See ChangeLog: Mon Sep 18 16:35:45 CEST 2000 Werner Koch
[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         ctx->items[n].mode = classify_user_id( r->d,
799                                               ctx->items[n].keyid,
800                                               ctx->items[n].fprint,
801                                               &ctx->items[n].name,
802                                               NULL );
803         if( !ctx->items[n].mode ) {
804             gcry_free( ctx );
805             return GPGERR_INV_USER_ID;
806         }
807         if( ctx->items[n].mode == 6 ) {
808             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
809             ctx->items[n].name = ctx->items[n].namebuf;
810         }
811     }
812
813     /* and call the lookup function */
814     ctx->primary = 1; /* we want to look for the primary key only */
815
816     if ( !ret_kb ) 
817         ret_kb = &help_kb;
818
819     if( sk ) {
820         rc = lookup( ctx, ret_kb, 1 );
821         if ( !rc && sk ) {
822             sk_from_block ( ctx, sk, *ret_kb );
823         }
824     }
825     else {
826        
827         rc = lookup( ctx, ret_kb, 0 );
828         if ( !rc && pk ) {
829             pk_from_block ( ctx, pk, *ret_kb, NULL /* FIXME need to get the namehash*/ );
830         }
831     }
832
833     release_kbnode ( help_kb );
834
835     if( retctx ) /* caller wants the context */
836         *retctx = ctx;
837     else {
838         /* Hmmm, why not get_pubkey-end here?? */
839         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
840         for(n=0; n < ctx->nitems; n++ )
841             gcry_free( ctx->items[n].namebuf );
842         gcry_free( ctx );
843     }
844
845     return rc;
846 }
847
848 int
849 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
850                    const char *name, KBNODE *ret_keyblock )
851 {
852     int rc;
853     STRLIST namelist = NULL;
854
855     add_to_strlist( &namelist, name );
856     rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
857     free_strlist( namelist );
858     return rc;
859 }
860
861 int
862 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
863                     STRLIST names, KBNODE *ret_keyblock )
864 {
865     return key_byname( retctx, names, pk, NULL, ret_keyblock );
866 }
867
868 int
869 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
870 {
871     int rc;
872
873     rc = lookup( ctx, ret_keyblock, 0 );
874     if ( !rc && pk && ret_keyblock )
875         pk_from_block ( ctx, pk, *ret_keyblock, NULL );
876     
877     return rc;
878 }
879
880 void
881 get_pubkey_end( GETKEY_CTX ctx )
882 {
883     if( ctx ) {
884         int n;
885
886         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
887         for(n=0; n < ctx->nitems; n++ )
888             gcry_free( ctx->items[n].namebuf );
889         if( !ctx->not_allocated )
890             gcry_free( ctx );
891     }
892 }
893
894 /****************
895  * Search for a key with the given fingerprint.
896  */
897 int
898 get_pubkey_byfprint( PKT_public_key *pk,
899                      const byte *fprint, size_t fprint_len)
900 {
901     int rc;
902
903     if( fprint_len == 20 || fprint_len == 16 ) {
904         struct getkey_ctx_s ctx;
905         KBNODE kb = NULL;
906
907         memset( &ctx, 0, sizeof ctx );
908         ctx.not_allocated = 1;
909         ctx.nitems = 1;
910         ctx.items[0].mode = fprint_len;
911         memcpy( ctx.items[0].fprint, fprint, fprint_len );
912         rc = lookup( &ctx, &kb, 0 );
913         if (!rc && pk )
914             pk_from_block ( &ctx, pk, kb, NULL );
915         release_kbnode ( kb );
916         get_pubkey_end( &ctx );
917     }
918     else
919         rc = GPGERR_GENERAL; /* Oops */
920     return rc;
921 }
922
923 /****************
924  * Search for a key with the given fingerprint and return the
925  * complete keyblock which may have more than only this key.
926  */
927 int
928 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
929                                                 size_t fprint_len )
930 {
931     int rc;
932
933     if( fprint_len == 20 || fprint_len == 16 ) {
934         struct getkey_ctx_s ctx;
935
936         memset( &ctx, 0, sizeof ctx );
937         ctx.not_allocated = 1;
938         ctx.nitems = 1;
939         ctx.items[0].mode = fprint_len;
940         memcpy( ctx.items[0].fprint, fprint, fprint_len );
941         rc = lookup( &ctx, ret_keyblock, 0 );
942         get_pubkey_end( &ctx );
943     }
944     else
945         rc = GPGERR_GENERAL; /* Oops */
946
947     return rc;
948 }
949
950
951
952 /****************
953  * Search for a key with the given lid and return the entire keyblock
954  */
955 int
956 get_keyblock_bylid( KBNODE *ret_keyblock, ulong lid )
957 {
958     int rc;
959     struct getkey_ctx_s ctx;
960     u32 kid[2];
961
962     if( keyid_from_lid( lid, kid ) )
963         kid[0] = kid[1] = 0;
964     memset( &ctx, 0, sizeof ctx );
965     ctx.not_allocated = 1;
966     ctx.nitems = 1;
967     ctx.items[0].mode = 12;
968     ctx.items[0].keyid[0] = kid[0];
969     ctx.items[0].keyid[1] = kid[1];
970     rc = lookup( &ctx,  ret_keyblock, 0 );
971     get_pubkey_end( &ctx );
972
973     return rc;
974 }
975
976
977
978
979
980 /****************
981  * Get a secret key by name and store it into sk
982  * If NAME is NULL use the default key
983  */
984 int
985 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
986 {
987     STRLIST namelist = NULL;
988     int rc;
989
990     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
991         add_to_strlist( &namelist, opt.def_secret_key );
992         rc = key_byname( NULL, namelist, NULL, sk, NULL );
993     }
994     else if( !name ) { /* use the first one as default key */
995         struct getkey_ctx_s ctx;
996         KBNODE kb = NULL;
997
998         memset( &ctx, 0, sizeof ctx );
999         ctx.not_allocated = 1;
1000         ctx.primary = 1;
1001         ctx.nitems = 1;
1002         ctx.items[0].mode = 15;
1003         rc = lookup( &ctx, &kb, 1 );
1004         if (!rc && sk )
1005             sk_from_block ( &ctx, sk, kb );
1006         release_kbnode ( kb );
1007         get_seckey_end( &ctx );
1008     }
1009     else {
1010         add_to_strlist( &namelist, name );
1011         rc = key_byname( NULL, namelist, NULL, sk, NULL );
1012     }
1013
1014     free_strlist( namelist );
1015
1016     if( !rc && unprotect )
1017         rc = check_secret_key( sk, 0 );
1018
1019     return rc;
1020 }
1021
1022 int
1023 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
1024                     STRLIST names, KBNODE *ret_keyblock )
1025 {
1026     return key_byname( retctx, names, NULL, sk, ret_keyblock );
1027 }
1028
1029
1030 int
1031 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1032 {
1033     int rc;
1034
1035     rc = lookup( ctx, ret_keyblock, 1 );
1036     if ( !rc && sk && ret_keyblock )
1037         sk_from_block ( ctx, sk, *ret_keyblock );
1038
1039     return rc;
1040 }
1041
1042 void
1043 get_seckey_end( GETKEY_CTX ctx )
1044 {
1045     get_pubkey_end( ctx );
1046 }
1047
1048
1049 \f
1050 /*******************************************************
1051  ************** compare functions **********************
1052  *******************************************************/
1053
1054 /****************
1055  * Do a word match (original user id starts with a '+').
1056  * The pattern is already tokenized to a more suitable format:
1057  * There are only the real words in it delimited by one space
1058  * and all converted to uppercase.
1059  *
1060  * Returns: 0 if all words match.
1061  *
1062  * Note: This algorithm is a straightforward one and not very
1063  *       fast.  It works for UTF-8 strings.  The uidlen should
1064  *       be removed but due to the fact that old versions of
1065  *       pgp don't use UTF-8 we still use the length; this should
1066  *       be fixed in parse-packet (and replace \0 by some special
1067  *       UTF-8 encoding)
1068  */
1069 static int
1070 word_match( const byte *uid, size_t uidlen, const byte *pattern )
1071 {
1072     size_t wlen, n;
1073     const byte *p;
1074     const byte *s;
1075
1076     for( s=pattern; *s; ) {
1077         do {
1078             /* skip leading delimiters */
1079             while( uidlen && !word_match_chars[*uid] )
1080                 uid++, uidlen--;
1081             /* get length of the word */
1082             n = uidlen; p = uid;
1083             while( n && word_match_chars[*p] )
1084                 p++, n--;
1085             wlen = p - uid;
1086             /* and compare against the current word from pattern */
1087             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
1088                 if( word_match_chars[*p] != s[n] )
1089                     break;
1090             }
1091             if( n == wlen && (s[n] == ' ' || !s[n]) )
1092                 break; /* found */
1093             uid += wlen;
1094             uidlen -= wlen;
1095         } while( uidlen );
1096         if( !uidlen )
1097             return -1; /* not found */
1098
1099         /* advance to next word in pattern */
1100         for(; *s != ' ' && *s ; s++ )
1101             ;
1102         if( *s )
1103             s++ ;
1104     }
1105     return 0; /* found */
1106 }
1107
1108 /****************
1109  * prepare word word_match; that is parse the name and
1110  * build the pattern.
1111  * caller has to free the returned pattern
1112  */
1113 static char*
1114 prepare_word_match( const byte *name )
1115 {
1116     byte *pattern, *p;
1117     int c;
1118
1119     /* the original length is always enough for the pattern */
1120     p = pattern = gcry_xmalloc(strlen(name)+1);
1121     do {
1122         /* skip leading delimiters */
1123         while( *name && !word_match_chars[*name] )
1124             name++;
1125         /* copy as long as we don't have a delimiter and convert
1126          * to uppercase.
1127          * fixme: how can we handle utf8 uppercasing */
1128         for( ; *name &&  (c=word_match_chars[*name]); name++ )
1129             *p++ = c;
1130         *p++ = ' '; /* append pattern delimiter */
1131     } while( *name );
1132     p[-1] = 0; /* replace last pattern delimiter by EOS */
1133
1134     return pattern;
1135 }
1136
1137
1138
1139
1140
1141 static int
1142 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
1143 {
1144     int i;
1145     const char *s, *se;
1146
1147     if( mode == 1 ) {  /* exact match */
1148         for(i=0; name[i] && uidlen; i++, uidlen-- )
1149             if( uid[i] != name[i] )
1150                 break;
1151         if( !uidlen && !name[i] )
1152             return 0; /* found */
1153     }
1154     else if( mode == 2 ) { /* case insensitive substring */
1155         if( memistr( uid, uidlen, name ) )
1156             return 0;
1157     }
1158     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1159         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1160             ;
1161         if( i < uidlen )  {
1162             /* skip opening delim and one char and look for the closing one*/
1163             s++; i++;
1164             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1165                 ;
1166             if( i < uidlen ) {
1167                 i = se - s;
1168                 if( mode == 3 ) { /* exact email address */
1169                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1170                         return 0;
1171                 }
1172                 else if( mode == 4 ) {  /* email substring */
1173                     if( memistr( s, i, name ) )
1174                         return 0;
1175                 }
1176                 else { /* email from end */
1177                     /* nyi */
1178                 }
1179             }
1180         }
1181     }
1182     else if( mode == 6 )
1183         return word_match( uid, uidlen, name );
1184     else
1185         BUG();
1186
1187     return -1; /* not found */
1188 }
1189
1190
1191
1192 \f
1193 /************************************************
1194  ************* Merging stuff ********************
1195  ************************************************/
1196
1197 /****************
1198  * merge all selfsignatures with the keys.
1199  * FIXME: replace this at least for the public key parts
1200  *        by merge_selfsigs
1201  */
1202 void
1203 merge_keys_and_selfsig( KBNODE keyblock )
1204 {
1205     PKT_public_key *pk = NULL;
1206     PKT_secret_key *sk = NULL;
1207     PKT_signature *sig;
1208     KBNODE k;
1209     u32 kid[2] = { 0, 0 };
1210     u32 sigdate = 0;
1211
1212     for(k=keyblock; k; k = k->next ) {
1213         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1214             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1215             pk = k->pkt->pkt.public_key; sk = NULL;
1216             if( pk->version < 4 )
1217                 pk = NULL; /* not needed for old keys */
1218             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1219                 keyid_from_pk( pk, kid );
1220             else if( !pk->expiredate ) { /* and subkey */
1221                 /* insert the expiration date here */
1222                 /*FIXME!!! pk->expiredate = subkeys_expiretime( k, kid );*/
1223             }
1224             sigdate = 0;
1225         }
1226         else if( k->pkt->pkttype == PKT_SECRET_KEY
1227             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1228             pk = NULL; sk = k->pkt->pkt.secret_key;
1229             if( sk->version < 4 )
1230                 sk = NULL;
1231             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1232                 keyid_from_sk( sk, kid );
1233             sigdate = 0;
1234         }
1235         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1236                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1237                  && sig->sig_class <= 0x30 && sig->version > 3
1238                  && !(sig->sig_class == 0x18 || sig->sig_class == 0x28)
1239                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1240             /* okay this is a self-signature which can be used.
1241              * This is not used for subkey binding signature, becuase this
1242              * is done above.
1243              * FIXME: We should only use this if the signature is valid
1244              *        but this is time consuming - we must provide another
1245              *        way to handle this
1246              */
1247             const byte *p;
1248             u32 ed;
1249
1250             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1251             if( pk ) {
1252                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1253                 if( sig->timestamp > sigdate ) {
1254                     pk->expiredate = ed;
1255                     sigdate = sig->timestamp;
1256                 }
1257             }
1258             else {
1259                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1260                 if( sig->timestamp > sigdate ) {
1261                     sk->expiredate = ed;
1262                     sigdate = sig->timestamp;
1263                 }
1264             }
1265         }
1266     }
1267 }
1268
1269
1270 static void
1271 fixup_uidnode ( KBNODE uidnode, KBNODE signode )
1272 {
1273     PKT_user_id   *uid = uidnode->pkt->pkt.user_id;
1274     PKT_signature *sig = signode->pkt->pkt.signature;
1275     const byte *p;
1276     size_t n;
1277
1278     uid->created = 0; /* not created == invalid */
1279     if ( !signode ) 
1280         return; /* no self-signature */
1281     if ( IS_UID_REV ( sig ) )
1282         return; /* has been revoked */
1283
1284     uid->created = sig->timestamp; /* this one is okay */    
1285  
1286         
1287     /* store the key flags in the helper variable for later processing */
1288     uid->help_key_usage = 0;
1289     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1290     if ( p && n ) {
1291         /* first octet of the keyflags */   
1292         if ( (*p & 3) )
1293             uid->help_key_usage |= GCRY_PK_USAGE_SIGN;
1294         if ( (*p & 12) )    
1295             uid->help_key_usage |= GCRY_PK_USAGE_ENCR;
1296     }
1297
1298     /* ditto or the key expiration */
1299     uid->help_key_expire = 0;
1300     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL);
1301     if ( p ) {
1302         uid->help_key_expire = sig->timestamp + buffer_to_u32(p);
1303     }
1304
1305     /* Set the primary user ID flag - we will later wipe out some
1306      * of them to only have one in out keyblock */
1307     uid->is_primary = 0;
1308     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_PRIMARY_UID, NULL );
1309     if ( p && *p )
1310         uid->is_primary = 1;
1311     /* We could also query this from the unhashed area if it is not in
1312      * the hased area and then later try to decide which is the better
1313      * there should be no security problem with this.
1314      * For now we only look at the hashed one. 
1315      */
1316 }
1317
1318 static void
1319 merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
1320 {
1321     PKT_public_key *pk = NULL;
1322     KBNODE k;
1323     u32 kid[2];
1324     u32 sigdate = 0, uiddate=0, uiddate2;
1325     KBNODE signode, uidnode, uidnode2;
1326     u32 curtime = make_timestamp ();
1327     unsigned int key_usage = 0;
1328     u32 key_expire = 0;
1329     int key_expire_seen = 0;
1330
1331     *r_revoked = 0;
1332     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1333         BUG ();
1334     pk = keyblock->pkt->pkt.public_key;
1335     pk->created = 0;
1336     keyid_from_pk( pk, kid );
1337     pk->main_keyid[0] = kid[0];
1338     pk->main_keyid[1] = kid[1];
1339
1340     if ( pk->version < 4 ) 
1341         return; /* nothing to do for old keys FIXME: This is wrong!!!!*/
1342
1343     /* first pass: find the latest direct key self-signature.
1344      * We assume that the newest one overrides all others
1345      */
1346     signode = NULL;
1347     sigdate = 0; /* helper to find the latest signature */
1348     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1349         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1350             PKT_signature *sig = k->pkt->pkt.signature;
1351             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1352                 if ( check_key_signature( keyblock, k, NULL ) )
1353                     ; /* signature did not verify */
1354                 else if ( IS_KEY_REV (sig) ){
1355                     /* key has been revoked - there is no way to override
1356                      * such a revocation, so we can stop now.
1357                      * we can't cope with expiration times for revocations
1358                      * here because we have to assumethat an attacker can
1359                      * generate all kinds of signatures.
1360                      */ 
1361                     *r_revoked = 1;
1362                     return;
1363                 }
1364                 else if ( IS_KEY_SIG (sig) && sig->timestamp >= sigdate ) {
1365                     const byte *p;
1366                     
1367                     p = parse_sig_subpkt( sig->hashed_data,
1368                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1369                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1370                         ; /* signature has expired - ignore it */
1371                     else {
1372                         sigdate = sig->timestamp;
1373                         signode = k;
1374                     }
1375                 }
1376             }
1377         }
1378     }
1379
1380     if ( signode ) {
1381         /* some information from a direct key signature take precedence
1382          * over the same information given in UID sigs.
1383          */
1384         PKT_signature *sig = signode->pkt->pkt.signature;
1385         const byte *p;
1386         size_t n;
1387         
1388         p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1389         if ( p && n ) {
1390             /* first octet of the keyflags */   
1391             if ( (*p & 3) )
1392                 key_usage |= GCRY_PK_USAGE_SIGN;
1393             if ( (*p & 12) )    
1394                 key_usage |= GCRY_PK_USAGE_ENCR;
1395         }
1396
1397         p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL);
1398         if ( p ) {
1399             key_expire = sig->timestamp + buffer_to_u32(p);
1400             key_expire_seen = 1;
1401         }
1402
1403         /* and set the created field */
1404         pk->created = sigdate;
1405         /* and mark that key as valid: one direct key signature should 
1406          * render a key as valid */
1407         pk->is_valid = 1;
1408     }
1409
1410
1411     /* second pass: look at the self-signature of all user IDs */
1412     signode = uidnode = NULL;
1413     sigdate = 0; /* helper to find the latest signature in one user ID */
1414     uiddate = 0; /* and over of all user IDs */
1415     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1416         if ( k->pkt->pkttype == PKT_USER_ID
1417              || k->pkt->pkttype == PKT_PHOTO_ID ) {
1418             if ( uidnode ) 
1419                 fixup_uidnode ( uidnode, signode );
1420             uidnode = k;
1421             signode = NULL;
1422             if ( sigdate > uiddate )
1423                 uiddate = sigdate;
1424             sigdate = 0;
1425         }
1426         else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode ) {
1427             PKT_signature *sig = k->pkt->pkt.signature;
1428             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) { 
1429                 if ( check_key_signature( keyblock, k, NULL ) )
1430                     ; /* signature did not verify */
1431                 else if ( IS_UID_SIG (sig) || IS_UID_REV (sig)) {
1432                     /* Note: we allow to invalidated cert revocations
1433                      * by a newer signature.  An attacker can't use this
1434                      * because a key should be revoced with a key revocation.
1435                      * The reason why we have to allow for that is that at
1436                      * one time an email address may become invalid but later
1437                      * the same email address may become valid again (hired,
1438                      * fired, hired again).
1439                      */                    
1440                     const byte *p;
1441                     
1442                     p = parse_sig_subpkt( sig->hashed_data,
1443                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1444                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1445                         ; /* signature/revocation has expired - ignore it */
1446                     else {
1447                         sigdate = sig->timestamp;
1448                         signode = k;
1449                     }
1450                 }
1451             }
1452         }
1453     }
1454     if ( uidnode ) {
1455         fixup_uidnode ( uidnode, signode );
1456         pk->is_valid = 1;
1457     }
1458     if ( sigdate > uiddate )
1459         uiddate = sigdate;
1460     /* if we do not have a direct key signature, take the key creation date
1461      * from the latest user ID.  Hmmm, another possibilty would be to take 
1462      * it from the latest primary user ID - but we don't implement it for
1463      * now */
1464     if ( !pk->created )
1465         pk->created = uiddate;
1466     if ( !pk->created ) {
1467         /* oops, still no creation date: use the timestamp */
1468         if (DBG_CACHE)
1469             log_debug( "merge_selfsigs_main: "
1470                        "using timestamp as creation date\n");    
1471         pk->created = pk->timestamp;
1472     }
1473
1474     /* Now that we had a look at all user IDs we can now get some information
1475      * from those user IDs.
1476      */
1477     
1478     if ( !key_usage ) {
1479         /* find the latest user ID with key flags set */
1480         uiddate = 0; /* helper to find the latest user ID */
1481         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1482             k = k->next ) {
1483             if ( k->pkt->pkttype == PKT_USER_ID
1484                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1485                 PKT_user_id *uid = k->pkt->pkt.user_id;
1486                 if ( uid->help_key_usage && uid->created > uiddate ) {
1487                     key_usage = uid->help_key_usage;
1488                     uiddate = uid->created;
1489                 }
1490             }
1491         }
1492     }
1493     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1494         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1495     }
1496     else { /* check that the usage matches the usage as given by the algo */
1497         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1498         if ( x ) /* mask it down to the actual allowed usage */
1499             key_usage &= x; 
1500     }
1501     pk->pubkey_usage = key_usage;
1502
1503
1504     if ( !key_expire_seen ) {
1505         /* find the latest valid user ID with a key expiration set 
1506          * Note, that this may be a diferent one from the above because
1507          * some user IDs may have no expiration date set */
1508         uiddate = 0; 
1509         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1510             k = k->next ) {
1511             if ( k->pkt->pkttype == PKT_USER_ID
1512                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1513                 PKT_user_id *uid = k->pkt->pkt.user_id;
1514                 if ( uid->help_key_expire && uid->created > uiddate ) {
1515                     key_expire = uid->help_key_expire;
1516                     uiddate = uid->created;
1517                 }
1518             }
1519         }
1520     }
1521     if ( key_expire >= curtime )
1522         pk->has_expired = key_expire;
1523     /* FIXME: we should see how to get rid of the expiretime fields */
1524
1525
1526     /* and now find the real primary user ID and delete all others */
1527     uiddate = uiddate2 = 0;
1528     uidnode = uidnode2 = NULL;
1529     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1530         if ( k->pkt->pkttype == PKT_USER_ID
1531              || k->pkt->pkttype == PKT_PHOTO_ID ) {
1532             PKT_user_id *uid = k->pkt->pkt.user_id;
1533             if ( uid->is_primary && uid->created > uiddate ) {
1534                 uiddate = uid->created;
1535                 uidnode = k;
1536             }
1537             if ( !uid->is_primary && uid->created > uiddate2 ) {
1538                 uiddate2 = uid->created;
1539                 uidnode2 = k;
1540             }
1541         }
1542     }
1543     if ( uidnode ) {
1544         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1545             k = k->next ) {
1546             if ( k->pkt->pkttype == PKT_USER_ID
1547                  || k->pkt->pkttype == PKT_PHOTO_ID ) {
1548                 PKT_user_id *uid = k->pkt->pkt.user_id;
1549                 if ( k != uidnode ) 
1550                     uid->is_primary = 0;
1551             }
1552         }
1553     }
1554     else if( uidnode2 ) {
1555         /* none is flagged primary - use the latest user ID we have */
1556         uidnode2->pkt->pkt.user_id->is_primary = 1;
1557     }
1558
1559 }
1560
1561
1562 static void
1563 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
1564 {
1565     PKT_public_key *mainpk = NULL, *subpk = NULL;
1566     PKT_signature *sig;
1567     KBNODE k;
1568     u32 mainkid[2];
1569     u32 sigdate = 0;
1570     KBNODE signode;
1571     u32 curtime = make_timestamp ();
1572     unsigned int key_usage = 0;
1573     u32 key_expire = 0;
1574     const byte *p;
1575     size_t n;
1576
1577     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1578         BUG ();
1579     mainpk = keyblock->pkt->pkt.public_key;
1580     if ( mainpk->version < 4 )
1581         return; /* (actually this should never happen) */
1582     keyid_from_pk( mainpk, mainkid );
1583     subpk = subnode->pkt->pkt.public_key;
1584     subpk->is_valid = 0;
1585     subpk->main_keyid[0] = mainpk->main_keyid[0];
1586     subpk->main_keyid[1] = mainpk->main_keyid[1];
1587     if ( subpk->version < 4 )
1588         return; /* there are no v3 subkeys */
1589
1590     /* find the latest key binding self-signature. */
1591     signode = NULL;
1592     sigdate = 0; /* helper to find the latest signature */
1593     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1594                                                         k = k->next ) {
1595         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1596             sig = k->pkt->pkt.signature;
1597             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) { 
1598                 if ( check_key_signature( keyblock, k, NULL ) )
1599                     ; /* signature did not verify */
1600                 else if ( IS_SUBKEY_REV (sig) ) {
1601                     /* key has been revoked - given the fact that it is easy
1602                      * to create a new subkey, it does not make sense to
1603                      * revive a revoked key.  So we can stop here.
1604                      */
1605                     subpk->is_revoked = 1;
1606                     return;
1607                 }
1608                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate ) {
1609                     p = parse_sig_subpkt( sig->hashed_data,
1610                                           SIGSUBPKT_SIG_EXPIRE, NULL );
1611                     if ( p && (sig->timestamp + buffer_to_u32(p)) >= curtime )
1612                         ; /* signature has expired - ignore it */
1613                     else {
1614                         sigdate = sig->timestamp;
1615                         signode = k;
1616                     }
1617                 }
1618             }
1619         }
1620     }
1621
1622     if ( !signode ) {
1623         subpk->created = subpk->timestamp;
1624         return;  /* no valid key binding */
1625     }
1626
1627     subpk->is_valid = 1;
1628     subpk->created = sigdate; 
1629     sig = signode->pkt->pkt.signature;
1630         
1631     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_FLAGS, &n );
1632     if ( p && n ) {
1633         /* first octet of the keyflags */   
1634         if ( (*p & 3) )
1635             key_usage |= GCRY_PK_USAGE_SIGN;
1636         if ( (*p & 12) )    
1637             key_usage |= GCRY_PK_USAGE_ENCR;
1638     }
1639     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1640         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1641     }
1642     else { /* check that the usage matches the usage as given by the algo */
1643         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
1644         if ( x ) /* mask it down to the actual allowed usage */
1645             key_usage &= x; 
1646     }
1647     subpk->pubkey_usage = key_usage;
1648     
1649     p = parse_sig_subpkt ( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL);
1650     if ( p ) 
1651         key_expire = sig->timestamp + buffer_to_u32(p);
1652     else
1653         key_expire = 0;
1654     subpk->has_expired = key_expire >= curtime? key_expire : 0;
1655 }
1656
1657
1658
1659 /* 
1660  * Merge information from the self-signatures with the key, so that
1661  * we can later use them more easy.
1662  * The function works by first applying the self signatures to the
1663  * primary key and the to each subkey.
1664  * Here are the rules we use to decide which inormation from which
1665  * self-signature is used:
1666  * We check all self signatures or validity and ignore all invalid signatures.
1667  * All signatures are then ordered by their creation date ....
1668  * For the primary key:
1669  *   FIXME the docs    
1670  */
1671 static void
1672 merge_selfsigs( KBNODE keyblock )
1673 {
1674     KBNODE k;
1675     int revoked;
1676     PKT_public_key *main_pk;
1677
1678     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1679         BUG ();
1680
1681     merge_selfsigs_main ( keyblock, &revoked );
1682     main_pk = keyblock->pkt->pkt.public_key;
1683     if ( revoked ) {
1684         /* if the primary key has been revoked we better set the revoke
1685          * flag on that key and all subkeys */
1686         for(k=keyblock; k; k = k->next ) {
1687             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
1688                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1689                 PKT_public_key *pk = k->pkt->pkt.public_key;
1690                 pk->is_revoked = 1;
1691                 pk->main_keyid[0] = main_pk->main_keyid[0];
1692                 pk->main_keyid[1] = main_pk->main_keyid[1];
1693             }
1694         }
1695         return;
1696     }
1697
1698     /* now merge in the data from each of the subkeys */
1699     for(k=keyblock; k; k = k->next ) {
1700         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1701             merge_selfsigs_subkey ( keyblock, k );
1702         }
1703     }
1704 }
1705
1706
1707 /*
1708  * Merge the secret keys from secblock into the pubblock thereby
1709  * replacing the public (sub)keys with their secret counterparts Hmmm:
1710  * It might be better to get away from the concept of entire secret
1711  * keys at all and have a way to store just the real secret parts
1712  * from the key.
1713  */
1714 static void
1715 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
1716 {
1717     KBNODE pub;
1718     int deleting = 0;
1719     int any_deleted = 0;
1720
1721     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
1722     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
1723     
1724     for (pub=pubblock; pub; pub = pub->next ) {
1725         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
1726              PKT_public_key *pk = pub->pkt->pkt.public_key;
1727              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
1728              assert ( pub == pubblock ); /* only in the first node */
1729              /* there is nothing to compare in this case, so just replace
1730               * some information */
1731              copy_public_parts_to_secret_key ( pk, sk );
1732              free_public_key ( pk );
1733              pub->pkt->pkttype = PKT_SECRET_KEY;
1734              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
1735         }
1736         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1737             KBNODE sec;
1738             PKT_public_key *pk = pub->pkt->pkt.public_key;
1739
1740             deleting = 0;
1741             /* this is more complicated: it may happen that the sequence
1742              * of the subkeys dosn't match, so we have to find the
1743              * appropriate secret key */
1744             for (sec=secblock->next; sec; sec = sec->next ) {
1745                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1746                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
1747                     if ( !cmp_public_secret_key ( pk, sk ) ) {
1748                         copy_public_parts_to_secret_key ( pk, sk );
1749                         free_public_key ( pk );
1750                         pub->pkt->pkttype = PKT_SECRET_KEY;
1751                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
1752                         break;
1753                     }
1754                 }
1755             }
1756             if ( !sec ) {
1757                 log_error ( "no corresponding secret subkey "
1758                             "for public subkey - removing\n" );
1759                 /* better remove the public subkey in this case */
1760                 delete_kbnode ( pub );
1761                 deleting = 1;
1762                 any_deleted = 1;
1763             }
1764         }
1765         else if ( deleting ) {
1766             delete_kbnode (pub);
1767         }
1768     }
1769
1770     if ( any_deleted ) {
1771         /* because we have not deleted the root node, we don't need to
1772          * update the pubblock */
1773         pub = pubblock;
1774         commit_kbnode ( &pubblock );
1775         assert ( pub == pubblock );
1776     }
1777 }
1778
1779
1780
1781 \f
1782 /************************************************
1783  ************* Find stuff ***********************
1784  ************************************************/
1785
1786 static int 
1787 find_by_name( KBNODE keyblock, const char *name,
1788               int mode, byte *namehash )
1789 {
1790     KBNODE k;
1791
1792     for(k=keyblock; k; k = k->next ) {
1793         if( k->pkt->pkttype == PKT_USER_ID
1794             && !compare_name( k->pkt->pkt.user_id->name,
1795                               k->pkt->pkt.user_id->len, name, mode)) {
1796             /* we found a matching name, look for the key */
1797             if( k->pkt->pkt.user_id->photo ) {
1798                 /* oops: this can never happen */
1799                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1800                                      k->pkt->pkt.user_id->photo,
1801                                      k->pkt->pkt.user_id->photolen );
1802             }
1803             else {
1804                 gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
1805                                      k->pkt->pkt.user_id->name,
1806                                      k->pkt->pkt.user_id->len );
1807             }
1808             return 1; 
1809         }
1810     }
1811     
1812     return 0;
1813 }
1814
1815
1816
1817 static KBNODE
1818 find_by_keyid( KBNODE keyblock, u32 *keyid, int mode )
1819 {
1820     KBNODE k;
1821
1822     for(k=keyblock; k; k = k->next ) {
1823         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1824             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1825             u32 aki[2];
1826             keyid_from_pk( k->pkt->pkt.public_key, aki );
1827             if( aki[1] == keyid[1] && ( mode == 10 || aki[0] == keyid[0] ) ) {
1828                 return k; /* found */
1829             }
1830         }
1831     }
1832     return NULL;
1833 }
1834
1835
1836
1837 static KBNODE
1838 find_by_fpr( KBNODE keyblock,  const char *name, int mode )
1839 {
1840     KBNODE k;
1841
1842     for(k=keyblock; k; k = k->next ) {
1843         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1844             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1845             byte afp[MAX_FINGERPRINT_LEN];
1846             size_t an;
1847
1848             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1849             if( an == mode && !memcmp( afp, name, an) ) {
1850                 return k;
1851             }
1852         }
1853     }
1854     return NULL;
1855 }
1856
1857
1858
1859
1860 /* See see whether the key fits
1861  * our requirements and in case we do not
1862  * request a the primary key, we should select
1863  * a suitable subkey.
1864  * FIXME: Check against PGP 7 whether we still need a kludge
1865  *        to favor type 16 keys over type 20 keys when type 20
1866  *        has not been explitely requested.
1867  * Returns: True when a suitable key has been found.
1868  *
1869  * We have to distinguish four cases:
1870  *  1. No usage and no primary key requested
1871  *     Examples for this case are that we have a keyID to be used
1872  *     for decrytion or verification.
1873  *  2. No usage but primary key requested
1874  *     This is the case for all functions which work on an
1875  *     entire keyblock, e.g. for editing or listing
1876  *  3. Usage and primary key requested
1877  *     FXME
1878  *  4. Usage but no primary key requested
1879  *     FIXME
1880  * FIXME: Tell what is going to happen here and something about the rationale
1881  *
1882  */
1883
1884 static int
1885 finish_lookup( GETKEY_CTX ctx,  KBNODE foundk )
1886 {
1887     KBNODE keyblock = ctx->keyblock;
1888     KBNODE k;
1889   #define USAGE_MASK  (GCRY_PK_USAGE_SIGN|GCRY_PK_USAGE_ENCR)
1890     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
1891     u32 latest_date;
1892     KBNODE latest_key;
1893
1894     assert( !foundk || foundk->pkt->pkttype == PKT_PUBLIC_KEY
1895                     || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1896     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1897    
1898     ctx->found_key = NULL;
1899     
1900     if ( DBG_CACHE )
1901         log_debug( "finish_lookup: checking %s (req_usage=%x)\n",
1902                    foundk? "one key":"all keys", req_usage);
1903
1904     latest_date = 0;
1905     latest_key  = NULL;
1906     /* We do check the subkeys only if we either have requested a specific
1907      * usage or have not requested to get the primary key. */
1908     if ( (req_usage || !ctx->primary)
1909          && (!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) ) {
1910         KBNODE nextk;
1911         /* either start a loop or check just this one subkey */
1912         for (k=foundk?foundk:keyblock; k; k = nextk ) {
1913             PKT_public_key *pk;
1914             nextk = k->next;
1915             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
1916                 continue;
1917             if ( foundk )
1918                 nextk = NULL;  /* what a hack */
1919             pk = k->pkt->pkt.public_key;
1920             if ( !pk->is_valid ) {
1921                 if (DBG_CACHE)
1922                     log_debug( "\tsubkey not valid\n");
1923                 continue;
1924             }
1925             if ( pk->is_revoked ) {
1926                 if (DBG_CACHE)
1927                     log_debug( "\tsubkey has been revoked\n");
1928                 continue;
1929             }
1930             if ( pk->has_expired ) {
1931                 if (DBG_CACHE)
1932                     log_debug( "\tsubkey has expired\n");
1933                 continue;
1934             }
1935             
1936             if ( req_usage &&
1937                  !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
1938                 if (DBG_CACHE)
1939                     log_debug( "\tusage does not match: want=%x have=%x\n",
1940                                req_usage, pk->pubkey_usage );
1941                 continue;
1942             }
1943
1944             if (DBG_CACHE)
1945                 log_debug( "\tconsidering key created %lu\n",
1946                            (ulong)pk->created);
1947             if ( pk->created > latest_date ) {
1948                 latest_date = pk->created;
1949                 latest_key  = k;
1950             }
1951         }
1952     }
1953
1954     if ( !latest_key ) {
1955         PKT_public_key *pk;
1956         if (DBG_CACHE && !foundk )
1957             log_debug( "\tno suitable subkeys found - trying primary\n");
1958         pk = keyblock->pkt->pkt.public_key;
1959         if ( !pk->is_valid ) {
1960             if (DBG_CACHE)
1961                 log_debug( "\tprimary key not valid\n");
1962         }
1963         else if ( pk->is_revoked ) {
1964             if (DBG_CACHE)
1965                 log_debug( "\tprimary key has been revoked\n");
1966         }
1967         else if ( pk->has_expired ) {
1968             if (DBG_CACHE)
1969                 log_debug( "\tprimary key has expired\n");
1970         }
1971         else  if ( req_usage
1972                    && !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
1973             if (DBG_CACHE)
1974                 log_debug( "\tusage does not match: want=%x have=%x\n",
1975                            req_usage, pk->pubkey_usage );
1976         }
1977         else { /* okay */
1978             if (DBG_CACHE)
1979                 log_debug( "\tprimary key may be used\n");
1980             latest_key = keyblock;
1981             latest_date = pk->created;
1982         }
1983     }
1984     
1985     if ( !latest_key ) {
1986         if (DBG_CACHE)
1987             log_debug("\tno suitable key found -  giving up\n");
1988         return 0;
1989     }
1990
1991     if (DBG_CACHE)
1992         log_debug( "\tusing key created %lu\n", (ulong)latest_date );
1993
1994     ctx->found_key = latest_key;
1995
1996     if ( latest_key != keyblock ) {
1997         log_info(_("using secondary key %08lX "
1998                    "instead of primary key %08lX\n"),
1999                  (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL),
2000                  (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL) );
2001     }
2002
2003     cache_user_id( keyblock );
2004     
2005     return 1; /* found */
2006 }
2007
2008  
2009 static int
2010 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2011 {
2012     int rc;
2013     int oldmode = set_packet_list_mode(0);
2014     byte namehash[20];
2015     int use_namehash=0;
2016     KBNODE secblock = NULL; /* helper */
2017
2018     if( !ctx->count ) /* first time */
2019         rc = enum_keyblocks( secmode?5:0, &ctx->kbpos, &ctx->keyblock );
2020     else
2021         rc = 0;
2022     if( !rc ) {
2023         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
2024             int n;
2025             getkey_item_t *item;
2026
2027             if ( secmode ) {
2028                 /* find the correspondig public key and use this 
2029                  * this one for the selection process */
2030                 u32 aki[2];
2031                 KBNODE k = ctx->keyblock;
2032                 
2033                 if ( k->pkt->pkttype != PKT_SECRET_KEY )
2034                     BUG();
2035                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
2036                 k = get_pubkeyblock( aki );
2037                 if( !k ) {
2038                     log_info(_("key %08lX: secret key without public key "
2039                                "- skipped\n"),  (ulong)aki[1] );
2040                     goto skip;
2041                 }
2042                 secblock = ctx->keyblock;
2043                 ctx->keyblock = k;
2044             }
2045
2046
2047             /* loop over all the user ids we want to look for */
2048             item = ctx->items;
2049             for(n=0; n < ctx->nitems; n++, item++ ) {
2050                 KBNODE k = NULL;
2051                 int found = 0;
2052     
2053                 if( item->mode < 10 ) {
2054                     found = find_by_name( ctx->keyblock,
2055                                           item->name, item->mode,
2056                                           namehash );
2057                     use_namehash = found;
2058                 }
2059                 else if( item->mode >= 10 && item->mode <= 12 ) {
2060                     k = find_by_keyid( ctx->keyblock, 
2061                                        item->keyid, item->mode );
2062                     found = !!k;
2063                 }
2064                 else if( item->mode == 15 ) {
2065                     found = 1;
2066                 }
2067                 else if( item->mode == 16 || item->mode == 20 ) {
2068                     k = find_by_fpr( ctx->keyblock,
2069                                      item->fprint, item->mode );
2070                     found = !!k;
2071                 }
2072                 else
2073                     BUG();
2074                 if( found ) { 
2075                     /* this keyblock looks fine - do further investigation */
2076                     merge_selfsigs ( ctx->keyblock );
2077                     if ( finish_lookup( ctx, k ) ) {
2078                         if ( secmode ) {
2079                             merge_public_with_secret ( ctx->keyblock,
2080                                                        secblock);
2081                             release_kbnode (secblock);
2082                             secblock = NULL;
2083                         }
2084                         goto found;
2085                     }
2086                 }
2087             }
2088           skip:
2089             /* release resources and try the next keyblock */
2090             if ( secmode ) {
2091                 release_kbnode( secblock );
2092                 secblock = NULL;
2093             }
2094             release_kbnode( ctx->keyblock );
2095             ctx->keyblock = NULL;
2096         }
2097       found:
2098         ;
2099     }
2100     if( rc && rc != -1 )
2101         log_error("enum_keyblocks failed: %s\n", gpg_errstr(rc));
2102
2103     if( !rc ) {
2104         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2105         ctx->keyblock = NULL;
2106     }
2107     else if( rc == -1 )
2108         rc = secmode ? GPGERR_NO_SECKEY : GPGERR_NO_PUBKEY;
2109
2110     if ( secmode ) {
2111         release_kbnode( secblock );
2112         secblock = NULL;
2113     }
2114     release_kbnode( ctx->keyblock );
2115     ctx->keyblock = NULL;
2116     set_packet_list_mode(oldmode);
2117   #if 0
2118     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2119         static int initialized;
2120
2121         if( !initialized ) {
2122             initialized = 1;
2123             atexit( print_stats );
2124         }
2125
2126         assert( ctx->mode < DIM(lkup_stats) );
2127         lkup_stats[ctx->mode].any = 1;
2128         if( !rc )
2129             lkup_stats[ctx->mode].okay_count++;
2130         else if ( rc == GPGERR_NO_PUBKEY || rc == GPGERR_NO_SECKEY )
2131             lkup_stats[ctx->mode].nokey_count++;
2132         else
2133             lkup_stats[ctx->mode].error_count++;
2134     }
2135    #endif
2136
2137     ctx->last_rc = rc;
2138     ctx->count++;
2139     return rc;
2140 }
2141
2142
2143
2144
2145
2146 /****************
2147  * FIXME: Replace by the generic function 
2148  *        It does not work as it is right now - it is used at 
2149  *        2 places:  a) to get the key for an anonyous recipient
2150  *                   b) to get the ultimately trusted keys.
2151  *        The a) usage might have some problems.
2152  *
2153  * Enumerate all primary secret keys.  Caller must use these procedure:
2154  *  1) create a void pointer and initialize it to NULL
2155  *  2) pass this void pointer by reference to this function
2156  *     and provide space for the secret key (pass a buffer for sk)
2157  *  3) call this function as long as it does not return -1
2158  *     to indicate EOF.
2159  *  4) Always call this function a last time with SK set to NULL,
2160  *     so that can free it's context.
2161  *
2162  *
2163  */
2164 int
2165 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
2166 {
2167     int rc=0;
2168     PACKET pkt;
2169     int save_mode;
2170     struct {
2171         int eof;
2172         int sequence;
2173         const char *name;
2174         IOBUF iobuf;
2175     } *c = *context;
2176
2177
2178     if( !c ) { /* make a new context */
2179         c = gcry_xcalloc( 1, sizeof *c );
2180         *context = c;
2181         c->sequence = 0;
2182         c->name = enum_keyblock_resources( &c->sequence, 1 );
2183     }
2184
2185     if( !sk ) { /* free the context */
2186         if( c->iobuf )
2187             iobuf_close(c->iobuf);
2188         gcry_free( c );
2189         *context = NULL;
2190         return 0;
2191     }
2192
2193     if( c->eof )
2194         return -1;
2195
2196     /* FIXME: This assumes a plain keyring file */
2197     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
2198         if( !c->iobuf ) {
2199             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
2200                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
2201                 continue; /* try next file */
2202             }
2203         }
2204
2205         save_mode = set_packet_list_mode(0);
2206         init_packet(&pkt);
2207         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
2208             if( rc )
2209                 ; /* e.g. unknown packet */
2210             else if( pkt.pkttype == PKT_SECRET_KEY
2211                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
2212                 copy_secret_key( sk, pkt.pkt.secret_key );
2213                 set_packet_list_mode(save_mode);
2214                 return 0; /* found */
2215             }
2216             free_packet(&pkt);
2217         }
2218         set_packet_list_mode(save_mode);
2219         iobuf_close(c->iobuf); c->iobuf = NULL;
2220     }
2221     c->eof = 1;
2222     return -1;
2223 }
2224
2225
2226 \f
2227 /*********************************************
2228  ***********  user ID printing helpers *******
2229  *********************************************/
2230
2231 /****************
2232  * Return a string with a printable representation of the user_id.
2233  * this string must be freed by m_free.
2234  */
2235 char*
2236 get_user_id_string( u32 *keyid )
2237 {
2238     user_id_db_t r;
2239     char *p;
2240     int pass=0;
2241     /* try it two times; second pass reads from key resources */
2242     do {
2243         for(r=user_id_db; r; r = r->next ) {
2244             keyid_list_t a;
2245             for (a=r->keyids; a; a= a->next ) {
2246                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2247                     p = gcry_xmalloc( r->len + 10 );
2248                     sprintf(p, "%08lX %.*s",
2249                             (ulong)keyid[1], r->len, r->name );
2250                     return p;
2251                 }
2252             }
2253         }
2254     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2255     p = gcry_xmalloc( 15 );
2256     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2257     return p;
2258 }
2259
2260
2261 char*
2262 get_user_id_string_native( u32 *keyid )
2263 {
2264     char *p = get_user_id_string( keyid );
2265     char *p2 = utf8_to_native( p, strlen(p) );
2266
2267     gcry_free(p);
2268     return p2;
2269 }
2270
2271
2272 char*
2273 get_long_user_id_string( u32 *keyid )
2274 {
2275     user_id_db_t r;
2276     char *p;
2277     int pass=0;
2278     /* try it two times; second pass reads from key resources */
2279     do {
2280         for(r=user_id_db; r; r = r->next ) {
2281             keyid_list_t a;
2282             for (a=r->keyids; a; a= a->next ) {
2283                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2284                     p = gcry_xmalloc( r->len + 20 );
2285                     sprintf(p, "%08lX%08lX %.*s",
2286                             (ulong)keyid[0], (ulong)keyid[1],
2287                             r->len, r->name );
2288                     return p;
2289                 }
2290             }
2291         }
2292     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2293     p = gcry_xmalloc( 25 );
2294     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2295     return p;
2296 }
2297
2298 char*
2299 get_user_id( u32 *keyid, size_t *rn )
2300 {
2301     user_id_db_t r;
2302     char *p;
2303     int pass=0;
2304
2305     /* try it two times; second pass reads from key resources */
2306     do {
2307         for(r=user_id_db; r; r = r->next ) {
2308             keyid_list_t a;
2309             for (a=r->keyids; a; a= a->next ) {
2310                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2311                     p = gcry_xmalloc( r->len );
2312                     memcpy(p, r->name, r->len );
2313                     *rn = r->len;
2314                     return p;
2315                 }
2316             }
2317         }
2318     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2319     p = gcry_xstrdup( _("[User id not found]") );
2320     *rn = strlen(p);
2321     return p;
2322 }
2323
2324