*/
#include "includes.h"
-RCSID("$OpenBSD: monitor.c,v 1.56 2004/05/09 01:19:27 djm Exp $");
+RCSID("$OpenBSD: monitor.c,v 1.63 2005/03/10 22:01:05 deraadt Exp $");
#include <openssl/dh.h>
extern Buffer input, output;
extern Buffer auth_debug;
extern int auth_debug_init;
+extern Buffer loginmsg;
/* State exported from the child */
int mm_answer_gss_checkmic(int, Buffer *);
#endif
+#ifdef SSH_AUDIT_EVENTS
+int mm_answer_audit_event(int, Buffer *);
+int mm_answer_audit_command(int, Buffer *);
+#endif
+
static Authctxt *authctxt;
static BIGNUM *ssh1_challenge = NULL; /* used for ssh1 rsa auth */
{MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond},
{MONITOR_REQ_PAM_FREE_CTX, MON_ONCE|MON_AUTHDECIDE, mm_answer_pam_free_ctx},
#endif
+#ifdef SSH_AUDIT_EVENTS
+ {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
+#endif
#ifdef BSD_AUTH
{MONITOR_REQ_BSDAUTHQUERY, MON_ISAUTH, mm_answer_bsdauthquery},
{MONITOR_REQ_BSDAUTHRESPOND, MON_AUTH,mm_answer_bsdauthrespond},
{MONITOR_REQ_PTY, 0, mm_answer_pty},
{MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup},
{MONITOR_REQ_TERM, 0, mm_answer_term},
+#ifdef SSH_AUDIT_EVENTS
+ {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
+ {MONITOR_REQ_AUDIT_COMMAND, MON_PERMIT, mm_answer_audit_command},
+#endif
{0, 0, NULL}
};
{MONITOR_REQ_PAM_QUERY, MON_ISAUTH, mm_answer_pam_query},
{MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond},
{MONITOR_REQ_PAM_FREE_CTX, MON_ONCE|MON_AUTHDECIDE, mm_answer_pam_free_ctx},
+#endif
+#ifdef SSH_AUDIT_EVENTS
+ {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
#endif
{0, 0, NULL}
};
{MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty},
{MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup},
{MONITOR_REQ_TERM, 0, mm_answer_term},
+#ifdef SSH_AUDIT_EVENTS
+ {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
+ {MONITOR_REQ_AUDIT_COMMAND, MON_ONCE, mm_answer_audit_command},
+#endif
{0, 0, NULL}
};
authctxt = _authctxt;
memset(authctxt, 0, sizeof(*authctxt));
+ authctxt->loginmsg = &loginmsg;
+
if (compat20) {
mon_dispatch = mon_dispatch_proto20;
}
static void
-monitor_child_handler(int signal)
+monitor_child_handler(int sig)
{
- kill(monitor_child_pid, signal);
+ kill(monitor_child_pid, sig);
}
void
}
int
-mm_answer_moduli(int socket, Buffer *m)
+mm_answer_moduli(int sock, Buffer *m)
{
DH *dh;
int min, want, max;
DH_free(dh);
}
- mm_request_send(socket, MONITOR_ANS_MODULI, m);
+ mm_request_send(sock, MONITOR_ANS_MODULI, m);
return (0);
}
int
-mm_answer_sign(int socket, Buffer *m)
+mm_answer_sign(int sock, Buffer *m)
{
Key *key;
u_char *p;
xfree(p);
xfree(signature);
- mm_request_send(socket, MONITOR_ANS_SIGN, m);
+ mm_request_send(sock, MONITOR_ANS_SIGN, m);
/* Turn on permissions for getpwnam */
monitor_permit(mon_dispatch, MONITOR_REQ_PWNAM, 1);
/* Retrieves the password entry and also checks if the user is permitted */
int
-mm_answer_pwnamallow(int socket, Buffer *m)
+mm_answer_pwnamallow(int sock, Buffer *m)
{
- char *login;
+ char *username;
struct passwd *pwent;
int allowed = 0;
if (authctxt->attempt++ != 0)
fatal("%s: multiple attempts for getpwnam", __func__);
- login = buffer_get_string(m, NULL);
+ username = buffer_get_string(m, NULL);
- pwent = getpwnamallow(login);
+ pwent = getpwnamallow(username);
- authctxt->user = xstrdup(login);
- setproctitle("%s [priv]", pwent ? login : "unknown");
- xfree(login);
+ authctxt->user = xstrdup(username);
+ setproctitle("%s [priv]", pwent ? username : "unknown");
+ xfree(username);
buffer_clear(m);
out:
debug3("%s: sending MONITOR_ANS_PWNAM: %d", __func__, allowed);
- mm_request_send(socket, MONITOR_ANS_PWNAM, m);
+ mm_request_send(sock, MONITOR_ANS_PWNAM, m);
/* For SSHv1 allow authentication now */
if (!compat20)
if (options.use_pam)
monitor_permit(mon_dispatch, MONITOR_REQ_PAM_START, 1);
#endif
+#ifdef SSH_AUDIT_EVENTS
+ monitor_permit(mon_dispatch, MONITOR_REQ_AUDIT_COMMAND, 1);
+#endif
return (0);
}
-int mm_answer_auth2_read_banner(int socket, Buffer *m)
+int mm_answer_auth2_read_banner(int sock, Buffer *m)
{
char *banner;
buffer_clear(m);
banner = auth2_read_banner();
buffer_put_cstring(m, banner != NULL ? banner : "");
- mm_request_send(socket, MONITOR_ANS_AUTH2_READ_BANNER, m);
+ mm_request_send(sock, MONITOR_ANS_AUTH2_READ_BANNER, m);
if (banner != NULL)
xfree(banner);
}
int
-mm_answer_authserv(int socket, Buffer *m)
+mm_answer_authserv(int sock, Buffer *m)
{
monitor_permit_authentications(1);
}
int
-mm_answer_authpassword(int socket, Buffer *m)
+mm_answer_authpassword(int sock, Buffer *m)
{
static int call_count;
char *passwd;
buffer_put_int(m, authenticated);
debug3("%s: sending result %d", __func__, authenticated);
- mm_request_send(socket, MONITOR_ANS_AUTHPASSWORD, m);
+ mm_request_send(sock, MONITOR_ANS_AUTHPASSWORD, m);
call_count++;
if (plen == 0 && call_count == 1)
#ifdef BSD_AUTH
int
-mm_answer_bsdauthquery(int socket, Buffer *m)
+mm_answer_bsdauthquery(int sock, Buffer *m)
{
char *name, *infotxt;
u_int numprompts;
buffer_put_cstring(m, prompts[0]);
debug3("%s: sending challenge success: %u", __func__, success);
- mm_request_send(socket, MONITOR_ANS_BSDAUTHQUERY, m);
+ mm_request_send(sock, MONITOR_ANS_BSDAUTHQUERY, m);
if (success) {
xfree(name);
}
int
-mm_answer_bsdauthrespond(int socket, Buffer *m)
+mm_answer_bsdauthrespond(int sock, Buffer *m)
{
char *response;
int authok;
buffer_put_int(m, authok);
debug3("%s: sending authenticated: %d", __func__, authok);
- mm_request_send(socket, MONITOR_ANS_BSDAUTHRESPOND, m);
+ mm_request_send(sock, MONITOR_ANS_BSDAUTHRESPOND, m);
auth_method = "bsdauth";
#ifdef SKEY
int
-mm_answer_skeyquery(int socket, Buffer *m)
+mm_answer_skeyquery(int sock, Buffer *m)
{
struct skey skey;
char challenge[1024];
buffer_put_cstring(m, challenge);
debug3("%s: sending challenge success: %u", __func__, success);
- mm_request_send(socket, MONITOR_ANS_SKEYQUERY, m);
+ mm_request_send(sock, MONITOR_ANS_SKEYQUERY, m);
return (0);
}
int
-mm_answer_skeyrespond(int socket, Buffer *m)
+mm_answer_skeyrespond(int sock, Buffer *m)
{
char *response;
int authok;
buffer_put_int(m, authok);
debug3("%s: sending authenticated: %d", __func__, authok);
- mm_request_send(socket, MONITOR_ANS_SKEYRESPOND, m);
+ mm_request_send(sock, MONITOR_ANS_SKEYRESPOND, m);
auth_method = "skey";
#ifdef USE_PAM
int
-mm_answer_pam_start(int socket, Buffer *m)
+mm_answer_pam_start(int sock, Buffer *m)
{
if (!options.use_pam)
fatal("UsePAM not set, but ended up in %s anyway", __func__);
}
int
-mm_answer_pam_account(int socket, Buffer *m)
+mm_answer_pam_account(int sock, Buffer *m)
{
u_int ret;
ret = do_pam_account();
buffer_put_int(m, ret);
+ buffer_append(&loginmsg, "\0", 1);
+ buffer_put_cstring(m, buffer_ptr(&loginmsg));
+ buffer_clear(&loginmsg);
- mm_request_send(socket, MONITOR_ANS_PAM_ACCOUNT, m);
+ mm_request_send(sock, MONITOR_ANS_PAM_ACCOUNT, m);
return (ret);
}
extern KbdintDevice sshpam_device;
int
-mm_answer_pam_init_ctx(int socket, Buffer *m)
+mm_answer_pam_init_ctx(int sock, Buffer *m)
{
debug3("%s", __func__);
} else {
buffer_put_int(m, 0);
}
- mm_request_send(socket, MONITOR_ANS_PAM_INIT_CTX, m);
+ mm_request_send(sock, MONITOR_ANS_PAM_INIT_CTX, m);
return (0);
}
int
-mm_answer_pam_query(int socket, Buffer *m)
+mm_answer_pam_query(int sock, Buffer *m)
{
char *name, *info, **prompts;
- u_int num, *echo_on;
- int i, ret;
+ u_int i, num, *echo_on;
+ int ret;
debug3("%s", __func__);
sshpam_authok = NULL;
xfree(prompts);
if (echo_on != NULL)
xfree(echo_on);
- mm_request_send(socket, MONITOR_ANS_PAM_QUERY, m);
+ mm_request_send(sock, MONITOR_ANS_PAM_QUERY, m);
return (0);
}
int
-mm_answer_pam_respond(int socket, Buffer *m)
+mm_answer_pam_respond(int sock, Buffer *m)
{
char **resp;
- u_int num;
- int i, ret;
+ u_int i, num;
+ int ret;
debug3("%s", __func__);
sshpam_authok = NULL;
}
buffer_clear(m);
buffer_put_int(m, ret);
- mm_request_send(socket, MONITOR_ANS_PAM_RESPOND, m);
+ mm_request_send(sock, MONITOR_ANS_PAM_RESPOND, m);
auth_method = "keyboard-interactive/pam";
if (ret == 0)
sshpam_authok = sshpam_ctxt;
}
int
-mm_answer_pam_free_ctx(int socket, Buffer *m)
+mm_answer_pam_free_ctx(int sock, Buffer *m)
{
debug3("%s", __func__);
(sshpam_device.free_ctx)(sshpam_ctxt);
buffer_clear(m);
- mm_request_send(socket, MONITOR_ANS_PAM_FREE_CTX, m);
+ mm_request_send(sock, MONITOR_ANS_PAM_FREE_CTX, m);
return (sshpam_authok == sshpam_ctxt);
}
#endif
}
int
-mm_answer_keyallowed(int socket, Buffer *m)
+mm_answer_keyallowed(int sock, Buffer *m)
{
Key *key;
char *cuser, *chost;
debug3("%s: key_from_blob: %p", __func__, key);
if (key != NULL && authctxt->valid) {
- switch(type) {
+ switch (type) {
case MM_USERKEY:
allowed = options.pubkey_authentication &&
user_key_allowed(authctxt->pw, key);
mm_append_debug(m);
- mm_request_send(socket, MONITOR_ANS_KEYALLOWED, m);
+ mm_request_send(sock, MONITOR_ANS_KEYALLOWED, m);
if (type == MM_RSAHOSTKEY)
monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);
}
int
-mm_answer_keyverify(int socket, Buffer *m)
+mm_answer_keyverify(int sock, Buffer *m)
{
Key *key;
u_char *signature, *data, *blob;
buffer_clear(m);
buffer_put_int(m, verified);
- mm_request_send(socket, MONITOR_ANS_KEYVERIFY, m);
+ mm_request_send(sock, MONITOR_ANS_KEYVERIFY, m);
return (verified);
}
}
int
-mm_answer_pty(int socket, Buffer *m)
+mm_answer_pty(int sock, Buffer *m)
{
extern struct monitor *pmonitor;
Session *s;
buffer_put_int(m, 1);
buffer_put_cstring(m, s->tty);
- mm_request_send(socket, MONITOR_ANS_PTY, m);
-
- mm_send_fd(socket, s->ptyfd);
- mm_send_fd(socket, s->ttyfd);
/* We need to trick ttyslot */
if (dup2(s->ttyfd, 0) == -1)
/* Now we can close the file descriptor again */
close(0);
+ /* send messages generated by record_login */
+ buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg));
+ buffer_clear(&loginmsg);
+
+ mm_request_send(sock, MONITOR_ANS_PTY, m);
+
+ mm_send_fd(sock, s->ptyfd);
+ mm_send_fd(sock, s->ttyfd);
+
/* make sure nothing uses fd 0 */
if ((fd0 = open(_PATH_DEVNULL, O_RDONLY)) < 0)
fatal("%s: open(/dev/null): %s", __func__, strerror(errno));
if (s != NULL)
mm_session_close(s);
buffer_put_int(m, 0);
- mm_request_send(socket, MONITOR_ANS_PTY, m);
+ mm_request_send(sock, MONITOR_ANS_PTY, m);
return (0);
}
int
-mm_answer_pty_cleanup(int socket, Buffer *m)
+mm_answer_pty_cleanup(int sock, Buffer *m)
{
Session *s;
char *tty;
}
int
-mm_answer_sesskey(int socket, Buffer *m)
+mm_answer_sesskey(int sock, Buffer *m)
{
BIGNUM *p;
int rsafail;
/* Turn off permissions */
- monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 1);
+ monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 0);
if ((p = BN_new()) == NULL)
fatal("%s: BN_new", __func__);
BN_clear_free(p);
- mm_request_send(socket, MONITOR_ANS_SESSKEY, m);
+ mm_request_send(sock, MONITOR_ANS_SESSKEY, m);
/* Turn on permissions for sessid passing */
monitor_permit(mon_dispatch, MONITOR_REQ_SESSID, 1);
}
int
-mm_answer_sessid(int socket, Buffer *m)
+mm_answer_sessid(int sock, Buffer *m)
{
int i;
}
int
-mm_answer_rsa_keyallowed(int socket, Buffer *m)
+mm_answer_rsa_keyallowed(int sock, Buffer *m)
{
BIGNUM *client_n;
Key *key = NULL;
mm_append_debug(m);
- mm_request_send(socket, MONITOR_ANS_RSAKEYALLOWED, m);
+ mm_request_send(sock, MONITOR_ANS_RSAKEYALLOWED, m);
monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);
monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 0);
}
int
-mm_answer_rsa_challenge(int socket, Buffer *m)
+mm_answer_rsa_challenge(int sock, Buffer *m)
{
Key *key = NULL;
u_char *blob;
buffer_put_bignum2(m, ssh1_challenge);
debug3("%s sending reply", __func__);
- mm_request_send(socket, MONITOR_ANS_RSACHALLENGE, m);
+ mm_request_send(sock, MONITOR_ANS_RSACHALLENGE, m);
monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 1);
}
int
-mm_answer_rsa_response(int socket, Buffer *m)
+mm_answer_rsa_response(int sock, Buffer *m)
{
Key *key = NULL;
u_char *blob, *response;
buffer_clear(m);
buffer_put_int(m, success);
- mm_request_send(socket, MONITOR_ANS_RSARESPONSE, m);
+ mm_request_send(sock, MONITOR_ANS_RSARESPONSE, m);
return (success);
}
int
-mm_answer_term(int socket, Buffer *req)
+mm_answer_term(int sock, Buffer *req)
{
extern struct monitor *pmonitor;
int res, status;
res = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
/* Terminate process */
- exit (res);
+ exit(res);
+}
+
+#ifdef SSH_AUDIT_EVENTS
+/* Report that an audit event occurred */
+int
+mm_answer_audit_event(int socket, Buffer *m)
+{
+ ssh_audit_event_t event;
+
+ debug3("%s entering", __func__);
+
+ event = buffer_get_int(m);
+ switch(event) {
+ case SSH_AUTH_FAIL_PUBKEY:
+ case SSH_AUTH_FAIL_HOSTBASED:
+ case SSH_AUTH_FAIL_GSSAPI:
+ case SSH_LOGIN_EXCEED_MAXTRIES:
+ case SSH_LOGIN_ROOT_DENIED:
+ case SSH_CONNECTION_CLOSE:
+ case SSH_INVALID_USER:
+ audit_event(event);
+ break;
+ default:
+ fatal("Audit event type %d not permitted", event);
+ }
+
+ return (0);
+}
+
+int
+mm_answer_audit_command(int socket, Buffer *m)
+{
+ u_int len;
+ char *cmd;
+
+ debug3("%s entering", __func__);
+ cmd = buffer_get_string(m, &len);
+ /* sanity check command, if so how? */
+ audit_run_command(cmd);
+ xfree(cmd);
+ return (0);
}
+#endif /* SSH_AUDIT_EVENTS */
void
monitor_apply_keystate(struct monitor *pmonitor)
fatal("mm_get_get: internal error: bad session id");
kex->we_need = buffer_get_int(m);
kex->kex[KEX_DH_GRP1_SHA1] = kexdh_server;
+ kex->kex[KEX_DH_GRP14_SHA1] = kexdh_server;
kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;
kex->server = 1;
kex->hostkey_type = buffer_get_int(m);
#ifdef GSSAPI
int
-mm_answer_gss_setup_ctx(int socket, Buffer *m)
+mm_answer_gss_setup_ctx(int sock, Buffer *m)
{
- gss_OID_desc oid;
+ gss_OID_desc goid;
OM_uint32 major;
u_int len;
- oid.elements = buffer_get_string(m, &len);
- oid.length = len;
+ goid.elements = buffer_get_string(m, &len);
+ goid.length = len;
- major = ssh_gssapi_server_ctx(&gsscontext, &oid);
+ major = ssh_gssapi_server_ctx(&gsscontext, &goid);
- xfree(oid.elements);
+ xfree(goid.elements);
buffer_clear(m);
buffer_put_int(m, major);
- mm_request_send(socket,MONITOR_ANS_GSSSETUP, m);
+ mm_request_send(sock,MONITOR_ANS_GSSSETUP, m);
/* Now we have a context, enable the step */
monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 1);
}
int
-mm_answer_gss_accept_ctx(int socket, Buffer *m)
+mm_answer_gss_accept_ctx(int sock, Buffer *m)
{
gss_buffer_desc in;
gss_buffer_desc out = GSS_C_EMPTY_BUFFER;
buffer_put_int(m, major);
buffer_put_string(m, out.value, out.length);
buffer_put_int(m, flags);
- mm_request_send(socket, MONITOR_ANS_GSSSTEP, m);
+ mm_request_send(sock, MONITOR_ANS_GSSSTEP, m);
gss_release_buffer(&minor, &out);
}
int
-mm_answer_gss_checkmic(int socket, Buffer *m)
+mm_answer_gss_checkmic(int sock, Buffer *m)
{
gss_buffer_desc gssbuf, mic;
OM_uint32 ret;
buffer_clear(m);
buffer_put_int(m, ret);
- mm_request_send(socket, MONITOR_ANS_GSSCHECKMIC, m);
+ mm_request_send(sock, MONITOR_ANS_GSSCHECKMIC, m);
if (!GSS_ERROR(ret))
monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);
}
int
-mm_answer_gss_userok(int socket, Buffer *m)
+mm_answer_gss_userok(int sock, Buffer *m)
{
int authenticated;
buffer_put_int(m, authenticated);
debug3("%s: sending result %d", __func__, authenticated);
- mm_request_send(socket, MONITOR_ANS_GSSUSEROK, m);
+ mm_request_send(sock, MONITOR_ANS_GSSUSEROK, m);
auth_method="gssapi-with-mic";
andersk / openssh.git / blobdiff