d792bfff996e50777eb0c5f792c45643a9b88a1e
[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]= mpi_set_opaque(NULL, read_rest(inp, pktlen, 0), pktlen );
1496         pktlen = 0;
1497     }
1498     else {
1499         for( i=0; i < ndata; i++ ) {
1500             n = pktlen;
1501             sig->data[i] = mpi_read(inp, &n, 0 );
1502             pktlen -=n;
1503             if( list_mode ) {
1504                 fprintf (listfp, "\tdata: ");
1505                 mpi_print(listfp, sig->data[i], mpi_print_mode );
1506                 putc ('\n', listfp);
1507             }
1508             if (!sig->data[i])
1509                 rc = G10ERR_INVALID_PACKET;
1510         }
1511     }
1512
1513   leave:
1514     iobuf_skip_rest(inp, pktlen, 0);
1515     return rc;
1516 }
1517
1518
1519 static int
1520 parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
1521                                              PKT_onepass_sig *ops )
1522 {
1523     int version;
1524     int rc = 0;
1525
1526     if( pktlen < 13 ) {
1527         log_error("packet(%d) too short\n", pkttype);
1528         rc = gpg_error (GPG_ERR_INV_PACKET);
1529         goto leave;
1530     }
1531     version = iobuf_get_noeof(inp); pktlen--;
1532     if( version != 3 ) {
1533         log_error("onepass_sig with unknown version %d\n", version);
1534         rc = gpg_error (GPG_ERR_INV_PACKET);
1535         goto leave;
1536     }
1537     ops->sig_class = iobuf_get_noeof(inp); pktlen--;
1538     ops->digest_algo = iobuf_get_noeof(inp); pktlen--;
1539     ops->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1540     ops->keyid[0] = read_32(inp); pktlen -= 4;
1541     ops->keyid[1] = read_32(inp); pktlen -= 4;
1542     ops->last = iobuf_get_noeof(inp); pktlen--;
1543     if( list_mode )
1544         fprintf (listfp, ":onepass_sig packet: keyid %08lX%08lX\n"
1545                "\tversion %d, sigclass %02x, digest %d, pubkey %d, last=%d\n",
1546                 (ulong)ops->keyid[0], (ulong)ops->keyid[1],
1547                 version, ops->sig_class,
1548                 ops->digest_algo, ops->pubkey_algo, ops->last );
1549
1550
1551   leave:
1552     iobuf_skip_rest(inp, pktlen, 0);
1553     return rc;
1554 }
1555
1556
1557 static gcry_mpi_t
1558 read_protected_v3_mpi (IOBUF inp, unsigned long *length)
1559 {
1560   int c;
1561   unsigned int nbits, nbytes;
1562   unsigned char *buf, *p;
1563   gcry_mpi_t val;
1564
1565   if (*length < 2)
1566     {
1567       log_error ("mpi too small\n");
1568       return NULL;
1569     }
1570
1571   if ((c=iobuf_get (inp)) == -1)
1572     return NULL;
1573   --*length;
1574   nbits = c << 8;
1575   if ((c=iobuf_get(inp)) == -1)
1576     return NULL;
1577   --*length;
1578   nbits |= c;
1579
1580   if (nbits > 16384)
1581     {
1582       log_error ("mpi too large (%u bits)\n", nbits);
1583       return NULL;
1584     }
1585   nbytes = (nbits+7) / 8;
1586   buf = p = xmalloc (2 + nbytes);
1587   *p++ = nbits >> 8;
1588   *p++ = nbits;
1589   for (; nbytes && length; nbytes--, --*length)
1590     *p++ = iobuf_get (inp);
1591   if (nbytes)
1592     {
1593       log_error ("packet shorter tham mpi\n");
1594       xfree (buf);
1595       return NULL;
1596     }
1597
1598   /* convert buffer into an opaque MPI */
1599   val = gcry_mpi_set_opaque (NULL, buf, (p-buf)*8); 
1600   return val;
1601 }
1602
1603
1604 static int
1605 parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
1606                               byte *hdr, int hdrlen, PACKET *pkt )
1607 {
1608     int i, version, algorithm;
1609     unsigned n;
1610     unsigned long timestamp, expiredate, max_expiredate;
1611     int npkey, nskey;
1612     int is_v4=0;
1613     int rc=0;
1614
1615     version = iobuf_get_noeof(inp); pktlen--;
1616     if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
1617         /* early versions of G10 use old PGP comments packets;
1618          * luckily all those comments are started by a hash */
1619         if( list_mode ) {
1620             fprintf (listfp, ":rfc1991 comment packet: \"" );
1621             for( ; pktlen; pktlen-- ) {
1622                 int c;
1623                 c = iobuf_get_noeof(inp);
1624                 if( c >= ' ' && c <= 'z' )
1625                     putc (c, listfp);
1626                 else
1627                     fprintf (listfp, "\\x%02x", c );
1628             }
1629             fprintf (listfp, "\"\n");
1630         }
1631         iobuf_skip_rest(inp, pktlen, 0);
1632         return 0;
1633     }
1634     else if( version == 4 )
1635         is_v4=1;
1636     else if( version != 2 && version != 3 ) {
1637         log_error("packet(%d) with unknown version %d\n", pkttype, version);
1638         rc = gpg_error (GPG_ERR_INV_PACKET);
1639         goto leave;
1640     }
1641
1642     if( pktlen < 11 ) {
1643         log_error("packet(%d) too short\n", pkttype);
1644         rc = gpg_error (GPG_ERR_INV_PACKET);
1645         goto leave;
1646     }
1647
1648     timestamp = read_32(inp); pktlen -= 4;
1649     if( is_v4 ) {
1650         expiredate = 0; /* have to get it from the selfsignature */
1651         max_expiredate = 0;
1652     }
1653     else {
1654         unsigned short ndays;
1655         ndays = read_16(inp); pktlen -= 2;
1656         if( ndays )
1657             expiredate = timestamp + ndays * 86400L;
1658         else
1659             expiredate = 0;
1660
1661         max_expiredate=expiredate;
1662     }
1663     algorithm = iobuf_get_noeof(inp); pktlen--;
1664     if( list_mode )
1665         fprintf (listfp, ":%s key packet:\n"
1666                "\tversion %d, algo %d, created %lu, expires %lu\n",
1667                 pkttype == PKT_PUBLIC_KEY? "public" :
1668                 pkttype == PKT_SECRET_KEY? "secret" :
1669                 pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
1670                 pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
1671                 version, algorithm, timestamp, expiredate );
1672
1673     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
1674         PKT_secret_key *sk = pkt->pkt.secret_key;
1675
1676         sk->timestamp = timestamp;
1677         sk->expiredate = expiredate;
1678         sk->max_expiredate = max_expiredate;
1679         sk->hdrbytes = hdrlen;
1680         sk->version = version;
1681         sk->is_primary = pkttype == PKT_SECRET_KEY;
1682         sk->pubkey_algo = algorithm;
1683         sk->req_usage = 0; 
1684         sk->pubkey_usage = 0; /* not yet used */
1685     }
1686     else {
1687         PKT_public_key *pk = pkt->pkt.public_key;
1688
1689         pk->timestamp = timestamp;
1690         pk->expiredate = expiredate;
1691         pk->max_expiredate = max_expiredate;
1692         pk->hdrbytes    = hdrlen;
1693         pk->version     = version;
1694         pk->is_primary = pkttype == PKT_PUBLIC_KEY;
1695         pk->pubkey_algo = algorithm;
1696         pk->req_usage = 0; 
1697         pk->pubkey_usage = 0; /* not yet used */
1698         pk->is_revoked = 0;
1699         pk->is_disabled = 0;
1700         pk->keyid[0] = 0;
1701         pk->keyid[1] = 0;
1702     }
1703     nskey = pubkey_get_nskey( algorithm );
1704     npkey = pubkey_get_npkey( algorithm );
1705     if( !npkey ) {
1706         if( list_mode )
1707             fprintf (listfp, "\tunknown algorithm %d\n", algorithm );
1708         unknown_pubkey_warning( algorithm );
1709     }
1710
1711
1712     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
1713         PKT_secret_key *sk = pkt->pkt.secret_key;
1714         byte temp[16];
1715         size_t snlen = 0;
1716
1717         if( !npkey ) {
1718             sk->skey[0] = mpi_set_opaque( NULL,
1719                                           read_rest(inp, pktlen, 0), pktlen );
1720             pktlen = 0;
1721             goto leave;
1722         }
1723
1724         for(i=0; i < npkey; i++ ) {
1725             n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1726             if( list_mode ) {
1727                 fprintf (listfp,   "\tskey[%d]: ", i);
1728                 mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1729                 putc ('\n', listfp);
1730             }
1731             if (!sk->skey[i])
1732                 rc = G10ERR_INVALID_PACKET;
1733         }
1734         if (rc) /* one of the MPIs were bad */
1735             goto leave;
1736         sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1737         sk->protect.sha1chk = 0;
1738         if( sk->protect.algo ) {
1739             sk->is_protected = 1;
1740             sk->protect.s2k.count = 0;
1741             if( sk->protect.algo == 254 || sk->protect.algo == 255 ) {
1742                 if( pktlen < 3 ) {
1743                     rc = G10ERR_INVALID_PACKET;
1744                     goto leave;
1745                 }
1746                 sk->protect.sha1chk = (sk->protect.algo == 254);
1747                 sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1748                 /* Note that a sk->protect.algo > 110 is illegal, but
1749                    I'm not erroring on it here as otherwise there
1750                    would be no way to delete such a key. */
1751                 sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
1752                 sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
1753                 /* check for the special GNU extension */
1754                 if( is_v4 && sk->protect.s2k.mode == 101 ) {
1755                     for(i=0; i < 4 && pktlen; i++, pktlen-- )
1756                         temp[i] = iobuf_get_noeof(inp);
1757                     if( i < 4 || memcmp( temp, "GNU", 3 ) ) {
1758                         if( list_mode )
1759                             fprintf (listfp,   "\tunknown S2K %d\n",
1760                                                 sk->protect.s2k.mode );
1761                         rc = G10ERR_INVALID_PACKET;
1762                         goto leave;
1763                     }
1764                     /* here we know that it is a gnu extension
1765                      * What follows is the GNU protection mode:
1766                      * All values have special meanings
1767                      * and they are mapped in the mode with a base of 1000.
1768                      */
1769                     sk->protect.s2k.mode = 1000 + temp[3];
1770                 }
1771                 switch( sk->protect.s2k.mode ) {
1772                   case 1:
1773                   case 3:
1774                     for(i=0; i < 8 && pktlen; i++, pktlen-- )
1775                         temp[i] = iobuf_get_noeof(inp);
1776                     memcpy(sk->protect.s2k.salt, temp, 8 );
1777                     break;
1778                 }
1779                 switch( sk->protect.s2k.mode ) {
1780                   case 0: if( list_mode ) fprintf (listfp, "\tsimple S2K" );
1781                     break;
1782                   case 1: if( list_mode ) fprintf (listfp, "\tsalted S2K" );
1783                     break;
1784                   case 3: if( list_mode ) fprintf (listfp, "\titer+salt S2K" );
1785                     break;
1786                   case 1001: if( list_mode ) fprintf (listfp,
1787                                                       "\tgnu-dummy S2K" );
1788                     break;
1789                   case 1002: if (list_mode) fprintf (listfp,
1790                                                   "\tgnu-divert-to-card S2K");
1791                     break;
1792                   default:
1793                     if( list_mode )
1794                         fprintf (listfp,   "\tunknown %sS2K %d\n",
1795                                  sk->protect.s2k.mode < 1000? "":"GNU ",
1796                                                    sk->protect.s2k.mode );
1797                     rc = G10ERR_INVALID_PACKET;
1798                     goto leave;
1799                 }
1800
1801                 if( list_mode ) {
1802                     fprintf (listfp, ", algo: %d,%s hash: %d",
1803                                      sk->protect.algo,
1804                                      sk->protect.sha1chk?" SHA1 protection,"
1805                                                         :" simple checksum,",
1806                                      sk->protect.s2k.hash_algo );
1807                     if( sk->protect.s2k.mode == 1
1808                         || sk->protect.s2k.mode == 3 ) {
1809                         fprintf (listfp, ", salt: ");
1810                         for(i=0; i < 8; i++ )
1811                             fprintf (listfp, "%02x", sk->protect.s2k.salt[i]);
1812                     }
1813                     putc ('\n', listfp);
1814                 }
1815
1816                 if( sk->protect.s2k.mode == 3 ) {
1817                     if( pktlen < 1 ) {
1818                         rc = G10ERR_INVALID_PACKET;
1819                         goto leave;
1820                     }
1821                     sk->protect.s2k.count = iobuf_get(inp);
1822                     pktlen--;
1823                     if( list_mode )
1824                         fprintf (listfp, "\tprotect count: %lu\n",
1825                                             (ulong)sk->protect.s2k.count);
1826                 }
1827                 else if( sk->protect.s2k.mode == 1002 ) {
1828                     /* Read the serial number. */
1829                     if (pktlen < 1) {
1830                       rc = G10ERR_INVALID_PACKET;
1831                         goto leave;
1832                     }
1833                     snlen = iobuf_get (inp);
1834                     pktlen--;
1835                     if (pktlen < snlen || snlen == -1) {
1836                         rc = G10ERR_INVALID_PACKET;
1837                         goto leave;
1838                     }
1839                 }
1840             }
1841             /* Note that a sk->protect.algo > 110 is illegal, but I'm
1842                not erroring on it here as otherwise there would be no
1843                way to delete such a key. */
1844             else { /* old version; no S2K, so we set mode to 0, hash MD5 */
1845                 sk->protect.s2k.mode = 0;
1846                 sk->protect.s2k.hash_algo = DIGEST_ALGO_MD5;
1847                 if( list_mode )
1848                     fprintf (listfp,   "\tprotect algo: %d  (hash algo: %d)\n",
1849                          sk->protect.algo, sk->protect.s2k.hash_algo );
1850             }
1851             /* It is really ugly that we don't know the size
1852              * of the IV here in cases we are not aware of the algorithm.
1853              * so a
1854              *   sk->protect.ivlen = cipher_get_blocksize(sk->protect.algo);
1855              * won't work.  The only solution I see is to hardwire it here.
1856              * NOTE: if you change the ivlen above 16, don't forget to
1857              * enlarge temp.
1858              */
1859             switch( sk->protect.algo ) {
1860               case 7: case 8: case 9: /* reserved for AES */
1861               case 10: /* Twofish */
1862                 sk->protect.ivlen = 16;
1863                 break;
1864               default:
1865                 sk->protect.ivlen = 8;
1866             }
1867             if( sk->protect.s2k.mode == 1001 )
1868                 sk->protect.ivlen = 0;
1869             else if( sk->protect.s2k.mode == 1002 )
1870                 sk->protect.ivlen = snlen < 16? snlen : 16;
1871
1872             if( pktlen < sk->protect.ivlen ) {
1873                 rc = G10ERR_INVALID_PACKET;
1874                 goto leave;
1875             }
1876             for(i=0; i < sk->protect.ivlen && pktlen; i++, pktlen-- )
1877                 temp[i] = iobuf_get_noeof(inp);
1878             if( list_mode ) {
1879                 fprintf (listfp,
1880                          sk->protect.s2k.mode == 1002? "\tserial-number: "
1881                                                      : "\tprotect IV: ");
1882                 for(i=0; i < sk->protect.ivlen; i++ )
1883                     fprintf (listfp, " %02x", temp[i] );
1884                 putc ('\n', listfp);
1885             }
1886             memcpy(sk->protect.iv, temp, sk->protect.ivlen );
1887         }
1888         else
1889             sk->is_protected = 0;
1890         /* It does not make sense to read it into secure memory.
1891          * If the user is so careless, not to protect his secret key,
1892          * we can assume, that he operates an open system :=(.
1893          * So we put the key into secure memory when we unprotect it. */
1894         if( sk->protect.s2k.mode == 1001 
1895             || sk->protect.s2k.mode == 1002 ) {
1896             /* better set some dummy stuff here */
1897             sk->skey[npkey] = mpi_set_opaque(NULL, xstrdup("dummydata"), 10);
1898             pktlen = 0;
1899         }
1900         else if( is_v4 && sk->is_protected ) {
1901             /* ugly; the length is encrypted too, so we read all
1902              * stuff up to the end of the packet into the first
1903              * skey element */
1904             sk->skey[npkey] = mpi_set_opaque(NULL,
1905                                              read_rest(inp, pktlen, 0),pktlen);
1906             pktlen = 0;
1907             if( list_mode ) {
1908                 fprintf (listfp, "\tencrypted stuff follows\n");
1909             }
1910         }
1911         else { /* v3 method: the mpi length is not encrypted */
1912             for(i=npkey; i < nskey; i++ ) {
1913                 if ( sk->is_protected ) {
1914                     sk->skey[i] = read_protected_v3_mpi (inp, &pktlen);
1915                     if( list_mode ) 
1916                         fprintf (listfp,   "\tskey[%d]: [encrypted]\n", i);
1917                 }
1918                 else {
1919                     n = pktlen;
1920                     sk->skey[i] = mpi_read(inp, &n, 0 );
1921                     pktlen -=n;
1922                     if( list_mode ) {
1923                         fprintf (listfp,   "\tskey[%d]: ", i);
1924                         mpi_print(listfp, sk->skey[i], mpi_print_mode  );
1925                         putc ('\n', listfp);
1926                     }
1927                 }
1928
1929                 if (!sk->skey[i])
1930                     rc = G10ERR_INVALID_PACKET;
1931             }
1932             if (rc)
1933                 goto leave;
1934
1935             sk->csum = read_16(inp); pktlen -= 2;
1936             if( list_mode ) {
1937                 fprintf (listfp, "\tchecksum: %04hx\n", sk->csum);
1938             }
1939         }
1940     }
1941     else {
1942         PKT_public_key *pk = pkt->pkt.public_key;
1943
1944         if( !npkey ) {
1945             pk->pkey[0] = mpi_set_opaque( NULL,
1946                                           read_rest(inp, pktlen, 0), pktlen );
1947             pktlen = 0;
1948             goto leave;
1949         }
1950
1951         for(i=0; i < npkey; i++ ) {
1952             n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1953             if( list_mode ) {
1954                 fprintf (listfp,   "\tpkey[%d]: ", i);
1955                 mpi_print(listfp, pk->pkey[i], mpi_print_mode  );
1956                 putc ('\n', listfp);
1957             }
1958             if (!pk->pkey[i])
1959                 rc = G10ERR_INVALID_PACKET;
1960         }
1961         if (rc)
1962             goto leave;
1963     }
1964
1965   leave:
1966     iobuf_skip_rest(inp, pktlen, 0);
1967     return rc;
1968 }
1969
1970 /* Attribute subpackets have the same format as v4 signature
1971    subpackets.  This is not part of OpenPGP, but is done in several
1972    versions of PGP nevertheless. */
1973 int
1974 parse_attribute_subpkts(PKT_user_id *uid)
1975 {
1976   size_t n;
1977   int count=0;
1978   struct user_attribute *attribs=NULL;
1979   const byte *buffer=uid->attrib_data;
1980   int buflen=uid->attrib_len;
1981   byte type;
1982
1983   xfree(uid->attribs);
1984
1985   while(buflen)
1986     {
1987       n = *buffer++; buflen--;
1988       if( n == 255 ) { /* 4 byte length header */
1989         if( buflen < 4 )
1990           goto too_short;
1991         n = (buffer[0] << 24) | (buffer[1] << 16)
1992           | (buffer[2] << 8) | buffer[3];
1993         buffer += 4;
1994         buflen -= 4;
1995       }
1996       else if( n >= 192 ) { /* 2 byte special encoded length header */
1997         if( buflen < 2 )
1998           goto too_short;
1999         n = (( n - 192 ) << 8) + *buffer + 192;
2000         buffer++;
2001         buflen--;
2002       }
2003       if( buflen < n )
2004         goto too_short;
2005
2006       attribs=xrealloc(attribs,(count+1)*sizeof(struct user_attribute));
2007       memset(&attribs[count],0,sizeof(struct user_attribute));
2008
2009       type=*buffer;
2010       buffer++;
2011       buflen--;
2012       n--;
2013
2014       attribs[count].type=type;
2015       attribs[count].data=buffer;
2016       attribs[count].len=n;
2017       buffer+=n;
2018       buflen-=n;
2019       count++;
2020     }
2021
2022   uid->attribs=attribs;
2023   uid->numattribs=count;
2024   return count;
2025
2026  too_short:
2027   if(opt.verbose)
2028     log_info("buffer shorter than attribute subpacket\n");
2029   uid->attribs=attribs;
2030   uid->numattribs=count;
2031   return count;
2032 }
2033
2034
2035 static int
2036 parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2037 {
2038     byte *p;
2039
2040     /* Cap the size of a user ID at 2k: a value absurdly large enough
2041        that there is no sane user ID string (which is printable text
2042        as of RFC2440bis) that won't fit in it, but yet small enough to
2043        avoid allocation problems.  A large pktlen may not be
2044        allocatable, and a very large pktlen could actually cause our
2045        allocation to wrap around in xmalloc to a small number. */
2046
2047     if (pktlen > 2048)
2048       {
2049         log_error ("packet(%d) too large\n", pkttype);
2050         iobuf_skip_rest(inp, pktlen, 0);
2051         return G10ERR_INVALID_PACKET;
2052       }
2053     
2054     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id + pktlen);
2055     packet->pkt.user_id->len = pktlen;
2056     packet->pkt.user_id->ref=1;
2057
2058     p = packet->pkt.user_id->name;
2059     for( ; pktlen; pktlen--, p++ )
2060         *p = iobuf_get_noeof(inp);
2061     *p = 0;
2062
2063     if( list_mode ) {
2064         int n = packet->pkt.user_id->len;
2065         fprintf (listfp, ":user ID packet: \"");
2066         /* fixme: Hey why don't we replace this with print_string?? */
2067         for(p=packet->pkt.user_id->name; n; p++, n-- ) {
2068             if( *p >= ' ' && *p <= 'z' )
2069                 putc (*p, listfp);
2070             else
2071                 fprintf (listfp, "\\x%02x", *p );
2072         }
2073         fprintf (listfp, "\"\n");
2074     }
2075     return 0;
2076 }
2077
2078
2079 void
2080 make_attribute_uidname(PKT_user_id *uid, size_t max_namelen)
2081 {
2082   assert ( max_namelen > 70 );
2083   if(uid->numattribs<=0)
2084     sprintf(uid->name,"[bad attribute packet of size %lu]",uid->attrib_len);
2085   else if(uid->numattribs>1)
2086     sprintf(uid->name,"[%d attributes of size %lu]",
2087             uid->numattribs,uid->attrib_len);
2088   else
2089     {
2090       /* Only one attribute, so list it as the "user id" */
2091
2092       if(uid->attribs->type==ATTRIB_IMAGE)
2093         {
2094           u32 len;
2095           byte type;
2096
2097           if(parse_image_header(uid->attribs,&type,&len))
2098             sprintf(uid->name,"[%.20s image of size %lu]",
2099                     image_type_to_string(type,1),(ulong)len);
2100           else
2101             sprintf(uid->name,"[invalid image]");
2102         }
2103       else
2104         sprintf(uid->name,"[unknown attribute of size %lu]",
2105                 (ulong)uid->attribs->len);
2106     }
2107
2108   uid->len = strlen(uid->name);
2109 }
2110
2111 static int
2112 parse_attribute( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2113 {
2114     byte *p;
2115
2116 #define EXTRA_UID_NAME_SPACE 71
2117     packet->pkt.user_id = xmalloc_clear(sizeof *packet->pkt.user_id
2118                                         + EXTRA_UID_NAME_SPACE);
2119     packet->pkt.user_id->ref=1;
2120     packet->pkt.user_id->attrib_data = xmalloc(pktlen);
2121     packet->pkt.user_id->attrib_len = pktlen;
2122
2123     p = packet->pkt.user_id->attrib_data;
2124     for( ; pktlen; pktlen--, p++ )
2125         *p = iobuf_get_noeof(inp);
2126
2127     /* Now parse out the individual attribute subpackets.  This is
2128        somewhat pointless since there is only one currently defined
2129        attribute type (jpeg), but it is correct by the spec. */
2130     parse_attribute_subpkts(packet->pkt.user_id);
2131
2132     make_attribute_uidname(packet->pkt.user_id, EXTRA_UID_NAME_SPACE);
2133
2134     if( list_mode ) {
2135         fprintf (listfp, ":attribute packet: %s\n", packet->pkt.user_id->name );
2136     }
2137     return 0;
2138 }
2139
2140
2141 static int
2142 parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
2143 {
2144     byte *p;
2145
2146     packet->pkt.comment = xmalloc(sizeof *packet->pkt.comment + pktlen - 1);
2147     packet->pkt.comment->len = pktlen;
2148     p = packet->pkt.comment->data;
2149     for( ; pktlen; pktlen--, p++ )
2150         *p = iobuf_get_noeof(inp);
2151
2152     if( list_mode ) {
2153         int n = packet->pkt.comment->len;
2154         fprintf (listfp, ":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
2155                                          "OpenPGP draft " : "" );
2156         for(p=packet->pkt.comment->data; n; p++, n-- ) {
2157             if( *p >= ' ' && *p <= 'z' )
2158                 putc (*p, listfp);
2159             else
2160                 fprintf (listfp, "\\x%02x", *p );
2161         }
2162         fprintf (listfp, "\"\n");
2163     }
2164     return 0;
2165 }
2166
2167
2168 static void
2169 parse_trust( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
2170 {
2171   int c;
2172
2173   if (pktlen)
2174     {
2175       c = iobuf_get_noeof(inp);
2176       pktlen--;
2177       pkt->pkt.ring_trust = xmalloc( sizeof *pkt->pkt.ring_trust );
2178       pkt->pkt.ring_trust->trustval = c;
2179       pkt->pkt.ring_trust->sigcache = 0;
2180       if (!c && pktlen==1)
2181         {
2182           c = iobuf_get_noeof (inp);
2183           pktlen--;
2184           /* we require that bit 7 of the sigcache is 0 (easier eof handling)*/
2185           if ( !(c & 0x80) )
2186             pkt->pkt.ring_trust->sigcache = c;
2187         }
2188       if( list_mode )
2189         fprintf (listfp, ":trust packet: flag=%02x sigcache=%02x\n",
2190                pkt->pkt.ring_trust->trustval,
2191                pkt->pkt.ring_trust->sigcache);
2192     }
2193   else
2194     {
2195       if( list_mode )
2196         fprintf (listfp, ":trust packet: empty\n");
2197     }
2198   iobuf_skip_rest (inp, pktlen, 0);
2199 }
2200
2201
2202 static int
2203 parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
2204                  PACKET *pkt, int new_ctb, int partial )
2205 {
2206     int rc = 0;
2207     int mode, namelen;
2208     PKT_plaintext *pt;
2209     byte *p;
2210     int c, i;
2211
2212     if( !partial && pktlen < 6 ) {
2213         log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
2214         rc = gpg_error (GPG_ERR_INV_PACKET);
2215         goto leave;
2216     }
2217     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2218     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
2219     pt = pkt->pkt.plaintext = xmalloc(sizeof *pkt->pkt.plaintext + namelen -1);
2220     pt->new_ctb = new_ctb;
2221     pt->mode = mode;
2222     pt->namelen = namelen;
2223     pt->is_partial = partial;
2224     if( pktlen ) {
2225         for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
2226             pt->name[i] = iobuf_get_noeof(inp);
2227     }
2228     else {
2229         for( i=0; i < namelen; i++ )
2230             if( (c=iobuf_get(inp)) == -1 )
2231                 break;
2232             else
2233                 pt->name[i] = c;
2234     }
2235     pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
2236     pt->len = pktlen;
2237     pt->buf = inp;
2238     pktlen = 0;
2239
2240     if( list_mode ) {
2241         fprintf (listfp, ":literal data packet:\n"
2242                "\tmode %c (%X), created %lu, name=\"",
2243                     mode >= ' ' && mode <'z'? mode : '?', mode,
2244                     (ulong)pt->timestamp );
2245         for(p=pt->name,i=0; i < namelen; p++, i++ ) {
2246             if( *p >= ' ' && *p <= 'z' )
2247                 putc (*p, listfp);
2248             else
2249                 fprintf (listfp, "\\x%02x", *p );
2250         }
2251         fprintf (listfp, "\",\n\traw data: ");
2252         if(partial)
2253           fprintf (listfp, "unknown length\n");
2254         else
2255           fprintf (listfp, "%lu bytes\n", (ulong)pt->len );
2256     }
2257
2258   leave:
2259     return rc;
2260 }
2261
2262
2263 static int
2264 parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
2265                   PACKET *pkt, int new_ctb )
2266 {
2267     PKT_compressed *zd;
2268
2269     /* pktlen is here 0, but data follows
2270      * (this should be the last object in a file or
2271      *  the compress algorithm should know the length)
2272      */
2273     zd = pkt->pkt.compressed =  xmalloc(sizeof *pkt->pkt.compressed );
2274     zd->algorithm = iobuf_get_noeof(inp);
2275     zd->len = 0; /* not used */ 
2276     zd->new_ctb = new_ctb;
2277     zd->buf = inp;
2278     if( list_mode )
2279         fprintf (listfp, ":compressed packet: algo=%d\n", zd->algorithm);
2280     return 0;
2281 }
2282
2283
2284 static int
2285 parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
2286                  PACKET *pkt, int new_ctb, int partial )
2287 {
2288     int rc = 0;
2289     PKT_encrypted *ed;
2290     unsigned long orig_pktlen = pktlen;
2291
2292     ed = pkt->pkt.encrypted =  xmalloc(sizeof *pkt->pkt.encrypted );
2293     ed->len = pktlen;
2294     /* we don't know the extralen which is (cipher_blocksize+2)
2295        because the algorithm ist not specified in this packet.
2296        However, it is only important to know this for some sanity
2297        checks on the packet length - it doesn't matter that we can't
2298        do it */
2299     ed->extralen = 0;
2300     ed->buf = NULL;
2301     ed->new_ctb = new_ctb;
2302     ed->is_partial = partial;
2303     ed->mdc_method = 0;
2304     if( pkttype == PKT_ENCRYPTED_MDC ) {
2305         /* fixme: add some pktlen sanity checks */
2306         int version;
2307
2308         version = iobuf_get_noeof(inp); 
2309         if (orig_pktlen)
2310             pktlen--;
2311         if( version != 1 ) {
2312             log_error("encrypted_mdc packet with unknown version %d\n",
2313                                                                 version);
2314             /*skip_rest(inp, pktlen); should we really do this? */
2315             rc = gpg_error (GPG_ERR_INV_PACKET);
2316             goto leave;
2317         }
2318         ed->mdc_method = DIGEST_ALGO_SHA1;
2319     }
2320     if( orig_pktlen && pktlen < 10 ) { /* actually this is blocksize+2 */
2321         log_error("packet(%d) too short\n", pkttype);
2322         rc = G10ERR_INVALID_PACKET;
2323         iobuf_skip_rest(inp, pktlen, partial);
2324         goto leave;
2325     }
2326     if( list_mode ) {
2327         if( orig_pktlen )
2328             fprintf (listfp, ":encrypted data packet:\n\tlength: %lu\n",
2329                      orig_pktlen);
2330         else
2331             fprintf (listfp, ":encrypted data packet:\n\tlength: unknown\n");
2332         if( ed->mdc_method )
2333             fprintf (listfp, "\tmdc_method: %d\n", ed->mdc_method );
2334     }
2335
2336     ed->buf = inp;
2337
2338   leave:
2339     return rc;
2340 }
2341
2342
2343 static int
2344 parse_mdc( IOBUF inp, int pkttype, unsigned long pktlen,
2345                                    PACKET *pkt, int new_ctb )
2346 {
2347     int rc = 0;
2348     PKT_mdc *mdc;
2349     byte *p;
2350
2351     mdc = pkt->pkt.mdc=  xmalloc(sizeof *pkt->pkt.mdc );
2352     if( list_mode )
2353         fprintf (listfp, ":mdc packet: length=%lu\n", pktlen);
2354     if( !new_ctb || pktlen != 20 ) {
2355         log_error("mdc_packet with invalid encoding\n");
2356         rc = gpg_error (GPG_ERR_INV_PACKET);
2357         goto leave;
2358     }
2359     p = mdc->hash;
2360     for( ; pktlen; pktlen--, p++ )
2361         *p = iobuf_get_noeof(inp);
2362
2363   leave:
2364     return rc;
2365 }
2366
2367
2368 /*
2369  * This packet is internally generated by PGG (by armor.c) to
2370  * transfer some information to the lower layer.  To make sure that
2371  * this packet is really a GPG faked one and not one comming from outside,
2372  * we first check that tehre is a unique tag in it.
2373  * The format of such a control packet is:
2374  *   n byte  session marker
2375  *   1 byte  control type CTRLPKT_xxxxx
2376  *   m byte  control data
2377  */
2378
2379 static int
2380 parse_gpg_control( IOBUF inp, int pkttype,
2381                    unsigned long pktlen, PACKET *packet, int partial )
2382 {
2383     byte *p;
2384     const byte *sesmark;
2385     size_t sesmarklen;
2386     int i;
2387
2388     if ( list_mode )
2389         fprintf (listfp, ":packet 63: length %lu ",  pktlen);
2390
2391     sesmark = get_session_marker ( &sesmarklen );
2392     if ( pktlen < sesmarklen+1 ) /* 1 is for the control bytes */
2393         goto skipit;
2394     for( i=0; i < sesmarklen; i++, pktlen-- ) {
2395         if ( sesmark[i] != iobuf_get_noeof(inp) )
2396             goto skipit;
2397     }
2398     if ( list_mode )
2399         puts ("- gpg control packet");
2400
2401     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2402                                       + pktlen - 1);
2403     packet->pkt.gpg_control->control = iobuf_get_noeof(inp); pktlen--;
2404     packet->pkt.gpg_control->datalen = pktlen;
2405     p = packet->pkt.gpg_control->data;
2406     for( ; pktlen; pktlen--, p++ )
2407         *p = iobuf_get_noeof(inp);
2408
2409     return 0;
2410
2411  skipit:
2412     if ( list_mode ) {
2413         int c;
2414
2415         i=0;
2416         fprintf (listfp, "- private (rest length %lu)\n",  pktlen);
2417         if( partial ) {
2418             while( (c=iobuf_get(inp)) != -1 )
2419                 dump_hex_line(c, &i);
2420         }
2421         else {
2422             for( ; pktlen; pktlen-- )
2423                 dump_hex_line(iobuf_get(inp), &i);
2424         }
2425         putc ('\n', listfp);
2426     }
2427     iobuf_skip_rest(inp,pktlen, 0);
2428     return gpg_error (GPG_ERR_INV_PACKET);
2429 }
2430
2431 /* create a gpg control packet to be used internally as a placeholder */
2432 PACKET *
2433 create_gpg_control( ctrlpkttype_t type, const byte *data, size_t datalen )
2434 {
2435     PACKET *packet;
2436     byte *p;
2437
2438     packet = xmalloc( sizeof *packet );
2439     init_packet(packet);
2440     packet->pkttype = PKT_GPG_CONTROL;
2441     packet->pkt.gpg_control = xmalloc(sizeof *packet->pkt.gpg_control
2442                                       + datalen - 1);
2443     packet->pkt.gpg_control->control = type;
2444     packet->pkt.gpg_control->datalen = datalen;
2445     p = packet->pkt.gpg_control->data;
2446     for( ; datalen; datalen--, p++ )
2447         *p = *data++;
2448
2449     return packet;
2450 }