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