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