Some doc fixes and a fix for "make distcheck".
[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   return rc;
662 }
663
664
665 static void
666 dump_hex_line (int c, int *i)
667 {
668   if (*i && !(*i % 8))
669     {
670       if (*i && !(*i % 24))
671         es_fprintf (listfp, "\n%4d:", *i);
672       else
673         es_putc (' ', listfp);
674     }
675   if (c == -1)
676     es_fprintf (listfp, " EOF");
677   else
678     es_fprintf (listfp, " %02x", c);
679   ++*i;
680 }
681
682
683 static int
684 copy_packet (IOBUF inp, IOBUF out, int pkttype,
685              unsigned long pktlen, int partial)
686 {
687   int rc;
688   int n;
689   char buf[100];
690
691   if (partial)
692     {
693       while ((n = iobuf_read (inp, buf, 100)) != -1)
694         if ((rc = iobuf_write (out, buf, n)))
695           return rc;            /* write error */
696     }
697   else if (!pktlen && pkttype == PKT_COMPRESSED)
698     {
699       log_debug ("copy_packet: compressed!\n");
700       /* compressed packet, copy till EOF */
701       while ((n = iobuf_read (inp, buf, 100)) != -1)
702         if ((rc = iobuf_write (out, buf, n)))
703           return rc;            /* write error */
704     }
705   else
706     {
707       for (; pktlen; pktlen -= n)
708         {
709           n = pktlen > 100 ? 100 : pktlen;
710           n = iobuf_read (inp, buf, n);
711           if (n == -1)
712             return gpg_error (GPG_ERR_EOF);
713           if ((rc = iobuf_write (out, buf, n)))
714             return rc;          /* write error */
715         }
716     }
717   return 0;
718 }
719
720
721 static void
722 skip_packet (IOBUF inp, int pkttype, unsigned long pktlen, int partial)
723 {
724   if (list_mode)
725     {
726       es_fprintf (listfp, ":unknown packet: type %2d, length %lu\n",
727                   pkttype, pktlen);
728       if (pkttype)
729         {
730           int c, i = 0;
731           es_fputs ("dump:", listfp);
732           if (partial)
733             {
734               while ((c = iobuf_get (inp)) != -1)
735                 dump_hex_line (c, &i);
736             }
737           else
738             {
739               for (; pktlen; pktlen--)
740                 {
741                   dump_hex_line ((c = iobuf_get (inp)), &i);
742                   if (c == -1)
743                     break;
744                 }
745             }
746           es_putc ('\n', listfp);
747           return;
748         }
749     }
750   iobuf_skip_rest (inp, pktlen, partial);
751 }
752
753
754 /* Read PKTLEN bytes form INP and return them in a newly allocated
755    buffer.  In case of an error NULL is returned and a error messages
756    printed.  */
757 static void *
758 read_rest (IOBUF inp, size_t pktlen)
759 {
760   int c;
761   byte *buf, *p;
762
763   buf = xtrymalloc (pktlen);
764   if (!buf)
765     {
766       gpg_error_t err = gpg_error_from_syserror ();
767       log_error ("error reading rest of packet: %s\n", gpg_strerror (err));
768       return NULL;
769     }
770   for (p = buf; pktlen; pktlen--)
771     {
772       c = iobuf_get (inp);
773       if (c == -1)
774         {
775           log_error ("premature eof while reading rest of packet\n");
776           xfree (buf);
777           return NULL;
778         }
779       *p++ = c;
780     }
781
782   return buf;
783 }
784
785
786 /* Read a special size+body from INP.  On success store an opaque MPI
787    with it at R_DATA.  On error return an error code and store NULL at
788    R_DATA.  Even in the error case store the number of read bytes at
789    R_NREAD.  The caller shall pass the remaining size of the packet in
790    PKTLEN.  */
791 static gpg_error_t
792 read_size_body (iobuf_t inp, int pktlen, size_t *r_nread,
793                 gcry_mpi_t *r_data)
794 {
795   char buffer[256];
796   char *tmpbuf;
797   int i, c, nbytes;
798
799   *r_nread = 0;
800   *r_data = NULL;
801
802   if (!pktlen)
803     return gpg_error (GPG_ERR_INV_PACKET);
804   c = iobuf_readbyte (inp);
805   if (c < 0)
806     return gpg_error (GPG_ERR_INV_PACKET);
807   pktlen--;
808   ++*r_nread;
809   nbytes = c;
810   if (nbytes < 2 || nbytes > 254)
811     return gpg_error (GPG_ERR_INV_PACKET);
812   if (nbytes > pktlen)
813     return gpg_error (GPG_ERR_INV_PACKET);
814
815   buffer[0] = nbytes;
816
817   for (i = 0; i < nbytes; i++)
818     {
819       c = iobuf_get (inp);
820       if (c < 0)
821         return gpg_error (GPG_ERR_INV_PACKET);
822       ++*r_nread;
823       buffer[1+i] = c;
824     }
825
826   tmpbuf = xtrymalloc (1 + nbytes);
827   if (!tmpbuf)
828     return gpg_error_from_syserror ();
829   memcpy (tmpbuf, buffer, 1 + nbytes);
830   *r_data = gcry_mpi_set_opaque (NULL, tmpbuf, 8 * (1 + nbytes));
831   if (!*r_data)
832     {
833       xfree (tmpbuf);
834       return gpg_error_from_syserror ();
835     }
836   return 0;
837 }
838
839
840 /* Parse a marker packet.  */
841 static int
842 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
843 {
844   (void) pkttype;
845
846   if (pktlen != 3)
847     goto fail;
848
849   if (iobuf_get (inp) != 'P')
850     {
851       pktlen--;
852       goto fail;
853     }
854
855   if (iobuf_get (inp) != 'G')
856     {
857       pktlen--;
858       goto fail;
859     }
860
861   if (iobuf_get (inp) != 'P')
862     {
863       pktlen--;
864       goto fail;
865     }
866
867   if (list_mode)
868     es_fputs (":marker packet: PGP\n", listfp);
869
870   return 0;
871
872  fail:
873   log_error ("invalid marker packet\n");
874   if (list_mode)
875     es_fputs (":marker packet: [invalid]\n", listfp);
876   iobuf_skip_rest (inp, pktlen, 0);
877   return G10ERR_INVALID_PACKET;
878 }
879
880
881 static int
882 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
883                  PACKET * packet)
884 {
885   PKT_symkey_enc *k;
886   int rc = 0;
887   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
888
889   if (pktlen < 4)
890     {
891       log_error ("packet(%d) too short\n", pkttype);
892       if (list_mode)
893         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
894       rc = gpg_error (GPG_ERR_INV_PACKET);
895       goto leave;
896     }
897   version = iobuf_get_noeof (inp);
898   pktlen--;
899   if (version != 4)
900     {
901       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
902       if (list_mode)
903         es_fprintf (listfp, ":symkey enc packet: [unknown version]\n");
904       rc = gpg_error (GPG_ERR_INV_PACKET);
905       goto leave;
906     }
907   if (pktlen > 200)
908     {                           /* (we encode the seskeylen in a byte) */
909       log_error ("packet(%d) too large\n", pkttype);
910       if (list_mode)
911         es_fprintf (listfp, ":symkey enc packet: [too large]\n");
912       rc = gpg_error (GPG_ERR_INV_PACKET);
913       goto leave;
914     }
915   cipher_algo = iobuf_get_noeof (inp);
916   pktlen--;
917   s2kmode = iobuf_get_noeof (inp);
918   pktlen--;
919   hash_algo = iobuf_get_noeof (inp);
920   pktlen--;
921   switch (s2kmode)
922     {
923     case 0: /* Simple S2K.  */
924       minlen = 0;
925       break;
926     case 1: /* Salted S2K.  */
927       minlen = 8;
928       break;
929     case 3: /* Iterated+salted S2K.  */
930       minlen = 9;
931       break;
932     default:
933       log_error ("unknown S2K mode %d\n", s2kmode);
934       if (list_mode)
935         es_fprintf (listfp, ":symkey enc packet: [unknown S2K mode]\n");
936       goto leave;
937     }
938   if (minlen > pktlen)
939     {
940       log_error ("packet with S2K %d too short\n", s2kmode);
941       if (list_mode)
942         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
943       rc = gpg_error (GPG_ERR_INV_PACKET);
944       goto leave;
945     }
946   seskeylen = pktlen - minlen;
947   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
948                                               + seskeylen - 1);
949   k->version = version;
950   k->cipher_algo = cipher_algo;
951   k->s2k.mode = s2kmode;
952   k->s2k.hash_algo = hash_algo;
953   if (s2kmode == 1 || s2kmode == 3)
954     {
955       for (i = 0; i < 8 && pktlen; i++, pktlen--)
956         k->s2k.salt[i] = iobuf_get_noeof (inp);
957     }
958   if (s2kmode == 3)
959     {
960       k->s2k.count = iobuf_get (inp);
961       pktlen--;
962     }
963   k->seskeylen = seskeylen;
964   if (k->seskeylen)
965     {
966       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
967         k->seskey[i] = iobuf_get_noeof (inp);
968
969       /* What we're watching out for here is a session key decryptor
970          with no salt.  The RFC says that using salt for this is a
971          MUST. */
972       if (s2kmode != 1 && s2kmode != 3)
973         log_info (_("WARNING: potentially insecure symmetrically"
974                     " encrypted session key\n"));
975     }
976   assert (!pktlen);
977
978   if (list_mode)
979     {
980       es_fprintf (listfp,
981                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
982                   version, cipher_algo, s2kmode, hash_algo);
983       if (seskeylen)
984         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
985       es_fprintf (listfp, "\n");
986       if (s2kmode == 1 || s2kmode == 3)
987         {
988           es_fprintf (listfp, "\tsalt ");
989           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
990           if (s2kmode == 3)
991             es_fprintf (listfp, ", count %lu (%lu)",
992                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
993                         (ulong) k->s2k.count);
994           es_fprintf (listfp, "\n");
995         }
996     }
997
998  leave:
999   iobuf_skip_rest (inp, pktlen, 0);
1000   return rc;
1001 }
1002
1003
1004 static int
1005 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
1006                  PACKET * packet)
1007 {
1008   int rc = 0;
1009   int i, ndata;
1010   PKT_pubkey_enc *k;
1011
1012   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
1013   if (pktlen < 12)
1014     {
1015       log_error ("packet(%d) too short\n", pkttype);
1016       if (list_mode)
1017         es_fputs (":pubkey enc packet: [too short]\n", listfp);
1018       rc = gpg_error (GPG_ERR_INV_PACKET);
1019       goto leave;
1020     }
1021   k->version = iobuf_get_noeof (inp);
1022   pktlen--;
1023   if (k->version != 2 && k->version != 3)
1024     {
1025       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
1026       if (list_mode)
1027         es_fputs (":pubkey enc packet: [unknown version]\n", listfp);
1028       rc = gpg_error (GPG_ERR_INV_PACKET);
1029       goto leave;
1030     }
1031   k->keyid[0] = read_32 (inp);
1032   pktlen -= 4;
1033   k->keyid[1] = read_32 (inp);
1034   pktlen -= 4;
1035   k->pubkey_algo = iobuf_get_noeof (inp);
1036   pktlen--;
1037   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
1038   if (list_mode)
1039     es_fprintf (listfp,
1040                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
1041                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
1042                 (ulong) k->keyid[1]);
1043
1044   ndata = pubkey_get_nenc (k->pubkey_algo);
1045   if (!ndata)
1046     {
1047       if (list_mode)
1048         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
1049       unknown_pubkey_warning (k->pubkey_algo);
1050       k->data[0] = NULL; /* No need to store the encrypted data.  */
1051     }
1052   else
1053     {
1054       for (i = 0; i < ndata; i++)
1055         {
1056           if (k->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
1057             {
1058               size_t n;
1059               rc = read_size_body (inp, pktlen, &n, k->data+i);
1060               pktlen -= n;
1061             }
1062           else
1063             {
1064               int n = pktlen;
1065               k->data[i] = mpi_read (inp, &n, 0);
1066               pktlen -= n;
1067               if (!k->data[i])
1068                 rc = gpg_error (GPG_ERR_INV_PACKET);
1069             }
1070           if (rc)
1071             goto leave;
1072           if (list_mode)
1073             {
1074               es_fprintf (listfp, "\tdata: ");
1075               mpi_print (listfp, k->data[i], mpi_print_mode);
1076               es_putc ('\n', listfp);
1077             }
1078         }
1079     }
1080
1081  leave:
1082   iobuf_skip_rest (inp, pktlen, 0);
1083   return rc;
1084 }
1085
1086
1087 static void
1088 dump_sig_subpkt (int hashed, int type, int critical,
1089                  const byte * buffer, size_t buflen, size_t length)
1090 {
1091   const char *p = NULL;
1092   int i;
1093
1094   /* The CERT has warning out with explains how to use GNUPG to detect
1095    * the ARRs - we print our old message here when it is a faked ARR
1096    * and add an additional notice.  */
1097   if (type == SIGSUBPKT_ARR && !hashed)
1098     {
1099       es_fprintf (listfp,
1100                   "\tsubpkt %d len %u (additional recipient request)\n"
1101                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
1102                   "encrypt to this key and thereby reveal the plaintext to "
1103                   "the owner of this ARR key. Detailed info follows:\n",
1104                   type, (unsigned) length);
1105     }
1106
1107   buffer++;
1108   length--;
1109
1110   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
1111               critical ? "critical " : "",
1112               hashed ? "hashed " : "", type, (unsigned) length);
1113   if (length > buflen)
1114     {
1115       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
1116       return;
1117     }
1118   switch (type)
1119     {
1120     case SIGSUBPKT_SIG_CREATED:
1121       if (length >= 4)
1122         es_fprintf (listfp, "sig created %s",
1123                     strtimestamp (buffer_to_u32 (buffer)));
1124       break;
1125     case SIGSUBPKT_SIG_EXPIRE:
1126       if (length >= 4)
1127         {
1128           if (buffer_to_u32 (buffer))
1129             es_fprintf (listfp, "sig expires after %s",
1130                         strtimevalue (buffer_to_u32 (buffer)));
1131           else
1132             es_fprintf (listfp, "sig does not expire");
1133         }
1134       break;
1135     case SIGSUBPKT_EXPORTABLE:
1136       if (length)
1137         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1138       break;
1139     case SIGSUBPKT_TRUST:
1140       if (length != 2)
1141         p = "[invalid trust subpacket]";
1142       else
1143         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1144                     buffer[1]);
1145       break;
1146     case SIGSUBPKT_REGEXP:
1147       if (!length)
1148         p = "[invalid regexp subpacket]";
1149       else
1150         es_fprintf (listfp, "regular expression: \"%s\"", buffer);
1151       break;
1152     case SIGSUBPKT_REVOCABLE:
1153       if (length)
1154         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1155       break;
1156     case SIGSUBPKT_KEY_EXPIRE:
1157       if (length >= 4)
1158         {
1159           if (buffer_to_u32 (buffer))
1160             es_fprintf (listfp, "key expires after %s",
1161                         strtimevalue (buffer_to_u32 (buffer)));
1162           else
1163             es_fprintf (listfp, "key does not expire");
1164         }
1165       break;
1166     case SIGSUBPKT_PREF_SYM:
1167       es_fputs ("pref-sym-algos:", listfp);
1168       for (i = 0; i < length; i++)
1169         es_fprintf (listfp, " %d", buffer[i]);
1170       break;
1171     case SIGSUBPKT_REV_KEY:
1172       es_fputs ("revocation key: ", listfp);
1173       if (length < 22)
1174         p = "[too short]";
1175       else
1176         {
1177           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1178           for (i = 2; i < length; i++)
1179             es_fprintf (listfp, "%02X", buffer[i]);
1180         }
1181       break;
1182     case SIGSUBPKT_ISSUER:
1183       if (length >= 8)
1184         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1185                     (ulong) buffer_to_u32 (buffer),
1186                     (ulong) buffer_to_u32 (buffer + 4));
1187       break;
1188     case SIGSUBPKT_NOTATION:
1189       {
1190         es_fputs ("notation: ", listfp);
1191         if (length < 8)
1192           p = "[too short]";
1193         else
1194           {
1195             const byte *s = buffer;
1196             size_t n1, n2;
1197
1198             n1 = (s[4] << 8) | s[5];
1199             n2 = (s[6] << 8) | s[7];
1200             s += 8;
1201             if (8 + n1 + n2 != length)
1202               p = "[error]";
1203             else
1204               {
1205                 es_write_sanitized (listfp, s, n1, ")", NULL);
1206                 es_putc ('=', listfp);
1207
1208                 if (*buffer & 0x80)
1209                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1210                 else
1211                   p = "[not human readable]";
1212               }
1213           }
1214       }
1215       break;
1216     case SIGSUBPKT_PREF_HASH:
1217       es_fputs ("pref-hash-algos:", listfp);
1218       for (i = 0; i < length; i++)
1219         es_fprintf (listfp, " %d", buffer[i]);
1220       break;
1221     case SIGSUBPKT_PREF_COMPR:
1222       es_fputs ("pref-zip-algos:", listfp);
1223       for (i = 0; i < length; i++)
1224         es_fprintf (listfp, " %d", buffer[i]);
1225       break;
1226     case SIGSUBPKT_KS_FLAGS:
1227       es_fputs ("key server preferences:", listfp);
1228       for (i = 0; i < length; i++)
1229         es_fprintf (listfp, " %02X", buffer[i]);
1230       break;
1231     case SIGSUBPKT_PREF_KS:
1232       es_fputs ("preferred key server: ", listfp);
1233       es_write_sanitized (listfp, buffer, length, ")", NULL);
1234       break;
1235     case SIGSUBPKT_PRIMARY_UID:
1236       p = "primary user ID";
1237       break;
1238     case SIGSUBPKT_POLICY:
1239       es_fputs ("policy: ", listfp);
1240       es_write_sanitized (listfp, buffer, length, ")", NULL);
1241       break;
1242     case SIGSUBPKT_KEY_FLAGS:
1243       es_fputs ("key flags:", listfp);
1244       for (i = 0; i < length; i++)
1245         es_fprintf (listfp, " %02X", buffer[i]);
1246       break;
1247     case SIGSUBPKT_SIGNERS_UID:
1248       p = "signer's user ID";
1249       break;
1250     case SIGSUBPKT_REVOC_REASON:
1251       if (length)
1252         {
1253           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1254           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1255           p = ")";
1256         }
1257       break;
1258     case SIGSUBPKT_ARR:
1259       es_fputs ("Big Brother's key (ignored): ", listfp);
1260       if (length < 22)
1261         p = "[too short]";
1262       else
1263         {
1264           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1265           if (length > 2)
1266             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1267         }
1268       break;
1269     case SIGSUBPKT_FEATURES:
1270       es_fputs ("features:", listfp);
1271       for (i = 0; i < length; i++)
1272         es_fprintf (listfp, " %02x", buffer[i]);
1273       break;
1274     case SIGSUBPKT_SIGNATURE:
1275       es_fputs ("signature: ", listfp);
1276       if (length < 17)
1277         p = "[too short]";
1278       else
1279         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1280                     buffer[0],
1281                     buffer[0] == 3 ? buffer[2] : buffer[1],
1282                     buffer[0] == 3 ? buffer[15] : buffer[2],
1283                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1284       break;
1285     default:
1286       if (type >= 100 && type <= 110)
1287         p = "experimental / private subpacket";
1288       else
1289         p = "?";
1290       break;
1291     }
1292
1293   es_fprintf (listfp, "%s)\n", p ? p : "");
1294 }
1295
1296
1297 /*
1298  * Returns: >= 0 use this offset into buffer
1299  *          -1 explicitly reject returning this type
1300  *          -2 subpacket too short
1301  */
1302 int
1303 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1304 {
1305   switch (type)
1306     {
1307     case SIGSUBPKT_REV_KEY:
1308       if (n < 22)
1309         break;
1310       return 0;
1311     case SIGSUBPKT_SIG_CREATED:
1312     case SIGSUBPKT_SIG_EXPIRE:
1313     case SIGSUBPKT_KEY_EXPIRE:
1314       if (n < 4)
1315         break;
1316       return 0;
1317     case SIGSUBPKT_KEY_FLAGS:
1318     case SIGSUBPKT_KS_FLAGS:
1319     case SIGSUBPKT_PREF_SYM:
1320     case SIGSUBPKT_PREF_HASH:
1321     case SIGSUBPKT_PREF_COMPR:
1322     case SIGSUBPKT_POLICY:
1323     case SIGSUBPKT_PREF_KS:
1324     case SIGSUBPKT_FEATURES:
1325     case SIGSUBPKT_REGEXP:
1326       return 0;
1327     case SIGSUBPKT_SIGNATURE:
1328     case SIGSUBPKT_EXPORTABLE:
1329     case SIGSUBPKT_REVOCABLE:
1330     case SIGSUBPKT_REVOC_REASON:
1331       if (!n)
1332         break;
1333       return 0;
1334     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1335       if (n < 8)
1336         break;
1337       return 0;
1338     case SIGSUBPKT_NOTATION:
1339       /* minimum length needed, and the subpacket must be well-formed
1340          where the name length and value length all fit inside the
1341          packet. */
1342       if (n < 8
1343           || 8 + ((buffer[4] << 8) | buffer[5]) +
1344           ((buffer[6] << 8) | buffer[7]) != n)
1345         break;
1346       return 0;
1347     case SIGSUBPKT_PRIMARY_UID:
1348       if (n != 1)
1349         break;
1350       return 0;
1351     case SIGSUBPKT_TRUST:
1352       if (n != 2)
1353         break;
1354       return 0;
1355     default:
1356       return 0;
1357     }
1358   return -2;
1359 }
1360
1361
1362 /* Return true if we understand the critical notation.  */
1363 static int
1364 can_handle_critical_notation (const byte * name, size_t len)
1365 {
1366   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1367     return 1;
1368   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1369     return 1;
1370
1371   return 0;
1372 }
1373
1374
1375 static int
1376 can_handle_critical (const byte * buffer, size_t n, int type)
1377 {
1378   switch (type)
1379     {
1380     case SIGSUBPKT_NOTATION:
1381       if (n >= 8)
1382         return can_handle_critical_notation (buffer + 8,
1383                                              (buffer[4] << 8) | buffer[5]);
1384       else
1385         return 0;
1386     case SIGSUBPKT_SIGNATURE:
1387     case SIGSUBPKT_SIG_CREATED:
1388     case SIGSUBPKT_SIG_EXPIRE:
1389     case SIGSUBPKT_KEY_EXPIRE:
1390     case SIGSUBPKT_EXPORTABLE:
1391     case SIGSUBPKT_REVOCABLE:
1392     case SIGSUBPKT_REV_KEY:
1393     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1394     case SIGSUBPKT_PREF_SYM:
1395     case SIGSUBPKT_PREF_HASH:
1396     case SIGSUBPKT_PREF_COMPR:
1397     case SIGSUBPKT_KEY_FLAGS:
1398     case SIGSUBPKT_PRIMARY_UID:
1399     case SIGSUBPKT_FEATURES:
1400     case SIGSUBPKT_TRUST:
1401     case SIGSUBPKT_REGEXP:
1402       /* Is it enough to show the policy or keyserver? */
1403     case SIGSUBPKT_POLICY:
1404     case SIGSUBPKT_PREF_KS:
1405       return 1;
1406
1407     default:
1408       return 0;
1409     }
1410 }
1411
1412
1413 const byte *
1414 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1415                  size_t * ret_n, int *start, int *critical)
1416 {
1417   const byte *buffer;
1418   int buflen;
1419   int type;
1420   int critical_dummy;
1421   int offset;
1422   size_t n;
1423   int seq = 0;
1424   int reqseq = start ? *start : 0;
1425
1426   if (!critical)
1427     critical = &critical_dummy;
1428
1429   if (!pktbuf || reqseq == -1)
1430     {
1431       static char dummy[] = "x";
1432       /* Return a value different from NULL to indicate that
1433        * there is no critical bit we do not understand.  */
1434       return reqtype == SIGSUBPKT_TEST_CRITICAL ? dummy : NULL;
1435     }
1436   buffer = pktbuf->data;
1437   buflen = pktbuf->len;
1438   while (buflen)
1439     {
1440       n = *buffer++;
1441       buflen--;
1442       if (n == 255) /* 4 byte length header.  */
1443         {
1444           if (buflen < 4)
1445             goto too_short;
1446           n = (buffer[0] << 24) | (buffer[1] << 16)
1447             | (buffer[2] << 8) | buffer[3];
1448           buffer += 4;
1449           buflen -= 4;
1450         }
1451       else if (n >= 192) /* 4 byte special encoded length header.  */
1452         {
1453           if (buflen < 2)
1454             goto too_short;
1455           n = ((n - 192) << 8) + *buffer + 192;
1456           buffer++;
1457           buflen--;
1458         }
1459       if (buflen < n)
1460         goto too_short;
1461       type = *buffer;
1462       if (type & 0x80)
1463         {
1464           type &= 0x7f;
1465           *critical = 1;
1466         }
1467       else
1468         *critical = 0;
1469       if (!(++seq > reqseq))
1470         ;
1471       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1472         {
1473           if (*critical)
1474             {
1475               if (n - 1 > buflen + 1)
1476                 goto too_short;
1477               if (!can_handle_critical (buffer + 1, n - 1, type))
1478                 {
1479                   if (opt.verbose)
1480                     log_info (_("subpacket of type %d has "
1481                                 "critical bit set\n"), type);
1482                   if (start)
1483                     *start = seq;
1484                   return NULL;  /* This is an error.  */
1485                 }
1486             }
1487         }
1488       else if (reqtype < 0) /* List packets.  */
1489         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1490                          type, *critical, buffer, buflen, n);
1491       else if (type == reqtype) /* Found.  */
1492         {
1493           buffer++;
1494           n--;
1495           if (n > buflen)
1496             goto too_short;
1497           if (ret_n)
1498             *ret_n = n;
1499           offset = parse_one_sig_subpkt (buffer, n, type);
1500           switch (offset)
1501             {
1502             case -2:
1503               log_error ("subpacket of type %d too short\n", type);
1504               return NULL;
1505             case -1:
1506               return NULL;
1507             default:
1508               break;
1509             }
1510           if (start)
1511             *start = seq;
1512           return buffer + offset;
1513         }
1514       buffer += n;
1515       buflen -= n;
1516     }
1517   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1518     return buffer;  /* Used as True to indicate that there is no. */
1519
1520   /* Critical bit we don't understand. */
1521   if (start)
1522     *start = -1;
1523   return NULL;  /* End of packets; not found.  */
1524
1525  too_short:
1526   if (opt.verbose)
1527     log_info ("buffer shorter than subpacket\n");
1528   if (start)
1529     *start = -1;
1530   return NULL;
1531 }
1532
1533
1534 const byte *
1535 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1536                   size_t * ret_n)
1537 {
1538   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1539 }
1540
1541
1542 const byte *
1543 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype,
1544                    size_t * ret_n)
1545 {
1546   const byte *p;
1547
1548   p = parse_sig_subpkt (sig->hashed, reqtype, ret_n);
1549   if (!p)
1550     p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n);
1551   return p;
1552 }
1553
1554
1555 /* Find all revocation keys.  Look in hashed area only.  */
1556 void
1557 parse_revkeys (PKT_signature * sig)
1558 {
1559   struct revocation_key *revkey;
1560   int seq = 0;
1561   size_t len;
1562
1563   if (sig->sig_class != 0x1F)
1564     return;
1565
1566   while ((revkey =
1567           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1568                                                      SIGSUBPKT_REV_KEY,
1569                                                      &len, &seq, NULL)))
1570     {
1571       if (len == sizeof (struct revocation_key)
1572           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1573         {
1574           sig->revkey = xrealloc (sig->revkey,
1575                                   sizeof (struct revocation_key *) *
1576                                   (sig->numrevkeys + 1));
1577           sig->revkey[sig->numrevkeys] = revkey;
1578           sig->numrevkeys++;
1579         }
1580     }
1581 }
1582
1583
1584 int
1585 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1586                  PKT_signature * sig)
1587 {
1588   int md5_len = 0;
1589   unsigned n;
1590   int is_v4 = 0;
1591   int rc = 0;
1592   int i, ndata;
1593
1594   if (pktlen < 16)
1595     {
1596       log_error ("packet(%d) too short\n", pkttype);
1597       if (list_mode)
1598         es_fputs (":signature packet: [too short]\n", listfp);
1599       goto leave;
1600     }
1601   sig->version = iobuf_get_noeof (inp);
1602   pktlen--;
1603   if (sig->version == 4)
1604     is_v4 = 1;
1605   else if (sig->version != 2 && sig->version != 3)
1606     {
1607       log_error ("packet(%d) with unknown version %d\n",
1608                  pkttype, sig->version);
1609       if (list_mode)
1610         es_fputs (":signature packet: [unknown version]\n", listfp);
1611       rc = gpg_error (GPG_ERR_INV_PACKET);
1612       goto leave;
1613     }
1614
1615   if (!is_v4)
1616     {
1617       md5_len = iobuf_get_noeof (inp);
1618       pktlen--;
1619     }
1620   sig->sig_class = iobuf_get_noeof (inp);
1621   pktlen--;
1622   if (!is_v4)
1623     {
1624       sig->timestamp = read_32 (inp);
1625       pktlen -= 4;
1626       sig->keyid[0] = read_32 (inp);
1627       pktlen -= 4;
1628       sig->keyid[1] = read_32 (inp);
1629       pktlen -= 4;
1630     }
1631   sig->pubkey_algo = iobuf_get_noeof (inp);
1632   pktlen--;
1633   sig->digest_algo = iobuf_get_noeof (inp);
1634   pktlen--;
1635   sig->flags.exportable = 1;
1636   sig->flags.revocable = 1;
1637   if (is_v4) /* Read subpackets.  */
1638     {
1639       n = read_16 (inp);
1640       pktlen -= 2;  /* Length of hashed data. */
1641       if (n > 10000)
1642         {
1643           log_error ("signature packet: hashed data too long\n");
1644           if (list_mode)
1645             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1646           rc = G10ERR_INVALID_PACKET;
1647           goto leave;
1648         }
1649       if (n)
1650         {
1651           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1652           sig->hashed->size = n;
1653           sig->hashed->len = n;
1654           if (iobuf_read (inp, sig->hashed->data, n) != n)
1655             {
1656               log_error ("premature eof while reading "
1657                          "hashed signature data\n");
1658               if (list_mode)
1659                 es_fputs (":signature packet: [premature eof]\n", listfp);
1660               rc = -1;
1661               goto leave;
1662             }
1663           pktlen -= n;
1664         }
1665       n = read_16 (inp);
1666       pktlen -= 2;  /* Length of unhashed data.  */
1667       if (n > 10000)
1668         {
1669           log_error ("signature packet: unhashed data too long\n");
1670           if (list_mode)
1671             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1672           rc = G10ERR_INVALID_PACKET;
1673           goto leave;
1674         }
1675       if (n)
1676         {
1677           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1678           sig->unhashed->size = n;
1679           sig->unhashed->len = n;
1680           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1681             {
1682               log_error ("premature eof while reading "
1683                          "unhashed signature data\n");
1684               if (list_mode)
1685                 es_fputs (":signature packet: [premature eof]\n", listfp);
1686               rc = -1;
1687               goto leave;
1688             }
1689           pktlen -= n;
1690         }
1691     }
1692
1693   if (pktlen < 5)  /* Sanity check.  */
1694     {
1695       log_error ("packet(%d) too short\n", pkttype);
1696       if (list_mode)
1697         es_fputs (":signature packet: [too short]\n", listfp);
1698       rc = G10ERR_INVALID_PACKET;
1699       goto leave;
1700     }
1701
1702   sig->digest_start[0] = iobuf_get_noeof (inp);
1703   pktlen--;
1704   sig->digest_start[1] = iobuf_get_noeof (inp);
1705   pktlen--;
1706
1707   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1708     {
1709       const byte *p;
1710       size_t len;
1711
1712       /* Set sig->flags.unknown_critical if there is a critical bit
1713        * set for packets which we do not understand.  */
1714       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1715           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1716         sig->flags.unknown_critical = 1;
1717
1718       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1719       if (p)
1720         sig->timestamp = buffer_to_u32 (p);
1721       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1722                && opt.verbose)
1723         log_info ("signature packet without timestamp\n");
1724
1725       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER, NULL);
1726       if (p)
1727         {
1728           sig->keyid[0] = buffer_to_u32 (p);
1729           sig->keyid[1] = buffer_to_u32 (p + 4);
1730         }
1731       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1732                && opt.verbose)
1733         log_info ("signature packet without keyid\n");
1734
1735       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1736       if (p && buffer_to_u32 (p))
1737         sig->expiredate = sig->timestamp + buffer_to_u32 (p);
1738       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1739         sig->flags.expired = 1;
1740
1741       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1742       if (p)
1743         sig->flags.policy_url = 1;
1744
1745       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1746       if (p)
1747         sig->flags.pref_ks = 1;
1748
1749       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1750       if (p)
1751         sig->flags.notation = 1;
1752
1753       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1754       if (p && *p == 0)
1755         sig->flags.revocable = 0;
1756
1757       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1758       if (p && len == 2)
1759         {
1760           sig->trust_depth = p[0];
1761           sig->trust_value = p[1];
1762
1763           /* Only look for a regexp if there is also a trust
1764              subpacket. */
1765           sig->trust_regexp =
1766             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1767
1768           /* If the regular expression is of 0 length, there is no
1769              regular expression. */
1770           if (len == 0)
1771             sig->trust_regexp = NULL;
1772         }
1773
1774       /* We accept the exportable subpacket from either the hashed or
1775          unhashed areas as older versions of gpg put it in the
1776          unhashed area.  In theory, anyway, we should never see this
1777          packet off of a local keyring. */
1778
1779       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE, NULL);
1780       if (p && *p == 0)
1781         sig->flags.exportable = 0;
1782
1783       /* Find all revocation keys.  */
1784       if (sig->sig_class == 0x1F)
1785         parse_revkeys (sig);
1786     }
1787
1788   if (list_mode)
1789     {
1790       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1791                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1792                   "\tdigest algo %d, begin of digest %02x %02x\n",
1793                   sig->pubkey_algo,
1794                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1795                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1796                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1797       if (is_v4)
1798         {
1799           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1800           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1801         }
1802     }
1803
1804   ndata = pubkey_get_nsig (sig->pubkey_algo);
1805   if (!ndata)
1806     {
1807       if (list_mode)
1808         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1809       unknown_pubkey_warning (sig->pubkey_algo);
1810
1811       /* We store the plain material in data[0], so that we are able
1812        * to write it back with build_packet().  */
1813       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1814         {
1815           /* We include a limit to avoid too trivial DoS attacks by
1816              having gpg allocate too much memory.  */
1817           log_error ("signature packet: too much data\n");
1818           rc = G10ERR_INVALID_PACKET;
1819         }
1820       else
1821         {
1822           sig->data[0] =
1823             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
1824           pktlen = 0;
1825         }
1826     }
1827   else
1828     {
1829       for (i = 0; i < ndata; i++)
1830         {
1831           n = pktlen;
1832           sig->data[i] = mpi_read (inp, &n, 0);
1833           pktlen -= n;
1834           if (list_mode)
1835             {
1836               es_fprintf (listfp, "\tdata: ");
1837               mpi_print (listfp, sig->data[i], mpi_print_mode);
1838               es_putc ('\n', listfp);
1839             }
1840           if (!sig->data[i])
1841             rc = G10ERR_INVALID_PACKET;
1842         }
1843     }
1844
1845  leave:
1846   iobuf_skip_rest (inp, pktlen, 0);
1847   return rc;
1848 }
1849
1850
1851 static int
1852 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1853                    PKT_onepass_sig * ops)
1854 {
1855   int version;
1856   int rc = 0;
1857
1858   if (pktlen < 13)
1859     {
1860       log_error ("packet(%d) too short\n", pkttype);
1861       if (list_mode)
1862         es_fputs (":onepass_sig packet: [too short]\n", listfp);
1863       rc = gpg_error (GPG_ERR_INV_PACKET);
1864       goto leave;
1865     }
1866   version = iobuf_get_noeof (inp);
1867   pktlen--;
1868   if (version != 3)
1869     {
1870       log_error ("onepass_sig with unknown version %d\n", version);
1871       if (list_mode)
1872         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
1873       rc = gpg_error (GPG_ERR_INV_PACKET);
1874       goto leave;
1875     }
1876   ops->sig_class = iobuf_get_noeof (inp);
1877   pktlen--;
1878   ops->digest_algo = iobuf_get_noeof (inp);
1879   pktlen--;
1880   ops->pubkey_algo = iobuf_get_noeof (inp);
1881   pktlen--;
1882   ops->keyid[0] = read_32 (inp);
1883   pktlen -= 4;
1884   ops->keyid[1] = read_32 (inp);
1885   pktlen -= 4;
1886   ops->last = iobuf_get_noeof (inp);
1887   pktlen--;
1888   if (list_mode)
1889     es_fprintf (listfp,
1890                 ":onepass_sig packet: keyid %08lX%08lX\n"
1891                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1892                 "last=%d\n",
1893                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1894                 version, ops->sig_class,
1895                 ops->digest_algo, ops->pubkey_algo, ops->last);
1896
1897
1898  leave:
1899   iobuf_skip_rest (inp, pktlen, 0);
1900   return rc;
1901 }
1902
1903
1904 static gcry_mpi_t
1905 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1906 {
1907   int c;
1908   unsigned int nbits, nbytes;
1909   unsigned char *buf, *p;
1910   gcry_mpi_t val;
1911
1912   if (*length < 2)
1913     {
1914       log_error ("mpi too small\n");
1915       return NULL;
1916     }
1917
1918   if ((c = iobuf_get (inp)) == -1)
1919     return NULL;
1920   --*length;
1921   nbits = c << 8;
1922   if ((c = iobuf_get (inp)) == -1)
1923     return NULL;
1924   --*length;
1925   nbits |= c;
1926
1927   if (nbits > 16384)
1928     {
1929       log_error ("mpi too large (%u bits)\n", nbits);
1930       return NULL;
1931     }
1932   nbytes = (nbits + 7) / 8;
1933   buf = p = xmalloc (2 + nbytes);
1934   *p++ = nbits >> 8;
1935   *p++ = nbits;
1936   for (; nbytes && *length; nbytes--, --*length)
1937     *p++ = iobuf_get (inp);
1938   if (nbytes)
1939     {
1940       log_error ("packet shorter than mpi\n");
1941       xfree (buf);
1942       return NULL;
1943     }
1944
1945   /* Convert buffer into an opaque MPI.  */
1946   val = gcry_mpi_set_opaque (NULL, buf, (p - buf) * 8);
1947   return val;
1948 }
1949
1950
1951 static int
1952 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1953            byte * hdr, int hdrlen, PACKET * pkt)
1954 {
1955   gpg_error_t err = 0;
1956   int i, version, algorithm;
1957   unsigned long timestamp, expiredate, max_expiredate;
1958   int npkey, nskey;
1959   int is_v4 = 0;
1960   int rc = 0;
1961   u32 keyid[2];
1962   PKT_public_key *pk;
1963
1964   (void) hdr;
1965
1966   pk = pkt->pkt.public_key; /* PK has been cleared. */
1967
1968   version = iobuf_get_noeof (inp);
1969   pktlen--;
1970   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1971     {
1972       /* Early versions of G10 used the old PGP comments packets;
1973        * luckily all those comments are started by a hash.  */
1974       if (list_mode)
1975         {
1976           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1977           for (; pktlen; pktlen--)
1978             {
1979               int c;
1980               c = iobuf_get (inp);
1981               if (c == -1)
1982                 break; /* Ooops: shorter than indicated.  */
1983               if (c >= ' ' && c <= 'z')
1984                 es_putc (c, listfp);
1985               else
1986                 es_fprintf (listfp, "\\x%02x", c);
1987             }
1988           es_fprintf (listfp, "\"\n");
1989         }
1990       iobuf_skip_rest (inp, pktlen, 0);
1991       return 0;
1992     }
1993   else if (version == 4)
1994     is_v4 = 1;
1995   else if (version != 2 && version != 3)
1996     {
1997       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1998       if (list_mode)
1999         es_fputs (":key packet: [unknown version]\n", listfp);
2000       err = gpg_error (GPG_ERR_INV_PACKET);
2001       goto leave;
2002     }
2003
2004   if (pktlen < 11)
2005     {
2006       log_error ("packet(%d) too short\n", pkttype);
2007       if (list_mode)
2008         es_fputs (":key packet: [too short]\n", listfp);
2009       err = gpg_error (GPG_ERR_INV_PACKET);
2010       goto leave;
2011     }
2012
2013   timestamp = read_32 (inp);
2014   pktlen -= 4;
2015   if (is_v4)
2016     {
2017       expiredate = 0;           /* have to get it from the selfsignature */
2018       max_expiredate = 0;
2019     }
2020   else
2021     {
2022       unsigned short ndays;
2023       ndays = read_16 (inp);
2024       pktlen -= 2;
2025       if (ndays)
2026         expiredate = timestamp + ndays * 86400L;
2027       else
2028         expiredate = 0;
2029
2030       max_expiredate = expiredate;
2031     }
2032   algorithm = iobuf_get_noeof (inp);
2033   pktlen--;
2034   if (list_mode)
2035     es_fprintf (listfp, ":%s key packet:\n"
2036                 "\tversion %d, algo %d, created %lu, expires %lu\n",
2037                 pkttype == PKT_PUBLIC_KEY ? "public" :
2038                 pkttype == PKT_SECRET_KEY ? "secret" :
2039                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
2040                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
2041                 version, algorithm, timestamp, expiredate);
2042
2043   pk->timestamp = timestamp;
2044   pk->expiredate = expiredate;
2045   pk->max_expiredate = max_expiredate;
2046   pk->hdrbytes = hdrlen;
2047   pk->version = version;
2048   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
2049   pk->pubkey_algo = algorithm;
2050
2051   nskey = pubkey_get_nskey (algorithm);
2052   npkey = pubkey_get_npkey (algorithm);
2053   if (!npkey)
2054     {
2055       if (list_mode)
2056         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2057       unknown_pubkey_warning (algorithm);
2058     }
2059
2060   if (!npkey)
2061     {
2062       /* Unknown algorithm - put data into an opaque MPI.  */
2063       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2064                                          read_rest (inp, pktlen), pktlen * 8);
2065       pktlen = 0;
2066       goto leave;
2067     }
2068   else
2069     {
2070       for (i = 0; i < npkey; i++)
2071         {
2072           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2073                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2074                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2075             {
2076               /* Read the OID (i==1) or the KDF params (i==2).  */
2077               size_t n;
2078               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2079               pktlen -= n;
2080             }
2081           else
2082             {
2083               unsigned int n = pktlen;
2084               pk->pkey[i] = mpi_read (inp, &n, 0);
2085               pktlen -= n;
2086               if (!pk->pkey[i])
2087                 err = gpg_error (GPG_ERR_INV_PACKET);
2088             }
2089           if (err)
2090             goto leave;
2091           if (list_mode)
2092             {
2093               es_fprintf (listfp, "\tpkey[%d]: ", i);
2094               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2095               if ((algorithm == PUBKEY_ALGO_ECDSA
2096                    || algorithm == PUBKEY_ALGO_EDDSA
2097                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2098                 {
2099                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2100                   es_fprintf (listfp, " %s (%s)",
2101                               openpgp_oid_to_curve (curve), curve);
2102                   xfree (curve);
2103                 }
2104               es_putc ('\n', listfp);
2105             }
2106         }
2107     }
2108   if (list_mode)
2109     keyid_from_pk (pk, keyid);
2110
2111   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2112     {
2113       struct seckey_info *ski;
2114       byte temp[16];
2115       size_t snlen = 0;
2116
2117       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2118       if (!pk->seckey_info)
2119         {
2120           err = gpg_error_from_syserror ();
2121           goto leave;
2122         }
2123
2124       ski->algo = iobuf_get_noeof (inp);
2125       pktlen--;
2126       if (ski->algo)
2127         {
2128           ski->is_protected = 1;
2129           ski->s2k.count = 0;
2130           if (ski->algo == 254 || ski->algo == 255)
2131             {
2132               if (pktlen < 3)
2133                 {
2134                   err = gpg_error (GPG_ERR_INV_PACKET);
2135                   goto leave;
2136                 }
2137               ski->sha1chk = (ski->algo == 254);
2138               ski->algo = iobuf_get_noeof (inp);
2139               pktlen--;
2140               /* Note that a ski->algo > 110 is illegal, but I'm not
2141                  erroring on it here as otherwise there would be no
2142                  way to delete such a key.  */
2143               ski->s2k.mode = iobuf_get_noeof (inp);
2144               pktlen--;
2145               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2146               pktlen--;
2147               /* Check for the special GNU extension.  */
2148               if (is_v4 && ski->s2k.mode == 101)
2149                 {
2150                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2151                     temp[i] = iobuf_get_noeof (inp);
2152                   if (i < 4 || memcmp (temp, "GNU", 3))
2153                     {
2154                       if (list_mode)
2155                         es_fprintf (listfp, "\tunknown S2K %d\n",
2156                                     ski->s2k.mode);
2157                       err = gpg_error (GPG_ERR_INV_PACKET);
2158                       goto leave;
2159                     }
2160                   /* Here we know that it is a GNU extension.  What
2161                    * follows is the GNU protection mode: All values
2162                    * have special meanings and they are mapped to MODE
2163                    * with a base of 1000.  */
2164                   ski->s2k.mode = 1000 + temp[3];
2165                 }
2166
2167               /* Read the salt.  */
2168               switch (ski->s2k.mode)
2169                 {
2170                 case 1:
2171                 case 3:
2172                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2173                     temp[i] = iobuf_get_noeof (inp);
2174                   memcpy (ski->s2k.salt, temp, 8);
2175                   break;
2176                 }
2177
2178               /* Check the mode.  */
2179               switch (ski->s2k.mode)
2180                 {
2181                 case 0:
2182                   if (list_mode)
2183                     es_fprintf (listfp, "\tsimple S2K");
2184                   break;
2185                 case 1:
2186                   if (list_mode)
2187                     es_fprintf (listfp, "\tsalted S2K");
2188                   break;
2189                 case 3:
2190                   if (list_mode)
2191                     es_fprintf (listfp, "\titer+salt S2K");
2192                   break;
2193                 case 1001:
2194                   if (list_mode)
2195                     es_fprintf (listfp, "\tgnu-dummy S2K");
2196                   break;
2197                 case 1002:
2198                   if (list_mode)
2199                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2200                   break;
2201                 default:
2202                   if (list_mode)
2203                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2204                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2205                                 ski->s2k.mode);
2206                   err = gpg_error (GPG_ERR_INV_PACKET);
2207                   goto leave;
2208                 }
2209
2210               /* Print some info.  */
2211               if (list_mode)
2212                 {
2213                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2214                               ski->algo,
2215                               ski->sha1chk ? " SHA1 protection,"
2216                               : " simple checksum,", ski->s2k.hash_algo);
2217                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2218                     {
2219                       es_fprintf (listfp, ", salt: ");
2220                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2221                     }
2222                   es_putc ('\n', listfp);
2223                 }
2224
2225               /* Read remaining protection parameters.  */
2226               if (ski->s2k.mode == 3)
2227                 {
2228                   if (pktlen < 1)
2229                     {
2230                       err = gpg_error (GPG_ERR_INV_PACKET);
2231                       goto leave;
2232                     }
2233                   ski->s2k.count = iobuf_get (inp);
2234                   pktlen--;
2235                   if (list_mode)
2236                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2237                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2238                                 (ulong) ski->s2k.count);
2239                 }
2240               else if (ski->s2k.mode == 1002)
2241                 {
2242                   /* Read the serial number. */
2243                   if (pktlen < 1)
2244                     {
2245                       err = gpg_error (GPG_ERR_INV_PACKET);
2246                       goto leave;
2247                     }
2248                   snlen = iobuf_get (inp);
2249                   pktlen--;
2250                   if (pktlen < snlen || snlen == (size_t)(-1))
2251                     {
2252                       err = gpg_error (GPG_ERR_INV_PACKET);
2253                       goto leave;
2254                     }
2255                 }
2256             }
2257           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2258             {
2259               /* Note that a ski->algo > 110 is illegal, but I'm not
2260                  erroring on it here as otherwise there would be no
2261                  way to delete such a key.  */
2262               ski->s2k.mode = 0;
2263               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2264               if (list_mode)
2265                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2266                             ski->algo, ski->s2k.hash_algo);
2267             }
2268
2269           /* It is really ugly that we don't know the size
2270            * of the IV here in cases we are not aware of the algorithm.
2271            * so a
2272            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2273            * won't work.  The only solution I see is to hardwire it.
2274            * NOTE: if you change the ivlen above 16, don't forget to
2275            * enlarge temp.  */
2276           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2277           assert (ski->ivlen <= sizeof (temp));
2278
2279           if (ski->s2k.mode == 1001)
2280             ski->ivlen = 0;
2281           else if (ski->s2k.mode == 1002)
2282             ski->ivlen = snlen < 16 ? snlen : 16;
2283
2284           if (pktlen < ski->ivlen)
2285             {
2286               err = gpg_error (GPG_ERR_INV_PACKET);
2287               goto leave;
2288             }
2289           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2290             temp[i] = iobuf_get_noeof (inp);
2291           if (list_mode)
2292             {
2293               es_fprintf (listfp,
2294                           ski->s2k.mode == 1002 ? "\tserial-number: "
2295                           : "\tprotect IV: ");
2296               for (i = 0; i < ski->ivlen; i++)
2297                 es_fprintf (listfp, " %02x", temp[i]);
2298               es_putc ('\n', listfp);
2299             }
2300           memcpy (ski->iv, temp, ski->ivlen);
2301         }
2302
2303       /* It does not make sense to read it into secure memory.
2304        * If the user is so careless, not to protect his secret key,
2305        * we can assume, that he operates an open system :=(.
2306        * So we put the key into secure memory when we unprotect it. */
2307       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2308         {
2309           /* Better set some dummy stuff here.  */
2310           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2311                                                  xstrdup ("dummydata"),
2312                                                  10 * 8);
2313           pktlen = 0;
2314         }
2315       else if (is_v4 && ski->is_protected)
2316         {
2317           /* Ugly: The length is encrypted too, so we read all stuff
2318            * up to the end of the packet into the first SKEY
2319            * element.  */
2320           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2321                                                  read_rest (inp, pktlen),
2322                                                  pktlen * 8);
2323           /* Mark that MPI as protected - we need this information for
2324              importing a key.  The OPAQUE flag can't be used because
2325              we also store public EdDSA values in opaque MPIs.  */
2326           if (pk->pkey[npkey])
2327             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2328           pktlen = 0;
2329           if (list_mode)
2330             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2331         }
2332       else
2333         {
2334           /* The v3 method: The mpi length is not encrypted.  */
2335           for (i = npkey; i < nskey; i++)
2336             {
2337               if (ski->is_protected)
2338                 {
2339                   pk->pkey[i] = read_protected_v3_mpi (inp, &pktlen);
2340                   if (pk->pkey[i])
2341                     gcry_mpi_set_flag (pk->pkey[i], GCRYMPI_FLAG_USER1);
2342                   if (list_mode)
2343                     es_fprintf (listfp, "\tskey[%d]: [v3 protected]\n", i);
2344                 }
2345               else
2346                 {
2347                   unsigned int n = pktlen;
2348                   pk->pkey[i] = mpi_read (inp, &n, 0);
2349                   pktlen -= n;
2350                   if (list_mode)
2351                     {
2352                       es_fprintf (listfp, "\tskey[%d]: ", i);
2353                       mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2354                       es_putc ('\n', listfp);
2355                     }
2356                 }
2357
2358               if (!pk->pkey[i])
2359                 err = gpg_error (GPG_ERR_INV_PACKET);
2360             }
2361           if (err)
2362             goto leave;
2363
2364           ski->csum = read_16 (inp);
2365           pktlen -= 2;
2366           if (list_mode)
2367             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2368         }
2369     }
2370
2371   if (list_mode)
2372     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2373                 (ulong) keyid[0], (ulong) keyid[1]);
2374
2375  leave:
2376   iobuf_skip_rest (inp, pktlen, 0);
2377   return rc;
2378 }
2379
2380
2381 /* Attribute subpackets have the same format as v4 signature
2382    subpackets.  This is not part of OpenPGP, but is done in several
2383    versions of PGP nevertheless.  */
2384 int
2385 parse_attribute_subpkts (PKT_user_id * uid)
2386 {
2387   size_t n;
2388   int count = 0;
2389   struct user_attribute *attribs = NULL;
2390   const byte *buffer = uid->attrib_data;
2391   int buflen = uid->attrib_len;
2392   byte type;
2393
2394   xfree (uid->attribs);
2395
2396   while (buflen)
2397     {
2398       n = *buffer++;
2399       buflen--;
2400       if (n == 255)  /* 4 byte length header.  */
2401         {
2402           if (buflen < 4)
2403             goto too_short;
2404           n = (buffer[0] << 24) | (buffer[1] << 16)
2405             | (buffer[2] << 8) | buffer[3];
2406           buffer += 4;
2407           buflen -= 4;
2408         }
2409       else if (n >= 192)  /* 2 byte special encoded length header.  */
2410         {
2411           if (buflen < 2)
2412             goto too_short;
2413           n = ((n - 192) << 8) + *buffer + 192;
2414           buffer++;
2415           buflen--;
2416         }
2417       if (buflen < n)
2418         goto too_short;
2419
2420       attribs =
2421         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2422       memset (&attribs[count], 0, sizeof (struct user_attribute));
2423
2424       type = *buffer;
2425       buffer++;
2426       buflen--;
2427       n--;
2428
2429       attribs[count].type = type;
2430       attribs[count].data = buffer;
2431       attribs[count].len = n;
2432       buffer += n;
2433       buflen -= n;
2434       count++;
2435     }
2436
2437   uid->attribs = attribs;
2438   uid->numattribs = count;
2439   return count;
2440
2441  too_short:
2442   if (opt.verbose)
2443     log_info ("buffer shorter than attribute subpacket\n");
2444   uid->attribs = attribs;
2445   uid->numattribs = count;
2446   return count;
2447 }
2448
2449
2450 static int
2451 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2452 {
2453   byte *p;
2454
2455   /* Cap the size of a user ID at 2k: a value absurdly large enough
2456      that there is no sane user ID string (which is printable text
2457      as of RFC2440bis) that won't fit in it, but yet small enough to
2458      avoid allocation problems.  A large pktlen may not be
2459      allocatable, and a very large pktlen could actually cause our
2460      allocation to wrap around in xmalloc to a small number. */
2461
2462   if (pktlen > 2048)
2463     {
2464       log_error ("packet(%d) too large\n", pkttype);
2465       if (list_mode)
2466         es_fprintf (listfp, ":user ID packet: [too large]\n");
2467       iobuf_skip_rest (inp, pktlen, 0);
2468       return G10ERR_INVALID_PACKET;
2469     }
2470
2471   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2472   packet->pkt.user_id->len = pktlen;
2473   packet->pkt.user_id->ref = 1;
2474
2475   p = packet->pkt.user_id->name;
2476   for (; pktlen; pktlen--, p++)
2477     *p = iobuf_get_noeof (inp);
2478   *p = 0;
2479
2480   if (list_mode)
2481     {
2482       int n = packet->pkt.user_id->len;
2483       es_fprintf (listfp, ":user ID packet: \"");
2484       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2485       for (p = packet->pkt.user_id->name; n; p++, n--)
2486         {
2487           if (*p >= ' ' && *p <= 'z')
2488             es_putc (*p, listfp);
2489           else
2490             es_fprintf (listfp, "\\x%02x", *p);
2491         }
2492       es_fprintf (listfp, "\"\n");
2493     }
2494   return 0;
2495 }
2496
2497
2498 void
2499 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2500 {
2501   assert (max_namelen > 70);
2502   if (uid->numattribs <= 0)
2503     sprintf (uid->name, "[bad attribute packet of size %lu]",
2504              uid->attrib_len);
2505   else if (uid->numattribs > 1)
2506     sprintf (uid->name, "[%d attributes of size %lu]",
2507              uid->numattribs, uid->attrib_len);
2508   else
2509     {
2510       /* Only one attribute, so list it as the "user id" */
2511
2512       if (uid->attribs->type == ATTRIB_IMAGE)
2513         {
2514           u32 len;
2515           byte type;
2516
2517           if (parse_image_header (uid->attribs, &type, &len))
2518             sprintf (uid->name, "[%.20s image of size %lu]",
2519                      image_type_to_string (type, 1), (ulong) len);
2520           else
2521             sprintf (uid->name, "[invalid image]");
2522         }
2523       else
2524         sprintf (uid->name, "[unknown attribute of size %lu]",
2525                  (ulong) uid->attribs->len);
2526     }
2527
2528   uid->len = strlen (uid->name);
2529 }
2530
2531
2532 static int
2533 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2534                  PACKET * packet)
2535 {
2536   byte *p;
2537
2538   (void) pkttype;
2539
2540   /* We better cap the size of an attribute packet to make DoS not too
2541      easy.  16MB should be more then enough for one attribute packet
2542      (ie. a photo).  */
2543   if (pktlen > 16*1024*1024)
2544     {
2545       log_error ("packet(%d) too large\n", pkttype);
2546       if (list_mode)
2547         es_fprintf (listfp, ":attribute packet: [too large]\n");
2548       iobuf_skip_rest (inp, pktlen, 0);
2549       return G10ERR_INVALID_PACKET;
2550     }
2551
2552 #define EXTRA_UID_NAME_SPACE 71
2553   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2554                                        + EXTRA_UID_NAME_SPACE);
2555   packet->pkt.user_id->ref = 1;
2556   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2557   packet->pkt.user_id->attrib_len = pktlen;
2558
2559   p = packet->pkt.user_id->attrib_data;
2560   for (; pktlen; pktlen--, p++)
2561     *p = iobuf_get_noeof (inp);
2562
2563   /* Now parse out the individual attribute subpackets.  This is
2564      somewhat pointless since there is only one currently defined
2565      attribute type (jpeg), but it is correct by the spec. */
2566   parse_attribute_subpkts (packet->pkt.user_id);
2567
2568   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2569
2570   if (list_mode)
2571     {
2572       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2573     }
2574   return 0;
2575 }
2576
2577
2578 static int
2579 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2580 {
2581   byte *p;
2582
2583   /* Cap comment packet at a reasonable value to avoid an integer
2584      overflow in the malloc below.  Comment packets are actually not
2585      anymore define my OpenPGP and we even stopped to use our
2586      private comment packet.  */
2587   if (pktlen > 65536)
2588     {
2589       log_error ("packet(%d) too large\n", pkttype);
2590       if (list_mode)
2591         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2592                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2593       iobuf_skip_rest (inp, pktlen, 0);
2594       return G10ERR_INVALID_PACKET;
2595     }
2596   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2597   packet->pkt.comment->len = pktlen;
2598   p = packet->pkt.comment->data;
2599   for (; pktlen; pktlen--, p++)
2600     *p = iobuf_get_noeof (inp);
2601
2602   if (list_mode)
2603     {
2604       int n = packet->pkt.comment->len;
2605       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2606                   "OpenPGP draft " : "");
2607       for (p = packet->pkt.comment->data; n; p++, n--)
2608         {
2609           if (*p >= ' ' && *p <= 'z')
2610             es_putc (*p, listfp);
2611           else
2612             es_fprintf (listfp, "\\x%02x", *p);
2613         }
2614       es_fprintf (listfp, "\"\n");
2615     }
2616   return 0;
2617 }
2618
2619
2620 static void
2621 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2622 {
2623   int c;
2624
2625   (void) pkttype;
2626
2627   if (pktlen)
2628     {
2629       c = iobuf_get_noeof (inp);
2630       pktlen--;
2631       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2632       pkt->pkt.ring_trust->trustval = c;
2633       pkt->pkt.ring_trust->sigcache = 0;
2634       if (!c && pktlen == 1)
2635         {
2636           c = iobuf_get_noeof (inp);
2637           pktlen--;
2638           /* We require that bit 7 of the sigcache is 0 (easier eof
2639              handling).  */
2640           if (!(c & 0x80))
2641             pkt->pkt.ring_trust->sigcache = c;
2642         }
2643       if (list_mode)
2644         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2645                     pkt->pkt.ring_trust->trustval,
2646                     pkt->pkt.ring_trust->sigcache);
2647     }
2648   else
2649     {
2650       if (list_mode)
2651         es_fprintf (listfp, ":trust packet: empty\n");
2652     }
2653   iobuf_skip_rest (inp, pktlen, 0);
2654 }
2655
2656
2657 static int
2658 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2659                  PACKET * pkt, int new_ctb, int partial)
2660 {
2661   int rc = 0;
2662   int mode, namelen;
2663   PKT_plaintext *pt;
2664   byte *p;
2665   int c, i;
2666
2667   if (!partial && pktlen < 6)
2668     {
2669       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2670       if (list_mode)
2671         es_fputs (":literal data packet: [too short]\n", listfp);
2672       rc = gpg_error (GPG_ERR_INV_PACKET);
2673       goto leave;
2674     }
2675   mode = iobuf_get_noeof (inp);
2676   if (pktlen)
2677     pktlen--;
2678   namelen = iobuf_get_noeof (inp);
2679   if (pktlen)
2680     pktlen--;
2681   /* Note that namelen will never exceed 255 bytes. */
2682   pt = pkt->pkt.plaintext =
2683     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2684   pt->new_ctb = new_ctb;
2685   pt->mode = mode;
2686   pt->namelen = namelen;
2687   pt->is_partial = partial;
2688   if (pktlen)
2689     {
2690       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2691         pt->name[i] = iobuf_get_noeof (inp);
2692     }
2693   else
2694     {
2695       for (i = 0; i < namelen; i++)
2696         if ((c = iobuf_get (inp)) == -1)
2697           break;
2698         else
2699           pt->name[i] = c;
2700     }
2701   pt->timestamp = read_32 (inp);
2702   if (pktlen)
2703     pktlen -= 4;
2704   pt->len = pktlen;
2705   pt->buf = inp;
2706   pktlen = 0;
2707
2708   if (list_mode)
2709     {
2710       es_fprintf (listfp, ":literal data packet:\n"
2711                   "\tmode %c (%X), created %lu, name=\"",
2712                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2713                   (ulong) pt->timestamp);
2714       for (p = pt->name, i = 0; i < namelen; p++, i++)
2715         {
2716           if (*p >= ' ' && *p <= 'z')
2717             es_putc (*p, listfp);
2718           else
2719             es_fprintf (listfp, "\\x%02x", *p);
2720         }
2721       es_fprintf (listfp, "\",\n\traw data: ");
2722       if (partial)
2723         es_fprintf (listfp, "unknown length\n");
2724       else
2725         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2726     }
2727
2728  leave:
2729   return rc;
2730 }
2731
2732
2733 static int
2734 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2735                   PACKET * pkt, int new_ctb)
2736 {
2737   PKT_compressed *zd;
2738
2739   /* PKTLEN is here 0, but data follows (this should be the last
2740      object in a file or the compress algorithm should know the
2741      length).  */
2742   (void) pkttype;
2743   (void) pktlen;
2744
2745   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2746   zd->algorithm = iobuf_get_noeof (inp);
2747   zd->len = 0;                  /* not used */
2748   zd->new_ctb = new_ctb;
2749   zd->buf = inp;
2750   if (list_mode)
2751     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2752   return 0;
2753 }
2754
2755
2756 static int
2757 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2758                  PACKET * pkt, int new_ctb, int partial)
2759 {
2760   int rc = 0;
2761   PKT_encrypted *ed;
2762   unsigned long orig_pktlen = pktlen;
2763
2764   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2765   /* ed->len is set below.  */
2766   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2767   ed->buf = NULL;
2768   ed->new_ctb = new_ctb;
2769   ed->is_partial = partial;
2770   if (pkttype == PKT_ENCRYPTED_MDC)
2771     {
2772       /* Fixme: add some pktlen sanity checks.  */
2773       int version;
2774
2775       version = iobuf_get_noeof (inp);
2776       if (orig_pktlen)
2777         pktlen--;
2778       if (version != 1)
2779         {
2780           log_error ("encrypted_mdc packet with unknown version %d\n",
2781                      version);
2782           if (list_mode)
2783             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
2784           /*skip_rest(inp, pktlen); should we really do this? */
2785           rc = gpg_error (GPG_ERR_INV_PACKET);
2786           goto leave;
2787         }
2788       ed->mdc_method = DIGEST_ALGO_SHA1;
2789     }
2790   else
2791     ed->mdc_method = 0;
2792
2793   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2794      detection bytes.  Note that we don't known the algorithm and thus
2795      we may only check against the minimum blocksize.  */
2796   if (orig_pktlen && pktlen < 10)
2797     {
2798       /* Actually this is blocksize+2.  */
2799       log_error ("packet(%d) too short\n", pkttype);
2800       if (list_mode)
2801         es_fputs (":encrypted data packet: [too short]\n", listfp);
2802       rc = G10ERR_INVALID_PACKET;
2803       iobuf_skip_rest (inp, pktlen, partial);
2804       goto leave;
2805     }
2806
2807   /* Store the remaining length of the encrypted data (i.e. without
2808      the MDC version number but with the IV etc.).  This value is
2809      required during decryption.  */
2810   ed->len = pktlen;
2811
2812   if (list_mode)
2813     {
2814       if (orig_pktlen)
2815         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2816                     orig_pktlen);
2817       else
2818         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2819       if (ed->mdc_method)
2820         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2821     }
2822
2823   ed->buf = inp;
2824
2825  leave:
2826   return rc;
2827 }
2828
2829
2830 /* Note, that this code is not anymore used in real life because the
2831    MDC checking is now done right after the decryption in
2832    decrypt_data.  */
2833 static int
2834 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2835            PACKET * pkt, int new_ctb)
2836 {
2837   int rc = 0;
2838   PKT_mdc *mdc;
2839   byte *p;
2840
2841   (void) pkttype;
2842
2843   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2844   if (list_mode)
2845     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2846   if (!new_ctb || pktlen != 20)
2847     {
2848       log_error ("mdc_packet with invalid encoding\n");
2849       rc = gpg_error (GPG_ERR_INV_PACKET);
2850       goto leave;
2851     }
2852   p = mdc->hash;
2853   for (; pktlen; pktlen--, p++)
2854     *p = iobuf_get_noeof (inp);
2855
2856  leave:
2857   return rc;
2858 }
2859
2860
2861 /*
2862  * This packet is internally generated by us (ibn armor.c) to transfer
2863  * some information to the lower layer.  To make sure that this packet
2864  * is really a GPG faked one and not one comming from outside, we
2865  * first check that there is a unique tag in it.
2866  *
2867  * The format of such a control packet is:
2868  *   n byte  session marker
2869  *   1 byte  control type CTRLPKT_xxxxx
2870  *   m byte  control data
2871  */
2872 static int
2873 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2874                    PACKET * packet, int partial)
2875 {
2876   byte *p;
2877   const byte *sesmark;
2878   size_t sesmarklen;
2879   int i;
2880
2881   (void) pkttype;
2882
2883   if (list_mode)
2884     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2885
2886   sesmark = get_session_marker (&sesmarklen);
2887   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2888     goto skipit;
2889   for (i = 0; i < sesmarklen; i++, pktlen--)
2890     {
2891       if (sesmark[i] != iobuf_get_noeof (inp))
2892         goto skipit;
2893     }
2894   if (pktlen > 4096)
2895     goto skipit;  /* Definitely too large.  We skip it to avoid an
2896                      overflow in the malloc.  */
2897   if (list_mode)
2898     puts ("- gpg control packet");
2899
2900   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2901                                      + pktlen - 1);
2902   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2903   pktlen--;
2904   packet->pkt.gpg_control->datalen = pktlen;
2905   p = packet->pkt.gpg_control->data;
2906   for (; pktlen; pktlen--, p++)
2907     *p = iobuf_get_noeof (inp);
2908
2909   return 0;
2910
2911  skipit:
2912   if (list_mode)
2913     {
2914       int c;
2915
2916       i = 0;
2917       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2918       if (partial)
2919         {
2920           while ((c = iobuf_get (inp)) != -1)
2921             dump_hex_line (c, &i);
2922         }
2923       else
2924         {
2925           for (; pktlen; pktlen--)
2926             {
2927               dump_hex_line ((c = iobuf_get (inp)), &i);
2928               if (c == -1)
2929                 break;
2930             }
2931         }
2932       es_putc ('\n', listfp);
2933     }
2934   iobuf_skip_rest (inp, pktlen, 0);
2935   return gpg_error (GPG_ERR_INV_PACKET);
2936 }
2937
2938
2939 /* Create a GPG control packet to be used internally as a placeholder.  */
2940 PACKET *
2941 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2942 {
2943   PACKET *packet;
2944   byte *p;
2945
2946   packet = xmalloc (sizeof *packet);
2947   init_packet (packet);
2948   packet->pkttype = PKT_GPG_CONTROL;
2949   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2950                                      + datalen - 1);
2951   packet->pkt.gpg_control->control = type;
2952   packet->pkt.gpg_control->datalen = datalen;
2953   p = packet->pkt.gpg_control->data;
2954   for (; datalen; datalen--, p++)
2955     *p = *data++;
2956
2957   return packet;
2958 }