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