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