gpg: Fix out-of-bound read in subpacket enumeration
[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       if (!buflen)
1706         goto no_type_byte;
1707       type = *buffer;
1708       if (type & 0x80)
1709         {
1710           type &= 0x7f;
1711           *critical = 1;
1712         }
1713       else
1714         *critical = 0;
1715       if (!(++seq > reqseq))
1716         ;
1717       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1718         {
1719           if (*critical)
1720             {
1721               if (n - 1 > buflen + 1)
1722                 goto too_short;
1723               if (!can_handle_critical (buffer + 1, n - 1, type))
1724                 {
1725                   if (opt.verbose)
1726                     log_info (_("subpacket of type %d has "
1727                                 "critical bit set\n"), type);
1728                   if (start)
1729                     *start = seq;
1730                   return NULL;  /* This is an error.  */
1731                 }
1732             }
1733         }
1734       else if (reqtype < 0) /* List packets.  */
1735         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1736                          type, *critical, buffer, buflen, n);
1737       else if (type == reqtype) /* Found.  */
1738         {
1739           buffer++;
1740           n--;
1741           if (n > buflen)
1742             goto too_short;
1743           if (ret_n)
1744             *ret_n = n;
1745           offset = parse_one_sig_subpkt (buffer, n, type);
1746           switch (offset)
1747             {
1748             case -2:
1749               log_error ("subpacket of type %d too short\n", type);
1750               return NULL;
1751             case -1:
1752               return NULL;
1753             default:
1754               break;
1755             }
1756           if (start)
1757             *start = seq;
1758           return buffer + offset;
1759         }
1760       buffer += n;
1761       buflen -= n;
1762     }
1763   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1764     /* Returning NULL means we found a subpacket with the critical bit
1765        set that we don't grok.  We've iterated over all the subpackets
1766        and haven't found such a packet so we need to return a non-NULL
1767        value.  */
1768     return buffer;
1769
1770   /* Critical bit we don't understand. */
1771   if (start)
1772     *start = -1;
1773   return NULL;  /* End of packets; not found.  */
1774
1775  too_short:
1776   if (opt.verbose)
1777     log_info ("buffer shorter than subpacket\n");
1778   if (start)
1779     *start = -1;
1780   return NULL;
1781
1782  no_type_byte:
1783   if (opt.verbose)
1784     log_info ("type octet missing in subpacket\n");
1785   if (start)
1786     *start = -1;
1787   return NULL;
1788 }
1789
1790
1791 const byte *
1792 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1793                   size_t * ret_n)
1794 {
1795   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1796 }
1797
1798
1799 const byte *
1800 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype)
1801 {
1802   const byte *p;
1803
1804   p = parse_sig_subpkt (sig->hashed, reqtype, NULL);
1805   if (!p)
1806     p = parse_sig_subpkt (sig->unhashed, reqtype, NULL);
1807   return p;
1808 }
1809
1810
1811 /* Find all revocation keys.  Look in hashed area only.  */
1812 void
1813 parse_revkeys (PKT_signature * sig)
1814 {
1815   const byte *revkey;
1816   int seq = 0;
1817   size_t len;
1818
1819   if (sig->sig_class != 0x1F)
1820     return;
1821
1822   while ((revkey = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REV_KEY,
1823                                     &len, &seq, NULL)))
1824     {
1825       if (/* The only valid length is 22 bytes.  See RFC 4880
1826              5.2.3.15.  */
1827           len == 22
1828           /* 0x80 bit must be set on the class.  */
1829           && (revkey[0] & 0x80))
1830         {
1831           sig->revkey = xrealloc (sig->revkey,
1832                                   sizeof (struct revocation_key) *
1833                                   (sig->numrevkeys + 1));
1834
1835           /* Copy the individual fields.  */
1836           sig->revkey[sig->numrevkeys].class = revkey[0];
1837           sig->revkey[sig->numrevkeys].algid = revkey[1];
1838           memcpy (sig->revkey[sig->numrevkeys].fpr, &revkey[2], 20);
1839
1840           sig->numrevkeys++;
1841         }
1842     }
1843 }
1844
1845
1846 int
1847 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1848                  PKT_signature * sig)
1849 {
1850   int md5_len = 0;
1851   unsigned n;
1852   int is_v4 = 0;
1853   int rc = 0;
1854   int i, ndata;
1855
1856   if (pktlen < 16)
1857     {
1858       log_error ("packet(%d) too short\n", pkttype);
1859       if (list_mode)
1860         es_fputs (":signature packet: [too short]\n", listfp);
1861       goto leave;
1862     }
1863   sig->version = iobuf_get_noeof (inp);
1864   pktlen--;
1865   if (sig->version == 4)
1866     is_v4 = 1;
1867   else if (sig->version != 2 && sig->version != 3)
1868     {
1869       log_error ("packet(%d) with unknown version %d\n",
1870                  pkttype, sig->version);
1871       if (list_mode)
1872         es_fputs (":signature packet: [unknown version]\n", listfp);
1873       rc = gpg_error (GPG_ERR_INV_PACKET);
1874       goto leave;
1875     }
1876
1877   if (!is_v4)
1878     {
1879       if (pktlen == 0)
1880         goto underflow;
1881       md5_len = iobuf_get_noeof (inp);
1882       pktlen--;
1883     }
1884   if (pktlen == 0)
1885     goto underflow;
1886   sig->sig_class = iobuf_get_noeof (inp);
1887   pktlen--;
1888   if (!is_v4)
1889     {
1890       if (pktlen < 12)
1891         goto underflow;
1892       sig->timestamp = read_32 (inp);
1893       pktlen -= 4;
1894       sig->keyid[0] = read_32 (inp);
1895       pktlen -= 4;
1896       sig->keyid[1] = read_32 (inp);
1897       pktlen -= 4;
1898     }
1899   if (pktlen < 2)
1900     goto underflow;
1901   sig->pubkey_algo = iobuf_get_noeof (inp);
1902   pktlen--;
1903   sig->digest_algo = iobuf_get_noeof (inp);
1904   pktlen--;
1905   sig->flags.exportable = 1;
1906   sig->flags.revocable = 1;
1907   if (is_v4) /* Read subpackets.  */
1908     {
1909       if (pktlen < 2)
1910         goto underflow;
1911       n = read_16 (inp);
1912       pktlen -= 2;  /* Length of hashed data. */
1913       if (pktlen < n)
1914         goto underflow;
1915       if (n > 10000)
1916         {
1917           log_error ("signature packet: hashed data too long\n");
1918           if (list_mode)
1919             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1920           rc = GPG_ERR_INV_PACKET;
1921           goto leave;
1922         }
1923       if (n)
1924         {
1925           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1926           sig->hashed->size = n;
1927           sig->hashed->len = n;
1928           if (iobuf_read (inp, sig->hashed->data, n) != n)
1929             {
1930               log_error ("premature eof while reading "
1931                          "hashed signature data\n");
1932               if (list_mode)
1933                 es_fputs (":signature packet: [premature eof]\n", listfp);
1934               rc = -1;
1935               goto leave;
1936             }
1937           pktlen -= n;
1938         }
1939       if (pktlen < 2)
1940         goto underflow;
1941       n = read_16 (inp);
1942       pktlen -= 2;  /* Length of unhashed data.  */
1943       if (pktlen < n)
1944         goto underflow;
1945       if (n > 10000)
1946         {
1947           log_error ("signature packet: unhashed data too long\n");
1948           if (list_mode)
1949             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1950           rc = GPG_ERR_INV_PACKET;
1951           goto leave;
1952         }
1953       if (n)
1954         {
1955           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1956           sig->unhashed->size = n;
1957           sig->unhashed->len = n;
1958           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1959             {
1960               log_error ("premature eof while reading "
1961                          "unhashed signature data\n");
1962               if (list_mode)
1963                 es_fputs (":signature packet: [premature eof]\n", listfp);
1964               rc = -1;
1965               goto leave;
1966             }
1967           pktlen -= n;
1968         }
1969     }
1970
1971   if (pktlen < 2)
1972     goto underflow;
1973   sig->digest_start[0] = iobuf_get_noeof (inp);
1974   pktlen--;
1975   sig->digest_start[1] = iobuf_get_noeof (inp);
1976   pktlen--;
1977
1978   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1979     {
1980       const byte *p;
1981       size_t len;
1982
1983       /* Set sig->flags.unknown_critical if there is a critical bit
1984        * set for packets which we do not understand.  */
1985       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1986           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1987         sig->flags.unknown_critical = 1;
1988
1989       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1990       if (p)
1991         sig->timestamp = buf32_to_u32 (p);
1992       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1993                && opt.verbose)
1994         log_info ("signature packet without timestamp\n");
1995
1996       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER);
1997       if (p)
1998         {
1999           sig->keyid[0] = buf32_to_u32 (p);
2000           sig->keyid[1] = buf32_to_u32 (p + 4);
2001         }
2002       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
2003                && opt.verbose)
2004         log_info ("signature packet without keyid\n");
2005
2006       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
2007       if (p && buf32_to_u32 (p))
2008         sig->expiredate = sig->timestamp + buf32_to_u32 (p);
2009       if (sig->expiredate && sig->expiredate <= make_timestamp ())
2010         sig->flags.expired = 1;
2011
2012       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
2013       if (p)
2014         sig->flags.policy_url = 1;
2015
2016       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
2017       if (p)
2018         sig->flags.pref_ks = 1;
2019
2020       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIGNERS_UID, &len);
2021       if (p && len)
2022         {
2023           sig->signers_uid = try_make_printable_string (p, len, 0);
2024           if (!sig->signers_uid)
2025             {
2026               rc = gpg_error_from_syserror ();
2027               goto leave;
2028             }
2029         }
2030
2031       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
2032       if (p)
2033         sig->flags.notation = 1;
2034
2035       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
2036       if (p && *p == 0)
2037         sig->flags.revocable = 0;
2038
2039       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
2040       if (p && len == 2)
2041         {
2042           sig->trust_depth = p[0];
2043           sig->trust_value = p[1];
2044
2045           /* Only look for a regexp if there is also a trust
2046              subpacket. */
2047           sig->trust_regexp =
2048             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
2049
2050           /* If the regular expression is of 0 length, there is no
2051              regular expression. */
2052           if (len == 0)
2053             sig->trust_regexp = NULL;
2054         }
2055
2056       /* We accept the exportable subpacket from either the hashed or
2057          unhashed areas as older versions of gpg put it in the
2058          unhashed area.  In theory, anyway, we should never see this
2059          packet off of a local keyring. */
2060
2061       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE);
2062       if (p && *p == 0)
2063         sig->flags.exportable = 0;
2064
2065       /* Find all revocation keys.  */
2066       if (sig->sig_class == 0x1F)
2067         parse_revkeys (sig);
2068     }
2069
2070   if (list_mode)
2071     {
2072       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
2073                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
2074                   "\tdigest algo %d, begin of digest %02x %02x\n",
2075                   sig->pubkey_algo,
2076                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
2077                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
2078                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
2079       if (is_v4)
2080         {
2081           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
2082           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
2083         }
2084     }
2085
2086   ndata = pubkey_get_nsig (sig->pubkey_algo);
2087   if (!ndata)
2088     {
2089       if (list_mode)
2090         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
2091       unknown_pubkey_warning (sig->pubkey_algo);
2092
2093       /* We store the plain material in data[0], so that we are able
2094        * to write it back with build_packet().  */
2095       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
2096         {
2097           /* We include a limit to avoid too trivial DoS attacks by
2098              having gpg allocate too much memory.  */
2099           log_error ("signature packet: too much data\n");
2100           rc = GPG_ERR_INV_PACKET;
2101         }
2102       else
2103         {
2104           sig->data[0] =
2105             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
2106           pktlen = 0;
2107         }
2108     }
2109   else
2110     {
2111       for (i = 0; i < ndata; i++)
2112         {
2113           n = pktlen;
2114           sig->data[i] = mpi_read (inp, &n, 0);
2115           pktlen -= n;
2116           if (list_mode)
2117             {
2118               es_fprintf (listfp, "\tdata: ");
2119               mpi_print (listfp, sig->data[i], mpi_print_mode);
2120               es_putc ('\n', listfp);
2121             }
2122           if (!sig->data[i])
2123             rc = GPG_ERR_INV_PACKET;
2124         }
2125     }
2126
2127  leave:
2128   iobuf_skip_rest (inp, pktlen, 0);
2129   return rc;
2130
2131  underflow:
2132   log_error ("packet(%d) too short\n", pkttype);
2133   if (list_mode)
2134     es_fputs (":signature packet: [too short]\n", listfp);
2135
2136   iobuf_skip_rest (inp, pktlen, 0);
2137
2138   return GPG_ERR_INV_PACKET;
2139 }
2140
2141
2142 static int
2143 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
2144                    PKT_onepass_sig * ops)
2145 {
2146   int version;
2147   int rc = 0;
2148
2149   if (pktlen < 13)
2150     {
2151       log_error ("packet(%d) too short\n", pkttype);
2152       if (list_mode)
2153         es_fputs (":onepass_sig packet: [too short]\n", listfp);
2154       rc = gpg_error (GPG_ERR_INV_PACKET);
2155       goto leave;
2156     }
2157   version = iobuf_get_noeof (inp);
2158   pktlen--;
2159   if (version != 3)
2160     {
2161       log_error ("onepass_sig with unknown version %d\n", version);
2162       if (list_mode)
2163         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
2164       rc = gpg_error (GPG_ERR_INV_PACKET);
2165       goto leave;
2166     }
2167   ops->sig_class = iobuf_get_noeof (inp);
2168   pktlen--;
2169   ops->digest_algo = iobuf_get_noeof (inp);
2170   pktlen--;
2171   ops->pubkey_algo = iobuf_get_noeof (inp);
2172   pktlen--;
2173   ops->keyid[0] = read_32 (inp);
2174   pktlen -= 4;
2175   ops->keyid[1] = read_32 (inp);
2176   pktlen -= 4;
2177   ops->last = iobuf_get_noeof (inp);
2178   pktlen--;
2179   if (list_mode)
2180     es_fprintf (listfp,
2181                 ":onepass_sig packet: keyid %08lX%08lX\n"
2182                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
2183                 "last=%d\n",
2184                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
2185                 version, ops->sig_class,
2186                 ops->digest_algo, ops->pubkey_algo, ops->last);
2187
2188
2189  leave:
2190   iobuf_skip_rest (inp, pktlen, 0);
2191   return rc;
2192 }
2193
2194
2195 static int
2196 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
2197            byte * hdr, int hdrlen, PACKET * pkt)
2198 {
2199   gpg_error_t err = 0;
2200   int i, version, algorithm;
2201   unsigned long timestamp, expiredate, max_expiredate;
2202   int npkey, nskey;
2203   u32 keyid[2];
2204   PKT_public_key *pk;
2205
2206   (void) hdr;
2207
2208   pk = pkt->pkt.public_key; /* PK has been cleared. */
2209
2210   version = iobuf_get_noeof (inp);
2211   pktlen--;
2212   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
2213     {
2214       /* Early versions of G10 used the old PGP comments packets;
2215        * luckily all those comments are started by a hash.  */
2216       if (list_mode)
2217         {
2218           es_fprintf (listfp, ":rfc1991 comment packet: \"");
2219           for (; pktlen; pktlen--)
2220             {
2221               int c;
2222               c = iobuf_get (inp);
2223               if (c == -1)
2224                 break; /* Ooops: shorter than indicated.  */
2225               if (c >= ' ' && c <= 'z')
2226                 es_putc (c, listfp);
2227               else
2228                 es_fprintf (listfp, "\\x%02x", c);
2229             }
2230           es_fprintf (listfp, "\"\n");
2231         }
2232       iobuf_skip_rest (inp, pktlen, 0);
2233       return 0;
2234     }
2235   else if (version == 4)
2236     {
2237       /* The only supported version.  Use an older gpg
2238          version (i.e. gpg 1.4) to parse v3 packets.  */
2239     }
2240   else if (version == 2 || version == 3)
2241     {
2242       if (opt.verbose > 1)
2243         log_info ("packet(%d) with obsolete version %d\n", pkttype, version);
2244       if (list_mode)
2245         es_fprintf (listfp, ":key packet: [obsolete version %d]\n", version);
2246       pk->version = version;
2247       err = gpg_error (GPG_ERR_LEGACY_KEY);
2248       goto leave;
2249     }
2250   else
2251     {
2252       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
2253       if (list_mode)
2254         es_fputs (":key packet: [unknown version]\n", listfp);
2255       err = gpg_error (GPG_ERR_INV_PACKET);
2256       goto leave;
2257     }
2258
2259   if (pktlen < 11)
2260     {
2261       log_error ("packet(%d) too short\n", pkttype);
2262       if (list_mode)
2263         es_fputs (":key packet: [too short]\n", listfp);
2264       err = gpg_error (GPG_ERR_INV_PACKET);
2265       goto leave;
2266     }
2267   else if (pktlen > MAX_KEY_PACKET_LENGTH)
2268     {
2269       log_error ("packet(%d) too large\n", pkttype);
2270       if (list_mode)
2271         es_fputs (":key packet: [too larget]\n", listfp);
2272       err = gpg_error (GPG_ERR_INV_PACKET);
2273       goto leave;
2274     }
2275
2276   timestamp = read_32 (inp);
2277   pktlen -= 4;
2278   expiredate = 0;               /* have to get it from the selfsignature */
2279   max_expiredate = 0;
2280   algorithm = iobuf_get_noeof (inp);
2281   pktlen--;
2282   if (list_mode)
2283     es_fprintf (listfp, ":%s key packet:\n"
2284                 "\tversion %d, algo %d, created %lu, expires %lu\n",
2285                 pkttype == PKT_PUBLIC_KEY ? "public" :
2286                 pkttype == PKT_SECRET_KEY ? "secret" :
2287                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
2288                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
2289                 version, algorithm, timestamp, expiredate);
2290
2291   pk->timestamp = timestamp;
2292   pk->expiredate = expiredate;
2293   pk->max_expiredate = max_expiredate;
2294   pk->hdrbytes = hdrlen;
2295   pk->version = version;
2296   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
2297   pk->pubkey_algo = algorithm;
2298
2299   nskey = pubkey_get_nskey (algorithm);
2300   npkey = pubkey_get_npkey (algorithm);
2301   if (!npkey)
2302     {
2303       if (list_mode)
2304         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2305       unknown_pubkey_warning (algorithm);
2306     }
2307
2308   if (!npkey)
2309     {
2310       /* Unknown algorithm - put data into an opaque MPI.  */
2311       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2312                                          read_rest (inp, pktlen), pktlen * 8);
2313       pktlen = 0;
2314       goto leave;
2315     }
2316   else
2317     {
2318       for (i = 0; i < npkey; i++)
2319         {
2320           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2321                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2322                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2323             {
2324               /* Read the OID (i==1) or the KDF params (i==2).  */
2325               size_t n;
2326               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2327               pktlen -= n;
2328             }
2329           else
2330             {
2331               unsigned int n = pktlen;
2332               pk->pkey[i] = mpi_read (inp, &n, 0);
2333               pktlen -= n;
2334               if (!pk->pkey[i])
2335                 err = gpg_error (GPG_ERR_INV_PACKET);
2336             }
2337           if (err)
2338             goto leave;
2339           if (list_mode)
2340             {
2341               es_fprintf (listfp, "\tpkey[%d]: ", i);
2342               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2343               if ((algorithm == PUBKEY_ALGO_ECDSA
2344                    || algorithm == PUBKEY_ALGO_EDDSA
2345                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2346                 {
2347                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2348                   const char *name = openpgp_oid_to_curve (curve, 0);
2349                   es_fprintf (listfp, " %s (%s)", name?name:"", curve);
2350                   xfree (curve);
2351                 }
2352               es_putc ('\n', listfp);
2353             }
2354         }
2355     }
2356   if (list_mode)
2357     keyid_from_pk (pk, keyid);
2358
2359   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2360     {
2361       struct seckey_info *ski;
2362       byte temp[16];
2363       size_t snlen = 0;
2364
2365       if (pktlen < 1)
2366         {
2367           err = gpg_error (GPG_ERR_INV_PACKET);
2368           goto leave;
2369         }
2370
2371       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2372       if (!pk->seckey_info)
2373         {
2374           err = gpg_error_from_syserror ();
2375           goto leave;
2376         }
2377
2378       ski->algo = iobuf_get_noeof (inp);
2379       pktlen--;
2380       if (ski->algo)
2381         {
2382           ski->is_protected = 1;
2383           ski->s2k.count = 0;
2384           if (ski->algo == 254 || ski->algo == 255)
2385             {
2386               if (pktlen < 3)
2387                 {
2388                   err = gpg_error (GPG_ERR_INV_PACKET);
2389                   goto leave;
2390                 }
2391               ski->sha1chk = (ski->algo == 254);
2392               ski->algo = iobuf_get_noeof (inp);
2393               pktlen--;
2394               /* Note that a ski->algo > 110 is illegal, but I'm not
2395                  erroring on it here as otherwise there would be no
2396                  way to delete such a key.  */
2397               ski->s2k.mode = iobuf_get_noeof (inp);
2398               pktlen--;
2399               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2400               pktlen--;
2401               /* Check for the special GNU extension.  */
2402               if (ski->s2k.mode == 101)
2403                 {
2404                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2405                     temp[i] = iobuf_get_noeof (inp);
2406                   if (i < 4 || memcmp (temp, "GNU", 3))
2407                     {
2408                       if (list_mode)
2409                         es_fprintf (listfp, "\tunknown S2K %d\n",
2410                                     ski->s2k.mode);
2411                       err = gpg_error (GPG_ERR_INV_PACKET);
2412                       goto leave;
2413                     }
2414                   /* Here we know that it is a GNU extension.  What
2415                    * follows is the GNU protection mode: All values
2416                    * have special meanings and they are mapped to MODE
2417                    * with a base of 1000.  */
2418                   ski->s2k.mode = 1000 + temp[3];
2419                 }
2420
2421               /* Read the salt.  */
2422               switch (ski->s2k.mode)
2423                 {
2424                 case 1:
2425                 case 3:
2426                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2427                     temp[i] = iobuf_get_noeof (inp);
2428                   if (i < 8)
2429                     {
2430                       err = gpg_error (GPG_ERR_INV_PACKET);
2431                       goto leave;
2432                     }
2433                   memcpy (ski->s2k.salt, temp, 8);
2434                   break;
2435                 }
2436
2437               /* Check the mode.  */
2438               switch (ski->s2k.mode)
2439                 {
2440                 case 0:
2441                   if (list_mode)
2442                     es_fprintf (listfp, "\tsimple S2K");
2443                   break;
2444                 case 1:
2445                   if (list_mode)
2446                     es_fprintf (listfp, "\tsalted S2K");
2447                   break;
2448                 case 3:
2449                   if (list_mode)
2450                     es_fprintf (listfp, "\titer+salt S2K");
2451                   break;
2452                 case 1001:
2453                   if (list_mode)
2454                     es_fprintf (listfp, "\tgnu-dummy S2K");
2455                   break;
2456                 case 1002:
2457                   if (list_mode)
2458                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2459                   break;
2460                 default:
2461                   if (list_mode)
2462                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2463                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2464                                 ski->s2k.mode);
2465                   err = gpg_error (GPG_ERR_INV_PACKET);
2466                   goto leave;
2467                 }
2468
2469               /* Print some info.  */
2470               if (list_mode)
2471                 {
2472                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2473                               ski->algo,
2474                               ski->sha1chk ? " SHA1 protection,"
2475                               : " simple checksum,", ski->s2k.hash_algo);
2476                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2477                     {
2478                       es_fprintf (listfp, ", salt: ");
2479                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2480                     }
2481                   es_putc ('\n', listfp);
2482                 }
2483
2484               /* Read remaining protection parameters.  */
2485               if (ski->s2k.mode == 3)
2486                 {
2487                   if (pktlen < 1)
2488                     {
2489                       err = gpg_error (GPG_ERR_INV_PACKET);
2490                       goto leave;
2491                     }
2492                   ski->s2k.count = iobuf_get (inp);
2493                   pktlen--;
2494                   if (list_mode)
2495                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2496                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2497                                 (ulong) ski->s2k.count);
2498                 }
2499               else if (ski->s2k.mode == 1002)
2500                 {
2501                   /* Read the serial number. */
2502                   if (pktlen < 1)
2503                     {
2504                       err = gpg_error (GPG_ERR_INV_PACKET);
2505                       goto leave;
2506                     }
2507                   snlen = iobuf_get (inp);
2508                   pktlen--;
2509                   if (pktlen < snlen || snlen == (size_t)(-1))
2510                     {
2511                       err = gpg_error (GPG_ERR_INV_PACKET);
2512                       goto leave;
2513                     }
2514                 }
2515             }
2516           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2517             {
2518               /* Note that a ski->algo > 110 is illegal, but I'm not
2519                  erroring on it here as otherwise there would be no
2520                  way to delete such a key.  */
2521               ski->s2k.mode = 0;
2522               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2523               if (list_mode)
2524                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2525                             ski->algo, ski->s2k.hash_algo);
2526             }
2527
2528           /* It is really ugly that we don't know the size
2529            * of the IV here in cases we are not aware of the algorithm.
2530            * so a
2531            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2532            * won't work.  The only solution I see is to hardwire it.
2533            * NOTE: if you change the ivlen above 16, don't forget to
2534            * enlarge temp.  */
2535           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2536           log_assert (ski->ivlen <= sizeof (temp));
2537
2538           if (ski->s2k.mode == 1001)
2539             ski->ivlen = 0;
2540           else if (ski->s2k.mode == 1002)
2541             ski->ivlen = snlen < 16 ? snlen : 16;
2542
2543           if (pktlen < ski->ivlen)
2544             {
2545               err = gpg_error (GPG_ERR_INV_PACKET);
2546               goto leave;
2547             }
2548           for (i = 0; i < ski->ivlen; i++, pktlen--)
2549             temp[i] = iobuf_get_noeof (inp);
2550           if (list_mode)
2551             {
2552               es_fprintf (listfp,
2553                           ski->s2k.mode == 1002 ? "\tserial-number: "
2554                           : "\tprotect IV: ");
2555               for (i = 0; i < ski->ivlen; i++)
2556                 es_fprintf (listfp, " %02x", temp[i]);
2557               es_putc ('\n', listfp);
2558             }
2559           memcpy (ski->iv, temp, ski->ivlen);
2560         }
2561
2562       /* It does not make sense to read it into secure memory.
2563        * If the user is so careless, not to protect his secret key,
2564        * we can assume, that he operates an open system :=(.
2565        * So we put the key into secure memory when we unprotect it. */
2566       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2567         {
2568           /* Better set some dummy stuff here.  */
2569           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2570                                                  xstrdup ("dummydata"),
2571                                                  10 * 8);
2572           pktlen = 0;
2573         }
2574       else if (ski->is_protected)
2575         {
2576           if (pktlen < 2) /* At least two bytes for the length.  */
2577             {
2578               err = gpg_error (GPG_ERR_INV_PACKET);
2579               goto leave;
2580             }
2581
2582           /* Ugly: The length is encrypted too, so we read all stuff
2583            * up to the end of the packet into the first SKEY
2584            * element.  */
2585           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2586                                                  read_rest (inp, pktlen),
2587                                                  pktlen * 8);
2588           /* Mark that MPI as protected - we need this information for
2589              importing a key.  The OPAQUE flag can't be used because
2590              we also store public EdDSA values in opaque MPIs.  */
2591           if (pk->pkey[npkey])
2592             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2593           pktlen = 0;
2594           if (list_mode)
2595             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2596         }
2597       else
2598         {
2599           /* Not encrypted.  */
2600           for (i = npkey; i < nskey; i++)
2601             {
2602               unsigned int n;
2603
2604               if (pktlen < 2) /* At least two bytes for the length.  */
2605                 {
2606                   err = gpg_error (GPG_ERR_INV_PACKET);
2607                   goto leave;
2608                 }
2609               n = pktlen;
2610               pk->pkey[i] = mpi_read (inp, &n, 0);
2611               pktlen -= n;
2612               if (list_mode)
2613                 {
2614                   es_fprintf (listfp, "\tskey[%d]: ", i);
2615                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2616                   es_putc ('\n', listfp);
2617                 }
2618
2619               if (!pk->pkey[i])
2620                 err = gpg_error (GPG_ERR_INV_PACKET);
2621             }
2622           if (err)
2623             goto leave;
2624
2625           if (pktlen < 2)
2626             {
2627               err = gpg_error (GPG_ERR_INV_PACKET);
2628               goto leave;
2629             }
2630           ski->csum = read_16 (inp);
2631           pktlen -= 2;
2632           if (list_mode)
2633             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2634         }
2635     }
2636
2637   /* Note that KEYID below has been initialized above in list_mode.  */
2638   if (list_mode)
2639     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2640                 (ulong) keyid[0], (ulong) keyid[1]);
2641
2642  leave:
2643   iobuf_skip_rest (inp, pktlen, 0);
2644   return err;
2645 }
2646
2647
2648 /* Attribute subpackets have the same format as v4 signature
2649    subpackets.  This is not part of OpenPGP, but is done in several
2650    versions of PGP nevertheless.  */
2651 int
2652 parse_attribute_subpkts (PKT_user_id * uid)
2653 {
2654   size_t n;
2655   int count = 0;
2656   struct user_attribute *attribs = NULL;
2657   const byte *buffer = uid->attrib_data;
2658   int buflen = uid->attrib_len;
2659   byte type;
2660
2661   xfree (uid->attribs);
2662
2663   while (buflen)
2664     {
2665       n = *buffer++;
2666       buflen--;
2667       if (n == 255)  /* 4 byte length header.  */
2668         {
2669           if (buflen < 4)
2670             goto too_short;
2671           n = buf32_to_size_t (buffer);
2672           buffer += 4;
2673           buflen -= 4;
2674         }
2675       else if (n >= 192)  /* 2 byte special encoded length header.  */
2676         {
2677           if (buflen < 2)
2678             goto too_short;
2679           n = ((n - 192) << 8) + *buffer + 192;
2680           buffer++;
2681           buflen--;
2682         }
2683       if (buflen < n)
2684         goto too_short;
2685
2686       if (!n)
2687         {
2688           /* Too short to encode the subpacket type.  */
2689           if (opt.verbose)
2690             log_info ("attribute subpacket too short\n");
2691           break;
2692         }
2693
2694       attribs = xrealloc (attribs,
2695                           (count + 1) * sizeof (struct user_attribute));
2696       memset (&attribs[count], 0, sizeof (struct user_attribute));
2697
2698       type = *buffer;
2699       buffer++;
2700       buflen--;
2701       n--;
2702
2703       attribs[count].type = type;
2704       attribs[count].data = buffer;
2705       attribs[count].len = n;
2706       buffer += n;
2707       buflen -= n;
2708       count++;
2709     }
2710
2711   uid->attribs = attribs;
2712   uid->numattribs = count;
2713   return count;
2714
2715  too_short:
2716   if (opt.verbose)
2717     log_info ("buffer shorter than attribute subpacket\n");
2718   uid->attribs = attribs;
2719   uid->numattribs = count;
2720   return count;
2721 }
2722
2723
2724 static int
2725 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2726 {
2727   byte *p;
2728
2729   /* Cap the size of a user ID at 2k: a value absurdly large enough
2730      that there is no sane user ID string (which is printable text
2731      as of RFC2440bis) that won't fit in it, but yet small enough to
2732      avoid allocation problems.  A large pktlen may not be
2733      allocatable, and a very large pktlen could actually cause our
2734      allocation to wrap around in xmalloc to a small number. */
2735
2736   if (pktlen > MAX_UID_PACKET_LENGTH)
2737     {
2738       log_error ("packet(%d) too large\n", pkttype);
2739       if (list_mode)
2740         es_fprintf (listfp, ":user ID packet: [too large]\n");
2741       iobuf_skip_rest (inp, pktlen, 0);
2742       return GPG_ERR_INV_PACKET;
2743     }
2744
2745   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2746   packet->pkt.user_id->len = pktlen;
2747   packet->pkt.user_id->ref = 1;
2748
2749   p = packet->pkt.user_id->name;
2750   for (; pktlen; pktlen--, p++)
2751     *p = iobuf_get_noeof (inp);
2752   *p = 0;
2753
2754   if (list_mode)
2755     {
2756       int n = packet->pkt.user_id->len;
2757       es_fprintf (listfp, ":user ID packet: \"");
2758       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2759       for (p = packet->pkt.user_id->name; n; p++, n--)
2760         {
2761           if (*p >= ' ' && *p <= 'z')
2762             es_putc (*p, listfp);
2763           else
2764             es_fprintf (listfp, "\\x%02x", *p);
2765         }
2766       es_fprintf (listfp, "\"\n");
2767     }
2768   return 0;
2769 }
2770
2771
2772 void
2773 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2774 {
2775   log_assert (max_namelen > 70);
2776   if (uid->numattribs <= 0)
2777     sprintf (uid->name, "[bad attribute packet of size %lu]",
2778              uid->attrib_len);
2779   else if (uid->numattribs > 1)
2780     sprintf (uid->name, "[%d attributes of size %lu]",
2781              uid->numattribs, uid->attrib_len);
2782   else
2783     {
2784       /* Only one attribute, so list it as the "user id" */
2785
2786       if (uid->attribs->type == ATTRIB_IMAGE)
2787         {
2788           u32 len;
2789           byte type;
2790
2791           if (parse_image_header (uid->attribs, &type, &len))
2792             sprintf (uid->name, "[%.20s image of size %lu]",
2793                      image_type_to_string (type, 1), (ulong) len);
2794           else
2795             sprintf (uid->name, "[invalid image]");
2796         }
2797       else
2798         sprintf (uid->name, "[unknown attribute of size %lu]",
2799                  (ulong) uid->attribs->len);
2800     }
2801
2802   uid->len = strlen (uid->name);
2803 }
2804
2805
2806 static int
2807 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2808                  PACKET * packet)
2809 {
2810   byte *p;
2811
2812   (void) pkttype;
2813
2814   /* We better cap the size of an attribute packet to make DoS not too
2815      easy.  16MB should be more then enough for one attribute packet
2816      (ie. a photo).  */
2817   if (pktlen > MAX_ATTR_PACKET_LENGTH)
2818     {
2819       log_error ("packet(%d) too large\n", pkttype);
2820       if (list_mode)
2821         es_fprintf (listfp, ":attribute packet: [too large]\n");
2822       iobuf_skip_rest (inp, pktlen, 0);
2823       return GPG_ERR_INV_PACKET;
2824     }
2825
2826 #define EXTRA_UID_NAME_SPACE 71
2827   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2828                                        + EXTRA_UID_NAME_SPACE);
2829   packet->pkt.user_id->ref = 1;
2830   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2831   packet->pkt.user_id->attrib_len = pktlen;
2832
2833   p = packet->pkt.user_id->attrib_data;
2834   for (; pktlen; pktlen--, p++)
2835     *p = iobuf_get_noeof (inp);
2836
2837   /* Now parse out the individual attribute subpackets.  This is
2838      somewhat pointless since there is only one currently defined
2839      attribute type (jpeg), but it is correct by the spec. */
2840   parse_attribute_subpkts (packet->pkt.user_id);
2841
2842   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2843
2844   if (list_mode)
2845     {
2846       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2847     }
2848   return 0;
2849 }
2850
2851
2852 static int
2853 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2854 {
2855   byte *p;
2856
2857   /* Cap comment packet at a reasonable value to avoid an integer
2858      overflow in the malloc below.  Comment packets are actually not
2859      anymore define my OpenPGP and we even stopped to use our
2860      private comment packet.  */
2861   if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2862     {
2863       log_error ("packet(%d) too large\n", pkttype);
2864       if (list_mode)
2865         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2866                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2867       iobuf_skip_rest (inp, pktlen, 0);
2868       return GPG_ERR_INV_PACKET;
2869     }
2870   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2871   packet->pkt.comment->len = pktlen;
2872   p = packet->pkt.comment->data;
2873   for (; pktlen; pktlen--, p++)
2874     *p = iobuf_get_noeof (inp);
2875
2876   if (list_mode)
2877     {
2878       int n = packet->pkt.comment->len;
2879       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2880                   "OpenPGP draft " : "");
2881       for (p = packet->pkt.comment->data; n; p++, n--)
2882         {
2883           if (*p >= ' ' && *p <= 'z')
2884             es_putc (*p, listfp);
2885           else
2886             es_fprintf (listfp, "\\x%02x", *p);
2887         }
2888       es_fprintf (listfp, "\"\n");
2889     }
2890   return 0;
2891 }
2892
2893
2894 /* Parse a ring trust packet RFC4880 (5.10).
2895  *
2896  * This parser is special in that the packet is not stored as a packet
2897  * but its content is merged into the previous packet.  */
2898 static gpg_error_t
2899 parse_ring_trust (parse_packet_ctx_t ctx, unsigned long pktlen)
2900 {
2901   gpg_error_t err;
2902   iobuf_t inp = ctx->inp;
2903   PKT_ring_trust rt = {0};
2904   int c;
2905   int not_gpg = 0;
2906
2907   if (!pktlen)
2908     {
2909       if (list_mode)
2910         es_fprintf (listfp, ":trust packet: empty\n");
2911       err = 0;
2912       goto leave;
2913     }
2914
2915   c = iobuf_get_noeof (inp);
2916   pktlen--;
2917   rt.trustval = c;
2918   if (pktlen)
2919     {
2920       if (!c)
2921         {
2922           c = iobuf_get_noeof (inp);
2923           /* We require that bit 7 of the sigcache is 0 (easier
2924            * eof handling).  */
2925           if (!(c & 0x80))
2926             rt.sigcache = c;
2927         }
2928       else
2929         iobuf_get_noeof (inp);  /* Dummy read.  */
2930       pktlen--;
2931     }
2932
2933   /* Next is the optional subtype.  */
2934   if (pktlen > 3)
2935     {
2936       char tmp[4];
2937       tmp[0] = iobuf_get_noeof (inp);
2938       tmp[1] = iobuf_get_noeof (inp);
2939       tmp[2] = iobuf_get_noeof (inp);
2940       tmp[3] = iobuf_get_noeof (inp);
2941       pktlen -= 4;
2942       if (!memcmp (tmp, "gpg", 3))
2943         rt.subtype = tmp[3];
2944       else
2945         not_gpg = 1;
2946     }
2947   /* If it is a key or uid subtype read the remaining data.  */
2948   if ((rt.subtype == RING_TRUST_KEY || rt.subtype == RING_TRUST_UID)
2949       && pktlen >= 6 )
2950     {
2951       int i;
2952       unsigned int namelen;
2953
2954       rt.keyorg = iobuf_get_noeof (inp);
2955       pktlen--;
2956       rt.keyupdate = read_32 (inp);
2957       pktlen -= 4;
2958       namelen = iobuf_get_noeof (inp);
2959       pktlen--;
2960       if (namelen && pktlen)
2961         {
2962           rt.url = xtrymalloc (namelen + 1);
2963           if (!rt.url)
2964             {
2965               err = gpg_error_from_syserror ();
2966               goto leave;
2967             }
2968           for (i = 0; pktlen && i < namelen; pktlen--, i++)
2969             rt.url[i] = iobuf_get_noeof (inp);
2970           rt.url[i] = 0;
2971         }
2972     }
2973
2974   if (list_mode)
2975     {
2976       if (rt.subtype == RING_TRUST_SIG)
2977         es_fprintf (listfp, ":trust packet: sig flag=%02x sigcache=%02x\n",
2978                     rt.trustval, rt.sigcache);
2979       else if (rt.subtype == RING_TRUST_UID || rt.subtype == RING_TRUST_KEY)
2980         {
2981           unsigned char *p;
2982
2983           es_fprintf (listfp, ":trust packet: %s upd=%lu src=%d%s",
2984                       (rt.subtype == RING_TRUST_UID? "uid" : "key"),
2985                       (unsigned long)rt.keyupdate,
2986                       rt.keyorg,
2987                       (rt.url? " url=":""));
2988           if (rt.url)
2989             {
2990               for (p = rt.url; *p; p++)
2991                 {
2992                   if (*p >= ' ' && *p <= 'z')
2993                     es_putc (*p, listfp);
2994                   else
2995                     es_fprintf (listfp, "\\x%02x", *p);
2996                 }
2997             }
2998           es_putc ('\n', listfp);
2999         }
3000       else if (not_gpg)
3001         es_fprintf (listfp, ":trust packet: not created by gpg\n");
3002       else
3003         es_fprintf (listfp, ":trust packet: subtype=%02x\n",
3004                     rt.subtype);
3005     }
3006
3007   /* Now transfer the data to the respective packet.  Do not do this
3008    * if SKIP_META is set.  */
3009   if (!ctx->last_pkt.pkt.generic || ctx->skip_meta)
3010     ;
3011   else if (rt.subtype == RING_TRUST_SIG
3012            && ctx->last_pkt.pkttype == PKT_SIGNATURE)
3013     {
3014       PKT_signature *sig = ctx->last_pkt.pkt.signature;
3015
3016       if ((rt.sigcache & 1))
3017         {
3018           sig->flags.checked = 1;
3019           sig->flags.valid = !!(rt.sigcache & 2);
3020         }
3021     }
3022   else if (rt.subtype == RING_TRUST_UID
3023            && (ctx->last_pkt.pkttype == PKT_USER_ID
3024                || ctx->last_pkt.pkttype == PKT_ATTRIBUTE))
3025     {
3026       PKT_user_id *uid = ctx->last_pkt.pkt.user_id;
3027
3028       uid->keyorg = rt.keyorg;
3029       uid->keyupdate = rt.keyupdate;
3030       uid->updateurl = rt.url;
3031       rt.url = NULL;
3032     }
3033   else if (rt.subtype == RING_TRUST_KEY
3034            && (ctx->last_pkt.pkttype == PKT_PUBLIC_KEY
3035                || ctx->last_pkt.pkttype == PKT_SECRET_KEY))
3036     {
3037       PKT_public_key *pk = ctx->last_pkt.pkt.public_key;
3038
3039       pk->keyorg = rt.keyorg;
3040       pk->keyupdate = rt.keyupdate;
3041       pk->updateurl = rt.url;
3042       rt.url = NULL;
3043     }
3044
3045   err = 0;
3046
3047  leave:
3048   xfree (rt.url);
3049   free_packet (NULL, ctx); /* This sets ctx->last_pkt to NULL.  */
3050   iobuf_skip_rest (inp, pktlen, 0);
3051   return err;
3052 }
3053
3054
3055 static int
3056 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
3057                  PACKET * pkt, int new_ctb, int partial)
3058 {
3059   int rc = 0;
3060   int mode, namelen;
3061   PKT_plaintext *pt;
3062   byte *p;
3063   int c, i;
3064
3065   if (!partial && pktlen < 6)
3066     {
3067       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
3068       if (list_mode)
3069         es_fputs (":literal data packet: [too short]\n", listfp);
3070       rc = gpg_error (GPG_ERR_INV_PACKET);
3071       goto leave;
3072     }
3073   mode = iobuf_get_noeof (inp);
3074   if (pktlen)
3075     pktlen--;
3076   namelen = iobuf_get_noeof (inp);
3077   if (pktlen)
3078     pktlen--;
3079   /* Note that namelen will never exceed 255 bytes. */
3080   pt = pkt->pkt.plaintext =
3081     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
3082   pt->new_ctb = new_ctb;
3083   pt->mode = mode;
3084   pt->namelen = namelen;
3085   pt->is_partial = partial;
3086   if (pktlen)
3087     {
3088       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
3089         pt->name[i] = iobuf_get_noeof (inp);
3090     }
3091   else
3092     {
3093       for (i = 0; i < namelen; i++)
3094         if ((c = iobuf_get (inp)) == -1)
3095           break;
3096         else
3097           pt->name[i] = c;
3098     }
3099   /* Fill up NAME so that a check with valgrind won't complain about
3100    * reading from uninitalized memory.  This case may be triggred by
3101    * corrupted packets.  */
3102   for (; i < namelen; i++)
3103     pt->name[i] = 0;
3104
3105   pt->timestamp = read_32 (inp);
3106   if (pktlen)
3107     pktlen -= 4;
3108   pt->len = pktlen;
3109   pt->buf = inp;
3110
3111   if (list_mode)
3112     {
3113       es_fprintf (listfp, ":literal data packet:\n"
3114                   "\tmode %c (%X), created %lu, name=\"",
3115                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
3116                   (ulong) pt->timestamp);
3117       for (p = pt->name, i = 0; i < namelen; p++, i++)
3118         {
3119           if (*p >= ' ' && *p <= 'z')
3120             es_putc (*p, listfp);
3121           else
3122             es_fprintf (listfp, "\\x%02x", *p);
3123         }
3124       es_fprintf (listfp, "\",\n\traw data: ");
3125       if (partial)
3126         es_fprintf (listfp, "unknown length\n");
3127       else
3128         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
3129     }
3130
3131  leave:
3132   return rc;
3133 }
3134
3135
3136 static int
3137 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
3138                   PACKET * pkt, int new_ctb)
3139 {
3140   PKT_compressed *zd;
3141
3142   /* PKTLEN is here 0, but data follows (this should be the last
3143      object in a file or the compress algorithm should know the
3144      length).  */
3145   (void) pkttype;
3146   (void) pktlen;
3147
3148   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
3149   zd->algorithm = iobuf_get_noeof (inp);
3150   zd->len = 0;                  /* not used */
3151   zd->new_ctb = new_ctb;
3152   zd->buf = inp;
3153   if (list_mode)
3154     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
3155   return 0;
3156 }
3157
3158
3159 static int
3160 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
3161                  PACKET * pkt, int new_ctb, int partial)
3162 {
3163   int rc = 0;
3164   PKT_encrypted *ed;
3165   unsigned long orig_pktlen = pktlen;
3166
3167   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
3168   /* ed->len is set below.  */
3169   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
3170   ed->buf = NULL;
3171   ed->new_ctb = new_ctb;
3172   ed->is_partial = partial;
3173   if (pkttype == PKT_ENCRYPTED_MDC)
3174     {
3175       /* Fixme: add some pktlen sanity checks.  */
3176       int version;
3177
3178       version = iobuf_get_noeof (inp);
3179       if (orig_pktlen)
3180         pktlen--;
3181       if (version != 1)
3182         {
3183           log_error ("encrypted_mdc packet with unknown version %d\n",
3184                      version);
3185           if (list_mode)
3186             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
3187           /*skip_rest(inp, pktlen); should we really do this? */
3188           rc = gpg_error (GPG_ERR_INV_PACKET);
3189           goto leave;
3190         }
3191       ed->mdc_method = DIGEST_ALGO_SHA1;
3192     }
3193   else
3194     ed->mdc_method = 0;
3195
3196   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
3197      detection bytes.  Note that we don't known the algorithm and thus
3198      we may only check against the minimum blocksize.  */
3199   if (orig_pktlen && pktlen < 10)
3200     {
3201       /* Actually this is blocksize+2.  */
3202       log_error ("packet(%d) too short\n", pkttype);
3203       if (list_mode)
3204         es_fputs (":encrypted data packet: [too short]\n", listfp);
3205       rc = GPG_ERR_INV_PACKET;
3206       iobuf_skip_rest (inp, pktlen, partial);
3207       goto leave;
3208     }
3209
3210   /* Store the remaining length of the encrypted data (i.e. without
3211      the MDC version number but with the IV etc.).  This value is
3212      required during decryption.  */
3213   ed->len = pktlen;
3214
3215   if (list_mode)
3216     {
3217       if (orig_pktlen)
3218         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
3219                     orig_pktlen);
3220       else
3221         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
3222       if (ed->mdc_method)
3223         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
3224     }
3225
3226   ed->buf = inp;
3227
3228  leave:
3229   return rc;
3230 }
3231
3232
3233 /* Note, that this code is not anymore used in real life because the
3234    MDC checking is now done right after the decryption in
3235    decrypt_data.  */
3236 static int
3237 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
3238            PACKET * pkt, int new_ctb)
3239 {
3240   int rc = 0;
3241   PKT_mdc *mdc;
3242   byte *p;
3243
3244   (void) pkttype;
3245
3246   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
3247   if (list_mode)
3248     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
3249   if (!new_ctb || pktlen != 20)
3250     {
3251       log_error ("mdc_packet with invalid encoding\n");
3252       rc = gpg_error (GPG_ERR_INV_PACKET);
3253       goto leave;
3254     }
3255   p = mdc->hash;
3256   for (; pktlen; pktlen--, p++)
3257     *p = iobuf_get_noeof (inp);
3258
3259  leave:
3260   return rc;
3261 }
3262
3263
3264 /*
3265  * This packet is internally generated by us (in armor.c) to transfer
3266  * some information to the lower layer.  To make sure that this packet
3267  * is really a GPG faked one and not one coming from outside, we
3268  * first check that there is a unique tag in it.
3269  *
3270  * The format of such a control packet is:
3271  *   n byte  session marker
3272  *   1 byte  control type CTRLPKT_xxxxx
3273  *   m byte  control data
3274  */
3275 static int
3276 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
3277                    PACKET * packet, int partial)
3278 {
3279   byte *p;
3280   const byte *sesmark;
3281   size_t sesmarklen;
3282   int i;
3283
3284   (void) pkttype;
3285
3286   if (list_mode)
3287     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
3288
3289   sesmark = get_session_marker (&sesmarklen);
3290   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
3291     goto skipit;
3292   for (i = 0; i < sesmarklen; i++, pktlen--)
3293     {
3294       if (sesmark[i] != iobuf_get_noeof (inp))
3295         goto skipit;
3296     }
3297   if (pktlen > 4096)
3298     goto skipit;  /* Definitely too large.  We skip it to avoid an
3299                      overflow in the malloc.  */
3300   if (list_mode)
3301     es_fputs ("- gpg control packet", listfp);
3302
3303   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
3304                                      + pktlen - 1);
3305   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
3306   pktlen--;
3307   packet->pkt.gpg_control->datalen = pktlen;
3308   p = packet->pkt.gpg_control->data;
3309   for (; pktlen; pktlen--, p++)
3310     *p = iobuf_get_noeof (inp);
3311
3312   return 0;
3313
3314  skipit:
3315   if (list_mode)
3316     {
3317       int c;
3318
3319       i = 0;
3320       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
3321       if (partial)
3322         {
3323           while ((c = iobuf_get (inp)) != -1)
3324             dump_hex_line (c, &i);
3325         }
3326       else
3327         {
3328           for (; pktlen; pktlen--)
3329             {
3330               dump_hex_line ((c = iobuf_get (inp)), &i);
3331               if (c == -1)
3332                 break;
3333             }
3334         }
3335       es_putc ('\n', listfp);
3336     }
3337   iobuf_skip_rest (inp, pktlen, 0);
3338   return gpg_error (GPG_ERR_INV_PACKET);
3339 }
3340
3341
3342 /* Create a GPG control packet to be used internally as a placeholder.  */
3343 PACKET *
3344 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
3345 {
3346   PACKET *packet;
3347   byte *p;
3348
3349   packet = xmalloc (sizeof *packet);
3350   init_packet (packet);
3351   packet->pkttype = PKT_GPG_CONTROL;
3352   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
3353                                      + datalen - 1);
3354   packet->pkt.gpg_control->control = type;
3355   packet->pkt.gpg_control->datalen = datalen;
3356   p = packet->pkt.gpg_control->data;
3357   for (; datalen; datalen--, p++)
3358     *p = *data++;
3359
3360   return packet;
3361 }