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