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