쉘코드 작성해보기 (1)

1. 쉘코드란

쉘코드(Shellcode)는 실행할 수 있는 어셈블리(기계어) 코드 조각을 의미한다.

pwnable에서는 쉘을 획득하기 위한 목적으로 쉘코드를 사용된다.

 

만약 프로그램의 실행 위치(rip)를 자신이 작성한 쉘코드로 옮길 수 있게 된다면 어셈블리어는 기계어와 거의 일대일 대응되므로 사실상 원하는 모든 명령을 CPU에 내릴 수 있게 되는 것이기 때문이다. 

쉘코드는 어셈블리어로 구성되므로 공격을 수행할 대상 아키텍처와 운영체제에 따라, 그리고 셸코드의 목적에 따라 다르게 작성되므로, 직접 작성할 줄 알아야 한다. 

2. orw 쉘코드 작성 

“/tmp/flag”경로의 파일을 read하는 쉘코드를 작성해보자

이처럼 파일과 관련된 쉘코드를 작성하기 필요한 syscall은 open(), read(), write() 등이 있다.

char buf[0x30];

int fd = open("/tmp/flag", RD_ONLY, NULL);
read(fd, buf, 0x30); 
write(1, buf, 0x30);

 

64bit에서는 rax에 syscall number가 들어가고 rdi, rsi, rdx에 각각 첫번째, 두번째 세번째 인자가 들어간다.

(64비트 함수 호출 규약 참고)

syscall	rax	rdi	rsi	rdx
read	0x00	unsigned int fd	char *buf	size_t count
write	0x01	unsigned int fd	const char *buf	size_t count
open	0x02	const char *filename	int flags	umode_t mode

 

즉,  파일 open (열기) -> 파일 읽기 -> 내용 쓰기 의 과정을 거쳐야 한다는 것이다. 

(1) open("/tmp/flag", RD_ONLY, NULL)

open은 첫번째 인자(rdi)로 open할 filename을 받는다.

즉, 우리는 읽어야되는 파일의 이름을 인자로 주기 위해서 “/tmp/flag” 문자열을 메모리에 로드해야 한다.

메모리는 리틀엔디안 방식으로 메모리에 로드되므로 2f 74 6d 70 2f 66 6c 61 67 를 역순으로 입력해야 하므로, 스택에 0x67616c662f706d742f를 push해야 한다. 

 

이때, 64비트에서는 8바이트 단위로 스택에 값을 저장할 수 있는데 현재 저장해야 하는 문자열은 9바이트이기 때문에 0x67은 따로 먼저 push 해준다. 그리고 rdi가 이를 가리키도록 rsp를 rdi로 옮긴다. (첫번째 인자이기 때문)

• push 0x67
• mov rax, 0x616c662f706d742f 
• push rax

//여기서 왜 바로 push안하고 rax에 저장하고 push하는지 솔직히 잘 모르겠다..이게 더 효율적인 방법이라는데 먼가 와닿지가 않음

 

open 함수의 두번째 인자로는 파일을 여는 모드를 지정하는데, 우리는 파일을 생성하거나 쓰지 않을 것이기 때문에 읽기 전용 모드(O_RDONLY)로 파일을 열 것이므로 rdi를 0으로 설정할 것이다.

• xor rsi, rsi 
  • xor은 두 비트가 다를 때 1을, 같을 때 0을 반환 (자기 자신과 xor 연산이므로 무조건 0 반환 후 rsi에 저장)

//이것도 그냥 mov rsi, 0 하면 되지 않나

-> xor rsi, rsi는 단순히 rsi를 0으로 만드는 가장 빠르고 효율적인 방법 중 하나라고 한다. (더 작은 바이트 수로 인코딩되기 때문에 성능 면에서 더 효율적이라고 함)

 

세번째 인자는 파일 생성 시 권한 설정 이므로 파일을 읽을 때에는 의미를 갖지 않으므로, rdx는 0으로 설정한다.

//마찬가지의 이유로 xor연산 사용

• xor rdx, rdx

마지막으로 rax를 open의 syscall 값인 2로 설정한다. 

push 0x67   ;저장해야 하는 문자열이 9바이트이므로 g(리틀엔디안) 먼저 push
mov rax, 0x616c662f706d742f    ; 나머지 8바이트 rax에 저장
push rax					   ; rax에 저장한 8바이트 push
mov rdi, rsp    ; rdi = "/tmp/flag"
xor rsi, rsi    ; rsi = 0 ; RD_ONLY
xor rdx, rdx    ; rdx = 0
mov rax, 2      ; rax = 2 ; syscall_open
syscall         ; open("/tmp/flag", RD_ONLY, NULL)

 

(2) read(fd, buf, 0x30)

syscall의 반환 값은 rax로 저장된다. (open()의 리턴값은 fd)

따라서 open("/tmp/flag", RD_ONLY, NULL)의 fd는 rax에 저장된다.

read의 첫 번째 인자는 읽을 파일의 fd값이므로 rax값을 rdi에 넣어준다.

• mov rdi, rax

두 번째 인자인 rsi는 파일에서 읽은 데이터를 저장할 버퍼 주소를 가리킨다.

0x30 만큼의 데이터를 파일에서 읽어올 것이므로, rsi에 rsp-0x30을 가르키도록 한다. 

• mov rsi, rsp
• sub rsi, 0x30

세 번째 인자인 rdx는 파일로부터 읽어낼 데이터의 길이인 0x30으로 설정한다.

• mov rdx, 0x30

read 시스템콜을 호출하기 위해서 rax를 0으로 설정합니다.

• mov rax, 0x0 
• 아 얘는 왜 xor안하는거임 구글링해봐도 모르겠음 ㅋ큐

mov rdi, rax      ; rdi = fd
mov rsi, rsp
sub rsi, 0x30     ; rsi = rsp-0x30 ; buf
mov rdx, 0x30     ; rdx = 0x30     ; len
mov rax, 0x0      ; rax = 0        ; syscall_read
syscall           ; read(fd, buf, 0x30)

 

(3) write(1, buf, 0x30)

write()는 첫번째 인자로 표준 출력(stdout) fd를 받으므로 1로 설정한다. 

• mov rdi, 1
• 파일 디스크립터와 같이 단순히 정수 값을 표현하는 경우에는 10진수 표기가 더 흔하게 사용된다고 한다,,

rsi와 rdx는 read와 값이 동일하므로, 이전에 사용한 값을 그대로 사용할 수 있다. 

 

• buf: 출력할 데이터가 저장된 버퍼의 주소
• count: 출력할 바이트 수 

 

write 시스템콜을 호출하기 위해서 rax를 1로 설정한다. 

mov rdi, 1        ; rdi = 1 ; fd = stdout
mov rax, 0x1      ; rax = 1 ; syscall_write
syscall           ; write(fd, buf, 0x30)

 

따라서 최종 코드는 아래와 같다.

;Name: orw.S

push 0x67
mov rax, 0x616c662f706d742f 
push rax
mov rdi, rsp    ; rdi = "/tmp/flag"
xor rsi, rsi    ; rsi = 0 ; RD_ONLY
xor rdx, rdx    ; rdx = 0
mov rax, 2      ; rax = 2 ; syscall_open
syscall         ; open("/tmp/flag", RD_ONLY, NULL)

mov rdi, rax      ; rdi = fd
mov rsi, rsp
sub rsi, 0x30     ; rsi = rsp-0x30 ; buf
mov rdx, 0x30     ; rdx = 0x30     ; len
mov rax, 0x0      ; rax = 0        ; syscall_read
syscall           ; read(fd, buf, 0x30)

mov rdi, 1        ; rdi = 1 ; fd = stdout
mov rax, 0x1      ; rax = 1 ; syscall_write
syscall           ; write(fd, buf, 0x30)

 

어셈블리 코드를 컴파일하는 방법에는 여러 가지가 있을 수 있다.

쉘 코드는 어셈블리어로 작성된 짧은 기계어 코드로 특정 기능을 수행하는 코드이지만, 독립적으로 실행 가능한 프로그램이 아니기 때문에 단순히 기계어로 변환되었더라도, 운영체제가 요구하는 ELF형식이 아니므로 리눅스에서 실행될 수 없다.  따라서, 실행 가능한 프로그램의 기본 구조만 갖추고, 구체적인 기능은 없는 코드인 스켈레톤 코드에 우리가 만든 쉘 코드를 삽입하면 ELF 형식을 갖추게 되어 실행 가능하게 된다. 

*스켈레톤 코드는 핵심 내용이 비어있는, 기본 구조만 갖춘 코드를 의미함. 

- 스켈레톤 코드

// File name: sh-skeleton.c
// Compile Option: gcc -o sh-skeleton sh-skeleton.c -masm=intel

__asm__(
    ".global run_sh\n"
    "run_sh:\n"

    "Input your shellcode here.\n"
    "Each line of your shellcode should be\n"
    "seperated by '\n'\n"

    "xor rdi, rdi   # rdi = 0\n"
    "mov rax, 0x3c	# rax = sys_exit\n"
    "syscall        # exit(0)");

void run_sh();

int main() { run_sh(); }

 

위의 스켈레톤 코드에서 __asm__ 부분에 우리가 작성한 쉘코드 채우면 된다.

// File name: orw.c
// Compile: gcc -o orw orw.c -masm=intel

__asm__(
    ".global run_sh\n"
    "run_sh:\n"

    "push 0x67\n"
    "mov rax, 0x616c662f706d742f \n"
    "push rax\n"
    "mov rdi, rsp    # rdi = '/tmp/flag'\n"
    "xor rsi, rsi    # rsi = 0 ; RD_ONLY\n"
    "xor rdx, rdx    # rdx = 0\n"
    "mov rax, 2      # rax = 2 ; syscall_open\n"
    "syscall         # open('/tmp/flag', RD_ONLY, NULL)\n"
    "\n"
    "mov rdi, rax      # rdi = fd\n"
    "mov rsi, rsp\n"
    "sub rsi, 0x30     # rsi = rsp-0x30 ; buf\n"
    "mov rdx, 0x30     # rdx = 0x30     ; len\n"
    "mov rax, 0x0      # rax = 0        ; syscall_read\n"
    "syscall           # read(fd, buf, 0x30)\n"
    "\n"
    "mov rdi, 1        # rdi = 1 ; fd = stdout\n"
    "mov rax, 0x1      # rax = 1 ; syscall_write\n"
    "syscall           # write(fd, buf, 0x30)\n"
    "\n"
    "xor rdi, rdi      # rdi = 0\n"
    "mov rax, 0x3c	   # rax = sys_exit\n"
    "syscall		   # exit(0)");

void run_sh();

int main() { run_sh(); }

 

코드를 작성하고 컴파일 한 뒤, 제대로 실행하는지 확인하기 위해서 /tmp/flag 파일을 생성한 뒤 쉘 코드를 실행해보면 제대로 동작하는 것을 확인할 수 있다.

 

끝~ 

 

3. 디버깅

다음으로는 우리가 만들 쉘 코드를 디버깅해볼 것이다. 

> gdb orw 명령어를 통해 gdb를 실행시켜준다. 

 

그 다음 쉘이 실행하는 부분인 run_sh()에 bp를 걸어준다

> b *run_sh

 

(1) 첫번째 syscall이 위치한 run_sh+29 브레이크 포인트를 설정한 후 실행

> b *run_sh+29 

> c

 

pwndbg는 syscall을 호출할 때, 아래처럼 인자를 해석해서 보여준다.

따라서,

open(“/tmp/flag”, O_RDONLY(0), NULL(0));가 실행됨을 확인할 수 있다.

 

syscall을 실행해보면 open 시스템 콜을 수행한 결과로 /tmp/flag의 fd(3)가 rax에 저장된다. 

 

(2) 두번째 syscall이 위치한 run_sh+55 브레이크 포인트를 설정한 후 실행

.read(fd, buf, 0x30)

->  fd(3)에서 데이터를 0x7fffffffe2c8에  0x30바이트만큼 저장한다. 

 

ni 명령어로 syscall을 실행해보고, RSI 레지스터의 값을 확인해보면 파일의 내용이 0x7fffffffe2b8에 저장되었음을 알 수 있다.

 

rsi는 read 함수의 두 번째 인자로, 파일에서 읽은 데이터를 저장할 버퍼 주소를 전달한다.

우리는 0x30 만큼의 데이터를 파일에서 읽어올 것이므로, rsi에 rsp-0x30을 가르키도록 하였다. 

이때, rsi 값을 rsp에 저장한 뒤 sub 명령어를 통해서 rsi에 0x30을 뺀 값을 저장하는 방식으로 하였기 때문에 아래 

> mov rsi, rsp 실행 결과 rsi가 rsp를 가르키고 있는 것을 확인할 수 있다. 

 

> sub rsi, 0x30의 실행 결과, rsi에는 rsp 0x7fffffffdee8 - 0x30 의 값인 0x0x7fffffffdeb8 를 가르키는 것을 확인할 수 있다. 

 

다시 돌아와서 이러한 레지스터의 값은 x/s 명령어로도 확인할 수 있다. 

x: 16진수로 보여줌

s: 해당 주소에 있는 문자열을 끝까지 (\n을 만날 때까지) 보여줌

 

(3) 세번째 syscall이 위치한 run_sh+71 브레이크 포인트를 설정한 후 실행

write 함수는 첫번째 인자인 rdi만 1로 설정한 뒤, 나머지 인자(buf, 0x30)는 read와 동일하였다. 

따라서 rdi만 1로 설정되어있고, 나머지 레지스터의 값은 동일하다. 

 

ni를 통해 syscall을 실행하면 0x7fffffffdeb8 (rsp - 0x30)에 저장된 값인 문자열이 출력된다. 

 

+) 실행 결과 출력에 이상한 값이 포함된다면, 초기화되지 않은 메모리 영역을 사용했기 때문이라고 한다.

이에 대한 개념은 추후에 다시 다뤄볼 것이다.