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