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