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