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 6809 - (show annotations) (download) (as text)
Mon Jun 19 12:50:42 2017 UTC (6 years, 9 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57040 byte(s) 
ログ関連を見直し。

・_snprintf_s() + notify_verbose_message() を logprintf() に置き換え。
・固定メッセージの notify_verbose_message() を logputs() に置き換え。

pvar を渡す必要が無くなったので、pvar が使えない状況でもログ出力が行える。

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