diff -up openssh/audit-bsm.c.audit openssh/audit-bsm.c

--- openssh/audit-bsm.c.audit	2019-03-27 23:26:14.000000000 +0100

+++ openssh/audit-bsm.c	2019-04-03 17:02:20.713886041 +0200

@@ -372,13 +372,26 @@ audit_connection_from(const char *host,

 #endif

 }

+int

+audit_run_command(struct ssh *ssh, const char *command)

+{

+	/* not implemented */

+	return 0;

+}

+

 void

-audit_run_command(const char *command)

+audit_end_command(struct ssh *ssh, int handle, const char *command)

 {

 	/* not implemented */

 }

 void

+audit_count_session_open(void)

+{

+	/* not necessary */

+}

+

+void

 audit_session_open(struct logininfo *li)

 {

 	/* not implemented */

@@ -390,6 +403,12 @@ audit_session_close(struct logininfo *li

 	/* not implemented */

 }

+int

+audit_keyusage(struct ssh *ssh, int host_user, char *fp, int rv)

+{

+	/* not implemented */

+}

+

 void

 audit_event(struct ssh *ssh, ssh_audit_event_t event)

 {

@@ -451,4 +470,28 @@ audit_event(struct ssh *ssh, ssh_audit_e

 		debug("%s: unhandled event %d", __func__, event);

 	}

 }

+

+void

+audit_unsupported_body(struct ssh *ssh, int what)

+{

+	/* not implemented */

+}

+

+void

+audit_kex_body(struct ssh *ssh, int ctos, char *enc, char *mac, char *compress, char *pfs, pid_t pid, uid_t uid)

+{

+	/* not implemented */

+}

+

+void

+audit_session_key_free_body(struct ssh * ssh, int ctos, pid_t pid, uid_t uid)

+{

+	/* not implemented */

+}

+

+void

+audit_destroy_sensitive_data(struct ssh *ssh, const char *fp, pid_t pid, uid_t uid)

+{

+	/* not implemented */

+}

 #endif /* BSM */

diff -up openssh/audit.c.audit openssh/audit.c

--- openssh/audit.c.audit	2019-03-27 23:26:14.000000000 +0100

+++ openssh/audit.c	2019-04-03 17:02:20.713886041 +0200

@@ -34,6 +34,12 @@

 #include "log.h"

 #include "hostfile.h"

 #include "auth.h"

+#include "ssh-gss.h"

+#include "monitor_wrap.h"

+#include "xmalloc.h"

+#include "misc.h"

+#include "servconf.h"

+#include "ssherr.h"

 /*

  * Care must be taken when using this since it WILL NOT be initialized when

@@ -41,6 +47,7 @@

  * audit_event(CONNECTION_ABANDON) is called.  Test for NULL before using.

  */

 extern Authctxt *the_authctxt;

+extern ServerOptions options;

 /* Maybe add the audit class to struct Authmethod? */

 ssh_audit_event_t

@@ -69,13 +76,10 @@ audit_classify_auth(const char *method)

 const char *

 audit_username(void)

 {

-	static const char unknownuser[] = "(unknown user)";

-	static const char invaliduser[] = "(invalid user)";

+	static const char unknownuser[] = "(unknown)";

-	if (the_authctxt == NULL || the_authctxt->user == NULL)

+	if (the_authctxt == NULL || the_authctxt->user == NULL || !the_authctxt->valid)

 		return (unknownuser);

-	if (!the_authctxt->valid)

-		return (invaliduser);

 	return (the_authctxt->user);

 }

@@ -109,6 +113,35 @@ audit_event_lookup(ssh_audit_event_t ev)

 	return(event_lookup[i].name);

 }

+void

+audit_key(struct ssh *ssh, int host_user, int *rv, const struct sshkey *key)

+{

+	char *fp;

+

+	fp = sshkey_fingerprint(key, options.fingerprint_hash, SSH_FP_HEX);

+	if (audit_keyusage(ssh, host_user, fp, (*rv == 0)) == 0)

+		*rv = -SSH_ERR_INTERNAL_ERROR;

+	free(fp);

+}

+

+void

+audit_unsupported(struct ssh *ssh, int what)

+{

+	PRIVSEP(audit_unsupported_body(ssh, what));

+}

+

+void

+audit_kex(struct ssh *ssh, int ctos, char *enc, char *mac, char *comp, char *pfs)

+{

+	PRIVSEP(audit_kex_body(ssh, ctos, enc, mac, comp, pfs, getpid(), getuid()));

+}

+

+void

+audit_session_key_free(struct ssh *ssh, int ctos)

+{

+	PRIVSEP(audit_session_key_free_body(ssh, ctos, getpid(), getuid()));

+}

+

 # ifndef CUSTOM_SSH_AUDIT_EVENTS

 /*

  * Null implementations of audit functions.

@@ -138,6 +171,17 @@ audit_event(struct ssh *ssh, ssh_audit_e

 }

 /*

+ * Called when a child process has called, or will soon call,

+ * audit_session_open.

+ */

+void

+audit_count_session_open(void)

+{

+	debug("audit count session open euid %d user %s", geteuid(),

+	      audit_username());

+}

+

+/*

  * Called when a user session is started.  Argument is the tty allocated to

  * the session, or NULL if no tty was allocated.

  *

@@ -172,13 +216,82 @@ audit_session_close(struct logininfo *li

 /*

  * This will be called when a user runs a non-interactive command.  Note that

  * it may be called multiple times for a single connection since SSH2 allows

- * multiple sessions within a single connection.

+ * multiple sessions within a single connection.  Returns a "handle" for

+ * audit_end_command.

  */

-void

-audit_run_command(const char *command)

+int

+audit_run_command(struct ssh *ssh, const char *command)

 {

 	debug("audit run command euid %d user %s command '%.200s'", geteuid(),

 	    audit_username(), command);

+	return 0;

+}

+

+/*

+ * This will be called when the non-interactive command finishes.  Note that

+ * it may be called multiple times for a single connection since SSH2 allows

+ * multiple sessions within a single connection.  "handle" should come from

+ * the corresponding audit_run_command.

+ */

+void

+audit_end_command(struct ssh *ssh, int handle, const char *command)

+{

+	debug("audit end nopty exec  euid %d user %s command '%.200s'", geteuid(),

+	    audit_username(), command);

+}

+

+/*

+ * This will be called when user is successfully autherized by the RSA1/RSA/DSA key.

+ *

+ * Type is the key type, len is the key length(byte) and fp is the fingerprint of the key.

+ */

+int

+audit_keyusage(struct ssh *ssh, int host_user, char *fp, int rv)

+{

+	debug("audit %s key usage euid %d user %s fingerprint %s, result %d",

+		host_user ? "pubkey" : "hostbased", geteuid(), audit_username(),

+		fp, rv);

+}

+

+/*

+ * This will be called when the protocol negotiation fails.

+ */

+void

+audit_unsupported_body(struct ssh *ssh, int what)

+{

+	debug("audit unsupported protocol euid %d type %d", geteuid(), what);

+}

+

+/*

+ * This will be called on succesfull protocol negotiation.

+ */

+void

+audit_kex_body(struct ssh *ssh, int ctos, char *enc, char *mac, char *compress, char *pfs, pid_t pid,

+	       uid_t uid)

+{

+	debug("audit protocol negotiation euid %d direction %d cipher %s mac %s compresion %s pfs %s from pid %ld uid %u",

+		(unsigned)geteuid(), ctos, enc, mac, compress, pfs, (long)pid,

+	        (unsigned)uid);

+}

+

+/*

+ * This will be called on succesfull session key discard

+ */

+void

+audit_session_key_free_body(struct ssh *, int ctos, pid_t pid, uid_t uid)

+{

+	debug("audit session key discard euid %u direction %d from pid %ld uid %u",

+		(unsigned)geteuid(), ctos, (long)pid, (unsigned)uid);

+}

+

+/*

+ * This will be called on destroy private part of the server key

+ */

+void

+audit_destroy_sensitive_data(struct ssh *ssh, const char *fp, pid_t pid, uid_t uid)

+{

+	debug("audit destroy sensitive data euid %d fingerprint %s from pid %ld uid %u",

+		geteuid(), fp, (long)pid, (unsigned)uid);

 }

 # endif  /* !defined CUSTOM_SSH_AUDIT_EVENTS */

 #endif /* SSH_AUDIT_EVENTS */

diff -up openssh/audit.h.audit openssh/audit.h

--- openssh/audit.h.audit	2019-03-27 23:26:14.000000000 +0100

+++ openssh/audit.h	2019-04-03 17:02:20.713886041 +0200

@@ -26,6 +26,7 @@

 # define _SSH_AUDIT_H

 #include "loginrec.h"

+#include "sshkey.h"

 struct ssh;

@@ -45,13 +46,32 @@ enum ssh_audit_event_type {

 	SSH_CONNECTION_ABANDON,	/* closed without completing auth */

 	SSH_AUDIT_UNKNOWN

 };

+

+enum ssh_audit_kex {

+	SSH_AUDIT_UNSUPPORTED_CIPHER,

+	SSH_AUDIT_UNSUPPORTED_MAC,

+	SSH_AUDIT_UNSUPPORTED_COMPRESSION

+};

 typedef enum ssh_audit_event_type ssh_audit_event_t;

+int	listening_for_clients(void);

+

 void	audit_connection_from(const char *, int);

 void	audit_event(struct ssh *, ssh_audit_event_t);

+void	audit_count_session_open(void);

 void	audit_session_open(struct logininfo *);

 void	audit_session_close(struct logininfo *);

-void	audit_run_command(const char *);

+int	audit_run_command(struct ssh *, const char *);

+void 	audit_end_command(struct ssh *, int, const char *);

 ssh_audit_event_t audit_classify_auth(const char *);

+int	audit_keyusage(struct ssh *, int, char *, int);

+void	audit_key(struct ssh *, int, int *, const struct sshkey *);

+void	audit_unsupported(struct ssh *, int);

+void	audit_kex(struct ssh *, int, char *, char *, char *, char *);

+void	audit_unsupported_body(struct ssh *, int);

+void	audit_kex_body(struct ssh *, int, char *, char *, char *, char *, pid_t, uid_t);

+void	audit_session_key_free(struct ssh *, int ctos);

+void	audit_session_key_free_body(struct ssh *, int ctos, pid_t, uid_t);

+void	audit_destroy_sensitive_data(struct ssh *, const char *, pid_t, uid_t);

 #endif /* _SSH_AUDIT_H */

diff -up openssh/audit-linux.c.audit openssh/audit-linux.c

--- openssh/audit-linux.c.audit	2019-03-27 23:26:14.000000000 +0100

+++ openssh/audit-linux.c	2019-04-03 17:02:20.713886041 +0200

@@ -33,27 +33,40 @@

 #include "log.h"

 #include "audit.h"

+#include "sshkey.h"

+#include "hostfile.h"

+#include "auth.h"

+#include "misc.h"      /* servconf.h needs misc.h for struct ForwardOptions */

+#include "servconf.h"

 #include "canohost.h"

 #include "packet.h"

-

+#include "cipher.h"

+#include "channels.h"

+#include "session.h"

+

+#define AUDIT_LOG_SIZE 256

+

+extern ServerOptions options;

+extern Authctxt *the_authctxt;

+extern u_int utmp_len;

 const char *audit_username(void);

-int

-linux_audit_record_event(int uid, const char *username, const char *hostname,

-    const char *ip, const char *ttyn, int success)

+static void

+linux_audit_user_logxxx(int uid, const char *username,

+    const char *ip, const char *ttyn, int success, int event)

 {

 	int audit_fd, rc, saved_errno;

 	if ((audit_fd = audit_open()) < 0) {

 		if (errno == EINVAL || errno == EPROTONOSUPPORT ||

 		    errno == EAFNOSUPPORT)

-			return 1; /* No audit support in kernel */

+			return; /* No audit support in kernel */

 		else

-			return 0; /* Must prevent login */

+			goto fatal_report; /* Must prevent login */

 	}

-	rc = audit_log_acct_message(audit_fd, AUDIT_USER_LOGIN,

+	rc = audit_log_acct_message(audit_fd, event,

 	    NULL, "login", username ? username : "(unknown)",

-	    username == NULL ? uid : -1, hostname, ip, ttyn, success);

+	    username == NULL ? uid : -1, NULL, ip, ttyn, success);

 	saved_errno = errno;

 	close(audit_fd);

@@ -65,9 +78,96 @@ linux_audit_record_event(int uid, const

 		rc = 0;

 	errno = saved_errno;

-	return rc >= 0;

+	if (rc < 0) {

+fatal_report:

+		fatal("linux_audit_write_entry failed: %s", strerror(errno));

+	}

+}

+

+static void

+linux_audit_user_auth(int uid, const char *username,

+    const char *ip, const char *ttyn, int success, int event)

+{

+	int audit_fd, rc, saved_errno;

+	static const char *event_name[] = {

+		"maxtries exceeded",

+		"root denied",

+		"success",

+		"none",

+		"password",

+		"challenge-response",

+		"pubkey",

+		"hostbased",

+		"gssapi",

+		"invalid user",

+		"nologin",

+		"connection closed",

+		"connection abandoned",

+		"unknown"

+	};

+

+	audit_fd = audit_open();

+	if (audit_fd < 0) {

+		if (errno == EINVAL || errno == EPROTONOSUPPORT ||

+		    errno == EAFNOSUPPORT)

+			return; /* No audit support in kernel */

+		else

+			goto fatal_report; /* Must prevent login */

+	}

+

+	if ((event < 0) || (event > SSH_AUDIT_UNKNOWN))

+		event = SSH_AUDIT_UNKNOWN;

+

+	rc = audit_log_acct_message(audit_fd, AUDIT_USER_AUTH,

+	    NULL, event_name[event], username ? username : "(unknown)",

+	    username == NULL ? uid : -1, NULL, ip, ttyn, success);

+	saved_errno = errno;

+	close(audit_fd);

+	/*

+	 * Do not report error if the error is EPERM and sshd is run as non

+	 * root user.

+	 */

+	if ((rc == -EPERM) && (geteuid() != 0))

+		rc = 0;

+	errno = saved_errno;

+	if (rc < 0) {

+fatal_report:

+		fatal("linux_audit_write_entry failed: %s", strerror(errno));

+	}

+}

+

+int

+audit_keyusage(struct ssh *ssh, int host_user, char *fp, int rv)

+{

+	char buf[AUDIT_LOG_SIZE];

+	int audit_fd, rc, saved_errno;

+

+	audit_fd = audit_open();

+	if (audit_fd < 0) {

+		if (errno == EINVAL || errno == EPROTONOSUPPORT ||

+					 errno == EAFNOSUPPORT)

+			return 1; /* No audit support in kernel */

+		else

+			return 0; /* Must prevent login */

+	}

+	snprintf(buf, sizeof(buf), "%s_auth grantors=auth-key", host_user ? "pubkey" : "hostbased");

+	rc = audit_log_acct_message(audit_fd, AUDIT_USER_AUTH, NULL,

+		buf, audit_username(), -1, NULL, ssh_remote_ipaddr(ssh), NULL, rv);

+	if ((rc < 0) && ((rc != -1) || (getuid() == 0)))

+		goto out;

+	snprintf(buf, sizeof(buf), "op=negotiate kind=auth-key fp=%s", fp);

+	rc = audit_log_user_message(audit_fd, AUDIT_CRYPTO_KEY_USER, buf, NULL,

+		ssh_remote_ipaddr(ssh), NULL, rv);

+out:

+	saved_errno = errno;

+	audit_close(audit_fd);

+	errno = saved_errno;

+	/* do not report error if the error is EPERM and sshd is run as non root user */

+	return (rc >= 0) || ((rc == -EPERM) && (getuid() != 0));

 }

+static int user_login_count = 0;

+

 /* Below is the sshd audit API code */

 void

@@ -76,49 +176,210 @@ audit_connection_from(const char *host,

 	/* not implemented */

 }

+int

+audit_run_command(struct ssh *ssh, const char *command)

+{

+	if (!user_login_count++)

+		linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+		    ssh_remote_ipaddr(ssh),

+		    "ssh", 1, AUDIT_USER_LOGIN);

+	linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+	    ssh_remote_ipaddr(ssh),

+	    "ssh", 1, AUDIT_USER_START);

+	return 0;

+}

+

 void

-audit_run_command(const char *command)

+audit_end_command(struct ssh *ssh, int handle, const char *command)

 {

-	/* not implemented */

+	linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+	    ssh_remote_ipaddr(ssh),

+	    "ssh", 1, AUDIT_USER_END);

+	if (user_login_count && !--user_login_count)

+		linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+		    ssh_remote_ipaddr(ssh),

+		    "ssh", 1, AUDIT_USER_LOGOUT);

+}

+

+void

+audit_count_session_open(void)

+{

+	user_login_count++;

 }

 void

 audit_session_open(struct logininfo *li)

 {

-	if (linux_audit_record_event(li->uid, NULL, li->hostname, NULL,

-	    li->line, 1) == 0)

-		fatal("linux_audit_write_entry failed: %s", strerror(errno));

+	if (!user_login_count++)

+		linux_audit_user_logxxx(li->uid, NULL, li->hostname,

+		    li->line, 1, AUDIT_USER_LOGIN);

+	linux_audit_user_logxxx(li->uid, NULL, li->hostname,

+	    li->line, 1, AUDIT_USER_START);

 }

 void

 audit_session_close(struct logininfo *li)

 {

-	/* not implemented */

+	linux_audit_user_logxxx(li->uid, NULL, li->hostname,

+	    li->line, 1, AUDIT_USER_END);

+	if (user_login_count && !--user_login_count)

+		linux_audit_user_logxxx(li->uid, NULL, li->hostname,

+		    li->line, 1, AUDIT_USER_LOGOUT);

 }

 void

 audit_event(struct ssh *ssh, ssh_audit_event_t event)

 {

 	switch(event) {

-	case SSH_AUTH_SUCCESS:

-	case SSH_CONNECTION_CLOSE:

 	case SSH_NOLOGIN:

-	case SSH_LOGIN_EXCEED_MAXTRIES:

 	case SSH_LOGIN_ROOT_DENIED:

+		linux_audit_user_auth(-1, audit_username(),

+			ssh_remote_ipaddr(ssh), "ssh", 0, event);

+		linux_audit_user_logxxx(-1, audit_username(),

+			ssh_remote_ipaddr(ssh), "ssh", 0, AUDIT_USER_LOGIN);

 		break;

-	case SSH_AUTH_FAIL_NONE:

 	case SSH_AUTH_FAIL_PASSWD:

+		if (options.use_pam)

+			break;

+	case SSH_LOGIN_EXCEED_MAXTRIES:

 	case SSH_AUTH_FAIL_KBDINT:

 	case SSH_AUTH_FAIL_PUBKEY:

 	case SSH_AUTH_FAIL_HOSTBASED:

 	case SSH_AUTH_FAIL_GSSAPI:

+		linux_audit_user_auth(-1, audit_username(),

+			ssh_remote_ipaddr(ssh), "ssh", 0, event);

+		break;

+

+	case SSH_CONNECTION_CLOSE:

+		if (user_login_count) {

+			while (user_login_count--)

+				linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+				    ssh_remote_ipaddr(ssh),

+				    "ssh", 1, AUDIT_USER_END);

+			linux_audit_user_logxxx(the_authctxt->pw->pw_uid, NULL,

+			    ssh_remote_ipaddr(ssh),

+			    "ssh", 1, AUDIT_USER_LOGOUT);

+		}

+		break;

+

+	case SSH_CONNECTION_ABANDON:

 	case SSH_INVALID_USER:

-		linux_audit_record_event(-1, audit_username(), NULL,

-		    ssh_remote_ipaddr(ssh), "sshd", 0);

+		linux_audit_user_logxxx(-1, audit_username(),

+			ssh_remote_ipaddr(ssh), "ssh", 0, AUDIT_USER_LOGIN);

 		break;

 	default:

 		debug("%s: unhandled event %d", __func__, event);

 		break;

 	}

 }

+

+void

+audit_unsupported_body(struct ssh *ssh, int what)

+{

+#ifdef AUDIT_CRYPTO_SESSION

+	char buf[AUDIT_LOG_SIZE];

+	const static char *name[] = { "cipher", "mac", "comp" };

+	char *s;

+	int audit_fd;

+

+	snprintf(buf, sizeof(buf), "op=unsupported-%s direction=? cipher=? ksize=? rport=%d laddr=%s lport=%d ",

+		name[what], ssh_remote_port(ssh), (s = get_local_ipaddr(ssh_packet_get_connection_in(ssh))),

+		ssh_local_port(ssh));

+	free(s);

+	audit_fd = audit_open();

+	if (audit_fd < 0)

+		/* no problem, the next instruction will be fatal() */

+		return;

+	audit_log_user_message(audit_fd, AUDIT_CRYPTO_SESSION,

+			buf, NULL, ssh_remote_ipaddr(ssh), NULL, 0);

+	audit_close(audit_fd);

+#endif

+}

+

+const static char *direction[] = { "from-server", "from-client", "both" };

+

+void

+audit_kex_body(struct ssh *ssh, int ctos, char *enc, char *mac, char *compress,

+    char *pfs, pid_t pid, uid_t uid)

+{

+#ifdef AUDIT_CRYPTO_SESSION

+	char buf[AUDIT_LOG_SIZE];

+	int audit_fd, audit_ok;

+	const struct sshcipher *cipher = cipher_by_name(enc);

+	char *s;

+

+	snprintf(buf, sizeof(buf), "op=start direction=%s cipher=%s ksize=%d mac=%s pfs=%s spid=%jd suid=%jd rport=%d laddr=%s lport=%d ",

+		direction[ctos], enc, cipher ? 8 * cipher->key_len : 0, mac, pfs,

+		(intmax_t)pid, (intmax_t)uid,

+		ssh_remote_port(ssh), (s = get_local_ipaddr(ssh_packet_get_connection_in(ssh))), ssh_local_port(ssh));

+	free(s);

+	audit_fd = audit_open();

+	if (audit_fd < 0) {

+		if (errno == EINVAL || errno == EPROTONOSUPPORT ||

+					 errno == EAFNOSUPPORT)

+			return; /* No audit support in kernel */

+		else

+			fatal("cannot open audit"); /* Must prevent login */

+	}

+	audit_ok = audit_log_user_message(audit_fd, AUDIT_CRYPTO_SESSION,

+			buf, NULL, ssh_remote_ipaddr(ssh), NULL, 1);

+	audit_close(audit_fd);

+	/* do not abort if the error is EPERM and sshd is run as non root user */

+	if ((audit_ok < 0) && ((audit_ok != -1) || (getuid() == 0)))

+		fatal("cannot write into audit"); /* Must prevent login */

+#endif

+}

+

+void

+audit_session_key_free_body(struct ssh *ssh, int ctos, pid_t pid, uid_t uid)

+{

+	char buf[AUDIT_LOG_SIZE];

+	int audit_fd, audit_ok;

+	char *s;

+

+	snprintf(buf, sizeof(buf), "op=destroy kind=session fp=? direction=%s spid=%jd suid=%jd rport=%d laddr=%s lport=%d ",

+		 direction[ctos], (intmax_t)pid, (intmax_t)uid,

+		 ssh_remote_port(ssh),

+		 (s = get_local_ipaddr(ssh_packet_get_connection_in(ssh))),

+		 ssh_local_port(ssh));

+	free(s);

+	audit_fd = audit_open();

+	if (audit_fd < 0) {

+		if (errno != EINVAL && errno != EPROTONOSUPPORT &&

+					 errno != EAFNOSUPPORT)

+			error("cannot open audit");

+		return;

+	}

+	audit_ok = audit_log_user_message(audit_fd, AUDIT_CRYPTO_KEY_USER,

+			buf, NULL, ssh_remote_ipaddr(ssh), NULL, 1);

+	audit_close(audit_fd);

+	/* do not abort if the error is EPERM and sshd is run as non root user */

+	if ((audit_ok < 0) && ((audit_ok != -1) || (getuid() == 0)))

+		error("cannot write into audit");

+}

+

+void

+audit_destroy_sensitive_data(struct ssh *ssh, const char *fp, pid_t pid, uid_t uid)

+{

+	char buf[AUDIT_LOG_SIZE];

+	int audit_fd, audit_ok;

+

+	snprintf(buf, sizeof(buf), "op=destroy kind=server fp=%s direction=? spid=%jd suid=%jd ",

+		fp, (intmax_t)pid, (intmax_t)uid);

+	audit_fd = audit_open();

+	if (audit_fd < 0) {

+		if (errno != EINVAL && errno != EPROTONOSUPPORT &&

+					 errno != EAFNOSUPPORT)

+			error("cannot open audit");

+		return;

+	}

+	audit_ok = audit_log_user_message(audit_fd, AUDIT_CRYPTO_KEY_USER,

+			buf, NULL,

+			listening_for_clients() ? NULL : ssh_remote_ipaddr(ssh),

+			NULL, 1);

+	audit_close(audit_fd);

+	/* do not abort if the error is EPERM and sshd is run as non root user */

+	if ((audit_ok < 0) && ((audit_ok != -1) || (getuid() == 0)))

+		error("cannot write into audit");

+}

 #endif /* USE_LINUX_AUDIT */

diff -up openssh/auditstub.c.audit openssh/auditstub.c

--- openssh/auditstub.c.audit	2019-04-03 17:02:20.714886050 +0200

+++ openssh/auditstub.c	2019-04-03 17:02:20.714886050 +0200

@@ -0,0 +1,52 @@

+/* $Id: auditstub.c,v 1.1 jfch Exp $ */

+

+/*

+ * Copyright 2010 Red Hat, Inc.  All rights reserved.

+ * Use is subject to license terms.

+ *

+ * 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.

+ *

+ * Red Hat author: Jan F. Chadima <jchadima@redhat.com>

+ */

+

+#include <sys/types.h>

+

+struct ssh;

+

+void

+audit_unsupported(struct ssh *ssh, int n)

+{

+}

+

+void

+audit_kex(struct ssh *ssh, int ctos, char *enc, char *mac, char *comp, char *pfs)

+{

+}

+

+void

+audit_session_key_free(struct ssh *ssh, int ctos)

+{

+}

+

+void

+audit_session_key_free_body(struct ssh *ssh, int ctos, pid_t pid, uid_t uid)

+{

+}

diff -up openssh/auth2.c.audit openssh/auth2.c

--- openssh/auth2.c.audit	2019-04-03 17:02:20.651885453 +0200

+++ openssh/auth2.c	2019-04-03 17:02:20.714886050 +0200

@@ -303,9 +303,6 @@ input_userauth_request(int type, u_int32

 		} else {

 			/* Invalid user, fake password information */

 			authctxt->pw = fakepw();

-#ifdef SSH_AUDIT_EVENTS

-			PRIVSEP(audit_event(ssh, SSH_INVALID_USER));

-#endif

 		}

 #ifdef USE_PAM

 		if (options.use_pam)

diff -up openssh/auth2-hostbased.c.audit openssh/auth2-hostbased.c

--- openssh/auth2-hostbased.c.audit	2019-04-03 17:02:20.612885083 +0200

+++ openssh/auth2-hostbased.c	2019-04-03 17:02:20.714886050 +0200

@@ -158,7 +158,7 @@ userauth_hostbased(struct ssh *ssh)

 	authenticated = 0;

 	if (PRIVSEP(hostbased_key_allowed(ssh, authctxt->pw, cuser,

 	    chost, key)) &&

-	    PRIVSEP(sshkey_verify(key, sig, slen,

+	    PRIVSEP(hostbased_key_verify(ssh, key, sig, slen,

 	    sshbuf_ptr(b), sshbuf_len(b), pkalg, ssh->compat, NULL)) == 0)

 		authenticated = 1;

@@ -175,6 +175,20 @@ done:

 	return authenticated;

 }

+int

+hostbased_key_verify(struct ssh *ssh, const struct sshkey *key, const u_char *sig,

+    size_t slen, const u_char *data, size_t datalen, const char *pkalg, u_int compat,

+    struct sshkey_sig_details **detailsp)

+{

+	int rv;

+

+	rv = sshkey_verify(key, sig, slen, data, datalen, pkalg, compat, detailsp);

+#ifdef SSH_AUDIT_EVENTS

+	audit_key(ssh, 0, &rv, key);

+#endif

+	return rv;

+}

+

 /* return 1 if given hostkey is allowed */

 int

 hostbased_key_allowed(struct ssh *ssh, struct passwd *pw,

diff -up openssh/auth2-pubkey.c.audit openssh/auth2-pubkey.c

--- openssh/auth2-pubkey.c.audit	2019-04-03 17:02:20.691885832 +0200

+++ openssh/auth2-pubkey.c	2019-04-03 17:02:20.714886050 +0200

@@ -219,7 +219,7 @@ userauth_pubkey(struct ssh *ssh)

 		/* test for correct signature */

 		authenticated = 0;

 		if (PRIVSEP(user_key_allowed(ssh, pw, key, 1, &authopts)) &&

-		    PRIVSEP(sshkey_verify(key, sig, slen,

+		    PRIVSEP(user_key_verify(ssh, key, sig, slen,

 		    sshbuf_ptr(b), sshbuf_len(b),

 		    (ssh->compat & SSH_BUG_SIGTYPE) == 0 ? pkalg : NULL,

 		    ssh->compat, &sig_details)) == 0) {

@@ -278,6 +278,20 @@ done:

 	return authenticated;

 }

+int

+user_key_verify(struct ssh *ssh, const struct sshkey *key, const u_char *sig,

+    size_t slen, const u_char *data, size_t datalen, const char *pkalg, u_int compat,

+    struct sshkey_sig_details **detailsp)

+{

+	int rv;

+

+	rv = sshkey_verify(key, sig, slen, data, datalen, pkalg, compat, detailsp);

+#ifdef SSH_AUDIT_EVENTS

+	audit_key(ssh, 1, &rv, key);

+#endif

+	return rv;

+}

+

 static int

 match_principals_option(const char *principal_list, struct sshkey_cert *cert)

 {

diff -up openssh/auth.c.audit openssh/auth.c

--- openssh/auth.c.audit	2019-04-03 17:02:20.691885832 +0200

+++ openssh/auth.c	2019-04-03 17:02:20.714886050 +0200

@@ -366,7 +366,7 @@ auth_log(struct ssh *ssh, int authentica

 # endif

 #endif

 #ifdef SSH_AUDIT_EVENTS

-	if (authenticated == 0 && !authctxt->postponed)

+	if (authenticated == 0 && !authctxt->postponed && !partial)

 		audit_event(ssh, audit_classify_auth(method));

 #endif

 }

@@ -592,9 +592,6 @@ getpwnamallow(struct ssh *ssh, const cha

 		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))

diff -up openssh/auth.h.audit openssh/auth.h

--- openssh/auth.h.audit	2019-04-03 17:02:20.692885842 +0200

+++ openssh/auth.h	2019-04-03 17:02:20.714886050 +0200

@@ -195,6 +195,8 @@ struct passwd * getpwnamallow(struct ssh

 char	*expand_authorized_keys(const char *, struct passwd *pw);

 char	*authorized_principals_file(struct passwd *);

+int	 user_key_verify(struct ssh *, const struct sshkey *, const u_char *, size_t,

+    const u_char *, size_t, const char *, u_int, struct sshkey_sig_details **);

 FILE	*auth_openkeyfile(const char *, struct passwd *, int);

 FILE	*auth_openprincipals(const char *, struct passwd *, int);

@@ -214,6 +216,8 @@ struct sshkey	*get_hostkey_private_by_ty

 int	 get_hostkey_index(struct sshkey *, int, struct ssh *);

 int	 sshd_hostkey_sign(struct ssh *, struct sshkey *, struct sshkey *,

     u_char **, size_t *, const u_char *, size_t, const char *);

+int	 hostbased_key_verify(struct ssh *, const struct sshkey *, const u_char *, size_t,

+    const u_char *, size_t, const char *, u_int, struct sshkey_sig_details **);

 /* Key / cert options linkage to auth layer */

 const struct sshauthopt *auth_options(struct ssh *);

diff -up openssh/cipher.c.audit openssh/cipher.c

--- openssh/cipher.c.audit	2019-03-27 23:26:14.000000000 +0100

+++ openssh/cipher.c	2019-04-03 17:02:20.714886050 +0200

@@ -61,25 +61,6 @@ struct sshcipher_ctx {

 	const struct sshcipher *cipher;

 };

-struct sshcipher {

-	char	*name;

-	u_int	block_size;

-	u_int	key_len;

-	u_int	iv_len;		/* defaults to block_size */

-	u_int	auth_len;

-	u_int	flags;

-#define CFLAG_CBC		(1<<0)

-#define CFLAG_CHACHAPOLY	(1<<1)

-#define CFLAG_AESCTR		(1<<2)

-#define CFLAG_NONE		(1<<3)

-#define CFLAG_INTERNAL		CFLAG_NONE /* Don't use "none" for packets */

-#ifdef WITH_OPENSSL

-	const EVP_CIPHER	*(*evptype)(void);

-#else

-	void	*ignored;

-#endif

-};

-

 static const struct sshcipher ciphers[] = {

 #ifdef WITH_OPENSSL

 #ifndef OPENSSL_NO_DES

@@ -410,7 +391,7 @@ cipher_get_length(struct sshcipher_ctx *