ready to release 0.4.3
[gnupg.git] / g10 / keygen.c
index 293d70a..a17d479 100644 (file)
 #include "ttyio.h"
 #include "options.h"
 #include "keydb.h"
+#include "status.h"
 #include "i18n.h"
 
 
-#if defined(HAVE_RSA_CIPHER) && 0
-  #define ENABLE_RSA_KEYGEN 1
-#endif
-
-
-static u16
-checksum_u16( unsigned n )
+static void
+write_uid( KBNODE root, const char *s )
 {
-    u16 a;
+    PACKET *pkt = m_alloc_clear(sizeof *pkt );
+    size_t n = strlen(s);
 
-    a  = (n >> 8) & 0xff;
-    a |= n & 0xff;
-    return a;
+    pkt->pkttype = PKT_USER_ID;
+    pkt->pkt.user_id = m_alloc( sizeof *pkt->pkt.user_id + n - 1 );
+    pkt->pkt.user_id->len = n;
+    strcpy(pkt->pkt.user_id->name, s);
+    add_kbnode( root, new_kbnode( pkt ) );
 }
 
-static u16
-checksum( byte *p, unsigned n )
+
+
+int
+keygen_add_key_expire( PKT_signature *sig, void *opaque )
 {
-    u16 a;
+    PKT_secret_key *sk = opaque;
+    byte buf[8];
+    u32  u;
+
+    if( sk->expiredate ) {
+       u = sk->expiredate;
+       buf[0] = (u >> 24) & 0xff;
+       buf[1] = (u >> 16) & 0xff;
+       buf[2] = (u >>  8) & 0xff;
+       buf[3] = u & 0xff;
+       build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
+    }
 
-    for(a=0; n; n-- )
-       a += *p++;
-    return a;
+    return 0;
 }
 
-static u16
-checksum_mpi( MPI a )
+
+/****************
+ * Add preference to the self signature packet.
+ * This is only called for packets with version > 3.
+ */
+int
+keygen_add_std_prefs( PKT_signature *sig, void *opaque )
 {
-    u16 csum;
-    byte *buffer;
-    unsigned nbytes;
-
-    buffer = mpi_get_buffer( a, &nbytes, NULL );
-    csum = checksum_u16( nbytes*8 );
-    csum += checksum( buffer, nbytes );
-    m_free( buffer );
-    return csum;
-}
+    byte buf[8];
 
+    keygen_add_key_expire( sig, opaque );
 
+    buf[0] = CIPHER_ALGO_BLOWFISH;
+    buf[1] = CIPHER_ALGO_CAST5;
+    build_sig_subpkt( sig, SIGSUBPKT_PREF_SYM, buf, 2 );
 
-static void
-write_uid( KBNODE root, const char *s )
-{
-    PACKET *pkt = m_alloc_clear(sizeof *pkt );
-    size_t n = strlen(s);
+    buf[0] = DIGEST_ALGO_RMD160;
+    buf[1] = DIGEST_ALGO_SHA1;
+    buf[2] = DIGEST_ALGO_TIGER;
+    buf[3] = DIGEST_ALGO_MD5;
+    build_sig_subpkt( sig, SIGSUBPKT_PREF_HASH, buf, 4 );
 
-    pkt->pkttype = PKT_USER_ID;
-    pkt->pkt.user_id = m_alloc( sizeof *pkt->pkt.user_id + n - 1 );
-    pkt->pkt.user_id->len = n;
-    strcpy(pkt->pkt.user_id->name, s);
-    add_kbnode( root, new_kbnode( pkt ) );
+    buf[0] = 2;
+    buf[1] = 1;
+    build_sig_subpkt( sig, SIGSUBPKT_PREF_COMPR, buf, 2 );
+
+    buf[0] = 0x80; /* no modify - It is reasonable that a key holder
+                   * has the possibility to reject signatures from users
+                   * who are known to sign everything without any
+                   * validation - so a signed key should be send
+                   * to the holder who in turn can put it on a keyserver
+                   */
+    build_sig_subpkt( sig, SIGSUBPKT_KS_FLAGS, buf, 1 );
+
+    return 0;
 }
 
 
+
 static int
-write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
+write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk )
 {
     PACKET *pkt;
     PKT_signature *sig;
     PKT_user_id *uid;
     int rc=0;
     KBNODE node;
-    PKT_public_cert *pkc;
+    PKT_public_key *pk;
 
     if( opt.verbose )
        log_info(_("writing self signature\n"));
@@ -108,14 +127,56 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
     if( !node )
        BUG(); /* no user id packet in tree */
     uid = node->pkt->pkt.user_id;
-    /* get the pkc packet from the pub_tree */
-    node = find_kbnode( pub_root, PKT_PUBLIC_CERT );
+    /* get the pk packet from the pub_tree */
+    node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
+    if( !node )
+       BUG();
+    pk = node->pkt->pkt.public_key;
+
+    /* and make the signature */
+    rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0,
+                            keygen_add_std_prefs, sk );
+    if( rc ) {
+       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
+       return rc;
+    }
+
+    pkt = m_alloc_clear( sizeof *pkt );
+    pkt->pkttype = PKT_SIGNATURE;
+    pkt->pkt.signature = sig;
+    add_kbnode( root, new_kbnode( pkt ) );
+    return rc;
+}
+
+static int
+write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk )
+{
+    PACKET *pkt;
+    PKT_signature *sig;
+    int rc=0;
+    KBNODE node;
+    PKT_public_key *pk, *subpk;
+
+    if( opt.verbose )
+       log_info(_("writing key binding signature\n"));
+
+    /* get the pk packet from the pub_tree */
+    node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
     if( !node )
        BUG();
-    pkc = node->pkt->pkt.public_cert;
+    pk = node->pkt->pkt.public_key;
+    /* find the last subkey */
+    subpk = NULL;
+    for(node=pub_root; node; node = node->next ) {
+       if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
+           subpk = node->pkt->pkt.public_key;
+    }
+    if( !subpk )
+       BUG();
 
     /* and make the signature */
-    rc = make_keysig_packet( &sig, pkc, uid, skc, 0x13, DIGEST_ALGO_RMD160 );
+    rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0,
+                                   keygen_add_key_expire, sk );
     if( rc ) {
        log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
        return rc;
@@ -130,64 +191,69 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
 
 
 static int
-gen_elg(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-       byte *salt, PKT_secret_cert **ret_skc, u16 valid_days )
+gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
+       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expiredate,
+                                                       int version )
 {
     int rc;
     int i;
     PACKET *pkt;
-    PKT_secret_cert *skc;
-    PKT_public_cert *pkc;
-    ELG_public_key pk;
-    ELG_secret_key sk;
+    PKT_secret_key *sk;
+    PKT_public_key *pk;
+    MPI skey[4];
     MPI *factors;
 
-    elg_generate( &pk, &sk, nbits, &factors );
-
-    skc = m_alloc_clear( sizeof *skc );
-    pkc = m_alloc_clear( sizeof *pkc );
-    skc->timestamp = pkc->timestamp = make_timestamp();
-    skc->valid_days = pkc->valid_days = valid_days;
-    skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_ELGAMAL;
-                      pkc->d.elg.p = pk.p;
-                      pkc->d.elg.g = pk.g;
-                      pkc->d.elg.y = pk.y;
-    skc->d.elg.p = sk.p;
-    skc->d.elg.g = sk.g;
-    skc->d.elg.y = sk.y;
-    skc->d.elg.x = sk.x;
-    skc->is_protected = 0;
-    skc->protect.algo = 0;
-
-    skc->csum = checksum_mpi( skc->d.elg.x );
-    /* return an unprotected version of the skc */
-    *ret_skc = copy_secret_cert( NULL, skc );
+    assert( is_ELGAMAL(algo) );
+    rc = pubkey_generate( algo, nbits, skey, &factors );
+    if( rc ) {
+       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
+       return rc;
+    }
+
+    sk = m_alloc_clear( sizeof *sk );
+    pk = m_alloc_clear( sizeof *pk );
+    sk->timestamp = pk->timestamp = make_timestamp();
+    sk->version = pk->version = version;
+    if( expiredate && expiredate < sk->timestamp )
+       expiredate = sk->timestamp; /* key generatio may take long */
+    sk->expiredate = pk->expiredate = expiredate;
+    sk->pubkey_algo = pk->pubkey_algo = algo;
+                      pk->pkey[0] = mpi_copy( skey[0] );
+                      pk->pkey[1] = mpi_copy( skey[1] );
+                      pk->pkey[2] = mpi_copy( skey[2] );
+    sk->skey[0] = skey[0];
+    sk->skey[1] = skey[1];
+    sk->skey[2] = skey[2];
+    sk->skey[3] = skey[3];
+    sk->is_protected = 0;
+    sk->protect.algo = 0;
+
+    sk->csum = checksum_mpi_counted_nbits( sk->skey[3] );
+    if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
+       *ret_sk = copy_secret_key( NULL, sk );
 
     if( dek ) {
-       skc->protect.algo = CIPHER_ALGO_BLOWFISH;
-       skc->protect.s2k  = 1;
-       skc->protect.hash = DIGEST_ALGO_RMD160;
-       memcpy(skc->protect.salt, salt, 8);
-       randomize_buffer(skc->protect.iv, 8, 1);
-       rc = protect_secret_key( skc, dek );
+       sk->protect.algo = dek->algo;
+       sk->protect.s2k = *s2k;
+       rc = protect_secret_key( sk, dek );
        if( rc ) {
            log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
-           free_public_cert(pkc);
-           free_secret_cert(skc);
+           free_public_key(pk);
+           free_secret_key(sk);
            return rc;
        }
     }
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = PKT_PUBLIC_CERT;
-    pkt->pkt.public_cert = pkc;
+    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+    pkt->pkt.public_key = pk;
     add_kbnode(pub_root, new_kbnode( pkt ));
 
-    /* don't know wether it make sense to have the factors, so for now
-     * we store them in the secret keyring (but they are of secret) */
+    /* don't know whether it makes sense to have the factors, so for now
+     * we store them in the secret keyring (but they are not secret) */
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = PKT_SECRET_CERT;
-    pkt->pkt.secret_cert = skc;
+    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+    pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
     for(i=0; factors[i]; i++ )
        add_kbnode( sec_root,
@@ -197,77 +263,86 @@ gen_elg(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
 }
 
 
-
-#ifdef ENABLE_RSA_KEYGEN
+/****************
+ * Generate a DSA key
+ */
 static int
-gen_rsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-       byte *salt, PKT_secret_cert **ret_skc, u16 valid_days )
+gen_dsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
+           STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expiredate )
 {
     int rc;
+    int i;
     PACKET *pkt;
-    PKT_secret_cert *skc;
-    PKT_public_cert *pkc;
-    RSA_public_key pk;
-    RSA_secret_key sk;
-
-    rsa_generate( &pk, &sk, nbits );
-
-    skc = m_alloc_clear( sizeof *skc );
-    pkc = m_alloc_clear( sizeof *pkc );
-    skc->timestamp = pkc->timestamp = make_timestamp();
-    skc->valid_days = pkc->valid_days = valid_days;
-    skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_RSA;
-                      memset(&pkc->mfx, 0, sizeof pkc->mfx);
-                      pkc->d.rsa.rsa_n = pk.n;
-                      pkc->d.rsa.rsa_e = pk.e;
-    skc->d.rsa.rsa_n = sk.n;
-    skc->d.rsa.rsa_e = sk.e;
-    skc->d.rsa.rsa_d = sk.d;
-    skc->d.rsa.rsa_p = sk.p;
-    skc->d.rsa.rsa_q = sk.q;
-    skc->d.rsa.rsa_u = sk.u;
-    skc->d.rsa.csum  = checksum_mpi( skc->d.rsa.rsa_d );
-    skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_p );
-    skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_q );
-    skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_u );
-
-    /* return an unprotected version of the skc */
-    *ret_skc = copy_secret_cert( NULL, skc );
+    PKT_secret_key *sk;
+    PKT_public_key *pk;
+    MPI skey[5];
+    MPI *factors;
+
+    if( nbits > 1024 )
+       nbits = 1024;
+
+    rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
+    if( rc ) {
+       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
+       return rc;
+    }
+
+    sk = m_alloc_clear( sizeof *sk );
+    pk = m_alloc_clear( sizeof *pk );
+    sk->timestamp = pk->timestamp = make_timestamp();
+    sk->version = pk->version = 4;
+    if( expiredate && expiredate < pk->timestamp )
+       expiredate = pk->timestamp; /* key generation may take long */
+    sk->expiredate = pk->expiredate = expiredate;
+    sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
+                      pk->pkey[0] = mpi_copy( skey[0] );
+                      pk->pkey[1] = mpi_copy( skey[1] );
+                      pk->pkey[2] = mpi_copy( skey[2] );
+                      pk->pkey[3] = mpi_copy( skey[3] );
+    sk->skey[0] = skey[0];
+    sk->skey[1] = skey[1];
+    sk->skey[2] = skey[2];
+    sk->skey[3] = skey[3];
+    sk->skey[4] = skey[4];
+    sk->is_protected = 0;
+    sk->protect.algo = 0;
+
+    sk->csum = checksum_mpi_counted_nbits( sk->skey[4] );
+    if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
+       *ret_sk = copy_secret_key( NULL, sk );
 
     if( dek ) {
-       skc->d.rsa.is_protected = 1;
-       skc->d.rsa.protect_algo = CIPHER_ALGO_BLOWFISH;
-       randomize_buffer( skc->d.rsa.protect.blowfish.iv, 8, 1);
-       skc->d.rsa.csum += checksum( skc->d.rsa.protect.blowfish.iv, 8 );
-       rc = protect_secret_key( skc, dek );
+       sk->protect.algo = dek->algo;
+       sk->protect.s2k = *s2k;
+       rc = protect_secret_key( sk, dek );
        if( rc ) {
            log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
-           free_public_cert(pkc);
-           free_secret_cert(skc);
+           free_public_key(pk);
+           free_secret_key(sk);
            return rc;
        }
     }
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = PKT_PUBLIC_CERT;
-    pkt->pkt.public_cert = pkc;
+    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+    pkt->pkt.public_key = pk;
     add_kbnode(pub_root, new_kbnode( pkt ));
 
+    /* don't know whether it makes sense to have the factors, so for now
+     * we store them in the secret keyring (but they are not secret)
+     * p = 2 * q * f1 * f2 * ... * fn
+     * We store only f1 to f_n-1;  fn can be calculated because p and q
+     * are known.
+     */
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = PKT_SECRET_CERT;
-    pkt->pkt.secret_cert = skc;
+    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+    pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
+    for(i=1; factors[i]; i++ ) /* the first one is q */
+       add_kbnode( sec_root,
+                   make_mpi_comment_node("#:DSA_factor:", factors[i] ));
 
-    return rc;
-}
-#endif /*ENABLE_RSA_KEYGEN*/
-
-
-static int
-gen_dsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-        byte *salt, PKT_secret_cert **ret_skc, u16 valid_days )
-{
-    return G10ERR_GENERAL;
+    return 0;
 }
 
 
@@ -301,104 +376,94 @@ check_valid_days( const char *s )
 
 
 /****************
- * Generate a keypair
+ * Returns: 0 to create both a DSA and a ElGamal key.
  */
-void
-generate_keypair()
+static int
+ask_algo( int *ret_v4, int addmode )
 {
     char *answer;
-    unsigned nbits;
-    char *pub_fname = NULL;
-    char *sec_fname = NULL;
-    char *uid = NULL;
-    KBNODE pub_root = NULL;
-    KBNODE sec_root = NULL;
-    PKT_secret_cert *skc = NULL;
-    DEK *dek = NULL;
-    byte *salt;
-    int rc;
     int algo;
-    const char *algo_name;
-    char *aname, *acomment, *amail;
-    int valid_days=0;
-
-    if( opt.batch || opt.answer_yes || opt.answer_no ) {
-       log_error(_("Key generation can only be used in interactive mode\n"));
-       return;
-    }
 
-    tty_printf(_("Please select the algorithm to use:\n"
-                "   (1) ElGamal is the suggested one.\n"
-                "   (2) DSA can only be used for signatures.\n"));
-  #ifdef ENABLE_RSA_KEYGEN
-    tty_printf(_("   (3) RSA cannot be used in the U.S.\n"));
-  #endif
+    tty_printf(_("Please select what kind of key you want:\n"));
+    if( !addmode )
+       tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
+    tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 2 );
+    if( addmode )
+       tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
+    tty_printf(    _("   (%d) DSA (sign only)\n"), 4 );
+    tty_printf(    _("   (%d) ElGamal in a v3 packet\n"), 5 );
 
+    *ret_v4 = 1;
     for(;;) {
-      #ifdef ENABLE_RSA_KEYGEN
-       answer = tty_get(_("Your selection? (1,2,3) "));
-      #else
-       answer = tty_get(_("Your selection? (1,2) "));
-      #endif
-       tty_kill_prompt();
+       answer = cpr_get(N_("keygen.algo"),_("Your selection? "));
+       cpr_kill_prompt();
        algo = *answer? atoi(answer): 1;
        m_free(answer);
-       if( algo == 1 ) {
-           algo = PUBKEY_ALGO_ELGAMAL;
-           algo_name = "ElGamal";
+       if( algo == 1 && !addmode ) {
+           algo = 0;   /* create both keys */
            break;
        }
        else if( algo == 2 ) {
+           algo = PUBKEY_ALGO_ELGAMAL;
+           break;
+       }
+       else if( algo == 3 && addmode ) {
+           algo = PUBKEY_ALGO_ELGAMAL_E;
+           break;
+       }
+       else if( algo == 4 ) {
            algo = PUBKEY_ALGO_DSA;
-           algo_name = "DSA";
-           tty_printf(_("Sorry; DSA key generation is not yet supported.\n"));
+           break;
        }
-      #ifdef ENABLE_RSA_KEYGEN
-       else if( algo == 3 ) {
-           algo = PUBKEY_ALGO_RSA;
-           algo_name = "RSA";
+       else if( algo == 5 ) {
+           algo = PUBKEY_ALGO_ELGAMAL_E;
+           *ret_v4 = 0;
            break;
        }
-      #endif
+       else
+           tty_printf(_("Invalid selection.\n"));
     }
+    return algo;
+}
 
 
+static unsigned
+ask_keysize( int algo )
+{
+    char *answer;
+    unsigned nbits;
 
     tty_printf(_("About to generate a new %s keypair.\n"
                 "              minimum keysize is  768 bits\n"
                 "              default keysize is 1024 bits\n"
-                "    highest suggested keysize is 2048 bits\n"), algo_name );
+                "    highest suggested keysize is 2048 bits\n"),
+                                       pubkey_algo_to_string(algo) );
     for(;;) {
-       answer = tty_get(_("What keysize do you want? (1024) "));
-       tty_kill_prompt();
+       answer = cpr_get(N_("keygen.size"),
+                         _("What keysize do you want? (1024) "));
+       cpr_kill_prompt();
        nbits = *answer? atoi(answer): 1024;
        m_free(answer);
        if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
-           tty_printf(_("DSA does only allow keysizes from 512 to 1024\n"));
+           tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
        else if( nbits < 768 )
            tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
-       else if( nbits > 2048 ) {
-           tty_printf(_("Keysizes larger than 2048 are not suggested, because "
-                        "computations take REALLY long!\n"));
-           answer = tty_get(_("Are you sure, that you want this keysize? "));
-           tty_kill_prompt();
-           if( answer_is_yes(answer) ) {
-               m_free(answer);
+       else if( nbits > 2048 && !cpr_enabled() ) {
+           tty_printf(
+               _("Keysizes larger than 2048 are not suggested because\n"
+                 "computations take REALLY long!\n"));
+           if( cpr_get_answer_is_yes(N_("keygen.size.huge.okay"),_(
+                       "Are you sure that you want this keysize? ")) ) {
                tty_printf(_("Okay, but keep in mind that your monitor "
                             "and keyboard radiation is also very vulnerable "
                             "to attacks!\n"));
                break;
            }
-           m_free(answer);
        }
-       else if( nbits > 1536 ) {
-           answer = tty_get(_("Do you really need such a large keysize? "));
-           tty_kill_prompt();
-           if( answer_is_yes(answer) ) {
-               m_free(answer);
+       else if( nbits > 1536 && !cpr_enabled() ) {
+           if( cpr_get_answer_is_yes(N_("keygen.size.large.okay"),_(
+                   "Do you really need such a large keysize? ")) )
                break;
-           }
-           m_free(answer);
        }
        else
            break;
@@ -412,6 +477,16 @@ generate_keypair()
        nbits = ((nbits + 31) / 32) * 32;
        tty_printf(_("rounded up to %u bits\n"), nbits );
     }
+    return nbits;
+}
+
+
+u32
+ask_expiredate()
+{
+    char *answer;
+    int valid_days=0;
+    u32 expiredate = 0;
 
     tty_printf(_("Please specify how long the key should be valid.\n"
                 "         0 = key does not expire\n"
@@ -419,13 +494,17 @@ generate_keypair()
                 "      <n>w = key expires in n weeks\n"
                 "      <n>m = key expires in n months\n"
                 "      <n>y = key expires in n years\n"));
+    /* Note: The elgamal subkey for DSA has no exiration date because
+     * it must be signed with the DSA key and this one has the expiration
+     * date */
+
     answer = NULL;
     for(;;) {
        int mult;
 
        m_free(answer);
-       answer = tty_get(_("Key is valid for? (0) "));
-       tty_kill_prompt();
+       answer = cpr_get(N_("keygen.valid"),_("Key is valid for? (0) "));
+       cpr_kill_prompt();
        trim_spaces(answer);
        if( !*answer )
            valid_days = 0;
@@ -439,38 +518,68 @@ generate_keypair()
            continue;
        }
 
-       if( !valid_days )
+       if( !valid_days ) {
            tty_printf(_("Key does not expire at all\n"));
+           expiredate = 0;
+       }
        else {
-           tty_printf(_("Key expires at %s\n"), strtimestamp(
-                      add_days_to_timestamp( make_timestamp(), valid_days )));
+           expiredate = make_timestamp() + valid_days * 86400L;
+           /* print the date when the key expires */
+           tty_printf(_("Key expires at %s\n"), asctimestamp(expiredate) );
        }
 
-       m_free(answer);
-       answer = tty_get(_("Is this correct (y/n)? "));
-       tty_kill_prompt();
-       if( answer_is_yes(answer) )
+       if( !cpr_enabled()
+            && cpr_get_answer_is_yes(N_("keygen.valid.okay"),
+                                      _("Is this correct (y/n)? ")) )
            break;
     }
     m_free(answer);
+    return expiredate;
+}
+
+
+static int
+has_invalid_email_chars( const char *s )
+{
+    int at_seen=0;
+
+    for( ; *s; s++ ) {
+       if( *s & 0x80 )
+           return 1;
+       if( *s == '@' )
+           at_seen=1;
+       else if( !at_seen
+                && !strchr("01234567890abcdefghijklmnopqrstuvwxyz_-.+", *s ))
+           return 1;
+       else if( at_seen
+                && !strchr("01234567890abcdefghijklmnopqrstuvwxyz_-.", *s ) )
+           return 1;
+    }
+    return 0;
+}
 
 
+static char *
+ask_user_id( int mode )
+{
+    char *answer;
+    char *aname, *acomment, *amail, *uid;
 
-    tty_printf( _("\n"
+    if( !mode )
+       tty_printf( _("\n"
 "You need a User-ID to identify your key; the software constructs the user id\n"
 "from Real Name, Comment and Email Address in this form:\n"
 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
-    uid = NULL;
-    aname=acomment=amail=NULL;
+    uid = aname = acomment = amail = NULL;
     for(;;) {
        char *p;
 
        if( !aname ) {
            for(;;) {
                m_free(aname);
-               aname = tty_get(_("Real name: "));
+               aname = cpr_get(N_("keygen.name"),_("Real name: "));
                trim_spaces(aname);
-               tty_kill_prompt();
+               cpr_kill_prompt();
                if( strpbrk( aname, "<([])>" ) )
                    tty_printf(_("Invalid character in name\n"));
                else if( isdigit(*aname) )
@@ -484,13 +593,13 @@ generate_keypair()
        if( !amail ) {
            for(;;) {
                m_free(amail);
-               amail = tty_get(_("Email address: "));
+               amail = cpr_get(N_("keygen.email"),_("Email address: "));
                trim_spaces(amail);
                strlwr(amail);
-               tty_kill_prompt();
+               cpr_kill_prompt();
                if( !*amail )
                    break;   /* no email address is okay */
-               else if( strcspn( amail, "abcdefghijklmnopqrstuvwxyz_-.@" )
+               else if( has_invalid_email_chars(amail)
                         || string_count_chr(amail,'@') != 1
                         || *amail == '@'
                         || amail[strlen(amail)-1] == '@'
@@ -504,9 +613,9 @@ generate_keypair()
        if( !acomment ) {
            for(;;) {
                m_free(acomment);
-               acomment = tty_get(_("Comment: "));
+               acomment = cpr_get(N_("keygen.comment"),_("Comment: "));
                trim_spaces(acomment);
-               tty_kill_prompt();
+               cpr_kill_prompt();
                if( !*acomment )
                    break;   /* no comment is okay */
                else if( strpbrk( acomment, "()" ) )
@@ -531,28 +640,46 @@ generate_keypair()
 
 
        tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
-       /* fixme: add a warning if this the user-id already exists */
+       /* fixme: add a warning if this user-id already exists */
        for(;;) {
-           answer = tty_get(_("Edit (N)ame, (C)omment, (E)mail or (O)kay? "));
-           tty_kill_prompt();
+           char *ansstr = _("NnCcEeOoQq");
+
+           if( strlen(ansstr) != 10 )
+               BUG();
+           if( cpr_enabled() ) {
+               answer = m_strdup(ansstr+6);
+               answer[1] = 0;
+           }
+           else {
+               answer = cpr_get(N_("keygen.userid.cmd"),_(
+                   "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
+               cpr_kill_prompt();
+           }
            if( strlen(answer) > 1 )
                ;
-           else if( *answer == 'N' || *answer == 'n' ) {
+           else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
                m_free(aname); aname = NULL;
                break;
            }
-           else if( *answer == 'C' || *answer == 'c' ) {
+           else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
                m_free(acomment); acomment = NULL;
                break;
            }
-           else if( *answer == 'E' || *answer == 'e' ) {
+           else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
+               m_free(amail); amail = NULL;
+               break;
+           }
+           else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
+               m_free(aname); aname = NULL;
+               m_free(acomment); acomment = NULL;
                m_free(amail); amail = NULL;
                break;
            }
-           else if( *answer == 'O' || *answer == 'o' ) {
+           else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
                m_free(aname); aname = NULL;
                m_free(acomment); acomment = NULL;
                m_free(amail); amail = NULL;
+               m_free(uid); uid = NULL;
                break;
            }
            m_free(answer);
@@ -562,53 +689,54 @@ generate_keypair()
            break;
        m_free(uid); uid = NULL;
     }
+    if( uid ) {
+       char *p = native_to_utf8( uid );
+       m_free( uid );
+       uid = p;
+    }
+    return uid;
+}
 
 
+static DEK *
+ask_passphrase( STRING2KEY **ret_s2k )
+{
+    DEK *dek = NULL;
+    STRING2KEY *s2k;
+
     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
 
-    dek = m_alloc_secure( sizeof *dek + 8 );
-    salt = (byte*)dek + sizeof *dek;
+    s2k = m_alloc_secure( sizeof *s2k );
     for(;;) {
-       dek->algo = CIPHER_ALGO_BLOWFISH;
-       randomize_buffer(salt, 8, 1);
-       rc = make_dek_from_passphrase( dek , 2, salt );
-       if( rc == -1 ) {
-           m_free(dek); dek = NULL;
-           tty_printf(_(
-           "You don't what a passphrase - this is probably a *bad* idea!\n"
-           "I will do it anyway.  You can change your passphrase at anytime,\n"
-           "using this program with the option \"--change-passphrase\"\n\n"));
-           break;
-       }
-       else if( rc == G10ERR_PASSPHRASE ) {
+       s2k->mode = opt.s2k_mode;
+       s2k->hash_algo = opt.s2k_digest_algo;
+       dek = passphrase_to_dek( NULL, opt.s2k_cipher_algo, s2k, 2 );
+       if( !dek ) {
            tty_printf(_("passphrase not correctly repeated; try again.\n"));
        }
-       else if( rc ) {
+       else if( !dek->keylen ) {
            m_free(dek); dek = NULL;
-           m_free(uid);
-           log_error("Error getting the passphrase: %s\n", g10_errstr(rc) );
-           return;
+           m_free(s2k); s2k = NULL;
+           tty_printf(_(
+           "You don't want a passphrase - this is probably a *bad* idea!\n"
+           "I will do it anyway.  You can change your passphrase at any time,\n"
+           "using this program with the option \"--edit-key\".\n\n"));
+           break;
        }
        else
            break; /* okay */
     }
+    *ret_s2k = s2k;
+    return dek;
+}
 
 
-    /* now check wether we a are allowed to write to the keyrings */
-    pub_fname = make_filename(opt.homedir, "pubring.gpg", NULL );
-    sec_fname = make_filename(opt.homedir, "secring.gpg", NULL );
-    if( opt.verbose ) {
-       tty_printf(_("writing public certificate to '%s'\n"), pub_fname );
-       tty_printf(_("writing secret certificate to '%s'\n"), sec_fname );
-    }
-
-    /* we create the packets as a tree of kbnodes. Because the structure
-     * we create is known in advance we simply generate a linked list
-     * The first packet is a dummy comment packet which we flag
-     * as deleted.  The very first packet must always be a CERT packet.
-     */
-    pub_root = make_comment_node("#"); delete_kbnode(pub_root);
-    sec_root = make_comment_node("#"); delete_kbnode(sec_root);
+static int
+do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
+          DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
+                                                            int v4_packet )
+{
+    int rc=0;
 
     tty_printf(_(
 "We need to generate a lot of random bytes. It is a good idea to perform\n"
@@ -616,16 +744,15 @@ generate_keypair()
 "network and the disks) during the prime generation; this gives the random\n"
 "number generator a better chance to gain enough entropy.\n") );
 
-    if( algo == PUBKEY_ALGO_ELGAMAL )
-       rc = gen_elg(nbits, pub_root, sec_root, dek, salt,  &skc, valid_days );
-  #ifdef ENABLE_RSA_KEYGEN
-    else if( algo == PUBKEY_ALGO_RSA )
-       rc = gen_rsa(nbits, pub_root, sec_root, dek, salt, &skc, valid_days  );
-  #endif
+    if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
+       rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k,
+                          sk, expiredate, v4_packet? 4:3 );
     else if( algo == PUBKEY_ALGO_DSA )
-       rc = gen_dsa(nbits, pub_root, sec_root, dek, salt, &skc, valid_days  );
+       rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
     else
        BUG();
+
+  #ifdef ENABLE_COMMENT_PACKETS
     if( !rc ) {
        add_kbnode( pub_root,
                make_comment_node("#created by GNUPG v" VERSION " ("
@@ -634,14 +761,114 @@ generate_keypair()
                make_comment_node("#created by GNUPG v" VERSION " ("
                                            PRINTABLE_OS_NAME ")"));
     }
+  #endif
+    return rc;
+}
+
+
+/****************
+ * Generate a new user id packet, or return NULL if cancelled
+ */
+PKT_user_id *
+generate_user_id()
+{
+    PKT_user_id *uid;
+    char *p;
+    size_t n;
+
+    p = ask_user_id( 1 );
+    if( !p )
+       return NULL;
+    n = strlen(p);
+    uid = m_alloc( sizeof *uid + n - 1 );
+    uid->len = n;
+    strcpy(uid->name, p);
+    return uid;
+}
+
+
+/****************
+ * Generate a keypair
+ */
+void
+generate_keypair()
+{
+    unsigned nbits;
+    char *pub_fname = NULL;
+    char *sec_fname = NULL;
+    char *uid = NULL;
+    KBNODE pub_root = NULL;
+    KBNODE sec_root = NULL;
+    PKT_secret_key *sk = NULL;
+    DEK *dek;
+    STRING2KEY *s2k;
+    int rc;
+    int algo;
+    u32 expiredate;
+    int v4;
+    int both = 0;
+
+    if( opt.batch || opt.answer_yes || opt.answer_no ) {
+       log_error(_("Key generation can only be used in interactive mode\n"));
+       return;
+    }
+
+    algo = ask_algo( &v4, 0 );
+    if( !algo ) {
+       algo = PUBKEY_ALGO_ELGAMAL_E;
+       both = 1;
+       tty_printf(_("DSA keypair will have 1024 bits.\n"));
+    }
+    nbits = ask_keysize( algo );
+    expiredate = ask_expiredate();
+    uid = ask_user_id(0);
+    if( !uid ) {
+       log_error(_("Key generation cancelled.\n"));
+       return;
+    }
+    dek = ask_passphrase( &s2k );
+
+
+    /* now check whether we are allowed to write to the keyrings */
+    pub_fname = make_filename(opt.homedir, "pubring.gpg", NULL );
+    sec_fname = make_filename(opt.homedir, "secring.gpg", NULL );
+    if( opt.verbose ) {
+       tty_printf(_("writing public certificate to '%s'\n"), pub_fname );
+       tty_printf(_("writing secret certificate to '%s'\n"), sec_fname );
+    }
+
+    /* we create the packets as a tree of kbnodes. Because the structure
+     * we create is known in advance we simply generate a linked list
+     * The first packet is a dummy comment packet which we flag
+     * as deleted.  The very first packet must always be a KEY packet.
+     */
+    pub_root = make_comment_node("#"); delete_kbnode(pub_root);
+    sec_root = make_comment_node("#"); delete_kbnode(sec_root);
+
+    if( both )
+       rc = do_create( PUBKEY_ALGO_DSA, 1024, pub_root, sec_root,
+                                              dek, s2k, &sk, expiredate, 1);
+    else
+       rc = do_create( algo,           nbits, pub_root, sec_root,
+                                              dek, s2k, &sk, expiredate, v4);
     if( !rc )
        write_uid(pub_root, uid );
     if( !rc )
        write_uid(sec_root, uid );
     if( !rc )
-       rc = write_selfsig(pub_root, pub_root, skc);
+       rc = write_selfsig(pub_root, pub_root, sk);
     if( !rc )
-       rc = write_selfsig(sec_root, pub_root, skc);
+       rc = write_selfsig(sec_root, pub_root, sk);
+
+    if( both ) {
+       rc = do_create( algo, nbits, pub_root, sec_root,
+                                         dek, s2k, NULL, expiredate, 1 );
+       if( !rc )
+           rc = write_keybinding(pub_root, pub_root, sk);
+       if( !rc )
+           rc = write_keybinding(sec_root, pub_root, sk);
+    }
+
 
     if( !rc ) {
        KBPOS pub_kbpos;
@@ -650,7 +877,6 @@ generate_keypair()
        int rc2 = -1;
 
        /* we can now write the certificates */
-
        if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
            if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
                log_error("can add keyblock file '%s'\n", pub_fname );
@@ -686,6 +912,11 @@ generate_keypair()
            log_error("can't write secret key: %s\n", g10_errstr(rc) );
        else {
            tty_printf(_("public and secret key created and signed.\n") );
+           if( algo == PUBKEY_ALGO_DSA )
+               tty_printf(_("Note that this key cannot be used for "
+                            "encryption.  You may want to use\n"
+                            "the command \"--add-key\" to generate a "
+                            "secondary key for this purpose.\n") );
        }
 
        if( !rc1 )
@@ -699,11 +930,95 @@ generate_keypair()
        tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
     release_kbnode( pub_root );
     release_kbnode( sec_root );
-    if( skc ) /* the unprotected  secret certificate */
-       free_secret_cert(skc);
+    if( sk ) /* the unprotected  secret key */
+       free_secret_key(sk);
     m_free(uid);
     m_free(dek);
+    m_free(s2k);
     m_free(pub_fname);
     m_free(sec_fname);
 }
 
+
+/****************
+ * add a new subkey to an existing key.
+ * Returns true if a new key has been generated and put into the keyblocks.
+ */
+int
+generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
+{
+    int okay=0, rc=0;
+    KBNODE node;
+    PKT_secret_key *sk = NULL; /* this is the primary sk */
+    int v4, algo;
+    u32 expiredate;
+    unsigned nbits;
+    char *passphrase = NULL;
+    DEK *dek = NULL;
+    STRING2KEY *s2k = NULL;
+
+    /* break out the primary secret key */
+    node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
+    if( !node ) {
+       log_error("Oops; secret key not found anymore!\n");
+       goto leave;
+    }
+
+    /* make a copy of the sk to keep the protected one in the keyblock */
+    sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
+    /* unprotect to get the passphrase */
+    switch( is_secret_key_protected( sk ) ) {
+      case -1:
+       rc = G10ERR_PUBKEY_ALGO;
+       break;
+      case 0:
+       tty_printf("This key is not protected.\n");
+       break;
+      default:
+       tty_printf("Key is protected.\n");
+       rc = check_secret_key( sk, 0 );
+       if( !rc )
+           passphrase = get_last_passphrase();
+       break;
+    }
+    if( rc )
+       goto leave;
+
+
+    algo = ask_algo( &v4, 1 );
+    assert(algo);
+    nbits = ask_keysize( algo );
+    expiredate = ask_expiredate();
+    if( !cpr_enabled() && !cpr_get_answer_is_yes(N_("keygen.sub.okay"),
+                                                 _("Really create? ") ) )
+       goto leave;
+
+    if( passphrase ) {
+       s2k = m_alloc_secure( sizeof *s2k );
+       s2k->mode = opt.s2k_mode;
+       s2k->hash_algo = opt.s2k_digest_algo;
+       set_next_passphrase( passphrase );
+       dek = passphrase_to_dek( NULL, opt.s2k_cipher_algo, s2k, 2 );
+    }
+
+    rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
+                                     dek, s2k, NULL, expiredate, v4 );
+    if( !rc )
+       rc = write_keybinding(pub_keyblock, pub_keyblock, sk);
+    if( !rc )
+       rc = write_keybinding(sec_keyblock, pub_keyblock, sk);
+    if( !rc )
+       okay = 1;
+
+  leave:
+    if( rc )
+       log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
+    m_free( passphrase );
+    m_free( dek );
+    m_free( s2k );
+    if( sk ) /* release the copy of the (now unprotected) secret key */
+       free_secret_key(sk);
+    set_next_passphrase( NULL );
+    return okay;
+}
+