The branch main has been updated by emaste:
URL:
https://cgit.FreeBSD.org/src/commit/?id=3d9fd9fcb432750f3716b28f6ccb0104cd9d351a
commit 3d9fd9fcb432750f3716b28f6ccb0104cd9d351a
Merge: 58d43a3cd72a 126e0f4f7dcb
Author: Ed Maste <ema...@freebsd.org>
AuthorDate: 2025-02-19 19:08:59 +0000
Commit: Ed Maste <ema...@freebsd.org>
CommitDate: 2025-02-19 19:08:59 +0000
openssh: Update to 9.9p1
Highlights from the release notes are reproduced below. Bug fixes and
improvements that were previously merged into FreeBSD have been elided.
See the upstream release notes for full details of the 9.9p1 release
(https://www.openssh.com/releasenotes.html).
---
Future deprecation notice
=========================
OpenSSH plans to remove support for the DSA signature algorithm in
early 2025.
Potentially-incompatible changes
--------------------------------
* ssh(1): remove support for pre-authentication compression.
* ssh(1), sshd(8): processing of the arguments to the "Match"
configuration directive now follows more shell-like rules for
quoted strings, including allowing nested quotes and \-escaped
characters.
New features
------------
* ssh(1), sshd(8): add support for a new hybrid post-quantum key
exchange based on the FIPS 203 Module-Lattice Key Enapsulation
mechanism (ML-KEM) combined with X25519 ECDH as described by
https://datatracker.ietf.org/doc/html/draft-kampanakis-curdle-ssh-pq-ke-03
This algorithm "mlkem768x25519-sha256" is available by default.
* ssh(1), sshd(8), ssh-agent(1): prevent private keys from being
included in core dump files for most of their lifespans. This is
in addition to pre-existing controls in ssh-agent(1) and sshd(8)
that prevented coredumps. This feature is supported on OpenBSD,
Linux and FreeBSD.
* All: convert key handling to use the libcrypto EVP_PKEY API, with
the exception of DSA.
Bugfixes
--------
* sshd(8): do not apply authorized_keys options when signature
verification fails. Prevents more restrictive key options being
incorrectly applied to subsequent keys in authorized_keys. bz3733
* ssh-keygen(1): include pathname in some of ssh-keygen's passphrase
prompts. Helps the user know what's going on when ssh-keygen is
invoked via other tools. Requested in GHPR503
* ssh(1), ssh-add(1): make parsing user@host consistently look for
the last '@' in the string rather than the first. This makes it
possible to more consistently use usernames that contain '@'
characters.
* ssh(1), sshd(8): be more strict in parsing key type names. Only
allow short names (e.g "rsa") in user-interface code and require
full SSH protocol names (e.g. "ssh-rsa") everywhere else. bz3725
* ssh-keygen(1): clarify that ed25519 is the default key type
generated and clarify that rsa-sha2-512 is the default signature
scheme when RSA is in use. GHPR505
---
Reviewed by: jlduran (build infrastructure)
Reviewed by: cy (build infrastructure)
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D48947
crypto/openssh/.depend | 3 +-
crypto/openssh/.github/ci-status.md | 4 +
crypto/openssh/.github/configs | 8 +-
crypto/openssh/.github/setup_ci.sh | 2 +-
crypto/openssh/.github/workflows/c-cpp.yml | 1 -
crypto/openssh/.github/workflows/selfhosted.yml | 3 +
crypto/openssh/ChangeLog | 11538 ++++++++---------
crypto/openssh/LICENCE | 41 +
crypto/openssh/Makefile.in | 2 +-
crypto/openssh/README | 2 +-
crypto/openssh/auth.c | 5 +-
crypto/openssh/channels.c | 8 +-
crypto/openssh/channels.h | 4 +-
crypto/openssh/cipher.c | 8 +-
crypto/openssh/config.h | 6 +
crypto/openssh/configure.ac | 11 +-
crypto/openssh/contrib/redhat/openssh.spec | 6 +-
crypto/openssh/contrib/ssh-copy-id | 62 +-
crypto/openssh/contrib/ssh-copy-id.1 | 21 +-
crypto/openssh/contrib/suse/openssh.spec | 2 +-
crypto/openssh/crypto_api.h | 7 +-
crypto/openssh/defines.h | 4 +-
crypto/openssh/kex-names.c | 8 +-
crypto/openssh/kex.c | 4 +-
crypto/openssh/kex.h | 16 +-
crypto/openssh/kexc25519.c | 4 +-
crypto/openssh/kexgen.c | 15 +-
crypto/openssh/kexmlkem768x25519.c | 280 +
crypto/openssh/kexsntrup761x25519.c | 6 +-
crypto/openssh/libcrux_mlkem768_sha3.h | 12332 +++++++++++++++++++
crypto/openssh/loginrec.c | 89 +-
crypto/openssh/match.c | 8 +-
crypto/openssh/mlkem768.sh | 148 +
crypto/openssh/moduli | 879 +-
crypto/openssh/monitor.c | 15 +-
crypto/openssh/mux.c | 28 +-
crypto/openssh/myproposal.h | 4 +-
crypto/openssh/nchan.c | 6 +-
crypto/openssh/openbsd-compat/arc4random.h | 2 +
crypto/openssh/openbsd-compat/openssl-compat.c | 26 +
crypto/openssh/openbsd-compat/openssl-compat.h | 10 +
crypto/openssh/openbsd-compat/port-linux.c | 2 +-
crypto/openssh/packet.c | 24 +-
crypto/openssh/packet.h | 6 +-
crypto/openssh/readconf.c | 164 +-
crypto/openssh/regress/cfginclude.sh | 26 +-
crypto/openssh/regress/misc/fuzz-harness/Makefile | 44 +-
.../regress/misc/fuzz-harness/mkcorpus_sntrup761.c | 82 +
.../misc/fuzz-harness/sntrup761_dec_fuzz.cc | 74 +
.../misc/fuzz-harness/sntrup761_enc_fuzz.cc | 57 +
.../regress/misc/fuzz-harness/watch-sntrup761.sh | 20 +
crypto/openssh/regress/multiplex.sh | 29 +-
crypto/openssh/regress/rekey.sh | 118 +-
crypto/openssh/regress/unittests/kex/Makefile | 3 +-
crypto/openssh/regress/unittests/kex/test_kex.c | 6 +-
crypto/openssh/regress/unittests/sshkey/common.c | 18 +-
.../openssh/regress/unittests/sshkey/test_file.c | 11 +-
.../openssh/regress/unittests/sshkey/test_sshkey.c | 26 +-
.../openssh/regress/unittests/test_helper/fuzz.c | 2 +-
crypto/openssh/servconf.c | 79 +-
crypto/openssh/servconf.h | 6 +-
crypto/openssh/sntrup761.c | 2886 +++--
crypto/openssh/sntrup761.sh | 62 +-
crypto/openssh/srclimit.c | 4 +
crypto/openssh/srclimit.h | 12 +-
crypto/openssh/ssh-add.c | 4 +-
crypto/openssh/ssh-ecdsa-sk.c | 49 +-
crypto/openssh/ssh-ecdsa.c | 258 +-
crypto/openssh/ssh-keygen.1 | 8 +-
crypto/openssh/ssh-keygen.c | 93 +-
crypto/openssh/ssh-keyscan.c | 5 +-
crypto/openssh/ssh-pkcs11-client.c | 83 +-
crypto/openssh/ssh-pkcs11-helper.c | 89 +-
crypto/openssh/ssh-pkcs11.c | 42 +-
crypto/openssh/ssh-rsa.c | 385 +-
crypto/openssh/ssh-sk.c | 29 +-
crypto/openssh/ssh.1 | 6 +-
crypto/openssh/ssh_api.c | 4 +-
crypto/openssh/ssh_config.5 | 22 +-
crypto/openssh/ssh_namespace.h | 31 +-
crypto/openssh/sshbuf-getput-crypto.c | 12 +-
crypto/openssh/sshbuf.c | 18 +-
crypto/openssh/sshbuf.h | 4 +-
crypto/openssh/sshconnect2.c | 3 +-
crypto/openssh/sshd-session.c | 31 +-
crypto/openssh/sshd.8 | 8 +-
crypto/openssh/sshd.c | 14 +-
crypto/openssh/sshd_config.5 | 45 +-
crypto/openssh/sshkey.c | 290 +-
crypto/openssh/sshkey.h | 27 +-
crypto/openssh/version.h | 4 +-
secure/lib/libssh/Makefile | 2 +-
92 files changed, 22746 insertions(+), 8209 deletions(-)
diff --cc crypto/openssh/auth.c
index 059104f26688,000000000000..961082b76667
mode 100644,000000..100644
--- a/crypto/openssh/auth.c
+++ b/crypto/openssh/auth.c
@@@ -1,785 -1,0 +1,786 @@@
- /* $OpenBSD: auth.c,v 1.161 2024/05/17 00:30:23 djm Exp $ */
++/* $OpenBSD: auth.c,v 1.162 2024/09/15 01:18:26 djm 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 "channels.h"
+#include "blacklist_client.h"
+
+/* import */
+extern ServerOptions options;
+extern struct include_list includes;
+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 (!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 = server_get_connection_info(ssh, 1, options.use_dns);
+ ci->user = user;
++ ci->user_invalid = getpwnam(user) == NULL;
+ 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]);
+ server_process_permitopen(ssh);
+
+#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);
++ 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);
+}
+
+/*
+ * 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);
+ if (dnsname != NULL)
+ return dnsname;
+ dnsname = ssh_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);
+}
diff --cc crypto/openssh/config.h
index 1fe7eae0c0fd,000000000000..904a6f91c210
mode 100644,000000..100644
--- a/crypto/openssh/config.h
+++ b/crypto/openssh/config.h
@@@ -1,2071 -1,0 +1,2077 @@@
+/* config.h. Generated from config.h.in by configure. */
+/* config.h.in. Generated from configure.ac by autoheader. */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* Define if you have a getaddrinfo that fails for the all-zeros IPv6 address
*** 12087 LINES SKIPPED ***
