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