g10/import.c

   1 /* import.c - import a key into our key storage.
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3  *               2006 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 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, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <assert.h>
  29
  30 #include "options.h"
  31 #include "packet.h"
  32 #include "errors.h"
  33 #include "keydb.h"
  34 #include "memory.h"
  35 #include "util.h"
  36 #include "trustdb.h"
  37 #include "main.h"
  38 #include "i18n.h"
  39 #include "ttyio.h"
  40 #include "status.h"
  41 #include "keyserver-internal.h"
  42
  43 struct stats_s {
  44     ulong count;
  45     ulong no_user_id;
  46     ulong imported;
  47     ulong imported_rsa;
  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 };
  61
  62
  63 static int import( IOBUF inp, const char* fname,struct stats_s *stats,
  64                    unsigned char **fpr,size_t *fpr_len,unsigned int options );
  65 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
  66 static void revocation_present(KBNODE keyblock);
  67 static int import_one(const char *fname, KBNODE keyblock,struct stats_s *stats,
  68                       unsigned char **fpr,size_t *fpr_len,
  69                       unsigned int options);
  70 static int import_secret_one( const char *fname, KBNODE keyblock,
  71                               struct stats_s *stats, unsigned int options);
  72 static int import_revoke_cert( const char *fname, KBNODE node,
  73                                struct stats_s *stats);
  74 static int chk_self_sigs( const char *fname, KBNODE keyblock,
  75                           PKT_public_key *pk, u32 *keyid, int *non_self );
  76 static int delete_inv_parts( const char *fname, KBNODE keyblock,
  77                              u32 *keyid, unsigned int options );
  78 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
  79                          KBNODE keyblock, u32 *keyid,
  80                          int *n_uids, int *n_sigs, int *n_subk );
  81 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
  82                              const char *fname, u32 *keyid );
  83 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
  84                              const char *fname, u32 *keyid );
  85 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
  86                              const char *fname, u32 *keyid );
  87 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
  88                              const char *fname, u32 *keyid );
  89
  90 int
  91 parse_import_options(char *str,unsigned int *options,int noisy)
  92 {
  93   struct parse_options import_opts[]=
  94     {
  95       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
  96        N_("import signatures that are marked as local-only")},
  97       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
  98        N_("repair damage from the pks keyserver during import")},
  99       {"fast-import",IMPORT_FAST,NULL,
 100        N_("do not update the trustdb after import")},
 101       {"convert-sk-to-pk",IMPORT_SK2PK,NULL,
 102        N_("create a public key when importing a secret key")},
 103       {"merge-only",IMPORT_MERGE_ONLY,NULL,
 104        N_("only accept updates to existing keys")},
 105       {"import-clean",IMPORT_CLEAN,NULL,
 106        N_("remove unusable parts from key after import")},
 107       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
 108        N_("remove as much as possible from key after import")},
 109       /* Aliases for backward compatibility */
 110       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
 111       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
 112       /* dummy */
 113       {"import-unusable-sigs",0,NULL,NULL},
 114       {"import-clean-sigs",0,NULL,NULL},
 115       {"import-clean-uids",0,NULL,NULL},
 116       {NULL,0,NULL,NULL}
 117     };
 118
 119   return parse_options(str,options,import_opts,noisy);
 120 }
 121
 122 void *
 123 import_new_stats_handle (void)
 124 {
 125     return xmalloc_clear ( sizeof (struct stats_s) );
 126 }
 127
 128 void
 129 import_release_stats_handle (void *p)
 130 {
 131     xfree (p);
 132 }
 133
 134 /****************
 135  * Import the public keys from the given filename. Input may be armored.
 136  * This function rejects all keys which are not validly self signed on at
 137  * least one userid. Only user ids which are self signed will be imported.
 138  * Other signatures are not checked.
 139  *
 140  * Actually this function does a merge. It works like this:
 141  *
 142  *  - get the keyblock
 143  *  - check self-signatures and remove all userids and their signatures
 144  *    without/invalid self-signatures.
 145  *  - reject the keyblock, if we have no valid userid.
 146  *  - See whether we have this key already in one of our pubrings.
 147  *    If not, simply add it to the default keyring.
 148  *  - Compare the key and the self-signatures of the new and the one in
 149  *    our keyring.  If they are different something weird is going on;
 150  *    ask what to do.
 151  *  - See whether we have only non-self-signature on one user id; if not
 152  *    ask the user what to do.
 153  *  - compare the signatures: If we already have this signature, check
 154  *    that they compare okay; if not, issue a warning and ask the user.
 155  *    (consider looking at the timestamp and use the newest?)
 156  *  - Simply add the signature.  Can't verify here because we may not have
 157  *    the signature's public key yet; verification is done when putting it
 158  *    into the trustdb, which is done automagically as soon as this pubkey
 159  *    is used.
 160  *  - Proceed with next signature.
 161  *
 162  *  Key revocation certificates have special handling.
 163  *
 164  */
 165 static int
 166 import_keys_internal( IOBUF inp, char **fnames, int nnames,
 167                       void *stats_handle, unsigned char **fpr, size_t *fpr_len,
 168                       unsigned int options )
 169 {
 170     int i, rc = 0;
 171     struct stats_s *stats = stats_handle;
 172
 173     if (!stats)
 174         stats = import_new_stats_handle ();
 175
 176     if (inp) {
 177         rc = import( inp, "[stream]", stats, fpr, fpr_len, options);
 178     }
 179     else {
 180         if( !fnames && !nnames )
 181             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
 182
 183         for(i=0; i < nnames; i++ ) {
 184             const char *fname = fnames? fnames[i] : NULL;
 185             IOBUF inp2 = iobuf_open(fname);
 186             if( !fname )
 187                 fname = "[stdin]";
 188             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
 189               {
 190                 iobuf_close (inp2);
 191                 inp2 = NULL;
 192                 errno = EPERM;
 193               }
 194             if( !inp2 )
 195                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
 196             else
 197               {
 198                 rc = import( inp2, fname, stats, fpr, fpr_len, options );
 199                 iobuf_close(inp2);
 200                 /* Must invalidate that ugly cache to actually close it. */
 201                 iobuf_ioctl (NULL, 2, 0, (char*)fname);
 202                 if( rc )
 203                   log_error("import from `%s' failed: %s\n", fname,
 204                             g10_errstr(rc) );
 205               }
 206             if( !fname )
 207                 break;
 208         }
 209     }
 210     if (!stats_handle) {
 211         import_print_stats (stats);
 212         import_release_stats_handle (stats);
 213     }
 214
 215     /* If no fast import and the trustdb is dirty (i.e. we added a key
 216        or userID that had something other than a selfsig, a signature
 217        that was other than a selfsig, or any revocation), then
 218        update/check the trustdb if the user specified by setting
 219        interactive or by not setting no-auto-check-trustdb */
 220
 221     if(!(options&IMPORT_FAST))
 222       trustdb_check_or_update();
 223
 224     return rc;
 225 }
 226
 227 void
 228 import_keys( char **fnames, int nnames,
 229              void *stats_handle, unsigned int options )
 230 {
 231   import_keys_internal(NULL,fnames,nnames,stats_handle,NULL,NULL,options);
 232 }
 233
 234 int
 235 import_keys_stream( IOBUF inp, void *stats_handle,
 236                     unsigned char **fpr, size_t *fpr_len,unsigned int options )
 237 {
 238   return import_keys_internal(inp,NULL,0,stats_handle,fpr,fpr_len,options);
 239 }
 240
 241 static int
 242 import( IOBUF inp, const char* fname,struct stats_s *stats,
 243         unsigned char **fpr,size_t *fpr_len,unsigned int options )
 244 {
 245     PACKET *pending_pkt = NULL;
 246     KBNODE keyblock;
 247     int rc = 0;
 248
 249     getkey_disable_caches();
 250
 251     if( !opt.no_armor ) { /* armored reading is not disabled */
 252         armor_filter_context_t *afx = xmalloc_clear( sizeof *afx );
 253         afx->only_keyblocks = 1;
 254         iobuf_push_filter2( inp, armor_filter, afx, 1 );
 255     }
 256
 257     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
 258         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
 259             rc = import_one( fname, keyblock, stats, fpr, fpr_len, options );
 260         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
 261                 rc = import_secret_one( fname, keyblock, stats, options );
 262         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
 263                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
 264             rc = import_revoke_cert( fname, keyblock, stats );
 265         else {
 266             log_info( _("skipping block of type %d\n"),
 267                                             keyblock->pkt->pkttype );
 268         }
 269         release_kbnode(keyblock);
 270         /* fixme: we should increment the not imported counter but this
 271            does only make sense if we keep on going despite of errors. */
 272         if( rc )
 273             break;
 274         if( !(++stats->count % 100) && !opt.quiet )
 275             log_info(_("%lu keys processed so far\n"), stats->count );
 276     }
 277     if( rc == -1 )
 278         rc = 0;
 279     else if( rc && rc != G10ERR_INV_KEYRING )
 280         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
 281
 282     return rc;
 283 }
 284
 285
 286 void
 287 import_print_stats (void *hd)
 288 {
 289     struct stats_s *stats = hd;
 290
 291     if( !opt.quiet ) {
 292         log_info(_("Total number processed: %lu\n"), stats->count );
 293         if( stats->skipped_new_keys )
 294             log_info(_("      skipped new keys: %lu\n"),
 295                                                 stats->skipped_new_keys );
 296         if( stats->no_user_id )
 297             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
 298         if( stats->imported || stats->imported_rsa ) {
 299             log_info(_("              imported: %lu"), stats->imported );
 300             if( stats->imported_rsa )
 301                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
 302             putc('\n', stderr);
 303         }
 304         if( stats->unchanged )
 305             log_info(_("             unchanged: %lu\n"), stats->unchanged );
 306         if( stats->n_uids )
 307             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
 308         if( stats->n_subk )
 309             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
 310         if( stats->n_sigs )
 311             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
 312         if( stats->n_revoc )
 313             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
 314         if( stats->secret_read )
 315             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
 316         if( stats->secret_imported )
 317             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
 318         if( stats->secret_dups )
 319             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
 320         if( stats->not_imported )
 321             log_info(_("          not imported: %lu\n"), stats->not_imported );
 322         if( stats->n_sigs_cleaned)
 323             log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
 324         if( stats->n_uids_cleaned)
 325             log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
 326     }
 327
 328     if( is_status_enabled() ) {
 329         char buf[14*20];
 330         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
 331                 stats->count,
 332                 stats->no_user_id,
 333                 stats->imported,
 334                 stats->imported_rsa,
 335                 stats->unchanged,
 336                 stats->n_uids,
 337                 stats->n_subk,
 338                 stats->n_sigs,
 339                 stats->n_revoc,
 340                 stats->secret_read,
 341                 stats->secret_imported,
 342                 stats->secret_dups,
 343                 stats->skipped_new_keys,
 344                 stats->not_imported );
 345         write_status_text( STATUS_IMPORT_RES, buf );
 346     }
 347 }
 348
 349
 350 /****************
 351  * Read the next keyblock from stream A.
 352  * PENDING_PKT should be initialzed to NULL
 353  * and not chnaged form the caller.
 354  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
 355  */
 356 static int
 357 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
 358 {
 359     int rc;
 360     PACKET *pkt;
 361     KBNODE root = NULL;
 362     int in_cert;
 363
 364     if( *pending_pkt ) {
 365         root = new_kbnode( *pending_pkt );
 366         *pending_pkt = NULL;
 367         in_cert = 1;
 368     }
 369     else
 370         in_cert = 0;
 371     pkt = xmalloc( sizeof *pkt );
 372     init_packet(pkt);
 373     while( (rc=parse_packet(a, pkt)) != -1 ) {
 374         if( rc ) {  /* ignore errors */
 375             if( rc != G10ERR_UNKNOWN_PACKET ) {
 376                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
 377                 rc = G10ERR_INV_KEYRING;
 378                 goto ready;
 379             }
 380             free_packet( pkt );
 381             init_packet(pkt);
 382             continue;
 383         }
 384
 385         if( !root && pkt->pkttype == PKT_SIGNATURE
 386                   && pkt->pkt.signature->sig_class == 0x20 ) {
 387             /* this is a revocation certificate which is handled
 388              * in a special way */
 389             root = new_kbnode( pkt );
 390             pkt = NULL;
 391             goto ready;
 392         }
 393
 394         /* make a linked list of all packets */
 395         switch( pkt->pkttype ) {
 396           case PKT_COMPRESSED:
 397             if(check_compress_algo(pkt->pkt.compressed->algorithm))
 398               {
 399                 rc = G10ERR_COMPR_ALGO;
 400                 goto ready;
 401               }
 402             else
 403               {
 404                 compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
 405                 pkt->pkt.compressed->buf = NULL;
 406                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
 407               }
 408             free_packet( pkt );
 409             init_packet(pkt);
 410             break;
 411
 412           case PKT_RING_TRUST:
 413             /* skip those packets */
 414             free_packet( pkt );
 415             init_packet(pkt);
 416             break;
 417
 418           case PKT_PUBLIC_KEY:
 419           case PKT_SECRET_KEY:
 420             if( in_cert ) { /* store this packet */
 421                 *pending_pkt = pkt;
 422                 pkt = NULL;
 423                 goto ready;
 424             }
 425             in_cert = 1;
 426           default:
 427             if( in_cert ) {
 428                 if( !root )
 429                     root = new_kbnode( pkt );
 430                 else
 431                     add_kbnode( root, new_kbnode( pkt ) );
 432                 pkt = xmalloc( sizeof *pkt );
 433             }
 434             init_packet(pkt);
 435             break;
 436         }
 437     }
 438   ready:
 439     if( rc == -1 && root )
 440         rc = 0;
 441
 442     if( rc )
 443         release_kbnode( root );
 444     else
 445         *ret_root = root;
 446     free_packet( pkt );
 447     xfree( pkt );
 448     return rc;
 449 }
 450
 451 /* Walk through the subkeys on a pk to find if we have the PKS
 452    disease: multiple subkeys with their binding sigs stripped, and the
 453    sig for the first subkey placed after the last subkey.  That is,
 454    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
 455    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
 456    and sub3, as they are already lost, but we can try and rescue sub1
 457    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
 458    sub2 sub3".  Returns TRUE if the keyblock was modified. */
 459
 460 static int
 461 fix_pks_corruption(KBNODE keyblock)
 462 {
 463   int changed=0,keycount=0;
 464   KBNODE node,last=NULL,sknode=NULL;
 465
 466   /* First determine if we have the problem at all.  Look for 2 or
 467      more subkeys in a row, followed by a single binding sig. */
 468   for(node=keyblock;node;last=node,node=node->next)
 469     {
 470       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
 471         {
 472           keycount++;
 473           if(!sknode)
 474             sknode=node;
 475         }
 476       else if(node->pkt->pkttype==PKT_SIGNATURE &&
 477               node->pkt->pkt.signature->sig_class==0x18 &&
 478               keycount>=2 && node->next==NULL)
 479         {
 480           /* We might have the problem, as this key has two subkeys in
 481              a row without any intervening packets. */
 482
 483           /* Sanity check */
 484           if(last==NULL)
 485             break;
 486
 487           /* Temporarily attach node to sknode. */
 488           node->next=sknode->next;
 489           sknode->next=node;
 490           last->next=NULL;
 491
 492           /* Note we aren't checking whether this binding sig is a
 493              selfsig.  This is not necessary here as the subkey and
 494              binding sig will be rejected later if that is the
 495              case. */
 496           if(check_key_signature(keyblock,node,NULL))
 497             {
 498               /* Not a match, so undo the changes. */
 499               sknode->next=node->next;
 500               last->next=node;
 501               node->next=NULL;
 502               break;
 503             }
 504           else
 505             {
 506               sknode->flag |= 1; /* Mark it good so we don't need to
 507                                     check it again */
 508               changed=1;
 509               break;
 510             }
 511         }
 512       else
 513         keycount=0;
 514     }
 515
 516   return changed;
 517 }
 518
 519
 520 static void
 521 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
 522 {
 523   byte array[MAX_FINGERPRINT_LEN], *s;
 524   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
 525   size_t i, n;
 526
 527   sprintf (buf, "%u ", reason);
 528   p = buf + strlen (buf);
 529
 530   if (pk)
 531     fingerprint_from_pk (pk, array, &n);
 532   else
 533     fingerprint_from_sk (sk, array, &n);
 534   s = array;
 535   for (i=0; i < n ; i++, s++, p += 2)
 536     sprintf (p, "%02X", *s);
 537
 538   write_status_text (STATUS_IMPORT_OK, buf);
 539 }
 540
 541 static void
 542 print_import_check (PKT_public_key * pk, PKT_user_id * id)
 543 {
 544     char * buf;
 545     byte fpr[24];
 546     u32 keyid[2];
 547     size_t i, pos = 0, n;
 548
 549     buf = xmalloc (17+41+id->len+32);
 550     keyid_from_pk (pk, keyid);
 551     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
 552     pos = 17;
 553     fingerprint_from_pk (pk, fpr, &n);
 554     for (i = 0; i < n; i++, pos += 2)
 555         sprintf (buf+pos, "%02X", fpr[i]);
 556     strcat (buf, " ");
 557     pos += 1;
 558     strcat (buf, id->name);
 559     write_status_text (STATUS_IMPORT_CHECK, buf);
 560     xfree (buf);
 561 }
 562
 563 static void
 564 check_prefs_warning(PKT_public_key *pk)
 565 {
 566   log_info(_("WARNING: key %s contains preferences for unavailable\n"),
 567            keystr_from_pk(pk));
 568   log_info(_("algorithms on these user IDs:\n"));
 569 }
 570
 571 static void
 572 check_prefs(KBNODE keyblock)
 573 {
 574   KBNODE node;
 575   PKT_public_key *pk;
 576   int problem=0;
 577
 578   merge_keys_and_selfsig(keyblock);
 579   pk=keyblock->pkt->pkt.public_key;
 580
 581   for(node=keyblock;node;node=node->next)
 582     {
 583       if(node->pkt->pkttype==PKT_USER_ID
 584          && node->pkt->pkt.user_id->created
 585          && node->pkt->pkt.user_id->prefs)
 586         {
 587           PKT_user_id *uid=node->pkt->pkt.user_id;
 588           prefitem_t *prefs=uid->prefs;
 589           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
 590
 591           for(;prefs->type;prefs++)
 592             {
 593               char num[10]; /* prefs->value is a byte, so we're over
 594                                safe here */
 595
 596               sprintf(num,"%u",prefs->value);
 597
 598               if(prefs->type==PREFTYPE_SYM)
 599                 {
 600                   if(check_cipher_algo(prefs->value))
 601                     {
 602                       const char *algo=cipher_algo_to_string(prefs->value);
 603                       if(!problem)
 604                         check_prefs_warning(pk);
 605                       log_info(_("         \"%s\": preference for cipher"
 606                                  " algorithm %s\n"),user,algo?algo:num);
 607                       problem=1;
 608                     }
 609                 }
 610               else if(prefs->type==PREFTYPE_HASH)
 611                 {
 612                   if(check_digest_algo(prefs->value))
 613                     {
 614                       const char *algo=digest_algo_to_string(prefs->value);
 615                       if(!problem)
 616                         check_prefs_warning(pk);
 617                       log_info(_("         \"%s\": preference for digest"
 618                                  " algorithm %s\n"),user,algo?algo:num);
 619                       problem=1;
 620                     }
 621                 }
 622               else if(prefs->type==PREFTYPE_ZIP)
 623                 {
 624                   if(check_compress_algo(prefs->value))
 625                     {
 626                       const char *algo=compress_algo_to_string(prefs->value);
 627                       if(!problem)
 628                         check_prefs_warning(pk);
 629                       log_info(_("         \"%s\": preference for compression"
 630                                  " algorithm %s\n"),user,algo?algo:num);
 631                       problem=1;
 632                     }
 633                 }
 634             }
 635
 636           xfree(user);
 637         }
 638     }
 639
 640   if(problem)
 641     {
 642       log_info(_("it is strongly suggested that you update"
 643                  " your preferences and\n"));
 644       log_info(_("re-distribute this key to avoid potential algorithm"
 645                  " mismatch problems\n"));
 646
 647       if(!opt.batch)
 648         {
 649           STRLIST sl=NULL,locusr=NULL;
 650           size_t fprlen=0;
 651           byte fpr[MAX_FINGERPRINT_LEN],*p;
 652           char username[(MAX_FINGERPRINT_LEN*2)+1];
 653           unsigned int i;
 654
 655           p=fingerprint_from_pk(pk,fpr,&fprlen);
 656           for(i=0;i<fprlen;i++,p++)
 657             sprintf(username+2*i,"%02X",*p);
 658           add_to_strlist(&locusr,username);
 659
 660           append_to_strlist(&sl,"updpref");
 661           append_to_strlist(&sl,"save");
 662
 663           keyedit_menu( username, locusr, sl, 1, 1 );
 664           free_strlist(sl);
 665           free_strlist(locusr);
 666         }
 667       else if(!opt.quiet)
 668         log_info(_("you can update your preferences with:"
 669                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
 670     }
 671 }
 672
 673 /****************
 674  * Try to import one keyblock.  Return an error only in serious cases, but
 675  * never for an invalid keyblock.  It uses log_error to increase the
 676  * internal errorcount, so that invalid input can be detected by programs
 677  * which called g10.
 678  */
 679 static int
 680 import_one( const char *fname, KBNODE keyblock, struct stats_s *stats,
 681             unsigned char **fpr,size_t *fpr_len,unsigned int options )
 682 {
 683     PKT_public_key *pk;
 684     PKT_public_key *pk_orig;
 685     KBNODE node, uidnode;
 686     KBNODE keyblock_orig = NULL;
 687     u32 keyid[2];
 688     int rc = 0;
 689     int new_key = 0;
 690     int mod_key = 0;
 691     int non_self = 0;
 692
 693     /* get the key and print some info about it */
 694     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
 695     if( !node )
 696         BUG();
 697
 698     pk = node->pkt->pkt.public_key;
 699
 700     if(fpr)
 701       *fpr=fingerprint_from_pk(pk,NULL,fpr_len);
 702
 703     keyid_from_pk( pk, keyid );
 704     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
 705
 706     if( opt.verbose && !opt.interactive )
 707       {
 708         log_info( "pub  %4u%c/%s %s  ",
 709                   nbits_from_pk( pk ),
 710                   pubkey_letter( pk->pubkey_algo ),
 711                   keystr_from_pk(pk), datestr_from_pk(pk) );
 712         if( uidnode )
 713           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
 714                              uidnode->pkt->pkt.user_id->len );
 715         putc('\n', stderr);
 716       }
 717
 718     if( !uidnode )
 719       {
 720         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
 721         return 0;
 722       }
 723
 724     if (opt.interactive) {
 725         if(is_status_enabled())
 726           print_import_check (pk, uidnode->pkt->pkt.user_id);
 727         merge_keys_and_selfsig (keyblock);
 728         tty_printf ("\n");
 729         show_basic_key_info (keyblock);
 730         tty_printf ("\n");
 731         if (!cpr_get_answer_is_yes ("import.okay",
 732                                     "Do you want to import this key? (y/N) "))
 733             return 0;
 734     }
 735
 736     collapse_uids(&keyblock);
 737
 738     /* Clean the key that we're about to import, to cut down on things
 739        that we have to clean later.  This has no practical impact on
 740        the end result, but does result in less logging which might
 741        confuse the user. */
 742     if(options&IMPORT_CLEAN)
 743       clean_key(keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
 744
 745     clear_kbnode_flags( keyblock );
 746
 747     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
 748        && opt.verbose)
 749       log_info(_("key %s: PKS subkey corruption repaired\n"),
 750                keystr_from_pk(pk));
 751
 752     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
 753     if( rc )
 754         return rc== -1? 0:rc;
 755
 756     /* If we allow such a thing, mark unsigned uids as valid */
 757     if( opt.allow_non_selfsigned_uid )
 758       for( node=keyblock; node; node = node->next )
 759         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
 760           {
 761             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
 762                                       node->pkt->pkt.user_id->len,0);
 763             node->flag |= 1;
 764             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
 765                       keystr_from_pk(pk),user);
 766             xfree(user);
 767           }
 768
 769     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
 770         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
 771         if( !opt.quiet )
 772           log_info(_("this may be caused by a missing self-signature\n"));
 773         stats->no_user_id++;
 774         return 0;
 775     }
 776
 777     /* do we have this key already in one of our pubrings ? */
 778     pk_orig = xmalloc_clear( sizeof *pk_orig );
 779     rc = get_pubkey_fast ( pk_orig, keyid );
 780     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
 781       {
 782         log_error( _("key %s: public key not found: %s\n"),
 783                    keystr(keyid), g10_errstr(rc));
 784       }
 785     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
 786       {
 787         if( opt.verbose )
 788           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
 789         rc = 0;
 790         stats->skipped_new_keys++;
 791       }
 792     else if( rc ) { /* insert this key */
 793         KEYDB_HANDLE hd = keydb_new (0);
 794
 795         rc = keydb_locate_writable (hd, NULL);
 796         if (rc) {
 797             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
 798             keydb_release (hd);
 799             return G10ERR_GENERAL;
 800         }
 801         if( opt.verbose > 1 )
 802             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
 803
 804         rc = keydb_insert_keyblock (hd, keyblock );
 805         if (rc)
 806            log_error (_("error writing keyring `%s': %s\n"),
 807                        keydb_get_resource_name (hd), g10_errstr(rc));
 808         else
 809           {
 810             /* This should not be possible since we delete the
 811                ownertrust when a key is deleted, but it can happen if
 812                the keyring and trustdb are out of sync.  It can also
 813                be made to happen with the trusted-key command. */
 814
 815             clear_ownertrusts (pk);
 816             if(non_self)
 817               revalidation_mark ();
 818           }
 819         keydb_release (hd);
 820
 821         /* we are ready */
 822         if( !opt.quiet )
 823           {
 824             char *p=get_user_id_native (keyid);
 825             log_info( _("key %s: public key \"%s\" imported\n"),
 826                       keystr(keyid),p);
 827             xfree(p);
 828           }
 829         if( is_status_enabled() )
 830           {
 831             char *us = get_long_user_id_string( keyid );
 832             write_status_text( STATUS_IMPORTED, us );
 833             xfree(us);
 834             print_import_ok (pk,NULL, 1);
 835           }
 836         stats->imported++;
 837         if( is_RSA( pk->pubkey_algo ) )
 838             stats->imported_rsa++;
 839         new_key = 1;
 840     }
 841     else { /* merge */
 842         KEYDB_HANDLE hd;
 843         int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
 844
 845         /* Compare the original against the new key; just to be sure nothing
 846          * weird is going on */
 847         if( cmp_public_keys( pk_orig, pk ) )
 848           {
 849             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
 850             goto leave;
 851           }
 852
 853         /* now read the original keyblock */
 854         hd = keydb_new (0);
 855         {
 856             byte afp[MAX_FINGERPRINT_LEN];
 857             size_t an;
 858
 859             fingerprint_from_pk (pk_orig, afp, &an);
 860             while (an < MAX_FINGERPRINT_LEN)
 861                 afp[an++] = 0;
 862             rc = keydb_search_fpr (hd, afp);
 863         }
 864         if( rc )
 865           {
 866             log_error (_("key %s: can't locate original keyblock: %s\n"),
 867                        keystr(keyid), g10_errstr(rc));
 868             keydb_release (hd);
 869             goto leave;
 870           }
 871         rc = keydb_get_keyblock (hd, &keyblock_orig );
 872         if (rc)
 873           {
 874             log_error (_("key %s: can't read original keyblock: %s\n"),
 875                        keystr(keyid), g10_errstr(rc));
 876             keydb_release (hd);
 877             goto leave;
 878           }
 879
 880         /* and try to merge the block */
 881         clear_kbnode_flags( keyblock_orig );
 882         clear_kbnode_flags( keyblock );
 883         n_uids = n_sigs = n_subk = n_sigs_cleaned = n_uids_cleaned = 0;
 884         rc = merge_blocks( fname, keyblock_orig, keyblock,
 885                            keyid, &n_uids, &n_sigs, &n_subk );
 886         if( rc )
 887           {
 888             keydb_release (hd);
 889             goto leave;
 890           }
 891
 892         if(options&IMPORT_CLEAN)
 893           clean_key(keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
 894                     &n_uids_cleaned,&n_sigs_cleaned);
 895
 896         if( n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned) {
 897             mod_key = 1;
 898             /* keyblock_orig has been updated; write */
 899             rc = keydb_update_keyblock (hd, keyblock_orig);
 900             if (rc)
 901                 log_error (_("error writing keyring `%s': %s\n"),
 902                              keydb_get_resource_name (hd), g10_errstr(rc) );
 903             else if(non_self)
 904               revalidation_mark ();
 905
 906             /* we are ready */
 907             if( !opt.quiet )
 908               {
 909                 char *p=get_user_id_native(keyid);
 910                 if( n_uids == 1 )
 911                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
 912                            keystr(keyid),p);
 913                 else if( n_uids )
 914                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
 915                             keystr(keyid),p,n_uids);
 916                 if( n_sigs == 1 )
 917                   log_info( _("key %s: \"%s\" 1 new signature\n"),
 918                             keystr(keyid), p);
 919                 else if( n_sigs )
 920                   log_info( _("key %s: \"%s\" %d new signatures\n"),
 921                             keystr(keyid), p, n_sigs );
 922                 if( n_subk == 1 )
 923                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
 924                             keystr(keyid), p);
 925                 else if( n_subk )
 926                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
 927                             keystr(keyid), p, n_subk );
 928                 if(n_sigs_cleaned==1)
 929                   log_info(_("key %s: \"%s\" %d signature cleaned\n"),
 930                            keystr(keyid),p,n_sigs_cleaned);
 931                 else if(n_sigs_cleaned)
 932                   log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
 933                            keystr(keyid),p,n_sigs_cleaned);
 934                 if(n_uids_cleaned==1)
 935                   log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
 936                            keystr(keyid),p,n_uids_cleaned);
 937                 else if(n_uids_cleaned)
 938                   log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
 939                            keystr(keyid),p,n_uids_cleaned);
 940                 xfree(p);
 941               }
 942
 943             stats->n_uids +=n_uids;
 944             stats->n_sigs +=n_sigs;
 945             stats->n_subk +=n_subk;
 946             stats->n_sigs_cleaned +=n_sigs_cleaned;
 947             stats->n_uids_cleaned +=n_uids_cleaned;
 948
 949             if (is_status_enabled ())
 950                  print_import_ok (pk, NULL,
 951                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
 952         }
 953         else
 954           {
 955             if (is_status_enabled ())
 956               print_import_ok (pk, NULL, 0);
 957
 958             if( !opt.quiet )
 959               {
 960                 char *p=get_user_id_native(keyid);
 961                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
 962                 xfree(p);
 963               }
 964
 965             stats->unchanged++;
 966           }
 967
 968         keydb_release (hd); hd = NULL;
 969     }
 970
 971   leave:
 972
 973     /* Now that the key is definitely incorporated into the keydb, we
 974        need to check if a designated revocation is present or if the
 975        prefs are not rational so we can warn the user. */
 976
 977     if(mod_key)
 978       {
 979         revocation_present(keyblock_orig);
 980         if(seckey_available(keyid)==0)
 981           check_prefs(keyblock_orig);
 982       }
 983     else if(new_key)
 984       {
 985         revocation_present(keyblock);
 986         if(seckey_available(keyid)==0)
 987           check_prefs(keyblock);
 988       }
 989
 990     release_kbnode( keyblock_orig );
 991     free_public_key( pk_orig );
 992
 993     return rc;
 994 }
 995
 996 /* Walk a secret keyblock and produce a public keyblock out of it. */
 997 static KBNODE
 998 sec_to_pub_keyblock(KBNODE sec_keyblock)
 999 {
1000   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
1001
1002   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
1003     {
1004       KBNODE pubnode;
1005
1006       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
1007          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1008         {
1009           /* Make a public key.  We only need to convert enough to
1010              write the keyblock out. */
1011
1012           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1013           PACKET *pkt=xmalloc_clear(sizeof(PACKET));
1014           PKT_public_key *pk=xmalloc_clear(sizeof(PKT_public_key));
1015           int n;
1016
1017           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1018             pkt->pkttype=PKT_PUBLIC_KEY;
1019           else
1020             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1021
1022           pkt->pkt.public_key=pk;
1023
1024           pk->version=sk->version;
1025           pk->timestamp=sk->timestamp;
1026           pk->expiredate=sk->expiredate;
1027           pk->pubkey_algo=sk->pubkey_algo;
1028
1029           n=pubkey_get_npkey(pk->pubkey_algo);
1030           if(n==0)
1031             {
1032               /* we can't properly extract the pubkey without knowing
1033                  the number of MPIs */
1034               release_kbnode(pub_keyblock);
1035               return NULL;
1036             }
1037           else
1038             {
1039               int i;
1040
1041               for(i=0;i<n;i++)
1042                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1043             }
1044
1045           pubnode=new_kbnode(pkt);
1046         }
1047       else
1048         {
1049           pubnode=clone_kbnode(secnode);
1050         }
1051
1052       if(pub_keyblock==NULL)
1053         pub_keyblock=pubnode;
1054       else
1055         add_kbnode(pub_keyblock,pubnode);
1056     }
1057
1058   return pub_keyblock;
1059 }
1060
1061 /****************
1062  * Ditto for secret keys.  Handling is simpler than for public keys.
1063  * We allow secret key importing only when allow is true, this is so
1064  * that a secret key can not be imported accidently and thereby tampering
1065  * with the trust calculation.
1066  */
1067 static int
1068 import_secret_one( const char *fname, KBNODE keyblock,
1069                    struct stats_s *stats, unsigned int options)
1070 {
1071     PKT_secret_key *sk;
1072     KBNODE node, uidnode;
1073     u32 keyid[2];
1074     int rc = 0;
1075
1076     /* get the key and print some info about it */
1077     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1078     if( !node )
1079         BUG();
1080
1081     sk = node->pkt->pkt.secret_key;
1082     keyid_from_sk( sk, keyid );
1083     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1084
1085     if( opt.verbose )
1086       {
1087         log_info( "sec  %4u%c/%s %s   ",
1088                   nbits_from_sk( sk ),
1089                   pubkey_letter( sk->pubkey_algo ),
1090                   keystr_from_sk(sk), datestr_from_sk(sk) );
1091         if( uidnode )
1092           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1093                              uidnode->pkt->pkt.user_id->len );
1094         putc('\n', stderr);
1095       }
1096     stats->secret_read++;
1097
1098     if( !uidnode )
1099       {
1100         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1101         return 0;
1102       }
1103
1104     if(sk->protect.algo>110)
1105       {
1106         log_error(_("key %s: secret key with invalid cipher %d"
1107                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1108         return 0;
1109       }
1110
1111 #ifdef ENABLE_SELINUX_HACKS
1112     if (1)
1113       {
1114         /* We don't allow to import secret keys because that may be used
1115            to put a secret key into the keyring and the user might later
1116            be tricked into signing stuff with that key.  */
1117         log_error (_("importing secret keys not allowed\n"));
1118         return 0;
1119       }
1120 #endif
1121
1122     clear_kbnode_flags( keyblock );
1123
1124     /* do we have this key already in one of our secrings ? */
1125     rc = seckey_available( keyid );
1126     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1127       {
1128         /* simply insert this key */
1129         KEYDB_HANDLE hd = keydb_new (1);
1130
1131         /* get default resource */
1132         rc = keydb_locate_writable (hd, NULL);
1133         if (rc) {
1134           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1135           keydb_release (hd);
1136           return G10ERR_GENERAL;
1137         }
1138         rc = keydb_insert_keyblock (hd, keyblock );
1139         if (rc)
1140           log_error (_("error writing keyring `%s': %s\n"),
1141                      keydb_get_resource_name (hd), g10_errstr(rc) );
1142         keydb_release (hd);
1143         /* we are ready */
1144         if( !opt.quiet )
1145           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1146         stats->secret_imported++;
1147         if (is_status_enabled ())
1148           print_import_ok (NULL, sk, 1|16);
1149
1150         if(options&IMPORT_SK2PK)
1151           {
1152             /* Try and make a public key out of this. */
1153
1154             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1155             if(pub_keyblock)
1156               {
1157                 import_one(fname,pub_keyblock,stats,
1158                            NULL,NULL,opt.import_options);
1159                 release_kbnode(pub_keyblock);
1160               }
1161           }
1162
1163         /* Now that the key is definitely incorporated into the keydb,
1164            if we have the public part of this key, we need to check if
1165            the prefs are rational. */
1166         node=get_pubkeyblock(keyid);
1167         if(node)
1168           {
1169             check_prefs(node);
1170             release_kbnode(node);
1171           }
1172       }
1173     else if( !rc )
1174       { /* we can't merge secret keys */
1175         log_error( _("key %s: already in secret keyring\n"),
1176                    keystr_from_sk(sk));
1177         stats->secret_dups++;
1178         if (is_status_enabled ())
1179           print_import_ok (NULL, sk, 16);
1180
1181         /* TODO: if we ever do merge secret keys, make sure to handle
1182            the sec_to_pub_keyblock feature as well. */
1183       }
1184     else
1185       log_error( _("key %s: secret key not found: %s\n"),
1186                  keystr_from_sk(sk), g10_errstr(rc));
1187
1188     return rc;
1189 }
1190
1191
1192 /****************
1193  * Import a revocation certificate; this is a single signature packet.
1194  */
1195 static int
1196 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1197 {
1198     PKT_public_key *pk=NULL;
1199     KBNODE onode, keyblock = NULL;
1200     KEYDB_HANDLE hd = NULL;
1201     u32 keyid[2];
1202     int rc = 0;
1203
1204     assert( !node->next );
1205     assert( node->pkt->pkttype == PKT_SIGNATURE );
1206     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1207
1208     keyid[0] = node->pkt->pkt.signature->keyid[0];
1209     keyid[1] = node->pkt->pkt.signature->keyid[1];
1210
1211     pk = xmalloc_clear( sizeof *pk );
1212     rc = get_pubkey( pk, keyid );
1213     if( rc == G10ERR_NO_PUBKEY )
1214       {
1215         log_error(_("key %s: no public key -"
1216                     " can't apply revocation certificate\n"), keystr(keyid));
1217         rc = 0;
1218         goto leave;
1219       }
1220     else if( rc )
1221       {
1222         log_error(_("key %s: public key not found: %s\n"),
1223                   keystr(keyid), g10_errstr(rc));
1224         goto leave;
1225       }
1226
1227     /* read the original keyblock */
1228     hd = keydb_new (0);
1229     {
1230         byte afp[MAX_FINGERPRINT_LEN];
1231         size_t an;
1232
1233         fingerprint_from_pk (pk, afp, &an);
1234         while (an < MAX_FINGERPRINT_LEN)
1235             afp[an++] = 0;
1236         rc = keydb_search_fpr (hd, afp);
1237     }
1238     if (rc)
1239       {
1240         log_error (_("key %s: can't locate original keyblock: %s\n"),
1241                    keystr(keyid), g10_errstr(rc));
1242         goto leave;
1243       }
1244     rc = keydb_get_keyblock (hd, &keyblock );
1245     if (rc)
1246       {
1247         log_error (_("key %s: can't read original keyblock: %s\n"),
1248                    keystr(keyid), g10_errstr(rc));
1249         goto leave;
1250       }
1251
1252     /* it is okay, that node is not in keyblock because
1253      * check_key_signature works fine for sig_class 0x20 in this
1254      * special case. */
1255     rc = check_key_signature( keyblock, node, NULL);
1256     if( rc )
1257       {
1258         log_error( _("key %s: invalid revocation certificate"
1259                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1260         goto leave;
1261       }
1262
1263     /* check whether we already have this */
1264     for(onode=keyblock->next; onode; onode=onode->next ) {
1265         if( onode->pkt->pkttype == PKT_USER_ID )
1266             break;
1267         else if( onode->pkt->pkttype == PKT_SIGNATURE
1268                  && !cmp_signatures(node->pkt->pkt.signature,
1269                                     onode->pkt->pkt.signature))
1270           {
1271             rc = 0;
1272             goto leave; /* yes, we already know about it */
1273           }
1274     }
1275
1276
1277     /* insert it */
1278     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1279
1280     /* and write the keyblock back */
1281     rc = keydb_update_keyblock (hd, keyblock );
1282     if (rc)
1283         log_error (_("error writing keyring `%s': %s\n"),
1284                    keydb_get_resource_name (hd), g10_errstr(rc) );
1285     keydb_release (hd); hd = NULL;
1286     /* we are ready */
1287     if( !opt.quiet )
1288       {
1289         char *p=get_user_id_native (keyid);
1290         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1291                   keystr(keyid),p);
1292         xfree(p);
1293       }
1294     stats->n_revoc++;
1295
1296     /* If the key we just revoked was ultimately trusted, remove its
1297        ultimate trust.  This doesn't stop the user from putting the
1298        ultimate trust back, but is a reasonable solution for now. */
1299     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1300       clear_ownertrusts(pk);
1301
1302     revalidation_mark ();
1303
1304   leave:
1305     keydb_release (hd);
1306     release_kbnode( keyblock );
1307     free_public_key( pk );
1308     return rc;
1309 }
1310
1311
1312 /****************
1313  * loop over the keyblock and check all self signatures.
1314  * Mark all user-ids with a self-signature by setting flag bit 0.
1315  * Mark all user-ids with an invalid self-signature by setting bit 1.
1316  * This works also for subkeys, here the subkey is marked.  Invalid or
1317  * extra subkey sigs (binding or revocation) are marked for deletion.
1318  * non_self is set to true if there are any sigs other than self-sigs
1319  * in this keyblock.
1320  */
1321 static int
1322 chk_self_sigs( const char *fname, KBNODE keyblock,
1323                PKT_public_key *pk, u32 *keyid, int *non_self )
1324 {
1325     KBNODE n,knode=NULL;
1326     PKT_signature *sig;
1327     int rc;
1328     u32 bsdate=0,rsdate=0;
1329     KBNODE bsnode=NULL,rsnode=NULL;
1330
1331     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1332       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1333         {
1334           knode=n;
1335           bsdate=0;
1336           rsdate=0;
1337           bsnode=NULL;
1338           rsnode=NULL;
1339           continue;
1340         }
1341       else if( n->pkt->pkttype != PKT_SIGNATURE )
1342             continue;
1343         sig = n->pkt->pkt.signature;
1344         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1345
1346             /* This just caches the sigs for later use.  That way we
1347                import a fully-cached key which speeds things up. */
1348             if(!opt.no_sig_cache)
1349               check_key_signature(keyblock,n,NULL);
1350
1351             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1352               {
1353                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1354                 if( !unode )
1355                   {
1356                     log_error( _("key %s: no user ID for signature\n"),
1357                                keystr(keyid));
1358                     return -1;  /* the complete keyblock is invalid */
1359                   }
1360
1361                 /* If it hasn't been marked valid yet, keep trying */
1362                 if(!(unode->flag&1)) {
1363                   rc = check_key_signature( keyblock, n, NULL);
1364                   if( rc )
1365                     {
1366                       if( opt.verbose )
1367                         {
1368                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1369                                       strlen(unode->pkt->pkt.user_id->name),0);
1370                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1371                                     _("key %s: unsupported public key "
1372                                       "algorithm on user ID \"%s\"\n"):
1373                                     _("key %s: invalid self-signature "
1374                                       "on user ID \"%s\"\n"),
1375                                     keystr(keyid),p);
1376                           xfree(p);
1377                         }
1378                     }
1379                   else
1380                     unode->flag |= 1; /* mark that signature checked */
1381                 }
1382               }
1383             else if( sig->sig_class == 0x18 ) {
1384               /* Note that this works based solely on the timestamps
1385                  like the rest of gpg.  If the standard gets
1386                  revocation targets, this may need to be revised. */
1387
1388                 if( !knode )
1389                   {
1390                     if(opt.verbose)
1391                       log_info( _("key %s: no subkey for key binding\n"),
1392                                 keystr(keyid));
1393                     n->flag |= 4; /* delete this */
1394                   }
1395                 else
1396                   {
1397                     rc = check_key_signature( keyblock, n, NULL);
1398                     if( rc )
1399                       {
1400                         if(opt.verbose)
1401                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1402                                    _("key %s: unsupported public key"
1403                                      " algorithm\n"):
1404                                    _("key %s: invalid subkey binding\n"),
1405                                    keystr(keyid));
1406                         n->flag|=4;
1407                       }
1408                     else
1409                       {
1410                         /* It's valid, so is it newer? */
1411                         if(sig->timestamp>=bsdate) {
1412                           knode->flag |= 1;  /* the subkey is valid */
1413                           if(bsnode)
1414                             {
1415                               bsnode->flag|=4; /* Delete the last binding
1416                                                   sig since this one is
1417                                                   newer */
1418                               if(opt.verbose)
1419                                 log_info(_("key %s: removed multiple subkey"
1420                                            " binding\n"),keystr(keyid));
1421                             }
1422
1423                           bsnode=n;
1424                           bsdate=sig->timestamp;
1425                         }
1426                         else
1427                           n->flag|=4; /* older */
1428                       }
1429                   }
1430             }
1431             else if( sig->sig_class == 0x28 ) {
1432               /* We don't actually mark the subkey as revoked right
1433                  now, so just check that the revocation sig is the
1434                  most recent valid one.  Note that we don't care if
1435                  the binding sig is newer than the revocation sig.
1436                  See the comment in getkey.c:merge_selfsigs_subkey for
1437                  more */
1438                 if( !knode )
1439                   {
1440                     if(opt.verbose)
1441                       log_info( _("key %s: no subkey for key revocation\n"),
1442                                 keystr(keyid));
1443                     n->flag |= 4; /* delete this */
1444                   }
1445                 else
1446                   {
1447                     rc = check_key_signature( keyblock, n, NULL);
1448                     if( rc )
1449                       {
1450                         if(opt.verbose)
1451                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1452                                    _("key %s: unsupported public"
1453                                      " key algorithm\n"):
1454                                    _("key %s: invalid subkey revocation\n"),
1455                                    keystr(keyid));
1456                         n->flag|=4;
1457                       }
1458                     else
1459                       {
1460                         /* It's valid, so is it newer? */
1461                         if(sig->timestamp>=rsdate)
1462                           {
1463                             if(rsnode)
1464                               {
1465                                 rsnode->flag|=4; /* Delete the last revocation
1466                                                     sig since this one is
1467                                                     newer */
1468                                 if(opt.verbose)
1469                                   log_info(_("key %s: removed multiple subkey"
1470                                              " revocation\n"),keystr(keyid));
1471                               }
1472
1473                             rsnode=n;
1474                             rsdate=sig->timestamp;
1475                           }
1476                         else
1477                           n->flag|=4; /* older */
1478                       }
1479                   }
1480             }
1481         }
1482         else
1483           *non_self=1;
1484     }
1485
1486     return 0;
1487 }
1488
1489 /****************
1490  * delete all parts which are invalid and those signatures whose
1491  * public key algorithm is not available in this implemenation;
1492  * but consider RSA as valid, because parse/build_packets knows
1493  * about it.
1494  * returns: true if at least one valid user-id is left over.
1495  */
1496 static int
1497 delete_inv_parts( const char *fname, KBNODE keyblock,
1498                   u32 *keyid, unsigned int options)
1499 {
1500     KBNODE node;
1501     int nvalid=0, uid_seen=0, subkey_seen=0;
1502
1503     for(node=keyblock->next; node; node = node->next ) {
1504         if( node->pkt->pkttype == PKT_USER_ID ) {
1505             uid_seen = 1;
1506             if( (node->flag & 2) || !(node->flag & 1) ) {
1507                 if( opt.verbose )
1508                   {
1509                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1510                                            node->pkt->pkt.user_id->len,0);
1511                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1512                               keystr(keyid),p);
1513                     xfree(p);
1514                   }
1515                 delete_kbnode( node ); /* the user-id */
1516                 /* and all following packets up to the next user-id */
1517                 while( node->next
1518                        && node->next->pkt->pkttype != PKT_USER_ID
1519                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1520                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1521                     delete_kbnode( node->next );
1522                     node = node->next;
1523                 }
1524             }
1525             else
1526                 nvalid++;
1527         }
1528         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1529                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1530             if( (node->flag & 2) || !(node->flag & 1) ) {
1531                 if( opt.verbose )
1532                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1533
1534                 delete_kbnode( node ); /* the subkey */
1535                 /* and all following signature packets */
1536                 while( node->next
1537                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1538                     delete_kbnode( node->next );
1539                     node = node->next;
1540                 }
1541             }
1542             else
1543               subkey_seen = 1;
1544         }
1545         else if( node->pkt->pkttype == PKT_SIGNATURE
1546                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1547                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1548             delete_kbnode( node ); /* build_packet() can't handle this */
1549         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1550                  !node->pkt->pkt.signature->flags.exportable &&
1551                  !(options&IMPORT_LOCAL_SIGS) &&
1552                  seckey_available( node->pkt->pkt.signature->keyid ) )
1553           {
1554             /* here we violate the rfc a bit by still allowing
1555              * to import non-exportable signature when we have the
1556              * the secret key used to create this signature - it
1557              * seems that this makes sense */
1558             if(opt.verbose)
1559               log_info( _("key %s: non exportable signature"
1560                           " (class 0x%02X) - skipped\n"),
1561                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1562             delete_kbnode( node );
1563           }
1564         else if( node->pkt->pkttype == PKT_SIGNATURE
1565                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1566             if( uid_seen )
1567               {
1568                 if(opt.verbose)
1569                   log_info( _("key %s: revocation certificate"
1570                               " at wrong place - skipped\n"),keystr(keyid));
1571                 delete_kbnode( node );
1572               }
1573             else {
1574               /* If the revocation cert is from a different key than
1575                  the one we're working on don't check it - it's
1576                  probably from a revocation key and won't be
1577                  verifiable with this key anyway. */
1578
1579               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1580                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1581                 {
1582                   int rc = check_key_signature( keyblock, node, NULL);
1583                   if( rc )
1584                     {
1585                       if(opt.verbose)
1586                         log_info( _("key %s: invalid revocation"
1587                                     " certificate: %s - skipped\n"),
1588                                   keystr(keyid), g10_errstr(rc));
1589                       delete_kbnode( node );
1590                     }
1591                 }
1592             }
1593         }
1594         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1595                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1596                   node->pkt->pkt.signature->sig_class == 0x28) &&
1597                  !subkey_seen )
1598           {
1599             if(opt.verbose)
1600               log_info( _("key %s: subkey signature"
1601                           " in wrong place - skipped\n"), keystr(keyid));
1602             delete_kbnode( node );
1603           }
1604         else if( node->pkt->pkttype == PKT_SIGNATURE
1605                  && !IS_CERT(node->pkt->pkt.signature))
1606           {
1607             if(opt.verbose)
1608               log_info(_("key %s: unexpected signature class (0x%02X) -"
1609                          " skipped\n"),keystr(keyid),
1610                        node->pkt->pkt.signature->sig_class);
1611             delete_kbnode(node);
1612           }
1613         else if( (node->flag & 4) ) /* marked for deletion */
1614           delete_kbnode( node );
1615     }
1616
1617     /* note: because keyblock is the public key, it is never marked
1618      * for deletion and so keyblock cannot change */
1619     commit_kbnode( &keyblock );
1620     return nvalid;
1621 }
1622
1623
1624 /****************
1625  * It may happen that the imported keyblock has duplicated user IDs.
1626  * We check this here and collapse those user IDs together with their
1627  * sigs into one.
1628  * Returns: True if the keyblock hash changed.
1629  */
1630 int
1631 collapse_uids( KBNODE *keyblock )
1632 {
1633     KBNODE n, n2;
1634     int in_uid;
1635     int any=0;
1636
1637   restart:
1638     for( n = *keyblock; n; n = n->next ) {
1639         if( n->pkt->pkttype != PKT_USER_ID )
1640             continue;
1641         for( n2 = n->next; n2; n2 = n2->next ) {
1642             if( n2->pkt->pkttype == PKT_USER_ID
1643                 && !cmp_user_ids( n->pkt->pkt.user_id,
1644                                   n2->pkt->pkt.user_id ) ) {
1645                 /* found a duplicate */
1646                 any = 1;
1647                 if( !n2->next
1648                     || n2->next->pkt->pkttype == PKT_USER_ID
1649                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1650                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1651                     /* no more signatures: delete the user ID
1652                      * and start over */
1653                     remove_kbnode( keyblock, n2 );
1654                 }
1655                 else {
1656                     /* The simple approach: Move one signature and
1657                      * then start over to delete the next one :-( */
1658                     move_kbnode( keyblock, n2->next, n->next );
1659                 }
1660                 goto restart;
1661             }
1662         }
1663     }
1664     if( !any )
1665         return 0;
1666
1667   restart_sig:
1668     /* now we may have duplicate signatures on one user ID: fix this */
1669     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1670         if( n->pkt->pkttype == PKT_USER_ID )
1671             in_uid = 1;
1672         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1673                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1674             in_uid = 0;
1675         else if( in_uid ) {
1676             n2 = n;
1677             do {
1678                 KBNODE ncmp = NULL;
1679                 for( ; n2; n2 = n2->next ) {
1680                     if(    n2->pkt->pkttype == PKT_USER_ID
1681                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1682                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1683                         break;
1684                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1685                         ;
1686                     else if( !ncmp )
1687                         ncmp = n2;
1688                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1689                                                 n2->pkt->pkt.signature )) {
1690                         remove_kbnode( keyblock, n2 );
1691                         goto restart_sig;
1692                     }
1693                 }
1694                 n2 = ncmp? ncmp->next : NULL;
1695             } while( n2 );
1696         }
1697     }
1698
1699     if(!opt.quiet)
1700       {
1701         const char *key="???";
1702
1703         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1704           key=keystr_from_pk(n->pkt->pkt.public_key);
1705         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1706           key=keystr_from_sk(n->pkt->pkt.secret_key);
1707
1708         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1709       }
1710
1711     return 1;
1712 }
1713
1714 /* Check for a 0x20 revocation from a revocation key that is not
1715    present.  This may be called without the benefit of merge_xxxx so
1716    you can't rely on pk->revkey and friends. */
1717 static void
1718 revocation_present(KBNODE keyblock)
1719 {
1720   KBNODE onode,inode;
1721   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1722
1723   for(onode=keyblock->next;onode;onode=onode->next)
1724     {
1725       /* If we reach user IDs, we're done. */
1726       if(onode->pkt->pkttype==PKT_USER_ID)
1727         break;
1728
1729       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1730          onode->pkt->pkt.signature->sig_class==0x1F &&
1731          onode->pkt->pkt.signature->revkey)
1732         {
1733           int idx;
1734           PKT_signature *sig=onode->pkt->pkt.signature;
1735
1736           for(idx=0;idx<sig->numrevkeys;idx++)
1737             {
1738               u32 keyid[2];
1739
1740               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1741                                      MAX_FINGERPRINT_LEN,keyid);
1742
1743               for(inode=keyblock->next;inode;inode=inode->next)
1744                 {
1745                   /* If we reach user IDs, we're done. */
1746                   if(inode->pkt->pkttype==PKT_USER_ID)
1747                     break;
1748
1749                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1750                      inode->pkt->pkt.signature->sig_class==0x20 &&
1751                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1752                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1753                     {
1754                       /* Okay, we have a revocation key, and a
1755                          revocation issued by it.  Do we have the key
1756                          itself? */
1757                       int rc;
1758
1759                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1760                                                    MAX_FINGERPRINT_LEN);
1761                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1762                         {
1763                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1764
1765                           /* No, so try and get it */
1766                           if(opt.keyserver
1767                              && (opt.keyserver_options.options
1768                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1769                             {
1770                               log_info(_("WARNING: key %s may be revoked:"
1771                                          " fetching revocation key %s\n"),
1772                                        tempkeystr,keystr(keyid));
1773                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1774                                                       MAX_FINGERPRINT_LEN,
1775                                                       opt.keyserver);
1776
1777                               /* Do we have it now? */
1778                               rc=get_pubkey_byfprint_fast (NULL,
1779                                                      sig->revkey[idx]->fpr,
1780                                                      MAX_FINGERPRINT_LEN);
1781                             }
1782
1783                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1784                             log_info(_("WARNING: key %s may be revoked:"
1785                                        " revocation key %s not present.\n"),
1786                                      tempkeystr,keystr(keyid));
1787
1788                           xfree(tempkeystr);
1789                         }
1790                     }
1791                 }
1792             }
1793         }
1794     }
1795 }
1796
1797 /****************
1798  * compare and merge the blocks
1799  *
1800  * o compare the signatures: If we already have this signature, check
1801  *   that they compare okay; if not, issue a warning and ask the user.
1802  * o Simply add the signature.  Can't verify here because we may not have
1803  *   the signature's public key yet; verification is done when putting it
1804  *   into the trustdb, which is done automagically as soon as this pubkey
1805  *   is used.
1806  * Note: We indicate newly inserted packets with flag bit 0
1807  */
1808 static int
1809 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1810               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1811 {
1812     KBNODE onode, node;
1813     int rc, found;
1814
1815     /* 1st: handle revocation certificates */
1816     for(node=keyblock->next; node; node=node->next ) {
1817         if( node->pkt->pkttype == PKT_USER_ID )
1818             break;
1819         else if( node->pkt->pkttype == PKT_SIGNATURE
1820                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1821             /* check whether we already have this */
1822             found = 0;
1823             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1824                 if( onode->pkt->pkttype == PKT_USER_ID )
1825                     break;
1826                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1827                          && onode->pkt->pkt.signature->sig_class == 0x20
1828                          && !cmp_signatures(onode->pkt->pkt.signature,
1829                                             node->pkt->pkt.signature))
1830                   {
1831                     found = 1;
1832                     break;
1833                   }
1834             }
1835             if( !found ) {
1836                 KBNODE n2 = clone_kbnode(node);
1837                 insert_kbnode( keyblock_orig, n2, 0 );
1838                 n2->flag |= 1;
1839                 ++*n_sigs;
1840                 if(!opt.quiet)
1841                   {
1842                     char *p=get_user_id_native (keyid);
1843                     log_info(_("key %s: \"%s\" revocation"
1844                                " certificate added\n"), keystr(keyid),p);
1845                     xfree(p);
1846                   }
1847             }
1848         }
1849     }
1850
1851     /* 2nd: merge in any direct key (0x1F) sigs */
1852     for(node=keyblock->next; node; node=node->next ) {
1853         if( node->pkt->pkttype == PKT_USER_ID )
1854             break;
1855         else if( node->pkt->pkttype == PKT_SIGNATURE
1856                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1857             /* check whether we already have this */
1858             found = 0;
1859             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1860                 if( onode->pkt->pkttype == PKT_USER_ID )
1861                     break;
1862                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1863                          && onode->pkt->pkt.signature->sig_class == 0x1F
1864                          && !cmp_signatures(onode->pkt->pkt.signature,
1865                                             node->pkt->pkt.signature)) {
1866                     found = 1;
1867                     break;
1868                 }
1869             }
1870             if( !found )
1871               {
1872                 KBNODE n2 = clone_kbnode(node);
1873                 insert_kbnode( keyblock_orig, n2, 0 );
1874                 n2->flag |= 1;
1875                 ++*n_sigs;
1876                 if(!opt.quiet)
1877                   log_info( _("key %s: direct key signature added\n"),
1878                             keystr(keyid));
1879               }
1880         }
1881     }
1882
1883     /* 3rd: try to merge new certificates in */
1884     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1885         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1886             /* find the user id in the imported keyblock */
1887             for(node=keyblock->next; node; node=node->next )
1888                 if( node->pkt->pkttype == PKT_USER_ID
1889                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1890                                           node->pkt->pkt.user_id ) )
1891                     break;
1892             if( node ) { /* found: merge */
1893                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1894                 if( rc )
1895                     return rc;
1896             }
1897         }
1898     }
1899
1900     /* 4th: add new user-ids */
1901     for(node=keyblock->next; node; node=node->next ) {
1902         if( node->pkt->pkttype == PKT_USER_ID) {
1903             /* do we have this in the original keyblock */
1904             for(onode=keyblock_orig->next; onode; onode=onode->next )
1905                 if( onode->pkt->pkttype == PKT_USER_ID
1906                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1907                                       node->pkt->pkt.user_id ) )
1908                     break;
1909             if( !onode ) { /* this is a new user id: append */
1910                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1911                 if( rc )
1912                     return rc;
1913                 ++*n_uids;
1914             }
1915         }
1916     }
1917
1918     /* 5th: add new subkeys */
1919     for(node=keyblock->next; node; node=node->next ) {
1920         onode = NULL;
1921         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1922             /* do we have this in the original keyblock? */
1923             for(onode=keyblock_orig->next; onode; onode=onode->next )
1924                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1925                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1926                                          node->pkt->pkt.public_key ) )
1927                     break;
1928             if( !onode ) { /* this is a new subkey: append */
1929                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1930                 if( rc )
1931                     return rc;
1932                 ++*n_subk;
1933             }
1934         }
1935         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1936             /* do we have this in the original keyblock? */
1937             for(onode=keyblock_orig->next; onode; onode=onode->next )
1938                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1939                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1940                                          node->pkt->pkt.secret_key ) )
1941                     break;
1942             if( !onode ) { /* this is a new subkey: append */
1943                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1944                 if( rc )
1945                     return rc;
1946                 ++*n_subk;
1947             }
1948         }
1949     }
1950
1951     /* 6th: merge subkey certificates */
1952     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1953         if( !(onode->flag & 1)
1954             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1955                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1956             /* find the subkey in the imported keyblock */
1957             for(node=keyblock->next; node; node=node->next ) {
1958                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1959                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1960                                           node->pkt->pkt.public_key ) )
1961                     break;
1962                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1963                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1964                                           node->pkt->pkt.secret_key ) )
1965                     break;
1966             }
1967             if( node ) { /* found: merge */
1968                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1969                 if( rc )
1970                     return rc;
1971             }
1972         }
1973     }
1974
1975
1976     return 0;
1977 }
1978
1979
1980 /****************
1981  * append the userid starting with NODE and all signatures to KEYBLOCK.
1982  */
1983 static int
1984 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1985                                           const char *fname, u32 *keyid )
1986 {
1987     KBNODE n, n_where=NULL;
1988
1989     assert(node->pkt->pkttype == PKT_USER_ID );
1990
1991     /* find the position */
1992     for( n = keyblock; n; n_where = n, n = n->next ) {
1993         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1994             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1995             break;
1996     }
1997     if( !n )
1998         n_where = NULL;
1999
2000     /* and append/insert */
2001     while( node ) {
2002         /* we add a clone to the original keyblock, because this
2003          * one is released first */
2004         n = clone_kbnode(node);
2005         if( n_where ) {
2006             insert_kbnode( n_where, n, 0 );
2007             n_where = n;
2008         }
2009         else
2010             add_kbnode( keyblock, n );
2011         n->flag |= 1;
2012         node->flag |= 1;
2013         if( n->pkt->pkttype == PKT_SIGNATURE )
2014             ++*n_sigs;
2015
2016         node = node->next;
2017         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2018             break;
2019     }
2020
2021     return 0;
2022 }
2023
2024
2025 /****************
2026  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2027  * (how should we handle comment packets here?)
2028  */
2029 static int
2030 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2031                                     const char *fname, u32 *keyid )
2032 {
2033     KBNODE n, n2;
2034     int found=0;
2035
2036     assert(dst->pkt->pkttype == PKT_USER_ID );
2037     assert(src->pkt->pkttype == PKT_USER_ID );
2038
2039     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2040         if( n->pkt->pkttype != PKT_SIGNATURE )
2041             continue;
2042         if( n->pkt->pkt.signature->sig_class == 0x18
2043             || n->pkt->pkt.signature->sig_class == 0x28 )
2044             continue; /* skip signatures which are only valid on subkeys */
2045         found = 0;
2046         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2047           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2048             {
2049               found++;
2050               break;
2051             }
2052         if( !found ) {
2053             /* This signature is new or newer, append N to DST.
2054              * We add a clone to the original keyblock, because this
2055              * one is released first */
2056             n2 = clone_kbnode(n);
2057             insert_kbnode( dst, n2, PKT_SIGNATURE );
2058             n2->flag |= 1;
2059             n->flag |= 1;
2060             ++*n_sigs;
2061         }
2062     }
2063
2064     return 0;
2065 }
2066
2067 /****************
2068  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2069  */
2070 static int
2071 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2072                                     const char *fname, u32 *keyid )
2073 {
2074     KBNODE n, n2;
2075     int found=0;
2076
2077     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2078            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2079
2080     for(n=src->next; n ; n = n->next ) {
2081         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2082             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2083             break;
2084         if( n->pkt->pkttype != PKT_SIGNATURE )
2085             continue;
2086         found = 0;
2087         for(n2=dst->next; n2; n2 = n2->next){
2088             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2089                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2090                 break;
2091             if( n2->pkt->pkttype == PKT_SIGNATURE
2092                 && n->pkt->pkt.signature->keyid[0]
2093                    == n2->pkt->pkt.signature->keyid[0]
2094                 && n->pkt->pkt.signature->keyid[1]
2095                    == n2->pkt->pkt.signature->keyid[1]
2096                 && n->pkt->pkt.signature->timestamp
2097                    <= n2->pkt->pkt.signature->timestamp
2098                 && n->pkt->pkt.signature->sig_class
2099                    == n2->pkt->pkt.signature->sig_class ) {
2100                 found++;
2101                 break;
2102             }
2103         }
2104         if( !found ) {
2105             /* This signature is new or newer, append N to DST.
2106              * We add a clone to the original keyblock, because this
2107              * one is released first */
2108             n2 = clone_kbnode(n);
2109             insert_kbnode( dst, n2, PKT_SIGNATURE );
2110             n2->flag |= 1;
2111             n->flag |= 1;
2112             ++*n_sigs;
2113         }
2114     }
2115
2116     return 0;
2117 }
2118
2119 /****************
2120  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2121  * Mark all new and copied packets by setting flag bit 0.
2122  */
2123 static int
2124 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2125                                           const char *fname, u32 *keyid )
2126 {
2127     KBNODE n;
2128
2129     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2130            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2131
2132     while(  node ) {
2133         /* we add a clone to the original keyblock, because this
2134          * one is released first */
2135         n = clone_kbnode(node);
2136         add_kbnode( keyblock, n );
2137         n->flag |= 1;
2138         node->flag |= 1;
2139         if( n->pkt->pkttype == PKT_SIGNATURE )
2140             ++*n_sigs;
2141
2142         node = node->next;
2143         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2144             break;
2145     }
2146
2147     return 0;
2148 }
2149
2150
2151
2152 /* Walk a public keyblock and produce a secret keyblock out of it.
2153    Instead of inserting the secret key parameters (which we don't
2154    have), we insert a stub.  */
2155 static KBNODE
2156 pub_to_sec_keyblock (KBNODE pub_keyblock)
2157 {
2158   KBNODE pubnode, secnode;
2159   KBNODE sec_keyblock = NULL;
2160   KBNODE walkctx = NULL;
2161
2162   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2163     {
2164       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2165           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2166         {
2167           /* Make a secret key.  We only need to convert enough to
2168              write the keyblock out. */
2169           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2170           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2171           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2172           int i, n;
2173
2174           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2175             pkt->pkttype = PKT_SECRET_KEY;
2176           else
2177             pkt->pkttype = PKT_SECRET_SUBKEY;
2178
2179           pkt->pkt.secret_key = sk;
2180
2181           copy_public_parts_to_secret_key ( pk, sk );
2182           sk->version     = pk->version;
2183           sk->timestamp   = pk->timestamp;
2184
2185           n = pubkey_get_npkey (pk->pubkey_algo);
2186           if (!n)
2187             n = 1; /* Unknown number of parameters, however the data
2188                       is stored in the first mpi. */
2189           for (i=0; i < n; i++ )
2190             sk->skey[i] = mpi_copy (pk->pkey[i]);
2191
2192           sk->is_protected = 1;
2193           sk->protect.s2k.mode = 1001;
2194
2195           secnode = new_kbnode (pkt);
2196         }
2197       else
2198         {
2199           secnode = clone_kbnode (pubnode);
2200         }
2201
2202       if(!sec_keyblock)
2203         sec_keyblock = secnode;
2204       else
2205         add_kbnode (sec_keyblock, secnode);
2206     }
2207
2208   return sec_keyblock;
2209 }
2210
2211
2212 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2213    stub keys with the serial number SNNUM of the card if one of the
2214    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2215    a duplicate (may happen in case of backed uped keys).
2216
2217    Returns: True if anything changed.
2218 */
2219 static int
2220 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock,
2221                                    const unsigned char *fpr1,
2222                                    const unsigned char *fpr2,
2223                                    const unsigned char *fpr3,
2224                                    const char *serialnostr)
2225 {
2226   KBNODE node;
2227   KBNODE walkctx = NULL;
2228   PKT_secret_key *sk;
2229   byte array[MAX_FINGERPRINT_LEN];
2230   size_t n;
2231   int result = 0;
2232   const char *s;
2233
2234   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2235     {
2236       if (node->pkt->pkttype != PKT_SECRET_KEY
2237           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2238         continue;
2239       sk = node->pkt->pkt.secret_key;
2240
2241       fingerprint_from_sk (sk, array, &n);
2242       if (n != 20)
2243         continue; /* Can't be a card key.  */
2244       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2245              || (fpr2 && !memcmp (array, fpr2, 20))
2246              || (fpr3 && !memcmp (array, fpr3, 20))) )
2247         continue;  /* No match.  */
2248
2249       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2250         {
2251           /* Standard case: migrate that stub to a key stub.  */
2252           sk->protect.s2k.mode = 1002;
2253           s = serialnostr;
2254           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2255                sk->protect.ivlen++, s += 2)
2256             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2257           result = 1;
2258         }
2259       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2260         {
2261           s = serialnostr;
2262           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2263                sk->protect.ivlen++, s += 2)
2264             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2265               {
2266                 log_info (_("NOTE: a key's S/N does not "
2267                             "match the card's one\n"));
2268                 break;
2269               }
2270         }
2271       else
2272         {
2273           if (node->pkt->pkttype != PKT_SECRET_KEY)
2274             log_info (_("NOTE: primary key is online and stored on card\n"));
2275           else
2276             log_info (_("NOTE: secondary key is online and stored on card\n"));
2277         }
2278     }
2279
2280   return result;
2281 }
2282
2283
2284
2285 /* Check whether a secret key stub exists for the public key PK.  If
2286    not create such a stub key and store it into the secring.  If it
2287    exists, add appropriate subkey stubs and update the secring.
2288    Return 0 if the key could be created. */
2289 int
2290 auto_create_card_key_stub ( const char *serialnostr,
2291                             const unsigned char *fpr1,
2292                             const unsigned char *fpr2,
2293                             const unsigned char *fpr3)
2294 {
2295   KBNODE pub_keyblock;
2296   KBNODE sec_keyblock;
2297   KEYDB_HANDLE hd;
2298   int rc;
2299
2300   /* We only want to do this for an OpenPGP card.  */
2301   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12)
2302       || strlen (serialnostr) != 32 )
2303     return G10ERR_GENERAL;
2304
2305   /* First get the public keyring from any of the provided fingerprints. */
2306   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2307        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2308        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2309     ;
2310   else
2311     return G10ERR_GENERAL;
2312
2313   hd = keydb_new (1);
2314
2315   /* Now check whether there is a secret keyring.  */
2316   {
2317     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2318     byte afp[MAX_FINGERPRINT_LEN];
2319     size_t an;
2320
2321     fingerprint_from_pk (pk, afp, &an);
2322     memset (afp, 0, MAX_FINGERPRINT_LEN);
2323     rc = keydb_search_fpr (hd, afp);
2324   }
2325
2326   if (!rc)
2327     {
2328       rc = keydb_get_keyblock (hd, &sec_keyblock);
2329       if (rc)
2330         {
2331           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2332           rc = G10ERR_GENERAL;
2333         }
2334       else
2335         {
2336           merge_keys_and_selfsig (sec_keyblock);
2337
2338           /* FIXME: We need to add new subkeys first.  */
2339           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2340                                                  fpr1, fpr2, fpr3,
2341                                                  serialnostr))
2342             {
2343               rc = keydb_update_keyblock (hd, sec_keyblock );
2344               if (rc)
2345                 log_error (_("error writing keyring `%s': %s\n"),
2346                            keydb_get_resource_name (hd), g10_errstr(rc) );
2347             }
2348         }
2349     }
2350   else  /* A secret key does not exists - create it.  */
2351     {
2352       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2353       update_sec_keyblock_with_cardinfo (sec_keyblock,
2354                                          fpr1, fpr2, fpr3,
2355                                          serialnostr);
2356
2357       rc = keydb_locate_writable (hd, NULL);
2358       if (rc)
2359         {
2360           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2361           rc = G10ERR_GENERAL;
2362         }
2363       else
2364         {
2365           rc = keydb_insert_keyblock (hd, sec_keyblock );
2366           if (rc)
2367             log_error (_("error writing keyring `%s': %s\n"),
2368                        keydb_get_resource_name (hd), g10_errstr(rc) );
2369         }
2370     }
2371
2372   release_kbnode (sec_keyblock);
2373   release_kbnode (pub_keyblock);
2374   keydb_release (hd);
2375   return rc;
2376 }
2377