g10/parse-packet.c

   1 /* parse-packet.c  - read packets
   2  *      Copyright (C) 1998 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 "packet.h"
  28 #include "iobuf.h"
  29 #include "mpi.h"
  30 #include "util.h"
  31 #include "cipher.h"
  32 #include "memory.h"
  33 #include "filter.h"
  34 #include "options.h"
  35 #include "main.h"
  36 #include "i18n.h"
  37
  38 static int mpi_print_mode = 0;
  39 static int list_mode = 0;
  40
  41 static int  parse( IOBUF inp, PACKET *pkt, int reqtype,
  42                    ulong *retpos, int *skip, IOBUF out, int do_skip );
  43 static int  copy_packet( IOBUF inp, IOBUF out, int pkttype,
  44                                                unsigned long pktlen );
  45 static void skip_packet( IOBUF inp, int pkttype, unsigned long pktlen );
  46 static void skip_rest( IOBUF inp, unsigned long pktlen );
  47 static void *read_rest( IOBUF inp, ulong *r_pktlen );
  48 static int  parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
  49                                                              PACKET *packet );
  50 static int  parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
  51                                                              PACKET *packet );
  52 static int  parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
  53                                                          PKT_signature *sig );
  54 static int  parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
  55                                                         PKT_onepass_sig *ops );
  56 static int  parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
  57                                       byte *hdr, int hdrlen, PACKET *packet );
  58 static int  parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen,
  59                                                            PACKET *packet );
  60 static int  parse_comment( IOBUF inp, int pkttype, unsigned long pktlen,
  61                                                            PACKET *packet );
  62 static void parse_trust( IOBUF inp, int pkttype, unsigned long pktlen );
  63 static int  parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
  64                                                PACKET *packet, int new_ctb);
  65 static int  parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
  66                                                PACKET *packet, int new_ctb );
  67 static int  parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
  68                                                PACKET *packet, int new_ctb);
  69
  70
  71 static unsigned short
  72 read_16(IOBUF inp)
  73 {
  74     unsigned short a;
  75     a = iobuf_get_noeof(inp) << 8;
  76     a |= iobuf_get_noeof(inp);
  77     return a;
  78 }
  79
  80 static unsigned long
  81 read_32(IOBUF inp)
  82 {
  83     unsigned long a;
  84     a =  iobuf_get_noeof(inp) << 24;
  85     a |= iobuf_get_noeof(inp) << 16;
  86     a |= iobuf_get_noeof(inp) << 8;
  87     a |= iobuf_get_noeof(inp);
  88     return a;
  89 }
  90
  91
  92 int
  93 set_packet_list_mode( int mode )
  94 {
  95     int old = list_mode;
  96     list_mode = mode;
  97     mpi_print_mode = DBG_MPI;
  98     return old;
  99 }
 100
 101 static void
 102 unknown_pubkey_warning( int algo )
 103 {
 104     static byte unknown_pubkey_algos[256];
 105
 106     algo &= 0xff;
 107     if( !unknown_pubkey_algos[algo] ) {
 108         if( opt.verbose )
 109             log_info(_("can't handle public key algorithm %d\n"), algo );
 110         unknown_pubkey_algos[algo] = 1;
 111     }
 112 }
 113
 114 /****************
 115  * Parse a Packet and return it in packet
 116  * Returns: 0 := valid packet in pkt
 117  *         -1 := no more packets
 118  *         >0 := error
 119  * Note: The function may return an error and a partly valid packet;
 120  * caller must free this packet.
 121  */
 122 int
 123 parse_packet( IOBUF inp, PACKET *pkt )
 124 {
 125     int skip, rc;
 126
 127     do {
 128         rc = parse( inp, pkt, 0, NULL, &skip, NULL, 0 );
 129     } while( skip );
 130     return rc;
 131 }
 132
 133 /****************
 134  * Like parse packet, but only return packets of the given type.
 135  */
 136 int
 137 search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos )
 138 {
 139     int skip, rc;
 140
 141     do {
 142         rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0 );
 143     } while( skip );
 144     return rc;
 145 }
 146
 147 /****************
 148  * Copy all packets from INP to OUT, thereby removing unused spaces.
 149  */
 150 int
 151 copy_all_packets( IOBUF inp, IOBUF out )
 152 {
 153     PACKET pkt;
 154     int skip, rc=0;
 155     do {
 156         init_packet(&pkt);
 157     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )));
 158     return rc;
 159 }
 160
 161 /****************
 162  * Copy some packets from INP to OUT, thereby removing unused spaces.
 163  * Stop at offset STOPoff (i.e. don't copy packets at this or later offsets)
 164  */
 165 int
 166 copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff )
 167 {
 168     PACKET pkt;
 169     int skip, rc=0;
 170     do {
 171         if( iobuf_tell(inp) >= stopoff )
 172             return 0;
 173         init_packet(&pkt);
 174     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )) );
 175     return rc;
 176 }
 177
 178 /****************
 179  * Skip over N packets
 180  */
 181 int
 182 skip_some_packets( IOBUF inp, unsigned n )
 183 {
 184     int skip, rc=0;
 185     PACKET pkt;
 186
 187     for( ;n && !rc; n--) {
 188         init_packet(&pkt);
 189         rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1 );
 190     }
 191     return rc;
 192 }
 193
 194
 195
 196 /****************
 197  * Parse packet. Set the variable skip points to to 1 if the packet
 198  * should be skipped; this is the case if either there is a
 199  * requested packet type and the parsed packet doesn't match or the
 200  * packet-type is 0, indicating deleted stuff.
 201  * if OUT is not NULL, a special copymode is used.
 202  */
 203 static int
 204 parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
 205        int *skip, IOBUF out, int do_skip )
 206 {
 207     int rc=0, c, ctb, pkttype, lenbytes;
 208     unsigned long pktlen;
 209     byte hdr[8];
 210     int hdrlen;
 211     int new_ctb = 0;
 212
 213     *skip = 0;
 214     assert( !pkt->pkt.generic );
 215     if( retpos )
 216         *retpos = iobuf_tell(inp);
 217     if( (ctb = iobuf_get(inp)) == -1 ) {
 218         rc = -1;
 219         goto leave;
 220     }
 221     hdrlen=0;
 222     hdr[hdrlen++] = ctb;
 223     if( !(ctb & 0x80) ) {
 224         log_error("%s: invalid packet (ctb=%02x)\n", iobuf_where(inp), ctb );
 225         rc = G10ERR_INVALID_PACKET;
 226         goto leave;
 227     }
 228     pktlen = 0;
 229     new_ctb = !!(ctb & 0x40);
 230     if( new_ctb ) {
 231         pkttype =  ctb & 0x3f;
 232         if( (c = iobuf_get(inp)) == -1 ) {
 233             log_error("%s: 1st length byte missing\n", iobuf_where(inp) );
 234             rc = G10ERR_INVALID_PACKET;
 235             goto leave;
 236         }
 237         hdr[hdrlen++] = c;
 238         if( c < 192 )
 239             pktlen = c;
 240         else if( c < 224 ) {
 241             pktlen = (c - 192) * 256;
 242             if( (c = iobuf_get(inp)) == -1 ) {
 243                 log_error("%s: 2nd length byte missing\n", iobuf_where(inp) );
 244                 rc = G10ERR_INVALID_PACKET;
 245                 goto leave;
 246             }
 247             hdr[hdrlen++] = c;
 248             pktlen += c + 192;
 249         }
 250         else if( c == 255 ) {
 251             pktlen  = (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 24;
 252             pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 16;
 253             pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 8;
 254             if( (c = iobuf_get(inp)) == -1 ) {
 255                 log_error("%s: 4 byte length invalid\n", iobuf_where(inp) );
 256                 rc = G10ERR_INVALID_PACKET;
 257                 goto leave;
 258             }
 259             pktlen |= (hdr[hdrlen++] = c );
 260         }
 261         else { /* partial body length */
 262             iobuf_set_partial_block_mode(inp, c & 0xff);
 263             pktlen = 0;/* to indicate partial length */
 264         }
 265     }
 266     else {
 267         pkttype = (ctb>>2)&0xf;
 268         lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
 269         if( !lenbytes ) {
 270             pktlen = 0; /* don't know the value */
 271             if( pkttype != PKT_COMPRESSED )
 272                 iobuf_set_block_mode(inp, 1);
 273         }
 274         else {
 275             for( ; lenbytes; lenbytes-- ) {
 276                 pktlen <<= 8;
 277                 pktlen |= hdr[hdrlen++] = iobuf_get_noeof(inp);
 278             }
 279         }
 280     }
 281
 282     if( out && pkttype  ) {
 283         if( iobuf_write( out, hdr, hdrlen ) == -1 )
 284             rc = G10ERR_WRITE_FILE;
 285         else
 286             rc = copy_packet(inp, out, pkttype, pktlen );
 287         goto leave;
 288     }
 289
 290     if( do_skip || !pkttype || (reqtype && pkttype != reqtype) ) {
 291         skip_packet(inp, pkttype, pktlen);
 292         *skip = 1;
 293         rc = 0;
 294         goto leave;
 295     }
 296
 297     if( DBG_PACKET )
 298         log_debug("parse_packet(iob=%d): type=%d length=%lu%s\n",
 299                    iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"" );
 300     pkt->pkttype = pkttype;
 301     rc = G10ERR_UNKNOWN_PACKET; /* default error */
 302     switch( pkttype ) {
 303       case PKT_PUBLIC_KEY:
 304       case PKT_PUBLIC_SUBKEY:
 305         pkt->pkt.public_key = m_alloc_clear(sizeof *pkt->pkt.public_key );
 306         rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
 307         break;
 308       case PKT_SECRET_KEY:
 309       case PKT_SECRET_SUBKEY:
 310         pkt->pkt.secret_key = m_alloc_clear(sizeof *pkt->pkt.secret_key );
 311         rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
 312         break;
 313       case PKT_SYMKEY_ENC:
 314         rc = parse_symkeyenc( inp, pkttype, pktlen, pkt );
 315         break;
 316       case PKT_PUBKEY_ENC:
 317         rc = parse_pubkeyenc(inp, pkttype, pktlen, pkt );
 318         break;
 319       case PKT_SIGNATURE:
 320         pkt->pkt.signature = m_alloc_clear(sizeof *pkt->pkt.signature );
 321         rc = parse_signature(inp, pkttype, pktlen, pkt->pkt.signature );
 322         break;
 323       case PKT_ONEPASS_SIG:
 324         pkt->pkt.onepass_sig = m_alloc_clear(sizeof *pkt->pkt.onepass_sig );
 325         rc = parse_onepass_sig(inp, pkttype, pktlen, pkt->pkt.onepass_sig );
 326         break;
 327       case PKT_USER_ID:
 328         rc = parse_user_id(inp, pkttype, pktlen, pkt );
 329         break;
 330       case PKT_OLD_COMMENT:
 331       case PKT_COMMENT:
 332         rc = parse_comment(inp, pkttype, pktlen, pkt);
 333         break;
 334       case PKT_RING_TRUST:
 335         parse_trust(inp, pkttype, pktlen);
 336         rc = G10ERR_UNKNOWN_PACKET;
 337         break;
 338       case PKT_PLAINTEXT:
 339         rc = parse_plaintext(inp, pkttype, pktlen, pkt, new_ctb );
 340         break;
 341       case PKT_COMPRESSED:
 342         rc = parse_compressed(inp, pkttype, pktlen, pkt, new_ctb );
 343         break;
 344       case PKT_ENCRYPTED:
 345         rc = parse_encrypted(inp, pkttype, pktlen, pkt, new_ctb );
 346         break;
 347       default:
 348         skip_packet(inp, pkttype, pktlen);
 349         break;
 350     }
 351
 352   leave:
 353     if( !rc && iobuf_error(inp) )
 354         rc = G10ERR_INV_KEYRING;
 355     return rc;
 356 }
 357
 358 static void
 359 dump_hex_line( int c, int *i )
 360 {
 361     if( *i && !(*i%8) ) {
 362         if( *i && !(*i%24) )
 363             printf("\n%4d:", *i );
 364         else
 365             putchar(' ');
 366     }
 367     if( c == -1 )
 368         printf(" EOF" );
 369     else
 370         printf(" %02x", c );
 371     ++*i;
 372 }
 373
 374
 375 static int
 376 copy_packet( IOBUF inp, IOBUF out, int pkttype, unsigned long pktlen )
 377 {
 378     int n;
 379     char buf[100];
 380
 381     if( iobuf_in_block_mode(inp) ) {
 382         while( (n = iobuf_read( inp, buf, 100 )) != -1 )
 383             if( iobuf_write(out, buf, n ) )
 384                 return G10ERR_WRITE_FILE; /* write error */
 385     }
 386     else if( !pktlen && pkttype == PKT_COMPRESSED ) {
 387         /* compressed packet, copy till EOF */
 388         while( (n = iobuf_read( inp, buf, 100 )) != -1 )
 389             if( iobuf_write(out, buf, n ) )
 390                 return G10ERR_WRITE_FILE; /* write error */
 391     }
 392     else {
 393         for( ; pktlen; pktlen -= n ) {
 394             n = pktlen > 100 ? 100 : pktlen;
 395             n = iobuf_read( inp, buf, n );
 396             if( n == -1 )
 397                 return G10ERR_READ_FILE;
 398             if( iobuf_write(out, buf, n ) )
 399                 return G10ERR_WRITE_FILE; /* write error */
 400         }
 401     }
 402     return 0;
 403 }
 404
 405
 406 static void
 407 skip_packet( IOBUF inp, int pkttype, unsigned long pktlen )
 408 {
 409     if( list_mode ) {
 410         printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen );
 411         if( pkttype ) {
 412             int c, i=0 ;
 413             printf("dump:");
 414             if( iobuf_in_block_mode(inp) ) {
 415                 while( (c=iobuf_get(inp)) != -1 )
 416                     dump_hex_line(c, &i);
 417             }
 418             else {
 419                 for( ; pktlen; pktlen-- )
 420                     dump_hex_line(iobuf_get(inp), &i);
 421             }
 422             putchar('\n');
 423             return;
 424         }
 425     }
 426     skip_rest(inp,pktlen);
 427 }
 428
 429 static void
 430 skip_rest( IOBUF inp, unsigned long pktlen )
 431 {
 432     if( iobuf_in_block_mode(inp) ) {
 433         while( iobuf_get(inp) != -1 )
 434                 ;
 435     }
 436     else {
 437         for( ; pktlen; pktlen-- )
 438             if( iobuf_get(inp) == -1 )
 439                 break;
 440     }
 441 }
 442
 443 static void *
 444 read_rest( IOBUF inp, ulong *r_pktlen )
 445 {
 446     byte *p;
 447     int i;
 448     size_t pktlen = *r_pktlen;
 449
 450     if( iobuf_in_block_mode(inp) ) {
 451         log_error("read_rest: can't store stream data\n");
 452         p = NULL;
 453     }
 454     else {
 455         p = m_alloc( pktlen + 2 );
 456         p[0] = pktlen >> 8;
 457         p[1] = pktlen & 0xff;
 458         for(i=2; pktlen; pktlen--, i++ )
 459             p[i] = iobuf_get(inp);
 460     }
 461     *r_pktlen = 0;
 462     return p;
 463 }
 464
 465 static void *
 466 read_rest2( IOBUF inp, size_t pktlen )
 467 {
 468     byte *p;
 469     int i;
 470
 471     if( iobuf_in_block_mode(inp) ) {
 472         log_error("read_rest: can't store stream data\n");
 473         p = NULL;
 474     }
 475     else {
 476         p = m_alloc( pktlen );
 477         for(i=0; pktlen; pktlen--, i++ )
 478             p[i] = iobuf_get(inp);
 479     }
 480     return p;
 481 }
 482
 483
 484
 485 static int
 486 parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 487 {
 488     PKT_symkey_enc *k;
 489     int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
 490
 491     if( pktlen < 4 ) {
 492         log_error("packet(%d) too short\n", pkttype);
 493         goto leave;
 494     }
 495     version = iobuf_get_noeof(inp); pktlen--;
 496     if( version != 4 ) {
 497         log_error("packet(%d) with unknown version %d\n", pkttype, version);
 498         goto leave;
 499     }
 500     if( pktlen > 200 ) { /* (we encode the seskeylen in a byte) */
 501         log_error("packet(%d) too large\n", pkttype);
 502         goto leave;
 503     }
 504     cipher_algo = iobuf_get_noeof(inp); pktlen--;
 505     s2kmode = iobuf_get_noeof(inp); pktlen--;
 506     hash_algo = iobuf_get_noeof(inp); pktlen--;
 507     switch( s2kmode ) {
 508       case 0:  /* simple s2k */
 509         minlen = 0;
 510         break;
 511       case 1:  /* salted s2k */
 512         minlen = 8;
 513         break;
 514       case 3:  /* iterated+salted s2k */
 515         minlen = 9;
 516         break;
 517       default:
 518         log_error("unknown S2K %d\n", s2kmode );
 519         goto leave;
 520     }
 521     if( minlen > pktlen ) {
 522         log_error("packet with S2K %d too short\n", s2kmode );
 523         goto leave;
 524     }
 525     seskeylen = pktlen - minlen;
 526     k = packet->pkt.symkey_enc = m_alloc_clear( sizeof *packet->pkt.symkey_enc
 527                                                 + seskeylen - 1 );
 528     k->version = version;
 529     k->cipher_algo = cipher_algo;
 530     k->s2k.mode = s2kmode;
 531     k->s2k.hash_algo = hash_algo;
 532     if( s2kmode == 1 || s2kmode == 3 ) {
 533         for(i=0; i < 8 && pktlen; i++, pktlen-- )
 534             k->s2k.salt[i] = iobuf_get_noeof(inp);
 535     }
 536     if( s2kmode == 3 ) {
 537         k->s2k.count = iobuf_get(inp); pktlen--;
 538     }
 539     k->seskeylen = seskeylen;
 540     for(i=0; i < seskeylen && pktlen; i++, pktlen-- )
 541         k->seskey[i] = iobuf_get_noeof(inp);
 542     assert( !pktlen );
 543
 544     if( list_mode ) {
 545         printf(":symkey enc packet: version %d, cipher %d, s2k %d, hash %d\n",
 546                             version, cipher_algo, s2kmode, hash_algo);
 547         if( s2kmode == 1 || s2kmode == 3 ) {
 548             printf("\tsalt ");
 549             for(i=0; i < 8; i++ )
 550                 printf("%02x", k->s2k.salt[i]);
 551             if( s2kmode == 3 )
 552                 printf(", count %lu\n", (ulong)k->s2k.count );
 553             printf("\n");
 554         }
 555     }
 556
 557   leave:
 558     skip_rest(inp, pktlen);
 559     return 0;
 560 }
 561
 562 static int
 563 parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 564 {
 565     unsigned n;
 566     int i, ndata;
 567     PKT_pubkey_enc *k;
 568
 569     k = packet->pkt.pubkey_enc = m_alloc(sizeof *packet->pkt.pubkey_enc );
 570     if( pktlen < 12 ) {
 571         log_error("packet(%d) too short\n", pkttype);
 572         goto leave;
 573     }
 574     k->version = iobuf_get_noeof(inp); pktlen--;
 575     if( k->version != 2 && k->version != 3 ) {
 576         log_error("packet(%d) with unknown version %d\n", pkttype, k->version);
 577         goto leave;
 578     }
 579     k->keyid[0] = read_32(inp); pktlen -= 4;
 580     k->keyid[1] = read_32(inp); pktlen -= 4;
 581     k->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
 582     k->throw_keyid = 0; /* only used as flag for build_packet */
 583     if( list_mode )
 584         printf(":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
 585           k->version, k->pubkey_algo, (ulong)k->keyid[0], (ulong)k->keyid[1]);
 586
 587     ndata = pubkey_get_nenc(k->pubkey_algo);
 588     if( !ndata ) {
 589         if( list_mode )
 590             printf("\tunsupported algorithm %d\n", k->pubkey_algo );
 591         unknown_pubkey_warning( k->pubkey_algo );
 592         k->data[0] = NULL;  /* no need to store the encrypted data */
 593     }
 594     else {
 595         for( i=0; i < ndata; i++ ) {
 596             n = pktlen;
 597             k->data[i] = mpi_read(inp, &n, 0); pktlen -=n;
 598             if( list_mode ) {
 599                 printf("\tdata: ");
 600                 mpi_print(stdout, k->data[i], mpi_print_mode );
 601                 putchar('\n');
 602             }
 603         }
 604     }
 605
 606   leave:
 607     skip_rest(inp, pktlen);
 608     return 0;
 609 }
 610
 611
 612 static void
 613 dump_sig_subpkt( int hashed, int type, int critical,
 614                  const char * buffer, size_t buflen, size_t length )
 615 {
 616     const char *p=NULL;
 617
 618     printf("\t%s%ssubpkt %d len %u (", /*)*/
 619               critical ? "critical ":"",
 620               hashed ? "hashed ":"", type, (unsigned)length );
 621     buffer++;
 622     length--;
 623     if( length > buflen ) {
 624         printf("too short: buffer is only %u)\n", (unsigned)buflen );
 625         return;
 626     }
 627     switch( type ) {
 628       case SIGSUBPKT_SIG_CREATED:
 629         if( length >= 4 )
 630             printf("sig created %s", strtimestamp( buffer_to_u32(buffer) ) );
 631         break;
 632       case SIGSUBPKT_SIG_EXPIRE:
 633         if( length >= 4 )
 634             printf("sig expires %s", strtimestamp( buffer_to_u32(buffer) ) );
 635         break;
 636       case SIGSUBPKT_EXPORTABLE:
 637         if( length )
 638             printf("%sexportable", *buffer? "":"not ");
 639         break;
 640       case SIGSUBPKT_TRUST:
 641         p = "trust signature";
 642         break;
 643       case SIGSUBPKT_REGEXP:
 644         p = "regular expression";
 645         break;
 646       case SIGSUBPKT_REVOCABLE:
 647         p = "revocable";
 648         break;
 649       case SIGSUBPKT_KEY_EXPIRE:
 650         if( length >= 4 )
 651             printf("key expires %s", strtimestamp( buffer_to_u32(buffer) ) );
 652         break;
 653       case SIGSUBPKT_ARR:
 654         p = "additional recipient request";
 655         break;
 656       case SIGSUBPKT_PREF_SYM:
 657         p = "preferred symmetric algorithms";
 658         break;
 659       case SIGSUBPKT_REV_KEY:
 660         p = "revocation key";
 661         break;
 662       case SIGSUBPKT_ISSUER:
 663         if( length >= 8 )
 664             printf("issuer key ID %08lX%08lX",
 665                       (ulong)buffer_to_u32(buffer),
 666                       (ulong)buffer_to_u32(buffer+4) );
 667         break;
 668       case SIGSUBPKT_NOTATION:
 669         p = "notation data";
 670         break;
 671       case SIGSUBPKT_PREF_HASH:
 672         p = "preferred hash algorithms";
 673         break;
 674       case SIGSUBPKT_PREF_COMPR:
 675         p = "preferred compression algorithms";
 676         break;
 677       case SIGSUBPKT_KS_FLAGS:
 678         p = "key server preferences";
 679         break;
 680       case SIGSUBPKT_PREF_KS:
 681         p = "preferred key server";
 682         break;
 683       case SIGSUBPKT_PRIMARY_UID:
 684         p = "primary user id";
 685         break;
 686       case SIGSUBPKT_POLICY:
 687         p = "policy URL";
 688         break;
 689       case SIGSUBPKT_KEY_FLAGS:
 690         p = "key flags";
 691         break;
 692       case SIGSUBPKT_SIGNERS_UID:
 693         p = "signer's user id";
 694         break;
 695       case SIGSUBPKT_PRIV_ADD_SIG:
 696         p = "signs additional user id";
 697         break;
 698       default: p = "?"; break;
 699     }
 700
 701     printf("%s)\n", p? p: "");
 702 }
 703
 704 const byte *
 705 parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
 706 {
 707     int buflen;
 708     int type;
 709     int critical;
 710     size_t n;
 711
 712     if( !buffer )
 713         return NULL;
 714     buflen = (*buffer << 8) | buffer[1];
 715     buffer += 2;
 716     for(;;) {
 717         if( !buflen )
 718             return NULL; /* end of packets; not found */
 719         n = *buffer++; buflen--;
 720         if( n == 255 ) {
 721             if( buflen < 4 )
 722                 goto too_short;
 723             n = (buffer[0] << 24) | (buffer[1] << 16)
 724                                   | (buffer[2] << 8) | buffer[3];
 725             buffer += 4;
 726             buflen -= 4;
 727
 728         }
 729         else if( n >= 192 ) {
 730             if( buflen < 2 )
 731                 goto too_short;
 732             n = (( n - 192 ) << 8) + *buffer + 192;
 733             buflen--;
 734         }
 735         if( buflen < n )
 736             goto too_short;
 737         type = *buffer;
 738         if( type & 0x80 ) {
 739             type &= 0x7f;
 740             critical = 1;
 741         }
 742         else
 743             critical = 0;
 744         if( reqtype < 0 ) /* list packets */
 745             dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
 746                                     type, critical, buffer, buflen, n );
 747         else if( type == reqtype )
 748             break; /* found */
 749         buffer += n; buflen -=n;
 750     }
 751     buffer++;
 752     n--;
 753     if( n > buflen )
 754         goto too_short;
 755     if( ret_n )
 756         *ret_n = n;
 757     switch( type ) {
 758       case SIGSUBPKT_SIG_CREATED:
 759       case SIGSUBPKT_SIG_EXPIRE:
 760       case SIGSUBPKT_KEY_EXPIRE:
 761         if( n < 4 )
 762             break;
 763         return buffer;
 764       case SIGSUBPKT_EXPORTABLE:
 765         if( !n )
 766             break;
 767         return buffer;
 768       case SIGSUBPKT_ISSUER:/* issuer key ID */
 769         if( n < 8 )
 770             break;
 771         return buffer;
 772       case SIGSUBPKT_PREF_SYM:
 773       case SIGSUBPKT_PREF_HASH:
 774       case SIGSUBPKT_PREF_COMPR:
 775         return buffer;
 776       case SIGSUBPKT_PRIV_ADD_SIG:
 777         /* because we use private data, we check the GNUPG marker */
 778         if( n < 24 )
 779             break;
 780         if( buffer[0] != 'G' || buffer[1] != 'P' || buffer[2] != 'G' )
 781             return NULL;
 782         return buffer+3;
 783       default: BUG(); /* not yet needed */
 784     }
 785     log_error("subpacket of type %d too short\n", type);
 786     return NULL;
 787
 788   too_short:
 789     log_error("buffer shorter than subpacket\n");
 790     return NULL;
 791 }
 792
 793
 794 const byte *
 795 parse_sig_subpkt2( PKT_signature *sig, sigsubpkttype_t reqtype, size_t *ret_n )
 796 {
 797     const byte *p;
 798
 799     p = parse_sig_subpkt( sig->hashed_data, reqtype, ret_n );
 800     if( !p )
 801         p = parse_sig_subpkt( sig->unhashed_data, reqtype, ret_n );
 802     return p;
 803 }
 804
 805
 806
 807 static int
 808 parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
 809                                           PKT_signature *sig )
 810 {
 811     int md5_len=0;
 812     unsigned n;
 813     int is_v4=0;
 814     int rc=0;
 815     int i, ndata;
 816
 817     if( pktlen < 16 ) {
 818         log_error("packet(%d) too short\n", pkttype);
 819         goto leave;
 820     }
 821     sig->version = iobuf_get_noeof(inp); pktlen--;
 822     if( sig->version == 4 )
 823         is_v4=1;
 824     else if( sig->version != 2 && sig->version != 3 ) {
 825         log_error("packet(%d) with unknown version %d\n", pkttype, sig->version);
 826         goto leave;
 827     }
 828
 829     if( !is_v4 ) {
 830         md5_len = iobuf_get_noeof(inp); pktlen--;
 831     }
 832     sig->sig_class = iobuf_get_noeof(inp); pktlen--;
 833     if( !is_v4 ) {
 834         sig->timestamp = read_32(inp); pktlen -= 4;
 835         sig->keyid[0] = read_32(inp); pktlen -= 4;
 836         sig->keyid[1] = read_32(inp); pktlen -= 4;
 837     }
 838     sig->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
 839     sig->digest_algo = iobuf_get_noeof(inp); pktlen--;
 840     if( is_v4 ) { /* read subpackets */
 841         n = read_16(inp); pktlen -= 2; /* length of hashed data */
 842         if( n > 10000 ) {
 843             log_error("signature packet: hashed data too long\n");
 844             rc = G10ERR_INVALID_PACKET;
 845             goto leave;
 846         }
 847         if( n ) {
 848             sig->hashed_data = m_alloc( n + 2 );
 849             sig->hashed_data[0] = n << 8;
 850             sig->hashed_data[1] = n;
 851             if( iobuf_read(inp, sig->hashed_data+2, n ) != n ) {
 852                 log_error("premature eof while reading hashed signature data\n");
 853                 rc = -1;
 854                 goto leave;
 855             }
 856             pktlen -= n;
 857         }
 858         n = read_16(inp); pktlen -= 2; /* length of unhashed data */
 859         if( n > 10000 ) {
 860             log_error("signature packet: unhashed data too long\n");
 861             rc = G10ERR_INVALID_PACKET;
 862             goto leave;
 863         }
 864         if( n ) {
 865             sig->unhashed_data = m_alloc( n + 2 );
 866             sig->unhashed_data[0] = n << 8;
 867             sig->unhashed_data[1] = n;
 868             if( iobuf_read(inp, sig->unhashed_data+2, n ) != n ) {
 869                 log_error("premature eof while reading unhashed signature data\n");
 870                 rc = -1;
 871                 goto leave;
 872             }
 873             pktlen -= n;
 874         }
 875     }
 876
 877     if( pktlen < 5 ) { /* sanity check */
 878         log_error("packet(%d) too short\n", pkttype);
 879         rc = G10ERR_INVALID_PACKET;
 880         goto leave;
 881     }
 882
 883     sig->digest_start[0] = iobuf_get_noeof(inp); pktlen--;
 884     sig->digest_start[1] = iobuf_get_noeof(inp); pktlen--;
 885
 886     if( is_v4 ) { /*extract required information */
 887         const byte *p;
 888
 889         /* FIXME: set sig->flags.unknown_critical is there is a
 890          * critical bit set for packets which are not understood
 891          * It does only make sense for hashed data.
 892          */
 893         p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_SIG_CREATED, NULL );
 894         if( !p )
 895             log_error("signature packet without timestamp\n");
 896         else
 897             sig->timestamp = buffer_to_u32(p);
 898         p = parse_sig_subpkt2( sig, SIGSUBPKT_ISSUER, NULL );
 899         if( !p )
 900             log_error("signature packet without keyid\n");
 901         else {
 902             sig->keyid[0] = buffer_to_u32(p);
 903             sig->keyid[1] = buffer_to_u32(p+4);
 904         }
 905     }
 906
 907     if( list_mode ) {
 908         printf(":signature packet: algo %d, keyid %08lX%08lX\n"
 909                "\tversion %d, created %lu, md5len %d, sigclass %02x\n"
 910                "\tdigest algo %d, begin of digest %02x %02x\n",
 911                 sig->pubkey_algo,
 912                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
 913                 sig->version, (ulong)sig->timestamp, md5_len, sig->sig_class,
 914                 sig->digest_algo,
 915                 sig->digest_start[0], sig->digest_start[1] );
 916         if( is_v4 ) {
 917             parse_sig_subpkt( sig->hashed_data,  SIGSUBPKT_LIST_HASHED, NULL );
 918             parse_sig_subpkt( sig->unhashed_data,SIGSUBPKT_LIST_UNHASHED, NULL);
 919         }
 920     }
 921
 922     ndata = pubkey_get_nsig(sig->pubkey_algo);
 923     if( !ndata ) {
 924         if( list_mode )
 925             printf("\tunknown algorithm %d\n", sig->pubkey_algo );
 926         unknown_pubkey_warning( sig->pubkey_algo );
 927         /* we store the plain material in data[0], so that we are able
 928          * to write it back with build_packet() */
 929         sig->data[0] = read_rest(inp, &pktlen );
 930     }
 931     else {
 932         for( i=0; i < ndata; i++ ) {
 933             n = pktlen;
 934             sig->data[i] = mpi_read(inp, &n, 0 );
 935             pktlen -=n;
 936             if( list_mode ) {
 937                 printf("\tdata: ");
 938                 mpi_print(stdout, sig->data[i], mpi_print_mode );
 939                 putchar('\n');
 940             }
 941         }
 942     }
 943
 944
 945   leave:
 946     skip_rest(inp, pktlen);
 947     return rc;
 948 }
 949
 950
 951 static int
 952 parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
 953                                              PKT_onepass_sig *ops )
 954 {
 955     int version;
 956
 957     if( pktlen < 13 ) {
 958         log_error("packet(%d) too short\n", pkttype);
 959         goto leave;
 960     }
 961     version = iobuf_get_noeof(inp); pktlen--;
 962     if( version != 3 ) {
 963         log_error("onepass_sig with unknown version %d\n", version);
 964         goto leave;
 965     }
 966     ops->sig_class = iobuf_get_noeof(inp); pktlen--;
 967     ops->digest_algo = iobuf_get_noeof(inp); pktlen--;
 968     ops->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
 969     ops->keyid[0] = read_32(inp); pktlen -= 4;
 970     ops->keyid[1] = read_32(inp); pktlen -= 4;
 971     ops->last = iobuf_get_noeof(inp); pktlen--;
 972     if( list_mode )
 973         printf(":onepass_sig packet: keyid %08lX%08lX\n"
 974                "\tversion %d, sigclass %02x, digest %d, pubkey %d, last=%d\n",
 975                 (ulong)ops->keyid[0], (ulong)ops->keyid[1],
 976                 version, ops->sig_class,
 977                 ops->digest_algo, ops->pubkey_algo, ops->last );
 978
 979
 980   leave:
 981     skip_rest(inp, pktlen);
 982     return 0;
 983 }
 984
 985
 986
 987
 988 static int
 989 parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
 990                               byte *hdr, int hdrlen, PACKET *pkt )
 991 {
 992     int i, version, algorithm;
 993     unsigned n;
 994     unsigned long timestamp, expiredate;
 995     int npkey, nskey;
 996     int is_v4=0;
 997     int rc=0;
 998
 999     version = iobuf_get_noeof(inp); pktlen--;
1000     if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
1001         /* early versions of G10 use old PGP comments packets;
1002          * luckily all those comments are started by a hash */
1003         if( list_mode ) {
1004             printf(":rfc1991 comment packet: \"" );
1005             for( ; pktlen; pktlen-- ) {
1006                 int c;
1007                 c = iobuf_get_noeof(inp);
1008                 if( c >= ' ' && c <= 'z' )
1009                     putchar(c);
1010                 else
1011                     printf("\\x%02x", c );
1012             }
1013             printf("\"\n");
1014         }
1015         skip_rest(inp, pktlen);
1016         return 0;
1017     }
1018     else if( version == 4 )
1019         is_v4=1;
1020     else if( version != 2 && version != 3 ) {
1021         log_error("packet(%d) with unknown version %d\n", pkttype, version);
1022         goto leave;
1023     }
1024
1025     if( pktlen < 11 ) {
1026         log_error("packet(%d) too short\n", pkttype);
1027         goto leave;
1028     }
1029
1030     timestamp = read_32(inp); pktlen -= 4;
1031     if( is_v4 )
1032         expiredate = 0; /* have to get it from the selfsignature */
1033     else {
1034         unsigned short ndays;
1035         ndays = read_16(inp); pktlen -= 2;
1036         if( ndays )
1037             expiredate = timestamp + ndays * 86400L;
1038         else
1039             expiredate = 0;
1040     }
1041     algorithm = iobuf_get_noeof(inp); pktlen--;
1042     if( list_mode )
1043         printf(":%s key packet:\n"
1044                "\tversion %d, algo %d, created %lu, expires %lu\n",
1045                 pkttype == PKT_PUBLIC_KEY? "public" :
1046                 pkttype == PKT_SECRET_KEY? "secret" :
1047                 pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
1048                 pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
1049                 version, algorithm, timestamp, expiredate );
1050
1051     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
1052         PKT_secret_key *sk = pkt->pkt.secret_key;
1053
1054         sk->timestamp = timestamp;
1055         sk->expiredate = expiredate;
1056         sk->hdrbytes = hdrlen;
1057         sk->version = version;
1058         sk->pubkey_algo = algorithm;
1059         sk->pubkey_usage = 0; /* not yet used */
1060     }
1061     else {
1062         PKT_public_key *pk = pkt->pkt.public_key;
1063
1064         pk->timestamp = timestamp;
1065         pk->expiredate = expiredate;
1066         pk->hdrbytes    = hdrlen;
1067         pk->version     = version;
1068         pk->pubkey_algo = algorithm;
1069         pk->pubkey_usage = 0; /* not yet used */
1070         pk->keyid[0] = 0;
1071         pk->keyid[1] = 0;
1072     }
1073     nskey = pubkey_get_nskey( algorithm );
1074     npkey = pubkey_get_npkey( algorithm );
1075     if( !npkey ) {
1076         if( list_mode )
1077             printf("\tunknown algorithm %d\n", algorithm );
1078         unknown_pubkey_warning( algorithm );
1079     }
1080
1081
1082     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
1083         PKT_secret_key *sk = pkt->pkt.secret_key;
1084         byte temp[8];
1085
1086         if( !npkey ) {
1087             sk->skey[0] = read_rest( inp, &pktlen );
1088             goto leave;
1089         }
1090
1091         for(i=0; i < npkey; i++ ) {
1092             n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1093             if( list_mode ) {
1094                 printf(  "\tskey[%d]: ", i);
1095                 mpi_print(stdout, sk->skey[i], mpi_print_mode  );
1096                 putchar('\n');
1097             }
1098         }
1099         sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1100         if( sk->protect.algo ) {
1101             sk->is_protected = 1;
1102             sk->protect.s2k.count = 0;
1103             if( sk->protect.algo == 255 ) {
1104                 if( pktlen < 3 ) {
1105                     rc = G10ERR_INVALID_PACKET;
1106                     goto leave;
1107                 }
1108                 sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
1109                 sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
1110                 sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
1111                 switch( sk->protect.s2k.mode ) {
1112                   case 1:
1113                   case 3:
1114                     for(i=0; i < 8 && pktlen; i++, pktlen-- )
1115                         temp[i] = iobuf_get_noeof(inp);
1116                     memcpy(sk->protect.s2k.salt, temp, 8 );
1117                     break;
1118                 }
1119                 switch( sk->protect.s2k.mode ) {
1120                   case 0: if( list_mode ) printf(  "\tsimple S2K" );
1121                     break;
1122                   case 1: if( list_mode ) printf(  "\tsalted S2K" );
1123                     break;
1124                   case 3: if( list_mode ) printf(  "\titer+salt S2K" );
1125                     break;
1126                   default:
1127                     if( list_mode )
1128                         printf(  "\tunknown S2K %d\n",
1129                                             sk->protect.s2k.mode );
1130                     rc = G10ERR_INVALID_PACKET;
1131                     goto leave;
1132                 }
1133
1134                 if( list_mode ) {
1135                     printf(", algo: %d, hash: %d",
1136                                      sk->protect.algo,
1137                                      sk->protect.s2k.hash_algo );
1138                     if( sk->protect.s2k.mode == 1
1139                         || sk->protect.s2k.mode == 3 ) {
1140                         printf(", salt: ");
1141                         for(i=0; i < 8; i++ )
1142                             printf("%02x", sk->protect.s2k.salt[i]);
1143                     }
1144                     putchar('\n');
1145                 }
1146
1147                 if( sk->protect.s2k.mode == 3 ) {
1148                     if( pktlen < 1 ) {
1149                         rc = G10ERR_INVALID_PACKET;
1150                         goto leave;
1151                     }
1152                     sk->protect.s2k.count = iobuf_get(inp);
1153                     pktlen--;
1154                     if( list_mode )
1155                         printf("\tprotect count: %lu\n",
1156                                             (ulong)sk->protect.s2k.count);
1157                 }
1158             }
1159             else { /* old version; no S2K, so we set mode to 0, hash MD5 */
1160                 sk->protect.s2k.mode = 0;
1161                 /* We need a kludge to cope with old GNUPG versions */
1162                 sk->protect.s2k.hash_algo =
1163                              ( sk->protect.algo == CIPHER_ALGO_BLOWFISH160
1164                                && algorithm == PUBKEY_ALGO_ELGAMAL_E ) ?
1165                                       DIGEST_ALGO_RMD160 : DIGEST_ALGO_MD5;
1166                 if( list_mode )
1167                     printf(  "\tprotect algo: %d  (hash algo: %d)\n",
1168                          sk->protect.algo, sk->protect.s2k.hash_algo );
1169             }
1170             if( pktlen < 8 ) {
1171                 rc = G10ERR_INVALID_PACKET;
1172                 goto leave;
1173             }
1174             /* fixme: Add support for other blocksizes */
1175             for(i=0; i < 8 && pktlen; i++, pktlen-- )
1176                 temp[i] = iobuf_get_noeof(inp);
1177             if( list_mode ) {
1178                 printf(  "\tprotect IV: ");
1179                 for(i=0; i < 8; i++ )
1180                     printf(" %02x", temp[i] );
1181                 putchar('\n');
1182             }
1183             memcpy(sk->protect.iv, temp, 8 );
1184         }
1185         else
1186             sk->is_protected = 0;
1187         /* It does not make sense to read it into secure memory.
1188          * If the user is so careless, not to protect his secret key,
1189          * we can assume, that he operates an open system :=(.
1190          * So we put the key into secure memory when we unprotect it. */
1191         if( is_v4 && sk->is_protected ){
1192             /* ugly; the length is encrypted too, so we read all
1193              * stuff up to the end of the packet into the first
1194              * skey element */
1195             sk->skey[npkey] = mpi_set_opaque(NULL,
1196                                              read_rest2(inp, pktlen), pktlen );
1197             pktlen = 0;
1198             if( list_mode ) {
1199                 printf("\tencrypted stuff follows\n");
1200             }
1201         }
1202         else { /* v3 method: the mpi length is not encrypted */
1203             for(i=npkey; i < nskey; i++ ) {
1204                 n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1205                 if( sk->is_protected )
1206                     mpi_set_protect_flag(sk->skey[i]);
1207                 if( list_mode ) {
1208                     printf(  "\tskey[%d]: ", i);
1209                     if( sk->is_protected )
1210                         printf(  "[encrypted]\n");
1211                     else {
1212                         mpi_print(stdout, sk->skey[i], mpi_print_mode  );
1213                         putchar('\n');
1214                     }
1215                 }
1216             }
1217
1218             sk->csum = read_16(inp); pktlen -= 2;
1219             if( list_mode ) {
1220                 printf("\tchecksum: %04hx\n", sk->csum);
1221             }
1222         }
1223     }
1224     else {
1225         PKT_public_key *pk = pkt->pkt.public_key;
1226
1227         if( !npkey ) {
1228             pk->pkey[0] = read_rest( inp, &pktlen );
1229             goto leave;
1230         }
1231
1232         for(i=0; i < npkey; i++ ) {
1233             n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
1234             if( list_mode ) {
1235                 printf(  "\tpkey[%d]: ", i);
1236                 mpi_print(stdout, pk->pkey[i], mpi_print_mode  );
1237                 putchar('\n');
1238             }
1239         }
1240     }
1241
1242   leave:
1243     skip_rest(inp, pktlen);
1244     return rc;
1245 }
1246
1247
1248 static int
1249 parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1250 {
1251     byte *p;
1252
1253     packet->pkt.user_id = m_alloc(sizeof *packet->pkt.user_id  + pktlen - 1);
1254     packet->pkt.user_id->len = pktlen;
1255     p = packet->pkt.user_id->name;
1256     for( ; pktlen; pktlen--, p++ )
1257         *p = iobuf_get_noeof(inp);
1258
1259     if( list_mode ) {
1260         int n = packet->pkt.user_id->len;
1261         printf(":user id packet: \"");
1262         for(p=packet->pkt.user_id->name; n; p++, n-- ) {
1263             if( *p >= ' ' && *p <= 'z' )
1264                 putchar(*p);
1265             else
1266                 printf("\\x%02x", *p );
1267         }
1268         printf("\"\n");
1269     }
1270     return 0;
1271 }
1272
1273
1274
1275 static int
1276 parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
1277 {
1278     byte *p;
1279
1280     packet->pkt.comment = m_alloc(sizeof *packet->pkt.comment + pktlen - 1);
1281     packet->pkt.comment->len = pktlen;
1282     p = packet->pkt.comment->data;
1283     for( ; pktlen; pktlen--, p++ )
1284         *p = iobuf_get_noeof(inp);
1285
1286     if( list_mode ) {
1287         int n = packet->pkt.comment->len;
1288         printf(":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
1289                                          "OpenPGP draft " : "" );
1290         for(p=packet->pkt.comment->data; n; p++, n-- ) {
1291             if( *p >= ' ' && *p <= 'z' )
1292                 putchar(*p);
1293             else
1294                 printf("\\x%02x", *p );
1295         }
1296         printf("\"\n");
1297     }
1298     return 0;
1299 }
1300
1301
1302 static void
1303 parse_trust( IOBUF inp, int pkttype, unsigned long pktlen )
1304 {
1305     int c;
1306
1307     c = iobuf_get_noeof(inp);
1308     if( list_mode )
1309         printf(":trust packet: flag=%02x\n", c );
1310 }
1311
1312
1313 static int
1314 parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
1315                                         PACKET *pkt, int new_ctb )
1316 {
1317     int mode, namelen;
1318     PKT_plaintext *pt;
1319     byte *p;
1320     int c, i;
1321
1322     if( pktlen && pktlen < 6 ) {
1323         log_error("packet(%d) too short (%lu)\n", pkttype, (ulong)pktlen);
1324         goto leave;
1325     }
1326     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
1327     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
1328     pt = pkt->pkt.plaintext = m_alloc(sizeof *pkt->pkt.plaintext + namelen -1);
1329     pt->new_ctb = new_ctb;
1330     pt->mode = mode;
1331     pt->namelen = namelen;
1332     if( pktlen ) {
1333         for( i=0; pktlen > 4 && i < namelen; pktlen--, i++ )
1334             pt->name[i] = iobuf_get_noeof(inp);
1335     }
1336     else {
1337         for( i=0; i < namelen; i++ )
1338             if( (c=iobuf_get(inp)) == -1 )
1339                 break;
1340             else
1341                 pt->name[i] = c;
1342     }
1343     pt->timestamp = read_32(inp); if( pktlen) pktlen -= 4;
1344     pt->len = pktlen;
1345     pt->buf = inp;
1346     pktlen = 0;
1347
1348     if( list_mode ) {
1349         printf(":literal data packet:\n"
1350                "\tmode %c, created %lu, name=\"",
1351                     mode >= ' ' && mode <'z'? mode : '?',
1352                     (ulong)pt->timestamp );
1353         for(p=pt->name,i=0; i < namelen; p++, i++ ) {
1354             if( *p >= ' ' && *p <= 'z' )
1355                 putchar(*p);
1356             else
1357                 printf("\\x%02x", *p );
1358         }
1359         printf("\",\n\traw data: %lu bytes\n", (ulong)pt->len );
1360     }
1361
1362   leave:
1363     return 0;
1364 }
1365
1366
1367 static int
1368 parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
1369                   PACKET *pkt, int new_ctb )
1370 {
1371     PKT_compressed *zd;
1372
1373     /* pktlen is here 0, but data follows
1374      * (this should be the last object in a file or
1375      *  the compress algorithm should know the length)
1376      */
1377     zd = pkt->pkt.compressed =  m_alloc(sizeof *pkt->pkt.compressed );
1378     zd->len = 0; /* not yet used */
1379     zd->algorithm = iobuf_get_noeof(inp);
1380     zd->new_ctb = new_ctb;
1381     zd->buf = inp;
1382     if( list_mode )
1383         printf(":compressed packet: algo=%d\n", zd->algorithm);
1384     return 0;
1385 }
1386
1387
1388 static int
1389 parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
1390                                        PACKET *pkt, int new_ctb )
1391 {
1392     PKT_encrypted *ed;
1393
1394     ed = pkt->pkt.encrypted =  m_alloc(sizeof *pkt->pkt.encrypted );
1395     ed->len = pktlen;
1396     ed->buf = NULL;
1397     ed->new_ctb = new_ctb;
1398     if( pktlen && pktlen < 10 ) {
1399         log_error("packet(%d) too short\n", pkttype);
1400         skip_rest(inp, pktlen);
1401         goto leave;
1402     }
1403     if( list_mode ) {
1404         if( pktlen )
1405             printf(":encrypted data packet:\n\tlength: %lu\n", pktlen-10);
1406         else
1407             printf(":encrypted data packet:\n\tlength: unknown\n");
1408     }
1409
1410     ed->buf = inp;
1411     pktlen = 0;
1412
1413   leave:
1414     return 0;
1415 }
1416
1417
1418