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