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