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