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