862ec6e7fe1f7468e6ca7c7d68efadc1a4a61858
[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( !npkey ) {
1751             sk->skey[0] = mpi_set_opaque( NULL,
1752                                           read_rest(inp, pktlen, 0), pktlen );
1753             pktlen = 0;
1754             goto leave;
1755         }
1756
1757         for(i=0; i < npkey; i++ ) {
1758             n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1759             if( list_mode ) {
1760                 fprintf (listfp,   "\tskey[%d]: ", i);
1761                 mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1762                 putc ('\n', listfp);
1763             }
1764             if (!sk->skey[i])
1765                 rc = G10ERR_INVALID_PACKET;
1766         }
1767         if (rc) /* one of the MPIs were bad */
1768             goto leave;
1769         if (list_mode && npkey)
1770             keyid_from_sk (sk, keyid);
1771
1772         sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1773         sk->protect.sha1chk = 0;
1774         if( sk->protect.algo ) {
1775             sk->is_protected = 1;
1776             sk->protect.s2k.count = 0;
1777             if( sk->protect.algo == 254 || sk->protect.algo == 255 ) {
1778                 if( pktlen < 3 ) {
1779                     rc = G10ERR_INVALID_PACKET;
1780                     goto leave;
1781                 }
1782                 sk->protect.sha1chk = (sk->protect.algo == 254);
1783                 sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1784                 /* Note that a sk->protect.algo > 110 is illegal, but
1785                    I'm not erroring on it here as otherwise there
1786                    would be no way to delete such a key. */
1787                 sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
1788                 sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
1789                 /* check for the special GNU extension */
1790                 if( is_v4 && sk->protect.s2k.mode == 101 ) {
1791                     for(i=0; i < 4 && pktlen; i++, pktlen-- )
1792                         temp[i] = iobuf_get_noeof(inp);
1793                     if( i < 4 || memcmp( temp, "GNU", 3 ) ) {
1794                         if( list_mode )
1795                             fprintf (listfp,   "\tunknown S2K %d\n",
1796                                                 sk->protect.s2k.mode );
1797                         rc = G10ERR_INVALID_PACKET;
1798                         goto leave;
1799                     }
1800                     /* here we know that it is a gnu extension
1801                      * What follows is the GNU protection mode:
1802                      * All values have special meanings
1803                      * and they are mapped in the mode with a base of 1000.
1804                      */
1805                     sk->protect.s2k.mode = 1000 + temp[3];
1806                 }
1807                 switch( sk->protect.s2k.mode ) {
1808                   case 1:
1809                   case 3:
1810                     for(i=0; i < 8 && pktlen; i++, pktlen-- )
1811                         temp[i] = iobuf_get_noeof(inp);
1812                     memcpy(sk->protect.s2k.salt, temp, 8 );
1813                     break;
1814                 }
1815                 switch( sk->protect.s2k.mode ) {
1816                   case 0: if( list_mode ) fprintf (listfp, "\tsimple S2K" );
1817                     break;
1818                   case 1: if( list_mode ) fprintf (listfp, "\tsalted S2K" );
1819                     break;
1820                   case 3: if( list_mode ) fprintf (listfp, "\titer+salt S2K" );
1821                     break;
1822                   case 1001: if( list_mode ) fprintf (listfp,
1823                                                       "\tgnu-dummy S2K" );
1824                     break;
1825                   case 1002: if (list_mode) fprintf (listfp,
1826                                                   "\tgnu-divert-to-card S2K");
1827                     break;
1828                   default:
1829                     if( list_mode )
1830                         fprintf (listfp,   "\tunknown %sS2K %d\n",
1831                                  sk->protect.s2k.mode < 1000? "":"GNU ",
1832                                                    sk->protect.s2k.mode );
1833                     rc = G10ERR_INVALID_PACKET;
1834                     goto leave;
1835                 }
1836
1837                 if( list_mode ) {
1838                     fprintf (listfp, ", algo: %d,%s hash: %d",
1839                                      sk->protect.algo,
1840                                      sk->protect.sha1chk?" SHA1 protection,"
1841                                                         :" simple checksum,",
1842                                      sk->protect.s2k.hash_algo );
1843                     if( sk->protect.s2k.mode == 1
1844                         || sk->protect.s2k.mode == 3 ) {
1845                         fprintf (listfp, ", salt: ");
1846                         for(i=0; i < 8; i++ )
1847                             fprintf (listfp, "%02x", sk->protect.s2k.salt[i]);
1848                     }
1849                     putc ('\n', listfp);
1850                 }
1851
1852                 if( sk->protect.s2k.mode == 3 ) {
1853                     if( pktlen < 1 ) {
1854                         rc = G10ERR_INVALID_PACKET;
1855                         goto leave;
1856                     }
1857                     sk->protect.s2k.count = iobuf_get(inp);
1858                     pktlen--;
1859                     if( list_mode )
1860                         fprintf (listfp, "\tprotect count: %lu (%lu)\n",
1861                                 (ulong)S2K_DECODE_COUNT
1862                                  ((ulong)sk->protect.s2k.count),
1863                                  (ulong)sk->protect.s2k.count);
1864                 }
1865                 else if( sk->protect.s2k.mode == 1002 ) {
1866                     /* Read the serial number. */
1867                     if (pktlen < 1) {
1868                       rc = G10ERR_INVALID_PACKET;
1869                         goto leave;
1870                     }
1871                     snlen = iobuf_get (inp);
1872                     pktlen--;
1873                     if (pktlen < snlen || snlen == (size_t)(-1)) {
1874                         rc = G10ERR_INVALID_PACKET;
1875                         goto leave;
1876                     }
1877                 }
1878             }
1879             /* Note that a sk->protect.algo > 110 is illegal, but I'm
1880                not erroring on it here as otherwise there would be no
1881                way to delete such a key. */
1882             else { /* old version; no S2K, so we set mode to 0, hash MD5 */
1883                 sk->protect.s2k.mode = 0;
1884                 sk->protect.s2k.hash_algo = DIGEST_ALGO_MD5;
1885                 if( list_mode )
1886                     fprintf (listfp,   "\tprotect algo: %d  (hash algo: %d)\n",
1887                          sk->protect.algo, sk->protect.s2k.hash_algo );
1888             }
1889             /* It is really ugly that we don't know the size
1890              * of the IV here in cases we are not aware of the algorithm.
1891              * so a
1892              *   sk->protect.ivlen = cipher_get_blocksize(sk->protect.algo);
1893              * won't work.  The only solution I see is to hardwire it here.
1894              * NOTE: if you change the ivlen above 16, don't forget to
1895              * enlarge temp.
1896              */
1897             switch( sk->protect.algo ) {
1898               case 7: case 8: case 9: /* AES */
1899               case 10: /* Twofish */
1900               case 11: case 12: case 13: /* Camellia */
1901                 sk->protect.ivlen = 16;
1902                 break;
1903               default:
1904                 sk->protect.ivlen = 8;
1905             }
1906             if( sk->protect.s2k.mode == 1001 )
1907                 sk->protect.ivlen = 0;
1908             else if( sk->protect.s2k.mode == 1002 )
1909                 sk->protect.ivlen = snlen < 16? snlen : 16;
1910
1911             if( pktlen < sk->protect.ivlen ) {
1912                 rc = G10ERR_INVALID_PACKET;
1913                 goto leave;
1914             }
1915             for(i=0; i < sk->protect.ivlen && pktlen; i++, pktlen-- )
1916                 temp[i] = iobuf_get_noeof(inp);
1917             if( list_mode ) {
1918                 fprintf (listfp,
1919                          sk->protect.s2k.mode == 1002? "\tserial-number: "
1920                                                      : "\tprotect IV: ");
1921                 for(i=0; i < sk->protect.ivlen; i++ )
1922                     fprintf (listfp, " %02x", temp[i] );
1923                 putc ('\n', listfp);
1924             }
1925             memcpy(sk->protect.iv, temp, sk->protect.ivlen );
1926         }
1927         else
1928             sk->is_protected = 0;
1929         /* It does not make sense to read it into secure memory.
1930          * If the user is so careless, not to protect his secret key,
1931          * we can assume, that he operates an open system :=(.
1932          * So we put the key into secure memory when we unprotect it. */
1933         if( sk->protect.s2k.mode == 1001
1934             || sk->protect.s2k.mode == 1002 ) {
1935             /* better set some dummy stuff here */
1936             sk->skey[npkey] = mpi_set_opaque(NULL, xstrdup("dummydata"), 10);
1937             pktlen = 0;
1938         }
1939         else if( is_v4 && sk->is_protected ) {
1940             /* ugly; the length is encrypted too, so we read all
1941              * stuff up to the end of the packet into the first
1942              * skey element */
1943             sk->skey[npkey] = mpi_set_opaque(NULL,
1944                                              read_rest(inp, pktlen, 0),pktlen);
1945             pktlen = 0;
1946             if( list_mode ) {
1947                 fprintf (listfp, "\tencrypted stuff follows\n");
1948             }
1949         }
1950         else { /* v3 method: the mpi length is not encrypted */
1951             for(i=npkey; i < nskey; i++ ) {
1952                 if ( sk->is_protected ) {
1953                     sk->skey[i] = read_protected_v3_mpi (inp, &pktlen);
1954                     if( list_mode )
1955                         fprintf (listfp,   "\tskey[%d]: [encrypted]\n", i);
1956                 }
1957                 else {
1958                     n = pktlen;
1959                     sk->skey[i] = mpi_read(inp, &n, 0 );
1960                     pktlen -=n;
1961                     if( list_mode ) {
1962                         fprintf (listfp,   "\tskey[%d]: ", i);
1963                         mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1964                         putc ('\n', listfp);
1965                     }
1966                 }
1967
1968                 if (!sk->skey[i])
1969                     rc = G10ERR_INVALID_PACKET;
1970             }
1971             if (rc)
1972                 goto leave;
1973
1974             sk->csum = read_16(inp); pktlen -= 2;
1975             if( list_mode ) {
1976                 fprintf (listfp, "\tchecksum: %04hx\n", sk->csum);
1977             }
1978         }
1979     }
1980     else {
1981         PKT_public_key *pk = pkt->pkt.public_key;
1982
1983         if( !npkey ) {
1984             pk->pkey[0] = mpi_set_opaque( NULL,
1985                                           read_rest(inp, pktlen, 0), pktlen );
1986             pktlen = 0;
1987             goto leave;
1988         }
1989
1990         for(i=0; i < npkey; i++ ) {
1991             n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1992             if( list_mode ) {
1993                 fprintf (listfp,   "\tpkey[%d]: ", i);
1994                 mpi_print(listfp, pk->pkey[i], mpi_print_mode  );
1995                 putc ('\n', listfp);
1996             }
1997             if (!pk->pkey[i])
1998                 rc = G10ERR_INVALID_PACKET;
1999         }
2000         if (rc)
2001             goto leave;
2002
2003         if (list_mode)
2004             keyid_from_pk (pk, keyid);
2005     }
2006
2007   if (list_mode && npkey)
2008       fprintf (listfp, "\tkeyid: %08lX%08lX\n",
2009               (ulong) keyid[0], (ulong) keyid[1]);
2010
2011   leave:
2012     iobuf_skip_rest(inp, pktlen, 0);
2013     return rc;
2014 }
2015
2016 /* Attribute subpackets have the same format as v4 signature
2017    subpackets.  This is not part of OpenPGP, but is done in several
2018    versions of PGP nevertheless. */
2019 int
2020 parse_attribute_subpkts(PKT_user_id *uid)
2021 {
2022   size_t n;
2023   int count=0;
2024   struct user_attribute *attribs=NULL;
2025   const byte *buffer=uid->attrib_data;
2026   int buflen=uid->attrib_len;
2027   byte type;
2028
2029   xfree(uid->attribs);
2030
2031   while(buflen)
2032     {
2033       n = *buffer++; buflen--;
2034       if( n == 255 ) { /* 4 byte length header */
2035         if( buflen < 4 )
2036           goto too_short;
2037         n = buf32_to_size_t (buffer);
2038         buffer += 4;
2039         buflen -= 4;
2040       }
2041       else if( n >= 192 ) { /* 2 byte special encoded length header */
2042         if( buflen < 2 )
2043           goto too_short;
2044         n = (( n - 192 ) << 8) + *buffer + 192;
2045         buffer++;
2046         buflen--;
2047       }
2048       if( buflen < n )
2049         goto too_short;
2050
2051       if (!n)
2052         {
2053           /* Too short to encode the subpacket type.  */
2054           if (opt.verbose)
2055             log_info ("attribute subpacket too short\n");
2056           break;
2057         }
2058
2059       attribs=xrealloc(attribs,(count+1)*sizeof(struct user_attribute));
2060       memset(&attribs[count],0,sizeof(struct user_attribute));
2061
2062       type=*buffer;
2063       buffer++;
2064       buflen--;
2065       n--;
2066
2067       attribs[count].type=type;
2068       attribs[count].data=buffer;
2069       attribs[count].len=n;
2070       buffer+=n;
2071       buflen-=n;
2072       count++;
2073     }
2074
2075   uid->attribs=attribs;
2076   uid->numattribs=count;
2077   return count;
2078
2079  too_short:
2080   if(opt.verbose)
2081     log_info("buffer shorter than attribute subpacket\n");
2082   uid->attribs=attribs;
2083   uid->numattribs=count;
2084   return count;
2085 }
2086
2087
2088 static int
2089 parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2090 {
2091     byte *p;
2092
2093     /* Cap the size of a user ID at 2k: a value absurdly large enough
2094        that there is no sane user ID string (which is printable text
2095        as of RFC2440bis) that won't fit in it, but yet small enough to
2096        avoid allocation problems.  A large pktlen may not be
2097        allocatable, and a very large pktlen could actually cause our
2098        allocation to wrap around in xmalloc to a small number. */
2099
2100     if (pktlen > MAX_UID_PACKET_LENGTH)
2101       {
2102         log_error("packet(%d) too large\n", pkttype);
2103         iobuf_skip_rest(inp, pktlen, 0);
2104         return G10ERR_INVALID_PACKET;
2105       }
2106
2107     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id + pktlen);
2108     packet->pkt.user_id->len = pktlen;
2109     packet->pkt.user_id->ref=1;
2110
2111     p = packet->pkt.user_id->name;
2112     for( ; pktlen; pktlen--, p++ )
2113         *p = iobuf_get_noeof(inp);
2114     *p = 0;
2115
2116     if( list_mode ) {
2117         int n = packet->pkt.user_id->len;
2118         fprintf (listfp, ":user ID packet: \"");
2119         /* fixme: Hey why don't we replace this with print_string?? */
2120         for(p=packet->pkt.user_id->name; n; p++, n-- ) {
2121             if( *p >= ' ' && *p <= 'z' )
2122                 putc (*p, listfp);
2123             else
2124                 fprintf (listfp, "\\x%02x", *p );
2125         }
2126         fprintf (listfp, "\"\n");
2127     }
2128     return 0;
2129 }
2130
2131
2132 void
2133 make_attribute_uidname(PKT_user_id *uid, size_t max_namelen)
2134 {
2135   assert ( max_namelen > 70 );
2136   if(uid->numattribs<=0)
2137     sprintf(uid->name,"[bad attribute packet of size %lu]",uid->attrib_len);
2138   else if(uid->numattribs>1)
2139     sprintf(uid->name,"[%d attributes of size %lu]",
2140             uid->numattribs,uid->attrib_len);
2141   else
2142     {
2143       /* Only one attribute, so list it as the "user id" */
2144
2145       if(uid->attribs->type==ATTRIB_IMAGE)
2146         {
2147           u32 len;
2148           byte type;
2149
2150           if(parse_image_header(uid->attribs,&type,&len))
2151             sprintf(uid->name,"[%.20s image of size %lu]",
2152                     image_type_to_string(type,1),(ulong)len);
2153           else
2154             sprintf(uid->name,"[invalid image]");
2155         }
2156       else
2157         sprintf(uid->name,"[unknown attribute of size %lu]",
2158                 (ulong)uid->attribs->len);
2159     }
2160
2161   uid->len = strlen(uid->name);
2162 }
2163
2164 static int
2165 parse_attribute( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2166 {
2167     byte *p;
2168
2169     (void)pkttype;
2170
2171     /* We better cap the size of an attribute packet to make DoS not
2172        too easy.  16MB should be more then enough for one attribute
2173        packet (ie. a photo).  */
2174     if (pktlen > MAX_ATTR_PACKET_LENGTH) {
2175         log_error ("packet(%d) too large\n", pkttype);
2176         if (list_mode)
2177           fprintf (listfp, ":attribute packet: [too large]\n");
2178         iobuf_skip_rest (inp, pktlen, 0);
2179         return G10ERR_INVALID_PACKET;
2180       }
2181
2182 #define EXTRA_UID_NAME_SPACE 71
2183     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id
2184                                         + EXTRA_UID_NAME_SPACE);
2185     packet->pkt.user_id->ref=1;
2186     packet->pkt.user_id->attrib_data = xmalloc(pktlen);
2187     packet->pkt.user_id->attrib_len = pktlen;
2188
2189     p = packet->pkt.user_id->attrib_data;
2190     for( ; pktlen; pktlen--, p++ )
2191         *p = iobuf_get_noeof(inp);
2192
2193     /* Now parse out the individual attribute subpackets.  This is
2194        somewhat pointless since there is only one currently defined
2195        attribute type (jpeg), but it is correct by the spec. */
2196     parse_attribute_subpkts(packet->pkt.user_id);
2197
2198     make_attribute_uidname(packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2199
2200     if( list_mode ) {
2201         fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name );
2202     }
2203     return 0;
2204 }
2205
2206
2207 static int
2208 parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2209 {
2210     byte *p;
2211
2212     /* Cap comment packet at a reasonable value to avoid an integer
2213        overflow in the malloc below.  Comment packets are actually not
2214        anymore define my OpenPGP and we even stopped to use our
2215        private comment packet. */
2216     if (pktlen > MAX_COMMENT_PACKET_LENGTH)
2217       {
2218         log_error ("packet(%d) too large\n", pkttype);
2219         iobuf_skip_rest (inp, pktlen, 0);
2220         return G10ERR_INVALID_PACKET;
2221       }
2222     packet->pkt.comment = xmalloc(sizeof *packet->pkt.comment + pktlen - 1);
2223     packet->pkt.comment->len = pktlen;
2224     p = packet->pkt.comment->data;
2225     for( ; pktlen; pktlen--, p++ )
2226         *p = iobuf_get_noeof(inp);
2227
2228     if( list_mode ) {
2229         int n = packet->pkt.comment->len;
2230         fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
2231                                          "OpenPGP draft " : "GnuPG " );
2232         for(p=packet->pkt.comment->data; n; p++, n-- ) {
2233             if( *p >= ' ' && *p <= 'z' )
2234                 putc (*p, listfp);
2235             else
2236                 fprintf (listfp, "\\x%02x", *p );
2237         }
2238         fprintf (listfp, "\"\n");
2239     }
2240     return 0;
2241 }
2242
2243
2244 static void
2245 parse_trust( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
2246 {
2247   int c;
2248
2249   (void)pkttype;
2250
2251   pkt->pkt.ring_trust = xmalloc( sizeof *pkt->pkt.ring_trust );
2252   if (pktlen)
2253     {
2254       c = iobuf_get_noeof(inp);
2255       pktlen--;
2256       pkt->pkt.ring_trust->trustval = c;
2257       pkt->pkt.ring_trust->sigcache = 0;
2258       if (!c && pktlen==1)
2259         {
2260           c = iobuf_get_noeof (inp);
2261           pktlen--;
2262           /* we require that bit 7 of the sigcache is 0 (easier eof handling)*/
2263           if ( !(c & 0x80) )
2264             pkt->pkt.ring_trust->sigcache = c;
2265         }
2266       if( list_mode )
2267         fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2268                pkt->pkt.ring_trust->trustval,
2269                pkt->pkt.ring_trust->sigcache);
2270     }
2271   else
2272     {
2273       pkt->pkt.ring_trust->trustval = 0;
2274       pkt->pkt.ring_trust->sigcache = 0;
2275       if (list_mode)
2276         fprintf (listfp, ":trust packet: empty\n");
2277     }
2278   iobuf_skip_rest (inp, pktlen, 0);
2279 }
2280
2281
2282 static int
2283 parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
2284                  PACKET *pkt, int new_ctb, int partial )
2285 {
2286     int rc = 0;
2287     int mode, namelen;
2288     PKT_plaintext *pt;
2289     byte *p;
2290     int c, i;
2291
2292     if( !partial && pktlen < 6 ) {
2293         log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
2294         rc = G10ERR_INVALID_PACKET;
2295         goto leave;
2296     }
2297     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2298     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2299     /* Note that namelen will never exceeds 255 byte. */
2300     pt = pkt->pkt.plaintext = xmalloc(sizeof *pkt->pkt.plaintext + namelen -1);
2301     pt->new_ctb = new_ctb;
2302     pt->mode = mode;
2303     pt->namelen = namelen;
2304     pt->is_partial = partial;
2305     if( pktlen ) {
2306         for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
2307             pt->name[i] = iobuf_get_noeof(inp);
2308     }
2309     else {
2310         for( i=0; i < namelen; i++ )
2311             if( (c=iobuf_get(inp)) == -1 )
2312                 break;
2313             else
2314                 pt->name[i] = c;
2315     }
2316     pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
2317     pt->len = pktlen;
2318     pt->buf = inp;
2319     pktlen = 0;
2320
2321     if( list_mode ) {
2322         fprintf (listfp, ":literal data packet:\n"
2323                "\tmode %c (%X), created %lu, name=\"",
2324                     mode >= ' ' && mode <'z'? mode : '?', mode,
2325                     (ulong)pt->timestamp );
2326         for(p=pt->name,i=0; i < namelen; p++, i++ ) {
2327             if( *p >= ' ' && *p <= 'z' )
2328                 putc (*p, listfp);
2329             else
2330                 fprintf (listfp, "\\x%02x", *p );
2331         }
2332         fprintf (listfp, "\",\n\traw data: ");
2333         if(partial)
2334           fprintf (listfp, "unknown length\n");
2335         else
2336           fprintf (listfp, "%lu bytes\n", (ulong)pt->len );
2337     }
2338
2339   leave:
2340     return rc;
2341 }
2342
2343
2344 static int
2345 parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
2346                   PACKET *pkt, int new_ctb )
2347 {
2348     PKT_compressed *zd;
2349
2350     /* pktlen is here 0, but data follows
2351      * (this should be the last object in a file or
2352      *  the compress algorithm should know the length)
2353      */
2354     zd = pkt->pkt.compressed =  xmalloc(sizeof *pkt->pkt.compressed );
2355     zd->algorithm = iobuf_get_noeof(inp);
2356     zd->len = 0; /* not used */
2357     zd->new_ctb = new_ctb;
2358     zd->buf = inp;
2359     if( list_mode )
2360         fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2361     return 0;
2362 }
2363
2364
2365 static int
2366 parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
2367                  PACKET *pkt, int new_ctb, int partial )
2368 {
2369     int rc = 0;
2370     PKT_encrypted *ed;
2371     unsigned long orig_pktlen = pktlen;
2372
2373     ed = pkt->pkt.encrypted =  xmalloc(sizeof *pkt->pkt.encrypted );
2374     ed->len = pktlen;
2375     /* we don't know the extralen which is (cipher_blocksize+2)
2376        because the algorithm ist not specified in this packet.
2377        However, it is only important to know this for some sanity
2378        checks on the packet length - it doesn't matter that we can't
2379        do it */
2380     ed->extralen = 0;
2381     ed->buf = NULL;
2382     ed->new_ctb = new_ctb;
2383     ed->is_partial = partial;
2384     ed->mdc_method = 0;
2385     if( pkttype == PKT_ENCRYPTED_MDC ) {
2386         /* fixme: add some pktlen sanity checks */
2387         int version;
2388
2389         version = iobuf_get_noeof(inp);
2390         if (orig_pktlen)
2391             pktlen--;
2392         if( version != 1 ) {
2393             log_error("encrypted_mdc packet with unknown version %d\n",
2394                                                                 version);
2395             /*skip_rest(inp, pktlen); should we really do this? */
2396             rc = G10ERR_INVALID_PACKET;
2397             goto leave;
2398         }
2399         ed->mdc_method = DIGEST_ALGO_SHA1;
2400     }
2401     if( orig_pktlen && pktlen < 10 ) { /* actually this is blocksize+2 */
2402         log_error("packet(%d) too short\n", pkttype);
2403         rc = G10ERR_INVALID_PACKET;
2404         iobuf_skip_rest(inp, pktlen, partial);
2405         goto leave;
2406     }
2407     if( list_mode ) {
2408         if( orig_pktlen )
2409             fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2410                      orig_pktlen);
2411         else
2412             fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2413         if( ed->mdc_method )
2414             fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method );
2415     }
2416
2417     ed->buf = inp;
2418
2419   leave:
2420     return rc;
2421 }
2422
2423
2424 static int
2425 parse_mdc( IOBUF inp, int pkttype, unsigned long pktlen,
2426                                    PACKET *pkt, int new_ctb )
2427 {
2428     int rc = 0;
2429     PKT_mdc *mdc;
2430     byte *p;
2431
2432     mdc = pkt->pkt.mdc=  xmalloc(sizeof *pkt->pkt.mdc );
2433     if( list_mode )
2434         fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2435     if( !new_ctb || pktlen != 20 ) {
2436         log_error("mdc_packet with invalid encoding\n");
2437         rc = G10ERR_INVALID_PACKET;
2438         goto leave;
2439     }
2440     p = mdc->hash;
2441     for( ; pktlen; pktlen--, p++ )
2442         *p = iobuf_get_noeof(inp);
2443
2444   leave:
2445     return rc;
2446 }
2447
2448
2449 /*
2450  * This packet is internally generated by GPG (by armor.c) to
2451  * transfer some information to the lower layer.  To make sure that
2452  * this packet is really a GPG faked one and not one comming from outside,
2453  * we first check that there is a unique tag in it.
2454  * The format of such a control packet is:
2455  *   n byte  session marker
2456  *   1 byte  control type CTRLPKT_xxxxx
2457  *   m byte  control data
2458  */
2459
2460 static int
2461 parse_gpg_control( IOBUF inp, int pkttype,
2462                    unsigned long pktlen, PACKET *packet, int partial )
2463 {
2464     byte *p;
2465     const byte *sesmark;
2466     size_t sesmarklen;
2467     int i;
2468
2469     if ( list_mode )
2470         fprintf (listfp, ":packet 63: length %lu ",  pktlen);
2471
2472     sesmark = get_session_marker ( &sesmarklen );
2473     if ( pktlen < sesmarklen+1 ) /* 1 is for the control bytes */
2474         goto skipit;
2475     for( i=0; i < sesmarklen; i++, pktlen-- ) {
2476         if ( sesmark[i] != iobuf_get_noeof(inp) )
2477             goto skipit;
2478     }
2479     if (pktlen > 4096)
2480       goto skipit; /* Definitely too large.  We skip it to avoid an
2481                       overflow in the malloc. */
2482     if ( list_mode )
2483         puts ("- gpg control packet");
2484
2485     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2486                                       + pktlen - 1);
2487     packet->pkt.gpg_control->control = iobuf_get_noeof(inp); pktlen--;
2488     packet->pkt.gpg_control->datalen = pktlen;
2489     p = packet->pkt.gpg_control->data;
2490     for( ; pktlen; pktlen--, p++ )
2491         *p = iobuf_get_noeof(inp);
2492
2493     return 0;
2494
2495  skipit:
2496     if ( list_mode ) {
2497         int c;
2498
2499         i=0;
2500         fprintf (listfp, "- private (rest length %lu)\n",  pktlen);
2501         if( partial ) {
2502             while( (c=iobuf_get(inp)) != -1 )
2503                 dump_hex_line(c, &i);
2504         }
2505         else {
2506             for( ; pktlen; pktlen-- )
2507               {
2508                 dump_hex_line ((c=iobuf_get (inp)), &i);
2509                 if (c == -1)
2510                   break;
2511               }
2512         }
2513         putc ('\n', listfp);
2514     }
2515     iobuf_skip_rest(inp,pktlen, 0);
2516     return G10ERR_INVALID_PACKET;
2517 }
2518
2519 /* create a gpg control packet to be used internally as a placeholder */
2520 PACKET *
2521 create_gpg_control( ctrlpkttype_t type, const byte *data, size_t datalen )
2522 {
2523     PACKET *packet;
2524     byte *p;
2525
2526     packet = xmalloc( sizeof *packet );
2527     init_packet(packet);
2528     packet->pkttype = PKT_GPG_CONTROL;
2529     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2530                                       + datalen - 1);
2531     packet->pkt.gpg_control->control = type;
2532     packet->pkt.gpg_control->datalen = datalen;
2533     p = packet->pkt.gpg_control->data;
2534     for( ; datalen; datalen--, p++ )
2535         *p = *data++;
2536
2537     return packet;
2538 }