g10/parse-packet.c

   1 /* parse-packet.c  - read packets
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   3  *               2007, 2009, 2010 Free Software Foundation, Inc.
   4  * Copyright (C) 2014 Werner Koch
   5  *
   6  * This file is part of GnuPG.
   7  *
   8  * GnuPG is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * GnuPG is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <assert.h>
  27
  28 #include "gpg.h"
  29 #include "util.h"
  30 #include "packet.h"
  31 #include "iobuf.h"
  32 #include "filter.h"
  33 #include "photoid.h"
  34 #include "options.h"
  35 #include "main.h"
  36 #include "i18n.h"
  37
  38
  39 /* Maximum length of packets to avoid excessive memory allocation.  */
  40 #define MAX_KEY_PACKET_LENGTH     (256 * 1024)
  41 #define MAX_UID_PACKET_LENGTH     (  2 * 1024)
  42 #define MAX_COMMENT_PACKET_LENGTH ( 64 * 1024)
  43 #define MAX_ATTR_PACKET_LENGTH    ( 16 * 1024*1024)
  44
  45
  46 static int mpi_print_mode;
  47 static int list_mode;
  48 static estream_t listfp;
  49
  50 static int parse (IOBUF inp, PACKET * pkt, int onlykeypkts,
  51                   off_t * retpos, int *skip, IOBUF out, int do_skip
  52 #ifdef DEBUG_PARSE_PACKET
  53                   , const char *dbg_w, const char *dbg_f, int dbg_l
  54 #endif
  55   );
  56 static int copy_packet (IOBUF inp, IOBUF out, int pkttype,
  57                         unsigned long pktlen, int partial);
  58 static void skip_packet (IOBUF inp, int pkttype,
  59                          unsigned long pktlen, int partial);
  60 static void *read_rest (IOBUF inp, size_t pktlen);
  61 static int parse_marker (IOBUF inp, int pkttype, unsigned long pktlen);
  62 static int parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
  63                             PACKET * packet);
  64 static int parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
  65                             PACKET * packet);
  66 static int parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
  67                               PKT_onepass_sig * ops);
  68 static int parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
  69                       byte * hdr, int hdrlen, PACKET * packet);
  70 static int parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen,
  71                           PACKET * packet);
  72 static int parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
  73                             PACKET * packet);
  74 static int parse_comment (IOBUF inp, int pkttype, unsigned long pktlen,
  75                           PACKET * packet);
  76 static void parse_trust (IOBUF inp, int pkttype, unsigned long pktlen,
  77                          PACKET * packet);
  78 static int parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
  79                             PACKET * packet, int new_ctb, int partial);
  80 static int parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
  81                              PACKET * packet, int new_ctb);
  82 static int parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
  83                             PACKET * packet, int new_ctb, int partial);
  84 static int parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
  85                       PACKET * packet, int new_ctb);
  86 static int parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
  87                               PACKET * packet, int partial);
  88
  89 static unsigned short
  90 read_16 (IOBUF inp)
  91 {
  92   unsigned short a;
  93   a = iobuf_get_noeof (inp) << 8;
  94   a |= iobuf_get_noeof (inp);
  95   return a;
  96 }
  97
  98
  99 static unsigned long
 100 read_32 (IOBUF inp)
 101 {
 102   unsigned long a;
 103   a = iobuf_get_noeof (inp) << 24;
 104   a |= iobuf_get_noeof (inp) << 16;
 105   a |= iobuf_get_noeof (inp) << 8;
 106   a |= iobuf_get_noeof (inp);
 107   return a;
 108 }
 109
 110
 111 /* Read an external representation of an mpi and return the MPI.  The
 112  * external format is a 16 bit unsigned value stored in network byte
 113  * order, giving the number of bits for the following integer. The
 114  * integer is stored with MSB first (left padded with zeroes to align
 115  * on a byte boundary).  */
 116 static gcry_mpi_t
 117 mpi_read (iobuf_t inp, unsigned int *ret_nread, int secure)
 118 {
 119   int c, c1, c2, i;
 120   unsigned int nmax = *ret_nread;
 121   unsigned int nbits, nbytes;
 122   size_t nread = 0;
 123   gcry_mpi_t a = NULL;
 124   byte *buf = NULL;
 125   byte *p;
 126
 127   if (!nmax)
 128     goto overflow;
 129
 130   if ((c = c1 = iobuf_get (inp)) == -1)
 131     goto leave;
 132   if (++nread == nmax)
 133     goto overflow;
 134   nbits = c << 8;
 135   if ((c = c2 = iobuf_get (inp)) == -1)
 136     goto leave;
 137   ++nread;
 138   nbits |= c;
 139   if (nbits > MAX_EXTERN_MPI_BITS)
 140     {
 141       log_error ("mpi too large (%u bits)\n", nbits);
 142       goto leave;
 143     }
 144
 145   nbytes = (nbits + 7) / 8;
 146   buf = secure ? gcry_xmalloc_secure (nbytes + 2) : gcry_xmalloc (nbytes + 2);
 147   p = buf;
 148   p[0] = c1;
 149   p[1] = c2;
 150   for (i = 0; i < nbytes; i++)
 151     {
 152       p[i + 2] = iobuf_get (inp) & 0xff;
 153       if (nread == nmax)
 154         goto overflow;
 155       nread++;
 156     }
 157
 158   if (gcry_mpi_scan (&a, GCRYMPI_FMT_PGP, buf, nread, &nread))
 159     a = NULL;
 160
 161   *ret_nread = nread;
 162   gcry_free(buf);
 163   return a;
 164
 165  overflow:
 166   log_error ("mpi larger than indicated length (%u bits)\n", 8*nmax);
 167  leave:
 168   *ret_nread = nread;
 169   gcry_free(buf);
 170   return a;
 171 }
 172
 173
 174 int
 175 set_packet_list_mode (int mode)
 176 {
 177   int old = list_mode;
 178   list_mode = mode;
 179   /* FIXME(gcrypt) mpi_print_mode = DBG_MPI; */
 180   /* We use stdout print only if invoked by the --list-packets command
 181      but switch to stderr in all other cases.  This breaks the
 182      previous behaviour but that seems to be more of a bug than
 183      intentional.  I don't believe that any application makes use of
 184      this long standing annoying way of printing to stdout except when
 185      doing a --list-packets. If this assumption fails, it will be easy
 186      to add an option for the listing stream.  Note that we initialize
 187      it only once; mainly because some code may switch the option
 188      value later back to 1 and we want to have all output to the same
 189      stream.
 190
 191      Using stderr is not actually very clean because it bypasses the
 192      logging code but it is a special thing anyway.  I am not sure
 193      whether using log_stream() would be better.  Perhaps we should
 194      enable the list mdoe only with a special option. */
 195   if (!listfp)
 196     listfp = opt.list_packets == 2 ? es_stdout : es_stderr;
 197   return old;
 198 }
 199
 200
 201 static void
 202 unknown_pubkey_warning (int algo)
 203 {
 204   static byte unknown_pubkey_algos[256];
 205
 206   /* First check whether the algorithm is usable but not suitable for
 207      encryption/signing.  */
 208   if (pubkey_get_npkey (algo))
 209     {
 210       if (opt.verbose)
 211         {
 212           if (!pubkey_get_nsig (algo))
 213             log_info ("public key algorithm %s not suitable for %s\n",
 214                       openpgp_pk_algo_name (algo), "signing");
 215           if (!pubkey_get_nenc (algo))
 216             log_info ("public key algorithm %s not suitable for %s\n",
 217                       openpgp_pk_algo_name (algo), "encryption");
 218         }
 219     }
 220   else
 221     {
 222       algo &= 0xff;
 223       if (!unknown_pubkey_algos[algo])
 224         {
 225           if (opt.verbose)
 226             log_info (_("can't handle public key algorithm %d\n"), algo);
 227           unknown_pubkey_algos[algo] = 1;
 228         }
 229     }
 230 }
 231
 232
 233 /* Parse a packet and return it in packet structure.
 234  * Returns: 0 := valid packet in pkt
 235  *         -1 := no more packets
 236  *         >0 := error
 237  * Note: The function may return an error and a partly valid packet;
 238  * caller must free this packet.   */
 239 #ifdef DEBUG_PARSE_PACKET
 240 int
 241 dbg_parse_packet (IOBUF inp, PACKET *pkt, const char *dbg_f, int dbg_l)
 242 {
 243   int skip, rc;
 244
 245   do
 246     {
 247       rc = parse (inp, pkt, 0, NULL, &skip, NULL, 0, "parse", dbg_f, dbg_l);
 248     }
 249   while (skip);
 250   return rc;
 251 }
 252 #else /*!DEBUG_PARSE_PACKET*/
 253 int
 254 parse_packet (IOBUF inp, PACKET * pkt)
 255 {
 256   int skip, rc;
 257
 258   do
 259     {
 260       rc = parse (inp, pkt, 0, NULL, &skip, NULL, 0);
 261     }
 262   while (skip);
 263   return rc;
 264 }
 265 #endif /*!DEBUG_PARSE_PACKET*/
 266
 267
 268 /*
 269  * Like parse packet, but only return secret or public (sub)key
 270  * packets.
 271  */
 272 #ifdef DEBUG_PARSE_PACKET
 273 int
 274 dbg_search_packet (IOBUF inp, PACKET * pkt, off_t * retpos, int with_uid,
 275                    const char *dbg_f, int dbg_l)
 276 {
 277   int skip, rc;
 278
 279   do
 280     {
 281       rc =
 282         parse (inp, pkt, with_uid ? 2 : 1, retpos, &skip, NULL, 0, "search",
 283                dbg_f, dbg_l);
 284     }
 285   while (skip);
 286   return rc;
 287 }
 288 #else /*!DEBUG_PARSE_PACKET*/
 289 int
 290 search_packet (IOBUF inp, PACKET * pkt, off_t * retpos, int with_uid)
 291 {
 292   int skip, rc;
 293
 294   do
 295     {
 296       rc = parse (inp, pkt, with_uid ? 2 : 1, retpos, &skip, NULL, 0);
 297     }
 298   while (skip);
 299   return rc;
 300 }
 301 #endif /*!DEBUG_PARSE_PACKET*/
 302
 303
 304 /*
 305  * Copy all packets from INP to OUT, thereby removing unused spaces.
 306  */
 307 #ifdef DEBUG_PARSE_PACKET
 308 int
 309 dbg_copy_all_packets (IOBUF inp, IOBUF out, const char *dbg_f, int dbg_l)
 310 {
 311   PACKET pkt;
 312   int skip, rc = 0;
 313   do
 314     {
 315       init_packet (&pkt);
 316     }
 317   while (!
 318          (rc =
 319           parse (inp, &pkt, 0, NULL, &skip, out, 0, "copy", dbg_f, dbg_l)));
 320   return rc;
 321 }
 322 #else /*!DEBUG_PARSE_PACKET*/
 323 int
 324 copy_all_packets (IOBUF inp, IOBUF out)
 325 {
 326   PACKET pkt;
 327   int skip, rc = 0;
 328   do
 329     {
 330       init_packet (&pkt);
 331     }
 332   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0)));
 333   return rc;
 334 }
 335 #endif /*!DEBUG_PARSE_PACKET*/
 336
 337
 338 /*
 339  * Copy some packets from INP to OUT, thereby removing unused spaces.
 340  * Stop at offset STOPoff (i.e. don't copy packets at this or later
 341  * offsets)
 342  */
 343 #ifdef DEBUG_PARSE_PACKET
 344 int
 345 dbg_copy_some_packets (IOBUF inp, IOBUF out, off_t stopoff,
 346                        const char *dbg_f, int dbg_l)
 347 {
 348   PACKET pkt;
 349   int skip, rc = 0;
 350   do
 351     {
 352       if (iobuf_tell (inp) >= stopoff)
 353         return 0;
 354       init_packet (&pkt);
 355     }
 356   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0,
 357                        "some", dbg_f, dbg_l)));
 358   return rc;
 359 }
 360 #else /*!DEBUG_PARSE_PACKET*/
 361 int
 362 copy_some_packets (IOBUF inp, IOBUF out, off_t stopoff)
 363 {
 364   PACKET pkt;
 365   int skip, rc = 0;
 366   do
 367     {
 368       if (iobuf_tell (inp) >= stopoff)
 369         return 0;
 370       init_packet (&pkt);
 371     }
 372   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0)));
 373   return rc;
 374 }
 375 #endif /*!DEBUG_PARSE_PACKET*/
 376
 377
 378 /*
 379  * Skip over N packets
 380  */
 381 #ifdef DEBUG_PARSE_PACKET
 382 int
 383 dbg_skip_some_packets (IOBUF inp, unsigned n, const char *dbg_f, int dbg_l)
 384 {
 385   int skip, rc = 0;
 386   PACKET pkt;
 387
 388   for (; n && !rc; n--)
 389     {
 390       init_packet (&pkt);
 391       rc = parse (inp, &pkt, 0, NULL, &skip, NULL, 1, "skip", dbg_f, dbg_l);
 392     }
 393   return rc;
 394 }
 395 #else /*!DEBUG_PARSE_PACKET*/
 396 int
 397 skip_some_packets (IOBUF inp, unsigned n)
 398 {
 399   int skip, rc = 0;
 400   PACKET pkt;
 401
 402   for (; n && !rc; n--)
 403     {
 404       init_packet (&pkt);
 405       rc = parse (inp, &pkt, 0, NULL, &skip, NULL, 1);
 406     }
 407   return rc;
 408 }
 409 #endif /*!DEBUG_PARSE_PACKET*/
 410
 411
 412 /*
 413  * Parse packet.  Stores 1 at SKIP 1 if the packet should be skipped;
 414  * this is the case if either ONLYKEYPKTS is set and the parsed packet
 415  * isn't a key packet or the packet-type is 0, indicating deleted
 416  * stuff.  If OUT is not NULL, a special copymode is used.
 417  */
 418 static int
 419 parse (IOBUF inp, PACKET * pkt, int onlykeypkts, off_t * retpos,
 420        int *skip, IOBUF out, int do_skip
 421 #ifdef DEBUG_PARSE_PACKET
 422        , const char *dbg_w, const char *dbg_f, int dbg_l
 423 #endif
 424        )
 425 {
 426   int rc = 0, c, ctb, pkttype, lenbytes;
 427   unsigned long pktlen;
 428   byte hdr[8];
 429   int hdrlen;
 430   int new_ctb = 0, partial = 0;
 431   int with_uid = (onlykeypkts == 2);
 432   off_t pos;
 433
 434   *skip = 0;
 435   assert (!pkt->pkt.generic);
 436   if (retpos || list_mode)
 437     {
 438       pos = iobuf_tell (inp);
 439       if (retpos)
 440         *retpos = pos;
 441     }
 442   else
 443     pos = 0; /* (silence compiler warning) */
 444
 445   if ((ctb = iobuf_get (inp)) == -1)
 446     {
 447       rc = -1;
 448       goto leave;
 449     }
 450   hdrlen = 0;
 451   hdr[hdrlen++] = ctb;
 452   if (!(ctb & 0x80))
 453     {
 454       log_error ("%s: invalid packet (ctb=%02x)\n", iobuf_where (inp), ctb);
 455       rc = gpg_error (GPG_ERR_INV_PACKET);
 456       goto leave;
 457     }
 458   pktlen = 0;
 459   new_ctb = !!(ctb & 0x40);
 460   if (new_ctb)
 461     {
 462       pkttype = ctb & 0x3f;
 463       if ((c = iobuf_get (inp)) == -1)
 464         {
 465           log_error ("%s: 1st length byte missing\n", iobuf_where (inp));
 466           rc = gpg_error (GPG_ERR_INV_PACKET);
 467           goto leave;
 468         }
 469
 470
 471       hdr[hdrlen++] = c;
 472       if (c < 192)
 473         pktlen = c;
 474       else if (c < 224)
 475         {
 476           pktlen = (c - 192) * 256;
 477           if ((c = iobuf_get (inp)) == -1)
 478             {
 479               log_error ("%s: 2nd length byte missing\n",
 480                          iobuf_where (inp));
 481               rc = gpg_error (GPG_ERR_INV_PACKET);
 482               goto leave;
 483             }
 484           hdr[hdrlen++] = c;
 485           pktlen += c + 192;
 486         }
 487       else if (c == 255)
 488         {
 489           pktlen = (hdr[hdrlen++] = iobuf_get_noeof (inp)) << 24;
 490           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof (inp)) << 16;
 491           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof (inp)) << 8;
 492           if ((c = iobuf_get (inp)) == -1)
 493             {
 494               log_error ("%s: 4 byte length invalid\n", iobuf_where (inp));
 495               rc = gpg_error (GPG_ERR_INV_PACKET);
 496               goto leave;
 497             }
 498           pktlen |= (hdr[hdrlen++] = c);
 499         }
 500       else /* Partial body length.  */
 501         {
 502           switch (pkttype)
 503             {
 504             case PKT_PLAINTEXT:
 505             case PKT_ENCRYPTED:
 506             case PKT_ENCRYPTED_MDC:
 507             case PKT_COMPRESSED:
 508               iobuf_set_partial_block_mode (inp, c & 0xff);
 509               pktlen = 0;       /* To indicate partial length.  */
 510               partial = 1;
 511               break;
 512
 513             default:
 514               log_error ("%s: partial length for invalid"
 515                          " packet type %d\n", iobuf_where (inp), pkttype);
 516               rc = gpg_error (GPG_ERR_INV_PACKET);
 517               goto leave;
 518             }
 519         }
 520
 521     }
 522   else
 523     {
 524       pkttype = (ctb >> 2) & 0xf;
 525       lenbytes = ((ctb & 3) == 3) ? 0 : (1 << (ctb & 3));
 526       if (!lenbytes)
 527         {
 528           pktlen = 0;   /* Don't know the value.  */
 529           /* This isn't really partial, but we can treat it the same
 530              in a "read until the end" sort of way.  */
 531           partial = 1;
 532           if (pkttype != PKT_ENCRYPTED && pkttype != PKT_PLAINTEXT
 533               && pkttype != PKT_COMPRESSED)
 534             {
 535               log_error ("%s: indeterminate length for invalid"
 536                          " packet type %d\n", iobuf_where (inp), pkttype);
 537               rc = gpg_error (GPG_ERR_INV_PACKET);
 538               goto leave;
 539             }
 540         }
 541       else
 542         {
 543           for (; lenbytes; lenbytes--)
 544             {
 545               pktlen <<= 8;
 546               pktlen |= hdr[hdrlen++] = iobuf_get_noeof (inp);
 547             }
 548         }
 549     }
 550
 551   if (pktlen == (unsigned long) (-1))
 552     {
 553       /* With some probability this is caused by a problem in the
 554        * the uncompressing layer - in some error cases it just loops
 555        * and spits out 0xff bytes. */
 556       log_error ("%s: garbled packet detected\n", iobuf_where (inp));
 557       g10_exit (2);
 558     }
 559
 560   if (out && pkttype)
 561     {
 562       rc = iobuf_write (out, hdr, hdrlen);
 563       if (!rc)
 564         rc = copy_packet (inp, out, pkttype, pktlen, partial);
 565       goto leave;
 566     }
 567
 568   if (with_uid && pkttype == PKT_USER_ID)
 569     ;
 570   else if (do_skip
 571            || !pkttype
 572            || (onlykeypkts && pkttype != PKT_PUBLIC_SUBKEY
 573                && pkttype != PKT_PUBLIC_KEY
 574                && pkttype != PKT_SECRET_SUBKEY && pkttype != PKT_SECRET_KEY))
 575     {
 576       iobuf_skip_rest (inp, pktlen, partial);
 577       *skip = 1;
 578       rc = 0;
 579       goto leave;
 580     }
 581
 582   if (DBG_PACKET)
 583     {
 584 #ifdef DEBUG_PARSE_PACKET
 585       log_debug ("parse_packet(iob=%d): type=%d length=%lu%s (%s.%s.%d)\n",
 586                  iobuf_id (inp), pkttype, pktlen, new_ctb ? " (new_ctb)" : "",
 587                  dbg_w, dbg_f, dbg_l);
 588 #else
 589       log_debug ("parse_packet(iob=%d): type=%d length=%lu%s\n",
 590                  iobuf_id (inp), pkttype, pktlen,
 591                  new_ctb ? " (new_ctb)" : "");
 592 #endif
 593     }
 594
 595   if (list_mode)
 596     es_fprintf (listfp, "# off=%lu ctb=%02x tag=%d hlen=%d plen=%lu%s%s\n",
 597                 (unsigned long)pos, ctb, pkttype, hdrlen, pktlen,
 598                 partial? " partial":"",
 599                 new_ctb? " new-ctb":"");
 600
 601   pkt->pkttype = pkttype;
 602   rc = GPG_ERR_UNKNOWN_PACKET;  /* default error */
 603   switch (pkttype)
 604     {
 605     case PKT_PUBLIC_KEY:
 606     case PKT_PUBLIC_SUBKEY:
 607     case PKT_SECRET_KEY:
 608     case PKT_SECRET_SUBKEY:
 609       pkt->pkt.public_key = xmalloc_clear (sizeof *pkt->pkt.public_key);
 610       rc = parse_key (inp, pkttype, pktlen, hdr, hdrlen, pkt);
 611       break;
 612     case PKT_SYMKEY_ENC:
 613       rc = parse_symkeyenc (inp, pkttype, pktlen, pkt);
 614       break;
 615     case PKT_PUBKEY_ENC:
 616       rc = parse_pubkeyenc (inp, pkttype, pktlen, pkt);
 617       break;
 618     case PKT_SIGNATURE:
 619       pkt->pkt.signature = xmalloc_clear (sizeof *pkt->pkt.signature);
 620       rc = parse_signature (inp, pkttype, pktlen, pkt->pkt.signature);
 621       break;
 622     case PKT_ONEPASS_SIG:
 623       pkt->pkt.onepass_sig = xmalloc_clear (sizeof *pkt->pkt.onepass_sig);
 624       rc = parse_onepass_sig (inp, pkttype, pktlen, pkt->pkt.onepass_sig);
 625       break;
 626     case PKT_USER_ID:
 627       rc = parse_user_id (inp, pkttype, pktlen, pkt);
 628       break;
 629     case PKT_ATTRIBUTE:
 630       pkt->pkttype = pkttype = PKT_USER_ID;     /* we store it in the userID */
 631       rc = parse_attribute (inp, pkttype, pktlen, pkt);
 632       break;
 633     case PKT_OLD_COMMENT:
 634     case PKT_COMMENT:
 635       rc = parse_comment (inp, pkttype, pktlen, pkt);
 636       break;
 637     case PKT_RING_TRUST:
 638       parse_trust (inp, pkttype, pktlen, pkt);
 639       rc = 0;
 640       break;
 641     case PKT_PLAINTEXT:
 642       rc = parse_plaintext (inp, pkttype, pktlen, pkt, new_ctb, partial);
 643       break;
 644     case PKT_COMPRESSED:
 645       rc = parse_compressed (inp, pkttype, pktlen, pkt, new_ctb);
 646       break;
 647     case PKT_ENCRYPTED:
 648     case PKT_ENCRYPTED_MDC:
 649       rc = parse_encrypted (inp, pkttype, pktlen, pkt, new_ctb, partial);
 650       break;
 651     case PKT_MDC:
 652       rc = parse_mdc (inp, pkttype, pktlen, pkt, new_ctb);
 653       break;
 654     case PKT_GPG_CONTROL:
 655       rc = parse_gpg_control (inp, pkttype, pktlen, pkt, partial);
 656       break;
 657     case PKT_MARKER:
 658       rc = parse_marker (inp, pkttype, pktlen);
 659       break;
 660     default:
 661       skip_packet (inp, pkttype, pktlen, partial);
 662       break;
 663     }
 664
 665  leave:
 666   /* FIXME: Do we leak in case of an error?  */
 667   if (!rc && iobuf_error (inp))
 668     rc = GPG_ERR_INV_KEYRING;
 669
 670   /* FIXME: We use only the error code for now to avoid problems with
 671      callers which have not been checked to always use gpg_err_code()
 672      when comparing error codes.  */
 673   return rc == -1? -1 : gpg_err_code (rc);
 674 }
 675
 676
 677 static void
 678 dump_hex_line (int c, int *i)
 679 {
 680   if (*i && !(*i % 8))
 681     {
 682       if (*i && !(*i % 24))
 683         es_fprintf (listfp, "\n%4d:", *i);
 684       else
 685         es_putc (' ', listfp);
 686     }
 687   if (c == -1)
 688     es_fprintf (listfp, " EOF");
 689   else
 690     es_fprintf (listfp, " %02x", c);
 691   ++*i;
 692 }
 693
 694
 695 static int
 696 copy_packet (IOBUF inp, IOBUF out, int pkttype,
 697              unsigned long pktlen, int partial)
 698 {
 699   int rc;
 700   int n;
 701   char buf[100];
 702
 703   if (partial)
 704     {
 705       while ((n = iobuf_read (inp, buf, 100)) != -1)
 706         if ((rc = iobuf_write (out, buf, n)))
 707           return rc;            /* write error */
 708     }
 709   else if (!pktlen && pkttype == PKT_COMPRESSED)
 710     {
 711       log_debug ("copy_packet: compressed!\n");
 712       /* compressed packet, copy till EOF */
 713       while ((n = iobuf_read (inp, buf, 100)) != -1)
 714         if ((rc = iobuf_write (out, buf, n)))
 715           return rc;            /* write error */
 716     }
 717   else
 718     {
 719       for (; pktlen; pktlen -= n)
 720         {
 721           n = pktlen > 100 ? 100 : pktlen;
 722           n = iobuf_read (inp, buf, n);
 723           if (n == -1)
 724             return gpg_error (GPG_ERR_EOF);
 725           if ((rc = iobuf_write (out, buf, n)))
 726             return rc;          /* write error */
 727         }
 728     }
 729   return 0;
 730 }
 731
 732
 733 static void
 734 skip_packet (IOBUF inp, int pkttype, unsigned long pktlen, int partial)
 735 {
 736   if (list_mode)
 737     {
 738       es_fprintf (listfp, ":unknown packet: type %2d, length %lu\n",
 739                   pkttype, pktlen);
 740       if (pkttype)
 741         {
 742           int c, i = 0;
 743           es_fputs ("dump:", listfp);
 744           if (partial)
 745             {
 746               while ((c = iobuf_get (inp)) != -1)
 747                 dump_hex_line (c, &i);
 748             }
 749           else
 750             {
 751               for (; pktlen; pktlen--)
 752                 {
 753                   dump_hex_line ((c = iobuf_get (inp)), &i);
 754                   if (c == -1)
 755                     break;
 756                 }
 757             }
 758           es_putc ('\n', listfp);
 759           return;
 760         }
 761     }
 762   iobuf_skip_rest (inp, pktlen, partial);
 763 }
 764
 765
 766 /* Read PKTLEN bytes form INP and return them in a newly allocated
 767    buffer.  In case of an error NULL is returned and a error messages
 768    printed.  */
 769 static void *
 770 read_rest (IOBUF inp, size_t pktlen)
 771 {
 772   int c;
 773   byte *buf, *p;
 774
 775   buf = xtrymalloc (pktlen);
 776   if (!buf)
 777     {
 778       gpg_error_t err = gpg_error_from_syserror ();
 779       log_error ("error reading rest of packet: %s\n", gpg_strerror (err));
 780       return NULL;
 781     }
 782   for (p = buf; pktlen; pktlen--)
 783     {
 784       c = iobuf_get (inp);
 785       if (c == -1)
 786         {
 787           log_error ("premature eof while reading rest of packet\n");
 788           xfree (buf);
 789           return NULL;
 790         }
 791       *p++ = c;
 792     }
 793
 794   return buf;
 795 }
 796
 797
 798 /* Read a special size+body from INP.  On success store an opaque MPI
 799    with it at R_DATA.  On error return an error code and store NULL at
 800    R_DATA.  Even in the error case store the number of read bytes at
 801    R_NREAD.  The caller shall pass the remaining size of the packet in
 802    PKTLEN.  */
 803 static gpg_error_t
 804 read_size_body (iobuf_t inp, int pktlen, size_t *r_nread,
 805                 gcry_mpi_t *r_data)
 806 {
 807   char buffer[256];
 808   char *tmpbuf;
 809   int i, c, nbytes;
 810
 811   *r_nread = 0;
 812   *r_data = NULL;
 813
 814   if (!pktlen)
 815     return gpg_error (GPG_ERR_INV_PACKET);
 816   c = iobuf_readbyte (inp);
 817   if (c < 0)
 818     return gpg_error (GPG_ERR_INV_PACKET);
 819   pktlen--;
 820   ++*r_nread;
 821   nbytes = c;
 822   if (nbytes < 2 || nbytes > 254)
 823     return gpg_error (GPG_ERR_INV_PACKET);
 824   if (nbytes > pktlen)
 825     return gpg_error (GPG_ERR_INV_PACKET);
 826
 827   buffer[0] = nbytes;
 828
 829   for (i = 0; i < nbytes; i++)
 830     {
 831       c = iobuf_get (inp);
 832       if (c < 0)
 833         return gpg_error (GPG_ERR_INV_PACKET);
 834       ++*r_nread;
 835       buffer[1+i] = c;
 836     }
 837
 838   tmpbuf = xtrymalloc (1 + nbytes);
 839   if (!tmpbuf)
 840     return gpg_error_from_syserror ();
 841   memcpy (tmpbuf, buffer, 1 + nbytes);
 842   *r_data = gcry_mpi_set_opaque (NULL, tmpbuf, 8 * (1 + nbytes));
 843   if (!*r_data)
 844     {
 845       xfree (tmpbuf);
 846       return gpg_error_from_syserror ();
 847     }
 848   return 0;
 849 }
 850
 851
 852 /* Parse a marker packet.  */
 853 static int
 854 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
 855 {
 856   (void) pkttype;
 857
 858   if (pktlen != 3)
 859     goto fail;
 860
 861   if (iobuf_get (inp) != 'P')
 862     {
 863       pktlen--;
 864       goto fail;
 865     }
 866
 867   if (iobuf_get (inp) != 'G')
 868     {
 869       pktlen--;
 870       goto fail;
 871     }
 872
 873   if (iobuf_get (inp) != 'P')
 874     {
 875       pktlen--;
 876       goto fail;
 877     }
 878
 879   if (list_mode)
 880     es_fputs (":marker packet: PGP\n", listfp);
 881
 882   return 0;
 883
 884  fail:
 885   log_error ("invalid marker packet\n");
 886   if (list_mode)
 887     es_fputs (":marker packet: [invalid]\n", listfp);
 888   iobuf_skip_rest (inp, pktlen, 0);
 889   return GPG_ERR_INV_PACKET;
 890 }
 891
 892
 893 static int
 894 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
 895                  PACKET * packet)
 896 {
 897   PKT_symkey_enc *k;
 898   int rc = 0;
 899   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
 900
 901   if (pktlen < 4)
 902     {
 903       log_error ("packet(%d) too short\n", pkttype);
 904       if (list_mode)
 905         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
 906       rc = gpg_error (GPG_ERR_INV_PACKET);
 907       goto leave;
 908     }
 909   version = iobuf_get_noeof (inp);
 910   pktlen--;
 911   if (version != 4)
 912     {
 913       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
 914       if (list_mode)
 915         es_fprintf (listfp, ":symkey enc packet: [unknown version]\n");
 916       rc = gpg_error (GPG_ERR_INV_PACKET);
 917       goto leave;
 918     }
 919   if (pktlen > 200)
 920     {                           /* (we encode the seskeylen in a byte) */
 921       log_error ("packet(%d) too large\n", pkttype);
 922       if (list_mode)
 923         es_fprintf (listfp, ":symkey enc packet: [too large]\n");
 924       rc = gpg_error (GPG_ERR_INV_PACKET);
 925       goto leave;
 926     }
 927   cipher_algo = iobuf_get_noeof (inp);
 928   pktlen--;
 929   s2kmode = iobuf_get_noeof (inp);
 930   pktlen--;
 931   hash_algo = iobuf_get_noeof (inp);
 932   pktlen--;
 933   switch (s2kmode)
 934     {
 935     case 0: /* Simple S2K.  */
 936       minlen = 0;
 937       break;
 938     case 1: /* Salted S2K.  */
 939       minlen = 8;
 940       break;
 941     case 3: /* Iterated+salted S2K.  */
 942       minlen = 9;
 943       break;
 944     default:
 945       log_error ("unknown S2K mode %d\n", s2kmode);
 946       if (list_mode)
 947         es_fprintf (listfp, ":symkey enc packet: [unknown S2K mode]\n");
 948       goto leave;
 949     }
 950   if (minlen > pktlen)
 951     {
 952       log_error ("packet with S2K %d too short\n", s2kmode);
 953       if (list_mode)
 954         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
 955       rc = gpg_error (GPG_ERR_INV_PACKET);
 956       goto leave;
 957     }
 958   seskeylen = pktlen - minlen;
 959   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
 960                                               + seskeylen - 1);
 961   k->version = version;
 962   k->cipher_algo = cipher_algo;
 963   k->s2k.mode = s2kmode;
 964   k->s2k.hash_algo = hash_algo;
 965   if (s2kmode == 1 || s2kmode == 3)
 966     {
 967       for (i = 0; i < 8 && pktlen; i++, pktlen--)
 968         k->s2k.salt[i] = iobuf_get_noeof (inp);
 969     }
 970   if (s2kmode == 3)
 971     {
 972       k->s2k.count = iobuf_get (inp);
 973       pktlen--;
 974     }
 975   k->seskeylen = seskeylen;
 976   if (k->seskeylen)
 977     {
 978       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
 979         k->seskey[i] = iobuf_get_noeof (inp);
 980
 981       /* What we're watching out for here is a session key decryptor
 982          with no salt.  The RFC says that using salt for this is a
 983          MUST. */
 984       if (s2kmode != 1 && s2kmode != 3)
 985         log_info (_("WARNING: potentially insecure symmetrically"
 986                     " encrypted session key\n"));
 987     }
 988   assert (!pktlen);
 989
 990   if (list_mode)
 991     {
 992       es_fprintf (listfp,
 993                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
 994                   version, cipher_algo, s2kmode, hash_algo);
 995       if (seskeylen)
 996         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
 997       es_fprintf (listfp, "\n");
 998       if (s2kmode == 1 || s2kmode == 3)
 999         {
1000           es_fprintf (listfp, "\tsalt ");
1001           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
1002           if (s2kmode == 3)
1003             es_fprintf (listfp, ", count %lu (%lu)",
1004                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
1005                         (ulong) k->s2k.count);
1006           es_fprintf (listfp, "\n");
1007         }
1008     }
1009
1010  leave:
1011   iobuf_skip_rest (inp, pktlen, 0);
1012   return rc;
1013 }
1014
1015
1016 static int
1017 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
1018                  PACKET * packet)
1019 {
1020   int rc = 0;
1021   int i, ndata;
1022   PKT_pubkey_enc *k;
1023
1024   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
1025   if (pktlen < 12)
1026     {
1027       log_error ("packet(%d) too short\n", pkttype);
1028       if (list_mode)
1029         es_fputs (":pubkey enc packet: [too short]\n", listfp);
1030       rc = gpg_error (GPG_ERR_INV_PACKET);
1031       goto leave;
1032     }
1033   k->version = iobuf_get_noeof (inp);
1034   pktlen--;
1035   if (k->version != 2 && k->version != 3)
1036     {
1037       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
1038       if (list_mode)
1039         es_fputs (":pubkey enc packet: [unknown version]\n", listfp);
1040       rc = gpg_error (GPG_ERR_INV_PACKET);
1041       goto leave;
1042     }
1043   k->keyid[0] = read_32 (inp);
1044   pktlen -= 4;
1045   k->keyid[1] = read_32 (inp);
1046   pktlen -= 4;
1047   k->pubkey_algo = iobuf_get_noeof (inp);
1048   pktlen--;
1049   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
1050   if (list_mode)
1051     es_fprintf (listfp,
1052                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
1053                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
1054                 (ulong) k->keyid[1]);
1055
1056   ndata = pubkey_get_nenc (k->pubkey_algo);
1057   if (!ndata)
1058     {
1059       if (list_mode)
1060         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
1061       unknown_pubkey_warning (k->pubkey_algo);
1062       k->data[0] = NULL; /* No need to store the encrypted data.  */
1063     }
1064   else
1065     {
1066       for (i = 0; i < ndata; i++)
1067         {
1068           if (k->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
1069             {
1070               size_t n;
1071               rc = read_size_body (inp, pktlen, &n, k->data+i);
1072               pktlen -= n;
1073             }
1074           else
1075             {
1076               int n = pktlen;
1077               k->data[i] = mpi_read (inp, &n, 0);
1078               pktlen -= n;
1079               if (!k->data[i])
1080                 rc = gpg_error (GPG_ERR_INV_PACKET);
1081             }
1082           if (rc)
1083             goto leave;
1084           if (list_mode)
1085             {
1086               es_fprintf (listfp, "\tdata: ");
1087               mpi_print (listfp, k->data[i], mpi_print_mode);
1088               es_putc ('\n', listfp);
1089             }
1090         }
1091     }
1092
1093  leave:
1094   iobuf_skip_rest (inp, pktlen, 0);
1095   return rc;
1096 }
1097
1098
1099 static void
1100 dump_sig_subpkt (int hashed, int type, int critical,
1101                  const byte * buffer, size_t buflen, size_t length)
1102 {
1103   const char *p = NULL;
1104   int i;
1105
1106   /* The CERT has warning out with explains how to use GNUPG to detect
1107    * the ARRs - we print our old message here when it is a faked ARR
1108    * and add an additional notice.  */
1109   if (type == SIGSUBPKT_ARR && !hashed)
1110     {
1111       es_fprintf (listfp,
1112                   "\tsubpkt %d len %u (additional recipient request)\n"
1113                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
1114                   "encrypt to this key and thereby reveal the plaintext to "
1115                   "the owner of this ARR key. Detailed info follows:\n",
1116                   type, (unsigned) length);
1117     }
1118
1119   buffer++;
1120   length--;
1121
1122   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
1123               critical ? "critical " : "",
1124               hashed ? "hashed " : "", type, (unsigned) length);
1125   if (length > buflen)
1126     {
1127       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
1128       return;
1129     }
1130   switch (type)
1131     {
1132     case SIGSUBPKT_SIG_CREATED:
1133       if (length >= 4)
1134         es_fprintf (listfp, "sig created %s",
1135                     strtimestamp (buffer_to_u32 (buffer)));
1136       break;
1137     case SIGSUBPKT_SIG_EXPIRE:
1138       if (length >= 4)
1139         {
1140           if (buffer_to_u32 (buffer))
1141             es_fprintf (listfp, "sig expires after %s",
1142                         strtimevalue (buffer_to_u32 (buffer)));
1143           else
1144             es_fprintf (listfp, "sig does not expire");
1145         }
1146       break;
1147     case SIGSUBPKT_EXPORTABLE:
1148       if (length)
1149         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1150       break;
1151     case SIGSUBPKT_TRUST:
1152       if (length != 2)
1153         p = "[invalid trust subpacket]";
1154       else
1155         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1156                     buffer[1]);
1157       break;
1158     case SIGSUBPKT_REGEXP:
1159       if (!length)
1160         p = "[invalid regexp subpacket]";
1161       else
1162         {
1163           es_fprintf (listfp, "regular expression: \"");
1164           es_write_sanitized (listfp, buffer, length, "\"", NULL);
1165           p = "\"";
1166         }
1167       break;
1168     case SIGSUBPKT_REVOCABLE:
1169       if (length)
1170         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1171       break;
1172     case SIGSUBPKT_KEY_EXPIRE:
1173       if (length >= 4)
1174         {
1175           if (buffer_to_u32 (buffer))
1176             es_fprintf (listfp, "key expires after %s",
1177                         strtimevalue (buffer_to_u32 (buffer)));
1178           else
1179             es_fprintf (listfp, "key does not expire");
1180         }
1181       break;
1182     case SIGSUBPKT_PREF_SYM:
1183       es_fputs ("pref-sym-algos:", listfp);
1184       for (i = 0; i < length; i++)
1185         es_fprintf (listfp, " %d", buffer[i]);
1186       break;
1187     case SIGSUBPKT_REV_KEY:
1188       es_fputs ("revocation key: ", listfp);
1189       if (length < 22)
1190         p = "[too short]";
1191       else
1192         {
1193           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1194           for (i = 2; i < length; i++)
1195             es_fprintf (listfp, "%02X", buffer[i]);
1196         }
1197       break;
1198     case SIGSUBPKT_ISSUER:
1199       if (length >= 8)
1200         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1201                     (ulong) buffer_to_u32 (buffer),
1202                     (ulong) buffer_to_u32 (buffer + 4));
1203       break;
1204     case SIGSUBPKT_NOTATION:
1205       {
1206         es_fputs ("notation: ", listfp);
1207         if (length < 8)
1208           p = "[too short]";
1209         else
1210           {
1211             const byte *s = buffer;
1212             size_t n1, n2;
1213
1214             n1 = (s[4] << 8) | s[5];
1215             n2 = (s[6] << 8) | s[7];
1216             s += 8;
1217             if (8 + n1 + n2 != length)
1218               p = "[error]";
1219             else
1220               {
1221                 es_write_sanitized (listfp, s, n1, ")", NULL);
1222                 es_putc ('=', listfp);
1223
1224                 if (*buffer & 0x80)
1225                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1226                 else
1227                   p = "[not human readable]";
1228               }
1229           }
1230       }
1231       break;
1232     case SIGSUBPKT_PREF_HASH:
1233       es_fputs ("pref-hash-algos:", listfp);
1234       for (i = 0; i < length; i++)
1235         es_fprintf (listfp, " %d", buffer[i]);
1236       break;
1237     case SIGSUBPKT_PREF_COMPR:
1238       es_fputs ("pref-zip-algos:", listfp);
1239       for (i = 0; i < length; i++)
1240         es_fprintf (listfp, " %d", buffer[i]);
1241       break;
1242     case SIGSUBPKT_KS_FLAGS:
1243       es_fputs ("key server preferences:", listfp);
1244       for (i = 0; i < length; i++)
1245         es_fprintf (listfp, " %02X", buffer[i]);
1246       break;
1247     case SIGSUBPKT_PREF_KS:
1248       es_fputs ("preferred key server: ", listfp);
1249       es_write_sanitized (listfp, buffer, length, ")", NULL);
1250       break;
1251     case SIGSUBPKT_PRIMARY_UID:
1252       p = "primary user ID";
1253       break;
1254     case SIGSUBPKT_POLICY:
1255       es_fputs ("policy: ", listfp);
1256       es_write_sanitized (listfp, buffer, length, ")", NULL);
1257       break;
1258     case SIGSUBPKT_KEY_FLAGS:
1259       es_fputs ("key flags:", listfp);
1260       for (i = 0; i < length; i++)
1261         es_fprintf (listfp, " %02X", buffer[i]);
1262       break;
1263     case SIGSUBPKT_SIGNERS_UID:
1264       p = "signer's user ID";
1265       break;
1266     case SIGSUBPKT_REVOC_REASON:
1267       if (length)
1268         {
1269           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1270           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1271           p = ")";
1272         }
1273       break;
1274     case SIGSUBPKT_ARR:
1275       es_fputs ("Big Brother's key (ignored): ", listfp);
1276       if (length < 22)
1277         p = "[too short]";
1278       else
1279         {
1280           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1281           if (length > 2)
1282             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1283         }
1284       break;
1285     case SIGSUBPKT_FEATURES:
1286       es_fputs ("features:", listfp);
1287       for (i = 0; i < length; i++)
1288         es_fprintf (listfp, " %02x", buffer[i]);
1289       break;
1290     case SIGSUBPKT_SIGNATURE:
1291       es_fputs ("signature: ", listfp);
1292       if (length < 17)
1293         p = "[too short]";
1294       else
1295         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1296                     buffer[0],
1297                     buffer[0] == 3 ? buffer[2] : buffer[1],
1298                     buffer[0] == 3 ? buffer[15] : buffer[2],
1299                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1300       break;
1301     default:
1302       if (type >= 100 && type <= 110)
1303         p = "experimental / private subpacket";
1304       else
1305         p = "?";
1306       break;
1307     }
1308
1309   es_fprintf (listfp, "%s)\n", p ? p : "");
1310 }
1311
1312
1313 /*
1314  * Returns: >= 0 use this offset into buffer
1315  *          -1 explicitly reject returning this type
1316  *          -2 subpacket too short
1317  */
1318 int
1319 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1320 {
1321   switch (type)
1322     {
1323     case SIGSUBPKT_REV_KEY:
1324       if (n < 22)
1325         break;
1326       return 0;
1327     case SIGSUBPKT_SIG_CREATED:
1328     case SIGSUBPKT_SIG_EXPIRE:
1329     case SIGSUBPKT_KEY_EXPIRE:
1330       if (n < 4)
1331         break;
1332       return 0;
1333     case SIGSUBPKT_KEY_FLAGS:
1334     case SIGSUBPKT_KS_FLAGS:
1335     case SIGSUBPKT_PREF_SYM:
1336     case SIGSUBPKT_PREF_HASH:
1337     case SIGSUBPKT_PREF_COMPR:
1338     case SIGSUBPKT_POLICY:
1339     case SIGSUBPKT_PREF_KS:
1340     case SIGSUBPKT_FEATURES:
1341     case SIGSUBPKT_REGEXP:
1342       return 0;
1343     case SIGSUBPKT_SIGNATURE:
1344     case SIGSUBPKT_EXPORTABLE:
1345     case SIGSUBPKT_REVOCABLE:
1346     case SIGSUBPKT_REVOC_REASON:
1347       if (!n)
1348         break;
1349       return 0;
1350     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1351       if (n < 8)
1352         break;
1353       return 0;
1354     case SIGSUBPKT_NOTATION:
1355       /* minimum length needed, and the subpacket must be well-formed
1356          where the name length and value length all fit inside the
1357          packet. */
1358       if (n < 8
1359           || 8 + ((buffer[4] << 8) | buffer[5]) +
1360           ((buffer[6] << 8) | buffer[7]) != n)
1361         break;
1362       return 0;
1363     case SIGSUBPKT_PRIMARY_UID:
1364       if (n != 1)
1365         break;
1366       return 0;
1367     case SIGSUBPKT_TRUST:
1368       if (n != 2)
1369         break;
1370       return 0;
1371     default:
1372       return 0;
1373     }
1374   return -2;
1375 }
1376
1377
1378 /* Return true if we understand the critical notation.  */
1379 static int
1380 can_handle_critical_notation (const byte * name, size_t len)
1381 {
1382   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1383     return 1;
1384   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1385     return 1;
1386
1387   return 0;
1388 }
1389
1390
1391 static int
1392 can_handle_critical (const byte * buffer, size_t n, int type)
1393 {
1394   switch (type)
1395     {
1396     case SIGSUBPKT_NOTATION:
1397       if (n >= 8)
1398         {
1399           size_t notation_len = ((buffer[4] << 8) | buffer[5]);
1400           if (n - 8 >= notation_len)
1401             return can_handle_critical_notation (buffer + 8, notation_len);
1402         }
1403       return 0;
1404     case SIGSUBPKT_SIGNATURE:
1405     case SIGSUBPKT_SIG_CREATED:
1406     case SIGSUBPKT_SIG_EXPIRE:
1407     case SIGSUBPKT_KEY_EXPIRE:
1408     case SIGSUBPKT_EXPORTABLE:
1409     case SIGSUBPKT_REVOCABLE:
1410     case SIGSUBPKT_REV_KEY:
1411     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1412     case SIGSUBPKT_PREF_SYM:
1413     case SIGSUBPKT_PREF_HASH:
1414     case SIGSUBPKT_PREF_COMPR:
1415     case SIGSUBPKT_KEY_FLAGS:
1416     case SIGSUBPKT_PRIMARY_UID:
1417     case SIGSUBPKT_FEATURES:
1418     case SIGSUBPKT_TRUST:
1419     case SIGSUBPKT_REGEXP:
1420       /* Is it enough to show the policy or keyserver? */
1421     case SIGSUBPKT_POLICY:
1422     case SIGSUBPKT_PREF_KS:
1423       return 1;
1424
1425     default:
1426       return 0;
1427     }
1428 }
1429
1430
1431 const byte *
1432 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1433                  size_t * ret_n, int *start, int *critical)
1434 {
1435   const byte *buffer;
1436   int buflen;
1437   int type;
1438   int critical_dummy;
1439   int offset;
1440   size_t n;
1441   int seq = 0;
1442   int reqseq = start ? *start : 0;
1443
1444   if (!critical)
1445     critical = &critical_dummy;
1446
1447   if (!pktbuf || reqseq == -1)
1448     {
1449       static char dummy[] = "x";
1450       /* Return a value different from NULL to indicate that
1451        * there is no critical bit we do not understand.  */
1452       return reqtype == SIGSUBPKT_TEST_CRITICAL ? dummy : NULL;
1453     }
1454   buffer = pktbuf->data;
1455   buflen = pktbuf->len;
1456   while (buflen)
1457     {
1458       n = *buffer++;
1459       buflen--;
1460       if (n == 255) /* 4 byte length header.  */
1461         {
1462           if (buflen < 4)
1463             goto too_short;
1464           n = (buffer[0] << 24) | (buffer[1] << 16)
1465             | (buffer[2] << 8) | buffer[3];
1466           buffer += 4;
1467           buflen -= 4;
1468         }
1469       else if (n >= 192) /* 4 byte special encoded length header.  */
1470         {
1471           if (buflen < 2)
1472             goto too_short;
1473           n = ((n - 192) << 8) + *buffer + 192;
1474           buffer++;
1475           buflen--;
1476         }
1477       if (buflen < n)
1478         goto too_short;
1479       type = *buffer;
1480       if (type & 0x80)
1481         {
1482           type &= 0x7f;
1483           *critical = 1;
1484         }
1485       else
1486         *critical = 0;
1487       if (!(++seq > reqseq))
1488         ;
1489       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1490         {
1491           if (*critical)
1492             {
1493               if (n - 1 > buflen + 1)
1494                 goto too_short;
1495               if (!can_handle_critical (buffer + 1, n - 1, type))
1496                 {
1497                   if (opt.verbose)
1498                     log_info (_("subpacket of type %d has "
1499                                 "critical bit set\n"), type);
1500                   if (start)
1501                     *start = seq;
1502                   return NULL;  /* This is an error.  */
1503                 }
1504             }
1505         }
1506       else if (reqtype < 0) /* List packets.  */
1507         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1508                          type, *critical, buffer, buflen, n);
1509       else if (type == reqtype) /* Found.  */
1510         {
1511           buffer++;
1512           n--;
1513           if (n > buflen)
1514             goto too_short;
1515           if (ret_n)
1516             *ret_n = n;
1517           offset = parse_one_sig_subpkt (buffer, n, type);
1518           switch (offset)
1519             {
1520             case -2:
1521               log_error ("subpacket of type %d too short\n", type);
1522               return NULL;
1523             case -1:
1524               return NULL;
1525             default:
1526               break;
1527             }
1528           if (start)
1529             *start = seq;
1530           return buffer + offset;
1531         }
1532       buffer += n;
1533       buflen -= n;
1534     }
1535   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1536     return buffer;  /* Used as True to indicate that there is no. */
1537
1538   /* Critical bit we don't understand. */
1539   if (start)
1540     *start = -1;
1541   return NULL;  /* End of packets; not found.  */
1542
1543  too_short:
1544   if (opt.verbose)
1545     log_info ("buffer shorter than subpacket\n");
1546   if (start)
1547     *start = -1;
1548   return NULL;
1549 }
1550
1551
1552 const byte *
1553 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1554                   size_t * ret_n)
1555 {
1556   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1557 }
1558
1559
1560 const byte *
1561 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype,
1562                    size_t * ret_n)
1563 {
1564   const byte *p;
1565
1566   p = parse_sig_subpkt (sig->hashed, reqtype, ret_n);
1567   if (!p)
1568     p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n);
1569   return p;
1570 }
1571
1572
1573 /* Find all revocation keys.  Look in hashed area only.  */
1574 void
1575 parse_revkeys (PKT_signature * sig)
1576 {
1577   struct revocation_key *revkey;
1578   int seq = 0;
1579   size_t len;
1580
1581   if (sig->sig_class != 0x1F)
1582     return;
1583
1584   while ((revkey =
1585           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1586                                                      SIGSUBPKT_REV_KEY,
1587                                                      &len, &seq, NULL)))
1588     {
1589       if (len == sizeof (struct revocation_key)
1590           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1591         {
1592           sig->revkey = xrealloc (sig->revkey,
1593                                   sizeof (struct revocation_key *) *
1594                                   (sig->numrevkeys + 1));
1595           sig->revkey[sig->numrevkeys] = revkey;
1596           sig->numrevkeys++;
1597         }
1598     }
1599 }
1600
1601
1602 int
1603 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1604                  PKT_signature * sig)
1605 {
1606   int md5_len = 0;
1607   unsigned n;
1608   int is_v4 = 0;
1609   int rc = 0;
1610   int i, ndata;
1611
1612   if (pktlen < 16)
1613     {
1614       log_error ("packet(%d) too short\n", pkttype);
1615       if (list_mode)
1616         es_fputs (":signature packet: [too short]\n", listfp);
1617       goto leave;
1618     }
1619   sig->version = iobuf_get_noeof (inp);
1620   pktlen--;
1621   if (sig->version == 4)
1622     is_v4 = 1;
1623   else if (sig->version != 2 && sig->version != 3)
1624     {
1625       log_error ("packet(%d) with unknown version %d\n",
1626                  pkttype, sig->version);
1627       if (list_mode)
1628         es_fputs (":signature packet: [unknown version]\n", listfp);
1629       rc = gpg_error (GPG_ERR_INV_PACKET);
1630       goto leave;
1631     }
1632
1633   if (!is_v4)
1634     {
1635       md5_len = iobuf_get_noeof (inp);
1636       pktlen--;
1637     }
1638   sig->sig_class = iobuf_get_noeof (inp);
1639   pktlen--;
1640   if (!is_v4)
1641     {
1642       sig->timestamp = read_32 (inp);
1643       pktlen -= 4;
1644       sig->keyid[0] = read_32 (inp);
1645       pktlen -= 4;
1646       sig->keyid[1] = read_32 (inp);
1647       pktlen -= 4;
1648     }
1649   sig->pubkey_algo = iobuf_get_noeof (inp);
1650   pktlen--;
1651   sig->digest_algo = iobuf_get_noeof (inp);
1652   pktlen--;
1653   sig->flags.exportable = 1;
1654   sig->flags.revocable = 1;
1655   if (is_v4) /* Read subpackets.  */
1656     {
1657       n = read_16 (inp);
1658       pktlen -= 2;  /* Length of hashed data. */
1659       if (n > 10000)
1660         {
1661           log_error ("signature packet: hashed data too long\n");
1662           if (list_mode)
1663             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1664           rc = GPG_ERR_INV_PACKET;
1665           goto leave;
1666         }
1667       if (n)
1668         {
1669           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1670           sig->hashed->size = n;
1671           sig->hashed->len = n;
1672           if (iobuf_read (inp, sig->hashed->data, n) != n)
1673             {
1674               log_error ("premature eof while reading "
1675                          "hashed signature data\n");
1676               if (list_mode)
1677                 es_fputs (":signature packet: [premature eof]\n", listfp);
1678               rc = -1;
1679               goto leave;
1680             }
1681           pktlen -= n;
1682         }
1683       n = read_16 (inp);
1684       pktlen -= 2;  /* Length of unhashed data.  */
1685       if (n > 10000)
1686         {
1687           log_error ("signature packet: unhashed data too long\n");
1688           if (list_mode)
1689             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1690           rc = GPG_ERR_INV_PACKET;
1691           goto leave;
1692         }
1693       if (n)
1694         {
1695           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1696           sig->unhashed->size = n;
1697           sig->unhashed->len = n;
1698           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1699             {
1700               log_error ("premature eof while reading "
1701                          "unhashed signature data\n");
1702               if (list_mode)
1703                 es_fputs (":signature packet: [premature eof]\n", listfp);
1704               rc = -1;
1705               goto leave;
1706             }
1707           pktlen -= n;
1708         }
1709     }
1710
1711   if (pktlen < 5)  /* Sanity check.  */
1712     {
1713       log_error ("packet(%d) too short\n", pkttype);
1714       if (list_mode)
1715         es_fputs (":signature packet: [too short]\n", listfp);
1716       rc = GPG_ERR_INV_PACKET;
1717       goto leave;
1718     }
1719
1720   sig->digest_start[0] = iobuf_get_noeof (inp);
1721   pktlen--;
1722   sig->digest_start[1] = iobuf_get_noeof (inp);
1723   pktlen--;
1724
1725   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1726     {
1727       const byte *p;
1728       size_t len;
1729
1730       /* Set sig->flags.unknown_critical if there is a critical bit
1731        * set for packets which we do not understand.  */
1732       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1733           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1734         sig->flags.unknown_critical = 1;
1735
1736       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1737       if (p)
1738         sig->timestamp = buffer_to_u32 (p);
1739       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1740                && opt.verbose)
1741         log_info ("signature packet without timestamp\n");
1742
1743       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER, NULL);
1744       if (p)
1745         {
1746           sig->keyid[0] = buffer_to_u32 (p);
1747           sig->keyid[1] = buffer_to_u32 (p + 4);
1748         }
1749       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1750                && opt.verbose)
1751         log_info ("signature packet without keyid\n");
1752
1753       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1754       if (p && buffer_to_u32 (p))
1755         sig->expiredate = sig->timestamp + buffer_to_u32 (p);
1756       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1757         sig->flags.expired = 1;
1758
1759       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1760       if (p)
1761         sig->flags.policy_url = 1;
1762
1763       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1764       if (p)
1765         sig->flags.pref_ks = 1;
1766
1767       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1768       if (p)
1769         sig->flags.notation = 1;
1770
1771       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1772       if (p && *p == 0)
1773         sig->flags.revocable = 0;
1774
1775       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1776       if (p && len == 2)
1777         {
1778           sig->trust_depth = p[0];
1779           sig->trust_value = p[1];
1780
1781           /* Only look for a regexp if there is also a trust
1782              subpacket. */
1783           sig->trust_regexp =
1784             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1785
1786           /* If the regular expression is of 0 length, there is no
1787              regular expression. */
1788           if (len == 0)
1789             sig->trust_regexp = NULL;
1790         }
1791
1792       /* We accept the exportable subpacket from either the hashed or
1793          unhashed areas as older versions of gpg put it in the
1794          unhashed area.  In theory, anyway, we should never see this
1795          packet off of a local keyring. */
1796
1797       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE, NULL);
1798       if (p && *p == 0)
1799         sig->flags.exportable = 0;
1800
1801       /* Find all revocation keys.  */
1802       if (sig->sig_class == 0x1F)
1803         parse_revkeys (sig);
1804     }
1805
1806   if (list_mode)
1807     {
1808       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1809                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1810                   "\tdigest algo %d, begin of digest %02x %02x\n",
1811                   sig->pubkey_algo,
1812                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1813                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1814                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1815       if (is_v4)
1816         {
1817           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1818           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1819         }
1820     }
1821
1822   ndata = pubkey_get_nsig (sig->pubkey_algo);
1823   if (!ndata)
1824     {
1825       if (list_mode)
1826         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1827       unknown_pubkey_warning (sig->pubkey_algo);
1828
1829       /* We store the plain material in data[0], so that we are able
1830        * to write it back with build_packet().  */
1831       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1832         {
1833           /* We include a limit to avoid too trivial DoS attacks by
1834              having gpg allocate too much memory.  */
1835           log_error ("signature packet: too much data\n");
1836           rc = GPG_ERR_INV_PACKET;
1837         }
1838       else
1839         {
1840           sig->data[0] =
1841             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
1842           pktlen = 0;
1843         }
1844     }
1845   else
1846     {
1847       for (i = 0; i < ndata; i++)
1848         {
1849           n = pktlen;
1850           sig->data[i] = mpi_read (inp, &n, 0);
1851           pktlen -= n;
1852           if (list_mode)
1853             {
1854               es_fprintf (listfp, "\tdata: ");
1855               mpi_print (listfp, sig->data[i], mpi_print_mode);
1856               es_putc ('\n', listfp);
1857             }
1858           if (!sig->data[i])
1859             rc = GPG_ERR_INV_PACKET;
1860         }
1861     }
1862
1863  leave:
1864   iobuf_skip_rest (inp, pktlen, 0);
1865   return rc;
1866 }
1867
1868
1869 static int
1870 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1871                    PKT_onepass_sig * ops)
1872 {
1873   int version;
1874   int rc = 0;
1875
1876   if (pktlen < 13)
1877     {
1878       log_error ("packet(%d) too short\n", pkttype);
1879       if (list_mode)
1880         es_fputs (":onepass_sig packet: [too short]\n", listfp);
1881       rc = gpg_error (GPG_ERR_INV_PACKET);
1882       goto leave;
1883     }
1884   version = iobuf_get_noeof (inp);
1885   pktlen--;
1886   if (version != 3)
1887     {
1888       log_error ("onepass_sig with unknown version %d\n", version);
1889       if (list_mode)
1890         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
1891       rc = gpg_error (GPG_ERR_INV_PACKET);
1892       goto leave;
1893     }
1894   ops->sig_class = iobuf_get_noeof (inp);
1895   pktlen--;
1896   ops->digest_algo = iobuf_get_noeof (inp);
1897   pktlen--;
1898   ops->pubkey_algo = iobuf_get_noeof (inp);
1899   pktlen--;
1900   ops->keyid[0] = read_32 (inp);
1901   pktlen -= 4;
1902   ops->keyid[1] = read_32 (inp);
1903   pktlen -= 4;
1904   ops->last = iobuf_get_noeof (inp);
1905   pktlen--;
1906   if (list_mode)
1907     es_fprintf (listfp,
1908                 ":onepass_sig packet: keyid %08lX%08lX\n"
1909                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1910                 "last=%d\n",
1911                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1912                 version, ops->sig_class,
1913                 ops->digest_algo, ops->pubkey_algo, ops->last);
1914
1915
1916  leave:
1917   iobuf_skip_rest (inp, pktlen, 0);
1918   return rc;
1919 }
1920
1921
1922 static int
1923 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1924            byte * hdr, int hdrlen, PACKET * pkt)
1925 {
1926   gpg_error_t err = 0;
1927   int i, version, algorithm;
1928   unsigned long timestamp, expiredate, max_expiredate;
1929   int npkey, nskey;
1930   u32 keyid[2];
1931   PKT_public_key *pk;
1932
1933   (void) hdr;
1934
1935   pk = pkt->pkt.public_key; /* PK has been cleared. */
1936
1937   version = iobuf_get_noeof (inp);
1938   pktlen--;
1939   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1940     {
1941       /* Early versions of G10 used the old PGP comments packets;
1942        * luckily all those comments are started by a hash.  */
1943       if (list_mode)
1944         {
1945           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1946           for (; pktlen; pktlen--)
1947             {
1948               int c;
1949               c = iobuf_get (inp);
1950               if (c == -1)
1951                 break; /* Ooops: shorter than indicated.  */
1952               if (c >= ' ' && c <= 'z')
1953                 es_putc (c, listfp);
1954               else
1955                 es_fprintf (listfp, "\\x%02x", c);
1956             }
1957           es_fprintf (listfp, "\"\n");
1958         }
1959       iobuf_skip_rest (inp, pktlen, 0);
1960       return 0;
1961     }
1962   else if (version == 4)
1963     {
1964       /* The only supported version.  Use an older gpg
1965          version (i.e. gpg 1.4) to parse v3 packets.  */
1966     }
1967   else if (version == 2 || version == 3)
1968     {
1969       if (opt.verbose > 1)
1970         log_info ("packet(%d) with obsolete version %d\n", pkttype, version);
1971       if (list_mode)
1972         es_fprintf (listfp, ":key packet: [obsolete version %d]\n", version);
1973       pk->version = version;
1974       err = gpg_error (GPG_ERR_LEGACY_KEY);
1975       goto leave;
1976     }
1977   else
1978     {
1979       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1980       if (list_mode)
1981         es_fputs (":key packet: [unknown version]\n", listfp);
1982       err = gpg_error (GPG_ERR_INV_PACKET);
1983       goto leave;
1984     }
1985
1986   if (pktlen < 11)
1987     {
1988       log_error ("packet(%d) too short\n", pkttype);
1989       if (list_mode)
1990         es_fputs (":key packet: [too short]\n", listfp);
1991       err = gpg_error (GPG_ERR_INV_PACKET);
1992       goto leave;
1993     }
1994   else if (pktlen > MAX_KEY_PACKET_LENGTH)
1995     {
1996       log_error ("packet(%d) too large\n", pkttype);
1997       if (list_mode)
1998         es_fputs (":key packet: [too larget]\n", listfp);
1999       err = gpg_error (GPG_ERR_INV_PACKET);
2000       goto leave;
2001     }
2002
2003   timestamp = read_32 (inp);
2004   pktlen -= 4;
2005   expiredate = 0;               /* have to get it from the selfsignature */
2006   max_expiredate = 0;
2007   algorithm = iobuf_get_noeof (inp);
2008   pktlen--;
2009   if (list_mode)
2010     es_fprintf (listfp, ":%s key packet:\n"
2011                 "\tversion %d, algo %d, created %lu, expires %lu\n",
2012                 pkttype == PKT_PUBLIC_KEY ? "public" :
2013                 pkttype == PKT_SECRET_KEY ? "secret" :
2014                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
2015                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
2016                 version, algorithm, timestamp, expiredate);
2017
2018   pk->timestamp = timestamp;
2019   pk->expiredate = expiredate;
2020   pk->max_expiredate = max_expiredate;
2021   pk->hdrbytes = hdrlen;
2022   pk->version = version;
2023   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
2024   pk->pubkey_algo = algorithm;
2025
2026   nskey = pubkey_get_nskey (algorithm);
2027   npkey = pubkey_get_npkey (algorithm);
2028   if (!npkey)
2029     {
2030       if (list_mode)
2031         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2032       unknown_pubkey_warning (algorithm);
2033     }
2034
2035   if (!npkey)
2036     {
2037       /* Unknown algorithm - put data into an opaque MPI.  */
2038       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2039                                          read_rest (inp, pktlen), pktlen * 8);
2040       pktlen = 0;
2041       goto leave;
2042     }
2043   else
2044     {
2045       for (i = 0; i < npkey; i++)
2046         {
2047           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2048                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2049                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2050             {
2051               /* Read the OID (i==1) or the KDF params (i==2).  */
2052               size_t n;
2053               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2054               pktlen -= n;
2055             }
2056           else
2057             {
2058               unsigned int n = pktlen;
2059               pk->pkey[i] = mpi_read (inp, &n, 0);
2060               pktlen -= n;
2061               if (!pk->pkey[i])
2062                 err = gpg_error (GPG_ERR_INV_PACKET);
2063             }
2064           if (err)
2065             goto leave;
2066           if (list_mode)
2067             {
2068               es_fprintf (listfp, "\tpkey[%d]: ", i);
2069               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2070               if ((algorithm == PUBKEY_ALGO_ECDSA
2071                    || algorithm == PUBKEY_ALGO_EDDSA
2072                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2073                 {
2074                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2075                   es_fprintf (listfp, " %s (%s)",
2076                               openpgp_oid_to_curve (curve), curve);
2077                   xfree (curve);
2078                 }
2079               es_putc ('\n', listfp);
2080             }
2081         }
2082     }
2083   if (list_mode)
2084     keyid_from_pk (pk, keyid);
2085
2086   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2087     {
2088       struct seckey_info *ski;
2089       byte temp[16];
2090       size_t snlen = 0;
2091
2092       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2093       if (!pk->seckey_info)
2094         {
2095           err = gpg_error_from_syserror ();
2096           goto leave;
2097         }
2098
2099       ski->algo = iobuf_get_noeof (inp);
2100       pktlen--;
2101       if (ski->algo)
2102         {
2103           ski->is_protected = 1;
2104           ski->s2k.count = 0;
2105           if (ski->algo == 254 || ski->algo == 255)
2106             {
2107               if (pktlen < 3)
2108                 {
2109                   err = gpg_error (GPG_ERR_INV_PACKET);
2110                   goto leave;
2111                 }
2112               ski->sha1chk = (ski->algo == 254);
2113               ski->algo = iobuf_get_noeof (inp);
2114               pktlen--;
2115               /* Note that a ski->algo > 110 is illegal, but I'm not
2116                  erroring on it here as otherwise there would be no
2117                  way to delete such a key.  */
2118               ski->s2k.mode = iobuf_get_noeof (inp);
2119               pktlen--;
2120               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2121               pktlen--;
2122               /* Check for the special GNU extension.  */
2123               if (ski->s2k.mode == 101)
2124                 {
2125                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2126                     temp[i] = iobuf_get_noeof (inp);
2127                   if (i < 4 || memcmp (temp, "GNU", 3))
2128                     {
2129                       if (list_mode)
2130                         es_fprintf (listfp, "\tunknown S2K %d\n",
2131                                     ski->s2k.mode);
2132                       err = gpg_error (GPG_ERR_INV_PACKET);
2133                       goto leave;
2134                     }
2135                   /* Here we know that it is a GNU extension.  What
2136                    * follows is the GNU protection mode: All values
2137                    * have special meanings and they are mapped to MODE
2138                    * with a base of 1000.  */
2139                   ski->s2k.mode = 1000 + temp[3];
2140                 }
2141
2142               /* Read the salt.  */
2143               switch (ski->s2k.mode)
2144                 {
2145                 case 1:
2146                 case 3:
2147                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2148                     temp[i] = iobuf_get_noeof (inp);
2149                   memcpy (ski->s2k.salt, temp, 8);
2150                   break;
2151                 }
2152
2153               /* Check the mode.  */
2154               switch (ski->s2k.mode)
2155                 {
2156                 case 0:
2157                   if (list_mode)
2158                     es_fprintf (listfp, "\tsimple S2K");
2159                   break;
2160                 case 1:
2161                   if (list_mode)
2162                     es_fprintf (listfp, "\tsalted S2K");
2163                   break;
2164                 case 3:
2165                   if (list_mode)
2166                     es_fprintf (listfp, "\titer+salt S2K");
2167                   break;
2168                 case 1001:
2169                   if (list_mode)
2170                     es_fprintf (listfp, "\tgnu-dummy S2K");
2171                   break;
2172                 case 1002:
2173                   if (list_mode)
2174                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2175                   break;
2176                 default:
2177                   if (list_mode)
2178                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2179                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2180                                 ski->s2k.mode);
2181                   err = gpg_error (GPG_ERR_INV_PACKET);
2182                   goto leave;
2183                 }
2184
2185               /* Print some info.  */
2186               if (list_mode)
2187                 {
2188                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2189                               ski->algo,
2190                               ski->sha1chk ? " SHA1 protection,"
2191                               : " simple checksum,", ski->s2k.hash_algo);
2192                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2193                     {
2194                       es_fprintf (listfp, ", salt: ");
2195                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2196                     }
2197                   es_putc ('\n', listfp);
2198                 }
2199
2200               /* Read remaining protection parameters.  */
2201               if (ski->s2k.mode == 3)
2202                 {
2203                   if (pktlen < 1)
2204                     {
2205                       err = gpg_error (GPG_ERR_INV_PACKET);
2206                       goto leave;
2207                     }
2208                   ski->s2k.count = iobuf_get (inp);
2209                   pktlen--;
2210                   if (list_mode)
2211                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2212                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2213                                 (ulong) ski->s2k.count);
2214                 }
2215               else if (ski->s2k.mode == 1002)
2216                 {
2217                   /* Read the serial number. */
2218                   if (pktlen < 1)
2219                     {
2220                       err = gpg_error (GPG_ERR_INV_PACKET);
2221                       goto leave;
2222                     }
2223                   snlen = iobuf_get (inp);
2224                   pktlen--;
2225                   if (pktlen < snlen || snlen == (size_t)(-1))
2226                     {
2227                       err = gpg_error (GPG_ERR_INV_PACKET);
2228                       goto leave;
2229                     }
2230                 }
2231             }
2232           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2233             {
2234               /* Note that a ski->algo > 110 is illegal, but I'm not
2235                  erroring on it here as otherwise there would be no
2236                  way to delete such a key.  */
2237               ski->s2k.mode = 0;
2238               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2239               if (list_mode)
2240                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2241                             ski->algo, ski->s2k.hash_algo);
2242             }
2243
2244           /* It is really ugly that we don't know the size
2245            * of the IV here in cases we are not aware of the algorithm.
2246            * so a
2247            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2248            * won't work.  The only solution I see is to hardwire it.
2249            * NOTE: if you change the ivlen above 16, don't forget to
2250            * enlarge temp.  */
2251           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2252           assert (ski->ivlen <= sizeof (temp));
2253
2254           if (ski->s2k.mode == 1001)
2255             ski->ivlen = 0;
2256           else if (ski->s2k.mode == 1002)
2257             ski->ivlen = snlen < 16 ? snlen : 16;
2258
2259           if (pktlen < ski->ivlen)
2260             {
2261               err = gpg_error (GPG_ERR_INV_PACKET);
2262               goto leave;
2263             }
2264           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2265             temp[i] = iobuf_get_noeof (inp);
2266           if (list_mode)
2267             {
2268               es_fprintf (listfp,
2269                           ski->s2k.mode == 1002 ? "\tserial-number: "
2270                           : "\tprotect IV: ");
2271               for (i = 0; i < ski->ivlen; i++)
2272                 es_fprintf (listfp, " %02x", temp[i]);
2273               es_putc ('\n', listfp);
2274             }
2275           memcpy (ski->iv, temp, ski->ivlen);
2276         }
2277
2278       /* It does not make sense to read it into secure memory.
2279        * If the user is so careless, not to protect his secret key,
2280        * we can assume, that he operates an open system :=(.
2281        * So we put the key into secure memory when we unprotect it. */
2282       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2283         {
2284           /* Better set some dummy stuff here.  */
2285           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2286                                                  xstrdup ("dummydata"),
2287                                                  10 * 8);
2288           pktlen = 0;
2289         }
2290       else if (ski->is_protected)
2291         {
2292           /* Ugly: The length is encrypted too, so we read all stuff
2293            * up to the end of the packet into the first SKEY
2294            * element.  */
2295           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2296                                                  read_rest (inp, pktlen),
2297                                                  pktlen * 8);
2298           /* Mark that MPI as protected - we need this information for
2299              importing a key.  The OPAQUE flag can't be used because
2300              we also store public EdDSA values in opaque MPIs.  */
2301           if (pk->pkey[npkey])
2302             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2303           pktlen = 0;
2304           if (list_mode)
2305             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2306         }
2307       else
2308         {
2309           /* Not encrypted.  */
2310           for (i = npkey; i < nskey; i++)
2311             {
2312               unsigned int n = pktlen;
2313               pk->pkey[i] = mpi_read (inp, &n, 0);
2314               pktlen -= n;
2315               if (list_mode)
2316                 {
2317                   es_fprintf (listfp, "\tskey[%d]: ", i);
2318                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2319                   es_putc ('\n', listfp);
2320                 }
2321
2322               if (!pk->pkey[i])
2323                 err = gpg_error (GPG_ERR_INV_PACKET);
2324             }
2325           if (err)
2326             goto leave;
2327
2328           ski->csum = read_16 (inp);
2329           pktlen -= 2;
2330           if (list_mode)
2331             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2332         }
2333     }
2334
2335   if (list_mode)
2336     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2337                 (ulong) keyid[0], (ulong) keyid[1]);
2338
2339  leave:
2340   iobuf_skip_rest (inp, pktlen, 0);
2341   return err;
2342 }
2343
2344
2345 /* Attribute subpackets have the same format as v4 signature
2346    subpackets.  This is not part of OpenPGP, but is done in several
2347    versions of PGP nevertheless.  */
2348 int
2349 parse_attribute_subpkts (PKT_user_id * uid)
2350 {
2351   size_t n;
2352   int count = 0;
2353   struct user_attribute *attribs = NULL;
2354   const byte *buffer = uid->attrib_data;
2355   int buflen = uid->attrib_len;
2356   byte type;
2357
2358   xfree (uid->attribs);
2359
2360   while (buflen)
2361     {
2362       n = *buffer++;
2363       buflen--;
2364       if (n == 255)  /* 4 byte length header.  */
2365         {
2366           if (buflen < 4)
2367             goto too_short;
2368           n = (buffer[0] << 24) | (buffer[1] << 16)
2369             | (buffer[2] << 8) | buffer[3];
2370           buffer += 4;
2371           buflen -= 4;
2372         }
2373       else if (n >= 192)  /* 2 byte special encoded length header.  */
2374         {
2375           if (buflen < 2)
2376             goto too_short;
2377           n = ((n - 192) << 8) + *buffer + 192;
2378           buffer++;
2379           buflen--;
2380         }
2381       if (buflen < n)
2382         goto too_short;
2383
2384       if (!n)
2385         {
2386           /* Too short to encode the subpacket type.  */
2387           if (opt.verbose)
2388             log_info ("attribute subpacket too short\n");
2389           break;
2390         }
2391
2392       attribs = xrealloc (attribs,
2393                           (count + 1) * sizeof (struct user_attribute));
2394       memset (&attribs[count], 0, sizeof (struct user_attribute));
2395
2396       type = *buffer;
2397       buffer++;
2398       buflen--;
2399       n--;
2400
2401       attribs[count].type = type;
2402       attribs[count].data = buffer;
2403       attribs[count].len = n;
2404       buffer += n;
2405       buflen -= n;
2406       count++;
2407     }
2408
2409   uid->attribs = attribs;
2410   uid->numattribs = count;
2411   return count;
2412
2413  too_short:
2414   if (opt.verbose)
2415     log_info ("buffer shorter than attribute subpacket\n");
2416   uid->attribs = attribs;
2417   uid->numattribs = count;
2418   return count;
2419 }
2420
2421
2422 static int
2423 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2424 {
2425   byte *p;
2426
2427   /* Cap the size of a user ID at 2k: a value absurdly large enough
2428      that there is no sane user ID string (which is printable text
2429      as of RFC2440bis) that won't fit in it, but yet small enough to
2430      avoid allocation problems.  A large pktlen may not be
2431      allocatable, and a very large pktlen could actually cause our
2432      allocation to wrap around in xmalloc to a small number. */
2433
2434   if (pktlen > MAX_UID_PACKET_LENGTH)
2435     {
2436       log_error ("packet(%d) too large\n", pkttype);
2437       if (list_mode)
2438         es_fprintf (listfp, ":user ID packet: [too large]\n");
2439       iobuf_skip_rest (inp, pktlen, 0);
2440       return GPG_ERR_INV_PACKET;
2441     }
2442
2443   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2444   packet->pkt.user_id->len = pktlen;
2445   packet->pkt.user_id->ref = 1;
2446
2447   p = packet->pkt.user_id->name;
2448   for (; pktlen; pktlen--, p++)
2449     *p = iobuf_get_noeof (inp);
2450   *p = 0;
2451
2452   if (list_mode)
2453     {
2454       int n = packet->pkt.user_id->len;
2455       es_fprintf (listfp, ":user ID packet: \"");
2456       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2457       for (p = packet->pkt.user_id->name; n; p++, n--)
2458         {
2459           if (*p >= ' ' && *p <= 'z')
2460             es_putc (*p, listfp);
2461           else
2462             es_fprintf (listfp, "\\x%02x", *p);
2463         }
2464       es_fprintf (listfp, "\"\n");
2465     }
2466   return 0;
2467 }
2468
2469
2470 void
2471 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2472 {
2473   assert (max_namelen > 70);
2474   if (uid->numattribs <= 0)
2475     sprintf (uid->name, "[bad attribute packet of size %lu]",
2476              uid->attrib_len);
2477   else if (uid->numattribs > 1)
2478     sprintf (uid->name, "[%d attributes of size %lu]",
2479              uid->numattribs, uid->attrib_len);
2480   else
2481     {
2482       /* Only one attribute, so list it as the "user id" */
2483
2484       if (uid->attribs->type == ATTRIB_IMAGE)
2485         {
2486           u32 len;
2487           byte type;
2488
2489           if (parse_image_header (uid->attribs, &type, &len))
2490             sprintf (uid->name, "[%.20s image of size %lu]",
2491                      image_type_to_string (type, 1), (ulong) len);
2492           else
2493             sprintf (uid->name, "[invalid image]");
2494         }
2495       else
2496         sprintf (uid->name, "[unknown attribute of size %lu]",
2497                  (ulong) uid->attribs->len);
2498     }
2499
2500   uid->len = strlen (uid->name);
2501 }
2502
2503
2504 static int
2505 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2506                  PACKET * packet)
2507 {
2508   byte *p;
2509
2510   (void) pkttype;
2511
2512   /* We better cap the size of an attribute packet to make DoS not too
2513      easy.  16MB should be more then enough for one attribute packet
2514      (ie. a photo).  */
2515   if (pktlen > MAX_ATTR_PACKET_LENGTH)
2516     {
2517       log_error ("packet(%d) too large\n", pkttype);
2518       if (list_mode)
2519         es_fprintf (listfp, ":attribute packet: [too large]\n");
2520       iobuf_skip_rest (inp, pktlen, 0);
2521       return GPG_ERR_INV_PACKET;
2522     }
2523
2524 #define EXTRA_UID_NAME_SPACE 71
2525   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2526                                        + EXTRA_UID_NAME_SPACE);
2527   packet->pkt.user_id->ref = 1;
2528   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2529   packet->pkt.user_id->attrib_len = pktlen;
2530
2531   p = packet->pkt.user_id->attrib_data;
2532   for (; pktlen; pktlen--, p++)
2533     *p = iobuf_get_noeof (inp);
2534
2535   /* Now parse out the individual attribute subpackets.  This is
2536      somewhat pointless since there is only one currently defined
2537      attribute type (jpeg), but it is correct by the spec. */
2538   parse_attribute_subpkts (packet->pkt.user_id);
2539
2540   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2541
2542   if (list_mode)
2543     {
2544       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2545     }
2546   return 0;
2547 }
2548
2549
2550 static int
2551 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2552 {
2553   byte *p;
2554
2555   /* Cap comment packet at a reasonable value to avoid an integer
2556      overflow in the malloc below.  Comment packets are actually not
2557      anymore define my OpenPGP and we even stopped to use our
2558      private comment packet.  */
2559   if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2560     {
2561       log_error ("packet(%d) too large\n", pkttype);
2562       if (list_mode)
2563         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2564                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2565       iobuf_skip_rest (inp, pktlen, 0);
2566       return GPG_ERR_INV_PACKET;
2567     }
2568   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2569   packet->pkt.comment->len = pktlen;
2570   p = packet->pkt.comment->data;
2571   for (; pktlen; pktlen--, p++)
2572     *p = iobuf_get_noeof (inp);
2573
2574   if (list_mode)
2575     {
2576       int n = packet->pkt.comment->len;
2577       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2578                   "OpenPGP draft " : "");
2579       for (p = packet->pkt.comment->data; n; p++, n--)
2580         {
2581           if (*p >= ' ' && *p <= 'z')
2582             es_putc (*p, listfp);
2583           else
2584             es_fprintf (listfp, "\\x%02x", *p);
2585         }
2586       es_fprintf (listfp, "\"\n");
2587     }
2588   return 0;
2589 }
2590
2591
2592 static void
2593 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2594 {
2595   int c;
2596
2597   (void) pkttype;
2598
2599   pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2600   if (pktlen)
2601     {
2602       c = iobuf_get_noeof (inp);
2603       pktlen--;
2604       pkt->pkt.ring_trust->trustval = c;
2605       pkt->pkt.ring_trust->sigcache = 0;
2606       if (!c && pktlen == 1)
2607         {
2608           c = iobuf_get_noeof (inp);
2609           pktlen--;
2610           /* We require that bit 7 of the sigcache is 0 (easier eof
2611              handling).  */
2612           if (!(c & 0x80))
2613             pkt->pkt.ring_trust->sigcache = c;
2614         }
2615       if (list_mode)
2616         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2617                     pkt->pkt.ring_trust->trustval,
2618                     pkt->pkt.ring_trust->sigcache);
2619     }
2620   else
2621     {
2622       pkt->pkt.ring_trust->trustval = 0;
2623       pkt->pkt.ring_trust->sigcache = 0;
2624       if (list_mode)
2625         es_fprintf (listfp, ":trust packet: empty\n");
2626     }
2627   iobuf_skip_rest (inp, pktlen, 0);
2628 }
2629
2630
2631 static int
2632 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2633                  PACKET * pkt, int new_ctb, int partial)
2634 {
2635   int rc = 0;
2636   int mode, namelen;
2637   PKT_plaintext *pt;
2638   byte *p;
2639   int c, i;
2640
2641   if (!partial && pktlen < 6)
2642     {
2643       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2644       if (list_mode)
2645         es_fputs (":literal data packet: [too short]\n", listfp);
2646       rc = gpg_error (GPG_ERR_INV_PACKET);
2647       goto leave;
2648     }
2649   mode = iobuf_get_noeof (inp);
2650   if (pktlen)
2651     pktlen--;
2652   namelen = iobuf_get_noeof (inp);
2653   if (pktlen)
2654     pktlen--;
2655   /* Note that namelen will never exceed 255 bytes. */
2656   pt = pkt->pkt.plaintext =
2657     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2658   pt->new_ctb = new_ctb;
2659   pt->mode = mode;
2660   pt->namelen = namelen;
2661   pt->is_partial = partial;
2662   if (pktlen)
2663     {
2664       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2665         pt->name[i] = iobuf_get_noeof (inp);
2666     }
2667   else
2668     {
2669       for (i = 0; i < namelen; i++)
2670         if ((c = iobuf_get (inp)) == -1)
2671           break;
2672         else
2673           pt->name[i] = c;
2674     }
2675   pt->timestamp = read_32 (inp);
2676   if (pktlen)
2677     pktlen -= 4;
2678   pt->len = pktlen;
2679   pt->buf = inp;
2680   pktlen = 0;
2681
2682   if (list_mode)
2683     {
2684       es_fprintf (listfp, ":literal data packet:\n"
2685                   "\tmode %c (%X), created %lu, name=\"",
2686                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2687                   (ulong) pt->timestamp);
2688       for (p = pt->name, i = 0; i < namelen; p++, i++)
2689         {
2690           if (*p >= ' ' && *p <= 'z')
2691             es_putc (*p, listfp);
2692           else
2693             es_fprintf (listfp, "\\x%02x", *p);
2694         }
2695       es_fprintf (listfp, "\",\n\traw data: ");
2696       if (partial)
2697         es_fprintf (listfp, "unknown length\n");
2698       else
2699         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2700     }
2701
2702  leave:
2703   return rc;
2704 }
2705
2706
2707 static int
2708 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2709                   PACKET * pkt, int new_ctb)
2710 {
2711   PKT_compressed *zd;
2712
2713   /* PKTLEN is here 0, but data follows (this should be the last
2714      object in a file or the compress algorithm should know the
2715      length).  */
2716   (void) pkttype;
2717   (void) pktlen;
2718
2719   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2720   zd->algorithm = iobuf_get_noeof (inp);
2721   zd->len = 0;                  /* not used */
2722   zd->new_ctb = new_ctb;
2723   zd->buf = inp;
2724   if (list_mode)
2725     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2726   return 0;
2727 }
2728
2729
2730 static int
2731 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2732                  PACKET * pkt, int new_ctb, int partial)
2733 {
2734   int rc = 0;
2735   PKT_encrypted *ed;
2736   unsigned long orig_pktlen = pktlen;
2737
2738   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2739   /* ed->len is set below.  */
2740   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2741   ed->buf = NULL;
2742   ed->new_ctb = new_ctb;
2743   ed->is_partial = partial;
2744   if (pkttype == PKT_ENCRYPTED_MDC)
2745     {
2746       /* Fixme: add some pktlen sanity checks.  */
2747       int version;
2748
2749       version = iobuf_get_noeof (inp);
2750       if (orig_pktlen)
2751         pktlen--;
2752       if (version != 1)
2753         {
2754           log_error ("encrypted_mdc packet with unknown version %d\n",
2755                      version);
2756           if (list_mode)
2757             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
2758           /*skip_rest(inp, pktlen); should we really do this? */
2759           rc = gpg_error (GPG_ERR_INV_PACKET);
2760           goto leave;
2761         }
2762       ed->mdc_method = DIGEST_ALGO_SHA1;
2763     }
2764   else
2765     ed->mdc_method = 0;
2766
2767   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2768      detection bytes.  Note that we don't known the algorithm and thus
2769      we may only check against the minimum blocksize.  */
2770   if (orig_pktlen && pktlen < 10)
2771     {
2772       /* Actually this is blocksize+2.  */
2773       log_error ("packet(%d) too short\n", pkttype);
2774       if (list_mode)
2775         es_fputs (":encrypted data packet: [too short]\n", listfp);
2776       rc = GPG_ERR_INV_PACKET;
2777       iobuf_skip_rest (inp, pktlen, partial);
2778       goto leave;
2779     }
2780
2781   /* Store the remaining length of the encrypted data (i.e. without
2782      the MDC version number but with the IV etc.).  This value is
2783      required during decryption.  */
2784   ed->len = pktlen;
2785
2786   if (list_mode)
2787     {
2788       if (orig_pktlen)
2789         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2790                     orig_pktlen);
2791       else
2792         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2793       if (ed->mdc_method)
2794         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2795     }
2796
2797   ed->buf = inp;
2798
2799  leave:
2800   return rc;
2801 }
2802
2803
2804 /* Note, that this code is not anymore used in real life because the
2805    MDC checking is now done right after the decryption in
2806    decrypt_data.  */
2807 static int
2808 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2809            PACKET * pkt, int new_ctb)
2810 {
2811   int rc = 0;
2812   PKT_mdc *mdc;
2813   byte *p;
2814
2815   (void) pkttype;
2816
2817   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2818   if (list_mode)
2819     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2820   if (!new_ctb || pktlen != 20)
2821     {
2822       log_error ("mdc_packet with invalid encoding\n");
2823       rc = gpg_error (GPG_ERR_INV_PACKET);
2824       goto leave;
2825     }
2826   p = mdc->hash;
2827   for (; pktlen; pktlen--, p++)
2828     *p = iobuf_get_noeof (inp);
2829
2830  leave:
2831   return rc;
2832 }
2833
2834
2835 /*
2836  * This packet is internally generated by us (ibn armor.c) to transfer
2837  * some information to the lower layer.  To make sure that this packet
2838  * is really a GPG faked one and not one comming from outside, we
2839  * first check that there is a unique tag in it.
2840  *
2841  * The format of such a control packet is:
2842  *   n byte  session marker
2843  *   1 byte  control type CTRLPKT_xxxxx
2844  *   m byte  control data
2845  */
2846 static int
2847 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2848                    PACKET * packet, int partial)
2849 {
2850   byte *p;
2851   const byte *sesmark;
2852   size_t sesmarklen;
2853   int i;
2854
2855   (void) pkttype;
2856
2857   if (list_mode)
2858     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2859
2860   sesmark = get_session_marker (&sesmarklen);
2861   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2862     goto skipit;
2863   for (i = 0; i < sesmarklen; i++, pktlen--)
2864     {
2865       if (sesmark[i] != iobuf_get_noeof (inp))
2866         goto skipit;
2867     }
2868   if (pktlen > 4096)
2869     goto skipit;  /* Definitely too large.  We skip it to avoid an
2870                      overflow in the malloc.  */
2871   if (list_mode)
2872     puts ("- gpg control packet");
2873
2874   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2875                                      + pktlen - 1);
2876   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2877   pktlen--;
2878   packet->pkt.gpg_control->datalen = pktlen;
2879   p = packet->pkt.gpg_control->data;
2880   for (; pktlen; pktlen--, p++)
2881     *p = iobuf_get_noeof (inp);
2882
2883   return 0;
2884
2885  skipit:
2886   if (list_mode)
2887     {
2888       int c;
2889
2890       i = 0;
2891       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2892       if (partial)
2893         {
2894           while ((c = iobuf_get (inp)) != -1)
2895             dump_hex_line (c, &i);
2896         }
2897       else
2898         {
2899           for (; pktlen; pktlen--)
2900             {
2901               dump_hex_line ((c = iobuf_get (inp)), &i);
2902               if (c == -1)
2903                 break;
2904             }
2905         }
2906       es_putc ('\n', listfp);
2907     }
2908   iobuf_skip_rest (inp, pktlen, 0);
2909   return gpg_error (GPG_ERR_INV_PACKET);
2910 }
2911
2912
2913 /* Create a GPG control packet to be used internally as a placeholder.  */
2914 PACKET *
2915 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2916 {
2917   PACKET *packet;
2918   byte *p;
2919
2920   packet = xmalloc (sizeof *packet);
2921   init_packet (packet);
2922   packet->pkttype = PKT_GPG_CONTROL;
2923   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2924                                      + datalen - 1);
2925   packet->pkt.gpg_control->control = type;
2926   packet->pkt.gpg_control->datalen = datalen;
2927   p = packet->pkt.gpg_control->data;
2928   for (; datalen; datalen--, p++)
2929     *p = *data++;
2930
2931   return packet;
2932 }