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