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