Open-Source-Software-Entwicklung und Downloads

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/ttssh2/ttxssh/auth.c

Annotation of /trunk/ttssh2/ttxssh/auth.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2980 - (hide annotations) (download) (as text)
Wed Jun 6 14:10:12 2007 UTC (17 years ago) by maya
Original Path: ttssh2/trunk/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 51371 byte(s) 
プリプロセッサにより構造体が変わってしまうので、INET6 と I18N の #define を逆転させた。
1 yutakakn 2728 /*
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 yutakakn 2800 #include "ssh.h"
32 yutakakn 2728
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 maya 2980 #ifndef NO_I18N
46 maya 2943 static HFONT DlgAuthFont;
47     static HFONT DlgTisFont;
48     static HFONT DlgAuthSetupFont;
49     #endif
50    
51 yutakakn 2890 void destroy_malloced_string(char FAR * FAR * str)
52 yutakakn 2728 {
53     if (*str != NULL) {
54     memset(*str, 0, strlen(*str));
55     free(*str);
56     *str = NULL;
57     }
58     }
59    
60     static int auth_types_to_control_IDs[] = {
61     -1, IDC_SSHUSERHOSTS, IDC_SSHUSERSA, IDC_SSHUSEPASSWORD,
62     IDC_SSHUSERHOSTS, IDC_SSHUSETIS, -1
63     };
64    
65     static LRESULT CALLBACK password_wnd_proc(HWND control, UINT msg,
66     WPARAM wParam, LPARAM lParam)
67     {
68     switch (msg) {
69     case WM_CHAR:
70     if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) {
71     char chars[] = { (char) wParam, 0 };
72    
73     SendMessage(control, EM_REPLACESEL, (WPARAM) TRUE,
74     (LPARAM) (char FAR *) chars);
75     return 0;
76     }
77     }
78    
79     return CallWindowProc((WNDPROC) GetWindowLong(control, GWL_USERDATA),
80     control, msg, wParam, lParam);
81     }
82    
83     static void init_password_control(HWND dlg)
84     {
85     HWND passwordControl = GetDlgItem(dlg, IDC_SSHPASSWORD);
86    
87     SetWindowLong(passwordControl, GWL_USERDATA,
88     SetWindowLong(passwordControl, GWL_WNDPROC,
89     (LONG) password_wnd_proc));
90    
91     SetFocus(passwordControl);
92     }
93    
94     static void set_auth_options_status(HWND dlg, int controlID)
95     {
96     BOOL RSA_enabled = controlID == IDC_SSHUSERSA;
97     BOOL rhosts_enabled = controlID == IDC_SSHUSERHOSTS;
98     BOOL TIS_enabled = controlID == IDC_SSHUSETIS;
99     int i;
100    
101     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, controlID);
102    
103     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), !TIS_enabled);
104     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), !TIS_enabled);
105    
106     for (i = IDC_CHOOSERSAFILE; i <= IDC_RSAFILENAME; i++) {
107     EnableWindow(GetDlgItem(dlg, i), RSA_enabled);
108     }
109    
110     for (i = IDC_LOCALUSERNAMELABEL; i <= IDC_HOSTRSAFILENAME; i++) {
111     EnableWindow(GetDlgItem(dlg, i), rhosts_enabled);
112     }
113     }
114    
115     static void init_auth_machine_banner(PTInstVar pvar, HWND dlg)
116     {
117     char buf[1024] = "Logging in to ";
118 maya 2980 #ifndef NO_I18N
119 maya 2937 char buf2[1024];
120     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf2, sizeof(buf2));
121     _snprintf(buf, sizeof(buf), buf2, SSH_get_host_name(pvar));
122     #else
123 yutakakn 2728 if (strlen(buf) + strlen(SSH_get_host_name(pvar)) < sizeof(buf) - 2) {
124     strcat(buf, SSH_get_host_name(pvar));
125     }
126 maya 2937 #endif
127 yutakakn 2728 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf);
128     }
129    
130     static void update_server_supported_types(PTInstVar pvar, HWND dlg)
131     {
132     int supported_methods = pvar->auth_state.supported_types;
133     int cur_control = -1;
134     int control;
135     HWND focus = GetFocus();
136    
137     if (supported_methods == 0) {
138     return;
139     }
140    
141     for (control = IDC_SSHUSEPASSWORD; control <= MAX_AUTH_CONTROL;
142     control++) {
143     BOOL enabled = FALSE;
144     int method;
145     HWND item = GetDlgItem(dlg, control);
146    
147     if (item != NULL) {
148     for (method = 0; method <= SSH_AUTH_MAX; method++) {
149     if (auth_types_to_control_IDs[method] == control
150     && (supported_methods & (1 << method)) != 0) {
151     enabled = TRUE;
152     }
153     }
154    
155     EnableWindow(item, enabled);
156    
157     if (IsDlgButtonChecked(dlg, control)) {
158     cur_control = control;
159     }
160     }
161     }
162    
163     if (cur_control >= 0) {
164     if (!IsWindowEnabled(GetDlgItem(dlg, cur_control))) {
165     do {
166     cur_control++;
167     if (cur_control > MAX_AUTH_CONTROL) {
168     cur_control = IDC_SSHUSEPASSWORD;
169     }
170     } while (!IsWindowEnabled(GetDlgItem(dlg, cur_control)));
171    
172     set_auth_options_status(dlg, cur_control);
173    
174     if (focus != NULL && !IsWindowEnabled(focus)) {
175     SetFocus(GetDlgItem(dlg, cur_control));
176     }
177     }
178     }
179     }
180    
181     static void init_auth_dlg(PTInstVar pvar, HWND dlg)
182     {
183     int default_method = pvar->session_settings.DefaultAuthMethod;
184    
185 maya 2980 #ifndef NO_I18N
186 maya 2937 GetWindowText(dlg, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
187     UTIL_get_lang_msg("DLG_AUTH_TITLE", pvar);
188     SetWindowText(dlg, pvar->ts->UIMsg);
189    
190     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
191     UTIL_get_lang_msg("DLG_AUTH_BANNER", pvar);
192     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
193    
194     GetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
195     UTIL_get_lang_msg("DLG_AUTH_BANNER2", pvar);
196     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg);
197    
198     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
199     UTIL_get_lang_msg("DLG_AUTH_USERNAME", pvar);
200     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
201    
202     GetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
203     UTIL_get_lang_msg("DLG_AUTH_PASSWORD", pvar);
204     SetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, pvar->ts->UIMsg);
205    
206     GetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
207     UTIL_get_lang_msg("DLG_AUTH_REMEMBER_PASSWORD", pvar);
208     SetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, pvar->ts->UIMsg);
209    
210     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
211     UTIL_get_lang_msg("DLG_AUTH_METHOD_PASSWORD", pvar);
212     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
213    
214     GetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
215     UTIL_get_lang_msg("DLG_AUTH_METHOD_RSA", pvar);
216     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
217    
218     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
219     UTIL_get_lang_msg("DLG_AUTH_METHOD_RHOST", pvar);
220     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
221    
222     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
223     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar);
224     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
225    
226     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
227     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar);
228     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
229    
230     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
231     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar);
232     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
233    
234     GetDlgItemText(dlg, IDOK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
235     UTIL_get_lang_msg("BTN_OK", pvar);
236     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
237    
238     GetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
239     UTIL_get_lang_msg("BTN_DISCONNECT", pvar);
240     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
241     #endif
242    
243 yutakakn 2728 init_auth_machine_banner(pvar, dlg);
244     init_password_control(dlg);
245    
246     if (pvar->auth_state.failed_method != SSH_AUTH_NONE) {
247     /* must be retrying a failed attempt */
248 maya 2980 #ifndef NO_I18N
249 maya 2937 strcpy(pvar->ts->UIMsg, "Authentication failed. Please retry.");
250     UTIL_get_lang_msg("DLG_AUTH_BANNER2_FAILED", pvar);
251     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, "Retrying SSH Authentication");
252    
253     strcpy(pvar->ts->UIMsg, "Retrying SSH Authentication");
254     UTIL_get_lang_msg("DLG_AUTH_TITLE_FAILED", pvar);
255     SetWindowText(dlg, pvar->ts->UIMsg);
256     #else
257 yutakakn 2728 SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
258     "Authentication failed. Please retry.");
259     SetWindowText(dlg, "Retrying SSH Authentication");
260 maya 2937 #endif
261 yutakakn 2728 default_method = pvar->auth_state.failed_method;
262     }
263    
264     set_auth_options_status(dlg,
265     auth_types_to_control_IDs[default_method]);
266    
267     if (default_method == SSH_AUTH_TIS) {
268     /* we disabled the password control, so fix the focus */
269     SetFocus(GetDlgItem(dlg, IDC_SSHUSETIS));
270     }
271    
272     if (pvar->auth_state.user != NULL) {
273     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->auth_state.user);
274     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
275     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
276     } else if (pvar->session_settings.DefaultUserName[0] != 0) {
277     SetDlgItemText(dlg, IDC_SSHUSERNAME,
278     pvar->session_settings.DefaultUserName);
279     } else {
280     SetFocus(GetDlgItem(dlg, IDC_SSHUSERNAME));
281     }
282    
283     SetDlgItemText(dlg, IDC_RSAFILENAME,
284     pvar->session_settings.DefaultRSAPrivateKeyFile);
285     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
286     pvar->session_settings.DefaultRhostsHostPrivateKeyFile);
287     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
288     pvar->session_settings.DefaultRhostsLocalUserName);
289    
290     update_server_supported_types(pvar, dlg);
291 yutakakn 2739
292 yutakakn 2784 // SSH2 autologin
293 yutakakn 2739 // ���[�U�A�p�X���[�h�A�F�����\�b�h���������������A������������OK�{�^�������������B
294 yutakakn 2784 //
295     // (2004.12.1 yutaka)
296     // (2005.1.26 yutaka) ���J���F���T�|�[�g
297 maya 2908 // �������O�C���������������A�������������������X���\ (2006.9.18 maya)
298     #if 0
299 yutakakn 2739 if (pvar->ssh2_autologin == 1) {
300 maya 2908 #endif
301     if (strlen(pvar->ssh2_username) > 0) {
302     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->ssh2_username);
303     }
304     if (pvar->ssh2_autologin == 1) {
305     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
306     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
307     }
308 yutakakn 2739
309     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
310 maya 2908 if (pvar->ssh2_autologin == 1) {
311     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
312     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), FALSE);
313     }
314 yutakakn 2739
315 yutakakn 2844 // '/I' �w�������������������������� (2005.9.5 yutaka)
316     if (pvar->ts->Minimize) {
317     //20050822���� start T.Takahashi
318     ShowWindow(dlg,SW_MINIMIZE);
319     //20050822���� end T.Takahashi
320     }
321    
322 yutakakn 2784 if (pvar->ssh2_authmethod == SSH_AUTH_PASSWORD) {
323 yutakakn 2739 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSEPASSWORD);
324 yutakakn 2784
325     } else if (pvar->ssh2_authmethod == SSH_AUTH_RSA) {
326     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSERSA);
327    
328     SetDlgItemText(dlg, IDC_RSAFILENAME, pvar->ssh2_keyfile);
329 maya 2908 if (pvar->ssh2_autologin == 1) {
330     EnableWindow(GetDlgItem(dlg, IDC_CHOOSERSAFILE), FALSE);
331     EnableWindow(GetDlgItem(dlg, IDC_RSAFILENAME), FALSE);
332     }
333 yutakakn 2784
334 yutakakn 2739 } else {
335     // TODO
336    
337     }
338 yasuhide 2963
339     if (pvar->ask4passwd == 1) {
340     SetFocus(GetDlgItem(dlg, IDC_SSHPASSWORD));
341     }
342 maya 2908 #if 0
343 yutakakn 2739 }
344 maya 2908 #endif
345 yutakakn 2739
346 yutakakn 2800 #if 1
347 yutakakn 2799 // �p�X���[�h�F���������O���Akeyboard-interactive���\�b�h�������������A���x������
348     // ���X�����B(2005.3.12 yutaka)
349     if (pvar->settings.ssh2_keyboard_interactive == 1) {
350 maya 2980 #ifndef NO_I18N
351 doda 2968 strcpy(pvar->ts->UIMsg, "Use p&lain password to log in (with keyboard-interactive)");
352     UTIL_get_lang_msg("DLG_AUTH_METHOD_PASSWORD_KBDINT", pvar);
353 maya 2937 SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
354     #else
355 yutakakn 2799 SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, "Use p&lain password to log in (with keyboard-interactive)");
356 maya 2937 #endif
357 yutakakn 2799 }
358    
359 yutakakn 2800 if (pvar->settings.ssh_protocol_version == 1) {
360 maya 2980 #ifndef NO_I18N
361 maya 2937 strcpy(pvar->ts->UIMsg, "Use challenge/response to log in(&TIS)");
362     UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE1", pvar);
363     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
364     #else
365 yutakakn 2800 SetDlgItemText(dlg, IDC_SSHUSETIS, "Use challenge/response to log in(&TIS)");
366 maya 2937 #endif
367 yutakakn 2800 } else {
368 maya 2980 #ifndef NO_I18N
369 maya 2952 strcpy(pvar->ts->UIMsg, "Use &challenge/response to log in(keyboard-interactive)");
370 maya 2937 UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE2", pvar);
371     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
372     #else
373 yutakakn 2804 SetDlgItemText(dlg, IDC_SSHUSETIS, "Use challenge/response to log in(&keyboard-interactive)");
374 maya 2937 #endif
375 yutakakn 2800 }
376     #endif
377    
378 yutakakn 2890 // �p�X���[�h���o���������`�F�b�N�{�b�N�X�����f�t�H���g���L�������� (2006.8.3 yutaka)
379 yutakakn 2891 if (pvar->ts_SSH->remember_password) {
380 yutakakn 2890 SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_CHECKED, 0);
381     } else {
382     SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_UNCHECKED, 0);
383     }
384    
385 yutakakn 2728 }
386    
387     static char FAR *alloc_control_text(HWND ctl)
388     {
389     int len = GetWindowTextLength(ctl);
390     char FAR *result = malloc(len + 1);
391    
392     if (result != NULL) {
393     GetWindowText(ctl, result, len + 1);
394     result[len] = 0;
395     }
396    
397     return result;
398     }
399    
400 maya 2980 #ifndef NO_I18N
401 maya 2937 static int get_key_file_name(HWND parent, char FAR * buf, int bufsize, PTInstVar pvar)
402 maya 2939 #else
403     static int get_key_file_name(HWND parent, char FAR * buf, int bufsize)
404     #endif
405 yutakakn 2728 {
406     #ifdef TERATERM32
407     OPENFILENAME params;
408     char fullname_buf[2048] = "identity";
409 maya 2980 #ifndef NO_I18N
410 maya 2937 char filter[MAX_UIMSG];
411     #endif
412 yutakakn 2728
413 yutakakn 2762 ZeroMemory(&params, sizeof(params));
414 yutakakn 2728 params.lStructSize = sizeof(OPENFILENAME);
415     params.hwndOwner = parent;
416 yutakakn 2762 // �t�B���^������ (2004.12.19 yutaka)
417 yutakakn 2818 // 3�t�@�C���t�B���^������ (2005.4.26 yutaka)
418 maya 2980 #ifndef NO_I18N
419 maya 2956 strncpy(pvar->ts->UIMsg, "identity files\\0identity;id_rsa;id_dsa\\0identity(RSA1)\\0identity\\0id_rsa(SSH2)\\0id_rsa\\0id_dsa(SSH2)\\0id_dsa\\0all(*.*)\\0*.*\\0\\0", sizeof(pvar->ts->UIMsg));
420 maya 2937 UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_FILTER", pvar);
421     memcpy(filter, pvar->ts->UIMsg, sizeof(filter));
422     params.lpstrFilter = filter;
423     #else
424 yutakakn 2818 params.lpstrFilter = "identity files\0identity;id_rsa;id_dsa\0identity(RSA1)\0identity\0id_rsa(SSH2)\0id_rsa\0id_dsa(SSH2)\0id_dsa\0all(*.*)\0*.*\0\0";
425 maya 2937 #endif
426 yutakakn 2728 params.lpstrCustomFilter = NULL;
427     params.nFilterIndex = 0;
428     buf[0] = 0;
429     params.lpstrFile = fullname_buf;
430     params.nMaxFile = sizeof(fullname_buf);
431     params.lpstrFileTitle = NULL;
432     params.lpstrInitialDir = NULL;
433 maya 2980 #ifndef NO_I18N
434 maya 2937 strcpy(pvar->ts->UIMsg, "Choose a file with the RSA/DSA private key");
435     UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_TITLE", pvar);
436     params.lpstrTitle = pvar->ts->UIMsg;
437     #else
438 yutakakn 2818 params.lpstrTitle = "Choose a file with the RSA/DSA private key";
439 maya 2937 #endif
440 yutakakn 2728 params.Flags =
441     OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
442     params.lpstrDefExt = NULL;
443    
444     if (GetOpenFileName(&params) != 0) {
445     copy_teraterm_dir_relative_path(buf, bufsize, fullname_buf);
446     return 1;
447     } else {
448     return 0;
449     }
450     #else
451     return 0;
452     #endif
453     }
454    
455 maya 2980 #ifndef NO_I18N
456 maya 2937 static void choose_RSA_key_file(HWND dlg, PTInstVar pvar)
457 maya 2939 #else
458     static void choose_RSA_key_file(HWND dlg)
459     #endif
460 yutakakn 2728 {
461     char buf[1024];
462    
463 maya 2980 #ifndef NO_I18N
464 maya 2937 if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
465 maya 2939 #else
466     if (get_key_file_name(dlg, buf, sizeof(buf))) {
467     #endif
468 yutakakn 2728 SetDlgItemText(dlg, IDC_RSAFILENAME, buf);
469     }
470     }
471    
472 maya 2980 #ifndef NO_I18N
473 maya 2937 static void choose_host_RSA_key_file(HWND dlg, PTInstVar pvar)
474 maya 2939 #else
475     static void choose_host_RSA_key_file(HWND dlg)
476     #endif
477 yutakakn 2728 {
478     char buf[1024];
479    
480 maya 2980 #ifndef NO_I18N
481 maya 2937 if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
482 maya 2939 #else
483     if (get_key_file_name(dlg, buf, sizeof(buf))) {
484     #endif
485 yutakakn 2728 SetDlgItemText(dlg, IDC_HOSTRSAFILENAME, buf);
486     }
487     }
488    
489     static BOOL end_auth_dlg(PTInstVar pvar, HWND dlg)
490     {
491     int method = SSH_AUTH_PASSWORD;
492     char FAR *password =
493     alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
494     CRYPTKeyPair FAR *key_pair = NULL;
495    
496     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
497     method = SSH_AUTH_RSA;
498     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
499     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
500     method = SSH_AUTH_RHOSTS_RSA;
501     } else {
502     method = SSH_AUTH_RHOSTS;
503     }
504     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
505     method = SSH_AUTH_TIS;
506     }
507    
508     if (method == SSH_AUTH_RSA || method == SSH_AUTH_RHOSTS_RSA) {
509     char buf[2048];
510     int file_ctl_ID =
511     method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
512    
513     buf[0] = 0;
514     GetDlgItemText(dlg, file_ctl_ID, buf, sizeof(buf));
515     if (buf[0] == 0) {
516 maya 2980 #ifndef NO_I18N
517 maya 2937 strcpy(pvar->ts->UIMsg, "You must specify a file containing the RSA/DSA private key.");
518     UTIL_get_lang_msg("MSG_KEYSPECIFY_ERROR", pvar);
519     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
520     #else
521 yutakakn 2728 notify_nonfatal_error(pvar,
522 yutakakn 2762 "You must specify a file containing the RSA/DSA private key.");
523 maya 2937 #endif
524 yutakakn 2728 SetFocus(GetDlgItem(dlg, file_ctl_ID));
525     destroy_malloced_string(&password);
526     return FALSE;
527 yutakakn 2762 }
528    
529     if (SSHv1(pvar)) {
530 yutakakn 2728 BOOL invalid_passphrase = FALSE;
531    
532     key_pair = KEYFILES_read_private_key(pvar, buf, password,
533     &invalid_passphrase,
534     FALSE);
535    
536     if (key_pair == NULL) {
537     if (invalid_passphrase) {
538     HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
539    
540     SetFocus(passwordCtl);
541     SendMessage(passwordCtl, EM_SETSEL, 0, -1);
542     } else {
543     SetFocus(GetDlgItem(dlg, file_ctl_ID));
544     }
545     destroy_malloced_string(&password);
546     return FALSE;
547     }
548 yutakakn 2762
549     } else { // SSH2(yutaka)
550     BOOL invalid_passphrase = FALSE;
551 yutakakn 2769 char errmsg[256];
552 yutakakn 2762
553 yutakakn 2769 memset(errmsg, 0, sizeof(errmsg));
554 yutakakn 2784 //GetCurrentDirectory(sizeof(errmsg), errmsg);
555 yutakakn 2769
556 yutakakn 2762 key_pair = read_SSH2_private_key(pvar, buf, password,
557     &invalid_passphrase,
558 yutakakn 2769 FALSE,
559     errmsg,
560     sizeof(errmsg)
561     );
562 yutakakn 2762
563     if (key_pair == NULL) { // read error
564 yutakakn 2769 char buf[1024];
565 maya 2980 #ifndef NO_I18N
566 maya 2937 strcpy(pvar->ts->UIMsg, "read error SSH2 private key file\r\n%s");
567     UTIL_get_lang_msg("MSG_READKEY_ERROR", pvar);
568     _snprintf(buf, sizeof(buf), pvar->ts->UIMsg, errmsg);
569     #else
570 yutakakn 2769 _snprintf(buf, sizeof(buf), "read error SSH2 private key file\r\n%s", errmsg);
571 maya 2937 #endif
572 yutakakn 2769 notify_nonfatal_error(pvar, buf);
573 yasuhide 2962 // �p�X�t���[�Y���������v����������������IDC_SSHPASSWORD���t�H�[�J�X������ (2006.10.29 yasuhide)
574     if (invalid_passphrase) {
575     HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
576    
577     SetFocus(passwordCtl);
578     SendMessage(passwordCtl, EM_SETSEL, 0, -1);
579     } else {
580     SetFocus(GetDlgItem(dlg, file_ctl_ID));
581     }
582 yutakakn 2762 destroy_malloced_string(&password);
583     return FALSE;
584     }
585    
586 yutakakn 2728 }
587 yutakakn 2762
588 yutakakn 2728 }
589    
590     /* from here on, we cannot fail, so just munge cur_cred in place */
591     pvar->auth_state.cur_cred.method = method;
592     pvar->auth_state.cur_cred.key_pair = key_pair;
593     /* we can't change the user name once it's set. It may already have
594     been sent to the server, and it can only be sent once. */
595     if (pvar->auth_state.user == NULL) {
596     pvar->auth_state.user =
597     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
598     }
599 yutakakn 2811
600 yutakakn 2890 // �p�X���[�h���������������������������� (2006.8.3 yutaka)
601     if (SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_GETCHECK, 0,0) == BST_CHECKED) {
602 yutakakn 2891 pvar->settings.remember_password = 1; // �o��������
603     pvar->ts_SSH->remember_password = 1;
604 yutakakn 2890 } else {
605 yutakakn 2891 pvar->settings.remember_password = 0; // ���������������Y����
606     pvar->ts_SSH->remember_password = 0;
607 yutakakn 2890 }
608    
609 yutakakn 2811 // ���J���F���������A�Z�b�V�������������p�X���[�h���g�����������������������������������B
610     // (2005.4.8 yutaka)
611     if (method == SSH_AUTH_PASSWORD || method == SSH_AUTH_RSA) {
612 yutakakn 2728 pvar->auth_state.cur_cred.password = password;
613     } else {
614     destroy_malloced_string(&password);
615     }
616     if (method == SSH_AUTH_RHOSTS || method == SSH_AUTH_RHOSTS_RSA) {
617     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
618 maya 2980 #ifndef NO_I18N
619 maya 2937 strcpy(pvar->ts->UIMsg, "Rhosts authentication will probably fail because it was not "
620     "the default authentication method.\n"
621     "To use Rhosts authentication "
622     "in TTSSH, you need to set it to be the default by restarting\n"
623     "TTSSH and selecting \"SSH Authentication...\" from the Setup menu"
624     "before connecting.");
625     UTIL_get_lang_msg("MSG_RHOSTS_NOTDEFAULT_ERROR", pvar);
626     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
627     #else
628 yutakakn 2728 notify_nonfatal_error(pvar,
629     "Rhosts authentication will probably fail because it was not "
630     "the default authentication method.\n"
631     "To use Rhosts authentication "
632     "in TTSSH, you need to set it to be the default by restarting\n"
633     "TTSSH and selecting \"SSH Authentication...\" from the Setup menu"
634     "before connecting.");
635 maya 2937 #endif
636 yutakakn 2728 }
637    
638     pvar->auth_state.cur_cred.rhosts_client_user =
639     alloc_control_text(GetDlgItem(dlg, IDC_LOCALUSERNAME));
640     }
641     pvar->auth_state.auth_dialog = NULL;
642    
643     GetDlgItemText(dlg, IDC_RSAFILENAME,
644     pvar->session_settings.DefaultRSAPrivateKeyFile,
645     sizeof(pvar->session_settings.
646     DefaultRSAPrivateKeyFile));
647     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
648     pvar->session_settings.DefaultRhostsHostPrivateKeyFile,
649     sizeof(pvar->session_settings.
650     DefaultRhostsHostPrivateKeyFile));
651     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
652     pvar->session_settings.DefaultRhostsLocalUserName,
653     sizeof(pvar->session_settings.
654     DefaultRhostsLocalUserName));
655    
656     if (SSHv1(pvar)) {
657     SSH_notify_user_name(pvar);
658     SSH_notify_cred(pvar);
659     } else {
660     // for SSH2(yutaka)
661     do_SSH2_userauth(pvar);
662     }
663    
664     EndDialog(dlg, 1);
665 maya 2980 #ifndef NO_I18N
666 maya 2949 if (DlgAuthFont != NULL) {
667     DeleteObject(DlgAuthFont);
668     }
669     #endif
670    
671 yutakakn 2728 return TRUE;
672     }
673    
674     static BOOL CALLBACK auth_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
675     LPARAM lParam)
676     {
677 yutakakn 2739 const int IDC_TIMER1 = 300;
678 yutakakn 2752 const int autologin_timeout = 10; // �~���b
679 yutakakn 2728 PTInstVar pvar;
680 maya 2980 #ifndef NO_I18N
681 maya 2943 LOGFONT logfont;
682     HFONT font;
683     #endif
684 yutakakn 2728
685     switch (msg) {
686     case WM_INITDIALOG:
687     pvar = (PTInstVar) lParam;
688     pvar->auth_state.auth_dialog = dlg;
689     SetWindowLong(dlg, DWL_USER, lParam);
690    
691     init_auth_dlg(pvar, dlg);
692 yutakakn 2739
693 maya 2980 #ifndef NO_I18N
694 maya 2943 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
695     GetObject(font, sizeof(LOGFONT), &logfont);
696 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthFont, pvar)) {
697 maya 2943 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
698     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
699     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
700 maya 2946 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
701 maya 2943 SendDlgItemMessage(dlg, IDC_SSHPASSWORDCAPTION, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
702 maya 2946 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
703 maya 2943 SendDlgItemMessage(dlg, IDC_REMEMBER_PASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
704     SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
705     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
706     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
707 maya 2946 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
708 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
709     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
710 maya 2946 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
711 maya 2943 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
712 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
713 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
714     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
715     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
716     }
717     else {
718     DlgAuthFont = NULL;
719     }
720     #endif
721    
722 yutakakn 2739 // SSH2 autologin���L�����������A�^�C�}���d�|�����B (2004.12.1 yutaka)
723     if (pvar->ssh2_autologin == 1) {
724     SetTimer(dlg, IDC_TIMER1, autologin_timeout, 0);
725     }
726 yutakakn 2728 return FALSE; /* because we set the focus */
727    
728 yutakakn 2739 case WM_TIMER:
729 yutakakn 2752 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
730     // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2004.12.16 yutaka)
731     if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME)) {
732     KillTimer(dlg, IDC_TIMER1);
733     SendMessage(dlg, WM_COMMAND, IDOK, 0);
734     }
735 yutakakn 2739 return TRUE;
736    
737 yutakakn 2728 case WM_COMMAND:
738     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
739    
740     switch (LOWORD(wParam)) {
741     case IDOK:
742 yutakakn 2783 // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2001.1.25 yutaka)
743 yutakakn 2835 if (pvar->userauth_retry_count == 0 && (pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME)) {
744 yutakakn 2783 return FALSE;
745     }
746 maya 2943
747 yutakakn 2728 return end_auth_dlg(pvar, dlg);
748    
749     case IDCANCEL: /* kill the connection */
750     pvar->auth_state.auth_dialog = NULL;
751     notify_closed_connection(pvar);
752     EndDialog(dlg, 0);
753 maya 2943
754 maya 2980 #ifndef NO_I18N
755 maya 2943 if (DlgAuthFont != NULL) {
756     DeleteObject(DlgAuthFont);
757     }
758     #endif
759    
760 yutakakn 2728 return TRUE;
761    
762     case IDC_SSHUSEPASSWORD:
763     case IDC_SSHUSERSA:
764     case IDC_SSHUSERHOSTS:
765     case IDC_SSHUSETIS:
766     set_auth_options_status(dlg, LOWORD(wParam));
767     return TRUE;
768    
769     case IDC_CHOOSERSAFILE:
770 maya 2980 #ifndef NO_I18N
771 maya 2937 choose_RSA_key_file(dlg, pvar);
772 maya 2939 #else
773     choose_RSA_key_file(dlg);
774     #endif
775 yutakakn 2728 return TRUE;
776    
777     case IDC_CHOOSEHOSTRSAFILE:
778 maya 2980 #ifndef NO_I18N
779 maya 2937 choose_host_RSA_key_file(dlg, pvar);
780 maya 2939 #else
781     choose_host_RSA_key_file(dlg);
782     #endif
783 yutakakn 2728 return TRUE;
784    
785     default:
786     return FALSE;
787     }
788    
789     default:
790     return FALSE;
791     }
792     }
793    
794     char FAR *AUTH_get_user_name(PTInstVar pvar)
795     {
796     return pvar->auth_state.user;
797     }
798    
799     int AUTH_set_supported_auth_types(PTInstVar pvar, int types)
800     {
801     char buf[1024];
802    
803     _snprintf(buf, sizeof(buf),
804     "Server reports supported authentication method mask = %d",
805     types);
806     buf[sizeof(buf) - 1] = 0;
807     notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
808    
809     if (SSHv1(pvar)) {
810     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
811     | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
812     | (1 << SSH_AUTH_TIS);
813     } else {
814     // for SSH2(yutaka)
815 yutakakn 2762 // types &= (1 << SSH_AUTH_PASSWORD);
816     // ���J���F�����L�������� (2004.12.18 yutaka)
817 yutakakn 2800 // TIS�������BSSH2����keyboard-interactive�����������B(2005.3.12 yutaka)
818 yutakakn 2762 types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
819 yutakakn 2800 | (1 << SSH_AUTH_DSA)
820     | (1 << SSH_AUTH_TIS);
821 yutakakn 2728 }
822     pvar->auth_state.supported_types = types;
823    
824     if (types == 0) {
825 maya 2980 #ifndef NO_I18N
826 maya 2937 strcpy(pvar->ts->UIMsg,
827     "Server does not support any of the authentication options\n"
828     "provided by TTSSH. This connection will now close.");
829     UTIL_get_lang_msg("MSG_NOAUTHMETHOD_ERROR", pvar);
830     notify_fatal_error(pvar, pvar->ts->UIMsg);
831     #else
832 yutakakn 2728 notify_fatal_error(pvar,
833     "Server does not support any of the authentication options\n"
834     "provided by TTSSH. This connection will now close.");
835 maya 2937 #endif
836 yutakakn 2728 return 0;
837     } else {
838     if (pvar->auth_state.auth_dialog != NULL) {
839     update_server_supported_types(pvar,
840     pvar->auth_state.auth_dialog);
841     }
842    
843     return 1;
844     }
845     }
846    
847     static void start_user_auth(PTInstVar pvar)
848     {
849 yutakakn 2739 // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
850 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
851     (LPARAM) NULL);
852     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
853     }
854    
855     static void try_default_auth(PTInstVar pvar)
856     {
857     if (pvar->session_settings.TryDefaultAuth) {
858     switch (pvar->session_settings.DefaultAuthMethod) {
859     case SSH_AUTH_RSA:{
860     BOOL invalid_passphrase;
861     char password[] = "";
862    
863     pvar->auth_state.cur_cred.key_pair
864     =
865     KEYFILES_read_private_key(pvar,
866     pvar->session_settings.
867     DefaultRSAPrivateKeyFile,
868     password,
869     &invalid_passphrase, TRUE);
870     if (pvar->auth_state.cur_cred.key_pair == NULL) {
871     return;
872     } else {
873     pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
874     }
875     break;
876     }
877    
878     case SSH_AUTH_RHOSTS:
879     if (pvar->session_settings.
880     DefaultRhostsHostPrivateKeyFile[0] != 0) {
881     BOOL invalid_passphrase;
882     char password[] = "";
883    
884     pvar->auth_state.cur_cred.key_pair
885     =
886     KEYFILES_read_private_key(pvar,
887     pvar->session_settings.
888     DefaultRhostsHostPrivateKeyFile,
889     password,
890     &invalid_passphrase, TRUE);
891     if (pvar->auth_state.cur_cred.key_pair == NULL) {
892     return;
893     } else {
894     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
895     }
896     } else {
897     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
898     }
899    
900     pvar->auth_state.cur_cred.rhosts_client_user =
901     _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
902     break;
903    
904     case SSH_AUTH_PASSWORD:
905     pvar->auth_state.cur_cred.password = _strdup("");
906     pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
907     break;
908    
909     case SSH_AUTH_TIS:
910     default:
911     return;
912     }
913    
914     pvar->auth_state.user =
915     _strdup(pvar->session_settings.DefaultUserName);
916     }
917     }
918    
919     void AUTH_notify_end_error(PTInstVar pvar)
920     {
921     if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
922     start_user_auth(pvar);
923     pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
924     }
925     }
926    
927     void AUTH_advance_to_next_cred(PTInstVar pvar)
928     {
929     pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
930    
931     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
932     try_default_auth(pvar);
933    
934     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
935     if (pvar->err_msg != NULL) {
936     pvar->auth_state.flags |=
937     AUTH_START_USER_AUTH_ON_ERROR_END;
938     } else {
939 yutakakn 2739 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
940     // �R�}���h���C���w������������
941 yutakakn 2728 start_user_auth(pvar);
942     }
943     }
944     } else {
945 yutakakn 2739 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
946     // �R�}���h���C���w������(/auth=xxxx)������
947 yutakakn 2728 start_user_auth(pvar);
948     }
949     }
950    
951     static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
952     {
953 maya 2980 #ifndef NO_I18N
954 maya 2937 GetWindowText(dlg, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
955     UTIL_get_lang_msg("DLG_TIS_TITLE", pvar);
956     SetWindowText(dlg, pvar->ts->UIMsg);
957    
958     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
959     UTIL_get_lang_msg("DLG_TIS_BANNER", pvar);
960     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
961 maya 2961
962     GetDlgItemText(dlg, IDOK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
963     UTIL_get_lang_msg("BTN_OK", pvar);
964     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
965    
966     GetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
967     UTIL_get_lang_msg("BTN_DISCONNECT", pvar);
968     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
969 maya 2937 #endif
970    
971 yutakakn 2728 init_auth_machine_banner(pvar, dlg);
972     init_password_control(dlg);
973    
974     if (pvar->auth_state.TIS_prompt != NULL) {
975     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
976     pvar->auth_state.TIS_prompt[10000] = 0;
977     }
978     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
979     pvar->auth_state.TIS_prompt);
980     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
981     }
982     }
983    
984     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
985     {
986     char FAR *password =
987     alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
988    
989     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
990     pvar->auth_state.cur_cred.password = password;
991     pvar->auth_state.auth_dialog = NULL;
992    
993 yutakakn 2800 // add
994     if (SSHv2(pvar)) {
995     pvar->keyboard_interactive_password_input = 1;
996     handle_SSH2_userauth_inforeq(pvar);
997     }
998    
999 yutakakn 2728 SSH_notify_cred(pvar);
1000    
1001     EndDialog(dlg, 1);
1002     return TRUE;
1003     }
1004    
1005     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
1006     LPARAM lParam)
1007     {
1008     PTInstVar pvar;
1009 maya 2980 #ifndef NO_I18N
1010 maya 2943 LOGFONT logfont;
1011     HFONT font;
1012     #endif
1013 yutakakn 2728
1014     switch (msg) {
1015     case WM_INITDIALOG:
1016     pvar = (PTInstVar) lParam;
1017     pvar->auth_state.auth_dialog = dlg;
1018     SetWindowLong(dlg, DWL_USER, lParam);
1019    
1020     init_TIS_dlg(pvar, dlg);
1021 maya 2943
1022 maya 2980 #ifndef NO_I18N
1023 maya 2943 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1024     GetObject(font, sizeof(LOGFONT), &logfont);
1025 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1026 maya 2943 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1027     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1028 maya 2946 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1029 maya 2943 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1030     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1031     }
1032     else {
1033     DlgTisFont = NULL;
1034     }
1035     #endif
1036    
1037 yutakakn 2728 return FALSE; /* because we set the focus */
1038    
1039     case WM_COMMAND:
1040     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1041    
1042     switch (LOWORD(wParam)) {
1043     case IDOK:
1044 maya 2980 #ifndef NO_I18N
1045 maya 2943 if (DlgTisFont != NULL) {
1046     DeleteObject(DlgTisFont);
1047     }
1048     #endif
1049    
1050 yutakakn 2728 return end_TIS_dlg(pvar, dlg);
1051    
1052     case IDCANCEL: /* kill the connection */
1053     pvar->auth_state.auth_dialog = NULL;
1054     notify_closed_connection(pvar);
1055     EndDialog(dlg, 0);
1056 maya 2943
1057 maya 2980 #ifndef NO_I18N
1058 maya 2943 if (DlgTisFont != NULL) {
1059     DeleteObject(DlgTisFont);
1060     }
1061     #endif
1062    
1063 yutakakn 2728 return TRUE;
1064    
1065     default:
1066     return FALSE;
1067     }
1068    
1069     default:
1070     return FALSE;
1071     }
1072     }
1073    
1074     void AUTH_do_cred_dialog(PTInstVar pvar)
1075     {
1076     if (pvar->auth_state.auth_dialog == NULL) {
1077     HWND cur_active = GetActiveWindow();
1078     DLGPROC dlg_proc;
1079     LPCTSTR dialog_template;
1080    
1081     switch (pvar->auth_state.mode) {
1082     case TIS_AUTH_MODE:
1083     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1084     dlg_proc = TIS_dlg_proc;
1085     break;
1086     case GENERIC_AUTH_MODE:
1087     default:
1088     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1089     dlg_proc = auth_dlg_proc;
1090     }
1091    
1092     if (!DialogBoxParam(hInst, dialog_template,
1093     cur_active !=
1094     NULL ? cur_active : pvar->NotificationWindow,
1095     dlg_proc, (LPARAM) pvar) == -1) {
1096 maya 2980 #ifndef NO_I18N
1097 maya 2937 strcpy(pvar->ts->UIMsg,
1098     "Unable to display authentication dialog box.\n"
1099     "Connection terminated.");
1100     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar);
1101     notify_fatal_error(pvar, pvar->ts->UIMsg);
1102     #else
1103 yutakakn 2728 notify_fatal_error(pvar,
1104     "Unable to display authentication dialog box.\n"
1105     "Connection terminated.");
1106 maya 2937 #endif
1107 yutakakn 2728 }
1108     }
1109     }
1110    
1111     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1112     {
1113 maya 2980 #ifndef NO_I18N
1114 maya 2937 GetWindowText(dlg, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1115     UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar);
1116     SetWindowText(dlg, pvar->ts->UIMsg);
1117    
1118     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1119     UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar);
1120     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1121    
1122     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1123     UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar);
1124     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1125    
1126     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1127     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar);
1128     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1129    
1130     GetDlgItemText(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1131     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD_KBDINT", pvar);
1132     SetDlgItemText(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, pvar->ts->UIMsg);
1133    
1134     GetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1135     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar);
1136     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1137    
1138     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1139     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar);
1140     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1141    
1142     GetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1143     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar);
1144     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1145    
1146     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1147     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar);
1148     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1149    
1150     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1151     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar);
1152     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1153    
1154     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1155     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar);
1156     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1157    
1158     GetDlgItemText(dlg, IDOK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1159     UTIL_get_lang_msg("BTN_OK", pvar);
1160     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1161    
1162     GetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1163     UTIL_get_lang_msg("BTN_CANCEL", pvar);
1164     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1165     #endif
1166    
1167 yutakakn 2728 switch (pvar->settings.DefaultAuthMethod) {
1168     case SSH_AUTH_RSA:
1169     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1170     IDC_SSHUSERSA);
1171     break;
1172     case SSH_AUTH_RHOSTS:
1173     case SSH_AUTH_RHOSTS_RSA:
1174     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1175     IDC_SSHUSERHOSTS);
1176     break;
1177     case SSH_AUTH_TIS:
1178     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1179     IDC_SSHUSETIS);
1180     break;
1181     case SSH_AUTH_PASSWORD:
1182     default:
1183     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1184     IDC_SSHUSEPASSWORD);
1185     }
1186    
1187     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1188     SetDlgItemText(dlg, IDC_RSAFILENAME,
1189     pvar->settings.DefaultRSAPrivateKeyFile);
1190     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1191     pvar->settings.DefaultRhostsHostPrivateKeyFile);
1192     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1193     pvar->settings.DefaultRhostsLocalUserName);
1194 yutakakn 2789
1195     // SSH2 keyboard-interactive method (2005.2.22 yutaka)
1196     if (pvar->settings.ssh2_keyboard_interactive) {
1197     SendMessage(GetDlgItem(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK), BM_SETCHECK, BST_CHECKED, 0);
1198     }
1199    
1200 yutakakn 2728 }
1201    
1202     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1203     {
1204     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1205     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1206     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1207     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1208     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1209     } else {
1210     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1211     }
1212     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1213     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1214     } else {
1215     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1216     }
1217    
1218     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1219     sizeof(pvar->settings.DefaultUserName));
1220     GetDlgItemText(dlg, IDC_RSAFILENAME,
1221     pvar->settings.DefaultRSAPrivateKeyFile,
1222     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1223     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1224     pvar->settings.DefaultRhostsHostPrivateKeyFile,
1225     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1226     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1227     pvar->settings.DefaultRhostsLocalUserName,
1228     sizeof(pvar->settings.DefaultRhostsLocalUserName));
1229    
1230 yutakakn 2789 // SSH2 keyboard-interactive method (2005.2.22 yutaka)
1231     {
1232     LRESULT ret;
1233     ret = SendMessage(GetDlgItem(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK), BM_GETCHECK, 0, 0);
1234     if (ret & BST_CHECKED) {
1235     pvar->settings.ssh2_keyboard_interactive = 1;
1236     } else {
1237     pvar->settings.ssh2_keyboard_interactive = 0;
1238     }
1239     }
1240    
1241 yutakakn 2728 EndDialog(dlg, 1);
1242     return TRUE;
1243     }
1244    
1245     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1246     WPARAM wParam, LPARAM lParam)
1247     {
1248     PTInstVar pvar;
1249 maya 2980 #ifndef NO_I18N
1250 maya 2943 LOGFONT logfont;
1251     HFONT font;
1252     #endif
1253 yutakakn 2728
1254     switch (msg) {
1255     case WM_INITDIALOG:
1256     pvar = (PTInstVar) lParam;
1257     SetWindowLong(dlg, DWL_USER, lParam);
1258    
1259     init_default_auth_dlg(pvar, dlg);
1260 maya 2943
1261 maya 2980 #ifndef NO_I18N
1262 maya 2943 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1263     GetObject(font, sizeof(LOGFONT), &logfont);
1264 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1265 maya 2943 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1266     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1267 maya 2946 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1268 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1269     SendDlgItemMessage(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1270     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1271     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1272 maya 2946 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1273 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1274     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1275 maya 2946 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1276 maya 2943 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1277 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1278 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1279     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1280     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1281     }
1282     else {
1283     DlgAuthSetupFont = NULL;
1284     }
1285     #endif
1286    
1287 yutakakn 2728 return TRUE; /* because we do not set the focus */
1288    
1289     case WM_COMMAND:
1290     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1291    
1292     switch (LOWORD(wParam)) {
1293     case IDOK:
1294 maya 2943
1295 maya 2980 #ifndef NO_I18N
1296 maya 2943 if (DlgAuthSetupFont != NULL) {
1297     DeleteObject(DlgAuthSetupFont);
1298     }
1299     #endif
1300    
1301 yutakakn 2728 return end_default_auth_dlg(pvar, dlg);
1302    
1303     case IDCANCEL:
1304     EndDialog(dlg, 0);
1305 maya 2943
1306 maya 2980 #ifndef NO_I18N
1307 maya 2943 if (DlgAuthSetupFont != NULL) {
1308     DeleteObject(DlgAuthSetupFont);
1309     }
1310     #endif
1311    
1312 yutakakn 2728 return TRUE;
1313    
1314     case IDC_CHOOSERSAFILE:
1315 maya 2980 #ifndef NO_I18N
1316 maya 2937 choose_RSA_key_file(dlg, pvar);
1317 maya 2939 #else
1318     choose_RSA_key_file(dlg);
1319     #endif
1320 yutakakn 2728 return TRUE;
1321    
1322     case IDC_CHOOSEHOSTRSAFILE:
1323 maya 2980 #ifndef NO_I18N
1324 maya 2937 choose_host_RSA_key_file(dlg, pvar);
1325 maya 2939 #else
1326     choose_host_RSA_key_file(dlg);
1327     #endif
1328 yutakakn 2728 return TRUE;
1329    
1330     default:
1331     return FALSE;
1332     }
1333    
1334     default:
1335     return FALSE;
1336     }
1337     }
1338    
1339     void AUTH_init(PTInstVar pvar)
1340     {
1341     pvar->auth_state.failed_method = SSH_AUTH_NONE;
1342     pvar->auth_state.auth_dialog = NULL;
1343     pvar->auth_state.user = NULL;
1344     pvar->auth_state.flags = 0;
1345     pvar->auth_state.TIS_prompt = NULL;
1346     pvar->auth_state.supported_types = 0;
1347     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1348     pvar->auth_state.cur_cred.password = NULL;
1349     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1350     pvar->auth_state.cur_cred.key_pair = NULL;
1351     AUTH_set_generic_mode(pvar);
1352     }
1353    
1354     void AUTH_set_generic_mode(PTInstVar pvar)
1355     {
1356     pvar->auth_state.mode = GENERIC_AUTH_MODE;
1357     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1358     }
1359    
1360     void AUTH_set_TIS_mode(PTInstVar pvar, char FAR * prompt, int len)
1361     {
1362     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1363     pvar->auth_state.mode = TIS_AUTH_MODE;
1364    
1365     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1366     pvar->auth_state.TIS_prompt = malloc(len + 1);
1367     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1368     pvar->auth_state.TIS_prompt[len] = 0;
1369     } else {
1370     AUTH_set_generic_mode(pvar);
1371     }
1372     }
1373    
1374     void AUTH_do_default_cred_dialog(PTInstVar pvar)
1375     {
1376     HWND cur_active = GetActiveWindow();
1377    
1378     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1379     cur_active !=
1380     NULL ? cur_active : pvar->NotificationWindow,
1381     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1382 maya 2980 #ifndef NO_I18N
1383 maya 2937 strcpy(pvar->ts->UIMsg, "Unable to display authentication setup dialog box.");
1384     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar);
1385     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1386     #else
1387 yutakakn 2728 notify_nonfatal_error(pvar,
1388     "Unable to display authentication setup dialog box.");
1389 maya 2937 #endif
1390 yutakakn 2728 }
1391     }
1392    
1393     void AUTH_destroy_cur_cred(PTInstVar pvar)
1394     {
1395     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1396     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1397     if (pvar->auth_state.cur_cred.key_pair != NULL) {
1398     CRYPT_free_key_pair(pvar->auth_state.cur_cred.key_pair);
1399     pvar->auth_state.cur_cred.key_pair = NULL;
1400     }
1401     }
1402    
1403     static char FAR *get_auth_method_name(SSHAuthMethod auth)
1404     {
1405     switch (auth) {
1406     case SSH_AUTH_PASSWORD:
1407     return "password";
1408     case SSH_AUTH_RSA:
1409     return "RSA";
1410     case SSH_AUTH_RHOSTS:
1411     return "rhosts";
1412     case SSH_AUTH_RHOSTS_RSA:
1413     return "rhosts with RSA";
1414     case SSH_AUTH_TIS:
1415     return "challenge/response (TIS)";
1416     default:
1417     return "unknown method";
1418     }
1419     }
1420    
1421     void AUTH_get_auth_info(PTInstVar pvar, char FAR * dest, int len)
1422     {
1423 yutakakn 2782 char *method = "unknown";
1424    
1425 yutakakn 2728 if (pvar->auth_state.user == NULL) {
1426     strncpy(dest, "None", len);
1427     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1428 yutakakn 2762 if (SSHv1(pvar)) {
1429 maya 2980 #ifndef NO_I18N
1430 maya 2949 strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1431     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1432     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user,
1433     get_auth_method_name(pvar->auth_state.cur_cred.method));
1434     #else
1435 yutakakn 2762 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
1436     get_auth_method_name(pvar->auth_state.cur_cred.method));
1437 maya 2949 #endif
1438 yutakakn 2762
1439 yutakakn 2800 } else {
1440     // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1441     // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1442     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1443     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1444 yutakakn 2782 // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1445 yutakakn 2800 if (pvar->keyboard_interactive_done == 1 ||
1446     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1447 yutakakn 2782 method = "keyboard-interactive";
1448     } else {
1449     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1450     }
1451 maya 2980 #ifndef NO_I18N
1452 maya 2949 strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1453     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1454     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user, method);
1455     #else
1456 yutakakn 2782 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user, method);
1457 maya 2949 #endif
1458 yutakakn 2782
1459 yutakakn 2762 } else {
1460     if (pvar->auth_state.cur_cred.key_pair->RSA_key != NULL) {
1461     method = "RSA";
1462     } else if (pvar->auth_state.cur_cred.key_pair->DSA_key != NULL) {
1463     method = "DSA";
1464     }
1465 maya 2980 #ifndef NO_I18N
1466 maya 2949 strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1467     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1468     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user, method);
1469     #else
1470 yutakakn 2762 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user, method);
1471 maya 2949 #endif
1472 yutakakn 2762 }
1473    
1474     }
1475    
1476 yutakakn 2728 } else {
1477 maya 2980 #ifndef NO_I18N
1478 maya 2949 strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1479     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1480     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user,
1481     get_auth_method_name(pvar->auth_state.failed_method));
1482     #else
1483 yutakakn 2728 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
1484     get_auth_method_name(pvar->auth_state.failed_method));
1485 maya 2949 #endif
1486 yutakakn 2728 }
1487    
1488     dest[len - 1] = 0;
1489     }
1490    
1491     void AUTH_notify_disconnecting(PTInstVar pvar)
1492     {
1493     if (pvar->auth_state.auth_dialog != NULL) {
1494     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1495     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1496     EnableWindow(pvar->NotificationWindow, TRUE);
1497     }
1498     }
1499    
1500     void AUTH_end(PTInstVar pvar)
1501     {
1502     destroy_malloced_string(&pvar->auth_state.user);
1503     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1504    
1505     AUTH_destroy_cur_cred(pvar);
1506     }
1507 yutakakn 2739
1508     /*
1509     * $Log: not supported by cvs2svn $
1510 maya 2980 * Revision 1.32 2007/03/17 11:53:29 doda
1511     * �v���C���e�L�X�g�F�����������L�[�{�[�h�C���^���N�e�B�u�F�����g�p�������������������������ASSH�F���_�C�A���O���v���C���e�L�X�g�F����rhosts�F�����\�������������C�������B
1512     *
1513 doda 2968 * Revision 1.31 2007/02/17 17:31:55 yasuhide
1514     * �R�}���h���C����ask4passwd ���w�����������A���O�C���_�C�A���O���p�X�t���[�Y�������t�H�[�J�X����
1515     *
1516 yasuhide 2963 * Revision 1.30 2007/02/17 16:20:21 yasuhide
1517     * SSH2 �����p�����F�����p�X�t���[�Y�������������A�p�X�t���[�Y�_�C�A���O���t�H�[�J�X������
1518     *
1519 yasuhide 2962 * Revision 1.29 2007/02/17 14:01:03 maya
1520     * �\�����b�Z�[�W��������������
1521     *
1522 maya 2961 * Revision 1.28 2007/01/31 13:15:08 maya
1523     * �����t�@�C�������������� \0 ���������F�����������o�O���C�������B
1524     *
1525 maya 2956 * Revision 1.27 2007/01/27 14:29:59 maya
1526     * �p���������{�������A�N�Z�����[�^�L�[�����������B
1527     *
1528 maya 2952 * Revision 1.26 2007/01/22 13:45:19 maya
1529     * �\�����b�Z�[�W��������������
1530     *
1531 maya 2949 * Revision 1.25 2007/01/04 08:36:42 maya
1532     * �t�H���g�����X�������������������B
1533     *
1534 maya 2946 * Revision 1.24 2006/12/06 14:31:13 maya
1535     * �\�����b�Z�[�W��������������
1536     *
1537 maya 2944 * Revision 1.23 2006/12/06 14:25:40 maya
1538     * �\�����b�Z�[�W��������������
1539     *
1540 maya 2943 * Revision 1.22 2006/11/29 16:58:52 maya
1541     * �\�����b�Z�[�W��������������
1542     *
1543 maya 2939 * Revision 1.21 2006/11/23 02:19:30 maya
1544     * �\�����b�Z�[�W�������t�@�C�����������������R�[�h���������J�n�����B
1545     *
1546 maya 2937 * Revision 1.20 2006/09/18 05:08:04 maya
1547     * �R�}���h���C���p�����[�^ '/ask4passwd' �����������B
1548     *
1549 maya 2908 * Revision 1.19 2006/08/05 03:47:49 yutakakn
1550     * �p�X���[�h�������������o������������������������ teraterm.ini �����f�����������������B
1551     *
1552 yutakakn 2891 * Revision 1.18 2006/08/03 15:04:37 yutakakn
1553     * �p�X���[�h�������������������������������������`�F�b�N�{�b�N�X���F���_�C�A���O�����������B
1554     *
1555 yutakakn 2890 * Revision 1.17 2005/09/05 10:46:22 yutakakn
1556     * '/I' �w�����������������F���_�C�A���O�����������������������B
1557     *
1558 yutakakn 2844 * Revision 1.16 2005/08/26 16:26:02 yutakakn
1559     * �������O�C������SSH�F���_�C�A���O�����������������������B
1560     *
1561 yutakakn 2841 * Revision 1.15 2005/07/15 14:58:04 yutakakn
1562     * SSH1���������x���[�U�F�������s�������A�������F�����������������o�O���C���B
1563     *
1564 yutakakn 2835 * Revision 1.14 2005/04/26 13:57:57 yutakakn
1565     * private key�t�@�C���_�C�A���O��3�t�@�C���t�B���^�����������B
1566     *
1567 yutakakn 2818 * Revision 1.13 2005/04/08 14:55:03 yutakakn
1568     * "Duplicate session"��������SSH�������O�C�����s�������������B
1569     *
1570 yutakakn 2811 * Revision 1.12 2005/03/23 12:39:35 yutakakn
1571     * SSH2�F���_�C�A���O�� Use challenge/response to log in ���A�N�Z�����[�^�L�[�������������B
1572     *
1573 yutakakn 2804 * Revision 1.11 2005/03/12 15:07:33 yutakakn
1574     * SSH2 keyboard-interactive�F����TIS�_�C�A���O�����������B
1575     *
1576 yutakakn 2800 * Revision 1.10 2005/03/12 12:08:05 yutakakn
1577     * �p�X���[�h�F�����O���s��keyboard-interactive���\�b�h���A�f�t�H���g�����l������(0)�������B
1578     * �����A�F���_�C�A���O�����x�������������L�����������X���������������B
1579     *
1580 yutakakn 2799 * Revision 1.9 2005/02/22 08:48:11 yutakakn
1581     * TTSSH setup�_�C�A���O�� HeartBeat �����������B
1582     * TTSSH authentication setup�_�C�A���O�� keyboard-interactive �����������B
1583     *
1584 yutakakn 2789 * Revision 1.8 2005/01/27 13:30:33 yutakakn
1585     * ���J���F���������O�C�����T�|�[�g�B
1586     * /auth=publickey, /keyfile �I�v�V�������V�K���������B
1587     * �����A�����������������T�|�[�g�B
1588     *
1589 yutakakn 2784 * Revision 1.7 2005/01/25 13:38:22 yutakakn
1590     * SSH�F���_�C�A���O���ARhosts/TIS���O���[�������O���AEnter�L�[�������������A
1591     * �A�v���P�[�V�����G���[���������������������B
1592     *
1593 yutakakn 2783 * Revision 1.6 2005/01/24 14:07:07 yutakakn
1594     * �Ekeyboard-interactive�F�����T�|�[�g�����B
1595     * �@�����������Ateraterm.ini�� "KeyboardInteractive" �G���g�������������B
1596     * �E�o�[�W�����_�C�A���O�� OpenSSL�o�[�W���� ������
1597     *
1598 yutakakn 2782 * Revision 1.5 2004/12/27 14:35:41 yutakakn
1599     * SSH2�����������������s�����G���[���b�Z�[�W�����������B
1600     *
1601 yutakakn 2769 * Revision 1.4 2004/12/22 17:28:14 yutakakn
1602     * SSH2���J���F��(RSA/DSA)���T�|�[�g�����B
1603     *
1604 yutakakn 2762 * Revision 1.3 2004/12/16 13:01:09 yutakakn
1605     * SSH�������O�C�����A�v���P�[�V�����G���[�������������C�������B
1606     *
1607 yutakakn 2752 * Revision 1.2 2004/12/01 15:37:49 yutakakn
1608     * SSH2�������O�C���@�\�������B
1609     * �����A�p�X���[�h�F�������������B
1610     * �E�R�}���h���C��
1611     * /ssh /auth=�F�����\�b�h /user=���[�U�� /passwd=�p�X���[�h
1612     *
1613 yutakakn 2739 */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
Über OSDN
Software suchen
Entwickeln Software
Hilfeseiten