Skip to contentSkip to conversation

kallsyms01: Utilize ksymbol table for unauthorized address access

PATCH In review Li Wang 2 participants 2 messages Apr 22, 2024 – Apr 29, 2024

lore
Share & tools
lore

Li Wang

author
#0 lore raw

PATCH 1/1 kallsyms01: Utilize ksymbol table for unauthorized address access

Access the system symbols with root permission to test whether it's possible to read and write the memory addresses of kernel-space from user-space. This helps in identifying potential vulnerabilities where user-space processes can inappropriately access kernel memory.

---
 runtest/mm                                    |   2 +
 testcases/kernel/security/kallsyms/.gitignore |   1 +
 testcases/kernel/security/kallsyms/Makefile   |   6 +
 testcases/kernel/security/kallsyms/kallsyms.c | 161 ++++++++++++++++++
 4 files changed, 170 insertions(+)
 create mode 100644 testcases/kernel/security/kallsyms/.gitignore
 create mode 100644 testcases/kernel/security/kallsyms/Makefile
 create mode 100644 testcases/kernel/security/kallsyms/kallsyms.c
runtest/mm +2 -0
index d859b331c..6a8cd0b9d 100644
@@ -58,6 +58,8 @@ mmap10_2 mmap10 -s
 mmap10_3 mmap10 -a -s
 mmap10_4 mmap10 -a -s -i 60
 
+kallsyms kallsyms
+
 ksm01 ksm01
 ksm01_1 ksm01 -u 128
 ksm02 ksm02
testcases/kernel/security/kallsyms/.gitignore new file +1 -0
new file mode 100644
index 000000000..7074d4e24
@@ -0,0 +1 @@
+kallsyms
testcases/kernel/security/kallsyms/Makefile new file +6 -0
new file mode 100644
index 000000000..5ea7d67db
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+top_srcdir		?= ../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+include $(top_srcdir)/include/mk/generic_leaf_target.mk
testcases/kernel/security/kallsyms/kallsyms.c new file +161 -0

161 lines not on this page · raw message

Signature · 5 lines
2.40.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#1 lore raw

Hi!

Quoted 39 lines
testcases/kernel/security/kallsyms/kallsyms.c new file +39 -0
+struct kallsym {
+	unsigned long addr;
+	char type;
+	char name[128];
+};
+
+struct ksymstbl {
+	struct kallsym symbol;
+	struct ksymstbl *next;
+};
+
+static struct ksymstbl *sym_table;
+static unsigned int nr_symbols;
+static sigjmp_buf jmpbuf;
+volatile sig_atomic_t segv_caught = 0;
+
+static void segv_handler(int sig)
+{
+	if (sig == SIGSEGV)
+		segv_caught++;
+	else
+		tst_res(TFAIL, "Unexpected signal %s", strsignal(sig));
+
+	siglongjmp(jmpbuf, 1);
+}
+
+static struct ksymstbl *read_kallsyms(unsigned int *nr_symbols)
+{
+	FILE *stream;
+	char *line = NULL;
+	size_t len = 0;
+	unsigned int nr_syms = 0;
+	struct ksymstbl *head, *item, *i;
+
+	item = head = calloc(1, sizeof(*head));
+	if (head == NULL)
+		goto out;
+
+	stream = SAFE_FOPEN("/proc/kallsyms", "r");

testcases/kernel/security/kallsyms/kallsyms.c line 97

Quoted 10 lines
testcases/kernel/security/kallsyms/kallsyms.c new file +10 -0
+
+	while (getline(&line, &len, stream) != -1) {
+		i = item;
+
+		sscanf(line, "%lx %c %s",
+				&i->symbol.addr, &i->symbol.type, i->symbol.name);
+
+		item = calloc(1, sizeof(*i));
+		if (item == NULL)
+			tst_brk(TBROK, "In calloc[]");

We should add SAFE_CALLOC() to the test library. Or maybe SAFE_ZEROED_MALLOC() because we actually mis-use the calloc() here to get the memory initialized to zero.

Also it may be actually faster to read the file twice, first time only to count the addresses and allocate an array of the symbols instead. That way we avoid all the allocation and list traversal.

static unsigned int read_kallsyms(struct ksymbtl *table, unsigned int table_size)

{
	FILE *stream = SAFE_FOPEN("/proc/kallsyms", "r");
	unsigned int nr_syms = 0;

	while (getline(&line, &len, stream) != -1) {

		if (table && nr_syms < table_size) {
			sscanf(line, "%lx %c %s",
			       &table[nr_syms].addr,
			       ...);
		}

		nr_syms++;
	}

	return nr_syms;
}

static void setup(void)

{
	unsigned int nr_syms;

	nr_syms = read_kallsyms(NULL, 0);

	sym_table = SAFE_MALLOC(sizeof(*sym_table) * nr_syms);

	if (nr_syms != read_kallsyms(sym_table, nr_syms))
		tst_res(TWARN, "/proc/kallsyms changed size!?");
}
Quoted 63 lines
testcases/kernel/security/kallsyms/kallsyms.c new file +63 -0
+		i->next = item;
+		nr_syms += 1;
+	}
+
+	*nr_symbols = nr_syms;
+	SAFE_FCLOSE(stream);
+out:
+	return head;
+}
+
+static void setup(void)
+{
+	sym_table = read_kallsyms(&nr_symbols);
+	if (!sym_table)
+		tst_brk(TBROK, "Failed to read kernel symbols");
+}
+
+static void access_ksymbols_address(struct ksymstbl *sym_table)
+{
+	if (sigsetjmp(jmpbuf, 1) == 0) {
+		*(volatile unsigned long *)sym_table->symbol.addr = 0;
+
+		tst_res(TFAIL, "Successfully accessed kernel addr 0x%lx (%s)",
+			sym_table->symbol.addr, sym_table->symbol.name);
+	}
+
+}
+
+static void test_access_kernel_address(void)
+{
+	struct ksymstbl *current;
+	struct sigaction sa;
+
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_handler = segv_handler;
+	sigaction(SIGSEGV, &sa, NULL);
+
+	current = sym_table;
+	while (current->next != NULL) {
+		access_ksymbols_address(current);
+		current = current->next;
+	}
+
+	if (segv_caught == (sig_atomic_t)nr_symbols)
+		tst_res(TPASS, "Caught %d times SIGSEGV in access ksymbols addr", segv_caught);
+}
+
+static void cleanup(void)
+{
+	while (sym_table != NULL) {
+		struct ksymstbl *temp = sym_table;
+		sym_table = sym_table->next;
+		free(temp);
+	}
+}
+
+static struct tst_test test = {
+	.needs_root = 1,
+	.setup = setup,
+	.cleanup = cleanup,
+	.max_runtime = 60,
+	.test_all = test_access_kernel_address,
+};
Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp