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