0385-CVE-2015-7547简单分析与调试

# CVE-2015-7547简单分析与调试

0x00 漏洞信息
=========

* * *

最近glibc有一个栈溢出的漏洞具体情况，漏洞的具体信息可以参考下面链接。

[CVE-2015-7547: glibc getaddrinfo stack-based buffer overflow](https://googleonlinesecurity.blogspot.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html)

poc在github上：https://github.com/fjserna/CVE-2015-7547

0x01 环境准备
=========

* * *

“`
操作系统：ubuntu15.04
glibc版本：glibc-2.2.0

“`

1.1 glibc源码编译
————-

在ubuntu系统下，只需要执行源码和调试符的命令之后就可以使用gdb对glibc的跟踪调试，安装指令如下：

“`
sudo apt-get install libc6-dbg
sudo apt-get source libc6-dev

“`

但是因为系统自带的glibc是**发行版**的，所以在编译的是时候选用了优化参数`-O2`,所以在调试的过程中会出现**变量被优化无法读取**以及代码运行的时候与**源码的行数**对不上的情况。

**所以需要自己编译一个可调式并且没有过度优化的glibc来进行调试。**

首先，从glibc的官网下载glibc的源码。我选择了2.20的版本。编译安装glibc的方法很容易可以在网上找到。需要注意的是在进行configure时需要设置一些特殊的参数。如果需要调试宏可以添加 -gdwarf-2,glibc无法使用-O0编译，不过-O1也够用了。

“`
/opt/glibc220/configure –prefix=/usr/local/glibc220/ –enable-debug CFLAGS=”-g -O1″ CPPFLAGS = “-g -O1”

“`

在`configure`执行完成之后只需要简单执行编译与安装就好了。

“`
sudo make
sudo make install

“`

1.2 使用调试版本glibc编译POC
——————–

在glibc编译安装成功后，系统默认的glibc还是原来的那个。所以需要选择指定的glibc来编译POC代码。

“`
gcc -o client CVE-2015-7547-client.c -Wl,-rpath /usr/local/glibc220

“`

通过ldd指令可以看到，确实使用了刚编的glibc。

这个时候就可以用GDB调试glibc中的函数了。

1.3 配置本地dns服务器
————–

运行poc的python服务器。修改`/etc/resolv.conf`。将域名服务器改为127.0.0.1就好了。不过这样一来这台机器访问网络就会出问题了。

“`
nameserver 127.0.0.1

“`

0x02 漏洞分析
=========

* * *

2.1 运行POC
———

使用gdb启动客户端直接运行，出现崩溃堆栈。


2.2 寻找溢出函数
———-

可以看到栈都被覆盖为0x42424242,根据[google提供的分析](https://googleonlinesecurity.blogspot.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html),出问题的是send_dg和send_vc函数。分别在send_vc和send_dg上下断点，重新运行程序，会发现先调用send_dg函数再调用send_vc函数。


可以看出是在send_vc的时候发生了栈溢出。

因为根据[google提供的分析](https://googleonlinesecurity.blogspot.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html)可以知道是在读取socket的时候发生的溢出，可以通过结合源码调试来分析。剔除不需要看的代码，核心代码如下，总共干了四件事。

“`
[1]选择适当的缓存
[2]读取dns包的长度
[3]读取dsn包
[4]判断是否需要读取第二个数据包。

“`

“`
static int
send_vc(res_state statp,
const u_char *buf, int buflen, const u_char *buf2, int buflen2,
u_char **ansp, int *anssizp,
int *terrno, int ns, u_char **anscp, u_char **ansp2, int *anssizp2,
int *resplen2, int *ansp2_malloced)
{
const HEADER *hp = (HEADER *) buf;
const HEADER *hp2 = (HEADER *) buf2;
u_char *ans = *ansp;
int orig_anssizp = *anssizp;

[…] //这段干的事情可以无视。

read_len:
//—————-[2]————-start—————-
cp = (u_char *)&rlen16;
len = sizeof(rlen16);
while ((n = TEMP_FAILURE_RETRY (read(statp->_vcsock, cp,
(int)len))) > 0) {
cp += n;
if ((len -= n) <= 0) break; } if (n <= 0) { [...] //出错处理无视。 } int rlen = ntohs (rlen16); //----------------[2]-------------end---------------- //----------------[1]-------------start---------------- int *thisanssizp; u_char **thisansp; int *thisresplenp; if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) { //第一次从read_len开始读取网络包进入这个分支。 thisanssizp = anssizp; //第一次调用read时可用内存65536 thisansp = anscp ?: ansp; //第一次调用read时使用的缓存anscp assert (anscp != NULL || ansp2 == NULL); thisresplenp = &resplen; } else { if (*anssizp != MAXPACKET) { [...] //重现流程中不会进入这块。 } else { /* The first reply did not fit into the user-provided buffer. Maybe the second answer will. */ *anssizp2 = orig_anssizp; //第二次调用时可用内存长度65536 *ansp2 = *ansp; //第二次调用read时使用的缓存ansp } thisanssizp = anssizp2; thisansp = ansp2; thisresplenp = resplen2; } //----------------[1]-------------end---------------- anhp = (HEADER *) *thisansp; *thisresplenp = rlen; if (rlen > *thisanssizp) {
[…] //重现流程中不会进入这块。
} else
len = rlen;

if (__glibc_unlikely (len < HFIXEDSZ)) { [...] //重现流程中不会进入这块。 } cp = *thisansp; //*ansp; //---------------[2]--------------------start----------------- while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){ //溢出点。
cp += n;
len -= n;
}
//—————[2]——————–start—————–

if (__glibc_unlikely (n <= 0)) { [...] //重现流程中不会进入这块。 } if (__glibc_unlikely (truncating)) { [...] //重现流程中不会进入这块。 } /* * If the calling application has bailed out of * a previous call and failed to arrange to have * the circuit closed or the server has got * itself confused, then drop the packet and * wait for the correct one. */ //---------------[4]--------------------start----------------- if ((recvresp1 || hp->id != anhp->id) //不进。
&& (recvresp2 || hp2->id != anhp->id)) {
[…] //重现流程中不会进入这块。
goto read_len;
}

/* Mark which reply we received. */
if (recvresp1 == 0 && hp->id == anhp->id) //第一次运行recvresp1=1 recvresp2=0
recvresp1 = 1;
else
recvresp2 = 1;
/* Repeat waiting if we have a second answer to arrive. */
if ((recvresp1 & recvresp2) == 0) // 调用goto，回到前面。
goto read_len;
//—————[4]——————–end—————–
/*
* All is well, or the error is fatal. Signal that the
* next nameserver ought not be tried.
*/
return resplen;
}

“`

根据源码分析，从socket读取网络包数据的时候是溢出的地方，所以在这里下断点。

“`
gdb> b res_send.c:853

“`


通过调用栈可以得知，read发生了两次[4]，而且第一次是正确的，在第二次read之后发生了溢出。通过[1]可以得知，在两次调用read的时候cp指向的内存不同。

第一次调用`read`函数时，缓冲区为**anscp**指向的内存。

第二次调用`read`函数时，缓冲区为**ansp**指向的内存。**这里暂时不用考虑二级指针的问题。**

可以断定，ansp指针索引的地址出现了问题。ansp是调用时从参数传入的。所以需要通过分析send_vc的调用函数。

2.3 内存分配错误
———-

send_vc的调用函数如下：

“`
int
__libc_res_nsend(res_state statp, const u_char *buf, int buflen,
const u_char *buf2, int buflen2,
u_char *ans, int anssiz, u_char **ansp, u_char **ansp2,
int *nansp2, int *resplen2, int *ansp2_malloced)
{
[…]
if (__glibc_unlikely (v_circuit)) {
/* Use VC; at most one attempt per server. */
try = statp->retry;
n = send_vc(statp, buf, buflen, buf2, buflen2, //statp状态，buff，bufflen第一组发送数据，buff，2bufflen2第二组发送数据。
&ans, &anssiz, &terrno, //u_char **ansp, int *anssizp,int *terrno,
ns, ansp, ansp2, nansp2, resplen2, //int ns, u_char **anscp, u_char **ansp2, int *anssizp2,int *resplen2,
ansp2_malloced); //int *ansp2_malloced
if (n < 0) return (-1); if (n == 0 && (buf2 == NULL || *resplen2 == 0)) goto next_ns; } else { /* Use datagrams. */ //经过send_dg函数调用，ansp指向65536buff，ans指向2048buff。 n = send_dg(statp, buf, buflen, buf2, buflen2, &ans, &anssiz, &terrno, ns, &v_circuit, &gotsomewhere, ansp, ansp2, nansp2, resplen2, ansp2_malloced); if (n < 0) return (-1); if (n == 0 && (buf2 == NULL || *resplen2 == 0)) goto next_ns; if (v_circuit) // XXX Check whether both requests failed or Z // XXX whether one has been answered successfully goto same_ns; } [...] } ``` 因为在调用`send_vc`之前程序先调用了`send_dg`，且两个函数参数基本相同，通过阅读源码会发现，`send_dg`对参数进行修改及新内存的申请。 ``` static int send_dg(res_state statp, const u_char *buf, int buflen, const u_char *buf2, int buflen2, u_char **ansp, int *anssizp, int *terrno, int ns, int *v_circuit, int *gotsomewhere, u_char **anscp, u_char **ansp2, int *anssizp2, int *resplen2, int *ansp2_malloced) { //ans指向大小为2048的缓冲器 //ansp指向ans //anscp指向ans const HEADER *hp = (HEADER *) buf; const HEADER *hp2 = (HEADER *) buf2; u_char *ans = *ansp; int orig_anssizp = *anssizp; struct timespec now, timeout, finish; struct pollfd pfd[1]; int ptimeout; struct sockaddr_in6 from; int resplen = 0; int n; [...] else if (pfd[0].revents & POLLIN) { int *thisanssizp; u_char **thisansp; int *thisresplenp; if ((recvresp1 | recvresp2) == 0 || buf2 == NULL) { //send_dg第一次进入这个分支。 thisanssizp = anssizp; thisansp = anscp ?: ansp; //thisansp被赋值为anscp assert (anscp != NULL || ansp2 == NULL); thisresplenp = &resplen; } else { [...] //第一次调用不会进入。 } if (*thisanssizp < MAXPACKET /* Yes, we test ANSCP here. If we have two buffers both will be allocatable. */ && anscp #ifdef FIONREAD && (ioctl (pfd[0].fd, FIONREAD, thisresplenp) < 0 || *thisanssizp < *thisresplenp) #endif ) { u_char *newp = malloc (MAXPACKET); if (newp != NULL) { *anssizp = MAXPACKET; //anssizp谁为65536 *thisansp = ans = newp; //anscp指向65536的buffer,但是ansp指向仍然指向原来的2048的buffer if (thisansp == ansp2) *ansp2_malloced = 1; } } ```  通过调试可以看出，ansp仍然指向大小为2048的缓冲区，而anscp指向了大小为65536的缓冲区。之后这两个指针又被传递给了send_vc。 2.4 溢出原因 -------- 所以溢出的原因是，`*anssizp`因为在之前的`send_dg`中被赋值为65536，`send_vc`中第二次调用`read`函数时，认为ansp指向的缓冲区的大小为`*anssizp`即65536，而实际上ansp指向了一块只有2048大小的缓冲区。所以在从socket读取大于2048个字节之后产生了栈溢出。  0x03 参考&感谢 ========== * * * 感谢分享：） 1. CVE-2015-7547 --- glibc getaddrinfo() stack-based buffer overflow https://sourceware.org/ml/libc-alpha/2016-02/msg00416.html 2. Linux glibc再曝漏洞：可导致Linux软件劫持 http://www.freebuf.com/news/96244.html 3. CVE-2015-7547: glibc getaddrinfo stack-based buffer overflow https://googleonlinesecurity.blogspot.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html 4. glibc编译debug版本 http://blog.csdn.net/jichl/article/details/7951996 5. glibc的编译和调试  http://blog.chinaunix.net/uid-20786208-id-4980168.html