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