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