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