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