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