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