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