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