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