[apple/xnu.git] / tests / correct_kernel_booted.c

// Copyright (c) 2020 Apple, Inc.  All rights reserved.

#include <darwintest.h>
#include <dirent.h>
#include <fcntl.h>
#include <libkern/OSByteOrder.h>
#include <mach-o/loader.h>
#include <stdbool.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <TargetConditionals.h>
#include <unistd.h>
#include <uuid/uuid.h>

static bool
get_macho_uuid(const char *cwd, const char *path, uuid_t uuid)
{
	bool found = false;
	void *mapped = MAP_FAILED;
	size_t mapped_len = 0;

	T_SETUPBEGIN;

	// Skip irregular files (directories, devices, etc.).
	struct stat stbuf = {};
	int ret = stat(path, &stbuf);
	if (ret < 0 && errno == ENOENT) {
		goto out;
	}
	T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "should stat %s%s", cwd, path);
	if ((stbuf.st_mode & S_IFREG) == 0) {
		goto out;
	}
	if (stbuf.st_size < (off_t)sizeof(struct mach_header)) {
		goto out;
	}

	int fd = open(path, O_RDONLY);
	if (fd < 0 && (errno == EPERM || errno == EACCES || errno == ENOENT)) {
		goto out;
	}
	T_QUIET;
	T_ASSERT_POSIX_SUCCESS(fd, "should open file at %s%s", cwd, path);

	mapped = mmap(NULL, (size_t)stbuf.st_size, PROT_READ, MAP_PRIVATE,
	    fd, 0);
	T_QUIET; T_WITH_ERRNO;
	T_ASSERT_NE(mapped, MAP_FAILED, "should map Mach-O binary at %s%s",
	    cwd, path);
	(void)close(fd);

	// Mach-O parsing boilerplate.
	uint32_t magic = *(uint32_t *)mapped;
	bool should_swap = false;
	bool b32 = false;
	// XXX This does not handle fat binaries.
	switch (magic) {
	case MH_CIGAM:
		should_swap = true;
		OS_FALLTHROUGH;
	case MH_MAGIC:
		b32 = true;
		break;
	case MH_CIGAM_64:
		should_swap = true;
		break;
	case MH_MAGIC_64:
		break;
	default:
		goto out;
	}
	const struct load_command *lcmd = NULL;
	unsigned int ncmds = 0;
	if (b32) {
		const struct mach_header *hdr = mapped;
		ncmds = hdr->ncmds;
		lcmd = (const void *)((const char *)mapped + sizeof(*hdr));
	} else {
		const struct mach_header_64 *hdr = mapped;
		ncmds = hdr->ncmds;
		lcmd = (const void *)((const char *)mapped + sizeof(*hdr));
	}
	ncmds = should_swap ? OSSwapInt32(ncmds) : ncmds;

	// Scan through load commands to find LC_UUID.
	for (unsigned int i = 0; i < ncmds; i++) {
		if ((should_swap ? OSSwapInt32(lcmd->cmd) : lcmd->cmd) == LC_UUID) {
			const struct uuid_command *uuid_cmd = (const void *)lcmd;
			uuid_copy(uuid, uuid_cmd->uuid);
			found = true;
			break;
		}

		uint32_t cmdsize = should_swap ? OSSwapInt32(lcmd->cmdsize) :
		    lcmd->cmdsize;
		lcmd = (const void *)((const char *)lcmd + cmdsize);
	}

	if (!found) {
		T_LOG("could not find LC_UUID in Mach-O at %s%s", cwd, path);
	}

out:
	T_SETUPEND;

	if (mapped != MAP_FAILED) {
		munmap(mapped, mapped_len);
	}
	return found;
}

T_DECL(correct_kernel_booted,
    "Make sure the kernel on disk matches the running kernel, by UUID.",
    T_META_RUN_CONCURRENTLY(true))
{
	T_SETUPBEGIN;

	uuid_t kern_uuid;
	uuid_string_t kern_uuid_str;
	size_t kern_uuid_size = sizeof(kern_uuid_str);
	int ret = sysctlbyname("kern.uuid", &kern_uuid_str, &kern_uuid_size, NULL,
	    0);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "should get running kernel UUID");
	T_LOG("%s: running kernel", kern_uuid_str);

	ret = uuid_parse(kern_uuid_str, kern_uuid);
	T_QUIET; T_ASSERT_EQ(ret, 0, "should parse kernel UUID into bytes");

#if TARGET_OS_OSX
	const char *kernels_path = "/System/Library/Kernels/";
#else // TARGET_OS_OSX
	const char *kernels_path = "/";
#endif // !TARGET_OS_OSX
	T_LOG("searching for kernels at %s", kernels_path);

	ret = chdir(kernels_path);
	T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "should change directory to %s",
	    kernels_path);

	DIR *kernels_dir = opendir(kernels_path);
	T_QUIET; T_ASSERT_NOTNULL(kernels_dir, "should open directory at %s",
	    kernels_path);

	T_SETUPEND;

	bool found = false;
	struct dirent *entry = NULL;
	while ((entry = readdir(kernels_dir)) != NULL) {
		uuid_t bin_uuid;
		bool ok = get_macho_uuid(kernels_path, entry->d_name, bin_uuid);
		if (ok) {
			uuid_string_t bin_uuid_str;
			uuid_unparse(bin_uuid, bin_uuid_str);
			T_LOG("%s: from %s%s", bin_uuid_str, kernels_path, entry->d_name);
			if (uuid_compare(bin_uuid, kern_uuid) == 0) {
				found = true;
				T_PASS("UUID from %s%s matches kernel UUID", kernels_path,
				    entry->d_name);
			}
		}
	}
	if (!found) {
		T_FAIL("failed to find kernel binary with UUID of the running kernel, "
		    "wrong kernel is booted");
	}
}
Commit	Line	Data
f427ee49 A	1	// Copyright (c) 2020 Apple, Inc. All rights reserved.
	2
	3	#include <darwintest.h>
	4	#include <dirent.h>
	5	#include <fcntl.h>
	6	#include <libkern/OSByteOrder.h>
	7	#include <mach-o/loader.h>
	8	#include <stdbool.h>
	9	#include <sys/mman.h>
	10	#include <sys/stat.h>
	11	#include <sys/sysctl.h>
	12	#include <TargetConditionals.h>
	13	#include <unistd.h>
	14	#include <uuid/uuid.h>
	15
	16	static bool
	17	get_macho_uuid(const char cwd, const char path, uuid_t uuid)
	18	{
	19	bool found = false;
	20	void *mapped = MAP_FAILED;
	21	size_t mapped_len = 0;
	22
	23	T_SETUPBEGIN;
	24
	25	// Skip irregular files (directories, devices, etc.).
	26	struct stat stbuf = {};
	27	int ret = stat(path, &stbuf);
	28	if (ret < 0 && errno == ENOENT) {
	29	goto out;
	30	}
	31	T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "should stat %s%s", cwd, path);
	32	if ((stbuf.st_mode & S_IFREG) == 0) {
	33	goto out;
	34	}
	35	if (stbuf.st_size < (off_t)sizeof(struct mach_header)) {
	36	goto out;
	37	}
	38
	39	int fd = open(path, O_RDONLY);
	40	if (fd < 0 && (errno == EPERM \|\| errno == EACCES \|\| errno == ENOENT)) {
	41	goto out;
	42	}
	43	T_QUIET;
	44	T_ASSERT_POSIX_SUCCESS(fd, "should open file at %s%s", cwd, path);
	45
	46	mapped = mmap(NULL, (size_t)stbuf.st_size, PROT_READ, MAP_PRIVATE,
	47	fd, 0);
	48	T_QUIET; T_WITH_ERRNO;
	49	T_ASSERT_NE(mapped, MAP_FAILED, "should map Mach-O binary at %s%s",
	50	cwd, path);
	51	(void)close(fd);
	52
	53	// Mach-O parsing boilerplate.
	54	uint32_t magic = (uint32_t )mapped;
	55	bool should_swap = false;
	56	bool b32 = false;
	57	// XXX This does not handle fat binaries.
	58	switch (magic) {
	59	case MH_CIGAM:
	60	should_swap = true;
	61	OS_FALLTHROUGH;
	62	case MH_MAGIC:
	63	b32 = true;
	64	break;
65	case MH_CIGAM_64:
66	should_swap = true;
67	break;
68	case MH_MAGIC_64:
69	break;
70	default:
71	goto out;
72	}
73	const struct load_command *lcmd = NULL;
74	unsigned int ncmds = 0;
75	if (b32) {
76	const struct mach_header *hdr = mapped;
77	ncmds = hdr->ncmds;
78	lcmd = (const void )((const char )mapped + sizeof(*hdr));
79	} else {
80	const struct mach_header_64 *hdr = mapped;
81	ncmds = hdr->ncmds;
82	lcmd = (const void )((const char )mapped + sizeof(*hdr));
83	}
84	ncmds = should_swap ? OSSwapInt32(ncmds) : ncmds;
85
86	// Scan through load commands to find LC_UUID.
87	for (unsigned int i = 0; i < ncmds; i++) {
88	if ((should_swap ? OSSwapInt32(lcmd->cmd) : lcmd->cmd) == LC_UUID) {
89	const struct uuid_command uuid_cmd = (const void )lcmd;
90	uuid_copy(uuid, uuid_cmd->uuid);
91	found = true;
92	break;
93	}
94
95	uint32_t cmdsize = should_swap ? OSSwapInt32(lcmd->cmdsize) :
96	lcmd->cmdsize;
97	lcmd = (const void )((const char )lcmd + cmdsize);
98	}
99
100	if (!found) {
101	T_LOG("could not find LC_UUID in Mach-O at %s%s", cwd, path);
102	}
103
104	out:
105	T_SETUPEND;
106
107	if (mapped != MAP_FAILED) {
108	munmap(mapped, mapped_len);
109	}
110	return found;
111	}
112
113	T_DECL(correct_kernel_booted,
114	"Make sure the kernel on disk matches the running kernel, by UUID.",
115	T_META_RUN_CONCURRENTLY(true))
116	{
117	T_SETUPBEGIN;
118
119	uuid_t kern_uuid;
120	uuid_string_t kern_uuid_str;
121	size_t kern_uuid_size = sizeof(kern_uuid_str);
122	int ret = sysctlbyname("kern.uuid", &kern_uuid_str, &kern_uuid_size, NULL,
123	0);
124	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "should get running kernel UUID");
125	T_LOG("%s: running kernel", kern_uuid_str);
126
127	ret = uuid_parse(kern_uuid_str, kern_uuid);
128	T_QUIET; T_ASSERT_EQ(ret, 0, "should parse kernel UUID into bytes");
129
130	#if TARGET_OS_OSX
131	const char *kernels_path = "/System/Library/Kernels/";
132	#else // TARGET_OS_OSX
133	const char *kernels_path = "/";
134	#endif // !TARGET_OS_OSX
135	T_LOG("searching for kernels at %s", kernels_path);
136
137	ret = chdir(kernels_path);
138	T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "should change directory to %s",
139	kernels_path);
140
141	DIR *kernels_dir = opendir(kernels_path);
142	T_QUIET; T_ASSERT_NOTNULL(kernels_dir, "should open directory at %s",
143	kernels_path);
144
145	T_SETUPEND;
146
147	bool found = false;
148	struct dirent *entry = NULL;
149	while ((entry = readdir(kernels_dir)) != NULL) {
150	uuid_t bin_uuid;
151	bool ok = get_macho_uuid(kernels_path, entry->d_name, bin_uuid);
152	if (ok) {
153	uuid_string_t bin_uuid_str;
154	uuid_unparse(bin_uuid, bin_uuid_str);
155	T_LOG("%s: from %s%s", bin_uuid_str, kernels_path, entry->d_name);
156	if (uuid_compare(bin_uuid, kern_uuid) == 0) {
157	found = true;
158	T_PASS("UUID from %s%s matches kernel UUID", kernels_path,
159	entry->d_name);
160	}
161	}
162	}
163	if (!found) {
164	T_FAIL("failed to find kernel binary with UUID of the running kernel, "
165	"wrong kernel is booted");
166	}
167	}