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 7101 - (hide annotations) (download) (as text)
Thu Apr 19 11:58:00 2018 UTC (5 years, 11 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57097 byte(s) 
keyboard-interactive 認証の表記を修正 #38004

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