gpg: Cleanup compiler warnings due to some configure options.
[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_EDDSA && (i == 0))
1994                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
1995             {
1996               /* Read the OID (i==1) or the KDF params (i==2).  */
1997               size_t n;
1998               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
1999               pktlen -= n;
2000             }
2001           else
2002             {
2003               unsigned int n = pktlen;
2004               pk->pkey[i] = mpi_read (inp, &n, 0);
2005               pktlen -= n;
2006               if (!pk->pkey[i])
2007                 err = gpg_error (GPG_ERR_INV_PACKET);
2008             }
2009           if (err)
2010             goto leave;
2011           if (list_mode)
2012             {
2013               es_fprintf (listfp, "\tpkey[%d]: ", i);
2014               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2015               if ((algorithm == PUBKEY_ALGO_ECDSA
2016                    || algorithm == PUBKEY_ALGO_EDDSA
2017                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2018                 {
2019                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2020                   es_fprintf (listfp, " %s (%s)",
2021                               openpgp_oid_to_curve (curve), curve);
2022                   xfree (curve);
2023                 }
2024               es_putc ('\n', listfp);
2025             }
2026         }
2027     }
2028   if (list_mode)
2029     keyid_from_pk (pk, keyid);
2030
2031   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2032     {
2033       struct seckey_info *ski;
2034       byte temp[16];
2035       size_t snlen = 0;
2036
2037       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2038       if (!pk->seckey_info)
2039         {
2040           err = gpg_error_from_syserror ();
2041           goto leave;
2042         }
2043
2044       ski->algo = iobuf_get_noeof (inp);
2045       pktlen--;
2046       if (ski->algo)
2047         {
2048           ski->is_protected = 1;
2049           ski->s2k.count = 0;
2050           if (ski->algo == 254 || ski->algo == 255)
2051             {
2052               if (pktlen < 3)
2053                 {
2054                   err = gpg_error (GPG_ERR_INV_PACKET);
2055                   goto leave;
2056                 }
2057               ski->sha1chk = (ski->algo == 254);
2058               ski->algo = iobuf_get_noeof (inp);
2059               pktlen--;
2060               /* Note that a ski->algo > 110 is illegal, but I'm not
2061                  erroring on it here as otherwise there would be no
2062                  way to delete such a key.  */
2063               ski->s2k.mode = iobuf_get_noeof (inp);
2064               pktlen--;
2065               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2066               pktlen--;
2067               /* Check for the special GNU extension.  */
2068               if (is_v4 && ski->s2k.mode == 101)
2069                 {
2070                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2071                     temp[i] = iobuf_get_noeof (inp);
2072                   if (i < 4 || memcmp (temp, "GNU", 3))
2073                     {
2074                       if (list_mode)
2075                         es_fprintf (listfp, "\tunknown S2K %d\n",
2076                                     ski->s2k.mode);
2077                       err = gpg_error (GPG_ERR_INV_PACKET);
2078                       goto leave;
2079                     }
2080                   /* Here we know that it is a GNU extension.  What
2081                    * follows is the GNU protection mode: All values
2082                    * have special meanings and they are mapped to MODE
2083                    * with a base of 1000.  */
2084                   ski->s2k.mode = 1000 + temp[3];
2085                 }
2086
2087               /* Read the salt.  */
2088               switch (ski->s2k.mode)
2089                 {
2090                 case 1:
2091                 case 3:
2092                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2093                     temp[i] = iobuf_get_noeof (inp);
2094                   memcpy (ski->s2k.salt, temp, 8);
2095                   break;
2096                 }
2097
2098               /* Check the mode.  */
2099               switch (ski->s2k.mode)
2100                 {
2101                 case 0:
2102                   if (list_mode)
2103                     es_fprintf (listfp, "\tsimple S2K");
2104                   break;
2105                 case 1:
2106                   if (list_mode)
2107                     es_fprintf (listfp, "\tsalted S2K");
2108                   break;
2109                 case 3:
2110                   if (list_mode)
2111                     es_fprintf (listfp, "\titer+salt S2K");
2112                   break;
2113                 case 1001:
2114                   if (list_mode)
2115                     es_fprintf (listfp, "\tgnu-dummy S2K");
2116                   break;
2117                 case 1002:
2118                   if (list_mode)
2119                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2120                   break;
2121                 default:
2122                   if (list_mode)
2123                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2124                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2125                                 ski->s2k.mode);
2126                   err = gpg_error (GPG_ERR_INV_PACKET);
2127                   goto leave;
2128                 }
2129
2130               /* Print some info.  */
2131               if (list_mode)
2132                 {
2133                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2134                               ski->algo,
2135                               ski->sha1chk ? " SHA1 protection,"
2136                               : " simple checksum,", ski->s2k.hash_algo);
2137                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2138                     {
2139                       es_fprintf (listfp, ", salt: ");
2140                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2141                     }
2142                   es_putc ('\n', listfp);
2143                 }
2144
2145               /* Read remaining protection parameters.  */
2146               if (ski->s2k.mode == 3)
2147                 {
2148                   if (pktlen < 1)
2149                     {
2150                       err = gpg_error (GPG_ERR_INV_PACKET);
2151                       goto leave;
2152                     }
2153                   ski->s2k.count = iobuf_get (inp);
2154                   pktlen--;
2155                   if (list_mode)
2156                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2157                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2158                                 (ulong) ski->s2k.count);
2159                 }
2160               else if (ski->s2k.mode == 1002)
2161                 {
2162                   /* Read the serial number. */
2163                   if (pktlen < 1)
2164                     {
2165                       err = gpg_error (GPG_ERR_INV_PACKET);
2166                       goto leave;
2167                     }
2168                   snlen = iobuf_get (inp);
2169                   pktlen--;
2170                   if (pktlen < snlen || snlen == (size_t)(-1))
2171                     {
2172                       err = gpg_error (GPG_ERR_INV_PACKET);
2173                       goto leave;
2174                     }
2175                 }
2176             }
2177           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2178             {
2179               /* Note that a ski->algo > 110 is illegal, but I'm not
2180                  erroring on it here as otherwise there would be no
2181                  way to delete such a key.  */
2182               ski->s2k.mode = 0;
2183               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2184               if (list_mode)
2185                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2186                             ski->algo, ski->s2k.hash_algo);
2187             }
2188
2189           /* It is really ugly that we don't know the size
2190            * of the IV here in cases we are not aware of the algorithm.
2191            * so a
2192            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2193            * won't work.  The only solution I see is to hardwire it.
2194            * NOTE: if you change the ivlen above 16, don't forget to
2195            * enlarge temp.  */
2196           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2197           assert (ski->ivlen <= sizeof (temp));
2198
2199           if (ski->s2k.mode == 1001)
2200             ski->ivlen = 0;
2201           else if (ski->s2k.mode == 1002)
2202             ski->ivlen = snlen < 16 ? snlen : 16;
2203
2204           if (pktlen < ski->ivlen)
2205             {
2206               err = gpg_error (GPG_ERR_INV_PACKET);
2207               goto leave;
2208             }
2209           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2210             temp[i] = iobuf_get_noeof (inp);
2211           if (list_mode)
2212             {
2213               es_fprintf (listfp,
2214                           ski->s2k.mode == 1002 ? "\tserial-number: "
2215                           : "\tprotect IV: ");
2216               for (i = 0; i < ski->ivlen; i++)
2217                 es_fprintf (listfp, " %02x", temp[i]);
2218               es_putc ('\n', listfp);
2219             }
2220           memcpy (ski->iv, temp, ski->ivlen);
2221         }
2222
2223       /* It does not make sense to read it into secure memory.
2224        * If the user is so careless, not to protect his secret key,
2225        * we can assume, that he operates an open system :=(.
2226        * So we put the key into secure memory when we unprotect it. */
2227       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2228         {
2229           /* Better set some dummy stuff here.  */
2230           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2231                                                  xstrdup ("dummydata"),
2232                                                  10 * 8);
2233           pktlen = 0;
2234         }
2235       else if (is_v4 && ski->is_protected)
2236         {
2237           /* Ugly: The length is encrypted too, so we read all stuff
2238            * up to the end of the packet into the first SKEY
2239            * element.  */
2240           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2241                                                  read_rest (inp, pktlen),
2242                                                  pktlen * 8);
2243           pktlen = 0;
2244           if (list_mode)
2245             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2246         }
2247       else
2248         {
2249           /* The v3 method: The mpi length is not encrypted.  */
2250           for (i = npkey; i < nskey; i++)
2251             {
2252               if (ski->is_protected)
2253                 {
2254                   pk->pkey[i] = read_protected_v3_mpi (inp, &pktlen);
2255                   if (list_mode)
2256                     es_fprintf (listfp, "\tskey[%d]: [v3 protected]\n", i);
2257                 }
2258               else
2259                 {
2260                   unsigned int n = pktlen;
2261                   pk->pkey[i] = mpi_read (inp, &n, 0);
2262                   pktlen -= n;
2263                   if (list_mode)
2264                     {
2265                       es_fprintf (listfp, "\tskey[%d]: ", i);
2266                       mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2267                       es_putc ('\n', listfp);
2268                     }
2269                 }
2270
2271               if (!pk->pkey[i])
2272                 err = gpg_error (GPG_ERR_INV_PACKET);
2273             }
2274           if (err)
2275             goto leave;
2276
2277           ski->csum = read_16 (inp);
2278           pktlen -= 2;
2279           if (list_mode)
2280             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2281         }
2282     }
2283
2284   if (list_mode)
2285     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2286                 (ulong) keyid[0], (ulong) keyid[1]);
2287
2288  leave:
2289   iobuf_skip_rest (inp, pktlen, 0);
2290   return rc;
2291 }
2292
2293
2294 /* Attribute subpackets have the same format as v4 signature
2295    subpackets.  This is not part of OpenPGP, but is done in several
2296    versions of PGP nevertheless.  */
2297 int
2298 parse_attribute_subpkts (PKT_user_id * uid)
2299 {
2300   size_t n;
2301   int count = 0;
2302   struct user_attribute *attribs = NULL;
2303   const byte *buffer = uid->attrib_data;
2304   int buflen = uid->attrib_len;
2305   byte type;
2306
2307   xfree (uid->attribs);
2308
2309   while (buflen)
2310     {
2311       n = *buffer++;
2312       buflen--;
2313       if (n == 255)  /* 4 byte length header.  */
2314         {
2315           if (buflen < 4)
2316             goto too_short;
2317           n = (buffer[0] << 24) | (buffer[1] << 16)
2318             | (buffer[2] << 8) | buffer[3];
2319           buffer += 4;
2320           buflen -= 4;
2321         }
2322       else if (n >= 192)  /* 2 byte special encoded length header.  */
2323         {
2324           if (buflen < 2)
2325             goto too_short;
2326           n = ((n - 192) << 8) + *buffer + 192;
2327           buffer++;
2328           buflen--;
2329         }
2330       if (buflen < n)
2331         goto too_short;
2332
2333       attribs =
2334         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2335       memset (&attribs[count], 0, sizeof (struct user_attribute));
2336
2337       type = *buffer;
2338       buffer++;
2339       buflen--;
2340       n--;
2341
2342       attribs[count].type = type;
2343       attribs[count].data = buffer;
2344       attribs[count].len = n;
2345       buffer += n;
2346       buflen -= n;
2347       count++;
2348     }
2349
2350   uid->attribs = attribs;
2351   uid->numattribs = count;
2352   return count;
2353
2354  too_short:
2355   if (opt.verbose)
2356     log_info ("buffer shorter than attribute subpacket\n");
2357   uid->attribs = attribs;
2358   uid->numattribs = count;
2359   return count;
2360 }
2361
2362
2363 static int
2364 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2365 {
2366   byte *p;
2367
2368   /* Cap the size of a user ID at 2k: a value absurdly large enough
2369      that there is no sane user ID string (which is printable text
2370      as of RFC2440bis) that won't fit in it, but yet small enough to
2371      avoid allocation problems.  A large pktlen may not be
2372      allocatable, and a very large pktlen could actually cause our
2373      allocation to wrap around in xmalloc to a small number. */
2374
2375   if (pktlen > 2048)
2376     {
2377       log_error ("packet(%d) too large\n", pkttype);
2378       iobuf_skip_rest (inp, pktlen, 0);
2379       return G10ERR_INVALID_PACKET;
2380     }
2381
2382   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2383   packet->pkt.user_id->len = pktlen;
2384   packet->pkt.user_id->ref = 1;
2385
2386   p = packet->pkt.user_id->name;
2387   for (; pktlen; pktlen--, p++)
2388     *p = iobuf_get_noeof (inp);
2389   *p = 0;
2390
2391   if (list_mode)
2392     {
2393       int n = packet->pkt.user_id->len;
2394       es_fprintf (listfp, ":user ID packet: \"");
2395       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2396       for (p = packet->pkt.user_id->name; n; p++, n--)
2397         {
2398           if (*p >= ' ' && *p <= 'z')
2399             es_putc (*p, listfp);
2400           else
2401             es_fprintf (listfp, "\\x%02x", *p);
2402         }
2403       es_fprintf (listfp, "\"\n");
2404     }
2405   return 0;
2406 }
2407
2408
2409 void
2410 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2411 {
2412   assert (max_namelen > 70);
2413   if (uid->numattribs <= 0)
2414     sprintf (uid->name, "[bad attribute packet of size %lu]",
2415              uid->attrib_len);
2416   else if (uid->numattribs > 1)
2417     sprintf (uid->name, "[%d attributes of size %lu]",
2418              uid->numattribs, uid->attrib_len);
2419   else
2420     {
2421       /* Only one attribute, so list it as the "user id" */
2422
2423       if (uid->attribs->type == ATTRIB_IMAGE)
2424         {
2425           u32 len;
2426           byte type;
2427
2428           if (parse_image_header (uid->attribs, &type, &len))
2429             sprintf (uid->name, "[%.20s image of size %lu]",
2430                      image_type_to_string (type, 1), (ulong) len);
2431           else
2432             sprintf (uid->name, "[invalid image]");
2433         }
2434       else
2435         sprintf (uid->name, "[unknown attribute of size %lu]",
2436                  (ulong) uid->attribs->len);
2437     }
2438
2439   uid->len = strlen (uid->name);
2440 }
2441
2442
2443 static int
2444 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2445                  PACKET * packet)
2446 {
2447   byte *p;
2448
2449   (void) pkttype;
2450
2451 #define EXTRA_UID_NAME_SPACE 71
2452   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2453                                        + EXTRA_UID_NAME_SPACE);
2454   packet->pkt.user_id->ref = 1;
2455   packet->pkt.user_id->attrib_data = xmalloc (pktlen);
2456   packet->pkt.user_id->attrib_len = pktlen;
2457
2458   p = packet->pkt.user_id->attrib_data;
2459   for (; pktlen; pktlen--, p++)
2460     *p = iobuf_get_noeof (inp);
2461
2462   /* Now parse out the individual attribute subpackets.  This is
2463      somewhat pointless since there is only one currently defined
2464      attribute type (jpeg), but it is correct by the spec. */
2465   parse_attribute_subpkts (packet->pkt.user_id);
2466
2467   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2468
2469   if (list_mode)
2470     {
2471       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2472     }
2473   return 0;
2474 }
2475
2476
2477 static int
2478 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2479 {
2480   byte *p;
2481
2482   /* Cap comment packet at a reasonable value to avoid an integer
2483      overflow in the malloc below.  Comment packets are actually not
2484      anymore define my OpenPGP and we even stopped to use our
2485      private comment packet.  */
2486   if (pktlen > 65536)
2487     {
2488       log_error ("packet(%d) too large\n", pkttype);
2489       iobuf_skip_rest (inp, pktlen, 0);
2490       return G10ERR_INVALID_PACKET;
2491     }
2492   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2493   packet->pkt.comment->len = pktlen;
2494   p = packet->pkt.comment->data;
2495   for (; pktlen; pktlen--, p++)
2496     *p = iobuf_get_noeof (inp);
2497
2498   if (list_mode)
2499     {
2500       int n = packet->pkt.comment->len;
2501       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2502                   "OpenPGP draft " : "");
2503       for (p = packet->pkt.comment->data; n; p++, n--)
2504         {
2505           if (*p >= ' ' && *p <= 'z')
2506             es_putc (*p, listfp);
2507           else
2508             es_fprintf (listfp, "\\x%02x", *p);
2509         }
2510       es_fprintf (listfp, "\"\n");
2511     }
2512   return 0;
2513 }
2514
2515
2516 static void
2517 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2518 {
2519   int c;
2520
2521   (void) pkttype;
2522
2523   if (pktlen)
2524     {
2525       c = iobuf_get_noeof (inp);
2526       pktlen--;
2527       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2528       pkt->pkt.ring_trust->trustval = c;
2529       pkt->pkt.ring_trust->sigcache = 0;
2530       if (!c && pktlen == 1)
2531         {
2532           c = iobuf_get_noeof (inp);
2533           pktlen--;
2534           /* We require that bit 7 of the sigcache is 0 (easier eof
2535              handling).  */
2536           if (!(c & 0x80))
2537             pkt->pkt.ring_trust->sigcache = c;
2538         }
2539       if (list_mode)
2540         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2541                     pkt->pkt.ring_trust->trustval,
2542                     pkt->pkt.ring_trust->sigcache);
2543     }
2544   else
2545     {
2546       if (list_mode)
2547         es_fprintf (listfp, ":trust packet: empty\n");
2548     }
2549   iobuf_skip_rest (inp, pktlen, 0);
2550 }
2551
2552
2553 static int
2554 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2555                  PACKET * pkt, int new_ctb, int partial)
2556 {
2557   int rc = 0;
2558   int mode, namelen;
2559   PKT_plaintext *pt;
2560   byte *p;
2561   int c, i;
2562
2563   if (!partial && pktlen < 6)
2564     {
2565       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2566       rc = gpg_error (GPG_ERR_INV_PACKET);
2567       goto leave;
2568     }
2569   mode = iobuf_get_noeof (inp);
2570   if (pktlen)
2571     pktlen--;
2572   namelen = iobuf_get_noeof (inp);
2573   if (pktlen)
2574     pktlen--;
2575   /* Note that namelen will never exceed 255 bytes. */
2576   pt = pkt->pkt.plaintext =
2577     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2578   pt->new_ctb = new_ctb;
2579   pt->mode = mode;
2580   pt->namelen = namelen;
2581   pt->is_partial = partial;
2582   if (pktlen)
2583     {
2584       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2585         pt->name[i] = iobuf_get_noeof (inp);
2586     }
2587   else
2588     {
2589       for (i = 0; i < namelen; i++)
2590         if ((c = iobuf_get (inp)) == -1)
2591           break;
2592         else
2593           pt->name[i] = c;
2594     }
2595   pt->timestamp = read_32 (inp);
2596   if (pktlen)
2597     pktlen -= 4;
2598   pt->len = pktlen;
2599   pt->buf = inp;
2600   pktlen = 0;
2601
2602   if (list_mode)
2603     {
2604       es_fprintf (listfp, ":literal data packet:\n"
2605                   "\tmode %c (%X), created %lu, name=\"",
2606                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2607                   (ulong) pt->timestamp);
2608       for (p = pt->name, i = 0; i < namelen; p++, i++)
2609         {
2610           if (*p >= ' ' && *p <= 'z')
2611             es_putc (*p, listfp);
2612           else
2613             es_fprintf (listfp, "\\x%02x", *p);
2614         }
2615       es_fprintf (listfp, "\",\n\traw data: ");
2616       if (partial)
2617         es_fprintf (listfp, "unknown length\n");
2618       else
2619         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2620     }
2621
2622  leave:
2623   return rc;
2624 }
2625
2626
2627 static int
2628 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2629                   PACKET * pkt, int new_ctb)
2630 {
2631   PKT_compressed *zd;
2632
2633   /* PKTLEN is here 0, but data follows (this should be the last
2634      object in a file or the compress algorithm should know the
2635      length).  */
2636   (void) pkttype;
2637   (void) pktlen;
2638
2639   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2640   zd->algorithm = iobuf_get_noeof (inp);
2641   zd->len = 0;                  /* not used */
2642   zd->new_ctb = new_ctb;
2643   zd->buf = inp;
2644   if (list_mode)
2645     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2646   return 0;
2647 }
2648
2649
2650 static int
2651 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2652                  PACKET * pkt, int new_ctb, int partial)
2653 {
2654   int rc = 0;
2655   PKT_encrypted *ed;
2656   unsigned long orig_pktlen = pktlen;
2657
2658   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2659   /* ed->len is set below.  */
2660   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2661   ed->buf = NULL;
2662   ed->new_ctb = new_ctb;
2663   ed->is_partial = partial;
2664   if (pkttype == PKT_ENCRYPTED_MDC)
2665     {
2666       /* Fixme: add some pktlen sanity checks.  */
2667       int version;
2668
2669       version = iobuf_get_noeof (inp);
2670       if (orig_pktlen)
2671         pktlen--;
2672       if (version != 1)
2673         {
2674           log_error ("encrypted_mdc packet with unknown version %d\n",
2675                      version);
2676           /*skip_rest(inp, pktlen); should we really do this? */
2677           rc = gpg_error (GPG_ERR_INV_PACKET);
2678           goto leave;
2679         }
2680       ed->mdc_method = DIGEST_ALGO_SHA1;
2681     }
2682   else
2683     ed->mdc_method = 0;
2684
2685   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2686      detection bytes.  Note that we don't known the algorithm and thus
2687      we may only check against the minimum blocksize.  */
2688   if (orig_pktlen && pktlen < 10)
2689     {
2690       /* Actually this is blocksize+2.  */
2691       log_error ("packet(%d) too short\n", pkttype);
2692       rc = G10ERR_INVALID_PACKET;
2693       iobuf_skip_rest (inp, pktlen, partial);
2694       goto leave;
2695     }
2696
2697   /* Store the remaining length of the encrypted data (i.e. without
2698      the MDC version number but with the IV etc.).  This value is
2699      required during decryption.  */
2700   ed->len = pktlen;
2701
2702   if (list_mode)
2703     {
2704       if (orig_pktlen)
2705         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2706                     orig_pktlen);
2707       else
2708         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2709       if (ed->mdc_method)
2710         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2711     }
2712
2713   ed->buf = inp;
2714
2715  leave:
2716   return rc;
2717 }
2718
2719
2720 /* Note, that this code is not anymore used in real life because the
2721    MDC checking is now done right after the decryption in
2722    decrypt_data.  */
2723 static int
2724 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2725            PACKET * pkt, int new_ctb)
2726 {
2727   int rc = 0;
2728   PKT_mdc *mdc;
2729   byte *p;
2730
2731   (void) pkttype;
2732
2733   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2734   if (list_mode)
2735     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2736   if (!new_ctb || pktlen != 20)
2737     {
2738       log_error ("mdc_packet with invalid encoding\n");
2739       rc = gpg_error (GPG_ERR_INV_PACKET);
2740       goto leave;
2741     }
2742   p = mdc->hash;
2743   for (; pktlen; pktlen--, p++)
2744     *p = iobuf_get_noeof (inp);
2745
2746  leave:
2747   return rc;
2748 }
2749
2750
2751 /*
2752  * This packet is internally generated by us (ibn armor.c) to transfer
2753  * some information to the lower layer.  To make sure that this packet
2754  * is really a GPG faked one and not one comming from outside, we
2755  * first check that there is a unique tag in it.
2756  *
2757  * The format of such a control packet is:
2758  *   n byte  session marker
2759  *   1 byte  control type CTRLPKT_xxxxx
2760  *   m byte  control data
2761  */
2762 static int
2763 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2764                    PACKET * packet, int partial)
2765 {
2766   byte *p;
2767   const byte *sesmark;
2768   size_t sesmarklen;
2769   int i;
2770
2771   (void) pkttype;
2772
2773   if (list_mode)
2774     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2775
2776   sesmark = get_session_marker (&sesmarklen);
2777   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2778     goto skipit;
2779   for (i = 0; i < sesmarklen; i++, pktlen--)
2780     {
2781       if (sesmark[i] != iobuf_get_noeof (inp))
2782         goto skipit;
2783     }
2784   if (pktlen > 4096)
2785     goto skipit;  /* Definitely too large.  We skip it to avoid an
2786                      overflow in the malloc.  */
2787   if (list_mode)
2788     puts ("- gpg control packet");
2789
2790   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2791                                      + pktlen - 1);
2792   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2793   pktlen--;
2794   packet->pkt.gpg_control->datalen = pktlen;
2795   p = packet->pkt.gpg_control->data;
2796   for (; pktlen; pktlen--, p++)
2797     *p = iobuf_get_noeof (inp);
2798
2799   return 0;
2800
2801  skipit:
2802   if (list_mode)
2803     {
2804       int c;
2805
2806       i = 0;
2807       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2808       if (partial)
2809         {
2810           while ((c = iobuf_get (inp)) != -1)
2811             dump_hex_line (c, &i);
2812         }
2813       else
2814         {
2815           for (; pktlen; pktlen--)
2816             {
2817               dump_hex_line ((c = iobuf_get (inp)), &i);
2818               if (c == -1)
2819                 break;
2820             }
2821         }
2822       es_putc ('\n', listfp);
2823     }
2824   iobuf_skip_rest (inp, pktlen, 0);
2825   return gpg_error (GPG_ERR_INV_PACKET);
2826 }
2827
2828
2829 /* Create a GPG control packet to be used internally as a placeholder.  */
2830 PACKET *
2831 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2832 {
2833   PACKET *packet;
2834   byte *p;
2835
2836   packet = xmalloc (sizeof *packet);
2837   init_packet (packet);
2838   packet->pkttype = PKT_GPG_CONTROL;
2839   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2840                                      + datalen - 1);
2841   packet->pkt.gpg_control->control = type;
2842   packet->pkt.gpg_control->datalen = datalen;
2843   p = packet->pkt.gpg_control->data;
2844   for (; datalen; datalen--, p++)
2845     *p = *data++;
2846
2847   return packet;
2848 }