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