* gpg.c (print_mds), armor.c (armor_filter, parse_hash_header): Add
[gnupg.git] / g10 / keygen.c
index b6bae94..971f839 100644 (file)
@@ -1,6 +1,6 @@
 /* keygen.c - generate a key pair
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- *               2005 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ *               2006 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -16,7 +16,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 #include <config.h>
@@ -128,42 +129,6 @@ static int gen_card_key_with_backup (int algo, int keyno, int is_primary,
                                      const char *backup_dir);
 
 
-#if GNUPG_MAJOR_VERSION == 1
-#define GET_NBITS(a)  mpi_get_nbits (a)
-#else
-#define GET_NBITS(a)  gcry_mpi_get_nbits (a)
-#endif
-
-#ifdef ENABLE_CARD_SUPPORT
-static int
-copy_mpi (MPI a, unsigned char *buffer, size_t len, size_t *ncopied)
-{
-  int rc;
-#if GNUPG_MAJOR_VERSION == 1
-  unsigned char *tmp;
-  unsigned int n;
-
-  tmp = mpi_get_secure_buffer (a, &n, NULL);
-  if (n > len)
-    rc = G10ERR_GENERAL;
-  else
-    {
-      rc = 0;
-      memcpy (buffer, tmp, n);
-      *ncopied = n;
-    }
-  xfree (tmp);
-#else /* GNUPG_MAJOR_VERSION != 1 */
-  rc = gcry_mpi_print (GCRYMPI_FMT_USG, buffer, len, ncopied, a);
-#endif /* GNUPG_MAJOR_VERSION != 1 */
-  if (rc)
-    log_error ("mpi_copy failed: %s\n", gpg_strerror (rc));
-  return rc;
-}
-#endif /* ENABLE_CARD_SUPPORT */
-
-
-
 static void
 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
 {
@@ -209,11 +174,11 @@ print_status_key_not_created (const char *handle)
 static void
 write_uid( KBNODE root, const char *s )
 {
-    PACKET *pkt = m_alloc_clear(sizeof *pkt );
+    PACKET *pkt = xmalloc_clear(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 = xmalloc_clear( 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);
@@ -225,9 +190,6 @@ do_add_key_flags (PKT_signature *sig, unsigned int use)
 {
     byte buf[1];
 
-    if (!use) 
-        return;
-
     buf[0] = 0;
 
     /* The spec says that all primary keys MUST be able to certify. */
@@ -240,6 +202,10 @@ do_add_key_flags (PKT_signature *sig, unsigned int use)
         buf[0] |= 0x04 | 0x08;
     if (use & PUBKEY_USAGE_AUTH)
         buf[0] |= 0x20;
+
+    if (!buf[0]) 
+        return;
+
     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
 }
 
@@ -397,7 +363,7 @@ 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," ,")))
          {
@@ -437,7 +403,7 @@ keygen_set_std_prefs (const char *string,int personal)
              }
          }
 
-       m_free(prefstring);
+       xfree(prefstring);
       }
 
     if(!rc)
@@ -446,7 +412,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;
@@ -455,7 +421,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++)
                      {
@@ -469,7 +435,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;
@@ -478,7 +444,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++)
                      {
@@ -492,7 +458,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;
@@ -501,7 +467,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++)
                      {
@@ -533,14 +499,14 @@ 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=xmalloc_clear(sizeof(PKT_user_id));
 
   if(!prefs_initialized)
     keygen_set_std_prefs(NULL,0);
 
   uid->ref=1;
 
-  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++)
@@ -564,8 +530,8 @@ PKT_user_id *keygen_get_std_prefs(void)
   uid->prefs[j].type=PREFTYPE_NONE;
   uid->prefs[j].value=0;
 
-  uid->mdc_feature=mdc_available;
-  uid->ks_modify=ks_modify;
+  uid->flags.mdc=mdc_available;
+  uid->flags.ks_modify=ks_modify;
 
   return uid;
 }
@@ -586,10 +552,10 @@ add_feature_mdc (PKT_signature *sig,int enabled)
 
     if (!s || !n) { /* create a new one */
         n = 1;
-        buf = m_alloc_clear (n);
+        buf = xmalloc_clear (n);
     }
     else {
-        buf = m_alloc (n);
+        buf = xmalloc (n);
         memcpy (buf, s, n);
     }
 
@@ -608,7 +574,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
@@ -630,10 +596,10 @@ add_keyserver_modify (PKT_signature *sig,int enabled)
 
   if (!s || !n) { /* create a new one */
     n = 1;
-    buf = m_alloc_clear (n);
+    buf = xmalloc_clear (n);
   }
   else {
-    buf = m_alloc (n);
+    buf = xmalloc (n);
     memcpy (buf, s, n);
   }
 
@@ -652,7 +618,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
@@ -724,6 +690,55 @@ keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
 }
 
 int
+keygen_add_notations(PKT_signature *sig,void *opaque)
+{
+  struct notation *notation;
+
+  /* We always start clean */
+  delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
+  delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
+  sig->flags.notation=0;
+
+  for(notation=opaque;notation;notation=notation->next)
+    if(!notation->flags.ignore)
+      {
+       unsigned char *buf;
+       unsigned int n1,n2;
+
+       n1=strlen(notation->name);
+       if(notation->altvalue)
+         n2=strlen(notation->altvalue);
+       else if(notation->bdat)
+         n2=notation->blen;
+       else
+         n2=strlen(notation->value);
+
+       buf = xmalloc( 8 + n1 + n2 );
+
+       /* human readable or not */
+       buf[0] = notation->bdat?0:0x80;
+       buf[1] = buf[2] = buf[3] = 0;
+       buf[4] = n1 >> 8;
+       buf[5] = n1;
+       buf[6] = n2 >> 8;
+       buf[7] = n2;
+       memcpy(buf+8, notation->name, n1 );
+       if(notation->altvalue)
+         memcpy(buf+8+n1, notation->altvalue, n2 );
+       else if(notation->bdat)
+         memcpy(buf+8+n1, notation->bdat, n2 );
+       else
+         memcpy(buf+8+n1, notation->value, n2 );
+       build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
+                         (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
+                         buf, 8+n1+n2 );
+       xfree(buf);
+      }
+
+  return 0;
+}
+
+int
 keygen_add_revkey(PKT_signature *sig, void *opaque)
 {
   struct revocation_key *revkey=opaque;
@@ -745,26 +760,18 @@ keygen_add_revkey(PKT_signature *sig, void *opaque)
   return 0;
 }
 
-static int
-make_backsig(PKT_signature *sig, PKT_public_key *pk,
-            PKT_public_key *sub_pk, PKT_secret_key *sub_sk)
+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);
+  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) );
+  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. */
@@ -874,7 +881,7 @@ write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
        return rc;
     }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xmalloc_clear( sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
     add_kbnode( root, new_kbnode( pkt ) );
@@ -882,8 +889,8 @@ write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 }
 
 static int
-write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
-               unsigned int use )
+write_selfsigs( KBNODE sec_root, KBNODE pub_root, PKT_secret_key *sk,
+               unsigned int use )
 {
     PACKET *pkt;
     PKT_signature *sig;
@@ -896,7 +903,7 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
        log_info(_("writing self signature\n"));
 
     /* get the uid packet from the list */
-    node = find_kbnode( root, PKT_USER_ID );
+    node = find_kbnode( pub_root, PKT_USER_ID );
     if( !node )
        BUG(); /* no user id packet in tree */
     uid = node->pkt->pkt.user_id;
@@ -918,10 +925,15 @@ write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
        return rc;
     }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xmalloc_clear( sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
-    add_kbnode( root, new_kbnode( pkt ) );
+    add_kbnode( sec_root, new_kbnode( pkt ) );
+
+    pkt = xmalloc_clear( sizeof *pkt );
+    pkt->pkttype = PKT_SIGNATURE;
+    pkt->pkt.signature = copy_signature(NULL,sig);
+    add_kbnode( pub_root, new_kbnode( pkt ) );
     return rc;
 }
 
@@ -977,7 +989,7 @@ write_keybinding( KBNODE root, KBNODE pub_root,
          return rc;
       }
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xmalloc_clear( sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = sig;
     add_kbnode( root, new_kbnode( pkt ) );
@@ -1014,8 +1026,8 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xmalloc_clear( sizeof *sk );
+    pk = xmalloc_clear( sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -1048,14 +1060,14 @@ gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    pkt = xmalloc_clear(sizeof *pkt);
     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 = xmalloc_clear(sizeof *pkt);
     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
@@ -1094,8 +1106,8 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xmalloc_clear( sizeof *sk );
+    pk = xmalloc_clear( sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -1130,7 +1142,7 @@ gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    pkt = xmalloc_clear(sizeof *pkt);
     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
     pkt->pkt.public_key = pk;
     add_kbnode(pub_root, new_kbnode( pkt ));
@@ -1141,7 +1153,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 = xmalloc_clear(sizeof *pkt);
     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
@@ -1182,8 +1194,8 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        return rc;
     }
 
-    sk = m_alloc_clear( sizeof *sk );
-    pk = m_alloc_clear( sizeof *pk );
+    sk = xmalloc_clear( sizeof *sk );
+    pk = xmalloc_clear( sizeof *pk );
     sk->timestamp = pk->timestamp = make_timestamp();
     sk->version = pk->version = 4;
     if( expireval ) {
@@ -1220,12 +1232,12 @@ gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
        }
     }
 
-    pkt = m_alloc_clear(sizeof *pkt);
+    pkt = xmalloc_clear(sizeof *pkt);
     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 = xmalloc_clear(sizeof *pkt);
     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
     pkt->pkt.secret_key = sk;
     add_kbnode(sec_root, new_kbnode( pkt ));
@@ -1268,6 +1280,9 @@ print_key_flags(int flags)
   if(flags&PUBKEY_USAGE_SIG)
     tty_printf("%s ",_("Sign"));
 
+  if(flags&PUBKEY_USAGE_CERT)
+    tty_printf("%s ",_("Certify"));
+
   if(flags&PUBKEY_USAGE_ENC)
     tty_printf("%s ",_("Encrypt"));
 
@@ -1278,7 +1293,7 @@ print_key_flags(int flags)
 
 /* Returns the key flags */
 static unsigned int
-ask_key_flags(int algo)
+ask_key_flags(int algo,int subkey)
 {
   const char *togglers=_("SsEeAaQq");
   char *answer=NULL;
@@ -1288,6 +1303,10 @@ ask_key_flags(int algo)
   if(strlen(togglers)!=8)
     BUG();
 
+  /* Only primary keys may certify. */
+  if(subkey)
+    possible&=~PUBKEY_USAGE_CERT;
+
   /* Preload the current set with the possible set, minus
      authentication, since nobody really uses auth yet. */
   current=possible&~PUBKEY_USAGE_AUTH;
@@ -1316,12 +1335,12 @@ ask_key_flags(int algo)
       tty_printf(_("   (%c) Finished\n"),togglers[6]);
       tty_printf("\n");
 
-      m_free(answer);
+      xfree(answer);
       answer = cpr_get("keygen.flags",_("Your selection? "));
       cpr_kill_prompt();
 
       if(strlen(answer)>1)
-       continue;
+       tty_printf(_("Invalid selection.\n"));
       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
        break;
       else if((*answer==togglers[0] || *answer==togglers[1])
@@ -1348,9 +1367,11 @@ ask_key_flags(int algo)
          else
            current|=PUBKEY_USAGE_AUTH;
        }
+      else
+       tty_printf(_("Invalid selection.\n"));
     }
 
-  m_free(answer);
+  xfree(answer);
 
   return current;
 }
@@ -1385,14 +1406,14 @@ 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;
        }
        else if( algo == 7 && opt.expert ) {
            algo = PUBKEY_ALGO_RSA;
-           *r_usage=ask_key_flags(algo);
+           *r_usage=ask_key_flags(algo,addmode);
            break;
        }
        else if( algo == 6 && addmode ) {
@@ -1412,7 +1433,7 @@ ask_algo (int addmode, unsigned int *r_usage)
        }
        else if( algo == 3 && opt.expert ) {
            algo = PUBKEY_ALGO_DSA;
-           *r_usage=ask_key_flags(algo);
+           *r_usage=ask_key_flags(algo,addmode);
            break;
        }
        else if( algo == 2 ) {
@@ -1467,7 +1488,7 @@ ask_keysize( int algo )
 
 #define PROMPTSTRING _("What keysize do you want? (%u) ")
 
-      prompt=m_alloc(strlen(PROMPTSTRING)+20);
+      prompt=xmalloc(strlen(PROMPTSTRING)+20);
       sprintf(prompt,PROMPTSTRING,def);
 
 #undef PROMPTSTRING
@@ -1475,8 +1496,8 @@ ask_keysize( int algo )
       answer = cpr_get("keygen.size",prompt);
       cpr_kill_prompt();
       nbits = *answer? atoi(answer): def;
-      m_free(prompt);
-      m_free(answer);
+      xfree(prompt);
+      xfree(answer);
       
       if(nbits<min || nbits>max)
        tty_printf(_("%s keysizes must be in the range %u-%u\n"),
@@ -1503,46 +1524,41 @@ ask_keysize( int algo )
 
 
 /****************
- * Parse an expire string and return it's value in days.
- * Returns -1 on error.
+ * Parse an expire string and return its value in seconds.
+ * Returns (u32)-1 on error.
+ * This isn't perfect since scan_isodatestr returns unix time, and
+ * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
+ * Because of this, we only permit setting expirations up to 2106, but
+ * OpenPGP could theoretically allow up to 2242.  I think we'll all
+ * just cope for the next few years until we get a 64-bit time_t or
+ * similar.
  */
-int
+u32
 parse_expire_string( const char *string )
 {
     int mult;
-    u32 abs_date=0;
-    u32 curtime = make_timestamp();
-    int valid_days;
+    u32 seconds,abs_date=0,curtime = make_timestamp();
 
     if( !*string )
-       valid_days = 0;
-    else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
-       /* This calculation is not perfectly okay because we
-        * are later going to simply multiply by 86400 and don't
-        * correct for leapseconds.  A solution would be to change
-        * the whole implemenation to work with dates and not intervals
-        * which are required for v3 keys.
-        */
-       valid_days = abs_date/86400-curtime/86400+1;
-    }
-    else if( (mult=check_valid_days(string)) ) {
-       valid_days = atoi(string) * mult;
-       if( valid_days < 0 || valid_days > 39447 )
-           valid_days = 0;
-    }
-    else {
-       valid_days = -1;
-    }
-    return valid_days;
+      seconds = 0;
+    else if ( !strncmp (string, "seconds=", 8) )
+      seconds = atoi (string+8);
+    else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime )
+      seconds = abs_date - curtime;
+    else if( (mult=check_valid_days(string)) )
+      seconds = atoi(string) * 86400L * mult;
+    else
+      seconds=(u32)-1;
+
+    return seconds;
 }
 
 /* object == 0 for a key, and 1 for a sig */
 u32
 ask_expire_interval(int object,const char *def_expire)
 {
+    u32 interval;
     char *answer;
-    int valid_days=0;
-    u32 interval = 0;
 
     switch(object)
       {
@@ -1581,7 +1597,7 @@ ask_expire_interval(int object,const char *def_expire)
       {
        u32 curtime=make_timestamp();
 
-       m_free(answer);
+       xfree(answer);
        if(object==0)
          answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
        else
@@ -1591,51 +1607,51 @@ ask_expire_interval(int object,const char *def_expire)
 #define PROMPTSTRING _("Signature is valid for? (%s) ")
            /* This will actually end up larger than necessary because
               of the 2 bytes for '%s' */
-           prompt=m_alloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
+           prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
            sprintf(prompt,PROMPTSTRING,def_expire);
 #undef PROMPTSTRING
 
            answer = cpr_get("siggen.valid",prompt);
-           m_free(prompt);
+           xfree(prompt);
 
            if(*answer=='\0')
-             answer=m_strdup(def_expire);
+             answer=xstrdup(def_expire);
          }
        cpr_kill_prompt();
        trim_spaces(answer);
-       valid_days = parse_expire_string( answer );
-       if( valid_days < 0 ) {
-         tty_printf(_("invalid value\n"));
-         continue;
-       }
+       interval = parse_expire_string( answer );
+       if( interval == (u32)-1 )
+         {
+           tty_printf(_("invalid value\n"));
+           continue;
+         }
 
-       if( !valid_days )
+       if( !interval )
          {
             tty_printf((object==0)
                        ? _("Key does not expire at all\n")
                        : _("Signature does not expire at all\n"));
-           interval = 0;
          }
-       else {
-         interval = valid_days * 86400L;
-
-         tty_printf(object==0
-                    ? _("Key expires at %s\n")
-                    : _("Signature expires at %s\n"),
-                    asctimestamp((ulong)(curtime + interval) ) );
-         /* FIXME: This check yields warning on alhas: Write a
-            configure check and to this check here only for 32 bit
-            machines */
-         if( (time_t)((ulong)(curtime+interval)) < 0 )
-           tty_printf(_("Your system can't display dates beyond 2038.\n"
-                        "However, it will be correctly handled up to 2106.\n"));
-       }
+       else
+         {
+           tty_printf(object==0
+                      ? _("Key expires at %s\n")
+                      : _("Signature expires at %s\n"),
+                      asctimestamp((ulong)(curtime + interval) ) );
+           /* FIXME: This check yields warning on alhas: Write a
+              configure check and to this check here only for 32 bit
+              machines */
+           if( (time_t)((ulong)(curtime+interval)) < 0 )
+             tty_printf(_("Your system can't display dates beyond 2038.\n"
+                          "However, it will be correctly handled up to 2106.\n"));
+         }
 
        if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
                                                   _("Is this correct? (y/N) ")) )
          break;
       }
-    m_free(answer);
+
+    xfree(answer);
     return interval;
 }
 
@@ -1646,27 +1662,6 @@ ask_expiredate()
     return x? make_timestamp() + x : 0;
 }
 
-static int
-has_invalid_email_chars( const char *s )
-{
-    int at_seen=0;
-    static char valid_chars[] = "01234567890_-."
-                               "abcdefghijklmnopqrstuvwxyz"
-                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-    for( ; *s; s++ ) {
-       if( *s & 0x80 )
-           return 1;
-       if( *s == '@' )
-           at_seen=1;
-       else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
-           return 1;
-       else if( at_seen && !strchr( valid_chars, *s ) )
-           return 1;
-    }
-    return 0;
-}
-
 
 static char *
 ask_user_id( int mode )
@@ -1687,7 +1682,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();
@@ -1707,26 +1702,21 @@ 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 || opt.allow_freeform_uid )
                    break;   /* no email address is okay */
-               else if( has_invalid_email_chars(amail)
-                        || string_count_chr(amail,'@') != 1
-                        || *amail == '@'
-                        || amail[strlen(amail)-1] == '@'
-                        || amail[strlen(amail)-1] == '.'
-                        || strstr(amail, "..") )
-                   tty_printf(_("Not a valid email address\n"));
+               else if ( !is_valid_mailbox (amail) )
+                    tty_printf(_("Not a valid email address\n"));
                else
                    break;
            }
        }
        if( !acomment ) {
            for(;;) {
-               m_free(acomment);
+               xfree(acomment);
                acomment = cpr_get("keygen.comment",_("Comment: "));
                trim_spaces(acomment);
                cpr_kill_prompt();
@@ -1740,8 +1730,8 @@ 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),")");
@@ -1788,7 +1778,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 {
@@ -1800,15 +1790,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] ) {
@@ -1816,29 +1806,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;
@@ -1855,7 +1845,7 @@ do_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 = S2K_DIGEST_ALGO;
@@ -1866,8 +1856,8 @@ do_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"
@@ -1926,7 +1916,7 @@ generate_user_id()
     if( !p )
        return NULL;
     n = strlen(p);
-    uid = m_alloc_clear( sizeof *uid + n - 1 );
+    uid = xmalloc_clear( sizeof *uid + n - 1 );
     uid->len = n;
     strcpy(uid->name, p);
     uid->ref = 1;
@@ -1942,11 +1932,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);
     }
 }
 
@@ -2014,7 +2004,7 @@ parse_parameter_usage (const char *fname,
         }
     }
     r->u.usage = use;
-    return 0;
+    return 1;
 }
 
 static int
@@ -2117,118 +2107,166 @@ static int
 proc_parameter_file( struct para_data_s *para, const char *fname,
                      struct output_control_s *outctrl, int card )
 {
-    struct para_data_s *r;
-    const char *s1, *s2, *s3;
-    size_t n;
-    char *p;
-    int i;
+  struct para_data_s *r;
+  const char *s1, *s2, *s3;
+  size_t n;
+  char *p;
+  int have_user_id=0,err,algo;
 
-    /* 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 ) ) {
-       r = get_parameter( para, pKEYTYPE );
-       log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
-       return -1;
+  /* Check that we have all required parameters. */
+  r = get_parameter( para, pKEYTYPE );
+  if(r)
+    {
+      algo=get_parameter_algo(para,pKEYTYPE);
+      if(check_pubkey_algo2(algo,PUBKEY_USAGE_SIG))
+       {
+         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
+         return -1;
+       }
+    }
+  else
+    {
+      log_error("%s: no Key-Type specified\n",fname);
+      return -1;
     }
 
-    if (parse_parameter_usage (fname, para, pKEYUSAGE))
-        return -1;
+  err=parse_parameter_usage (fname, para, pKEYUSAGE);
+  if(err==0)
+    {
+      /* Default to algo capabilities if key-usage is not provided */
+      r=xmalloc_clear(sizeof(*r));
+      r->key=pKEYUSAGE;
+      r->u.usage=openpgp_pk_algo_usage(algo);
+      r->next=para;
+      para=r;
+    }
+  else if(err==-1)
+    return -1;
+
+  r = get_parameter( para, pSUBKEYTYPE );
+  if(r)
+    {
+      algo=get_parameter_algo( para, pSUBKEYTYPE);
+      if(check_pubkey_algo(algo))
+       {
+         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
+         return -1;
+       }
 
-    i = get_parameter_algo( para, pSUBKEYTYPE );
-    if( i > 0 && check_pubkey_algo( i ) ) {
-       r = get_parameter( para, pSUBKEYTYPE );
-       log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
+      err=parse_parameter_usage (fname, para, pSUBKEYUSAGE);
+      if(err==0)
+       {
+         /* Default to algo capabilities if subkey-usage is not
+            provided */
+         r=xmalloc_clear(sizeof(*r));
+         r->key=pSUBKEYUSAGE;
+         r->u.usage=openpgp_pk_algo_usage(algo);
+         r->next=para;
+         para=r;
+       }
+      else if(err==-1)
        return -1;
     }
-    if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
-        return -1;
-
 
-    if( !get_parameter_value( para, pUSERID ) ) {
-       /* create the formatted user ID */
-       s1 = get_parameter_value( para, pNAMEREAL );
-       s2 = get_parameter_value( para, pNAMECOMMENT );
-       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->key = pUSERID;
-           p = r->u.value;
-           if( s1 )
-               p = stpcpy(p, s1 );
-           if( s2 )
-               p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
-           if( s3 )
-               p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
-           r->next = para;
-           para = r;
+  if( get_parameter_value( para, pUSERID ) )
+    have_user_id=1;
+  else
+    {
+      /* create the formatted user ID */
+      s1 = get_parameter_value( para, pNAMEREAL );
+      s2 = get_parameter_value( para, pNAMECOMMENT );
+      s3 = get_parameter_value( para, pNAMEEMAIL );
+      if( s1 || s2 || s3 )
+       {
+         n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
+         r = xmalloc_clear( sizeof *r + n + 20 );
+         r->key = pUSERID;
+         p = r->u.value;
+         if( s1 )
+           p = stpcpy(p, s1 );
+         if( s2 )
+           p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
+         if( s3 )
+           p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
+         r->next = para;
+         para = r;
+         have_user_id=1;
        }
     }
 
-    /* Set preferences, if any. */
-    keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
-
-    /* Set revoker, if any. */
-    if (parse_revocation_key (fname, para, pREVOKER))
+  if(!have_user_id)
+    {
+      log_error("%s: no User-ID specified\n",fname);
       return -1;
+    }
 
-    /* make DEK and S2K from the Passphrase */
-    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 */
-       STRING2KEY *s2k;
-       DEK *dek;
+  /* Set preferences, if any. */
+  keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
 
-       s2k = m_alloc_secure( sizeof *s2k );
-       s2k->mode = opt.s2k_mode;
-       s2k->hash_algo = S2K_DIGEST_ALGO;
-       set_next_passphrase( r->u.value );
-       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) );
-
-       r = m_alloc_clear( sizeof *r );
-       r->key = pPASSPHRASE_S2K;
-       r->u.s2k = s2k;
-       r->next = para;
-       para = r;
-       r = m_alloc_clear( sizeof *r );
-       r->key = pPASSPHRASE_DEK;
-       r->u.dek = dek;
-       r->next = para;
-       para = r;
-    }
+  /* Set revoker, if any. */
+  if (parse_revocation_key (fname, para, pREVOKER))
+    return -1;
+
+  /* make DEK and S2K from the Passphrase */
+  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 */
+    STRING2KEY *s2k;
+    DEK *dek;
+
+    s2k = xmalloc_secure( sizeof *s2k );
+    s2k->mode = opt.s2k_mode;
+    s2k->hash_algo = S2K_DIGEST_ALGO;
+    set_next_passphrase( r->u.value );
+    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) );
+
+    r = xmalloc_clear( sizeof *r );
+    r->key = pPASSPHRASE_S2K;
+    r->u.s2k = s2k;
+    r->next = para;
+    para = r;
+    r = xmalloc_clear( sizeof *r );
+    r->key = pPASSPHRASE_DEK;
+    r->u.dek = dek;
+    r->next = para;
+    para = r;
+  }
+
+  /* make KEYEXPIRE from Expire-Date */
+  r = get_parameter( para, pEXPIREDATE );
+  if( r && *r->u.value )
+    {
+      u32 seconds;
 
-    /* make KEYEXPIRE from Expire-Date */
-    r = get_parameter( para, pEXPIREDATE );
-    if( r && *r->u.value ) {
-       i = parse_expire_string( r->u.value );
-       if( i < 0 ) {
-           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
-           return -1;
+      seconds = parse_expire_string( r->u.value );
+      if( seconds == (u32)-1 )
+       {
+         log_error("%s:%d: invalid expire date\n", fname, r->lnr );
+         return -1;
        }
-       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->key = pSUBKEYEXPIRE;
-       r->u.expire = i * 86400L;
-       r->next = para;
-       para = r;
+      r->u.expire = seconds;
+      r->key = pKEYEXPIRE;  /* change hat entry */
+      /* also set it for the subkey */
+      r = xmalloc_clear( sizeof *r + 20 );
+      r->key = pSUBKEYEXPIRE;
+      r->u.expire = seconds;
+      r->next = para;
+      para = r;
     }
 
-    if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
-       log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
-       return -1;
-    }
+  if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
+    log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
+    return -1;
+  }
 
-    do_generate_keypair( para, outctrl, card );
-    return 0;
+  do_generate_keypair( para, outctrl, card );
+  return 0;
 }
 
 
@@ -2330,8 +2368,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;
                }
            }
@@ -2339,8 +2377,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;
                }
            }
@@ -2398,7 +2436,7 @@ read_parameter_file( const char *fname )
                break;
            }
        }
-       r = m_alloc_clear( sizeof *r + strlen( value ) );
+       r = xmalloc_clear( sizeof *r + strlen( value ) );
        r->lnr = lnr;
        r->key = keywords[i].key;
        strcpy( r->u.value, value );
@@ -2426,10 +2464,10 @@ read_parameter_file( const char *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 );
-       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 );
@@ -2531,30 +2569,30 @@ generate_keypair (const char *fname, const char *card_serialno,
       if( !algo )
         { /* default: DSA with ElG subkey of the specified size */
           both = 1;
-          r = m_alloc_clear( sizeof *r + 20 );
+          r = xmalloc_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 %u bits.\n"),1024);
-          r = m_alloc_clear( sizeof *r + 20 );
+          r = xmalloc_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 = xmalloc_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 = xmalloc_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 = xmalloc_clear( sizeof *r + 20 );
           r->key = pSUBKEYUSAGE;
           strcpy( r->u.value, "encrypt" );
           r->next = para;
@@ -2562,7 +2600,7 @@ generate_keypair (const char *fname, const char *card_serialno,
         }
       else 
         {
-          r = m_alloc_clear( sizeof *r + 20 );
+          r = xmalloc_clear( sizeof *r + 20 );
           r->key = pKEYTYPE;
           sprintf( r->u.value, "%d", algo );
           r->next = para;
@@ -2570,7 +2608,7 @@ generate_keypair (const char *fname, const char *card_serialno,
            
           if (use)
             {
-              r = m_alloc_clear( sizeof *r + 25 );
+              r = xmalloc_clear( sizeof *r + 25 );
               r->key = pKEYUSAGE;
               sprintf( r->u.value, "%s%s%s",
                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
@@ -2583,7 +2621,7 @@ generate_keypair (const char *fname, const char *card_serialno,
         }
        
       nbits = ask_keysize( algo );
-      r = m_alloc_clear( sizeof *r + 20 );
+      r = xmalloc_clear( sizeof *r + 20 );
       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
       sprintf( r->u.value, "%u", nbits);
       r->next = para;
@@ -2591,12 +2629,12 @@ generate_keypair (const char *fname, const char *card_serialno,
     }
    
   expire = ask_expire_interval(0,NULL);
-  r = m_alloc_clear( sizeof *r + 20 );
+  r = xmalloc_clear( sizeof *r + 20 );
   r->key = pKEYEXPIRE;
   r->u.expire = expire;
   r->next = para;
   para = r;
-  r = m_alloc_clear( sizeof *r + 20 );
+  r = xmalloc_clear( sizeof *r + 20 );
   r->key = pSUBKEYEXPIRE;
   r->u.expire = expire;
   r->next = para;
@@ -2609,7 +2647,7 @@ generate_keypair (const char *fname, const char *card_serialno,
       release_parameter_list( para );
       return;
     }
-  r = m_alloc_clear( sizeof *r + strlen(uid) );
+  r = xmalloc_clear( sizeof *r + strlen(uid) );
   r->key = pUSERID;
   strcpy( r->u.value, uid );
   r->next = para;
@@ -2618,12 +2656,12 @@ generate_keypair (const char *fname, const char *card_serialno,
   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
   if( dek )
     {
-      r = m_alloc_clear( sizeof *r );
+      r = xmalloc_clear( sizeof *r );
       r->key = pPASSPHRASE_DEK;
       r->u.dek = dek;
       r->next = para;
       para = r;
-      r = m_alloc_clear( sizeof *r );
+      r = xmalloc_clear( sizeof *r );
       r->key = pPASSPHRASE_S2K;
       r->u.s2k = s2k;
       r->next = para;
@@ -2670,7 +2708,7 @@ generate_raw_key (int algo, unsigned int nbits, u32 created_at,
 
   dek = do_ask_passphrase (&s2k);
 
-  sk = m_alloc_clear (sizeof *sk);
+  sk = xmalloc_clear (sizeof *sk);
   sk->timestamp = created_at;
   sk->version = 4;
   sk->pubkey_algo = algo;
@@ -2708,8 +2746,8 @@ generate_raw_key (int algo, unsigned int nbits, u32 created_at,
  leave:
   if (sk)
     free_secret_key (sk);
-  m_free (dek);
-  m_free (s2k);
+  xfree (dek);
+  xfree (s2k);
   return rc;
 }
 #endif /* ENABLE_CARD_SUPPORT */
@@ -2720,7 +2758,7 @@ start_tree(KBNODE *tree)
 {
   PACKET *pkt;
 
-  pkt=m_alloc_clear(sizeof(*pkt));
+  pkt=xmalloc_clear(sizeof(*pkt));
   pkt->pkttype=PKT_NONE;
   *tree=new_kbnode(pkt);
   delete_kbnode(*tree);
@@ -2750,7 +2788,7 @@ do_generate_keypair( struct para_data_s *para,
            outctrl->pub.stream = NULL;
             if (outctrl->pub.fname)
               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
-           m_free( outctrl->pub.fname );
+           xfree( outctrl->pub.fname );
            outctrl->pub.fname =  outctrl->pub.newfname;
            outctrl->pub.newfname = NULL;
 
@@ -2778,7 +2816,7 @@ do_generate_keypair( struct para_data_s *para,
            outctrl->sec.stream = NULL;
             if (outctrl->sec.fname)
               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
-           m_free( outctrl->sec.fname );
+           xfree( outctrl->sec.fname );
            outctrl->sec.fname =  outctrl->sec.newfname;
            outctrl->sec.newfname = NULL;
 
@@ -2851,17 +2889,16 @@ do_generate_keypair( struct para_data_s *para,
          write_direct_sig(sec_root,pub_root,pri_sk,revkey);
       }
 
-    if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
+    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, pri_sk,
-                               get_parameter_uint (para, pKEYUSAGE));
+         write_uid(sec_root, s );
+
        if( !rc )
-           rc = write_selfsig(sec_root, pub_root, pri_sk,
-                               get_parameter_uint (para, pKEYUSAGE));
-    }
+         rc = write_selfsigs(sec_root, pub_root, pri_sk,
+                             get_parameter_uint (para, pKEYUSAGE));
+      }
 
     /* Write the auth key to the card before the encryption key.  This
        is a partial workaround for a PGP bug (as of this writing, all
@@ -3123,7 +3160,7 @@ generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
     if (ask_pass)
         dek = do_ask_passphrase (&s2k);
     else if (passphrase) {
-       s2k = m_alloc_secure( sizeof *s2k );
+       s2k = xmalloc_secure( sizeof *s2k );
        s2k->mode = opt.s2k_mode;
        s2k->hash_algo = S2K_DIGEST_ALGO;
        set_next_passphrase( passphrase );
@@ -3145,9 +3182,9 @@ 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 );
+    xfree( passphrase );
+    xfree( dek );
+    xfree( s2k );
     /* release the copy of the (now unprotected) secret keys */
     if( pri_sk )
        free_secret_key(pri_sk);
@@ -3260,7 +3297,7 @@ generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
  leave:
   if (rc)
     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
-  m_free (passphrase);
+  xfree (passphrase);
   /* Release the copy of the (now unprotected) secret keys. */
   if (pri_sk)
     free_secret_key (pri_sk);
@@ -3277,15 +3314,21 @@ generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
 static int
 write_keyblock( IOBUF 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",
+  for( ; node ; node = node->next )
+    {
+      if(!is_deleted_kbnode(node))
+       {
+         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;
+             return G10ERR_WRITE_FILE;
+           }
        }
     }
-    return 0;
+
+  return 0;
 }
 
 
@@ -3304,8 +3347,8 @@ gen_card_key (int algo, int keyno, int is_primary,
 
   assert (algo == PUBKEY_ALGO_RSA);
   
-
-  rc = agent_scd_genkey (&info, keyno, 1);
+  /* Fixme: We don't have the serialnumber available, thus passing NULL. */
+  rc = agent_scd_genkey (&info, keyno, 1, NULL);
 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
 /*      { */
 /*        tty_printf ("\n"); */
@@ -3443,7 +3486,7 @@ gen_card_key_with_backup (int algo, int keyno, int is_primary,
       {
        log_error (_("can't create backup file `%s': %s\n"),
                    fname, strerror(errno) );
-        m_free (fname);
+        xfree (fname);
         free_secret_key (sk_unprotected);
         free_secret_key (sk_protected);
         return G10ERR_OPEN_FILE;
@@ -3483,8 +3526,8 @@ gen_card_key_with_backup (int algo, int keyno, int is_primary,
         xfree (fprbuf);
       }
     free_packet (pkt);
-    m_free (pkt);
-    m_free (fname);
+    xfree (pkt);
+    xfree (fname);
     if (rc)
       {
         free_secret_key (sk_unprotected);
@@ -3526,104 +3569,70 @@ int
 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
 {
   int rc;
-  size_t n;
-  MPI rsa_n, rsa_e, rsa_p, rsa_q;
-  unsigned int nbits;
-  unsigned char *template = NULL;
-  unsigned char *tp;
-  unsigned char m[128], e[4];
-  size_t mlen, elen;
+  unsigned char *rsa_n = NULL;
+  unsigned char *rsa_e = NULL;
+  unsigned char *rsa_p = NULL;
+  unsigned char *rsa_q = NULL;
+  unsigned int rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
+  unsigned char *sexp = NULL;
+  unsigned char *p;
+  char numbuf[55], numbuf2[50];
 
   assert (is_RSA (sk->pubkey_algo));
   assert (!sk->is_protected);
 
-  rc = -1;
-  /* Some basic checks on the key parameters. */
-  rsa_n = sk->skey[0];
-  rsa_e = sk->skey[1];
-  rsa_p = sk->skey[3];
-  rsa_q = sk->skey[4];
-
-  nbits = GET_NBITS (rsa_n);
-  if (nbits != 1024)
-    {
-      log_error (_("length of RSA modulus is not %d\n"), 1024);
-      goto leave;
-    }
-  nbits = GET_NBITS (rsa_e);
-  if (nbits < 2 || nbits > 32)
+  /* Copy the parameters into straight buffers. */
+  rsa_n = mpi_get_secure_buffer (sk->skey[0], &rsa_n_len, NULL);
+  rsa_e = mpi_get_secure_buffer (sk->skey[1], &rsa_e_len, NULL);
+  rsa_p = mpi_get_secure_buffer (sk->skey[3], &rsa_p_len, NULL);
+  rsa_q = mpi_get_secure_buffer (sk->skey[4], &rsa_q_len, NULL);
+  if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
     {
-      log_error (_("public exponent too large (more than 32 bits)\n"));
-      goto leave;
-    }
-  nbits = GET_NBITS (rsa_p);
-  if (nbits != 512)
-    {
-      log_error (_("length of an RSA prime is not %d\n"), 512);
-      goto leave;
-    }
-  nbits = GET_NBITS (rsa_q);
-  if (nbits != 512)
-    {
-      log_error (_("length of an RSA prime is not %d\n"), 512);
+      rc = G10ERR_INV_ARG;
       goto leave;
     }
 
-  
-  /* We need the modulus later to calculate the fingerprint. */
-  rc = copy_mpi (rsa_n, m, 128, &n);
-  if (rc)
-    goto leave;
-  assert (n == 128);
-  mlen = 128;
-
-  /* Build the private key template as described in section 4.3.3.6 of
-     the OpenPGP card specs:
-         0xC0   <length> public exponent
-         0xC1   <length> prime p 
-         0xC2   <length> prime q 
-  */
-  template = tp = xmalloc_secure (1+2 + 1+1+4 + 1+1+(512/8) + 1+1+(512/8));
-  *tp++ = 0xC0;
-  *tp++ = 4;
-  rc = copy_mpi (rsa_e, tp, 4, &n);
-  if (rc)
-    goto leave;
-  assert (n <= 4);
-  memcpy (e, tp, n);  /* Save a copy of the exponent for later use.  */
-  elen = n;
-  if (n != 4)
-    {
-      memmove (tp+4-n, tp, 4-n);
-      memset (tp, 0, 4-n);
-    }                 
-  tp += 4;
-
-  *tp++ = 0xC1;
-  *tp++ = 64;
-  rc = copy_mpi (rsa_p, tp, 64, &n);
-  if (rc)
-    goto leave;
-  assert (n == 64);
-  tp += 64;
+  /* Put the key into an S-expression. */
+  sexp = p = xmalloc_secure (30
+                             + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
+                             + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
 
-  *tp++ = 0xC2;
-  *tp++ = 64;
-  rc = copy_mpi (rsa_q, tp, 64, &n);
-  if (rc)
-    goto leave;
-  assert (n == 64);
-  tp += 64;
-  assert (tp - template == 138);
+  p = stpcpy (p,"(11:private-key(3:rsa(1:n");
+  sprintf (numbuf, "%u:", rsa_n_len);
+  p = stpcpy (p, numbuf);
+  memcpy (p, rsa_n, rsa_n_len);
+  p += rsa_n_len;
+
+  sprintf (numbuf, ")(1:e%u:", rsa_e_len);
+  p = stpcpy (p, numbuf);
+  memcpy (p, rsa_e, rsa_e_len);
+  p += rsa_e_len;
+
+  sprintf (numbuf, ")(1:p%u:", rsa_p_len);
+  p = stpcpy (p, numbuf);
+  memcpy (p, rsa_p, rsa_p_len);
+  p += rsa_p_len;
+
+  sprintf (numbuf, ")(1:q%u:", rsa_q_len);
+  p = stpcpy (p, numbuf);
+  memcpy (p, rsa_q, rsa_q_len);
+  p += rsa_q_len;
+
+  p = stpcpy (p,"))(10:created-at");
+  sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
+  sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
+  p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
 
-  rc = agent_openpgp_storekey (keyno,
-                               template, tp - template,
-                               sk->timestamp,
-                               m, mlen,
-                               e, elen);
+  /* Fixme: Unfortunately we don't have the serialnumber available -
+     thus we can't pass it down to the agent. */ 
+  rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
 
  leave:
-  xfree (template);
+  xfree (sexp);
+  xfree (rsa_n);
+  xfree (rsa_e);
+  xfree (rsa_p);
+  xfree (rsa_q);
   return rc;
 }
 #endif /*ENABLE_CARD_SUPPORT*/