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