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