Use inline functions to convert buffer data to scalars.
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27 #include "util.h"
28 #include "packet.h"
29 #include "memory.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "options.h"
33 #include "main.h"
34 #include "trustdb.h"
35 #include "i18n.h"
36 #include "keyserver-internal.h"
37 #include "../include/host2net.h"
38
39 #define MAX_PK_CACHE_ENTRIES   PK_UID_CACHE_SIZE
40 #define MAX_UID_CACHE_ENTRIES  PK_UID_CACHE_SIZE
41
42 #if MAX_PK_CACHE_ENTRIES < 2
43 #error We need the cache for key creation
44 #endif
45
46 struct getkey_ctx_s {
47     int exact;
48     KBNODE keyblock;
49     KBPOS  kbpos;
50     KBNODE found_key; /* pointer into some keyblock */
51     int last_rc;
52     int req_usage;
53     int req_algo;
54     KEYDB_HANDLE kr_handle;
55     int not_allocated;
56     int nitems;
57     KEYDB_SEARCH_DESC items[1];
58 };
59
60 #if 0
61 static struct {
62     int any;
63     int okay_count;
64     int nokey_count;
65     int error_count;
66 } lkup_stats[21];
67 #endif
68
69 typedef struct keyid_list {
70     struct keyid_list *next;
71     u32 keyid[2];
72 } *keyid_list_t;
73
74
75 #if MAX_PK_CACHE_ENTRIES
76   typedef struct pk_cache_entry {
77       struct pk_cache_entry *next;
78       u32 keyid[2];
79       PKT_public_key *pk;
80   } *pk_cache_entry_t;
81   static pk_cache_entry_t pk_cache;
82   static int pk_cache_entries;   /* number of entries in pk cache */
83   static int pk_cache_disabled;
84 #endif
85
86 #if MAX_UID_CACHE_ENTRIES < 5
87 #error we really need the userid cache
88 #endif
89 typedef struct user_id_db {
90     struct user_id_db *next;
91     keyid_list_t keyids;
92     int len;
93     char name[1];
94 } *user_id_db_t;
95 static user_id_db_t user_id_db;
96 static int uid_cache_entries;   /* number of entries in uid cache */
97
98 static void merge_selfsigs( KBNODE keyblock );
99 static int lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode );
100
101 #if 0
102 static void
103 print_stats()
104 {
105     int i;
106     for(i=0; i < DIM(lkup_stats); i++ ) {
107         if( lkup_stats[i].any )
108             fprintf(stderr,
109                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
110                     i,
111                     lkup_stats[i].okay_count,
112                     lkup_stats[i].nokey_count,
113                     lkup_stats[i].error_count );
114     }
115 }
116 #endif
117
118
119 void
120 cache_public_key( PKT_public_key *pk )
121 {
122 #if MAX_PK_CACHE_ENTRIES
123     pk_cache_entry_t ce;
124     u32 keyid[2];
125
126     if( pk_cache_disabled )
127         return;
128
129     if( pk->dont_cache )
130         return;
131
132     if( is_ELGAMAL(pk->pubkey_algo)
133         || pk->pubkey_algo == PUBKEY_ALGO_DSA
134         || is_RSA(pk->pubkey_algo) ) {
135         keyid_from_pk( pk, keyid );
136     }
137     else
138         return; /* don't know how to get the keyid */
139
140     for( ce = pk_cache; ce; ce = ce->next )
141         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
142             if( DBG_CACHE )
143                 log_debug("cache_public_key: already in cache\n");
144             return;
145         }
146
147     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
148         /* fixme: use another algorithm to free some cache slots */
149         pk_cache_disabled=1;
150         if( opt.verbose > 1 )
151             log_info(_("too many entries in pk cache - disabled\n"));
152         return;
153     }
154     pk_cache_entries++;
155     ce = xmalloc( sizeof *ce );
156     ce->next = pk_cache;
157     pk_cache = ce;
158     ce->pk = copy_public_key( NULL, pk );
159     ce->keyid[0] = keyid[0];
160     ce->keyid[1] = keyid[1];
161 #endif
162 }
163
164
165 /* Return a const utf-8 string with the text "[User ID not found]".
166    This fucntion is required so that we don't need to switch gettext's
167    encoding temporary. */
168 static const char *
169 user_id_not_found_utf8 (void)
170 {
171   static char *text;
172
173   if (!text)
174     text = native_to_utf8 (_("[User ID not found]"));
175   return text;
176 }
177
178
179
180 /*
181  * Return the user ID from the given keyblock.
182  * We use the primary uid flag which has been set by the merge_selfsigs
183  * function.  The returned value is only valid as long as then given
184  * keyblock is not changed
185  */
186 static const char *
187 get_primary_uid ( KBNODE keyblock, size_t *uidlen )
188 {
189     KBNODE k;
190     const char *s;
191
192     for (k=keyblock; k; k=k->next ) {
193         if ( k->pkt->pkttype == PKT_USER_ID
194              && !k->pkt->pkt.user_id->attrib_data
195              && k->pkt->pkt.user_id->is_primary ) {
196             *uidlen = k->pkt->pkt.user_id->len;
197             return k->pkt->pkt.user_id->name;
198         }
199     }
200     s = user_id_not_found_utf8 ();
201     *uidlen = strlen (s);
202     return s;
203 }
204
205
206 static void
207 release_keyid_list ( keyid_list_t k )
208 {
209     while (  k ) {
210         keyid_list_t k2 = k->next;
211         xfree (k);
212         k = k2;
213     }
214 }
215
216 /****************
217  * Store the association of keyid and userid
218  * Feed only public keys to this function.
219  */
220 static void
221 cache_user_id( KBNODE keyblock )
222 {
223     user_id_db_t r;
224     const char *uid;
225     size_t uidlen;
226     keyid_list_t keyids = NULL;
227     KBNODE k;
228
229     for (k=keyblock; k; k = k->next ) {
230         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
231              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
232             keyid_list_t a = xmalloc_clear ( sizeof *a );
233             /* Hmmm: For a long list of keyids it might be an advantage
234              * to append the keys */
235             keyid_from_pk( k->pkt->pkt.public_key, a->keyid );
236             /* first check for duplicates */
237             for(r=user_id_db; r; r = r->next ) {
238                 keyid_list_t b = r->keyids;
239                 for ( b = r->keyids; b; b = b->next ) {
240                     if( b->keyid[0] == a->keyid[0]
241                         && b->keyid[1] == a->keyid[1] ) {
242                         if( DBG_CACHE )
243                             log_debug("cache_user_id: already in cache\n");
244                         release_keyid_list ( keyids );
245                         xfree ( a );
246                         return;
247                     }
248                 }
249             }
250             /* now put it into the cache */
251             a->next = keyids;
252             keyids = a;
253         }
254     }
255     if ( !keyids )
256         BUG (); /* No key no fun */
257
258
259     uid = get_primary_uid ( keyblock, &uidlen );
260
261     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
262         /* fixme: use another algorithm to free some cache slots */
263         r = user_id_db;
264         user_id_db = r->next;
265         release_keyid_list ( r->keyids );
266         xfree(r);
267         uid_cache_entries--;
268     }
269     r = xmalloc( sizeof *r + uidlen-1 );
270     r->keyids = keyids;
271     r->len = uidlen;
272     memcpy(r->name, uid, r->len);
273     r->next = user_id_db;
274     user_id_db = r;
275     uid_cache_entries++;
276 }
277
278
279 void
280 getkey_disable_caches()
281 {
282 #if MAX_PK_CACHE_ENTRIES
283     {
284         pk_cache_entry_t ce, ce2;
285
286         for( ce = pk_cache; ce; ce = ce2 ) {
287             ce2 = ce->next;
288             free_public_key( ce->pk );
289             xfree( ce );
290         }
291         pk_cache_disabled=1;
292         pk_cache_entries = 0;
293         pk_cache = NULL;
294     }
295 #endif
296     /* fixme: disable user id cache ? */
297 }
298
299
300 static void
301 pk_from_block ( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE keyblock )
302 {
303     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
304
305     assert ( a->pkt->pkttype == PKT_PUBLIC_KEY
306              ||  a->pkt->pkttype == PKT_PUBLIC_SUBKEY );
307
308     copy_public_key ( pk, a->pkt->pkt.public_key );
309 }
310
311 static void
312 sk_from_block ( GETKEY_CTX ctx,
313                 PKT_secret_key *sk, KBNODE keyblock )
314 {
315     KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
316
317     assert ( a->pkt->pkttype == PKT_SECRET_KEY
318              ||  a->pkt->pkttype == PKT_SECRET_SUBKEY );
319
320     copy_secret_key( sk, a->pkt->pkt.secret_key);
321 }
322
323
324 /****************
325  * Get a public key and store it into the allocated pk
326  * can be called with PK set to NULL to just read it into some
327  * internal structures.
328  */
329 int
330 get_pubkey( PKT_public_key *pk, u32 *keyid )
331 {
332     int internal = 0;
333     int rc = 0;
334
335 #if MAX_PK_CACHE_ENTRIES
336     if(pk)
337       {
338         /* Try to get it from the cache.  We don't do this when pk is
339            NULL as it does not guarantee that the user IDs are
340            cached. */
341         pk_cache_entry_t ce;
342         for( ce = pk_cache; ce; ce = ce->next )
343           {
344             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] )
345               {
346                 copy_public_key( pk, ce->pk );
347                 return 0;
348               }
349           }
350       }
351 #endif
352     /* more init stuff */
353     if( !pk ) {
354         pk = xmalloc_clear( sizeof *pk );
355         internal++;
356     }
357
358
359     /* do a lookup */
360     {   struct getkey_ctx_s ctx;
361         KBNODE kb = NULL;
362         memset( &ctx, 0, sizeof ctx );
363         ctx.exact = 1; /* use the key ID exactly as given */
364         ctx.not_allocated = 1;
365         ctx.kr_handle = keydb_new (0);
366         ctx.nitems = 1;
367         ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
368         ctx.items[0].u.kid[0] = keyid[0];
369         ctx.items[0].u.kid[1] = keyid[1];
370         ctx.req_algo  = pk->req_algo;
371         ctx.req_usage = pk->req_usage;
372         rc = lookup( &ctx, &kb, 0 );
373         if ( !rc ) {
374             pk_from_block ( &ctx, pk, kb );
375         }
376         get_pubkey_end( &ctx );
377         release_kbnode ( kb );
378     }
379     if( !rc )
380         goto leave;
381
382     rc = G10ERR_NO_PUBKEY;
383
384   leave:
385     if( !rc )
386         cache_public_key( pk );
387     if( internal )
388         free_public_key(pk);
389     return rc;
390 }
391
392
393 /* Get a public key and store it into the allocated pk.  This function
394    differs from get_pubkey() in that it does not do a check of the key
395    to avoid recursion.  It should be used only in very certain cases.
396    It will only retrieve primary keys. */
397 int
398 get_pubkey_fast (PKT_public_key *pk, u32 *keyid)
399 {
400   int rc = 0;
401   KEYDB_HANDLE hd;
402   KBNODE keyblock;
403   u32 pkid[2];
404
405   assert (pk);
406 #if MAX_PK_CACHE_ENTRIES
407   { /* Try to get it from the cache */
408     pk_cache_entry_t ce;
409
410     for (ce = pk_cache; ce; ce = ce->next)
411       {
412         if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
413           {
414             if (pk)
415               copy_public_key (pk, ce->pk);
416             return 0;
417           }
418       }
419   }
420 #endif
421
422   hd = keydb_new (0);
423   rc = keydb_search_kid (hd, keyid);
424   if (rc == -1)
425     {
426       keydb_release (hd);
427       return G10ERR_NO_PUBKEY;
428     }
429   rc = keydb_get_keyblock (hd, &keyblock);
430   keydb_release (hd);
431   if (rc)
432     {
433       log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
434       return G10ERR_NO_PUBKEY;
435     }
436
437   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
438            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
439
440   keyid_from_pk(keyblock->pkt->pkt.public_key,pkid);
441   if(keyid[0]==pkid[0] && keyid[1]==pkid[1])
442     copy_public_key (pk, keyblock->pkt->pkt.public_key );
443   else
444     rc=G10ERR_NO_PUBKEY;
445
446   release_kbnode (keyblock);
447
448   /* Not caching key here since it won't have all of the fields
449      properly set. */
450
451   return rc;
452 }
453
454
455 KBNODE
456 get_pubkeyblock( u32 *keyid )
457 {
458     struct getkey_ctx_s ctx;
459     int rc = 0;
460     KBNODE keyblock = NULL;
461
462     memset( &ctx, 0, sizeof ctx );
463     /* no need to set exact here because we want the entire block */
464     ctx.not_allocated = 1;
465     ctx.kr_handle = keydb_new (0);
466     ctx.nitems = 1;
467     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
468     ctx.items[0].u.kid[0] = keyid[0];
469     ctx.items[0].u.kid[1] = keyid[1];
470     rc = lookup( &ctx, &keyblock, 0 );
471     get_pubkey_end( &ctx );
472
473     return rc ? NULL : keyblock;
474 }
475
476
477
478
479 /****************
480  * Get a secret key and store it into sk
481  */
482 int
483 get_seckey( PKT_secret_key *sk, u32 *keyid )
484 {
485     int rc;
486     struct getkey_ctx_s ctx;
487     KBNODE kb = NULL;
488
489     memset( &ctx, 0, sizeof ctx );
490     ctx.exact = 1; /* use the key ID exactly as given */
491     ctx.not_allocated = 1;
492     ctx.kr_handle = keydb_new (1);
493     ctx.nitems = 1;
494     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
495     ctx.items[0].u.kid[0] = keyid[0];
496     ctx.items[0].u.kid[1] = keyid[1];
497     ctx.req_algo  = sk->req_algo;
498     ctx.req_usage = sk->req_usage;
499     rc = lookup( &ctx, &kb, 1 );
500     if ( !rc ) {
501         sk_from_block ( &ctx, sk, kb );
502     }
503     get_seckey_end( &ctx );
504     release_kbnode ( kb );
505
506     if( !rc ) {
507         /* check the secret key (this may prompt for a passprase to
508          * unlock the secret key
509          */
510         rc = check_secret_key( sk, 0 );
511     }
512
513     return rc;
514 }
515
516
517 /****************
518  * Check whether the secret key is available.  This is just a fast
519  * check and does not tell us whether the secret key is valid.  It
520  * merely tells other whether there is some secret key.
521  * Returns: 0 := key is available
522  * G10ERR_NO_SECKEY := not availabe
523  */
524 int
525 seckey_available( u32 *keyid )
526 {
527     int rc;
528     KEYDB_HANDLE hd = keydb_new (1);
529
530     rc = keydb_search_kid (hd, keyid);
531     if ( rc == -1 )
532         rc = G10ERR_NO_SECKEY;
533     keydb_release (hd);
534     return rc;
535 }
536
537
538 /****************
539  * Return the type of the user id:
540  *
541  * Please use the constants KEYDB_SERCH_MODE_xxx
542  *  0 = Invalid user ID
543  *  1 = exact match
544  *  2 = match a substring
545  *  3 = match an email address
546  *  4 = match a substring of an email address
547  *  5 = match an email address, but compare from end
548  *  6 = word match mode
549  * 10 = it is a short KEYID (don't care about keyid[0])
550  * 11 = it is a long  KEYID
551  * 12 = it is a trustdb index (keyid is looked up)
552  * 16 = it is a 16 byte fingerprint
553  * 20 = it is a 20 byte fingerprint
554  * 21 = Unified fingerprint :fpr:pk_algo:
555  *      (We don't use pk_algo yet)
556  *
557  * Rules used:
558  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
559  *   must be in the range 0..9), this is considered a keyid; depending
560  *   on the length a short or complete one.
561  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
562  *   must be in the range 0..9), this is considered a fingerprint.
563  * - If the username starts with a left angle, we assume it is a complete
564  *   email address and look only at this part.
565  * - If the username starts with a colon we assume it is a unified
566  *   key specfification.
567  * - If the username starts with a '.', we assume it is the ending
568  *   part of an email address
569  * - If the username starts with an '@', we assume it is a part of an
570  *   email address
571  * - If the userid start with an '=' an exact compare is done.
572  * - If the userid starts with a '*' a case insensitive substring search is
573  *   done (This is the default).
574  * - If the userid starts with a '+' we will compare individual words
575  *   and a match requires that all the words are in the userid.
576  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
577  *   (note that you can't search for these characters). Compare
578  *   is not case sensitive.
579  */
580
581 int
582 classify_user_id( const char *name, KEYDB_SEARCH_DESC *desc )
583 {
584     const char *s;
585     int hexprefix = 0;
586     int hexlength;
587     int mode = 0;
588     KEYDB_SEARCH_DESC dummy_desc;
589
590     if (!desc)
591         desc = &dummy_desc;
592
593     /* clear the structure so that the mode field is set to zero unless
594      * we set it to the correct value right at the end of this function */
595     memset (desc, 0, sizeof *desc);
596
597     /* skip leading spaces.  Fixme: what is with trailing spaces? */
598     for(s = name; *s && spacep (s); s++ )
599         ;
600
601     switch (*s) {
602         case 0:    /* empty string is an error */
603             return 0;
604
605 #if 0
606         case '.':  /* an email address, compare from end */
607             mode = KEYDB_SEARCH_MODE_MAILEND;
608             s++;
609             desc->u.name = s;
610             break;
611 #endif
612
613         case '<':  /* an email address */
614             mode = KEYDB_SEARCH_MODE_MAIL;
615             desc->u.name = s;
616             break;
617
618         case '@':  /* part of an email address */
619             mode = KEYDB_SEARCH_MODE_MAILSUB;
620             s++;
621             desc->u.name = s;
622             break;
623
624         case '=':  /* exact compare */
625             mode = KEYDB_SEARCH_MODE_EXACT;
626             s++;
627             desc->u.name = s;
628             break;
629
630         case '*':  /* case insensitive substring search */
631             mode = KEYDB_SEARCH_MODE_SUBSTR;
632             s++;
633             desc->u.name = s;
634             break;
635
636 #if 0
637         case '+':  /* compare individual words */
638             mode = KEYDB_SEARCH_MODE_WORDS;
639             s++;
640             desc->u.name = s;
641             break;
642 #endif
643
644         case '#':  /* local user id */
645             return 0; /* This is now obsolete and van't not be used anymore*/
646
647         case ':': /*Unified fingerprint */
648             {
649                 const char *se, *si;
650                 int i;
651
652                 se = strchr( ++s,':');
653                 if ( !se )
654                     return 0;
655                 for (i=0,si=s; si < se; si++, i++ ) {
656                     if ( !strchr("01234567890abcdefABCDEF", *si ) )
657                         return 0; /* invalid digit */
658                 }
659                 if (i != 32 && i != 40)
660                     return 0; /* invalid length of fpr*/
661                 for (i=0,si=s; si < se; i++, si +=2)
662                     desc->u.fpr[i] = hextobyte(si);
663                 for ( ; i < 20; i++)
664                     desc->u.fpr[i]= 0;
665                 s = se + 1;
666                 mode = KEYDB_SEARCH_MODE_FPR;
667             }
668             break;
669
670         default:
671             if (s[0] == '0' && s[1] == 'x') {
672                 hexprefix = 1;
673                 s += 2;
674             }
675
676             hexlength = strspn(s, "0123456789abcdefABCDEF");
677             if (hexlength >= 8 && s[hexlength] =='!') {
678                 desc->exact = 1;
679                 hexlength++; /* just for the following check */
680             }
681
682             /* check if a hexadecimal number is terminated by EOS or blank */
683             if (hexlength && s[hexlength] && !spacep(s+hexlength)) {
684                 if (hexprefix)      /* a "0x" prefix without correct */
685                     return 0;       /* termination is an error */
686                 else                /* The first chars looked like */
687                     hexlength = 0;  /* a hex number, but really were not. */
688             }
689
690             if (desc->exact)
691                 hexlength--;
692
693             if (hexlength == 8
694                 || (!hexprefix && hexlength == 9 && *s == '0')){
695                 /* short keyid */
696                 if (hexlength == 9)
697                     s++;
698                 desc->u.kid[0] = 0;
699                 desc->u.kid[1] = strtoul( s, NULL, 16 );
700                 mode = KEYDB_SEARCH_MODE_SHORT_KID;
701             }
702             else if (hexlength == 16
703                      || (!hexprefix && hexlength == 17 && *s == '0')) {
704                 /* complete keyid */
705                 char buf[9];
706                 if (hexlength == 17)
707                     s++;
708                 mem2str(buf, s, 9 );
709                 desc->u.kid[0] = strtoul( buf, NULL, 16 );
710                 desc->u.kid[1] = strtoul( s+8, NULL, 16 );
711                 mode = KEYDB_SEARCH_MODE_LONG_KID;
712             }
713             else if (hexlength == 32 || (!hexprefix && hexlength == 33
714                                                             && *s == '0')) {
715                 /* md5 fingerprint */
716                 int i;
717                 if (hexlength == 33)
718                     s++;
719                 memset(desc->u.fpr+16, 0, 4);
720                 for (i=0; i < 16; i++, s+=2) {
721                     int c = hextobyte(s);
722                     if (c == -1)
723                         return 0;
724                     desc->u.fpr[i] = c;
725                 }
726                 mode = KEYDB_SEARCH_MODE_FPR16;
727             }
728             else if (hexlength == 40 || (!hexprefix && hexlength == 41
729                                                               && *s == '0')) {
730                 /* sha1/rmd160 fingerprint */
731                 int i;
732                 if (hexlength == 41)
733                     s++;
734                 for (i=0; i < 20; i++, s+=2) {
735                     int c = hextobyte(s);
736                     if (c == -1)
737                         return 0;
738                     desc->u.fpr[i] = c;
739                 }
740                 mode = KEYDB_SEARCH_MODE_FPR20;
741             }
742             else if (!hexprefix) {
743                 /* No hex indicator;  check for a space separated
744                    OpenPGP v4 fingerprint like:
745                      8061 5870 F5BA D690 3336  86D0 F2AD 85AC 1E42 B367
746                    or
747                      8061 5870 F5BA D690 3336 86D0 F2AD 85AC 1E42 B367
748                  */
749                 mode = 0;
750                 hexlength = strspn (s, " 0123456789abcdefABCDEF");
751                 if (s[hexlength] && s[hexlength] != ' ')
752                     hexlength = 0; /* Followed by non-space.  */
753                 while (hexlength && s[hexlength-1] == ' ')
754                     hexlength--;   /* Trim trailing spaces.  */
755                 if ((hexlength == 49 || hexlength == 50)
756                     && (!s[hexlength] || s[hexlength] == ' ')) {
757                     int i, c;
758
759                     for (i=0; i < 20; i++) {
760                         if (i && !(i % 2)) {
761                             if (*s != ' ')
762                                 break;
763                             s++;
764                             /* Skip the double space in the middle but
765                                don't require it to help copying
766                                fingerprints from sources which fold
767                                multiple space to one.  */
768                             if (i == 10 && *s == ' ')
769                                 s++;
770                         }
771
772                         c = hextobyte(s);
773                         if (c == -1)
774                             break;
775                         desc->u.fpr[i] = c;
776                         s += 2;
777                     }
778                     if (i == 20)
779                         mode = KEYDB_SEARCH_MODE_FPR20;
780                 }
781
782                 if (!mode) {
783                     desc->exact = 0;
784                     desc->u.name = s;
785                     mode = KEYDB_SEARCH_MODE_SUBSTR;   /* default mode */
786                 }
787             }
788             else        /* This was a hex number with a prefix */
789               return 0; /* and a wrong length */
790     }
791
792     desc->mode = mode;
793     return mode;
794 }
795
796
797 static int
798 skip_unusable(void *dummy, u32 *keyid,PKT_user_id *uid)
799 {
800   int unusable=0;
801   KBNODE keyblock;
802
803   (void)dummy;
804
805   keyblock=get_pubkeyblock(keyid);
806   if(!keyblock)
807     {
808       log_error("error checking usability status of %s\n",keystr(keyid));
809       goto leave;
810     }
811
812   /* Is the user ID in question revoked/expired? */
813   if(uid)
814     {
815       KBNODE node;
816
817       for(node=keyblock;node;node=node->next)
818         {
819           if(node->pkt->pkttype==PKT_USER_ID)
820             {
821               if(cmp_user_ids(uid,node->pkt->pkt.user_id)==0
822                  && (node->pkt->pkt.user_id->is_revoked
823                      || node->pkt->pkt.user_id->is_expired))
824                 {
825                   unusable=1;
826                   break;
827                 }
828             }
829         }
830     }
831
832   if(!unusable)
833     unusable=pk_is_disabled(keyblock->pkt->pkt.public_key);
834
835  leave:
836   release_kbnode(keyblock);
837   return unusable;
838 }
839
840 /****************
841  * Try to get the pubkey by the userid. This function looks for the
842  * first pubkey certificate which has the given name in a user_id.  if
843  * pk/sk has the pubkey algo set, the function will only return a
844  * pubkey with that algo.  If namelist is NULL, the first key is
845  * returned.  The caller should provide storage for either the pk or
846  * the sk.  If ret_kb is not NULL the function will return the
847  * keyblock there.
848  */
849
850 static int
851 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
852             PKT_public_key *pk, PKT_secret_key *sk,
853             int secmode, int include_unusable,
854             KBNODE *ret_kb, KEYDB_HANDLE *ret_kdbhd )
855 {
856     int rc = 0;
857     int n;
858     STRLIST r;
859     GETKEY_CTX ctx;
860     KBNODE help_kb = NULL;
861
862     if( retctx ) {/* reset the returned context in case of error */
863         assert (!ret_kdbhd);  /* not allowed because the handle is
864                                  stored in the context */
865         *retctx = NULL;
866     }
867     if (ret_kdbhd)
868         *ret_kdbhd = NULL;
869
870     if(!namelist)
871       {
872         ctx = xmalloc_clear (sizeof *ctx);
873         ctx->nitems = 1;
874         ctx->items[0].mode=KEYDB_SEARCH_MODE_FIRST;
875         if(!include_unusable)
876           ctx->items[0].skipfnc=skip_unusable;
877       }
878     else
879       {
880         /* build the search context */
881         for(n=0, r=namelist; r; r = r->next )
882           n++;
883
884         ctx = xmalloc_clear (sizeof *ctx + (n-1)*sizeof ctx->items );
885         ctx->nitems = n;
886
887         for(n=0, r=namelist; r; r = r->next, n++ )
888           {
889             classify_user_id (r->d, &ctx->items[n]);
890
891             if (ctx->items[n].exact)
892               ctx->exact = 1;
893             if (!ctx->items[n].mode)
894               {
895                 xfree (ctx);
896                 return G10ERR_INV_USER_ID;
897               }
898             if(!include_unusable
899                && ctx->items[n].mode!=KEYDB_SEARCH_MODE_SHORT_KID
900                && ctx->items[n].mode!=KEYDB_SEARCH_MODE_LONG_KID
901                && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR16
902                && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR20
903                && ctx->items[n].mode!=KEYDB_SEARCH_MODE_FPR)
904               ctx->items[n].skipfnc=skip_unusable;
905           }
906       }
907
908     ctx->kr_handle = keydb_new (secmode);
909     if ( !ret_kb )
910         ret_kb = &help_kb;
911
912     if( secmode ) {
913         if (sk) {
914             ctx->req_algo  = sk->req_algo;
915             ctx->req_usage = sk->req_usage;
916         }
917         rc = lookup( ctx, ret_kb, 1 );
918         if ( !rc && sk ) {
919             sk_from_block ( ctx, sk, *ret_kb );
920         }
921     }
922     else {
923         if (pk) {
924             ctx->req_algo  = pk->req_algo;
925             ctx->req_usage = pk->req_usage;
926         }
927         rc = lookup( ctx, ret_kb, 0 );
928         if ( !rc && pk ) {
929             pk_from_block ( ctx, pk, *ret_kb );
930         }
931     }
932
933     release_kbnode ( help_kb );
934
935     if (retctx) /* caller wants the context */
936         *retctx = ctx;
937     else {
938         if (ret_kdbhd) {
939             *ret_kdbhd = ctx->kr_handle;
940             ctx->kr_handle = NULL;
941         }
942         get_pubkey_end (ctx);
943     }
944
945     return rc;
946 }
947
948
949
950 /* Find a public key from NAME and return the keyblock or the key.  If
951    ret_kdb is not NULL, the KEYDB handle used to locate this keyblock
952    is returned and the caller is responsible for closing it.  If a key
953    was not found and NAME is a valid RFC822 mailbox and PKA retrieval
954    has been enabled, we try to import the pkea via the PKA
955    mechanism. */
956 int
957 get_pubkey_byname (PKT_public_key *pk,
958                    const char *name, KBNODE *ret_keyblock,
959                    KEYDB_HANDLE *ret_kdbhd, int include_unusable )
960 {
961   int rc;
962   STRLIST namelist = NULL;
963
964   add_to_strlist( &namelist, name );
965
966   rc = key_byname( NULL, namelist, pk, NULL, 0,
967                    include_unusable, ret_keyblock, ret_kdbhd);
968
969   /* If the requested name resembles a valid mailbox and automatic
970      retrieval has been enabled, we try to import the key. */
971
972   if (rc == G10ERR_NO_PUBKEY && is_valid_mailbox(name))
973     {
974       struct akl *akl;
975
976       for(akl=opt.auto_key_locate;akl;akl=akl->next)
977         {
978           unsigned char *fpr=NULL;
979           size_t fpr_len;
980
981           switch(akl->type)
982             {
983             case AKL_CERT:
984               glo_ctrl.in_auto_key_retrieve++;
985               rc=keyserver_import_cert(name,&fpr,&fpr_len);
986               glo_ctrl.in_auto_key_retrieve--;
987
988               if(rc==0)
989                 log_info(_("automatically retrieved `%s' via %s\n"),
990                          name,"DNS CERT");
991               break;
992
993             case AKL_PKA:
994               glo_ctrl.in_auto_key_retrieve++;
995               rc=keyserver_import_pka(name,&fpr,&fpr_len);
996               glo_ctrl.in_auto_key_retrieve--;
997
998               if(rc==0)
999                 log_info(_("automatically retrieved `%s' via %s\n"),
1000                          name,"PKA");
1001               break;
1002
1003             case AKL_LDAP:
1004               glo_ctrl.in_auto_key_retrieve++;
1005               rc=keyserver_import_ldap(name,&fpr,&fpr_len);
1006               glo_ctrl.in_auto_key_retrieve--;
1007
1008               if(rc==0)
1009                 log_info(_("automatically retrieved `%s' via %s\n"),
1010                          name,"LDAP");
1011               break;
1012
1013             case AKL_KEYSERVER:
1014               /* Strictly speaking, we don't need to only use a valid
1015                  mailbox for the getname search, but it helps cut down
1016                  on the problem of searching for something like "john"
1017                  and getting a whole lot of keys back. */
1018               if(opt.keyserver)
1019                 {
1020                   glo_ctrl.in_auto_key_retrieve++;
1021                   rc=keyserver_import_name(name,&fpr,&fpr_len,opt.keyserver);
1022                   glo_ctrl.in_auto_key_retrieve--;
1023
1024                   if(rc==0)
1025                     log_info(_("automatically retrieved `%s' via %s\n"),
1026                              name,opt.keyserver->uri);
1027                 }
1028               break;
1029
1030             case AKL_SPEC:
1031               {
1032                 struct keyserver_spec *keyserver;
1033
1034                 keyserver=keyserver_match(akl->spec);
1035                 glo_ctrl.in_auto_key_retrieve++;
1036                 rc=keyserver_import_name(name,&fpr,&fpr_len,keyserver);
1037                 glo_ctrl.in_auto_key_retrieve--;
1038
1039                 if(rc==0)
1040                   log_info(_("automatically retrieved `%s' via %s\n"),
1041                            name,akl->spec->uri);
1042               }
1043               break;
1044             }
1045
1046           /* Use the fingerprint of the key that we actually fetched.
1047              This helps prevent problems where the key that we fetched
1048              doesn't have the same name that we used to fetch it.  In
1049              the case of CERT and PKA, this is an actual security
1050              requirement as the URL might point to a key put in by an
1051              attacker.  By forcing the use of the fingerprint, we
1052              won't use the attacker's key here. */
1053           if(rc==0 && fpr)
1054             {
1055               int i;
1056               char fpr_string[MAX_FINGERPRINT_LEN*2+1];
1057
1058               assert(fpr_len<=MAX_FINGERPRINT_LEN);
1059
1060               free_strlist(namelist);
1061               namelist=NULL;
1062
1063               for(i=0;i<fpr_len;i++)
1064                 sprintf(fpr_string+2*i,"%02X",fpr[i]);
1065
1066               if(opt.verbose)
1067                 log_info("auto-key-locate found fingerprint %s\n",fpr_string);
1068
1069               add_to_strlist( &namelist, fpr_string );
1070
1071               xfree(fpr);
1072             }
1073
1074           rc = key_byname( NULL, namelist, pk, NULL, 0,
1075                            include_unusable, ret_keyblock, ret_kdbhd);
1076           if(rc!=G10ERR_NO_PUBKEY)
1077             break;
1078         }
1079     }
1080
1081   free_strlist( namelist );
1082   return rc;
1083 }
1084
1085 int
1086 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
1087                     STRLIST names, KBNODE *ret_keyblock )
1088 {
1089     return key_byname( retctx, names, pk, NULL, 0, 1, ret_keyblock, NULL);
1090 }
1091
1092 int
1093 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1094 {
1095     int rc;
1096
1097     rc = lookup( ctx, ret_keyblock, 0 );
1098     if ( !rc && pk && ret_keyblock )
1099         pk_from_block ( ctx, pk, *ret_keyblock );
1100
1101     return rc;
1102 }
1103
1104 void
1105 get_pubkey_end( GETKEY_CTX ctx )
1106 {
1107     if( ctx ) {
1108         memset (&ctx->kbpos, 0, sizeof ctx->kbpos);
1109         keydb_release (ctx->kr_handle);
1110         if( !ctx->not_allocated )
1111             xfree( ctx );
1112     }
1113 }
1114
1115
1116 /****************
1117  * Search for a key with the given fingerprint.
1118  * FIXME:
1119  * We should replace this with the _byname function.  Thiscsan be done
1120  * by creating a userID conforming to the unified fingerprint style.
1121  */
1122 int
1123 get_pubkey_byfprint( PKT_public_key *pk,
1124                      const byte *fprint, size_t fprint_len)
1125 {
1126     int rc;
1127
1128     if( fprint_len == 20 || fprint_len == 16 ) {
1129         struct getkey_ctx_s ctx;
1130         KBNODE kb = NULL;
1131
1132         memset( &ctx, 0, sizeof ctx );
1133         ctx.exact = 1 ;
1134         ctx.not_allocated = 1;
1135         ctx.kr_handle = keydb_new (0);
1136         ctx.nitems = 1;
1137         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
1138                                           : KEYDB_SEARCH_MODE_FPR20;
1139         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1140         rc = lookup( &ctx, &kb, 0 );
1141         if (!rc && pk )
1142             pk_from_block ( &ctx, pk, kb );
1143         release_kbnode ( kb );
1144         get_pubkey_end( &ctx );
1145     }
1146     else
1147         rc = G10ERR_GENERAL; /* Oops */
1148     return rc;
1149 }
1150
1151
1152 /* Get a public key and store it into the allocated pk.  This function
1153    differs from get_pubkey_byfprint() in that it does not do a check
1154    of the key to avoid recursion.  It should be used only in very
1155    certain cases.  PK may be NULL to check just for the existance of
1156    the key. */
1157 int
1158 get_pubkey_byfprint_fast (PKT_public_key *pk,
1159                           const byte *fprint, size_t fprint_len)
1160 {
1161   int rc = 0;
1162   KEYDB_HANDLE hd;
1163   KBNODE keyblock;
1164   byte fprbuf[MAX_FINGERPRINT_LEN];
1165   int i;
1166
1167   for (i=0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
1168     fprbuf[i] = fprint[i];
1169   while (i < MAX_FINGERPRINT_LEN)
1170     fprbuf[i++] = 0;
1171
1172   hd = keydb_new (0);
1173   rc = keydb_search_fpr (hd, fprbuf);
1174   if (rc == -1)
1175     {
1176       keydb_release (hd);
1177       return G10ERR_NO_PUBKEY;
1178     }
1179   rc = keydb_get_keyblock (hd, &keyblock);
1180   keydb_release (hd);
1181   if (rc)
1182     {
1183       log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1184       return G10ERR_NO_PUBKEY;
1185     }
1186
1187   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
1188            ||  keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1189   if (pk)
1190     copy_public_key (pk, keyblock->pkt->pkt.public_key );
1191   release_kbnode (keyblock);
1192
1193   /* Not caching key here since it won't have all of the fields
1194      properly set. */
1195
1196   return 0;
1197 }
1198
1199 /****************
1200  * Search for a key with the given fingerprint and return the
1201  * complete keyblock which may have more than only this key.
1202  */
1203 int
1204 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
1205                                                 size_t fprint_len )
1206 {
1207     int rc;
1208
1209     if( fprint_len == 20 || fprint_len == 16 ) {
1210         struct getkey_ctx_s ctx;
1211
1212         memset( &ctx, 0, sizeof ctx );
1213         ctx.not_allocated = 1;
1214         ctx.kr_handle = keydb_new (0);
1215         ctx.nitems = 1;
1216         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
1217                                           : KEYDB_SEARCH_MODE_FPR20;
1218         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1219         rc = lookup( &ctx, ret_keyblock, 0 );
1220         get_pubkey_end( &ctx );
1221     }
1222     else
1223         rc = G10ERR_GENERAL; /* Oops */
1224
1225     return rc;
1226 }
1227
1228
1229 /****************
1230  * Get a secret key by name and store it into sk
1231  * If NAME is NULL use the default key
1232  */
1233 static int
1234 get_seckey_byname2( GETKEY_CTX *retctx,
1235                     PKT_secret_key *sk, const char *name, int unprotect,
1236                     KBNODE *retblock )
1237 {
1238   STRLIST namelist = NULL;
1239   int rc,include_unusable=1;
1240
1241   /* If we have no name, try to use the default secret key.  If we
1242      have no default, we'll use the first usable one. */
1243
1244   if( !name && opt.def_secret_key && *opt.def_secret_key )
1245     add_to_strlist( &namelist, opt.def_secret_key );
1246   else if(name)
1247     add_to_strlist( &namelist, name );
1248   else
1249     include_unusable=0;
1250
1251   rc = key_byname( retctx, namelist, NULL, sk, 1, include_unusable,
1252                    retblock, NULL );
1253
1254   free_strlist( namelist );
1255
1256   if( !rc && unprotect )
1257     rc = check_secret_key( sk, 0 );
1258
1259   return rc;
1260 }
1261
1262 int
1263 get_seckey_byname( PKT_secret_key *sk, const char *name, int unlock )
1264 {
1265     return get_seckey_byname2 ( NULL, sk, name, unlock, NULL );
1266 }
1267
1268
1269 int
1270 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
1271                     STRLIST names, KBNODE *ret_keyblock )
1272 {
1273     return key_byname( retctx, names, NULL, sk, 1, 1, ret_keyblock, NULL );
1274 }
1275
1276
1277 int
1278 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1279 {
1280     int rc;
1281
1282     rc = lookup( ctx, ret_keyblock, 1 );
1283     if ( !rc && sk && ret_keyblock )
1284         sk_from_block ( ctx, sk, *ret_keyblock );
1285
1286     return rc;
1287 }
1288
1289
1290 void
1291 get_seckey_end( GETKEY_CTX ctx )
1292 {
1293     get_pubkey_end( ctx );
1294 }
1295
1296
1297 /****************
1298  * Search for a key with the given fingerprint.
1299  * FIXME:
1300  * We should replace this with the _byname function.  Thiscsan be done
1301  * by creating a userID conforming to the unified fingerprint style.
1302  */
1303 int
1304 get_seckey_byfprint( PKT_secret_key *sk,
1305                      const byte *fprint, size_t fprint_len)
1306 {
1307     int rc;
1308
1309     if( fprint_len == 20 || fprint_len == 16 ) {
1310         struct getkey_ctx_s ctx;
1311         KBNODE kb = NULL;
1312
1313         memset( &ctx, 0, sizeof ctx );
1314         ctx.exact = 1 ;
1315         ctx.not_allocated = 1;
1316         ctx.kr_handle = keydb_new (1);
1317         ctx.nitems = 1;
1318         ctx.items[0].mode = fprint_len==16? KEYDB_SEARCH_MODE_FPR16
1319                                           : KEYDB_SEARCH_MODE_FPR20;
1320         memcpy( ctx.items[0].u.fpr, fprint, fprint_len );
1321         rc = lookup( &ctx, &kb, 1 );
1322         if (!rc && sk )
1323             sk_from_block ( &ctx, sk, kb );
1324         release_kbnode ( kb );
1325         get_seckey_end( &ctx );
1326     }
1327     else
1328         rc = G10ERR_GENERAL; /* Oops */
1329     return rc;
1330 }
1331
1332
1333 /* Search for a secret key with the given fingerprint and return the
1334    complete keyblock which may have more than only this key. */
1335 int
1336 get_seckeyblock_byfprint (KBNODE *ret_keyblock, const byte *fprint,
1337                           size_t fprint_len )
1338 {
1339   int rc;
1340   struct getkey_ctx_s ctx;
1341
1342   if (fprint_len != 20 && fprint_len == 16)
1343     return G10ERR_GENERAL; /* Oops */
1344
1345   memset (&ctx, 0, sizeof ctx);
1346   ctx.not_allocated = 1;
1347   ctx.kr_handle = keydb_new (1);
1348   ctx.nitems = 1;
1349   ctx.items[0].mode = (fprint_len==16
1350                        ? KEYDB_SEARCH_MODE_FPR16
1351                        : KEYDB_SEARCH_MODE_FPR20);
1352   memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1353   rc = lookup (&ctx, ret_keyblock, 1);
1354   get_seckey_end (&ctx);
1355
1356   return rc;
1357 }
1358
1359
1360 \f
1361 /************************************************
1362  ************* Merging stuff ********************
1363  ************************************************/
1364
1365 /****************
1366  * merge all selfsignatures with the keys.
1367  * FIXME: replace this at least for the public key parts
1368  *        by merge_selfsigs.
1369  *        It is still used in keyedit.c and
1370  *        at 2 or 3 other places - check whether it is really needed.
1371  *        It might be needed by the key edit and import stuff because
1372  *        the keylock is changed.
1373  */
1374 void
1375 merge_keys_and_selfsig( KBNODE keyblock )
1376 {
1377     PKT_public_key *pk = NULL;
1378     PKT_secret_key *sk = NULL;
1379     PKT_signature *sig;
1380     KBNODE k;
1381     u32 kid[2] = { 0, 0 };
1382     u32 sigdate = 0;
1383
1384     if (keyblock && keyblock->pkt->pkttype == PKT_PUBLIC_KEY ) {
1385         /* divert to our new function */
1386         merge_selfsigs (keyblock);
1387         return;
1388     }
1389     /* still need the old one because the new one can't handle secret keys */
1390
1391     for(k=keyblock; k; k = k->next ) {
1392         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1393             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1394             pk = k->pkt->pkt.public_key; sk = NULL;
1395             if( pk->version < 4 )
1396                 pk = NULL; /* not needed for old keys */
1397             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1398                 keyid_from_pk( pk, kid );
1399             else if( !pk->expiredate ) { /* and subkey */
1400                 /* insert the expiration date here */
1401                 /*FIXME!!! pk->expiredate = subkeys_expiretime( k, kid );*/
1402             }
1403             sigdate = 0;
1404         }
1405         else if( k->pkt->pkttype == PKT_SECRET_KEY
1406             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1407             pk = NULL; sk = k->pkt->pkt.secret_key;
1408             if( sk->version < 4 )
1409                 sk = NULL;
1410             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1411                 keyid_from_sk( sk, kid );
1412             sigdate = 0;
1413         }
1414         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1415                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1416                  && sig->sig_class <= 0x30 && sig->version > 3
1417                  && !(sig->sig_class == 0x18 || sig->sig_class == 0x28)
1418                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1419             /* okay this is a self-signature which can be used.
1420              * This is not used for subkey binding signature, becuase this
1421              * is done above.
1422              * FIXME: We should only use this if the signature is valid
1423              *        but this is time consuming - we must provide another
1424              *        way to handle this
1425              */
1426             const byte *p;
1427             u32 ed;
1428
1429             p = parse_sig_subpkt( sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL );
1430             if( pk ) {
1431                 ed = p? pk->timestamp + buf32_to_u32(p):0;
1432                 if( sig->timestamp > sigdate ) {
1433                     pk->expiredate = ed;
1434                     sigdate = sig->timestamp;
1435                 }
1436             }
1437             else {
1438                 ed = p? sk->timestamp + buf32_to_u32(p):0;
1439                 if( sig->timestamp > sigdate ) {
1440                     sk->expiredate = ed;
1441                     sigdate = sig->timestamp;
1442                 }
1443             }
1444         }
1445
1446         if(pk && (pk->expiredate==0 ||
1447                   (pk->max_expiredate && pk->expiredate>pk->max_expiredate)))
1448           pk->expiredate=pk->max_expiredate;
1449
1450         if(sk && (sk->expiredate==0 ||
1451                   (sk->max_expiredate && sk->expiredate>sk->max_expiredate)))
1452           sk->expiredate=sk->max_expiredate;
1453     }
1454 }
1455
1456 static int
1457 parse_key_usage(PKT_signature *sig)
1458 {
1459   int key_usage=0;
1460   const byte *p;
1461   size_t n;
1462   byte flags;
1463
1464   p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_KEY_FLAGS,&n);
1465   if(p && n)
1466     {
1467       /* first octet of the keyflags */
1468       flags=*p;
1469
1470       if(flags & 1)
1471         {
1472           key_usage |= PUBKEY_USAGE_CERT;
1473           flags&=~1;
1474         }
1475
1476       if(flags & 2)
1477         {
1478           key_usage |= PUBKEY_USAGE_SIG;
1479           flags&=~2;
1480         }
1481
1482       /* We do not distinguish between encrypting communications and
1483          encrypting storage. */
1484       if(flags & (0x04|0x08))
1485         {
1486           key_usage |= PUBKEY_USAGE_ENC;
1487           flags&=~(0x04|0x08);
1488         }
1489
1490       if(flags & 0x20)
1491         {
1492           key_usage |= PUBKEY_USAGE_AUTH;
1493           flags&=~0x20;
1494         }
1495
1496       if(flags)
1497         key_usage |= PUBKEY_USAGE_UNKNOWN;
1498
1499       if (!key_usage)
1500         key_usage |= PUBKEY_USAGE_NONE;
1501     }
1502   else if (p) /* Key flags of length zero.  */
1503     key_usage |= PUBKEY_USAGE_NONE;
1504
1505   /* We set PUBKEY_USAGE_UNKNOWN to indicate that this key has a
1506      capability that we do not handle.  This serves to distinguish
1507      between a zero key usage which we handle as the default
1508      capabilities for that algorithm, and a usage that we do not
1509      handle.  Likewise we use PUBKEY_USAGE_NONE to indicate that
1510      key_flags have been given but they do not specify any usage.  */
1511
1512   return key_usage;
1513 }
1514
1515 /*
1516  * Apply information from SIGNODE (which is the valid self-signature
1517  * associated with that UID) to the UIDNODE:
1518  * - wether the UID has been revoked
1519  * - assumed creation date of the UID
1520  * - temporary store the keyflags here
1521  * - temporary store the key expiration time here
1522  * - mark whether the primary user ID flag hat been set.
1523  * - store the preferences
1524  */
1525 static void
1526 fixup_uidnode ( KBNODE uidnode, KBNODE signode, u32 keycreated )
1527 {
1528     PKT_user_id   *uid = uidnode->pkt->pkt.user_id;
1529     PKT_signature *sig = signode->pkt->pkt.signature;
1530     const byte *p, *sym, *hash, *zip;
1531     size_t n, nsym, nhash, nzip;
1532
1533     sig->flags.chosen_selfsig = 1; /* we chose this one */
1534     uid->created = 0; /* not created == invalid */
1535     if ( IS_UID_REV ( sig ) )
1536       {
1537         uid->is_revoked = 1;
1538         return; /* has been revoked */
1539       }
1540     else
1541       uid->is_revoked=0;
1542
1543     uid->expiredate = sig->expiredate;
1544
1545     if(sig->flags.expired)
1546       {
1547         uid->is_expired = 1;
1548         return; /* has expired */
1549       }
1550     else
1551       uid->is_expired=0;
1552
1553     uid->created = sig->timestamp; /* this one is okay */
1554     uid->selfsigversion = sig->version;
1555     /* If we got this far, it's not expired :) */
1556     uid->is_expired = 0;
1557
1558     /* store the key flags in the helper variable for later processing */
1559     uid->help_key_usage=parse_key_usage(sig);
1560
1561     /* ditto for the key expiration */
1562     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1563     if( p && buf32_to_u32 (p) )
1564       uid->help_key_expire = keycreated + buf32_to_u32(p);
1565     else
1566       uid->help_key_expire = 0;
1567
1568     /* Set the primary user ID flag - we will later wipe out some
1569      * of them to only have one in our keyblock */
1570     uid->is_primary = 0;
1571     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL );
1572     if ( p && *p )
1573         uid->is_primary = 2;
1574     /* We could also query this from the unhashed area if it is not in
1575      * the hased area and then later try to decide which is the better
1576      * there should be no security problem with this.
1577      * For now we only look at the hashed one.
1578      */
1579
1580     /* Now build the preferences list.  These must come from the
1581        hashed section so nobody can modify the ciphers a key is
1582        willing to accept. */
1583     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_SYM, &n );
1584     sym = p; nsym = p?n:0;
1585     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_HASH, &n );
1586     hash = p; nhash = p?n:0;
1587     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_COMPR, &n );
1588     zip = p; nzip = p?n:0;
1589     if (uid->prefs)
1590         xfree (uid->prefs);
1591     n = nsym + nhash + nzip;
1592     if (!n)
1593         uid->prefs = NULL;
1594     else {
1595         uid->prefs = xmalloc (sizeof (*uid->prefs) * (n+1));
1596         n = 0;
1597         for (; nsym; nsym--, n++) {
1598             uid->prefs[n].type = PREFTYPE_SYM;
1599             uid->prefs[n].value = *sym++;
1600         }
1601         for (; nhash; nhash--, n++) {
1602             uid->prefs[n].type = PREFTYPE_HASH;
1603             uid->prefs[n].value = *hash++;
1604         }
1605         for (; nzip; nzip--, n++) {
1606             uid->prefs[n].type = PREFTYPE_ZIP;
1607             uid->prefs[n].value = *zip++;
1608         }
1609         uid->prefs[n].type = PREFTYPE_NONE; /* end of list marker */
1610         uid->prefs[n].value = 0;
1611     }
1612
1613     /* see whether we have the MDC feature */
1614     uid->flags.mdc = 0;
1615     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
1616     if (p && n && (p[0] & 0x01))
1617         uid->flags.mdc = 1;
1618
1619     /* and the keyserver modify flag */
1620     uid->flags.ks_modify = 1;
1621     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
1622     if (p && n && (p[0] & 0x80))
1623         uid->flags.ks_modify = 0;
1624 }
1625
1626 static void
1627 sig_to_revoke_info(PKT_signature *sig,struct revoke_info *rinfo)
1628 {
1629   rinfo->date = sig->timestamp;
1630   rinfo->algo = sig->pubkey_algo;
1631   rinfo->keyid[0] = sig->keyid[0];
1632   rinfo->keyid[1] = sig->keyid[1];
1633 }
1634
1635 static void
1636 merge_selfsigs_main(KBNODE keyblock, int *r_revoked, struct revoke_info *rinfo)
1637 {
1638     PKT_public_key *pk = NULL;
1639     KBNODE k;
1640     u32 kid[2];
1641     u32 sigdate, uiddate, uiddate2;
1642     KBNODE signode, uidnode, uidnode2;
1643     u32 curtime = make_timestamp ();
1644     unsigned int key_usage = 0;
1645     u32 keytimestamp = 0;
1646     u32 key_expire = 0;
1647     int key_expire_seen = 0;
1648     byte sigversion = 0;
1649
1650     *r_revoked = 0;
1651     memset(rinfo,0,sizeof(*rinfo));
1652
1653     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY )
1654         BUG ();
1655     pk = keyblock->pkt->pkt.public_key;
1656     keytimestamp = pk->timestamp;
1657
1658     keyid_from_pk( pk, kid );
1659     pk->main_keyid[0] = kid[0];
1660     pk->main_keyid[1] = kid[1];
1661
1662     if ( pk->version < 4 ) {
1663         /* before v4 the key packet itself contains the expiration
1664          * date and there was no way to change it, so we start with
1665          * the one from the key packet */
1666         key_expire = pk->max_expiredate;
1667         key_expire_seen = 1;
1668     }
1669
1670     /* first pass: find the latest direct key self-signature.
1671      * We assume that the newest one overrides all others
1672      */
1673
1674     /* In case this key was already merged */
1675     xfree(pk->revkey);
1676     pk->revkey=NULL;
1677     pk->numrevkeys=0;
1678
1679     signode = NULL;
1680     sigdate = 0; /* helper to find the latest signature */
1681     for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next ) {
1682         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
1683             PKT_signature *sig = k->pkt->pkt.signature;
1684             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) {
1685                 if ( check_key_signature( keyblock, k, NULL ) )
1686                     ; /* signature did not verify */
1687                 else if ( IS_KEY_REV (sig) ){
1688                     /* key has been revoked - there is no way to override
1689                      * such a revocation, so we theoretically can stop now.
1690                      * We should not cope with expiration times for revocations
1691                      * here because we have to assume that an attacker can
1692                      * generate all kinds of signatures.  However due to the
1693                      * fact that the key has been revoked it does not harm
1694                      * either and by continuing we gather some more info on
1695                      * that key.
1696                      */
1697                     *r_revoked = 1;
1698                     sig_to_revoke_info(sig,rinfo);
1699                 }
1700                 else if ( IS_KEY_SIG (sig) ) {
1701                   /* Add any revocation keys onto the pk.  This is
1702                      particularly interesting since we normally only
1703                      get data from the most recent 1F signature, but
1704                      you need multiple 1F sigs to properly handle
1705                      revocation keys (PGP does it this way, and a
1706                      revocation key could be sensitive and hence in a
1707                      different signature). */
1708                   if(sig->revkey) {
1709                     int i;
1710
1711                     pk->revkey=
1712                       xrealloc(pk->revkey,sizeof(struct revocation_key)*
1713                                 (pk->numrevkeys+sig->numrevkeys));
1714
1715                     for(i=0;i<sig->numrevkeys;i++)
1716                       memcpy(&pk->revkey[pk->numrevkeys++],
1717                              sig->revkey[i],
1718                              sizeof(struct revocation_key));
1719                   }
1720
1721                   if( sig->timestamp >= sigdate ) {
1722                     if(sig->flags.expired)
1723                         ; /* signature has expired - ignore it */
1724                     else {
1725                         sigdate = sig->timestamp;
1726                         signode = k;
1727                         if( sig->version > sigversion )
1728                           sigversion = sig->version;
1729
1730                     }
1731                   }
1732                 }
1733             }
1734         }
1735     }
1736
1737     /* Remove dupes from the revocation keys */
1738
1739     if(pk->revkey)
1740       {
1741         int i,j,x,changed=0;
1742
1743         for(i=0;i<pk->numrevkeys;i++)
1744           {
1745             for(j=i+1;j<pk->numrevkeys;j++)
1746               {
1747                 if(memcmp(&pk->revkey[i],&pk->revkey[j],
1748                           sizeof(struct revocation_key))==0)
1749                   {
1750                     /* remove j */
1751
1752                     for(x=j;x<pk->numrevkeys-1;x++)
1753                       pk->revkey[x]=pk->revkey[x+1];
1754
1755                     pk->numrevkeys--;
1756                     j--;
1757                     changed=1;
1758                   }
1759               }
1760           }
1761
1762         if(changed)
1763           pk->revkey=xrealloc(pk->revkey,
1764                                pk->numrevkeys*sizeof(struct revocation_key));
1765       }
1766
1767     if ( signode )
1768       {
1769         /* some information from a direct key signature take precedence
1770          * over the same information given in UID sigs.
1771          */
1772         PKT_signature *sig = signode->pkt->pkt.signature;
1773         const byte *p;
1774
1775         key_usage=parse_key_usage(sig);
1776
1777         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1778         if( p && buf32_to_u32 (p) )
1779           {
1780             key_expire = keytimestamp + buf32_to_u32 (p);
1781             key_expire_seen = 1;
1782           }
1783
1784         /* mark that key as valid: one direct key signature should
1785          * render a key as valid */
1786         pk->is_valid = 1;
1787       }
1788
1789     /* pass 1.5: look for key revocation signatures that were not made
1790        by the key (i.e. did a revocation key issue a revocation for
1791        us?).  Only bother to do this if there is a revocation key in
1792        the first place and we're not revoked already. */
1793
1794     if(!*r_revoked && pk->revkey)
1795       for(k=keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next )
1796         {
1797           if ( k->pkt->pkttype == PKT_SIGNATURE )
1798             {
1799               PKT_signature *sig = k->pkt->pkt.signature;
1800
1801               if(IS_KEY_REV(sig) &&
1802                  (sig->keyid[0]!=kid[0] || sig->keyid[1]!=kid[1]))
1803                 {
1804                   int rc=check_revocation_keys(pk,sig);
1805                   if(rc==0)
1806                     {
1807                       *r_revoked=2;
1808                       sig_to_revoke_info(sig,rinfo);
1809                       /* don't continue checking since we can't be any
1810                          more revoked than this */
1811                       break;
1812                     }
1813                   else if(rc==G10ERR_NO_PUBKEY)
1814                     pk->maybe_revoked=1;
1815
1816                   /* A failure here means the sig did not verify, was
1817                      not issued by a revocation key, or a revocation
1818                      key loop was broken.  If a revocation key isn't
1819                      findable, however, the key might be revoked and
1820                      we don't know it. */
1821
1822                   /* TODO: In the future handle subkey and cert
1823                      revocations?  PGP doesn't, but it's in 2440. */
1824                 }
1825             }
1826         }
1827
1828     /* second pass: look at the self-signature of all user IDs */
1829     signode = uidnode = NULL;
1830     sigdate = 0; /* helper to find the latest signature in one user ID */
1831     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1832         if ( k->pkt->pkttype == PKT_USER_ID ) {
1833             if ( uidnode && signode )
1834               {
1835                 fixup_uidnode ( uidnode, signode, keytimestamp );
1836                 pk->is_valid=1;
1837               }
1838             uidnode = k;
1839             signode = NULL;
1840             sigdate = 0;
1841         }
1842         else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode ) {
1843             PKT_signature *sig = k->pkt->pkt.signature;
1844             if ( sig->keyid[0] == kid[0] && sig->keyid[1]==kid[1] ) {
1845                 if ( check_key_signature( keyblock, k, NULL ) )
1846                     ; /* signature did not verify */
1847                 else if ( (IS_UID_SIG (sig) || IS_UID_REV (sig))
1848                           && sig->timestamp >= sigdate )
1849                   {
1850                     /* Note: we allow to invalidate cert revocations
1851                      * by a newer signature.  An attacker can't use this
1852                      * because a key should be revoced with a key revocation.
1853                      * The reason why we have to allow for that is that at
1854                      * one time an email address may become invalid but later
1855                      * the same email address may become valid again (hired,
1856                      * fired, hired again).
1857                      */
1858
1859                     sigdate = sig->timestamp;
1860                     signode = k;
1861                     signode->pkt->pkt.signature->flags.chosen_selfsig=0;
1862                     if( sig->version > sigversion )
1863                       sigversion = sig->version;
1864                   }
1865             }
1866         }
1867     }
1868     if ( uidnode && signode ) {
1869         fixup_uidnode ( uidnode, signode, keytimestamp );
1870         pk->is_valid = 1;
1871     }
1872
1873     /* If the key isn't valid yet, and we have
1874        --allow-non-selfsigned-uid set, then force it valid. */
1875     if(!pk->is_valid && opt.allow_non_selfsigned_uid)
1876       {
1877         if(opt.verbose)
1878           log_info(_("Invalid key %s made valid by"
1879                      " --allow-non-selfsigned-uid\n"),keystr_from_pk(pk));
1880         pk->is_valid = 1;
1881       }
1882
1883     /* The key STILL isn't valid, so try and find an ultimately
1884        trusted signature. */
1885     if(!pk->is_valid)
1886       {
1887         uidnode=NULL;
1888
1889         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k=k->next)
1890           {
1891             if ( k->pkt->pkttype == PKT_USER_ID )
1892               uidnode = k;
1893             else if ( k->pkt->pkttype == PKT_SIGNATURE && uidnode )
1894               {
1895                 PKT_signature *sig = k->pkt->pkt.signature;
1896
1897                 if(sig->keyid[0] != kid[0] || sig->keyid[1]!=kid[1])
1898                   {
1899                     PKT_public_key *ultimate_pk;
1900
1901                     ultimate_pk=xmalloc_clear(sizeof(*ultimate_pk));
1902
1903                     /* We don't want to use the full get_pubkey to
1904                        avoid infinite recursion in certain cases.
1905                        There is no reason to check that an ultimately
1906                        trusted key is still valid - if it has been
1907                        revoked or the user should also renmove the
1908                        ultimate trust flag.  */
1909                     if(get_pubkey_fast(ultimate_pk,sig->keyid)==0
1910                        && check_key_signature2(keyblock,k,ultimate_pk,
1911                                                NULL,NULL,NULL,NULL)==0
1912                        && get_ownertrust(ultimate_pk)==TRUST_ULTIMATE)
1913                       {
1914                         free_public_key(ultimate_pk);
1915                         pk->is_valid=1;
1916                         break;
1917                       }
1918
1919                     free_public_key(ultimate_pk);
1920                   }
1921               }
1922           }
1923       }
1924
1925     /* Record the highest selfsig version so we know if this is a v3
1926        key through and through, or a v3 key with a v4 selfsig
1927        somewhere.  This is useful in a few places to know if the key
1928        must be treated as PGP2-style or OpenPGP-style.  Note that a
1929        selfsig revocation with a higher version number will also raise
1930        this value.  This is okay since such a revocation must be
1931        issued by the user (i.e. it cannot be issued by someone else to
1932        modify the key behavior.) */
1933
1934     pk->selfsigversion=sigversion;
1935
1936     /* Now that we had a look at all user IDs we can now get some information
1937      * from those user IDs.
1938      */
1939
1940     if ( !key_usage ) {
1941         /* find the latest user ID with key flags set */
1942         uiddate = 0; /* helper to find the latest user ID */
1943         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1944             k = k->next ) {
1945             if ( k->pkt->pkttype == PKT_USER_ID ) {
1946                 PKT_user_id *uid = k->pkt->pkt.user_id;
1947                 if ( uid->help_key_usage && uid->created > uiddate ) {
1948                     key_usage = uid->help_key_usage;
1949                     uiddate = uid->created;
1950                 }
1951             }
1952         }
1953     }
1954     if ( !key_usage ) { /* no key flags at all: get it from the algo */
1955         key_usage = openpgp_pk_algo_usage ( pk->pubkey_algo );
1956     }
1957     else { /* check that the usage matches the usage as given by the algo */
1958         int x = openpgp_pk_algo_usage ( pk->pubkey_algo );
1959         if ( x ) /* mask it down to the actual allowed usage */
1960             key_usage &= x;
1961     }
1962
1963     /* Whatever happens, it's a primary key, so it can certify. */
1964     pk->pubkey_usage = key_usage|PUBKEY_USAGE_CERT;
1965
1966     if ( !key_expire_seen ) {
1967         /* find the latest valid user ID with a key expiration set
1968          * Note, that this may be a different one from the above because
1969          * some user IDs may have no expiration date set */
1970         uiddate = 0;
1971         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1972             k = k->next ) {
1973             if ( k->pkt->pkttype == PKT_USER_ID ) {
1974                 PKT_user_id *uid = k->pkt->pkt.user_id;
1975                 if ( uid->help_key_expire && uid->created > uiddate ) {
1976                     key_expire = uid->help_key_expire;
1977                     uiddate = uid->created;
1978                 }
1979             }
1980         }
1981     }
1982
1983     /* Currently only v3 keys have a maximum expiration date, but I'll
1984        bet v5 keys get this feature again. */
1985     if(key_expire==0 || (pk->max_expiredate && key_expire>pk->max_expiredate))
1986       key_expire=pk->max_expiredate;
1987
1988     pk->has_expired = key_expire >= curtime? 0 : key_expire;
1989     pk->expiredate = key_expire;
1990
1991     /* Fixme: we should see how to get rid of the expiretime fields  but
1992      * this needs changes at other places too. */
1993
1994     /* and now find the real primary user ID and delete all others */
1995     uiddate = uiddate2 = 0;
1996     uidnode = uidnode2 = NULL;
1997     for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next ) {
1998         if ( k->pkt->pkttype == PKT_USER_ID &&
1999              !k->pkt->pkt.user_id->attrib_data) {
2000             PKT_user_id *uid = k->pkt->pkt.user_id;
2001             if (uid->is_primary)
2002               {
2003                 if(uid->created > uiddate)
2004                   {
2005                     uiddate = uid->created;
2006                     uidnode = k;
2007                   }
2008                 else if(uid->created==uiddate && uidnode)
2009                   {
2010                     /* The dates are equal, so we need to do a
2011                        different (and arbitrary) comparison.  This
2012                        should rarely, if ever, happen.  It's good to
2013                        try and guarantee that two different GnuPG
2014                        users with two different keyrings at least pick
2015                        the same primary. */
2016                     if(cmp_user_ids(uid,uidnode->pkt->pkt.user_id)>0)
2017                       uidnode=k;
2018                   }
2019               }
2020             else
2021               {
2022                 if(uid->created > uiddate2)
2023                   {
2024                     uiddate2 = uid->created;
2025                     uidnode2 = k;
2026                   }
2027                 else if(uid->created==uiddate2 && uidnode2)
2028                   {
2029                     if(cmp_user_ids(uid,uidnode2->pkt->pkt.user_id)>0)
2030                       uidnode2=k;
2031                   }
2032               }
2033         }
2034     }
2035     if ( uidnode ) {
2036         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2037             k = k->next ) {
2038             if ( k->pkt->pkttype == PKT_USER_ID &&
2039                  !k->pkt->pkt.user_id->attrib_data) {
2040                 PKT_user_id *uid = k->pkt->pkt.user_id;
2041                 if ( k != uidnode )
2042                     uid->is_primary = 0;
2043             }
2044         }
2045     }
2046     else if( uidnode2 ) {
2047         /* none is flagged primary - use the latest user ID we have,
2048            and disambiguate with the arbitrary packet comparison. */
2049         uidnode2->pkt->pkt.user_id->is_primary = 1;
2050     }
2051     else
2052       {
2053         /* None of our uids were self-signed, so pick the one that
2054            sorts first to be the primary.  This is the best we can do
2055            here since there are no self sigs to date the uids. */
2056
2057         uidnode = NULL;
2058
2059         for(k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2060             k = k->next )
2061           {
2062             if(k->pkt->pkttype==PKT_USER_ID
2063                && !k->pkt->pkt.user_id->attrib_data)
2064               {
2065                 if(!uidnode)
2066                   {
2067                     uidnode=k;
2068                     uidnode->pkt->pkt.user_id->is_primary=1;
2069                     continue;
2070                   }
2071                 else
2072                   {
2073                     if(cmp_user_ids(k->pkt->pkt.user_id,
2074                                     uidnode->pkt->pkt.user_id)>0)
2075                       {
2076                         uidnode->pkt->pkt.user_id->is_primary=0;
2077                         uidnode=k;
2078                         uidnode->pkt->pkt.user_id->is_primary=1;
2079                       }
2080                     else
2081                       k->pkt->pkt.user_id->is_primary=0; /* just to be
2082                                                             safe */
2083                   }
2084               }
2085           }
2086       }
2087 }
2088
2089 /* Convert a buffer to a signature.  Useful for 0x19 embedded sigs.
2090    Caller must free the signature when they are done. */
2091 static PKT_signature *
2092 buf_to_sig(const byte *buf,size_t len)
2093 {
2094   PKT_signature *sig=xmalloc_clear(sizeof(PKT_signature));
2095   IOBUF iobuf=iobuf_temp_with_content(buf,len);
2096   int save_mode=set_packet_list_mode(0);
2097
2098   if(parse_signature(iobuf,PKT_SIGNATURE,len,sig)!=0)
2099     {
2100       xfree(sig);
2101       sig=NULL;
2102     }
2103
2104   set_packet_list_mode(save_mode);
2105   iobuf_close(iobuf);
2106
2107   return sig;
2108 }
2109
2110 static void
2111 merge_selfsigs_subkey( KBNODE keyblock, KBNODE subnode )
2112 {
2113     PKT_public_key *mainpk = NULL, *subpk = NULL;
2114     PKT_signature *sig;
2115     KBNODE k;
2116     u32 mainkid[2];
2117     u32 sigdate = 0;
2118     KBNODE signode;
2119     u32 curtime = make_timestamp ();
2120     unsigned int key_usage = 0;
2121     u32 keytimestamp = 0;
2122     u32 key_expire = 0;
2123     const byte *p;
2124
2125     if ( subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY )
2126         BUG ();
2127     mainpk = keyblock->pkt->pkt.public_key;
2128     if ( mainpk->version < 4 )
2129         return; /* (actually this should never happen) */
2130     keyid_from_pk( mainpk, mainkid );
2131     subpk = subnode->pkt->pkt.public_key;
2132     keytimestamp = subpk->timestamp;
2133
2134     subpk->is_valid = 0;
2135     subpk->main_keyid[0] = mainpk->main_keyid[0];
2136     subpk->main_keyid[1] = mainpk->main_keyid[1];
2137
2138     /* find the latest key binding self-signature. */
2139     signode = NULL;
2140     sigdate = 0; /* helper to find the latest signature */
2141     for(k=subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2142                                                         k = k->next ) {
2143         if ( k->pkt->pkttype == PKT_SIGNATURE ) {
2144             sig = k->pkt->pkt.signature;
2145             if ( sig->keyid[0] == mainkid[0] && sig->keyid[1]==mainkid[1] ) {
2146                 if ( check_key_signature( keyblock, k, NULL ) )
2147                     ; /* signature did not verify */
2148                 else if ( IS_SUBKEY_REV (sig) ) {
2149                   /* Note that this means that the date on a
2150                      revocation sig does not matter - even if the
2151                      binding sig is dated after the revocation sig,
2152                      the subkey is still marked as revoked.  This
2153                      seems ok, as it is just as easy to make new
2154                      subkeys rather than re-sign old ones as the
2155                      problem is in the distribution.  Plus, PGP (7)
2156                      does this the same way.  */
2157                     subpk->is_revoked = 1;
2158                     sig_to_revoke_info(sig,&subpk->revoked);
2159                     /* although we could stop now, we continue to
2160                      * figure out other information like the old expiration
2161                      * time */
2162                 }
2163                 else if ( IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate )
2164                   {
2165                     if(sig->flags.expired)
2166                       ; /* signature has expired - ignore it */
2167                     else
2168                       {
2169                         sigdate = sig->timestamp;
2170                         signode = k;
2171                         signode->pkt->pkt.signature->flags.chosen_selfsig=0;
2172                       }
2173                   }
2174             }
2175         }
2176     }
2177
2178     /* no valid key binding */
2179     if ( !signode )
2180       return;
2181
2182     sig = signode->pkt->pkt.signature;
2183     sig->flags.chosen_selfsig=1; /* so we know which selfsig we chose later */
2184
2185     key_usage=parse_key_usage(sig);
2186     if ( !key_usage )
2187       {
2188         /* no key flags at all: get it from the algo */
2189         key_usage = openpgp_pk_algo_usage ( subpk->pubkey_algo );
2190       }
2191     else
2192       {
2193         /* check that the usage matches the usage as given by the algo */
2194         int x = openpgp_pk_algo_usage ( subpk->pubkey_algo );
2195         if ( x ) /* mask it down to the actual allowed usage */
2196           key_usage &= x;
2197       }
2198
2199     subpk->pubkey_usage = key_usage;
2200
2201     p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2202     if ( p && buf32_to_u32 (p) )
2203         key_expire = keytimestamp + buf32_to_u32 (p);
2204     else
2205         key_expire = 0;
2206     subpk->has_expired = key_expire >= curtime? 0 : key_expire;
2207     subpk->expiredate = key_expire;
2208
2209     /* Check that algo exists.  Elgamal sign+encrypt are only allowed
2210        with option --rfc2440. */
2211     if (RFC2440 && subpk->pubkey_algo == PUBKEY_ALGO_ELGAMAL)
2212       ;
2213     else if(check_pubkey_algo(subpk->pubkey_algo))
2214       return;
2215
2216     subpk->is_valid = 1;
2217
2218     /* Find the most recent 0x19 embedded signature on our self-sig. */
2219     if(subpk->backsig==0)
2220       {
2221         int seq=0;
2222         size_t n;
2223         PKT_signature *backsig=NULL;
2224
2225         sigdate=0;
2226
2227         /* We do this while() since there may be other embedded
2228            signatures in the future.  We only want 0x19 here. */
2229
2230         while((p=enum_sig_subpkt(sig->hashed,
2231                                  SIGSUBPKT_SIGNATURE,&n,&seq,NULL)))
2232           if(n>3 && ((p[0]==3 && p[2]==0x19) || (p[0]==4 && p[1]==0x19)))
2233             {
2234               PKT_signature *tempsig=buf_to_sig(p,n);
2235               if(tempsig)
2236                 {
2237                   if(tempsig->timestamp>sigdate)
2238                     {
2239                       if(backsig)
2240                         free_seckey_enc(backsig);
2241
2242                       backsig=tempsig;
2243                       sigdate=backsig->timestamp;
2244                     }
2245                   else
2246                     free_seckey_enc(tempsig);
2247                 }
2248             }
2249
2250         seq=0;
2251
2252         /* It is safe to have this in the unhashed area since the 0x19
2253            is located on the selfsig for convenience, not security. */
2254
2255         while((p=enum_sig_subpkt(sig->unhashed,SIGSUBPKT_SIGNATURE,
2256                                  &n,&seq,NULL)))
2257           if(n>3 && ((p[0]==3 && p[2]==0x19) || (p[0]==4 && p[1]==0x19)))
2258             {
2259               PKT_signature *tempsig=buf_to_sig(p,n);
2260               if(tempsig)
2261                 {
2262                   if(tempsig->timestamp>sigdate)
2263                     {
2264                       if(backsig)
2265                         free_seckey_enc(backsig);
2266
2267                       backsig=tempsig;
2268                       sigdate=backsig->timestamp;
2269                     }
2270                   else
2271                     free_seckey_enc(tempsig);
2272                 }
2273             }
2274
2275         if(backsig)
2276           {
2277             /* At ths point, backsig contains the most recent 0x19 sig.
2278                Let's see if it is good. */
2279
2280             /* 2==valid, 1==invalid, 0==didn't check */
2281             if(check_backsig(mainpk,subpk,backsig)==0)
2282               subpk->backsig=2;
2283             else
2284               subpk->backsig=1;
2285
2286             free_seckey_enc(backsig);
2287           }
2288       }
2289 }
2290
2291
2292 /*
2293  * Merge information from the self-signatures with the key, so that
2294  * we can later use them more easy.
2295  * The function works by first applying the self signatures to the
2296  * primary key and the to each subkey.
2297  * Here are the rules we use to decide which inormation from which
2298  * self-signature is used:
2299  * We check all self signatures or validity and ignore all invalid signatures.
2300  * All signatures are then ordered by their creation date ....
2301  * For the primary key:
2302  *   FIXME the docs
2303  */
2304 static void
2305 merge_selfsigs( KBNODE keyblock )
2306 {
2307     KBNODE k;
2308     int revoked;
2309     struct revoke_info rinfo;
2310     PKT_public_key *main_pk;
2311     prefitem_t *prefs;
2312     int mdc_feature;
2313
2314     if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY ) {
2315         if (keyblock->pkt->pkttype == PKT_SECRET_KEY ) {
2316             log_error ("expected public key but found secret key "
2317                        "- must stop\n");
2318             /* we better exit here becuase a public key is expected at
2319                other places too.  FIXME: Figure this out earlier and
2320                don't get to here at all */
2321             g10_exit (1);
2322         }
2323         BUG ();
2324     }
2325
2326     merge_selfsigs_main ( keyblock, &revoked, &rinfo );
2327
2328     /* now merge in the data from each of the subkeys */
2329     for(k=keyblock; k; k = k->next ) {
2330         if (  k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2331             merge_selfsigs_subkey ( keyblock, k );
2332         }
2333     }
2334
2335     main_pk = keyblock->pkt->pkt.public_key;
2336     if ( revoked || main_pk->has_expired || !main_pk->is_valid ) {
2337         /* if the primary key is revoked, expired, or invalid we
2338          * better set the appropriate flags on that key and all
2339          * subkeys */
2340         for(k=keyblock; k; k = k->next ) {
2341             if ( k->pkt->pkttype == PKT_PUBLIC_KEY
2342                 || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2343                 PKT_public_key *pk = k->pkt->pkt.public_key;
2344                 if(!main_pk->is_valid)
2345                   pk->is_valid = 0;
2346                 if(revoked && !pk->is_revoked)
2347                   {
2348                     pk->is_revoked = revoked;
2349                     memcpy(&pk->revoked,&rinfo,sizeof(rinfo));
2350                   }
2351                 if(main_pk->has_expired)
2352                   pk->has_expired = main_pk->has_expired;
2353             }
2354         }
2355         return;
2356     }
2357
2358     /* set the preference list of all keys to those of the primary real
2359      * user ID.  Note: we use these preferences when we don't know by
2360      * which user ID the key has been selected.
2361      * fixme: we should keep atoms of commonly used preferences or
2362      * use reference counting to optimize the preference lists storage.
2363      * FIXME: it might be better to use the intersection of
2364      * all preferences.
2365      * Do a similar thing for the MDC feature flag.
2366      */
2367     prefs = NULL;
2368     mdc_feature = 0;
2369     for (k=keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next) {
2370         if (k->pkt->pkttype == PKT_USER_ID
2371             && !k->pkt->pkt.user_id->attrib_data
2372             && k->pkt->pkt.user_id->is_primary) {
2373             prefs = k->pkt->pkt.user_id->prefs;
2374             mdc_feature = k->pkt->pkt.user_id->flags.mdc;
2375             break;
2376         }
2377     }
2378     for(k=keyblock; k; k = k->next ) {
2379         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
2380              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2381             PKT_public_key *pk = k->pkt->pkt.public_key;
2382             if (pk->prefs)
2383                 xfree (pk->prefs);
2384             pk->prefs = copy_prefs (prefs);
2385             pk->mdc_feature = mdc_feature;
2386         }
2387     }
2388 }
2389
2390
2391 /*
2392  * Merge the secret keys from secblock into the pubblock thereby
2393  * replacing the public (sub)keys with their secret counterparts Hmmm:
2394  * It might be better to get away from the concept of entire secret
2395  * keys at all and have a way to store just the real secret parts
2396  * from the key.
2397  */
2398 static void
2399 merge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
2400 {
2401     KBNODE pub;
2402
2403     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2404     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2405
2406     for (pub=pubblock; pub; pub = pub->next ) {
2407         if ( pub->pkt->pkttype == PKT_PUBLIC_KEY ) {
2408              PKT_public_key *pk = pub->pkt->pkt.public_key;
2409              PKT_secret_key *sk = secblock->pkt->pkt.secret_key;
2410              assert ( pub == pubblock ); /* only in the first node */
2411              /* there is nothing to compare in this case, so just replace
2412               * some information */
2413              copy_public_parts_to_secret_key ( pk, sk );
2414              free_public_key ( pk );
2415              pub->pkt->pkttype = PKT_SECRET_KEY;
2416              pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2417         }
2418         else if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2419             KBNODE sec;
2420             PKT_public_key *pk = pub->pkt->pkt.public_key;
2421
2422             /* this is more complicated: it may happen that the sequence
2423              * of the subkeys dosn't match, so we have to find the
2424              * appropriate secret key */
2425             for (sec=secblock->next; sec; sec = sec->next ) {
2426                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2427                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2428                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2429                         copy_public_parts_to_secret_key ( pk, sk );
2430                         free_public_key ( pk );
2431                         pub->pkt->pkttype = PKT_SECRET_SUBKEY;
2432                         pub->pkt->pkt.secret_key = copy_secret_key (NULL, sk);
2433                         break;
2434                     }
2435                 }
2436             }
2437             if ( !sec )
2438                 BUG(); /* already checked in premerge */
2439         }
2440     }
2441 }
2442
2443 /* This function checks that for every public subkey a corresponding
2444  * secret subkey is available and deletes the public subkey otherwise.
2445  * We need this function because we can't delete it later when we
2446  * actually merge the secret parts into the pubring.
2447  * The function also plays some games with the node flags.
2448  */
2449 static void
2450 premerge_public_with_secret ( KBNODE pubblock, KBNODE secblock )
2451 {
2452     KBNODE last, pub;
2453
2454     assert ( pubblock->pkt->pkttype == PKT_PUBLIC_KEY );
2455     assert ( secblock->pkt->pkttype == PKT_SECRET_KEY );
2456
2457     for (pub=pubblock,last=NULL; pub; last = pub, pub = pub->next ) {
2458         pub->flag &= ~3; /* reset bits 0 and 1 */
2459         if ( pub->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2460             KBNODE sec;
2461             PKT_public_key *pk = pub->pkt->pkt.public_key;
2462
2463             for (sec=secblock->next; sec; sec = sec->next ) {
2464                 if ( sec->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2465                     PKT_secret_key *sk = sec->pkt->pkt.secret_key;
2466                     if ( !cmp_public_secret_key ( pk, sk ) ) {
2467                         if ( sk->protect.s2k.mode == 1001 ) {
2468                             /* The secret parts are not available so
2469                                we can't use that key for signing etc.
2470                                Fix the pubkey usage */
2471                             pk->pubkey_usage &= ~(PUBKEY_USAGE_SIG
2472                                                   |PUBKEY_USAGE_AUTH);
2473                         }
2474                         /* transfer flag bits 0 and 1 to the pubblock */
2475                         pub->flag |= (sec->flag &3);
2476                         break;
2477                     }
2478                 }
2479             }
2480             if ( !sec ) {
2481                 KBNODE next, ll;
2482
2483                 if (opt.verbose)
2484                   log_info (_("no secret subkey"
2485                               " for public subkey %s - ignoring\n"),
2486                             keystr_from_pk (pk));
2487                 /* we have to remove the subkey in this case */
2488                 assert ( last );
2489                 /* find the next subkey */
2490                 for (next=pub->next,ll=pub;
2491                      next && next->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2492                      ll = next, next = next->next )
2493                     ;
2494                 /* make new link */
2495                 last->next = next;
2496                 /* release this public subkey with all sigs */
2497                 ll->next = NULL;
2498                 release_kbnode( pub );
2499                 /* let the loop continue */
2500                 pub = last;
2501             }
2502         }
2503     }
2504     /* We need to copy the found bits (0 and 1) from the secret key to
2505        the public key.  This has already been done for the subkeys but
2506        got lost on the primary key - fix it here *. */
2507     pubblock->flag |= (secblock->flag & 3);
2508 }
2509
2510
2511
2512 \f
2513 /* See see whether the key fits
2514  * our requirements and in case we do not
2515  * request the primary key, we should select
2516  * a suitable subkey.
2517  * FIXME: Check against PGP 7 whether we still need a kludge
2518  *        to favor type 16 keys over type 20 keys when type 20
2519  *        has not been explitely requested.
2520  * Returns: True when a suitable key has been found.
2521  *
2522  * We have to distinguish four cases:  FIXME!
2523  *  1. No usage and no primary key requested
2524  *     Examples for this case are that we have a keyID to be used
2525  *     for decrytion or verification.
2526  *  2. No usage but primary key requested
2527  *     This is the case for all functions which work on an
2528  *     entire keyblock, e.g. for editing or listing
2529  *  3. Usage and primary key requested
2530  *     FXME
2531  *  4. Usage but no primary key requested
2532  *     FIXME
2533  * FIXME: Tell what is going to happen here and something about the rationale
2534  * Note: We don't use this function if no specific usage is requested;
2535  *       This way the getkey functions can be used for plain key listings.
2536  *
2537  * CTX ist the keyblock we are investigating, if FOUNDK is not NULL this
2538  * is the key we actually found by looking at the keyid or a fingerprint and
2539  * may eitehr point to the primary or one of the subkeys.
2540  */
2541
2542 static int
2543 finish_lookup (GETKEY_CTX ctx)
2544 {
2545     KBNODE keyblock = ctx->keyblock;
2546     KBNODE k;
2547     KBNODE foundk = NULL;
2548     PKT_user_id *foundu = NULL;
2549 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC|PUBKEY_USAGE_CERT)
2550     unsigned int req_usage = ( ctx->req_usage & USAGE_MASK );
2551     /* Request the primary if we're certifying another key, and also
2552        if signing data while --pgp6 or --pgp7 is on since pgp 6 and 7
2553        do not understand signatures made by a signing subkey.  PGP 8
2554        does. */
2555     int req_prim = (ctx->req_usage & PUBKEY_USAGE_CERT) ||
2556       ((PGP6 || PGP7) && (ctx->req_usage & PUBKEY_USAGE_SIG));
2557     u32 latest_date;
2558     KBNODE latest_key;
2559     u32 curtime = make_timestamp ();
2560
2561     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
2562
2563     ctx->found_key = NULL;
2564
2565     if (ctx->exact) {
2566         for (k=keyblock; k; k = k->next) {
2567             if ( (k->flag & 1) ) {
2568                 assert ( k->pkt->pkttype == PKT_PUBLIC_KEY
2569                          || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
2570                 foundk = k;
2571                 break;
2572             }
2573         }
2574     }
2575
2576     for (k=keyblock; k; k = k->next) {
2577         if ( (k->flag & 2) ) {
2578             assert (k->pkt->pkttype == PKT_USER_ID);
2579             foundu = k->pkt->pkt.user_id;
2580             break;
2581         }
2582     }
2583
2584     if ( DBG_CACHE )
2585         log_debug( "finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
2586                    (ulong)keyid_from_pk( keyblock->pkt->pkt.public_key, NULL),
2587                    foundk? "one":"all", req_usage);
2588
2589     if (!req_usage) {
2590         latest_key = foundk? foundk:keyblock;
2591         goto found;
2592     }
2593
2594     latest_date = 0;
2595     latest_key  = NULL;
2596     /* do not look at subkeys if a certification key is requested */
2597     if ((!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) && !req_prim) {
2598         KBNODE nextk;
2599         /* either start a loop or check just this one subkey */
2600         for (k=foundk?foundk:keyblock; k; k = nextk ) {
2601             PKT_public_key *pk;
2602             nextk = k->next;
2603             if ( k->pkt->pkttype != PKT_PUBLIC_SUBKEY )
2604                 continue;
2605             if ( foundk )
2606                 nextk = NULL;  /* what a hack */
2607             pk = k->pkt->pkt.public_key;
2608             if (DBG_CACHE)
2609                 log_debug( "\tchecking subkey %08lX\n",
2610                            (ulong)keyid_from_pk( pk, NULL));
2611             if ( !pk->is_valid ) {
2612                 if (DBG_CACHE)
2613                     log_debug( "\tsubkey not valid\n");
2614                 continue;
2615             }
2616             if ( pk->is_revoked ) {
2617                 if (DBG_CACHE)
2618                     log_debug( "\tsubkey has been revoked\n");
2619                 continue;
2620             }
2621             if ( pk->has_expired ) {
2622                 if (DBG_CACHE)
2623                     log_debug( "\tsubkey has expired\n");
2624                 continue;
2625             }
2626             if ( pk->timestamp > curtime && !opt.ignore_valid_from ) {
2627                 if (DBG_CACHE)
2628                     log_debug( "\tsubkey not yet valid\n");
2629                 continue;
2630             }
2631
2632             if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2633                 if (DBG_CACHE)
2634                     log_debug( "\tusage does not match: want=%x have=%x\n",
2635                                req_usage, pk->pubkey_usage );
2636                 continue;
2637             }
2638
2639             if (DBG_CACHE)
2640                 log_debug( "\tsubkey looks fine\n");
2641             if ( pk->timestamp > latest_date ) {
2642                 latest_date = pk->timestamp;
2643                 latest_key  = k;
2644             }
2645         }
2646     }
2647
2648     /* Okay now try the primary key unless we want an exact
2649      * key ID match on a subkey */
2650     if ((!latest_key && !(ctx->exact && foundk != keyblock)) || req_prim) {
2651         PKT_public_key *pk;
2652         if (DBG_CACHE && !foundk && !req_prim )
2653             log_debug( "\tno suitable subkeys found - trying primary\n");
2654         pk = keyblock->pkt->pkt.public_key;
2655         if ( !pk->is_valid ) {
2656             if (DBG_CACHE)
2657                 log_debug( "\tprimary key not valid\n");
2658         }
2659         else if ( pk->is_revoked ) {
2660             if (DBG_CACHE)
2661                 log_debug( "\tprimary key has been revoked\n");
2662         }
2663         else if ( pk->has_expired ) {
2664             if (DBG_CACHE)
2665                 log_debug( "\tprimary key has expired\n");
2666         }
2667         else  if ( !((pk->pubkey_usage&USAGE_MASK) & req_usage) ) {
2668             if (DBG_CACHE)
2669                 log_debug( "\tprimary key usage does not match: "
2670                            "want=%x have=%x\n",
2671                            req_usage, pk->pubkey_usage );
2672         }
2673         else { /* okay */
2674             if (DBG_CACHE)
2675                 log_debug( "\tprimary key may be used\n");
2676             latest_key = keyblock;
2677             latest_date = pk->timestamp;
2678         }
2679     }
2680
2681     if ( !latest_key ) {
2682         if (DBG_CACHE)
2683             log_debug("\tno suitable key found -  giving up\n");
2684         return 0;
2685     }
2686
2687  found:
2688     if (DBG_CACHE)
2689         log_debug( "\tusing key %08lX\n",
2690                 (ulong)keyid_from_pk( latest_key->pkt->pkt.public_key, NULL) );
2691
2692     if (latest_key) {
2693         PKT_public_key *pk = latest_key->pkt->pkt.public_key;
2694         if (pk->user_id)
2695             free_user_id (pk->user_id);
2696         pk->user_id = scopy_user_id (foundu);
2697     }
2698
2699     ctx->found_key = latest_key;
2700
2701     if (latest_key != keyblock && opt.verbose)
2702       {
2703         char *tempkeystr=
2704           xstrdup(keystr_from_pk(latest_key->pkt->pkt.public_key));
2705         log_info(_("using subkey %s instead of primary key %s\n"),
2706                  tempkeystr, keystr_from_pk(keyblock->pkt->pkt.public_key));
2707         xfree(tempkeystr);
2708       }
2709
2710     cache_user_id( keyblock );
2711
2712     return 1; /* found */
2713 }
2714
2715
2716 static int
2717 lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
2718 {
2719     int rc;
2720     KBNODE secblock = NULL; /* helper */
2721     int no_suitable_key = 0;
2722
2723     rc = 0;
2724     while (!(rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems))) {
2725         /* If we are searching for the first key we have to make sure
2726            that the next interation does not no an implicit reset.
2727            This can be triggered by an empty key ring. */
2728         if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
2729             ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;
2730
2731         rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
2732         if (rc) {
2733             log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
2734             rc = 0;
2735             goto skip;
2736         }
2737
2738         if ( secmode ) {
2739             /* find the correspondig public key and use this
2740              * this one for the selection process */
2741             u32 aki[2];
2742             KBNODE k = ctx->keyblock;
2743
2744             if (k->pkt->pkttype != PKT_SECRET_KEY)
2745                 BUG();
2746
2747             keyid_from_sk (k->pkt->pkt.secret_key, aki);
2748             k = get_pubkeyblock (aki);
2749             if( !k )
2750               {
2751                 if (!opt.quiet)
2752                   log_info(_("key %s: secret key without public key"
2753                              " - skipped\n"), keystr(aki));
2754                 goto skip;
2755               }
2756             secblock = ctx->keyblock;
2757             ctx->keyblock = k;
2758
2759             premerge_public_with_secret ( ctx->keyblock, secblock );
2760         }
2761
2762         /* warning: node flag bits 0 and 1 should be preserved by
2763          * merge_selfsigs.  For secret keys, premerge did tranfer the
2764          * keys to the keyblock */
2765         merge_selfsigs ( ctx->keyblock );
2766         if ( finish_lookup (ctx) ) {
2767             no_suitable_key = 0;
2768             if ( secmode ) {
2769                 merge_public_with_secret ( ctx->keyblock,
2770                                            secblock);
2771                 release_kbnode (secblock);
2772                 secblock = NULL;
2773             }
2774             goto found;
2775         }
2776         else
2777             no_suitable_key = 1;
2778
2779       skip:
2780         /* release resources and continue search */
2781         if ( secmode ) {
2782             release_kbnode( secblock );
2783             secblock = NULL;
2784         }
2785         release_kbnode( ctx->keyblock );
2786         ctx->keyblock = NULL;
2787     }
2788
2789   found:
2790     if( rc && rc != -1 )
2791         log_error("keydb_search failed: %s\n", g10_errstr(rc));
2792
2793     if( !rc ) {
2794         *ret_keyblock = ctx->keyblock; /* return the keyblock */
2795         ctx->keyblock = NULL;
2796     }
2797     else if (rc == -1 && no_suitable_key)
2798         rc = secmode ? G10ERR_UNU_SECKEY : G10ERR_UNU_PUBKEY;
2799     else if( rc == -1 )
2800         rc = secmode ? G10ERR_NO_SECKEY : G10ERR_NO_PUBKEY;
2801
2802     if ( secmode ) {
2803         release_kbnode( secblock );
2804         secblock = NULL;
2805     }
2806     release_kbnode( ctx->keyblock );
2807     ctx->keyblock = NULL;
2808
2809     ctx->last_rc = rc;
2810     return rc;
2811 }
2812
2813
2814
2815
2816 /****************
2817  * FIXME: Replace by the generic function
2818  *        It does not work as it is right now - it is used at
2819  *        2 places:  a) to get the key for an anonyous recipient
2820  *                   b) to get the ultimately trusted keys.
2821  *        The a) usage might have some problems.
2822  *
2823  * set with_subkeys true to include subkeys
2824  * set with_spm true to include secret-parts-missing keys
2825  *
2826  * Enumerate all primary secret keys.  Caller must use these procedure:
2827  *  1) create a void pointer and initialize it to NULL
2828  *  2) pass this void pointer by reference to this function
2829  *     and provide space for the secret key (pass a buffer for sk)
2830  *  3) call this function as long as it does not return -1
2831  *     to indicate EOF.
2832  *  4) Always call this function a last time with SK set to NULL,
2833  *     so that can free it's context.
2834  */
2835 int
2836 enum_secret_keys( void **context, PKT_secret_key *sk,
2837                   int with_subkeys, int with_spm )
2838 {
2839     int rc=0;
2840     struct {
2841         int eof;
2842         int first;
2843         KEYDB_HANDLE hd;
2844         KBNODE keyblock;
2845         KBNODE node;
2846     } *c = *context;
2847
2848
2849     if( !c ) { /* make a new context */
2850         c = xmalloc_clear( sizeof *c );
2851         *context = c;
2852         c->hd = keydb_new (1);
2853         c->first = 1;
2854         c->keyblock = NULL;
2855         c->node = NULL;
2856     }
2857
2858     if( !sk ) { /* free the context */
2859         keydb_release (c->hd);
2860         release_kbnode (c->keyblock);
2861         xfree( c );
2862         *context = NULL;
2863         return 0;
2864     }
2865
2866     if( c->eof )
2867         return -1;
2868
2869     do {
2870         /* get the next secret key from the current keyblock */
2871         for (; c->node; c->node = c->node->next) {
2872             if ((c->node->pkt->pkttype == PKT_SECRET_KEY
2873                 || (with_subkeys
2874                     && c->node->pkt->pkttype == PKT_SECRET_SUBKEY) )
2875                 && !(c->node->pkt->pkt.secret_key->protect.s2k.mode==1001
2876                      && !with_spm)) {
2877                 copy_secret_key (sk, c->node->pkt->pkt.secret_key );
2878                 c->node = c->node->next;
2879                 return 0; /* found */
2880             }
2881         }
2882         release_kbnode (c->keyblock);
2883         c->keyblock = c->node = NULL;
2884
2885         rc = c->first? keydb_search_first (c->hd) : keydb_search_next (c->hd);
2886         c->first = 0;
2887         if (rc) {
2888             keydb_release (c->hd); c->hd = NULL;
2889             c->eof = 1;
2890             return -1; /* eof */
2891         }
2892
2893         rc = keydb_get_keyblock (c->hd, &c->keyblock);
2894         c->node = c->keyblock;
2895     } while (!rc);
2896
2897     return rc; /* error */
2898 }
2899
2900
2901 \f
2902 /*********************************************
2903  ***********  user ID printing helpers *******
2904  *********************************************/
2905
2906 /****************
2907  * Return a string with a printable representation of the user_id.
2908  * this string must be freed by xfree.
2909  */
2910 char*
2911 get_user_id_string( u32 *keyid )
2912 {
2913   user_id_db_t r;
2914   char *p;
2915   int pass=0;
2916   /* try it two times; second pass reads from key resources */
2917   do
2918     {
2919       for(r=user_id_db; r; r = r->next )
2920         {
2921           keyid_list_t a;
2922           for (a=r->keyids; a; a= a->next )
2923             {
2924               if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] )
2925                 {
2926                   p = xmalloc( keystrlen() + 1 + r->len + 1 );
2927                   sprintf(p, "%s %.*s", keystr(keyid), r->len, r->name );
2928                   return p;
2929                 }
2930             }
2931         }
2932     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2933   p = xmalloc( keystrlen() + 5 );
2934   sprintf(p, "%s [?]", keystr(keyid));
2935   return p;
2936 }
2937
2938
2939 char*
2940 get_user_id_string_native ( u32 *keyid )
2941 {
2942   char *p = get_user_id_string( keyid );
2943   char *p2 = utf8_to_native( p, strlen(p), 0 );
2944   xfree(p);
2945   return p2;
2946 }
2947
2948
2949 char*
2950 get_long_user_id_string( u32 *keyid )
2951 {
2952     user_id_db_t r;
2953     char *p;
2954     int pass=0;
2955     /* try it two times; second pass reads from key resources */
2956     do {
2957         for(r=user_id_db; r; r = r->next ) {
2958             keyid_list_t a;
2959             for (a=r->keyids; a; a= a->next ) {
2960                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2961                     p = xmalloc( r->len + 20 );
2962                     sprintf(p, "%08lX%08lX %.*s",
2963                             (ulong)keyid[0], (ulong)keyid[1],
2964                             r->len, r->name );
2965                     return p;
2966                 }
2967             }
2968         }
2969     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2970     p = xmalloc( 25 );
2971     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2972     return p;
2973 }
2974
2975 char*
2976 get_user_id( u32 *keyid, size_t *rn )
2977 {
2978     user_id_db_t r;
2979     char *p;
2980     int pass=0;
2981
2982     /* try it two times; second pass reads from key resources */
2983     do {
2984         for(r=user_id_db; r; r = r->next ) {
2985             keyid_list_t a;
2986             for (a=r->keyids; a; a= a->next ) {
2987                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
2988                     p = xmalloc( r->len );
2989                     memcpy(p, r->name, r->len );
2990                     *rn = r->len;
2991                     return p;
2992                 }
2993             }
2994         }
2995     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2996     p = xstrdup( user_id_not_found_utf8 () );
2997     *rn = strlen(p);
2998     return p;
2999 }
3000
3001 char*
3002 get_user_id_native( u32 *keyid )
3003 {
3004   size_t rn;
3005   char *p = get_user_id( keyid, &rn );
3006   char *p2 = utf8_to_native( p, rn, 0 );
3007   xfree(p);
3008   return p2;
3009 }
3010
3011 KEYDB_HANDLE
3012 get_ctx_handle(GETKEY_CTX ctx)
3013 {
3014   return ctx->kr_handle;
3015 }
3016
3017 static void
3018 free_akl(struct akl *akl)
3019 {
3020   if(akl->spec)
3021     free_keyserver_spec(akl->spec);
3022
3023   xfree(akl);
3024 }
3025
3026 void
3027 release_akl(void)
3028 {
3029   while(opt.auto_key_locate)
3030     {
3031       struct akl *akl2=opt.auto_key_locate;
3032       opt.auto_key_locate=opt.auto_key_locate->next;
3033       free_akl(akl2);
3034     }
3035 }
3036
3037 int
3038 parse_auto_key_locate(char *options)
3039 {
3040   char *tok;
3041
3042   while((tok=optsep(&options)))
3043     {
3044       struct akl *akl,*check,*last=NULL;
3045       int dupe=0;
3046
3047       if(tok[0]=='\0')
3048         continue;
3049
3050       /* For now we silently ignore the new methods introduced with
3051          2.0.10. */
3052       if (!ascii_strcasecmp (tok,"nodefault")
3053           || !ascii_strcasecmp (tok,"local"))
3054         continue;
3055
3056       akl=xmalloc_clear(sizeof(*akl));
3057
3058       if(ascii_strcasecmp(tok,"ldap")==0)
3059         akl->type=AKL_LDAP;
3060       else if(ascii_strcasecmp(tok,"keyserver")==0)
3061         akl->type=AKL_KEYSERVER;
3062 #ifdef USE_DNS_CERT
3063       else if(ascii_strcasecmp(tok,"cert")==0)
3064         akl->type=AKL_CERT;
3065 #endif
3066 #ifdef USE_DNS_PKA
3067       else if(ascii_strcasecmp(tok,"pka")==0)
3068         akl->type=AKL_PKA;
3069 #endif
3070       else if((akl->spec=parse_keyserver_uri(tok,1,NULL,0)))
3071         akl->type=AKL_SPEC;
3072       else
3073         {
3074           free_akl(akl);
3075           return 0;
3076         }
3077
3078       /* We must maintain the order the user gave us */
3079       for(check=opt.auto_key_locate;check;last=check,check=check->next)
3080         {
3081           /* Check for duplicates */
3082           if(check->type==akl->type
3083              && (akl->type!=AKL_SPEC
3084                  || (akl->type==AKL_SPEC
3085                      && strcmp(check->spec->uri,akl->spec->uri)==0)))
3086             {
3087               dupe=1;
3088               free_akl(akl);
3089               break;
3090             }
3091         }
3092
3093       if(!dupe)
3094         {
3095           if(last)
3096             last->next=akl;
3097           else
3098             opt.auto_key_locate=akl;
3099         }
3100     }
3101
3102   return 1;
3103 }