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 5430 by yutakapon, Sat Nov 23 16:29:16 2013 UTC revision 5545 by yutakapon, Mon Mar 17 16:06:58 2014 UTC
# Line 38  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI Line 38  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI
38  #include "ssh.h"  #include "ssh.h"
39  #include "ttcommon.h"  #include "ttcommon.h"
40  #include "ttlib.h"  #include "ttlib.h"
41    #include "keyfiles.h"
42    
43  #include <stdlib.h>  #include <stdlib.h>
44  #include <stdio.h>  #include <stdio.h>
# Line 287  static void normalize_host_key_order(cha Line 288  static void normalize_host_key_order(cha
288                  KEY_ECDSA256,                  KEY_ECDSA256,
289                  KEY_ECDSA384,                  KEY_ECDSA384,
290                  KEY_ECDSA521,                  KEY_ECDSA521,
291                    KEY_ED25519,
292                  KEY_RSA,                  KEY_RSA,
293                  KEY_DSA,                  KEY_DSA,
294                  KEY_NONE,                  KEY_NONE,
# Line 3383  typedef struct { Line 3385  typedef struct {
3385          RSA *rsa;          RSA *rsa;
3386          DSA *dsa;          DSA *dsa;
3387          EC_KEY *ecdsa;          EC_KEY *ecdsa;
3388            unsigned char *ed25519_sk;
3389            unsigned char *ed25519_pk;
3390          ssh_keytype type;          ssh_keytype type;
3391  } ssh_private_key_t;  } ssh_private_key_t;
3392    
3393  static ssh_private_key_t private_key = {NULL, NULL, NULL, KEY_UNSPEC};  static ssh_private_key_t private_key = {NULL, NULL, NULL, NULL, NULL, KEY_UNSPEC};
3394    
3395  typedef struct {  typedef struct {
3396          RSA *rsa;          RSA *rsa;
3397          DSA *dsa;          DSA *dsa;
3398          EC_KEY *ecdsa;          EC_KEY *ecdsa;
3399            unsigned char *ed25519_sk;
3400            unsigned char *ed25519_pk;
3401          ssh_keytype type;          ssh_keytype type;
3402  } ssh_public_key_t;  } ssh_public_key_t;
3403    
3404  static ssh_public_key_t public_key = {NULL, NULL, NULL, KEY_UNSPEC};  static ssh_public_key_t public_key = {NULL, NULL, NULL, NULL, NULL, KEY_UNSPEC};
3405    
3406  static void free_ssh_key(void)  static void free_ssh_key(void)
3407  {  {
# Line 3415  static void free_ssh_key(void) Line 3421  static void free_ssh_key(void)
3421          EC_KEY_free(public_key.ecdsa);          EC_KEY_free(public_key.ecdsa);
3422          public_key.ecdsa = NULL;          public_key.ecdsa = NULL;
3423    
3424            free(private_key.ed25519_sk);
3425            private_key.ed25519_sk = NULL;
3426            free(private_key.ed25519_pk);
3427            private_key.ed25519_pk = NULL;
3428    
3429          private_key.type = KEY_UNSPEC;          private_key.type = KEY_UNSPEC;
3430          public_key.type = KEY_UNSPEC;          public_key.type = KEY_UNSPEC;
3431  }  }
# Line 3523  static BOOL generate_ssh_key(ssh_keytype Line 3534  static BOOL generate_ssh_key(ssh_keytype
3534                  break;                  break;
3535          }          }
3536    
3537            case KEY_ED25519:
3538            {
3539                    // 秘密鍵を作る
3540                    private_key.ed25519_pk = malloc(ED25519_PK_SZ);
3541                    private_key.ed25519_sk = malloc(ED25519_SK_SZ);
3542                    if (private_key.ed25519_pk == NULL || private_key.ed25519_sk == NULL)
3543                            goto error;
3544                    crypto_sign_ed25519_keypair(private_key.ed25519_pk, private_key.ed25519_sk);
3545    
3546                    // 公開鍵を作る
3547                    public_key.ed25519_pk = malloc(ED25519_PK_SZ);
3548                    if (public_key.ed25519_pk == NULL)
3549                            goto error;
3550                    memcpy(public_key.ed25519_pk, private_key.ed25519_pk, ED25519_PK_SZ);
3551    
3552                    break;
3553            }
3554    
3555          default:          default:
3556                  goto error;                  goto error;
3557          }          }
# Line 3601  static unsigned int arc4random(void) Line 3630  static unsigned int arc4random(void)
3630          return(r);          return(r);
3631  }  }
3632    
3633    void arc4random_buf(void *_buf, size_t n)
3634    {
3635            size_t i;
3636            unsigned int r = 0;
3637            char *buf = (char *)_buf;
3638    
3639            for (i = 0; i < n; i++) {
3640                    if (i % 4 == 0)
3641                            r = arc4random();
3642                    buf[i] = r & 0xff;
3643                    r >>= 8;
3644            }
3645            i = r = 0;
3646    }
3647    
3648  //  //
3649  // SSH1 3DES  // SSH1 3DES
3650  //  //
# Line 4036  static void init_password_control(HWND d Line 4080  static void init_password_control(HWND d
4080                                      (LONG) password_wnd_proc));                                      (LONG) password_wnd_proc));
4081  }  }
4082    
4083    // bcrypt KDF形式で秘密鍵を保存する
4084    // based on OpenSSH 6.5:key_save_private(), key_private_to_blob2()
4085    static void save_bcrypt_private_key(char *passphrase, char *filename, char *comment, HWND dlg, PTInstVar pvar)
4086    {
4087            SSHCipher ciphernameval = SSH_CIPHER_NONE;
4088            char *ciphername = DEFAULT_CIPHERNAME;
4089            int rounds = DEFAULT_ROUNDS;
4090            buffer_t *b = NULL;
4091            buffer_t *kdf = NULL;
4092            buffer_t *encoded = NULL;
4093            buffer_t *blob = NULL;
4094            int blocksize, keylen, ivlen, authlen, i, n;
4095            unsigned char *key = NULL, salt[SALT_LEN];
4096            char *kdfname = KDFNAME;
4097            EVP_CIPHER_CTX cipher_ctx;
4098            Key keyblob;
4099            unsigned char *cp = NULL;
4100            unsigned int len, check;
4101            FILE *fp;
4102            char uimsg[MAX_UIMSG];
4103    
4104            b = buffer_init();
4105            kdf = buffer_init();
4106            encoded = buffer_init();
4107            blob = buffer_init();
4108            if (b == NULL || kdf == NULL || encoded == NULL || blob == NULL)
4109                    goto ed25519_error;
4110    
4111            ciphernameval = get_cipher_by_name(ciphername);
4112            blocksize = get_cipher_block_size(ciphernameval);
4113            keylen = get_cipher_key_len(ciphernameval);
4114            ivlen = blocksize;
4115            authlen = 0;  // TODO: とりあえず固定化
4116            key = calloc(1, keylen + ivlen);
4117    
4118            if (strcmp(kdfname, "none") != 0) {
4119                    arc4random_buf(salt, SALT_LEN);
4120                    if (bcrypt_pbkdf(passphrase, strlen(passphrase),
4121                            salt, SALT_LEN, key, keylen + ivlen, rounds) < 0)
4122                            //fatal("bcrypt_pbkdf failed");
4123                            ;
4124                    buffer_put_string(kdf, salt, SALT_LEN);
4125                    buffer_put_int(kdf, rounds);
4126            }
4127            // 暗号化の準備
4128            // TODO: OpenSSH 6.5では -Z オプションで、暗号化アルゴリズムを指定可能だが、
4129            // ここでは"AES256-CBC"に固定とする。
4130            cipher_init_SSH2(&cipher_ctx, key, keylen, key + keylen, ivlen, CIPHER_ENCRYPT,
4131                    get_cipher_EVP_CIPHER(ciphernameval), 0, pvar);
4132            memset(key, 0, keylen + ivlen);
4133            free(key);
4134    
4135            buffer_append(encoded, AUTH_MAGIC, sizeof(AUTH_MAGIC));
4136            buffer_put_cstring(encoded, ciphername);
4137            buffer_put_cstring(encoded, kdfname);
4138            buffer_put_string(encoded, buffer_ptr(kdf), buffer_len(kdf));
4139            buffer_put_int(encoded, 1);                     /* number of keys */
4140    
4141            // key_to_blob()を一時利用するため、Key構造体を初期化する。
4142            keyblob.type = private_key.type;
4143            keyblob.rsa = private_key.rsa;
4144            keyblob.dsa = private_key.dsa;
4145            keyblob.ecdsa = private_key.ecdsa;
4146            keyblob.ed25519_pk = private_key.ed25519_pk;
4147            keyblob.ed25519_sk = private_key.ed25519_sk;
4148            key_to_blob(&keyblob, &cp, &len);                       /* public key */
4149    
4150            buffer_put_string(encoded, cp, len);
4151    
4152            memset(cp, 0, len);
4153            free(cp);
4154    
4155            /* Random check bytes */
4156            check = arc4random();
4157            buffer_put_int(b, check);
4158            buffer_put_int(b, check);
4159    
4160            /* append private key and comment*/
4161            key_private_serialize(&keyblob, b);
4162            buffer_put_cstring(b, comment);
4163    
4164            /* padding */
4165            i = 0;
4166            while (buffer_len(b) % blocksize)
4167                    buffer_put_char(b, ++i & 0xff);
4168    
4169            /* length */
4170            buffer_put_int(encoded, buffer_len(b));
4171    
4172            /* encrypt */
4173            cp = buffer_append_space(encoded, buffer_len(b) + authlen);
4174            if (EVP_Cipher(&cipher_ctx, cp, buffer_ptr(b), buffer_len(b)) == 0) {
4175                    //strncpy_s(errmsg, errmsg_len, "Key decrypt error", _TRUNCATE);
4176                    //free(decrypted);
4177                    //goto error;
4178            }
4179            cipher_cleanup_SSH2(&cipher_ctx);
4180    
4181            len = 2 * buffer_len(encoded);
4182            cp = malloc(len);
4183            n = uuencode(buffer_ptr(encoded), buffer_len(encoded), (char *)cp, len);
4184            if (n < 0) {
4185                    free(cp);
4186                    goto ed25519_error;
4187            }
4188    
4189            buffer_clear(blob);
4190            buffer_append(blob, MARK_BEGIN, sizeof(MARK_BEGIN) - 1);
4191            for (i = 0; i < n; i++) {
4192                    buffer_put_char(blob, cp[i]);
4193                    if (i % 70 == 69)
4194                            buffer_put_char(blob, '\n');
4195            }
4196            if (i % 70 != 69)
4197                    buffer_put_char(blob, '\n');
4198            buffer_append(blob, MARK_END, sizeof(MARK_END) - 1);
4199            free(cp);
4200    
4201            len = buffer_len(blob);
4202    
4203            // 秘密鍵をファイルに保存する。
4204            fp = fopen(filename, "w");
4205            if (fp == NULL) {
4206                    UTIL_get_lang_msg("MSG_SAVE_KEY_OPENFILE_ERROR", pvar,
4207                                      "Can't open key file");
4208                    strncpy_s(uimsg, sizeof(uimsg), pvar->ts->UIMsg, _TRUNCATE);
4209                    UTIL_get_lang_msg("MSG_ERROR", pvar, "ERROR");
4210                    MessageBox(dlg, uimsg, pvar->ts->UIMsg, MB_OK | MB_ICONEXCLAMATION);
4211                    goto ed25519_error;
4212            }
4213            n = fwrite(buffer_ptr(blob), buffer_len(blob), 1, fp);
4214            if (n != 1) {
4215                    UTIL_get_lang_msg("MSG_SAVE_KEY_WRITEFILE_ERROR", pvar,
4216                                      "Can't open key file");
4217                    strncpy_s(uimsg, sizeof(uimsg), pvar->ts->UIMsg, _TRUNCATE);
4218                    UTIL_get_lang_msg("MSG_ERROR", pvar, "ERROR");
4219                    MessageBox(dlg, uimsg, pvar->ts->UIMsg, MB_OK | MB_ICONEXCLAMATION);
4220            }
4221            fclose(fp);
4222    
4223    
4224    ed25519_error:
4225            buffer_free(b);
4226            buffer_free(kdf);
4227            buffer_free(encoded);
4228            buffer_free(blob);
4229    }
4230    
4231  static BOOL CALLBACK TTXKeyGenerator(HWND dlg, UINT msg, WPARAM wParam,  static BOOL CALLBACK TTXKeyGenerator(HWND dlg, UINT msg, WPARAM wParam,
4232                                       LPARAM lParam)                                       LPARAM lParam)
4233  {  {
# Line 4078  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4270  static BOOL CALLBACK TTXKeyGenerator(HWN
4270                  GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));                  GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
4271                  UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);                  UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
4272                  SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);                  SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
4273                    GetDlgItemText(dlg, IDC_BCRYPT_KDF_CHECK, uimsg, sizeof(uimsg));
4274                    UTIL_get_lang_msg("DLG_BCRYPT_KDF", pvar, uimsg);
4275                    SetDlgItemText(dlg, IDC_BCRYPT_KDF_CHECK, pvar->ts->UIMsg);
4276    
4277                  font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);                  font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
4278                  GetObject(font, sizeof(LOGFONT), &logfont);                  GetObject(font, sizeof(LOGFONT), &logfont);
# Line 4089  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4284  static BOOL CALLBACK TTXKeyGenerator(HWN
4284                          SendDlgItemMessage(dlg, IDC_ECDSA256_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_ECDSA256_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4285                          SendDlgItemMessage(dlg, IDC_ECDSA384_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_ECDSA384_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4286                          SendDlgItemMessage(dlg, IDC_ECDSA521_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_ECDSA521_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4287                            SendDlgItemMessage(dlg, IDC_ED25519_TYPE, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4288                          SendDlgItemMessage(dlg, IDC_KEYBITS_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_KEYBITS_LABEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4289                          SendDlgItemMessage(dlg, IDC_KEYBITS, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_KEYBITS, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4290                          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 4102  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4298  static BOOL CALLBACK TTXKeyGenerator(HWN
4298                          SendDlgItemMessage(dlg, IDC_SAVE_PRIVATE_KEY, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDC_SAVE_PRIVATE_KEY, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4299                          SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4300                          SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));                          SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4301                            SendDlgItemMessage(dlg, IDC_BCRYPT_KDF_CHECK, WM_SETFONT, (WPARAM)DlgKeygenFont, MAKELPARAM(TRUE,0));
4302                  }                  }
4303                  else {                  else {
4304                          DlgHostFont = NULL;                          DlgHostFont = NULL;
# Line 4130  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4327  static BOOL CALLBACK TTXKeyGenerator(HWN
4327                  EnableWindow(GetDlgItem(dlg, IDC_SAVE_PUBLIC_KEY), FALSE);                  EnableWindow(GetDlgItem(dlg, IDC_SAVE_PUBLIC_KEY), FALSE);
4328                  EnableWindow(GetDlgItem(dlg, IDC_SAVE_PRIBATE_KEY), FALSE);                  EnableWindow(GetDlgItem(dlg, IDC_SAVE_PRIBATE_KEY), FALSE);
4329    
4330                    // default bcrypt KDF
4331                    EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4332    
4333                  }                  }
4334                  return TRUE;                  return TRUE;
4335    
# Line 4168  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4368  static BOOL CALLBACK TTXKeyGenerator(HWN
4368                                  case KEY_ECDSA521:                                  case KEY_ECDSA521:
4369                                          SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);                                          SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);
4370                                          break;                                          break;
4371                                    case KEY_ED25519:
4372                                            bits = 0;
4373                                            break;
4374                          }                          }
4375    
4376                          // passphrase edit box disabled(default)                          // passphrase edit box disabled(default)
# Line 4222  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4425  static BOOL CALLBACK TTXKeyGenerator(HWN
4425                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA256_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA256_TYPE), TRUE);
4426                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA384_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA384_TYPE), TRUE);
4427                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA521_TYPE), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_ECDSA521_TYPE), TRUE);
4428                                    EnableWindow(GetDlgItem(dlg, IDC_ED25519_TYPE), TRUE);
4429                                  if (!isFixedLengthKey(key_type)) {                                  if (!isFixedLengthKey(key_type)) {
4430                                          EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);                                          EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);
4431                                  }                                  }
# Line 4249  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4453  static BOOL CALLBACK TTXKeyGenerator(HWN
4453                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);
4454                                  SetDlgItemInt(dlg, IDC_KEYBITS, saved_key_bits, FALSE);                                  SetDlgItemInt(dlg, IDC_KEYBITS, saved_key_bits, FALSE);
4455                          }                          }
4456                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), FALSE);
4457                          key_type = KEY_RSA1;                          key_type = KEY_RSA1;
4458                          break;                          break;
4459    
# Line 4257  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4462  static BOOL CALLBACK TTXKeyGenerator(HWN
4462                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), TRUE);
4463                                  SetDlgItemInt(dlg, IDC_KEYBITS, saved_key_bits, FALSE);                                  SetDlgItemInt(dlg, IDC_KEYBITS, saved_key_bits, FALSE);
4464                          }                          }
4465                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4466                          key_type = KEY_RSA;                          key_type = KEY_RSA;
4467                          break;                          break;
4468    
# Line 4265  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4471  static BOOL CALLBACK TTXKeyGenerator(HWN
4471                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
4472                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
4473                          }                          }
4474                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4475                          key_type = KEY_DSA;                          key_type = KEY_DSA;
4476                          SetDlgItemInt(dlg, IDC_KEYBITS, 1024, FALSE);                          SetDlgItemInt(dlg, IDC_KEYBITS, 1024, FALSE);
4477                          break;                          break;
# Line 4274  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4481  static BOOL CALLBACK TTXKeyGenerator(HWN
4481                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
4482                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
4483                          }                          }
4484                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4485                          key_type = KEY_ECDSA256;                          key_type = KEY_ECDSA256;
4486                          SetDlgItemInt(dlg, IDC_KEYBITS, 256, FALSE);                          SetDlgItemInt(dlg, IDC_KEYBITS, 256, FALSE);
4487                          break;                          break;
# Line 4283  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4491  static BOOL CALLBACK TTXKeyGenerator(HWN
4491                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
4492                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
4493                          }                          }
4494                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4495                          key_type = KEY_ECDSA384;                          key_type = KEY_ECDSA384;
4496                          SetDlgItemInt(dlg, IDC_KEYBITS, 384, FALSE);                          SetDlgItemInt(dlg, IDC_KEYBITS, 384, FALSE);
4497                          break;                          break;
# Line 4292  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4501  static BOOL CALLBACK TTXKeyGenerator(HWN
4501                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);                                  EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
4502                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);                                  saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
4503                          }                          }
4504                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), TRUE);
4505                          key_type = KEY_ECDSA521;                          key_type = KEY_ECDSA521;
4506                          SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);                          SetDlgItemInt(dlg, IDC_KEYBITS, 521, FALSE);
4507                          break;                          break;
4508    
4509                    case IDC_ED25519_TYPE | (BN_CLICKED << 16):
4510                            /* ED25519 ではビット数を指定できない。*/
4511                            if (!isFixedLengthKey(key_type)) {
4512                                    EnableWindow(GetDlgItem(dlg, IDC_KEYBITS), FALSE);
4513                                    saved_key_bits = GetDlgItemInt(dlg, IDC_KEYBITS, NULL, FALSE);
4514                            }
4515                            EnableWindow(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), FALSE);
4516                            key_type = KEY_ED25519;
4517                            SetDlgItemInt(dlg, IDC_KEYBITS, 0, FALSE);
4518                            break;
4519    
4520                  // saving public key file                  // saving public key file
4521                  case IDC_SAVE_PUBLIC_KEY:                  case IDC_SAVE_PUBLIC_KEY:
4522                          {                          {
# Line 4342  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4563  static BOOL CALLBACK TTXKeyGenerator(HWN
4563                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
4564                                  strncpy_s(filename, sizeof(filename), "id_ecdsa.pub", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_ecdsa.pub", _TRUNCATE);
4565                                  break;                                  break;
4566                            case KEY_ED25519:
4567                                    UTIL_get_lang_msg("FILEDLG_SAVE_PUBLICKEY_ED25519_FILTER", pvar,
4568                                                      "SSH2 ED25519 key(id_ed25519.pub)\\0id_ed25519.pub\\0All Files(*.*)\\0*.*\\0\\0");
4569                                    memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
4570                                    ofn.lpstrFilter = uimsg;
4571                                    strncpy_s(filename, sizeof(filename), "id_ed25519.pub", _TRUNCATE);
4572                                    break;
4573                            default:
4574                                    break;
4575                          }                          }
4576                          ofn.lpstrFile = filename;                          ofn.lpstrFile = filename;
4577                          ofn.nMaxFile = sizeof(filename);                          ofn.nMaxFile = sizeof(filename);
# Line 4424  static BOOL CALLBACK TTXKeyGenerator(HWN Line 4654  static BOOL CALLBACK TTXKeyGenerator(HWN
4654                                          buffer_put_ecpoint(b, EC_KEY_get0_group(ecdsa),                                          buffer_put_ecpoint(b, EC_KEY_get0_group(ecdsa),
4655                                                                EC_KEY_get0_public_key(ecdsa));                                                                EC_KEY_get0_public_key(ecdsa));
4656                                          break;                                          break;
4657    
4658                                    case KEY_ED25519:
4659                                            keyname = get_ssh_keytype_name(public_key.type);
4660                                            buffer_put_cstring(b, keyname);
4661                                            buffer_put_string(b, public_key.ed25519_pk, ED25519_PK_SZ);
4662                                            break;
4663                                  }                                  }
4664    
4665                                  blob = buffer_ptr(b);                                  blob = buffer_ptr(b);
# Line 4524  public_error: Line 4760  public_error:
4760                                  ofn.lpstrFilter = uimsg;                                  ofn.lpstrFilter = uimsg;
4761                                  strncpy_s(filename, sizeof(filename), "id_ecdsa", _TRUNCATE);                                  strncpy_s(filename, sizeof(filename), "id_ecdsa", _TRUNCATE);
4762                                  break;                                  break;
4763                            case KEY_ED25519:
4764                                    UTIL_get_lang_msg("FILEDLG_SAVE_PRIVATEKEY_ED25519_FILTER", pvar,
4765                                                      "SSH2 ED25519 key(id_ed25519)\\0id_ed25519\\0All Files(*.*)\\0*.*\\0\\0");
4766                                    memcpy(uimsg, pvar->ts->UIMsg, sizeof(uimsg));
4767                                    ofn.lpstrFilter = uimsg;
4768                                    strncpy_s(filename, sizeof(filename), "id_ed25519", _TRUNCATE);
4769                                    break;
4770                            default:
4771                                    break;
4772                          }                          }
4773                          ofn.lpstrFile = filename;                          ofn.lpstrFile = filename;
4774                          ofn.nMaxFile = sizeof(filename);                          ofn.nMaxFile = sizeof(filename);
# Line 4653  error:; Line 4898  error:;
4898                                  buffer_free(b);                                  buffer_free(b);
4899                                  buffer_free(enc);                                  buffer_free(enc);
4900    
4901                          } else { // SSH2 RSA, DSA, ECDSA                          } else if (private_key.type == KEY_ED25519) { // SSH2 ED25519
4902                                    save_bcrypt_private_key(buf, filename, comment, dlg, pvar);
4903    
4904                            } else { // SSH2 RSA, DSA, ECDSA                        
4905                                  int len;                                  int len;
4906                                  FILE *fp;                                  FILE *fp;
4907                                  const EVP_CIPHER *cipher;                                  const EVP_CIPHER *cipher;
4908    
4909                                    if (SendMessage(GetDlgItem(dlg, IDC_BCRYPT_KDF_CHECK), BM_GETCHECK, 0, 0) == BST_CHECKED) {
4910                                            save_bcrypt_private_key(buf, filename, comment, dlg, pvar);
4911                                            break;
4912                                    }
4913    
4914                                  len = strlen(buf);                                  len = strlen(buf);
4915                                  // TODO: range check (len >= 4)                                  // TODO: range check (len >= 4)
4916    
Legend:
Removed from v.5430  
changed lines
  Added in v.5545
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help