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