* export.c (parse_export_options): New option sexp-format.
[gnupg.git] / g10 / keygen.c
index ff6fec8..740dce5 100644 (file)
@@ -26,6 +26,8 @@
 #include <ctype.h>
 #include <errno.h>
 #include <assert.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "main.h"
 #include "packet.h"
@@ -36,6 +38,8 @@
 #include "trustdb.h"
 #include "status.h"
 #include "i18n.h"
+#include "call-agent.h"
+
 
 #define MAX_PREFS 30 
 
@@ -57,7 +61,8 @@ enum para_name {
   pSUBKEYEXPIRE, /* in n seconds */
   pPASSPHRASE,
   pPASSPHRASE_DEK,
-  pPASSPHRASE_S2K
+  pPASSPHRASE_S2K,
+  pSERIALNO
 };
 
 struct para_data_s {
@@ -81,13 +86,13 @@ struct output_control_s {
     struct {
        char  *fname;
        char  *newfname;
-       IOBUF stream;
+       iobuf_t stream;
        armor_filter_context_t afx;
     } pub;
     struct {
        char  *fname;
        char  *newfname;
-       IOBUF stream;
+       iobuf_t stream;
        armor_filter_context_t afx;
     } sec;
 };
@@ -109,18 +114,22 @@ static int nzip_prefs;
 static int mdc_available,ks_modify;
 
 static void do_generate_keypair( struct para_data_s *para,
-                                struct output_control_s *outctrl );
-static int  write_keyblock( IOBUF out, KBNODE node );
+                                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);
+
 
 
 static void
 write_uid( KBNODE root, const char *s )
 {
-    PACKET *pkt = m_alloc_clear(sizeof *pkt );
+    PACKET *pkt = xcalloc (1,sizeof *pkt );
     size_t n = strlen(s);
 
     pkt->pkttype = PKT_USER_ID;
-    pkt->pkt.user_id = m_alloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
+    pkt->pkt.user_id = xcalloc (1, sizeof *pkt->pkt.user_id + n - 1 );
     pkt->pkt.user_id->len = n;
     pkt->pkt.user_id->ref = 1;
     strcpy(pkt->pkt.user_id->name, s);
@@ -241,7 +250,7 @@ keygen_set_std_prefs (const char *string,int personal)
     if (!string || !ascii_strcasecmp (string, "default")) {
       if (opt.def_preference_list)
        string=opt.def_preference_list;
-      else if ( !check_cipher_algo(CIPHER_ALGO_IDEA) )
+      else if ( !openpgp_cipher_test_algo(CIPHER_ALGO_IDEA) )
         string = AES CAST5 "S2 S1 H2 H3 Z2 Z1";
       else
         string = AES CAST5 "S2 H2 H3 Z2 Z1";
@@ -261,16 +270,16 @@ keygen_set_std_prefs (const char *string,int personal)
       {
        char *tok,*prefstring;
 
-       prefstring=m_strdup(string); /* need a writable string! */
+       prefstring=xstrdup (string); /* need a writable string! */
 
        while((tok=strsep(&prefstring," ,")))
          {
-           if((val=string_to_cipher_algo(tok)))
+           if((val=openpgp_cipher_map_name(tok)))
              {
                if(set_one_pref(val,1,tok,sym,&nsym))
                  rc=-1;
              }
-           else if((val=string_to_digest_algo(tok)))
+           else if((val=openpgp_md_map_name(tok)))
              {
                if(set_one_pref(val,2,tok,hash,&nhash))
                  rc=-1;
@@ -301,7 +310,7 @@ keygen_set_std_prefs (const char *string,int personal)
              }
          }
 
-       m_free(prefstring);
+       xfree (prefstring);
       }
 
     if(!rc)
@@ -310,7 +319,7 @@ keygen_set_std_prefs (const char *string,int personal)
          {
            if(personal==PREFTYPE_SYM)
              {
-               m_free(opt.personal_cipher_prefs);
+               xfree (opt.personal_cipher_prefs);
 
                if(nsym==0)
                  opt.personal_cipher_prefs=NULL;
@@ -319,7 +328,7 @@ keygen_set_std_prefs (const char *string,int personal)
                    int i;
 
                    opt.personal_cipher_prefs=
-                     m_alloc(sizeof(prefitem_t *)*(nsym+1));
+                     xmalloc (sizeof(prefitem_t *)*(nsym+1));
 
                    for (i=0; i<nsym; i++)
                      {
@@ -333,7 +342,7 @@ keygen_set_std_prefs (const char *string,int personal)
              }
            else if(personal==PREFTYPE_HASH)
              {
-               m_free(opt.personal_digest_prefs);
+               xfree (opt.personal_digest_prefs);
 
                if(nhash==0)
                  opt.personal_digest_prefs=NULL;
@@ -342,7 +351,7 @@ keygen_set_std_prefs (const char *string,int personal)
                    int i;
 
                    opt.personal_digest_prefs=
-                     m_alloc(sizeof(prefitem_t *)*(nhash+1));
+                     xmalloc (sizeof(prefitem_t *)*(nhash+1));
 
                    for (i=0; i<nhash; i++)
                      {
@@ -356,7 +365,7 @@ keygen_set_std_prefs (const char *string,int personal)
              }
            else if(personal==PREFTYPE_ZIP)
              {
-               m_free(opt.personal_compress_prefs);
+               xfree (opt.personal_compress_prefs);
 
                if(nzip==0)
                  opt.personal_compress_prefs=NULL;
@@ -365,7 +374,7 @@ keygen_set_std_prefs (const char *string,int personal)
                    int i;
 
                    opt.personal_compress_prefs=
-                     m_alloc(sizeof(prefitem_t *)*(nzip+1));
+                     xmalloc (sizeof(prefitem_t *)*(nzip+1));
 
                    for (i=0; i<nzip; i++)
                      {
@@ -400,12 +409,12 @@ keygen_set_std_prefs (const char *string,int personal)
 PKT_user_id *keygen_get_std_prefs(void)
 {
   int i,j=0;
-  PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
+  PKT_user_id *uid=xcalloc (1,sizeof(PKT_user_id));
 
   if(!prefs_initialized)
     keygen_set_std_prefs(NULL,0);
 
-  uid->prefs=m_alloc((sizeof(prefitem_t *)*
+  uid->prefs=xmalloc ((sizeof(prefitem_t *)*
                      (nsym_prefs+nhash_prefs+nzip_prefs+1)));
 
   for(i=0;i<nsym_prefs;i++,j++)
@@ -451,10 +460,10 @@ add_feature_mdc (PKT_signature *sig,int enabled)
 
     if (!s || !n) { /* create a new one */
         n = 1;
-        buf = m_alloc_clear (n);
+        buf = xcalloc (1,n);
     }
     else {
-        buf = m_alloc (n);
+        buf = xmalloc (n);
         memcpy (buf, s, n);
     }
 
@@ -473,7 +482,7 @@ add_feature_mdc (PKT_signature *sig,int enabled)
     else
       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 
-    m_free (buf);
+    xfree (buf);
 }
 
 static void
@@ -495,10 +504,10 @@ add_keyserver_modify (PKT_signature *sig,int enabled)
 
   if (!s || !n) { /* create a new one */
     n = 1;
-    buf = m_alloc_clear (n);
+    buf = xcalloc (1,n);
   }
   else {
-    buf = m_alloc (n);
+    buf = xmalloc (n);
     memcpy (buf, s, n);
   }
 
@@ -517,7 +526,7 @@ add_keyserver_modify (PKT_signature *sig,int enabled)
   else
     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
 
-  m_free (buf);
+  xfree (buf);
 }
 
 int
@@ -624,11 +633,11 @@ write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
                            keygen_add_revkey,revkey);
     if( rc ) {
-       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
+       log_error("make_keysig_packet failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
     add_kbnode( root, new_kbnode( pkt ) );
@@ -668,11 +677,11 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
                             keygen_add_std_prefs, pk );
     if( rc ) {
-       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
+       log_error("make_keysig_packet failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
     add_kbnode( root, new_kbnode( pkt ) );
@@ -717,11 +726,11 @@ write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
     rc = make_keysig_packet( &sig, pk, NULL, subpk, 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) );
+       log_error("make_keysig_packet failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
     add_kbnode( root, new_kbnode( pkt ) );
@@ -738,8 +747,8 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     PACKET *pkt;
     PKT_secret_key *sk;
     PKT_public_key *pk;
-    MPI skey[4];
-    MPI *factors;
+    gcry_mpi_t skey[4];
+    gcry_mpi_t *factors;
 
     assert( is_ELGAMAL(algo) );
 
@@ -753,14 +762,15 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        log_info(_("keysize rounded up to %u bits\n"), nbits );
     }
 
-    rc = pubkey_generate( algo, nbits, skey, &factors );
+#warning need to implement this
+    rc = -1 /*pubkey_generate( algo, nbits, skey, &factors )*/;
     if( rc ) {
-       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
+       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xcalloc (1, sizeof *sk );
+    pk = xcalloc (1, sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -786,21 +796,21 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        sk->protect.s2k = *s2k;
        rc = protect_secret_key( sk, dek );
        if( rc ) {
-           log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
+           log_error("protect_secret_key failed: %s\n", gpg_strerror (rc) );
            free_public_key(pk);
            free_secret_key(sk);
            return rc;
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    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 = m_alloc_clear(sizeof *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 ));
@@ -824,8 +834,8 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     PACKET *pkt;
     PKT_secret_key *sk;
     PKT_public_key *pk;
-    MPI skey[5];
-    MPI *factors;
+    gcry_mpi_t skey[5];
+    gcry_mpi_t *factors;
 
     if( nbits > 1024 || nbits < 512 ) {
        nbits = 1024;
@@ -837,14 +847,15 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        log_info(_("keysize rounded up to %u bits\n"), nbits );
     }
 
-    rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
+#warning need to implement this
+    rc = -1 /*pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors )*/;
     if( rc ) {
-       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
+       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xcalloc (1, sizeof *sk );
+    pk = xcalloc (1, sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -872,14 +883,14 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        sk->protect.s2k = *s2k;
        rc = protect_secret_key( sk, dek );
        if( rc ) {
-           log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
+           log_error("protect_secret_key failed: %s\n", gpg_strerror (rc) );
            free_public_key(pk);
            free_secret_key(sk);
            return rc;
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    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 ));
@@ -890,7 +901,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
      * 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 = 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 ));
@@ -913,8 +924,8 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
     PACKET *pkt;
     PKT_secret_key *sk;
     PKT_public_key *pk;
-    MPI skey[6];
-    MPI *factors;
+    gcry_mpi_t skey[6];
+    gcry_mpi_t *factors;
 
     assert( is_RSA(algo) );
 
@@ -928,14 +939,15 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        log_info(_("keysize rounded up to %u bits\n"), nbits );
     }
 
-    rc = pubkey_generate( algo, nbits, skey, &factors );
+#warning need to implement this
+    rc = -1 /*pubkey_generate( algo, nbits, skey, &factors )*/;
     if( rc ) {
-       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
+       log_error("pubkey_generate failed: %s\n", gpg_strerror (rc) );
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xcalloc (1, sizeof *sk );
+    pk = xcalloc (1, sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -965,19 +977,19 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        sk->protect.s2k = *s2k;
        rc = protect_secret_key( sk, dek );
        if( rc ) {
-           log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
+           log_error("protect_secret_key failed: %s\n", gpg_strerror (rc) );
            free_public_key(pk);
            free_secret_key(sk);
            return rc;
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    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 = m_alloc_clear(sizeof *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 ));
@@ -1043,7 +1055,7 @@ ask_algo (int addmode, unsigned int *r_usage)
        answer = cpr_get("keygen.algo",_("Your selection? "));
        cpr_kill_prompt();
        algo = *answer? atoi(answer): 1;
-       m_free(answer);
+       xfree (answer);
        if( algo == 1 && !addmode ) {
            algo = 0;   /* create both keys */
            break;
@@ -1103,7 +1115,7 @@ ask_keysize( int algo )
                       "              minimum keysize is  768 bits\n"
                       "              default keysize is 1024 bits\n"
                       "    highest suggested keysize is 2048 bits\n"),
-                    pubkey_algo_to_string(algo) );
+                    gcry_pk_algo_name (algo) );
     }
 
     for(;;) {
@@ -1111,7 +1123,7 @@ ask_keysize( int algo )
                          _("What keysize do you want? (1024) "));
        cpr_kill_prompt();
        nbits = *answer? atoi(answer): 1024;
-       m_free(answer);
+       xfree (answer);
        if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
            tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
        else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
@@ -1234,7 +1246,7 @@ ask_expire_interval(int object)
     for(;;) {
        u32 curtime=make_timestamp();
 
-       m_free(answer);
+       xfree (answer);
        if(object==0)
          answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
        else
@@ -1269,7 +1281,7 @@ ask_expire_interval(int object)
                                            _("Is this correct (y/n)? ")) )
            break;
     }
-    m_free(answer);
+    xfree (answer);
     return interval;
 }
 
@@ -1280,6 +1292,19 @@ ask_expiredate()
     return x? make_timestamp() + x : 0;
 }
 
+
+static int
+count_chr( const char *string, int c )
+{
+  int count;
+
+  for (count=0; *string; string++ )
+    if ( *string == c )
+      count++;
+  return count;
+}
+
+
 static int
 has_invalid_email_chars( const char *s )
 {
@@ -1320,7 +1345,7 @@ ask_user_id( int mode )
 
        if( !aname ) {
            for(;;) {
-               m_free(aname);
+               xfree (aname);
                aname = cpr_get("keygen.name",_("Real name: "));
                trim_spaces(aname);
                cpr_kill_prompt();
@@ -1340,14 +1365,14 @@ ask_user_id( int mode )
        }
        if( !amail ) {
            for(;;) {
-               m_free(amail);
+               xfree (amail);
                amail = cpr_get("keygen.email",_("Email address: "));
                trim_spaces(amail);
                cpr_kill_prompt();
                if( !*amail )
                    break;   /* no email address is okay */
                else if( has_invalid_email_chars(amail)
-                        || string_count_chr(amail,'@') != 1
+                        || count_chr(amail,'@') != 1
                         || *amail == '@'
                         || amail[strlen(amail)-1] == '@'
                         || amail[strlen(amail)-1] == '.'
@@ -1359,7 +1384,7 @@ ask_user_id( int mode )
        }
        if( !acomment ) {
            for(;;) {
-               m_free(acomment);
+               xfree (acomment);
                acomment = cpr_get("keygen.comment",_("Comment: "));
                trim_spaces(acomment);
                cpr_kill_prompt();
@@ -1373,19 +1398,14 @@ ask_user_id( int mode )
        }
 
 
-       m_free(uid);
-       uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
+       xfree (uid);
+       uid = p = xmalloc (strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
        p = stpcpy(p, aname );
        if( *acomment )
            p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
        if( *amail )
            p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
 
-       /* append a warning if we do not have dev/random
-        * or it is switched into  quick testmode */
-       if( quick_random_gen(-1) )
-           strcpy(p, " (INSECURE!)" );
-
        /* print a note in case that UTF8 mapping has to be done */
        for(p=uid; *p; p++ ) {
            if( *p & 0x80 ) {
@@ -1409,7 +1429,7 @@ ask_user_id( int mode )
            if( strlen(ansstr) != 10 )
                BUG();
            if( cpr_enabled() ) {
-               answer = m_strdup(ansstr+6);
+               answer = xstrdup (ansstr+6);
                answer[1] = 0;
            }
            else {
@@ -1421,15 +1441,15 @@ ask_user_id( int mode )
            if( strlen(answer) > 1 )
                ;
            else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
-               m_free(aname); aname = NULL;
+               xfree (aname); aname = NULL;
                break;
            }
            else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
-               m_free(acomment); acomment = NULL;
+               xfree (acomment); acomment = NULL;
                break;
            }
            else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
-               m_free(amail); amail = NULL;
+               xfree (amail); amail = NULL;
                break;
            }
            else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
@@ -1437,29 +1457,29 @@ ask_user_id( int mode )
                    tty_printf(_("Please correct the error first\n"));
                }
                else {
-                   m_free(aname); aname = NULL;
-                   m_free(acomment); acomment = NULL;
-                   m_free(amail); amail = NULL;
+                   xfree (aname); aname = NULL;
+                   xfree (acomment); acomment = NULL;
+                   xfree (amail); amail = NULL;
                    break;
                }
            }
            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;
+               xfree (aname); aname = NULL;
+               xfree (acomment); acomment = NULL;
+               xfree (amail); amail = NULL;
+               xfree (uid); uid = NULL;
                break;
            }
-           m_free(answer);
+           xfree (answer);
        }
-       m_free(answer);
+       xfree (answer);
        if( !amail && !acomment && !amail )
            break;
-       m_free(uid); uid = NULL;
+       xfree (uid); uid = NULL;
     }
     if( uid ) {
        char *p = native_to_utf8( uid );
-       m_free( uid );
+       xfree ( uid );
        uid = p;
     }
     return uid;
@@ -1475,7 +1495,7 @@ ask_passphrase( STRING2KEY **ret_s2k )
 
     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
 
-    s2k = m_alloc_secure( sizeof *s2k );
+    s2k = xmalloc_secure ( sizeof *s2k );
     for(;;) {
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
@@ -1486,8 +1506,8 @@ ask_passphrase( STRING2KEY **ret_s2k )
            tty_printf(_("%s.\n"), _(errtext));
        }
        else if( !dek->keylen ) {
-           m_free(dek); dek = NULL;
-           m_free(s2k); s2k = NULL;
+           xfree (dek); dek = NULL;
+           xfree (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"
@@ -1552,7 +1572,7 @@ generate_user_id()
     if( !p )
        return NULL;
     n = strlen(p);
-    uid = m_alloc_clear( sizeof *uid + n - 1 );
+    uid = xcalloc (1, sizeof *uid + n - 1 );
     uid->len = n;
     strcpy(uid->name, p);
     uid->ref = 1;
@@ -1568,11 +1588,11 @@ release_parameter_list( struct para_data_s *r )
     for( ; r ; r = r2 ) {
        r2 = r->next;
        if( r->key == pPASSPHRASE_DEK )
-           m_free( r->u.dek );
+           xfree ( r->u.dek );
        else if( r->key == pPASSPHRASE_S2K )
-           m_free( r->u.s2k );
+           xfree ( r->u.s2k );
 
-       m_free(r);
+       xfree (r);
     }
 }
 
@@ -1603,7 +1623,7 @@ get_parameter_algo( struct para_data_s *para, enum para_name key )
     if( isdigit( *r->u.value ) )
        i = atoi( r->u.value );
     else
-        i = string_to_pubkey_algo( r->u.value );
+        i = openpgp_pk_map_name ( r->u.value );
     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
       i = 0; /* we don't want to allow generation of these algorithms */
     return i;
@@ -1739,7 +1759,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;
@@ -1750,7 +1770,7 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
     /* check that we have all required parameters */
     assert( get_parameter( para, pKEYTYPE ) );
     i = get_parameter_algo( para, pKEYTYPE );
-    if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
+    if( i < 1 || openpgp_pk_test_algo ( i, PUBKEY_USAGE_SIG ) ) {
        r = get_parameter( para, pKEYTYPE );
        log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
        return -1;
@@ -1760,7 +1780,7 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
         return -1;
 
     i = get_parameter_algo( para, pSUBKEYTYPE );
-    if( i > 0 && check_pubkey_algo( i ) ) {
+    if( i > 0 && openpgp_pk_test_algo ( i, 0 ) ) {
        r = get_parameter( para, pSUBKEYTYPE );
        log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
        return -1;
@@ -1776,7 +1796,7 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
        s3 = get_parameter_value( para, pNAMEEMAIL );
        if( s1 || s2 || s3 ) {
            n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
-           r = m_alloc_clear( sizeof *r + n + 20 );
+           r = xcalloc (1, sizeof *r + n + 20 );
            r->key = pUSERID;
            p = r->u.value;
            if( s1 )
@@ -1801,12 +1821,12 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
     r = get_parameter( para, pPASSPHRASE );
     if( r && *r->u.value ) {
        /* we have a plain text passphrase - create a DEK from it.
-        * It is a little bit ridiculous to keep it ih secure memory
-        * but becuase we do this alwasy, why not here */
+        * It is a little bit ridiculous to keep it in secure memory
+        * but because we do this always, why not here. */
        STRING2KEY *s2k;
        DEK *dek;
 
-       s2k = m_alloc_secure( sizeof *s2k );
+       s2k = xmalloc_secure ( sizeof *s2k );
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
        set_next_passphrase( r->u.value );
@@ -1816,12 +1836,12 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
        assert( dek );
        memset( r->u.value, 0, strlen(r->u.value) );
 
-       r = m_alloc_clear( sizeof *r );
+       r = xcalloc (1, sizeof *r );
        r->key = pPASSPHRASE_S2K;
        r->u.s2k = s2k;
        r->next = para;
        para = r;
-       r = m_alloc_clear( sizeof *r );
+       r = xcalloc (1, sizeof *r );
        r->key = pPASSPHRASE_DEK;
        r->u.dek = dek;
        r->next = para;
@@ -1839,7 +1859,7 @@ proc_parameter_file( struct para_data_s *para, const char *fname,
        r->u.expire = i * 86400L;
        r->key = pKEYEXPIRE;  /* change hat entry */
        /* also set it for the subkey */
-       r = m_alloc_clear( sizeof *r + 20 );
+       r = xcalloc (1, sizeof *r + 20 );
        r->key = pSUBKEYEXPIRE;
        r->u.expire = i * 86400L;
        r->next = para;
@@ -1851,7 +1871,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;
 }
 
@@ -1935,7 +1955,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;
            }
@@ -1943,8 +1963,8 @@ read_parameter_file( const char *fname )
                if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
                    ; /* still the same file - ignore it */
                else {
-                   m_free( outctrl.pub.newfname );
-                   outctrl.pub.newfname = m_strdup( value );
+                   xfree ( outctrl.pub.newfname );
+                   outctrl.pub.newfname = xstrdup ( value );
                    outctrl.use_files = 1;
                }
            }
@@ -1952,8 +1972,8 @@ read_parameter_file( const char *fname )
                if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
                    ; /* still the same file - ignore it */
                else {
-                  m_free( outctrl.sec.newfname );
-                  outctrl.sec.newfname = m_strdup( value );
+                  xfree ( outctrl.sec.newfname );
+                  outctrl.sec.newfname = xstrdup ( value );
                   outctrl.use_files = 1;
                }
            }
@@ -1995,7 +2015,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;
        }
@@ -2009,7 +2029,7 @@ read_parameter_file( const char *fname )
                break;
            }
        }
-       r = m_alloc_clear( sizeof *r + strlen( value ) );
+       r = xcalloc (1, sizeof *r + strlen( value ) );
        r->lnr = lnr;
        r->key = keywords[i].key;
        strcpy( r->u.value, value );
@@ -2023,16 +2043,16 @@ 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 );
-       m_free( outctrl.pub.fname );
-       m_free( outctrl.pub.newfname );
-       m_free( outctrl.sec.fname );
-       m_free( outctrl.sec.newfname );
+       xfree ( outctrl.pub.fname );
+       xfree ( outctrl.pub.newfname );
+       xfree ( outctrl.sec.fname );
+       xfree ( outctrl.sec.newfname );
     }
 
     release_parameter_list( para );
@@ -2048,113 +2068,169 @@ read_parameter_file( const char *fname )
 void
 generate_keypair( const char *fname )
 {
-    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;
+  unsigned int nbits;
+  char *uid = NULL;
+  DEK *dek;
+  STRING2KEY *s2k;
+  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)
+    {
+      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;
+  do
+    {
+      xfree (serialno); serialno = NULL;
+      card = check_smartcard (&serialno);
+      if (card < 0)
+        return;
+    }
+  while (card > 1);
 
-       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;
+  if (serialno)
+    {
+      r = xcalloc (1, sizeof *r + strlen (serialno) );
+      r->key = pSERIALNO;
+      strcpy( r->u.value, serialno);
+      r->next = para;
+      para = r;
+      xfree (serialno); serialno = NULL;
     }
-    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;
+  if (card)
+    {
+      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;
+    }
+  else
+    {
+      algo = ask_algo (0, &use);
+      
+      if (!algo)
+        { /* default: DSA with ElG subkey of the specified size */
+          both = 1;
+          r = xcalloc (1, 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 = xcalloc (1, sizeof *r + 20 );
+          r->key = pKEYLENGTH;
+          strcpy( r->u.value, "1024" );
+          r->next = para;
+          para = r;
+          
+          algo = PUBKEY_ALGO_ELGAMAL_E;
+          r = xcalloc (1, sizeof *r + 20 );
+          r->key = pSUBKEYTYPE;
+          sprintf( r->u.value, "%d", algo );
+          r->next = para;
+          para = r;
+        }
+      else 
+        {
+          r = xcalloc (1, sizeof *r + 20 );
+          r->key = pKEYTYPE;
+          sprintf( r->u.value, "%d", algo );
+          r->next = para;
+          para = r;
+          
+          if (use)
+            {
+              r = xcalloc (1, 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 = xcalloc (1, 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 = xcalloc (1, sizeof *r + 20 );
+  r->key = pKEYEXPIRE;
+  r->u.expire = expire;
+  r->next = para;
+  para = r;
+  r = xcalloc (1, sizeof *r + 20 );
+  r->key = pSUBKEYEXPIRE;
+  r->u.expire = expire;
+  r->next = para;
+  para = r;
+  
+  uid = ask_user_id(0);
+  if (!uid)
+    {
+      log_error(_("Key generation canceled.\n"));
+      release_parameter_list( para );
+      return;
     }
+  r = xcalloc (1, sizeof *r + strlen(uid) );
+  r->key = pUSERID;
+  strcpy( r->u.value, uid );
+  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;
-    r->next = para;
-    para = r;
-    r = m_alloc_clear( sizeof *r + 20 );
-    r->key = pSUBKEYEXPIRE;
-    r->u.expire = expire;
-    r->next = para;
-    para = r;
-
-    uid = ask_user_id(0);
-    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 ) {
-       r = m_alloc_clear( sizeof *r );
-       r->key = pPASSPHRASE_DEK;
-       r->u.dek = dek;
-       r->next = para;
-       para = r;
-       r = m_alloc_clear( sizeof *r );
-       r->key = pPASSPHRASE_S2K;
-       r->u.s2k = s2k;
-       r->next = para;
-       para = r;
+  dek = card? NULL : ask_passphrase( &s2k );
+  if (dek)
+    {
+      r = xcalloc (1, sizeof *r );
+      r->key = pPASSPHRASE_DEK;
+      r->u.dek = dek;
+      r->next = para;
+      para = r;
+      r = xcalloc (1, sizeof *r );
+      r->key = pPASSPHRASE_S2K;
+      r->u.s2k = s2k;
+      r->next = para;
+      para = r;
     }
-
-    proc_parameter_file( para, "[internal]", &outctrl );
-    release_parameter_list( para );
+  
+  proc_parameter_file (para, "[internal]", &outctrl, card);
+  release_parameter_list (para);
 }
 
 
@@ -2176,225 +2252,280 @@ print_status_key_created (int letter, PKT_public_key *pk)
   write_status_text (STATUS_KEY_CREATED, buf);
 }
 
+
+
 static void
-do_generate_keypairstruct para_data_s *para,
-                    struct output_control_s *outctrl )
+do_generate_keypair (struct para_data_s *para,
+                    struct output_control_s *outctrl, int card)
 {
-    KBNODE pub_root = NULL;
-    KBNODE sec_root = NULL;
-    PKT_secret_key *sk = NULL;
-    const char *s;
-    struct revocation_key *revkey;
-    int rc;
-    int did_sub = 0;
-
-    if( outctrl->dryrun ) {
-       log_info("dry-run mode - key generation skipped\n");
-       return;
+  KBNODE pub_root = NULL;
+  KBNODE sec_root = NULL;
+  PKT_secret_key *sk = NULL;
+  const char *s;
+  struct revocation_key *revkey;
+  int rc;
+  int did_sub = 0;
+
+  if (outctrl->dryrun)
+    {
+      log_info ("dry-run mode - key generation skipped\n");
+      return;
     }
 
 
-    if( outctrl->use_files ) {
-       if( outctrl->pub.newfname ) {
-           iobuf_close(outctrl->pub.stream);
-           outctrl->pub.stream = NULL;
-           m_free( outctrl->pub.fname );
-           outctrl->pub.fname =  outctrl->pub.newfname;
-           outctrl->pub.newfname = NULL;
-
-           outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
-           if( !outctrl->pub.stream ) {
-               log_error("can't create `%s': %s\n", outctrl->pub.newfname,
-                                                    strerror(errno) );
-               return;
+  if (outctrl->use_files)
+    {
+      if (outctrl->pub.newfname)
+       {
+         iobuf_close (outctrl->pub.stream);
+         outctrl->pub.stream = NULL;
+         xfree (outctrl->pub.fname);
+         outctrl->pub.fname = outctrl->pub.newfname;
+         outctrl->pub.newfname = NULL;
+
+         outctrl->pub.stream = iobuf_create (outctrl->pub.fname);
+         if (!outctrl->pub.stream)
+           {
+             log_error ("can't create `%s': %s\n", outctrl->pub.newfname,
+                        strerror (errno));
+             return;
            }
-           if( opt.armor ) {
-               outctrl->pub.afx.what = 1;
-               iobuf_push_filter( outctrl->pub.stream, armor_filter,
-                                                   &outctrl->pub.afx );
+         if (opt.armor)
+           {
+             outctrl->pub.afx.what = 1;
+             iobuf_push_filter (outctrl->pub.stream, armor_filter,
+                                &outctrl->pub.afx);
            }
        }
-       if( outctrl->sec.newfname ) {
-           iobuf_close(outctrl->sec.stream);
-           outctrl->sec.stream = NULL;
-           m_free( outctrl->sec.fname );
-           outctrl->sec.fname =  outctrl->sec.newfname;
-           outctrl->sec.newfname = NULL;
-
-           outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
-           if( !outctrl->sec.stream ) {
-               log_error("can't create `%s': %s\n", outctrl->sec.newfname,
-                                                    strerror(errno) );
-               return;
+      if (outctrl->sec.newfname)
+       {
+         iobuf_close (outctrl->sec.stream);
+         outctrl->sec.stream = NULL;
+         xfree (outctrl->sec.fname);
+         outctrl->sec.fname = outctrl->sec.newfname;
+         outctrl->sec.newfname = NULL;
+
+         outctrl->sec.stream = iobuf_create (outctrl->sec.fname);
+         if (!outctrl->sec.stream)
+           {
+             log_error ("can't create `%s': %s\n", outctrl->sec.newfname,
+                        strerror (errno));
+             return;
            }
-           if( opt.armor ) {
-               outctrl->sec.afx.what = 5;
-               iobuf_push_filter( outctrl->sec.stream, armor_filter,
-                                                   &outctrl->sec.afx );
+         if (opt.armor)
+           {
+             outctrl->sec.afx.what = 5;
+             iobuf_push_filter (outctrl->sec.stream, armor_filter,
+                                &outctrl->sec.afx);
            }
        }
-       assert( outctrl->pub.stream );
-       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 );
+      assert (outctrl->pub.stream);
+      assert (outctrl->sec.stream);
+      if (opt.verbose)
+       {
+         log_info (_("writing public key to `%s'\n"), outctrl->pub.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);
+       }
+    }
+
+
+  /* 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 (!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),
+                      &sk, get_parameter_u32 (para, pKEYEXPIRE));
+    }
+  else
+    {
+      rc = gen_card_key (PUBKEY_ALGO_RSA, 1, pub_root, sec_root,
+                         get_parameter_u32 (para, pKEYEXPIRE), para);
+      if (!rc)
+        {
+          sk = sec_root->next->pkt->pkt.secret_key;
+          assert (sk);
         }
+      
     }
 
+  if (!rc && (revkey = get_parameter_revkey (para, pREVOKER)))
+    {
+      rc = write_direct_sig (pub_root, pub_root, sk, revkey);
+      if (!rc)
+       write_direct_sig (sec_root, pub_root, sk, revkey);
+    }
 
-    /* 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);
-
-    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(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
-      {
-       rc=write_direct_sig(pub_root,pub_root,sk,revkey);
-       if(!rc)
-         write_direct_sig(sec_root,pub_root,sk,revkey);
-      }
+  if (!rc && (s = get_parameter_value (para, pUSERID)))
+    {
+      write_uid (pub_root, s);
+      if (!rc)
+       write_uid (sec_root, s);
+      if (!rc)
+       rc = write_selfsig (pub_root, pub_root, sk,
+                           get_parameter_uint (para, pKEYUSAGE));
+      if (!rc)
+       rc = write_selfsig (sec_root, pub_root, sk,
+                           get_parameter_uint (para, pKEYUSAGE));
+    }
+
+  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),
+                          NULL, get_parameter_u32 (para, pSUBKEYEXPIRE));
+        }
+      else
+        {
+          rc = gen_card_key (PUBKEY_ALGO_RSA, 2, pub_root, sec_root,
+                             get_parameter_u32 (para, pKEYEXPIRE), para);
+        }
 
-    if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
-       write_uid(pub_root, s );
-       if( !rc )
-           write_uid(sec_root, s );
-       if( !rc )
-           rc = write_selfsig(pub_root, pub_root, sk,
-                               get_parameter_uint (para, pKEYUSAGE));
-       if( !rc )
-           rc = write_selfsig(sec_root, pub_root, 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));
-        did_sub = 1;
+      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));
+      did_sub = 1;
     }
 
 
-    if( !rc && outctrl->use_files ) { /* direct write to specified files */
-       rc = write_keyblock( outctrl->pub.stream, pub_root );
-       if( rc )
-           log_error("can't write public key: %s\n", g10_errstr(rc) );
-       if( !rc ) {
-           rc = write_keyblock( outctrl->sec.stream, sec_root );
-           if( rc )
-               log_error("can't write secret key: %s\n", g10_errstr(rc) );
+  if (!rc && outctrl->use_files)
+    {                          /* direct write to specified files */
+      rc = write_keyblock (outctrl->pub.stream, pub_root);
+      if (rc)
+       log_error ("can't write public key: %s\n", gpg_strerror (rc));
+      if (!rc)
+       {
+         rc = write_keyblock (outctrl->sec.stream, sec_root);
+         if (rc)
+           log_error ("can't write secret key: %s\n", gpg_strerror (rc));
        }
 
     }
-    else if( !rc ) { /* write to the standard keyrings */
-       KEYDB_HANDLE pub_hd = keydb_new (0);
-       KEYDB_HANDLE sec_hd = keydb_new (1);
+  else if (!rc)
+    {                          /* write to the standard keyrings */
+      KEYDB_HANDLE pub_hd = keydb_new (0);
+      KEYDB_HANDLE sec_hd = keydb_new (1);
 
-        /* FIXME: we may have to create the keyring first */
-        rc = keydb_locate_writable (pub_hd, NULL);
-        if (rc) 
-           log_error (_("no writable public keyring found: %s\n"),
-                       g10_errstr (rc));
+      /* FIXME: we may have to create the keyring first */
+      rc = keydb_locate_writable (pub_hd, NULL);
+      if (rc)
+       log_error (_("no writable public keyring found: %s\n"),
+                  gpg_strerror (rc));
 
-        if (!rc) {  
-            rc = keydb_locate_writable (sec_hd, NULL);
-            if (rc) 
-                log_error (_("no writable secret keyring found: %s\n"),
-                           g10_errstr (rc));
-        }
+      if (!rc)
+       {
+         rc = keydb_locate_writable (sec_hd, NULL);
+         if (rc)
+           log_error (_("no writable secret keyring found: %s\n"),
+                      gpg_strerror (rc));
+       }
 
-        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 (!rc && opt.verbose)
+       {
+         log_info (_("writing public key to `%s'\n"),
+                   keydb_get_resource_name (pub_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) {
-           rc = keydb_insert_keyblock (pub_hd, pub_root);
-            if (rc)
-                log_error (_("error writing public keyring `%s': %s\n"),
-                           keydb_get_resource_name (pub_hd), g10_errstr(rc));
-        }
+      if (!rc)
+       {
+         rc = keydb_insert_keyblock (pub_hd, pub_root);
+         if (rc)
+           log_error (_("error writing public keyring `%s': %s\n"),
+                      keydb_get_resource_name (pub_hd), gpg_strerror (rc));
+       }
 
-        if (!rc) {
-           rc = keydb_insert_keyblock (sec_hd, sec_root);
-            if (rc)
-                log_error (_("error writing secret keyring `%s': %s\n"),
-                           keydb_get_resource_name (pub_hd), g10_errstr(rc));
-        }
+      if (!rc)
+       {
+         rc = keydb_insert_keyblock (sec_hd, sec_root);
+         if (rc)
+           log_error (_("error writing secret keyring `%s': %s\n"),
+                      keydb_get_resource_name (pub_hd), gpg_strerror (rc));
+       }
 
-        keydb_release (pub_hd);
-        keydb_release (sec_hd);
-
-       if (!rc) {
-            int no_enc_rsa =
-                get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
-                && get_parameter_uint( para, pKEYUSAGE )
-                && !(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 ));
-
-           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);
-            }
-            
+      keydb_release (pub_hd);
+      keydb_release (sec_hd);
+
+      if (!rc)
+       {
+         int no_enc_rsa =
+           get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_RSA
+           && get_parameter_uint (para, pKEYUSAGE)
+           && !(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));
+
+         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);
+           }
 
-           if( !opt.batch
-               && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
-                     || no_enc_rsa )
-               && !get_parameter( para, pSUBKEYTYPE ) )
+
+         if (!opt.batch
+             && (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_DSA
+                 || no_enc_rsa) && !get_parameter (para, pSUBKEYTYPE))
            {
-               tty_printf(_("Note that this key cannot be used for "
-                            "encryption.  You may want to use\n"
-                            "the command \"--edit-key\" to generate a "
-                            "secondary key for this purpose.\n") );
+             tty_printf (_("Note that this key cannot be used for "
+                           "encryption.  You may want to use\n"
+                           "the command \"--edit-key\" to generate a "
+                           "secondary key for this purpose.\n"));
            }
        }
     }
 
-    if( rc ) {
-       if( opt.batch )
-           log_error("key generation failed: %s\n", g10_errstr(rc) );
-       else
-           tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
+  if (rc)
+    {
+      if (opt.batch)
+       log_error ("key generation failed: %s\n", gpg_strerror (rc));
+      else
+       tty_printf (_("Key generation failed: %s\n"), gpg_strerror (rc));
     }
-    else {
-        PKT_public_key *pk = find_kbnode (pub_root, 
-                                    PKT_PUBLIC_KEY)->pkt->pkt.public_key;
-        print_status_key_created (did_sub? 'B':'P', pk);
+  else
+    {
+      PKT_public_key *pk = find_kbnode (pub_root,
+                                       PKT_PUBLIC_KEY)->pkt->pkt.public_key;
+      print_status_key_created (did_sub ? 'B' : 'P', pk);
     }
-    release_kbnode( pub_root );
-    release_kbnode( sec_root );
-    if( sk ) /* the unprotected  secret key */
-       free_secret_key(sk);
+
+  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. */
 }
 
 
@@ -2435,7 +2566,7 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
                       : _("key has been created %lu seconds "
                           "in future (time warp or clock problem)\n"), d );
        if( !opt.ignore_time_conflict ) {
-           rc = G10ERR_TIME_CONFLICT;
+           rc = GPG_ERR_TIME_CONFLICT;
            goto leave;
        }
     }
@@ -2449,7 +2580,7 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
     /* unprotect to get the passphrase */
     switch( is_secret_key_protected( sk ) ) {
       case -1:
-       rc = G10ERR_PUBKEY_ALGO;
+       rc = GPG_ERR_PUBKEY_ALGO;
        break;
       case 0:
        tty_printf("This key is not protected.\n");
@@ -2474,7 +2605,7 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
        goto leave;
 
     if( passphrase ) {
-       s2k = m_alloc_secure( sizeof *s2k );
+       s2k = xmalloc_secure ( sizeof *s2k );
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
        set_next_passphrase( passphrase );
@@ -2495,10 +2626,10 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
 
   leave:
     if( rc )
-       log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
-    m_free( passphrase );
-    m_free( dek );
-    m_free( s2k );
+       log_error(_("Key generation failed: %s\n"), gpg_strerror (rc) );
+    xfree ( passphrase );
+    xfree ( dek );
+    xfree ( s2k );
     if( sk ) /* release the copy of the (now unprotected) secret key */
        free_secret_key(sk);
     set_next_passphrase( NULL );
@@ -2509,15 +2640,351 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
  * Write a keyblock to an output stream
  */
 static int
-write_keyblock( IOBUF out, KBNODE node )
+write_keyblock( iobuf_t out, KBNODE node )
 {
     for( ; node ; node = node->next ) {
        int rc = build_packet( out, node->pkt );
        if( rc ) {
            log_error("build_packet(%d) failed: %s\n",
-                       node->pkt->pkttype, g10_errstr(rc) );
-           return G10ERR_WRITE_FILE;
+                       node->pkt->pkttype, gpg_strerror (rc) );
+           return rc;
        }
     }
     return 0;
 }
+
+\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,
+              u32 expireval, struct para_data_s *para)
+{
+  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");
+      gcry_mpi_release (info.n);
+      gcry_mpi_release (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;
+}
+
+
+