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