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