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