失眠网 > 理解Linux内核漏洞：（内核开发人员必读）

理解Linux内核漏洞：（内核开发人员必读）

时间：2019-03-08 04:58:25

初步理解内核漏洞：（内核开发人员必读）

内核开发人员，如果不了解内核漏洞的话，容易在开发时引入漏洞，轻则导致内核崩溃，影响上面的所有应用程序；重则导致内核提权，即可以突破应用层的沙箱，进入内核，并在内核里面为所欲为。

本文章就是讲解一下常见的内核漏洞类型，让内核开发人员有个初步的了解，从而在开发时就会有潜意识，不会制造比较明显的漏洞了。（对于专门挖过内核漏洞的人来说，该文章就没必要看了：）。

常见的内核漏洞有下面几种：栈溢出(stack overflow)、堆溢出(heap overflow)、整型溢出漏洞（integer overflow）、释放后重用（use-after-free）、双重释放（double free）、线程竞争（race condtion）.

下面通过例子，一一进行简单地介绍：

栈溢出：

例子：

static size_t deviceA_write(struct file *filp, const char __user *buf, size_t len, loff_t *data) {int ret = 0;char tmp[100] = { 0 };/* write data to the buffer */if (copy_from_user(tmp, buf, len)) {return -EFAULT;}

上述是一个设备驱动的代码，提供了write的接口。即用户在应用层可以调用write函数，向该设备写数据。内核开发人员都知道copy_from_user是从应用层往内核层拷贝数据，其第一个参数tmp为拷贝的目的地址；第二个参数buf 为拷贝的源地址；第三个参数为拷贝的数据的长度。在这里目标地址的长度为100，但是由于没有对拷贝的长度（len）做限制，当用户传入的长度大于100时，用户的数据就会覆盖掉tmp的100个字节以外的数据。由于栈是从高往低的，因此覆盖的数据会是比tmp的高地址的数据。程序的返回地址一般在进行函数调用时放到栈上，在这里如果将返回地址覆盖掉了，那么就可以控制指令计数器IP，从而可以在内核层任意执行代码了。（这里暂时不考虑内核的缓解措施）

堆溢出：

堆溢出和栈类似，只不过溢出的对象为堆而已。比如将上述例子中的char tmp[100] 换成char *tmp = kmalloc(100); 那么就变成堆溢出漏洞了。

整型溢出：

整型溢出，就是在进行整数运算时没有考虑到整数本身的上下限。比如unsigned int的下限是0，上限是0xffffffff. 当a,b,c都是unsgined int 类型时， a = b + c，就有可能发生溢出，溢出的结果会导致a比b或者c都小。比如b = 0xffffffff, c = 2, 那么a = b + c = 0xffffffff + 2 = 1, 如果对整型溢出不了解，是不是觉得很神奇？两个数相加的和竟然变小了！

例子：

1 int driver_create_buffer(Command *userCommand)2 {3 ...4 uint32_t totalCount = 0;5 uint32_t *regAddrBuf = NULL;7 uint32_t kernelCount = 1000;8 const uint32_t userCount = userCommand->count;9 ...10totalCount = kernelCount + userCount;11regAddrBuf = kzalloc(totalCount * sizeof(uint32_t), GFP_KERNEL);12copy_from_user(regAddrBuf, userCommand->buffer, userCount*sizeof(uint32_t));13 ...14 }

上述代码的第10行，将正整数kernelCount与userCount相加，存储到totalCount中。而userCount是用户可以控制的，当将该值设为很大时，就会导致溢出，比如userCount= 0xffffffff - 1000 + 1时，那么totalCount的大小就为1。在11行，分配的空间时按照totalCount 进行分配的，在而在12行拷贝的内容长度为userCount，而userCount明显比totalCount大。因此会导致溢出漏洞。

释放后重用：

顾名思义，就是一个内核对象在释放后又使用该对象。这种的漏洞的利用技术已经很成熟了，这里先不介绍利用了：）

1. static int dealloc_session(void *core_handle,2.struct session *session)3. {4....5.deregister(session->handle);6.mutex_destroy(&session->lock);7.sessions[session->id] = NULL;8.kfree(session);9.session = NULL;10....11. }

初一看，没什么问题，将session的所有内容成员都释放以后，然后对session本身进行kfree以后，并且马上设置为NULL。但是这里没有考虑多线程的问题。比如一个线程在第8行，将session内核对象释放以后，此时另外一个线程正在第5行访问该对象。那么就造成了释放后重用漏洞。

双重释放：

双重释放，顾命思义，就是将一个对象释放两次。那么开发人员说了，释放两次就释放两次，那能利用吗？那么我要说了：可以利用！双重释放的漏洞是可以转化为释放后重用漏洞的。并且技术也很成熟。下面看一个例子：

1. static long deviceB_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)2 {3....4.if (__copy_from_user(idc, (void __user *)arg, tmp)) {5. kfree(idc);6. err = -EFAULT;7.} else {8. err = spi_message(spi, idc, n_ioc);9.}10. kfree(ioc);11. return 0;13. }

ioctl是内核开发人员很熟悉的，通过ioctl可以给设备驱动添加新的功能。用户层可以直接调用ioctl来使用设备的新功能。在上述例子中，第5行，将idc内核对象释放了，但是没有返回。在第10行又被释放了一次，造成了内核对象idc的双重释放。