Exporting secret keys via gpg-agent is now basically supported.
[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 static int
745 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
746 {
747   (void) pkttype;
748
749   if (pktlen != 3)
750     goto fail;
751
752   if (iobuf_get (inp) != 'P')
753     {
754       pktlen--;
755       goto fail;
756     }
757
758   if (iobuf_get (inp) != 'G')
759     {
760       pktlen--;
761       goto fail;
762     }
763
764   if (iobuf_get (inp) != 'P')
765     {
766       pktlen--;
767       goto fail;
768     }
769
770   if (list_mode)
771     es_fputs (":marker packet: PGP\n", listfp);
772
773   return 0;
774
775  fail:
776   log_error ("invalid marker packet\n");
777   iobuf_skip_rest (inp, pktlen, 0);
778   return G10ERR_INVALID_PACKET;
779 }
780
781
782 static int
783 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
784                  PACKET * packet)
785 {
786   PKT_symkey_enc *k;
787   int rc = 0;
788   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
789
790   if (pktlen < 4)
791     {
792       log_error ("packet(%d) too short\n", pkttype);
793       rc = gpg_error (GPG_ERR_INV_PACKET);
794       goto leave;
795     }
796   version = iobuf_get_noeof (inp);
797   pktlen--;
798   if (version != 4)
799     {
800       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
801       rc = gpg_error (GPG_ERR_INV_PACKET);
802       goto leave;
803     }
804   if (pktlen > 200)
805     {                           /* (we encode the seskeylen in a byte) */
806       log_error ("packet(%d) too large\n", pkttype);
807       rc = gpg_error (GPG_ERR_INV_PACKET);
808       goto leave;
809     }
810   cipher_algo = iobuf_get_noeof (inp);
811   pktlen--;
812   s2kmode = iobuf_get_noeof (inp);
813   pktlen--;
814   hash_algo = iobuf_get_noeof (inp);
815   pktlen--;
816   switch (s2kmode)
817     {
818     case 0: /* Simple S2K.  */
819       minlen = 0;
820       break;
821     case 1: /* Salted S2K.  */
822       minlen = 8;
823       break;
824     case 3: /* Iterated+salted S2K.  */
825       minlen = 9;
826       break;
827     default:
828       log_error ("unknown S2K mode %d\n", s2kmode);
829       goto leave;
830     }
831   if (minlen > pktlen)
832     {
833       log_error ("packet with S2K %d too short\n", s2kmode);
834       rc = gpg_error (GPG_ERR_INV_PACKET);
835       goto leave;
836     }
837   seskeylen = pktlen - minlen;
838   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
839                                               + seskeylen - 1);
840   k->version = version;
841   k->cipher_algo = cipher_algo;
842   k->s2k.mode = s2kmode;
843   k->s2k.hash_algo = hash_algo;
844   if (s2kmode == 1 || s2kmode == 3)
845     {
846       for (i = 0; i < 8 && pktlen; i++, pktlen--)
847         k->s2k.salt[i] = iobuf_get_noeof (inp);
848     }
849   if (s2kmode == 3)
850     {
851       k->s2k.count = iobuf_get (inp);
852       pktlen--;
853     }
854   k->seskeylen = seskeylen;
855   if (k->seskeylen)
856     {
857       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
858         k->seskey[i] = iobuf_get_noeof (inp);
859
860       /* What we're watching out for here is a session key decryptor
861          with no salt.  The RFC says that using salt for this is a
862          MUST. */
863       if (s2kmode != 1 && s2kmode != 3)
864         log_info (_("WARNING: potentially insecure symmetrically"
865                     " encrypted session key\n"));
866     }
867   assert (!pktlen);
868
869   if (list_mode)
870     {
871       es_fprintf (listfp,
872                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
873                   version, cipher_algo, s2kmode, hash_algo);
874       if (seskeylen)
875         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
876       es_fprintf (listfp, "\n");
877       if (s2kmode == 1 || s2kmode == 3)
878         {
879           es_fprintf (listfp, "\tsalt ");
880           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
881           if (s2kmode == 3)
882             es_fprintf (listfp, ", count %lu (%lu)",
883                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
884                         (ulong) k->s2k.count);
885           es_fprintf (listfp, "\n");
886         }
887     }
888
889  leave:
890   iobuf_skip_rest (inp, pktlen, 0);
891   return rc;
892 }
893
894
895 static int
896 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
897                  PACKET * packet)
898 {
899   unsigned int n;
900   int rc = 0;
901   int i, ndata;
902   PKT_pubkey_enc *k;
903
904   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
905   if (pktlen < 12)
906     {
907       log_error ("packet(%d) too short\n", pkttype);
908       rc = gpg_error (GPG_ERR_INV_PACKET);
909       goto leave;
910     }
911   k->version = iobuf_get_noeof (inp);
912   pktlen--;
913   if (k->version != 2 && k->version != 3)
914     {
915       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
916       rc = gpg_error (GPG_ERR_INV_PACKET);
917       goto leave;
918     }
919   k->keyid[0] = read_32 (inp);
920   pktlen -= 4;
921   k->keyid[1] = read_32 (inp);
922   pktlen -= 4;
923   k->pubkey_algo = iobuf_get_noeof (inp);
924   pktlen--;
925   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
926   if (list_mode)
927     es_fprintf (listfp,
928                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
929                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
930                 (ulong) k->keyid[1]);
931
932   ndata = pubkey_get_nenc (k->pubkey_algo);
933   if (!ndata)
934     {
935       if (list_mode)
936         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
937       unknown_pubkey_warning (k->pubkey_algo);
938       k->data[0] = NULL; /* No need to store the encrypted data.  */
939     }
940   else
941     {
942       for (i = 0; i < ndata; i++)
943         {
944           n = pktlen;
945           k->data[i] = mpi_read (inp, &n, 0);
946           pktlen -= n;
947           if (list_mode)
948             {
949               es_fprintf (listfp, "\tdata: ");
950               mpi_print (listfp, k->data[i], mpi_print_mode);
951               es_putc ('\n', listfp);
952             }
953           if (!k->data[i])
954             rc = gpg_error (GPG_ERR_INV_PACKET);
955         }
956     }
957
958  leave:
959   iobuf_skip_rest (inp, pktlen, 0);
960   return rc;
961 }
962
963
964 static void
965 dump_sig_subpkt (int hashed, int type, int critical,
966                  const byte * buffer, size_t buflen, size_t length)
967 {
968   const char *p = NULL;
969   int i;
970
971   /* The CERT has warning out with explains how to use GNUPG to detect
972    * the ARRs - we print our old message here when it is a faked ARR
973    * and add an additional notice.  */
974   if (type == SIGSUBPKT_ARR && !hashed)
975     {
976       es_fprintf (listfp,
977                   "\tsubpkt %d len %u (additional recipient request)\n"
978                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
979                   "encrypt to this key and thereby reveal the plaintext to "
980                   "the owner of this ARR key. Detailed info follows:\n",
981                   type, (unsigned) length);
982     }
983
984   buffer++;
985   length--;
986
987   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
988               critical ? "critical " : "",
989               hashed ? "hashed " : "", type, (unsigned) length);
990   if (length > buflen)
991     {
992       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
993       return;
994     }
995   switch (type)
996     {
997     case SIGSUBPKT_SIG_CREATED:
998       if (length >= 4)
999         es_fprintf (listfp, "sig created %s",
1000                     strtimestamp (buffer_to_u32 (buffer)));
1001       break;
1002     case SIGSUBPKT_SIG_EXPIRE:
1003       if (length >= 4)
1004         {
1005           if (buffer_to_u32 (buffer))
1006             es_fprintf (listfp, "sig expires after %s",
1007                         strtimevalue (buffer_to_u32 (buffer)));
1008           else
1009             es_fprintf (listfp, "sig does not expire");
1010         }
1011       break;
1012     case SIGSUBPKT_EXPORTABLE:
1013       if (length)
1014         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1015       break;
1016     case SIGSUBPKT_TRUST:
1017       if (length != 2)
1018         p = "[invalid trust subpacket]";
1019       else
1020         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1021                     buffer[1]);
1022       break;
1023     case SIGSUBPKT_REGEXP:
1024       if (!length)
1025         p = "[invalid regexp subpacket]";
1026       else
1027         es_fprintf (listfp, "regular expression: \"%s\"", buffer);
1028       break;
1029     case SIGSUBPKT_REVOCABLE:
1030       if (length)
1031         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1032       break;
1033     case SIGSUBPKT_KEY_EXPIRE:
1034       if (length >= 4)
1035         {
1036           if (buffer_to_u32 (buffer))
1037             es_fprintf (listfp, "key expires after %s",
1038                         strtimevalue (buffer_to_u32 (buffer)));
1039           else
1040             es_fprintf (listfp, "key does not expire");
1041         }
1042       break;
1043     case SIGSUBPKT_PREF_SYM:
1044       es_fputs ("pref-sym-algos:", listfp);
1045       for (i = 0; i < length; i++)
1046         es_fprintf (listfp, " %d", buffer[i]);
1047       break;
1048     case SIGSUBPKT_REV_KEY:
1049       es_fputs ("revocation key: ", listfp);
1050       if (length < 22)
1051         p = "[too short]";
1052       else
1053         {
1054           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1055           for (i = 2; i < length; i++)
1056             es_fprintf (listfp, "%02X", buffer[i]);
1057         }
1058       break;
1059     case SIGSUBPKT_ISSUER:
1060       if (length >= 8)
1061         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1062                     (ulong) buffer_to_u32 (buffer),
1063                     (ulong) buffer_to_u32 (buffer + 4));
1064       break;
1065     case SIGSUBPKT_NOTATION:
1066       {
1067         es_fputs ("notation: ", listfp);
1068         if (length < 8)
1069           p = "[too short]";
1070         else
1071           {
1072             const byte *s = buffer;
1073             size_t n1, n2;
1074
1075             n1 = (s[4] << 8) | s[5];
1076             n2 = (s[6] << 8) | s[7];
1077             s += 8;
1078             if (8 + n1 + n2 != length)
1079               p = "[error]";
1080             else
1081               {
1082                 es_write_sanitized (listfp, s, n1, ")", NULL);
1083                 es_putc ('=', listfp);
1084
1085                 if (*buffer & 0x80)
1086                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1087                 else
1088                   p = "[not human readable]";
1089               }
1090           }
1091       }
1092       break;
1093     case SIGSUBPKT_PREF_HASH:
1094       es_fputs ("pref-hash-algos:", listfp);
1095       for (i = 0; i < length; i++)
1096         es_fprintf (listfp, " %d", buffer[i]);
1097       break;
1098     case SIGSUBPKT_PREF_COMPR:
1099       es_fputs ("pref-zip-algos:", listfp);
1100       for (i = 0; i < length; i++)
1101         es_fprintf (listfp, " %d", buffer[i]);
1102       break;
1103     case SIGSUBPKT_KS_FLAGS:
1104       es_fputs ("key server preferences:", listfp);
1105       for (i = 0; i < length; i++)
1106         es_fprintf (listfp, " %02X", buffer[i]);
1107       break;
1108     case SIGSUBPKT_PREF_KS:
1109       es_fputs ("preferred key server: ", listfp);
1110       es_write_sanitized (listfp, buffer, length, ")", NULL);
1111       break;
1112     case SIGSUBPKT_PRIMARY_UID:
1113       p = "primary user ID";
1114       break;
1115     case SIGSUBPKT_POLICY:
1116       es_fputs ("policy: ", listfp);
1117       es_write_sanitized (listfp, buffer, length, ")", NULL);
1118       break;
1119     case SIGSUBPKT_KEY_FLAGS:
1120       es_fputs ("key flags:", listfp);
1121       for (i = 0; i < length; i++)
1122         es_fprintf (listfp, " %02X", buffer[i]);
1123       break;
1124     case SIGSUBPKT_SIGNERS_UID:
1125       p = "signer's user ID";
1126       break;
1127     case SIGSUBPKT_REVOC_REASON:
1128       if (length)
1129         {
1130           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1131           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1132           p = ")";
1133         }
1134       break;
1135     case SIGSUBPKT_ARR:
1136       es_fputs ("Big Brother's key (ignored): ", listfp);
1137       if (length < 22)
1138         p = "[too short]";
1139       else
1140         {
1141           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1142           if (length > 2)
1143             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1144         }
1145       break;
1146     case SIGSUBPKT_FEATURES:
1147       es_fputs ("features:", listfp);
1148       for (i = 0; i < length; i++)
1149         es_fprintf (listfp, " %02x", buffer[i]);
1150       break;
1151     case SIGSUBPKT_SIGNATURE:
1152       es_fputs ("signature: ", listfp);
1153       if (length < 17)
1154         p = "[too short]";
1155       else
1156         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1157                     buffer[0],
1158                     buffer[0] == 3 ? buffer[2] : buffer[1],
1159                     buffer[0] == 3 ? buffer[15] : buffer[2],
1160                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1161       break;
1162     default:
1163       if (type >= 100 && type <= 110)
1164         p = "experimental / private subpacket";
1165       else
1166         p = "?";
1167       break;
1168     }
1169
1170   es_fprintf (listfp, "%s)\n", p ? p : "");
1171 }
1172
1173
1174 /*
1175  * Returns: >= 0 use this offset into buffer
1176  *          -1 explicitly reject returning this type
1177  *          -2 subpacket too short
1178  */
1179 int
1180 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1181 {
1182   switch (type)
1183     {
1184     case SIGSUBPKT_REV_KEY:
1185       if (n < 22)
1186         break;
1187       return 0;
1188     case SIGSUBPKT_SIG_CREATED:
1189     case SIGSUBPKT_SIG_EXPIRE:
1190     case SIGSUBPKT_KEY_EXPIRE:
1191       if (n < 4)
1192         break;
1193       return 0;
1194     case SIGSUBPKT_KEY_FLAGS:
1195     case SIGSUBPKT_KS_FLAGS:
1196     case SIGSUBPKT_PREF_SYM:
1197     case SIGSUBPKT_PREF_HASH:
1198     case SIGSUBPKT_PREF_COMPR:
1199     case SIGSUBPKT_POLICY:
1200     case SIGSUBPKT_PREF_KS:
1201     case SIGSUBPKT_FEATURES:
1202     case SIGSUBPKT_REGEXP:
1203       return 0;
1204     case SIGSUBPKT_SIGNATURE:
1205     case SIGSUBPKT_EXPORTABLE:
1206     case SIGSUBPKT_REVOCABLE:
1207     case SIGSUBPKT_REVOC_REASON:
1208       if (!n)
1209         break;
1210       return 0;
1211     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1212       if (n < 8)
1213         break;
1214       return 0;
1215     case SIGSUBPKT_NOTATION:
1216       /* minimum length needed, and the subpacket must be well-formed
1217          where the name length and value length all fit inside the
1218          packet. */
1219       if (n < 8
1220           || 8 + ((buffer[4] << 8) | buffer[5]) +
1221           ((buffer[6] << 8) | buffer[7]) != n)
1222         break;
1223       return 0;
1224     case SIGSUBPKT_PRIMARY_UID:
1225       if (n != 1)
1226         break;
1227       return 0;
1228     case SIGSUBPKT_TRUST:
1229       if (n != 2)
1230         break;
1231       return 0;
1232     default:
1233       return 0;
1234     }
1235   return -2;
1236 }
1237
1238
1239 /* Return true if we understand the critical notation.  */
1240 static int
1241 can_handle_critical_notation (const byte * name, size_t len)
1242 {
1243   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1244     return 1;
1245   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1246     return 1;
1247
1248   return 0;
1249 }
1250
1251
1252 static int
1253 can_handle_critical (const byte * buffer, size_t n, int type)
1254 {
1255   switch (type)
1256     {
1257     case SIGSUBPKT_NOTATION:
1258       if (n >= 8)
1259         return can_handle_critical_notation (buffer + 8,
1260                                              (buffer[4] << 8) | buffer[5]);
1261       else
1262         return 0;
1263     case SIGSUBPKT_SIGNATURE:
1264     case SIGSUBPKT_SIG_CREATED:
1265     case SIGSUBPKT_SIG_EXPIRE:
1266     case SIGSUBPKT_KEY_EXPIRE:
1267     case SIGSUBPKT_EXPORTABLE:
1268     case SIGSUBPKT_REVOCABLE:
1269     case SIGSUBPKT_REV_KEY:
1270     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1271     case SIGSUBPKT_PREF_SYM:
1272     case SIGSUBPKT_PREF_HASH:
1273     case SIGSUBPKT_PREF_COMPR:
1274     case SIGSUBPKT_KEY_FLAGS:
1275     case SIGSUBPKT_PRIMARY_UID:
1276     case SIGSUBPKT_FEATURES:
1277     case SIGSUBPKT_TRUST:
1278     case SIGSUBPKT_REGEXP:
1279       /* Is it enough to show the policy or keyserver? */
1280     case SIGSUBPKT_POLICY:
1281     case SIGSUBPKT_PREF_KS:
1282       return 1;
1283
1284     default:
1285       return 0;
1286     }
1287 }
1288
1289
1290 const byte *
1291 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1292                  size_t * ret_n, int *start, int *critical)
1293 {
1294   const byte *buffer;
1295   int buflen;
1296   int type;
1297   int critical_dummy;
1298   int offset;
1299   size_t n;
1300   int seq = 0;
1301   int reqseq = start ? *start : 0;
1302
1303   if (!critical)
1304     critical = &critical_dummy;
1305
1306   if (!pktbuf || reqseq == -1)
1307     {
1308       /* return some value different from NULL to indicate that
1309        * there is no critical bit we do not understand.  The caller
1310        * will never use the value.  Yes I know, it is an ugly hack */
1311       return reqtype ==
1312         SIGSUBPKT_TEST_CRITICAL ? (const byte *) &pktbuf : NULL;
1313     }
1314   buffer = pktbuf->data;
1315   buflen = pktbuf->len;
1316   while (buflen)
1317     {
1318       n = *buffer++;
1319       buflen--;
1320       if (n == 255) /* 4 byte length header.  */
1321         {                       
1322           if (buflen < 4)
1323             goto too_short;
1324           n = (buffer[0] << 24) | (buffer[1] << 16)
1325             | (buffer[2] << 8) | buffer[3];
1326           buffer += 4;
1327           buflen -= 4;
1328         }
1329       else if (n >= 192) /* 4 byte special encoded length header.  */
1330         {                       
1331           if (buflen < 2)
1332             goto too_short;
1333           n = ((n - 192) << 8) + *buffer + 192;
1334           buffer++;
1335           buflen--;
1336         }
1337       if (buflen < n)
1338         goto too_short;
1339       type = *buffer;
1340       if (type & 0x80)
1341         {
1342           type &= 0x7f;
1343           *critical = 1;
1344         }
1345       else
1346         *critical = 0;
1347       if (!(++seq > reqseq))
1348         ;
1349       else if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1350         {
1351           if (*critical)
1352             {
1353               if (n - 1 > buflen + 1)
1354                 goto too_short;
1355               if (!can_handle_critical (buffer + 1, n - 1, type))
1356                 {
1357                   if (opt.verbose)
1358                     log_info (_("subpacket of type %d has "
1359                                 "critical bit set\n"), type);
1360                   if (start)
1361                     *start = seq;
1362                   return NULL;  /* This is an error.  */
1363                 }
1364             }
1365         }
1366       else if (reqtype < 0) /* List packets.  */
1367         dump_sig_subpkt (reqtype == SIGSUBPKT_LIST_HASHED,
1368                          type, *critical, buffer, buflen, n);
1369       else if (type == reqtype) /* Found.  */
1370         {
1371           buffer++;
1372           n--;
1373           if (n > buflen)
1374             goto too_short;
1375           if (ret_n)
1376             *ret_n = n;
1377           offset = parse_one_sig_subpkt (buffer, n, type);
1378           switch (offset)
1379             {
1380             case -2:
1381               log_error ("subpacket of type %d too short\n", type);
1382               return NULL;
1383             case -1:
1384               return NULL;
1385             default:
1386               break;
1387             }
1388           if (start)
1389             *start = seq;
1390           return buffer + offset;
1391         }
1392       buffer += n;
1393       buflen -= n;
1394     }
1395   if (reqtype == SIGSUBPKT_TEST_CRITICAL)
1396     return buffer;  /* Used as True to indicate that there is no. */
1397
1398   /* Critical bit we don't understand. */
1399   if (start)
1400     *start = -1;
1401   return NULL;  /* End of packets; not found.  */
1402
1403  too_short:
1404   if (opt.verbose)
1405     log_info ("buffer shorter than subpacket\n");
1406   if (start)
1407     *start = -1;
1408   return NULL;
1409 }
1410
1411
1412 const byte *
1413 parse_sig_subpkt (const subpktarea_t * buffer, sigsubpkttype_t reqtype,
1414                   size_t * ret_n)
1415 {
1416   return enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL);
1417 }
1418
1419
1420 const byte *
1421 parse_sig_subpkt2 (PKT_signature * sig, sigsubpkttype_t reqtype,
1422                    size_t * ret_n)
1423 {
1424   const byte *p;
1425
1426   p = parse_sig_subpkt (sig->hashed, reqtype, ret_n);
1427   if (!p)
1428     p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n);
1429   return p;
1430 }
1431
1432
1433 /* Find all revocation keys.  Look in hashed area only.  */
1434 void
1435 parse_revkeys (PKT_signature * sig)
1436 {
1437   struct revocation_key *revkey;
1438   int seq = 0;
1439   size_t len;
1440
1441   if (sig->sig_class != 0x1F)
1442     return;
1443
1444   while ((revkey =
1445           (struct revocation_key *) enum_sig_subpkt (sig->hashed,
1446                                                      SIGSUBPKT_REV_KEY,
1447                                                      &len, &seq, NULL)))
1448     {
1449       if (len == sizeof (struct revocation_key) 
1450           && (revkey->class & 0x80))  /* 0x80 bit must be set.  */
1451         {
1452           sig->revkey = xrealloc (sig->revkey,
1453                                   sizeof (struct revocation_key *) *
1454                                   (sig->numrevkeys + 1));
1455           sig->revkey[sig->numrevkeys] = revkey;
1456           sig->numrevkeys++;
1457         }
1458     }
1459 }
1460
1461
1462 int
1463 parse_signature (IOBUF inp, int pkttype, unsigned long pktlen,
1464                  PKT_signature * sig)
1465 {
1466   int md5_len = 0;
1467   unsigned n;
1468   int is_v4 = 0;
1469   int rc = 0;
1470   int i, ndata;
1471
1472   if (pktlen < 16)
1473     {
1474       log_error ("packet(%d) too short\n", pkttype);
1475       goto leave;
1476     }
1477   sig->version = iobuf_get_noeof (inp);
1478   pktlen--;
1479   if (sig->version == 4)
1480     is_v4 = 1;
1481   else if (sig->version != 2 && sig->version != 3)
1482     {
1483       log_error ("packet(%d) with unknown version %d\n",
1484                  pkttype, sig->version);
1485       rc = gpg_error (GPG_ERR_INV_PACKET);
1486       goto leave;
1487     }
1488
1489   if (!is_v4)
1490     {
1491       md5_len = iobuf_get_noeof (inp);
1492       pktlen--;
1493     }
1494   sig->sig_class = iobuf_get_noeof (inp);
1495   pktlen--;
1496   if (!is_v4)
1497     {
1498       sig->timestamp = read_32 (inp);
1499       pktlen -= 4;
1500       sig->keyid[0] = read_32 (inp);
1501       pktlen -= 4;
1502       sig->keyid[1] = read_32 (inp);
1503       pktlen -= 4;
1504     }
1505   sig->pubkey_algo = iobuf_get_noeof (inp);
1506   pktlen--;
1507   sig->digest_algo = iobuf_get_noeof (inp);
1508   pktlen--;
1509   sig->flags.exportable = 1;
1510   sig->flags.revocable = 1;
1511   if (is_v4) /* Read subpackets.  */
1512     { 
1513       n = read_16 (inp);
1514       pktlen -= 2;  /* Length of hashed data. */
1515       if (n > 10000)
1516         {
1517           log_error ("signature packet: hashed data too long\n");
1518           rc = G10ERR_INVALID_PACKET;
1519           goto leave;
1520         }
1521       if (n)
1522         {
1523           sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1);
1524           sig->hashed->size = n;
1525           sig->hashed->len = n;
1526           if (iobuf_read (inp, sig->hashed->data, n) != n)
1527             {
1528               log_error ("premature eof while reading "
1529                          "hashed signature data\n");
1530               rc = -1;
1531               goto leave;
1532             }
1533           pktlen -= n;
1534         }
1535       n = read_16 (inp);
1536       pktlen -= 2;  /* Length of unhashed data.  */
1537       if (n > 10000)
1538         {
1539           log_error ("signature packet: unhashed data too long\n");
1540           rc = G10ERR_INVALID_PACKET;
1541           goto leave;
1542         }
1543       if (n)
1544         {
1545           sig->unhashed = xmalloc (sizeof (*sig->unhashed) + n - 1);
1546           sig->unhashed->size = n;
1547           sig->unhashed->len = n;
1548           if (iobuf_read (inp, sig->unhashed->data, n) != n)
1549             {
1550               log_error ("premature eof while reading "
1551                          "unhashed signature data\n");
1552               rc = -1;
1553               goto leave;
1554             }
1555           pktlen -= n;
1556         }
1557     }
1558
1559   if (pktlen < 5)  /* Sanity check.  */
1560     {                           
1561       log_error ("packet(%d) too short\n", pkttype);
1562       rc = G10ERR_INVALID_PACKET;
1563       goto leave;
1564     }
1565
1566   sig->digest_start[0] = iobuf_get_noeof (inp);
1567   pktlen--;
1568   sig->digest_start[1] = iobuf_get_noeof (inp);
1569   pktlen--;
1570
1571   if (is_v4 && sig->pubkey_algo)  /* Extract required information.  */
1572     {                   
1573       const byte *p;
1574       size_t len;
1575
1576       /* Set sig->flags.unknown_critical if there is a critical bit
1577        * set for packets which we do not understand.  */
1578       if (!parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1579           || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL, NULL))
1580         sig->flags.unknown_critical = 1;
1581
1582       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL);
1583       if (p)
1584         sig->timestamp = buffer_to_u32 (p);
1585       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1586                && opt.verbose)
1587         log_info ("signature packet without timestamp\n");
1588
1589       p = parse_sig_subpkt2 (sig, SIGSUBPKT_ISSUER, NULL);
1590       if (p)
1591         {
1592           sig->keyid[0] = buffer_to_u32 (p);
1593           sig->keyid[1] = buffer_to_u32 (p + 4);
1594         }
1595       else if (!(sig->pubkey_algo >= 100 && sig->pubkey_algo <= 110)
1596                && opt.verbose)
1597         log_info ("signature packet without keyid\n");
1598
1599       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL);
1600       if (p && buffer_to_u32 (p))
1601         sig->expiredate = sig->timestamp + buffer_to_u32 (p);
1602       if (sig->expiredate && sig->expiredate <= make_timestamp ())
1603         sig->flags.expired = 1;
1604
1605       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, NULL);
1606       if (p)
1607         sig->flags.policy_url = 1;
1608
1609       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, NULL);
1610       if (p)
1611         sig->flags.pref_ks = 1;
1612
1613       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION, NULL);
1614       if (p)
1615         sig->flags.notation = 1;
1616
1617       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_REVOCABLE, NULL);
1618       if (p && *p == 0)
1619         sig->flags.revocable = 0;
1620
1621       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_TRUST, &len);
1622       if (p && len == 2)
1623         {
1624           sig->trust_depth = p[0];
1625           sig->trust_value = p[1];
1626
1627           /* Only look for a regexp if there is also a trust
1628              subpacket. */
1629           sig->trust_regexp =
1630             parse_sig_subpkt (sig->hashed, SIGSUBPKT_REGEXP, &len);
1631
1632           /* If the regular expression is of 0 length, there is no
1633              regular expression. */
1634           if (len == 0)
1635             sig->trust_regexp = NULL;
1636         }
1637
1638       /* We accept the exportable subpacket from either the hashed or
1639          unhashed areas as older versions of gpg put it in the
1640          unhashed area.  In theory, anyway, we should never see this
1641          packet off of a local keyring. */
1642
1643       p = parse_sig_subpkt2 (sig, SIGSUBPKT_EXPORTABLE, NULL);
1644       if (p && *p == 0)
1645         sig->flags.exportable = 0;
1646
1647       /* Find all revocation keys.  */
1648       if (sig->sig_class == 0x1F)
1649         parse_revkeys (sig);
1650     }
1651
1652   if (list_mode)
1653     {
1654       es_fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1655                   "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1656                   "\tdigest algo %d, begin of digest %02x %02x\n",
1657                   sig->pubkey_algo,
1658                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1659                   sig->version, (ulong) sig->timestamp, md5_len, sig->sig_class,
1660                   sig->digest_algo, sig->digest_start[0], sig->digest_start[1]);
1661       if (is_v4)
1662         {
1663           parse_sig_subpkt (sig->hashed, SIGSUBPKT_LIST_HASHED, NULL);
1664           parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1665         }
1666     }
1667
1668   ndata = pubkey_get_nsig (sig->pubkey_algo);
1669   if (!ndata)
1670     {
1671       if (list_mode)
1672         es_fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo);
1673       unknown_pubkey_warning (sig->pubkey_algo);
1674
1675       /* We store the plain material in data[0], so that we are able
1676        * to write it back with build_packet().  */
1677       if (pktlen > (5 * MAX_EXTERN_MPI_BITS / 8))
1678         {
1679           /* We include a limit to avoid too trivial DoS attacks by
1680              having gpg allocate too much memory.  */
1681           log_error ("signature packet: too much data\n");
1682           rc = G10ERR_INVALID_PACKET;
1683         }
1684       else
1685         {
1686           sig->data[0] =
1687             gcry_mpi_set_opaque (NULL, read_rest (inp, pktlen, 0),
1688                                  pktlen * 8);
1689           pktlen = 0;
1690         }
1691     }
1692   else
1693     {
1694       for (i = 0; i < ndata; i++)
1695         {
1696           n = pktlen;
1697           sig->data[i] = mpi_read (inp, &n, 0);
1698           pktlen -= n;
1699           if (list_mode)
1700             {
1701               es_fprintf (listfp, "\tdata: ");
1702               mpi_print (listfp, sig->data[i], mpi_print_mode);
1703               es_putc ('\n', listfp);
1704             }
1705           if (!sig->data[i])
1706             rc = G10ERR_INVALID_PACKET;
1707         }
1708     }
1709
1710  leave:
1711   iobuf_skip_rest (inp, pktlen, 0);
1712   return rc;
1713 }
1714
1715
1716 static int
1717 parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
1718                    PKT_onepass_sig * ops)
1719 {
1720   int version;
1721   int rc = 0;
1722
1723   if (pktlen < 13)
1724     {
1725       log_error ("packet(%d) too short\n", pkttype);
1726       rc = gpg_error (GPG_ERR_INV_PACKET);
1727       goto leave;
1728     }
1729   version = iobuf_get_noeof (inp);
1730   pktlen--;
1731   if (version != 3)
1732     {
1733       log_error ("onepass_sig with unknown version %d\n", version);
1734       rc = gpg_error (GPG_ERR_INV_PACKET);
1735       goto leave;
1736     }
1737   ops->sig_class = iobuf_get_noeof (inp);
1738   pktlen--;
1739   ops->digest_algo = iobuf_get_noeof (inp);
1740   pktlen--;
1741   ops->pubkey_algo = iobuf_get_noeof (inp);
1742   pktlen--;
1743   ops->keyid[0] = read_32 (inp);
1744   pktlen -= 4;
1745   ops->keyid[1] = read_32 (inp);
1746   pktlen -= 4;
1747   ops->last = iobuf_get_noeof (inp);
1748   pktlen--;
1749   if (list_mode)
1750     es_fprintf (listfp,
1751                 ":onepass_sig packet: keyid %08lX%08lX\n"
1752                 "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, "
1753                 "last=%d\n",
1754                 (ulong) ops->keyid[0], (ulong) ops->keyid[1],
1755                 version, ops->sig_class,
1756                 ops->digest_algo, ops->pubkey_algo, ops->last);
1757
1758
1759  leave:
1760   iobuf_skip_rest (inp, pktlen, 0);
1761   return rc;
1762 }
1763
1764
1765 static gcry_mpi_t
1766 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1767 {
1768   int c;
1769   unsigned int nbits, nbytes;
1770   unsigned char *buf, *p;
1771   gcry_mpi_t val;
1772
1773   if (*length < 2)
1774     {
1775       log_error ("mpi too small\n");
1776       return NULL;
1777     }
1778
1779   if ((c = iobuf_get (inp)) == -1)
1780     return NULL;
1781   --*length;
1782   nbits = c << 8;
1783   if ((c = iobuf_get (inp)) == -1)
1784     return NULL;
1785   --*length;
1786   nbits |= c;
1787
1788   if (nbits > 16384)
1789     {
1790       log_error ("mpi too large (%u bits)\n", nbits);
1791       return NULL;
1792     }
1793   nbytes = (nbits + 7) / 8;
1794   buf = p = xmalloc (2 + nbytes);
1795   *p++ = nbits >> 8;
1796   *p++ = nbits;
1797   for (; nbytes && *length; nbytes--, --*length)
1798     *p++ = iobuf_get (inp);
1799   if (nbytes)
1800     {
1801       log_error ("packet shorter than mpi\n");
1802       xfree (buf);
1803       return NULL;
1804     }
1805
1806   /* Convert buffer into an opaque MPI.  */
1807   val = gcry_mpi_set_opaque (NULL, buf, (p - buf) * 8);
1808   return val;
1809 }
1810
1811
1812 static int
1813 parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
1814            byte * hdr, int hdrlen, PACKET * pkt)
1815 {
1816   gpg_error_t err = 0;
1817   int i, version, algorithm;
1818   unsigned n;
1819   unsigned long timestamp, expiredate, max_expiredate;
1820   int npkey, nskey;
1821   int is_v4 = 0;
1822   int rc = 0;
1823   u32 keyid[2];
1824   PKT_public_key *pk;
1825
1826   (void) hdr;
1827
1828   pk = pkt->pkt.public_key; /* PK has been cleared. */
1829
1830   version = iobuf_get_noeof (inp);
1831   pktlen--;
1832   if (pkttype == PKT_PUBLIC_SUBKEY && version == '#')
1833     {
1834       /* Early versions of G10 used the old PGP comments packets;
1835        * luckily all those comments are started by a hash.  */
1836       if (list_mode)
1837         {
1838           es_fprintf (listfp, ":rfc1991 comment packet: \"");
1839           for (; pktlen; pktlen--)
1840             {
1841               int c;
1842               c = iobuf_get_noeof (inp);
1843               if (c >= ' ' && c <= 'z')
1844                 es_putc (c, listfp);
1845               else
1846                 es_fprintf (listfp, "\\x%02x", c);
1847             }
1848           es_fprintf (listfp, "\"\n");
1849         }
1850       iobuf_skip_rest (inp, pktlen, 0);
1851       return 0;
1852     }
1853   else if (version == 4)
1854     is_v4 = 1;
1855   else if (version != 2 && version != 3)
1856     {
1857       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
1858       err = gpg_error (GPG_ERR_INV_PACKET);
1859       goto leave;
1860     }
1861
1862   if (pktlen < 11)
1863     {
1864       log_error ("packet(%d) too short\n", pkttype);
1865       err = gpg_error (GPG_ERR_INV_PACKET);
1866       goto leave;
1867     }
1868
1869   timestamp = read_32 (inp);
1870   pktlen -= 4;
1871   if (is_v4)
1872     {
1873       expiredate = 0;           /* have to get it from the selfsignature */
1874       max_expiredate = 0;
1875     }
1876   else
1877     {
1878       unsigned short ndays;
1879       ndays = read_16 (inp);
1880       pktlen -= 2;
1881       if (ndays)
1882         expiredate = timestamp + ndays * 86400L;
1883       else
1884         expiredate = 0;
1885
1886       max_expiredate = expiredate;
1887     }
1888   algorithm = iobuf_get_noeof (inp);
1889   pktlen--;
1890   if (list_mode)
1891     es_fprintf (listfp, ":%s key packet:\n"
1892                 "\tversion %d, algo %d, created %lu, expires %lu\n",
1893                 pkttype == PKT_PUBLIC_KEY ? "public" :
1894                 pkttype == PKT_SECRET_KEY ? "secret" :
1895                 pkttype == PKT_PUBLIC_SUBKEY ? "public sub" :
1896                 pkttype == PKT_SECRET_SUBKEY ? "secret sub" : "??",
1897                 version, algorithm, timestamp, expiredate);
1898
1899   pk->timestamp = timestamp;
1900   pk->expiredate = expiredate;
1901   pk->max_expiredate = max_expiredate;
1902   pk->hdrbytes = hdrlen;
1903   pk->version = version;
1904   pk->is_primary = (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY);
1905   pk->pubkey_algo = algorithm;
1906
1907   nskey = pubkey_get_nskey (algorithm);
1908   npkey = pubkey_get_npkey (algorithm);
1909   if (!npkey)
1910     {
1911       if (list_mode)
1912         es_fprintf (listfp, "\tunknown algorithm %d\n", algorithm);
1913       unknown_pubkey_warning (algorithm);
1914     }
1915
1916
1917   if (!npkey)
1918     {
1919       /* Unknown algorithm - put data into an opaque MPI.  */
1920       pk->pkey[0] = gcry_mpi_set_opaque (NULL,
1921                                          read_rest (inp, pktlen, 0),
1922                                          pktlen * 8);
1923       pktlen = 0;
1924       goto leave;
1925     }
1926   else
1927     {
1928       /* Fill in public key parameters.  */
1929       for (i = 0; i < npkey; i++)
1930         {
1931           n = pktlen;
1932           pk->pkey[i] = mpi_read (inp, &n, 0);
1933           pktlen -= n;
1934           if (list_mode)
1935             {
1936               es_fprintf (listfp, "\tpkey[%d]: ", i);
1937               mpi_print (listfp, pk->pkey[i], mpi_print_mode);
1938               es_putc ('\n', listfp);
1939             }
1940           if (!pk->pkey[i])
1941             err = gpg_error (GPG_ERR_INV_PACKET);
1942         }
1943       if (err)
1944         goto leave;
1945     }
1946
1947   if (list_mode)
1948     keyid_from_pk (pk, keyid);
1949
1950   if (pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY)
1951     {
1952       struct seckey_info *ski;
1953       byte temp[16];
1954       size_t snlen = 0;
1955
1956       pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1957       if (!pk->seckey_info)
1958         {
1959           err = gpg_error_from_syserror ();
1960           goto leave;
1961         }
1962
1963       ski->algo = iobuf_get_noeof (inp);
1964       pktlen--;
1965       if (ski->algo)
1966         {
1967           ski->is_protected = 1;
1968           ski->s2k.count = 0;
1969           if (ski->algo == 254 || ski->algo == 255)
1970             {
1971               if (pktlen < 3)
1972                 {
1973                   err = gpg_error (GPG_ERR_INV_PACKET);
1974                   goto leave;
1975                 }
1976               ski->sha1chk = (ski->algo == 254);
1977               ski->algo = iobuf_get_noeof (inp);
1978               pktlen--;
1979               /* Note that a ski->algo > 110 is illegal, but I'm not
1980                  erroring on it here as otherwise there would be no
1981                  way to delete such a key.  */
1982               ski->s2k.mode = iobuf_get_noeof (inp);
1983               pktlen--;
1984               ski->s2k.hash_algo = iobuf_get_noeof (inp);
1985               pktlen--;
1986               /* Check for the special GNU extension.  */
1987               if (is_v4 && ski->s2k.mode == 101)
1988                 {
1989                   for (i = 0; i < 4 && pktlen; i++, pktlen--)
1990                     temp[i] = iobuf_get_noeof (inp);
1991                   if (i < 4 || memcmp (temp, "GNU", 3))
1992                     {
1993                       if (list_mode)
1994                         es_fprintf (listfp, "\tunknown S2K %d\n",
1995                                     ski->s2k.mode);
1996                       err = gpg_error (GPG_ERR_INV_PACKET);
1997                       goto leave;
1998                     }
1999                   /* Here we know that it is a GNU extension.  What
2000                    * follows is the GNU protection mode: All values
2001                    * have special meanings and they are mapped to MODE
2002                    * with a base of 1000.  */
2003                   ski->s2k.mode = 1000 + temp[3];
2004                 }
2005
2006               /* Read the salt.  */
2007               switch (ski->s2k.mode)
2008                 {
2009                 case 1:
2010                 case 3:
2011                   for (i = 0; i < 8 && pktlen; i++, pktlen--)
2012                     temp[i] = iobuf_get_noeof (inp);
2013                   memcpy (ski->s2k.salt, temp, 8);
2014                   break;
2015                 }
2016
2017               /* Check the mode.  */
2018               switch (ski->s2k.mode)
2019                 {
2020                 case 0:
2021                   if (list_mode)
2022                     es_fprintf (listfp, "\tsimple S2K");
2023                   break;
2024                 case 1:
2025                   if (list_mode)
2026                     es_fprintf (listfp, "\tsalted S2K");
2027                   break;
2028                 case 3:
2029                   if (list_mode)
2030                     es_fprintf (listfp, "\titer+salt S2K");
2031                   break;
2032                 case 1001:
2033                   if (list_mode)
2034                     es_fprintf (listfp, "\tgnu-dummy S2K");
2035                   break;
2036                 case 1002:
2037                   if (list_mode)
2038                     es_fprintf (listfp, "\tgnu-divert-to-card S2K");
2039                   break;
2040                 default:
2041                   if (list_mode)
2042                     es_fprintf (listfp, "\tunknown %sS2K %d\n",
2043                                 ski->s2k.mode < 1000 ? "" : "GNU ",
2044                                 ski->s2k.mode);
2045                   err = gpg_error (GPG_ERR_INV_PACKET);
2046                   goto leave;
2047                 }
2048
2049               /* Print some info.  */
2050               if (list_mode)
2051                 {
2052                   es_fprintf (listfp, ", algo: %d,%s hash: %d",
2053                               ski->algo,
2054                               ski->sha1chk ? " SHA1 protection,"
2055                               : " simple checksum,", ski->s2k.hash_algo);
2056                   if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
2057                     {
2058                       es_fprintf (listfp, ", salt: ");
2059                       es_write_hexstring (listfp, ski->s2k.salt, 8, 0, NULL);
2060                     }
2061                   es_putc ('\n', listfp);
2062                 }
2063
2064               /* Read remaining protection parameters.  */
2065               if (ski->s2k.mode == 3)
2066                 {
2067                   if (pktlen < 1)
2068                     {
2069                       err = gpg_error (GPG_ERR_INV_PACKET);
2070                       goto leave;
2071                     }
2072                   ski->s2k.count = iobuf_get (inp);
2073                   pktlen--;
2074                   if (list_mode)
2075                     es_fprintf (listfp, "\tprotect count: %lu\n",
2076                                 (ulong) ski->s2k.count);
2077                 }
2078               else if (ski->s2k.mode == 1002)
2079                 {
2080                   /* Read the serial number. */
2081                   if (pktlen < 1)
2082                     {
2083                       err = gpg_error (GPG_ERR_INV_PACKET);
2084                       goto leave;
2085                     }
2086                   snlen = iobuf_get (inp);
2087                   pktlen--;
2088                   if (pktlen < snlen || snlen == -1)
2089                     {
2090                       err = gpg_error (GPG_ERR_INV_PACKET);
2091                       goto leave;
2092                     }
2093                 }
2094             }
2095           else /* Old version; no S2K, so we set mode to 0, hash MD5.  */
2096             { 
2097               /* Note that a ski->algo > 110 is illegal, but I'm not
2098                  erroring on it here as otherwise there would be no
2099                  way to delete such a key.  */
2100               ski->s2k.mode = 0;
2101               ski->s2k.hash_algo = DIGEST_ALGO_MD5;
2102               if (list_mode)
2103                 es_fprintf (listfp, "\tprotect algo: %d  (hash algo: %d)\n",
2104                             ski->algo, ski->s2k.hash_algo);
2105             }
2106           
2107           /* It is really ugly that we don't know the size
2108            * of the IV here in cases we are not aware of the algorithm.
2109            * so a
2110            *   ski->ivlen = cipher_get_blocksize (ski->algo);
2111            * won't work.  The only solution I see is to hardwire it.
2112            * NOTE: if you change the ivlen above 16, don't forget to
2113            * enlarge temp.  */
2114           ski->ivlen = openpgp_cipher_blocklen (ski->algo);
2115           assert (ski->ivlen <= sizeof (temp));
2116
2117           if (ski->s2k.mode == 1001)
2118             ski->ivlen = 0;
2119           else if (ski->s2k.mode == 1002)
2120             ski->ivlen = snlen < 16 ? snlen : 16;
2121
2122           if (pktlen < ski->ivlen)
2123             {
2124               err = gpg_error (GPG_ERR_INV_PACKET);
2125               goto leave;
2126             }
2127           for (i = 0; i < ski->ivlen && pktlen; i++, pktlen--)
2128             temp[i] = iobuf_get_noeof (inp);
2129           if (list_mode)
2130             {
2131               es_fprintf (listfp,
2132                           ski->s2k.mode == 1002 ? "\tserial-number: "
2133                           : "\tprotect IV: ");
2134               for (i = 0; i < ski->ivlen; i++)
2135                 es_fprintf (listfp, " %02x", temp[i]);
2136               es_putc ('\n', listfp);
2137             }
2138           memcpy (ski->iv, temp, ski->ivlen);
2139         }
2140
2141       /* It does not make sense to read it into secure memory.
2142        * If the user is so careless, not to protect his secret key,
2143        * we can assume, that he operates an open system :=(.
2144        * So we put the key into secure memory when we unprotect it. */
2145       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2146         {
2147           /* Better set some dummy stuff here.  */
2148           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2149                                                  xstrdup ("dummydata"),
2150                                                  10 * 8);
2151           pktlen = 0;
2152         }
2153       else if (is_v4 && ski->is_protected)
2154         {
2155           /* Ugly: The length is encrypted too, so we read all stuff
2156            * up to the end of the packet into the first SKEY
2157            * element.  */
2158           pk->pkey[npkey] = gcry_mpi_set_opaque (NULL,
2159                                                  read_rest (inp, pktlen, 0),
2160                                                  pktlen * 8);
2161           pktlen = 0;
2162           if (list_mode)
2163             es_fprintf (listfp, "\tskey[%d]: [v4 protected]\n", npkey);
2164         }
2165       else 
2166         {       
2167           /* The v3 method: The mpi length is not encrypted.  */
2168           for (i = npkey; i < nskey; i++)
2169             {
2170               if (ski->is_protected)
2171                 {
2172                   pk->pkey[i] = read_protected_v3_mpi (inp, &pktlen);
2173                   if (list_mode)
2174                     es_fprintf (listfp, "\tskey[%d]: [v3 protected]\n", i);
2175                 }
2176               else
2177                 {
2178                   n = pktlen;
2179                   pk->pkey[i] = mpi_read (inp, &n, 0);
2180                   pktlen -= n;
2181                   if (list_mode)
2182                     {
2183                       es_fprintf (listfp, "\tskey[%d]: ", i);
2184                       mpi_print (listfp, pk->pkey[i], mpi_print_mode);
2185                       es_putc ('\n', listfp);
2186                     }
2187                 }
2188
2189               if (!pk->pkey[i])
2190                 err = gpg_error (GPG_ERR_INV_PACKET);
2191             }
2192           if (err)
2193             goto leave;
2194
2195           ski->csum = read_16 (inp);
2196           pktlen -= 2;
2197           if (list_mode)
2198             es_fprintf (listfp, "\tchecksum: %04hx\n", ski->csum);
2199         }
2200     }
2201
2202   if (list_mode)
2203     es_fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2204                 (ulong) keyid[0], (ulong) keyid[1]);
2205
2206  leave:
2207   iobuf_skip_rest (inp, pktlen, 0);
2208   return rc;
2209 }
2210
2211
2212 /* Attribute subpackets have the same format as v4 signature
2213    subpackets.  This is not part of OpenPGP, but is done in several
2214    versions of PGP nevertheless.  */
2215 int
2216 parse_attribute_subpkts (PKT_user_id * uid)
2217 {
2218   size_t n;
2219   int count = 0;
2220   struct user_attribute *attribs = NULL;
2221   const byte *buffer = uid->attrib_data;
2222   int buflen = uid->attrib_len;
2223   byte type;
2224
2225   xfree (uid->attribs);
2226
2227   while (buflen)
2228     {
2229       n = *buffer++;
2230       buflen--;
2231       if (n == 255)  /* 4 byte length header.  */
2232         {                       
2233           if (buflen < 4)
2234             goto too_short;
2235           n = (buffer[0] << 24) | (buffer[1] << 16)
2236             | (buffer[2] << 8) | buffer[3];
2237           buffer += 4;
2238           buflen -= 4;
2239         }
2240       else if (n >= 192)  /* 2 byte special encoded length header.  */
2241         {                       
2242           if (buflen < 2)
2243             goto too_short;
2244           n = ((n - 192) << 8) + *buffer + 192;
2245           buffer++;
2246           buflen--;
2247         }
2248       if (buflen < n)
2249         goto too_short;
2250
2251       attribs =
2252         xrealloc (attribs, (count + 1) * sizeof (struct user_attribute));
2253       memset (&attribs[count], 0, sizeof (struct user_attribute));
2254
2255       type = *buffer;
2256       buffer++;
2257       buflen--;
2258       n--;
2259
2260       attribs[count].type = type;
2261       attribs[count].data = buffer;
2262       attribs[count].len = n;
2263       buffer += n;
2264       buflen -= n;
2265       count++;
2266     }
2267
2268   uid->attribs = attribs;
2269   uid->numattribs = count;
2270   return count;
2271
2272  too_short:
2273   if (opt.verbose)
2274     log_info ("buffer shorter than attribute subpacket\n");
2275   uid->attribs = attribs;
2276   uid->numattribs = count;
2277   return count;
2278 }
2279
2280
2281 static int
2282 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2283 {
2284   byte *p;
2285
2286   /* Cap the size of a user ID at 2k: a value absurdly large enough
2287      that there is no sane user ID string (which is printable text
2288      as of RFC2440bis) that won't fit in it, but yet small enough to
2289      avoid allocation problems.  A large pktlen may not be
2290      allocatable, and a very large pktlen could actually cause our
2291      allocation to wrap around in xmalloc to a small number. */
2292
2293   if (pktlen > 2048)
2294     {
2295       log_error ("packet(%d) too large\n", pkttype);
2296       iobuf_skip_rest (inp, pktlen, 0);
2297       return G10ERR_INVALID_PACKET;
2298     }
2299
2300   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2301   packet->pkt.user_id->len = pktlen;
2302   packet->pkt.user_id->ref = 1;
2303
2304   p = packet->pkt.user_id->name;
2305   for (; pktlen; pktlen--, p++)
2306     *p = iobuf_get_noeof (inp);
2307   *p = 0;
2308
2309   if (list_mode)
2310     {
2311       int n = packet->pkt.user_id->len;
2312       es_fprintf (listfp, ":user ID packet: \"");
2313       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2314       for (p = packet->pkt.user_id->name; n; p++, n--)
2315         {
2316           if (*p >= ' ' && *p <= 'z')
2317             es_putc (*p, listfp);
2318           else
2319             es_fprintf (listfp, "\\x%02x", *p);
2320         }
2321       es_fprintf (listfp, "\"\n");
2322     }
2323   return 0;
2324 }
2325
2326
2327 void
2328 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2329 {
2330   assert (max_namelen > 70);
2331   if (uid->numattribs <= 0)
2332     sprintf (uid->name, "[bad attribute packet of size %lu]",
2333              uid->attrib_len);
2334   else if (uid->numattribs > 1)
2335     sprintf (uid->name, "[%d attributes of size %lu]",
2336              uid->numattribs, uid->attrib_len);
2337   else
2338     {
2339       /* Only one attribute, so list it as the "user id" */
2340
2341       if (uid->attribs->type == ATTRIB_IMAGE)
2342         {
2343           u32 len;
2344           byte type;
2345
2346           if (parse_image_header (uid->attribs, &type, &len))
2347             sprintf (uid->name, "[%.20s image of size %lu]",
2348                      image_type_to_string (type, 1), (ulong) len);
2349           else
2350             sprintf (uid->name, "[invalid image]");
2351         }
2352       else
2353         sprintf (uid->name, "[unknown attribute of size %lu]",
2354                  (ulong) uid->attribs->len);
2355     }
2356
2357   uid->len = strlen (uid->name);
2358 }
2359
2360
2361 static int
2362 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2363                  PACKET * packet)
2364 {
2365   byte *p;
2366
2367   (void) pkttype;
2368
2369 #define EXTRA_UID_NAME_SPACE 71
2370   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2371                                        + EXTRA_UID_NAME_SPACE);
2372   packet->pkt.user_id->ref = 1;
2373   packet->pkt.user_id->attrib_data = xmalloc (pktlen);
2374   packet->pkt.user_id->attrib_len = pktlen;
2375
2376   p = packet->pkt.user_id->attrib_data;
2377   for (; pktlen; pktlen--, p++)
2378     *p = iobuf_get_noeof (inp);
2379
2380   /* Now parse out the individual attribute subpackets.  This is
2381      somewhat pointless since there is only one currently defined
2382      attribute type (jpeg), but it is correct by the spec. */
2383   parse_attribute_subpkts (packet->pkt.user_id);
2384
2385   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2386
2387   if (list_mode)
2388     {
2389       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2390     }
2391   return 0;
2392 }
2393
2394
2395 static int
2396 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2397 {
2398   byte *p;
2399
2400   /* Cap comment packet at a reasonable value to avoid an integer
2401      overflow in the malloc below.  Comment packets are actually not
2402      anymore define my OpenPGP and we even stopped to use our
2403      private comment packet.  */
2404   if (pktlen > 65536)
2405     {
2406       log_error ("packet(%d) too large\n", pkttype);
2407       iobuf_skip_rest (inp, pktlen, 0);
2408       return G10ERR_INVALID_PACKET;
2409     }
2410   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2411   packet->pkt.comment->len = pktlen;
2412   p = packet->pkt.comment->data;
2413   for (; pktlen; pktlen--, p++)
2414     *p = iobuf_get_noeof (inp);
2415
2416   if (list_mode)
2417     {
2418       int n = packet->pkt.comment->len;
2419       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2420                   "OpenPGP draft " : "");
2421       for (p = packet->pkt.comment->data; n; p++, n--)
2422         {
2423           if (*p >= ' ' && *p <= 'z')
2424             es_putc (*p, listfp);
2425           else
2426             es_fprintf (listfp, "\\x%02x", *p);
2427         }
2428       es_fprintf (listfp, "\"\n");
2429     }
2430   return 0;
2431 }
2432
2433
2434 static void
2435 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2436 {
2437   int c;
2438
2439   (void) pkttype;
2440
2441   if (pktlen)
2442     {
2443       c = iobuf_get_noeof (inp);
2444       pktlen--;
2445       pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2446       pkt->pkt.ring_trust->trustval = c;
2447       pkt->pkt.ring_trust->sigcache = 0;
2448       if (!c && pktlen == 1)
2449         {
2450           c = iobuf_get_noeof (inp);
2451           pktlen--;
2452           /* We require that bit 7 of the sigcache is 0 (easier eof
2453              handling).  */
2454           if (!(c & 0x80))
2455             pkt->pkt.ring_trust->sigcache = c;
2456         }
2457       if (list_mode)
2458         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2459                     pkt->pkt.ring_trust->trustval,
2460                     pkt->pkt.ring_trust->sigcache);
2461     }
2462   else
2463     {
2464       if (list_mode)
2465         es_fprintf (listfp, ":trust packet: empty\n");
2466     }
2467   iobuf_skip_rest (inp, pktlen, 0);
2468 }
2469
2470
2471 static int
2472 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2473                  PACKET * pkt, int new_ctb, int partial)
2474 {
2475   int rc = 0;
2476   int mode, namelen;
2477   PKT_plaintext *pt;
2478   byte *p;
2479   int c, i;
2480
2481   if (!partial && pktlen < 6)
2482     {
2483       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2484       rc = gpg_error (GPG_ERR_INV_PACKET);
2485       goto leave;
2486     }
2487   mode = iobuf_get_noeof (inp);
2488   if (pktlen)
2489     pktlen--;
2490   namelen = iobuf_get_noeof (inp);
2491   if (pktlen)
2492     pktlen--;
2493   /* Note that namelen will never exceed 255 bytes. */
2494   pt = pkt->pkt.plaintext =
2495     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2496   pt->new_ctb = new_ctb;
2497   pt->mode = mode;
2498   pt->namelen = namelen;
2499   pt->is_partial = partial;
2500   if (pktlen)
2501     {
2502       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2503         pt->name[i] = iobuf_get_noeof (inp);
2504     }
2505   else
2506     {
2507       for (i = 0; i < namelen; i++)
2508         if ((c = iobuf_get (inp)) == -1)
2509           break;
2510         else
2511           pt->name[i] = c;
2512     }
2513   pt->timestamp = read_32 (inp);
2514   if (pktlen)
2515     pktlen -= 4;
2516   pt->len = pktlen;
2517   pt->buf = inp;
2518   pktlen = 0;
2519
2520   if (list_mode)
2521     {
2522       es_fprintf (listfp, ":literal data packet:\n"
2523                   "\tmode %c (%X), created %lu, name=\"",
2524                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2525                   (ulong) pt->timestamp);
2526       for (p = pt->name, i = 0; i < namelen; p++, i++)
2527         {
2528           if (*p >= ' ' && *p <= 'z')
2529             es_putc (*p, listfp);
2530           else
2531             es_fprintf (listfp, "\\x%02x", *p);
2532         }
2533       es_fprintf (listfp, "\",\n\traw data: ");
2534       if (partial)
2535         es_fprintf (listfp, "unknown length\n");
2536       else
2537         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2538     }
2539
2540  leave:
2541   return rc;
2542 }
2543
2544
2545 static int
2546 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2547                   PACKET * pkt, int new_ctb)
2548 {
2549   PKT_compressed *zd;
2550
2551   /* PKTLEN is here 0, but data follows (this should be the last
2552      object in a file or the compress algorithm should know the
2553      length).  */
2554   (void) pkttype;
2555   (void) pktlen;
2556
2557   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2558   zd->algorithm = iobuf_get_noeof (inp);
2559   zd->len = 0;                  /* not used */
2560   zd->new_ctb = new_ctb;
2561   zd->buf = inp;
2562   if (list_mode)
2563     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2564   return 0;
2565 }
2566
2567
2568 static int
2569 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2570                  PACKET * pkt, int new_ctb, int partial)
2571 {
2572   int rc = 0;
2573   PKT_encrypted *ed;
2574   unsigned long orig_pktlen = pktlen;
2575
2576   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2577   /* ed->len is set below.  */
2578   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2579   ed->buf = NULL;
2580   ed->new_ctb = new_ctb;
2581   ed->is_partial = partial;
2582   if (pkttype == PKT_ENCRYPTED_MDC)
2583     {
2584       /* Fixme: add some pktlen sanity checks.  */
2585       int version;
2586
2587       version = iobuf_get_noeof (inp);
2588       if (orig_pktlen)
2589         pktlen--;
2590       if (version != 1)
2591         {
2592           log_error ("encrypted_mdc packet with unknown version %d\n",
2593                      version);
2594           /*skip_rest(inp, pktlen); should we really do this? */
2595           rc = gpg_error (GPG_ERR_INV_PACKET);
2596           goto leave;
2597         }
2598       ed->mdc_method = DIGEST_ALGO_SHA1;
2599     }
2600   else
2601     ed->mdc_method = 0;
2602
2603   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2604      detection bytes.  Note that we don't known the algorithm and thus
2605      we may only check against the minimum blocksize.  */
2606   if (orig_pktlen && pktlen < 10)
2607     {
2608       /* Actually this is blocksize+2.  */
2609       log_error ("packet(%d) too short\n", pkttype);
2610       rc = G10ERR_INVALID_PACKET;
2611       iobuf_skip_rest (inp, pktlen, partial);
2612       goto leave;
2613     }
2614
2615   /* Store the remaining length of the encrypted data (i.e. without
2616      the MDC version number but with the IV etc.).  This value is
2617      required during decryption.  */
2618   ed->len = pktlen;
2619
2620   if (list_mode)
2621     {
2622       if (orig_pktlen)
2623         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2624                     orig_pktlen);
2625       else
2626         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2627       if (ed->mdc_method)
2628         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2629     }
2630
2631   ed->buf = inp;
2632
2633  leave:
2634   return rc;
2635 }
2636
2637
2638 /* Note, that this code is not anymore used in real life because the
2639    MDC checking is now done right after the decryption in
2640    decrypt_data.  */
2641 static int
2642 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2643            PACKET * pkt, int new_ctb)
2644 {
2645   int rc = 0;
2646   PKT_mdc *mdc;
2647   byte *p;
2648
2649   (void) pkttype;
2650
2651   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2652   if (list_mode)
2653     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2654   if (!new_ctb || pktlen != 20)
2655     {
2656       log_error ("mdc_packet with invalid encoding\n");
2657       rc = gpg_error (GPG_ERR_INV_PACKET);
2658       goto leave;
2659     }
2660   p = mdc->hash;
2661   for (; pktlen; pktlen--, p++)
2662     *p = iobuf_get_noeof (inp);
2663
2664  leave:
2665   return rc;
2666 }
2667
2668
2669 /*
2670  * This packet is internally generated by us (ibn armor.c) to transfer
2671  * some information to the lower layer.  To make sure that this packet
2672  * is really a GPG faked one and not one comming from outside, we
2673  * first check that there is a unique tag in it.
2674  *
2675  * The format of such a control packet is:
2676  *   n byte  session marker
2677  *   1 byte  control type CTRLPKT_xxxxx
2678  *   m byte  control data
2679  */
2680 static int
2681 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2682                    PACKET * packet, int partial)
2683 {
2684   byte *p;
2685   const byte *sesmark;
2686   size_t sesmarklen;
2687   int i;
2688
2689   (void) pkttype;
2690
2691   if (list_mode)
2692     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2693
2694   sesmark = get_session_marker (&sesmarklen);
2695   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2696     goto skipit;
2697   for (i = 0; i < sesmarklen; i++, pktlen--)
2698     {
2699       if (sesmark[i] != iobuf_get_noeof (inp))
2700         goto skipit;
2701     }
2702   if (pktlen > 4096)
2703     goto skipit;  /* Definitely too large.  We skip it to avoid an
2704                      overflow in the malloc.  */
2705   if (list_mode)
2706     puts ("- gpg control packet");
2707
2708   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2709                                      + pktlen - 1);
2710   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2711   pktlen--;
2712   packet->pkt.gpg_control->datalen = pktlen;
2713   p = packet->pkt.gpg_control->data;
2714   for (; pktlen; pktlen--, p++)
2715     *p = iobuf_get_noeof (inp);
2716
2717   return 0;
2718
2719  skipit:
2720   if (list_mode)
2721     {
2722       int c;
2723
2724       i = 0;
2725       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2726       if (partial)
2727         {
2728           while ((c = iobuf_get (inp)) != -1)
2729             dump_hex_line (c, &i);
2730         }
2731       else
2732         {
2733           for (; pktlen; pktlen--)
2734             {
2735               dump_hex_line ((c = iobuf_get (inp)), &i);
2736               if (c == -1)
2737                 break;
2738             }
2739         }
2740       es_putc ('\n', listfp);
2741     }
2742   iobuf_skip_rest (inp, pktlen, 0);
2743   return gpg_error (GPG_ERR_INV_PACKET);
2744 }
2745
2746
2747 /* Create a GPG control packet to be used internally as a placeholder.  */
2748 PACKET *
2749 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2750 {
2751   PACKET *packet;
2752   byte *p;
2753
2754   packet = xmalloc (sizeof *packet);
2755   init_packet (packet);
2756   packet->pkttype = PKT_GPG_CONTROL;
2757   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2758                                      + datalen - 1);
2759   packet->pkt.gpg_control->control = type;
2760   packet->pkt.gpg_control->datalen = datalen;
2761   p = packet->pkt.gpg_control->data;
2762   for (; datalen; datalen--, p++)
2763     *p = *data++;
2764
2765   return packet;
2766 }
2767