Fix stdint.h problem for Apple.
[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       static char dummy[] = "x";
1432       /* Return a value different from NULL to indicate that
1433        * there is no critical bit we do not understand.  */
1434       return reqtype == SIGSUBPKT_TEST_CRITICAL ? dummy : NULL;
1435     }
1436   buffer = pktbuf->data;
1437   buflen = pktbuf->len;
1438   while (buflen)
1439     {
1440       n = *buffer++;
1441       buflen--;
1442       if (n == 255) /* 4 byte length header.  */
1443         {
1444           if (buflen < 4)
1445             goto too_short;
1446           n = (buffer[0] << 24) | (buffer[1] << 16)
1447             | (buffer[2] << 8) | buffer[3];
1448           buffer += 4;
1449           buflen -= 4;
1450         }
1451       else if (n >= 192) /* 4 byte special encoded length header.  */
1452         {
1453           if (buflen < 2)
1454             goto too_short;
1455           n = ((n - 192) << 8) + *buffer + 192;
1456           buffer++;
1457           buflen--;
1458         }
1459       if (buflen < n)
1460         goto too_short;
1461       type = *buffer;
1462       if (type & 0x80)
1463         {
1464           type &= 0x7f;
1465           *critical = 1;
1466         }
1467       else
1468         *critical = 0;
1469       if (!(++seq > reqseq))
1470         ;
1471       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1472         {
1473           if (*critical)
1474             {
1475               if (n - 1 > buflen + 1)
1476                 goto too_short;
1477               if (!can_handle_critical (buffer + 1, n - 1, type))
1478                 {
1479                   if (opt.verbose)
1480                     log_info (_("subpacket of type %d has "
1481                                 "critical bit set\n"), type);
1482                   if (start)
1483                     *start = seq;
1484                   return NULL;  /* This is an error.  */
1485                 }
1486             }
1487         }
1488       else if (reqtype < 0) /* List packets.  */
1489         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1490                          type, *critical, buffer, buflen, n);
1491       else if (type == reqtype) /* Found.  */
1492         {
1493           buffer++;
1494           n--;
1495           if (n > buflen)
1496             goto too_short;
1497           if (ret_n)
1498             *ret_n = n;
1499           offset = parse_one_sig_subpkt (buffer, n, type);
1500           switch (offset)
1501             {
1502             case -2:
1503               log_error ("subpacket of type %d too short\n", type);
1504               return NULL;
1505             case -1:
1506               return NULL;
1507             default:
1508               break;
1509             }
1510           if (start)
1511             *start = seq;
1512           return buffer + offset;
1513         }
1514       buffer += n;
1515       buflen -= n;
1516     }
1517   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1518     return buffer;  /* Used as True to indicate that there is no. */
1519
1520   /* Critical bit we don't understand. */
1521   if (start)
1522     *start = -1;
1523   return NULL;  /* End of packets; not found.  */
1524
1525  too_short:
1526   if (opt.verbose)
1527     log_info ("buffer shorter than subpacket\n");
1528   if (start)
1529     *start = -1;
1530   return NULL;
1531 }
1532
1533
1534 const byte *
1535 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1536                   size_t * ret_n)
1537 {
1538   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1539 }
1540
1541
1542 const byte *
1543 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype,
1544                    size_t * ret_n)
1545 {
1546   const byte *p;
1547
1548   p = parse_sig_subpkt (sig->hashed, reqtype, ret_n);
1549   if (!p)
1550     p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n);
1551   return p;
1552 }
1553
1554
1555 /* Find all revocation keys.  Look in hashed area only.  */
1556 void
1557 parse_revkeys (PKT_signature * sig)
1558 {
1559   struct revocation_key *revkey;
1560   int seq = 0;
1561   size_t len;
1562
1563   if (sig->sig_class != 0x1F)
1564     return;
1565
1566   while ((revkey =
1567           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1568                                                      SIGSUBPKT_REV_KEY,
1569                                                      &len, &seq, NULL)))
1570     {
1571       if (len == sizeof (struct revocation_key)
1572           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1573         {
1574           sig->revkey = xrealloc (sig->revkey,
1575                                   sizeof (struct revocation_key *) *
1576                                   (sig->numrevkeys + 1));
1577           sig->revkey[sig->numrevkeys] = revkey;
1578           sig->numrevkeys++;
1579         }
1580     }
1581 }
1582
1583
1584 int
1585 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1586                  PKT_signature * sig)
1587 {
1588   int md5_len = 0;
1589   unsigned n;
1590   int is_v4 = 0;
1591   int rc = 0;
1592   int i, ndata;
1593
1594   if (pktlen < 16)
1595     {
1596       log_error ("packet(%d) too short\n", pkttype);
1597       if (list_mode)
1598         es_fputs (":signature packet: [too short]\n", listfp);
1599       goto leave;
1600     }
1601   sig->version = iobuf_get_noeof (inp);
1602   pktlen--;
1603   if (sig->version == 4)
1604     is_v4 = 1;
1605   else if (sig->version != 2 && sig->version != 3)
1606     {
1607       log_error ("packet(%d) with unknown version %d\n",
1608                  pkttype, sig->version);
1609       if (list_mode)
1610         es_fputs (":signature packet: [unknown version]\n", listfp);
1611       rc = gpg_error (GPG_ERR_INV_PACKET);
1612       goto leave;
1613     }
1614
1615   if (!is_v4)
1616     {
1617       md5_len = iobuf_get_noeof (inp);
1618       pktlen--;
1619     }
1620   sig->sig_class = iobuf_get_noeof (inp);
1621   pktlen--;
1622   if (!is_v4)
1623     {
1624       sig->timestamp = read_32 (inp);
1625       pktlen -= 4;
1626       sig->keyid[0] = read_32 (inp);
1627       pktlen -= 4;
1628       sig->keyid[1] = read_32 (inp);
1629       pktlen -= 4;
1630     }
1631   sig->pubkey_algo = iobuf_get_noeof (inp);
1632   pktlen--;
1633   sig->digest_algo = iobuf_get_noeof (inp);
1634   pktlen--;
1635   sig->flags.exportable = 1;
1636   sig->flags.revocable = 1;
1637   if (is_v4) /* Read subpackets.  */
1638     {
1639       n = read_16 (inp);
1640       pktlen -= 2;  /* Length of hashed data. */
1641       if (n > 10000)
1642         {
1643           log_error ("signature packet: hashed data too long\n");
1644           if (list_mode)
1645             es_fputs (":signature packet: [hashed data too long]\n", listfp);
1646           rc = G10ERR_INVALID_PACKET;
1647           goto leave;
1648         }
1649       if (n)
1650         {
1651           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1652           sig->hashed->size = n;
1653           sig->hashed->len = n;
1654           if (iobuf_read (inp, sig->hashed->data, n) != n)
1655             {
1656               log_error ("premature eof while reading "
1657                          "hashed signature data\n");
1658               if (list_mode)
1659                 es_fputs (":signature packet: [premature eof]\n", listfp);
1660               rc = -1;
1661               goto leave;
1662             }
1663           pktlen -= n;
1664         }
1665       n = read_16 (inp);
1666       pktlen -= 2;  /* Length of unhashed data.  */
1667       if (n > 10000)
1668         {
1669           log_error ("signature packet: unhashed data too long\n");
1670           if (list_mode)
1671             es_fputs (":signature packet: [unhashed data too long]\n", listfp);
1672           rc = G10ERR_INVALID_PACKET;
1673           goto leave;
1674         }
1675       if (n)
1676         {
1677           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1678           sig->unhashed->size = n;
1679           sig->unhashed->len = n;
1680           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1681             {
1682               log_error ("premature eof while reading "
1683                          "unhashed signature data\n");
1684               if (list_mode)
1685                 es_fputs (":signature packet: [premature eof]\n", listfp);
1686               rc = -1;
1687               goto leave;
1688             }
1689           pktlen -= n;
1690         }
1691     }
1692
1693   if (pktlen < 5)  /* Sanity check.  */
1694     {
1695       log_error ("packet(%d) too short\n", pkttype);
1696       if (list_mode)
1697         es_fputs (":signature packet: [too short]\n", listfp);
1698       rc = G10ERR_INVALID_PACKET;
1699       goto leave;
1700     }
1701
1702   sig->digest_start[0] = iobuf_get_noeof (inp);
1703   pktlen--;
1704   sig->digest_start[1] = iobuf_get_noeof (inp);
1705   pktlen--;
1706
1707   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1708     {
1709       const byte *p;
1710       size_t len;
1711
1712       /* Set sig->flags.unknown_critical if there is a critical bit
1713        * set for packets which we do not understand.  */
1714       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1715           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1716         sig->flags.unknown_critical = 1;
1717
1718       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1719       if (p)
1720         sig->timestamp = buffer_to_u32 (p);
1721       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1722                && opt.verbose)
1723         log_info ("signature packet without timestamp\n");
1724
1725       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER, NULL);
1726       if (p)
1727         {
1728           sig->keyid[0] = buffer_to_u32 (p);
1729           sig->keyid[1] = buffer_to_u32 (p + 4);
1730         }
1731       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1732                && opt.verbose)
1733         log_info ("signature packet without keyid\n");
1734
1735       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1736       if (p && buffer_to_u32 (p))
1737         sig->expiredate = sig->timestamp + buffer_to_u32 (p);
1738       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1739         sig->flags.expired = 1;
1740
1741       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1742       if (p)
1743         sig->flags.policy_url = 1;
1744
1745       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1746       if (p)
1747         sig->flags.pref_ks = 1;
1748
1749       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1750       if (p)
1751         sig->flags.notation = 1;
1752
1753       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1754       if (p && *p == 0)
1755         sig->flags.revocable = 0;
1756
1757       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1758       if (p && len == 2)
1759         {
1760           sig->trust_depth = p[0];
1761           sig->trust_value = p[1];
1762
1763           /* Only look for a regexp if there is also a trust
1764              subpacket. */
1765           sig->trust_regexp =
1766             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1767
1768           /* If the regular expression is of 0 length, there is no
1769              regular expression. */
1770           if (len == 0)
1771             sig->trust_regexp = NULL;
1772         }
1773
1774       /* We accept the exportable subpacket from either the hashed or
1775          unhashed areas as older versions of gpg put it in the
1776          unhashed area.  In theory, anyway, we should never see this
1777          packet off of a local keyring. */
1778
1779       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE, NULL);
1780       if (p && *p == 0)
1781         sig->flags.exportable = 0;
1782
1783       /* Find all revocation keys.  */
1784       if (sig->sig_class == 0x1F)
1785         parse_revkeys (sig);
1786     }
1787
1788   if (list_mode)
1789     {
1790       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1791                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1792                   "\tdigest algo %d, begin of digest %02x %02x\n",
1793                   sig->pubkey_algo,
1794                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1795                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1796                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1797       if (is_v4)
1798         {
1799           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1800           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1801         }
1802     }
1803
1804   ndata = pubkey_get_nsig (sig->pubkey_algo);
1805   if (!ndata)
1806     {
1807       if (list_mode)
1808         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1809       unknown_pubkey_warning (sig->pubkey_algo);
1810
1811       /* We store the plain material in data[0], so that we are able
1812        * to write it back with build_packet().  */
1813       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1814         {
1815           /* We include a limit to avoid too trivial DoS attacks by
1816              having gpg allocate too much memory.  */
1817           log_error ("signature packet: too much data\n");
1818           rc = G10ERR_INVALID_PACKET;
1819         }
1820       else
1821         {
1822           sig->data[0] =
1823             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen), pktlen * 8);
1824           pktlen = 0;
1825         }
1826     }
1827   else
1828     {
1829       for (i = 0; i < ndata; i++)
1830         {
1831           n = pktlen;
1832           sig->data[i] = mpi_read (inp, &n, 0);
1833           pktlen -= n;
1834           if (list_mode)
1835             {
1836               es_fprintf (listfp, "\tdata: ");
1837               mpi_print (listfp, sig->data[i], mpi_print_mode);
1838               es_putc ('\n', listfp);
1839             }
1840           if (!sig->data[i])
1841             rc = G10ERR_INVALID_PACKET;
1842         }
1843     }
1844
1845  leave:
1846   iobuf_skip_rest (inp, pktlen, 0);
1847   return rc;
1848 }
1849
1850
1851 static int
1852 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1853                    PKT_onepass_sig * ops)
1854 {
1855   int version;
1856   int rc = 0;
1857
1858   if (pktlen < 13)
1859     {
1860       log_error ("packet(%d) too short\n", pkttype);
1861       if (list_mode)
1862         es_fputs (":onepass_sig packet: [too short]\n", listfp);
1863       rc = gpg_error (GPG_ERR_INV_PACKET);
1864       goto leave;
1865     }
1866   version = iobuf_get_noeof (inp);
1867   pktlen--;
1868   if (version != 3)
1869     {
1870       log_error ("onepass_sig with unknown version %d\n", version);
1871       if (list_mode)
1872         es_fputs (":onepass_sig packet: [unknown version]\n", listfp);
1873       rc = gpg_error (GPG_ERR_INV_PACKET);
1874       goto leave;
1875     }
1876   ops->sig_class = iobuf_get_noeof (inp);
1877   pktlen--;
1878   ops->digest_algo = iobuf_get_noeof (inp);
1879   pktlen--;
1880   ops->pubkey_algo = iobuf_get_noeof (inp);
1881   pktlen--;
1882   ops->keyid[0] = read_32 (inp);
1883   pktlen -= 4;
1884   ops->keyid[1] = read_32 (inp);
1885   pktlen -= 4;
1886   ops->last = iobuf_get_noeof (inp);
1887   pktlen--;
1888   if (list_mode)
1889     es_fprintf (listfp,
1890                 ":onepass_sig packet: keyid %08lX%08lX\n"
1891                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1892                 "last=%d\n",
1893                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1894                 version, ops->sig_class,
1895                 ops->digest_algo, ops->pubkey_algo, ops->last);
1896
1897
1898  leave:
1899   iobuf_skip_rest (inp, pktlen, 0);
1900   return rc;
1901 }
1902
1903
1904 static int
1905 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1906            byte * hdr, int hdrlen, PACKET * pkt)
1907 {
1908   gpg_error_t err = 0;
1909   int i, version, algorithm;
1910   unsigned long timestamp, expiredate, max_expiredate;
1911   int npkey, nskey;
1912   int rc = 0;
1913   u32 keyid[2];
1914   PKT_public_key *pk;
1915
1916   (void) hdr;
1917
1918   pk = pkt->pkt.public_key; /* PK has been cleared. */
1919
1920   version = iobuf_get_noeof (inp);
1921   pktlen--;
1922   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1923     {
1924       /* Early versions of G10 used the old PGP comments packets;
1925        * luckily all those comments are started by a hash.  */
1926       if (list_mode)
1927         {
1928           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1929           for (; pktlen; pktlen--)
1930             {
1931               int c;
1932               c = iobuf_get (inp);
1933               if (c == -1)
1934                 break; /* Ooops: shorter than indicated.  */
1935               if (c >= ' ' && c <= 'z')
1936                 es_putc (c, listfp);
1937               else
1938                 es_fprintf (listfp, "\\x%02x", c);
1939             }
1940           es_fprintf (listfp, "\"\n");
1941         }
1942       iobuf_skip_rest (inp, pktlen, 0);
1943       return 0;
1944     }
1945   else if (version == 4)
1946     {
1947       /* The only supported version.  Use an older gpg
1948          versions (i.e. gpg 1.4 to parse v3 packets).  */
1949     }
1950   else if (version == 2 || version == 3)
1951     {
1952       if (opt.verbose > 1)
1953         log_info ("packet(%d) with obsolete version %d\n", pkttype, version);
1954       if (list_mode)
1955         es_fprintf (listfp, ":key packet: [obsolete version %d]\n", version);
1956       err = gpg_error (GPG_ERR_INV_PACKET);
1957       goto leave;
1958     }
1959   else
1960     {
1961       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1962       if (list_mode)
1963         es_fputs (":key packet: [unknown version]\n", listfp);
1964       err = gpg_error (GPG_ERR_INV_PACKET);
1965       goto leave;
1966     }
1967
1968   if (pktlen < 11)
1969     {
1970       log_error ("packet(%d) too short\n", pkttype);
1971       if (list_mode)
1972         es_fputs (":key packet: [too short]\n", listfp);
1973       err = gpg_error (GPG_ERR_INV_PACKET);
1974       goto leave;
1975     }
1976
1977   timestamp = read_32 (inp);
1978   pktlen -= 4;
1979   expiredate = 0;               /* have to get it from the selfsignature */
1980   max_expiredate = 0;
1981   algorithm = iobuf_get_noeof (inp);
1982   pktlen--;
1983   if (list_mode)
1984     es_fprintf (listfp, ":%s key packet:\n"
1985                 "\tversion %d, algo %d, created %lu, expires %lu\n",
1986                 pkttype == PKT_PUBLIC_KEY ? "public" :
1987                 pkttype == PKT_SECRET_KEY ? "secret" :
1988                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
1989                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
1990                 version, algorithm, timestamp, expiredate);
1991
1992   pk->timestamp = timestamp;
1993   pk->expiredate = expiredate;
1994   pk->max_expiredate = max_expiredate;
1995   pk->hdrbytes = hdrlen;
1996   pk->version = version;
1997   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
1998   pk->pubkey_algo = algorithm;
1999
2000   nskey = pubkey_get_nskey (algorithm);
2001   npkey = pubkey_get_npkey (algorithm);
2002   if (!npkey)
2003     {
2004       if (list_mode)
2005         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
2006       unknown_pubkey_warning (algorithm);
2007     }
2008
2009   if (!npkey)
2010     {
2011       /* Unknown algorithm - put data into an opaque MPI.  */
2012       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
2013                                          read_rest (inp, pktlen), pktlen * 8);
2014       pktlen = 0;
2015       goto leave;
2016     }
2017   else
2018     {
2019       for (i = 0; i < npkey; i++)
2020         {
2021           if (    (algorithm == PUBKEY_ALGO_ECDSA && (i == 0))
2022                || (algorithm == PUBKEY_ALGO_EDDSA && (i == 0))
2023                || (algorithm == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
2024             {
2025               /* Read the OID (i==1) or the KDF params (i==2).  */
2026               size_t n;
2027               err = read_size_body (inp, pktlen, &n, pk->pkey+i);
2028               pktlen -= n;
2029             }
2030           else
2031             {
2032               unsigned int n = pktlen;
2033               pk->pkey[i] = mpi_read (inp, &n, 0);
2034               pktlen -= n;
2035               if (!pk->pkey[i])
2036                 err = gpg_error (GPG_ERR_INV_PACKET);
2037             }
2038           if (err)
2039             goto leave;
2040           if (list_mode)
2041             {
2042               es_fprintf (listfp, "\tpkey[%d]: ", i);
2043               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2044               if ((algorithm == PUBKEY_ALGO_ECDSA
2045                    || algorithm == PUBKEY_ALGO_EDDSA
2046                    || algorithm == PUBKEY_ALGO_ECDH) && i==0)
2047                 {
2048                   char *curve = openpgp_oid_to_str (pk->pkey[0]);
2049                   es_fprintf (listfp, " %s (%s)",
2050                               openpgp_oid_to_curve (curve), curve);
2051                   xfree (curve);
2052                 }
2053               es_putc ('\n', listfp);
2054             }
2055         }
2056     }
2057   if (list_mode)
2058     keyid_from_pk (pk, keyid);
2059
2060   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2061     {
2062       struct seckey_info *ski;
2063       byte temp[16];
2064       size_t snlen = 0;
2065
2066       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2067       if (!pk->seckey_info)
2068         {
2069           err = gpg_error_from_syserror ();
2070           goto leave;
2071         }
2072
2073       ski->algo = iobuf_get_noeof (inp);
2074       pktlen--;
2075       if (ski->algo)
2076         {
2077           ski->is_protected = 1;
2078           ski->s2k.count = 0;
2079           if (ski->algo == 254 || ski->algo == 255)
2080             {
2081               if (pktlen < 3)
2082                 {
2083                   err = gpg_error (GPG_ERR_INV_PACKET);
2084                   goto leave;
2085                 }
2086               ski->sha1chk = (ski->algo == 254);
2087               ski->algo = iobuf_get_noeof (inp);
2088               pktlen--;
2089               /* Note that a ski->algo > 110 is illegal, but I'm not
2090                  erroring on it here as otherwise there would be no
2091                  way to delete such a key.  */
2092               ski->s2k.mode = iobuf_get_noeof (inp);
2093               pktlen--;
2094               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2095               pktlen--;
2096               /* Check for the special GNU extension.  */
2097               if (ski->s2k.mode == 101)
2098                 {
2099                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2100                     temp[i] = iobuf_get_noeof (inp);
2101                   if (i < 4 || memcmp (temp, "GNU", 3))
2102                     {
2103                       if (list_mode)
2104                         es_fprintf (listfp, "\tunknown S2K %d\n",
2105                                     ski->s2k.mode);
2106                       err = gpg_error (GPG_ERR_INV_PACKET);
2107                       goto leave;
2108                     }
2109                   /* Here we know that it is a GNU extension.  What
2110                    * follows is the GNU protection mode: All values
2111                    * have special meanings and they are mapped to MODE
2112                    * with a base of 1000.  */
2113                   ski->s2k.mode = 1000 + temp[3];
2114                 }
2115
2116               /* Read the salt.  */
2117               switch (ski->s2k.mode)
2118                 {
2119                 case 1:
2120                 case 3:
2121                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2122                     temp[i] = iobuf_get_noeof (inp);
2123                   memcpy (ski->s2k.salt, temp, 8);
2124                   break;
2125                 }
2126
2127               /* Check the mode.  */
2128               switch (ski->s2k.mode)
2129                 {
2130                 case 0:
2131                   if (list_mode)
2132                     es_fprintf (listfp, "\tsimple S2K");
2133                   break;
2134                 case 1:
2135                   if (list_mode)
2136                     es_fprintf (listfp, "\tsalted S2K");
2137                   break;
2138                 case 3:
2139                   if (list_mode)
2140                     es_fprintf (listfp, "\titer+salt S2K");
2141                   break;
2142                 case 1001:
2143                   if (list_mode)
2144                     es_fprintf (listfp, "\tgnu-dummy S2K");
2145                   break;
2146                 case 1002:
2147                   if (list_mode)
2148                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2149                   break;
2150                 default:
2151                   if (list_mode)
2152                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2153                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2154                                 ski->s2k.mode);
2155                   err = gpg_error (GPG_ERR_INV_PACKET);
2156                   goto leave;
2157                 }
2158
2159               /* Print some info.  */
2160               if (list_mode)
2161                 {
2162                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2163                               ski->algo,
2164                               ski->sha1chk ? " SHA1 protection,"
2165                               : " simple checksum,", ski->s2k.hash_algo);
2166                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2167                     {
2168                       es_fprintf (listfp, ", salt: ");
2169                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2170                     }
2171                   es_putc ('\n', listfp);
2172                 }
2173
2174               /* Read remaining protection parameters.  */
2175               if (ski->s2k.mode == 3)
2176                 {
2177                   if (pktlen < 1)
2178                     {
2179                       err = gpg_error (GPG_ERR_INV_PACKET);
2180                       goto leave;
2181                     }
2182                   ski->s2k.count = iobuf_get (inp);
2183                   pktlen--;
2184                   if (list_mode)
2185                     es_fprintf (listfp, "\tprotect count: %lu (%lu)\n",
2186                                 (ulong)S2K_DECODE_COUNT ((ulong)ski->s2k.count),
2187                                 (ulong) ski->s2k.count);
2188                 }
2189               else if (ski->s2k.mode == 1002)
2190                 {
2191                   /* Read the serial number. */
2192                   if (pktlen < 1)
2193                     {
2194                       err = gpg_error (GPG_ERR_INV_PACKET);
2195                       goto leave;
2196                     }
2197                   snlen = iobuf_get (inp);
2198                   pktlen--;
2199                   if (pktlen < snlen || snlen == (size_t)(-1))
2200                     {
2201                       err = gpg_error (GPG_ERR_INV_PACKET);
2202                       goto leave;
2203                     }
2204                 }
2205             }
2206           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2207             {
2208               /* Note that a ski->algo > 110 is illegal, but I'm not
2209                  erroring on it here as otherwise there would be no
2210                  way to delete such a key.  */
2211               ski->s2k.mode = 0;
2212               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2213               if (list_mode)
2214                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2215                             ski->algo, ski->s2k.hash_algo);
2216             }
2217
2218           /* It is really ugly that we don't know the size
2219            * of the IV here in cases we are not aware of the algorithm.
2220            * so a
2221            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2222            * won't work.  The only solution I see is to hardwire it.
2223            * NOTE: if you change the ivlen above 16, don't forget to
2224            * enlarge temp.  */
2225           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2226           assert (ski->ivlen <= sizeof (temp));
2227
2228           if (ski->s2k.mode == 1001)
2229             ski->ivlen = 0;
2230           else if (ski->s2k.mode == 1002)
2231             ski->ivlen = snlen < 16 ? snlen : 16;
2232
2233           if (pktlen < ski->ivlen)
2234             {
2235               err = gpg_error (GPG_ERR_INV_PACKET);
2236               goto leave;
2237             }
2238           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2239             temp[i] = iobuf_get_noeof (inp);
2240           if (list_mode)
2241             {
2242               es_fprintf (listfp,
2243                           ski->s2k.mode == 1002 ? "\tserial-number: "
2244                           : "\tprotect IV: ");
2245               for (i = 0; i < ski->ivlen; i++)
2246                 es_fprintf (listfp, " %02x", temp[i]);
2247               es_putc ('\n', listfp);
2248             }
2249           memcpy (ski->iv, temp, ski->ivlen);
2250         }
2251
2252       /* It does not make sense to read it into secure memory.
2253        * If the user is so careless, not to protect his secret key,
2254        * we can assume, that he operates an open system :=(.
2255        * So we put the key into secure memory when we unprotect it. */
2256       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2257         {
2258           /* Better set some dummy stuff here.  */
2259           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2260                                                  xstrdup ("dummydata"),
2261                                                  10 * 8);
2262           pktlen = 0;
2263         }
2264       else if (ski->is_protected)
2265         {
2266           /* Ugly: The length is encrypted too, so we read all stuff
2267            * up to the end of the packet into the first SKEY
2268            * element.  */
2269           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2270                                                  read_rest (inp, pktlen),
2271                                                  pktlen * 8);
2272           /* Mark that MPI as protected - we need this information for
2273              importing a key.  The OPAQUE flag can't be used because
2274              we also store public EdDSA values in opaque MPIs.  */
2275           if (pk->pkey[npkey])
2276             gcry_mpi_set_flag (pk->pkey[npkey], GCRYMPI_FLAG_USER1);
2277           pktlen = 0;
2278           if (list_mode)
2279             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2280         }
2281       else
2282         {
2283           /* Not encrypted.  */
2284           for (i = npkey; i < nskey; i++)
2285             {
2286               unsigned int n = pktlen;
2287               pk->pkey[i] = mpi_read (inp, &n, 0);
2288               pktlen -= n;
2289               if (list_mode)
2290                 {
2291                   es_fprintf (listfp, "\tskey[%d]: ", i);
2292                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2293                   es_putc ('\n', listfp);
2294                 }
2295
2296               if (!pk->pkey[i])
2297                 err = gpg_error (GPG_ERR_INV_PACKET);
2298             }
2299           if (err)
2300             goto leave;
2301
2302           ski->csum = read_16 (inp);
2303           pktlen -= 2;
2304           if (list_mode)
2305             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2306         }
2307     }
2308
2309   if (list_mode)
2310     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2311                 (ulong) keyid[0], (ulong) keyid[1]);
2312
2313  leave:
2314   iobuf_skip_rest (inp, pktlen, 0);
2315   return rc;
2316 }
2317
2318
2319 /* Attribute subpackets have the same format as v4 signature
2320    subpackets.  This is not part of OpenPGP, but is done in several
2321    versions of PGP nevertheless.  */
2322 int
2323 parse_attribute_subpkts (PKT_user_id * uid)
2324 {
2325   size_t n;
2326   int count = 0;
2327   struct user_attribute *attribs = NULL;
2328   const byte *buffer = uid->attrib_data;
2329   int buflen = uid->attrib_len;
2330   byte type;
2331
2332   xfree (uid->attribs);
2333
2334   while (buflen)
2335     {
2336       n = *buffer++;
2337       buflen--;
2338       if (n == 255)  /* 4 byte length header.  */
2339         {
2340           if (buflen < 4)
2341             goto too_short;
2342           n = (buffer[0] << 24) | (buffer[1] << 16)
2343             | (buffer[2] << 8) | buffer[3];
2344           buffer += 4;
2345           buflen -= 4;
2346         }
2347       else if (n >= 192)  /* 2 byte special encoded length header.  */
2348         {
2349           if (buflen < 2)
2350             goto too_short;
2351           n = ((n - 192) << 8) + *buffer + 192;
2352           buffer++;
2353           buflen--;
2354         }
2355       if (buflen < n)
2356         goto too_short;
2357
2358       attribs =
2359         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2360       memset (&attribs[count], 0, sizeof (struct user_attribute));
2361
2362       type = *buffer;
2363       buffer++;
2364       buflen--;
2365       n--;
2366
2367       attribs[count].type = type;
2368       attribs[count].data = buffer;
2369       attribs[count].len = n;
2370       buffer += n;
2371       buflen -= n;
2372       count++;
2373     }
2374
2375   uid->attribs = attribs;
2376   uid->numattribs = count;
2377   return count;
2378
2379  too_short:
2380   if (opt.verbose)
2381     log_info ("buffer shorter than attribute subpacket\n");
2382   uid->attribs = attribs;
2383   uid->numattribs = count;
2384   return count;
2385 }
2386
2387
2388 static int
2389 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2390 {
2391   byte *p;
2392
2393   /* Cap the size of a user ID at 2k: a value absurdly large enough
2394      that there is no sane user ID string (which is printable text
2395      as of RFC2440bis) that won't fit in it, but yet small enough to
2396      avoid allocation problems.  A large pktlen may not be
2397      allocatable, and a very large pktlen could actually cause our
2398      allocation to wrap around in xmalloc to a small number. */
2399
2400   if (pktlen > 2048)
2401     {
2402       log_error ("packet(%d) too large\n", pkttype);
2403       if (list_mode)
2404         es_fprintf (listfp, ":user ID packet: [too large]\n");
2405       iobuf_skip_rest (inp, pktlen, 0);
2406       return G10ERR_INVALID_PACKET;
2407     }
2408
2409   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2410   packet->pkt.user_id->len = pktlen;
2411   packet->pkt.user_id->ref = 1;
2412
2413   p = packet->pkt.user_id->name;
2414   for (; pktlen; pktlen--, p++)
2415     *p = iobuf_get_noeof (inp);
2416   *p = 0;
2417
2418   if (list_mode)
2419     {
2420       int n = packet->pkt.user_id->len;
2421       es_fprintf (listfp, ":user ID packet: \"");
2422       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2423       for (p = packet->pkt.user_id->name; n; p++, n--)
2424         {
2425           if (*p >= ' ' && *p <= 'z')
2426             es_putc (*p, listfp);
2427           else
2428             es_fprintf (listfp, "\\x%02x", *p);
2429         }
2430       es_fprintf (listfp, "\"\n");
2431     }
2432   return 0;
2433 }
2434
2435
2436 void
2437 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2438 {
2439   assert (max_namelen > 70);
2440   if (uid->numattribs <= 0)
2441     sprintf (uid->name, "[bad attribute packet of size %lu]",
2442              uid->attrib_len);
2443   else if (uid->numattribs > 1)
2444     sprintf (uid->name, "[%d attributes of size %lu]",
2445              uid->numattribs, uid->attrib_len);
2446   else
2447     {
2448       /* Only one attribute, so list it as the "user id" */
2449
2450       if (uid->attribs->type == ATTRIB_IMAGE)
2451         {
2452           u32 len;
2453           byte type;
2454
2455           if (parse_image_header (uid->attribs, &type, &len))
2456             sprintf (uid->name, "[%.20s image of size %lu]",
2457                      image_type_to_string (type, 1), (ulong) len);
2458           else
2459             sprintf (uid->name, "[invalid image]");
2460         }
2461       else
2462         sprintf (uid->name, "[unknown attribute of size %lu]",
2463                  (ulong) uid->attribs->len);
2464     }
2465
2466   uid->len = strlen (uid->name);
2467 }
2468
2469
2470 static int
2471 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2472                  PACKET * packet)
2473 {
2474   byte *p;
2475
2476   (void) pkttype;
2477
2478   /* We better cap the size of an attribute packet to make DoS not too
2479      easy.  16MB should be more then enough for one attribute packet
2480      (ie. a photo).  */
2481   if (pktlen > 16*1024*1024)
2482     {
2483       log_error ("packet(%d) too large\n", pkttype);
2484       if (list_mode)
2485         es_fprintf (listfp, ":attribute packet: [too large]\n");
2486       iobuf_skip_rest (inp, pktlen, 0);
2487       return G10ERR_INVALID_PACKET;
2488     }
2489
2490 #define EXTRA_UID_NAME_SPACE 71
2491   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2492                                        + EXTRA_UID_NAME_SPACE);
2493   packet->pkt.user_id->ref = 1;
2494   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2495   packet->pkt.user_id->attrib_len = pktlen;
2496
2497   p = packet->pkt.user_id->attrib_data;
2498   for (; pktlen; pktlen--, p++)
2499     *p = iobuf_get_noeof (inp);
2500
2501   /* Now parse out the individual attribute subpackets.  This is
2502      somewhat pointless since there is only one currently defined
2503      attribute type (jpeg), but it is correct by the spec. */
2504   parse_attribute_subpkts (packet->pkt.user_id);
2505
2506   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2507
2508   if (list_mode)
2509     {
2510       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2511     }
2512   return 0;
2513 }
2514
2515
2516 static int
2517 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2518 {
2519   byte *p;
2520
2521   /* Cap comment packet at a reasonable value to avoid an integer
2522      overflow in the malloc below.  Comment packets are actually not
2523      anymore define my OpenPGP and we even stopped to use our
2524      private comment packet.  */
2525   if (pktlen > 65536)
2526     {
2527       log_error ("packet(%d) too large\n", pkttype);
2528       if (list_mode)
2529         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2530                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2531       iobuf_skip_rest (inp, pktlen, 0);
2532       return G10ERR_INVALID_PACKET;
2533     }
2534   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2535   packet->pkt.comment->len = pktlen;
2536   p = packet->pkt.comment->data;
2537   for (; pktlen; pktlen--, p++)
2538     *p = iobuf_get_noeof (inp);
2539
2540   if (list_mode)
2541     {
2542       int n = packet->pkt.comment->len;
2543       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2544                   "OpenPGP draft " : "");
2545       for (p = packet->pkt.comment->data; n; p++, n--)
2546         {
2547           if (*p >= ' ' && *p <= 'z')
2548             es_putc (*p, listfp);
2549           else
2550             es_fprintf (listfp, "\\x%02x", *p);
2551         }
2552       es_fprintf (listfp, "\"\n");
2553     }
2554   return 0;
2555 }
2556
2557
2558 static void
2559 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2560 {
2561   int c;
2562
2563   (void) pkttype;
2564
2565   if (pktlen)
2566     {
2567       c = iobuf_get_noeof (inp);
2568       pktlen--;
2569       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2570       pkt->pkt.ring_trust->trustval = c;
2571       pkt->pkt.ring_trust->sigcache = 0;
2572       if (!c && pktlen == 1)
2573         {
2574           c = iobuf_get_noeof (inp);
2575           pktlen--;
2576           /* We require that bit 7 of the sigcache is 0 (easier eof
2577              handling).  */
2578           if (!(c & 0x80))
2579             pkt->pkt.ring_trust->sigcache = c;
2580         }
2581       if (list_mode)
2582         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2583                     pkt->pkt.ring_trust->trustval,
2584                     pkt->pkt.ring_trust->sigcache);
2585     }
2586   else
2587     {
2588       if (list_mode)
2589         es_fprintf (listfp, ":trust packet: empty\n");
2590     }
2591   iobuf_skip_rest (inp, pktlen, 0);
2592 }
2593
2594
2595 static int
2596 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2597                  PACKET * pkt, int new_ctb, int partial)
2598 {
2599   int rc = 0;
2600   int mode, namelen;
2601   PKT_plaintext *pt;
2602   byte *p;
2603   int c, i;
2604
2605   if (!partial && pktlen < 6)
2606     {
2607       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2608       if (list_mode)
2609         es_fputs (":literal data packet: [too short]\n", listfp);
2610       rc = gpg_error (GPG_ERR_INV_PACKET);
2611       goto leave;
2612     }
2613   mode = iobuf_get_noeof (inp);
2614   if (pktlen)
2615     pktlen--;
2616   namelen = iobuf_get_noeof (inp);
2617   if (pktlen)
2618     pktlen--;
2619   /* Note that namelen will never exceed 255 bytes. */
2620   pt = pkt->pkt.plaintext =
2621     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2622   pt->new_ctb = new_ctb;
2623   pt->mode = mode;
2624   pt->namelen = namelen;
2625   pt->is_partial = partial;
2626   if (pktlen)
2627     {
2628       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2629         pt->name[i] = iobuf_get_noeof (inp);
2630     }
2631   else
2632     {
2633       for (i = 0; i < namelen; i++)
2634         if ((c = iobuf_get (inp)) == -1)
2635           break;
2636         else
2637           pt->name[i] = c;
2638     }
2639   pt->timestamp = read_32 (inp);
2640   if (pktlen)
2641     pktlen -= 4;
2642   pt->len = pktlen;
2643   pt->buf = inp;
2644   pktlen = 0;
2645
2646   if (list_mode)
2647     {
2648       es_fprintf (listfp, ":literal data packet:\n"
2649                   "\tmode %c (%X), created %lu, name=\"",
2650                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2651                   (ulong) pt->timestamp);
2652       for (p = pt->name, i = 0; i < namelen; p++, i++)
2653         {
2654           if (*p >= ' ' && *p <= 'z')
2655             es_putc (*p, listfp);
2656           else
2657             es_fprintf (listfp, "\\x%02x", *p);
2658         }
2659       es_fprintf (listfp, "\",\n\traw data: ");
2660       if (partial)
2661         es_fprintf (listfp, "unknown length\n");
2662       else
2663         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2664     }
2665
2666  leave:
2667   return rc;
2668 }
2669
2670
2671 static int
2672 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2673                   PACKET * pkt, int new_ctb)
2674 {
2675   PKT_compressed *zd;
2676
2677   /* PKTLEN is here 0, but data follows (this should be the last
2678      object in a file or the compress algorithm should know the
2679      length).  */
2680   (void) pkttype;
2681   (void) pktlen;
2682
2683   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2684   zd->algorithm = iobuf_get_noeof (inp);
2685   zd->len = 0;                  /* not used */
2686   zd->new_ctb = new_ctb;
2687   zd->buf = inp;
2688   if (list_mode)
2689     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2690   return 0;
2691 }
2692
2693
2694 static int
2695 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2696                  PACKET * pkt, int new_ctb, int partial)
2697 {
2698   int rc = 0;
2699   PKT_encrypted *ed;
2700   unsigned long orig_pktlen = pktlen;
2701
2702   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2703   /* ed->len is set below.  */
2704   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2705   ed->buf = NULL;
2706   ed->new_ctb = new_ctb;
2707   ed->is_partial = partial;
2708   if (pkttype == PKT_ENCRYPTED_MDC)
2709     {
2710       /* Fixme: add some pktlen sanity checks.  */
2711       int version;
2712
2713       version = iobuf_get_noeof (inp);
2714       if (orig_pktlen)
2715         pktlen--;
2716       if (version != 1)
2717         {
2718           log_error ("encrypted_mdc packet with unknown version %d\n",
2719                      version);
2720           if (list_mode)
2721             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
2722           /*skip_rest(inp, pktlen); should we really do this? */
2723           rc = gpg_error (GPG_ERR_INV_PACKET);
2724           goto leave;
2725         }
2726       ed->mdc_method = DIGEST_ALGO_SHA1;
2727     }
2728   else
2729     ed->mdc_method = 0;
2730
2731   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2732      detection bytes.  Note that we don't known the algorithm and thus
2733      we may only check against the minimum blocksize.  */
2734   if (orig_pktlen && pktlen < 10)
2735     {
2736       /* Actually this is blocksize+2.  */
2737       log_error ("packet(%d) too short\n", pkttype);
2738       if (list_mode)
2739         es_fputs (":encrypted data packet: [too short]\n", listfp);
2740       rc = G10ERR_INVALID_PACKET;
2741       iobuf_skip_rest (inp, pktlen, partial);
2742       goto leave;
2743     }
2744
2745   /* Store the remaining length of the encrypted data (i.e. without
2746      the MDC version number but with the IV etc.).  This value is
2747      required during decryption.  */
2748   ed->len = pktlen;
2749
2750   if (list_mode)
2751     {
2752       if (orig_pktlen)
2753         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2754                     orig_pktlen);
2755       else
2756         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2757       if (ed->mdc_method)
2758         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2759     }
2760
2761   ed->buf = inp;
2762
2763  leave:
2764   return rc;
2765 }
2766
2767
2768 /* Note, that this code is not anymore used in real life because the
2769    MDC checking is now done right after the decryption in
2770    decrypt_data.  */
2771 static int
2772 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2773            PACKET * pkt, int new_ctb)
2774 {
2775   int rc = 0;
2776   PKT_mdc *mdc;
2777   byte *p;
2778
2779   (void) pkttype;
2780
2781   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2782   if (list_mode)
2783     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2784   if (!new_ctb || pktlen != 20)
2785     {
2786       log_error ("mdc_packet with invalid encoding\n");
2787       rc = gpg_error (GPG_ERR_INV_PACKET);
2788       goto leave;
2789     }
2790   p = mdc->hash;
2791   for (; pktlen; pktlen--, p++)
2792     *p = iobuf_get_noeof (inp);
2793
2794  leave:
2795   return rc;
2796 }
2797
2798
2799 /*
2800  * This packet is internally generated by us (ibn armor.c) to transfer
2801  * some information to the lower layer.  To make sure that this packet
2802  * is really a GPG faked one and not one comming from outside, we
2803  * first check that there is a unique tag in it.
2804  *
2805  * The format of such a control packet is:
2806  *   n byte  session marker
2807  *   1 byte  control type CTRLPKT_xxxxx
2808  *   m byte  control data
2809  */
2810 static int
2811 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2812                    PACKET * packet, int partial)
2813 {
2814   byte *p;
2815   const byte *sesmark;
2816   size_t sesmarklen;
2817   int i;
2818
2819   (void) pkttype;
2820
2821   if (list_mode)
2822     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2823
2824   sesmark = get_session_marker (&sesmarklen);
2825   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2826     goto skipit;
2827   for (i = 0; i < sesmarklen; i++, pktlen--)
2828     {
2829       if (sesmark[i] != iobuf_get_noeof (inp))
2830         goto skipit;
2831     }
2832   if (pktlen > 4096)
2833     goto skipit;  /* Definitely too large.  We skip it to avoid an
2834                      overflow in the malloc.  */
2835   if (list_mode)
2836     puts ("- gpg control packet");
2837
2838   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2839                                      + pktlen - 1);
2840   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2841   pktlen--;
2842   packet->pkt.gpg_control->datalen = pktlen;
2843   p = packet->pkt.gpg_control->data;
2844   for (; pktlen; pktlen--, p++)
2845     *p = iobuf_get_noeof (inp);
2846
2847   return 0;
2848
2849  skipit:
2850   if (list_mode)
2851     {
2852       int c;
2853
2854       i = 0;
2855       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2856       if (partial)
2857         {
2858           while ((c = iobuf_get (inp)) != -1)
2859             dump_hex_line (c, &i);
2860         }
2861       else
2862         {
2863           for (; pktlen; pktlen--)
2864             {
2865               dump_hex_line ((c = iobuf_get (inp)), &i);
2866               if (c == -1)
2867                 break;
2868             }
2869         }
2870       es_putc ('\n', listfp);
2871     }
2872   iobuf_skip_rest (inp, pktlen, 0);
2873   return gpg_error (GPG_ERR_INV_PACKET);
2874 }
2875
2876
2877 /* Create a GPG control packet to be used internally as a placeholder.  */
2878 PACKET *
2879 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2880 {
2881   PACKET *packet;
2882   byte *p;
2883
2884   packet = xmalloc (sizeof *packet);
2885   init_packet (packet);
2886   packet->pkttype = PKT_GPG_CONTROL;
2887   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2888                                      + datalen - 1);
2889   packet->pkt.gpg_control->control = type;
2890   packet->pkt.gpg_control->datalen = datalen;
2891   p = packet->pkt.gpg_control->data;
2892   for (; datalen; datalen--, p++)
2893     *p = *data++;
2894
2895   return packet;
2896 }