gpg: Fix typo.
[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 re-enable 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 specification 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                       if (retctx)
1658                         *retctx = NULL;
1659                       rc = gpg_error_from_syserror ();
1660                     }
1661                   else
1662                     {
1663                       u32 *keyid = pk_keyid (&best.key);
1664                       ctx->exact = 1;
1665                       ctx->nitems = 1;
1666                       ctx->items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
1667                       ctx->items[0].u.kid[0] = keyid[0];
1668                       ctx->items[0].u.kid[1] = keyid[1];
1669
1670                       if (ret_keyblock)
1671                         {
1672                           release_kbnode (*ret_keyblock);
1673                           *ret_keyblock = NULL;
1674                           rc = getkey_next (ctrl, ctx, NULL, ret_keyblock);
1675                         }
1676                     }
1677                 }
1678             }
1679
1680           if (pk)
1681             *pk = best.key;
1682           else
1683             release_public_key_parts (&best.key);
1684         }
1685     }
1686
1687   if (rc && ctx)
1688     {
1689       getkey_end (ctrl, ctx);
1690       ctx = NULL;
1691     }
1692
1693   if (retctx && ctx)
1694     *retctx = ctx;
1695   else
1696     getkey_end (ctrl, ctx);
1697
1698   return rc;
1699 }
1700
1701 \f
1702
1703 /* Get a public key from a file.
1704  *
1705  * PK is the buffer to store the key.  The caller needs to make sure
1706  * that PK->REQ_USAGE is valid.  PK->REQ_USAGE is passed through to
1707  * the lookup function and is a mask of PUBKEY_USAGE_SIG,
1708  * PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  If this is non-zero, only
1709  * keys with the specified usage will be returned.
1710  *
1711  * FNAME is the file name.  That file should contain exactly one
1712  * keyblock.
1713  *
1714  * This function returns 0 on success.  Otherwise, an error code is
1715  * returned.  In particular, GPG_ERR_NO_PUBKEY is returned if the key
1716  * is not found.
1717  *
1718  * The self-signed data has already been merged into the public key
1719  * using merge_selfsigs.  The caller must release the content of PK by
1720  * calling release_public_key_parts (or, if PK was malloced, using
1721  * free_public_key).
1722  */
1723 gpg_error_t
1724 get_pubkey_fromfile (ctrl_t ctrl, PKT_public_key *pk, const char *fname)
1725 {
1726   gpg_error_t err;
1727   kbnode_t keyblock;
1728   kbnode_t found_key;
1729   unsigned int infoflags;
1730
1731   err = read_key_from_file (ctrl, fname, &keyblock);
1732   if (!err)
1733     {
1734       /* Warning: node flag bits 0 and 1 should be preserved by
1735        * merge_selfsigs.  FIXME: Check whether this still holds. */
1736       merge_selfsigs (ctrl, keyblock);
1737       found_key = finish_lookup (keyblock, pk->req_usage, 0, &infoflags);
1738       print_status_key_considered (keyblock, infoflags);
1739       if (found_key)
1740         pk_from_block (pk, keyblock, found_key);
1741       else
1742         err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1743     }
1744
1745   release_kbnode (keyblock);
1746   return err;
1747 }
1748
1749
1750 /* Lookup a key with the specified fingerprint.
1751  *
1752  * If PK is not NULL, the public key of the first result is returned
1753  * in *PK.  Note: this function does an exact search and thus the
1754  * returned public key may be a subkey rather than the primary key.
1755  * Note: The self-signed data has already been merged into the public
1756  * key using merge_selfsigs.  Free *PK by calling
1757  * release_public_key_parts (or, if PK was allocated using xfree, you
1758  * can use free_public_key, which calls release_public_key_parts(PK)
1759  * and then xfree(PK)).
1760  *
1761  * If PK->REQ_USAGE is set, it is used to filter the search results.
1762  * (Thus, if PK is not NULL, PK->REQ_USAGE must be valid!!!)  See the
1763  * documentation for finish_lookup to understand exactly how this is
1764  * used.
1765  *
1766  * If R_KEYBLOCK is not NULL, then the first result's keyblock is
1767  * returned in *R_KEYBLOCK.  This should be freed using
1768  * release_kbnode().
1769  *
1770  * FPRINT is a byte array whose contents is the fingerprint to use as
1771  * the search term.  FPRINT_LEN specifies the length of the
1772  * fingerprint (in bytes).  Currently, only 16 and 20-byte
1773  * fingerprints are supported.
1774  *
1775  * FIXME: We should replace this with the _byname function.  This can
1776  * be done by creating a userID conforming to the unified fingerprint
1777  * style.  */
1778 int
1779 get_pubkey_byfprint (ctrl_t ctrl, PKT_public_key *pk, kbnode_t *r_keyblock,
1780                      const byte * fprint, size_t fprint_len)
1781 {
1782   int rc;
1783
1784   if (r_keyblock)
1785     *r_keyblock = NULL;
1786
1787   if (fprint_len == 20 || fprint_len == 16)
1788     {
1789       struct getkey_ctx_s ctx;
1790       KBNODE kb = NULL;
1791       KBNODE found_key = NULL;
1792
1793       memset (&ctx, 0, sizeof ctx);
1794       ctx.exact = 1;
1795       ctx.not_allocated = 1;
1796       ctx.kr_handle = keydb_new ();
1797       if (!ctx.kr_handle)
1798         return gpg_error_from_syserror ();
1799
1800       ctx.nitems = 1;
1801       ctx.items[0].mode = fprint_len == 16 ? KEYDB_SEARCH_MODE_FPR16
1802         : KEYDB_SEARCH_MODE_FPR20;
1803       memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1804       rc = lookup (ctrl, &ctx, 0, &kb, &found_key);
1805       if (!rc && pk)
1806         pk_from_block (pk, kb, found_key);
1807       if (!rc && r_keyblock)
1808         {
1809           *r_keyblock = kb;
1810           kb = NULL;
1811         }
1812       release_kbnode (kb);
1813       getkey_end (ctrl, &ctx);
1814     }
1815   else
1816     rc = GPG_ERR_GENERAL; /* Oops */
1817   return rc;
1818 }
1819
1820
1821 /* This function is similar to get_pubkey_byfprint, but it doesn't
1822  * merge the self-signed data into the public key and subkeys or into
1823  * the user ids.  It also doesn't add the key to the user id cache.
1824  * Further, this function ignores PK->REQ_USAGE.
1825  *
1826  * This function is intended to avoid recursion and, as such, should
1827  * only be used in very specific situations.
1828  *
1829  * Like get_pubkey_byfprint, PK may be NULL.  In that case, this
1830  * function effectively just checks for the existence of the key.  */
1831 int
1832 get_pubkey_byfprint_fast (PKT_public_key * pk,
1833                           const byte * fprint, size_t fprint_len)
1834 {
1835   int rc = 0;
1836   KEYDB_HANDLE hd;
1837   KBNODE keyblock;
1838   byte fprbuf[MAX_FINGERPRINT_LEN];
1839   int i;
1840
1841   for (i = 0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
1842     fprbuf[i] = fprint[i];
1843   while (i < MAX_FINGERPRINT_LEN)
1844     fprbuf[i++] = 0;
1845
1846   hd = keydb_new ();
1847   if (!hd)
1848     return gpg_error_from_syserror ();
1849
1850   rc = keydb_search_fpr (hd, fprbuf);
1851   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1852     {
1853       keydb_release (hd);
1854       return GPG_ERR_NO_PUBKEY;
1855     }
1856   rc = keydb_get_keyblock (hd, &keyblock);
1857   keydb_release (hd);
1858   if (rc)
1859     {
1860       log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
1861       return GPG_ERR_NO_PUBKEY;
1862     }
1863
1864   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
1865               || keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1866   if (pk)
1867     copy_public_key (pk, keyblock->pkt->pkt.public_key);
1868   release_kbnode (keyblock);
1869
1870   /* Not caching key here since it won't have all of the fields
1871      properly set. */
1872
1873   return 0;
1874 }
1875
1876 const char *
1877 parse_def_secret_key (ctrl_t ctrl)
1878 {
1879   KEYDB_HANDLE hd = NULL;
1880   strlist_t t;
1881   static int warned;
1882
1883   for (t = opt.def_secret_key; t; t = t->next)
1884     {
1885       gpg_error_t err;
1886       KEYDB_SEARCH_DESC desc;
1887       KBNODE kb;
1888       KBNODE node;
1889
1890       err = classify_user_id (t->d, &desc, 1);
1891       if (err)
1892         {
1893           log_error (_("secret key \"%s\" not found: %s\n"),
1894                      t->d, gpg_strerror (err));
1895           if (!opt.quiet)
1896             log_info (_("(check argument of option '%s')\n"), "--default-key");
1897           continue;
1898         }
1899
1900       if (! hd)
1901         {
1902           hd = keydb_new ();
1903           if (!hd)
1904             return NULL;
1905         }
1906       else
1907         keydb_search_reset (hd);
1908
1909
1910       err = keydb_search (hd, &desc, 1, NULL);
1911       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1912         continue;
1913
1914       if (err)
1915         {
1916           log_error (_("key \"%s\" not found: %s\n"), t->d, gpg_strerror (err));
1917           t = NULL;
1918           break;
1919         }
1920
1921       err = keydb_get_keyblock (hd, &kb);
1922       if (err)
1923         {
1924           log_error (_("error reading keyblock: %s\n"),
1925                      gpg_strerror (err));
1926           continue;
1927         }
1928
1929       merge_selfsigs (ctrl, kb);
1930
1931       err = gpg_error (GPG_ERR_NO_SECKEY);
1932       node = kb;
1933       do
1934         {
1935           PKT_public_key *pk = node->pkt->pkt.public_key;
1936
1937           /* Check that the key has the signing capability.  */
1938           if (! (pk->pubkey_usage & PUBKEY_USAGE_SIG))
1939             continue;
1940
1941           /* Check if the key is valid.  */
1942           if (pk->flags.revoked)
1943             {
1944               if (DBG_LOOKUP)
1945                 log_debug ("not using %s as default key, %s",
1946                            keystr_from_pk (pk), "revoked");
1947               continue;
1948             }
1949           if (pk->has_expired)
1950             {
1951               if (DBG_LOOKUP)
1952                 log_debug ("not using %s as default key, %s",
1953                            keystr_from_pk (pk), "expired");
1954               continue;
1955             }
1956           if (pk_is_disabled (pk))
1957             {
1958               if (DBG_LOOKUP)
1959                 log_debug ("not using %s as default key, %s",
1960                            keystr_from_pk (pk), "disabled");
1961               continue;
1962             }
1963
1964           err = agent_probe_secret_key (ctrl, pk);
1965           if (! err)
1966             /* This is a valid key.  */
1967             break;
1968         }
1969       while ((node = find_next_kbnode (node, PKT_PUBLIC_SUBKEY)));
1970
1971       release_kbnode (kb);
1972       if (err)
1973         {
1974           if (! warned && ! opt.quiet)
1975             {
1976               log_info (_("Warning: not using '%s' as default key: %s\n"),
1977                         t->d, gpg_strerror (GPG_ERR_NO_SECKEY));
1978               print_reported_error (err, GPG_ERR_NO_SECKEY);
1979             }
1980         }
1981       else
1982         {
1983           if (! warned && ! opt.quiet)
1984             log_info (_("using \"%s\" as default secret key for signing\n"),
1985                       t->d);
1986           break;
1987         }
1988     }
1989
1990   if (! warned && opt.def_secret_key && ! t)
1991     log_info (_("all values passed to '%s' ignored\n"),
1992               "--default-key");
1993
1994   warned = 1;
1995
1996   if (hd)
1997     keydb_release (hd);
1998
1999   if (t)
2000     return t->d;
2001   return NULL;
2002 }
2003
2004
2005 /* Look up a secret key.
2006  *
2007  * If PK is not NULL, the public key of the first result is returned
2008  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2009  * set, it is used to filter the search results.  See the
2010  * documentation for finish_lookup to understand exactly how this is
2011  * used.  Note: The self-signed data has already been merged into the
2012  * public key using merge_selfsigs.  Free *PK by calling
2013  * release_public_key_parts (or, if PK was allocated using xfree, you
2014  * can use free_public_key, which calls release_public_key_parts(PK)
2015  * and then xfree(PK)).
2016  *
2017  * If --default-key was set, then the specified key is looked up.  (In
2018  * this case, the default key is returned even if it is considered
2019  * unusable.  See the documentation for skip_unusable for exactly what
2020  * this means.)
2021  *
2022  * Otherwise, this initiates a DB scan that returns all keys that are
2023  * usable (see previous paragraph for exactly what usable means) and
2024  * for which a secret key is available.
2025  *
2026  * This function returns the first match.  Additional results can be
2027  * returned using getkey_next.  */
2028 gpg_error_t
2029 get_seckey_default (ctrl_t ctrl, PKT_public_key *pk)
2030 {
2031   gpg_error_t err;
2032   strlist_t namelist = NULL;
2033   int include_unusable = 1;
2034
2035
2036   const char *def_secret_key = parse_def_secret_key (ctrl);
2037   if (def_secret_key)
2038     add_to_strlist (&namelist, def_secret_key);
2039   else
2040     include_unusable = 0;
2041
2042   err = key_byname (ctrl, NULL, namelist, pk, 1, include_unusable, NULL, NULL);
2043
2044   free_strlist (namelist);
2045
2046   return err;
2047 }
2048
2049
2050 \f
2051 /* Search for keys matching some criteria.
2052  *
2053  * If RETCTX is not NULL, then the constructed context is returned in
2054  * *RETCTX so that getpubkey_next can be used to get subsequent
2055  * results.  In this case, getkey_end() must be used to free the
2056  * search context.  If RETCTX is not NULL, then RET_KDBHD must be
2057  * NULL.
2058  *
2059  * If PK is not NULL, the public key of the first result is returned
2060  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2061  * set, it is used to filter the search results.  See the
2062  * documentation for finish_lookup to understand exactly how this is
2063  * used.  Note: The self-signed data has already been merged into the
2064  * public key using merge_selfsigs.  Free *PK by calling
2065  * release_public_key_parts (or, if PK was allocated using xfree, you
2066  * can use free_public_key, which calls release_public_key_parts(PK)
2067  * and then xfree(PK)).
2068  *
2069  * If NAMES is not NULL, then a search query is constructed using
2070  * classify_user_id on each of the strings in the list.  (Recall: the
2071  * database does an OR of the terms, not an AND.)  If NAMES is
2072  * NULL, then all results are returned.
2073  *
2074  * If WANT_SECRET is set, then only keys with an available secret key
2075  * (either locally or via key registered on a smartcard) are returned.
2076  *
2077  * This function does not skip unusable keys (see the documentation
2078  * for skip_unusable for an exact definition).
2079  *
2080  * If RET_KEYBLOCK is not NULL, the keyblock is returned in
2081  * *RET_KEYBLOCK.  This should be freed using release_kbnode().
2082  *
2083  * This function returns 0 on success.  Otherwise, an error code is
2084  * returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
2085  * (if want_secret is set) is returned if the key is not found.  */
2086 gpg_error_t
2087 getkey_bynames (ctrl_t ctrl, getkey_ctx_t *retctx, PKT_public_key *pk,
2088                 strlist_t names, int want_secret, kbnode_t *ret_keyblock)
2089 {
2090   return key_byname (ctrl, retctx, names, pk, want_secret, 1,
2091                      ret_keyblock, NULL);
2092 }
2093
2094
2095 /* Search for one key matching some criteria.
2096  *
2097  * If RETCTX is not NULL, then the constructed context is returned in
2098  * *RETCTX so that getpubkey_next can be used to get subsequent
2099  * results.  In this case, getkey_end() must be used to free the
2100  * search context.  If RETCTX is not NULL, then RET_KDBHD must be
2101  * NULL.
2102  *
2103  * If PK is not NULL, the public key of the first result is returned
2104  * in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
2105  * set, it is used to filter the search results.  See the
2106  * documentation for finish_lookup to understand exactly how this is
2107  * used.  Note: The self-signed data has already been merged into the
2108  * public key using merge_selfsigs.  Free *PK by calling
2109  * release_public_key_parts (or, if PK was allocated using xfree, you
2110  * can use free_public_key, which calls release_public_key_parts(PK)
2111  * and then xfree(PK)).
2112  *
2113  * If NAME is not NULL, then a search query is constructed using
2114  * classify_user_id on the string.  In this case, even unusable keys
2115  * (see the documentation for skip_unusable for an exact definition of
2116  * unusable) are returned.  Otherwise, if --default-key was set, then
2117  * that key is returned (even if it is unusable).  If neither of these
2118  * conditions holds, then the first usable key is returned.
2119  *
2120  * If WANT_SECRET is set, then only keys with an available secret key
2121  * (either locally or via key registered on a smartcard) are returned.
2122  *
2123  * This function does not skip unusable keys (see the documentation
2124  * for skip_unusable for an exact definition).
2125  *
2126  * If RET_KEYBLOCK is not NULL, the keyblock is returned in
2127  * *RET_KEYBLOCK.  This should be freed using release_kbnode().
2128  *
2129  * This function returns 0 on success.  Otherwise, an error code is
2130  * returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
2131  * (if want_secret is set) is returned if the key is not found.
2132  *
2133  * FIXME: We also have the get_pubkey_byname function which has a
2134  * different semantic.  Should be merged with this one.  */
2135 gpg_error_t
2136 getkey_byname (ctrl_t ctrl, getkey_ctx_t *retctx, PKT_public_key *pk,
2137                const char *name, int want_secret, kbnode_t *ret_keyblock)
2138 {
2139   gpg_error_t err;
2140   strlist_t namelist = NULL;
2141   int with_unusable = 1;
2142   const char *def_secret_key = NULL;
2143
2144   if (want_secret && !name)
2145     def_secret_key = parse_def_secret_key (ctrl);
2146
2147   if (want_secret && !name && def_secret_key)
2148     add_to_strlist (&namelist, def_secret_key);
2149   else if (name)
2150     add_to_strlist (&namelist, name);
2151   else
2152     with_unusable = 0;
2153
2154   err = key_byname (ctrl, retctx, namelist, pk, want_secret, with_unusable,
2155                     ret_keyblock, NULL);
2156
2157   /* FIXME: Check that we really return GPG_ERR_NO_SECKEY if
2158      WANT_SECRET has been used.  */
2159
2160   free_strlist (namelist);
2161
2162   return err;
2163 }
2164
2165
2166 /* Return the next search result.
2167  *
2168  * If PK is not NULL, the public key of the next result is returned in
2169  * *PK.  Note: The self-signed data has already been merged into the
2170  * public key using merge_selfsigs.  Free *PK by calling
2171  * release_public_key_parts (or, if PK was allocated using xmalloc, you
2172  * can use free_public_key, which calls release_public_key_parts(PK)
2173  * and then xfree(PK)).
2174  *
2175  * RET_KEYBLOCK can be given as NULL; if it is not NULL it the entire
2176  * found keyblock is returned which must be released with
2177  * release_kbnode.  If the function returns an error NULL is stored at
2178  * RET_KEYBLOCK.
2179  *
2180  * The self-signed data has already been merged into the public key
2181  * using merge_selfsigs.  */
2182 gpg_error_t
2183 getkey_next (ctrl_t ctrl, getkey_ctx_t ctx,
2184              PKT_public_key *pk, kbnode_t *ret_keyblock)
2185 {
2186   int rc; /* Fixme:  Make sure this is proper gpg_error */
2187   KBNODE keyblock = NULL;
2188   KBNODE found_key = NULL;
2189
2190   /* We need to disable the caching so that for an exact key search we
2191      won't get the result back from the cache and thus end up in an
2192      endless loop.  The endless loop can occur, because the cache is
2193      used without respecting the current file pointer!  */
2194   keydb_disable_caching (ctx->kr_handle);
2195
2196   /* FOUND_KEY is only valid as long as RET_KEYBLOCK is.  If the
2197    * caller wants PK, but not RET_KEYBLOCK, we need hand in our own
2198    * keyblock.  */
2199   if (pk && ret_keyblock == NULL)
2200       ret_keyblock = &keyblock;
2201
2202   rc = lookup (ctrl, ctx, ctx->want_secret,
2203                ret_keyblock, pk ? &found_key : NULL);
2204   if (!rc && pk)
2205     {
2206       log_assert (found_key);
2207       pk_from_block (pk, NULL, found_key);
2208       release_kbnode (keyblock);
2209     }
2210
2211   return rc;
2212 }
2213
2214
2215 /* Release any resources used by a key listing context.  This must be
2216  * called on the context returned by, e.g., getkey_byname.  */
2217 void
2218 getkey_end (ctrl_t ctrl, getkey_ctx_t ctx)
2219 {
2220   if (ctx)
2221     {
2222       if (ctrl && !ctrl->cached_getkey_kdb)
2223         ctrl->cached_getkey_kdb = ctx->kr_handle;
2224       else
2225         keydb_release (ctx->kr_handle);
2226       free_strlist (ctx->extra_list);
2227       if (!ctx->not_allocated)
2228         xfree (ctx);
2229     }
2230 }
2231
2232
2233 \f
2234 /************************************************
2235  ************* Merging stuff ********************
2236  ************************************************/
2237
2238 /* Set the mainkey_id fields for all keys in KEYBLOCK.  This is
2239  * usually done by merge_selfsigs but at some places we only need the
2240  * main_kid not a full merge.  The function also guarantees that all
2241  * pk->keyids are computed.  */
2242 void
2243 setup_main_keyids (kbnode_t keyblock)
2244 {
2245   u32 kid[2], mainkid[2];
2246   kbnode_t kbctx, node;
2247   PKT_public_key *pk;
2248
2249   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2250     BUG ();
2251   pk = keyblock->pkt->pkt.public_key;
2252
2253   keyid_from_pk (pk, mainkid);
2254   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
2255     {
2256       if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
2257             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2258         continue;
2259       pk = node->pkt->pkt.public_key;
2260       keyid_from_pk (pk, kid); /* Make sure pk->keyid is set.  */
2261       if (!pk->main_keyid[0] && !pk->main_keyid[1])
2262         {
2263           pk->main_keyid[0] = mainkid[0];
2264           pk->main_keyid[1] = mainkid[1];
2265         }
2266     }
2267 }
2268
2269
2270 /* KEYBLOCK corresponds to a public key block.  This function merges
2271  * much of the information from the self-signed data into the public
2272  * key, public subkey and user id data structures.  If you use the
2273  * high-level search API (e.g., get_pubkey) for looking up key blocks,
2274  * then you don't need to call this function.  This function is
2275  * useful, however, if you change the keyblock, e.g., by adding or
2276  * removing a self-signed data packet.  */
2277 void
2278 merge_keys_and_selfsig (ctrl_t ctrl, kbnode_t keyblock)
2279 {
2280   if (!keyblock)
2281     ;
2282   else if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
2283     merge_selfsigs (ctrl, keyblock);
2284   else
2285     log_debug ("FIXME: merging secret key blocks is not anymore available\n");
2286 }
2287
2288
2289 static int
2290 parse_key_usage (PKT_signature * sig)
2291 {
2292   int key_usage = 0;
2293   const byte *p;
2294   size_t n;
2295   byte flags;
2296
2297   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n);
2298   if (p && n)
2299     {
2300       /* First octet of the keyflags.  */
2301       flags = *p;
2302
2303       if (flags & 1)
2304         {
2305           key_usage |= PUBKEY_USAGE_CERT;
2306           flags &= ~1;
2307         }
2308
2309       if (flags & 2)
2310         {
2311           key_usage |= PUBKEY_USAGE_SIG;
2312           flags &= ~2;
2313         }
2314
2315       /* We do not distinguish between encrypting communications and
2316          encrypting storage. */
2317       if (flags & (0x04 | 0x08))
2318         {
2319           key_usage |= PUBKEY_USAGE_ENC;
2320           flags &= ~(0x04 | 0x08);
2321         }
2322
2323       if (flags & 0x20)
2324         {
2325           key_usage |= PUBKEY_USAGE_AUTH;
2326           flags &= ~0x20;
2327         }
2328
2329       if (flags)
2330         key_usage |= PUBKEY_USAGE_UNKNOWN;
2331
2332       if (!key_usage)
2333         key_usage |= PUBKEY_USAGE_NONE;
2334     }
2335   else if (p) /* Key flags of length zero.  */
2336     key_usage |= PUBKEY_USAGE_NONE;
2337
2338   /* We set PUBKEY_USAGE_UNKNOWN to indicate that this key has a
2339      capability that we do not handle.  This serves to distinguish
2340      between a zero key usage which we handle as the default
2341      capabilities for that algorithm, and a usage that we do not
2342      handle.  Likewise we use PUBKEY_USAGE_NONE to indicate that
2343      key_flags have been given but they do not specify any usage.  */
2344
2345   return key_usage;
2346 }
2347
2348
2349 /* Apply information from SIGNODE (which is the valid self-signature
2350  * associated with that UID) to the UIDNODE:
2351  * - weather the UID has been revoked
2352  * - assumed creation date of the UID
2353  * - temporary store the keyflags here
2354  * - temporary store the key expiration time here
2355  * - mark whether the primary user ID flag hat been set.
2356  * - store the preferences
2357  */
2358 static void
2359 fixup_uidnode (KBNODE uidnode, KBNODE signode, u32 keycreated)
2360 {
2361   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
2362   PKT_signature *sig = signode->pkt->pkt.signature;
2363   const byte *p, *sym, *hash, *zip;
2364   size_t n, nsym, nhash, nzip;
2365
2366   sig->flags.chosen_selfsig = 1;/* We chose this one. */
2367   uid->created = 0;             /* Not created == invalid. */
2368   if (IS_UID_REV (sig))
2369     {
2370       uid->flags.revoked = 1;
2371       return; /* Has been revoked.  */
2372     }
2373   else
2374     uid->flags.revoked = 0;
2375
2376   uid->expiredate = sig->expiredate;
2377
2378   if (sig->flags.expired)
2379     {
2380       uid->flags.expired = 1;
2381       return; /* Has expired.  */
2382     }
2383   else
2384     uid->flags.expired = 0;
2385
2386   uid->created = sig->timestamp; /* This one is okay. */
2387   uid->selfsigversion = sig->version;
2388   /* If we got this far, it's not expired :) */
2389   uid->flags.expired = 0;
2390
2391   /* Store the key flags in the helper variable for later processing.  */
2392   uid->help_key_usage = parse_key_usage (sig);
2393
2394   /* Ditto for the key expiration.  */
2395   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2396   if (p && buf32_to_u32 (p))
2397     uid->help_key_expire = keycreated + buf32_to_u32 (p);
2398   else
2399     uid->help_key_expire = 0;
2400
2401   /* Set the primary user ID flag - we will later wipe out some
2402    * of them to only have one in our keyblock.  */
2403   uid->flags.primary = 0;
2404   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
2405   if (p && *p)
2406     uid->flags.primary = 2;
2407
2408   /* We could also query this from the unhashed area if it is not in
2409    * the hased area and then later try to decide which is the better
2410    * there should be no security problem with this.
2411    * For now we only look at the hashed one.  */
2412
2413   /* Now build the preferences list.  These must come from the
2414      hashed section so nobody can modify the ciphers a key is
2415      willing to accept.  */
2416   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM, &n);
2417   sym = p;
2418   nsym = p ? n : 0;
2419   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH, &n);
2420   hash = p;
2421   nhash = p ? n : 0;
2422   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR, &n);
2423   zip = p;
2424   nzip = p ? n : 0;
2425   if (uid->prefs)
2426     xfree (uid->prefs);
2427   n = nsym + nhash + nzip;
2428   if (!n)
2429     uid->prefs = NULL;
2430   else
2431     {
2432       uid->prefs = xmalloc (sizeof (*uid->prefs) * (n + 1));
2433       n = 0;
2434       for (; nsym; nsym--, n++)
2435         {
2436           uid->prefs[n].type = PREFTYPE_SYM;
2437           uid->prefs[n].value = *sym++;
2438         }
2439       for (; nhash; nhash--, n++)
2440         {
2441           uid->prefs[n].type = PREFTYPE_HASH;
2442           uid->prefs[n].value = *hash++;
2443         }
2444       for (; nzip; nzip--, n++)
2445         {
2446           uid->prefs[n].type = PREFTYPE_ZIP;
2447           uid->prefs[n].value = *zip++;
2448         }
2449       uid->prefs[n].type = PREFTYPE_NONE; /* End of list marker  */
2450       uid->prefs[n].value = 0;
2451     }
2452
2453   /* See whether we have the MDC feature.  */
2454   uid->flags.mdc = 0;
2455   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
2456   if (p && n && (p[0] & 0x01))
2457     uid->flags.mdc = 1;
2458
2459   /* And the keyserver modify flag.  */
2460   uid->flags.ks_modify = 1;
2461   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
2462   if (p && n && (p[0] & 0x80))
2463     uid->flags.ks_modify = 0;
2464 }
2465
2466 static void
2467 sig_to_revoke_info (PKT_signature * sig, struct revoke_info *rinfo)
2468 {
2469   rinfo->date = sig->timestamp;
2470   rinfo->algo = sig->pubkey_algo;
2471   rinfo->keyid[0] = sig->keyid[0];
2472   rinfo->keyid[1] = sig->keyid[1];
2473 }
2474
2475
2476 /* Given a keyblock, parse the key block and extract various pieces of
2477    information and save them with the primary key packet and the user
2478    id packets.  For instance, some information is stored in signature
2479    packets.  We find the latest such valid packet (since the user can
2480    change that information) and copy its contents into the
2481    PKT_public_key.
2482
2483    Note that R_REVOKED may be set to 0, 1 or 2.
2484
2485    This function fills in the following fields in the primary key's
2486    keyblock:
2487
2488      main_keyid          (computed)
2489      revkey / numrevkeys (derived from self signed key data)
2490      flags.valid         (whether we have at least 1 self-sig)
2491      flags.maybe_revoked (whether a designed revoked the key, but
2492                           we are missing the key to check the sig)
2493      selfsigversion      (highest version of any valid self-sig)
2494      pubkey_usage        (derived from most recent self-sig or most
2495                           recent user id)
2496      has_expired         (various sources)
2497      expiredate          (various sources)
2498
2499   See the documentation for fixup_uidnode for how the user id packets
2500   are modified.  In addition to that the primary user id's is_primary
2501   field is set to 1 and the other user id's is_primary are set to
2502   0.  */
2503 static void
2504 merge_selfsigs_main (ctrl_t ctrl, kbnode_t keyblock, int *r_revoked,
2505                      struct revoke_info *rinfo)
2506 {
2507   PKT_public_key *pk = NULL;
2508   KBNODE k;
2509   u32 kid[2];
2510   u32 sigdate, uiddate, uiddate2;
2511   KBNODE signode, uidnode, uidnode2;
2512   u32 curtime = make_timestamp ();
2513   unsigned int key_usage = 0;
2514   u32 keytimestamp = 0;
2515   u32 key_expire = 0;
2516   int key_expire_seen = 0;
2517   byte sigversion = 0;
2518
2519   *r_revoked = 0;
2520   memset (rinfo, 0, sizeof (*rinfo));
2521
2522   /* Section 11.1 of RFC 4880 determines the order of packets within a
2523      message.  There are three sections, which must occur in the
2524      following order: the public key, the user ids and user attributes
2525      and the subkeys.  Within each section, each primary packet (e.g.,
2526      a user id packet) is followed by one or more signature packets,
2527      which modify that packet.  */
2528
2529   /* According to Section 11.1 of RFC 4880, the public key must be the
2530      first packet.  */
2531   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2532     /* parse_keyblock_image ensures that the first packet is the
2533        public key.  */
2534     BUG ();
2535   pk = keyblock->pkt->pkt.public_key;
2536   keytimestamp = pk->timestamp;
2537
2538   keyid_from_pk (pk, kid);
2539   pk->main_keyid[0] = kid[0];
2540   pk->main_keyid[1] = kid[1];
2541
2542   if (pk->version < 4)
2543     {
2544       /* Before v4 the key packet itself contains the expiration date
2545        * and there was no way to change it, so we start with the one
2546        * from the key packet.  */
2547       key_expire = pk->max_expiredate;
2548       key_expire_seen = 1;
2549     }
2550
2551   /* First pass:
2552
2553       - Find the latest direct key self-signature.  We assume that the
2554         newest one overrides all others.
2555
2556       - Determine whether the key has been revoked.
2557
2558       - Gather all revocation keys (unlike other data, we don't just
2559         take them from the latest self-signed packet).
2560
2561       - Determine max (sig[...]->version).
2562    */
2563
2564   /* Reset this in case this key was already merged. */
2565   xfree (pk->revkey);
2566   pk->revkey = NULL;
2567   pk->numrevkeys = 0;
2568
2569   signode = NULL;
2570   sigdate = 0; /* Helper variable to find the latest signature.  */
2571
2572   /* According to Section 11.1 of RFC 4880, the public key comes first
2573      and is immediately followed by any signature packets that modify
2574      it.  */
2575   for (k = keyblock;
2576        k && k->pkt->pkttype != PKT_USER_ID
2577          && k->pkt->pkttype != PKT_ATTRIBUTE
2578          && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2579        k = k->next)
2580     {
2581       if (k->pkt->pkttype == PKT_SIGNATURE)
2582         {
2583           PKT_signature *sig = k->pkt->pkt.signature;
2584           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
2585             /* Self sig.  */
2586             {
2587               if (check_key_signature (ctrl, keyblock, k, NULL))
2588                 ; /* Signature did not verify.  */
2589               else if (IS_KEY_REV (sig))
2590                 {
2591                   /* Key has been revoked - there is no way to
2592                    * override such a revocation, so we theoretically
2593                    * can stop now.  We should not cope with expiration
2594                    * times for revocations here because we have to
2595                    * assume that an attacker can generate all kinds of
2596                    * signatures.  However due to the fact that the key
2597                    * has been revoked it does not harm either and by
2598                    * continuing we gather some more info on that
2599                    * key.  */
2600                   *r_revoked = 1;
2601                   sig_to_revoke_info (sig, rinfo);
2602                 }
2603               else if (IS_KEY_SIG (sig))
2604                 {
2605                   /* Add the indicated revocations keys from all
2606                      signatures not just the latest.  We do this
2607                      because you need multiple 1F sigs to properly
2608                      handle revocation keys (PGP does it this way, and
2609                      a revocation key could be sensitive and hence in
2610                      a different signature). */
2611                   if (sig->revkey)
2612                     {
2613                       int i;
2614
2615                       pk->revkey =
2616                         xrealloc (pk->revkey, sizeof (struct revocation_key) *
2617                                   (pk->numrevkeys + sig->numrevkeys));
2618
2619                       for (i = 0; i < sig->numrevkeys; i++)
2620                         memcpy (&pk->revkey[pk->numrevkeys++],
2621                                 &sig->revkey[i],
2622                                 sizeof (struct revocation_key));
2623                     }
2624
2625                   if (sig->timestamp >= sigdate)
2626                     /* This is the latest signature so far.  */
2627                     {
2628                       if (sig->flags.expired)
2629                         ; /* Signature has expired - ignore it.  */
2630                       else
2631                         {
2632                           sigdate = sig->timestamp;
2633                           signode = k;
2634                           if (sig->version > sigversion)
2635                             sigversion = sig->version;
2636
2637                         }
2638                     }
2639                 }
2640             }
2641         }
2642     }
2643
2644   /* Remove dupes from the revocation keys.  */
2645   if (pk->revkey)
2646     {
2647       int i, j, x, changed = 0;
2648
2649       for (i = 0; i < pk->numrevkeys; i++)
2650         {
2651           for (j = i + 1; j < pk->numrevkeys; j++)
2652             {
2653               if (memcmp (&pk->revkey[i], &pk->revkey[j],
2654                           sizeof (struct revocation_key)) == 0)
2655                 {
2656                   /* remove j */
2657
2658                   for (x = j; x < pk->numrevkeys - 1; x++)
2659                     pk->revkey[x] = pk->revkey[x + 1];
2660
2661                   pk->numrevkeys--;
2662                   j--;
2663                   changed = 1;
2664                 }
2665             }
2666         }
2667
2668       if (changed)
2669         pk->revkey = xrealloc (pk->revkey,
2670                                pk->numrevkeys *
2671                                sizeof (struct revocation_key));
2672     }
2673
2674   if (signode)
2675     /* SIGNODE is the 1F signature packet with the latest creation
2676        time.  Extract some information from it.  */
2677     {
2678       /* Some information from a direct key signature take precedence
2679        * over the same information given in UID sigs.  */
2680       PKT_signature *sig = signode->pkt->pkt.signature;
2681       const byte *p;
2682
2683       key_usage = parse_key_usage (sig);
2684
2685       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2686       if (p && buf32_to_u32 (p))
2687         {
2688           key_expire = keytimestamp + buf32_to_u32 (p);
2689           key_expire_seen = 1;
2690         }
2691
2692       /* Mark that key as valid: One direct key signature should
2693        * render a key as valid.  */
2694       pk->flags.valid = 1;
2695     }
2696
2697   /* Pass 1.5: Look for key revocation signatures that were not made
2698      by the key (i.e. did a revocation key issue a revocation for
2699      us?).  Only bother to do this if there is a revocation key in the
2700      first place and we're not revoked already.  */
2701
2702   if (!*r_revoked && pk->revkey)
2703     for (k = keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next)
2704       {
2705         if (k->pkt->pkttype == PKT_SIGNATURE)
2706           {
2707             PKT_signature *sig = k->pkt->pkt.signature;
2708
2709             if (IS_KEY_REV (sig) &&
2710                 (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1]))
2711               {
2712                 int rc = check_revocation_keys (ctrl, pk, sig);
2713                 if (rc == 0)
2714                   {
2715                     *r_revoked = 2;
2716                     sig_to_revoke_info (sig, rinfo);
2717                     /* Don't continue checking since we can't be any
2718                        more revoked than this.  */
2719                     break;
2720                   }
2721                 else if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2722                   pk->flags.maybe_revoked = 1;
2723
2724                 /* A failure here means the sig did not verify, was
2725                    not issued by a revocation key, or a revocation
2726                    key loop was broken.  If a revocation key isn't
2727                    findable, however, the key might be revoked and
2728                    we don't know it.  */
2729
2730                 /* TODO: In the future handle subkey and cert
2731                    revocations?  PGP doesn't, but it's in 2440. */
2732               }
2733           }
2734       }
2735
2736   /* Second pass: Look at the self-signature of all user IDs.  */
2737
2738   /* According to RFC 4880 section 11.1, user id and attribute packets
2739      are in the second section, after the public key packet and before
2740      the subkey packets.  */
2741   signode = uidnode = NULL;
2742   sigdate = 0; /* Helper variable to find the latest signature in one UID. */
2743   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
2744     {
2745       if (k->pkt->pkttype == PKT_USER_ID || k->pkt->pkttype == PKT_ATTRIBUTE)
2746         /* New user id packet.  */
2747         {
2748           if (uidnode && signode)
2749             /* Apply the data from the most recent self-signed packet
2750                to the preceding user id packet.  */
2751             {
2752               fixup_uidnode (uidnode, signode, keytimestamp);
2753               pk->flags.valid = 1;
2754             }
2755           /* Clear SIGNODE.  The only relevant self-signed data for
2756              UIDNODE follows it.  */
2757           if (k->pkt->pkttype == PKT_USER_ID)
2758             uidnode = k;
2759           else
2760             uidnode = NULL;
2761           signode = NULL;
2762           sigdate = 0;
2763         }
2764       else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
2765         {
2766           PKT_signature *sig = k->pkt->pkt.signature;
2767           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
2768             {
2769               if (check_key_signature (ctrl, keyblock, k, NULL))
2770                 ;               /* signature did not verify */
2771               else if ((IS_UID_SIG (sig) || IS_UID_REV (sig))
2772                        && sig->timestamp >= sigdate)
2773                 {
2774                   /* Note: we allow invalidation of cert revocations
2775                    * by a newer signature.  An attacker can't use this
2776                    * because a key should be revoked with a key revocation.
2777                    * The reason why we have to allow for that is that at
2778                    * one time an email address may become invalid but later
2779                    * the same email address may become valid again (hired,
2780                    * fired, hired again).  */
2781
2782                   sigdate = sig->timestamp;
2783                   signode = k;
2784                   signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
2785                   if (sig->version > sigversion)
2786                     sigversion = sig->version;
2787                 }
2788             }
2789         }
2790     }
2791   if (uidnode && signode)
2792     {
2793       fixup_uidnode (uidnode, signode, keytimestamp);
2794       pk->flags.valid = 1;
2795     }
2796
2797   /* If the key isn't valid yet, and we have
2798      --allow-non-selfsigned-uid set, then force it valid. */
2799   if (!pk->flags.valid && opt.allow_non_selfsigned_uid)
2800     {
2801       if (opt.verbose)
2802         log_info (_("Invalid key %s made valid by"
2803                     " --allow-non-selfsigned-uid\n"), keystr_from_pk (pk));
2804       pk->flags.valid = 1;
2805     }
2806
2807   /* The key STILL isn't valid, so try and find an ultimately
2808      trusted signature. */
2809   if (!pk->flags.valid)
2810     {
2811       uidnode = NULL;
2812
2813       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2814            k = k->next)
2815         {
2816           if (k->pkt->pkttype == PKT_USER_ID)
2817             uidnode = k;
2818           else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
2819             {
2820               PKT_signature *sig = k->pkt->pkt.signature;
2821
2822               if (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1])
2823                 {
2824                   PKT_public_key *ultimate_pk;
2825
2826                   ultimate_pk = xmalloc_clear (sizeof (*ultimate_pk));
2827
2828                   /* We don't want to use the full get_pubkey to
2829                      avoid infinite recursion in certain cases.
2830                      There is no reason to check that an ultimately
2831                      trusted key is still valid - if it has been
2832                      revoked the user should also remove the
2833                      ultimate trust flag.  */
2834                   if (get_pubkey_fast (ultimate_pk, sig->keyid) == 0
2835                       && check_key_signature2 (ctrl,
2836                                                keyblock, k, ultimate_pk,
2837                                                NULL, NULL, NULL, NULL) == 0
2838                       && get_ownertrust (ctrl, ultimate_pk) == TRUST_ULTIMATE)
2839                     {
2840                       free_public_key (ultimate_pk);
2841                       pk->flags.valid = 1;
2842                       break;
2843                     }
2844
2845                   free_public_key (ultimate_pk);
2846                 }
2847             }
2848         }
2849     }
2850
2851   /* Record the highest selfsig version so we know if this is a v3
2852      key through and through, or a v3 key with a v4 selfsig
2853      somewhere.  This is useful in a few places to know if the key
2854      must be treated as PGP2-style or OpenPGP-style.  Note that a
2855      selfsig revocation with a higher version number will also raise
2856      this value.  This is okay since such a revocation must be
2857      issued by the user (i.e. it cannot be issued by someone else to
2858      modify the key behavior.) */
2859
2860   pk->selfsigversion = sigversion;
2861
2862   /* Now that we had a look at all user IDs we can now get some information
2863    * from those user IDs.
2864    */
2865
2866   if (!key_usage)
2867     {
2868       /* Find the latest user ID with key flags set. */
2869       uiddate = 0; /* Helper to find the latest user ID.  */
2870       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2871            k = k->next)
2872         {
2873           if (k->pkt->pkttype == PKT_USER_ID)
2874             {
2875               PKT_user_id *uid = k->pkt->pkt.user_id;
2876               if (uid->help_key_usage && uid->created > uiddate)
2877                 {
2878                   key_usage = uid->help_key_usage;
2879                   uiddate = uid->created;
2880                 }
2881             }
2882         }
2883     }
2884   if (!key_usage)
2885     {
2886       /* No key flags at all: get it from the algo.  */
2887       key_usage = openpgp_pk_algo_usage (pk->pubkey_algo);
2888     }
2889   else
2890     {
2891       /* Check that the usage matches the usage as given by the algo.  */
2892       int x = openpgp_pk_algo_usage (pk->pubkey_algo);
2893       if (x) /* Mask it down to the actual allowed usage.  */
2894         key_usage &= x;
2895     }
2896
2897   /* Whatever happens, it's a primary key, so it can certify. */
2898   pk->pubkey_usage = key_usage | PUBKEY_USAGE_CERT;
2899
2900   if (!key_expire_seen)
2901     {
2902       /* Find the latest valid user ID with a key expiration set
2903        * Note, that this may be a different one from the above because
2904        * some user IDs may have no expiration date set.  */
2905       uiddate = 0;
2906       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2907            k = k->next)
2908         {
2909           if (k->pkt->pkttype == PKT_USER_ID)
2910             {
2911               PKT_user_id *uid = k->pkt->pkt.user_id;
2912               if (uid->help_key_expire && uid->created > uiddate)
2913                 {
2914                   key_expire = uid->help_key_expire;
2915                   uiddate = uid->created;
2916                 }
2917             }
2918         }
2919     }
2920
2921   /* Currently only v3 keys have a maximum expiration date, but I'll
2922      bet v5 keys get this feature again. */
2923   if (key_expire == 0
2924       || (pk->max_expiredate && key_expire > pk->max_expiredate))
2925     key_expire = pk->max_expiredate;
2926
2927   pk->has_expired = key_expire >= curtime ? 0 : key_expire;
2928   pk->expiredate = key_expire;
2929
2930   /* Fixme: we should see how to get rid of the expiretime fields  but
2931    * this needs changes at other places too. */
2932
2933   /* And now find the real primary user ID and delete all others.  */
2934   uiddate = uiddate2 = 0;
2935   uidnode = uidnode2 = NULL;
2936   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
2937     {
2938       if (k->pkt->pkttype == PKT_USER_ID && !k->pkt->pkt.user_id->attrib_data)
2939         {
2940           PKT_user_id *uid = k->pkt->pkt.user_id;
2941           if (uid->flags.primary)
2942             {
2943               if (uid->created > uiddate)
2944                 {
2945                   uiddate = uid->created;
2946                   uidnode = k;
2947                 }
2948               else if (uid->created == uiddate && uidnode)
2949                 {
2950                   /* The dates are equal, so we need to do a
2951                      different (and arbitrary) comparison.  This
2952                      should rarely, if ever, happen.  It's good to
2953                      try and guarantee that two different GnuPG
2954                      users with two different keyrings at least pick
2955                      the same primary. */
2956                   if (cmp_user_ids (uid, uidnode->pkt->pkt.user_id) > 0)
2957                     uidnode = k;
2958                 }
2959             }
2960           else
2961             {
2962               if (uid->created > uiddate2)
2963                 {
2964                   uiddate2 = uid->created;
2965                   uidnode2 = k;
2966                 }
2967               else if (uid->created == uiddate2 && uidnode2)
2968                 {
2969                   if (cmp_user_ids (uid, uidnode2->pkt->pkt.user_id) > 0)
2970                     uidnode2 = k;
2971                 }
2972             }
2973         }
2974     }
2975   if (uidnode)
2976     {
2977       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2978            k = k->next)
2979         {
2980           if (k->pkt->pkttype == PKT_USER_ID &&
2981               !k->pkt->pkt.user_id->attrib_data)
2982             {
2983               PKT_user_id *uid = k->pkt->pkt.user_id;
2984               if (k != uidnode)
2985                 uid->flags.primary = 0;
2986             }
2987         }
2988     }
2989   else if (uidnode2)
2990     {
2991       /* None is flagged primary - use the latest user ID we have,
2992          and disambiguate with the arbitrary packet comparison. */
2993       uidnode2->pkt->pkt.user_id->flags.primary = 1;
2994     }
2995   else
2996     {
2997       /* None of our uids were self-signed, so pick the one that
2998          sorts first to be the primary.  This is the best we can do
2999          here since there are no self sigs to date the uids. */
3000
3001       uidnode = NULL;
3002
3003       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3004            k = k->next)
3005         {
3006           if (k->pkt->pkttype == PKT_USER_ID
3007               && !k->pkt->pkt.user_id->attrib_data)
3008             {
3009               if (!uidnode)
3010                 {
3011                   uidnode = k;
3012                   uidnode->pkt->pkt.user_id->flags.primary = 1;
3013                   continue;
3014                 }
3015               else
3016                 {
3017                   if (cmp_user_ids (k->pkt->pkt.user_id,
3018                                     uidnode->pkt->pkt.user_id) > 0)
3019                     {
3020                       uidnode->pkt->pkt.user_id->flags.primary = 0;
3021                       uidnode = k;
3022                       uidnode->pkt->pkt.user_id->flags.primary = 1;
3023                     }
3024                   else
3025                     k->pkt->pkt.user_id->flags.primary = 0;     /* just to be
3026                                                                    safe */
3027                 }
3028             }
3029         }
3030     }
3031 }
3032
3033 /* Convert a buffer to a signature.  Useful for 0x19 embedded sigs.
3034    Caller must free the signature when they are done. */
3035 static PKT_signature *
3036 buf_to_sig (const byte * buf, size_t len)
3037 {
3038   PKT_signature *sig = xmalloc_clear (sizeof (PKT_signature));
3039   IOBUF iobuf = iobuf_temp_with_content (buf, len);
3040   int save_mode = set_packet_list_mode (0);
3041
3042   if (parse_signature (iobuf, PKT_SIGNATURE, len, sig) != 0)
3043     {
3044       xfree (sig);
3045       sig = NULL;
3046     }
3047
3048   set_packet_list_mode (save_mode);
3049   iobuf_close (iobuf);
3050
3051   return sig;
3052 }
3053
3054 /* Use the self-signed data to fill in various fields in subkeys.
3055
3056    KEYBLOCK is the whole keyblock.  SUBNODE is the subkey to fill in.
3057
3058    Sets the following fields on the subkey:
3059
3060      main_keyid
3061      flags.valid        if the subkey has a valid self-sig binding
3062      flags.revoked
3063      flags.backsig
3064      pubkey_usage
3065      has_expired
3066      expired_date
3067
3068    On this subkey's most revent valid self-signed packet, the
3069    following field is set:
3070
3071      flags.chosen_selfsig
3072   */
3073 static void
3074 merge_selfsigs_subkey (ctrl_t ctrl, kbnode_t keyblock, kbnode_t subnode)
3075 {
3076   PKT_public_key *mainpk = NULL, *subpk = NULL;
3077   PKT_signature *sig;
3078   KBNODE k;
3079   u32 mainkid[2];
3080   u32 sigdate = 0;
3081   KBNODE signode;
3082   u32 curtime = make_timestamp ();
3083   unsigned int key_usage = 0;
3084   u32 keytimestamp = 0;
3085   u32 key_expire = 0;
3086   const byte *p;
3087
3088   if (subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3089     BUG ();
3090   mainpk = keyblock->pkt->pkt.public_key;
3091   if (mainpk->version < 4)
3092     return;/* (actually this should never happen) */
3093   keyid_from_pk (mainpk, mainkid);
3094   subpk = subnode->pkt->pkt.public_key;
3095   keytimestamp = subpk->timestamp;
3096
3097   subpk->flags.valid = 0;
3098   subpk->flags.exact = 0;
3099   subpk->main_keyid[0] = mainpk->main_keyid[0];
3100   subpk->main_keyid[1] = mainpk->main_keyid[1];
3101
3102   /* Find the latest key binding self-signature.  */
3103   signode = NULL;
3104   sigdate = 0; /* Helper to find the latest signature.  */
3105   for (k = subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3106        k = k->next)
3107     {
3108       if (k->pkt->pkttype == PKT_SIGNATURE)
3109         {
3110           sig = k->pkt->pkt.signature;
3111           if (sig->keyid[0] == mainkid[0] && sig->keyid[1] == mainkid[1])
3112             {
3113               if (check_key_signature (ctrl, keyblock, k, NULL))
3114                 ; /* Signature did not verify.  */
3115               else if (IS_SUBKEY_REV (sig))
3116                 {
3117                   /* Note that this means that the date on a
3118                      revocation sig does not matter - even if the
3119                      binding sig is dated after the revocation sig,
3120                      the subkey is still marked as revoked.  This
3121                      seems ok, as it is just as easy to make new
3122                      subkeys rather than re-sign old ones as the
3123                      problem is in the distribution.  Plus, PGP (7)
3124                      does this the same way.  */
3125                   subpk->flags.revoked = 1;
3126                   sig_to_revoke_info (sig, &subpk->revoked);
3127                   /* Although we could stop now, we continue to
3128                    * figure out other information like the old expiration
3129                    * time.  */
3130                 }
3131               else if (IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate)
3132                 {
3133                   if (sig->flags.expired)
3134                     ; /* Signature has expired - ignore it.  */
3135                   else
3136                     {
3137                       sigdate = sig->timestamp;
3138                       signode = k;
3139                       signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
3140                     }
3141                 }
3142             }
3143         }
3144     }
3145
3146   /* No valid key binding.  */
3147   if (!signode)
3148     return;
3149
3150   sig = signode->pkt->pkt.signature;
3151   sig->flags.chosen_selfsig = 1; /* So we know which selfsig we chose later.  */
3152
3153   key_usage = parse_key_usage (sig);
3154   if (!key_usage)
3155     {
3156       /* No key flags at all: get it from the algo.  */
3157       key_usage = openpgp_pk_algo_usage (subpk->pubkey_algo);
3158     }
3159   else
3160     {
3161       /* Check that the usage matches the usage as given by the algo.  */
3162       int x = openpgp_pk_algo_usage (subpk->pubkey_algo);
3163       if (x) /* Mask it down to the actual allowed usage.  */
3164         key_usage &= x;
3165     }
3166
3167   subpk->pubkey_usage = key_usage;
3168
3169   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
3170   if (p && buf32_to_u32 (p))
3171     key_expire = keytimestamp + buf32_to_u32 (p);
3172   else
3173     key_expire = 0;
3174   subpk->has_expired = key_expire >= curtime ? 0 : key_expire;
3175   subpk->expiredate = key_expire;
3176
3177   /* Algo doesn't exist.  */
3178   if (openpgp_pk_test_algo (subpk->pubkey_algo))
3179     return;
3180
3181   subpk->flags.valid = 1;
3182
3183   /* Find the most recent 0x19 embedded signature on our self-sig. */
3184   if (!subpk->flags.backsig)
3185     {
3186       int seq = 0;
3187       size_t n;
3188       PKT_signature *backsig = NULL;
3189
3190       sigdate = 0;
3191
3192       /* We do this while() since there may be other embedded
3193          signatures in the future.  We only want 0x19 here. */
3194
3195       while ((p = enum_sig_subpkt (sig->hashed,
3196                                    SIGSUBPKT_SIGNATURE, &n, &seq, NULL)))
3197         if (n > 3
3198             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
3199           {
3200             PKT_signature *tempsig = buf_to_sig (p, n);
3201             if (tempsig)
3202               {
3203                 if (tempsig->timestamp > sigdate)
3204                   {
3205                     if (backsig)
3206                       free_seckey_enc (backsig);
3207
3208                     backsig = tempsig;
3209                     sigdate = backsig->timestamp;
3210                   }
3211                 else
3212                   free_seckey_enc (tempsig);
3213               }
3214           }
3215
3216       seq = 0;
3217
3218       /* It is safe to have this in the unhashed area since the 0x19
3219          is located on the selfsig for convenience, not security. */
3220
3221       while ((p = enum_sig_subpkt (sig->unhashed, SIGSUBPKT_SIGNATURE,
3222                                    &n, &seq, NULL)))
3223         if (n > 3
3224             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
3225           {
3226             PKT_signature *tempsig = buf_to_sig (p, n);
3227             if (tempsig)
3228               {
3229                 if (tempsig->timestamp > sigdate)
3230                   {
3231                     if (backsig)
3232                       free_seckey_enc (backsig);
3233
3234                     backsig = tempsig;
3235                     sigdate = backsig->timestamp;
3236                   }
3237                 else
3238                   free_seckey_enc (tempsig);
3239               }
3240           }
3241
3242       if (backsig)
3243         {
3244           /* At this point, backsig contains the most recent 0x19 sig.
3245              Let's see if it is good. */
3246
3247           /* 2==valid, 1==invalid, 0==didn't check */
3248           if (check_backsig (mainpk, subpk, backsig) == 0)
3249             subpk->flags.backsig = 2;
3250           else
3251             subpk->flags.backsig = 1;
3252
3253           free_seckey_enc (backsig);
3254         }
3255     }
3256 }
3257
3258
3259 /* Merge information from the self-signatures with the public key,
3260    subkeys and user ids to make using them more easy.
3261
3262    See documentation for merge_selfsigs_main, merge_selfsigs_subkey
3263    and fixup_uidnode for exactly which fields are updated.  */
3264 static void
3265 merge_selfsigs (ctrl_t ctrl, kbnode_t keyblock)
3266 {
3267   KBNODE k;
3268   int revoked;
3269   struct revoke_info rinfo;
3270   PKT_public_key *main_pk;
3271   prefitem_t *prefs;
3272   unsigned int mdc_feature;
3273
3274   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
3275     {
3276       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
3277         {
3278           log_error ("expected public key but found secret key "
3279                      "- must stop\n");
3280           /* We better exit here because a public key is expected at
3281              other places too.  FIXME: Figure this out earlier and
3282              don't get to here at all */
3283           g10_exit (1);
3284         }
3285       BUG ();
3286     }
3287
3288   merge_selfsigs_main (ctrl, keyblock, &revoked, &rinfo);
3289
3290   /* Now merge in the data from each of the subkeys.  */
3291   for (k = keyblock; k; k = k->next)
3292     {
3293       if (k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3294         {
3295           merge_selfsigs_subkey (ctrl, keyblock, k);
3296         }
3297     }
3298
3299   main_pk = keyblock->pkt->pkt.public_key;
3300   if (revoked || main_pk->has_expired || !main_pk->flags.valid)
3301     {
3302       /* If the primary key is revoked, expired, or invalid we
3303        * better set the appropriate flags on that key and all
3304        * subkeys.  */
3305       for (k = keyblock; k; k = k->next)
3306         {
3307           if (k->pkt->pkttype == PKT_PUBLIC_KEY
3308               || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3309             {
3310               PKT_public_key *pk = k->pkt->pkt.public_key;
3311               if (!main_pk->flags.valid)
3312                 pk->flags.valid = 0;
3313               if (revoked && !pk->flags.revoked)
3314                 {
3315                   pk->flags.revoked = revoked;
3316                   memcpy (&pk->revoked, &rinfo, sizeof (rinfo));
3317                 }
3318               if (main_pk->has_expired)
3319                 pk->has_expired = main_pk->has_expired;
3320             }
3321         }
3322       return;
3323     }
3324
3325   /* Set the preference list of all keys to those of the primary real
3326    * user ID.  Note: we use these preferences when we don't know by
3327    * which user ID the key has been selected.
3328    * fixme: we should keep atoms of commonly used preferences or
3329    * use reference counting to optimize the preference lists storage.
3330    * FIXME: it might be better to use the intersection of
3331    * all preferences.
3332    * Do a similar thing for the MDC feature flag.  */
3333   prefs = NULL;
3334   mdc_feature = 0;
3335   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
3336     {
3337       if (k->pkt->pkttype == PKT_USER_ID
3338           && !k->pkt->pkt.user_id->attrib_data
3339           && k->pkt->pkt.user_id->flags.primary)
3340         {
3341           prefs = k->pkt->pkt.user_id->prefs;
3342           mdc_feature = k->pkt->pkt.user_id->flags.mdc;
3343           break;
3344         }
3345     }
3346   for (k = keyblock; k; k = k->next)
3347     {
3348       if (k->pkt->pkttype == PKT_PUBLIC_KEY
3349           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3350         {
3351           PKT_public_key *pk = k->pkt->pkt.public_key;
3352           if (pk->prefs)
3353             xfree (pk->prefs);
3354           pk->prefs = copy_prefs (prefs);
3355           pk->flags.mdc = mdc_feature;
3356         }
3357     }
3358 }
3359
3360
3361 \f
3362 /* See whether the key satisfies any additional requirements specified
3363  * in CTX.  If so, return the node of an appropriate key or subkey.
3364  * Otherwise, return NULL if there was no appropriate key.
3365  *
3366  * Note that we do not return a reference, i.e. the result must not be
3367  * freed using 'release_kbnode'.
3368  *
3369  * In case the primary key is not required, select a suitable subkey.
3370  * We need the primary key if PUBKEY_USAGE_CERT is set in REQ_USAGE or
3371  * we are in PGP6 or PGP7 mode and PUBKEY_USAGE_SIG is set in
3372  * REQ_USAGE.
3373  *
3374  * If any of PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT
3375  * are set in REQ_USAGE, we filter by the key's function.  Concretely,
3376  * if PUBKEY_USAGE_SIG and PUBKEY_USAGE_CERT are set, then we only
3377  * return a key if it is (at least) either a signing or a
3378  * certification key.
3379  *
3380  * If REQ_USAGE is set, then we reject any keys that are not good
3381  * (i.e., valid, not revoked, not expired, etc.).  This allows the
3382  * getkey functions to be used for plain key listings.
3383  *
3384  * Sets the matched key's user id field (pk->user_id) to the user id
3385  * that matched the low-level search criteria or NULL.
3386  *
3387  * If R_FLAGS is not NULL set certain flags for more detailed error
3388  * reporting.  Used flags are:
3389  *
3390  * - LOOKUP_ALL_SUBKEYS_EXPIRED :: All Subkeys are expired or have
3391  *                                 been revoked.
3392  * - LOOKUP_NOT_SELECTED :: No suitable key found
3393  *
3394  * This function needs to handle several different cases:
3395  *
3396  *  1. No requested usage and no primary key requested
3397  *     Examples for this case are that we have a keyID to be used
3398  *     for decrytion or verification.
3399  *  2. No usage but primary key requested
3400  *     This is the case for all functions which work on an
3401  *     entire keyblock, e.g. for editing or listing
3402  *  3. Usage and primary key requested
3403  *     FIXME
3404  *  4. Usage but no primary key requested
3405  *     FIXME
3406  *
3407  */
3408 static kbnode_t
3409 finish_lookup (kbnode_t keyblock, unsigned int req_usage, int want_exact,
3410                unsigned int *r_flags)
3411 {
3412   kbnode_t k;
3413
3414   /* If WANT_EXACT is set, the key or subkey that actually matched the
3415      low-level search criteria.  */
3416   kbnode_t foundk = NULL;
3417   /* The user id (if any) that matched the low-level search criteria.  */
3418   PKT_user_id *foundu = NULL;
3419
3420   u32 latest_date;
3421   kbnode_t latest_key;
3422   PKT_public_key *pk;
3423   int req_prim;
3424   u32 curtime = make_timestamp ();
3425
3426   if (r_flags)
3427     *r_flags = 0;
3428
3429 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC|PUBKEY_USAGE_CERT)
3430   req_usage &= USAGE_MASK;
3431
3432   /* Request the primary if we're certifying another key, and also if
3433    * signing data while --pgp6 or --pgp7 is on since pgp 6 and 7 do
3434    * not understand signatures made by a signing subkey.  PGP 8 does. */
3435   req_prim = ((req_usage & PUBKEY_USAGE_CERT)
3436               || ((PGP6 || PGP7) && (req_usage & PUBKEY_USAGE_SIG)));
3437
3438
3439   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3440
3441   /* For an exact match mark the primary or subkey that matched the
3442      low-level search criteria.  */
3443   if (want_exact)
3444     {
3445       for (k = keyblock; k; k = k->next)
3446         {
3447           if ((k->flag & 1))
3448             {
3449               log_assert (k->pkt->pkttype == PKT_PUBLIC_KEY
3450                           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY);
3451               foundk = k;
3452               pk = k->pkt->pkt.public_key;
3453               pk->flags.exact = 1;
3454               break;
3455             }
3456         }
3457     }
3458
3459   /* Get the user id that matched that low-level search criteria.  */
3460   for (k = keyblock; k; k = k->next)
3461     {
3462       if ((k->flag & 2))
3463         {
3464           log_assert (k->pkt->pkttype == PKT_USER_ID);
3465           foundu = k->pkt->pkt.user_id;
3466           break;
3467         }
3468     }
3469
3470   if (DBG_LOOKUP)
3471     log_debug ("finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
3472                (ulong) keyid_from_pk (keyblock->pkt->pkt.public_key, NULL),
3473                foundk ? "one" : "all", req_usage);
3474
3475   if (!req_usage)
3476     {
3477       latest_key = foundk ? foundk : keyblock;
3478       goto found;
3479     }
3480
3481   latest_date = 0;
3482   latest_key = NULL;
3483   /* Set LATEST_KEY to the latest (the one with the most recent
3484    * timestamp) good (valid, not revoked, not expired, etc.) subkey.
3485    *
3486    * Don't bother if we are only looking for a primary key or we need
3487    * an exact match and the exact match is not a subkey.  */
3488   if (req_prim || (foundk && foundk->pkt->pkttype != PKT_PUBLIC_SUBKEY))
3489     ;
3490   else
3491     {
3492       kbnode_t nextk;
3493       int n_subkeys = 0;
3494       int n_revoked_or_expired = 0;
3495
3496       /* Either start a loop or check just this one subkey.  */
3497       for (k = foundk ? foundk : keyblock; k; k = nextk)
3498         {
3499           if (foundk)
3500             {
3501               /* If FOUNDK is not NULL, then only consider that exact
3502                  key, i.e., don't iterate.  */
3503               nextk = NULL;
3504             }
3505           else
3506             nextk = k->next;
3507
3508           if (k->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3509             continue;
3510
3511           pk = k->pkt->pkt.public_key;
3512           if (DBG_LOOKUP)
3513             log_debug ("\tchecking subkey %08lX\n",
3514                        (ulong) keyid_from_pk (pk, NULL));
3515
3516           if (!pk->flags.valid)
3517             {
3518               if (DBG_LOOKUP)
3519                 log_debug ("\tsubkey not valid\n");
3520               continue;
3521             }
3522           if (!((pk->pubkey_usage & USAGE_MASK) & req_usage))
3523             {
3524               if (DBG_LOOKUP)
3525                 log_debug ("\tusage does not match: want=%x have=%x\n",
3526                            req_usage, pk->pubkey_usage);
3527               continue;
3528             }
3529
3530           n_subkeys++;
3531           if (pk->flags.revoked)
3532             {
3533               if (DBG_LOOKUP)
3534                 log_debug ("\tsubkey has been revoked\n");
3535               n_revoked_or_expired++;
3536               continue;
3537             }
3538           if (pk->has_expired)
3539             {
3540               if (DBG_LOOKUP)
3541                 log_debug ("\tsubkey has expired\n");
3542               n_revoked_or_expired++;
3543               continue;
3544             }
3545           if (pk->timestamp > curtime && !opt.ignore_valid_from)
3546             {
3547               if (DBG_LOOKUP)
3548                 log_debug ("\tsubkey not yet valid\n");
3549               continue;
3550             }
3551
3552           if (DBG_LOOKUP)
3553             log_debug ("\tsubkey might be fine\n");
3554           /* In case a key has a timestamp of 0 set, we make sure
3555              that it is used.  A better change would be to compare
3556              ">=" but that might also change the selected keys and
3557              is as such a more intrusive change.  */
3558           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3559             {
3560               latest_date = pk->timestamp;
3561               latest_key = k;
3562             }
3563         }
3564       if (n_subkeys == n_revoked_or_expired && r_flags)
3565         *r_flags |= LOOKUP_ALL_SUBKEYS_EXPIRED;
3566     }