See ChangeLog: Thu Jan 27 18:00:44 CET 2000 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 "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 == GCRY_PK_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 = gcry_xmalloc( 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         gcry_free(r);
240         uid_cache_entries--;
241     }
242     r = gcry_xmalloc( 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             gcry_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             gcry_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 GPGERR_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 = gcry_xcalloc( 1, 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 = gcry_xmalloc( 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 = GPGERR_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 = gcry_xcalloc( 1, 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  *          GPGERR_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 = gcry_xcalloc( 1, 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     int                 hexprefix = 0;
545     int                 hexlength;
546
547     /* skip leading spaces.   FIXME: what is with leading spaces? */
548     for(s = name; *s && isspace(*s); s++ )
549         ;
550
551     switch (*s) {
552         case 0:    /* empty string is an error */
553             return 0;
554
555         case '.':  /* an email address, compare from end */
556             mode = 5;
557             s++;
558             break;
559
560         case '<':  /* an email address */
561             mode = 3;
562             break;
563
564         case '@':  /* part of an email address */
565             mode = 4;
566             s++;
567             break;
568
569         case '=':  /* exact compare */
570             mode = 1;
571             s++;
572             break;
573
574         case '*':  /* case insensitive substring search */
575             mode = 2;
576             s++;
577             break;
578
579         case '+':  /* compare individual words */
580             mode = 6;
581             s++;
582             break;
583
584         case '#':  /* local user id */
585             mode = 12;
586             s++;
587             if (keyid) {
588                 if (keyid_from_lid(strtoul(s, NULL, 10), keyid))
589                     keyid[0] = keyid[1] = 0;
590             }
591             break;
592
593         default:
594             if (s[0] == '0' && s[1] == 'x') {
595                 hexprefix = 1;
596                 s += 2;
597             }
598
599             hexlength = strspn(s, "0123456789abcdefABCDEF");
600
601             /* check if a hexadecimal number is terminated by EOS or blank */
602             if (hexlength && s[hexlength] && !isspace(s[hexlength])) {
603                 if (hexprefix)      /* a "0x" prefix without correct */
604                     return 0;       /* termination is an error */
605                 else                /* The first chars looked like */
606                     hexlength = 0;  /* a hex number, but really were not. */
607             }
608
609             if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0')){
610                 /* short keyid */
611                 if (hexlength == 9)
612                     s++;
613                 if (keyid) {
614                     keyid[0] = 0;
615                     keyid[1] = strtoul( s, NULL, 16 );
616                 }
617                 mode = 10;
618             }
619             else if (hexlength == 16 || (!hexprefix && hexlength == 17
620                                                           && *s == '0')) {
621                 /* complete keyid */
622                 char buf[9];
623                 if (hexlength == 17)
624                     s++;
625                 mem2str(buf, s, 9 );
626                 keyid[0] = strtoul( buf, NULL, 16 );
627                 keyid[1] = strtoul( s+8, NULL, 16 );
628                 mode = 11;
629             }
630             else if (hexlength == 32 || (!hexprefix && hexlength == 33
631                                                             && *s == '0')) {
632                 /* md5 fingerprint */
633                 int i;
634                 if (hexlength == 33)
635                     s++;
636                 if (fprint) {
637                     memset(fprint+16, 4, 0);
638                     for (i=0; i < 16; i++, s+=2) {
639                         int c = hextobyte(s);
640                         if (c == -1)
641                             return 0;
642                         fprint[i] = c;
643                     }
644                 }
645                 mode = 16;
646             }
647             else if (hexlength == 40 || (!hexprefix && hexlength == 41
648                                                               && *s == '0')) {
649                 /* sha1/rmd160 fingerprint */
650                 int i;
651                 if (hexlength == 41)
652                     s++;
653                 if (fprint) {
654                     for (i=0; i < 20; i++, s+=2) {
655                         int c = hextobyte(s);
656                         if (c == -1)
657                             return 0;
658                         fprint[i] = c;
659                     }
660                 }
661                 mode = 20;
662             }
663             else {
664                 if (hexprefix)  /* This was a hex number with a prefix */
665                     return 0;   /* and a wrong length */
666
667                 mode = 2;   /* Default is case insensitive substring search */
668             }
669     }
670
671     if( retstr )
672         *retstr = s;
673     if( retlen )
674         *retlen = strlen(s);
675
676     return mode;
677 }
678
679
680
681 /****************
682  * Try to get the pubkey by the userid. This function looks for the
683  * first pubkey certificate which has the given name in a user_id.
684  * if pk/sk has the pubkey algo set, the function will only return
685  * a pubkey with that algo.
686  * The caller must provide provide storage for either the pk or the sk.
687  * If ret_kb is not NULL the funtion will return the keyblock there.
688  */
689
690 static int
691 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
692             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
693 {
694     int rc = 0;
695     int n;
696     STRLIST r;
697     GETKEY_CTX ctx;
698
699     assert( !pk ^ !sk );
700
701     /* build the search context */
702     /* Performance hint: Use a static buffer if there is only one name */
703     /*                   and we don't have mode 6 */
704     for(n=0, r=namelist; r; r = r->next )
705         n++;
706     ctx = gcry_xcalloc( 1, sizeof *ctx + (n-1)*sizeof ctx->items );
707     ctx->nitems = n;
708
709     for(n=0, r=namelist; r; r = r->next, n++ ) {
710         ctx->items[n].mode = classify_user_id( r->d,
711                                               ctx->items[n].keyid,
712                                               ctx->items[n].fprint,
713                                               &ctx->items[n].name,
714                                               NULL );
715         if( !ctx->items[n].mode ) {
716             gcry_free( ctx );
717             return GPGERR_INV_USER_ID;
718         }
719         if( ctx->items[n].mode == 6 ) {
720             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
721             ctx->items[n].name = ctx->items[n].namebuf;
722         }
723     }
724
725     /* and call the lookup function */
726     ctx->primary = 1; /* we want to look for the primary key only */
727     if( sk )
728         rc = lookup_sk( ctx, sk, ret_kb );
729     else
730         rc = lookup_pk( ctx, pk, ret_kb );
731
732     if( retctx ) /* caller wants the context */
733         *retctx = ctx;
734     else {
735         /* Hmmm, why not get_pubkey-end here?? */
736         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
737         for(n=0; n < ctx->nitems; n++ )
738             gcry_free( ctx->items[n].namebuf );
739         gcry_free( ctx );
740     }
741
742     return rc;
743 }
744
745 int
746 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
747                    const char *name, KBNODE *ret_keyblock )
748 {
749     int rc;
750     STRLIST namelist = NULL;
751
752     add_to_strlist( &namelist, name );
753
754     if( !pk ) {
755         /* Performance Hint: key_byname should not need a pk here */
756         pk = gcry_xcalloc( 1, sizeof *pk );
757         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
758         free_public_key( pk );
759     }
760     else
761         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
762
763     free_strlist( namelist );
764     return rc;
765 }
766
767 int
768 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
769                     STRLIST names, KBNODE *ret_keyblock )
770 {
771     int rc;
772
773     if( !pk ) {
774         /* Performance Hint: key_byname should not need a pk here */
775         pk = gcry_xcalloc( 1, sizeof *pk );
776         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
777         free_public_key( pk );
778     }
779     else
780         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
781
782     return rc;
783 }
784
785 int
786 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
787 {
788     int rc;
789
790     if( !pk ) {
791         /* Performance Hint: lookup_read should not need a pk in this case */
792         pk = gcry_xcalloc( 1, sizeof *pk );
793         rc = lookup_pk( ctx, pk, ret_keyblock );
794         free_public_key( pk );
795     }
796     else
797         rc = lookup_pk( ctx, pk, ret_keyblock );
798     return rc;
799 }
800
801 void
802 get_pubkey_end( GETKEY_CTX ctx )
803 {
804     if( ctx ) {
805         int n;
806
807         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
808         for(n=0; n < ctx->nitems; n++ )
809             gcry_free( ctx->items[n].namebuf );
810         if( !ctx->not_allocated )
811             gcry_free( ctx );
812     }
813 }
814
815 /****************
816  * Search for a key with the given fingerprint.
817  */
818 int
819 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
820 {
821     int rc;
822
823     if( fprint_len == 20 || fprint_len == 16 ) {
824         struct getkey_ctx_s ctx;
825         memset( &ctx, 0, sizeof ctx );
826         ctx.not_allocated = 1;
827         ctx.nitems = 1;
828         ctx.items[0].mode = fprint_len;
829         memcpy( ctx.items[0].fprint, fprint, fprint_len );
830         rc = lookup_pk( &ctx, pk, NULL );
831         get_pubkey_end( &ctx );
832     }
833     else
834         rc = GPGERR_GENERAL; /* Oops */
835     return rc;
836 }
837
838 /****************
839  * Search for a key with the given fingerprint and return the
840  * complete keyblock which may have more than only this key.
841  */
842 int
843 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
844                                                 size_t fprint_len )
845 {
846     int rc;
847     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
848
849     if( fprint_len == 20 || fprint_len == 16 ) {
850         struct getkey_ctx_s ctx;
851         memset( &ctx, 0, sizeof ctx );
852         ctx.not_allocated = 1;
853         ctx.nitems = 1;
854         ctx.items[0].mode = fprint_len;
855         memcpy( ctx.items[0].fprint, fprint, fprint_len );
856         rc = lookup_pk( &ctx, pk, ret_keyblock );
857         get_pubkey_end( &ctx );
858     }
859     else
860         rc = GPGERR_GENERAL; /* Oops */
861
862     free_public_key( pk );
863     return rc;
864 }
865
866
867
868 /****************
869  * Search for a key with the given lid and return the complete keyblock
870  */
871 int
872 get_keyblock_bylid( KBNODE *ret_keyblock, ulong lid )
873 {
874     int rc;
875     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
876     struct getkey_ctx_s ctx;
877     u32 kid[2];
878
879     if( keyid_from_lid( lid, kid ) )
880         kid[0] = kid[1] = 0;
881     memset( &ctx, 0, sizeof ctx );
882     ctx.not_allocated = 1;
883     ctx.nitems = 1;
884     ctx.items[0].mode = 12;
885     ctx.items[0].keyid[0] = kid[0];
886     ctx.items[0].keyid[1] = kid[1];
887     rc = lookup_pk( &ctx, pk, ret_keyblock );
888     get_pubkey_end( &ctx );
889
890     free_public_key( pk );
891     return rc;
892 }
893
894
895
896
897
898 /****************
899  * Get a secret key by name and store it into sk
900  * If NAME is NULL use the default key
901  */
902 int
903 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
904 {
905     STRLIST namelist = NULL;
906     int rc;
907
908     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
909         add_to_strlist( &namelist, opt.def_secret_key );
910         rc = key_byname( NULL, namelist, NULL, sk, NULL );
911     }
912     else if( !name ) { /* use the first one as default key */
913         struct getkey_ctx_s ctx;
914
915         memset( &ctx, 0, sizeof ctx );
916         ctx.not_allocated = 1;
917         ctx.primary = 1;
918         ctx.nitems = 1;
919         ctx.items[0].mode = 15;
920         rc = lookup_sk( &ctx, sk, NULL );
921         get_seckey_end( &ctx );
922     }
923     else {
924         add_to_strlist( &namelist, name );
925         rc = key_byname( NULL, namelist, NULL, sk, NULL );
926     }
927
928     free_strlist( namelist );
929
930     if( !rc && unprotect )
931         rc = check_secret_key( sk, 0 );
932
933     return rc;
934 }
935
936 int
937 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
938                     STRLIST names, KBNODE *ret_keyblock )
939 {
940     int rc;
941
942     if( !sk ) {
943         /* Performance Hint: key_byname should not need a sk here */
944         sk = gcry_xcalloc_secure( 1,  sizeof *sk );
945         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
946         free_secret_key( sk );
947     }
948     else
949         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
950
951     return rc;
952 }
953
954
955 int
956 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
957 {
958     int rc;
959
960     if( !sk ) {
961         /* Performance Hint: lookup_read should not need a pk in this case */
962         sk = gcry_xcalloc_secure( 1,  sizeof *sk );
963         rc = lookup_sk( ctx, sk, ret_keyblock );
964         free_secret_key( sk );
965     }
966     else
967         rc = lookup_sk( ctx, sk, ret_keyblock );
968     return rc;
969 }
970
971 void
972 get_seckey_end( GETKEY_CTX ctx )
973 {
974     if( ctx ) {
975         int n;
976
977         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
978         for(n=0; n < ctx->nitems; n++ )
979             gcry_free( ctx->items[n].namebuf );
980         if( !ctx->not_allocated )
981             gcry_free( ctx );
982     }
983 }
984
985
986
987 /****************
988  * Do a word match (original user id starts with a '+').
989  * The pattern is already tokenized to a more suitable format:
990  * There are only the real words in it delimited by one space
991  * and all converted to uppercase.
992  *
993  * Returns: 0 if all words match.
994  *
995  * Note: This algorithm is a straightforward one and not very
996  *       fast.  It works for UTF-8 strings.  The uidlen should
997  *       be removed but due to the fact that old versions of
998  *       pgp don't use UTF-8 we still use the length; this should
999  *       be fixed in parse-packet (and replace \0 by some special
1000  *       UTF-8 encoding)
1001  */
1002 static int
1003 word_match( const byte *uid, size_t uidlen, const byte *pattern )
1004 {
1005     size_t wlen, n;
1006     const byte *p;
1007     const byte *s;
1008
1009     for( s=pattern; *s; ) {
1010         do {
1011             /* skip leading delimiters */
1012             while( uidlen && !word_match_chars[*uid] )
1013                 uid++, uidlen--;
1014             /* get length of the word */
1015             n = uidlen; p = uid;
1016             while( n && word_match_chars[*p] )
1017                 p++, n--;
1018             wlen = p - uid;
1019             /* and compare against the current word from pattern */
1020             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
1021                 if( word_match_chars[*p] != s[n] )
1022                     break;
1023             }
1024             if( n == wlen && (s[n] == ' ' || !s[n]) )
1025                 break; /* found */
1026             uid += wlen;
1027             uidlen -= wlen;
1028         } while( uidlen );
1029         if( !uidlen )
1030             return -1; /* not found */
1031
1032         /* advance to next word in pattern */
1033         for(; *s != ' ' && *s ; s++ )
1034             ;
1035         if( *s )
1036             s++ ;
1037     }
1038     return 0; /* found */
1039 }
1040
1041 /****************
1042  * prepare word word_match; that is parse the name and
1043  * build the pattern.
1044  * caller has to free the returned pattern
1045  */
1046 static char*
1047 prepare_word_match( const byte *name )
1048 {
1049     byte *pattern, *p;
1050     int c;
1051
1052     /* the original length is always enough for the pattern */
1053     p = pattern = gcry_xmalloc(strlen(name)+1);
1054     do {
1055         /* skip leading delimiters */
1056         while( *name && !word_match_chars[*name] )
1057             name++;
1058         /* copy as long as we don't have a delimiter and convert
1059          * to uppercase.
1060          * fixme: how can we handle utf8 uppercasing */
1061         for( ; *name &&  (c=word_match_chars[*name]); name++ )
1062             *p++ = c;
1063         *p++ = ' '; /* append pattern delimiter */
1064     } while( *name );
1065     p[-1] = 0; /* replace last pattern delimiter by EOS */
1066
1067     return pattern;
1068 }
1069
1070
1071
1072
1073
1074 static int
1075 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
1076 {
1077     int i;
1078     const char *s, *se;
1079
1080     if( mode == 1 ) {  /* exact match */
1081         for(i=0; name[i] && uidlen; i++, uidlen-- )
1082             if( uid[i] != name[i] )
1083                 break;
1084         if( !uidlen && !name[i] )
1085             return 0; /* found */
1086     }
1087     else if( mode == 2 ) { /* case insensitive substring */
1088         if( memistr( uid, uidlen, name ) )
1089             return 0;
1090     }
1091     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1092         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1093             ;
1094         if( i < uidlen )  {
1095             /* skip opening delim and one char and look for the closing one*/
1096             s++; i++;
1097             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1098                 ;
1099             if( i < uidlen ) {
1100                 i = se - s;
1101                 if( mode == 3 ) { /* exact email address */
1102                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1103                         return 0;
1104                 }
1105                 else if( mode == 4 ) {  /* email substring */
1106                     if( memistr( s, i, name ) )
1107                         return 0;
1108                 }
1109                 else { /* email from end */
1110                     /* nyi */
1111                 }
1112             }
1113         }
1114     }
1115     else if( mode == 6 )
1116         return word_match( uid, uidlen, name );
1117     else
1118         BUG();
1119
1120     return -1; /* not found */
1121 }
1122
1123
1124
1125 /****************
1126  * Assume that knode points to a public key packet  and keyblock is
1127  * the entire keyblock.  This function adds all relevant information from
1128  * a selfsignature to the public key.
1129  */
1130
1131 static void
1132 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
1133                           PKT_public_key *orig_pk )
1134 {
1135     PKT_public_key *pk = knode->pkt->pkt.public_key;
1136     PKT_signature *sig;
1137     KBNODE k;
1138     u32 kid[2];
1139     u32 sigdate = 0;
1140
1141     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
1142             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1143
1144     if( pk->version < 4 )
1145         return; /* this is only needed for version >=4 packets */
1146
1147
1148     /* find the selfsignature */
1149     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1150         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1151         if( !k )
1152            BUG(); /* keyblock without primary key!!! */
1153         keyid_from_pk( knode->pkt->pkt.public_key, kid );
1154     }
1155     else
1156         keyid_from_pk( pk, kid );
1157
1158     for(k=knode->next; k; k = k->next ) {
1159         if( k->pkt->pkttype == PKT_SIGNATURE
1160             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1161             && sig->sig_class <= 0x30
1162             && sig->keyid[0] == kid[0]
1163             && sig->keyid[1] == kid[1]
1164             && sig->version > 3 ) {
1165             /* okay this is a self-signature which can be used.
1166              * We use the latest self-signature.
1167              * FIXME: We should only use this if the signature is valid
1168              *        but this is time consuming - we must provide another
1169              *        way to handle this
1170              */
1171             const byte *p;
1172             u32 ed;
1173
1174             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1175             ed = p? pk->timestamp + buffer_to_u32(p):0;
1176             /* use the latest self signature */
1177             if( sig->timestamp > sigdate ) {
1178                 pk->expiredate = ed;
1179                 orig_pk->expiredate = ed;
1180                 sigdate = sig->timestamp;
1181             }
1182             /* fixme: add usage etc. to pk */
1183         }
1184         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1185             break; /* stop here */
1186     }
1187 }
1188
1189
1190 /****************
1191  * merge all selfsignatures with the keys.
1192  */
1193 void
1194 merge_keys_and_selfsig( KBNODE keyblock )
1195 {
1196     PKT_public_key *pk = NULL;
1197     PKT_secret_key *sk = NULL;
1198     PKT_signature *sig;
1199     KBNODE k;
1200     u32 kid[2] = { 0, 0 };
1201     u32 sigdate = 0;
1202
1203     for(k=keyblock; k; k = k->next ) {
1204         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1205             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1206             pk = k->pkt->pkt.public_key; sk = NULL;
1207             if( pk->version < 4 )
1208                 pk = NULL; /* not needed for old keys */
1209             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1210                 keyid_from_pk( pk, kid );
1211             sigdate = 0;
1212         }
1213         else if( k->pkt->pkttype == PKT_SECRET_KEY
1214             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1215             pk = NULL; sk = k->pkt->pkt.secret_key;
1216             if( sk->version < 4 )
1217                 sk = NULL;
1218             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1219                 keyid_from_sk( sk, kid );
1220             sigdate = 0;
1221         }
1222         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1223                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1224                  && sig->sig_class <= 0x30 && sig->version > 3
1225                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1226             /* okay this is a self-signature which can be used.
1227              * FIXME: We should only use this if the signature is valid
1228              *        but this is time consuming - we must provide another
1229              *        way to handle this
1230              */
1231             const byte *p;
1232             u32 ed;
1233
1234             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1235             if( pk ) {
1236                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1237                 if( sig->timestamp > sigdate ) {
1238                     pk->expiredate = ed;
1239                     sigdate = sig->timestamp;
1240                 }
1241             }
1242             else {
1243                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1244                 if( sig->timestamp > sigdate ) {
1245                     sk->expiredate = ed;
1246                     sigdate = sig->timestamp;
1247                 }
1248             }
1249         }
1250     }
1251 }
1252
1253
1254 static KBNODE
1255 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
1256               int mode, byte *namehash, int *use_namehash )
1257 {
1258     KBNODE k, kk;
1259
1260     for(k=keyblock; k; k = k->next ) {
1261         if( k->pkt->pkttype == PKT_USER_ID
1262             && !compare_name( k->pkt->pkt.user_id->name,
1263                               k->pkt->pkt.user_id->len, name, mode)) {
1264             /* we found a matching name, look for the key */
1265             for(kk=keyblock; kk; kk = kk->next ) {
1266                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
1267                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1268                     && ( !pk->pubkey_algo
1269                          || pk->pubkey_algo
1270                             == kk->pkt->pkt.public_key->pubkey_algo)
1271                     && ( !pk->pubkey_usage
1272                          || !openpgp_pk_test_algo(
1273                                kk->pkt->pkt.public_key->pubkey_algo,
1274                                                    pk->pubkey_usage ))
1275                   )
1276                     break;
1277             }
1278             if( kk ) {
1279                 u32 aki[2];
1280                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
1281                 cache_user_id( k->pkt->pkt.user_id, aki );
1282                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1283                                     k->pkt->pkt.user_id->name,
1284                                     k->pkt->pkt.user_id->len );
1285                 *use_namehash = 1;
1286                 return kk;
1287             }
1288             else if( is_RSA(pk->pubkey_algo) )
1289                 log_error(_("RSA key cannot be used in this version\n"));
1290             else
1291                 log_error(_("No key for user ID\n"));
1292         }
1293     }
1294     return NULL;
1295 }
1296
1297 static KBNODE
1298 find_by_name_sk( KBNODE keyblock, PKT_secret_key *sk, const char *name,
1299                  int mode )
1300 {
1301     KBNODE k, kk;
1302
1303     for(k=keyblock; k; k = k->next ) {
1304         if( k->pkt->pkttype == PKT_USER_ID
1305             && !compare_name( k->pkt->pkt.user_id->name,
1306                               k->pkt->pkt.user_id->len, name, mode)) {
1307             /* we found a matching name, look for the key */
1308             for(kk=keyblock; kk; kk = kk->next ) {
1309                 if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1310                       || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1311                     && ( !sk->pubkey_algo
1312                          || sk->pubkey_algo
1313                             == kk->pkt->pkt.secret_key->pubkey_algo)
1314                     && ( !sk->pubkey_usage
1315                          || !openpgp_pk_test_algo(
1316                                kk->pkt->pkt.secret_key->pubkey_algo,
1317                                                    sk->pubkey_usage ))
1318                   )
1319                     break;
1320             }
1321             if( kk ) {
1322                 u32 aki[2];
1323                 keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1324                 cache_user_id( k->pkt->pkt.user_id, aki );
1325                 return kk;
1326             }
1327             else if( is_RSA(sk->pubkey_algo) )
1328                 log_error(_("RSA key cannot be used in this version\n"));
1329             else
1330                 log_error(_("No key for user ID\n"));
1331         }
1332     }
1333     return NULL;
1334 }
1335
1336
1337 static KBNODE
1338 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
1339 {
1340     KBNODE k;
1341
1342     if( DBG_CACHE )
1343         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
1344                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
1345
1346     for(k=keyblock; k; k = k->next ) {
1347         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1348             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1349             u32 aki[2];
1350             keyid_from_pk( k->pkt->pkt.public_key, aki );
1351             if( DBG_CACHE )
1352                 log_debug("         aki=%08lx%08lx algo=%d\n",
1353                                 (ulong)aki[0], (ulong)aki[1],
1354                                  k->pkt->pkt.public_key->pubkey_algo    );
1355
1356             if( aki[1] == keyid[1]
1357                 && ( mode == 10 || aki[0] == keyid[0] )
1358                 && ( !pk->pubkey_algo
1359                      || pk->pubkey_algo
1360                         == k->pkt->pkt.public_key->pubkey_algo) ){
1361                 KBNODE kk;
1362                 /* cache the userid */
1363                 for(kk=keyblock; kk; kk = kk->next )
1364                     if( kk->pkt->pkttype == PKT_USER_ID )
1365                         break;
1366                 if( kk )
1367                     cache_user_id( kk->pkt->pkt.user_id, aki );
1368                 else
1369                     log_error(_("No user ID for key\n"));
1370                 return k; /* found */
1371             }
1372         }
1373     }
1374     return NULL;
1375 }
1376
1377 static KBNODE
1378 find_by_keyid_sk( KBNODE keyblock, PKT_secret_key *sk, u32 *keyid, int mode )
1379 {
1380     KBNODE k;
1381
1382     if( DBG_CACHE )
1383         log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1384                    (ulong)keyid[0], (ulong)keyid[1], sk->pubkey_algo, mode );
1385
1386     for(k=keyblock; k; k = k->next ) {
1387         if(    k->pkt->pkttype == PKT_SECRET_KEY
1388             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1389             u32 aki[2];
1390             keyid_from_sk( k->pkt->pkt.secret_key, aki );
1391             if( DBG_CACHE )
1392                 log_debug("         aki=%08lx%08lx algo=%d\n",
1393                                 (ulong)aki[0], (ulong)aki[1],
1394                                  k->pkt->pkt.secret_key->pubkey_algo    );
1395
1396             if( aki[1] == keyid[1]
1397                 && ( mode == 10 || aki[0] == keyid[0] )
1398                 && ( !sk->pubkey_algo
1399                      || sk->pubkey_algo
1400                         == k->pkt->pkt.secret_key->pubkey_algo) ){
1401                 KBNODE kk;
1402                 /* cache the userid */
1403                 for(kk=keyblock; kk; kk = kk->next )
1404                     if( kk->pkt->pkttype == PKT_USER_ID )
1405                         break;
1406                 if( kk )
1407                     cache_user_id( kk->pkt->pkt.user_id, aki );
1408                 else
1409                     log_error(_("No user ID for key\n"));
1410                 return k; /* found */
1411             }
1412         }
1413     }
1414     return NULL;
1415 }
1416
1417
1418 static KBNODE
1419 find_first( KBNODE keyblock, PKT_public_key *pk )
1420 {
1421     KBNODE k;
1422
1423     for(k=keyblock; k; k = k->next ) {
1424         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1425             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1426         {
1427             if( !pk->pubkey_algo
1428                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
1429                 return k;
1430         }
1431     }
1432     return NULL;
1433 }
1434
1435 static KBNODE
1436 find_first_sk( KBNODE keyblock, PKT_secret_key *sk )
1437 {
1438     KBNODE k;
1439
1440     for(k=keyblock; k; k = k->next ) {
1441         if(    k->pkt->pkttype == PKT_SECRET_KEY
1442             || k->pkt->pkttype == PKT_SECRET_SUBKEY )
1443         {
1444             if( !sk->pubkey_algo
1445                 || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo )
1446                 return k;
1447         }
1448     }
1449     return NULL;
1450 }
1451
1452
1453 static KBNODE
1454 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
1455 {
1456     KBNODE k;
1457
1458     for(k=keyblock; k; k = k->next ) {
1459         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1460             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1461             byte afp[MAX_FINGERPRINT_LEN];
1462             size_t an;
1463
1464             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1465
1466             if( DBG_CACHE ) {
1467                 u32 aki[2];
1468                 keyid_from_pk( k->pkt->pkt.public_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.public_key->pubkey_algo, mode,
1472                                                             (unsigned)an );
1473             }
1474
1475             if( an == mode
1476                 && !memcmp( afp, name, an)
1477                 && ( !pk->pubkey_algo
1478                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
1479                 return k;
1480         }
1481     }
1482     return NULL;
1483 }
1484
1485 static KBNODE
1486 find_by_fpr_sk( KBNODE keyblock, PKT_secret_key *sk,
1487                                  const char *name, int mode )
1488 {
1489     KBNODE k;
1490
1491     for(k=keyblock; k; k = k->next ) {
1492         if(    k->pkt->pkttype == PKT_SECRET_KEY
1493             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1494             byte afp[MAX_FINGERPRINT_LEN];
1495             size_t an;
1496
1497             fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1498
1499             if( DBG_CACHE ) {
1500                 u32 aki[2];
1501                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
1502                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1503                                 (ulong)aki[0], (ulong)aki[1],
1504                         k->pkt->pkt.secret_key->pubkey_algo, mode,
1505                                                         (unsigned)an );
1506             }
1507
1508             if( an == mode
1509                 && !memcmp( afp, name, an)
1510                 && ( !sk->pubkey_algo
1511                      || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo) )
1512                 return k;
1513         }
1514     }
1515     return NULL;
1516 }
1517
1518
1519 static void
1520 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
1521                                                int use_namehash, int primary )
1522 {
1523     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
1524             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1525     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1526     if( primary && !pk->pubkey_usage ) {
1527         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1528                                       use_namehash? namehash:NULL);
1529         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1530     }
1531     else {
1532         if( primary && pk->pubkey_usage
1533             && openpgp_pk_test_algo( k->pkt->pkt.public_key->pubkey_algo,
1534                        pk->pubkey_usage ) == GPGERR_WR_PUBKEY_ALGO ) {
1535             /* if the usage is not correct, try to use a subkey */
1536             KBNODE save_k = k;
1537
1538             k = NULL;
1539             /* kludge for pgp 5: which doesn't accept type 20:
1540              * try to use a type 16 subkey instead */
1541             if( pk->pubkey_usage == GCRY_PK_USAGE_ENCR ) {
1542                 for( k = save_k; k; k = k->next ) {
1543                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1544                         && k->pkt->pkt.public_key->pubkey_algo
1545                             == GCRY_PK_ELG_E
1546                         && !openpgp_pk_test_algo(
1547                                 k->pkt->pkt.public_key->pubkey_algo,
1548                                                  pk->pubkey_usage ) )
1549                         break;
1550                 }
1551             }
1552
1553             if( !k ) {
1554                 for(k = save_k ; k; k = k->next ) {
1555                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1556                         && !openpgp_pk_test_algo(
1557                                 k->pkt->pkt.public_key->pubkey_algo,
1558                                                  pk->pubkey_usage ) )
1559                         break;
1560                 }
1561             }
1562             if( !k )
1563                 k = save_k;
1564             else
1565                 log_info(_("using secondary key %08lX "
1566                            "instead of primary key %08lX\n"),
1567                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1568                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1569                         );
1570         }
1571
1572         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1573                                       use_namehash? namehash:NULL);
1574         merge_one_pk_and_selfsig( keyblock, k, pk );
1575     }
1576 }
1577
1578 static void
1579 finish_lookup_sk( KBNODE keyblock, PKT_secret_key *sk, KBNODE k, int primary )
1580 {
1581     assert(    k->pkt->pkttype == PKT_SECRET_KEY
1582             || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1583     assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1584     if( primary && !sk->pubkey_usage ) {
1585         copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1586     }
1587     else {
1588         if( primary && sk->pubkey_usage
1589             && openpgp_pk_test_algo( k->pkt->pkt.secret_key->pubkey_algo,
1590                        sk->pubkey_usage ) == GPGERR_WR_PUBKEY_ALGO ) {
1591             /* if the usage is not correct, try to use a subkey */
1592             KBNODE save_k = k;
1593
1594             k = NULL;
1595             /* kludge for pgp 5: which doesn't accept type 20:
1596              * try to use a type 16 subkey instead */
1597             if( sk->pubkey_usage == GCRY_PK_USAGE_ENCR ) {
1598                 for( k = save_k; k; k = k->next ) {
1599                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1600                         && k->pkt->pkt.secret_key->pubkey_algo
1601                             == GCRY_PK_ELG_E
1602                         && !openpgp_pk_test_algo(
1603                                 k->pkt->pkt.secret_key->pubkey_algo,
1604                                                  sk->pubkey_usage ) )
1605                         break;
1606                 }
1607             }
1608
1609             if( !k ) {
1610                 for(k = save_k ; k; k = k->next ) {
1611                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1612                         && !openpgp_pk_test_algo(
1613                                 k->pkt->pkt.secret_key->pubkey_algo,
1614                                                  sk->pubkey_usage ) )
1615                         break;
1616                 }
1617             }
1618             if( !k )
1619                 k = save_k;
1620             else
1621                 log_info(_("using secondary key %08lX "
1622                            "instead of primary key %08lX\n"),
1623                       (ulong)keyid_from_sk( k->pkt->pkt.secret_key, NULL),
1624                       (ulong)keyid_from_sk( save_k->pkt->pkt.secret_key, NULL)
1625                         );
1626         }
1627
1628         copy_secret_key( sk, k->pkt->pkt.secret_key );
1629     }
1630 }
1631
1632
1633 static int
1634 lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1635 {
1636     int rc;
1637     KBNODE k;
1638     int oldmode = set_packet_list_mode(0);
1639     byte namehash[20];
1640     int use_namehash=0;
1641
1642     if( !ctx->count ) /* first time */
1643         rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1644     else
1645         rc = 0;
1646     if( !rc ) {
1647         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1648             int n;
1649             getkey_item_t *item;
1650             /* fixme: we don't enum the complete keyblock, but
1651              * use the first match and then continue with the next keyblock
1652              */
1653             /* loop over all the user ids we want to look for */
1654             item = ctx->items;
1655             for(n=0; n < ctx->nitems; n++, item++ ) {
1656                 if( item->mode < 10 )
1657                     k = find_by_name( ctx->keyblock, pk,
1658                                       item->name, item->mode,
1659                                       namehash, &use_namehash );
1660                 else if( item->mode >= 10 && item->mode <= 12 )
1661                     k = find_by_keyid( ctx->keyblock, pk,
1662                                        item->keyid, item->mode );
1663                 else if( item->mode == 15 )
1664                     k = find_first( ctx->keyblock, pk );
1665                 else if( item->mode == 16 || item->mode == 20 )
1666                     k = find_by_fpr( ctx->keyblock, pk,
1667                                      item->fprint, item->mode );
1668                 else
1669                     BUG();
1670                 if( k ) {
1671                     finish_lookup( ctx->keyblock, pk, k, namehash,
1672                                                  use_namehash, ctx->primary );
1673                     goto found;
1674                 }
1675             }
1676             release_kbnode( ctx->keyblock );
1677             ctx->keyblock = NULL;
1678         }
1679       found: ;
1680     }
1681     if( rc && rc != -1 )
1682         log_error("enum_keyblocks failed: %s\n", gpg_errstr(rc));
1683
1684     if( !rc ) {
1685         if( ret_keyblock ) {
1686             *ret_keyblock = ctx->keyblock;
1687             ctx->keyblock = NULL;
1688         }
1689     }
1690     else if( rc == -1 )
1691         rc = GPGERR_NO_PUBKEY;
1692
1693     release_kbnode( ctx->keyblock );
1694     ctx->keyblock = NULL;
1695     set_packet_list_mode(oldmode);
1696   #if 0
1697     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1698         static int initialized;
1699
1700         if( !initialized ) {
1701             initialized = 1;
1702             atexit( print_stats );
1703         }
1704
1705         assert( ctx->mode < DIM(lkup_stats) );
1706         lkup_stats[ctx->mode].any = 1;
1707         if( !rc )
1708             lkup_stats[ctx->mode].okay_count++;
1709         else if ( rc == GPGERR_NO_PUBKEY )
1710             lkup_stats[ctx->mode].nokey_count++;
1711         else
1712             lkup_stats[ctx->mode].error_count++;
1713     }
1714    #endif
1715
1716     ctx->last_rc = rc;
1717     ctx->count++;
1718     return rc;
1719 }
1720
1721
1722
1723 static int
1724 lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1725 {
1726     int rc;
1727     KBNODE k;
1728     int oldmode = set_packet_list_mode(0);
1729
1730     if( !ctx->count ) /* first time */
1731         rc = enum_keyblocks( 5, &ctx->kbpos, &ctx->keyblock );
1732     else
1733         rc = 0;
1734     if( !rc ) {
1735         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1736             int n;
1737             getkey_item_t *item;
1738             /* fixme: we don't enum the complete keyblock, but
1739              * use the first match and then continue with the next keyblock
1740              */
1741             /* loop over all the user ids we want to look for */
1742             item = ctx->items;
1743             for(n=0; n < ctx->nitems; n++, item++ ) {
1744                 if( item->mode < 10 )
1745                     k = find_by_name_sk( ctx->keyblock, sk,
1746                                          item->name, item->mode );
1747                 else if( item->mode >= 10 && item->mode <= 12 )
1748                     k = find_by_keyid_sk( ctx->keyblock, sk,
1749                                           item->keyid, item->mode );
1750                 else if( item->mode == 15 )
1751                     k = find_first_sk( ctx->keyblock, sk );
1752                 else if( item->mode == 16 || item->mode == 20 )
1753                     k = find_by_fpr_sk( ctx->keyblock, sk,
1754                                         item->fprint, item->mode );
1755                 else
1756                     BUG();
1757                 if( k ) {
1758                     finish_lookup_sk( ctx->keyblock, sk, k, ctx->primary );
1759                     goto found;
1760                 }
1761             }
1762             release_kbnode( ctx->keyblock );
1763             ctx->keyblock = NULL;
1764         }
1765       found: ;
1766     }
1767     if( rc && rc != -1 )
1768         log_error("enum_keyblocks failed: %s\n", gpg_errstr(rc));
1769
1770     if( !rc ) {
1771         if( ret_keyblock ) {
1772             *ret_keyblock = ctx->keyblock;
1773             ctx->keyblock = NULL;
1774         }
1775     }
1776     else if( rc == -1 )
1777         rc = GPGERR_NO_SECKEY;
1778
1779     release_kbnode( ctx->keyblock );
1780     ctx->keyblock = NULL;
1781     set_packet_list_mode(oldmode);
1782
1783     ctx->last_rc = rc;
1784     ctx->count++;
1785     return rc;
1786 }
1787
1788
1789
1790 /****************
1791  * fixme: replace by the generic function
1792  *
1793  * Enumerate all primary secret keys.  Caller must use these procedure:
1794  *  1) create a void pointer and initialize it to NULL
1795  *  2) pass this void pointer by reference to this function
1796  *     and provide space for the secret key (pass a buffer for sk)
1797  *  3) call this function as long as it does not return -1
1798  *     to indicate EOF.
1799  *  4) Always call this function a last time with SK set to NULL,
1800  *     so that can free it's context.
1801  *
1802  *
1803  */
1804 int
1805 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1806 {
1807     int rc=0;
1808     PACKET pkt;
1809     int save_mode;
1810     struct {
1811         int eof;
1812         int sequence;
1813         const char *name;
1814         IOBUF iobuf;
1815     } *c = *context;
1816
1817
1818     if( !c ) { /* make a new context */
1819         c = gcry_xcalloc( 1, sizeof *c );
1820         *context = c;
1821         c->sequence = 0;
1822         c->name = enum_keyblock_resources( &c->sequence, 1 );
1823     }
1824
1825     if( !sk ) { /* free the context */
1826         if( c->iobuf )
1827             iobuf_close(c->iobuf);
1828         gcry_free( c );
1829         *context = NULL;
1830         return 0;
1831     }
1832
1833     if( c->eof )
1834         return -1;
1835
1836     /* FIXME: This assumes a plain keyring file */
1837     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1838         if( !c->iobuf ) {
1839             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1840                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1841                 continue; /* try next file */
1842             }
1843         }
1844
1845         save_mode = set_packet_list_mode(0);
1846         init_packet(&pkt);
1847         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1848             if( rc )
1849                 ; /* e.g. unknown packet */
1850             else if( pkt.pkttype == PKT_SECRET_KEY
1851                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1852                 copy_secret_key( sk, pkt.pkt.secret_key );
1853                 set_packet_list_mode(save_mode);
1854                 return 0; /* found */
1855             }
1856             free_packet(&pkt);
1857         }
1858         set_packet_list_mode(save_mode);
1859         iobuf_close(c->iobuf); c->iobuf = NULL;
1860     }
1861     c->eof = 1;
1862     return -1;
1863 }
1864
1865
1866 /****************
1867  * Return a string with a printable representation of the user_id.
1868  * this string must be freed by m_free.
1869  */
1870 char*
1871 get_user_id_string( u32 *keyid )
1872 {
1873     user_id_db_t r;
1874     char *p;
1875     int pass=0;
1876     /* try it two times; second pass reads from key resources */
1877     do {
1878         for(r=user_id_db; r; r = r->next )
1879             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1880                 p = gcry_xmalloc( r->len + 10 );
1881                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1882                 return p;
1883             }
1884     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1885     p = gcry_xmalloc( 15 );
1886     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1887     return p;
1888 }
1889
1890 char*
1891 get_long_user_id_string( u32 *keyid )
1892 {
1893     user_id_db_t r;
1894     char *p;
1895     int pass=0;
1896     /* try it two times; second pass reads from key resources */
1897     do {
1898         for(r=user_id_db; r; r = r->next )
1899             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1900                 p = gcry_xmalloc( r->len + 20 );
1901                 sprintf(p, "%08lX%08lX %.*s",
1902                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1903                 return p;
1904             }
1905     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1906     p = gcry_xmalloc( 25 );
1907     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
1908     return p;
1909 }
1910
1911 char*
1912 get_user_id( u32 *keyid, size_t *rn )
1913 {
1914     user_id_db_t r;
1915     char *p;
1916     int pass=0;
1917     /* try it two times; second pass reads from key resources */
1918     do {
1919         for(r=user_id_db; r; r = r->next )
1920             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1921                 p = gcry_xmalloc( r->len );
1922                 memcpy(p, r->name, r->len );
1923                 *rn = r->len;
1924                 return p;
1925             }
1926     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1927     p = gcry_xmalloc( 19 );
1928     memcpy(p, "[User id not found]", 19 );
1929     *rn = 19;
1930     return p;
1931 }
1932
1933