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