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