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