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 5042 - (hide annotations) (download) (as text)
Tue Oct 16 12:43:13 2012 UTC (11 years, 5 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 53957 byte(s) 
PuTTYのシンボルと衝突するため、Tera Term側の名前を変更する。

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