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