OpenSolaris_b135/lib/libbsm/common/audit_cron.c

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

#include <sys/types.h>
#include <sys/systeminfo.h>
#include <bsm/audit.h>
#include <bsm/libbsm.h>
#include <bsm/audit_uevents.h>
#include <bsm/audit_private.h>
#include <unistd.h>
#include <wait.h>
#include <fcntl.h>
#include <pwd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <syslog.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <libgen.h>

#include <locale.h>
#include "generic.h"

#define	F_AUID	"%u\n"
#define	F_SMASK	"%x\n"
#define	F_FMASK	"%x\n"
#define	F_PORT	"%lx\n"
#define	F_TYPE	"%x\n"
#define	F_MACH	"%x %x %x %x\n"
#define	F_ASID	"%u\n"

#define	AU_SUFFIX	".au"

#define	ANC_BAD_FILE	-1
#define	ANC_BAD_FORMAT	-2

#define	AUDIT_CRON_TEXTBUF	256
static char	textbuf[AUDIT_CRON_TEXTBUF];

int
audit_cron_mode()
{
	return (!cannot_audit(0));
}

static void
audit_cron_syslog(const char *message) {
	static	int	is_open = 0;

	if (!is_open) {
		openlog("Solaris_Audit", LOG_ODELAY, LOG_CRON);
		is_open = 1;
	}
	syslog(LOG_WARNING, "%s", message);
}

/*
 * audit_cron_getinfo returns the audit characteristics from the relevant
 * auxiliary file, it if exists.  If not, it creates them from the crontab
 * or atjob uid.
 */

static int
audit_cron_getinfo(char *fname, char *fname_aux, struct auditinfo_addr *info)
{
	int		fd;
	struct stat	st;
	au_mask_t mask;
	struct passwd	pwd;
	char		pwd_buff[1024];
	static char	*msg =
	    "Used defaults instead of ancilary audit file";

	if ((fd = open(fname_aux, O_RDONLY)) == -1) {
		/* no syslog here; common case */
		goto make_it_up;
	}
	if (fstat(fd, &st) == -1) {
		/* no syslog here either; common case */
		goto delete_first;
	}

	if (read(fd, textbuf, st.st_size) != st.st_size) {
		audit_cron_syslog(msg);
		goto delete_first;
	}

	if (sscanf(textbuf,
	    F_AUID
	    F_SMASK
	    F_FMASK
	    F_PORT
	    F_TYPE
	    F_MACH
	    F_ASID,
	    &(info->ai_auid),
	    &(info->ai_mask.am_success),
	    &(info->ai_mask.am_failure),
	    &(info->ai_termid.at_port),
	    &(info->ai_termid.at_type),
	    &(info->ai_termid.at_addr[0]),
	    &(info->ai_termid.at_addr[1]),
	    &(info->ai_termid.at_addr[2]),
	    &(info->ai_termid.at_addr[3]),
	    &(info->ai_asid)) != 10) {
		audit_cron_syslog(msg);
		goto delete_first;
	}
	(void) close(fd);
	return (0);

delete_first:
	(void) close(fd);
	if (unlink(fname_aux)) {
		if (errno != ENOENT)
			audit_cron_syslog(
			    "Failed to remove invalid ancilary audit file");
	}
	/* intentionally falls through */

make_it_up:
	if (stat(fname, &st))
		return (-1);

	/* port and IP are zero */
	(void) memset(&(info->ai_termid), 0, sizeof (au_tid_addr_t));
	info->ai_termid.at_type = AU_IPv4;

	/* the caller is the child of cron which will run the job. */
	info->ai_asid = getpid();

	info->ai_mask.am_success = 0;	/* cover error case */
	info->ai_mask.am_failure = 0;

	if (strstr(fname, "crontabs") != NULL) {
		if (getpwnam_r(basename(fname), &pwd, pwd_buff,
		    sizeof (pwd_buff)) == NULL)
			return (-1); /* getpwnam_r sets errno */
	} else {
		if (getpwuid_r(st.st_uid, &pwd, pwd_buff, sizeof (pwd_buff)) ==
		    NULL)
			return (-1); /* getpwuid_r sets errno */
	}

	info->ai_auid = pwd.pw_uid;

	if (au_user_mask(pwd.pw_name, &mask)) {
		errno = EINVAL; /* pw_name lookup failed */
		return (-1);
	}
	info->ai_mask.am_success = mask.am_success;
	info->ai_mask.am_failure = mask.am_failure;

	return (0);
}

int
audit_cron_setinfo(char *fname, struct auditinfo_addr *info)
{
	int		fd, len, r;
	int		save_err;

	r = chmod(fname, 0200);
	if (r == -1 && errno != ENOENT)
		return (-1);

	if ((fd = open(fname, O_CREAT|O_WRONLY|O_TRUNC, 0200)) == -1)
		return (-1);

	len = sprintf(textbuf,
	    F_AUID
	    F_SMASK
	    F_FMASK
	    F_PORT
	    F_TYPE
	    F_MACH
	    F_ASID,
	    info->ai_auid,
	    info->ai_mask.am_success,
	    info->ai_mask.am_failure,
	    info->ai_termid.at_port,
	    info->ai_termid.at_type,
	    info->ai_termid.at_addr[0],
	    info->ai_termid.at_addr[1],
	    info->ai_termid.at_addr[2],
	    info->ai_termid.at_addr[3],
	    info->ai_asid);

	if (write(fd, textbuf, len) != len)
		goto audit_setinfo_clean;

	if (fchmod(fd, 0400) == -1)
		goto audit_setinfo_clean;

	(void) close(fd);
	return (0);

audit_setinfo_clean:
	save_err = errno;
	(void) close(fd);
	(void) unlink(fname);
	errno = save_err;
	return (-1);
}

char *
audit_cron_make_anc_name(char *fname)
{
	char *anc_name;

	anc_name = (char *)malloc(strlen(fname) + strlen(AU_SUFFIX) + 1);
	if (anc_name == NULL)
		return (NULL);

	(void) strcpy(anc_name, fname);
	(void) strcat(anc_name, AU_SUFFIX);
	return (anc_name);
}

int
audit_cron_is_anc_name(char *name)
{
	int	pos;

	pos = strlen(name) - strlen(AU_SUFFIX);
	if (pos <= 0)
		return (0);

	if (strcmp(name + pos, AU_SUFFIX) == 0)
		return (1);

	return (0);
}

static void
audit_cron_session_failure(char *name, int type, char *err_str)
{
	const char	*mess;

	if (type == 0)
		mess = dgettext(bsm_dom,
		"at-job session for user %s failed: ancillary file: %s");
	else
		mess = dgettext(bsm_dom,
		"crontab job session for user %s failed: ancillary file: %s");

	(void) snprintf(textbuf, sizeof (textbuf), mess, name, err_str);

	aug_save_event(AUE_cron_invoke);
	aug_save_sorf(4);
	aug_save_text(textbuf);
	(void) aug_audit();
}


int
audit_cron_session(
		char *name,
		char *path,
		uid_t uid,
		gid_t gid,
		char *at_jobname)
{
	struct auditinfo_addr	info;
	au_mask_t		mask;
	char			*anc_file, *fname;
	int			r = 0;
	char			full_path[PATH_MAX];

	if (cannot_audit(0)) {
		return (0);
	}

	/* get auditinfo from ancillary file */
	if (at_jobname == NULL) {
		/*
		 *	this is a cron-event, so we can get
		 *	filename from "name" arg
		 */
		fname = name;
		if (path != NULL) {
			if (strlen(path) + strlen(fname) + 2 > PATH_MAX) {
				errno = ENAMETOOLONG;
				r = -1;
			}
			(void) strcat(strcat(strcpy(full_path, path), "/"),
			    fname);
			fname = full_path;
		}
	} else {
		/* this is an at-event, use "at_jobname" */
		fname = at_jobname;
	}

	if (r == 0) {
		anc_file = audit_cron_make_anc_name(fname);
		if (anc_file == NULL) {
			r = -1;
		} else {
			r = audit_cron_getinfo(fname, anc_file, &info);
		}
	}

	if (r != 0) {
		char *err_str;

		if (r == ANC_BAD_FORMAT)
			err_str = dgettext(bsm_dom, "bad format");
		else
			err_str = strerror(errno);

		audit_cron_session_failure(name,
		    at_jobname == NULL,
		    err_str);
		if (anc_file != NULL)
			free(anc_file);
		return (r);
	}

	free(anc_file);
	aug_init();

	/* get current audit masks */
	if (au_user_mask(name, &mask) == 0) {
		info.ai_mask.am_success  |= mask.am_success;
		info.ai_mask.am_failure  |= mask.am_failure;
	}

	/* save audit attributes for further use in current process */
	aug_save_auid(info.ai_auid);
	aug_save_asid(info.ai_asid);
	aug_save_tid_ex(info.ai_termid.at_port, info.ai_termid.at_addr,
	    info.ai_termid.at_type);
	aug_save_pid(getpid());
	aug_save_uid(uid);
	aug_save_gid(gid);
	aug_save_euid(uid);
	aug_save_egid(gid);

	/* set mixed audit masks */
	return (setaudit_addr(&info, sizeof (info)));
}

/*
 * audit_cron_new_job - create audit record with an information
 *			about new job started by cron.
 *	args:
 *	cmd  - command being run by cron daemon.
 *	type - type of job (0 - at-job, 1 - crontab job).
 *	event - not used. pointer to cron event structure.
 */
/*ARGSUSED*/
void
audit_cron_new_job(char *cmd, int type, void *event)
{
	if (cannot_audit(0))
		return;

	if (type == 0) {
		(void) snprintf(textbuf, sizeof (textbuf),
		    dgettext(bsm_dom, "at-job"));
	} else if (type == 1) {
		(void) snprintf(textbuf, sizeof (textbuf),
		    dgettext(bsm_dom, "batch-job"));
	} else if (type == 2) {
		(void) snprintf(textbuf, sizeof (textbuf),
		    dgettext(bsm_dom, "crontab-job"));
	} else if ((type > 2) && (type <= 25)) {	/* 25 from cron.h */
		(void) snprintf(textbuf, sizeof (textbuf),
		    dgettext(bsm_dom, "queue-job (%c)"), (type+'a'));
	} else {
		(void) snprintf(textbuf, sizeof (textbuf),
		    dgettext(bsm_dom, "unknown job type (%d)"), type);
	}

	aug_save_event(AUE_cron_invoke);
	aug_save_sorf(0);
	aug_save_text(textbuf);
	aug_save_text1(cmd);
	(void) aug_audit();
}

void
audit_cron_bad_user(char *name)
{
	if (cannot_audit(0))
		return;

	(void) snprintf(textbuf, sizeof (textbuf),
	    dgettext(bsm_dom, "bad user %s"), name);

	aug_save_event(AUE_cron_invoke);
	aug_save_sorf(2);
	aug_save_text(textbuf);
	(void) aug_audit();
}

void
audit_cron_user_acct_expired(char *name)
{
	if (cannot_audit(0))
		return;

	(void) snprintf(textbuf, sizeof (textbuf),
	    dgettext(bsm_dom,
	    "user %s account expired"), name);

	aug_save_event(AUE_cron_invoke);
	aug_save_sorf(3);
	aug_save_text(textbuf);
	(void) aug_audit();
}

int
audit_cron_create_anc_file(char *name, char *path, char *uname, uid_t uid)
{
	au_mask_t	msk;
	auditinfo_addr_t ai;
	int		pid;
	char		*anc_name;
	char		full_path[PATH_MAX];

	if (cannot_audit(0))
		return (0);

	if (name == NULL)
		return (0);

	if (path != NULL) {
		if (strlen(path) + strlen(name) + 2 > PATH_MAX)
			return (-1);
		(void) strcat(strcat(strcpy(full_path, path), "/"), name);
		name = full_path;
	}
	anc_name = audit_cron_make_anc_name(name);

	if (access(anc_name, F_OK) != 0) {
		if (au_user_mask(uname, &msk) != 0) {
			free(anc_name);
			return (-1);
		}

		ai.ai_mask = msk;
		ai.ai_auid = uid;
		ai.ai_termid.at_port = 0;
		ai.ai_termid.at_type = AU_IPv4;
		ai.ai_termid.at_addr[0] = 0;
		ai.ai_termid.at_addr[1] = 0;
		ai.ai_termid.at_addr[2] = 0;
		ai.ai_termid.at_addr[3] = 0;
		/* generate new pid to use it as asid */
		pid = vfork();
		if (pid == -1) {
			free(anc_name);
			return (-1);
		}
		if (pid == 0)
			exit(0);
		else {
		/*
		 * we need to clear status of children for
		 * wait() call in "cron"
		 */
			int lock;

			(void) waitpid(pid, &lock, 0);
		}
		ai.ai_asid = pid;
		if (audit_cron_setinfo(anc_name, &ai) != 0) {
			free(anc_name);
			return (-1);
		}
	}

	free(anc_name);
	return (0);
}

int
audit_cron_delete_anc_file(char *name, char *path)
{
	char	*anc_name;
	char	full_path[PATH_MAX];
	int	r;

	if (name == NULL)
		return (0);

	if (path != NULL) {
		if (strlen(path) + strlen(name) + 2 > PATH_MAX)
			return (-1);
		(void) strcat(strcat(strcpy(full_path, path), "/"), name);
		name = full_path;
	}
	anc_name = audit_cron_make_anc_name(name);
	r = unlink(anc_name);
	free(anc_name);
	return (r);
}