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