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