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