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