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