[BACK]Return to ssh-keygen.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/ssh-keygen.c between version 1.152 and 1.177

version 1.152, 2006/07/26 13:57:17 version 1.177, 2010/02/08 10:50:20
Line 12 
Line 12 
  * called by a name other than "ssh" or "Secure Shell".   * called by a name other than "ssh" or "Secure Shell".
  */   */
   
 #include "includes.h"  
   
 #include <sys/types.h>  #include <sys/types.h>
   #include <sys/socket.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <sys/param.h>  #include <sys/param.h>
   
Line 24 
Line 23 
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <pwd.h>  #include <pwd.h>
   #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
Line 34 
Line 34 
 #include "authfile.h"  #include "authfile.h"
 #include "uuencode.h"  #include "uuencode.h"
 #include "buffer.h"  #include "buffer.h"
 #include "bufaux.h"  
 #include "pathnames.h"  #include "pathnames.h"
 #include "log.h"  #include "log.h"
 #include "misc.h"  #include "misc.h"
Line 42 
Line 41 
 #include "hostfile.h"  #include "hostfile.h"
 #include "dns.h"  #include "dns.h"
   
 #ifdef SMARTCARD  #ifdef ENABLE_PKCS11
 #include "scard.h"  #include "ssh-pkcs11.h"
 #endif  #endif
   
 /* Number of bits in the RSA/DSA key.  This value can be set on the command line. */  /* Number of bits in the RSA/DSA key.  This value can be set on the command line. */
Line 65 
Line 64 
   
 int quiet = 0;  int quiet = 0;
   
   int log_level = SYSLOG_LEVEL_INFO;
   
 /* Flag indicating that we want to hash a known_hosts file */  /* Flag indicating that we want to hash a known_hosts file */
 int hash_hosts = 0;  int hash_hosts = 0;
 /* Flag indicating that we want lookup a host in known_hosts file */  /* Flag indicating that we want lookup a host in known_hosts file */
Line 126 
Line 127 
                         name = _PATH_SSH_CLIENT_ID_RSA;                          name = _PATH_SSH_CLIENT_ID_RSA;
                         break;                          break;
                 default:                  default:
                         fprintf(stderr, "bad key type");                          fprintf(stderr, "bad key type\n");
                         exit(1);                          exit(1);
                         break;                          break;
                 }                  }
Line 135 
Line 136 
         fprintf(stderr, "%s (%s): ", prompt, identity_file);          fprintf(stderr, "%s (%s): ", prompt, identity_file);
         if (fgets(buf, sizeof(buf), stdin) == NULL)          if (fgets(buf, sizeof(buf), stdin) == NULL)
                 exit(1);                  exit(1);
         if (strchr(buf, '\n'))          buf[strcspn(buf, "\n")] = '\0';
                 *strchr(buf, '\n') = 0;  
         if (strcmp(buf, "") != 0)          if (strcmp(buf, "") != 0)
                 strlcpy(identity_file, buf, sizeof(identity_file));                  strlcpy(identity_file, buf, sizeof(identity_file));
         have_identity = 1;          have_identity = 1;
Line 173 
Line 173 
         Key *k;          Key *k;
         u_int len;          u_int len;
         u_char *blob;          u_char *blob;
           char comment[61];
         struct stat st;          struct stat st;
   
         if (!have_identity)          if (!have_identity)
Line 195 
Line 196 
                 fprintf(stderr, "key_to_blob failed\n");                  fprintf(stderr, "key_to_blob failed\n");
                 exit(1);                  exit(1);
         }          }
         fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);          /* Comment + surrounds must fit into 72 chars (RFC 4716 sec 3.3) */
         fprintf(stdout,          snprintf(comment, sizeof(comment),
             "Comment: \"%u-bit %s, converted from OpenSSH by %s@%s\"\n",              "%u-bit %s, converted by %s@%s from OpenSSH",
             key_size(k), key_type(k),              key_size(k), key_type(k),
             pw->pw_name, hostname);              pw->pw_name, hostname);
   
           fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);
           fprintf(stdout, "Comment: \"%s\"\n", comment);
         dump_base64(stdout, blob, len);          dump_base64(stdout, blob, len);
         fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END);          fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END);
         key_free(k);          key_free(k);
Line 216 
Line 220 
         if (buffer_len(b) < bytes)          if (buffer_len(b) < bytes)
                 fatal("buffer_get_bignum_bits: input buffer too small: "                  fatal("buffer_get_bignum_bits: input buffer too small: "
                     "need %d have %d", bytes, buffer_len(b));                      "need %d have %d", bytes, buffer_len(b));
         BN_bin2bn(buffer_ptr(b), bytes, value);          if (BN_bin2bn(buffer_ptr(b), bytes, value) == NULL)
                   fatal("buffer_get_bignum_bits: BN_bin2bn failed");
         buffer_consume(b, bytes);          buffer_consume(b, bytes);
 }  }
   
Line 234 
Line 239 
         buffer_init(&b);          buffer_init(&b);
         buffer_append(&b, blob, blen);          buffer_append(&b, blob, blen);
   
         magic  = buffer_get_int(&b);          magic = buffer_get_int(&b);
         if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {          if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {
                 error("bad magic 0x%x != 0x%x", magic, SSH_COM_PRIVATE_KEY_MAGIC);                  error("bad magic 0x%x != 0x%x", magic, SSH_COM_PRIVATE_KEY_MAGIC);
                 buffer_free(&b);                  buffer_free(&b);
Line 246 
Line 251 
         i2 = buffer_get_int(&b);          i2 = buffer_get_int(&b);
         i3 = buffer_get_int(&b);          i3 = buffer_get_int(&b);
         i4 = buffer_get_int(&b);          i4 = buffer_get_int(&b);
         debug("ignore (%d %d %d %d)", i1,i2,i3,i4);          debug("ignore (%d %d %d %d)", i1, i2, i3, i4);
         if (strcmp(cipher, "none") != 0) {          if (strcmp(cipher, "none") != 0) {
                 error("unsupported cipher %s", cipher);                  error("unsupported cipher %s", cipher);
                 xfree(cipher);                  xfree(cipher);
Line 277 
Line 282 
                 buffer_get_bignum_bits(&b, key->dsa->priv_key);                  buffer_get_bignum_bits(&b, key->dsa->priv_key);
                 break;                  break;
         case KEY_RSA:          case KEY_RSA:
                 e  = buffer_get_char(&b);                  e = buffer_get_char(&b);
                 debug("e %lx", e);                  debug("e %lx", e);
                 if (e < 30) {                  if (e < 30) {
                         e <<= 8;                          e <<= 8;
Line 339 
Line 344 
                 line[pos++] = c;                  line[pos++] = c;
                 line[pos] = '\0';                  line[pos] = '\0';
         }          }
         if (c == EOF)          /* We reached EOF */
                 return -1;          return -1;
         return pos;  
 }  }
   
 static void  static void
Line 413 
Line 417 
                  PEM_write_RSAPrivateKey(stdout, k->rsa, NULL, NULL, 0, NULL, NULL)) :                   PEM_write_RSAPrivateKey(stdout, k->rsa, NULL, NULL, 0, NULL, NULL)) :
             key_write(k, stdout);              key_write(k, stdout);
         if (!ok) {          if (!ok) {
                 fprintf(stderr, "key write failed");                  fprintf(stderr, "key write failed\n");
                 exit(1);                  exit(1);
         }          }
         key_free(k);          key_free(k);
Line 447 
Line 451 
         exit(0);          exit(0);
 }  }
   
 #ifdef SMARTCARD  
 static void  static void
 do_upload(struct passwd *pw, const char *sc_reader_id)  do_download(struct passwd *pw, const char *pkcs11provider)
 {  {
         Key *prv = NULL;  #ifdef ENABLE_PKCS11
         struct stat st;  
         int ret;  
   
         if (!have_identity)  
                 ask_filename(pw, "Enter file in which the key is");  
         if (stat(identity_file, &st) < 0) {  
                 perror(identity_file);  
                 exit(1);  
         }  
         prv = load_identity(identity_file);  
         if (prv == NULL) {  
                 error("load failed");  
                 exit(1);  
         }  
         ret = sc_put_key(prv, sc_reader_id);  
         key_free(prv);  
         if (ret < 0)  
                 exit(1);  
         logit("loading key done");  
         exit(0);  
 }  
   
 static void  
 do_download(struct passwd *pw, const char *sc_reader_id)  
 {  
         Key **keys = NULL;          Key **keys = NULL;
         int i;          int i, nkeys;
   
         keys = sc_get_keys(sc_reader_id, NULL);          pkcs11_init(0);
         if (keys == NULL)          nkeys = pkcs11_add_provider(pkcs11provider, NULL, &keys);
                 fatal("cannot read public key from smartcard");          if (nkeys <= 0)
         for (i = 0; keys[i]; i++) {                  fatal("cannot read public key from pkcs11");
           for (i = 0; i < nkeys; i++) {
                 key_write(keys[i], stdout);                  key_write(keys[i], stdout);
                 key_free(keys[i]);                  key_free(keys[i]);
                 fprintf(stdout, "\n");                  fprintf(stdout, "\n");
         }          }
         xfree(keys);          xfree(keys);
           pkcs11_terminate();
         exit(0);          exit(0);
   #else
           fatal("no pkcs11 support");
   #endif /* ENABLE_PKCS11 */
 }  }
 #endif /* SMARTCARD */  
   
 static void  static void
 do_fingerprint(struct passwd *pw)  do_fingerprint(struct passwd *pw)
 {  {
         FILE *f;          FILE *f;
         Key *public;          Key *public;
         char *comment = NULL, *cp, *ep, line[16*1024], *fp;          char *comment = NULL, *cp, *ep, line[16*1024], *fp, *ra;
         int i, skip = 0, num = 1, invalid = 1;          int i, skip = 0, num = 0, invalid = 1;
         enum fp_rep rep;          enum fp_rep rep;
         enum fp_type fptype;          enum fp_type fptype;
         struct stat st;          struct stat st;
Line 516 
Line 498 
         public = key_load_public(identity_file, &comment);          public = key_load_public(identity_file, &comment);
         if (public != NULL) {          if (public != NULL) {
                 fp = key_fingerprint(public, fptype, rep);                  fp = key_fingerprint(public, fptype, rep);
                 printf("%u %s %s\n", key_size(public), fp, comment);                  ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
                   printf("%u %s %s (%s)\n", key_size(public), fp, comment,
                       key_type(public));
                   if (log_level >= SYSLOG_LEVEL_VERBOSE)
                           printf("%s\n", ra);
                 key_free(public);                  key_free(public);
                 xfree(comment);                  xfree(comment);
                   xfree(ra);
                 xfree(fp);                  xfree(fp);
                 exit(0);                  exit(0);
         }          }
Line 530 
Line 517 
         f = fopen(identity_file, "r");          f = fopen(identity_file, "r");
         if (f != NULL) {          if (f != NULL) {
                 while (fgets(line, sizeof(line), f)) {                  while (fgets(line, sizeof(line), f)) {
                         i = strlen(line) - 1;                          if ((cp = strchr(line, '\n')) == NULL) {
                         if (line[i] != '\n') {                                  error("line %d too long: %.40s...",
                                 error("line %d too long: %.40s...", num, line);                                      num + 1, line);
                                 skip = 1;                                  skip = 1;
                                 continue;                                  continue;
                         }                          }
Line 541 
Line 528 
                                 skip = 0;                                  skip = 0;
                                 continue;                                  continue;
                         }                          }
                         line[i] = '\0';                          *cp = '\0';
   
                         /* Skip leading whitespace, empty and comment lines. */                          /* Skip leading whitespace, empty and comment lines. */
                         for (cp = line; *cp == ' ' || *cp == '\t'; cp++)                          for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
                                 ;                                  ;
                         if (!*cp || *cp == '\n' || *cp == '#')                          if (!*cp || *cp == '\n' || *cp == '#')
                                 continue ;                                  continue;
                         i = strtol(cp, &ep, 10);                          i = strtol(cp, &ep, 10);
                         if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {                          if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {
                                 int quoted = 0;                                  int quoted = 0;
Line 576 
Line 563 
                         }                          }
                         comment = *cp ? cp : comment;                          comment = *cp ? cp : comment;
                         fp = key_fingerprint(public, fptype, rep);                          fp = key_fingerprint(public, fptype, rep);
                         printf("%u %s %s\n", key_size(public), fp,                          ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
                             comment ? comment : "no comment");                          printf("%u %s %s (%s)\n", key_size(public), fp,
                               comment ? comment : "no comment", key_type(public));
                           if (log_level >= SYSLOG_LEVEL_VERBOSE)
                                   printf("%s\n", ra);
                           xfree(ra);
                         xfree(fp);                          xfree(fp);
                         key_free(public);                          key_free(public);
                         invalid = 0;                          invalid = 0;
Line 592 
Line 583 
 }  }
   
 static void  static void
 print_host(FILE *f, char *name, Key *public, int hash)  print_host(FILE *f, const char *name, Key *public, int hash)
 {  {
         if (hash && (name = host_hash(name, NULL, 0)) == NULL)          if (print_fingerprint) {
                 fatal("hash_host failed");                  enum fp_rep rep;
         fprintf(f, "%s ", name);                  enum fp_type fptype;
         if (!key_write(public, f))                  char *fp, *ra;
                 fatal("key_write failed");  
         fprintf(f, "\n");                  fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;
                   rep =    print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_HEX;
                   fp = key_fingerprint(public, fptype, rep);
                   ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
                   printf("%u %s %s (%s)\n", key_size(public), fp, name,
                       key_type(public));
                   if (log_level >= SYSLOG_LEVEL_VERBOSE)
                           printf("%s\n", ra);
                   xfree(ra);
                   xfree(fp);
           } else {
                   if (hash && (name = host_hash(name, NULL, 0)) == NULL)
                           fatal("hash_host failed");
                   fprintf(f, "%s ", name);
                   if (!key_write(public, f))
                           fatal("key_write failed");
                   fprintf(f, "\n");
           }
 }  }
   
 static void  static void
Line 609 
Line 617 
         Key *public;          Key *public;
         char *cp, *cp2, *kp, *kp2;          char *cp, *cp2, *kp, *kp2;
         char line[16*1024], tmp[MAXPATHLEN], old[MAXPATHLEN];          char line[16*1024], tmp[MAXPATHLEN], old[MAXPATHLEN];
         int c, i, skip = 0, inplace = 0, num = 0, invalid = 0, has_unhashed = 0;          int c, skip = 0, inplace = 0, num = 0, invalid = 0, has_unhashed = 0;
   
         if (!have_identity) {          if (!have_identity) {
                 cp = tilde_expand_filename(_PATH_SSH_USER_HOSTFILE, pw->pw_uid);                  cp = tilde_expand_filename(_PATH_SSH_USER_HOSTFILE, pw->pw_uid);
Line 644 
Line 652 
         }          }
   
         while (fgets(line, sizeof(line), in)) {          while (fgets(line, sizeof(line), in)) {
                 num++;                  if ((cp = strchr(line, '\n')) == NULL) {
                 i = strlen(line) - 1;                          error("line %d too long: %.40s...", num + 1, line);
                 if (line[i] != '\n') {  
                         error("line %d too long: %.40s...", num, line);  
                         skip = 1;                          skip = 1;
                         invalid = 1;                          invalid = 1;
                         continue;                          continue;
                 }                  }
                   num++;
                 if (skip) {                  if (skip) {
                         skip = 0;                          skip = 0;
                         continue;                          continue;
                 }                  }
                 line[i] = '\0';                  *cp = '\0';
   
                 /* Skip leading whitespace, empty and comment lines. */                  /* Skip leading whitespace, empty and comment lines. */
                 for (cp = line; *cp == ' ' || *cp == '\t'; cp++)                  for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
Line 720 
Line 727 
                                         printf("# Host %s found: "                                          printf("# Host %s found: "
                                             "line %d type %s\n", name,                                              "line %d type %s\n", name,
                                             num, key_type(public));                                              num, key_type(public));
                                         print_host(out, cp, public, hash_hosts);                                          print_host(out, name, public,
                                               hash_hosts);
                                 }                                  }
                                 if (delete_host && !c)                                  if (delete_host && !c)
                                         print_host(out, cp, public, 0);                                          print_host(out, cp, public, 0);
Line 744 
Line 752 
         fclose(in);          fclose(in);
   
         if (invalid) {          if (invalid) {
                 fprintf(stderr, "%s is not a valid known_host file.\n",                  fprintf(stderr, "%s is not a valid known_hosts file.\n",
                     identity_file);                      identity_file);
                 if (inplace) {                  if (inplace) {
                         fprintf(stderr, "Not replacing existing known_hosts "                          fprintf(stderr, "Not replacing existing known_hosts "
Line 956 
Line 964 
                         key_free(private);                          key_free(private);
                         exit(1);                          exit(1);
                 }                  }
                 if (strchr(new_comment, '\n'))                  new_comment[strcspn(new_comment, "\n")] = '\0';
                         *strchr(new_comment, '\n') = 0;  
         }          }
   
         /* Save the file using the new passphrase. */          /* Save the file using the new passphrase. */
Line 982 
Line 989 
         }          }
         f = fdopen(fd, "w");          f = fdopen(fd, "w");
         if (f == NULL) {          if (f == NULL) {
                 printf("fdopen %s failed", identity_file);                  printf("fdopen %s failed\n", identity_file);
                 exit(1);                  exit(1);
         }          }
         if (!key_write(public, f))          if (!key_write(public, f))
                 fprintf(stderr, "write key failed");                  fprintf(stderr, "write key failed\n");
         key_free(public);          key_free(public);
         fprintf(f, " %s\n", new_comment);          fprintf(f, " %s\n", new_comment);
         fclose(f);          fclose(f);
Line 1000 
Line 1007 
 static void  static void
 usage(void)  usage(void)
 {  {
         fprintf(stderr, "Usage: %s [options]\n", __progname);          fprintf(stderr, "usage: %s [options]\n", __progname);
         fprintf(stderr, "Options:\n");          fprintf(stderr, "Options:\n");
         fprintf(stderr, "  -a trials   Number of trials for screening DH-GEX moduli.\n");          fprintf(stderr, "  -a trials   Number of trials for screening DH-GEX moduli.\n");
         fprintf(stderr, "  -B          Show bubblebabble digest of key file.\n");          fprintf(stderr, "  -B          Show bubblebabble digest of key file.\n");
         fprintf(stderr, "  -b bits     Number of bits in the key to create.\n");          fprintf(stderr, "  -b bits     Number of bits in the key to create.\n");
         fprintf(stderr, "  -C comment  Provide new comment.\n");          fprintf(stderr, "  -C comment  Provide new comment.\n");
         fprintf(stderr, "  -c          Change comment in private and public key files.\n");          fprintf(stderr, "  -c          Change comment in private and public key files.\n");
 #ifdef SMARTCARD  #ifdef ENABLE_PKCS11
         fprintf(stderr, "  -D reader   Download public key from smartcard.\n");          fprintf(stderr, "  -D pkcs11   Download public key from pkcs11 token.\n");
 #endif /* SMARTCARD */  #endif
         fprintf(stderr, "  -e          Convert OpenSSH to IETF SECSH key file.\n");          fprintf(stderr, "  -e          Convert OpenSSH to RFC 4716 key file.\n");
         fprintf(stderr, "  -F hostname Find hostname in known hosts file.\n");          fprintf(stderr, "  -F hostname Find hostname in known hosts file.\n");
         fprintf(stderr, "  -f filename Filename of the key file.\n");          fprintf(stderr, "  -f filename Filename of the key file.\n");
         fprintf(stderr, "  -G file     Generate candidates for DH-GEX moduli.\n");          fprintf(stderr, "  -G file     Generate candidates for DH-GEX moduli.\n");
         fprintf(stderr, "  -g          Use generic DNS resource record format.\n");          fprintf(stderr, "  -g          Use generic DNS resource record format.\n");
         fprintf(stderr, "  -H          Hash names in known_hosts file.\n");          fprintf(stderr, "  -H          Hash names in known_hosts file.\n");
         fprintf(stderr, "  -i          Convert IETF SECSH to OpenSSH key file.\n");          fprintf(stderr, "  -i          Convert RFC 4716 to OpenSSH key file.\n");
         fprintf(stderr, "  -l          Show fingerprint of key file.\n");          fprintf(stderr, "  -l          Show fingerprint of key file.\n");
         fprintf(stderr, "  -M memory   Amount of memory (MB) to use for generating DH-GEX moduli.\n");          fprintf(stderr, "  -M memory   Amount of memory (MB) to use for generating DH-GEX moduli.\n");
         fprintf(stderr, "  -N phrase   Provide new passphrase.\n");          fprintf(stderr, "  -N phrase   Provide new passphrase.\n");
Line 1028 
Line 1035 
         fprintf(stderr, "  -S start    Start point (hex) for generating DH-GEX moduli.\n");          fprintf(stderr, "  -S start    Start point (hex) for generating DH-GEX moduli.\n");
         fprintf(stderr, "  -T file     Screen candidates for DH-GEX moduli.\n");          fprintf(stderr, "  -T file     Screen candidates for DH-GEX moduli.\n");
         fprintf(stderr, "  -t type     Specify type of key to create.\n");          fprintf(stderr, "  -t type     Specify type of key to create.\n");
 #ifdef SMARTCARD  
         fprintf(stderr, "  -U reader   Upload private key to smartcard.\n");  
 #endif /* SMARTCARD */  
         fprintf(stderr, "  -v          Verbose.\n");          fprintf(stderr, "  -v          Verbose.\n");
         fprintf(stderr, "  -W gen      Generator to use for generating DH-GEX moduli.\n");          fprintf(stderr, "  -W gen      Generator to use for generating DH-GEX moduli.\n");
         fprintf(stderr, "  -y          Read private key file and print public key.\n");          fprintf(stderr, "  -y          Read private key file and print public key.\n");
Line 1042 
Line 1046 
  * Main program for key management.   * Main program for key management.
  */   */
 int  int
 main(int ac, char **av)  main(int argc, char **argv)
 {  {
         char dotsshdir[MAXPATHLEN], comment[1024], *passphrase1, *passphrase2;          char dotsshdir[MAXPATHLEN], comment[1024], *passphrase1, *passphrase2;
         char out_file[MAXPATHLEN], *reader_id = NULL;          char out_file[MAXPATHLEN], *pkcs11provider = NULL;
         char *rr_hostname = NULL;          char *rr_hostname = NULL;
         Key *private, *public;          Key *private, *public;
         struct passwd *pw;          struct passwd *pw;
         struct stat st;          struct stat st;
         int opt, type, fd, download = 0;          int opt, type, fd;
         u_int32_t memory = 0, generator_wanted = 0, trials = 100;          u_int32_t memory = 0, generator_wanted = 0, trials = 100;
         int do_gen_candidates = 0, do_screen_candidates = 0;          int do_gen_candidates = 0, do_screen_candidates = 0;
         int log_level = SYSLOG_LEVEL_INFO;  
         BIGNUM *start = NULL;          BIGNUM *start = NULL;
         FILE *f;          FILE *f;
         const char *errstr;          const char *errstr;
Line 1065 
Line 1068 
         sanitise_stdfd();          sanitise_stdfd();
   
         SSLeay_add_all_algorithms();          SSLeay_add_all_algorithms();
         log_init(av[0], SYSLOG_LEVEL_INFO, SYSLOG_FACILITY_USER, 1);          log_init(argv[0], SYSLOG_LEVEL_INFO, SYSLOG_FACILITY_USER, 1);
   
         /* we need this for the home * directory.  */          /* we need this for the home * directory.  */
         pw = getpwuid(getuid());          pw = getpwuid(getuid());
Line 1078 
Line 1081 
                 exit(1);                  exit(1);
         }          }
   
         while ((opt = getopt(ac, av,          while ((opt = getopt(argc, argv,
             "degiqpclBHvxXyF:b:f:t:U:D:P:N:C:r:g:R:T:G:M:S:a:W:")) != -1) {              "degiqpclBHvxXyF:b:f:t:D:P:N:C:r:g:R:T:G:M:S:a:W:")) != -1) {
                 switch (opt) {                  switch (opt) {
                 case 'b':                  case 'b':
                         bits = (u_int32_t)strtonum(optarg, 768, 32768, &errstr);                          bits = (u_int32_t)strtonum(optarg, 768, 32768, &errstr);
Line 1151 
Line 1154 
                         key_type_name = optarg;                          key_type_name = optarg;
                         break;                          break;
                 case 'D':                  case 'D':
                         download = 1;                          pkcs11provider = optarg;
                         /*FALLTHROUGH*/  
                 case 'U':  
                         reader_id = optarg;  
                         break;                          break;
                 case 'v':                  case 'v':
                         if (log_level == SYSLOG_LEVEL_INFO)                          if (log_level == SYSLOG_LEVEL_INFO)
Line 1211 
Line 1211 
         }          }
   
         /* reinit */          /* reinit */
         log_init(av[0], log_level, SYSLOG_FACILITY_USER, 1);          log_init(argv[0], log_level, SYSLOG_FACILITY_USER, 1);
   
         if (optind < ac) {          if (optind < argc) {
                 printf("Too many arguments.\n");                  printf("Too many arguments.\n");
                 usage();                  usage();
         }          }
Line 1221 
Line 1221 
                 printf("Can only have one of -p and -c.\n");                  printf("Can only have one of -p and -c.\n");
                 usage();                  usage();
         }          }
           if (print_fingerprint && (delete_host || hash_hosts)) {
                   printf("Cannot use -l with -D or -R.\n");
                   usage();
           }
         if (delete_host || hash_hosts || find_host)          if (delete_host || hash_hosts || find_host)
                 do_known_hosts(pw, rr_hostname);                  do_known_hosts(pw, rr_hostname);
         if (print_fingerprint || print_bubblebabble)          if (print_fingerprint || print_bubblebabble)
Line 1258 
Line 1262 
                         exit(0);                          exit(0);
                 }                  }
         }          }
         if (reader_id != NULL) {          if (pkcs11provider != NULL)
 #ifdef SMARTCARD                  do_download(pw, pkcs11provider);
                 if (download)  
                         do_download(pw, reader_id);  
                 else  
                         do_upload(pw, reader_id);  
 #else /* SMARTCARD */  
                 fatal("no support for smartcards.");  
 #endif /* SMARTCARD */  
         }  
   
         if (do_gen_candidates) {          if (do_gen_candidates) {
                 FILE *out = fopen(out_file, "w");                  FILE *out = fopen(out_file, "w");
Line 1325 
Line 1321 
                 printf("Generating public/private %s key pair.\n", key_type_name);                  printf("Generating public/private %s key pair.\n", key_type_name);
         private = key_generate(type, bits);          private = key_generate(type, bits);
         if (private == NULL) {          if (private == NULL) {
                 fprintf(stderr, "key_generate failed");                  fprintf(stderr, "key_generate failed\n");
                 exit(1);                  exit(1);
         }          }
         public  = key_from_private(private);          public  = key_from_private(private);
Line 1385 
Line 1381 
         if (identity_comment) {          if (identity_comment) {
                 strlcpy(comment, identity_comment, sizeof(comment));                  strlcpy(comment, identity_comment, sizeof(comment));
         } else {          } else {
                 /* Create default commend field for the passphrase. */                  /* Create default comment field for the passphrase. */
                 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name, hostname);                  snprintf(comment, sizeof comment, "%s@%s", pw->pw_name, hostname);
         }          }
   
Line 1415 
Line 1411 
         }          }
         f = fdopen(fd, "w");          f = fdopen(fd, "w");
         if (f == NULL) {          if (f == NULL) {
                 printf("fdopen %s failed", identity_file);                  printf("fdopen %s failed\n", identity_file);
                 exit(1);                  exit(1);
         }          }
         if (!key_write(public, f))          if (!key_write(public, f))
                 fprintf(stderr, "write key failed");                  fprintf(stderr, "write key failed\n");
         fprintf(f, " %s\n", comment);          fprintf(f, " %s\n", comment);
         fclose(f);          fclose(f);
   
         if (!quiet) {          if (!quiet) {
                 char *fp = key_fingerprint(public, SSH_FP_MD5, SSH_FP_HEX);                  char *fp = key_fingerprint(public, SSH_FP_MD5, SSH_FP_HEX);
                   char *ra = key_fingerprint(public, SSH_FP_MD5,
                       SSH_FP_RANDOMART);
                 printf("Your public key has been saved in %s.\n",                  printf("Your public key has been saved in %s.\n",
                     identity_file);                      identity_file);
                 printf("The key fingerprint is:\n");                  printf("The key fingerprint is:\n");
                 printf("%s %s\n", fp, comment);                  printf("%s %s\n", fp, comment);
                   printf("The key's randomart image is:\n");
                   printf("%s\n", ra);
                   xfree(ra);
                 xfree(fp);                  xfree(fp);
         }          }
   
Legend:
Removed from v.1.152  
changed lines
  Added in v.1.177