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