* misc.c (optsep): Add the ability to understand keyword="quoted arg with
[gnupg.git] / g10 / keygen.c
index ccaa4ad..3b5a409 100644 (file)
@@ -1,5 +1,6 @@
 /* keygen.c - generate a key pair
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ *               2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -25,6 +26,9 @@
 #include <ctype.h>
 #include <errno.h>
 #include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include "util.h"
 #include "main.h"
 #include "packet.h"
 #include "trustdb.h"
 #include "status.h"
 #include "i18n.h"
+#include "cardglue.h"
 
 #define MAX_PREFS 30 
 
-
 enum para_name {
   pKEYTYPE,
   pKEYLENGTH,
@@ -46,6 +50,7 @@ enum para_name {
   pSUBKEYTYPE,
   pSUBKEYLENGTH,
   pSUBKEYUSAGE,
+  pAUTHKEYTYPE,
   pNAMEREAL,
   pNAMEEMAIL,
   pNAMECOMMENT,
@@ -57,7 +62,8 @@ enum para_name {
   pSUBKEYEXPIRE, /* in n seconds */
   pPASSPHRASE,
   pPASSPHRASE_DEK,
-  pPASSPHRASE_S2K
+  pPASSPHRASE_S2K,
+  pSERIALNO
 };
 
 struct para_data_s {
@@ -106,12 +112,13 @@ static byte hash_prefs[MAX_PREFS];
 static int nhash_prefs;
 static byte zip_prefs[MAX_PREFS];
 static int nzip_prefs;
-static int mdc_available;
+static int mdc_available,ks_modify;
 
 static void do_generate_keypair( struct para_data_s *para,
-                                struct output_control_s *outctrl );
+                                struct output_control_s *outctrl, int card );
 static int  write_keyblock( IOBUF out, KBNODE node );
-
+static int gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
+                         u32 expireval, struct para_data_s *para);
 
 static void
 write_uid( KBNODE root, const char *s )
@@ -137,9 +144,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);
 }
 
@@ -223,25 +237,45 @@ int
 keygen_set_std_prefs (const char *string,int personal)
 {
     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
-    int  nsym=0, nhash=0, nzip=0, mdc=1; /* mdc defaults on */
-    int val,rc = 0;
-
-    if (!string || !ascii_strcasecmp (string, "default")) {
-      if (opt.def_preference_list)
-       string=opt.def_preference_list;
-      else if ( !check_cipher_algo(CIPHER_ALGO_IDEA) )
-        string = "S7 S3 S2 S1 H2 H3 Z2 Z1";
-      else
-        string = "S7 S3 S2 H2 H3 Z2 Z1";
+    int nsym=0, nhash=0, nzip=0, val, rc=0;
+    int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
+    char dummy_string[45]; /* enough for 15 items */
 
-      /* If we have it, IDEA goes *after* 3DES so it won't be used
-         unless we're encrypting along with a V3 key.  Ideally, we
-         would only put the S1 preference in if the key was RSA and
-         <=2048 bits, as that is what won't break PGP2, but that is
-         difficult with the current code, and not really worth
-         checking as a non-RSA <=2048 bit key wouldn't be usable by
-         PGP2 anyway. -dms */
-    }
+    if (!string || !ascii_strcasecmp (string, "default"))
+      {
+       if (opt.def_preference_list)
+         string=opt.def_preference_list;
+       else
+         {
+           dummy_string[0]='\0';
+
+           /* Make sure we do not add more than 15 items here, as we
+              could overflow the size of dummy_string. */
+           if(!check_cipher_algo(CIPHER_ALGO_AES256))
+             strcat(dummy_string,"S9 ");
+           if(!check_cipher_algo(CIPHER_ALGO_AES192))
+             strcat(dummy_string,"S8 ");
+           if(!check_cipher_algo(CIPHER_ALGO_AES))
+             strcat(dummy_string,"S7 ");
+           if(!check_cipher_algo(CIPHER_ALGO_CAST5))
+             strcat(dummy_string,"S3 ");
+           strcat(dummy_string,"S2 "); /* 3DES */
+           /* If we have it, IDEA goes *after* 3DES so it won't be
+              used unless we're encrypting along with a V3 key.
+              Ideally, we would only put the S1 preference in if the
+              key was RSA and <=2048 bits, as that is what won't
+              break PGP2, but that is difficult with the current
+              code, and not really worth checking as a non-RSA <=2048
+              bit key wouldn't be usable by PGP2 anyway. -dms */
+           if(!check_cipher_algo(CIPHER_ALGO_IDEA))
+             strcat(dummy_string,"S1 ");
+
+           /* SHA-1, RIPEMD160, ZLIB, ZIP */
+           strcat(dummy_string,"H2 H3 Z2 Z1");
+
+           string=dummy_string;
+         }
+      }
     else if (!ascii_strcasecmp (string, "none"))
         string = "";
 
@@ -272,6 +306,10 @@ keygen_set_std_prefs (const char *string,int personal)
              mdc=1;
            else if (ascii_strcasecmp(tok,"no-mdc")==0)
              mdc=0;
+           else if (ascii_strcasecmp(tok,"ks-modify")==0)
+             modify=1;
+           else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
+             modify=0;
            else
              {
                log_info (_("invalid item `%s' in preference string\n"),tok);
@@ -368,6 +406,7 @@ keygen_set_std_prefs (const char *string,int personal)
            memcpy (hash_prefs, hash, (nhash_prefs=nhash));
            memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
            mdc_available = mdc;
+           ks_modify = modify;
            prefs_initialized = 1;
          }
       }
@@ -410,6 +449,7 @@ PKT_user_id *keygen_get_std_prefs(void)
   uid->prefs[j].value=0;
 
   uid->mdc_feature=mdc_available;
+  uid->ks_modify=ks_modify;
 
   return uid;
 }
@@ -455,6 +495,50 @@ add_feature_mdc (PKT_signature *sig,int enabled)
     m_free (buf);
 }
 
+static void
+add_keyserver_modify (PKT_signature *sig,int enabled)
+{
+  const byte *s;
+  size_t n;
+  int i;
+  char *buf;
+
+  /* The keyserver modify flag is a negative flag (i.e. no-modify) */
+  enabled=!enabled;
+
+  s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
+  /* Already set or cleared */
+  if (s && n &&
+      ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
+    return;
+
+  if (!s || !n) { /* create a new one */
+    n = 1;
+    buf = m_alloc_clear (n);
+  }
+  else {
+    buf = m_alloc (n);
+    memcpy (buf, s, n);
+  }
+
+  if(enabled)
+    buf[0] |= 0x80; /* no-modify flag */
+  else
+    buf[0] &= ~0x80;
+
+  /* Are there any bits set? */
+  for(i=0;i<n;i++)
+    if(buf[i]!=0)
+      break;
+
+  if(i==n)
+    delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
+  else
+    build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
+
+  m_free (buf);
+}
+
 int
 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
 {
@@ -487,6 +571,7 @@ keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
 
     /* Make sure that the MDC feature flag is set if needed */
     add_feature_mdc (sig,mdc_available);
+    add_keyserver_modify (sig,ks_modify);
 
     return 0;
 }
@@ -501,24 +586,25 @@ int
 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
 {
     PKT_public_key *pk = opaque;
-    byte buf[8];
 
     do_add_key_flags (sig, pk->pubkey_usage);
     keygen_add_key_expire( sig, opaque );
     keygen_upd_std_prefs (sig, opaque);
 
-    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;
 }
 
 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)
 {
   struct revocation_key *revkey=opaque;
@@ -541,6 +627,104 @@ keygen_add_revkey(PKT_signature *sig, void *opaque)
 }
 
 static int
+make_backsig(PKT_signature *sig, PKT_public_key *pk,
+            PKT_public_key *sub_pk, PKT_secret_key *sub_sk)
+{
+  PKT_signature *backsig;
+  int rc;
+
+#ifndef DO_BACKSIGS
+  /* This is not enabled yet, as I want to get a bit closer to RFC day
+     before enabling this.  I've been burned before :) */
+
+  return 0;
+#endif
+
+  cache_public_key (sub_pk);
+
+  rc=make_keysig_packet(&backsig,pk,NULL,sub_pk,sub_sk, 0x19, 0, 0, 0, 0,
+                       NULL,NULL);
+  if( rc )
+    log_error("make_keysig_packet failed for backsig: %s\n", g10_errstr(rc) );
+  else
+    {
+      /* get it into a binary packed form. */
+      IOBUF backsig_out=iobuf_temp();
+      PACKET backsig_pkt;
+      init_packet(&backsig_pkt);
+      backsig_pkt.pkttype=PKT_SIGNATURE;
+      backsig_pkt.pkt.signature=backsig;
+      rc=build_packet(backsig_out,&backsig_pkt);
+      free_packet(&backsig_pkt);
+      if(rc)
+       log_error("build_packet failed for backsig: %s\n",g10_errstr(rc));
+      else
+       {
+         size_t pktlen=0;
+         byte *buf=iobuf_get_temp_buffer(backsig_out);
+         /* Remove the packet header */
+         if(buf[0]&0x40)
+           {
+             if(buf[1]<192)
+               {
+                 pktlen=buf[1];
+                 buf+=2;
+               }
+             else if(buf[1]<224)
+               {
+                 pktlen=(buf[1]-192)*256;
+                 pktlen+=buf[2]+192;
+                 buf+=3;
+               }
+             else if(buf[1]==255)
+               {
+                 pktlen =buf[2] << 24;
+                 pktlen|=buf[3] << 16;
+                 pktlen|=buf[4] << 8;
+                 pktlen|=buf[5];
+                 buf+=6;
+               }
+             else
+               BUG();
+           }
+         else
+           {
+             int mark=1;
+             switch(buf[0]&3)
+               {
+               case 3:
+                 BUG();
+                 break;
+               case 2:
+                 pktlen =buf[mark++] << 24;
+                 pktlen|=buf[mark++] << 16;
+               case 1:
+                 pktlen|=buf[mark++] << 8;
+               case 0:
+                 pktlen|=buf[mark++];
+               }
+             buf+=mark;
+           }
+         /* now make the binary blob into a subpacket */
+         build_sig_subpkt(sig,SIGSUBPKT_SIGNATURE,buf,pktlen);
+
+         iobuf_close(backsig_out);
+       }
+    }
+  return rc;
+}
+
+
+static int
 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
                  struct revocation_key *revkey )
 {
@@ -622,15 +806,17 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
     return rc;
 }
 
+/* sub_sk is currently unused (reserved for backsigs) */
 static int
-write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
+write_keybinding( KBNODE root, KBNODE pub_root,
+                 PKT_secret_key *pri_sk, PKT_secret_key *sub_sk,
                   unsigned int use )
 {
     PACKET *pkt;
     PKT_signature *sig;
     int rc=0;
     KBNODE node;
-    PKT_public_key *pk, *subpk;
+    PKT_public_key *pri_pk, *sub_pk;
     struct opaque_data_usage_and_pk oduap;
 
     if( opt.verbose )
@@ -640,30 +826,38 @@ write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
     if( !node )
        BUG();
-    pk = node->pkt->pkt.public_key;
+    pri_pk = node->pkt->pkt.public_key;
     /* we have to cache the key, so that the verification of the signature
      * creation is able to retrieve the public key */
-    cache_public_key (pk);
+    cache_public_key (pri_pk);
  
     /* find the last subkey */
-    subpk = NULL;
+    sub_pk = NULL;
     for(node=pub_root; node; node = node->next ) {
        if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
-           subpk = node->pkt->pkt.public_key;
+           sub_pk = node->pkt->pkt.public_key;
     }
-    if( !subpk )
+    if( !sub_pk )
        BUG();
 
     /* and make the signature */
     oduap.usage = use;
-    oduap.pk = subpk;
-    rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0, 0, 0, 0,
-                            keygen_add_key_flags_and_expire, &oduap );
+    oduap.pk = sub_pk;
+    rc=make_keysig_packet(&sig, pri_pk, NULL, sub_pk, pri_sk, 0x18, 0, 0, 0, 0,
+                         keygen_add_key_flags_and_expire, &oduap );
     if( rc ) {
        log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
        return rc;
     }
 
+    /* make a backsig */
+    if(use&PUBKEY_USAGE_SIG)
+      {
+       rc=make_backsig(sig,pri_pk,sub_pk,sub_sk);
+       if(rc)
+         return rc;
+      }
+
     pkt = m_alloc_clear( sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
@@ -674,7 +868,7 @@ 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 )
+       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
 {
     int rc;
     int i;
@@ -721,7 +915,7 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     sk->protect.algo = 0;
 
     sk->csum = checksum_mpi( sk->skey[3] );
-    if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
+    if( ret_sk ) /* return an unprotected version of the sk */
        *ret_sk = copy_secret_key( NULL, sk );
 
     if( dek ) {
@@ -737,14 +931,14 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     }
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
     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 = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
     for(i=0; factors[i]; i++ )
@@ -760,7 +954,7 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
  */
 static int
 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
-           STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
+       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
 {
     int rc;
     int i;
@@ -807,7 +1001,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     sk->protect.algo = 0;
 
     sk->csum = checksum_mpi ( sk->skey[4] );
-    if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
+    if( ret_sk ) /* return an unprotected version of the sk */
        *ret_sk = copy_secret_key( NULL, sk );
 
     if( dek ) {
@@ -823,7 +1017,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     }
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
     pkt->pkt.public_key = pk;
     add_kbnode(pub_root, new_kbnode( pkt ));
 
@@ -834,7 +1028,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
      * are known.
      */
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
     for(i=1; factors[i]; i++ ) /* the first one is q */
@@ -850,7 +1044,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
  */
 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 )
+       STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
 {
     int rc;
     PACKET *pkt;
@@ -900,7 +1094,7 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     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 */
+    if( ret_sk ) /* return an unprotected version of the sk */
        *ret_sk = copy_secret_key( NULL, sk );
 
     if( dek ) {
@@ -916,12 +1110,12 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     }
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
     pkt->pkt.public_key = pk;
     add_kbnode(pub_root, new_kbnode( pkt ));
 
     pkt = m_alloc_clear(sizeof *pkt);
-    pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+    pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
 
@@ -936,10 +1130,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;
@@ -958,7 +1152,7 @@ check_valid_days( const char *s )
 
 
 /****************
- * Returns: 0 to create both a DSA and a ElGamal key.
+ * Returns: 0 to create both a DSA and a Elgamal key.
  *          and only if key flags are to be written the desired usage.
  */
 static int
@@ -970,17 +1164,15 @@ ask_algo (int addmode, unsigned int *r_usage)
     *r_usage = 0;
     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) DSA and Elgamal (default)\n"), 1 );
     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
     if( addmode )
-       tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
-    if (opt.expert)
-        tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
-    tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
+       tty_printf(    _("   (%d) Elgamal (encrypt only)\n"), 3 );
+    tty_printf(    _("   (%d) RSA (sign only)\n"), 4 );
     if (addmode)
-        tty_printf(    _("   (%d) RSA (encrypt only)\n"), 6 );
+        tty_printf(    _("   (%d) RSA (encrypt only)\n"), 5 );
     if (opt.expert)
-      tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 7 );
+      tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 6 );
 
     for(;;) {
        answer = cpr_get("keygen.algo",_("Your selection? "));
@@ -991,41 +1183,29 @@ ask_algo (int addmode, unsigned int *r_usage)
            algo = 0;   /* create both keys */
            break;
        }
-       else if( algo == 7 && opt.expert ) {
+       else if( algo == 6 && opt.expert ) {
            algo = PUBKEY_ALGO_RSA;
            *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
            break;
        }
-       else if( algo == 6 && addmode ) {
+       else if( algo == 5 && addmode ) {
            algo = PUBKEY_ALGO_RSA;
             *r_usage = PUBKEY_USAGE_ENC;
            break;
        }
-       else if( algo == 5 ) {
+       else if( algo == 4 ) {
            algo = PUBKEY_ALGO_RSA;
             *r_usage = PUBKEY_USAGE_SIG;
            break;
        }
-       else if( algo == 4 && opt.expert)
-         {
-           tty_printf(_(
-"The use of this algorithm is only supported by GnuPG.  You will not be\n"
-"able to use this key to communicate with PGP users.  This algorithm is also\n"
-"very slow, and may not be as secure as the other choices.\n"));
-
-           if( cpr_get_answer_is_yes("keygen.algo.elg_se",
-                                     _("Create anyway? ")))
-             {
-               algo = PUBKEY_ALGO_ELGAMAL;
-               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
@@ -1273,7 +1453,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"));
@@ -1287,7 +1467,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)
                         || string_count_chr(amail,'@') != 1
@@ -1340,7 +1520,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") );
@@ -1410,7 +1591,7 @@ ask_user_id( int mode )
 
 
 static DEK *
-ask_passphrase( STRING2KEY **ret_s2k )
+do_ask_passphrase( STRING2KEY **ret_s2k )
 {
     DEK *dek = NULL;
     STRING2KEY *s2k;
@@ -1422,10 +1603,11 @@ ask_passphrase( STRING2KEY **ret_s2k )
     for(;;) {
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
-       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,errtext);
+       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
+                                 errtext, NULL);
        if( !dek ) {
-           errtext = _("passphrase not correctly repeated; try again");
-           tty_printf(_("%s.\n"), errtext);
+           errtext = N_("passphrase not correctly repeated; try again");
+           tty_printf(_("%s.\n"), _(errtext));
        }
        else if( !dek->keylen ) {
            m_free(dek); dek = NULL;
@@ -1446,37 +1628,41 @@ ask_passphrase( STRING2KEY **ret_s2k )
 
 static int
 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
-          DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
+          DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
+          int is_subkey )
 {
-    int rc=0;
+  int rc=0;
 
-    if( !opt.batch )
-       tty_printf(_(
+  if( !opt.batch )
+    tty_printf(_(
 "We need to generate a lot of random bytes. It is a good idea to perform\n"
 "some other action (type on the keyboard, move the mouse, utilize the\n"
 "disks) during the prime generation; this gives the random number\n"
 "generator a better chance to gain enough entropy.\n") );
 
-    if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
-       rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
-    else if( algo == PUBKEY_ALGO_DSA )
-       rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
-    else if( algo == PUBKEY_ALGO_RSA )
-       rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
-    else
-       BUG();
-
-  #ifdef ENABLE_COMMENT_PACKETS
-    if( !rc ) {
-       add_kbnode( pub_root,
+  if( algo == PUBKEY_ALGO_ELGAMAL_E )
+    rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
+                is_subkey);
+  else if( algo == PUBKEY_ALGO_DSA )
+    rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
+                is_subkey);
+  else if( algo == PUBKEY_ALGO_RSA )
+    rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
+                is_subkey);
+  else
+    BUG();
+
+#ifdef ENABLE_COMMENT_PACKETS
+  if( !rc ) {
+    add_kbnode( pub_root,
                make_comment_node("#created by GNUPG v" VERSION " ("
-                                           PRINTABLE_OS_NAME ")"));
-       add_kbnode( sec_root,
+                                 PRINTABLE_OS_NAME ")"));
+    add_kbnode( sec_root,
                make_comment_node("#created by GNUPG v" VERSION " ("
-                                           PRINTABLE_OS_NAME ")"));
-    }
-  #endif
-    return rc;
+                                 PRINTABLE_OS_NAME ")"));
+  }
+#endif
+  return rc;
 }
 
 
@@ -1542,7 +1728,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 = string_to_pubkey_algo( r->u.value );
@@ -1574,6 +1760,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 */
@@ -1681,7 +1869,7 @@ get_parameter_revkey( struct para_data_s *para, enum para_name key )
 
 static int
 proc_parameter_file( struct para_data_s *para, const char *fname,
-                     struct output_control_s *outctrl )
+                     struct output_control_s *outctrl, int card )
 {
     struct para_data_s *r;
     const char *s1, *s2, *s3;
@@ -1752,7 +1940,8 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
        set_next_passphrase( r->u.value );
-       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
+       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
+                                 NULL, NULL);
        set_next_passphrase( NULL );
        assert( dek );
        memset( r->u.value, 0, strlen(r->u.value) );
@@ -1792,7 +1981,7 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
        return -1;
     }
 
-    do_generate_keypair( para, outctrl );
+    do_generate_keypair( para, outctrl, card );
     return 0;
 }
 
@@ -1876,7 +2065,7 @@ read_parameter_file( const char *fname )
                outctrl.dryrun = 1;
            else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
                outctrl.lnr = lnr;
-               proc_parameter_file( para, fname, &outctrl );
+               proc_parameter_file( para, fname, &outctrl, 0 );
                release_parameter_list( para );
                para = NULL;
            }
@@ -1936,7 +2125,7 @@ read_parameter_file( const char *fname )
 
        if( keywords[i].key == pKEYTYPE && para ) {
            outctrl.lnr = lnr;
-           proc_parameter_file( para, fname, &outctrl );
+           proc_parameter_file( para, fname, &outctrl, 0 );
            release_parameter_list( para );
            para = NULL;
        }
@@ -1964,12 +2153,19 @@ read_parameter_file( const char *fname )
     }
     else if( para ) {
        outctrl.lnr = lnr;
-       proc_parameter_file( para, fname, &outctrl );
+       proc_parameter_file( para, fname, &outctrl, 0 );
     }
 
     if( outctrl.use_files ) { /* close open streams */
        iobuf_close( outctrl.pub.stream );
        iobuf_close( outctrl.sec.stream );
+
+        /* Must invalidate that ugly cache to actually close it.  */
+        if (outctrl.pub.fname)
+          iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
+        if (outctrl.sec.fname)
+          iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
+
        m_free( outctrl.pub.fname );
        m_free( outctrl.pub.newfname );
        m_free( outctrl.sec.fname );
@@ -1982,81 +2178,146 @@ 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;
-    DEK *dek;
-    STRING2KEY *s2k;
-    int algo;
-    unsigned int use;
-    int both = 0;
-    u32 expire;
-    struct para_data_s *para = NULL;
-    struct para_data_s *r;
-    struct output_control_s outctrl;
-
-    memset( &outctrl, 0, sizeof( outctrl ) );
-
-    if( opt.batch ) {
-       read_parameter_file( fname );
-       return;
-    }
-
-    algo = ask_algo( 0, &use );
-    if( !algo ) { /* default: DSA with ElG subkey of the specified size */
-       both = 1;
-       r = m_alloc_clear( sizeof *r + 20 );
-       r->key = pKEYTYPE;
-       sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
-       r->next = para;
-       para = r;
-       tty_printf(_("DSA keypair will have 1024 bits.\n"));
-       r = m_alloc_clear( sizeof *r + 20 );
-       r->key = pKEYLENGTH;
-       strcpy( r->u.value, "1024" );
-       r->next = para;
-       para = r;
-
-       algo = PUBKEY_ALGO_ELGAMAL_E;
-       r = m_alloc_clear( sizeof *r + 20 );
-       r->key = pSUBKEYTYPE;
-       sprintf( r->u.value, "%d", algo );
-       r->next = para;
-       para = r;
-    }
-    else {
-       r = m_alloc_clear( sizeof *r + 20 );
-       r->key = pKEYTYPE;
-       sprintf( r->u.value, "%d", algo );
-       r->next = para;
-       para = r;
-
-        if (use) {
-            r = m_alloc_clear( sizeof *r + 20 );
-            r->key = pKEYUSAGE;
-            sprintf( r->u.value, "%s%s",
-                     (use & PUBKEY_USAGE_SIG)? "sign ":"",
-                     (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
-            r->next = para;
-            para = r;
-        }
-
+  unsigned int nbits;
+  char *uid = NULL;
+  DEK *dek;
+  STRING2KEY *s2k;
+  int algo;
+  unsigned int use;
+  int both = 0;
+  u32 expire;
+  struct para_data_s *para = NULL;
+  struct para_data_s *r;
+  struct output_control_s outctrl;
+  
+  memset( &outctrl, 0, sizeof( outctrl ) );
+  
+  if (opt.batch && card_serialno)
+    {
+      /* We don't yet support unattended key generation. */
+      log_error (_("sorry, can't do this in batch mode\n"));
+      return;
     }
-
-    nbits = ask_keysize( algo );
-    r = m_alloc_clear( sizeof *r + 20 );
-    r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
-    sprintf( r->u.value, "%u", nbits);
-    r->next = para;
-    para = r;
-
-    expire = ask_expire_interval(0);
+  
+   if (opt.batch)
+     {
+       read_parameter_file( fname );
+       return;
+     }
+
+   if (card_serialno)
+     {
+#ifdef ENABLE_CARD_SUPPORT
+       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
+       r->key = pSERIALNO;
+       strcpy( r->u.value, card_serialno);
+       r->next = para;
+       para = r;
+       
+       algo = PUBKEY_ALGO_RSA;
+       
+       r = xcalloc (1, sizeof *r + 20 );
+       r->key = pKEYTYPE;
+       sprintf( r->u.value, "%d", algo );
+       r->next = para;
+       para = r;
+       r = xcalloc (1, sizeof *r + 20 );
+       r->key = pKEYUSAGE;
+       strcpy (r->u.value, "sign");
+       r->next = para;
+       para = r;
+       
+       r = xcalloc (1, sizeof *r + 20 );
+       r->key = pSUBKEYTYPE;
+       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;
+       para = r;
+       
+       r = xcalloc (1, sizeof *r + 20 );
+       r->key = pAUTHKEYTYPE;
+       sprintf( r->u.value, "%d", algo );
+       r->next = para;
+       para = r;
+#endif /*ENABLE_CARD_SUPPORT*/
+     }
+   else
+     {
+       algo = ask_algo( 0, &use );
+       if( !algo )
+         { /* default: DSA with ElG subkey of the specified size */
+           both = 1;
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pKEYTYPE;
+           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
+           r->next = para;
+           para = r;
+           tty_printf(_("DSA keypair will have 1024 bits.\n"));
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pKEYLENGTH;
+           strcpy( r->u.value, "1024" );
+           r->next = para;
+           para = r;
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pKEYUSAGE;
+           strcpy( r->u.value, "sign" );
+           r->next = para;
+           para = r;
+           
+           algo = PUBKEY_ALGO_ELGAMAL_E;
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pSUBKEYTYPE;
+           sprintf( r->u.value, "%d", algo );
+           r->next = para;
+           para = r;
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pSUBKEYUSAGE;
+           strcpy( r->u.value, "encrypt" );
+           r->next = para;
+           para = r;
+         }
+       else 
+         {
+           r = m_alloc_clear( sizeof *r + 20 );
+           r->key = pKEYTYPE;
+           sprintf( r->u.value, "%d", algo );
+           r->next = para;
+           para = r;
+           
+           if (use)
+             {
+               r = m_alloc_clear( sizeof *r + 20 );
+               r->key = pKEYUSAGE;
+               sprintf( r->u.value, "%s%s",
+                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
+                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
+               r->next = para;
+               para = r;
+             }
+           
+         }
+       
+       nbits = ask_keysize( algo );
+       r = m_alloc_clear( sizeof *r + 20 );
+       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
+       sprintf( r->u.value, "%u", nbits);
+       r->next = para;
+       para = r;
+     }
+
+   expire = ask_expire_interval(0);
     r = m_alloc_clear( sizeof *r + 20 );
     r->key = pKEYEXPIRE;
     r->u.expire = expire;
@@ -2069,19 +2330,21 @@ generate_keypair( const char *fname )
     para = r;
 
     uid = ask_user_id(0);
-    if( !uid ) {
+    if( !uid ) 
+      {
        log_error(_("Key generation canceled.\n"));
        release_parameter_list( para );
        return;
-    }
+      }
     r = m_alloc_clear( sizeof *r + strlen(uid) );
     r->key = pUSERID;
     strcpy( r->u.value, uid );
     r->next = para;
     para = r;
-
-    dek = ask_passphrase( &s2k );
-    if( dek ) {
+    
+    dek = card_serialno? NULL : do_ask_passphrase( &s2k );
+    if( dek )
+      {
        r = m_alloc_clear( sizeof *r );
        r->key = pPASSPHRASE_DEK;
        r->u.dek = dek;
@@ -2092,9 +2355,9 @@ generate_keypair( const char *fname )
        r->u.s2k = s2k;
        r->next = para;
        para = r;
-    }
-
-    proc_parameter_file( para, "[internal]", &outctrl );
+      }
+    
+    proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
     release_parameter_list( para );
 }
 
@@ -2119,11 +2382,11 @@ print_status_key_created (int letter, PKT_public_key *pk)
 
 static void
 do_generate_keypair( struct para_data_s *para,
-                    struct output_control_s *outctrl )
+                    struct output_control_s *outctrl, int card )
 {
     KBNODE pub_root = NULL;
     KBNODE sec_root = NULL;
-    PKT_secret_key *sk = NULL;
+    PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
     const char *s;
     struct revocation_key *revkey;
     int rc;
@@ -2139,6 +2402,8 @@ do_generate_keypair( struct para_data_s *para,
        if( outctrl->pub.newfname ) {
            iobuf_close(outctrl->pub.stream);
            outctrl->pub.stream = NULL;
+            if (outctrl->pub.fname)
+              iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
            m_free( outctrl->pub.fname );
            outctrl->pub.fname =  outctrl->pub.newfname;
            outctrl->pub.newfname = NULL;
@@ -2156,13 +2421,19 @@ do_generate_keypair( struct para_data_s *para,
            }
        }
        if( outctrl->sec.newfname ) {
+            mode_t oldmask;
+
            iobuf_close(outctrl->sec.stream);
            outctrl->sec.stream = NULL;
+            if (outctrl->sec.fname)
+              iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
            m_free( outctrl->sec.fname );
            outctrl->sec.fname =  outctrl->sec.newfname;
            outctrl->sec.newfname = NULL;
 
+           oldmask = umask (077);
            outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
+            umask (oldmask);
            if( !outctrl->sec.stream ) {
                log_error("can't create `%s': %s\n", outctrl->sec.newfname,
                                                     strerror(errno) );
@@ -2178,7 +2449,11 @@ do_generate_keypair( struct para_data_s *para,
        assert( outctrl->sec.stream );
         if( opt.verbose ) {
             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
-            log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
+            if (card)
+              log_info (_("writing secret key stub to `%s'\n"),
+                        outctrl->sec.fname);
+            else
+              log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
         }
     }
 
@@ -2191,19 +2466,32 @@ do_generate_keypair( struct para_data_s *para,
     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
 
-    rc = do_create( get_parameter_algo( para, pKEYTYPE ),
-                   get_parameter_uint( para, pKEYLENGTH ),
-                   pub_root, sec_root,
-                   get_parameter_dek( para, pPASSPHRASE_DEK ),
-                   get_parameter_s2k( para, pPASSPHRASE_S2K ),
-                   &sk,
-                   get_parameter_u32( para, pKEYEXPIRE ) );
+    if (!card)
+      {
+        rc = do_create( get_parameter_algo( para, pKEYTYPE ),
+                        get_parameter_uint( para, pKEYLENGTH ),
+                        pub_root, sec_root,
+                        get_parameter_dek( para, pPASSPHRASE_DEK ),
+                        get_parameter_s2k( para, pPASSPHRASE_S2K ),
+                        &pri_sk,
+                        get_parameter_u32( para, pKEYEXPIRE ), 0 );
+      }
+    else
+      {
+        rc = gen_card_key (PUBKEY_ALGO_RSA, 1, pub_root, sec_root,
+                           get_parameter_u32 (para, pKEYEXPIRE), para);
+        if (!rc)
+          {
+            pri_sk = sec_root->next->pkt->pkt.secret_key;
+            assert (pri_sk);
+          }
+      }
 
     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
       {
-       rc=write_direct_sig(pub_root,pub_root,sk,revkey);
+       rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
        if(!rc)
-         write_direct_sig(sec_root,pub_root,sk,revkey);
+         write_direct_sig(sec_root,pub_root,pri_sk,revkey);
       }
 
     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
@@ -2211,31 +2499,51 @@ do_generate_keypair( struct para_data_s *para,
        if( !rc )
            write_uid(sec_root, s );
        if( !rc )
-           rc = write_selfsig(pub_root, pub_root, sk,
+           rc = write_selfsig(pub_root, pub_root, pri_sk,
                                get_parameter_uint (para, pKEYUSAGE));
        if( !rc )
-           rc = write_selfsig(sec_root, pub_root, sk,
+           rc = write_selfsig(sec_root, pub_root, pri_sk,
                                get_parameter_uint (para, pKEYUSAGE));
     }
 
-    if( get_parameter( para, pSUBKEYTYPE ) ) {
-       rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
-                       get_parameter_uint( para, pSUBKEYLENGTH ),
-                       pub_root, sec_root,
-                       get_parameter_dek( para, pPASSPHRASE_DEK ),
-                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
-                       NULL,
-                       get_parameter_u32( para, pSUBKEYEXPIRE ) );
-       if( !rc )
-           rc = write_keybinding(pub_root, pub_root, sk,
-                                         get_parameter_uint (para, pSUBKEYUSAGE));
-       if( !rc )
-           rc = write_keybinding(sec_root, pub_root, sk,
-                                         get_parameter_uint (para, pSUBKEYUSAGE));
+    if( get_parameter( para, pSUBKEYTYPE ) )
+      {
+        if (!card)
+          {
+            rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
+                            get_parameter_uint( para, pSUBKEYLENGTH ),
+                            pub_root, sec_root,
+                            get_parameter_dek( para, pPASSPHRASE_DEK ),
+                            get_parameter_s2k( para, pPASSPHRASE_S2K ),
+                            &sub_sk,
+                            get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
+          }
+        else
+          {
+            rc = gen_card_key (PUBKEY_ALGO_RSA, 2, pub_root, sec_root,
+                               get_parameter_u32 (para, pKEYEXPIRE), para);
+          }
+
+        if( !rc )
+          rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
+                                get_parameter_uint (para, pSUBKEYUSAGE));
+        if( !rc )
+          rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
+                                get_parameter_uint (para, pSUBKEYUSAGE));
         did_sub = 1;
-    }
-
+      }
 
+    if (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, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
+        if (!rc)
+          rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
+      }
+    
     if( !rc && outctrl->use_files ) { /* direct write to specified files */
        rc = write_keyblock( outctrl->pub.stream, pub_root );
        if( rc )
@@ -2267,8 +2575,12 @@ do_generate_keypair( struct para_data_s *para,
         if (!rc && opt.verbose) {
             log_info(_("writing public key to `%s'\n"),
                      keydb_get_resource_name (pub_hd));
-            log_info(_("writing secret key to `%s'\n"),
-                     keydb_get_resource_name (sec_hd));
+            if (card)
+              log_info (_("writing secret key stub to `%s'\n"),
+                        keydb_get_resource_name (sec_hd));
+            else
+              log_info(_("writing secret key to `%s'\n"),
+                       keydb_get_resource_name (sec_hd));
         }
 
         if (!rc) {
@@ -2295,14 +2607,16 @@ do_generate_keypair( struct para_data_s *para,
                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
             PKT_public_key *pk = find_kbnode (pub_root, 
                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
-            
-            update_ownertrust (pk,
-                               ((get_ownertrust (pk) & ~TRUST_MASK)
-                                | TRUST_ULTIMATE ));
+
+           keyid_from_pk(pk,pk->main_keyid);
+           register_trusted_keyid(pk->main_keyid);
+
+           update_ownertrust (pk,
+                              ((get_ownertrust (pk) & ~TRUST_MASK)
+                               | TRUST_ULTIMATE ));
 
            if (!opt.batch) {
                 tty_printf(_("public and secret key created and signed.\n") );
-                tty_printf(_("key marked as ultimately trusted.\n") );
                tty_printf("\n");
                list_keyblock(pub_root,0,1,NULL);
             }
@@ -2334,8 +2648,11 @@ do_generate_keypair( struct para_data_s *para,
     }
     release_kbnode( pub_root );
     release_kbnode( sec_root );
-    if( sk ) /* the unprotected  secret key */
-       free_secret_key(sk);
+
+    if( pri_sk && !card) /* the unprotected  secret key unless we have a */
+      free_secret_key(pri_sk); /* shallow copy in card mode. */
+    if( sub_sk )
+       free_secret_key(sub_sk);
 }
 
 
@@ -2348,7 +2665,7 @@ 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 */
+    PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
     int algo;
     unsigned int use;
     u32 expire;
@@ -2366,11 +2683,11 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
     }
 
     /* make a copy of the sk to keep the protected one in the keyblock */
-    sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
+    pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
 
     cur_time = make_timestamp();
-    if( sk->timestamp > cur_time ) {
-       ulong d = sk->timestamp - cur_time;
+    if( pri_sk->timestamp > cur_time ) {
+       ulong d = pri_sk->timestamp - cur_time;
        log_info( d==1 ? _("key has been created %lu second "
                           "in future (time warp or clock problem)\n")
                       : _("key has been created %lu seconds "
@@ -2381,14 +2698,14 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
        }
     }
 
-    if (sk->version < 4) {
+    if (pri_sk->version < 4) {
         log_info (_("NOTE: creating subkeys for v3 keys "
                     "is not OpenPGP compliant\n"));
        goto leave;
     }
 
     /* unprotect to get the passphrase */
-    switch( is_secret_key_protected( sk ) ) {
+    switch( is_secret_key_protected( pri_sk ) ) {
       case -1:
        rc = G10ERR_PUBKEY_ALGO;
        break;
@@ -2397,7 +2714,7 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
        break;
       default:
        tty_printf("Key is protected.\n");
-       rc = check_secret_key( sk, 0 );
+       rc = check_secret_key( pri_sk, 0 );
        if( !rc )
            passphrase = get_last_passphrase();
        break;
@@ -2405,7 +2722,6 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
     if( rc )
        goto leave;
 
-
     algo = ask_algo( 1, &use );
     assert(algo);
     nbits = ask_keysize( algo );
@@ -2419,15 +2735,16 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
        set_next_passphrase( passphrase );
-       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
+       dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
+                                 NULL, NULL );
     }
 
     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
-                                     dek, s2k, NULL, expire );
+                                     dek, s2k, &sub_sk, expire, 1 );
     if( !rc )
-       rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
+       rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
     if( !rc )
-       rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
+       rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
     if( !rc ) {
        okay = 1;
         write_status_text (STATUS_KEY_CREATED, "S");
@@ -2439,8 +2756,11 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
     m_free( passphrase );
     m_free( dek );
     m_free( s2k );
-    if( sk ) /* release the copy of the (now unprotected) secret key */
-       free_secret_key(sk);
+    /* release the copy of the (now unprotected) secret keys */
+    if( pri_sk )
+       free_secret_key(pri_sk);
+    if( sub_sk )
+       free_secret_key(sub_sk);
     set_next_passphrase( NULL );
     return okay;
 }
@@ -2461,3 +2781,81 @@ write_keyblock( IOBUF out, KBNODE node )
     }
     return 0;
 }
+
+
+static int
+gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
+              u32 expireval, struct para_data_s *para)
+{
+#ifdef ENABLE_CARD_SUPPORT
+  int rc;
+  const char *s;
+  struct agent_card_genkey_s info;
+  PACKET *pkt;
+  PKT_secret_key *sk;
+  PKT_public_key *pk;
+
+  assert (algo == PUBKEY_ALGO_RSA);
+
+  rc = agent_scd_genkey (&info, keyno, 1);
+/*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
+/*      { */
+/*        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 = agent_scd_genkey (&info, keyno, 1); */
+/*      } */
+
+  if (rc)
+    {
+      log_error ("key generation failed: %s\n", gpg_strerror (rc));
+      return rc;
+    }
+  if ( !info.n || !info.e )
+    {
+      log_error ("communication error with SCD\n");
+      mpi_free (info.n);
+      mpi_free (info.e);
+      return gpg_error (GPG_ERR_GENERAL);
+    }
+  
+
+  pk = xcalloc (1, sizeof *pk );
+  sk = xcalloc (1, sizeof *sk );
+  sk->timestamp = pk->timestamp = info.created_at;
+  sk->version = pk->version = 4;
+  if (expireval)
+      sk->expiredate = pk->expiredate = pk->timestamp + expireval;
+  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->is_protected = 1;
+  sk->protect.s2k.mode = 1002;
+  s = get_parameter_value (para, pSERIALNO);
+  if (s)
+    {
+      for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
+           sk->protect.ivlen++, s += 2)
+        sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
+    }
+
+  pkt = xcalloc (1,sizeof *pkt);
+  pkt->pkttype = keyno == 1 ? 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 = keyno == 1 ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
+  pkt->pkt.secret_key = sk;
+  add_kbnode(sec_root, new_kbnode( pkt ));
+
+  return 0;
+#else
+  return -1;
+#endif /*!ENABLE_CARD_SUPPORT*/
+}