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