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