g10/keygen.c

   1 /* keygen.c - generate a key pair
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26 #include <errno.h>
  27 #include <assert.h>
  28 #include "util.h"
  29 #include "main.h"
  30 #include "packet.h"
  31 #include "cipher.h"
  32 #include "ttyio.h"
  33 #include "options.h"
  34 #include "keydb.h"
  35 #include "trustdb.h"
  36 #include "status.h"
  37 #include "i18n.h"
  38
  39 #define MAX_PREFS 30
  40
  41
  42 enum para_name {
  43   pKEYTYPE,
  44   pKEYLENGTH,
  45   pKEYUSAGE,
  46   pSUBKEYTYPE,
  47   pSUBKEYLENGTH,
  48   pSUBKEYUSAGE,
  49   pNAMEREAL,
  50   pNAMEEMAIL,
  51   pNAMECOMMENT,
  52   pPREFERENCES,
  53   pREVOKER,
  54   pUSERID,
  55   pEXPIREDATE,
  56   pKEYEXPIRE, /* in n seconds */
  57   pSUBKEYEXPIRE, /* in n seconds */
  58   pPASSPHRASE,
  59   pPASSPHRASE_DEK,
  60   pPASSPHRASE_S2K
  61 };
  62
  63 struct para_data_s {
  64     struct para_data_s *next;
  65     int lnr;
  66     enum para_name key;
  67     union {
  68         DEK *dek;
  69         STRING2KEY *s2k;
  70         u32 expire;
  71         unsigned int usage;
  72         struct revocation_key revkey;
  73         char value[1];
  74     } u;
  75 };
  76
  77 struct output_control_s {
  78     int lnr;
  79     int dryrun;
  80     int use_files;
  81     struct {
  82         char  *fname;
  83         char  *newfname;
  84         IOBUF stream;
  85         armor_filter_context_t afx;
  86     } pub;
  87     struct {
  88         char  *fname;
  89         char  *newfname;
  90         IOBUF stream;
  91         armor_filter_context_t afx;
  92     } sec;
  93 };
  94
  95
  96 struct opaque_data_usage_and_pk {
  97     unsigned int usage;
  98     PKT_public_key *pk;
  99 };
 100
 101
 102 static int prefs_initialized = 0;
 103 static byte sym_prefs[MAX_PREFS];
 104 static int nsym_prefs;
 105 static byte hash_prefs[MAX_PREFS];
 106 static int nhash_prefs;
 107 static byte zip_prefs[MAX_PREFS];
 108 static int nzip_prefs;
 109 static int mdc_available;
 110
 111 static void do_generate_keypair( struct para_data_s *para,
 112                                  struct output_control_s *outctrl );
 113 static int  write_keyblock( IOBUF out, KBNODE node );
 114
 115
 116 static void
 117 write_uid( KBNODE root, const char *s )
 118 {
 119     PACKET *pkt = m_alloc_clear(sizeof *pkt );
 120     size_t n = strlen(s);
 121
 122     pkt->pkttype = PKT_USER_ID;
 123     pkt->pkt.user_id = m_alloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
 124     pkt->pkt.user_id->len = n;
 125     pkt->pkt.user_id->ref = 1;
 126     strcpy(pkt->pkt.user_id->name, s);
 127     add_kbnode( root, new_kbnode( pkt ) );
 128 }
 129
 130 static void
 131 do_add_key_flags (PKT_signature *sig, unsigned int use)
 132 {
 133     byte buf[1];
 134
 135     if (!use)
 136         return;
 137
 138     buf[0] = 0;
 139     if (use & PUBKEY_USAGE_SIG)
 140         buf[0] |= 0x01 | 0x02;
 141     if (use & PUBKEY_USAGE_ENC)
 142         buf[0] |= 0x04 | 0x08;
 143     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
 144 }
 145
 146
 147 int
 148 keygen_add_key_expire( PKT_signature *sig, void *opaque )
 149 {
 150     PKT_public_key *pk = opaque;
 151     byte buf[8];
 152     u32  u;
 153
 154     if( pk->expiredate ) {
 155         if(pk->expiredate > pk->timestamp)
 156           u= pk->expiredate - pk->timestamp;
 157         else
 158           u= 0;
 159
 160         buf[0] = (u >> 24) & 0xff;
 161         buf[1] = (u >> 16) & 0xff;
 162         buf[2] = (u >>  8) & 0xff;
 163         buf[3] = u & 0xff;
 164         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
 165     }
 166     else
 167       {
 168         /* Make sure we don't leave a key expiration subpacket lying
 169            around */
 170         delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
 171       }
 172
 173     return 0;
 174 }
 175
 176 static int
 177 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
 178 {
 179     struct opaque_data_usage_and_pk *oduap = opaque;
 180
 181     do_add_key_flags (sig, oduap->usage);
 182     return keygen_add_key_expire (sig, oduap->pk);
 183 }
 184
 185 static int
 186 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
 187 {
 188     int i;
 189
 190     for (i=0; i < *nbuf; i++ )
 191       if (buf[i] == val)
 192         {
 193           log_info (_("preference `%s' duplicated\n"), item);
 194           return -1;
 195         }
 196
 197     if (*nbuf >= MAX_PREFS)
 198       {
 199         if(type==1)
 200           log_info(_("too many cipher preferences\n"));
 201         else if(type==2)
 202           log_info(_("too many digest preferences\n"));
 203         else if(type==3)
 204           log_info(_("too many compression preferences\n"));
 205         else
 206           BUG();
 207
 208         return -1;
 209       }
 210
 211     buf[(*nbuf)++] = val;
 212     return 0;
 213 }
 214
 215 /*
 216  * Parse the supplied string and use it to set the standard
 217  * preferences.  The string may be in a form like the one printed by
 218  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
 219  * cipher/hash/compress names.  Use NULL to set the default
 220  * preferences.  Returns: 0 = okay
 221  */
 222 int
 223 keygen_set_std_prefs (const char *string,int personal)
 224 {
 225     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
 226     int  nsym=0, nhash=0, nzip=0, mdc=1; /* mdc defaults on */
 227     int val,rc = 0;
 228
 229     if (!string || !ascii_strcasecmp (string, "default")) {
 230       if (opt.def_preference_list)
 231         string=opt.def_preference_list;
 232       else if ( !check_cipher_algo(CIPHER_ALGO_IDEA) )
 233         string = "S7 S3 S2 S1 H2 H3 Z2 Z1";
 234       else
 235         string = "S7 S3 S2 H2 H3 Z2 Z1";
 236
 237       /* If we have it, IDEA goes *after* 3DES so it won't be used
 238          unless we're encrypting along with a V3 key.  Ideally, we
 239          would only put the S1 preference in if the key was RSA and
 240          <=2048 bits, as that is what won't break PGP2, but that is
 241          difficult with the current code, and not really worth
 242          checking as a non-RSA <=2048 bit key wouldn't be usable by
 243          PGP2 anyway -dms */
 244     }
 245     else if (!ascii_strcasecmp (string, "none"))
 246         string = "";
 247
 248     if(strlen(string))
 249       {
 250         char *tok,*prefstring;
 251
 252         prefstring=m_strdup(string); /* need a writable string! */
 253
 254         while((tok=strsep(&prefstring," ,")))
 255           {
 256             if((val=string_to_cipher_algo(tok)))
 257               {
 258                 if(set_one_pref(val,1,tok,sym,&nsym))
 259                   rc=-1;
 260               }
 261             else if((val=string_to_digest_algo(tok)))
 262               {
 263                 if(set_one_pref(val,2,tok,hash,&nhash))
 264                   rc=-1;
 265               }
 266             else if((val=string_to_compress_algo(tok))>-1)
 267               {
 268                 if(set_one_pref(val,3,tok,zip,&nzip))
 269                   rc=-1;
 270               }
 271             else if (ascii_strcasecmp(tok,"mdc")==0)
 272               mdc=1;
 273             else if (ascii_strcasecmp(tok,"no-mdc")==0)
 274               mdc=0;
 275             else
 276               {
 277                 log_info (_("invalid item `%s' in preference string\n"),tok);
 278                 rc=-1;
 279               }
 280           }
 281
 282         m_free(prefstring);
 283       }
 284
 285     if(!rc)
 286       {
 287         if(personal)
 288           {
 289             if(personal==PREFTYPE_SYM)
 290               {
 291                 m_free(opt.personal_cipher_prefs);
 292
 293                 if(nsym==0)
 294                   opt.personal_cipher_prefs=NULL;
 295                 else
 296                   {
 297                     int i;
 298
 299                     opt.personal_cipher_prefs=
 300                       m_alloc(sizeof(prefitem_t *)*(nsym+1));
 301
 302                     for (i=0; i<nsym; i++)
 303                       {
 304                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
 305                         opt.personal_cipher_prefs[i].value = sym[i];
 306                       }
 307
 308                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
 309                     opt.personal_cipher_prefs[i].value = 0;
 310                   }
 311               }
 312             else if(personal==PREFTYPE_HASH)
 313               {
 314                 m_free(opt.personal_digest_prefs);
 315
 316                 if(nhash==0)
 317                   opt.personal_digest_prefs=NULL;
 318                 else
 319                   {
 320                     int i;
 321
 322                     opt.personal_digest_prefs=
 323                       m_alloc(sizeof(prefitem_t *)*(nhash+1));
 324
 325                     for (i=0; i<nhash; i++)
 326                       {
 327                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
 328                         opt.personal_digest_prefs[i].value = hash[i];
 329                       }
 330
 331                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
 332                     opt.personal_digest_prefs[i].value = 0;
 333                   }
 334               }
 335             else if(personal==PREFTYPE_ZIP)
 336               {
 337                 m_free(opt.personal_compress_prefs);
 338
 339                 if(nzip==0)
 340                   opt.personal_compress_prefs=NULL;
 341                 else
 342                   {
 343                     int i;
 344
 345                     opt.personal_compress_prefs=
 346                       m_alloc(sizeof(prefitem_t *)*(nzip+1));
 347
 348                     for (i=0; i<nzip; i++)
 349                       {
 350                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
 351                         opt.personal_compress_prefs[i].value = zip[i];
 352                       }
 353
 354                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
 355                     opt.personal_compress_prefs[i].value = 0;
 356                   }
 357               }
 358           }
 359         else
 360           {
 361             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
 362             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
 363             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
 364             mdc_available = mdc;
 365             prefs_initialized = 1;
 366           }
 367       }
 368
 369     return rc;
 370 }
 371
 372 /* Return a fake user ID containing the preferences.  Caller must
 373    free. */
 374 PKT_user_id *keygen_get_std_prefs(void)
 375 {
 376   int i,j=0;
 377   PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
 378
 379   if(!prefs_initialized)
 380     keygen_set_std_prefs(NULL,0);
 381
 382   uid->prefs=m_alloc((sizeof(prefitem_t *)*
 383                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
 384
 385   for(i=0;i<nsym_prefs;i++,j++)
 386     {
 387       uid->prefs[j].type=PREFTYPE_SYM;
 388       uid->prefs[j].value=sym_prefs[i];
 389     }
 390
 391   for(i=0;i<nhash_prefs;i++,j++)
 392     {
 393       uid->prefs[j].type=PREFTYPE_HASH;
 394       uid->prefs[j].value=hash_prefs[i];
 395     }
 396
 397   for(i=0;i<nzip_prefs;i++,j++)
 398     {
 399       uid->prefs[j].type=PREFTYPE_ZIP;
 400       uid->prefs[j].value=zip_prefs[i];
 401     }
 402
 403   uid->prefs[j].type=PREFTYPE_NONE;
 404   uid->prefs[j].value=0;
 405
 406   uid->mdc_feature=mdc_available;
 407
 408   return uid;
 409 }
 410
 411 static void
 412 add_feature_mdc (PKT_signature *sig,int enabled)
 413 {
 414     const byte *s;
 415     size_t n;
 416     int i;
 417     char *buf;
 418
 419     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
 420     /* Already set or cleared */
 421     if (s && n &&
 422         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
 423       return;
 424
 425     if (!s || !n) { /* create a new one */
 426         n = 1;
 427         buf = m_alloc_clear (n);
 428     }
 429     else {
 430         buf = m_alloc (n);
 431         memcpy (buf, s, n);
 432     }
 433
 434     if(enabled)
 435       buf[0] |= 0x01; /* MDC feature */
 436     else
 437       buf[0] &= ~0x01;
 438
 439     /* Are there any bits set? */
 440     for(i=0;i<n;i++)
 441       if(buf[i]!=0)
 442         break;
 443
 444     if(i==n)
 445       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
 446     else
 447       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 448
 449     m_free (buf);
 450 }
 451
 452 int
 453 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
 454 {
 455     if (!prefs_initialized)
 456         keygen_set_std_prefs (NULL, 0);
 457
 458     if (nsym_prefs)
 459         build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
 460     else
 461       {
 462         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
 463         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
 464       }
 465
 466     if (nhash_prefs)
 467         build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
 468     else
 469       {
 470         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
 471         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
 472       }
 473
 474     if (nzip_prefs)
 475         build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
 476     else
 477       {
 478         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
 479         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
 480       }
 481
 482     /* Make sure that the MDC feature flag is set if needed */
 483     add_feature_mdc (sig,mdc_available);
 484
 485     return 0;
 486 }
 487
 488
 489 /****************
 490  * Add preference to the self signature packet.
 491  * This is only called for packets with version > 3.
 492
 493  */
 494 int
 495 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
 496 {
 497     PKT_public_key *pk = opaque;
 498     byte buf[8];
 499
 500     do_add_key_flags (sig, pk->pubkey_usage);
 501     keygen_add_key_expire( sig, opaque );
 502     keygen_upd_std_prefs (sig, opaque);
 503
 504     buf[0] = 0x80; /* no modify - It is reasonable that a key holder
 505                     * has the possibility to reject signatures from users
 506                     * who are known to sign everything without any
 507                     * validation - so a signed key should be send
 508                     * to the holder who in turn can put it on a keyserver
 509                     */
 510     build_sig_subpkt( sig, SIGSUBPKT_KS_FLAGS, buf, 1 );
 511
 512     return 0;
 513 }
 514
 515 int
 516 keygen_add_revkey(PKT_signature *sig, void *opaque)
 517 {
 518   struct revocation_key *revkey=opaque;
 519   byte buf[2+MAX_FINGERPRINT_LEN];
 520
 521   buf[0]=revkey->class;
 522   buf[1]=revkey->algid;
 523   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
 524
 525   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
 526
 527   /* All sigs with revocation keys set are nonrevocable */
 528   sig->flags.revocable=0;
 529   buf[0] = 0;
 530   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
 531
 532   parse_revkeys(sig);
 533
 534   return 0;
 535 }
 536
 537 static int
 538 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 539                   struct revocation_key *revkey )
 540 {
 541     PACKET *pkt;
 542     PKT_signature *sig;
 543     int rc=0;
 544     KBNODE node;
 545     PKT_public_key *pk;
 546
 547     if( opt.verbose )
 548         log_info(_("writing direct signature\n"));
 549
 550     /* get the pk packet from the pub_tree */
 551     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
 552     if( !node )
 553         BUG();
 554     pk = node->pkt->pkt.public_key;
 555
 556     /* we have to cache the key, so that the verification of the signature
 557      * creation is able to retrieve the public key */
 558     cache_public_key (pk);
 559
 560     /* and make the signature */
 561     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
 562                             keygen_add_revkey,revkey);
 563     if( rc ) {
 564         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
 565         return rc;
 566     }
 567
 568     pkt = m_alloc_clear( sizeof *pkt );
 569     pkt->pkttype = PKT_SIGNATURE;
 570     pkt->pkt.signature = sig;
 571     add_kbnode( root, new_kbnode( pkt ) );
 572     return rc;
 573 }
 574
 575 static int
 576 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 577                unsigned int use )
 578 {
 579     PACKET *pkt;
 580     PKT_signature *sig;
 581     PKT_user_id *uid;
 582     int rc=0;
 583     KBNODE node;
 584     PKT_public_key *pk;
 585
 586     if( opt.verbose )
 587         log_info(_("writing self signature\n"));
 588
 589     /* get the uid packet from the list */
 590     node = find_kbnode( root, PKT_USER_ID );
 591     if( !node )
 592         BUG(); /* no user id packet in tree */
 593     uid = node->pkt->pkt.user_id;
 594     /* get the pk packet from the pub_tree */
 595     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
 596     if( !node )
 597         BUG();
 598     pk = node->pkt->pkt.public_key;
 599     pk->pubkey_usage = use;
 600     /* we have to cache the key, so that the verification of the signature
 601      * creation is able to retrieve the public key */
 602     cache_public_key (pk);
 603
 604     /* and make the signature */
 605     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
 606                              keygen_add_std_prefs, pk );
 607     if( rc ) {
 608         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
 609         return rc;
 610     }
 611
 612     pkt = m_alloc_clear( sizeof *pkt );
 613     pkt->pkttype = PKT_SIGNATURE;
 614     pkt->pkt.signature = sig;
 615     add_kbnode( root, new_kbnode( pkt ) );
 616     return rc;
 617 }
 618
 619 static int
 620 write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 621                   unsigned int use )
 622 {
 623     PACKET *pkt;
 624     PKT_signature *sig;
 625     int rc=0;
 626     KBNODE node;
 627     PKT_public_key *pk, *subpk;
 628     struct opaque_data_usage_and_pk oduap;
 629
 630     if( opt.verbose )
 631         log_info(_("writing key binding signature\n"));
 632
 633     /* get the pk packet from the pub_tree */
 634     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
 635     if( !node )
 636         BUG();
 637     pk = node->pkt->pkt.public_key;
 638     /* we have to cache the key, so that the verification of the signature
 639      * creation is able to retrieve the public key */
 640     cache_public_key (pk);
 641
 642     /* find the last subkey */
 643     subpk = NULL;
 644     for(node=pub_root; node; node = node->next ) {
 645         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
 646             subpk = node->pkt->pkt.public_key;
 647     }
 648     if( !subpk )
 649         BUG();
 650
 651     /* and make the signature */
 652     oduap.usage = use;
 653     oduap.pk = subpk;
 654     rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0, 0, 0, 0,
 655                              keygen_add_key_flags_and_expire, &oduap );
 656     if( rc ) {
 657         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
 658         return rc;
 659     }
 660
 661     pkt = m_alloc_clear( sizeof *pkt );
 662     pkt->pkttype = PKT_SIGNATURE;
 663     pkt->pkt.signature = sig;
 664     add_kbnode( root, new_kbnode( pkt ) );
 665     return rc;
 666 }
 667
 668
 669 static int
 670 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
 671         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
 672 {
 673     int rc;
 674     int i;
 675     PACKET *pkt;
 676     PKT_secret_key *sk;
 677     PKT_public_key *pk;
 678     MPI skey[4];
 679     MPI *factors;
 680
 681     assert( is_ELGAMAL(algo) );
 682
 683     if( nbits < 512 ) {
 684         nbits = 1024;
 685         log_info(_("keysize invalid; using %u bits\n"), nbits );
 686     }
 687
 688     if( (nbits % 32) ) {
 689         nbits = ((nbits + 31) / 32) * 32;
 690         log_info(_("keysize rounded up to %u bits\n"), nbits );
 691     }
 692
 693     rc = pubkey_generate( algo, nbits, skey, &factors );
 694     if( rc ) {
 695         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
 696         return rc;
 697     }
 698
 699     sk = m_alloc_clear( sizeof *sk );
 700     pk = m_alloc_clear( sizeof *pk );
 701     sk->timestamp = pk->timestamp = make_timestamp();
 702     sk->version = pk->version = 4;
 703     if( expireval ) {
 704         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
 705     }
 706     sk->pubkey_algo = pk->pubkey_algo = algo;
 707                        pk->pkey[0] = mpi_copy( skey[0] );
 708                        pk->pkey[1] = mpi_copy( skey[1] );
 709                        pk->pkey[2] = mpi_copy( skey[2] );
 710     sk->skey[0] = skey[0];
 711     sk->skey[1] = skey[1];
 712     sk->skey[2] = skey[2];
 713     sk->skey[3] = skey[3];
 714     sk->is_protected = 0;
 715     sk->protect.algo = 0;
 716
 717     sk->csum = checksum_mpi( sk->skey[3] );
 718     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
 719         *ret_sk = copy_secret_key( NULL, sk );
 720
 721     if( dek ) {
 722         sk->protect.algo = dek->algo;
 723         sk->protect.s2k = *s2k;
 724         rc = protect_secret_key( sk, dek );
 725         if( rc ) {
 726             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
 727             free_public_key(pk);
 728             free_secret_key(sk);
 729             return rc;
 730         }
 731     }
 732
 733     pkt = m_alloc_clear(sizeof *pkt);
 734     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
 735     pkt->pkt.public_key = pk;
 736     add_kbnode(pub_root, new_kbnode( pkt ));
 737
 738     /* don't know whether it makes sense to have the factors, so for now
 739      * we store them in the secret keyring (but they are not secret) */
 740     pkt = m_alloc_clear(sizeof *pkt);
 741     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
 742     pkt->pkt.secret_key = sk;
 743     add_kbnode(sec_root, new_kbnode( pkt ));
 744     for(i=0; factors[i]; i++ )
 745         add_kbnode( sec_root,
 746                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
 747
 748     return 0;
 749 }
 750
 751
 752 /****************
 753  * Generate a DSA key
 754  */
 755 static int
 756 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
 757             STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
 758 {
 759     int rc;
 760     int i;
 761     PACKET *pkt;
 762     PKT_secret_key *sk;
 763     PKT_public_key *pk;
 764     MPI skey[5];
 765     MPI *factors;
 766
 767     if( nbits > 1024 || nbits < 512 ) {
 768         nbits = 1024;
 769         log_info(_("keysize invalid; using %u bits\n"), nbits );
 770     }
 771
 772     if( (nbits % 64) ) {
 773         nbits = ((nbits + 63) / 64) * 64;
 774         log_info(_("keysize rounded up to %u bits\n"), nbits );
 775     }
 776
 777     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
 778     if( rc ) {
 779         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
 780         return rc;
 781     }
 782
 783     sk = m_alloc_clear( sizeof *sk );
 784     pk = m_alloc_clear( sizeof *pk );
 785     sk->timestamp = pk->timestamp = make_timestamp();
 786     sk->version = pk->version = 4;
 787     if( expireval ) {
 788         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
 789     }
 790     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
 791                        pk->pkey[0] = mpi_copy( skey[0] );
 792                        pk->pkey[1] = mpi_copy( skey[1] );
 793                        pk->pkey[2] = mpi_copy( skey[2] );
 794                        pk->pkey[3] = mpi_copy( skey[3] );
 795     sk->skey[0] = skey[0];
 796     sk->skey[1] = skey[1];
 797     sk->skey[2] = skey[2];
 798     sk->skey[3] = skey[3];
 799     sk->skey[4] = skey[4];
 800     sk->is_protected = 0;
 801     sk->protect.algo = 0;
 802
 803     sk->csum = checksum_mpi ( sk->skey[4] );
 804     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
 805         *ret_sk = copy_secret_key( NULL, sk );
 806
 807     if( dek ) {
 808         sk->protect.algo = dek->algo;
 809         sk->protect.s2k = *s2k;
 810         rc = protect_secret_key( sk, dek );
 811         if( rc ) {
 812             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
 813             free_public_key(pk);
 814             free_secret_key(sk);
 815             return rc;
 816         }
 817     }
 818
 819     pkt = m_alloc_clear(sizeof *pkt);
 820     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
 821     pkt->pkt.public_key = pk;
 822     add_kbnode(pub_root, new_kbnode( pkt ));
 823
 824     /* don't know whether it makes sense to have the factors, so for now
 825      * we store them in the secret keyring (but they are not secret)
 826      * p = 2 * q * f1 * f2 * ... * fn
 827      * We store only f1 to f_n-1;  fn can be calculated because p and q
 828      * are known.
 829      */
 830     pkt = m_alloc_clear(sizeof *pkt);
 831     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
 832     pkt->pkt.secret_key = sk;
 833     add_kbnode(sec_root, new_kbnode( pkt ));
 834     for(i=1; factors[i]; i++ )  /* the first one is q */
 835         add_kbnode( sec_root,
 836                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
 837
 838     return 0;
 839 }
 840
 841
 842 /*
 843  * Generate an RSA key.
 844  */
 845 static int
 846 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
 847         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
 848 {
 849     int rc;
 850     PACKET *pkt;
 851     PKT_secret_key *sk;
 852     PKT_public_key *pk;
 853     MPI skey[6];
 854     MPI *factors;
 855
 856     assert( is_RSA(algo) );
 857
 858     if( nbits < 1024 ) {
 859         nbits = 1024;
 860         log_info(_("keysize invalid; using %u bits\n"), nbits );
 861     }
 862
 863     if( (nbits % 32) ) {
 864         nbits = ((nbits + 31) / 32) * 32;
 865         log_info(_("keysize rounded up to %u bits\n"), nbits );
 866     }
 867
 868     rc = pubkey_generate( algo, nbits, skey, &factors );
 869     if( rc ) {
 870         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
 871         return rc;
 872     }
 873
 874     sk = m_alloc_clear( sizeof *sk );
 875     pk = m_alloc_clear( sizeof *pk );
 876     sk->timestamp = pk->timestamp = make_timestamp();
 877     sk->version = pk->version = 4;
 878     if( expireval ) {
 879         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
 880     }
 881     sk->pubkey_algo = pk->pubkey_algo = algo;
 882                        pk->pkey[0] = mpi_copy( skey[0] );
 883                        pk->pkey[1] = mpi_copy( skey[1] );
 884     sk->skey[0] = skey[0];
 885     sk->skey[1] = skey[1];
 886     sk->skey[2] = skey[2];
 887     sk->skey[3] = skey[3];
 888     sk->skey[4] = skey[4];
 889     sk->skey[5] = skey[5];
 890     sk->is_protected = 0;
 891     sk->protect.algo = 0;
 892
 893     sk->csum  = checksum_mpi (sk->skey[2] );
 894     sk->csum += checksum_mpi (sk->skey[3] );
 895     sk->csum += checksum_mpi (sk->skey[4] );
 896     sk->csum += checksum_mpi (sk->skey[5] );
 897     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
 898         *ret_sk = copy_secret_key( NULL, sk );
 899
 900     if( dek ) {
 901         sk->protect.algo = dek->algo;
 902         sk->protect.s2k = *s2k;
 903         rc = protect_secret_key( sk, dek );
 904         if( rc ) {
 905             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
 906             free_public_key(pk);
 907             free_secret_key(sk);
 908             return rc;
 909         }
 910     }
 911
 912     pkt = m_alloc_clear(sizeof *pkt);
 913     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
 914     pkt->pkt.public_key = pk;
 915     add_kbnode(pub_root, new_kbnode( pkt ));
 916
 917     pkt = m_alloc_clear(sizeof *pkt);
 918     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
 919     pkt->pkt.secret_key = sk;
 920     add_kbnode(sec_root, new_kbnode( pkt ));
 921
 922     return 0;
 923 }
 924
 925
 926 /****************
 927  * check valid days:
 928  * return 0 on error or the multiplier
 929  */
 930 static int
 931 check_valid_days( const char *s )
 932 {
 933     if( !isdigit(*s) )
 934         return 0;
 935     for( s++; *s; s++)
 936         if( !isdigit(*s) )
 937             break;
 938     if( !*s )
 939         return 1;
 940     if( s[1] )
 941         return 0; /* e.g. "2323wc" */
 942     if( *s == 'd' || *s == 'D' )
 943         return 1;
 944     if( *s == 'w' || *s == 'W' )
 945         return 7;
 946     if( *s == 'm' || *s == 'M' )
 947         return 30;
 948     if( *s == 'y' || *s == 'Y' )
 949         return 365;
 950     return 0;
 951 }
 952
 953
 954 /****************
 955  * Returns: 0 to create both a DSA and a ElGamal key.
 956  *          and only if key flags are to be written the desired usage.
 957  */
 958 static int
 959 ask_algo (int addmode, unsigned int *r_usage)
 960 {
 961     char *answer;
 962     int algo;
 963
 964     *r_usage = 0;
 965     tty_printf(_("Please select what kind of key you want:\n"));
 966     if( !addmode )
 967         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
 968     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
 969     if( addmode )
 970         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
 971     if (opt.expert)
 972         tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
 973     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
 974     if (addmode)
 975         tty_printf(    _("   (%d) RSA (encrypt only)\n"), 6 );
 976     if (opt.expert)
 977       tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 7 );
 978
 979     for(;;) {
 980         answer = cpr_get("keygen.algo",_("Your selection? "));
 981         cpr_kill_prompt();
 982         algo = *answer? atoi(answer): 1;
 983         m_free(answer);
 984         if( algo == 1 && !addmode ) {
 985             algo = 0;   /* create both keys */
 986             break;
 987         }
 988         else if( algo == 7 && opt.expert ) {
 989             algo = PUBKEY_ALGO_RSA;
 990             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
 991             break;
 992         }
 993         else if( algo == 6 && addmode ) {
 994             algo = PUBKEY_ALGO_RSA;
 995             *r_usage = PUBKEY_USAGE_ENC;
 996             break;
 997         }
 998         else if( algo == 5 ) {
 999             algo = PUBKEY_ALGO_RSA;
1000             *r_usage = PUBKEY_USAGE_SIG;
1001             break;
1002         }
1003         else if( algo == 4 && opt.expert)
1004           {
1005             tty_printf(_(
1006 "The use of this algorithm is only supported by GnuPG.  You will not be\n"
1007 "able to use this key to communicate with PGP users.  This algorithm is also\n"
1008 "very slow, and may not be as secure as the other choices.\n"));
1009
1010             if( cpr_get_answer_is_yes("keygen.algo.elg_se",
1011                                       _("Create anyway? ")))
1012               {
1013                 algo = PUBKEY_ALGO_ELGAMAL;
1014                 break;
1015               }
1016         }
1017         else if( algo == 3 && addmode ) {
1018             algo = PUBKEY_ALGO_ELGAMAL_E;
1019             break;
1020         }
1021         else if( algo == 2 ) {
1022             algo = PUBKEY_ALGO_DSA;
1023             break;
1024         }
1025         else
1026             tty_printf(_("Invalid selection.\n"));
1027     }
1028     return algo;
1029 }
1030
1031
1032 static unsigned
1033 ask_keysize( int algo )
1034 {
1035     char *answer;
1036     unsigned nbits;
1037
1038     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1039         tty_printf (_("About to generate a new %s keypair.\n"
1040                       "              minimum keysize is  768 bits\n"
1041                       "              default keysize is 1024 bits\n"
1042                       "    highest suggested keysize is 2048 bits\n"),
1043                     pubkey_algo_to_string(algo) );
1044     }
1045
1046     for(;;) {
1047         answer = cpr_get("keygen.size",
1048                           _("What keysize do you want? (1024) "));
1049         cpr_kill_prompt();
1050         nbits = *answer? atoi(answer): 1024;
1051         m_free(answer);
1052         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1053             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1054         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1055             tty_printf(_("keysize too small;"
1056                          " 1024 is smallest value allowed for RSA.\n"));
1057         else if( nbits < 768 )
1058             tty_printf(_("keysize too small;"
1059                          " 768 is smallest value allowed.\n"));
1060         else if( nbits > 4096 ) {
1061             /* It is ridiculous and an annoyance to use larger key sizes!
1062              * GnuPG can handle much larger sizes; but it takes an eternity
1063              * to create such a key (but less than the time the Sirius
1064              * Computer Corporation needs to process one of the usual
1065              * complaints) and {de,en}cryption although needs some time.
1066              * So, before you complain about this limitation, I suggest that
1067              * you start a discussion with Marvin about this theme and then
1068              * do whatever you want. */
1069             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1070                                                                          4096);
1071         }
1072         else if( nbits > 2048 && !cpr_enabled() ) {
1073             tty_printf(
1074                 _("Keysizes larger than 2048 are not suggested because\n"
1075                   "computations take REALLY long!\n"));
1076             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1077                         "Are you sure that you want this keysize? ")) ) {
1078                 tty_printf(_("Okay, but keep in mind that your monitor "
1079                              "and keyboard radiation is also very vulnerable "
1080                              "to attacks!\n"));
1081                 break;
1082             }
1083         }
1084         else
1085             break;
1086     }
1087     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1088     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1089         nbits = ((nbits + 63) / 64) * 64;
1090         tty_printf(_("rounded up to %u bits\n"), nbits );
1091     }
1092     else if( (nbits % 32) ) {
1093         nbits = ((nbits + 31) / 32) * 32;
1094         tty_printf(_("rounded up to %u bits\n"), nbits );
1095     }
1096     return nbits;
1097 }
1098
1099
1100 /****************
1101  * Parse an expire string and return it's value in days.
1102  * Returns -1 on error.
1103  */
1104 static int
1105 parse_expire_string( const char *string )
1106 {
1107     int mult;
1108     u32 abs_date=0;
1109     u32 curtime = make_timestamp();
1110     int valid_days;
1111
1112     if( !*string )
1113         valid_days = 0;
1114     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1115         /* This calculation is not perfectly okay because we
1116          * are later going to simply multiply by 86400 and don't
1117          * correct for leapseconds.  A solution would be to change
1118          * the whole implemenation to work with dates and not intervals
1119          * which are required for v3 keys.
1120          */
1121         valid_days = abs_date/86400-curtime/86400+1;
1122     }
1123     else if( (mult=check_valid_days(string)) ) {
1124         valid_days = atoi(string) * mult;
1125         if( valid_days < 0 || valid_days > 39447 )
1126             valid_days = 0;
1127     }
1128     else {
1129         valid_days = -1;
1130     }
1131     return valid_days;
1132 }
1133
1134 /* object == 0 for a key, and 1 for a sig */
1135 u32
1136 ask_expire_interval(int object)
1137 {
1138     char *answer;
1139     int valid_days=0;
1140     u32 interval = 0;
1141
1142     switch(object)
1143       {
1144       case 0:
1145         tty_printf(_("Please specify how long the key should be valid.\n"
1146                      "         0 = key does not expire\n"
1147                      "      <n>  = key expires in n days\n"
1148                      "      <n>w = key expires in n weeks\n"
1149                      "      <n>m = key expires in n months\n"
1150                      "      <n>y = key expires in n years\n"));
1151         break;
1152
1153       case 1:
1154         tty_printf(_("Please specify how long the signature should be valid.\n"
1155                      "         0 = signature does not expire\n"
1156                      "      <n>  = signature expires in n days\n"
1157                      "      <n>w = signature expires in n weeks\n"
1158                      "      <n>m = signature expires in n months\n"
1159                      "      <n>y = signature expires in n years\n"));
1160         break;
1161
1162       default:
1163         BUG();
1164       }
1165
1166     /* Note: The elgamal subkey for DSA has no expiration date because
1167      * it must be signed with the DSA key and this one has the expiration
1168      * date */
1169
1170     answer = NULL;
1171     for(;;) {
1172         u32 curtime=make_timestamp();
1173
1174         m_free(answer);
1175         if(object==0)
1176           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1177         else
1178           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1179         cpr_kill_prompt();
1180         trim_spaces(answer);
1181         valid_days = parse_expire_string( answer );
1182         if( valid_days < 0 ) {
1183             tty_printf(_("invalid value\n"));
1184             continue;
1185         }
1186
1187         if( !valid_days ) {
1188             tty_printf(_("%s does not expire at all\n"),
1189                        object==0?"Key":"Signature");
1190             interval = 0;
1191         }
1192         else {
1193             interval = valid_days * 86400L;
1194             /* print the date when the key expires */
1195             tty_printf(_("%s expires at %s\n"),
1196                         object==0?"Key":"Signature",
1197                         asctimestamp((ulong)(curtime + interval) ) );
1198             /* FIXME: This check yields warning on alhas:
1199                write a configure check and to this check here only for 32 bit machines */
1200             if( (time_t)((ulong)(curtime+interval)) < 0 )
1201                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1202                     "However, it will be correctly handled up to 2106.\n"));
1203         }
1204
1205         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1206                                             _("Is this correct (y/n)? ")) )
1207             break;
1208     }
1209     m_free(answer);
1210     return interval;
1211 }
1212
1213 u32
1214 ask_expiredate()
1215 {
1216     u32 x = ask_expire_interval(0);
1217     return x? make_timestamp() + x : 0;
1218 }
1219
1220 static int
1221 has_invalid_email_chars( const char *s )
1222 {
1223     int at_seen=0;
1224     static char valid_chars[] = "01234567890_-."
1225                                 "abcdefghijklmnopqrstuvwxyz"
1226                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1227
1228     for( ; *s; s++ ) {
1229         if( *s & 0x80 )
1230             return 1;
1231         if( *s == '@' )
1232             at_seen=1;
1233         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1234             return 1;
1235         else if( at_seen && !strchr( valid_chars, *s ) )
1236             return 1;
1237     }
1238     return 0;
1239 }
1240
1241
1242 static char *
1243 ask_user_id( int mode )
1244 {
1245     char *answer;
1246     char *aname, *acomment, *amail, *uid;
1247
1248     if( !mode )
1249         tty_printf( _("\n"
1250 "You need a User-ID to identify your key; the software constructs the user id\n"
1251 "from Real Name, Comment and Email Address in this form:\n"
1252 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1253     uid = aname = acomment = amail = NULL;
1254     for(;;) {
1255         char *p;
1256         int fail=0;
1257
1258         if( !aname ) {
1259             for(;;) {
1260                 m_free(aname);
1261                 aname = cpr_get("keygen.name",_("Real name: "));
1262                 trim_spaces(aname);
1263                 cpr_kill_prompt();
1264
1265                 if( opt.allow_freeform_uid )
1266                     break;
1267
1268                 if( strpbrk( aname, "<>" ) )
1269                     tty_printf(_("Invalid character in name\n"));
1270                 else if( isdigit(*aname) )
1271                     tty_printf(_("Name may not start with a digit\n"));
1272                 else if( strlen(aname) < 5 )
1273                     tty_printf(_("Name must be at least 5 characters long\n"));
1274                 else
1275                     break;
1276             }
1277         }
1278         if( !amail ) {
1279             for(;;) {
1280                 m_free(amail);
1281                 amail = cpr_get("keygen.email",_("Email address: "));
1282                 trim_spaces(amail);
1283                 cpr_kill_prompt();
1284                 if( !*amail )
1285                     break;   /* no email address is okay */
1286                 else if( has_invalid_email_chars(amail)
1287                          || string_count_chr(amail,'@') != 1
1288                          || *amail == '@'
1289                          || amail[strlen(amail)-1] == '@'
1290                          || amail[strlen(amail)-1] == '.'
1291                          || strstr(amail, "..") )
1292                     tty_printf(_("Not a valid email address\n"));
1293                 else
1294                     break;
1295             }
1296         }
1297         if( !acomment ) {
1298             for(;;) {
1299                 m_free(acomment);
1300                 acomment = cpr_get("keygen.comment",_("Comment: "));
1301                 trim_spaces(acomment);
1302                 cpr_kill_prompt();
1303                 if( !*acomment )
1304                     break;   /* no comment is okay */
1305                 else if( strpbrk( acomment, "()" ) )
1306                     tty_printf(_("Invalid character in comment\n"));
1307                 else
1308                     break;
1309             }
1310         }
1311
1312
1313         m_free(uid);
1314         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1315         p = stpcpy(p, aname );
1316         if( *acomment )
1317             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1318         if( *amail )
1319             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1320
1321         /* append a warning if we do not have dev/random
1322          * or it is switched into  quick testmode */
1323         if( quick_random_gen(-1) )
1324             strcpy(p, " (INSECURE!)" );
1325
1326         /* print a note in case that UTF8 mapping has to be done */
1327         for(p=uid; *p; p++ ) {
1328             if( *p & 0x80 ) {
1329                 tty_printf(_("You are using the `%s' character set.\n"),
1330                            get_native_charset() );
1331                 break;
1332             }
1333         }
1334
1335         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1336         /* fixme: add a warning if this user-id already exists */
1337         if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1338             fail = 1;
1339             tty_printf(_("Please don't put the email address "
1340                           "into the real name or the comment\n") );
1341         }
1342
1343         for(;;) {
1344             const char *ansstr = _("NnCcEeOoQq");
1345
1346             if( strlen(ansstr) != 10 )
1347                 BUG();
1348             if( cpr_enabled() ) {
1349                 answer = m_strdup(ansstr+6);
1350                 answer[1] = 0;
1351             }
1352             else {
1353                 answer = cpr_get("keygen.userid.cmd", fail?
1354                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1355                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1356                 cpr_kill_prompt();
1357             }
1358             if( strlen(answer) > 1 )
1359                 ;
1360             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1361                 m_free(aname); aname = NULL;
1362                 break;
1363             }
1364             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1365                 m_free(acomment); acomment = NULL;
1366                 break;
1367             }
1368             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1369                 m_free(amail); amail = NULL;
1370                 break;
1371             }
1372             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1373                 if( fail ) {
1374                     tty_printf(_("Please correct the error first\n"));
1375                 }
1376                 else {
1377                     m_free(aname); aname = NULL;
1378                     m_free(acomment); acomment = NULL;
1379                     m_free(amail); amail = NULL;
1380                     break;
1381                 }
1382             }
1383             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1384                 m_free(aname); aname = NULL;
1385                 m_free(acomment); acomment = NULL;
1386                 m_free(amail); amail = NULL;
1387                 m_free(uid); uid = NULL;
1388                 break;
1389             }
1390             m_free(answer);
1391         }
1392         m_free(answer);
1393         if( !amail && !acomment && !amail )
1394             break;
1395         m_free(uid); uid = NULL;
1396     }
1397     if( uid ) {
1398         char *p = native_to_utf8( uid );
1399         m_free( uid );
1400         uid = p;
1401     }
1402     return uid;
1403 }
1404
1405
1406 static DEK *
1407 ask_passphrase( STRING2KEY **ret_s2k )
1408 {
1409     DEK *dek = NULL;
1410     STRING2KEY *s2k;
1411     const char *errtext = NULL;
1412
1413     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1414
1415     s2k = m_alloc_secure( sizeof *s2k );
1416     for(;;) {
1417         s2k->mode = opt.s2k_mode;
1418         s2k->hash_algo = opt.s2k_digest_algo;
1419         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,errtext);
1420         if( !dek ) {
1421             errtext = _("passphrase not correctly repeated; try again");
1422             tty_printf(_("%s.\n"), errtext);
1423         }
1424         else if( !dek->keylen ) {
1425             m_free(dek); dek = NULL;
1426             m_free(s2k); s2k = NULL;
1427             tty_printf(_(
1428             "You don't want a passphrase - this is probably a *bad* idea!\n"
1429             "I will do it anyway.  You can change your passphrase at any time,\n"
1430             "using this program with the option \"--edit-key\".\n\n"));
1431             break;
1432         }
1433         else
1434             break; /* okay */
1435     }
1436     *ret_s2k = s2k;
1437     return dek;
1438 }
1439
1440
1441 static int
1442 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1443            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1444 {
1445     int rc=0;
1446
1447     if( !opt.batch )
1448         tty_printf(_(
1449 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1450 "some other action (type on the keyboard, move the mouse, utilize the\n"
1451 "disks) during the prime generation; this gives the random number\n"
1452 "generator a better chance to gain enough entropy.\n") );
1453
1454     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
1455         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1456     else if( algo == PUBKEY_ALGO_DSA )
1457         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1458     else if( algo == PUBKEY_ALGO_RSA )
1459         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1460     else
1461         BUG();
1462
1463   #ifdef ENABLE_COMMENT_PACKETS
1464     if( !rc ) {
1465         add_kbnode( pub_root,
1466                 make_comment_node("#created by GNUPG v" VERSION " ("
1467                                             PRINTABLE_OS_NAME ")"));
1468         add_kbnode( sec_root,
1469                 make_comment_node("#created by GNUPG v" VERSION " ("
1470                                             PRINTABLE_OS_NAME ")"));
1471     }
1472   #endif
1473     return rc;
1474 }
1475
1476
1477 /****************
1478  * Generate a new user id packet, or return NULL if canceled
1479  */
1480 PKT_user_id *
1481 generate_user_id()
1482 {
1483     PKT_user_id *uid;
1484     char *p;
1485     size_t n;
1486
1487     p = ask_user_id( 1 );
1488     if( !p )
1489         return NULL;
1490     n = strlen(p);
1491     uid = m_alloc_clear( sizeof *uid + n - 1 );
1492     uid->len = n;
1493     strcpy(uid->name, p);
1494     uid->ref = 1;
1495     return uid;
1496 }
1497
1498
1499 static void
1500 release_parameter_list( struct para_data_s *r )
1501 {
1502     struct para_data_s *r2;
1503
1504     for( ; r ; r = r2 ) {
1505         r2 = r->next;
1506         if( r->key == pPASSPHRASE_DEK )
1507             m_free( r->u.dek );
1508         else if( r->key == pPASSPHRASE_S2K )
1509             m_free( r->u.s2k );
1510
1511         m_free(r);
1512     }
1513 }
1514
1515 static struct para_data_s *
1516 get_parameter( struct para_data_s *para, enum para_name key )
1517 {
1518     struct para_data_s *r;
1519
1520     for( r = para; r && r->key != key; r = r->next )
1521         ;
1522     return r;
1523 }
1524
1525 static const char *
1526 get_parameter_value( struct para_data_s *para, enum para_name key )
1527 {
1528     struct para_data_s *r = get_parameter( para, key );
1529     return (r && *r->u.value)? r->u.value : NULL;
1530 }
1531
1532 static int
1533 get_parameter_algo( struct para_data_s *para, enum para_name key )
1534 {
1535     int i;
1536     struct para_data_s *r = get_parameter( para, key );
1537     if( !r )
1538         return -1;
1539     if( isdigit( *r->u.value ) )
1540         i = atoi( r->u.value );
1541     else
1542         i = string_to_pubkey_algo( r->u.value );
1543     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1544       i = 0; /* we don't want to allow generation of these algorithms */
1545     return i;
1546 }
1547
1548 /*
1549  * parse the usage parameter and set the keyflags.  Return true on error.
1550  */
1551 static int
1552 parse_parameter_usage (const char *fname,
1553                        struct para_data_s *para, enum para_name key)
1554 {
1555     struct para_data_s *r = get_parameter( para, key );
1556     char *p, *pn;
1557     unsigned int use;
1558
1559     if( !r )
1560         return 0; /* none (this is an optional parameter)*/
1561
1562     use = 0;
1563     pn = r->u.value;
1564     while ( (p = strsep (&pn, " \t,")) ) {
1565         if ( !*p)
1566             ;
1567         else if ( !ascii_strcasecmp (p, "sign") )
1568             use |= PUBKEY_USAGE_SIG;
1569         else if ( !ascii_strcasecmp (p, "encrypt") )
1570             use |= PUBKEY_USAGE_ENC;
1571         else {
1572             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1573             return -1; /* error */
1574         }
1575     }
1576     r->u.usage = use;
1577     return 0;
1578 }
1579
1580 static int
1581 parse_revocation_key (const char *fname,
1582                       struct para_data_s *para, enum para_name key)
1583 {
1584   struct para_data_s *r = get_parameter( para, key );
1585   struct revocation_key revkey;
1586   char *pn;
1587   int i;
1588
1589   if( !r )
1590     return 0; /* none (this is an optional parameter) */
1591
1592   pn = r->u.value;
1593
1594   revkey.class=0x80;
1595   revkey.algid=atoi(pn);
1596   if(!revkey.algid)
1597     goto fail;
1598
1599   /* Skip to the fpr */
1600   while(*pn && *pn!=':')
1601     pn++;
1602
1603   if(*pn!=':')
1604     goto fail;
1605
1606   pn++;
1607
1608   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1609     {
1610       int c=hextobyte(pn);
1611       if(c==-1)
1612         goto fail;
1613
1614       revkey.fpr[i]=c;
1615     }
1616
1617   /* skip to the tag */
1618   while(*pn && *pn!='s' && *pn!='S')
1619     pn++;
1620
1621   if(ascii_strcasecmp(pn,"sensitive")==0)
1622     revkey.class|=0x40;
1623
1624   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1625
1626   return 0;
1627
1628   fail:
1629   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1630   return -1; /* error */
1631 }
1632
1633
1634 static u32
1635 get_parameter_u32( struct para_data_s *para, enum para_name key )
1636 {
1637     struct para_data_s *r = get_parameter( para, key );
1638
1639     if( !r )
1640         return 0;
1641     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1642         return r->u.expire;
1643     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1644         return r->u.usage;
1645
1646     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1647 }
1648
1649 static unsigned int
1650 get_parameter_uint( struct para_data_s *para, enum para_name key )
1651 {
1652     return get_parameter_u32( para, key );
1653 }
1654
1655 static DEK *
1656 get_parameter_dek( struct para_data_s *para, enum para_name key )
1657 {
1658     struct para_data_s *r = get_parameter( para, key );
1659     return r? r->u.dek : NULL;
1660 }
1661
1662 static STRING2KEY *
1663 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1664 {
1665     struct para_data_s *r = get_parameter( para, key );
1666     return r? r->u.s2k : NULL;
1667 }
1668
1669 static struct revocation_key *
1670 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1671 {
1672     struct para_data_s *r = get_parameter( para, key );
1673     return r? &r->u.revkey : NULL;
1674 }
1675
1676 static int
1677 proc_parameter_file( struct para_data_s *para, const char *fname,
1678                      struct output_control_s *outctrl )
1679 {
1680     struct para_data_s *r;
1681     const char *s1, *s2, *s3;
1682     size_t n;
1683     char *p;
1684     int i;
1685
1686     /* check that we have all required parameters */
1687     assert( get_parameter( para, pKEYTYPE ) );
1688     i = get_parameter_algo( para, pKEYTYPE );
1689     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1690         r = get_parameter( para, pKEYTYPE );
1691         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1692         return -1;
1693     }
1694
1695     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1696         return -1;
1697
1698     i = get_parameter_algo( para, pSUBKEYTYPE );
1699     if( i > 0 && check_pubkey_algo( i ) ) {
1700         r = get_parameter( para, pSUBKEYTYPE );
1701         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1702         return -1;
1703     }
1704     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1705         return -1;
1706
1707
1708     if( !get_parameter_value( para, pUSERID ) ) {
1709         /* create the formatted user ID */
1710         s1 = get_parameter_value( para, pNAMEREAL );
1711         s2 = get_parameter_value( para, pNAMECOMMENT );
1712         s3 = get_parameter_value( para, pNAMEEMAIL );
1713         if( s1 || s2 || s3 ) {
1714             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1715             r = m_alloc_clear( sizeof *r + n + 20 );
1716             r->key = pUSERID;
1717             p = r->u.value;
1718             if( s1 )
1719                 p = stpcpy(p, s1 );
1720             if( s2 )
1721                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1722             if( s3 )
1723                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1724             r->next = para;
1725             para = r;
1726         }
1727     }
1728
1729     /* Set preferences, if any. */
1730     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1731
1732     /* Set revoker, if any. */
1733     if (parse_revocation_key (fname, para, pREVOKER))
1734       return -1;
1735
1736     /* make DEK and S2K from the Passphrase */
1737     r = get_parameter( para, pPASSPHRASE );
1738     if( r && *r->u.value ) {
1739         /* we have a plain text passphrase - create a DEK from it.
1740          * It is a little bit ridiculous to keep it ih secure memory
1741          * but becuase we do this alwasy, why not here */
1742         STRING2KEY *s2k;
1743         DEK *dek;
1744
1745         s2k = m_alloc_secure( sizeof *s2k );
1746         s2k->mode = opt.s2k_mode;
1747         s2k->hash_algo = opt.s2k_digest_algo;
1748         set_next_passphrase( r->u.value );
1749         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
1750         set_next_passphrase( NULL );
1751         assert( dek );
1752         memset( r->u.value, 0, strlen(r->u.value) );
1753
1754         r = m_alloc_clear( sizeof *r );
1755         r->key = pPASSPHRASE_S2K;
1756         r->u.s2k = s2k;
1757         r->next = para;
1758         para = r;
1759         r = m_alloc_clear( sizeof *r );
1760         r->key = pPASSPHRASE_DEK;
1761         r->u.dek = dek;
1762         r->next = para;
1763         para = r;
1764     }
1765
1766     /* make KEYEXPIRE from Expire-Date */
1767     r = get_parameter( para, pEXPIREDATE );
1768     if( r && *r->u.value ) {
1769         i = parse_expire_string( r->u.value );
1770         if( i < 0 ) {
1771             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1772             return -1;
1773         }
1774         r->u.expire = i * 86400L;
1775         r->key = pKEYEXPIRE;  /* change hat entry */
1776         /* also set it for the subkey */
1777         r = m_alloc_clear( sizeof *r + 20 );
1778         r->key = pSUBKEYEXPIRE;
1779         r->u.expire = i * 86400L;
1780         r->next = para;
1781         para = r;
1782     }
1783
1784     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1785         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1786         return -1;
1787     }
1788
1789     do_generate_keypair( para, outctrl );
1790     return 0;
1791 }
1792
1793
1794 /****************
1795  * Kludge to allow non interactive key generation controlled
1796  * by a parameter file (which currently is only stdin)
1797  * Note, that string parameters are expected to be in UTF-8
1798  */
1799 static void
1800 read_parameter_file( const char *fname )
1801 {
1802     static struct { const char *name;
1803                     enum para_name key;
1804     } keywords[] = {
1805         { "Key-Type",       pKEYTYPE},
1806         { "Key-Length",     pKEYLENGTH },
1807         { "Key-Usage",      pKEYUSAGE },
1808         { "Subkey-Type",    pSUBKEYTYPE },
1809         { "Subkey-Length",  pSUBKEYLENGTH },
1810         { "Subkey-Usage",   pSUBKEYUSAGE },
1811         { "Name-Real",      pNAMEREAL },
1812         { "Name-Email",     pNAMEEMAIL },
1813         { "Name-Comment",   pNAMECOMMENT },
1814         { "Expire-Date",    pEXPIREDATE },
1815         { "Passphrase",     pPASSPHRASE },
1816         { "Preferences",    pPREFERENCES },
1817         { "Revoker",        pREVOKER },
1818         { NULL, 0 }
1819     };
1820     FILE *fp;
1821     char line[1024], *p;
1822     int lnr;
1823     const char *err = NULL;
1824     struct para_data_s *para, *r;
1825     int i;
1826     struct output_control_s outctrl;
1827
1828     memset( &outctrl, 0, sizeof( outctrl ) );
1829
1830     if( !fname || !*fname || !strcmp(fname,"-") ) {
1831         fp = stdin;
1832         fname = "-";
1833     }
1834     else {
1835         fp = fopen( fname, "r" );
1836         if( !fp ) {
1837             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1838             return;
1839         }
1840     }
1841
1842     lnr = 0;
1843     err = NULL;
1844     para = NULL;
1845     while( fgets( line, DIM(line)-1, fp ) ) {
1846         char *keyword, *value;
1847
1848         lnr++;
1849         if( *line && line[strlen(line)-1] != '\n' ) {
1850             err = "line too long";
1851             break;
1852         }
1853         for( p = line; isspace(*(byte*)p); p++ )
1854             ;
1855         if( !*p || *p == '#' )
1856             continue;
1857         keyword = p;
1858         if( *keyword == '%' ) {
1859             for( ; !isspace(*(byte*)p); p++ )
1860                 ;
1861             if( *p )
1862                 *p++ = 0;
1863             for( ; isspace(*(byte*)p); p++ )
1864                 ;
1865             value = p;
1866             trim_trailing_ws( value, strlen(value) );
1867             if( !ascii_strcasecmp( keyword, "%echo" ) )
1868                 log_info("%s\n", value );
1869             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
1870                 outctrl.dryrun = 1;
1871             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
1872                 outctrl.lnr = lnr;
1873                 proc_parameter_file( para, fname, &outctrl );
1874                 release_parameter_list( para );
1875                 para = NULL;
1876             }
1877             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
1878                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1879                     ; /* still the same file - ignore it */
1880                 else {
1881                     m_free( outctrl.pub.newfname );
1882                     outctrl.pub.newfname = m_strdup( value );
1883                     outctrl.use_files = 1;
1884                 }
1885             }
1886             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
1887                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1888                     ; /* still the same file - ignore it */
1889                 else {
1890                    m_free( outctrl.sec.newfname );
1891                    outctrl.sec.newfname = m_strdup( value );
1892                    outctrl.use_files = 1;
1893                 }
1894             }
1895             else
1896                 log_info("skipping control `%s' (%s)\n", keyword, value );
1897
1898
1899             continue;
1900         }
1901
1902
1903         if( !(p = strchr( p, ':' )) || p == keyword ) {
1904             err = "missing colon";
1905             break;
1906         }
1907         if( *p )
1908             *p++ = 0;
1909         for( ; isspace(*(byte*)p); p++ )
1910             ;
1911         if( !*p ) {
1912             err = "missing argument";
1913             break;
1914         }
1915         value = p;
1916         trim_trailing_ws( value, strlen(value) );
1917
1918         for(i=0; keywords[i].name; i++ ) {
1919             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
1920                 break;
1921         }
1922         if( !keywords[i].name ) {
1923             err = "unknown keyword";
1924             break;
1925         }
1926         if( keywords[i].key != pKEYTYPE && !para ) {
1927             err = "parameter block does not start with \"Key-Type\"";
1928             break;
1929         }
1930
1931         if( keywords[i].key == pKEYTYPE && para ) {
1932             outctrl.lnr = lnr;
1933             proc_parameter_file( para, fname, &outctrl );
1934             release_parameter_list( para );
1935             para = NULL;
1936         }
1937         else {
1938             for( r = para; r; r = r->next ) {
1939                 if( r->key == keywords[i].key )
1940                     break;
1941             }
1942             if( r ) {
1943                 err = "duplicate keyword";
1944                 break;
1945             }
1946         }
1947         r = m_alloc_clear( sizeof *r + strlen( value ) );
1948         r->lnr = lnr;
1949         r->key = keywords[i].key;
1950         strcpy( r->u.value, value );
1951         r->next = para;
1952         para = r;
1953     }
1954     if( err )
1955         log_error("%s:%d: %s\n", fname, lnr, err );
1956     else if( ferror(fp) ) {
1957         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
1958     }
1959     else if( para ) {
1960         outctrl.lnr = lnr;
1961         proc_parameter_file( para, fname, &outctrl );
1962     }
1963
1964     if( outctrl.use_files ) { /* close open streams */
1965         iobuf_close( outctrl.pub.stream );
1966         iobuf_close( outctrl.sec.stream );
1967         m_free( outctrl.pub.fname );
1968         m_free( outctrl.pub.newfname );
1969         m_free( outctrl.sec.fname );
1970         m_free( outctrl.sec.newfname );
1971     }
1972
1973     release_parameter_list( para );
1974     if( strcmp( fname, "-" ) )
1975         fclose(fp);
1976 }
1977
1978
1979 /****************
1980  * Generate a keypair
1981  * (fname is only used in batch mode)
1982  */
1983 void
1984 generate_keypair( const char *fname )
1985 {
1986     unsigned int nbits;
1987     char *uid = NULL;
1988     DEK *dek;
1989     STRING2KEY *s2k;
1990     int algo;
1991     unsigned int use;
1992     int both = 0;
1993     u32 expire;
1994     struct para_data_s *para = NULL;
1995     struct para_data_s *r;
1996     struct output_control_s outctrl;
1997
1998     memset( &outctrl, 0, sizeof( outctrl ) );
1999
2000     if( opt.batch ) {
2001         read_parameter_file( fname );
2002         return;
2003     }
2004
2005     algo = ask_algo( 0, &use );
2006     if( !algo ) { /* default: DSA with ElG subkey of the specified size */
2007         both = 1;
2008         r = m_alloc_clear( sizeof *r + 20 );
2009         r->key = pKEYTYPE;
2010         sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2011         r->next = para;
2012         para = r;
2013         tty_printf(_("DSA keypair will have 1024 bits.\n"));
2014         r = m_alloc_clear( sizeof *r + 20 );
2015         r->key = pKEYLENGTH;
2016         strcpy( r->u.value, "1024" );
2017         r->next = para;
2018         para = r;
2019
2020         algo = PUBKEY_ALGO_ELGAMAL_E;
2021         r = m_alloc_clear( sizeof *r + 20 );
2022         r->key = pSUBKEYTYPE;
2023         sprintf( r->u.value, "%d", algo );
2024         r->next = para;
2025         para = r;
2026     }
2027     else {
2028         r = m_alloc_clear( sizeof *r + 20 );
2029         r->key = pKEYTYPE;
2030         sprintf( r->u.value, "%d", algo );
2031         r->next = para;
2032         para = r;
2033
2034         if (use) {
2035             r = m_alloc_clear( sizeof *r + 20 );
2036             r->key = pKEYUSAGE;
2037             sprintf( r->u.value, "%s%s",
2038                      (use & PUBKEY_USAGE_SIG)? "sign ":"",
2039                      (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2040             r->next = para;
2041             para = r;
2042         }
2043
2044     }
2045
2046     nbits = ask_keysize( algo );
2047     r = m_alloc_clear( sizeof *r + 20 );
2048     r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2049     sprintf( r->u.value, "%u", nbits);
2050     r->next = para;
2051     para = r;
2052
2053     expire = ask_expire_interval(0);
2054     r = m_alloc_clear( sizeof *r + 20 );
2055     r->key = pKEYEXPIRE;
2056     r->u.expire = expire;
2057     r->next = para;
2058     para = r;
2059     r = m_alloc_clear( sizeof *r + 20 );
2060     r->key = pSUBKEYEXPIRE;
2061     r->u.expire = expire;
2062     r->next = para;
2063     para = r;
2064
2065     uid = ask_user_id(0);
2066     if( !uid ) {
2067         log_error(_("Key generation canceled.\n"));
2068         release_parameter_list( para );
2069         return;
2070     }
2071     r = m_alloc_clear( sizeof *r + strlen(uid) );
2072     r->key = pUSERID;
2073     strcpy( r->u.value, uid );
2074     r->next = para;
2075     para = r;
2076
2077     dek = ask_passphrase( &s2k );
2078     if( dek ) {
2079         r = m_alloc_clear( sizeof *r );
2080         r->key = pPASSPHRASE_DEK;
2081         r->u.dek = dek;
2082         r->next = para;
2083         para = r;
2084         r = m_alloc_clear( sizeof *r );
2085         r->key = pPASSPHRASE_S2K;
2086         r->u.s2k = s2k;
2087         r->next = para;
2088         para = r;
2089     }
2090
2091     proc_parameter_file( para, "[internal]", &outctrl );
2092     release_parameter_list( para );
2093 }
2094
2095
2096 static void
2097 print_status_key_created (int letter, PKT_public_key *pk)
2098 {
2099   byte array[MAX_FINGERPRINT_LEN], *s;
2100   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2101   size_t i, n;
2102
2103   p = buf;
2104   *p++ = letter;
2105   *p++ = ' ';
2106   fingerprint_from_pk (pk, array, &n);
2107   s = array;
2108   for (i=0; i < n ; i++, s++, p += 2)
2109     sprintf (p, "%02X", *s);
2110   *p = 0;
2111   write_status_text (STATUS_KEY_CREATED, buf);
2112 }
2113
2114 static void
2115 do_generate_keypair( struct para_data_s *para,
2116                      struct output_control_s *outctrl )
2117 {
2118     KBNODE pub_root = NULL;
2119     KBNODE sec_root = NULL;
2120     PKT_secret_key *sk = NULL;
2121     const char *s;
2122     struct revocation_key *revkey;
2123     int rc;
2124     int did_sub = 0;
2125
2126     if( outctrl->dryrun ) {
2127         log_info("dry-run mode - key generation skipped\n");
2128         return;
2129     }
2130
2131
2132     if( outctrl->use_files ) {
2133         if( outctrl->pub.newfname ) {
2134             iobuf_close(outctrl->pub.stream);
2135             outctrl->pub.stream = NULL;
2136             m_free( outctrl->pub.fname );
2137             outctrl->pub.fname =  outctrl->pub.newfname;
2138             outctrl->pub.newfname = NULL;
2139
2140             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2141             if( !outctrl->pub.stream ) {
2142                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2143                                                      strerror(errno) );
2144                 return;
2145             }
2146             if( opt.armor ) {
2147                 outctrl->pub.afx.what = 1;
2148                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2149                                                     &outctrl->pub.afx );
2150             }
2151         }
2152         if( outctrl->sec.newfname ) {
2153             iobuf_close(outctrl->sec.stream);
2154             outctrl->sec.stream = NULL;
2155             m_free( outctrl->sec.fname );
2156             outctrl->sec.fname =  outctrl->sec.newfname;
2157             outctrl->sec.newfname = NULL;
2158
2159             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2160             if( !outctrl->sec.stream ) {
2161                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2162                                                      strerror(errno) );
2163                 return;
2164             }
2165             if( opt.armor ) {
2166                 outctrl->sec.afx.what = 5;
2167                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2168                                                     &outctrl->sec.afx );
2169             }
2170         }
2171         assert( outctrl->pub.stream );
2172         assert( outctrl->sec.stream );
2173         if( opt.verbose ) {
2174             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2175             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2176         }
2177     }
2178
2179
2180     /* we create the packets as a tree of kbnodes. Because the structure
2181      * we create is known in advance we simply generate a linked list
2182      * The first packet is a dummy comment packet which we flag
2183      * as deleted.  The very first packet must always be a KEY packet.
2184      */
2185     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2186     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2187
2188     rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2189                     get_parameter_uint( para, pKEYLENGTH ),
2190                     pub_root, sec_root,
2191                     get_parameter_dek( para, pPASSPHRASE_DEK ),
2192                     get_parameter_s2k( para, pPASSPHRASE_S2K ),
2193                     &sk,
2194                     get_parameter_u32( para, pKEYEXPIRE ) );
2195
2196     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2197       {
2198         rc=write_direct_sig(pub_root,pub_root,sk,revkey);
2199         if(!rc)
2200           write_direct_sig(sec_root,pub_root,sk,revkey);
2201       }
2202
2203     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2204         write_uid(pub_root, s );
2205         if( !rc )
2206             write_uid(sec_root, s );
2207         if( !rc )
2208             rc = write_selfsig(pub_root, pub_root, sk,
2209                                get_parameter_uint (para, pKEYUSAGE));
2210         if( !rc )
2211             rc = write_selfsig(sec_root, pub_root, sk,
2212                                get_parameter_uint (para, pKEYUSAGE));
2213     }
2214
2215     if( get_parameter( para, pSUBKEYTYPE ) ) {
2216         rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2217                         get_parameter_uint( para, pSUBKEYLENGTH ),
2218                         pub_root, sec_root,
2219                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2220                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2221                         NULL,
2222                         get_parameter_u32( para, pSUBKEYEXPIRE ) );
2223         if( !rc )
2224             rc = write_keybinding(pub_root, pub_root, sk,
2225                                   get_parameter_uint (para, pSUBKEYUSAGE));
2226         if( !rc )
2227             rc = write_keybinding(sec_root, pub_root, sk,
2228                                   get_parameter_uint (para, pSUBKEYUSAGE));
2229         did_sub = 1;
2230     }
2231
2232
2233     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2234         rc = write_keyblock( outctrl->pub.stream, pub_root );
2235         if( rc )
2236             log_error("can't write public key: %s\n", g10_errstr(rc) );
2237         if( !rc ) {
2238             rc = write_keyblock( outctrl->sec.stream, sec_root );
2239             if( rc )
2240                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2241         }
2242
2243     }
2244     else if( !rc ) { /* write to the standard keyrings */
2245         KEYDB_HANDLE pub_hd = keydb_new (0);
2246         KEYDB_HANDLE sec_hd = keydb_new (1);
2247
2248         /* FIXME: we may have to create the keyring first */
2249         rc = keydb_locate_writable (pub_hd, NULL);
2250         if (rc)
2251             log_error (_("no writable public keyring found: %s\n"),
2252                        g10_errstr (rc));
2253
2254         if (!rc) {
2255             rc = keydb_locate_writable (sec_hd, NULL);
2256             if (rc)
2257                 log_error (_("no writable secret keyring found: %s\n"),
2258                            g10_errstr (rc));
2259         }
2260
2261         if (!rc && opt.verbose) {
2262             log_info(_("writing public key to `%s'\n"),
2263                      keydb_get_resource_name (pub_hd));
2264             log_info(_("writing secret key to `%s'\n"),
2265                      keydb_get_resource_name (sec_hd));
2266         }
2267
2268         if (!rc) {
2269             rc = keydb_insert_keyblock (pub_hd, pub_root);
2270             if (rc)
2271                 log_error (_("error writing public keyring `%s': %s\n"),
2272                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2273         }
2274
2275         if (!rc) {
2276             rc = keydb_insert_keyblock (sec_hd, sec_root);
2277             if (rc)
2278                 log_error (_("error writing secret keyring `%s': %s\n"),
2279                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2280         }
2281
2282         keydb_release (pub_hd);
2283         keydb_release (sec_hd);
2284
2285         if (!rc) {
2286             int no_enc_rsa =
2287                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2288                 && get_parameter_uint( para, pKEYUSAGE )
2289                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2290             PKT_public_key *pk = find_kbnode (pub_root,
2291                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2292
2293             update_ownertrust (pk,
2294                                ((get_ownertrust (pk) & ~TRUST_MASK)
2295                                 | TRUST_ULTIMATE ));
2296
2297             if (!opt.batch) {
2298                 tty_printf(_("public and secret key created and signed.\n") );
2299                 tty_printf(_("key marked as ultimately trusted.\n") );
2300                 tty_printf("\n");
2301                 list_keyblock(pub_root,0,1,NULL);
2302             }
2303
2304
2305             if( !opt.batch
2306                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2307                      || no_enc_rsa )
2308                 && !get_parameter( para, pSUBKEYTYPE ) )
2309             {
2310                 tty_printf(_("Note that this key cannot be used for "
2311                              "encryption.  You may want to use\n"
2312                              "the command \"--edit-key\" to generate a "
2313                              "secondary key for this purpose.\n") );
2314             }
2315         }
2316     }
2317
2318     if( rc ) {
2319         if( opt.batch )
2320             log_error("key generation failed: %s\n", g10_errstr(rc) );
2321         else
2322             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2323     }
2324     else {
2325         PKT_public_key *pk = find_kbnode (pub_root,
2326                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2327         print_status_key_created (did_sub? 'B':'P', pk);
2328     }
2329     release_kbnode( pub_root );
2330     release_kbnode( sec_root );
2331     if( sk ) /* the unprotected  secret key */
2332         free_secret_key(sk);
2333 }
2334
2335
2336 /****************
2337  * add a new subkey to an existing key.
2338  * Returns true if a new key has been generated and put into the keyblocks.
2339  */
2340 int
2341 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2342 {
2343     int okay=0, rc=0;
2344     KBNODE node;
2345     PKT_secret_key *sk = NULL; /* this is the primary sk */
2346     int algo;
2347     unsigned int use;
2348     u32 expire;
2349     unsigned nbits;
2350     char *passphrase = NULL;
2351     DEK *dek = NULL;
2352     STRING2KEY *s2k = NULL;
2353     u32 cur_time;
2354
2355     /* break out the primary secret key */
2356     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2357     if( !node ) {
2358         log_error("Oops; secret key not found anymore!\n");
2359         goto leave;
2360     }
2361
2362     /* make a copy of the sk to keep the protected one in the keyblock */
2363     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2364
2365     cur_time = make_timestamp();
2366     if( sk->timestamp > cur_time ) {
2367         ulong d = sk->timestamp - cur_time;
2368         log_info( d==1 ? _("key has been created %lu second "
2369                            "in future (time warp or clock problem)\n")
2370                        : _("key has been created %lu seconds "
2371                            "in future (time warp or clock problem)\n"), d );
2372         if( !opt.ignore_time_conflict ) {
2373             rc = G10ERR_TIME_CONFLICT;
2374             goto leave;
2375         }
2376     }
2377
2378     if (sk->version < 4) {
2379         log_info (_("NOTE: creating subkeys for v3 keys "
2380                     "is not OpenPGP compliant\n"));
2381         goto leave;
2382     }
2383
2384     /* unprotect to get the passphrase */
2385     switch( is_secret_key_protected( sk ) ) {
2386       case -1:
2387         rc = G10ERR_PUBKEY_ALGO;
2388         break;
2389       case 0:
2390         tty_printf("This key is not protected.\n");
2391         break;
2392       default:
2393         tty_printf("Key is protected.\n");
2394         rc = check_secret_key( sk, 0 );
2395         if( !rc )
2396             passphrase = get_last_passphrase();
2397         break;
2398     }
2399     if( rc )
2400         goto leave;
2401
2402
2403     algo = ask_algo( 1, &use );
2404     assert(algo);
2405     nbits = ask_keysize( algo );
2406     expire = ask_expire_interval(0);
2407     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2408                                                   _("Really create? ") ) )
2409         goto leave;
2410
2411     if( passphrase ) {
2412         s2k = m_alloc_secure( sizeof *s2k );
2413         s2k->mode = opt.s2k_mode;
2414         s2k->hash_algo = opt.s2k_digest_algo;
2415         set_next_passphrase( passphrase );
2416         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
2417     }
2418
2419     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2420                                       dek, s2k, NULL, expire );
2421     if( !rc )
2422         rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
2423     if( !rc )
2424         rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
2425     if( !rc ) {
2426         okay = 1;
2427         write_status_text (STATUS_KEY_CREATED, "S");
2428     }
2429
2430   leave:
2431     if( rc )
2432         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2433     m_free( passphrase );
2434     m_free( dek );
2435     m_free( s2k );
2436     if( sk ) /* release the copy of the (now unprotected) secret key */
2437         free_secret_key(sk);
2438     set_next_passphrase( NULL );
2439     return okay;
2440 }
2441
2442 /****************
2443  * Write a keyblock to an output stream
2444  */
2445 static int
2446 write_keyblock( IOBUF out, KBNODE node )
2447 {
2448     for( ; node ; node = node->next ) {
2449         int rc = build_packet( out, node->pkt );
2450         if( rc ) {
2451             log_error("build_packet(%d) failed: %s\n",
2452                         node->pkt->pkttype, g10_errstr(rc) );
2453             return G10ERR_WRITE_FILE;
2454         }
2455     }
2456     return 0;
2457 }