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