aa32dff74956ec610829f6a778b35071f867dc7b
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998, 1999, 2000 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
28 #include "util.h"
29 #include "packet.h"
30 #include <gcrypt.h>
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "options.h"
34 #include "main.h"
35 #include "trustdb.h"
36 #include "i18n.h"
37
38
39 #if 0
40 #define MAX_UNK_CACHE_ENTRIES 1000   /* we use a linked list - so I guess
41                                       * this is a reasonable limit */
42 #define MAX_PK_CACHE_ENTRIES    50
43 #endif
44 #define MAX_UID_CACHE_ENTRIES   50
45
46 /* A map of the all characters valid used for word_match()
47  * Valid characters are in in this table converted to uppercase.
48  * because the upper 128 bytes have special meaning, we assume
49  * that they are all valid.
50  * Note: We must use numerical values here in case that this program
51  * will be converted to those little blue HAL9000s with their strange
52  * EBCDIC character set (user ids are UTF-8).
53  * wk 2000-04-13: Hmmm, does this really make sense, given the fact that
54  * we can run gpg now on a S/390 running GNU/Linux, where the code
55  * translation is done by the device drivers?
56  */
57 static const byte word_match_chars[256] = {
58   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
59   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
60   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
61   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
62   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
63   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
64   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
65   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
66   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
67   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
68   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
69   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
70   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
71   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
72   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
73   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
74   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
75   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
76   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
77   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
78   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
79   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
80   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
81   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
82   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
83   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
84   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
85   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
86   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
87   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
88   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
89   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
90 };
91
92 typedef struct {
93     int mode;
94     u32 keyid[2];
95     byte fprint[20];
96     char *namebuf;
97     const char *name;
98 } getkey_item_t;
99
100 struct getkey_ctx_s {
101     /* make an array or a linked list from dome fields */
102     int primary;
103     KBNODE keyblock;
104     KBPOS kbpos;
105     KBNODE found_key; /* pointer into some keyblock */
106     int last_rc;
107     int req_usage;
108     int req_algo;
109     ulong count;
110     int not_allocated;
111     int nitems;
112     getkey_item_t items[1];
113 };
114
115
116
117
118
119 #if 0
120 static struct {
121     int any;
122     int okay_count;
123     int nokey_count;
124     int error_count;
125 } lkup_stats[21];
126 #endif
127
128 typedef struct keyid_list {
129     struct keyid_list *next;
130     u32 keyid[2];
131 } *keyid_list_t;
132
133
134 #if MAX_UNK_CACHE_ENTRIES
135   static keyid_list_t unknown_keyids;
136   static int unk_cache_entries;   /* number of entries in unknown keys cache */
137   static int unk_cache_disabled;
138 #endif
139
140 #if MAX_PK_CACHE_ENTRIES
141   typedef struct pk_cache_entry {
142       struct pk_cache_entry *next;
143       u32 keyid[2];
144       PKT_public_key *pk;
145   } *pk_cache_entry_t;
146   static pk_cache_entry_t pk_cache;
147   static int pk_cache_entries;   /* number of entries in pk cache */
148   static int pk_cache_disabled;
149 #endif
150
151 #if MAX_UID_CACHE_ENTRIES < 5
152     #error we really need the userid cache
153 #endif
154 typedef struct user_id_db {
155     struct user_id_db *next;
156     keyid_list_t keyids;
157     int len;
158     char name[1];
159 } *user_id_db_t;
160 static user_id_db_t user_id_db;
161 static int uid_cache_entries;   /* number of entries in uid cache */
162
163
164
165 static char* prepare_word_match( const byte *name );
166 static int lookup( GETKEY_CTX ctx, KBNODE *ret_kb, int secmode );
167
168
169 #if 0
170 static void
171 print_stats()
172 {
173     int i;
174     for(i=0; i < DIM(lkup_stats); i++ ) {
175         if( lkup_stats[i].any )
176             fprintf(stderr,
177                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
178                     i,
179                     lkup_stats[i].okay_count,
180                     lkup_stats[i].nokey_count,
181                     lkup_stats[i].error_count );
182     }
183 }
184 #endif
185
186
187 static void
188 cache_public_key( PKT_public_key *pk )
189 {
190   #if MAX_PK_CACHE_ENTRIES
191     pk_cache_entry_t ce;
192     u32 keyid[2];
193
194     if( pk_cache_disabled )
195         return;
196
197     if( is_ELGAMAL(pk->pubkey_algo)
198         || pk->pubkey_algo == GCRY_PK_DSA
199         || is_RSA(pk->pubkey_algo) ) {
200         keyid_from_pk( pk, keyid );
201     }
202     else
203         return; /* don't know how to get the keyid */
204
205     for( ce = pk_cache; ce; ce = ce->next )
206         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
207             if( DBG_CACHE )
208                 log_debug("cache_public_key: already in cache\n");
209             return;
210         }
211
212     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
213         /* fixme: use another algorithm to free some cache slots */
214         pk_cache_disabled=1;
215         if( opt.verbose > 1 )
216             log_info(_("too many entries in pk cache - disabled\n"));
217         return;
218     }
219     pk_cache_entries++;
220     ce = gcry_xmalloc( sizeof *ce );
221     ce->next = pk_cache;
222     pk_cache = ce;
223     ce->pk = copy_public_key( NULL, pk );
224     ce->keyid[0] = keyid[0];
225     ce->keyid[1] = keyid[1];
226   #endif
227 }
228
229 /*
230  * Return the user ID from the given keyblock.
231  * We use the primary uid flag which has been set by the merge_selfsigs
232  * function.  The returned value is only valid as long as then given
233  * keyblock is not changed
234  */
235 static const char *
236 get_primary_uid ( KBNODE keyblock, size_t *uidlen )
237 {
238     KBNODE k;
239
240     for (k=keyblock; k; k=k->next ) {
241         if ( k->pkt->pkttype == PKT_USER_ID
242              && k->pkt->pkt.user_id->is_primary ) {
243             *uidlen = k->pkt->pkt.user_id->len;
244             return k->pkt->pkt.user_id->name;
245         }
246     } 
247     *uidlen = 12;
248     return "[No user ID]";
249 }
250
251
252 static void
253 release_keyid_list ( keyid_list_t k )
254 {
255     while (  k ) {
256         keyid_list_t k2 = k->next;
257         gcry_free (k);
258         k = k2;
259     }
260 }
261
262 /****************
263  * Store the association of keyid and userid
264  * Feed only public keys to this function.
265  */
266 void
267 cache_user_id( KBNODE keyblock )
268 {
269     user_id_db_t r;
270     const char *uid;
271     size_t uidlen;
272     keyid_list_t keyids = NULL;
273     KBNODE k;
274
275     for (k=keyblock; k; k = k->next ) {
276         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
277              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
278             keyid_list_t a = gcry_xcalloc ( 1, sizeof *a );
279             /* Hmmm: For a long list of keyids it might be an advantage
280              * to append the keys */
281             keyid_from_pk( k->pkt->pkt.public_key, a->keyid );
282             /* first check for duplicates */
283             for(r=user_id_db; r; r = r->next ) {
284                 keyid_list_t b = r->keyids;
285                 for ( b = r->keyids; b; b = b->next ) {
286                     if( b->keyid[0] == a->keyid[0]
287                         && b->keyid[1] == a->keyid[1] ) {
288                         if( DBG_CACHE )
289                             log_debug("cache_user_id: already in cache\n");
290                         release_keyid_list ( keyids );
291                         gcry_free ( a );
292                         return;
293                     }
294                 }
295             }
296             /* now put it into the cache */
297             a->next = keyids;
298             keyids = a;
299         }
300     }
301     if ( !keyids )
302         BUG (); /* No key no fun */
303
304
305     uid = get_primary_uid ( keyblock, &uidlen );
306
307     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
308         /* fixme: use another algorithm to free some cache slots */
309         r = user_id_db;
310         user_id_db = r->next;
311         release_keyid_list ( r->keyids );
312         gcry_free(r);
313         uid_cache_entries--;
314     }
315     r = gcry_xmalloc( sizeof *r + uidlen-1 );
316     r->keyids = keyids;
317     r->len = uidlen;
318     memcpy(r->name, uid, r->len);
319     r->next = user_id_db;
320     user_id_db = r;
321     uid_cache_entries++;
322 }
323
324
325 void
326 getkey_disable_caches()
327 {
328   #if MAX_UNK_CACHE_ENTRIES
329     {
330         keyid_list_t kl, kl2;
331         for( kl = unknown_keyids; kl; kl = kl2 ) {
332             kl2 = kl->next;
333             gcry_free(kl);
334         }
335         unknown_keyids = NULL;
336         unk_cache_disabled = 1;
337     }
338   #endif
339   #if MAX_PK_CACHE_ENTRIES
340     {
341         pk_cache_entry_t ce, ce2;
342
343         for( ce = pk_cache; ce; ce = ce2 ) {
344             ce2 = ce->next;
345             free_public_key( ce->pk );
346             gcry_free( ce );
347         }
348         pk_cache_disabled=1;
349         pk_cache_entries = 0;
350         pk_cache = NULL;
351     }
352   #endif
353     /* fixme: disable user id cache ? */
354 }
355
356
357 static void
358 pk_from_block ( GETKEY_CTX ctx,
359                 PKT_public_key *pk, KBNODE keyblock, const char *namehash )
360 {
361     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
362
363     assert ( a->pkt->pkttype == PKT_PUBLIC_KEY
364              ||  a->pkt->pkttype == PKT_PUBLIC_SUBKEY );
365      
366     copy_public_key_new_namehash( pk, a->pkt->pkt.public_key, namehash);
367 }
368
369 static void
370 sk_from_block ( GETKEY_CTX ctx,
371                 PKT_secret_key *sk, KBNODE keyblock )
372 {
373     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
374
375     assert ( a->pkt->pkttype == PKT_SECRET_KEY
376              ||  a->pkt->pkttype == PKT_SECRET_SUBKEY );
377      
378     copy_secret_key( sk, a->pkt->pkt.secret_key);
379 }
380
381
382 /****************
383  * Get a public key and store it into the allocated pk
384  * can be called with PK set to NULL to just read it into some
385  * internal structures.
386  */
387 int
388 get_pubkey( PKT_public_key *pk, u32 *keyid )
389 {
390     int internal = 0;
391     int rc = 0;
392
393   #if MAX_UNK_CACHE_ENTRIES
394     {   /* let's see whether we checked the keyid already */
395         keyid_list_t kl;
396         for( kl = unknown_keyids; kl; kl = kl->next )
397             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
398                 return GPGERR_NO_PUBKEY; /* already checked and not found */
399     }
400   #endif
401
402   #if MAX_PK_CACHE_ENTRIES
403     {   /* Try to get it from the cache */
404         pk_cache_entry_t ce;
405         for( ce = pk_cache; ce; ce = ce->next ) {
406             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
407                 if( pk )
408                     copy_public_key( pk, ce->pk );
409                 return 0;
410             }
411         }
412     }
413   #endif
414     /* more init stuff */
415     if( !pk ) {
416         pk = gcry_xcalloc( 1, sizeof *pk );
417         internal++;
418     }
419
420
421     /* do a lookup */
422     {   struct getkey_ctx_s ctx;
423         KBNODE kb = NULL;
424         memset( &ctx, 0, sizeof ctx );
425         ctx.not_allocated = 1;
426         ctx.nitems = 1;
427         ctx.items[0].mode = 11;
428         ctx.items[0].keyid[0] = keyid[0];
429         ctx.items[0].keyid[1] = keyid[1];
430         ctx.req_algo  = pk->req_algo;
431         ctx.req_usage = pk->req_usage;
432         rc = lookup( &ctx, &kb, 0 );
433         if ( !rc ) {
434             pk_from_block ( &ctx, pk, kb, NULL );
435         }
436         get_pubkey_end( &ctx );
437         release_kbnode ( kb );
438     }
439     if( !rc )
440         goto leave;
441
442   #if MAX_UNK_CACHE_ENTRIES
443     /* not found: store it for future reference */
444     if( unk_cache_disabled )
445         ;
446     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
447         unk_cache_disabled = 1;
448         if( opt.verbose > 1 )
449             log_info(_("too many entries in unk cache - disabled\n"));
450     }
451     else {
452         keyid_list_t kl;
453
454         kl = gcry_xmalloc( sizeof *kl );
455         kl->keyid[0] = keyid[0];
456         kl->keyid[1] = keyid[1];
457         kl->next = unknown_keyids;
458         unknown_keyids = kl;
459     }
460   #endif
461     rc = GPGERR_NO_PUBKEY;
462
463   leave:
464     if( !rc )
465         cache_public_key( pk );
466     if( internal )
467         free_public_key(pk);
468     return rc;
469 }
470
471
472 KBNODE
473 get_pubkeyblock( u32 *keyid )
474 {
475     struct getkey_ctx_s ctx;
476     int rc = 0;
477     KBNODE keyblock = NULL;
478
479     memset( &ctx, 0, sizeof ctx );
480     ctx.not_allocated = 1;
481     ctx.nitems = 1;
482     ctx.items[0].mode = 11;
483     ctx.items[0].keyid[0] = keyid[0];
484     ctx.items[0].keyid[1] = keyid[1];
485     rc = lookup( &ctx, &keyblock, 0 );
486     get_pubkey_end( &ctx );
487
488     return rc ? NULL : keyblock;
489 }
490
491
492
493
494 /****************
495  * Get a secret key and store it into sk
496  */
497 int
498 get_seckey( PKT_secret_key *sk, u32 *keyid )
499 {
500     int rc;
501     struct getkey_ctx_s ctx;
502     KBNODE kb = NULL;
503
504     memset( &ctx, 0, sizeof ctx );
505     ctx.not_allocated = 1;
506     ctx.nitems = 1;
507     ctx.items[0].mode = 11;
508     ctx.items[0].keyid[0] = keyid[0];
509     ctx.items[0].keyid[1] = keyid[1];
510     ctx.req_algo  = sk->req_algo;
511     ctx.req_usage = sk->req_usage;
512     rc = lookup( &ctx, &kb, 1 );
513     if ( !rc ) {
514         sk_from_block ( &ctx, sk, kb );
515     }
516     get_seckey_end( &ctx );
517     release_kbnode ( kb );
518
519     if( !rc ) {
520         /* check the secret key (this may prompt for a passprase to
521          * unlock the secret key
522          */
523         rc = check_secret_key( sk, 0 );
524     }
525
526     return rc;
527 }
528
529
530 /****************
531  * Check whether the secret key is available
532  * Returns: 0 := key is available
533  *          GPGERR_NO_SECKEY := not availabe
534  */
535 int
536 seckey_available( u32 *keyid )
537 {
538     int rc;
539     struct getkey_ctx_s ctx;
540     KBNODE kb = NULL;
541
542     memset( &ctx, 0, sizeof ctx );
543     ctx.not_allocated = 1;
544     ctx.nitems = 1;
545     ctx.items[0].mode = 11;
546     ctx.items[0].keyid[0] = keyid[0];
547     ctx.items[0].keyid[1] = keyid[1];
548     rc = lookup( &ctx, &kb, 1 );
549     get_seckey_end( &ctx );
550     release_kbnode ( kb );
551     return rc;
552 }
553
554
555
556 static int
557 hextobyte( const byte *s )
558 {
559     int c;
560
561     if( *s >= '0' && *s <= '9' )
562         c = 16 * (*s - '0');
563     else if( *s >= 'A' && *s <= 'F' )
564         c = 16 * (10 + *s - 'A');
565     else if( *s >= 'a' && *s <= 'f' )
566         c = 16 * (10 + *s - 'a');
567     else
568         return -1;
569     s++;
570     if( *s >= '0' && *s <= '9' )
571         c += *s - '0';
572     else if( *s >= 'A' && *s <= 'F' )
573         c += 10 + *s - 'A';
574     else if( *s >= 'a' && *s <= 'f' )
575         c += 10 + *s - 'a';
576     else
577         return -1;
578     return c;
579 }
580
581
582
583 /****************
584  * Return the type of the user id:
585  *
586  *  0 = Invalid user ID
587  *  1 = exact match
588  *  2 = match a substring
589  *  3 = match an email address
590  *  4 = match a substring of an email address
591  *  5 = match an email address, but compare from end
592  *  6 = word match mode
593  * 10 = it is a short KEYID (don't care about keyid[0])
594  * 11 = it is a long  KEYID
595  * 12 = it is a trustdb index (keyid is looked up)
596  * 16 = it is a 16 byte fingerprint
597  * 20 = it is a 20 byte fingerprint
598  *
599  * if fprint is not NULL, it should be an array of at least 20 bytes.
600  *
601  * Rules used:
602  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
603  *   must be in the range 0..9), this is considered a keyid; depending
604  *   on the length a short or complete one.
605  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
606  *   must be in the range 0..9), this is considered a fingerprint.
607  * - If the username starts with a left angle, we assume it is a complete
608  *   email address and look only at this part.
609  * - If the username starts with a '.', we assume it is the ending
610  *   part of an email address
611  * - If the username starts with an '@', we assume it is a part of an
612  *   email address
613  * - If the userid start with an '=' an exact compare is done.
614  * - If the userid starts with a '*' a case insensitive substring search is
615  *   done (This is the default).
616  * - If the userid starts with a '+' we will compare individual words
617  *   and a match requires that all the words are in the userid.
618  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
619  *   (note that you can't search for these characters). Compare
620  *   is not case sensitive.
621  */
622
623 int
624 classify_user_id( const char *name, u32 *keyid, byte *fprint,
625                   const char **retstr, size_t *retlen )
626 {
627     const char *        s;
628     int                 mode = 0;
629     int                 hexprefix = 0;
630     int                 hexlength;
631
632     /* skip leading spaces.   FIXME: what is with leading spaces? */
633     for(s = name; *s && isspace(*s); s++ )
634         ;
635
636     switch (*s) {
637         case 0:    /* empty string is an error */
638             return 0;
639
640         case '.':  /* an email address, compare from end */
641             mode = 5;
642             s++;
643             break;
644
645         case '<':  /* an email address */
646             mode = 3;
647             break;
648
649         case '@':  /* part of an email address */
650             mode = 4;
651             s++;
652             break;
653
654         case '=':  /* exact compare */
655             mode = 1;
656             s++;
657             break;
658
659         case '*':  /* case insensitive substring search */
660             mode = 2;
661             s++;
662             break;
663
664         case '+':  /* compare individual words */
665             mode = 6;
666             s++;
667             break;
668
669         case '#':  /* local user id */
670             mode = 12;
671             s++;
672             if (keyid) {
673                 if (keyid_from_lid(strtoul(s, NULL, 10), keyid))
674                     keyid[0] = keyid[1] = 0;
675             }
676             break;
677
678         default:
679             if (s[0] == '0' && s[1] == 'x') {
680                 hexprefix = 1;
681                 s += 2;
682             }
683
684             hexlength = strspn(s, "0123456789abcdefABCDEF");
685
686             /* check if a hexadecimal number is terminated by EOS or blank */
687             if (hexlength && s[hexlength] && !isspace(s[hexlength])) {
688                 if (hexprefix)      /* a "0x" prefix without correct */
689                     return 0;       /* termination is an error */
690                 else                /* The first chars looked like */
691                     hexlength = 0;  /* a hex number, but really were not. */
692             }
693
694             if (hexlength == 8
695                 || (!hexprefix && hexlength == 9 && *s == '0')){
696                 /* short keyid */
697                 if (hexlength == 9)
698                     s++;
699                 if (keyid) {
700                     keyid[0] = 0;
701                     keyid[1] = strtoul( s, NULL, 16 );
702                 }
703                 mode = 10;
704             }
705             else if (hexlength == 16
706                      || (!hexprefix && hexlength == 17 && *s == '0')) {
707                 /* complete keyid */
708                 char buf[9];
709                 if (hexlength == 17)
710                     s++;
711                 mem2str(buf, s, 9 );
712                 keyid[0] = strtoul( buf, NULL, 16 );
713                 keyid[1] = strtoul( s+8, NULL, 16 );
714                 mode = 11;
715             }
716             else if (hexlength == 32 || (!hexprefix && hexlength == 33
717                                                             && *s == '0')) {
718                 /* md5 fingerprint */
719                 int i;
720                 if (hexlength == 33)
721                     s++;
722                 if (fprint) {
723                     memset(fprint+16, 4, 0);
724                     for (i=0; i < 16; i++, s+=2) {
725                         int c = hextobyte(s);
726                         if (c == -1)
727                             return 0;
728                         fprint[i] = c;
729                     }
730                 }
731                 mode = 16;
732             }
733             else if (hexlength == 40 || (!hexprefix && hexlength == 41
734                                                               && *s == '0')) {
735                 /* sha1/rmd160 fingerprint */
736                 int i;
737                 if (hexlength == 41)
738                     s++;
739                 if (fprint) {
740                     for (i=0; i < 20; i++, s+=2) {
741                         int c = hextobyte(s);
742                         if (c == -1)
743                             return 0;
744                         fprint[i] = c;
745                     }
746                 }
747                 mode = 20;
748             }
749             else {
750                 if (hexprefix)  /* This was a hex number with a prefix */
751                     return 0;   /* and a wrong length */
752
753                 mode = 2;   /* Default is case insensitive substring search */
754             }
755     }
756
757     if( retstr )
758         *retstr = s;
759     if( retlen )
760         *retlen = strlen(s);
761
762     return mode;
763 }
764
765
766
767 /****************
768  * Try to get the pubkey by the userid. This function looks for the
769  * first pubkey certificate which has the given name in a user_id.
770  * if pk/sk has the pubkey algo set, the function will only return
771  * a pubkey with that algo.
772  * The caller must provide provide storage for either the pk or the sk.
773  * If ret_kb is not NULL the funtion will return the keyblock there.
774  */
775
776 static int
777 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
778             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
779 {
780     int rc = 0;
781     int n;
782     STRLIST r;
783     GETKEY_CTX ctx;
784     KBNODE help_kb = NULL;
785     
786     if( retctx ) /* reset the returned context in case of error */
787         *retctx = NULL;
788
789     /* build the search context */
790     /* Performance hint: Use a static buffer if there is only one name */
791     /*                   and we don't have mode 6 */
792     for(n=0, r=namelist; r; r = r->next )
793         n++;
794     ctx = gcry_xcalloc( 1, sizeof *ctx + (n-1)*sizeof ctx->items );
795     ctx->nitems = n;
796
797     for(n=0, r=namelist; r; r = r->next, n++ ) {
798         int mode = classify_user_id( r->d,
799                                  ctx->items[n].keyid,
800                                  ctx->items[n].fprint,
801                                  &ctx->items[n].name,
802                                  NULL );
803
804         /* if we don't use one of the exact key specifications, we assume that
805          * the primary key is requested */
806         if ( mode != 10 && mode != 11 && mode != 16 && mode == 20 )
807             ctx->primary = 1; 
808
809         ctx->items[n].mode = mode;
810         if( !ctx->items[n].mode ) {
811             gcry_free( ctx );
812             return GPGERR_INV_USER_ID;
813         }
814         if( ctx->items[n].mode == 6 ) {
815             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
816             ctx->items[n].name = ctx->items[n].namebuf;
817         }
818     }
819
820
821
822     if ( !ret_kb ) 
823         ret_kb = &help_kb;
824
825     if( sk ) {
826         rc = lookup( ctx, ret_kb, 1 );
827         if ( !rc && sk ) {
828             sk_from_block ( ctx, sk, *ret_kb );
829         }
830     }
831     else {
832        
833         rc = lookup( ctx, ret_kb, 0 );
834         if ( !rc && pk ) {
835             pk_from_block ( ctx, pk, *ret_kb, NULL /* FIXME need to get the namehash*/ );
836         }
837     }
838
839     release_kbnode ( help_kb );
840
841     if( retctx ) /* caller wants the context */
842         *retctx = ctx;
843     else {
844         /* Hmmm, why not get_pubkey-end here?? */
845         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
846         for(n=0; n < ctx->nitems; n++ )
847             gcry_free( ctx->items[n].namebuf );
848         gcry_free( ctx );
849     }
850
851     return rc;
852 }
853
854 int
855 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
856                    const char *name, KBNODE *ret_keyblock )
857 {
858     int rc;
859     STRLIST namelist = NULL;
860
861     add_to_strlist( &namelist, name );
862     rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
863     free_strlist( namelist );
864     return rc;
865 }
866
867 int
868 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
869                     STRLIST names, KBNODE *ret_keyblock )
870 {
871     return key_byname( retctx, names, pk, NULL, ret_keyblock );
872 }
873
874 int
875 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
876 {
877     int rc;
878
879     rc = lookup( ctx, ret_keyblock, 0 );
880     if ( !rc && pk && ret_keyblock )
881         pk_from_block ( ctx, pk, *ret_keyblock, NULL );
882     
883     return rc;
884 }
885
886 void
887 get_pubkey_end( GETKEY_CTX ctx )
888 {
889     if( ctx ) {
890         int n;
891
892         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
893         for(n=0; n < ctx->nitems; n++ )
894             gcry_free( ctx->items[n].namebuf );
895         if( !ctx->not_allocated )
896             gcry_free( ctx );
897     }
898 }
899
900 /****************
901  * Search for a key with the given fingerprint.
902  */
903 int
904 get_pubkey_byfprint( PKT_public_key *pk,
905                      const byte *fprint, size_t fprint_len)
906 {
907     int rc;
908
909     if( fprint_len == 20 || fprint_len == 16 ) {
910         struct getkey_ctx_s ctx;
911         KBNODE kb = NULL;
912
913         memset( &ctx, 0, sizeof ctx );
914         ctx.not_allocated = 1;
915         ctx.nitems = 1;
916         ctx.items[0].mode = fprint_len;
917         memcpy( ctx.items[0].fprint, fprint, fprint_len );
918         rc = lookup( &ctx, &kb, 0 );
919         if (!rc && pk )
920             pk_from_block ( &ctx, pk, kb, NULL );
921         release_kbnode ( kb );
922         get_pubkey_end( &ctx );
923     }
924     else
925         rc = GPGERR_GENERAL; /* Oops */
926     return rc;
927 }
928
929 /****************
930  * Search for a key with the given fingerprint and return the
931  * complete keyblock which may have more than only this key.
932  */
933 int
934 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
935                                                 size_t fprint_len )
936 {
937     int rc;
938
939     if( fprint_len == 20 || fprint_len == 16 ) {
940         struct getkey_ctx_s ctx;
941
942         memset( &ctx, 0, sizeof ctx );
943         ctx.not_allocated = 1;
944         ctx.nitems = 1;
945         ctx.items[0].mode = fprint_len;
946         memcpy( ctx.items[0].fprint, fprint, fprint_len );
947         rc = lookup( &ctx, ret_keyblock, 0 );
948         get_pubkey_end( &ctx );
949     }
950     else
951         rc = GPGERR_GENERAL; /* Oops */
952
953     return rc;
954 }
955
956
957
958 /****************
959  * Search for a key with the given lid and return the entire keyblock
960  */
961 int
962 get_keyblock_bylid( KBNODE *ret_keyblock, ulong lid )
963 {
964     int rc;
965     struct getkey_ctx_s ctx;
966     u32 kid[2];
967
968     if( keyid_from_lid( lid, kid ) )
969         kid[0] = kid[1] = 0;
970     memset( &ctx, 0, sizeof ctx );
971     ctx.not_allocated = 1;
972     ctx.nitems = 1;
973     ctx.items[0].mode = 12;
974     ctx.items[0].keyid[0] = kid[0];
975     ctx.items[0].keyid[1] = kid[1];
976     rc = lookup( &ctx,  ret_keyblock, 0 );
977     get_pubkey_end( &ctx );
978
979     return rc;
980 }
981
982
983
984
985
986 /****************
987  * Get a secret key by name and store it into sk
988  * If NAME is NULL use the default key
989  */
990 int
991 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
992 {
993     STRLIST namelist = NULL;
994     int rc;
995
996     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
997         add_to_strlist( &namelist, opt.def_secret_key );
998         rc = key_byname( NULL, namelist, NULL, sk, NULL );
999     }
1000     else if( !name ) { /* use the first one as default key */
1001         struct getkey_ctx_s ctx;
1002         KBNODE kb = NULL;
1003
1004         memset( &ctx, 0, sizeof ctx );
1005         ctx.not_allocated = 1;
1006         ctx.primary = 1;
1007         ctx.nitems = 1;
1008         ctx.items[0].mode = 15;
1009         rc = lookup( &ctx, &kb, 1 );
1010         if (!rc && sk )
1011             sk_from_block ( &ctx, sk, kb );
1012         release_kbnode ( kb );
1013         get_seckey_end( &ctx );
1014     }
1015     else {
1016         add_to_strlist( &namelist, name );
1017         rc = key_byname( NULL, namelist, NULL, sk, NULL );
1018     }
1019
1020     free_strlist( namelist );
1021
1022     if( !rc && unprotect )
1023         rc = check_secret_key( sk, 0 );
1024
1025     return rc;
1026 }
1027
1028 int
1029 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
1030                     STRLIST names, KBNODE *ret_keyblock )
1031 {
1032     return key_byname( retctx, names, NULL, sk, ret_keyblock );
1033 }
1034
1035
1036 int
1037 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1038 {
1039     int rc;
1040
1041     rc = lookup( ctx, ret_keyblock, 1 );
1042     if ( !rc && sk && ret_keyblock )
1043         sk_from_block ( ctx, sk, *ret_keyblock );
1044
1045     return rc;
1046 }
1047
1048 void
1049 get_seckey_end( GETKEY_CTX ctx )
1050 {
1051     get_pubkey_end( ctx );
1052 }
1053
1054
1055 \f
1056 /*******************************************************
1057  ************** compare functions **********************
1058  *******************************************************/
1059
1060 /****************
1061  * Do a word match (original user id starts with a '+').
1062  * The pattern is already tokenized to a more suitable format:
1063  * There are only the real words in it delimited by one space
1064  * and all converted to uppercase.
1065  *
1066  * Returns: 0 if all words match.
1067  *
1068  * Note: This algorithm is a straightforward one and not very
1069  *       fast.  It works for UTF-8 strings.  The uidlen should
1070  *       be removed but due to the fact that old versions of
1071  *       pgp don't use UTF-8 we still use the length; this should
1072  *       be fixed in parse-packet (and replace \0 by some special
1073  *       UTF-8 encoding)
1074  */
1075 static int
1076 word_match( const byte *uid, size_t uidlen, const byte *pattern )
1077 {
1078     size_t wlen, n;
1079     const byte *p;
1080     const byte *s;
1081
1082     for( s=pattern; *s; ) {
1083         do {
1084             /* skip leading delimiters */
1085             while( uidlen && !word_match_chars[*uid] )
1086                 uid++, uidlen--;
1087             /* get length of the word */
1088             n = uidlen; p = uid;
1089             while( n && word_match_chars[*p] )
1090                 p++, n--;
1091             wlen = p - uid;
1092             /* and compare against the current word from pattern */
1093             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
1094                 if( word_match_chars[*p] != s[n] )
1095                     break;
1096             }
1097             if( n == wlen && (s[n] == ' ' || !s[n]) )
1098                 break; /* found */
1099             uid += wlen;
1100             uidlen -= wlen;
1101         } while( uidlen );
1102         if( !uidlen )
1103             return -1; /* not found */
1104
1105         /* advance to next word in pattern */
1106         for(; *s != ' ' && *s ; s++ )
1107             ;
1108         if( *s )
1109             s++ ;
1110     }
1111     return 0; /* found */
1112 }
1113
1114 /****************
1115  * prepare word word_match; that is parse the name and
1116  * build the pattern.
1117  * caller has to free the returned pattern
1118  */
1119 static char*
1120 prepare_word_match( const byte *name )
1121 {
1122     byte *pattern, *p;
1123     int c;
1124
1125     /* the original length is always enough for the pattern */
1126     p = pattern = gcry_xmalloc(strlen(name)+1);
1127     do {
1128         /* skip leading delimiters */
1129         while( *name && !word_match_chars[*name] )
1130             name++;
1131         /* copy as long as we don't have a delimiter and convert
1132          * to uppercase.
1133          * fixme: how can we handle utf8 uppercasing */
1134         for( ; *name &&  (c=word_match_chars[*name]); name++ )
1135             *p++ = c;
1136         *p++ = ' '; /* append pattern delimiter */
1137     } while( *name );
1138     p[-1] = 0; /* replace last pattern delimiter by EOS */
1139
1140     return pattern;
1141 }
1142
1143
1144
1145
1146
1147 static int
1148 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
1149 {
1150     int i;
1151     const char *s, *se;
1152
1153     if( mode == 1 ) {  /* exact match */
1154         for(i=0; name[i] && uidlen; i++, uidlen-- )
1155             if( uid[i] != name[i] )
1156                 break;
1157         if( !uidlen && !name[i] )
1158             return 0; /* found */
1159     }
1160     else if( mode == 2 ) { /* case insensitive substring */
1161         if( memistr( uid, uidlen, name ) )
1162             return 0;
1163     }
1164     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1165         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1166             ;
1167         if( i < uidlen )  {
1168             /* skip opening delim and one char and look for the closing one*/
1169             s++; i++;
1170             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1171                 ;
1172             if( i < uidlen ) {
1173                 i = se - s;
1174                 if( mode == 3 ) { /* exact email address */
1175                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1176                         return 0;
1177                 }
1178                 else if( mode == 4 ) {  /* email substring */
1179                     if( memistr( s, i, name ) )
1180                         return 0;
1181                 }
1182                 else { /* email from end */
1183                     /* nyi */
1184                 }
1185             }
1186         }
1187     }
1188     else if( mode == 6 )
1189         return word_match( uid, uidlen, name );
1190     else
1191         BUG();
1192
1193     return -1; /* not found */
1194 }
1195
1196
1197
1198 \f
1199 /************************************************
1200  ************* Merging stuff ********************
1201  ************************************************/
1202
1203 /****************
1204  * merge all selfsignatures with the keys.
1205  * FIXME: replace this at least for the public key parts
1206  *        by merge_selfsigs
1207  */
1208 void
1209 merge_keys_and_selfsig( KBNODE keyblock )
1210 {
1211     PKT_public_key *pk = NULL;
1212     PKT_secret_key *sk = NULL;
1213     PKT_signature *sig;
1214     KBNODE k;
1215     u32 kid[2] = { 0, 0 };
1216     u32 sigdate = 0;
1217
1218     for(k=keyblock; k; k = k->next ) {
1219         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1220             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1221             pk = k->pkt->pkt.public_key; sk = NULL;
1222             if( pk->version < 4 )
1223                 pk = NULL; /* not needed for old keys */
1224             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1225                 keyid_from_pk( pk, kid );
1226             else if( !pk->expiredate ) { /* and subkey */
1227                 /* insert the expiration date here */
1228                 /*FIXME!!! pk->expiredate = subkeys_expiretime( k, kid );*/
1229             }
1230             sigdate = 0;
1231         }
1232         else if( k->pkt->pkttype == PKT_SECRET_KEY
1233             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1234             pk = NULL; sk = k->pkt->pkt.secret_key;
1235             if( sk->version < 4 )
1236                 sk = NULL;
1237             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1238                 keyid_from_sk( sk, kid );
1239             sigdate = 0;
1240         }
1241         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1242                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1243                  && sig->sig_class <= 0x30 && sig->version > 3
1244                  && !(sig->sig_class == 0x18 || sig->sig_class == 0x28)
1245                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1246             /* okay this is a self-signature which can be used.
1247              * This is not used for subkey binding signature, becuase this
1248              * is done above.
1249              * FIXME: We should only use this if the signature is valid
1250              *        but this is time consuming - we must provide another
1251              *        way to handle this
1252              */
1253             const byte *p;
1254             u32 ed;
1255
1256             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1257             if( pk ) {
1258                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1259                 if( sig->timestamp > sigdate ) {
1260                     pk->expiredate = ed;
1261                     sigdate = sig->timestamp;
1262                 }
1263             }
1264             else {
1265                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1266                 if( sig->timestamp > sigdate ) {
1267                     sk->expiredate = ed;
1268                     sigdate = sig->timestamp;
1269                 }
1270             }
1271         }
1272     }
1273 }
1274
1275
1276 static void
1277 fixup_uidnode ( KBNODE uidnode, KBNODE signode )
1278 {
1279     PKT_user_id   *uid = uidnode->pkt->pkt.user_id;
1280     PKT_signature *sig = signode->pkt->pkt.signature;
1281     const byte *p;
1282     size_t n;
1283
1284     uid->created = 0; /* not created == invalid */
1285     if ( !signode ) 
1286         return; /* no self-signature */
1287     if ( IS_UID_REV ( sig ) )
1288         return; /* has been revoked */
1289
1290     uid->created = sig->timestamp; /* this one is okay */    
1291  
1292         
1293     /* store the key flags in the helper variable for later processing */
1294     uid->help_key_usage = 0;
1295     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1296     if ( p && n ) {
1297         /* first octet of the keyflags */   
1298         if ( (*p & 3) )
1299             uid->help_key_usage |= GCRY_PK_USAGE_SIGN;
1300         if ( (*p & 12) )    
1301             uid->help_key_usage |= GCRY_PK_USAGE_ENCR;
1302     }
1303
1304     /* ditto or the key expiration */
1305     uid->help_key_expire = 0;
1306     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL);
1307     if ( p ) {
1308         uid->help_key_expire = sig->timestamp + buffer_to_u32(p);
1309     }
1310
1311     /* Set the primary user ID flag - we will later wipe out some
1312      * of them to only have one in out keyblock */
1313     uid->is_primary = 0;
1314     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_PRIMARY_UID, NULL );
1315     if ( p && *p )
1316         uid->is_primary = 1;
1317     /* We could also query this from the unhashed area if it is not in
1318      * the hased area and then later try to decide which is the better
1319      * there should be no security problem with this.
1320      * For now we only look at the hashed one. 
1321      */
1322 }
1323
1324 static void
1325 merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
1326 {
1327     PKT_public_key *pk = NULL;
1328     KBNODE k;
1329     u32 kid[2];
1330     u32 sigdate = 0, uiddate=0, uiddate2;
1331     KBNODE signode, uidnode, uidnode2;
1332     u32 curtime = make_timestamp ();
1333     unsigned int key_usage = 0;
1334     u32 key_expire = 0;
1335     int key_expire_seen = 0;
1336
1337     *r_revoked = 0;
1338     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1339         BUG ();
1340     pk = keyblock->pkt->pkt.public_key;
1341     pk->created = 0;
1342     keyid_from_pk( pk, kid );
1343     pk->main_keyid[0] = kid[0];
1344     pk->main_keyid[1] = kid[1];
1345
1346     if ( pk->version < 4 ) {
1347         /* before v4 the key packet itself contains the expiration date
1348          * and there was noway to change it.  So we also use only the
1349          * one from the key packet */
1350         key_expire = pk->expiredate;
1351         key_expire_seen = 1;
1352     }
1353
1354     /* first pass: find the latest direct key self-signature.
1355      * We assume that the newest one overrides all others
1356      */
1357     signode = NULL;
1358     sigdate = 0; /* helper to find the latest signature */
1359     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1360         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1361             PKT_signature *sig = k->pkt->pkt.signature;
1362             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1363                 if ( check_key_signature( keyblock, k, NULL ) )
1364                     ; /* signature did not verify */
1365                 else if ( IS_KEY_REV (sig) ){
1366                     /* key has been revoked - there is no way to override
1367                      * such a revocation, so we can stop now.
1368                      * we can't cope with expiration times for revocations
1369                      * here because we have to assumethat an attacker can
1370                      * generate all kinds of signatures.
1371                      */ 
1372                     *r_revoked = 1;
1373                     return;
1374                 }
1375                 else if ( IS_KEY_SIG (sig) && sig->timestamp >= sigdate ) {
1376                     const byte *p;
1377                     
1378                     p = parse_sig_subpkt( sig->hashed_data,
1379                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1380                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1381                         ; /* signature has expired - ignore it */
1382                     else {
1383                         sigdate = sig->timestamp;
1384                         signode = k;
1385                     }
1386                 }
1387             }
1388         }
1389     }
1390
1391     if ( signode ) {
1392         /* some information from a direct key signature take precedence
1393          * over the same information given in UID sigs.
1394          */
1395         PKT_signature *sig = signode->pkt->pkt.signature;
1396         const byte *p;
1397         size_t n;
1398         
1399         p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1400         if ( p && n ) {
1401             /* first octet of the keyflags */   
1402             if ( (*p & 3) )
1403                 key_usage |= GCRY_PK_USAGE_SIGN;
1404             if ( (*p & 12) )    
1405                 key_usage |= GCRY_PK_USAGE_ENCR;
1406         }
1407
1408         if ( pk->version > 3 ) {
1409             p = parse_sig_subpkt ( sig->hashed_data,
1410                                    SIGSUBPKT_KEY_EXPIRE, NULL);
1411             if ( p ) {
1412                 key_expire = sig->timestamp + buffer_to_u32(p);
1413                 key_expire_seen = 1;
1414             }
1415         }
1416         /* and set the created field */
1417         pk->created = sigdate;
1418         /* and mark that key as valid: one direct key signature should 
1419          * render a key as valid */
1420         pk->is_valid = 1;
1421     }
1422
1423
1424     /* second pass: look at the self-signature of all user IDs */
1425     signode = uidnode = NULL;
1426     sigdate = 0; /* helper to find the latest signature in one user ID */
1427     uiddate = 0; /* and over of all user IDs */
1428     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1429         if ( k->pkt->pkttype == PKT_USER_ID
1430              || k->pkt->pkttype == PKT_PHOTO_ID ) {
1431             if ( uidnode ) 
1432                 fixup_uidnode ( uidnode, signode );
1433             uidnode = k;
1434             signode = NULL;
1435             if ( sigdate > uiddate )
1436                 uiddate = sigdate;
1437             sigdate = 0;
1438         }
1439         else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode ) {
1440             PKT_signature *sig = k->pkt->pkt.signature;
1441             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1442                 if ( check_key_signature( keyblock, k, NULL ) )
1443                     ; /* signature did not verify */
1444                 else if ( IS_UID_SIG (sig) || IS_UID_REV (sig)) {
1445                     /* Note: we allow to invalidated cert revocations
1446                      * by a newer signature.  An attacker can't use this
1447                      * because a key should be revoced with a key revocation.
1448                      * The reason why we have to allow for that is that at
1449                      * one time an email address may become invalid but later
1450                      * the same email address may become valid again (hired,
1451                      * fired, hired again).
1452                      */                    
1453                     const byte *p;
1454                     
1455                     p = parse_sig_subpkt( sig->hashed_data,
1456                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1457                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1458                         ; /* signature/revocation has expired - ignore it */
1459                     else {
1460                         sigdate = sig->timestamp;
1461                         signode = k;
1462                     }
1463                 }
1464             }
1465         }
1466     }
1467     if ( uidnode ) {
1468         fixup_uidnode ( uidnode, signode );
1469         pk->is_valid = 1;
1470     }
1471     if ( sigdate > uiddate )
1472         uiddate = sigdate;
1473     /* if we do not have a direct key signature, take the key creation date
1474      * from the latest user ID.  Hmmm, another possibilty would be to take 
1475      * it from the latest primary user ID - but we don't implement it for
1476      * now */
1477     if ( !pk->created )
1478         pk->created = uiddate;
1479     if ( !pk->created ) {
1480         /* oops, still no creation date: use the timestamp */
1481         if (DBG_CACHE)
1482             log_debug( "merge_selfsigs_main: "
1483                        "using timestamp as creation date\n");    
1484         pk->created = pk->timestamp;
1485     }
1486
1487     /* Now that we had a look at all user IDs we can now get some information
1488      * from those user IDs.
1489      */
1490     
1491     if ( !key_usage ) {
1492         /* find the latest user ID with key flags set */
1493         uiddate = 0; /* helper to find the latest user ID */
1494         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1495             k = k->next ) {
1496             if ( k->pkt->pkttype == PKT_USER_ID
1497                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1498                 PKT_user_id *uid = k->pkt->pkt.user_id;
1499                 if ( uid->help_key_usage && uid->created > uiddate ) {
1500                     key_usage = uid->help_key_usage;
1501                     uiddate = uid->created;
1502                 }
1503             }
1504         }
1505     }
1506     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1507         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1508     }
1509     else { /* check that the usage matches the usage as given by the algo */
1510         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1511         if ( x ) /* mask it down to the actual allowed usage */
1512             key_usage &= x; 
1513     }
1514     pk->pubkey_usage = key_usage;
1515
1516
1517     if ( !key_expire_seen ) {
1518         /* find the latest valid user ID with a key expiration set 
1519          * Note, that this may be a diferent one from the above because
1520          * some user IDs may have no expiration date set */
1521         uiddate = 0; 
1522         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1523             k = k->next ) {
1524             if ( k->pkt->pkttype == PKT_USER_ID
1525                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1526                 PKT_user_id *uid = k->pkt->pkt.user_id;
1527                 if ( uid->help_key_expire && uid->created > uiddate ) {
1528                     key_expire = uid->help_key_expire;
1529                     uiddate = uid->created;
1530                 }
1531             }
1532         }
1533     }
1534    
1535     pk->has_expired = key_expire >= curtime? 0 : key_expire;
1536     /* FIXME: we should see how to get rid of the expiretime fields */
1537
1538
1539     /* and now find the real primary user ID and delete all others */
1540     uiddate = uiddate2 = 0;
1541     uidnode = uidnode2 = NULL;
1542     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1543         if ( k->pkt->pkttype == PKT_USER_ID
1544              || k->pkt->pkttype == PKT_PHOTO_ID ) {
1545             PKT_user_id *uid = k->pkt->pkt.user_id;
1546             if ( uid->is_primary && uid->created > uiddate ) {
1547                 uiddate = uid->created;
1548                 uidnode = k;
1549             }
1550             if ( !uid->is_primary && uid->created > uiddate2 ) {
1551                 uiddate2 = uid->created;
1552                 uidnode2 = k;
1553             }
1554         }
1555     }
1556     if ( uidnode ) {
1557         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1558             k = k->next ) {
1559             if ( k->pkt->pkttype == PKT_USER_ID
1560                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1561                 PKT_user_id *uid = k->pkt->pkt.user_id;
1562                 if ( k != uidnode ) 
1563                     uid->is_primary = 0;
1564             }
1565         }
1566     }
1567     else if( uidnode2 ) {
1568         /* none is flagged primary - use the latest user ID we have */
1569         uidnode2->pkt->pkt.user_id->is_primary = 1;
1570     }
1571
1572 }
1573
1574
1575 static void
1576 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
1577 {
1578     PKT_public_key *mainpk = NULL, *subpk = NULL;
1579     PKT_signature *sig;
1580     KBNODE k;
1581     u32 mainkid[2];
1582     u32 sigdate = 0;
1583     KBNODE signode;
1584     u32 curtime = make_timestamp ();
1585     unsigned int key_usage = 0;
1586     u32 key_expire = 0;
1587     const byte *p;
1588     size_t n;
1589
1590     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1591         BUG ();
1592     mainpk = keyblock->pkt->pkt.public_key;
1593     if ( mainpk->version < 4 )
1594         return; /* (actually this should never happen) */
1595     keyid_from_pk( mainpk, mainkid );
1596     subpk = subnode->pkt->pkt.public_key;
1597     subpk->is_valid = 0;
1598     subpk->main_keyid[0] = mainpk->main_keyid[0];
1599     subpk->main_keyid[1] = mainpk->main_keyid[1];
1600     if ( subpk->version < 4 )
1601         return; /* there are no v3 subkeys */
1602
1603     /* find the latest key binding self-signature. */
1604     signode = NULL;
1605     sigdate = 0; /* helper to find the latest signature */
1606     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1607                                                         k = k->next ) {
1608         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1609             sig = k->pkt->pkt.signature;
1610             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) { 
1611                 if ( check_key_signature( keyblock, k, NULL ) )
1612                     ; /* signature did not verify */
1613                 else if ( IS_SUBKEY_REV (sig) ) {
1614                     /* key has been revoked - given the fact that it is easy
1615                      * to create a new subkey, it does not make sense to
1616                      * revive a revoked key.  So we can stop here.
1617                      */
1618                     subpk->is_revoked = 1;
1619                     return;
1620                 }
1621                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate ) {
1622                     p = parse_sig_subpkt( sig->hashed_data,
1623                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1624                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1625                         ; /* signature has expired - ignore it */
1626                     else {
1627                         sigdate = sig->timestamp;
1628                         signode = k;
1629                     }
1630                 }
1631             }
1632         }
1633     }
1634
1635     if ( !signode ) {
1636         subpk->created = subpk->timestamp;
1637         return;  /* no valid key binding */
1638     }
1639
1640     subpk->is_valid = 1;
1641     subpk->created = sigdate; 
1642     sig = signode->pkt->pkt.signature;
1643         
1644     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1645     if ( p && n ) {
1646         /* first octet of the keyflags */   
1647         if ( (*p & 3) )
1648             key_usage |= GCRY_PK_USAGE_SIGN;
1649         if ( (*p & 12) )    
1650             key_usage |= GCRY_PK_USAGE_ENCR;
1651     }
1652     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1653         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1654     }
1655     else { /* check that the usage matches the usage as given by the algo */
1656         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1657         if ( x ) /* mask it down to the actual allowed usage */
1658             key_usage &= x; 
1659     }
1660     subpk->pubkey_usage = key_usage;
1661     
1662     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL);
1663     if ( p ) 
1664         key_expire = sig->timestamp + buffer_to_u32(p);
1665     else
1666         key_expire = 0;
1667     subpk->has_expired = key_expire >= curtime? 0 : key_expire;
1668 }
1669
1670
1671
1672 /* 
1673  * Merge information from the self-signatures with the key, so that
1674  * we can later use them more easy.
1675  * The function works by first applying the self signatures to the
1676  * primary key and the to each subkey.
1677  * Here are the rules we use to decide which inormation from which
1678  * self-signature is used:
1679  * We check all self signatures or validity and ignore all invalid signatures.
1680  * All signatures are then ordered by their creation date ....
1681  * For the primary key:
1682  *   FIXME the docs    
1683  */
1684 static void
1685 merge_selfsigs( KBNODE keyblock )
1686 {
1687     KBNODE k;
1688     int revoked;
1689     PKT_public_key *main_pk;
1690
1691     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1692         BUG ();
1693
1694     merge_selfsigs_main ( keyblock, &revoked );
1695     main_pk = keyblock->pkt->pkt.public_key;
1696     if ( revoked ) {
1697         /* if the primary key has been revoked we better set the revoke
1698          * flag on that key and all subkeys */
1699         for(k=keyblock; k; k = k->next ) {
1700             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1701                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1702                 PKT_public_key *pk = k->pkt->pkt.public_key;
1703                 pk->is_revoked = 1;
1704                 pk->main_keyid[0] = main_pk->main_keyid[0];
1705                 pk->main_keyid[1] = main_pk->main_keyid[1];
1706             }
1707         }
1708         return;
1709     }
1710
1711     /* now merge in the data from each of the subkeys */
1712     for(k=keyblock; k; k = k->next ) {
1713         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1714             merge_selfsigs_subkey ( keyblock, k );
1715         }
1716     }
1717 }
1718
1719
1720 /*
1721  * Merge the secret keys from secblock into the pubblock thereby
1722  * replacing the public (sub)keys with their secret counterparts Hmmm:
1723  * It might be better to get away from the concept of entire secret
1724  * keys at all and have a way to store just the real secret parts
1725  * from the key.
1726  */
1727 void
1728 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
1729 {
1730     KBNODE pub;
1731     int deleting = 0;
1732     int any_deleted = 0;
1733
1734     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
1735     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
1736     
1737     for (pub=pubblock; pub; pub = pub->next ) {
1738         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
1739              PKT_public_key *pk = pub->pkt->pkt.public_key;
1740              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
1741              assert ( pub == pubblock ); /* only in the first node */
1742              /* there is nothing to compare in this case, so just replace
1743               * some information */
1744              copy_public_parts_to_secret_key ( pk, sk );
1745              free_public_key ( pk );
1746              pub->pkt->pkttype = PKT_SECRET_KEY;
1747              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
1748         }
1749         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1750             KBNODE sec;
1751             PKT_public_key *pk = pub->pkt->pkt.public_key;
1752
1753             deleting = 0;
1754             /* this is more complicated: it may happen that the sequence
1755              * of the subkeys dosn't match, so we have to find the
1756              * appropriate secret key */
1757             for (sec=secblock->next; sec; sec = sec->next ) {
1758                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1759                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
1760                     if ( !cmp_public_secret_key ( pk, sk ) ) {
1761                         copy_public_parts_to_secret_key ( pk, sk );
1762                         free_public_key ( pk );
1763                         pub->pkt->pkttype = PKT_SECRET_KEY;
1764                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
1765                         break;
1766                     }
1767                 }
1768             }
1769             if ( !sec ) {
1770                 log_error ( "no corresponding secret subkey "
1771                             "for public subkey - removing\n" );
1772                 /* better remove the public subkey in this case */
1773                 delete_kbnode ( pub );
1774                 deleting = 1;
1775                 any_deleted = 1;
1776             }
1777         }
1778         else if ( deleting ) {
1779             delete_kbnode (pub);
1780         }
1781     }
1782
1783     if ( any_deleted ) {
1784         /* because we have not deleted the root node, we don't need to
1785          * update the pubblock */
1786         pub = pubblock;
1787         commit_kbnode ( &pubblock );
1788         assert ( pub == pubblock );
1789     }
1790 }
1791
1792
1793
1794 \f
1795 /************************************************
1796  ************* Find stuff ***********************
1797  ************************************************/
1798
1799 static int 
1800 find_by_name( KBNODE keyblock, const char *name,
1801               int mode, byte *namehash )
1802 {
1803     KBNODE k;
1804
1805     for(k=keyblock; k; k = k->next ) {
1806         if( k->pkt->pkttype == PKT_USER_ID
1807             && !compare_name( k->pkt->pkt.user_id->name,
1808                               k->pkt->pkt.user_id->len, name, mode)) {
1809             /* we found a matching name, look for the key */
1810             if( k->pkt->pkt.user_id->photo ) {
1811                 /* oops: this can never happen */
1812                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1813                                      k->pkt->pkt.user_id->photo,
1814                                      k->pkt->pkt.user_id->photolen );
1815             }
1816             else {
1817                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1818                                      k->pkt->pkt.user_id->name,
1819                                      k->pkt->pkt.user_id->len );
1820             }
1821             return 1; 
1822         }
1823     }
1824     
1825     return 0;
1826 }
1827
1828
1829
1830 static KBNODE
1831 find_by_keyid( KBNODE keyblock, u32 *keyid, int mode )
1832 {
1833     KBNODE k;
1834
1835     for(k=keyblock; k; k = k->next ) {
1836         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1837             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1838             u32 aki[2];
1839             keyid_from_pk( k->pkt->pkt.public_key, aki );
1840             if( aki[1] == keyid[1] && ( mode == 10 || aki[0] == keyid[0] ) ) {
1841                 return k; /* found */
1842             }
1843         }
1844     }
1845     return NULL;
1846 }
1847
1848
1849
1850 static KBNODE
1851 find_by_fpr( KBNODE keyblock,  const char *name, int mode )
1852 {
1853     KBNODE k;
1854
1855     for(k=keyblock; k; k = k->next ) {
1856         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1857             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1858             byte afp[MAX_FINGERPRINT_LEN];
1859             size_t an;
1860
1861             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1862             if( an == mode && !memcmp( afp, name, an) ) {
1863                 return k;
1864             }
1865         }
1866     }
1867     return NULL;
1868 }
1869
1870
1871
1872
1873 /* See see whether the key fits
1874  * our requirements and in case we do not
1875  * request a the primary key, we should select
1876  * a suitable subkey.
1877  * FIXME: Check against PGP 7 whether we still need a kludge
1878  *        to favor type 16 keys over type 20 keys when type 20
1879  *        has not been explitely requested.
1880  * Returns: True when a suitable key has been found.
1881  *
1882  * We have to distinguish four cases:
1883  *  1. No usage and no primary key requested
1884  *     Examples for this case are that we have a keyID to be used
1885  *     for decrytion or verification.
1886  *  2. No usage but primary key requested
1887  *     This is the case for all functions which work on an
1888  *     entire keyblock, e.g. for editing or listing
1889  *  3. Usage and primary key requested
1890  *     FXME
1891  *  4. Usage but no primary key requested
1892  *     FIXME
1893  * FIXME: Tell what is going to happen here and something about the rationale
1894  *
1895  */
1896
1897 static int
1898 finish_lookup( GETKEY_CTX ctx,  KBNODE foundk )
1899 {
1900     KBNODE keyblock = ctx->keyblock;
1901     KBNODE k;
1902   #define USAGE_MASK  (GCRY_PK_USAGE_SIGN|GCRY_PK_USAGE_ENCR)
1903     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
1904     u32 latest_date;
1905     KBNODE latest_key;
1906
1907     assert( !foundk || foundk->pkt->pkttype == PKT_PUBLIC_KEY
1908                     || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1909     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1910    
1911     ctx->found_key = NULL;
1912     
1913     if ( DBG_CACHE )
1914         log_debug( "finish_lookup: checking %s (req_usage=%x)\n",
1915                    foundk? "one key":"all keys", req_usage);
1916
1917     latest_date = 0;
1918     latest_key  = NULL;
1919     /* We do check the subkeys only if we either have requested a specific
1920      * usage or have not requested to get the primary key. */
1921     if ( (req_usage || !ctx->primary)
1922          && (!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) ) {
1923         KBNODE nextk;
1924         /* either start a loop or check just this one subkey */
1925         for (k=foundk?foundk:keyblock; k; k = nextk ) {
1926             PKT_public_key *pk;
1927             nextk = k->next;
1928             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1929                 continue;
1930             if ( foundk )
1931                 nextk = NULL;  /* what a hack */
1932             pk = k->pkt->pkt.public_key;
1933             if ( !pk->is_valid ) {
1934                 if (DBG_CACHE)
1935                     log_debug( "\tsubkey not valid\n");
1936                 continue;
1937             }
1938             if ( pk->is_revoked ) {
1939                 if (DBG_CACHE)
1940                     log_debug( "\tsubkey has been revoked\n");
1941                 continue;
1942             }
1943             if ( pk->has_expired ) {
1944                 if (DBG_CACHE)
1945                     log_debug( "\tsubkey has expired\n");
1946                 continue;
1947             }
1948             
1949             if ( req_usage &&
1950                  !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
1951                 if (DBG_CACHE)
1952                     log_debug( "\tusage does not match: want=%x have=%x\n",
1953                                req_usage, pk->pubkey_usage );
1954                 continue;
1955             }
1956
1957             if (DBG_CACHE)
1958                 log_debug( "\tconsidering key %08lX\n",
1959                            (ulong)keyid_from_pk( pk, NULL));
1960             if ( pk->created > latest_date ) {
1961                 latest_date = pk->created;
1962                 latest_key  = k;
1963             }
1964         }
1965     }
1966
1967     if ( !latest_key ) {
1968         PKT_public_key *pk;
1969         if (DBG_CACHE && !foundk )
1970             log_debug( "\tno suitable subkeys found - trying primary\n");
1971         pk = keyblock->pkt->pkt.public_key;
1972         if ( !pk->is_valid ) {
1973             if (DBG_CACHE)
1974                 log_debug( "\tprimary key not valid\n");
1975         }
1976         else if ( pk->is_revoked ) {
1977             if (DBG_CACHE)
1978                 log_debug( "\tprimary key has been revoked\n");
1979         }
1980         else if ( pk->has_expired ) {
1981             if (DBG_CACHE)
1982                 log_debug( "\tprimary key has expired\n");
1983         }
1984         else  if ( req_usage
1985                    && !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
1986             if (DBG_CACHE)
1987                 log_debug( "\tusage does not match: want=%x have=%x\n",
1988                            req_usage, pk->pubkey_usage );
1989         }
1990         else { /* okay */
1991             if (DBG_CACHE)
1992                 log_debug( "\tprimary key may be used\n");
1993             latest_key = keyblock;
1994             latest_date = pk->created;
1995         }
1996     }
1997     
1998     if ( !latest_key ) {
1999         if (DBG_CACHE)
2000             log_debug("\tno suitable key found -  giving up\n");
2001         return 0;
2002     }
2003
2004     if (DBG_CACHE)
2005         log_debug( "\tusing key %08lX\n",
2006                 (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL) );
2007
2008     ctx->found_key = latest_key;
2009
2010     if ( latest_key != keyblock ) {
2011         log_info(_("using secondary key %08lX "
2012                    "instead of primary key %08lX\n"),
2013                  (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL),
2014                  (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL) );
2015     }
2016
2017     cache_user_id( keyblock );
2018     
2019     return 1; /* found */
2020 }
2021
2022  
2023 static int
2024 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2025 {
2026     int rc;
2027     int oldmode = set_packet_list_mode(0);
2028     byte namehash[20];
2029     int use_namehash=0;
2030     KBNODE secblock = NULL; /* helper */
2031
2032     if( !ctx->count ) /* first time */
2033         rc = enum_keyblocks( secmode?5:0, &ctx->kbpos, &ctx->keyblock );
2034     else
2035         rc = 0;
2036     if( !rc ) {
2037         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
2038             int n;
2039             getkey_item_t *item;
2040
2041             if ( secmode ) {
2042                 /* find the correspondig public key and use this 
2043                  * this one for the selection process */
2044                 u32 aki[2];
2045                 KBNODE k = ctx->keyblock;
2046                 
2047                 if ( k->pkt->pkttype != PKT_SECRET_KEY )
2048                     BUG();
2049                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
2050                 k = get_pubkeyblock( aki );
2051                 if( !k ) {
2052                     log_info(_("key %08lX: secret key without public key "
2053                                "- skipped\n"),  (ulong)aki[1] );
2054                     goto skip;
2055                 }
2056                 secblock = ctx->keyblock;
2057                 ctx->keyblock = k;
2058             }
2059
2060
2061             /* loop over all the user ids we want to look for */
2062             item = ctx->items;
2063             for(n=0; n < ctx->nitems; n++, item++ ) {
2064                 KBNODE k = NULL;
2065                 int found = 0;
2066     
2067                 if( item->mode < 10 ) {
2068                     found = find_by_name( ctx->keyblock,
2069                                           item->name, item->mode,
2070                                           namehash );
2071                     use_namehash = found;
2072                 }
2073                 else if( item->mode >= 10 && item->mode <= 12 ) {
2074                     k = find_by_keyid( ctx->keyblock, 
2075                                        item->keyid, item->mode );
2076                     found = !!k;
2077                 }
2078                 else if( item->mode == 15 ) {
2079                     found = 1;
2080                 }
2081                 else if( item->mode == 16 || item->mode == 20 ) {
2082                     k = find_by_fpr( ctx->keyblock,
2083                                      item->fprint, item->mode );
2084                     found = !!k;
2085                 }
2086                 else
2087                     BUG();
2088                 if( found ) { 
2089                     /* this keyblock looks fine - do further investigation */
2090                     merge_selfsigs ( ctx->keyblock );
2091                     if ( finish_lookup( ctx, k ) ) {
2092                         if ( secmode ) {
2093                             merge_public_with_secret ( ctx->keyblock,
2094                                                        secblock);
2095                             release_kbnode (secblock);
2096                             secblock = NULL;
2097                         }
2098                         goto found;
2099                     }
2100                 }
2101             }
2102           skip:
2103             /* release resources and try the next keyblock */
2104             if ( secmode ) {
2105                 release_kbnode( secblock );
2106                 secblock = NULL;
2107             }
2108             release_kbnode( ctx->keyblock );
2109             ctx->keyblock = NULL;
2110         }
2111       found:
2112         ;
2113     }
2114     if( rc && rc != -1 )
2115         log_error("enum_keyblocks failed: %s\n", gpg_errstr(rc));
2116
2117     if( !rc ) {
2118         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2119         ctx->keyblock = NULL;
2120     }
2121     else if( rc == -1 )
2122         rc = secmode ? GPGERR_NO_SECKEY : GPGERR_NO_PUBKEY;
2123
2124     if ( secmode ) {
2125         release_kbnode( secblock );
2126         secblock = NULL;
2127     }
2128     release_kbnode( ctx->keyblock );
2129     ctx->keyblock = NULL;
2130     set_packet_list_mode(oldmode);
2131   #if 0
2132     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2133         static int initialized;
2134
2135         if( !initialized ) {
2136             initialized = 1;
2137             atexit( print_stats );
2138         }
2139
2140         assert( ctx->mode < DIM(lkup_stats) );
2141         lkup_stats[ctx->mode].any = 1;
2142         if( !rc )
2143             lkup_stats[ctx->mode].okay_count++;
2144         else if ( rc == GPGERR_NO_PUBKEY || rc == GPGERR_NO_SECKEY )
2145             lkup_stats[ctx->mode].nokey_count++;
2146         else
2147             lkup_stats[ctx->mode].error_count++;
2148     }
2149    #endif
2150
2151     ctx->last_rc = rc;
2152     ctx->count++;
2153     return rc;
2154 }
2155
2156
2157
2158
2159
2160 /****************
2161  * FIXME: Replace by the generic function 
2162  *        It does not work as it is right now - it is used at 
2163  *        2 places:  a) to get the key for an anonyous recipient
2164  *                   b) to get the ultimately trusted keys.
2165  *        The a) usage might have some problems.
2166  *
2167  * Enumerate all primary secret keys.  Caller must use these procedure:
2168  *  1) create a void pointer and initialize it to NULL
2169  *  2) pass this void pointer by reference to this function
2170  *     and provide space for the secret key (pass a buffer for sk)
2171  *  3) call this function as long as it does not return -1
2172  *     to indicate EOF.
2173  *  4) Always call this function a last time with SK set to NULL,
2174  *     so that can free it's context.
2175  *
2176  *
2177  */
2178 int
2179 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
2180 {
2181     int rc=0;
2182     PACKET pkt;
2183     int save_mode;
2184     struct {
2185         int eof;
2186         int sequence;
2187         const char *name;
2188         IOBUF iobuf;
2189     } *c = *context;
2190
2191
2192     if( !c ) { /* make a new context */
2193         c = gcry_xcalloc( 1, sizeof *c );
2194         *context = c;
2195         c->sequence = 0;
2196         c->name = enum_keyblock_resources( &c->sequence, 1 );
2197     }
2198
2199     if( !sk ) { /* free the context */
2200         if( c->iobuf )
2201             iobuf_close(c->iobuf);
2202         gcry_free( c );
2203         *context = NULL;
2204         return 0;
2205     }
2206
2207     if( c->eof )
2208         return -1;
2209
2210     /* FIXME: This assumes a plain keyring file */
2211     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
2212         if( !c->iobuf ) {
2213             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
2214                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
2215                 continue; /* try next file */
2216             }
2217         }
2218
2219         save_mode = set_packet_list_mode(0);
2220         init_packet(&pkt);
2221         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
2222             if( rc )
2223                 ; /* e.g. unknown packet */
2224             else if( pkt.pkttype == PKT_SECRET_KEY
2225                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
2226                 copy_secret_key( sk, pkt.pkt.secret_key );
2227                 set_packet_list_mode(save_mode);
2228                 return 0; /* found */
2229             }
2230             free_packet(&pkt);
2231         }
2232         set_packet_list_mode(save_mode);
2233         iobuf_close(c->iobuf); c->iobuf = NULL;
2234     }
2235     c->eof = 1;
2236     return -1;
2237 }
2238
2239
2240 \f
2241 /*********************************************
2242  ***********  user ID printing helpers *******
2243  *********************************************/
2244
2245 /****************
2246  * Return a string with a printable representation of the user_id.
2247  * this string must be freed by m_free.
2248  */
2249 char*
2250 get_user_id_string( u32 *keyid )
2251 {
2252     user_id_db_t r;
2253     char *p;
2254     int pass=0;
2255     /* try it two times; second pass reads from key resources */
2256     do {
2257         for(r=user_id_db; r; r = r->next ) {
2258             keyid_list_t a;
2259             for (a=r->keyids; a; a= a->next ) {
2260                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2261                     p = gcry_xmalloc( r->len + 10 );
2262                     sprintf(p, "%08lX %.*s",
2263                             (ulong)keyid[1], r->len, r->name );
2264                     return p;
2265                 }
2266             }
2267         }
2268     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2269     p = gcry_xmalloc( 15 );
2270     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2271     return p;
2272 }
2273
2274
2275 char*
2276 get_user_id_string_native( u32 *keyid )
2277 {
2278     char *p = get_user_id_string( keyid );
2279     char *p2 = utf8_to_native( p, strlen(p) );
2280
2281     gcry_free(p);
2282     return p2;
2283 }
2284
2285
2286 char*
2287 get_long_user_id_string( u32 *keyid )
2288 {
2289     user_id_db_t r;
2290     char *p;
2291     int pass=0;
2292     /* try it two times; second pass reads from key resources */
2293     do {
2294         for(r=user_id_db; r; r = r->next ) {
2295             keyid_list_t a;
2296             for (a=r->keyids; a; a= a->next ) {
2297                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2298                     p = gcry_xmalloc( r->len + 20 );
2299                     sprintf(p, "%08lX%08lX %.*s",
2300                             (ulong)keyid[0], (ulong)keyid[1],
2301                             r->len, r->name );
2302                     return p;
2303                 }
2304             }
2305         }
2306     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2307     p = gcry_xmalloc( 25 );
2308     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2309     return p;
2310 }
2311
2312 char*
2313 get_user_id( u32 *keyid, size_t *rn )
2314 {
2315     user_id_db_t r;
2316     char *p;
2317     int pass=0;
2318
2319     /* try it two times; second pass reads from key resources */
2320     do {
2321         for(r=user_id_db; r; r = r->next ) {
2322             keyid_list_t a;
2323             for (a=r->keyids; a; a= a->next ) {
2324                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2325                     p = gcry_xmalloc( r->len );
2326                     memcpy(p, r->name, r->len );
2327                     *rn = r->len;
2328                     return p;
2329                 }
2330             }
2331         }
2332     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2333     p = gcry_xstrdup( _("[User id not found]") );
2334     *rn = strlen(p);
2335     return p;
2336 }
2337
2338