g10/keygen.c

   1 /* keygen.c - generate a key pair
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3  *               2006, 2007, 2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  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 <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31
  32 #include "gpg.h"
  33 #include "util.h"
  34 #include "main.h"
  35 #include "packet.h"
  36 #include "cipher.h"
  37 #include "ttyio.h"
  38 #include "options.h"
  39 #include "keydb.h"
  40 #include "trustdb.h"
  41 #include "status.h"
  42 #include "i18n.h"
  43 #include "keyserver-internal.h"
  44 #include "call-agent.h"
  45 #include "host2net.h"
  46
  47 /* The default algorithms.  If you change them remember to change them
  48    also in gpg.c:gpgconf_list.  You should also check that the value
  49    is inside the bounds enforced by ask_keysize and gen_xxx.  */
  50 #define DEFAULT_STD_ALGO    GCRY_PK_RSA
  51 #define DEFAULT_STD_KEYSIZE 2048
  52
  53
  54 #define MAX_PREFS 30
  55
  56 enum para_name {
  57   pKEYTYPE,
  58   pKEYLENGTH,
  59   pKEYUSAGE,
  60   pSUBKEYTYPE,
  61   pSUBKEYLENGTH,
  62   pSUBKEYUSAGE,
  63   pAUTHKEYTYPE,
  64   pNAMEREAL,
  65   pNAMEEMAIL,
  66   pNAMECOMMENT,
  67   pPREFERENCES,
  68   pREVOKER,
  69   pUSERID,
  70   pCREATIONDATE,
  71   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
  72   pEXPIREDATE,
  73   pKEYEXPIRE, /* in n seconds */
  74   pSUBKEYEXPIRE, /* in n seconds */
  75   pPASSPHRASE,
  76   pPASSPHRASE_DEK,
  77   pPASSPHRASE_S2K,
  78   pSERIALNO,
  79   pBACKUPENCDIR,
  80   pHANDLE,
  81   pKEYSERVER
  82 };
  83
  84 struct para_data_s {
  85     struct para_data_s *next;
  86     int lnr;
  87     enum para_name key;
  88     union {
  89         DEK *dek;
  90         STRING2KEY *s2k;
  91         u32 expire;
  92         u32 creation;
  93         unsigned int usage;
  94         struct revocation_key revkey;
  95         char value[1];
  96     } u;
  97 };
  98
  99 struct output_control_s {
 100     int lnr;
 101     int dryrun;
 102     int ask_passphrase;
 103     int use_files;
 104     struct {
 105         char  *fname;
 106         char  *newfname;
 107         IOBUF stream;
 108         armor_filter_context_t *afx;
 109     } pub;
 110     struct {
 111         char  *fname;
 112         char  *newfname;
 113         IOBUF stream;
 114         armor_filter_context_t *afx;
 115     } sec;
 116 };
 117
 118
 119 struct opaque_data_usage_and_pk {
 120     unsigned int usage;
 121     PKT_public_key *pk;
 122 };
 123
 124
 125 static int prefs_initialized = 0;
 126 static byte sym_prefs[MAX_PREFS];
 127 static int nsym_prefs;
 128 static byte hash_prefs[MAX_PREFS];
 129 static int nhash_prefs;
 130 static byte zip_prefs[MAX_PREFS];
 131 static int nzip_prefs;
 132 static int mdc_available,ks_modify;
 133
 134 static void do_generate_keypair( struct para_data_s *para,
 135                                  struct output_control_s *outctrl, int card );
 136 static int  write_keyblock( IOBUF out, KBNODE node );
 137 static int gen_card_key (int algo, int keyno, int is_primary,
 138                          KBNODE pub_root, KBNODE sec_root,
 139                          PKT_secret_key **ret_sk,
 140                          u32 *timestamp,
 141                          u32 expireval, struct para_data_s *para);
 142 static int gen_card_key_with_backup (int algo, int keyno, int is_primary,
 143                                      KBNODE pub_root, KBNODE sec_root,
 144                                      u32 timestamp,
 145                                      u32 expireval, struct para_data_s *para,
 146                                      const char *backup_dir);
 147
 148
 149 static void
 150 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
 151 {
 152   byte array[MAX_FINGERPRINT_LEN], *s;
 153   char *buf, *p;
 154   size_t i, n;
 155
 156   if (!handle)
 157     handle = "";
 158
 159   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
 160
 161   p = buf;
 162   if (letter || pk)
 163     {
 164       *p++ = letter;
 165       *p++ = ' ';
 166       fingerprint_from_pk (pk, array, &n);
 167       s = array;
 168       for (i=0; i < n ; i++, s++, p += 2)
 169         sprintf (p, "%02X", *s);
 170     }
 171   if (*handle)
 172     {
 173       *p++ = ' ';
 174       for (i=0; handle[i] && i < 100; i++)
 175         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
 176     }
 177   *p = 0;
 178   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
 179                      buf);
 180   xfree (buf);
 181 }
 182
 183 static void
 184 print_status_key_not_created (const char *handle)
 185 {
 186   print_status_key_created (0, NULL, handle);
 187 }
 188
 189
 190
 191 static void
 192 write_uid( KBNODE root, const char *s )
 193 {
 194     PACKET *pkt = xmalloc_clear(sizeof *pkt );
 195     size_t n = strlen(s);
 196
 197     pkt->pkttype = PKT_USER_ID;
 198     pkt->pkt.user_id = xmalloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
 199     pkt->pkt.user_id->len = n;
 200     pkt->pkt.user_id->ref = 1;
 201     strcpy(pkt->pkt.user_id->name, s);
 202     add_kbnode( root, new_kbnode( pkt ) );
 203 }
 204
 205 static void
 206 do_add_key_flags (PKT_signature *sig, unsigned int use)
 207 {
 208     byte buf[1];
 209
 210     buf[0] = 0;
 211
 212     /* The spec says that all primary keys MUST be able to certify. */
 213     if(sig->sig_class!=0x18)
 214       buf[0] |= 0x01;
 215
 216     if (use & PUBKEY_USAGE_SIG)
 217       buf[0] |= 0x02;
 218     if (use & PUBKEY_USAGE_ENC)
 219         buf[0] |= 0x04 | 0x08;
 220     if (use & PUBKEY_USAGE_AUTH)
 221         buf[0] |= 0x20;
 222
 223     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
 224 }
 225
 226
 227 int
 228 keygen_add_key_expire( PKT_signature *sig, void *opaque )
 229 {
 230     PKT_public_key *pk = opaque;
 231     byte buf[8];
 232     u32  u;
 233
 234     if( pk->expiredate ) {
 235         if(pk->expiredate > pk->timestamp)
 236           u= pk->expiredate - pk->timestamp;
 237         else
 238           u= 1;
 239
 240         buf[0] = (u >> 24) & 0xff;
 241         buf[1] = (u >> 16) & 0xff;
 242         buf[2] = (u >>  8) & 0xff;
 243         buf[3] = u & 0xff;
 244         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
 245     }
 246     else
 247       {
 248         /* Make sure we don't leave a key expiration subpacket lying
 249            around */
 250         delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
 251       }
 252
 253     return 0;
 254 }
 255
 256 static int
 257 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
 258 {
 259     struct opaque_data_usage_and_pk *oduap = opaque;
 260
 261     do_add_key_flags (sig, oduap->usage);
 262     return keygen_add_key_expire (sig, oduap->pk);
 263 }
 264
 265 static int
 266 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
 267 {
 268     int i;
 269
 270     for (i=0; i < *nbuf; i++ )
 271       if (buf[i] == val)
 272         {
 273           log_info (_("preference `%s' duplicated\n"), item);
 274           return -1;
 275         }
 276
 277     if (*nbuf >= MAX_PREFS)
 278       {
 279         if(type==1)
 280           log_info(_("too many cipher preferences\n"));
 281         else if(type==2)
 282           log_info(_("too many digest preferences\n"));
 283         else if(type==3)
 284           log_info(_("too many compression preferences\n"));
 285         else
 286           BUG();
 287
 288         return -1;
 289       }
 290
 291     buf[(*nbuf)++] = val;
 292     return 0;
 293 }
 294
 295 /*
 296  * Parse the supplied string and use it to set the standard
 297  * preferences.  The string may be in a form like the one printed by
 298  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
 299  * cipher/hash/compress names.  Use NULL to set the default
 300  * preferences.  Returns: 0 = okay
 301  */
 302 int
 303 keygen_set_std_prefs (const char *string,int personal)
 304 {
 305     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
 306     int nsym=0, nhash=0, nzip=0, val, rc=0;
 307     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
 308     char dummy_string[20*4+1]; /* Enough for 20 items. */
 309
 310     if (!string || !ascii_strcasecmp (string, "default"))
 311       {
 312         if (opt.def_preference_list)
 313           string=opt.def_preference_list;
 314         else
 315           {
 316             dummy_string[0]='\0';
 317
 318             /* The rationale why we use the order AES256,192,128 is
 319                for compatibility reasons with PGP.  If gpg would
 320                define AES128 first, we would get the somewhat
 321                confusing situation:
 322
 323                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
 324                  gpg -r gpgkey -r pgpkey  ---gives--> AES
 325
 326                Note that by using --personal-cipher-preferences it is
 327                possible to prefer AES128.
 328             */
 329
 330             /* Make sure we do not add more than 15 items here, as we
 331                could overflow the size of dummy_string.  We currently
 332                have at most 12. */
 333             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
 334               strcat(dummy_string,"S9 ");
 335             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
 336               strcat(dummy_string,"S8 ");
 337             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
 338               strcat(dummy_string,"S7 ");
 339             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_CAST5) )
 340               strcat(dummy_string,"S3 ");
 341             strcat(dummy_string,"S2 "); /* 3DES */
 342             /* If we have it, IDEA goes *after* 3DES so it won't be
 343                used unless we're encrypting along with a V3 key.
 344                Ideally, we would only put the S1 preference in if the
 345                key was RSA and <=2048 bits, as that is what won't
 346                break PGP2, but that is difficult with the current
 347                code, and not really worth checking as a non-RSA <=2048
 348                bit key wouldn't be usable by PGP2 anyway. -dms */
 349             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_IDEA) )
 350               strcat(dummy_string,"S1 ");
 351
 352
 353             /* The default hash algo order is:
 354                  SHA-256, SHA-1, SHA-384, SHA-512, SHA-224.
 355                Ordering SHA-1 before SHA-384 might be viewed as a bit
 356                strange; it is done because we expect that soon enough
 357                SHA-3 will be available and at that point there should
 358                be no more need for SHA-384 etc.  Anyway this order is
 359                just a default and can easily be changed by a config
 360                option.  */
 361             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
 362               strcat (dummy_string, "H8 ");
 363
 364             strcat (dummy_string, "H2 "); /* SHA-1 */
 365
 366             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
 367               strcat (dummy_string, "H9 ");
 368
 369             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
 370               strcat (dummy_string, "H10 ");
 371
 372             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
 373               strcat (dummy_string, "H11 ");
 374
 375
 376             /* ZLIB */
 377             strcat(dummy_string,"Z2 ");
 378
 379             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
 380               strcat(dummy_string,"Z3 ");
 381
 382             /* ZIP */
 383             strcat(dummy_string,"Z1");
 384
 385             string=dummy_string;
 386           }
 387       }
 388     else if (!ascii_strcasecmp (string, "none"))
 389         string = "";
 390
 391     if(strlen(string))
 392       {
 393         char *tok,*prefstring;
 394
 395         prefstring=xstrdup(string); /* need a writable string! */
 396
 397         while((tok=strsep(&prefstring," ,")))
 398           {
 399             if((val=string_to_cipher_algo (tok)))
 400               {
 401                 if(set_one_pref(val,1,tok,sym,&nsym))
 402                   rc=-1;
 403               }
 404             else if((val=string_to_digest_algo (tok)))
 405               {
 406                 if(set_one_pref(val,2,tok,hash,&nhash))
 407                   rc=-1;
 408               }
 409             else if((val=string_to_compress_algo(tok))>-1)
 410               {
 411                 if(set_one_pref(val,3,tok,zip,&nzip))
 412                   rc=-1;
 413               }
 414             else if (ascii_strcasecmp(tok,"mdc")==0)
 415               mdc=1;
 416             else if (ascii_strcasecmp(tok,"no-mdc")==0)
 417               mdc=0;
 418             else if (ascii_strcasecmp(tok,"ks-modify")==0)
 419               modify=1;
 420             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
 421               modify=0;
 422             else
 423               {
 424                 log_info (_("invalid item `%s' in preference string\n"),tok);
 425
 426                 /* Complain if IDEA is not available. */
 427                 if(ascii_strcasecmp(tok,"s1")==0
 428                    || ascii_strcasecmp(tok,"idea")==0)
 429                   idea_cipher_warn(1);
 430
 431                 rc=-1;
 432               }
 433           }
 434
 435         xfree(prefstring);
 436       }
 437
 438     if(!rc)
 439       {
 440         if(personal)
 441           {
 442             if(personal==PREFTYPE_SYM)
 443               {
 444                 xfree(opt.personal_cipher_prefs);
 445
 446                 if(nsym==0)
 447                   opt.personal_cipher_prefs=NULL;
 448                 else
 449                   {
 450                     int i;
 451
 452                     opt.personal_cipher_prefs=
 453                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
 454
 455                     for (i=0; i<nsym; i++)
 456                       {
 457                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
 458                         opt.personal_cipher_prefs[i].value = sym[i];
 459                       }
 460
 461                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
 462                     opt.personal_cipher_prefs[i].value = 0;
 463                   }
 464               }
 465             else if(personal==PREFTYPE_HASH)
 466               {
 467                 xfree(opt.personal_digest_prefs);
 468
 469                 if(nhash==0)
 470                   opt.personal_digest_prefs=NULL;
 471                 else
 472                   {
 473                     int i;
 474
 475                     opt.personal_digest_prefs=
 476                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
 477
 478                     for (i=0; i<nhash; i++)
 479                       {
 480                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
 481                         opt.personal_digest_prefs[i].value = hash[i];
 482                       }
 483
 484                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
 485                     opt.personal_digest_prefs[i].value = 0;
 486                   }
 487               }
 488             else if(personal==PREFTYPE_ZIP)
 489               {
 490                 xfree(opt.personal_compress_prefs);
 491
 492                 if(nzip==0)
 493                   opt.personal_compress_prefs=NULL;
 494                 else
 495                   {
 496                     int i;
 497
 498                     opt.personal_compress_prefs=
 499                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
 500
 501                     for (i=0; i<nzip; i++)
 502                       {
 503                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
 504                         opt.personal_compress_prefs[i].value = zip[i];
 505                       }
 506
 507                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
 508                     opt.personal_compress_prefs[i].value = 0;
 509                   }
 510               }
 511           }
 512         else
 513           {
 514             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
 515             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
 516             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
 517             mdc_available = mdc;
 518             ks_modify = modify;
 519             prefs_initialized = 1;
 520           }
 521       }
 522
 523     return rc;
 524 }
 525
 526 /* Return a fake user ID containing the preferences.  Caller must
 527    free. */
 528 PKT_user_id *
 529 keygen_get_std_prefs(void)
 530 {
 531   int i,j=0;
 532   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
 533
 534   if(!prefs_initialized)
 535     keygen_set_std_prefs(NULL,0);
 536
 537   uid->ref=1;
 538
 539   uid->prefs=xmalloc((sizeof(prefitem_t *)*
 540                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
 541
 542   for(i=0;i<nsym_prefs;i++,j++)
 543     {
 544       uid->prefs[j].type=PREFTYPE_SYM;
 545       uid->prefs[j].value=sym_prefs[i];
 546     }
 547
 548   for(i=0;i<nhash_prefs;i++,j++)
 549     {
 550       uid->prefs[j].type=PREFTYPE_HASH;
 551       uid->prefs[j].value=hash_prefs[i];
 552     }
 553
 554   for(i=0;i<nzip_prefs;i++,j++)
 555     {
 556       uid->prefs[j].type=PREFTYPE_ZIP;
 557       uid->prefs[j].value=zip_prefs[i];
 558     }
 559
 560   uid->prefs[j].type=PREFTYPE_NONE;
 561   uid->prefs[j].value=0;
 562
 563   uid->flags.mdc=mdc_available;
 564   uid->flags.ks_modify=ks_modify;
 565
 566   return uid;
 567 }
 568
 569 static void
 570 add_feature_mdc (PKT_signature *sig,int enabled)
 571 {
 572     const byte *s;
 573     size_t n;
 574     int i;
 575     char *buf;
 576
 577     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
 578     /* Already set or cleared */
 579     if (s && n &&
 580         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
 581       return;
 582
 583     if (!s || !n) { /* create a new one */
 584         n = 1;
 585         buf = xmalloc_clear (n);
 586     }
 587     else {
 588         buf = xmalloc (n);
 589         memcpy (buf, s, n);
 590     }
 591
 592     if(enabled)
 593       buf[0] |= 0x01; /* MDC feature */
 594     else
 595       buf[0] &= ~0x01;
 596
 597     /* Are there any bits set? */
 598     for(i=0;i<n;i++)
 599       if(buf[i]!=0)
 600         break;
 601
 602     if(i==n)
 603       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
 604     else
 605       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 606
 607     xfree (buf);
 608 }
 609
 610 static void
 611 add_keyserver_modify (PKT_signature *sig,int enabled)
 612 {
 613   const byte *s;
 614   size_t n;
 615   int i;
 616   char *buf;
 617
 618   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
 619   enabled=!enabled;
 620
 621   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
 622   /* Already set or cleared */
 623   if (s && n &&
 624       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
 625     return;
 626
 627   if (!s || !n) { /* create a new one */
 628     n = 1;
 629     buf = xmalloc_clear (n);
 630   }
 631   else {
 632     buf = xmalloc (n);
 633     memcpy (buf, s, n);
 634   }
 635
 636   if(enabled)
 637     buf[0] |= 0x80; /* no-modify flag */
 638   else
 639     buf[0] &= ~0x80;
 640
 641   /* Are there any bits set? */
 642   for(i=0;i<n;i++)
 643     if(buf[i]!=0)
 644       break;
 645
 646   if(i==n)
 647     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
 648   else
 649     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
 650
 651   xfree (buf);
 652 }
 653
 654
 655 int
 656 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
 657 {
 658   (void)opaque;
 659
 660   if (!prefs_initialized)
 661     keygen_set_std_prefs (NULL, 0);
 662
 663   if (nsym_prefs)
 664     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
 665   else
 666     {
 667       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
 668       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
 669     }
 670
 671   if (nhash_prefs)
 672     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
 673   else
 674     {
 675       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
 676       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
 677     }
 678
 679   if (nzip_prefs)
 680     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
 681   else
 682     {
 683       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
 684       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
 685     }
 686
 687   /* Make sure that the MDC feature flag is set if needed.  */
 688   add_feature_mdc (sig,mdc_available);
 689   add_keyserver_modify (sig,ks_modify);
 690   keygen_add_keyserver_url(sig,NULL);
 691
 692   return 0;
 693 }
 694
 695
 696 /****************
 697  * Add preference to the self signature packet.
 698  * This is only called for packets with version > 3.
 699
 700  */
 701 int
 702 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
 703 {
 704     PKT_public_key *pk = opaque;
 705
 706     do_add_key_flags (sig, pk->pubkey_usage);
 707     keygen_add_key_expire( sig, opaque );
 708     keygen_upd_std_prefs (sig, opaque);
 709     keygen_add_keyserver_url(sig,NULL);
 710
 711     return 0;
 712 }
 713
 714 int
 715 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
 716 {
 717   const char *url=opaque;
 718
 719   if(!url)
 720     url=opt.def_keyserver_url;
 721
 722   if(url)
 723     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
 724   else
 725     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
 726
 727   return 0;
 728 }
 729
 730 int
 731 keygen_add_notations(PKT_signature *sig,void *opaque)
 732 {
 733   struct notation *notation;
 734
 735   /* We always start clean */
 736   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
 737   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
 738   sig->flags.notation=0;
 739
 740   for(notation=opaque;notation;notation=notation->next)
 741     if(!notation->flags.ignore)
 742       {
 743         unsigned char *buf;
 744         unsigned int n1,n2;
 745
 746         n1=strlen(notation->name);
 747         if(notation->altvalue)
 748           n2=strlen(notation->altvalue);
 749         else if(notation->bdat)
 750           n2=notation->blen;
 751         else
 752           n2=strlen(notation->value);
 753
 754         buf = xmalloc( 8 + n1 + n2 );
 755
 756         /* human readable or not */
 757         buf[0] = notation->bdat?0:0x80;
 758         buf[1] = buf[2] = buf[3] = 0;
 759         buf[4] = n1 >> 8;
 760         buf[5] = n1;
 761         buf[6] = n2 >> 8;
 762         buf[7] = n2;
 763         memcpy(buf+8, notation->name, n1 );
 764         if(notation->altvalue)
 765           memcpy(buf+8+n1, notation->altvalue, n2 );
 766         else if(notation->bdat)
 767           memcpy(buf+8+n1, notation->bdat, n2 );
 768         else
 769           memcpy(buf+8+n1, notation->value, n2 );
 770         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
 771                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
 772                           buf, 8+n1+n2 );
 773         xfree(buf);
 774       }
 775
 776   return 0;
 777 }
 778
 779 int
 780 keygen_add_revkey(PKT_signature *sig, void *opaque)
 781 {
 782   struct revocation_key *revkey=opaque;
 783   byte buf[2+MAX_FINGERPRINT_LEN];
 784
 785   buf[0]=revkey->class;
 786   buf[1]=revkey->algid;
 787   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
 788
 789   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
 790
 791   /* All sigs with revocation keys set are nonrevocable */
 792   sig->flags.revocable=0;
 793   buf[0] = 0;
 794   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
 795
 796   parse_revkeys(sig);
 797
 798   return 0;
 799 }
 800
 801
 802
 803 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
 804    signature creation time.  */
 805 int
 806 make_backsig (PKT_signature *sig,PKT_public_key *pk,
 807               PKT_public_key *sub_pk,PKT_secret_key *sub_sk,
 808               u32 timestamp)
 809 {
 810   PKT_signature *backsig;
 811   int rc;
 812
 813   cache_public_key(sub_pk);
 814
 815   rc = make_keysig_packet (&backsig, pk, NULL, sub_pk, sub_sk, 0x19,
 816                            0, 0, timestamp, 0, NULL, NULL);
 817   if(rc)
 818     log_error("make_keysig_packet failed for backsig: %s\n",g10_errstr(rc));
 819   else
 820     {
 821       /* Get it into a binary packed form. */
 822       IOBUF backsig_out=iobuf_temp();
 823       PACKET backsig_pkt;
 824
 825       init_packet(&backsig_pkt);
 826       backsig_pkt.pkttype=PKT_SIGNATURE;
 827       backsig_pkt.pkt.signature=backsig;
 828       rc=build_packet(backsig_out,&backsig_pkt);
 829       free_packet(&backsig_pkt);
 830       if(rc)
 831         log_error("build_packet failed for backsig: %s\n",g10_errstr(rc));
 832       else
 833         {
 834           size_t pktlen=0;
 835           byte *buf=iobuf_get_temp_buffer(backsig_out);
 836
 837           /* Remove the packet header */
 838           if(buf[0]&0x40)
 839             {
 840               if(buf[1]<192)
 841                 {
 842                   pktlen=buf[1];
 843                   buf+=2;
 844                 }
 845               else if(buf[1]<224)
 846                 {
 847                   pktlen=(buf[1]-192)*256;
 848                   pktlen+=buf[2]+192;
 849                   buf+=3;
 850                 }
 851               else if(buf[1]==255)
 852                 {
 853                   pktlen = buf32_to_size_t (buf+2);
 854                   buf+=6;
 855                 }
 856               else
 857                 BUG();
 858             }
 859           else
 860             {
 861               int mark=1;
 862
 863               switch(buf[0]&3)
 864                 {
 865                 case 3:
 866                   BUG();
 867                   break;
 868
 869                 case 2:
 870                   pktlen  = (size_t)buf[mark++] << 24;
 871                   pktlen |= buf[mark++] << 16;
 872
 873                 case 1:
 874                   pktlen |= buf[mark++] << 8;
 875
 876                 case 0:
 877                   pktlen |= buf[mark++];
 878                 }
 879
 880               buf+=mark;
 881             }
 882
 883           /* Now make the binary blob into a subpacket.  */
 884           build_sig_subpkt(sig,SIGSUBPKT_SIGNATURE,buf,pktlen);
 885
 886           iobuf_close(backsig_out);
 887         }
 888     }
 889
 890   return rc;
 891 }
 892
 893
 894 static int
 895 write_direct_sig (KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
 896                   struct revocation_key *revkey, u32 timestamp)
 897 {
 898   PACKET *pkt;
 899   PKT_signature *sig;
 900   int rc=0;
 901   KBNODE node;
 902   PKT_public_key *pk;
 903
 904   if( opt.verbose )
 905     log_info(_("writing direct signature\n"));
 906
 907   /* Get the pk packet from the pub_tree. */
 908   node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
 909   if( !node )
 910     BUG();
 911   pk = node->pkt->pkt.public_key;
 912
 913   /* We have to cache the key, so that the verification of the
 914      signature creation is able to retrieve the public key.  */
 915   cache_public_key (pk);
 916
 917   /* Make the signature.  */
 918   rc = make_keysig_packet (&sig,pk,NULL,NULL,sk,0x1F,
 919                            0, 0, timestamp, 0,
 920                            keygen_add_revkey, revkey);
 921   if( rc )
 922     {
 923       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
 924       return rc;
 925     }
 926
 927   pkt = xmalloc_clear( sizeof *pkt );
 928   pkt->pkttype = PKT_SIGNATURE;
 929   pkt->pkt.signature = sig;
 930   add_kbnode( root, new_kbnode( pkt ) );
 931   return rc;
 932 }
 933
 934
 935 static int
 936 write_selfsigs( KBNODE sec_root, KBNODE pub_root, PKT_secret_key *sk,
 937                 unsigned int use, u32 timestamp )
 938 {
 939   PACKET *pkt;
 940   PKT_signature *sig;
 941   PKT_user_id *uid;
 942   int rc=0;
 943   KBNODE node;
 944   PKT_public_key *pk;
 945
 946   if( opt.verbose )
 947     log_info(_("writing self signature\n"));
 948
 949   /* Get the uid packet from the list. */
 950   node = find_kbnode( pub_root, PKT_USER_ID );
 951   if( !node )
 952     BUG(); /* No user id packet in tree.  */
 953   uid = node->pkt->pkt.user_id;
 954
 955   /* Get the pk packet from the pub_tree. */
 956   node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
 957   if( !node )
 958     BUG();
 959   pk = node->pkt->pkt.public_key;
 960   pk->pubkey_usage = use;
 961
 962   /* We have to cache the key, so that the verification of the
 963      signature creation is able to retrieve the public key.  */
 964   cache_public_key (pk);
 965
 966   /* Make the signature.  */
 967   rc = make_keysig_packet (&sig, pk, uid, NULL, sk, 0x13,
 968                            0, 0, timestamp, 0,
 969                            keygen_add_std_prefs, pk);
 970   if( rc )
 971     {
 972       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
 973       return rc;
 974     }
 975
 976   pkt = xmalloc_clear( sizeof *pkt );
 977   pkt->pkttype = PKT_SIGNATURE;
 978   pkt->pkt.signature = sig;
 979   add_kbnode( sec_root, new_kbnode( pkt ) );
 980
 981   pkt = xmalloc_clear( sizeof *pkt );
 982   pkt->pkttype = PKT_SIGNATURE;
 983   pkt->pkt.signature = copy_signature(NULL,sig);
 984   add_kbnode( pub_root, new_kbnode( pkt ) );
 985   return rc;
 986 }
 987
 988
 989 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
 990    signature creation times.  */
 991 static int
 992 write_keybinding (KBNODE root, KBNODE pub_root,
 993                   PKT_secret_key *pri_sk, PKT_secret_key *sub_sk,
 994                   unsigned int use, u32 timestamp)
 995 {
 996   PACKET *pkt;
 997   PKT_signature *sig;
 998   int rc=0;
 999   KBNODE node;
1000   PKT_public_key *pri_pk, *sub_pk;
1001   struct opaque_data_usage_and_pk oduap;
1002
1003   if ( opt.verbose )
1004     log_info(_("writing key binding signature\n"));
1005
1006   /* Get the pk packet from the pub_tree.  */
1007   node = find_kbnode ( pub_root, PKT_PUBLIC_KEY );
1008   if ( !node )
1009     BUG();
1010   pri_pk = node->pkt->pkt.public_key;
1011
1012   /* We have to cache the key, so that the verification of the
1013    * signature creation is able to retrieve the public key.  */
1014   cache_public_key (pri_pk);
1015
1016   /* Find the last subkey. */
1017   sub_pk = NULL;
1018   for (node=pub_root; node; node = node->next )
1019     {
1020       if ( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1021         sub_pk = node->pkt->pkt.public_key;
1022     }
1023   if (!sub_pk)
1024     BUG();
1025
1026   /* Make the signature.  */
1027   oduap.usage = use;
1028   oduap.pk = sub_pk;
1029   rc = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_sk, 0x18,
1030                            0, 0, timestamp, 0,
1031                            keygen_add_key_flags_and_expire, &oduap );
1032   if (rc)
1033     {
1034       log_error ("make_keysig_packet failed: %s\n", g10_errstr(rc) );
1035       return rc;
1036     }
1037
1038   /* Make a backsig.  */
1039   if (use&PUBKEY_USAGE_SIG)
1040     {
1041       rc = make_backsig (sig, pri_pk, sub_pk, sub_sk, timestamp);
1042       if (rc)
1043         return rc;
1044     }
1045
1046   pkt = xmalloc_clear ( sizeof *pkt );
1047   pkt->pkttype = PKT_SIGNATURE;
1048   pkt->pkt.signature = sig;
1049   add_kbnode (root, new_kbnode (pkt) );
1050   return rc;
1051 }
1052
1053
1054
1055 static int
1056 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1057                const char *topname, const char *elems)
1058 {
1059   gcry_sexp_t list, l2;
1060   const char *s;
1061   int i, idx;
1062   int rc = 0;
1063
1064   list = gcry_sexp_find_token (sexp, topname, 0);
1065   if (!list)
1066     return gpg_error (GPG_ERR_INV_OBJ);
1067   l2 = gcry_sexp_cadr (list);
1068   gcry_sexp_release (list);
1069   list = l2;
1070   if (!list)
1071     return gpg_error (GPG_ERR_NO_OBJ);
1072
1073   for (idx=0,s=elems; *s; s++, idx++)
1074     {
1075       l2 = gcry_sexp_find_token (list, s, 1);
1076       if (!l2)
1077         {
1078           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1079           goto leave;
1080         }
1081       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1082       gcry_sexp_release (l2);
1083       if (!array[idx])
1084         {
1085           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1086           goto leave;
1087         }
1088     }
1089   gcry_sexp_release (list);
1090
1091  leave:
1092   if (rc)
1093     {
1094       for (i=0; i<idx; i++)
1095         {
1096           gcry_mpi_release (array[i]);
1097           array[i] = NULL;
1098         }
1099       gcry_sexp_release (list);
1100     }
1101   return rc;
1102 }
1103
1104
1105 static int
1106 genhelp_protect (DEK *dek, STRING2KEY *s2k, PKT_secret_key *sk)
1107 {
1108   int rc = 0;
1109
1110   if (dek)
1111     {
1112       sk->protect.algo = dek->algo;
1113       sk->protect.s2k = *s2k;
1114       rc = protect_secret_key (sk, dek);
1115       if (rc)
1116         log_error ("protect_secret_key failed: %s\n", gpg_strerror (rc) );
1117     }
1118
1119   return rc;
1120 }
1121
1122 static void
1123 genhelp_factors (gcry_sexp_t misc_key_info, KBNODE sec_root)
1124 {
1125   (void)misc_key_info;
1126   (void)sec_root;
1127 #if 0 /* Not used anymore */
1128   size_t n;
1129   char *buf;
1130
1131   if (misc_key_info)
1132     {
1133       /* DSA: don't know whether it makes sense to have the factors, so for now
1134          we store them in the secret keyring (but they are not secret)
1135          p = 2 * q * f1 * f2 * ... * fn
1136          We store only f1 to f_n-1;  fn can be calculated because p and q
1137          are known. */
1138       n = gcry_sexp_sprint (misc_key_info, 0, NULL, 0);
1139       buf = xmalloc (n+4);
1140       strcpy (buf, "#::");
1141       n = gcry_sexp_sprint (misc_key_info, 0, buf+3, n);
1142       if (n)
1143         {
1144           n += 3;
1145           add_kbnode (sec_root, make_comment_node_from_buffer (buf, n));
1146         }
1147       xfree (buf);
1148       gcry_sexp_release (misc_key_info);
1149     }
1150 #endif
1151 }
1152
1153
1154 /* Generate an Elgamal encryption key pair. TIMESTAMP is the creatuion
1155    time to be put into the key structure.  */
1156 static int
1157 gen_elg (int algo, unsigned int nbits,
1158          KBNODE pub_root, KBNODE sec_root, DEK *dek,
1159          STRING2KEY *s2k, PKT_secret_key **ret_sk,
1160          u32 timestamp, u32 expireval, int is_subkey)
1161 {
1162   int rc;
1163   PACKET *pkt;
1164   PKT_secret_key *sk;
1165   PKT_public_key *pk;
1166   gcry_sexp_t s_parms, s_key;
1167   gcry_sexp_t misc_key_info;
1168
1169   assert( is_ELGAMAL(algo) );
1170
1171   if (nbits < 1024)
1172     {
1173       nbits = 2048;
1174       log_info (_("keysize invalid; using %u bits\n"), nbits );
1175     }
1176   else if (nbits > 4096)
1177     {
1178       nbits = 4096;
1179       log_info (_("keysize invalid; using %u bits\n"), nbits );
1180     }
1181
1182   if ((nbits % 32))
1183     {
1184       nbits = ((nbits + 31) / 32) * 32;
1185       log_info (_("keysize rounded up to %u bits\n"), nbits );
1186     }
1187
1188
1189   rc = gcry_sexp_build ( &s_parms, NULL,
1190                          "(genkey(%s(nbits %d)))",
1191                          algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1192                          algo == GCRY_PK_ELG     ? "elg" : "x-oops" ,
1193                          (int)nbits);
1194   if (rc)
1195     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1196
1197   rc = gcry_pk_genkey (&s_key, s_parms);
1198   gcry_sexp_release (s_parms);
1199   if (rc)
1200     {
1201       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1202       return rc;
1203     }
1204
1205   sk = xmalloc_clear( sizeof *sk );
1206   pk = xmalloc_clear( sizeof *pk );
1207   sk->timestamp = pk->timestamp = timestamp;
1208   sk->version = pk->version = 4;
1209   if (expireval)
1210     {
1211       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1212     }
1213   sk->pubkey_algo = pk->pubkey_algo = algo;
1214
1215   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pgy");
1216   if (rc)
1217     {
1218       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1219       gcry_sexp_release (s_key);
1220       free_secret_key (sk);
1221       free_public_key (pk);
1222       return rc;
1223     }
1224   rc = key_from_sexp (sk->skey, s_key, "private-key", "pgyx");
1225   if (rc)
1226     {
1227       log_error("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1228       gcry_sexp_release (s_key);
1229       free_secret_key (sk);
1230       free_public_key (pk);
1231       return rc;
1232     }
1233   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1234   gcry_sexp_release (s_key);
1235
1236   sk->is_protected = 0;
1237   sk->protect.algo = 0;
1238
1239   sk->csum = checksum_mpi (sk->skey[3]);
1240   if (ret_sk) /* Return an unprotected version of the sk.  */
1241     *ret_sk = copy_secret_key ( NULL, sk );
1242
1243   rc = genhelp_protect (dek, s2k, sk);
1244   if (rc)
1245     {
1246       free_public_key (pk);
1247       free_secret_key (sk);
1248       gcry_sexp_release (misc_key_info);
1249       return rc;
1250     }
1251
1252   pkt = xmalloc_clear (sizeof *pkt);
1253   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1254   pkt->pkt.public_key = pk;
1255   add_kbnode (pub_root, new_kbnode( pkt ));
1256
1257   /* Don't know whether it makes sense to have access to the factors,
1258      so for now we store them in the secret keyring (but they are not
1259      secret).  */
1260   pkt = xmalloc_clear (sizeof *pkt);
1261   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1262   pkt->pkt.secret_key = sk;
1263   add_kbnode (sec_root, new_kbnode( pkt ));
1264
1265   genhelp_factors (misc_key_info, sec_root);
1266
1267   return 0;
1268 }
1269
1270
1271 /****************
1272  * Generate a DSA key
1273  */
1274 static int
1275 gen_dsa (unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1276          STRING2KEY *s2k, PKT_secret_key **ret_sk,
1277          u32 timestamp, u32 expireval, int is_subkey)
1278 {
1279   int rc;
1280   PACKET *pkt;
1281   PKT_secret_key *sk;
1282   PKT_public_key *pk;
1283   gcry_sexp_t s_parms, s_key;
1284   gcry_sexp_t misc_key_info;
1285   unsigned int qbits;
1286
1287   if (nbits < 768)
1288     {
1289       nbits = 2048;
1290       log_info(_("keysize invalid; using %u bits\n"), nbits );
1291     }
1292   else if ( nbits > 3072 )
1293     {
1294       nbits = 3072;
1295       log_info(_("keysize invalid; using %u bits\n"), nbits );
1296     }
1297
1298   if( (nbits % 64) )
1299     {
1300       nbits = ((nbits + 63) / 64) * 64;
1301       log_info(_("keysize rounded up to %u bits\n"), nbits );
1302     }
1303
1304   /* To comply with FIPS rules we round up to the next value unless in
1305      expert mode.  */
1306   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1307     {
1308       nbits = ((nbits + 1023) / 1024) * 1024;
1309       log_info(_("keysize rounded up to %u bits\n"), nbits );
1310     }
1311
1312   /*
1313     Figure out a q size based on the key size.  FIPS 180-3 says:
1314
1315     L = 1024, N = 160
1316     L = 2048, N = 224
1317     L = 2048, N = 256
1318     L = 3072, N = 256
1319
1320     2048/256 is an odd pair since there is also a 2048/224 and
1321     3072/256.  Matching sizes is not a very exact science.
1322
1323     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1324     but less than 2048, and 160 for 1024 (DSA1).
1325   */
1326
1327   if (nbits > 2047)
1328     qbits = 256;
1329   else if ( nbits > 1024)
1330     qbits = 224;
1331   else
1332     qbits = 160;
1333
1334   if (qbits != 160 )
1335     log_info (_("WARNING: some OpenPGP programs can't"
1336                 " handle a DSA key with this digest size\n"));
1337
1338   rc = gcry_sexp_build (&s_parms, NULL,
1339                         "(genkey(dsa(nbits %d)(qbits %d)))",
1340                         (int)nbits, (int)qbits);
1341   if (rc)
1342     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1343
1344   rc = gcry_pk_genkey (&s_key, s_parms);
1345   gcry_sexp_release (s_parms);
1346   if (rc)
1347     {
1348       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1349       return rc;
1350     }
1351
1352   sk = xmalloc_clear( sizeof *sk );
1353   pk = xmalloc_clear( sizeof *pk );
1354   sk->timestamp = pk->timestamp = timestamp;
1355   sk->version = pk->version = 4;
1356   if (expireval)
1357     sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1358   sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
1359
1360   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pqgy");
1361   if (rc)
1362     {
1363       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1364       gcry_sexp_release (s_key);
1365       free_public_key(pk);
1366       free_secret_key(sk);
1367       return rc;
1368     }
1369   rc = key_from_sexp (sk->skey, s_key, "private-key", "pqgyx");
1370   if (rc)
1371     {
1372       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1373       gcry_sexp_release (s_key);
1374       free_public_key(pk);
1375       free_secret_key(sk);
1376       return rc;
1377     }
1378   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1379   gcry_sexp_release (s_key);
1380
1381   sk->is_protected = 0;
1382   sk->protect.algo = 0;
1383
1384   sk->csum = checksum_mpi ( sk->skey[4] );
1385   if( ret_sk ) /* return an unprotected version of the sk */
1386     *ret_sk = copy_secret_key( NULL, sk );
1387
1388   rc = genhelp_protect (dek, s2k, sk);
1389   if (rc)
1390     {
1391       free_public_key (pk);
1392       free_secret_key (sk);
1393       gcry_sexp_release (misc_key_info);
1394       return rc;
1395     }
1396
1397   pkt = xmalloc_clear(sizeof *pkt);
1398   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1399   pkt->pkt.public_key = pk;
1400   add_kbnode(pub_root, new_kbnode( pkt ));
1401
1402   /* Don't know whether it makes sense to have the factors, so for now
1403    * we store them in the secret keyring (but they are not secret)
1404    * p = 2 * q * f1 * f2 * ... * fn
1405    * We store only f1 to f_n-1;  fn can be calculated because p and q
1406    * are known.
1407    */
1408   pkt = xmalloc_clear(sizeof *pkt);
1409   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1410   pkt->pkt.secret_key = sk;
1411   add_kbnode(sec_root, new_kbnode( pkt ));
1412
1413   genhelp_factors (misc_key_info, sec_root);
1414
1415   return 0;
1416 }
1417
1418
1419 /*
1420  * Generate an RSA key.
1421  */
1422 static int
1423 gen_rsa (int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1424          STRING2KEY *s2k, PKT_secret_key **ret_sk,
1425          u32 timestamp, u32 expireval, int is_subkey)
1426 {
1427   int rc;
1428   PACKET *pkt;
1429   PKT_secret_key *sk;
1430   PKT_public_key *pk;
1431   gcry_sexp_t s_parms, s_key;
1432   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
1433
1434   assert (is_RSA(algo));
1435
1436   if (!nbits)
1437     nbits = DEFAULT_STD_KEYSIZE;
1438
1439   if (nbits < 1024)
1440     {
1441       nbits = 2048;
1442       log_info (_("keysize invalid; using %u bits\n"), nbits );
1443     }
1444   else if (nbits > maxsize)
1445     {
1446       nbits = maxsize;
1447       log_info (_("keysize invalid; using %u bits\n"), nbits );
1448     }
1449
1450   if ((nbits % 32))
1451     {
1452       nbits = ((nbits + 31) / 32) * 32;
1453       log_info (_("keysize rounded up to %u bits\n"), nbits );
1454     }
1455
1456   rc = gcry_sexp_build (&s_parms, NULL,
1457                         "(genkey(rsa(nbits %d)))",
1458                         (int)nbits);
1459   if (rc)
1460     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1461
1462   rc = gcry_pk_genkey (&s_key, s_parms);
1463   gcry_sexp_release (s_parms);
1464   if (rc)
1465     {
1466       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1467       return rc;
1468     }
1469
1470   sk = xmalloc_clear( sizeof *sk );
1471   pk = xmalloc_clear( sizeof *pk );
1472   sk->timestamp = pk->timestamp = timestamp;
1473   sk->version = pk->version = 4;
1474   if (expireval)
1475     {
1476       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1477     }
1478   sk->pubkey_algo = pk->pubkey_algo = algo;
1479
1480   rc = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
1481   if (rc)
1482     {
1483       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1484       gcry_sexp_release (s_key);
1485       free_public_key(pk);
1486       free_secret_key(sk);
1487       return rc;
1488     }
1489   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
1490   if (rc)
1491     {
1492       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1493       gcry_sexp_release (s_key);
1494       free_public_key(pk);
1495       free_secret_key(sk);
1496       return rc;
1497     }
1498   gcry_sexp_release (s_key);
1499
1500   sk->is_protected = 0;
1501   sk->protect.algo = 0;
1502
1503   sk->csum  = checksum_mpi (sk->skey[2] );
1504   sk->csum += checksum_mpi (sk->skey[3] );
1505   sk->csum += checksum_mpi (sk->skey[4] );
1506   sk->csum += checksum_mpi (sk->skey[5] );
1507   if( ret_sk ) /* return an unprotected version of the sk */
1508     *ret_sk = copy_secret_key( NULL, sk );
1509
1510   rc = genhelp_protect (dek, s2k, sk);
1511   if (rc)
1512     {
1513       free_public_key (pk);
1514       free_secret_key (sk);
1515       return rc;
1516     }
1517
1518   pkt = xmalloc_clear(sizeof *pkt);
1519   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1520   pkt->pkt.public_key = pk;
1521   add_kbnode(pub_root, new_kbnode( pkt ));
1522
1523   pkt = xmalloc_clear(sizeof *pkt);
1524   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1525   pkt->pkt.secret_key = sk;
1526   add_kbnode(sec_root, new_kbnode( pkt ));
1527
1528   return 0;
1529 }
1530
1531
1532 /****************
1533  * check valid days:
1534  * return 0 on error or the multiplier
1535  */
1536 static int
1537 check_valid_days( const char *s )
1538 {
1539     if( !digitp(s) )
1540         return 0;
1541     for( s++; *s; s++)
1542         if( !digitp(s) )
1543             break;
1544     if( !*s )
1545         return 1;
1546     if( s[1] )
1547         return 0; /* e.g. "2323wc" */
1548     if( *s == 'd' || *s == 'D' )
1549         return 1;
1550     if( *s == 'w' || *s == 'W' )
1551         return 7;
1552     if( *s == 'm' || *s == 'M' )
1553         return 30;
1554     if( *s == 'y' || *s == 'Y' )
1555         return 365;
1556     return 0;
1557 }
1558
1559
1560 static void
1561 print_key_flags(int flags)
1562 {
1563   if(flags&PUBKEY_USAGE_SIG)
1564     tty_printf("%s ",_("Sign"));
1565
1566   if(flags&PUBKEY_USAGE_CERT)
1567     tty_printf("%s ",_("Certify"));
1568
1569   if(flags&PUBKEY_USAGE_ENC)
1570     tty_printf("%s ",_("Encrypt"));
1571
1572   if(flags&PUBKEY_USAGE_AUTH)
1573     tty_printf("%s ",_("Authenticate"));
1574 }
1575
1576
1577 /* Returns the key flags */
1578 static unsigned int
1579 ask_key_flags(int algo,int subkey)
1580 {
1581   /* TRANSLATORS: Please use only plain ASCII characters for the
1582      translation.  If this is not possible use single digits.  The
1583      string needs to 8 bytes long. Here is a description of the
1584      functions:
1585
1586        s = Toggle signing capability
1587        e = Toggle encryption capability
1588        a = Toggle authentication capability
1589        q = Finish
1590   */
1591   const char *togglers=_("SsEeAaQq");
1592   char *answer=NULL;
1593   const char *s;
1594   unsigned int current=0;
1595   unsigned int possible=openpgp_pk_algo_usage(algo);
1596
1597   if ( strlen(togglers) != 8 )
1598     {
1599       tty_printf ("NOTE: Bad translation at %s:%d. "
1600                   "Please report.\n", __FILE__, __LINE__);
1601       togglers = "11223300";
1602     }
1603
1604   /* Only primary keys may certify. */
1605   if(subkey)
1606     possible&=~PUBKEY_USAGE_CERT;
1607
1608   /* Preload the current set with the possible set, minus
1609      authentication, since nobody really uses auth yet. */
1610   current=possible&~PUBKEY_USAGE_AUTH;
1611
1612   for(;;)
1613     {
1614       tty_printf("\n");
1615       tty_printf(_("Possible actions for a %s key: "),
1616                  openpgp_pk_algo_name (algo));
1617       print_key_flags(possible);
1618       tty_printf("\n");
1619       tty_printf(_("Current allowed actions: "));
1620       print_key_flags(current);
1621       tty_printf("\n\n");
1622
1623       if(possible&PUBKEY_USAGE_SIG)
1624         tty_printf(_("   (%c) Toggle the sign capability\n"),
1625                    togglers[0]);
1626       if(possible&PUBKEY_USAGE_ENC)
1627         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1628                    togglers[2]);
1629       if(possible&PUBKEY_USAGE_AUTH)
1630         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1631                    togglers[4]);
1632
1633       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1634       tty_printf("\n");
1635
1636       xfree(answer);
1637       answer = cpr_get("keygen.flags",_("Your selection? "));
1638       cpr_kill_prompt();
1639
1640       if (*answer == '=')
1641         {
1642           /* Hack to allow direct entry of the capabilities.  */
1643           current = 0;
1644           for (s=answer+1; *s; s++)
1645             {
1646               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
1647                 current |= PUBKEY_USAGE_SIG;
1648               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
1649                 current |= PUBKEY_USAGE_ENC;
1650               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
1651                 current |= PUBKEY_USAGE_AUTH;
1652             }
1653           break;
1654         }
1655       else if (strlen(answer)>1)
1656         tty_printf(_("Invalid selection.\n"));
1657       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1658         break;
1659       else if((*answer==togglers[0] || *answer==togglers[1])
1660               && possible&PUBKEY_USAGE_SIG)
1661         {
1662           if(current&PUBKEY_USAGE_SIG)
1663             current&=~PUBKEY_USAGE_SIG;
1664           else
1665             current|=PUBKEY_USAGE_SIG;
1666         }
1667       else if((*answer==togglers[2] || *answer==togglers[3])
1668               && possible&PUBKEY_USAGE_ENC)
1669         {
1670           if(current&PUBKEY_USAGE_ENC)
1671             current&=~PUBKEY_USAGE_ENC;
1672           else
1673             current|=PUBKEY_USAGE_ENC;
1674         }
1675       else if((*answer==togglers[4] || *answer==togglers[5])
1676               && possible&PUBKEY_USAGE_AUTH)
1677         {
1678           if(current&PUBKEY_USAGE_AUTH)
1679             current&=~PUBKEY_USAGE_AUTH;
1680           else
1681             current|=PUBKEY_USAGE_AUTH;
1682         }
1683       else
1684         tty_printf(_("Invalid selection.\n"));
1685     }
1686
1687   xfree(answer);
1688
1689   return current;
1690 }
1691
1692
1693 /* Ask for an algorithm.  The function returns the algorithm id to
1694  * create. If ADDMODE is false the function won't show an option to
1695  * create the primary and subkey combined and won't set R_USAGE
1696  * either.  If a combined algorithm has been selected, the subkey
1697  * algorithm is stored at R_SUBKEY_ALGO.  */
1698 static int
1699 ask_algo (int addmode, int *r_subkey_algo, unsigned int *r_usage)
1700 {
1701   char *answer = NULL;
1702   int algo;
1703   int dummy_algo;
1704
1705   if (!r_subkey_algo)
1706     r_subkey_algo = &dummy_algo;
1707
1708   tty_printf (_("Please select what kind of key you want:\n"));
1709
1710   if (!addmode)
1711     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1712   if (!addmode)
1713     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1714
1715   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1716   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1717
1718   if (addmode)
1719     {
1720       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1721       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1722     }
1723   if (opt.expert)
1724     {
1725       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1726       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1727     }
1728
1729   for(;;)
1730     {
1731       *r_usage = 0;
1732       *r_subkey_algo = 0;
1733       xfree (answer);
1734       answer = cpr_get ("keygen.algo", _("Your selection? "));
1735       cpr_kill_prompt ();
1736       algo = *answer? atoi (answer) : 1;
1737       if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
1738         {
1739           algo = PUBKEY_ALGO_RSA;
1740           *r_subkey_algo = PUBKEY_ALGO_RSA;
1741           break;
1742         }
1743       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
1744         {
1745           algo = PUBKEY_ALGO_DSA;
1746           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1747           break;
1748         }
1749       else if (algo == 3 || !strcmp (answer, "dsa"))
1750         {
1751           algo = PUBKEY_ALGO_DSA;
1752           *r_usage = PUBKEY_USAGE_SIG;
1753           break;
1754         }
1755       else if (algo == 4 || !strcmp (answer, "rsa/s"))
1756         {
1757           algo = PUBKEY_ALGO_RSA;
1758           *r_usage = PUBKEY_USAGE_SIG;
1759           break;
1760         }
1761       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
1762         {
1763           algo = PUBKEY_ALGO_ELGAMAL_E;
1764           *r_usage = PUBKEY_USAGE_ENC;
1765           break;
1766         }
1767       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
1768         {
1769           algo = PUBKEY_ALGO_RSA;
1770           *r_usage = PUBKEY_USAGE_ENC;
1771           break;
1772         }
1773       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
1774         {
1775           algo = PUBKEY_ALGO_DSA;
1776           *r_usage = ask_key_flags (algo, addmode);
1777           break;
1778         }
1779       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
1780         {
1781           algo = PUBKEY_ALGO_RSA;
1782           *r_usage = ask_key_flags (algo, addmode);
1783           break;
1784         }
1785       else
1786         tty_printf (_("Invalid selection.\n"));
1787
1788     }
1789
1790   xfree(answer);
1791   return algo;
1792 }
1793
1794
1795 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1796    is not 0, the function asks for the size of the encryption
1797    subkey. */
1798 static unsigned
1799 ask_keysize (int algo, unsigned int primary_keysize)
1800 {
1801   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1802   int for_subkey = !!primary_keysize;
1803   int autocomp = 0;
1804
1805   if(opt.expert)
1806     min=512;
1807   else
1808     min=1024;
1809
1810   if (primary_keysize && !opt.expert)
1811     {
1812       /* Deduce the subkey size from the primary key size.  */
1813       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1814         nbits = 3072; /* For performance reasons we don't support more
1815                          than 3072 bit DSA.  However we won't see this
1816                          case anyway because DSA can't be used as an
1817                          encryption subkey ;-). */
1818       else
1819         nbits = primary_keysize;
1820       autocomp = 1;
1821       goto leave;
1822     }
1823
1824   switch(algo)
1825     {
1826     case PUBKEY_ALGO_DSA:
1827       def=2048;
1828       max=3072;
1829       break;
1830
1831     case PUBKEY_ALGO_RSA:
1832       min=1024;
1833       break;
1834     }
1835
1836   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1837              openpgp_pk_algo_name (algo), min, max);
1838
1839   for(;;)
1840     {
1841       char *prompt, *answer;
1842
1843       if (for_subkey)
1844         prompt = xasprintf (_("What keysize do you want "
1845                               "for the subkey? (%u) "), def);
1846       else
1847         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1848       answer = cpr_get ("keygen.size", prompt);
1849       cpr_kill_prompt ();
1850       nbits = *answer? atoi (answer): def;
1851       xfree(prompt);
1852       xfree(answer);
1853
1854       if(nbits<min || nbits>max)
1855         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1856                    openpgp_pk_algo_name (algo), min, max);
1857       else
1858         break;
1859     }
1860
1861   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1862
1863  leave:
1864   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1865     {
1866       nbits = ((nbits + 63) / 64) * 64;
1867       if (!autocomp)
1868         tty_printf(_("rounded up to %u bits\n"), nbits );
1869     }
1870   else if( (nbits % 32) )
1871     {
1872       nbits = ((nbits + 31) / 32) * 32;
1873       if (!autocomp)
1874         tty_printf(_("rounded up to %u bits\n"), nbits );
1875     }
1876
1877   return nbits;
1878 }
1879
1880
1881 /****************
1882  * Parse an expire string and return its value in seconds.
1883  * Returns (u32)-1 on error.
1884  * This isn't perfect since scan_isodatestr returns unix time, and
1885  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1886  * Because of this, we only permit setting expirations up to 2106, but
1887  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1888  * just cope for the next few years until we get a 64-bit time_t or
1889  * similar.
1890  */
1891 u32
1892 parse_expire_string( const char *string )
1893 {
1894   int mult;
1895   u32 seconds;
1896   u32 abs_date = 0;
1897   u32 curtime = make_timestamp ();
1898   time_t tt;
1899
1900   if (!*string)
1901     seconds = 0;
1902   else if (!strncmp (string, "seconds=", 8))
1903     seconds = atoi (string+8);
1904   else if ((abs_date = scan_isodatestr(string))
1905            && (abs_date+86400/2) > curtime)
1906     seconds = (abs_date+86400/2) - curtime;
1907   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1908     seconds = (u32)tt - curtime;
1909   else if ((mult = check_valid_days (string)))
1910     seconds = atoi (string) * 86400L * mult;
1911   else
1912     seconds = (u32)(-1);
1913
1914   return seconds;
1915 }
1916
1917 /* Parsean Creation-Date string which is either "1986-04-26" or
1918    "19860426T042640".  Returns 0 on error. */
1919 static u32
1920 parse_creation_string (const char *string)
1921 {
1922   u32 seconds;
1923
1924   if (!*string)
1925     seconds = 0;
1926   else if ( !strncmp (string, "seconds=", 8) )
1927     seconds = atoi (string+8);
1928   else if ( !(seconds = scan_isodatestr (string)))
1929     {
1930       time_t tmp = isotime2epoch (string);
1931       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1932     }
1933   return seconds;
1934 }
1935
1936
1937 /* object == 0 for a key, and 1 for a sig */
1938 u32
1939 ask_expire_interval(int object,const char *def_expire)
1940 {
1941     u32 interval;
1942     char *answer;
1943
1944     switch(object)
1945       {
1946       case 0:
1947         if(def_expire)
1948           BUG();
1949         tty_printf(_("Please specify how long the key should be valid.\n"
1950                      "         0 = key does not expire\n"
1951                      "      <n>  = key expires in n days\n"
1952                      "      <n>w = key expires in n weeks\n"
1953                      "      <n>m = key expires in n months\n"
1954                      "      <n>y = key expires in n years\n"));
1955         break;
1956
1957       case 1:
1958         if(!def_expire)
1959           BUG();
1960         tty_printf(_("Please specify how long the signature should be valid.\n"
1961                      "         0 = signature does not expire\n"
1962                      "      <n>  = signature expires in n days\n"
1963                      "      <n>w = signature expires in n weeks\n"
1964                      "      <n>m = signature expires in n months\n"
1965                      "      <n>y = signature expires in n years\n"));
1966         break;
1967
1968       default:
1969         BUG();
1970       }
1971
1972     /* Note: The elgamal subkey for DSA has no expiration date because
1973      * it must be signed with the DSA key and this one has the expiration
1974      * date */
1975
1976     answer = NULL;
1977     for(;;)
1978       {
1979         u32 curtime;
1980
1981         xfree(answer);
1982         if(object==0)
1983           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1984         else
1985           {
1986             char *prompt;
1987
1988 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1989             /* This will actually end up larger than necessary because
1990                of the 2 bytes for '%s' */
1991             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1992             sprintf(prompt,PROMPTSTRING,def_expire);
1993 #undef PROMPTSTRING
1994
1995             answer = cpr_get("siggen.valid",prompt);
1996             xfree(prompt);
1997
1998             if(*answer=='\0')
1999               answer=xstrdup(def_expire);
2000           }
2001         cpr_kill_prompt();
2002         trim_spaces(answer);
2003         curtime = make_timestamp ();
2004         interval = parse_expire_string( answer );
2005         if( interval == (u32)-1 )
2006           {
2007             tty_printf(_("invalid value\n"));
2008             continue;
2009           }
2010
2011         if( !interval )
2012           {
2013             tty_printf((object==0)
2014                        ? _("Key does not expire at all\n")
2015                        : _("Signature does not expire at all\n"));
2016           }
2017         else
2018           {
2019             tty_printf(object==0
2020                        ? _("Key expires at %s\n")
2021                        : _("Signature expires at %s\n"),
2022                        asctimestamp((ulong)(curtime + interval) ) );
2023 #if SIZEOF_TIME_T <= 4
2024             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2025               tty_printf (_("Your system can't display dates beyond 2038.\n"
2026                             "However, it will be correctly handled up to"
2027                             " 2106.\n"));
2028             else
2029 #endif /*SIZEOF_TIME_T*/
2030               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2031                 {
2032                   tty_printf (_("invalid value\n"));
2033                   continue;
2034                 }
2035           }
2036
2037         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2038                                                    _("Is this correct? (y/N) ")) )
2039           break;
2040       }
2041
2042     xfree(answer);
2043     return interval;
2044 }
2045
2046 u32
2047 ask_expiredate()
2048 {
2049     u32 x = ask_expire_interval(0,NULL);
2050     return x? make_timestamp() + x : 0;
2051 }
2052
2053
2054
2055 static PKT_user_id *
2056 uid_from_string (const char *string)
2057 {
2058   size_t n;
2059   PKT_user_id *uid;
2060
2061   n = strlen (string);
2062   uid = xmalloc_clear (sizeof *uid + n);
2063   uid->len = n;
2064   strcpy (uid->name, string);
2065   uid->ref = 1;
2066   return uid;
2067 }
2068
2069
2070 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2071    printed for use during a new key creation.  If KEYBLOCK is not NULL
2072    the function prevents the creation of an already existing user
2073    ID.  */
2074 static char *
2075 ask_user_id (int mode, KBNODE keyblock)
2076 {
2077     char *answer;
2078     char *aname, *acomment, *amail, *uid;
2079
2080     if ( !mode )
2081       {
2082         /* TRANSLATORS: This is the new string telling the user what
2083            gpg is now going to do (i.e. ask for the parts of the user
2084            ID).  Note that if you do not tyranslated this string, a
2085            different string will be used used, which might still have
2086            a correct transaltion.  */
2087         const char *s1 =
2088           N_("\n"
2089              "GnuPG needs to construct a user ID to identify your key.\n"
2090              "\n");
2091         const char *s2 = _(s1);
2092
2093         if (!strcmp (s1, s2))
2094           {
2095             /* There is no translation for the string thus we to use
2096                the old info text.  gettext has no way to tell whether
2097                a translation is actually available, thus we need to
2098                to compare again. */
2099             /* TRANSLATORS: This string is in general not anymore used
2100                but you should keep your existing translation.  In case
2101                the new string is not translated this old string will
2102                be used. */
2103             const char *s3 = N_("\n"
2104 "You need a user ID to identify your key; "
2105                                         "the software constructs the user ID\n"
2106 "from the Real Name, Comment and Email Address in this form:\n"
2107 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2108             const char *s4 = _(s3);
2109             if (strcmp (s3, s4))
2110               s2 = s3; /* A translation exists - use it. */
2111           }
2112         tty_printf ("%s", s2) ;
2113       }
2114     uid = aname = acomment = amail = NULL;
2115     for(;;) {
2116         char *p;
2117         int fail=0;
2118
2119         if( !aname ) {
2120             for(;;) {
2121                 xfree(aname);
2122                 aname = cpr_get("keygen.name",_("Real name: "));
2123                 trim_spaces(aname);
2124                 cpr_kill_prompt();
2125
2126                 if( opt.allow_freeform_uid )
2127                     break;
2128
2129                 if( strpbrk( aname, "<>" ) )
2130                     tty_printf(_("Invalid character in name\n"));
2131                 else if( digitp(aname) )
2132                     tty_printf(_("Name may not start with a digit\n"));
2133                 else if( strlen(aname) < 5 )
2134                     tty_printf(_("Name must be at least 5 characters long\n"));
2135                 else
2136                     break;
2137             }
2138         }
2139         if( !amail ) {
2140             for(;;) {
2141                 xfree(amail);
2142                 amail = cpr_get("keygen.email",_("Email address: "));
2143                 trim_spaces(amail);
2144                 cpr_kill_prompt();
2145                 if( !*amail || opt.allow_freeform_uid )
2146                     break;   /* no email address is okay */
2147                 else if ( !is_valid_mailbox (amail) )
2148                     tty_printf(_("Not a valid email address\n"));
2149                 else
2150                     break;
2151             }
2152         }
2153         if( !acomment ) {
2154             for(;;) {
2155                 xfree(acomment);
2156                 acomment = cpr_get("keygen.comment",_("Comment: "));
2157                 trim_spaces(acomment);
2158                 cpr_kill_prompt();
2159                 if( !*acomment )
2160                     break;   /* no comment is okay */
2161                 else if( strpbrk( acomment, "()" ) )
2162                     tty_printf(_("Invalid character in comment\n"));
2163                 else
2164                     break;
2165             }
2166         }
2167
2168
2169         xfree(uid);
2170         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2171         p = stpcpy(p, aname );
2172         if( *acomment )
2173             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2174         if( *amail )
2175             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2176
2177         /* Append a warning if the RNG is switched into fake mode.  */
2178         if ( random_is_faked ()  )
2179           strcpy(p, " (insecure!)" );
2180
2181         /* print a note in case that UTF8 mapping has to be done */
2182         for(p=uid; *p; p++ ) {
2183             if( *p & 0x80 ) {
2184                 tty_printf(_("You are using the `%s' character set.\n"),
2185                            get_native_charset() );
2186                 break;
2187             }
2188         }
2189
2190         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2191
2192         if( !*amail && !opt.allow_freeform_uid
2193             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2194             fail = 1;
2195             tty_printf(_("Please don't put the email address "
2196                          "into the real name or the comment\n") );
2197         }
2198
2199         if (!fail && keyblock)
2200           {
2201             PKT_user_id *uidpkt = uid_from_string (uid);
2202             KBNODE node;
2203
2204             for (node=keyblock; node && !fail; node=node->next)
2205               if (!is_deleted_kbnode (node)
2206                   && node->pkt->pkttype == PKT_USER_ID
2207                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2208                 fail = 1;
2209             if (fail)
2210               tty_printf (_("Such a user ID already exists on this key!\n"));
2211             free_user_id (uidpkt);
2212           }
2213
2214         for(;;) {
2215             /* TRANSLATORS: These are the allowed answers in
2216                lower and uppercase.  Below you will find the matching
2217                string which should be translated accordingly and the
2218                letter changed to match the one in the answer string.
2219
2220                  n = Change name
2221                  c = Change comment
2222                  e = Change email
2223                  o = Okay (ready, continue)
2224                  q = Quit
2225              */
2226             const char *ansstr = _("NnCcEeOoQq");
2227
2228             if( strlen(ansstr) != 10 )
2229                 BUG();
2230             if( cpr_enabled() ) {
2231                 answer = xstrdup (ansstr + (fail?8:6));
2232                 answer[1] = 0;
2233             }
2234             else {
2235                 answer = cpr_get("keygen.userid.cmd", fail?
2236                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2237                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2238                 cpr_kill_prompt();
2239             }
2240             if( strlen(answer) > 1 )
2241                 ;
2242             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2243                 xfree(aname); aname = NULL;
2244                 break;
2245             }
2246             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2247                 xfree(acomment); acomment = NULL;
2248                 break;
2249             }
2250             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2251                 xfree(amail); amail = NULL;
2252                 break;
2253             }
2254             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2255                 if( fail ) {
2256                     tty_printf(_("Please correct the error first\n"));
2257                 }
2258                 else {
2259                     xfree(aname); aname = NULL;
2260                     xfree(acomment); acomment = NULL;
2261                     xfree(amail); amail = NULL;
2262                     break;
2263                 }
2264             }
2265             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2266                 xfree(aname); aname = NULL;
2267                 xfree(acomment); acomment = NULL;
2268                 xfree(amail); amail = NULL;
2269                 xfree(uid); uid = NULL;
2270                 break;
2271             }
2272             xfree(answer);
2273         }
2274         xfree(answer);
2275         if( !aname && !acomment && !amail )
2276             break;
2277         xfree(uid); uid = NULL;
2278     }
2279     if( uid ) {
2280         char *p = native_to_utf8( uid );
2281         xfree( uid );
2282         uid = p;
2283     }
2284     return uid;
2285 }
2286
2287
2288 /*  MODE  0 - standard
2289           1 - Ask for passphrase of the card backup key.  */
2290 static DEK *
2291 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2292 {
2293     DEK *dek = NULL;
2294     STRING2KEY *s2k;
2295     const char *errtext = NULL;
2296     const char *custdesc = NULL;
2297
2298     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2299
2300     if (mode == 1)
2301       custdesc = _("Please enter a passphrase to protect the off-card "
2302                    "backup of the new encryption key.");
2303
2304     s2k = xmalloc_secure( sizeof *s2k );
2305     for(;;) {
2306         s2k->mode = opt.s2k_mode;
2307         s2k->hash_algo = S2K_DIGEST_ALGO;
2308         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2309                                      errtext, custdesc, NULL, r_canceled);
2310         if (!dek && *r_canceled) {
2311             xfree(dek); dek = NULL;
2312             xfree(s2k); s2k = NULL;
2313             break;
2314         }
2315         else if( !dek ) {
2316             errtext = N_("passphrase not correctly repeated; try again");
2317             tty_printf(_("%s.\n"), _(errtext));
2318         }
2319         else if( !dek->keylen ) {
2320             xfree(dek); dek = NULL;
2321             xfree(s2k); s2k = NULL;
2322             tty_printf(_(
2323             "You don't want a passphrase - this is probably a *bad* idea!\n"
2324             "I will do it anyway.  You can change your passphrase at any time,\n"
2325             "using this program with the option \"--edit-key\".\n\n"));
2326             break;
2327         }
2328         else
2329             break; /* okay */
2330     }
2331     *ret_s2k = s2k;
2332     return dek;
2333 }
2334
2335
2336 /* Basic key generation.  Here we divert to the actual generation
2337    routines based on the requested algorithm.  */
2338 static int
2339 do_create (int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2340            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk,
2341            u32 timestamp, u32 expiredate, int is_subkey )
2342 {
2343   int rc=0;
2344
2345   if( !opt.batch )
2346     tty_printf(_(
2347 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2348 "some other action (type on the keyboard, move the mouse, utilize the\n"
2349 "disks) during the prime generation; this gives the random number\n"
2350 "generator a better chance to gain enough entropy.\n") );
2351
2352   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2353     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2354                  timestamp, expiredate, is_subkey);
2355   else if( algo == PUBKEY_ALGO_DSA )
2356     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk,
2357                  timestamp, expiredate, is_subkey);
2358   else if( algo == PUBKEY_ALGO_RSA )
2359     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2360                  timestamp, expiredate, is_subkey);
2361   else
2362     BUG();
2363
2364   return rc;
2365 }
2366
2367
2368 /* Generate a new user id packet or return NULL if canceled.  If
2369    KEYBLOCK is not NULL the function prevents the creation of an
2370    already existing user ID.  */
2371 PKT_user_id *
2372 generate_user_id (KBNODE keyblock)
2373 {
2374   char *p;
2375
2376   p = ask_user_id (1, keyblock);
2377   if (!p)
2378     return NULL;  /* Canceled. */
2379   return uid_from_string (p);
2380 }
2381
2382
2383 static void
2384 release_parameter_list( struct para_data_s *r )
2385 {
2386     struct para_data_s *r2;
2387
2388     for( ; r ; r = r2 ) {
2389         r2 = r->next;
2390         if( r->key == pPASSPHRASE_DEK )
2391             xfree( r->u.dek );
2392         else if( r->key == pPASSPHRASE_S2K )
2393             xfree( r->u.s2k );
2394
2395         xfree(r);
2396     }
2397 }
2398
2399 static struct para_data_s *
2400 get_parameter( struct para_data_s *para, enum para_name key )
2401 {
2402     struct para_data_s *r;
2403
2404     for( r = para; r && r->key != key; r = r->next )
2405         ;
2406     return r;
2407 }
2408
2409 static const char *
2410 get_parameter_value( struct para_data_s *para, enum para_name key )
2411 {
2412     struct para_data_s *r = get_parameter( para, key );
2413     return (r && *r->u.value)? r->u.value : NULL;
2414 }
2415
2416 static int
2417 get_parameter_algo( struct para_data_s *para, enum para_name key,
2418                     int *r_default)
2419 {
2420   int i;
2421   struct para_data_s *r = get_parameter( para, key );
2422
2423   if (r_default)
2424     *r_default = 0;
2425
2426   if (!r)
2427     return -1;
2428
2429   if (!ascii_strcasecmp (r->u.value, "default"))
2430     {
2431       /* Note: If you change this default algo, remember to change it
2432          also in gpg.c:gpgconf_list.  */
2433       i = DEFAULT_STD_ALGO;
2434       if (r_default)
2435         *r_default = 1;
2436     }
2437   else if (digitp (r->u.value))
2438     i = atoi( r->u.value );
2439   else if (!strcmp (r->u.value, "ELG-E")
2440            || !strcmp (r->u.value, "ELG"))
2441     i = GCRY_PK_ELG_E;
2442   else
2443     i = gcry_pk_map_name (r->u.value);
2444
2445   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2446     i = 0; /* we don't want to allow generation of these algorithms */
2447   return i;
2448 }
2449
2450 /*
2451  * Parse the usage parameter and set the keyflags.  Returns -1 on
2452  * error, 0 for no usage given or 1 for usage available.
2453  */
2454 static int
2455 parse_parameter_usage (const char *fname,
2456                        struct para_data_s *para, enum para_name key)
2457 {
2458     struct para_data_s *r = get_parameter( para, key );
2459     char *p, *pn;
2460     unsigned int use;
2461
2462     if( !r )
2463         return 0; /* none (this is an optional parameter)*/
2464
2465     use = 0;
2466     pn = r->u.value;
2467     while ( (p = strsep (&pn, " \t,")) ) {
2468         if ( !*p)
2469             ;
2470         else if ( !ascii_strcasecmp (p, "sign") )
2471             use |= PUBKEY_USAGE_SIG;
2472         else if ( !ascii_strcasecmp (p, "encrypt") )
2473             use |= PUBKEY_USAGE_ENC;
2474         else if ( !ascii_strcasecmp (p, "auth") )
2475             use |= PUBKEY_USAGE_AUTH;
2476         else {
2477             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2478             return -1; /* error */
2479         }
2480     }
2481     r->u.usage = use;
2482     return 1;
2483 }
2484
2485 static int
2486 parse_revocation_key (const char *fname,
2487                       struct para_data_s *para, enum para_name key)
2488 {
2489   struct para_data_s *r = get_parameter( para, key );
2490   struct revocation_key revkey;
2491   char *pn;
2492   int i;
2493
2494   if( !r )
2495     return 0; /* none (this is an optional parameter) */
2496
2497   pn = r->u.value;
2498
2499   revkey.class=0x80;
2500   revkey.algid=atoi(pn);
2501   if(!revkey.algid)
2502     goto fail;
2503
2504   /* Skip to the fpr */
2505   while(*pn && *pn!=':')
2506     pn++;
2507
2508   if(*pn!=':')
2509     goto fail;
2510
2511   pn++;
2512
2513   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2514     {
2515       int c=hextobyte(pn);
2516       if(c==-1)
2517         goto fail;
2518
2519       revkey.fpr[i]=c;
2520     }
2521
2522   /* skip to the tag */
2523   while(*pn && *pn!='s' && *pn!='S')
2524     pn++;
2525
2526   if(ascii_strcasecmp(pn,"sensitive")==0)
2527     revkey.class|=0x40;
2528
2529   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2530
2531   return 0;
2532
2533   fail:
2534   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2535   return -1; /* error */
2536 }
2537
2538
2539 static u32
2540 get_parameter_u32( struct para_data_s *para, enum para_name key )
2541 {
2542   struct para_data_s *r = get_parameter( para, key );
2543
2544   if( !r )
2545     return 0;
2546   if( r->key == pKEYCREATIONDATE )
2547     return r->u.creation;
2548   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2549     return r->u.expire;
2550   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2551     return r->u.usage;
2552
2553   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2554 }
2555
2556 static unsigned int
2557 get_parameter_uint( struct para_data_s *para, enum para_name key )
2558 {
2559     return get_parameter_u32( para, key );
2560 }
2561
2562 static DEK *
2563 get_parameter_dek( struct para_data_s *para, enum para_name key )
2564 {
2565     struct para_data_s *r = get_parameter( para, key );
2566     return r? r->u.dek : NULL;
2567 }
2568
2569 static STRING2KEY *
2570 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2571 {
2572     struct para_data_s *r = get_parameter( para, key );
2573     return r? r->u.s2k : NULL;
2574 }
2575
2576 static struct revocation_key *
2577 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2578 {
2579     struct para_data_s *r = get_parameter( para, key );
2580     return r? &r->u.revkey : NULL;
2581 }
2582
2583 static int
2584 proc_parameter_file( struct para_data_s *para, const char *fname,
2585                      struct output_control_s *outctrl, int card )
2586 {
2587   struct para_data_s *r;
2588   const char *s1, *s2, *s3;
2589   size_t n;
2590   char *p;
2591   int is_default = 0;
2592   int have_user_id = 0;
2593   int err, algo;
2594
2595   /* Check that we have all required parameters. */
2596   r = get_parameter( para, pKEYTYPE );
2597   if(r)
2598     {
2599       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2600       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2601         {
2602           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2603           return -1;
2604         }
2605     }
2606   else
2607     {
2608       log_error ("%s: no Key-Type specified\n",fname);
2609       return -1;
2610     }
2611
2612   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2613   if (!err)
2614     {
2615       /* Default to algo capabilities if key-usage is not provided and
2616          no default algorithm has been requested.  */
2617       r = xmalloc_clear(sizeof(*r));
2618       r->key = pKEYUSAGE;
2619       r->u.usage = (is_default
2620                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2621                     : openpgp_pk_algo_usage(algo));
2622       r->next = para;
2623       para = r;
2624     }
2625   else if (err == -1)
2626     return -1;
2627   else
2628     {
2629       r = get_parameter (para, pKEYUSAGE);
2630       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2631         {
2632           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2633                      fname, r->lnr, algo);
2634           return -1;
2635         }
2636     }
2637
2638   is_default = 0;
2639   r = get_parameter( para, pSUBKEYTYPE );
2640   if(r)
2641     {
2642       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2643       if (openpgp_pk_test_algo (algo))
2644         {
2645           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2646           return -1;
2647         }
2648
2649       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2650       if (!err)
2651         {
2652           /* Default to algo capabilities if subkey-usage is not
2653              provided */
2654           r = xmalloc_clear (sizeof(*r));
2655           r->key = pSUBKEYUSAGE;
2656           r->u.usage = (is_default
2657                         ? PUBKEY_USAGE_ENC
2658                         : openpgp_pk_algo_usage (algo));
2659           r->next = para;
2660           para = r;
2661         }
2662       else if (err == -1)
2663         return -1;
2664       else
2665         {
2666           r = get_parameter (para, pSUBKEYUSAGE);
2667           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2668             {
2669               log_error ("%s:%d: specified Subkey-Usage not allowed"
2670                          " for algo %d\n", fname, r->lnr, algo);
2671               return -1;
2672             }
2673         }
2674     }
2675
2676
2677   if( get_parameter_value( para, pUSERID ) )
2678     have_user_id=1;
2679   else
2680     {
2681       /* create the formatted user ID */
2682       s1 = get_parameter_value( para, pNAMEREAL );
2683       s2 = get_parameter_value( para, pNAMECOMMENT );
2684       s3 = get_parameter_value( para, pNAMEEMAIL );
2685       if( s1 || s2 || s3 )
2686         {
2687           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2688           r = xmalloc_clear( sizeof *r + n + 20 );
2689           r->key = pUSERID;
2690           p = r->u.value;
2691           if( s1 )
2692             p = stpcpy(p, s1 );
2693           if( s2 )
2694             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2695           if( s3 )
2696             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2697           r->next = para;
2698           para = r;
2699           have_user_id=1;
2700         }
2701     }
2702
2703   if(!have_user_id)
2704     {
2705       log_error("%s: no User-ID specified\n",fname);
2706       return -1;
2707     }
2708
2709   /* Set preferences, if any. */
2710   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2711
2712   /* Set keyserver, if any. */
2713   s1=get_parameter_value( para, pKEYSERVER );
2714   if(s1)
2715     {
2716       struct keyserver_spec *spec;
2717
2718       spec=parse_keyserver_uri(s1,1,NULL,0);
2719       if(spec)
2720         {
2721           free_keyserver_spec(spec);
2722           opt.def_keyserver_url=s1;
2723         }
2724       else
2725         {
2726           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2727           return -1;
2728         }
2729     }
2730
2731   /* Set revoker, if any. */
2732   if (parse_revocation_key (fname, para, pREVOKER))
2733     return -1;
2734
2735   /* Make DEK and S2K from the Passphrase. */
2736   if (outctrl->ask_passphrase)
2737     {
2738       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2739          feature is required so that GUIs are able to do a key
2740          creation but have gpg-agent ask for the passphrase.  */
2741       int canceled = 0;
2742       STRING2KEY *s2k;
2743       DEK *dek;
2744
2745       dek = do_ask_passphrase (&s2k, 0, &canceled);
2746       if (dek)
2747         {
2748           r = xmalloc_clear( sizeof *r );
2749           r->key = pPASSPHRASE_DEK;
2750           r->u.dek = dek;
2751           r->next = para;
2752           para = r;
2753           r = xmalloc_clear( sizeof *r );
2754           r->key = pPASSPHRASE_S2K;
2755           r->u.s2k = s2k;
2756           r->next = para;
2757           para = r;
2758         }
2759
2760       if (canceled)
2761         {
2762           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2763           return -1;
2764         }
2765     }
2766   else
2767     {
2768       r = get_parameter( para, pPASSPHRASE );
2769       if ( r && *r->u.value )
2770         {
2771           /* We have a plain text passphrase - create a DEK from it.
2772            * It is a little bit ridiculous to keep it in secure memory
2773            * but because we do this always, why not here.  */
2774           STRING2KEY *s2k;
2775           DEK *dek;
2776
2777           s2k = xmalloc_secure ( sizeof *s2k );
2778           s2k->mode = opt.s2k_mode;
2779           s2k->hash_algo = S2K_DIGEST_ALGO;
2780           set_next_passphrase ( r->u.value );
2781           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2782                                    NULL, NULL);
2783           set_next_passphrase (NULL );
2784           assert (dek);
2785           memset (r->u.value, 0, strlen(r->u.value));
2786
2787           r = xmalloc_clear (sizeof *r);
2788           r->key = pPASSPHRASE_S2K;
2789           r->u.s2k = s2k;
2790           r->next = para;
2791           para = r;
2792           r = xmalloc_clear (sizeof *r);
2793           r->key = pPASSPHRASE_DEK;
2794           r->u.dek = dek;
2795           r->next = para;
2796           para = r;
2797         }
2798     }
2799
2800   /* Make KEYCREATIONDATE from Creation-Date.  */
2801   r = get_parameter (para, pCREATIONDATE);
2802   if (r && *r->u.value)
2803     {
2804       u32 seconds;
2805
2806       seconds = parse_creation_string (r->u.value);
2807       if (!seconds)
2808         {
2809           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2810           return -1;
2811         }
2812       r->u.creation = seconds;
2813       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2814     }
2815
2816   /* Make KEYEXPIRE from Expire-Date.  */
2817   r = get_parameter( para, pEXPIREDATE );
2818   if( r && *r->u.value )
2819     {
2820       u32 seconds;
2821
2822       seconds = parse_expire_string( r->u.value );
2823       if( seconds == (u32)-1 )
2824         {
2825           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2826           return -1;
2827         }
2828       r->u.expire = seconds;
2829       r->key = pKEYEXPIRE;  /* change hat entry */
2830       /* also set it for the subkey */
2831       r = xmalloc_clear( sizeof *r + 20 );
2832       r->key = pSUBKEYEXPIRE;
2833       r->u.expire = seconds;
2834       r->next = para;
2835       para = r;
2836     }
2837
2838   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2839     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2840     return -1;
2841   }
2842
2843   do_generate_keypair( para, outctrl, card );
2844   return 0;
2845 }
2846
2847
2848 /****************
2849  * Kludge to allow non interactive key generation controlled
2850  * by a parameter file.
2851  * Note, that string parameters are expected to be in UTF-8
2852  */
2853 static void
2854 read_parameter_file( const char *fname )
2855 {
2856     static struct { const char *name;
2857                     enum para_name key;
2858     } keywords[] = {
2859         { "Key-Type",       pKEYTYPE},
2860         { "Key-Length",     pKEYLENGTH },
2861         { "Key-Usage",      pKEYUSAGE },
2862         { "Subkey-Type",    pSUBKEYTYPE },
2863         { "Subkey-Length",  pSUBKEYLENGTH },
2864         { "Subkey-Usage",   pSUBKEYUSAGE },
2865         { "Name-Real",      pNAMEREAL },
2866         { "Name-Email",     pNAMEEMAIL },
2867         { "Name-Comment",   pNAMECOMMENT },
2868         { "Expire-Date",    pEXPIREDATE },
2869         { "Creation-Date",  pCREATIONDATE },
2870         { "Passphrase",     pPASSPHRASE },
2871         { "Preferences",    pPREFERENCES },
2872         { "Revoker",        pREVOKER },
2873         { "Handle",         pHANDLE },
2874         { "Keyserver",      pKEYSERVER },
2875         { NULL, 0 }
2876     };
2877     IOBUF fp;
2878     byte *line;
2879     unsigned int maxlen, nline;
2880     char *p;
2881     int lnr;
2882     const char *err = NULL;
2883     struct para_data_s *para, *r;
2884     int i;
2885     struct output_control_s outctrl;
2886
2887     memset( &outctrl, 0, sizeof( outctrl ) );
2888     outctrl.pub.afx = new_armor_context ();
2889     outctrl.sec.afx = new_armor_context ();
2890
2891     if( !fname || !*fname)
2892       fname = "-";
2893
2894     fp = iobuf_open (fname);
2895     if (fp && is_secured_file (iobuf_get_fd (fp)))
2896       {
2897         iobuf_close (fp);
2898         fp = NULL;
2899         errno = EPERM;
2900       }
2901     if (!fp) {
2902       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2903       return;
2904     }
2905     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2906
2907     lnr = 0;
2908     err = NULL;
2909     para = NULL;
2910     maxlen = 1024;
2911     line = NULL;
2912     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2913         char *keyword, *value;
2914
2915         lnr++;
2916         if( !maxlen ) {
2917             err = "line too long";
2918             break;
2919         }
2920         for( p = line; isspace(*(byte*)p); p++ )
2921             ;
2922         if( !*p || *p == '#' )
2923             continue;
2924         keyword = p;
2925         if( *keyword == '%' ) {
2926             for( ; !isspace(*(byte*)p); p++ )
2927                 ;
2928             if( *p )
2929                 *p++ = 0;
2930             for( ; isspace(*(byte*)p); p++ )
2931                 ;
2932             value = p;
2933             trim_trailing_ws( value, strlen(value) );
2934             if( !ascii_strcasecmp( keyword, "%echo" ) )
2935                 log_info("%s\n", value );
2936             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2937                 outctrl.dryrun = 1;
2938             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2939                 outctrl.ask_passphrase = 1;
2940             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2941                 outctrl.ask_passphrase = 0;
2942             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2943                 outctrl.lnr = lnr;
2944                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2945                   print_status_key_not_created
2946                     (get_parameter_value (para, pHANDLE));
2947                 release_parameter_list( para );
2948                 para = NULL;
2949             }
2950             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2951                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2952                     ; /* still the same file - ignore it */
2953                 else {
2954                     xfree( outctrl.pub.newfname );
2955                     outctrl.pub.newfname = xstrdup( value );
2956                     outctrl.use_files = 1;
2957                 }
2958             }
2959             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2960                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2961                     ; /* still the same file - ignore it */
2962                 else {
2963                    xfree( outctrl.sec.newfname );
2964                    outctrl.sec.newfname = xstrdup( value );
2965                    outctrl.use_files = 1;
2966                 }
2967             }
2968             else
2969                 log_info("skipping control `%s' (%s)\n", keyword, value );
2970
2971
2972             continue;
2973         }
2974
2975
2976         if( !(p = strchr( p, ':' )) || p == keyword ) {
2977             err = "missing colon";
2978             break;
2979         }
2980         if( *p )
2981             *p++ = 0;
2982         for( ; isspace(*(byte*)p); p++ )
2983             ;
2984         if( !*p ) {
2985             err = "missing argument";
2986             break;
2987         }
2988         value = p;
2989         trim_trailing_ws( value, strlen(value) );
2990
2991         for(i=0; keywords[i].name; i++ ) {
2992             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2993                 break;
2994         }
2995         if( !keywords[i].name ) {
2996             err = "unknown keyword";
2997             break;
2998         }
2999         if( keywords[i].key != pKEYTYPE && !para ) {
3000             err = "parameter block does not start with \"Key-Type\"";
3001             break;
3002         }
3003
3004         if( keywords[i].key == pKEYTYPE && para ) {
3005             outctrl.lnr = lnr;
3006             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3007               print_status_key_not_created
3008                 (get_parameter_value (para, pHANDLE));
3009             release_parameter_list( para );
3010             para = NULL;
3011         }
3012         else {
3013             for( r = para; r; r = r->next ) {
3014                 if( r->key == keywords[i].key )
3015                     break;
3016             }
3017             if( r ) {
3018                 err = "duplicate keyword";
3019                 break;
3020             }
3021         }
3022         r = xmalloc_clear( sizeof *r + strlen( value ) );
3023         r->lnr = lnr;
3024         r->key = keywords[i].key;
3025         strcpy( r->u.value, value );
3026         r->next = para;
3027         para = r;
3028     }
3029     if( err )
3030         log_error("%s:%d: %s\n", fname, lnr, err );
3031     else if( iobuf_error (fp) ) {
3032         log_error("%s:%d: read error\n", fname, lnr);
3033     }
3034     else if( para ) {
3035         outctrl.lnr = lnr;
3036         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3037           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3038     }
3039
3040     if( outctrl.use_files ) { /* close open streams */
3041         iobuf_close( outctrl.pub.stream );
3042         iobuf_close( outctrl.sec.stream );
3043
3044         /* Must invalidate that ugly cache to actually close it.  */
3045         if (outctrl.pub.fname)
3046           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
3047         if (outctrl.sec.fname)
3048           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
3049
3050         xfree( outctrl.pub.fname );
3051         xfree( outctrl.pub.newfname );
3052         xfree( outctrl.sec.fname );
3053         xfree( outctrl.sec.newfname );
3054     }
3055
3056     release_parameter_list( para );
3057     iobuf_close (fp);
3058     release_armor_context (outctrl.pub.afx);
3059     release_armor_context (outctrl.sec.afx);
3060 }
3061
3062
3063 /*
3064  * Generate a keypair (fname is only used in batch mode) If
3065  * CARD_SERIALNO is not NULL the function will create the keys on an
3066  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
3067  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
3068  * generate in software, imported to the card and a backup file
3069  * written to directory given by this argument .
3070  */
3071 void
3072 generate_keypair (const char *fname, const char *card_serialno,
3073                   const char *backup_encryption_dir)
3074 {
3075   unsigned int nbits;
3076   char *uid = NULL;
3077   DEK *dek;
3078   STRING2KEY *s2k;
3079   int algo;
3080   unsigned int use;
3081   int both = 0;
3082   u32 expire;
3083   struct para_data_s *para = NULL;
3084   struct para_data_s *r;
3085   struct output_control_s outctrl;
3086   int canceled;
3087
3088   memset( &outctrl, 0, sizeof( outctrl ) );
3089
3090   if (opt.batch && card_serialno)
3091     {
3092       /* We don't yet support unattended key generation. */
3093       log_error (_("can't do this in batch mode\n"));
3094       return;
3095     }
3096
3097   if (opt.batch)
3098     {
3099       read_parameter_file( fname );
3100       return;
3101     }
3102
3103   if (card_serialno)
3104     {
3105 #ifdef ENABLE_CARD_SUPPORT
3106       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3107       r->key = pSERIALNO;
3108       strcpy( r->u.value, card_serialno);
3109       r->next = para;
3110       para = r;
3111
3112       algo = PUBKEY_ALGO_RSA;
3113
3114       r = xcalloc (1, sizeof *r + 20 );
3115       r->key = pKEYTYPE;
3116       sprintf( r->u.value, "%d", algo );
3117       r->next = para;
3118       para = r;
3119       r = xcalloc (1, sizeof *r + 20 );
3120       r->key = pKEYUSAGE;
3121       strcpy (r->u.value, "sign");
3122       r->next = para;
3123       para = r;
3124
3125       r = xcalloc (1, sizeof *r + 20 );
3126       r->key = pSUBKEYTYPE;
3127       sprintf( r->u.value, "%d", algo );
3128       r->next = para;
3129       para = r;
3130       r = xcalloc (1, sizeof *r + 20 );
3131       r->key = pSUBKEYUSAGE;
3132       strcpy (r->u.value, "encrypt");
3133       r->next = para;
3134       para = r;
3135
3136       r = xcalloc (1, sizeof *r + 20 );
3137       r->key = pAUTHKEYTYPE;
3138       sprintf( r->u.value, "%d", algo );
3139       r->next = para;
3140       para = r;
3141
3142       if (backup_encryption_dir)
3143         {
3144           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
3145           r->key = pBACKUPENCDIR;
3146           strcpy (r->u.value, backup_encryption_dir);
3147           r->next = para;
3148           para = r;
3149         }
3150 #endif /*ENABLE_CARD_SUPPORT*/
3151     }
3152   else
3153     {
3154       int subkey_algo;
3155
3156       algo = ask_algo (0, &subkey_algo, &use);
3157       if (subkey_algo)
3158         {
3159           /* Create primary and subkey at once.  */
3160           both = 1;
3161           r = xmalloc_clear( sizeof *r + 20 );
3162           r->key = pKEYTYPE;
3163           sprintf( r->u.value, "%d", algo );
3164           r->next = para;
3165           para = r;
3166           nbits = ask_keysize (algo, 0);
3167           r = xmalloc_clear( sizeof *r + 20 );
3168           r->key = pKEYLENGTH;
3169           sprintf( r->u.value, "%u", nbits);
3170           r->next = para;
3171           para = r;
3172           r = xmalloc_clear( sizeof *r + 20 );
3173           r->key = pKEYUSAGE;
3174           strcpy( r->u.value, "sign" );
3175           r->next = para;
3176           para = r;
3177
3178           r = xmalloc_clear( sizeof *r + 20 );
3179           r->key = pSUBKEYTYPE;
3180           sprintf( r->u.value, "%d", subkey_algo);
3181           r->next = para;
3182           para = r;
3183           r = xmalloc_clear( sizeof *r + 20 );
3184           r->key = pSUBKEYUSAGE;
3185           strcpy( r->u.value, "encrypt" );
3186           r->next = para;
3187           para = r;
3188         }
3189       else
3190         {
3191           r = xmalloc_clear( sizeof *r + 20 );
3192           r->key = pKEYTYPE;
3193           sprintf( r->u.value, "%d", algo );
3194           r->next = para;
3195           para = r;
3196
3197           if (use)
3198             {
3199               r = xmalloc_clear( sizeof *r + 25 );
3200               r->key = pKEYUSAGE;
3201               sprintf( r->u.value, "%s%s%s",
3202                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3203                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3204                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3205               r->next = para;
3206               para = r;
3207             }
3208           nbits = 0;
3209         }
3210
3211       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3212       r = xmalloc_clear( sizeof *r + 20 );
3213       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3214       sprintf( r->u.value, "%u", nbits);
3215       r->next = para;
3216       para = r;
3217     }
3218
3219   expire = ask_expire_interval(0,NULL);
3220   r = xmalloc_clear( sizeof *r + 20 );
3221   r->key = pKEYEXPIRE;
3222   r->u.expire = expire;
3223   r->next = para;
3224   para = r;
3225   r = xmalloc_clear( sizeof *r + 20 );
3226   r->key = pSUBKEYEXPIRE;
3227   r->u.expire = expire;
3228   r->next = para;
3229   para = r;
3230
3231   uid = ask_user_id (0, NULL);
3232   if( !uid )
3233     {
3234       log_error(_("Key generation canceled.\n"));
3235       release_parameter_list( para );
3236       return;
3237     }
3238   r = xmalloc_clear( sizeof *r + strlen(uid) );
3239   r->key = pUSERID;
3240   strcpy( r->u.value, uid );
3241   r->next = para;
3242   para = r;
3243
3244   canceled = 0;
3245   dek = card_serialno? NULL : do_ask_passphrase (&s2k, 0, &canceled);
3246   if( dek )
3247     {
3248       r = xmalloc_clear( sizeof *r );
3249       r->key = pPASSPHRASE_DEK;
3250       r->u.dek = dek;
3251       r->next = para;
3252       para = r;
3253       r = xmalloc_clear( sizeof *r );
3254       r->key = pPASSPHRASE_S2K;
3255       r->u.s2k = s2k;
3256       r->next = para;
3257       para = r;
3258     }
3259
3260   if (canceled)
3261     log_error (_("Key generation canceled.\n"));
3262   else
3263     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3264   release_parameter_list( para );
3265 }
3266
3267
3268 #ifdef ENABLE_CARD_SUPPORT
3269 /* Generate a raw key and return it as a secret key packet.  The
3270    function will ask for the passphrase and return a protected as well
3271    as an unprotected copy of a new secret key packet.  0 is returned
3272    on success and the caller must then free the returned values.  */
3273 static int
3274 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3275                   PKT_secret_key **r_sk_unprotected,
3276                   PKT_secret_key **r_sk_protected)
3277 {
3278   int rc;
3279   DEK *dek = NULL;
3280   STRING2KEY *s2k = NULL;
3281   PKT_secret_key *sk = NULL;
3282   int i;
3283   size_t nskey, npkey;
3284   gcry_sexp_t s_parms, s_key;
3285   int canceled;
3286
3287   npkey = pubkey_get_npkey (algo);
3288   nskey = pubkey_get_nskey (algo);
3289   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3290
3291   if (nbits < 512)
3292     {
3293       nbits = 512;
3294       log_info (_("keysize invalid; using %u bits\n"), nbits );
3295     }
3296
3297   if ((nbits % 32))
3298     {
3299       nbits = ((nbits + 31) / 32) * 32;
3300       log_info(_("keysize rounded up to %u bits\n"), nbits );
3301     }
3302
3303   dek = do_ask_passphrase (&s2k, 1, &canceled);
3304   if (canceled)
3305     {
3306       rc = gpg_error (GPG_ERR_CANCELED);
3307       goto leave;
3308     }
3309
3310   sk = xmalloc_clear (sizeof *sk);
3311   sk->timestamp = created_at;
3312   sk->version = 4;
3313   sk->pubkey_algo = algo;
3314
3315   if ( !is_RSA (algo) )
3316     {
3317       log_error ("only RSA is supported for offline generated keys\n");
3318       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3319       goto leave;
3320     }
3321   rc = gcry_sexp_build (&s_parms, NULL,
3322                         "(genkey(rsa(nbits %d)))",
3323                         (int)nbits);
3324   if (rc)
3325     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3326   rc = gcry_pk_genkey (&s_key, s_parms);
3327   gcry_sexp_release (s_parms);
3328   if (rc)
3329     {
3330       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3331       goto leave;
3332     }
3333   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3334   gcry_sexp_release (s_key);
3335   if (rc)
3336     {
3337       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3338       goto leave;
3339     }
3340
3341   for (i=npkey; i < nskey; i++)
3342     sk->csum += checksum_mpi (sk->skey[i]);
3343
3344   if (r_sk_unprotected)
3345     *r_sk_unprotected = copy_secret_key (NULL, sk);
3346
3347   rc = genhelp_protect (dek, s2k, sk);
3348   if (rc)
3349     goto leave;
3350
3351   if (r_sk_protected)
3352     {
3353       *r_sk_protected = sk;
3354       sk = NULL;
3355     }
3356
3357  leave:
3358   if (sk)
3359     free_secret_key (sk);
3360   xfree (dek);
3361   xfree (s2k);
3362   return rc;
3363 }
3364 #endif /* ENABLE_CARD_SUPPORT */
3365
3366 /* Create and delete a dummy packet to start off a list of kbnodes. */
3367 static void
3368 start_tree(KBNODE *tree)
3369 {
3370   PACKET *pkt;
3371
3372   pkt=xmalloc_clear(sizeof(*pkt));
3373   pkt->pkttype=PKT_NONE;
3374   *tree=new_kbnode(pkt);
3375   delete_kbnode(*tree);
3376 }
3377
3378
3379 static void
3380 do_generate_keypair (struct para_data_s *para,
3381                      struct output_control_s *outctrl, int card)
3382 {
3383   KBNODE pub_root = NULL;
3384   KBNODE sec_root = NULL;
3385   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3386   const char *s;
3387   struct revocation_key *revkey;
3388   int rc;
3389   int did_sub = 0;
3390   u32 timestamp;
3391
3392   if( outctrl->dryrun )
3393     {
3394       log_info("dry-run mode - key generation skipped\n");
3395       return;
3396     }
3397
3398   if ( outctrl->use_files )
3399     {
3400       if ( outctrl->pub.newfname )
3401         {
3402           iobuf_close(outctrl->pub.stream);
3403           outctrl->pub.stream = NULL;
3404           if (outctrl->pub.fname)
3405             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3406           xfree( outctrl->pub.fname );
3407           outctrl->pub.fname =  outctrl->pub.newfname;
3408           outctrl->pub.newfname = NULL;
3409
3410           if (is_secured_filename (outctrl->pub.fname) )
3411             {
3412               outctrl->pub.stream = NULL;
3413               errno = EPERM;
3414             }
3415           else
3416             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3417           if (!outctrl->pub.stream)
3418             {
3419               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3420                         strerror(errno) );
3421               return;
3422             }
3423           if (opt.armor)
3424             {
3425               outctrl->pub.afx->what = 1;
3426               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3427             }
3428         }
3429       if (outctrl->sec.newfname)
3430         {
3431           mode_t oldmask;
3432
3433           iobuf_close(outctrl->sec.stream);
3434           outctrl->sec.stream = NULL;
3435           if (outctrl->sec.fname)
3436             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3437           xfree( outctrl->sec.fname );
3438           outctrl->sec.fname =  outctrl->sec.newfname;
3439           outctrl->sec.newfname = NULL;
3440
3441           oldmask = umask (077);
3442           if (is_secured_filename (outctrl->sec.fname) )
3443             {
3444               outctrl->sec.stream = NULL;
3445               errno = EPERM;
3446             }
3447           else
3448             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3449           umask (oldmask);
3450           if (!outctrl->sec.stream)
3451             {
3452               log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3453                         strerror(errno) );
3454               return;
3455             }
3456           if (opt.armor)
3457             {
3458               outctrl->sec.afx->what = 5;
3459               push_armor_filter (outctrl->sec.afx, outctrl->sec.stream);
3460             }
3461         }
3462       assert( outctrl->pub.stream );
3463       assert( outctrl->sec.stream );
3464       if (opt.verbose)
3465         {
3466           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3467           if (card)
3468             log_info (_("writing secret key stub to `%s'\n"),
3469                       outctrl->sec.fname);
3470           else
3471             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3472         }
3473     }
3474
3475
3476   /* We create the packets as a tree of kbnodes.  Because the
3477      structure we create is known in advance we simply generate a
3478      linked list.  The first packet is a dummy packet which we flag as
3479      deleted.  The very first packet must always be a KEY packet.  */
3480
3481   start_tree (&pub_root);
3482   start_tree (&sec_root);
3483
3484   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3485   if (!timestamp)
3486     timestamp = make_timestamp ();
3487
3488   /* Note that, depending on the backend (i.e. the used scdaemon
3489      version), the card key generation may update TIMESTAMP for each
3490      key.  Thus we need to pass TIMESTAMP to all signing function to
3491      make sure that the binding signature is done using the timestamp
3492      of the corresponding (sub)key and not that of the primary key.
3493      An alternative implementation could tell the signing function the
3494      node of the subkey but that is more work than just to pass the
3495      current timestamp.  */
3496
3497   if (!card)
3498     {
3499       rc = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3500                       get_parameter_uint( para, pKEYLENGTH ),
3501                       pub_root, sec_root,
3502                       get_parameter_dek( para, pPASSPHRASE_DEK ),
3503                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
3504                       &pri_sk,
3505                       timestamp,
3506                       get_parameter_u32( para, pKEYEXPIRE ), 0 );
3507     }
3508   else
3509     {
3510       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3511                          &timestamp,
3512                          get_parameter_u32 (para, pKEYEXPIRE), para);
3513       if (!rc)
3514         {
3515           pri_sk = sec_root->next->pkt->pkt.secret_key;
3516           assert (pri_sk);
3517         }
3518     }
3519
3520   if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3521     {
3522       rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3523       if (!rc)
3524         rc = write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3525     }
3526
3527   if( !rc && (s=get_parameter_value(para, pUSERID)) )
3528     {
3529       write_uid (pub_root, s );
3530       write_uid (sec_root, s );
3531
3532       rc = write_selfsigs (sec_root, pub_root, pri_sk,
3533                            get_parameter_uint (para, pKEYUSAGE), timestamp);
3534     }
3535
3536   /* Write the auth key to the card before the encryption key.  This
3537      is a partial workaround for a PGP bug (as of this writing, all
3538      versions including 8.1), that causes it to try and encrypt to
3539      the most recent subkey regardless of whether that subkey is
3540      actually an encryption type.  In this case, the auth key is an
3541      RSA key so it succeeds. */
3542
3543   if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3544     {
3545       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3546                          &timestamp,
3547                          get_parameter_u32 (para, pKEYEXPIRE), para);
3548
3549       if (!rc)
3550         rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3551                                PUBKEY_USAGE_AUTH, timestamp);
3552       if (!rc)
3553         rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3554                                PUBKEY_USAGE_AUTH, timestamp);
3555     }
3556
3557   if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3558     {
3559       if (!card)
3560         {
3561           rc = do_create( get_parameter_algo( para, pSUBKEYTYPE, NULL ),
3562                           get_parameter_uint( para, pSUBKEYLENGTH ),
3563                           pub_root, sec_root,
3564                           get_parameter_dek( para, pPASSPHRASE_DEK ),
3565                           get_parameter_s2k( para, pPASSPHRASE_S2K ),
3566                           &sub_sk,
3567                           timestamp,
3568                           get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3569         }
3570       else
3571         {
3572           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3573             {
3574               /* A backup of the encryption key has been requested.
3575                  Generate the key in software and import it then to
3576                  the card.  Write a backup file. */
3577               rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3578                                              pub_root, sec_root,
3579                                              timestamp,
3580                                              get_parameter_u32 (para,
3581                                                                 pKEYEXPIRE),
3582                                              para, s);
3583             }
3584           else
3585             {
3586               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3587                                  NULL,
3588                                  &timestamp,
3589                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3590             }
3591         }
3592
3593       if( !rc )
3594         rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3595                               get_parameter_uint (para, pSUBKEYUSAGE),
3596                               timestamp);
3597       if( !rc )
3598         rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3599                               get_parameter_uint (para, pSUBKEYUSAGE),
3600                               timestamp);
3601       did_sub = 1;
3602     }
3603
3604   if (!rc && outctrl->use_files)  /* Direct write to specified files.  */
3605     {
3606       rc = write_keyblock( outctrl->pub.stream, pub_root );
3607       if (rc)
3608         log_error ("can't write public key: %s\n", g10_errstr(rc) );
3609       if (!rc)
3610         {
3611           rc = write_keyblock( outctrl->sec.stream, sec_root );
3612           if(rc)
3613             log_error ("can't write secret key: %s\n", g10_errstr(rc) );
3614         }
3615     }
3616   else if (!rc) /* Write to the standard keyrings.  */
3617     {
3618       KEYDB_HANDLE pub_hd = keydb_new (0);
3619       KEYDB_HANDLE sec_hd = keydb_new (1);
3620
3621       rc = keydb_locate_writable (pub_hd, NULL);
3622       if (rc)
3623         log_error (_("no writable public keyring found: %s\n"),
3624                    g10_errstr (rc));
3625
3626       if (!rc)
3627         {
3628           rc = keydb_locate_writable (sec_hd, NULL);
3629           if (rc)
3630             log_error (_("no writable secret keyring found: %s\n"),
3631                        g10_errstr (rc));
3632         }
3633
3634       if (!rc && opt.verbose)
3635         {
3636           log_info (_("writing public key to `%s'\n"),
3637                     keydb_get_resource_name (pub_hd));
3638           if (card)
3639             log_info (_("writing secret key stub to `%s'\n"),
3640                       keydb_get_resource_name (sec_hd));
3641           else
3642             log_info (_("writing secret key to `%s'\n"),
3643                       keydb_get_resource_name (sec_hd));
3644         }
3645
3646       if (!rc)
3647         {
3648           rc = keydb_insert_keyblock (pub_hd, pub_root);
3649           if (rc)
3650             log_error (_("error writing public keyring `%s': %s\n"),
3651                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3652         }
3653
3654       if (!rc)
3655         {
3656           rc = keydb_insert_keyblock (sec_hd, sec_root);
3657           if (rc)
3658             log_error (_("error writing secret keyring `%s': %s\n"),
3659                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3660         }
3661
3662       keydb_release (pub_hd);
3663       keydb_release (sec_hd);
3664
3665       if (!rc)
3666         {
3667           int no_enc_rsa;
3668           PKT_public_key *pk;
3669
3670           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
3671                          == PUBKEY_ALGO_RSA)
3672                         && get_parameter_uint (para, pKEYUSAGE)
3673                         && !((get_parameter_uint (para, pKEYUSAGE)
3674                               & PUBKEY_USAGE_ENC)) );
3675
3676           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3677
3678           keyid_from_pk(pk,pk->main_keyid);
3679           register_trusted_keyid(pk->main_keyid);
3680
3681           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
3682                                   | TRUST_ULTIMATE ));
3683
3684           if (!opt.batch)
3685             {
3686               tty_printf (_("public and secret key created and signed.\n") );
3687               tty_printf ("\n");
3688               list_keyblock(pub_root,0,1,NULL);
3689             }
3690
3691
3692           if (!opt.batch
3693               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
3694                   || no_enc_rsa )
3695               && !get_parameter (para, pSUBKEYTYPE) )
3696             {
3697               tty_printf(_("Note that this key cannot be used for "
3698                            "encryption.  You may want to use\n"
3699                            "the command \"--edit-key\" to generate a "
3700                            "subkey for this purpose.\n") );
3701             }
3702         }
3703     }
3704
3705   if (rc)
3706     {
3707       if (opt.batch)
3708         log_error ("key generation failed: %s\n", g10_errstr(rc) );
3709       else
3710         tty_printf (_("Key generation failed: %s\n"), g10_errstr(rc) );
3711       write_status_error (card? "card_key_generate":"key_generate", rc);
3712       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3713     }
3714   else
3715     {
3716       PKT_public_key *pk = find_kbnode (pub_root,
3717                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3718       print_status_key_created (did_sub? 'B':'P', pk,
3719                                 get_parameter_value (para, pHANDLE));
3720     }
3721   release_kbnode( pub_root );
3722   release_kbnode( sec_root );
3723
3724   if (pri_sk && !card)        /* The unprotected secret key unless we */
3725     free_secret_key (pri_sk); /* have a shallow copy in card mode. */
3726   if (sub_sk)
3727     free_secret_key(sub_sk);
3728 }
3729
3730
3731 /* Add a new subkey to an existing key.  Returns true if a new key has
3732    been generated and put into the keyblocks.  */
3733 int
3734 generate_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock)
3735 {
3736   int okay=0, rc=0;
3737   KBNODE node;
3738   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3739   int algo;
3740   unsigned int use;
3741   u32 expire;
3742   unsigned nbits;
3743   char *passphrase = NULL;
3744   DEK *dek = NULL;
3745   STRING2KEY *s2k = NULL;
3746   u32 cur_time;
3747   int ask_pass = 0;
3748   int canceled;
3749
3750   /* Break out the primary secret key.  */
3751   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3752   if( !node )
3753     {
3754       log_error ("Oops; secret key not found anymore!\n");
3755       goto leave;
3756     }
3757
3758   /* Make a copy of the sk to keep the protected one in the keyblock. */
3759   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3760
3761   cur_time = make_timestamp();
3762
3763   if (pri_sk->timestamp > cur_time)
3764     {
3765       ulong d = pri_sk->timestamp - cur_time;
3766       log_info ( d==1 ? _("key has been created %lu second "
3767                           "in future (time warp or clock problem)\n")
3768                  : _("key has been created %lu seconds "
3769                      "in future (time warp or clock problem)\n"), d );
3770       if (!opt.ignore_time_conflict)
3771         {
3772           rc = G10ERR_TIME_CONFLICT;
3773           goto leave;
3774         }
3775     }
3776
3777   if (pri_sk->version < 4)
3778     {
3779       log_info (_("NOTE: creating subkeys for v3 keys "
3780                   "is not OpenPGP compliant\n"));
3781       goto leave;
3782     }
3783
3784   if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001)
3785     {
3786       tty_printf (_("Secret parts of primary key are not available.\n"));
3787       rc = G10ERR_NO_SECKEY;
3788       goto leave;
3789     }
3790
3791
3792   /* Unprotect to get the passphrase.  */
3793   switch (is_secret_key_protected (pri_sk) )
3794     {
3795     case -1:
3796       rc = G10ERR_PUBKEY_ALGO;
3797       break;
3798     case 0:
3799       tty_printf (_("This key is not protected.\n"));
3800       break;
3801     case -2:
3802       tty_printf (_("Secret parts of primary key are stored on-card.\n"));
3803       ask_pass = 1;
3804       break;
3805     default:
3806       tty_printf (_("Key is protected.\n"));
3807       rc = check_secret_key ( pri_sk, 0 );
3808       if (!rc)
3809         passphrase = get_last_passphrase();
3810       break;
3811     }
3812   if (rc)
3813     goto leave;
3814
3815   algo = ask_algo (1, NULL, &use);
3816   assert (algo);
3817   nbits = ask_keysize (algo, 0);
3818   expire = ask_expire_interval (0, NULL);
3819   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3820                                                _("Really create? (y/N) ")))
3821     goto leave;
3822
3823   canceled = 0;
3824   if (ask_pass)
3825     dek = do_ask_passphrase (&s2k, 0, &canceled);
3826   else if (passphrase)
3827     {
3828       s2k = xmalloc_secure ( sizeof *s2k );
3829       s2k->mode = opt.s2k_mode;
3830       s2k->hash_algo = S2K_DIGEST_ALGO;
3831       set_next_passphrase ( passphrase );
3832       dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3833                                NULL, NULL );
3834     }
3835
3836   if (canceled)
3837     rc = GPG_ERR_CANCELED;
3838
3839   if (!rc)
3840     rc = do_create (algo, nbits, pub_keyblock, sec_keyblock,
3841                     dek, s2k, &sub_sk, cur_time, expire, 1 );
3842   xfree (dek);
3843   if (!rc)
3844     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk,
3845                           use, cur_time);
3846   if (!rc)
3847     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk,
3848                            use, cur_time);
3849   if (!rc)
3850     {
3851       okay = 1;
3852       write_status_text (STATUS_KEY_CREATED, "S");
3853     }
3854
3855  leave:
3856   if (rc)
3857     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3858   xfree (passphrase);
3859   xfree (s2k);
3860   /* Release the copy of the (now unprotected) secret keys.  */
3861   if (pri_sk)
3862     free_secret_key (pri_sk);
3863   if (sub_sk)
3864     free_secret_key (sub_sk);
3865   set_next_passphrase (NULL);
3866   return okay;
3867 }
3868
3869
3870 #ifdef ENABLE_CARD_SUPPORT
3871 /* Generate a subkey on a card. */
3872 int
3873 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3874                           int keyno, const char *serialno)
3875 {
3876   int okay=0, rc=0;
3877   KBNODE node;
3878   PKT_secret_key *pri_sk = NULL, *sub_sk;
3879   int algo;
3880   unsigned int use;
3881   u32 expire;
3882   char *passphrase = NULL;
3883   u32 cur_time;
3884   struct para_data_s *para = NULL;
3885
3886   assert (keyno >= 1 && keyno <= 3);
3887
3888   para = xcalloc (1, sizeof *para + strlen (serialno) );
3889   para->key = pSERIALNO;
3890   strcpy (para->u.value, serialno);
3891
3892   /* Break out the primary secret key */
3893   node = find_kbnode (sec_keyblock, PKT_SECRET_KEY);
3894   if (!node)
3895     {
3896       log_error("Oops; secret key not found anymore!\n");
3897       goto leave;
3898     }
3899
3900   /* Make a copy of the sk to keep the protected one in the keyblock */
3901   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3902
3903   cur_time = make_timestamp();
3904   if (pri_sk->timestamp > cur_time)
3905     {
3906       ulong d = pri_sk->timestamp - cur_time;
3907       log_info (d==1 ? _("key has been created %lu second "
3908                          "in future (time warp or clock problem)\n")
3909                      : _("key has been created %lu seconds "
3910                          "in future (time warp or clock problem)\n"), d );
3911         if (!opt.ignore_time_conflict)
3912           {
3913             rc = G10ERR_TIME_CONFLICT;
3914             goto leave;
3915           }
3916     }
3917
3918   if (pri_sk->version < 4)
3919     {
3920       log_info (_("NOTE: creating subkeys for v3 keys "
3921                   "is not OpenPGP compliant\n"));
3922       goto leave;
3923     }
3924
3925   /* Unprotect to get the passphrase. */
3926   switch( is_secret_key_protected (pri_sk) )
3927     {
3928     case -1:
3929       rc = G10ERR_PUBKEY_ALGO;
3930       break;
3931     case 0:
3932       tty_printf("This key is not protected.\n");
3933       break;
3934     default:
3935       tty_printf("Key is protected.\n");
3936       rc = check_secret_key( pri_sk, 0 );
3937       if (!rc)
3938         passphrase = get_last_passphrase();
3939       break;
3940     }
3941   if (rc)
3942     goto leave;
3943
3944   algo = PUBKEY_ALGO_RSA;
3945   expire = ask_expire_interval (0,NULL);
3946   if (keyno == 1)
3947     use = PUBKEY_USAGE_SIG;
3948   else if (keyno == 2)
3949     use = PUBKEY_USAGE_ENC;
3950   else
3951     use = PUBKEY_USAGE_AUTH;
3952   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3953                                                _("Really create? (y/N) ")))
3954     goto leave;
3955
3956   if (passphrase)
3957     set_next_passphrase (passphrase);
3958
3959   /* Note, that depending on the backend, the card key generation may
3960      update CUR_TIME.  */
3961   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3962                      &sub_sk, &cur_time, expire, para);
3963   if (!rc)
3964     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk,
3965                            use, cur_time);
3966   if (!rc)
3967     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk,
3968                            use, cur_time);
3969   if (!rc)
3970     {
3971       okay = 1;
3972       write_status_text (STATUS_KEY_CREATED, "S");
3973     }
3974
3975  leave:
3976   if (rc)
3977     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3978   xfree (passphrase);
3979   /* Release the copy of the (now unprotected) secret keys. */
3980   if (pri_sk)
3981     free_secret_key (pri_sk);
3982   set_next_passphrase( NULL );
3983   release_parameter_list (para);
3984   return okay;
3985 }
3986 #endif /* !ENABLE_CARD_SUPPORT */
3987
3988
3989 /*
3990  * Write a keyblock to an output stream
3991  */
3992 static int
3993 write_keyblock( IOBUF out, KBNODE node )
3994 {
3995   for( ; node ; node = node->next )
3996     {
3997       if(!is_deleted_kbnode(node))
3998         {
3999           int rc = build_packet( out, node->pkt );
4000           if( rc )
4001             {
4002               log_error("build_packet(%d) failed: %s\n",
4003                         node->pkt->pkttype, g10_errstr(rc) );
4004               return rc;
4005             }
4006         }
4007     }
4008
4009   return 0;
4010 }
4011
4012
4013 /* Note that timestamp is an in/out arg. */
4014 static int
4015 gen_card_key (int algo, int keyno, int is_primary,
4016               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
4017               u32 *timestamp, u32 expireval, struct para_data_s *para)
4018 {
4019 #ifdef ENABLE_CARD_SUPPORT
4020   int rc;
4021   const char *s;
4022   struct agent_card_genkey_s info;
4023   PACKET *pkt;
4024   PKT_secret_key *sk;
4025   PKT_public_key *pk;
4026
4027   assert (algo == PUBKEY_ALGO_RSA);
4028
4029   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
4030   rc = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
4031 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
4032 /*      { */
4033 /*        tty_printf ("\n"); */
4034 /*        log_error ("WARNING: key does already exists!\n"); */
4035 /*        tty_printf ("\n"); */
4036 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
4037 /*                                    _("Replace existing key? "))) */
4038 /*          rc = agent_scd_genkey (&info, keyno, 1); */
4039 /*      } */
4040
4041   if (rc)
4042     {
4043       log_error ("key generation failed: %s\n", gpg_strerror (rc));
4044       return rc;
4045     }
4046   if ( !info.n || !info.e )
4047     {
4048       log_error ("communication error with SCD\n");
4049       gcry_mpi_release (info.n);
4050       gcry_mpi_release (info.e);
4051       return gpg_error (GPG_ERR_GENERAL);
4052     }
4053
4054   if (*timestamp != info.created_at)
4055     log_info ("Note that the key does not use the suggested creation date\n");
4056   *timestamp = info.created_at;
4057
4058   pk = xcalloc (1, sizeof *pk );
4059   sk = xcalloc (1, sizeof *sk );
4060   sk->timestamp = pk->timestamp = info.created_at;
4061   sk->version = pk->version = 4;
4062   if (expireval)
4063       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
4064   sk->pubkey_algo = pk->pubkey_algo = algo;
4065   pk->pkey[0] = info.n;
4066   pk->pkey[1] = info.e;
4067   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
4068   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
4069   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
4070   sk->is_protected = 1;
4071   sk->protect.s2k.mode = 1002;
4072   s = get_parameter_value (para, pSERIALNO);
4073   if (s)
4074     {
4075       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
4076            sk->protect.ivlen++, s += 2)
4077         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
4078     }
4079
4080   if( ret_sk )
4081     *ret_sk = sk;
4082
4083   pkt = xcalloc (1,sizeof *pkt);
4084   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
4085   pkt->pkt.public_key = pk;
4086   add_kbnode(pub_root, new_kbnode( pkt ));
4087
4088   pkt = xcalloc (1,sizeof *pkt);
4089   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
4090   pkt->pkt.secret_key = sk;
4091   add_kbnode(sec_root, new_kbnode( pkt ));
4092
4093   return 0;
4094 #else
4095   return -1;
4096 #endif /*!ENABLE_CARD_SUPPORT*/
4097 }
4098
4099
4100
4101 static int
4102 gen_card_key_with_backup (int algo, int keyno, int is_primary,
4103                           KBNODE pub_root, KBNODE sec_root,
4104                           u32 timestamp,
4105                           u32 expireval, struct para_data_s *para,
4106                           const char *backup_dir)
4107 {
4108 #ifdef ENABLE_CARD_SUPPORT
4109   int rc;
4110   const char *s;
4111   PACKET *pkt;
4112   PKT_secret_key *sk, *sk_unprotected = NULL, *sk_protected = NULL;
4113   PKT_public_key *pk;
4114   size_t n;
4115   int i;
4116   unsigned int nbits;
4117
4118   /* Get the size of the key directly from the card.  */
4119   {
4120     struct agent_card_info_s info;
4121
4122     memset (&info, 0, sizeof info);
4123     if (!agent_scd_getattr ("KEY-ATTR", &info)
4124         && info.key_attr[1].algo)
4125       nbits = info.key_attr[1].nbits;
4126     else
4127       nbits = 1024; /* All pre-v2.0 cards.  */
4128     agent_release_card_info (&info);
4129   }
4130
4131   /* Create a key of this size in memory.  */
4132   rc = generate_raw_key (algo, nbits, timestamp,
4133                          &sk_unprotected, &sk_protected);
4134   if (rc)
4135     return rc;
4136
4137   /* Store the key to the card. */
4138   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
4139   if (rc)
4140     {
4141       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
4142       free_secret_key (sk_unprotected);
4143       free_secret_key (sk_protected);
4144       write_status_error ("save_key_to_card", rc);
4145       return rc;
4146     }
4147
4148   /* Get rid of the secret key parameters and store the serial numer. */
4149   sk = sk_unprotected;
4150   n = pubkey_get_nskey (sk->pubkey_algo);
4151   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
4152     {
4153       gcry_mpi_release (sk->skey[i]);
4154       sk->skey[i] = NULL;
4155     }
4156   i = pubkey_get_npkey (sk->pubkey_algo);
4157   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
4158   sk->is_protected = 1;
4159   sk->protect.s2k.mode = 1002;
4160   s = get_parameter_value (para, pSERIALNO);
4161   assert (s);
4162   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
4163        sk->protect.ivlen++, s += 2)
4164     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
4165
4166   /* Now write the *protected* secret key to the file.  */
4167   {
4168     char name_buffer[50];
4169     char *fname;
4170     IOBUF fp;
4171     mode_t oldmask;
4172
4173     keyid_from_sk (sk, NULL);
4174     snprintf (name_buffer, sizeof name_buffer, "sk_%08lX%08lX.gpg",
4175               (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
4176
4177     fname = make_filename (backup_dir, name_buffer, NULL);
4178     oldmask = umask (077);
4179     if (is_secured_filename (fname))
4180       {
4181         fp = NULL;
4182         errno = EPERM;
4183       }
4184     else
4185       fp = iobuf_create (fname);
4186     umask (oldmask);
4187     if (!fp)
4188       {
4189         rc = gpg_error_from_syserror ();
4190         log_error (_("can't create backup file `%s': %s\n"),
4191                    fname, strerror(errno) );
4192         xfree (fname);
4193         free_secret_key (sk_unprotected);
4194         free_secret_key (sk_protected);
4195         return rc;
4196       }
4197
4198     pkt = xcalloc (1, sizeof *pkt);
4199     pkt->pkttype = PKT_SECRET_KEY;
4200     pkt->pkt.secret_key = sk_protected;
4201     sk_protected = NULL;
4202
4203     rc = build_packet (fp, pkt);
4204     if (rc)
4205       {
4206         log_error("build packet failed: %s\n", g10_errstr(rc) );
4207         iobuf_cancel (fp);
4208       }
4209     else
4210       {
4211         unsigned char array[MAX_FINGERPRINT_LEN];
4212         char *fprbuf, *p;
4213
4214         iobuf_close (fp);
4215         iobuf_ioctl (NULL, 2, 0, (char*)fname);
4216         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
4217
4218         fingerprint_from_sk (sk, array, &n);
4219         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
4220         for (i=0; i < n ; i++, p += 2)
4221           sprintf (p, "%02X", array[i]);
4222         *p++ = ' ';
4223         *p = 0;
4224
4225         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
4226                                       fprbuf,
4227                                       fname, strlen (fname),
4228                                       0);
4229         xfree (fprbuf);
4230       }
4231     free_packet (pkt);
4232     xfree (pkt);
4233     xfree (fname);
4234     if (rc)
4235       {
4236         free_secret_key (sk_unprotected);
4237         return rc;
4238       }
4239   }
4240
4241   /* Create the public key from the secret key. */
4242   pk = xcalloc (1, sizeof *pk );
4243   pk->timestamp = sk->timestamp;
4244   pk->version = sk->version;
4245   if (expireval)
4246       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
4247   pk->pubkey_algo = sk->pubkey_algo;
4248   n = pubkey_get_npkey (sk->pubkey_algo);
4249   for (i=0; i < n; i++)
4250     pk->pkey[i] = mpi_copy (sk->skey[i]);
4251
4252   /* Build packets and add them to the node lists.  */
4253   pkt = xcalloc (1,sizeof *pkt);
4254   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
4255   pkt->pkt.public_key = pk;
4256   add_kbnode(pub_root, new_kbnode( pkt ));
4257
4258   pkt = xcalloc (1,sizeof *pkt);
4259   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
4260   pkt->pkt.secret_key = sk;
4261   add_kbnode(sec_root, new_kbnode( pkt ));
4262
4263   return 0;
4264 #else
4265   return -1;
4266 #endif /*!ENABLE_CARD_SUPPORT*/
4267 }
4268
4269
4270 #ifdef ENABLE_CARD_SUPPORT
4271 int
4272 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
4273 {
4274   int rc;
4275   unsigned char *rsa_n = NULL;
4276   unsigned char *rsa_e = NULL;
4277   unsigned char *rsa_p = NULL;
4278   unsigned char *rsa_q = NULL;
4279   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
4280   unsigned char *sexp = NULL;
4281   unsigned char *p;
4282   char numbuf[55], numbuf2[50];
4283
4284   assert (is_RSA (sk->pubkey_algo));
4285   assert (!sk->is_protected);
4286
4287   /* Copy the parameters into straight buffers. */
4288   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_n, &rsa_n_len, sk->skey[0]);
4289   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_e, &rsa_e_len, sk->skey[1]);
4290   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_p, &rsa_p_len, sk->skey[3]);
4291   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_q, &rsa_q_len, sk->skey[4]);
4292   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
4293     {
4294       rc = G10ERR_INV_ARG;
4295       goto leave;
4296     }
4297
4298    /* Put the key into an S-expression. */
4299   sexp = p = xmalloc_secure (30
4300                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
4301                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
4302
4303   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
4304   sprintf (numbuf, "%u:", (unsigned int)rsa_n_len);
4305   p = stpcpy (p, numbuf);
4306   memcpy (p, rsa_n, rsa_n_len);
4307   p += rsa_n_len;
4308
4309   sprintf (numbuf, ")(1:e%u:", (unsigned int)rsa_e_len);
4310   p = stpcpy (p, numbuf);
4311   memcpy (p, rsa_e, rsa_e_len);
4312   p += rsa_e_len;
4313
4314   sprintf (numbuf, ")(1:p%u:", (unsigned int)rsa_p_len);
4315   p = stpcpy (p, numbuf);
4316   memcpy (p, rsa_p, rsa_p_len);
4317   p += rsa_p_len;
4318
4319   sprintf (numbuf, ")(1:q%u:", (unsigned int)rsa_q_len);
4320   p = stpcpy (p, numbuf);
4321   memcpy (p, rsa_q, rsa_q_len);
4322   p += rsa_q_len;
4323
4324   p = stpcpy (p,"))(10:created-at");
4325   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
4326   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
4327   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
4328
4329   /* Fixme: Unfortunately we don't have the serialnumber available -
4330      thus we can't pass&n