[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.65 and 1.66

version 1.65, 2001/06/24 05:35:33 version 1.66, 2001/06/26 02:47:07
Line 17 
Line 17 
 #include <openssl/evp.h>  #include <openssl/evp.h>
 #include <openssl/pem.h>  #include <openssl/pem.h>
   
   #ifdef SMARTCARD
   #include <sectok.h>
   #endif
   
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "key.h"  #include "key.h"
 #include "rsa.h"  #include "rsa.h"
Line 28 
Line 32 
 #include "log.h"  #include "log.h"
 #include "readpass.h"  #include "readpass.h"
   
   
 /* Number of bits in the RSA/DSA key.  This value can be changed on the command line. */  /* Number of bits in the RSA/DSA key.  This value can be changed on the command line. */
 int bits = 1024;  int bits = 1024;
   
Line 371 
Line 376 
         exit(0);          exit(0);
 }  }
   
   #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); \
   error("#bytes %d", len); \
                   if (BN_bn2bin(prv->rsa->x, elements[i]) < 0) \
                           goto done; \
           } while(0)
   
 static void  static void
   do_upload(struct passwd *pw, int reader)
   {
   #ifndef SMARTCARD
           fatal("no support for smartcards.");
   #else
           Key *prv = NULL;
           struct stat st;
           u_char *elements[NUM_RSA_KEY_ELEMENTS];
           u_char key_fid[2];
           u_char atr[256];
           u_char AUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};
           int len, status = 1, i, fd = -1, ret;
           int cla = 0x00;
   
           if (!have_identity)
                   ask_filename(pw, "Enter file in which the key is");
           if (stat(identity_file, &st) < 0) {
                   perror(identity_file);
                   goto done;
           }
           prv = load_identity(identity_file);
           if (prv == NULL) {
                   error("load failed");
                   goto done;
           }
   {
           prv->type = KEY_RSA;
           key_write(prv, stderr);
   }
           for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
                   elements[i] = NULL;
           COPY_RSA_KEY(q, 0);
           COPY_RSA_KEY(p, 1);
           COPY_RSA_KEY(iqmp, 2);
           COPY_RSA_KEY(dmq1, 3);
           COPY_RSA_KEY(dmp1, 4);
           COPY_RSA_KEY(n, 5);
           len = BN_num_bytes(prv->rsa->n);
           fd = scopen(reader, 0, NULL);
           if (fd < 0) {
                   error("scopen failed %d.", fd);
                   goto done;
           }
           ret = screset(fd, atr, NULL);
           if (ret <= 0) {
                   error("screset failed.");
                   goto done;
           }
           if (cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(AUT0)) < 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) < 0)
                   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]) < 0)
                   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++)
                   xfree(elements[i]);
           if (fd != -1)
                   scclose(fd);
           exit(status);
   #endif
   }
   
   static void
 do_fingerprint(struct passwd *pw)  do_fingerprint(struct passwd *pw)
 {  {
         FILE *f;          FILE *f;
Line 660 
Line 751 
         char dotsshdir[16 * 1024], comment[1024], *passphrase1, *passphrase2;          char dotsshdir[16 * 1024], comment[1024], *passphrase1, *passphrase2;
         Key *private, *public;          Key *private, *public;
         struct passwd *pw;          struct passwd *pw;
         int opt, type, fd;          int opt, type, fd, reader = -1;
         struct stat st;          struct stat st;
         FILE *f;          FILE *f;
   
Line 680 
Line 771 
                 exit(1);                  exit(1);
         }          }
   
         while ((opt = getopt(ac, av, "deiqpclBRxXyb:f:t:P:N:C:")) != -1) {          while ((opt = getopt(ac, av, "deiqpclBRxXyb:f:t:u:P:N:C:")) != -1) {
                 switch (opt) {                  switch (opt) {
                 case 'b':                  case 'b':
                         bits = atoi(optarg);                          bits = atoi(optarg);
Line 689 
Line 780 
                                 exit(1);                                  exit(1);
                         }                          }
                         break;                          break;
   
                 case 'l':                  case 'l':
                         print_fingerprint = 1;                          print_fingerprint = 1;
                         break;                          break;
   
                 case 'B':                  case 'B':
                         print_bubblebabble = 1;                          print_bubblebabble = 1;
                         break;                          break;
   
                 case 'p':                  case 'p':
                         change_passphrase = 1;                          change_passphrase = 1;
                         break;                          break;
   
                 case 'c':                  case 'c':
                         change_comment = 1;                          change_comment = 1;
                         break;                          break;
   
                 case 'f':                  case 'f':
                         strlcpy(identity_file, optarg, sizeof(identity_file));                          strlcpy(identity_file, optarg, sizeof(identity_file));
                         have_identity = 1;                          have_identity = 1;
                         break;                          break;
   
                 case 'P':                  case 'P':
                         identity_passphrase = optarg;                          identity_passphrase = optarg;
                         break;                          break;
   
                 case 'N':                  case 'N':
                         identity_new_passphrase = optarg;                          identity_new_passphrase = optarg;
                         break;                          break;
   
                 case 'C':                  case 'C':
                         identity_comment = optarg;                          identity_comment = optarg;
                         break;                          break;
   
                 case 'q':                  case 'q':
                         quiet = 1;                          quiet = 1;
                         break;                          break;
   
                 case 'R':                  case 'R':
                         /* unused */                          /* unused */
                         exit(0);                          exit(0);
                         break;                          break;
   
                 case 'e':                  case 'e':
                 case 'x':                  case 'x':
                         /* export key */                          /* export key */
                         convert_to_ssh2 = 1;                          convert_to_ssh2 = 1;
                         break;                          break;
   
                 case 'i':                  case 'i':
                 case 'X':                  case 'X':
                         /* import key */                          /* import key */
                         convert_from_ssh2 = 1;                          convert_from_ssh2 = 1;
                         break;                          break;
   
                 case 'y':                  case 'y':
                         print_public = 1;                          print_public = 1;
                         break;                          break;
   
                 case 'd':                  case 'd':
                         key_type_name = "dsa";                          key_type_name = "dsa";
                         break;                          break;
   
                 case 't':                  case 't':
                         key_type_name = optarg;                          key_type_name = optarg;
                         break;                          break;
                   case 'u':
                           reader = atoi(optarg); /*XXX*/
                           break;
                 case '?':                  case '?':
                 default:                  default:
                         usage();                          usage();
Line 781 
Line 859 
                 do_convert_from_ssh2(pw);                  do_convert_from_ssh2(pw);
         if (print_public)          if (print_public)
                 do_print_public(pw);                  do_print_public(pw);
           if (reader != -1)
                   do_upload(pw, reader);
   
         arc4random_stir();          arc4random_stir();
   
Legend:
Removed from v.1.65  
changed lines
  Added in v.1.66