version 1.20.2.4, 2001/05/07 21:09:26 |
version 1.20.2.5, 2001/09/27 00:15:41 |
|
|
#include "hostfile.h" |
#include "hostfile.h" |
#include "canohost.h" |
#include "canohost.h" |
#include "tildexpand.h" |
#include "tildexpand.h" |
|
#include "match.h" |
|
|
/* import */ |
/* import */ |
extern ServerOptions options; |
extern ServerOptions options; |
|
|
|
|
/* protocol */ |
/* protocol */ |
|
|
void input_service_request(int type, int plen, void *ctxt); |
static void input_service_request(int, int, void *); |
void input_userauth_request(int type, int plen, void *ctxt); |
static void input_userauth_request(int, int, void *); |
void protocol_error(int type, int plen, void *ctxt); |
static void protocol_error(int, int, void *); |
|
|
/* helper */ |
/* helper */ |
Authmethod *authmethod_lookup(const char *name); |
static Authmethod *authmethod_lookup(const char *); |
char *authmethods_get(void); |
static char *authmethods_get(void); |
int user_key_allowed(struct passwd *pw, Key *key); |
static int user_key_allowed(struct passwd *, Key *); |
int |
static int hostbased_key_allowed(struct passwd *, const char *, char *, Key *); |
hostbased_key_allowed(struct passwd *pw, const char *cuser, char *chost, |
|
Key *key); |
|
|
|
/* auth */ |
/* auth */ |
void userauth_banner(void); |
static void userauth_banner(void); |
void userauth_reply(Authctxt *authctxt, int authenticated); |
static int userauth_none(Authctxt *); |
int userauth_none(Authctxt *authctxt); |
static int userauth_passwd(Authctxt *); |
int userauth_passwd(Authctxt *authctxt); |
static int userauth_pubkey(Authctxt *); |
int userauth_pubkey(Authctxt *authctxt); |
static int userauth_hostbased(Authctxt *); |
int userauth_hostbased(Authctxt *authctxt); |
static int userauth_kbdint(Authctxt *); |
int userauth_kbdint(Authctxt *authctxt); |
|
|
|
Authmethod authmethods[] = { |
Authmethod authmethods[] = { |
{"none", |
{"none", |
|
|
x_authctxt = authctxt; /*XXX*/ |
x_authctxt = authctxt; /*XXX*/ |
|
|
/* challenge-reponse is implemented via keyboard interactive */ |
/* challenge-reponse is implemented via keyboard interactive */ |
if (options.challenge_reponse_authentication) |
if (options.challenge_response_authentication) |
options.kbd_interactive_authentication = 1; |
options.kbd_interactive_authentication = 1; |
|
|
dispatch_init(&protocol_error); |
dispatch_init(&protocol_error); |
|
|
do_authenticated(authctxt); |
do_authenticated(authctxt); |
} |
} |
|
|
void |
static void |
protocol_error(int type, int plen, void *ctxt) |
protocol_error(int type, int plen, void *ctxt) |
{ |
{ |
log("auth: protocol error: type %d plen %d", type, plen); |
log("auth: protocol error: type %d plen %d", type, plen); |
|
|
packet_write_wait(); |
packet_write_wait(); |
} |
} |
|
|
void |
static void |
input_service_request(int type, int plen, void *ctxt) |
input_service_request(int type, int plen, void *ctxt) |
{ |
{ |
Authctxt *authctxt = ctxt; |
Authctxt *authctxt = ctxt; |
|
|
xfree(service); |
xfree(service); |
} |
} |
|
|
void |
static void |
input_userauth_request(int type, int plen, void *ctxt) |
input_userauth_request(int type, int plen, void *ctxt) |
{ |
{ |
Authctxt *authctxt = ctxt; |
Authctxt *authctxt = ctxt; |
|
|
setproctitle("%s", pw ? user : "unknown"); |
setproctitle("%s", pw ? user : "unknown"); |
authctxt->user = xstrdup(user); |
authctxt->user = xstrdup(user); |
authctxt->service = xstrdup(service); |
authctxt->service = xstrdup(service); |
authctxt->style = style ? xstrdup(style) : NULL; /* currently unused */ |
authctxt->style = style ? xstrdup(style) : NULL; |
} else if (authctxt->valid) { |
} else if (strcmp(user, authctxt->user) != 0 || |
if (strcmp(user, authctxt->user) != 0 || |
strcmp(service, authctxt->service) != 0) { |
strcmp(service, authctxt->service) != 0) { |
packet_disconnect("Change of username or service not allowed: " |
log("input_userauth_request: mismatch: (%s,%s)!=(%s,%s)", |
"(%s,%s) -> (%s,%s)", |
user, service, authctxt->user, authctxt->service); |
authctxt->user, authctxt->service, user, service); |
authctxt->valid = 0; |
|
} |
|
} |
} |
/* reset state */ |
/* reset state */ |
dispatch_set(SSH2_MSG_USERAUTH_INFO_RESPONSE, &protocol_error); |
dispatch_set(SSH2_MSG_USERAUTH_INFO_RESPONSE, &protocol_error); |
|
|
void |
void |
userauth_finish(Authctxt *authctxt, int authenticated, char *method) |
userauth_finish(Authctxt *authctxt, int authenticated, char *method) |
{ |
{ |
|
char *methods; |
|
|
if (!authctxt->valid && authenticated) |
if (!authctxt->valid && authenticated) |
fatal("INTERNAL ERROR: authenticated invalid user %s", |
fatal("INTERNAL ERROR: authenticated invalid user %s", |
authctxt->user); |
authctxt->user); |
|
|
/* Log before sending the reply */ |
/* Log before sending the reply */ |
auth_log(authctxt, authenticated, method, " ssh2"); |
auth_log(authctxt, authenticated, method, " ssh2"); |
|
|
if (!authctxt->postponed) |
if (authctxt->postponed) |
userauth_reply(authctxt, authenticated); |
return; |
|
|
|
/* XXX todo: check if multiple auth methods are needed */ |
|
if (authenticated == 1) { |
|
/* turn off userauth */ |
|
dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &protocol_error); |
|
packet_start(SSH2_MSG_USERAUTH_SUCCESS); |
|
packet_send(); |
|
packet_write_wait(); |
|
/* now we can break out */ |
|
authctxt->success = 1; |
|
} else { |
|
if (authctxt->failures++ > AUTH_FAIL_MAX) |
|
packet_disconnect(AUTH_FAIL_MSG, authctxt->user); |
|
methods = authmethods_get(); |
|
packet_start(SSH2_MSG_USERAUTH_FAILURE); |
|
packet_put_cstring(methods); |
|
packet_put_char(0); /* XXX partial success, unused */ |
|
packet_send(); |
|
packet_write_wait(); |
|
xfree(methods); |
|
} |
} |
} |
|
|
void |
static void |
userauth_banner(void) |
userauth_banner(void) |
{ |
{ |
struct stat st; |
struct stat st; |
|
|
return; |
return; |
} |
} |
|
|
void |
static int |
userauth_reply(Authctxt *authctxt, int authenticated) |
|
{ |
|
char *methods; |
|
|
|
/* XXX todo: check if multiple auth methods are needed */ |
|
if (authenticated == 1) { |
|
/* turn off userauth */ |
|
dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &protocol_error); |
|
packet_start(SSH2_MSG_USERAUTH_SUCCESS); |
|
packet_send(); |
|
packet_write_wait(); |
|
/* now we can break out */ |
|
authctxt->success = 1; |
|
} else { |
|
if (authctxt->failures++ > AUTH_FAIL_MAX) |
|
packet_disconnect(AUTH_FAIL_MSG, authctxt->user); |
|
methods = authmethods_get(); |
|
packet_start(SSH2_MSG_USERAUTH_FAILURE); |
|
packet_put_cstring(methods); |
|
packet_put_char(0); /* XXX partial success, unused */ |
|
packet_send(); |
|
packet_write_wait(); |
|
xfree(methods); |
|
} |
|
} |
|
|
|
int |
|
userauth_none(Authctxt *authctxt) |
userauth_none(Authctxt *authctxt) |
{ |
{ |
/* disable method "none", only allowed one time */ |
/* disable method "none", only allowed one time */ |
|
|
return authctxt->valid ? auth_password(authctxt, "") : 0; |
return authctxt->valid ? auth_password(authctxt, "") : 0; |
} |
} |
|
|
int |
static int |
userauth_passwd(Authctxt *authctxt) |
userauth_passwd(Authctxt *authctxt) |
{ |
{ |
char *password; |
char *password; |
|
|
return authenticated; |
return authenticated; |
} |
} |
|
|
int |
static int |
userauth_kbdint(Authctxt *authctxt) |
userauth_kbdint(Authctxt *authctxt) |
{ |
{ |
int authenticated = 0; |
int authenticated = 0; |
char *lang = NULL; |
char *lang, *devs; |
char *devs = NULL; |
|
|
|
lang = packet_get_string(NULL); |
lang = packet_get_string(NULL); |
devs = packet_get_string(NULL); |
devs = packet_get_string(NULL); |
packet_done(); |
packet_done(); |
|
|
debug("keyboard-interactive language %s devs %s", lang, devs); |
debug("keyboard-interactive devs %s", devs); |
|
|
if (options.challenge_reponse_authentication) |
if (options.challenge_response_authentication) |
authenticated = auth2_challenge(authctxt, devs); |
authenticated = auth2_challenge(authctxt, devs); |
|
|
xfree(lang); |
|
xfree(devs); |
xfree(devs); |
|
xfree(lang); |
return authenticated; |
return authenticated; |
} |
} |
|
|
int |
static int |
userauth_pubkey(Authctxt *authctxt) |
userauth_pubkey(Authctxt *authctxt) |
{ |
{ |
Buffer b; |
Buffer b; |
|
|
return authenticated; |
return authenticated; |
} |
} |
|
|
int |
static int |
userauth_hostbased(Authctxt *authctxt) |
userauth_hostbased(Authctxt *authctxt) |
{ |
{ |
Buffer b; |
Buffer b; |
|
|
|
|
#define DELIM "," |
#define DELIM "," |
|
|
char * |
static char * |
authmethods_get(void) |
authmethods_get(void) |
{ |
{ |
Authmethod *method = NULL; |
Authmethod *method = NULL; |
|
|
return list; |
return list; |
} |
} |
|
|
Authmethod * |
static Authmethod * |
authmethod_lookup(const char *name) |
authmethod_lookup(const char *name) |
{ |
{ |
Authmethod *method = NULL; |
Authmethod *method = NULL; |
|
|
} |
} |
|
|
/* return 1 if user allows given key */ |
/* return 1 if user allows given key */ |
int |
static int |
user_key_allowed(struct passwd *pw, Key *key) |
user_key_allowed2(struct passwd *pw, Key *key, char *file) |
{ |
{ |
char line[8192], file[MAXPATHLEN]; |
char line[8192]; |
int found_key = 0; |
int found_key = 0; |
FILE *f; |
FILE *f; |
u_long linenum = 0; |
u_long linenum = 0; |
|
|
/* Temporarily use the user's uid. */ |
/* Temporarily use the user's uid. */ |
temporarily_use_uid(pw); |
temporarily_use_uid(pw); |
|
|
/* The authorized keys. */ |
debug("trying public key file %s", file); |
snprintf(file, sizeof file, "%.500s/%.100s", pw->pw_dir, |
|
_PATH_SSH_USER_PERMITTED_KEYS2); |
|
|
|
/* Fail quietly if file does not exist */ |
/* Fail quietly if file does not exist */ |
if (stat(file, &st) < 0) { |
if (stat(file, &st) < 0) { |
|
|
restore_uid(); |
restore_uid(); |
return 0; |
return 0; |
} |
} |
if (options.strict_modes) { |
if (options.strict_modes && |
int fail = 0; |
secure_filename(f, file, pw, line, sizeof(line)) != 0) { |
char buf[1024]; |
fclose(f); |
/* Check open file in order to avoid open/stat races */ |
log("Authentication refused: %s", line); |
if (fstat(fileno(f), &st) < 0 || |
restore_uid(); |
(st.st_uid != 0 && st.st_uid != pw->pw_uid) || |
return 0; |
(st.st_mode & 022) != 0) { |
|
snprintf(buf, sizeof buf, |
|
"%s authentication refused for %.100s: " |
|
"bad ownership or modes for '%s'.", |
|
key_type(key), pw->pw_name, file); |
|
fail = 1; |
|
} else { |
|
/* Check path to _PATH_SSH_USER_PERMITTED_KEYS */ |
|
int i; |
|
static const char *check[] = { |
|
"", _PATH_SSH_USER_DIR, NULL |
|
}; |
|
for (i = 0; check[i]; i++) { |
|
snprintf(line, sizeof line, "%.500s/%.100s", |
|
pw->pw_dir, check[i]); |
|
if (stat(line, &st) < 0 || |
|
(st.st_uid != 0 && st.st_uid != pw->pw_uid) || |
|
(st.st_mode & 022) != 0) { |
|
snprintf(buf, sizeof buf, |
|
"%s authentication refused for %.100s: " |
|
"bad ownership or modes for '%s'.", |
|
key_type(key), pw->pw_name, line); |
|
fail = 1; |
|
break; |
|
} |
|
} |
|
} |
|
if (fail) { |
|
fclose(f); |
|
log("%s", buf); |
|
restore_uid(); |
|
return 0; |
|
} |
|
} |
} |
|
|
found_key = 0; |
found_key = 0; |
found = key_new(key->type); |
found = key_new(key->type); |
|
|
|
|
if (!*cp || *cp == '\n' || *cp == '#') |
if (!*cp || *cp == '\n' || *cp == '#') |
continue; |
continue; |
|
|
if (key_read(found, &cp) == -1) { |
if (key_read(found, &cp) != 1) { |
/* no key? check if there are options for this key */ |
/* no key? check if there are options for this key */ |
int quoted = 0; |
int quoted = 0; |
debug2("user_key_allowed: check options: '%s'", cp); |
debug2("user_key_allowed: check options: '%s'", cp); |
|
|
/* Skip remaining whitespace. */ |
/* Skip remaining whitespace. */ |
for (; *cp == ' ' || *cp == '\t'; cp++) |
for (; *cp == ' ' || *cp == '\t'; cp++) |
; |
; |
if (key_read(found, &cp) == -1) { |
if (key_read(found, &cp) != 1) { |
debug2("user_key_allowed: advance: '%s'", cp); |
debug2("user_key_allowed: advance: '%s'", cp); |
/* still no key? advance to next line*/ |
/* still no key? advance to next line*/ |
continue; |
continue; |
|
|
if (key_equal(found, key) && |
if (key_equal(found, key) && |
auth_parse_options(pw, options, file, linenum) == 1) { |
auth_parse_options(pw, options, file, linenum) == 1) { |
found_key = 1; |
found_key = 1; |
debug("matching key found: file %s, line %ld", |
debug("matching key found: file %s, line %lu", |
file, linenum); |
file, linenum); |
break; |
break; |
} |
} |
|
|
return found_key; |
return found_key; |
} |
} |
|
|
|
/* check whether given key is in .ssh/authorized_keys* */ |
|
static int |
|
user_key_allowed(struct passwd *pw, Key *key) |
|
{ |
|
int success; |
|
char *file; |
|
|
|
file = authorized_keys_file(pw); |
|
success = user_key_allowed2(pw, key, file); |
|
xfree(file); |
|
if (success) |
|
return success; |
|
|
|
/* try suffix "2" for backward compat, too */ |
|
file = authorized_keys_file2(pw); |
|
success = user_key_allowed2(pw, key, file); |
|
xfree(file); |
|
return success; |
|
} |
|
|
/* return 1 if given hostkey is allowed */ |
/* return 1 if given hostkey is allowed */ |
int |
static int |
hostbased_key_allowed(struct passwd *pw, const char *cuser, char *chost, |
hostbased_key_allowed(struct passwd *pw, const char *cuser, char *chost, |
Key *key) |
Key *key) |
{ |
{ |
Key *found; |
|
const char *resolvedname, *ipaddr, *lookup; |
const char *resolvedname, *ipaddr, *lookup; |
struct stat st; |
|
char *user_hostfile; |
|
int host_status, len; |
int host_status, len; |
|
|
resolvedname = get_canonical_hostname(options.reverse_mapping_check); |
resolvedname = get_canonical_hostname(options.reverse_mapping_check); |
|
|
} |
} |
debug2("userauth_hostbased: access allowed by auth_rhosts2"); |
debug2("userauth_hostbased: access allowed by auth_rhosts2"); |
|
|
/* XXX this is copied from auth-rh-rsa.c and should be shared */ |
host_status = check_key_in_hostfiles(pw, key, lookup, |
found = key_new(key->type); |
_PATH_SSH_SYSTEM_HOSTFILE, |
host_status = check_host_in_hostfile(_PATH_SSH_SYSTEM_HOSTFILE2, lookup, |
options.ignore_user_known_hosts ? NULL : _PATH_SSH_USER_HOSTFILE); |
key, found, NULL); |
|
|
|
if (host_status != HOST_OK && !options.ignore_user_known_hosts) { |
/* backward compat if no key has been found. */ |
user_hostfile = tilde_expand_filename(_PATH_SSH_USER_HOSTFILE2, |
if (host_status == HOST_NEW) |
pw->pw_uid); |
host_status = check_key_in_hostfiles(pw, key, lookup, |
if (options.strict_modes && |
_PATH_SSH_SYSTEM_HOSTFILE2, |
(stat(user_hostfile, &st) == 0) && |
options.ignore_user_known_hosts ? NULL : |
((st.st_uid != 0 && st.st_uid != pw->pw_uid) || |
_PATH_SSH_USER_HOSTFILE2); |
(st.st_mode & 022) != 0)) { |
|
log("Hostbased authentication refused for %.100s: " |
|
"bad owner or modes for %.200s", |
|
pw->pw_name, user_hostfile); |
|
} else { |
|
temporarily_use_uid(pw); |
|
host_status = check_host_in_hostfile(user_hostfile, |
|
lookup, key, found, NULL); |
|
restore_uid(); |
|
} |
|
xfree(user_hostfile); |
|
} |
|
key_free(found); |
|
|
|
debug2("userauth_hostbased: key %s for %s", host_status == HOST_OK ? |
|
"ok" : "not found", lookup); |
|
return (host_status == HOST_OK); |
return (host_status == HOST_OK); |
} |
} |
|
|