Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

Contents of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/auth.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3073 - (show annotations) (download) (as text)
Tue Dec 11 19:33:02 2007 UTC (16 years, 4 months ago) by maya
Original Path: ttssh2/trunk/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 46969 byte(s) 
デフォルトユーザ名を指定しておらず、認証方式を challenge にしており、/ask4passwd を指定している場合、SSH2_MSG_SERVICE_REQUESTを2回送信してしまう問題を修正した。
認証方式を challenge にしており、CheckAuthListFirst が off で、/ask4passwd を指定している場合、TIS 認証ダイアログが自動的に出現しない問題を修正した。
CheckAuthListFirst が on で、ユーザ名を送信できる状態になる前にユーザ名を入力してフォーカスを外した場合、OKボタンを押したあとに認証が行われない問題を修正した。
1 /*
2 Copyright (c) 1998-2001, Robert O'Callahan
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without modification,
6 are permitted provided that the following conditions are met:
7
8 Redistributions of source code must retain the above copyright notice, this list of
9 conditions and the following disclaimer.
10
11 Redistributions in binary form must reproduce the above copyright notice, this list
12 of conditions and the following disclaimer in the documentation and/or other materials
13 provided with the distribution.
14
15 The name of Robert O'Callahan may not be used to endorse or promote products derived from
16 this software without specific prior written permission.
17
18 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
19 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21 THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "ttxssh.h"
30 #include "util.h"
31 #include "ssh.h"
32
33 #include <io.h>
34 #include <fcntl.h>
35 #include <stdlib.h>
36 #include <errno.h>
37
38 #include "resource.h"
39 #include "keyfiles.h"
40
41 #define AUTH_START_USER_AUTH_ON_ERROR_END 1
42
43 #define MAX_AUTH_CONTROL IDC_SSHUSETIS
44
45 static HFONT DlgAuthFont;
46 static HFONT DlgTisFont;
47 static HFONT DlgAuthSetupFont;
48
49 void destroy_malloced_string(char FAR * FAR * str)
50 {
51 if (*str != NULL) {
52 memset(*str, 0, strlen(*str));
53 free(*str);
54 *str = NULL;
55 }
56 }
57
58 static int auth_types_to_control_IDs[] = {
59 -1, IDC_SSHUSERHOSTS, IDC_SSHUSERSA, IDC_SSHUSEPASSWORD,
60 IDC_SSHUSERHOSTS, IDC_SSHUSETIS, -1
61 };
62
63 static LRESULT CALLBACK password_wnd_proc(HWND control, UINT msg,
64 WPARAM wParam, LPARAM lParam)
65 {
66 switch (msg) {
67 case WM_CHAR:
68 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) {
69 char chars[] = { (char) wParam, 0 };
70
71 SendMessage(control, EM_REPLACESEL, (WPARAM) TRUE,
72 (LPARAM) (char FAR *) chars);
73 return 0;
74 }
75 }
76
77 return CallWindowProc((WNDPROC) GetWindowLong(control, GWL_USERDATA),
78 control, msg, wParam, lParam);
79 }
80
81 static void init_password_control(HWND dlg)
82 {
83 HWND passwordControl = GetDlgItem(dlg, IDC_SSHPASSWORD);
84
85 SetWindowLong(passwordControl, GWL_USERDATA,
86 SetWindowLong(passwordControl, GWL_WNDPROC,
87 (LONG) password_wnd_proc));
88
89 SetFocus(passwordControl);
90 }
91
92 static void set_auth_options_status(HWND dlg, int controlID)
93 {
94 BOOL RSA_enabled = controlID == IDC_SSHUSERSA;
95 BOOL rhosts_enabled = controlID == IDC_SSHUSERHOSTS;
96 BOOL TIS_enabled = controlID == IDC_SSHUSETIS;
97 int i;
98
99 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, controlID);
100
101 EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), !TIS_enabled);
102 EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), !TIS_enabled);
103
104 for (i = IDC_CHOOSERSAFILE; i <= IDC_RSAFILENAME; i++) {
105 EnableWindow(GetDlgItem(dlg, i), RSA_enabled);
106 }
107
108 for (i = IDC_LOCALUSERNAMELABEL; i <= IDC_HOSTRSAFILENAME; i++) {
109 EnableWindow(GetDlgItem(dlg, i), rhosts_enabled);
110 }
111 }
112
113 static void init_auth_machine_banner(PTInstVar pvar, HWND dlg)
114 {
115 char buf[1024], buf2[1024];
116
117 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf2, sizeof(buf2));
118 _snprintf_s(buf, sizeof(buf), _TRUNCATE, buf2, SSH_get_host_name(pvar));
119 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf);
120 }
121
122 static void update_server_supported_types(PTInstVar pvar, HWND dlg)
123 {
124 int supported_methods = pvar->auth_state.supported_types;
125 int cur_control = -1;
126 int control;
127 HWND focus = GetFocus();
128
129 if (supported_methods == 0) {
130 return;
131 }
132
133 for (control = IDC_SSHUSEPASSWORD; control <= MAX_AUTH_CONTROL;
134 control++) {
135 BOOL enabled = FALSE;
136 int method;
137 HWND item = GetDlgItem(dlg, control);
138
139 if (item != NULL) {
140 for (method = 0; method <= SSH_AUTH_MAX; method++) {
141 if (auth_types_to_control_IDs[method] == control
142 && (supported_methods & (1 << method)) != 0) {
143 enabled = TRUE;
144 }
145 }
146
147 EnableWindow(item, enabled);
148
149 if (IsDlgButtonChecked(dlg, control)) {
150 cur_control = control;
151 }
152 }
153 }
154
155 if (cur_control >= 0) {
156 if (!IsWindowEnabled(GetDlgItem(dlg, cur_control))) {
157 do {
158 cur_control++;
159 if (cur_control > MAX_AUTH_CONTROL) {
160 cur_control = IDC_SSHUSEPASSWORD;
161 }
162 } while (!IsWindowEnabled(GetDlgItem(dlg, cur_control)));
163
164 set_auth_options_status(dlg, cur_control);
165
166 if (focus != NULL && !IsWindowEnabled(focus)) {
167 SetFocus(GetDlgItem(dlg, cur_control));
168 }
169 }
170 }
171 }
172
173 static void init_auth_dlg(PTInstVar pvar, HWND dlg)
174 {
175 int default_method = pvar->session_settings.DefaultAuthMethod;
176 char uimsg[MAX_UIMSG];
177
178 GetWindowText(dlg, uimsg, sizeof(uimsg));
179 UTIL_get_lang_msg("DLG_AUTH_TITLE", pvar, uimsg);
180 SetWindowText(dlg, pvar->ts->UIMsg);
181 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
182 UTIL_get_lang_msg("DLG_AUTH_BANNER", pvar, uimsg);
183 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
184 GetDlgItemText(dlg, IDC_SSHAUTHBANNER2, uimsg, sizeof(uimsg));
185 UTIL_get_lang_msg("DLG_AUTH_BANNER2", pvar, uimsg);
186 SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg);
187 GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
188 UTIL_get_lang_msg("DLG_AUTH_USERNAME", pvar, uimsg);
189 SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
190 GetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, uimsg, sizeof(uimsg));
191 UTIL_get_lang_msg("DLG_AUTH_PASSWORD", pvar, uimsg);
192 SetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, pvar->ts->UIMsg);
193 GetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, uimsg, sizeof(uimsg));
194 UTIL_get_lang_msg("DLG_AUTH_REMEMBER_PASSWORD", pvar, uimsg);
195 SetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, pvar->ts->UIMsg);
196 GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
197 UTIL_get_lang_msg("DLG_AUTH_METHOD_PASSWORD", pvar, uimsg);
198 SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
199 GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
200 UTIL_get_lang_msg("DLG_AUTH_METHOD_RSA", pvar, uimsg);
201 SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
202 GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
203 UTIL_get_lang_msg("DLG_AUTH_METHOD_RHOST", pvar, uimsg);
204 SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
205 GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
206 UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
207 SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
208 GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
209 UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
210 SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
211 GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
212 UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
213 SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
214 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
215 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
216 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
217 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
218 UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
219 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
220
221 init_auth_machine_banner(pvar, dlg);
222 init_password_control(dlg);
223
224 if (pvar->auth_state.failed_method != SSH_AUTH_NONE) {
225 /* must be retrying a failed attempt */
226 UTIL_get_lang_msg("DLG_AUTH_BANNER2_FAILED", pvar, "Authentication failed. Please retry.");
227 SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg);
228 UTIL_get_lang_msg("DLG_AUTH_TITLE_FAILED", pvar, "Retrying SSH Authentication");
229 SetWindowText(dlg, pvar->ts->UIMsg);
230 default_method = pvar->auth_state.failed_method;
231 }
232
233 set_auth_options_status(dlg,
234 auth_types_to_control_IDs[default_method]);
235
236 if (default_method == SSH_AUTH_TIS) {
237 /* we disabled the password control, so fix the focus */
238 SetFocus(GetDlgItem(dlg, IDC_SSHUSETIS));
239 }
240
241 if (pvar->auth_state.user != NULL) {
242 SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->auth_state.user);
243 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
244 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
245 } else if (pvar->session_settings.DefaultUserName[0] != 0) {
246 SetDlgItemText(dlg, IDC_SSHUSERNAME,
247 pvar->session_settings.DefaultUserName);
248 }
249
250 SetDlgItemText(dlg, IDC_RSAFILENAME,
251 pvar->session_settings.DefaultRSAPrivateKeyFile);
252 SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
253 pvar->session_settings.DefaultRhostsHostPrivateKeyFile);
254 SetDlgItemText(dlg, IDC_LOCALUSERNAME,
255 pvar->session_settings.DefaultRhostsLocalUserName);
256
257 update_server_supported_types(pvar, dlg);
258
259 // SSH2 autologin
260 // ���[�U�A�p�X���[�h�A�F�����\�b�h���������������A������������OK�{�^�������������B
261 //
262 // (2004.12.1 yutaka)
263 // (2005.1.26 yutaka) ���J���F���T�|�[�g
264 // �������O�C���������������A�������������������X���\ (2006.9.18 maya)
265 #if 0
266 if (pvar->ssh2_autologin == 1) {
267 #endif
268 if (strlen(pvar->ssh2_username) > 0) {
269 SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->ssh2_username);
270 }
271 if (pvar->ssh2_autologin == 1) {
272 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
273 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
274 }
275
276 SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
277 if (pvar->ssh2_autologin == 1) {
278 EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
279 EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), FALSE);
280 }
281
282 // '/I' �w�������������������������� (2005.9.5 yutaka)
283 if (pvar->ts->Minimize) {
284 //20050822���� start T.Takahashi
285 ShowWindow(dlg,SW_MINIMIZE);
286 //20050822���� end T.Takahashi
287 }
288
289 if (pvar->ssh2_authmethod == SSH_AUTH_PASSWORD) {
290 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSEPASSWORD);
291
292 } else if (pvar->ssh2_authmethod == SSH_AUTH_RSA) {
293 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSERSA);
294
295 SetDlgItemText(dlg, IDC_RSAFILENAME, pvar->ssh2_keyfile);
296 if (pvar->ssh2_autologin == 1) {
297 EnableWindow(GetDlgItem(dlg, IDC_CHOOSERSAFILE), FALSE);
298 EnableWindow(GetDlgItem(dlg, IDC_RSAFILENAME), FALSE);
299 }
300
301 // /auth=challenge ������ (2007.10.5 maya)
302 } else if (pvar->ssh2_authmethod == SSH_AUTH_TIS) {
303 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSETIS);
304 EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
305 SetDlgItemText(dlg, IDC_SSHPASSWORD, "");
306
307 } else {
308 // TODO
309
310 }
311
312 GetDlgItemText(dlg, IDC_SSHUSERNAME, uimsg, sizeof(uimsg));
313 if (uimsg[0] == 0) {
314 SetFocus(GetDlgItem(dlg, IDC_SSHUSERNAME));
315 }
316 else if (pvar->ask4passwd == 1) {
317 SetFocus(GetDlgItem(dlg, IDC_SSHPASSWORD));
318 }
319 #if 0
320 }
321 #endif
322
323 #if 1
324 if (pvar->settings.ssh_protocol_version == 1) {
325 UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE1", pvar,
326 "Use challenge/response to log in(&TIS)");
327 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
328 } else {
329 UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE2", pvar,
330 "Use &challenge/response to log in(keyboard-interactive)");
331 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
332 }
333 #endif
334
335 // �p�X���[�h���o���������`�F�b�N�{�b�N�X�����f�t�H���g���L�������� (2006.8.3 yutaka)
336 if (pvar->ts_SSH->remember_password) {
337 SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_CHECKED, 0);
338 } else {
339 SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_UNCHECKED, 0);
340 }
341
342 }
343
344 static char FAR *alloc_control_text(HWND ctl)
345 {
346 int len = GetWindowTextLength(ctl);
347 char FAR *result = malloc(len + 1);
348
349 if (result != NULL) {
350 GetWindowText(ctl, result, len + 1);
351 result[len] = 0;
352 }
353
354 return result;
355 }
356
357 static int get_key_file_name(HWND parent, char FAR * buf, int bufsize, PTInstVar pvar)
358 {
359 OPENFILENAME params;
360 char fullname_buf[2048] = "identity";
361 char filter[MAX_UIMSG];
362
363 ZeroMemory(&params, sizeof(params));
364 params.lStructSize = sizeof(OPENFILENAME);
365 params.hwndOwner = parent;
366 // �t�B���^������ (2004.12.19 yutaka)
367 // 3�t�@�C���t�B���^������ (2005.4.26 yutaka)
368 UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_FILTER", pvar,
369 "identity files\\0identity;id_rsa;id_dsa\\0identity(RSA1)\\0identity\\0id_rsa(SSH2)\\0id_rsa\\0id_dsa(SSH2)\\0id_dsa\\0all(*.*)\\0*.*\\0\\0");
370 memcpy(filter, pvar->ts->UIMsg, sizeof(filter));
371 params.lpstrFilter = filter;
372 params.lpstrCustomFilter = NULL;
373 params.nFilterIndex = 0;
374 buf[0] = 0;
375 params.lpstrFile = fullname_buf;
376 params.nMaxFile = sizeof(fullname_buf);
377 params.lpstrFileTitle = NULL;
378 params.lpstrInitialDir = NULL;
379 UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_TITLE", pvar,
380 "Choose a file with the RSA/DSA private key");
381 params.lpstrTitle = pvar->ts->UIMsg;
382 params.Flags =
383 OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
384 params.lpstrDefExt = NULL;
385
386 if (GetOpenFileName(&params) != 0) {
387 copy_teraterm_dir_relative_path(buf, bufsize, fullname_buf);
388 return 1;
389 } else {
390 return 0;
391 }
392 }
393
394 static void choose_RSA_key_file(HWND dlg, PTInstVar pvar)
395 {
396 char buf[1024];
397
398 if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
399 SetDlgItemText(dlg, IDC_RSAFILENAME, buf);
400 }
401 }
402
403 static void choose_host_RSA_key_file(HWND dlg, PTInstVar pvar)
404 {
405 char buf[1024];
406
407 if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
408 SetDlgItemText(dlg, IDC_HOSTRSAFILENAME, buf);
409 }
410 }
411
412 static BOOL end_auth_dlg(PTInstVar pvar, HWND dlg)
413 {
414 int method = SSH_AUTH_PASSWORD;
415 char FAR *password =
416 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
417 CRYPTKeyPair FAR *key_pair = NULL;
418
419 if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
420 method = SSH_AUTH_RSA;
421 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
422 if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
423 method = SSH_AUTH_RHOSTS_RSA;
424 } else {
425 method = SSH_AUTH_RHOSTS;
426 }
427 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
428 method = SSH_AUTH_TIS;
429 }
430
431 if (method == SSH_AUTH_RSA || method == SSH_AUTH_RHOSTS_RSA) {
432 char buf[2048];
433 int file_ctl_ID =
434 method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
435
436 buf[0] = 0;
437 GetDlgItemText(dlg, file_ctl_ID, buf, sizeof(buf));
438 if (buf[0] == 0) {
439 UTIL_get_lang_msg("MSG_KEYSPECIFY_ERROR", pvar,
440 "You must specify a file containing the RSA/DSA private key.");
441 notify_nonfatal_error(pvar, pvar->ts->UIMsg);
442 SetFocus(GetDlgItem(dlg, file_ctl_ID));
443 destroy_malloced_string(&password);
444 return FALSE;
445 }
446
447 if (SSHv1(pvar)) {
448 BOOL invalid_passphrase = FALSE;
449
450 key_pair = KEYFILES_read_private_key(pvar, buf, password,
451 &invalid_passphrase,
452 FALSE);
453
454 if (key_pair == NULL) {
455 if (invalid_passphrase) {
456 HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
457
458 SetFocus(passwordCtl);
459 SendMessage(passwordCtl, EM_SETSEL, 0, -1);
460 } else {
461 SetFocus(GetDlgItem(dlg, file_ctl_ID));
462 }
463 destroy_malloced_string(&password);
464 return FALSE;
465 }
466
467 } else { // SSH2(yutaka)
468 BOOL invalid_passphrase = FALSE;
469 char errmsg[256];
470
471 memset(errmsg, 0, sizeof(errmsg));
472 //GetCurrentDirectory(sizeof(errmsg), errmsg);
473
474 key_pair = read_SSH2_private_key(pvar, buf, password,
475 &invalid_passphrase,
476 FALSE,
477 errmsg,
478 sizeof(errmsg)
479 );
480
481 if (key_pair == NULL) { // read error
482 char buf[1024];
483 UTIL_get_lang_msg("MSG_READKEY_ERROR", pvar,
484 "read error SSH2 private key file\r\n%s");
485 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, errmsg);
486 notify_nonfatal_error(pvar, buf);
487 // �p�X�t���[�Y���������v����������������IDC_SSHPASSWORD���t�H�[�J�X������ (2006.10.29 yasuhide)
488 if (invalid_passphrase) {
489 HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
490
491 SetFocus(passwordCtl);
492 SendMessage(passwordCtl, EM_SETSEL, 0, -1);
493 } else {
494 SetFocus(GetDlgItem(dlg, file_ctl_ID));
495 }
496 destroy_malloced_string(&password);
497 return FALSE;
498 }
499
500 }
501
502 }
503
504 /* from here on, we cannot fail, so just munge cur_cred in place */
505 pvar->auth_state.cur_cred.method = method;
506 pvar->auth_state.cur_cred.key_pair = key_pair;
507 /* we can't change the user name once it's set. It may already have
508 been sent to the server, and it can only be sent once. */
509 if (pvar->auth_state.user == NULL) {
510 pvar->auth_state.user =
511 alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
512 }
513
514 // �p�X���[�h���������������������������� (2006.8.3 yutaka)
515 if (SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_GETCHECK, 0,0) == BST_CHECKED) {
516 pvar->settings.remember_password = 1; // �o��������
517 pvar->ts_SSH->remember_password = 1;
518 } else {
519 pvar->settings.remember_password = 0; // ���������������Y����
520 pvar->ts_SSH->remember_password = 0;
521 }
522
523 // ���J���F���������A�Z�b�V�������������p�X���[�h���g�����������������������������������B
524 // (2005.4.8 yutaka)
525 if (method == SSH_AUTH_PASSWORD || method == SSH_AUTH_RSA) {
526 pvar->auth_state.cur_cred.password = password;
527 } else {
528 destroy_malloced_string(&password);
529 }
530 if (method == SSH_AUTH_RHOSTS || method == SSH_AUTH_RHOSTS_RSA) {
531 if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
532 UTIL_get_lang_msg("MSG_RHOSTS_NOTDEFAULT_ERROR", pvar,
533 "Rhosts authentication will probably fail because it was not "
534 "the default authentication method.\n"
535 "To use Rhosts authentication "
536 "in TTSSH, you need to set it to be the default by restarting\n"
537 "TTSSH and selecting \"SSH Authentication...\" from the Setup menu"
538 "before connecting.");
539 notify_nonfatal_error(pvar, pvar->ts->UIMsg);
540 }
541
542 pvar->auth_state.cur_cred.rhosts_client_user =
543 alloc_control_text(GetDlgItem(dlg, IDC_LOCALUSERNAME));
544 }
545 pvar->auth_state.auth_dialog = NULL;
546
547 GetDlgItemText(dlg, IDC_RSAFILENAME,
548 pvar->session_settings.DefaultRSAPrivateKeyFile,
549 sizeof(pvar->session_settings.
550 DefaultRSAPrivateKeyFile));
551 GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
552 pvar->session_settings.DefaultRhostsHostPrivateKeyFile,
553 sizeof(pvar->session_settings.
554 DefaultRhostsHostPrivateKeyFile));
555 GetDlgItemText(dlg, IDC_LOCALUSERNAME,
556 pvar->session_settings.DefaultRhostsLocalUserName,
557 sizeof(pvar->session_settings.
558 DefaultRhostsLocalUserName));
559
560 if (SSHv1(pvar)) {
561 SSH_notify_user_name(pvar);
562 SSH_notify_cred(pvar);
563 } else {
564 // for SSH2(yutaka)
565 do_SSH2_userauth(pvar);
566 }
567
568 EndDialog(dlg, 1);
569 if (DlgAuthFont != NULL) {
570 DeleteObject(DlgAuthFont);
571 }
572
573 return TRUE;
574 }
575
576 static BOOL CALLBACK auth_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
577 LPARAM lParam)
578 {
579 const int IDC_TIMER1 = 300;
580 const int IDC_TIMER2 = 301;
581 const int IDC_TIMER3 = 302;
582 const int autologin_timeout = 10; // �~���b
583 PTInstVar pvar;
584 LOGFONT logfont;
585 HFONT font;
586
587 switch (msg) {
588 case WM_INITDIALOG:
589 pvar = (PTInstVar) lParam;
590 pvar->auth_state.auth_dialog = dlg;
591 SetWindowLong(dlg, DWL_USER, lParam);
592
593 init_auth_dlg(pvar, dlg);
594
595 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
596 GetObject(font, sizeof(LOGFONT), &logfont);
597 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthFont, pvar)) {
598 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
599 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
600 SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
601 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
602 SendDlgItemMessage(dlg, IDC_SSHPASSWORDCAPTION, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
603 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
604 SendDlgItemMessage(dlg, IDC_REMEMBER_PASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
605 SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
606 SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
607 SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
608 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
609 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
610 SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
611 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
612 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
613 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
614 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
615 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
616 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
617 }
618 else {
619 DlgAuthFont = NULL;
620 }
621
622 // SSH2 autologin���L�����������A�^�C�}���d�|�����B (2004.12.1 yutaka)
623 if (pvar->ssh2_autologin == 1) {
624 SetTimer(dlg, IDC_TIMER1, autologin_timeout, 0);
625 }
626 else {
627 // �T�|�[�g�������������\�b�h���`�F�b�N�����B(2007.9.24 maya)
628 // �������L�����A�����������s�����������A���[�U�����m����������
629 if (pvar->session_settings.CheckAuthListFirst &&
630 !pvar->tryed_ssh2_authlist &&
631 GetWindowTextLength(GetDlgItem(dlg, IDC_SSHUSERNAME)) > 0) {
632 SetTimer(dlg, IDC_TIMER2, autologin_timeout, 0);
633 }
634 // /auth=challenge ���w���������������[�U�����m������������
635 // �������������������v�����������AOK �{�^����������
636 // TIS auth �_�C�A���O���o��
637 else {
638 SetTimer(dlg, IDC_TIMER3, autologin_timeout, 0);
639 }
640 }
641 return FALSE; /* because we set the focus */
642
643 case WM_TIMER:
644 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
645 // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2004.12.16 yutaka)
646 if (wParam == IDC_TIMER1) {
647 // �������O�C��������
648 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
649 (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
650 KillTimer(dlg, IDC_TIMER1);
651 SendMessage(dlg, WM_COMMAND, IDOK, 0);
652 }
653 }
654 else if (wParam == IDC_TIMER2) {
655 // authlist ����������
656 if (SSHv2(pvar)) {
657 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
658 (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
659 KillTimer(dlg, IDC_TIMER2);
660
661 // �_�C�A���O�����[�U������������
662 if (pvar->auth_state.user == NULL) {
663 pvar->auth_state.user =
664 alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
665 }
666
667 // ���[�U�������X��������
668 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
669
670 // none ������
671 do_SSH2_userauth(pvar);
672
673 // TIS �p�� OK �������^�C�}�[���d�|��������
674 // �F�������s������������������
675 // Unexpected SSH2 message �������B
676 }
677 }
678 else if (SSHv1(pvar)) {
679 KillTimer(dlg, IDC_TIMER2);
680 // TIS �p�� OK �������^�C�}�[���d�|����
681 if (pvar->ssh2_authmethod == SSH_AUTH_TIS) {
682 SendMessage(dlg, WM_COMMAND, IDOK, 0);
683 }
684 // SSH1 ���� none ����������
685 }
686 // �v���g�R���o�[�W�����m���O������������
687 }
688 else if (wParam == IDC_TIMER3) {
689 if (SSHv2(pvar) || SSHv1(pvar)) {
690 // TIS �p�� OK �������^�C�}�[���d�|����
691 if (pvar->ssh2_authmethod == SSH_AUTH_TIS) {
692 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
693 (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
694 KillTimer(dlg, IDC_TIMER3);
695 SendMessage(dlg, WM_COMMAND, IDOK, 0);
696 }
697 }
698 }
699 // �v���g�R���o�[�W�����m���O������������
700 }
701 return FALSE;
702
703 case WM_COMMAND:
704 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
705
706 switch (LOWORD(wParam)) {
707 case IDOK:
708 // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2001.1.25 yutaka)
709 if (pvar->userauth_retry_count == 0 &&
710 ((pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) ||
711 !(pvar->ssh_state.status_flags & STATUS_HOST_OK))) {
712 return FALSE;
713 }
714
715 return end_auth_dlg(pvar, dlg);
716
717 case IDCANCEL: /* kill the connection */
718 pvar->auth_state.auth_dialog = NULL;
719 notify_closed_connection(pvar);
720 EndDialog(dlg, 0);
721
722 if (DlgAuthFont != NULL) {
723 DeleteObject(DlgAuthFont);
724 }
725
726 return TRUE;
727
728 case IDC_SSHUSERNAME:
729 // ���[�U�����t�H�[�J�X������������ (2007.9.29 maya)
730 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
731 (pvar->ssh_state.status_flags & STATUS_HOST_OK) &&
732 HIWORD(wParam) == EN_KILLFOCUS) {
733 // �������L���������������s��������������
734 if (SSHv2(pvar) &&
735 pvar->session_settings.CheckAuthListFirst &&
736 !pvar->tryed_ssh2_authlist) {
737 // �_�C�A���O�����[�U�������f
738 if (pvar->auth_state.user == NULL) {
739 pvar->auth_state.user =
740 alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
741 }
742
743 // ���[�U���������������������`�F�b�N����
744 if (strlen(pvar->auth_state.user) == 0) {
745 return FALSE;
746 }
747
748 // ���[�U�������X��������
749 EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
750
751 // none ������
752 do_SSH2_userauth(pvar);
753 return TRUE;
754 }
755 }
756
757 return FALSE;
758
759 case IDC_SSHUSEPASSWORD:
760 case IDC_SSHUSERSA:
761 case IDC_SSHUSERHOSTS:
762 case IDC_SSHUSETIS:
763 set_auth_options_status(dlg, LOWORD(wParam));
764 return TRUE;
765
766 case IDC_CHOOSERSAFILE:
767 choose_RSA_key_file(dlg, pvar);
768 return TRUE;
769
770 case IDC_CHOOSEHOSTRSAFILE:
771 choose_host_RSA_key_file(dlg, pvar);
772 return TRUE;
773
774 default:
775 return FALSE;
776 }
777
778 default:
779 return FALSE;
780 }
781 }
782
783 char FAR *AUTH_get_user_name(PTInstVar pvar)
784 {
785 return pvar->auth_state.user;
786 }
787
788 int AUTH_set_supported_auth_types(PTInstVar pvar, int types)
789 {
790 char buf[1024];
791
792 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
793 "Server reports supported authentication method mask = %d",
794 types);
795 buf[sizeof(buf) - 1] = 0;
796 notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
797
798 if (SSHv1(pvar)) {
799 types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
800 | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
801 | (1 << SSH_AUTH_TIS);
802 } else {
803 // for SSH2(yutaka)
804 // types &= (1 << SSH_AUTH_PASSWORD);
805 // ���J���F�����L�������� (2004.12.18 yutaka)
806 // TIS�������BSSH2����keyboard-interactive�����������B(2005.3.12 yutaka)
807 types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
808 | (1 << SSH_AUTH_TIS);
809 }
810 pvar->auth_state.supported_types = types;
811
812 if (types == 0) {
813 UTIL_get_lang_msg("MSG_NOAUTHMETHOD_ERROR", pvar,
814 "Server does not support any of the authentication options\n"
815 "provided by TTSSH. This connection will now close.");
816 notify_fatal_error(pvar, pvar->ts->UIMsg);
817 return 0;
818 } else {
819 if (pvar->auth_state.auth_dialog != NULL) {
820 update_server_supported_types(pvar,
821 pvar->auth_state.auth_dialog);
822 }
823
824 return 1;
825 }
826 }
827
828 static void start_user_auth(PTInstVar pvar)
829 {
830 // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
831 PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
832 (LPARAM) NULL);
833 pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
834 }
835
836 static void try_default_auth(PTInstVar pvar)
837 {
838 if (pvar->session_settings.TryDefaultAuth) {
839 switch (pvar->session_settings.DefaultAuthMethod) {
840 case SSH_AUTH_RSA:{
841 BOOL invalid_passphrase;
842 char password[] = "";
843
844 pvar->auth_state.cur_cred.key_pair
845 =
846 KEYFILES_read_private_key(pvar,
847 pvar->session_settings.
848 DefaultRSAPrivateKeyFile,
849 password,
850 &invalid_passphrase, TRUE);
851 if (pvar->auth_state.cur_cred.key_pair == NULL) {
852 return;
853 } else {
854 pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
855 }
856 break;
857 }
858
859 case SSH_AUTH_RHOSTS:
860 if (pvar->session_settings.
861 DefaultRhostsHostPrivateKeyFile[0] != 0) {
862 BOOL invalid_passphrase;
863 char password[] = "";
864
865 pvar->auth_state.cur_cred.key_pair
866 =
867 KEYFILES_read_private_key(pvar,
868 pvar->session_settings.
869 DefaultRhostsHostPrivateKeyFile,
870 password,
871 &invalid_passphrase, TRUE);
872 if (pvar->auth_state.cur_cred.key_pair == NULL) {
873 return;
874 } else {
875 pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
876 }
877 } else {
878 pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
879 }
880
881 pvar->auth_state.cur_cred.rhosts_client_user =
882 _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
883 break;
884
885 case SSH_AUTH_PASSWORD:
886 pvar->auth_state.cur_cred.password = _strdup("");
887 pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
888 break;
889
890 case SSH_AUTH_TIS:
891 default:
892 return;
893 }
894
895 pvar->auth_state.user =
896 _strdup(pvar->session_settings.DefaultUserName);
897 }
898 }
899
900 void AUTH_notify_end_error(PTInstVar pvar)
901 {
902 if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
903 start_user_auth(pvar);
904 pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
905 }
906 }
907
908 void AUTH_advance_to_next_cred(PTInstVar pvar)
909 {
910 pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
911
912 if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
913 try_default_auth(pvar);
914
915 if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
916 if (pvar->err_msg != NULL) {
917 pvar->auth_state.flags |=
918 AUTH_START_USER_AUTH_ON_ERROR_END;
919 } else {
920 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
921 // �R�}���h���C���w������������
922 start_user_auth(pvar);
923 }
924 }
925 } else {
926 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
927 // �R�}���h���C���w������(/auth=xxxx)������
928 start_user_auth(pvar);
929 }
930 }
931
932 static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
933 {
934 char uimsg[MAX_UIMSG];
935
936 GetWindowText(dlg, uimsg, sizeof(uimsg));
937 UTIL_get_lang_msg("DLG_TIS_TITLE", pvar, uimsg);
938 SetWindowText(dlg, pvar->ts->UIMsg);
939 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
940 UTIL_get_lang_msg("DLG_TIS_BANNER", pvar, uimsg);
941 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
942 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
943 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
944 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
945 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
946 UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
947 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
948
949 init_auth_machine_banner(pvar, dlg);
950 init_password_control(dlg);
951
952 if (pvar->auth_state.TIS_prompt != NULL) {
953 if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
954 pvar->auth_state.TIS_prompt[10000] = 0;
955 }
956 SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
957 pvar->auth_state.TIS_prompt);
958 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
959 }
960 }
961
962 static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
963 {
964 char FAR *password =
965 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
966
967 pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
968 pvar->auth_state.cur_cred.password = password;
969 pvar->auth_state.auth_dialog = NULL;
970
971 // add
972 if (SSHv2(pvar)) {
973 pvar->keyboard_interactive_password_input = 1;
974 handle_SSH2_userauth_inforeq(pvar);
975 }
976
977 SSH_notify_cred(pvar);
978
979 EndDialog(dlg, 1);
980 return TRUE;
981 }
982
983 static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
984 LPARAM lParam)
985 {
986 PTInstVar pvar;
987 LOGFONT logfont;
988 HFONT font;
989
990 switch (msg) {
991 case WM_INITDIALOG:
992 pvar = (PTInstVar) lParam;
993 pvar->auth_state.auth_dialog = dlg;
994 SetWindowLong(dlg, DWL_USER, lParam);
995
996 init_TIS_dlg(pvar, dlg);
997
998 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
999 GetObject(font, sizeof(LOGFONT), &logfont);
1000 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1001 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1002 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1003 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1004 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1005 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1006 }
1007 else {
1008 DlgTisFont = NULL;
1009 }
1010
1011 // /auth=challenge ������ (2007.10.5 maya)
1012 if (pvar->ssh2_autologin == 1) {
1013 SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
1014 SendMessage(dlg, WM_COMMAND, IDOK, 0);
1015 }
1016
1017 return FALSE; /* because we set the focus */
1018
1019 case WM_COMMAND:
1020 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1021
1022 switch (LOWORD(wParam)) {
1023 case IDOK:
1024 if (DlgTisFont != NULL) {
1025 DeleteObject(DlgTisFont);
1026 }
1027
1028 return end_TIS_dlg(pvar, dlg);
1029
1030 case IDCANCEL: /* kill the connection */
1031 pvar->auth_state.auth_dialog = NULL;
1032 notify_closed_connection(pvar);
1033 EndDialog(dlg, 0);
1034
1035 if (DlgTisFont != NULL) {
1036 DeleteObject(DlgTisFont);
1037 }
1038
1039 return TRUE;
1040
1041 default:
1042 return FALSE;
1043 }
1044
1045 default:
1046 return FALSE;
1047 }
1048 }
1049
1050 void AUTH_do_cred_dialog(PTInstVar pvar)
1051 {
1052 if (pvar->auth_state.auth_dialog == NULL) {
1053 HWND cur_active = GetActiveWindow();
1054 DLGPROC dlg_proc;
1055 LPCTSTR dialog_template;
1056
1057 switch (pvar->auth_state.mode) {
1058 case TIS_AUTH_MODE:
1059 dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1060 dlg_proc = TIS_dlg_proc;
1061 break;
1062 case GENERIC_AUTH_MODE:
1063 default:
1064 dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1065 dlg_proc = auth_dlg_proc;
1066 }
1067
1068 if (!DialogBoxParam(hInst, dialog_template,
1069 cur_active !=
1070 NULL ? cur_active : pvar->NotificationWindow,
1071 dlg_proc, (LPARAM) pvar) == -1) {
1072 UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar,
1073 "Unable to display authentication dialog box.\n"
1074 "Connection terminated.");
1075 notify_fatal_error(pvar, pvar->ts->UIMsg);
1076 }
1077 }
1078 }
1079
1080 static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1081 {
1082 char uimsg[MAX_UIMSG];
1083
1084 GetWindowText(dlg, uimsg, sizeof(uimsg));
1085 UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar, uimsg);
1086 SetWindowText(dlg, pvar->ts->UIMsg);
1087 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1088 UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar, uimsg);
1089 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1090 GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
1091 UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar, uimsg);
1092 SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1093 GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
1094 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar, uimsg);
1095 SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1096 GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
1097 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar, uimsg);
1098 SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1099 GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
1100 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar, uimsg);
1101 SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1102 GetDlgItemText(dlg, IDC_SSHUSETIS, uimsg, sizeof(uimsg));
1103 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar, uimsg);
1104 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1105 GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
1106 UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
1107 SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1108 GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
1109 UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
1110 SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1111 GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
1112 UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
1113 SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1114 GetDlgItemText(dlg, IDC_CHECKAUTH, uimsg, sizeof(uimsg));
1115 UTIL_get_lang_msg("DLG_AUTHSETUP_CHECKAUTH", pvar, uimsg);
1116 SetDlgItemText(dlg, IDC_CHECKAUTH, pvar->ts->UIMsg);
1117 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1118 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1119 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1120 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1121 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1122 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1123
1124 switch (pvar->settings.DefaultAuthMethod) {
1125 case SSH_AUTH_RSA:
1126 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1127 IDC_SSHUSERSA);
1128 break;
1129 case SSH_AUTH_RHOSTS:
1130 case SSH_AUTH_RHOSTS_RSA:
1131 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1132 IDC_SSHUSERHOSTS);
1133 break;
1134 case SSH_AUTH_TIS:
1135 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1136 IDC_SSHUSETIS);
1137 break;
1138 case SSH_AUTH_PASSWORD:
1139 default:
1140 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1141 IDC_SSHUSEPASSWORD);
1142 }
1143
1144 SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1145 SetDlgItemText(dlg, IDC_RSAFILENAME,
1146 pvar->settings.DefaultRSAPrivateKeyFile);
1147 SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1148 pvar->settings.DefaultRhostsHostPrivateKeyFile);
1149 SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1150 pvar->settings.DefaultRhostsLocalUserName);
1151
1152 if (pvar->settings.CheckAuthListFirst) {
1153 CheckDlgButton(dlg, IDC_CHECKAUTH, TRUE);
1154 }
1155 }
1156
1157 static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1158 {
1159 if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1160 pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1161 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1162 if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1163 pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1164 } else {
1165 pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1166 }
1167 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1168 pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1169 } else {
1170 pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1171 }
1172
1173 GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1174 sizeof(pvar->settings.DefaultUserName));
1175 GetDlgItemText(dlg, IDC_RSAFILENAME,
1176 pvar->settings.DefaultRSAPrivateKeyFile,
1177 sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1178 GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1179 pvar->settings.DefaultRhostsHostPrivateKeyFile,
1180 sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1181 GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1182 pvar->settings.DefaultRhostsLocalUserName,
1183 sizeof(pvar->settings.DefaultRhostsLocalUserName));
1184
1185 if (IsDlgButtonChecked(dlg, IDC_CHECKAUTH)) {
1186 pvar->settings.CheckAuthListFirst = TRUE;
1187 }
1188 else {
1189 pvar->settings.CheckAuthListFirst = FALSE;
1190 }
1191
1192 EndDialog(dlg, 1);
1193 return TRUE;
1194 }
1195
1196 static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1197 WPARAM wParam, LPARAM lParam)
1198 {
1199 PTInstVar pvar;
1200 LOGFONT logfont;
1201 HFONT font;
1202
1203 switch (msg) {
1204 case WM_INITDIALOG:
1205 pvar = (PTInstVar) lParam;
1206 SetWindowLong(dlg, DWL_USER, lParam);
1207
1208 init_default_auth_dlg(pvar, dlg);
1209
1210 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1211 GetObject(font, sizeof(LOGFONT), &logfont);
1212 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1213 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1214 SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1215 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1216 SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1217 SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1218 SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1219 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1220 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1221 SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1222 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1223 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1224 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1225 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1226 SendDlgItemMessage(dlg, IDC_CHECKAUTH, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1227 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1228 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1229 }
1230 else {
1231 DlgAuthSetupFont = NULL;
1232 }
1233
1234 return TRUE; /* because we do not set the focus */
1235
1236 case WM_COMMAND:
1237 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1238
1239 switch (LOWORD(wParam)) {
1240 case IDOK:
1241
1242 if (DlgAuthSetupFont != NULL) {
1243 DeleteObject(DlgAuthSetupFont);
1244 }
1245
1246 return end_default_auth_dlg(pvar, dlg);
1247
1248 case IDCANCEL:
1249 EndDialog(dlg, 0);
1250
1251 if (DlgAuthSetupFont != NULL) {
1252 DeleteObject(DlgAuthSetupFont);
1253 }
1254
1255 return TRUE;
1256
1257 case IDC_CHOOSERSAFILE:
1258 choose_RSA_key_file(dlg, pvar);
1259 return TRUE;
1260
1261 case IDC_CHOOSEHOSTRSAFILE:
1262 choose_host_RSA_key_file(dlg, pvar);
1263 return TRUE;
1264
1265 default:
1266 return FALSE;
1267 }
1268
1269 default:
1270 return FALSE;
1271 }
1272 }
1273
1274 void AUTH_init(PTInstVar pvar)
1275 {
1276 pvar->auth_state.failed_method = SSH_AUTH_NONE;
1277 pvar->auth_state.auth_dialog = NULL;
1278 pvar->auth_state.user = NULL;
1279 pvar->auth_state.flags = 0;
1280 pvar->auth_state.TIS_prompt = NULL;
1281 pvar->auth_state.supported_types = 0;
1282 pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1283 pvar->auth_state.cur_cred.password = NULL;
1284 pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1285 pvar->auth_state.cur_cred.key_pair = NULL;
1286 AUTH_set_generic_mode(pvar);
1287 }
1288
1289 void AUTH_set_generic_mode(PTInstVar pvar)
1290 {
1291 pvar->auth_state.mode = GENERIC_AUTH_MODE;
1292 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1293 }
1294
1295 void AUTH_set_TIS_mode(PTInstVar pvar, char FAR * prompt, int len)
1296 {
1297 if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1298 pvar->auth_state.mode = TIS_AUTH_MODE;
1299
1300 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1301 pvar->auth_state.TIS_prompt = malloc(len + 1);
1302 memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1303 pvar->auth_state.TIS_prompt[len] = 0;
1304 } else {
1305 AUTH_set_generic_mode(pvar);
1306 }
1307 }
1308
1309 void AUTH_do_default_cred_dialog(PTInstVar pvar)
1310 {
1311 HWND cur_active = GetActiveWindow();
1312
1313 if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1314 cur_active != NULL ? cur_active
1315 : pvar->NotificationWindow,
1316 default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1317 UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar,
1318 "Unable to display authentication setup dialog box.");
1319 notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1320 }
1321 }
1322
1323 void AUTH_destroy_cur_cred(PTInstVar pvar)
1324 {
1325 destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1326 destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1327 if (pvar->auth_state.cur_cred.key_pair != NULL) {
1328 CRYPT_free_key_pair(pvar->auth_state.cur_cred.key_pair);
1329 pvar->auth_state.cur_cred.key_pair = NULL;
1330 }
1331 }
1332
1333 static char FAR *get_auth_method_name(SSHAuthMethod auth)
1334 {
1335 switch (auth) {
1336 case SSH_AUTH_PASSWORD:
1337 return "password";
1338 case SSH_AUTH_RSA:
1339 return "RSA";
1340 case SSH_AUTH_RHOSTS:
1341 return "rhosts";
1342 case SSH_AUTH_RHOSTS_RSA:
1343 return "rhosts with RSA";
1344 case SSH_AUTH_TIS:
1345 return "challenge/response (TIS)";
1346 default:
1347 return "unknown method";
1348 }
1349 }
1350
1351 void AUTH_get_auth_info(PTInstVar pvar, char FAR * dest, int len)
1352 {
1353 char *method = "unknown";
1354
1355 if (pvar->auth_state.user == NULL) {
1356 strncpy_s(dest, len, "None", _TRUNCATE);
1357 } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1358 if (SSHv1(pvar)) {
1359 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1360 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1361 get_auth_method_name(pvar->auth_state.cur_cred.method));
1362
1363 } else {
1364 // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1365 // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1366 if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1367 pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1368 // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1369 if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1370 method = "keyboard-interactive";
1371 } else {
1372 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1373 }
1374 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1375 _snprintf_s(dest, len, _TRUNCATE,
1376 pvar->ts->UIMsg, pvar->auth_state.user, method);
1377
1378 } else {
1379 if (pvar->auth_state.cur_cred.key_pair->RSA_key != NULL) {
1380 method = "RSA";
1381 } else if (pvar->auth_state.cur_cred.key_pair->DSA_key != NULL) {
1382 method = "DSA";
1383 }
1384 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1385 _snprintf_s(dest, len, _TRUNCATE,
1386 pvar->ts->UIMsg, pvar->auth_state.user, method);
1387 }
1388
1389 }
1390
1391 } else {
1392 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1393 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1394 get_auth_method_name(pvar->auth_state.failed_method));
1395 }
1396
1397 dest[len - 1] = 0;
1398 }
1399
1400 void AUTH_notify_disconnecting(PTInstVar pvar)
1401 {
1402 if (pvar->auth_state.auth_dialog != NULL) {
1403 PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1404 /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1405 EnableWindow(pvar->NotificationWindow, TRUE);
1406 }
1407 }
1408
1409 void AUTH_end(PTInstVar pvar)
1410 {
1411 destroy_malloced_string(&pvar->auth_state.user);
1412 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1413
1414 AUTH_destroy_cur_cred(pvar);
1415 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help