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 5678 - (show annotations) (download) (as text)
Sat Oct 4 03:39:24 2014 UTC (9 years, 6 months ago) by maya
Original Path: trunk/ttssh2/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 57227 byte(s) 
SSH2 切断シーケンスの調整
・shell のチャネルが MSG_CHANNEL_CLOSE を受け取ったとき
  MSG_DISCONNECT を送り、MSG_CHANNEL_CLOSE を送り、socket を切断する
  ↓
  MSG_CHANNEL_CLOSE を送り、MSG_DISCONNECT を送り、socket を切断する
・認証中にユーザがキャンセルしたとき
  MSG_CHANNEL_CLOSE を送り、socket を切断する
  ↓
  MSG_DISCONNECT を送り、socket を切断する
・MSG_DISCONNECT を受け取ったとき
  MSG_CHANNEL_CLOSE を送り、socket を切断する
    ↓
  socket を切断する
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 FAR * FAR * str)
52 {
53 if (*str != NULL) {
54 memset(*str, 0, 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 FAR *) 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 FAR *alloc_control_text(HWND ctl)
356 {
357 int len = GetWindowTextLength(ctl);
358 char FAR *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 FAR * 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 FAR *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 buf[2048];
446 int file_ctl_ID =
447 method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
448
449 buf[0] = 0;
450 GetDlgItemText(dlg, file_ctl_ID, buf, sizeof(buf));
451 if (buf[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, buf, 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(buf, &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 FAR *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 char buf[1024];
947
948 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
949 "Server reports supported authentication method mask = %d",
950 types);
951 buf[sizeof(buf) - 1] = 0;
952 notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
953
954 if (SSHv1(pvar)) {
955 types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
956 | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
957 | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
958 } else {
959 // for SSH2(yutaka)
960 // types &= (1 << SSH_AUTH_PASSWORD);
961 // ���J���F�����L�������� (2004.12.18 yutaka)
962 // TIS�������BSSH2����keyboard-interactive�����������B(2005.3.12 yutaka)
963 types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
964 | (1 << SSH_AUTH_TIS) | (1 << SSH_AUTH_PAGEANT);
965 }
966 pvar->auth_state.supported_types = types;
967
968 if (types == 0) {
969 UTIL_get_lang_msg("MSG_NOAUTHMETHOD_ERROR", pvar,
970 "Server does not support any of the authentication options\n"
971 "provided by TTSSH. This connection will now close.");
972 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
973 return 0;
974 } else {
975 if (pvar->auth_state.auth_dialog != NULL) {
976 update_server_supported_types(pvar,
977 pvar->auth_state.auth_dialog);
978 }
979
980 return 1;
981 }
982 }
983
984 static void start_user_auth(PTInstVar pvar)
985 {
986 // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
987 PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
988 (LPARAM) NULL);
989 pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
990 }
991
992 static void try_default_auth(PTInstVar pvar)
993 {
994 if (pvar->session_settings.TryDefaultAuth) {
995 switch (pvar->session_settings.DefaultAuthMethod) {
996 case SSH_AUTH_RSA:{
997 BOOL invalid_passphrase;
998 char password[] = "";
999
1000 pvar->auth_state.cur_cred.key_pair
1001 =
1002 KEYFILES_read_private_key(pvar,
1003 pvar->session_settings.
1004 DefaultRSAPrivateKeyFile,
1005 password,
1006 &invalid_passphrase, TRUE);
1007 if (pvar->auth_state.cur_cred.key_pair == NULL) {
1008 return;
1009 } else {
1010 pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1011 }
1012 break;
1013 }
1014
1015 case SSH_AUTH_RHOSTS:
1016 if (pvar->session_settings.
1017 DefaultRhostsHostPrivateKeyFile[0] != 0) {
1018 BOOL invalid_passphrase;
1019 char password[] = "";
1020
1021 pvar->auth_state.cur_cred.key_pair
1022 =
1023 KEYFILES_read_private_key(pvar,
1024 pvar->session_settings.
1025 DefaultRhostsHostPrivateKeyFile,
1026 password,
1027 &invalid_passphrase, TRUE);
1028 if (pvar->auth_state.cur_cred.key_pair == NULL) {
1029 return;
1030 } else {
1031 pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
1032 }
1033 } else {
1034 pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
1035 }
1036
1037 pvar->auth_state.cur_cred.rhosts_client_user =
1038 _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
1039 break;
1040
1041 case SSH_AUTH_PAGEANT:
1042 pvar->auth_state.cur_cred.method = SSH_AUTH_PAGEANT;
1043 break;
1044
1045 case SSH_AUTH_PASSWORD:
1046 pvar->auth_state.cur_cred.password = _strdup("");
1047 pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1048 break;
1049
1050 case SSH_AUTH_TIS:
1051 default:
1052 return;
1053 }
1054
1055 pvar->auth_state.user =
1056 _strdup(pvar->session_settings.DefaultUserName);
1057 }
1058 }
1059
1060 void AUTH_notify_end_error(PTInstVar pvar)
1061 {
1062 if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
1063 start_user_auth(pvar);
1064 pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
1065 }
1066 }
1067
1068 void AUTH_advance_to_next_cred(PTInstVar pvar)
1069 {
1070 pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
1071
1072 if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1073 try_default_auth(pvar);
1074
1075 if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
1076 if (pvar->err_msg != NULL) {
1077 pvar->auth_state.flags |=
1078 AUTH_START_USER_AUTH_ON_ERROR_END;
1079 } else {
1080 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1081 // �R�}���h���C���w������������
1082 start_user_auth(pvar);
1083 }
1084 }
1085 } else {
1086 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
1087 // �R�}���h���C���w������(/auth=xxxx)������
1088 start_user_auth(pvar);
1089 }
1090 }
1091
1092 static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
1093 {
1094 char uimsg[MAX_UIMSG];
1095
1096 GetWindowText(dlg, uimsg, sizeof(uimsg));
1097 UTIL_get_lang_msg("DLG_TIS_TITLE", pvar, uimsg);
1098 SetWindowText(dlg, pvar->ts->UIMsg);
1099 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1100 UTIL_get_lang_msg("DLG_TIS_BANNER", pvar, uimsg);
1101 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1102 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1103 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1104 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1105 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1106 UTIL_get_lang_msg("BTN_DISCONNECT", pvar, uimsg);
1107 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1108
1109 init_auth_machine_banner(pvar, dlg);
1110 init_password_control(dlg);
1111
1112 if (pvar->auth_state.TIS_prompt != NULL) {
1113 if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
1114 pvar->auth_state.TIS_prompt[10000] = 0;
1115 }
1116 SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
1117 pvar->auth_state.TIS_prompt);
1118 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1119 }
1120 }
1121
1122 static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
1123 {
1124 char FAR *password =
1125 alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
1126
1127 pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1128 pvar->auth_state.cur_cred.password = password;
1129 pvar->auth_state.auth_dialog = NULL;
1130
1131 // add
1132 if (SSHv2(pvar)) {
1133 pvar->keyboard_interactive_password_input = 1;
1134 handle_SSH2_userauth_inforeq(pvar);
1135 }
1136
1137 SSH_notify_cred(pvar);
1138
1139 EndDialog(dlg, 1);
1140 return TRUE;
1141 }
1142
1143 static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
1144 LPARAM lParam)
1145 {
1146 PTInstVar pvar;
1147 LOGFONT logfont;
1148 HFONT font;
1149
1150 switch (msg) {
1151 case WM_INITDIALOG:
1152 pvar = (PTInstVar) lParam;
1153 pvar->auth_state.auth_dialog = dlg;
1154 SetWindowLong(dlg, DWL_USER, lParam);
1155
1156 init_TIS_dlg(pvar, dlg);
1157
1158 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1159 GetObject(font, sizeof(LOGFONT), &logfont);
1160 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgTisFont, pvar)) {
1161 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1162 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER2, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1163 SendDlgItemMessage(dlg, IDC_SSHPASSWORD, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1164 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1165 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgTisFont, MAKELPARAM(TRUE,0));
1166 }
1167 else {
1168 DlgTisFont = NULL;
1169 }
1170
1171 // /auth=challenge ������ (2007.10.5 maya)
1172 if (pvar->ssh2_autologin == 1) {
1173 SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
1174 SendMessage(dlg, WM_COMMAND, IDOK, 0);
1175 }
1176
1177 return FALSE; /* because we set the focus */
1178
1179 case WM_COMMAND:
1180 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1181
1182 switch (LOWORD(wParam)) {
1183 case IDOK:
1184 if (DlgTisFont != NULL) {
1185 DeleteObject(DlgTisFont);
1186 }
1187
1188 return end_TIS_dlg(pvar, dlg);
1189
1190 case IDCANCEL: /* kill the connection */
1191 pvar->auth_state.auth_dialog = NULL;
1192 notify_closed_connection(pvar, "authentication cancelled");
1193 EndDialog(dlg, 0);
1194
1195 if (DlgTisFont != NULL) {
1196 DeleteObject(DlgTisFont);
1197 }
1198
1199 return TRUE;
1200
1201 default:
1202 return FALSE;
1203 }
1204
1205 default:
1206 return FALSE;
1207 }
1208 }
1209
1210 void AUTH_do_cred_dialog(PTInstVar pvar)
1211 {
1212 if (pvar->auth_state.auth_dialog == NULL) {
1213 HWND cur_active = GetActiveWindow();
1214 DLGPROC dlg_proc;
1215 LPCTSTR dialog_template;
1216
1217 switch (pvar->auth_state.mode) {
1218 case TIS_AUTH_MODE:
1219 dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
1220 dlg_proc = TIS_dlg_proc;
1221 break;
1222 case GENERIC_AUTH_MODE:
1223 default:
1224 dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
1225 dlg_proc = auth_dlg_proc;
1226 }
1227
1228 if (!DialogBoxParam(hInst, dialog_template,
1229 cur_active !=
1230 NULL ? cur_active : pvar->NotificationWindow,
1231 dlg_proc, (LPARAM) pvar) == -1) {
1232 UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTH_ERROR", pvar,
1233 "Unable to display authentication dialog box.\n"
1234 "Connection terminated.");
1235 notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);
1236 }
1237 }
1238 }
1239
1240 static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
1241 {
1242 char uimsg[MAX_UIMSG];
1243
1244 GetWindowText(dlg, uimsg, sizeof(uimsg));
1245 UTIL_get_lang_msg("DLG_AUTHSETUP_TITLE", pvar, uimsg);
1246 SetWindowText(dlg, pvar->ts->UIMsg);
1247 GetDlgItemText(dlg, IDC_SSHAUTHBANNER, uimsg, sizeof(uimsg));
1248 UTIL_get_lang_msg("DLG_AUTHSETUP_BANNER", pvar, uimsg);
1249 SetDlgItemText(dlg, IDC_SSHAUTHBANNER, pvar->ts->UIMsg);
1250 GetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, uimsg, sizeof(uimsg));
1251 UTIL_get_lang_msg("DLG_AUTHSETUP_USERNAME", pvar, uimsg);
1252 SetDlgItemText(dlg, IDC_SSHUSERNAMELABEL, pvar->ts->UIMsg);
1253 GetDlgItemText(dlg, IDC_SSHUSEPASSWORD, uimsg, sizeof(uimsg));
1254 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PASSWORD", pvar, uimsg);
1255 SetDlgItemText(dlg, IDC_SSHUSEPASSWORD, pvar->ts->UIMsg);
1256 GetDlgItemText(dlg, IDC_SSHUSERSA, uimsg, sizeof(uimsg));
1257 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RSA", pvar, uimsg);
1258 SetDlgItemText(dlg, IDC_SSHUSERSA, pvar->ts->UIMsg);
1259 GetDlgItemText(dlg, IDC_SSHUSERHOSTS, uimsg, sizeof(uimsg));
1260 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_RHOST", pvar, uimsg);
1261 SetDlgItemText(dlg, IDC_SSHUSERHOSTS, pvar->ts->UIMsg);
1262 GetDlgItemText(dlg, IDC_SSHUSETIS, uimsg, sizeof(uimsg));
1263 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_CHALLENGE", pvar, uimsg);
1264 SetDlgItemText(dlg, IDC_SSHUSETIS, pvar->ts->UIMsg);
1265 GetDlgItemText(dlg, IDC_SSHUSEPAGEANT, uimsg, sizeof(uimsg));
1266 UTIL_get_lang_msg("DLG_AUTHSETUP_METHOD_PAGEANT", pvar, uimsg);
1267 SetDlgItemText(dlg, IDC_SSHUSEPAGEANT, pvar->ts->UIMsg);
1268 GetDlgItemText(dlg, IDC_CHOOSERSAFILE, uimsg, sizeof(uimsg));
1269 UTIL_get_lang_msg("DLG_AUTH_PRIVATEKEY", pvar, uimsg);
1270 SetDlgItemText(dlg, IDC_CHOOSERSAFILE, pvar->ts->UIMsg);
1271 GetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, uimsg, sizeof(uimsg));
1272 UTIL_get_lang_msg("DLG_AUTH_LOCALUSER", pvar, uimsg);
1273 SetDlgItemText(dlg, IDC_LOCALUSERNAMELABEL, pvar->ts->UIMsg);
1274 GetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, uimsg, sizeof(uimsg));
1275 UTIL_get_lang_msg("DLG_AUTH_HOST_PRIVATEKEY", pvar, uimsg);
1276 SetDlgItemText(dlg, IDC_CHOOSEHOSTRSAFILE, pvar->ts->UIMsg);
1277 GetDlgItemText(dlg, IDC_CHECKAUTH, uimsg, sizeof(uimsg));
1278 UTIL_get_lang_msg("DLG_AUTHSETUP_CHECKAUTH", pvar, uimsg);
1279 SetDlgItemText(dlg, IDC_CHECKAUTH, pvar->ts->UIMsg);
1280 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1281 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1282 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1283 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1284 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1285 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1286
1287 switch (pvar->settings.DefaultAuthMethod) {
1288 case SSH_AUTH_RSA:
1289 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1290 IDC_SSHUSERSA);
1291 break;
1292 case SSH_AUTH_RHOSTS:
1293 case SSH_AUTH_RHOSTS_RSA:
1294 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1295 IDC_SSHUSERHOSTS);
1296 break;
1297 case SSH_AUTH_TIS:
1298 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1299 IDC_SSHUSETIS);
1300 break;
1301 case SSH_AUTH_PAGEANT:
1302 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1303 IDC_SSHUSEPAGEANT);
1304 break;
1305 case SSH_AUTH_PASSWORD:
1306 default:
1307 CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
1308 IDC_SSHUSEPASSWORD);
1309 }
1310
1311 SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
1312 SetDlgItemText(dlg, IDC_RSAFILENAME,
1313 pvar->settings.DefaultRSAPrivateKeyFile);
1314 SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1315 pvar->settings.DefaultRhostsHostPrivateKeyFile);
1316 SetDlgItemText(dlg, IDC_LOCALUSERNAME,
1317 pvar->settings.DefaultRhostsLocalUserName);
1318
1319 if (pvar->settings.CheckAuthListFirst) {
1320 CheckDlgButton(dlg, IDC_CHECKAUTH, TRUE);
1321 }
1322 }
1323
1324 static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
1325 {
1326 if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
1327 pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
1328 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
1329 if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
1330 pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
1331 } else {
1332 pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
1333 }
1334 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
1335 pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
1336 } else if (IsDlgButtonChecked(dlg, IDC_SSHUSEPAGEANT)) {
1337 pvar->settings.DefaultAuthMethod = SSH_AUTH_PAGEANT;
1338 } else {
1339 pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
1340 }
1341
1342 GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
1343 sizeof(pvar->settings.DefaultUserName));
1344 GetDlgItemText(dlg, IDC_RSAFILENAME,
1345 pvar->settings.DefaultRSAPrivateKeyFile,
1346 sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
1347 GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
1348 pvar->settings.DefaultRhostsHostPrivateKeyFile,
1349 sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
1350 GetDlgItemText(dlg, IDC_LOCALUSERNAME,
1351 pvar->settings.DefaultRhostsLocalUserName,
1352 sizeof(pvar->settings.DefaultRhostsLocalUserName));
1353
1354 if (IsDlgButtonChecked(dlg, IDC_CHECKAUTH)) {
1355 pvar->settings.CheckAuthListFirst = TRUE;
1356 }
1357 else {
1358 pvar->settings.CheckAuthListFirst = FALSE;
1359 }
1360
1361 EndDialog(dlg, 1);
1362 return TRUE;
1363 }
1364
1365 static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
1366 WPARAM wParam, LPARAM lParam)
1367 {
1368 PTInstVar pvar;
1369 LOGFONT logfont;
1370 HFONT font;
1371
1372 switch (msg) {
1373 case WM_INITDIALOG:
1374 pvar = (PTInstVar) lParam;
1375 SetWindowLong(dlg, DWL_USER, lParam);
1376
1377 init_default_auth_dlg(pvar, dlg);
1378
1379 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1380 GetObject(font, sizeof(LOGFONT), &logfont);
1381 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAuthSetupFont, pvar)) {
1382 SendDlgItemMessage(dlg, IDC_SSHAUTHBANNER, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1383 SendDlgItemMessage(dlg, IDC_SSHUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1384 SendDlgItemMessage(dlg, IDC_SSHUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1385 SendDlgItemMessage(dlg, IDC_SSHUSEPASSWORD, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1386 SendDlgItemMessage(dlg, IDC_SSHUSERSA, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1387 SendDlgItemMessage(dlg, IDC_CHOOSERSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1388 SendDlgItemMessage(dlg, IDC_RSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1389 SendDlgItemMessage(dlg, IDC_SSHUSERHOSTS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1390 SendDlgItemMessage(dlg, IDC_LOCALUSERNAMELABEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1391 SendDlgItemMessage(dlg, IDC_LOCALUSERNAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1392 SendDlgItemMessage(dlg, IDC_CHOOSEHOSTRSAFILE, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1393 SendDlgItemMessage(dlg, IDC_HOSTRSAFILENAME, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1394 SendDlgItemMessage(dlg, IDC_SSHUSETIS, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1395 SendDlgItemMessage(dlg, IDC_SSHUSEPAGEANT, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1396 SendDlgItemMessage(dlg, IDC_CHECKAUTH, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1397 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1398 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgAuthSetupFont, MAKELPARAM(TRUE,0));
1399 }
1400 else {
1401 DlgAuthSetupFont = NULL;
1402 }
1403
1404 return TRUE; /* because we do not set the focus */
1405
1406 case WM_COMMAND:
1407 pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
1408
1409 switch (LOWORD(wParam)) {
1410 case IDOK:
1411
1412 if (DlgAuthSetupFont != NULL) {
1413 DeleteObject(DlgAuthSetupFont);
1414 }
1415
1416 return end_default_auth_dlg(pvar, dlg);
1417
1418 case IDCANCEL:
1419 EndDialog(dlg, 0);
1420
1421 if (DlgAuthSetupFont != NULL) {
1422 DeleteObject(DlgAuthSetupFont);
1423 }
1424
1425 return TRUE;
1426
1427 case IDC_CHOOSERSAFILE:
1428 choose_RSA_key_file(dlg, pvar);
1429 return TRUE;
1430
1431 case IDC_CHOOSEHOSTRSAFILE:
1432 choose_host_RSA_key_file(dlg, pvar);
1433 return TRUE;
1434
1435 default:
1436 return FALSE;
1437 }
1438
1439 default:
1440 return FALSE;
1441 }
1442 }
1443
1444 void AUTH_init(PTInstVar pvar)
1445 {
1446 pvar->auth_state.failed_method = SSH_AUTH_NONE;
1447 pvar->auth_state.auth_dialog = NULL;
1448 pvar->auth_state.user = NULL;
1449 pvar->auth_state.flags = 0;
1450 pvar->auth_state.TIS_prompt = NULL;
1451 pvar->auth_state.supported_types = 0;
1452 pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
1453 pvar->auth_state.cur_cred.password = NULL;
1454 pvar->auth_state.cur_cred.rhosts_client_user = NULL;
1455 pvar->auth_state.cur_cred.key_pair = NULL;
1456 AUTH_set_generic_mode(pvar);
1457 }
1458
1459 void AUTH_set_generic_mode(PTInstVar pvar)
1460 {
1461 pvar->auth_state.mode = GENERIC_AUTH_MODE;
1462 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1463 }
1464
1465 void AUTH_set_TIS_mode(PTInstVar pvar, char FAR * prompt, int len)
1466 {
1467 if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1468 pvar->auth_state.mode = TIS_AUTH_MODE;
1469
1470 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1471 pvar->auth_state.TIS_prompt = malloc(len + 1);
1472 memcpy(pvar->auth_state.TIS_prompt, prompt, len);
1473 pvar->auth_state.TIS_prompt[len] = 0;
1474 } else {
1475 AUTH_set_generic_mode(pvar);
1476 }
1477 }
1478
1479 void AUTH_do_default_cred_dialog(PTInstVar pvar)
1480 {
1481 HWND cur_active = GetActiveWindow();
1482
1483 if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
1484 cur_active != NULL ? cur_active
1485 : pvar->NotificationWindow,
1486 default_auth_dlg_proc, (LPARAM) pvar) == -1) {
1487 UTIL_get_lang_msg("MSG_CREATEWINDOW_AUTHSETUP_ERROR", pvar,
1488 "Unable to display authentication setup dialog box.");
1489 notify_nonfatal_error(pvar, pvar->ts->UIMsg);
1490 }
1491 }
1492
1493 void AUTH_destroy_cur_cred(PTInstVar pvar)
1494 {
1495 destroy_malloced_string(&pvar->auth_state.cur_cred.password);
1496 destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
1497 if (pvar->auth_state.cur_cred.key_pair != NULL) {
1498 key_free(pvar->auth_state.cur_cred.key_pair);
1499 pvar->auth_state.cur_cred.key_pair = NULL;
1500 }
1501 }
1502
1503 static const char *get_auth_method_name(SSHAuthMethod auth)
1504 {
1505 switch (auth) {
1506 case SSH_AUTH_PASSWORD:
1507 return "password";
1508 case SSH_AUTH_RSA:
1509 return "publickey";
1510 case SSH_AUTH_PAGEANT:
1511 return "publickey";
1512 case SSH_AUTH_RHOSTS:
1513 return "rhosts";
1514 case SSH_AUTH_RHOSTS_RSA:
1515 return "rhosts with RSA";
1516 case SSH_AUTH_TIS:
1517 return "challenge/response (TIS)";
1518 default:
1519 return "unknown method";
1520 }
1521 }
1522
1523 void AUTH_get_auth_info(PTInstVar pvar, char FAR * dest, int len)
1524 {
1525 const char *method = "unknown";
1526 char buf[256];
1527
1528 if (pvar->auth_state.user == NULL) {
1529 strncpy_s(dest, len, "None", _TRUNCATE);
1530 } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
1531 if (SSHv1(pvar)) {
1532 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1533 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1534 pvar->auth_state.user,
1535 get_auth_method_name(pvar->auth_state.cur_cred.method));
1536
1537 if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1538 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1539 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1540 "RSA");
1541 strncat_s(dest, len, buf, _TRUNCATE);
1542 }
1543 else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1544 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1545 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1546 "RSA");
1547 strncat_s(dest, len, buf, _TRUNCATE);
1548 }
1549 } else {
1550 // SSH2:�F�����\�b�h������ (2004.12.23 yutaka)
1551 // keyboard-interactive���\�b�h������ (2005.3.12 yutaka)
1552 if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD ||
1553 pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1554 // keyboard-interactive���\�b�h������ (2005.1.24 yutaka)
1555 if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
1556 method = "keyboard-interactive";
1557 } else {
1558 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1559 }
1560 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1561 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1562 pvar->auth_state.user, method);
1563 }
1564 else if (pvar->auth_state.cur_cred.method == SSH_AUTH_RSA) {
1565 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1566 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1567 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1568 pvar->auth_state.user,
1569 get_auth_method_name(pvar->auth_state.cur_cred.method));
1570
1571 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO2", pvar, " with %s key");
1572 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1573 ssh_key_type(pvar->auth_state.cur_cred.key_pair->type));
1574 strncat_s(dest, len, buf, _TRUNCATE);
1575 }
1576 else if (pvar->auth_state.cur_cred.method == SSH_AUTH_PAGEANT) {
1577 int key_len = get_uint32_MSBfirst(pvar->pageant_curkey + 4);
1578 char *s = (char *)malloc(key_len+1);
1579
1580 method = get_auth_method_name(pvar->auth_state.cur_cred.method);
1581 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1582 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1583 pvar->auth_state.user,
1584 get_auth_method_name(pvar->auth_state.cur_cred.method));
1585
1586 memcpy(s, pvar->pageant_curkey+4+4, key_len);
1587 s[key_len] = '\0';
1588 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO3", pvar, " with %s key from Pageant");
1589 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg,
1590 ssh_key_type(get_keytype_from_name(s)));
1591 strncat_s(dest, len, buf, _TRUNCATE);
1592
1593 free(s);
1594 }
1595 }
1596
1597 } else {
1598 UTIL_get_lang_msg("DLG_ABOUT_AUTH_INFO", pvar, "User '%s', using %s");
1599 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg, pvar->auth_state.user,
1600 get_auth_method_name(pvar->auth_state.failed_method));
1601 }
1602
1603 dest[len - 1] = 0;
1604 }
1605
1606 void AUTH_notify_disconnecting(PTInstVar pvar)
1607 {
1608 if (pvar->auth_state.auth_dialog != NULL) {
1609 PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
1610 /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
1611 EnableWindow(pvar->NotificationWindow, TRUE);
1612 }
1613 }
1614
1615 void AUTH_end(PTInstVar pvar)
1616 {
1617 destroy_malloced_string(&pvar->auth_state.user);
1618 destroy_malloced_string(&pvar->auth_state.TIS_prompt);
1619
1620 AUTH_destroy_cur_cred(pvar);
1621 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help