b22a599891f788157694f920ba776a4cb5103fe5
[gnupg.git] / g10 / parse-packet.c
1 /* parse-packet.c  - read packets
2  *      Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 <gcrypt.h>
28 #include "packet.h"
29 #include "iobuf.h"
30 #include "util.h"
31 #include "filter.h"
32 #include "options.h"
33 #include "main.h"
34 #include "i18n.h"
35
36 static int mpi_print_mode = 0;
37 static int list_mode = 0;
38
39 static int  parse( IOBUF inp, PACKET *pkt, int reqtype,
40                    ulong *retpos, int *skip, IOBUF out, int do_skip
41             #ifdef DEBUG_PARSE_PACKET
42                    ,const char *dbg_w, const char *dbg_f, int dbg_l
43             #endif
44                  );
45 static int  copy_packet( IOBUF inp, IOBUF out, int pkttype,
46                                                unsigned long pktlen );
47 static void skip_packet( IOBUF inp, int pkttype, unsigned long pktlen );
48 static void skip_rest( IOBUF inp, unsigned long pktlen );
49 static void *read_rest( IOBUF inp, size_t pktlen );
50 static int  parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
51                                                              PACKET *packet );
52 static int  parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
53                                                              PACKET *packet );
54 static int  parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
55                                                          PKT_signature *sig );
56 static int  parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
57                                                         PKT_onepass_sig *ops );
58 static int  parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
59                                       byte *hdr, int hdrlen, PACKET *packet );
60 static int  parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen,
61                                                            PACKET *packet );
62 static int  parse_photo_id( IOBUF inp, int pkttype, unsigned long pktlen,
63                                                            PACKET *packet );
64 static int  parse_comment( IOBUF inp, int pkttype, unsigned long pktlen,
65                                                            PACKET *packet );
66 static void parse_trust( IOBUF inp, int pkttype, unsigned long pktlen,
67                                                            PACKET *packet );
68 static int  parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
69                                                PACKET *packet, int new_ctb);
70 static int  parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
71                                                PACKET *packet, int new_ctb );
72 static int  parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
73                                                PACKET *packet, int new_ctb);
74 static int  parse_mdc( IOBUF inp, int pkttype, unsigned long pktlen,
75                                                PACKET *packet, int new_ctb);
76
77 static unsigned short
78 read_16(IOBUF inp)
79 {
80     unsigned short a;
81     a = iobuf_get_noeof(inp) << 8;
82     a |= iobuf_get_noeof(inp);
83     return a;
84 }
85
86 static unsigned long
87 read_32(IOBUF inp)
88 {
89     unsigned long a;
90     a =  iobuf_get_noeof(inp) << 24;
91     a |= iobuf_get_noeof(inp) << 16;
92     a |= iobuf_get_noeof(inp) << 8;
93     a |= iobuf_get_noeof(inp);
94     return a;
95 }
96
97
98 int
99 set_packet_list_mode( int mode )
100 {
101     int old = list_mode;
102     list_mode = mode;
103     mpi_print_mode = (opt.debug & DBG_MPI_VALUE);
104     return old;
105 }
106
107 static void
108 unknown_pubkey_warning( int algo )
109 {
110     static byte unknown_pubkey_algos[256];
111
112     algo &= 0xff;
113     if( !unknown_pubkey_algos[algo] ) {
114         if( opt.verbose )
115             log_info(_("can't handle public key algorithm %d\n"), algo );
116         unknown_pubkey_algos[algo] = 1;
117     }
118 }
119
120 /****************
121  * Parse a Packet and return it in packet
122  * Returns: 0 := valid packet in pkt
123  *         -1 := no more packets
124  *         >0 := error
125  * Note: The function may return an error and a partly valid packet;
126  * caller must free this packet.
127  */
128 #ifdef DEBUG_PARSE_PACKET
129 int
130 dbg_parse_packet( IOBUF inp, PACKET *pkt, ulong *retpos,
131                   const char *dbg_f, int dbg_l )
132 {
133     int skip, rc;
134
135     do {
136         rc = parse( inp, pkt, 0, retpos,
137                     &skip, NULL, 0, "parse", dbg_f, dbg_l );
138     } while( skip );
139     return rc;
140 }
141 #else
142 int
143 parse_packet( IOBUF inp, PACKET *pkt, ulong *retpos )
144 {
145     int skip, rc;
146
147     do {
148         rc = parse( inp, pkt, 0, retpos, &skip, NULL, 0 );
149     } while( skip );
150     return rc;
151 }
152 #endif
153
154 /****************
155  * Like parse packet, but only return packets of the given type.
156  */
157 #ifdef DEBUG_PARSE_PACKET
158 int
159 dbg_search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos,
160                    const char *dbg_f, int dbg_l )
161 {
162     int skip, rc;
163
164     do {
165         rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0, "search", dbg_f, dbg_l );
166     } while( skip );
167     return rc;
168 }
169 #else
170 int
171 search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos )
172 {
173     int skip, rc;
174
175     do {
176         rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0 );
177     } while( skip );
178     return rc;
179 }
180 #endif
181
182 /****************
183  * Copy all packets from INP to OUT, thereby removing unused spaces.
184  */
185 #ifdef DEBUG_PARSE_PACKET
186 int
187 dbg_copy_all_packets( IOBUF inp, IOBUF out,
188                    const char *dbg_f, int dbg_l )
189 {
190     PACKET pkt;
191     int skip, rc=0;
192     do {
193         init_packet(&pkt);
194     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0, "copy", dbg_f, dbg_l )));
195     return rc;
196 }
197 #else
198 int
199 copy_all_packets( IOBUF inp, IOBUF out )
200 {
201     PACKET pkt;
202     int skip, rc=0;
203     do {
204         init_packet(&pkt);
205     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )));
206     return rc;
207 }
208 #endif
209
210 /****************
211  * Copy some packets from INP to OUT, thereby removing unused spaces.
212  * Stop at offset STOPoff (i.e. don't copy packets at this or later offsets)
213  */
214 #ifdef DEBUG_PARSE_PACKET
215 int
216 dbg_copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff,
217                    const char *dbg_f, int dbg_l )
218 {
219     PACKET pkt;
220     int skip, rc=0;
221     do {
222         if( iobuf_tell(inp) >= stopoff )
223             return 0;
224         init_packet(&pkt);
225     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0,
226                                      "some", dbg_f, dbg_l )) );
227     return rc;
228 }
229 #else
230 int
231 copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff )
232 {
233     PACKET pkt;
234     int skip, rc=0;
235     do {
236         if( iobuf_tell(inp) >= stopoff )
237             return 0;
238         init_packet(&pkt);
239     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )) );
240     return rc;
241 }
242 #endif
243
244 /****************
245  * Skip over N packets
246  */
247 #ifdef DEBUG_PARSE_PACKET
248 int
249 dbg_skip_some_packets( IOBUF inp, unsigned n,
250                    const char *dbg_f, int dbg_l )
251 {
252     int skip, rc=0;
253     PACKET pkt;
254
255     for( ;n && !rc; n--) {
256         init_packet(&pkt);
257         rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1, "skip", dbg_f, dbg_l );
258     }
259     return rc;
260 }
261 #else
262 int
263 skip_some_packets( IOBUF inp, unsigned n )
264 {
265     int skip, rc=0;
266     PACKET pkt;
267
268     for( ;n && !rc; n--) {
269         init_packet(&pkt);
270         rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1 );
271     }
272     return rc;
273 }
274 #endif
275
276
277 /****************
278  * Parse packet. Set the variable skip points to to 1 if the packet
279  * should be skipped; this is the case if either there is a
280  * requested packet type and the parsed packet doesn't match or the
281  * packet-type is 0, indicating deleted stuff.
282  * if OUT is not NULL, a special copymode is used.
283  */
284 static int
285 parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
286        int *skip, IOBUF out, int do_skip
287 #ifdef DEBUG_PARSE_PACKET
288        ,const char *dbg_w, const char *dbg_f, int dbg_l
289 #endif
290      )
291 {
292     int rc=0, c, ctb, pkttype, lenbytes;
293     unsigned long pktlen;
294     byte hdr[8];
295     int hdrlen;
296     int new_ctb = 0;
297
298     *skip = 0;
299     assert( !pkt->pkt.generic );
300     if( retpos )
301         *retpos = iobuf_tell(inp);
302
303     if( (ctb = iobuf_get(inp)) == -1 ) {
304         rc = -1;
305         goto leave;
306     }
307     hdrlen=0;
308     hdr[hdrlen++] = ctb;
309     if( !(ctb & 0x80) ) {
310         log_error("%s: invalid packet (ctb=%02x) near %lu\n",
311                             iobuf_where(inp), ctb, iobuf_tell(inp) );
312         rc = GPGERR_INVALID_PACKET;
313         goto leave;
314     }
315     pktlen = 0;
316     new_ctb = !!(ctb & 0x40);
317     if( new_ctb ) {
318         pkttype =  ctb & 0x3f;
319         if( (c = iobuf_get(inp)) == -1 ) {
320             log_error("%s: 1st length byte missing\n", iobuf_where(inp) );
321             rc = GPGERR_INVALID_PACKET;
322             goto leave;
323         }
324         hdr[hdrlen++] = c;
325         if( c < 192 )
326             pktlen = c;
327         else if( c < 224 ) {
328             pktlen = (c - 192) * 256;
329             if( (c = iobuf_get(inp)) == -1 ) {
330                 log_error("%s: 2nd length byte missing\n", iobuf_where(inp) );
331                 rc = GPGERR_INVALID_PACKET;
332                 goto leave;
333             }
334             hdr[hdrlen++] = c;
335             pktlen += c + 192;
336         }
337         else if( c == 255 ) {
338             pktlen  = (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 24;
339             pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 16;
340             pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 8;
341             if( (c = iobuf_get(inp)) == -1 ) {
342                 log_error("%s: 4 byte length invalid\n", iobuf_where(inp) );
343                 rc = GPGERR_INVALID_PACKET;
344                 goto leave;
345             }
346             pktlen |= (hdr[hdrlen++] = c );
347         }
348         else { /* partial body length */
349             iobuf_set_partial_block_mode(inp, c & 0xff);
350             pktlen = 0;/* to indicate partial length */
351         }
352     }
353     else {
354         pkttype = (ctb>>2)&0xf;
355         lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
356         if( !lenbytes ) {
357             pktlen = 0; /* don't know the value */
358             if( pkttype != PKT_COMPRESSED )
359                 iobuf_set_block_mode(inp, 1);
360         }
361         else {
362             for( ; lenbytes; lenbytes-- ) {
363                 pktlen <<= 8;
364                 pktlen |= hdr[hdrlen++] = iobuf_get_noeof(inp);
365             }
366         }
367     }
368
369     if( out && pkttype  ) {
370         if( iobuf_write( out, hdr, hdrlen ) == -1 )
371             rc = GPGERR_WRITE_FILE;
372         else
373             rc = copy_packet(inp, out, pkttype, pktlen );
374         goto leave;
375     }
376
377     if( do_skip || !pkttype || (reqtype && pkttype != reqtype) ) {
378         skip_rest(inp, pktlen);
379         *skip = 1;
380         rc = 0;
381         goto leave;
382     }
383
384     if( DBG_PACKET ) {
385       #ifdef DEBUG_PARSE_PACKET
386         log_debug("parse_packet(iob=%d): type=%d length=%lu%s (%s.%s.%d)\n",
387                    iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"",
388                     dbg_w, dbg_f, dbg_l );
389       #else
390         log_debug("parse_packet(iob=%d): type=%d length=%lu%s\n",
391                    iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"" );
392       #endif
393     }
394     pkt->pkttype = pkttype;
395     rc = GPGERR_UNKNOWN_PACKET; /* default error */
396     switch( pkttype ) {
397       case PKT_PUBLIC_KEY:
398       case PKT_PUBLIC_SUBKEY:
399         pkt->pkt.public_key = gcry_xcalloc( 1,sizeof *pkt->pkt.public_key );
400         rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
401         break;
402       case PKT_SECRET_KEY:
403       case PKT_SECRET_SUBKEY:
404         pkt->pkt.secret_key = gcry_xcalloc( 1,sizeof *pkt->pkt.secret_key );
405         rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
406         break;
407       case PKT_SYMKEY_ENC:
408         rc = parse_symkeyenc( inp, pkttype, pktlen, pkt );
409         break;
410       case PKT_PUBKEY_ENC:
411         rc = parse_pubkeyenc(inp, pkttype, pktlen, pkt );
412         break;
413       case PKT_SIGNATURE:
414         pkt->pkt.signature = gcry_xcalloc( 1,sizeof *pkt->pkt.signature );
415         rc = parse_signature(inp, pkttype, pktlen, pkt->pkt.signature );
416         break;
417       case PKT_ONEPASS_SIG:
418         pkt->pkt.onepass_sig = gcry_xcalloc( 1,sizeof *pkt->pkt.onepass_sig );
419         rc = parse_onepass_sig(inp, pkttype, pktlen, pkt->pkt.onepass_sig );
420         break;
421       case PKT_USER_ID:
422         rc = parse_user_id(inp, pkttype, pktlen, pkt );
423         break;
424       case PKT_PHOTO_ID:
425         pkt->pkttype = pkttype = PKT_USER_ID;  /* must fix it */
426         rc = parse_photo_id(inp, pkttype, pktlen, pkt);
427         break;
428       case PKT_OLD_COMMENT:
429       case PKT_COMMENT:
430         rc = parse_comment(inp, pkttype, pktlen, pkt);
431         break;
432       case PKT_RING_TRUST:
433         parse_trust(inp, pkttype, pktlen, pkt);
434         rc = 0;
435         break;
436       case PKT_PLAINTEXT:
437         rc = parse_plaintext(inp, pkttype, pktlen, pkt, new_ctb );
438         break;
439       case PKT_COMPRESSED:
440         rc = parse_compressed(inp, pkttype, pktlen, pkt, new_ctb );
441         break;
442       case PKT_ENCRYPTED:
443       case PKT_ENCRYPTED_MDC:
444         rc = parse_encrypted(inp, pkttype, pktlen, pkt, new_ctb );
445         break;
446       case PKT_MDC:
447         rc = parse_mdc(inp, pkttype, pktlen, pkt, new_ctb );
448         break;
449       default:
450         skip_packet(inp, pkttype, pktlen);
451         break;
452     }
453
454   leave:
455     if( !rc && iobuf_error(inp) )
456         rc = GPGERR_INV_KEYRING;
457     return rc;
458 }
459
460 static void
461 dump_hex_line( int c, int *i )
462 {
463     if( *i && !(*i%8) ) {
464         if( *i && !(*i%24) )
465             printf("\n%4d:", *i );
466         else
467             putchar(' ');
468     }
469     if( c == -1 )
470         printf(" EOF" );
471     else
472         printf(" %02x", c );
473     ++*i;
474 }
475
476
477 static int
478 copy_packet( IOBUF inp, IOBUF out, int pkttype, unsigned long pktlen )
479 {
480     int n;
481     char buf[100];
482
483     if( iobuf_in_block_mode(inp) ) {
484         while( (n = iobuf_read( inp, buf, 100 )) != -1 )
485             if( iobuf_write(out, buf, n ) )
486                 return GPGERR_WRITE_FILE; /* write error */
487     }
488     else if( !pktlen && pkttype == PKT_COMPRESSED ) {
489         log_debug("copy_packet: compressed!\n");
490         /* compressed packet, copy till EOF */
491         while( (n = iobuf_read( inp, buf, 100 )) != -1 )
492             if( iobuf_write(out, buf, n ) )
493                 return GPGERR_WRITE_FILE; /* write error */
494     }
495     else {
496         for( ; pktlen; pktlen -= n ) {
497             n = pktlen > 100 ? 100 : pktlen;
498             n = iobuf_read( inp, buf, n );
499             if( n == -1 )
500                 return GPGERR_READ_FILE;
501             if( iobuf_write(out, buf, n ) )
502                 return GPGERR_WRITE_FILE; /* write error */
503         }
504     }
505     return 0;
506 }
507
508
509 static void
510 skip_packet( IOBUF inp, int pkttype, unsigned long pktlen )
511 {
512     if( list_mode ) {
513         if( pkttype == PKT_MARKER )
514             fputs(":marker packet:\n", stdout );
515         else
516             printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen);
517         if( pkttype ) {
518             int c, i=0 ;
519             if( pkttype != PKT_MARKER )
520                 fputs("dump:", stdout );
521             if( iobuf_in_block_mode(inp) ) {
522                 while( (c=iobuf_get(inp)) != -1 )
523                     dump_hex_line(c, &i);
524             }
525             else {
526                 for( ; pktlen; pktlen-- )
527                     dump_hex_line(iobuf_get(inp), &i);
528             }
529             putchar('\n');
530             return;
531         }
532     }
533     skip_rest(inp,pktlen);
534 }
535
536 static void
537 skip_rest( IOBUF inp, unsigned long pktlen )
538 {
539     if( iobuf_in_block_mode(inp) ) {
540         while( iobuf_get(inp) != -1 )
541                 ;
542     }
543     else {
544         for( ; pktlen; pktlen-- )
545             if( iobuf_get(inp) == -1 )
546                 break;
547     }
548 }
549
550
551 static void *
552 read_rest( IOBUF inp, size_t pktlen )
553 {
554     byte *p;
555     int i;
556
557     if( iobuf_in_block_mode(inp) ) {
558         log_error("read_rest: can't store stream data\n");
559         p = NULL;
560     }
561     else {
562         p = gcry_xmalloc( pktlen );
563         for(i=0; pktlen; pktlen--, i++ )
564             p[i] = iobuf_get(inp);
565     }
566     return p;
567 }
568
569
570
571 static int
572 parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
573 {
574     PKT_symkey_enc *k;
575     int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
576
577     if( pktlen < 4 ) {
578         log_error("packet(%d) too short\n", pkttype);
579         goto leave;
580     }
581     version = iobuf_get_noeof(inp); pktlen--;
582     if( version != 4 ) {
583         log_error("packet(%d) with unknown version %d\n", pkttype, version);
584         goto leave;
585     }
586     if( pktlen > 200 ) { /* (we encode the seskeylen in a byte) */
587         log_error("packet(%d) too large\n", pkttype);
588         goto leave;
589     }
590     cipher_algo = iobuf_get_noeof(inp); pktlen--;
591     s2kmode = iobuf_get_noeof(inp); pktlen--;
592     hash_algo = iobuf_get_noeof(inp); pktlen--;
593     switch( s2kmode ) {
594       case 0:  /* simple s2k */
595         minlen = 0;
596         break;
597       case 1:  /* salted s2k */
598         minlen = 8;
599         break;
600       case 3:  /* iterated+salted s2k */
601         minlen = 9;
602         break;
603       default:
604         log_error("unknown S2K %d\n", s2kmode );
605         goto leave;
606     }
607     if( minlen > pktlen ) {
608         log_error("packet with S2K %d too short\n", s2kmode );
609         goto leave;
610     }
611     seskeylen = pktlen - minlen;
612     k = packet->pkt.symkey_enc = gcry_xcalloc( 1, sizeof *packet->pkt.symkey_enc
613                                                 + seskeylen - 1 );
614     k->version = version;
615     k->cipher_algo = cipher_algo;
616     k->s2k.mode = s2kmode;
617     k->s2k.hash_algo = hash_algo;
618     if( s2kmode == 1 || s2kmode == 3 ) {
619         for(i=0; i < 8 && pktlen; i++, pktlen-- )
620             k->s2k.salt[i] = iobuf_get_noeof(inp);
621     }
622     if( s2kmode == 3 ) {
623         k->s2k.count = iobuf_get(inp); pktlen--;
624     }
625     k->seskeylen = seskeylen;
626     for(i=0; i < seskeylen && pktlen; i++, pktlen-- )
627         k->seskey[i] = iobuf_get_noeof(inp);
628     assert( !pktlen );
629
630     if( list_mode ) {
631         printf(":symkey enc packet: version %d, cipher %d, s2k %d, hash %d\n",
632                             version, cipher_algo, s2kmode, hash_algo);
633         if( s2kmode == 1 || s2kmode == 3 ) {
634             printf("\tsalt ");
635             for(i=0; i < 8; i++ )
636                 printf("%02x", k->s2k.salt[i]);
637             if( s2kmode == 3 )
638                 printf(", count %lu\n", (ulong)k->s2k.count );
639             printf("\n");
640         }
641     }
642
643   leave:
644     skip_rest(inp, pktlen);
645     return 0;
646 }
647
648 static int
649 parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
650 {
651     unsigned n;
652     int i, ndata;
653     PKT_pubkey_enc *k;
654
655     k = packet->pkt.pubkey_enc = gcry_xcalloc( 1,sizeof *packet->pkt.pubkey_enc);
656     if( pktlen < 12 ) {
657         log_error("packet(%d) too short\n", pkttype);
658         goto leave;
659     }
660     k->version = iobuf_get_noeof(inp); pktlen--;
661     if( k->version != 2 && k->version != 3 ) {
662         log_error("packet(%d) with unknown version %d\n", pkttype, k->version);
663         goto leave;
664     }
665     k->keyid[0] = read_32(inp); pktlen -= 4;
666     k->keyid[1] = read_32(inp); pktlen -= 4;
667     k->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
668     k->throw_keyid = 0; /* only used as flag for build_packet */
669     if( list_mode )
670         printf(":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
671           k->version, k->pubkey_algo, (ulong)k->keyid[0], (ulong)k->keyid[1]);
672
673     ndata = pubkey_get_nenc(k->pubkey_algo);
674     if( !ndata ) {
675         if( list_mode )
676             printf("\tunsupported algorithm %d\n", k->pubkey_algo );
677         unknown_pubkey_warning( k->pubkey_algo );
678         k->data[0] = NULL;  /* no need to store the encrypted data */
679     }
680     else {
681         for( i=0; i < ndata; i++ ) {
682             n = pktlen;
683             k->data[i] = mpi_read(inp, &n, 0); pktlen -=n;
684             if( list_mode ) {
685                 printf("\tdata: ");
686                 mpi_print(stdout, k->data[i], mpi_print_mode );
687                 putchar('\n');
688             }
689         }
690     }
691
692   leave:
693     skip_rest(inp, pktlen);
694     return 0;
695 }
696
697
698 static void
699 dump_sig_subpkt( int hashed, int type, int critical,
700                  const byte *buffer, size_t buflen, size_t length )
701 {
702     const char *p=NULL;
703     int i;
704
705     /* The CERT has warning out with explains how to use GNUPG to
706      * detect the ARRs - we print our old message here when it is a faked
707      * ARR and add an additional notice */
708     if ( type == SIGSUBPKT_ARR && !hashed ) {
709         printf("\tsubpkt %d len %u (additional recipient request)\n"
710                "WARNING: PGP versions > 5.0 and < 6.5.8 will automagically "
711                "encrypt to this key and thereby reveal the plaintext to "
712                "the owner of this ARR key. Detailed info follows:\n",
713                type, (unsigned)length );
714     }
715     
716     printf("\t%s%ssubpkt %d len %u (", /*)*/
717               critical ? "critical ":"",
718               hashed ? "hashed ":"", type, (unsigned)length );
719     buffer++;
720     length--;
721     if( length > buflen ) {
722         printf("too short: buffer is only %u)\n", (unsigned)buflen );
723         return;
724     }
725     switch( type ) {
726       case SIGSUBPKT_SIG_CREATED:
727         if( length >= 4 )
728             printf("sig created %s", strtimestamp( buffer_to_u32(buffer) ) );
729         break;
730       case SIGSUBPKT_SIG_EXPIRE:
731         if( length >= 4 )
732             printf("sig expires after %s",
733                                      strtimevalue( buffer_to_u32(buffer) ) );
734         break;
735       case SIGSUBPKT_EXPORTABLE:
736         if( length )
737             printf("%sexportable", *buffer? "":"not ");
738         break;
739       case SIGSUBPKT_TRUST:
740         p = "trust signature";
741         break;
742       case SIGSUBPKT_REGEXP:
743         p = "regular expression";
744         break;
745       case SIGSUBPKT_REVOCABLE:
746         p = "revocable";
747         break;
748       case SIGSUBPKT_KEY_EXPIRE:
749         if( length >= 4 )
750             printf("key expires after %s",
751                                     strtimevalue( buffer_to_u32(buffer) ) );
752         break;
753       case SIGSUBPKT_PREF_SYM:
754         fputs("pref-sym-algos:", stdout );
755         for( i=0; i < length; i++ )
756             printf(" %d", buffer[i] );
757         break;
758       case SIGSUBPKT_REV_KEY:
759         fputs("revocation key: ", stdout );
760         if( length < 22 )
761             p = "[too short]";
762         else {
763             printf("c=%02x a=%d f=", buffer[0], buffer[1] );
764             for( i=2; i < length; i++ )
765                 printf("%02X", buffer[i] );
766         }
767         break;
768       case SIGSUBPKT_ISSUER:
769         if( length >= 8 )
770             printf("issuer key ID %08lX%08lX",
771                       (ulong)buffer_to_u32(buffer),
772                       (ulong)buffer_to_u32(buffer+4) );
773         break;
774       case SIGSUBPKT_NOTATION:
775         {
776             fputs("notation: ", stdout );
777             if( length < 8 )
778                 p = "[too short]";
779             else if( !(*buffer & 0x80) )
780                 p = "[not human readable]";
781             else {
782                 const byte *s = buffer;
783                 size_t n1, n2;
784
785                 n1 = (s[4] << 8) | s[5];
786                 n2 = (s[6] << 8) | s[7];
787                 s += 8;
788                 if( 8+n1+n2 != length )
789                     p = "[error]";
790                 else {
791                     print_string( stdout, s, n1, ')' );
792                     putc( '=', stdout );
793                     print_string( stdout, s+n1, n2, ')' );
794                 }
795             }
796         }
797         break;
798       case SIGSUBPKT_PREF_HASH:
799         fputs("pref-hash-algos:", stdout );
800         for( i=0; i < length; i++ )
801             printf(" %d", buffer[i] );
802         break;
803       case SIGSUBPKT_PREF_COMPR:
804         fputs("pref-zip-algos:", stdout );
805         for( i=0; i < length; i++ )
806             printf(" %d", buffer[i] );
807         break;
808       case SIGSUBPKT_KS_FLAGS:
809         p = "key server preferences";
810         break;
811       case SIGSUBPKT_PREF_KS:
812         p = "preferred key server";
813         break;
814       case SIGSUBPKT_PRIMARY_UID:
815         p = "primary user ID";
816         break;
817       case SIGSUBPKT_POLICY:
818         fputs("policy: ", stdout );
819         print_string( stdout, buffer, length, ')' );
820         break;
821       case SIGSUBPKT_KEY_FLAGS:
822         fputs ( "key flags:", stdout );
823         for( i=0; i < length; i++ )
824             printf(" %02X", buffer[i] );
825         break;
826       case SIGSUBPKT_SIGNERS_UID:
827         p = "signer's user ID";
828         break;
829       case SIGSUBPKT_REVOC_REASON:
830         if( length ) {
831             printf("revocation reason 0x%02x (", *buffer );
832             print_string( stdout, buffer+1, length-1, ')' );
833             p = ")";
834         }
835         break;
836       case SIGSUBPKT_ARR:
837         fputs("Big Brother's key (ignored): ", stdout );
838         if( length < 22 )
839             p = "[too short]";
840         else {
841             printf("c=%02x a=%d f=", buffer[0], buffer[1] );
842             for( i=2; i < length; i++ )
843                 printf("%02X", buffer[i] );
844         }
845         break;
846       case SIGSUBPKT_PRIV_ADD_SIG:
847         p = "signs additional user ID";
848         break;
849       default: p = "?"; break;
850     }
851
852     printf("%s)\n", p? p: "");
853 }
854
855 /****************
856  * Returns: >= 0 offset into buffer
857  *          -1 unknown type
858  *          -2 unsupported type
859  *          -3 subpacket too short
860  */
861 static int
862 parse_one_sig_subpkt( const byte *buffer, size_t n, int type )
863 {
864     switch( type ) {
865       case SIGSUBPKT_SIG_CREATED:
866       case SIGSUBPKT_SIG_EXPIRE:
867       case SIGSUBPKT_KEY_EXPIRE:
868         if( n < 4 )
869             break;
870         return 0;
871       case SIGSUBPKT_KEY_FLAGS:
872           return 0;  
873       case SIGSUBPKT_EXPORTABLE:
874         if( !n )
875             break;
876         return 0;
877       case SIGSUBPKT_ISSUER:/* issuer key ID */
878         if( n < 8 )
879             break;
880         return 0;
881       case SIGSUBPKT_NOTATION:
882         if( n < 8 ) /* minimum length needed */
883             break;
884         return 0;
885       case SIGSUBPKT_REVOC_REASON:
886         if( !n  )
887             break;
888         return 0;
889       case SIGSUBPKT_PREF_SYM:
890       case SIGSUBPKT_PREF_HASH:
891       case SIGSUBPKT_PREF_COMPR:
892       case SIGSUBPKT_POLICY:
893         return 0;
894       case SIGSUBPKT_PRIMARY_UID:
895           if ( n != 1 )
896               break;
897           return 0;   
898       case SIGSUBPKT_PRIV_ADD_SIG:
899         /* because we use private data, we check the GNUPG marker */
900         if( n < 24 )
901             break;
902         if( buffer[0] != 'G' || buffer[1] != 'P' || buffer[2] != 'G' )
903             return -2;
904         return 3;
905       default: return -1;
906     }
907     return -3;
908 }
909
910
911 static int
912 can_handle_critical( const byte *buffer, size_t n, int type )
913 {
914     switch( type ) {
915       case SIGSUBPKT_NOTATION:
916         if( n >= 8 && (*buffer & 0x80) )
917             return 1; /* human readable is handled */
918         return 0;
919
920       case SIGSUBPKT_SIG_CREATED:
921       case SIGSUBPKT_SIG_EXPIRE:
922       case SIGSUBPKT_KEY_EXPIRE:
923       case SIGSUBPKT_EXPORTABLE:
924       case SIGSUBPKT_ISSUER:/* issuer key ID */
925       case SIGSUBPKT_PREF_SYM:
926       case SIGSUBPKT_PREF_HASH:
927       case SIGSUBPKT_PREF_COMPR:
928       case SIGSUBPKT_KEY_FLAGS:
929         return 1;
930
931       case SIGSUBPKT_POLICY: /* Is it enough to show the policy? */
932       default:
933         return 0;
934     }
935 }
936
937
938 const byte *
939 enum_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype,
940                  size_t *ret_n, int *start )
941 {
942     int buflen;
943     int type;
944     int critical;
945     int offset;
946     size_t n;
947     int seq = 0;
948     int reqseq = start? *start: 0;
949
950     if( !buffer || reqseq == -1 ) {
951         /* return some value different from NULL to indicate that
952          * there is no crtitical bit we do not understand.  The caller
953          * will never use the value.  Yes I know, it is an ugly hack */
954         return reqtype == SIGSUBPKT_TEST_CRITICAL? (const byte*)&buffer : NULL;
955     }
956     buflen = (*buffer << 8) | buffer[1];
957     buffer += 2;
958     while( buflen ) {
959         n = *buffer++; buflen--;
960         if( n == 255 ) {
961             if( buflen < 4 )
962                 goto too_short;
963             n = (buffer[0] << 24) | (buffer[1] << 16)
964                                   | (buffer[2] << 8) | buffer[3];
965             buffer += 4;
966             buflen -= 4;
967
968         }
969         else if( n >= 192 ) {
970             if( buflen < 2 )
971                 goto too_short;
972             n = (( n - 192 ) << 8) + *buffer + 192;
973             buffer++;
974             buflen--;
975         }
976         if( buflen < n )
977             goto too_short;
978         type = *buffer;
979         if( type & 0x80 ) {
980             type &= 0x7f;
981             critical = 1;
982         }
983         else
984             critical = 0;
985         if( !(++seq > reqseq) )
986             ;
987         else if( reqtype == SIGSUBPKT_TEST_CRITICAL ) {
988             if( critical ) {
989                 if( n-1 > buflen+1 )
990                     goto too_short;
991                 if( !can_handle_critical(buffer+1, n-1, type ) ) {
992                     log_info(_("subpacket of type %d has critical bit set\n"),
993                                                                         type);
994                     if( start )
995                         *start = seq;
996                     return NULL; /* this is an error */
997                 }
998             }
999         }
1000         else if( reqtype < 0 ) /* list packets */
1001             dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
1002                                     type, critical, buffer, buflen, n );
1003         else if( type == reqtype ) { /* found */
1004             buffer++;
1005             n--;
1006             if( n > buflen )
1007                 goto too_short;
1008             if( ret_n )
1009                 *ret_n = n;
1010             offset = parse_one_sig_subpkt(buffer, n, type );
1011             switch( offset ) {
1012               case -3:
1013                 log_error("subpacket of type %d too short\n", type);
1014                 return NULL;
1015               case -2:
1016                 return NULL;
1017               case -1:
1018                 BUG(); /* not yet needed */
1019               default:
1020                 break;
1021             }
1022             if( start )
1023                 *start = seq;
1024             return buffer+offset;
1025         }
1026         buffer += n; buflen -=n;
1027     }
1028     if( reqtype == SIGSUBPKT_TEST_CRITICAL )
1029         return buffer; /* as value true to indicate that there is no */
1030                        /* critical bit we don't understand */
1031     if( start )
1032         *start = -1;
1033     return NULL; /* end of packets; not found */
1034
1035   too_short:
1036     log_error("buffer shorter than subpacket\n");
1037     if( start )
1038         *start = -1;
1039     return NULL;
1040 }
1041
1042
1043 const byte *
1044 parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
1045 {
1046     return enum_sig_subpkt( buffer, reqtype, ret_n, NULL );
1047 }
1048
1049 const byte *
1050 parse_sig_subpkt2( PKT_signature *sig, sigsubpkttype_t reqtype, size_t *ret_n )
1051 {
1052     const byte *p;
1053
1054     p = parse_sig_subpkt( sig->hashed_data, reqtype, ret_n );
1055     if( !p )
1056         p = parse_sig_subpkt( sig->unhashed_data, reqtype, ret_n );
1057     return p;
1058 }
1059
1060
1061
1062 static int
1063 parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
1064                                           PKT_signature *sig )
1065 {
1066     int md5_len=0;
1067     unsigned n;
1068     int is_v4=0;
1069     int rc=0;
1070     int i, ndata;
1071
1072     if( pktlen < 16 ) {
1073         log_error("packet(%d) too short\n", pkttype);
1074         goto leave;
1075     }
1076     sig->version = iobuf_get_noeof(inp); pktlen--;
1077     if( sig->version == 4 )
1078         is_v4=1;
1079     else if( sig->version != 2 && sig->version != 3 ) {
1080         log_error("packet(%d) with unknown version %d\n", pkttype, sig->version);
1081         goto leave;
1082     }
1083
1084     if( !is_v4 ) {
1085         md5_len = iobuf_get_noeof(inp); pktlen--;
1086     }
1087     sig->sig_class = iobuf_get_noeof(inp); pktlen--;
1088     if( !is_v4 ) {
1089         sig->timestamp = read_32(inp); pktlen -= 4;
1090         sig->keyid[0] = read_32(inp); pktlen -= 4;
1091         sig->keyid[1] = read_32(inp); pktlen -= 4;
1092     }
1093     sig->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1094     sig->digest_algo = iobuf_get_noeof(inp); pktlen--;
1095     if( is_v4 ) { /* read subpackets */
1096         n = read_16(inp); pktlen -= 2; /* length of hashed data */
1097         if( n > 10000 ) {
1098             log_error("signature packet: hashed data too long\n");
1099             rc = GPGERR_INVALID_PACKET;
1100             goto leave;
1101         }
1102         if( n ) {
1103             sig->hashed_data = gcry_xmalloc( n + 2 );
1104             sig->hashed_data[0] = n >> 8;
1105             sig->hashed_data[1] = n;
1106             if( iobuf_read(inp, sig->hashed_data+2, n ) != n ) {
1107                 log_error("premature eof while reading hashed signature data\n");
1108                 rc = -1;
1109                 goto leave;
1110             }
1111             pktlen -= n;
1112         }
1113         n = read_16(inp); pktlen -= 2; /* length of unhashed data */
1114         if( n > 10000 ) {
1115             log_error("signature packet: unhashed data too long\n");
1116             rc = GPGERR_INVALID_PACKET;
1117             goto leave;
1118         }
1119         if( n ) {
1120             sig->unhashed_data = gcry_xmalloc( n + 2 );
1121             sig->unhashed_data[0] = n >> 8;
1122             sig->unhashed_data[1] = n;
1123             if( iobuf_read(inp, sig->unhashed_data+2, n ) != n ) {
1124                 log_error("premature eof while reading unhashed signature data\n");
1125                 rc = -1;
1126                 goto leave;
1127             }
1128             pktlen -= n;
1129         }
1130     }
1131
1132     if( pktlen < 5 ) { /* sanity check */
1133         log_error("packet(%d) too short\n", pkttype);
1134         rc = GPGERR_INVALID_PACKET;
1135         goto leave;
1136     }
1137
1138     sig->digest_start[0] = iobuf_get_noeof(inp); pktlen--;
1139     sig->digest_start[1] = iobuf_get_noeof(inp); pktlen--;
1140
1141     if( is_v4 && sig->pubkey_algo ) { /*extract required information */
1142         const byte *p;
1143
1144         /* set sig->flags.unknown_critical if there is a
1145          * critical bit set for packets which we do not understand */
1146         if( !parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_TEST_CRITICAL, NULL)
1147            || !parse_sig_subpkt( sig->unhashed_data, SIGSUBPKT_TEST_CRITICAL,
1148                                                                         NULL) )
1149         {
1150             sig->flags.unknown_critical = 1;
1151         }
1152
1153         p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_SIG_CREATED, NULL );
1154         if( !p )
1155             log_error("signature packet without timestamp\n");
1156         else
1157             sig->timestamp = buffer_to_u32(p);
1158         p = parse_sig_subpkt2( sig, SIGSUBPKT_ISSUER, NULL );
1159         if( !p )
1160             log_error("signature packet without keyid\n");
1161         else {
1162             sig->keyid[0] = buffer_to_u32(p);
1163             sig->keyid[1] = buffer_to_u32(p+4);
1164         }
1165     }
1166
1167     if( list_mode ) {
1168         printf(":signature packet: algo %d, keyid %08lX%08lX\n"
1169                "\tversion %d, created %lu, md5len %d, sigclass %02x\n"
1170                "\tdigest algo %d, begin of digest %02x %02x\n",
1171                 sig->pubkey_algo,
1172                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1173                 sig->version, (ulong)sig->timestamp, md5_len, sig->sig_class,
1174                 sig->digest_algo,
1175                 sig->digest_start[0], sig->digest_start[1] );
1176         if( is_v4 ) {
1177             parse_sig_subpkt( sig->hashed_data,  SIGSUBPKT_LIST_HASHED, NULL );
1178             parse_sig_subpkt( sig->unhashed_data,SIGSUBPKT_LIST_UNHASHED, NULL);
1179         }
1180     }
1181
1182     ndata = pubkey_get_nsig(sig->pubkey_algo);
1183     if( !ndata ) {
1184         if( list_mode )
1185             printf("\tunknown algorithm %d\n", sig->pubkey_algo );
1186         unknown_pubkey_warning( sig->pubkey_algo );
1187         /* we store the plain material in data[0], so that we are able
1188          * to write it back with build_packet() */
1189         sig->data[0] = mpi_set_opaque(NULL, read_rest(inp, pktlen), pktlen );
1190         pktlen = 0;
1191     }
1192     else {
1193         for( i=0; i < ndata; i++ ) {
1194             n = pktlen;
1195             sig->data[i] = mpi_read(inp, &n, 0 );
1196             pktlen -=n;
1197             if( list_mode ) {
1198                 printf("\tdata: ");
1199                 mpi_print(stdout, sig->data[i], mpi_print_mode );
1200                 putchar('\n');
1201             }
1202         }
1203     }
1204
1205   leave:
1206     skip_rest(inp, pktlen);
1207     return rc;
1208 }
1209
1210
1211 static int
1212 parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
1213                                              PKT_onepass_sig *ops )
1214 {
1215     int version;
1216
1217     if( pktlen < 13 ) {
1218         log_error("packet(%d) too short\n", pkttype);
1219         goto leave;
1220     }
1221     version = iobuf_get_noeof(inp); pktlen--;
1222     if( version != 3 ) {
1223         log_error("onepass_sig with unknown version %d\n", version);
1224         goto leave;
1225     }
1226     ops->sig_class = iobuf_get_noeof(inp); pktlen--;
1227     ops->digest_algo = iobuf_get_noeof(inp); pktlen--;
1228     ops->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
1229     ops->keyid[0] = read_32(inp); pktlen -= 4;
1230     ops->keyid[1] = read_32(inp); pktlen -= 4;
1231     ops->last = iobuf_get_noeof(inp); pktlen--;
1232     if( list_mode )
1233         printf(":onepass_sig packet: keyid %08lX%08lX\n"
1234                "\tversion %d, sigclass %02x, digest %d, pubkey %d, last=%d\n",
1235                 (ulong)ops->keyid[0], (ulong)ops->keyid[1],
1236                 version, ops->sig_class,
1237                 ops->digest_algo, ops->pubkey_algo, ops->last );
1238
1239
1240   leave:
1241     skip_rest(inp, pktlen);
1242     return 0;
1243 }
1244
1245
1246
1247
1248 static int
1249 parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
1250                               byte *hdr, int hdrlen, PACKET *pkt )
1251 {
1252     int i, version, algorithm;
1253     unsigned n;
1254     unsigned long timestamp, expiredate;
1255     int npkey, nskey;
1256     int is_v4=0;
1257     int rc=0;
1258
1259     version = iobuf_get_noeof(inp); pktlen--;
1260     if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
1261         /* early versions of gpg use old PGP comments packets;
1262          * luckily all those comments are started by a hash */
1263         if( list_mode ) {
1264             printf(":rfc1991 comment packet: \"" );
1265             for( ; pktlen; pktlen-- ) {
1266                 int c;
1267                 c = iobuf_get_noeof(inp);
1268                 if( c >= ' ' && c <= 'z' )
1269                     putchar(c);
1270                 else
1271                     printf("\\x%02x", c );
1272             }
1273             printf("\"\n");
1274         }
1275         skip_rest(inp, pktlen);
1276         return 0;
1277     }
1278     else if( version == 4 )
1279         is_v4=1;
1280     else if( version != 2 && version != 3 ) {
1281         log_error("packet(%d) with unknown version %d\n", pkttype, version);
1282         goto leave;
1283     }
1284
1285     if( pktlen < 11 ) {
1286         log_error("packet(%d) too short\n", pkttype);
1287         goto leave;
1288     }
1289
1290     timestamp = read_32(inp); pktlen -= 4;
1291     if( is_v4 )
1292         expiredate = 0; /* have to get it from the selfsignature */
1293     else {
1294         unsigned short ndays;
1295         ndays = read_16(inp); pktlen -= 2;
1296         if( ndays )
1297             expiredate = timestamp + ndays * 86400L;
1298         else
1299             expiredate = 0;
1300     }
1301     algorithm = iobuf_get_noeof(inp); pktlen--;
1302     if( list_mode )
1303         printf(":%s key packet:\n"
1304                "\tversion %d, algo %d, created %lu, expires %lu\n",
1305                 pkttype == PKT_PUBLIC_KEY? "public" :
1306                 pkttype == PKT_SECRET_KEY? "secret" :
1307                 pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
1308                 pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
1309                 version, algorithm, timestamp, expiredate );
1310
1311     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
1312         PKT_secret_key *sk = pkt->pkt.secret_key;
1313
1314         sk->timestamp = timestamp;
1315         sk->expiredate = expiredate;
1316         sk->hdrbytes = hdrlen;
1317         sk->version = version;
1318         sk->is_primary = pkttype == PKT_SECRET_KEY;
1319         sk->pubkey_algo = algorithm;
1320         sk->req_usage = 0; 
1321         sk->pubkey_usage = 0; /* will be set by getkey functions */
1322     }
1323     else {
1324         PKT_public_key *pk = pkt->pkt.public_key;
1325
1326         pk->timestamp = timestamp;
1327         pk->expiredate = expiredate;
1328         pk->hdrbytes    = hdrlen;
1329         pk->version     = version;
1330         pk->pubkey_algo = algorithm;
1331         pk->req_usage = 0;
1332         pk->pubkey_usage = 0; /* will be set bey getkey functions */
1333         pk->is_revoked = 0;
1334         pk->keyid[0] = 0;
1335         pk->keyid[1] = 0;
1336     }
1337     nskey = pubkey_get_nskey( algorithm );
1338     npkey = pubkey_get_npkey( algorithm );
1339     if( !npkey ) {
1340         if( list_mode )
1341             printf("\tunknown algorithm %d\n", algorithm );
1342         unknown_pubkey_warning( algorithm );
1343     }
1344
1345
1346     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
1347         PKT_secret_key *sk = pkt->pkt.secret_key;
1348         byte temp[16];
1349
1350         if( !npkey ) {
1351             sk->skey[0] = gcry_mpi_set_opaque( NULL,
1352                                              read_rest(inp, pktlen), pktlen*8 );
1353             pktlen = 0;
1354             goto leave;
1355         }
1356
1357         for(i=0; i < npkey; i++ ) {
1358             n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1359             if( list_mode ) {
1360                 printf(  "\tskey[%d]: ", i);
1361                 mpi_print(stdout, sk->skey[i], mpi_print_mode  );
1362                 putchar('\n');
1363             }
1364         }
1365         sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1366         if( sk->protect.algo ) {
1367             sk->is_protected = 1;
1368             sk->protect.s2k.count = 0;
1369             if( sk->protect.algo == 255 ) {
1370                 if( pktlen < 3 ) {
1371                     rc = GPGERR_INVALID_PACKET;
1372                     goto leave;
1373                 }
1374                 sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1375                 sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
1376                 sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
1377                 /* check for the special GNU extension */
1378                 if( is_v4 && sk->protect.s2k.mode == 101 ) {
1379                     for(i=0; i < 4 && pktlen; i++, pktlen-- )
1380                         temp[i] = iobuf_get_noeof(inp);
1381                     if( i < 4 || memcmp( temp, "GNU", 3 ) ) {
1382                         if( list_mode )
1383                             printf(  "\tunknown S2K %d\n",
1384                                                 sk->protect.s2k.mode );
1385                         rc = GPGERR_INVALID_PACKET;
1386                         goto leave;
1387                     }
1388                     /* here we know that it is a gnu extension
1389                      * What follows is the GNU protection mode:
1390                      * All values have special meanings
1391                      * and they are mapped in the mode with a base of 1000.
1392                      */
1393                     sk->protect.s2k.mode = 1000 + temp[3];
1394                 }
1395                 switch( sk->protect.s2k.mode ) {
1396                   case 1:
1397                   case 3:
1398                     for(i=0; i < 8 && pktlen; i++, pktlen-- )
1399                         temp[i] = iobuf_get_noeof(inp);
1400                     memcpy(sk->protect.s2k.salt, temp, 8 );
1401                     break;
1402                 }
1403                 switch( sk->protect.s2k.mode ) {
1404                   case 0: if( list_mode ) printf(  "\tsimple S2K" );
1405                     break;
1406                   case 1: if( list_mode ) printf(  "\tsalted S2K" );
1407                     break;
1408                   case 3: if( list_mode ) printf(  "\titer+salt S2K" );
1409                     break;
1410                   case 1001: if( list_mode ) printf(  "\tgnu-dummy S2K" );
1411                     break;
1412                   default:
1413                     if( list_mode )
1414                         printf(  "\tunknown %sS2K %d\n",
1415                                  sk->protect.s2k.mode < 1000? "":"GNU ",
1416                                                    sk->protect.s2k.mode );
1417                     rc = GPGERR_INVALID_PACKET;
1418                     goto leave;
1419                 }
1420
1421                 if( list_mode ) {
1422                     printf(", algo: %d, hash: %d",
1423                                      sk->protect.algo,
1424                                      sk->protect.s2k.hash_algo );
1425                     if( sk->protect.s2k.mode == 1
1426                         || sk->protect.s2k.mode == 3 ) {
1427                         printf(", salt: ");
1428                         for(i=0; i < 8; i++ )
1429                             printf("%02x", sk->protect.s2k.salt[i]);
1430                     }
1431                     putchar('\n');
1432                 }
1433
1434                 if( sk->protect.s2k.mode == 3 ) {
1435                     if( pktlen < 1 ) {
1436                         rc = GPGERR_INVALID_PACKET;
1437                         goto leave;
1438                     }
1439                     sk->protect.s2k.count = iobuf_get(inp);
1440                     pktlen--;
1441                     if( list_mode )
1442                         printf("\tprotect count: %lu\n",
1443                                             (ulong)sk->protect.s2k.count);
1444                 }
1445             }
1446             else { /* old version; no S2K, so we set mode to 0, hash MD5 */
1447                 sk->protect.s2k.mode = 0;
1448                 sk->protect.s2k.hash_algo = GCRY_MD_MD5;
1449                 if( list_mode )
1450                     printf(  "\tprotect algo: %d  (hash algo: %d)\n",
1451                          sk->protect.algo, sk->protect.s2k.hash_algo );
1452             }
1453             /* It is really ugly that we don't know the size
1454              * of the IV here in cases we are not aware of the algorithm.
1455              * so a
1456              *   sk->protect.ivlen = cipher_get_blocksize(sk->protect.algo);
1457              * won't work.  The only solution I see is to hardwire it here.
1458              * NOTE: if you change the ivlen above 16, don't forget to
1459              * enlarge temp.
1460              */
1461             switch( sk->protect.algo ) {
1462               case 7: case 8: case 9: /* reserved for AES */
1463               case 10: /* Twofish */
1464                 sk->protect.ivlen = 16;
1465                 break;
1466               default:
1467                 sk->protect.ivlen = 8;
1468             }
1469             if( sk->protect.s2k.mode == 1001 )
1470                 sk->protect.ivlen = 0;
1471
1472             if( pktlen < sk->protect.ivlen ) {
1473                 rc = GPGERR_INVALID_PACKET;
1474                 goto leave;
1475             }
1476             for(i=0; i < sk->protect.ivlen && pktlen; i++, pktlen-- )
1477                 temp[i] = iobuf_get_noeof(inp);
1478             if( list_mode ) {
1479                 printf(  "\tprotect IV: ");
1480                 for(i=0; i < sk->protect.ivlen; i++ )
1481                     printf(" %02x", temp[i] );
1482                 putchar('\n');
1483             }
1484             memcpy(sk->protect.iv, temp, sk->protect.ivlen );
1485         }
1486         else
1487             sk->is_protected = 0;
1488         /* It does not make sense to read it into secure memory.
1489          * If the user is so careless, not to protect his secret key,
1490          * we can assume, that he operates an open system :=(.
1491          * So we put the key into secure memory when we unprotect it. */
1492         if( sk->protect.s2k.mode == 1001 ) {
1493             /* better set some dummy stuff here */
1494             sk->skey[npkey] = mpi_set_opaque(NULL, gcry_xstrdup("dummydata"), 10);
1495             pktlen = 0;
1496         }
1497         else if( is_v4 && sk->is_protected ) {
1498             /* ugly; the length is encrypted too, so we read all
1499              * stuff up to the end of the packet into the first
1500              * skey element */
1501             sk->skey[npkey] = gcry_mpi_set_opaque(NULL,
1502                                              read_rest(inp, pktlen), pktlen*8 );
1503             pktlen = 0;
1504             if( list_mode ) {
1505                 printf("\tencrypted stuff follows\n");
1506             }
1507         }
1508         else { /* unencrypted v4 or v3 method (where length is not encrypted) */
1509             for(i=npkey; i < nskey; i++ ) {
1510                 n = pktlen;
1511                 sk->skey[i] = sk->is_protected ? mpi_read_opaque(inp, &n )
1512                                                : mpi_read( inp, &n, 1 );
1513                 pktlen -=n;
1514                 if( list_mode ) {
1515                     printf(  "\tskey[%d]: ", i);
1516                     if( sk->is_protected )
1517                         printf(  "[encrypted]\n");
1518                     else {
1519                         mpi_print(stdout, sk->skey[i], mpi_print_mode  );
1520                         putchar('\n');
1521                     }
1522                 }
1523             }
1524
1525             sk->csum = read_16(inp); pktlen -= 2;
1526             if( list_mode ) {
1527                 printf("\tchecksum: %04hx\n", sk->csum);
1528             }
1529         }
1530     }
1531     else {
1532         PKT_public_key *pk = pkt->pkt.public_key;
1533
1534         if( !npkey ) {
1535             pk->pkey[0] = gcry_mpi_set_opaque( NULL,
1536                                              read_rest(inp, pktlen), pktlen*8 );
1537             pktlen = 0;
1538             goto leave;
1539         }
1540
1541         for(i=0; i < npkey; i++ ) {
1542             n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1543             if( list_mode ) {
1544                 printf(  "\tpkey[%d]: ", i);
1545                 mpi_print(stdout, pk->pkey[i], mpi_print_mode  );
1546                 putchar('\n');
1547             }
1548         }
1549     }
1550
1551   leave:
1552     skip_rest(inp, pktlen);
1553     return rc;
1554 }
1555
1556
1557 static int
1558 parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1559 {
1560     byte *p;
1561
1562     packet->pkt.user_id = gcry_xmalloc(sizeof *packet->pkt.user_id  + pktlen);
1563     packet->pkt.user_id->len = pktlen;
1564     packet->pkt.user_id->photo = NULL;
1565     packet->pkt.user_id->photolen = 0;
1566     p = packet->pkt.user_id->name;
1567     for( ; pktlen; pktlen--, p++ )
1568         *p = iobuf_get_noeof(inp);
1569     *p = 0;
1570
1571     if( list_mode ) {
1572         int n = packet->pkt.user_id->len;
1573         printf(":user ID packet: \"");
1574         /* fixme: Hey why don't we replace this wioth print_string?? */
1575         for(p=packet->pkt.user_id->name; n; p++, n-- ) {
1576             if( *p >= ' ' && *p <= 'z' )
1577                 putchar(*p);
1578             else
1579                 printf("\\x%02x", *p );
1580         }
1581         printf("\"\n");
1582     }
1583     return 0;
1584 }
1585
1586
1587 /****************
1588  * PGP generates a packet of type 17. We assume this is a photo ID and
1589  * simply store it here as a comment packet.
1590  */
1591 static int
1592 parse_photo_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1593 {
1594     byte *p;
1595
1596     packet->pkt.user_id = gcry_xmalloc(sizeof *packet->pkt.user_id  + 30);
1597     sprintf( packet->pkt.user_id->name, "[image of size %lu]", pktlen );
1598     packet->pkt.user_id->len = strlen(packet->pkt.user_id->name);
1599
1600     packet->pkt.user_id->photo = gcry_xmalloc(sizeof *packet->pkt.user_id + pktlen);
1601     packet->pkt.user_id->photolen = pktlen;
1602     p = packet->pkt.user_id->photo;
1603     for( ; pktlen; pktlen--, p++ )
1604         *p = iobuf_get_noeof(inp);
1605
1606     if( list_mode ) {
1607         printf(":photo_id packet: %s\n", packet->pkt.user_id->name );
1608     }
1609     return 0;
1610 }
1611
1612
1613 static int
1614 parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1615 {
1616     byte *p;
1617
1618     packet->pkt.comment = gcry_xmalloc(sizeof *packet->pkt.comment + pktlen - 1);
1619     packet->pkt.comment->len = pktlen;
1620     p = packet->pkt.comment->data;
1621     for( ; pktlen; pktlen--, p++ )
1622         *p = iobuf_get_noeof(inp);
1623
1624     if( list_mode ) {
1625         int n = packet->pkt.comment->len;
1626         printf(":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
1627                                          "OpenPGP draft " : "" );
1628         for(p=packet->pkt.comment->data; n; p++, n-- ) {
1629             if( *p >= ' ' && *p <= 'z' )
1630                 putchar(*p);
1631             else
1632                 printf("\\x%02x", *p );
1633         }
1634         printf("\"\n");
1635     }
1636     return 0;
1637 }
1638
1639
1640 static void
1641 parse_trust( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
1642 {
1643     int c;
1644
1645     c = iobuf_get_noeof(inp);
1646     pkt->pkt.ring_trust = gcry_xmalloc( sizeof *pkt->pkt.ring_trust );
1647     pkt->pkt.ring_trust->trustval = c;
1648     if( list_mode )
1649         printf(":trust packet: flag=%02x\n", c );
1650 }
1651
1652
1653 static int
1654 parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
1655                                         PACKET *pkt, int new_ctb )
1656 {
1657     int mode, namelen;
1658     PKT_plaintext *pt;
1659     byte *p;
1660     int c, i;
1661
1662     if( pktlen && pktlen < 6 ) {
1663         log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
1664         goto leave;
1665     }
1666     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
1667     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
1668     pt = pkt->pkt.plaintext = gcry_xmalloc(sizeof *pkt->pkt.plaintext + namelen -1);
1669     pt->new_ctb = new_ctb;
1670     pt->mode = mode;
1671     pt->namelen = namelen;
1672     if( pktlen ) {
1673         for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
1674             pt->name[i] = iobuf_get_noeof(inp);
1675     }
1676     else {
1677         for( i=0; i < namelen; i++ )
1678             if( (c=iobuf_get(inp)) == -1 )
1679                 break;
1680             else
1681                 pt->name[i] = c;
1682     }
1683     pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
1684     pt->len = pktlen;
1685     pt->buf = inp;
1686     pktlen = 0;
1687
1688     if( list_mode ) {
1689         printf(":literal data packet:\n"
1690                "\tmode %c, created %lu, name=\"",
1691                     mode >= ' ' && mode <'z'? mode : '?',
1692                     (ulong)pt->timestamp );
1693         for(p=pt->name,i=0; i < namelen; p++, i++ ) {
1694             if( *p >= ' ' && *p <= 'z' )
1695                 putchar(*p);
1696             else
1697                 printf("\\x%02x", *p );
1698         }
1699         printf("\",\n\traw data: %lu bytes\n", (ulong)pt->len );
1700     }
1701
1702   leave:
1703     return 0;
1704 }
1705
1706
1707 static int
1708 parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
1709                   PACKET *pkt, int new_ctb )
1710 {
1711     PKT_compressed *zd;
1712
1713     /* pktlen is here 0, but data follows
1714      * (this should be the last object in a file or
1715      *  the compress algorithm should know the length)
1716      */
1717     zd = pkt->pkt.compressed =  gcry_xmalloc(sizeof *pkt->pkt.compressed );
1718     zd->len = 0; /* not yet used */
1719     zd->algorithm = iobuf_get_noeof(inp);
1720     zd->new_ctb = new_ctb;
1721     zd->buf = inp;
1722     if( list_mode )
1723         printf(":compressed packet: algo=%d\n", zd->algorithm);
1724     return 0;
1725 }
1726
1727
1728 static int
1729 parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
1730                                        PACKET *pkt, int new_ctb )
1731 {
1732     PKT_encrypted *ed;
1733
1734     ed = pkt->pkt.encrypted =  gcry_xmalloc(sizeof *pkt->pkt.encrypted );
1735     ed->len = pktlen;
1736     ed->buf = NULL;
1737     ed->new_ctb = new_ctb;
1738     ed->mdc_method = 0;
1739     if( pkttype == PKT_ENCRYPTED_MDC ) {
1740         /* fixme: add some pktlen sanity checks */
1741         int version;
1742
1743         version = iobuf_get_noeof(inp); pktlen--;
1744         if( version != 1 ) {
1745             log_error("encrypted_mdc packet with unknown version %d\n",
1746                                                                 version);
1747             goto leave;
1748         }
1749         ed->mdc_method = GCRY_MD_SHA1;
1750     }
1751     if( pktlen && pktlen < 10 ) { /* actually this is blocksize+2 */
1752         log_error("packet(%d) too short\n", pkttype);
1753         skip_rest(inp, pktlen);
1754         goto leave;
1755     }
1756     if( list_mode ) {
1757         if( pktlen )
1758             printf(":encrypted data packet:\n\tlength: %lu\n", pktlen);
1759         else
1760             printf(":encrypted data packet:\n\tlength: unknown\n");
1761         if( ed->mdc_method )
1762             printf("\tmdc_method: %d\n", ed->mdc_method );
1763     }
1764
1765     ed->buf = inp;
1766     pktlen = 0;
1767
1768   leave:
1769     return 0;
1770 }
1771
1772
1773 static int
1774 parse_mdc( IOBUF inp, int pkttype, unsigned long pktlen,
1775                                    PACKET *pkt, int new_ctb )
1776 {
1777     PKT_mdc *mdc;
1778     byte *p;
1779
1780     mdc = pkt->pkt.mdc=  gcry_xmalloc(sizeof *pkt->pkt.mdc );
1781     if( list_mode )
1782         printf(":mdc packet: length=%lu\n", pktlen);
1783     if( !new_ctb || pktlen != 20 ) {
1784         log_error("mdc_packet with invalid encoding\n");
1785         goto leave;
1786     }
1787     p = mdc->hash;
1788     for( ; pktlen; pktlen--, p++ )
1789         *p = iobuf_get_noeof(inp);
1790
1791   leave:
1792     return 0;
1793 }
1794