version 1.71, 2001/09/27 15:31:17 |
version 1.71.2.3, 2002/05/17 00:03:23 |
|
|
#include "pathnames.h" |
#include "pathnames.h" |
#include "uidswap.h" |
#include "uidswap.h" |
#include "auth-options.h" |
#include "auth-options.h" |
#include "misc.h" |
|
#include "hostfile.h" |
#include "hostfile.h" |
#include "canohost.h" |
#include "canohost.h" |
#include "tildexpand.h" |
|
#include "match.h" |
#include "match.h" |
|
#include "monitor_wrap.h" |
|
#include "atomicio.h" |
|
|
/* import */ |
/* import */ |
extern ServerOptions options; |
extern ServerOptions options; |
extern u_char *session_id2; |
extern u_char *session_id2; |
extern int session_id2_len; |
extern int session_id2_len; |
|
|
static Authctxt *x_authctxt = NULL; |
Authctxt *x_authctxt = NULL; |
static int one = 1; |
static int one = 1; |
|
|
typedef struct Authmethod Authmethod; |
typedef struct Authmethod Authmethod; |
|
|
|
|
/* protocol */ |
/* protocol */ |
|
|
static void input_service_request(int, int, void *); |
static void input_service_request(int, u_int32_t, void *); |
static void input_userauth_request(int, int, void *); |
static void input_userauth_request(int, u_int32_t, void *); |
static void protocol_error(int, int, void *); |
|
|
|
/* helper */ |
/* helper */ |
static Authmethod *authmethod_lookup(const char *); |
static Authmethod *authmethod_lookup(const char *); |
static char *authmethods_get(void); |
static char *authmethods_get(void); |
static int user_key_allowed(struct passwd *, Key *); |
int user_key_allowed(struct passwd *, Key *); |
static int hostbased_key_allowed(struct passwd *, const char *, char *, Key *); |
int hostbased_key_allowed(struct passwd *, const char *, char *, Key *); |
|
|
/* auth */ |
/* auth */ |
static void userauth_banner(void); |
static void userauth_banner(void); |
|
|
* loop until authctxt->success == TRUE |
* loop until authctxt->success == TRUE |
*/ |
*/ |
|
|
void |
Authctxt * |
do_authentication2() |
do_authentication2(void) |
{ |
{ |
Authctxt *authctxt = authctxt_new(); |
Authctxt *authctxt = authctxt_new(); |
|
|
|
|
if (options.challenge_response_authentication) |
if (options.challenge_response_authentication) |
options.kbd_interactive_authentication = 1; |
options.kbd_interactive_authentication = 1; |
|
|
dispatch_init(&protocol_error); |
dispatch_init(&dispatch_protocol_error); |
dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request); |
dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request); |
dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt); |
dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt); |
do_authenticated(authctxt); |
|
} |
|
|
|
static void |
return (authctxt); |
protocol_error(int type, int plen, void *ctxt) |
|
{ |
|
log("auth: protocol error: type %d plen %d", type, plen); |
|
packet_start(SSH2_MSG_UNIMPLEMENTED); |
|
packet_put_int(0); |
|
packet_send(); |
|
packet_write_wait(); |
|
} |
} |
|
|
static void |
static void |
input_service_request(int type, int plen, void *ctxt) |
input_service_request(int type, u_int32_t seq, void *ctxt) |
{ |
{ |
Authctxt *authctxt = ctxt; |
Authctxt *authctxt = ctxt; |
u_int len; |
u_int len; |
int accept = 0; |
int accept = 0; |
char *service = packet_get_string(&len); |
char *service = packet_get_string(&len); |
packet_done(); |
packet_check_eom(); |
|
|
if (authctxt == NULL) |
if (authctxt == NULL) |
fatal("input_service_request: no authctxt"); |
fatal("input_service_request: no authctxt"); |
|
|
} |
} |
|
|
static void |
static void |
input_userauth_request(int type, int plen, void *ctxt) |
input_userauth_request(int type, u_int32_t seq, void *ctxt) |
{ |
{ |
Authctxt *authctxt = ctxt; |
Authctxt *authctxt = ctxt; |
Authmethod *m = NULL; |
Authmethod *m = NULL; |
|
|
|
|
if (authctxt->attempt++ == 0) { |
if (authctxt->attempt++ == 0) { |
/* setup auth context */ |
/* setup auth context */ |
struct passwd *pw = NULL; |
authctxt->pw = PRIVSEP(getpwnamallow(user)); |
pw = getpwnam(user); |
if (authctxt->pw && strcmp(service, "ssh-connection")==0) { |
if (pw && allowed_user(pw) && strcmp(service, "ssh-connection")==0) { |
|
authctxt->pw = pwcopy(pw); |
|
authctxt->valid = 1; |
authctxt->valid = 1; |
debug2("input_userauth_request: setting up authctxt for %s", user); |
debug2("input_userauth_request: setting up authctxt for %s", user); |
} else { |
} else { |
log("input_userauth_request: illegal user %s", user); |
log("input_userauth_request: illegal user %s", user); |
} |
} |
setproctitle("%s", pw ? user : "unknown"); |
setproctitle("%s%s", authctxt->pw ? user : "unknown", |
|
use_privsep ? " [net]" : ""); |
authctxt->user = xstrdup(user); |
authctxt->user = xstrdup(user); |
authctxt->service = xstrdup(service); |
authctxt->service = xstrdup(service); |
authctxt->style = style ? xstrdup(style) : NULL; |
authctxt->style = style ? xstrdup(style) : NULL; |
|
if (use_privsep) |
|
mm_inform_authserv(service, style); |
} else if (strcmp(user, authctxt->user) != 0 || |
} else 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: " |
packet_disconnect("Change of username or service not allowed: " |
|
|
authctxt->user, authctxt->service, user, service); |
authctxt->user, authctxt->service, user, service); |
} |
} |
/* reset state */ |
/* reset state */ |
dispatch_set(SSH2_MSG_USERAUTH_INFO_RESPONSE, &protocol_error); |
auth2_challenge_stop(authctxt); |
authctxt->postponed = 0; |
authctxt->postponed = 0; |
#ifdef BSD_AUTH |
|
if (authctxt->as) { |
|
auth_close(authctxt->as); |
|
authctxt->as = NULL; |
|
} |
|
#endif |
|
|
|
/* try to authenticate user */ |
/* try to authenticate user */ |
m = authmethod_lookup(method); |
m = authmethod_lookup(method); |
|
|
/* XXX todo: check if multiple auth methods are needed */ |
/* XXX todo: check if multiple auth methods are needed */ |
if (authenticated == 1) { |
if (authenticated == 1) { |
/* turn off userauth */ |
/* turn off userauth */ |
dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &protocol_error); |
dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &dispatch_protocol_ignore); |
packet_start(SSH2_MSG_USERAUTH_SUCCESS); |
packet_start(SSH2_MSG_USERAUTH_SUCCESS); |
packet_send(); |
packet_send(); |
packet_write_wait(); |
packet_write_wait(); |
|
|
} |
} |
} |
} |
|
|
static void |
char * |
userauth_banner(void) |
auth2_read_banner(void) |
{ |
{ |
struct stat st; |
struct stat st; |
char *banner = NULL; |
char *banner = NULL; |
off_t len, n; |
off_t len, n; |
int fd; |
int fd; |
|
|
if (options.banner == NULL || (datafellows & SSH_BUG_BANNER)) |
if ((fd = open(options.banner, O_RDONLY)) == -1) |
return; |
return (NULL); |
if ((fd = open(options.banner, O_RDONLY)) < 0) |
if (fstat(fd, &st) == -1) { |
return; |
close(fd); |
if (fstat(fd, &st) < 0) |
return (NULL); |
goto done; |
} |
len = st.st_size; |
len = st.st_size; |
banner = xmalloc(len + 1); |
banner = xmalloc(len + 1); |
if ((n = read(fd, banner, len)) < 0) |
n = atomicio(read, fd, banner, len); |
goto done; |
close(fd); |
|
|
|
if (n != len) { |
|
free(banner); |
|
return (NULL); |
|
} |
banner[n] = '\0'; |
banner[n] = '\0'; |
|
|
|
return (banner); |
|
} |
|
|
|
static void |
|
userauth_banner(void) |
|
{ |
|
char *banner = NULL; |
|
|
|
if (options.banner == NULL || (datafellows & SSH_BUG_BANNER)) |
|
return; |
|
|
|
if ((banner = PRIVSEP(auth2_read_banner())) == NULL) |
|
goto done; |
|
|
packet_start(SSH2_MSG_USERAUTH_BANNER); |
packet_start(SSH2_MSG_USERAUTH_BANNER); |
packet_put_cstring(banner); |
packet_put_cstring(banner); |
packet_put_cstring(""); /* language, unused */ |
packet_put_cstring(""); /* language, unused */ |
|
|
done: |
done: |
if (banner) |
if (banner) |
xfree(banner); |
xfree(banner); |
close(fd); |
|
return; |
return; |
} |
} |
|
|
|
|
Authmethod *m = authmethod_lookup("none"); |
Authmethod *m = authmethod_lookup("none"); |
if (m != NULL) |
if (m != NULL) |
m->enabled = NULL; |
m->enabled = NULL; |
packet_done(); |
packet_check_eom(); |
userauth_banner(); |
userauth_banner(); |
return authctxt->valid ? auth_password(authctxt, "") : 0; |
return (authctxt->valid ? PRIVSEP(auth_password(authctxt, "")) : 0); |
} |
} |
|
|
static int |
static int |
|
|
if (change) |
if (change) |
log("password change not supported"); |
log("password change not supported"); |
password = packet_get_string(&len); |
password = packet_get_string(&len); |
packet_done(); |
packet_check_eom(); |
if (authctxt->valid && |
if (authctxt->valid && |
auth_password(authctxt, password) == 1) |
PRIVSEP(auth_password(authctxt, password)) == 1) |
authenticated = 1; |
authenticated = 1; |
memset(password, 0, len); |
memset(password, 0, len); |
xfree(password); |
xfree(password); |
|
|
{ |
{ |
int authenticated = 0; |
int authenticated = 0; |
char *lang, *devs; |
char *lang, *devs; |
|
|
lang = packet_get_string(NULL); |
lang = packet_get_string(NULL); |
devs = packet_get_string(NULL); |
devs = packet_get_string(NULL); |
packet_done(); |
packet_check_eom(); |
|
|
debug("keyboard-interactive devs %s", devs); |
debug("keyboard-interactive devs %s", devs); |
|
|
|
|
userauth_pubkey(Authctxt *authctxt) |
userauth_pubkey(Authctxt *authctxt) |
{ |
{ |
Buffer b; |
Buffer b; |
Key *key; |
Key *key = NULL; |
char *pkalg, *pkblob, *sig; |
char *pkalg; |
|
u_char *pkblob, *sig; |
u_int alen, blen, slen; |
u_int alen, blen, slen; |
int have_sig, pktype; |
int have_sig, pktype; |
int authenticated = 0; |
int authenticated = 0; |
|
|
pktype = key_type_from_name(pkalg); |
pktype = key_type_from_name(pkalg); |
if (pktype == KEY_UNSPEC) { |
if (pktype == KEY_UNSPEC) { |
/* this is perfectly legal */ |
/* this is perfectly legal */ |
log("userauth_pubkey: unsupported public key algorithm: %s", pkalg); |
log("userauth_pubkey: unsupported public key algorithm: %s", |
xfree(pkalg); |
pkalg); |
xfree(pkblob); |
goto done; |
return 0; |
|
} |
} |
key = key_from_blob(pkblob, blen); |
key = key_from_blob(pkblob, blen); |
if (key != NULL) { |
if (key == NULL) { |
if (have_sig) { |
error("userauth_pubkey: cannot decode key: %s", pkalg); |
sig = packet_get_string(&slen); |
goto done; |
packet_done(); |
} |
buffer_init(&b); |
if (key->type != pktype) { |
if (datafellows & SSH_OLD_SESSIONID) { |
error("userauth_pubkey: type mismatch for decoded key " |
buffer_append(&b, session_id2, session_id2_len); |
"(received %d, expected %d)", key->type, pktype); |
} else { |
goto done; |
buffer_put_string(&b, session_id2, session_id2_len); |
} |
} |
if (have_sig) { |
/* reconstruct packet */ |
sig = packet_get_string(&slen); |
buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST); |
packet_check_eom(); |
buffer_put_cstring(&b, authctxt->user); |
buffer_init(&b); |
buffer_put_cstring(&b, |
if (datafellows & SSH_OLD_SESSIONID) { |
datafellows & SSH_BUG_PKSERVICE ? |
buffer_append(&b, session_id2, session_id2_len); |
"ssh-userauth" : |
} else { |
authctxt->service); |
buffer_put_string(&b, session_id2, session_id2_len); |
if (datafellows & SSH_BUG_PKAUTH) { |
} |
buffer_put_char(&b, have_sig); |
/* reconstruct packet */ |
} else { |
buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST); |
buffer_put_cstring(&b, "publickey"); |
buffer_put_cstring(&b, authctxt->user); |
buffer_put_char(&b, have_sig); |
buffer_put_cstring(&b, |
buffer_put_cstring(&b, pkalg); |
datafellows & SSH_BUG_PKSERVICE ? |
} |
"ssh-userauth" : |
buffer_put_string(&b, pkblob, blen); |
authctxt->service); |
|
if (datafellows & SSH_BUG_PKAUTH) { |
|
buffer_put_char(&b, have_sig); |
|
} else { |
|
buffer_put_cstring(&b, "publickey"); |
|
buffer_put_char(&b, have_sig); |
|
buffer_put_cstring(&b, pkalg); |
|
} |
|
buffer_put_string(&b, pkblob, blen); |
#ifdef DEBUG_PK |
#ifdef DEBUG_PK |
buffer_dump(&b); |
buffer_dump(&b); |
#endif |
#endif |
/* test for correct signature */ |
/* test for correct signature */ |
if (user_key_allowed(authctxt->pw, key) && |
authenticated = 0; |
key_verify(key, sig, slen, buffer_ptr(&b), buffer_len(&b)) == 1) |
if (PRIVSEP(user_key_allowed(authctxt->pw, key)) && |
authenticated = 1; |
PRIVSEP(key_verify(key, sig, slen, buffer_ptr(&b), |
buffer_clear(&b); |
buffer_len(&b))) == 1) |
xfree(sig); |
authenticated = 1; |
} else { |
buffer_clear(&b); |
debug("test whether pkalg/pkblob are acceptable"); |
xfree(sig); |
packet_done(); |
} else { |
|
debug("test whether pkalg/pkblob are acceptable"); |
|
packet_check_eom(); |
|
|
/* XXX fake reply and always send PK_OK ? */ |
/* XXX fake reply and always send PK_OK ? */ |
/* |
/* |
* XXX this allows testing whether a user is allowed |
* XXX this allows testing whether a user is allowed |
* to login: if you happen to have a valid pubkey this |
* to login: if you happen to have a valid pubkey this |
* message is sent. the message is NEVER sent at all |
* message is sent. the message is NEVER sent at all |
* if a user is not allowed to login. is this an |
* if a user is not allowed to login. is this an |
* issue? -markus |
* issue? -markus |
*/ |
*/ |
if (user_key_allowed(authctxt->pw, key)) { |
if (PRIVSEP(user_key_allowed(authctxt->pw, key))) { |
packet_start(SSH2_MSG_USERAUTH_PK_OK); |
packet_start(SSH2_MSG_USERAUTH_PK_OK); |
packet_put_string(pkalg, alen); |
packet_put_string(pkalg, alen); |
packet_put_string(pkblob, blen); |
packet_put_string(pkblob, blen); |
packet_send(); |
packet_send(); |
packet_write_wait(); |
packet_write_wait(); |
authctxt->postponed = 1; |
authctxt->postponed = 1; |
} |
|
} |
} |
if (authenticated != 1) |
|
auth_clear_options(); |
|
key_free(key); |
|
} |
} |
|
if (authenticated != 1) |
|
auth_clear_options(); |
|
done: |
debug2("userauth_pubkey: authenticated %d pkalg %s", authenticated, pkalg); |
debug2("userauth_pubkey: authenticated %d pkalg %s", authenticated, pkalg); |
|
if (key != NULL) |
|
key_free(key); |
xfree(pkalg); |
xfree(pkalg); |
xfree(pkblob); |
xfree(pkblob); |
return authenticated; |
return authenticated; |
|
|
userauth_hostbased(Authctxt *authctxt) |
userauth_hostbased(Authctxt *authctxt) |
{ |
{ |
Buffer b; |
Buffer b; |
Key *key; |
Key *key = NULL; |
char *pkalg, *pkblob, *sig, *cuser, *chost, *service; |
char *pkalg, *cuser, *chost, *service; |
|
u_char *pkblob, *sig; |
u_int alen, blen, slen; |
u_int alen, blen, slen; |
int pktype; |
int pktype; |
int authenticated = 0; |
int authenticated = 0; |
|
|
} |
} |
key = key_from_blob(pkblob, blen); |
key = key_from_blob(pkblob, blen); |
if (key == NULL) { |
if (key == NULL) { |
debug("userauth_hostbased: cannot decode key: %s", pkalg); |
error("userauth_hostbased: cannot decode key: %s", pkalg); |
goto done; |
goto done; |
} |
} |
|
if (key->type != pktype) { |
|
error("userauth_hostbased: type mismatch for decoded key " |
|
"(received %d, expected %d)", key->type, pktype); |
|
goto done; |
|
} |
service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" : |
service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" : |
authctxt->service; |
authctxt->service; |
buffer_init(&b); |
buffer_init(&b); |
|
|
buffer_dump(&b); |
buffer_dump(&b); |
#endif |
#endif |
/* test for allowed key and correct signature */ |
/* test for allowed key and correct signature */ |
if (hostbased_key_allowed(authctxt->pw, cuser, chost, key) && |
authenticated = 0; |
key_verify(key, sig, slen, buffer_ptr(&b), buffer_len(&b)) == 1) |
if (PRIVSEP(hostbased_key_allowed(authctxt->pw, cuser, chost, key)) && |
|
PRIVSEP(key_verify(key, sig, slen, buffer_ptr(&b), |
|
buffer_len(&b))) == 1) |
authenticated = 1; |
authenticated = 1; |
|
|
buffer_clear(&b); |
buffer_clear(&b); |
key_free(key); |
|
|
|
done: |
done: |
debug2("userauth_hostbased: authenticated %d", authenticated); |
debug2("userauth_hostbased: authenticated %d", authenticated); |
|
if (key != NULL) |
|
key_free(key); |
xfree(pkalg); |
xfree(pkalg); |
xfree(pkblob); |
xfree(pkblob); |
xfree(cuser); |
xfree(cuser); |
|
|
authmethods_get(void) |
authmethods_get(void) |
{ |
{ |
Authmethod *method = NULL; |
Authmethod *method = NULL; |
u_int size = 0; |
Buffer b; |
char *list; |
char *list; |
|
|
|
buffer_init(&b); |
for (method = authmethods; method->name != NULL; method++) { |
for (method = authmethods; method->name != NULL; method++) { |
if (strcmp(method->name, "none") == 0) |
if (strcmp(method->name, "none") == 0) |
continue; |
continue; |
if (method->enabled != NULL && *(method->enabled) != 0) { |
if (method->enabled != NULL && *(method->enabled) != 0) { |
if (size != 0) |
if (buffer_len(&b) > 0) |
size += strlen(DELIM); |
buffer_append(&b, ",", 1); |
size += strlen(method->name); |
buffer_append(&b, method->name, strlen(method->name)); |
} |
} |
} |
} |
size++; /* trailing '\0' */ |
buffer_append(&b, "\0", 1); |
list = xmalloc(size); |
list = xstrdup(buffer_ptr(&b)); |
list[0] = '\0'; |
buffer_free(&b); |
|
|
for (method = authmethods; method->name != NULL; method++) { |
|
if (strcmp(method->name, "none") == 0) |
|
continue; |
|
if (method->enabled != NULL && *(method->enabled) != 0) { |
|
if (list[0] != '\0') |
|
strlcat(list, DELIM, size); |
|
strlcat(list, method->name, size); |
|
} |
|
} |
|
return list; |
return list; |
} |
} |
|
|
|
|
u_long linenum = 0; |
u_long linenum = 0; |
struct stat st; |
struct stat st; |
Key *found; |
Key *found; |
|
char *fp; |
|
|
if (pw == NULL) |
if (pw == NULL) |
return 0; |
return 0; |
|
|
found_key = 1; |
found_key = 1; |
debug("matching key found: file %s, line %lu", |
debug("matching key found: file %s, line %lu", |
file, linenum); |
file, linenum); |
|
fp = key_fingerprint(found, SSH_FP_MD5, SSH_FP_HEX); |
|
verbose("Found matching %s key: %s", |
|
key_type(found), fp); |
|
xfree(fp); |
break; |
break; |
} |
} |
} |
} |
|
|
} |
} |
|
|
/* check whether given key is in .ssh/authorized_keys* */ |
/* check whether given key is in .ssh/authorized_keys* */ |
static int |
int |
user_key_allowed(struct passwd *pw, Key *key) |
user_key_allowed(struct passwd *pw, Key *key) |
{ |
{ |
int success; |
int success; |
|
|
} |
} |
|
|
/* return 1 if given hostkey is allowed */ |
/* return 1 if given hostkey is allowed */ |
static int |
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) |
{ |
{ |
const char *resolvedname, *ipaddr, *lookup; |
const char *resolvedname, *ipaddr, *lookup; |
int host_status, len; |
HostStatus host_status; |
|
int len; |
|
|
resolvedname = get_canonical_hostname(options.reverse_mapping_check); |
resolvedname = get_canonical_hostname(options.verify_reverse_mapping); |
ipaddr = get_remote_ipaddr(); |
ipaddr = get_remote_ipaddr(); |
|
|
debug2("userauth_hostbased: chost %s resolvedname %s ipaddr %s", |
debug2("userauth_hostbased: chost %s resolvedname %s ipaddr %s", |
|
|
|
|
return (host_status == HOST_OK); |
return (host_status == HOST_OK); |
} |
} |
|
|