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 6801 - (hide annotations) (download) (as text)
Tue Jun 13 10:30:12 2017 UTC (6 years, 9 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57214 byte(s) 
eliminate FAR keyword.
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     char buf[1024];
947    
948     _snprintf_s(buf, sizeof(buf), _TRUNCATE,
949     "Server reports supported authentication method mask = %d",
950     types);
951     buf[sizeof(buf) - 1] = 0;
952     notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
953    
954     if (SSHv1(pvar)) {
955     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
956     | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
957     | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
958     } else {
959     // for SSH2(yutaka)
960     // types &= (1 << SSH_AUTH_PASSWORD);
961     // ���J���F�����L�������� (2004.12.18 yutaka)
962     // TIS�������BSSH2����keyboard-interactive�����������B(2005.3.12 yutaka)
963     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
964     | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
965     }
966     pvar->auth_state.supported_types = types;
967    
968     if (types == 0) {
969     UTIL_get_lang_msg("MSG_NOAUTHMETHOD_ERROR", pvar,
970     "Server does not support any of the authentication options\n"
971     "provided by TTSSH. This connection will now close.");
972 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
973 maya 3227 return 0;
974     } else {
975     if (pvar->auth_state.auth_dialog != NULL) {
976     update_server_supported_types(pvar,
977     pvar->auth_state.auth_dialog);
978     }
979    
980     return 1;
981     }
982     }
983    
984     static void start_user_auth(PTInstVar pvar)
985     {
986     // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
987     PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
988     (LPARAM) NULL);
989     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
990     }
991    
992     static void try_default_auth(PTInstVar pvar)
993     {
994     if (pvar->session_settings.TryDefaultAuth) {
995     switch (pvar->session_settings.DefaultAuthMethod) {
996     case SSH_AUTH_RSA:{
997     BOOL invalid_passphrase;
998     char password[] = "";
999    
1000     pvar->auth_state.cur_cred.key_pair
1001     =
1002     KEYFILES_read_private_key(pvar,
1003     pvar->session_settings.
1004     DefaultRSAPrivateKeyFile,
1005     password,
1006     &invalid_passphrase, TRUE);
1007     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1008     return;
1009     } else {
1010     pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1011     }
1012     break;
1013     }
1014    
1015     case SSH_AUTH_RHOSTS:
1016     if (pvar->session_settings.
1017     DefaultRhostsHostPrivateKeyFile[0] != 0) {
1018     BOOL invalid_passphrase;
1019     char password[] = "";
1020    
1021     pvar->auth_state.cur_cred.key_pair
1022     =
1023     KEYFILES_read_private_key(pvar,
1024     pvar->session_settings.
1025     DefaultRhostsHostPrivateKeyFile,
1026     password,
1027     &invalid_passphrase, TRUE);
1028     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1029     return;
1030     } else {
1031     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
1032     }
1033     } else {
1034     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
1035     }
1036    
1037     pvar->auth_state.cur_cred.rhosts_client_user =
1038     _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
1039     break;
1040    
1041     case SSH_AUTH_PAGEANT:
1042     pvar->auth_state.cur_cred.method = SSH_AUTH_PAGEANT;
1043     break;
1044    
1045     case SSH_AUTH_PASSWORD:
1046     pvar->auth_state.cur_cred.password = _strdup("");
1047     pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1048     break;
1049    
1050     case SSH_AUTH_TIS:
1051     default:
1052     return;
1053     }
1054    
1055     pvar->auth_state.user =
1056     _strdup(pvar->session_settings.DefaultUserName);
1057     }
1058     }
1059    
1060     void AUTH_notify_end_error(PTInstVar pvar)
1061     {
1062     if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
1063     start_user_auth(pvar);
1064     pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
1065     }
1066     }
1067    
1068     void AUTH_advance_to_next_cred(PTInstVar pvar)
1069     {
1070     pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
1071    
1072     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1073     try_default_auth(pvar);
1074    
1075     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1076     if (pvar->err_msg != NULL) {
1077     pvar->auth_state.flags |=
1078     AUTH_START_USER_AUTH_ON_ERROR_END;
1079     } else {
1080     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1081     // �R�}���h���C���w������������
1082     start_user_auth(pvar);
1083     }
1084     }
1085     } else {
1086     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1087     // �R�}���h���C���w������(/auth=xxxx)������
1088     start_user_auth(pvar);
1089     }
1090     }
1091    
1092     static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
1093     {
1094     char uimsg[MAX_UIMSG];
1095    
1096     GetWindowText(dlg, uimsg, sizeof(uimsg));
1097     UTIL_get_lang_msg("DLG_TIS_TITLE", pvar, uimsg);
1098     SetWindowText(dlg, pvar->ts->UIMsg);
1099     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1100     UTIL_get_lang_msg("DLG_TIS_BANNER", pvar, uimsg);
1101     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1102     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1103     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1104     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1105     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1106     UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
1107     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1108    
1109     init_auth_machine_banner(pvar, dlg);
1110     init_password_control(dlg);
1111    
1112     if (pvar->auth_state.TIS_prompt != NULL) {
1113     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
1114     pvar->auth_state.TIS_prompt[10000] = 0;
1115     }
1116     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
1117     pvar->auth_state.TIS_prompt);
1118     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1119     }
1120     }
1121    
1122     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
1123     {
1124 doda 6801 char *password =
1125 maya 3227 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
1126    
1127     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1128     pvar->auth_state.cur_cred.password = password;
1129     pvar->auth_state.auth_dialog = NULL;
1130    
1131     // add
1132     if (SSHv2(pvar)) {
1133     pvar->keyboard_interactive_password_input = 1;
1134     handle_SSH2_userauth_inforeq(pvar);
1135     }
1136    
1137     SSH_notify_cred(pvar);
1138    
1139     EndDialog(dlg, 1);
1140     return TRUE;
1141     }
1142    
1143     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
1144     LPARAM lParam)
1145     {
1146     PTInstVar pvar;
1147     LOGFONT logfont;
1148     HFONT font;
1149    
1150     switch (msg) {
1151     case WM_INITDIALOG:
1152     pvar = (PTInstVar) lParam;
1153     pvar->auth_state.auth_dialog = dlg;
1154     SetWindowLong(dlg, DWL_USER, lParam);
1155    
1156     init_TIS_dlg(pvar, dlg);
1157    
1158     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1159     GetObject(font, sizeof(LOGFONT), &logfont);
1160     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1161     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1162     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1163     SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1164     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1165     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1166     }
1167     else {
1168     DlgTisFont = NULL;
1169     }
1170    
1171     // /auth=challenge ������ (2007.10.5 maya)
1172     if (pvar->ssh2_autologin == 1) {
1173     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
1174     SendMessage(dlg, WM_COMMAND, IDOK, 0);
1175     }
1176    
1177     return FALSE; /* because we set the focus */
1178    
1179     case WM_COMMAND:
1180     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1181    
1182     switch (LOWORD(wParam)) {
1183     case IDOK:
1184     if (DlgTisFont != NULL) {
1185     DeleteObject(DlgTisFont);
1186     }
1187    
1188     return end_TIS_dlg(pvar, dlg);
1189    
1190     case IDCANCEL: /* kill the connection */
1191     pvar->auth_state.auth_dialog = NULL;
1192 maya 5678 notify_closed_connection(pvar, "authentication cancelled");
1193 maya 3227 EndDialog(dlg, 0);
1194    
1195     if (DlgTisFont != NULL) {
1196     DeleteObject(DlgTisFont);
1197     }
1198    
1199     return TRUE;
1200    
1201     default:
1202     return FALSE;
1203     }
1204    
1205     default:
1206     return FALSE;
1207     }
1208     }
1209    
1210     void AUTH_do_cred_dialog(PTInstVar pvar)
1211     {
1212     if (pvar->auth_state.auth_dialog == NULL) {
1213     HWND cur_active = GetActiveWindow();
1214     DLGPROC dlg_proc;
1215     LPCTSTR dialog_template;
1216    
1217     switch (pvar->auth_state.mode) {
1218     case TIS_AUTH_MODE:
1219     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1220     dlg_proc = TIS_dlg_proc;
1221     break;
1222     case GENERIC_AUTH_MODE:
1223     default:
1224     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1225     dlg_proc = auth_dlg_proc;
1226     }
1227    
1228     if (!DialogBoxParam(hInst, dialog_template,
1229     cur_active !=
1230     NULL ? cur_active : pvar->NotificationWindow,
1231     dlg_proc, (LPARAM) pvar) == -1) {
1232     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar,
1233     "Unable to display authentication dialog box.\n"
1234     "Connection terminated.");
1235 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
1236 maya 3227 }
1237     }
1238     }
1239    
1240     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1241     {
1242     char uimsg[MAX_UIMSG];
1243    
1244     GetWindowText(dlg, uimsg, sizeof(uimsg));
1245     UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar, uimsg);
1246     SetWindowText(dlg, pvar->ts->UIMsg);
1247     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1248     UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar, uimsg);
1249     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1250     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
1251     UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar, uimsg);
1252     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1253     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
1254     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar, uimsg);
1255     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1256     GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
1257     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar, uimsg);
1258     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1259     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
1260     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar, uimsg);
1261     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1262     GetDlgItemText(dlg, IDC_SSHUSETIS, uimsg, sizeof(uimsg));
1263     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar, uimsg);
1264     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1265     GetDlgItemText(dlg, IDC_SSHUSEPAGEANT, uimsg, sizeof(uimsg));
1266     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PAGEANT", pvar, uimsg);
1267     SetDlgItemText(dlg, IDC_SSHUSEPAGEANT, pvar->ts->UIMsg);
1268     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
1269     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
1270     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1271     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
1272     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
1273     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1274     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
1275     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
1276     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1277     GetDlgItemText(dlg, IDC_CHECKAUTH, uimsg, sizeof(uimsg));
1278     UTIL_get_lang_msg("DLG_AUTHSETUP_CHECKAUTH", pvar, uimsg);
1279     SetDlgItemText(dlg, IDC_CHECKAUTH, pvar->ts->UIMsg);
1280     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1281     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1282     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1283     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1284     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1285     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1286    
1287     switch (pvar->settings.DefaultAuthMethod) {
1288     case SSH_AUTH_RSA:
1289     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1290     IDC_SSHUSERSA);
1291     break;
1292     case SSH_AUTH_RHOSTS:
1293     case SSH_AUTH_RHOSTS_RSA:
1294     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1295     IDC_SSHUSERHOSTS);
1296     break;
1297     case SSH_AUTH_TIS:
1298     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1299     IDC_SSHUSETIS);
1300     break;
1301     case SSH_AUTH_PAGEANT:
1302     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1303     IDC_SSHUSEPAGEANT);
1304     break;
1305     case SSH_AUTH_PASSWORD:
1306     default:
1307     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1308     IDC_SSHUSEPASSWORD);
1309     }
1310    
1311     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1312     SetDlgItemText(dlg, IDC_RSAFILENAME,
1313     pvar->settings.DefaultRSAPrivateKeyFile);
1314     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1315     pvar->settings.DefaultRhostsHostPrivateKeyFile);
1316     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1317     pvar->settings.DefaultRhostsLocalUserName);
1318    
1319     if (pvar->settings.CheckAuthListFirst) {
1320     CheckDlgButton(dlg, IDC_CHECKAUTH, TRUE);
1321     }
1322     }
1323    
1324     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1325     {
1326     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1327     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1328     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1329     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1330     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1331     } else {
1332     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1333     }
1334     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1335     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1336     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSEPAGEANT)) {
1337     pvar->settings.DefaultAuthMethod = SSH_AUTH_PAGEANT;
1338     } else {
1339     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1340     }
1341    
1342     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1343     sizeof(pvar->settings.DefaultUserName));
1344     GetDlgItemText(dlg, IDC_RSAFILENAME,
1345     pvar->settings.DefaultRSAPrivateKeyFile,
1346     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1347     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1348     pvar->settings.DefaultRhostsHostPrivateKeyFile,
1349     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1350     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1351     pvar->settings.DefaultRhostsLocalUserName,
1352     sizeof(pvar->settings.DefaultRhostsLocalUserName));
1353    
1354     if (IsDlgButtonChecked(dlg, IDC_CHECKAUTH)) {
1355     pvar->settings.CheckAuthListFirst = TRUE;
1356     }
1357     else {
1358     pvar->settings.CheckAuthListFirst = FALSE;
1359     }
1360    
1361     EndDialog(dlg, 1);
1362     return TRUE;
1363     }
1364    
1365     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1366     WPARAM wParam, LPARAM lParam)
1367     {
1368     PTInstVar pvar;
1369     LOGFONT logfont;
1370     HFONT font;
1371    
1372     switch (msg) {
1373     case WM_INITDIALOG:
1374     pvar = (PTInstVar) lParam;
1375     SetWindowLong(dlg, DWL_USER, lParam);
1376    
1377     init_default_auth_dlg(pvar, dlg);
1378    
1379     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1380     GetObject(font, sizeof(LOGFONT), &logfont);
1381     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1382     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1383     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1384     SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1385     SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1386     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1387     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1388     SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1389     SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1390     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1391     SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1392     SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1393     SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1394     SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1395     SendDlgItemMessage(dlg, IDC_SSHUSEPAGEANT, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1396     SendDlgItemMessage(dlg, IDC_CHECKAUTH, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1397     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1398     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1399     }
1400     else {
1401     DlgAuthSetupFont = NULL;
1402     }
1403    
1404     return TRUE; /* because we do not set the focus */
1405    
1406     case WM_COMMAND:
1407     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1408    
1409     switch (LOWORD(wParam)) {
1410     case IDOK:
1411    
1412     if (DlgAuthSetupFont != NULL) {
1413     DeleteObject(DlgAuthSetupFont);
1414     }
1415    
1416     return end_default_auth_dlg(pvar, dlg);
1417    
1418     case IDCANCEL:
1419     EndDialog(dlg, 0);
1420    
1421     if (DlgAuthSetupFont != NULL) {
1422     DeleteObject(DlgAuthSetupFont);
1423     }
1424    
1425     return TRUE;
1426    
1427     case IDC_CHOOSERSAFILE:
1428     choose_RSA_key_file(dlg, pvar);
1429     return TRUE;
1430    
1431     case IDC_CHOOSEHOSTRSAFILE:
1432     choose_host_RSA_key_file(dlg, pvar);
1433     return TRUE;
1434    
1435     default:
1436     return FALSE;
1437     }
1438    
1439     default:
1440     return FALSE;
1441     }
1442     }
1443    
1444     void AUTH_init(PTInstVar pvar)
1445     {
1446     pvar->auth_state.failed_method = SSH_AUTH_NONE;
1447     pvar->auth_state.auth_dialog = NULL;
1448     pvar->auth_state.user = NULL;
1449     pvar->auth_state.flags = 0;
1450     pvar->auth_state.TIS_prompt = NULL;
1451     pvar->auth_state.supported_types = 0;
1452     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1453     pvar->auth_state.cur_cred.password = NULL;
1454     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1455     pvar->auth_state.cur_cred.key_pair = NULL;
1456     AUTH_set_generic_mode(pvar);
1457     }
1458    
1459     void AUTH_set_generic_mode(PTInstVar pvar)
1460     {
1461     pvar->auth_state.mode = GENERIC_AUTH_MODE;
1462     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1463     }
1464    
1465 doda 6801 void AUTH_set_TIS_mode(PTInstVar pvar, char *prompt, int len)
1466 maya 3227 {
1467     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1468     pvar->auth_state.mode = TIS_AUTH_MODE;
1469    
1470     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1471     pvar->auth_state.TIS_prompt = malloc(len + 1);
1472     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1473     pvar->auth_state.TIS_prompt[len] = 0;
1474     } else {
1475     AUTH_set_generic_mode(pvar);
1476     }
1477     }
1478    
1479     void AUTH_do_default_cred_dialog(PTInstVar pvar)
1480     {
1481     HWND cur_active = GetActiveWindow();
1482    
1483     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1484     cur_active != NULL ? cur_active
1485     : pvar->NotificationWindow,
1486     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1487     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar,
1488     "Unable to display authentication setup dialog box.");
1489     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1490     }
1491     }
1492    
1493     void AUTH_destroy_cur_cred(PTInstVar pvar)
1494     {
1495     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1496     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1497     if (pvar->auth_state.cur_cred.key_pair != NULL) {
1498 maya 4307 key_free(pvar->auth_state.cur_cred.key_pair);
1499 maya 3227 pvar->auth_state.cur_cred.key_pair = NULL;
1500     }
1501     }
1502    
1503 maya 4307 static const char *get_auth_method_name(SSHAuthMethod auth)
1504 maya 3227 {
1505     switch (auth) {
1506     case SSH_AUTH_PASSWORD:
1507     return "password";
1508     case SSH_AUTH_RSA:
1509 maya 5550 return "publickey";
1510 maya 3227 case SSH_AUTH_PAGEANT:
1511 maya 5550 return "publickey";
1512 maya 3227 case SSH_AUTH_RHOSTS:
1513     return "rhosts";
1514     case SSH_AUTH_RHOSTS_RSA:
1515     return "rhosts with RSA";
1516     case SSH_AUTH_TIS:
1517     return "challenge/response (TIS)";
1518     default:
1519     return "unknown method";
1520     }
1521     }
1522    
1523 doda 6801 void AUTH_get_auth_info(PTInstVar pvar, char *dest, int len)
1524 maya 3227 {
1525 maya 4307 const char *method = "unknown";
1526 yutakapon 5545 char buf[256];
1527 maya 3227
1528     if (pvar->auth_state.user == NULL) {
1529     strncpy_s(dest, len, "None", _TRUNCATE);
1530     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1531     if (SSHv1(pvar)) {
1532     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1533 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1534     pvar->auth_state.user,
1535 maya 3227 get_auth_method_name(pvar->auth_state.cur_cred.method));
1536    
1537 maya 5550 if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1538     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1539     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1540     "RSA");
1541     strncat_s(dest, len, buf, _TRUNCATE);
1542     }
1543     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1544     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1545     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1546     "RSA");
1547     strncat_s(dest, len, buf, _TRUNCATE);
1548     }
1549 maya 3227 } else {
1550     // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1551     // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1552     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1553     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1554     // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1555     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1556     method = "keyboard-interactive";
1557     } else {
1558     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1559     }
1560     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1561 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1562     pvar->auth_state.user, method);
1563     }
1564     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1565     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1566     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1567     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1568     pvar->auth_state.user,
1569     get_auth_method_name(pvar->auth_state.cur_cred.method));
1570 maya 3227
1571 maya 5550 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1572     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1573     ssh_key_type(pvar->auth_state.cur_cred.key_pair->type));
1574     strncat_s(dest, len, buf, _TRUNCATE);
1575     }
1576     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1577     int key_len = get_uint32_MSBfirst(pvar->pageant_curkey + 4);
1578     char *s = (char *)malloc(key_len+1);
1579 yutakapon 5545
1580 maya 5550 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1581     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1582     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1583     pvar->auth_state.user,
1584     get_auth_method_name(pvar->auth_state.cur_cred.method));
1585 maya 3227
1586 maya 5550 memcpy(s, pvar->pageant_curkey+4+4, key_len);
1587     s[key_len] = '\0';
1588     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1589     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1590     ssh_key_type(get_keytype_from_name(s)));
1591     strncat_s(dest, len, buf, _TRUNCATE);
1592    
1593     free(s);
1594 maya 3227 }
1595     }
1596    
1597     } else {
1598     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1599     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1600     get_auth_method_name(pvar->auth_state.failed_method));
1601     }
1602    
1603     dest[len - 1] = 0;
1604     }
1605    
1606     void AUTH_notify_disconnecting(PTInstVar pvar)
1607     {
1608     if (pvar->auth_state.auth_dialog != NULL) {
1609     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1610     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1611     EnableWindow(pvar->NotificationWindow, TRUE);
1612     }
1613     }
1614    
1615     void AUTH_end(PTInstVar pvar)
1616     {
1617     destroy_malloced_string(&pvar->auth_state.user);
1618     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1619    
1620     AUTH_destroy_cur_cred(pvar);
1621     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help