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