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