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