Use inline functions to convert buffer data to scalars.
[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 #include "host2net.h"
38
39
40 /* Maximum length of packets to avoid excessive memory allocation.  */
41 #define MAX_KEY_PACKET_LENGTH     (256 * 1024)
42 #define MAX_UID_PACKET_LENGTH     (  2 * 1024)
43 #define MAX_COMMENT_PACKET_LENGTH ( 64 * 1024)
44 #define MAX_ATTR_PACKET_LENGTH    ( 16 * 1024*1024)
45
46
47 static int mpi_print_mode;
48 static int list_mode;
49 static estream_t listfp;
50
51 static int parse (IOBUF inp, PACKET * pkt, int onlykeypkts,
52                   off_t * retpos, int *skip, IOBUF out, int do_skip
53 #ifdef DEBUG_PARSE_PACKET
54                   , const char *dbg_w, const char *dbg_f, int dbg_l
55 #endif
56   );
57 static int copy_packet (IOBUF inp, IOBUF out, int pkttype,
58                         unsigned long pktlen, int partial);
59 static void skip_packet (IOBUF inp, int pkttype,
60                          unsigned long pktlen, int partial);
61 static void *read_rest (IOBUF inp, size_t pktlen);
62 static int parse_marker (IOBUF inp, int pkttype, unsigned long pktlen);
63 static int parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
64                             PACKET * packet);
65 static int parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
66                             PACKET * packet);
67 static int parse_onepass_sig (IOBUF inp, int pkttype, unsigned long pktlen,
68                               PKT_onepass_sig * ops);
69 static int parse_key (IOBUF inp, int pkttype, unsigned long pktlen,
70                       byte * hdr, int hdrlen, PACKET * packet);
71 static int parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen,
72                           PACKET * packet);
73 static int parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
74                             PACKET * packet);
75 static int parse_comment (IOBUF inp, int pkttype, unsigned long pktlen,
76                           PACKET * packet);
77 static void parse_trust (IOBUF inp, int pkttype, unsigned long pktlen,
78                          PACKET * packet);
79 static int parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
80                             PACKET * packet, int new_ctb, int partial);
81 static int parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
82                              PACKET * packet, int new_ctb);
83 static int parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
84                             PACKET * packet, int new_ctb, int partial);
85 static int parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
86                       PACKET * packet, int new_ctb);
87 static int parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
88                               PACKET * packet, int partial);
89
90 static unsigned short
91 read_16 (IOBUF inp)
92 {
93   unsigned short a;
94   a = (unsigned short)iobuf_get_noeof (inp) << 8;
95   a |= iobuf_get_noeof (inp);
96   return a;
97 }
98
99
100 static unsigned long
101 read_32 (IOBUF inp)
102 {
103   unsigned long a;
104   a = (unsigned long)iobuf_get_noeof (inp) << 24;
105   a |= iobuf_get_noeof (inp) << 16;
106   a |= iobuf_get_noeof (inp) << 8;
107   a |= iobuf_get_noeof (inp);
108   return a;
109 }
110
111
112 /* Read an external representation of an mpi and return the MPI.  The
113  * external format is a 16 bit unsigned value stored in network byte
114  * order, giving the number of bits for the following integer. The
115  * integer is stored with MSB first (left padded with zeroes to align
116  * on a byte boundary).  */
117 static gcry_mpi_t
118 mpi_read (iobuf_t inp, unsigned int *ret_nread, int secure)
119 {
120   int c, c1, c2, i;
121   unsigned int nmax = *ret_nread;
122   unsigned int nbits, nbytes;
123   size_t nread = 0;
124   gcry_mpi_t a = NULL;
125   byte *buf = NULL;
126   byte *p;
127
128   if (!nmax)
129     goto overflow;
130
131   if ((c = c1 = iobuf_get (inp)) == -1)
132     goto leave;
133   if (++nread == nmax)
134     goto overflow;
135   nbits = c << 8;
136   if ((c = c2 = iobuf_get (inp)) == -1)
137     goto leave;
138   ++nread;
139   nbits |= c;
140   if (nbits > MAX_EXTERN_MPI_BITS)
141     {
142       log_error ("mpi too large (%u bits)\n", nbits);
143       goto leave;
144     }
145
146   nbytes = (nbits + 7) / 8;
147   buf = secure ? gcry_xmalloc_secure (nbytes + 2) : gcry_xmalloc (nbytes + 2);
148   p = buf;
149   p[0] = c1;
150   p[1] = c2;
151   for (i = 0; i < nbytes; i++)
152     {
153       p[i + 2] = iobuf_get (inp) & 0xff;
154       if (nread == nmax)
155         goto overflow;
156       nread++;
157     }
158
159   if (gcry_mpi_scan (&a, GCRYMPI_FMT_PGP, buf, nread, &nread))
160     a = NULL;
161
162   *ret_nread = nread;
163   gcry_free(buf);
164   return a;
165
166  overflow:
167   log_error ("mpi larger than indicated length (%u bits)\n", 8*nmax);
168  leave:
169   *ret_nread = nread;
170   gcry_free(buf);
171   return a;
172 }
173
174
175 int
176 set_packet_list_mode (int mode)
177 {
178   int old = list_mode;
179   list_mode = mode;
180   /* FIXME(gcrypt) mpi_print_mode = DBG_MPI; */
181   /* We use stdout print only if invoked by the --list-packets command
182      but switch to stderr in all other cases.  This breaks the
183      previous behaviour but that seems to be more of a bug than
184      intentional.  I don't believe that any application makes use of
185      this long standing annoying way of printing to stdout except when
186      doing a --list-packets. If this assumption fails, it will be easy
187      to add an option for the listing stream.  Note that we initialize
188      it only once; mainly because some code may switch the option
189      value later back to 1 and we want to have all output to the same
190      stream.
191
192      Using stderr is not actually very clean because it bypasses the
193      logging code but it is a special thing anyway.  I am not sure
194      whether using log_stream() would be better.  Perhaps we should
195      enable the list mdoe only with a special option. */
196   if (!listfp)
197     listfp = opt.list_packets == 2 ? es_stdout : es_stderr;
198   return old;
199 }
200
201
202 static void
203 unknown_pubkey_warning (int algo)
204 {
205   static byte unknown_pubkey_algos[256];
206
207   /* First check whether the algorithm is usable but not suitable for
208      encryption/signing.  */
209   if (pubkey_get_npkey (algo))
210     {
211       if (opt.verbose)
212         {
213           if (!pubkey_get_nsig (algo))
214             log_info ("public key algorithm %s not suitable for %s\n",
215                       openpgp_pk_algo_name (algo), "signing");
216           if (!pubkey_get_nenc (algo))
217             log_info ("public key algorithm %s not suitable for %s\n",
218                       openpgp_pk_algo_name (algo), "encryption");
219         }
220     }
221   else
222     {
223       algo &= 0xff;
224       if (!unknown_pubkey_algos[algo])
225         {
226           if (opt.verbose)
227             log_info (_("can't handle public key algorithm %d\n"), algo);
228           unknown_pubkey_algos[algo] = 1;
229         }
230     }
231 }
232
233
234 /* Parse a packet and return it in packet structure.
235  * Returns: 0 := valid packet in pkt
236  *         -1 := no more packets
237  *         >0 := error
238  * Note: The function may return an error and a partly valid packet;
239  * caller must free this packet.   */
240 #ifdef DEBUG_PARSE_PACKET
241 int
242 dbg_parse_packet (IOBUF inp, PACKET *pkt, const char *dbg_f, int dbg_l)
243 {
244   int skip, rc;
245
246   do
247     {
248       rc = parse (inp, pkt, 0, NULL, &skip, NULL, 0, "parse", dbg_f, dbg_l);
249     }
250   while (skip);
251   return rc;
252 }
253 #else /*!DEBUG_PARSE_PACKET*/
254 int
255 parse_packet (IOBUF inp, PACKET * pkt)
256 {
257   int skip, rc;
258
259   do
260     {
261       rc = parse (inp, pkt, 0, NULL, &skip, NULL, 0);
262     }
263   while (skip);
264   return rc;
265 }
266 #endif /*!DEBUG_PARSE_PACKET*/
267
268
269 /*
270  * Like parse packet, but only return secret or public (sub)key
271  * packets.
272  */
273 #ifdef DEBUG_PARSE_PACKET
274 int
275 dbg_search_packet (IOBUF inp, PACKET * pkt, off_t * retpos, int with_uid,
276                    const char *dbg_f, int dbg_l)
277 {
278   int skip, rc;
279
280   do
281     {
282       rc =
283         parse (inp, pkt, with_uid ? 2 : 1, retpos, &skip, NULL, 0, "search",
284                dbg_f, dbg_l);
285     }
286   while (skip);
287   return rc;
288 }
289 #else /*!DEBUG_PARSE_PACKET*/
290 int
291 search_packet (IOBUF inp, PACKET * pkt, off_t * retpos, int with_uid)
292 {
293   int skip, rc;
294
295   do
296     {
297       rc = parse (inp, pkt, with_uid ? 2 : 1, retpos, &skip, NULL, 0);
298     }
299   while (skip);
300   return rc;
301 }
302 #endif /*!DEBUG_PARSE_PACKET*/
303
304
305 /*
306  * Copy all packets from INP to OUT, thereby removing unused spaces.
307  */
308 #ifdef DEBUG_PARSE_PACKET
309 int
310 dbg_copy_all_packets (IOBUF inp, IOBUF out, const char *dbg_f, int dbg_l)
311 {
312   PACKET pkt;
313   int skip, rc = 0;
314   do
315     {
316       init_packet (&pkt);
317     }
318   while (!
319          (rc =
320           parse (inp, &pkt, 0, NULL, &skip, out, 0, "copy", dbg_f, dbg_l)));
321   return rc;
322 }
323 #else /*!DEBUG_PARSE_PACKET*/
324 int
325 copy_all_packets (IOBUF inp, IOBUF out)
326 {
327   PACKET pkt;
328   int skip, rc = 0;
329   do
330     {
331       init_packet (&pkt);
332     }
333   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0)));
334   return rc;
335 }
336 #endif /*!DEBUG_PARSE_PACKET*/
337
338
339 /*
340  * Copy some packets from INP to OUT, thereby removing unused spaces.
341  * Stop at offset STOPoff (i.e. don't copy packets at this or later
342  * offsets)
343  */
344 #ifdef DEBUG_PARSE_PACKET
345 int
346 dbg_copy_some_packets (IOBUF inp, IOBUF out, off_t stopoff,
347                        const char *dbg_f, int dbg_l)
348 {
349   PACKET pkt;
350   int skip, rc = 0;
351   do
352     {
353       if (iobuf_tell (inp) >= stopoff)
354         return 0;
355       init_packet (&pkt);
356     }
357   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0,
358                        "some", dbg_f, dbg_l)));
359   return rc;
360 }
361 #else /*!DEBUG_PARSE_PACKET*/
362 int
363 copy_some_packets (IOBUF inp, IOBUF out, off_t stopoff)
364 {
365   PACKET pkt;
366   int skip, rc = 0;
367   do
368     {
369       if (iobuf_tell (inp) >= stopoff)
370         return 0;
371       init_packet (&pkt);
372     }
373   while (!(rc = parse (inp, &pkt, 0, NULL, &skip, out, 0)));
374   return rc;
375 }
376 #endif /*!DEBUG_PARSE_PACKET*/
377
378
379 /*
380  * Skip over N packets
381  */
382 #ifdef DEBUG_PARSE_PACKET
383 int
384 dbg_skip_some_packets (IOBUF inp, unsigned n, const char *dbg_f, int dbg_l)
385 {
386   int skip, rc = 0;
387   PACKET pkt;
388
389   for (; n && !rc; n--)
390     {
391       init_packet (&pkt);
392       rc = parse (inp, &pkt, 0, NULL, &skip, NULL, 1, "skip", dbg_f, dbg_l);
393     }
394   return rc;
395 }
396 #else /*!DEBUG_PARSE_PACKET*/
397 int
398 skip_some_packets (IOBUF inp, unsigned n)
399 {
400   int skip, rc = 0;
401   PACKET pkt;
402
403   for (; n && !rc; n--)
404     {
405       init_packet (&pkt);
406       rc = parse (inp, &pkt, 0, NULL, &skip, NULL, 1);
407     }
408   return rc;
409 }
410 #endif /*!DEBUG_PARSE_PACKET*/
411
412
413 /*
414  * Parse packet.  Stores 1 at SKIP 1 if the packet should be skipped;
415  * this is the case if either ONLYKEYPKTS is set and the parsed packet
416  * isn't a key packet or the packet-type is 0, indicating deleted
417  * stuff.  If OUT is not NULL, a special copymode is used.
418  */
419 static int
420 parse (IOBUF inp, PACKET * pkt, int onlykeypkts, off_t * retpos,
421        int *skip, IOBUF out, int do_skip
422 #ifdef DEBUG_PARSE_PACKET
423        , const char *dbg_w, const char *dbg_f, int dbg_l
424 #endif
425        )
426 {
427   int rc = 0, c, ctb, pkttype, lenbytes;
428   unsigned long pktlen;
429   byte hdr[8];
430   int hdrlen;
431   int new_ctb = 0, partial = 0;
432   int with_uid = (onlykeypkts == 2);
433   off_t pos;
434
435   *skip = 0;
436   assert (!pkt->pkt.generic);
437   if (retpos || list_mode)
438     {
439       pos = iobuf_tell (inp);
440       if (retpos)
441         *retpos = pos;
442     }
443   else
444     pos = 0; /* (silence compiler warning) */
445
446   if ((ctb = iobuf_get (inp)) == -1)
447     {
448       rc = -1;
449       goto leave;
450     }
451   hdrlen = 0;
452   hdr[hdrlen++] = ctb;
453   if (!(ctb & 0x80))
454     {
455       log_error ("%s: invalid packet (ctb=%02x)\n", iobuf_where (inp), ctb);
456       rc = gpg_error (GPG_ERR_INV_PACKET);
457       goto leave;
458     }
459   pktlen = 0;
460   new_ctb = !!(ctb & 0x40);
461   if (new_ctb)
462     {
463       pkttype = ctb & 0x3f;
464       if ((c = iobuf_get (inp)) == -1)
465         {
466           log_error ("%s: 1st length byte missing\n", iobuf_where (inp));
467           rc = gpg_error (GPG_ERR_INV_PACKET);
468           goto leave;
469         }
470
471
472       hdr[hdrlen++] = c;
473       if (c < 192)
474         pktlen = c;
475       else if (c < 224)
476         {
477           pktlen = (c - 192) * 256;
478           if ((c = iobuf_get (inp)) == -1)
479             {
480               log_error ("%s: 2nd length byte missing\n",
481                          iobuf_where (inp));
482               rc = gpg_error (GPG_ERR_INV_PACKET);
483               goto leave;
484             }
485           hdr[hdrlen++] = c;
486           pktlen += c + 192;
487         }
488       else if (c == 255)
489         {
490           pktlen = (unsigned long)(hdr[hdrlen++] = iobuf_get_noeof (inp)) << 24;
491           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof (inp)) << 16;
492           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof (inp)) << 8;
493           if ((c = iobuf_get (inp)) == -1)
494             {
495               log_error ("%s: 4 byte length invalid\n", iobuf_where (inp));
496               rc = gpg_error (GPG_ERR_INV_PACKET);
497               goto leave;
498             }
499           pktlen |= (hdr[hdrlen++] = c);
500         }
501       else /* Partial body length.  */
502         {
503           switch (pkttype)
504             {
505             case PKT_PLAINTEXT:
506             case PKT_ENCRYPTED:
507             case PKT_ENCRYPTED_MDC:
508             case PKT_COMPRESSED:
509               iobuf_set_partial_block_mode (inp, c & 0xff);
510               pktlen = 0;       /* To indicate partial length.  */
511               partial = 1;
512               break;
513
514             default:
515               log_error ("%s: partial length for invalid"
516                          " packet type %d\n", iobuf_where (inp), pkttype);
517               rc = gpg_error (GPG_ERR_INV_PACKET);
518               goto leave;
519             }
520         }
521
522     }
523   else
524     {
525       pkttype = (ctb >> 2) & 0xf;
526       lenbytes = ((ctb & 3) == 3) ? 0 : (1 << (ctb & 3));
527       if (!lenbytes)
528         {
529           pktlen = 0;   /* Don't know the value.  */
530           /* This isn't really partial, but we can treat it the same
531              in a "read until the end" sort of way.  */
532           partial = 1;
533           if (pkttype != PKT_ENCRYPTED && pkttype != PKT_PLAINTEXT
534               && pkttype != PKT_COMPRESSED)
535             {
536               log_error ("%s: indeterminate length for invalid"
537                          " packet type %d\n", iobuf_where (inp), pkttype);
538               rc = gpg_error (GPG_ERR_INV_PACKET);
539               goto leave;
540             }
541         }
542       else
543         {
544           for (; lenbytes; lenbytes--)
545             {
546               pktlen <<= 8;
547               pktlen |= hdr[hdrlen++] = iobuf_get_noeof (inp);
548             }
549         }
550     }
551
552   if (pktlen == (unsigned long) (-1))
553     {
554       /* With some probability this is caused by a problem in the
555        * the uncompressing layer - in some error cases it just loops
556        * and spits out 0xff bytes. */
557       log_error ("%s: garbled packet detected\n", iobuf_where (inp));
558       g10_exit (2);
559     }
560
561   if (out && pkttype)
562     {
563       rc = iobuf_write (out, hdr, hdrlen);
564       if (!rc)
565         rc = copy_packet (inp, out, pkttype, pktlen, partial);
566       goto leave;
567     }
568
569   if (with_uid && pkttype == PKT_USER_ID)
570     ;
571   else if (do_skip
572            || !pkttype
573            || (onlykeypkts && pkttype != PKT_PUBLIC_SUBKEY
574                && pkttype != PKT_PUBLIC_KEY
575                && pkttype != PKT_SECRET_SUBKEY && pkttype != PKT_SECRET_KEY))
576     {
577       iobuf_skip_rest (inp, pktlen, partial);
578       *skip = 1;
579       rc = 0;
580       goto leave;
581     }
582
583   if (DBG_PACKET)
584     {
585 #ifdef DEBUG_PARSE_PACKET
586       log_debug ("parse_packet(iob=%d): type=%d length=%lu%s (%s.%s.%d)\n",
587                  iobuf_id (inp), pkttype, pktlen, new_ctb ? " (new_ctb)" : "",
588                  dbg_w, dbg_f, dbg_l);
589 #else
590       log_debug ("parse_packet(iob=%d): type=%d length=%lu%s\n",
591                  iobuf_id (inp), pkttype, pktlen,
592                  new_ctb ? " (new_ctb)" : "");
593 #endif
594     }
595
596   if (list_mode)
597     es_fprintf (listfp, "# off=%lu ctb=%02x tag=%d hlen=%d plen=%lu%s%s\n",
598                 (unsigned long)pos, ctb, pkttype, hdrlen, pktlen,
599                 partial? " partial":"",
600                 new_ctb? " new-ctb":"");
601
602   pkt->pkttype = pkttype;
603   rc = GPG_ERR_UNKNOWN_PACKET;  /* default error */
604   switch (pkttype)
605     {
606     case PKT_PUBLIC_KEY:
607     case PKT_PUBLIC_SUBKEY:
608     case PKT_SECRET_KEY:
609     case PKT_SECRET_SUBKEY:
610       pkt->pkt.public_key = xmalloc_clear (sizeof *pkt->pkt.public_key);
611       rc = parse_key (inp, pkttype, pktlen, hdr, hdrlen, pkt);
612       break;
613     case PKT_SYMKEY_ENC:
614       rc = parse_symkeyenc (inp, pkttype, pktlen, pkt);
615       break;
616     case PKT_PUBKEY_ENC:
617       rc = parse_pubkeyenc (inp, pkttype, pktlen, pkt);
618       break;
619     case PKT_SIGNATURE:
620       pkt->pkt.signature = xmalloc_clear (sizeof *pkt->pkt.signature);
621       rc = parse_signature (inp, pkttype, pktlen, pkt->pkt.signature);
622       break;
623     case PKT_ONEPASS_SIG:
624       pkt->pkt.onepass_sig = xmalloc_clear (sizeof *pkt->pkt.onepass_sig);
625       rc = parse_onepass_sig (inp, pkttype, pktlen, pkt->pkt.onepass_sig);
626       break;
627     case PKT_USER_ID:
628       rc = parse_user_id (inp, pkttype, pktlen, pkt);
629       break;
630     case PKT_ATTRIBUTE:
631       pkt->pkttype = pkttype = PKT_USER_ID;     /* we store it in the userID */
632       rc = parse_attribute (inp, pkttype, pktlen, pkt);
633       break;
634     case PKT_OLD_COMMENT:
635     case PKT_COMMENT:
636       rc = parse_comment (inp, pkttype, pktlen, pkt);
637       break;
638     case PKT_RING_TRUST:
639       parse_trust (inp, pkttype, pktlen, pkt);
640       rc = 0;
641       break;
642     case PKT_PLAINTEXT:
643       rc = parse_plaintext (inp, pkttype, pktlen, pkt, new_ctb, partial);
644       break;
645     case PKT_COMPRESSED:
646       rc = parse_compressed (inp, pkttype, pktlen, pkt, new_ctb);
647       break;
648     case PKT_ENCRYPTED:
649     case PKT_ENCRYPTED_MDC:
650       rc = parse_encrypted (inp, pkttype, pktlen, pkt, new_ctb, partial);
651       break;
652     case PKT_MDC:
653       rc = parse_mdc (inp, pkttype, pktlen, pkt, new_ctb);
654       break;
655     case PKT_GPG_CONTROL:
656       rc = parse_gpg_control (inp, pkttype, pktlen, pkt, partial);
657       break;
658     case PKT_MARKER:
659       rc = parse_marker (inp, pkttype, pktlen);
660       break;
661     default:
662       skip_packet (inp, pkttype, pktlen, partial);
663       break;
664     }
665
666  leave:
667   /* FIXME: Do we leak in case of an error?  */
668   if (!rc && iobuf_error (inp))
669     rc = GPG_ERR_INV_KEYRING;
670
671   /* FIXME: We use only the error code for now to avoid problems with
672      callers which have not been checked to always use gpg_err_code()
673      when comparing error codes.  */
674   return rc == -1? -1 : gpg_err_code (rc);
675 }
676
677
678 static void
679 dump_hex_line (int c, int *i)
680 {
681   if (*i && !(*i % 8))
682     {
683       if (*i && !(*i % 24))
684         es_fprintf (listfp, "\n%4d:", *i);
685       else
686         es_putc (' ', listfp);
687     }
688   if (c == -1)
689     es_fprintf (listfp, " EOF");
690   else
691     es_fprintf (listfp, " %02x", c);
692   ++*i;
693 }
694
695
696 static int
697 copy_packet (IOBUF inp, IOBUF out, int pkttype,
698              unsigned long pktlen, int partial)
699 {
700   int rc;
701   int n;
702   char buf[100];
703
704   if (partial)
705     {
706       while ((n = iobuf_read (inp, buf, 100)) != -1)
707         if ((rc = iobuf_write (out, buf, n)))
708           return rc;            /* write error */
709     }
710   else if (!pktlen && pkttype == PKT_COMPRESSED)
711     {
712       log_debug ("copy_packet: compressed!\n");
713       /* compressed packet, copy till EOF */
714       while ((n = iobuf_read (inp, buf, 100)) != -1)
715         if ((rc = iobuf_write (out, buf, n)))
716           return rc;            /* write error */
717     }
718   else
719     {
720       for (; pktlen; pktlen -= n)
721         {
722           n = pktlen > 100 ? 100 : pktlen;
723           n = iobuf_read (inp, buf, n);
724           if (n == -1)
725             return gpg_error (GPG_ERR_EOF);
726           if ((rc = iobuf_write (out, buf, n)))
727             return rc;          /* write error */
728         }
729     }
730   return 0;
731 }
732
733
734 static void
735 skip_packet (IOBUF inp, int pkttype, unsigned long pktlen, int partial)
736 {
737   if (list_mode)
738     {
739       es_fprintf (listfp, ":unknown packet: type %2d, length %lu\n",
740                   pkttype, pktlen);
741       if (pkttype)
742         {
743           int c, i = 0;
744           es_fputs ("dump:", listfp);
745           if (partial)
746             {
747               while ((c = iobuf_get (inp)) != -1)
748                 dump_hex_line (c, &i);
749             }
750           else
751             {
752               for (; pktlen; pktlen--)
753                 {
754                   dump_hex_line ((c = iobuf_get (inp)), &i);
755                   if (c == -1)
756                     break;
757                 }
758             }
759           es_putc ('\n', listfp);
760           return;
761         }
762     }
763   iobuf_skip_rest (inp, pktlen, partial);
764 }
765
766
767 /* Read PKTLEN bytes form INP and return them in a newly allocated
768    buffer.  In case of an error NULL is returned and a error messages
769    printed.  */
770 static void *
771 read_rest (IOBUF inp, size_t pktlen)
772 {
773   int c;
774   byte *buf, *p;
775
776   buf = xtrymalloc (pktlen);
777   if (!buf)
778     {
779       gpg_error_t err = gpg_error_from_syserror ();
780       log_error ("error reading rest of packet: %s\n", gpg_strerror (err));
781       return NULL;
782     }
783   for (p = buf; pktlen; pktlen--)
784     {
785       c = iobuf_get (inp);
786       if (c == -1)
787         {
788           log_error ("premature eof while reading rest of packet\n");
789           xfree (buf);
790           return NULL;
791         }
792       *p++ = c;
793     }
794
795   return buf;
796 }
797
798
799 /* Read a special size+body from INP.  On success store an opaque MPI
800    with it at R_DATA.  On error return an error code and store NULL at
801    R_DATA.  Even in the error case store the number of read bytes at
802    R_NREAD.  The caller shall pass the remaining size of the packet in
803    PKTLEN.  */
804 static gpg_error_t
805 read_size_body (iobuf_t inp, int pktlen, size_t *r_nread,
806                 gcry_mpi_t *r_data)
807 {
808   char buffer[256];
809   char *tmpbuf;
810   int i, c, nbytes;
811
812   *r_nread = 0;
813   *r_data = NULL;
814
815   if (!pktlen)
816     return gpg_error (GPG_ERR_INV_PACKET);
817   c = iobuf_readbyte (inp);
818   if (c < 0)
819     return gpg_error (GPG_ERR_INV_PACKET);
820   pktlen--;
821   ++*r_nread;
822   nbytes = c;
823   if (nbytes < 2 || nbytes > 254)
824     return gpg_error (GPG_ERR_INV_PACKET);
825   if (nbytes > pktlen)
826     return gpg_error (GPG_ERR_INV_PACKET);
827
828   buffer[0] = nbytes;
829
830   for (i = 0; i < nbytes; i++)
831     {
832       c = iobuf_get (inp);
833       if (c < 0)
834         return gpg_error (GPG_ERR_INV_PACKET);
835       ++*r_nread;
836       buffer[1+i] = c;
837     }
838
839   tmpbuf = xtrymalloc (1 + nbytes);
840   if (!tmpbuf)
841     return gpg_error_from_syserror ();
842   memcpy (tmpbuf, buffer, 1 + nbytes);
843   *r_data = gcry_mpi_set_opaque (NULL, tmpbuf, 8 * (1 + nbytes));
844   if (!*r_data)
845     {
846       xfree (tmpbuf);
847       return gpg_error_from_syserror ();
848     }
849   return 0;
850 }
851
852
853 /* Parse a marker packet.  */
854 static int
855 parse_marker (IOBUF inp, int pkttype, unsigned long pktlen)
856 {
857   (void) pkttype;
858
859   if (pktlen != 3)
860     goto fail;
861
862   if (iobuf_get (inp) != 'P')
863     {
864       pktlen--;
865       goto fail;
866     }
867
868   if (iobuf_get (inp) != 'G')
869     {
870       pktlen--;
871       goto fail;
872     }
873
874   if (iobuf_get (inp) != 'P')
875     {
876       pktlen--;
877       goto fail;
878     }
879
880   if (list_mode)
881     es_fputs (":marker packet: PGP\n", listfp);
882
883   return 0;
884
885  fail:
886   log_error ("invalid marker packet\n");
887   if (list_mode)
888     es_fputs (":marker packet: [invalid]\n", listfp);
889   iobuf_skip_rest (inp, pktlen, 0);
890   return GPG_ERR_INV_PACKET;
891 }
892
893
894 static int
895 parse_symkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
896                  PACKET * packet)
897 {
898   PKT_symkey_enc *k;
899   int rc = 0;
900   int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
901
902   if (pktlen < 4)
903     {
904       log_error ("packet(%d) too short\n", pkttype);
905       if (list_mode)
906         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
907       rc = gpg_error (GPG_ERR_INV_PACKET);
908       goto leave;
909     }
910   version = iobuf_get_noeof (inp);
911   pktlen--;
912   if (version != 4)
913     {
914       log_error ("packet(%d) with unknown version %d\n", pkttype, version);
915       if (list_mode)
916         es_fprintf (listfp, ":symkey enc packet: [unknown version]\n");
917       rc = gpg_error (GPG_ERR_INV_PACKET);
918       goto leave;
919     }
920   if (pktlen > 200)
921     {                           /* (we encode the seskeylen in a byte) */
922       log_error ("packet(%d) too large\n", pkttype);
923       if (list_mode)
924         es_fprintf (listfp, ":symkey enc packet: [too large]\n");
925       rc = gpg_error (GPG_ERR_INV_PACKET);
926       goto leave;
927     }
928   cipher_algo = iobuf_get_noeof (inp);
929   pktlen--;
930   s2kmode = iobuf_get_noeof (inp);
931   pktlen--;
932   hash_algo = iobuf_get_noeof (inp);
933   pktlen--;
934   switch (s2kmode)
935     {
936     case 0: /* Simple S2K.  */
937       minlen = 0;
938       break;
939     case 1: /* Salted S2K.  */
940       minlen = 8;
941       break;
942     case 3: /* Iterated+salted S2K.  */
943       minlen = 9;
944       break;
945     default:
946       log_error ("unknown S2K mode %d\n", s2kmode);
947       if (list_mode)
948         es_fprintf (listfp, ":symkey enc packet: [unknown S2K mode]\n");
949       goto leave;
950     }
951   if (minlen > pktlen)
952     {
953       log_error ("packet with S2K %d too short\n", s2kmode);
954       if (list_mode)
955         es_fprintf (listfp, ":symkey enc packet: [too short]\n");
956       rc = gpg_error (GPG_ERR_INV_PACKET);
957       goto leave;
958     }
959   seskeylen = pktlen - minlen;
960   k = packet->pkt.symkey_enc = xmalloc_clear (sizeof *packet->pkt.symkey_enc
961                                               + seskeylen - 1);
962   k->version = version;
963   k->cipher_algo = cipher_algo;
964   k->s2k.mode = s2kmode;
965   k->s2k.hash_algo = hash_algo;
966   if (s2kmode == 1 || s2kmode == 3)
967     {
968       for (i = 0; i < 8 && pktlen; i++, pktlen--)
969         k->s2k.salt[i] = iobuf_get_noeof (inp);
970     }
971   if (s2kmode == 3)
972     {
973       k->s2k.count = iobuf_get (inp);
974       pktlen--;
975     }
976   k->seskeylen = seskeylen;
977   if (k->seskeylen)
978     {
979       for (i = 0; i < seskeylen && pktlen; i++, pktlen--)
980         k->seskey[i] = iobuf_get_noeof (inp);
981
982       /* What we're watching out for here is a session key decryptor
983          with no salt.  The RFC says that using salt for this is a
984          MUST. */
985       if (s2kmode != 1 && s2kmode != 3)
986         log_info (_("WARNING: potentially insecure symmetrically"
987                     " encrypted session key\n"));
988     }
989   assert (!pktlen);
990
991   if (list_mode)
992     {
993       es_fprintf (listfp,
994                   ":symkey enc packet: version %d, cipher %d, s2k %d, hash %d",
995                   version, cipher_algo, s2kmode, hash_algo);
996       if (seskeylen)
997         es_fprintf (listfp, ", seskey %d bits", (seskeylen - 1) * 8);
998       es_fprintf (listfp, "\n");
999       if (s2kmode == 1 || s2kmode == 3)
1000         {
1001           es_fprintf (listfp, "\tsalt ");
1002           es_write_hexstring (listfp, k->s2k.salt, 8, 0, NULL);
1003           if (s2kmode == 3)
1004             es_fprintf (listfp, ", count %lu (%lu)",
1005                         S2K_DECODE_COUNT ((ulong) k->s2k.count),
1006                         (ulong) k->s2k.count);
1007           es_fprintf (listfp, "\n");
1008         }
1009     }
1010
1011  leave:
1012   iobuf_skip_rest (inp, pktlen, 0);
1013   return rc;
1014 }
1015
1016
1017 static int
1018 parse_pubkeyenc (IOBUF inp, int pkttype, unsigned long pktlen,
1019                  PACKET * packet)
1020 {
1021   int rc = 0;
1022   int i, ndata;
1023   PKT_pubkey_enc *k;
1024
1025   k = packet->pkt.pubkey_enc = xmalloc_clear (sizeof *packet->pkt.pubkey_enc);
1026   if (pktlen < 12)
1027     {
1028       log_error ("packet(%d) too short\n", pkttype);
1029       if (list_mode)
1030         es_fputs (":pubkey enc packet: [too short]\n", listfp);
1031       rc = gpg_error (GPG_ERR_INV_PACKET);
1032       goto leave;
1033     }
1034   k->version = iobuf_get_noeof (inp);
1035   pktlen--;
1036   if (k->version != 2 && k->version != 3)
1037     {
1038       log_error ("packet(%d) with unknown version %d\n", pkttype, k->version);
1039       if (list_mode)
1040         es_fputs (":pubkey enc packet: [unknown version]\n", listfp);
1041       rc = gpg_error (GPG_ERR_INV_PACKET);
1042       goto leave;
1043     }
1044   k->keyid[0] = read_32 (inp);
1045   pktlen -= 4;
1046   k->keyid[1] = read_32 (inp);
1047   pktlen -= 4;
1048   k->pubkey_algo = iobuf_get_noeof (inp);
1049   pktlen--;
1050   k->throw_keyid = 0;  /* Only used as flag for build_packet.  */
1051   if (list_mode)
1052     es_fprintf (listfp,
1053                 ":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
1054                 k->version, k->pubkey_algo, (ulong) k->keyid[0],
1055                 (ulong) k->keyid[1]);
1056
1057   ndata = pubkey_get_nenc (k->pubkey_algo);
1058   if (!ndata)
1059     {
1060       if (list_mode)
1061         es_fprintf (listfp, "\tunsupported algorithm %d\n", k->pubkey_algo);
1062       unknown_pubkey_warning (k->pubkey_algo);
1063       k->data[0] = NULL; /* No need to store the encrypted data.  */
1064     }
1065   else
1066     {
1067       for (i = 0; i < ndata; i++)
1068         {
1069           if (k->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
1070             {
1071               size_t n;
1072               rc = read_size_body (inp, pktlen, &n, k->data+i);
1073               pktlen -= n;
1074             }
1075           else
1076             {
1077               int n = pktlen;
1078               k->data[i] = mpi_read (inp, &n, 0);
1079               pktlen -= n;
1080               if (!k->data[i])
1081                 rc = gpg_error (GPG_ERR_INV_PACKET);
1082             }
1083           if (rc)
1084             goto leave;
1085           if (list_mode)
1086             {
1087               es_fprintf (listfp, "\tdata: ");
1088               mpi_print (listfp, k->data[i], mpi_print_mode);
1089               es_putc ('\n', listfp);
1090             }
1091         }
1092     }
1093
1094  leave:
1095   iobuf_skip_rest (inp, pktlen, 0);
1096   return rc;
1097 }
1098
1099
1100 static void
1101 dump_sig_subpkt (int hashed, int type, int critical,
1102                  const byte * buffer, size_t buflen, size_t length)
1103 {
1104   const char *p = NULL;
1105   int i;
1106
1107   /* The CERT has warning out with explains how to use GNUPG to detect
1108    * the ARRs - we print our old message here when it is a faked ARR
1109    * and add an additional notice.  */
1110   if (type == SIGSUBPKT_ARR && !hashed)
1111     {
1112       es_fprintf (listfp,
1113                   "\tsubpkt %d len %u (additional recipient request)\n"
1114                   "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
1115                   "encrypt to this key and thereby reveal the plaintext to "
1116                   "the owner of this ARR key. Detailed info follows:\n",
1117                   type, (unsigned) length);
1118     }
1119
1120   buffer++;
1121   length--;
1122
1123   es_fprintf (listfp, "\t%s%ssubpkt %d len %u (",       /*) */
1124               critical ? "critical " : "",
1125               hashed ? "hashed " : "", type, (unsigned) length);
1126   if (length > buflen)
1127     {
1128       es_fprintf (listfp, "too short: buffer is only %u)\n", (unsigned) buflen);
1129       return;
1130     }
1131   switch (type)
1132     {
1133     case SIGSUBPKT_SIG_CREATED:
1134       if (length >= 4)
1135         es_fprintf (listfp, "sig created %s",
1136                     strtimestamp (buf32_to_u32 (buffer)));
1137       break;
1138     case SIGSUBPKT_SIG_EXPIRE:
1139       if (length >= 4)
1140         {
1141           if (buf32_to_u32 (buffer))
1142             es_fprintf (listfp, "sig expires after %s",
1143                         strtimevalue (buf32_to_u32 (buffer)));
1144           else
1145             es_fprintf (listfp, "sig does not expire");
1146         }
1147       break;
1148     case SIGSUBPKT_EXPORTABLE:
1149       if (length)
1150         es_fprintf (listfp, "%sexportable", *buffer ? "" : "not ");
1151       break;
1152     case SIGSUBPKT_TRUST:
1153       if (length != 2)
1154         p = "[invalid trust subpacket]";
1155       else
1156         es_fprintf (listfp, "trust signature of depth %d, value %d", buffer[0],
1157                     buffer[1]);
1158       break;
1159     case SIGSUBPKT_REGEXP:
1160       if (!length)
1161         p = "[invalid regexp subpacket]";
1162       else
1163         {
1164           es_fprintf (listfp, "regular expression: \"");
1165           es_write_sanitized (listfp, buffer, length, "\"", NULL);
1166           p = "\"";
1167         }
1168       break;
1169     case SIGSUBPKT_REVOCABLE:
1170       if (length)
1171         es_fprintf (listfp, "%srevocable", *buffer ? "" : "not ");
1172       break;
1173     case SIGSUBPKT_KEY_EXPIRE:
1174       if (length >= 4)
1175         {
1176           if (buf32_to_u32 (buffer))
1177             es_fprintf (listfp, "key expires after %s",
1178                         strtimevalue (buf32_to_u32 (buffer)));
1179           else
1180             es_fprintf (listfp, "key does not expire");
1181         }
1182       break;
1183     case SIGSUBPKT_PREF_SYM:
1184       es_fputs ("pref-sym-algos:", listfp);
1185       for (i = 0; i < length; i++)
1186         es_fprintf (listfp, " %d", buffer[i]);
1187       break;
1188     case SIGSUBPKT_REV_KEY:
1189       es_fputs ("revocation key: ", listfp);
1190       if (length < 22)
1191         p = "[too short]";
1192       else
1193         {
1194           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1195           for (i = 2; i < length; i++)
1196             es_fprintf (listfp, "%02X", buffer[i]);
1197         }
1198       break;
1199     case SIGSUBPKT_ISSUER:
1200       if (length >= 8)
1201         es_fprintf (listfp, "issuer key ID %08lX%08lX",
1202                     (ulong) buf32_to_u32 (buffer),
1203                     (ulong) buf32_to_u32 (buffer + 4));
1204       break;
1205     case SIGSUBPKT_NOTATION:
1206       {
1207         es_fputs ("notation: ", listfp);
1208         if (length < 8)
1209           p = "[too short]";
1210         else
1211           {
1212             const byte *s = buffer;
1213             size_t n1, n2;
1214
1215             n1 = (s[4] << 8) | s[5];
1216             n2 = (s[6] << 8) | s[7];
1217             s += 8;
1218             if (8 + n1 + n2 != length)
1219               p = "[error]";
1220             else
1221               {
1222                 es_write_sanitized (listfp, s, n1, ")", NULL);
1223                 es_putc ('=', listfp);
1224
1225                 if (*buffer & 0x80)
1226                   es_write_sanitized (listfp, s + n1, n2, ")", NULL);
1227                 else
1228                   p = "[not human readable]";
1229               }
1230           }
1231       }
1232       break;
1233     case SIGSUBPKT_PREF_HASH:
1234       es_fputs ("pref-hash-algos:", listfp);
1235       for (i = 0; i < length; i++)
1236         es_fprintf (listfp, " %d", buffer[i]);
1237       break;
1238     case SIGSUBPKT_PREF_COMPR:
1239       es_fputs ("pref-zip-algos:", listfp);
1240       for (i = 0; i < length; i++)
1241         es_fprintf (listfp, " %d", buffer[i]);
1242       break;
1243     case SIGSUBPKT_KS_FLAGS:
1244       es_fputs ("key server preferences:", listfp);
1245       for (i = 0; i < length; i++)
1246         es_fprintf (listfp, " %02X", buffer[i]);
1247       break;
1248     case SIGSUBPKT_PREF_KS:
1249       es_fputs ("preferred key server: ", listfp);
1250       es_write_sanitized (listfp, buffer, length, ")", NULL);
1251       break;
1252     case SIGSUBPKT_PRIMARY_UID:
1253       p = "primary user ID";
1254       break;
1255     case SIGSUBPKT_POLICY:
1256       es_fputs ("policy: ", listfp);
1257       es_write_sanitized (listfp, buffer, length, ")", NULL);
1258       break;
1259     case SIGSUBPKT_KEY_FLAGS:
1260       es_fputs ("key flags:", listfp);
1261       for (i = 0; i < length; i++)
1262         es_fprintf (listfp, " %02X", buffer[i]);
1263       break;
1264     case SIGSUBPKT_SIGNERS_UID:
1265       p = "signer's user ID";
1266       break;
1267     case SIGSUBPKT_REVOC_REASON:
1268       if (length)
1269         {
1270           es_fprintf (listfp, "revocation reason 0x%02x (", *buffer);
1271           es_write_sanitized (listfp, buffer + 1, length - 1, ")", NULL);
1272           p = ")";
1273         }
1274       break;
1275     case SIGSUBPKT_ARR:
1276       es_fputs ("Big Brother's key (ignored): ", listfp);
1277       if (length < 22)
1278         p = "[too short]";
1279       else
1280         {
1281           es_fprintf (listfp, "c=%02x a=%d f=", buffer[0], buffer[1]);
1282           if (length > 2)
1283             es_write_hexstring (listfp, buffer+2, length-2, 0, NULL);
1284         }
1285       break;
1286     case SIGSUBPKT_FEATURES:
1287       es_fputs ("features:", listfp);
1288       for (i = 0; i < length; i++)
1289         es_fprintf (listfp, " %02x", buffer[i]);
1290       break;
1291     case SIGSUBPKT_SIGNATURE:
1292       es_fputs ("signature: ", listfp);
1293       if (length < 17)
1294         p = "[too short]";
1295       else
1296         es_fprintf (listfp, "v%d, class 0x%02X, algo %d, digest algo %d",
1297                     buffer[0],
1298                     buffer[0] == 3 ? buffer[2] : buffer[1],
1299                     buffer[0] == 3 ? buffer[15] : buffer[2],
1300                     buffer[0] == 3 ? buffer[16] : buffer[3]);
1301       break;
1302     default:
1303       if (type >= 100 && type <= 110)
1304         p = "experimental / private subpacket";
1305       else
1306         p = "?";
1307       break;
1308     }
1309
1310   es_fprintf (listfp, "%s)\n", p ? p : "");
1311 }
1312
1313
1314 /*
1315  * Returns: >= 0 use this offset into buffer
1316  *          -1 explicitly reject returning this type
1317  *          -2 subpacket too short
1318  */
1319 int
1320 parse_one_sig_subpkt (const byte * buffer, size_t n, int type)
1321 {
1322   switch (type)
1323     {
1324     case SIGSUBPKT_REV_KEY:
1325       if (n < 22)
1326         break;
1327       return 0;
1328     case SIGSUBPKT_SIG_CREATED:
1329     case SIGSUBPKT_SIG_EXPIRE:
1330     case SIGSUBPKT_KEY_EXPIRE:
1331       if (n < 4)
1332         break;
1333       return 0;
1334     case SIGSUBPKT_KEY_FLAGS:
1335     case SIGSUBPKT_KS_FLAGS:
1336     case SIGSUBPKT_PREF_SYM:
1337     case SIGSUBPKT_PREF_HASH:
1338     case SIGSUBPKT_PREF_COMPR:
1339     case SIGSUBPKT_POLICY:
1340     case SIGSUBPKT_PREF_KS:
1341     case SIGSUBPKT_FEATURES:
1342     case SIGSUBPKT_REGEXP:
1343       return 0;
1344     case SIGSUBPKT_SIGNATURE:
1345     case SIGSUBPKT_EXPORTABLE:
1346     case SIGSUBPKT_REVOCABLE:
1347     case SIGSUBPKT_REVOC_REASON:
1348       if (!n)
1349         break;
1350       return 0;
1351     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1352       if (n < 8)
1353         break;
1354       return 0;
1355     case SIGSUBPKT_NOTATION:
1356       /* minimum length needed, and the subpacket must be well-formed
1357          where the name length and value length all fit inside the
1358          packet. */
1359       if (n < 8
1360           || 8 + ((buffer[4] << 8) | buffer[5]) +
1361           ((buffer[6] << 8) | buffer[7]) != n)
1362         break;
1363       return 0;
1364     case SIGSUBPKT_PRIMARY_UID:
1365       if (n != 1)
1366         break;
1367       return 0;
1368     case SIGSUBPKT_TRUST:
1369       if (n != 2)
1370         break;
1371       return 0;
1372     default:
1373       return 0;
1374     }
1375   return -2;
1376 }
1377
1378
1379 /* Return true if we understand the critical notation.  */
1380 static int
1381 can_handle_critical_notation (const byte * name, size_t len)
1382 {
1383   if (len == 32 && memcmp (name, "preferred-email-encoding@pgp.com", 32) == 0)
1384     return 1;
1385   if (len == 21 && memcmp (name, "pka-address@gnupg.org", 21) == 0)
1386     return 1;
1387
1388   return 0;
1389 }
1390
1391
1392 static int
1393 can_handle_critical (const byte * buffer, size_t n, int type)
1394 {
1395   switch (type)
1396     {
1397     case SIGSUBPKT_NOTATION:
1398       if (n >= 8)
1399         {
1400           size_t notation_len = ((buffer[4] << 8) | buffer[5]);
1401           if (n - 8 >= notation_len)
1402             return can_handle_critical_notation (buffer + 8, notation_len);
1403         }
1404       return 0;
1405     case SIGSUBPKT_SIGNATURE:
1406     case SIGSUBPKT_SIG_CREATED:
1407     case SIGSUBPKT_SIG_EXPIRE:
1408     case SIGSUBPKT_KEY_EXPIRE:
1409     case SIGSUBPKT_EXPORTABLE:
1410     case SIGSUBPKT_REVOCABLE:
1411     case SIGSUBPKT_REV_KEY:
1412     case SIGSUBPKT_ISSUER:      /* issuer key ID */
1413     case SIGSUBPKT_PREF_SYM:
1414     case SIGSUBPKT_PREF_HASH:
1415     case SIGSUBPKT_PREF_COMPR:
1416     case SIGSUBPKT_KEY_FLAGS:
1417     case SIGSUBPKT_PRIMARY_UID:
1418     case SIGSUBPKT_FEATURES:
1419     case SIGSUBPKT_TRUST:
1420     case SIGSUBPKT_REGEXP:
1421       /* Is it enough to show the policy or keyserver? */
1422     case SIGSUBPKT_POLICY:
1423     case SIGSUBPKT_PREF_KS:
1424       return 1;
1425
1426     default:
1427       return 0;
1428     }
1429 }
1430
1431
1432 const byte *
1433 enum_sig_subpkt (const subpktarea_t * pktbuf, sigsubpkttype_t reqtype,
1434                  size_t * ret_n, int *start, int *critical)
1435 {
1436   const byte *buffer;
1437   int buflen;
1438   int type;
1439   int critical_dummy;
1440   int offset;
1441   size_t n;
1442   int seq = 0;
1443   int reqseq = start ? *start : 0;
1444
1445   if (!critical)
1446     critical = &critical_dummy;
1447
1448   if (!pktbuf || reqseq == -1)
1449     {
1450       static char dummy[] = "x";
1451       /* Return a value different from NULL to indicate that
1452        * there is no critical bit we do not understand.  */
1453       return reqtype == SIGSUBPKT_TEST_CRITICAL ? dummy : NULL;
1454     }
1455   buffer = pktbuf->data;
1456   buflen = pktbuf->len;
1457   while (buflen)
1458     {
1459       n = *buffer++;
1460       buflen--;
1461       if (n == 255) /* 4 byte length header.  */
1462         {
1463           if (buflen < 4)
1464             goto too_short;
1465           n = buf32_to_size_t (buffer);
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 = buf32_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] = buf32_to_u32 (p);
1747           sig->keyid[1] = buf32_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 && buf32_to_u32 (p))
1755         sig->expiredate = sig->timestamp + buf32_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 = buf32_to_size_t (buffer);
2369           buffer += 4;
2370           buflen -= 4;
2371         }
2372       else if (n >= 192)  /* 2 byte special encoded length header.  */
2373         {
2374           if (buflen < 2)
2375             goto too_short;
2376           n = ((n - 192) << 8) + *buffer + 192;
2377           buffer++;
2378           buflen--;
2379         }
2380       if (buflen < n)
2381         goto too_short;
2382
2383       if (!n)
2384         {
2385           /* Too short to encode the subpacket type.  */
2386           if (opt.verbose)
2387             log_info ("attribute subpacket too short\n");
2388           break;
2389         }
2390
2391       attribs = xrealloc (attribs,
2392                           (count + 1) * sizeof (struct user_attribute));
2393       memset (&attribs[count], 0, sizeof (struct user_attribute));
2394
2395       type = *buffer;
2396       buffer++;
2397       buflen--;
2398       n--;
2399
2400       attribs[count].type = type;
2401       attribs[count].data = buffer;
2402       attribs[count].len = n;
2403       buffer += n;
2404       buflen -= n;
2405       count++;
2406     }
2407
2408   uid->attribs = attribs;
2409   uid->numattribs = count;
2410   return count;
2411
2412  too_short:
2413   if (opt.verbose)
2414     log_info ("buffer shorter than attribute subpacket\n");
2415   uid->attribs = attribs;
2416   uid->numattribs = count;
2417   return count;
2418 }
2419
2420
2421 static int
2422 parse_user_id (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2423 {
2424   byte *p;
2425
2426   /* Cap the size of a user ID at 2k: a value absurdly large enough
2427      that there is no sane user ID string (which is printable text
2428      as of RFC2440bis) that won't fit in it, but yet small enough to
2429      avoid allocation problems.  A large pktlen may not be
2430      allocatable, and a very large pktlen could actually cause our
2431      allocation to wrap around in xmalloc to a small number. */
2432
2433   if (pktlen > MAX_UID_PACKET_LENGTH)
2434     {
2435       log_error ("packet(%d) too large\n", pkttype);
2436       if (list_mode)
2437         es_fprintf (listfp, ":user ID packet: [too large]\n");
2438       iobuf_skip_rest (inp, pktlen, 0);
2439       return GPG_ERR_INV_PACKET;
2440     }
2441
2442   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id + pktlen);
2443   packet->pkt.user_id->len = pktlen;
2444   packet->pkt.user_id->ref = 1;
2445
2446   p = packet->pkt.user_id->name;
2447   for (; pktlen; pktlen--, p++)
2448     *p = iobuf_get_noeof (inp);
2449   *p = 0;
2450
2451   if (list_mode)
2452     {
2453       int n = packet->pkt.user_id->len;
2454       es_fprintf (listfp, ":user ID packet: \"");
2455       /* fixme: Hey why don't we replace this with es_write_sanitized?? */
2456       for (p = packet->pkt.user_id->name; n; p++, n--)
2457         {
2458           if (*p >= ' ' && *p <= 'z')
2459             es_putc (*p, listfp);
2460           else
2461             es_fprintf (listfp, "\\x%02x", *p);
2462         }
2463       es_fprintf (listfp, "\"\n");
2464     }
2465   return 0;
2466 }
2467
2468
2469 void
2470 make_attribute_uidname (PKT_user_id * uid, size_t max_namelen)
2471 {
2472   assert (max_namelen > 70);
2473   if (uid->numattribs <= 0)
2474     sprintf (uid->name, "[bad attribute packet of size %lu]",
2475              uid->attrib_len);
2476   else if (uid->numattribs > 1)
2477     sprintf (uid->name, "[%d attributes of size %lu]",
2478              uid->numattribs, uid->attrib_len);
2479   else
2480     {
2481       /* Only one attribute, so list it as the "user id" */
2482
2483       if (uid->attribs->type == ATTRIB_IMAGE)
2484         {
2485           u32 len;
2486           byte type;
2487
2488           if (parse_image_header (uid->attribs, &type, &len))
2489             sprintf (uid->name, "[%.20s image of size %lu]",
2490                      image_type_to_string (type, 1), (ulong) len);
2491           else
2492             sprintf (uid->name, "[invalid image]");
2493         }
2494       else
2495         sprintf (uid->name, "[unknown attribute of size %lu]",
2496                  (ulong) uid->attribs->len);
2497     }
2498
2499   uid->len = strlen (uid->name);
2500 }
2501
2502
2503 static int
2504 parse_attribute (IOBUF inp, int pkttype, unsigned long pktlen,
2505                  PACKET * packet)
2506 {
2507   byte *p;
2508
2509   (void) pkttype;
2510
2511   /* We better cap the size of an attribute packet to make DoS not too
2512      easy.  16MB should be more then enough for one attribute packet
2513      (ie. a photo).  */
2514   if (pktlen > MAX_ATTR_PACKET_LENGTH)
2515     {
2516       log_error ("packet(%d) too large\n", pkttype);
2517       if (list_mode)
2518         es_fprintf (listfp, ":attribute packet: [too large]\n");
2519       iobuf_skip_rest (inp, pktlen, 0);
2520       return GPG_ERR_INV_PACKET;
2521     }
2522
2523 #define EXTRA_UID_NAME_SPACE 71
2524   packet->pkt.user_id = xmalloc_clear (sizeof *packet->pkt.user_id
2525                                        + EXTRA_UID_NAME_SPACE);
2526   packet->pkt.user_id->ref = 1;
2527   packet->pkt.user_id->attrib_data = xmalloc (pktlen? pktlen:1);
2528   packet->pkt.user_id->attrib_len = pktlen;
2529
2530   p = packet->pkt.user_id->attrib_data;
2531   for (; pktlen; pktlen--, p++)
2532     *p = iobuf_get_noeof (inp);
2533
2534   /* Now parse out the individual attribute subpackets.  This is
2535      somewhat pointless since there is only one currently defined
2536      attribute type (jpeg), but it is correct by the spec. */
2537   parse_attribute_subpkts (packet->pkt.user_id);
2538
2539   make_attribute_uidname (packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2540
2541   if (list_mode)
2542     {
2543       es_fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name);
2544     }
2545   return 0;
2546 }
2547
2548
2549 static int
2550 parse_comment (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * packet)
2551 {
2552   byte *p;
2553
2554   /* Cap comment packet at a reasonable value to avoid an integer
2555      overflow in the malloc below.  Comment packets are actually not
2556      anymore define my OpenPGP and we even stopped to use our
2557      private comment packet.  */
2558   if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2559     {
2560       log_error ("packet(%d) too large\n", pkttype);
2561       if (list_mode)
2562         es_fprintf (listfp, ":%scomment packet: [too large]\n",
2563                     pkttype == PKT_OLD_COMMENT ? "OpenPGP draft " : "");
2564       iobuf_skip_rest (inp, pktlen, 0);
2565       return GPG_ERR_INV_PACKET;
2566     }
2567   packet->pkt.comment = xmalloc (sizeof *packet->pkt.comment + pktlen - 1);
2568   packet->pkt.comment->len = pktlen;
2569   p = packet->pkt.comment->data;
2570   for (; pktlen; pktlen--, p++)
2571     *p = iobuf_get_noeof (inp);
2572
2573   if (list_mode)
2574     {
2575       int n = packet->pkt.comment->len;
2576       es_fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT ?
2577                   "OpenPGP draft " : "");
2578       for (p = packet->pkt.comment->data; n; p++, n--)
2579         {
2580           if (*p >= ' ' && *p <= 'z')
2581             es_putc (*p, listfp);
2582           else
2583             es_fprintf (listfp, "\\x%02x", *p);
2584         }
2585       es_fprintf (listfp, "\"\n");
2586     }
2587   return 0;
2588 }
2589
2590
2591 static void
2592 parse_trust (IOBUF inp, int pkttype, unsigned long pktlen, PACKET * pkt)
2593 {
2594   int c;
2595
2596   (void) pkttype;
2597
2598   pkt->pkt.ring_trust = xmalloc (sizeof *pkt->pkt.ring_trust);
2599   if (pktlen)
2600     {
2601       c = iobuf_get_noeof (inp);
2602       pktlen--;
2603       pkt->pkt.ring_trust->trustval = c;
2604       pkt->pkt.ring_trust->sigcache = 0;
2605       if (!c && pktlen == 1)
2606         {
2607           c = iobuf_get_noeof (inp);
2608           pktlen--;
2609           /* We require that bit 7 of the sigcache is 0 (easier eof
2610              handling).  */
2611           if (!(c & 0x80))
2612             pkt->pkt.ring_trust->sigcache = c;
2613         }
2614       if (list_mode)
2615         es_fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2616                     pkt->pkt.ring_trust->trustval,
2617                     pkt->pkt.ring_trust->sigcache);
2618     }
2619   else
2620     {
2621       pkt->pkt.ring_trust->trustval = 0;
2622       pkt->pkt.ring_trust->sigcache = 0;
2623       if (list_mode)
2624         es_fprintf (listfp, ":trust packet: empty\n");
2625     }
2626   iobuf_skip_rest (inp, pktlen, 0);
2627 }
2628
2629
2630 static int
2631 parse_plaintext (IOBUF inp, int pkttype, unsigned long pktlen,
2632                  PACKET * pkt, int new_ctb, int partial)
2633 {
2634   int rc = 0;
2635   int mode, namelen;
2636   PKT_plaintext *pt;
2637   byte *p;
2638   int c, i;
2639
2640   if (!partial && pktlen < 6)
2641     {
2642       log_error ("packet(%d) too short (%lu)\n", pkttype, (ulong) pktlen);
2643       if (list_mode)
2644         es_fputs (":literal data packet: [too short]\n", listfp);
2645       rc = gpg_error (GPG_ERR_INV_PACKET);
2646       goto leave;
2647     }
2648   mode = iobuf_get_noeof (inp);
2649   if (pktlen)
2650     pktlen--;
2651   namelen = iobuf_get_noeof (inp);
2652   if (pktlen)
2653     pktlen--;
2654   /* Note that namelen will never exceed 255 bytes. */
2655   pt = pkt->pkt.plaintext =
2656     xmalloc (sizeof *pkt->pkt.plaintext + namelen - 1);
2657   pt->new_ctb = new_ctb;
2658   pt->mode = mode;
2659   pt->namelen = namelen;
2660   pt->is_partial = partial;
2661   if (pktlen)
2662     {
2663       for (i = 0; pktlen > 4 && i < namelen; pktlen--, i++)
2664         pt->name[i] = iobuf_get_noeof (inp);
2665     }
2666   else
2667     {
2668       for (i = 0; i < namelen; i++)
2669         if ((c = iobuf_get (inp)) == -1)
2670           break;
2671         else
2672           pt->name[i] = c;
2673     }
2674   pt->timestamp = read_32 (inp);
2675   if (pktlen)
2676     pktlen -= 4;
2677   pt->len = pktlen;
2678   pt->buf = inp;
2679   pktlen = 0;
2680
2681   if (list_mode)
2682     {
2683       es_fprintf (listfp, ":literal data packet:\n"
2684                   "\tmode %c (%X), created %lu, name=\"",
2685                   mode >= ' ' && mode < 'z' ? mode : '?', mode,
2686                   (ulong) pt->timestamp);
2687       for (p = pt->name, i = 0; i < namelen; p++, i++)
2688         {
2689           if (*p >= ' ' && *p <= 'z')
2690             es_putc (*p, listfp);
2691           else
2692             es_fprintf (listfp, "\\x%02x", *p);
2693         }
2694       es_fprintf (listfp, "\",\n\traw data: ");
2695       if (partial)
2696         es_fprintf (listfp, "unknown length\n");
2697       else
2698         es_fprintf (listfp, "%lu bytes\n", (ulong) pt->len);
2699     }
2700
2701  leave:
2702   return rc;
2703 }
2704
2705
2706 static int
2707 parse_compressed (IOBUF inp, int pkttype, unsigned long pktlen,
2708                   PACKET * pkt, int new_ctb)
2709 {
2710   PKT_compressed *zd;
2711
2712   /* PKTLEN is here 0, but data follows (this should be the last
2713      object in a file or the compress algorithm should know the
2714      length).  */
2715   (void) pkttype;
2716   (void) pktlen;
2717
2718   zd = pkt->pkt.compressed = xmalloc (sizeof *pkt->pkt.compressed);
2719   zd->algorithm = iobuf_get_noeof (inp);
2720   zd->len = 0;                  /* not used */
2721   zd->new_ctb = new_ctb;
2722   zd->buf = inp;
2723   if (list_mode)
2724     es_fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2725   return 0;
2726 }
2727
2728
2729 static int
2730 parse_encrypted (IOBUF inp, int pkttype, unsigned long pktlen,
2731                  PACKET * pkt, int new_ctb, int partial)
2732 {
2733   int rc = 0;
2734   PKT_encrypted *ed;
2735   unsigned long orig_pktlen = pktlen;
2736
2737   ed = pkt->pkt.encrypted = xmalloc (sizeof *pkt->pkt.encrypted);
2738   /* ed->len is set below.  */
2739   ed->extralen = 0;  /* Unknown here; only used in build_packet.  */
2740   ed->buf = NULL;
2741   ed->new_ctb = new_ctb;
2742   ed->is_partial = partial;
2743   if (pkttype == PKT_ENCRYPTED_MDC)
2744     {
2745       /* Fixme: add some pktlen sanity checks.  */
2746       int version;
2747
2748       version = iobuf_get_noeof (inp);
2749       if (orig_pktlen)
2750         pktlen--;
2751       if (version != 1)
2752         {
2753           log_error ("encrypted_mdc packet with unknown version %d\n",
2754                      version);
2755           if (list_mode)
2756             es_fputs (":encrypted data packet: [unknown version]\n", listfp);
2757           /*skip_rest(inp, pktlen); should we really do this? */
2758           rc = gpg_error (GPG_ERR_INV_PACKET);
2759           goto leave;
2760         }
2761       ed->mdc_method = DIGEST_ALGO_SHA1;
2762     }
2763   else
2764     ed->mdc_method = 0;
2765
2766   /* A basic sanity check.  We need at least an 8 byte IV plus the 2
2767      detection bytes.  Note that we don't known the algorithm and thus
2768      we may only check against the minimum blocksize.  */
2769   if (orig_pktlen && pktlen < 10)
2770     {
2771       /* Actually this is blocksize+2.  */
2772       log_error ("packet(%d) too short\n", pkttype);
2773       if (list_mode)
2774         es_fputs (":encrypted data packet: [too short]\n", listfp);
2775       rc = GPG_ERR_INV_PACKET;
2776       iobuf_skip_rest (inp, pktlen, partial);
2777       goto leave;
2778     }
2779
2780   /* Store the remaining length of the encrypted data (i.e. without
2781      the MDC version number but with the IV etc.).  This value is
2782      required during decryption.  */
2783   ed->len = pktlen;
2784
2785   if (list_mode)
2786     {
2787       if (orig_pktlen)
2788         es_fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2789                     orig_pktlen);
2790       else
2791         es_fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2792       if (ed->mdc_method)
2793         es_fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method);
2794     }
2795
2796   ed->buf = inp;
2797
2798  leave:
2799   return rc;
2800 }
2801
2802
2803 /* Note, that this code is not anymore used in real life because the
2804    MDC checking is now done right after the decryption in
2805    decrypt_data.  */
2806 static int
2807 parse_mdc (IOBUF inp, int pkttype, unsigned long pktlen,
2808            PACKET * pkt, int new_ctb)
2809 {
2810   int rc = 0;
2811   PKT_mdc *mdc;
2812   byte *p;
2813
2814   (void) pkttype;
2815
2816   mdc = pkt->pkt.mdc = xmalloc (sizeof *pkt->pkt.mdc);
2817   if (list_mode)
2818     es_fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2819   if (!new_ctb || pktlen != 20)
2820     {
2821       log_error ("mdc_packet with invalid encoding\n");
2822       rc = gpg_error (GPG_ERR_INV_PACKET);
2823       goto leave;
2824     }
2825   p = mdc->hash;
2826   for (; pktlen; pktlen--, p++)
2827     *p = iobuf_get_noeof (inp);
2828
2829  leave:
2830   return rc;
2831 }
2832
2833
2834 /*
2835  * This packet is internally generated by us (ibn armor.c) to transfer
2836  * some information to the lower layer.  To make sure that this packet
2837  * is really a GPG faked one and not one comming from outside, we
2838  * first check that there is a unique tag in it.
2839  *
2840  * The format of such a control packet is:
2841  *   n byte  session marker
2842  *   1 byte  control type CTRLPKT_xxxxx
2843  *   m byte  control data
2844  */
2845 static int
2846 parse_gpg_control (IOBUF inp, int pkttype, unsigned long pktlen,
2847                    PACKET * packet, int partial)
2848 {
2849   byte *p;
2850   const byte *sesmark;
2851   size_t sesmarklen;
2852   int i;
2853
2854   (void) pkttype;
2855
2856   if (list_mode)
2857     es_fprintf (listfp, ":packet 63: length %lu ", pktlen);
2858
2859   sesmark = get_session_marker (&sesmarklen);
2860   if (pktlen < sesmarklen + 1)  /* 1 is for the control bytes */
2861     goto skipit;
2862   for (i = 0; i < sesmarklen; i++, pktlen--)
2863     {
2864       if (sesmark[i] != iobuf_get_noeof (inp))
2865         goto skipit;
2866     }
2867   if (pktlen > 4096)
2868     goto skipit;  /* Definitely too large.  We skip it to avoid an
2869                      overflow in the malloc.  */
2870   if (list_mode)
2871     puts ("- gpg control packet");
2872
2873   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2874                                      + pktlen - 1);
2875   packet->pkt.gpg_control->control = iobuf_get_noeof (inp);
2876   pktlen--;
2877   packet->pkt.gpg_control->datalen = pktlen;
2878   p = packet->pkt.gpg_control->data;
2879   for (; pktlen; pktlen--, p++)
2880     *p = iobuf_get_noeof (inp);
2881
2882   return 0;
2883
2884  skipit:
2885   if (list_mode)
2886     {
2887       int c;
2888
2889       i = 0;
2890       es_fprintf (listfp, "- private (rest length %lu)\n", pktlen);
2891       if (partial)
2892         {
2893           while ((c = iobuf_get (inp)) != -1)
2894             dump_hex_line (c, &i);
2895         }
2896       else
2897         {
2898           for (; pktlen; pktlen--)
2899             {
2900               dump_hex_line ((c = iobuf_get (inp)), &i);
2901               if (c == -1)
2902                 break;
2903             }
2904         }
2905       es_putc ('\n', listfp);
2906     }
2907   iobuf_skip_rest (inp, pktlen, 0);
2908   return gpg_error (GPG_ERR_INV_PACKET);
2909 }
2910
2911
2912 /* Create a GPG control packet to be used internally as a placeholder.  */
2913 PACKET *
2914 create_gpg_control (ctrlpkttype_t type, const byte * data, size_t datalen)
2915 {
2916   PACKET *packet;
2917   byte *p;
2918
2919   packet = xmalloc (sizeof *packet);
2920   init_packet (packet);
2921   packet->pkttype = PKT_GPG_CONTROL;
2922   packet->pkt.gpg_control = xmalloc (sizeof *packet->pkt.gpg_control
2923                                      + datalen - 1);
2924   packet->pkt.gpg_control->control = type;
2925   packet->pkt.gpg_control->datalen = datalen;
2926   p = packet->pkt.gpg_control->data;
2927   for (; datalen; datalen--, p++)
2928     *p = *data++;
2929
2930   return packet;
2931 }