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