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