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 2956 - (hide annotations) (download) (as text)
Wed Jan 31 13:15:08 2007 UTC (17 years, 2 months ago) by maya
Original Path: ttssh2/trunk/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 49720 byte(s) 
言語ファイルがないときに \0 が正しく認識されないバグを修正した。
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     #endif
949    
950 yutakakn 2728 init_auth_machine_banner(pvar, dlg);
951     init_password_control(dlg);
952    
953     if (pvar->auth_state.TIS_prompt != NULL) {
954     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
955     pvar->auth_state.TIS_prompt[10000] = 0;
956     }
957     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
958     pvar->auth_state.TIS_prompt);
959     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
960     }
961     }
962    
963     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
964     {
965     char FAR *password =
966     alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
967    
968     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
969     pvar->auth_state.cur_cred.password = password;
970     pvar->auth_state.auth_dialog = NULL;
971    
972 yutakakn 2800 // add
973     if (SSHv2(pvar)) {
974     pvar->keyboard_interactive_password_input = 1;
975     handle_SSH2_userauth_inforeq(pvar);
976     }
977    
978 yutakakn 2728 SSH_notify_cred(pvar);
979    
980     EndDialog(dlg, 1);
981     return TRUE;
982     }
983    
984     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
985     LPARAM lParam)
986     {
987     PTInstVar pvar;
988 maya 2943 #ifdef I18N
989     LOGFONT logfont;
990     HFONT font;
991     #endif
992 yutakakn 2728
993     switch (msg) {
994     case WM_INITDIALOG:
995     pvar = (PTInstVar) lParam;
996     pvar->auth_state.auth_dialog = dlg;
997     SetWindowLong(dlg, DWL_USER, lParam);
998    
999     init_TIS_dlg(pvar, dlg);
1000 maya 2943
1001     #ifdef I18N
1002     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1003     GetObject(font, sizeof(LOGFONT), &logfont);
1004 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1005 maya 2943 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1006     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1007 maya 2946 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1008 maya 2943 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1009     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1010     }
1011     else {
1012     DlgTisFont = NULL;
1013     }
1014     #endif
1015    
1016 yutakakn 2728 return FALSE; /* because we set the focus */
1017    
1018     case WM_COMMAND:
1019     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1020    
1021     switch (LOWORD(wParam)) {
1022     case IDOK:
1023 maya 2943 #ifdef I18N
1024     if (DlgTisFont != NULL) {
1025     DeleteObject(DlgTisFont);
1026     }
1027     #endif
1028    
1029 yutakakn 2728 return end_TIS_dlg(pvar, dlg);
1030    
1031     case IDCANCEL: /* kill the connection */
1032     pvar->auth_state.auth_dialog = NULL;
1033     notify_closed_connection(pvar);
1034     EndDialog(dlg, 0);
1035 maya 2943
1036     #ifdef I18N
1037     if (DlgTisFont != NULL) {
1038     DeleteObject(DlgTisFont);
1039     }
1040     #endif
1041    
1042 yutakakn 2728 return TRUE;
1043    
1044     default:
1045     return FALSE;
1046     }
1047    
1048     default:
1049     return FALSE;
1050     }
1051     }
1052    
1053     void AUTH_do_cred_dialog(PTInstVar pvar)
1054     {
1055     if (pvar->auth_state.auth_dialog == NULL) {
1056     HWND cur_active = GetActiveWindow();
1057     DLGPROC dlg_proc;
1058     LPCTSTR dialog_template;
1059    
1060     switch (pvar->auth_state.mode) {
1061     case TIS_AUTH_MODE:
1062     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1063     dlg_proc = TIS_dlg_proc;
1064     break;
1065     case GENERIC_AUTH_MODE:
1066     default:
1067     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1068     dlg_proc = auth_dlg_proc;
1069     }
1070    
1071     if (!DialogBoxParam(hInst, dialog_template,
1072     cur_active !=
1073     NULL ? cur_active : pvar->NotificationWindow,
1074     dlg_proc, (LPARAM) pvar) == -1) {
1075 maya 2937 #ifdef I18N
1076     strcpy(pvar->ts->UIMsg,
1077     "Unable to display authentication dialog box.\n"
1078     "Connection terminated.");
1079     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar);
1080     notify_fatal_error(pvar, pvar->ts->UIMsg);
1081     #else
1082 yutakakn 2728 notify_fatal_error(pvar,
1083     "Unable to display authentication dialog box.\n"
1084     "Connection terminated.");
1085 maya 2937 #endif
1086 yutakakn 2728 }
1087     }
1088     }
1089    
1090     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1091     {
1092 maya 2937 #ifdef I18N
1093     GetWindowText(dlg, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1094     UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar);
1095     SetWindowText(dlg, pvar->ts->UIMsg);
1096    
1097     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1098     UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar);
1099     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1100    
1101     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1102     UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar);
1103     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1104    
1105     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1106     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar);
1107     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1108    
1109     GetDlgItemText(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1110     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD_KBDINT", pvar);
1111     SetDlgItemText(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, pvar->ts->UIMsg);
1112    
1113     GetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1114     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar);
1115     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1116    
1117     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1118     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar);
1119     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1120    
1121     GetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1122     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar);
1123     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1124    
1125     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1126     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar);
1127     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1128    
1129     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1130     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar);
1131     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1132    
1133     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1134     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar);
1135     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1136    
1137     GetDlgItemText(dlg, IDOK, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1138     UTIL_get_lang_msg("BTN_OK", pvar);
1139     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1140    
1141     GetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg, sizeof(pvar->ts->UIMsg));
1142     UTIL_get_lang_msg("BTN_CANCEL", pvar);
1143     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1144     #endif
1145    
1146 yutakakn 2728 switch (pvar->settings.DefaultAuthMethod) {
1147     case SSH_AUTH_RSA:
1148     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1149     IDC_SSHUSERSA);
1150     break;
1151     case SSH_AUTH_RHOSTS:
1152     case SSH_AUTH_RHOSTS_RSA:
1153     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1154     IDC_SSHUSERHOSTS);
1155     break;
1156     case SSH_AUTH_TIS:
1157     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1158     IDC_SSHUSETIS);
1159     break;
1160     case SSH_AUTH_PASSWORD:
1161     default:
1162     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1163     IDC_SSHUSEPASSWORD);
1164     }
1165    
1166     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1167     SetDlgItemText(dlg, IDC_RSAFILENAME,
1168     pvar->settings.DefaultRSAPrivateKeyFile);
1169     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1170     pvar->settings.DefaultRhostsHostPrivateKeyFile);
1171     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1172     pvar->settings.DefaultRhostsLocalUserName);
1173 yutakakn 2789
1174     // SSH2 keyboard-interactive method (2005.2.22 yutaka)
1175     if (pvar->settings.ssh2_keyboard_interactive) {
1176     SendMessage(GetDlgItem(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK), BM_SETCHECK, BST_CHECKED, 0);
1177     }
1178    
1179 yutakakn 2728 }
1180    
1181     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1182     {
1183     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1184     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1185     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1186     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1187     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1188     } else {
1189     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1190     }
1191     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1192     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1193     } else {
1194     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1195     }
1196    
1197     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1198     sizeof(pvar->settings.DefaultUserName));
1199     GetDlgItemText(dlg, IDC_RSAFILENAME,
1200     pvar->settings.DefaultRSAPrivateKeyFile,
1201     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1202     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1203     pvar->settings.DefaultRhostsHostPrivateKeyFile,
1204     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1205     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1206     pvar->settings.DefaultRhostsLocalUserName,
1207     sizeof(pvar->settings.DefaultRhostsLocalUserName));
1208    
1209 yutakakn 2789 // SSH2 keyboard-interactive method (2005.2.22 yutaka)
1210     {
1211     LRESULT ret;
1212     ret = SendMessage(GetDlgItem(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK), BM_GETCHECK, 0, 0);
1213     if (ret & BST_CHECKED) {
1214     pvar->settings.ssh2_keyboard_interactive = 1;
1215     } else {
1216     pvar->settings.ssh2_keyboard_interactive = 0;
1217     }
1218     }
1219    
1220 yutakakn 2728 EndDialog(dlg, 1);
1221     return TRUE;
1222     }
1223    
1224     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1225     WPARAM wParam, LPARAM lParam)
1226     {
1227     PTInstVar pvar;
1228 maya 2943 #ifdef I18N
1229     LOGFONT logfont;
1230     HFONT font;
1231     #endif
1232 yutakakn 2728
1233     switch (msg) {
1234     case WM_INITDIALOG:
1235     pvar = (PTInstVar) lParam;
1236     SetWindowLong(dlg, DWL_USER, lParam);
1237    
1238     init_default_auth_dlg(pvar, dlg);
1239 maya 2943
1240     #ifdef I18N
1241     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1242     GetObject(font, sizeof(LOGFONT), &logfont);
1243 maya 2946 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1244 maya 2943 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1245     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1246 maya 2946 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1247 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1248     SendDlgItemMessage(dlg, IDC_KEYBOARD_INTERACTIVE_CHECK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1249     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1250     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1251 maya 2946 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1252 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1253     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1254 maya 2946 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1255 maya 2943 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1256 maya 2946 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1257 maya 2943 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1258     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1259     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1260     }
1261     else {
1262     DlgAuthSetupFont = NULL;
1263     }
1264     #endif
1265    
1266 yutakakn 2728 return TRUE; /* because we do not set the focus */
1267    
1268     case WM_COMMAND:
1269     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1270    
1271     switch (LOWORD(wParam)) {
1272     case IDOK:
1273 maya 2943
1274     #ifdef I18N
1275     if (DlgAuthSetupFont != NULL) {
1276     DeleteObject(DlgAuthSetupFont);
1277     }
1278     #endif
1279    
1280 yutakakn 2728 return end_default_auth_dlg(pvar, dlg);
1281    
1282     case IDCANCEL:
1283     EndDialog(dlg, 0);
1284 maya 2943
1285     #ifdef I18N
1286     if (DlgAuthSetupFont != NULL) {
1287     DeleteObject(DlgAuthSetupFont);
1288     }
1289     #endif
1290    
1291 yutakakn 2728 return TRUE;
1292    
1293     case IDC_CHOOSERSAFILE:
1294 maya 2939 #ifdef I18N
1295 maya 2937 choose_RSA_key_file(dlg, pvar);
1296 maya 2939 #else
1297     choose_RSA_key_file(dlg);
1298     #endif
1299 yutakakn 2728 return TRUE;
1300    
1301     case IDC_CHOOSEHOSTRSAFILE:
1302 maya 2939 #ifdef I18N
1303 maya 2937 choose_host_RSA_key_file(dlg, pvar);
1304 maya 2939 #else
1305     choose_host_RSA_key_file(dlg);
1306     #endif
1307 yutakakn 2728 return TRUE;
1308    
1309     default:
1310     return FALSE;
1311     }
1312    
1313     default:
1314     return FALSE;
1315     }
1316     }
1317    
1318     void AUTH_init(PTInstVar pvar)
1319     {
1320     pvar->auth_state.failed_method = SSH_AUTH_NONE;
1321     pvar->auth_state.auth_dialog = NULL;
1322     pvar->auth_state.user = NULL;
1323     pvar->auth_state.flags = 0;
1324     pvar->auth_state.TIS_prompt = NULL;
1325     pvar->auth_state.supported_types = 0;
1326     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1327     pvar->auth_state.cur_cred.password = NULL;
1328     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1329     pvar->auth_state.cur_cred.key_pair = NULL;
1330     AUTH_set_generic_mode(pvar);
1331     }
1332    
1333     void AUTH_set_generic_mode(PTInstVar pvar)
1334     {
1335     pvar->auth_state.mode = GENERIC_AUTH_MODE;
1336     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1337     }
1338    
1339     void AUTH_set_TIS_mode(PTInstVar pvar, char FAR * prompt, int len)
1340     {
1341     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1342     pvar->auth_state.mode = TIS_AUTH_MODE;
1343    
1344     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1345     pvar->auth_state.TIS_prompt = malloc(len + 1);
1346     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1347     pvar->auth_state.TIS_prompt[len] = 0;
1348     } else {
1349     AUTH_set_generic_mode(pvar);
1350     }
1351     }
1352    
1353     void AUTH_do_default_cred_dialog(PTInstVar pvar)
1354     {
1355     HWND cur_active = GetActiveWindow();
1356    
1357     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1358     cur_active !=
1359     NULL ? cur_active : pvar->NotificationWindow,
1360     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1361 maya 2937 #ifdef I18N
1362     strcpy(pvar->ts->UIMsg, "Unable to display authentication setup dialog box.");
1363     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar);
1364     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1365     #else
1366 yutakakn 2728 notify_nonfatal_error(pvar,
1367     "Unable to display authentication setup dialog box.");
1368 maya 2937 #endif
1369 yutakakn 2728 }
1370     }
1371    
1372     void AUTH_destroy_cur_cred(PTInstVar pvar)
1373     {
1374     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1375     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1376     if (pvar->auth_state.cur_cred.key_pair != NULL) {
1377     CRYPT_free_key_pair(pvar->auth_state.cur_cred.key_pair);
1378     pvar->auth_state.cur_cred.key_pair = NULL;
1379     }
1380     }
1381    
1382     static char FAR *get_auth_method_name(SSHAuthMethod auth)
1383     {
1384     switch (auth) {
1385     case SSH_AUTH_PASSWORD:
1386     return "password";
1387     case SSH_AUTH_RSA:
1388     return "RSA";
1389     case SSH_AUTH_RHOSTS:
1390     return "rhosts";
1391     case SSH_AUTH_RHOSTS_RSA:
1392     return "rhosts with RSA";
1393     case SSH_AUTH_TIS:
1394     return "challenge/response (TIS)";
1395     default:
1396     return "unknown method";
1397     }
1398     }
1399    
1400     void AUTH_get_auth_info(PTInstVar pvar, char FAR * dest, int len)
1401     {
1402 yutakakn 2782 char *method = "unknown";
1403    
1404 yutakakn 2728 if (pvar->auth_state.user == NULL) {
1405     strncpy(dest, "None", len);
1406     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1407 yutakakn 2762 if (SSHv1(pvar)) {
1408 maya 2949 #ifdef I18N
1409     strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1410     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1411     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user,
1412     get_auth_method_name(pvar->auth_state.cur_cred.method));
1413     #else
1414 yutakakn 2762 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
1415     get_auth_method_name(pvar->auth_state.cur_cred.method));
1416 maya 2949 #endif
1417 yutakakn 2762
1418 yutakakn 2800 } else {
1419     // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1420     // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1421     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1422     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1423 yutakakn 2782 // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1424 yutakakn 2800 if (pvar->keyboard_interactive_done == 1 ||
1425     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1426 yutakakn 2782 method = "keyboard-interactive";
1427     } else {
1428     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1429     }
1430 maya 2949 #ifdef I18N
1431     strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1432     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1433     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user, method);
1434     #else
1435 yutakakn 2782 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user, method);
1436 maya 2949 #endif
1437 yutakakn 2782
1438 yutakakn 2762 } else {
1439     if (pvar->auth_state.cur_cred.key_pair->RSA_key != NULL) {
1440     method = "RSA";
1441     } else if (pvar->auth_state.cur_cred.key_pair->DSA_key != NULL) {
1442     method = "DSA";
1443     }
1444 maya 2949 #ifdef I18N
1445     strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1446     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1447     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user, method);
1448     #else
1449 yutakakn 2762 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user, method);
1450 maya 2949 #endif
1451 yutakakn 2762 }
1452    
1453     }
1454    
1455 yutakakn 2728 } else {
1456 maya 2949 #ifdef I18N
1457     strcpy(pvar->ts->UIMsg, "User '%s', using %s");
1458     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar);
1459     _snprintf(dest, len, pvar->ts->UIMsg, pvar->auth_state.user,
1460     get_auth_method_name(pvar->auth_state.failed_method));
1461     #else
1462 yutakakn 2728 _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
1463     get_auth_method_name(pvar->auth_state.failed_method));
1464 maya 2949 #endif
1465 yutakakn 2728 }
1466    
1467     dest[len - 1] = 0;
1468     }
1469    
1470     void AUTH_notify_disconnecting(PTInstVar pvar)
1471     {
1472     if (pvar->auth_state.auth_dialog != NULL) {
1473     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1474     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1475     EnableWindow(pvar->NotificationWindow, TRUE);
1476     }
1477     }
1478    
1479     void AUTH_end(PTInstVar pvar)
1480     {
1481     destroy_malloced_string(&pvar->auth_state.user);
1482     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1483    
1484     AUTH_destroy_cur_cred(pvar);
1485     }
1486 yutakakn 2739
1487     /*
1488     * $Log: not supported by cvs2svn $
1489 maya 2956 * Revision 1.27 2007/01/27 14:29:59 maya
1490     * �p���������{�������A�N�Z�����[�^�L�[�����������B
1491     *
1492 maya 2952 * Revision 1.26 2007/01/22 13:45:19 maya
1493     * �\�����b�Z�[�W��������������
1494     *
1495 maya 2949 * Revision 1.25 2007/01/04 08:36:42 maya
1496     * �t�H���g�����X�������������������B
1497     *
1498 maya 2946 * Revision 1.24 2006/12/06 14:31:13 maya
1499     * �\�����b�Z�[�W��������������
1500     *
1501 maya 2944 * Revision 1.23 2006/12/06 14:25:40 maya
1502     * �\�����b�Z�[�W��������������
1503     *
1504 maya 2943 * Revision 1.22 2006/11/29 16:58:52 maya
1505     * �\�����b�Z�[�W��������������
1506     *
1507 maya 2939 * Revision 1.21 2006/11/23 02:19:30 maya
1508     * �\�����b�Z�[�W�������t�@�C�����������������R�[�h���������J�n�����B
1509     *
1510 maya 2937 * Revision 1.20 2006/09/18 05:08:04 maya
1511     * �R�}���h���C���p�����[�^ '/ask4passwd' �����������B
1512     *
1513 maya 2908 * Revision 1.19 2006/08/05 03:47:49 yutakakn
1514     * �p�X���[�h�������������o������������������������ teraterm.ini �����f�����������������B
1515     *
1516 yutakakn 2891 * Revision 1.18 2006/08/03 15:04:37 yutakakn
1517     * �p�X���[�h�������������������������������������`�F�b�N�{�b�N�X���F���_�C�A���O�����������B
1518     *
1519 yutakakn 2890 * Revision 1.17 2005/09/05 10:46:22 yutakakn
1520     * '/I' �w�����������������F���_�C�A���O�����������������������B
1521     *
1522 yutakakn 2844 * Revision 1.16 2005/08/26 16:26:02 yutakakn
1523     * �������O�C������SSH�F���_�C�A���O�����������������������B
1524     *
1525 yutakakn 2841 * Revision 1.15 2005/07/15 14:58:04 yutakakn
1526     * SSH1���������x���[�U�F�������s�������A�������F�����������������o�O���C���B
1527     *
1528 yutakakn 2835 * Revision 1.14 2005/04/26 13:57:57 yutakakn
1529     * private key�t�@�C���_�C�A���O��3�t�@�C���t�B���^�����������B
1530     *
1531 yutakakn 2818 * Revision 1.13 2005/04/08 14:55:03 yutakakn
1532     * "Duplicate session"��������SSH�������O�C�����s�������������B
1533     *
1534 yutakakn 2811 * Revision 1.12 2005/03/23 12:39:35 yutakakn
1535     * SSH2�F���_�C�A���O�� Use challenge/response to log in ���A�N�Z�����[�^�L�[�������������B
1536     *
1537 yutakakn 2804 * Revision 1.11 2005/03/12 15:07:33 yutakakn
1538     * SSH2 keyboard-interactive�F����TIS�_�C�A���O�����������B
1539     *
1540 yutakakn 2800 * Revision 1.10 2005/03/12 12:08:05 yutakakn
1541     * �p�X���[�h�F�����O���s��keyboard-interactive���\�b�h���A�f�t�H���g�����l������(0)�������B
1542     * �����A�F���_�C�A���O�����x�������������L�����������X���������������B
1543     *
1544 yutakakn 2799 * Revision 1.9 2005/02/22 08:48:11 yutakakn
1545     * TTSSH setup�_�C�A���O�� HeartBeat �����������B
1546     * TTSSH authentication setup�_�C�A���O�� keyboard-interactive �����������B
1547     *
1548 yutakakn 2789 * Revision 1.8 2005/01/27 13:30:33 yutakakn
1549     * ���J���F���������O�C�����T�|�[�g�B
1550     * /auth=publickey, /keyfile �I�v�V�������V�K���������B
1551     * �����A�����������������T�|�[�g�B
1552     *
1553 yutakakn 2784 * Revision 1.7 2005/01/25 13:38:22 yutakakn
1554     * SSH�F���_�C�A���O���ARhosts/TIS���O���[�������O���AEnter�L�[�������������A
1555     * �A�v���P�[�V�����G���[���������������������B
1556     *
1557 yutakakn 2783 * Revision 1.6 2005/01/24 14:07:07 yutakakn
1558     * �Ekeyboard-interactive�F�����T�|�[�g�����B
1559     * �@�����������Ateraterm.ini�� "KeyboardInteractive" �G���g�������������B
1560     * �E�o�[�W�����_�C�A���O�� OpenSSL�o�[�W���� ������
1561     *
1562 yutakakn 2782 * Revision 1.5 2004/12/27 14:35:41 yutakakn
1563     * SSH2�����������������s�����G���[���b�Z�[�W�����������B
1564     *
1565 yutakakn 2769 * Revision 1.4 2004/12/22 17:28:14 yutakakn
1566     * SSH2���J���F��(RSA/DSA)���T�|�[�g�����B
1567     *
1568 yutakakn 2762 * Revision 1.3 2004/12/16 13:01:09 yutakakn
1569     * SSH�������O�C�����A�v���P�[�V�����G���[�������������C�������B
1570     *
1571 yutakakn 2752 * Revision 1.2 2004/12/01 15:37:49 yutakakn
1572     * SSH2�������O�C���@�\�������B
1573     * �����A�p�X���[�h�F�������������B
1574     * �E�R�}���h���C��
1575     * /ssh /auth=�F�����\�b�h /user=���[�U�� /passwd=�p�X���[�h
1576     *
1577 yutakakn 2739 */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help