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