Nuked almost all trailing white space.
[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, int partial);
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 static void *
724 read_rest (IOBUF inp, size_t pktlen, int partial)
725 {
726   byte *p;
727   int i;
728
729   if (partial)
730     {
731       log_error ("read_rest: can't store stream data\n");
732       p = NULL;
733     }
734   else
735     {
736       p = xmalloc (pktlen);
737       for (i = 0; pktlen; pktlen--, i++)
738         p[i] = iobuf_get (inp);
739     }
740   return p;
741 }
742
743
744 /* Read a special size+body from INP.  On success store an opaque MPI
745    with it at R_DATA.  On error return an error code and store NULL at
746    R_DATA.  Even in the error case store the number of read bytes at
747    R_NREAD.  The caller shall pass the remaining size of the packet in
748    PKTLEN.  */
749 static gpg_error_t
750 read_size_body (iobuf_t inp, int pktlen, size_t *r_nread,
751                 gcry_mpi_t *r_data)
752 {
753   char buffer[256];
754   char *tmpbuf;
755   int i, c, nbytes;
756
757   *r_nread = 0;
758   *r_data = NULL;
759
760   if (!pktlen)
761     return gpg_error (GPG_ERR_INV_PACKET);
762   c = iobuf_readbyte (inp);
763   if (c < 0)
764     return gpg_error (GPG_ERR_INV_PACKET);
765   pktlen--;
766   ++*r_nread;
767   nbytes = c;
768   if (nbytes < 2 || nbytes > 254)
769     return gpg_error (GPG_ERR_INV_PACKET);
770   if (nbytes > pktlen)
771     return gpg_error (GPG_ERR_INV_PACKET);
772
773   buffer[0] = nbytes;
774
775   for (i = 0; i < nbytes; i++)
776     {
777       c = iobuf_get (inp);
778       if (c < 0)
779         return gpg_error (GPG_ERR_INV_PACKET);
780       ++*r_nread;
781       buffer[1+i] = c;
782     }
783
784   tmpbuf = xtrymalloc (1 + nbytes);
785   if (!tmpbuf)
786     return gpg_error_from_syserror ();
787   memcpy (tmpbuf, buffer, 1 + nbytes);
788   *r_data = gcry_mpi_set_opaque (NULL, tmpbuf, 8 * (1 + nbytes));
789   if (!*r_data)
790     {
791       xfree (tmpbuf);
792       return gpg_error_from_syserror ();
793     }
794   return 0;
795 }
796
797
798 /* Parse a marker packet.  */
799 static int
800 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
801 {
802   (void) pkttype;
803
804   if (pktlen != 3)
805     goto fail;
806
807   if (iobuf_get (inp) != 'P')
808     {
809       pktlen--;
810       goto fail;
811     }
812
813   if (iobuf_get (inp) != 'G')
814     {
815       pktlen--;
816       goto fail;
817     }
818
819   if (iobuf_get (inp) != 'P')
820     {
821       pktlen--;
822       goto fail;
823     }
824
825   if (list_mode)
826     es_fputs (":marker packet: PGP\n", listfp);
827
828   return 0;
829
830  fail:
831   log_error ("invalid marker packet\n");
832   iobuf_skip_rest (inp, pktlen, 0);
833   return G10ERR_INVALID_PACKET;
834 }
835
836
837 static int
838 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
839                  PACKET * packet)
840 {
841   PKT_symkey_enc *k;
842   int rc = 0;
843   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
844
845   if (pktlen < 4)
846     {
847       log_error ("packet(%d) too short\n", pkttype);
848       rc = gpg_error (GPG_ERR_INV_PACKET);
849       goto leave;
850     }
851   version = iobuf_get_noeof (inp);
852   pktlen--;
853   if (version != 4)
854     {
855       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
856       rc = gpg_error (GPG_ERR_INV_PACKET);
857       goto leave;
858     }
859   if (pktlen > 200)
860     {                           /* (we encode the seskeylen in a byte) */
861       log_error ("packet(%d) too large\n", pkttype);
862       rc = gpg_error (GPG_ERR_INV_PACKET);
863       goto leave;
864     }
865   cipher_algo = iobuf_get_noeof (inp);
866   pktlen--;
867   s2kmode = iobuf_get_noeof (inp);
868   pktlen--;
869   hash_algo = iobuf_get_noeof (inp);
870   pktlen--;
871   switch (s2kmode)
872     {
873     case 0: /* Simple S2K.  */
874       minlen = 0;
875       break;
876     case 1: /* Salted S2K.  */
877       minlen = 8;
878       break;
879     case 3: /* Iterated+salted S2K.  */
880       minlen = 9;
881       break;
882     default:
883       log_error ("unknown S2K mode %d\n", s2kmode);
884       goto leave;
885     }
886   if (minlen > pktlen)
887     {
888       log_error ("packet with S2K %d too short\n", s2kmode);
889       rc = gpg_error (GPG_ERR_INV_PACKET);
890       goto leave;
891     }
892   seskeylen = pktlen - minlen;
893   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
894                                               + seskeylen - 1);
895   k->version = version;
896   k->cipher_algo = cipher_algo;
897   k->s2k.mode = s2kmode;
898   k->s2k.hash_algo = hash_algo;
899   if (s2kmode == 1 || s2kmode == 3)
900     {
901       for (i = 0; i < 8 && pktlen; i++, pktlen--)
902         k->s2k.salt[i] = iobuf_get_noeof (inp);
903     }
904   if (s2kmode == 3)
905     {
906       k->s2k.count = iobuf_get (inp);
907       pktlen--;
908     }
909   k->seskeylen = seskeylen;
910   if (k->seskeylen)
911     {
912       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
913         k->seskey[i] = iobuf_get_noeof (inp);
914
915       /* What we're watching out for here is a session key decryptor
916          with no salt.  The RFC says that using salt for this is a
917          MUST. */
918       if (s2kmode != 1 && s2kmode != 3)
919         log_info (_("WARNING: potentially insecure symmetrically"
920                     " encrypted session key\n"));
921     }
922   assert (!pktlen);
923
924   if (list_mode)
925     {
926       es_fprintf (listfp,
927                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
928                   version, cipher_algo, s2kmode, hash_algo);
929       if (seskeylen)
930         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
931       es_fprintf (listfp, "\n");
932       if (s2kmode == 1 || s2kmode == 3)
933         {
934           es_fprintf (listfp, "\tsalt ");
935           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
936           if (s2kmode == 3)
937             es_fprintf (listfp, ", count %lu (%lu)",
938                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
939                         (ulong) k->s2k.count);
940           es_fprintf (listfp, "\n");
941         }
942     }
943
944  leave:
945   iobuf_skip_rest (inp, pktlen, 0);
946   return rc;
947 }
948
949
950 static int
951 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
952                  PACKET * packet)
953 {
954   unsigned int n;
955   int rc = 0;
956   int i, ndata;
957   PKT_pubkey_enc *k;
958
959   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
960   if (pktlen < 12)
961     {
962       log_error ("packet(%d) too short\n", pkttype);
963       rc = gpg_error (GPG_ERR_INV_PACKET);
964       goto leave;
965     }
966   k->version = iobuf_get_noeof (inp);
967   pktlen--;
968   if (k->version != 2 && k->version != 3)
969     {
970       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
971       rc = gpg_error (GPG_ERR_INV_PACKET);
972       goto leave;
973     }
974   k->keyid[0] = read_32 (inp);
975   pktlen -= 4;
976   k->keyid[1] = read_32 (inp);
977   pktlen -= 4;
978   k->pubkey_algo = iobuf_get_noeof (inp);
979   pktlen--;
980   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
981   if (list_mode)
982     es_fprintf (listfp,
983                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
984                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
985                 (ulong) k->keyid[1]);
986
987   ndata = pubkey_get_nenc (k->pubkey_algo);
988   if (!ndata)
989     {
990       if (list_mode)
991         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
992       unknown_pubkey_warning (k->pubkey_algo);
993       k->data[0] = NULL; /* No need to store the encrypted data.  */
994     }
995   else
996     {
997       for (i = 0; i < ndata; i++)
998         {
999           if (k->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
1000             {
1001               rc = read_size_body (inp, pktlen, &n, k->data+i);
1002               pktlen -= n;
1003             }
1004           else
1005             {
1006               n = pktlen;
1007               k->data[i] = mpi_read (inp, &n, 0);
1008               pktlen -= n;
1009               if (!k->data[i])
1010                 rc = gpg_error (GPG_ERR_INV_PACKET);
1011             }
1012           if (rc)
1013             goto leave;
1014           if (list_mode)
1015             {
1016               es_fprintf (listfp, "\tdata: ");
1017               mpi_print (listfp, k->data[i], mpi_print_mode);
1018               es_putc ('\n', listfp);
1019             }
1020         }
1021     }
1022
1023  leave:
1024   iobuf_skip_rest (inp, pktlen, 0);
1025   return rc;
1026 }
1027
1028
1029 static void
1030 dump_sig_subpkt (int hashed, int type, int critical,
1031                  const byte * buffer, size_t buflen, size_t length)
1032 {
1033   const char *p = NULL;
1034   int i;
1035
1036   /* The CERT has warning out with explains how to use GNUPG to detect
1037    * the ARRs - we print our old message here when it is a faked ARR
1038    * and add an additional notice.  */
1039   if (type == SIGSUBPKT_ARR && !hashed)
1040     {
1041       es_fprintf (listfp,
1042                   "\tsubpkt %d len %u (additional recipient request)\n"
1043                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
1044                   "encrypt to this key and thereby reveal the plaintext to "
1045                   "the owner of this ARR key. Detailed info follows:\n",
1046                   type, (unsigned) length);
1047     }
1048
1049   buffer++;
1050   length--;
1051
1052   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
1053               critical ? "critical " : "",
1054               hashed ? "hashed " : "", type, (unsigned) length);
1055   if (length > buflen)
1056     {
1057       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
1058       return;
1059     }
1060   switch (type)
1061     {
1062     case SIGSUBPKT_SIG_CREATED:
1063       if (length >= 4)
1064         es_fprintf (listfp, "sig created %s",
1065                     strtimestamp (buffer_to_u32 (buffer)));
1066       break;
1067     case SIGSUBPKT_SIG_EXPIRE:
1068       if (length >= 4)
1069         {
1070           if (buffer_to_u32 (buffer))
1071             es_fprintf (listfp, "sig expires after %s",
1072                         strtimevalue (buffer_to_u32 (buffer)));
1073           else
1074             es_fprintf (listfp, "sig does not expire");
1075         }
1076       break;
1077     case SIGSUBPKT_EXPORTABLE:
1078       if (length)
1079         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1080       break;
1081     case SIGSUBPKT_TRUST:
1082       if (length != 2)
1083         p = "[invalid trust subpacket]";
1084       else
1085         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1086                     buffer[1]);
1087       break;
1088     case SIGSUBPKT_REGEXP:
1089       if (!length)
1090         p = "[invalid regexp subpacket]";
1091       else
1092         es_fprintf (listfp, "regular expression: \"%s\"", buffer);
1093       break;
1094     case SIGSUBPKT_REVOCABLE:
1095       if (length)
1096         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1097       break;
1098     case SIGSUBPKT_KEY_EXPIRE:
1099       if (length >= 4)
1100         {
1101           if (buffer_to_u32 (buffer))
1102             es_fprintf (listfp, "key expires after %s",
1103                         strtimevalue (buffer_to_u32 (buffer)));
1104           else
1105             es_fprintf (listfp, "key does not expire");
1106         }
1107       break;
1108     case SIGSUBPKT_PREF_SYM:
1109       es_fputs ("pref-sym-algos:", listfp);
1110       for (i = 0; i < length; i++)
1111         es_fprintf (listfp, " %d", buffer[i]);
1112       break;
1113     case SIGSUBPKT_REV_KEY:
1114       es_fputs ("revocation key: ", listfp);
1115       if (length < 22)
1116         p = "[too short]";
1117       else
1118         {
1119           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1120           for (i = 2; i < length; i++)
1121             es_fprintf (listfp, "%02X", buffer[i]);
1122         }
1123       break;
1124     case SIGSUBPKT_ISSUER:
1125       if (length >= 8)
1126         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1127                     (ulong) buffer_to_u32 (buffer),
1128                     (ulong) buffer_to_u32 (buffer + 4));
1129       break;
1130     case SIGSUBPKT_NOTATION:
1131       {
1132         es_fputs ("notation: ", listfp);
1133         if (length < 8)
1134           p = "[too short]";
1135         else
1136           {
1137             const byte *s = buffer;
1138             size_t n1, n2;
1139
1140             n1 = (s[4] << 8) | s[5];
1141             n2 = (s[6] << 8) | s[7];
1142             s += 8;
1143             if (8 + n1 + n2 != length)
1144               p = "[error]";
1145             else
1146               {
1147                 es_write_sanitized (listfp, s, n1, ")", NULL);
1148                 es_putc ('=', listfp);
1149
1150                 if (*buffer & 0x80)
1151                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1152                 else
1153                   p = "[not human readable]";
1154               }
1155           }
1156       }
1157       break;
1158     case SIGSUBPKT_PREF_HASH:
1159       es_fputs ("pref-hash-algos:", listfp);
1160       for (i = 0; i < length; i++)
1161         es_fprintf (listfp, " %d", buffer[i]);
1162       break;
1163     case SIGSUBPKT_PREF_COMPR:
1164       es_fputs ("pref-zip-algos:", listfp);
1165       for (i = 0; i < length; i++)
1166         es_fprintf (listfp, " %d", buffer[i]);
1167       break;
1168     case SIGSUBPKT_KS_FLAGS:
1169       es_fputs ("key server preferences:", listfp);
1170       for (i = 0; i < length; i++)
1171         es_fprintf (listfp, " %02X", buffer[i]);
1172       break;
1173     case SIGSUBPKT_PREF_KS:
1174       es_fputs ("preferred key server: ", listfp);
1175       es_write_sanitized (listfp, buffer, length, ")", NULL);
1176       break;
1177     case SIGSUBPKT_PRIMARY_UID:
1178       p = "primary user ID";
1179       break;
1180     case SIGSUBPKT_POLICY:
1181       es_fputs ("policy: ", listfp);
1182       es_write_sanitized (listfp, buffer, length, ")", NULL);
1183       break;
1184     case SIGSUBPKT_KEY_FLAGS:
1185       es_fputs ("key flags:", listfp);
1186       for (i = 0; i < length; i++)
1187         es_fprintf (listfp, " %02X", buffer[i]);
1188       break;
1189     case SIGSUBPKT_SIGNERS_UID:
1190       p = "signer's user ID";
1191       break;
1192     case SIGSUBPKT_REVOC_REASON:
1193       if (length)
1194         {
1195           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1196           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1197           p = ")";
1198         }
1199       break;
1200     case SIGSUBPKT_ARR:
1201       es_fputs ("Big Brother's key (ignored): ", listfp);
1202       if (length < 22)
1203         p = "[too short]";
1204       else
1205         {
1206           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1207           if (length > 2)
1208             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1209         }
1210       break;
1211     case SIGSUBPKT_FEATURES:
1212       es_fputs ("features:", listfp);
1213       for (i = 0; i < length; i++)
1214         es_fprintf (listfp, " %02x", buffer[i]);
1215       break;
1216     case SIGSUBPKT_SIGNATURE:
1217       es_fputs ("signature: ", listfp);
1218       if (length < 17)
1219         p = "[too short]";
1220       else
1221         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1222                     buffer[0],
1223                     buffer[0] == 3 ? buffer[2] : buffer[1],
1224                     buffer[0] == 3 ? buffer[15] : buffer[2],
1225                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1226       break;
1227     default:
1228       if (type >= 100 && type <= 110)
1229         p = "experimental / private subpacket";
1230       else
1231         p = "?";
1232       break;
1233     }
1234
1235   es_fprintf (listfp, "%s)\n", p ? p : "");
1236 }
1237
1238
1239 /*
1240  * Returns: >= 0 use this offset into buffer
1241  *          -1 explicitly reject returning this type
1242  *          -2 subpacket too short
1243  */
1244 int
1245 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1246 {
1247   switch (type)
1248     {
1249     case SIGSUBPKT_REV_KEY:
1250       if (n < 22)
1251         break;
1252       return 0;
1253     case SIGSUBPKT_SIG_CREATED:
1254     case SIGSUBPKT_SIG_EXPIRE:
1255     case SIGSUBPKT_KEY_EXPIRE:
1256       if (n < 4)
1257         break;
1258       return 0;
1259     case SIGSUBPKT_KEY_FLAGS:
1260     case SIGSUBPKT_KS_FLAGS:
1261     case SIGSUBPKT_PREF_SYM:
1262     case SIGSUBPKT_PREF_HASH:
1263     case SIGSUBPKT_PREF_COMPR:
1264     case SIGSUBPKT_POLICY:
1265     case SIGSUBPKT_PREF_KS:
1266     case SIGSUBPKT_FEATURES:
1267     case SIGSUBPKT_REGEXP:
1268       return 0;
1269     case SIGSUBPKT_SIGNATURE:
1270     case SIGSUBPKT_EXPORTABLE:
1271     case SIGSUBPKT_REVOCABLE:
1272     case SIGSUBPKT_REVOC_REASON:
1273       if (!n)
1274         break;
1275       return 0;
1276     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1277       if (n < 8)
1278         break;
1279       return 0;
1280     case SIGSUBPKT_NOTATION:
1281       /* minimum length needed, and the subpacket must be well-formed
1282          where the name length and value length all fit inside the
1283          packet. */
1284       if (n < 8
1285           || 8 + ((buffer[4] << 8) | buffer[5]) +
1286           ((buffer[6] << 8) | buffer[7]) != n)
1287         break;
1288       return 0;
1289     case SIGSUBPKT_PRIMARY_UID:
1290       if (n != 1)
1291         break;
1292       return 0;
1293     case SIGSUBPKT_TRUST:
1294       if (n != 2)
1295         break;
1296       return 0;
1297     default:
1298       return 0;
1299     }
1300   return -2;
1301 }
1302
1303
1304 /* Return true if we understand the critical notation.  */
1305 static int
1306 can_handle_critical_notation (const byte * name, size_t len)
1307 {
1308   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1309     return 1;
1310   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1311     return 1;
1312
1313   return 0;
1314 }
1315
1316
1317 static int
1318 can_handle_critical (const byte * buffer, size_t n, int type)
1319 {
1320   switch (type)
1321     {
1322     case SIGSUBPKT_NOTATION:
1323       if (n >= 8)
1324         return can_handle_critical_notation (buffer + 8,
1325                                              (buffer[4] << 8) | buffer[5]);
1326       else
1327         return 0;
1328     case SIGSUBPKT_SIGNATURE:
1329     case SIGSUBPKT_SIG_CREATED:
1330     case SIGSUBPKT_SIG_EXPIRE:
1331     case SIGSUBPKT_KEY_EXPIRE:
1332     case SIGSUBPKT_EXPORTABLE:
1333     case SIGSUBPKT_REVOCABLE:
1334     case SIGSUBPKT_REV_KEY:
1335     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1336     case SIGSUBPKT_PREF_SYM:
1337     case SIGSUBPKT_PREF_HASH:
1338     case SIGSUBPKT_PREF_COMPR:
1339     case SIGSUBPKT_KEY_FLAGS:
1340     case SIGSUBPKT_PRIMARY_UID:
1341     case SIGSUBPKT_FEATURES:
1342     case SIGSUBPKT_TRUST:
1343     case SIGSUBPKT_REGEXP:
1344       /* Is it enough to show the policy or keyserver? */
1345     case SIGSUBPKT_POLICY:
1346     case SIGSUBPKT_PREF_KS:
1347       return 1;
1348
1349     default:
1350       return 0;
1351     }
1352 }
1353
1354
1355 const byte *
1356 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1357                  size_t * ret_n, int *start, int *critical)
1358 {
1359   const byte *buffer;
1360   int buflen;
1361   int type;
1362   int critical_dummy;
1363   int offset;
1364   size_t n;
1365   int seq = 0;
1366   int reqseq = start ? *start : 0;
1367
1368   if (!critical)
1369     critical = &critical_dummy;
1370
1371   if (!pktbuf || reqseq == -1)
1372     {
1373       /* return some value different from NULL to indicate that
1374        * there is no critical bit we do not understand.  The caller
1375        * will never use the value.  Yes I know, it is an ugly hack */
1376       return reqtype ==
1377         SIGSUBPKT_TEST_CRITICAL ? (const byte *) &pktbuf : NULL;
1378     }
1379   buffer = pktbuf->data;
1380   buflen = pktbuf->len;
1381   while (buflen)
1382     {
1383       n = *buffer++;
1384       buflen--;
1385       if (n == 255) /* 4 byte length header.  */
1386         {
1387           if (buflen < 4)
1388             goto too_short;
1389           n = (buffer[0] << 24) | (buffer[1] << 16)
1390             | (buffer[2] << 8) | buffer[3];
1391           buffer += 4;
1392           buflen -= 4;
1393         }
1394       else if (n >= 192) /* 4 byte special encoded length header.  */
1395         {
1396           if (buflen < 2)
1397             goto too_short;
1398           n = ((n - 192) << 8) + *buffer + 192;
1399           buffer++;
1400           buflen--;
1401         }
1402       if (buflen < n)
1403         goto too_short;
1404       type = *buffer;
1405       if (type & 0x80)
1406         {
1407           type &= 0x7f;
1408           *critical = 1;
1409         }
1410       else
1411         *critical = 0;
1412       if (!(++seq > reqseq))
1413         ;
1414       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1415         {
1416           if (*critical)
1417             {
1418               if (n - 1 > buflen + 1)
1419                 goto too_short;
1420               if (!can_handle_critical (buffer + 1, n - 1, type))
1421                 {
1422                   if (opt.verbose)
1423                     log_info (_("subpacket of type %d has "
1424                                 "critical bit set\n"), type);
1425                   if (start)
1426                     *start = seq;
1427                   return NULL;  /* This is an error.  */
1428                 }
1429             }
1430         }
1431       else if (reqtype < 0) /* List packets.  */
1432         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1433                          type, *critical, buffer, buflen, n);
1434       else if (type == reqtype) /* Found.  */
1435         {
1436           buffer++;
1437           n--;
1438           if (n > buflen)
1439             goto too_short;
1440           if (ret_n)
1441             *ret_n = n;
1442           offset = parse_one_sig_subpkt (buffer, n, type);
1443           switch (offset)
1444             {
1445             case -2:
1446               log_error ("subpacket of type %d too short\n", type);
1447               return NULL;
1448             case -1:
1449               return NULL;
1450             default:
1451               break;
1452             }
1453           if (start)
1454             *start = seq;
1455           return buffer + offset;
1456         }
1457       buffer += n;
1458       buflen -= n;
1459     }
1460   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1461     return buffer;  /* Used as True to indicate that there is no. */
1462
1463   /* Critical bit we don't understand. */
1464   if (start)
1465     *start = -1;
1466   return NULL;  /* End of packets; not found.  */
1467
1468  too_short:
1469   if (opt.verbose)
1470     log_info ("buffer shorter than subpacket\n");
1471   if (start)
1472     *start = -1;
1473   return NULL;
1474 }
1475
1476
1477 const byte *
1478 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1479                   size_t * ret_n)
1480 {
1481   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1482 }
1483
1484
1485 const byte *
1486 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype,
1487                    size_t * ret_n)
1488 {
1489   const byte *p;
1490
1491   p = parse_sig_subpkt (sig->hashed, reqtype, ret_n);
1492   if (!p)
1493     p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n);
1494   return p;
1495 }
1496
1497
1498 /* Find all revocation keys.  Look in hashed area only.  */
1499 void
1500 parse_revkeys (PKT_signature * sig)
1501 {
1502   struct revocation_key *revkey;
1503   int seq = 0;
1504   size_t len;
1505
1506   if (sig->sig_class != 0x1F)
1507     return;
1508
1509   while ((revkey =
1510           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1511                                                      SIGSUBPKT_REV_KEY,
1512                                                      &len, &seq, NULL)))
1513     {
1514       if (len == sizeof (struct revocation_key)
1515           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1516         {
1517           sig->revkey = xrealloc (sig->revkey,
1518                                   sizeof (struct revocation_key *) *
1519                                   (sig->numrevkeys + 1));
1520           sig->revkey[sig->numrevkeys] = revkey;
1521           sig->numrevkeys++;
1522         }
1523     }
1524 }
1525
1526
1527 int
1528 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1529                  PKT_signature * sig)
1530 {
1531   int md5_len = 0;
1532   unsigned n;
1533   int is_v4 = 0;
1534   int rc = 0;
1535   int i, ndata;
1536
1537   if (pktlen < 16)
1538     {
1539       log_error ("packet(%d) too short\n", pkttype);
1540       goto leave;
1541     }
1542   sig->version = iobuf_get_noeof (inp);
1543   pktlen--;
1544   if (sig->version == 4)
1545     is_v4 = 1;
1546   else if (sig->version != 2 && sig->version != 3)
1547     {
1548       log_error ("packet(%d) with unknown version %d\n",
1549                  pkttype, sig->version);
1550       rc = gpg_error (GPG_ERR_INV_PACKET);
1551       goto leave;
1552     }
1553
1554   if (!is_v4)
1555     {
1556       md5_len = iobuf_get_noeof (inp);
1557       pktlen--;
1558     }
1559   sig->sig_class = iobuf_get_noeof (inp);
1560   pktlen--;
1561   if (!is_v4)
1562     {
1563       sig->timestamp = read_32 (inp);
1564       pktlen -= 4;
1565       sig->keyid[0] = read_32 (inp);
1566       pktlen -= 4;
1567       sig->keyid[1] = read_32 (inp);
1568       pktlen -= 4;
1569     }
1570   sig->pubkey_algo = iobuf_get_noeof (inp);
1571   pktlen--;
1572   sig->digest_algo = iobuf_get_noeof (inp);
1573   pktlen--;
1574   sig->flags.exportable = 1;
1575   sig->flags.revocable = 1;
1576   if (is_v4) /* Read subpackets.  */
1577     {
1578       n = read_16 (inp);
1579       pktlen -= 2;  /* Length of hashed data. */
1580       if (n > 10000)
1581         {
1582           log_error ("signature packet: hashed data too long\n");
1583           rc = G10ERR_INVALID_PACKET;
1584           goto leave;
1585         }
1586       if (n)
1587         {
1588           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1589           sig->hashed->size = n;
1590           sig->hashed->len = n;
1591           if (iobuf_read (inp, sig->hashed->data, n) != n)
1592             {
1593               log_error ("premature eof while reading "
1594                          "hashed signature data\n");
1595               rc = -1;
1596               goto leave;
1597             }
1598           pktlen -= n;
1599         }
1600       n = read_16 (inp);
1601       pktlen -= 2;  /* Length of unhashed data.  */
1602       if (n > 10000)
1603         {
1604           log_error ("signature packet: unhashed data too long\n");
1605           rc = G10ERR_INVALID_PACKET;
1606           goto leave;
1607         }
1608       if (n)
1609         {
1610           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1611           sig->unhashed->size = n;
1612           sig->unhashed->len = n;
1613           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1614             {
1615               log_error ("premature eof while reading "
1616                          "unhashed signature data\n");
1617               rc = -1;
1618               goto leave;
1619             }
1620           pktlen -= n;
1621         }
1622     }
1623
1624   if (pktlen < 5)  /* Sanity check.  */
1625     {
1626       log_error ("packet(%d) too short\n", pkttype);
1627       rc = G10ERR_INVALID_PACKET;
1628       goto leave;
1629     }
1630
1631   sig->digest_start[0] = iobuf_get_noeof (inp);
1632   pktlen--;
1633   sig->digest_start[1] = iobuf_get_noeof (inp);
1634   pktlen--;
1635
1636   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1637     {
1638       const byte *p;
1639       size_t len;
1640
1641       /* Set sig->flags.unknown_critical if there is a critical bit
1642        * set for packets which we do not understand.  */
1643       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1644           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1645         sig->flags.unknown_critical = 1;
1646
1647       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1648       if (p)
1649         sig->timestamp = buffer_to_u32 (p);
1650       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1651                && opt.verbose)
1652         log_info ("signature packet without timestamp\n");
1653
1654       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER, NULL);
1655       if (p)
1656         {
1657           sig->keyid[0] = buffer_to_u32 (p);
1658           sig->keyid[1] = buffer_to_u32 (p + 4);
1659         }
1660       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1661                && opt.verbose)
1662         log_info ("signature packet without keyid\n");
1663
1664       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1665       if (p && buffer_to_u32 (p))
1666         sig->expiredate = sig->timestamp + buffer_to_u32 (p);
1667       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1668         sig->flags.expired = 1;
1669
1670       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1671       if (p)
1672         sig->flags.policy_url = 1;
1673
1674       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1675       if (p)
1676         sig->flags.pref_ks = 1;
1677
1678       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1679       if (p)
1680         sig->flags.notation = 1;
1681
1682       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1683       if (p && *p == 0)
1684         sig->flags.revocable = 0;
1685
1686       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1687       if (p && len == 2)
1688         {
1689           sig->trust_depth = p[0];
1690           sig->trust_value = p[1];
1691
1692           /* Only look for a regexp if there is also a trust
1693              subpacket. */
1694           sig->trust_regexp =
1695             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1696
1697           /* If the regular expression is of 0 length, there is no
1698              regular expression. */
1699           if (len == 0)
1700             sig->trust_regexp = NULL;
1701         }
1702
1703       /* We accept the exportable subpacket from either the hashed or
1704          unhashed areas as older versions of gpg put it in the
1705          unhashed area.  In theory, anyway, we should never see this
1706          packet off of a local keyring. */
1707
1708       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE, NULL);
1709       if (p && *p == 0)
1710         sig->flags.exportable = 0;
1711
1712       /* Find all revocation keys.  */
1713       if (sig->sig_class == 0x1F)
1714         parse_revkeys (sig);
1715     }
1716
1717   if (list_mode)
1718     {
1719       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1720                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1721                   "\tdigest algo %d, begin of digest %02x %02x\n",
1722                   sig->pubkey_algo,
1723                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1724                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1725                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1726       if (is_v4)
1727         {
1728           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1729           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1730         }
1731     }
1732
1733   ndata = pubkey_get_nsig (sig->pubkey_algo);
1734   if (!ndata)
1735     {
1736       if (list_mode)
1737         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1738       unknown_pubkey_warning (sig->pubkey_algo);
1739
1740       /* We store the plain material in data[0], so that we are able
1741        * to write it back with build_packet().  */
1742       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1743         {
1744           /* We include a limit to avoid too trivial DoS attacks by
1745              having gpg allocate too much memory.  */
1746           log_error ("signature packet: too much data\n");
1747           rc = G10ERR_INVALID_PACKET;
1748         }
1749       else
1750         {
1751           sig->data[0] =
1752             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen, 0),
1753                                  pktlen * 8);
1754           pktlen = 0;
1755         }
1756     }
1757   else
1758     {
1759       for (i = 0; i < ndata; i++)
1760         {
1761           n = pktlen;
1762           sig->data[i] = mpi_read (inp, &n, 0);
1763           pktlen -= n;
1764           if (list_mode)
1765             {
1766               es_fprintf (listfp, "\tdata: ");
1767               mpi_print (listfp, sig->data[i], mpi_print_mode);
1768               es_putc ('\n', listfp);
1769             }
1770           if (!sig->data[i])
1771             rc = G10ERR_INVALID_PACKET;
1772         }
1773     }
1774
1775  leave:
1776   iobuf_skip_rest (inp, pktlen, 0);
1777   return rc;
1778 }
1779
1780
1781 static int
1782 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1783                    PKT_onepass_sig * ops)
1784 {
1785   int version;
1786   int rc = 0;
1787
1788   if (pktlen < 13)
1789     {
1790       log_error ("packet(%d) too short\n", pkttype);
1791       rc = gpg_error (GPG_ERR_INV_PACKET);
1792       goto leave;
1793     }
1794   version = iobuf_get_noeof (inp);
1795   pktlen--;
1796   if (version != 3)
1797     {
1798       log_error ("onepass_sig with unknown version %d\n", version);
1799       rc = gpg_error (GPG_ERR_INV_PACKET);
1800       goto leave;
1801     }
1802   ops->sig_class = iobuf_get_noeof (inp);
1803   pktlen--;
1804   ops->digest_algo = iobuf_get_noeof (inp);
1805   pktlen--;
1806   ops->pubkey_algo = iobuf_get_noeof (inp);
1807   pktlen--;
1808   ops->keyid[0] = read_32 (inp);
1809   pktlen -= 4;
1810   ops->keyid[1] = read_32 (inp);
1811   pktlen -= 4;
1812   ops->last = iobuf_get_noeof (inp);
1813   pktlen--;
1814   if (list_mode)
1815     es_fprintf (listfp,
1816                 ":onepass_sig packet: keyid %08lX%08lX\n"
1817                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1818                 "last=%d\n",
1819                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1820                 version, ops->sig_class,
1821                 ops->digest_algo, ops->pubkey_algo, ops->last);
1822
1823
1824  leave:
1825   iobuf_skip_rest (inp, pktlen, 0);
1826   return rc;
1827 }
1828
1829
1830 static gcry_mpi_t
1831 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1832 {
1833   int c;
1834   unsigned int nbits, nbytes;
1835   unsigned char *buf, *p;
1836   gcry_mpi_t val;
1837
1838   if (*length < 2)
1839     {
1840       log_error ("mpi too small\n");
1841       return NULL;
1842     }
1843
1844   if ((c = iobuf_get (inp)) == -1)
1845     return NULL;
1846   --*length;
1847   nbits = c << 8;
1848   if ((c = iobuf_get (inp)) == -1)
1849     return NULL;
1850   --*length;
1851   nbits |= c;
1852
1853   if (nbits > 16384)
1854     {
1855       log_error ("mpi too large (%u bits)\n", nbits);
1856       return NULL;
1857     }
1858   nbytes = (nbits + 7) / 8;
1859   buf = p = xmalloc (2 + nbytes);
1860   *p++ = nbits >> 8;
1861   *p++ = nbits;
1862   for (; nbytes && *length; nbytes--, --*length)
1863     *p++ = iobuf_get (inp);
1864   if (nbytes)
1865     {
1866       log_error ("packet shorter than mpi\n");
1867       xfree (buf);
1868       return NULL;
1869     }
1870
1871   /* Convert buffer into an opaque MPI.  */
1872   val = gcry_mpi_set_opaque (NULL, buf, (p - buf) * 8);
1873   return val;
1874 }
1875
1876
1877 static int
1878 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1879            byte * hdr, int hdrlen, PACKET * pkt)
1880 {
1881   gpg_error_t err = 0;
1882   int i, version, algorithm;
1883   unsigned n;
1884   unsigned long timestamp, expiredate, max_expiredate;
1885   int npkey, nskey;
1886   int is_v4 = 0;
1887   int rc = 0;
1888   u32 keyid[2];
1889   PKT_public_key *pk;
1890
1891   (void) hdr;
1892
1893   pk = pkt->pkt.public_key; /* PK has been cleared. */
1894
1895   version = iobuf_get_noeof (inp);
1896   pktlen--;
1897   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1898     {
1899       /* Early versions of G10 used the old PGP comments packets;
1900        * luckily all those comments are started by a hash.  */
1901       if (list_mode)
1902         {
1903           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1904           for (; pktlen; pktlen--)
1905             {
1906               int c;
1907               c = iobuf_get_noeof (inp);
1908               if (c >= ' ' && c <= 'z')
1909                 es_putc (c, listfp);
1910               else
1911                 es_fprintf (listfp, "\\x%02x", c);
1912             }
1913           es_fprintf (listfp, "\"\n");
1914         }
1915       iobuf_skip_rest (inp, pktlen, 0);
1916       return 0;
1917     }
1918   else if (version == 4)
1919     is_v4 = 1;
1920   else if (version != 2 && version != 3)
1921     {
1922       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1923       err = gpg_error (GPG_ERR_INV_PACKET);
1924       goto leave;
1925     }
1926
1927   if (pktlen < 11)
1928     {
1929       log_error ("packet(%d) too short\n", pkttype);
1930       err = gpg_error (GPG_ERR_INV_PACKET);
1931       goto leave;
1932     }
1933
1934   timestamp = read_32 (inp);
1935   pktlen -= 4;
1936   if (is_v4)
1937     {
1938       expiredate = 0;           /* have to get it from the selfsignature */
1939       max_expiredate = 0;
1940     }
1941   else
1942     {
1943       unsigned short ndays;
1944       ndays = read_16 (inp);
1945       pktlen -= 2;
1946       if (ndays)
1947         expiredate = timestamp + ndays * 86400L;
1948       else
1949         expiredate = 0;
1950
1951       max_expiredate = expiredate;
1952     }
1953   algorithm = iobuf_get_noeof (inp);
1954   pktlen--;
1955   if (list_mode)
1956     es_fprintf (listfp, ":%s key packet:\n"
1957                 "\tversion %d, algo %d, created %lu, expires %lu\n",
1958                 pkttype == PKT_PUBLIC_KEY ? "public" :
1959                 pkttype == PKT_SECRET_KEY ? "secret" :
1960                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
1961                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
1962                 version, algorithm, timestamp, expiredate);
1963
1964   pk->timestamp = timestamp;
1965   pk->expiredate = expiredate;
1966   pk->max_expiredate = max_expiredate;
1967   pk->hdrbytes = hdrlen;
1968   pk->version = version;
1969   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
1970   pk->pubkey_algo = algorithm;
1971
1972   nskey = pubkey_get_nskey (algorithm);
1973   npkey = pubkey_get_npkey (algorithm);
1974   if (!npkey)
1975     {
1976       if (list_mode)
1977         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
1978       unknown_pubkey_warning (algorithm);
1979     }
1980
1981   if (!npkey)
1982     {
1983       /* Unknown algorithm - put data into an opaque MPI.  */
1984       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
1985                                          read_rest (inp, pktlen, 0),
1986                                          pktlen * 8);
1987       pktlen = 0;
1988       goto leave;
1989     }
1990   else
1991     {
1992       for (i = 0; i < npkey; i++)
1993         {
1994           if ((algorithm == PUBKEY_ALGO_ECDSA
1995                || algorithm == PUBKEY_ALGO_ECDH) && (i==0 || i == 2))
1996             {
1997               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
1998               pktlen -= n;
1999             }
2000           else
2001             {
2002               n = pktlen;
2003               pk->pkey[i] = mpi_read (inp, &n, 0);
2004               pktlen -= n;
2005               if (!pk->pkey[i])
2006                 err = gpg_error (GPG_ERR_INV_PACKET);
2007             }
2008           if (err)
2009             goto leave;
2010           if (list_mode)
2011             {
2012               es_fprintf (listfp, "\tpkey[%d]: ", i);
2013               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2014               es_putc ('\n', listfp);
2015             }
2016         }
2017     }
2018   if (list_mode)
2019     keyid_from_pk (pk, keyid);
2020
2021   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2022     {
2023       struct seckey_info *ski;
2024       byte temp[16];
2025       size_t snlen = 0;
2026
2027       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2028       if (!pk->seckey_info)
2029         {
2030           err = gpg_error_from_syserror ();
2031           goto leave;
2032         }
2033
2034       ski->algo = iobuf_get_noeof (inp);
2035       pktlen--;
2036       if (ski->algo)
2037         {
2038           ski->is_protected = 1;
2039           ski->s2k.count = 0;
2040           if (ski->algo == 254 || ski->algo == 255)
2041             {
2042               if (pktlen < 3)
2043                 {
2044                   err = gpg_error (GPG_ERR_INV_PACKET);
2045                   goto leave;
2046                 }
2047               ski->sha1chk = (ski->algo == 254);
2048               ski->algo = iobuf_get_noeof (inp);
2049               pktlen--;
2050               /* Note that a ski->algo > 110 is illegal, but I'm not
2051                  erroring on it here as otherwise there would be no
2052                  way to delete such a key.  */
2053               ski->s2k.mode = iobuf_get_noeof (inp);
2054               pktlen--;
2055               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2056               pktlen--;
2057               /* Check for the special GNU extension.  */
2058               if (is_v4 && ski->s2k.mode == 101)
2059                 {
2060                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2061                     temp[i] = iobuf_get_noeof (inp);
2062                   if (i < 4 || memcmp (temp, "GNU", 3))
2063                     {
2064                       if (list_mode)
2065                         es_fprintf (listfp, "\tunknown S2K %d\n",
2066                                     ski->s2k.mode);
2067                       err = gpg_error (GPG_ERR_INV_PACKET);
2068                       goto leave;
2069                     }
2070                   /* Here we know that it is a GNU extension.  What
2071                    * follows is the GNU protection mode: All values
2072                    * have special meanings and they are mapped to MODE
2073                    * with a base of 1000.  */
2074                   ski->s2k.mode = 1000 + temp[3];
2075                 }
2076
2077               /* Read the salt.  */
2078               switch (ski->s2k.mode)
2079                 {
2080                 case 1:
2081                 case 3:
2082                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2083                     temp[i] = iobuf_get_noeof (inp);
2084                   memcpy (ski->s2k.salt, temp, 8);
2085                   break;
2086                 }
2087
2088               /* Check the mode.  */
2089               switch (ski->s2k.mode)
2090                 {
2091                 case 0:
2092                   if (list_mode)
2093                     es_fprintf (listfp, "\tsimple S2K");
2094                   break;
2095                 case 1:
2096                   if (list_mode)
2097                     es_fprintf (listfp, "\tsalted S2K");
2098                   break;
2099                 case 3:
2100                   if (list_mode)
2101                     es_fprintf (listfp, "\titer+salt S2K");
2102                   break;
2103                 case 1001:
2104                   if (list_mode)
2105                     es_fprintf (listfp, "\tgnu-dummy S2K");
2106                   break;
2107                 case 1002:
2108                   if (list_mode)
2109                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2110                   break;
2111                 default:
2112                   if (list_mode)
2113                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2114                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2115                                 ski->s2k.mode);
2116                   err = gpg_error (GPG_ERR_INV_PACKET);
2117                   goto leave;
2118                 }
2119
2120               /* Print some info.  */
2121               if (list_mode)
2122                 {
2123                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2124                               ski->algo,
2125                               ski->sha1chk ? " SHA1 protection,"
2126                               : " simple checksum,", ski->s2k.hash_algo);
2127                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2128                     {
2129                       es_fprintf (listfp, ", salt: ");
2130                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2131                     }
2132                   es_putc ('\n', listfp);
2133                 }
2134
2135               /* Read remaining protection parameters.  */
2136               if (ski->s2k.mode == 3)
2137                 {
2138                   if (pktlen < 1)
2139                     {
2140                       err = gpg_error (GPG_ERR_INV_PACKET);
2141                       goto leave;
2142                     }
2143                   ski->s2k.count = iobuf_get (inp);
2144                   pktlen--;
2145                   if (list_mode)
2146                     es_fprintf (listfp, "\tprotect count: %lu\n",
2147                                 (ulong) ski->s2k.count);
2148                 }
2149               else if (ski->s2k.mode == 1002)
2150                 {
2151                   /* Read the serial number. */
2152                   if (pktlen < 1)
2153                     {
2154                       err = gpg_error (GPG_ERR_INV_PACKET);
2155                       goto leave;
2156                     }
2157                   snlen = iobuf_get (inp);
2158                   pktlen--;
2159                   if (pktlen < snlen || snlen == (size_t)(-1))
2160                     {
2161                       err = gpg_error (GPG_ERR_INV_PACKET);
2162                       goto leave;
2163                     }
2164                 }
2165             }
2166           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2167             {
2168               /* Note that a ski->algo > 110 is illegal, but I'm not
2169                  erroring on it here as otherwise there would be no
2170                  way to delete such a key.  */
2171               ski->s2k.mode = 0;
2172               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2173               if (list_mode)
2174                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2175                             ski->algo, ski->s2k.hash_algo);
2176             }
2177
2178           /* It is really ugly that we don't know the size
2179            * of the IV here in cases we are not aware of the algorithm.
2180            * so a
2181            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2182            * won't work.  The only solution I see is to hardwire it.
2183            * NOTE: if you change the ivlen above 16, don't forget to
2184            * enlarge temp.  */
2185           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2186           assert (ski->ivlen <= sizeof (temp));
2187
2188           if (ski->s2k.mode == 1001)
2189             ski->ivlen = 0;
2190           else if (ski->s2k.mode == 1002)
2191             ski->ivlen = snlen < 16 ? snlen : 16;
2192
2193           if (pktlen < ski->ivlen)
2194             {
2195               err = gpg_error (GPG_ERR_INV_PACKET);
2196               goto leave;
2197             }
2198           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2199             temp[i] = iobuf_get_noeof (inp);
2200           if (list_mode)
2201             {
2202               es_fprintf (listfp,
2203                           ski->s2k.mode == 1002 ? "\tserial-number: "
2204                           : "\tprotect IV: ");
2205               for (i = 0; i < ski->ivlen; i++)
2206                 es_fprintf (listfp, " %02x", temp[i]);
2207               es_putc ('\n', listfp);
2208             }
2209           memcpy (ski->iv, temp, ski->ivlen);
2210         }
2211
2212       /* It does not make sense to read it into secure memory.
2213        * If the user is so careless, not to protect his secret key,
2214        * we can assume, that he operates an open system :=(.
2215        * So we put the key into secure memory when we unprotect it. */
2216       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2217         {
2218           /* Better set some dummy stuff here.  */
2219           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2220                                                  xstrdup ("dummydata"),
2221                                                  10 * 8);
2222           pktlen = 0;
2223         }
2224       else if (is_v4 && ski->is_protected)
2225         {
2226           /* Ugly: The length is encrypted too, so we read all stuff
2227            * up to the end of the packet into the first SKEY
2228            * element.  */
2229           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2230                                                  read_rest (inp, pktlen, 0),
2231                                                  pktlen * 8);
2232           pktlen = 0;
2233           if (list_mode)
2234             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2235         }
2236       else
2237         {
2238           /* The v3 method: The mpi length is not encrypted.  */
2239           for (i = npkey; i < nskey; i++)
2240             {
2241               if (ski->is_protected)
2242                 {
2243                   pk->pkey[i] = read_protected_v3_mpi (inp, &pktlen);
2244                   if (list_mode)
2245                     es_fprintf (listfp, "\tskey[%d]: [v3 protected]\n", i);
2246                 }
2247               else
2248                 {
2249                   n = pktlen;
2250                   pk->pkey[i] = mpi_read (inp, &n, 0);
2251                   pktlen -= n;
2252                   if (list_mode)
2253                     {
2254                       es_fprintf (listfp, "\tskey[%d]: ", i);
2255                       mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2256                       es_putc ('\n', listfp);
2257                     }
2258                 }
2259
2260               if (!pk->pkey[i])
2261                 err = gpg_error (GPG_ERR_INV_PACKET);
2262             }
2263           if (err)
2264             goto leave;
2265
2266           ski->csum = read_16 (inp);
2267           pktlen -= 2;
2268           if (list_mode)
2269             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2270         }
2271     }
2272
2273   if (list_mode)
2274     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2275                 (ulong) keyid[0], (ulong) keyid[1]);
2276
2277  leave:
2278   iobuf_skip_rest (inp, pktlen, 0);
2279   return rc;
2280 }
2281
2282
2283 /* Attribute subpackets have the same format as v4 signature
2284    subpackets.  This is not part of OpenPGP, but is done in several
2285    versions of PGP nevertheless.  */
2286 int
2287 parse_attribute_subpkts (PKT_user_id * uid)
2288 {
2289   size_t n;
2290   int count = 0;
2291   struct user_attribute *attribs = NULL;
2292   const byte *buffer = uid->attrib_data;
2293   int buflen = uid->attrib_len;
2294   byte type;
2295
2296   xfree (uid->attribs);
2297
2298   while (buflen)
2299     {
2300       n = *buffer++;
2301       buflen--;
2302       if (n == 255)  /* 4 byte length header.  */
2303         {
2304           if (buflen < 4)
2305             goto too_short;
2306           n = (buffer[0] << 24) | (buffer[1] << 16)
2307             | (buffer[2] << 8) | buffer[3];
2308           buffer += 4;
2309           buflen -= 4;
2310         }
2311       else if (n >= 192)  /* 2 byte special encoded length header.  */
2312         {
2313           if (buflen < 2)
2314             goto too_short;
2315           n = ((n - 192) << 8) + *buffer + 192;
2316           buffer++;
2317           buflen--;
2318         }
2319       if (buflen < n)
2320         goto too_short;
2321
2322       attribs =
2323         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2324       memset (&attribs[count], 0, sizeof (struct user_attribute));
2325
2326       type = *buffer;
2327       buffer++;
2328       buflen--;
2329       n--;
2330
2331       attribs[count].type = type;
2332       attribs[count].data = buffer;
2333       attribs[count].len = n;
2334       buffer += n;
2335       buflen -= n;
2336       count++;
2337     }
2338
2339   uid->attribs = attribs;
2340   uid->numattribs = count;
2341   return count;
2342
2343  too_short:
2344   if (opt.verbose)
2345     log_info ("buffer shorter than attribute subpacket\n");
2346   uid->attribs = attribs;
2347   uid->numattribs = count;
2348   return count;
2349 }
2350
2351
2352 static int
2353 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2354 {
2355   byte *p;
2356
2357   /* Cap the size of a user ID at 2k: a value absurdly large enough
2358      that there is no sane user ID string (which is printable text
2359      as of RFC2440bis) that won't fit in it, but yet small enough to
2360      avoid allocation problems.  A large pktlen may not be
2361      allocatable, and a very large pktlen could actually cause our
2362      allocation to wrap around in xmalloc to a small number. */
2363
2364   if (pktlen > 2048)
2365     {
2366       log_error ("packet(%d) too large\n", pkttype);
2367       iobuf_skip_rest (inp, pktlen, 0);
2368       return G10ERR_INVALID_PACKET;
2369     }
2370
2371   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2372   packet->pkt.user_id->len = pktlen;
2373   packet->pkt.user_id->ref = 1;
2374
2375   p = packet->pkt.user_id->name;
2376   for (; pktlen; pktlen--, p++)
2377     *p = iobuf_get_noeof (inp);
2378   *p = 0;
2379
2380   if (list_mode)
2381     {
2382       int n = packet->pkt.user_id->len;
2383       es_fprintf (listfp, ":user ID packet: \"");
2384       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2385       for (p = packet->pkt.user_id->name; n; p++, n--)
2386         {
2387           if (*p >= ' ' && *p <= 'z')
2388             es_putc (*p, listfp);
2389           else
2390             es_fprintf (listfp, "\\x%02x", *p);
2391         }
2392       es_fprintf (listfp, "\"\n");
2393     }
2394   return 0;
2395 }
2396
2397
2398 void
2399 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2400 {
2401   assert (max_namelen > 70);
2402   if (uid->numattribs <= 0)
2403     sprintf (uid->name, "[bad attribute packet of size %lu]",
2404              uid->attrib_len);
2405   else if (uid->numattribs > 1)
2406     sprintf (uid->name, "[%d attributes of size %lu]",
2407              uid->numattribs, uid->attrib_len);
2408   else
2409     {
2410       /* Only one attribute, so list it as the "user id" */
2411
2412       if (uid->attribs->type == ATTRIB_IMAGE)
2413         {
2414           u32 len;
2415           byte type;
2416
2417           if (parse_image_header (uid->attribs, &type, &len))
2418             sprintf (uid->name, "[%.20s image of size %lu]",
2419                      image_type_to_string (type, 1), (ulong) len);
2420           else
2421             sprintf (uid->name, "[invalid image]");
2422         }
2423       else
2424         sprintf (uid->name, "[unknown attribute of size %lu]",
2425                  (ulong) uid->attribs->len);
2426     }
2427
2428   uid->len = strlen (uid->name);
2429 }
2430
2431
2432 static int
2433 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2434                  PACKET * packet)
2435 {
2436   byte *p;
2437
2438   (void) pkttype;
2439
2440 #define EXTRA_UID_NAME_SPACE 71
2441   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2442                                        + EXTRA_UID_NAME_SPACE);
2443   packet->pkt.user_id->ref = 1;
2444   packet->pkt.user_id->attrib_data = xmalloc (pktlen);
2445   packet->pkt.user_id->attrib_len = pktlen;
2446
2447   p = packet->pkt.user_id->attrib_data;
2448   for (; pktlen; pktlen--, p++)
2449     *p = iobuf_get_noeof (inp);
2450
2451   /* Now parse out the individual attribute subpackets.  This is
2452      somewhat pointless since there is only one currently defined
2453      attribute type (jpeg), but it is correct by the spec. */
2454   parse_attribute_subpkts (packet->pkt.user_id);
2455
2456   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2457
2458   if (list_mode)
2459     {
2460       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2461     }
2462   return 0;
2463 }
2464
2465
2466 static int
2467 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2468 {
2469   byte *p;
2470
2471   /* Cap comment packet at a reasonable value to avoid an integer
2472      overflow in the malloc below.  Comment packets are actually not
2473      anymore define my OpenPGP and we even stopped to use our
2474      private comment packet.  */
2475   if (pktlen > 65536)
2476     {
2477       log_error ("packet(%d) too large\n", pkttype);
2478       iobuf_skip_rest (inp, pktlen, 0);
2479       return G10ERR_INVALID_PACKET;
2480     }
2481   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2482   packet->pkt.comment->len = pktlen;
2483   p = packet->pkt.comment->data;
2484   for (; pktlen; pktlen--, p++)
2485     *p = iobuf_get_noeof (inp);
2486
2487   if (list_mode)
2488     {
2489       int n = packet->pkt.comment->len;
2490       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2491                   "OpenPGP draft " : "");
2492       for (p = packet->pkt.comment->data; n; p++, n--)
2493         {
2494           if (*p >= ' ' && *p <= 'z')
2495             es_putc (*p, listfp);
2496           else
2497             es_fprintf (listfp, "\\x%02x", *p);
2498         }
2499       es_fprintf (listfp, "\"\n");
2500     }
2501   return 0;
2502 }
2503
2504
2505 static void
2506 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2507 {
2508   int c;
2509
2510   (void) pkttype;
2511
2512   if (pktlen)
2513     {
2514       c = iobuf_get_noeof (inp);
2515       pktlen--;
2516       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2517       pkt->pkt.ring_trust->trustval = c;
2518       pkt->pkt.ring_trust->sigcache = 0;
2519       if (!c && pktlen == 1)
2520         {
2521           c = iobuf_get_noeof (inp);
2522           pktlen--;
2523           /* We require that bit 7 of the sigcache is 0 (easier eof
2524              handling).  */
2525           if (!(c & 0x80))
2526             pkt->pkt.ring_trust->sigcache = c;
2527         }
2528       if (list_mode)
2529         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2530                     pkt->pkt.ring_trust->trustval,
2531                     pkt->pkt.ring_trust->sigcache);
2532     }
2533   else
2534     {
2535       if (list_mode)
2536         es_fprintf (listfp, ":trust packet: empty\n");
2537     }
2538   iobuf_skip_rest (inp, pktlen, 0);
2539 }
2540
2541
2542 static int
2543 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2544                  PACKET * pkt, int new_ctb, int partial)
2545 {
2546   int rc = 0;
2547   int mode, namelen;
2548   PKT_plaintext *pt;
2549   byte *p;
2550   int c, i;
2551
2552   if (!partial && pktlen < 6)
2553     {
2554       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2555       rc = gpg_error (GPG_ERR_INV_PACKET);
2556       goto leave;
2557     }
2558   mode = iobuf_get_noeof (inp);
2559   if (pktlen)
2560     pktlen--;
2561   namelen = iobuf_get_noeof (inp);
2562   if (pktlen)
2563     pktlen--;
2564   /* Note that namelen will never exceed 255 bytes. */
2565   pt = pkt->pkt.plaintext =
2566     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2567   pt->new_ctb = new_ctb;
2568   pt->mode = mode;
2569   pt->namelen = namelen;
2570   pt->is_partial = partial;
2571   if (pktlen)
2572     {
2573       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2574         pt->name[i] = iobuf_get_noeof (inp);
2575     }
2576   else
2577     {
2578       for (i = 0; i < namelen; i++)
2579         if ((c = iobuf_get (inp)) == -1)
2580           break;
2581         else
2582           pt->name[i] = c;
2583     }
2584   pt->timestamp = read_32 (inp);
2585   if (pktlen)
2586     pktlen -= 4;
2587   pt->len = pktlen;
2588   pt->buf = inp;
2589   pktlen = 0;
2590
2591   if (list_mode)
2592     {
2593       es_fprintf (listfp, ":literal data packet:\n"
2594                   "\tmode %c (%X), created %lu, name=\"",
2595                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2596                   (ulong) pt->timestamp);
2597       for (p = pt->name, i = 0; i < namelen; p++, i++)
2598         {
2599           if (*p >= ' ' && *p <= 'z')
2600             es_putc (*p, listfp);
2601           else
2602             es_fprintf (listfp, "\\x%02x", *p);
2603         }
2604       es_fprintf (listfp, "\",\n\traw data: ");
2605       if (partial)
2606         es_fprintf (listfp, "unknown length\n");
2607       else
2608         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2609     }
2610
2611  leave:
2612   return rc;
2613 }
2614
2615
2616 static int
2617 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2618                   PACKET * pkt, int new_ctb)
2619 {
2620   PKT_compressed *zd;
2621
2622   /* PKTLEN is here 0, but data follows (this should be the last
2623      object in a file or the compress algorithm should know the
2624      length).  */
2625   (void) pkttype;
2626   (void) pktlen;
2627
2628   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2629   zd->algorithm = iobuf_get_noeof (inp);
2630   zd->len = 0;                  /* not used */
2631   zd->new_ctb = new_ctb;
2632   zd->buf = inp;
2633   if (list_mode)
2634     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2635   return 0;
2636 }
2637
2638
2639 static int
2640 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2641                  PACKET * pkt, int new_ctb, int partial)
2642 {
2643   int rc = 0;
2644   PKT_encrypted *ed;
2645   unsigned long orig_pktlen = pktlen;
2646
2647   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2648   /* ed->len is set below.  */
2649   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2650   ed->buf = NULL;
2651   ed->new_ctb = new_ctb;
2652   ed->is_partial = partial;
2653   if (pkttype == PKT_ENCRYPTED_MDC)
2654     {
2655       /* Fixme: add some pktlen sanity checks.  */
2656       int version;
2657
2658       version = iobuf_get_noeof (inp);
2659       if (orig_pktlen)
2660         pktlen--;
2661       if (version != 1)
2662         {
2663           log_error ("encrypted_mdc packet with unknown version %d\n",
2664                      version);
2665           /*skip_rest(inp, pktlen); should we really do this? */
2666           rc = gpg_error (GPG_ERR_INV_PACKET);
2667           goto leave;
2668         }
2669       ed->mdc_method = DIGEST_ALGO_SHA1;
2670     }
2671   else
2672     ed->mdc_method = 0;
2673
2674   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2675      detection bytes.  Note that we don't known the algorithm and thus
2676      we may only check against the minimum blocksize.  */
2677   if (orig_pktlen && pktlen < 10)
2678     {
2679       /* Actually this is blocksize+2.  */
2680       log_error ("packet(%d) too short\n", pkttype);
2681       rc = G10ERR_INVALID_PACKET;
2682       iobuf_skip_rest (inp, pktlen, partial);
2683       goto leave;
2684     }
2685
2686   /* Store the remaining length of the encrypted data (i.e. without
2687      the MDC version number but with the IV etc.).  This value is
2688      required during decryption.  */
2689   ed->len = pktlen;
2690
2691   if (list_mode)
2692     {
2693       if (orig_pktlen)
2694         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2695                     orig_pktlen);
2696       else
2697         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2698       if (ed->mdc_method)
2699         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2700     }
2701
2702   ed->buf = inp;
2703
2704  leave:
2705   return rc;
2706 }
2707
2708
2709 /* Note, that this code is not anymore used in real life because the
2710    MDC checking is now done right after the decryption in
2711    decrypt_data.  */
2712 static int
2713 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2714            PACKET * pkt, int new_ctb)
2715 {
2716   int rc = 0;
2717   PKT_mdc *mdc;
2718   byte *p;
2719
2720   (void) pkttype;
2721
2722   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2723   if (list_mode)
2724     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2725   if (!new_ctb || pktlen != 20)
2726     {
2727       log_error ("mdc_packet with invalid encoding\n");
2728       rc = gpg_error (GPG_ERR_INV_PACKET);
2729       goto leave;
2730     }
2731   p = mdc->hash;
2732   for (; pktlen; pktlen--, p++)
2733     *p = iobuf_get_noeof (inp);
2734
2735  leave:
2736   return rc;
2737 }
2738
2739
2740 /*
2741  * This packet is internally generated by us (ibn armor.c) to transfer
2742  * some information to the lower layer.  To make sure that this packet
2743  * is really a GPG faked one and not one comming from outside, we
2744  * first check that there is a unique tag in it.
2745  *
2746  * The format of such a control packet is:
2747  *   n byte  session marker
2748  *   1 byte  control type CTRLPKT_xxxxx
2749  *   m byte  control data
2750  */
2751 static int
2752 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2753                    PACKET * packet, int partial)
2754 {
2755   byte *p;
2756   const byte *sesmark;
2757   size_t sesmarklen;
2758   int i;
2759
2760   (void) pkttype;
2761
2762   if (list_mode)
2763     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2764
2765   sesmark = get_session_marker (&sesmarklen);
2766   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2767     goto skipit;
2768   for (i = 0; i < sesmarklen; i++, pktlen--)
2769     {
2770       if (sesmark[i] != iobuf_get_noeof (inp))
2771         goto skipit;
2772     }
2773   if (pktlen > 4096)
2774     goto skipit;  /* Definitely too large.  We skip it to avoid an
2775                      overflow in the malloc.  */
2776   if (list_mode)
2777     puts ("- gpg control packet");
2778
2779   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2780                                      + pktlen - 1);
2781   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2782   pktlen--;
2783   packet->pkt.gpg_control->datalen = pktlen;
2784   p = packet->pkt.gpg_control->data;
2785   for (; pktlen; pktlen--, p++)
2786     *p = iobuf_get_noeof (inp);
2787
2788   return 0;
2789
2790  skipit:
2791   if (list_mode)
2792     {
2793       int c;
2794
2795       i = 0;
2796       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2797       if (partial)
2798         {
2799           while ((c = iobuf_get (inp)) != -1)
2800             dump_hex_line (c, &i);
2801         }
2802       else
2803         {
2804           for (; pktlen; pktlen--)
2805             {
2806               dump_hex_line ((c = iobuf_get (inp)), &i);
2807               if (c == -1)
2808                 break;
2809             }
2810         }
2811       es_putc ('\n', listfp);
2812     }
2813   iobuf_skip_rest (inp, pktlen, 0);
2814   return gpg_error (GPG_ERR_INV_PACKET);
2815 }
2816
2817
2818 /* Create a GPG control packet to be used internally as a placeholder.  */
2819 PACKET *
2820 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2821 {
2822   PACKET *packet;
2823   byte *p;
2824
2825   packet = xmalloc (sizeof *packet);
2826   init_packet (packet);
2827   packet->pkttype = PKT_GPG_CONTROL;
2828   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2829                                      + datalen - 1);
2830   packet->pkt.gpg_control->control = type;
2831   packet->pkt.gpg_control->datalen = datalen;
2832   p = packet->pkt.gpg_control->data;
2833   for (; datalen; datalen--, p++)
2834     *p = *data++;
2835
2836   return packet;
2837 }