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