Release notes are available at https://www.openssh.com/txt/release-9.2 OpenSSH 9.2 contains fixes for two security problems and a memory safety problem. The memory safety problem is not believed to be exploitable. These fixes have already been committed to OpenSSH 9.1 in FreeBSD. Some other notable items from the release notes: * ssh(1): add a new EnableEscapeCommandline ssh_config(5) option that controls whether the client-side ~C escape sequence that provides a command-line is available. Among other things, the ~C command-line could be used to add additional port-forwards at runtime. * sshd(8): add support for channel inactivity timeouts via a new sshd_config(5) ChannelTimeout directive. This allows channels that have not seen traffic in a configurable interval to be automatically closed. Different timeouts may be applied to session, X11, agent and TCP forwarding channels. * sshd(8): add a sshd_config UnusedConnectionTimeout option to terminate client connections that have no open channels for a length of time. This complements the ChannelTimeout option above. * sshd(8): add a -V (version) option to sshd like the ssh client has. * scp(1), sftp(1): add a -X option to both scp(1) and sftp(1) to allow control over some SFTP protocol parameters: the copy buffer length and the number of in-flight requests, both of which are used during upload/download. Previously these could be controlled in sftp(1) only. This makes them available in both SFTP protocol clients using the same option character sequence. * ssh-keyscan(1): allow scanning of complete CIDR address ranges, e.g. "ssh-keyscan 192.168.0.0/24". If a CIDR range is passed, then it will be expanded to all possible addresses in the range including the all-0s and all-1s addresses. bz#976 * ssh(1): support dynamic remote port forwarding in escape command-line's -R processing. bz#3499 MFC after: 1 week Sponsored by: The FreeBSD Foundation
881 lines
24 KiB
C
881 lines
24 KiB
C
/* $OpenBSD: auth.c,v 1.159 2022/12/09 00:17:40 dtucker Exp $ */
|
|
/*
|
|
* Copyright (c) 2000 Markus Friedl. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#ifdef HAVE_PATHS_H
|
|
# include <paths.h>
|
|
#endif
|
|
#include <pwd.h>
|
|
#ifdef HAVE_LOGIN_H
|
|
#include <login.h>
|
|
#endif
|
|
#ifdef USE_SHADOW
|
|
#include <shadow.h>
|
|
#endif
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
#include <netdb.h>
|
|
#include <time.h>
|
|
|
|
#include "xmalloc.h"
|
|
#include "match.h"
|
|
#include "groupaccess.h"
|
|
#include "log.h"
|
|
#include "sshbuf.h"
|
|
#include "misc.h"
|
|
#include "servconf.h"
|
|
#include "sshkey.h"
|
|
#include "hostfile.h"
|
|
#include "auth.h"
|
|
#include "auth-options.h"
|
|
#include "canohost.h"
|
|
#include "uidswap.h"
|
|
#include "packet.h"
|
|
#include "loginrec.h"
|
|
#ifdef GSSAPI
|
|
#include "ssh-gss.h"
|
|
#endif
|
|
#include "authfile.h"
|
|
#include "monitor_wrap.h"
|
|
#include "ssherr.h"
|
|
#include "compat.h"
|
|
#include "channels.h"
|
|
#include "blacklist_client.h"
|
|
|
|
/* import */
|
|
extern ServerOptions options;
|
|
extern struct include_list includes;
|
|
extern int use_privsep;
|
|
extern struct sshbuf *loginmsg;
|
|
extern struct passwd *privsep_pw;
|
|
extern struct sshauthopt *auth_opts;
|
|
|
|
/* Debugging messages */
|
|
static struct sshbuf *auth_debug;
|
|
|
|
/*
|
|
* Check if the user is allowed to log in via ssh. If user is listed
|
|
* in DenyUsers or one of user's groups is listed in DenyGroups, false
|
|
* will be returned. If AllowUsers isn't empty and user isn't listed
|
|
* there, or if AllowGroups isn't empty and one of user's groups isn't
|
|
* listed there, false will be returned.
|
|
* If the user's shell is not executable, false will be returned.
|
|
* Otherwise true is returned.
|
|
*/
|
|
int
|
|
allowed_user(struct ssh *ssh, struct passwd * pw)
|
|
{
|
|
struct stat st;
|
|
const char *hostname = NULL, *ipaddr = NULL;
|
|
u_int i;
|
|
int r;
|
|
|
|
/* Shouldn't be called if pw is NULL, but better safe than sorry... */
|
|
if (!pw || !pw->pw_name)
|
|
return 0;
|
|
|
|
if (!options.use_pam && platform_locked_account(pw)) {
|
|
logit("User %.100s not allowed because account is locked",
|
|
pw->pw_name);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Deny if shell does not exist or is not executable unless we
|
|
* are chrooting.
|
|
*/
|
|
if (options.chroot_directory == NULL ||
|
|
strcasecmp(options.chroot_directory, "none") == 0) {
|
|
char *shell = xstrdup((pw->pw_shell[0] == '\0') ?
|
|
_PATH_BSHELL : pw->pw_shell); /* empty = /bin/sh */
|
|
|
|
if (stat(shell, &st) == -1) {
|
|
logit("User %.100s not allowed because shell %.100s "
|
|
"does not exist", pw->pw_name, shell);
|
|
free(shell);
|
|
return 0;
|
|
}
|
|
if (S_ISREG(st.st_mode) == 0 ||
|
|
(st.st_mode & (S_IXOTH|S_IXUSR|S_IXGRP)) == 0) {
|
|
logit("User %.100s not allowed because shell %.100s "
|
|
"is not executable", pw->pw_name, shell);
|
|
free(shell);
|
|
return 0;
|
|
}
|
|
free(shell);
|
|
}
|
|
|
|
if (options.num_deny_users > 0 || options.num_allow_users > 0 ||
|
|
options.num_deny_groups > 0 || options.num_allow_groups > 0) {
|
|
hostname = auth_get_canonical_hostname(ssh, options.use_dns);
|
|
ipaddr = ssh_remote_ipaddr(ssh);
|
|
}
|
|
|
|
/* Return false if user is listed in DenyUsers */
|
|
if (options.num_deny_users > 0) {
|
|
for (i = 0; i < options.num_deny_users; i++) {
|
|
r = match_user(pw->pw_name, hostname, ipaddr,
|
|
options.deny_users[i]);
|
|
if (r < 0) {
|
|
fatal("Invalid DenyUsers pattern \"%.100s\"",
|
|
options.deny_users[i]);
|
|
} else if (r != 0) {
|
|
logit("User %.100s from %.100s not allowed "
|
|
"because listed in DenyUsers",
|
|
pw->pw_name, hostname);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
/* Return false if AllowUsers isn't empty and user isn't listed there */
|
|
if (options.num_allow_users > 0) {
|
|
for (i = 0; i < options.num_allow_users; i++) {
|
|
r = match_user(pw->pw_name, hostname, ipaddr,
|
|
options.allow_users[i]);
|
|
if (r < 0) {
|
|
fatal("Invalid AllowUsers pattern \"%.100s\"",
|
|
options.allow_users[i]);
|
|
} else if (r == 1)
|
|
break;
|
|
}
|
|
/* i < options.num_allow_users iff we break for loop */
|
|
if (i >= options.num_allow_users) {
|
|
logit("User %.100s from %.100s not allowed because "
|
|
"not listed in AllowUsers", pw->pw_name, hostname);
|
|
return 0;
|
|
}
|
|
}
|
|
if (options.num_deny_groups > 0 || options.num_allow_groups > 0) {
|
|
/* Get the user's group access list (primary and supplementary) */
|
|
if (ga_init(pw->pw_name, pw->pw_gid) == 0) {
|
|
logit("User %.100s from %.100s not allowed because "
|
|
"not in any group", pw->pw_name, hostname);
|
|
return 0;
|
|
}
|
|
|
|
/* Return false if one of user's groups is listed in DenyGroups */
|
|
if (options.num_deny_groups > 0)
|
|
if (ga_match(options.deny_groups,
|
|
options.num_deny_groups)) {
|
|
ga_free();
|
|
logit("User %.100s from %.100s not allowed "
|
|
"because a group is listed in DenyGroups",
|
|
pw->pw_name, hostname);
|
|
return 0;
|
|
}
|
|
/*
|
|
* Return false if AllowGroups isn't empty and one of user's groups
|
|
* isn't listed there
|
|
*/
|
|
if (options.num_allow_groups > 0)
|
|
if (!ga_match(options.allow_groups,
|
|
options.num_allow_groups)) {
|
|
ga_free();
|
|
logit("User %.100s from %.100s not allowed "
|
|
"because none of user's groups are listed "
|
|
"in AllowGroups", pw->pw_name, hostname);
|
|
return 0;
|
|
}
|
|
ga_free();
|
|
}
|
|
|
|
#ifdef CUSTOM_SYS_AUTH_ALLOWED_USER
|
|
if (!sys_auth_allowed_user(pw, loginmsg))
|
|
return 0;
|
|
#endif
|
|
|
|
/* We found no reason not to let this user try to log on... */
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Formats any key left in authctxt->auth_method_key for inclusion in
|
|
* auth_log()'s message. Also includes authxtct->auth_method_info if present.
|
|
*/
|
|
static char *
|
|
format_method_key(Authctxt *authctxt)
|
|
{
|
|
const struct sshkey *key = authctxt->auth_method_key;
|
|
const char *methinfo = authctxt->auth_method_info;
|
|
char *fp, *cafp, *ret = NULL;
|
|
|
|
if (key == NULL)
|
|
return NULL;
|
|
|
|
if (sshkey_is_cert(key)) {
|
|
fp = sshkey_fingerprint(key,
|
|
options.fingerprint_hash, SSH_FP_DEFAULT);
|
|
cafp = sshkey_fingerprint(key->cert->signature_key,
|
|
options.fingerprint_hash, SSH_FP_DEFAULT);
|
|
xasprintf(&ret, "%s %s ID %s (serial %llu) CA %s %s%s%s",
|
|
sshkey_type(key), fp == NULL ? "(null)" : fp,
|
|
key->cert->key_id,
|
|
(unsigned long long)key->cert->serial,
|
|
sshkey_type(key->cert->signature_key),
|
|
cafp == NULL ? "(null)" : cafp,
|
|
methinfo == NULL ? "" : ", ",
|
|
methinfo == NULL ? "" : methinfo);
|
|
free(fp);
|
|
free(cafp);
|
|
} else {
|
|
fp = sshkey_fingerprint(key, options.fingerprint_hash,
|
|
SSH_FP_DEFAULT);
|
|
xasprintf(&ret, "%s %s%s%s", sshkey_type(key),
|
|
fp == NULL ? "(null)" : fp,
|
|
methinfo == NULL ? "" : ", ",
|
|
methinfo == NULL ? "" : methinfo);
|
|
free(fp);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
auth_log(struct ssh *ssh, int authenticated, int partial,
|
|
const char *method, const char *submethod)
|
|
{
|
|
Authctxt *authctxt = (Authctxt *)ssh->authctxt;
|
|
int level = SYSLOG_LEVEL_VERBOSE;
|
|
const char *authmsg;
|
|
char *extra = NULL;
|
|
|
|
if (use_privsep && !mm_is_monitor() && !authctxt->postponed)
|
|
return;
|
|
|
|
/* Raise logging level */
|
|
if (authenticated == 1 ||
|
|
!authctxt->valid ||
|
|
authctxt->failures >= options.max_authtries / 2 ||
|
|
strcmp(method, "password") == 0)
|
|
level = SYSLOG_LEVEL_INFO;
|
|
|
|
if (authctxt->postponed)
|
|
authmsg = "Postponed";
|
|
else if (partial)
|
|
authmsg = "Partial";
|
|
else {
|
|
authmsg = authenticated ? "Accepted" : "Failed";
|
|
if (authenticated)
|
|
BLACKLIST_NOTIFY(ssh, BLACKLIST_AUTH_OK, "ssh");
|
|
}
|
|
|
|
if ((extra = format_method_key(authctxt)) == NULL) {
|
|
if (authctxt->auth_method_info != NULL)
|
|
extra = xstrdup(authctxt->auth_method_info);
|
|
}
|
|
|
|
do_log2(level, "%s %s%s%s for %s%.100s from %.200s port %d ssh2%s%s",
|
|
authmsg,
|
|
method,
|
|
submethod != NULL ? "/" : "", submethod == NULL ? "" : submethod,
|
|
authctxt->valid ? "" : "invalid user ",
|
|
authctxt->user,
|
|
ssh_remote_ipaddr(ssh),
|
|
ssh_remote_port(ssh),
|
|
extra != NULL ? ": " : "",
|
|
extra != NULL ? extra : "");
|
|
|
|
free(extra);
|
|
|
|
#if defined(CUSTOM_FAILED_LOGIN) || defined(SSH_AUDIT_EVENTS)
|
|
if (authenticated == 0 && !(authctxt->postponed || partial)) {
|
|
/* Log failed login attempt */
|
|
# ifdef CUSTOM_FAILED_LOGIN
|
|
if (strcmp(method, "password") == 0 ||
|
|
strncmp(method, "keyboard-interactive", 20) == 0 ||
|
|
strcmp(method, "challenge-response") == 0)
|
|
record_failed_login(ssh, authctxt->user,
|
|
auth_get_canonical_hostname(ssh, options.use_dns), "ssh");
|
|
# endif
|
|
# ifdef SSH_AUDIT_EVENTS
|
|
audit_event(ssh, audit_classify_auth(method));
|
|
# endif
|
|
}
|
|
#endif
|
|
#if defined(CUSTOM_FAILED_LOGIN) && defined(WITH_AIXAUTHENTICATE)
|
|
if (authenticated)
|
|
sys_auth_record_login(authctxt->user,
|
|
auth_get_canonical_hostname(ssh, options.use_dns), "ssh",
|
|
loginmsg);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
auth_maxtries_exceeded(struct ssh *ssh)
|
|
{
|
|
Authctxt *authctxt = (Authctxt *)ssh->authctxt;
|
|
|
|
error("maximum authentication attempts exceeded for "
|
|
"%s%.100s from %.200s port %d ssh2",
|
|
authctxt->valid ? "" : "invalid user ",
|
|
authctxt->user,
|
|
ssh_remote_ipaddr(ssh),
|
|
ssh_remote_port(ssh));
|
|
ssh_packet_disconnect(ssh, "Too many authentication failures");
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
/*
|
|
* Check whether root logins are disallowed.
|
|
*/
|
|
int
|
|
auth_root_allowed(struct ssh *ssh, const char *method)
|
|
{
|
|
switch (options.permit_root_login) {
|
|
case PERMIT_YES:
|
|
return 1;
|
|
case PERMIT_NO_PASSWD:
|
|
if (strcmp(method, "publickey") == 0 ||
|
|
strcmp(method, "hostbased") == 0 ||
|
|
strcmp(method, "gssapi-with-mic") == 0)
|
|
return 1;
|
|
break;
|
|
case PERMIT_FORCED_ONLY:
|
|
if (auth_opts->force_command != NULL) {
|
|
logit("Root login accepted for forced command.");
|
|
return 1;
|
|
}
|
|
break;
|
|
}
|
|
logit("ROOT LOGIN REFUSED FROM %.200s port %d",
|
|
ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Given a template and a passwd structure, build a filename
|
|
* by substituting % tokenised options. Currently, %% becomes '%',
|
|
* %h becomes the home directory and %u the username.
|
|
*
|
|
* This returns a buffer allocated by xmalloc.
|
|
*/
|
|
char *
|
|
expand_authorized_keys(const char *filename, struct passwd *pw)
|
|
{
|
|
char *file, uidstr[32], ret[PATH_MAX];
|
|
int i;
|
|
|
|
snprintf(uidstr, sizeof(uidstr), "%llu",
|
|
(unsigned long long)pw->pw_uid);
|
|
file = percent_expand(filename, "h", pw->pw_dir,
|
|
"u", pw->pw_name, "U", uidstr, (char *)NULL);
|
|
|
|
/*
|
|
* Ensure that filename starts anchored. If not, be backward
|
|
* compatible and prepend the '%h/'
|
|
*/
|
|
if (path_absolute(file))
|
|
return (file);
|
|
|
|
i = snprintf(ret, sizeof(ret), "%s/%s", pw->pw_dir, file);
|
|
if (i < 0 || (size_t)i >= sizeof(ret))
|
|
fatal("expand_authorized_keys: path too long");
|
|
free(file);
|
|
return (xstrdup(ret));
|
|
}
|
|
|
|
char *
|
|
authorized_principals_file(struct passwd *pw)
|
|
{
|
|
if (options.authorized_principals_file == NULL)
|
|
return NULL;
|
|
return expand_authorized_keys(options.authorized_principals_file, pw);
|
|
}
|
|
|
|
/* return ok if key exists in sysfile or userfile */
|
|
HostStatus
|
|
check_key_in_hostfiles(struct passwd *pw, struct sshkey *key, const char *host,
|
|
const char *sysfile, const char *userfile)
|
|
{
|
|
char *user_hostfile;
|
|
struct stat st;
|
|
HostStatus host_status;
|
|
struct hostkeys *hostkeys;
|
|
const struct hostkey_entry *found;
|
|
|
|
hostkeys = init_hostkeys();
|
|
load_hostkeys(hostkeys, host, sysfile, 0);
|
|
if (userfile != NULL) {
|
|
user_hostfile = tilde_expand_filename(userfile, pw->pw_uid);
|
|
if (options.strict_modes &&
|
|
(stat(user_hostfile, &st) == 0) &&
|
|
((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
|
|
(st.st_mode & 022) != 0)) {
|
|
logit("Authentication refused for %.100s: "
|
|
"bad owner or modes for %.200s",
|
|
pw->pw_name, user_hostfile);
|
|
auth_debug_add("Ignored %.200s: bad ownership or modes",
|
|
user_hostfile);
|
|
} else {
|
|
temporarily_use_uid(pw);
|
|
load_hostkeys(hostkeys, host, user_hostfile, 0);
|
|
restore_uid();
|
|
}
|
|
free(user_hostfile);
|
|
}
|
|
host_status = check_key_in_hostkeys(hostkeys, key, &found);
|
|
if (host_status == HOST_REVOKED)
|
|
error("WARNING: revoked key for %s attempted authentication",
|
|
host);
|
|
else if (host_status == HOST_OK)
|
|
debug_f("key for %s found at %s:%ld",
|
|
found->host, found->file, found->line);
|
|
else
|
|
debug_f("key for host %s not found", host);
|
|
|
|
free_hostkeys(hostkeys);
|
|
|
|
return host_status;
|
|
}
|
|
|
|
struct passwd *
|
|
getpwnamallow(struct ssh *ssh, const char *user)
|
|
{
|
|
#ifdef HAVE_LOGIN_CAP
|
|
extern login_cap_t *lc;
|
|
#ifdef HAVE_AUTH_HOSTOK
|
|
const char *from_host, *from_ip;
|
|
#endif
|
|
#ifdef BSD_AUTH
|
|
auth_session_t *as;
|
|
#endif
|
|
#endif
|
|
struct passwd *pw;
|
|
struct connection_info *ci;
|
|
u_int i;
|
|
|
|
ci = get_connection_info(ssh, 1, options.use_dns);
|
|
ci->user = user;
|
|
parse_server_match_config(&options, &includes, ci);
|
|
log_change_level(options.log_level);
|
|
log_verbose_reset();
|
|
for (i = 0; i < options.num_log_verbose; i++)
|
|
log_verbose_add(options.log_verbose[i]);
|
|
process_permitopen(ssh, &options);
|
|
|
|
#if defined(_AIX) && defined(HAVE_SETAUTHDB)
|
|
aix_setauthdb(user);
|
|
#endif
|
|
|
|
pw = getpwnam(user);
|
|
|
|
#if defined(_AIX) && defined(HAVE_SETAUTHDB)
|
|
aix_restoreauthdb();
|
|
#endif
|
|
if (pw == NULL) {
|
|
BLACKLIST_NOTIFY(ssh, BLACKLIST_BAD_USER, user);
|
|
logit("Invalid user %.100s from %.100s port %d",
|
|
user, ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));
|
|
#ifdef CUSTOM_FAILED_LOGIN
|
|
record_failed_login(ssh, user,
|
|
auth_get_canonical_hostname(ssh, options.use_dns), "ssh");
|
|
#endif
|
|
#ifdef SSH_AUDIT_EVENTS
|
|
audit_event(ssh, SSH_INVALID_USER);
|
|
#endif /* SSH_AUDIT_EVENTS */
|
|
return (NULL);
|
|
}
|
|
if (!allowed_user(ssh, pw))
|
|
return (NULL);
|
|
#ifdef HAVE_LOGIN_CAP
|
|
if ((lc = login_getpwclass(pw)) == NULL) {
|
|
debug("unable to get login class: %s", user);
|
|
return (NULL);
|
|
}
|
|
#ifdef HAVE_AUTH_HOSTOK
|
|
from_host = auth_get_canonical_hostname(ssh, options.use_dns);
|
|
from_ip = ssh_remote_ipaddr(ssh);
|
|
if (!auth_hostok(lc, from_host, from_ip)) {
|
|
debug("Denied connection for %.200s from %.200s [%.200s].",
|
|
pw->pw_name, from_host, from_ip);
|
|
return (NULL);
|
|
}
|
|
#endif /* HAVE_AUTH_HOSTOK */
|
|
#ifdef HAVE_AUTH_TIMEOK
|
|
if (!auth_timeok(lc, time(NULL))) {
|
|
debug("LOGIN %.200s REFUSED (TIME)", pw->pw_name);
|
|
return (NULL);
|
|
}
|
|
#endif /* HAVE_AUTH_TIMEOK */
|
|
#ifdef BSD_AUTH
|
|
if ((as = auth_open()) == NULL || auth_setpwd(as, pw) != 0 ||
|
|
auth_approval(as, lc, pw->pw_name, "ssh") <= 0) {
|
|
debug("Approval failure for %s", user);
|
|
pw = NULL;
|
|
}
|
|
if (as != NULL)
|
|
auth_close(as);
|
|
#endif
|
|
#endif
|
|
if (pw != NULL)
|
|
return (pwcopy(pw));
|
|
return (NULL);
|
|
}
|
|
|
|
/* Returns 1 if key is revoked by revoked_keys_file, 0 otherwise */
|
|
int
|
|
auth_key_is_revoked(struct sshkey *key)
|
|
{
|
|
char *fp = NULL;
|
|
int r;
|
|
|
|
if (options.revoked_keys_file == NULL)
|
|
return 0;
|
|
if ((fp = sshkey_fingerprint(key, options.fingerprint_hash,
|
|
SSH_FP_DEFAULT)) == NULL) {
|
|
r = SSH_ERR_ALLOC_FAIL;
|
|
error_fr(r, "fingerprint key");
|
|
goto out;
|
|
}
|
|
|
|
r = sshkey_check_revoked(key, options.revoked_keys_file);
|
|
switch (r) {
|
|
case 0:
|
|
break; /* not revoked */
|
|
case SSH_ERR_KEY_REVOKED:
|
|
error("Authentication key %s %s revoked by file %s",
|
|
sshkey_type(key), fp, options.revoked_keys_file);
|
|
goto out;
|
|
default:
|
|
error_r(r, "Error checking authentication key %s %s in "
|
|
"revoked keys file %s", sshkey_type(key), fp,
|
|
options.revoked_keys_file);
|
|
goto out;
|
|
}
|
|
|
|
/* Success */
|
|
r = 0;
|
|
|
|
out:
|
|
free(fp);
|
|
return r == 0 ? 0 : 1;
|
|
}
|
|
|
|
void
|
|
auth_debug_add(const char *fmt,...)
|
|
{
|
|
char buf[1024];
|
|
va_list args;
|
|
int r;
|
|
|
|
va_start(args, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, args);
|
|
va_end(args);
|
|
debug3("%s", buf);
|
|
if (auth_debug != NULL)
|
|
if ((r = sshbuf_put_cstring(auth_debug, buf)) != 0)
|
|
fatal_fr(r, "sshbuf_put_cstring");
|
|
}
|
|
|
|
void
|
|
auth_debug_send(struct ssh *ssh)
|
|
{
|
|
char *msg;
|
|
int r;
|
|
|
|
if (auth_debug == NULL)
|
|
return;
|
|
while (sshbuf_len(auth_debug) != 0) {
|
|
if ((r = sshbuf_get_cstring(auth_debug, &msg, NULL)) != 0)
|
|
fatal_fr(r, "sshbuf_get_cstring");
|
|
ssh_packet_send_debug(ssh, "%s", msg);
|
|
free(msg);
|
|
}
|
|
}
|
|
|
|
void
|
|
auth_debug_reset(void)
|
|
{
|
|
if (auth_debug != NULL)
|
|
sshbuf_reset(auth_debug);
|
|
else if ((auth_debug = sshbuf_new()) == NULL)
|
|
fatal_f("sshbuf_new failed");
|
|
}
|
|
|
|
struct passwd *
|
|
fakepw(void)
|
|
{
|
|
static int done = 0;
|
|
static struct passwd fake;
|
|
const char hashchars[] = "./ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
"abcdefghijklmnopqrstuvwxyz0123456789"; /* from bcrypt.c */
|
|
char *cp;
|
|
|
|
if (done)
|
|
return (&fake);
|
|
|
|
memset(&fake, 0, sizeof(fake));
|
|
fake.pw_name = "NOUSER";
|
|
fake.pw_passwd = xstrdup("$2a$10$"
|
|
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
|
|
for (cp = fake.pw_passwd + 7; *cp != '\0'; cp++)
|
|
*cp = hashchars[arc4random_uniform(sizeof(hashchars) - 1)];
|
|
#ifdef HAVE_STRUCT_PASSWD_PW_GECOS
|
|
fake.pw_gecos = "NOUSER";
|
|
#endif
|
|
fake.pw_uid = privsep_pw == NULL ? (uid_t)-1 : privsep_pw->pw_uid;
|
|
fake.pw_gid = privsep_pw == NULL ? (gid_t)-1 : privsep_pw->pw_gid;
|
|
#ifdef HAVE_STRUCT_PASSWD_PW_CLASS
|
|
fake.pw_class = "";
|
|
#endif
|
|
fake.pw_dir = "/nonexist";
|
|
fake.pw_shell = "/nonexist";
|
|
done = 1;
|
|
|
|
return (&fake);
|
|
}
|
|
|
|
/*
|
|
* Returns the remote DNS hostname as a string. The returned string must not
|
|
* be freed. NB. this will usually trigger a DNS query the first time it is
|
|
* called.
|
|
* This function does additional checks on the hostname to mitigate some
|
|
* attacks on based on conflation of hostnames and IP addresses.
|
|
*/
|
|
|
|
static char *
|
|
remote_hostname(struct ssh *ssh)
|
|
{
|
|
struct sockaddr_storage from;
|
|
socklen_t fromlen;
|
|
struct addrinfo hints, *ai, *aitop;
|
|
char name[NI_MAXHOST], ntop2[NI_MAXHOST];
|
|
const char *ntop = ssh_remote_ipaddr(ssh);
|
|
|
|
/* Get IP address of client. */
|
|
fromlen = sizeof(from);
|
|
memset(&from, 0, sizeof(from));
|
|
if (getpeername(ssh_packet_get_connection_in(ssh),
|
|
(struct sockaddr *)&from, &fromlen) == -1) {
|
|
debug("getpeername failed: %.100s", strerror(errno));
|
|
return xstrdup(ntop);
|
|
}
|
|
|
|
ipv64_normalise_mapped(&from, &fromlen);
|
|
if (from.ss_family == AF_INET6)
|
|
fromlen = sizeof(struct sockaddr_in6);
|
|
|
|
debug3("Trying to reverse map address %.100s.", ntop);
|
|
/* Map the IP address to a host name. */
|
|
if (getnameinfo((struct sockaddr *)&from, fromlen, name, sizeof(name),
|
|
NULL, 0, NI_NAMEREQD) != 0) {
|
|
/* Host name not found. Use ip address. */
|
|
return xstrdup(ntop);
|
|
}
|
|
|
|
/*
|
|
* if reverse lookup result looks like a numeric hostname,
|
|
* someone is trying to trick us by PTR record like following:
|
|
* 1.1.1.10.in-addr.arpa. IN PTR 2.3.4.5
|
|
*/
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_socktype = SOCK_DGRAM; /*dummy*/
|
|
hints.ai_flags = AI_NUMERICHOST;
|
|
if (getaddrinfo(name, NULL, &hints, &ai) == 0) {
|
|
logit("Nasty PTR record \"%s\" is set up for %s, ignoring",
|
|
name, ntop);
|
|
freeaddrinfo(ai);
|
|
return xstrdup(ntop);
|
|
}
|
|
|
|
/* Names are stored in lowercase. */
|
|
lowercase(name);
|
|
|
|
/*
|
|
* Map it back to an IP address and check that the given
|
|
* address actually is an address of this host. This is
|
|
* necessary because anyone with access to a name server can
|
|
* define arbitrary names for an IP address. Mapping from
|
|
* name to IP address can be trusted better (but can still be
|
|
* fooled if the intruder has access to the name server of
|
|
* the domain).
|
|
*/
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_family = from.ss_family;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
if (getaddrinfo(name, NULL, &hints, &aitop) != 0) {
|
|
logit("reverse mapping checking getaddrinfo for %.700s "
|
|
"[%s] failed.", name, ntop);
|
|
return xstrdup(ntop);
|
|
}
|
|
/* Look for the address from the list of addresses. */
|
|
for (ai = aitop; ai; ai = ai->ai_next) {
|
|
if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop2,
|
|
sizeof(ntop2), NULL, 0, NI_NUMERICHOST) == 0 &&
|
|
(strcmp(ntop, ntop2) == 0))
|
|
break;
|
|
}
|
|
freeaddrinfo(aitop);
|
|
/* If we reached the end of the list, the address was not there. */
|
|
if (ai == NULL) {
|
|
/* Address not found for the host name. */
|
|
logit("Address %.100s maps to %.600s, but this does not "
|
|
"map back to the address.", ntop, name);
|
|
return xstrdup(ntop);
|
|
}
|
|
return xstrdup(name);
|
|
}
|
|
|
|
/*
|
|
* Return the canonical name of the host in the other side of the current
|
|
* connection. The host name is cached, so it is efficient to call this
|
|
* several times.
|
|
*/
|
|
|
|
const char *
|
|
auth_get_canonical_hostname(struct ssh *ssh, int use_dns)
|
|
{
|
|
static char *dnsname;
|
|
|
|
if (!use_dns)
|
|
return ssh_remote_ipaddr(ssh);
|
|
else if (dnsname != NULL)
|
|
return dnsname;
|
|
else {
|
|
dnsname = remote_hostname(ssh);
|
|
return dnsname;
|
|
}
|
|
}
|
|
|
|
/* These functions link key/cert options to the auth framework */
|
|
|
|
/* Log sshauthopt options locally and (optionally) for remote transmission */
|
|
void
|
|
auth_log_authopts(const char *loc, const struct sshauthopt *opts, int do_remote)
|
|
{
|
|
int do_env = options.permit_user_env && opts->nenv > 0;
|
|
int do_permitopen = opts->npermitopen > 0 &&
|
|
(options.allow_tcp_forwarding & FORWARD_LOCAL) != 0;
|
|
int do_permitlisten = opts->npermitlisten > 0 &&
|
|
(options.allow_tcp_forwarding & FORWARD_REMOTE) != 0;
|
|
size_t i;
|
|
char msg[1024], buf[64];
|
|
|
|
snprintf(buf, sizeof(buf), "%d", opts->force_tun_device);
|
|
/* Try to keep this alphabetically sorted */
|
|
snprintf(msg, sizeof(msg), "key options:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
|
|
opts->permit_agent_forwarding_flag ? " agent-forwarding" : "",
|
|
opts->force_command == NULL ? "" : " command",
|
|
do_env ? " environment" : "",
|
|
opts->valid_before == 0 ? "" : "expires",
|
|
opts->no_require_user_presence ? " no-touch-required" : "",
|
|
do_permitopen ? " permitopen" : "",
|
|
do_permitlisten ? " permitlisten" : "",
|
|
opts->permit_port_forwarding_flag ? " port-forwarding" : "",
|
|
opts->cert_principals == NULL ? "" : " principals",
|
|
opts->permit_pty_flag ? " pty" : "",
|
|
opts->require_verify ? " uv" : "",
|
|
opts->force_tun_device == -1 ? "" : " tun=",
|
|
opts->force_tun_device == -1 ? "" : buf,
|
|
opts->permit_user_rc ? " user-rc" : "",
|
|
opts->permit_x11_forwarding_flag ? " x11-forwarding" : "");
|
|
|
|
debug("%s: %s", loc, msg);
|
|
if (do_remote)
|
|
auth_debug_add("%s: %s", loc, msg);
|
|
|
|
if (options.permit_user_env) {
|
|
for (i = 0; i < opts->nenv; i++) {
|
|
debug("%s: environment: %s", loc, opts->env[i]);
|
|
if (do_remote) {
|
|
auth_debug_add("%s: environment: %s",
|
|
loc, opts->env[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Go into a little more details for the local logs. */
|
|
if (opts->valid_before != 0) {
|
|
format_absolute_time(opts->valid_before, buf, sizeof(buf));
|
|
debug("%s: expires at %s", loc, buf);
|
|
}
|
|
if (opts->cert_principals != NULL) {
|
|
debug("%s: authorized principals: \"%s\"",
|
|
loc, opts->cert_principals);
|
|
}
|
|
if (opts->force_command != NULL)
|
|
debug("%s: forced command: \"%s\"", loc, opts->force_command);
|
|
if (do_permitopen) {
|
|
for (i = 0; i < opts->npermitopen; i++) {
|
|
debug("%s: permitted open: %s",
|
|
loc, opts->permitopen[i]);
|
|
}
|
|
}
|
|
if (do_permitlisten) {
|
|
for (i = 0; i < opts->npermitlisten; i++) {
|
|
debug("%s: permitted listen: %s",
|
|
loc, opts->permitlisten[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Activate a new set of key/cert options; merging with what is there. */
|
|
int
|
|
auth_activate_options(struct ssh *ssh, struct sshauthopt *opts)
|
|
{
|
|
struct sshauthopt *old = auth_opts;
|
|
const char *emsg = NULL;
|
|
|
|
debug_f("setting new authentication options");
|
|
if ((auth_opts = sshauthopt_merge(old, opts, &emsg)) == NULL) {
|
|
error("Inconsistent authentication options: %s", emsg);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Disable forwarding, etc for the session */
|
|
void
|
|
auth_restrict_session(struct ssh *ssh)
|
|
{
|
|
struct sshauthopt *restricted;
|
|
|
|
debug_f("restricting session");
|
|
|
|
/* A blank sshauthopt defaults to permitting nothing */
|
|
if ((restricted = sshauthopt_new()) == NULL)
|
|
fatal_f("sshauthopt_new failed");
|
|
restricted->permit_pty_flag = 1;
|
|
restricted->restricted = 1;
|
|
|
|
if (auth_activate_options(ssh, restricted) != 0)
|
|
fatal_f("failed to restrict session");
|
|
sshauthopt_free(restricted);
|
|
}
|