›
›

Bài giảng An toàn hệ điều hành - Shellcode - Nguyễn Hồng Sơn

Download
Shellcode  
ꢀꢁꢂꢃꢄN ꢅꢆNG SꢇN  
PTITHCM  
1
Khái niꢈm shellcode  
ꢀ Nghꢉa phꢊ biꢋn trꢌꢍc ꢎây: mꢏt chꢌơng trình khi thꢐc  
thi sꢑ cung cꢒp mꢏt shell  
ꢀ Ví dꢓ: '/bin/sh' cho Unix/Linux shell, hay  
command.com shell trên DOS và Microsoft Windows  
ꢀ Nghꢉa rꢏng hơn: bꢒt kꢔ byte code nào ꢎꢌꢕc chèn vào  
mꢏt quá trình khai thác lꢖ hꢊng ꢎꢗ hoàn thành mꢏt tác  
vꢓ mong muꢘn. Có nghꢉa là mꢏt payload  
2
Khái niꢈm shellcode (2/2)  
ꢀ Shellcode ꢎꢌꢕc viꢋt dꢌꢍi dꢙng ngôn ngꢚ  
assembly, trích xuꢒt các opcode dꢌꢍi dꢙng hexa  
và dùng nhꢌ là các biꢋn string trong chꢌơng trình  
ꢀ Các thꢌ viꢈn chuꢛn không hꢖ trꢕ shellcode, phꢜi  
dùng kernel system call cꢝa hꢈ ꢎiꢞu hành mꢏt  
cách trꢐc tiꢋp  
3
System call  
ꢀ Là mã chꢌơng trình chꢙy trong ngꢚ cꢜnh cꢝa user  
(user space) yêu cꢟu kernel thꢐc hiꢈn các công viꢈc  
khác nhau nhꢌ mꢠ, ꢎꢡc file, tꢙo mꢏt phân vùng bꢏ  
nhꢍ…  
ꢀ Các system call thꢌꢢng ꢎꢌꢕc thꢐc hiꢈn theo thꢝ tꢓc  
nhꢒt ꢎꢣnh nhꢌ nꢙp mꢏt giá trꢣ vào thanh ghi và gꢡi mꢏt  
ngꢤt tꢌơng ꢥng (ví dꢓ syscall exit ꢠ ví dꢓ 1)  
4
Windows shellcode và Linux shellcode  
ꢀ Linux cho phép giao tiꢋp trꢐc tiꢋp vꢍi kernel qua int 0x80  
ꢀ Windows không cho phép giao tiꢋp trꢐc tiꢋp vꢍi kernel,  
hꢈ thꢘng phꢜi giao tiꢋp bꢦng cách nꢙp ꢎꢣa chꢧ cꢝa  
hàm_cꢟn ꢎꢌꢕc thꢐc thi tꢨ DLL.  
ꢀ ꢩꢣa chꢧ cꢝa hàm ꢎꢌꢕc tìm thꢒy trong windows sꢑ thay ꢎꢊi  
tùy theo phiên bꢜn cꢝa OS trong khi các 0x80 syscall  
number là không ꢎꢊi  
5
Viꢋt shellcode  
ꢀ Hơi khác vꢍi assembly code thông thꢌꢢng, ꢎó là khꢜ nꢪng  
portability.  
ꢀ Vì không thꢗ biꢋt ꢎꢣa chꢧ nên không thꢗ lꢫp trình cꢥng mꢏt ꢎꢣa  
chꢧ trong shellcode.  
ꢀ Phꢜi dùng thꢝ thuꢫt ꢎꢗ tꢙo shellcode mà không phꢜi tham  
chiꢋu các tham sꢘ trong bꢏ nhꢍ theo cách thông thꢌꢢng  
ꢀ Chꢧ bꢦng cách cung cꢒp ꢎꢣa chꢧ chính xác trên memory page  
và chꢧ có thꢗ làm vào thꢢi ꢎiꢗm biên dꢣch  
ꢀ Cách dꢬ nhꢒt là dùng chuꢖi trong shellcode nhꢌ ví dꢓ ꢎơn  
giꢜn sau  
6
section .data  
#chꢧ dùng thanh ghi ꢠ ꢎây...  
section .text  
global _start  
jmp dummy  
_start:  
#pop register, dꢐa vào ꢎó biꢋt ꢎꢌꢕc vꢣ trí chuꢖi  
#Tꢙi ꢎây là các assembly instructions sꢑ dùng chuꢖi  
dummy:  
call _start  
ꢎꢭt chuꢖi chꢖ này  
7
Linux Shellcoding  
/*shellcodetest.c*/  
char code[] = “chuꢖi mã lꢈnh!";  
int main(int argc, char **argv)  
{
int (*func)();  
func = (int (*)()) code;  
(int)(*func)();  
}
8
Viꢋt Shellcode cho exit() syscall  
ꢀ Viꢋt system call trong ngôn ngꢚ C  
ꢀ compiled và disassembled, thꢒy nhꢚng gì các  
chꢧ thꢣ thꢐc sꢐ làm  
main()  
{
exit(0);  
}
gcc –static –o exit exit.c  
gdb exit  
9
exit syscall  
ꢀ asm code to call exit (ví dꢓ 1)  
;exit.asm  
section .text  
global _start  
_start:  
mov ebx,0  
mov eax,1  
int 0x80  
10  
Dꢣch và trích xuꢒt mã máy  
$ nasm -f elf exit.asm  
$ ld -o exiter exit.o  
$ objdump -d exiter  
exit_shellcode: file format elf32-i386  
Disassembly of section .text:  
08048080 <.text>:  
8048080:  
8048085:  
804808a:  
bb 00 00 00 00  
b8 01 00 00 00  
cd 80  
mov $0x0,%ebx  
mov $0x1,%eax  
int $0x80  
Thay vào shellcodetest.c  
char code[] = "\xbb\x00\x00\x00\x00\xb8\x01\x00\x00\x00\xcd\x80";  
11  
Ví dꢓ 2  
;hello.asm  
section .text  
global _start  
_start:  
jmp short ender  
starter:  
xor eax, eax ;clean up the registers  
xor ebx, ebx  
xor edx, edx  
xor ecx, ecx  
mov al, 4  
mov bl, 1  
pop ecx  
mov dl, 5  
int 0x80  
;syscall write  
;stdout is 1  
;get the address of the string from the stack  
;length of the string  
xor eax, eax  
mov al, 1  
xor ebx,ebx  
int 0x80  
;exit the shellcode  
ender:  
call starter ;put the address of the string on the stack  
db 'hello'  
12  
08048080 <_start>:  
8048080: eb 19  
jmp 804809b  
08048082 <starter>:  
8048082:  
8048084:  
8048086:  
8048088:  
804808a:  
804808c:  
804808e:  
804808f:  
8048091:  
8048093:  
8048095:  
8048097:  
8048099:  
31 c0  
31 db  
31 d2  
31 c9  
b0 04  
b3 01  
59  
b2 05  
cd 80  
31 c0  
b0 01  
31 db  
cd 80  
xor %eax,%eax  
xor %ebx,%ebx  
xor %edx,%edx  
xor %ecx,%ecx  
mov $0x4,%al  
mov $0x1,%bl  
pop %ecx  
mov $0x5,%dl  
int $0x80  
xor %eax,%eax  
mov $0x1,%al  
xor %ebx,%ebx  
int $0x80  
$ nasm -f elf hello.asm  
$ ld -o hello hello.o  
$ objdump -d hello  
0804809b <ender>:  
804809b:  
80480a0:  
e8 e2 ff ff ff  
68 65 6c 6c 6f  
call 8048082  
push $0x6f6c6c65  
13  
char code[] =  
"\xeb\x19\x31\xc0\x31\xdb\x31\xd2\x31\xc9\xb0\x04\xb3\x01\x59\xb2\x05\xcd"  
\
"\x80\x31\xc0\xb0\x01\x31\xdb\xcd\x80\xe8\xe2\xff\xff\xff\x68\x65\x6c\x6c\x6f";  
14  
Injectable Shellcode  
ꢀ Nơi thꢌꢢng ꢎꢭt shellcode: buffer  
ꢀ Buffer là mꢜng ký tꢐꢀstring  
ꢀ Chuꢖi mã lꢈnh thꢌꢢng chꢥa ký tꢐ null  
ꢀ Ví dꢓ:  
\xbb\x00\x00\x00\x00\xb8\x01\x00\x00\x00\xcd\x80  
ꢀ Null kꢋt thúc chuꢖi, ꢀchèn shellcode và buffer không  
thành công  
ꢀ Cꢟn có cách ꢎꢊi null thành non-null opcode  
15  
mov ebx,0  
mov eax,1  
int 0x80  
\xbb\x00\x00\x00\x00  
\xb8\x01\x00\x00\x00  
\xcd\x80  
ꢀ Hai chꢧ thꢣ ꢎꢟu làm phát sinh null  
ꢀ Mov ebx,0 sꢑ tꢙo ra null, thay bꢦng xor ebx,ebx sꢑ tránh xuꢒt hiꢈn  
null trong opcode  
ꢀ Chꢧ thꢣ thꢥ hai dùng eax có 4 byte dꢮn ꢎꢋn khi nꢙp 1 vào thì phꢟn  
còn lꢙi chꢥa null, ꢎꢊi thành mov al,1  
xor ebx,ebx  
mov al,1  
int 0x80  
16  
Viꢋt lꢙi mã hꢕp ngꢚ  
;exit.asm  
section .text  
global _start  
_start:  
xor eax, eax ;  
mov al, 1  
;exit is syscall  
1
xor ebx,ebx ;zero out ebx  
int 0x80  
17  
Dꢣch và trích xuꢒt mã máy  
$ nasm -f elf exit.asm  
$ ld -o exiter exit.o  
$ objdump -d exiter  
Disassembly of section .text:  
08048080 <_start>:  
8048080: b0 01  
8048082: 31 db  
8048084: cd 80  
mov $0x1,%al  
xor %ebx,%ebx  
int $0x80  
Thay vào shellcodetest.c  
char code[] = "\xb0\x01\x31\xdb\xcd\x80";  
18  
Lꢒy mꢏt shell  
Nꢪm bꢌꢍc:  
1. Viꢋt shellcode lꢒy shell nhꢌ mong muꢘn bꢦng ngôn ngꢚ cꢒp cao.  
2. Compile và disassemble chꢌơng trình shellcode (ngôn ngꢚ cꢒp  
cao).  
3. Phân tích cách làm viꢈc cꢝa chꢌơng trình ꢠ mꢥc assembly.  
4. Giꢜn lꢌꢕc ꢎꢗ tꢙo mꢏt chꢌơng trình dꢌꢍi dꢙng aseembly nhꢯ gꢡn và  
có tính nꢪng injectable nhꢌ ꢎã nói trên.  
5. Trích mã máy (instruction code) và tꢙo shellcode.  
19  
Step 1  
ꢀ Cách dꢬ nhꢒt ꢎꢗ tꢙo mꢏt shell là dùng công cꢓ tꢙo mꢏt tiꢋn  
trình mꢍi  
ꢀ Có 2 cách tꢙo:  
ꢀ Thông qua mꢏt tiꢋn trình ꢎã có và thay thꢋ program ꢎã chꢙy  
ꢀ Copy mꢏt tiꢋn trình có sꢰn và chꢙy program mꢍi tꢙi vꢣ trí cꢝa  
nó  
ꢀ Kernel sꢑ hꢖ trꢕ, chꢧ cꢟn báo cho kernel biꢋt cꢟn làm gì  
bꢦng cách dùng fork() và execve()  
20  
Tải về để xem bản đầy đủ
pdf 35 trang yennguyen 22020 Free
Download
Bạn đang xem 20 trang mẫu của tài liệu "Bài giảng An toàn hệ điều hành - Shellcode - Nguyễn Hồng Sơn", để tải tài liệu gốc về máy hãy click vào nút Download ở trên

File đính kèm:

  • pdfbai_giang_an_toan_he_dieu_hanh_shellcode_nguyen_hong_son.pdf