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