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