src/usr.bin/ssh/monitor.c - diff

Return to monitor.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/monitor.c between version 1.55 and 1.55.2.2

version 1.55, 2004/02/05 05:37:17

version 1.55.2.2, 2005/03/10 17:15:04

Line 57

#include "bufaux.h"

#include "compat.h"

#include "ssh2.h"

#include "mpaux.h"

#ifdef GSSAPI

#include "ssh-gss.h"

Line 74

Line 73

extern Buffer input, output;

extern Buffer auth_debug;

extern int auth_debug_init;

extern Buffer loginmsg;

/* State exported from the child */

Line 308

}

static void

monitor_child_handler(int signal)

monitor_child_handler(int sig)

{

kill(monitor_child_pid, signal);

kill(monitor_child_pid, sig);

}

void

Line 425

}

int

mm_answer_moduli(int socket, Buffer *m)

mm_answer_moduli(int sock, Buffer *m)

{

DH *dh;

int min, want, max;

Line 455

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;

Line 496

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

Line 507

/* 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;

Line 518

if (authctxt->attempt++ != 0)

fatal("%s: multiple attempts for getpwnam", __func__);

username = buffer_get_string(m, NULL);

pwent = getpwnamallow(login);

pwent = getpwnamallow(username);

authctxt->user = xstrdup(login);

authctxt->user = xstrdup(username);

setproctitle("%s [priv]", pwent ? login : "unknown");

setproctitle("%s [priv]", pwent ? username : "unknown");

xfree(login);

xfree(username);

buffer_clear(m);

Line 549

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)

Line 564

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

Line 580

}

int

mm_answer_authserv(int socket, Buffer *m)

mm_answer_authserv(int sock, Buffer *m)

{

monitor_permit_authentications(1);

Line 598

}

int

mm_answer_authpassword(int socket, Buffer *m)

mm_answer_authpassword(int sock, Buffer *m)

{

static int call_count;

char *passwd;

Line 616

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)

Line 630

#ifdef BSD_AUTH

int

mm_answer_bsdauthquery(int socket, Buffer *m)

mm_answer_bsdauthquery(int sock, Buffer *m)

{

char *name, *infotxt;

u_int numprompts;

Line 647

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

Line 660

}

int

mm_answer_bsdauthrespond(int socket, Buffer *m)

mm_answer_bsdauthrespond(int sock, Buffer *m)

{

char *response;

int authok;

Line 679

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";

Line 689

#ifdef SKEY

int

mm_answer_skeyquery(int socket, Buffer *m)

mm_answer_skeyquery(int sock, Buffer *m)

{

struct skey skey;

char challenge[1024];

Line 703

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;

Line 727

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";

Line 747

}

int

mm_answer_keyallowed(int socket, Buffer *m)

mm_answer_keyallowed(int sock, Buffer *m)

{

Key *key;

char *cuser, *chost;

Line 817

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

Line 938

}

int

mm_answer_keyverify(int socket, Buffer *m)

mm_answer_keyverify(int sock, Buffer *m)

{

Key *key;

u_char *signature, *data, *blob;

Line 988

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

}

Line 1030

}

int

mm_answer_pty(int socket, Buffer *m)

mm_answer_pty(int sock, Buffer *m)

{

extern struct monitor *pmonitor;

Session *s;

Line 1052

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)

fatal("%s: dup2", __func__);

Line 1066

Line 1062

/* 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));

Line 1086

Line 1091

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;

Line 1107

Line 1112

}

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

Line 1128

Line 1133

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

Line 1137

Line 1142

}

int

mm_answer_sessid(int socket, Buffer *m)

mm_answer_sessid(int sock, Buffer *m)

{

int i;

Line 1155

Line 1160

}

int

mm_answer_rsa_keyallowed(int socket, Buffer *m)

mm_answer_rsa_keyallowed(int sock, Buffer *m)

{

BIGNUM *client_n;

Key *key = NULL;

Line 1195

Line 1200

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

Line 1203

Line 1208

}

int

mm_answer_rsa_challenge(int socket, Buffer *m)

mm_answer_rsa_challenge(int sock, Buffer *m)

{

Key *key = NULL;

u_char *blob;

Line 1229

Line 1234

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

Line 1239

Line 1244

}

int

mm_answer_rsa_response(int socket, Buffer *m)

mm_answer_rsa_response(int sock, Buffer *m)

{

Key *key = NULL;

u_char *blob, *response;

Line 1278

Line 1283

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;

Line 1301

Line 1306

res = WIFEXITED(status) ? WEXITSTATUS(status) : 1;

/* Terminate process */

exit (res);

exit(res);

}

void

Line 1368

Line 1373

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

Line 1556

Line 1562

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

goid.elements = buffer_get_string(m, &len);

oid.length = 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);

Line 1581

Line 1587

}

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;

Line 1598

Line 1604

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

Line 1611

Line 1617

}

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;

Line 1630

Line 1636

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

Line 1639

Line 1645

}

int

mm_answer_gss_userok(int socket, Buffer *m)

mm_answer_gss_userok(int sock, Buffer *m)

{

int authenticated;

Line 1649

Line 1655

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";