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