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