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