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