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