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