Libheap是一个用于在Linux平台上分析glibc堆结构的GDB调试脚本，使用Python语言编写。

[[164643]]

安装

Glibc安装

尽管Libheap不要求glibc使用GDB调试支持和符号进行编译，但是如果用户使用的话，也不会影响它的功能。已经有很多手动构建Glibc的指导说明，目前最合适的一个：

Devpit – Building GLIBC

Fedora上使用了以下简单的方法实现了该方法：

debuginfo-install glibc

使用该命令，系统会自动安装并设置调试Glibc。

GDB安装

如果用户使用的是较新版本的Fedora，其中的GDB使用加入了最新的python支持的新技术。否则，用户就需要从SVN中构建GDB，而不是使用Tom Tromey提供的步骤：

$ sudo yum install python-devel git texinfo
$ mkdir -p ~/archer/build ~/archer/install
$ cd ~/archer
$ git clone git://sourceware.org/git/archer.git
$ cd archer
$ git checkout --track -b python origin/archer-tromey-python
$ cd ../build
$ ../archer/configure --prefix=$(cd ../install && pwd)
$ make all install

这一步完成后，用户就会得到一个可以在archer/install/bin/gdb上运行的编译版本GDB。

Libheap安装

最后一步是安装Libheap库，这一步相对简单，只需要将其移动到Python路径(sys.path)下：

$ mv libheap.py /usr/lib/python2.6

用法

加载libheap同加载其他Python库的方法类似：

$ gdb

(gdb) python from libheap import *

整体堆状态

多个不同的状态用于输出堆的整体状态，如下：

heap -h

(gdb) heap -h
==================== Heap Dump=========================
 
Options:
  -a 0x1234 指定arena地址
  -b        输出压缩的bin列表(只是空闲数据块)
  -c        输出压缩的arena列表(所有数据块)
  -f [#]    输出所有的fast bin，或独立的fast bin
  -l        输出arena 中所有数据块的flat列表
  -s [#]    输出所有的small bin，或独立的small bin

heap

(gdb) heap
==================== HeapDump=========================
 
Arena(s) found:
     arena @ 0xf2f3a0

heap -b

(gdb) heap -b
==================== Heap Dump=========================
 
  fast bin 0   @ 0x804b000
    free chunk @ 0x804b000- size 0x10
  unsorted bin @ 0xf2f3d8
    free_chunk @ 0x804b010- size 0x88

heap -f

(gdb) heap -b
==================== HeapDump=========================
 
  fast bin 0   @ 0x804b000
    free chunk @ 0x804b000- size 0x10
  unsorted bin @ 0xf2f3d8
    free_chunk @ 0x804b010- size 0x88

heap -f

(gdb) heap -f
==================== HeapDump=========================
 
[ fb  0 ] 0xf2f3a8 -> [0x0804b000 ] (16)
[ fb  1 ] 0xf2f3ac -> [0x00000000 ]
[ fb  2 ] 0xf2f3b0 -> [0x00000000 ]
[ fb  3 ] 0xf2f3b4 -> [0x00000000 ]
[ fb  4 ] 0xf2f3b8 -> [0x00000000 ]
[ fb  5 ] 0xf2f3bc -> [0x00000000 ]
[ fb  6 ] 0xf2f3c0 -> [0x00000000 ]
[ fb  7 ] 0xf2f3c4 -> [0x00000000 ]
[ fb  8 ] 0xf2f3c8 -> [0x00000000 ]
[ fb  9 ] 0xf2f3cc -> [0x00000000 ]

heap -s

(gdb) heap -s 1
==================== HeapDump=========================
 
[ sb 01 ] 0xf2f3d8 -> [ 0x0804b010 | 0x0804b010 ]
                      [0x00f2f3d0 | 0x00f2f3d0 ]  (136)

heap -l

(gdb) heap -l
==================== Heap Dump=========================
 
          ADDR             SIZE         STATUS
sbrk_base 0x602c00
chunk     0x602c00         0x110        (inuse)
chunk     0x602d10         0x110        (F) FD 75dea366deb8 BK 602f30
chunk     0x602e20         0x110        (inuse)
chunk     0x602f30         0x110        (F) FD 602d10 BK 75dea366deb8
chunk     0x603040         0x110        (inuse)
chunk     0x603150         0x20eb0      (top)
sbrk_end  0x624008

heap -c

(gdb) heap -c
==================== Heap Dump=========================
|A||11||A||11||A||T|

数据块

libheap为用户提供了多种方法用于检查内存分配数据块。该库使用一个比较完善的malloc_chunk结构体输出程序，因此只要是有效的数据库，就可以输出其地址：

(gdb) p *(mchunkptr) 0x608790
struct malloc_chunk {
prev_size   = 0x0
size        = 0x21a81
fd          = 0x0
bk          = 0x0
fd_nextsize = 0x0
bk_nextsize = 0x0

为了获取数据库的更加细粒度的访问权限，libheap使用了一个代表内存分配数据块的python类：

(gdb) python print malloc_chunk(0x608790)
struct malloc_chunk {
prev_size   = 0x0
size        = 0x21a81
fd          = 0x0
bk          = 0x0
fd_nextsize = 0x0
bk_nextsize = 0x0

默认情况下，程序会将一个地址看作已释放的数据库，并读取malloc_chunk结构体的所有字段。但是如果用户传递一个名为‘inuse’的可选布尔项就可以改变这种情况。如果用户只是想要读取已分配数据块的头部，那么可以传入一个名为‘read_data’的可选布尔项。该类默认读取数据块中指定的任意大小的内存，这样显示是有弊端的：攻击者可以使用虚假的值覆盖size字段。因此程序设置了一个可选的size标志，用户可以指定真实的数据块大小。综上所述，用户可以访问和更改数据块中独立的字段：

(gdb) python chunk = malloc_chunk(0x608790, inuse=True,read_data=False)
(gdb) python print chunk
struct malloc_chunk {
prev_size   = 0x0
size        = 0x21a81
 
(gdb) python chunk.size = 1
(gdb) python chunk.write()
(gdb) python print chunk
struct malloc_chunk {
prev_size   = 0x0
size        = 0x1
 
(gdb) python print malloc_chunk(0x608790, inuse=True, size=8)
struct malloc_chunk {
prev_size   = 0x0
size        = 0x1
data        = (0,)
raw         ="\x00\x00\x00\x00"

最后，如果用户想要查看内存分配数据块在堆实现中的表现形式，可以向该类传递一个行内存字符串，并查看解析情况：

(gdb) python printmalloc_chunk(mem='\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00',inuse=True)
struct malloc_chunk {
prev_size   = 0x1
size        = 0x2

Glibc结构体

libheap中还包含malloc_par和malloc_state结构体的输出程序。用户可以通过请求输出全局变量查看：

(gdb) p mp_
$1 = struct malloc_par {
 
(gdb) p main_arena
$2 = struct malloc_state {

以下为这两个重要结构体的Python类实现，用户可以使用这些类查看任意内存：

(gdb) python print malloc_state(0x6503d0b37e60)
struct malloc_state {
mutex          = 0x0
flags          = 0x1
fastbinsY      = {...}
top            = 0x608790
last_remainder = 0x0
bins           = {...}
binmap         = {...}
next           =0x6503d0b37e60
system_mem     = 0x21890
max_system_mem = 0x21890
 
(gdb) python print malloc_par(0x6cb800)
struct malloc_par {
trim_threshold   = 0x9e000
top_pad          = 0x20000
mmap_threshold   = 0x4f000
n_mmaps          = 0x0
n_mmaps_max      = 0x10000
max_n_mmaps      = 0x1
no_dyn_threshold = 0x0
mmapped_mem      = 0x0
max_mmapped_mem  = 0x4f000
max_total_mem    = 0x0
sbrk_base        =0x809c000

便捷函数

如果用户想要扩展该库或使用其中的任意功能，以下为在Python中重新实现的Glibc函数列表：

chunk2mem(p)
mem2chunk(mem)
request2size(req)
prev_inuse(p)
chunk_is_mmapped(p)
chunk_non_main_arena(p)
chunksize(p)
next_chunk(p)
prev_chunk(p)
chunk_at_offset(p, s)
inuse(p)
set_inuse(p)
clear_inuse(p)
inuse_bit_at_offset(p, s)
set_inuse_bit_at_offset(p, s)
clear_inuse_bit_at_offset(p, s)
bin_at(m, i)
next_bin(b)
first(b)
last(b)
in_smallbin_range(sz)
smallbin_index(sz)
largebin_index_32(sz)
largebin_index_64(sz)
largebin_index(sz)
bin_index(sz)
fastbin(ar_ptr, idx)
fastbin_index(sz)
have_fastchunks(M)
clear_fastchunks(M)
set_fastchunks(M)
contiguous(M)
noncontiguous(M)
set_noncontiguous(M)
set_contiguous(M)
mutex_lock(ar_ptr [, inferior])
mutex_unlock(ar_ptr [, inferior])
top(ar_ptr)
heap_for_ptr(ptr)