gpg: Handle critical marked 'Reason for Revocation'.
[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   pkt->pkttype = pkttype;
768   rc = GPG_ERR_UNKNOWN_PACKET;  /* default error */
769   switch (pkttype)
770     {
771     case PKT_PUBLIC_KEY:
772     case PKT_PUBLIC_SUBKEY:
773     case PKT_SECRET_KEY:
774     case PKT_SECRET_SUBKEY:
775       pkt->pkt.public_key = xmalloc_clear (sizeof *pkt->pkt.public_key);
776       rc = parse_key (inp, pkttype, pktlen, hdr, hdrlen, pkt);
777       break;
778     case PKT_SYMKEY_ENC:
779       rc = parse_symkeyenc (inp, pkttype, pktlen, pkt);
780       break;
781     case PKT_PUBKEY_ENC:
782       rc = parse_pubkeyenc (inp, pkttype, pktlen, pkt);
783       break;
784     case PKT_SIGNATURE:
785       pkt->pkt.signature = xmalloc_clear (sizeof *pkt->pkt.signature);
786       rc = parse_signature (inp, pkttype, pktlen, pkt->pkt.signature);
787       break;
788     case PKT_ONEPASS_SIG:
789       pkt->pkt.onepass_sig = xmalloc_clear (sizeof *pkt->pkt.onepass_sig);
790       rc = parse_onepass_sig (inp, pkttype, pktlen, pkt->pkt.onepass_sig);
791       break;
792     case PKT_USER_ID:
793       rc = parse_user_id (inp, pkttype, pktlen, pkt);
794       break;
795     case PKT_ATTRIBUTE:
796       pkt->pkttype = pkttype = PKT_USER_ID;     /* we store it in the userID */
797       rc = parse_attribute (inp, pkttype, pktlen, pkt);
798       break;
799     case PKT_OLD_COMMENT:
800     case PKT_COMMENT:
801       rc = parse_comment (inp, pkttype, pktlen, pkt);
802       break;
803     case PKT_RING_TRUST:
804       {
805         rc = parse_ring_trust (ctx, pktlen);
806         if (!rc)
807           goto again; /* Directly read the next packet.  */
808       }
809       break;
810     case PKT_PLAINTEXT:
811       rc = parse_plaintext (inp, pkttype, pktlen, pkt, new_ctb, partial);
812       break;
813     case PKT_COMPRESSED:
814       rc = parse_compressed (inp, pkttype, pktlen, pkt, new_ctb);
815       break;
816     case PKT_ENCRYPTED:
817     case PKT_ENCRYPTED_MDC:
818       rc = parse_encrypted (inp, pkttype, pktlen, pkt, new_ctb, partial);
819       break;
820     case PKT_MDC:
821       rc = parse_mdc (inp, pkttype, pktlen, pkt, new_ctb);
822       break;
823     case PKT_GPG_CONTROL:
824       rc = parse_gpg_control (inp, pkttype, pktlen, pkt, partial);
825       break;
826     case PKT_MARKER:
827       rc = parse_marker (inp, pkttype, pktlen);
828       break;
829     default:
830       /* Unknown packet.  Skip it.  */
831       skip_packet (inp, pkttype, pktlen, partial);
832       break;
833     }
834
835   /* Store a shallow copy of certain packets in the context.  */
836   free_packet (NULL, ctx);
837   if (!rc && (pkttype == PKT_PUBLIC_KEY
838               || pkttype == PKT_SECRET_KEY
839               || pkttype == PKT_USER_ID
840               || pkttype == PKT_ATTRIBUTE
841               || pkttype == PKT_SIGNATURE))
842     {
843       ctx->last_pkt = *pkt;
844     }
845
846  leave:
847   /* FIXME: We leak in case of an error (see the xmalloc's above).  */
848   if (!rc && iobuf_error (inp))
849     rc = GPG_ERR_INV_KEYRING;
850
851   /* FIXME: We use only the error code for now to avoid problems with
852      callers which have not been checked to always use gpg_err_code()
853      when comparing error codes.  */
854   return rc == -1? -1 : gpg_err_code (rc);
855 }
856
857
858 static void
859 dump_hex_line (int c, int *i)
860 {
861   if (*i && !(*i % 8))
862     {
863       if (*i && !(*i % 24))
864         es_fprintf (listfp, "\n%4d:", *i);
865       else
866         es_putc (' ', listfp);
867     }
868   if (c == -1)
869     es_fprintf (listfp, " EOF");
870   else
871     es_fprintf (listfp, " %02x", c);
872   ++*i;
873 }
874
875
876 /* Copy the contents of a packet from the pipeline IN to the pipeline
877    OUT.
878
879    The header and length have already been read from INP and the
880    decoded values are given as PKGTYPE and PKTLEN.
881
882    If the packet is a partial body length packet (RFC 4880, Section
883    4.2.2.4), then iobuf_set_partial_block_modeiobuf_set_partial_block_mode
884    should already have been called on INP and PARTIAL should be set.
885
886    If PARTIAL is set or PKTLEN is 0 and PKTTYPE is PKT_COMPRESSED,
887    copy until the first EOF is encountered on INP.
888
889    Returns 0 on success and an error code if an error occurs.  */
890 static int
891 copy_packet (IOBUF inp, IOBUF out, int pkttype,
892              unsigned long pktlen, int partial)
893 {
894   int rc;
895   int n;
896   char buf[100];
897
898   if (partial)
899     {
900       while ((n = iobuf_read (inp, buf, sizeof (buf))) != -1)
901         if ((rc = iobuf_write (out, buf, n)))
902           return rc;            /* write error */
903     }
904   else if (!pktlen && pkttype == PKT_COMPRESSED)
905     {
906       log_debug ("copy_packet: compressed!\n");
907       /* compressed packet, copy till EOF */
908       while ((n = iobuf_read (inp, buf, sizeof (buf))) != -1)
909         if ((rc = iobuf_write (out, buf, n)))
910           return rc;            /* write error */
911     }
912   else
913     {
914       for (; pktlen; pktlen -= n)
915         {
916           n = pktlen > sizeof (buf) ? sizeof (buf) : pktlen;
917           n = iobuf_read (inp, buf, n);
918           if (n == -1)
919             return gpg_error (GPG_ERR_EOF);
920           if ((rc = iobuf_write (out, buf, n)))
921             return rc;          /* write error */
922         }
923     }
924   return 0;
925 }
926
927
928 /* Skip an unknown packet.  PKTTYPE is the packet's type, PKTLEN is
929    the length of the packet's content and PARTIAL is whether partial
930    body length encoding in used (in this case PKTLEN is ignored).  */
931 static void
932 skip_packet (IOBUF inp, int pkttype, unsigned long pktlen, int partial)
933 {
934   if (list_mode)
935     {
936       es_fprintf (listfp, ":unknown packet: type %2d, length %lu\n",
937                   pkttype, pktlen);
938       if (pkttype)
939         {
940           int c, i = 0;
941           es_fputs ("dump:", listfp);
942           if (partial)
943             {
944               while ((c = iobuf_get (inp)) != -1)
945                 dump_hex_line (c, &i);
946             }
947           else
948             {
949               for (; pktlen; pktlen--)
950                 {
951                   dump_hex_line ((c = iobuf_get (inp)), &i);
952                   if (c == -1)
953                     break;
954                 }
955             }
956           es_putc ('\n', listfp);
957           return;
958         }
959     }
960   iobuf_skip_rest (inp, pktlen, partial);
961 }
962
963
964 /* Read PKTLEN bytes form INP and return them in a newly allocated
965    buffer.  In case of an error (including reading fewer than PKTLEN
966    bytes from INP before EOF is returned), NULL is returned and an
967    error message is logged.  */
968 static void *
969 read_rest (IOBUF inp, size_t pktlen)
970 {
971   int c;
972   byte *buf, *p;
973
974   buf = xtrymalloc (pktlen);
975   if (!buf)
976     {
977       gpg_error_t err = gpg_error_from_syserror ();
978       log_error ("error reading rest of packet: %s\n", gpg_strerror (err));
979       return NULL;
980     }
981   for (p = buf; pktlen; pktlen--)
982     {
983       c = iobuf_get (inp);
984       if (c == -1)
985         {
986           log_error ("premature eof while reading rest of packet\n");
987           xfree (buf);
988           return NULL;
989         }
990       *p++ = c;
991     }
992
993   return buf;
994 }
995
996
997 /* Read a special size+body from INP.  On success store an opaque MPI
998    with it at R_DATA.  On error return an error code and store NULL at
999    R_DATA.  Even in the error case store the number of read bytes at
1000    R_NREAD.  The caller shall pass the remaining size of the packet in
1001    PKTLEN.  */
1002 static gpg_error_t
1003 read_size_body (iobuf_t inp, int pktlen, size_t *r_nread,
1004                 gcry_mpi_t *r_data)
1005 {
1006   char buffer[256];
1007   char *tmpbuf;
1008   int i, c, nbytes;
1009
1010   *r_nread = 0;
1011   *r_data = NULL;
1012
1013   if (!pktlen)
1014     return gpg_error (GPG_ERR_INV_PACKET);
1015   c = iobuf_readbyte (inp);
1016   if (c < 0)
1017     return gpg_error (GPG_ERR_INV_PACKET);
1018   pktlen--;
1019   ++*r_nread;
1020   nbytes = c;
1021   if (nbytes < 2 || nbytes > 254)
1022     return gpg_error (GPG_ERR_INV_PACKET);
1023   if (nbytes > pktlen)
1024     return gpg_error (GPG_ERR_INV_PACKET);
1025
1026   buffer[0] = nbytes;
1027
1028   for (i = 0; i < nbytes; i++)
1029     {
1030       c = iobuf_get (inp);
1031       if (c < 0)
1032         return gpg_error (GPG_ERR_INV_PACKET);
1033       ++*r_nread;
1034       buffer[1+i] = c;
1035     }
1036
1037   tmpbuf = xtrymalloc (1 + nbytes);
1038   if (!tmpbuf)
1039     return gpg_error_from_syserror ();
1040   memcpy (tmpbuf, buffer, 1 + nbytes);
1041   *r_data = gcry_mpi_set_opaque (NULL, tmpbuf, 8 * (1 + nbytes));
1042   if (!*r_data)
1043     {
1044       xfree (tmpbuf);
1045       return gpg_error_from_syserror ();
1046     }
1047   return 0;
1048 }
1049
1050
1051 /* Parse a marker packet.  */
1052 static int
1053 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
1054 {
1055   (void) pkttype;
1056
1057   if (pktlen != 3)
1058     goto fail;
1059
1060   if (iobuf_get (inp) != 'P')
1061     {
1062       pktlen--;
1063       goto fail;
1064     }
1065
1066   if (iobuf_get (inp) != 'G')
1067     {
1068       pktlen--;
1069       goto fail;
1070     }
1071
1072   if (iobuf_get (inp) != 'P')
1073     {
1074       pktlen--;
1075       goto fail;
1076     }
1077
1078   if (list_mode)
1079     es_fputs (":marker packet: PGP\n", listfp);
1080
1081   return 0;
1082
1083  fail:
1084   log_error ("invalid marker packet\n");
1085   if (list_mode)
1086     es_fputs (":marker packet: [invalid]\n", listfp);
1087   iobuf_skip_rest (inp, pktlen, 0);
1088   return GPG_ERR_INV_PACKET;
1089 }
1090
1091
1092 static int
1093 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
1094                  PACKET * packet)
1095 {
1096   PKT_symkey_enc *k;
1097   int rc = 0;
1098   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
1099
1100   if (pktlen < 4)
1101     {
1102       log_error ("packet(%d) too short\n", pkttype);
1103       if (list_mode)
1104         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
1105       rc = gpg_error (GPG_ERR_INV_PACKET);
1106       goto leave;
1107     }
1108   version = iobuf_get_noeof (inp);
1109   pktlen--;
1110   if (version != 4)
1111     {
1112       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1113       if (list_mode)
1114         es_fprintf (listfp, ":symkey enc packet: [unknown version]\n");
1115       rc = gpg_error (GPG_ERR_INV_PACKET);
1116       goto leave;
1117     }
1118   if (pktlen > 200)
1119     {                           /* (we encode the seskeylen in a byte) */
1120       log_error ("packet(%d) too large\n", pkttype);
1121       if (list_mode)
1122         es_fprintf (listfp, ":symkey enc packet: [too large]\n");
1123       rc = gpg_error (GPG_ERR_INV_PACKET);
1124       goto leave;
1125     }
1126   cipher_algo = iobuf_get_noeof (inp);
1127   pktlen--;
1128   s2kmode = iobuf_get_noeof (inp);
1129   pktlen--;
1130   hash_algo = iobuf_get_noeof (inp);
1131   pktlen--;
1132   switch (s2kmode)
1133     {
1134     case 0: /* Simple S2K.  */
1135       minlen = 0;
1136       break;
1137     case 1: /* Salted S2K.  */
1138       minlen = 8;
1139       break;
1140     case 3: /* Iterated+salted S2K.  */
1141       minlen = 9;
1142       break;
1143     default:
1144       log_error ("unknown S2K mode %d\n", s2kmode);
1145       if (list_mode)
1146         es_fprintf (listfp, ":symkey enc packet: [unknown S2K mode]\n");
1147       goto leave;
1148     }
1149   if (minlen > pktlen)
1150     {
1151       log_error ("packet with S2K %d too short\n", s2kmode);
1152       if (list_mode)
1153         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
1154       rc = gpg_error (GPG_ERR_INV_PACKET);
1155       goto leave;
1156     }
1157   seskeylen = pktlen - minlen;
1158   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
1159                                               + seskeylen - 1);
1160   k->version = version;
1161   k->cipher_algo = cipher_algo;
1162   k->s2k.mode = s2kmode;
1163   k->s2k.hash_algo = hash_algo;
1164   if (s2kmode == 1 || s2kmode == 3)
1165     {
1166       for (i = 0; i < 8 && pktlen; i++, pktlen--)
1167         k->s2k.salt[i] = iobuf_get_noeof (inp);
1168     }
1169   if (s2kmode == 3)
1170     {
1171       k->s2k.count = iobuf_get (inp);
1172       pktlen--;
1173     }
1174   k->seskeylen = seskeylen;
1175   if (k->seskeylen)
1176     {
1177       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
1178         k->seskey[i] = iobuf_get_noeof (inp);
1179
1180       /* What we're watching out for here is a session key decryptor
1181          with no salt.  The RFC says that using salt for this is a
1182          MUST. */
1183       if (s2kmode != 1 && s2kmode != 3)
1184         log_info (_("WARNING: potentially insecure symmetrically"
1185                     " encrypted session key\n"));
1186     }
1187   log_assert (!pktlen);
1188
1189   if (list_mode)
1190     {
1191       es_fprintf (listfp,
1192                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
1193                   version, cipher_algo, s2kmode, hash_algo);
1194       if (seskeylen)
1195         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
1196       es_fprintf (listfp, "\n");
1197       if (s2kmode == 1 || s2kmode == 3)
1198         {
1199           es_fprintf (listfp, "\tsalt ");
1200           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
1201           if (s2kmode == 3)
1202             es_fprintf (listfp, ", count %lu (%lu)",
1203                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
1204                         (ulong) k->s2k.count);
1205           es_fprintf (listfp, "\n");
1206         }
1207     }
1208
1209  leave:
1210   iobuf_skip_rest (inp, pktlen, 0);
1211   return rc;
1212 }
1213
1214
1215 static int
1216 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
1217                  PACKET * packet)
1218 {
1219   int rc = 0;
1220   int i, ndata;
1221   PKT_pubkey_enc *k;
1222
1223   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
1224   if (pktlen < 12)
1225     {
1226       log_error ("packet(%d) too short\n", pkttype);
1227       if (list_mode)
1228         es_fputs (":pubkey enc packet: [too short]\n", listfp);
1229       rc = gpg_error (GPG_ERR_INV_PACKET);
1230       goto leave;
1231     }
1232   k->version = iobuf_get_noeof (inp);
1233   pktlen--;
1234   if (k->version != 2 && k->version != 3)
1235     {
1236       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
1237       if (list_mode)
1238         es_fputs (":pubkey enc packet: [unknown version]\n", listfp);
1239       rc = gpg_error (GPG_ERR_INV_PACKET);
1240       goto leave;
1241     }
1242   k->keyid[0] = read_32 (inp);
1243   pktlen -= 4;
1244   k->keyid[1] = read_32 (inp);
1245   pktlen -= 4;
1246   k->pubkey_algo = iobuf_get_noeof (inp);
1247   pktlen--;
1248   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
1249   if (list_mode)
1250     es_fprintf (listfp,
1251                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
1252                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
1253                 (ulong) k->keyid[1]);
1254
1255   ndata = pubkey_get_nenc (k->pubkey_algo);
1256   if (!ndata)
1257     {
1258       if (list_mode)
1259         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
1260       unknown_pubkey_warning (k->pubkey_algo);
1261       k->data[0] = NULL; /* No need to store the encrypted data.  */
1262     }
1263   else
1264     {
1265       for (i = 0; i < ndata; i++)
1266         {
1267           if (k->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
1268             {
1269               size_t n;
1270               rc = read_size_body (inp, pktlen, &n, k->data+i);
1271               pktlen -= n;
1272             }
1273           else
1274             {
1275               int n = pktlen;
1276               k->data[i] = mpi_read (inp, &n, 0);
1277               pktlen -= n;
1278               if (!k->data[i])
1279                 rc = gpg_error (GPG_ERR_INV_PACKET);
1280             }
1281           if (rc)
1282             goto leave;
1283           if (list_mode)
1284             {
1285               es_fprintf (listfp, "\tdata: ");
1286               mpi_print (listfp, k->data[i], mpi_print_mode);
1287               es_putc ('\n', listfp);
1288             }
1289         }
1290     }
1291
1292  leave:
1293   iobuf_skip_rest (inp, pktlen, 0);
1294   return rc;
1295 }
1296
1297
1298 /* Dump a subpacket to LISTFP.  BUFFER contains the subpacket in
1299    question and points to the type field in the subpacket header (not
1300    the start of the header).  TYPE is the subpacket's type with the
1301    critical bit cleared.  CRITICAL is the value of the CRITICAL bit.
1302    BUFLEN is the length of the buffer and LENGTH is the length of the
1303    subpacket according to the subpacket's header.  */
1304 static void
1305 dump_sig_subpkt (int hashed, int type, int critical,
1306                  const byte * buffer, size_t buflen, size_t length)
1307 {
1308   const char *p = NULL;
1309   int i;
1310
1311   /* The CERT has warning out with explains how to use GNUPG to detect
1312    * the ARRs - we print our old message here when it is a faked ARR
1313    * and add an additional notice.  */
1314   if (type == SIGSUBPKT_ARR && !hashed)
1315     {
1316       es_fprintf (listfp,
1317                   "\tsubpkt %d len %u (additional recipient request)\n"
1318                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
1319                   "encrypt to this key and thereby reveal the plaintext to "
1320                   "the owner of this ARR key. Detailed info follows:\n",
1321                   type, (unsigned) length);
1322     }
1323
1324   buffer++;
1325   length--;
1326
1327   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
1328               critical ? "critical " : "",
1329               hashed ? "hashed " : "", type, (unsigned) length);
1330   if (length > buflen)
1331     {
1332       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
1333       return;
1334     }
1335   switch (type)
1336     {
1337     case SIGSUBPKT_SIG_CREATED:
1338       if (length >= 4)
1339         es_fprintf (listfp, "sig created %s",
1340                     strtimestamp (buf32_to_u32 (buffer)));
1341       break;
1342     case SIGSUBPKT_SIG_EXPIRE:
1343       if (length >= 4)
1344         {
1345           if (buf32_to_u32 (buffer))
1346             es_fprintf (listfp, "sig expires after %s",
1347                         strtimevalue (buf32_to_u32 (buffer)));
1348           else
1349             es_fprintf (listfp, "sig does not expire");
1350         }
1351       break;
1352     case SIGSUBPKT_EXPORTABLE:
1353       if (length)
1354         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1355       break;
1356     case SIGSUBPKT_TRUST:
1357       if (length != 2)
1358         p = "[invalid trust subpacket]";
1359       else
1360         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1361                     buffer[1]);
1362       break;
1363     case SIGSUBPKT_REGEXP:
1364       if (!length)
1365         p = "[invalid regexp subpacket]";
1366       else
1367         {
1368           es_fprintf (listfp, "regular expression: \"");
1369           es_write_sanitized (listfp, buffer, length, "\"", NULL);
1370           p = "\"";
1371         }
1372       break;
1373     case SIGSUBPKT_REVOCABLE:
1374       if (length)
1375         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1376       break;
1377     case SIGSUBPKT_KEY_EXPIRE:
1378       if (length >= 4)
1379         {
1380           if (buf32_to_u32 (buffer))
1381             es_fprintf (listfp, "key expires after %s",
1382                         strtimevalue (buf32_to_u32 (buffer)));
1383           else
1384             es_fprintf (listfp, "key does not expire");
1385         }
1386       break;
1387     case SIGSUBPKT_PREF_SYM:
1388       es_fputs ("pref-sym-algos:", listfp);
1389       for (i = 0; i < length; i++)
1390         es_fprintf (listfp, " %d", buffer[i]);
1391       break;
1392     case SIGSUBPKT_REV_KEY:
1393       es_fputs ("revocation key: ", listfp);
1394       if (length < 22)
1395         p = "[too short]";
1396       else
1397         {
1398           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1399           for (i = 2; i < length; i++)
1400             es_fprintf (listfp, "%02X", buffer[i]);
1401         }
1402       break;
1403     case SIGSUBPKT_ISSUER:
1404       if (length >= 8)
1405         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1406                     (ulong) buf32_to_u32 (buffer),
1407                     (ulong) buf32_to_u32 (buffer + 4));
1408       break;
1409     case SIGSUBPKT_ISSUER_FPR:
1410       if (length >= 21)
1411         {
1412           char *tmp;
1413           es_fprintf (listfp, "issuer fpr v%d ", buffer[0]);
1414           tmp = bin2hex (buffer+1, length-1, NULL);
1415           if (tmp)
1416             {
1417               es_fputs (tmp, listfp);
1418               xfree (tmp);
1419             }
1420         }
1421       break;
1422     case SIGSUBPKT_NOTATION:
1423       {
1424         es_fputs ("notation: ", listfp);
1425         if (length < 8)
1426           p = "[too short]";
1427         else
1428           {
1429             const byte *s = buffer;
1430             size_t n1, n2;
1431
1432             n1 = (s[4] << 8) | s[5];
1433             n2 = (s[6] << 8) | s[7];
1434             s += 8;
1435             if (8 + n1 + n2 != length)
1436               p = "[error]";
1437             else
1438               {
1439                 es_write_sanitized (listfp, s, n1, ")", NULL);
1440                 es_putc ('=', listfp);
1441
1442                 if (*buffer & 0x80)
1443                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1444                 else
1445                   p = "[not human readable]";
1446               }
1447           }
1448       }
1449       break;
1450     case SIGSUBPKT_PREF_HASH:
1451       es_fputs ("pref-hash-algos:", listfp);
1452       for (i = 0; i < length; i++)
1453         es_fprintf (listfp, " %d", buffer[i]);
1454       break;
1455     case SIGSUBPKT_PREF_COMPR:
1456       es_fputs ("pref-zip-algos:", listfp);
1457       for (i = 0; i < length; i++)
1458         es_fprintf (listfp, " %d", buffer[i]);
1459       break;
1460     case SIGSUBPKT_KS_FLAGS:
1461       es_fputs ("keyserver preferences:", listfp);
1462       for (i = 0; i < length; i++)
1463         es_fprintf (listfp, " %02X", buffer[i]);
1464       break;
1465     case SIGSUBPKT_PREF_KS:
1466       es_fputs ("preferred keyserver: ", listfp);
1467       es_write_sanitized (listfp, buffer, length, ")", NULL);
1468       break;
1469     case SIGSUBPKT_PRIMARY_UID:
1470       p = "primary user ID";
1471       break;
1472     case SIGSUBPKT_POLICY:
1473       es_fputs ("policy: ", listfp);
1474       es_write_sanitized (listfp, buffer, length, ")", NULL);
1475       break;
1476     case SIGSUBPKT_KEY_FLAGS:
1477       es_fputs ("key flags:", listfp);
1478       for (i = 0; i < length; i++)
1479         es_fprintf (listfp, " %02X", buffer[i]);
1480       break;
1481     case SIGSUBPKT_SIGNERS_UID:
1482       p = "signer's user ID";
1483       break;
1484     case SIGSUBPKT_REVOC_REASON:
1485       if (length)
1486         {
1487           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1488           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1489           p = ")";
1490         }
1491       break;
1492     case SIGSUBPKT_ARR:
1493       es_fputs ("Big Brother's key (ignored): ", listfp);
1494       if (length < 22)
1495         p = "[too short]";
1496       else
1497         {
1498           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1499           if (length > 2)
1500             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1501         }
1502       break;
1503     case SIGSUBPKT_FEATURES:
1504       es_fputs ("features:", listfp);
1505       for (i = 0; i < length; i++)
1506         es_fprintf (listfp, " %02x", buffer[i]);
1507       break;
1508     case SIGSUBPKT_SIGNATURE:
1509       es_fputs ("signature: ", listfp);
1510       if (length < 17)
1511         p = "[too short]";
1512       else
1513         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1514                     buffer[0],
1515                     buffer[0] == 3 ? buffer[2] : buffer[1],
1516                     buffer[0] == 3 ? buffer[15] : buffer[2],
1517                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1518       break;
1519     default:
1520       if (type >= 100 && type <= 110)
1521         p = "experimental / private subpacket";
1522       else
1523         p = "?";
1524       break;
1525     }
1526
1527   es_fprintf (listfp, "%s)\n", p ? p : "");
1528 }
1529
1530
1531 /*
1532  * Returns: >= 0 use this offset into buffer
1533  *          -1 explicitly reject returning this type
1534  *          -2 subpacket too short
1535  */
1536 int
1537 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1538 {
1539   switch (type)
1540     {
1541     case SIGSUBPKT_REV_KEY:
1542       if (n < 22)
1543         break;
1544       return 0;
1545     case SIGSUBPKT_SIG_CREATED:
1546     case SIGSUBPKT_SIG_EXPIRE:
1547     case SIGSUBPKT_KEY_EXPIRE:
1548       if (n < 4)
1549         break;
1550       return 0;
1551     case SIGSUBPKT_KEY_FLAGS:
1552     case SIGSUBPKT_KS_FLAGS:
1553     case SIGSUBPKT_PREF_SYM:
1554     case SIGSUBPKT_PREF_HASH:
1555     case SIGSUBPKT_PREF_COMPR:
1556     case SIGSUBPKT_POLICY:
1557     case SIGSUBPKT_PREF_KS:
1558     case SIGSUBPKT_FEATURES:
1559     case SIGSUBPKT_REGEXP:
1560       return 0;
1561     case SIGSUBPKT_SIGNATURE:
1562     case SIGSUBPKT_EXPORTABLE:
1563     case SIGSUBPKT_REVOCABLE:
1564     case SIGSUBPKT_REVOC_REASON:
1565       if (!n)
1566         break;
1567       return 0;
1568     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1569       if (n < 8)
1570         break;
1571       return 0;
1572     case SIGSUBPKT_ISSUER_FPR:  /* issuer key ID */
1573       if (n < 21)
1574         break;
1575       return 0;
1576     case SIGSUBPKT_NOTATION:
1577       /* minimum length needed, and the subpacket must be well-formed
1578          where the name length and value length all fit inside the
1579          packet. */
1580       if (n < 8
1581           || 8 + ((buffer[4] << 8) | buffer[5]) +
1582           ((buffer[6] << 8) | buffer[7]) != n)
1583         break;
1584       return 0;
1585     case SIGSUBPKT_PRIMARY_UID:
1586       if (n != 1)
1587         break;
1588       return 0;
1589     case SIGSUBPKT_TRUST:
1590       if (n != 2)
1591         break;
1592       return 0;
1593     default:
1594       return 0;
1595     }
1596   return -2;
1597 }
1598
1599
1600 /* Return true if we understand the critical notation.  */
1601 static int
1602 can_handle_critical_notation (const byte * name, size_t len)
1603 {
1604   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1605     return 1;
1606   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1607     return 1;
1608
1609   return 0;
1610 }
1611
1612
1613 static int
1614 can_handle_critical (const byte * buffer, size_t n, int type)
1615 {
1616   switch (type)
1617     {
1618     case SIGSUBPKT_NOTATION:
1619       if (n >= 8)
1620         {
1621           size_t notation_len = ((buffer[4] << 8) | buffer[5]);
1622           if (n - 8 >= notation_len)
1623             return can_handle_critical_notation (buffer + 8, notation_len);
1624         }
1625       return 0;
1626     case SIGSUBPKT_SIGNATURE:
1627     case SIGSUBPKT_SIG_CREATED:
1628     case SIGSUBPKT_SIG_EXPIRE:
1629     case SIGSUBPKT_KEY_EXPIRE:
1630     case SIGSUBPKT_EXPORTABLE:
1631     case SIGSUBPKT_REVOCABLE:
1632     case SIGSUBPKT_REV_KEY:
1633     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1634     case SIGSUBPKT_ISSUER_FPR:  /* issuer fingerprint */
1635     case SIGSUBPKT_PREF_SYM:
1636     case SIGSUBPKT_PREF_HASH:
1637     case SIGSUBPKT_PREF_COMPR:
1638     case SIGSUBPKT_KEY_FLAGS:
1639     case SIGSUBPKT_PRIMARY_UID:
1640     case SIGSUBPKT_FEATURES:
1641     case SIGSUBPKT_TRUST:
1642     case SIGSUBPKT_REGEXP:
1643       /* Is it enough to show the policy or keyserver? */
1644     case SIGSUBPKT_POLICY:
1645     case SIGSUBPKT_PREF_KS:
1646     case SIGSUBPKT_REVOC_REASON: /* At least we know about it.  */
1647       return 1;
1648
1649     default:
1650       return 0;
1651     }
1652 }
1653
1654
1655 const byte *
1656 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1657                  size_t * ret_n, int *start, int *critical)
1658 {
1659   const byte *buffer;
1660   int buflen;
1661   int type;
1662   int critical_dummy;
1663   int offset;
1664   size_t n;
1665   int seq = 0;
1666   int reqseq = start ? *start : 0;
1667
1668   if (!critical)
1669     critical = &critical_dummy;
1670
1671   if (!pktbuf || reqseq == -1)
1672     {
1673       static char dummy[] = "x";
1674       /* Return a value different from NULL to indicate that
1675        * there is no critical bit we do not understand.  */
1676       return reqtype == SIGSUBPKT_TEST_CRITICAL ? dummy : NULL;
1677     }
1678   buffer = pktbuf->data;
1679   buflen = pktbuf->len;
1680   while (buflen)
1681     {
1682       n = *buffer++;
1683       buflen--;
1684       if (n == 255) /* 4 byte length header.  */
1685         {
1686           if (buflen < 4)
1687             goto too_short;
1688           n = buf32_to_size_t (buffer);
1689           buffer += 4;
1690           buflen -= 4;
1691         }
1692       else if (n >= 192) /* 4 byte special encoded length header.  */
1693         {
1694           if (buflen < 2)
1695             goto too_short;
1696           n = ((n - 192) << 8) + *buffer + 192;
1697           buffer++;
1698           buflen--;
1699         }
1700       if (buflen < n)
1701         goto too_short;
1702       type = *buffer;
1703       if (type & 0x80)
1704         {
1705           type &= 0x7f;
1706           *critical = 1;
1707         }
1708       else
1709         *critical = 0;
1710       if (!(++seq > reqseq))
1711         ;
1712       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1713         {
1714           if (*critical)
1715             {
1716               if (n - 1 > buflen + 1)
1717                 goto too_short;
1718               if (!can_handle_critical (buffer + 1, n - 1, type))
1719                 {
1720                   if (opt.verbose)
1721                     log_info (_("subpacket of type %d has "
1722                                 "critical bit set\n"), type);
1723                   if (start)
1724                     *start = seq;
1725                   return NULL;  /* This is an error.  */
1726                 }
1727             }
1728         }
1729       else if (reqtype < 0) /* List packets.  */
1730         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1731                          type, *critical, buffer, buflen, n);
1732       else if (type == reqtype) /* Found.  */
1733         {
1734           buffer++;
1735           n--;
1736           if (n > buflen)
1737             goto too_short;
1738           if (ret_n)
1739             *ret_n = n;
1740           offset = parse_one_sig_subpkt (buffer, n, type);
1741           switch (offset)
1742             {
1743             case -2:
1744               log_error ("subpacket of type %d too short\n", type);
1745               return NULL;
1746             case -1:
1747               return NULL;
1748             default:
1749               break;
1750             }
1751           if (start)
1752             *start = seq;
1753           return buffer + offset;
1754         }
1755       buffer += n;
1756       buflen -= n;
1757     }
1758   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1759     /* Returning NULL means we found a subpacket with the critical bit
1760        set that we don't grok.  We've iterated over all the subpackets
1761        and haven't found such a packet so we need to return a non-NULL
1762        value.  */
1763     return buffer;
1764
1765   /* Critical bit we don't understand. */
1766   if (start)
1767     *start = -1;
1768   return NULL;  /* End of packets; not found.  */
1769
1770  too_short:
1771   if (opt.verbose)
1772     log_info ("buffer shorter than subpacket\n");
1773   if (start)
1774     *start = -1;
1775   return NULL;
1776 }
1777
1778
1779 const byte *
1780 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1781                   size_t * ret_n)
1782 {
1783   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1784 }
1785
1786
1787 const byte *
1788 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype)
1789 {
1790   const byte *p;
1791
1792   p = parse_sig_subpkt (sig->hashed, reqtype, NULL);
1793   if (!p)
1794     p = parse_sig_subpkt (sig->unhashed, reqtype, NULL);
1795   return p;
1796 }
1797
1798
1799 /* Find all revocation keys.  Look in hashed area only.  */
1800 void
1801 parse_revkeys (PKT_signature * sig)
1802 {
1803   const byte *revkey;
1804   int seq = 0;
1805   size_t len;
1806
1807   if (sig->sig_class != 0x1F)
1808     return;
1809
1810   while ((revkey = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REV_KEY,
1811                                     &len, &seq, NULL)))
1812     {
1813       if (/* The only valid length is 22 bytes.  See RFC 4880
1814              5.2.3.15.  */
1815           len == 22
1816           /* 0x80 bit must be set on the class.  */
1817           && (revkey[0] & 0x80))
1818         {
1819           sig->revkey = xrealloc (sig->revkey,
1820                                   sizeof (struct revocation_key) *
1821                                   (sig->numrevkeys + 1));
1822
1823           /* Copy the individual fields.  */
1824           sig->revkey[sig->numrevkeys].class = revkey[0];
1825           sig->revkey[sig->numrevkeys].algid = revkey[1];
1826           memcpy (sig->revkey[sig->numrevkeys].fpr, &revkey[2], 20);
1827
1828           sig->numrevkeys++;
1829         }
1830     }
1831 }
1832
1833
1834 int
1835 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1836                  PKT_signature * sig)
1837 {
1838   int md5_len = 0;
1839   unsigned n;
1840   int is_v4 = 0;
1841   int rc = 0;
1842   int i, ndata;
1843
1844   if (pktlen < 16)
1845     {
1846       log_error ("packet(%d) too short\n", pkttype);
1847       if (list_mode)
1848         es_fputs (":signature packet: [too short]\n", listfp);
1849       goto leave;
1850     }
1851   sig->version = iobuf_get_noeof (inp);
1852   pktlen--;
1853   if (sig->version == 4)
1854     is_v4 = 1;
1855   else if (sig->version != 2 && sig->version != 3)
1856     {
1857       log_error ("packet(%d) with unknown version %d\n",
1858                  pkttype, sig->version);
1859       if (list_mode)
1860         es_fputs (":signature packet: [unknown version]\n", listfp);
1861       rc = gpg_error (GPG_ERR_INV_PACKET);
1862       goto leave;
1863     }
1864
1865   if (!is_v4)
1866     {
1867       if (pktlen == 0)
1868         goto underflow;
1869       md5_len = iobuf_get_noeof (inp);
1870       pktlen--;
1871     }
1872   if (pktlen == 0)
1873     goto underflow;
1874   sig->sig_class = iobuf_get_noeof (inp);
1875   pktlen--;
1876   if (!is_v4)
1877     {
1878       if (pktlen < 12)
1879         goto underflow;
1880       sig->timestamp = read_32 (inp);
1881       pktlen -= 4;
1882       sig->keyid[0] = read_32 (inp);
1883       pktlen -= 4;
1884       sig->keyid[1] = read_32 (inp);
1885       pktlen -= 4;
1886     }
1887   if (pktlen < 2)
1888     goto underflow;
1889   sig->pubkey_algo = iobuf_get_noeof (inp);
1890   pktlen--;
1891   sig->digest_algo = iobuf_get_noeof (inp);
1892   pktlen--;
1893   sig->flags.exportable = 1;
1894   sig->flags.revocable = 1;
1895   if (is_v4) /* Read subpackets.  */
1896     {
1897       if (pktlen < 2)
1898         goto underflow;
1899       n = read_16 (inp);
1900       pktlen -= 2;  /* Length of hashed data. */
1901       if (pktlen < n)
1902         goto underflow;
1903       if (n > 10000)
1904         {
1905           log_error ("signature packet: hashed data too long\n");
1906           if (list_mode)
1907             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1908           rc = GPG_ERR_INV_PACKET;
1909           goto leave;
1910         }
1911       if (n)
1912         {
1913           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1914           sig->hashed->size = n;
1915           sig->hashed->len = n;
1916           if (iobuf_read (inp, sig->hashed->data, n) != n)
1917             {
1918               log_error ("premature eof while reading "
1919                          "hashed signature data\n");
1920               if (list_mode)
1921                 es_fputs (":signature packet: [premature eof]\n", listfp);
1922               rc = -1;
1923               goto leave;
1924             }
1925           pktlen -= n;
1926         }
1927       if (pktlen < 2)
1928         goto underflow;
1929       n = read_16 (inp);
1930       pktlen -= 2;  /* Length of unhashed data.  */
1931       if (pktlen < n)
1932         goto underflow;
1933       if (n > 10000)
1934         {
1935           log_error ("signature packet: unhashed data too long\n");
1936           if (list_mode)
1937             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1938           rc = GPG_ERR_INV_PACKET;
1939           goto leave;
1940         }
1941       if (n)
1942         {
1943           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1944           sig->unhashed->size = n;
1945           sig->unhashed->len = n;
1946           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1947             {
1948               log_error ("premature eof while reading "
1949                          "unhashed signature data\n");
1950               if (list_mode)
1951                 es_fputs (":signature packet: [premature eof]\n", listfp);
1952               rc = -1;
1953               goto leave;
1954             }
1955           pktlen -= n;
1956         }
1957     }
1958
1959   if (pktlen < 2)
1960     goto underflow;
1961   sig->digest_start[0] = iobuf_get_noeof (inp);
1962   pktlen--;
1963   sig->digest_start[1] = iobuf_get_noeof (inp);
1964   pktlen--;
1965
1966   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1967     {
1968       const byte *p;
1969       size_t len;
1970
1971       /* Set sig->flags.unknown_critical if there is a critical bit
1972        * set for packets which we do not understand.  */
1973       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1974           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1975         sig->flags.unknown_critical = 1;
1976
1977       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1978       if (p)
1979         sig->timestamp = buf32_to_u32 (p);
1980       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1981                && opt.verbose)
1982         log_info ("signature packet without timestamp\n");
1983
1984       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER);
1985       if (p)
1986         {
1987           sig->keyid[0] = buf32_to_u32 (p);
1988           sig->keyid[1] = buf32_to_u32 (p + 4);
1989         }
1990       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1991                && opt.verbose)
1992         log_info ("signature packet without keyid\n");
1993
1994       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1995       if (p && buf32_to_u32 (p))
1996         sig->expiredate = sig->timestamp + buf32_to_u32 (p);
1997       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1998         sig->flags.expired = 1;
1999
2000       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
2001       if (p)
2002         sig->flags.policy_url = 1;
2003
2004       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
2005       if (p)
2006         sig->flags.pref_ks = 1;
2007
2008       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIGNERS_UID, &len);
2009       if (p && len)
2010         {
2011           sig->signers_uid = try_make_printable_string (p, len, 0);
2012           if (!sig->signers_uid)
2013             {
2014               rc = gpg_error_from_syserror ();
2015               goto leave;
2016             }
2017         }
2018
2019       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
2020       if (p)
2021         sig->flags.notation = 1;
2022
2023       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
2024       if (p && *p == 0)
2025         sig->flags.revocable = 0;
2026
2027       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
2028       if (p && len == 2)
2029         {
2030           sig->trust_depth = p[0];
2031           sig->trust_value = p[1];
2032
2033           /* Only look for a regexp if there is also a trust
2034              subpacket. */
2035           sig->trust_regexp =
2036             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
2037
2038           /* If the regular expression is of 0 length, there is no
2039              regular expression. */
2040           if (len == 0)
2041             sig->trust_regexp = NULL;
2042         }
2043
2044       /* We accept the exportable subpacket from either the hashed or
2045          unhashed areas as older versions of gpg put it in the
2046          unhashed area.  In theory, anyway, we should never see this
2047          packet off of a local keyring. */
2048
2049       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE);
2050       if (p && *p == 0)
2051         sig->flags.exportable = 0;
2052
2053       /* Find all revocation keys.  */
2054       if (sig->sig_class == 0x1F)
2055         parse_revkeys (sig);
2056     }
2057
2058   if (list_mode)
2059     {
2060       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
2061                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
2062                   "\tdigest algo %d, begin of digest %02x %02x\n",
2063                   sig->pubkey_algo,
2064                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
2065                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
2066                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
2067       if (is_v4)
2068         {
2069           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
2070           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
2071         }
2072     }
2073
2074   ndata = pubkey_get_nsig (sig->pubkey_algo);
2075   if (!ndata)
2076     {
2077       if (list_mode)
2078         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
2079       unknown_pubkey_warning (sig->pubkey_algo);
2080
2081       /* We store the plain material in data[0], so that we are able
2082        * to write it back with build_packet().  */
2083       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
2084         {
2085           /* We include a limit to avoid too trivial DoS attacks by
2086              having gpg allocate too much memory.  */
2087           log_error ("signature packet: too much data\n");
2088           rc = GPG_ERR_INV_PACKET;
2089         }
2090       else
2091         {
2092           sig->data[0] =
2093             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
2094           pktlen = 0;
2095         }
2096     }
2097   else
2098     {
2099       for (i = 0; i < ndata; i++)
2100         {
2101           n = pktlen;
2102           sig->data[i] = mpi_read (inp, &n, 0);
2103           pktlen -= n;
2104           if (list_mode)
2105             {
2106               es_fprintf (listfp, "\tdata: ");
2107               mpi_print (listfp, sig->data[i], mpi_print_mode);
2108               es_putc ('\n', listfp);
2109             }
2110           if (!sig->data[i])
2111             rc = GPG_ERR_INV_PACKET;
2112         }
2113     }
2114
2115  leave:
2116   iobuf_skip_rest (inp, pktlen, 0);
2117   return rc;
2118
2119  underflow:
2120   log_error ("packet(%d) too short\n", pkttype);
2121   if (list_mode)
2122     es_fputs (":signature packet: [too short]\n", listfp);
2123
2124   iobuf_skip_rest (inp, pktlen, 0);
2125
2126   return GPG_ERR_INV_PACKET;
2127 }
2128
2129
2130 static int
2131 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
2132                    PKT_onepass_sig * ops)
2133 {
2134   int version;
2135   int rc = 0;
2136
2137   if (pktlen < 13)
2138     {
2139       log_error ("packet(%d) too short\n", pkttype);
2140       if (list_mode)
2141         es_fputs (":onepass_sig packet: [too short]\n", listfp);
2142       rc = gpg_error (GPG_ERR_INV_PACKET);
2143       goto leave;
2144     }
2145   version = iobuf_get_noeof (inp);
2146   pktlen--;
2147   if (version != 3)
2148     {
2149       log_error ("onepass_sig with unknown version %d\n", version);
2150       if (list_mode)
2151         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
2152       rc = gpg_error (GPG_ERR_INV_PACKET);
2153       goto leave;
2154     }
2155   ops->sig_class = iobuf_get_noeof (inp);
2156   pktlen--;
2157   ops->digest_algo = iobuf_get_noeof (inp);
2158   pktlen--;
2159   ops->pubkey_algo = iobuf_get_noeof (inp);
2160   pktlen--;
2161   ops->keyid[0] = read_32 (inp);
2162   pktlen -= 4;
2163   ops->keyid[1] = read_32 (inp);
2164   pktlen -= 4;
2165   ops->last = iobuf_get_noeof (inp);
2166   pktlen--;
2167   if (list_mode)
2168     es_fprintf (listfp,
2169                 ":onepass_sig packet: keyid %08lX%08lX\n"
2170                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
2171                 "last=%d\n",
2172                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
2173                 version, ops->sig_class,
2174                 ops->digest_algo, ops->pubkey_algo, ops->last);
2175
2176
2177  leave:
2178   iobuf_skip_rest (inp, pktlen, 0);
2179   return rc;
2180 }
2181
2182
2183 static int
2184 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
2185            byte * hdr, int hdrlen, PACKET * pkt)
2186 {
2187   gpg_error_t err = 0;
2188   int i, version, algorithm;
2189   unsigned long timestamp, expiredate, max_expiredate;
2190   int npkey, nskey;
2191   u32 keyid[2];
2192   PKT_public_key *pk;
2193
2194   (void) hdr;
2195
2196   pk = pkt->pkt.public_key; /* PK has been cleared. */
2197
2198   version = iobuf_get_noeof (inp);
2199   pktlen--;
2200   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
2201     {
2202       /* Early versions of G10 used the old PGP comments packets;
2203        * luckily all those comments are started by a hash.  */
2204       if (list_mode)
2205         {
2206           es_fprintf (listfp, ":rfc1991 comment packet: \"");
2207           for (; pktlen; pktlen--)
2208             {
2209               int c;
2210               c = iobuf_get (inp);
2211               if (c == -1)
2212                 break; /* Ooops: shorter than indicated.  */
2213               if (c >= ' ' && c <= 'z')
2214                 es_putc (c, listfp);
2215               else
2216                 es_fprintf (listfp, "\\x%02x", c);
2217             }
2218           es_fprintf (listfp, "\"\n");
2219         }
2220       iobuf_skip_rest (inp, pktlen, 0);
2221       return 0;
2222     }
2223   else if (version == 4)
2224     {
2225       /* The only supported version.  Use an older gpg
2226          version (i.e. gpg 1.4) to parse v3 packets.  */
2227     }
2228   else if (version == 2 || version == 3)
2229     {
2230       if (opt.verbose > 1)
2231         log_info ("packet(%d) with obsolete version %d\n", pkttype, version);
2232       if (list_mode)
2233         es_fprintf (listfp, ":key packet: [obsolete version %d]\n", version);
2234       pk->version = version;
2235       err = gpg_error (GPG_ERR_LEGACY_KEY);
2236       goto leave;
2237     }
2238   else
2239     {
2240       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
2241       if (list_mode)
2242         es_fputs (":key packet: [unknown version]\n", listfp);
2243       err = gpg_error (GPG_ERR_INV_PACKET);
2244       goto leave;
2245     }
2246
2247   if (pktlen < 11)
2248     {
2249       log_error ("packet(%d) too short\n", pkttype);
2250       if (list_mode)
2251         es_fputs (":key packet: [too short]\n", listfp);
2252       err = gpg_error (GPG_ERR_INV_PACKET);
2253       goto leave;
2254     }
2255   else if (pktlen > MAX_KEY_PACKET_LENGTH)
2256     {
2257       log_error ("packet(%d) too large\n", pkttype);
2258       if (list_mode)
2259         es_fputs (":key packet: [too larget]\n", listfp);
2260       err = gpg_error (GPG_ERR_INV_PACKET);
2261       goto leave;
2262     }
2263
2264   timestamp = read_32 (inp);
2265   pktlen -= 4;
2266   expiredate = 0;               /* have to get it from the selfsignature */
2267   max_expiredate = 0;
2268   algorithm = iobuf_get_noeof (inp);
2269   pktlen--;
2270   if (list_mode)
2271     es_fprintf (listfp, ":%s key packet:\n"
2272                 "\tversion %d, algo %d, created %lu, expires %lu\n",
2273                 pkttype == PKT_PUBLIC_KEY ? "public" :
2274                 pkttype == PKT_SECRET_KEY ? "secret" :
2275                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
2276                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
2277                 version, algorithm, timestamp, expiredate);
2278
2279   pk->timestamp = timestamp;
2280   pk->expiredate = expiredate;
2281   pk->max_expiredate = max_expiredate;
2282   pk->hdrbytes = hdrlen;
2283   pk->version = version;
2284   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
2285   pk->pubkey_algo = algorithm;
2286
2287   nskey = pubkey_get_nskey (algorithm);
2288   npkey = pubkey_get_npkey (algorithm);
2289   if (!npkey)
2290     {
2291       if (list_mode)
2292         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2293       unknown_pubkey_warning (algorithm);
2294     }
2295
2296   if (!npkey)
2297     {
2298       /* Unknown algorithm - put data into an opaque MPI.  */
2299       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2300                                          read_rest (inp, pktlen), pktlen * 8);
2301       pktlen = 0;
2302       goto leave;
2303     }
2304   else
2305     {
2306       for (i = 0; i < npkey; i++)
2307         {
2308           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2309                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2310                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2311             {
2312               /* Read the OID (i==1) or the KDF params (i==2).  */
2313               size_t n;
2314               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2315               pktlen -= n;
2316             }
2317           else
2318             {
2319               unsigned int n = pktlen;
2320               pk->pkey[i] = mpi_read (inp, &n, 0);
2321               pktlen -= n;
2322               if (!pk->pkey[i])
2323                 err = gpg_error (GPG_ERR_INV_PACKET);
2324             }
2325           if (err)
2326             goto leave;
2327           if (list_mode)
2328             {
2329               es_fprintf (listfp, "\tpkey[%d]: ", i);
2330               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2331               if ((algorithm == PUBKEY_ALGO_ECDSA
2332                    || algorithm == PUBKEY_ALGO_EDDSA
2333                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2334                 {
2335                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2336                   const char *name = openpgp_oid_to_curve (curve, 0);
2337                   es_fprintf (listfp, " %s (%s)", name?name:"", curve);
2338                   xfree (curve);
2339                 }
2340               es_putc ('\n', listfp);
2341             }
2342         }
2343     }
2344   if (list_mode)
2345     keyid_from_pk (pk, keyid);
2346
2347   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2348     {
2349       struct seckey_info *ski;
2350       byte temp[16];
2351       size_t snlen = 0;
2352
2353       if (pktlen < 1)
2354         {
2355           err = gpg_error (GPG_ERR_INV_PACKET);
2356           goto leave;
2357         }
2358
2359       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2360       if (!pk->seckey_info)
2361         {
2362           err = gpg_error_from_syserror ();
2363           goto leave;
2364         }
2365
2366       ski->algo = iobuf_get_noeof (inp);
2367       pktlen--;
2368       if (ski->algo)
2369         {
2370           ski->is_protected = 1;
2371           ski->s2k.count = 0;
2372           if (ski->algo == 254 || ski->algo == 255)
2373             {
2374               if (pktlen < 3)
2375                 {
2376                   err = gpg_error (GPG_ERR_INV_PACKET);
2377                   goto leave;
2378                 }
2379               ski->sha1chk = (ski->algo == 254);
2380               ski->algo = iobuf_get_noeof (inp);
2381               pktlen--;
2382               /* Note that a ski->algo > 110 is illegal, but I'm not
2383                  erroring on it here as otherwise there would be no
2384                  way to delete such a key.  */
2385               ski->s2k.mode = iobuf_get_noeof (inp);
2386               pktlen--;
2387               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2388               pktlen--;
2389               /* Check for the special GNU extension.  */
2390               if (ski->s2k.mode == 101)
2391                 {
2392                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2393                     temp[i] = iobuf_get_noeof (inp);
2394                   if (i < 4 || memcmp (temp, "GNU", 3))
2395                     {
2396                       if (list_mode)
2397                         es_fprintf (listfp, "\tunknown S2K %d\n",
2398                                     ski->s2k.mode);
2399                       err = gpg_error (GPG_ERR_INV_PACKET);
2400                       goto leave;
2401                     }
2402                   /* Here we know that it is a GNU extension.  What
2403                    * follows is the GNU protection mode: All values
2404                    * have special meanings and they are mapped to MODE
2405                    * with a base of 1000.  */
2406                   ski->s2k.mode = 1000 + temp[3];
2407                 }
2408
2409               /* Read the salt.  */
2410               switch (ski->s2k.mode)
2411                 {
2412                 case 1:
2413                 case 3:
2414                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2415                     temp[i] = iobuf_get_noeof (inp);
2416                   if (i < 8)
2417                     {
2418                       err = gpg_error (GPG_ERR_INV_PACKET);
2419                       goto leave;
2420                     }
2421                   memcpy (ski->s2k.salt, temp, 8);
2422                   break;
2423                 }
2424
2425               /* Check the mode.  */
2426               switch (ski->s2k.mode)
2427                 {
2428                 case 0:
2429                   if (list_mode)
2430                     es_fprintf (listfp, "\tsimple S2K");
2431                   break;
2432                 case 1:
2433                   if (list_mode)
2434                     es_fprintf (listfp, "\tsalted S2K");
2435                   break;
2436                 case 3:
2437                   if (list_mode)
2438                     es_fprintf (listfp, "\titer+salt S2K");
2439                   break;
2440                 case 1001:
2441                   if (list_mode)
2442                     es_fprintf (listfp, "\tgnu-dummy S2K");
2443                   break;
2444                 case 1002:
2445                   if (list_mode)
2446                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2447                   break;
2448                 default:
2449                   if (list_mode)
2450                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2451                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2452                                 ski->s2k.mode);
2453                   err = gpg_error (GPG_ERR_INV_PACKET);
2454                   goto leave;
2455                 }
2456
2457               /* Print some info.  */
2458               if (list_mode)
2459                 {
2460                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2461                               ski->algo,
2462                               ski->sha1chk ? " SHA1 protection,"
2463                               : " simple checksum,", ski->s2k.hash_algo);
2464                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2465                     {
2466                       es_fprintf (listfp, ", salt: ");
2467                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2468                     }
2469                   es_putc ('\n', listfp);
2470                 }
2471
2472               /* Read remaining protection parameters.  */
2473               if (ski->s2k.mode == 3)
2474                 {
2475                   if (pktlen < 1)
2476                     {
2477                       err = gpg_error (GPG_ERR_INV_PACKET);
2478                       goto leave;
2479                     }
2480                   ski->s2k.count = iobuf_get (inp);
2481                   pktlen--;
2482                   if (list_mode)
2483                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2484                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2485                                 (ulong) ski->s2k.count);
2486                 }
2487               else if (ski->s2k.mode == 1002)
2488                 {
2489                   /* Read the serial number. */
2490                   if (pktlen < 1)
2491                     {
2492                       err = gpg_error (GPG_ERR_INV_PACKET);
2493                       goto leave;
2494                     }
2495                   snlen = iobuf_get (inp);
2496                   pktlen--;
2497                   if (pktlen < snlen || snlen == (size_t)(-1))
2498                     {
2499                       err = gpg_error (GPG_ERR_INV_PACKET);
2500                       goto leave;
2501                     }
2502                 }
2503             }
2504           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2505             {
2506               /* Note that a ski->algo > 110 is illegal, but I'm not
2507                  erroring on it here as otherwise there would be no
2508                  way to delete such a key.  */
2509               ski->s2k.mode = 0;
2510               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2511               if (list_mode)
2512                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2513                             ski->algo, ski->s2k.hash_algo);
2514             }
2515
2516           /* It is really ugly that we don't know the size
2517            * of the IV here in cases we are not aware of the algorithm.
2518            * so a
2519            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2520            * won't work.  The only solution I see is to hardwire it.
2521            * NOTE: if you change the ivlen above 16, don't forget to
2522            * enlarge temp.  */
2523           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2524           log_assert (ski->ivlen <= sizeof (temp));
2525
2526           if (ski->s2k.mode == 1001)
2527             ski->ivlen = 0;
2528           else if (ski->s2k.mode == 1002)
2529             ski->ivlen = snlen < 16 ? snlen : 16;
2530
2531           if (pktlen < ski->ivlen)
2532             {
2533               err = gpg_error (GPG_ERR_INV_PACKET);
2534               goto leave;
2535             }
2536           for (i = 0; i < ski->ivlen; i++, pktlen--)
2537             temp[i] = iobuf_get_noeof (inp);
2538           if (list_mode)
2539             {
2540               es_fprintf (listfp,
2541                           ski->s2k.mode == 1002 ? "\tserial-number: "
2542                           : "\tprotect IV: ");
2543               for (i = 0; i < ski->ivlen; i++)
2544                 es_fprintf (listfp, " %02x", temp[i]);
2545               es_putc ('\n', listfp);
2546             }
2547           memcpy (ski->iv, temp, ski->ivlen);
2548         }
2549
2550       /* It does not make sense to read it into secure memory.
2551        * If the user is so careless, not to protect his secret key,
2552        * we can assume, that he operates an open system :=(.
2553        * So we put the key into secure memory when we unprotect it. */
2554       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2555         {
2556           /* Better set some dummy stuff here.  */
2557           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2558                                                  xstrdup ("dummydata"),
2559                                                  10 * 8);
2560           pktlen = 0;
2561         }
2562       else if (ski->is_protected)
2563         {
2564           if (pktlen < 2) /* At least two bytes for the length.  */
2565             {
2566               err = gpg_error (GPG_ERR_INV_PACKET);
2567               goto leave;
2568             }
2569
2570           /* Ugly: The length is encrypted too, so we read all stuff
2571            * up to the end of the packet into the first SKEY
2572            * element.  */
2573           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2574                                                  read_rest (inp, pktlen),
2575                                                  pktlen * 8);
2576           /* Mark that MPI as protected - we need this information for
2577              importing a key.  The OPAQUE flag can't be used because
2578              we also store public EdDSA values in opaque MPIs.  */
2579           if (pk->pkey[npkey])
2580             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2581           pktlen = 0;
2582           if (list_mode)
2583             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2584         }
2585       else
2586         {
2587           /* Not encrypted.  */
2588           for (i = npkey; i < nskey; i++)
2589             {
2590               unsigned int n;
2591
2592               if (pktlen < 2) /* At least two bytes for the length.  */
2593                 {
2594                   err = gpg_error (GPG_ERR_INV_PACKET);
2595                   goto leave;
2596                 }
2597               n = pktlen;
2598               pk->pkey[i] = mpi_read (inp, &n, 0);
2599               pktlen -= n;
2600               if (list_mode)
2601                 {
2602                   es_fprintf (listfp, "\tskey[%d]: ", i);
2603                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2604                   es_putc ('\n', listfp);
2605                 }
2606
2607               if (!pk->pkey[i])
2608                 err = gpg_error (GPG_ERR_INV_PACKET);
2609             }
2610           if (err)
2611             goto leave;
2612
2613           if (pktlen < 2)
2614             {
2615               err = gpg_error (GPG_ERR_INV_PACKET);
2616               goto leave;
2617             }
2618           ski->csum = read_16 (inp);
2619           pktlen -= 2;
2620           if (list_mode)
2621             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2622         }
2623     }
2624
2625   /* Note that KEYID below has been initialized above in list_mode.  */
2626   if (list_mode)
2627     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2628                 (ulong) keyid[0], (ulong) keyid[1]);
2629
2630  leave:
2631   iobuf_skip_rest (inp, pktlen, 0);
2632   return err;
2633 }
2634
2635
2636 /* Attribute subpackets have the same format as v4 signature
2637    subpackets.  This is not part of OpenPGP, but is done in several
2638    versions of PGP nevertheless.  */
2639 int
2640 parse_attribute_subpkts (PKT_user_id * uid)
2641 {
2642   size_t n;
2643   int count = 0;
2644   struct user_attribute *attribs = NULL;
2645   const byte *buffer = uid->attrib_data;
2646   int buflen = uid->attrib_len;
2647   byte type;
2648
2649   xfree (uid->attribs);
2650
2651   while (buflen)
2652     {
2653       n = *buffer++;
2654       buflen--;
2655       if (n == 255)  /* 4 byte length header.  */
2656         {
2657           if (buflen < 4)
2658             goto too_short;
2659           n = buf32_to_size_t (buffer);
2660           buffer += 4;
2661           buflen -= 4;
2662         }
2663       else if (n >= 192)  /* 2 byte special encoded length header.  */
2664         {
2665           if (buflen < 2)
2666             goto too_short;
2667           n = ((n - 192) << 8) + *buffer + 192;
2668           buffer++;
2669           buflen--;
2670         }
2671       if (buflen < n)
2672         goto too_short;
2673
2674       if (!n)
2675         {
2676           /* Too short to encode the subpacket type.  */
2677           if (opt.verbose)
2678             log_info ("attribute subpacket too short\n");
2679           break;
2680         }
2681
2682       attribs = xrealloc (attribs,
2683                           (count + 1) * sizeof (struct user_attribute));
2684       memset (&attribs[count], 0, sizeof (struct user_attribute));
2685
2686       type = *buffer;
2687       buffer++;
2688       buflen--;
2689       n--;
2690
2691       attribs[count].type = type;
2692       attribs[count].data = buffer;
2693       attribs[count].len = n;
2694       buffer += n;
2695       buflen -= n;
2696       count++;
2697     }
2698
2699   uid->attribs = attribs;
2700   uid->numattribs = count;
2701   return count;
2702
2703  too_short:
2704   if (opt.verbose)
2705     log_info ("buffer shorter than attribute subpacket\n");
2706   uid->attribs = attribs;
2707   uid->numattribs = count;
2708   return count;
2709 }
2710
2711
2712 static int
2713 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2714 {
2715   byte *p;
2716
2717   /* Cap the size of a user ID at 2k: a value absurdly large enough
2718      that there is no sane user ID string (which is printable text
2719      as of RFC2440bis) that won't fit in it, but yet small enough to
2720      avoid allocation problems.  A large pktlen may not be
2721      allocatable, and a very large pktlen could actually cause our
2722      allocation to wrap around in xmalloc to a small number. */
2723
2724   if (pktlen > MAX_UID_PACKET_LENGTH)
2725     {
2726       log_error ("packet(%d) too large\n", pkttype);
2727       if (list_mode)
2728         es_fprintf (listfp, ":user ID packet: [too large]\n");
2729       iobuf_skip_rest (inp, pktlen, 0);
2730       return GPG_ERR_INV_PACKET;
2731     }
2732
2733   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2734   packet->pkt.user_id->len = pktlen;
2735   packet->pkt.user_id->ref = 1;
2736
2737   p = packet->pkt.user_id->name;
2738   for (; pktlen; pktlen--, p++)
2739     *p = iobuf_get_noeof (inp);
2740   *p = 0;
2741
2742   if (list_mode)
2743     {
2744       int n = packet->pkt.user_id->len;
2745       es_fprintf (listfp, ":user ID packet: \"");
2746       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2747       for (p = packet->pkt.user_id->name; n; p++, n--)
2748         {
2749           if (*p >= ' ' && *p <= 'z')
2750             es_putc (*p, listfp);
2751           else
2752             es_fprintf (listfp, "\\x%02x", *p);
2753         }
2754       es_fprintf (listfp, "\"\n");
2755     }
2756   return 0;
2757 }
2758
2759
2760 void
2761 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2762 {
2763   log_assert (max_namelen > 70);
2764   if (uid->numattribs <= 0)
2765     sprintf (uid->name, "[bad attribute packet of size %lu]",
2766              uid->attrib_len);
2767   else if (uid->numattribs > 1)
2768     sprintf (uid->name, "[%d attributes of size %lu]",
2769              uid->numattribs, uid->attrib_len);
2770   else
2771     {
2772       /* Only one attribute, so list it as the "user id" */
2773
2774       if (uid->attribs->type == ATTRIB_IMAGE)
2775         {
2776           u32 len;
2777           byte type;
2778
2779           if (parse_image_header (uid->attribs, &type, &len))
2780             sprintf (uid->name, "[%.20s image of size %lu]",
2781                      image_type_to_string (type, 1), (ulong) len);
2782           else
2783             sprintf (uid->name, "[invalid image]");
2784         }
2785       else
2786         sprintf (uid->name, "[unknown attribute of size %lu]",
2787                  (ulong) uid->attribs->len);
2788     }
2789
2790   uid->len = strlen (uid->name);
2791 }
2792
2793
2794 static int
2795 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2796                  PACKET * packet)
2797 {
2798   byte *p;
2799
2800   (void) pkttype;
2801
2802   /* We better cap the size of an attribute packet to make DoS not too
2803      easy.  16MB should be more then enough for one attribute packet
2804      (ie. a photo).  */
2805   if (pktlen > MAX_ATTR_PACKET_LENGTH)
2806     {
2807       log_error ("packet(%d) too large\n", pkttype);
2808       if (list_mode)
2809         es_fprintf (listfp, ":attribute packet: [too large]\n");
2810       iobuf_skip_rest (inp, pktlen, 0);
2811       return GPG_ERR_INV_PACKET;
2812     }
2813
2814 #define EXTRA_UID_NAME_SPACE 71
2815   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2816                                        + EXTRA_UID_NAME_SPACE);
2817   packet->pkt.user_id->ref = 1;
2818   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2819   packet->pkt.user_id->attrib_len = pktlen;
2820
2821   p = packet->pkt.user_id->attrib_data;
2822   for (; pktlen; pktlen--, p++)
2823     *p = iobuf_get_noeof (inp);
2824
2825   /* Now parse out the individual attribute subpackets.  This is
2826      somewhat pointless since there is only one currently defined
2827      attribute type (jpeg), but it is correct by the spec. */
2828   parse_attribute_subpkts (packet->pkt.user_id);
2829
2830   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2831
2832   if (list_mode)
2833     {
2834       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2835     }
2836   return 0;
2837 }
2838
2839
2840 static int
2841 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2842 {
2843   byte *p;
2844
2845   /* Cap comment packet at a reasonable value to avoid an integer
2846      overflow in the malloc below.  Comment packets are actually not
2847      anymore define my OpenPGP and we even stopped to use our
2848      private comment packet.  */
2849   if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2850     {
2851       log_error ("packet(%d) too large\n", pkttype);
2852       if (list_mode)
2853         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2854                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2855       iobuf_skip_rest (inp, pktlen, 0);
2856       return GPG_ERR_INV_PACKET;
2857     }
2858   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2859   packet->pkt.comment->len = pktlen;
2860   p = packet->pkt.comment->data;
2861   for (; pktlen; pktlen--, p++)
2862     *p = iobuf_get_noeof (inp);
2863
2864   if (list_mode)
2865     {
2866       int n = packet->pkt.comment->len;
2867       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2868                   "OpenPGP draft " : "");
2869       for (p = packet->pkt.comment->data; n; p++, n--)
2870         {
2871           if (*p >= ' ' && *p <= 'z')
2872             es_putc (*p, listfp);
2873           else
2874             es_fprintf (listfp, "\\x%02x", *p);
2875         }
2876       es_fprintf (listfp, "\"\n");
2877     }
2878   return 0;
2879 }
2880
2881
2882 /* Parse a ring trust packet RFC4880 (5.10).
2883  *
2884  * This parser is special in that the packet is not stored as a packet
2885  * but its content is merged into the previous packet.  */
2886 static gpg_error_t
2887 parse_ring_trust (parse_packet_ctx_t ctx, unsigned long pktlen)
2888 {
2889   gpg_error_t err;
2890   iobuf_t inp = ctx->inp;
2891   PKT_ring_trust rt = {0};
2892   int c;
2893   int not_gpg = 0;
2894
2895   if (!pktlen)
2896     {
2897       if (list_mode)
2898         es_fprintf (listfp, ":trust packet: empty\n");
2899       err = 0;
2900       goto leave;
2901     }
2902
2903   c = iobuf_get_noeof (inp);
2904   pktlen--;
2905   rt.trustval = c;
2906   if (pktlen)
2907     {
2908       if (!c)
2909         {
2910           c = iobuf_get_noeof (inp);
2911           /* We require that bit 7 of the sigcache is 0 (easier
2912            * eof handling).  */
2913           if (!(c & 0x80))
2914             rt.sigcache = c;
2915         }
2916       else
2917         iobuf_get_noeof (inp);  /* Dummy read.  */
2918       pktlen--;
2919     }
2920
2921   /* Next is the optional subtype.  */
2922   if (pktlen > 3)
2923     {
2924       char tmp[4];
2925       tmp[0] = iobuf_get_noeof (inp);
2926       tmp[1] = iobuf_get_noeof (inp);
2927       tmp[2] = iobuf_get_noeof (inp);
2928       tmp[3] = iobuf_get_noeof (inp);
2929       pktlen -= 4;
2930       if (!memcmp (tmp, "gpg", 3))
2931         rt.subtype = tmp[3];
2932       else
2933         not_gpg = 1;
2934     }
2935   /* If it is a key or uid subtype read the remaining data.  */
2936   if ((rt.subtype == RING_TRUST_KEY || rt.subtype == RING_TRUST_UID)
2937       && pktlen >= 6 )
2938     {
2939       int i;
2940       unsigned int namelen;
2941
2942       rt.keysrc = iobuf_get_noeof (inp);
2943       pktlen--;
2944       rt.keyupdate = read_32 (inp);
2945       pktlen -= 4;
2946       namelen = iobuf_get_noeof (inp);
2947       pktlen--;
2948       if (namelen && pktlen)
2949         {
2950           rt.url = xtrymalloc (namelen + 1);
2951           if (rt.url)
2952             {
2953               err = gpg_error_from_syserror ();
2954               goto leave;
2955             }
2956           for (i = 0; pktlen && i < namelen; pktlen--, i++)
2957             rt.url[i] = iobuf_get_noeof (inp);
2958           rt.url[i] = 0;
2959         }
2960     }
2961
2962   if (list_mode)
2963     {
2964       if (rt.subtype == RING_TRUST_SIG)
2965         es_fprintf (listfp, ":trust packet: sig flag=%02x sigcache=%02x\n",
2966                     rt.trustval, rt.sigcache);
2967       else if (rt.subtype == RING_TRUST_UID || rt.subtype == RING_TRUST_KEY)
2968         {
2969           unsigned char *p;
2970
2971           es_fprintf (listfp, ":trust packet: %s upd=%lu src=%d%s",
2972                       (rt.subtype == RING_TRUST_UID? "uid" : "key"),
2973                       (unsigned long)rt.keyupdate,
2974                       rt.keysrc,
2975                       (rt.url? " url=":""));
2976           if (rt.url)
2977             {
2978               for (p = rt.url; *p; p++)
2979                 {
2980                   if (*p >= ' ' && *p <= 'z')
2981                     es_putc (*p, listfp);
2982                   else
2983                     es_fprintf (listfp, "\\x%02x", *p);
2984                 }
2985             }
2986           es_putc ('\n', listfp);
2987         }
2988       else if (not_gpg)
2989         es_fprintf (listfp, ":trust packet: not created by gpg\n");
2990       else
2991         es_fprintf (listfp, ":trust packet: subtype=%02x\n",
2992                     rt.subtype);
2993     }
2994
2995   /* Now transfer the data to the respective packet.  Do not do this
2996    * if SKIP_META is set.  */
2997   if (!ctx->last_pkt.pkt.generic || ctx->skip_meta)
2998     ;
2999   else if (rt.subtype == RING_TRUST_SIG
3000            && ctx->last_pkt.pkttype == PKT_SIGNATURE)
3001     {
3002       PKT_signature *sig = ctx->last_pkt.pkt.signature;
3003
3004       if ((rt.sigcache & 1))
3005         {
3006           sig->flags.checked = 1;
3007           sig->flags.valid = !!(rt.sigcache & 2);
3008         }
3009     }
3010   else if (rt.subtype == RING_TRUST_UID
3011            && (ctx->last_pkt.pkttype == PKT_USER_ID
3012                || ctx->last_pkt.pkttype == PKT_ATTRIBUTE))
3013     {
3014       PKT_user_id *uid = ctx->last_pkt.pkt.user_id;
3015
3016       uid->keysrc = rt.keysrc;
3017       uid->keyupdate = rt.keyupdate;
3018       uid->updateurl = rt.url;
3019       rt.url = NULL;
3020     }
3021   else if (rt.subtype == RING_TRUST_KEY
3022            && (ctx->last_pkt.pkttype == PKT_PUBLIC_KEY
3023                || ctx->last_pkt.pkttype == PKT_SECRET_KEY))
3024     {
3025       PKT_public_key *pk = ctx->last_pkt.pkt.public_key;
3026
3027       pk->keysrc = rt.keysrc;
3028       pk->keyupdate = rt.keyupdate;
3029       pk->updateurl = rt.url;
3030       rt.url = NULL;
3031     }
3032
3033   err = 0;
3034
3035  leave:
3036   xfree (rt.url);
3037   free_packet (NULL, ctx); /* This sets ctx->last_pkt to NULL.  */
3038   iobuf_skip_rest (inp, pktlen, 0);
3039   return err;
3040 }
3041
3042
3043 static int
3044 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
3045                  PACKET * pkt, int new_ctb, int partial)
3046 {
3047   int rc = 0;
3048   int mode, namelen;
3049   PKT_plaintext *pt;
3050   byte *p;
3051   int c, i;
3052
3053   if (!partial && pktlen < 6)
3054     {
3055       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
3056       if (list_mode)
3057         es_fputs (":literal data packet: [too short]\n", listfp);
3058       rc = gpg_error (GPG_ERR_INV_PACKET);
3059       goto leave;
3060     }
3061   mode = iobuf_get_noeof (inp);
3062   if (pktlen)
3063     pktlen--;
3064   namelen = iobuf_get_noeof (inp);
3065   if (pktlen)
3066     pktlen--;
3067   /* Note that namelen will never exceed 255 bytes. */
3068   pt = pkt->pkt.plaintext =
3069     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
3070   pt->new_ctb = new_ctb;
3071   pt->mode = mode;
3072   pt->namelen = namelen;
3073   pt->is_partial = partial;
3074   if (pktlen)
3075     {
3076       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
3077         pt->name[i] = iobuf_get_noeof (inp);
3078     }
3079   else
3080     {
3081       for (i = 0; i < namelen; i++)
3082         if ((c = iobuf_get (inp)) == -1)
3083           break;
3084         else
3085           pt->name[i] = c;
3086     }
3087   pt->timestamp = read_32 (inp);
3088   if (pktlen)
3089     pktlen -= 4;
3090   pt->len = pktlen;
3091   pt->buf = inp;
3092
3093   if (list_mode)
3094     {
3095       es_fprintf (listfp, ":literal data packet:\n"
3096                   "\tmode %c (%X), created %lu, name=\"",
3097                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
3098                   (ulong) pt->timestamp);
3099       for (p = pt->name, i = 0; i < namelen; p++, i++)
3100         {
3101           if (*p >= ' ' && *p <= 'z')
3102             es_putc (*p, listfp);
3103           else
3104             es_fprintf (listfp, "\\x%02x", *p);
3105         }
3106       es_fprintf (listfp, "\",\n\traw data: ");
3107       if (partial)
3108         es_fprintf (listfp, "unknown length\n");
3109       else
3110         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
3111     }
3112
3113  leave:
3114   return rc;
3115 }
3116
3117
3118 static int
3119 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
3120                   PACKET * pkt, int new_ctb)
3121 {
3122   PKT_compressed *zd;
3123
3124   /* PKTLEN is here 0, but data follows (this should be the last
3125      object in a file or the compress algorithm should know the
3126      length).  */
3127   (void) pkttype;
3128   (void) pktlen;
3129
3130   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
3131   zd->algorithm = iobuf_get_noeof (inp);
3132   zd->len = 0;                  /* not used */
3133   zd->new_ctb = new_ctb;
3134   zd->buf = inp;
3135   if (list_mode)
3136     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
3137   return 0;
3138 }
3139
3140
3141 static int
3142 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
3143                  PACKET * pkt, int new_ctb, int partial)
3144 {
3145   int rc = 0;
3146   PKT_encrypted *ed;
3147   unsigned long orig_pktlen = pktlen;
3148
3149   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
3150   /* ed->len is set below.  */
3151   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
3152   ed->buf = NULL;
3153   ed->new_ctb = new_ctb;
3154   ed->is_partial = partial;
3155   if (pkttype == PKT_ENCRYPTED_MDC)
3156     {
3157       /* Fixme: add some pktlen sanity checks.  */
3158       int version;
3159
3160       version = iobuf_get_noeof (inp);
3161       if (orig_pktlen)
3162         pktlen--;
3163       if (version != 1)
3164         {
3165           log_error ("encrypted_mdc packet with unknown version %d\n",
3166                      version);
3167           if (list_mode)
3168             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
3169           /*skip_rest(inp, pktlen); should we really do this? */
3170           rc = gpg_error (GPG_ERR_INV_PACKET);
3171           goto leave;
3172         }
3173       ed->mdc_method = DIGEST_ALGO_SHA1;
3174     }
3175   else
3176     ed->mdc_method = 0;
3177
3178   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
3179      detection bytes.  Note that we don't known the algorithm and thus
3180      we may only check against the minimum blocksize.  */
3181   if (orig_pktlen && pktlen < 10)
3182     {
3183       /* Actually this is blocksize+2.  */
3184       log_error ("packet(%d) too short\n", pkttype);
3185       if (list_mode)
3186         es_fputs (":encrypted data packet: [too short]\n", listfp);
3187       rc = GPG_ERR_INV_PACKET;
3188       iobuf_skip_rest (inp, pktlen, partial);
3189       goto leave;
3190     }
3191
3192   /* Store the remaining length of the encrypted data (i.e. without
3193      the MDC version number but with the IV etc.).  This value is
3194      required during decryption.  */
3195   ed->len = pktlen;
3196
3197   if (list_mode)
3198     {
3199       if (orig_pktlen)
3200         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
3201                     orig_pktlen);
3202       else
3203         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
3204       if (ed->mdc_method)
3205         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
3206     }
3207
3208   ed->buf = inp;
3209
3210  leave:
3211   return rc;
3212 }
3213
3214
3215 /* Note, that this code is not anymore used in real life because the
3216    MDC checking is now done right after the decryption in
3217    decrypt_data.  */
3218 static int
3219 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
3220            PACKET * pkt, int new_ctb)
3221 {
3222   int rc = 0;
3223   PKT_mdc *mdc;
3224   byte *p;
3225
3226   (void) pkttype;
3227
3228   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
3229   if (list_mode)
3230     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
3231   if (!new_ctb || pktlen != 20)
3232     {
3233       log_error ("mdc_packet with invalid encoding\n");
3234       rc = gpg_error (GPG_ERR_INV_PACKET);
3235       goto leave;
3236     }
3237   p = mdc->hash;
3238   for (; pktlen; pktlen--, p++)
3239     *p = iobuf_get_noeof (inp);
3240
3241  leave:
3242   return rc;
3243 }
3244
3245
3246 /*
3247  * This packet is internally generated by us (in armor.c) to transfer
3248  * some information to the lower layer.  To make sure that this packet
3249  * is really a GPG faked one and not one coming from outside, we
3250  * first check that there is a unique tag in it.
3251  *
3252  * The format of such a control packet is:
3253  *   n byte  session marker
3254  *   1 byte  control type CTRLPKT_xxxxx
3255  *   m byte  control data
3256  */
3257 static int
3258 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
3259                    PACKET * packet, int partial)
3260 {
3261   byte *p;
3262   const byte *sesmark;
3263   size_t sesmarklen;
3264   int i;
3265
3266   (void) pkttype;
3267
3268   if (list_mode)
3269     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
3270
3271   sesmark = get_session_marker (&sesmarklen);
3272   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
3273     goto skipit;
3274   for (i = 0; i < sesmarklen; i++, pktlen--)
3275     {
3276       if (sesmark[i] != iobuf_get_noeof (inp))
3277         goto skipit;
3278     }
3279   if (pktlen > 4096)
3280     goto skipit;  /* Definitely too large.  We skip it to avoid an
3281                      overflow in the malloc.  */
3282   if (list_mode)
3283     es_fputs ("- gpg control packet", listfp);
3284
3285   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
3286                                      + pktlen - 1);
3287   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
3288   pktlen--;
3289   packet->pkt.gpg_control->datalen = pktlen;
3290   p = packet->pkt.gpg_control->data;
3291   for (; pktlen; pktlen--, p++)
3292     *p = iobuf_get_noeof (inp);
3293
3294   return 0;
3295
3296  skipit:
3297   if (list_mode)
3298     {
3299       int c;
3300
3301       i = 0;
3302       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
3303       if (partial)
3304         {
3305           while ((c = iobuf_get (inp)) != -1)
3306             dump_hex_line (c, &i);
3307         }
3308       else
3309         {
3310           for (; pktlen; pktlen--)
3311             {
3312               dump_hex_line ((c = iobuf_get (inp)), &i);
3313               if (c == -1)
3314                 break;
3315             }
3316         }
3317       es_putc ('\n', listfp);
3318     }
3319   iobuf_skip_rest (inp, pktlen, 0);
3320   return gpg_error (GPG_ERR_INV_PACKET);
3321 }
3322
3323
3324 /* Create a GPG control packet to be used internally as a placeholder.  */
3325 PACKET *
3326 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
3327 {
3328   PACKET *packet;
3329   byte *p;
3330
3331   packet = xmalloc (sizeof *packet);
3332   init_packet (packet);
3333   packet->pkttype = PKT_GPG_CONTROL;
3334   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
3335                                      + datalen - 1);
3336   packet->pkt.gpg_control->control = type;
3337   packet->pkt.gpg_control->datalen = datalen;
3338   p = packet->pkt.gpg_control->data;
3339   for (; datalen; datalen--, p++)
3340     *p = *data++;
3341
3342   return packet;
3343 }