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