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