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