[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.82 and 1.82.2.3

version 1.82, 2001/09/28 12:07:09 version 1.82.2.3, 2002/05/17 00:03:24
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);          fflush(stderr);
Line 143 
Line 144 
 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 184 
Line 185 
         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(u_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 268 
Line 269 
                 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 285 
Line 286 
 {  {
         Key *k;          Key *k;
         int blen;          int blen;
           u_int len;
         char line[1024], *p;          char line[1024], *p;
         u_char blob[8096];          u_char blob[8096];
         char encoded[8096];          char encoded[8096];
Line 329 
Line 331 
                 *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 351 
Line 359 
                 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 381 
Line 390 
 }  }
   
 #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);          log("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:  
   
         memset(elements[0], '\0', BN_num_bytes(prv->rsa->q));  
         memset(elements[1], '\0', BN_num_bytes(prv->rsa->p));  
         memset(elements[2], '\0', BN_num_bytes(prv->rsa->iqmp));  
         memset(elements[3], '\0', BN_num_bytes(prv->rsa->dmq1));  
         memset(elements[4], '\0', BN_num_bytes(prv->rsa->dmp1));  
         memset(elements[5], '\0', BN_num_bytes(prv->rsa->n));  
   
         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 /* SMARTCARD */  #endif /* SMARTCARD */
Line 530 
Line 441 
         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 611 
Line 524 
                 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 664 
Line 577 
                         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 742 
Line 655 
                 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 829 
Line 742 
 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 956 
Line 869 
   
         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.82  
changed lines
  Added in v.1.82.2.3