Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

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