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