g10/packet.h: Remove unused argument from enum_sig_subpkt.
[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 {
1590   const byte *p;
1591
1592   p = parse_sig_subpkt (sig->hashed, reqtype, NULL);
1593   if (!p)
1594     p = parse_sig_subpkt (sig->unhashed, reqtype, NULL);
1595   return p;
1596 }
1597
1598
1599 /* Find all revocation keys.  Look in hashed area only.  */
1600 void
1601 parse_revkeys (PKT_signature * sig)
1602 {
1603   struct revocation_key *revkey;
1604   int seq = 0;
1605   size_t len;
1606
1607   if (sig->sig_class != 0x1F)
1608     return;
1609
1610   while ((revkey =
1611           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1612                                                      SIGSUBPKT_REV_KEY,
1613                                                      &len, &seq, NULL)))
1614     {
1615       if (len == sizeof (struct revocation_key)
1616           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1617         {
1618           sig->revkey = xrealloc (sig->revkey,
1619                                   sizeof (struct revocation_key *) *
1620                                   (sig->numrevkeys + 1));
1621           sig->revkey[sig->numrevkeys] = revkey;
1622           sig->numrevkeys++;
1623         }
1624     }
1625 }
1626
1627
1628 int
1629 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1630                  PKT_signature * sig)
1631 {
1632   int md5_len = 0;
1633   unsigned n;
1634   int is_v4 = 0;
1635   int rc = 0;
1636   int i, ndata;
1637
1638   if (pktlen < 16)
1639     {
1640       log_error ("packet(%d) too short\n", pkttype);
1641       if (list_mode)
1642         es_fputs (":signature packet: [too short]\n", listfp);
1643       goto leave;
1644     }
1645   sig->version = iobuf_get_noeof (inp);
1646   pktlen--;
1647   if (sig->version == 4)
1648     is_v4 = 1;
1649   else if (sig->version != 2 && sig->version != 3)
1650     {
1651       log_error ("packet(%d) with unknown version %d\n",
1652                  pkttype, sig->version);
1653       if (list_mode)
1654         es_fputs (":signature packet: [unknown version]\n", listfp);
1655       rc = gpg_error (GPG_ERR_INV_PACKET);
1656       goto leave;
1657     }
1658
1659   if (!is_v4)
1660     {
1661       md5_len = iobuf_get_noeof (inp);
1662       pktlen--;
1663     }
1664   sig->sig_class = iobuf_get_noeof (inp);
1665   pktlen--;
1666   if (!is_v4)
1667     {
1668       sig->timestamp = read_32 (inp);
1669       pktlen -= 4;
1670       sig->keyid[0] = read_32 (inp);
1671       pktlen -= 4;
1672       sig->keyid[1] = read_32 (inp);
1673       pktlen -= 4;
1674     }
1675   sig->pubkey_algo = iobuf_get_noeof (inp);
1676   pktlen--;
1677   sig->digest_algo = iobuf_get_noeof (inp);
1678   pktlen--;
1679   sig->flags.exportable = 1;
1680   sig->flags.revocable = 1;
1681   if (is_v4) /* Read subpackets.  */
1682     {
1683       n = read_16 (inp);
1684       pktlen -= 2;  /* Length of hashed data. */
1685       if (n > 10000)
1686         {
1687           log_error ("signature packet: hashed data too long\n");
1688           if (list_mode)
1689             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1690           rc = GPG_ERR_INV_PACKET;
1691           goto leave;
1692         }
1693       if (n)
1694         {
1695           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1696           sig->hashed->size = n;
1697           sig->hashed->len = n;
1698           if (iobuf_read (inp, sig->hashed->data, n) != n)
1699             {
1700               log_error ("premature eof while reading "
1701                          "hashed signature data\n");
1702               if (list_mode)
1703                 es_fputs (":signature packet: [premature eof]\n", listfp);
1704               rc = -1;
1705               goto leave;
1706             }
1707           pktlen -= n;
1708         }
1709       n = read_16 (inp);
1710       pktlen -= 2;  /* Length of unhashed data.  */
1711       if (n > 10000)
1712         {
1713           log_error ("signature packet: unhashed data too long\n");
1714           if (list_mode)
1715             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1716           rc = GPG_ERR_INV_PACKET;
1717           goto leave;
1718         }
1719       if (n)
1720         {
1721           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1722           sig->unhashed->size = n;
1723           sig->unhashed->len = n;
1724           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1725             {
1726               log_error ("premature eof while reading "
1727                          "unhashed signature data\n");
1728               if (list_mode)
1729                 es_fputs (":signature packet: [premature eof]\n", listfp);
1730               rc = -1;
1731               goto leave;
1732             }
1733           pktlen -= n;
1734         }
1735     }
1736
1737   if (pktlen < 5)  /* Sanity check.  */
1738     {
1739       log_error ("packet(%d) too short\n", pkttype);
1740       if (list_mode)
1741         es_fputs (":signature packet: [too short]\n", listfp);
1742       rc = GPG_ERR_INV_PACKET;
1743       goto leave;
1744     }
1745
1746   sig->digest_start[0] = iobuf_get_noeof (inp);
1747   pktlen--;
1748   sig->digest_start[1] = iobuf_get_noeof (inp);
1749   pktlen--;
1750
1751   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1752     {
1753       const byte *p;
1754       size_t len;
1755
1756       /* Set sig->flags.unknown_critical if there is a critical bit
1757        * set for packets which we do not understand.  */
1758       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1759           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1760         sig->flags.unknown_critical = 1;
1761
1762       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1763       if (p)
1764         sig->timestamp = buf32_to_u32 (p);
1765       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1766                && opt.verbose)
1767         log_info ("signature packet without timestamp\n");
1768
1769       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER);
1770       if (p)
1771         {
1772           sig->keyid[0] = buf32_to_u32 (p);
1773           sig->keyid[1] = buf32_to_u32 (p + 4);
1774         }
1775       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1776                && opt.verbose)
1777         log_info ("signature packet without keyid\n");
1778
1779       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1780       if (p && buf32_to_u32 (p))
1781         sig->expiredate = sig->timestamp + buf32_to_u32 (p);
1782       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1783         sig->flags.expired = 1;
1784
1785       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1786       if (p)
1787         sig->flags.policy_url = 1;
1788
1789       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1790       if (p)
1791         sig->flags.pref_ks = 1;
1792
1793       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1794       if (p)
1795         sig->flags.notation = 1;
1796
1797       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1798       if (p && *p == 0)
1799         sig->flags.revocable = 0;
1800
1801       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1802       if (p && len == 2)
1803         {
1804           sig->trust_depth = p[0];
1805           sig->trust_value = p[1];
1806
1807           /* Only look for a regexp if there is also a trust
1808              subpacket. */
1809           sig->trust_regexp =
1810             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1811
1812           /* If the regular expression is of 0 length, there is no
1813              regular expression. */
1814           if (len == 0)
1815             sig->trust_regexp = NULL;
1816         }
1817
1818       /* We accept the exportable subpacket from either the hashed or
1819          unhashed areas as older versions of gpg put it in the
1820          unhashed area.  In theory, anyway, we should never see this
1821          packet off of a local keyring. */
1822
1823       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE);
1824       if (p && *p == 0)
1825         sig->flags.exportable = 0;
1826
1827       /* Find all revocation keys.  */
1828       if (sig->sig_class == 0x1F)
1829         parse_revkeys (sig);
1830     }
1831
1832   if (list_mode)
1833     {
1834       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1835                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1836                   "\tdigest algo %d, begin of digest %02x %02x\n",
1837                   sig->pubkey_algo,
1838                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1839                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1840                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1841       if (is_v4)
1842         {
1843           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1844           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1845         }
1846     }
1847
1848   ndata = pubkey_get_nsig (sig->pubkey_algo);
1849   if (!ndata)
1850     {
1851       if (list_mode)
1852         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1853       unknown_pubkey_warning (sig->pubkey_algo);
1854
1855       /* We store the plain material in data[0], so that we are able
1856        * to write it back with build_packet().  */
1857       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1858         {
1859           /* We include a limit to avoid too trivial DoS attacks by
1860              having gpg allocate too much memory.  */
1861           log_error ("signature packet: too much data\n");
1862           rc = GPG_ERR_INV_PACKET;
1863         }
1864       else
1865         {
1866           sig->data[0] =
1867             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
1868           pktlen = 0;
1869         }
1870     }
1871   else
1872     {
1873       for (i = 0; i < ndata; i++)
1874         {
1875           n = pktlen;
1876           sig->data[i] = mpi_read (inp, &n, 0);
1877           pktlen -= n;
1878           if (list_mode)
1879             {
1880               es_fprintf (listfp, "\tdata: ");
1881               mpi_print (listfp, sig->data[i], mpi_print_mode);
1882               es_putc ('\n', listfp);
1883             }
1884           if (!sig->data[i])
1885             rc = GPG_ERR_INV_PACKET;
1886         }
1887     }
1888
1889  leave:
1890   iobuf_skip_rest (inp, pktlen, 0);
1891   return rc;
1892 }
1893
1894
1895 static int
1896 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1897                    PKT_onepass_sig * ops)
1898 {
1899   int version;
1900   int rc = 0;
1901
1902   if (pktlen < 13)
1903     {
1904       log_error ("packet(%d) too short\n", pkttype);
1905       if (list_mode)
1906         es_fputs (":onepass_sig packet: [too short]\n", listfp);
1907       rc = gpg_error (GPG_ERR_INV_PACKET);
1908       goto leave;
1909     }
1910   version = iobuf_get_noeof (inp);
1911   pktlen--;
1912   if (version != 3)
1913     {
1914       log_error ("onepass_sig with unknown version %d\n", version);
1915       if (list_mode)
1916         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
1917       rc = gpg_error (GPG_ERR_INV_PACKET);
1918       goto leave;
1919     }
1920   ops->sig_class = iobuf_get_noeof (inp);
1921   pktlen--;
1922   ops->digest_algo = iobuf_get_noeof (inp);
1923   pktlen--;
1924   ops->pubkey_algo = iobuf_get_noeof (inp);
1925   pktlen--;
1926   ops->keyid[0] = read_32 (inp);
1927   pktlen -= 4;
1928   ops->keyid[1] = read_32 (inp);
1929   pktlen -= 4;
1930   ops->last = iobuf_get_noeof (inp);
1931   pktlen--;
1932   if (list_mode)
1933     es_fprintf (listfp,
1934                 ":onepass_sig packet: keyid %08lX%08lX\n"
1935                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1936                 "last=%d\n",
1937                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1938                 version, ops->sig_class,
1939                 ops->digest_algo, ops->pubkey_algo, ops->last);
1940
1941
1942  leave:
1943   iobuf_skip_rest (inp, pktlen, 0);
1944   return rc;
1945 }
1946
1947
1948 static int
1949 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1950            byte * hdr, int hdrlen, PACKET * pkt)
1951 {
1952   gpg_error_t err = 0;
1953   int i, version, algorithm;
1954   unsigned long timestamp, expiredate, max_expiredate;
1955   int npkey, nskey;
1956   u32 keyid[2];
1957   PKT_public_key *pk;
1958
1959   (void) hdr;
1960
1961   pk = pkt->pkt.public_key; /* PK has been cleared. */
1962
1963   version = iobuf_get_noeof (inp);
1964   pktlen--;
1965   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1966     {
1967       /* Early versions of G10 used the old PGP comments packets;
1968        * luckily all those comments are started by a hash.  */
1969       if (list_mode)
1970         {
1971           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1972           for (; pktlen; pktlen--)
1973             {
1974               int c;
1975               c = iobuf_get (inp);
1976               if (c == -1)
1977                 break; /* Ooops: shorter than indicated.  */
1978               if (c >= ' ' && c <= 'z')
1979                 es_putc (c, listfp);
1980               else
1981                 es_fprintf (listfp, "\\x%02x", c);
1982             }
1983           es_fprintf (listfp, "\"\n");
1984         }
1985       iobuf_skip_rest (inp, pktlen, 0);
1986       return 0;
1987     }
1988   else if (version == 4)
1989     {
1990       /* The only supported version.  Use an older gpg
1991          version (i.e. gpg 1.4) to parse v3 packets.  */
1992     }
1993   else if (version == 2 || version == 3)
1994     {
1995       if (opt.verbose > 1)
1996         log_info ("packet(%d) with obsolete version %d\n", pkttype, version);
1997       if (list_mode)
1998         es_fprintf (listfp, ":key packet: [obsolete version %d]\n", version);
1999       pk->version = version;
2000       err = gpg_error (GPG_ERR_LEGACY_KEY);
2001       goto leave;
2002     }
2003   else
2004     {
2005       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
2006       if (list_mode)
2007         es_fputs (":key packet: [unknown version]\n", listfp);
2008       err = gpg_error (GPG_ERR_INV_PACKET);
2009       goto leave;
2010     }
2011
2012   if (pktlen < 11)
2013     {
2014       log_error ("packet(%d) too short\n", pkttype);
2015       if (list_mode)
2016         es_fputs (":key packet: [too short]\n", listfp);
2017       err = gpg_error (GPG_ERR_INV_PACKET);
2018       goto leave;
2019     }
2020   else if (pktlen > MAX_KEY_PACKET_LENGTH)
2021     {
2022       log_error ("packet(%d) too large\n", pkttype);
2023       if (list_mode)
2024         es_fputs (":key packet: [too larget]\n", listfp);
2025       err = gpg_error (GPG_ERR_INV_PACKET);
2026       goto leave;
2027     }
2028
2029   timestamp = read_32 (inp);
2030   pktlen -= 4;
2031   expiredate = 0;               /* have to get it from the selfsignature */
2032   max_expiredate = 0;
2033   algorithm = iobuf_get_noeof (inp);
2034   pktlen--;
2035   if (list_mode)
2036     es_fprintf (listfp, ":%s key packet:\n"
2037                 "\tversion %d, algo %d, created %lu, expires %lu\n",
2038                 pkttype == PKT_PUBLIC_KEY ? "public" :
2039                 pkttype == PKT_SECRET_KEY ? "secret" :
2040                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
2041                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
2042                 version, algorithm, timestamp, expiredate);
2043
2044   pk->timestamp = timestamp;
2045   pk->expiredate = expiredate;
2046   pk->max_expiredate = max_expiredate;
2047   pk->hdrbytes = hdrlen;
2048   pk->version = version;
2049   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
2050   pk->pubkey_algo = algorithm;
2051
2052   nskey = pubkey_get_nskey (algorithm);
2053   npkey = pubkey_get_npkey (algorithm);
2054   if (!npkey)
2055     {
2056       if (list_mode)
2057         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2058       unknown_pubkey_warning (algorithm);
2059     }
2060
2061   if (!npkey)
2062     {
2063       /* Unknown algorithm - put data into an opaque MPI.  */
2064       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2065                                          read_rest (inp, pktlen), pktlen * 8);
2066       pktlen = 0;
2067       goto leave;
2068     }
2069   else
2070     {
2071       for (i = 0; i < npkey; i++)
2072         {
2073           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2074                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2075                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2076             {
2077               /* Read the OID (i==1) or the KDF params (i==2).  */
2078               size_t n;
2079               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2080               pktlen -= n;
2081             }
2082           else
2083             {
2084               unsigned int n = pktlen;
2085               pk->pkey[i] = mpi_read (inp, &n, 0);
2086               pktlen -= n;
2087               if (!pk->pkey[i])
2088                 err = gpg_error (GPG_ERR_INV_PACKET);
2089             }
2090           if (err)
2091             goto leave;
2092           if (list_mode)
2093             {
2094               es_fprintf (listfp, "\tpkey[%d]: ", i);
2095               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2096               if ((algorithm == PUBKEY_ALGO_ECDSA
2097                    || algorithm == PUBKEY_ALGO_EDDSA
2098                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2099                 {
2100                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2101                   const char *name = openpgp_oid_to_curve (curve, 0);
2102                   es_fprintf (listfp, " %s (%s)", name?name:"", curve);
2103                   xfree (curve);
2104                 }
2105               es_putc ('\n', listfp);
2106             }
2107         }
2108     }
2109   if (list_mode)
2110     keyid_from_pk (pk, keyid);
2111
2112   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2113     {
2114       struct seckey_info *ski;
2115       byte temp[16];
2116       size_t snlen = 0;
2117
2118       if (pktlen < 1)
2119         {
2120           err = gpg_error (GPG_ERR_INV_PACKET);
2121           goto leave;
2122         }
2123
2124       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2125       if (!pk->seckey_info)
2126         {
2127           err = gpg_error_from_syserror ();
2128           goto leave;
2129         }
2130
2131       ski->algo = iobuf_get_noeof (inp);
2132       pktlen--;
2133       if (ski->algo)
2134         {
2135           ski->is_protected = 1;
2136           ski->s2k.count = 0;
2137           if (ski->algo == 254 || ski->algo == 255)
2138             {
2139               if (pktlen < 3)
2140                 {
2141                   err = gpg_error (GPG_ERR_INV_PACKET);
2142                   goto leave;
2143                 }
2144               ski->sha1chk = (ski->algo == 254);
2145               ski->algo = iobuf_get_noeof (inp);
2146               pktlen--;
2147               /* Note that a ski->algo > 110 is illegal, but I'm not
2148                  erroring on it here as otherwise there would be no
2149                  way to delete such a key.  */
2150               ski->s2k.mode = iobuf_get_noeof (inp);
2151               pktlen--;
2152               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2153               pktlen--;
2154               /* Check for the special GNU extension.  */
2155               if (ski->s2k.mode == 101)
2156                 {
2157                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2158                     temp[i] = iobuf_get_noeof (inp);
2159                   if (i < 4 || memcmp (temp, "GNU", 3))
2160                     {
2161                       if (list_mode)
2162                         es_fprintf (listfp, "\tunknown S2K %d\n",
2163                                     ski->s2k.mode);
2164                       err = gpg_error (GPG_ERR_INV_PACKET);
2165                       goto leave;
2166                     }
2167                   /* Here we know that it is a GNU extension.  What
2168                    * follows is the GNU protection mode: All values
2169                    * have special meanings and they are mapped to MODE
2170                    * with a base of 1000.  */
2171                   ski->s2k.mode = 1000 + temp[3];
2172                 }
2173
2174               /* Read the salt.  */
2175               switch (ski->s2k.mode)
2176                 {
2177                 case 1:
2178                 case 3:
2179                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2180                     temp[i] = iobuf_get_noeof (inp);
2181                   memcpy (ski->s2k.salt, temp, 8);
2182                   break;
2183                 }
2184
2185               /* Check the mode.  */
2186               switch (ski->s2k.mode)
2187                 {
2188                 case 0:
2189                   if (list_mode)
2190                     es_fprintf (listfp, "\tsimple S2K");
2191                   break;
2192                 case 1:
2193                   if (list_mode)
2194                     es_fprintf (listfp, "\tsalted S2K");
2195                   break;
2196                 case 3:
2197                   if (list_mode)
2198                     es_fprintf (listfp, "\titer+salt S2K");
2199                   break;
2200                 case 1001:
2201                   if (list_mode)
2202                     es_fprintf (listfp, "\tgnu-dummy S2K");
2203                   break;
2204                 case 1002:
2205                   if (list_mode)
2206                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2207                   break;
2208                 default:
2209                   if (list_mode)
2210                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2211                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2212                                 ski->s2k.mode);
2213                   err = gpg_error (GPG_ERR_INV_PACKET);
2214                   goto leave;
2215                 }
2216
2217               /* Print some info.  */
2218               if (list_mode)
2219                 {
2220                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2221                               ski->algo,
2222                               ski->sha1chk ? " SHA1 protection,"
2223                               : " simple checksum,", ski->s2k.hash_algo);
2224                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2225                     {
2226                       es_fprintf (listfp, ", salt: ");
2227                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2228                     }
2229                   es_putc ('\n', listfp);
2230                 }
2231
2232               /* Read remaining protection parameters.  */
2233               if (ski->s2k.mode == 3)
2234                 {
2235                   if (pktlen < 1)
2236                     {
2237                       err = gpg_error (GPG_ERR_INV_PACKET);
2238                       goto leave;
2239                     }
2240                   ski->s2k.count = iobuf_get (inp);
2241                   pktlen--;
2242                   if (list_mode)
2243                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2244                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2245                                 (ulong) ski->s2k.count);
2246                 }
2247               else if (ski->s2k.mode == 1002)
2248                 {
2249                   /* Read the serial number. */
2250                   if (pktlen < 1)
2251                     {
2252                       err = gpg_error (GPG_ERR_INV_PACKET);
2253                       goto leave;
2254                     }
2255                   snlen = iobuf_get (inp);
2256                   pktlen--;
2257                   if (pktlen < snlen || snlen == (size_t)(-1))
2258                     {
2259                       err = gpg_error (GPG_ERR_INV_PACKET);
2260                       goto leave;
2261                     }
2262                 }
2263             }
2264           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2265             {
2266               /* Note that a ski->algo > 110 is illegal, but I'm not
2267                  erroring on it here as otherwise there would be no
2268                  way to delete such a key.  */
2269               ski->s2k.mode = 0;
2270               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2271               if (list_mode)
2272                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2273                             ski->algo, ski->s2k.hash_algo);
2274             }
2275
2276           /* It is really ugly that we don't know the size
2277            * of the IV here in cases we are not aware of the algorithm.
2278            * so a
2279            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2280            * won't work.  The only solution I see is to hardwire it.
2281            * NOTE: if you change the ivlen above 16, don't forget to
2282            * enlarge temp.  */
2283           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2284           assert (ski->ivlen <= sizeof (temp));
2285
2286           if (ski->s2k.mode == 1001)
2287             ski->ivlen = 0;
2288           else if (ski->s2k.mode == 1002)
2289             ski->ivlen = snlen < 16 ? snlen : 16;
2290
2291           if (pktlen < ski->ivlen)
2292             {
2293               err = gpg_error (GPG_ERR_INV_PACKET);
2294               goto leave;
2295             }
2296           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2297             temp[i] = iobuf_get_noeof (inp);
2298           if (list_mode)
2299             {
2300               es_fprintf (listfp,
2301                           ski->s2k.mode == 1002 ? "\tserial-number: "
2302                           : "\tprotect IV: ");
2303               for (i = 0; i < ski->ivlen; i++)
2304                 es_fprintf (listfp, " %02x", temp[i]);
2305               es_putc ('\n', listfp);
2306             }
2307           memcpy (ski->iv, temp, ski->ivlen);
2308         }
2309
2310       /* It does not make sense to read it into secure memory.
2311        * If the user is so careless, not to protect his secret key,
2312        * we can assume, that he operates an open system :=(.
2313        * So we put the key into secure memory when we unprotect it. */
2314       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2315         {
2316           /* Better set some dummy stuff here.  */
2317           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2318                                                  xstrdup ("dummydata"),
2319                                                  10 * 8);
2320           pktlen = 0;
2321         }
2322       else if (ski->is_protected)
2323         {
2324           if (pktlen < 2) /* At least two bytes for the length.  */
2325             {
2326               err = gpg_error (GPG_ERR_INV_PACKET);
2327               goto leave;
2328             }
2329
2330           /* Ugly: The length is encrypted too, so we read all stuff
2331            * up to the end of the packet into the first SKEY
2332            * element.  */
2333           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2334                                                  read_rest (inp, pktlen),
2335                                                  pktlen * 8);
2336           /* Mark that MPI as protected - we need this information for
2337              importing a key.  The OPAQUE flag can't be used because
2338              we also store public EdDSA values in opaque MPIs.  */
2339           if (pk->pkey[npkey])
2340             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2341           pktlen = 0;
2342           if (list_mode)
2343             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2344         }
2345       else
2346         {
2347           /* Not encrypted.  */
2348           for (i = npkey; i < nskey; i++)
2349             {
2350               unsigned int n;
2351
2352               if (pktlen < 2) /* At least two bytes for the length.  */
2353                 {
2354                   err = gpg_error (GPG_ERR_INV_PACKET);
2355                   goto leave;
2356                 }
2357               n = pktlen;
2358               pk->pkey[i] = mpi_read (inp, &n, 0);
2359               pktlen -= n;
2360               if (list_mode)
2361                 {
2362                   es_fprintf (listfp, "\tskey[%d]: ", i);
2363                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2364                   es_putc ('\n', listfp);
2365                 }
2366
2367               if (!pk->pkey[i])
2368                 err = gpg_error (GPG_ERR_INV_PACKET);
2369             }
2370           if (err)
2371             goto leave;
2372
2373           if (pktlen < 2)
2374             {
2375               err = gpg_error (GPG_ERR_INV_PACKET);
2376               goto leave;
2377             }
2378           ski->csum = read_16 (inp);
2379           pktlen -= 2;
2380           if (list_mode)
2381             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2382         }
2383     }
2384
2385   if (list_mode)
2386     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2387                 (ulong) keyid[0], (ulong) keyid[1]);
2388
2389  leave:
2390   iobuf_skip_rest (inp, pktlen, 0);
2391   return err;
2392 }
2393
2394
2395 /* Attribute subpackets have the same format as v4 signature
2396    subpackets.  This is not part of OpenPGP, but is done in several
2397    versions of PGP nevertheless.  */
2398 int
2399 parse_attribute_subpkts (PKT_user_id * uid)
2400 {
2401   size_t n;
2402   int count = 0;
2403   struct user_attribute *attribs = NULL;
2404   const byte *buffer = uid->attrib_data;
2405   int buflen = uid->attrib_len;
2406   byte type;
2407
2408   xfree (uid->attribs);
2409
2410   while (buflen)
2411     {
2412       n = *buffer++;
2413       buflen--;
2414       if (n == 255)  /* 4 byte length header.  */
2415         {
2416           if (buflen < 4)
2417             goto too_short;
2418           n = buf32_to_size_t (buffer);
2419           buffer += 4;
2420           buflen -= 4;
2421         }
2422       else if (n >= 192)  /* 2 byte special encoded length header.  */
2423         {
2424           if (buflen < 2)
2425             goto too_short;
2426           n = ((n - 192) << 8) + *buffer + 192;
2427           buffer++;
2428           buflen--;
2429         }
2430       if (buflen < n)
2431         goto too_short;
2432
2433       if (!n)
2434         {
2435           /* Too short to encode the subpacket type.  */
2436           if (opt.verbose)
2437             log_info ("attribute subpacket too short\n");
2438           break;
2439         }
2440
2441       attribs = xrealloc (attribs,
2442                           (count + 1) * sizeof (struct user_attribute));
2443       memset (&attribs[count], 0, sizeof (struct user_attribute));
2444
2445       type = *buffer;
2446       buffer++;
2447       buflen--;
2448       n--;
2449
2450       attribs[count].type = type;
2451       attribs[count].data = buffer;
2452       attribs[count].len = n;
2453       buffer += n;
2454       buflen -= n;
2455       count++;
2456     }
2457
2458   uid->attribs = attribs;
2459   uid->numattribs = count;
2460   return count;
2461
2462  too_short:
2463   if (opt.verbose)
2464     log_info ("buffer shorter than attribute subpacket\n");
2465   uid->attribs = attribs;
2466   uid->numattribs = count;
2467   return count;
2468 }
2469
2470
2471 static int
2472 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2473 {
2474   byte *p;
2475
2476   /* Cap the size of a user ID at 2k: a value absurdly large enough
2477      that there is no sane user ID string (which is printable text
2478      as of RFC2440bis) that won't fit in it, but yet small enough to
2479      avoid allocation problems.  A large pktlen may not be
2480      allocatable, and a very large pktlen could actually cause our
2481      allocation to wrap around in xmalloc to a small number. */
2482
2483   if (pktlen > MAX_UID_PACKET_LENGTH)
2484     {
2485       log_error ("packet(%d) too large\n", pkttype);
2486       if (list_mode)
2487         es_fprintf (listfp, ":user ID packet: [too large]\n");
2488       iobuf_skip_rest (inp, pktlen, 0);
2489       return GPG_ERR_INV_PACKET;
2490     }
2491
2492   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2493   packet->pkt.user_id->len = pktlen;
2494   packet->pkt.user_id->ref = 1;
2495
2496   p = packet->pkt.user_id->name;
2497   for (; pktlen; pktlen--, p++)
2498     *p = iobuf_get_noeof (inp);
2499   *p = 0;
2500
2501   if (list_mode)
2502     {
2503       int n = packet->pkt.user_id->len;
2504       es_fprintf (listfp, ":user ID packet: \"");
2505       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2506       for (p = packet->pkt.user_id->name; n; p++, n--)
2507         {
2508           if (*p >= ' ' && *p <= 'z')
2509             es_putc (*p, listfp);
2510           else
2511             es_fprintf (listfp, "\\x%02x", *p);
2512         }
2513       es_fprintf (listfp, "\"\n");
2514     }
2515   return 0;
2516 }
2517
2518
2519 void
2520 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2521 {
2522   assert (max_namelen > 70);
2523   if (uid->numattribs <= 0)
2524     sprintf (uid->name, "[bad attribute packet of size %lu]",
2525              uid->attrib_len);
2526   else if (uid->numattribs > 1)
2527     sprintf (uid->name, "[%d attributes of size %lu]",
2528              uid->numattribs, uid->attrib_len);
2529   else
2530     {
2531       /* Only one attribute, so list it as the "user id" */
2532
2533       if (uid->attribs->type == ATTRIB_IMAGE)
2534         {
2535           u32 len;
2536           byte type;
2537
2538           if (parse_image_header (uid->attribs, &type, &len))
2539             sprintf (uid->name, "[%.20s image of size %lu]",
2540                      image_type_to_string (type, 1), (ulong) len);
2541           else
2542             sprintf (uid->name, "[invalid image]");
2543         }
2544       else
2545         sprintf (uid->name, "[unknown attribute of size %lu]",
2546                  (ulong) uid->attribs->len);
2547     }
2548
2549   uid->len = strlen (uid->name);
2550 }
2551
2552
2553 static int
2554 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2555                  PACKET * packet)
2556 {
2557   byte *p;
2558
2559   (void) pkttype;
2560
2561   /* We better cap the size of an attribute packet to make DoS not too
2562      easy.  16MB should be more then enough for one attribute packet
2563      (ie. a photo).  */
2564   if (pktlen > MAX_ATTR_PACKET_LENGTH)
2565     {
2566       log_error ("packet(%d) too large\n", pkttype);
2567       if (list_mode)
2568         es_fprintf (listfp, ":attribute packet: [too large]\n");
2569       iobuf_skip_rest (inp, pktlen, 0);
2570       return GPG_ERR_INV_PACKET;
2571     }
2572
2573 #define EXTRA_UID_NAME_SPACE 71
2574   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2575                                        + EXTRA_UID_NAME_SPACE);
2576   packet->pkt.user_id->ref = 1;
2577   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2578   packet->pkt.user_id->attrib_len = pktlen;
2579
2580   p = packet->pkt.user_id->attrib_data;
2581   for (; pktlen; pktlen--, p++)
2582     *p = iobuf_get_noeof (inp);
2583
2584   /* Now parse out the individual attribute subpackets.  This is
2585      somewhat pointless since there is only one currently defined
2586      attribute type (jpeg), but it is correct by the spec. */
2587   parse_attribute_subpkts (packet->pkt.user_id);
2588
2589   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2590
2591   if (list_mode)
2592     {
2593       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2594     }
2595   return 0;
2596 }
2597
2598
2599 static int
2600 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2601 {
2602   byte *p;
2603
2604   /* Cap comment packet at a reasonable value to avoid an integer
2605      overflow in the malloc below.  Comment packets are actually not
2606      anymore define my OpenPGP and we even stopped to use our
2607      private comment packet.  */
2608   if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2609     {
2610       log_error ("packet(%d) too large\n", pkttype);
2611       if (list_mode)
2612         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2613                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2614       iobuf_skip_rest (inp, pktlen, 0);
2615       return GPG_ERR_INV_PACKET;
2616     }
2617   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2618   packet->pkt.comment->len = pktlen;
2619   p = packet->pkt.comment->data;
2620   for (; pktlen; pktlen--, p++)
2621     *p = iobuf_get_noeof (inp);
2622
2623   if (list_mode)
2624     {
2625       int n = packet->pkt.comment->len;
2626       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2627                   "OpenPGP draft " : "");
2628       for (p = packet->pkt.comment->data; n; p++, n--)
2629         {
2630           if (*p >= ' ' && *p <= 'z')
2631             es_putc (*p, listfp);
2632           else
2633             es_fprintf (listfp, "\\x%02x", *p);
2634         }
2635       es_fprintf (listfp, "\"\n");
2636     }
2637   return 0;
2638 }
2639
2640
2641 static void
2642 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2643 {
2644   int c;
2645
2646   (void) pkttype;
2647
2648   pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2649   if (pktlen)
2650     {
2651       c = iobuf_get_noeof (inp);
2652       pktlen--;
2653       pkt->pkt.ring_trust->trustval = c;
2654       pkt->pkt.ring_trust->sigcache = 0;
2655       if (!c && pktlen == 1)
2656         {
2657           c = iobuf_get_noeof (inp);
2658           pktlen--;
2659           /* We require that bit 7 of the sigcache is 0 (easier eof
2660              handling).  */
2661           if (!(c & 0x80))
2662             pkt->pkt.ring_trust->sigcache = c;
2663         }
2664       if (list_mode)
2665         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2666                     pkt->pkt.ring_trust->trustval,
2667                     pkt->pkt.ring_trust->sigcache);
2668     }
2669   else
2670     {
2671       pkt->pkt.ring_trust->trustval = 0;
2672       pkt->pkt.ring_trust->sigcache = 0;
2673       if (list_mode)
2674         es_fprintf (listfp, ":trust packet: empty\n");
2675     }
2676   iobuf_skip_rest (inp, pktlen, 0);
2677 }
2678
2679
2680 static int
2681 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2682                  PACKET * pkt, int new_ctb, int partial)
2683 {
2684   int rc = 0;
2685   int mode, namelen;
2686   PKT_plaintext *pt;
2687   byte *p;
2688   int c, i;
2689
2690   if (!partial && pktlen < 6)
2691     {
2692       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2693       if (list_mode)
2694         es_fputs (":literal data packet: [too short]\n", listfp);
2695       rc = gpg_error (GPG_ERR_INV_PACKET);
2696       goto leave;
2697     }
2698   mode = iobuf_get_noeof (inp);
2699   if (pktlen)
2700     pktlen--;
2701   namelen = iobuf_get_noeof (inp);
2702   if (pktlen)
2703     pktlen--;
2704   /* Note that namelen will never exceed 255 bytes. */
2705   pt = pkt->pkt.plaintext =
2706     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2707   pt->new_ctb = new_ctb;
2708   pt->mode = mode;
2709   pt->namelen = namelen;
2710   pt->is_partial = partial;
2711   if (pktlen)
2712     {
2713       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2714         pt->name[i] = iobuf_get_noeof (inp);
2715     }
2716   else
2717     {
2718       for (i = 0; i < namelen; i++)
2719         if ((c = iobuf_get (inp)) == -1)
2720           break;
2721         else
2722           pt->name[i] = c;
2723     }
2724   pt->timestamp = read_32 (inp);
2725   if (pktlen)
2726     pktlen -= 4;
2727   pt->len = pktlen;
2728   pt->buf = inp;
2729   pktlen = 0;
2730
2731   if (list_mode)
2732     {
2733       es_fprintf (listfp, ":literal data packet:\n"
2734                   "\tmode %c (%X), created %lu, name=\"",
2735                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2736                   (ulong) pt->timestamp);
2737       for (p = pt->name, i = 0; i < namelen; p++, i++)
2738         {
2739           if (*p >= ' ' && *p <= 'z')
2740             es_putc (*p, listfp);
2741           else
2742             es_fprintf (listfp, "\\x%02x", *p);
2743         }
2744       es_fprintf (listfp, "\",\n\traw data: ");
2745       if (partial)
2746         es_fprintf (listfp, "unknown length\n");
2747       else
2748         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2749     }
2750
2751  leave:
2752   return rc;
2753 }
2754
2755
2756 static int
2757 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2758                   PACKET * pkt, int new_ctb)
2759 {
2760   PKT_compressed *zd;
2761
2762   /* PKTLEN is here 0, but data follows (this should be the last
2763      object in a file or the compress algorithm should know the
2764      length).  */
2765   (void) pkttype;
2766   (void) pktlen;
2767
2768   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2769   zd->algorithm = iobuf_get_noeof (inp);
2770   zd->len = 0;                  /* not used */
2771   zd->new_ctb = new_ctb;
2772   zd->buf = inp;
2773   if (list_mode)
2774     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2775   return 0;
2776 }
2777
2778
2779 static int
2780 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2781                  PACKET * pkt, int new_ctb, int partial)
2782 {
2783   int rc = 0;
2784   PKT_encrypted *ed;
2785   unsigned long orig_pktlen = pktlen;
2786
2787   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2788   /* ed->len is set below.  */
2789   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2790   ed->buf = NULL;
2791   ed->new_ctb = new_ctb;
2792   ed->is_partial = partial;
2793   if (pkttype == PKT_ENCRYPTED_MDC)
2794     {
2795       /* Fixme: add some pktlen sanity checks.  */
2796       int version;
2797
2798       version = iobuf_get_noeof (inp);
2799       if (orig_pktlen)
2800         pktlen--;
2801       if (version != 1)
2802         {
2803           log_error ("encrypted_mdc packet with unknown version %d\n",
2804                      version);
2805           if (list_mode)
2806             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
2807           /*skip_rest(inp, pktlen); should we really do this? */
2808           rc = gpg_error (GPG_ERR_INV_PACKET);
2809           goto leave;
2810         }
2811       ed->mdc_method = DIGEST_ALGO_SHA1;
2812     }
2813   else
2814     ed->mdc_method = 0;
2815
2816   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2817      detection bytes.  Note that we don't known the algorithm and thus
2818      we may only check against the minimum blocksize.  */
2819   if (orig_pktlen && pktlen < 10)
2820     {
2821       /* Actually this is blocksize+2.  */
2822       log_error ("packet(%d) too short\n", pkttype);
2823       if (list_mode)
2824         es_fputs (":encrypted data packet: [too short]\n", listfp);
2825       rc = GPG_ERR_INV_PACKET;
2826       iobuf_skip_rest (inp, pktlen, partial);
2827       goto leave;
2828     }
2829
2830   /* Store the remaining length of the encrypted data (i.e. without
2831      the MDC version number but with the IV etc.).  This value is
2832      required during decryption.  */
2833   ed->len = pktlen;
2834
2835   if (list_mode)
2836     {
2837       if (orig_pktlen)
2838         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2839                     orig_pktlen);
2840       else
2841         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2842       if (ed->mdc_method)
2843         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2844     }
2845
2846   ed->buf = inp;
2847
2848  leave:
2849   return rc;
2850 }
2851
2852
2853 /* Note, that this code is not anymore used in real life because the
2854    MDC checking is now done right after the decryption in
2855    decrypt_data.  */
2856 static int
2857 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2858            PACKET * pkt, int new_ctb)
2859 {
2860   int rc = 0;
2861   PKT_mdc *mdc;
2862   byte *p;
2863
2864   (void) pkttype;
2865
2866   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2867   if (list_mode)
2868     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2869   if (!new_ctb || pktlen != 20)
2870     {
2871       log_error ("mdc_packet with invalid encoding\n");
2872       rc = gpg_error (GPG_ERR_INV_PACKET);
2873       goto leave;
2874     }
2875   p = mdc->hash;
2876   for (; pktlen; pktlen--, p++)
2877     *p = iobuf_get_noeof (inp);
2878
2879  leave:
2880   return rc;
2881 }
2882
2883
2884 /*
2885  * This packet is internally generated by us (ibn armor.c) to transfer
2886  * some information to the lower layer.  To make sure that this packet
2887  * is really a GPG faked one and not one comming from outside, we
2888  * first check that there is a unique tag in it.
2889  *
2890  * The format of such a control packet is:
2891  *   n byte  session marker
2892  *   1 byte  control type CTRLPKT_xxxxx
2893  *   m byte  control data
2894  */
2895 static int
2896 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2897                    PACKET * packet, int partial)
2898 {
2899   byte *p;
2900   const byte *sesmark;
2901   size_t sesmarklen;
2902   int i;
2903
2904   (void) pkttype;
2905
2906   if (list_mode)
2907     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2908
2909   sesmark = get_session_marker (&sesmarklen);
2910   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2911     goto skipit;
2912   for (i = 0; i < sesmarklen; i++, pktlen--)
2913     {
2914       if (sesmark[i] != iobuf_get_noeof (inp))
2915         goto skipit;
2916     }
2917   if (pktlen > 4096)
2918     goto skipit;  /* Definitely too large.  We skip it to avoid an
2919                      overflow in the malloc.  */
2920   if (list_mode)
2921     es_fputs ("- gpg control packet", listfp);
2922
2923   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2924                                      + pktlen - 1);
2925   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2926   pktlen--;
2927   packet->pkt.gpg_control->datalen = pktlen;
2928   p = packet->pkt.gpg_control->data;
2929   for (; pktlen; pktlen--, p++)
2930     *p = iobuf_get_noeof (inp);
2931
2932   return 0;
2933
2934  skipit:
2935   if (list_mode)
2936     {
2937       int c;
2938
2939       i = 0;
2940       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2941       if (partial)
2942         {
2943           while ((c = iobuf_get (inp)) != -1)
2944             dump_hex_line (c, &i);
2945         }
2946       else
2947         {
2948           for (; pktlen; pktlen--)
2949             {
2950               dump_hex_line ((c = iobuf_get (inp)), &i);
2951               if (c == -1)
2952                 break;
2953             }
2954         }
2955       es_putc ('\n', listfp);
2956     }
2957   iobuf_skip_rest (inp, pktlen, 0);
2958   return gpg_error (GPG_ERR_INV_PACKET);
2959 }
2960
2961
2962 /* Create a GPG control packet to be used internally as a placeholder.  */
2963 PACKET *
2964 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2965 {
2966   PACKET *packet;
2967   byte *p;
2968
2969   packet = xmalloc (sizeof *packet);
2970   init_packet (packet);
2971   packet->pkttype = PKT_GPG_CONTROL;
2972   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2973                                      + datalen - 1);
2974   packet->pkt.gpg_control->control = type;
2975   packet->pkt.gpg_control->datalen = datalen;
2976   p = packet->pkt.gpg_control->data;
2977   for (; datalen; datalen--, p++)
2978     *p = *data++;
2979
2980   return packet;
2981 }