See ChangeLog: Tue Mar 2 16:44:57 CET 1999 Werner Koch
[gnupg.git] / g10 / parse-packet.c
index 26c1122..40c737c 100644 (file)
@@ -1,14 +1,14 @@
 /* parse-packet.c  - read packets
  *     Copyright (C) 1998 Free Software Foundation, Inc.
  *
- * This file is part of GNUPG.
+ * This file is part of GnuPG.
  *
- * GNUPG is free software; you can redistribute it and/or modify
+ * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- * GNUPG is distributed in the hope that it will be useful,
+ * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
 #include "memory.h"
 #include "filter.h"
 #include "options.h"
+#include "main.h"
+#include "i18n.h"
 
-static mpi_print_mode = 0;
-static list_mode = 0;
+static int mpi_print_mode = 0;
+static int list_mode = 0;
 
 static int  parse( IOBUF inp, PACKET *pkt, int reqtype,
-                  ulong *retpos, int *skip, IOBUF out, int do_skip );
+                  ulong *retpos, int *skip, IOBUF out, int do_skip
+           #ifdef DEBUG_PARSE_PACKET
+                  ,const char *dbg_w, const char *dbg_f, int dbg_l
+           #endif
+                );
 static int  copy_packet( IOBUF inp, IOBUF out, int pkttype,
                                               unsigned long pktlen );
 static void skip_packet( IOBUF inp, int pkttype, unsigned long pktlen );
 static void skip_rest( IOBUF inp, unsigned long pktlen );
-static int  parse_publickey( IOBUF inp, int pkttype, unsigned long pktlen,
+static void *read_rest( IOBUF inp, ulong *r_pktlen );
+static int  parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
+                                                            PACKET *packet );
+static int  parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen,
                                                             PACKET *packet );
 static int  parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
                                                         PKT_signature *sig );
 static int  parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
                                                        PKT_onepass_sig *ops );
-static int  parse_certificate( IOBUF inp, int pkttype, unsigned long pktlen,
+static int  parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
                                      byte *hdr, int hdrlen, PACKET *packet );
 static int  parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen,
                                                           PACKET *packet );
@@ -56,11 +65,12 @@ static int  parse_comment( IOBUF inp, int pkttype, unsigned long pktlen,
                                                           PACKET *packet );
 static void parse_trust( IOBUF inp, int pkttype, unsigned long pktlen );
 static int  parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
-                                                               PACKET *pkt );
+                                              PACKET *packet, int new_ctb);
 static int  parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
-                                                          PACKET *packet );
+                                              PACKET *packet, int new_ctb );
 static int  parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
-                                                          PACKET *packet );
+                                              PACKET *packet, int new_ctb);
+
 
 static unsigned short
 read_16(IOBUF inp)
@@ -82,16 +92,6 @@ read_32(IOBUF inp)
     return a;
 }
 
-static unsigned long
-buffer_to_u32( const byte *buffer )
-{
-    unsigned long a;
-    a =  *buffer << 24;
-    a |= buffer[1] << 16;
-    a |= buffer[2] << 8;
-    a |= buffer[3];
-    return a;
-}
 
 int
 set_packet_list_mode( int mode )
@@ -102,6 +102,19 @@ set_packet_list_mode( int mode )
     return old;
 }
 
+static void
+unknown_pubkey_warning( int algo )
+{
+    static byte unknown_pubkey_algos[256];
+
+    algo &= 0xff;
+    if( !unknown_pubkey_algos[algo] ) {
+       if( opt.verbose )
+           log_info(_("can't handle public key algorithm %d\n"), algo );
+       unknown_pubkey_algos[algo] = 1;
+    }
+}
+
 /****************
  * Parse a Packet and return it in packet
  * Returns: 0 := valid packet in pkt
@@ -110,6 +123,18 @@ set_packet_list_mode( int mode )
  * Note: The function may return an error and a partly valid packet;
  * caller must free this packet.
  */
+#ifdef DEBUG_PARSE_PACKET
+int
+dbg_parse_packet( IOBUF inp, PACKET *pkt, const char *dbg_f, int dbg_l )
+{
+    int skip, rc;
+
+    do {
+       rc = parse( inp, pkt, 0, NULL, &skip, NULL, 0, "parse", dbg_f, dbg_l );
+    } while( skip );
+    return rc;
+}
+#else
 int
 parse_packet( IOBUF inp, PACKET *pkt )
 {
@@ -120,10 +145,24 @@ parse_packet( IOBUF inp, PACKET *pkt )
     } while( skip );
     return rc;
 }
+#endif
 
 /****************
- * Like parse packet, but do only return packets of the given type.
+ * Like parse packet, but only return packets of the given type.
  */
+#ifdef DEBUG_PARSE_PACKET
+int
+dbg_search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos,
+                  const char *dbg_f, int dbg_l )
+{
+    int skip, rc;
+
+    do {
+       rc = parse( inp, pkt, pkttype, retpos, &skip, NULL, 0, "search", dbg_f, dbg_l );
+    } while( skip );
+    return rc;
+}
+#else
 int
 search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos )
 {
@@ -134,10 +173,24 @@ search_packet( IOBUF inp, PACKET *pkt, int pkttype, ulong *retpos )
     } while( skip );
     return rc;
 }
+#endif
 
 /****************
  * Copy all packets from INP to OUT, thereby removing unused spaces.
  */
+#ifdef DEBUG_PARSE_PACKET
+int
+dbg_copy_all_packets( IOBUF inp, IOBUF out,
+                  const char *dbg_f, int dbg_l )
+{
+    PACKET pkt;
+    int skip, rc=0;
+    do {
+       init_packet(&pkt);
+    } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0, "copy", dbg_f, dbg_l )));
+    return rc;
+}
+#else
 int
 copy_all_packets( IOBUF inp, IOBUF out )
 {
@@ -148,11 +201,28 @@ copy_all_packets( IOBUF inp, IOBUF out )
     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )));
     return rc;
 }
+#endif
 
 /****************
  * Copy some packets from INP to OUT, thereby removing unused spaces.
- * Stop after at offset STOPoff (i.e. don't copy the packet at this offset)
+ * Stop at offset STOPoff (i.e. don't copy packets at this or later offsets)
  */
+#ifdef DEBUG_PARSE_PACKET
+int
+dbg_copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff,
+                  const char *dbg_f, int dbg_l )
+{
+    PACKET pkt;
+    int skip, rc=0;
+    do {
+       if( iobuf_tell(inp) >= stopoff )
+           return 0;
+       init_packet(&pkt);
+    } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0,
+                                    "some", dbg_f, dbg_l )) );
+    return rc;
+}
+#else
 int
 copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff )
 {
@@ -165,10 +235,26 @@ copy_some_packets( IOBUF inp, IOBUF out, ulong stopoff )
     } while( !(rc = parse( inp, &pkt, 0, NULL, &skip, out, 0 )) );
     return rc;
 }
+#endif
 
 /****************
  * Skip over N packets
  */
+#ifdef DEBUG_PARSE_PACKET
+int
+dbg_skip_some_packets( IOBUF inp, unsigned n,
+                  const char *dbg_f, int dbg_l )
+{
+    int skip, rc=0;
+    PACKET pkt;
+
+    for( ;n && !rc; n--) {
+       init_packet(&pkt);
+       rc = parse( inp, &pkt, 0, NULL, &skip, NULL, 1, "skip", dbg_f, dbg_l );
+    }
+    return rc;
+}
+#else
 int
 skip_some_packets( IOBUF inp, unsigned n )
 {
@@ -181,6 +267,8 @@ skip_some_packets( IOBUF inp, unsigned n )
     }
     return rc;
 }
+#endif
+
 
 /****************
  * Parse packet. Set the variable skip points to to 1 if the packet
@@ -191,33 +279,43 @@ skip_some_packets( IOBUF inp, unsigned n )
  */
 static int
 parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
-       int *skip, IOBUF out, int do_skip )
+       int *skip, IOBUF out, int do_skip
+#ifdef DEBUG_PARSE_PACKET
+       ,const char *dbg_w, const char *dbg_f, int dbg_l
+#endif
+     )
 {
-    int rc, c, ctb, pkttype, lenbytes;
+    int rc=0, c, ctb, pkttype, lenbytes;
     unsigned long pktlen;
-    byte hdr[5];
+    byte hdr[8];
     int hdrlen;
-    int pgp3 = 0;
+    int new_ctb = 0;
 
     *skip = 0;
     assert( !pkt->pkt.generic );
     if( retpos )
        *retpos = iobuf_tell(inp);
-    if( (ctb = iobuf_get(inp)) == -1 )
-       return -1;
+
+    if( (ctb = iobuf_get(inp)) == -1 ) {
+       rc = -1;
+       goto leave;
+    }
     hdrlen=0;
     hdr[hdrlen++] = ctb;
     if( !(ctb & 0x80) ) {
-       log_error("%s: invalid packet (ctb=%02x)\n", iobuf_where(inp), ctb );
-       return G10ERR_INVALID_PACKET;
+       log_error("%s: invalid packet (ctb=%02x) near %lu\n",
+                           iobuf_where(inp), ctb, iobuf_tell(inp) );
+       rc = G10ERR_INVALID_PACKET;
+       goto leave;
     }
     pktlen = 0;
-    pgp3 = !!(ctb & 0x40);
-    if( pgp3 ) {
+    new_ctb = !!(ctb & 0x40);
+    if( new_ctb ) {
        pkttype =  ctb & 0x3f;
        if( (c = iobuf_get(inp)) == -1 ) {
            log_error("%s: 1st length byte missing\n", iobuf_where(inp) );
-           return G10ERR_INVALID_PACKET;
+           rc = G10ERR_INVALID_PACKET;
+           goto leave;
        }
        hdr[hdrlen++] = c;
        if( c < 192 )
@@ -226,15 +324,25 @@ parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
            pktlen = (c - 192) * 256;
            if( (c = iobuf_get(inp)) == -1 ) {
                log_error("%s: 2nd length byte missing\n", iobuf_where(inp) );
-               return G10ERR_INVALID_PACKET;
+               rc = G10ERR_INVALID_PACKET;
+               goto leave;
            }
            hdr[hdrlen++] = c;
            pktlen += c + 192;
        }
+       else if( c == 255 ) {
+           pktlen  = (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 24;
+           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 16;
+           pktlen |= (hdr[hdrlen++] = iobuf_get_noeof(inp)) << 8;
+           if( (c = iobuf_get(inp)) == -1 ) {
+               log_error("%s: 4 byte length invalid\n", iobuf_where(inp) );
+               rc = G10ERR_INVALID_PACKET;
+               goto leave;
+           }
+           pktlen |= (hdr[hdrlen++] = c );
+       }
        else { /* partial body length */
-           pktlen = 1 << (c & 0x1f);
-           log_debug("partial body length of %lu bytes\n", pktlen );
-           iobuf_set_partial_block_mode(inp, pktlen);
+           iobuf_set_partial_block_mode(inp, c & 0xff);
            pktlen = 0;/* to indicate partial length */
        }
     }
@@ -259,33 +367,44 @@ parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
            rc = G10ERR_WRITE_FILE;
        else
            rc = copy_packet(inp, out, pkttype, pktlen );
-       return rc;
+       goto leave;
     }
 
     if( do_skip || !pkttype || (reqtype && pkttype != reqtype) ) {
-       skip_packet(inp, pkttype, pktlen);
+       skip_rest(inp, pktlen);
        *skip = 1;
-       return 0;
+       rc = 0;
+       goto leave;
     }
 
-    if( DBG_PACKET )
+    if( DBG_PACKET ) {
+      #ifdef DEBUG_PARSE_PACKET
+       log_debug("parse_packet(iob=%d): type=%d length=%lu%s (%s.%s.%d)\n",
+                  iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"",
+                   dbg_w, dbg_f, dbg_l );
+      #else
        log_debug("parse_packet(iob=%d): type=%d length=%lu%s\n",
-                  iobuf_id(inp), pkttype, pktlen, pgp3?" (pgp3)":"" );
+                  iobuf_id(inp), pkttype, pktlen, new_ctb?" (new_ctb)":"" );
+      #endif
+    }
     pkt->pkttype = pkttype;
     rc = G10ERR_UNKNOWN_PACKET; /* default error */
     switch( pkttype ) {
-      case PKT_PUBLIC_CERT:
-      case PKT_PUBKEY_SUBCERT:
-       pkt->pkt.public_cert = m_alloc_clear(sizeof *pkt->pkt.public_cert );
-       rc = parse_certificate(inp, pkttype, pktlen, hdr, hdrlen, pkt );
+      case PKT_PUBLIC_KEY:
+      case PKT_PUBLIC_SUBKEY:
+       pkt->pkt.public_key = m_alloc_clear(sizeof *pkt->pkt.public_key );
+       rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
        break;
-      case PKT_SECRET_CERT:
-      case PKT_SECKEY_SUBCERT:
-       pkt->pkt.secret_cert = m_alloc_clear(sizeof *pkt->pkt.secret_cert );
-       rc = parse_certificate(inp, pkttype, pktlen, hdr, hdrlen, pkt );
+      case PKT_SECRET_KEY:
+      case PKT_SECRET_SUBKEY:
+       pkt->pkt.secret_key = m_alloc_clear(sizeof *pkt->pkt.secret_key );
+       rc = parse_key(inp, pkttype, pktlen, hdr, hdrlen, pkt );
+       break;
+      case PKT_SYMKEY_ENC:
+       rc = parse_symkeyenc( inp, pkttype, pktlen, pkt );
        break;
       case PKT_PUBKEY_ENC:
-       rc = parse_publickey(inp, pkttype, pktlen, pkt );
+       rc = parse_pubkeyenc(inp, pkttype, pktlen, pkt );
        break;
       case PKT_SIGNATURE:
        pkt->pkt.signature = m_alloc_clear(sizeof *pkt->pkt.signature );
@@ -298,26 +417,31 @@ parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
       case PKT_USER_ID:
        rc = parse_user_id(inp, pkttype, pktlen, pkt );
        break;
+      case PKT_OLD_COMMENT:
       case PKT_COMMENT:
        rc = parse_comment(inp, pkttype, pktlen, pkt);
        break;
       case PKT_RING_TRUST:
        parse_trust(inp, pkttype, pktlen);
+       rc = G10ERR_UNKNOWN_PACKET;
        break;
       case PKT_PLAINTEXT:
-       rc = parse_plaintext(inp, pkttype, pktlen, pkt );
+       rc = parse_plaintext(inp, pkttype, pktlen, pkt, new_ctb );
        break;
       case PKT_COMPRESSED:
-       rc = parse_compressed(inp, pkttype, pktlen, pkt );
+       rc = parse_compressed(inp, pkttype, pktlen, pkt, new_ctb );
        break;
       case PKT_ENCRYPTED:
-       rc = parse_encrypted(inp, pkttype, pktlen, pkt );
+       rc = parse_encrypted(inp, pkttype, pktlen, pkt, new_ctb );
        break;
       default:
        skip_packet(inp, pkttype, pktlen);
        break;
     }
 
+  leave:
+    if( !rc && iobuf_error(inp) )
+       rc = G10ERR_INV_KEYRING;
     return rc;
 }
 
@@ -350,6 +474,7 @@ copy_packet( IOBUF inp, IOBUF out, int pkttype, unsigned long pktlen )
                return G10ERR_WRITE_FILE; /* write error */
     }
     else if( !pktlen && pkttype == PKT_COMPRESSED ) {
+       log_debug("copy_packet: compressed!\n");
        /* compressed packet, copy till EOF */
        while( (n = iobuf_read( inp, buf, 100 )) != -1 )
            if( iobuf_write(out, buf, n ) )
@@ -373,10 +498,14 @@ static void
 skip_packet( IOBUF inp, int pkttype, unsigned long pktlen )
 {
     if( list_mode ) {
-       printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen );
+       if( pkttype == PKT_MARKER )
+           fputs(":marker packet:\n", stdout );
+       else
+           printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen);
        if( pkttype ) {
            int c, i=0 ;
-           printf("dump:");
+           if( pkttype != PKT_MARKER )
+               fputs("dump:", stdout );
            if( iobuf_in_block_mode(inp) ) {
                while( (c=iobuf_get(inp)) != -1 )
                    dump_hex_line(c, &i);
@@ -401,15 +530,135 @@ skip_rest( IOBUF inp, unsigned long pktlen )
     }
     else {
        for( ; pktlen; pktlen-- )
-           iobuf_get(inp);
+           if( iobuf_get(inp) == -1 )
+               break;
+    }
+}
+
+static void *
+read_rest( IOBUF inp, ulong *r_pktlen )
+{
+    byte *p;
+    int i;
+    size_t pktlen = *r_pktlen;
+
+    if( iobuf_in_block_mode(inp) ) {
+       log_error("read_rest: can't store stream data\n");
+       p = NULL;
+    }
+    else {
+       p = m_alloc( pktlen + 2 );
+       p[0] = pktlen >> 8;
+       p[1] = pktlen & 0xff;
+       for(i=2; pktlen; pktlen--, i++ )
+           p[i] = iobuf_get(inp);
+    }
+    *r_pktlen = 0;
+    return p;
+}
+
+static void *
+read_rest2( IOBUF inp, size_t pktlen )
+{
+    byte *p;
+    int i;
+
+    if( iobuf_in_block_mode(inp) ) {
+       log_error("read_rest: can't store stream data\n");
+       p = NULL;
+    }
+    else {
+       p = m_alloc( pktlen );
+       for(i=0; pktlen; pktlen--, i++ )
+           p[i] = iobuf_get(inp);
     }
+    return p;
 }
 
 
+
 static int
-parse_publickey( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
+parse_symkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
+{
+    PKT_symkey_enc *k;
+    int i, version, s2kmode, cipher_algo, hash_algo, seskeylen, minlen;
+
+    if( pktlen < 4 ) {
+       log_error("packet(%d) too short\n", pkttype);
+       goto leave;
+    }
+    version = iobuf_get_noeof(inp); pktlen--;
+    if( version != 4 ) {
+       log_error("packet(%d) with unknown version %d\n", pkttype, version);
+       goto leave;
+    }
+    if( pktlen > 200 ) { /* (we encode the seskeylen in a byte) */
+       log_error("packet(%d) too large\n", pkttype);
+       goto leave;
+    }
+    cipher_algo = iobuf_get_noeof(inp); pktlen--;
+    s2kmode = iobuf_get_noeof(inp); pktlen--;
+    hash_algo = iobuf_get_noeof(inp); pktlen--;
+    switch( s2kmode ) {
+      case 0:  /* simple s2k */
+       minlen = 0;
+       break;
+      case 1:  /* salted s2k */
+       minlen = 8;
+       break;
+      case 3:  /* iterated+salted s2k */
+       minlen = 9;
+       break;
+      default:
+       log_error("unknown S2K %d\n", s2kmode );
+       goto leave;
+    }
+    if( minlen > pktlen ) {
+       log_error("packet with S2K %d too short\n", s2kmode );
+       goto leave;
+    }
+    seskeylen = pktlen - minlen;
+    k = packet->pkt.symkey_enc = m_alloc_clear( sizeof *packet->pkt.symkey_enc
+                                               + seskeylen - 1 );
+    k->version = version;
+    k->cipher_algo = cipher_algo;
+    k->s2k.mode = s2kmode;
+    k->s2k.hash_algo = hash_algo;
+    if( s2kmode == 1 || s2kmode == 3 ) {
+       for(i=0; i < 8 && pktlen; i++, pktlen-- )
+           k->s2k.salt[i] = iobuf_get_noeof(inp);
+    }
+    if( s2kmode == 3 ) {
+       k->s2k.count = iobuf_get(inp); pktlen--;
+    }
+    k->seskeylen = seskeylen;
+    for(i=0; i < seskeylen && pktlen; i++, pktlen-- )
+       k->seskey[i] = iobuf_get_noeof(inp);
+    assert( !pktlen );
+
+    if( list_mode ) {
+       printf(":symkey enc packet: version %d, cipher %d, s2k %d, hash %d\n",
+                           version, cipher_algo, s2kmode, hash_algo);
+       if( s2kmode == 1 || s2kmode == 3 ) {
+           printf("\tsalt ");
+           for(i=0; i < 8; i++ )
+               printf("%02x", k->s2k.salt[i]);
+           if( s2kmode == 3 )
+               printf(", count %lu\n", (ulong)k->s2k.count );
+           printf("\n");
+       }
+    }
+
+  leave:
+    skip_rest(inp, pktlen);
+    return 0;
+}
+
+static int
+parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 {
     unsigned n;
+    int i, ndata;
     PKT_pubkey_enc *k;
 
     k = packet->pkt.pubkey_enc = m_alloc(sizeof *packet->pkt.pubkey_enc );
@@ -425,34 +674,29 @@ parse_publickey( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
     k->keyid[0] = read_32(inp); pktlen -= 4;
     k->keyid[1] = read_32(inp); pktlen -= 4;
     k->pubkey_algo = iobuf_get_noeof(inp); pktlen--;
+    k->throw_keyid = 0; /* only used as flag for build_packet */
     if( list_mode )
-       printf(":public key encoded packet: version %d, keyid %08lX%08lX\n",
-                           k->version, (ulong)k->keyid[0], (ulong)k->keyid[1]);
-    if( k->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
-       n = pktlen;
-       k->d.elg.a = mpi_read(inp, &n, 0); pktlen -=n;
-       n = pktlen;
-       k->d.elg.b = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf("\telg a: ");
-           mpi_print(stdout, k->d.elg.a, mpi_print_mode );
-           printf("\n\telg b: ");
-           mpi_print(stdout, k->d.elg.b, mpi_print_mode );
-           putchar('\n');
-       }
+       printf(":pubkey enc packet: version %d, algo %d, keyid %08lX%08lX\n",
+         k->version, k->pubkey_algo, (ulong)k->keyid[0], (ulong)k->keyid[1]);
+
+    ndata = pubkey_get_nenc(k->pubkey_algo);
+    if( !ndata ) {
+       if( list_mode )
+           printf("\tunsupported algorithm %d\n", k->pubkey_algo );
+       unknown_pubkey_warning( k->pubkey_algo );
+       k->data[0] = NULL;  /* no need to store the encrypted data */
     }
-    else if( k->pubkey_algo == PUBKEY_ALGO_RSA ) {
-       n = pktlen;
-       k->d.rsa.rsa_integer = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf("\trsa integer: ");
-           mpi_print(stdout, k->d.rsa.rsa_integer, mpi_print_mode );
-           putchar('\n');
+    else {
+       for( i=0; i < ndata; i++ ) {
+           n = pktlen;
+           k->data[i] = mpi_read(inp, &n, 0); pktlen -=n;
+           if( list_mode ) {
+               printf("\tdata: ");
+               mpi_print(stdout, k->data[i], mpi_print_mode );
+               putchar('\n');
+           }
        }
     }
-    else if( list_mode )
-       printf("\tunknown algorithm %d\n", k->pubkey_algo );
-
 
   leave:
     skip_rest(inp, pktlen);
@@ -460,20 +704,172 @@ parse_publickey( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 }
 
 
-static const byte *
-parse_subpkt( const byte *buffer, int reqtype )
+static void
+dump_sig_subpkt( int hashed, int type, int critical,
+                const byte *buffer, size_t buflen, size_t length )
+{
+    const char *p=NULL;
+    int i;
+
+    printf("\t%s%ssubpkt %d len %u (", /*)*/
+             critical ? "critical ":"",
+             hashed ? "hashed ":"", type, (unsigned)length );
+    buffer++;
+    length--;
+    if( length > buflen ) {
+       printf("too short: buffer is only %u)\n", (unsigned)buflen );
+       return;
+    }
+    switch( type ) {
+      case SIGSUBPKT_SIG_CREATED:
+       if( length >= 4 )
+           printf("sig created %s", strtimestamp( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_SIG_EXPIRE:
+       if( length >= 4 )
+           printf("sig expires after %s",
+                                    strtimevalue( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_EXPORTABLE:
+       if( length )
+           printf("%sexportable", *buffer? "":"not ");
+       break;
+      case SIGSUBPKT_TRUST:
+       p = "trust signature";
+       break;
+      case SIGSUBPKT_REGEXP:
+       p = "regular expression";
+       break;
+      case SIGSUBPKT_REVOCABLE:
+       p = "revocable";
+       break;
+      case SIGSUBPKT_KEY_EXPIRE:
+       if( length >= 4 )
+           printf("key expires after %s",
+                                   strtimevalue( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_ARR:
+       p = "additional recipient request";
+       break;
+      case SIGSUBPKT_PREF_SYM:
+       fputs("pref-sym-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_REV_KEY:
+       p = "revocation key";
+       break;
+      case SIGSUBPKT_ISSUER:
+       if( length >= 8 )
+           printf("issuer key ID %08lX%08lX",
+                     (ulong)buffer_to_u32(buffer),
+                     (ulong)buffer_to_u32(buffer+4) );
+       break;
+      case SIGSUBPKT_NOTATION:
+       p = "notation data";
+       break;
+      case SIGSUBPKT_PREF_HASH:
+       fputs("pref-hash-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_PREF_COMPR:
+       fputs("pref-zip-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_KS_FLAGS:
+       p = "key server preferences";
+       break;
+      case SIGSUBPKT_PREF_KS:
+       p = "preferred key server";
+       break;
+      case SIGSUBPKT_PRIMARY_UID:
+       p = "primary user id";
+       break;
+      case SIGSUBPKT_POLICY:
+       p = "policy URL";
+       break;
+      case SIGSUBPKT_KEY_FLAGS:
+       p = "key flags";
+       break;
+      case SIGSUBPKT_SIGNERS_UID:
+       p = "signer's user id";
+       break;
+      case SIGSUBPKT_PRIV_ADD_SIG:
+       p = "signs additional user id";
+       break;
+      default: p = "?"; break;
+    }
+
+    printf("%s)\n", p? p: "");
+}
+
+/****************
+ * Returns: >= 0 offset into buffer
+ *         -1 unknown type
+ *         -2 unsupported type
+ *         -3 subpacket too short
+ */
+static int
+parse_one_sig_subpkt( const byte *buffer, size_t n, int type )
+{
+    switch( type ) {
+      case SIGSUBPKT_SIG_CREATED:
+      case SIGSUBPKT_SIG_EXPIRE:
+      case SIGSUBPKT_KEY_EXPIRE:
+       if( n < 4 )
+           break;
+       return 0;
+      case SIGSUBPKT_EXPORTABLE:
+       if( !n )
+           break;
+       return 0;
+      case SIGSUBPKT_ISSUER:/* issuer key ID */
+       if( n < 8 )
+           break;
+       return 0;
+      case SIGSUBPKT_PREF_SYM:
+      case SIGSUBPKT_PREF_HASH:
+      case SIGSUBPKT_PREF_COMPR:
+       return 0;
+      case SIGSUBPKT_PRIV_ADD_SIG:
+       /* because we use private data, we check the GNUPG marker */
+       if( n < 24 )
+           break;
+       if( buffer[0] != 'G' || buffer[1] != 'P' || buffer[2] != 'G' )
+           return -2;
+       return 3;
+      default: return -1;
+    }
+    return -3;
+}
+
+const byte *
+parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
 {
-    int buflen = (*buffer << 8) | buffer[1];
+    int buflen;
     int type;
     int critical;
+    int offset;
     size_t n;
 
+    if( !buffer )
+       return NULL;
+    buflen = (*buffer << 8) | buffer[1];
     buffer += 2;
-    for(;;) {
-       if( !buflen )
-           return NULL; /* end of packets; not found */
+    while( buflen ) {
        n = *buffer++; buflen--;
-       if( n >= 192 ) {
+       if( n == 255 ) {
+           if( buflen < 4 )
+               goto too_short;
+           n = (buffer[0] << 24) | (buffer[1] << 16)
+                                 | (buffer[2] << 8) | buffer[3];
+           buffer += 4;
+           buflen -= 4;
+
+       }
+       else if( n >= 192 ) {
            if( buflen < 2 )
                goto too_short;
            n = (( n - 192 ) << 8) + *buffer + 192;
@@ -488,62 +884,47 @@ parse_subpkt( const byte *buffer, int reqtype )
        }
        else
            critical = 0;
-       if( reqtype < 0 ) { /* list packets */
-           printf("\t%ssubpacket %d of length %u (%s)\n",
-                   reqtype == -1 ? "hashed ":"", type, n,
-                   type == 2 ? "signature creation time"
-                 : type == 3 ? "signature expiration time"
-                 : type == 4 ? "exportable"
-                 : type == 5 ? "trust signature"
-                 : type == 6 ? "regular expression"
-                 : type == 7 ? "revocable"
-                 : type == 9 ? "key expiration time"
-                 : type ==10 ? "additional recipient request"
-                 : type ==11 ? "preferred symmetric algorithms"
-                 : type ==12 ? "revocation key"
-                 : type ==16 ? "issuer key ID"
-                 : type ==20 ? "notation data"
-                 : type ==21 ? "preferred hash algorithms"
-                 : type ==22 ? "preferred compression algorithms"
-                 : type ==23 ? "key server preferences"
-                 : type ==24 ? "preferred key server"
-                             : "?");
+       if( reqtype == SIGSUBPKT_TEST_CRITICAL ) {
+           if( critical ) {
+               if( n-1 > buflen+1 )
+                   goto too_short;
+               if( parse_one_sig_subpkt(buffer+1, n-1, type ) < 0 ) {
+                   log_info(_("subpacket of type %d has critical bit set\n"),
+                                                                       type);
+                   return NULL; /* this is an error */
+               }
+           }
+       }
+       else if( reqtype < 0 ) /* list packets */
+           dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
+                                   type, critical, buffer, buflen, n );
+       else if( type == reqtype ) { /* found */
+           buffer++;
+           n--;
+           if( n > buflen )
+               goto too_short;
+           if( ret_n )
+               *ret_n = n;
+           offset = parse_one_sig_subpkt(buffer, n, type );
+           switch( offset ) {
+             case -3:
+               log_error("subpacket of type %d too short\n", type);
+               return NULL;
+             case -2:
+               return NULL;
+             case -1:
+               BUG(); /* not yet needed */
+             default:
+               break;
+           }
+           return buffer+offset;
        }
-       else if( type == reqtype )
-           break; /* found */
        buffer += n; buflen -=n;
     }
-    buffer++;
-    n--;
-    if( n > buflen )
-       goto too_short;
-    switch( type ) {
-      case 2: /* signature creation time */
-       if( n < 4 )
-           break;
-       return buffer;
-      case 16:/* issuer key ID */
-       if( n < 8 )
-           break;
-       return buffer;
-      case 3: /* signature expiration time */
-      case 4: /* exportable */
-      case 5: /* trust signature */
-      case 6: /* regular expression */
-      case 7: /* revocable */
-      case 9: /* key expiration time */
-      case 10:/* additional recipient request */
-      case 11:/* preferred symmetric algorithms */
-      case 12:/* revocation key */
-      case 20:/* notation data */
-      case 21:/* preferred hash algorithms */
-      case 22:/* preferred compression algorithms */
-      case 23:/* key server preferences */
-      case 24:/* preferred key server */
-      default: BUG(); /* not yet needed */
-    }
-    log_error("subpacket of type %d too short\n", type);
-    return NULL;
+    if( reqtype == SIGSUBPKT_TEST_CRITICAL )
+       return buffer; /* as value true to indicate that there is no */
+                      /* critical bit we don't understand */
+    return NULL; /* end of packets; not found */
 
   too_short:
     log_error("buffer shorter than subpacket\n");
@@ -551,6 +932,19 @@ parse_subpkt( const byte *buffer, int reqtype )
 }
 
 
+const byte *
+parse_sig_subpkt2( PKT_signature *sig, sigsubpkttype_t reqtype, size_t *ret_n )
+{
+    const byte *p;
+
+    p = parse_sig_subpkt( sig->hashed_data, reqtype, ret_n );
+    if( !p )
+       p = parse_sig_subpkt( sig->unhashed_data, reqtype, ret_n );
+    return p;
+}
+
+
+
 static int
 parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
                                          PKT_signature *sig )
@@ -559,6 +953,7 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
     unsigned n;
     int is_v4=0;
     int rc=0;
+    int i, ndata;
 
     if( pktlen < 16 ) {
        log_error("packet(%d) too short\n", pkttype);
@@ -629,14 +1024,24 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
     sig->digest_start[0] = iobuf_get_noeof(inp); pktlen--;
     sig->digest_start[1] = iobuf_get_noeof(inp); pktlen--;
 
-    if( is_v4 ) { /*extract required informations */
+    if( is_v4 ) { /*extract required information */
        const byte *p;
-       p = parse_subpkt( sig->hashed_data, 2 );
+
+       /* set sig->flags.unknown_critical if there is a
+        * critical bit set for packets which we do not understand */
+       if( !parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_TEST_CRITICAL, NULL)
+          || !parse_sig_subpkt( sig->unhashed_data, SIGSUBPKT_TEST_CRITICAL,
+                                                                       NULL) )
+       {
+           sig->flags.unknown_critical = 1;
+       }
+
+       p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_SIG_CREATED, NULL );
        if( !p )
            log_error("signature packet without timestamp\n");
        else
            sig->timestamp = buffer_to_u32(p);
-       p = parse_subpkt( sig->unhashed_data, 16 );
+       p = parse_sig_subpkt2( sig, SIGSUBPKT_ISSUER, NULL );
        if( !p )
            log_error("signature packet without keyid\n");
        else {
@@ -646,55 +1051,41 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
     }
 
     if( list_mode ) {
-       printf(":signature packet: keyid %08lX%08lX\n"
+       printf(":signature packet: algo %d, keyid %08lX%08lX\n"
               "\tversion %d, created %lu, md5len %d, sigclass %02x\n"
               "\tdigest algo %d, begin of digest %02x %02x\n",
+               sig->pubkey_algo,
                (ulong)sig->keyid[0], (ulong)sig->keyid[1],
                sig->version, (ulong)sig->timestamp, md5_len, sig->sig_class,
                sig->digest_algo,
                sig->digest_start[0], sig->digest_start[1] );
        if( is_v4 ) {
-           parse_subpkt( sig->hashed_data, -1 );
-           parse_subpkt( sig->unhashed_data, -2 );
-       }
-    }
-    if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
-       n = pktlen;
-       sig->d.elg.a = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen;
-       sig->d.elg.b = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf("\telg a: ");
-           mpi_print(stdout, sig->d.elg.a, mpi_print_mode );
-           printf("\n\telg b: ");
-           mpi_print(stdout, sig->d.elg.b, mpi_print_mode );
-           putchar('\n');
+           parse_sig_subpkt( sig->hashed_data,  SIGSUBPKT_LIST_HASHED, NULL );
+           parse_sig_subpkt( sig->unhashed_data,SIGSUBPKT_LIST_UNHASHED, NULL);
        }
     }
-    else if( sig->pubkey_algo == PUBKEY_ALGO_DSA ) {
-       n = pktlen;
-       sig->d.dsa.r = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen;
-       sig->d.dsa.s = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf("\tdsa r: ");
-           mpi_print(stdout, sig->d.elg.a, mpi_print_mode );
-           printf("\n\tdsa s: ");
-           mpi_print(stdout, sig->d.elg.b, mpi_print_mode );
-           putchar('\n');
-       }
+
+    ndata = pubkey_get_nsig(sig->pubkey_algo);
+    if( !ndata ) {
+       if( list_mode )
+           printf("\tunknown algorithm %d\n", sig->pubkey_algo );
+       unknown_pubkey_warning( sig->pubkey_algo );
+       /* we store the plain material in data[0], so that we are able
+        * to write it back with build_packet() */
+       sig->data[0] = read_rest(inp, &pktlen );
     }
-    else if( sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
-       n = pktlen;
-       sig->d.rsa.rsa_integer = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf("\trsa integer: ");
-           mpi_print(stdout, sig->d.rsa.rsa_integer, mpi_print_mode );
-           putchar('\n');
+    else {
+       for( i=0; i < ndata; i++ ) {
+           n = pktlen;
+           sig->data[i] = mpi_read(inp, &n, 0 );
+           pktlen -=n;
+           if( list_mode ) {
+               printf("\tdata: ");
+               mpi_print(stdout, sig->data[i], mpi_print_mode );
+               putchar('\n');
+           }
        }
     }
-    else if( list_mode )
-       printf("\tunknown algorithm %d\n", sig->pubkey_algo );
 
 
   leave:
@@ -741,22 +1132,22 @@ parse_onepass_sig( IOBUF inp, int pkttype, unsigned long pktlen,
 
 
 static int
-parse_certificate( IOBUF inp, int pkttype, unsigned long pktlen,
+parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
                              byte *hdr, int hdrlen, PACKET *pkt )
 {
     int i, version, algorithm;
     unsigned n;
-    unsigned long timestamp;
-    unsigned short valid_period;
+    unsigned long timestamp, expiredate;
+    int npkey, nskey;
     int is_v4=0;
     int rc=0;
 
     version = iobuf_get_noeof(inp); pktlen--;
-    if( pkttype == PKT_PUBKEY_SUBCERT && version == '#' ) {
-       /* early versions of G10 use old comments packets; luckily all those
-        * comments are started by a hash */
+    if( pkttype == PKT_PUBLIC_SUBKEY && version == '#' ) {
+       /* early versions of G10 use old PGP comments packets;
+        * luckily all those comments are started by a hash */
        if( list_mode ) {
-           printf(":old comment packet: \"" );
+           printf(":rfc1991 comment packet: \"" );
            for( ; pktlen; pktlen-- ) {
                int c;
                c = iobuf_get_noeof(inp);
@@ -784,355 +1175,216 @@ parse_certificate( IOBUF inp, int pkttype, unsigned long pktlen,
 
     timestamp = read_32(inp); pktlen -= 4;
     if( is_v4 )
-       valid_period = 0;
+       expiredate = 0; /* have to get it from the selfsignature */
     else {
-       valid_period = read_16(inp); pktlen -= 2;
+       unsigned short ndays;
+       ndays = read_16(inp); pktlen -= 2;
+       if( ndays )
+           expiredate = timestamp + ndays * 86400L;
+       else
+           expiredate = 0;
     }
     algorithm = iobuf_get_noeof(inp); pktlen--;
     if( list_mode )
        printf(":%s key packet:\n"
-              "\tversion %d, created %lu, valid for %hu days\n",
-               pkttype == PKT_PUBLIC_CERT? "public" :
-               pkttype == PKT_SECRET_CERT? "secret" :
-               pkttype == PKT_PUBKEY_SUBCERT? "public sub" :
-               pkttype == PKT_SECKEY_SUBCERT? "secret sub" : "??",
-               version, timestamp, valid_period );
-    if( pkttype == PKT_SECRET_CERT || pkttype == PKT_SECKEY_SUBCERT )  {
-       pkt->pkt.secret_cert->timestamp = timestamp;
-       pkt->pkt.secret_cert->valid_days = valid_period;
-       pkt->pkt.secret_cert->hdrbytes = hdrlen;
-       pkt->pkt.secret_cert->version = version;
-       pkt->pkt.secret_cert->pubkey_algo = algorithm;
+              "\tversion %d, algo %d, created %lu, expires %lu\n",
+               pkttype == PKT_PUBLIC_KEY? "public" :
+               pkttype == PKT_SECRET_KEY? "secret" :
+               pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
+               pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
+               version, algorithm, timestamp, expiredate );
+
+    if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
+       PKT_secret_key *sk = pkt->pkt.secret_key;
+
+       sk->timestamp = timestamp;
+       sk->expiredate = expiredate;
+       sk->hdrbytes = hdrlen;
+       sk->version = version;
+       sk->is_primary = pkttype == PKT_SECRET_KEY;
+       sk->pubkey_algo = algorithm;
+       sk->pubkey_usage = 0; /* not yet used */
     }
     else {
-       pkt->pkt.public_cert->timestamp = timestamp;
-       pkt->pkt.public_cert->valid_days = valid_period;
-       pkt->pkt.public_cert->hdrbytes    = hdrlen;
-       pkt->pkt.public_cert->version     = version;
-       pkt->pkt.public_cert->pubkey_algo = algorithm;
-    }
-
-    if( algorithm == PUBKEY_ALGO_ELGAMAL ) {
-       MPI elg_p, elg_g, elg_y;
-       n = pktlen; elg_p = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen; elg_g = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen; elg_y = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf(  "\telg p: ");
-           mpi_print(stdout, elg_p, mpi_print_mode  );
-           printf("\n\telg g: ");
-           mpi_print(stdout, elg_g, mpi_print_mode  );
-           printf("\n\telg y: ");
-           mpi_print(stdout, elg_y, mpi_print_mode  );
-           putchar('\n');
-       }
-       if( pkttype == PKT_PUBLIC_CERT || pkttype == PKT_PUBKEY_SUBCERT ) {
-           pkt->pkt.public_cert->d.elg.p = elg_p;
-           pkt->pkt.public_cert->d.elg.g = elg_g;
-           pkt->pkt.public_cert->d.elg.y = elg_y;
-       }
-       else {
-           PKT_secret_cert *cert = pkt->pkt.secret_cert;
-           byte temp[8];
-
-           pkt->pkt.secret_cert->d.elg.p = elg_p;
-           pkt->pkt.secret_cert->d.elg.g = elg_g;
-           pkt->pkt.secret_cert->d.elg.y = elg_y;
-           cert->protect.algo = iobuf_get_noeof(inp); pktlen--;
-           if( cert->protect.algo ) {
-               cert->is_protected = 1;
-               cert->protect.count = 0;
-               if( cert->protect.algo == 255 ) {
-                   if( pktlen < 3 ) {
-                       rc = G10ERR_INVALID_PACKET;
-                       goto leave;
-                   }
-                   cert->protect.algo = iobuf_get_noeof(inp); pktlen--;
-                   cert->protect.s2k  = iobuf_get_noeof(inp); pktlen--;
-                   cert->protect.hash = iobuf_get_noeof(inp); pktlen--;
-                   switch( cert->protect.s2k ) {
-                     case 1:
-                     case 3:
-                       for(i=0; i < 8 && pktlen; i++, pktlen-- )
-                           temp[i] = iobuf_get_noeof(inp);
-                       memcpy(cert->protect.salt, temp, 8 );
-                       break;
-                   }
-                   switch( cert->protect.s2k ) {
-                     case 0: if( list_mode ) printf(  "\tsimple S2K" );
-                       break;
-                     case 1: if( list_mode ) printf(  "\tsalted S2K" );
-                       break;
-                     case 3: if( list_mode ) printf(  "\titer+salt S2K" );
-                       break;
-                     default:
-                       if( list_mode )
-                           printf(  "\tunknown S2K %d\n",
-                                               cert->protect.s2k );
-                       rc = G10ERR_INVALID_PACKET;
-                       goto leave;
-                   }
+       PKT_public_key *pk = pkt->pkt.public_key;
+
+       pk->timestamp = timestamp;
+       pk->expiredate = expiredate;
+       pk->hdrbytes    = hdrlen;
+       pk->version     = version;
+       pk->pubkey_algo = algorithm;
+       pk->pubkey_usage = 0; /* not yet used */
+       pk->keyid[0] = 0;
+       pk->keyid[1] = 0;
+    }
+    nskey = pubkey_get_nskey( algorithm );
+    npkey = pubkey_get_npkey( algorithm );
+    if( !npkey ) {
+       if( list_mode )
+           printf("\tunknown algorithm %d\n", algorithm );
+       unknown_pubkey_warning( algorithm );
+    }
 
-                   if( list_mode ) {
-                       printf(", algo: %d, hash: %d",
-                                        cert->protect.algo,
-                                        cert->protect.hash );
-                       if( cert->protect.s2k == 1
-                           || cert->protect.s2k == 3 ) {
-                           printf(", salt: ");
-                           for(i=0; i < 8; i++ )
-                               printf("%02x", cert->protect.salt[i]);
-                       }
-                       putchar('\n');
-                   }
 
-                   if( cert->protect.s2k == 3 ) {
-                       if( !pktlen ) {
-                           rc = G10ERR_INVALID_PACKET;
-                           goto leave;
-                       }
-                       cert->protect.count = iobuf_get_noeof(inp);
-                       pktlen--;
-                   }
+    if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY ) {
+       PKT_secret_key *sk = pkt->pkt.secret_key;
+       byte temp[8];
+
+       if( !npkey ) {
+           sk->skey[0] = read_rest( inp, &pktlen );
+           goto leave;
+       }
 
+       for(i=0; i < npkey; i++ ) {
+           n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
+           if( list_mode ) {
+               printf(  "\tskey[%d]: ", i);
+               mpi_print(stdout, sk->skey[i], mpi_print_mode  );
+               putchar('\n');
+           }
+       }
+       sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
+       if( sk->protect.algo ) {
+           sk->is_protected = 1;
+           sk->protect.s2k.count = 0;
+           if( sk->protect.algo == 255 ) {
+               if( pktlen < 3 ) {
+                   rc = G10ERR_INVALID_PACKET;
+                   goto leave;
                }
-               else {
-                   if( list_mode )
-                       printf(  "\tprotect algo: %d\n",
-                                               cert->protect.algo);
-                   /* old version, we don't have a S2K, so we fake one */
-                   cert->protect.s2k = 0;
-                   /* We need this kludge to cope with old GNUPG versions */
-                   cert->protect.hash =
-                        cert->protect.algo == CIPHER_ALGO_BLOWFISH?
-                                     DIGEST_ALGO_RMD160 : DIGEST_ALGO_MD5;
+               sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
+               sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
+               sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
+               switch( sk->protect.s2k.mode ) {
+                 case 1:
+                 case 3:
+                   for(i=0; i < 8 && pktlen; i++, pktlen-- )
+                       temp[i] = iobuf_get_noeof(inp);
+                   memcpy(sk->protect.s2k.salt, temp, 8 );
+                   break;
                }
-               if( pktlen < 8 ) {
+               switch( sk->protect.s2k.mode ) {
+                 case 0: if( list_mode ) printf(  "\tsimple S2K" );
+                   break;
+                 case 1: if( list_mode ) printf(  "\tsalted S2K" );
+                   break;
+                 case 3: if( list_mode ) printf(  "\titer+salt S2K" );
+                   break;
+                 default:
+                   if( list_mode )
+                       printf(  "\tunknown S2K %d\n",
+                                           sk->protect.s2k.mode );
                    rc = G10ERR_INVALID_PACKET;
                    goto leave;
                }
-               for(i=0; i < 8 && pktlen; i++, pktlen-- )
-                   temp[i] = iobuf_get_noeof(inp);
+
                if( list_mode ) {
-                   printf(  "\tprotect IV: ");
-                   for(i=0; i < 8; i++ )
-                       printf(" %02x", temp[i] );
+                   printf(", algo: %d, hash: %d",
+                                    sk->protect.algo,
+                                    sk->protect.s2k.hash_algo );
+                   if( sk->protect.s2k.mode == 1
+                       || sk->protect.s2k.mode == 3 ) {
+                       printf(", salt: ");
+                       for(i=0; i < 8; i++ )
+                           printf("%02x", sk->protect.s2k.salt[i]);
+                   }
                    putchar('\n');
                }
-               memcpy(cert->protect.iv, temp, 8 );
+
+               if( sk->protect.s2k.mode == 3 ) {
+                   if( pktlen < 1 ) {
+                       rc = G10ERR_INVALID_PACKET;
+                       goto leave;
+                   }
+                   sk->protect.s2k.count = iobuf_get(inp);
+                   pktlen--;
+                   if( list_mode )
+                       printf("\tprotect count: %lu\n",
+                                           (ulong)sk->protect.s2k.count);
+               }
            }
-           else
-               cert->is_protected = 0;
-           /* It does not make sense to read it into secure memory.
-            * If the user is so careless, not to protect his secret key,
-            * we can assume, that he operates an open system :=(.
-            * So we put the key into secure memory when we unprotect him. */
-           n = pktlen; cert->d.elg.x = mpi_read(inp, &n, 0 ); pktlen -=n;
-
-           cert->csum = read_16(inp); pktlen -= 2;
+           else { /* old version; no S2K, so we set mode to 0, hash MD5 */
+               sk->protect.s2k.mode = 0;
+               /* We need a kludge to cope with old GNUPG versions */
+               sk->protect.s2k.hash_algo =
+                            ( sk->protect.algo == CIPHER_ALGO_BLOWFISH160
+                              && algorithm == PUBKEY_ALGO_ELGAMAL_E ) ?
+                                     DIGEST_ALGO_RMD160 : DIGEST_ALGO_MD5;
+               if( list_mode )
+                   printf(  "\tprotect algo: %d  (hash algo: %d)\n",
+                        sk->protect.algo, sk->protect.s2k.hash_algo );
+           }
+           if( pktlen < 8 ) {
+               rc = G10ERR_INVALID_PACKET;
+               goto leave;
+           }
+           /* fixme: Add support for other blocksizes */
+           for(i=0; i < 8 && pktlen; i++, pktlen-- )
+               temp[i] = iobuf_get_noeof(inp);
            if( list_mode ) {
-           printf("\telg x: ");
-           mpi_print(stdout, cert->d.elg.x, mpi_print_mode  );
-           putchar('\n');
-               printf("\t[secret value x is not shown]\n"
-                      "\tchecksum: %04hx\n", cert->csum);
+               printf(  "\tprotect IV: ");
+               for(i=0; i < 8; i++ )
+                   printf(" %02x", temp[i] );
+               putchar('\n');
            }
-         /*log_mpidump("elg p=", cert->d.elg.p );
-           log_mpidump("elg g=", cert->d.elg.g );
-           log_mpidump("elg y=", cert->d.elg.y );
-           log_mpidump("elg x=", cert->d.elg.x ); */
-       }
-    }
-    else if( algorithm == PUBKEY_ALGO_DSA ) {
-       MPI dsa_p, dsa_q, dsa_g, dsa_y;
-       n = pktlen; dsa_p = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen; dsa_q = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen; dsa_g = mpi_read(inp, &n, 0 ); pktlen -=n;
-       n = pktlen; dsa_y = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf(  "\tdsa p: ");
-           mpi_print(stdout, dsa_p, mpi_print_mode  );
-           printf("\n\tdsa q: ");
-           mpi_print(stdout, dsa_q, mpi_print_mode  );
-           printf("\n\tdsa g: ");
-           mpi_print(stdout, dsa_g, mpi_print_mode  );
-           printf("\n\tdsa y: ");
-           mpi_print(stdout, dsa_y, mpi_print_mode  );
-           putchar('\n');
+           memcpy(sk->protect.iv, temp, 8 );
        }
-       if( pkttype == PKT_PUBLIC_CERT || pkttype == PKT_PUBKEY_SUBCERT ) {
-           pkt->pkt.public_cert->d.dsa.p = dsa_p;
-           pkt->pkt.public_cert->d.dsa.q = dsa_q;
-           pkt->pkt.public_cert->d.dsa.g = dsa_g;
-           pkt->pkt.public_cert->d.dsa.y = dsa_y;
+       else
+           sk->is_protected = 0;
+       /* It does not make sense to read it into secure memory.
+        * If the user is so careless, not to protect his secret key,
+        * we can assume, that he operates an open system :=(.
+        * So we put the key into secure memory when we unprotect it. */
+       if( is_v4 && sk->is_protected ){
+           /* ugly; the length is encrypted too, so we read all
+            * stuff up to the end of the packet into the first
+            * skey element */
+           sk->skey[npkey] = mpi_set_opaque(NULL,
+                                            read_rest2(inp, pktlen), pktlen );
+           pktlen = 0;
+           if( list_mode ) {
+               printf("\tencrypted stuff follows\n");
+           }
        }
-       else {
-           PKT_secret_cert *cert = pkt->pkt.secret_cert;
-           byte temp[8];
-
-           pkt->pkt.secret_cert->d.dsa.p = dsa_p;
-           pkt->pkt.secret_cert->d.dsa.q = dsa_q;
-           pkt->pkt.secret_cert->d.dsa.g = dsa_g;
-           pkt->pkt.secret_cert->d.dsa.y = dsa_y;
-           cert->protect.algo = iobuf_get_noeof(inp); pktlen--;
-           if( cert->protect.algo ) {
-               cert->is_protected = 1;
-               cert->protect.count = 0;
-               if( cert->protect.algo == 255 ) {
-                   if( pktlen < 3 ) {
-                       rc = G10ERR_INVALID_PACKET;
-                       goto leave;
-                   }
-                   cert->protect.algo = iobuf_get_noeof(inp); pktlen--;
-                   cert->protect.s2k  = iobuf_get_noeof(inp); pktlen--;
-                   cert->protect.hash = iobuf_get_noeof(inp); pktlen--;
-                   switch( cert->protect.s2k ) {
-                     case 1:
-                     case 3:
-                       for(i=0; i < 8 && pktlen; i++, pktlen-- )
-                           temp[i] = iobuf_get_noeof(inp);
-                       memcpy(cert->protect.salt, temp, 8 );
-                       break;
-                   }
-                   switch( cert->protect.s2k ) {
-                     case 0: if( list_mode ) printf(  "\tsimple S2K" );
-                       break;
-                     case 1: if( list_mode ) printf(  "\tsalted S2K" );
-                       break;
-                     case 3: if( list_mode ) printf(  "\titer+salt S2K" );
-                       break;
-                     default:
-                       if( list_mode )
-                           printf(  "\tunknown S2K %d\n", cert->protect.s2k );
-                       rc = G10ERR_INVALID_PACKET;
-                       goto leave;
-                   }
-
-                   if( list_mode ) {
-                       printf(", algo: %d, hash: %d",
-                                        cert->protect.algo,
-                                        cert->protect.hash );
-                       if( cert->protect.s2k == 1 || cert->protect.s2k == 3 ){
-                           printf(", salt: ");
-                           for(i=0; i < 8; i++ )
-                               printf("%02x", cert->protect.salt[i]);
-                       }
+       else { /* v3 method: the mpi length is not encrypted */
+           for(i=npkey; i < nskey; i++ ) {
+               n = pktlen; sk->skey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
+               if( sk->is_protected )
+                   mpi_set_protect_flag(sk->skey[i]);
+               if( list_mode ) {
+                   printf(  "\tskey[%d]: ", i);
+                   if( sk->is_protected )
+                       printf(  "[encrypted]\n");
+                   else {
+                       mpi_print(stdout, sk->skey[i], mpi_print_mode  );
                        putchar('\n');
                    }
-
-                   if( cert->protect.s2k == 3 ) {
-                       if( !pktlen ) {
-                           rc = G10ERR_INVALID_PACKET;
-                           goto leave;
-                       }
-                       cert->protect.count = iobuf_get_noeof(inp);
-                       pktlen--;
-                   }
-
-               }
-               else {
-                   if( list_mode )
-                       printf(  "\tprotect algo: %d\n", cert->protect.algo);
-                   /* old version, we don't have a S2K, so we fake one */
-                   cert->protect.s2k = 0;
-                   cert->protect.hash = DIGEST_ALGO_MD5;
                }
-               if( pktlen < 8 ) {
-                   rc = G10ERR_INVALID_PACKET;
-                   goto leave;
-               }
-               for(i=0; i < 8 && pktlen; i++, pktlen-- )
-                   temp[i] = iobuf_get_noeof(inp);
-               if( list_mode ) {
-                   printf(  "\tprotect IV: ");
-                   for(i=0; i < 8; i++ )
-                       printf(" %02x", temp[i] );
-                   putchar('\n');
-               }
-               memcpy(cert->protect.iv, temp, 8 );
            }
-           else
-               cert->is_protected = 0;
-           /* It does not make sense to read it into secure memory.
-            * If the user is so careless, not to protect his secret key,
-            * we can assume, that he operates an open system :=(.
-            * So we put the key into secure memory when we unprotect him. */
-           n = pktlen; cert->d.dsa.x = mpi_read(inp, &n, 0 ); pktlen -=n;
-
-           cert->csum = read_16(inp); pktlen -= 2;
+
+           sk->csum = read_16(inp); pktlen -= 2;
            if( list_mode ) {
-               printf("\t[secret value x is not shown]\n"
-                      "\tchecksum: %04hx\n", cert->csum);
+               printf("\tchecksum: %04hx\n", sk->csum);
            }
-         /*log_mpidump("dsa p=", cert->d.dsa.p );
-           log_mpidump("dsa q=", cert->d.dsa.q );
-           log_mpidump("dsa g=", cert->d.dsa.g );
-           log_mpidump("dsa y=", cert->d.dsa.y );
-           log_mpidump("dsa x=", cert->d.dsa.x ); */
        }
     }
-    else if( algorithm == PUBKEY_ALGO_RSA ) {
-       MPI rsa_pub_mod, rsa_pub_exp;
+    else {
+       PKT_public_key *pk = pkt->pkt.public_key;
 
-       n = pktlen; rsa_pub_mod = mpi_read(inp, &n, 0); pktlen -=n;
-       n = pktlen; rsa_pub_exp = mpi_read(inp, &n, 0 ); pktlen -=n;
-       if( list_mode ) {
-           printf(  "\tpublic modulus  n:  ");
-           mpi_print(stdout, rsa_pub_mod, mpi_print_mode  );
-           printf("\n\tpublic exponent e: ");
-           mpi_print(stdout, rsa_pub_exp, mpi_print_mode  );
-           putchar('\n');
-       }
-       if( pkttype == PKT_PUBLIC_CERT || pkttype == PKT_PUBKEY_SUBCERT ) {
-           pkt->pkt.public_cert->d.rsa.rsa_n = rsa_pub_mod;
-           pkt->pkt.public_cert->d.rsa.rsa_e = rsa_pub_exp;
+       if( !npkey ) {
+           pk->pkey[0] = read_rest( inp, &pktlen );
+           goto leave;
        }
-       else {
-           PKT_secret_cert *cert = pkt->pkt.secret_cert;
-           byte temp[8];
-
-           pkt->pkt.secret_cert->d.rsa.rsa_n = rsa_pub_mod;
-           pkt->pkt.secret_cert->d.rsa.rsa_e = rsa_pub_exp;
-           cert->protect.algo = iobuf_get_noeof(inp); pktlen--;
-           if( list_mode )
-               printf(  "\tprotect algo: %d\n", cert->protect.algo);
-           if( cert->protect.algo ) {
-               cert->is_protected = 1;
-               for(i=0; i < 8 && pktlen; i++, pktlen-- )
-                   temp[i] = iobuf_get_noeof(inp);
-               if( list_mode ) {
-                   printf(  "\tprotect IV: ");
-                   for(i=0; i < 8; i++ )
-                       printf(" %02x", temp[i] );
-                   putchar('\n');
-               }
-               if( cert->protect.algo == CIPHER_ALGO_BLOWFISH )
-                   memcpy(cert->protect.iv, temp, 8 );
-           }
-           else
-               cert->is_protected = 0;
-           /* (See comments at the code for elg keys) */
-           n = pktlen; cert->d.rsa.rsa_d = mpi_read(inp, &n, 0 ); pktlen -=n;
-           n = pktlen; cert->d.rsa.rsa_p = mpi_read(inp, &n, 0 ); pktlen -=n;
-           n = pktlen; cert->d.rsa.rsa_q = mpi_read(inp, &n, 0 ); pktlen -=n;
-           n = pktlen; cert->d.rsa.rsa_u = mpi_read(inp, &n, 0 ); pktlen -=n;
-
-           cert->csum = read_16(inp); pktlen -= 2;
+
+       for(i=0; i < npkey; i++ ) {
+           n = pktlen; pk->pkey[i] = mpi_read(inp, &n, 0 ); pktlen -=n;
            if( list_mode ) {
-               printf("\t[secret values d,p,q,u are not shown]\n"
-                      "\tchecksum: %04hx\n", cert->csum);
+               printf(  "\tpkey[%d]: ", i);
+               mpi_print(stdout, pk->pkey[i], mpi_print_mode  );
+               putchar('\n');
            }
-        /* log_mpidump("rsa n=", cert->d.rsa.rsa_n );
-           log_mpidump("rsa e=", cert->d.rsa.rsa_e );
-           log_mpidump("rsa d=", cert->d.rsa.rsa_d );
-           log_mpidump("rsa p=", cert->d.rsa.rsa_p );
-           log_mpidump("rsa q=", cert->d.rsa.rsa_q );
-           log_mpidump("rsa u=", cert->d.rsa.rsa_u ); */
        }
     }
-    else if( list_mode )
-       printf("\tunknown algorithm %d\n", algorithm );
-
 
   leave:
     skip_rest(inp, pktlen);
@@ -1145,15 +1397,17 @@ parse_user_id( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 {
     byte *p;
 
-    packet->pkt.user_id = m_alloc(sizeof *packet->pkt.user_id  + pktlen - 1);
+    packet->pkt.user_id = m_alloc(sizeof *packet->pkt.user_id  + pktlen);
     packet->pkt.user_id->len = pktlen;
     p = packet->pkt.user_id->name;
     for( ; pktlen; pktlen--, p++ )
        *p = iobuf_get_noeof(inp);
+    *p = 0;
 
     if( list_mode ) {
        int n = packet->pkt.user_id->len;
        printf(":user id packet: \"");
+       /* fixme: Hey why don't we replace this wioth print_string?? */
        for(p=packet->pkt.user_id->name; n; p++, n-- ) {
            if( *p >= ' ' && *p <= 'z' )
                putchar(*p);
@@ -1180,7 +1434,8 @@ parse_comment( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 
     if( list_mode ) {
        int n = packet->pkt.comment->len;
-       printf(":comment packet: \"");
+       printf(":%scomment packet: \"", pkttype == PKT_OLD_COMMENT?
+                                        "OpenPGP draft " : "" );
        for(p=packet->pkt.comment->data; n; p++, n-- ) {
            if( *p >= ' ' && *p <= 'z' )
                putchar(*p);
@@ -1205,7 +1460,8 @@ parse_trust( IOBUF inp, int pkttype, unsigned long pktlen )
 
 
 static int
-parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
+parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen,
+                                       PACKET *pkt, int new_ctb )
 {
     int mode, namelen;
     PKT_plaintext *pt;
@@ -1219,6 +1475,7 @@ parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
     mode = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
     namelen = iobuf_get_noeof(inp); if( pktlen ) pktlen--;
     pt = pkt->pkt.plaintext = m_alloc(sizeof *pkt->pkt.plaintext + namelen -1);
+    pt->new_ctb = new_ctb;
     pt->mode = mode;
     pt->namelen = namelen;
     if( pktlen ) {
@@ -1257,7 +1514,8 @@ parse_plaintext( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
 
 
 static int
-parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
+parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen,
+                 PACKET *pkt, int new_ctb )
 {
     PKT_compressed *zd;
 
@@ -1268,6 +1526,7 @@ parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
     zd = pkt->pkt.compressed = m_alloc(sizeof *pkt->pkt.compressed );
     zd->len = 0; /* not yet used */
     zd->algorithm = iobuf_get_noeof(inp);
+    zd->new_ctb = new_ctb;
     zd->buf = inp;
     if( list_mode )
        printf(":compressed packet: algo=%d\n", zd->algorithm);
@@ -1276,23 +1535,26 @@ parse_compressed( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
 
 
 static int
-parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *pkt )
+parse_encrypted( IOBUF inp, int pkttype, unsigned long pktlen,
+                                      PACKET *pkt, int new_ctb )
 {
     PKT_encrypted *ed;
 
     ed = pkt->pkt.encrypted =  m_alloc(sizeof *pkt->pkt.encrypted );
     ed->len = pktlen;
     ed->buf = NULL;
+    ed->new_ctb = new_ctb;
     if( pktlen && pktlen < 10 ) {
        log_error("packet(%d) too short\n", pkttype);
        skip_rest(inp, pktlen);
        goto leave;
     }
-    if( list_mode )
+    if( list_mode ) {
        if( pktlen )
            printf(":encrypted data packet:\n\tlength: %lu\n", pktlen-10);
        else
            printf(":encrypted data packet:\n\tlength: unknown\n");
+    }
 
     ed->buf = inp;
     pktlen = 0;