Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Diff of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 4321 by maya, Sat Feb 19 07:41:41 2011 UTC revision 4325 by maya, Sat Feb 19 15:37:07 2011 UTC
# Line 2861  static BOOL CALLBACK TTXSetupDlg(HWND dl Line 2861  static BOOL CALLBACK TTXSetupDlg(HWND dl
2861  typedef struct {  typedef struct {
2862          RSA *rsa;          RSA *rsa;
2863          DSA *dsa;          DSA *dsa;
2864            EC_KEY *ecdsa;
2865          enum ssh_keytype type;          enum ssh_keytype type;
2866  } ssh_private_key_t;  } ssh_private_key_t;
2867    
2868  static ssh_private_key_t private_key = {NULL, NULL, KEY_UNSPEC};  static ssh_private_key_t private_key = {NULL, NULL, NULL, KEY_UNSPEC};
2869    
2870  typedef struct {  typedef struct {
2871          RSA *rsa;          RSA *rsa;
2872          DSA *dsa;          DSA *dsa;
2873            EC_KEY *ecdsa;
2874          enum ssh_keytype type;          enum ssh_keytype type;
2875  } ssh_public_key_t;  } ssh_public_key_t;
2876    
2877  static ssh_public_key_t public_key = {NULL, NULL, KEY_UNSPEC};  static ssh_public_key_t public_key = {NULL, NULL, NULL, KEY_UNSPEC};
2878    
2879  static void free_ssh_key(void)  static void free_ssh_key(void)
2880  {  {
# Line 2887  static void free_ssh_key(void) Line 2889  static void free_ssh_key(void)
2889          RSA_free(public_key.rsa);          RSA_free(public_key.rsa);
2890          public_key.rsa = NULL;          public_key.rsa = NULL;
2891    
2892            EC_KEY_free(private_key.ecdsa);
2893            private_key.ecdsa = NULL;
2894            EC_KEY_free(public_key.ecdsa);
2895            public_key.ecdsa = NULL;
2896    
2897          private_key.type = KEY_UNSPEC;          private_key.type = KEY_UNSPEC;
2898          public_key.type = KEY_UNSPEC;          public_key.type = KEY_UNSPEC;
2899  }  }
# Line 2896  static BOOL generate_ssh_key(enum ssh_ke Line 2903  static BOOL generate_ssh_key(enum ssh_ke
2903          // if SSH key already is generated, should free the resource.          // if SSH key already is generated, should free the resource.
2904          free_ssh_key();          free_ssh_key();
2905    
2906          if (type == KEY_RSA1 || type == KEY_RSA) {          switch (type) {
2907            case KEY_RSA1:
2908            case KEY_RSA:
2909            {
2910                  RSA *priv = NULL;                  RSA *priv = NULL;
2911                  RSA *pub = NULL;                  RSA *pub = NULL;
2912    
# Line 2918  static BOOL generate_ssh_key(enum ssh_ke Line 2928  static BOOL generate_ssh_key(enum ssh_ke
2928                  BN_copy(pub->n, priv->n);                  BN_copy(pub->n, priv->n);
2929                  BN_copy(pub->e, priv->e);                  BN_copy(pub->e, priv->e);
2930                  public_key.rsa = pub;                  public_key.rsa = pub;
2931                    break;
2932          } else if (type == KEY_DSA) {          }
2933            
2934            case KEY_DSA:
2935            {
2936                  DSA *priv = NULL;                  DSA *priv = NULL;
2937                  DSA *pub = NULL;                  DSA *pub = NULL;
2938    
# Line 2951  static BOOL generate_ssh_key(enum ssh_ke Line 2964  static BOOL generate_ssh_key(enum ssh_ke
2964                  BN_copy(pub->g, priv->g);                  BN_copy(pub->g, priv->g);
2965                  BN_copy(pub->pub_key, priv->pub_key);                  BN_copy(pub->pub_key, priv->pub_key);
2966                  public_key.dsa = pub;                  public_key.dsa = pub;
2967                    break;
2968            }
2969    
2970          } else {          case KEY_ECDSA256:
2971            case KEY_ECDSA384:
2972            case KEY_ECDSA521:
2973            {
2974                    EC_KEY *priv = NULL;
2975                    EC_KEY *pub = NULL;
2976    
2977                    switch (type) {
2978                            case KEY_ECDSA256:
2979                                    priv = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
2980                                    pub = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
2981                                    break;
2982                            case KEY_ECDSA384:
2983                                    priv = EC_KEY_new_by_curve_name(NID_secp384r1);
2984                                    pub = EC_KEY_new_by_curve_name(NID_secp384r1);
2985                                    break;
2986                            case KEY_ECDSA521:
2987                                    priv = EC_KEY_new_by_curve_name(NID_secp521r1);
2988                                    pub = EC_KEY_new_by_curve_name(NID_secp521r1);
2989                                    break;
2990                    }
2991                    if (priv == NULL || pub == NULL) {
2992                            goto error;
2993                    }
2994    
2995                    // private key
2996                    if (EC_KEY_generate_key(priv) != 1) {
2997                            goto error;
2998                    }
2999                    EC_KEY_set_asn1_flag(priv, OPENSSL_EC_NAMED_CURVE);
3000                    private_key.ecdsa = priv;
3001    
3002                    // public key
3003                    if (EC_KEY_set_public_key(pub, EC_KEY_get0_public_key(priv)) != 1) {
3004                            goto error;
3005                    }
3006                    public_key.ecdsa = pub;
3007    
3008                    break;
3009            }
3010    
3011            default:
3012                  goto error;                  goto error;
3013          }          }
3014    
# Line 3480  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3536  static BOOL CALLBACK TTXKeyGenerator(HWN
3536                          SendDlgItemMessage(dlg, IDC_RSA1_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_RSA1_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3537                          SendDlgItemMessage(dlg, IDC_RSA_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_RSA_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3538                          SendDlgItemMessage(dlg, IDC_DSA_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_DSA_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3539                            SendDlgItemMessage(dlg, IDC_ECDSA256_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3540                            SendDlgItemMessage(dlg, IDC_ECDSA384_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3541                            SendDlgItemMessage(dlg, IDC_ECDSA521_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3542                          SendDlgItemMessage(dlg, IDC_KEYBITS_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_KEYBITS_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3543                          SendDlgItemMessage(dlg, IDC_KEYBITS, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_KEYBITS, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
3544                          SendDlgItemMessage(dlg, IDC_KEY_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_KEY_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
# Line 3526  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3585  static BOOL CALLBACK TTXKeyGenerator(HWN
3585                          cbarg.type = key_type;                          cbarg.type = key_type;
3586                          cbarg.dlg = dlg;                          cbarg.dlg = dlg;
3587    
3588                            bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
3589    
3590                            switch (key_type) {
3591                                    case KEY_RSA1:
3592                                    case KEY_RSA:
3593                                    case KEY_DSA:
3594                                            if (bits < ((key_type==KEY_DSA)?SSH_DSA_MINIMUM_KEY_SIZE:SSH_RSA_MINIMUM_KEY_SIZE)) {
3595                                                    UTIL_get_lang_msg("MSG_KEYBITS_MIN_ERROR", pvar,
3596                                                                      "The key bits is too small.");
3597                                                    MessageBox(dlg, pvar->ts->UIMsg,
3598                                                               "Tera Term", MB_OK | MB_ICONEXCLAMATION);
3599                                                    return TRUE;
3600                                            }
3601                                            break;
3602                                    case KEY_ECDSA256:
3603                                            SetDlgItemInt(dlg, IDC_KEYBITS, 256, FALSE);
3604                                            break;
3605                                    case KEY_ECDSA384:
3606                                            SetDlgItemInt(dlg, IDC_KEYBITS, 384, FALSE);
3607                                            break;
3608                                    case KEY_ECDSA521:
3609                                            SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);
3610                                            break;
3611                            }
3612    
3613                          // passphrase edit box disabled(default)                          // passphrase edit box disabled(default)
3614                          EnableWindow(GetDlgItem(dlg, IDC_KEY_EDIT), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_KEY_EDIT), FALSE);
3615                          EnableWindow(GetDlgItem(dlg, IDC_CONFIRM_EDIT), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_CONFIRM_EDIT), FALSE);
# Line 3537  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3621  static BOOL CALLBACK TTXKeyGenerator(HWN
3621                          EnableWindow(GetDlgItem(dlg, IDC_RSA1_TYPE), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_RSA1_TYPE), FALSE);
3622                          EnableWindow(GetDlgItem(dlg, IDC_RSA_TYPE), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_RSA_TYPE), FALSE);
3623                          EnableWindow(GetDlgItem(dlg, IDC_DSA_TYPE), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_DSA_TYPE), FALSE);
3624                            EnableWindow(GetDlgItem(dlg, IDC_ECDSA256_TYPE), FALSE);
3625                            EnableWindow(GetDlgItem(dlg, IDC_ECDSA384_TYPE), FALSE);
3626                            EnableWindow(GetDlgItem(dlg, IDC_ECDSA521_TYPE), FALSE);
3627                          EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);                          EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
3628                          EnableWindow(GetDlgItem(dlg, IDOK), FALSE);                          EnableWindow(GetDlgItem(dlg, IDOK), FALSE);
3629                          EnableWindow(GetDlgItem(dlg, IDCANCEL), FALSE);                          EnableWindow(GetDlgItem(dlg, IDCANCEL), FALSE);
3630    
                         bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);  
   
                         if (bits < ((key_type==KEY_DSA)?SSH_DSA_MINIMUM_KEY_SIZE:SSH_RSA_MINIMUM_KEY_SIZE)) {  
                                 UTIL_get_lang_msg("MSG_KEYBITS_MIN_ERROR", pvar,  
                                                   "The key bits is too small.");  
                                 MessageBox(dlg, pvar->ts->UIMsg,  
                                            "Tera Term", MB_OK | MB_ICONEXCLAMATION);  
                                 return TRUE;  
                         }  
   
3631                          if (generate_ssh_key(key_type, bits, keygen_progress, &cbarg)) {                          if (generate_ssh_key(key_type, bits, keygen_progress, &cbarg)) {
3632                                  MSG msg;                                  MSG msg;
3633                                  int c = 0;                                  int c = 0;
# Line 3574  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3651  static BOOL CALLBACK TTXKeyGenerator(HWN
3651                                  EnableWindow(GetDlgItem(dlg, IDC_RSA1_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_RSA1_TYPE), TRUE);
3652                                  EnableWindow(GetDlgItem(dlg, IDC_RSA_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_RSA_TYPE), TRUE);
3653                                  EnableWindow(GetDlgItem(dlg, IDC_DSA_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_DSA_TYPE), TRUE);
3654                                    EnableWindow(GetDlgItem(dlg, IDC_ECDSA256_TYPE), TRUE);
3655                                    EnableWindow(GetDlgItem(dlg, IDC_ECDSA384_TYPE), TRUE);
3656                                    EnableWindow(GetDlgItem(dlg, IDC_ECDSA521_TYPE), TRUE);
3657                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);
3658                                  EnableWindow(GetDlgItem(dlg, IDOK), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDOK), TRUE);
3659                                  EnableWindow(GetDlgItem(dlg, IDCANCEL), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDCANCEL), TRUE);
# Line 3606  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3686  static BOOL CALLBACK TTXKeyGenerator(HWN
3686                          key_type = KEY_DSA;                          key_type = KEY_DSA;
3687                          break;                          break;
3688    
3689                    case IDC_ECDSA256_TYPE | (BN_CLICKED << 16):
3690                            key_type = KEY_ECDSA256;
3691                            SetDlgItemInt(dlg, IDC_KEYBITS, 256, FALSE);
3692                            break;
3693    
3694                    case IDC_ECDSA384_TYPE | (BN_CLICKED << 16):
3695                            key_type = KEY_ECDSA384;
3696                            SetDlgItemInt(dlg, IDC_KEYBITS, 384, FALSE);
3697                            break;
3698    
3699                    case IDC_ECDSA521_TYPE | (BN_CLICKED << 16):
3700                            key_type = KEY_ECDSA521;
3701                            SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);
3702                            break;
3703    
3704                  // saving public key file                  // saving public key file
3705                  case IDC_SAVE_PUBLIC_KEY:                  case IDC_SAVE_PUBLIC_KEY:
3706                          {                          {
# Line 3621  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3716  static BOOL CALLBACK TTXKeyGenerator(HWN
3716                          ZeroMemory(&ofn, sizeof(ofn));                          ZeroMemory(&ofn, sizeof(ofn));
3717                          ofn.lStructSize = sizeof(ofn);                          ofn.lStructSize = sizeof(ofn);
3718                          ofn.hwndOwner = dlg;                          ofn.hwndOwner = dlg;
3719                          if (public_key.type == KEY_RSA1) {                          switch (public_key.type) {
3720                            case KEY_RSA1:
3721                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_RSA1_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_RSA1_FILTER", pvar,
3722                                                    "SSH1 RSA key(identity.pub)\\0identity.pub\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH1 RSA key(identity.pub)\\0identity.pub\\0All Files(*.*)\\0*.*\\0\\0");
3723                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3724                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3725                                  strncpy_s(filename, sizeof(filename), "identity.pub", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "identity.pub", _TRUNCATE);
3726                          } else if (public_key.type == KEY_RSA) {                                  break;
3727                            case KEY_RSA:
3728                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_RSA_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_RSA_FILTER", pvar,
3729                                                    "SSH2 RSA key(id_rsa.pub)\\0id_rsa.pub\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH2 RSA key(id_rsa.pub)\\0id_rsa.pub\\0All Files(*.*)\\0*.*\\0\\0");
3730                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3731                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3732                                  strncpy_s(filename, sizeof(filename), "id_rsa.pub", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_rsa.pub", _TRUNCATE);
3733                          } else {                                  break;
3734                            case KEY_DSA:
3735                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_DSA_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_DSA_FILTER", pvar,
3736                                                    "SSH2 DSA key(id_dsa.pub)\\0id_dsa.pub\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH2 DSA key(id_dsa.pub)\\0id_dsa.pub\\0All Files(*.*)\\0*.*\\0\\0");
3737                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3738                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3739                                  strncpy_s(filename, sizeof(filename), "id_dsa.pub", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_dsa.pub", _TRUNCATE);
3740                                    break;
3741                            case KEY_ECDSA256:
3742                            case KEY_ECDSA384:
3743                            case KEY_ECDSA521:
3744                                    UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_ECDSA_FILTER", pvar,
3745                                                      "SSH2 ECDSA key(id_ecdsa.pub)\\0id_ecdsa.pub\\0All Files(*.*)\\0*.*\\0\\0");
3746                                    memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3747                                    ofn.lpstrFilter = uimsg;
3748                                    strncpy_s(filename, sizeof(filename), "id_ecdsa.pub", _TRUNCATE);
3749                                    break;
3750                          }                          }
3751                          ofn.lpstrFile = filename;                          ofn.lpstrFile = filename;
3752                          ofn.nMaxFile = sizeof(filename);                          ofn.nMaxFile = sizeof(filename);
# Line 3679  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3787  static BOOL CALLBACK TTXKeyGenerator(HWN
3787                                  fprintf(fp, " %s", buf);                                  fprintf(fp, " %s", buf);
3788                                  OPENSSL_free(buf);                                  OPENSSL_free(buf);
3789    
3790                          } else { // SSH2 RSA, DSA                          } else { // SSH2 RSA, DSA, ECDSA
3791                                  buffer_t *b;                                  buffer_t *b;
3792                                  char *keyname;                                  char *keyname, *s;
3793                                  DSA *dsa = public_key.dsa;                                  DSA *dsa = public_key.dsa;
3794                                  RSA *rsa = public_key.rsa;                                  RSA *rsa = public_key.rsa;
3795                                    EC_KEY *ecdsa = public_key.ecdsa;
3796                                  int len;                                  int len;
3797                                  char *blob;                                  char *blob;
3798                                  char *uuenc; // uuencode data                                  char *uuenc; // uuencode data
# Line 3693  static BOOL CALLBACK TTXKeyGenerator(HWN Line 3802  static BOOL CALLBACK TTXKeyGenerator(HWN
3802                                  if (b == NULL)                                  if (b == NULL)
3803                                          goto public_error;                                          goto public_error;
3804    
3805                                  if (public_key.type == KEY_DSA) { // DSA                                  switch (public_key.type) {
3806                                    case KEY_DSA: // DSA
3807                                          keyname = "ssh-dss";                                          keyname = "ssh-dss";
3808                                          buffer_put_string(b, keyname, strlen(keyname));                                          buffer_put_string(b, keyname, strlen(keyname));
3809                                          buffer_put_bignum2(b, dsa->p);                                          buffer_put_bignum2(b, dsa->p);
3810                                          buffer_put_bignum2(b, dsa->q);                                          buffer_put_bignum2(b, dsa->q);
3811                                          buffer_put_bignum2(b, dsa->g);                                          buffer_put_bignum2(b, dsa->g);
3812                                          buffer_put_bignum2(b, dsa->pub_key);                                          buffer_put_bignum2(b, dsa->pub_key);
3813                                            break;
3814    
3815                                  } else { // RSA                                  case KEY_RSA: // RSA
3816                                          keyname = "ssh-rsa";                                          keyname = "ssh-rsa";
3817                                          buffer_put_string(b, keyname, strlen(keyname));                                          buffer_put_string(b, keyname, strlen(keyname));
3818                                          buffer_put_bignum2(b, rsa->e);                                          buffer_put_bignum2(b, rsa->e);
3819                                          buffer_put_bignum2(b, rsa->n);                                          buffer_put_bignum2(b, rsa->n);
3820                                            break;
3821    
3822                                    case KEY_ECDSA256: // ECDSA
3823                                    case KEY_ECDSA384:
3824                                    case KEY_ECDSA521:
3825                                            keyname = get_sshname_from_keytype(public_key.type);
3826                                            buffer_put_string(b, keyname, strlen(keyname));
3827                                            s = curve_keytype_to_name(public_key.type);
3828                                            buffer_put_string(b, s, strlen(s));
3829                                            buffer_put_ecpoint(b, EC_KEY_get0_group(ecdsa),
3830                                                                  EC_KEY_get0_public_key(ecdsa));
3831                                            break;
3832                                  }                                  }
3833    
3834                                  blob = buffer_ptr(b);                                  blob = buffer_ptr(b);
# Line 3773  public_error: Line 3896  public_error:
3896                          ZeroMemory(&ofn, sizeof(ofn));                          ZeroMemory(&ofn, sizeof(ofn));
3897                          ofn.lStructSize = sizeof(ofn);                          ofn.lStructSize = sizeof(ofn);
3898                          ofn.hwndOwner = dlg;                          ofn.hwndOwner = dlg;
3899                          if (private_key.type == KEY_RSA1) {                          switch (private_key.type) {
3900                            case KEY_RSA1:
3901                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_RSA1_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_RSA1_FILTER", pvar,
3902                                                    "SSH1 RSA key(identity)\\0identity\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH1 RSA key(identity)\\0identity\\0All Files(*.*)\\0*.*\\0\\0");
3903                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3904                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3905                                  strncpy_s(filename, sizeof(filename), "identity", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "identity", _TRUNCATE);
3906                          } else if (private_key.type == KEY_RSA) {                                  break;
3907                            case KEY_RSA:
3908                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_RSA_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_RSA_FILTER", pvar,
3909                                                    "SSH2 RSA key(id_rsa)\\0id_rsa\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH2 RSA key(id_rsa)\\0id_rsa\\0All Files(*.*)\\0*.*\\0\\0");
3910                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3911                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3912                                  strncpy_s(filename, sizeof(filename), "id_rsa", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_rsa", _TRUNCATE);
3913                          } else {                                  break;
3914                            case KEY_DSA:
3915                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_DSA_FILTER", pvar,                                  UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_DSA_FILTER", pvar,
3916                                                    "SSH2 DSA key(id_dsa)\\0id_dsa\\0All Files(*.*)\\0*.*\\0\\0");                                                    "SSH2 DSA key(id_dsa)\\0id_dsa\\0All Files(*.*)\\0*.*\\0\\0");
3917                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));                                  memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3918                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
3919                                  strncpy_s(filename, sizeof(filename), "id_dsa", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_dsa", _TRUNCATE);
3920                                    break;
3921                            case KEY_ECDSA256:
3922                            case KEY_ECDSA384:
3923                            case KEY_ECDSA521:
3924                                    UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_ECDSA_FILTER", pvar,
3925                                                      "SSH2 ECDSA key(id_ecdsa)\\0id_ecdsa\\0All Files(*.*)\\0*.*\\0\\0");
3926                                    memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
3927                                    ofn.lpstrFilter = uimsg;
3928                                    strncpy_s(filename, sizeof(filename), "id_ecdsa", _TRUNCATE);
3929                                    break;
3930                          }                          }
3931                          ofn.lpstrFile = filename;                          ofn.lpstrFile = filename;
3932                          ofn.nMaxFile = sizeof(filename);                          ofn.nMaxFile = sizeof(filename);
# Line 3920  error:; Line 4056  error:;
4056                                  buffer_free(b);                                  buffer_free(b);
4057                                  buffer_free(enc);                                  buffer_free(enc);
4058    
4059                          } else { // SSH2 RSA, DSA                          } else { // SSH2 RSA, DSA, ECDSA
4060                                  int len;                                  int len;
4061                                  FILE *fp;                                  FILE *fp;
4062                                  const EVP_CIPHER *cipher;                                  const EVP_CIPHER *cipher;
# Line 3942  error:; Line 4078  error:;
4078                                          MessageBox(dlg, uimsg, pvar->ts->UIMsg, MB_OK | MB_ICONEXCLAMATION);                                          MessageBox(dlg, uimsg, pvar->ts->UIMsg, MB_OK | MB_ICONEXCLAMATION);
4079                                          break;                                          break;
4080                                  }                                  }
4081    
4082                                  if (key_type == KEY_RSA) { // RSA                                  switch (key_type) {
4083                                    case KEY_RSA: // RSA
4084                                          ret = PEM_write_RSAPrivateKey(fp, private_key.rsa, cipher, buf, len, NULL, NULL);                                          ret = PEM_write_RSAPrivateKey(fp, private_key.rsa, cipher, buf, len, NULL, NULL);
4085                                  } else { // DSA                                          break;
4086                                    case KEY_DSA: // DSA
4087                                          ret = PEM_write_DSAPrivateKey(fp, private_key.dsa, cipher, buf, len, NULL, NULL);                                          ret = PEM_write_DSAPrivateKey(fp, private_key.dsa, cipher, buf, len, NULL, NULL);
4088                                            break;
4089                                    case KEY_ECDSA256: // ECDSA
4090                                    case KEY_ECDSA384:
4091                                    case KEY_ECDSA521:
4092                                            ret = PEM_write_ECPrivateKey(fp, private_key.ecdsa, cipher, buf, len, NULL, NULL);
4093                                            break;
4094                                  }                                  }
4095                                  if (ret == 0) {                                  if (ret == 0) {
4096                                          UTIL_get_lang_msg("MSG_SAVE_KEY_WRITEFILE_ERROR", pvar,                                          UTIL_get_lang_msg("MSG_SAVE_KEY_WRITEFILE_ERROR", pvar,
Legend:
Removed from v.4321  
changed lines
  Added in v.4325
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help