🌼 什么是二進制漏洞
二進制漏洞是可執行檔案（PE、ELF檔案等）因編碼時考慮不周，造成的軟體執行了非預期的功能，由于二進制漏洞大都涉及到系統層面，所以危害程度比較高，比如經典的office堆疊溢位漏洞（CVE-2012-0158）、（CVE-2017-11882）以及（CVE-2017-11882）的補丁繞過漏洞（CVE-2018-0802）等，都是危險程度極高的0day和1day漏洞，所以，二進制漏洞的挖掘和分析就顯得尤為重要，本篇文章將對常見的二進制漏洞進行簡要的介紹和分析，
🌴 常見的二進制漏洞介紹
-
堆疊溢位漏洞（Stack-Overflow）
-
堆溢位漏洞（Heap-Overflow）
-
釋放后重參考漏洞（Use-After-Free）
-
雙重釋放漏洞（Double-Free）
-
越界訪問漏洞（Out-of-bounds）
🌀二進制漏洞挖掘常用工具
- GDB: Linux除錯中必要用到的
- gdb-peda、pwndbg、gef: GDB除錯插件
- pwntools：寫exp和poc的利器
- libc-databases：可以通過泄露的libc的某個函式地址查出遠程系統是用的哪個libc版本
- checksec：可以很方便的知道elf程式的安全性和程式的運行平臺
- objdump ：可以很快的知道elf程式中的關鍵資訊
- readelf：可以很快的知道elf程式中的關鍵資訊
- ida pro：反匯編工具
- ROPgadget：強大的rop利用工具
- one_gadget：可以快速的尋找libc中的呼叫exec(‘bin/sh’)的位置
🐥 為什么學習二進制安全?
首先提出一個問題，不知道大家有沒有碰到過在寫代碼中遇到過以下這樣的問題：
- 明明看起來代碼寫的毫無問題，但是卻在main函式之前就已經報錯，
- 碰到一款好的軟體，但是廣告太煩無法關閉，
- 你想知道一款軟體的功能是如何實作的，卻苦于沒有源代碼，
- 軟體出現崩潰，想要找到原因卻無從下手，
- 電腦中了病毒，殺毒軟體卻無法查殺，
- 剛剛發布的產品，馬上就被人破解了，上面只是提出一部分常見的問題，在學習二進制安全后你可以這樣解決以上的問題，
🌵 學習后可以做些什么？
(1). 因為二進制安全需要深入理解計算機的運行機制，作業系統原理，所以碰到此類問題，你可以很快定位到錯誤位置，為你的編碼作業提供強有力的支撐，
(2). 碰到這類軟體的時候，你可以通過逆向工程的方式，將其中的廣告頁面替換，甚至直接將彈出廣告的函式直接ret或用nop填充掉，還給自己一個清靜沒有廣告的辦公環境，
(3). 當你想知道這個功能如何實作的時候，你既可以靜態分析其函式的實作邏輯，也可以動態跟蹤它的資料流向，從而完整了解該功能是如何實作的，
(4). 當軟體崩潰是不是無從下手，但是學了二進制安全之后你可以使用除錯器接管例外，去發掘漏洞產生的位置，定位到模塊或者函式的某一條陳述句，然后提供給廠商修復或者自己二次開發使用補丁修復漏洞，
(5). 當中了殺軟無法識別的病毒是不是很恐慌，學習了二進制安全后就可以直接手動分析病毒做了些什么，并且將其執行的操作逆轉，拯救中毒的計算機作業系統，
(6). 剛剛發布的軟體馬上就被別人破解了，沒有收入了，是不是很郁悶，當學習了二進制安全后，你可以對你的軟體加混淆、加花指令、加反除錯、加代碼虛擬化等等手段，讓破解者的破解成本增加到無法承受，從而放棄破解，
🐼 如何學習二進制安全
上面我們已經討論過了為什么要學，學了可以做什么，那么接下來我們要討論的就是如何學習，當初學者興致勃勃的準備開始學習的時候會發現，雖然書籍眾多，卻無從下手，一個不小心還會誤入歧途，成為一個只懂得是什么，卻不懂得為什么的庸人，接下來我們要做的就是，縷清這條線，讓其清晰明了，
首先，我們作為二進制研發人員必須要懂的語言有三門半，為什么說是三門半呢，因為這四門語言是C、C++、Python以及匯編，C和C++屬于一脈相承因此只算一門半語言，因為這兩門語言的學習是連續的，不需要像學習Python或匯編一樣重新學習語法結構，那么接下來我來說明一下為什么要學習這三門半語言，首先是C和C++，先不說開發殺毒引擎或者其他大型工程，僅僅有一點最為實際，那就是IDA pro所翻譯出的偽代碼是C語言格式的，另外在以后漏洞的學習中，除了匯編語言，C和C++是開發shellcode最為高效的語言，而且相比于匯編也更容易理解，并且也許我們想招寫一些具有特殊功能的小玩意，比如遠（病）控（毒）軟（木）件（馬），C和C++也一定是你最優秀的選擇，或者我們需要寫一些驅動代碼，比如實作一個類似于火絨劍的監控軟體，畢竟，你總不能去用易語言開發吧，現在的系統也不兼容啊對不對，
那么介紹完C和C++的用處，接下來說明下Python的作用，其實Python就像是一個萬能膠水，哪里有用粘哪里，它可以輔助我們快捷的開發一些輔助分析工具或者Exploit，也可以充當解放雙手釋放勞動力解決重復操作的機器人，總之，Python除了性能感人，其他都不會讓你失望的，最后說明一下匯編語言的作用，其實這是最不用解釋的了，畢竟，動態分析中沒有任何一款工具可以把代碼還原成偽代碼執行，我們分析程序中所接觸的全都是匯編代碼，
上面扯了一大段為什么要學習這些語言，那么下面來說明下如何學習這些語言，其實很簡單，就是看書，當然如果覺得乏味，靠譜的教學視頻也是可以的，
C語言有很多本書可以選擇，但是我只推薦一本，避免選擇困難，這本書叫做《C Primer Plus》,這本書的作者叫Stephen Prata，目前這本書已經翻譯成中文版了，可以直接在網上購買，這本書詳盡的說明了C語言語法你所需要了解的一切，推薦花30天時間簡單學習，然后就開始學習C++，C++的學習我推薦使用《C++ Primer》作為教材，推薦學習時間依然是30天，
你以為我會讓你接下來直接開始學Python？你太天真了，
C和C++在簡單看完這兩本書的情況，你只是知道，卻不會使用，這時候你最需要的就是練習了，如果以前數學學的還不錯，那就搞本《演算法導論》，練習里面的演算法與資料結構，如果基礎差一點，就買一本國內出版的零基礎學演算法一類的書練習里面的例子，這個階段我的推薦學習時長為60天，對，你沒看錯，和學習語法的時間一樣長，
當你練習了這么久之后，就可以繼續學習語言了，沒錯，終于到Python了，買本《Python核心編程》吧，你已經有了不錯的基礎，相信我，一周之內看完這本書你沒問題的，不需要你記住所有庫的 使用，Python的庫實在太多了，你只需要記住大概有個什么庫可以解決相關問題，需要的時候再去網上查就好了，
最后是我們的匯編語言，最艱苦的日子到了，這是個很難學的東西，我學習的時候也感覺頭冷，但是很不幸，這是一門必要的語言，
匯編語言我推薦使用《匯編語言 基于x86處理器》這本書來學習，也許很多人都是學習的王爽老師的那本《匯編語言》入門的，我是我還是想推薦這本，因為這本書是我見過最容易理解的匯編語言教材，至此，語言階段結束， 當我們學習完語言基礎之后，我們需要學習的就是系統編程了，這個階段我們只需要看兩本書，但是別高興的太早，因為這兩本書都是大部頭，好在我們不是專業開發人員，所以不需要看的那么細致，
第一本《Windows程式設計》,這一本主要講解的是GUI編程，我們也就是寫寫安全工具，所以簡單看看就行，但是一些以后可能會發現一些奇淫技巧，比如界面藏私鑰這種操作，遇到了在了解就行，第二本是《Windows核心編程》，這本書主要講的是Win32 API編程，需要好好了解一下，因為Windows下的惡意代碼一類的，萬變不離其宗，最后還是要走API這條路，
這個階段的推薦學習時間是90天，學習完系統編程，我們要學習的是Windows下的檔案結構，也就是PE（Portable Executable）結構，這個結構對于我們分析病毒還是漏洞都有著至關重要的作用，因此需要詳細了解，講解這個結構的書非常多，
我推薦使用《Windows PE權威指南》，這樣既學習了PE結構，又復習了匯編語言，推薦時長30天，學習了這么多基礎，鋪墊了這么久，我們終于要開始學逆向了，軟體逆向我依然只推薦一本書《c++反匯編與逆向分析技術揭秘》,軟體逆向看這一本書就夠了，但是看完之后建議看一些綜合類的實戰書籍，比如《加密與解密4》，然后我們還需要對Windows的除錯原理有些了解，這里使用《Windows高級除錯》以及《軟體除錯》來學習，
推薦學習時長90天
，
最后我們要選擇的就是細分領域了，當然，也可以全學，
惡意代碼分析我推薦《惡意代碼分析實戰》，
漏洞分析我推薦《0day安全:軟體漏洞分析技術》入門，
《漏洞戰爭》進階，《shellcoder編程揭秘》來了解漏洞利用中的奇淫技巧，很不幸的是，我還沒有發現一本值得推薦漏洞挖掘的書籍，此階段建議學習時長90天，
至此，我們的安全學習就已經踏上了正軌，需要在作業中不斷精進，不斷成長，
0x01堆疊溢位漏洞原理
堆疊溢位漏洞屬于緩沖區漏洞的一種，實體如下：
#include <stdio.h>
#include <string.h>
int main()
{
char *str = "AAAAAAAAAAAAAAAAAAAAAAAA";
vulnfun(str);
return;
}
int vulnfun(char *str)
{
char stack[10];
strcpy(stack,str); // 這里造成溢位！
}編譯后使用windbg運行
直接運行到了地址0x41414141，這個就是字串AAAA，就是變數str里面的字串通過strcpy拷貝到堆疊空間時，沒有對字串長度做限制，導致了堆疊溢位，最后覆寫到了回傳地址，造成程式崩潰，
溢位后的堆疊空間布局如下：
堆疊溢位原理圖
0x02 堆溢位漏洞原理
使用以下代碼演示堆溢位漏洞
#include <windows.h>
#include <stdio.h>
int main ( )
{
HANDLE hHeap;
char *heap;
char str[] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
hHeap = HeapCreate(HEAP_GENERATE_EXCEPTIONS, 0x1000, 0xffff);
getchar(); // 用于暫停程式，便于除錯器加載
heap = HeapAlloc(hHeap, 0, 0x10);
printf("heap addr:0x%08x\n",heap);
strcpy(heap,str); // 導致堆溢位
HeapFree(hHeap, 0, heap); // 觸發崩潰
HeapDestroy(hHeap);
return 0;
}由于除錯堆和常態堆的結構不同，在演示代碼中加入getchar函式，用于暫停行程，方便運行heapoverflowexe后用除錯器附加行程，debug版本和Release版本實際運行的行程中各個記憶體結構和分配程序也不同，因此測驗的時候應該編譯成release版本，
運行程式，使用windbg附加除錯（一定要附加除錯），g運行后程式崩潰
上面的ecx已經被AAAA字串覆寫掉了，最后在參考該地址的時候導致崩潰，通過前面的堆疊回溯定位到了main函式入口，找到復制字串的函式下斷點
此時堆塊已經分配完畢，對應的分配地址位于0x007104a0，0x007104a0是堆塊資料的起始地址，并非堆頭資訊的起始地址，對于已經分配的堆塊，開頭有8位元組的HEAP_ENTRY結構，因此heap的HEAP_ENTRY結構位于0x007104a0-8=0x710498，
在windbg上查看兩個堆塊的資訊，這兩個堆塊目前處于占用狀態，共有0x10大小空間
0:000> !heap -p -a 0x710498
address 00710498 found in
_HEAP @ 710000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
00710498 0005 0000 [00] 007104a0 00010 - (busy)在windbg中，使用！heap查看HeapCreate創建的整個堆塊資訊，可以發現堆塊heap后面還有一個空閑堆塊0x007104c0：
0:000> !heap
Heap Address NT/Segment Heap
560000 NT Heap
800000 NT Heap
710000 NT Heap
0:000> !heap -a 710000
HEAPEXT: Unable to get address of ntdll!RtlpHeapInvalidBadAddress.
Index Address Name Debugging options enabled
3: 00710000
Segment at 00710000 to 00720000 (00001000 bytes committed)
Flags: 40001064
ForceFlags: 40000064
Granularity: 8 bytes
Segment Reserve: 00100000
Segment Commit: 00002000
DeCommit Block Thres: 00000200
DeCommit Total Thres: 00002000
Total Free Size: 00000164
Max. Allocation Size: 7ffdefff
Lock Variable at: 00710248
Next TagIndex: 0000
Maximum TagIndex: 0000
Tag Entries: 00000000
PsuedoTag Entries: 00000000
Virtual Alloc List: 0071009c
Uncommitted ranges: 0071008c
00711000: 0000f000 (61440 bytes)
FreeList[ 00 ] at 007100c0: 007104c8 . 007104c8
007104c0: 00028 . 00b20 [104] - free
Segment00 at 00710000:
Flags: 00000000
Base: 00710000
First Entry: 00710498
Last Entry: 00720000
Total Pages: 00000010
Total UnCommit: 0000000f
Largest UnCommit:00000000
UnCommitted Ranges: (1)
Heap entries for Segment00 in Heap 00710000
address: psize . size flags state (requested size)
00710000: 00000 . 00498 [101] - busy (497)
00710498: 00498 . 00028 [107] - busy (10), tail fill //heap的占用堆塊
007104c0: 00028 . 00b20 [104] free fill //空閑堆塊
00710fe0: 00b20 . 00020 [111] - busy (1d)
00711000: 0000f000 - uncommitted bytes.在復制字串的時候，原本只有0x10大小的堆塊，填充過多的字串的時候就會覆寫到下方的空閑堆塊007104c0，在復制前007104c0空閑堆塊的HEAP_FREE_ENTRY結構資料如下：
0:000> dt _HEAP_FREE_ENTRY 0x007104c0
ntdll!_HEAP_FREE_ENTRY
+0x000 HeapEntry : _HEAP_ENTRY
+0x000 UnpackedEntry : _HEAP_UNPACKED_ENTRY
+0x000 Size : 0x6298
+0x002 Flags : 0x16 ''
+0x003 SmallTagIndex : 0xac ''
+0x000 SubSegmentCode : 0xac166298
+0x004 PreviousSize : 0xcfb9
+0x006 SegmentOffset : 0 ''
+0x006 LFHFlags : 0 ''
+0x007 UnusedBytes : 0 ''
+0x000 ExtendedEntry : _HEAP_EXTENDED_ENTRY
+0x000 FunctionIndex : 0x6298
+0x002 ContextValue : 0xac16
+0x000 InterceptorValue : 0xac166298
+0x004 UnusedBytesLength : 0xcfb9
+0x006 EntryOffset : 0 ''
+0x007 ExtendedBlockSignature : 0 ''
+0x000 Code1 : 0xac166298
+0x004 Code2 : 0xcfb9
+0x006 Code3 : 0 ''
+0x007 Code4 : 0 ''
+0x004 Code234 : 0xcfb9
+0x000 AgregateCode : 0x0000cfb9`ac166298
+0x008 FreeList : _LIST_ENTRY [ 0x7100c0 - 0x7100c0 ]0:000> dt _LIST_ENTRY 0x007104c0+8
ntdll!_LIST_ENTRY
[ 0x7100c0 - 0x7100c0 ]
+0x000 Flink : 0x007100c0 _LIST_ENTRY [ 0x7104c8 - 0x7104c8 ]
+0x004 Blink : 0x007100c0 _LIST_ENTRY [ 0x7104c8 - 0x7104c8 ]覆寫后0x007104c0空閑塊的HEAP_FREE_ENTRY結構資料如下：
0:000> g
(2c08.234): Access violation - code c0000005 (!!! second chance !!!)
eax=007e04a0 ebx=007e0498 ecx=41414141 edx=007e0260 esi=007e04b8 edi=007e0000
eip=7775919d esp=0019fdb0 ebp=0019fea8 iopl=0 nv up ei ng nz na po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010283
ntdll!RtlpFreeHeap+0x5bd:
7775919d 8b11 mov edx,dword ptr [ecx] ds:002b:41414141=????????
0:000> dt _HEAP_FREE_ENTRY 0x007104c0
ntdll!_HEAP_FREE_ENTRY
+0x000 HeapEntry : _HEAP_ENTRY
+0x000 UnpackedEntry : _HEAP_UNPACKED_ENTRY
+0x000 Size : ??
+0x002 Flags : ??
+0x003 SmallTagIndex : ??
+0x000 SubSegmentCode : ??
+0x004 PreviousSize : ??
+0x006 SegmentOffset : ??
+0x006 LFHFlags : ??
+0x007 UnusedBytes : ??
+0x000 ExtendedEntry : _HEAP_EXTENDED_ENTRY
+0x000 FunctionIndex : ??
+0x002 ContextValue : ??
+0x000 InterceptorValue : ??
+0x004 UnusedBytesLength : ??
+0x006 EntryOffset : ??
+0x007 ExtendedBlockSignature : ??
+0x000 Code1 : ??
+0x004 Code2 : ??
+0x006 Code3 : ??
+0x007 Code4 : ??
+0x004 Code234 : ??
+0x000 AgregateCode : ??
+0x008 FreeList : _LIST_ENTRY
Memory read error 007104c0整個空閑堆頭資訊都被覆寫了，包括最后的空閑鏈表中的前后向指標都被成了0x41414141，后面呼叫HeapFree釋放堆塊的時候，就會將buf2和后面的空閑堆塊0x007104c0合并，修改兩個空閑堆塊的前后向指標就會參考0x41414141，最后造成崩潰，
如果把上面釋放堆塊的操作換成分配堆塊HeapAlloc（），也會導致崩潰，因為在分配堆塊的時候會去遍歷空閑鏈表指標，會造成地址參考例外，當記憶體中已經分配多個堆塊的時候，可能覆寫到的就是已經分配到的堆塊，此時可能就是覆寫HEAP_ENTRY結構，而不是HEAP_FREE_ENTRY結構，
堆溢位原理圖
0x03 堆除錯技巧
微軟提供了一些除錯選項用于輔助堆除錯，可以通過windbg提供的gflag.exe或者！gflag命令來設定：
htc：堆尾檢查，是否發生溢位
hfc：堆釋放檢查
hpc：堆引數檢查
hpa：啟用頁堆
htg：堆標志
ust：用戶態堆疊回溯對heapoverflow.exe添加堆尾檢查和頁堆，去掉堆標志：
gflags.exe -i F:\vulns\Release\heapoverflow +htc +hpa +htg堆尾檢查
主要是在每個堆塊的尾部，用戶資料之后添加8位元組，通常是連續的2個0xabababab，該資料段被破壞就可能發生了溢位，
對heapoverflow.exe開啟hpc和htc，用windbg加載對heapoverflow程式，附加行程無法在堆尾添加額外標志，使用以下命令開啟堆尾檢查和堆引數檢查：
0:000> !gflag +htc +hpc
Current NtGlobalFlag contents: 0x00000070
htc - Enable heap tail checking
hfc - Enable heap free checking
hpc - Enable heap parameter checking0:000:x86> g
HEAP[heapoverflow.exe]: Heap block at 001E0498 modified at 001E04B0 past requested size of 10
(13d0.3c9c): WOW64 breakpoint - code 4000001f (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
ntdll_77710000!RtlpBreakPointHeap+0x13:
777f07c7 cc int 3執行命令g后，按下回車鍵程式會斷下來
0:000:x86> kb
# ChildEBP RetAddr Args to Child
00 0019fd18 777dd85b 00000000 001e0000 001e0498 ntdll_77710000!RtlpBreakPointHeap+0x13
01 0019fd30 77793e9c 001e0000 00000000 77786780 ntdll_77710000!RtlpCheckBusyBlockTail+0x1a2
02 0019fd4c 777ef9f1 7772e4dc 9ceeef49 001e0000 ntdll_77710000!RtlpValidateHeapEntry+0x633d9
03 0019fda4 7775991d 001e04a0 9ceeec45 001e0498 ntdll_77710000!RtlDebugFreeHeap+0xbf
04 0019fea8 77758b98 001e0498 001e04a0 001e04c1 ntdll_77710000!RtlpFreeHeap+0xd3d
*** WARNING: Unable to verify checksum for F:\vulns\Release\heapoverflow.exe
05 0019fefc 00401094 001e0000 00000000 001e04a0 ntdll_77710000!RtlFreeHeap+0x758
WARNING: Stack unwind information not available. Following frames may be wrong.
06 001e0000 01000709 ffeeffee 00000000 001e00a4 heapoverflow+0x1094
07 001e0004 ffeeffee 00000000 001e00a4 001e00a4 0x1000709
08 001e0008 00000000 001e00a4 001e00a4 001e0000 0xffeeffeeHEAP[heapoverflow.exe]: Heap block at 001E0498 modified at 001E04B0 past requested size of 10上面一句除錯輸出資訊的意思是，在大小為0x10的堆塊0x001E0498的0x001E04B0覆寫破壞了，0x10大小的空間加上堆頭的8位元組一共0x18位元組，0x001E04B0-0x001E0498=0x18，也就是說0x001E04B0位于堆塊資料的最后一個位元組上，基于上面的資訊，可以分析出程式主要是因為向0x10的堆塊中復制過多資料導致的堆溢位，
頁堆
在除錯漏洞的時候，經常需要定位導致漏洞的代碼和函式，比如導致堆溢位的位元組復制指令rep movsz等，前面的堆尾檢查方式主要是堆被破壞的場景，不利于定位導致漏洞的代碼，為此，引入了頁堆的概念，開啟后，會在堆塊中增加不可訪問的柵欄頁，溢位覆寫到柵欄頁就會觸發例外，
開啟頁堆：
gflags.exe -i F:\vulns\Release\heapoverflow +hpa
用windbg加載heapoverflow，運行！gflag命令開啟了頁堆，然后g運行后在cmd按下回車鍵斷下
0:000> g
(46c.b74): Access violation - code c0000005 (!!! second chance !!!)
eax=00000021 ebx=01795ff0 ecx=00000004 edx=77d364f4 esi=0012ff38 edi=01796000
eip=00401084 esp=0012ff10 ebp=01790000 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010202
image00400000+0x1084:
00401084 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:000> dd esi
0012ff38 41414141 41414141 41414141 41414141
0012ff48 00407000 00401327 00000001 01699fb0
0012ff58 0169bf70 00000000 00000000 7ffdd000
0012ff68 c0000005 00000000 0012ff5c 0012fb1c
0012ff78 0012ffc4 00402c50 004060b8 00000000
0012ff88 0012ff94 76281174 7ffdd000 0012ffd4
0012ff98 77d4b3f5 7ffdd000 77cb48a4 00000000
0012ffa8 00000000 7ffdd000 c0000005 76292b35
0:000> dc edi
01796000 ???????? ???????? ???????? ???????? ????????????????
01796010 ???????? ???????? ???????? ???????? ????????????????
01796020 ???????? ???????? ???????? ???????? ????????????????
01796030 ???????? ???????? ???????? ???????? ????????????????
01796040 ???????? ???????? ???????? ???????? ????????????????
01796050 ???????? ???????? ???????? ???????? ????????????????
01796060 ???????? ???????? ???????? ???????? ????????????????
01796070 ???????? ???????? ???????? ???????? ????????????????可以發現程式在復制A字串的時候觸發了例外，程式復制到0x11位元組的時候被斷下，此時例外還未破壞到堆塊，直接定位導致溢位的復制指令rep movs
0:000> kb
ChildEBP RetAddr Args to Child
WARNING: Stack unwind information not available. Following frames may be wrong.
0012ff48 00401327 00000001 01699fb0 0169bf70 image00400000+0x1084
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Windows\system32\kernel32.dll -
0012ff88 76281174 7ffdd000 0012ffd4 77d4b3f5 image00400000+0x1327
0012ff94 77d4b3f5 7ffdd000 77cb48a4 00000000 kernel32!BaseThreadInitThunk+0x12
0012ffd4 77d4b3c8 0040b000 7ffdd000 00000000 ntdll!RtlInitializeExceptionChain+0x63
0012ffec 00000000 0040b000 7ffdd000 00000000 ntdll!RtlInitializeExceptionChain+0x36
0:000> ub image00400000+0x1327
image00400000+0x1301:
00401301 e847120000 call image00400000+0x254d (0040254d)
00401306 e8af0e0000 call image00400000+0x21ba (004021ba)
0040130b a150994000 mov eax,dword ptr [image00400000+0x9950 (00409950)]
00401310 a354994000 mov dword ptr [image00400000+0x9954 (00409954)],eax
00401315 50 push eax
00401316 ff3548994000 push dword ptr [image00400000+0x9948 (00409948)]
0040131c ff3544994000 push dword ptr [image00400000+0x9944 (00409944)]
00401322 e8d9fcffff call image00400000+0x1000 (00401000)根據堆疊回溯，呼叫rep movs的上一層函式位于image00400000+0x1084的上一條指令，也就是00401322，此處呼叫了00401000函式，很容易發現這是主入口函式：
0:000> uf 00401000
image00400000+0x1000:
00401000 83ec24 sub esp,24h
00401003 b908000000 mov ecx,8
00401008 53 push ebx
00401009 55 push ebp
0040100a 56 push esi
0040100b 57 push edi
0040100c be44704000 mov esi,offset image00400000+0x7044 (00407044)
00401011 8d7c2410 lea edi,[esp+10h]
00401015 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
00401017 68ffff0000 push 0FFFFh
0040101c 6800100000 push 1000h //堆塊大小壓入
00401021 6a04 push 4
00401023 a4 movs byte ptr es:[edi],byte ptr [esi]
00401024 ff150c604000 call dword ptr [image00400000+0x600c (0040600c)]//呼叫HeapCreate創建堆塊
0040102a 8be8 mov ebp,eax
0040102c a16c704000 mov eax,dword ptr [image00400000+0x706c (0040706c)]
00401031 48 dec eax
00401032 a36c704000 mov dword ptr [image00400000+0x706c (0040706c)],eax
00401037 7808 js image00400000+0x1041 (00401041)
image00400000+0x1039:
00401039 ff0568704000 inc dword ptr [image00400000+0x7068 (00407068)]
0040103f eb0d jmp image00400000+0x104e (0040104e)
image00400000+0x1041:
00401041 6868704000 push offset image00400000+0x7068 (00407068)
00401046 e896000000 call image00400000+0x10e1 (004010e1)
0040104b 83c404 add esp,4
image00400000+0x104e:
0040104e 6a10 push 10h
00401050 6a00 push 0
00401052 55 push ebp
00401053 ff1508604000 call dword ptr [image00400000+0x6008 (00406008)] //呼叫HeapAlloc分配0x10的堆塊
00401059 8bd8 mov ebx,eax //分配的堆塊地址
0040105b 53 push ebx
0040105c 6830704000 push offset image00400000+0x7030 (00407030)
00401061 e84a000000 call image00400000+0x10b0 (004010b0)
00401066 8d7c2418 lea edi,[esp+18h]
0040106a 83c9ff or ecx,0FFFFFFFFh
0040106d 33c0 xor eax,eax
0040106f 83c408 add esp,8
00401072 f2ae repne scas byte ptr es:[edi]
00401074 f7d1 not ecx //獲取str長度
00401076 2bf9 sub edi,ecx
00401078 53 push ebx
00401079 8bc1 mov eax,ecx
0040107b 8bf7 mov esi,edi //str = 0x20
0040107d 8bfb mov edi,ebx //分配的堆塊只有0x10
0040107f 6a00 push 0
00401081 c1e902 shr ecx,2
00401084 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
00401086 8bc8 mov ecx,eax
00401088 55 push ebp
00401089 83e103 and ecx,3
0040108c f3a4 rep movs byte ptr es:[edi],byte ptr [esi] //0x20 < 0x10 回圈復制導致溢位
0040108e ff1504604000 call dword ptr [image00400000+0x6004 (00406004)]
00401094 55 push ebp
00401095 ff1500604000 call dword ptr [image00400000+0x6000 (00406000)]
0040109b 5f pop edi
0040109c 5e pop esi
0040109d 5d pop ebp
0040109e 33c0 xor eax,eax
004010a0 5b pop ebx
004010a1 83c424 add esp,24h
004010a4 c3 ret0x04整數溢位漏洞原理
整數分為有符號和無符號兩類，有符號數以最高位作為符號位，正整數最高位為1，負整數最高位為0，不同型別的整數在記憶體中有不同的取值范圍，unsigned int = 4位元組，int = 4位元組，當存盤的數值超過該型別整數的最大值就會發生溢位，
在一些有符號和無符號轉換的程序中最有可能發生整數溢位漏洞，
基于堆疊的整數溢位
基于堆疊的整數溢位的例子：
#include "stdio.h"
#include "string.h"
int main(int argc, char *argv){
int i;
char buf[8]; // 堆疊緩沖區
unsigned short int size; // 無符號短整數取值范圍：0 ~ 65535
char overflow[65550];
memset(overflow,65,sizeof(overflow)); // 填充為“A”字符
printf("請輸入數值:\n");
scanf("%d",&i); //輸入65540
size = i;
printf("size：%d\n",size); // 輸出系統識別出來的size數值 4
printf("i：%d\n",i); // 輸出系統識別出來的i資料 65540
if (size > 8) //邊界檢查
return -1;
memcpy(buf,overflow,i); // 堆疊溢位
return 0;
}代碼中size變數是無符號短整型，取值范圍是0~65535，輸入的值大于65535就會發生溢位，最后得到size為4，這樣會通過邊界檢查，但是用memcpy復制資料的時候，使用的是int型別的引數i，這個值是輸入的65540，就會發生堆疊溢位：
基于堆的整數溢位
基于堆的整數溢位的例子：
#include "stdio.h"
#include "windows.h"
int main(int argc, char * argv)
{
int* heap;
unsigned short int size; // 無符號短整數取值范圍：0 ~ 65535
char *pheap1, *pheap2;
HANDLE hHeap;
printf("輸入size數值：\n");
scanf("%d",&size);
hHeap = HeapCreate(HEAP_GENERATE_EXCEPTIONS, 0x100, 0xfff); //創建一個堆塊
if (size <= 0x50)
{
size -= 5; //輸入2，size=-3=65533，
printf("size：%d\n",size);
pheap1 = HeapAlloc(hHeap, 0, size); // pheap1會分配過大的堆塊，導致溢位！
pheap2 = HeapAlloc(hHeap, 0, 0x50);
}
HeapFree(hHeap, 0, pheap1);
HeapFree(hHeap, 0, pheap2);
return 0;
}代碼中的size是unsigned short int型別，當輸入小于5，size減去5會得到負數，但由于unsigned short int取值范圍的限制無法識別負數，得到正數65533，最后分配得到過大的堆塊，溢位覆寫了后面的堆管理結構：
0x05 格式化字串漏洞原理
格式化漏洞產生的原因主要是對用戶輸入的內容沒有做過濾，有些輸入資料都是作為引數傳遞給某些執行格式化操作的函式的，比如：printf，fprintf，vprintf，sprintf，
惡意用戶可以使用%s和%x等格式符，從堆疊和其他記憶體位置輸出資料，也可以使用格式符%n向任意地址寫入資料，配合printf（）函式就可以向任意地址寫入被格式化的位元組數，可能導致任意代碼執行，或者讀取敏感資料，
以下面的代碼為例講解格式化字串漏洞原理：
#include <stdio.h>
#include <string.h>
int main (int argc, char *argv[])
{
char buff[1024]; // 設定堆疊空間
strncpy(buff,argv[1],sizeof(buff)-1);
printf(buff); //觸發漏洞
return 0;
}可以發現當輸入資料包含%s和%x格式符的時候，會意外輸出其他資料：
用ollydbg附加除錯程式，執行前需要先設定命令列引數，除錯-引數-命令列：test-%x
在運行程式后，傳遞給printf的引數只有test-%x，但是他把輸入引數test-%x之后的另一個堆疊上資料當做引數傳給了printf函式，因為printf基本型別是：
printf（“格式化控制符”，變數串列）；傳遞給printf的引數只有一個，但是程式默認將堆疊上的下一個資料作為引數傳遞給了printf函式，剛好下一個資料是strcpy（）函式的目標地址，就是buff變數，buff剛好指向test-%x的地址0x0019fec4，所以程式會輸出0x0019fec4，如果后面再加一個%x就會將src引數的值也輸出了，這樣就可以遍歷整個堆疊上資料了，
除了利用%x讀取堆疊上資料，還可以用%n寫入資料修改回傳地址來實作漏洞利用，
0x06 雙重釋放漏洞原理
Double Free漏洞是由于對同一塊記憶體進行二次釋放導致的，利用漏洞可以執行任意代碼，編譯成release示例代碼如下：
#include <stdio.h>
#include "windows.h"
int main (int argc, char *argv[])
{
void *p1,*p2,*p3;
p1 = malloc(100);
printf("Alloc p1：%p\n",p1);
p2 = malloc(100);
printf("Alloc p2：%p\n",p2);
p3 = malloc(100);
printf("Alloc p3：%p\n",p3);
printf("Free p1\n");
free(p1);
printf("Free p3\n");
free(p3);
printf("Free p2\n");
free(p2);
printf("Double Free p2\n"); //二次釋放
free(p2);
return 0;
}在二次釋放p2的時候就會發生程式崩潰，但是并不是每次出現Double Free都會發生崩潰，要有堆塊合并的動作發生才會發生崩潰
#include <stdio.h>
#include "windows.h"
int main (int argc, char *argv[])
{
void *p1,*p2,*p3;
p1 = malloc(100);
printf("Alloc p1：%p\n",p1);
p2 = malloc(100);
printf("Alloc p2：%p\n",p2);
p3 = malloc(100);
printf("Alloc p3：%p\n",p3);
printf("Free p2\n");
free(p2);
printf("Double Free p2\n");
free(p2);
printf("Free p1\n");
free(p1);
printf("Free p3\n");
free(p3);
return 0;
}
雙重釋放原理圖
在釋放程序中，鄰近的已經釋放的堆塊存在合并操作，這會改變原有堆頭資訊，之后再對其地址參考釋放就會發生訪問例外，
0x07釋放后重參考漏洞原理
通過以下代碼理解UAF漏洞原理：
#include <stdio.h>
#define size 32
int main(int argc, char **argv) {
char *buf1;
char *buf2;
buf1 = (char *) malloc(size);
printf("buf1：0x%p\n", buf1);
free(buf1);
// 分配 buf2 去“占坑”buf1 的記憶體位置
buf2 = (char *) malloc(size);
printf("buf2：0x%p\n\n", buf2);
// 對buf2進行記憶體清零
memset(buf2, 0, size);
printf("buf2：%d\n", *buf2);
// 重參考已釋放的buf1指標，但卻導致buf2值被篡改
printf("==== Use After Free ===\n");
strncpy(buf1, "hack", 5);
printf("buf2：%s\n\n", buf2);
free(buf2);
}
buf2 “占坑”了buf1 的記憶體位置，經過UAF后，buf2被成功篡改了
程式通過分配和buf1大小相同的堆塊buf2實作占坑，似的buf2分配到已經釋放的buf1記憶體位置，但由于buf1指標依然有效，并且指向的記憶體資料是不可預測的，可能被堆管理器回收，也可能被其他資料占用填充，buf1指標稱為懸掛指標，借助懸掛指標buf1將記憶體賦值為hack，導致buf2也被篡改為hack，
如果原有的漏洞程式參考到懸掛指標指向的資料用于執行指令，就會導致任意代碼執行，
在通常的瀏覽器UAF漏洞中，都是某個C++物件被釋放后重參考，假設程式存在UAF的漏洞，有個懸掛指標指向test物件，要實作漏洞利用，通過占坑方式覆寫test物件的虛表指標，虛表指標指向虛函式存放地址，現在讓其指向惡意構造的shellcode，當程式再次參考到test物件就會導致任意代碼執行，
UAF漏洞利用原理圖
0x08 陣列越界訪問漏洞
先區分一下陣列越界漏洞和溢位漏洞：陣列越界訪問包含讀寫型別，溢位屬于資料寫入；部分溢位漏洞本質確實就是陣列越界漏洞，
陣列越界就像是倒水的時候倒錯了杯子，溢位就像是水從杯子里溢位來，
下面代碼為例分析陣列越界訪問漏洞：
#include "stdio.h"
int main(){
int index;
int array[3] = {0x11, 0x22, 0x33};
printf("輸入陣列索引下標：");
scanf("%d", &index);
printf("輸出陣列元素：array[%d] = 0x%x\n", index, array[index]); //陣列越界讀操作
//array[index] = 1 ; //陣列越界寫操作
return 0;
}
執行生成的程式，然后分別輸入12345，輸出結果如上，當輸入的陣列下標分別是12的時候，會得到正常數值，但是從索引3開始就超出了原來的陣列array的范圍，比如輸入5，就會陣列越界訪問array陣列，導致讀取不在程式控制范圍內的數值，
使用ollydbg除錯發現array[5]就是從array開始的第六個資料0x4012A9，已經讀取到了array之外的資料，如果越界訪問距離過大，就會訪問到不可訪問的記憶體空間，導致程式崩潰，
0x09型別混淆漏洞原理
型別混淆漏洞（Type Confusion）一般是將資料型別A當做資料型別B來決議參考，這就可能導致非法訪問資料從而執行任意代碼，比如將Unit轉成了String，將類物件轉成資料結構，
型別混淆漏洞是現在瀏覽器漏洞挖掘的主流漏洞，這類漏洞在java，js等弱型別語言中非常常見，
下面的代碼，A類被混淆成B類，就可能導致私有域被外部訪問到：
class A {
private int value;
};
class B {
public int value;
};
B attack = AcastB(var); //將A型別混淆轉成B型別
attack.value = 1; //導致可以訪問私有域以IE/Edge型別混淆漏洞（CVE-2017-0037）為例講解，漏洞原因是函式處理時，沒有對物件型別進行嚴格檢查，導致型別混淆，
PoC如下：在PoC中定義了一個table，標簽中定義了表id為th1，在boom()中參考，然后是setInterval設定事件，
運行PoC，用Windbg附加并加載運行出現崩潰
從崩潰點可以看到eax作為指標，參考了一個無效地址，導致崩潰，而上一條指令是一個call，這個無效的回傳值來自這個call，在這個call處下斷點，ecx作為引數，存放的物件是一個Layout::FlowItem::`vftable虛表
這里讀取虛表中+4的值，為0時this指標賦值v1，隨后v1+16后回傳，因此，Layout::FlowItem::`vftable所屬指標的這個情況是正常的，函式會正常回傳進入后續處理邏輯
讓程式繼續運行，會再次呼叫該函式，此時ecx并不是一個虛表物件，而是一個int Array物件，這里我們可以通過條件斷點來跟蹤兩個物件的創建程序，重點關注兩個物件創建的函式，一個是FlowItem::`vftable對應的虛表物件，另一個是引發崩潰的int Array物件，這兩個函式的回傳值，也就是eax暫存器中存放的指向這兩個創建物件的指標，
通過跟蹤可以看到第一次呼叫Readable函式時ecx是一個正常的FlowItem物件，而第二次呼叫的時候ecx是一個int Array Object，Layout::Patchable >::Readable函式是處理虛表物件的函式，由于boom()函式中參考th1.align導致Readable函式得到第二次參考，由于沒有進行物件屬性檢查，導致第二次呼叫時將table物件傳入，最終發生型別混淆崩潰，
0x10競爭條件漏洞原理
競爭條件（Race Condition）是由于多個執行緒/物件/行程同時操作同一資源，導致系統執行違背原有邏輯設定的行為，這類漏洞在linux，內核層面非常多見，在windows和web層面也存在，
互斥鎖的出現就是為了解決此類漏洞問題，保證某一物件在特定資源訪問時，其他物件不能操作此資源，
競爭條件”發生在多個執行緒同時訪問同一個共享代碼、變數、檔案等沒有進行鎖操作或者同步操作的場景中， ——Wikipedia-computer_science比如如下代碼：
#-*-coding:utf-8-*-
import threading
COUNT = 0
def Run(threads_name):
global COUNT
read_value = COUNT
print "COUNT in Thread-%s is %d" % (str(threads_name), read_value)
COUNT = read_value + 1
def main():
threads = []
for j in range(10):
t = threading.Thread(target=Run,args=(j,))
threads.append(t)
t.start()
for i in range(len(threads)):
threads[i].join()
print("Finally, The COUNT is %d" % (COUNT,))
if __name__ == '__main__':
main()執行結果如下：
按照我們的預想，結果應該都是10，但是發現結果可能存在非預期解，原因就在于我們沒有對變數COUNT做同步制約，導致可能Thread-7在讀COUNT,還沒來得及更改COUNT,Thread-8搶奪資源，也來讀COUNT,并且將COUNT修改為它讀的結果+1，由此出現非預期，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/300424.html
標籤：其他