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