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