[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.76 and 1.104

version 1.76, 2001/08/02 08:58:35 version 1.104, 2003/05/11 16:56:48
Line 29 
Line 29 
 #include "readpass.h"  #include "readpass.h"
   
 #ifdef SMARTCARD  #ifdef SMARTCARD
 #include <sectok.h>  
 #include <openssl/engine.h>  
 #include "scard.h"  #include "scard.h"
 #endif  #endif
   
Line 73 
Line 71 
 int convert_from_ssh2 = 0;  int convert_from_ssh2 = 0;
 int print_public = 0;  int print_public = 0;
   
 /* default to RSA for SSH-1 */  char *key_type_name = NULL;
 char *key_type_name = "rsa1";  
   
 /* argv0 */  /* argv0 */
 extern char *__progname;  extern char *__progname;
Line 87 
Line 84 
         char buf[1024];          char buf[1024];
         char *name = NULL;          char *name = NULL;
   
         switch (key_type_from_name(key_type_name)) {          if (key_type_name == NULL)
         case KEY_RSA1:  
                 name = _PATH_SSH_CLIENT_IDENTITY;  
                 break;  
         case KEY_DSA:  
                 name = _PATH_SSH_CLIENT_ID_DSA;  
                 break;  
         case KEY_RSA:  
                 name = _PATH_SSH_CLIENT_ID_RSA;                  name = _PATH_SSH_CLIENT_ID_RSA;
                 break;          else
         default:                  switch (key_type_from_name(key_type_name)) {
                 fprintf(stderr, "bad key type");                  case KEY_RSA1:
                 exit(1);                          name = _PATH_SSH_CLIENT_IDENTITY;
                 break;                          break;
         }                  case KEY_DSA:
                           name = _PATH_SSH_CLIENT_ID_DSA;
                           break;
                   case KEY_RSA:
                           name = _PATH_SSH_CLIENT_ID_RSA;
                           break;
                   default:
                           fprintf(stderr, "bad key type");
                           exit(1);
                           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);
         fflush(stderr);  
         if (fgets(buf, sizeof(buf), stdin) == NULL)          if (fgets(buf, sizeof(buf), stdin) == NULL)
                 exit(1);                  exit(1);
         if (strchr(buf, '\n'))          if (strchr(buf, '\n'))
Line 135 
Line 135 
 }  }
   
 #define SSH_COM_PUBLIC_BEGIN            "---- BEGIN SSH2 PUBLIC KEY ----"  #define SSH_COM_PUBLIC_BEGIN            "---- BEGIN SSH2 PUBLIC KEY ----"
 #define SSH_COM_PUBLIC_END              "---- END SSH2 PUBLIC KEY ----"  #define SSH_COM_PUBLIC_END              "---- END SSH2 PUBLIC KEY ----"
 #define SSH_COM_PRIVATE_BEGIN           "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----"  #define SSH_COM_PRIVATE_BEGIN           "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----"
 #define SSH_COM_PRIVATE_KEY_MAGIC       0x3f6ff9eb  #define SSH_COM_PRIVATE_KEY_MAGIC       0x3f6ff9eb
   
Line 143 
Line 143 
 do_convert_to_ssh2(struct passwd *pw)  do_convert_to_ssh2(struct passwd *pw)
 {  {
         Key *k;          Key *k;
         int len;          u_int len;
         u_char *blob;          u_char *blob;
         struct stat st;          struct stat st;
   
Line 159 
Line 159 
                         exit(1);                          exit(1);
                 }                  }
         }          }
         key_to_blob(k, &blob, &len);          if (k->type == KEY_RSA1) {
                   fprintf(stderr, "version 1 keys are not supported\n");
                   exit(1);
           }
           if (key_to_blob(k, &blob, &len) <= 0) {
                   fprintf(stderr, "key_to_blob failed\n");
                   exit(1);
           }
         fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);          fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);
         fprintf(stdout,          fprintf(stdout,
             "Comment: \"%d-bit %s, converted from OpenSSH by %s@%s\"\n",              "Comment: \"%u-bit %s, converted from OpenSSH by %s@%s\"\n",
             key_size(k), key_type(k),              key_size(k), key_type(k),
             pw->pw_name, hostname);              pw->pw_name, hostname);
         dump_base64(stdout, blob, len);          dump_base64(stdout, blob, len);
Line 181 
Line 188 
         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((u_char *)buffer_ptr(b), bytes, value);          BN_bin2bn(buffer_ptr(b), bytes, value);
         buffer_consume(b, bytes);          buffer_consume(b, bytes);
 }  }
   
 static Key *  static Key *
 do_convert_private_ssh2_from_blob(char *blob, int blen)  do_convert_private_ssh2_from_blob(u_char *blob, u_int blen)
 {  {
         Buffer b;          Buffer b;
         Key *key = NULL;          Key *key = NULL;
Line 265 
Line 272 
                 break;                  break;
         }          }
         rlen = buffer_len(&b);          rlen = buffer_len(&b);
         if(rlen != 0)          if (rlen != 0)
                 error("do_convert_private_ssh2_from_blob: "                  error("do_convert_private_ssh2_from_blob: "
                     "remaining bytes in key blob %d", rlen);                      "remaining bytes in key blob %d", rlen);
         buffer_free(&b);          buffer_free(&b);
Line 282 
Line 289 
 {  {
         Key *k;          Key *k;
         int blen;          int blen;
           u_int len;
         char line[1024], *p;          char line[1024], *p;
         char blob[8096];          u_char blob[8096];
         char encoded[8096];          char encoded[8096];
         struct stat st;          struct stat st;
         int escaped = 0, private = 0, ok;          int escaped = 0, private = 0, ok;
Line 326 
Line 334 
                 *p = '\0';                  *p = '\0';
                 strlcat(encoded, line, sizeof(encoded));                  strlcat(encoded, line, sizeof(encoded));
         }          }
         blen = uudecode(encoded, (u_char *)blob, sizeof(blob));          len = strlen(encoded);
           if (((len % 4) == 3) &&
               (encoded[len-1] == '=') &&
               (encoded[len-2] == '=') &&
               (encoded[len-3] == '='))
                   encoded[len-3] = '\0';
           blen = uudecode(encoded, blob, sizeof(blob));
         if (blen < 0) {          if (blen < 0) {
                 fprintf(stderr, "uudecode failed.\n");                  fprintf(stderr, "uudecode failed.\n");
                 exit(1);                  exit(1);
Line 348 
Line 362 
                 exit(1);                  exit(1);
         }          }
         key_free(k);          key_free(k);
         fprintf(stdout, "\n");          if (!private)
                   fprintf(stdout, "\n");
         fclose(fp);          fclose(fp);
         exit(0);          exit(0);
 }  }
Line 378 
Line 393 
 }  }
   
 #ifdef SMARTCARD  #ifdef SMARTCARD
 #define NUM_RSA_KEY_ELEMENTS 5+1  
 #define COPY_RSA_KEY(x, i) \  
         do { \  
                 len = BN_num_bytes(prv->rsa->x); \  
                 elements[i] = xmalloc(len); \  
                 debug("#bytes %d", len); \  
                 if (BN_bn2bin(prv->rsa->x, elements[i]) < 0) \  
                         goto done; \  
         } while(0)  
   
 static int  
 get_AUT0(char *aut0)  
 {  
         EVP_MD *evp_md = EVP_sha1();  
         EVP_MD_CTX md;  
         char *pass;  
   
         pass = read_passphrase("Enter passphrase for smartcard: ", RP_ALLOW_STDIN);  
         if (pass == NULL)  
                 return -1;  
         EVP_DigestInit(&md, evp_md);  
         EVP_DigestUpdate(&md, pass, strlen(pass));  
         EVP_DigestFinal(&md, aut0, NULL);  
         memset(pass, 0, strlen(pass));  
         xfree(pass);  
         return 0;  
 }  
   
 static void  static void
 do_upload(struct passwd *pw, const char *sc_reader_id)  do_upload(struct passwd *pw, const char *sc_reader_id)
 {  {
         Key *prv = NULL;          Key *prv = NULL;
         struct stat st;          struct stat st;
         u_char *elements[NUM_RSA_KEY_ELEMENTS];          int ret;
         u_char key_fid[2];  
         u_char DEFAUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};  
         u_char AUT0[EVP_MAX_MD_SIZE];  
         int len, status = 1, i, fd = -1, ret;  
         int sw = 0, cla = 0x00;  
   
         for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)  
                 elements[i] = NULL;  
         if (!have_identity)          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(identity_file, &st) < 0) {          if (stat(identity_file, &st) < 0) {
                 perror(identity_file);                  perror(identity_file);
                 goto done;                  exit(1);
         }          }
         prv = load_identity(identity_file);          prv = load_identity(identity_file);
         if (prv == NULL) {          if (prv == NULL) {
                 error("load failed");                  error("load failed");
                 goto done;                  exit(1);
         }          }
         COPY_RSA_KEY(q, 0);          ret = sc_put_key(prv, sc_reader_id);
         COPY_RSA_KEY(p, 1);          key_free(prv);
         COPY_RSA_KEY(iqmp, 2);          if (ret < 0)
         COPY_RSA_KEY(dmq1, 3);                  exit(1);
         COPY_RSA_KEY(dmp1, 4);          logit("loading key done");
         COPY_RSA_KEY(n, 5);          exit(0);
         len = BN_num_bytes(prv->rsa->n);  
         fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw);  
         if (fd < 0) {  
                 error("sectok_open failed: %s", sectok_get_sw(sw));  
                 goto done;  
         }  
         if (! sectok_cardpresent(fd)) {  
                 error("smartcard in reader %s not present",  
                     sc_reader_id);  
                 goto done;  
         }  
         ret = sectok_reset(fd, 0, NULL, &sw);  
         if (ret <= 0) {  
                 error("sectok_reset failed: %s", sectok_get_sw(sw));  
                 goto done;  
         }  
         if ((cla = cyberflex_inq_class(fd)) < 0) {  
                 error("cyberflex_inq_class failed");  
                 goto done;  
         }  
         memcpy(AUT0, DEFAUT0, sizeof(DEFAUT0));  
         if (cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {  
                 if (get_AUT0(AUT0) < 0 ||  
                     cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {  
                         error("cyberflex_verify_AUT0 failed");  
                         goto done;  
                 }  
         }  
         key_fid[0] = 0x00;  
         key_fid[1] = 0x12;  
         if (cyberflex_load_rsa_priv(fd, cla, key_fid, 5, 8*len, elements,  
             &sw) < 0) {  
                 error("cyberflex_load_rsa_priv failed: %s", sectok_get_sw(sw));  
                 goto done;  
         }  
         if (!sectok_swOK(sw))  
                 goto done;  
         log("cyberflex_load_rsa_priv done");  
         key_fid[0] = 0x73;  
         key_fid[1] = 0x68;  
         if (cyberflex_load_rsa_pub(fd, cla, key_fid, len, elements[5],  
             &sw) < 0) {  
                 error("cyberflex_load_rsa_pub failed: %s", sectok_get_sw(sw));  
                 goto done;  
         }  
         if (!sectok_swOK(sw))  
                 goto done;  
         log("cyberflex_load_rsa_pub done");  
         status = 0;  
         log("loading key done");  
 done:  
         if (prv)  
                 key_free(prv);  
         for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)  
                 if (elements[i])  
                         xfree(elements[i]);  
         if (fd != -1)  
                 sectok_close(fd);  
         exit(status);  
 }  }
   
 static void  static void
 do_download(struct passwd *pw, const char *sc_reader_id)  do_download(struct passwd *pw, const char *sc_reader_id)
 {  {
         Key *pub = NULL;          Key **keys = NULL;
           int i;
   
         pub = sc_get_key(sc_reader_id);          keys = sc_get_keys(sc_reader_id, NULL);
         if (pub == NULL)          if (keys == NULL)
                 fatal("cannot read public key from smartcard");                  fatal("cannot read public key from smartcard");
         key_write(pub, stdout);          for (i = 0; keys[i]; i++) {
         key_free(pub);                  key_write(keys[i], stdout);
         fprintf(stdout, "\n");                  key_free(keys[i]);
                   fprintf(stdout, "\n");
           }
           xfree(keys);
         exit(0);          exit(0);
 }  }
 #endif  #endif /* SMARTCARD */
   
 static void  static void
 do_fingerprint(struct passwd *pw)  do_fingerprint(struct passwd *pw)
Line 519 
Line 444 
         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;
         int i, skip = 0, num = 1, invalid = 1, rep, fptype;          int i, skip = 0, num = 1, invalid = 1;
           enum fp_rep rep;
           enum fp_type fptype;
         struct stat st;          struct stat st;
   
         fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;          fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;
Line 534 
Line 461 
         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("%d %s %s\n", key_size(public), fp, comment);                  printf("%u %s %s\n", key_size(public), fp, comment);
                 key_free(public);                  key_free(public);
                 xfree(comment);                  xfree(comment);
                 xfree(fp);                  xfree(fp);
Line 568 
Line 495 
                         if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {                          if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {
                                 int quoted = 0;                                  int quoted = 0;
                                 comment = cp;                                  comment = cp;
                                 for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) {                                  for (; *cp && (quoted || (*cp != ' ' &&
                                       *cp != '\t')); cp++) {
                                         if (*cp == '\\' && cp[1] == '"')                                          if (*cp == '\\' && cp[1] == '"')
                                                 cp++;   /* Skip both */                                                  cp++;   /* Skip both */
                                         else if (*cp == '"')                                          else if (*cp == '"')
Line 591 
Line 519 
                         }                          }
                         comment = *cp ? cp : comment;                          comment = *cp ? cp : comment;
                         fp = key_fingerprint(public, fptype, rep);                          fp = key_fingerprint(public, fptype, rep);
                         printf("%d %s %s\n", key_size(public), fp,                          printf("%u %s %s\n", key_size(public), fp,
                             comment ? comment : "no comment");                              comment ? comment : "no comment");
                         xfree(fp);                          xfree(fp);
                         key_free(public);                          key_free(public);
Line 600 
Line 528 
                 fclose(f);                  fclose(f);
         }          }
         if (invalid) {          if (invalid) {
                 printf("%s is not a valid key file.\n", identity_file);                  printf("%s is not a public key file.\n", identity_file);
                 exit(1);                  exit(1);
         }          }
         exit(0);          exit(0);
Line 653 
Line 581 
                         read_passphrase("Enter new passphrase (empty for no "                          read_passphrase("Enter new passphrase (empty for no "
                             "passphrase): ", RP_ALLOW_STDIN);                              "passphrase): ", RP_ALLOW_STDIN);
                 passphrase2 = read_passphrase("Enter same passphrase again: ",                  passphrase2 = read_passphrase("Enter same passphrase again: ",
                      RP_ALLOW_STDIN);                      RP_ALLOW_STDIN);
   
                 /* Verify that they are the same. */                  /* Verify that they are the same. */
                 if (strcmp(passphrase1, passphrase2) != 0) {                  if (strcmp(passphrase1, passphrase2) != 0) {
Line 731 
Line 659 
                 fprintf(stderr, "Comments are only supported for RSA1 keys.\n");                  fprintf(stderr, "Comments are only supported for RSA1 keys.\n");
                 key_free(private);                  key_free(private);
                 exit(1);                  exit(1);
         }          }
         printf("Key now has comment '%s'\n", comment);          printf("Key now has comment '%s'\n", comment);
   
         if (identity_comment) {          if (identity_comment) {
Line 788 
Line 716 
 static void  static void
 usage(void)  usage(void)
 {  {
         printf("Usage: %s [-ceilpqyB] [-t type] [-b bits] [-f file] [-C comment] "          fprintf(stderr, "Usage: %s [options]\n", __progname);
             "[-N new-pass] [-P pass]\n", __progname);          fprintf(stderr, "Options:\n");
           fprintf(stderr, "  -b bits     Number of bits in the key to create.\n");
           fprintf(stderr, "  -c          Change comment in private and public key files.\n");
           fprintf(stderr, "  -e          Convert OpenSSH to IETF SECSH key file.\n");
           fprintf(stderr, "  -f filename Filename of the key file.\n");
           fprintf(stderr, "  -i          Convert IETF SECSH to OpenSSH key file.\n");
           fprintf(stderr, "  -l          Show fingerprint of key file.\n");
           fprintf(stderr, "  -p          Change passphrase of private key file.\n");
           fprintf(stderr, "  -q          Quiet.\n");
           fprintf(stderr, "  -y          Read private key file and print public key.\n");
           fprintf(stderr, "  -t type     Specify type of key to create.\n");
           fprintf(stderr, "  -B          Show bubblebabble digest of key file.\n");
           fprintf(stderr, "  -C comment  Provide new comment.\n");
           fprintf(stderr, "  -N phrase   Provide new passphrase.\n");
           fprintf(stderr, "  -P phrase   Provide old passphrase.\n");
   #ifdef SMARTCARD
           fprintf(stderr, "  -D reader   Download public key from smartcard.\n");
           fprintf(stderr, "  -U reader   Upload private key to smartcard.\n");
   #endif /* SMARTCARD */
   
         exit(1);          exit(1);
 }  }
   
Line 799 
Line 746 
 int  int
 main(int ac, char **av)  main(int ac, char **av)
 {  {
         char dotsshdir[16 * 1024], comment[1024], *passphrase1, *passphrase2;          char dotsshdir[MAXPATHLEN], comment[1024], *passphrase1, *passphrase2;
         char *reader_id = NULL;          char *reader_id = NULL;
         Key *private, *public;          Key *private, *public;
         struct passwd *pw;          struct passwd *pw;
Line 919 
Line 866 
                         do_download(pw, reader_id);                          do_download(pw, reader_id);
                 else                  else
                         do_upload(pw, reader_id);                          do_upload(pw, reader_id);
 #else  #else /* SMARTCARD */
                 fatal("no support for smartcards.");                  fatal("no support for smartcards.");
 #endif  #endif /* SMARTCARD */
         }          }
   
         arc4random_stir();          arc4random_stir();
   
           if (key_type_name == NULL) {
                   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);
Legend:
Removed from v.1.76  
changed lines
  Added in v.1.104