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