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