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