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