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