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