/*
 * Copyright (c) 2016 Martijn van Duren <vias@imperialat.at>
 * Copyright (c) 2015 Ted Unangst <tedu@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ioctl.h>

#include <fcntl.h>
#include <limits.h>
#include <libgen.h>
#include <login_cap.h>
#include <bsd_auth.h>
#include <readpassphrase.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <err.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <syslog.h>
#include <errno.h>

#include "vias.h"

static void __dead
usage(void)
{
	fprintf(stderr, "usage: vias [-a style] [-C config] "
	    "file [editor args]\n");
	exit(1);
}

size_t
arraylen(const char **arr)
{
	size_t cnt = 0;

	while (*arr) {
		cnt++;
		arr++;
	}
	return cnt;
}

static int
parseuid(const char *s, uid_t *uid)
{
	struct passwd *pw;
	const char *errstr;

	if ((pw = getpwnam(s)) != NULL) {
		*uid = pw->pw_uid;
		return 0;
	}
	*uid = strtonum(s, 0, UID_MAX, &errstr);
	if (errstr)
		return -1;
	return 0;
}

static int
uidcheck(const char *s, uid_t desired)
{
	uid_t uid;

	if (parseuid(s, &uid) != 0)
		return -1;
	if (uid != desired)
		return -1;
	return 0;
}

static int
parsegid(const char *s, gid_t *gid)
{
	struct group *gr;
	const char *errstr;

	if ((gr = getgrnam(s)) != NULL) {
		*gid = gr->gr_gid;
		return 0;
	}
	*gid = strtonum(s, 0, GID_MAX, &errstr);
	if (errstr)
		return -1;
	return 0;
}

static int
open_nosym(const char *file)
{
	static int dep = 0;
	struct stat sb;
	char dir[PATH_MAX];
	int fd, pfd;

	dep++;
	(void) strlcpy(dir, dirname(file), sizeof(dir));

	if (dir[1] == '\0') {
		dep--;
		if ((pfd = open("/", O_CLOEXEC)) == -1)
			return -1;
	} else {
		pfd = open_nosym(dir);
		dep--;
		if (pfd == -1)
			return -1;
	}

	do {
		if (dep) {
			fd = openat(pfd, basename(file),
			    O_NOFOLLOW | O_CLOEXEC);
		} else {
			fd = openat(pfd, basename(file),
			    O_RDWR | O_NOFOLLOW | O_CLOEXEC | O_CREAT, 0777);
		}
	} while (fd == -1 && errno == EINTR);
	close(pfd);
	if (fd == -1)
		return -1;

	if (fstat(fd, &sb) == -1)
		err(1, "fstat");
/*
 * This should already have been checked in parse.y.
 * It's only here to test for race-conditions
 */
	if (S_ISLNK(sb.st_mode))
		errx(1, "Symbolic links not allowed");
	if (dep && !S_ISDIR(sb.st_mode))
		errc(1, ENOTDIR, NULL);
	if (!dep && !S_ISREG(sb.st_mode))
		errx(1, "File is not a regular file");

	return fd;
}

static int
match(uid_t uid, gid_t *groups, int ngroups, const char *file, struct rule *r)
{
	int i;
	int flen;

	if (r->ident[0] == ':') {
		gid_t rgid;
		if (parsegid(r->ident + 1, &rgid) == -1)
			return 0;
		for (i = 0; i < ngroups; i++) {
			if (rgid == groups[i])
				break;
		}
		if (i == ngroups)
			return 0;
	} else {
		if (uidcheck(r->ident, uid) != 0)
			return 0;
	}
	if (r->files != NULL) {
		for (i = 0; r->files[i] != NULL; i++) {
			flen = strlen(r->files[i]);
/* Allow access to the entire directory tree */
			if (r->files[i][flen-1] == '/') {
				if (!strncmp(r->files[i], file, flen))
					break;
			} else {
				if (!strcmp(r->files[i], file))
					break;
			}
		}
		if (r->files[i] == NULL)
			return 0;
	}
	return 1;
}

static int
permit(uid_t uid, gid_t *groups, int ngroups, struct rule **lastr,
    const char *file)
{
	int i;
	int fd = -1, pfd = -1;
	uid_t suid = -1;
	struct rule *r;
	char *rfile;

	if ((rfile = realpath(file, NULL)) == NULL)
		err(1, "Unable to open %s", file);

	*lastr = NULL;
	for (i = 0; i < nrules; i++) {
		r = rules[i];
		if (match(uid, groups, ngroups, rfile, r)) {
/* Try to open the file, so we know the rule is really permitted */
			if (r->target) {
				if (parseuid(r->target, &suid) == -1)
					err(1, "getpwnam");
				if (seteuid(suid) == -1)
					err(1, "seteuid");
			}
			if ((fd = open_nosym(rfile)) != -1) {
				if (pfd != -1)
					if (close(pfd) == -1)
						err(1, "close");
				pfd = fd;
				*lastr = rules[i];
			} else if (errno != EPERM) {
				err(1, "open %s", file);
			}
			if (r->target && seteuid(0))
				err(1, "seteuid");
		}
	}
	if (*lastr == NULL || (*lastr)->action != PERMIT) {
		if (fd != -1 && close(fd) == -1)
			err(1, "close");
		return -1;
	}

	return fd;
}

static void
parseconfig(const char *filename, int checkperms)
{
	extern FILE *yyfp;
	extern int yyparse(void);
	struct stat sb;

	yyfp = fopen(filename, "r");
	if (!yyfp)
		err(1, checkperms ? "vias is not enabled, %s" :
		    "could not open config file %s", filename);

	if (checkperms) {
		if (fstat(fileno(yyfp), &sb) != 0)
			err(1, "fstat(\"%s\")", filename);
		if ((sb.st_mode & (S_IWGRP|S_IWOTH)) != 0)
			errx(1, "%s is writable by group or other", filename);
		if (sb.st_uid != 0)
			errx(1, "%s is not owned by root", filename);
	}

	yyparse();
	fclose(yyfp);
	if (parse_errors)
		exit(1);
}

static void __dead
checkconfig(const char *confpath, uid_t uid, gid_t *groups, int ngroups,
    const char *file)
{
	struct rule *rule;

	parseconfig(confpath, 0);
	if (!file)
		exit(0);

	if (permit(uid, groups, ngroups, &rule, file) != -1) {
		printf("permit%s\n", (rule->options & NOPASS) ? " nopass" : "");
		exit(0);
	}
	printf("deny\n");
	exit(1);
}

static void
authuser(char *myname, char *login_style, int persist)
{
	char *challenge = NULL, *response, rbuf[1024], cbuf[128];
	auth_session_t *as;
	int fd = -1;

	if (persist)
		fd = open("/dev/tty", O_RDWR);
	if (fd != -1) {
		if (ioctl(fd, TIOCCHKVERAUTH) == 0)
			goto good;
	}

	if (!(as = auth_userchallenge(myname, login_style, "auth-doas",
	    &challenge)))
		errx(1, "Authorization failed");
	if (!challenge) {
		char host[HOST_NAME_MAX + 1];
		if (gethostname(host, sizeof(host)))
			snprintf(host, sizeof(host), "?");
		snprintf(cbuf, sizeof(cbuf),
		    "\rvias (%.32s@%.32s) password: ", myname, host);
		challenge = cbuf;
	}
	response = readpassphrase(challenge, rbuf, sizeof(rbuf),
	    RPP_REQUIRE_TTY);
	if (response == NULL && errno == ENOTTY) {
		syslog(LOG_AUTHPRIV | LOG_NOTICE,
		    "tty required for %s", myname);
		errx(1, "a tty is required");
	}
	if (!auth_userresponse(as, response, 0)) {
		syslog(LOG_AUTHPRIV | LOG_NOTICE,
		    "failed auth for %s", myname);
		errc(1, EPERM, NULL);
	}
	explicit_bzero(rbuf, sizeof(rbuf));
good:
	if (fd != -1) {
		int secs = 5 * 60;
		ioctl(fd, TIOCSETVERAUTH, &secs);
		close(fd);
	}
}
static int
fcpy(int dfd, int sfd)
{
	unsigned char buf[4096];
	int r;

	do {
		while ((r = read(sfd, buf, sizeof(buf))) > 0) {
			if (write(dfd, buf, r) != r)
				return 0;
		}
	} while (r == -1 && errno == EINTR);
	if (r == -1)
		return 0;
	return 1;
}

int
main(int argc, char **argv)
{
	const char *confpath = NULL;
	char tmpfile[] = "/tmp/vias.XXXXXX";
	char myname[_PW_NAME_LEN + 1];
	struct passwd *pw;
	struct rule *rule;
	uid_t uid;
	gid_t groups[NGROUPS_MAX + 1];
	int ngroups;
	int i, ch;
	int ofd, tfd;
	char cwdpath[PATH_MAX];
	const char *cwd;
	char *login_style = NULL;
	char *file;
	char **eargv;
	int status;
	pid_t ret, vipid;

	setprogname("vias");

	closefrom(STDERR_FILENO + 1);

	uid = getuid();

	while ((ch = getopt(argc, argv, "a:C:")) != -1) {
		switch (ch) {
		case 'a':
			login_style = optarg;
			break;
		case 'C':
			confpath = optarg;
			break;
		default:
			usage();
		}
	}
	argv += optind;
	argc -= optind;

	if (argc == 0 && confpath == NULL)
		usage();
	file = argv[0];
	argv++;
	argc--;

	pw = getpwuid(uid);
	if (!pw)
		err(1, "getpwuid failed");
	if (strlcpy(myname, pw->pw_name, sizeof(myname)) >= sizeof(myname))
		errx(1, "pw_name too long");
	ngroups = getgroups(NGROUPS_MAX, groups);
	if (ngroups == -1)
		err(1, "can't get groups");
	groups[ngroups++] = getgid();

	if (confpath)
		checkconfig(confpath, uid, groups, ngroups, file);

	if (geteuid())
		errx(1, "not installed setuid");

	parseconfig("/etc/vias.conf", 1);

	if (setuid(0) == -1)
		err(1, "setuid");
	if ((ofd = permit(uid, groups, ngroups, &rule, file)) == -1) {
		syslog(LOG_AUTHPRIV | LOG_NOTICE,
		    "failed edit for %s: %s", myname, file);
		errc(1, EPERM, "%s", file);
	}

	if (setreuid(uid, 0) == -1)
		err(1, "setreuid failed");
	
	if (!(rule->options & NOPASS))
		authuser(myname, login_style, rule->options & PERSIST);

	if (pledge("stdio rpath wpath cpath exec proc id", NULL) == -1)
		err(1, "pledge");

	if ((setuid(uid)) == -1)
		err(1, "setuid failed");

	if (pledge("stdio rpath wpath cpath exec proc", NULL) == -1)
		err(1, "pledge");

	if ((tfd = mkstemp(tmpfile)) == -1)
		err(1, "mkstemp failed");

	if (pledge("stdio rpath cpath exec proc", NULL) == -1)
		err(1, "pledge");

	if (!fcpy(tfd, ofd)) {
		unlink(tmpfile);
		err(1, "temp copy failed");
	}

	if (getcwd(cwdpath, sizeof(cwdpath)) == NULL)
		cwd = "(failed)";
	else
		cwd = cwdpath;

	if (pledge("stdio cpath exec proc", NULL) == -1)
		err(1, "pledge");

	syslog(LOG_AUTHPRIV | LOG_INFO, "%s edited %s as %s from %s",
	    myname, file, pw->pw_name, cwd);

	if ((eargv = reallocarray(NULL, arraylen((const char **) argv) + 2,
	    sizeof(*eargv))) == NULL) {
		unlink(tmpfile);
		err(1, NULL);
	}
	eargv[0] = getenv("EDITOR");
	if (eargv[0] == NULL || *(eargv[0]) == '\0')
		eargv[0] = "vi";

	switch ((vipid = fork())) {
	case -1:
		unlink(tmpfile);
		err(1, "fork failed");
	case 0:
		if (pledge("stdio exec", NULL) == -1)
			err(1, "pledge");

		for (i = 0; argv[i] != NULL; i++)
			eargv[i+1] = argv[i];
		eargv[i+1] = tmpfile;
		eargv[i+2] = NULL;
		execvp(eargv[0], eargv);
		err(1, "execvp failed");
	default:
		if (pledge("stdio cpath", NULL) == -1)
			err(1, "pledge");

		while ((ret = waitpid(vipid, &status, 0)) == -1 &&
		    errno == EINTR)
			;
		if (ret == -1)
			err(1, "wait failed: Temporary file saved at %s",
			    tmpfile);
	}

	if (WEXITSTATUS(status) != 0) {
		errx(1, "%s exited with status %d: Temporary file saved at %s",
		    eargv[0], WEXITSTATUS(status), tmpfile);
	}

	(void) lseek(tfd, 0, SEEK_SET);
	if (ftruncate(ofd, 0) == -1)
		err(1, "ftruncate failed: Temporary file saved at %s", tmpfile);
	(void) lseek(ofd, 0, SEEK_SET);
	if (!fcpy(ofd, tfd))
		err(1, "restoring failed: Temporary file saved at %s", tmpfile);
	if (unlink(tmpfile) == -1)
		err(1, "unlink %s", tmpfile);
	return 0;
}