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