01600e44ef28287313f33ecf815e9741947c8afa
[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         return can_handle_critical_notation(buffer+8,(buffer[4]<<8)|buffer[5]);
1128       else
1129         return 0;
1130     case SIGSUBPKT_SIGNATURE:
1131     case SIGSUBPKT_SIG_CREATED:
1132     case SIGSUBPKT_SIG_EXPIRE:
1133     case SIGSUBPKT_KEY_EXPIRE:
1134     case SIGSUBPKT_EXPORTABLE:
1135     case SIGSUBPKT_REVOCABLE:
1136     case SIGSUBPKT_REV_KEY:
1137     case SIGSUBPKT_ISSUER:/* issuer key ID */
1138     case SIGSUBPKT_PREF_SYM:
1139     case SIGSUBPKT_PREF_HASH:
1140     case SIGSUBPKT_PREF_COMPR:
1141     case SIGSUBPKT_KEY_FLAGS:
1142     case SIGSUBPKT_PRIMARY_UID:
1143     case SIGSUBPKT_FEATURES:
1144     case SIGSUBPKT_TRUST:
1145     case SIGSUBPKT_REGEXP:
1146       /* Is it enough to show the policy or keyserver? */
1147     case SIGSUBPKT_POLICY:
1148     case SIGSUBPKT_PREF_KS:
1149       return 1;
1150
1151     default:
1152       return 0;
1153     }
1154 }
1155
1156
1157 const byte *
1158 enum_sig_subpkt( const subpktarea_t *pktbuf, sigsubpkttype_t reqtype,
1159                  size_t *ret_n, int *start, int *critical )
1160 {
1161     const byte *buffer;
1162     int buflen;
1163     int type;
1164     int critical_dummy;
1165     int offset;
1166     size_t n;
1167     int seq = 0;
1168     int reqseq = start? *start: 0;
1169
1170     if(!critical)
1171       critical=&critical_dummy;
1172
1173     if( !pktbuf || reqseq == -1 ) {
1174         /* return some value different from NULL to indicate that
1175          * there is no critical bit we do not understand.  The caller
1176          * will never use the value.  Yes I know, it is an ugly hack */
1177         return reqtype == SIGSUBPKT_TEST_CRITICAL? (const byte*)&pktbuf : NULL;
1178     }
1179     buffer = pktbuf->data;
1180     buflen = pktbuf->len;
1181     while( buflen ) {
1182         n = *buffer++; buflen--;
1183         if( n == 255 ) { /* 4 byte length header */
1184             if( buflen < 4 )
1185                 goto too_short;
1186             n = (buffer[0] << 24) | (buffer[1] << 16)
1187                 | (buffer[2] << 8) | buffer[3];
1188             buffer += 4;
1189             buflen -= 4;
1190         }
1191         else if( n >= 192 ) { /* 2 byte special encoded length header */
1192             if( buflen < 2 )
1193                 goto too_short;
1194             n = (( n - 192 ) << 8) + *buffer + 192;
1195             buffer++;
1196             buflen--;
1197         }
1198         if( buflen < n )
1199             goto too_short;
1200         type = *buffer;
1201         if( type & 0x80 ) {
1202             type &= 0x7f;
1203             *critical = 1;
1204         }
1205         else
1206             *critical = 0;
1207         if( !(++seq > reqseq) )
1208             ;
1209         else if( reqtype == SIGSUBPKT_TEST_CRITICAL ) {
1210             if( *critical ) {
1211                 if( n-1 > buflen+1 )
1212                     goto too_short;
1213                 if( !can_handle_critical(buffer+1, n-1, type ) )
1214                   {
1215                     if(opt.verbose)
1216                       log_info(_("subpacket of type %d has "
1217                                  "critical bit set\n"),type);
1218                     if( start )
1219                       *start = seq;
1220                     return NULL; /* this is an error */
1221                   }
1222             }
1223         }
1224         else if( reqtype < 0 ) /* list packets */
1225             dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
1226                                     type, *critical, buffer, buflen, n );
1227         else if( type == reqtype ) { /* found */
1228             buffer++;
1229             n--;
1230             if( n > buflen )
1231                 goto too_short;
1232             if( ret_n )
1233                 *ret_n = n;
1234             offset = parse_one_sig_subpkt(buffer, n, type );
1235             switch( offset ) {
1236               case -2:
1237                 log_error("subpacket of type %d too short\n", type);
1238                 return NULL;
1239               case -1:
1240                 return NULL;
1241               default:
1242                 break;
1243             }
1244             if( start )
1245                 *start = seq;
1246             return buffer+offset;
1247         }
1248         buffer += n; buflen -=n;
1249     }
1250     if( reqtype == SIGSUBPKT_TEST_CRITICAL )
1251         return buffer; /* as value true to indicate that there is no */
1252                        /* critical bit we don't understand */
1253     if( start )
1254         *start = -1;
1255     return NULL; /* end of packets; not found */
1256
1257   too_short:
1258     if(opt.verbose)
1259       log_info("buffer shorter than subpacket\n");
1260     if( start )
1261         *start = -1;
1262     return NULL;
1263 }
1264
1265
1266 const byte *
1267 parse_sig_subpkt (const subpktarea_t *buffer, sigsubpkttype_t reqtype,
1268                   size_t *ret_n)
1269 {
1270     return enum_sig_subpkt( buffer, reqtype, ret_n, NULL, NULL );
1271 }
1272
1273 const byte *
1274 parse_sig_subpkt2 (PKT_signature *sig, sigsubpkttype_t reqtype,
1275                    size_t *ret_n )
1276 {
1277     const byte *p;
1278
1279     p = parse_sig_subpkt (sig->hashed, reqtype, ret_n );
1280     if( !p )
1281         p = parse_sig_subpkt (sig->unhashed, reqtype, ret_n );
1282     return p;
1283 }
1284
1285 /* Find all revocation keys. Look in hashed area only. */
1286 void parse_revkeys(PKT_signature *sig)
1287 {
1288   struct revocation_key *revkey;
1289   int seq=0;
1290   size_t len;
1291
1292   if(sig->sig_class!=0x1F)
1293     return;
1294
1295   while((revkey=
1296          (struct revocation_key *)enum_sig_subpkt(sig->hashed,
1297                                                   SIGSUBPKT_REV_KEY,
1298                                                   &len,&seq,NULL)))
1299     {
1300       if(len==sizeof(struct revocation_key) &&
1301          (revkey->class&0x80)) /* 0x80 bit must be set */
1302         {
1303           sig->revkey=xrealloc(sig->revkey,
1304                           sizeof(struct revocation_key *)*(sig->numrevkeys+1));
1305           sig->revkey[sig->numrevkeys]=revkey;
1306           sig->numrevkeys++;
1307         }
1308     }
1309 }
1310
1311 int
1312 parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
1313                                           PKT_signature *sig )
1314 {
1315     int md5_len=0;
1316     unsigned n;
1317     int is_v4=0;
1318     int rc=0;
1319     int i, ndata;
1320
1321     if( pktlen < 16 ) {
1322         log_error("packet(%d) too short\n", pkttype);
1323         goto leave;
1324     }
1325     sig->version = iobuf_get_noeof(inp); pktlen--;
1326     if( sig->version == 4 )
1327         is_v4=1;
1328     else if( sig->version != 2 && sig->version != 3 ) {
1329         log_error("packet(%d) with unknown version %d\n", pkttype, sig->version);
1330         rc = G10ERR_INVALID_PACKET;
1331         goto leave;
1332     }
1333
1334     if( !is_v4 ) {
1335         md5_len = iobuf_get_noeof(inp); pktlen--;
1336     }
1337     sig->sig_class = iobuf_get_noeof(inp); pktlen--;
1338     if( !is_v4 ) {
1339         sig->timestamp = read_32(inp); pktlen -= 4;
1340         sig->keyid[0] = read_32(inp); pktlen -= 4;
1341         sig->keyid[1] = read_32(inp); pktlen -= 4;
1342     }
1343     sig->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1344     sig->digest_algo = iobuf_get_noeof(inp); pktlen--;
1345     sig->flags.exportable=1;
1346     sig->flags.revocable=1;
1347     if( is_v4 ) { /* read subpackets */
1348         n = read_16(inp); pktlen -= 2; /* length of hashed data */
1349         if( n > 10000 ) {
1350             log_error("signature packet: hashed data too long\n");
1351             rc = G10ERR_INVALID_PACKET;
1352             goto leave;
1353         }
1354         if( n ) {
1355             sig->hashed = xmalloc (sizeof (*sig->hashed) + n - 1 );
1356             sig->hashed->size = n;
1357             sig->hashed->len = n;
1358             if( iobuf_read (inp, sig->hashed->data, n ) != n ) {
1359                 log_error ("premature eof while reading "
1360                            "hashed signature data\n");
1361                 rc = -1;
1362                 goto leave;
1363             }
1364             pktlen -= n;
1365         }
1366         n = read_16(inp); pktlen -= 2; /* length of unhashed data */
1367         if( n > 10000 ) {
1368             log_error("signature packet: unhashed data too long\n");
1369             rc = G10ERR_INVALID_PACKET;
1370             goto leave;
1371         }
1372         if( n ) {
1373             sig->unhashed = xmalloc (sizeof(*sig->unhashed) + n - 1 );
1374             sig->unhashed->size = n;
1375             sig->unhashed->len = n;
1376             if( iobuf_read(inp, sig->unhashed->data, n ) != n ) {
1377                 log_error("premature eof while reading "
1378                           "unhashed signature data\n");
1379                 rc = -1;
1380                 goto leave;
1381             }
1382             pktlen -= n;
1383         }
1384     }
1385
1386     if( pktlen < 5 ) { /* sanity check */
1387         log_error("packet(%d) too short\n", pkttype);
1388         rc = G10ERR_INVALID_PACKET;
1389         goto leave;
1390     }
1391
1392     sig->digest_start[0] = iobuf_get_noeof(inp); pktlen--;
1393     sig->digest_start[1] = iobuf_get_noeof(inp); pktlen--;
1394
1395     if( is_v4 && sig->pubkey_algo )
1396       { /*extract required information */
1397         const byte *p;
1398         size_t len;
1399
1400         /* set sig->flags.unknown_critical if there is a
1401          * critical bit set for packets which we do not understand */
1402         if( !parse_sig_subpkt (sig->hashed, SIGSUBPKT_TEST_CRITICAL, NULL)
1403             || !parse_sig_subpkt (sig->unhashed, SIGSUBPKT_TEST_CRITICAL,
1404                                   NULL) )
1405           sig->flags.unknown_critical = 1;
1406
1407         p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_CREATED, NULL );
1408         if(p)
1409           sig->timestamp = buffer_to_u32(p);
1410         else if(!(sig->pubkey_algo>=100 && sig->pubkey_algo<=110)
1411                 && opt.verbose)
1412           log_info ("signature packet without timestamp\n");
1413
1414         p = parse_sig_subpkt2( sig, SIGSUBPKT_ISSUER, NULL );
1415         if(p)
1416           {
1417             sig->keyid[0] = buffer_to_u32(p);
1418             sig->keyid[1] = buffer_to_u32(p+4);
1419           }
1420         else if(!(sig->pubkey_algo>=100 && sig->pubkey_algo<=110)
1421                 && opt.verbose)
1422           log_info ("signature packet without keyid\n");
1423
1424         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_SIG_EXPIRE,NULL);
1425         if(p && buffer_to_u32(p))
1426           sig->expiredate=sig->timestamp+buffer_to_u32(p);
1427         if(sig->expiredate && sig->expiredate<=make_timestamp())
1428           sig->flags.expired=1;
1429
1430         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_POLICY,NULL);
1431         if(p)
1432           sig->flags.policy_url=1;
1433
1434         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,NULL);
1435         if(p)
1436           sig->flags.pref_ks=1;
1437
1438         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,NULL);
1439         if(p)
1440           sig->flags.notation=1;
1441
1442         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_REVOCABLE,NULL);
1443         if(p && *p==0)
1444           sig->flags.revocable=0;
1445
1446         p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_TRUST,&len);
1447         if(p && len==2)
1448           {
1449             sig->trust_depth=p[0];
1450             sig->trust_value=p[1];
1451
1452             /* Only look for a regexp if there is also a trust
1453                subpacket. */
1454             sig->trust_regexp=
1455               parse_sig_subpkt(sig->hashed,SIGSUBPKT_REGEXP,&len);
1456
1457             /* If the regular expression is of 0 length, there is no
1458                regular expression. */
1459             if(len==0)
1460               sig->trust_regexp=NULL;
1461           }
1462
1463         /* We accept the exportable subpacket from either the hashed
1464            or unhashed areas as older versions of gpg put it in the
1465            unhashed area.  In theory, anyway, we should never see this
1466            packet off of a local keyring. */
1467
1468         p=parse_sig_subpkt2(sig,SIGSUBPKT_EXPORTABLE,NULL);
1469         if(p && *p==0)
1470           sig->flags.exportable=0;
1471
1472         /* Find all revocation keys. */
1473         if(sig->sig_class==0x1F)
1474           parse_revkeys(sig);
1475       }
1476
1477     if( list_mode ) {
1478         fprintf (listfp, ":signature packet: algo %d, keyid %08lX%08lX\n"
1479                "\tversion %d, created %lu, md5len %d, sigclass 0x%02x\n"
1480                "\tdigest algo %d, begin of digest %02x %02x\n",
1481                 sig->pubkey_algo,
1482                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1483                 sig->version, (ulong)sig->timestamp, md5_len, sig->sig_class,
1484                 sig->digest_algo,
1485                 sig->digest_start[0], sig->digest_start[1] );
1486         if( is_v4 ) {
1487             parse_sig_subpkt (sig->hashed,   SIGSUBPKT_LIST_HASHED, NULL );
1488             parse_sig_subpkt (sig->unhashed, SIGSUBPKT_LIST_UNHASHED, NULL);
1489         }
1490     }
1491
1492     ndata = pubkey_get_nsig(sig->pubkey_algo);
1493     if( !ndata ) {
1494         if( list_mode )
1495             fprintf (listfp, "\tunknown algorithm %d\n", sig->pubkey_algo );
1496         unknown_pubkey_warning( sig->pubkey_algo );
1497         /* We store the plain material in data[0], so that we are able
1498          * to write it back with build_packet() */
1499         if (pktlen > (5 * MAX_EXTERN_MPI_BITS/8))
1500           {
1501             /* However we include a limit to avoid too trivial DoS
1502                attacks by having gpg allocate too much memory.  */
1503             log_error ("signature packet: too much data\n");
1504             rc = G10ERR_INVALID_PACKET;
1505           }
1506         else
1507           {
1508             sig->data[0]= mpi_set_opaque (NULL, read_rest(inp, pktlen, 0),
1509                                           pktlen );
1510             pktlen = 0;
1511           }
1512     }
1513     else {
1514         for( i=0; i < ndata; i++ ) {
1515             n = pktlen;
1516             sig->data[i] = mpi_read(inp, &n, 0 );
1517             pktlen -=n;
1518             if( list_mode ) {
1519                 fprintf (listfp, "\tdata: ");
1520                 mpi_print(listfp, sig->data[i], mpi_print_mode );
1521                 putc ('\n', listfp);
1522             }
1523             if (!sig->data[i])
1524                 rc = G10ERR_INVALID_PACKET;
1525         }
1526     }
1527
1528   leave:
1529     iobuf_skip_rest(inp, pktlen, 0);
1530     return rc;
1531 }
1532
1533
1534 static int
1535 parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
1536                                              PKT_onepass_sig *ops )
1537 {
1538     int version;
1539     int rc = 0;
1540
1541     if( pktlen < 13 ) {
1542         log_error("packet(%d) too short\n", pkttype);
1543         rc = G10ERR_INVALID_PACKET;
1544         goto leave;
1545     }
1546     version = iobuf_get_noeof(inp); pktlen--;
1547     if( version != 3 ) {
1548         log_error("onepass_sig with unknown version %d\n", version);
1549         rc = G10ERR_INVALID_PACKET;
1550         goto leave;
1551     }
1552     ops->sig_class = iobuf_get_noeof(inp); pktlen--;
1553     ops->digest_algo = iobuf_get_noeof(inp); pktlen--;
1554     ops->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1555     ops->keyid[0] = read_32(inp); pktlen -= 4;
1556     ops->keyid[1] = read_32(inp); pktlen -= 4;
1557     ops->last = iobuf_get_noeof(inp); pktlen--;
1558     if( list_mode )
1559         fprintf (listfp, ":onepass_sig packet: keyid %08lX%08lX\n"
1560               "\tversion %d, sigclass 0x%02x, digest %d, pubkey %d, last=%d\n",
1561                 (ulong)ops->keyid[0], (ulong)ops->keyid[1],
1562                 version, ops->sig_class,
1563                 ops->digest_algo, ops->pubkey_algo, ops->last );
1564
1565
1566   leave:
1567     iobuf_skip_rest(inp, pktlen, 0);
1568     return rc;
1569 }
1570
1571
1572 static MPI
1573 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1574 {
1575   int c;
1576   unsigned int nbits, nbytes;
1577   unsigned char *buf, *p;
1578   MPI val;
1579
1580   if (*length < 2)
1581     {
1582       log_error ("mpi too small\n");
1583       return NULL;
1584     }
1585
1586   if ((c=iobuf_get (inp)) == -1)
1587     return NULL;
1588   --*length;
1589   nbits = c << 8;
1590   if ((c=iobuf_get(inp)) == -1)
1591     return NULL;
1592   --*length;
1593   nbits |= c;
1594
1595   if (nbits > 16384)
1596     {
1597       log_error ("mpi too large (%u bits)\n", nbits);
1598       return NULL;
1599     }
1600   nbytes = (nbits+7) / 8;
1601   buf = p = xmalloc (2 + nbytes);
1602   *p++ = nbits >> 8;
1603   *p++ = nbits;
1604   for (; nbytes && *length; nbytes--, --*length)
1605     *p++ = iobuf_get (inp);
1606   if (nbytes)
1607     {
1608       log_error ("packet shorter tham mpi\n");
1609       xfree (buf);
1610       return NULL;
1611     }
1612
1613   /* convert buffer into an opaque MPI */
1614   val = mpi_set_opaque (NULL, buf, p-buf);
1615   return val;
1616 }
1617
1618
1619 static int
1620 parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
1621                               byte *hdr, int hdrlen, PACKET *pkt )
1622 {
1623     int i, version, algorithm;
1624     unsigned n;
1625     unsigned long timestamp, expiredate, max_expiredate;
1626     int npkey, nskey;
1627     int is_v4=0;
1628     int rc=0;
1629     u32 keyid[2];
1630
1631     version = iobuf_get_noeof(inp); pktlen--;
1632     if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
1633         /* early versions of G10 use old PGP comments packets;
1634          * luckily all those comments are started by a hash */
1635         if( list_mode ) {
1636             fprintf (listfp, ":rfc1991 comment packet: \"" );
1637             for( ; pktlen; pktlen-- ) {
1638                 int c;
1639                 c = iobuf_get_noeof(inp);
1640                 if( c >= ' ' && c <= 'z' )
1641                     putc (c, listfp);
1642                 else
1643                     fprintf (listfp, "\\x%02x", c );
1644             }
1645             fprintf (listfp, "\"\n");
1646         }
1647         iobuf_skip_rest(inp, pktlen, 0);
1648         return 0;
1649     }
1650     else if( version == 4 )
1651         is_v4=1;
1652     else if( version != 2 && version != 3 ) {
1653         log_error("packet(%d) with unknown version %d\n", pkttype, version);
1654         rc = G10ERR_INVALID_PACKET;
1655         goto leave;
1656     }
1657
1658     if( pktlen < 11 ) {
1659         log_error("packet(%d) too short\n", pkttype);
1660         rc = G10ERR_INVALID_PACKET;
1661         goto leave;
1662     }
1663
1664     timestamp = read_32(inp); pktlen -= 4;
1665     if( is_v4 ) {
1666         expiredate = 0; /* have to get it from the selfsignature */
1667         max_expiredate = 0;
1668     }
1669     else {
1670         unsigned short ndays;
1671         ndays = read_16(inp); pktlen -= 2;
1672         if( ndays )
1673             expiredate = timestamp + ndays * 86400L;
1674         else
1675             expiredate = 0;
1676
1677         max_expiredate=expiredate;
1678     }
1679     algorithm = iobuf_get_noeof(inp); pktlen--;
1680     if( list_mode )
1681         fprintf (listfp, ":%s key packet:\n"
1682                "\tversion %d, algo %d, created %lu, expires %lu\n",
1683                 pkttype == PKT_PUBLIC_KEY? "public" :
1684                 pkttype == PKT_SECRET_KEY? "secret" :
1685                 pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
1686                 pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
1687                 version, algorithm, timestamp, expiredate );
1688
1689     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
1690         PKT_secret_key *sk = pkt->pkt.secret_key;
1691
1692         sk->timestamp = timestamp;
1693         sk->expiredate = expiredate;
1694         sk->max_expiredate = max_expiredate;
1695         sk->hdrbytes = hdrlen;
1696         sk->version = version;
1697         sk->is_primary = pkttype == PKT_SECRET_KEY;
1698         sk->pubkey_algo = algorithm;
1699         sk->req_usage = 0;
1700         sk->pubkey_usage = 0; /* not yet used */
1701     }
1702     else {
1703         PKT_public_key *pk = pkt->pkt.public_key;
1704
1705         pk->timestamp = timestamp;
1706         pk->expiredate = expiredate;
1707         pk->max_expiredate = max_expiredate;
1708         pk->hdrbytes    = hdrlen;
1709         pk->version     = version;
1710         pk->is_primary = pkttype == PKT_PUBLIC_KEY;
1711         pk->pubkey_algo = algorithm;
1712         pk->req_usage = 0;
1713         pk->pubkey_usage = 0; /* not yet used */
1714         pk->is_revoked = 0;
1715         pk->is_disabled = 0;
1716         pk->keyid[0] = 0;
1717         pk->keyid[1] = 0;
1718     }
1719     nskey = pubkey_get_nskey( algorithm );
1720     npkey = pubkey_get_npkey( algorithm );
1721     if( !npkey ) {
1722         if( list_mode )
1723             fprintf (listfp, "\tunknown algorithm %d\n", algorithm );
1724         unknown_pubkey_warning( algorithm );
1725     }
1726
1727     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
1728         PKT_secret_key *sk = pkt->pkt.secret_key;
1729         byte temp[16];
1730         size_t snlen = 0;
1731
1732         if( !npkey ) {
1733             sk->skey[0] = mpi_set_opaque( NULL,
1734                                           read_rest(inp, pktlen, 0), pktlen );
1735             pktlen = 0;
1736             goto leave;
1737         }
1738
1739         for(i=0; i < npkey; i++ ) {
1740             n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1741             if( list_mode ) {
1742                 fprintf (listfp,   "\tskey[%d]: ", i);
1743                 mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1744                 putc ('\n', listfp);
1745             }
1746             if (!sk->skey[i])
1747                 rc = G10ERR_INVALID_PACKET;
1748         }
1749         if (rc) /* one of the MPIs were bad */
1750             goto leave;
1751         if (list_mode && npkey)
1752             keyid_from_sk (sk, keyid);
1753
1754         sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1755         sk->protect.sha1chk = 0;
1756         if( sk->protect.algo ) {
1757             sk->is_protected = 1;
1758             sk->protect.s2k.count = 0;
1759             if( sk->protect.algo == 254 || sk->protect.algo == 255 ) {
1760                 if( pktlen < 3 ) {
1761                     rc = G10ERR_INVALID_PACKET;
1762                     goto leave;
1763                 }
1764                 sk->protect.sha1chk = (sk->protect.algo == 254);
1765                 sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1766                 /* Note that a sk->protect.algo > 110 is illegal, but
1767                    I'm not erroring on it here as otherwise there
1768                    would be no way to delete such a key. */
1769                 sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
1770                 sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
1771                 /* check for the special GNU extension */
1772                 if( is_v4 && sk->protect.s2k.mode == 101 ) {
1773                     for(i=0; i < 4 && pktlen; i++, pktlen-- )
1774                         temp[i] = iobuf_get_noeof(inp);
1775                     if( i < 4 || memcmp( temp, "GNU", 3 ) ) {
1776                         if( list_mode )
1777                             fprintf (listfp,   "\tunknown S2K %d\n",
1778                                                 sk->protect.s2k.mode );
1779                         rc = G10ERR_INVALID_PACKET;
1780                         goto leave;
1781                     }
1782                     /* here we know that it is a gnu extension
1783                      * What follows is the GNU protection mode:
1784                      * All values have special meanings
1785                      * and they are mapped in the mode with a base of 1000.
1786                      */
1787                     sk->protect.s2k.mode = 1000 + temp[3];
1788                 }
1789                 switch( sk->protect.s2k.mode ) {
1790                   case 1:
1791                   case 3:
1792                     for(i=0; i < 8 && pktlen; i++, pktlen-- )
1793                         temp[i] = iobuf_get_noeof(inp);
1794                     memcpy(sk->protect.s2k.salt, temp, 8 );
1795                     break;
1796                 }
1797                 switch( sk->protect.s2k.mode ) {
1798                   case 0: if( list_mode ) fprintf (listfp, "\tsimple S2K" );
1799                     break;
1800                   case 1: if( list_mode ) fprintf (listfp, "\tsalted S2K" );
1801                     break;
1802                   case 3: if( list_mode ) fprintf (listfp, "\titer+salt S2K" );
1803                     break;
1804                   case 1001: if( list_mode ) fprintf (listfp,
1805                                                       "\tgnu-dummy S2K" );
1806                     break;
1807                   case 1002: if (list_mode) fprintf (listfp,
1808                                                   "\tgnu-divert-to-card S2K");
1809                     break;
1810                   default:
1811                     if( list_mode )
1812                         fprintf (listfp,   "\tunknown %sS2K %d\n",
1813                                  sk->protect.s2k.mode < 1000? "":"GNU ",
1814                                                    sk->protect.s2k.mode );
1815                     rc = G10ERR_INVALID_PACKET;
1816                     goto leave;
1817                 }
1818
1819                 if( list_mode ) {
1820                     fprintf (listfp, ", algo: %d,%s hash: %d",
1821                                      sk->protect.algo,
1822                                      sk->protect.sha1chk?" SHA1 protection,"
1823                                                         :" simple checksum,",
1824                                      sk->protect.s2k.hash_algo );
1825                     if( sk->protect.s2k.mode == 1
1826                         || sk->protect.s2k.mode == 3 ) {
1827                         fprintf (listfp, ", salt: ");
1828                         for(i=0; i < 8; i++ )
1829                             fprintf (listfp, "%02x", sk->protect.s2k.salt[i]);
1830                     }
1831                     putc ('\n', listfp);
1832                 }
1833
1834                 if( sk->protect.s2k.mode == 3 ) {
1835                     if( pktlen < 1 ) {
1836                         rc = G10ERR_INVALID_PACKET;
1837                         goto leave;
1838                     }
1839                     sk->protect.s2k.count = iobuf_get(inp);
1840                     pktlen--;
1841                     if( list_mode )
1842                         fprintf (listfp, "\tprotect count: %lu (%lu)\n",
1843                                 (ulong)S2K_DECODE_COUNT
1844                                  ((ulong)sk->protect.s2k.count),
1845                                  (ulong)sk->protect.s2k.count);
1846                 }
1847                 else if( sk->protect.s2k.mode == 1002 ) {
1848                     /* Read the serial number. */
1849                     if (pktlen < 1) {
1850                       rc = G10ERR_INVALID_PACKET;
1851                         goto leave;
1852                     }
1853                     snlen = iobuf_get (inp);
1854                     pktlen--;
1855                     if (pktlen < snlen || snlen == (size_t)(-1)) {
1856                         rc = G10ERR_INVALID_PACKET;
1857                         goto leave;
1858                     }
1859                 }
1860             }
1861             /* Note that a sk->protect.algo > 110 is illegal, but I'm
1862                not erroring on it here as otherwise there would be no
1863                way to delete such a key. */
1864             else { /* old version; no S2K, so we set mode to 0, hash MD5 */
1865                 sk->protect.s2k.mode = 0;
1866                 sk->protect.s2k.hash_algo = DIGEST_ALGO_MD5;
1867                 if( list_mode )
1868                     fprintf (listfp,   "\tprotect algo: %d  (hash algo: %d)\n",
1869                          sk->protect.algo, sk->protect.s2k.hash_algo );
1870             }
1871             /* It is really ugly that we don't know the size
1872              * of the IV here in cases we are not aware of the algorithm.
1873              * so a
1874              *   sk->protect.ivlen = cipher_get_blocksize(sk->protect.algo);
1875              * won't work.  The only solution I see is to hardwire it here.
1876              * NOTE: if you change the ivlen above 16, don't forget to
1877              * enlarge temp.
1878              */
1879             switch( sk->protect.algo ) {
1880               case 7: case 8: case 9: /* AES */
1881               case 10: /* Twofish */
1882               case 11: case 12: case 13: /* Camellia */
1883                 sk->protect.ivlen = 16;
1884                 break;
1885               default:
1886                 sk->protect.ivlen = 8;
1887             }
1888             if( sk->protect.s2k.mode == 1001 )
1889                 sk->protect.ivlen = 0;
1890             else if( sk->protect.s2k.mode == 1002 )
1891                 sk->protect.ivlen = snlen < 16? snlen : 16;
1892
1893             if( pktlen < sk->protect.ivlen ) {
1894                 rc = G10ERR_INVALID_PACKET;
1895                 goto leave;
1896             }
1897             for(i=0; i < sk->protect.ivlen && pktlen; i++, pktlen-- )
1898                 temp[i] = iobuf_get_noeof(inp);
1899             if( list_mode ) {
1900                 fprintf (listfp,
1901                          sk->protect.s2k.mode == 1002? "\tserial-number: "
1902                                                      : "\tprotect IV: ");
1903                 for(i=0; i < sk->protect.ivlen; i++ )
1904                     fprintf (listfp, " %02x", temp[i] );
1905                 putc ('\n', listfp);
1906             }
1907             memcpy(sk->protect.iv, temp, sk->protect.ivlen );
1908         }
1909         else
1910             sk->is_protected = 0;
1911         /* It does not make sense to read it into secure memory.
1912          * If the user is so careless, not to protect his secret key,
1913          * we can assume, that he operates an open system :=(.
1914          * So we put the key into secure memory when we unprotect it. */
1915         if( sk->protect.s2k.mode == 1001
1916             || sk->protect.s2k.mode == 1002 ) {
1917             /* better set some dummy stuff here */
1918             sk->skey[npkey] = mpi_set_opaque(NULL, xstrdup("dummydata"), 10);
1919             pktlen = 0;
1920         }
1921         else if( is_v4 && sk->is_protected ) {
1922             /* ugly; the length is encrypted too, so we read all
1923              * stuff up to the end of the packet into the first
1924              * skey element */
1925             sk->skey[npkey] = mpi_set_opaque(NULL,
1926                                              read_rest(inp, pktlen, 0),pktlen);
1927             pktlen = 0;
1928             if( list_mode ) {
1929                 fprintf (listfp, "\tencrypted stuff follows\n");
1930             }
1931         }
1932         else { /* v3 method: the mpi length is not encrypted */
1933             for(i=npkey; i < nskey; i++ ) {
1934                 if ( sk->is_protected ) {
1935                     sk->skey[i] = read_protected_v3_mpi (inp, &pktlen);
1936                     if( list_mode )
1937                         fprintf (listfp,   "\tskey[%d]: [encrypted]\n", i);
1938                 }
1939                 else {
1940                     n = pktlen;
1941                     sk->skey[i] = mpi_read(inp, &n, 0 );
1942                     pktlen -=n;
1943                     if( list_mode ) {
1944                         fprintf (listfp,   "\tskey[%d]: ", i);
1945                         mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1946                         putc ('\n', listfp);
1947                     }
1948                 }
1949
1950                 if (!sk->skey[i])
1951                     rc = G10ERR_INVALID_PACKET;
1952             }
1953             if (rc)
1954                 goto leave;
1955
1956             sk->csum = read_16(inp); pktlen -= 2;
1957             if( list_mode ) {
1958                 fprintf (listfp, "\tchecksum: %04hx\n", sk->csum);
1959             }
1960         }
1961     }
1962     else {
1963         PKT_public_key *pk = pkt->pkt.public_key;
1964
1965         if( !npkey ) {
1966             pk->pkey[0] = mpi_set_opaque( NULL,
1967                                           read_rest(inp, pktlen, 0), pktlen );
1968             pktlen = 0;
1969             goto leave;
1970         }
1971
1972         for(i=0; i < npkey; i++ ) {
1973             n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1974             if( list_mode ) {
1975                 fprintf (listfp,   "\tpkey[%d]: ", i);
1976                 mpi_print(listfp, pk->pkey[i], mpi_print_mode  );
1977                 putc ('\n', listfp);
1978             }
1979             if (!pk->pkey[i])
1980                 rc = G10ERR_INVALID_PACKET;
1981         }
1982         if (rc)
1983             goto leave;
1984
1985         if (list_mode)
1986             keyid_from_pk (pk, keyid);
1987     }
1988
1989   if (list_mode && npkey)
1990       fprintf (listfp, "\tkeyid: %08lX%08lX\n",
1991               (ulong) keyid[0], (ulong) keyid[1]);
1992
1993   leave:
1994     iobuf_skip_rest(inp, pktlen, 0);
1995     return rc;
1996 }
1997
1998 /* Attribute subpackets have the same format as v4 signature
1999    subpackets.  This is not part of OpenPGP, but is done in several
2000    versions of PGP nevertheless. */
2001 int
2002 parse_attribute_subpkts(PKT_user_id *uid)
2003 {
2004   size_t n;
2005   int count=0;
2006   struct user_attribute *attribs=NULL;
2007   const byte *buffer=uid->attrib_data;
2008   int buflen=uid->attrib_len;
2009   byte type;
2010
2011   xfree(uid->attribs);
2012
2013   while(buflen)
2014     {
2015       n = *buffer++; buflen--;
2016       if( n == 255 ) { /* 4 byte length header */
2017         if( buflen < 4 )
2018           goto too_short;
2019         n = (buffer[0] << 24) | (buffer[1] << 16)
2020           | (buffer[2] << 8) | buffer[3];
2021         buffer += 4;
2022         buflen -= 4;
2023       }
2024       else if( n >= 192 ) { /* 2 byte special encoded length header */
2025         if( buflen < 2 )
2026           goto too_short;
2027         n = (( n - 192 ) << 8) + *buffer + 192;
2028         buffer++;
2029         buflen--;
2030       }
2031       if( buflen < n )
2032         goto too_short;
2033
2034       if (!n)
2035         {
2036           /* Too short to encode the subpacket type.  */
2037           if (opt.verbose)
2038             log_info ("attribute subpacket too short\n");
2039           break;
2040         }
2041
2042       attribs=xrealloc(attribs,(count+1)*sizeof(struct user_attribute));
2043       memset(&attribs[count],0,sizeof(struct user_attribute));
2044
2045       type=*buffer;
2046       buffer++;
2047       buflen--;
2048       n--;
2049
2050       attribs[count].type=type;
2051       attribs[count].data=buffer;
2052       attribs[count].len=n;
2053       buffer+=n;
2054       buflen-=n;
2055       count++;
2056     }
2057
2058   uid->attribs=attribs;
2059   uid->numattribs=count;
2060   return count;
2061
2062  too_short:
2063   if(opt.verbose)
2064     log_info("buffer shorter than attribute subpacket\n");
2065   uid->attribs=attribs;
2066   uid->numattribs=count;
2067   return count;
2068 }
2069
2070
2071 static int
2072 parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2073 {
2074     byte *p;
2075
2076     /* Cap the size of a user ID at 2k: a value absurdly large enough
2077        that there is no sane user ID string (which is printable text
2078        as of RFC2440bis) that won't fit in it, but yet small enough to
2079        avoid allocation problems.  A large pktlen may not be
2080        allocatable, and a very large pktlen could actually cause our
2081        allocation to wrap around in xmalloc to a small number. */
2082
2083     if(pktlen>2048)
2084       {
2085         log_error("packet(%d) too large\n", pkttype);
2086         iobuf_skip_rest(inp, pktlen, 0);
2087         return G10ERR_INVALID_PACKET;
2088       }
2089
2090     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id + pktlen);
2091     packet->pkt.user_id->len = pktlen;
2092     packet->pkt.user_id->ref=1;
2093
2094     p = packet->pkt.user_id->name;
2095     for( ; pktlen; pktlen--, p++ )
2096         *p = iobuf_get_noeof(inp);
2097     *p = 0;
2098
2099     if( list_mode ) {
2100         int n = packet->pkt.user_id->len;
2101         fprintf (listfp, ":user ID packet: \"");
2102         /* fixme: Hey why don't we replace this with print_string?? */
2103         for(p=packet->pkt.user_id->name; n; p++, n-- ) {
2104             if( *p >= ' ' && *p <= 'z' )
2105                 putc (*p, listfp);
2106             else
2107                 fprintf (listfp, "\\x%02x", *p );
2108         }
2109         fprintf (listfp, "\"\n");
2110     }
2111     return 0;
2112 }
2113
2114
2115 void
2116 make_attribute_uidname(PKT_user_id *uid, size_t max_namelen)
2117 {
2118   assert ( max_namelen > 70 );
2119   if(uid->numattribs<=0)
2120     sprintf(uid->name,"[bad attribute packet of size %lu]",uid->attrib_len);
2121   else if(uid->numattribs>1)
2122     sprintf(uid->name,"[%d attributes of size %lu]",
2123             uid->numattribs,uid->attrib_len);
2124   else
2125     {
2126       /* Only one attribute, so list it as the "user id" */
2127
2128       if(uid->attribs->type==ATTRIB_IMAGE)
2129         {
2130           u32 len;
2131           byte type;
2132
2133           if(parse_image_header(uid->attribs,&type,&len))
2134             sprintf(uid->name,"[%.20s image of size %lu]",
2135                     image_type_to_string(type,1),(ulong)len);
2136           else
2137             sprintf(uid->name,"[invalid image]");
2138         }
2139       else
2140         sprintf(uid->name,"[unknown attribute of size %lu]",
2141                 (ulong)uid->attribs->len);
2142     }
2143
2144   uid->len = strlen(uid->name);
2145 }
2146
2147 static int
2148 parse_attribute( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2149 {
2150     byte *p;
2151
2152 #define EXTRA_UID_NAME_SPACE 71
2153     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id
2154                                         + EXTRA_UID_NAME_SPACE);
2155     packet->pkt.user_id->ref=1;
2156     packet->pkt.user_id->attrib_data = xmalloc(pktlen);
2157     packet->pkt.user_id->attrib_len = pktlen;
2158
2159     p = packet->pkt.user_id->attrib_data;
2160     for( ; pktlen; pktlen--, p++ )
2161         *p = iobuf_get_noeof(inp);
2162
2163     /* Now parse out the individual attribute subpackets.  This is
2164        somewhat pointless since there is only one currently defined
2165        attribute type (jpeg), but it is correct by the spec. */
2166     parse_attribute_subpkts(packet->pkt.user_id);
2167
2168     make_attribute_uidname(packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2169
2170     if( list_mode ) {
2171         fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name );
2172     }
2173     return 0;
2174 }
2175
2176
2177 static int
2178 parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2179 {
2180     byte *p;
2181
2182     /* Cap comment packet at a reasonable value to avoid an integer
2183        overflow in the malloc below.  Comment packets are actually not
2184        anymore define my OpenPGP and we even stopped to use our
2185        private comment packet. */
2186     if (pktlen>65536)
2187       {
2188         log_error ("packet(%d) too large\n", pkttype);
2189         iobuf_skip_rest (inp, pktlen, 0);
2190         return G10ERR_INVALID_PACKET;
2191       }
2192     packet->pkt.comment = xmalloc(sizeof *packet->pkt.comment + pktlen - 1);
2193     packet->pkt.comment->len = pktlen;
2194     p = packet->pkt.comment->data;
2195     for( ; pktlen; pktlen--, p++ )
2196         *p = iobuf_get_noeof(inp);
2197
2198     if( list_mode ) {
2199         int n = packet->pkt.comment->len;
2200         fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
2201                                          "OpenPGP draft " : "GnuPG " );
2202         for(p=packet->pkt.comment->data; n; p++, n-- ) {
2203             if( *p >= ' ' && *p <= 'z' )
2204                 putc (*p, listfp);
2205             else
2206                 fprintf (listfp, "\\x%02x", *p );
2207         }
2208         fprintf (listfp, "\"\n");
2209     }
2210     return 0;
2211 }
2212
2213
2214 static void
2215 parse_trust( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
2216 {
2217   int c;
2218
2219   if (pktlen)
2220     {
2221       c = iobuf_get_noeof(inp);
2222       pktlen--;
2223       pkt->pkt.ring_trust = xmalloc( sizeof *pkt->pkt.ring_trust );
2224       pkt->pkt.ring_trust->trustval = c;
2225       pkt->pkt.ring_trust->sigcache = 0;
2226       if (!c && pktlen==1)
2227         {
2228           c = iobuf_get_noeof (inp);
2229           pktlen--;
2230           /* we require that bit 7 of the sigcache is 0 (easier eof handling)*/
2231           if ( !(c & 0x80) )
2232             pkt->pkt.ring_trust->sigcache = c;
2233         }
2234       if( list_mode )
2235         fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2236                pkt->pkt.ring_trust->trustval,
2237                pkt->pkt.ring_trust->sigcache);
2238     }
2239   else
2240     {
2241       if( list_mode )
2242         fprintf (listfp, ":trust packet: empty\n");
2243     }
2244   iobuf_skip_rest (inp, pktlen, 0);
2245 }
2246
2247
2248 static int
2249 parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
2250                  PACKET *pkt, int new_ctb, int partial )
2251 {
2252     int rc = 0;
2253     int mode, namelen;
2254     PKT_plaintext *pt;
2255     byte *p;
2256     int c, i;
2257
2258     if( !partial && pktlen < 6 ) {
2259         log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
2260         rc = G10ERR_INVALID_PACKET;
2261         goto leave;
2262     }
2263     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2264     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2265     /* Note that namelen will never exceeds 255 byte. */
2266     pt = pkt->pkt.plaintext = xmalloc(sizeof *pkt->pkt.plaintext + namelen -1);
2267     pt->new_ctb = new_ctb;
2268     pt->mode = mode;
2269     pt->namelen = namelen;
2270     pt->is_partial = partial;
2271     if( pktlen ) {
2272         for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
2273             pt->name[i] = iobuf_get_noeof(inp);
2274     }
2275     else {
2276         for( i=0; i < namelen; i++ )
2277             if( (c=iobuf_get(inp)) == -1 )
2278                 break;
2279             else
2280                 pt->name[i] = c;
2281     }
2282     pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
2283     pt->len = pktlen;
2284     pt->buf = inp;
2285     pktlen = 0;
2286
2287     if( list_mode ) {
2288         fprintf (listfp, ":literal data packet:\n"
2289                "\tmode %c (%X), created %lu, name=\"",
2290                     mode >= ' ' && mode <'z'? mode : '?', mode,
2291                     (ulong)pt->timestamp );
2292         for(p=pt->name,i=0; i < namelen; p++, i++ ) {
2293             if( *p >= ' ' && *p <= 'z' )
2294                 putc (*p, listfp);
2295             else
2296                 fprintf (listfp, "\\x%02x", *p );
2297         }
2298         fprintf (listfp, "\",\n\traw data: ");
2299         if(partial)
2300           fprintf (listfp, "unknown length\n");
2301         else
2302           fprintf (listfp, "%lu bytes\n", (ulong)pt->len );
2303     }
2304
2305   leave:
2306     return rc;
2307 }
2308
2309
2310 static int
2311 parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
2312                   PACKET *pkt, int new_ctb )
2313 {
2314     PKT_compressed *zd;
2315
2316     /* pktlen is here 0, but data follows
2317      * (this should be the last object in a file or
2318      *  the compress algorithm should know the length)
2319      */
2320     zd = pkt->pkt.compressed =  xmalloc(sizeof *pkt->pkt.compressed );
2321     zd->algorithm = iobuf_get_noeof(inp);
2322     zd->len = 0; /* not used */
2323     zd->new_ctb = new_ctb;
2324     zd->buf = inp;
2325     if( list_mode )
2326         fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2327     return 0;
2328 }
2329
2330
2331 static int
2332 parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
2333                  PACKET *pkt, int new_ctb, int partial )
2334 {
2335     int rc = 0;
2336     PKT_encrypted *ed;
2337     unsigned long orig_pktlen = pktlen;
2338
2339     ed = pkt->pkt.encrypted =  xmalloc(sizeof *pkt->pkt.encrypted );
2340     ed->len = pktlen;
2341     /* we don't know the extralen which is (cipher_blocksize+2)
2342        because the algorithm ist not specified in this packet.
2343        However, it is only important to know this for some sanity
2344        checks on the packet length - it doesn't matter that we can't
2345        do it */
2346     ed->extralen = 0;
2347     ed->buf = NULL;
2348     ed->new_ctb = new_ctb;
2349     ed->is_partial = partial;
2350     ed->mdc_method = 0;
2351     if( pkttype == PKT_ENCRYPTED_MDC ) {
2352         /* fixme: add some pktlen sanity checks */
2353         int version;
2354
2355         version = iobuf_get_noeof(inp);
2356         if (orig_pktlen)
2357             pktlen--;
2358         if( version != 1 ) {
2359             log_error("encrypted_mdc packet with unknown version %d\n",
2360                                                                 version);
2361             /*skip_rest(inp, pktlen); should we really do this? */
2362             rc = G10ERR_INVALID_PACKET;
2363             goto leave;
2364         }
2365         ed->mdc_method = DIGEST_ALGO_SHA1;
2366     }
2367     if( orig_pktlen && pktlen < 10 ) { /* actually this is blocksize+2 */
2368         log_error("packet(%d) too short\n", pkttype);
2369         rc = G10ERR_INVALID_PACKET;
2370         iobuf_skip_rest(inp, pktlen, partial);
2371         goto leave;
2372     }
2373     if( list_mode ) {
2374         if( orig_pktlen )
2375             fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2376                      orig_pktlen);
2377         else
2378             fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2379         if( ed->mdc_method )
2380             fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method );
2381     }
2382
2383     ed->buf = inp;
2384
2385   leave:
2386     return rc;
2387 }
2388
2389
2390 static int
2391 parse_mdc( IOBUF inp, int pkttype, unsigned long pktlen,
2392                                    PACKET *pkt, int new_ctb )
2393 {
2394     int rc = 0;
2395     PKT_mdc *mdc;
2396     byte *p;
2397
2398     mdc = pkt->pkt.mdc=  xmalloc(sizeof *pkt->pkt.mdc );
2399     if( list_mode )
2400         fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2401     if( !new_ctb || pktlen != 20 ) {
2402         log_error("mdc_packet with invalid encoding\n");
2403         rc = G10ERR_INVALID_PACKET;
2404         goto leave;
2405     }
2406     p = mdc->hash;
2407     for( ; pktlen; pktlen--, p++ )
2408         *p = iobuf_get_noeof(inp);
2409
2410   leave:
2411     return rc;
2412 }
2413
2414
2415 /*
2416  * This packet is internally generated by GPG (by armor.c) to
2417  * transfer some information to the lower layer.  To make sure that
2418  * this packet is really a GPG faked one and not one comming from outside,
2419  * we first check that there is a unique tag in it.
2420  * The format of such a control packet is:
2421  *   n byte  session marker
2422  *   1 byte  control type CTRLPKT_xxxxx
2423  *   m byte  control data
2424  */
2425
2426 static int
2427 parse_gpg_control( IOBUF inp, int pkttype,
2428                    unsigned long pktlen, PACKET *packet, int partial )
2429 {
2430     byte *p;
2431     const byte *sesmark;
2432     size_t sesmarklen;
2433     int i;
2434
2435     if ( list_mode )
2436         fprintf (listfp, ":packet 63: length %lu ",  pktlen);
2437
2438     sesmark = get_session_marker ( &sesmarklen );
2439     if ( pktlen < sesmarklen+1 ) /* 1 is for the control bytes */
2440         goto skipit;
2441     for( i=0; i < sesmarklen; i++, pktlen-- ) {
2442         if ( sesmark[i] != iobuf_get_noeof(inp) )
2443             goto skipit;
2444     }
2445     if (pktlen > 4096)
2446       goto skipit; /* Definitely too large.  We skip it to avoid an
2447                       overflow in the malloc. */
2448     if ( list_mode )
2449         puts ("- gpg control packet");
2450
2451     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2452                                       + pktlen - 1);
2453     packet->pkt.gpg_control->control = iobuf_get_noeof(inp); pktlen--;
2454     packet->pkt.gpg_control->datalen = pktlen;
2455     p = packet->pkt.gpg_control->data;
2456     for( ; pktlen; pktlen--, p++ )
2457         *p = iobuf_get_noeof(inp);
2458
2459     return 0;
2460
2461  skipit:
2462     if ( list_mode ) {
2463         int c;
2464
2465         i=0;
2466         fprintf (listfp, "- private (rest length %lu)\n",  pktlen);
2467         if( partial ) {
2468             while( (c=iobuf_get(inp)) != -1 )
2469                 dump_hex_line(c, &i);
2470         }
2471         else {
2472             for( ; pktlen; pktlen-- )
2473               {
2474                 dump_hex_line ((c=iobuf_get (inp)), &i);
2475                 if (c == -1)
2476                   break;
2477               }
2478         }
2479         putc ('\n', listfp);
2480     }
2481     iobuf_skip_rest(inp,pktlen, 0);
2482     return G10ERR_INVALID_PACKET;
2483 }
2484
2485 /* create a gpg control packet to be used internally as a placeholder */
2486 PACKET *
2487 create_gpg_control( ctrlpkttype_t type, const byte *data, size_t datalen )
2488 {
2489     PACKET *packet;
2490     byte *p;
2491
2492     packet = xmalloc( sizeof *packet );
2493     init_packet(packet);
2494     packet->pkttype = PKT_GPG_CONTROL;
2495     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2496                                       + datalen - 1);
2497     packet->pkt.gpg_control->control = type;
2498     packet->pkt.gpg_control->datalen = datalen;
2499     p = packet->pkt.gpg_control->data;
2500     for( ; datalen; datalen--, p++ )
2501         *p = *data++;
2502
2503     return packet;
2504 }