Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/auth.c

Contents of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/auth.c

Parent Directory Parent Directory | Revision Log Revision Log

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