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