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