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