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 7360 - (hide annotations) (download) (as text)
Sun Dec 23 16:13:05 2018 UTC (5 years, 3 months ago) by zmatsuo
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57120 byte(s) 
OPENFILENAME.lStructSize を　get_OPENFILENAME_SIZE()　で初期化
1 maya 3227 /*
2 doda 6841 * Copyright (c) 1998-2001, Robert O'Callahan
3     * (C) 2004-2017 TeraTerm Project
4     * All rights reserved.
5     *
6     * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8     * are met:
9     *
10     * 1. Redistributions of source code must retain the above copyright
11     * notice, this list of conditions and the following disclaimer.
12     * 2. Redistributions in binary form must reproduce the above copyright
13     * notice, this list of conditions and the following disclaimer in the
14     * documentation and/or other materials provided with the distribution.
15     * 3. The name of the author may not be used to endorse or promote products
16     * derived from this software without specific prior written permission.
17     *
18     * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21     * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28     */
29 maya 3227
30     #include "ttxssh.h"
31     #include "util.h"
32     #include "ssh.h"
33 maya 4304 #include "key.h"
34 zmatsuo 7360 #include "ttlib.h"
35 maya 3227
36     #include <io.h>
37     #include <fcntl.h>
38     #include <stdlib.h>
39     #include <errno.h>
40    
41     #include "resource.h"
42     #include "keyfiles.h"
43     #include "libputty.h"
44    
45     #define AUTH_START_USER_AUTH_ON_ERROR_END 1
46    
47     #define MAX_AUTH_CONTROL IDC_SSHUSEPAGEANT
48    
49     static HFONT DlgAuthFont;
50     static HFONT DlgTisFont;
51     static HFONT DlgAuthSetupFont;
52    
53 doda 6801 void destroy_malloced_string(char **str)
54 maya 3227 {
55     if (*str != NULL) {
56 yutakapon 6229 SecureZeroMemory(*str, strlen(*str));
57 maya 3227 free(*str);
58     *str = NULL;
59     }
60     }
61    
62     static int auth_types_to_control_IDs[] = {
63     -1, IDC_SSHUSERHOSTS, IDC_SSHUSERSA, IDC_SSHUSEPASSWORD,
64     IDC_SSHUSERHOSTS, IDC_SSHUSETIS, -1,
65     -1, -1, -1, -1, -1, -1, -1, -1, -1, IDC_SSHUSEPAGEANT, -1
66     };
67    
68 maya 4649 LRESULT CALLBACK password_wnd_proc(HWND control, UINT msg,
69     WPARAM wParam, LPARAM lParam)
70 maya 3227 {
71     switch (msg) {
72     case WM_CHAR:
73     if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) {
74     char chars[] = { (char) wParam, 0 };
75    
76     SendMessage(control, EM_REPLACESEL, (WPARAM) TRUE,
77 doda 6801 (LPARAM) (char *) chars);
78 maya 3227 return 0;
79     }
80     }
81    
82     return CallWindowProc((WNDPROC) GetWindowLong(control, GWL_USERDATA),
83     control, msg, wParam, lParam);
84     }
85    
86     static void init_password_control(HWND dlg)
87     {
88     HWND passwordControl = GetDlgItem(dlg, IDC_SSHPASSWORD);
89    
90     SetWindowLong(passwordControl, GWL_USERDATA,
91     SetWindowLong(passwordControl, GWL_WNDPROC,
92     (LONG) password_wnd_proc));
93    
94     SetFocus(passwordControl);
95     }
96    
97     static void set_auth_options_status(HWND dlg, int controlID)
98     {
99     BOOL RSA_enabled = controlID == IDC_SSHUSERSA;
100     BOOL rhosts_enabled = controlID == IDC_SSHUSERHOSTS;
101     BOOL TIS_enabled = controlID == IDC_SSHUSETIS;
102     BOOL PAGEANT_enabled = controlID == IDC_SSHUSEPAGEANT;
103     int i;
104    
105     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, controlID);
106    
107     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), (!TIS_enabled && !PAGEANT_enabled));
108     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), (!TIS_enabled && !PAGEANT_enabled));
109    
110     for (i = IDC_CHOOSERSAFILE; i <= IDC_RSAFILENAME; i++) {
111     EnableWindow(GetDlgItem(dlg, i), RSA_enabled);
112     }
113    
114     for (i = IDC_LOCALUSERNAMELABEL; i <= IDC_HOSTRSAFILENAME; i++) {
115     EnableWindow(GetDlgItem(dlg, i), rhosts_enabled);
116     }
117     }
118    
119     static void init_auth_machine_banner(PTInstVar pvar, HWND dlg)
120     {
121     char buf[1024], buf2[1024];
122    
123     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf2, sizeof(buf2));
124     _snprintf_s(buf, sizeof(buf), _TRUNCATE, buf2, SSH_get_host_name(pvar));
125     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf);
126     }
127    
128     static void update_server_supported_types(PTInstVar pvar, HWND dlg)
129     {
130     int supported_methods = pvar->auth_state.supported_types;
131     int cur_control = -1;
132     int control;
133     HWND focus = GetFocus();
134    
135     if (supported_methods == 0) {
136     return;
137     }
138    
139     for (control = IDC_SSHUSEPASSWORD; control <= MAX_AUTH_CONTROL;
140     control++) {
141     BOOL enabled = FALSE;
142     int method;
143     HWND item = GetDlgItem(dlg, control);
144    
145     if (item != NULL) {
146     for (method = 0; method <= SSH_AUTH_MAX; method++) {
147     if (auth_types_to_control_IDs[method] == control
148     && (supported_methods & (1 << method)) != 0) {
149     enabled = TRUE;
150     }
151     }
152    
153     EnableWindow(item, enabled);
154    
155     if (IsDlgButtonChecked(dlg, control)) {
156     cur_control = control;
157     }
158     }
159     }
160    
161     if (cur_control >= 0) {
162     if (!IsWindowEnabled(GetDlgItem(dlg, cur_control))) {
163     do {
164     cur_control++;
165     if (cur_control > MAX_AUTH_CONTROL) {
166     cur_control = IDC_SSHUSEPASSWORD;
167     }
168     } while (!IsWindowEnabled(GetDlgItem(dlg, cur_control)));
169    
170     set_auth_options_status(dlg, cur_control);
171    
172     if (focus != NULL && !IsWindowEnabled(focus)) {
173     SetFocus(GetDlgItem(dlg, cur_control));
174     }
175     }
176     }
177     }
178    
179     static void init_auth_dlg(PTInstVar pvar, HWND dlg)
180     {
181     int default_method = pvar->session_settings.DefaultAuthMethod;
182     char uimsg[MAX_UIMSG];
183    
184     GetWindowText(dlg, uimsg, sizeof(uimsg));
185     UTIL_get_lang_msg("DLG_AUTH_TITLE", pvar, uimsg);
186     SetWindowText(dlg, pvar->ts->UIMsg);
187     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
188     UTIL_get_lang_msg("DLG_AUTH_BANNER", pvar, uimsg);
189     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
190     GetDlgItemText(dlg, IDC_SSHAUTHBANNER2, uimsg, sizeof(uimsg));
191     UTIL_get_lang_msg("DLG_AUTH_BANNER2", pvar, uimsg);
192     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg);
193     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
194     UTIL_get_lang_msg("DLG_AUTH_USERNAME", pvar, uimsg);
195     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
196     GetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, uimsg, sizeof(uimsg));
197     UTIL_get_lang_msg("DLG_AUTH_PASSWORD", pvar, uimsg);
198     SetDlgItemText(dlg, IDC_SSHPASSWORDCAPTION, pvar->ts->UIMsg);
199     GetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, uimsg, sizeof(uimsg));
200     UTIL_get_lang_msg("DLG_AUTH_REMEMBER_PASSWORD", pvar, uimsg);
201     SetDlgItemText(dlg, IDC_REMEMBER_PASSWORD, pvar->ts->UIMsg);
202     GetDlgItemText(dlg, IDC_FORWARD_AGENT, uimsg, sizeof(uimsg));
203     UTIL_get_lang_msg("DLG_AUTH_FWDAGENT", pvar, uimsg);
204     SetDlgItemText(dlg, IDC_FORWARD_AGENT, pvar->ts->UIMsg);
205     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
206     UTIL_get_lang_msg("DLG_AUTH_METHOD_PASSWORD", pvar, uimsg);
207     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
208     GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
209     UTIL_get_lang_msg("DLG_AUTH_METHOD_RSA", pvar, uimsg);
210     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
211     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
212     UTIL_get_lang_msg("DLG_AUTH_METHOD_RHOST", pvar, uimsg);
213     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
214     GetDlgItemText(dlg, IDC_SSHUSEPAGEANT, uimsg, sizeof(uimsg));
215     UTIL_get_lang_msg("DLG_AUTH_METHOD_PAGEANT", pvar, uimsg);
216     SetDlgItemText(dlg, IDC_SSHUSEPAGEANT, pvar->ts->UIMsg);
217     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
218     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
219     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
220     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
221     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
222     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
223     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
224     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
225     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
226     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
227     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
228     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
229     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
230     UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
231     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
232    
233     init_auth_machine_banner(pvar, dlg);
234     init_password_control(dlg);
235    
236 maya 3342 // �F�����s�������x������������
237 maya 3227 if (pvar->auth_state.failed_method != SSH_AUTH_NONE) {
238     /* must be retrying a failed attempt */
239     UTIL_get_lang_msg("DLG_AUTH_BANNER2_FAILED", pvar, "Authentication failed. Please retry.");
240     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2, pvar->ts->UIMsg);
241     UTIL_get_lang_msg("DLG_AUTH_TITLE_FAILED", pvar, "Retrying SSH Authentication");
242     SetWindowText(dlg, pvar->ts->UIMsg);
243     default_method = pvar->auth_state.failed_method;
244     }
245    
246 maya 3342 // �p�X���[�h���o���������`�F�b�N�{�b�N�X�����f�t�H���g���L�������� (2006.8.3 yutaka)
247     if (pvar->ts_SSH->remember_password) {
248     SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_CHECKED, 0);
249     } else {
250     SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_SETCHECK, BST_UNCHECKED, 0);
251     }
252 maya 3227
253 maya 3342 // ForwardAgent �����������f���� (2008.12.4 maya)
254     CheckDlgButton(dlg, IDC_FORWARD_AGENT, pvar->settings.ForwardAgent);
255    
256     // SSH �o�[�W������������ TIS �����x������������
257     if (pvar->settings.ssh_protocol_version == 1) {
258     UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE1", pvar,
259 doda 7101 "Use challenge/response(&TIS) to log in");
260 maya 3342 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
261     } else {
262     UTIL_get_lang_msg("DLG_AUTH_METHOD_CHALLENGE2", pvar,
263 doda 7101 "Use keyboard-&interactive to log in");
264 maya 3342 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
265 maya 3227 }
266    
267     if (pvar->auth_state.user != NULL) {
268     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->auth_state.user);
269     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
270     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
271 maya 3342 }
272 maya 4759 else if (strlen(pvar->ssh2_username) > 0) {
273 maya 3342 SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->ssh2_username);
274     if (pvar->ssh2_autologin == 1) {
275     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
276     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
277     }
278     }
279     else if (pvar->session_settings.DefaultUserName[0] != 0) {
280 maya 3227 SetDlgItemText(dlg, IDC_SSHUSERNAME,
281     pvar->session_settings.DefaultUserName);
282     }
283    
284 maya 3342 if (strlen(pvar->ssh2_password) > 0) {
285     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
286     if (pvar->ssh2_autologin == 1) {
287     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
288     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), FALSE);
289     }
290     }
291    
292 maya 3227 SetDlgItemText(dlg, IDC_RSAFILENAME,
293     pvar->session_settings.DefaultRSAPrivateKeyFile);
294     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
295     pvar->session_settings.DefaultRhostsHostPrivateKeyFile);
296     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
297     pvar->session_settings.DefaultRhostsLocalUserName);
298    
299 maya 3342 if (pvar->ssh2_authmethod == SSH_AUTH_PASSWORD) {
300     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSEPASSWORD);
301 maya 3227
302 maya 3342 } else if (pvar->ssh2_authmethod == SSH_AUTH_RSA) {
303     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSERSA);
304 maya 3227
305 maya 3342 SetDlgItemText(dlg, IDC_RSAFILENAME, pvar->ssh2_keyfile);
306 maya 3227 if (pvar->ssh2_autologin == 1) {
307 maya 3342 EnableWindow(GetDlgItem(dlg, IDC_CHOOSERSAFILE), FALSE);
308     EnableWindow(GetDlgItem(dlg, IDC_RSAFILENAME), FALSE);
309 maya 3227 }
310    
311 maya 3342 // /auth=challenge ������ (2007.10.5 maya)
312     } else if (pvar->ssh2_authmethod == SSH_AUTH_TIS) {
313     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSETIS);
314     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
315     SetDlgItemText(dlg, IDC_SSHPASSWORD, "");
316 maya 3227
317 maya 3342 // /auth=pageant ������
318     } else if (pvar->ssh2_authmethod == SSH_AUTH_PAGEANT) {
319     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSEPAGEANT);
320     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
321     SetDlgItemText(dlg, IDC_SSHPASSWORD, "");
322 maya 3227
323 maya 3342 } else {
324     // �f�t�H���g���F�����\�b�h���_�C�A���O�����f
325     set_auth_options_status(dlg, auth_types_to_control_IDs[default_method]);
326 maya 3227
327 maya 3342 update_server_supported_types(pvar, dlg);
328 maya 3227
329 maya 3342 // �z�X�g�m�F�_�C�A���O��������������=�E�B���h�E���A�N�e�B�u������������
330     // �� SetFocus �����s�����A�R�}���h���C�����n�������F��������������������
331     // �����������A�������O�C���L������ SetFocus ������ (2009.1.31 maya)
332     if (default_method == SSH_AUTH_TIS) {
333     /* we disabled the password control, so fix the focus */
334     SetFocus(GetDlgItem(dlg, IDC_SSHUSETIS));
335 maya 3227 }
336 maya 3342 else if (default_method == SSH_AUTH_PAGEANT) {
337     SetFocus(GetDlgItem(dlg, IDC_SSHUSEPAGEANT));
338     }
339 maya 3227
340     }
341    
342 maya 3342 if (GetWindowTextLength(GetDlgItem(dlg, IDC_SSHUSERNAME)) == 0) {
343     SetFocus(GetDlgItem(dlg, IDC_SSHUSERNAME));
344 maya 3227 }
345 maya 3342 else if (pvar->ask4passwd == 1) {
346     SetFocus(GetDlgItem(dlg, IDC_SSHPASSWORD));
347     }
348 maya 3227
349 maya 3342 // '/I' �w�������������������������� (2005.9.5 yutaka)
350     if (pvar->ts->Minimize) {
351     //20050822���� start T.Takahashi
352     ShowWindow(dlg,SW_MINIMIZE);
353     //20050822���� end T.Takahashi
354 maya 3227 }
355     }
356    
357 doda 6801 static char *alloc_control_text(HWND ctl)
358 maya 3227 {
359     int len = GetWindowTextLength(ctl);
360 doda 6801 char *result = malloc(len + 1);
361 maya 3227
362     if (result != NULL) {
363     GetWindowText(ctl, result, len + 1);
364     result[len] = 0;
365     }
366    
367     return result;
368     }
369    
370 doda 6801 static int get_key_file_name(HWND parent, char *buf, int bufsize, PTInstVar pvar)
371 maya 3227 {
372     OPENFILENAME params;
373     char fullname_buf[2048] = "identity";
374     char filter[MAX_UIMSG];
375    
376     ZeroMemory(&params, sizeof(params));
377 zmatsuo 7360 params.lStructSize = get_OPENFILENAME_SIZE();
378 maya 3227 params.hwndOwner = parent;
379     // �t�B���^������ (2004.12.19 yutaka)
380     // 3�t�@�C���t�B���^������ (2005.4.26 yutaka)
381     UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_FILTER", pvar,
382 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");
383 maya 3227 memcpy(filter, pvar->ts->UIMsg, sizeof(filter));
384     params.lpstrFilter = filter;
385     params.lpstrCustomFilter = NULL;
386     params.nFilterIndex = 0;
387     buf[0] = 0;
388     params.lpstrFile = fullname_buf;
389     params.nMaxFile = sizeof(fullname_buf);
390     params.lpstrFileTitle = NULL;
391     params.lpstrInitialDir = NULL;
392     UTIL_get_lang_msg("FILEDLG_OPEN_PRIVATEKEY_TITLE", pvar,
393 maya 5553 "Choose a file with the RSA/DSA/ECDSA/ED25519 private key");
394 maya 3227 params.lpstrTitle = pvar->ts->UIMsg;
395     params.Flags =
396     OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
397     params.lpstrDefExt = NULL;
398    
399     if (GetOpenFileName(&params) != 0) {
400     copy_teraterm_dir_relative_path(buf, bufsize, fullname_buf);
401     return 1;
402     } else {
403     return 0;
404     }
405     }
406    
407     static void choose_RSA_key_file(HWND dlg, PTInstVar pvar)
408     {
409     char buf[1024];
410    
411     if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
412     SetDlgItemText(dlg, IDC_RSAFILENAME, buf);
413     }
414     }
415    
416     static void choose_host_RSA_key_file(HWND dlg, PTInstVar pvar)
417     {
418     char buf[1024];
419    
420     if (get_key_file_name(dlg, buf, sizeof(buf), pvar)) {
421     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME, buf);
422     }
423     }
424    
425     static BOOL end_auth_dlg(PTInstVar pvar, HWND dlg)
426     {
427     int method = SSH_AUTH_PASSWORD;
428 doda 6801 char *password =
429 maya 3227 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
430 maya 4307 Key *key_pair = NULL;
431 maya 3227
432     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
433     method = SSH_AUTH_RSA;
434     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
435     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
436     method = SSH_AUTH_RHOSTS_RSA;
437     } else {
438     method = SSH_AUTH_RHOSTS;
439     }
440     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
441     method = SSH_AUTH_TIS;
442     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSEPAGEANT)) {
443     method = SSH_AUTH_PAGEANT;
444     }
445    
446     if (method == SSH_AUTH_RSA || method == SSH_AUTH_RHOSTS_RSA) {
447 maya 5767 char keyfile[2048];
448 maya 3227 int file_ctl_ID =
449     method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
450    
451 maya 5767 keyfile[0] = 0;
452     GetDlgItemText(dlg, file_ctl_ID, keyfile, sizeof(keyfile));
453     if (keyfile[0] == 0) {
454 maya 3227 UTIL_get_lang_msg("MSG_KEYSPECIFY_ERROR", pvar,
455 maya 5553 "You must specify a file containing the RSA/DSA/ECDSA/ED25519 private key.");
456 maya 3227 notify_nonfatal_error(pvar, pvar->ts->UIMsg);
457     SetFocus(GetDlgItem(dlg, file_ctl_ID));
458     destroy_malloced_string(&password);
459     return FALSE;
460     }
461    
462     if (SSHv1(pvar)) {
463     BOOL invalid_passphrase = FALSE;
464    
465 maya 5767 key_pair = KEYFILES_read_private_key(pvar, keyfile, password,
466 maya 3227 &invalid_passphrase,
467     FALSE);
468    
469     if (key_pair == NULL) {
470     if (invalid_passphrase) {
471     HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
472    
473     SetFocus(passwordCtl);
474     SendMessage(passwordCtl, EM_SETSEL, 0, -1);
475     } else {
476     SetFocus(GetDlgItem(dlg, file_ctl_ID));
477     }
478     destroy_malloced_string(&password);
479     return FALSE;
480     }
481    
482     } else { // SSH2(yutaka)
483     BOOL invalid_passphrase = FALSE;
484     char errmsg[256];
485 maya 5056 FILE *fp = NULL;
486     ssh2_keyfile_type keyfile_type;
487 maya 3227
488     memset(errmsg, 0, sizeof(errmsg));
489    
490 maya 5767 keyfile_type = get_ssh2_keytype(keyfile, &fp, errmsg, sizeof(errmsg));
491 maya 5056 switch (keyfile_type) {
492     case SSH2_KEYFILE_TYPE_OPENSSH:
493     {
494     key_pair = read_SSH2_private_key(pvar, fp, password,
495     &invalid_passphrase,
496     FALSE,
497     errmsg,
498     sizeof(errmsg)
499     );
500     break;
501     }
502     case SSH2_KEYFILE_TYPE_PUTTY:
503     {
504     key_pair = read_SSH2_PuTTY_private_key(pvar, fp, password,
505     &invalid_passphrase,
506     FALSE,
507     errmsg,
508     sizeof(errmsg)
509     );
510     break;
511     }
512     case SSH2_KEYFILE_TYPE_SECSH:
513     {
514     key_pair = read_SSH2_SECSH_private_key(pvar, fp, password,
515     &invalid_passphrase,
516     FALSE,
517     errmsg,
518     sizeof(errmsg)
519     );
520     break;
521     }
522     default:
523     {
524     char buf[1024];
525 maya 5552
526     // �t�@�C�����J�����������t�@�C���`�����s��������������������
527     if (fp != NULL) {
528     key_pair = read_SSH2_private_key(pvar, fp, password,
529     &invalid_passphrase,
530     FALSE,
531     errmsg,
532     sizeof(errmsg)
533     );
534     break;
535     }
536    
537 maya 5056 UTIL_get_lang_msg("MSG_READKEY_ERROR", pvar,
538     "read error SSH2 private key file\r\n%s");
539     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, errmsg);
540     notify_nonfatal_error(pvar, buf);
541 maya 5552 // ���������������������� SSH2 �������t�@�C�����J����������
542 maya 5056 // ���t�@�C�����I���{�^�����t�H�[�J�X������
543     SetFocus(GetDlgItem(dlg, IDC_CHOOSERSAFILE));
544     destroy_malloced_string(&password);
545     return FALSE;
546     }
547     }
548 maya 3227
549     if (key_pair == NULL) { // read error
550     char buf[1024];
551     UTIL_get_lang_msg("MSG_READKEY_ERROR", pvar,
552     "read error SSH2 private key file\r\n%s");
553     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, errmsg);
554     notify_nonfatal_error(pvar, buf);
555     // �p�X�t���[�Y���������v����������������IDC_SSHPASSWORD���t�H�[�J�X������ (2006.10.29 yasuhide)
556     if (invalid_passphrase) {
557     HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
558    
559     SetFocus(passwordCtl);
560     SendMessage(passwordCtl, EM_SETSEL, 0, -1);
561     } else {
562     SetFocus(GetDlgItem(dlg, file_ctl_ID));
563     }
564     destroy_malloced_string(&password);
565     return FALSE;
566     }
567    
568     }
569    
570     }
571     else if (method == SSH_AUTH_PAGEANT) {
572     pvar->pageant_key = NULL;
573     pvar->pageant_curkey = NULL;
574     pvar->pageant_keylistlen = 0;
575     pvar->pageant_keycount = 0;
576     pvar->pageant_keycurrent = 0;
577     pvar->pageant_keyfinal=FALSE;
578    
579     // Pageant �����M
580     if (SSHv1(pvar)) {
581     pvar->pageant_keylistlen = putty_get_ssh1_keylist(&pvar->pageant_key);
582     }
583     else {
584     pvar->pageant_keylistlen = putty_get_ssh2_keylist(&pvar->pageant_key);
585     }
586     if (pvar->pageant_keylistlen == 0) {
587     UTIL_get_lang_msg("MSG_PAGEANT_NOTFOUND", pvar,
588     "Can't find Pageant.");
589     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
590    
591     return FALSE;
592     }
593     pvar->pageant_curkey = pvar->pageant_key;
594    
595     // ������
596     pvar->pageant_keycount = get_uint32_MSBfirst(pvar->pageant_curkey);
597     if (pvar->pageant_keycount == 0) {
598     UTIL_get_lang_msg("MSG_PAGEANT_NOKEY", pvar,
599     "Pageant has no valid key.");
600     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
601    
602     return FALSE;
603     }
604     pvar->pageant_curkey += 4;
605     }
606    
607     /* from here on, we cannot fail, so just munge cur_cred in place */
608     pvar->auth_state.cur_cred.method = method;
609     pvar->auth_state.cur_cred.key_pair = key_pair;
610     /* we can't change the user name once it's set. It may already have
611     been sent to the server, and it can only be sent once. */
612     if (pvar->auth_state.user == NULL) {
613     pvar->auth_state.user =
614     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
615     }
616    
617     // �p�X���[�h���������������������������� (2006.8.3 yutaka)
618     if (SendMessage(GetDlgItem(dlg, IDC_REMEMBER_PASSWORD), BM_GETCHECK, 0,0) == BST_CHECKED) {
619     pvar->settings.remember_password = 1; // �o��������
620     pvar->ts_SSH->remember_password = 1;
621     } else {
622     pvar->settings.remember_password = 0; // ���������������Y����
623     pvar->ts_SSH->remember_password = 0;
624     }
625    
626     // ���J���F���������A�Z�b�V�������������p�X���[�h���g�����������������������������������B
627     // (2005.4.8 yutaka)
628     if (method == SSH_AUTH_PASSWORD || method == SSH_AUTH_RSA) {
629     pvar->auth_state.cur_cred.password = password;
630     } else {
631     destroy_malloced_string(&password);
632     }
633     if (method == SSH_AUTH_RHOSTS || method == SSH_AUTH_RHOSTS_RSA) {
634     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
635     UTIL_get_lang_msg("MSG_RHOSTS_NOTDEFAULT_ERROR", pvar,
636     "Rhosts authentication will probably fail because it was not "
637     "the default authentication method.\n"
638     "To use Rhosts authentication "
639     "in TTSSH, you need to set it to be the default by restarting\n"
640 yutakapon 6019 "TTSSH and selecting \"SSH Authentication...\" from the Setup menu "
641 maya 3227 "before connecting.");
642     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
643     }
644    
645     pvar->auth_state.cur_cred.rhosts_client_user =
646     alloc_control_text(GetDlgItem(dlg, IDC_LOCALUSERNAME));
647     }
648     pvar->auth_state.auth_dialog = NULL;
649    
650     GetDlgItemText(dlg, IDC_RSAFILENAME,
651     pvar->session_settings.DefaultRSAPrivateKeyFile,
652     sizeof(pvar->session_settings.
653     DefaultRSAPrivateKeyFile));
654     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
655     pvar->session_settings.DefaultRhostsHostPrivateKeyFile,
656     sizeof(pvar->session_settings.
657     DefaultRhostsHostPrivateKeyFile));
658     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
659     pvar->session_settings.DefaultRhostsLocalUserName,
660     sizeof(pvar->session_settings.
661     DefaultRhostsLocalUserName));
662    
663     if (SSHv1(pvar)) {
664     SSH_notify_user_name(pvar);
665     SSH_notify_cred(pvar);
666     } else {
667     // for SSH2(yutaka)
668     do_SSH2_userauth(pvar);
669     }
670    
671     EndDialog(dlg, 1);
672     if (DlgAuthFont != NULL) {
673     DeleteObject(DlgAuthFont);
674     }
675    
676     return TRUE;
677     }
678    
679     BOOL autologin_sent_none;
680     static BOOL CALLBACK auth_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
681     LPARAM lParam)
682     {
683 maya 3342 const int IDC_TIMER1 = 300; // �������O�C�����L��������
684     const int IDC_TIMER2 = 301; // �T�|�[�g�������������\�b�h�������`�F�b�N(CheckAuthListFirst)
685     const int IDC_TIMER3 = 302; // challenge �� ask4passwd ��CheckAuthListFirst �� FALSE ������
686 maya 3227 const int autologin_timeout = 10; // �~���b
687     PTInstVar pvar;
688     LOGFONT logfont;
689     HFONT font;
690    
691     switch (msg) {
692     case WM_INITDIALOG:
693     pvar = (PTInstVar) lParam;
694     pvar->auth_state.auth_dialog = dlg;
695     SetWindowLong(dlg, DWL_USER, lParam);
696    
697     init_auth_dlg(pvar, dlg);
698    
699     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
700     GetObject(font, sizeof(LOGFONT), &logfont);
701     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthFont, pvar)) {
702     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
703     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
704     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
705     SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
706     SendDlgItemMessage(dlg, IDC_SSHPASSWORDCAPTION, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
707     SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
708     SendDlgItemMessage(dlg, IDC_REMEMBER_PASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
709     SendDlgItemMessage(dlg, IDC_FORWARD_AGENT, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
710     SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
711     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
712     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
713     SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
714     SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
715     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
716     SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
717     SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
718     SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
719     SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
720     SendDlgItemMessage(dlg, IDC_SSHUSEPAGEANT, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
721     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
722     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthFont, MAKELPARAM(TRUE,0));
723     }
724     else {
725     DlgAuthFont = NULL;
726     }
727    
728     // SSH2 autologin���L�����������A�^�C�}���d�|�����B (2004.12.1 yutaka)
729     if (pvar->ssh2_autologin == 1) {
730     autologin_sent_none = FALSE;
731     SetTimer(dlg, IDC_TIMER1, autologin_timeout, 0);
732     }
733     else {
734     // �T�|�[�g�������������\�b�h���`�F�b�N�����B(2007.9.24 maya)
735     // �������L�����A�����������s�����������A���[�U�����m����������
736     if (pvar->session_settings.CheckAuthListFirst &&
737     !pvar->tryed_ssh2_authlist &&
738     GetWindowTextLength(GetDlgItem(dlg, IDC_SSHUSERNAME)) > 0) {
739     SetTimer(dlg, IDC_TIMER2, autologin_timeout, 0);
740     }
741 maya 3342 // /auth=challenge �� /ask4passwd ���w���������������[�U�����m����������
742     // �������AOK �{�^���������� TIS auth �_�C�A���O���o��
743     else if (pvar->ssh2_authmethod == SSH_AUTH_TIS &&
744     pvar->ask4passwd &&
745     GetWindowTextLength(GetDlgItem(dlg, IDC_SSHUSERNAME)) > 0) {
746 maya 3227 SetTimer(dlg, IDC_TIMER3, autologin_timeout, 0);
747     }
748     }
749     return FALSE; /* because we set the focus */
750    
751     case WM_TIMER:
752     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
753     // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2004.12.16 yutaka)
754     if (wParam == IDC_TIMER1) {
755     // �������O�C��������
756     if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
757     (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
758     if (SSHv2(pvar) &&
759     pvar->session_settings.CheckAuthListFirst &&
760     !pvar->tryed_ssh2_authlist) {
761     if (!autologin_sent_none) {
762 maya 3342 autologin_sent_none = TRUE;
763    
764 maya 3336 // �_�C�A���O�����[�U������������
765     if (pvar->auth_state.user == NULL) {
766     pvar->auth_state.user =
767     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
768     }
769    
770 maya 3342 // CheckAuthListFirst �� TRUE �������� AuthList ���A����������������
771     // IDOK �����������i�����������A�F�����\�b�h none ������ (2008.10.12 maya)
772 maya 3227 do_SSH2_userauth(pvar);
773     }
774     //else {
775     // none �������������A����������������
776     //}
777     }
778     else {
779 maya 3342 // SSH1 ������
780     // ������ CheckAuthListFirst �� FALSE ������
781     // ������ CheckAuthListFirst TRUE ���Aauthlist ���A������������
782 maya 3346 KillTimer(dlg, IDC_TIMER1);
783 maya 3342
784     // �_�C�A���O�����[�U������������
785     if (pvar->auth_state.user == NULL) {
786     pvar->auth_state.user =
787     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
788     }
789    
790 maya 3227 SendMessage(dlg, WM_COMMAND, IDOK, 0);
791     }
792     }
793     }
794     else if (wParam == IDC_TIMER2) {
795     // authlist ����������
796 maya 3346 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
797     (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
798     if (SSHv2(pvar)) {
799 maya 3227 KillTimer(dlg, IDC_TIMER2);
800    
801     // �_�C�A���O�����[�U������������
802     if (pvar->auth_state.user == NULL) {
803     pvar->auth_state.user =
804     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
805     }
806    
807     // ���[�U�������X��������
808     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
809    
810 maya 3342 // �F�����\�b�h none ������
811 maya 3227 do_SSH2_userauth(pvar);
812    
813 maya 3342 // TIS �p�� OK �����������F�������s������������������
814 maya 3227 // Unexpected SSH2 message �������B
815     }
816 maya 3346 else if (SSHv1(pvar)) {
817     KillTimer(dlg, IDC_TIMER2);
818    
819     // TIS �p�� OK ������
820     if (pvar->ssh2_authmethod == SSH_AUTH_TIS) {
821     SendMessage(dlg, WM_COMMAND, IDOK, 0);
822     }
823     // SSH1 �����F�����\�b�h none ����������
824 maya 3227 }
825 maya 3346 // �v���g�R���o�[�W�����m���O������������
826 maya 3227 }
827     }
828     else if (wParam == IDC_TIMER3) {
829 maya 3346 if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
830     (pvar->ssh_state.status_flags & STATUS_HOST_OK)) {
831     if (SSHv2(pvar) || SSHv1(pvar)) {
832     KillTimer(dlg, IDC_TIMER3);
833    
834     // TIS �p�� OK ������
835     SendMessage(dlg, WM_COMMAND, IDOK, 0);
836 maya 3227 }
837 maya 3346 // �v���g�R���o�[�W�����m���O������������
838 maya 3227 }
839     }
840     return FALSE;
841    
842     case WM_COMMAND:
843     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
844    
845     switch (LOWORD(wParam)) {
846     case IDOK:
847 yutakapon 5562 // �F�������T�[�o�������f�������������A�L�����Z�������������B(2014.3.31 yutaka)
848     if (!pvar->cv->Ready) {
849     goto canceled;
850     }
851    
852 maya 3227 // �F�������������������A�F���f�[�^�����M�����B�����������A�������B(2001.1.25 yutaka)
853     if (pvar->userauth_retry_count == 0 &&
854     ((pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) ||
855     !(pvar->ssh_state.status_flags & STATUS_HOST_OK))) {
856     return FALSE;
857     }
858     else if (SSHv2(pvar) &&
859     pvar->session_settings.CheckAuthListFirst &&
860     !pvar->tryed_ssh2_authlist) {
861     // CheckAuthListFirst ���L�����F������������������������
862     // OK �������������������� (2008.10.4 maya)
863     return FALSE;
864     }
865    
866     return end_auth_dlg(pvar, dlg);
867    
868     case IDCANCEL: /* kill the connection */
869 yutakapon 5562 canceled:
870 maya 3227 pvar->auth_state.auth_dialog = NULL;
871 maya 5678 notify_closed_connection(pvar, "authentication cancelled");
872 maya 3227 EndDialog(dlg, 0);
873    
874     if (DlgAuthFont != NULL) {
875     DeleteObject(DlgAuthFont);
876     }
877    
878     return TRUE;
879    
880     case IDC_SSHUSERNAME:
881     // ���[�U�����t�H�[�J�X������������ (2007.9.29 maya)
882     if (!(pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) &&
883     (pvar->ssh_state.status_flags & STATUS_HOST_OK) &&
884     HIWORD(wParam) == EN_KILLFOCUS) {
885     // �������L���������������s��������������
886     if (SSHv2(pvar) &&
887     pvar->session_settings.CheckAuthListFirst &&
888     !pvar->tryed_ssh2_authlist) {
889     // �_�C�A���O�����[�U�������f
890     if (pvar->auth_state.user == NULL) {
891     pvar->auth_state.user =
892     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
893     }
894    
895     // ���[�U���������������������`�F�b�N����
896     if (strlen(pvar->auth_state.user) == 0) {
897     return FALSE;
898     }
899    
900     // ���[�U�������X��������
901     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
902    
903 maya 3342 // �F�����\�b�h none ������
904 maya 3227 do_SSH2_userauth(pvar);
905     return TRUE;
906     }
907     }
908    
909     return FALSE;
910    
911     case IDC_SSHUSEPASSWORD:
912     case IDC_SSHUSERSA:
913     case IDC_SSHUSERHOSTS:
914     case IDC_SSHUSETIS:
915     case IDC_SSHUSEPAGEANT:
916     set_auth_options_status(dlg, LOWORD(wParam));
917     return TRUE;
918    
919     case IDC_CHOOSERSAFILE:
920     choose_RSA_key_file(dlg, pvar);
921     return TRUE;
922    
923     case IDC_CHOOSEHOSTRSAFILE:
924     choose_host_RSA_key_file(dlg, pvar);
925     return TRUE;
926    
927     case IDC_FORWARD_AGENT:
928     // �����Z�b�V�������������f������ (2008.12.4 maya)
929     pvar->session_settings.ForwardAgent = IsDlgButtonChecked(dlg, IDC_FORWARD_AGENT);
930     return TRUE;
931    
932     default:
933     return FALSE;
934     }
935    
936     default:
937     return FALSE;
938     }
939     }
940    
941 doda 6801 char *AUTH_get_user_name(PTInstVar pvar)
942 maya 3227 {
943     return pvar->auth_state.user;
944     }
945    
946     int AUTH_set_supported_auth_types(PTInstVar pvar, int types)
947     {
948 doda 6809 logprintf(LOG_LEVEL_VERBOSE, "Server reports supported authentication method mask = %d", types);
949 maya 3227
950     if (SSHv1(pvar)) {
951     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
952     | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
953     | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
954     } else {
955     // for SSH2(yutaka)
956     // types &= (1 << SSH_AUTH_PASSWORD);
957     // ���J���F�����L�������� (2004.12.18 yutaka)
958     // TIS�������BSSH2����keyboard-interactive�����������B(2005.3.12 yutaka)
959     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
960     | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
961     }
962     pvar->auth_state.supported_types = types;
963    
964     if (types == 0) {
965     UTIL_get_lang_msg("MSG_NOAUTHMETHOD_ERROR", pvar,
966     "Server does not support any of the authentication options\n"
967     "provided by TTSSH. This connection will now close.");
968 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
969 maya 3227 return 0;
970     } else {
971     if (pvar->auth_state.auth_dialog != NULL) {
972 doda 6809 update_server_supported_types(pvar, pvar->auth_state.auth_dialog);
973 maya 3227 }
974    
975     return 1;
976     }
977     }
978    
979     static void start_user_auth(PTInstVar pvar)
980     {
981     // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
982     PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
983     (LPARAM) NULL);
984     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
985     }
986    
987     static void try_default_auth(PTInstVar pvar)
988     {
989     if (pvar->session_settings.TryDefaultAuth) {
990     switch (pvar->session_settings.DefaultAuthMethod) {
991     case SSH_AUTH_RSA:{
992     BOOL invalid_passphrase;
993     char password[] = "";
994    
995     pvar->auth_state.cur_cred.key_pair
996     =
997     KEYFILES_read_private_key(pvar,
998     pvar->session_settings.
999     DefaultRSAPrivateKeyFile,
1000     password,
1001     &invalid_passphrase, TRUE);
1002     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1003     return;
1004     } else {
1005     pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1006     }
1007     break;
1008     }
1009    
1010     case SSH_AUTH_RHOSTS:
1011     if (pvar->session_settings.
1012     DefaultRhostsHostPrivateKeyFile[0] != 0) {
1013     BOOL invalid_passphrase;
1014     char password[] = "";
1015    
1016     pvar->auth_state.cur_cred.key_pair
1017     =
1018     KEYFILES_read_private_key(pvar,
1019     pvar->session_settings.
1020     DefaultRhostsHostPrivateKeyFile,
1021     password,
1022     &invalid_passphrase, TRUE);
1023     if (pvar->auth_state.cur_cred.key_pair == NULL) {
1024     return;
1025     } else {
1026     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
1027     }
1028     } else {
1029     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
1030     }
1031    
1032     pvar->auth_state.cur_cred.rhosts_client_user =
1033     _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
1034     break;
1035    
1036     case SSH_AUTH_PAGEANT:
1037     pvar->auth_state.cur_cred.method = SSH_AUTH_PAGEANT;
1038     break;
1039    
1040     case SSH_AUTH_PASSWORD:
1041     pvar->auth_state.cur_cred.password = _strdup("");
1042     pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1043     break;
1044    
1045     case SSH_AUTH_TIS:
1046     default:
1047     return;
1048     }
1049    
1050     pvar->auth_state.user =
1051     _strdup(pvar->session_settings.DefaultUserName);
1052     }
1053     }
1054    
1055     void AUTH_notify_end_error(PTInstVar pvar)
1056     {
1057     if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
1058     start_user_auth(pvar);
1059     pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
1060     }
1061     }
1062    
1063     void AUTH_advance_to_next_cred(PTInstVar pvar)
1064     {
1065     pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
1066    
1067     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1068     try_default_auth(pvar);
1069    
1070     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1071     if (pvar->err_msg != NULL) {
1072     pvar->auth_state.flags |=
1073     AUTH_START_USER_AUTH_ON_ERROR_END;
1074     } else {
1075     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1076     // �R�}���h���C���w������������
1077     start_user_auth(pvar);
1078     }
1079     }
1080     } else {
1081     // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1082     // �R�}���h���C���w������(/auth=xxxx)������
1083     start_user_auth(pvar);
1084     }
1085     }
1086    
1087     static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
1088     {
1089     char uimsg[MAX_UIMSG];
1090    
1091     GetWindowText(dlg, uimsg, sizeof(uimsg));
1092     UTIL_get_lang_msg("DLG_TIS_TITLE", pvar, uimsg);
1093     SetWindowText(dlg, pvar->ts->UIMsg);
1094     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1095     UTIL_get_lang_msg("DLG_TIS_BANNER", pvar, uimsg);
1096     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1097     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1098     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1099     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1100     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1101     UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
1102     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1103    
1104     init_auth_machine_banner(pvar, dlg);
1105     init_password_control(dlg);
1106    
1107     if (pvar->auth_state.TIS_prompt != NULL) {
1108     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
1109     pvar->auth_state.TIS_prompt[10000] = 0;
1110     }
1111     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
1112     pvar->auth_state.TIS_prompt);
1113     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1114     }
1115     }
1116    
1117     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
1118     {
1119 doda 6801 char *password =
1120 maya 3227 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
1121    
1122     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1123     pvar->auth_state.cur_cred.password = password;
1124     pvar->auth_state.auth_dialog = NULL;
1125    
1126     // add
1127     if (SSHv2(pvar)) {
1128     pvar->keyboard_interactive_password_input = 1;
1129     handle_SSH2_userauth_inforeq(pvar);
1130     }
1131    
1132     SSH_notify_cred(pvar);
1133    
1134     EndDialog(dlg, 1);
1135     return TRUE;
1136     }
1137    
1138     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
1139     LPARAM lParam)
1140     {
1141     PTInstVar pvar;
1142     LOGFONT logfont;
1143     HFONT font;
1144    
1145     switch (msg) {
1146     case WM_INITDIALOG:
1147     pvar = (PTInstVar) lParam;
1148     pvar->auth_state.auth_dialog = dlg;
1149     SetWindowLong(dlg, DWL_USER, lParam);
1150    
1151     init_TIS_dlg(pvar, dlg);
1152    
1153     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1154     GetObject(font, sizeof(LOGFONT), &logfont);
1155     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1156     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1157     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1158     SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1159     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1160     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1161     }
1162     else {
1163     DlgTisFont = NULL;
1164     }
1165    
1166     // /auth=challenge ������ (2007.10.5 maya)
1167     if (pvar->ssh2_autologin == 1) {
1168     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
1169     SendMessage(dlg, WM_COMMAND, IDOK, 0);
1170     }
1171    
1172     return FALSE; /* because we set the focus */
1173    
1174     case WM_COMMAND:
1175     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1176    
1177     switch (LOWORD(wParam)) {
1178     case IDOK:
1179     if (DlgTisFont != NULL) {
1180     DeleteObject(DlgTisFont);
1181     }
1182    
1183     return end_TIS_dlg(pvar, dlg);
1184    
1185     case IDCANCEL: /* kill the connection */
1186     pvar->auth_state.auth_dialog = NULL;
1187 maya 5678 notify_closed_connection(pvar, "authentication cancelled");
1188 maya 3227 EndDialog(dlg, 0);
1189    
1190     if (DlgTisFont != NULL) {
1191     DeleteObject(DlgTisFont);
1192     }
1193    
1194     return TRUE;
1195    
1196     default:
1197     return FALSE;
1198     }
1199    
1200     default:
1201     return FALSE;
1202     }
1203     }
1204    
1205     void AUTH_do_cred_dialog(PTInstVar pvar)
1206     {
1207     if (pvar->auth_state.auth_dialog == NULL) {
1208     HWND cur_active = GetActiveWindow();
1209     DLGPROC dlg_proc;
1210     LPCTSTR dialog_template;
1211    
1212     switch (pvar->auth_state.mode) {
1213     case TIS_AUTH_MODE:
1214     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1215     dlg_proc = TIS_dlg_proc;
1216     break;
1217     case GENERIC_AUTH_MODE:
1218     default:
1219     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1220     dlg_proc = auth_dlg_proc;
1221     }
1222    
1223     if (!DialogBoxParam(hInst, dialog_template,
1224     cur_active !=
1225     NULL ? cur_active : pvar->NotificationWindow,
1226     dlg_proc, (LPARAM) pvar) == -1) {
1227     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar,
1228     "Unable to display authentication dialog box.\n"
1229     "Connection terminated.");
1230 maya 5678 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
1231 maya 3227 }
1232     }
1233     }
1234    
1235     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1236     {
1237     char uimsg[MAX_UIMSG];
1238    
1239     GetWindowText(dlg, uimsg, sizeof(uimsg));
1240     UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar, uimsg);
1241     SetWindowText(dlg, pvar->ts->UIMsg);
1242     GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1243     UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar, uimsg);
1244     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1245     GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
1246     UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar, uimsg);
1247     SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1248     GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
1249     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar, uimsg);
1250     SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1251     GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
1252     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar, uimsg);
1253     SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1254     GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
1255     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar, uimsg);
1256     SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1257     GetDlgItemText(dlg, IDC_SSHUSETIS, uimsg, sizeof(uimsg));
1258     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar, uimsg);
1259     SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1260     GetDlgItemText(dlg, IDC_SSHUSEPAGEANT, uimsg, sizeof(uimsg));
1261     UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PAGEANT", pvar, uimsg);
1262     SetDlgItemText(dlg, IDC_SSHUSEPAGEANT, pvar->ts->UIMsg);
1263     GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
1264     UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
1265     SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1266     GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
1267     UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
1268     SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1269     GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
1270     UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
1271     SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1272     GetDlgItemText(dlg, IDC_CHECKAUTH, uimsg, sizeof(uimsg));
1273     UTIL_get_lang_msg("DLG_AUTHSETUP_CHECKAUTH", pvar, uimsg);
1274     SetDlgItemText(dlg, IDC_CHECKAUTH, pvar->ts->UIMsg);
1275     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1276     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1277     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1278     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1279     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1280     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1281    
1282     switch (pvar->settings.DefaultAuthMethod) {
1283     case SSH_AUTH_RSA:
1284     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1285     IDC_SSHUSERSA);
1286     break;
1287     case SSH_AUTH_RHOSTS:
1288     case SSH_AUTH_RHOSTS_RSA:
1289     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1290     IDC_SSHUSERHOSTS);
1291     break;
1292     case SSH_AUTH_TIS:
1293     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1294     IDC_SSHUSETIS);
1295     break;
1296     case SSH_AUTH_PAGEANT:
1297     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1298     IDC_SSHUSEPAGEANT);
1299     break;
1300     case SSH_AUTH_PASSWORD:
1301     default:
1302     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1303     IDC_SSHUSEPASSWORD);
1304     }
1305    
1306     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1307     SetDlgItemText(dlg, IDC_RSAFILENAME,
1308     pvar->settings.DefaultRSAPrivateKeyFile);
1309     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1310     pvar->settings.DefaultRhostsHostPrivateKeyFile);
1311     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1312     pvar->settings.DefaultRhostsLocalUserName);
1313    
1314     if (pvar->settings.CheckAuthListFirst) {
1315     CheckDlgButton(dlg, IDC_CHECKAUTH, TRUE);
1316     }
1317     }
1318    
1319     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1320     {
1321     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1322     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1323     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1324     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1325     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1326     } else {
1327     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1328     }
1329     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1330     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1331     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSEPAGEANT)) {
1332     pvar->settings.DefaultAuthMethod = SSH_AUTH_PAGEANT;
1333     } else {
1334     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1335     }
1336    
1337     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1338     sizeof(pvar->settings.DefaultUserName));
1339     GetDlgItemText(dlg, IDC_RSAFILENAME,
1340     pvar->settings.DefaultRSAPrivateKeyFile,
1341     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1342     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1343     pvar->settings.DefaultRhostsHostPrivateKeyFile,
1344     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1345     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1346     pvar->settings.DefaultRhostsLocalUserName,
1347     sizeof(pvar->settings.DefaultRhostsLocalUserName));
1348    
1349     if (IsDlgButtonChecked(dlg, IDC_CHECKAUTH)) {
1350     pvar->settings.CheckAuthListFirst = TRUE;
1351     }
1352     else {
1353     pvar->settings.CheckAuthListFirst = FALSE;
1354     }
1355    
1356     EndDialog(dlg, 1);
1357     return TRUE;
1358     }
1359    
1360     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1361     WPARAM wParam, LPARAM lParam)
1362     {
1363     PTInstVar pvar;
1364     LOGFONT logfont;
1365     HFONT font;
1366    
1367     switch (msg) {
1368     case WM_INITDIALOG:
1369     pvar = (PTInstVar) lParam;
1370     SetWindowLong(dlg, DWL_USER, lParam);
1371    
1372     init_default_auth_dlg(pvar, dlg);
1373    
1374     font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1375     GetObject(font, sizeof(LOGFONT), &logfont);
1376     if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1377     SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1378     SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1379     SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1380     SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1381     SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1382     SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1383     SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1384     SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1385     SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1386     SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1387     SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1388     SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1389     SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1390     SendDlgItemMessage(dlg, IDC_SSHUSEPAGEANT, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1391     SendDlgItemMessage(dlg, IDC_CHECKAUTH, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1392     SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1393     SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1394     }
1395     else {
1396     DlgAuthSetupFont = NULL;
1397     }
1398    
1399     return TRUE; /* because we do not set the focus */
1400    
1401     case WM_COMMAND:
1402     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1403    
1404     switch (LOWORD(wParam)) {
1405     case IDOK:
1406    
1407     if (DlgAuthSetupFont != NULL) {
1408     DeleteObject(DlgAuthSetupFont);
1409     }
1410    
1411     return end_default_auth_dlg(pvar, dlg);
1412    
1413     case IDCANCEL:
1414     EndDialog(dlg, 0);
1415    
1416     if (DlgAuthSetupFont != NULL) {
1417     DeleteObject(DlgAuthSetupFont);
1418     }
1419    
1420     return TRUE;
1421    
1422     case IDC_CHOOSERSAFILE:
1423     choose_RSA_key_file(dlg, pvar);
1424     return TRUE;
1425    
1426     case IDC_CHOOSEHOSTRSAFILE:
1427     choose_host_RSA_key_file(dlg, pvar);
1428     return TRUE;
1429    
1430     default:
1431     return FALSE;
1432     }
1433    
1434     default:
1435     return FALSE;
1436     }
1437     }
1438    
1439     void AUTH_init(PTInstVar pvar)
1440     {
1441     pvar->auth_state.failed_method = SSH_AUTH_NONE;
1442     pvar->auth_state.auth_dialog = NULL;
1443     pvar->auth_state.user = NULL;
1444     pvar->auth_state.flags = 0;
1445     pvar->auth_state.TIS_prompt = NULL;
1446     pvar->auth_state.supported_types = 0;
1447     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1448     pvar->auth_state.cur_cred.password = NULL;
1449     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1450     pvar->auth_state.cur_cred.key_pair = NULL;
1451     AUTH_set_generic_mode(pvar);
1452     }
1453    
1454     void AUTH_set_generic_mode(PTInstVar pvar)
1455     {
1456     pvar->auth_state.mode = GENERIC_AUTH_MODE;
1457     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1458     }
1459    
1460 doda 6801 void AUTH_set_TIS_mode(PTInstVar pvar, char *prompt, int len)
1461 maya 3227 {
1462     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1463     pvar->auth_state.mode = TIS_AUTH_MODE;
1464    
1465     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1466     pvar->auth_state.TIS_prompt = malloc(len + 1);
1467     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1468     pvar->auth_state.TIS_prompt[len] = 0;
1469     } else {
1470     AUTH_set_generic_mode(pvar);
1471     }
1472     }
1473    
1474     void AUTH_do_default_cred_dialog(PTInstVar pvar)
1475     {
1476     HWND cur_active = GetActiveWindow();
1477    
1478     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1479     cur_active != NULL ? cur_active
1480     : pvar->NotificationWindow,
1481     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1482     UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar,
1483     "Unable to display authentication setup dialog box.");
1484     notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1485     }
1486     }
1487    
1488     void AUTH_destroy_cur_cred(PTInstVar pvar)
1489     {
1490     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1491     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1492     if (pvar->auth_state.cur_cred.key_pair != NULL) {
1493 maya 4307 key_free(pvar->auth_state.cur_cred.key_pair);
1494 maya 3227 pvar->auth_state.cur_cred.key_pair = NULL;
1495     }
1496     }
1497    
1498 maya 4307 static const char *get_auth_method_name(SSHAuthMethod auth)
1499 maya 3227 {
1500     switch (auth) {
1501     case SSH_AUTH_PASSWORD:
1502     return "password";
1503     case SSH_AUTH_RSA:
1504 maya 5550 return "publickey";
1505 maya 3227 case SSH_AUTH_PAGEANT:
1506 maya 5550 return "publickey";
1507 maya 3227 case SSH_AUTH_RHOSTS:
1508     return "rhosts";
1509     case SSH_AUTH_RHOSTS_RSA:
1510     return "rhosts with RSA";
1511     case SSH_AUTH_TIS:
1512     return "challenge/response (TIS)";
1513     default:
1514     return "unknown method";
1515     }
1516     }
1517    
1518 doda 6801 void AUTH_get_auth_info(PTInstVar pvar, char *dest, int len)
1519 maya 3227 {
1520 maya 4307 const char *method = "unknown";
1521 yutakapon 5545 char buf[256];
1522 maya 3227
1523     if (pvar->auth_state.user == NULL) {
1524     strncpy_s(dest, len, "None", _TRUNCATE);
1525     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1526     if (SSHv1(pvar)) {
1527     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1528 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1529     pvar->auth_state.user,
1530 maya 3227 get_auth_method_name(pvar->auth_state.cur_cred.method));
1531    
1532 maya 5550 if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1533     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1534     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1535     "RSA");
1536     strncat_s(dest, len, buf, _TRUNCATE);
1537     }
1538     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1539     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1540     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1541     "RSA");
1542     strncat_s(dest, len, buf, _TRUNCATE);
1543     }
1544 maya 3227 } else {
1545     // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1546     // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1547     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1548     pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1549     // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1550     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1551     method = "keyboard-interactive";
1552     } else {
1553     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1554     }
1555     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1556 maya 5550 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1557     pvar->auth_state.user, method);
1558     }
1559     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1560     method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1561     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1562     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1563     pvar->auth_state.user,
1564     get_auth_method_name(pvar->auth_state.cur_cred.method));
1565 maya 3227
1566 maya 5550 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1567     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1568     ssh_key_type(pvar->auth_state.cur_cred.key_pair->type));
1569     strncat_s(dest, len, buf, _TRUNCATE);
1570     }
1571     else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1572     int key_len = get_uint32_MSBfirst(pvar->pageant_curkey + 4);
1573     char *s = (char *)malloc(key_len+1);
1574 yutakapon 5545
1575 maya 5550 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1576     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1577     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1578     pvar->auth_state.user,
1579     get_auth_method_name(pvar->auth_state.cur_cred.method));
1580 maya 3227
1581 maya 5550 memcpy(s, pvar->pageant_curkey+4+4, key_len);
1582     s[key_len] = '\0';
1583     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1584     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1585     ssh_key_type(get_keytype_from_name(s)));
1586     strncat_s(dest, len, buf, _TRUNCATE);
1587    
1588     free(s);
1589 maya 3227 }
1590     }
1591    
1592     } else {
1593     UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1594     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1595     get_auth_method_name(pvar->auth_state.failed_method));
1596     }
1597    
1598     dest[len - 1] = 0;
1599     }
1600    
1601     void AUTH_notify_disconnecting(PTInstVar pvar)
1602     {
1603     if (pvar->auth_state.auth_dialog != NULL) {
1604     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1605     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1606     EnableWindow(pvar->NotificationWindow, TRUE);
1607     }
1608     }
1609    
1610     void AUTH_end(PTInstVar pvar)
1611     {
1612     destroy_malloced_string(&pvar->auth_state.user);
1613     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1614    
1615     AUTH_destroy_cur_cred(pvar);
1616     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help