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