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