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