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