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