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