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