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