ssh-keygen.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1994 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * Identity and host key generation and maintenance.
   6  *
   7  * As far as I am concerned, the code I have written for this software
   8  * can be used freely for any purpose.  Any derived versions of this
   9  * software must be clearly marked as such, and if the derived work is
  10  * incompatible with the protocol description in the RFC file, it must be
  11  * called by a name other than "ssh" or "Secure Shell".
  12  */
  13
  14 #include "includes.h"
  15 RCSID("$OpenBSD: ssh-keygen.c,v 1.34 2000/11/15 20:24:43 millert Exp $");
  16
  17 #include <openssl/evp.h>
  18 #include <openssl/pem.h>
  19 #include <openssl/rsa.h>
  20 #include <openssl/dsa.h>
  21
  22 #include "ssh.h"
  23 #include "xmalloc.h"
  24 #include "key.h"
  25 #include "rsa.h"
  26 #include "authfile.h"
  27 #include "uuencode.h"
  28
  29 #include "buffer.h"
  30 #include "bufaux.h"
  31
  32 /* Number of bits in the RSA/DSA key.  This value can be changed on the command line. */
  33 int bits = 1024;
  34
  35 /*
  36  * Flag indicating that we just want to change the passphrase.  This can be
  37  * set on the command line.
  38  */
  39 int change_passphrase = 0;
  40
  41 /*
  42  * Flag indicating that we just want to change the comment.  This can be set
  43  * on the command line.
  44  */
  45 int change_comment = 0;
  46
  47 int quiet = 0;
  48
  49 /* Flag indicating that we just want to see the key fingerprint */
  50 int print_fingerprint = 0;
  51
  52 /* The identity file name, given on the command line or entered by the user. */
  53 char identity_file[1024];
  54 int have_identity = 0;
  55
  56 /* This is set to the passphrase if given on the command line. */
  57 char *identity_passphrase = NULL;
  58
  59 /* This is set to the new passphrase if given on the command line. */
  60 char *identity_new_passphrase = NULL;
  61
  62 /* This is set to the new comment if given on the command line. */
  63 char *identity_comment = NULL;
  64
  65 /* Dump public key file in format used by real and the original SSH 2 */
  66 int convert_to_ssh2 = 0;
  67 int convert_from_ssh2 = 0;
  68 int print_public = 0;
  69
  70 /* key type */
  71 int dsa_mode = 0;               /* compat */
  72 char *key_type_name = NULL;
  73
  74 /* argv0 */
  75 #ifdef HAVE___PROGNAME
  76 extern char *__progname;
  77 #else
  78 char *__progname;
  79 #endif
  80
  81 char hostname[MAXHOSTNAMELEN];
  82
  83 void
  84 ask_filename(struct passwd *pw, const char *prompt)
  85 {
  86         char buf[1024];
  87         snprintf(identity_file, sizeof(identity_file), "%s/%s",
  88             pw->pw_dir,
  89             dsa_mode ? SSH_CLIENT_ID_DSA: SSH_CLIENT_IDENTITY);
  90         printf("%s (%s): ", prompt, identity_file);
  91         fflush(stdout);
  92         if (fgets(buf, sizeof(buf), stdin) == NULL)
  93                 exit(1);
  94         if (strchr(buf, '\n'))
  95                 *strchr(buf, '\n') = 0;
  96         if (strcmp(buf, "") != 0)
  97                 strlcpy(identity_file, buf, sizeof(identity_file));
  98         have_identity = 1;
  99 }
 100
 101 int
 102 try_load_key(char *filename, Key *k)
 103 {
 104         int success = 1;
 105         if (!load_private_key(filename, "", k, NULL)) {
 106                 char *pass = read_passphrase("Enter passphrase: ", 1);
 107                 if (!load_private_key(filename, pass, k, NULL)) {
 108                         success = 0;
 109                 }
 110                 memset(pass, 0, strlen(pass));
 111                 xfree(pass);
 112         }
 113         return success;
 114 }
 115
 116 #define SSH_COM_PUBLIC_BEGIN            "---- BEGIN SSH2 PUBLIC KEY ----"
 117 #define SSH_COM_PUBLIC_END              "---- END SSH2 PUBLIC KEY ----"
 118 #define SSH_COM_PRIVATE_BEGIN           "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----"
 119 #define SSH_COM_PRIVATE_KEY_MAGIC       0x3f6ff9eb
 120
 121 void
 122 do_convert_to_ssh2(struct passwd *pw)
 123 {
 124         Key *k;
 125         int len;
 126         unsigned char *blob;
 127         struct stat st;
 128
 129         if (!have_identity)
 130                 ask_filename(pw, "Enter file in which the key is");
 131         if (stat(identity_file, &st) < 0) {
 132                 perror(identity_file);
 133                 exit(1);
 134         }
 135         k = key_new(KEY_UNSPEC);
 136         if (!try_load_key(identity_file, k)) {
 137                 fprintf(stderr, "load failed\n");
 138                 exit(1);
 139         }
 140         key_to_blob(k, &blob, &len);
 141         fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);
 142         fprintf(stdout,
 143             "Comment: \"%d-bit %s, converted from OpenSSH by %s@%s\"\n",
 144             key_size(k), key_type(k),
 145             pw->pw_name, hostname);
 146         dump_base64(stdout, blob, len);
 147         fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END);
 148         key_free(k);
 149         xfree(blob);
 150         exit(0);
 151 }
 152
 153 void
 154 buffer_get_bignum_bits(Buffer *b, BIGNUM *value)
 155 {
 156         int bits = buffer_get_int(b);
 157         int bytes = (bits + 7) / 8;
 158         if (buffer_len(b) < bytes)
 159                 fatal("buffer_get_bignum_bits: input buffer too small");
 160         BN_bin2bn((unsigned char *)buffer_ptr(b), bytes, value);
 161         buffer_consume(b, bytes);
 162 }
 163
 164 Key *
 165 do_convert_private_ssh2_from_blob(char *blob, int blen)
 166 {
 167         Buffer b;
 168         DSA *dsa;
 169         Key *key = NULL;
 170         int ignore, magic, rlen;
 171         char *type, *cipher;
 172
 173         buffer_init(&b);
 174         buffer_append(&b, blob, blen);
 175
 176         magic  = buffer_get_int(&b);
 177         if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {
 178                 error("bad magic 0x%x != 0x%x", magic, SSH_COM_PRIVATE_KEY_MAGIC);
 179                 buffer_free(&b);
 180                 return NULL;
 181         }
 182         ignore = buffer_get_int(&b);
 183         type   = buffer_get_string(&b, NULL);
 184         cipher = buffer_get_string(&b, NULL);
 185         ignore = buffer_get_int(&b);
 186         ignore = buffer_get_int(&b);
 187         ignore = buffer_get_int(&b);
 188         xfree(type);
 189
 190         if (strcmp(cipher, "none") != 0) {
 191                 error("unsupported cipher %s", cipher);
 192                 xfree(cipher);
 193                 buffer_free(&b);
 194                 return NULL;
 195         }
 196         xfree(cipher);
 197
 198         key = key_new(KEY_DSA);
 199         dsa = key->dsa;
 200         dsa->priv_key = BN_new();
 201         if (dsa->priv_key == NULL) {
 202                 error("alloc priv_key failed");
 203                 key_free(key);
 204                 return NULL;
 205         }
 206         buffer_get_bignum_bits(&b, dsa->p);
 207         buffer_get_bignum_bits(&b, dsa->g);
 208         buffer_get_bignum_bits(&b, dsa->q);
 209         buffer_get_bignum_bits(&b, dsa->pub_key);
 210         buffer_get_bignum_bits(&b, dsa->priv_key);
 211         rlen = buffer_len(&b);
 212         if(rlen != 0)
 213                 error("do_convert_private_ssh2_from_blob: remaining bytes in key blob %d", rlen);
 214         buffer_free(&b);
 215         return key;
 216 }
 217
 218 void
 219 do_convert_from_ssh2(struct passwd *pw)
 220 {
 221         Key *k;
 222         int blen;
 223         char line[1024], *p;
 224         char blob[8096];
 225         char encoded[8096];
 226         struct stat st;
 227         int escaped = 0, private = 0, ok;
 228         FILE *fp;
 229
 230         if (!have_identity)
 231                 ask_filename(pw, "Enter file in which the key is");
 232         if (stat(identity_file, &st) < 0) {
 233                 perror(identity_file);
 234                 exit(1);
 235         }
 236         fp = fopen(identity_file, "r");
 237         if (fp == NULL) {
 238                 perror(identity_file);
 239                 exit(1);
 240         }
 241         encoded[0] = '\0';
 242         while (fgets(line, sizeof(line), fp)) {
 243                 if (!(p = strchr(line, '\n'))) {
 244                         fprintf(stderr, "input line too long.\n");
 245                         exit(1);
 246                 }
 247                 if (p > line && p[-1] == '\\')
 248                         escaped++;
 249                 if (strncmp(line, "----", 4) == 0 ||
 250                     strstr(line, ": ") != NULL) {
 251                         if (strstr(line, SSH_COM_PRIVATE_BEGIN) != NULL)
 252                                 private = 1;
 253                         fprintf(stderr, "ignore: %s", line);
 254                         continue;
 255                 }
 256                 if (escaped) {
 257                         escaped--;
 258                         fprintf(stderr, "escaped: %s", line);
 259                         continue;
 260                 }
 261                 *p = '\0';
 262                 strlcat(encoded, line, sizeof(encoded));
 263         }
 264         blen = uudecode(encoded, (unsigned char *)blob, sizeof(blob));
 265         if (blen < 0) {
 266                 fprintf(stderr, "uudecode failed.\n");
 267                 exit(1);
 268         }
 269         k = private ?
 270             do_convert_private_ssh2_from_blob(blob, blen) :
 271             key_from_blob(blob, blen);
 272         if (k == NULL) {
 273                 fprintf(stderr, "decode blob failed.\n");
 274                 exit(1);
 275         }
 276         ok = private ?
 277             PEM_write_DSAPrivateKey(stdout, k->dsa, NULL, NULL, 0, NULL, NULL) :
 278             key_write(k, stdout);
 279         if (!ok) {
 280                 fprintf(stderr, "key write failed");
 281                 exit(1);
 282         }
 283         key_free(k);
 284         fprintf(stdout, "\n");
 285         fclose(fp);
 286         exit(0);
 287 }
 288
 289 void
 290 do_print_public(struct passwd *pw)
 291 {
 292         Key *k;
 293         struct stat st;
 294
 295         if (!have_identity)
 296                 ask_filename(pw, "Enter file in which the key is");
 297         if (stat(identity_file, &st) < 0) {
 298                 perror(identity_file);
 299                 exit(1);
 300         }
 301         k = key_new(KEY_UNSPEC);
 302         if (!try_load_key(identity_file, k)) {
 303                 fprintf(stderr, "load failed\n");
 304                 exit(1);
 305         }
 306         if (!key_write(k, stdout))
 307                 fprintf(stderr, "key_write failed");
 308         key_free(k);
 309         fprintf(stdout, "\n");
 310         exit(0);
 311 }
 312
 313 void
 314 do_fingerprint(struct passwd *pw)
 315 {
 316
 317         FILE *f;
 318         Key *public;
 319         char *comment = NULL, *cp, *ep, line[16*1024];
 320         int i, skip = 0, num = 1, invalid = 1, success = 0;
 321         unsigned int ignore;
 322         struct stat st;
 323
 324         if (!have_identity)
 325                 ask_filename(pw, "Enter file in which the key is");
 326         if (stat(identity_file, &st) < 0) {
 327                 perror(identity_file);
 328                 exit(1);
 329         }
 330         public = key_new(KEY_RSA1);
 331         if (load_public_key(identity_file, public, &comment)) {
 332                 success = 1;
 333         } else {
 334                 key_free(public);
 335                 public = key_new(KEY_UNSPEC);
 336                 if (try_load_public_key(identity_file, public, &comment))
 337                         success = 1;
 338                 else
 339                         error("try_load_public_key KEY_UNSPEC failed");
 340         }
 341         if (success) {
 342                 printf("%d %s %s\n", key_size(public), key_fingerprint(public), comment);
 343                 key_free(public);
 344                 xfree(comment);
 345                 exit(0);
 346         }
 347
 348         /* XXX RSA1 only */
 349
 350         public = key_new(KEY_RSA1);
 351         f = fopen(identity_file, "r");
 352         if (f != NULL) {
 353                 while (fgets(line, sizeof(line), f)) {
 354                         i = strlen(line) - 1;
 355                         if (line[i] != '\n') {
 356                                 error("line %d too long: %.40s...", num, line);
 357                                 skip = 1;
 358                                 continue;
 359                         }
 360                         num++;
 361                         if (skip) {
 362                                 skip = 0;
 363                                 continue;
 364                         }
 365                         line[i] = '\0';
 366
 367                         /* Skip leading whitespace, empty and comment lines. */
 368                         for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
 369                                 ;
 370                         if (!*cp || *cp == '\n' || *cp == '#')
 371                                 continue ;
 372                         i = strtol(cp, &ep, 10);
 373                         if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {
 374                                 int quoted = 0;
 375                                 comment = cp;
 376                                 for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) {
 377                                         if (*cp == '\\' && cp[1] == '"')
 378                                                 cp++;   /* Skip both */
 379                                         else if (*cp == '"')
 380                                                 quoted = !quoted;
 381                                 }
 382                                 if (!*cp)
 383                                         continue;
 384                                 *cp++ = '\0';
 385                         }
 386                         ep = cp;
 387                         if (auth_rsa_read_key(&cp, &ignore, public->rsa->e, public->rsa->n)) {
 388                                 invalid = 0;
 389                                 comment = *cp ? cp : comment;
 390                                 printf("%d %s %s\n", key_size(public),
 391                                     key_fingerprint(public),
 392                                     comment ? comment : "no comment");
 393                         }
 394                 }
 395                 fclose(f);
 396         }
 397         key_free(public);
 398         if (invalid) {
 399                 printf("%s is not a valid key file.\n", identity_file);
 400                 exit(1);
 401         }
 402         exit(0);
 403 }
 404
 405 /*
 406  * Perform changing a passphrase.  The argument is the passwd structure
 407  * for the current user.
 408  */
 409 void
 410 do_change_passphrase(struct passwd *pw)
 411 {
 412         char *comment;
 413         char *old_passphrase, *passphrase1, *passphrase2;
 414         struct stat st;
 415         Key *private;
 416         Key *public;
 417         int type = KEY_RSA1;
 418
 419         if (!have_identity)
 420                 ask_filename(pw, "Enter file in which the key is");
 421         if (stat(identity_file, &st) < 0) {
 422                 perror(identity_file);
 423                 exit(1);
 424         }
 425         public = key_new(type);
 426         if (!load_public_key(identity_file, public, NULL)) {
 427                 type = KEY_UNSPEC;
 428         } else {
 429                 /* Clear the public key since we are just about to load the whole file. */
 430                 key_free(public);
 431         }
 432         /* Try to load the file with empty passphrase. */
 433         private = key_new(type);
 434         if (!load_private_key(identity_file, "", private, &comment)) {
 435                 if (identity_passphrase)
 436                         old_passphrase = xstrdup(identity_passphrase);
 437                 else
 438                         old_passphrase = read_passphrase("Enter old passphrase: ", 1);
 439                 if (!load_private_key(identity_file, old_passphrase, private, &comment)) {
 440                         memset(old_passphrase, 0, strlen(old_passphrase));
 441                         xfree(old_passphrase);
 442                         printf("Bad passphrase.\n");
 443                         exit(1);
 444                 }
 445                 memset(old_passphrase, 0, strlen(old_passphrase));
 446                 xfree(old_passphrase);
 447         }
 448         printf("Key has comment '%s'\n", comment);
 449
 450         /* Ask the new passphrase (twice). */
 451         if (identity_new_passphrase) {
 452                 passphrase1 = xstrdup(identity_new_passphrase);
 453                 passphrase2 = NULL;
 454         } else {
 455                 passphrase1 =
 456                         read_passphrase("Enter new passphrase (empty for no passphrase): ", 1);
 457                 passphrase2 = read_passphrase("Enter same passphrase again: ", 1);
 458
 459                 /* Verify that they are the same. */
 460                 if (strcmp(passphrase1, passphrase2) != 0) {
 461                         memset(passphrase1, 0, strlen(passphrase1));
 462                         memset(passphrase2, 0, strlen(passphrase2));
 463                         xfree(passphrase1);
 464                         xfree(passphrase2);
 465                         printf("Pass phrases do not match.  Try again.\n");
 466                         exit(1);
 467                 }
 468                 /* Destroy the other copy. */
 469                 memset(passphrase2, 0, strlen(passphrase2));
 470                 xfree(passphrase2);
 471         }
 472
 473         /* Save the file using the new passphrase. */
 474         if (!save_private_key(identity_file, passphrase1, private, comment)) {
 475                 printf("Saving the key failed: %s: %s.\n",
 476                        identity_file, strerror(errno));
 477                 memset(passphrase1, 0, strlen(passphrase1));
 478                 xfree(passphrase1);
 479                 key_free(private);
 480                 xfree(comment);
 481                 exit(1);
 482         }
 483         /* Destroy the passphrase and the copy of the key in memory. */
 484         memset(passphrase1, 0, strlen(passphrase1));
 485         xfree(passphrase1);
 486         key_free(private);               /* Destroys contents */
 487         xfree(comment);
 488
 489         printf("Your identification has been saved with the new passphrase.\n");
 490         exit(0);
 491 }
 492
 493 /*
 494  * Change the comment of a private key file.
 495  */
 496 void
 497 do_change_comment(struct passwd *pw)
 498 {
 499         char new_comment[1024], *comment;
 500         Key *private;
 501         Key *public;
 502         char *passphrase;
 503         struct stat st;
 504         FILE *f;
 505
 506         if (!have_identity)
 507                 ask_filename(pw, "Enter file in which the key is");
 508         if (stat(identity_file, &st) < 0) {
 509                 perror(identity_file);
 510                 exit(1);
 511         }
 512         /*
 513          * Try to load the public key from the file the verify that it is
 514          * readable and of the proper format.
 515          */
 516         public = key_new(KEY_RSA1);
 517         if (!load_public_key(identity_file, public, NULL)) {
 518                 printf("%s is not a valid key file.\n", identity_file);
 519                 exit(1);
 520         }
 521
 522         private = key_new(KEY_RSA1);
 523         if (load_private_key(identity_file, "", private, &comment))
 524                 passphrase = xstrdup("");
 525         else {
 526                 if (identity_passphrase)
 527                         passphrase = xstrdup(identity_passphrase);
 528                 else if (identity_new_passphrase)
 529                         passphrase = xstrdup(identity_new_passphrase);
 530                 else
 531                         passphrase = read_passphrase("Enter passphrase: ", 1);
 532                 /* Try to load using the passphrase. */
 533                 if (!load_private_key(identity_file, passphrase, private, &comment)) {
 534                         memset(passphrase, 0, strlen(passphrase));
 535                         xfree(passphrase);
 536                         printf("Bad passphrase.\n");
 537                         exit(1);
 538                 }
 539         }
 540         printf("Key now has comment '%s'\n", comment);
 541
 542         if (identity_comment) {
 543                 strlcpy(new_comment, identity_comment, sizeof(new_comment));
 544         } else {
 545                 printf("Enter new comment: ");
 546                 fflush(stdout);
 547                 if (!fgets(new_comment, sizeof(new_comment), stdin)) {
 548                         memset(passphrase, 0, strlen(passphrase));
 549                         key_free(private);
 550                         exit(1);
 551                 }
 552                 if (strchr(new_comment, '\n'))
 553                         *strchr(new_comment, '\n') = 0;
 554         }
 555
 556         /* Save the file using the new passphrase. */
 557         if (!save_private_key(identity_file, passphrase, private, new_comment)) {
 558                 printf("Saving the key failed: %s: %s.\n",
 559                        identity_file, strerror(errno));
 560                 memset(passphrase, 0, strlen(passphrase));
 561                 xfree(passphrase);
 562                 key_free(private);
 563                 xfree(comment);
 564                 exit(1);
 565         }
 566         memset(passphrase, 0, strlen(passphrase));
 567         xfree(passphrase);
 568         key_free(private);
 569
 570         strlcat(identity_file, ".pub", sizeof(identity_file));
 571         f = fopen(identity_file, "w");
 572         if (!f) {
 573                 printf("Could not save your public key in %s\n", identity_file);
 574                 exit(1);
 575         }
 576         if (!key_write(public, f))
 577                 fprintf(stderr, "write key failed");
 578         key_free(public);
 579         fprintf(f, " %s\n", new_comment);
 580         fclose(f);
 581
 582         xfree(comment);
 583
 584         printf("The comment in your key file has been changed.\n");
 585         exit(0);
 586 }
 587
 588 void
 589 usage(void)
 590 {
 591         printf("Usage: %s [-lpqxXyc] [-t type] [-b bits] [-f file] [-C comment] [-N new-pass] [-P pass]\n", __progname);
 592         exit(1);
 593 }
 594
 595 /*
 596  * Main program for key management.
 597  */
 598 int
 599 main(int ac, char **av)
 600 {
 601         char dotsshdir[16 * 1024], comment[1024], *passphrase1, *passphrase2;
 602         struct passwd *pw;
 603         int opt;
 604         struct stat st;
 605         FILE *f;
 606         int type = KEY_RSA1;
 607         Key *private;
 608         Key *public;
 609
 610         extern int optind;
 611         extern char *optarg;
 612
 613         __progname = get_progname(av[0]);
 614         init_rng();
 615
 616         SSLeay_add_all_algorithms();
 617
 618         /* we need this for the home * directory.  */
 619         pw = getpwuid(getuid());
 620         if (!pw) {
 621                 printf("You don't exist, go away!\n");
 622                 exit(1);
 623         }
 624         if (gethostname(hostname, sizeof(hostname)) < 0) {
 625                 perror("gethostname");
 626                 exit(1);
 627         }
 628
 629         while ((opt = getopt(ac, av, "dqpclRxXyb:f:t:P:N:C:")) != EOF) {
 630                 switch (opt) {
 631                 case 'b':
 632                         bits = atoi(optarg);
 633                         if (bits < 512 || bits > 32768) {
 634                                 printf("Bits has bad value.\n");
 635                                 exit(1);
 636                         }
 637                         break;
 638
 639                 case 'l':
 640                         print_fingerprint = 1;
 641                         break;
 642
 643                 case 'p':
 644                         change_passphrase = 1;
 645                         break;
 646
 647                 case 'c':
 648                         change_comment = 1;
 649                         break;
 650
 651                 case 'f':
 652                         strlcpy(identity_file, optarg, sizeof(identity_file));
 653                         have_identity = 1;
 654                         break;
 655
 656                 case 'P':
 657                         identity_passphrase = optarg;
 658                         break;
 659
 660                 case 'N':
 661                         identity_new_passphrase = optarg;
 662                         break;
 663
 664                 case 'C':
 665                         identity_comment = optarg;
 666                         break;
 667
 668                 case 'q':
 669                         quiet = 1;
 670                         break;
 671
 672                 case 'R':
 673                         /* unused */
 674                         exit(0);
 675                         break;
 676
 677                 case 'x':
 678                         convert_to_ssh2 = 1;
 679                         break;
 680
 681                 case 'X':
 682                         convert_from_ssh2 = 1;
 683                         break;
 684
 685                 case 'y':
 686                         print_public = 1;
 687                         break;
 688
 689                 case 'd':
 690                         key_type_name = "dsa";
 691                         dsa_mode = 1;
 692                         break;
 693
 694                 case 't':
 695                         key_type_name = optarg;
 696                         dsa_mode = (strcmp(optarg, "dsa") == 0);
 697                         break;
 698
 699                 case '?':
 700                 default:
 701                         usage();
 702                 }
 703         }
 704         if (optind < ac) {
 705                 printf("Too many arguments.\n");
 706                 usage();
 707         }
 708         if (change_passphrase && change_comment) {
 709                 printf("Can only have one of -p and -c.\n");
 710                 usage();
 711         }
 712         if (print_fingerprint)
 713                 do_fingerprint(pw);
 714         if (change_passphrase)
 715                 do_change_passphrase(pw);
 716         if (change_comment)
 717                 do_change_comment(pw);
 718         if (convert_to_ssh2)
 719                 do_convert_to_ssh2(pw);
 720         if (convert_from_ssh2)
 721                 do_convert_from_ssh2(pw);
 722         if (print_public)
 723                 do_print_public(pw);
 724
 725         arc4random_stir();
 726
 727         if (key_type_name != NULL) {
 728                 type = key_type_from_name(key_type_name);
 729                 if (type == KEY_UNSPEC) {
 730                         fprintf(stderr, "unknown key type %s\n", key_type_name);
 731                         exit(1);
 732                 }
 733         }
 734         if (!quiet)
 735                 printf("Generating public/private key pair.\n");
 736         private = key_generate(type, bits);
 737         if (private == NULL) {
 738                 fprintf(stderr, "key_generate failed");
 739                 exit(1);
 740         }
 741         public  = key_from_private(private);
 742
 743         if (!have_identity)
 744                 ask_filename(pw, "Enter file in which to save the key");
 745
 746         /* Create ~/.ssh directory if it doesn\'t already exist. */
 747         snprintf(dotsshdir, sizeof dotsshdir, "%s/%s", pw->pw_dir, SSH_USER_DIR);
 748         if (strstr(identity_file, dotsshdir) != NULL &&
 749             stat(dotsshdir, &st) < 0) {
 750                 if (mkdir(dotsshdir, 0700) < 0)
 751                         error("Could not create directory '%s'.", dotsshdir);
 752                 else if (!quiet)
 753                         printf("Created directory '%s'.\n", dotsshdir);
 754         }
 755         /* If the file already exists, ask the user to confirm. */
 756         if (stat(identity_file, &st) >= 0) {
 757                 char yesno[3];
 758                 printf("%s already exists.\n", identity_file);
 759                 printf("Overwrite (y/n)? ");
 760                 fflush(stdout);
 761                 if (fgets(yesno, sizeof(yesno), stdin) == NULL)
 762                         exit(1);
 763                 if (yesno[0] != 'y' && yesno[0] != 'Y')
 764                         exit(1);
 765         }
 766         /* Ask for a passphrase (twice). */
 767         if (identity_passphrase)
 768                 passphrase1 = xstrdup(identity_passphrase);
 769         else if (identity_new_passphrase)
 770                 passphrase1 = xstrdup(identity_new_passphrase);
 771         else {
 772 passphrase_again:
 773                 passphrase1 =
 774                         read_passphrase("Enter passphrase (empty for no passphrase): ", 1);
 775                 passphrase2 = read_passphrase("Enter same passphrase again: ", 1);
 776                 if (strcmp(passphrase1, passphrase2) != 0) {
 777                         /* The passphrases do not match.  Clear them and retry. */
 778                         memset(passphrase1, 0, strlen(passphrase1));
 779                         memset(passphrase2, 0, strlen(passphrase2));
 780                         xfree(passphrase1);
 781                         xfree(passphrase2);
 782                         printf("Passphrases do not match.  Try again.\n");
 783                         goto passphrase_again;
 784                 }
 785                 /* Clear the other copy of the passphrase. */
 786                 memset(passphrase2, 0, strlen(passphrase2));
 787                 xfree(passphrase2);
 788         }
 789
 790         if (identity_comment) {
 791                 strlcpy(comment, identity_comment, sizeof(comment));
 792         } else {
 793                 /* Create default commend field for the passphrase. */
 794                 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name, hostname);
 795         }
 796
 797         /* Save the key with the given passphrase and comment. */
 798         if (!save_private_key(identity_file, passphrase1, private, comment)) {
 799                 printf("Saving the key failed: %s: %s.\n",
 800                     identity_file, strerror(errno));
 801                 memset(passphrase1, 0, strlen(passphrase1));
 802                 xfree(passphrase1);
 803                 exit(1);
 804         }
 805         /* Clear the passphrase. */
 806         memset(passphrase1, 0, strlen(passphrase1));
 807         xfree(passphrase1);
 808
 809         /* Clear the private key and the random number generator. */
 810         key_free(private);
 811         arc4random_stir();
 812
 813         if (!quiet)
 814                 printf("Your identification has been saved in %s.\n", identity_file);
 815
 816         strlcat(identity_file, ".pub", sizeof(identity_file));
 817         f = fopen(identity_file, "w");
 818         if (!f) {
 819                 printf("Could not save your public key in %s\n", identity_file);
 820                 exit(1);
 821         }
 822         if (!key_write(public, f))
 823                 fprintf(stderr, "write key failed");
 824         fprintf(f, " %s\n", comment);
 825         fclose(f);
 826
 827         if (!quiet) {
 828                 printf("Your public key has been saved in %s.\n",
 829                     identity_file);
 830                 printf("The key fingerprint is:\n");
 831                 printf("%s %s\n", key_fingerprint(public), comment);
 832         }
 833
 834         key_free(public);
 835         exit(0);
 836 }