See ChangeLog: Sat Nov 13 17:44:23 CET 1999 Werner Koch
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998, 1999 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 <gcrypt.h>
28 #include "util.h"
29 #include "packet.h"
30 #include "memory.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "options.h"
34 #include "main.h"
35 #include "trustdb.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 /* A map of the all characters valid used for word_match()
44  * Valid characters are in in this table converted to uppercase.
45  * because the upper 128 bytes have special meaning, we assume
46  * that they are all valid.
47  * Note: We must use numerical values here in case that this program
48  * will be converted to those little blue HAL9000s with their strange
49  * EBCDIC character set (user ids are UTF-8). */
50 static const byte word_match_chars[256] = {
51   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
52   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
56   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
57   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
58   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
59   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
60   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
61   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
62   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
63   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
64   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
65   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
66   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
67   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
68   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
69   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
70   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
71   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
72   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
73   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
74   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
75   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
76   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
77   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
78   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
79   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
80   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
81   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
82   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
83 };
84
85 typedef struct {
86     int mode;
87     u32 keyid[2];
88     byte fprint[20];
89     char *namebuf;
90     const char *name;
91 } getkey_item_t;
92
93 struct getkey_ctx_s {
94     /* make an array or a linked list from dome fields */
95     int primary;
96     KBNODE keyblock;
97     KBPOS kbpos;
98     int last_rc;
99     ulong count;
100     int not_allocated;
101     int nitems;
102     getkey_item_t items[1];
103 };
104
105
106
107
108
109 #if 0
110 static struct {
111     int any;
112     int okay_count;
113     int nokey_count;
114     int error_count;
115 } lkup_stats[21];
116 #endif
117
118
119
120 #if MAX_UNK_CACHE_ENTRIES
121   typedef struct keyid_list {
122       struct keyid_list *next;
123       u32 keyid[2];
124   } *keyid_list_t;
125   static keyid_list_t unknown_keyids;
126   static int unk_cache_entries;   /* number of entries in unknown keys cache */
127   static int unk_cache_disabled;
128 #endif
129
130 #if MAX_PK_CACHE_ENTRIES
131   typedef struct pk_cache_entry {
132       struct pk_cache_entry *next;
133       u32 keyid[2];
134       PKT_public_key *pk;
135   } *pk_cache_entry_t;
136   static pk_cache_entry_t pk_cache;
137   static int pk_cache_entries;   /* number of entries in pk cache */
138   static int pk_cache_disabled;
139 #endif
140
141 #if MAX_UID_CACHE_ENTRIES < 5
142     #error we really need the userid cache
143 #endif
144 typedef struct user_id_db {
145     struct user_id_db *next;
146     u32 keyid[2];
147     int len;
148     char name[1];
149 } *user_id_db_t;
150 static user_id_db_t user_id_db;
151 static int uid_cache_entries;   /* number of entries in uid cache */
152
153
154
155 static char* prepare_word_match( const byte *name );
156 static int lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_kb );
157 static int lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_kb );
158
159
160 #if 0
161 static void
162 print_stats()
163 {
164     int i;
165     for(i=0; i < DIM(lkup_stats); i++ ) {
166         if( lkup_stats[i].any )
167             fprintf(stderr,
168                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
169                     i,
170                     lkup_stats[i].okay_count,
171                     lkup_stats[i].nokey_count,
172                     lkup_stats[i].error_count );
173     }
174 }
175 #endif
176
177
178 static void
179 cache_public_key( PKT_public_key *pk )
180 {
181   #if MAX_PK_CACHE_ENTRIES
182     pk_cache_entry_t ce;
183     u32 keyid[2];
184
185     if( pk_cache_disabled )
186         return;
187
188     if( is_ELGAMAL(pk->pubkey_algo)
189         || pk->pubkey_algo == GCRY_PK_DSA
190         || is_RSA(pk->pubkey_algo) ) {
191         keyid_from_pk( pk, keyid );
192     }
193     else
194         return; /* don't know how to get the keyid */
195
196     for( ce = pk_cache; ce; ce = ce->next )
197         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
198             if( DBG_CACHE )
199                 log_debug("cache_public_key: already in cache\n");
200             return;
201         }
202
203     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
204         /* fixme: use another algorithm to free some cache slots */
205         pk_cache_disabled=1;
206         if( opt.verbose > 1 )
207             log_info(_("too many entries in pk cache - disabled\n"));
208         return;
209     }
210     pk_cache_entries++;
211     ce = m_alloc( sizeof *ce );
212     ce->next = pk_cache;
213     pk_cache = ce;
214     ce->pk = copy_public_key( NULL, pk );
215     ce->keyid[0] = keyid[0];
216     ce->keyid[1] = keyid[1];
217   #endif
218 }
219
220
221 /****************
222  * Store the association of keyid and userid
223  */
224 void
225 cache_user_id( PKT_user_id *uid, u32 *keyid )
226 {
227     user_id_db_t r;
228
229     for(r=user_id_db; r; r = r->next )
230         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
231             if( DBG_CACHE )
232                log_debug("cache_user_id: already in cache\n");
233             return;
234         }
235
236     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
237         /* fixme: use another algorithm to free some cache slots */
238         r = user_id_db;
239         user_id_db = r->next;
240         m_free(r);
241         uid_cache_entries--;
242     }
243     r = m_alloc( sizeof *r + uid->len-1 );
244     r->keyid[0] = keyid[0];
245     r->keyid[1] = keyid[1];
246     r->len = uid->len;
247     memcpy(r->name, uid->name, r->len);
248     r->next = user_id_db;
249     user_id_db = r;
250     uid_cache_entries++;
251 }
252
253
254 void
255 getkey_disable_caches()
256 {
257   #if MAX_UNK_CACHE_ENTRIES
258     {
259         keyid_list_t kl, kl2;
260         for( kl = unknown_keyids; kl; kl = kl2 ) {
261             kl2 = kl->next;
262             m_free(kl);
263         }
264         unknown_keyids = NULL;
265         unk_cache_disabled = 1;
266     }
267   #endif
268   #if MAX_PK_CACHE_ENTRIES
269     {
270         pk_cache_entry_t ce, ce2;
271
272         for( ce = pk_cache; ce; ce = ce2 ) {
273             ce2 = ce->next;
274             free_public_key( ce->pk );
275             m_free( ce );
276         }
277         pk_cache_disabled=1;
278         pk_cache_entries = 0;
279         pk_cache = NULL;
280     }
281   #endif
282     /* fixme: disable user id cache ? */
283 }
284
285
286 /****************
287  * Get a public key and store it into the allocated pk
288  * can be called with PK set to NULL to just read it into some
289  * internal structures.
290  */
291 int
292 get_pubkey( PKT_public_key *pk, u32 *keyid )
293 {
294     int internal = 0;
295     int rc = 0;
296
297   #if MAX_UNK_CACHE_ENTRIES
298     {   /* let's see whether we checked the keyid already */
299         keyid_list_t kl;
300         for( kl = unknown_keyids; kl; kl = kl->next )
301             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
302                 return G10ERR_NO_PUBKEY; /* already checked and not found */
303     }
304   #endif
305
306   #if MAX_PK_CACHE_ENTRIES
307     {   /* Try to get it from the cache */
308         pk_cache_entry_t ce;
309         for( ce = pk_cache; ce; ce = ce->next ) {
310             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
311                 if( pk )
312                     copy_public_key( pk, ce->pk );
313                 return 0;
314             }
315         }
316     }
317   #endif
318     /* more init stuff */
319     if( !pk ) {
320         pk = m_alloc_clear( sizeof *pk );
321         internal++;
322     }
323
324
325     /* do a lookup */
326     {   struct getkey_ctx_s ctx;
327         memset( &ctx, 0, sizeof ctx );
328         ctx.not_allocated = 1;
329         ctx.nitems = 1;
330         ctx.items[0].mode = 11;
331         ctx.items[0].keyid[0] = keyid[0];
332         ctx.items[0].keyid[1] = keyid[1];
333         rc = lookup_pk( &ctx, pk, NULL );
334         get_pubkey_end( &ctx );
335     }
336     if( !rc )
337         goto leave;
338
339   #if MAX_UNK_CACHE_ENTRIES
340     /* not found: store it for future reference */
341     if( unk_cache_disabled )
342         ;
343     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
344         unk_cache_disabled = 1;
345         if( opt.verbose > 1 )
346             log_info(_("too many entries in unk cache - disabled\n"));
347     }
348     else {
349         keyid_list_t kl;
350
351         kl = m_alloc( sizeof *kl );
352         kl->keyid[0] = keyid[0];
353         kl->keyid[1] = keyid[1];
354         kl->next = unknown_keyids;
355         unknown_keyids = kl;
356     }
357   #endif
358     rc = G10ERR_NO_PUBKEY;
359
360   leave:
361     if( !rc )
362         cache_public_key( pk );
363     if( internal )
364         free_public_key(pk);
365     return rc;
366 }
367
368
369 KBNODE
370 get_pubkeyblock( u32 *keyid )
371 {
372     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
373     struct getkey_ctx_s ctx;
374     int rc = 0;
375     KBNODE keyblock = NULL;
376
377     memset( &ctx, 0, sizeof ctx );
378     ctx.not_allocated = 1;
379     ctx.nitems = 1;
380     ctx.items[0].mode = 11;
381     ctx.items[0].keyid[0] = keyid[0];
382     ctx.items[0].keyid[1] = keyid[1];
383     rc = lookup_pk( &ctx, pk, &keyblock );
384     free_public_key(pk);
385     get_pubkey_end( &ctx );
386
387     return rc ? NULL : keyblock;
388 }
389
390
391
392
393 /****************
394  * Get a secret key and store it into sk
395  */
396 int
397 get_seckey( PKT_secret_key *sk, u32 *keyid )
398 {
399     int rc;
400     struct getkey_ctx_s ctx;
401
402     memset( &ctx, 0, sizeof ctx );
403     ctx.not_allocated = 1;
404     ctx.nitems = 1;
405     ctx.items[0].mode = 11;
406     ctx.items[0].keyid[0] = keyid[0];
407     ctx.items[0].keyid[1] = keyid[1];
408     rc = lookup_sk( &ctx, sk, NULL );
409     get_seckey_end( &ctx );
410     if( !rc ) {
411         /* check the secret key (this may prompt for a passprase to
412          * unlock the secret key
413          */
414         rc = check_secret_key( sk, 0 );
415     }
416
417     return rc;
418 }
419
420
421 /****************
422  * Get the primary secret key and store it into sk
423  * Note: This function does not unprotect the key!
424  */
425 int
426 get_primary_seckey( PKT_secret_key *sk, u32 *keyid )
427 {
428     struct getkey_ctx_s ctx;
429     int rc;
430
431     memset( &ctx, 0, sizeof ctx );
432     ctx.not_allocated = 1;
433     ctx.primary = 1;
434     ctx.nitems = 1;
435     ctx.items[0].mode = 11;
436     ctx.items[0].keyid[0] = keyid[0];
437     ctx.items[0].keyid[1] = keyid[1];
438     rc = lookup_sk( &ctx, sk, NULL );
439     get_seckey_end( &ctx );
440     return rc;
441 }
442
443
444
445 /****************
446  * Check whether the secret key is available
447  * Returns: 0 := key is available
448  *          G10ERR_NO_SECKEY := not availabe
449  */
450 int
451 seckey_available( u32 *keyid )
452 {
453     int rc;
454     struct getkey_ctx_s ctx;
455     PKT_secret_key *sk;
456
457     sk = m_alloc_clear( sizeof *sk );
458     memset( &ctx, 0, sizeof ctx );
459     ctx.not_allocated = 1;
460     ctx.nitems = 1;
461     ctx.items[0].mode = 11;
462     ctx.items[0].keyid[0] = keyid[0];
463     ctx.items[0].keyid[1] = keyid[1];
464     rc = lookup_sk( &ctx, sk, NULL );
465     get_seckey_end( &ctx );
466     free_secret_key( sk );
467     return rc;
468 }
469
470
471
472 static int
473 hextobyte( const byte *s )
474 {
475     int c;
476
477     if( *s >= '0' && *s <= '9' )
478         c = 16 * (*s - '0');
479     else if( *s >= 'A' && *s <= 'F' )
480         c = 16 * (10 + *s - 'A');
481     else if( *s >= 'a' && *s <= 'f' )
482         c = 16 * (10 + *s - 'a');
483     else
484         return -1;
485     s++;
486     if( *s >= '0' && *s <= '9' )
487         c += *s - '0';
488     else if( *s >= 'A' && *s <= 'F' )
489         c += 10 + *s - 'A';
490     else if( *s >= 'a' && *s <= 'f' )
491         c += 10 + *s - 'a';
492     else
493         return -1;
494     return c;
495 }
496
497
498
499 /****************
500  * Return the type of the user id:
501  *
502  *  0 = Invalid user ID
503  *  1 = exact match
504  *  2 = match a substring
505  *  3 = match an email address
506  *  4 = match a substring of an email address
507  *  5 = match an email address, but compare from end
508  *  6 = word match mode
509  * 10 = it is a short KEYID (don't care about keyid[0])
510  * 11 = it is a long  KEYID
511  * 12 = it is a trustdb index (keyid is looked up)
512  * 16 = it is a 16 byte fingerprint
513  * 20 = it is a 20 byte fingerprint
514  *
515  * if fprint is not NULL, it should be an array of at least 20 bytes.
516  *
517  * Rules used:
518  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
519  *   must be in the range 0..9), this is considered a keyid; depending
520  *   on the length a short or complete one.
521  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
522  *   must be in the range 0..9), this is considered a fingerprint.
523  * - If the username starts with a left angle, we assume it is a complete
524  *   email address and look only at this part.
525  * - If the username starts with a '.', we assume it is the ending
526  *   part of an email address
527  * - If the username starts with an '@', we assume it is a part of an
528  *   email address
529  * - If the userid start with an '=' an exact compare is done.
530  * - If the userid starts with a '*' a case insensitive substring search is
531  *   done (This is the default).
532  * - If the userid starts with a '+' we will compare individual words
533  *   and a match requires that all the words are in the userid.
534  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
535  *   (note that you can't search for these characters). Compare
536  *   is not case sensitive.
537  */
538
539 int
540 classify_user_id( const char *name, u32 *keyid, byte *fprint,
541                   const char **retstr, size_t *retlen )
542 {
543     const char *        s;
544     int                 mode = 0;
545     int                 hexprefix = 0;
546     int                 hexlength;
547
548     /* skip leading spaces.   FIXME: what is with leading spaces? */
549     for(s = name; *s && isspace(*s); s++ )
550         ;
551
552     switch (*s) {
553         case 0:    /* empty string is an error */
554             return 0;
555
556         case '.':  /* an email address, compare from end */
557             mode = 5;
558             s++;
559             break;
560
561         case '<':  /* an email address */
562             mode = 3;
563             break;
564
565         case '@':  /* part of an email address */
566             mode = 4;
567             s++;
568             break;
569
570         case '=':  /* exact compare */
571             mode = 1;
572             s++;
573             break;
574
575         case '*':  /* case insensitive substring search */
576             mode = 2;
577             s++;
578             break;
579
580         case '+':  /* compare individual words */
581             mode = 6;
582             s++;
583             break;
584
585         case '#':  /* local user id */
586             mode = 12;
587             s++;
588             if (keyid) {
589                 if (keyid_from_lid(strtoul(s, NULL, 10), keyid))
590                     keyid[0] = keyid[1] = 0;
591             }
592             break;
593
594         default:
595             if (s[0] == '0' && s[1] == 'x') {
596                 hexprefix = 1;
597                 s += 2;
598             }
599
600             hexlength = strspn(s, "0123456789abcdefABCDEF");
601
602             /* check if a hexadecimal number is terminated by EOS or blank */
603             if (hexlength && s[hexlength] && !isspace(s[hexlength])) {
604                 if (hexprefix)      /* a "0x" prefix without correct */
605                     return 0;       /* termination is an error */
606                 else                /* The first chars looked like */
607                     hexlength = 0;  /* a hex number, but really were not. */
608             }
609
610             if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0')){
611                 /* short keyid */
612                 if (hexlength == 9)
613                     s++;
614                 if (keyid) {
615                     keyid[0] = 0;
616                     keyid[1] = strtoul( s, NULL, 16 );
617                 }
618                 mode = 10;
619             }
620             else if (hexlength == 16 || (!hexprefix && hexlength == 17
621                                                           && *s == '0')) {
622                 /* complete keyid */
623                 char buf[9];
624                 if (hexlength == 17)
625                     s++;
626                 mem2str(buf, s, 9 );
627                 keyid[0] = strtoul( buf, NULL, 16 );
628                 keyid[1] = strtoul( s+8, NULL, 16 );
629                 mode = 11;
630             }
631             else if (hexlength == 32 || (!hexprefix && hexlength == 33
632                                                             && *s == '0')) {
633                 /* md5 fingerprint */
634                 int i;
635                 if (hexlength == 33)
636                     s++;
637                 if (fprint) {
638                     memset(fprint+16, 4, 0);
639                     for (i=0; i < 16; i++, s+=2) {
640                         int c = hextobyte(s);
641                         if (c == -1)
642                             return 0;
643                         fprint[i] = c;
644                     }
645                 }
646                 mode = 16;
647             }
648             else if (hexlength == 40 || (!hexprefix && hexlength == 41
649                                                               && *s == '0')) {
650                 /* sha1/rmd160 fingerprint */
651                 int i;
652                 if (hexlength == 41)
653                     s++;
654                 if (fprint) {
655                     for (i=0; i < 20; i++, s+=2) {
656                         int c = hextobyte(s);
657                         if (c == -1)
658                             return 0;
659                         fprint[i] = c;
660                     }
661                 }
662                 mode = 20;
663             }
664             else {
665                 if (hexprefix)  /* This was a hex number with a prefix */
666                     return 0;   /* and a wrong length */
667
668                 mode = 2;   /* Default is case insensitive substring search */
669             }
670     }
671
672     if( retstr )
673         *retstr = s;
674     if( retlen )
675         *retlen = strlen(s);
676
677     return mode;
678 }
679
680
681
682 /****************
683  * Try to get the pubkey by the userid. This function looks for the
684  * first pubkey certificate which has the given name in a user_id.
685  * if pk/sk has the pubkey algo set, the function will only return
686  * a pubkey with that algo.
687  * The caller must provide provide storage for either the pk or the sk.
688  * If ret_kb is not NULL the funtion will return the keyblock there.
689  */
690
691 static int
692 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
693             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
694 {
695     int rc = 0;
696     int n;
697     STRLIST r;
698     GETKEY_CTX ctx;
699
700     assert( !pk ^ !sk );
701
702     /* build the search context */
703     /* Performance hint: Use a static buffer if there is only one name */
704     /*                   and we don't have mode 6 */
705     for(n=0, r=namelist; r; r = r->next )
706         n++;
707     ctx = m_alloc_clear( sizeof *ctx + (n-1)*sizeof ctx->items );
708     ctx->nitems = n;
709
710     for(n=0, r=namelist; r; r = r->next, n++ ) {
711         ctx->items[n].mode = classify_user_id( r->d,
712                                               ctx->items[n].keyid,
713                                               ctx->items[n].fprint,
714                                               &ctx->items[n].name,
715                                               NULL );
716         if( !ctx->items[n].mode ) {
717             m_free( ctx );
718             return G10ERR_INV_USER_ID;
719         }
720         if( ctx->items[n].mode == 6 ) {
721             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
722             ctx->items[n].name = ctx->items[n].namebuf;
723         }
724     }
725
726     /* and call the lookup function */
727     ctx->primary = 1; /* we want to look for the primary key only */
728     if( sk )
729         rc = lookup_sk( ctx, sk, ret_kb );
730     else
731         rc = lookup_pk( ctx, pk, ret_kb );
732
733     if( retctx ) /* caller wants the context */
734         *retctx = ctx;
735     else {
736         /* Hmmm, why not get_pubkey-end here?? */
737         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
738         for(n=0; n < ctx->nitems; n++ )
739             m_free( ctx->items[n].namebuf );
740         m_free( ctx );
741     }
742
743     return rc;
744 }
745
746 int
747 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
748                    const char *name, KBNODE *ret_keyblock )
749 {
750     int rc;
751     STRLIST namelist = NULL;
752
753     add_to_strlist( &namelist, name );
754
755     if( !pk ) {
756         /* Performance Hint: key_byname should not need a pk here */
757         pk = m_alloc_clear( sizeof *pk );
758         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
759         free_public_key( pk );
760     }
761     else
762         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
763
764     free_strlist( namelist );
765     return rc;
766 }
767
768 int
769 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
770                     STRLIST names, KBNODE *ret_keyblock )
771 {
772     int rc;
773
774     if( !pk ) {
775         /* Performance Hint: key_byname should not need a pk here */
776         pk = m_alloc_clear( sizeof *pk );
777         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
778         free_public_key( pk );
779     }
780     else
781         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
782
783     return rc;
784 }
785
786 int
787 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
788 {
789     int rc;
790
791     if( !pk ) {
792         /* Performance Hint: lookup_read should not need a pk in this case */
793         pk = m_alloc_clear( sizeof *pk );
794         rc = lookup_pk( ctx, pk, ret_keyblock );
795         free_public_key( pk );
796     }
797     else
798         rc = lookup_pk( ctx, pk, ret_keyblock );
799     return rc;
800 }
801
802 void
803 get_pubkey_end( GETKEY_CTX ctx )
804 {
805     if( ctx ) {
806         int n;
807
808         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
809         for(n=0; n < ctx->nitems; n++ )
810             m_free( ctx->items[n].namebuf );
811         if( !ctx->not_allocated )
812             m_free( ctx );
813     }
814 }
815
816 /****************
817  * Search for a key with the given fingerprint.
818  */
819 int
820 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
821 {
822     int rc;
823
824     if( fprint_len == 20 || fprint_len == 16 ) {
825         struct getkey_ctx_s ctx;
826         memset( &ctx, 0, sizeof ctx );
827         ctx.not_allocated = 1;
828         ctx.nitems = 1;
829         ctx.items[0].mode = fprint_len;
830         memcpy( ctx.items[0].fprint, fprint, fprint_len );
831         rc = lookup_pk( &ctx, pk, NULL );
832         get_pubkey_end( &ctx );
833     }
834     else
835         rc = G10ERR_GENERAL; /* Oops */
836     return rc;
837 }
838
839 /****************
840  * Search for a key with the given fingerprint and return the
841  * complete keyblock which may have more than only this key.
842  */
843 int
844 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
845                                                 size_t fprint_len )
846 {
847     int rc;
848     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
849
850     if( fprint_len == 20 || fprint_len == 16 ) {
851         struct getkey_ctx_s ctx;
852         memset( &ctx, 0, sizeof ctx );
853         ctx.not_allocated = 1;
854         ctx.nitems = 1;
855         ctx.items[0].mode = fprint_len;
856         memcpy( ctx.items[0].fprint, fprint, fprint_len );
857         rc = lookup_pk( &ctx, pk, ret_keyblock );
858         get_pubkey_end( &ctx );
859     }
860     else
861         rc = G10ERR_GENERAL; /* Oops */
862
863     free_public_key( pk );
864     return rc;
865 }
866
867
868
869 /****************
870  * Search for a key with the given lid and return the complete keyblock
871  */
872 int
873 get_keyblock_bylid( KBNODE *ret_keyblock, ulong lid )
874 {
875     int rc;
876     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
877     struct getkey_ctx_s ctx;
878     u32 kid[2];
879
880     if( keyid_from_lid( lid, kid ) )
881         kid[0] = kid[1] = 0;
882     memset( &ctx, 0, sizeof ctx );
883     ctx.not_allocated = 1;
884     ctx.nitems = 1;
885     ctx.items[0].mode = 12;
886     ctx.items[0].keyid[0] = kid[0];
887     ctx.items[0].keyid[1] = kid[1];
888     rc = lookup_pk( &ctx, pk, ret_keyblock );
889     get_pubkey_end( &ctx );
890
891     free_public_key( pk );
892     return rc;
893 }
894
895
896
897
898
899 /****************
900  * Get a secret key by name and store it into sk
901  * If NAME is NULL use the default key
902  */
903 int
904 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
905 {
906     STRLIST namelist = NULL;
907     int rc;
908
909     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
910         add_to_strlist( &namelist, opt.def_secret_key );
911         rc = key_byname( NULL, namelist, NULL, sk, NULL );
912     }
913     else if( !name ) { /* use the first one as default key */
914         struct getkey_ctx_s ctx;
915
916         memset( &ctx, 0, sizeof ctx );
917         ctx.not_allocated = 1;
918         ctx.primary = 1;
919         ctx.nitems = 1;
920         ctx.items[0].mode = 15;
921         rc = lookup_sk( &ctx, sk, NULL );
922         get_seckey_end( &ctx );
923     }
924     else {
925         add_to_strlist( &namelist, name );
926         rc = key_byname( NULL, namelist, NULL, sk, NULL );
927     }
928
929     free_strlist( namelist );
930
931     if( !rc && unprotect )
932         rc = check_secret_key( sk, 0 );
933
934     return rc;
935 }
936
937 int
938 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
939                     STRLIST names, KBNODE *ret_keyblock )
940 {
941     int rc;
942
943     if( !sk ) {
944         /* Performance Hint: key_byname should not need a sk here */
945         sk = m_alloc_secure_clear( sizeof *sk );
946         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
947         free_secret_key( sk );
948     }
949     else
950         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
951
952     return rc;
953 }
954
955
956 int
957 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
958 {
959     int rc;
960
961     if( !sk ) {
962         /* Performance Hint: lookup_read should not need a pk in this case */
963         sk = m_alloc_secure_clear( sizeof *sk );
964         rc = lookup_sk( ctx, sk, ret_keyblock );
965         free_secret_key( sk );
966     }
967     else
968         rc = lookup_sk( ctx, sk, ret_keyblock );
969     return rc;
970 }
971
972 void
973 get_seckey_end( GETKEY_CTX ctx )
974 {
975     if( ctx ) {
976         int n;
977
978         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
979         for(n=0; n < ctx->nitems; n++ )
980             m_free( ctx->items[n].namebuf );
981         if( !ctx->not_allocated )
982             m_free( ctx );
983     }
984 }
985
986
987
988 /****************
989  * Do a word match (original user id starts with a '+').
990  * The pattern is already tokenized to a more suitable format:
991  * There are only the real words in it delimited by one space
992  * and all converted to uppercase.
993  *
994  * Returns: 0 if all words match.
995  *
996  * Note: This algorithm is a straightforward one and not very
997  *       fast.  It works for UTF-8 strings.  The uidlen should
998  *       be removed but due to the fact that old versions of
999  *       pgp don't use UTF-8 we still use the length; this should
1000  *       be fixed in parse-packet (and replace \0 by some special
1001  *       UTF-8 encoding)
1002  */
1003 static int
1004 word_match( const byte *uid, size_t uidlen, const byte *pattern )
1005 {
1006     size_t wlen, n;
1007     const byte *p;
1008     const byte *s;
1009
1010     for( s=pattern; *s; ) {
1011         do {
1012             /* skip leading delimiters */
1013             while( uidlen && !word_match_chars[*uid] )
1014                 uid++, uidlen--;
1015             /* get length of the word */
1016             n = uidlen; p = uid;
1017             while( n && word_match_chars[*p] )
1018                 p++, n--;
1019             wlen = p - uid;
1020             /* and compare against the current word from pattern */
1021             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
1022                 if( word_match_chars[*p] != s[n] )
1023                     break;
1024             }
1025             if( n == wlen && (s[n] == ' ' || !s[n]) )
1026                 break; /* found */
1027             uid += wlen;
1028             uidlen -= wlen;
1029         } while( uidlen );
1030         if( !uidlen )
1031             return -1; /* not found */
1032
1033         /* advance to next word in pattern */
1034         for(; *s != ' ' && *s ; s++ )
1035             ;
1036         if( *s )
1037             s++ ;
1038     }
1039     return 0; /* found */
1040 }
1041
1042 /****************
1043  * prepare word word_match; that is parse the name and
1044  * build the pattern.
1045  * caller has to free the returned pattern
1046  */
1047 static char*
1048 prepare_word_match( const byte *name )
1049 {
1050     byte *pattern, *p;
1051     int c;
1052
1053     /* the original length is always enough for the pattern */
1054     p = pattern = m_alloc(strlen(name)+1);
1055     do {
1056         /* skip leading delimiters */
1057         while( *name && !word_match_chars[*name] )
1058             name++;
1059         /* copy as long as we don't have a delimiter and convert
1060          * to uppercase.
1061          * fixme: how can we handle utf8 uppercasing */
1062         for( ; *name &&  (c=word_match_chars[*name]); name++ )
1063             *p++ = c;
1064         *p++ = ' '; /* append pattern delimiter */
1065     } while( *name );
1066     p[-1] = 0; /* replace last pattern delimiter by EOS */
1067
1068     return pattern;
1069 }
1070
1071
1072
1073
1074
1075 static int
1076 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
1077 {
1078     int i;
1079     const char *s, *se;
1080
1081     if( mode == 1 ) {  /* exact match */
1082         for(i=0; name[i] && uidlen; i++, uidlen-- )
1083             if( uid[i] != name[i] )
1084                 break;
1085         if( !uidlen && !name[i] )
1086             return 0; /* found */
1087     }
1088     else if( mode == 2 ) { /* case insensitive substring */
1089         if( memistr( uid, uidlen, name ) )
1090             return 0;
1091     }
1092     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1093         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1094             ;
1095         if( i < uidlen )  {
1096             /* skip opening delim and one char and look for the closing one*/
1097             s++; i++;
1098             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1099                 ;
1100             if( i < uidlen ) {
1101                 i = se - s;
1102                 if( mode == 3 ) { /* exact email address */
1103                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1104                         return 0;
1105                 }
1106                 else if( mode == 4 ) {  /* email substring */
1107                     if( memistr( s, i, name ) )
1108                         return 0;
1109                 }
1110                 else { /* email from end */
1111                     /* nyi */
1112                 }
1113             }
1114         }
1115     }
1116     else if( mode == 6 )
1117         return word_match( uid, uidlen, name );
1118     else
1119         BUG();
1120
1121     return -1; /* not found */
1122 }
1123
1124
1125
1126 /****************
1127  * Assume that knode points to a public key packet  and keyblock is
1128  * the entire keyblock.  This function adds all relevant information from
1129  * a selfsignature to the public key.
1130  */
1131
1132 static void
1133 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
1134                           PKT_public_key *orig_pk )
1135 {
1136     PKT_public_key *pk = knode->pkt->pkt.public_key;
1137     PKT_signature *sig;
1138     KBNODE k;
1139     u32 kid[2];
1140     u32 sigdate = 0;
1141
1142     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
1143             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1144
1145     if( pk->version < 4 )
1146         return; /* this is only needed for version >=4 packets */
1147
1148
1149     /* find the selfsignature */
1150     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1151         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1152         if( !k )
1153            BUG(); /* keyblock without primary key!!! */
1154         keyid_from_pk( knode->pkt->pkt.public_key, kid );
1155     }
1156     else
1157         keyid_from_pk( pk, kid );
1158
1159     for(k=knode->next; k; k = k->next ) {
1160         if( k->pkt->pkttype == PKT_SIGNATURE
1161             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1162             && sig->sig_class <= 0x30
1163             && sig->keyid[0] == kid[0]
1164             && sig->keyid[1] == kid[1]
1165             && sig->version > 3 ) {
1166             /* okay this is a self-signature which can be used.
1167              * We use the latest self-signature.
1168              * FIXME: We should only use this if the signature is valid
1169              *        but this is time consuming - we must provide another
1170              *        way to handle this
1171              */
1172             const byte *p;
1173             u32 ed;
1174
1175             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1176             ed = p? pk->timestamp + buffer_to_u32(p):0;
1177             /* use the latest self signature */
1178             if( sig->timestamp > sigdate ) {
1179                 pk->expiredate = ed;
1180                 orig_pk->expiredate = ed;
1181                 sigdate = sig->timestamp;
1182             }
1183             /* fixme: add usage etc. to pk */
1184         }
1185         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1186             break; /* stop here */
1187     }
1188 }
1189
1190
1191 /****************
1192  * merge all selfsignatures with the keys.
1193  */
1194 void
1195 merge_keys_and_selfsig( KBNODE keyblock )
1196 {
1197     PKT_public_key *pk = NULL;
1198     PKT_secret_key *sk = NULL;
1199     PKT_signature *sig;
1200     KBNODE k;
1201     u32 kid[2] = { 0, 0 };
1202     u32 sigdate = 0;
1203
1204     for(k=keyblock; k; k = k->next ) {
1205         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1206             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1207             pk = k->pkt->pkt.public_key; sk = NULL;
1208             if( pk->version < 4 )
1209                 pk = NULL; /* not needed for old keys */
1210             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1211                 keyid_from_pk( pk, kid );
1212             sigdate = 0;
1213         }
1214         else if( k->pkt->pkttype == PKT_SECRET_KEY
1215             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1216             pk = NULL; sk = k->pkt->pkt.secret_key;
1217             if( sk->version < 4 )
1218                 sk = NULL;
1219             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1220                 keyid_from_sk( sk, kid );
1221             sigdate = 0;
1222         }
1223         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1224                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1225                  && sig->sig_class <= 0x30 && sig->version > 3
1226                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1227             /* okay this is a self-signature which can be used.
1228              * FIXME: We should only use this if the signature is valid
1229              *        but this is time consuming - we must provide another
1230              *        way to handle this
1231              */
1232             const byte *p;
1233             u32 ed;
1234
1235             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1236             if( pk ) {
1237                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1238                 if( sig->timestamp > sigdate ) {
1239                     pk->expiredate = ed;
1240                     sigdate = sig->timestamp;
1241                 }
1242             }
1243             else {
1244                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1245                 if( sig->timestamp > sigdate ) {
1246                     sk->expiredate = ed;
1247                     sigdate = sig->timestamp;
1248                 }
1249             }
1250         }
1251     }
1252 }
1253
1254
1255 static KBNODE
1256 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
1257               int mode, byte *namehash, int *use_namehash )
1258 {
1259     KBNODE k, kk;
1260
1261     for(k=keyblock; k; k = k->next ) {
1262         if( k->pkt->pkttype == PKT_USER_ID
1263             && !compare_name( k->pkt->pkt.user_id->name,
1264                               k->pkt->pkt.user_id->len, name, mode)) {
1265             /* we found a matching name, look for the key */
1266             for(kk=keyblock; kk; kk = kk->next ) {
1267                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
1268                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1269                     && ( !pk->pubkey_algo
1270                          || pk->pubkey_algo
1271                             == kk->pkt->pkt.public_key->pubkey_algo)
1272                     && ( !pk->pubkey_usage
1273                          || !openpgp_pk_test_algo(
1274                                kk->pkt->pkt.public_key->pubkey_algo,
1275                                                    pk->pubkey_usage ))
1276                   )
1277                     break;
1278             }
1279             if( kk ) {
1280                 u32 aki[2];
1281                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
1282                 cache_user_id( k->pkt->pkt.user_id, aki );
1283                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1284                                     k->pkt->pkt.user_id->name,
1285                                     k->pkt->pkt.user_id->len );
1286                 *use_namehash = 1;
1287                 return kk;
1288             }
1289             else if( is_RSA(pk->pubkey_algo) )
1290                 log_error(_("RSA key cannot be used in this version\n"));
1291             else
1292                 log_error(_("No key for user ID\n"));
1293         }
1294     }
1295     return NULL;
1296 }
1297
1298 static KBNODE
1299 find_by_name_sk( KBNODE keyblock, PKT_secret_key *sk, const char *name,
1300                  int mode )
1301 {
1302     KBNODE k, kk;
1303
1304     for(k=keyblock; k; k = k->next ) {
1305         if( k->pkt->pkttype == PKT_USER_ID
1306             && !compare_name( k->pkt->pkt.user_id->name,
1307                               k->pkt->pkt.user_id->len, name, mode)) {
1308             /* we found a matching name, look for the key */
1309             for(kk=keyblock; kk; kk = kk->next ) {
1310                 if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1311                       || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1312                     && ( !sk->pubkey_algo
1313                          || sk->pubkey_algo
1314                             == kk->pkt->pkt.secret_key->pubkey_algo)
1315                     && ( !sk->pubkey_usage
1316                          || !openpgp_pk_test_algo(
1317                                kk->pkt->pkt.secret_key->pubkey_algo,
1318                                                    sk->pubkey_usage ))
1319                   )
1320                     break;
1321             }
1322             if( kk ) {
1323                 u32 aki[2];
1324                 keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1325                 cache_user_id( k->pkt->pkt.user_id, aki );
1326                 return kk;
1327             }
1328             else if( is_RSA(sk->pubkey_algo) )
1329                 log_error(_("RSA key cannot be used in this version\n"));
1330             else
1331                 log_error(_("No key for user ID\n"));
1332         }
1333     }
1334     return NULL;
1335 }
1336
1337
1338 static KBNODE
1339 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
1340 {
1341     KBNODE k;
1342
1343     if( DBG_CACHE )
1344         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
1345                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
1346
1347     for(k=keyblock; k; k = k->next ) {
1348         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1349             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1350             u32 aki[2];
1351             keyid_from_pk( k->pkt->pkt.public_key, aki );
1352             if( DBG_CACHE )
1353                 log_debug("         aki=%08lx%08lx algo=%d\n",
1354                                 (ulong)aki[0], (ulong)aki[1],
1355                                  k->pkt->pkt.public_key->pubkey_algo    );
1356
1357             if( aki[1] == keyid[1]
1358                 && ( mode == 10 || aki[0] == keyid[0] )
1359                 && ( !pk->pubkey_algo
1360                      || pk->pubkey_algo
1361                         == k->pkt->pkt.public_key->pubkey_algo) ){
1362                 KBNODE kk;
1363                 /* cache the userid */
1364                 for(kk=keyblock; kk; kk = kk->next )
1365                     if( kk->pkt->pkttype == PKT_USER_ID )
1366                         break;
1367                 if( kk )
1368                     cache_user_id( kk->pkt->pkt.user_id, aki );
1369                 else
1370                     log_error(_("No user ID for key\n"));
1371                 return k; /* found */
1372             }
1373         }
1374     }
1375     return NULL;
1376 }
1377
1378 static KBNODE
1379 find_by_keyid_sk( KBNODE keyblock, PKT_secret_key *sk, u32 *keyid, int mode )
1380 {
1381     KBNODE k;
1382
1383     if( DBG_CACHE )
1384         log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1385                    (ulong)keyid[0], (ulong)keyid[1], sk->pubkey_algo, mode );
1386
1387     for(k=keyblock; k; k = k->next ) {
1388         if(    k->pkt->pkttype == PKT_SECRET_KEY
1389             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1390             u32 aki[2];
1391             keyid_from_sk( k->pkt->pkt.secret_key, aki );
1392             if( DBG_CACHE )
1393                 log_debug("         aki=%08lx%08lx algo=%d\n",
1394                                 (ulong)aki[0], (ulong)aki[1],
1395                                  k->pkt->pkt.secret_key->pubkey_algo    );
1396
1397             if( aki[1] == keyid[1]
1398                 && ( mode == 10 || aki[0] == keyid[0] )
1399                 && ( !sk->pubkey_algo
1400                      || sk->pubkey_algo
1401                         == k->pkt->pkt.secret_key->pubkey_algo) ){
1402                 KBNODE kk;
1403                 /* cache the userid */
1404                 for(kk=keyblock; kk; kk = kk->next )
1405                     if( kk->pkt->pkttype == PKT_USER_ID )
1406                         break;
1407                 if( kk )
1408                     cache_user_id( kk->pkt->pkt.user_id, aki );
1409                 else
1410                     log_error(_("No user ID for key\n"));
1411                 return k; /* found */
1412             }
1413         }
1414     }
1415     return NULL;
1416 }
1417
1418
1419 static KBNODE
1420 find_first( KBNODE keyblock, PKT_public_key *pk )
1421 {
1422     KBNODE k;
1423
1424     for(k=keyblock; k; k = k->next ) {
1425         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1426             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1427         {
1428             if( !pk->pubkey_algo
1429                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
1430                 return k;
1431         }
1432     }
1433     return NULL;
1434 }
1435
1436 static KBNODE
1437 find_first_sk( KBNODE keyblock, PKT_secret_key *sk )
1438 {
1439     KBNODE k;
1440
1441     for(k=keyblock; k; k = k->next ) {
1442         if(    k->pkt->pkttype == PKT_SECRET_KEY
1443             || k->pkt->pkttype == PKT_SECRET_SUBKEY )
1444         {
1445             if( !sk->pubkey_algo
1446                 || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo )
1447                 return k;
1448         }
1449     }
1450     return NULL;
1451 }
1452
1453
1454 static KBNODE
1455 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
1456 {
1457     KBNODE k;
1458
1459     for(k=keyblock; k; k = k->next ) {
1460         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1461             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1462             byte afp[MAX_FINGERPRINT_LEN];
1463             size_t an;
1464
1465             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1466
1467             if( DBG_CACHE ) {
1468                 u32 aki[2];
1469                 keyid_from_pk( k->pkt->pkt.public_key, aki );
1470                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1471                                 (ulong)aki[0], (ulong)aki[1],
1472                         k->pkt->pkt.public_key->pubkey_algo, mode,
1473                                                             (unsigned)an );
1474             }
1475
1476             if( an == mode
1477                 && !memcmp( afp, name, an)
1478                 && ( !pk->pubkey_algo
1479                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
1480                 return k;
1481         }
1482     }
1483     return NULL;
1484 }
1485
1486 static KBNODE
1487 find_by_fpr_sk( KBNODE keyblock, PKT_secret_key *sk,
1488                                  const char *name, int mode )
1489 {
1490     KBNODE k;
1491
1492     for(k=keyblock; k; k = k->next ) {
1493         if(    k->pkt->pkttype == PKT_SECRET_KEY
1494             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1495             byte afp[MAX_FINGERPRINT_LEN];
1496             size_t an;
1497
1498             fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1499
1500             if( DBG_CACHE ) {
1501                 u32 aki[2];
1502                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
1503                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1504                                 (ulong)aki[0], (ulong)aki[1],
1505                         k->pkt->pkt.secret_key->pubkey_algo, mode,
1506                                                         (unsigned)an );
1507             }
1508
1509             if( an == mode
1510                 && !memcmp( afp, name, an)
1511                 && ( !sk->pubkey_algo
1512                      || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo) )
1513                 return k;
1514         }
1515     }
1516     return NULL;
1517 }
1518
1519
1520 static void
1521 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
1522                                                int use_namehash, int primary )
1523 {
1524     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
1525             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1526     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1527     if( primary && !pk->pubkey_usage ) {
1528         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1529                                       use_namehash? namehash:NULL);
1530         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1531     }
1532     else {
1533         if( primary && pk->pubkey_usage
1534             && openpgp_pk_test_algo( k->pkt->pkt.public_key->pubkey_algo,
1535                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1536             /* if the usage is not correct, try to use a subkey */
1537             KBNODE save_k = k;
1538
1539             k = NULL;
1540             /* kludge for pgp 5: which doesn't accept type 20:
1541              * try to use a type 16 subkey instead */
1542             if( pk->pubkey_usage == GCRY_PK_USAGE_ENCR ) {
1543                 for( k = save_k; k; k = k->next ) {
1544                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1545                         && k->pkt->pkt.public_key->pubkey_algo
1546                             == GCRY_PK_ELG_E
1547                         && !openpgp_pk_test_algo(
1548                                 k->pkt->pkt.public_key->pubkey_algo,
1549                                                  pk->pubkey_usage ) )
1550                         break;
1551                 }
1552             }
1553
1554             if( !k ) {
1555                 for(k = save_k ; k; k = k->next ) {
1556                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1557                         && !openpgp_pk_test_algo(
1558                                 k->pkt->pkt.public_key->pubkey_algo,
1559                                                  pk->pubkey_usage ) )
1560                         break;
1561                 }
1562             }
1563             if( !k )
1564                 k = save_k;
1565             else
1566                 log_info(_("using secondary key %08lX "
1567                            "instead of primary key %08lX\n"),
1568                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1569                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1570                         );
1571         }
1572
1573         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1574                                       use_namehash? namehash:NULL);
1575         merge_one_pk_and_selfsig( keyblock, k, pk );
1576     }
1577 }
1578
1579 static void
1580 finish_lookup_sk( KBNODE keyblock, PKT_secret_key *sk, KBNODE k, int primary )
1581 {
1582     assert(    k->pkt->pkttype == PKT_SECRET_KEY
1583             || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1584     assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1585     if( primary && !sk->pubkey_usage ) {
1586         copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1587     }
1588     else {
1589         if( primary && sk->pubkey_usage
1590             && openpgp_pk_test_algo( k->pkt->pkt.secret_key->pubkey_algo,
1591                        sk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1592             /* if the usage is not correct, try to use a subkey */
1593             KBNODE save_k = k;
1594
1595             k = NULL;
1596             /* kludge for pgp 5: which doesn't accept type 20:
1597              * try to use a type 16 subkey instead */
1598             if( sk->pubkey_usage == GCRY_PK_USAGE_ENCR ) {
1599                 for( k = save_k; k; k = k->next ) {
1600                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1601                         && k->pkt->pkt.secret_key->pubkey_algo
1602                             == GCRY_PK_ELG_E
1603                         && !openpgp_pk_test_algo(
1604                                 k->pkt->pkt.secret_key->pubkey_algo,
1605                                                  sk->pubkey_usage ) )
1606                         break;
1607                 }
1608             }
1609
1610             if( !k ) {
1611                 for(k = save_k ; k; k = k->next ) {
1612                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1613                         && !openpgp_pk_test_algo(
1614                                 k->pkt->pkt.secret_key->pubkey_algo,
1615                                                  sk->pubkey_usage ) )
1616                         break;
1617                 }
1618             }
1619             if( !k )
1620                 k = save_k;
1621             else
1622                 log_info(_("using secondary key %08lX "
1623                            "instead of primary key %08lX\n"),
1624                       (ulong)keyid_from_sk( k->pkt->pkt.secret_key, NULL),
1625                       (ulong)keyid_from_sk( save_k->pkt->pkt.secret_key, NULL)
1626                         );
1627         }
1628
1629         copy_secret_key( sk, k->pkt->pkt.secret_key );
1630     }
1631 }
1632
1633
1634 static int
1635 lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1636 {
1637     int rc;
1638     KBNODE k;
1639     int oldmode = set_packet_list_mode(0);
1640     byte namehash[20];
1641     int use_namehash=0;
1642
1643     if( !ctx->count ) /* first time */
1644         rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1645     else
1646         rc = 0;
1647     if( !rc ) {
1648         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1649             int n;
1650             getkey_item_t *item;
1651             /* fixme: we don't enum the complete keyblock, but
1652              * use the first match and then continue with the next keyblock
1653              */
1654             /* loop over all the user ids we want to look for */
1655             item = ctx->items;
1656             for(n=0; n < ctx->nitems; n++, item++ ) {
1657                 if( item->mode < 10 )
1658                     k = find_by_name( ctx->keyblock, pk,
1659                                       item->name, item->mode,
1660                                       namehash, &use_namehash );
1661                 else if( item->mode >= 10 && item->mode <= 12 )
1662                     k = find_by_keyid( ctx->keyblock, pk,
1663                                        item->keyid, item->mode );
1664                 else if( item->mode == 15 )
1665                     k = find_first( ctx->keyblock, pk );
1666                 else if( item->mode == 16 || item->mode == 20 )
1667                     k = find_by_fpr( ctx->keyblock, pk,
1668                                      item->fprint, item->mode );
1669                 else
1670                     BUG();
1671                 if( k ) {
1672                     finish_lookup( ctx->keyblock, pk, k, namehash,
1673                                                  use_namehash, ctx->primary );
1674                     goto found;
1675                 }
1676             }
1677             release_kbnode( ctx->keyblock );
1678             ctx->keyblock = NULL;
1679         }
1680       found: ;
1681     }
1682     if( rc && rc != -1 )
1683         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1684
1685     if( !rc ) {
1686         if( ret_keyblock ) {
1687             *ret_keyblock = ctx->keyblock;
1688             ctx->keyblock = NULL;
1689         }
1690     }
1691     else if( rc == -1 )
1692         rc = G10ERR_NO_PUBKEY;
1693
1694     release_kbnode( ctx->keyblock );
1695     ctx->keyblock = NULL;
1696     set_packet_list_mode(oldmode);
1697   #if 0
1698     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1699         static int initialized;
1700
1701         if( !initialized ) {
1702             initialized = 1;
1703             atexit( print_stats );
1704         }
1705
1706         assert( ctx->mode < DIM(lkup_stats) );
1707         lkup_stats[ctx->mode].any = 1;
1708         if( !rc )
1709             lkup_stats[ctx->mode].okay_count++;
1710         else if ( rc == G10ERR_NO_PUBKEY )
1711             lkup_stats[ctx->mode].nokey_count++;
1712         else
1713             lkup_stats[ctx->mode].error_count++;
1714     }
1715    #endif
1716
1717     ctx->last_rc = rc;
1718     ctx->count++;
1719     return rc;
1720 }
1721
1722
1723
1724 static int
1725 lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1726 {
1727     int rc;
1728     KBNODE k;
1729     int oldmode = set_packet_list_mode(0);
1730
1731     if( !ctx->count ) /* first time */
1732         rc = enum_keyblocks( 5, &ctx->kbpos, &ctx->keyblock );
1733     else
1734         rc = 0;
1735     if( !rc ) {
1736         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1737             int n;
1738             getkey_item_t *item;
1739             /* fixme: we don't enum the complete keyblock, but
1740              * use the first match and then continue with the next keyblock
1741              */
1742             /* loop over all the user ids we want to look for */
1743             item = ctx->items;
1744             for(n=0; n < ctx->nitems; n++, item++ ) {
1745                 if( item->mode < 10 )
1746                     k = find_by_name_sk( ctx->keyblock, sk,
1747                                          item->name, item->mode );
1748                 else if( item->mode >= 10 && item->mode <= 12 )
1749                     k = find_by_keyid_sk( ctx->keyblock, sk,
1750                                           item->keyid, item->mode );
1751                 else if( item->mode == 15 )
1752                     k = find_first_sk( ctx->keyblock, sk );
1753                 else if( item->mode == 16 || item->mode == 20 )
1754                     k = find_by_fpr_sk( ctx->keyblock, sk,
1755                                         item->fprint, item->mode );
1756                 else
1757                     BUG();
1758                 if( k ) {
1759                     finish_lookup_sk( ctx->keyblock, sk, k, ctx->primary );
1760                     goto found;
1761                 }
1762             }
1763             release_kbnode( ctx->keyblock );
1764             ctx->keyblock = NULL;
1765         }
1766       found: ;
1767     }
1768     if( rc && rc != -1 )
1769         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1770
1771     if( !rc ) {
1772         if( ret_keyblock ) {
1773             *ret_keyblock = ctx->keyblock;
1774             ctx->keyblock = NULL;
1775         }
1776     }
1777     else if( rc == -1 )
1778         rc = G10ERR_NO_SECKEY;
1779
1780     release_kbnode( ctx->keyblock );
1781     ctx->keyblock = NULL;
1782     set_packet_list_mode(oldmode);
1783
1784     ctx->last_rc = rc;
1785     ctx->count++;
1786     return rc;
1787 }
1788
1789
1790
1791 /****************
1792  * fixme: replace by the generic function
1793  *
1794  * Enumerate all primary secret keys.  Caller must use these procedure:
1795  *  1) create a void pointer and initialize it to NULL
1796  *  2) pass this void pointer by reference to this function
1797  *     and provide space for the secret key (pass a buffer for sk)
1798  *  3) call this function as long as it does not return -1
1799  *     to indicate EOF.
1800  *  4) Always call this function a last time with SK set to NULL,
1801  *     so that can free it's context.
1802  *
1803  *
1804  */
1805 int
1806 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1807 {
1808     int rc=0;
1809     PACKET pkt;
1810     int save_mode;
1811     struct {
1812         int eof;
1813         int sequence;
1814         const char *name;
1815         IOBUF iobuf;
1816     } *c = *context;
1817
1818
1819     if( !c ) { /* make a new context */
1820         c = m_alloc_clear( sizeof *c );
1821         *context = c;
1822         c->sequence = 0;
1823         c->name = enum_keyblock_resources( &c->sequence, 1 );
1824     }
1825
1826     if( !sk ) { /* free the context */
1827         if( c->iobuf )
1828             iobuf_close(c->iobuf);
1829         m_free( c );
1830         *context = NULL;
1831         return 0;
1832     }
1833
1834     if( c->eof )
1835         return -1;
1836
1837     /* FIXME: This assumes a plain keyring file */
1838     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1839         if( !c->iobuf ) {
1840             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1841                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1842                 continue; /* try next file */
1843             }
1844         }
1845
1846         save_mode = set_packet_list_mode(0);
1847         init_packet(&pkt);
1848         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1849             if( rc )
1850                 ; /* e.g. unknown packet */
1851             else if( pkt.pkttype == PKT_SECRET_KEY
1852                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1853                 copy_secret_key( sk, pkt.pkt.secret_key );
1854                 set_packet_list_mode(save_mode);
1855                 return 0; /* found */
1856             }
1857             free_packet(&pkt);
1858         }
1859         set_packet_list_mode(save_mode);
1860         iobuf_close(c->iobuf); c->iobuf = NULL;
1861     }
1862     c->eof = 1;
1863     return -1;
1864 }
1865
1866
1867 /****************
1868  * Return a string with a printable representation of the user_id.
1869  * this string must be freed by m_free.
1870  */
1871 char*
1872 get_user_id_string( u32 *keyid )
1873 {
1874     user_id_db_t r;
1875     char *p;
1876     int pass=0;
1877     /* try it two times; second pass reads from key resources */
1878     do {
1879         for(r=user_id_db; r; r = r->next )
1880             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1881                 p = m_alloc( r->len + 10 );
1882                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1883                 return p;
1884             }
1885     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1886     p = m_alloc( 15 );
1887     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1888     return p;
1889 }
1890
1891 char*
1892 get_long_user_id_string( u32 *keyid )
1893 {
1894     user_id_db_t r;
1895     char *p;
1896     int pass=0;
1897     /* try it two times; second pass reads from key resources */
1898     do {
1899         for(r=user_id_db; r; r = r->next )
1900             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1901                 p = m_alloc( r->len + 20 );
1902                 sprintf(p, "%08lX%08lX %.*s",
1903                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1904                 return p;
1905             }
1906     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1907     p = m_alloc( 25 );
1908     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
1909     return p;
1910 }
1911
1912 char*
1913 get_user_id( u32 *keyid, size_t *rn )
1914 {
1915     user_id_db_t r;
1916     char *p;
1917     int pass=0;
1918     /* try it two times; second pass reads from key resources */
1919     do {
1920         for(r=user_id_db; r; r = r->next )
1921             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1922                 p = m_alloc( r->len );
1923                 memcpy(p, r->name, r->len );
1924                 *rn = r->len;
1925                 return p;
1926             }
1927     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1928     p = m_alloc( 19 );
1929     memcpy(p, "[User id not found]", 19 );
1930     *rn = 19;
1931     return p;
1932 }
1933
1934