gpg: Refresh expired keys originating from the WKD.
[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, 2010  Free Software Foundation, Inc.
4  * Copyright (C) 2015, 2016 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27
28 #include "gpg.h"
29 #include "../common/util.h"
30 #include "packet.h"
31 #include "../common/iobuf.h"
32 #include "keydb.h"
33 #include "options.h"
34 #include "main.h"
35 #include "trustdb.h"
36 #include "../common/i18n.h"
37 #include "keyserver-internal.h"
38 #include "call-agent.h"
39 #include "../common/host2net.h"
40 #include "../common/mbox-util.h"
41 #include "../common/status.h"
42
43 #define MAX_PK_CACHE_ENTRIES   PK_UID_CACHE_SIZE
44 #define MAX_UID_CACHE_ENTRIES  PK_UID_CACHE_SIZE
45
46 #if MAX_PK_CACHE_ENTRIES < 2
47 #error We need the cache for key creation
48 #endif
49
50 /* Flags values returned by the lookup code.  Note that the values are
51  * directly used by the KEY_CONSIDERED status line.  */
52 #define LOOKUP_NOT_SELECTED        (1<<0)
53 #define LOOKUP_ALL_SUBKEYS_EXPIRED (1<<1)  /* or revoked */
54
55
56 /* A context object used by the lookup functions.  */
57 struct getkey_ctx_s
58 {
59   /* Part of the search criteria: whether the search is an exact
60      search or not.  A search that is exact requires that a key or
61      subkey meet all of the specified criteria.  A search that is not
62      exact allows selecting a different key or subkey from the
63      keyblock that matched the critera.  Further, an exact search
64      returns the key or subkey that matched whereas a non-exact search
65      typically returns the primary key.  See finish_lookup for
66      details.  */
67   int exact;
68
69   /* Part of the search criteria: Whether the caller only wants keys
70      with an available secret key.  This is used by getkey_next to get
71      the next result with the same initial criteria.  */
72   int want_secret;
73
74   /* Part of the search criteria: The type of the requested key.  A
75      mask of PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.
76      If non-zero, then for a key to match, it must implement one of
77      the required uses.  */
78   int req_usage;
79
80   /* The database handle.  */
81   KEYDB_HANDLE kr_handle;
82
83   /* Whether we should call xfree() on the context when the context is
84      released using getkey_end()).  */
85   int not_allocated;
86
87   /* This variable is used as backing store for strings which have
88      their address used in ITEMS.  */
89   strlist_t extra_list;
90
91   /* Hack to return the mechanism (AKL_foo) used to find the key.  */
92   int found_via_akl;
93
94   /* Part of the search criteria: The low-level search specification
95      as passed to keydb_search.  */
96   int nitems;
97   /* This must be the last element in the structure.  When we allocate
98      the structure, we allocate it so that ITEMS can hold NITEMS.  */
99   KEYDB_SEARCH_DESC items[1];
100 };
101
102 #if 0
103 static struct
104 {
105   int any;
106   int okay_count;
107   int nokey_count;
108   int error_count;
109 } lkup_stats[21];
110 #endif
111
112 typedef struct keyid_list
113 {
114   struct keyid_list *next;
115   char fpr[MAX_FINGERPRINT_LEN];
116   u32 keyid[2];
117 } *keyid_list_t;
118
119
120 #if MAX_PK_CACHE_ENTRIES
121 typedef struct pk_cache_entry
122 {
123   struct pk_cache_entry *next;
124   u32 keyid[2];
125   PKT_public_key *pk;
126 } *pk_cache_entry_t;
127 static pk_cache_entry_t pk_cache;
128 static int pk_cache_entries;    /* Number of entries in pk cache.  */
129 static int pk_cache_disabled;
130 #endif
131
132 #if MAX_UID_CACHE_ENTRIES < 5
133 #error we really need the userid cache
134 #endif
135 typedef struct user_id_db
136 {
137   struct user_id_db *next;
138   keyid_list_t keyids;
139   int len;
140   char name[1];
141 } *user_id_db_t;
142 static user_id_db_t user_id_db;
143 static int uid_cache_entries;   /* Number of entries in uid cache. */
144
145 static void merge_selfsigs (ctrl_t ctrl, kbnode_t keyblock);
146 static int lookup (ctrl_t ctrl, getkey_ctx_t ctx, int want_secret,
147                    kbnode_t *ret_keyblock, kbnode_t *ret_found_key);
148 static kbnode_t finish_lookup (kbnode_t keyblock,
149                                unsigned int req_usage, int want_exact,
150                                int want_secret, unsigned int *r_flags);
151 static void print_status_key_considered (kbnode_t keyblock, unsigned int flags);
152
153
154 #if 0
155 static void
156 print_stats ()
157 {
158   int i;
159   for (i = 0; i < DIM (lkup_stats); i++)
160     {
161       if (lkup_stats[i].any)
162         es_fprintf (es_stderr,
163                  "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
164                  i,
165                  lkup_stats[i].okay_count,
166                  lkup_stats[i].nokey_count, lkup_stats[i].error_count);
167     }
168 }
169 #endif
170
171
172 /* Cache a copy of a public key in the public key cache.  PK is not
173  * cached if caching is disabled (via getkey_disable_caches), if
174  * PK->FLAGS.DONT_CACHE is set, we don't know how to derive a key id
175  * from the public key (e.g., unsupported algorithm), or a key with
176  * the key id is already in the cache.
177  *
178  * The public key packet is copied into the cache using
179  * copy_public_key.  Thus, any secret parts are not copied, for
180  * instance.
181  *
182  * This cache is filled by get_pubkey and is read by get_pubkey and
183  * get_pubkey_fast.  */
184 void
185 cache_public_key (PKT_public_key * pk)
186 {
187 #if MAX_PK_CACHE_ENTRIES
188   pk_cache_entry_t ce, ce2;
189   u32 keyid[2];
190
191   if (pk_cache_disabled)
192     return;
193
194   if (pk->flags.dont_cache)
195     return;
196
197   if (is_ELGAMAL (pk->pubkey_algo)
198       || pk->pubkey_algo == PUBKEY_ALGO_DSA
199       || pk->pubkey_algo == PUBKEY_ALGO_ECDSA
200       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
201       || pk->pubkey_algo == PUBKEY_ALGO_ECDH
202       || is_RSA (pk->pubkey_algo))
203     {
204       keyid_from_pk (pk, keyid);
205     }
206   else
207     return; /* Don't know how to get the keyid.  */
208
209   for (ce = pk_cache; ce; ce = ce->next)
210     if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
211       {
212         if (DBG_CACHE)
213           log_debug ("cache_public_key: already in cache\n");
214         return;
215       }
216
217   if (pk_cache_entries >= MAX_PK_CACHE_ENTRIES)
218     {
219       int n;
220
221       /* Remove the last 50% of the entries.  */
222       for (ce = pk_cache, n = 0; ce && n < pk_cache_entries/2; n++)
223         ce = ce->next;
224       if (ce && ce != pk_cache && ce->next)
225         {
226           ce2 = ce->next;
227           ce->next = NULL;
228           ce = ce2;
229           for (; ce; ce = ce2)
230             {
231               ce2 = ce->next;
232               free_public_key (ce->pk);
233               xfree (ce);
234               pk_cache_entries--;
235             }
236         }
237       log_assert (pk_cache_entries < MAX_PK_CACHE_ENTRIES);
238     }
239   pk_cache_entries++;
240   ce = xmalloc (sizeof *ce);
241   ce->next = pk_cache;
242   pk_cache = ce;
243   ce->pk = copy_public_key (NULL, pk);
244   ce->keyid[0] = keyid[0];
245   ce->keyid[1] = keyid[1];
246 #endif
247 }
248
249
250 /* Return a const utf-8 string with the text "[User ID not found]".
251    This function is required so that we don't need to switch gettext's
252    encoding temporary.  */
253 static const char *
254 user_id_not_found_utf8 (void)
255 {
256   static char *text;
257
258   if (!text)
259     text = native_to_utf8 (_("[User ID not found]"));
260   return text;
261 }
262
263
264
265 /* Return the user ID from the given keyblock.
266  * We use the primary uid flag which has been set by the merge_selfsigs
267  * function.  The returned value is only valid as long as the given
268  * keyblock is not changed.  */
269 static const char *
270 get_primary_uid (KBNODE keyblock, size_t * uidlen)
271 {
272   KBNODE k;
273   const char *s;
274
275   for (k = keyblock; k; k = k->next)
276     {
277       if (k->pkt->pkttype == PKT_USER_ID
278           && !k->pkt->pkt.user_id->attrib_data
279           && k->pkt->pkt.user_id->flags.primary)
280         {
281           *uidlen = k->pkt->pkt.user_id->len;
282           return k->pkt->pkt.user_id->name;
283         }
284     }
285   s = user_id_not_found_utf8 ();
286   *uidlen = strlen (s);
287   return s;
288 }
289
290
291 static void
292 release_keyid_list (keyid_list_t k)
293 {
294   while (k)
295     {
296       keyid_list_t k2 = k->next;
297       xfree (k);
298       k = k2;
299     }
300 }
301
302 /****************
303  * Store the association of keyid and userid
304  * Feed only public keys to this function.
305  */
306 static void
307 cache_user_id (KBNODE keyblock)
308 {
309   user_id_db_t r;
310   const char *uid;
311   size_t uidlen;
312   keyid_list_t keyids = NULL;
313   KBNODE k;
314
315   for (k = keyblock; k; k = k->next)
316     {
317       if (k->pkt->pkttype == PKT_PUBLIC_KEY
318           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
319         {
320           keyid_list_t a = xmalloc_clear (sizeof *a);
321           /* Hmmm: For a long list of keyids it might be an advantage
322            * to append the keys.  */
323           fingerprint_from_pk (k->pkt->pkt.public_key, a->fpr, NULL);
324           keyid_from_pk (k->pkt->pkt.public_key, a->keyid);
325           /* First check for duplicates.  */
326           for (r = user_id_db; r; r = r->next)
327             {
328               keyid_list_t b;
329
330               for (b = r->keyids; b; b = b->next)
331                 {
332                   if (!memcmp (b->fpr, a->fpr, MAX_FINGERPRINT_LEN))
333                     {
334                       if (DBG_CACHE)
335                         log_debug ("cache_user_id: already in cache\n");
336                       release_keyid_list (keyids);
337                       xfree (a);
338                       return;
339                     }
340                 }
341             }
342           /* Now put it into the cache.  */
343           a->next = keyids;
344           keyids = a;
345         }
346     }
347   if (!keyids)
348     BUG (); /* No key no fun.  */
349
350
351   uid = get_primary_uid (keyblock, &uidlen);
352
353   if (uid_cache_entries >= MAX_UID_CACHE_ENTRIES)
354     {
355       /* fixme: use another algorithm to free some cache slots */
356       r = user_id_db;
357       user_id_db = r->next;
358       release_keyid_list (r->keyids);
359       xfree (r);
360       uid_cache_entries--;
361     }
362   r = xmalloc (sizeof *r + uidlen - 1);
363   r->keyids = keyids;
364   r->len = uidlen;
365   memcpy (r->name, uid, r->len);
366   r->next = user_id_db;
367   user_id_db = r;
368   uid_cache_entries++;
369 }
370
371
372 /* Disable and drop the public key cache (which is filled by
373    cache_public_key and get_pubkey).  Note: there is currently no way
374    to re-enable this cache.  */
375 void
376 getkey_disable_caches ()
377 {
378 #if MAX_PK_CACHE_ENTRIES
379   {
380     pk_cache_entry_t ce, ce2;
381
382     for (ce = pk_cache; ce; ce = ce2)
383       {
384         ce2 = ce->next;
385         free_public_key (ce->pk);
386         xfree (ce);
387       }
388     pk_cache_disabled = 1;
389     pk_cache_entries = 0;
390     pk_cache = NULL;
391   }
392 #endif
393   /* fixme: disable user id cache ? */
394 }
395
396
397 void
398 pubkey_free (pubkey_t key)
399 {
400   if (key)
401     {
402       xfree (key->pk);
403       release_kbnode (key->keyblock);
404       xfree (key);
405     }
406 }
407
408 void
409 pubkeys_free (pubkey_t keys)
410 {
411   while (keys)
412     {
413       pubkey_t next = keys->next;
414       pubkey_free (keys);
415       keys = next;
416     }
417 }
418
419
420 /* Returns all keys that match the search specification SEARCH_TERMS.
421  *
422  * This function also checks for and warns about duplicate entries in
423  * the keydb, which can occur if the user has configured multiple
424  * keyrings or keyboxes or if a keyring or keybox was corrupted.
425  *
426  * Note: SEARCH_TERMS will not be expanded (i.e., it may not be a
427  * group).
428  *
429  * USE is the operation for which the key is required.  It must be
430  * either PUBKEY_USAGE_ENC, PUBKEY_USAGE_SIG, PUBKEY_USAGE_CERT or
431  * PUBKEY_USAGE_AUTH.
432  *
433  * INCLUDE_UNUSABLE indicates whether disabled keys are allowed.
434  * (Recipients specified with --encrypt-to and --hidden-encrypt-to may
435  * be disabled.  It is possible to edit disabled keys.)
436  *
437  * SOURCE is the context in which SEARCH_TERMS was specified, e.g.,
438  * "--encrypt-to", etc.  If this function is called interactively,
439  * then this should be NULL.
440  *
441  * If WARN_POSSIBLY_AMBIGUOUS is set, then emits a warning if the user
442  * does not specify a long key id or a fingerprint.
443  *
444  * The results are placed in *KEYS.  *KEYS must be NULL!
445  *
446  * Fixme: Currently, only PUBKEY_USAGE_ENC and PUBKEY_USAGE_SIG are
447  * implemented.  */
448 gpg_error_t
449 get_pubkeys (ctrl_t ctrl,
450              char *search_terms, int use, int include_unusable, char *source,
451              int warn_possibly_ambiguous,
452              pubkey_t *r_keys)
453 {
454   /* We show a warning when a key appears multiple times in the DB.
455    * This can happen for two reasons:
456    *
457    *   - The user has configured multiple keyrings or keyboxes.
458    *
459    *   - The keyring or keybox has been corrupted in some way, e.g., a
460    *     bug or a random process changing them.
461    *
462    * For each duplicate, we only want to show the key once.  Hence,
463    * this list.  */
464   static strlist_t key_dups;
465   gpg_error_t err;
466   char *use_str;   /* USE transformed to a string.  */
467   KEYDB_SEARCH_DESC desc;
468   GETKEY_CTX ctx;
469   pubkey_t results = NULL;
470   pubkey_t r;
471   int count;
472   char fingerprint[2 * MAX_FINGERPRINT_LEN + 1];
473
474   if (DBG_LOOKUP)
475     {
476       log_debug ("\n");
477       log_debug ("%s: Checking %s=%s\n",
478                  __func__, source ? source : "user input", search_terms);
479     }
480
481   if (*r_keys)
482     log_bug ("%s: KEYS should be NULL!\n", __func__);
483
484   switch (use)
485     {
486     case PUBKEY_USAGE_ENC: use_str = "encrypt"; break;
487     case PUBKEY_USAGE_SIG: use_str = "sign"; break;
488     case PUBKEY_USAGE_CERT: use_str = "cetify"; break;
489     case PUBKEY_USAGE_AUTH: use_str = "authentication"; break;
490     default: log_bug ("%s: Bad value for USE (%d)\n", __func__, use);
491     }
492
493   if (use == PUBKEY_USAGE_CERT || use == PUBKEY_USAGE_AUTH)
494     log_bug ("%s: use=%s is unimplemented.\n", __func__, use_str);
495
496   err = classify_user_id (search_terms, &desc, 1);
497   if (err)
498     {
499       log_info (_("key \"%s\" not found: %s\n"),
500                 search_terms, gpg_strerror (err));
501       if (!opt.quiet && source)
502         log_info (_("(check argument of option '%s')\n"), source);
503       goto leave;
504     }
505
506   if (warn_possibly_ambiguous
507       && ! (desc.mode == KEYDB_SEARCH_MODE_LONG_KID
508             || desc.mode == KEYDB_SEARCH_MODE_FPR16
509             || desc.mode == KEYDB_SEARCH_MODE_FPR20
510             || desc.mode == KEYDB_SEARCH_MODE_FPR))
511     {
512       log_info (_("Warning: '%s' should be a long key ID or a fingerprint\n"),
513                 search_terms);
514       if (!opt.quiet && source)
515         log_info (_("(check argument of option '%s')\n"), source);
516     }
517
518   /* Gather all of the results.  */
519   ctx = NULL;
520   count = 0;
521   do
522     {
523       PKT_public_key *pk;
524       KBNODE kb;
525
526       pk = xtrycalloc (1, sizeof *pk);
527       if (!pk)
528         {
529           err = gpg_error_from_syserror ();
530           goto leave;
531         }
532
533       pk->req_usage = use;
534
535       if (! ctx)
536         err = get_pubkey_byname (ctrl, &ctx, pk, search_terms, &kb, NULL,
537                                  include_unusable, 1);
538       else
539         err = getkey_next (ctrl, ctx, pk, &kb);
540
541       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND) /* No more results.   */
542         {
543           xfree (pk);
544           break;
545         }
546       else if (err) /* An error (other than "not found").  */
547         {
548           log_error (_("error looking up: %s\n"), gpg_strerror (err));
549           xfree (pk);
550           break;
551         }
552
553       /* Another result!  */
554       count ++;
555
556       r = xtrycalloc (1, sizeof (*r));
557       if (!r)
558         {
559           err = gpg_error_from_syserror ();
560           xfree (pk);
561           goto leave;
562         }
563       r->pk = pk;
564       r->keyblock = kb;
565       r->next = results;
566       results = r;
567     }
568   while (ctx);
569   getkey_end (ctrl, ctx);
570
571   if (DBG_LOOKUP)
572     {
573       log_debug ("%s resulted in %d matches.\n", search_terms, count);
574       for (r = results; r; r = r->next)
575         log_debug ("  %s\n",
576                    hexfingerprint (r->keyblock->pkt->pkt.public_key,
577                                    fingerprint, sizeof (fingerprint)));
578     }
579
580   if (! results && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
581     { /* No match.  */
582       if (DBG_LOOKUP)
583         log_debug ("%s: '%s' not found.\n", __func__, search_terms);
584
585       log_info (_("key \"%s\" not found\n"), search_terms);
586       if (!opt.quiet && source)
587         log_info (_("(check argument of option '%s')\n"), source);
588
589       goto leave;
590     }
591   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
592     ; /* No more matches.  */
593   else if (err)
594     { /* Some other error.  An error message was already printed out.
595        * Free RESULTS and continue.  */
596       goto leave;
597     }
598
599   /* Check for duplicates.  */
600   if (DBG_LOOKUP)
601     log_debug ("%s: Checking results of %s='%s' for dups\n",
602                __func__, source ? source : "user input", search_terms);
603   count = 0;
604   for (r = results; r; r = r->next)
605     {
606       pubkey_t *prevp;
607       pubkey_t next;
608       pubkey_t r2;
609       int dups = 0;
610
611       prevp = &r->next;
612       next = r->next;
613       while ((r2 = next))
614         {
615           if (cmp_public_keys (r->keyblock->pkt->pkt.public_key,
616                                r2->keyblock->pkt->pkt.public_key) != 0)
617             { /* Not a dup.  */
618               prevp = &r2->next;
619               next = r2->next;
620               continue;
621             }
622
623           dups ++;
624           count ++;
625
626           /* Remove R2 from the list.  */
627           *prevp = r2->next;
628           release_kbnode (r2->keyblock);
629           next = r2->next;
630           xfree (r2);
631         }
632
633       if (dups)
634         {
635           hexfingerprint (r->keyblock->pkt->pkt.public_key,
636                           fingerprint, sizeof fingerprint);
637           if (! strlist_find (key_dups, fingerprint))
638             {
639               char fingerprint_formatted[MAX_FORMATTED_FINGERPRINT_LEN + 1];
640
641               log_info (_("Warning: %s appears in the keyring %d times\n"),
642                         format_hexfingerprint (fingerprint,
643                                                fingerprint_formatted,
644                                                sizeof fingerprint_formatted),
645                         1 + dups);
646               add_to_strlist (&key_dups, fingerprint);
647             }
648         }
649     }
650
651   if (DBG_LOOKUP && count)
652     {
653       log_debug ("After removing %d dups:\n", count);
654       for (r = results, count = 0; r; r = r->next)
655         log_debug ("  %d: %s\n",
656                    count,
657                    hexfingerprint (r->keyblock->pkt->pkt.public_key,
658                                    fingerprint, sizeof fingerprint));
659     }
660
661  leave:
662   if (err)
663     pubkeys_free (results);
664   else
665     *r_keys = results;
666
667   return err;
668 }
669
670
671 static void
672 pk_from_block (PKT_public_key *pk, kbnode_t keyblock, kbnode_t found_key)
673 {
674   kbnode_t a = found_key ? found_key : keyblock;
675
676   log_assert (a->pkt->pkttype == PKT_PUBLIC_KEY
677               || a->pkt->pkttype == PKT_PUBLIC_SUBKEY);
678
679   copy_public_key (pk, a->pkt->pkt.public_key);
680 }
681
682
683 /* Specialized version of get_pubkey which retrieves the key based on
684  * information in SIG.  In contrast to get_pubkey PK is required.  */
685 gpg_error_t
686 get_pubkey_for_sig (ctrl_t ctrl, PKT_public_key *pk, PKT_signature *sig)
687 {
688   const byte *fpr;
689   size_t fprlen;
690
691   /* First try the new ISSUER_FPR info.  */
692   fpr = issuer_fpr_raw (sig, &fprlen);
693   if (fpr && !get_pubkey_byfprint (ctrl, pk, NULL, fpr, fprlen))
694     return 0;
695
696   /* Fallback to use the ISSUER_KEYID.  */
697   return get_pubkey (ctrl, pk, sig->keyid);
698 }
699
700
701 /* Return the public key with the key id KEYID and store it at PK.
702  * The resources in *PK should be released using
703  * release_public_key_parts().  This function also stores a copy of
704  * the public key in the user id cache (see cache_public_key).
705  *
706  * If PK is NULL, this function just stores the public key in the
707  * cache and returns the usual return code.
708  *
709  * PK->REQ_USAGE (which is a mask of PUBKEY_USAGE_SIG,
710  * PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT) is passed through to the
711  * lookup function.  If this is non-zero, only keys with the specified
712  * usage will be returned.  As such, it is essential that
713  * PK->REQ_USAGE be correctly initialized!
714  *
715  * Returns 0 on success, GPG_ERR_NO_PUBKEY if there is no public key
716  * with the specified key id, or another error code if an error
717  * occurs.
718  *
719  * If the data was not read from the cache, then the self-signed data
720  * has definitely been merged into the public key using
721  * merge_selfsigs.  */
722 int
723 get_pubkey (ctrl_t ctrl, PKT_public_key * pk, u32 * keyid)
724 {
725   int internal = 0;
726   int rc = 0;
727
728 #if MAX_PK_CACHE_ENTRIES
729   if (pk)
730     {
731       /* Try to get it from the cache.  We don't do this when pk is
732          NULL as it does not guarantee that the user IDs are
733          cached. */
734       pk_cache_entry_t ce;
735       for (ce = pk_cache; ce; ce = ce->next)
736         {
737           if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
738             /* XXX: We don't check PK->REQ_USAGE here, but if we don't
739                read from the cache, we do check it!  */
740             {
741               copy_public_key (pk, ce->pk);
742               return 0;
743             }
744         }
745     }
746 #endif
747   /* More init stuff.  */
748   if (!pk)
749     {
750       internal++;
751       pk = xtrycalloc (1, sizeof *pk);
752       if (!pk)
753         {
754           rc = gpg_error_from_syserror ();
755           goto leave;
756         }
757     }
758
759
760   /* Do a lookup.  */
761   {
762     struct getkey_ctx_s ctx;
763     kbnode_t kb = NULL;
764     kbnode_t found_key = NULL;
765
766     memset (&ctx, 0, sizeof ctx);
767     ctx.exact = 1; /* Use the key ID exactly as given.  */
768     ctx.not_allocated = 1;
769
770     if (ctrl && ctrl->cached_getkey_kdb)
771       {
772         ctx.kr_handle = ctrl->cached_getkey_kdb;
773         ctrl->cached_getkey_kdb = NULL;
774         keydb_search_reset (ctx.kr_handle);
775       }
776     else
777       {
778         ctx.kr_handle = keydb_new ();
779         if (!ctx.kr_handle)
780           {
781             rc = gpg_error_from_syserror ();
782             goto leave;
783           }
784       }
785     ctx.nitems = 1;
786     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
787     ctx.items[0].u.kid[0] = keyid[0];
788     ctx.items[0].u.kid[1] = keyid[1];
789     ctx.req_usage = pk->req_usage;
790     rc = lookup (ctrl, &ctx, 0, &kb, &found_key);
791     if (!rc)
792       {
793         pk_from_block (pk, kb, found_key);
794       }
795     getkey_end (ctrl, &ctx);
796     release_kbnode (kb);
797   }
798   if (!rc)
799     goto leave;
800
801   rc = GPG_ERR_NO_PUBKEY;
802
803 leave:
804   if (!rc)
805     cache_public_key (pk);
806   if (internal)
807     free_public_key (pk);
808   return rc;
809 }
810
811
812 /* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
813  * account nor does it merge in the self-signed data.  This function
814  * also only considers primary keys.  It is intended to be used as a
815  * quick check of the key to avoid recursion.  It should only be used
816  * in very certain cases.  Like get_pubkey and unlike any of the other
817  * lookup functions, this function also consults the user id cache
818  * (see cache_public_key).
819  *
820  * Return the public key in *PK.  The resources in *PK should be
821  * released using release_public_key_parts().  */
822 int
823 get_pubkey_fast (PKT_public_key * pk, u32 * keyid)
824 {
825   int rc = 0;
826   KEYDB_HANDLE hd;
827   KBNODE keyblock;
828   u32 pkid[2];
829
830   log_assert (pk);
831 #if MAX_PK_CACHE_ENTRIES
832   {
833     /* Try to get it from the cache */
834     pk_cache_entry_t ce;
835
836     for (ce = pk_cache; ce; ce = ce->next)
837       {
838         if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1]
839             /* Only consider primary keys.  */
840             && ce->pk->keyid[0] == ce->pk->main_keyid[0]
841             && ce->pk->keyid[1] == ce->pk->main_keyid[1])
842           {
843             if (pk)
844               copy_public_key (pk, ce->pk);
845             return 0;
846           }
847       }
848   }
849 #endif
850
851   hd = keydb_new ();
852   if (!hd)
853     return gpg_error_from_syserror ();
854   rc = keydb_search_kid (hd, keyid);
855   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
856     {
857       keydb_release (hd);
858       return GPG_ERR_NO_PUBKEY;
859     }
860   rc = keydb_get_keyblock (hd, &keyblock);
861   keydb_release (hd);
862   if (rc)
863     {
864       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
865       return GPG_ERR_NO_PUBKEY;
866     }
867
868   log_assert (keyblock && keyblock->pkt
869               && keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
870
871   /* We return the primary key.  If KEYID matched a subkey, then we
872      return an error.  */
873   keyid_from_pk (keyblock->pkt->pkt.public_key, pkid);
874   if (keyid[0] == pkid[0] && keyid[1] == pkid[1])
875     copy_public_key (pk, keyblock->pkt->pkt.public_key);
876   else
877     rc = GPG_ERR_NO_PUBKEY;
878
879   release_kbnode (keyblock);
880
881   /* Not caching key here since it won't have all of the fields
882      properly set. */
883
884   return rc;
885 }
886
887
888 /* Return the entire keyblock used to create SIG.  This is a
889  * specialized version of get_pubkeyblock.
890  *
891  * FIXME: This is a hack because get_pubkey_for_sig was already called
892  * and it could have used a cache to hold the key.  */
893 kbnode_t
894 get_pubkeyblock_for_sig (ctrl_t ctrl, PKT_signature *sig)
895 {
896   const byte *fpr;
897   size_t fprlen;
898   kbnode_t keyblock;
899
900   /* First try the new ISSUER_FPR info.  */
901   fpr = issuer_fpr_raw (sig, &fprlen);
902   if (fpr && !get_pubkey_byfprint (ctrl, NULL, &keyblock, fpr, fprlen))
903     return keyblock;
904
905   /* Fallback to use the ISSUER_KEYID.  */
906   return get_pubkeyblock (ctrl, sig->keyid);
907 }
908
909
910 /* Return the key block for the key with key id KEYID or NULL, if an
911  * error occurs.  Use release_kbnode() to release the key block.
912  *
913  * The self-signed data has already been merged into the public key
914  * using merge_selfsigs.  */
915 kbnode_t
916 get_pubkeyblock (ctrl_t ctrl, u32 * keyid)
917 {
918   struct getkey_ctx_s ctx;
919   int rc = 0;
920   KBNODE keyblock = NULL;
921
922   memset (&ctx, 0, sizeof ctx);
923   /* No need to set exact here because we want the entire block.  */
924   ctx.not_allocated = 1;
925   ctx.kr_handle = keydb_new ();
926   if (!ctx.kr_handle)
927     return NULL;
928   ctx.nitems = 1;
929   ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
930   ctx.items[0].u.kid[0] = keyid[0];
931   ctx.items[0].u.kid[1] = keyid[1];
932   rc = lookup (ctrl, &ctx, 0, &keyblock, NULL);
933   getkey_end (ctrl, &ctx);
934
935   return rc ? NULL : keyblock;
936 }
937
938
939 /* Return the public key with the key id KEYID iff the secret key is
940  * available and store it at PK.  The resources should be released
941  * using release_public_key_parts().
942  *
943  * Unlike other lookup functions, PK may not be NULL.  PK->REQ_USAGE
944  * is passed through to the lookup function and is a mask of
945  * PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  Thus, it
946  * must be valid!  If this is non-zero, only keys with the specified
947  * usage will be returned.
948  *
949  * Returns 0 on success.  If a public key with the specified key id is
950  * not found or a secret key is not available for that public key, an
951  * error code is returned.  Note: this function ignores legacy keys.
952  * An error code is also return if an error occurs.
953  *
954  * The self-signed data has already been merged into the public key
955  * using merge_selfsigs.  */
956 gpg_error_t
957 get_seckey (ctrl_t ctrl, PKT_public_key *pk, u32 *keyid)
958 {
959   gpg_error_t err;
960   struct getkey_ctx_s ctx;
961   kbnode_t keyblock = NULL;
962   kbnode_t found_key = NULL;
963
964   memset (&ctx, 0, sizeof ctx);
965   ctx.exact = 1; /* Use the key ID exactly as given.  */
966   ctx.not_allocated = 1;
967   ctx.kr_handle = keydb_new ();
968   if (!ctx.kr_handle)
969     return gpg_error_from_syserror ();
970   ctx.nitems = 1;
971   ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
972   ctx.items[0].u.kid[0] = keyid[0];
973   ctx.items[0].u.kid[1] = keyid[1];
974   ctx.req_usage = pk->req_usage;
975   err = lookup (ctrl, &ctx, 1, &keyblock, &found_key);
976   if (!err)
977     {
978       pk_from_block (pk, keyblock, found_key);
979     }
980   getkey_end (ctrl, &ctx);
981   release_kbnode (keyblock);
982
983   if (!err)
984     {
985       err = agent_probe_secret_key (/*ctrl*/NULL, pk);
986       if (err)
987         release_public_key_parts (pk);
988     }
989
990   return err;
991 }
992
993
994 /* Skip unusable keys.  A key is unusable if it is revoked, expired or
995    disabled or if the selected user id is revoked or expired.  */
996 static int
997 skip_unusable (void *opaque, u32 * keyid, int uid_no)
998 {
999   ctrl_t ctrl = opaque;
1000   int unusable = 0;
1001   KBNODE keyblock;
1002   PKT_public_key *pk;
1003
1004   keyblock = get_pubkeyblock (ctrl, keyid);
1005   if (!keyblock)
1006     {
1007       log_error ("error checking usability status of %s\n", keystr (keyid));
1008       goto leave;
1009     }
1010
1011   pk = keyblock->pkt->pkt.public_key;
1012
1013   /* Is the key revoked or expired?  */
1014   if (pk->flags.revoked || pk->has_expired)
1015     unusable = 1;
1016
1017   /* Is the user ID in question revoked or expired? */
1018   if (!unusable && uid_no)
1019     {
1020       KBNODE node;
1021       int uids_seen = 0;
1022
1023       for (node = keyblock; node; node = node->next)
1024         {
1025           if (node->pkt->pkttype == PKT_USER_ID)
1026             {
1027               PKT_user_id *user_id = node->pkt->pkt.user_id;
1028
1029               uids_seen ++;
1030               if (uids_seen != uid_no)
1031                 continue;
1032
1033               if (user_id->flags.revoked || user_id->flags.expired)
1034                 unusable = 1;
1035
1036               break;
1037             }
1038         }
1039
1040       /* If UID_NO is non-zero, then the keyblock better have at least
1041          that many UIDs.  */
1042       log_assert (uids_seen == uid_no);
1043     }
1044
1045   if (!unusable)
1046     unusable = pk_is_disabled (pk);
1047
1048 leave:
1049   release_kbnode (keyblock);
1050   return unusable;
1051 }
1052
1053
1054 /* Search for keys matching some criteria.
1055
1056    If RETCTX is not NULL, then the constructed context is returned in
1057    *RETCTX so that getpubkey_next can be used to get subsequent
1058    results.  In this case, getkey_end() must be used to free the
1059    search context.  If RETCTX is not NULL, then RET_KDBHD must be
1060    NULL.
1061
1062    If NAMELIST is not NULL, then a search query is constructed using
1063    classify_user_id on each of the strings in the list.  (Recall: the
1064    database does an OR of the terms, not an AND.)  If NAMELIST is
1065    NULL, then all results are returned.
1066
1067    If PK is not NULL, the public key of the first result is returned
1068    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
1069    set, it is used to filter the search results.  See the
1070    documentation for finish_lookup to understand exactly how this is
1071    used.  Note: The self-signed data has already been merged into the
1072    public key using merge_selfsigs.  Free *PK by calling
1073    release_public_key_parts (or, if PK was allocated using xfree, you
1074    can use free_public_key, which calls release_public_key_parts(PK)
1075    and then xfree(PK)).
1076
1077    If WANT_SECRET is set, then only keys with an available secret key
1078    (either locally or via key registered on a smartcard) are returned.
1079
1080    If INCLUDE_UNUSABLE is set, then unusable keys (see the
1081    documentation for skip_unusable for an exact definition) are
1082    skipped unless they are looked up by key id or by fingerprint.
1083
1084    If RET_KB is not NULL, the keyblock is returned in *RET_KB.  This
1085    should be freed using release_kbnode().
1086
1087    If RET_KDBHD is not NULL, then the new database handle used to
1088    conduct the search is returned in *RET_KDBHD.  This can be used to
1089    get subsequent results using keydb_search_next.  Note: in this
1090    case, no advanced filtering is done for subsequent results (e.g.,
1091    WANT_SECRET and PK->REQ_USAGE are not respected).
1092
1093    This function returns 0 on success.  Otherwise, an error code is
1094    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
1095    (if want_secret is set) is returned if the key is not found.  */
1096 static int
1097 key_byname (ctrl_t ctrl, GETKEY_CTX *retctx, strlist_t namelist,
1098             PKT_public_key *pk,
1099             int want_secret, int include_unusable,
1100             KBNODE * ret_kb, KEYDB_HANDLE * ret_kdbhd)
1101 {
1102   int rc = 0;
1103   int n;
1104   strlist_t r;
1105   GETKEY_CTX ctx;
1106   KBNODE help_kb = NULL;
1107   KBNODE found_key = NULL;
1108
1109   if (retctx)
1110     {
1111       /* Reset the returned context in case of error.  */
1112       log_assert (!ret_kdbhd); /* Not allowed because the handle is stored
1113                                   in the context.  */
1114       *retctx = NULL;
1115     }
1116   if (ret_kdbhd)
1117     *ret_kdbhd = NULL;
1118
1119   if (!namelist)
1120     /* No search terms: iterate over the whole DB.  */
1121     {
1122       ctx = xmalloc_clear (sizeof *ctx);
1123       ctx->nitems = 1;
1124       ctx->items[0].mode = KEYDB_SEARCH_MODE_FIRST;
1125       if (!include_unusable)
1126         {
1127           ctx->items[0].skipfnc = skip_unusable;
1128           ctx->items[0].skipfncvalue = ctrl;
1129         }
1130     }
1131   else
1132     {
1133       /* Build the search context.  */
1134       for (n = 0, r = namelist; r; r = r->next)
1135         n++;
1136
1137       /* CTX has space for a single search term at the end.  Thus, we
1138          need to allocate sizeof *CTX plus (n - 1) sizeof
1139          CTX->ITEMS.  */
1140       ctx = xmalloc_clear (sizeof *ctx + (n - 1) * sizeof ctx->items);
1141       ctx->nitems = n;
1142
1143       for (n = 0, r = namelist; r; r = r->next, n++)
1144         {
1145           gpg_error_t err;
1146
1147           err = classify_user_id (r->d, &ctx->items[n], 1);
1148
1149           if (ctx->items[n].exact)
1150             ctx->exact = 1;
1151           if (err)
1152             {
1153               xfree (ctx);
1154               return gpg_err_code (err); /* FIXME: remove gpg_err_code.  */
1155             }
1156           if (!include_unusable
1157               && ctx->items[n].mode != KEYDB_SEARCH_MODE_SHORT_KID
1158               && ctx->items[n].mode != KEYDB_SEARCH_MODE_LONG_KID
1159               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR16
1160               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR20
1161               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR)
1162             {
1163               ctx->items[n].skipfnc = skip_unusable;
1164               ctx->items[n].skipfncvalue = ctrl;
1165             }
1166         }
1167     }
1168
1169   ctx->want_secret = want_secret;
1170   ctx->kr_handle = keydb_new ();
1171   if (!ctx->kr_handle)
1172     {
1173       rc = gpg_error_from_syserror ();
1174       getkey_end (ctrl, ctx);
1175       return rc;
1176     }
1177
1178   if (!ret_kb)
1179     ret_kb = &help_kb;
1180
1181   if (pk)
1182     {
1183       ctx->req_usage = pk->req_usage;
1184     }
1185
1186   rc = lookup (ctrl, ctx, want_secret, ret_kb, &found_key);
1187   if (!rc && pk)
1188     {
1189       pk_from_block (pk, *ret_kb, found_key);
1190     }
1191
1192   release_kbnode (help_kb);
1193
1194   if (retctx) /* Caller wants the context.  */
1195     *retctx = ctx;
1196   else
1197     {
1198       if (ret_kdbhd)
1199         {
1200           *ret_kdbhd = ctx->kr_handle;
1201           ctx->kr_handle = NULL;
1202         }
1203       getkey_end (ctrl, ctx);
1204     }
1205
1206   return rc;
1207 }
1208
1209
1210 /* Find a public key identified by NAME.
1211  *
1212  * If name appears to be a valid RFC822 mailbox (i.e., email
1213  * address) and auto key lookup is enabled (no_akl == 0), then the
1214  * specified auto key lookup methods (--auto-key-lookup) are used to
1215  * import the key into the local keyring.  Otherwise, just the local
1216  * keyring is consulted.
1217  *
1218  * If RETCTX is not NULL, then the constructed context is returned in
1219  * *RETCTX so that getpubkey_next can be used to get subsequent
1220  * results.  In this case, getkey_end() must be used to free the
1221  * search context.  If RETCTX is not NULL, then RET_KDBHD must be
1222  * NULL.
1223  *
1224  * If PK is not NULL, the public key of the first result is returned
1225  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  PK->REQ_USAGE is
1226  * passed through to the lookup function and is a mask of
1227  * PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  If this
1228  * is non-zero, only keys with the specified usage will be returned.
1229  * Note: The self-signed data has already been merged into the public
1230  * key using merge_selfsigs.  Free *PK by calling
1231  * release_public_key_parts (or, if PK was allocated using xfree, you
1232  * can use free_public_key, which calls release_public_key_parts(PK)
1233  * and then xfree(PK)).
1234  *
1235  * NAME is a string, which is turned into a search query using
1236  * classify_user_id.
1237  *
1238  * If RET_KEYBLOCK is not NULL, the keyblock is returned in
1239  * *RET_KEYBLOCK.  This should be freed using release_kbnode().
1240  *
1241  * If RET_KDBHD is not NULL, then the new database handle used to
1242  * conduct the search is returned in *RET_KDBHD.  This can be used to
1243  * get subsequent results using keydb_search_next or to modify the
1244  * returned record.  Note: in this case, no advanced filtering is done
1245  * for subsequent results (e.g., PK->REQ_USAGE is not respected).
1246  * Unlike RETCTX, this is always returned.
1247  *
1248  * If INCLUDE_UNUSABLE is set, then unusable keys (see the
1249  * documentation for skip_unusable for an exact definition) are
1250  * skipped unless they are looked up by key id or by fingerprint.
1251  *
1252  * If NO_AKL is set, then the auto key locate functionality is
1253  * disabled and only the local key ring is considered.  Note: the
1254  * local key ring is consulted even if local is not in the
1255  * --auto-key-locate option list!
1256  *
1257  * This function returns 0 on success.  Otherwise, an error code is
1258  * returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
1259  * (if want_secret is set) is returned if the key is not found.  */
1260 int
1261 get_pubkey_byname (ctrl_t ctrl, GETKEY_CTX * retctx, PKT_public_key * pk,
1262                    const char *name, KBNODE * ret_keyblock,
1263                    KEYDB_HANDLE * ret_kdbhd, int include_unusable, int no_akl)
1264 {
1265   int rc;
1266   strlist_t namelist = NULL;
1267   struct akl *akl;
1268   int is_mbox;
1269   int nodefault = 0;
1270   int anylocalfirst = 0;
1271   int mechanism_type = AKL_NODEFAULT;
1272
1273   /* If RETCTX is not NULL, then RET_KDBHD must be NULL.  */
1274   log_assert (retctx == NULL || ret_kdbhd == NULL);
1275
1276   if (retctx)
1277     *retctx = NULL;
1278
1279   /* Does NAME appear to be a mailbox (mail address)?  */
1280   is_mbox = is_valid_mailbox (name);
1281
1282   /* The auto-key-locate feature works as follows: there are a number
1283    * of methods to look up keys.  By default, the local keyring is
1284    * tried first.  Then, each method listed in the --auto-key-locate is
1285    * tried in the order it appears.
1286    *
1287    * This can be changed as follows:
1288    *
1289    *   - if nodefault appears anywhere in the list of options, then
1290    *     the local keyring is not tried first, or,
1291    *
1292    *   - if local appears anywhere in the list of options, then the
1293    *     local keyring is not tried first, but in the order in which
1294    *     it was listed in the --auto-key-locate option.
1295    *
1296    * Note: we only save the search context in RETCTX if the local
1297    * method is the first method tried (either explicitly or
1298    * implicitly).  */
1299   if (!no_akl)
1300     {
1301       /* auto-key-locate is enabled.  */
1302
1303       /* nodefault is true if "nodefault" or "local" appear.  */
1304       for (akl = opt.auto_key_locate; akl; akl = akl->next)
1305         if (akl->type == AKL_NODEFAULT || akl->type == AKL_LOCAL)
1306           {
1307             nodefault = 1;
1308             break;
1309           }
1310       /* anylocalfirst is true if "local" appears before any other
1311          search methods (except "nodefault").  */
1312       for (akl = opt.auto_key_locate; akl; akl = akl->next)
1313         if (akl->type != AKL_NODEFAULT)
1314           {
1315             if (akl->type == AKL_LOCAL)
1316               anylocalfirst = 1;
1317             break;
1318           }
1319     }
1320
1321   if (!nodefault)
1322     {
1323       /* "nodefault" didn't occur.  Thus, "local" is implicitly the
1324        *  first method to try.  */
1325       anylocalfirst = 1;
1326     }
1327
1328   if (nodefault && is_mbox)
1329     {
1330       /* Either "nodefault" or "local" (explicitly) appeared in the
1331        * auto key locate list and NAME appears to be an email address.
1332        * Don't try the local keyring.  */
1333       rc = GPG_ERR_NO_PUBKEY;
1334     }
1335   else
1336     {
1337       /* Either "nodefault" and "local" don't appear in the auto key
1338        * locate list (in which case we try the local keyring first) or
1339        * NAME does not appear to be an email address (in which case we
1340        * only try the local keyring).  In this case, lookup NAME in
1341        * the local keyring.  */
1342       add_to_strlist (&namelist, name);
1343       rc = key_byname (ctrl, retctx, namelist, pk, 0,
1344                        include_unusable, ret_keyblock, ret_kdbhd);
1345     }
1346
1347   /* If the requested name resembles a valid mailbox and automatic
1348      retrieval has been enabled, we try to import the key. */
1349   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && !no_akl && is_mbox)
1350     {
1351       /* NAME wasn't present in the local keyring (or we didn't try
1352        * the local keyring).  Since the auto key locate feature is
1353        * enabled and NAME appears to be an email address, try the auto
1354        * locate feature.  */
1355       for (akl = opt.auto_key_locate; akl; akl = akl->next)
1356         {
1357           unsigned char *fpr = NULL;
1358           size_t fpr_len;
1359           int did_akl_local = 0;
1360           int no_fingerprint = 0;
1361           const char *mechanism_string = "?";
1362
1363           mechanism_type = akl->type;
1364           switch (mechanism_type)
1365             {
1366             case AKL_NODEFAULT:
1367               /* This is a dummy mechanism.  */
1368               mechanism_string = "None";
1369               rc = GPG_ERR_NO_PUBKEY;
1370               break;
1371
1372             case AKL_LOCAL:
1373               mechanism_string = "Local";
1374               did_akl_local = 1;
1375               if (retctx)
1376                 {
1377                   getkey_end (ctrl, *retctx);
1378                   *retctx = NULL;
1379                 }
1380               add_to_strlist (&namelist, name);
1381               rc = key_byname (ctrl, anylocalfirst ? retctx : NULL,
1382                                namelist, pk, 0,
1383                                include_unusable, ret_keyblock, ret_kdbhd);
1384               break;
1385
1386             case AKL_CERT:
1387               mechanism_string = "DNS CERT";
1388               glo_ctrl.in_auto_key_retrieve++;
1389               rc = keyserver_import_cert (ctrl, name, 0, &fpr, &fpr_len);
1390               glo_ctrl.in_auto_key_retrieve--;
1391               break;
1392
1393             case AKL_PKA:
1394               mechanism_string = "PKA";
1395               glo_ctrl.in_auto_key_retrieve++;
1396               rc = keyserver_import_pka (ctrl, name, &fpr, &fpr_len);
1397               glo_ctrl.in_auto_key_retrieve--;
1398               break;
1399
1400             case AKL_DANE:
1401               mechanism_string = "DANE";
1402               glo_ctrl.in_auto_key_retrieve++;
1403               rc = keyserver_import_cert (ctrl, name, 1, &fpr, &fpr_len);
1404               glo_ctrl.in_auto_key_retrieve--;
1405               break;
1406
1407             case AKL_WKD:
1408               mechanism_string = "WKD";
1409               glo_ctrl.in_auto_key_retrieve++;
1410               rc = keyserver_import_wkd (ctrl, name, 0, &fpr, &fpr_len);
1411               glo_ctrl.in_auto_key_retrieve--;
1412               break;
1413
1414             case AKL_LDAP:
1415               mechanism_string = "LDAP";
1416               glo_ctrl.in_auto_key_retrieve++;
1417               rc = keyserver_import_ldap (ctrl, name, &fpr, &fpr_len);
1418               glo_ctrl.in_auto_key_retrieve--;
1419               break;
1420
1421             case AKL_KEYSERVER:
1422               /* Strictly speaking, we don't need to only use a valid
1423                * mailbox for the getname search, but it helps cut down
1424                * on the problem of searching for something like "john"
1425                * and getting a whole lot of keys back. */
1426               if (keyserver_any_configured (ctrl))
1427                 {
1428                   mechanism_string = "keyserver";
1429                   glo_ctrl.in_auto_key_retrieve++;
1430                   rc = keyserver_import_name (ctrl, name, &fpr, &fpr_len,
1431                                               opt.keyserver);
1432                   glo_ctrl.in_auto_key_retrieve--;
1433                 }
1434               else
1435                 {
1436                   mechanism_string = "Unconfigured keyserver";
1437                   rc = GPG_ERR_NO_PUBKEY;
1438                 }
1439               break;
1440
1441             case AKL_SPEC:
1442               {
1443                 struct keyserver_spec *keyserver;
1444
1445                 mechanism_string = akl->spec->uri;
1446                 keyserver = keyserver_match (akl->spec);
1447                 glo_ctrl.in_auto_key_retrieve++;
1448                 rc = keyserver_import_name (ctrl,
1449                                             name, &fpr, &fpr_len, keyserver);
1450                 glo_ctrl.in_auto_key_retrieve--;
1451               }
1452               break;
1453             }
1454
1455           /* Use the fingerprint of the key that we actually fetched.
1456            * This helps prevent problems where the key that we fetched
1457            * doesn't have the same name that we used to fetch it.  In
1458            * the case of CERT and PKA, this is an actual security
1459            * requirement as the URL might point to a key put in by an
1460            * attacker.  By forcing the use of the fingerprint, we
1461            * won't use the attacker's key here. */
1462           if (!rc && fpr)
1463             {
1464               char fpr_string[MAX_FINGERPRINT_LEN * 2 + 1];
1465
1466               log_assert (fpr_len <= MAX_FINGERPRINT_LEN);
1467
1468               free_strlist (namelist);
1469               namelist = NULL;
1470
1471               bin2hex (fpr, fpr_len, fpr_string);
1472
1473               if (opt.verbose)
1474                 log_info ("auto-key-locate found fingerprint %s\n",
1475                           fpr_string);
1476
1477               add_to_strlist (&namelist, fpr_string);
1478             }
1479           else if (!rc && !fpr && !did_akl_local)
1480             { /* The acquisition method said no failure occurred, but
1481                * it didn't return a fingerprint.  That's a failure.  */
1482               no_fingerprint = 1;
1483               rc = GPG_ERR_NO_PUBKEY;
1484             }
1485           xfree (fpr);
1486           fpr = NULL;
1487
1488           if (!rc && !did_akl_local)
1489             { /* There was no error and we didn't do a local lookup.
1490                * This means that we imported a key into the local
1491                * keyring.  Try to read the imported key from the
1492                * keyring.  */
1493               if (retctx)
1494                 {
1495                   getkey_end (ctrl, *retctx);
1496                   *retctx = NULL;
1497                 }
1498               rc = key_byname (ctrl, anylocalfirst ? retctx : NULL,
1499                                namelist, pk, 0,
1500                                include_unusable, ret_keyblock, ret_kdbhd);
1501             }
1502           if (!rc)
1503             {
1504               /* Key found.  */
1505               if (opt.verbose)
1506                 log_info (_("automatically retrieved '%s' via %s\n"),
1507                           name, mechanism_string);
1508               break;
1509             }
1510           if (gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
1511               || opt.verbose || no_fingerprint)
1512             log_info (_("error retrieving '%s' via %s: %s\n"),
1513                       name, mechanism_string,
1514                       no_fingerprint ? _("No fingerprint") : gpg_strerror (rc));
1515         }
1516     }
1517
1518
1519   if (rc && retctx)
1520     {
1521       getkey_end (ctrl, *retctx);
1522       *retctx = NULL;
1523     }
1524
1525   if (retctx && *retctx)
1526     {
1527       log_assert (!(*retctx)->extra_list);
1528       (*retctx)->extra_list = namelist;
1529       (*retctx)->found_via_akl = mechanism_type;
1530     }
1531   else
1532     free_strlist (namelist);
1533
1534   return rc;
1535 }
1536
1537
1538 \f
1539
1540 /* Comparison machinery for get_best_pubkey_byname.  */
1541
1542 /* First we have a struct to cache computed information about the key
1543  * in question.  */
1544 struct pubkey_cmp_cookie
1545 {
1546   int valid;                    /* Is this cookie valid?  */
1547   PKT_public_key key;           /* The key.  */
1548   PKT_user_id *uid;             /* The matching UID packet.  */
1549   unsigned int validity;        /* Computed validity of (KEY, UID).  */
1550   u32 creation_time;            /* Creation time of the newest subkey
1551                                    capable of encryption.  */
1552 };
1553
1554
1555 /* Then we have a series of helper functions.  */
1556 static int
1557 key_is_ok (const PKT_public_key *key)
1558 {
1559   return (! key->has_expired && ! key->flags.revoked
1560           && key->flags.valid && ! key->flags.disabled);
1561 }
1562
1563
1564 static int
1565 uid_is_ok (const PKT_public_key *key, const PKT_user_id *uid)
1566 {
1567   return key_is_ok (key) && ! uid->flags.revoked;
1568 }
1569
1570
1571 static int
1572 subkey_is_ok (const PKT_public_key *sub)
1573 {
1574   return ! sub->flags.revoked && sub->flags.valid && ! sub->flags.disabled;
1575 }
1576
1577 /* Return true if KEYBLOCK has only expired encryption subkyes.  Note
1578  * that the function returns false if the key has no encryption
1579  * subkeys at all or the subkecys are revoked.  */
1580 static int
1581 only_expired_enc_subkeys (kbnode_t keyblock)
1582 {
1583   kbnode_t node;
1584   PKT_public_key *sub;
1585   int any = 0;
1586
1587   for (node = find_next_kbnode (keyblock, PKT_PUBLIC_SUBKEY);
1588        node; node = find_next_kbnode (node, PKT_PUBLIC_SUBKEY))
1589     {
1590       sub = node->pkt->pkt.public_key;
1591
1592       if (!(sub->pubkey_usage & PUBKEY_USAGE_ENC))
1593         continue;
1594
1595       if (!subkey_is_ok (sub))
1596         continue;
1597
1598       any = 1;
1599       if (!sub->has_expired)
1600         return 0;
1601     }
1602
1603   return any? 1 : 0;
1604 }
1605
1606 /* Finally this function compares a NEW key to the former candidate
1607  * OLD.  Returns < 0 if the old key is worse, > 0 if the old key is
1608  * better, == 0 if it is a tie.  */
1609 static int
1610 pubkey_cmp (ctrl_t ctrl, const char *name, struct pubkey_cmp_cookie *old,
1611             struct pubkey_cmp_cookie *new, KBNODE new_keyblock)
1612 {
1613   kbnode_t n;
1614
1615   new->creation_time = 0;
1616   for (n = find_next_kbnode (new_keyblock, PKT_PUBLIC_SUBKEY);
1617        n; n = find_next_kbnode (n, PKT_PUBLIC_SUBKEY))
1618     {
1619       PKT_public_key *sub = n->pkt->pkt.public_key;
1620
1621       if ((sub->pubkey_usage & PUBKEY_USAGE_ENC) == 0)
1622         continue;
1623
1624       if (! subkey_is_ok (sub))
1625         continue;
1626
1627       if (sub->timestamp > new->creation_time)
1628         new->creation_time = sub->timestamp;
1629     }
1630
1631   for (n = find_next_kbnode (new_keyblock, PKT_USER_ID);
1632        n; n = find_next_kbnode (n, PKT_USER_ID))
1633     {
1634       PKT_user_id *uid = n->pkt->pkt.user_id;
1635       char *mbox = mailbox_from_userid (uid->name);
1636       int match = mbox ? strcasecmp (name, mbox) == 0 : 0;
1637
1638       xfree (mbox);
1639       if (! match)
1640         continue;
1641
1642       new->uid = scopy_user_id (uid);
1643       new->validity =
1644         get_validity (ctrl, new_keyblock, &new->key, uid, NULL, 0) & TRUST_MASK;
1645       new->valid = 1;
1646
1647       if (! old->valid)
1648         return -1;      /* No OLD key.  */
1649
1650       if (! uid_is_ok (&old->key, old->uid) && uid_is_ok (&new->key, uid))
1651         return -1;      /* Validity of the NEW key is better.  */
1652
1653       if (old->validity < new->validity)
1654         return -1;      /* Validity of the NEW key is better.  */
1655
1656       if (old->validity == new->validity && uid_is_ok (&new->key, uid)
1657           && old->creation_time < new->creation_time)
1658         return -1;      /* Both keys are of the same validity, but the
1659                            NEW key is newer.  */
1660     }
1661
1662   /* Stick with the OLD key.  */
1663   return 1;
1664 }
1665
1666
1667 /* This function works like get_pubkey_byname, but if the name
1668  * resembles a mail address, the results are ranked and only the best
1669  * result is returned.  */
1670 gpg_error_t
1671 get_best_pubkey_byname (ctrl_t ctrl, GETKEY_CTX *retctx, PKT_public_key *pk,
1672                         const char *name, KBNODE *ret_keyblock,
1673                         int include_unusable)
1674 {
1675   gpg_error_t err;
1676   struct getkey_ctx_s *ctx = NULL;
1677   int is_mbox = is_valid_mailbox (name);
1678   int wkd_tried = 0;
1679
1680   if (retctx)
1681     *retctx = NULL;
1682
1683  start_over:
1684   if (ctx)  /* Clear  in case of a start over.  */
1685     {
1686       if (ret_keyblock)
1687         {
1688           release_kbnode (*ret_keyblock);
1689           *ret_keyblock = NULL;
1690         }
1691       getkey_end (ctrl, ctx);
1692       ctx = NULL;
1693     }
1694   err = get_pubkey_byname (ctrl, &ctx, pk, name, ret_keyblock,
1695                            NULL, include_unusable, 0);
1696   if (err)
1697     {
1698       getkey_end (ctrl, ctx);
1699       return err;
1700     }
1701
1702   /* If the keyblock was retrieved from the local database and the key
1703    * has expired, do further checks.  However, we can do this only if
1704    * the caller requested a keyblock.  */
1705   if (is_mbox && ctx && ctx->found_via_akl == AKL_LOCAL && ret_keyblock)
1706     {
1707       u32 now = make_timestamp ();
1708       PKT_public_key *pk2 = (*ret_keyblock)->pkt->pkt.public_key;
1709       int found;
1710
1711       /* If the key has expired and its origin was the WKD then try to
1712        * get a fresh key from the WKD.  We also try this if the key
1713        * has any only expired encryption subkeys.  In case we checked
1714        * for a fresh copy in the last 3 hours we won't do that again.
1715        * Unfortunately that does not yet work because KEYUPDATE is
1716        * only updated during import iff the key has actually changed
1717        * (see import.c:import_one).  */
1718       if (!wkd_tried && pk2->keyorg == KEYORG_WKD
1719           && (pk2->keyupdate + 3*3600) < now
1720           && (pk2->has_expired || only_expired_enc_subkeys (*ret_keyblock)))
1721         {
1722           if (opt.verbose)
1723             log_info (_("checking for a fresh copy of an expired key via %s\n"),
1724                       "WKD");
1725           wkd_tried = 1;
1726           glo_ctrl.in_auto_key_retrieve++;
1727           found = !keyserver_import_wkd (ctrl, name, 0, NULL, NULL);
1728           glo_ctrl.in_auto_key_retrieve--;
1729           if (found)
1730             goto start_over;
1731         }
1732     }
1733
1734   if (is_mbox && ctx)
1735     {
1736       /* Rank results and return only the most relevant key.  */
1737       struct pubkey_cmp_cookie best = { 0 };
1738       struct pubkey_cmp_cookie new = { 0 };
1739       kbnode_t new_keyblock;
1740
1741       while (getkey_next (ctrl, ctx, &new.key, &new_keyblock) == 0)
1742         {
1743           int diff = pubkey_cmp (ctrl, name, &best, &new, new_keyblock);
1744           release_kbnode (new_keyblock);
1745           if (diff < 0)
1746             {
1747               /* New key is better.  */
1748               release_public_key_parts (&best.key);
1749               free_user_id (best.uid);
1750               best = new;
1751             }
1752           else if (diff > 0)
1753             {
1754               /* Old key is better.  */
1755               release_public_key_parts (&new.key);
1756               free_user_id (new.uid);
1757               new.uid = NULL;
1758             }
1759           else
1760             {
1761               /* A tie.  Keep the old key.  */
1762               release_public_key_parts (&new.key);
1763               free_user_id (new.uid);
1764               new.uid = NULL;
1765             }
1766         }
1767       getkey_end (ctrl, ctx);
1768       ctx = NULL;
1769       free_user_id (best.uid);
1770       best.uid = NULL;
1771
1772       if (best.valid)
1773         {
1774           if (retctx || ret_keyblock)
1775             {
1776               ctx = xtrycalloc (1, sizeof **retctx);
1777               if (! ctx)
1778                 err = gpg_error_from_syserror ();
1779               else
1780                 {
1781                   ctx->kr_handle = keydb_new ();
1782                   if (! ctx->kr_handle)
1783                     {
1784                       err = gpg_error_from_syserror ();
1785                       xfree (ctx);
1786                       ctx = NULL;
1787                       if (retctx)
1788                         *retctx = NULL;
1789                     }
1790                   else
1791                     {
1792                       u32 *keyid = pk_keyid (&best.key);
1793                       ctx->exact = 1;
1794                       ctx->nitems = 1;
1795                       ctx->items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
1796                       ctx->items[0].u.kid[0] = keyid[0];
1797                       ctx->items[0].u.kid[1] = keyid[1];
1798
1799                       if (ret_keyblock)
1800                         {
1801                           release_kbnode (*ret_keyblock);
1802                           *ret_keyblock = NULL;
1803                           err = getkey_next (ctrl, ctx, NULL, ret_keyblock);
1804                         }
1805                     }
1806                 }
1807             }
1808
1809           if (pk)
1810             *pk = best.key;
1811           else
1812             release_public_key_parts (&best.key);
1813         }
1814     }
1815
1816   if (err && ctx)
1817     {
1818       getkey_end (ctrl, ctx);
1819       ctx = NULL;
1820     }
1821
1822   if (retctx && ctx)
1823     *retctx = ctx;
1824   else
1825     getkey_end (ctrl, ctx);
1826
1827   return err;
1828 }
1829
1830 \f
1831
1832 /* Get a public key from a file.
1833  *
1834  * PK is the buffer to store the key.  The caller needs to make sure
1835  * that PK->REQ_USAGE is valid.  PK->REQ_USAGE is passed through to
1836  * the lookup function and is a mask of PUBKEY_USAGE_SIG,
1837  * PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  If this is non-zero, only
1838  * keys with the specified usage will be returned.
1839  *
1840  * FNAME is the file name.  That file should contain exactly one
1841  * keyblock.
1842  *
1843  * This function returns 0 on success.  Otherwise, an error code is
1844  * returned.  In particular, GPG_ERR_NO_PUBKEY is returned if the key
1845  * is not found.
1846  *
1847  * The self-signed data has already been merged into the public key
1848  * using merge_selfsigs.  The caller must release the content of PK by
1849  * calling release_public_key_parts (or, if PK was malloced, using
1850  * free_public_key).
1851  */
1852 gpg_error_t
1853 get_pubkey_fromfile (ctrl_t ctrl, PKT_public_key *pk, const char *fname)
1854 {
1855   gpg_error_t err;
1856   kbnode_t keyblock;
1857   kbnode_t found_key;
1858   unsigned int infoflags;
1859
1860   err = read_key_from_file (ctrl, fname, &keyblock);
1861   if (!err)
1862     {
1863       /* Warning: node flag bits 0 and 1 should be preserved by
1864        * merge_selfsigs.  FIXME: Check whether this still holds. */
1865       merge_selfsigs (ctrl, keyblock);
1866       found_key = finish_lookup (keyblock, pk->req_usage, 0, 0, &infoflags);
1867       print_status_key_considered (keyblock, infoflags);
1868       if (found_key)
1869         pk_from_block (pk, keyblock, found_key);
1870       else
1871         err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1872     }
1873
1874   release_kbnode (keyblock);
1875   return err;
1876 }
1877
1878
1879 /* Lookup a key with the specified fingerprint.
1880  *
1881  * If PK is not NULL, the public key of the first result is returned
1882  * in *PK.  Note: this function does an exact search and thus the
1883  * returned public key may be a subkey rather than the primary key.
1884  * Note: The self-signed data has already been merged into the public
1885  * key using merge_selfsigs.  Free *PK by calling
1886  * release_public_key_parts (or, if PK was allocated using xfree, you
1887  * can use free_public_key, which calls release_public_key_parts(PK)
1888  * and then xfree(PK)).
1889  *
1890  * If PK->REQ_USAGE is set, it is used to filter the search results.
1891  * (Thus, if PK is not NULL, PK->REQ_USAGE must be valid!!!)  See the
1892  * documentation for finish_lookup to understand exactly how this is
1893  * used.
1894  *
1895  * If R_KEYBLOCK is not NULL, then the first result's keyblock is
1896  * returned in *R_KEYBLOCK.  This should be freed using
1897  * release_kbnode().
1898  *
1899  * FPRINT is a byte array whose contents is the fingerprint to use as
1900  * the search term.  FPRINT_LEN specifies the length of the
1901  * fingerprint (in bytes).  Currently, only 16 and 20-byte
1902  * fingerprints are supported.
1903  *
1904  * FIXME: We should replace this with the _byname function.  This can
1905  * be done by creating a userID conforming to the unified fingerprint
1906  * style.  */
1907 int
1908 get_pubkey_byfprint (ctrl_t ctrl, PKT_public_key *pk, kbnode_t *r_keyblock,
1909                      const byte * fprint, size_t fprint_len)
1910 {
1911   int rc;
1912
1913   if (r_keyblock)
1914     *r_keyblock = NULL;
1915
1916   if (fprint_len == 20 || fprint_len == 16)
1917     {
1918       struct getkey_ctx_s ctx;
1919       KBNODE kb = NULL;
1920       KBNODE found_key = NULL;
1921
1922       memset (&ctx, 0, sizeof ctx);
1923       ctx.exact = 1;
1924       ctx.not_allocated = 1;
1925       /* FIXME: We should get the handle from the cache like we do in
1926        * get_pubkey.  */
1927       ctx.kr_handle = keydb_new ();
1928       if (!ctx.kr_handle)
1929         return gpg_error_from_syserror ();
1930
1931       ctx.nitems = 1;
1932       ctx.items[0].mode = fprint_len == 16 ? KEYDB_SEARCH_MODE_FPR16
1933         : KEYDB_SEARCH_MODE_FPR20;
1934       memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1935       if (pk)
1936         ctx.req_usage = pk->req_usage;
1937       rc = lookup (ctrl, &ctx, 0, &kb, &found_key);
1938       if (!rc && pk)
1939         pk_from_block (pk, kb, found_key);
1940       if (!rc && r_keyblock)
1941         {
1942           *r_keyblock = kb;
1943           kb = NULL;
1944         }
1945       release_kbnode (kb);
1946       getkey_end (ctrl, &ctx);
1947     }
1948   else
1949     rc = GPG_ERR_GENERAL; /* Oops */
1950   return rc;
1951 }
1952
1953
1954 /* This function is similar to get_pubkey_byfprint, but it doesn't
1955  * merge the self-signed data into the public key and subkeys or into
1956  * the user ids.  It also doesn't add the key to the user id cache.
1957  * Further, this function ignores PK->REQ_USAGE.
1958  *
1959  * This function is intended to avoid recursion and, as such, should
1960  * only be used in very specific situations.
1961  *
1962  * Like get_pubkey_byfprint, PK may be NULL.  In that case, this
1963  * function effectively just checks for the existence of the key.  */
1964 gpg_error_t
1965 get_pubkey_byfprint_fast (PKT_public_key * pk,
1966                           const byte * fprint, size_t fprint_len)
1967 {
1968   gpg_error_t err;
1969   KBNODE keyblock;
1970
1971   err = get_keyblock_byfprint_fast (&keyblock, NULL, fprint, fprint_len, 0);
1972   if (!err)
1973     {
1974       if (pk)
1975         copy_public_key (pk, keyblock->pkt->pkt.public_key);
1976       release_kbnode (keyblock);
1977     }
1978
1979   return err;
1980 }
1981
1982
1983 /* This function is similar to get_pubkey_byfprint_fast but returns a
1984  * keydb handle at R_HD and the keyblock at R_KEYBLOCK.  R_KEYBLOCK or
1985  * R_HD may be NULL.  If LOCK is set the handle has been opend in
1986  * locked mode and keydb_disable_caching () has been called.  On error
1987  * R_KEYBLOCK is set to NULL but R_HD must be released by the caller;
1988  * it may have a value of NULL, though.  This allows to do an insert
1989  * operation on a locked keydb handle.  */
1990 gpg_error_t
1991 get_keyblock_byfprint_fast (kbnode_t *r_keyblock, KEYDB_HANDLE *r_hd,
1992                             const byte *fprint, size_t fprint_len, int lock)
1993 {
1994   gpg_error_t err;
1995   KEYDB_HANDLE hd;
1996   kbnode_t keyblock;
1997   byte fprbuf[MAX_FINGERPRINT_LEN];
1998   int i;
1999
2000   if (r_keyblock)
2001     *r_keyblock = NULL;
2002   if (r_hd)
2003     *r_hd = NULL;
2004
2005   for (i = 0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
2006     fprbuf[i] = fprint[i];
2007   while (i < MAX_FINGERPRINT_LEN)
2008     fprbuf[i++] = 0;
2009
2010   hd = keydb_new ();
2011   if (!hd)
2012     return gpg_error_from_syserror ();
2013
2014   if (lock)
2015     {
2016       err = keydb_lock (hd);
2017       if (err)
2018         {
2019           /* If locking did not work, we better don't return a handle
2020            * at all - there was a reason that locking has been
2021            * requested.  */
2022           keydb_release (hd);
2023           return err;
2024         }
2025       keydb_disable_caching (hd);
2026     }
2027
2028   /* Fo all other errors we return the handle.  */
2029   if (r_hd)
2030     *r_hd = hd;
2031
2032   err = keydb_search_fpr (hd, fprbuf);
2033   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2034     {
2035       if (!r_hd)
2036         keydb_release (hd);
2037       return gpg_error (GPG_ERR_NO_PUBKEY);
2038     }
2039   err = keydb_get_keyblock (hd, &keyblock);
2040   if (err)
2041     {
2042       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (err));
2043       if (!r_hd)
2044         keydb_release (hd);
2045       return gpg_error (GPG_ERR_NO_PUBKEY);
2046     }
2047
2048   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
2049               || keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY);
2050
2051   /* Not caching key here since it won't have all of the fields
2052      properly set. */
2053
2054   if (r_keyblock)
2055     *r_keyblock = keyblock;
2056   else
2057     release_kbnode (keyblock);
2058
2059   if (!r_hd)
2060     keydb_release (hd);
2061
2062   return 0;
2063 }
2064
2065
2066 const char *
2067 parse_def_secret_key (ctrl_t ctrl)
2068 {
2069   KEYDB_HANDLE hd = NULL;
2070   strlist_t t;
2071   static int warned;
2072
2073   for (t = opt.def_secret_key; t; t = t->next)
2074     {
2075       gpg_error_t err;
2076       KEYDB_SEARCH_DESC desc;
2077       KBNODE kb;
2078       KBNODE node;
2079
2080       err = classify_user_id (t->d, &desc, 1);
2081       if (err)
2082         {
2083           log_error (_("secret key \"%s\" not found: %s\n"),
2084                      t->d, gpg_strerror (err));
2085           if (!opt.quiet)
2086             log_info (_("(check argument of option '%s')\n"), "--default-key");
2087           continue;
2088         }
2089
2090       if (! hd)
2091         {
2092           hd = keydb_new ();
2093           if (!hd)
2094             return NULL;
2095         }
2096       else
2097         keydb_search_reset (hd);
2098
2099
2100       err = keydb_search (hd, &desc, 1, NULL);
2101       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2102         continue;
2103
2104       if (err)
2105         {
2106           log_error (_("key \"%s\" not found: %s\n"), t->d, gpg_strerror (err));
2107           t = NULL;
2108           break;
2109         }
2110
2111       err = keydb_get_keyblock (hd, &kb);
2112       if (err)
2113         {
2114           log_error (_("error reading keyblock: %s\n"),
2115                      gpg_strerror (err));
2116           continue;
2117         }
2118
2119       merge_selfsigs (ctrl, kb);
2120
2121       err = gpg_error (GPG_ERR_NO_SECKEY);
2122       node = kb;
2123       do
2124         {
2125           PKT_public_key *pk = node->pkt->pkt.public_key;
2126
2127           /* Check that the key has the signing capability.  */
2128           if (! (pk->pubkey_usage & PUBKEY_USAGE_SIG))
2129             continue;
2130
2131           /* Check if the key is valid.  */
2132           if (pk->flags.revoked)
2133             {
2134               if (DBG_LOOKUP)
2135                 log_debug ("not using %s as default key, %s",
2136                            keystr_from_pk (pk), "revoked");
2137               continue;
2138             }
2139           if (pk->has_expired)
2140             {
2141               if (DBG_LOOKUP)
2142                 log_debug ("not using %s as default key, %s",
2143                            keystr_from_pk (pk), "expired");
2144               continue;
2145             }
2146           if (pk_is_disabled (pk))
2147             {
2148               if (DBG_LOOKUP)
2149                 log_debug ("not using %s as default key, %s",
2150                            keystr_from_pk (pk), "disabled");
2151               continue;
2152             }
2153
2154           err = agent_probe_secret_key (ctrl, pk);
2155           if (! err)
2156             /* This is a valid key.  */
2157             break;
2158         }
2159       while ((node = find_next_kbnode (node, PKT_PUBLIC_SUBKEY)));
2160
2161       release_kbnode (kb);
2162       if (err)
2163         {
2164           if (! warned && ! opt.quiet)
2165             {
2166               log_info (_("Warning: not using '%s' as default key: %s\n"),
2167                         t->d, gpg_strerror (GPG_ERR_NO_SECKEY));
2168               print_reported_error (err, GPG_ERR_NO_SECKEY);
2169             }
2170         }
2171       else
2172         {
2173           if (! warned && ! opt.quiet)
2174             log_info (_("using \"%s\" as default secret key for signing\n"),
2175                       t->d);
2176           break;
2177         }
2178     }
2179
2180   if (! warned && opt.def_secret_key && ! t)
2181     log_info (_("all values passed to '%s' ignored\n"),
2182               "--default-key");
2183
2184   warned = 1;
2185
2186   if (hd)
2187     keydb_release (hd);
2188
2189   if (t)
2190     return t->d;
2191   return NULL;
2192 }
2193
2194
2195 /* Look up a secret key.
2196  *
2197  * If PK is not NULL, the public key of the first result is returned
2198  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2199  * set, it is used to filter the search results.  See the
2200  * documentation for finish_lookup to understand exactly how this is
2201  * used.  Note: The self-signed data has already been merged into the
2202  * public key using merge_selfsigs.  Free *PK by calling
2203  * release_public_key_parts (or, if PK was allocated using xfree, you
2204  * can use free_public_key, which calls release_public_key_parts(PK)
2205  * and then xfree(PK)).
2206  *
2207  * If --default-key was set, then the specified key is looked up.  (In
2208  * this case, the default key is returned even if it is considered
2209  * unusable.  See the documentation for skip_unusable for exactly what
2210  * this means.)
2211  *
2212  * Otherwise, this initiates a DB scan that returns all keys that are
2213  * usable (see previous paragraph for exactly what usable means) and
2214  * for which a secret key is available.
2215  *
2216  * This function returns the first match.  Additional results can be
2217  * returned using getkey_next.  */
2218 gpg_error_t
2219 get_seckey_default (ctrl_t ctrl, PKT_public_key *pk)
2220 {
2221   gpg_error_t err;
2222   strlist_t namelist = NULL;
2223   int include_unusable = 1;
2224
2225
2226   const char *def_secret_key = parse_def_secret_key (ctrl);
2227   if (def_secret_key)
2228     add_to_strlist (&namelist, def_secret_key);
2229   else
2230     include_unusable = 0;
2231
2232   err = key_byname (ctrl, NULL, namelist, pk, 1, include_unusable, NULL, NULL);
2233
2234   free_strlist (namelist);
2235
2236   return err;
2237 }
2238
2239
2240 \f
2241 /* Search for keys matching some criteria.
2242  *
2243  * If RETCTX is not NULL, then the constructed context is returned in
2244  * *RETCTX so that getpubkey_next can be used to get subsequent
2245  * results.  In this case, getkey_end() must be used to free the
2246  * search context.  If RETCTX is not NULL, then RET_KDBHD must be
2247  * NULL.
2248  *
2249  * If PK is not NULL, the public key of the first result is returned
2250  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2251  * set, it is used to filter the search results.  See the
2252  * documentation for finish_lookup to understand exactly how this is
2253  * used.  Note: The self-signed data has already been merged into the
2254  * public key using merge_selfsigs.  Free *PK by calling
2255  * release_public_key_parts (or, if PK was allocated using xfree, you
2256  * can use free_public_key, which calls release_public_key_parts(PK)
2257  * and then xfree(PK)).
2258  *
2259  * If NAMES is not NULL, then a search query is constructed using
2260  * classify_user_id on each of the strings in the list.  (Recall: the
2261  * database does an OR of the terms, not an AND.)  If NAMES is
2262  * NULL, then all results are returned.
2263  *
2264  * If WANT_SECRET is set, then only keys with an available secret key
2265  * (either locally or via key registered on a smartcard) are returned.
2266  *
2267  * This function does not skip unusable keys (see the documentation
2268  * for skip_unusable for an exact definition).
2269  *
2270  * If RET_KEYBLOCK is not NULL, the keyblock is returned in
2271  * *RET_KEYBLOCK.  This should be freed using release_kbnode().
2272  *
2273  * This function returns 0 on success.  Otherwise, an error code is
2274  * returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
2275  * (if want_secret is set) is returned if the key is not found.  */
2276 gpg_error_t
2277 getkey_bynames (ctrl_t ctrl, getkey_ctx_t *retctx, PKT_public_key *pk,
2278                 strlist_t names, int want_secret, kbnode_t *ret_keyblock)
2279 {
2280   return key_byname (ctrl, retctx, names, pk, want_secret, 1,
2281                      ret_keyblock, NULL);
2282 }
2283
2284
2285 /* Search for one key matching some criteria.
2286  *
2287  * If RETCTX is not NULL, then the constructed context is returned in
2288  * *RETCTX so that getpubkey_next can be used to get subsequent
2289  * results.  In this case, getkey_end() must be used to free the
2290  * search context.  If RETCTX is not NULL, then RET_KDBHD must be
2291  * NULL.
2292  *
2293  * If PK is not NULL, the public key of the first result is returned
2294  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2295  * set, it is used to filter the search results.  See the
2296  * documentation for finish_lookup to understand exactly how this is
2297  * used.  Note: The self-signed data has already been merged into the
2298  * public key using merge_selfsigs.  Free *PK by calling
2299  * release_public_key_parts (or, if PK was allocated using xfree, you
2300  * can use free_public_key, which calls release_public_key_parts(PK)
2301  * and then xfree(PK)).
2302  *
2303  * If NAME is not NULL, then a search query is constructed using
2304  * classify_user_id on the string.  In this case, even unusable keys
2305  * (see the documentation for skip_unusable for an exact definition of
2306  * unusable) are returned.  Otherwise, if --default-key was set, then
2307  * that key is returned (even if it is unusable).  If neither of these
2308  * conditions holds, then the first usable key is returned.
2309  *
2310  * If WANT_SECRET is set, then only keys with an available secret key
2311  * (either locally or via key registered on a smartcard) are returned.
2312  *
2313  * This function does not skip unusable keys (see the documentation
2314  * for skip_unusable for an exact definition).
2315  *
2316  * If RET_KEYBLOCK is not NULL, the keyblock is returned in
2317  * *RET_KEYBLOCK.  This should be freed using release_kbnode().
2318  *
2319  * This function returns 0 on success.  Otherwise, an error code is
2320  * returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
2321  * (if want_secret is set) is returned if the key is not found.
2322  *
2323  * FIXME: We also have the get_pubkey_byname function which has a
2324  * different semantic.  Should be merged with this one.  */
2325 gpg_error_t
2326 getkey_byname (ctrl_t ctrl, getkey_ctx_t *retctx, PKT_public_key *pk,
2327                const char *name, int want_secret, kbnode_t *ret_keyblock)
2328 {
2329   gpg_error_t err;
2330   strlist_t namelist = NULL;
2331   int with_unusable = 1;
2332   const char *def_secret_key = NULL;
2333
2334   if (want_secret && !name)
2335     def_secret_key = parse_def_secret_key (ctrl);
2336
2337   if (want_secret && !name && def_secret_key)
2338     add_to_strlist (&namelist, def_secret_key);
2339   else if (name)
2340     add_to_strlist (&namelist, name);
2341   else
2342     with_unusable = 0;
2343
2344   err = key_byname (ctrl, retctx, namelist, pk, want_secret, with_unusable,
2345                     ret_keyblock, NULL);
2346
2347   /* FIXME: Check that we really return GPG_ERR_NO_SECKEY if
2348      WANT_SECRET has been used.  */
2349
2350   free_strlist (namelist);
2351
2352   return err;
2353 }
2354
2355
2356 /* Return the next search result.
2357  *
2358  * If PK is not NULL, the public key of the next result is returned in
2359  * *PK.  Note: The self-signed data has already been merged into the
2360  * public key using merge_selfsigs.  Free *PK by calling
2361  * release_public_key_parts (or, if PK was allocated using xmalloc, you
2362  * can use free_public_key, which calls release_public_key_parts(PK)
2363  * and then xfree(PK)).
2364  *
2365  * RET_KEYBLOCK can be given as NULL; if it is not NULL it the entire
2366  * found keyblock is returned which must be released with
2367  * release_kbnode.  If the function returns an error NULL is stored at
2368  * RET_KEYBLOCK.
2369  *
2370  * The self-signed data has already been merged into the public key
2371  * using merge_selfsigs.  */
2372 gpg_error_t
2373 getkey_next (ctrl_t ctrl, getkey_ctx_t ctx,
2374              PKT_public_key *pk, kbnode_t *ret_keyblock)
2375 {
2376   int rc; /* Fixme:  Make sure this is proper gpg_error */
2377   KBNODE keyblock = NULL;
2378   KBNODE found_key = NULL;
2379
2380   /* We need to disable the caching so that for an exact key search we
2381      won't get the result back from the cache and thus end up in an
2382      endless loop.  The endless loop can occur, because the cache is
2383      used without respecting the current file pointer!  */
2384   keydb_disable_caching (ctx->kr_handle);
2385
2386   /* FOUND_KEY is only valid as long as RET_KEYBLOCK is.  If the
2387    * caller wants PK, but not RET_KEYBLOCK, we need hand in our own
2388    * keyblock.  */
2389   if (pk && ret_keyblock == NULL)
2390       ret_keyblock = &keyblock;
2391
2392   rc = lookup (ctrl, ctx, ctx->want_secret,
2393                ret_keyblock, pk ? &found_key : NULL);
2394   if (!rc && pk)
2395     {
2396       log_assert (found_key);
2397       pk_from_block (pk, NULL, found_key);
2398       release_kbnode (keyblock);
2399     }
2400
2401   return rc;
2402 }
2403
2404
2405 /* Release any resources used by a key listing context.  This must be
2406  * called on the context returned by, e.g., getkey_byname.  */
2407 void
2408 getkey_end (ctrl_t ctrl, getkey_ctx_t ctx)
2409 {
2410   if (ctx)
2411     {
2412 #ifdef HAVE_W32_SYSTEM
2413
2414       /* FIXME: This creates a big regression for Windows because the
2415        * keyring is only released after the global ctrl is released.
2416        * So if an operation does a getkey and then tries to modify the
2417        * keyring it will fail on Windows with a sharing violation.  We
2418        * need to modify all keyring write operations to also take the
2419        * ctrl and close the cached_getkey_kdb handle to make writing
2420        * work.  See: GnuPG-bug-id: 3097  */
2421       (void)ctrl;
2422       keydb_release (ctx->kr_handle);
2423
2424 #else /*!HAVE_W32_SYSTEM*/
2425
2426       if (ctrl && !ctrl->cached_getkey_kdb)
2427         ctrl->cached_getkey_kdb = ctx->kr_handle;
2428       else
2429         keydb_release (ctx->kr_handle);
2430
2431 #endif /*!HAVE_W32_SYSTEM*/
2432
2433       free_strlist (ctx->extra_list);
2434       if (!ctx->not_allocated)
2435         xfree (ctx);
2436     }
2437 }
2438
2439
2440 \f
2441 /************************************************
2442  ************* Merging stuff ********************
2443  ************************************************/
2444
2445 /* Set the mainkey_id fields for all keys in KEYBLOCK.  This is
2446  * usually done by merge_selfsigs but at some places we only need the
2447  * main_kid not a full merge.  The function also guarantees that all
2448  * pk->keyids are computed.  */
2449 void
2450 setup_main_keyids (kbnode_t keyblock)
2451 {
2452   u32 kid[2], mainkid[2];
2453   kbnode_t kbctx, node;
2454   PKT_public_key *pk;
2455
2456   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2457     BUG ();
2458   pk = keyblock->pkt->pkt.public_key;
2459
2460   keyid_from_pk (pk, mainkid);
2461   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
2462     {
2463       if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
2464             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2465         continue;
2466       pk = node->pkt->pkt.public_key;
2467       keyid_from_pk (pk, kid); /* Make sure pk->keyid is set.  */
2468       if (!pk->main_keyid[0] && !pk->main_keyid[1])
2469         {
2470           pk->main_keyid[0] = mainkid[0];
2471           pk->main_keyid[1] = mainkid[1];
2472         }
2473     }
2474 }
2475
2476
2477 /* KEYBLOCK corresponds to a public key block.  This function merges
2478  * much of the information from the self-signed data into the public
2479  * key, public subkey and user id data structures.  If you use the
2480  * high-level search API (e.g., get_pubkey) for looking up key blocks,
2481  * then you don't need to call this function.  This function is
2482  * useful, however, if you change the keyblock, e.g., by adding or
2483  * removing a self-signed data packet.  */
2484 void
2485 merge_keys_and_selfsig (ctrl_t ctrl, kbnode_t keyblock)
2486 {
2487   if (!keyblock)
2488     ;
2489   else if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
2490     merge_selfsigs (ctrl, keyblock);
2491   else
2492     log_debug ("FIXME: merging secret key blocks is not anymore available\n");
2493 }
2494
2495
2496 static int
2497 parse_key_usage (PKT_signature * sig)
2498 {
2499   int key_usage = 0;
2500   const byte *p;
2501   size_t n;
2502   byte flags;
2503
2504   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n);
2505   if (p && n)
2506     {
2507       /* First octet of the keyflags.  */
2508       flags = *p;
2509
2510       if (flags & 1)
2511         {
2512           key_usage |= PUBKEY_USAGE_CERT;
2513           flags &= ~1;
2514         }
2515
2516       if (flags & 2)
2517         {
2518           key_usage |= PUBKEY_USAGE_SIG;
2519           flags &= ~2;
2520         }
2521
2522       /* We do not distinguish between encrypting communications and
2523          encrypting storage. */
2524       if (flags & (0x04 | 0x08))
2525         {
2526           key_usage |= PUBKEY_USAGE_ENC;
2527           flags &= ~(0x04 | 0x08);
2528         }
2529
2530       if (flags & 0x20)
2531         {
2532           key_usage |= PUBKEY_USAGE_AUTH;
2533           flags &= ~0x20;
2534         }
2535
2536       if (flags)
2537         key_usage |= PUBKEY_USAGE_UNKNOWN;
2538
2539       if (!key_usage)
2540         key_usage |= PUBKEY_USAGE_NONE;
2541     }
2542   else if (p) /* Key flags of length zero.  */
2543     key_usage |= PUBKEY_USAGE_NONE;
2544
2545   /* We set PUBKEY_USAGE_UNKNOWN to indicate that this key has a
2546      capability that we do not handle.  This serves to distinguish
2547      between a zero key usage which we handle as the default
2548      capabilities for that algorithm, and a usage that we do not
2549      handle.  Likewise we use PUBKEY_USAGE_NONE to indicate that
2550      key_flags have been given but they do not specify any usage.  */
2551
2552   return key_usage;
2553 }
2554
2555
2556 /* Apply information from SIGNODE (which is the valid self-signature
2557  * associated with that UID) to the UIDNODE:
2558  * - weather the UID has been revoked
2559  * - assumed creation date of the UID
2560  * - temporary store the keyflags here
2561  * - temporary store the key expiration time here
2562  * - mark whether the primary user ID flag hat been set.
2563  * - store the preferences
2564  */
2565 static void
2566 fixup_uidnode (KBNODE uidnode, KBNODE signode, u32 keycreated)
2567 {
2568   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
2569   PKT_signature *sig = signode->pkt->pkt.signature;
2570   const byte *p, *sym, *aead, *hash, *zip;
2571   size_t n, nsym, naead, nhash, nzip;
2572
2573   sig->flags.chosen_selfsig = 1;/* We chose this one. */
2574   uid->created = 0;             /* Not created == invalid. */
2575   if (IS_UID_REV (sig))
2576     {
2577       uid->flags.revoked = 1;
2578       return; /* Has been revoked.  */
2579     }
2580   else
2581     uid->flags.revoked = 0;
2582
2583   uid->expiredate = sig->expiredate;
2584
2585   if (sig->flags.expired)
2586     {
2587       uid->flags.expired = 1;
2588       return; /* Has expired.  */
2589     }
2590   else
2591     uid->flags.expired = 0;
2592
2593   uid->created = sig->timestamp; /* This one is okay. */
2594   uid->selfsigversion = sig->version;
2595   /* If we got this far, it's not expired :) */
2596   uid->flags.expired = 0;
2597
2598   /* Store the key flags in the helper variable for later processing.  */
2599   uid->help_key_usage = parse_key_usage (sig);
2600
2601   /* Ditto for the key expiration.  */
2602   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2603   if (p && buf32_to_u32 (p))
2604     uid->help_key_expire = keycreated + buf32_to_u32 (p);
2605   else
2606     uid->help_key_expire = 0;
2607
2608   /* Set the primary user ID flag - we will later wipe out some
2609    * of them to only have one in our keyblock.  */
2610   uid->flags.primary = 0;
2611   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
2612   if (p && *p)
2613     uid->flags.primary = 2;
2614
2615   /* We could also query this from the unhashed area if it is not in
2616    * the hased area and then later try to decide which is the better
2617    * there should be no security problem with this.
2618    * For now we only look at the hashed one.  */
2619
2620   /* Now build the preferences list.  These must come from the
2621      hashed section so nobody can modify the ciphers a key is
2622      willing to accept.  */
2623   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM, &n);
2624   sym = p;
2625   nsym = p ? n : 0;
2626   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_AEAD, &n);
2627   aead = p;
2628   naead = p ? n : 0;
2629   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH, &n);
2630   hash = p;
2631   nhash = p ? n : 0;
2632   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR, &n);
2633   zip = p;
2634   nzip = p ? n : 0;
2635   if (uid->prefs)
2636     xfree (uid->prefs);
2637   n = nsym + naead + nhash + nzip;
2638   if (!n)
2639     uid->prefs = NULL;
2640   else
2641     {
2642       uid->prefs = xmalloc (sizeof (*uid->prefs) * (n + 1));
2643       n = 0;
2644       for (; nsym; nsym--, n++)
2645         {
2646           uid->prefs[n].type = PREFTYPE_SYM;
2647           uid->prefs[n].value = *sym++;
2648         }
2649       for (; naead; naead--, n++)
2650         {
2651           uid->prefs[n].type = PREFTYPE_AEAD;
2652           uid->prefs[n].value = *aead++;
2653         }
2654       for (; nhash; nhash--, n++)
2655         {
2656           uid->prefs[n].type = PREFTYPE_HASH;
2657           uid->prefs[n].value = *hash++;
2658         }
2659       for (; nzip; nzip--, n++)
2660         {
2661           uid->prefs[n].type = PREFTYPE_ZIP;
2662           uid->prefs[n].value = *zip++;
2663         }
2664       uid->prefs[n].type = PREFTYPE_NONE; /* End of list marker  */
2665       uid->prefs[n].value = 0;
2666     }
2667
2668   /* See whether we have the MDC feature.  */
2669   uid->flags.mdc = 0;
2670   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
2671   if (p && n && (p[0] & 0x01))
2672     uid->flags.mdc = 1;
2673
2674   /* See whether we have the AEAD feature.  */
2675   uid->flags.aead = 0;
2676   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
2677   if (p && n && (p[0] & 0x02))
2678     uid->flags.aead = 1;
2679
2680   /* And the keyserver modify flag.  */
2681   uid->flags.ks_modify = 1;
2682   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
2683   if (p && n && (p[0] & 0x80))
2684     uid->flags.ks_modify = 0;
2685 }
2686
2687 static void
2688 sig_to_revoke_info (PKT_signature * sig, struct revoke_info *rinfo)
2689 {
2690   rinfo->date = sig->timestamp;
2691   rinfo->algo = sig->pubkey_algo;
2692   rinfo->keyid[0] = sig->keyid[0];
2693   rinfo->keyid[1] = sig->keyid[1];
2694 }
2695
2696
2697 /* Given a keyblock, parse the key block and extract various pieces of
2698  * information and save them with the primary key packet and the user
2699  * id packets.  For instance, some information is stored in signature
2700  * packets.  We find the latest such valid packet (since the user can
2701  * change that information) and copy its contents into the
2702  * PKT_public_key.
2703  *
2704  * Note that R_REVOKED may be set to 0, 1 or 2.
2705  *
2706  * This function fills in the following fields in the primary key's
2707  * keyblock:
2708  *
2709  *   main_keyid          (computed)
2710  *   revkey / numrevkeys (derived from self signed key data)
2711  *   flags.valid         (whether we have at least 1 self-sig)
2712  *   flags.maybe_revoked (whether a designed revoked the key, but
2713  *                        we are missing the key to check the sig)
2714  *   selfsigversion      (highest version of any valid self-sig)
2715  *   pubkey_usage        (derived from most recent self-sig or most
2716  *                        recent user id)
2717  *   has_expired         (various sources)
2718  *   expiredate          (various sources)
2719  *
2720  * See the documentation for fixup_uidnode for how the user id packets
2721  * are modified.  In addition to that the primary user id's is_primary
2722  * field is set to 1 and the other user id's is_primary are set to 0.
2723  */
2724 static void
2725 merge_selfsigs_main (ctrl_t ctrl, kbnode_t keyblock, int *r_revoked,
2726                      struct revoke_info *rinfo)
2727 {
2728   PKT_public_key *pk = NULL;
2729   KBNODE k;
2730   u32 kid[2];
2731   u32 sigdate, uiddate, uiddate2;
2732   KBNODE signode, uidnode, uidnode2;
2733   u32 curtime = make_timestamp ();
2734   unsigned int key_usage = 0;
2735   u32 keytimestamp = 0;
2736   u32 key_expire = 0;
2737   int key_expire_seen = 0;
2738   byte sigversion = 0;
2739
2740   *r_revoked = 0;
2741   memset (rinfo, 0, sizeof (*rinfo));
2742
2743   /* Section 11.1 of RFC 4880 determines the order of packets within a
2744    * message.  There are three sections, which must occur in the
2745    * following order: the public key, the user ids and user attributes
2746    * and the subkeys.  Within each section, each primary packet (e.g.,
2747    * a user id packet) is followed by one or more signature packets,
2748    * which modify that packet.  */
2749
2750   /* According to Section 11.1 of RFC 4880, the public key must be the
2751      first packet.  Note that parse_keyblock_image ensures that the
2752      first packet is the public key.  */
2753   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2754     BUG ();
2755   pk = keyblock->pkt->pkt.public_key;
2756   keytimestamp = pk->timestamp;
2757
2758   keyid_from_pk (pk, kid);
2759   pk->main_keyid[0] = kid[0];
2760   pk->main_keyid[1] = kid[1];
2761
2762   if (pk->version < 4)
2763     {
2764       /* Before v4 the key packet itself contains the expiration date
2765        * and there was no way to change it, so we start with the one
2766        * from the key packet.  */
2767       key_expire = pk->max_expiredate;
2768       key_expire_seen = 1;
2769     }
2770
2771   /* First pass:
2772    *
2773    * - Find the latest direct key self-signature.  We assume that the
2774    *   newest one overrides all others.
2775    *
2776    * - Determine whether the key has been revoked.
2777    *
2778    * - Gather all revocation keys (unlike other data, we don't just
2779    *   take them from the latest self-signed packet).
2780    *
2781    * - Determine max (sig[...]->version).
2782    */
2783
2784   /* Reset this in case this key was already merged. */
2785   xfree (pk->revkey);
2786   pk->revkey = NULL;
2787   pk->numrevkeys = 0;
2788
2789   signode = NULL;
2790   sigdate = 0; /* Helper variable to find the latest signature.  */
2791
2792   /* According to Section 11.1 of RFC 4880, the public key comes first
2793    * and is immediately followed by any signature packets that modify
2794    * it.  */
2795   for (k = keyblock;
2796        k && k->pkt->pkttype != PKT_USER_ID
2797          && k->pkt->pkttype != PKT_ATTRIBUTE
2798          && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2799        k = k->next)
2800     {
2801       if (k->pkt->pkttype == PKT_SIGNATURE)
2802         {
2803           PKT_signature *sig = k->pkt->pkt.signature;
2804           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
2805             { /* Self sig.  */
2806
2807               if (check_key_signature (ctrl, keyblock, k, NULL))
2808                 ; /* Signature did not verify.  */
2809               else if (IS_KEY_REV (sig))
2810                 {
2811                   /* Key has been revoked - there is no way to
2812                    * override such a revocation, so we theoretically
2813                    * can stop now.  We should not cope with expiration
2814                    * times for revocations here because we have to
2815                    * assume that an attacker can generate all kinds of
2816                    * signatures.  However due to the fact that the key
2817                    * has been revoked it does not harm either and by
2818                    * continuing we gather some more info on that
2819                    * key.  */
2820                   *r_revoked = 1;
2821                   sig_to_revoke_info (sig, rinfo);
2822                 }
2823               else if (IS_KEY_SIG (sig))
2824                 {
2825                   /* Add the indicated revocations keys from all
2826                    * signatures not just the latest.  We do this
2827                    * because you need multiple 1F sigs to properly
2828                    * handle revocation keys (PGP does it this way, and
2829                    * a revocation key could be sensitive and hence in
2830                    * a different signature).  */
2831                   if (sig->revkey)
2832                     {
2833                       int i;
2834
2835                       pk->revkey =
2836                         xrealloc (pk->revkey, sizeof (struct revocation_key) *
2837                                   (pk->numrevkeys + sig->numrevkeys));
2838
2839                       for (i = 0; i < sig->numrevkeys; i++)
2840                         memcpy (&pk->revkey[pk->numrevkeys++],
2841                                 &sig->revkey[i],
2842                                 sizeof (struct revocation_key));
2843                     }
2844
2845                   if (sig->timestamp >= sigdate)
2846                     { /* This is the latest signature so far.  */
2847
2848                       if (sig->flags.expired)
2849                         ; /* Signature has expired - ignore it.  */
2850                       else
2851                         {
2852                           sigdate = sig->timestamp;
2853                           signode = k;
2854                           if (sig->version > sigversion)
2855                             sigversion = sig->version;
2856
2857                         }
2858                     }
2859                 }
2860             }
2861         }
2862     }
2863
2864   /* Remove dupes from the revocation keys.  */
2865   if (pk->revkey)
2866     {
2867       int i, j, x, changed = 0;
2868
2869       for (i = 0; i < pk->numrevkeys; i++)
2870         {
2871           for (j = i + 1; j < pk->numrevkeys; j++)
2872             {
2873               if (memcmp (&pk->revkey[i], &pk->revkey[j],
2874                           sizeof (struct revocation_key)) == 0)
2875                 {
2876                   /* remove j */
2877
2878                   for (x = j; x < pk->numrevkeys - 1; x++)
2879                     pk->revkey[x] = pk->revkey[x + 1];
2880
2881                   pk->numrevkeys--;
2882                   j--;
2883                   changed = 1;
2884                 }
2885             }
2886         }
2887
2888       if (changed)
2889         pk->revkey = xrealloc (pk->revkey,
2890                                pk->numrevkeys *
2891                                sizeof (struct revocation_key));
2892     }
2893
2894   /* SIGNODE is the 1F signature packet with the latest creation time.
2895    * Extract some information from it.  */
2896   if (signode)
2897     {
2898       /* Some information from a direct key signature take precedence
2899        * over the same information given in UID sigs.  */
2900       PKT_signature *sig = signode->pkt->pkt.signature;
2901       const byte *p;
2902
2903       key_usage = parse_key_usage (sig);
2904
2905       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2906       if (p && buf32_to_u32 (p))
2907         {
2908           key_expire = keytimestamp + buf32_to_u32 (p);
2909           key_expire_seen = 1;
2910         }
2911
2912       /* Mark that key as valid: One direct key signature should
2913        * render a key as valid.  */
2914       pk->flags.valid = 1;
2915     }
2916
2917   /* Pass 1.5: Look for key revocation signatures that were not made
2918    * by the key (i.e. did a revocation key issue a revocation for
2919    * us?).  Only bother to do this if there is a revocation key in the
2920    * first place and we're not revoked already.  */
2921
2922   if (!*r_revoked && pk->revkey)
2923     for (k = keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next)
2924       {
2925         if (k->pkt->pkttype == PKT_SIGNATURE)
2926           {
2927             PKT_signature *sig = k->pkt->pkt.signature;
2928
2929             if (IS_KEY_REV (sig) &&
2930                 (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1]))
2931               {
2932                 int rc = check_revocation_keys (ctrl, pk, sig);
2933                 if (rc == 0)
2934                   {
2935                     *r_revoked = 2;
2936                     sig_to_revoke_info (sig, rinfo);
2937                     /* Don't continue checking since we can't be any
2938                      * more revoked than this.  */
2939                     break;
2940                   }
2941                 else if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2942                   pk->flags.maybe_revoked = 1;
2943
2944                 /* A failure here means the sig did not verify, was
2945                  * not issued by a revocation key, or a revocation
2946                  * key loop was broken.  If a revocation key isn't
2947                  * findable, however, the key might be revoked and
2948                  * we don't know it.  */
2949
2950                 /* Fixme: In the future handle subkey and cert
2951                  * revocations?  PGP doesn't, but it's in 2440.  */
2952               }
2953           }
2954       }
2955
2956   /* Second pass: Look at the self-signature of all user IDs.  */
2957
2958   /* According to RFC 4880 section 11.1, user id and attribute packets
2959    * are in the second section, after the public key packet and before
2960    * the subkey packets.  */
2961   signode = uidnode = NULL;
2962   sigdate = 0; /* Helper variable to find the latest signature in one UID. */
2963   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
2964     {
2965       if (k->pkt->pkttype == PKT_USER_ID || k->pkt->pkttype == PKT_ATTRIBUTE)
2966         { /* New user id packet.  */
2967
2968           /* Apply the data from the most recent self-signed packet to
2969            * the preceding user id packet.  */
2970           if (uidnode && signode)
2971             {
2972               fixup_uidnode (uidnode, signode, keytimestamp);
2973               pk->flags.valid = 1;
2974             }
2975
2976           /* Clear SIGNODE.  The only relevant self-signed data for
2977            * UIDNODE follows it.  */
2978           if (k->pkt->pkttype == PKT_USER_ID)
2979             uidnode = k;
2980           else
2981             uidnode = NULL;
2982
2983           signode = NULL;
2984           sigdate = 0;
2985         }
2986       else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
2987         {
2988           PKT_signature *sig = k->pkt->pkt.signature;
2989           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
2990             {
2991               if (check_key_signature (ctrl, keyblock, k, NULL))
2992                 ;               /* signature did not verify */
2993               else if ((IS_UID_SIG (sig) || IS_UID_REV (sig))
2994                        && sig->timestamp >= sigdate)
2995                 {
2996                   /* Note: we allow invalidation of cert revocations
2997                    * by a newer signature.  An attacker can't use this
2998                    * because a key should be revoked with a key revocation.
2999                    * The reason why we have to allow for that is that at
3000                    * one time an email address may become invalid but later
3001                    * the same email address may become valid again (hired,
3002                    * fired, hired again).  */
3003
3004                   sigdate = sig->timestamp;
3005                   signode = k;
3006                   signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
3007                   if (sig->version > sigversion)
3008                     sigversion = sig->version;
3009                 }
3010             }
3011         }
3012     }
3013   if (uidnode && signode)
3014     {
3015       fixup_uidnode (uidnode, signode, keytimestamp);
3016       pk->flags.valid = 1;
3017     }
3018
3019   /* If the key isn't valid yet, and we have
3020    * --allow-non-selfsigned-uid set, then force it valid. */
3021   if (!pk->flags.valid && opt.allow_non_selfsigned_uid)
3022     {
3023       if (opt.verbose)
3024         log_info (_("Invalid key %s made valid by"
3025                     " --allow-non-selfsigned-uid\n"), keystr_from_pk (pk));
3026       pk->flags.valid = 1;
3027     }
3028
3029   /* The key STILL isn't valid, so try and find an ultimately
3030    * trusted signature. */
3031   if (!pk->flags.valid)
3032     {
3033       uidnode = NULL;
3034
3035       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3036            k = k->next)
3037         {
3038           if (k->pkt->pkttype == PKT_USER_ID)
3039             uidnode = k;
3040           else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
3041             {
3042               PKT_signature *sig = k->pkt->pkt.signature;
3043
3044               if (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1])
3045                 {
3046                   PKT_public_key *ultimate_pk;
3047
3048                   ultimate_pk = xmalloc_clear (sizeof (*ultimate_pk));
3049
3050                   /* We don't want to use the full get_pubkey to avoid
3051                    * infinite recursion in certain cases.  There is no
3052                    * reason to check that an ultimately trusted key is
3053                    * still valid - if it has been revoked the user
3054                    * should also remove the ultimate trust flag.  */
3055                   if (get_pubkey_fast (ultimate_pk, sig->keyid) == 0
3056                       && check_key_signature2 (ctrl,
3057                                                keyblock, k, ultimate_pk,
3058                                                NULL, NULL, NULL, NULL) == 0
3059                       && get_ownertrust (ctrl, ultimate_pk) == TRUST_ULTIMATE)
3060                     {
3061                       free_public_key (ultimate_pk);
3062                       pk->flags.valid = 1;
3063                       break;
3064                     }
3065
3066                   free_public_key (ultimate_pk);
3067                 }
3068             }
3069         }
3070     }
3071
3072   /* Record the highest selfsig version so we know if this is a v3 key
3073    * through and through, or a v3 key with a v4 selfsig somewhere.
3074    * This is useful in a few places to know if the key must be treated
3075    * as PGP2-style or OpenPGP-style.  Note that a selfsig revocation
3076    * with a higher version number will also raise this value.  This is
3077    * okay since such a revocation must be issued by the user (i.e. it
3078    * cannot be issued by someone else to modify the key behavior.) */
3079
3080   pk->selfsigversion = sigversion;
3081
3082   /* Now that we had a look at all user IDs we can now get some
3083    * information from those user IDs.  */
3084
3085   if (!key_usage)
3086     {
3087       /* Find the latest user ID with key flags set. */
3088       uiddate = 0; /* Helper to find the latest user ID.  */
3089       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3090            k = k->next)
3091         {
3092           if (k->pkt->pkttype == PKT_USER_ID)
3093             {
3094               PKT_user_id *uid = k->pkt->pkt.user_id;
3095
3096               if (uid->help_key_usage && uid->created > uiddate)
3097                 {
3098                   key_usage = uid->help_key_usage;
3099                   uiddate = uid->created;
3100                 }
3101             }
3102         }
3103     }
3104
3105   if (!key_usage)
3106     {
3107       /* No key flags at all: get it from the algo.  */
3108       key_usage = openpgp_pk_algo_usage (pk->pubkey_algo);
3109     }
3110   else
3111     {
3112       /* Check that the usage matches the usage as given by the algo.  */
3113       int x = openpgp_pk_algo_usage (pk->pubkey_algo);
3114       if (x) /* Mask it down to the actual allowed usage.  */
3115         key_usage &= x;
3116     }
3117
3118   /* Whatever happens, it's a primary key, so it can certify. */
3119   pk->pubkey_usage = key_usage | PUBKEY_USAGE_CERT;
3120
3121   if (!key_expire_seen)
3122     {
3123       /* Find the latest valid user ID with a key expiration set
3124        * Note, that this may be a different one from the above because
3125        * some user IDs may have no expiration date set.  */
3126       uiddate = 0;
3127       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3128            k = k->next)
3129         {
3130           if (k->pkt->pkttype == PKT_USER_ID)
3131             {
3132               PKT_user_id *uid = k->pkt->pkt.user_id;
3133               if (uid->help_key_expire && uid->created > uiddate)
3134                 {
3135                   key_expire = uid->help_key_expire;
3136                   uiddate = uid->created;
3137                 }
3138             }
3139         }
3140     }
3141
3142   /* Currently only v3 keys have a maximum expiration date, but I'll
3143    * bet v5 keys get this feature again. */
3144   if (key_expire == 0
3145       || (pk->max_expiredate && key_expire > pk->max_expiredate))
3146     key_expire = pk->max_expiredate;
3147
3148   pk->has_expired = key_expire >= curtime ? 0 : key_expire;
3149   pk->expiredate = key_expire;
3150
3151   /* Fixme: we should see how to get rid of the expiretime fields but
3152    * this needs changes at other places too.  */
3153
3154   /* And now find the real primary user ID and delete all others.  */
3155   uiddate = uiddate2 = 0;
3156   uidnode = uidnode2 = NULL;
3157   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
3158     {
3159       if (k->pkt->pkttype == PKT_USER_ID && !k->pkt->pkt.user_id->attrib_data)
3160         {
3161           PKT_user_id *uid = k->pkt->pkt.user_id;
3162           if (uid->flags.primary)
3163             {
3164               if (uid->created > uiddate)
3165                 {
3166                   uiddate = uid->created;
3167                   uidnode = k;
3168                 }
3169               else if (uid->created == uiddate && uidnode)
3170                 {
3171                   /* The dates are equal, so we need to do a different
3172                    * (and arbitrary) comparison.  This should rarely,
3173                    * if ever, happen.  It's good to try and guarantee
3174                    * that two different GnuPG users with two different
3175                    * keyrings at least pick the same primary.  */
3176                   if (cmp_user_ids (uid, uidnode->pkt->pkt.user_id) > 0)
3177                     uidnode = k;
3178                 }
3179             }
3180           else
3181             {
3182               if (uid->created > uiddate2)
3183                 {
3184                   uiddate2 = uid->created;
3185                   uidnode2 = k;
3186                 }
3187               else if (uid->created == uiddate2 && uidnode2)
3188                 {
3189                   if (cmp_user_ids (uid, uidnode2->pkt->pkt.user_id) > 0)
3190                     uidnode2 = k;
3191                 }
3192             }
3193         }
3194     }
3195   if (uidnode)
3196     {
3197       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3198            k = k->next)
3199         {
3200           if (k->pkt->pkttype == PKT_USER_ID &&
3201               !k->pkt->pkt.user_id->attrib_data)
3202             {
3203               PKT_user_id *uid = k->pkt->pkt.user_id;
3204               if (k != uidnode)
3205                 uid->flags.primary = 0;
3206             }
3207         }
3208     }
3209   else if (uidnode2)
3210     {
3211       /* None is flagged primary - use the latest user ID we have,
3212        * and disambiguate with the arbitrary packet comparison. */
3213       uidnode2->pkt->pkt.user_id->flags.primary = 1;
3214     }
3215   else
3216     {
3217       /* None of our uids were self-signed, so pick the one that
3218        * sorts first to be the primary.  This is the best we can do
3219        * here since there are no self sigs to date the uids. */
3220
3221       uidnode = NULL;
3222
3223       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3224            k = k->next)
3225         {
3226           if (k->pkt->pkttype == PKT_USER_ID
3227               && !k->pkt->pkt.user_id->attrib_data)
3228             {
3229               if (!uidnode)
3230                 {
3231                   uidnode = k;
3232                   uidnode->pkt->pkt.user_id->flags.primary = 1;
3233                   continue;
3234                 }
3235               else
3236                 {
3237                   if (cmp_user_ids (k->pkt->pkt.user_id,
3238                                     uidnode->pkt->pkt.user_id) > 0)
3239                     {
3240                       uidnode->pkt->pkt.user_id->flags.primary = 0;
3241                       uidnode = k;
3242                       uidnode->pkt->pkt.user_id->flags.primary = 1;
3243                     }
3244                   else
3245                     {
3246                       /* just to be safe: */
3247                       k->pkt->pkt.user_id->flags.primary = 0;
3248                     }
3249                 }
3250             }
3251         }
3252     }
3253 }
3254
3255
3256 /* Convert a buffer to a signature.  Useful for 0x19 embedded sigs.
3257  * Caller must free the signature when they are done. */
3258 static PKT_signature *
3259 buf_to_sig (const byte * buf, size_t len)
3260 {
3261   PKT_signature *sig = xmalloc_clear (sizeof (PKT_signature));
3262   IOBUF iobuf = iobuf_temp_with_content (buf, len);
3263   int save_mode = set_packet_list_mode (0);
3264
3265   if (parse_signature (iobuf, PKT_SIGNATURE, len, sig) != 0)
3266     {
3267       free_seckey_enc (sig);
3268       sig = NULL;
3269     }
3270
3271   set_packet_list_mode (save_mode);
3272   iobuf_close (iobuf);
3273
3274   return sig;
3275 }
3276
3277
3278 /* Use the self-signed data to fill in various fields in subkeys.
3279  *
3280  * KEYBLOCK is the whole keyblock.  SUBNODE is the subkey to fill in.
3281  *
3282  * Sets the following fields on the subkey:
3283  *
3284  *   main_keyid
3285  *   flags.valid        if the subkey has a valid self-sig binding
3286  *   flags.revoked
3287  *   flags.backsig
3288  *   pubkey_usage
3289  *   has_expired
3290  *   expired_date
3291  *
3292  * On this subkey's most revent valid self-signed packet, the
3293  * following field is set:
3294  *
3295  *   flags.chosen_selfsig
3296  */
3297 static void
3298 merge_selfsigs_subkey (ctrl_t ctrl, kbnode_t keyblock, kbnode_t subnode)
3299 {
3300   PKT_public_key *mainpk = NULL, *subpk = NULL;
3301   PKT_signature *sig;
3302   KBNODE k;
3303   u32 mainkid[2];
3304   u32 sigdate = 0;
3305   KBNODE signode;
3306   u32 curtime = make_timestamp ();
3307   unsigned int key_usage = 0;
3308   u32 keytimestamp = 0;
3309   u32 key_expire = 0;
3310   const byte *p;
3311
3312   if (subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3313     BUG ();
3314   mainpk = keyblock->pkt->pkt.public_key;
3315   if (mainpk->version < 4)
3316     return;/* (actually this should never happen) */
3317   keyid_from_pk (mainpk, mainkid);
3318   subpk = subnode->pkt->pkt.public_key;
3319   keytimestamp = subpk->timestamp;
3320
3321   subpk->flags.valid = 0;
3322   subpk->flags.exact = 0;
3323   subpk->main_keyid[0] = mainpk->main_keyid[0];
3324   subpk->main_keyid[1] = mainpk->main_keyid[1];
3325
3326   /* Find the latest key binding self-signature.  */
3327   signode = NULL;
3328   sigdate = 0; /* Helper to find the latest signature.  */
3329   for (k = subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3330        k = k->next)
3331     {
3332       if (k->pkt->pkttype == PKT_SIGNATURE)
3333         {
3334           sig = k->pkt->pkt.signature;
3335           if (sig->keyid[0] == mainkid[0] && sig->keyid[1] == mainkid[1])
3336             {
3337               if (check_key_signature (ctrl, keyblock, k, NULL))
3338                 ; /* Signature did not verify.  */
3339               else if (IS_SUBKEY_REV (sig))
3340                 {
3341                   /* Note that this means that the date on a
3342                    * revocation sig does not matter - even if the
3343                    * binding sig is dated after the revocation sig,
3344                    * the subkey is still marked as revoked.  This
3345                    * seems ok, as it is just as easy to make new
3346                    * subkeys rather than re-sign old ones as the
3347                    * problem is in the distribution.  Plus, PGP (7)
3348                    * does this the same way.  */
3349                   subpk->flags.revoked = 1;
3350                   sig_to_revoke_info (sig, &subpk->revoked);
3351                   /* Although we could stop now, we continue to
3352                    * figure out other information like the old expiration
3353                    * time.  */
3354                 }
3355               else if (IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate)
3356                 {
3357                   if (sig->flags.expired)
3358                     ; /* Signature has expired - ignore it.  */
3359                   else
3360                     {
3361                       sigdate = sig->timestamp;
3362                       signode = k;
3363                       signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
3364                     }
3365                 }
3366             }
3367         }
3368     }
3369
3370   /* No valid key binding.  */
3371   if (!signode)
3372     return;
3373
3374   sig = signode->pkt->pkt.signature;
3375   sig->flags.chosen_selfsig = 1; /* So we know which selfsig we chose later.  */
3376
3377   key_usage = parse_key_usage (sig);
3378   if (!key_usage)
3379     {
3380       /* No key flags at all: get it from the algo.  */
3381       key_usage = openpgp_pk_algo_usage (subpk->pubkey_algo);
3382     }
3383   else
3384     {
3385       /* Check that the usage matches the usage as given by the algo.  */
3386       int x = openpgp_pk_algo_usage (subpk->pubkey_algo);
3387       if (x) /* Mask it down to the actual allowed usage.  */
3388         key_usage &= x;
3389     }
3390
3391   subpk->pubkey_usage = key_usage;
3392
3393   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
3394   if (p && buf32_to_u32 (p))
3395     key_expire = keytimestamp + buf32_to_u32 (p);
3396   else
3397     key_expire = 0;
3398
3399   subpk->has_expired = key_expire >= curtime ? 0 : key_expire;
3400   subpk->expiredate = key_expire;
3401
3402   /* Algo doesn't exist.  */
3403   if (openpgp_pk_test_algo (subpk->pubkey_algo))
3404     return;
3405
3406   subpk->flags.valid = 1;
3407
3408   /* Find the most recent 0x19 embedded signature on our self-sig. */
3409   if (!subpk->flags.backsig)
3410     {
3411       int seq = 0;
3412       size_t n;
3413       PKT_signature *backsig = NULL;
3414
3415       sigdate = 0;
3416
3417       /* We do this while() since there may be other embedded
3418        * signatures in the future.  We only want 0x19 here. */
3419
3420       while ((p = enum_sig_subpkt (sig->hashed,
3421                                    SIGSUBPKT_SIGNATURE, &n, &seq, NULL)))
3422         if (n > 3
3423             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
3424           {
3425             PKT_signature *tempsig = buf_to_sig (p, n);
3426             if (tempsig)
3427               {
3428                 if (tempsig->timestamp > sigdate)
3429                   {
3430                     if (backsig)
3431                       free_seckey_enc (backsig);
3432
3433                     backsig = tempsig;
3434                     sigdate = backsig->timestamp;
3435                   }
3436                 else
3437                   free_seckey_enc (tempsig);
3438               }
3439           }
3440
3441       seq = 0;
3442
3443       /* It is safe to have this in the unhashed area since the 0x19
3444        * is located on the selfsig for convenience, not security. */
3445
3446       while ((p = enum_sig_subpkt (sig->unhashed, SIGSUBPKT_SIGNATURE,
3447                                    &n, &seq, NULL)))
3448         if (n > 3
3449             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
3450           {
3451             PKT_signature *tempsig = buf_to_sig (p, n);
3452             if (tempsig)
3453               {
3454                 if (tempsig->timestamp > sigdate)
3455                   {
3456                     if (backsig)
3457                       free_seckey_enc (backsig);
3458
3459                     backsig = tempsig;
3460                     sigdate = backsig->timestamp;
3461                   }
3462                 else
3463                   free_seckey_enc (tempsig);
3464               }
3465           }
3466
3467       if (backsig)
3468         {
3469           /* At this point, backsig contains the most recent 0x19 sig.
3470            * Let's see if it is good. */
3471
3472           /* 2==valid, 1==invalid, 0==didn't check */
3473           if (check_backsig (mainpk, subpk, backsig) == 0)
3474             subpk->flags.backsig = 2;
3475           else
3476             subpk->flags.backsig = 1;
3477
3478           free_seckey_enc (backsig);
3479         }
3480     }
3481 }
3482
3483
3484 /* Merge information from the self-signatures with the public key,
3485  * subkeys and user ids to make using them more easy.
3486  *
3487  * See documentation for merge_selfsigs_main, merge_selfsigs_subkey
3488  * and fixup_uidnode for exactly which fields are updated.  */
3489 static void
3490 merge_selfsigs (ctrl_t ctrl, kbnode_t keyblock)
3491 {
3492   KBNODE k;
3493   int revoked;
3494   struct revoke_info rinfo;
3495   PKT_public_key *main_pk;
3496   prefitem_t *prefs;
3497   unsigned int mdc_feature;
3498   unsigned int aead_feature;
3499
3500   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
3501     {
3502       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
3503         {
3504           log_error ("expected public key but found secret key "
3505                      "- must stop\n");
3506           /* We better exit here because a public key is expected at
3507            * other places too.  FIXME: Figure this out earlier and
3508            * don't get to here at all */
3509           g10_exit (1);
3510         }
3511       BUG ();
3512     }
3513
3514   merge_selfsigs_main (ctrl, keyblock, &revoked, &rinfo);
3515
3516   /* Now merge in the data from each of the subkeys.  */
3517   for (k = keyblock; k; k = k->next)
3518     {
3519       if (k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3520         {
3521           merge_selfsigs_subkey (ctrl, keyblock, k);
3522         }
3523     }
3524
3525   main_pk = keyblock->pkt->pkt.public_key;
3526   if (revoked || main_pk->has_expired || !main_pk->flags.valid)
3527     {
3528       /* If the primary key is revoked, expired, or invalid we
3529        * better set the appropriate flags on that key and all
3530        * subkeys.  */
3531       for (k = keyblock; k; k = k->next)
3532         {
3533           if (k->pkt->pkttype == PKT_PUBLIC_KEY
3534               || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3535             {
3536               PKT_public_key *pk = k->pkt->pkt.public_key;
3537               if (!main_pk->flags.valid)
3538                 pk->flags.valid = 0;
3539               if (revoked && !pk->flags.revoked)
3540                 {
3541                   pk->flags.revoked = revoked;
3542                   memcpy (&pk->revoked, &rinfo, sizeof (rinfo));
3543                 }
3544               if (main_pk->has_expired)
3545                 pk->has_expired = main_pk->has_expired;
3546             }
3547         }
3548       return;
3549     }
3550
3551   /* Set the preference list of all keys to those of the primary real
3552    * user ID.  Note: we use these preferences when we don't know by
3553    * which user ID the key has been selected.
3554    * fixme: we should keep atoms of commonly used preferences or
3555    * use reference counting to optimize the preference lists storage.
3556    * FIXME: it might be better to use the intersection of
3557    * all preferences.
3558    * Do a similar thing for the MDC feature flag.  */
3559   prefs = NULL;
3560   mdc_feature = aead_feature = 0;
3561   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
3562     {
3563       if (k->pkt->pkttype == PKT_USER_ID
3564           && !k->pkt->pkt.user_id->attrib_data
3565           && k->pkt->pkt.user_id->flags.primary)
3566         {
3567           prefs = k->pkt->pkt.user_id->prefs;
3568           mdc_feature = k->pkt->pkt.user_id->flags.mdc;
3569           aead_feature = k->pkt->pkt.user_id->flags.aead;
3570           break;
3571         }
3572     }
3573   for (k = keyblock; k; k = k->next)
3574     {
3575       if (k->pkt->pkttype == PKT_PUBLIC_KEY
3576           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3577         {
3578           PKT_public_key *pk = k->pkt->pkt.public_key;
3579           if (pk->prefs)
3580