Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2739 - (hide annotations) (download) (as text)
Wed Dec 1 15:37:49 2004 UTC (19 years, 4 months ago) by yutakakn
Original Path: ttssh2/trunk/ttxssh/auth.c
File MIME type: text/x-csrc
File size: 25165 byte(s) 
SSH2自動ログイン機能を追加。
現状、パスワード認証のみに対応。
・コマンドライン
  /ssh /auth=認証メソッド /user=ユーザ名 /passwd=パスワード
1 yutakakn 2728 /*
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    
32     #include <io.h>
33     #include <fcntl.h>
34     #include <stdlib.h>
35     #include <errno.h>
36    
37     #include "resource.h"
38     #include "keyfiles.h"
39    
40     #define AUTH_START_USER_AUTH_ON_ERROR_END 1
41    
42     #define MAX_AUTH_CONTROL IDC_SSHUSETIS
43    
44     static void destroy_malloced_string(char FAR * FAR * str)
45     {
46     if (*str != NULL) {
47     memset(*str, 0, strlen(*str));
48     free(*str);
49     *str = NULL;
50     }
51     }
52    
53     static int auth_types_to_control_IDs[] = {
54     -1, IDC_SSHUSERHOSTS, IDC_SSHUSERSA, IDC_SSHUSEPASSWORD,
55     IDC_SSHUSERHOSTS, IDC_SSHUSETIS, -1
56     };
57    
58     static LRESULT CALLBACK password_wnd_proc(HWND control, UINT msg,
59     WPARAM wParam, LPARAM lParam)
60     {
61     switch (msg) {
62     case WM_CHAR:
63     if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) {
64     char chars[] = { (char) wParam, 0 };
65    
66     SendMessage(control, EM_REPLACESEL, (WPARAM) TRUE,
67     (LPARAM) (char FAR *) chars);
68     return 0;
69     }
70     }
71    
72     return CallWindowProc((WNDPROC) GetWindowLong(control, GWL_USERDATA),
73     control, msg, wParam, lParam);
74     }
75    
76     static void init_password_control(HWND dlg)
77     {
78     HWND passwordControl = GetDlgItem(dlg, IDC_SSHPASSWORD);
79    
80     SetWindowLong(passwordControl, GWL_USERDATA,
81     SetWindowLong(passwordControl, GWL_WNDPROC,
82     (LONG) password_wnd_proc));
83    
84     SetFocus(passwordControl);
85     }
86    
87     static void set_auth_options_status(HWND dlg, int controlID)
88     {
89     BOOL RSA_enabled = controlID == IDC_SSHUSERSA;
90     BOOL rhosts_enabled = controlID == IDC_SSHUSERHOSTS;
91     BOOL TIS_enabled = controlID == IDC_SSHUSETIS;
92     int i;
93    
94     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, controlID);
95    
96     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), !TIS_enabled);
97     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), !TIS_enabled);
98    
99     for (i = IDC_CHOOSERSAFILE; i <= IDC_RSAFILENAME; i++) {
100     EnableWindow(GetDlgItem(dlg, i), RSA_enabled);
101     }
102    
103     for (i = IDC_LOCALUSERNAMELABEL; i <= IDC_HOSTRSAFILENAME; i++) {
104     EnableWindow(GetDlgItem(dlg, i), rhosts_enabled);
105     }
106     }
107    
108     static void init_auth_machine_banner(PTInstVar pvar, HWND dlg)
109     {
110     char buf[1024] = "Logging in to ";
111    
112     if (strlen(buf) + strlen(SSH_get_host_name(pvar)) < sizeof(buf) - 2) {
113     strcat(buf, SSH_get_host_name(pvar));
114     }
115     SetDlgItemText(dlg, IDC_SSHAUTHBANNER, buf);
116     }
117    
118     static void update_server_supported_types(PTInstVar pvar, HWND dlg)
119     {
120     int supported_methods = pvar->auth_state.supported_types;
121     int cur_control = -1;
122     int control;
123     HWND focus = GetFocus();
124    
125     if (supported_methods == 0) {
126     return;
127     }
128    
129     for (control = IDC_SSHUSEPASSWORD; control <= MAX_AUTH_CONTROL;
130     control++) {
131     BOOL enabled = FALSE;
132     int method;
133     HWND item = GetDlgItem(dlg, control);
134    
135     if (item != NULL) {
136     for (method = 0; method <= SSH_AUTH_MAX; method++) {
137     if (auth_types_to_control_IDs[method] == control
138     && (supported_methods & (1 << method)) != 0) {
139     enabled = TRUE;
140     }
141     }
142    
143     EnableWindow(item, enabled);
144    
145     if (IsDlgButtonChecked(dlg, control)) {
146     cur_control = control;
147     }
148     }
149     }
150    
151     if (cur_control >= 0) {
152     if (!IsWindowEnabled(GetDlgItem(dlg, cur_control))) {
153     do {
154     cur_control++;
155     if (cur_control > MAX_AUTH_CONTROL) {
156     cur_control = IDC_SSHUSEPASSWORD;
157     }
158     } while (!IsWindowEnabled(GetDlgItem(dlg, cur_control)));
159    
160     set_auth_options_status(dlg, cur_control);
161    
162     if (focus != NULL && !IsWindowEnabled(focus)) {
163     SetFocus(GetDlgItem(dlg, cur_control));
164     }
165     }
166     }
167     }
168    
169     static void init_auth_dlg(PTInstVar pvar, HWND dlg)
170     {
171     int default_method = pvar->session_settings.DefaultAuthMethod;
172    
173     init_auth_machine_banner(pvar, dlg);
174     init_password_control(dlg);
175    
176     if (pvar->auth_state.failed_method != SSH_AUTH_NONE) {
177     /* must be retrying a failed attempt */
178     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
179     "Authentication failed. Please retry.");
180     SetWindowText(dlg, "Retrying SSH Authentication");
181     default_method = pvar->auth_state.failed_method;
182     }
183    
184     set_auth_options_status(dlg,
185     auth_types_to_control_IDs[default_method]);
186    
187     if (default_method == SSH_AUTH_TIS) {
188     /* we disabled the password control, so fix the focus */
189     SetFocus(GetDlgItem(dlg, IDC_SSHUSETIS));
190     }
191    
192     if (pvar->auth_state.user != NULL) {
193     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->auth_state.user);
194     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
195     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
196     } else if (pvar->session_settings.DefaultUserName[0] != 0) {
197     SetDlgItemText(dlg, IDC_SSHUSERNAME,
198     pvar->session_settings.DefaultUserName);
199     } else {
200     SetFocus(GetDlgItem(dlg, IDC_SSHUSERNAME));
201     }
202    
203     SetDlgItemText(dlg, IDC_RSAFILENAME,
204     pvar->session_settings.DefaultRSAPrivateKeyFile);
205     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
206     pvar->session_settings.DefaultRhostsHostPrivateKeyFile);
207     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
208     pvar->session_settings.DefaultRhostsLocalUserName);
209    
210     update_server_supported_types(pvar, dlg);
211 yutakakn 2739
212     // SSH2 autologin (2004.12.1 yutaka)
213     // ���[�U�A�p�X���[�h�A�F�����\�b�h���������������A������������OK�{�^�������������B
214     if (pvar->ssh2_autologin == 1) {
215     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->ssh2_username);
216     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAME), FALSE);
217     EnableWindow(GetDlgItem(dlg, IDC_SSHUSERNAMELABEL), FALSE);
218    
219     SetDlgItemText(dlg, IDC_SSHPASSWORD, pvar->ssh2_password);
220     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORD), FALSE);
221     EnableWindow(GetDlgItem(dlg, IDC_SSHPASSWORDCAPTION), FALSE);
222    
223     if (pvar->auth_state.cur_cred.method == SSH_AUTH_PASSWORD) {
224     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL, IDC_SSHUSEPASSWORD);
225     } else {
226     // TODO
227    
228     }
229     }
230    
231 yutakakn 2728 }
232    
233     static char FAR *alloc_control_text(HWND ctl)
234     {
235     int len = GetWindowTextLength(ctl);
236     char FAR *result = malloc(len + 1);
237    
238     if (result != NULL) {
239     GetWindowText(ctl, result, len + 1);
240     result[len] = 0;
241     }
242    
243     return result;
244     }
245    
246     static int get_key_file_name(HWND parent, char FAR * buf, int bufsize)
247     {
248     #ifdef TERATERM32
249     OPENFILENAME params;
250     char fullname_buf[2048] = "identity";
251    
252     params.lStructSize = sizeof(OPENFILENAME);
253     params.hwndOwner = parent;
254     params.lpstrFilter = NULL;
255     params.lpstrCustomFilter = NULL;
256     params.nFilterIndex = 0;
257     buf[0] = 0;
258     params.lpstrFile = fullname_buf;
259     params.nMaxFile = sizeof(fullname_buf);
260     params.lpstrFileTitle = NULL;
261     params.lpstrInitialDir = NULL;
262     params.lpstrTitle = "Choose a file with the RSA private key";
263     params.Flags =
264     OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
265     params.lpstrDefExt = NULL;
266    
267     if (GetOpenFileName(&params) != 0) {
268     copy_teraterm_dir_relative_path(buf, bufsize, fullname_buf);
269     return 1;
270     } else {
271     return 0;
272     }
273     #else
274     return 0;
275     #endif
276     }
277    
278     static void choose_RSA_key_file(HWND dlg)
279     {
280     char buf[1024];
281    
282     if (get_key_file_name(dlg, buf, sizeof(buf))) {
283     SetDlgItemText(dlg, IDC_RSAFILENAME, buf);
284     }
285     }
286    
287     static void choose_host_RSA_key_file(HWND dlg)
288     {
289     char buf[1024];
290    
291     if (get_key_file_name(dlg, buf, sizeof(buf))) {
292     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME, buf);
293     }
294     }
295    
296     static BOOL end_auth_dlg(PTInstVar pvar, HWND dlg)
297     {
298     int method = SSH_AUTH_PASSWORD;
299     char FAR *password =
300     alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
301     CRYPTKeyPair FAR *key_pair = NULL;
302    
303     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
304     method = SSH_AUTH_RSA;
305     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
306     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
307     method = SSH_AUTH_RHOSTS_RSA;
308     } else {
309     method = SSH_AUTH_RHOSTS;
310     }
311     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
312     method = SSH_AUTH_TIS;
313     }
314    
315     if (method == SSH_AUTH_RSA || method == SSH_AUTH_RHOSTS_RSA) {
316     char buf[2048];
317     int file_ctl_ID =
318     method == SSH_AUTH_RSA ? IDC_RSAFILENAME : IDC_HOSTRSAFILENAME;
319    
320     buf[0] = 0;
321     GetDlgItemText(dlg, file_ctl_ID, buf, sizeof(buf));
322     if (buf[0] == 0) {
323     notify_nonfatal_error(pvar,
324     "You must specify a file containing the RSA private key.");
325     SetFocus(GetDlgItem(dlg, file_ctl_ID));
326     destroy_malloced_string(&password);
327     return FALSE;
328     } else {
329     BOOL invalid_passphrase = FALSE;
330    
331     key_pair = KEYFILES_read_private_key(pvar, buf, password,
332     &invalid_passphrase,
333     FALSE);
334    
335     if (key_pair == NULL) {
336     if (invalid_passphrase) {
337     HWND passwordCtl = GetDlgItem(dlg, IDC_SSHPASSWORD);
338    
339     SetFocus(passwordCtl);
340     SendMessage(passwordCtl, EM_SETSEL, 0, -1);
341     } else {
342     SetFocus(GetDlgItem(dlg, file_ctl_ID));
343     }
344     destroy_malloced_string(&password);
345     return FALSE;
346     }
347     }
348     }
349    
350     /* from here on, we cannot fail, so just munge cur_cred in place */
351     pvar->auth_state.cur_cred.method = method;
352     pvar->auth_state.cur_cred.key_pair = key_pair;
353     /* we can't change the user name once it's set. It may already have
354     been sent to the server, and it can only be sent once. */
355     if (pvar->auth_state.user == NULL) {
356     pvar->auth_state.user =
357     alloc_control_text(GetDlgItem(dlg, IDC_SSHUSERNAME));
358     }
359     if (method == SSH_AUTH_PASSWORD) {
360     pvar->auth_state.cur_cred.password = password;
361     } else {
362     destroy_malloced_string(&password);
363     }
364     if (method == SSH_AUTH_RHOSTS || method == SSH_AUTH_RHOSTS_RSA) {
365     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
366     notify_nonfatal_error(pvar,
367     "Rhosts authentication will probably fail because it was not "
368     "the default authentication method.\n"
369     "To use Rhosts authentication "
370     "in TTSSH, you need to set it to be the default by restarting\n"
371     "TTSSH and selecting \"SSH Authentication...\" from the Setup menu"
372     "before connecting.");
373     }
374    
375     pvar->auth_state.cur_cred.rhosts_client_user =
376     alloc_control_text(GetDlgItem(dlg, IDC_LOCALUSERNAME));
377     }
378     pvar->auth_state.auth_dialog = NULL;
379    
380     GetDlgItemText(dlg, IDC_RSAFILENAME,
381     pvar->session_settings.DefaultRSAPrivateKeyFile,
382     sizeof(pvar->session_settings.
383     DefaultRSAPrivateKeyFile));
384     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
385     pvar->session_settings.DefaultRhostsHostPrivateKeyFile,
386     sizeof(pvar->session_settings.
387     DefaultRhostsHostPrivateKeyFile));
388     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
389     pvar->session_settings.DefaultRhostsLocalUserName,
390     sizeof(pvar->session_settings.
391     DefaultRhostsLocalUserName));
392    
393     if (SSHv1(pvar)) {
394     SSH_notify_user_name(pvar);
395     SSH_notify_cred(pvar);
396     } else {
397     // for SSH2(yutaka)
398     do_SSH2_userauth(pvar);
399     }
400    
401     EndDialog(dlg, 1);
402     return TRUE;
403     }
404    
405     static BOOL CALLBACK auth_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
406     LPARAM lParam)
407     {
408 yutakakn 2739 const int IDC_TIMER1 = 300;
409     const int autologin_timeout = 1000; // �~���b
410 yutakakn 2728 PTInstVar pvar;
411    
412     switch (msg) {
413     case WM_INITDIALOG:
414     pvar = (PTInstVar) lParam;
415     pvar->auth_state.auth_dialog = dlg;
416     SetWindowLong(dlg, DWL_USER, lParam);
417    
418     init_auth_dlg(pvar, dlg);
419 yutakakn 2739
420     // SSH2 autologin���L�����������A�^�C�}���d�|�����B (2004.12.1 yutaka)
421     if (pvar->ssh2_autologin == 1) {
422     SetTimer(dlg, IDC_TIMER1, autologin_timeout, 0);
423     }
424 yutakakn 2728 return FALSE; /* because we set the focus */
425    
426 yutakakn 2739 case WM_TIMER:
427     KillTimer(dlg, IDC_TIMER1);
428     SendMessage(dlg, WM_COMMAND, IDOK, 0);
429     return TRUE;
430    
431 yutakakn 2728 case WM_COMMAND:
432     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
433    
434     switch (LOWORD(wParam)) {
435     case IDOK:
436     return end_auth_dlg(pvar, dlg);
437    
438     case IDCANCEL: /* kill the connection */
439     pvar->auth_state.auth_dialog = NULL;
440     notify_closed_connection(pvar);
441     EndDialog(dlg, 0);
442     return TRUE;
443    
444     case IDC_SSHUSEPASSWORD:
445     case IDC_SSHUSERSA:
446     case IDC_SSHUSERHOSTS:
447     case IDC_SSHUSETIS:
448     set_auth_options_status(dlg, LOWORD(wParam));
449     return TRUE;
450    
451     case IDC_CHOOSERSAFILE:
452     choose_RSA_key_file(dlg);
453     return TRUE;
454    
455     case IDC_CHOOSEHOSTRSAFILE:
456     choose_host_RSA_key_file(dlg);
457     return TRUE;
458    
459     default:
460     return FALSE;
461     }
462    
463     default:
464     return FALSE;
465     }
466     }
467    
468     char FAR *AUTH_get_user_name(PTInstVar pvar)
469     {
470     return pvar->auth_state.user;
471     }
472    
473     int AUTH_set_supported_auth_types(PTInstVar pvar, int types)
474     {
475     char buf[1024];
476    
477     _snprintf(buf, sizeof(buf),
478     "Server reports supported authentication method mask = %d",
479     types);
480     buf[sizeof(buf) - 1] = 0;
481     notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
482    
483     if (SSHv1(pvar)) {
484     types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
485     | (1 << SSH_AUTH_RHOSTS_RSA) | (1 << SSH_AUTH_RHOSTS)
486     | (1 << SSH_AUTH_TIS);
487     } else {
488     // for SSH2(yutaka)
489     types &= (1 << SSH_AUTH_PASSWORD);
490     // types &= (1 << SSH_AUTH_PASSWORD) | (1 << SSH_AUTH_RSA)
491     // | (1 << SSH_AUTH_DSA);
492     }
493     pvar->auth_state.supported_types = types;
494    
495     if (types == 0) {
496     notify_fatal_error(pvar,
497     "Server does not support any of the authentication options\n"
498     "provided by TTSSH. This connection will now close.");
499     return 0;
500     } else {
501     if (pvar->auth_state.auth_dialog != NULL) {
502     update_server_supported_types(pvar,
503     pvar->auth_state.auth_dialog);
504     }
505    
506     return 1;
507     }
508     }
509    
510     static void start_user_auth(PTInstVar pvar)
511     {
512 yutakakn 2739 // �F���_�C�A���O���\�������� (2004.12.1 yutaka)
513 yutakakn 2728 PostMessage(pvar->NotificationWindow, WM_COMMAND, (WPARAM) ID_SSHAUTH,
514     (LPARAM) NULL);
515     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
516     }
517    
518     static void try_default_auth(PTInstVar pvar)
519     {
520     if (pvar->session_settings.TryDefaultAuth) {
521     switch (pvar->session_settings.DefaultAuthMethod) {
522     case SSH_AUTH_RSA:{
523     BOOL invalid_passphrase;
524     char password[] = "";
525    
526     pvar->auth_state.cur_cred.key_pair
527     =
528     KEYFILES_read_private_key(pvar,
529     pvar->session_settings.
530     DefaultRSAPrivateKeyFile,
531     password,
532     &invalid_passphrase, TRUE);
533     if (pvar->auth_state.cur_cred.key_pair == NULL) {
534     return;
535     } else {
536     pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
537     }
538     break;
539     }
540    
541     case SSH_AUTH_RHOSTS:
542     if (pvar->session_settings.
543     DefaultRhostsHostPrivateKeyFile[0] != 0) {
544     BOOL invalid_passphrase;
545     char password[] = "";
546    
547     pvar->auth_state.cur_cred.key_pair
548     =
549     KEYFILES_read_private_key(pvar,
550     pvar->session_settings.
551     DefaultRhostsHostPrivateKeyFile,
552     password,
553     &invalid_passphrase, TRUE);
554     if (pvar->auth_state.cur_cred.key_pair == NULL) {
555     return;
556     } else {
557     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS_RSA;
558     }
559     } else {
560     pvar->auth_state.cur_cred.method = SSH_AUTH_RHOSTS;
561     }
562    
563     pvar->auth_state.cur_cred.rhosts_client_user =
564     _strdup(pvar->session_settings.DefaultRhostsLocalUserName);
565     break;
566    
567     case SSH_AUTH_PASSWORD:
568     pvar->auth_state.cur_cred.password = _strdup("");
569     pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
570     break;
571    
572     case SSH_AUTH_TIS:
573     default:
574     return;
575     }
576    
577     pvar->auth_state.user =
578     _strdup(pvar->session_settings.DefaultUserName);
579     }
580     }
581    
582     void AUTH_notify_end_error(PTInstVar pvar)
583     {
584     if ((pvar->auth_state.flags & AUTH_START_USER_AUTH_ON_ERROR_END) != 0) {
585     start_user_auth(pvar);
586     pvar->auth_state.flags &= ~AUTH_START_USER_AUTH_ON_ERROR_END;
587     }
588     }
589    
590     void AUTH_advance_to_next_cred(PTInstVar pvar)
591     {
592     pvar->auth_state.failed_method = pvar->auth_state.cur_cred.method;
593    
594     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
595     try_default_auth(pvar);
596    
597     if (pvar->auth_state.cur_cred.method == SSH_AUTH_NONE) {
598     if (pvar->err_msg != NULL) {
599     pvar->auth_state.flags |=
600     AUTH_START_USER_AUTH_ON_ERROR_END;
601     } else {
602 yutakakn 2739 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
603     // �R�}���h���C���w������������
604 yutakakn 2728 start_user_auth(pvar);
605     }
606     }
607     } else {
608 yutakakn 2739 // �������F���_�C�A���O���o�������� (2004.12.1 yutaka)
609     // �R�}���h���C���w������(/auth=xxxx)������
610 yutakakn 2728 start_user_auth(pvar);
611     }
612     }
613    
614     static void init_TIS_dlg(PTInstVar pvar, HWND dlg)
615     {
616     init_auth_machine_banner(pvar, dlg);
617     init_password_control(dlg);
618    
619     if (pvar->auth_state.TIS_prompt != NULL) {
620     if (strlen(pvar->auth_state.TIS_prompt) > 10000) {
621     pvar->auth_state.TIS_prompt[10000] = 0;
622     }
623     SetDlgItemText(dlg, IDC_SSHAUTHBANNER2,
624     pvar->auth_state.TIS_prompt);
625     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
626     }
627     }
628    
629     static BOOL end_TIS_dlg(PTInstVar pvar, HWND dlg)
630     {
631     char FAR *password =
632     alloc_control_text(GetDlgItem(dlg, IDC_SSHPASSWORD));
633    
634     pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
635     pvar->auth_state.cur_cred.password = password;
636     pvar->auth_state.auth_dialog = NULL;
637    
638     SSH_notify_cred(pvar);
639    
640     EndDialog(dlg, 1);
641     return TRUE;
642     }
643    
644     static BOOL CALLBACK TIS_dlg_proc(HWND dlg, UINT msg, WPARAM wParam,
645     LPARAM lParam)
646     {
647     PTInstVar pvar;
648    
649     switch (msg) {
650     case WM_INITDIALOG:
651     pvar = (PTInstVar) lParam;
652     pvar->auth_state.auth_dialog = dlg;
653     SetWindowLong(dlg, DWL_USER, lParam);
654    
655     init_TIS_dlg(pvar, dlg);
656     return FALSE; /* because we set the focus */
657    
658     case WM_COMMAND:
659     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
660    
661     switch (LOWORD(wParam)) {
662     case IDOK:
663     return end_TIS_dlg(pvar, dlg);
664    
665     case IDCANCEL: /* kill the connection */
666     pvar->auth_state.auth_dialog = NULL;
667     notify_closed_connection(pvar);
668     EndDialog(dlg, 0);
669     return TRUE;
670    
671     default:
672     return FALSE;
673     }
674    
675     default:
676     return FALSE;
677     }
678     }
679    
680     void AUTH_do_cred_dialog(PTInstVar pvar)
681     {
682     if (pvar->auth_state.auth_dialog == NULL) {
683     HWND cur_active = GetActiveWindow();
684     DLGPROC dlg_proc;
685     LPCTSTR dialog_template;
686    
687     switch (pvar->auth_state.mode) {
688     case TIS_AUTH_MODE:
689     dialog_template = MAKEINTRESOURCE(IDD_SSHTISAUTH);
690     dlg_proc = TIS_dlg_proc;
691     break;
692     case GENERIC_AUTH_MODE:
693     default:
694     dialog_template = MAKEINTRESOURCE(IDD_SSHAUTH);
695     dlg_proc = auth_dlg_proc;
696     }
697    
698     if (!DialogBoxParam(hInst, dialog_template,
699     cur_active !=
700     NULL ? cur_active : pvar->NotificationWindow,
701     dlg_proc, (LPARAM) pvar) == -1) {
702     notify_fatal_error(pvar,
703     "Unable to display authentication dialog box.\n"
704     "Connection terminated.");
705     }
706     }
707     }
708    
709     static void init_default_auth_dlg(PTInstVar pvar, HWND dlg)
710     {
711     switch (pvar->settings.DefaultAuthMethod) {
712     case SSH_AUTH_RSA:
713     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
714     IDC_SSHUSERSA);
715     break;
716     case SSH_AUTH_RHOSTS:
717     case SSH_AUTH_RHOSTS_RSA:
718     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
719     IDC_SSHUSERHOSTS);
720     break;
721     case SSH_AUTH_TIS:
722     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
723     IDC_SSHUSETIS);
724     break;
725     case SSH_AUTH_PASSWORD:
726     default:
727     CheckRadioButton(dlg, IDC_SSHUSEPASSWORD, MAX_AUTH_CONTROL,
728     IDC_SSHUSEPASSWORD);
729     }
730    
731     SetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName);
732     SetDlgItemText(dlg, IDC_RSAFILENAME,
733     pvar->settings.DefaultRSAPrivateKeyFile);
734     SetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
735     pvar->settings.DefaultRhostsHostPrivateKeyFile);
736     SetDlgItemText(dlg, IDC_LOCALUSERNAME,
737     pvar->settings.DefaultRhostsLocalUserName);
738     }
739    
740     static BOOL end_default_auth_dlg(PTInstVar pvar, HWND dlg)
741     {
742     if (IsDlgButtonChecked(dlg, IDC_SSHUSERSA)) {
743     pvar->settings.DefaultAuthMethod = SSH_AUTH_RSA;
744     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSERHOSTS)) {
745     if (GetWindowTextLength(GetDlgItem(dlg, IDC_HOSTRSAFILENAME)) > 0) {
746     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS_RSA;
747     } else {
748     pvar->settings.DefaultAuthMethod = SSH_AUTH_RHOSTS;
749     }
750     } else if (IsDlgButtonChecked(dlg, IDC_SSHUSETIS)) {
751     pvar->settings.DefaultAuthMethod = SSH_AUTH_TIS;
752     } else {
753     pvar->settings.DefaultAuthMethod = SSH_AUTH_PASSWORD;
754     }
755    
756     GetDlgItemText(dlg, IDC_SSHUSERNAME, pvar->settings.DefaultUserName,
757     sizeof(pvar->settings.DefaultUserName));
758     GetDlgItemText(dlg, IDC_RSAFILENAME,
759     pvar->settings.DefaultRSAPrivateKeyFile,
760     sizeof(pvar->settings.DefaultRSAPrivateKeyFile));
761     GetDlgItemText(dlg, IDC_HOSTRSAFILENAME,
762     pvar->settings.DefaultRhostsHostPrivateKeyFile,
763     sizeof(pvar->settings.DefaultRhostsHostPrivateKeyFile));
764     GetDlgItemText(dlg, IDC_LOCALUSERNAME,
765     pvar->settings.DefaultRhostsLocalUserName,
766     sizeof(pvar->settings.DefaultRhostsLocalUserName));
767    
768     EndDialog(dlg, 1);
769     return TRUE;
770     }
771    
772     static BOOL CALLBACK default_auth_dlg_proc(HWND dlg, UINT msg,
773     WPARAM wParam, LPARAM lParam)
774     {
775     PTInstVar pvar;
776    
777     switch (msg) {
778     case WM_INITDIALOG:
779     pvar = (PTInstVar) lParam;
780     SetWindowLong(dlg, DWL_USER, lParam);
781    
782     init_default_auth_dlg(pvar, dlg);
783     return TRUE; /* because we do not set the focus */
784    
785     case WM_COMMAND:
786     pvar = (PTInstVar) GetWindowLong(dlg, DWL_USER);
787    
788     switch (LOWORD(wParam)) {
789     case IDOK:
790     return end_default_auth_dlg(pvar, dlg);
791    
792     case IDCANCEL:
793     EndDialog(dlg, 0);
794     return TRUE;
795    
796     case IDC_CHOOSERSAFILE:
797     choose_RSA_key_file(dlg);
798     return TRUE;
799    
800     case IDC_CHOOSEHOSTRSAFILE:
801     choose_host_RSA_key_file(dlg);
802     return TRUE;
803    
804     default:
805     return FALSE;
806     }
807    
808     default:
809     return FALSE;
810     }
811     }
812    
813     void AUTH_init(PTInstVar pvar)
814     {
815     pvar->auth_state.failed_method = SSH_AUTH_NONE;
816     pvar->auth_state.auth_dialog = NULL;
817     pvar->auth_state.user = NULL;
818     pvar->auth_state.flags = 0;
819     pvar->auth_state.TIS_prompt = NULL;
820     pvar->auth_state.supported_types = 0;
821     pvar->auth_state.cur_cred.method = SSH_AUTH_NONE;
822     pvar->auth_state.cur_cred.password = NULL;
823     pvar->auth_state.cur_cred.rhosts_client_user = NULL;
824     pvar->auth_state.cur_cred.key_pair = NULL;
825     AUTH_set_generic_mode(pvar);
826     }
827    
828     void AUTH_set_generic_mode(PTInstVar pvar)
829     {
830     pvar->auth_state.mode = GENERIC_AUTH_MODE;
831     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
832     }
833    
834     void AUTH_set_TIS_mode(PTInstVar pvar, char FAR * prompt, int len)
835     {
836     if (pvar->auth_state.cur_cred.method == SSH_AUTH_TIS) {
837     pvar->auth_state.mode = TIS_AUTH_MODE;
838    
839     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
840     pvar->auth_state.TIS_prompt = malloc(len + 1);
841     memcpy(pvar->auth_state.TIS_prompt, prompt, len);
842     pvar->auth_state.TIS_prompt[len] = 0;
843     } else {
844     AUTH_set_generic_mode(pvar);
845     }
846     }
847    
848     void AUTH_do_default_cred_dialog(PTInstVar pvar)
849     {
850     HWND cur_active = GetActiveWindow();
851    
852     if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHAUTHSETUP),
853     cur_active !=
854     NULL ? cur_active : pvar->NotificationWindow,
855     default_auth_dlg_proc, (LPARAM) pvar) == -1) {
856     notify_nonfatal_error(pvar,
857     "Unable to display authentication setup dialog box.");
858     }
859     }
860    
861     void AUTH_destroy_cur_cred(PTInstVar pvar)
862     {
863     destroy_malloced_string(&pvar->auth_state.cur_cred.password);
864     destroy_malloced_string(&pvar->auth_state.cur_cred.rhosts_client_user);
865     if (pvar->auth_state.cur_cred.key_pair != NULL) {
866     CRYPT_free_key_pair(pvar->auth_state.cur_cred.key_pair);
867     pvar->auth_state.cur_cred.key_pair = NULL;
868     }
869     }
870    
871     static char FAR *get_auth_method_name(SSHAuthMethod auth)
872     {
873     switch (auth) {
874     case SSH_AUTH_PASSWORD:
875     return "password";
876     case SSH_AUTH_RSA:
877     return "RSA";
878     case SSH_AUTH_RHOSTS:
879     return "rhosts";
880     case SSH_AUTH_RHOSTS_RSA:
881     return "rhosts with RSA";
882     case SSH_AUTH_TIS:
883     return "challenge/response (TIS)";
884     default:
885     return "unknown method";
886     }
887     }
888    
889     void AUTH_get_auth_info(PTInstVar pvar, char FAR * dest, int len)
890     {
891     if (pvar->auth_state.user == NULL) {
892     strncpy(dest, "None", len);
893     } else if (pvar->auth_state.cur_cred.method != SSH_AUTH_NONE) {
894     _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
895     get_auth_method_name(pvar->auth_state.cur_cred.method));
896     } else {
897     _snprintf(dest, len, "User '%s', using %s", pvar->auth_state.user,
898     get_auth_method_name(pvar->auth_state.failed_method));
899     }
900    
901     dest[len - 1] = 0;
902     }
903    
904     void AUTH_notify_disconnecting(PTInstVar pvar)
905     {
906     if (pvar->auth_state.auth_dialog != NULL) {
907     PostMessage(pvar->auth_state.auth_dialog, WM_COMMAND, IDCANCEL, 0);
908     /* the main window might not go away if it's not enabled. (see vtwin.cpp) */
909     EnableWindow(pvar->NotificationWindow, TRUE);
910     }
911     }
912    
913     void AUTH_end(PTInstVar pvar)
914     {
915     destroy_malloced_string(&pvar->auth_state.user);
916     destroy_malloced_string(&pvar->auth_state.TIS_prompt);
917    
918     AUTH_destroy_cur_cred(pvar);
919     }
920 yutakakn 2739
921     /*
922     * $Log: not supported by cvs2svn $
923     */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help