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