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