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