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 6809 - (hide annotations) (download) (as text)
Mon Jun 19 12:50:42 2017 UTC (6 years, 9 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57040 byte(s) 
ログ関連を見直し。

・_snprintf_s() + notify_verbose_message() を logprintf() に置き換え。
・固定メッセージの notify_verbose_message() を logputs() に置き換え。

pvar を渡す必要が無くなったので、pvar が使えない状況でもログ出力が行える。

全体的に LOGLEVEL を見直したい……
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 doda 6801 void destroy_malloced_string(char **str)
52 maya 3227 {
53     if (*str != NULL) {
54 yutakapon 6229 SecureZeroMemory(*str, strlen(*str));
55 maya 3227 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 doda 6801 (LPARAM) (char *) chars);
76 maya 3227 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 doda 6801 static char *alloc_control_text(HWND ctl)
356 maya 3227 {
357     int len = GetWindowTextLength(ctl);
358 doda 6801 char *result = malloc(len + 1);
359 maya 3227
360     if (result != NULL) {
361     GetWindowText(ctl, result, len + 1);
362     result[len] = 0;
363     }
364    
365     return result;
366     }
367    
368 doda 6801 static int get_key_file_name(HWND parent, char *buf, int bufsize, PTInstVar pvar)
369 maya 3227 {
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 doda 6801 char *password =
427 maya 3227 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 maya 5767 char keyfile[2048];
446 maya 3227 int file_ctl_ID =
447     method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
448    
449 maya 5767 keyfile[0] = 0;
450     GetDlgItemText(dlg, file_ctl_ID, keyfile, sizeof(keyfile));
451     if (keyfile[0] == 0) {
452 maya 3227 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 maya 5767 key_pair = KEYFILES_read_private_key(pvar, keyfile, password,
464 maya 3227 &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 5767 keyfile_type = get_ssh2_keytype(keyfile, &fp, errmsg, sizeof(errmsg));
489 maya 5056 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 yutakapon 6019 "TTSSH and selecting \"SSH Authentication...\" from the Setup menu "
639 maya 3227 "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 yutakapon 5562 // �F�������T�[�o�������f�������������A�L�����Z�������������B(2014.3.31 yutaka)
846     if (!pvar->cv->Ready) {
847     goto canceled;
848     }
849    
850 maya 3227 // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2001.1.25 yutaka)
851     if (pvar->userauth_retry_count == 0 &&
852     ((pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) ||
853     !(pvar->ssh_state.status_flags & STATUS_HOST_OK))) {
854     return FALSE;
855     }
856     else if (SSHv2(pvar) &&
857     pvar->session_settings.CheckAuthListFirst &&
858     !pvar->tryed_ssh2_authlist) {
859     // CheckAuthListFirst ���L�����F������������������������
860     // OK �������������������� (2008.10.4 maya)
861     return FALSE;
862     }
863    
864     return end_auth_dlg(pvar, dlg);
865    
866     case IDCANCEL: /* kill the connection */
867 yutakapon 5562 canceled:
868 maya 3227 pvar->auth_state.auth_dialog = NULL;
869 maya 5678 notify_closed_connection(pvar, "authentication cancelled");
870 maya 3227 EndDialog(dlg, 0);
871    
872     if (DlgAuthFont != NULL) {
873     DeleteObject(DlgAuthFont);
874     }
875    
876     return TRUE;
877    
878     case IDC_SSHUSERNAME:
879     // ���[�U�����t�H�[�J�X������������ (2007.9.29 maya)
880     if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
881     (pvar->ssh_state.status_flags & STATUS_HOST_OK) &&
882     HIWORD(wParam) == EN_KILLFOCUS) {
883     // �������L���������������s��������������
884     if (SSHv2(pvar) &&
885     pvar->session_settings.CheckAuthListFirst &&
886     !pvar->tryed_ssh2_authlist) {
887     // �_�C�A���O�����[�U�������f
888     if (pvar->auth_state.user == NULL) {
889     pvar->auth_state.user =
890     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
891     }
892    
893     // ���[�U���������������������`�F�b�N����
894     if (strlen(pvar->auth_state.user) == 0) {
895     return FALSE;
896     }
897    
898     // ���[�U�������X��������
899     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
900    
901 maya 3342 // �F�����\�b�h none ������
902 maya 3227 do_SSH2_userauth(pvar);
903     return TRUE;
904     }
905     }
906    
907     return FALSE;
908    
909     case IDC_SSHUSEPASSWORD:
910     case IDC_SSHUSERSA:
911     case IDC_SSHUSERHOSTS:
912     case IDC_SSHUSETIS:
913     case IDC_SSHUSEPAGEANT:
914     set_auth_options_status(dlg, LOWORD(wParam));
915     return TRUE;
916    
917     case IDC_CHOOSERSAFILE:
918     choose_RSA_key_file(dlg, pvar);
919     return TRUE;
920    
921     case IDC_CHOOSEHOSTRSAFILE:
922     choose_host_RSA_key_file(dlg, pvar);
923     return TRUE;
924    
925     case IDC_FORWARD_AGENT:
926     // �����Z�b�V�������������f������ (2008.12.4 maya)
927     pvar->session_settings.ForwardAgent = IsDlgButtonChecked(dlg, IDC_FORWARD_AGENT);
928     return TRUE;
929    
930     default:
931     return FALSE;
932     }
933    
934     default:
935     return FALSE;
936     }
937     }
938    
939 doda 6801 char *AUTH_get_user_name(PTInstVar pvar)
940 maya 3227 {
941     return pvar->auth_state.user;
942     }
943    
944     int AUTH_set_supported_auth_types(PTInstVar pvar, int types)
945     {
946 doda 6809 logprintf(LOG_LEVEL_VERBOSE, "Server reports supported authentication method mask = %d", types);
947 maya 3227
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 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
967 maya 3227 return 0;
968     } else {
969     if (pvar->auth_state.auth_dialog != NULL) {
970 doda 6809 update_server_supported_types(pvar, pvar->auth_state.auth_dialog);
971 maya 3227 }
972    
973     return 1;
974     }
975     }
976    
977     static void start_user_auth(PTInstVar pvar)
978     {
979     // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
980     PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
981     (LPARAM) NULL);
982     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
983     }
984    
985     static void try_default_auth(PTInstVar pvar)
986     {
987     if (pvar->session_settings.TryDefaultAuth) {
988     switch (pvar->session_settings.DefaultAuthMethod) {
989     case SSH_AUTH_RSA:{
990     BOOL invalid_passphrase;
991     char password[] = "";
992    
993     pvar->auth_state.cur_cred.key_pair
994     =
995     KEYFILES_read_private_key(pvar,
996     pvar->session_settings.
997     DefaultRSAPrivateKeyFile,
998     password,
999     &invalid_passphrase, TRUE);
1000     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1001     return;
1002     } else {
1003     pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1004     }
1005     break;
1006     }
1007    
1008     case SSH_AUTH_RHOSTS:
1009     if (pvar->session_settings.
1010     DefaultRhostsHostPrivateKeyFile[0] != 0) {
1011     BOOL invalid_passphrase;
1012     char password[] = "";
1013    
1014     pvar->auth_state.cur_cred.key_pair
1015     =
1016     KEYFILES_read_private_key(pvar,
1017     pvar->session_settings.
1018     DefaultRhostsHostPrivateKeyFile,
1019     password,
1020     &invalid_passphrase, TRUE);
1021     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1022     return;
1023     } else {
1024     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
1025     }
1026     } else {
1027     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
1028     }
1029    
1030     pvar->auth_state.cur_cred.rhosts_client_user =
1031     _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
1032     break;
1033    
1034     case SSH_AUTH_PAGEANT:
1035     pvar->auth_state.cur_cred.method = SSH_AUTH_PAGEANT;
1036     break;
1037    
1038     case SSH_AUTH_PASSWORD:
1039     pvar->auth_state.cur_cred.password = _strdup("");
1040     pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1041     break;
1042    
1043     case SSH_AUTH_TIS:
1044     default:
1045     return;
1046     }
1047    
1048     pvar->auth_state.user =
1049     _strdup(pvar->session_settings.DefaultUserName);
1050     }
1051     }
1052    
1053     void AUTH_notify_end_error(PTInstVar pvar)
1054     {
1055     if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
1056     start_user_auth(pvar);
1057     pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
1058     }
1059     }
1060    
1061     void AUTH_advance_to_next_cred(PTInstVar pvar)
1062     {
1063     pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
1064    
1065     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1066     try_default_auth(pvar);
1067    
1068     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1069     if (pvar->err_msg != NULL) {
1070     pvar->auth_state.flags |=
1071     AUTH_START_USER_AUTH_ON_ERROR_END;
1072     } else {
1073     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1074     // �R�}���h���C���w������������
1075     start_user_auth(pvar);
1076     }
1077     }
1078     } else {
1079     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1080     // �R�}���h���C���w������(/auth=xxxx)������
1081     start_user_auth(pvar);
1082     }
1083     }
1084    
1085     static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
1086     {
1087     char uimsg[MAX_UIMSG];
1088    
1089     GetWindowText(dlg, uimsg, sizeof(uimsg));
1090     UTIL_get_lang_msg("DLG_TIS_TITLE", pvar, uimsg);
1091     SetWindowText(dlg, pvar->ts->UIMsg);
1092     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1093     UTIL_get_lang_msg("DLG_TIS_BANNER", pvar, uimsg);
1094     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1095     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1096     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1097     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1098     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1099     UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
1100     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1101    
1102     init_auth_machine_banner(pvar, dlg);
1103     init_password_control(dlg);
1104    
1105     if (pvar->auth_state.TIS_prompt != NULL) {
1106     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
1107     pvar->auth_state.TIS_prompt[10000] = 0;
1108     }
1109     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
1110     pvar->auth_state.TIS_prompt);
1111     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1112     }
1113     }
1114    
1115     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
1116     {
1117 doda 6801 char *password =
1118 maya 3227 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
1119    
1120     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1121     pvar->auth_state.cur_cred.password = password;
1122     pvar->auth_state.auth_dialog = NULL;
1123    
1124     // add
1125     if (SSHv2(pvar)) {
1126     pvar->keyboard_interactive_password_input = 1;
1127     handle_SSH2_userauth_inforeq(pvar);
1128     }
1129    
1130     SSH_notify_cred(pvar);
1131    
1132     EndDialog(dlg, 1);
1133     return TRUE;
1134     }
1135    
1136     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
1137     LPARAM lParam)
1138     {
1139     PTInstVar pvar;
1140     LOGFONT logfont;
1141     HFONT font;
1142    
1143     switch (msg) {
1144     case WM_INITDIALOG:
1145     pvar = (PTInstVar) lParam;
1146     pvar->auth_state.auth_dialog = dlg;
1147     SetWindowLong(dlg, DWL_USER, lParam);
1148    
1149     init_TIS_dlg(pvar, dlg);
1150    
1151     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1152     GetObject(font, sizeof(LOGFONT), &logfont);
1153     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1154     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1155     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1156     SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1157     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1158     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1159     }
1160     else {
1161     DlgTisFont = NULL;
1162     }
1163    
1164     // /auth=challenge ������ (2007.10.5 maya)
1165     if (pvar->ssh2_autologin == 1) {
1166     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
1167     SendMessage(dlg, WM_COMMAND, IDOK, 0);
1168     }
1169    
1170     return FALSE; /* because we set the focus */
1171    
1172     case WM_COMMAND:
1173     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1174    
1175     switch (LOWORD(wParam)) {
1176     case IDOK:
1177     if (DlgTisFont != NULL) {
1178     DeleteObject(DlgTisFont);
1179     }
1180    
1181     return end_TIS_dlg(pvar, dlg);
1182    
1183     case IDCANCEL: /* kill the connection */
1184     pvar->auth_state.auth_dialog = NULL;
1185 maya 5678 notify_closed_connection(pvar, "authentication cancelled");
1186 maya 3227 EndDialog(dlg, 0);
1187    
1188     if (DlgTisFont != NULL) {
1189     DeleteObject(DlgTisFont);
1190     }
1191    
1192     return TRUE;
1193    
1194     default:
1195     return FALSE;
1196     }
1197    
1198     default:
1199     return FALSE;
1200     }
1201     }
1202    
1203     void AUTH_do_cred_dialog(PTInstVar pvar)
1204     {
1205     if (pvar->auth_state.auth_dialog == NULL) {
1206     HWND cur_active = GetActiveWindow();
1207     DLGPROC dlg_proc;
1208     LPCTSTR dialog_template;
1209    
1210     switch (pvar->auth_state.mode) {
1211     case TIS_AUTH_MODE:
1212     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1213     dlg_proc = TIS_dlg_proc;
1214     break;
1215     case GENERIC_AUTH_MODE:
1216     default:
1217     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1218     dlg_proc = auth_dlg_proc;
1219     }
1220    
1221     if (!DialogBoxParam(hInst, dialog_template,
1222     cur_active !=
1223     NULL ? cur_active : pvar->NotificationWindow,
1224     dlg_proc, (LPARAM) pvar) == -1) {
1225     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar,
1226     "Unable to display authentication dialog box.\n"
1227     "Connection terminated.");
1228 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
1229 maya 3227 }
1230     }
1231     }
1232    
1233     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1234     {
1235     char uimsg[MAX_UIMSG];
1236    
1237     GetWindowText(dlg, uimsg, sizeof(uimsg));
1238     UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar, uimsg);
1239     SetWindowText(dlg, pvar->ts->UIMsg);
1240     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1241     UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar, uimsg);
1242     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1243     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
1244     UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar, uimsg);
1245     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1246     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
1247     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar, uimsg);
1248     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1249     GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
1250     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar, uimsg);
1251     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1252     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
1253     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar, uimsg);
1254     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1255     GetDlgItemText(dlg, IDC_SSHUSETIS, uimsg, sizeof(uimsg));
1256     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar, uimsg);
1257     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1258     GetDlgItemText(dlg, IDC_SSHUSEPAGEANT, uimsg, sizeof(uimsg));
1259     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PAGEANT", pvar, uimsg);
1260     SetDlgItemText(dlg, IDC_SSHUSEPAGEANT, pvar->ts->UIMsg);
1261     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
1262     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
1263     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1264     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
1265     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
1266     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1267     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
1268     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
1269     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1270     GetDlgItemText(dlg, IDC_CHECKAUTH, uimsg, sizeof(uimsg));
1271     UTIL_get_lang_msg("DLG_AUTHSETUP_CHECKAUTH", pvar, uimsg);
1272     SetDlgItemText(dlg, IDC_CHECKAUTH, pvar->ts->UIMsg);
1273     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1274     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1275     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1276     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1277     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1278     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1279    
1280     switch (pvar->settings.DefaultAuthMethod) {
1281     case SSH_AUTH_RSA:
1282     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1283     IDC_SSHUSERSA);
1284     break;
1285     case SSH_AUTH_RHOSTS:
1286     case SSH_AUTH_RHOSTS_RSA:
1287     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1288     IDC_SSHUSERHOSTS);
1289     break;
1290     case SSH_AUTH_TIS:
1291     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1292     IDC_SSHUSETIS);
1293     break;
1294     case SSH_AUTH_PAGEANT:
1295     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1296     IDC_SSHUSEPAGEANT);
1297     break;
1298     case SSH_AUTH_PASSWORD:
1299     default:
1300     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1301     IDC_SSHUSEPASSWORD);
1302     }
1303    
1304     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1305     SetDlgItemText(dlg, IDC_RSAFILENAME,
1306     pvar->settings.DefaultRSAPrivateKeyFile);
1307     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1308     pvar->settings.DefaultRhostsHostPrivateKeyFile);
1309     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1310     pvar->settings.DefaultRhostsLocalUserName);
1311    
1312     if (pvar->settings.CheckAuthListFirst) {
1313     CheckDlgButton(dlg, IDC_CHECKAUTH, TRUE);
1314     }
1315     }
1316    
1317     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1318     {
1319     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1320     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1321     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1322     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1323     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1324     } else {
1325     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1326     }
1327     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1328     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1329     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSEPAGEANT)) {
1330     pvar->settings.DefaultAuthMethod = SSH_AUTH_PAGEANT;
1331     } else {
1332     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1333     }
1334    
1335     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1336     sizeof(pvar->settings.DefaultUserName));
1337     GetDlgItemText(dlg, IDC_RSAFILENAME,
1338     pvar->settings.DefaultRSAPrivateKeyFile,
1339     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1340     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1341     pvar->settings.DefaultRhostsHostPrivateKeyFile,
1342     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1343     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1344     pvar->settings.DefaultRhostsLocalUserName,
1345     sizeof(pvar->settings.DefaultRhostsLocalUserName));
1346    
1347     if (IsDlgButtonChecked(dlg, IDC_CHECKAUTH)) {
1348     pvar->settings.CheckAuthListFirst = TRUE;
1349     }
1350     else {
1351     pvar->settings.CheckAuthListFirst = FALSE;
1352     }
1353    
1354     EndDialog(dlg, 1);
1355     return TRUE;
1356     }
1357    
1358     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1359     WPARAM wParam, LPARAM lParam)
1360     {
1361     PTInstVar pvar;
1362     LOGFONT logfont;
1363     HFONT font;
1364    
1365     switch (msg) {
1366     case WM_INITDIALOG:
1367     pvar = (PTInstVar) lParam;
1368     SetWindowLong(dlg, DWL_USER, lParam);
1369    
1370     init_default_auth_dlg(pvar, dlg);
1371    
1372     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1373     GetObject(font, sizeof(LOGFONT), &logfont);
1374     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1375     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1376     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1377     SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1378     SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1379     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1380     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1381     SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1382     SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1383     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1384     SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1385     SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1386     SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1387     SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1388     SendDlgItemMessage(dlg, IDC_SSHUSEPAGEANT, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1389     SendDlgItemMessage(dlg, IDC_CHECKAUTH, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1390     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1391     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1392     }
1393     else {
1394     DlgAuthSetupFont = NULL;
1395     }
1396    
1397     return TRUE; /* because we do not set the focus */
1398    
1399     case WM_COMMAND:
1400     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1401    
1402     switch (LOWORD(wParam)) {
1403     case IDOK:
1404    
1405     if (DlgAuthSetupFont != NULL) {
1406     DeleteObject(DlgAuthSetupFont);
1407     }
1408    
1409     return end_default_auth_dlg(pvar, dlg);
1410    
1411     case IDCANCEL:
1412     EndDialog(dlg, 0);
1413    
1414     if (DlgAuthSetupFont != NULL) {
1415     DeleteObject(DlgAuthSetupFont);
1416     }
1417    
1418     return TRUE;
1419    
1420     case IDC_CHOOSERSAFILE:
1421     choose_RSA_key_file(dlg, pvar);
1422     return TRUE;
1423    
1424     case IDC_CHOOSEHOSTRSAFILE:
1425     choose_host_RSA_key_file(dlg, pvar);
1426     return TRUE;
1427    
1428     default:
1429     return FALSE;
1430     }
1431    
1432     default:
1433     return FALSE;
1434     }
1435     }
1436    
1437     void AUTH_init(PTInstVar pvar)
1438     {
1439     pvar->auth_state.failed_method = SSH_AUTH_NONE;
1440     pvar->auth_state.auth_dialog = NULL;
1441     pvar->auth_state.user = NULL;
1442     pvar->auth_state.flags = 0;
1443     pvar->auth_state.TIS_prompt = NULL;
1444     pvar->auth_state.supported_types = 0;
1445     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1446     pvar->auth_state.cur_cred.password = NULL;
1447     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1448     pvar->auth_state.cur_cred.key_pair = NULL;
1449     AUTH_set_generic_mode(pvar);
1450     }
1451    
1452     void AUTH_set_generic_mode(PTInstVar pvar)
1453     {
1454     pvar->auth_state.mode = GENERIC_AUTH_MODE;
1455     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1456     }
1457    
1458 doda 6801 void AUTH_set_TIS_mode(PTInstVar pvar, char *prompt, int len)
1459 maya 3227 {
1460     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1461     pvar->auth_state.mode = TIS_AUTH_MODE;
1462    
1463     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1464     pvar->auth_state.TIS_prompt = malloc(len + 1);
1465     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1466     pvar->auth_state.TIS_prompt[len] = 0;
1467     } else {
1468     AUTH_set_generic_mode(pvar);
1469     }
1470     }
1471    
1472     void AUTH_do_default_cred_dialog(PTInstVar pvar)
1473     {
1474     HWND cur_active = GetActiveWindow();
1475    
1476     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1477     cur_active != NULL ? cur_active
1478     : pvar->NotificationWindow,
1479     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1480     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar,
1481     "Unable to display authentication setup dialog box.");
1482     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1483     }
1484     }
1485    
1486     void AUTH_destroy_cur_cred(PTInstVar pvar)
1487     {
1488     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1489     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1490     if (pvar->auth_state.cur_cred.key_pair != NULL) {
1491 maya 4307 key_free(pvar->auth_state.cur_cred.key_pair);
1492 maya 3227 pvar->auth_state.cur_cred.key_pair = NULL;
1493     }
1494     }
1495    
1496 maya 4307 static const char *get_auth_method_name(SSHAuthMethod auth)
1497 maya 3227 {
1498     switch (auth) {
1499     case SSH_AUTH_PASSWORD:
1500     return "password";
1501     case SSH_AUTH_RSA:
1502 maya 5550 return "publickey";
1503 maya 3227 case SSH_AUTH_PAGEANT:
1504 maya 5550 return "publickey";
1505 maya 3227 case SSH_AUTH_RHOSTS:
1506     return "rhosts";
1507     case SSH_AUTH_RHOSTS_RSA:
1508     return "rhosts with RSA";
1509     case SSH_AUTH_TIS:
1510     return "challenge/response (TIS)";
1511     default:
1512     return "unknown method";
1513     }
1514     }
1515    
1516 doda 6801 void AUTH_get_auth_info(PTInstVar pvar, char *dest, int len)
1517 maya 3227 {
1518 maya 4307 const char *method = "unknown";
1519 yutakapon 5545 char buf[256];
1520 maya 3227
1521     if (pvar->auth_state.user == NULL) {
1522     strncpy_s(dest, len, "None", _TRUNCATE);
1523     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1524     if (SSHv1(pvar)) {
1525     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1526 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1527     pvar->auth_state.user,
1528 maya 3227 get_auth_method_name(pvar->auth_state.cur_cred.method));
1529    
1530 maya 5550 if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1531     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1532     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1533     "RSA");
1534     strncat_s(dest, len, buf, _TRUNCATE);
1535     }
1536     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1537     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1538     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1539     "RSA");
1540     strncat_s(dest, len, buf, _TRUNCATE);
1541     }
1542 maya 3227 } else {
1543     // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1544     // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1545     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1546     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1547     // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1548     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1549     method = "keyboard-interactive";
1550     } else {
1551     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1552     }
1553     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1554 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1555     pvar->auth_state.user, method);
1556     }
1557     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1558     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1559     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1560     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1561     pvar->auth_state.user,
1562     get_auth_method_name(pvar->auth_state.cur_cred.method));
1563 maya 3227
1564 maya 5550 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1565     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1566     ssh_key_type(pvar->auth_state.cur_cred.key_pair->type));
1567     strncat_s(dest, len, buf, _TRUNCATE);
1568     }
1569     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1570     int key_len = get_uint32_MSBfirst(pvar->pageant_curkey + 4);
1571     char *s = (char *)malloc(key_len+1);
1572 yutakapon 5545
1573 maya 5550 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1574     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1575     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1576     pvar->auth_state.user,
1577     get_auth_method_name(pvar->auth_state.cur_cred.method));
1578 maya 3227
1579 maya 5550 memcpy(s, pvar->pageant_curkey+4+4, key_len);
1580     s[key_len] = '\0';
1581     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1582     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1583     ssh_key_type(get_keytype_from_name(s)));
1584     strncat_s(dest, len, buf, _TRUNCATE);
1585    
1586     free(s);
1587 maya 3227 }
1588     }
1589    
1590     } else {
1591     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1592     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1593     get_auth_method_name(pvar->auth_state.failed_method));
1594     }
1595    
1596     dest[len - 1] = 0;
1597     }
1598    
1599     void AUTH_notify_disconnecting(PTInstVar pvar)
1600     {
1601     if (pvar->auth_state.auth_dialog != NULL) {
1602     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1603     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1604     EnableWindow(pvar->NotificationWindow, TRUE);
1605     }
1606     }
1607    
1608     void AUTH_end(PTInstVar pvar)
1609     {
1610     destroy_malloced_string(&pvar->auth_state.user);
1611     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1612    
1613     AUTH_destroy_cur_cred(pvar);
1614     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help