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