最近glibc有一个栈溢出的漏洞具体情况,漏洞的具体信息可以参考下面链接。
CVE-2015-7547: glibc getaddrinfo stack-based buffer overflow
poc在github上:https://github.com/fjserna/CVE-2015-7547
操作系统:ubuntu15.04 glibc版本:glibc-2.2.0
在ubuntu系统下,只需要执行源码和调试符的命令之后就可以使用gdb对glibc的跟踪调试,安装指令如下:
sudo apt-get install libc6-dbg sudo apt-get source libc6-dev
但是因为系统自带的glibc是 发行版 的,所以在编译的是时候选用了优化参数 -O2
,所以在调试的过程中会出现 变量被优化无法读取 以及代码运行的时候与 源码的行数 对不上的情况。
首先,从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
在glibc编译安装成功后,系统默认的glibc还是原来的那个。所以需要选择指定的glibc来编译POC代码。
gcc -o client CVE-2015-7547-client.c -Wl,-rpath /usr/local/glibc220
通过ldd指令可以看到,确实使用了刚编的glibc。
这个时候就可以用GDB调试glibc中的函数了。
运行poc的python服务器。修改 /etc/resolv.conf
。将域名服务器改为127.0.0.1就好了。不过这样一来这台机器访问网络就会出问题了。
nameserver 127.0.0.1
使用gdb启动客户端直接运行,出现崩溃堆栈。
可以看到栈都被覆盖为0x42424242,根据 google提供的分析 ,出问题的是send_dg和send_vc函数。分别在send_vc和send_dg上下断点,重新运行程序,会发现先调用send_dg函数再调用send_vc函数。
可以看出是在send_vc的时候发生了栈溢出。
因为根据 google提供的分析 可以知道是在读取socket的时候发生的溢出,可以通过结合源码调试来分析。剔除不需要看的代码,核心代码如下,总共干了四件事。
[1]选择适当的缓存 [2]读取dns包的长度 [3]读取dsn包 [4]判断是否需要读取第二个数据包。
#!c 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的调用函数。
send_vc的调用函数如下:
#!c 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
对参数进行修改及新内存的申请。
#!c 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。
所以溢出的原因是, *anssizp
因为在之前的 send_dg
中被赋值为65536, send_vc
中第二次调用 read
函数时,认为ansp指向的缓冲区的大小为 *anssizp
即65536,而实际上ansp指向了一块只有2048大小的缓冲区。所以在从socket读取大于2048个字节之后产生了栈溢出。
感谢分享:)
CVE-2015-7547 --- glibc getaddrinfo() stack-based buffer overflow
https://sourceware.org/ml/libc-alpha/2016-02/msg00416.html
Linux glibc再曝漏洞:可导致Linux软件劫持
http://www.freebuf.com/news/96244.html
CVE-2015-7547: glibc getaddrinfo stack-based buffer overflow
https://googleonlinesecurity.blogspot.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html
glibc编译debug版本
http://blog.csdn.net/jichl/article/details/7951996
glibc的编译和调试
http://blog.chinaunix.net/uid-20786208-id-4980168.html