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