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