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