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