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