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