Function name cleanups
[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 "cipher.h"
32 #include "filter.h"
33 #include "photoid.h"
34 #include "options.h"
35 #include "main.h"
36 #include "i18n.h"
37
38 static int mpi_print_mode;
39 static int list_mode;
40 static estream_t listfp;
41
42 static int parse (IOBUF inp, PACKET * pkt, int onlykeypkts,
43                   off_t * retpos, int *skip, IOBUF out, int do_skip
44 #ifdef DEBUG_PARSE_PACKET
45                   , const char *dbg_w, const char *dbg_f, int dbg_l
46 #endif
47   );
48 static int copy_packet (IOBUF inp, IOBUF out, int pkttype,
49                         unsigned long pktlen, int partial);
50 static void skip_packet (IOBUF inp, int pkttype,
51                          unsigned long pktlen, int partial);
52 static void *read_rest (IOBUF inp, size_t pktlen, int partial);
53 static int parse_marker (IOBUF inp, int pkttype, unsigned long pktlen);
54 static int parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
55                             PACKET * packet);
56 static int parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
57                             PACKET * packet);
58 static int parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
59                               PKT_onepass_sig * ops);
60 static int parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
61                       byte * hdr, int hdrlen, PACKET * packet);
62 static int parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen,
63                           PACKET * packet);
64 static int parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
65                             PACKET * packet);
66 static int parse_comment (IOBUF inp, int pkttype, unsigned long pktlen,
67                           PACKET * packet);
68 static void parse_trust (IOBUF inp, int pkttype, unsigned long pktlen,
69                          PACKET * packet);
70 static int parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
71                             PACKET * packet, int new_ctb, int partial);
72 static int parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
73                              PACKET * packet, int new_ctb);
74 static int parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
75                             PACKET * packet, int new_ctb, int partial);
76 static int parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
77                       PACKET * packet, int new_ctb);
78 static int parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
79                               PACKET * packet, int partial);
80
81 static unsigned short
82 read_16 (IOBUF inp)
83 {
84   unsigned short a;
85   a = iobuf_get_noeof (inp) << 8;
86   a |= iobuf_get_noeof (inp);
87   return a;
88 }
89
90
91 static unsigned long
92 read_32 (IOBUF inp)
93 {
94   unsigned long a;
95   a = iobuf_get_noeof (inp) << 24;
96   a |= iobuf_get_noeof (inp) << 16;
97   a |= iobuf_get_noeof (inp) << 8;
98   a |= iobuf_get_noeof (inp);
99   return a;
100 }
101
102
103 /* Read an external representation of an mpi and return the MPI.  The
104  * external format is a 16 bit unsigned value stored in network byte
105  * order, giving the number of bits for the following integer. The
106  * integer is stored with MSB first (left padded with zeroes to align
107  * on a byte boundary).  */
108 static gcry_mpi_t
109 mpi_read (iobuf_t inp, unsigned int *ret_nread, int secure)
110 {
111   /*FIXME: Needs to be synced with gnupg14/mpi/mpicoder.c */
112
113   int c, c1, c2, i;
114   unsigned int nbits, nbytes;
115   size_t nread = 0;
116   gcry_mpi_t a = NULL;
117   byte *buf = NULL;
118   byte *p;
119
120   if ((c = c1 = iobuf_get (inp)) == -1)
121     goto leave;
122   nbits = c << 8;
123   if ((c = c2 = iobuf_get (inp)) == -1)
124     goto leave;
125   nbits |= c;
126   if (nbits > MAX_EXTERN_MPI_BITS)
127     {
128       log_error ("mpi too large (%u bits)\n", nbits);
129       goto leave;
130     }
131   nread = 2;
132   nbytes = (nbits + 7) / 8;
133   buf = secure ? gcry_xmalloc_secure (nbytes + 2) : gcry_xmalloc (nbytes + 2);
134   p = buf;
135   p[0] = c1;
136   p[1] = c2;
137   for (i = 0; i < nbytes; i++)
138     {
139       p[i + 2] = iobuf_get (inp) & 0xff;
140       nread++;
141     }
142
143   if (nread >= 2 && !(buf[0] << 8 | buf[1]))
144     {
145       /* Libgcrypt < 1.5.0 accidently rejects zero-length (i.e. zero)
146          MPIs.  We fix this here.  */
147       a = gcry_mpi_new (0);
148     }
149   else
150     {
151       if (gcry_mpi_scan (&a, GCRYMPI_FMT_PGP, buf, nread, &nread))
152         a = NULL;
153     }
154
155  leave:
156   gcry_free (buf);
157   if (nread > *ret_nread)
158     log_bug ("mpi larger than packet");
159   else
160     *ret_nread = nread;
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 static void *
724 read_rest (IOBUF inp, size_t pktlen, int partial)
725 {
726   byte *p;
727   int i;
728
729   if (partial)
730     {
731       log_error ("read_rest: can't store stream data\n");
732       p = NULL;
733     }
734   else
735     {
736       p = xmalloc (pktlen);
737       for (i = 0; pktlen; pktlen--, i++)
738         p[i] = iobuf_get (inp);
739     }
740   return p;
741 }
742
743
744 /*
745  * Read a special size+body from inp into body[body_max_size] and
746  * return it in a buffer and as MPI.  On success the number of
747  * consumed bytes will body[0]+1.  The format of the content of the
748  * returned MPI is one byte LEN, following by LEN bytes.  Caller is
749  * expected to pre-allocate fixed-size 255 byte buffer (or smaller
750  * when appropriate).
751  */
752 static int
753 read_size_body (iobuf_t inp, byte *body, int body_max_size,
754                 int pktlen, gcry_mpi_t *out )
755 {
756   unsigned int n;
757   int rc;
758   gcry_mpi_t result;
759
760   *out = NULL;
761
762   if( (n = iobuf_readbyte(inp)) == -1 )
763     {
764       return G10ERR_INVALID_PACKET;
765     }
766   if ( n >= body_max_size || n < 2)
767     {
768       log_error("invalid size+body field\n");
769       return G10ERR_INVALID_PACKET;
770     }
771   body[0] = n;
772   if ((n = iobuf_read(inp, body+1, n)) == -1)
773     {
774       log_error("invalid size+body field\n");
775       return G10ERR_INVALID_PACKET;
776     }
777   if (n+1 > pktlen)
778     {
779       log_error("size+body field is larger than the packet\n");
780       return G10ERR_INVALID_PACKET;
781     }
782   rc = gcry_mpi_scan (&result, GCRYMPI_FMT_USG, body, n+1, NULL);
783   if (rc)
784     log_fatal ("mpi_scan failed: %s\n", gpg_strerror (rc));
785
786   *out = result;
787
788   return rc;
789 }
790
791
792 /* Parse a marker packet.  */
793 static int
794 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
795 {
796   (void) pkttype;
797
798   if (pktlen != 3)
799     goto fail;
800
801   if (iobuf_get (inp) != 'P')
802     {
803       pktlen--;
804       goto fail;
805     }
806
807   if (iobuf_get (inp) != 'G')
808     {
809       pktlen--;
810       goto fail;
811     }
812
813   if (iobuf_get (inp) != 'P')
814     {
815       pktlen--;
816       goto fail;
817     }
818
819   if (list_mode)
820     es_fputs (":marker packet: PGP\n", listfp);
821
822   return 0;
823
824  fail:
825   log_error ("invalid marker packet\n");
826   iobuf_skip_rest (inp, pktlen, 0);
827   return G10ERR_INVALID_PACKET;
828 }
829
830
831 static int
832 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
833                  PACKET * packet)
834 {
835   PKT_symkey_enc *k;
836   int rc = 0;
837   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
838
839   if (pktlen < 4)
840     {
841       log_error ("packet(%d) too short\n", pkttype);
842       rc = gpg_error (GPG_ERR_INV_PACKET);
843       goto leave;
844     }
845   version = iobuf_get_noeof (inp);
846   pktlen--;
847   if (version != 4)
848     {
849       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
850       rc = gpg_error (GPG_ERR_INV_PACKET);
851       goto leave;
852     }
853   if (pktlen > 200)
854     {                           /* (we encode the seskeylen in a byte) */
855       log_error ("packet(%d) too large\n", pkttype);
856       rc = gpg_error (GPG_ERR_INV_PACKET);
857       goto leave;
858     }
859   cipher_algo = iobuf_get_noeof (inp);
860   pktlen--;
861   s2kmode = iobuf_get_noeof (inp);
862   pktlen--;
863   hash_algo = iobuf_get_noeof (inp);
864   pktlen--;
865   switch (s2kmode)
866     {
867     case 0: /* Simple S2K.  */
868       minlen = 0;
869       break;
870     case 1: /* Salted S2K.  */
871       minlen = 8;
872       break;
873     case 3: /* Iterated+salted S2K.  */
874       minlen = 9;
875       break;
876     default:
877       log_error ("unknown S2K mode %d\n", s2kmode);
878       goto leave;
879     }
880   if (minlen > pktlen)
881     {
882       log_error ("packet with S2K %d too short\n", s2kmode);
883       rc = gpg_error (GPG_ERR_INV_PACKET);
884       goto leave;
885     }
886   seskeylen = pktlen - minlen;
887   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
888                                               + seskeylen - 1);
889   k->version = version;
890   k->cipher_algo = cipher_algo;
891   k->s2k.mode = s2kmode;
892   k->s2k.hash_algo = hash_algo;
893   if (s2kmode == 1 || s2kmode == 3)
894     {
895       for (i = 0; i < 8 && pktlen; i++, pktlen--)
896         k->s2k.salt[i] = iobuf_get_noeof (inp);
897     }
898   if (s2kmode == 3)
899     {
900       k->s2k.count = iobuf_get (inp);
901       pktlen--;
902     }
903   k->seskeylen = seskeylen;
904   if (k->seskeylen)
905     {
906       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
907         k->seskey[i] = iobuf_get_noeof (inp);
908
909       /* What we're watching out for here is a session key decryptor
910          with no salt.  The RFC says that using salt for this is a
911          MUST. */
912       if (s2kmode != 1 && s2kmode != 3)
913         log_info (_("WARNING: potentially insecure symmetrically"
914                     " encrypted session key\n"));
915     }
916   assert (!pktlen);
917
918   if (list_mode)
919     {
920       es_fprintf (listfp,
921                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
922                   version, cipher_algo, s2kmode, hash_algo);
923       if (seskeylen)
924         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
925       es_fprintf (listfp, "\n");
926       if (s2kmode == 1 || s2kmode == 3)
927         {
928           es_fprintf (listfp, "\tsalt ");
929           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
930           if (s2kmode == 3)
931             es_fprintf (listfp, ", count %lu (%lu)",
932                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
933                         (ulong) k->s2k.count);
934           es_fprintf (listfp, "\n");
935         }
936     }
937
938  leave:
939   iobuf_skip_rest (inp, pktlen, 0);
940   return rc;
941 }
942
943
944 static int
945 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
946                  PACKET * packet)
947 {
948   unsigned int n;
949   int rc = 0;
950   int i, ndata;
951   PKT_pubkey_enc *k;
952
953   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
954   if (pktlen < 12)
955     {
956       log_error ("packet(%d) too short\n", pkttype);
957       rc = gpg_error (GPG_ERR_INV_PACKET);
958       goto leave;
959     }
960   k->version = iobuf_get_noeof (inp);
961   pktlen--;
962   if (k->version != 2 && k->version != 3)
963     {
964       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
965       rc = gpg_error (GPG_ERR_INV_PACKET);
966       goto leave;
967     }
968   k->keyid[0] = read_32 (inp);
969   pktlen -= 4;
970   k->keyid[1] = read_32 (inp);
971   pktlen -= 4;
972   k->pubkey_algo = iobuf_get_noeof (inp);
973   pktlen--;
974   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
975   if (list_mode)
976     es_fprintf (listfp,
977                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
978                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
979                 (ulong) k->keyid[1]);
980
981   ndata = pubkey_get_nenc (k->pubkey_algo);
982   if (!ndata)
983     {
984       if (list_mode)
985         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
986       unknown_pubkey_warning (k->pubkey_algo);
987       k->data[0] = NULL; /* No need to store the encrypted data.  */
988     }
989   else
990     {
991       if (k->pubkey_algo == PUBKEY_ALGO_ECDH)
992         {
993           byte encr_buf[255];
994           
995           assert (ndata == 2);
996           n = pktlen;
997           k->data[0] = mpi_read (inp, &n, 0);
998           pktlen -= n;
999           rc = read_size_body (inp, encr_buf, sizeof(encr_buf),
1000                                pktlen, k->data+1);
1001           if (rc)
1002             goto leave;
1003
1004           if (list_mode)
1005             {
1006               es_fprintf (listfp, "\tdata: ");
1007               mpi_print (listfp, k->data[0], mpi_print_mode );
1008               es_putc ('\n', listfp);
1009               es_fprintf (listfp, "\tdata: [% 3d bytes] ", encr_buf[0]+1);
1010               mpi_print (listfp, k->data[1], mpi_print_mode );
1011               es_putc ('\n', listfp);
1012             }
1013           pktlen -= (encr_buf[0]+1);
1014         }
1015       else
1016         {
1017           for (i = 0; i < ndata; i++)
1018             {
1019               n = pktlen;
1020               k->data[i] = mpi_read (inp, &n, 0);
1021               pktlen -= n;
1022               if (list_mode)
1023                 {
1024                   es_fprintf (listfp, "\tdata: ");
1025                   mpi_print (listfp, k->data[i], mpi_print_mode);
1026                   es_putc ('\n', listfp);
1027                 }
1028               if (!k->data[i])
1029                 rc = gpg_error (GPG_ERR_INV_PACKET);
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, 0),
1764                                  pktlen * 8);
1765           pktlen = 0;
1766         }
1767     }
1768   else
1769     {
1770       for (i = 0; i < ndata; i++)
1771         {
1772           n = pktlen;
1773           sig->data[i] = mpi_read (inp, &n, 0);
1774           pktlen -= n;
1775           if (list_mode)
1776             {
1777               es_fprintf (listfp, "\tdata: ");
1778               mpi_print (listfp, sig->data[i], mpi_print_mode);
1779               es_putc ('\n', listfp);
1780             }
1781           if (!sig->data[i])
1782             rc = G10ERR_INVALID_PACKET;
1783         }
1784     }
1785
1786  leave:
1787   iobuf_skip_rest (inp, pktlen, 0);
1788   return rc;
1789 }
1790
1791
1792 static int
1793 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1794                    PKT_onepass_sig * ops)
1795 {
1796   int version;
1797   int rc = 0;
1798
1799   if (pktlen < 13)
1800     {
1801       log_error ("packet(%d) too short\n", pkttype);
1802       rc = gpg_error (GPG_ERR_INV_PACKET);
1803       goto leave;
1804     }
1805   version = iobuf_get_noeof (inp);
1806   pktlen--;
1807   if (version != 3)
1808     {
1809       log_error ("onepass_sig with unknown version %d\n", version);
1810       rc = gpg_error (GPG_ERR_INV_PACKET);
1811       goto leave;
1812     }
1813   ops->sig_class = iobuf_get_noeof (inp);
1814   pktlen--;
1815   ops->digest_algo = iobuf_get_noeof (inp);
1816   pktlen--;
1817   ops->pubkey_algo = iobuf_get_noeof (inp);
1818   pktlen--;
1819   ops->keyid[0] = read_32 (inp);
1820   pktlen -= 4;
1821   ops->keyid[1] = read_32 (inp);
1822   pktlen -= 4;
1823   ops->last = iobuf_get_noeof (inp);
1824   pktlen--;
1825   if (list_mode)
1826     es_fprintf (listfp,
1827                 ":onepass_sig packet: keyid %08lX%08lX\n"
1828                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1829                 "last=%d\n",
1830                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1831                 version, ops->sig_class,
1832                 ops->digest_algo, ops->pubkey_algo, ops->last);
1833
1834
1835  leave:
1836   iobuf_skip_rest (inp, pktlen, 0);
1837   return rc;
1838 }
1839
1840
1841 static gcry_mpi_t
1842 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1843 {
1844   int c;
1845   unsigned int nbits, nbytes;
1846   unsigned char *buf, *p;
1847   gcry_mpi_t val;
1848
1849   if (*length < 2)
1850     {
1851       log_error ("mpi too small\n");
1852       return NULL;
1853     }
1854
1855   if ((c = iobuf_get (inp)) == -1)
1856     return NULL;
1857   --*length;
1858   nbits = c << 8;
1859   if ((c = iobuf_get (inp)) == -1)
1860     return NULL;
1861   --*length;
1862   nbits |= c;
1863
1864   if (nbits > 16384)
1865     {
1866       log_error ("mpi too large (%u bits)\n", nbits);
1867       return NULL;
1868     }
1869   nbytes = (nbits + 7) / 8;
1870   buf = p = xmalloc (2 + nbytes);
1871   *p++ = nbits >> 8;
1872   *p++ = nbits;
1873   for (; nbytes && *length; nbytes--, --*length)
1874     *p++ = iobuf_get (inp);
1875   if (nbytes)
1876     {
1877       log_error ("packet shorter than mpi\n");
1878       xfree (buf);
1879       return NULL;
1880     }
1881
1882   /* Convert buffer into an opaque MPI.  */
1883   val = gcry_mpi_set_opaque (NULL, buf, (p - buf) * 8);
1884   return val;
1885 }
1886
1887
1888 static int
1889 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1890            byte * hdr, int hdrlen, PACKET * pkt)
1891 {
1892   gpg_error_t err = 0;
1893   int i, version, algorithm;
1894   unsigned n;
1895   unsigned long timestamp, expiredate, max_expiredate;
1896   int npkey, nskey;
1897   int is_v4 = 0;
1898   int rc = 0;
1899   u32 keyid[2];
1900   PKT_public_key *pk;
1901
1902   (void) hdr;
1903
1904   pk = pkt->pkt.public_key; /* PK has been cleared. */
1905
1906   version = iobuf_get_noeof (inp);
1907   pktlen--;
1908   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1909     {
1910       /* Early versions of G10 used the old PGP comments packets;
1911        * luckily all those comments are started by a hash.  */
1912       if (list_mode)
1913         {
1914           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1915           for (; pktlen; pktlen--)
1916             {
1917               int c;
1918               c = iobuf_get_noeof (inp);
1919               if (c >= ' ' && c <= 'z')
1920                 es_putc (c, listfp);
1921               else
1922                 es_fprintf (listfp, "\\x%02x", c);
1923             }
1924           es_fprintf (listfp, "\"\n");
1925         }
1926       iobuf_skip_rest (inp, pktlen, 0);
1927       return 0;
1928     }
1929   else if (version == 4)
1930     is_v4 = 1;
1931   else if (version != 2 && version != 3)
1932     {
1933       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1934       err = gpg_error (GPG_ERR_INV_PACKET);
1935       goto leave;
1936     }
1937
1938   if (pktlen < 11)
1939     {
1940       log_error ("packet(%d) too short\n", pkttype);
1941       err = gpg_error (GPG_ERR_INV_PACKET);
1942       goto leave;
1943     }
1944
1945   timestamp = read_32 (inp);
1946   pktlen -= 4;
1947   if (is_v4)
1948     {
1949       expiredate = 0;           /* have to get it from the selfsignature */
1950       max_expiredate = 0;
1951     }
1952   else
1953     {
1954       unsigned short ndays;
1955       ndays = read_16 (inp);
1956       pktlen -= 2;
1957       if (ndays)
1958         expiredate = timestamp + ndays * 86400L;
1959       else
1960         expiredate = 0;
1961
1962       max_expiredate = expiredate;
1963     }
1964   algorithm = iobuf_get_noeof (inp);
1965   pktlen--;
1966   if (list_mode)
1967     es_fprintf (listfp, ":%s key packet:\n"
1968                 "\tversion %d, algo %d, created %lu, expires %lu\n",
1969                 pkttype == PKT_PUBLIC_KEY ? "public" :
1970                 pkttype == PKT_SECRET_KEY ? "secret" :
1971                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
1972                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
1973                 version, algorithm, timestamp, expiredate);
1974
1975   pk->timestamp = timestamp;
1976   pk->expiredate = expiredate;
1977   pk->max_expiredate = max_expiredate;
1978   pk->hdrbytes = hdrlen;
1979   pk->version = version;
1980   pk->flags.primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
1981   pk->pubkey_algo = algorithm;
1982
1983   nskey = pubkey_get_nskey (algorithm);
1984   npkey = pubkey_get_npkey (algorithm);
1985   if (!npkey)
1986     {
1987       if (list_mode)
1988         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
1989       unknown_pubkey_warning (algorithm);
1990     }
1991
1992
1993   if (!npkey)
1994     {
1995       /* Unknown algorithm - put data into an opaque MPI.  */
1996       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
1997                                          read_rest (inp, pktlen, 0),
1998                                          pktlen * 8);
1999       pktlen = 0;
2000       goto leave;
2001     }
2002   else
2003     {
2004       /* Fill in public key parameters.  */
2005       if (algorithm == PUBKEY_ALGO_ECDSA || algorithm == PUBKEY_ALGO_ECDH)
2006         {
2007           /* FIXME: The code in this function ignores the errors.  */
2008           byte name_oid[256];
2009           
2010           err = read_size_body (inp, name_oid, sizeof(name_oid),
2011                                 pktlen, pk->pkey+0);
2012           if (err)
2013             goto leave;
2014           n = name_oid[0];
2015           if (list_mode)
2016             es_fprintf (listfp, "\tpkey[0]: curve OID [%d] ...%02x %02x\n", 
2017                         n, name_oid[1+n-2], name_oid[1+n-1]);
2018           pktlen -= (n+1);
2019           /* Set item [1], which corresponds to the public key; these
2020              two fields are all we need to uniquely define the key/ */
2021           n = pktlen;
2022           pk->pkey[1] = mpi_read( inp, &n, 0 );
2023           pktlen -=n;
2024           if (!pk->pkey[1])
2025             err = gpg_error (GPG_ERR_INV_PACKET);
2026           else if (list_mode)
2027             {
2028               es_fprintf (listfp, "\tpkey[1]: ");
2029               mpi_print (listfp, pk->pkey[1], mpi_print_mode);
2030               es_putc ('\n', listfp);
2031             }
2032           /* One more field for ECDH. */
2033           if (algorithm == PUBKEY_ALGO_ECDH)
2034             {
2035               /* (NAMEOID holds the KEK params.)  */
2036               err = read_size_body (inp, name_oid, sizeof(name_oid),
2037                                     pktlen, pk->pkey+2);
2038               if (err)
2039                 goto leave;
2040               n = name_oid[0];
2041               if (name_oid[1] != 1)
2042                 {
2043                   log_error ("invalid ecdh KEK parameters field type in "
2044                              "private key: understand type 1, "
2045                              "but found 0x%02x\n", name_oid[1]);
2046                   err = gpg_error (GPG_ERR_INV_PACKET);
2047                   goto leave;
2048                 }
2049               if (list_mode)
2050                 es_fprintf (listfp, "\tpkey[2]: KEK params type=01 "
2051                             "hash:%d sym-algo:%d\n",
2052                             name_oid[1+n-2], name_oid[1+n-1]);
2053               pktlen -= (n+1);
2054             }
2055         }
2056       else
2057         {
2058           for (i = 0; i < npkey; i++)
2059             {
2060               n = pktlen;
2061               pk->pkey[i] = mpi_read (inp, &n, 0);
2062               pktlen -= n;
2063               if (list_mode)
2064                 {
2065                   es_fprintf (listfp, "\tpkey[%d]: ", i);
2066                   mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2067                   es_putc ('\n', listfp);
2068                 }
2069               if (!pk->pkey[i])
2070                 err = gpg_error (GPG_ERR_INV_PACKET);
2071             }
2072         }
2073       if (err)
2074         goto leave;
2075     }
2076
2077   if (list_mode)
2078     keyid_from_pk (pk, keyid);
2079
2080   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
2081     {
2082       struct seckey_info *ski;
2083       byte temp[16];
2084       size_t snlen = 0;
2085
2086       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
2087       if (!pk->seckey_info)
2088         {
2089           err = gpg_error_from_syserror ();
2090           goto leave;
2091         }
2092
2093       ski->algo = iobuf_get_noeof (inp);
2094       pktlen--;
2095       if (ski->algo)
2096         {
2097           ski->is_protected = 1;
2098           ski->s2k.count = 0;
2099           if (ski->algo == 254 || ski->algo == 255)
2100             {
2101               if (pktlen < 3)
2102                 {
2103                   err = gpg_error (GPG_ERR_INV_PACKET);
2104                   goto leave;
2105                 }
2106               ski->sha1chk = (ski->algo == 254);
2107               ski->algo = iobuf_get_noeof (inp);
2108               pktlen--;
2109               /* Note that a ski->algo > 110 is illegal, but I'm not
2110                  erroring on it here as otherwise there would be no
2111                  way to delete such a key.  */
2112               ski->s2k.mode = iobuf_get_noeof (inp);
2113               pktlen--;
2114               ski->s2k.hash_algo = iobuf_get_noeof (inp);
2115               pktlen--;
2116               /* Check for the special GNU extension.  */
2117               if (is_v4 && ski->s2k.mode == 101)
2118                 {
2119                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
2120                     temp[i] = iobuf_get_noeof (inp);
2121                   if (i < 4 || memcmp (temp, "GNU", 3))
2122                     {
2123                       if (list_mode)
2124                         es_fprintf (listfp, "\tunknown S2K %d\n",
2125                                     ski->s2k.mode);
2126                       err = gpg_error (GPG_ERR_INV_PACKET);
2127                       goto leave;
2128                     }
2129                   /* Here we know that it is a GNU extension.  What
2130                    * follows is the GNU protection mode: All values
2131                    * have special meanings and they are mapped to MODE
2132                    * with a base of 1000.  */
2133                   ski->s2k.mode = 1000 + temp[3];
2134                 }
2135
2136               /* Read the salt.  */
2137               switch (ski->s2k.mode)
2138                 {
2139                 case 1:
2140                 case 3:
2141                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2142                     temp[i] = iobuf_get_noeof (inp);
2143                   memcpy (ski->s2k.salt, temp, 8);
2144                   break;
2145                 }
2146
2147               /* Check the mode.  */
2148               switch (ski->s2k.mode)
2149                 {
2150                 case 0:
2151                   if (list_mode)
2152                     es_fprintf (listfp, "\tsimple S2K");
2153                   break;
2154                 case 1:
2155                   if (list_mode)
2156                     es_fprintf (listfp, "\tsalted S2K");
2157                   break;
2158                 case 3:
2159                   if (list_mode)
2160                     es_fprintf (listfp, "\titer+salt S2K");
2161                   break;
2162                 case 1001:
2163                   if (list_mode)
2164                     es_fprintf (listfp, "\tgnu-dummy S2K");
2165                   break;
2166                 case 1002:
2167                   if (list_mode)
2168                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2169                   break;
2170                 default:
2171                   if (list_mode)
2172                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2173                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2174                                 ski->s2k.mode);
2175                   err = gpg_error (GPG_ERR_INV_PACKET);
2176                   goto leave;
2177                 }
2178
2179               /* Print some info.  */
2180               if (list_mode)
2181                 {
2182                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2183                               ski->algo,
2184                               ski->sha1chk ? " SHA1 protection,"
2185                               : " simple checksum,", ski->s2k.hash_algo);
2186                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2187                     {
2188                       es_fprintf (listfp, ", salt: ");
2189                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2190                     }
2191                   es_putc ('\n', listfp);
2192                 }
2193
2194               /* Read remaining protection parameters.  */
2195               if (ski->s2k.mode == 3)
2196                 {
2197                   if (pktlen < 1)
2198                     {
2199                       err = gpg_error (GPG_ERR_INV_PACKET);
2200                       goto leave;
2201                     }
2202                   ski->s2k.count = iobuf_get (inp);
2203                   pktlen--;
2204                   if (list_mode)
2205                     es_fprintf (listfp, "\tprotect count: %lu\n",
2206                                 (ulong) ski->s2k.count);
2207                 }
2208               else if (ski->s2k.mode == 1002)
2209                 {
2210                   /* Read the serial number. */
2211                   if (pktlen < 1)
2212                     {
2213                       err = gpg_error (GPG_ERR_INV_PACKET);
2214                       goto leave;
2215                     }
2216                   snlen = iobuf_get (inp);
2217                   pktlen--;
2218                   if (pktlen < snlen || snlen == (size_t)(-1))
2219                     {
2220                       err = gpg_error (GPG_ERR_INV_PACKET);
2221                       goto leave;
2222                     }
2223                 }
2224             }
2225           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2226             { 
2227               /* Note that a ski->algo > 110 is illegal, but I'm not
2228                  erroring on it here as otherwise there would be no
2229                  way to delete such a key.  */
2230               ski->s2k.mode = 0;
2231               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2232               if (list_mode)
2233                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2234                             ski->algo, ski->s2k.hash_algo);
2235             }
2236           
2237           /* It is really ugly that we don't know the size
2238            * of the IV here in cases we are not aware of the algorithm.
2239            * so a
2240            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2241            * won't work.  The only solution I see is to hardwire it.
2242            * NOTE: if you change the ivlen above 16, don't forget to
2243            * enlarge temp.  */
2244           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2245           assert (ski->ivlen <= sizeof (temp));
2246
2247           if (ski->s2k.mode == 1001)
2248             ski->ivlen = 0;
2249           else if (ski->s2k.mode == 1002)
2250             ski->ivlen = snlen < 16 ? snlen : 16;
2251
2252           if (pktlen < ski->ivlen)
2253             {
2254               err = gpg_error (GPG_ERR_INV_PACKET);
2255               goto leave;
2256             }
2257           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2258             temp[i] = iobuf_get_noeof (inp);
2259           if (list_mode)
2260             {
2261               es_fprintf (listfp,
2262                           ski->s2k.mode == 1002 ? "\tserial-number: "
2263                           : "\tprotect IV: ");
2264               for (i = 0; i < ski->ivlen; i++)
2265                 es_fprintf (listfp, " %02x", temp[i]);
2266               es_putc ('\n', listfp);
2267             }
2268           memcpy (ski->iv, temp, ski->ivlen);
2269         }
2270
2271       /* It does not make sense to read it into secure memory.
2272        * If the user is so careless, not to protect his secret key,
2273        * we can assume, that he operates an open system :=(.
2274        * So we put the key into secure memory when we unprotect it. */
2275       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2276         {
2277           /* Better set some dummy stuff here.  */
2278           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2279                                                  xstrdup ("dummydata"),
2280                                                  10 * 8);
2281           pktlen = 0;
2282         }
2283       else if (is_v4 && ski->is_protected)
2284         {
2285           /* Ugly: The length is encrypted too, so we read all stuff
2286            * up to the end of the packet into the first SKEY
2287            * element.  */
2288           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2289                                                  read_rest (inp, pktlen, 0),
2290                                                  pktlen * 8);
2291           pktlen = 0;
2292           if (list_mode)
2293             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2294         }
2295       else 
2296         {       
2297           /* The v3 method: The mpi length is not encrypted.  */
2298           for (i = npkey; i < nskey; i++)
2299             {
2300               if (ski->is_protected)
2301                 {
2302                   pk->pkey[i] = read_protected_v3_mpi (inp, &pktlen);
2303                   if (list_mode)
2304                     es_fprintf (listfp, "\tskey[%d]: [v3 protected]\n", i);
2305                 }
2306               else
2307                 {
2308                   n = pktlen;
2309                   pk->pkey[i] = mpi_read (inp, &n, 0);
2310                   pktlen -= n;
2311                   if (list_mode)
2312                     {
2313                       es_fprintf (listfp, "\tskey[%d]: ", i);
2314                       mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2315                       es_putc ('\n', listfp);
2316                     }
2317                 }
2318
2319               if (!pk->pkey[i])
2320                 err = gpg_error (GPG_ERR_INV_PACKET);
2321             }
2322           if (err)
2323             goto leave;
2324
2325           ski->csum = read_16 (inp);
2326           pktlen -= 2;
2327           if (list_mode)
2328             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2329         }
2330     }
2331
2332   if (list_mode)
2333     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2334                 (ulong) keyid[0], (ulong) keyid[1]);
2335
2336  leave:
2337   iobuf_skip_rest (inp, pktlen, 0);
2338   return rc;
2339 }
2340
2341
2342 /* Attribute subpackets have the same format as v4 signature
2343    subpackets.  This is not part of OpenPGP, but is done in several
2344    versions of PGP nevertheless.  */
2345 int
2346 parse_attribute_subpkts (PKT_user_id * uid)
2347 {
2348   size_t n;
2349   int count = 0;
2350   struct user_attribute *attribs = NULL;
2351   const byte *buffer = uid->attrib_data;
2352   int buflen = uid->attrib_len;
2353   byte type;
2354
2355   xfree (uid->attribs);
2356
2357   while (buflen)
2358     {
2359       n = *buffer++;
2360       buflen--;
2361       if (n == 255)  /* 4 byte length header.  */
2362         {                       
2363           if (buflen < 4)
2364             goto too_short;
2365           n = (buffer[0] << 24) | (buffer[1] << 16)
2366             | (buffer[2] << 8) | buffer[3];
2367           buffer += 4;
2368           buflen -= 4;
2369         }
2370       else if (n >= 192)  /* 2 byte special encoded length header.  */
2371         {                       
2372           if (buflen < 2)
2373             goto too_short;
2374           n = ((n - 192) << 8) + *buffer + 192;
2375           buffer++;
2376           buflen--;
2377         }
2378       if (buflen < n)
2379         goto too_short;
2380
2381       attribs =
2382         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2383       memset (&attribs[count], 0, sizeof (struct user_attribute));
2384
2385       type = *buffer;
2386       buffer++;
2387       buflen--;
2388       n--;
2389
2390       attribs[count].type = type;
2391       attribs[count].data = buffer;
2392       attribs[count].len = n;
2393       buffer += n;
2394       buflen -= n;
2395       count++;
2396     }
2397
2398   uid->attribs = attribs;
2399   uid->numattribs = count;
2400   return count;
2401
2402  too_short:
2403   if (opt.verbose)
2404     log_info ("buffer shorter than attribute subpacket\n");
2405   uid->attribs = attribs;
2406   uid->numattribs = count;
2407   return count;
2408 }
2409
2410
2411 static int
2412 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2413 {
2414   byte *p;
2415
2416   /* Cap the size of a user ID at 2k: a value absurdly large enough
2417      that there is no sane user ID string (which is printable text
2418      as of RFC2440bis) that won't fit in it, but yet small enough to
2419      avoid allocation problems.  A large pktlen may not be
2420      allocatable, and a very large pktlen could actually cause our
2421      allocation to wrap around in xmalloc to a small number. */
2422
2423   if (pktlen > 2048)
2424     {
2425       log_error ("packet(%d) too large\n", pkttype);
2426       iobuf_skip_rest (inp, pktlen, 0);
2427       return G10ERR_INVALID_PACKET;
2428     }
2429
2430   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2431   packet->pkt.user_id->len = pktlen;
2432   packet->pkt.user_id->ref = 1;
2433
2434   p = packet->pkt.user_id->name;
2435   for (; pktlen; pktlen--, p++)
2436     *p = iobuf_get_noeof (inp);
2437   *p = 0;
2438
2439   if (list_mode)
2440     {
2441       int n = packet->pkt.user_id->len;
2442       es_fprintf (listfp, ":user ID packet: \"");
2443       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2444       for (p = packet->pkt.user_id->name; n; p++, n--)
2445         {
2446           if (*p >= ' ' && *p <= 'z')
2447             es_putc (*p, listfp);
2448           else
2449             es_fprintf (listfp, "\\x%02x", *p);
2450         }
2451       es_fprintf (listfp, "\"\n");
2452     }
2453   return 0;
2454 }
2455
2456
2457 void
2458 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2459 {
2460   assert (max_namelen > 70);
2461   if (uid->numattribs <= 0)
2462     sprintf (uid->name, "[bad attribute packet of size %lu]",
2463              uid->attrib_len);
2464   else if (uid->numattribs > 1)
2465     sprintf (uid->name, "[%d attributes of size %lu]",
2466              uid->numattribs, uid->attrib_len);
2467   else
2468     {
2469       /* Only one attribute, so list it as the "user id" */
2470
2471       if (uid->attribs->type == ATTRIB_IMAGE)
2472         {
2473           u32 len;
2474           byte type;
2475
2476           if (parse_image_header (uid->attribs, &type, &len))
2477             sprintf (uid->name, "[%.20s image of size %lu]",
2478                      image_type_to_string (type, 1), (ulong) len);
2479           else
2480             sprintf (uid->name, "[invalid image]");
2481         }
2482       else
2483         sprintf (uid->name, "[unknown attribute of size %lu]",
2484                  (ulong) uid->attribs->len);
2485     }
2486
2487   uid->len = strlen (uid->name);
2488 }
2489
2490
2491 static int
2492 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2493                  PACKET * packet)
2494 {
2495   byte *p;
2496
2497   (void) pkttype;
2498
2499 #define EXTRA_UID_NAME_SPACE 71
2500   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2501                                        + EXTRA_UID_NAME_SPACE);
2502   packet->pkt.user_id->ref = 1;
2503   packet->pkt.user_id->attrib_data = xmalloc (pktlen);
2504   packet->pkt.user_id->attrib_len = pktlen;
2505
2506   p = packet->pkt.user_id->attrib_data;
2507   for (; pktlen; pktlen--, p++)
2508     *p = iobuf_get_noeof (inp);
2509
2510   /* Now parse out the individual attribute subpackets.  This is
2511      somewhat pointless since there is only one currently defined
2512      attribute type (jpeg), but it is correct by the spec. */
2513   parse_attribute_subpkts (packet->pkt.user_id);
2514
2515   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2516
2517   if (list_mode)
2518     {
2519       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2520     }
2521   return 0;
2522 }
2523
2524
2525 static int
2526 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2527 {
2528   byte *p;
2529
2530   /* Cap comment packet at a reasonable value to avoid an integer
2531      overflow in the malloc below.  Comment packets are actually not
2532      anymore define my OpenPGP and we even stopped to use our
2533      private comment packet.  */
2534   if (pktlen > 65536)
2535     {
2536       log_error ("packet(%d) too large\n", pkttype);
2537       iobuf_skip_rest (inp, pktlen, 0);
2538       return G10ERR_INVALID_PACKET;
2539     }
2540   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2541   packet->pkt.comment->len = pktlen;
2542   p = packet->pkt.comment->data;
2543   for (; pktlen; pktlen--, p++)
2544     *p = iobuf_get_noeof (inp);
2545
2546   if (list_mode)
2547     {
2548       int n = packet->pkt.comment->len;
2549       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2550                   "OpenPGP draft " : "");
2551       for (p = packet->pkt.comment->data; n; p++, n--)
2552         {
2553           if (*p >= ' ' && *p <= 'z')
2554             es_putc (*p, listfp);
2555           else
2556             es_fprintf (listfp, "\\x%02x", *p);
2557         }
2558       es_fprintf (listfp, "\"\n");
2559     }
2560   return 0;
2561 }
2562
2563
2564 static void
2565 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2566 {
2567   int c;
2568
2569   (void) pkttype;
2570
2571   if (pktlen)
2572     {
2573       c = iobuf_get_noeof (inp);
2574       pktlen--;
2575       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2576       pkt->pkt.ring_trust->trustval = c;
2577       pkt->pkt.ring_trust->sigcache = 0;
2578       if (!c && pktlen == 1)
2579         {
2580           c = iobuf_get_noeof (inp);
2581           pktlen--;
2582           /* We require that bit 7 of the sigcache is 0 (easier eof
2583              handling).  */
2584           if (!(c & 0x80))
2585             pkt->pkt.ring_trust->sigcache = c;
2586         }
2587       if (list_mode)
2588         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2589                     pkt->pkt.ring_trust->trustval,
2590                     pkt->pkt.ring_trust->sigcache);
2591     }
2592   else
2593     {
2594       if (list_mode)
2595         es_fprintf (listfp, ":trust packet: empty\n");
2596     }
2597   iobuf_skip_rest (inp, pktlen, 0);
2598 }
2599
2600
2601 static int
2602 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2603                  PACKET * pkt, int new_ctb, int partial)
2604 {
2605   int rc = 0;
2606   int mode, namelen;
2607   PKT_plaintext *pt;
2608   byte *p;
2609   int c, i;
2610
2611   if (!partial && pktlen < 6)
2612     {
2613       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2614       rc = gpg_error (GPG_ERR_INV_PACKET);
2615       goto leave;
2616     }
2617   mode = iobuf_get_noeof (inp);
2618   if (pktlen)
2619     pktlen--;
2620   namelen = iobuf_get_noeof (inp);
2621   if (pktlen)
2622     pktlen--;
2623   /* Note that namelen will never exceed 255 bytes. */
2624   pt = pkt->pkt.plaintext =
2625     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2626   pt->new_ctb = new_ctb;
2627   pt->mode = mode;
2628   pt->namelen = namelen;
2629   pt->is_partial = partial;
2630   if (pktlen)
2631     {
2632       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2633         pt->name[i] = iobuf_get_noeof (inp);
2634     }
2635   else
2636     {
2637       for (i = 0; i < namelen; i++)
2638         if ((c = iobuf_get (inp)) == -1)
2639           break;
2640         else
2641           pt->name[i] = c;
2642     }
2643   pt->timestamp = read_32 (inp);
2644   if (pktlen)
2645     pktlen -= 4;
2646   pt->len = pktlen;
2647   pt->buf = inp;
2648   pktlen = 0;
2649
2650   if (list_mode)
2651     {
2652       es_fprintf (listfp, ":literal data packet:\n"
2653                   "\tmode %c (%X), created %lu, name=\"",
2654                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2655                   (ulong) pt->timestamp);
2656       for (p = pt->name, i = 0; i < namelen; p++, i++)
2657         {
2658           if (*p >= ' ' && *p <= 'z')
2659             es_putc (*p, listfp);
2660           else
2661             es_fprintf (listfp, "\\x%02x", *p);
2662         }
2663       es_fprintf (listfp, "\",\n\traw data: ");
2664       if (partial)
2665         es_fprintf (listfp, "unknown length\n");
2666       else
2667         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2668     }
2669
2670  leave:
2671   return rc;
2672 }
2673
2674
2675 static int
2676 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2677                   PACKET * pkt, int new_ctb)
2678 {
2679   PKT_compressed *zd;
2680
2681   /* PKTLEN is here 0, but data follows (this should be the last
2682      object in a file or the compress algorithm should know the
2683      length).  */
2684   (void) pkttype;
2685   (void) pktlen;
2686
2687   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2688   zd->algorithm = iobuf_get_noeof (inp);
2689   zd->len = 0;                  /* not used */
2690   zd->new_ctb = new_ctb;
2691   zd->buf = inp;
2692   if (list_mode)
2693     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2694   return 0;
2695 }
2696
2697
2698 static int
2699 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2700                  PACKET * pkt, int new_ctb, int partial)
2701 {
2702   int rc = 0;
2703   PKT_encrypted *ed;
2704   unsigned long orig_pktlen = pktlen;
2705
2706   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2707   /* ed->len is set below.  */
2708   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2709   ed->buf = NULL;
2710   ed->new_ctb = new_ctb;
2711   ed->is_partial = partial;
2712   if (pkttype == PKT_ENCRYPTED_MDC)
2713     {
2714       /* Fixme: add some pktlen sanity checks.  */
2715       int version;
2716
2717       version = iobuf_get_noeof (inp);
2718       if (orig_pktlen)
2719         pktlen--;
2720       if (version != 1)
2721         {
2722           log_error ("encrypted_mdc packet with unknown version %d\n",
2723                      version);
2724           /*skip_rest(inp, pktlen); should we really do this? */
2725           rc = gpg_error (GPG_ERR_INV_PACKET);
2726           goto leave;
2727         }
2728       ed->mdc_method = DIGEST_ALGO_SHA1;
2729     }
2730   else
2731     ed->mdc_method = 0;
2732
2733   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2734      detection bytes.  Note that we don't known the algorithm and thus
2735      we may only check against the minimum blocksize.  */
2736   if (orig_pktlen && pktlen < 10)
2737     {
2738       /* Actually this is blocksize+2.  */
2739       log_error ("packet(%d) too short\n", pkttype);
2740       rc = G10ERR_INVALID_PACKET;
2741       iobuf_skip_rest (inp, pktlen, partial);
2742       goto leave;
2743     }
2744
2745   /* Store the remaining length of the encrypted data (i.e. without
2746      the MDC version number but with the IV etc.).  This value is
2747      required during decryption.  */
2748   ed->len = pktlen;
2749
2750   if (list_mode)
2751     {
2752       if (orig_pktlen)
2753         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2754                     orig_pktlen);
2755       else
2756         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2757       if (ed->mdc_method)
2758         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2759     }
2760
2761   ed->buf = inp;
2762
2763  leave:
2764   return rc;
2765 }
2766
2767
2768 /* Note, that this code is not anymore used in real life because the
2769    MDC checking is now done right after the decryption in
2770    decrypt_data.  */
2771 static int
2772 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2773            PACKET * pkt, int new_ctb)
2774 {
2775   int rc = 0;
2776   PKT_mdc *mdc;
2777   byte *p;
2778
2779   (void) pkttype;
2780
2781   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2782   if (list_mode)
2783     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2784   if (!new_ctb || pktlen != 20)
2785     {
2786       log_error ("mdc_packet with invalid encoding\n");
2787       rc = gpg_error (GPG_ERR_INV_PACKET);
2788       goto leave;
2789     }
2790   p = mdc->hash;
2791   for (; pktlen; pktlen--, p++)
2792     *p = iobuf_get_noeof (inp);
2793
2794  leave:
2795   return rc;
2796 }
2797
2798
2799 /*
2800  * This packet is internally generated by us (ibn armor.c) to transfer
2801  * some information to the lower layer.  To make sure that this packet
2802  * is really a GPG faked one and not one comming from outside, we
2803  * first check that there is a unique tag in it.
2804  *
2805  * The format of such a control packet is:
2806  *   n byte  session marker
2807  *   1 byte  control type CTRLPKT_xxxxx
2808  *   m byte  control data
2809  */
2810 static int
2811 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2812                    PACKET * packet, int partial)
2813 {
2814   byte *p;
2815   const byte *sesmark;
2816   size_t sesmarklen;
2817   int i;
2818
2819   (void) pkttype;
2820
2821   if (list_mode)
2822     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2823
2824   sesmark = get_session_marker (&sesmarklen);
2825   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2826     goto skipit;
2827   for (i = 0; i < sesmarklen; i++, pktlen--)
2828     {
2829       if (sesmark[i] != iobuf_get_noeof (inp))
2830         goto skipit;
2831     }
2832   if (pktlen > 4096)
2833     goto skipit;  /* Definitely too large.  We skip it to avoid an
2834                      overflow in the malloc.  */
2835   if (list_mode)
2836     puts ("- gpg control packet");
2837
2838   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2839                                      + pktlen - 1);
2840   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2841   pktlen--;
2842   packet->pkt.gpg_control->datalen = pktlen;
2843   p = packet->pkt.gpg_control->data;
2844   for (; pktlen; pktlen--, p++)
2845     *p = iobuf_get_noeof (inp);
2846
2847   return 0;
2848
2849  skipit:
2850   if (list_mode)
2851     {
2852       int c;
2853
2854       i = 0;
2855       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2856       if (partial)
2857         {
2858           while ((c = iobuf_get (inp)) != -1)
2859             dump_hex_line (c, &i);
2860         }
2861       else
2862         {
2863           for (; pktlen; pktlen--)
2864             {
2865               dump_hex_line ((c = iobuf_get (inp)), &i);
2866               if (c == -1)
2867                 break;
2868             }
2869         }
2870       es_putc ('\n', listfp);
2871     }
2872   iobuf_skip_rest (inp, pktlen, 0);
2873   return gpg_error (GPG_ERR_INV_PACKET);
2874 }
2875
2876
2877 /* Create a GPG control packet to be used internally as a placeholder.  */
2878 PACKET *
2879 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2880 {
2881   PACKET *packet;
2882   byte *p;
2883
2884   packet = xmalloc (sizeof *packet);
2885   init_packet (packet);
2886   packet->pkttype = PKT_GPG_CONTROL;
2887   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2888                                      + datalen - 1);
2889   packet->pkt.gpg_control->control = type;
2890   packet->pkt.gpg_control->datalen = datalen;
2891   p = packet->pkt.gpg_control->data;
2892   for (; datalen; datalen--, p++)
2893     *p = *data++;
2894
2895   return packet;
2896 }
2897