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