git: bd9d7cdd1420 - main - OpenSSH: Update to 10.5p1
- Reply: Herbert J. Skuhra: "Re: git: bd9d7cdd1420 - main - OpenSSH: Update to 10.5p1"
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Mon, 09 Nov 2026 14:55:03 UTC
The branch main has been updated by emaste:
URL: https://cgit.FreeBSD.org/src/commit/?id=bd9d7cdd142073d2a83d2748df8781ee552f2336
commit bd9d7cdd142073d2a83d2748df8781ee552f2336
Merge: dbeadd4326a0 d0b3de198145
Author: Ed Maste <emaste@FreeBSD.org>
AuthorDate: 2026-11-09 14:54:42 +0000
Commit: Ed Maste <emaste@FreeBSD.org>
CommitDate: 2026-11-09 14:54:42 +0000
OpenSSH: Update to 10.5p1
This release contains security fixes and small bugfixes.
Full release notes are available at
https://www.openssh.com/txt/release-10.5.
Selected items from the release notes:
Security
========
* ssh-agent(1): fix an interaction between agent locking and the
session-bind@openssh.com extension that is used to identify
forwarded agents. These binding requests were refused when the
agent was locked, with the result that operations that were
intended to be limited to local use only could be performed
remotely, including the ability to add PKCS#11 tokens and make
use of keys that had destination restrictions applied.
Reported by sn0x-sharma
* ssh(1): avoid potential realloc use-after-free in the client if a
remote forwarding is added via the local session multiplexing
socket while a remote forwarding open request is pending with the
server. Report and fix from Brian Mingus of Cognatory
* sshd(8): make the authorized_keys "restrict" keyword apply
correctly to tunnel forwarding too (which is administratively
disabled by default). Reported by Erichen, Institute of Computing
Technology, Chinese Academy of Sciences
New features
------------
* ssh-keygen(1): add ability to set or clear the touch-required and
verify-required flags on FIDO private keys when resetting a
private key's passphrase.
* ssh(1): tweak ordering of certificates tried during pubkey
authentication to prefer FIDO keys that do not require user
presence (touch) first, and FIDO keys that require user
verification via PIN or biometrics last. This effectively tries
low-friction authenticators before higher friction ones.
* ssh(1): add a "ssh -Z user@host" mode that prints the keys that
will be tried for public key authentication in the order that
they will be used.
* sshd(8) use setproctitle(3) to identify sshd-session when its
acting as a post-authentication monitor.
Sponsored by: The FreeBSD Foundation
crypto/openssh/.depend | 5 +-
crypto/openssh/.github/ci-status.md | 5 +
crypto/openssh/.github/setup_ci.sh | 11 +-
crypto/openssh/.github/workflows/c-cpp.yml | 5 +-
crypto/openssh/.github/workflows/selfhosted.yml | 3 +-
crypto/openssh/.github/workflows/vm.yml | 4 +-
crypto/openssh/ChangeLog | 807 ++++++++++++++++++---
crypto/openssh/Makefile.in | 2 +-
crypto/openssh/README.md | 2 +-
crypto/openssh/README.tun | 132 ----
crypto/openssh/auth.c | 5 +-
crypto/openssh/auth2-gss.c | 4 +-
crypto/openssh/auth2-hostbased.c | 13 +-
crypto/openssh/auth2-pubkey.c | 12 +-
crypto/openssh/authfile.c | 4 +-
crypto/openssh/config.h | 15 +-
crypto/openssh/configure.ac | 143 ++--
crypto/openssh/contrib/redhat/openssh.spec | 2 +-
crypto/openssh/contrib/suse/openssh.spec | 2 +-
crypto/openssh/crypto_api.h | 6 +-
crypto/openssh/fixalgorithms | 4 +-
crypto/openssh/kex-names.c | 12 +-
crypto/openssh/kex.c | 2 -
crypto/openssh/kex.h | 44 +-
crypto/openssh/kexecdh.c | 68 +-
crypto/openssh/kexgen.c | 13 +-
crypto/openssh/kexmlkem768ecdh.c | 308 ++++++++
crypto/openssh/monitor.c | 19 +-
crypto/openssh/monitor_wrap.c | 4 +-
crypto/openssh/myproposal.h | 6 +-
crypto/openssh/openbsd-compat/fake-rfc2553.c | 2 +-
crypto/openssh/openbsd-compat/openssl-compat.h | 2 -
crypto/openssh/packet.c | 17 +-
crypto/openssh/packet.h | 36 +-
crypto/openssh/readconf.c | 16 +-
crypto/openssh/regress/Makefile | 2 +-
crypto/openssh/regress/agent.sh | 3 +-
crypto/openssh/regress/cfgparse.sh | 52 +-
crypto/openssh/regress/channel-timeout.sh | 13 +-
crypto/openssh/regress/ecdsa256_openssh.prv | 8 +
crypto/openssh/regress/ecdsa256_openssh.pub | 1 +
crypto/openssh/regress/ecdsa384_openssh.prv | 10 +
crypto/openssh/regress/ecdsa384_openssh.pub | 1 +
crypto/openssh/regress/ecdsa521_openssh.prv | 12 +
crypto/openssh/regress/ecdsa521_openssh.pub | 1 +
crypto/openssh/regress/keyscan.sh | 39 +-
crypto/openssh/regress/misc/sk-dummy/sk-dummy.c | 4 +-
crypto/openssh/regress/pubkey-priority.sh | 120 +++
crypto/openssh/regress/rekey.sh | 24 +-
crypto/openssh/regress/sshfp-connect.sh | 183 ++++-
crypto/openssh/regress/unittests/bitmap/tests.c | 2 +-
.../openssh/regress/unittests/conversion/tests.c | 1 +
.../regress/unittests/hostkeys/test_iterate.c | 9 -
crypto/openssh/regress/unittests/kex/Makefile | 3 +-
crypto/openssh/regress/unittests/kex/test_kex.c | 12 +-
.../unittests/sshbuf/test_sshbuf_getput_crypto.c | 15 +-
.../unittests/sshbuf/test_sshbuf_getput_fuzz.c | 8 +-
crypto/openssh/regress/unittests/sshkey/common.c | 4 +-
.../openssh/regress/unittests/sshkey/test_file.c | 9 +-
.../openssh/regress/unittests/sshkey/test_fuzz.c | 13 +-
.../openssh/regress/unittests/sshkey/test_sshkey.c | 39 +-
crypto/openssh/regress/unittests/sshsig/tests.c | 8 +-
.../regress/unittests/test_helper/test_helper.c | 4 +-
crypto/openssh/servconf.c | 34 +-
crypto/openssh/servconf.h | 4 +-
crypto/openssh/serverloop.c | 5 +-
crypto/openssh/sk-usbhid.c | 9 -
crypto/openssh/ssh-add.1 | 13 +-
crypto/openssh/ssh-add.c | 5 +-
crypto/openssh/ssh-agent.c | 25 +-
crypto/openssh/ssh-ecdsa-sk.c | 19 +-
crypto/openssh/ssh-ecdsa.c | 10 +-
crypto/openssh/ssh-ed25519.c | 5 +-
crypto/openssh/ssh-keygen.1 | 41 +-
crypto/openssh/ssh-keygen.c | 56 +-
crypto/openssh/ssh-keyscan.c | 101 +--
crypto/openssh/ssh-keysign.8 | 6 +-
crypto/openssh/ssh-mldsa-eddsa.c | 48 +-
crypto/openssh/ssh-pkcs11.c | 26 +-
crypto/openssh/ssh-sk.c | 13 +-
crypto/openssh/ssh.1 | 129 +---
crypto/openssh/ssh.c | 92 ++-
crypto/openssh/ssh_api.c | 8 +-
crypto/openssh/ssh_config.5 | 24 +-
crypto/openssh/sshbuf-getput-crypto.c | 8 +-
crypto/openssh/sshbuf.h | 23 +-
crypto/openssh/sshconnect.h | 4 +-
crypto/openssh/sshconnect2.c | 159 +++-
crypto/openssh/sshd-auth.c | 12 +-
crypto/openssh/sshd-session.c | 4 +-
crypto/openssh/sshd.8 | 12 +-
crypto/openssh/sshd_config | 5 +-
crypto/openssh/sshd_config.5 | 26 +-
crypto/openssh/sshkey.c | 42 +-
crypto/openssh/sshkey.h | 42 +-
crypto/openssh/version.h | 6 +-
secure/lib/libssh/Makefile | 2 +-
97 files changed, 2173 insertions(+), 1180 deletions(-)
diff --cc crypto/openssh/README.md
index 1cfcd7bb9feb,000000000000..c7c0805211c1
mode 100644,000000..100644
--- a/crypto/openssh/README.md
+++ b/crypto/openssh/README.md
@@@ -1,89 -1,0 +1,89 @@@
+# Portable OpenSSH
+
+[](../../actions/workflows/c-cpp.yml)
+[](../../actions/workflows/vm.yml)
+[](https://github.com/openssh/openssh-portable-selfhosted/actions/workflows/selfhosted.yml)
+[](../../actions/workflows/cifuzz.yml)
+[](https://issues.oss-fuzz.com/issues?q="Project:+openssh"+is:open)
+[](https://scan.coverity.com/projects/openssh-portable)
+
+OpenSSH is a complete implementation of the SSH protocol (version 2) for secure remote login, command execution and file transfer. It includes a client ``ssh`` and server ``sshd``, file transfer utilities ``scp`` and ``sftp`` as well as tools for key generation (``ssh-keygen``), run-time key storage (``ssh-agent``) and a number of supporting programs.
+
+This is a port of OpenBSD's [OpenSSH](https://openssh.com) to most Unix-like operating systems, including Linux, OS X and Cygwin. Portable OpenSSH polyfills OpenBSD APIs that are not available elsewhere, adds sshd sandboxing for more operating systems and includes support for OS-native authentication and auditing (e.g. using PAM).
+
+## Documentation
+
+The official documentation for OpenSSH are the man pages for each tool:
+
+* [ssh(1)](https://man.openbsd.org/ssh.1)
+* [sshd(8)](https://man.openbsd.org/sshd.8)
+* [ssh-keygen(1)](https://man.openbsd.org/ssh-keygen.1)
+* [ssh-agent(1)](https://man.openbsd.org/ssh-agent.1)
+* [scp(1)](https://man.openbsd.org/scp.1)
+* [sftp(1)](https://man.openbsd.org/sftp.1)
+* [ssh-keyscan(8)](https://man.openbsd.org/ssh-keyscan.8)
+* [sftp-server(8)](https://man.openbsd.org/sftp-server.8)
+
+## Stable Releases
+
+Stable release tarballs are available from a number of [download mirrors](https://www.openssh.com/portable.html#downloads). We recommend the use of a stable release for most users. Please read the [release notes](https://www.openssh.com/releasenotes.html) for details of recent changes and potential incompatibilities.
+
+## Building Portable OpenSSH
+
+### Dependencies
+
+Portable OpenSSH is built using autoconf and make. It requires a working C compiler, standard library and headers.
+
- ``libcrypto`` from one of [LibreSSL](https://www.libressl.org/), [OpenSSL](https://www.openssl.org), [AWS-LC](https://github.com/aws/aws-lc) or [BoringSSL](https://github.com/google/boringssl) may also be used. OpenSSH may be built without either of these, but the resulting binaries will have only a subset of the cryptographic algorithms normally available.
++``libcrypto`` from one of [LibreSSL](https://www.libressl.org/), [OpenSSL](https://www.openssl.org), [AWS-LC](https://github.com/aws/aws-lc) or [BoringSSL](https://github.com/google/boringssl) may also be used. OpenSSH may be built without any of these, but the resulting binaries will have only a subset of the cryptographic algorithms normally available.
+
+[zlib](https://www.zlib.net/) is optional; without it transport compression is not supported.
+
+FIDO security token support needs [libfido2](https://github.com/Yubico/libfido2) and its dependencies and will be enabled automatically if they are found.
+
+In addition, certain platforms and build-time options may require additional dependencies; see README.platform for details about your platform.
+
+### Building a release
+
+Release tarballs and release branches in git include a pre-built copy of the ``configure`` script and may be built using:
+
+```
+tar zxvf openssh-X.YpZ.tar.gz
+cd openssh
+./configure # [options]
+make && make tests
+```
+
+See the [Build-time Customisation](#build-time-customisation) section below for configure options. If you plan on installing OpenSSH to your system, then you will usually want to specify destination paths.
+
+### Building from git
+
+If building from the git master branch, you'll need [autoconf](https://www.gnu.org/software/autoconf/) installed to build the ``configure`` script. The following commands will check out and build portable OpenSSH from git:
+
+```
+git clone https://github.com/openssh/openssh-portable # or https://anongit.mindrot.org/openssh.git
+cd openssh-portable
+autoreconf
+./configure
+make && make tests
+```
+
+### Build-time Customisation
+
+There are many build-time customisation options available. All Autoconf destination path flags (e.g. ``--prefix``) are supported (and are usually required if you want to install OpenSSH).
+
+For a full list of available flags, run ``./configure --help`` but a few of the more frequently-used ones are described below. Some of these flags will require additional libraries and/or headers be installed.
+
+Flag | Meaning
+--- | ---
+``--with-pam`` | Enable [PAM](https://en.wikipedia.org/wiki/Pluggable_authentication_module) support. [OpenPAM](https://www.openpam.org/), [Linux PAM](http://www.linux-pam.org/) and Solaris PAM are supported.
+``--with-libedit`` | Enable [libedit](https://www.thrysoee.dk/editline/) support for sftp.
+``--with-kerberos5`` | Enable Kerberos/GSSAPI support. Both [Heimdal](https://www.h5l.org/) and [MIT](https://web.mit.edu/kerberos/) Kerberos implementations are supported.
+``--with-selinux`` | Enable [SELinux](https://en.wikipedia.org/wiki/Security-Enhanced_Linux) support.
+
+## Development
+
+Portable OpenSSH development is discussed on the [openssh-unix-dev mailing list](https://lists.mindrot.org/mailman/listinfo/openssh-unix-dev) ([archive mirror](https://marc.info/?l=openssh-unix-dev)). Bugs and feature requests are tracked on our [Bugzilla](https://bugzilla.mindrot.org/).
+
+## Reporting bugs
+
+_Non-security_ bugs may be reported to the developers via [Bugzilla](https://bugzilla.mindrot.org/) or via the mailing list above. Security bugs should be reported to [openssh@openssh.com](mailto:openssh.openssh.com).
diff --cc crypto/openssh/auth.c
index da1a674126d1,000000000000..ced0cb304be8
mode 100644,000000..100644
--- a/crypto/openssh/auth.c
+++ b/crypto/openssh/auth.c
@@@ -1,791 -1,0 +1,794 @@@
- /* $OpenBSD: auth.c,v 1.164 2026/02/11 22:57:16 djm Exp $ */
++/* $OpenBSD: auth.c,v 1.165 2026/07/21 06:17:42 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>
+#include <paths.h>
+#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 "blocklist_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;
+ int r;
+ u_int i;
+
+ /* 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)
+ BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_OK,
+ "Authenticated");
+ }
+
+ 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;
+
+ BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Maximum attempts exceeded");
+ 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_channel_timeouts(ssh);
+ server_process_permitopen(ssh);
++ ssh_packet_set_rekey_limits(ssh, options.rekey_limit,
++ options.rekey_interval);
+
+#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) {
+ BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Invalid 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;
+ u_int i;
+ int r;
+
+ if (options.num_revoked_keys_files == 0)
+ 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;
+ }
+
+ for (i = 0; i < options.num_revoked_keys_files; i++) {
+ r = sshkey_check_revoked(key, options.revoked_keys_files[i]);
+ 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_files[i]);
+ goto out;
+ default:
+ error_r(r, "Error checking authentication key %s %s in "
+ "revoked keys file %s", sshkey_type(key), fp,
+ options.revoked_keys_files[i]);
+ 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" : "");
+
*** 10639 LINES SKIPPED ***