(parse_dn_part): Map common OIDs to human readable
[gnupg.git] / g10 / keygen.c
index 740dce5..72c5e1e 100644 (file)
@@ -1,6 +1,6 @@
 /* keygen.c - generate a key pair
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
- *                                               Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002,
+ *               2003, 2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -50,6 +50,7 @@ enum para_name {
   pSUBKEYTYPE,
   pSUBKEYLENGTH,
   pSUBKEYUSAGE,
+  pAUTHKEYTYPE,
   pNAMEREAL,
   pNAMEEMAIL,
   pNAMECOMMENT,
@@ -116,7 +117,6 @@ static int mdc_available,ks_modify;
 static void do_generate_keypair( struct para_data_s *para,
                                 struct output_control_s *outctrl, int card);
 static int write_keyblock( iobuf_t out, KBNODE node );
-static int check_smartcard (char **);
 static int gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
                          u32 expireval, struct para_data_s *para);
 
@@ -146,9 +146,16 @@ do_add_key_flags (PKT_signature *sig, unsigned int use)
 
     buf[0] = 0;
     if (use & PUBKEY_USAGE_SIG)
-        buf[0] |= 0x01 | 0x02;
+      {
+       if(sig->sig_class==0x18)
+         buf[0] |= 0x02; /* Don't set the certify flag for subkeys */
+       else
+         buf[0] |= 0x01 | 0x02;
+      }
     if (use & PUBKEY_USAGE_ENC)
         buf[0] |= 0x04 | 0x08;
+    if (use & PUBKEY_USAGE_AUTH)
+        buf[0] |= 0x20;
     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
 }
 
@@ -584,6 +591,18 @@ keygen_add_std_prefs( PKT_signature *sig, void *opaque )
     return 0;
 }
 
+
+int
+keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
+{
+  const char *url=opaque;
+
+  build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
+
+  return 0;
+}
+
+
 int
 keygen_add_revkey(PKT_signature *sig, void *opaque)
 {
@@ -739,86 +758,198 @@ write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 
 
 static int
-gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
+key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
+               const char *topname, const char *elems)
 {
-    int rc;
-    int i;
-    PACKET *pkt;
-    PKT_secret_key *sk;
-    PKT_public_key *pk;
-    gcry_mpi_t skey[4];
-    gcry_mpi_t *factors;
+  gcry_sexp_t list, l2;
+  const char *s;
+  int i, idx;
+  int rc = 0;
+
+  list = gcry_sexp_find_token (sexp, topname, 0);
+  if (!list)
+    return gpg_error (GPG_ERR_INV_OBJ);
+  l2 = gcry_sexp_cadr (list);
+  gcry_sexp_release (list);
+  list = l2;
+  if (!list)
+    return gpg_error (GPG_ERR_NO_OBJ);
+
+  for (idx=0,s=elems; *s; s++, idx++)
+    {
+      l2 = gcry_sexp_find_token (list, s, 1);
+      if (!l2)
+        {
+          rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
+          goto leave;
+        }
+      array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
+      gcry_sexp_release (l2);
+      if (!array[idx]) 
+        {
+          rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
+          goto leave;
+        }
+    }
+  gcry_sexp_release (list);
+
+ leave:
+  if (rc)
+    {
+      for (i=0; i<idx; i++)
+        {
+          xfree (array[i]);
+          array[i] = NULL;
+        }
+      gcry_sexp_release (list);
+    }
+  return rc;
+}
 
-    assert( is_ELGAMAL(algo) );
 
-    if( nbits < 512 ) {
-       nbits = 1024;
-       log_info(_("keysize invalid; using %u bits\n"), nbits );
+static int
+genhelp_protect (DEK *dek, STRING2KEY *s2k, PKT_secret_key *sk)
+{
+  int rc = 0;
+
+  if (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", gpg_strerror (rc) );
     }
 
-    if( (nbits % 32) ) {
-       nbits = ((nbits + 31) / 32) * 32;
-       log_info(_("keysize rounded up to %u bits\n"), nbits );
+  return rc;
+}
+
+static void
+genhelp_factors (gcry_sexp_t misc_key_info, KBNODE sec_root)
+{
+  size_t n;
+  char *buf;
+  
+  if (misc_key_info)
+    {
+      /* DSA: 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. */
+      n = gcry_sexp_sprint (misc_key_info, 0, NULL, 0);
+      buf = xmalloc (n+4);
+      strcpy (buf, "#::");
+      n = gcry_sexp_sprint (misc_key_info, 0, buf+3, n);
+      if (n)
+        {
+          n += 3;
+          add_kbnode (sec_root, make_comment_node_from_buffer (buf, n));
+        }
+      xfree (buf);
+      gcry_sexp_release (misc_key_info);
     }
+}
 
-#warning need to implement this
-    rc = -1 /*pubkey_generate( algo, nbits, skey, &factors )*/;
-    if( rc ) {
-       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
-       return rc;
+
+static int
+gen_elg(int algo, unsigned int nbits,
+        KBNODE pub_root, KBNODE sec_root, DEK *dek,
+       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
+{
+  int rc;
+  PACKET *pkt;
+  PKT_secret_key *sk;
+  PKT_public_key *pk;
+  gcry_sexp_t s_parms, s_key;
+  gcry_sexp_t misc_key_info;
+  
+  assert (is_ELGAMAL(algo));
+
+  if (nbits < 512)
+    {
+      nbits = 1024;
+      log_info (_("keysize invalid; using %u bits\n"), nbits);
     }
 
-    sk = xcalloc (1, sizeof *sk );
-    pk = xcalloc (1, sizeof *pk );
-    sk->timestamp = pk->timestamp = make_timestamp();
-    sk->version = pk->version = 4;
-    if( expireval ) {
-       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
-    }
-    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( 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 ) {
-       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", gpg_strerror (rc) );
-           free_public_key(pk);
-           free_secret_key(sk);
-           return rc;
-       }
+  if ((nbits % 32))
+    {
+      nbits = ((nbits + 31) / 32) * 32;
+      log_info (_("keysize rounded up to %u bits\n"), nbits);
     }
 
-    pkt = xcalloc (1,sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
-    pkt->pkt.public_key = pk;
-    add_kbnode(pub_root, new_kbnode( pkt ));
+  rc = gcry_sexp_build ( &s_parms, NULL,
+                         "(genkey(%s(nbits %d)))",
+                         algo == GCRY_PK_ELG_E ? "openpgp-elg" :
+                         algo == GCRY_PK_ELG    ? "elg" : "x-oops" ,
+                         (int)nbits);
+  if (rc)
+    log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
+  
+  rc = gcry_pk_genkey (&s_key, s_parms);
+  gcry_sexp_release (s_parms);
+  if (rc)
+    {
+      log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
+      return rc;
+    }
 
-    /* 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 = xcalloc (1,sizeof *pkt);
-    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,
-                   make_mpi_comment_node("#:ELG_factor:", factors[i] ));
+  sk = xcalloc (1, sizeof *sk);
+  pk = xcalloc (1, sizeof *pk);
+  sk->timestamp = pk->timestamp = make_timestamp();
+  sk->version = pk->version = 4;
+  if (expireval)
+    sk->expiredate = pk->expiredate = sk->timestamp + expireval;
+  sk->pubkey_algo = pk->pubkey_algo = algo;
 
-    return 0;
+  rc = key_from_sexp (pk->pkey, s_key, "public-key", "pgy");
+  if (rc) 
+    {
+      log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
+      gcry_sexp_release (s_key);
+      return rc;
+    }
+  rc = key_from_sexp (sk->skey, s_key, "private-key", "pgyx");
+  if (rc)
+    {
+      log_error("key_from_sexp failed: %s\n", gpg_strerror (rc) );
+      gcry_sexp_release (s_key);
+      return rc;
+    }
+  misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
+  gcry_sexp_release (s_key);
+
+  sk->is_protected = 0;
+  sk->protect.algo = 0;
+
+  sk->csum = checksum_mpi (sk->skey[3]);
+  if (ret_sk) /* not a subkey: return an unprotected version of the sk */
+    *ret_sk = copy_secret_key (NULL, sk);
+
+  rc = genhelp_protect (dek, s2k, sk);
+  if (rc)
+    {
+      free_public_key (pk);
+      free_secret_key (sk);
+      gcry_sexp_release (misc_key_info);
+      return rc;
+    }
+
+  pkt = xcalloc (1,sizeof *pkt);
+  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) */
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+  pkt->pkt.secret_key = sk;
+  add_kbnode(sec_root, new_kbnode( pkt ));
+  
+  genhelp_factors (misc_key_info, sec_root);
+  
+  return 0;
 }
 
 
@@ -826,90 +957,96 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
  * Generate a DSA key
  */
 static int
-gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-           STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
+gen_dsa (unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
+         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
 {
-    int rc;
-    int i;
-    PACKET *pkt;
-    PKT_secret_key *sk;
-    PKT_public_key *pk;
-    gcry_mpi_t skey[5];
-    gcry_mpi_t *factors;
+  int rc;
+  PACKET *pkt;
+  PKT_secret_key *sk;
+  PKT_public_key *pk;
+  gcry_sexp_t s_parms, s_key;
+  gcry_sexp_t misc_key_info;
 
-    if( nbits > 1024 || nbits < 512 ) {
-       nbits = 1024;
-       log_info(_("keysize invalid; using %u bits\n"), nbits );
+  if (nbits > 1024 || nbits < 512)
+    {
+      nbits = 1024;
+      log_info(_("keysize invalid; using %u bits\n"), nbits);
     }
 
-    if( (nbits % 64) ) {
-       nbits = ((nbits + 63) / 64) * 64;
-       log_info(_("keysize rounded up to %u bits\n"), nbits );
+  if ((nbits % 64))
+    {
+      nbits = ((nbits + 63) / 64) * 64;
+      log_info (_("keysize rounded up to %u bits\n"), nbits);
     }
 
-#warning need to implement this
-    rc = -1 /*pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors )*/;
-    if( rc ) {
-       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
-       return rc;
+  rc = gcry_sexp_build (&s_parms, NULL,
+                        "(genkey(dsa(nbits %d)))",
+                        (int)nbits);
+  if (rc)
+    log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
+  
+  rc = gcry_pk_genkey (&s_key, s_parms);
+  gcry_sexp_release (s_parms);
+  if (rc)
+    {
+      log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
+      return rc;
     }
 
-    sk = xcalloc (1, sizeof *sk );
-    pk = xcalloc (1, sizeof *pk );
-    sk->timestamp = pk->timestamp = make_timestamp();
-    sk->version = pk->version = 4;
-    if( expireval ) {
-       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
-    }
-    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 ( 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 ) {
-       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", gpg_strerror (rc) );
-           free_public_key(pk);
-           free_secret_key(sk);
-           return rc;
-       }
+  sk = xcalloc (1, sizeof *sk );
+  pk = xcalloc (1, sizeof *pk );
+  sk->timestamp = pk->timestamp = make_timestamp();
+  sk->version = pk->version = 4;
+  if (expireval) 
+    sk->expiredate = pk->expiredate = sk->timestamp + expireval;
+  sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
+
+  rc = key_from_sexp (pk->pkey, s_key, "public-key", "pqgy");
+  if (rc) 
+    {
+      log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
+      gcry_sexp_release (s_key);
+      return rc;
     }
+  rc = key_from_sexp (sk->skey, s_key, "private-key", "pqgyx");
+  if (rc) 
+    {
+      log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
+      gcry_sexp_release (s_key);
+      return rc;
+    }
+  misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
+  gcry_sexp_release (s_key);
 
-    pkt = xcalloc (1,sizeof *pkt);
-    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 = xcalloc (1,sizeof *pkt);
-    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] ));
+  sk->is_protected = 0;
+  sk->protect.algo = 0;
 
-    return 0;
+  sk->csum = checksum_mpi ( sk->skey[4] );
+  if (ret_sk) /* not a subkey: return an unprotected version of the sk */
+    *ret_sk = copy_secret_key( NULL, sk );
+
+  rc = genhelp_protect (dek, s2k, sk);
+  if (rc)
+    {
+      free_public_key (pk);
+      free_secret_key (sk);
+      gcry_sexp_release (misc_key_info);
+      return rc;
+    }
+
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+  pkt->pkt.public_key = pk;
+  add_kbnode(pub_root, new_kbnode( pkt ));
+
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+  pkt->pkt.secret_key = sk;
+  add_kbnode(sec_root, new_kbnode( pkt ));
+
+  genhelp_factors (misc_key_info, sec_root);
+
+  return 0;
 }
 
 
@@ -920,81 +1057,93 @@ static int
 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
 {
-    int rc;
-    PACKET *pkt;
-    PKT_secret_key *sk;
-    PKT_public_key *pk;
-    gcry_mpi_t skey[6];
-    gcry_mpi_t *factors;
+  int rc;
+  PACKET *pkt;
+  PKT_secret_key *sk;
+  PKT_public_key *pk;
+  gcry_sexp_t s_parms, s_key;
 
-    assert( is_RSA(algo) );
+  assert (is_RSA(algo));
 
-    if( nbits < 1024 ) {
-       nbits = 1024;
-       log_info(_("keysize invalid; using %u bits\n"), nbits );
+  if (nbits < 1024)
+    {
+      nbits = 1024;
+      log_info(_("keysize invalid; using %u bits\n"), nbits);
     }
 
-    if( (nbits % 32) ) {
-       nbits = ((nbits + 31) / 32) * 32;
-       log_info(_("keysize rounded up to %u bits\n"), nbits );
+  if ((nbits % 32))
+    {
+      nbits = ((nbits + 31) / 32) * 32;
+      log_info (_("keysize rounded up to %u bits\n"), nbits);
     }
 
-#warning need to implement this
-    rc = -1 /*pubkey_generate( algo, nbits, skey, &factors )*/;
-    if( rc ) {
-       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
-       return rc;
+  rc = gcry_sexp_build (&s_parms, NULL,
+                        "(genkey(rsa(nbits %d)))",
+                        (int)nbits);
+  if (rc)
+    log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
+  
+  rc = gcry_pk_genkey (&s_key, s_parms);
+  gcry_sexp_release (s_parms);
+  if (rc)
+    {
+      log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
+      return rc;
     }
 
-    sk = xcalloc (1, sizeof *sk );
-    pk = xcalloc (1, sizeof *pk );
-    sk->timestamp = pk->timestamp = make_timestamp();
-    sk->version = pk->version = 4;
-    if( expireval ) {
-       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
-    }
-    sk->pubkey_algo = pk->pubkey_algo = algo;
-                      pk->pkey[0] = mpi_copy( skey[0] );
-                      pk->pkey[1] = mpi_copy( skey[1] );
-    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->skey[5] = skey[5];
-    sk->is_protected = 0;
-    sk->protect.algo = 0;
-
-    sk->csum  = checksum_mpi (sk->skey[2] );
-    sk->csum += checksum_mpi (sk->skey[3] );
-    sk->csum += checksum_mpi (sk->skey[4] );
-    sk->csum += checksum_mpi (sk->skey[5] );
-    if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
-       *ret_sk = copy_secret_key( NULL, sk );
-
-    if( 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", gpg_strerror (rc) );
-           free_public_key(pk);
-           free_secret_key(sk);
-           return rc;
-       }
+  sk = xcalloc (1, sizeof *sk );
+  pk = xcalloc (1, sizeof *pk );
+  sk->timestamp = pk->timestamp = make_timestamp();
+  sk->version = pk->version = 4;
+  if (expireval) 
+    sk->expiredate = pk->expiredate = sk->timestamp + expireval;
+  sk->pubkey_algo = pk->pubkey_algo = algo;
+
+  rc = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
+  if (rc) 
+    {
+      log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
+      gcry_sexp_release (s_key);
+      return rc;
     }
+  rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
+  if (rc) 
+    {
+      log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
+      gcry_sexp_release (s_key);
+      return rc;
+    }
+  gcry_sexp_release (s_key);
 
-    pkt = xcalloc (1,sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
-    pkt->pkt.public_key = pk;
-    add_kbnode(pub_root, new_kbnode( pkt ));
+  sk->is_protected = 0;
+  sk->protect.algo = 0;
 
-    pkt = xcalloc (1,sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
-    pkt->pkt.secret_key = sk;
-    add_kbnode(sec_root, new_kbnode( pkt ));
+  sk->csum  = checksum_mpi (sk->skey[2] );
+  sk->csum += checksum_mpi (sk->skey[3] );
+  sk->csum += checksum_mpi (sk->skey[4] );
+  sk->csum += checksum_mpi (sk->skey[5] );
+  if (ret_sk) /* not a subkey: return an unprotected version of the sk */
+    *ret_sk = copy_secret_key (NULL, sk);
 
-    return 0;
+  rc = genhelp_protect (dek, s2k, sk);
+  if (rc)
+    {
+      free_public_key (pk);
+      free_secret_key (sk);
+      return rc;
+    }
+
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+  pkt->pkt.public_key = pk;
+  add_kbnode (pub_root, new_kbnode( pkt ));
+
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+  pkt->pkt.secret_key = sk;
+  add_kbnode(sec_root, new_kbnode( pkt ));
+
+  return 0;
 }
 
 
@@ -1005,10 +1154,10 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
 static int
 check_valid_days( const char *s )
 {
-    if( !isdigit(*s) )
+    if( !digitp(s) )
        return 0;
     for( s++; *s; s++)
-       if( !isdigit(*s) )
+       if( !digitp(s) )
            break;
     if( !*s )
        return 1;
@@ -1086,15 +1235,18 @@ ask_algo (int addmode, unsigned int *r_usage)
                                      _("Create anyway? ")))
              {
                algo = PUBKEY_ALGO_ELGAMAL;
+                *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
                break;
              }
        }
        else if( algo == 3 && addmode ) {
            algo = PUBKEY_ALGO_ELGAMAL_E;
+            *r_usage = PUBKEY_USAGE_ENC;
            break;
        }
        else if( algo == 2 ) {
            algo = PUBKEY_ALGO_DSA;
+            *r_usage = PUBKEY_USAGE_SIG;
            break;
        }
        else
@@ -1270,8 +1422,9 @@ ask_expire_interval(int object)
            tty_printf(_("%s expires at %s\n"),
                        object==0?"Key":"Signature",
                        asctimestamp((ulong)(curtime + interval) ) );
-            /* FIXME: This check yields warning on alhas:
-               write a configure check and to this check here only for 32 bit machines */
+            /* FIXME: This check yields warning some machines: write a
+               configure check and do this check here only for 32 bit
+               machines */
            if( (time_t)((ulong)(curtime+interval)) < 0 )
                tty_printf(_("Your system can't display dates beyond 2038.\n"
                    "However, it will be correctly handled up to 2106.\n"));
@@ -1355,7 +1508,7 @@ ask_user_id( int mode )
 
                if( strpbrk( aname, "<>" ) )
                    tty_printf(_("Invalid character in name\n"));
-               else if( isdigit(*aname) )
+               else if( digitp(aname) )
                    tty_printf(_("Name may not start with a digit\n"));
                else if( strlen(aname) < 5 )
                    tty_printf(_("Name must be at least 5 characters long\n"));
@@ -1369,7 +1522,7 @@ ask_user_id( int mode )
                amail = cpr_get("keygen.email",_("Email address: "));
                trim_spaces(amail);
                cpr_kill_prompt();
-               if( !*amail )
+               if( !*amail || opt.allow_freeform_uid )
                    break;   /* no email address is okay */
                else if( has_invalid_email_chars(amail)
                         || count_chr(amail,'@') != 1
@@ -1417,7 +1570,8 @@ ask_user_id( int mode )
 
        tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
        /* fixme: add a warning if this user-id already exists */
-       if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
+       if( !*amail && !opt.allow_freeform_uid
+            && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
            fail = 1;
            tty_printf(_("Please don't put the email address "
                          "into the real name or the comment\n") );
@@ -1474,7 +1628,7 @@ ask_user_id( int mode )
        }
        xfree (answer);
        if( !amail && !acomment && !amail )
-           break;
+          break;
        xfree (uid); uid = NULL;
     }
     if( uid ) {
@@ -1495,7 +1649,7 @@ ask_passphrase( STRING2KEY **ret_s2k )
 
     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
 
-    s2k = xmalloc_secure ( sizeof *s2k );
+    s2k = xmalloc ( sizeof *s2k );
     for(;;) {
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
@@ -1620,7 +1774,7 @@ get_parameter_algo( struct para_data_s *para, enum para_name key )
     struct para_data_s *r = get_parameter( para, key );
     if( !r )
        return -1;
-    if( isdigit( *r->u.value ) )
+    if( digitp( r->u.value ) )
        i = atoi( r->u.value );
     else
         i = openpgp_pk_map_name ( r->u.value );
@@ -1652,6 +1806,8 @@ parse_parameter_usage (const char *fname,
             use |= PUBKEY_USAGE_SIG;
         else if ( !ascii_strcasecmp (p, "encrypt") )
             use |= PUBKEY_USAGE_ENC;
+        else if ( !ascii_strcasecmp (p, "auth") )
+            use |= PUBKEY_USAGE_AUTH;
         else {
             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
             return -1; /* error */
@@ -2062,11 +2218,12 @@ read_parameter_file( const char *fname )
 
 
 /****************
- * Generate a keypair
- * (fname is only used in batch mode)
+ * Generate a keypair (fname is only used in batch mode) If
+ * CARD_SERIALNO is not NULL the fucntion will create the keys on an
+ * OpenPGP Card.
  */
 void
-generate_keypair( const char *fname )
+generate_keypair( const char *fname, const char *card_serialno )
 {
   unsigned int nbits;
   char *uid = NULL;
@@ -2075,42 +2232,34 @@ generate_keypair( const char *fname )
   int algo;
   unsigned int use;
   int both = 0;
-  int card = 0;
   u32 expire;
   struct para_data_s *para = NULL;
   struct para_data_s *r;
   struct output_control_s outctrl;
-  char *serialno = NULL;
 
   memset (&outctrl, 0, sizeof (outctrl));
 
-  if (opt.batch)
+  if (opt.batch && card_serialno)
     {
-      read_parameter_file( fname );
+      /* We don't yet support unattended key generation. */
+      log_error (_("sorry, can't do this in batch mode\n"));
       return;
     }
 
-  do
+  if (opt.batch)
     {
-      xfree (serialno); serialno = NULL;
-      card = check_smartcard (&serialno);
-      if (card < 0)
-        return;
+      read_parameter_file( fname );
+      return;
     }
-  while (card > 1);
 
-  if (serialno)
+  if (card_serialno)
     {
-      r = xcalloc (1, sizeof *r + strlen (serialno) );
+      r = xcalloc (1, sizeof *r + strlen (card_serialno) );
       r->key = pSERIALNO;
-      strcpy( r->u.value, serialno);
+      strcpy( r->u.value, card_serialno);
       r->next = para;
       para = r;
-      xfree (serialno); serialno = NULL;
-    }
 
-  if (card)
-    {
       algo = PUBKEY_ALGO_RSA;
 
       r = xcalloc (1, sizeof *r + 20 );
@@ -2134,6 +2283,12 @@ generate_keypair( const char *fname )
       strcpy (r->u.value, "encrypt");
       r->next = para;
       para = r;
+
+      r = xcalloc (1, sizeof *r + 20 );
+      r->key = pAUTHKEYTYPE;
+      sprintf( r->u.value, "%d", algo );
+      r->next = para;
+      para = r;
     }
   else
     {
@@ -2153,6 +2308,11 @@ generate_keypair( const char *fname )
           strcpy( r->u.value, "1024" );
           r->next = para;
           para = r;
+          r = xcalloc (1, sizeof *r + 20 );
+          r->key = pKEYUSAGE;
+          strcpy( r->u.value, "sign" );
+          r->next = para;
+          para = r;
           
           algo = PUBKEY_ALGO_ELGAMAL_E;
           r = xcalloc (1, sizeof *r + 20 );
@@ -2160,6 +2320,12 @@ generate_keypair( const char *fname )
           sprintf( r->u.value, "%d", algo );
           r->next = para;
           para = r;
+          r = xcalloc (1, sizeof *r + 20 );
+          r->key = pSUBKEYUSAGE;
+          strcpy( r->u.value, "encrypt" );
+          r->next = para;
+          r->next = para;
+          para = r;
         }
       else 
         {
@@ -2214,7 +2380,7 @@ generate_keypair( const char *fname )
   r->next = para;
   para = r;
 
-  dek = card? NULL : ask_passphrase( &s2k );
+  dek = card_serialno? NULL : ask_passphrase( &s2k );
   if (dek)
     {
       r = xcalloc (1, sizeof *r );
@@ -2229,7 +2395,7 @@ generate_keypair( const char *fname )
       para = r;
     }
   
-  proc_parameter_file (para, "[internal]", &outctrl, card);
+  proc_parameter_file (para, "[internal]", &outctrl, !!card_serialno);
   release_parameter_list (para);
 }
 
@@ -2286,7 +2452,7 @@ do_generate_keypair (struct para_data_s *para,
          outctrl->pub.stream = iobuf_create (outctrl->pub.fname);
          if (!outctrl->pub.stream)
            {
-             log_error ("can't create `%s': %s\n", outctrl->pub.newfname,
+             log_error ("can't create `%s': %s\n", outctrl->pub.fname,
                         strerror (errno));
              return;
            }
@@ -2308,7 +2474,7 @@ do_generate_keypair (struct para_data_s *para,
          outctrl->sec.stream = iobuf_create (outctrl->sec.fname);
          if (!outctrl->sec.stream)
            {
-             log_error ("can't create `%s': %s\n", outctrl->sec.newfname,
+             log_error ("can't create `%s': %s\n", outctrl->sec.fname,
                         strerror (errno));
              return;
            }
@@ -2383,7 +2549,7 @@ do_generate_keypair (struct para_data_s *para,
                            get_parameter_uint (para, pKEYUSAGE));
     }
 
-  if (get_parameter (para, pSUBKEYTYPE))
+  if ((! rc) && get_parameter (para, pSUBKEYTYPE))
     {
       if (!card)
         {
@@ -2409,6 +2575,17 @@ do_generate_keypair (struct para_data_s *para,
       did_sub = 1;
     }
 
+  if ((! rc) && card && get_parameter (para, pAUTHKEYTYPE))
+    {
+      rc = gen_card_key (PUBKEY_ALGO_RSA, 3, pub_root, sec_root,
+                         get_parameter_u32 (para, pKEYEXPIRE), para);
+
+      if (!rc)
+       rc = write_keybinding (pub_root, pub_root, sk, PUBKEY_USAGE_AUTH);
+      if (!rc)
+       rc = write_keybinding (sec_root, pub_root, sk, PUBKEY_USAGE_AUTH);
+    }
+
 
   if (!rc && outctrl->use_files)
     {                          /* direct write to specified files */
@@ -2505,6 +2682,15 @@ do_generate_keypair (struct para_data_s *para,
                            "the command \"--edit-key\" to generate a "
                            "secondary key for this purpose.\n"));
            }
+
+          if (!opt.batch && card)
+            {
+              tty_printf(_(
+"Please create a revocation certificate now, so that you are able\n"
+"to revoke the key if it ever happens that you lose your card or\n"
+"the card gets damaged.  Use the command \"--gen-revoke\".\n"
+                         ));
+            }
        }
     }
 
@@ -2525,7 +2711,7 @@ do_generate_keypair (struct para_data_s *para,
   release_kbnode (pub_root);
   release_kbnode (sec_root);
   if (sk && !card)         /* The unprotected secret key unless we have */
-    free_secret_key (sk);  /* shallow copy in card mode. */
+    free_secret_key (sk);  /* shallow copy in card mode. */
 }
 
 
@@ -2654,264 +2840,6 @@ write_keyblock( iobuf_t out, KBNODE node )
 }
 
 \f
-static void
-show_sha1_fpr (const unsigned char *fpr)
-{
-  int i;
-
-  if (fpr)
-    {
-      for (i=0; i < 20 ; i+=2, fpr += 2 )
-        {
-          if (i == 10 )
-            tty_printf (" ");
-          tty_printf (" %02X%02X", *fpr, fpr[1]);
-        }
-    }
-  else
-    tty_printf (" [none]");
-  tty_printf ("\n");
-}
-
-static void
-show_smartcard (struct agent_card_info_s *info)
-{
-  PKT_public_key *pk = xcalloc (1, sizeof *pk);
-
-  /* FIXME: Sanitize what we show. */
-  tty_printf ("Name of cardholder: %s\n",
-              info->disp_name && *info->disp_name? info->disp_name 
-                                                 : "[not set]");
-  tty_printf ("URL of public key : %s\n",
-              info->pubkey_url && *info->pubkey_url? info->pubkey_url 
-                                                 : "[not set]");
-  tty_printf ("Signature key ....:");
-  show_sha1_fpr (info->fpr1valid? info->fpr1:NULL);
-  tty_printf ("Encryption key....:");
-  show_sha1_fpr (info->fpr2valid? info->fpr2:NULL);
-  tty_printf ("Authentication key:");
-  show_sha1_fpr (info->fpr3valid? info->fpr3:NULL);
-
-  if (info->fpr1valid && !get_pubkey_byfprint (pk, info->fpr1, 20))
-    print_pubkey_info (pk);
-
-  free_public_key( pk );
-}
-
-
-static char *
-smartcard_get_one_name (const char *prompt1, const char *prompt2)
-{
-  char *name;
-  int i;
-
-  for (;;)
-    {
-      name = cpr_get (prompt1, prompt2);
-      if (!name)
-        return NULL;
-      trim_spaces (name);
-      cpr_kill_prompt ();
-      for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
-        ;
-
-      /* The name must be in Latin-1 and not UTF-8 - lacking the code
-         to ensure this we restrict it to ASCII. */
-      if (name[i])
-        tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
-      else if (strchr (name, '<'))
-        tty_printf (_("Error: The \"<\" character may not be used.\n"));
-      else if (strstr (name, "  "))
-        tty_printf (_("Error: Double spaces are not allowed.\n"));    
-      else
-        return name;
-      xfree (name);
-    }
-}
-
-static int
-smartcard_change_name (const char *current_name)
-{
-  char *surname = NULL, *givenname = NULL;
-  char *isoname, *p;
-  int rc;
-
-  surname = smartcard_get_one_name ("keygen.smartcard.surname",
-                                    _("Cardholder's surname: "));
-  givenname = smartcard_get_one_name ("keygen.smartcard.givenname",
-                                       _("Cardholder's given name: "));
-  if (!surname || !givenname || (!*surname && !*givenname))
-    {
-      xfree (surname);
-      xfree (givenname);
-      return -1; /*canceled*/
-    }
-
-  isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
-  strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
-  xfree (surname);
-  xfree (givenname);
-  for (p=isoname; *p; p++)
-    if (*p == ' ')
-      *p = '<';
-
-  log_debug ("setting Name to `%s'\n", isoname);
-  rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname) );
-  if (rc)
-    log_error ("error setting Name: %s\n", gpg_strerror (rc));
-
-  xfree (isoname);
-  return rc;
-}
-
-
-static int
-smartcard_change_url (const char *current_url)
-{
-  char *url;
-  int rc;
-
-  url = cpr_get ("keygen.smartcard.url", _("URL to retrieve public key: "));
-  if (!url)
-    return -1;
-  trim_spaces (url);
-  cpr_kill_prompt ();
-
-  rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url) );
-  if (rc)
-    log_error ("error setting URL: %s\n", gpg_strerror (rc));
-  xfree (url);
-  return rc;
-}
-
-
-/* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
-static int
-fpr_is_zero (const char *fpr)
-{
-  int i;
-
-  for (i=0; i < 20 && !fpr[i]; i++)
-    ;
-  return (i == 20);
-}
-
-/* Check whether a smartcatrd is available and alow to select it as
-   the target for key generation. 
-   
-   Return values: -1 = Quit generation
-                   0 = No smartcard
-                   1 = Generate keypair
-*/
-static int
-check_smartcard (char **r_serialno)
-{
-  struct agent_card_info_s info;
-  int rc;
-
-  rc = agent_learn (&info);
-  if (rc)
-    {
-      tty_printf (_("OpenPGP card not available: %s\n"),
-                  gpg_strerror (rc));
-      return 0;
-    }
-  
-  tty_printf (_("OpenPGP card no. %s detected\n"),
-              info.serialno? info.serialno : "[none]");
-
-
-  for (;;)
-    {
-      char *answer;
-      int reread = 0;
-
-      tty_printf ("\n");
-      show_smartcard (&info);
-
-      tty_printf ("\n"
-                  "N - change cardholder name\n"
-                  "U - change public key URL\n"
-                  "K - generate signature and encryption key\n"
-                  "A - generate authentication key\n"
-                  "Q - quit\n"
-                  "\n");
-
-      answer = cpr_get("keygen.smartcard.menu",_("Your selection? "));
-      cpr_kill_prompt();
-      if (strlen (answer) != 1)
-        continue;
-
-      rc = 0;
-      if ( *answer == 'N' || *answer == 'n')
-        {
-          if (!smartcard_change_name (info.disp_name))
-            reread = 1;
-        }
-      else if ( *answer == 'U' || *answer == 'u')
-        {
-          if (!smartcard_change_url (info.pubkey_url))
-            reread = 1;
-        }
-      else if ( *answer == 'K' || *answer == 'k')
-        {
-          if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
-               || (info.fpr2valid && !fpr_is_zero (info.fpr2)))
-            {
-              tty_printf ("\n");
-              log_error ("WARNING: key does already exists!\n");
-              tty_printf ("\n");
-              if ( cpr_get_answer_is_yes( "keygen.card.replace_key",
-                                          _("Replace existing key? ")))
-                {
-                  rc = 1;
-                  break;
-                }
-            }
-          else
-            {
-              rc = 1;
-              break;
-            }
-        }
-      else if ( *answer == 'A' || *answer == 'a' )
-        {
-          tty_printf (_("Generation of authentication key"
-                        " not yet implemented\n"));
-        }
-      else if ( *answer == 'q' || *answer == 'Q')
-        {
-          rc = -1;
-          break;
-        }
-
-      if (reread)
-        {
-          xfree (info.serialno); info.serialno = NULL;
-          xfree (info.disp_name); info.disp_name = NULL;
-          xfree (info.pubkey_url); info.pubkey_url = NULL;
-          rc = agent_learn (&info);
-          if (rc)
-            {
-              tty_printf (_("OpenPGP card not anymore available: %s\n"),
-                          gpg_strerror (rc));
-              g10_exit (1);
-            }
-          reread = 0;
-        }
-    }
-
-  if (r_serialno && rc > 0)
-    *r_serialno = info.serialno;
-  else
-    xfree (info.serialno); 
-  xfree (info.disp_name); 
-  xfree (info.pubkey_url);
-
-  return rc;
-}
-
-
 
 static int
 gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
@@ -2938,10 +2866,8 @@ gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
 /*      } */
 
   if (rc)
-    {
-      log_error ("key generation failed: %s\n", gpg_strerror (rc));
-      return rc;
-    }
+    return rc;
+
   if ( !info.n || !info.e )
     {
       log_error ("communication error with SCD\n");
@@ -2960,9 +2886,9 @@ gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
   sk->pubkey_algo = pk->pubkey_algo = algo;
   pk->pkey[0] = info.n;
   pk->pkey[1] = info.e; 
-  sk->skey[0] = mpi_copy (pk->pkey[0]);
-  sk->skey[1] = mpi_copy (pk->pkey[1]);
-  sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
+  sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
+  sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
+  sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
   sk->is_protected = 1;
   sk->protect.s2k.mode = 1002;
   s = get_parameter_value (para, pSERIALNO);