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