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