[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.128.2.3 and 1.129

version 1.128.2.3, 2006/11/08 00:44:05 version 1.129, 2005/09/13 23:40:07
Line 1 
Line 1 
 /* $OpenBSD$ */  
 /*  /*
  * Author: Tatu Ylonen <ylo@cs.hut.fi>   * Author: Tatu Ylonen <ylo@cs.hut.fi>
  * Copyright (c) 1994 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland   * Copyright (c) 1994 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
Line 12 
Line 11 
  * called by a name other than "ssh" or "Secure Shell".   * called by a name other than "ssh" or "Secure Shell".
  */   */
   
 #include <sys/types.h>  #include "includes.h"
 #include <sys/stat.h>  RCSID("$OpenBSD$");
 #include <sys/socket.h>  
 #include <sys/param.h>  
   
 #include <openssl/evp.h>  #include <openssl/evp.h>
 #include <openssl/pem.h>  #include <openssl/pem.h>
   
 #include <errno.h>  
 #include <fcntl.h>  
 #include <pwd.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <unistd.h>  
   
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "key.h"  #include "key.h"
 #include "rsa.h"  #include "rsa.h"
 #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"
 #include "match.h"  #include "match.h"
 #include "hostfile.h"  #include "hostfile.h"
 #include "dns.h"  
   
 #ifdef SMARTCARD  #ifdef SMARTCARD
 #include "scard.h"  #include "scard.h"
 #endif  #endif
   #include "dns.h"
   
 /* 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 changed on the command line. */
 #define DEFAULT_BITS            2048  u_int32_t bits = 2048;
 #define DEFAULT_BITS_DSA        1024  
 u_int32_t bits = 0;  
   
 /*  /*
  * Flag indicating that we just want to change the passphrase.  This can be   * Flag indicating that we just want to change the passphrase.  This can be
Line 113 
Line 101 
   
         if (key_type_name == NULL)          if (key_type_name == NULL)
                 name = _PATH_SSH_CLIENT_ID_RSA;                  name = _PATH_SSH_CLIENT_ID_RSA;
         else {          else
                 switch (key_type_from_name(key_type_name)) {                  switch (key_type_from_name(key_type_name)) {
                 case KEY_RSA1:                  case KEY_RSA1:
                         name = _PATH_SSH_CLIENT_IDENTITY;                          name = _PATH_SSH_CLIENT_IDENTITY;
Line 129 
Line 117 
                         exit(1);                          exit(1);
                         break;                          break;
                 }                  }
         }  
         snprintf(identity_file, sizeof(identity_file), "%s/%s", pw->pw_dir, name);          snprintf(identity_file, sizeof(identity_file), "%s/%s", pw->pw_dir, name);
         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)
Line 215 
Line 203 
         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));
         if (BN_bin2bn(buffer_ptr(b), bytes, value) == NULL)          BN_bin2bn(buffer_ptr(b), bytes, value);
                 fatal("buffer_get_bignum_bits: BN_bin2bn failed");  
         buffer_consume(b, bytes);          buffer_consume(b, bytes);
 }  }
   
Line 313 
Line 300 
         return key;          return key;
 }  }
   
 static int  
 get_line(FILE *fp, char *line, size_t len)  
 {  
         int c;  
         size_t pos = 0;  
   
         line[0] = '\0';  
         while ((c = fgetc(fp)) != EOF) {  
                 if (pos >= len - 1) {  
                         fprintf(stderr, "input line too long.\n");  
                         exit(1);  
                 }  
                 switch (c) {  
                 case '\r':  
                         c = fgetc(fp);  
                         if (c != EOF && c != '\n' && ungetc(c, fp) == EOF) {  
                                 fprintf(stderr, "unget: %s\n", strerror(errno));  
                                 exit(1);  
                         }  
                         return pos;  
                 case '\n':  
                         return pos;  
                 }  
                 line[pos++] = c;  
                 line[pos] = '\0';  
         }  
         if (c == EOF)  
                 return -1;  
         return pos;  
 }  
   
 static void  static void
 do_convert_from_ssh2(struct passwd *pw)  do_convert_from_ssh2(struct passwd *pw)
 {  {
         Key *k;          Key *k;
         int blen;          int blen;
         u_int len;          u_int len;
         char line[1024];          char line[1024], *p;
         u_char blob[8096];          u_char blob[8096];
         char encoded[8096];          char encoded[8096];
         struct stat st;          struct stat st;
Line 369 
Line 325 
                 exit(1);                  exit(1);
         }          }
         encoded[0] = '\0';          encoded[0] = '\0';
         while ((blen = get_line(fp, line, sizeof(line))) != -1) {          while (fgets(line, sizeof(line), fp)) {
                 if (line[blen - 1] == '\\')                  if (!(p = strchr(line, '\n'))) {
                           fprintf(stderr, "input line too long.\n");
                           exit(1);
                   }
                   if (p > line && p[-1] == '\\')
                         escaped++;                          escaped++;
                 if (strncmp(line, "----", 4) == 0 ||                  if (strncmp(line, "----", 4) == 0 ||
                     strstr(line, ": ") != NULL) {                      strstr(line, ": ") != NULL) {
Line 387 
Line 347 
                         /* fprintf(stderr, "escaped: %s", line); */                          /* fprintf(stderr, "escaped: %s", line); */
                         continue;                          continue;
                 }                  }
                   *p = '\0';
                 strlcat(encoded, line, sizeof(encoded));                  strlcat(encoded, line, sizeof(encoded));
         }          }
         len = strlen(encoded);          len = strlen(encoded);
Line 522 
Line 483 
                 xfree(fp);                  xfree(fp);
                 exit(0);                  exit(0);
         }          }
         if (comment) {          if (comment)
                 xfree(comment);                  xfree(comment);
                 comment = NULL;  
         }  
   
         f = fopen(identity_file, "r");          f = fopen(identity_file, "r");
         if (f != NULL) {          if (f != NULL) {
Line 871 
Line 830 
 /*  /*
  * Print the SSHFP RR.   * Print the SSHFP RR.
  */   */
 static int  static void
 do_print_resource_record(struct passwd *pw, char *fname, char *hname)  do_print_resource_record(struct passwd *pw, char *hname)
 {  {
         Key *public;          Key *public;
         char *comment = NULL;          char *comment = NULL;
         struct stat st;          struct stat st;
   
         if (fname == NULL)          if (!have_identity)
                 ask_filename(pw, "Enter file in which the key is");                  ask_filename(pw, "Enter file in which the key is");
         if (stat(fname, &st) < 0) {          if (stat(identity_file, &st) < 0) {
                 if (errno == ENOENT)                  perror(identity_file);
                         return 0;  
                 perror(fname);  
                 exit(1);                  exit(1);
         }          }
         public = key_load_public(fname, &comment);          public = key_load_public(identity_file, &comment);
         if (public != NULL) {          if (public != NULL) {
                 export_dns_rr(hname, public, stdout, print_generic);                  export_dns_rr(hname, public, stdout, print_generic);
                 key_free(public);                  key_free(public);
                 xfree(comment);                  xfree(comment);
                 return 1;                  exit(0);
         }          }
         if (comment)          if (comment)
                 xfree(comment);                  xfree(comment);
   
         printf("failed to read v2 public key from %s.\n", fname);          printf("failed to read v2 public key from %s.\n", identity_file);
         exit(1);          exit(1);
 }  }
   
Line 1082 
Line 1039 
             "degiqpclBHvxXyF:b:f:t:U:D:P:N:C:r:g:R:T:G:M:S:a:W:")) != -1) {              "degiqpclBHvxXyF:b:f:t:U: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 = strtonum(optarg, 512, 32768, &errstr);
                         if (errstr)                          if (errstr)
                                 fatal("Bits has bad value %s (%s)",                                  fatal("Bits has bad value %s (%s)",
                                         optarg, errstr);                                          optarg, errstr);
Line 1152 
Line 1109 
                         break;                          break;
                 case 'D':                  case 'D':
                         download = 1;                          download = 1;
                         /*FALLTHROUGH*/  
                 case 'U':                  case 'U':
                         reader_id = optarg;                          reader_id = optarg;
                         break;                          break;
Line 1169 
Line 1125 
                         rr_hostname = optarg;                          rr_hostname = optarg;
                         break;                          break;
                 case 'W':                  case 'W':
                         generator_wanted = (u_int32_t)strtonum(optarg, 1,                          generator_wanted = strtonum(optarg, 1, UINT_MAX, &errstr);
                             UINT_MAX, &errstr);  
                         if (errstr)                          if (errstr)
                                 fatal("Desired generator has bad value: %s (%s)",                                  fatal("Desired generator has bad value: %s (%s)",
                                         optarg, errstr);                                          optarg, errstr);
                         break;                          break;
                 case 'a':                  case 'a':
                         trials = (u_int32_t)strtonum(optarg, 1, UINT_MAX, &errstr);                          trials = strtonum(optarg, 1, UINT_MAX, &errstr);
                         if (errstr)                          if (errstr)
                                 fatal("Invalid number of trials: %s (%s)",                                  fatal("Invalid number of trials: %s (%s)",
                                         optarg, errstr);                                          optarg, errstr);
                         break;                          break;
                 case 'M':                  case 'M':
                         memory = (u_int32_t)strtonum(optarg, 1, UINT_MAX, &errstr);                          memory = strtonum(optarg, 1, UINT_MAX, &errstr);
                         if (errstr) {                          if (errstr) {
                                 fatal("Memory limit is %s: %s", errstr, optarg);                                  fatal("Memory limit is %s: %s", errstr, optarg);
                         }                          }
Line 1236 
Line 1191 
         if (print_public)          if (print_public)
                 do_print_public(pw);                  do_print_public(pw);
         if (rr_hostname != NULL) {          if (rr_hostname != NULL) {
                 unsigned int n = 0;                  do_print_resource_record(pw, rr_hostname);
   
                 if (have_identity) {  
                         n = do_print_resource_record(pw,  
                             identity_file, rr_hostname);  
                         if (n == 0) {  
                                 perror(identity_file);  
                                 exit(1);  
                         }  
                         exit(0);  
                 } else {  
   
                         n += do_print_resource_record(pw,  
                             _PATH_HOST_RSA_KEY_FILE, rr_hostname);  
                         n += do_print_resource_record(pw,  
                             _PATH_HOST_DSA_KEY_FILE, rr_hostname);  
   
                         if (n == 0)  
                                 fatal("no keys found.");  
                         exit(0);  
                 }  
         }          }
         if (reader_id != NULL) {          if (reader_id != NULL) {
 #ifdef SMARTCARD  #ifdef SMARTCARD
Line 1277 
Line 1212 
                             out_file, strerror(errno));                              out_file, strerror(errno));
                         return (1);                          return (1);
                 }                  }
                 if (bits == 0)  
                         bits = DEFAULT_BITS;  
                 if (gen_candidates(out, memory, bits, start) != 0)                  if (gen_candidates(out, memory, bits, start) != 0)
                         fatal("modulus candidate generation failed");                          fatal("modulus candidate generation failed\n");
   
                 return (0);                  return (0);
         }          }
Line 1303 
Line 1236 
                             out_file, strerror(errno));                              out_file, strerror(errno));
                 }                  }
                 if (prime_test(in, out, trials, generator_wanted) != 0)                  if (prime_test(in, out, trials, generator_wanted) != 0)
                         fatal("modulus screening failed");                          fatal("modulus screening failed\n");
                 return (0);                  return (0);
         }          }
   
         arc4random_stir();          arc4random_stir();
   
         if (key_type_name == NULL)          if (key_type_name == NULL) {
                 key_type_name = "rsa";                  printf("You must specify a key type (-t).\n");
                   usage();
           }
         type = key_type_from_name(key_type_name);          type = key_type_from_name(key_type_name);
         if (type == KEY_UNSPEC) {          if (type == KEY_UNSPEC) {
                 fprintf(stderr, "unknown key type %s\n", key_type_name);                  fprintf(stderr, "unknown key type %s\n", key_type_name);
                 exit(1);                  exit(1);
         }          }
         if (bits == 0)  
                 bits = (type == KEY_DSA) ? DEFAULT_BITS_DSA : DEFAULT_BITS;  
         if (type == KEY_DSA && bits != 1024)  
                 fatal("DSA keys must be 1024 bits");  
         if (!quiet)          if (!quiet)
                 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);
Line 1333 
Line 1263 
         if (!have_identity)          if (!have_identity)
                 ask_filename(pw, "Enter file in which to save the key");                  ask_filename(pw, "Enter file in which to save the key");
   
         /* Create ~/.ssh directory if it doesn't already exist. */          /* Create ~/.ssh directory if it doesn\'t already exist. */
         snprintf(dotsshdir, sizeof dotsshdir, "%s/%s", pw->pw_dir, _PATH_SSH_USER_DIR);          snprintf(dotsshdir, sizeof dotsshdir, "%s/%s", pw->pw_dir, _PATH_SSH_USER_DIR);
         if (strstr(identity_file, dotsshdir) != NULL &&          if (strstr(identity_file, dotsshdir) != NULL &&
             stat(dotsshdir, &st) < 0) {              stat(dotsshdir, &st) < 0) {
Legend:
Removed from v.1.128.2.3  
changed lines
  Added in v.1.129