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