힙 오버플로우와 Use-After-Free

// ⚠️ 교육 목적
#include <stdlib.h>
#include <string.h>

int main(void) {
    char *buf = malloc(16);
    char *secret = malloc(16);
    strcpy(secret, "PASSWORD");

    // ❌ buf 영역을 넘어 secret까지 덮어씀
    strcpy(buf, "AAAAAAAAAAAAAAAAAAAAAAAAAA");  // 27 바이트

    // 힙은 보통 buf와 secret이 인접
    // → secret 변조됨

    free(buf);
    free(secret);
    return 0;
}


// 방어:
// 1. 항상 strncpy/snprintf
// 2. -fsanitize=address (런타임 탐지)
// 3. 힙 일관성 검사 (glibc malloc 보호)

// ⚠️ 교육 목적
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    char *p = malloc(16);
    strcpy(p, "Original");
    free(p);

    // ❌ UAF — p는 더 이상 유효하지 않음
    char *q = malloc(16);     // q가 p와 같은 메모리 받을 수 있음
    strcpy(q, "Hijacked");

    printf("p: %s\n", p);  // "Hijacked" 출력 (의도와 다름)

    free(q);
    return 0;
}


// 안전 패턴:
#define SAFE_FREE(p) do { free(p); (p) = NULL; } while (0)

int safe_main(void) {
    char *p = malloc(16);
    SAFE_FREE(p);
    // p는 NULL — 사용 시 즉시 segfault (조용한 버그보다 명확)

    if (p != NULL) {
        // 실행 안 됨
    }
    return 0;
}

// ⚠️ 교육 목적
#include <stdlib.h>

int main(void) {
    char *p = malloc(16);
    free(p);
    free(p);  // ❌ Double free
    // 글리브 모던 버전:
    // free(): double free detected in tcache 2
    // Aborted (core dumped)

    // 공격: double free → 힙 메타데이터 손상 → 임의 쓰기
    // 모던 glibc는 tcache·MALLOC_CHECK_ 으로 일부 차단
    return 0;
}

// C에는 자동 destructor 없음 — 수동으로 RAII 흉내
// goto cleanup 패턴

#include <stdio.h>
#include <stdlib.h>

int do_work(void) {
    char *buf1 = NULL, *buf2 = NULL;
    FILE *fp = NULL;
    int rc = -1;

    buf1 = malloc(1024);
    if (!buf1) goto cleanup;

    buf2 = malloc(2048);
    if (!buf2) goto cleanup;

    fp = fopen("data.txt", "r");
    if (!fp) goto cleanup;

    // 작업...
    rc = 0;

cleanup:
    free(buf1);  // free(NULL)은 안전
    free(buf2);
    if (fp) fclose(fp);
    return rc;
}

// C++의 unique_ptr은 자동 RAII
// std::unique_ptr<int> p(new int(42));
// 함수 종료 시 자동 delete


// C에서 비슷하게 — GCC __attribute__((cleanup))
#include <stdio.h>
#include <stdlib.h>

void auto_free(void *p) {
    void **pp = (void**)p;
    free(*pp);
}

#define SCOPED_PTR __attribute__((cleanup(auto_free)))

int main(void) {
    SCOPED_PTR char *p = malloc(100);
    // 함수 종료 시 자동 free

    return 0;
}

gcc -fsanitize=address -g uaf.c -o uaf
./uaf

# 출력:
# ==12345== ERROR: AddressSanitizer: heap-use-after-free
# READ of size 1 at 0x... thread T0
#     #0 0x... in main uaf.c:10
#
# 0x... is located 0 bytes inside of 16-byte region [0x..., 0x...)
# freed by thread T0 here:
#     #0 0x... in __interceptor_free
#     #1 0x... in main uaf.c:7
# previously allocated by thread T0 here:
#     #0 0x... in __interceptor_malloc
#     #1 0x... in main uaf.c:5

Chrome UAF (자주 발생):
- CVE-2023-2033 V8 type confusion
- CVE-2023-3079 V8 UAF
방어: V8 sandbox, MiraclePtr (Chromium의 dangling pointer 방지)


Firefox UAF:
- CVE-2023-32205 SpiderMonkey JIT
방어: ASan + Fuzzing + RUST 일부 모듈


브라우저들의 대응:
- Chrome → Rust 일부 도입
- Mozilla → Rust 적극 채택 (Servo, Stylo)
- Apple → Swift 우선