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