g10/import.c

   1 /* import.c - import a key into our key storage.
   2  * Copyright (C) 1998-2007, 2010-2011 Free Software Foundation, Inc.
   3  * Copyright (C) 2014  Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "gpg.h"
  29 #include "options.h"
  30 #include "packet.h"
  31 #include "status.h"
  32 #include "keydb.h"
  33 #include "util.h"
  34 #include "trustdb.h"
  35 #include "main.h"
  36 #include "i18n.h"
  37 #include "ttyio.h"
  38 #include "status.h"
  39 #include "keyserver-internal.h"
  40 #include "call-agent.h"
  41 #include "../common/membuf.h"
  42
  43 struct stats_s
  44 {
  45   ulong count;
  46   ulong no_user_id;
  47   ulong imported;
  48   ulong n_uids;
  49   ulong n_sigs;
  50   ulong n_subk;
  51   ulong unchanged;
  52   ulong n_revoc;
  53   ulong secret_read;
  54   ulong secret_imported;
  55   ulong secret_dups;
  56   ulong skipped_new_keys;
  57   ulong not_imported;
  58   ulong n_sigs_cleaned;
  59   ulong n_uids_cleaned;
  60   ulong v3keys;   /* Number of V3 keys seen.  */
  61 };
  62
  63
  64 static int import (ctrl_t ctrl,
  65                    IOBUF inp, const char* fname, struct stats_s *stats,
  66                    unsigned char **fpr, size_t *fpr_len, unsigned int options,
  67                    import_screener_t screener, void *screener_arg);
  68 static int read_block (IOBUF a, PACKET **pending_pkt, kbnode_t *ret_root,
  69                        int *r_v3keys);
  70 static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
  71 static int import_one (ctrl_t ctrl,
  72                        const char *fname, kbnode_t keyblock,struct stats_s *stats,
  73                        unsigned char **fpr, size_t *fpr_len,
  74                        unsigned int options, int from_sk, int silent,
  75                        import_screener_t screener, void *screener_arg);
  76 static int import_secret_one (ctrl_t ctrl, const char *fname, kbnode_t keyblock,
  77                               struct stats_s *stats, int batch,
  78                               unsigned int options, int for_migration,
  79                               import_screener_t screener, void *screener_arg);
  80 static int import_revoke_cert( const char *fname, kbnode_t node,
  81                                struct stats_s *stats);
  82 static int chk_self_sigs (const char *fname, kbnode_t keyblock,
  83                           PKT_public_key *pk, u32 *keyid, int *non_self );
  84 static int delete_inv_parts (const char *fname, kbnode_t keyblock,
  85                              u32 *keyid, unsigned int options );
  86 static int merge_blocks (const char *fname, kbnode_t keyblock_orig,
  87                          kbnode_t keyblock, u32 *keyid,
  88                          int *n_uids, int *n_sigs, int *n_subk );
  89 static int append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs,
  90                              const char *fname, u32 *keyid );
  91 static int append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs,
  92                              const char *fname, u32 *keyid );
  93 static int merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs,
  94                              const char *fname, u32 *keyid );
  95 static int merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs,
  96                              const char *fname, u32 *keyid );
  97
  98 int
  99 parse_import_options(char *str,unsigned int *options,int noisy)
 100 {
 101   struct parse_options import_opts[]=
 102     {
 103       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
 104        N_("import signatures that are marked as local-only")},
 105
 106       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
 107        N_("repair damage from the pks keyserver during import")},
 108
 109       {"keep-ownertrust", IMPORT_KEEP_OWNERTTRUST, NULL,
 110        N_("do not clear the ownertrust values during import")},
 111
 112       {"fast-import",IMPORT_FAST,NULL,
 113        N_("do not update the trustdb after import")},
 114
 115       {"merge-only",IMPORT_MERGE_ONLY,NULL,
 116        N_("only accept updates to existing keys")},
 117
 118       {"import-clean",IMPORT_CLEAN,NULL,
 119        N_("remove unusable parts from key after import")},
 120
 121       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
 122        N_("remove as much as possible from key after import")},
 123
 124       /* Aliases for backward compatibility */
 125       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
 126       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
 127       /* dummy */
 128       {"import-unusable-sigs",0,NULL,NULL},
 129       {"import-clean-sigs",0,NULL,NULL},
 130       {"import-clean-uids",0,NULL,NULL},
 131       {"convert-sk-to-pk",0, NULL,NULL}, /* Not anymore needed due to
 132                                             the new design.  */
 133       {NULL,0,NULL,NULL}
 134     };
 135
 136   return parse_options(str,options,import_opts,noisy);
 137 }
 138
 139
 140 void *
 141 import_new_stats_handle (void)
 142 {
 143   return xmalloc_clear ( sizeof (struct stats_s) );
 144 }
 145
 146
 147 void
 148 import_release_stats_handle (void *p)
 149 {
 150   xfree (p);
 151 }
 152
 153
 154 /*
 155  * Import the public keys from the given filename. Input may be armored.
 156  * This function rejects all keys which are not validly self signed on at
 157  * least one userid. Only user ids which are self signed will be imported.
 158  * Other signatures are not checked.
 159  *
 160  * Actually this function does a merge. It works like this:
 161  *
 162  *  - get the keyblock
 163  *  - check self-signatures and remove all userids and their signatures
 164  *    without/invalid self-signatures.
 165  *  - reject the keyblock, if we have no valid userid.
 166  *  - See whether we have this key already in one of our pubrings.
 167  *    If not, simply add it to the default keyring.
 168  *  - Compare the key and the self-signatures of the new and the one in
 169  *    our keyring.  If they are different something weird is going on;
 170  *    ask what to do.
 171  *  - See whether we have only non-self-signature on one user id; if not
 172  *    ask the user what to do.
 173  *  - compare the signatures: If we already have this signature, check
 174  *    that they compare okay; if not, issue a warning and ask the user.
 175  *    (consider looking at the timestamp and use the newest?)
 176  *  - Simply add the signature.  Can't verify here because we may not have
 177  *    the signature's public key yet; verification is done when putting it
 178  *    into the trustdb, which is done automagically as soon as this pubkey
 179  *    is used.
 180  *  - Proceed with next signature.
 181  *
 182  *  Key revocation certificates have special handling.
 183  */
 184 static int
 185 import_keys_internal (ctrl_t ctrl, iobuf_t inp, char **fnames, int nnames,
 186                       void *stats_handle, unsigned char **fpr, size_t *fpr_len,
 187                       unsigned int options,
 188                       import_screener_t screener, void *screener_arg)
 189 {
 190   int i;
 191   int rc = 0;
 192   struct stats_s *stats = stats_handle;
 193
 194   if (!stats)
 195     stats = import_new_stats_handle ();
 196
 197   if (inp)
 198     {
 199       rc = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options,
 200                    screener, screener_arg);
 201     }
 202   else
 203     {
 204       if (!fnames && !nnames)
 205         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
 206
 207       for (i=0; i < nnames; i++)
 208         {
 209           const char *fname = fnames? fnames[i] : NULL;
 210           IOBUF inp2 = iobuf_open(fname);
 211
 212           if (!fname)
 213             fname = "[stdin]";
 214           if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
 215             {
 216               iobuf_close (inp2);
 217               inp2 = NULL;
 218               gpg_err_set_errno (EPERM);
 219             }
 220           if (!inp2)
 221             log_error (_("can't open '%s': %s\n"), fname, strerror (errno));
 222           else
 223             {
 224               rc = import (ctrl, inp2, fname, stats, fpr, fpr_len, options,
 225                            screener, screener_arg);
 226               iobuf_close (inp2);
 227               /* Must invalidate that ugly cache to actually close it. */
 228               iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
 229               if (rc)
 230                 log_error ("import from '%s' failed: %s\n",
 231                            fname, gpg_strerror (rc) );
 232             }
 233           if (!fname)
 234             break;
 235         }
 236     }
 237
 238   if (!stats_handle)
 239     {
 240       import_print_stats (stats);
 241       import_release_stats_handle (stats);
 242     }
 243
 244   /* If no fast import and the trustdb is dirty (i.e. we added a key
 245      or userID that had something other than a selfsig, a signature
 246      that was other than a selfsig, or any revocation), then
 247      update/check the trustdb if the user specified by setting
 248      interactive or by not setting no-auto-check-trustdb */
 249
 250   if (!(options & IMPORT_FAST))
 251     check_or_update_trustdb ();
 252
 253   return rc;
 254 }
 255
 256
 257 void
 258 import_keys (ctrl_t ctrl, char **fnames, int nnames,
 259              void *stats_handle, unsigned int options )
 260 {
 261   import_keys_internal (ctrl, NULL, fnames, nnames, stats_handle,
 262                         NULL, NULL, options, NULL, NULL);
 263 }
 264
 265 int
 266 import_keys_stream (ctrl_t ctrl, IOBUF inp, void *stats_handle,
 267                     unsigned char **fpr, size_t *fpr_len, unsigned int options)
 268 {
 269   return import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
 270                                fpr, fpr_len, options, NULL, NULL);
 271 }
 272
 273
 274 /* Variant of import_keys_stream reading from an estream_t.  */
 275 int
 276 import_keys_es_stream (ctrl_t ctrl, estream_t fp, void *stats_handle,
 277                        unsigned char **fpr, size_t *fpr_len,
 278                        unsigned int options,
 279                        import_screener_t screener, void *screener_arg)
 280 {
 281   int rc;
 282   iobuf_t inp;
 283
 284   inp = iobuf_esopen (fp, "r", 1);
 285   if (!inp)
 286     {
 287       rc = gpg_error_from_syserror ();
 288       log_error ("iobuf_esopen failed: %s\n", gpg_strerror (rc));
 289       return rc;
 290     }
 291
 292   rc = import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
 293                              fpr, fpr_len, options,
 294                              screener, screener_arg);
 295
 296   iobuf_close (inp);
 297   return rc;
 298 }
 299
 300
 301 static int
 302 import (ctrl_t ctrl, IOBUF inp, const char* fname,struct stats_s *stats,
 303         unsigned char **fpr,size_t *fpr_len, unsigned int options,
 304         import_screener_t screener, void *screener_arg)
 305 {
 306   PACKET *pending_pkt = NULL;
 307   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
 308                                 grasp the return semantics of
 309                                 read_block. */
 310   int rc = 0;
 311   int v3keys;
 312
 313   getkey_disable_caches ();
 314
 315   if (!opt.no_armor) /* Armored reading is not disabled.  */
 316     {
 317       armor_filter_context_t *afx;
 318
 319       afx = new_armor_context ();
 320       afx->only_keyblocks = 1;
 321       push_armor_filter (afx, inp);
 322       release_armor_context (afx);
 323     }
 324
 325   while (!(rc = read_block (inp, &pending_pkt, &keyblock, &v3keys)))
 326     {
 327       stats->v3keys += v3keys;
 328       if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
 329         rc = import_one (ctrl, fname, keyblock,
 330                          stats, fpr, fpr_len, options, 0, 0,
 331                          screener, screener_arg);
 332       else if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
 333         rc = import_secret_one (ctrl, fname, keyblock, stats,
 334                                 opt.batch, options, 0,
 335                                 screener, screener_arg);
 336       else if (keyblock->pkt->pkttype == PKT_SIGNATURE
 337                && keyblock->pkt->pkt.signature->sig_class == 0x20 )
 338         rc = import_revoke_cert( fname, keyblock, stats );
 339       else
 340         {
 341           log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
 342         }
 343       release_kbnode (keyblock);
 344
 345       /* fixme: we should increment the not imported counter but
 346          this does only make sense if we keep on going despite of
 347          errors.  For now we do this only if the imported key is too
 348          large. */
 349       if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
 350             && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
 351         {
 352           stats->not_imported++;
 353           rc = 0;
 354         }
 355       else if (rc)
 356         break;
 357
 358       if (!(++stats->count % 100) && !opt.quiet)
 359         log_info (_("%lu keys processed so far\n"), stats->count );
 360     }
 361   stats->v3keys += v3keys;
 362   if (rc == -1)
 363     rc = 0;
 364   else if (rc && gpg_err_code (rc) != GPG_ERR_INV_KEYRING)
 365     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (rc));
 366
 367   return rc;
 368 }
 369
 370
 371 /* Helper to migrate secring.gpg to GnuPG 2.1.  */
 372 gpg_error_t
 373 import_old_secring (ctrl_t ctrl, const char *fname)
 374 {
 375   gpg_error_t err;
 376   iobuf_t inp;
 377   PACKET *pending_pkt = NULL;
 378   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
 379                                 grasp the return semantics of
 380                                 read_block. */
 381   struct stats_s *stats;
 382   int v3keys;
 383
 384   inp = iobuf_open (fname);
 385   if (inp && is_secured_file (iobuf_get_fd (inp)))
 386     {
 387       iobuf_close (inp);
 388       inp = NULL;
 389       gpg_err_set_errno (EPERM);
 390     }
 391   if (!inp)
 392     {
 393       err = gpg_error_from_syserror ();
 394       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
 395       return err;
 396     }
 397
 398   getkey_disable_caches();
 399   stats = import_new_stats_handle ();
 400   while (!(err = read_block (inp, &pending_pkt, &keyblock, &v3keys)))
 401     {
 402       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
 403         err = import_secret_one (ctrl, fname, keyblock, stats, 1, 0, 1,
 404                                  NULL, NULL);
 405       release_kbnode (keyblock);
 406       if (err)
 407         break;
 408     }
 409   import_release_stats_handle (stats);
 410   if (err == -1)
 411     err = 0;
 412   else if (err && gpg_err_code (err) != GPG_ERR_INV_KEYRING)
 413     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
 414   else if (err)
 415     log_error ("import from '%s' failed: %s\n", fname, gpg_strerror (err));
 416
 417   iobuf_close (inp);
 418   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
 419
 420   return err;
 421 }
 422
 423
 424 void
 425 import_print_stats (void *hd)
 426 {
 427   struct stats_s *stats = hd;
 428
 429   if (!opt.quiet)
 430     {
 431       log_info(_("Total number processed: %lu\n"),
 432                stats->count + stats->v3keys);
 433       if (stats->v3keys)
 434         log_info(_("    skipped PGP-2 keys: %lu\n"), stats->v3keys);
 435       if (stats->skipped_new_keys )
 436         log_info(_("      skipped new keys: %lu\n"),
 437                  stats->skipped_new_keys );
 438       if (stats->no_user_id )
 439         log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
 440       if (stats->imported)
 441         {
 442           log_info(_("              imported: %lu"), stats->imported );
 443           log_printf ("\n");
 444         }
 445       if (stats->unchanged )
 446         log_info(_("             unchanged: %lu\n"), stats->unchanged );
 447       if (stats->n_uids )
 448         log_info(_("          new user IDs: %lu\n"), stats->n_uids );
 449       if (stats->n_subk )
 450         log_info(_("           new subkeys: %lu\n"), stats->n_subk );
 451       if (stats->n_sigs )
 452         log_info(_("        new signatures: %lu\n"), stats->n_sigs );
 453       if (stats->n_revoc )
 454         log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
 455       if (stats->secret_read )
 456         log_info(_("      secret keys read: %lu\n"), stats->secret_read );
 457       if (stats->secret_imported )
 458         log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
 459       if (stats->secret_dups )
 460         log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
 461       if (stats->not_imported )
 462         log_info(_("          not imported: %lu\n"), stats->not_imported );
 463       if (stats->n_sigs_cleaned)
 464         log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
 465       if (stats->n_uids_cleaned)
 466         log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
 467     }
 468
 469   if (is_status_enabled ())
 470     {
 471       char buf[15*20];
 472
 473       snprintf (buf, sizeof buf,
 474                 "%lu %lu %lu 0 %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
 475                 stats->count + stats->v3keys,
 476                 stats->no_user_id,
 477                 stats->imported,
 478                 stats->unchanged,
 479                 stats->n_uids,
 480                 stats->n_subk,
 481                 stats->n_sigs,
 482                 stats->n_revoc,
 483                 stats->secret_read,
 484                 stats->secret_imported,
 485                 stats->secret_dups,
 486                 stats->skipped_new_keys,
 487                 stats->not_imported,
 488                 stats->v3keys );
 489       write_status_text (STATUS_IMPORT_RES, buf);
 490     }
 491 }
 492
 493
 494 /* Return true if PKTTYPE is valid in a keyblock.  */
 495 static int
 496 valid_keyblock_packet (int pkttype)
 497 {
 498   switch (pkttype)
 499     {
 500     case PKT_PUBLIC_KEY:
 501     case PKT_PUBLIC_SUBKEY:
 502     case PKT_SECRET_KEY:
 503     case PKT_SECRET_SUBKEY:
 504     case PKT_SIGNATURE:
 505     case PKT_USER_ID:
 506     case PKT_ATTRIBUTE:
 507     case PKT_RING_TRUST:
 508       return 1;
 509     default:
 510       return 0;
 511     }
 512 }
 513
 514
 515 /****************
 516  * Read the next keyblock from stream A.
 517  * PENDING_PKT should be initialzed to NULL
 518  * and not changed by the caller.
 519  * Return: 0 = okay, -1 no more blocks or another errorcode.
 520  *         The int at at R_V3KEY counts the number of unsupported v3
 521  *         keyblocks.
 522  */
 523 static int
 524 read_block( IOBUF a, PACKET **pending_pkt, kbnode_t *ret_root, int *r_v3keys)
 525 {
 526   int rc;
 527   PACKET *pkt;
 528   kbnode_t root = NULL;
 529   int in_cert, in_v3key;
 530
 531   *r_v3keys = 0;
 532
 533   if (*pending_pkt)
 534     {
 535       root = new_kbnode( *pending_pkt );
 536       *pending_pkt = NULL;
 537       in_cert = 1;
 538     }
 539   else
 540     in_cert = 0;
 541
 542   pkt = xmalloc (sizeof *pkt);
 543   init_packet (pkt);
 544   in_v3key = 0;
 545   while ((rc=parse_packet(a, pkt)) != -1)
 546     {
 547       if (rc && (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY
 548                  && (pkt->pkttype == PKT_PUBLIC_KEY
 549                      || pkt->pkttype == PKT_SECRET_KEY)))
 550         {
 551           in_v3key = 1;
 552           ++*r_v3keys;
 553           free_packet (pkt);
 554           init_packet (pkt);
 555           continue;
 556         }
 557       else if (rc ) /* (ignore errors) */
 558         {
 559           if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET)
 560             ; /* Do not show a diagnostic.  */
 561           else
 562             {
 563               log_error("read_block: read error: %s\n", gpg_strerror (rc) );
 564               rc = GPG_ERR_INV_KEYRING;
 565               goto ready;
 566             }
 567           free_packet( pkt );
 568           init_packet(pkt);
 569           continue;
 570         }
 571
 572         if (in_v3key && !(pkt->pkttype == PKT_PUBLIC_KEY
 573                           || pkt->pkttype == PKT_SECRET_KEY))
 574           {
 575             free_packet( pkt );
 576             init_packet(pkt);
 577             continue;
 578           }
 579         in_v3key = 0;
 580
 581         if (!root && pkt->pkttype == PKT_SIGNATURE
 582                   && pkt->pkt.signature->sig_class == 0x20 )
 583           {
 584             /* This is a revocation certificate which is handled in a
 585              * special way.  */
 586             root = new_kbnode( pkt );
 587             pkt = NULL;
 588             goto ready;
 589           }
 590
 591         /* Make a linked list of all packets.  */
 592         switch (pkt->pkttype)
 593           {
 594           case PKT_COMPRESSED:
 595             if (check_compress_algo (pkt->pkt.compressed->algorithm))
 596               {
 597                 rc = GPG_ERR_COMPR_ALGO;
 598                 goto ready;
 599               }
 600             else
 601               {
 602                 compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
 603                 pkt->pkt.compressed->buf = NULL;
 604                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
 605               }
 606             free_packet( pkt );
 607             init_packet(pkt);
 608             break;
 609
 610           case PKT_RING_TRUST:
 611             /* Skip those packets.  */
 612             free_packet( pkt );
 613             init_packet(pkt);
 614             break;
 615
 616           case PKT_PUBLIC_KEY:
 617           case PKT_SECRET_KEY:
 618             if (in_cert ) /* Store this packet.  */
 619               {
 620                 *pending_pkt = pkt;
 621                 pkt = NULL;
 622                 goto ready;
 623               }
 624             in_cert = 1;
 625           default:
 626             if (in_cert && valid_keyblock_packet (pkt->pkttype))
 627               {
 628                 if (!root )
 629                   root = new_kbnode (pkt);
 630                 else
 631                   add_kbnode (root, new_kbnode (pkt));
 632                 pkt = xmalloc (sizeof *pkt);
 633               }
 634             init_packet(pkt);
 635             break;
 636           }
 637     }
 638
 639  ready:
 640   if (rc == -1 && root )
 641     rc = 0;
 642
 643   if (rc )
 644     release_kbnode( root );
 645   else
 646     *ret_root = root;
 647   free_packet( pkt );
 648   xfree( pkt );
 649   return rc;
 650 }
 651
 652
 653 /* Walk through the subkeys on a pk to find if we have the PKS
 654    disease: multiple subkeys with their binding sigs stripped, and the
 655    sig for the first subkey placed after the last subkey.  That is,
 656    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
 657    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
 658    and sub3, as they are already lost, but we can try and rescue sub1
 659    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
 660    sub2 sub3".  Returns TRUE if the keyblock was modified. */
 661 static int
 662 fix_pks_corruption (kbnode_t keyblock)
 663 {
 664   int changed = 0;
 665   int keycount = 0;
 666   kbnode_t node;
 667   kbnode_t last = NULL;
 668   kbnode_t sknode=NULL;
 669
 670   /* First determine if we have the problem at all.  Look for 2 or
 671      more subkeys in a row, followed by a single binding sig. */
 672   for (node=keyblock; node; last=node, node=node->next)
 673     {
 674       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 675         {
 676           keycount++;
 677           if(!sknode)
 678             sknode=node;
 679         }
 680       else if (node->pkt->pkttype == PKT_SIGNATURE
 681                && node->pkt->pkt.signature->sig_class == 0x18
 682                && keycount >= 2
 683                && !node->next)
 684         {
 685           /* We might have the problem, as this key has two subkeys in
 686              a row without any intervening packets. */
 687
 688           /* Sanity check */
 689           if (!last)
 690             break;
 691
 692           /* Temporarily attach node to sknode. */
 693           node->next = sknode->next;
 694           sknode->next = node;
 695           last->next = NULL;
 696
 697           /* Note we aren't checking whether this binding sig is a
 698              selfsig.  This is not necessary here as the subkey and
 699              binding sig will be rejected later if that is the
 700              case. */
 701           if (check_key_signature (keyblock,node,NULL))
 702             {
 703               /* Not a match, so undo the changes. */
 704               sknode->next = node->next;
 705               last->next = node;
 706               node->next = NULL;
 707               break;
 708             }
 709           else
 710             {
 711               sknode->flag |= 1; /* Mark it good so we don't need to
 712                                     check it again */
 713               changed = 1;
 714               break;
 715             }
 716         }
 717       else
 718         keycount = 0;
 719     }
 720
 721   return changed;
 722 }
 723
 724
 725 /* Versions of GnuPG before 1.4.11 and 2.0.16 allowed to import bogus
 726    direct key signatures.  A side effect of this was that a later
 727    import of the same good direct key signatures was not possible
 728    because the cmp_signature check in merge_blocks considered them
 729    equal.  Although direct key signatures are now checked during
 730    import, there might still be bogus signatures sitting in a keyring.
 731    We need to detect and delete them before doing a merge.  This
 732    function returns the number of removed sigs.  */
 733 static int
 734 fix_bad_direct_key_sigs (kbnode_t keyblock, u32 *keyid)
 735 {
 736   gpg_error_t err;
 737   kbnode_t node;
 738   int count = 0;
 739
 740   for (node = keyblock->next; node; node=node->next)
 741     {
 742       if (node->pkt->pkttype == PKT_USER_ID)
 743         break;
 744       if (node->pkt->pkttype == PKT_SIGNATURE
 745           && IS_KEY_SIG (node->pkt->pkt.signature))
 746         {
 747           err = check_key_signature (keyblock, node, NULL);
 748           if (err && gpg_err_code (err) != GPG_ERR_PUBKEY_ALGO )
 749             {
 750               /* If we don't know the error, we can't decide; this is
 751                  not a problem because cmp_signature can't compare the
 752                  signature either.  */
 753               log_info ("key %s: invalid direct key signature removed\n",
 754                         keystr (keyid));
 755               delete_kbnode (node);
 756               count++;
 757             }
 758         }
 759     }
 760
 761   return count;
 762 }
 763
 764
 765 static void
 766 print_import_ok (PKT_public_key *pk, unsigned int reason)
 767 {
 768   byte array[MAX_FINGERPRINT_LEN], *s;
 769   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
 770   size_t i, n;
 771
 772   snprintf (buf, sizeof buf, "%u ", reason);
 773   p = buf + strlen (buf);
 774
 775   fingerprint_from_pk (pk, array, &n);
 776   s = array;
 777   for (i=0; i < n ; i++, s++, p += 2)
 778     sprintf (p, "%02X", *s);
 779
 780   write_status_text (STATUS_IMPORT_OK, buf);
 781 }
 782
 783
 784 static void
 785 print_import_check (PKT_public_key * pk, PKT_user_id * id)
 786 {
 787   char * buf;
 788   byte fpr[24];
 789   u32 keyid[2];
 790   size_t i, n;
 791   size_t pos = 0;
 792
 793   buf = xmalloc (17+41+id->len+32);
 794   keyid_from_pk (pk, keyid);
 795   sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
 796   pos = 17;
 797   fingerprint_from_pk (pk, fpr, &n);
 798   for (i = 0; i < n; i++, pos += 2)
 799     sprintf (buf+pos, "%02X", fpr[i]);
 800   strcat (buf, " ");
 801   pos += 1;
 802   strcat (buf, id->name);
 803   write_status_text (STATUS_IMPORT_CHECK, buf);
 804   xfree (buf);
 805 }
 806
 807
 808 static void
 809 check_prefs_warning(PKT_public_key *pk)
 810 {
 811   log_info(_("WARNING: key %s contains preferences for unavailable\n"
 812              "algorithms on these user IDs:\n"), keystr_from_pk(pk));
 813 }
 814
 815
 816 static void
 817 check_prefs (ctrl_t ctrl, kbnode_t keyblock)
 818 {
 819   kbnode_t node;
 820   PKT_public_key *pk;
 821   int problem=0;
 822
 823   merge_keys_and_selfsig(keyblock);
 824   pk=keyblock->pkt->pkt.public_key;
 825
 826   for(node=keyblock;node;node=node->next)
 827     {
 828       if(node->pkt->pkttype==PKT_USER_ID
 829          && node->pkt->pkt.user_id->created
 830          && node->pkt->pkt.user_id->prefs)
 831         {
 832           PKT_user_id *uid = node->pkt->pkt.user_id;
 833           prefitem_t *prefs = uid->prefs;
 834           char *user = utf8_to_native(uid->name,strlen(uid->name),0);
 835
 836           for(;prefs->type;prefs++)
 837             {
 838               char num[10]; /* prefs->value is a byte, so we're over
 839                                safe here */
 840
 841               sprintf(num,"%u",prefs->value);
 842
 843               if(prefs->type==PREFTYPE_SYM)
 844                 {
 845                   if (openpgp_cipher_test_algo (prefs->value))
 846                     {
 847                       const char *algo =
 848                         (openpgp_cipher_test_algo (prefs->value)
 849                          ? num
 850                          : openpgp_cipher_algo_name (prefs->value));
 851                       if(!problem)
 852                         check_prefs_warning(pk);
 853                       log_info(_("         \"%s\": preference for cipher"
 854                                  " algorithm %s\n"), user, algo);
 855                       problem=1;
 856                     }
 857                 }
 858               else if(prefs->type==PREFTYPE_HASH)
 859                 {
 860                   if(openpgp_md_test_algo(prefs->value))
 861                     {
 862                       const char *algo =
 863                         (gcry_md_test_algo (prefs->value)
 864                          ? num
 865                          : gcry_md_algo_name (prefs->value));
 866                       if(!problem)
 867                         check_prefs_warning(pk);
 868                       log_info(_("         \"%s\": preference for digest"
 869                                  " algorithm %s\n"), user, algo);
 870                       problem=1;
 871                     }
 872                 }
 873               else if(prefs->type==PREFTYPE_ZIP)
 874                 {
 875                   if(check_compress_algo (prefs->value))
 876                     {
 877                       const char *algo=compress_algo_to_string(prefs->value);
 878                       if(!problem)
 879                         check_prefs_warning(pk);
 880                       log_info(_("         \"%s\": preference for compression"
 881                                  " algorithm %s\n"),user,algo?algo:num);
 882                       problem=1;
 883                     }
 884                 }
 885             }
 886
 887           xfree(user);
 888         }
 889     }
 890
 891   if(problem)
 892     {
 893       log_info(_("it is strongly suggested that you update"
 894                  " your preferences and\n"));
 895       log_info(_("re-distribute this key to avoid potential algorithm"
 896                  " mismatch problems\n"));
 897
 898       if(!opt.batch)
 899         {
 900           strlist_t sl = NULL;
 901           strlist_t locusr = NULL;
 902           size_t fprlen=0;
 903           byte fpr[MAX_FINGERPRINT_LEN], *p;
 904           char username[(MAX_FINGERPRINT_LEN*2)+1];
 905           unsigned int i;
 906
 907           p = fingerprint_from_pk (pk,fpr,&fprlen);
 908           for(i=0;i<fprlen;i++,p++)
 909             sprintf(username+2*i,"%02X",*p);
 910           add_to_strlist(&locusr,username);
 911
 912           append_to_strlist(&sl,"updpref");
 913           append_to_strlist(&sl,"save");
 914
 915           keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
 916           free_strlist(sl);
 917           free_strlist(locusr);
 918         }
 919       else if(!opt.quiet)
 920         log_info(_("you can update your preferences with:"
 921                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
 922     }
 923 }
 924
 925
 926 /*
 927  * Try to import one keyblock. Return an error only in serious cases,
 928  * but never for an invalid keyblock.  It uses log_error to increase
 929  * the internal errorcount, so that invalid input can be detected by
 930  * programs which called gpg.  If SILENT is no messages are printed -
 931  * even most error messages are suppressed.
 932  */
 933 static int
 934 import_one (ctrl_t ctrl,
 935             const char *fname, kbnode_t keyblock, struct stats_s *stats,
 936             unsigned char **fpr, size_t *fpr_len, unsigned int options,
 937             int from_sk, int silent,
 938             import_screener_t screener, void *screener_arg)
 939 {
 940   PKT_public_key *pk;
 941   PKT_public_key *pk_orig;
 942   kbnode_t node, uidnode;
 943   kbnode_t keyblock_orig = NULL;
 944   byte fpr2[MAX_FINGERPRINT_LEN];
 945   size_t fpr2len;
 946   u32 keyid[2];
 947   int rc = 0;
 948   int new_key = 0;
 949   int mod_key = 0;
 950   int same_key = 0;
 951   int non_self = 0;
 952   size_t an;
 953   char pkstrbuf[PUBKEY_STRING_SIZE];
 954
 955   /* Get the key and print some info about it. */
 956   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
 957   if (!node )
 958     BUG();
 959
 960   pk = node->pkt->pkt.public_key;
 961
 962   fingerprint_from_pk (pk, fpr2, &fpr2len);
 963   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
 964     fpr2[an] = 0;
 965   keyid_from_pk( pk, keyid );
 966   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
 967
 968   if (opt.verbose && !opt.interactive && !silent)
 969     {
 970       log_info( "pub  %s/%s %s  ",
 971                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
 972                 keystr_from_pk(pk), datestr_from_pk(pk) );
 973       if (uidnode)
 974         print_utf8_buffer (log_get_stream (),
 975                            uidnode->pkt->pkt.user_id->name,
 976                            uidnode->pkt->pkt.user_id->len );
 977       log_printf ("\n");
 978     }
 979
 980
 981   if (!uidnode )
 982     {
 983       if (!silent)
 984         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
 985       return 0;
 986     }
 987
 988   if (screener && screener (keyblock, screener_arg))
 989     {
 990       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
 991                  _("rejected by import screener"));
 992       return 0;
 993     }
 994
 995   if (opt.interactive && !silent)
 996     {
 997       if (is_status_enabled())
 998         print_import_check (pk, uidnode->pkt->pkt.user_id);
 999       merge_keys_and_selfsig (keyblock);
1000       tty_printf ("\n");
1001       show_basic_key_info (keyblock);
1002       tty_printf ("\n");
1003       if (!cpr_get_answer_is_yes ("import.okay",
1004                                   "Do you want to import this key? (y/N) "))
1005         return 0;
1006     }
1007
1008   collapse_uids(&keyblock);
1009
1010   /* Clean the key that we're about to import, to cut down on things
1011      that we have to clean later.  This has no practical impact on the
1012      end result, but does result in less logging which might confuse
1013      the user. */
1014   if (options&IMPORT_CLEAN)
1015     clean_key (keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
1016
1017   clear_kbnode_flags( keyblock );
1018
1019   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
1020       && opt.verbose)
1021     log_info (_("key %s: PKS subkey corruption repaired\n"),
1022               keystr_from_pk(pk));
1023
1024   rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
1025   if (rc )
1026     return rc== -1? 0:rc;
1027
1028   /* If we allow such a thing, mark unsigned uids as valid */
1029   if (opt.allow_non_selfsigned_uid)
1030     {
1031       for (node=keyblock; node; node = node->next )
1032         if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
1033           {
1034             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
1035                                       node->pkt->pkt.user_id->len,0);
1036             node->flag |= 1;
1037             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
1038                       keystr_from_pk(pk),user);
1039             xfree(user);
1040           }
1041     }
1042
1043   if (!delete_inv_parts( fname, keyblock, keyid, options ) )
1044     {
1045       if (!silent)
1046         {
1047           log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
1048           if (!opt.quiet )
1049             log_info(_("this may be caused by a missing self-signature\n"));
1050         }
1051       stats->no_user_id++;
1052       return 0;
1053     }
1054
1055   /* Do we have this key already in one of our pubrings ? */
1056   pk_orig = xmalloc_clear( sizeof *pk_orig );
1057   rc = get_pubkey_byfprint_fast (pk_orig, fpr2, fpr2len);
1058   if (rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
1059       && gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY )
1060     {
1061       if (!silent)
1062         log_error (_("key %s: public key not found: %s\n"),
1063                    keystr(keyid), gpg_strerror (rc));
1064     }
1065   else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
1066     {
1067       if (opt.verbose && !silent )
1068         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
1069       rc = 0;
1070       stats->skipped_new_keys++;
1071     }
1072   else if (rc )  /* Insert this key. */
1073     {
1074       KEYDB_HANDLE hd = keydb_new ();
1075
1076       rc = keydb_locate_writable (hd, NULL);
1077       if (rc)
1078         {
1079           log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
1080           keydb_release (hd);
1081           return GPG_ERR_GENERAL;
1082         }
1083       if (opt.verbose > 1 )
1084         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1085
1086       rc = keydb_insert_keyblock (hd, keyblock );
1087       if (rc)
1088         log_error (_("error writing keyring '%s': %s\n"),
1089                    keydb_get_resource_name (hd), gpg_strerror (rc));
1090       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1091         {
1092           /* This should not be possible since we delete the
1093              ownertrust when a key is deleted, but it can happen if
1094              the keyring and trustdb are out of sync.  It can also
1095              be made to happen with the trusted-key command and by
1096              importing and locally exported key. */
1097
1098           clear_ownertrusts (pk);
1099           if (non_self)
1100             revalidation_mark ();
1101         }
1102       keydb_release (hd);
1103
1104       /* We are ready.  */
1105       if (!opt.quiet && !silent)
1106         {
1107           char *p = get_user_id_byfpr_native (fpr2);
1108           log_info (_("key %s: public key \"%s\" imported\n"),
1109                     keystr(keyid), p);
1110           xfree(p);
1111         }
1112       if (is_status_enabled())
1113         {
1114           char *us = get_long_user_id_string( keyid );
1115           write_status_text( STATUS_IMPORTED, us );
1116           xfree(us);
1117           print_import_ok (pk, 1);
1118         }
1119       stats->imported++;
1120       new_key = 1;
1121     }
1122   else /* merge */
1123     {
1124       KEYDB_HANDLE hd;
1125       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1126
1127       /* Compare the original against the new key; just to be sure nothing
1128        * weird is going on */
1129       if (cmp_public_keys( pk_orig, pk ) )
1130         {
1131           if (!silent)
1132             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1133           goto leave;
1134         }
1135
1136       /* Now read the original keyblock again so that we can use
1137          that handle for updating the keyblock.  */
1138       hd = keydb_new ();
1139       keydb_disable_caching (hd);
1140       rc = keydb_search_fpr (hd, fpr2);
1141       if (rc )
1142         {
1143           log_error (_("key %s: can't locate original keyblock: %s\n"),
1144                      keystr(keyid), gpg_strerror (rc));
1145           keydb_release (hd);
1146           goto leave;
1147         }
1148       rc = keydb_get_keyblock (hd, &keyblock_orig);
1149       if (rc)
1150         {
1151           log_error (_("key %s: can't read original keyblock: %s\n"),
1152                      keystr(keyid), gpg_strerror (rc));
1153           keydb_release (hd);
1154           goto leave;
1155         }
1156
1157       /* Make sure the original direct key sigs are all sane.  */
1158       n_sigs_cleaned = fix_bad_direct_key_sigs (keyblock_orig, keyid);
1159       if (n_sigs_cleaned)
1160         commit_kbnode (&keyblock_orig);
1161
1162       /* and try to merge the block */
1163       clear_kbnode_flags( keyblock_orig );
1164       clear_kbnode_flags( keyblock );
1165       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1166       rc = merge_blocks( fname, keyblock_orig, keyblock,
1167                          keyid, &n_uids, &n_sigs, &n_subk );
1168       if (rc )
1169         {
1170           keydb_release (hd);
1171           goto leave;
1172         }
1173
1174       if ((options & IMPORT_CLEAN))
1175         clean_key (keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
1176                    &n_uids_cleaned,&n_sigs_cleaned);
1177
1178       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1179         {
1180           mod_key = 1;
1181           /* KEYBLOCK_ORIG has been updated; write */
1182           rc = keydb_update_keyblock (hd, keyblock_orig);
1183           if (rc)
1184             log_error (_("error writing keyring '%s': %s\n"),
1185                        keydb_get_resource_name (hd), gpg_strerror (rc) );
1186           else if (non_self)
1187             revalidation_mark ();
1188
1189           /* We are ready.  */
1190           if (!opt.quiet && !silent)
1191             {
1192               char *p = get_user_id_byfpr_native (fpr2);
1193               if (n_uids == 1 )
1194                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1195                           keystr(keyid),p);
1196               else if (n_uids )
1197                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
1198                           keystr(keyid),p,n_uids);
1199               if (n_sigs == 1 )
1200                 log_info( _("key %s: \"%s\" 1 new signature\n"),
1201                           keystr(keyid), p);
1202               else if (n_sigs )
1203                 log_info( _("key %s: \"%s\" %d new signatures\n"),
1204                           keystr(keyid), p, n_sigs );
1205               if (n_subk == 1 )
1206                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
1207                           keystr(keyid), p);
1208               else if (n_subk )
1209                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
1210                           keystr(keyid), p, n_subk );
1211               if (n_sigs_cleaned==1)
1212                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
1213                          keystr(keyid),p,n_sigs_cleaned);
1214               else if (n_sigs_cleaned)
1215                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
1216                          keystr(keyid),p,n_sigs_cleaned);
1217               if (n_uids_cleaned==1)
1218                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
1219                          keystr(keyid),p,n_uids_cleaned);
1220               else if (n_uids_cleaned)
1221                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
1222                          keystr(keyid),p,n_uids_cleaned);
1223               xfree(p);
1224             }
1225
1226           stats->n_uids +=n_uids;
1227           stats->n_sigs +=n_sigs;
1228           stats->n_subk +=n_subk;
1229           stats->n_sigs_cleaned +=n_sigs_cleaned;
1230           stats->n_uids_cleaned +=n_uids_cleaned;
1231
1232           if (is_status_enabled () && !silent)
1233             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
1234         }
1235       else
1236         {
1237           same_key = 1;
1238           if (is_status_enabled ())
1239             print_import_ok (pk, 0);
1240
1241           if (!opt.quiet && !silent)
1242             {
1243               char *p = get_user_id_byfpr_native (fpr2);
1244               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
1245               xfree(p);
1246             }
1247
1248           stats->unchanged++;
1249         }
1250
1251       keydb_release (hd); hd = NULL;
1252     }
1253
1254   leave:
1255   if (mod_key || new_key || same_key)
1256     {
1257       /* A little explanation for this: we fill in the fingerprint
1258          when importing keys as it can be useful to know the
1259          fingerprint in certain keyserver-related cases (a keyserver
1260          asked for a particular name, but the key doesn't have that
1261          name).  However, in cases where we're importing more than
1262          one key at a time, we cannot know which key to fingerprint.
1263          In these cases, rather than guessing, we do not
1264          fingerprinting at all, and we must hope the user ID on the
1265          keys are useful.  Note that we need to do this for new
1266          keys, merged keys and even for unchanged keys.  This is
1267          required because for example the --auto-key-locate feature
1268          may import an already imported key and needs to know the
1269          fingerprint of the key in all cases.  */
1270       if (fpr)
1271         {
1272           xfree (*fpr);
1273           /* Note that we need to compare against 0 here because
1274              COUNT gets only incremented after returning form this
1275              function.  */
1276           if (!stats->count)
1277             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
1278           else
1279             *fpr = NULL;
1280         }
1281     }
1282
1283   /* Now that the key is definitely incorporated into the keydb, we
1284      need to check if a designated revocation is present or if the
1285      prefs are not rational so we can warn the user. */
1286
1287   if (mod_key)
1288     {
1289       revocation_present (ctrl, keyblock_orig);
1290       if (!from_sk && have_secret_key_with_kid (keyid))
1291         check_prefs (ctrl, keyblock_orig);
1292     }
1293   else if (new_key)
1294     {
1295       revocation_present (ctrl, keyblock);
1296       if (!from_sk && have_secret_key_with_kid (keyid))
1297         check_prefs (ctrl, keyblock);
1298     }
1299
1300   release_kbnode( keyblock_orig );
1301   free_public_key( pk_orig );
1302
1303   return rc;
1304 }
1305
1306
1307 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
1308    function prints diagnostics and returns an error code.  If BATCH is
1309    true the secret keys are stored by gpg-agent in the transfer format
1310    (i.e. no re-protection and aksing for passphrases). */
1311 static gpg_error_t
1312 transfer_secret_keys (ctrl_t ctrl, struct stats_s *stats, kbnode_t sec_keyblock,
1313                       int batch)
1314 {
1315   gpg_error_t err = 0;
1316   void *kek = NULL;
1317   size_t keklen;
1318   kbnode_t ctx = NULL;
1319   kbnode_t node;
1320   PKT_public_key *main_pk, *pk;
1321   struct seckey_info *ski;
1322   int nskey;
1323   membuf_t mbuf;
1324   int i, j;
1325   void *format_args[2*PUBKEY_MAX_NSKEY];
1326   gcry_sexp_t skey, prot, tmpsexp;
1327   gcry_sexp_t curve = NULL;
1328   unsigned char *transferkey = NULL;
1329   size_t transferkeylen;
1330   gcry_cipher_hd_t cipherhd = NULL;
1331   unsigned char *wrappedkey = NULL;
1332   size_t wrappedkeylen;
1333   char *cache_nonce = NULL;
1334
1335   /* Get the current KEK.  */
1336   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
1337   if (err)
1338     {
1339       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1340       goto leave;
1341     }
1342
1343   /* Prepare a cipher context.  */
1344   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1345                           GCRY_CIPHER_MODE_AESWRAP, 0);
1346   if (!err)
1347     err = gcry_cipher_setkey (cipherhd, kek, keklen);
1348   if (err)
1349     goto leave;
1350   xfree (kek);
1351   kek = NULL;
1352
1353   main_pk = NULL;
1354   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
1355     {
1356       if (node->pkt->pkttype != PKT_SECRET_KEY
1357           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
1358         continue;
1359       pk = node->pkt->pkt.public_key;
1360       if (!main_pk)
1361         main_pk = pk;
1362
1363       /* Make sure the keyids are available.  */
1364       keyid_from_pk (pk, NULL);
1365       if (node->pkt->pkttype == PKT_SECRET_KEY)
1366         {
1367           pk->main_keyid[0] = pk->keyid[0];
1368           pk->main_keyid[1] = pk->keyid[1];
1369         }
1370       else
1371         {
1372           pk->main_keyid[0] = main_pk->keyid[0];
1373           pk->main_keyid[1] = main_pk->keyid[1];
1374         }
1375
1376
1377       ski = pk->seckey_info;
1378       if (!ski)
1379         BUG ();
1380
1381       stats->count++;
1382       stats->secret_read++;
1383
1384       /* We ignore stub keys.  The way we handle them in other parts
1385          of the code is by asking the agent whether any secret key is
1386          available for a given keyblock and then concluding that we
1387          have a secret key; all secret (sub)keys of the keyblock the
1388          agent does not know of are then stub keys.  This works also
1389          for card stub keys.  The learn command or the card-status
1390          command may be used to check with the agent whether a card
1391          has been inserted and a stub key is in turn generated by the
1392          agent.  */
1393       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1394         continue;
1395
1396       /* Convert our internal secret key object into an S-expression.  */
1397       nskey = pubkey_get_nskey (pk->pubkey_algo);
1398       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1399         {
1400           err = gpg_error (GPG_ERR_BAD_SECKEY);
1401           log_error ("internal error: %s\n", gpg_strerror (err));
1402           goto leave;
1403         }
1404
1405       init_membuf (&mbuf, 50);
1406       put_membuf_str (&mbuf, "(skey");
1407       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1408           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1409           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1410         {
1411           /* The ECC case.  */
1412           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
1413           if (!curvestr)
1414             err = gpg_error_from_syserror ();
1415           else
1416             {
1417               err = gcry_sexp_build (&curve, NULL, "(curve %s)", curvestr);
1418               xfree (curvestr);
1419               if (!err)
1420                 {
1421                   j = 0;
1422                   /* Append the public key element Q.  */
1423                   put_membuf_str (&mbuf, " _ %m");
1424                   format_args[j++] = pk->pkey + 1;
1425
1426                   /* Append the secret key element D.  For ECDH we
1427                      skip PKEY[2] because this holds the KEK which is
1428                      not needed by gpg-agent.  */
1429                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1430                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1431                     put_membuf_str (&mbuf, " e %m");
1432                   else
1433                     put_membuf_str (&mbuf, " _ %m");
1434                   format_args[j++] = pk->pkey + i;
1435                 }
1436             }
1437         }
1438       else
1439         {
1440           /* Standard case for the old (non-ECC) algorithms.  */
1441           for (i=j=0; i < nskey; i++)
1442             {
1443               if (!pk->pkey[i])
1444                 continue; /* Protected keys only have NPKEY+1 elements.  */
1445
1446               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1447                 put_membuf_str (&mbuf, " e %m");
1448               else
1449                 put_membuf_str (&mbuf, " _ %m");
1450               format_args[j++] = pk->pkey + i;
1451             }
1452         }
1453       put_membuf_str (&mbuf, ")");
1454       put_membuf (&mbuf, "", 1);
1455       if (err)
1456         xfree (get_membuf (&mbuf, NULL));
1457       else
1458         {
1459           char *format = get_membuf (&mbuf, NULL);
1460           if (!format)
1461             err = gpg_error_from_syserror ();
1462           else
1463             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1464           xfree (format);
1465         }
1466       if (err)
1467         {
1468           log_error ("error building skey array: %s\n", gpg_strerror (err));
1469           goto leave;
1470         }
1471
1472       if (ski->is_protected)
1473         {
1474           char countbuf[35];
1475
1476           /* Note that the IVLEN may be zero if we are working on a
1477              dummy key.  We can't express that in an S-expression and
1478              thus we send dummy data for the IV.  */
1479           snprintf (countbuf, sizeof countbuf, "%lu",
1480                     (unsigned long)ski->s2k.count);
1481           err = gcry_sexp_build
1482             (&prot, NULL,
1483              " (protection %s %s %b %d %s %b %s)\n",
1484              ski->sha1chk? "sha1":"sum",
1485              openpgp_cipher_algo_name (ski->algo),
1486              ski->ivlen? (int)ski->ivlen:1,
1487              ski->ivlen? ski->iv: (const unsigned char*)"X",
1488              ski->s2k.mode,
1489              openpgp_md_algo_name (ski->s2k.hash_algo),
1490              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1491              countbuf);
1492         }
1493       else
1494         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1495
1496       tmpsexp = NULL;
1497       xfree (transferkey);
1498       transferkey = NULL;
1499       if (!err)
1500         err = gcry_sexp_build (&tmpsexp, NULL,
1501                                "(openpgp-private-key\n"
1502                                " (version %d)\n"
1503                                " (algo %s)\n"
1504                                " %S%S\n"
1505                                " (csum %d)\n"
1506                                " %S)\n",
1507                                pk->version,
1508                                openpgp_pk_algo_name (pk->pubkey_algo),
1509                                curve, skey,
1510                                (int)(unsigned long)ski->csum, prot);
1511       gcry_sexp_release (skey);
1512       gcry_sexp_release (prot);
1513       if (!err)
1514         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1515       gcry_sexp_release (tmpsexp);
1516       if (err)
1517         {
1518           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1519           goto leave;
1520         }
1521
1522       /* Wrap the key.  */
1523       wrappedkeylen = transferkeylen + 8;
1524       xfree (wrappedkey);
1525       wrappedkey = xtrymalloc (wrappedkeylen);
1526       if (!wrappedkey)
1527         err = gpg_error_from_syserror ();
1528       else
1529         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1530                                    transferkey, transferkeylen);
1531       if (err)
1532         goto leave;
1533       xfree (transferkey);
1534       transferkey = NULL;
1535
1536       /* Send the wrapped key to the agent.  */
1537       {
1538         char *desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_IMPORT, 1);
1539         err = agent_import_key (ctrl, desc, &cache_nonce,
1540                                 wrappedkey, wrappedkeylen, batch);
1541         xfree (desc);
1542       }
1543       if (!err)
1544         {
1545           if (opt.verbose)
1546             log_info (_("key %s: secret key imported\n"),
1547                       keystr_from_pk_with_sub (main_pk, pk));
1548           stats->secret_imported++;
1549         }
1550       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
1551         {
1552           if (opt.verbose)
1553             log_info (_("key %s: secret key already exists\n"),
1554                       keystr_from_pk_with_sub (main_pk, pk));
1555           err = 0;
1556           stats->secret_dups++;
1557         }
1558       else
1559         {
1560           log_error (_("key %s: error sending to agent: %s\n"),
1561                      keystr_from_pk_with_sub (main_pk, pk),
1562                      gpg_strerror (err));
1563           if (gpg_err_code (err) == GPG_ERR_CANCELED
1564               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1565             break; /* Don't try the other subkeys.  */
1566         }
1567     }
1568
1569  leave:
1570   gcry_sexp_release (curve);
1571   xfree (cache_nonce);
1572   xfree (wrappedkey);
1573   xfree (transferkey);
1574   gcry_cipher_close (cipherhd);
1575   xfree (kek);
1576   return err;
1577 }
1578
1579
1580 /* Walk a secret keyblock and produce a public keyblock out of it.
1581    Returns a new node or NULL on error. */
1582 static kbnode_t
1583 sec_to_pub_keyblock (kbnode_t sec_keyblock)
1584 {
1585   kbnode_t pub_keyblock = NULL;
1586   kbnode_t ctx = NULL;
1587   kbnode_t secnode, pubnode;
1588
1589   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
1590     {
1591       if (secnode->pkt->pkttype == PKT_SECRET_KEY
1592           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
1593         {
1594           /* Make a public key.  */
1595           PACKET *pkt;
1596           PKT_public_key *pk;
1597
1598           pkt = xtrycalloc (1, sizeof *pkt);
1599           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
1600           if (!pk)
1601             {
1602               xfree (pkt);
1603               release_kbnode (pub_keyblock);
1604               return NULL;
1605             }
1606           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
1607             pkt->pkttype = PKT_PUBLIC_KEY;
1608           else
1609             pkt->pkttype = PKT_PUBLIC_SUBKEY;
1610           pkt->pkt.public_key = pk;
1611
1612           pubnode = new_kbnode (pkt);
1613         }
1614       else
1615         {
1616           pubnode = clone_kbnode (secnode);
1617         }
1618
1619       if (!pub_keyblock)
1620         pub_keyblock = pubnode;
1621       else
1622         add_kbnode (pub_keyblock, pubnode);
1623     }
1624
1625   return pub_keyblock;
1626 }
1627
1628 /****************
1629  * Ditto for secret keys.  Handling is simpler than for public keys.
1630  * We allow secret key importing only when allow is true, this is so
1631  * that a secret key can not be imported accidently and thereby tampering
1632  * with the trust calculation.
1633  */
1634 static int
1635 import_secret_one (ctrl_t ctrl, const char *fname, kbnode_t keyblock,
1636                    struct stats_s *stats, int batch, unsigned int options,
1637                    int for_migration,
1638                    import_screener_t screener, void *screener_arg)
1639 {
1640   PKT_public_key *pk;
1641   struct seckey_info *ski;
1642   kbnode_t node, uidnode;
1643   u32 keyid[2];
1644   int rc = 0;
1645   int nr_prev;
1646   kbnode_t pub_keyblock;
1647   char pkstrbuf[PUBKEY_STRING_SIZE];
1648
1649   /* Get the key and print some info about it */
1650   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1651   if (!node)
1652     BUG ();
1653
1654   pk = node->pkt->pkt.public_key;
1655
1656   keyid_from_pk (pk, keyid);
1657   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
1658
1659   if (screener && screener (keyblock, screener_arg))
1660     {
1661       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
1662                  _("rejected by import screener"));
1663       return 0;
1664   }
1665
1666   if (opt.verbose && !for_migration)
1667     {
1668       log_info ("sec  %s/%s %s   ",
1669                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1670                 keystr_from_pk (pk), datestr_from_pk (pk));
1671       if (uidnode)
1672         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
1673                            uidnode->pkt->pkt.user_id->len);
1674       log_printf ("\n");
1675     }
1676   stats->secret_read++;
1677
1678   if ((options & IMPORT_NO_SECKEY))
1679     {
1680       if (!for_migration)
1681         log_error (_("importing secret keys not allowed\n"));
1682       return 0;
1683     }
1684
1685   if (!uidnode)
1686     {
1687       if (!for_migration)
1688         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
1689       return 0;
1690     }
1691
1692   ski = pk->seckey_info;
1693   if (!ski)
1694     {
1695       /* Actually an internal error.  */
1696       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
1697       return 0;
1698     }
1699
1700   /* A quick check to not import keys with an invalid protection
1701      cipher algorithm (only checks the primary key, though).  */
1702   if (ski->algo > 110)
1703     {
1704       if (!for_migration)
1705         log_error (_("key %s: secret key with invalid cipher %d"
1706                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
1707       return 0;
1708     }
1709
1710 #ifdef ENABLE_SELINUX_HACKS
1711   if (1)
1712     {
1713       /* We don't allow to import secret keys because that may be used
1714          to put a secret key into the keyring and the user might later
1715          be tricked into signing stuff with that key.  */
1716       log_error (_("importing secret keys not allowed\n"));
1717       return 0;
1718     }
1719 #endif
1720
1721   clear_kbnode_flags (keyblock);
1722
1723   nr_prev = stats->skipped_new_keys;
1724
1725   /* Make a public key out of the key. */
1726   pub_keyblock = sec_to_pub_keyblock (keyblock);
1727   if (!pub_keyblock)
1728     log_error ("key %s: failed to create public key from secret key\n",
1729                    keystr_from_pk (pk));
1730   else
1731     {
1732       /* Note that this outputs an IMPORT_OK status message for the
1733          public key block, and below we will output another one for
1734          the secret keys.  FIXME?  */
1735       import_one (ctrl, fname, pub_keyblock, stats,
1736                   NULL, NULL, options, 1, for_migration,
1737                   screener, screener_arg);
1738
1739       /* Fixme: We should check for an invalid keyblock and
1740          cancel the secret key import in this case.  */
1741       release_kbnode (pub_keyblock);
1742
1743       /* At least we cancel the secret key import when the public key
1744          import was skipped due to MERGE_ONLY option and a new
1745          key.  */
1746       if (stats->skipped_new_keys <= nr_prev)
1747         {
1748           /* Read the keyblock again to get the effects of a merge.  */
1749           /* Fixme: we should do this based on the fingerprint or
1750              even better let import_one return the merged
1751              keyblock.  */
1752           node = get_pubkeyblock (keyid);
1753           if (!node)
1754             log_error ("key %s: failed to re-lookup public key\n",
1755                        keystr_from_pk (pk));
1756           else
1757             {
1758               nr_prev = stats->secret_imported;
1759               if (!transfer_secret_keys (ctrl, stats, keyblock, batch))
1760                 {
1761                   int status = 16;
1762                   if (!opt.quiet)
1763                     log_info (_("key %s: secret key imported\n"),
1764                               keystr_from_pk (pk));
1765                   if (stats->secret_imported > nr_prev)
1766                     status |= 1;
1767                   if (is_status_enabled ())
1768                     print_import_ok (pk, status);
1769                   check_prefs (ctrl, node);
1770                 }
1771               release_kbnode (node);
1772             }
1773         }
1774     }
1775
1776   return rc;
1777 }
1778
1779
1780 /****************
1781  * Import a revocation certificate; this is a single signature packet.
1782  */
1783 static int
1784 import_revoke_cert( const char *fname, kbnode_t node, struct stats_s *stats )
1785 {
1786   PKT_public_key *pk = NULL;
1787   kbnode_t onode;
1788   kbnode_t keyblock = NULL;
1789   KEYDB_HANDLE hd = NULL;
1790   u32 keyid[2];
1791   int rc = 0;
1792
1793   (void)fname;
1794
1795   assert( !node->next );
1796   assert( node->pkt->pkttype == PKT_SIGNATURE );
1797   assert( node->pkt->pkt.signature->sig_class == 0x20 );
1798
1799   keyid[0] = node->pkt->pkt.signature->keyid[0];
1800   keyid[1] = node->pkt->pkt.signature->keyid[1];
1801
1802   pk = xmalloc_clear( sizeof *pk );
1803   rc = get_pubkey( pk, keyid );
1804   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
1805     {
1806       log_error(_("key %s: no public key -"
1807                   " can't apply revocation certificate\n"), keystr(keyid));
1808       rc = 0;
1809       goto leave;
1810     }
1811   else if (rc )
1812     {
1813       log_error(_("key %s: public key not found: %s\n"),
1814                 keystr(keyid), gpg_strerror (rc));
1815       goto leave;
1816     }
1817
1818   /* Read the original keyblock. */
1819   hd = keydb_new ();
1820   {
1821     byte afp[MAX_FINGERPRINT_LEN];
1822     size_t an;
1823
1824     fingerprint_from_pk (pk, afp, &an);
1825     while (an < MAX_FINGERPRINT_LEN)
1826       afp[an++] = 0;
1827     rc = keydb_search_fpr (hd, afp);
1828   }
1829   if (rc)
1830     {
1831       log_error (_("key %s: can't locate original keyblock: %s\n"),
1832                  keystr(keyid), gpg_strerror (rc));
1833       goto leave;
1834     }
1835   rc = keydb_get_keyblock (hd, &keyblock );
1836   if (rc)
1837     {
1838       log_error (_("key %s: can't read original keyblock: %s\n"),
1839                  keystr(keyid), gpg_strerror (rc));
1840       goto leave;
1841     }
1842
1843   /* it is okay, that node is not in keyblock because
1844    * check_key_signature works fine for sig_class 0x20 in this
1845    * special case. */
1846   rc = check_key_signature( keyblock, node, NULL);
1847   if (rc )
1848     {
1849       log_error( _("key %s: invalid revocation certificate"
1850                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
1851       goto leave;
1852     }
1853
1854   /* check whether we already have this */
1855   for(onode=keyblock->next; onode; onode=onode->next ) {
1856     if (onode->pkt->pkttype == PKT_USER_ID )
1857       break;
1858     else if (onode->pkt->pkttype == PKT_SIGNATURE
1859              && !cmp_signatures(node->pkt->pkt.signature,
1860                                 onode->pkt->pkt.signature))
1861       {
1862         rc = 0;
1863         goto leave; /* yes, we already know about it */
1864       }
1865   }
1866
1867   /* insert it */
1868   insert_kbnode( keyblock, clone_kbnode(node), 0 );
1869
1870   /* and write the keyblock back */
1871   rc = keydb_update_keyblock (hd, keyblock );
1872   if (rc)
1873     log_error (_("error writing keyring '%s': %s\n"),
1874                keydb_get_resource_name (hd), gpg_strerror (rc) );
1875   keydb_release (hd);
1876   hd = NULL;
1877
1878   /* we are ready */
1879   if (!opt.quiet )
1880     {
1881       char *p=get_user_id_native (keyid);
1882       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1883                 keystr(keyid),p);
1884       xfree(p);
1885     }
1886   stats->n_revoc++;
1887
1888   /* If the key we just revoked was ultimately trusted, remove its
1889      ultimate trust.  This doesn't stop the user from putting the
1890      ultimate trust back, but is a reasonable solution for now. */
1891   if(get_ownertrust(pk)==TRUST_ULTIMATE)
1892     clear_ownertrusts(pk);
1893
1894   revalidation_mark ();
1895
1896  leave:
1897   keydb_release (hd);
1898   release_kbnode( keyblock );
1899   free_public_key( pk );
1900   return rc;
1901 }
1902
1903
1904 /*
1905  * Loop over the keyblock and check all self signatures.
1906  * Mark all user-ids with a self-signature by setting flag bit 0.
1907  * Mark all user-ids with an invalid self-signature by setting bit 1.
1908  * This works also for subkeys, here the subkey is marked.  Invalid or
1909  * extra subkey sigs (binding or revocation) are marked for deletion.
1910  * non_self is set to true if there are any sigs other than self-sigs
1911  * in this keyblock.
1912  */
1913 static int
1914 chk_self_sigs (const char *fname, kbnode_t keyblock,
1915                PKT_public_key *pk, u32 *keyid, int *non_self )
1916 {
1917   kbnode_t n, knode = NULL;
1918   PKT_signature *sig;
1919   int rc;
1920   u32 bsdate=0, rsdate=0;
1921   kbnode_t bsnode = NULL, rsnode = NULL;
1922
1923   (void)fname;
1924   (void)pk;
1925
1926   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
1927     {
1928       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1929         {
1930           knode = n;
1931           bsdate = 0;
1932           rsdate = 0;
1933           bsnode = NULL;
1934           rsnode = NULL;
1935           continue;
1936         }
1937
1938       if ( n->pkt->pkttype != PKT_SIGNATURE )
1939         continue;
1940
1941       sig = n->pkt->pkt.signature;
1942       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
1943         {
1944           *non_self = 1;
1945           continue;
1946         }
1947
1948       /* This just caches the sigs for later use.  That way we
1949          import a fully-cached key which speeds things up. */
1950       if (!opt.no_sig_cache)
1951         check_key_signature (keyblock, n, NULL);
1952
1953       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1954         {
1955           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1956           if ( !unode )
1957             {
1958               log_error( _("key %s: no user ID for signature\n"),
1959                          keystr(keyid));
1960               return -1;  /* The complete keyblock is invalid.  */
1961             }
1962
1963           /* If it hasn't been marked valid yet, keep trying.  */
1964           if (!(unode->flag&1))
1965             {
1966               rc = check_key_signature (keyblock, n, NULL);
1967               if ( rc )
1968                 {
1969                   if ( opt.verbose )
1970                     {
1971                       char *p = utf8_to_native
1972                         (unode->pkt->pkt.user_id->name,
1973                          strlen (unode->pkt->pkt.user_id->name),0);
1974                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
1975                                 _("key %s: unsupported public key "
1976                                   "algorithm on user ID \"%s\"\n"):
1977                                 _("key %s: invalid self-signature "
1978                                   "on user ID \"%s\"\n"),
1979                                 keystr (keyid),p);
1980                       xfree (p);
1981                     }
1982                 }
1983               else
1984                 unode->flag |= 1; /* Mark that signature checked. */
1985             }
1986         }
1987       else if (IS_KEY_SIG (sig))
1988         {
1989           rc = check_key_signature (keyblock, n, NULL);
1990           if ( rc )
1991             {
1992               if (opt.verbose)
1993                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
1994                           _("key %s: unsupported public key algorithm\n"):
1995                           _("key %s: invalid direct key signature\n"),
1996                           keystr (keyid));
1997               n->flag |= 4;
1998             }
1999         }
2000       else if ( IS_SUBKEY_SIG (sig) )
2001         {
2002           /* Note that this works based solely on the timestamps like
2003              the rest of gpg.  If the standard gets revocation
2004              targets, this may need to be revised.  */
2005
2006           if ( !knode )
2007             {
2008               if (opt.verbose)
2009                 log_info (_("key %s: no subkey for key binding\n"),
2010                           keystr (keyid));
2011               n->flag |= 4; /* delete this */
2012             }
2013           else
2014             {
2015               rc = check_key_signature (keyblock, n, NULL);
2016               if ( rc )
2017                 {
2018                   if (opt.verbose)
2019                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2020                               _("key %s: unsupported public key"
2021                                 " algorithm\n"):
2022                               _("key %s: invalid subkey binding\n"),
2023                               keystr (keyid));
2024                   n->flag |= 4;
2025                 }
2026               else
2027                 {
2028                   /* It's valid, so is it newer? */
2029                   if (sig->timestamp >= bsdate)
2030                     {
2031                       knode->flag |= 1;  /* The subkey is valid.  */
2032                       if (bsnode)
2033                         {
2034                           /* Delete the last binding sig since this
2035                              one is newer */
2036                           bsnode->flag |= 4;
2037                           if (opt.verbose)
2038                             log_info (_("key %s: removed multiple subkey"
2039                                         " binding\n"),keystr(keyid));
2040                         }
2041
2042                       bsnode = n;
2043                       bsdate = sig->timestamp;
2044                     }
2045                   else
2046                     n->flag |= 4; /* older */
2047                 }
2048             }
2049         }
2050       else if ( IS_SUBKEY_REV (sig) )
2051         {
2052           /* We don't actually mark the subkey as revoked right now,
2053              so just check that the revocation sig is the most recent
2054              valid one.  Note that we don't care if the binding sig is
2055              newer than the revocation sig.  See the comment in
2056              getkey.c:merge_selfsigs_subkey for more.  */
2057           if ( !knode )
2058             {
2059               if (opt.verbose)
2060                 log_info (_("key %s: no subkey for key revocation\n"),
2061                           keystr(keyid));
2062               n->flag |= 4; /* delete this */
2063             }
2064           else
2065             {
2066               rc = check_key_signature (keyblock, n, NULL);
2067               if ( rc )
2068                 {
2069                   if(opt.verbose)
2070                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2071                               _("key %s: unsupported public"
2072                                 " key algorithm\n"):
2073                               _("key %s: invalid subkey revocation\n"),
2074                               keystr(keyid));
2075                   n->flag |= 4;
2076                 }
2077               else
2078                 {
2079                   /* It's valid, so is it newer? */
2080                   if (sig->timestamp >= rsdate)
2081                     {
2082                       if (rsnode)
2083                         {
2084                           /* Delete the last revocation sig since
2085                              this one is newer.  */
2086                           rsnode->flag |= 4;
2087                           if (opt.verbose)
2088                             log_info (_("key %s: removed multiple subkey"
2089                                         " revocation\n"),keystr(keyid));
2090                         }
2091
2092                       rsnode = n;
2093                       rsdate = sig->timestamp;
2094                     }
2095                   else
2096                     n->flag |= 4; /* older */
2097                 }
2098             }
2099         }
2100     }
2101
2102   return 0;
2103 }
2104
2105
2106 /****************
2107  * delete all parts which are invalid and those signatures whose
2108  * public key algorithm is not available in this implemenation;
2109  * but consider RSA as valid, because parse/build_packets knows
2110  * about it.
2111  * returns: true if at least one valid user-id is left over.
2112  */
2113 static int
2114 delete_inv_parts( const char *fname, kbnode_t keyblock,
2115                   u32 *keyid, unsigned int options)
2116 {
2117   kbnode_t node;
2118   int nvalid=0, uid_seen=0, subkey_seen=0;
2119
2120   (void)fname;
2121
2122   for (node=keyblock->next; node; node = node->next )
2123     {
2124       if (node->pkt->pkttype == PKT_USER_ID)
2125         {
2126           uid_seen = 1;
2127           if ((node->flag & 2) || !(node->flag & 1) )
2128             {
2129               if (opt.verbose )
2130                 {
2131                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2132                                          node->pkt->pkt.user_id->len,0);
2133                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2134                             keystr(keyid),p);
2135                   xfree(p);
2136                 }
2137               delete_kbnode( node ); /* the user-id */
2138               /* and all following packets up to the next user-id */
2139               while (node->next
2140                      && node->next->pkt->pkttype != PKT_USER_ID
2141                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2142                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2143                 delete_kbnode( node->next );
2144                 node = node->next;
2145               }
2146             }
2147           else
2148             nvalid++;
2149         }
2150       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2151                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2152         {
2153           if ((node->flag & 2) || !(node->flag & 1) )
2154             {
2155               if (opt.verbose )
2156                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2157
2158               delete_kbnode( node ); /* the subkey */
2159               /* and all following signature packets */
2160               while (node->next
2161                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2162                 delete_kbnode( node->next );
2163                 node = node->next;
2164               }
2165             }
2166           else
2167             subkey_seen = 1;
2168         }
2169       else if (node->pkt->pkttype == PKT_SIGNATURE
2170                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2171                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2172         {
2173           delete_kbnode( node ); /* build_packet() can't handle this */
2174         }
2175       else if (node->pkt->pkttype == PKT_SIGNATURE
2176                && !node->pkt->pkt.signature->flags.exportable
2177                && !(options&IMPORT_LOCAL_SIGS)
2178                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2179         {
2180           /* here we violate the rfc a bit by still allowing
2181            * to import non-exportable signature when we have the
2182            * the secret key used to create this signature - it
2183            * seems that this makes sense */
2184           if(opt.verbose)
2185             log_info( _("key %s: non exportable signature"
2186                         " (class 0x%02X) - skipped\n"),
2187                       keystr(keyid), node->pkt->pkt.signature->sig_class );
2188           delete_kbnode( node );
2189         }
2190       else if (node->pkt->pkttype == PKT_SIGNATURE
2191                && node->pkt->pkt.signature->sig_class == 0x20)
2192         {
2193           if (uid_seen )
2194             {
2195               if(opt.verbose)
2196                 log_info( _("key %s: revocation certificate"
2197                             " at wrong place - skipped\n"),keystr(keyid));
2198               delete_kbnode( node );
2199             }
2200           else
2201             {
2202               /* If the revocation cert is from a different key than
2203                  the one we're working on don't check it - it's
2204                  probably from a revocation key and won't be
2205                  verifiable with this key anyway. */
2206
2207               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
2208                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
2209                 {
2210                   int rc = check_key_signature( keyblock, node, NULL);
2211                   if (rc )
2212                     {
2213                       if(opt.verbose)
2214                         log_info( _("key %s: invalid revocation"
2215                                     " certificate: %s - skipped\n"),
2216                                   keystr(keyid), gpg_strerror (rc));
2217                       delete_kbnode( node );
2218                     }
2219                 }
2220             }
2221         }
2222       else if (node->pkt->pkttype == PKT_SIGNATURE
2223                && (node->pkt->pkt.signature->sig_class == 0x18
2224                    || node->pkt->pkt.signature->sig_class == 0x28)
2225                && !subkey_seen )
2226         {
2227           if(opt.verbose)
2228             log_info( _("key %s: subkey signature"
2229                         " in wrong place - skipped\n"), keystr(keyid));
2230           delete_kbnode( node );
2231         }
2232       else if (node->pkt->pkttype == PKT_SIGNATURE
2233                && !IS_CERT(node->pkt->pkt.signature))
2234         {
2235           if(opt.verbose)
2236             log_info(_("key %s: unexpected signature class (0x%02X) -"
2237                        " skipped\n"),keystr(keyid),
2238                      node->pkt->pkt.signature->sig_class);
2239           delete_kbnode(node);
2240           }
2241       else if ((node->flag & 4) ) /* marked for deletion */
2242         delete_kbnode( node );
2243     }
2244
2245   /* note: because keyblock is the public key, it is never marked
2246    * for deletion and so keyblock cannot change */
2247   commit_kbnode( &keyblock );
2248   return nvalid;
2249 }
2250
2251
2252 /****************
2253  * It may happen that the imported keyblock has duplicated user IDs.
2254  * We check this here and collapse those user IDs together with their
2255  * sigs into one.
2256  * Returns: True if the keyblock has changed.
2257  */
2258 int
2259 collapse_uids( kbnode_t *keyblock )
2260 {
2261   kbnode_t uid1;
2262   int any=0;
2263
2264   for(uid1=*keyblock;uid1;uid1=uid1->next)
2265     {
2266       kbnode_t uid2;
2267
2268       if(is_deleted_kbnode(uid1))
2269         continue;
2270
2271       if(uid1->pkt->pkttype!=PKT_USER_ID)
2272         continue;
2273
2274       for(uid2=uid1->next;uid2;uid2=uid2->next)
2275         {
2276           if(is_deleted_kbnode(uid2))
2277             continue;
2278
2279           if(uid2->pkt->pkttype!=PKT_USER_ID)
2280             continue;
2281
2282           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2283                           uid2->pkt->pkt.user_id)==0)
2284             {
2285               /* We have a duplicated uid */
2286               kbnode_t sig1,last;
2287
2288               any=1;
2289
2290               /* Now take uid2's signatures, and attach them to
2291                  uid1 */
2292               for(last=uid2;last->next;last=last->next)
2293                 {
2294                   if(is_deleted_kbnode(last))
2295                     continue;
2296
2297                   if(last->next->pkt->pkttype==PKT_USER_ID
2298                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2299                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2300                     break;
2301                 }
2302
2303               /* Snip out uid2 */
2304               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2305
2306               /* Now put uid2 in place as part of uid1 */
2307               last->next=uid1->next;
2308               uid1->next=uid2;
2309               delete_kbnode(uid2);
2310
2311               /* Now dedupe uid1 */
2312               for(sig1=uid1->next;sig1;sig1=sig1->next)
2313                 {
2314                   kbnode_t sig2;
2315
2316                   if(is_deleted_kbnode(sig1))
2317                     continue;
2318
2319                   if(sig1->pkt->pkttype==PKT_USER_ID
2320                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2321                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2322                     break;
2323
2324                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2325                     continue;
2326
2327                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2328                     {
2329                       if(is_deleted_kbnode(sig2))
2330                         continue;
2331
2332                       if(sig2->pkt->pkttype==PKT_USER_ID
2333                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2334                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2335                         break;
2336
2337                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2338                         continue;
2339
2340                       if(cmp_signatures(sig1->pkt->pkt.signature,
2341                                         sig2->pkt->pkt.signature)==0)
2342                         {
2343                           /* We have a match, so delete the second
2344                              signature */
2345                           delete_kbnode(sig2);
2346                           sig2=last;
2347                         }
2348                     }
2349                 }
2350             }
2351         }
2352     }
2353
2354   commit_kbnode(keyblock);
2355
2356   if(any && !opt.quiet)
2357     {
2358       const char *key="???";
2359
2360       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2361         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2362       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2363         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2364
2365       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2366     }
2367
2368   return any;
2369 }
2370
2371
2372 /* Check for a 0x20 revocation from a revocation key that is not
2373    present.  This may be called without the benefit of merge_xxxx so
2374    you can't rely on pk->revkey and friends. */
2375 static void
2376 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2377 {
2378   kbnode_t onode, inode;
2379   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2380
2381   for(onode=keyblock->next;onode;onode=onode->next)
2382     {
2383       /* If we reach user IDs, we're done. */
2384       if(onode->pkt->pkttype==PKT_USER_ID)
2385         break;
2386
2387       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2388          onode->pkt->pkt.signature->sig_class==0x1F &&
2389          onode->pkt->pkt.signature->revkey)
2390         {
2391           int idx;
2392           PKT_signature *sig=onode->pkt->pkt.signature;
2393
2394           for(idx=0;idx<sig->numrevkeys;idx++)
2395             {
2396               u32 keyid[2];
2397
2398               keyid_from_fingerprint(sig->revkey[idx]->fpr,
2399                                      MAX_FINGERPRINT_LEN,keyid);
2400
2401               for(inode=keyblock->next;inode;inode=inode->next)
2402                 {
2403                   /* If we reach user IDs, we're done. */
2404                   if(inode->pkt->pkttype==PKT_USER_ID)
2405                     break;
2406
2407                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2408                      inode->pkt->pkt.signature->sig_class==0x20 &&
2409                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2410                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2411                     {
2412                       /* Okay, we have a revocation key, and a
2413                          revocation issued by it.  Do we have the key
2414                          itself? */
2415                       int rc;
2416
2417                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
2418                                                    MAX_FINGERPRINT_LEN);
2419                       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2420                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2421                         {
2422                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2423
2424                           /* No, so try and get it */
2425                           if(opt.keyserver
2426                              && (opt.keyserver_options.options
2427                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
2428                             {
2429                               log_info(_("WARNING: key %s may be revoked:"
2430                                          " fetching revocation key %s\n"),
2431                                        tempkeystr,keystr(keyid));
2432                               keyserver_import_fprint (ctrl,
2433                                                        sig->revkey[idx]->fpr,
2434                                                        MAX_FINGERPRINT_LEN,
2435                                                        opt.keyserver);
2436
2437                               /* Do we have it now? */
2438                               rc=get_pubkey_byfprint_fast (NULL,
2439                                                      sig->revkey[idx]->fpr,
2440                                                      MAX_FINGERPRINT_LEN);
2441                             }
2442
2443                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2444                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2445                             log_info(_("WARNING: key %s may be revoked:"
2446                                        " revocation key %s not present.\n"),
2447                                      tempkeystr,keystr(keyid));
2448
2449                           xfree(tempkeystr);
2450                         }
2451                     }
2452                 }
2453             }
2454         }
2455     }
2456 }
2457
2458
2459 /*
2460  * compare and merge the blocks
2461  *
2462  * o compare the signatures: If we already have this signature, check
2463  *   that they compare okay; if not, issue a warning and ask the user.
2464  * o Simply add the signature.  Can't verify here because we may not have
2465  *   the signature's public key yet; verification is done when putting it
2466  *   into the trustdb, which is done automagically as soon as this pubkey
2467  *   is used.
2468  * Note: We indicate newly inserted packets with flag bit 0
2469  */
2470 static int
2471 merge_blocks (const char *fname, kbnode_t keyblock_orig, kbnode_t keyblock,
2472               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2473 {
2474   kbnode_t onode, node;
2475   int rc, found;
2476
2477   /* 1st: handle revocation certificates */
2478   for (node=keyblock->next; node; node=node->next )
2479     {
2480       if (node->pkt->pkttype == PKT_USER_ID )
2481         break;
2482       else if (node->pkt->pkttype == PKT_SIGNATURE
2483                && node->pkt->pkt.signature->sig_class == 0x20)
2484         {
2485           /* check whether we already have this */
2486           found = 0;
2487           for (onode=keyblock_orig->next; onode; onode=onode->next)
2488             {
2489               if (onode->pkt->pkttype == PKT_USER_ID )
2490                 break;
2491               else if (onode->pkt->pkttype == PKT_SIGNATURE
2492                        && onode->pkt->pkt.signature->sig_class == 0x20
2493                        && !cmp_signatures(onode->pkt->pkt.signature,
2494                                           node->pkt->pkt.signature))
2495                 {
2496                   found = 1;
2497                   break;
2498                 }
2499             }
2500           if (!found)
2501             {
2502               kbnode_t n2 = clone_kbnode(node);
2503               insert_kbnode( keyblock_orig, n2, 0 );
2504               n2->flag |= 1;
2505               ++*n_sigs;
2506               if(!opt.quiet)
2507                 {
2508                   char *p=get_user_id_native (keyid);
2509                   log_info(_("key %s: \"%s\" revocation"
2510                              " certificate added\n"), keystr(keyid),p);
2511                   xfree(p);
2512                 }
2513             }
2514         }
2515     }
2516
2517   /* 2nd: merge in any direct key (0x1F) sigs */
2518   for(node=keyblock->next; node; node=node->next)
2519     {
2520       if (node->pkt->pkttype == PKT_USER_ID )
2521         break;
2522       else if (node->pkt->pkttype == PKT_SIGNATURE
2523                && node->pkt->pkt.signature->sig_class == 0x1F)
2524         {
2525           /* check whether we already have this */
2526           found = 0;
2527           for (onode=keyblock_orig->next; onode; onode=onode->next)
2528             {
2529               if (onode->pkt->pkttype == PKT_USER_ID)
2530                 break;
2531               else if (onode->pkt->pkttype == PKT_SIGNATURE
2532                        && onode->pkt->pkt.signature->sig_class == 0x1F
2533                        && !cmp_signatures(onode->pkt->pkt.signature,
2534                                           node->pkt->pkt.signature))
2535                 {
2536                   found = 1;
2537                   break;
2538                 }
2539             }
2540           if (!found )
2541             {
2542               kbnode_t n2 = clone_kbnode(node);
2543               insert_kbnode( keyblock_orig, n2, 0 );
2544               n2->flag |= 1;
2545               ++*n_sigs;
2546               if(!opt.quiet)
2547                 log_info( _("key %s: direct key signature added\n"),
2548                           keystr(keyid));
2549             }
2550         }
2551     }
2552
2553   /* 3rd: try to merge new certificates in */
2554   for (onode=keyblock_orig->next; onode; onode=onode->next)
2555     {
2556       if (!(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID)
2557         {
2558           /* find the user id in the imported keyblock */
2559           for (node=keyblock->next; node; node=node->next)
2560             if (node->pkt->pkttype == PKT_USER_ID
2561                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2562                                   node->pkt->pkt.user_id ) )
2563               break;
2564           if (node ) /* found: merge */
2565             {
2566               rc = merge_sigs( onode, node, n_sigs, fname, keyid );
2567               if (rc )
2568                 return rc;
2569             }
2570         }
2571     }
2572
2573   /* 4th: add new user-ids */
2574   for (node=keyblock->next; node; node=node->next)
2575     {
2576       if (node->pkt->pkttype == PKT_USER_ID)
2577         {
2578           /* do we have this in the original keyblock */
2579           for (onode=keyblock_orig->next; onode; onode=onode->next )
2580             if (onode->pkt->pkttype == PKT_USER_ID
2581                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2582                                   node->pkt->pkt.user_id ) )
2583               break;
2584           if (!onode ) /* this is a new user id: append */
2585             {
2586               rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
2587               if (rc )
2588                 return rc;
2589               ++*n_uids;
2590             }
2591         }
2592     }
2593
2594   /* 5th: add new subkeys */
2595   for (node=keyblock->next; node; node=node->next)
2596     {
2597       onode = NULL;
2598       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2599         {
2600           /* do we have this in the original keyblock? */
2601           for(onode=keyblock_orig->next; onode; onode=onode->next)
2602             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2603                 && !cmp_public_keys( onode->pkt->pkt.public_key,
2604                                      node->pkt->pkt.public_key))
2605               break;
2606           if (!onode ) /* This is a new subkey: append.  */
2607             {
2608               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2609               if (rc)
2610                 return rc;
2611               ++*n_subk;
2612             }
2613         }
2614       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
2615         {
2616           /* do we have this in the original keyblock? */
2617           for (onode=keyblock_orig->next; onode; onode=onode->next )
2618             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
2619                 && !cmp_public_keys (onode->pkt->pkt.public_key,
2620                                      node->pkt->pkt.public_key) )
2621               break;
2622           if (!onode ) /* This is a new subkey: append.  */
2623             {
2624               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2625               if (rc )
2626                 return rc;
2627               ++*n_subk;
2628             }
2629         }
2630     }
2631
2632   /* 6th: merge subkey certificates */
2633   for (onode=keyblock_orig->next; onode; onode=onode->next)
2634     {
2635       if (!(onode->flag & 1)
2636           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2637               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
2638         {
2639           /* find the subkey in the imported keyblock */
2640           for(node=keyblock->next; node; node=node->next)
2641             {
2642               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2643                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
2644                   && !cmp_public_keys( onode->pkt->pkt.public_key,
2645                                        node->pkt->pkt.public_key ) )
2646                 break;
2647             }
2648           if (node) /* Found: merge.  */
2649             {
2650               rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2651               if (rc )
2652                 return rc;
2653             }
2654         }
2655     }
2656
2657   return 0;
2658 }
2659
2660
2661 /*
2662  * Append the userid starting with NODE and all signatures to KEYBLOCK.
2663  */
2664 static int
2665 append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs,
2666             const char *fname, u32 *keyid )
2667 {
2668   kbnode_t n;
2669   kbnode_t n_where = NULL;
2670
2671   (void)fname;
2672   (void)keyid;
2673
2674   assert(node->pkt->pkttype == PKT_USER_ID );
2675
2676   /* find the position */
2677   for (n = keyblock; n; n_where = n, n = n->next)
2678     {
2679       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2680           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2681         break;
2682     }
2683   if (!n)
2684     n_where = NULL;
2685
2686   /* and append/insert */
2687   while (node)
2688     {
2689       /* we add a clone to the original keyblock, because this
2690        * one is released first */
2691       n = clone_kbnode(node);
2692       if (n_where)
2693         {
2694           insert_kbnode( n_where, n, 0 );
2695           n_where = n;
2696         }
2697       else
2698         add_kbnode( keyblock, n );
2699       n->flag |= 1;
2700       node->flag |= 1;
2701       if (n->pkt->pkttype == PKT_SIGNATURE )
2702         ++*n_sigs;
2703
2704       node = node->next;
2705       if (node && node->pkt->pkttype != PKT_SIGNATURE )
2706         break;
2707     }
2708
2709   return 0;
2710 }
2711
2712
2713 /*
2714  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2715  * (how should we handle comment packets here?)
2716  */
2717 static int
2718 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs,
2719             const char *fname, u32 *keyid)
2720 {
2721   kbnode_t n, n2;
2722   int found = 0;
2723
2724   (void)fname;
2725   (void)keyid;
2726
2727   assert(dst->pkt->pkttype == PKT_USER_ID );
2728   assert(src->pkt->pkttype == PKT_USER_ID );
2729
2730   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
2731     {
2732       if (n->pkt->pkttype != PKT_SIGNATURE )
2733         continue;
2734       if (n->pkt->pkt.signature->sig_class == 0x18
2735           || n->pkt->pkt.signature->sig_class == 0x28 )
2736         continue; /* skip signatures which are only valid on subkeys */
2737
2738       found = 0;
2739       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2740         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2741           {
2742             found++;
2743             break;
2744           }
2745       if (!found )
2746         {
2747           /* This signature is new or newer, append N to DST.
2748            * We add a clone to the original keyblock, because this
2749            * one is released first */
2750           n2 = clone_kbnode(n);
2751           insert_kbnode( dst, n2, PKT_SIGNATURE );
2752           n2->flag |= 1;
2753           n->flag |= 1;
2754           ++*n_sigs;
2755         }
2756     }
2757
2758   return 0;
2759 }
2760
2761
2762 /*
2763  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2764  */
2765 static int
2766 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs,
2767                const char *fname, u32 *keyid)
2768 {
2769   kbnode_t n, n2;
2770   int found = 0;
2771
2772   (void)fname;
2773   (void)keyid;
2774
2775   assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2776           || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
2777
2778   for (n=src->next; n ; n = n->next)
2779     {
2780       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2781           || n->pkt->pkttype == PKT_PUBLIC_KEY )
2782         break;
2783       if (n->pkt->pkttype != PKT_SIGNATURE )
2784         continue;
2785
2786       found = 0;
2787       for (n2=dst->next; n2; n2 = n2->next)
2788         {
2789           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2790               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2791             break;
2792           if (n2->pkt->pkttype == PKT_SIGNATURE
2793               && (n->pkt->pkt.signature->keyid[0]
2794                   == n2->pkt->pkt.signature->keyid[0])
2795               && (n->pkt->pkt.signature->keyid[1]
2796                   == n2->pkt->pkt.signature->keyid[1])
2797               && (n->pkt->pkt.signature->timestamp
2798                   <= n2->pkt->pkt.signature->timestamp)
2799               && (n->pkt->pkt.signature->sig_class
2800                   == n2->pkt->pkt.signature->sig_class))
2801             {
2802               found++;
2803               break;
2804             }
2805         }
2806       if (!found )
2807         {
2808           /* This signature is new or newer, append N to DST.
2809            * We add a clone to the original keyblock, because this
2810            * one is released first */
2811           n2 = clone_kbnode(n);
2812           insert_kbnode( dst, n2, PKT_SIGNATURE );
2813           n2->flag |= 1;
2814           n->flag |= 1;
2815           ++*n_sigs;
2816         }
2817     }
2818
2819   return 0;
2820 }
2821
2822
2823 /*
2824  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
2825  * Mark all new and copied packets by setting flag bit 0.
2826  */
2827 static int
2828 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs,
2829             const char *fname, u32 *keyid)
2830 {
2831   kbnode_t n;
2832
2833   (void)fname;
2834   (void)keyid;
2835
2836   assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2837           || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2838
2839   while (node)
2840     {
2841       /* we add a clone to the original keyblock, because this
2842        * one is released first */
2843       n = clone_kbnode(node);
2844       add_kbnode( keyblock, n );
2845       n->flag |= 1;
2846       node->flag |= 1;
2847       if (n->pkt->pkttype == PKT_SIGNATURE )
2848         ++*n_sigs;
2849
2850       node = node->next;
2851       if (node && node->pkt->pkttype != PKT_SIGNATURE )
2852         break;
2853     }
2854
2855   return 0;
2856 }