/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983-1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/filio.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
#include <pwd.h>
#include <grp.h>
#include <signal.h>
#include <netdb.h>
#include <syslog.h>
#include <nss_dbdefs.h>
#include <security/pam_appl.h>
#include <deflt.h>

#ifdef SYSV
#include <shadow.h>
#endif /* SYSV */

#ifndef NCARGS
#define	NCARGS	5120
#endif /* NCARGS */

#ifdef SYSV
#define	rindex	strrchr
#define	killpg(a, b)	kill(-(a), (b))
#else
char  *sprintf();
#endif	/* SYSV */

#define	MAXFD(A, B) ((A) > (B) ? (A) : (B))
#define	_PATH_DEFAULT_LOGIN	"/etc/default/login"

static void error(char *fmt, ...);
static void doit(int f, struct sockaddr_storage *fromp);
static void getstr(char *buf, int cnt, char *err);

static int legalenvvar(char *s);

/* Function decls. for functions not in any header file.  (Grrrr.) */
extern int audit_rexecd_setup(void);
extern int audit_rexecd_success(char *, char *, char *);
extern int audit_rexecd_fail(char *, char *, char *, char *);
extern int audit_settid(int);	/* set termnal ID */

/* PAM conversation function */
static int rexec_conv(int, struct pam_message **,
		struct pam_response **, void *);

static pam_handle_t *pamh;	/* authentication handle */
static struct pam_conv conv = {
			rexec_conv,
			NULL
		};

/*
 * remote execute server:
 *	username\0
 *	password\0
 *	command\0
 *	data
 *
 * in.rexecd has been modified to run as the user invoking it. Hence there is no
 * need to limit any privileges.
 */
/*ARGSUSED*/
int
main(int argc, char **argv)
{
	struct sockaddr_storage from;
	socklen_t fromlen;

	openlog("rexec", LOG_PID | LOG_ODELAY, LOG_DAEMON);
	(void) audit_rexecd_setup();	/* BSM */
	fromlen = (socklen_t)sizeof (from);
	if (getpeername(0, (struct sockaddr *)&from, &fromlen) < 0) {
		(void) fprintf(stderr, "%s: ", argv[0]);
		perror("getpeername");
		exit(1);
	}

	if (audit_settid(0) != 0) {
		perror("settid");
		exit(1);
	}

	doit(0, &from);
	return (0);
}

static char	username[20] = "USER=";
static char	homedir[64] = "HOME=";
static char	shell[64] = "SHELL=";

static char	*envinit[] =
#ifdef SYSV
	{homedir, shell, (char *)0, username,
	(char *)0, (char *)0, (char *)0, (char *)0,
	(char *)0, (char *)0, (char *)0, (char *)0,
	(char *)0, (char *)0, (char *)0, (char *)0,
	(char *)0, (char *)0, (char *)0, (char *)0,
	(char *)0};
#define	ENVINIT_PATH	2	/* position of PATH in envinit[] */
#define	PAM_ENV_ELIM	16	/* max PAM environment variables */

/*
 *	See PSARC opinion 1992/025
 */
static char	userpath[] = "PATH=/usr/bin:";
static char	rootpath[] = "PATH=/usr/sbin:/usr/bin";
#else
	    {homedir, shell, "PATH=:/usr/ucb:/bin:/usr/bin", username, 0};
#endif /* SYSV */

static struct	sockaddr_storage asin;
static char pass[16];

static void
doit(int f, struct sockaddr_storage *fromp)
{
	char cmdbuf[NCARGS+1], *cp;
	char user[16];
	char hostname [MAXHOSTNAMELEN + 1];
	struct passwd *pwd, pw_data;
	char pwdbuf[NSS_BUFLEN_PASSWD];
	int s;
	ushort_t port;
	pid_t pid;
	int pv[2], cc;
	fd_set readfrom, ready;
	char buf[BUFSIZ], sig;
	int one = 1;
	int idx = 0, end_env = 0;
	char **pam_env;
	int status = PAM_AUTH_ERR;
	char abuf[INET6_ADDRSTRLEN];
	struct in_addr v4dst;
	socklen_t fromplen;
	struct sockaddr_in *sin;
	struct sockaddr_in6 *sin6;
	int pam_flags = 0;

	(void) signal(SIGINT, SIG_DFL);
	(void) signal(SIGQUIT, SIG_DFL);
	(void) signal(SIGTERM, SIG_DFL);
#ifdef DEBUG
	{
		int t = open("/dev/tty", 2);
		if (t >= 0) {
#ifdef SYSV
			(void) setsid();
#else
			(void) ioctl(t, TIOCNOTTY, (char *)0);
#endif	/* SYSV */
			(void) close(t);
		}
	}
#endif
	if (fromp->ss_family == AF_INET) {
		sin = (struct sockaddr_in *)fromp;
		fromplen = sizeof (struct sockaddr_in);
		asin.ss_family = AF_INET;  /* used for bind */
	} else if (fromp->ss_family == AF_INET6) {
		sin6 = (struct sockaddr_in6 *)fromp;
		fromplen = sizeof (struct sockaddr_in6);
		asin.ss_family = AF_INET6; /* used for bind */
	} else {
		syslog(LOG_ERR, "unknown address family %d\n",
		    fromp->ss_family);
		exit(1);
	}
	/*
	 * store common info. for audit record
	 */

	if (getnameinfo((const struct sockaddr *) fromp, fromplen, hostname,
	    sizeof (hostname), NULL, 0, 0) != 0) {
		if (fromp->ss_family == AF_INET6) {
			if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
				struct in_addr ipv4_addr;

				IN6_V4MAPPED_TO_INADDR(&sin6->sin6_addr,
				    &ipv4_addr);
				inet_ntop(AF_INET, &ipv4_addr, abuf,
				    sizeof (abuf));
			} else {
				inet_ntop(AF_INET6, &sin6->sin6_addr,
				    abuf, sizeof (abuf));
			}
		} else if (fromp->ss_family == AF_INET) {
				inet_ntop(AF_INET, &sin->sin_addr,
				    abuf, sizeof (abuf));
			}
		(void) strncpy(hostname, abuf, sizeof (hostname));
	}
	(void) dup2(f, 0);
	(void) dup2(f, 1);
	(void) dup2(f, 2);
	(void) alarm(60);
	port = 0;
	for (;;) {
		char c;
		if (read(f, &c, 1) != 1)
			exit(1);
		if (c == 0)
			break;
		port = port * 10 + c - '0';
	}
	(void) alarm(0);
	if (port != 0) {
		s = socket(fromp->ss_family, SOCK_STREAM, 0);
		if (s < 0)
			exit(1);
		if (bind(s, (struct sockaddr *)&asin, fromplen) < 0)
			exit(1);
		(void) alarm(60);
		if (fromp->ss_family == AF_INET) {
			sin->sin_port = htons((ushort_t)port);
		} else if (fromp->ss_family == AF_INET6) {
			sin6->sin6_port = htons((ushort_t)port);
		}
		if (connect(s, (struct sockaddr *)fromp, fromplen) < 0)
			exit(1);
		(void) alarm(0);
	}
	getstr(user, sizeof (user), "username");
	getstr(pass, sizeof (pass), "password");
	getstr(cmdbuf, sizeof (cmdbuf), "command");

	pwd = getpwnam_r(user, &pw_data, pwdbuf, sizeof (pwdbuf));
	if (pwd == NULL) {
		(void) audit_rexecd_fail("Login incorrect", hostname, user,
		    cmdbuf);	    /* BSM */
		error("Login incorrect.\n");
		exit(1);
	}

	if (defopen(_PATH_DEFAULT_LOGIN) == 0) {
		int flags;
		char *p;
		flags = defcntl(DC_GETFLAGS, 0);
		TURNOFF(flags, DC_CASE);
		(void) defcntl(DC_SETFLAGS, flags);
		if ((p = defread("PASSREQ=")) != NULL &&
		    strcasecmp(p, "YES") == 0) {
			pam_flags |= PAM_DISALLOW_NULL_AUTHTOK;
		}
		defopen(NULL);
	}

	if (pam_start("rexec", user, &conv, &pamh) != PAM_SUCCESS) {
		exit(1);
	}
	if (pam_set_item(pamh, PAM_RHOST, hostname) != PAM_SUCCESS) {
		exit(1);
	}

	if ((status = pam_authenticate(pamh, pam_flags)) != PAM_SUCCESS) {
		switch (status) {
		case PAM_USER_UNKNOWN:
			(void) audit_rexecd_fail("Login incorrect", hostname,
			    user, cmdbuf);		/* BSM */
			error("Login incorrect.\n");
			break;
		default:
			(void) audit_rexecd_fail("Password incorrect", hostname,
			    user, cmdbuf);	/* BSM */
			error("Password incorrect.\n");
		}
		pam_end(pamh, status);
		exit(1);
	}
	if ((status = pam_acct_mgmt(pamh, pam_flags)) != PAM_SUCCESS) {
		(void) audit_rexecd_fail("Account or Password Expired",
		    hostname, user, cmdbuf);
		switch (status) {
			case PAM_NEW_AUTHTOK_REQD:
				error("Password Expired.\n");
				break;
			case PAM_PERM_DENIED:
				error("Account Expired.\n");
				break;
			case PAM_AUTHTOK_EXPIRED:
				error("Password Expired.\n");
				break;
			default:
				error("Login incorrect.\n");
				break;
		}
		pam_end(pamh, status);
		exit(1);
	}

	(void) write(2, "\0", 1);

	if (setgid((gid_t)pwd->pw_gid) < 0) {
		(void) audit_rexecd_fail("Can't setgid", hostname,
		    user, cmdbuf);	/* BSM */
		error("setgid");
		pam_end(pamh, PAM_ABORT);
		exit(1);
	}
	(void) initgroups(pwd->pw_name, pwd->pw_gid);

	if ((status = pam_setcred(pamh, PAM_ESTABLISH_CRED)) != PAM_SUCCESS) {
		(void) audit_rexecd_fail("Unable to establish credentials",
		    hostname, user, cmdbuf);	/* BSM */
		error("Unable to establish credentials.\n");
		pam_end(pamh, PAM_SUCCESS);
	}

	(void) audit_rexecd_success(hostname, user, cmdbuf);	/* BSM */

	if (setuid((uid_t)pwd->pw_uid) < 0) {
		(void) audit_rexecd_fail("Can't setuid", hostname,
		    user, cmdbuf);	/* BSM */
		error("setuid");
		pam_end(pamh, PAM_ABORT);
		exit(1);
	}


	if (port) {
		(void) pipe(pv);
		pid = fork();
		if (pid == (pid_t)-1)  {
			error("Try again.\n");
			pam_end(pamh, PAM_ABORT);
			exit(1);
		}
		if (pid) {
			/*
			 * since the daemon is running as the user no need
			 * to prune privileges.
			 */
			(void) close(0); (void) close(1); (void) close(2);
			(void) close(f); (void) close(pv[1]);
			FD_ZERO(&readfrom);
			FD_SET(s, &readfrom);
			FD_SET(pv[0], &readfrom);
			(void) ioctl(pv[0], FIONBIO, (char *)&one);
			/* should set s nbio! */
			do {
				ready = readfrom;
				if (select(MAXFD(s, pv[0])+1, &ready, NULL,
				    NULL, NULL) < 0) {
					perror("select:");
					exit(1);
				}
				if (FD_ISSET(s, &ready)) {
					if (read(s, &sig, 1) <= 0)
						FD_CLR(s, &readfrom);
					else
						(void) killpg(pid, sig);
				}
				if (FD_ISSET(pv[0], &ready)) {
					cc = read(pv[0], buf, sizeof (buf));
					if (cc <= 0) {
						(void) shutdown(s, 1+1);
						FD_CLR(pv[0], &readfrom);
					} else
						(void) write(s, buf, cc);
				}
			} while (FD_ISSET(s, &readfrom) ||
			    FD_ISSET(pv[0], &readfrom));
			exit(0);
		}
		/* setpgrp(0, getpid()); */
		(void) setsid();	/* Should be the same as above. */
		(void) close(s); (void)close(pv[0]);
		(void) dup2(pv[1], 2);
	}

	if (*pwd->pw_shell == '\0')
		pwd->pw_shell = "/bin/sh";
	if (f > 2)
		(void) close(f);
	/* Change directory only after becoming the appropriate user. */
	if (chdir(pwd->pw_dir) < 0) {
		error("No remote directory.\n");
		pam_end(pamh, PAM_ABORT);
		exit(1);
	}
#ifdef	SYSV
	if (pwd->pw_uid)
		envinit[ENVINIT_PATH] = userpath;
	else
		envinit[ENVINIT_PATH] = rootpath;
#endif	/* SYSV */
	(void) strncat(homedir, pwd->pw_dir, sizeof (homedir) - 6);
	(void) strncat(shell, pwd->pw_shell, sizeof (shell) - 7);
	(void) strncat(username, pwd->pw_name, sizeof (username) - 6);

	/*
	 * add PAM environment variables set by modules
	 * -- only allowed 16 (PAM_ENV_ELIM)
	 * -- check to see if the environment variable is legal
	 */
	for (end_env = 0; envinit[end_env] != 0; end_env++)
		;
	if ((pam_env = pam_getenvlist(pamh)) != 0) {
		while (pam_env[idx] != 0) {
			if (idx < PAM_ENV_ELIM &&
			    legalenvvar(pam_env[idx])) {
				envinit[end_env + idx] = pam_env[idx];
			}
			idx++;
		}
	}

	pam_end(pamh, PAM_SUCCESS);

	cp = rindex(pwd->pw_shell, '/');
	if (cp)
		cp++;
	else
		cp = pwd->pw_shell;
	(void) execle(pwd->pw_shell, cp, "-c", cmdbuf, (char *)0, envinit);
	perror(pwd->pw_shell);
	exit(1);
}

static void
getstr(char *buf, int cnt, char *err)
{
	char c;

	do {
		if (read(0, &c, 1) != 1)
			exit(1);
		*buf++ = c;
		if (--cnt == 0) {
			error("%s too long\n", err);
			exit(1);
		}
	} while (c != 0);
}

static void
error(char *fmt, ...)
{
	va_list ap;
	char buf[BUFSIZ];

	buf[0] = 1;
	va_start(ap, fmt);
	(void) vsprintf(buf+1, fmt, ap);
	va_end(ap);
	(void) write(2, buf, strlen(buf));
}

static char *illegal[] = {
	"SHELL=",
	"HOME=",
	"LOGNAME=",
#ifndef NO_MAIL
	"MAIL=",
#endif
	"CDPATH=",
	"IFS=",
	"PATH=",
	"USER=",
	0
};

/*
 * legalenvvar - can PAM insert this environmental variable?
 */

static int
legalenvvar(char *s)
{
	register char **p;

	for (p = illegal; *p; p++)
		if (strncmp(s, *p, strlen(*p)) == 0)
			return (0);

	if (s[0] == 'L' && s[1] == 'D' && s[2] == '_')
		return (0);

	return (1);
}

/*
 * rexec_conv -  This is the conv (conversation) function called from
 *	a PAM authentication module to print error messages
 *	or garner information from the user.
 */

/* ARGSUSED3 */
static int
rexec_conv(int num_msg, struct pam_message **msg,
    struct pam_response **response, void *appdata_ptr)
{
	struct pam_message	*m;
	struct pam_response	*r;
	int			i;

	if (num_msg <= 0)
		return (PAM_CONV_ERR);

	*response = calloc(num_msg, sizeof (struct pam_response));
	if (*response == NULL)
		return (PAM_BUF_ERR);

	m = *msg;
	r = *response;

	if (m->msg_style == PAM_PROMPT_ECHO_OFF) {
		if (pass[0] != '\0') {
			r->resp = strdup(pass);
			if (r->resp == NULL) {
				/* free responses */
				r = *response;
				for (i = 0; i < num_msg; i++, r++) {
					if (r->resp)
						free(r->resp);
				}
				free(*response);
				*response = NULL;
				return (PAM_BUF_ERR);
			}
		}
	}

	return (PAM_SUCCESS);
}