g10/mainproc.c

   1 /* mainproc.c - handle packets
   2  * Copyright (C) 1998-2009 Free Software Foundation, Inc.
   3  * Copyright (C) 2013-2014 Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <time.h>
  26
  27 #include "gpg.h"
  28 #include "../common/util.h"
  29 #include "packet.h"
  30 #include "../common/iobuf.h"
  31 #include "options.h"
  32 #include "keydb.h"
  33 #include "filter.h"
  34 #include "main.h"
  35 #include "../common/status.h"
  36 #include "../common/i18n.h"
  37 #include "trustdb.h"
  38 #include "keyserver-internal.h"
  39 #include "photoid.h"
  40 #include "../common/mbox-util.h"
  41 #include "call-dirmngr.h"
  42 #include "../common/compliance.h"
  43
  44 /* Put an upper limit on nested packets.  The 32 is an arbitrary
  45    value, a much lower should actually be sufficient.  */
  46 #define MAX_NESTING_DEPTH 32
  47
  48
  49 /* An object to build a list of keyid related info.  */
  50 struct kidlist_item
  51 {
  52   struct kidlist_item *next;
  53   u32 kid[2];
  54   int pubkey_algo;
  55   int reason;
  56 };
  57
  58
  59 /*
  60  * Object to hold the processing context.
  61  */
  62 typedef struct mainproc_context *CTX;
  63 struct mainproc_context
  64 {
  65   ctrl_t ctrl;
  66   struct mainproc_context *anchor;  /* May be useful in the future. */
  67   PKT_public_key *last_pubkey;
  68   PKT_user_id     *last_user_id;
  69   md_filter_context_t mfx;
  70   int sigs_only;    /* Process only signatures and reject all other stuff. */
  71   int encrypt_only; /* Process only encryption messages. */
  72
  73   /* Name of the file with the complete signature or the file with the
  74      detached signature.  This is currently only used to deduce the
  75      file name of the data file if that has not been given. */
  76   const char *sigfilename;
  77
  78   /* A structure to describe the signed data in case of a detached
  79      signature. */
  80   struct
  81   {
  82     /* A file descriptor of the signed data.  Only used if not -1. */
  83     int data_fd;
  84     /* A list of filenames with the data files or NULL. This is only
  85        used if DATA_FD is -1. */
  86     strlist_t data_names;
  87     /* Flag to indicated that either one of the next previous fields
  88        is used.  This is only needed for better readability. */
  89     int used;
  90   } signed_data;
  91
  92   DEK *dek;
  93   int last_was_session_key;
  94   kbnode_t list;    /* The current list of packets. */
  95   iobuf_t iobuf;    /* Used to get the filename etc. */
  96   int trustletter;  /* Temporary usage in list_node. */
  97   ulong symkeys;    /* Number of symmetrically encrypted session keys.  */
  98   struct kidlist_item *pkenc_list; /* List of encryption packets. */
  99   struct {
 100     unsigned int sig_seen:1;      /* Set to true if a signature packet
 101                                      has been seen. */
 102     unsigned int data:1;          /* Any data packet seen */
 103     unsigned int uncompress_failed:1;
 104   } any;
 105 };
 106
 107
 108 /* Counter with the number of literal data packets seen.  Note that
 109  * this is also bumped at the end of an encryption.  This counter is
 110  * used for a basic consistency check of a received PGP message.  */
 111 static int literals_seen;
 112
 113
 114 /*** Local prototypes.  ***/
 115 static int do_proc_packets (ctrl_t ctrl, CTX c, iobuf_t a);
 116 static void list_node (CTX c, kbnode_t node);
 117 static void proc_tree (CTX c, kbnode_t node);
 118
 119
 120 /*** Functions.  ***/
 121
 122 /* Reset the literal data counter.  This is required to setup a new
 123  * decryption or verification context.  */
 124 void
 125 reset_literals_seen(void)
 126 {
 127   literals_seen = 0;
 128 }
 129
 130
 131 static void
 132 release_list( CTX c )
 133 {
 134   proc_tree (c, c->list);
 135   release_kbnode (c->list);
 136   while (c->pkenc_list)
 137     {
 138       struct kidlist_item *tmp = c->pkenc_list->next;
 139       xfree (c->pkenc_list);
 140       c->pkenc_list = tmp;
 141     }
 142   c->pkenc_list = NULL;
 143   c->list = NULL;
 144   c->any.data = 0;
 145   c->any.uncompress_failed = 0;
 146   c->last_was_session_key = 0;
 147   xfree (c->dek);
 148   c->dek = NULL;
 149 }
 150
 151
 152 static int
 153 add_onepass_sig (CTX c, PACKET *pkt)
 154 {
 155   kbnode_t node;
 156
 157   if (c->list) /* Add another packet. */
 158     add_kbnode (c->list, new_kbnode (pkt));
 159   else /* Insert the first one.  */
 160     c->list = node = new_kbnode (pkt);
 161
 162   return 1;
 163 }
 164
 165
 166 static int
 167 add_gpg_control (CTX c, PACKET *pkt)
 168 {
 169   if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
 170     {
 171       /* New clear text signature.
 172        * Process the last one and reset everything */
 173       release_list(c);
 174     }
 175
 176   if (c->list)  /* Add another packet.  */
 177     add_kbnode (c->list, new_kbnode (pkt));
 178   else /* Insert the first one. */
 179     c->list = new_kbnode (pkt);
 180
 181   return 1;
 182 }
 183
 184
 185 static int
 186 add_user_id (CTX c, PACKET *pkt)
 187 {
 188   if (!c->list)
 189     {
 190       log_error ("orphaned user ID\n");
 191       return 0;
 192     }
 193   add_kbnode (c->list, new_kbnode (pkt));
 194   return 1;
 195 }
 196
 197
 198 static int
 199 add_subkey (CTX c, PACKET *pkt)
 200 {
 201   if (!c->list)
 202     {
 203       log_error ("subkey w/o mainkey\n");
 204       return 0;
 205     }
 206   add_kbnode (c->list, new_kbnode (pkt));
 207   return 1;
 208 }
 209
 210
 211 static int
 212 add_ring_trust (CTX c, PACKET *pkt)
 213 {
 214   if (!c->list)
 215     {
 216       log_error ("ring trust w/o key\n");
 217       return 0;
 218     }
 219   add_kbnode (c->list, new_kbnode (pkt));
 220   return 1;
 221 }
 222
 223
 224 static int
 225 add_signature (CTX c, PACKET *pkt)
 226 {
 227   kbnode_t node;
 228
 229   c->any.sig_seen = 1;
 230   if (pkt->pkttype == PKT_SIGNATURE && !c->list)
 231     {
 232       /* This is the first signature for the following datafile.
 233        * GPG does not write such packets; instead it always uses
 234        * onepass-sig packets.  The drawback of PGP's method
 235        * of prepending the signature to the data is
 236        * that it is not possible to make a signature from data read
 237        * from stdin.    (GPG is able to read PGP stuff anyway.) */
 238       node = new_kbnode (pkt);
 239       c->list = node;
 240       return 1;
 241     }
 242   else if (!c->list)
 243     return 0; /* oops (invalid packet sequence)*/
 244   else if (!c->list->pkt)
 245     BUG();    /* so nicht */
 246
 247   /* Add a new signature node item at the end. */
 248   node = new_kbnode (pkt);
 249   add_kbnode (c->list, node);
 250
 251   return 1;
 252 }
 253
 254 static int
 255 symkey_decrypt_seskey (DEK *dek, byte *seskey, size_t slen)
 256 {
 257   gcry_cipher_hd_t hd;
 258
 259   if(slen < 17 || slen > 33)
 260     {
 261       log_error ( _("weird size for an encrypted session key (%d)\n"),
 262                   (int)slen);
 263       return GPG_ERR_BAD_KEY;
 264     }
 265
 266   if (openpgp_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1))
 267       BUG ();
 268   if (gcry_cipher_setkey ( hd, dek->key, dek->keylen ))
 269     BUG ();
 270   gcry_cipher_setiv ( hd, NULL, 0 );
 271   gcry_cipher_decrypt ( hd, seskey, slen, NULL, 0 );
 272   gcry_cipher_close ( hd );
 273
 274   /* Here we can only test whether the algo given in decrypted
 275    * session key is a valid OpenPGP algo.  With 11 defined
 276    * symmetric algorithms we will miss 4.3% of wrong passphrases
 277    * here.  The actual checking is done later during bulk
 278    * decryption; we can't bring this check forward easily.  */
 279   if (openpgp_cipher_test_algo (seskey[0]))
 280     return gpg_error (GPG_ERR_BAD_KEY);
 281
 282   /* Now we replace the dek components with the real session key to
 283      decrypt the contents of the sequencing packet. */
 284
 285   dek->keylen=slen-1;
 286   dek->algo=seskey[0];
 287
 288   if(dek->keylen > DIM(dek->key))
 289     BUG ();
 290
 291   memcpy(dek->key, seskey + 1, dek->keylen);
 292
 293   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
 294
 295   return 0;
 296 }
 297
 298
 299 static void
 300 proc_symkey_enc (CTX c, PACKET *pkt)
 301 {
 302   PKT_symkey_enc *enc;
 303
 304   enc = pkt->pkt.symkey_enc;
 305   if (!enc)
 306     log_error ("invalid symkey encrypted packet\n");
 307   else if(!c->dek)
 308     {
 309       int algo = enc->cipher_algo;
 310       const char *s = openpgp_cipher_algo_name (algo);
 311
 312       if (!openpgp_cipher_test_algo (algo))
 313         {
 314           if (!opt.quiet)
 315             {
 316               if (enc->seskeylen)
 317                 log_info (_("%s encrypted session key\n"), s );
 318               else
 319                 log_info (_("%s encrypted data\n"), s );
 320             }
 321         }
 322       else
 323         log_error (_("encrypted with unknown algorithm %d\n"), algo);
 324
 325       if (openpgp_md_test_algo (enc->s2k.hash_algo))
 326         {
 327           log_error(_("passphrase generated with unknown digest"
 328                       " algorithm %d\n"),enc->s2k.hash_algo);
 329           s = NULL;
 330         }
 331
 332       c->last_was_session_key = 2;
 333       if (!s || opt.list_only)
 334         goto leave;
 335
 336       if (opt.override_session_key)
 337         {
 338           c->dek = xmalloc_clear (sizeof *c->dek);
 339           if (get_override_session_key (c->dek, opt.override_session_key))
 340             {
 341               xfree (c->dek);
 342               c->dek = NULL;
 343             }
 344         }
 345       else
 346         {
 347           c->dek = passphrase_to_dek (algo, &enc->s2k, 0, 0, NULL, NULL);
 348           if (c->dek)
 349             {
 350               c->dek->symmetric = 1;
 351
 352               /* FIXME: This doesn't work perfectly if a symmetric key
 353                  comes before a public key in the message - if the
 354                  user doesn't know the passphrase, then there is a
 355                  chance that the "decrypted" algorithm will happen to
 356                  be a valid one, which will make the returned dek
 357                  appear valid, so we won't try any public keys that
 358                  come later. */
 359               if (enc->seskeylen)
 360                 {
 361                   if (symkey_decrypt_seskey (c->dek,
 362                                              enc->seskey, enc->seskeylen))
 363                     {
 364                       if (c->dek->s2k_cacheid[0])
 365                         {
 366                           if (opt.debug)
 367                             log_debug ("cleared passphrase cached with ID:"
 368                                        " %s\n", c->dek->s2k_cacheid);
 369                           passphrase_clear_cache (c->dek->s2k_cacheid);
 370                         }
 371                       xfree (c->dek);
 372                       c->dek = NULL;
 373                     }
 374                 }
 375               else
 376                 c->dek->algo_info_printed = 1;
 377             }
 378         }
 379     }
 380
 381  leave:
 382   c->symkeys++;
 383   free_packet (pkt, NULL);
 384 }
 385
 386
 387 static void
 388 proc_pubkey_enc (ctrl_t ctrl, CTX c, PACKET *pkt)
 389 {
 390   PKT_pubkey_enc *enc;
 391   int result = 0;
 392
 393   /* Check whether the secret key is available and store in this case.  */
 394   c->last_was_session_key = 1;
 395   enc = pkt->pkt.pubkey_enc;
 396   /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
 397   /* Hmmm: why do I have this algo check here - anyway there is
 398    * function to check it. */
 399   if (opt.verbose)
 400     log_info (_("public key is %s\n"), keystr (enc->keyid));
 401
 402   if (is_status_enabled())
 403     {
 404       char buf[50];
 405       /* FIXME: For ECC support we need to map the OpenPGP algo number
 406          to the Libgcrypt defined one.  This is due a chicken-egg
 407          problem: We need to have code in Libgcrypt for a new
 408          algorithm so to implement a proposed new algorithm before the
 409          IANA will finally assign an OpenPGP identifier.  */
 410       snprintf (buf, sizeof buf, "%08lX%08lX %d 0",
 411                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo);
 412       write_status_text (STATUS_ENC_TO, buf);
 413     }
 414
 415   if (!opt.list_only && opt.override_session_key)
 416     {
 417       /* It does not make much sense to store the session key in
 418        * secure memory because it has already been passed on the
 419        * command line and the GCHQ knows about it.  */
 420       c->dek = xmalloc_clear (sizeof *c->dek);
 421       result = get_override_session_key (c->dek, opt.override_session_key);
 422       if (result)
 423         {
 424           xfree (c->dek);
 425           c->dek = NULL;
 426         }
 427     }
 428   else if (enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E
 429            || enc->pubkey_algo == PUBKEY_ALGO_ECDH
 430            || enc->pubkey_algo == PUBKEY_ALGO_RSA
 431            || enc->pubkey_algo == PUBKEY_ALGO_RSA_E
 432            || enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL)
 433     {
 434       /* Note that we also allow type 20 Elgamal keys for decryption.
 435          There are still a couple of those keys in active use as a
 436          subkey.  */
 437
 438       /* FIXME: Store this all in a list and process it later so that
 439          we can prioritize what key to use.  This gives a better user
 440          experience if wildcard keyids are used.  */
 441       if  (!c->dek && ((!enc->keyid[0] && !enc->keyid[1])
 442                        || opt.try_all_secrets
 443                        || have_secret_key_with_kid (enc->keyid)))
 444         {
 445           if(opt.list_only)
 446             result = GPG_ERR_MISSING_ACTION; /* fixme: Use better error code. */
 447           else
 448             {
 449               c->dek = xmalloc_secure_clear (sizeof *c->dek);
 450               if ((result = get_session_key (ctrl, enc, c->dek)))
 451                 {
 452                   /* Error: Delete the DEK. */
 453                   xfree (c->dek);
 454                   c->dek = NULL;
 455                 }
 456             }
 457         }
 458       else
 459         result = GPG_ERR_NO_SECKEY;
 460     }
 461   else
 462     result = GPG_ERR_PUBKEY_ALGO;
 463
 464   if (1)
 465     {
 466       /* Store it for later display.  */
 467       struct kidlist_item *x = xmalloc (sizeof *x);
 468       x->kid[0] = enc->keyid[0];
 469       x->kid[1] = enc->keyid[1];
 470       x->pubkey_algo = enc->pubkey_algo;
 471       x->reason = result;
 472       x->next = c->pkenc_list;
 473       c->pkenc_list = x;
 474
 475       if (!result && opt.verbose > 1)
 476         log_info (_("public key encrypted data: good DEK\n"));
 477     }
 478
 479   free_packet(pkt, NULL);
 480 }
 481
 482
 483 /*
 484  * Print the list of public key encrypted packets which we could
 485  * not decrypt.
 486  */
 487 static void
 488 print_pkenc_list (ctrl_t ctrl, struct kidlist_item *list, int failed)
 489 {
 490   for (; list; list = list->next)
 491     {
 492       PKT_public_key *pk;
 493       const char *algstr;
 494
 495       if (failed && !list->reason)
 496         continue;
 497       if (!failed && list->reason)
 498         continue;
 499
 500       algstr = openpgp_pk_algo_name (list->pubkey_algo);
 501       pk = xmalloc_clear (sizeof *pk);
 502
 503       if (!algstr)
 504         algstr = "[?]";
 505       pk->pubkey_algo = list->pubkey_algo;
 506       if (!get_pubkey (ctrl, pk, list->kid))
 507         {
 508           char *p;
 509           log_info (_("encrypted with %u-bit %s key, ID %s, created %s\n"),
 510                     nbits_from_pk (pk), algstr, keystr_from_pk(pk),
 511                     strtimestamp (pk->timestamp));
 512           p = get_user_id_native (ctrl, list->kid);
 513           log_printf (_("      \"%s\"\n"), p);
 514           xfree (p);
 515         }
 516       else
 517         log_info (_("encrypted with %s key, ID %s\n"),
 518                   algstr, keystr(list->kid));
 519
 520       free_public_key (pk);
 521
 522       if (gpg_err_code (list->reason) == GPG_ERR_NO_SECKEY)
 523         {
 524           if (is_status_enabled())
 525             {
 526               char buf[20];
 527               snprintf (buf, sizeof buf, "%08lX%08lX",
 528                         (ulong)list->kid[0], (ulong)list->kid[1]);
 529               write_status_text (STATUS_NO_SECKEY, buf);
 530             }
 531         }
 532       else if (gpg_err_code (list->reason) == GPG_ERR_MISSING_ACTION)
 533         {
 534           /* Not tested for secret key due to --list-only mode.  */
 535         }
 536       else if (list->reason)
 537         {
 538           log_info (_("public key decryption failed: %s\n"),
 539                     gpg_strerror (list->reason));
 540           write_status_error ("pkdecrypt_failed", list->reason);
 541         }
 542     }
 543 }
 544
 545
 546 static void
 547 proc_encrypted (CTX c, PACKET *pkt)
 548 {
 549   int result = 0;
 550   int early_plaintext = literals_seen;
 551
 552   if (early_plaintext)
 553     {
 554       log_info (_("WARNING: multiple plaintexts seen\n"));
 555       write_status_errcode ("decryption.early_plaintext", GPG_ERR_BAD_DATA);
 556       /* We fail only later so that we can print some more info first.  */
 557     }
 558
 559   if (!opt.quiet)
 560     {
 561       if (c->symkeys>1)
 562         log_info (_("encrypted with %lu passphrases\n"), c->symkeys);
 563       else if (c->symkeys == 1)
 564         log_info (_("encrypted with 1 passphrase\n"));
 565       print_pkenc_list (c->ctrl, c->pkenc_list, 1 );
 566       print_pkenc_list (c->ctrl, c->pkenc_list, 0 );
 567     }
 568
 569   /* FIXME: Figure out the session key by looking at all pkenc packets. */
 570
 571   write_status (STATUS_BEGIN_DECRYPTION);
 572
 573   /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
 574   if (opt.list_only)
 575     result = -1;
 576   else if (!c->dek && !c->last_was_session_key)
 577     {
 578       int algo;
 579       STRING2KEY s2kbuf;
 580       STRING2KEY *s2k = NULL;
 581       int canceled;
 582
 583       if (opt.override_session_key)
 584         {
 585           c->dek = xmalloc_clear (sizeof *c->dek);
 586           result = get_override_session_key (c->dek, opt.override_session_key);
 587           if (result)
 588             {
 589               xfree (c->dek);
 590               c->dek = NULL;
 591             }
 592         }
 593       else
 594         {
 595           /* Assume this is old style conventional encrypted data. */
 596           algo = opt.def_cipher_algo;
 597           if (algo)
 598             log_info (_("assuming %s encrypted data\n"),
 599                       openpgp_cipher_algo_name (algo));
 600           else if (openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
 601             {
 602               algo = opt.def_cipher_algo;
 603               if (!algo)
 604                 algo = opt.s2k_cipher_algo;
 605               log_info (_("IDEA cipher unavailable, "
 606                           "optimistically attempting to use %s instead\n"),
 607                         openpgp_cipher_algo_name (algo));
 608             }
 609           else
 610             {
 611               algo = CIPHER_ALGO_IDEA;
 612               if (!opt.s2k_digest_algo)
 613                 {
 614                   /* If no digest is given we assume SHA-1. */
 615                   s2kbuf.mode = 0;
 616                   s2kbuf.hash_algo = DIGEST_ALGO_SHA1;
 617                   s2k = &s2kbuf;
 618                 }
 619               log_info (_("assuming %s encrypted data\n"), "IDEA");
 620             }
 621
 622           c->dek = passphrase_to_dek (algo, s2k, 0, 0, NULL, &canceled);
 623           if (c->dek)
 624             c->dek->algo_info_printed = 1;
 625           else if (canceled)
 626             result = gpg_error (GPG_ERR_CANCELED);
 627           else
 628             result = gpg_error (GPG_ERR_INV_PASSPHRASE);
 629         }
 630     }
 631   else if (!c->dek)
 632     result = GPG_ERR_NO_SECKEY;
 633
 634   /* Compute compliance with CO_DE_VS.  */
 635   if (!result && is_status_enabled ()
 636       /* Symmetric encryption and asymmetric encryption voids compliance.  */
 637       && (c->symkeys != !!c->pkenc_list )
 638       /* Overriding session key voids compliance.  */
 639       && !opt.override_session_key
 640       /* Check symmetric cipher.  */
 641       && gnupg_cipher_is_compliant (CO_DE_VS, c->dek->algo,
 642                                     GCRY_CIPHER_MODE_CFB))
 643     {
 644       struct kidlist_item *i;
 645       int compliant = 1;
 646       PKT_public_key *pk = xmalloc (sizeof *pk);
 647
 648       if ( !(c->pkenc_list || c->symkeys) )
 649         log_debug ("%s: where else did the session key come from?\n", __func__);
 650
 651       /* Now check that every key used to encrypt the session key is
 652        * compliant.  */
 653       for (i = c->pkenc_list; i && compliant; i = i->next)
 654         {
 655           memset (pk, 0, sizeof *pk);
 656           pk->pubkey_algo = i->pubkey_algo;
 657           if (get_pubkey (c->ctrl, pk, i->kid) != 0
 658               || ! gnupg_pk_is_compliant (CO_DE_VS, pk->pubkey_algo, pk->pkey,
 659                                           nbits_from_pk (pk), NULL))
 660             compliant = 0;
 661           release_public_key_parts (pk);
 662         }
 663
 664       xfree (pk);
 665
 666       if (compliant)
 667         write_status_strings (STATUS_DECRYPTION_COMPLIANCE_MODE,
 668                               gnupg_status_compliance_flag (CO_DE_VS),
 669                               NULL);
 670
 671     }
 672
 673
 674   if (!result)
 675     result = decrypt_data (c->ctrl, c, pkt->pkt.encrypted, c->dek );
 676
 677   /* Trigger the deferred error.  */
 678   if (!result && early_plaintext)
 679     result = gpg_error (GPG_ERR_BAD_DATA);
 680
 681   if (result == -1)
 682     ;
 683   else if (!result
 684            && !opt.ignore_mdc_error
 685            && !pkt->pkt.encrypted->mdc_method)
 686     {
 687       /* The message has been decrypted but does not carry an MDC.
 688        * The option --ignore-mdc-error has also not been used.  To
 689        * avoid attacks changing an MDC message to a non-MDC message,
 690        * we fail here.  */
 691       log_error (_("WARNING: message was not integrity protected\n"));
 692       if (!pkt->pkt.encrypted->mdc_method
 693           && (openpgp_cipher_get_algo_blklen (c->dek->algo) == 8
 694               || c->dek->algo == CIPHER_ALGO_TWOFISH))
 695         {
 696           /* Before 2.2.8 we did not fail hard for a missing MDC if
 697            * one of the old ciphers where used.  Although these cases
 698            * are rare in practice we print a hint on how to decrypt
 699            * such messages.  */
 700           log_string
 701             (GPGRT_LOG_INFO,
 702              _("Hint: If this message was created before the year 2003 it is\n"
 703                "likely that this message is legitimate.  This is because back\n"
 704                "then integrity protection was not widely used.\n"));
 705           log_info (_("Use the option '%s' to decrypt anyway.\n"),
 706                      "--ignore-mdc-error");
 707           write_status_errcode ("nomdc_with_legacy_cipher",
 708                                 GPG_ERR_DECRYPT_FAILED);
 709         }
 710       log_info (_("decryption forced to fail!\n"));
 711       write_status (STATUS_DECRYPTION_FAILED);
 712     }
 713   else if (!result || (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE
 714                        && opt.ignore_mdc_error))
 715     {
 716       write_status (STATUS_DECRYPTION_OKAY);
 717       if (opt.verbose > 1)
 718         log_info(_("decryption okay\n"));
 719       if (pkt->pkt.encrypted->mdc_method && !result)
 720         write_status (STATUS_GOODMDC);
 721       else
 722         log_info (_("WARNING: message was not integrity protected\n"));
 723     }
 724   else if (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE)
 725     {
 726       glo_ctrl.lasterr = result;
 727       log_error (_("WARNING: encrypted message has been manipulated!\n"));
 728       write_status (STATUS_BADMDC);
 729       write_status (STATUS_DECRYPTION_FAILED);
 730     }
 731   else
 732     {
 733       if ((gpg_err_code (result) == GPG_ERR_BAD_KEY
 734            || gpg_err_code (result) == GPG_ERR_CIPHER_ALGO)
 735           && *c->dek->s2k_cacheid != '\0')
 736         {
 737           if (opt.debug)
 738             log_debug ("cleared passphrase cached with ID: %s\n",
 739                        c->dek->s2k_cacheid);
 740           passphrase_clear_cache (c->dek->s2k_cacheid);
 741         }
 742       glo_ctrl.lasterr = result;
 743       write_status (STATUS_DECRYPTION_FAILED);
 744       log_error (_("decryption failed: %s\n"), gpg_strerror (result));
 745       /* Hmmm: does this work when we have encrypted using multiple
 746        * ways to specify the session key (symmmetric and PK). */
 747     }
 748
 749   xfree (c->dek);
 750   c->dek = NULL;
 751   free_packet (pkt, NULL);
 752   c->last_was_session_key = 0;
 753   write_status (STATUS_END_DECRYPTION);
 754
 755   /* Bump the counter even if we have not seen a literal data packet
 756    * inside an encryption container.  This acts as a sentinel in case
 757    * a misplace extra literal data packets follows after this
 758    * encrypted packet.  */
 759   literals_seen++;
 760 }
 761
 762
 763 static void
 764 proc_plaintext( CTX c, PACKET *pkt )
 765 {
 766   PKT_plaintext *pt = pkt->pkt.plaintext;
 767   int any, clearsig, rc;
 768   kbnode_t n;
 769
 770   /* This is a literal data packet.  Bumb a counter for later checks.  */
 771   literals_seen++;
 772
 773   if (pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8))
 774     log_info (_("Note: sender requested \"for-your-eyes-only\"\n"));
 775   else if (opt.verbose)
 776     {
 777       /* We don't use print_utf8_buffer because that would require a
 778        * string change which we don't want in 2.2.  It is also not
 779        * clear whether the filename is always utf-8 encoded.  */
 780       char *tmp = make_printable_string (pt->name, pt->namelen, 0);
 781       log_info (_("original file name='%.*s'\n"), (int)strlen (tmp), tmp);
 782       xfree (tmp);
 783     }
 784
 785   free_md_filter_context (&c->mfx);
 786   if (gcry_md_open (&c->mfx.md, 0, 0))
 787     BUG ();
 788   /* fixme: we may need to push the textfilter if we have sigclass 1
 789    * and no armoring - Not yet tested
 790    * Hmmm, why don't we need it at all if we have sigclass 1
 791    * Should we assume that plaintext in mode 't' has always sigclass 1??
 792    * See: Russ Allbery's mail 1999-02-09
 793    */
 794   any = clearsig = 0;
 795   for (n=c->list; n; n = n->next )
 796     {
 797       if (n->pkt->pkttype == PKT_ONEPASS_SIG)
 798         {
 799           /* The onepass signature case. */
 800           if (n->pkt->pkt.onepass_sig->digest_algo)
 801             {
 802               if (!opt.skip_verify)
 803                 gcry_md_enable (c->mfx.md,
 804                                 n->pkt->pkt.onepass_sig->digest_algo);
 805
 806               any = 1;
 807             }
 808         }
 809       else if (n->pkt->pkttype == PKT_GPG_CONTROL
 810                && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
 811         {
 812           /* The clearsigned message case. */
 813           size_t datalen = n->pkt->pkt.gpg_control->datalen;
 814           const byte *data = n->pkt->pkt.gpg_control->data;
 815
 816           /* Check that we have at least the sigclass and one hash.  */
 817           if  (datalen < 2)
 818             log_fatal ("invalid control packet CTRLPKT_CLEARSIGN_START\n");
 819           /* Note that we don't set the clearsig flag for not-dash-escaped
 820            * documents.  */
 821           clearsig = (*data == 0x01);
 822           for (data++, datalen--; datalen; datalen--, data++)
 823             if (!opt.skip_verify)
 824               gcry_md_enable (c->mfx.md, *data);
 825           any = 1;
 826           break;  /* Stop here as one-pass signature packets are not
 827                      expected.  */
 828         }
 829       else if (n->pkt->pkttype == PKT_SIGNATURE)
 830         {
 831           /* The SIG+LITERAL case that PGP used to use.  */
 832           if (!opt.skip_verify)
 833             gcry_md_enable (c->mfx.md, n->pkt->pkt.signature->digest_algo);
 834           any = 1;
 835         }
 836     }
 837
 838   if (!any && !opt.skip_verify)
 839     {
 840       /* This is for the old GPG LITERAL+SIG case.  It's not legal
 841          according to 2440, so hopefully it won't come up that often.
 842          There is no good way to specify what algorithms to use in
 843          that case, so these there are the historical answer. */
 844         gcry_md_enable (c->mfx.md, DIGEST_ALGO_RMD160);
 845         gcry_md_enable (c->mfx.md, DIGEST_ALGO_SHA1);
 846     }
 847   if (DBG_HASHING)
 848     {
 849       gcry_md_debug (c->mfx.md, "verify");
 850       if (c->mfx.md2)
 851         gcry_md_debug (c->mfx.md2, "verify2");
 852     }
 853
 854   rc=0;
 855
 856   if (literals_seen > 1)
 857     {
 858       log_info (_("WARNING: multiple plaintexts seen\n"));
 859
 860       if (!opt.flags.allow_multiple_messages)
 861         {
 862           write_status_text (STATUS_ERROR, "proc_pkt.plaintext 89_BAD_DATA");
 863           log_inc_errorcount ();
 864           rc = gpg_error (GPG_ERR_UNEXPECTED);
 865         }
 866     }
 867
 868   if (!rc)
 869     {
 870       /* It we are in --verify mode, we do not want to output the
 871        * signed text.  However, if --output is also used we do what
 872        * has been requested and write out the signed data.  */
 873       rc = handle_plaintext (pt, &c->mfx,
 874                              (opt.outfp || opt.outfile)? 0 :  c->sigs_only,
 875                              clearsig);
 876       if (gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only)
 877         {
 878           /* Can't write output but we hash it anyway to check the
 879              signature. */
 880           rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
 881         }
 882     }
 883
 884   if (rc)
 885     log_error ("handle plaintext failed: %s\n", gpg_strerror (rc));
 886
 887   free_packet (pkt, NULL);
 888   c->last_was_session_key = 0;
 889
 890   /* We add a marker control packet instead of the plaintext packet.
 891    * This is so that we can later detect invalid packet sequences.  */
 892   n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
 893   if (c->list)
 894     add_kbnode (c->list, n);
 895   else
 896     c->list = n;
 897 }
 898
 899
 900 static int
 901 proc_compressed_cb (iobuf_t a, void *info)
 902 {
 903   if ( ((CTX)info)->signed_data.used
 904        && ((CTX)info)->signed_data.data_fd != -1)
 905     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
 906                                          ((CTX)info)->signed_data.data_fd);
 907   else
 908     return proc_signature_packets (((CTX)info)->ctrl, info, a,
 909                                    ((CTX)info)->signed_data.data_names,
 910                                    ((CTX)info)->sigfilename );
 911 }
 912
 913
 914 static int
 915 proc_encrypt_cb (iobuf_t a, void *info )
 916 {
 917   CTX c = info;
 918   return proc_encryption_packets (c->ctrl, info, a );
 919 }
 920
 921
 922 static int
 923 proc_compressed (CTX c, PACKET *pkt)
 924 {
 925   PKT_compressed *zd = pkt->pkt.compressed;
 926   int rc;
 927
 928   /*printf("zip: compressed data packet\n");*/
 929   if (c->sigs_only)
 930     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
 931   else if( c->encrypt_only )
 932     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
 933   else
 934     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
 935
 936   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
 937     {
 938       if  (!c->any.uncompress_failed)
 939         {
 940           CTX cc;
 941
 942           for (cc=c; cc; cc = cc->anchor)
 943             cc->any.uncompress_failed = 1;
 944           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
 945         }
 946     }
 947   else if (rc)
 948     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
 949
 950   free_packet (pkt, NULL);
 951   c->last_was_session_key = 0;
 952   return rc;
 953 }
 954
 955
 956 /*
 957  * Check the signature.  If R_PK is not NULL a copy of the public key
 958  * used to verify the signature will be stored there, or NULL if not
 959  * found.  Returns: 0 = valid signature or an error code
 960  */
 961 static int
 962 do_check_sig (CTX c, kbnode_t node, int *is_selfsig,
 963               int *is_expkey, int *is_revkey, PKT_public_key **r_pk)
 964 {
 965   PKT_signature *sig;
 966   gcry_md_hd_t md = NULL;
 967   gcry_md_hd_t md2 = NULL;
 968   gcry_md_hd_t md_good = NULL;
 969   int algo, rc;
 970
 971   if (r_pk)
 972     *r_pk = NULL;
 973
 974   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
 975   if (is_selfsig)
 976     *is_selfsig = 0;
 977   sig = node->pkt->pkt.signature;
 978
 979   algo = sig->digest_algo;
 980   rc = openpgp_md_test_algo (algo);
 981   if (rc)
 982     return rc;
 983
 984   if (sig->sig_class == 0x00)
 985     {
 986       if (c->mfx.md)
 987         {
 988           if (gcry_md_copy (&md, c->mfx.md ))
 989             BUG ();
 990         }
 991       else /* detached signature */
 992         {
 993           /* check_signature() will enable the md. */
 994           if (gcry_md_open (&md, 0, 0 ))
 995             BUG ();
 996         }
 997     }
 998   else if (sig->sig_class == 0x01)
 999     {
1000       /* How do we know that we have to hash the (already hashed) text
1001          in canonical mode ??? (calculating both modes???) */
1002       if (c->mfx.md)
1003         {
1004           if (gcry_md_copy (&md, c->mfx.md ))
1005             BUG ();
1006           if (c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2))
1007             BUG ();
1008         }
1009       else /* detached signature */
1010         {
1011           log_debug ("Do we really need this here?");
1012           /* check_signature() will enable the md*/
1013           if (gcry_md_open (&md, 0, 0 ))
1014             BUG ();
1015           if (gcry_md_open (&md2, 0, 0 ))
1016             BUG ();
1017         }
1018     }
1019   else if ((sig->sig_class&~3) == 0x10
1020            ||   sig->sig_class == 0x18
1021            ||   sig->sig_class == 0x1f
1022            ||   sig->sig_class == 0x20
1023            ||   sig->sig_class == 0x28
1024            ||   sig->sig_class == 0x30)
1025     {
1026       if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1027           || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1028         {
1029           return check_key_signature (c->ctrl, c->list, node, is_selfsig);
1030         }
1031       else if (sig->sig_class == 0x20)
1032         {
1033           log_error (_("standalone revocation - "
1034                        "use \"gpg --import\" to apply\n"));
1035           return GPG_ERR_NOT_PROCESSED;
1036         }
1037       else
1038         {
1039           log_error ("invalid root packet for sigclass %02x\n", sig->sig_class);
1040           return GPG_ERR_SIG_CLASS;
1041         }
1042     }
1043   else
1044     return GPG_ERR_SIG_CLASS;
1045
1046   /* We only get here if we are checking the signature of a binary
1047      (0x00) or text document (0x01).  */
1048   rc = check_signature2 (c->ctrl, sig, md, NULL, is_expkey, is_revkey, r_pk);
1049   if (! rc)
1050     md_good = md;
1051   else if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2)
1052     {
1053       PKT_public_key *pk2;
1054
1055       rc = check_signature2 (c->ctrl, sig, md2, NULL, is_expkey, is_revkey,
1056                              r_pk? &pk2 : NULL);
1057       if (!rc)
1058         {
1059           md_good = md2;
1060           if (r_pk)
1061             {
1062               free_public_key (*r_pk);
1063               *r_pk = pk2;
1064             }
1065         }
1066     }
1067
1068   if (md_good)
1069     {
1070       unsigned char *buffer = gcry_md_read (md_good, sig->digest_algo);
1071       sig->digest_len = gcry_md_get_algo_dlen (map_md_openpgp_to_gcry (algo));
1072       memcpy (sig->digest, buffer, sig->digest_len);
1073     }
1074
1075   gcry_md_close (md);
1076   gcry_md_close (md2);
1077
1078   return rc;
1079 }
1080
1081
1082 static void
1083 print_userid (PACKET *pkt)
1084 {
1085   if (!pkt)
1086     BUG();
1087
1088   if (pkt->pkttype != PKT_USER_ID)
1089     {
1090       es_printf ("ERROR: unexpected packet type %d", pkt->pkttype );
1091       return;
1092     }
1093   if (opt.with_colons)
1094     {
1095       if (pkt->pkt.user_id->attrib_data)
1096         es_printf("%u %lu",
1097                   pkt->pkt.user_id->numattribs,
1098                   pkt->pkt.user_id->attrib_len);
1099       else
1100         es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
1101                             pkt->pkt.user_id->len, ":", NULL);
1102     }
1103   else
1104     print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
1105                        pkt->pkt.user_id->len );
1106 }
1107
1108
1109 /*
1110  * List the keyblock in a user friendly way
1111  */
1112 static void
1113 list_node (CTX c, kbnode_t node)
1114 {
1115   if (!node)
1116     ;
1117   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1118            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1119     {
1120       PKT_public_key *pk = node->pkt->pkt.public_key;
1121
1122       if (opt.with_colons)
1123         {
1124           u32 keyid[2];
1125
1126           keyid_from_pk( pk, keyid );
1127           if (pk->flags.primary)
1128             c->trustletter = (opt.fast_list_mode
1129                               ? 0
1130                               : get_validity_info
1131                                   (c->ctrl,
1132                                    node->pkt->pkttype == PKT_PUBLIC_KEY
1133                                    ? node : NULL,
1134                                    pk, NULL));
1135           es_printf ("%s:", pk->flags.primary? "pub":"sub" );
1136           if (c->trustletter)
1137             es_putc (c->trustletter, es_stdout);
1138           es_printf (":%u:%d:%08lX%08lX:%s:%s::",
1139                      nbits_from_pk( pk ),
1140                      pk->pubkey_algo,
1141                      (ulong)keyid[0],(ulong)keyid[1],
1142                      colon_datestr_from_pk( pk ),
1143                      colon_strtime (pk->expiredate) );
1144           if (pk->flags.primary && !opt.fast_list_mode)
1145             es_putc (get_ownertrust_info (c->ctrl, pk, 1), es_stdout);
1146           es_putc (':', es_stdout);
1147           es_putc ('\n', es_stdout);
1148         }
1149       else
1150         {
1151           print_key_line (c->ctrl, es_stdout, pk, 0);
1152         }
1153
1154       if (opt.keyid_format == KF_NONE && !opt.with_colons)
1155         ; /* Already printed.  */
1156       else if ((pk->flags.primary && opt.fingerprint) || opt.fingerprint > 1)
1157         print_fingerprint (c->ctrl, NULL, pk, 0);
1158
1159       if (pk->flags.primary)
1160         {
1161           int kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
1162
1163           /* Now list all userids with their signatures. */
1164           for (node = node->next; node; node = node->next)
1165             {
1166               if (node->pkt->pkttype == PKT_SIGNATURE)
1167                 {
1168                   list_node (c,  node );
1169                 }
1170               else if (node->pkt->pkttype == PKT_USER_ID)
1171                 {
1172                   if (opt.with_colons)
1173                     es_printf ("%s:::::::::",
1174                                node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1175                   else
1176                     es_printf ("uid%*s",
1177                                kl + (opt.legacy_list_mode? 9:11),
1178                                "" );
1179                   print_userid (node->pkt);
1180                   if (opt.with_colons)
1181                     es_putc (':', es_stdout);
1182                   es_putc ('\n', es_stdout);
1183                 }
1184               else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1185                 {
1186                   list_node(c,  node );
1187                 }
1188             }
1189         }
1190     }
1191   else if (node->pkt->pkttype == PKT_SECRET_KEY
1192            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1193     {
1194
1195       log_debug ("FIXME: No way to print secret key packets here\n");
1196       /* fixme: We may use a function to turn a secret key packet into
1197          a public key one and use that here.  */
1198     }
1199   else if (node->pkt->pkttype == PKT_SIGNATURE)
1200     {
1201       PKT_signature *sig = node->pkt->pkt.signature;
1202       int is_selfsig = 0;
1203       int rc2 = 0;
1204       size_t n;
1205       char *p;
1206       int sigrc = ' ';
1207
1208       if (!opt.verbose)
1209         return;
1210
1211       if (sig->sig_class == 0x20 || sig->sig_class == 0x30)
1212         es_fputs ("rev", es_stdout);
1213       else
1214         es_fputs ("sig", es_stdout);
1215       if (opt.check_sigs)
1216         {
1217           fflush (stdout);
1218           rc2 = do_check_sig (c, node, &is_selfsig, NULL, NULL, NULL);
1219           switch (gpg_err_code (rc2))
1220             {
1221             case 0:                       sigrc = '!'; break;
1222             case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
1223             case GPG_ERR_NO_PUBKEY:
1224             case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
1225             default:                      sigrc = '%'; break;
1226             }
1227         }
1228       else /* Check whether this is a self signature.  */
1229         {
1230           u32 keyid[2];
1231
1232           if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1233               || c->list->pkt->pkttype == PKT_SECRET_KEY )
1234             {
1235               keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1236
1237               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1238                 is_selfsig = 1;
1239             }
1240         }
1241
1242       if (opt.with_colons)
1243         {
1244           es_putc (':', es_stdout);
1245           if (sigrc != ' ')
1246             es_putc (sigrc, es_stdout);
1247           es_printf ("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1248                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1249                      colon_datestr_from_sig (sig),
1250                      colon_expirestr_from_sig (sig));
1251
1252           if (sig->trust_depth || sig->trust_value)
1253             es_printf ("%d %d",sig->trust_depth,sig->trust_value);
1254           es_putc (':', es_stdout);
1255
1256           if (sig->trust_regexp)
1257             es_write_sanitized (es_stdout, sig->trust_regexp,
1258                                 strlen (sig->trust_regexp), ":", NULL);
1259           es_putc (':', es_stdout);
1260         }
1261       else
1262         es_printf ("%c       %s %s   ",
1263                    sigrc, keystr (sig->keyid), datestr_from_sig(sig));
1264       if (sigrc == '%')
1265         es_printf ("[%s] ", gpg_strerror (rc2) );
1266       else if (sigrc == '?')
1267         ;
1268       else if (is_selfsig)
1269         {
1270           if (opt.with_colons)
1271             es_putc (':', es_stdout);
1272           es_fputs (sig->sig_class == 0x18? "[keybind]":"[selfsig]", es_stdout);
1273           if (opt.with_colons)
1274             es_putc (':', es_stdout);
1275         }
1276       else if (!opt.fast_list_mode)
1277         {
1278           p = get_user_id (c->ctrl, sig->keyid, &n, NULL);
1279           es_write_sanitized (es_stdout, p, n,
1280                               opt.with_colons?":":NULL, NULL );
1281           xfree (p);
1282         }
1283       if (opt.with_colons)
1284         es_printf (":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1285       es_putc ('\n', es_stdout);
1286     }
1287   else
1288     log_error ("invalid node with packet of type %d\n", node->pkt->pkttype);
1289 }
1290
1291
1292 int
1293 proc_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1294 {
1295   int rc;
1296   CTX c = xmalloc_clear (sizeof *c);
1297
1298   c->ctrl = ctrl;
1299   c->anchor = anchor;
1300   rc = do_proc_packets (ctrl, c, a);
1301   xfree (c);
1302
1303   return rc;
1304 }
1305
1306
1307 int
1308 proc_signature_packets (ctrl_t ctrl, void *anchor, iobuf_t a,
1309                         strlist_t signedfiles, const char *sigfilename )
1310 {
1311   CTX c = xmalloc_clear (sizeof *c);
1312   int rc;
1313
1314   c->ctrl = ctrl;
1315   c->anchor = anchor;
1316   c->sigs_only = 1;
1317
1318   c->signed_data.data_fd = -1;
1319   c->signed_data.data_names = signedfiles;
1320   c->signed_data.used = !!signedfiles;
1321
1322   c->sigfilename = sigfilename;
1323   rc = do_proc_packets (ctrl, c, a);
1324
1325   /* If we have not encountered any signature we print an error
1326      messages, send a NODATA status back and return an error code.
1327      Using log_error is required because verify_files does not check
1328      error codes for each file but we want to terminate the process
1329      with an error. */
1330   if (!rc && !c->any.sig_seen)
1331     {
1332       write_status_text (STATUS_NODATA, "4");
1333       log_error (_("no signature found\n"));
1334       rc = GPG_ERR_NO_DATA;
1335     }
1336
1337   /* Propagate the signature seen flag upward. Do this only on success
1338      so that we won't issue the nodata status several times.  */
1339   if (!rc && c->anchor && c->any.sig_seen)
1340     c->anchor->any.sig_seen = 1;
1341
1342   xfree (c);
1343   return rc;
1344 }
1345
1346
1347 int
1348 proc_signature_packets_by_fd (ctrl_t ctrl,
1349                               void *anchor, iobuf_t a, int signed_data_fd )
1350 {
1351   int rc;
1352   CTX c;
1353
1354   c = xtrycalloc (1, sizeof *c);
1355   if (!c)
1356     return gpg_error_from_syserror ();
1357
1358   c->ctrl = ctrl;
1359   c->anchor = anchor;
1360   c->sigs_only = 1;
1361
1362   c->signed_data.data_fd = signed_data_fd;
1363   c->signed_data.data_names = NULL;
1364   c->signed_data.used = (signed_data_fd != -1);
1365
1366   rc = do_proc_packets (ctrl, c, a);
1367
1368   /* If we have not encountered any signature we print an error
1369      messages, send a NODATA status back and return an error code.
1370      Using log_error is required because verify_files does not check
1371      error codes for each file but we want to terminate the process
1372      with an error. */
1373   if (!rc && !c->any.sig_seen)
1374     {
1375       write_status_text (STATUS_NODATA, "4");
1376       log_error (_("no signature found\n"));
1377       rc = gpg_error (GPG_ERR_NO_DATA);
1378     }
1379
1380   /* Propagate the signature seen flag upward. Do this only on success
1381      so that we won't issue the nodata status several times. */
1382   if (!rc && c->anchor && c->any.sig_seen)
1383     c->anchor->any.sig_seen = 1;
1384
1385   xfree ( c );
1386   return rc;
1387 }
1388
1389
1390 int
1391 proc_encryption_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1392 {
1393   CTX c = xmalloc_clear (sizeof *c);
1394   int rc;
1395
1396   c->ctrl = ctrl;
1397   c->anchor = anchor;
1398   c->encrypt_only = 1;
1399   rc = do_proc_packets (ctrl, c, a);
1400   xfree (c);
1401   return rc;
1402 }
1403
1404
1405 static int
1406 check_nesting (CTX c)
1407 {
1408   int level;
1409
1410   for (level=0; c; c = c->anchor)
1411     level++;
1412
1413   if (level > MAX_NESTING_DEPTH)
1414     {
1415       log_error ("input data with too deeply nested packets\n");
1416       write_status_text (STATUS_UNEXPECTED, "1");
1417       return GPG_ERR_BAD_DATA;
1418     }
1419
1420   return 0;
1421 }
1422
1423
1424 static int
1425 do_proc_packets (ctrl_t ctrl, CTX c, iobuf_t a)
1426 {
1427   PACKET *pkt;
1428   struct parse_packet_ctx_s parsectx;
1429   int rc = 0;
1430   int any_data = 0;
1431   int newpkt;
1432
1433   rc = check_nesting (c);
1434   if (rc)
1435     return rc;
1436
1437   pkt = xmalloc( sizeof *pkt );
1438   c->iobuf = a;
1439   init_packet(pkt);
1440   init_parse_packet (&parsectx, a);
1441   while ((rc=parse_packet (&parsectx, pkt)) != -1)
1442     {
1443       any_data = 1;
1444       if (rc)
1445         {
1446           free_packet (pkt, &parsectx);
1447           /* Stop processing when an invalid packet has been encountered
1448            * but don't do so when we are doing a --list-packets.  */
1449           if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1450               && opt.list_packets == 0)
1451             break;
1452           continue;
1453         }
1454       newpkt = -1;
1455       if (opt.list_packets)
1456         {
1457           switch (pkt->pkttype)
1458             {
1459             case PKT_PUBKEY_ENC:    proc_pubkey_enc (ctrl, c, pkt); break;
1460             case PKT_SYMKEY_ENC:    proc_symkey_enc (c, pkt); break;
1461             case PKT_ENCRYPTED:
1462             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1463             case PKT_COMPRESSED:    rc = proc_compressed (c, pkt); break;
1464             default: newpkt = 0; break;
1465             }
1466         }
1467       else if (c->sigs_only)
1468         {
1469           switch (pkt->pkttype)
1470             {
1471             case PKT_PUBLIC_KEY:
1472             case PKT_SECRET_KEY:
1473             case PKT_USER_ID:
1474             case PKT_SYMKEY_ENC:
1475             case PKT_PUBKEY_ENC:
1476             case PKT_ENCRYPTED:
1477             case PKT_ENCRYPTED_MDC:
1478               write_status_text( STATUS_UNEXPECTED, "0" );
1479               rc = GPG_ERR_UNEXPECTED;
1480               goto leave;
1481
1482             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1483             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1484             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1485             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1486             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1487             default: newpkt = 0; break;
1488             }
1489         }
1490       else if (c->encrypt_only)
1491         {
1492           switch (pkt->pkttype)
1493             {
1494             case PKT_PUBLIC_KEY:
1495             case PKT_SECRET_KEY:
1496             case PKT_USER_ID:
1497               write_status_text (STATUS_UNEXPECTED, "0");
1498               rc = GPG_ERR_UNEXPECTED;
1499               goto leave;
1500
1501             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1502             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1503             case PKT_PUBKEY_ENC:  proc_pubkey_enc (ctrl, c, pkt); break;
1504             case PKT_ENCRYPTED:
1505             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1506             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1507             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1508             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1509             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1510             default: newpkt = 0; break;
1511             }
1512         }
1513       else
1514         {
1515           switch (pkt->pkttype)
1516             {
1517             case PKT_PUBLIC_KEY:
1518             case PKT_SECRET_KEY:
1519               release_list (c);
1520               c->list = new_kbnode (pkt);
1521               newpkt = 1;
1522               break;
1523             case PKT_PUBLIC_SUBKEY:
1524             case PKT_SECRET_SUBKEY:
1525               newpkt = add_subkey (c, pkt);
1526               break;
1527             case PKT_USER_ID:     newpkt = add_user_id (c, pkt); break;
1528             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1529             case PKT_PUBKEY_ENC:  proc_pubkey_enc (ctrl, c, pkt); break;
1530             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1531             case PKT_ENCRYPTED:
1532             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1533             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1534             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1535             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1536             case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1537             case PKT_RING_TRUST:  newpkt = add_ring_trust (c, pkt); break;
1538             default: newpkt = 0; break;
1539             }
1540         }
1541
1542       if (rc)
1543         goto leave;
1544
1545       /* This is a very ugly construct and frankly, I don't remember why
1546        * I used it.  Adding the MDC check here is a hack.
1547        * The right solution is to initiate another context for encrypted
1548        * packet and not to reuse the current one ...  It works right
1549        * when there is a compression packet between which adds just
1550        * an extra layer.
1551        * Hmmm: Rewrite this whole module here??
1552        */
1553       if (pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC)
1554         c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1555
1556       if (newpkt == -1)
1557         ;
1558       else if (newpkt)
1559         {
1560           pkt = xmalloc (sizeof *pkt);
1561           init_packet (pkt);
1562         }
1563       else
1564         free_packet (pkt, &parsectx);
1565     }
1566
1567   if (rc == GPG_ERR_INV_PACKET)
1568     write_status_text (STATUS_NODATA, "3");
1569
1570   if (any_data)
1571     rc = 0;
1572   else if (rc == -1)
1573     write_status_text (STATUS_NODATA, "2");
1574
1575
1576  leave:
1577   release_list (c);
1578   xfree(c->dek);
1579   free_packet (pkt, &parsectx);
1580   deinit_parse_packet (&parsectx);
1581   xfree (pkt);
1582   free_md_filter_context (&c->mfx);
1583   return rc;
1584 }
1585
1586
1587 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1588    of the notation data. */
1589 static pka_info_t *
1590 get_pka_address (PKT_signature *sig)
1591 {
1592   pka_info_t *pka = NULL;
1593   struct notation *nd,*notation;
1594
1595   notation=sig_to_notation(sig);
1596
1597   for(nd=notation;nd;nd=nd->next)
1598     {
1599       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1600         continue; /* Not the notation we want. */
1601
1602       /* For now we only use the first valid PKA notation. In future
1603          we might want to keep additional PKA notations in a linked
1604          list. */
1605       if (is_valid_mailbox (nd->value))
1606         {
1607           pka = xmalloc (sizeof *pka + strlen(nd->value));
1608           pka->valid = 0;
1609           pka->checked = 0;
1610           pka->uri = NULL;
1611           strcpy (pka->email, nd->value);
1612           break;
1613         }
1614     }
1615
1616   free_notation(notation);
1617
1618   return pka;
1619 }
1620
1621
1622 /* Return the URI from a DNS PKA record.  If this record has already
1623    be retrieved for the signature we merely return it; if not we go
1624    out and try to get that DNS record. */
1625 static const char *
1626 pka_uri_from_sig (CTX c, PKT_signature *sig)
1627 {
1628   if (!sig->flags.pka_tried)
1629     {
1630       log_assert (!sig->pka_info);
1631       sig->flags.pka_tried = 1;
1632       sig->pka_info = get_pka_address (sig);
1633       if (sig->pka_info)
1634         {
1635           char *url;
1636           unsigned char *fpr;
1637           size_t fprlen;
1638
1639           if (!gpg_dirmngr_get_pka (c->ctrl, sig->pka_info->email,
1640                                     &fpr, &fprlen, &url))
1641             {
1642               if (fpr && fprlen == sizeof sig->pka_info->fpr)
1643                 {
1644                   memcpy (sig->pka_info->fpr, fpr, fprlen);
1645                   if (url)
1646                     {
1647                       sig->pka_info->valid = 1;
1648                       if (!*url)
1649                         xfree (url);
1650                       else
1651                         sig->pka_info->uri = url;
1652                       url = NULL;
1653                     }
1654                 }
1655               xfree (fpr);
1656               xfree (url);
1657             }
1658         }
1659     }
1660   return sig->pka_info? sig->pka_info->uri : NULL;
1661 }
1662
1663
1664 /* Return true if the AKL has the WKD method specified.  */
1665 static int
1666 akl_has_wkd_method (void)
1667 {
1668   struct akl *akl;
1669
1670   for (akl = opt.auto_key_locate; akl; akl = akl->next)
1671     if (akl->type == AKL_WKD)
1672       return 1;
1673   return 0;
1674 }
1675
1676
1677 /* Return the ISSUER fingerprint buffer and its lenbgth at R_LEN.
1678  * Returns NULL if not available.  The returned buffer is valid as
1679  * long as SIG is not modified.  */
1680 const byte *
1681 issuer_fpr_raw (PKT_signature *sig, size_t *r_len)
1682 {
1683   const byte *p;
1684   size_t n;
1685
1686   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_ISSUER_FPR, &n);
1687   if (p && n == 21 && p[0] == 4)
1688     {
1689       *r_len = n - 1;
1690       return p+1;
1691     }
1692   *r_len = 0;
1693   return NULL;
1694 }
1695
1696
1697 /* Return the ISSUER fingerprint string in human readable format if
1698  * available.  Caller must release the string.  */
1699 /* FIXME: Move to another file.  */
1700 char *
1701 issuer_fpr_string (PKT_signature *sig)
1702 {
1703   const byte *p;
1704   size_t n;
1705
1706   p = issuer_fpr_raw (sig, &n);
1707   return p? bin2hex (p, n, NULL) : NULL;
1708 }
1709
1710
1711 static void
1712 print_good_bad_signature (int statno, const char *keyid_str, kbnode_t un,
1713                           PKT_signature *sig, int rc)
1714 {
1715   char *p;
1716
1717   write_status_text_and_buffer (statno, keyid_str,
1718                                 un? un->pkt->pkt.user_id->name:"[?]",
1719                                 un? un->pkt->pkt.user_id->len:3,
1720                                 -1);
1721
1722   if (un)
1723     p = utf8_to_native (un->pkt->pkt.user_id->name,
1724                         un->pkt->pkt.user_id->len, 0);
1725   else
1726     p = xstrdup ("[?]");
1727
1728   if (rc)
1729     log_info (_("BAD signature from \"%s\""), p);
1730   else if (sig->flags.expired)
1731     log_info (_("Expired signature from \"%s\""), p);
1732   else
1733     log_info (_("Good signature from \"%s\""), p);
1734
1735   xfree (p);
1736 }
1737
1738
1739 static int
1740 check_sig_and_print (CTX c, kbnode_t node)
1741 {
1742   PKT_signature *sig = node->pkt->pkt.signature;
1743   const char *astr;
1744   int rc;
1745   int is_expkey = 0;
1746   int is_revkey = 0;
1747   char *issuer_fpr = NULL;
1748   PKT_public_key *pk = NULL;  /* The public key for the signature or NULL. */
1749   int tried_ks_by_fpr;
1750
1751   if (opt.skip_verify)
1752     {
1753       log_info(_("signature verification suppressed\n"));
1754       return 0;
1755     }
1756
1757   /* Check that the message composition is valid.
1758    *
1759    * Per RFC-2440bis (-15) allowed:
1760    *
1761    * S{1,n}           -- detached signature.
1762    * S{1,n} P         -- old style PGP2 signature
1763    * O{1,n} P S{1,n}  -- standard OpenPGP signature.
1764    * C P S{1,n}       -- cleartext signature.
1765    *
1766    *
1767    *      O = One-Pass Signature packet.
1768    *      S = Signature packet.
1769    *      P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1770    *             (Note that the current rfc2440bis draft also allows
1771    *              for a signed message but that does not work as it
1772    *              introduces ambiguities.)
1773    *          We keep track of these packages using the marker packet
1774    *          CTRLPKT_PLAINTEXT_MARK.
1775    *      C = Marker packet for cleartext signatures.
1776    *
1777    * We reject all other messages.
1778    *
1779    * Actually we are calling this too often, i.e. for verification of
1780    * each message but better have some duplicate work than to silently
1781    * introduce a bug here.
1782    */
1783   {
1784     kbnode_t n;
1785     int n_onepass, n_sig;
1786
1787 /*     log_debug ("checking signature packet composition\n"); */
1788 /*     dump_kbnode (c->list); */
1789
1790     n = c->list;
1791     log_assert (n);
1792     if ( n->pkt->pkttype == PKT_SIGNATURE )
1793       {
1794         /* This is either "S{1,n}" case (detached signature) or
1795            "S{1,n} P" (old style PGP2 signature). */
1796         for (n = n->next; n; n = n->next)
1797           if (n->pkt->pkttype != PKT_SIGNATURE)
1798             break;
1799         if (!n)
1800           ; /* Okay, this is a detached signature.  */
1801         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1802                  && (n->pkt->pkt.gpg_control->control
1803                      == CTRLPKT_PLAINTEXT_MARK) )
1804           {
1805             if (n->next)
1806               goto ambiguous;  /* We only allow one P packet. */
1807           }
1808         else
1809           goto ambiguous;
1810       }
1811     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1812       {
1813         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1814         for (n_onepass=1, n = n->next;
1815              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1816           n_onepass++;
1817         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1818                     && (n->pkt->pkt.gpg_control->control
1819                         == CTRLPKT_PLAINTEXT_MARK)))
1820           goto ambiguous;
1821         for (n_sig=0, n = n->next;
1822              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1823           n_sig++;
1824         if (!n_sig)
1825           goto ambiguous;
1826
1827         /* If we wanted to disallow multiple sig verification, we'd do
1828            something like this:
1829
1830            if (n && !opt.allow_multisig_verification)
1831              goto ambiguous;
1832
1833            However, now that we have --allow-multiple-messages, this
1834            can stay allowable as we can't get here unless multiple
1835            messages (i.e. multiple literals) are allowed. */
1836
1837         if (n_onepass != n_sig)
1838           {
1839             log_info ("number of one-pass packets does not match "
1840                       "number of signature packets\n");
1841             goto ambiguous;
1842           }
1843       }
1844     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1845              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1846       {
1847         /* This is the "C P S{1,n}" case (clear text signature). */
1848         n = n->next;
1849         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1850                     && (n->pkt->pkt.gpg_control->control
1851                         == CTRLPKT_PLAINTEXT_MARK)))
1852           goto ambiguous;
1853         for (n_sig=0, n = n->next;
1854              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1855           n_sig++;
1856         if (n || !n_sig)
1857           goto ambiguous;
1858       }
1859     else
1860       {
1861       ambiguous:
1862         log_error(_("can't handle this ambiguous signature data\n"));
1863         return 0;
1864       }
1865   }
1866
1867   if (sig->signers_uid)
1868     write_status_buffer (STATUS_NEWSIG,
1869                          sig->signers_uid, strlen (sig->signers_uid), 0);
1870   else
1871     write_status_text (STATUS_NEWSIG, NULL);
1872
1873   astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1874   issuer_fpr = issuer_fpr_string (sig);
1875
1876   if (issuer_fpr)
1877     {
1878       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1879       log_info (_("               using %s key %s\n"),
1880                 astr? astr: "?", issuer_fpr);
1881
1882     }
1883   else if (!keystrlen () || keystrlen () > 8)
1884     {
1885       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1886       log_info (_("               using %s key %s\n"),
1887                 astr? astr: "?", keystr(sig->keyid));
1888     }
1889   else /* Legacy format.  */
1890     log_info (_("Signature made %s using %s key ID %s\n"),
1891               asctimestamp(sig->timestamp), astr? astr: "?",
1892               keystr(sig->keyid));
1893
1894   /* In verbose mode print the signers UID.  */
1895   if (sig->signers_uid)
1896     log_info (_("               issuer \"%s\"\n"), sig->signers_uid);
1897
1898   rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1899
1900   /* If the key isn't found, check for a preferred keyserver.  */
1901   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && sig->flags.pref_ks)
1902     {
1903       const byte *p;
1904       int seq = 0;
1905       size_t n;
1906
1907       while ((p=enum_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1908         {
1909           /* According to my favorite copy editor, in English grammar,
1910              you say "at" if the key is located on a web page, but
1911              "from" if it is located on a keyserver.  I'm not going to
1912              even try to make two strings here :) */
1913           log_info(_("Key available at: ") );
1914           print_utf8_buffer (log_get_stream(), p, n);
1915           log_printf ("\n");
1916
1917           if (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1918               && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1919             {
1920               struct keyserver_spec *spec;
1921
1922               spec = parse_preferred_keyserver (sig);
1923               if (spec)
1924                 {
1925                   int res;
1926
1927                   free_public_key (pk);
1928                   pk = NULL;
1929                   glo_ctrl.in_auto_key_retrieve++;
1930                   res = keyserver_import_keyid (c->ctrl, sig->keyid,spec, 1);
1931                   glo_ctrl.in_auto_key_retrieve--;
1932                   if (!res)
1933                     rc = do_check_sig (c, node, NULL,
1934                                        &is_expkey, &is_revkey, &pk);
1935                   free_keyserver_spec (spec);
1936
1937                   if (!rc)
1938                     break;
1939                 }
1940             }
1941         }
1942     }
1943
1944   /* If the avove methods didn't work, our next try is to use the URI
1945    * from a DNS PKA record.  */
1946   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1947       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
1948       && (opt.keyserver_options.options & KEYSERVER_HONOR_PKA_RECORD))
1949     {
1950       const char *uri = pka_uri_from_sig (c, sig);
1951
1952       if (uri)
1953         {
1954           /* FIXME: We might want to locate the key using the
1955              fingerprint instead of the keyid. */
1956           int res;
1957           struct keyserver_spec *spec;
1958
1959           spec = parse_keyserver_uri (uri, 1);
1960           if (spec)
1961             {
1962               free_public_key (pk);
1963               pk = NULL;
1964               glo_ctrl.in_auto_key_retrieve++;
1965               res = keyserver_import_keyid (c->ctrl, sig->keyid, spec, 1);
1966               glo_ctrl.in_auto_key_retrieve--;
1967               free_keyserver_spec (spec);
1968               if (!res)
1969                 rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1970             }
1971         }
1972     }
1973
1974   /* If the above methods didn't work, our next try is to locate
1975    * the key via its fingerprint from a keyserver.  This requires
1976    * that the signers fingerprint is encoded in the signature.  We
1977    * favor this over the WKD method (to be tried next), because an
1978    * arbitrary keyserver is less subject to web bug like monitoring.  */
1979   tried_ks_by_fpr = 0;
1980   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1981       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1982       && keyserver_any_configured (c->ctrl))
1983     {
1984       int res;
1985       const byte *p;
1986       size_t n;
1987
1988       p = issuer_fpr_raw (sig, &n);
1989       if (p)
1990         {
1991           /* v4 packet with a SHA-1 fingerprint.  */
1992           free_public_key (pk);
1993           pk = NULL;
1994           glo_ctrl.in_auto_key_retrieve++;
1995           res = keyserver_import_fprint (c->ctrl, p, n, opt.keyserver, 1);
1996           tried_ks_by_fpr = 1;
1997           glo_ctrl.in_auto_key_retrieve--;
1998           if (!res)
1999             rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2000         }
2001     }
2002
2003   /* If the above methods didn't work, our next try is to retrieve the
2004    * key from the WKD. */
2005   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2006       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
2007       && !opt.flags.disable_signer_uid
2008       && akl_has_wkd_method ()
2009       && sig->signers_uid)
2010     {
2011       int res;
2012
2013       free_public_key (pk);
2014       pk = NULL;
2015       glo_ctrl.in_auto_key_retrieve++;
2016       res = keyserver_import_wkd (c->ctrl, sig->signers_uid, 1, NULL, NULL);
2017       glo_ctrl.in_auto_key_retrieve--;
2018       /* Fixme: If the fingerprint is embedded in the signature,
2019        * compare it to the fingerprint of the returned key.  */
2020       if (!res)
2021         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2022     }
2023
2024   /* If the above methods did't work, our next try is to use a
2025    * keyserver.  */
2026   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2027       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
2028       && !tried_ks_by_fpr
2029       && keyserver_any_configured (c->ctrl))
2030     {
2031       int res;
2032
2033       free_public_key (pk);
2034       pk = NULL;
2035       glo_ctrl.in_auto_key_retrieve++;
2036       res = keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver, 1);
2037       glo_ctrl.in_auto_key_retrieve--;
2038       if (!res)
2039         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2040     }
2041
2042   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
2043     {
2044       kbnode_t un, keyblock;
2045       int count = 0;
2046       int statno;
2047       char keyid_str[50];
2048       PKT_public_key *mainpk = NULL;
2049
2050       if (rc)
2051         statno = STATUS_BADSIG;
2052       else if (sig->flags.expired)
2053         statno = STATUS_EXPSIG;
2054       else if (is_expkey)
2055         statno = STATUS_EXPKEYSIG;
2056       else if(is_revkey)
2057         statno = STATUS_REVKEYSIG;
2058       else
2059         statno = STATUS_GOODSIG;
2060
2061       /* FIXME: We should have the public key in PK and thus the
2062        * keyblock has already been fetched.  Thus we could use the
2063        * fingerprint or PK itself to lookup the entire keyblock.  That
2064        * would best be done with a cache.  */
2065       keyblock = get_pubkeyblock_for_sig (c->ctrl, sig);
2066
2067       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX [uncertain] ",
2068                 (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2069
2070       /* Find and print the primary user ID along with the
2071          "Good|Expired|Bad signature" line.  */
2072       for (un=keyblock; un; un = un->next)
2073         {
2074           int valid;
2075
2076           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
2077             {
2078               mainpk = un->pkt->pkt.public_key;
2079               continue;
2080             }
2081           if (un->pkt->pkttype != PKT_USER_ID)
2082             continue;
2083           if (!un->pkt->pkt.user_id->created)
2084             continue;
2085           if (un->pkt->pkt.user_id->flags.revoked)
2086             continue;
2087           if (un->pkt->pkt.user_id->flags.expired)
2088             continue;
2089           if (!un->pkt->pkt.user_id->flags.primary)
2090             continue;
2091           /* We want the textual primary user ID here */
2092           if (un->pkt->pkt.user_id->attrib_data)
2093             continue;
2094
2095           log_assert (mainpk);
2096
2097           /* Since this is just informational, don't actually ask the
2098              user to update any trust information.  (Note: we register
2099              the signature later.)  Because print_good_bad_signature
2100              does not print a LF we need to compute the validity
2101              before calling that function.  */
2102           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2103             valid = get_validity (c->ctrl, keyblock, mainpk,
2104                                   un->pkt->pkt.user_id, NULL, 0);
2105           else
2106             valid = 0; /* Not used.  */
2107
2108           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2109
2110           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2111
2112           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2113             log_printf (" [%s]\n",trust_value_to_string(valid));
2114           else
2115             log_printf ("\n");
2116
2117           count++;
2118         }
2119
2120       log_assert (mainpk);
2121
2122       /* In case we did not found a valid textual userid above
2123          we print the first user id packet or a "[?]" instead along
2124          with the "Good|Expired|Bad signature" line.  */
2125       if (!count)
2126         {
2127           /* Try for an invalid textual userid */
2128           for (un=keyblock; un; un = un->next)
2129             {
2130               if (un->pkt->pkttype == PKT_USER_ID
2131                   && !un->pkt->pkt.user_id->attrib_data)
2132                 break;
2133             }
2134
2135           /* Try for any userid at all */
2136           if (!un)
2137             {
2138               for (un=keyblock; un; un = un->next)
2139                 {
2140                   if (un->pkt->pkttype == PKT_USER_ID)
2141                     break;
2142                 }
2143             }
2144
2145           if (opt.trust_model==TM_ALWAYS || !un)
2146             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2147
2148           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2149
2150           if (opt.trust_model != TM_ALWAYS && un)
2151             log_printf (" %s",_("[uncertain]") );
2152           log_printf ("\n");
2153         }
2154
2155       /* If we have a good signature and already printed
2156        * the primary user ID, print all the other user IDs */
2157       if (count
2158           && !rc
2159           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
2160         {
2161           char *p;
2162           for( un=keyblock; un; un = un->next)
2163             {
2164               if (un->pkt->pkttype != PKT_USER_ID)
2165                 continue;
2166               if ((un->pkt->pkt.user_id->flags.revoked
2167                    || un->pkt->pkt.user_id->flags.expired)
2168                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
2169                 continue;
2170               /* Skip textual primary user ids which we printed above. */
2171               if (un->pkt->pkt.user_id->flags.primary
2172                   && !un->pkt->pkt.user_id->attrib_data )
2173                 continue;
2174
2175               /* If this user id has attribute data, print that.  */
2176               if (un->pkt->pkt.user_id->attrib_data)
2177                 {
2178                   dump_attribs (un->pkt->pkt.user_id, mainpk);
2179
2180                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
2181                     show_photos (c->ctrl,
2182                                  un->pkt->pkt.user_id->attribs,
2183                                  un->pkt->pkt.user_id->numattribs,
2184                                  mainpk ,un->pkt->pkt.user_id);
2185                 }
2186
2187               p = utf8_to_native (un->pkt->pkt.user_id->name,
2188                                   un->pkt->pkt.user_id->len, 0);
2189               log_info (_("                aka \"%s\""), p);
2190               xfree (p);
2191
2192               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2193                 {
2194                   const char *valid;
2195
2196                   if (un->pkt->pkt.user_id->flags.revoked)
2197                     valid = _("revoked");
2198                   else if (un->pkt->pkt.user_id->flags.expired)
2199                     valid = _("expired");
2200                   else
2201                     /* Since this is just informational, don't
2202                        actually ask the user to update any trust
2203                        information.  */
2204                     valid = (trust_value_to_string
2205                              (get_validity (c->ctrl, keyblock, mainpk,
2206                                             un->pkt->pkt.user_id, NULL, 0)));
2207                   log_printf (" [%s]\n",valid);
2208                 }
2209               else
2210                 log_printf ("\n");
2211             }
2212         }
2213
2214       /* For good signatures print notation data.  */
2215       if (!rc)
2216         {
2217           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
2218             show_policy_url (sig, 0, 1);
2219           else
2220             show_policy_url (sig, 0, 2);
2221
2222           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
2223             show_keyserver_url (sig, 0, 1);
2224           else
2225             show_keyserver_url (sig, 0, 2);
2226
2227           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
2228             show_notation
2229               (sig, 0, 1,
2230                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
2231                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
2232           else
2233             show_notation (sig, 0, 2, 0);
2234         }
2235
2236       /* For good signatures print the VALIDSIG status line.  */
2237       if (!rc && is_status_enabled () && pk)
2238         {
2239           char pkhex[MAX_FINGERPRINT_LEN*2+1];
2240           char mainpkhex[MAX_FINGERPRINT_LEN*2+1];
2241
2242           hexfingerprint (pk, pkhex, sizeof pkhex);
2243           hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
2244
2245           /* TODO: Replace the reserved '0' in the field below with
2246              bits for status flags (policy url, notation, etc.).  */
2247           write_status_printf (STATUS_VALIDSIG,
2248                                "%s %s %lu %lu %d 0 %d %d %02X %s",
2249                                pkhex,
2250                                strtimestamp (sig->timestamp),
2251                                (ulong)sig->timestamp,
2252                                (ulong)sig->expiredate,
2253                                sig->version, sig->pubkey_algo,
2254                                sig->digest_algo,
2255                                sig->sig_class,
2256                                mainpkhex);
2257         }
2258
2259       /* Print compliance warning for Good signatures.  */
2260       if (!rc && pk && !opt.quiet
2261           && !gnupg_pk_is_compliant (opt.compliance, pk->pubkey_algo,
2262                                      pk->pkey, nbits_from_pk (pk), NULL))
2263         {
2264           log_info (_("WARNING: This key is not suitable for signing"
2265                       " in %s mode\n"),
2266                     gnupg_compliance_option_string (opt.compliance));
2267         }
2268
2269       /* For good signatures compute and print the trust information.
2270          Note that in the Tofu trust model this may ask the user on
2271          how to resolve a conflict.  */
2272       if (!rc)
2273         {
2274           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
2275             pka_uri_from_sig (c, sig); /* Make sure PKA info is available. */
2276           rc = check_signatures_trust (c->ctrl, sig);
2277         }
2278
2279       /* Print extra information about the signature.  */
2280       if (sig->flags.expired)
2281         {
2282           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2283           rc = GPG_ERR_GENERAL; /* Need a better error here?  */
2284         }
2285       else if (sig->expiredate)
2286         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2287
2288       if (opt.verbose)
2289         {
2290           char pkstrbuf[PUBKEY_STRING_SIZE];
2291
2292           if (pk)
2293             pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
2294           else
2295             *pkstrbuf = 0;
2296
2297           log_info (_("%s signature, digest algorithm %s%s%s\n"),
2298                     sig->sig_class==0x00?_("binary"):
2299                     sig->sig_class==0x01?_("textmode"):_("unknown"),
2300                     gcry_md_algo_name (sig->digest_algo),
2301                     *pkstrbuf?_(", key algorithm "):"", pkstrbuf);
2302         }
2303
2304       /* Print final warnings.  */
2305       if (!rc && !c->signed_data.used)
2306         {
2307           /* Signature is basically good but we test whether the
2308              deprecated command
2309                gpg --verify FILE.sig
2310              was used instead of
2311                gpg --verify FILE.sig FILE
2312              to verify a detached signature.  If we figure out that a
2313              data file with a matching name exists, we print a warning.
2314
2315              The problem is that the first form would also verify a
2316              standard signature.  This behavior could be used to
2317              create a made up .sig file for a tarball by creating a
2318              standard signature from a valid detached signature packet
2319              (for example from a signed git tag).  Then replace the
2320              sig file on the FTP server along with a changed tarball.
2321              Using the first form the verify command would correctly
2322              verify the signature but don't even consider the tarball.  */
2323           kbnode_t n;
2324           char *dfile;
2325
2326           dfile = get_matching_datafile (c->sigfilename);
2327           if (dfile)
2328             {
2329               for (n = c->list; n; n = n->next)
2330                 if (n->pkt->pkttype != PKT_SIGNATURE)
2331                   break;
2332               if (n)
2333                 {
2334                   /* Not only signature packets in the tree thus this
2335                      is not a detached signature.  */
2336                   log_info (_("WARNING: not a detached signature; "
2337                               "file '%s' was NOT verified!\n"), dfile);
2338                 }
2339               xfree (dfile);
2340             }
2341         }
2342
2343       /* Compute compliance with CO_DE_VS.  */
2344       if (pk && is_status_enabled ()
2345           && gnupg_pk_is_compliant (CO_DE_VS, pk->pubkey_algo, pk->pkey,
2346                                     nbits_from_pk (pk), NULL)
2347           && gnupg_digest_is_compliant (CO_DE_VS, sig->digest_algo))
2348         write_status_strings (STATUS_VERIFICATION_COMPLIANCE_MODE,
2349                               gnupg_status_compliance_flag (CO_DE_VS),
2350                               NULL);
2351
2352       free_public_key (pk);
2353       pk = NULL;
2354       release_kbnode( keyblock );
2355       if (rc)
2356         g10_errors_seen = 1;
2357       if (opt.batch && rc)
2358         g10_exit (1);
2359     }
2360   else
2361     {
2362       write_status_printf (STATUS_ERRSIG, "%08lX%08lX %d %d %02x %lu %d %s",
2363                            (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2364                            sig->pubkey_algo, sig->digest_algo,
2365                            sig->sig_class, (ulong)sig->timestamp,
2366                            gpg_err_code (rc),
2367                            issuer_fpr? issuer_fpr:"-");
2368       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2369         {
2370           write_status_printf (STATUS_NO_PUBKEY, "%08lX%08lX",
2371                                (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2372         }
2373       if (gpg_err_code (rc) != GPG_ERR_NOT_PROCESSED)
2374         log_error (_("Can't check signature: %s\n"), gpg_strerror (rc));
2375     }
2376
2377   free_public_key (pk);
2378   xfree (issuer_fpr);
2379   return rc;
2380 }
2381
2382
2383 /*
2384  * Process the tree which starts at node
2385  */
2386 static void
2387 proc_tree (CTX c, kbnode_t node)
2388 {
2389   kbnode_t n1;
2390   int rc;
2391
2392   if (opt.list_packets || opt.list_only)
2393     return;
2394
2395   /* We must skip our special plaintext marker packets here because
2396      they may be the root packet.  These packets are only used in
2397      additional checks and skipping them here doesn't matter.  */
2398   while (node
2399          && node->pkt->pkttype == PKT_GPG_CONTROL
2400           && node->pkt->pkt.gpg_control->control == CTRLPKT_PLAINTEXT_MARK)
2401     {
2402       node = node->next;
2403     }
2404   if (!node)
2405     return;
2406
2407   c->trustletter = ' ';
2408   if (node->pkt->pkttype == PKT_PUBLIC_KEY
2409       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2410     {
2411       merge_keys_and_selfsig (c->ctrl, node);
2412       list_node (c, node);
2413     }
2414   else if (node->pkt->pkttype == PKT_SECRET_KEY)
2415     {
2416       merge_keys_and_selfsig (c->ctrl, node);
2417       list_node (c, node);
2418     }
2419   else if (node->pkt->pkttype == PKT_ONEPASS_SIG)
2420     {
2421       /* Check all signatures.  */
2422       if (!c->any.data)
2423         {
2424           int use_textmode = 0;
2425
2426           free_md_filter_context (&c->mfx);
2427           /* Prepare to create all requested message digests.  */
2428           rc = gcry_md_open (&c->mfx.md, 0, 0);
2429           if (rc)
2430             goto hash_err;
2431
2432           /* Fixme: why looking for the signature packet and not the
2433              one-pass packet?  */
2434           for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2435             gcry_md_enable (c->mfx.md, n1->pkt->pkt.signature->digest_algo);
2436
2437           if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2438             use_textmode = 1;
2439
2440           /* Ask for file and hash it. */
2441           if (c->sigs_only)
2442             {
2443               if (c->signed_data.used && c->signed_data.data_fd != -1)
2444                 rc = hash_datafile_by_fd (c->mfx.md, NULL,
2445                                           c->signed_data.data_fd,
2446                                           use_textmode);
2447               else
2448                 rc = hash_datafiles (c->mfx.md, NULL,
2449                                      c->signed_data.data_names,
2450                                      c->sigfilename,
2451                                      use_textmode);
2452             }
2453           else
2454             {
2455               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2456                                               iobuf_get_real_fname (c->iobuf),
2457                                               use_textmode);
2458             }
2459
2460         hash_err:
2461           if (rc)
2462             {
2463               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2464               return;
2465             }
2466         }
2467       else if (c->signed_data.used)
2468         {
2469           log_error (_("not a detached signature\n"));
2470           return;
2471         }
2472
2473       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2474         check_sig_and_print (c, n1);
2475
2476     }
2477   else if (node->pkt->pkttype == PKT_GPG_CONTROL
2478            && node->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
2479     {
2480       /* Clear text signed message.  */
2481       if (!c->any.data)
2482         {
2483           log_error ("cleartext signature without data\n");
2484           return;
2485         }
2486       else if (c->signed_data.used)
2487         {
2488           log_error (_("not a detached signature\n"));
2489           return;
2490         }
2491
2492       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2493         check_sig_and_print (c, n1);
2494
2495     }
2496   else if (node->pkt->pkttype == PKT_SIGNATURE)
2497     {
2498       PKT_signature *sig = node->pkt->pkt.signature;
2499       int multiple_ok = 1;
2500
2501       n1 = find_next_kbnode (node, PKT_SIGNATURE);
2502       if (n1)
2503         {
2504           byte class = sig->sig_class;
2505           byte hash  = sig->digest_algo;
2506
2507           for (; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2508             {
2509               /* We can't currently handle multiple signatures of
2510                * different classes (we'd pretty much have to run a
2511                * different hash context for each), but if they are all
2512                * the same and it is detached signature, we make an
2513                * exception.  Note that the old code also disallowed
2514                * multiple signatures if the digest algorithms are
2515                * different.  We softened this restriction only for
2516                * detached signatures, to be on the safe side. */
2517               if (n1->pkt->pkt.signature->sig_class != class
2518                   || (c->any.data
2519                       && n1->pkt->pkt.signature->digest_algo != hash))
2520                 {
2521                   multiple_ok = 0;
2522                   log_info (_("WARNING: multiple signatures detected.  "
2523                               "Only the first will be checked.\n"));
2524                   break;
2525                 }
2526             }
2527         }
2528
2529       if (sig->sig_class != 0x00 && sig->sig_class != 0x01)
2530         {
2531           log_info(_("standalone signature of class 0x%02x\n"), sig->sig_class);
2532         }
2533       else if (!c->any.data)
2534         {
2535           /* Detached signature */
2536           free_md_filter_context (&c->mfx);
2537           rc = gcry_md_open (&c->mfx.md, sig->digest_algo, 0);
2538           if (rc)
2539             goto detached_hash_err;
2540
2541           if (multiple_ok)
2542             {
2543               /* If we have and want to handle multiple signatures we
2544                * need to enable all hash algorithms for the context.  */
2545               for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE)); )
2546                 if (!openpgp_md_test_algo (n1->pkt->pkt.signature->digest_algo))
2547                   gcry_md_enable (c->mfx.md,
2548                                   map_md_openpgp_to_gcry
2549                                   (n1->pkt->pkt.signature->digest_algo));
2550             }
2551
2552           if (RFC2440 || RFC4880)
2553             ; /* Strict RFC mode.  */
2554           else if (sig->digest_algo == DIGEST_ALGO_SHA1
2555                    && sig->pubkey_algo == PUBKEY_ALGO_DSA
2556                    && sig->sig_class == 0x01)
2557             {
2558               /* Enable a workaround for a pgp5 bug when the detached
2559                * signature has been created in textmode.  Note that we
2560                * do not implement this for multiple signatures with
2561                * different hash algorithms. */
2562               rc = gcry_md_open (&c->mfx.md2, sig->digest_algo, 0);
2563               if (rc)
2564                 goto detached_hash_err;
2565             }
2566
2567           /* Here we used to have another hack to work around a pgp
2568            * 2 bug: It worked by not using the textmode for detached
2569            * signatures; this would let the first signature check
2570            * (on md) fail but the second one (on md2), which adds an
2571            * extra CR would then have produced the "correct" hash.
2572            * This is very, very ugly hack but it may haved help in
2573            * some cases (and break others).
2574            *     c->mfx.md2? 0 :(sig->sig_class == 0x01)
2575            */
2576
2577           if (DBG_HASHING)
2578             {
2579               gcry_md_debug (c->mfx.md, "verify");
2580               if (c->mfx.md2)
2581                 gcry_md_debug (c->mfx.md2, "verify2");
2582             }
2583
2584           if (c->sigs_only)
2585             {
2586               if (c->signed_data.used && c->signed_data.data_fd != -1)
2587                 rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2588                                           c->signed_data.data_fd,
2589                                           (sig->sig_class == 0x01));
2590               else
2591                 rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2592                                      c->signed_data.data_names,
2593                                      c->sigfilename,
2594                                      (sig->sig_class == 0x01));
2595             }
2596           else
2597             {
2598               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2599                                               iobuf_get_real_fname(c->iobuf),
2600                                               (sig->sig_class == 0x01));
2601             }
2602
2603         detached_hash_err:
2604           if (rc)
2605             {
2606               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2607               return;
2608             }
2609         }
2610       else if (c->signed_data.used)
2611         {
2612           log_error (_("not a detached signature\n"));
2613           return;
2614         }
2615       else if (!opt.quiet)
2616         log_info (_("old style (PGP 2.x) signature\n"));
2617
2618       if (multiple_ok)
2619         {
2620           for (n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2621             check_sig_and_print (c, n1);
2622         }
2623       else
2624         check_sig_and_print (c, node);
2625
2626     }
2627   else
2628     {
2629       dump_kbnode (c->list);
2630       log_error ("invalid root packet detected in proc_tree()\n");
2631       dump_kbnode (node);
2632     }
2633 }