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