/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2018-2023, Juniper Networks, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/cdefs.h>
#include <stdlib.h>
#include <sysexits.h>
#include <unistd.h>
#include <paths.h>
#include <err.h>
#include <syslog.h>
#include <libsecureboot.h>
#include <libveriexec.h>
#include <sys/types.h>

#include "veriexec.h"

/* Globals that are shared with manifest_parser.c */
int dev_fd = -1;
int ForceFlags = 0;
int Verbose = 0;
int VeriexecVersion = 0;
const char *Cdir = NULL;

/*!
 * @brief Print help message describing program's usage
 * @param void
 * @return always returns code 0
 */
static int
veriexec_usage(void)
{
	printf("%s",
	    "Usage:\tveriexec [-C path] [-hlxv] [-[iz] state] [path]\n");

	return (0);
}

/*!
 * @brief Load a veriexec manifest
 * @param manifest Pointer to the location of the manifest file
 * @retval the error code returned from the parser
 */
static int
veriexec_load(const char *manifest)
{
	unsigned char *content;
	int rc;

	content = verify_signed(manifest, VEF_VERBOSE);
	if (!content)
		errx(EX_USAGE, "cannot verify %s", manifest);
	if (manifest_open(manifest, (const char *)content)) {
		rc = yyparse();
	} else {
		err(EX_NOINPUT, "cannot load %s", manifest);
	}
	free(content);
	return (rc);
}

/*!
 * @brief Get the veriexec state for the supplied argument
 * @param arg_text String containing the argument to be processed
 * @retval The veriexec state number for the specified argument
 */
static uint32_t
veriexec_state_query(const char *arg_text)
{
	uint32_t state = 0;
	unsigned long len;

	len = strlen(arg_text);

	if (strncmp(arg_text, "active", len) == 0)
		state |= VERIEXEC_STATE_ACTIVE;
	else if (strncmp(arg_text, "enforce", len) == 0)
		state |= VERIEXEC_STATE_ENFORCE;
	if (strncmp(arg_text, "loaded", len) == 0)
		state |= VERIEXEC_STATE_LOADED;
	if (strncmp(arg_text, "locked", len) == 0)
		state |= VERIEXEC_STATE_LOCKED;
	if (state == 0 || __bitcount(state) > 1)
		errx(EX_USAGE, "Unknown state \'%s\'", arg_text);

	return (state);
}

/*!
 * @brief Get the veriexec command state for the supplied argument
 * @param arg_text String containing the argument to be processed
 * @retval The veriexec command state for the specified argument
 */
static uint32_t
veriexec_state_modify(const char *arg_text)
{
	uint32_t state = 0;
	unsigned long len;

	len = strlen(arg_text);

	if (strncmp(arg_text, "active", len) == 0)
		state = VERIEXEC_ACTIVE;
	else if (strncmp(arg_text, "enforce", len) == 0)
		state = VERIEXEC_ENFORCE;
	else if (strncmp(arg_text, "getstate", len) == 0)
		state = VERIEXEC_GETSTATE;
	else if (strncmp(arg_text, "lock", len) == 0)
		state = VERIEXEC_LOCK;
	else
		errx(EX_USAGE, "Unknown command \'%s\'", arg_text);

	return (state);
}

#ifdef HAVE_VERIEXEC_GET_PATH_LABEL
static void
veriexec_check_labels(int argc, char *argv[])
{
	char buf[BUFSIZ];
	char *cp;
	int n;

	n = (argc - optind);
	for (; optind < argc; optind++) {
		cp = veriexec_get_path_label(argv[optind], buf, sizeof(buf));
		if (cp) {
			if (n > 1)
				printf("%s: %s\n", argv[optind], cp);
			else
				printf("%s\n", cp);
			if (cp != buf)
				free(cp);
		}
	}
	exit(EX_OK);
}
#endif

static void
veriexec_check_paths(int argc, char *argv[])
{
	int x;

	x = EX_OK;
	for (; optind < argc; optind++) {
		if (veriexec_check_path(argv[optind])) {
			warn("%s", argv[optind]);
			x = 2;
		}
	}
	exit(x);
}

int
main(int argc, char *argv[])
{
	long long converted_int;
	uint32_t state;
	int c, x;

	if (argc < 2)
		return (veriexec_usage());

	dev_fd = open(_PATH_DEV_VERIEXEC, O_WRONLY, 0);

	while ((c = getopt(argc, argv, "C:hi:lSxvz:")) != -1) {
		switch (c) {
		case 'h':
			/* Print usage info */

			return (veriexec_usage());
		case 'C':
			/* Get the provided directory argument */

			Cdir = optarg;
			break;
		case 'i':
			/* Query the current state */

			if (dev_fd < 0) {
				err(EX_UNAVAILABLE, "cannot open veriexec");
			}
			if (ioctl(dev_fd, VERIEXEC_GETSTATE, &x)) {
				err(EX_UNAVAILABLE,
				    "Cannot get veriexec state");
			}

			state = veriexec_state_query(optarg);

			exit((x & state) == 0);
			break;
#ifdef HAVE_VERIEXEC_GET_PATH_LABEL
		case 'l':
			veriexec_check_labels(argc, argv);
			break;
#endif
		case 'S':
			/* Strictly enforce certificate validity */
			ve_enforce_validity_set(1);
			break;
		case 'v':
			/* Increase the verbosity */

			Verbose++;
			break;
		case 'x':
			/* Check veriexec paths */

			/*
			 * -x says all other args are paths to check.
			 */
			veriexec_check_paths(argc, argv);
			break;
		case 'z':
			/* Modify the state */

			if (strncmp(optarg, "debug", strlen(optarg)) == 0) {
				const char *error;

				if (optind >= argc)
					errx(EX_USAGE,
					    "Missing mac_veriexec verbosity level \'N\', veriexec -z debug N, where N is \'off\' or the value 0 or greater");

				if (strncmp(argv[optind], "off", strlen(argv[optind])) == 0) {
					state = VERIEXEC_DEBUG_OFF;
					x = 0;
				} else {
					state = VERIEXEC_DEBUG_ON;

					converted_int = strtonum(argv[optind], 0, INT_MAX, &error);

					if (error != NULL)
						errx(EX_USAGE, "Conversion error for argument \'%s\' : %s",
						    argv[optind], error);

					x = (int) converted_int;


					if (x == 0)
						state = VERIEXEC_DEBUG_OFF;
				}
			} else
				state = veriexec_state_modify(optarg);

			if (dev_fd < 0)
				err(EX_UNAVAILABLE, "Cannot open veriexec");
			if (ioctl(dev_fd, state, &x))
				err(EX_UNAVAILABLE, "Cannot %s veriexec", optarg);

			if (state == VERIEXEC_DEBUG_ON || state == VERIEXEC_DEBUG_OFF)
				printf("mac_veriexec debug verbosity level: %d\n", x);
			else if (state == VERIEXEC_GETSTATE)
				printf("Veriexec state (octal) : %#o\n", x);

			exit(EX_OK);
			break;
		default:

			/* Missing argument, print usage info.*/
			veriexec_usage();
			exit(EX_USAGE);
			break;
		}
	}

	if (Verbose)
		printf("Verbosity level : %d\n", Verbose);

	if (dev_fd < 0)
		err(EX_UNAVAILABLE, "Cannot open veriexec");

	openlog(getprogname(), LOG_PID, LOG_AUTH);
	if (ve_trust_init() < 1)
		errx(EX_OSFILE, "cannot initialize trust store");
#ifdef VERIEXEC_GETVERSION
	if (ioctl(dev_fd, VERIEXEC_GETVERSION, &VeriexecVersion)) {
		VeriexecVersion = 0;	/* unknown */
	}
#endif

	for (; optind < argc; optind++) {
		if (veriexec_load(argv[optind])) {
			err(EX_DATAERR, "cannot load %s", argv[optind]);
		}
	}
	exit(EX_OK);
}