/*	$OpenBSD: xonly.c,v 1.2 2023/06/26 19:03:03 guenther Exp $	*/

#include <sys/types.h>
#include <sys/mman.h>

#include <dlfcn.h>
#include <err.h>
#include <fcntl.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define UNREADABLE	0
#define READABLE	1

int main(void);
void sigsegv(int);
void setup_table(void);

void *setup_ldso(void);
void *setup_mmap_xz(void);
void *setup_mmap_x(void);
void *setup_mmap_nrx(void);
void *setup_mmap_nwx(void);
void *setup_mmap_xnwx(void);

char	***_csu_finish(char **_argv, char **_envp, void (*_cleanup)(void));

struct outcome {
	int uu;
	int ku;
};

struct readable {
	const char *name;
	void *(*setup)(void);
	int isfn;
	void *addr;
	int skip;
	struct outcome got;
} readables[] = {
	{ "ld.so",	setup_ldso, 1,		NULL,	0, {} },
	{ "mmap xz",	setup_mmap_xz, 0,	NULL,	0, {} },
	{ "mmap x",	setup_mmap_x, 0,	NULL,	0, {} },
	{ "mmap nrx",	setup_mmap_nrx, 0,	NULL,	0, {} },
	{ "mmap nwx",	setup_mmap_nwx, 0,	NULL,	0, {} },
	{ "mmap xnwx",	setup_mmap_xnwx, 0,	NULL,	0, {} },
	{ "main",	NULL, 1,		&main,	0, {} },
	{ "libc",	NULL, 1,		&_csu_finish, 0, {} },
};

static struct outcome expectations[2][8] = {
#if defined(__aarch64__) || defined(__amd64__)
	[0] = {
		/* ld.so */	{ UNREADABLE,	UNREADABLE },
		/* mmap xz */	{ UNREADABLE,	UNREADABLE },
		/* mmap x */	{ UNREADABLE,	UNREADABLE },
		/* mmap nrx */	{ UNREADABLE,	UNREADABLE },
		/* mmap nwx */	{ UNREADABLE,	UNREADABLE },
		/* mmap xnwx */	{ UNREADABLE,	UNREADABLE },
		/* main */	{ UNREADABLE,	UNREADABLE },
		/* libc */	{ UNREADABLE,	UNREADABLE },
	},
#else
#error "unknown architecture"
#endif
#if defined(__amd64__)
	/* PKU not available. */
	[1] = {
		/* ld.so */	{ READABLE,	UNREADABLE },
		/* mmap xz */	{ UNREADABLE,	UNREADABLE },
		/* mmap x */	{ READABLE,	READABLE },
		/* mmap nrx */	{ READABLE,	READABLE },
		/* mmap nwx */	{ READABLE,	READABLE },
		/* mmap xnwx */	{ READABLE,	READABLE },
		/* main */	{ READABLE,	UNREADABLE },
		/* libc */	{ READABLE,	UNREADABLE },
	},
#endif
};

jmp_buf fail;

void
sigsegv(__unused int signo)
{
	longjmp(fail, 1);
}

void *
setup_mmap_xz(void)
{
	return mmap(NULL, getpagesize(), PROT_EXEC,
	    MAP_ANON | MAP_PRIVATE, -1, 0);
	/* no data written. tests read-fault of an unbacked exec-only page */
}

void *
setup_mmap_x(void)
{
	char *addr;

	addr = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
	    MAP_ANON | MAP_PRIVATE, -1, 0);
	explicit_bzero(addr, getpagesize());
	mprotect(addr, getpagesize(), PROT_EXEC);
	return addr;
}

void *
setup_mmap_nrx(void)
{
	char *addr;

	addr = mmap(NULL, getpagesize(), PROT_NONE,
	    MAP_ANON | MAP_PRIVATE, -1, 0);
	mprotect(addr, getpagesize(), PROT_READ | PROT_WRITE);
	explicit_bzero(addr, getpagesize());
	mprotect(addr, getpagesize(), PROT_EXEC);
	return addr;
}

void *
setup_mmap_nwx(void)
{
	char *addr;

	addr = mmap(NULL, getpagesize(), PROT_NONE,
	    MAP_ANON | MAP_PRIVATE, -1, 0);
	mprotect(addr, getpagesize(), PROT_WRITE);
	explicit_bzero(addr, getpagesize());
	mprotect(addr, getpagesize(), PROT_EXEC);
	return addr;
}

void *
setup_mmap_xnwx(void)
{
	char *addr;

	addr = mmap(NULL, getpagesize(), PROT_EXEC,
	    MAP_ANON | MAP_PRIVATE, -1, 0);
	mprotect(addr, getpagesize(), PROT_NONE);
	mprotect(addr, getpagesize(), PROT_WRITE);
	explicit_bzero(addr, getpagesize());
	mprotect(addr, getpagesize(), PROT_EXEC);
	return addr;
}

void *
setup_ldso(void)
{
	void *dlopenp, *handle;

	handle = dlopen("ld.so", RTLD_NOW);
	if (handle == NULL)
		errx(1, "dlopen");
	dlopenp = dlsym(handle, "dlopen");
	return dlopenp;
}

void
setup_table(void)
{
	size_t i;

	for (i = 0; i < sizeof(readables)/sizeof(readables[0]); i++) {
		if (setjmp(fail) == 0) {
			if (readables[i].setup)
				readables[i].addr = readables[i].setup();
		} else {
			readables[i].skip = 1;
		}
#ifdef __hppa__
		/* hppa ptable headers point at the instructions */
		if (readables[i].isfn) {
			readables[i].addr = (void *)*(u_int *)
			    ((u_int)readables[i].addr & ~3);
		}
#endif
	}
}

int
main(void)
{
	size_t i;
	int p[2];
	int error = 0;
	const struct outcome *desires = expectations[0];

#if defined(__amd64__)
	{
		uint32_t ebx, ecx, edx;
		asm("cpuid" : "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (7), "c" (0));
		if ((ecx & 8) == 0) /* SEFF0ECX_PKU */
			desires = expectations[1];
	}
#endif


	signal(SIGSEGV, sigsegv);
	signal(SIGBUS, sigsegv);

	setup_table();

	for (i = 0; i < sizeof(readables)/sizeof(readables[0]); i++) {
		struct readable *r = &readables[i];
		char c;

		if (r->skip)
			continue;
		pipe(p);
		fcntl(p[0], F_SETFL, O_NONBLOCK);

		if (write(p[1], r->addr, 1) == 1 && read(p[0], &c, 1) == 1)
			r->got.ku = 1;

		if (setjmp(fail) == 0) {
			volatile int x = *(int *)(r->addr);
			(void)x;
			r->got.uu = 1;
		}

		close(p[0]);
		close(p[1]);
	}

	printf("%-16s  %18s  userland     kernel\n", "", "");
	for (i = 0; i < sizeof(readables)/sizeof(readables[0]); i++) {
		struct readable *r = &readables[i];

		if (r->skip) {
			printf("%-16s  %18p  %-12s %-12s\n", r->name, r->addr,
			    "skipped", "skipped");
		} else {
			const struct outcome *want = &desires[i];

			if (r->got.uu != want->uu || r->got.ku != want->ku)
				error++;

			printf("%-16s  %18p  %s%-10s %s%-10s\n",
			    r->name, r->addr,
			    r->got.uu == want->uu ? "P " : "F ",
			    r->got.uu ? "readable" : "unreadable",
			    r->got.ku == want->ku ? "P " : "F ",
			    r->got.ku ? "readable" : "unreadable");
		}
	}
	return error;
}