如何对NULL指针地址建立合法映射，从而合法访问NULL指针

本文将介绍如何对NULL指针地址建立合法映射，从而合法访问NULL指针。本文表达的宗旨：

任何虚拟地址，只要有合法的页表映射，就能访问！

提到C语言编程，我想几乎所有人都遭遇过NULL指针。我们的代码中总是在不断的判断指针是否为NULL：

if (p1 != NULL) {

//...

}

if (p2 == NULL) {

exit(-1);

}

如果我们忘记了这种判断，我们会收获到段错误：

[15445.731305] a.out[3511]: segfault at 0 ip 000000000040071c sp 00007ffedbacbdd0 error 4 in a.out[400000+1000]

诚然，我们都讨厌segfault，但segfault并非由于访问NULL指针引起的，相反，我们要感谢NULL指针，它帮助我们的程序排除了大量的segfault。

在现代操作系统中，程序访问的地址都是虚拟地址，硬件MMU结合操作系统创建的页表会在进程私有虚拟地址和全局物理地址之间做映射，当程序访问一个虚拟地址的时候，该映射会将这次访问转换成到物理地址的访问。

所以，segfault的本质是程序访问的虚拟内存地址无法合理映射到物理地址的一种错误通知。

引发segfault的地址成为非法地址。

现在，随意给出两个虚拟地址：

unsigned char *p1 = 0x7f1233443344;

unsigned char *p2 = 0xaa12bb443344;

谁能说出哪个虚拟地址是合法的，哪个是非法的？谁也说不出，只有试着访问它的时候才知道，引发segfault的地址就是非法的，否则就是合法的。这可能会对程序数据造成严重的伤害。

因此有必要人为规定一个非法地址，这样在程序中就可以做判断了，只要不是人为规定的那个非法地址，那就是合法的。至于说谁来严格保证其合法性，除了需要编程规范和编程习惯之外，操作系统也确实不会为该非法地址映射可以访问的物理页面。有法可依只是安全的必要条件，加上违法必究才是充分且必要的。

数字0是最特殊的，判断一个值是否为0在硬件层面上也很高效，把0作为非法地址具有高度的可辨识性，于是几乎所有的编程语言都用0来表示非法地址：

#define NULL 0

这就是NULL指针的本质。

现在让我们忘掉编程层面的原则，重新审视NULL指针。

NULL指针指示地址0，地址0没有什么特殊的，它就是进程地址空间的一个普通地址，只要为其映射一个可以访问的物理地址，它就是可以访问的。下面我们就来试试。

首先我们写个简单的C程序：

// gcc access0.c -o access0

#include

#include

#include

int main(int argc, char **argv)

{

int i, j;

unsigned char *nilp = NULL;

unsigned char *used = NULL;

used = (unsigned char *)calloc(128, 1);

// 写页面，调物理页面到内存。

strcpy(used, "zhejiang wenzhou pixie shi");

// 以下的打印便于将信息传递到内核模块，这只是为了方便，真正

// 正确的做法应该自己去hack这些信息，然后传递到内核模块。

printf("pid=%d addr=%p ", getpid(), used);

// 等待内核模块创建NULL地址的页表，完成后敲回车。

getchar();

// 打印NULL指针的前64个字节

for (i = 0; i < 4; i++) {

for (j = 0; j < 16; j++) {

printf("0x%0.2x ", *nilp);

nilp++;

}

printf(" ");

}

getchar();

free (used);

return 0;

}

可以看到，从for循环开始，我们的程序访问NULL指针地址后的64字节的数据。我们希望把NULL指针映射到calloc的地址处，然后看看是不是打印出了 “zhejiang wenzhou pixie shi”。

这个很简单，写一个内核模块，把NULL开始的一个page和calloc返回的used开始的一个page映射到同一个物理页面即可。

下面该写内核模块了，为了简化操作，这里采用Guru模式的stap脚本来进行编程：

// mapNULL.stp

%{

#include

#include

#include

pte_t * get_pte(struct task_struct *task, unsigned long address)

{

pgd_t* pgd;

pud_t* pud;

pmd_t* pmd;

pte_t* pte;

struct mm_struct *mm = task->mm;

static int nil = 0;

static pmd_t gpmd = {0};

static pte_t gpte = {0};

pgd = pgd_offset(mm, address);

if(pgd_none(*pgd) || pgd_bad(*pgd)) {

return NULL;

}

pud = pud_offset(pgd, address);

if(pud_none(*pud) || pud_bad(*pud)) {

return NULL;

}

pmd = pmd_offset(pud, address);

if(pmd_none(*pmd) || pmd_bad(*pmd)) {

*pmd = gpmd;

if(pmd_none(*pmd) || pmd_bad(*pmd)) {

return NULL;

}

}

pte = pte_offset_kernel(pmd, address);

if (nil != 0) {

pte->pte &= 0xfffffffffffff000;

*pte = gpte;

}

if(pte_none(*pte)) {

return NULL;

}

if (nil == 0) {

gpmd = *pmd;

gpte = *pte;

nil = 1;

}

return pte;

}

%}

function mapNULL:long(pid:long, addr:long)

%{

struct task_struct *task;

pte_t* pte;

void (*fun)(void);

fun = (void (*))0xffffffff81066090;

fun();

task = pid_task(find_pid_n***_ARG_pid, &init_pid_ns), PIDTYPE_PID);

if(!(pte = get_pte(task, STAP_ARG_addr))) {

STAP_RETVALUE = -1;

return;

}

fun();

if(get_pte(task, 0) == NULL) {

STAP_RETVALUE = -1;

return;

}

fun();

STAP_RETVALUE = 0;

%}

probe begin

{

mapNULL($1, $2);

exit();

}

下面演示一下效果，先看直接执行access0，不加载内核模块的效果：

[root@localhost mod]# ./access0

pid=4172 addr=0x1c78010

段错误

[root@localhost mod]#

很显然，访问了“非法地址NULL”之后，收获一个segfault。下面，我们结合内核模块再次来运行access0：

[root@localhost mod]# ./access0

pid=4174 addr=0xf38010

另起一个终端，按照打印的pid和addr加载模块：

[root@localhost mod]# stap -g mapNULL.stp 4174 0xf38010

[root@localhost mod]#

access0的终端敲入回车：

[root@localhost mod]# ./access0

pid=4174 addr=0xf38010

0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x91 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x7a 0x68 0x65 0x6a 0x69 0x61 0x6e 0x67 0x20 0x77 0x65 0x6e 0x7a 0x68 0x6f 0x75

0x20 0x70 0x69 0x78 0x69 0x65 0x20 0x73 0x68 0x69 0x00 0x00 0x00 0x00 0x00 0x00

0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

[root@localhost mod]#

可以看到，第二行开始的就是“zhejiang Wenzhou pixie shi ”了：

0x7a 0x68 0x65 0x6a 0x69 0x61 0x6e 0x67 0x20 0x77 0x65 0x6e 0x7a 0x68 0x6f 0x75

0x20 0x70 0x69 0x78 0x69 0x65 0x20 0x73 0x68 0x69 ...

那么第一行是什么呢？很显然，used内存是calloc返回的，这种内存是被malloc内存管理结构锁管理的，第一行的16字节就是这种管理机构，如果我们破坏掉它，那么在最后的free处就会出错。我们可以试一试：

// 打印NULL指针的前64个字节

for (i = 0; i < 4; i++) {

for (j = 0; j < 16; j++) {

printf("0x%0.2x ", *nilp);

if (i == 0) 将第一行16字节数据设置成0ff。

*nilp = 0xff;

nilp++;

}

printf(" ");

}

效果就是：

[root@localhost mod]# ./access0

pid=4184 addr=0x90a010

0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x91 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x7a 0x68 0x65 0x6a 0x69 0x61 0x6e 0x67 0x20 0x77 0x65 0x6e 0x7a 0x68 0x6f 0x75

0x20 0x70 0x69 0x78 0x69 0x65 0x20 0x73 0x68 0x69 0x00 0x00 0x00 0x00 0x00 0x00

0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

*** Error in `./access0': munmap_chunk(): invalid pointer: 0x000000000090a010 ***

======= Backtrace: =========

/lib64/libc.so.6(+0x7f5d4)[0x7f06b56705d4]

./access0[0x400789]

/lib64/libc.so.6(__libc_start_main+0xf5)[0x7f06b56133d5]

./access0[0x4005c9]

======= Memory map: ========

00400000-00401000 r-xp 00000000 fd:00 38533721

通过重写NULL指针地址的映射页表，我们成功访问了NULL指针，并且读出了数据。

由于MMU的映射粒度是页面，即4096字节(x86_64平台，也可以是别的值，比如2M)，所以严格来讲，“非法地址”并非只有NULL，而是从0到4096的一个页面。

很多系统正是通过将NULL地址开始的一个page映射到一个不可读写不可访问的物理page来达到捕捉非法地址的效果的。

现在，我们把部分task_struct结构体的内存映射到NULL开始的第一个虚拟地址空间页面，通过修改task结构体的comm来修改自己的名字，达到自省的目的。

修改自己名字的方法很多，prct就可以，但是本文通过映射task结构体的方式进行。

先看用户态C代码：

#include

#include

#include

int main(int argc, char **argv)

{

int i;

unsigned char *nilp = NULL;

// 为模块提供信息。

printf("pid=%d addr=%p ", getpid(), used);

getchar();

// 在一个页面范围查找task的comm字段

for (i = 0; i < 4096; i++) {

// +2是为了跳过“./”，此处没有进行复杂的字符串解析

if (!memcmp(nilp, argv[0]+2, strlen(argv[0])-2)) {

printf("OK ");

// 更改comm字段为皮鞋湿

memcpy(nilp, "pixieshi", 8);

break;

}

nilp++;

}

printf(" ");

getchar();

free (used);

}

下面是对应的内核模块：

// mapCOMM.c

// make -C /lib/modules/`uname -r`/build SUBDIRS=`pwd` modules

#include

#include

#include

#define DIRECT_MAP_START 0xffff880000000000

#define PAGE_TABLE_E 0x8000000000000000

static int pid = 16790;

module_param(pid, int, 0644);

static unsigned long addr = 0;

module_param(addr, long, 0644);

static int nil = 0;

static pmd_t gpmd = {0};

static pte_t gpte = {0};

static unsigned long tskp;

void (*fun)(void);

static pte_t* get_pte(struct task_struct *task, unsigned long address)

{

pgd_t* pgd;

pud_t* pud;

pmd_t* pmd;

pte_t* pte;

struct mm_struct *mm = task->mm;

pgd = pgd_offset(mm, address);

if(pgd_none(*pgd) || pgd_bad(*pgd)) {

return NULL;

}

pud = pud_offset(pgd, address);

if(pud_none(*pud) || pud_bad(*pud)) {

return NULL;

}

pmd = pmd_offset(pud, address);

if(pmd_none(*pmd) || pmd_bad(*pmd)) {

*pmd = gpmd;

if(pmd_none(*pmd) || pmd_bad(*pmd)) {

return NULL;

}

}

pte = pte_offset_kernel(pmd, address);

if (nil != 0) {

pte->pte = tskp;

}

if(pte_none(*pte)) {

return NULL;

}

if (nil == 0) {

pte_t p = *pte;

gpmd = *pmd;

gpte = p;

nil = 1;

}

return pte;

}

static int mapCOMM_init(void)

{

struct task_struct *task;

pte_t* pte;

int tsk_off;

struct page* page;

fun = 0xffffffff81066090;

fun();

task = pid_task(find_pid_ns(pid, &init_pid_ns), PIDTYPE_PID);

tskp = (unsigned long)task;

tskp -= DIRECT_MAP_START;

tsk_off = tskp & 0xfff;

#define COMM_OFF 1872

// 保证可以在一个页面内找到comm字段

if (tsk_off + COMM_OFF > 0xfff) {

tskp += 0x1000;

}

// 页面对齐

tskp &= 0xfffffffffffff000;

tskp += PAGE_TABLE_E;

// 用户态读写权限

tskp |= 0x67;

if(!(pte = get_pte(task, addr)))

return -1;

fun();

if(!(pte = get_pte(task, 0)))

return -1;

fun();

return -1;

}

static void mapCOMM_exit(void)

{

}

module_init(mapCOMM_init);

module_exit(mapCOMM_exit);

MODULE_LICENSE("GPL");

编译后备用。我们先运行我们的skinshoe进程。

[root@localhost mod]# ./skinshoe

pid=4216 addr=0x22d4010

获得输出信息后，另起终端，加载模块，输入skinshoe打印的信息：

[root@localhost mod]# insmod ./mapCOMM.ko pid=4216 addr=0x22d4010

insmod: ERROR: could not insert module ./mapCOMM.ko: Operation not permitted

此时skinshoe进程的运行终端看看进程的名字有没有改变：

[root@localhost mod]# cat /proc/4216/comm

pixieshi

[root@localhost mod]# ps -e|grep 4216

4216 pts/4 00:00:00 pixieshi

OK，已经改成“皮鞋湿”了。

当然了，合法访问NULL指针其实有更加“正规”的做法，即修改内核参数：

[root@localhost stap]# sysctl -a|grep vm.mmap_min_addr

vm.mmap_min_addr = 4096

[root@localhost stap]# sysctl -w vm.mmap_min_addr=0

vm.mmap_min_addr = 0

[root@localhost stap]# sysctl -a|grep vm.mmap_min_addr

vm.mmap_min_addr = 0

[root@localhost stap]#

然后使用mmap系统调用将指针FIXed map到地址0即可。

说一下本文的缘起以及一些例行的形而上的意义。

前天晚上，有位朋友问了我一个问题，为了备忘，我昨天发了一则朋友圈：

昨天有人问我说为什么NULL指针不能访问，我说NULL指针是可以访问的，NULL就是0，0也是一个合法地址，为什么不能访问？ 之所以一访问NULL就会收获一个段错误纯粹是编程意义上的人为规定，不存在操作系统硬件层面的硬性机制阻止NULL指针被访问。 为此，我还专门写了一个demo，修改页表项为NULL地址映射一个物理页面，NULL地址不光可以读写，还能修改进程名字呢。 char *p;char *p = NULL; 以上二者是不同的，上面那个p指针是“无”，而下面那个p则是“空”，“无”是什么都没有，“空”是实实在在的空，仔细体会这种略带哲学意味的区别。

关于“空”和“无”，在C/C++编程规范上特别要注意：

防止访问空指针：访问指针前要判断NULL。

杜绝野指针：释放指针后要设置NULL。

总之，我们要依靠“空”，避开“无”。

“无”是什么都没有，薛定谔的无，“空”是实实在在的空，空为万物，万物皆空。