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 7508 - (hide annotations) (download) (as text)
Sun Mar 24 03:44:58 2019 UTC (5 years ago) by maya
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 59469 byte(s) 
Visual Studio 2005 でビルドできないのを修正

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