C เขียนโค้ดที่ปลอดภัยจากการโจมตี



ช่องโหว่ระดับ CVE ในซอฟต์แวร์ C ส่วนใหญ่มาจากรูปแบบเดิม ๆ ไม่กี่แบบ รู้แล้วเลี่ยงได้

1. buffer overflow

// ❌ ช่องโหว่
void greet(const char *name)
{
    char buf[64];
    strcpy(buf, name);                  // name ยาว > 63 → เขียนทะลุ stack
    printf("Hello, %s\n", buf);
}

buffer บน stack อยู่ติดกับ saved return address — เขียนทะลุไปทับได้ ผู้โจมตีใส่ค่าที่ทำให้โปรแกรมกระโดดไปรันโค้ดของเขา (“stack smashing” — Morris worm 1988, และอีกนับไม่ถ้วน)

แก้: ใช้ฟังก์ชันที่จำกัดขนาดปลายทางเสมอ

// ✅
void greet(const char *name)
{
    char buf[64];
    snprintf(buf, sizeof(buf), "%s", name);   // ตัดที่ 63 + ปิด '\0'
    printf("Hello, %s\n", buf);
}
อันตรายใช้แทน
gets(buf)ถูกลบจากมาตรฐานแล้ว — fgets(buf, sizeof buf, stdin)
strcpy(d, s)snprintf(d, sizeof d, "%s", s)
strcat(d, s)snprintf ต่อเนื่อง หรือ strlcat (BSD)
sprintf(d, ...)snprintf(d, sizeof d, ...)
scanf("%s", buf)scanf("%63s", buf) หรือ fgets + sscanf

sizeof buf ใช้ได้เฉพาะเมื่อ buf เป็นอาร์เรย์จริง — ถ้าเป็น pointer ต้องส่งขนาดมาด้วย

2. off-by-one

char buf[10];
for (int i = 0; i <= 10; i++) buf[i] = 'x';   // เขียน buf[10] — เกิน 1 ไบต์

strncpy(dst, src, sizeof(dst));                 // ถ้า src ยาว = sizeof(dst) → ไม่มีที่ให้ '\0'
dst[sizeof(dst) - 1] = '\0';                    // ต้องปิดเอง

จอง +1 สำหรับ '\0' เสมอ:

char *copy = malloc(strlen(s) + 1);            // ไม่ใช่ strlen(s)
strcpy(copy, s);

3. format string vulnerability

// ❌ ช่องโหว่
void log_error(const char *user_input)
{
    printf(user_input);                 // ถ้า user_input มี "%s%s%s%n" = อ่าน/เขียนหน่วยความจำ!
}

ผู้โจมตีใส่ %x %x %x อ่าน stack, %n เขียนหน่วยความจำ (จำนวน char ที่พิมพ์ไปยังที่อยู่บน stack)

แก้: input เป็น argument ไม่ใช่ format

// ✅
void log_error(const char *user_input)
{
    printf("%s", user_input);           // หรือ fputs(user_input, stdout)
}

-Wformat-security เตือน printf(variable) ที่ไม่มี format literal

4. integer overflow ก่อน malloc

// ❌ ช่องโหว่
void *make_buffer(size_t count, size_t size)
{
    return malloc(count * size);        // count * size อาจ overflow → จองน้อยกว่าที่คิด
}

// ผู้เรียก: make_buffer(0x100000000, 0x100000000) บน 64-bit
// → count * size wraps เป็นค่าเล็ก → malloc สำเร็จด้วยขนาดเล็ก
// → โค้ดที่เขียนตาม count เขียนทะลุ heap

แก้: เช็ค overflow ก่อนคูณ หรือใช้ calloc (เช็คให้)

// ✅ วิธี A
void *make_buffer(size_t count, size_t size)
{
    if (size != 0 && count > SIZE_MAX / size) {
        return NULL;                    // จะ overflow
    }
    return malloc(count * size);
}

// ✅ วิธี B
void *buf = calloc(count, size);        // calloc เช็ค count*size overflow ให้ + ล้าง 0

5. TOCTOU (time-of-check to time-of-use)

// ❌ ช่องโหว่
if (access("/tmp/data", W_OK) == 0) {   // เช็คสิทธิ์
    // ← ผู้โจมตีสลับไฟล์เป็น symlink ตรงนี้
    FILE *f = fopen("/tmp/data", "w");   // ใช้ — อาจเขียนไฟล์อื่น
}

fopen(path, "w") ตัด (truncate) ไฟล์ทิ้งทันทีที่เปิด — ถ้าเช็ค fd ทีหลังแล้วพบว่าไม่ปลอดภัย ก็สายไปแล้ว ข้อมูลเดิมหายไป ต้องเปิดแบบไม่ truncate ไม่ตาม symlink เช็คจาก fd ก่อน แล้วค่อยล้าง+เขียน

// ✅ POSIX — ตรวจทุกค่าคืน และจัดการ ownership ของ fd จนครบ
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

int fd = open("/tmp/data", O_RDWR | O_NOFOLLOW);   // ไม่มี O_TRUNC, ไม่ตาม symlink (เฉพาะชิ้นสุดท้ายของ path)
if (fd < 0) {
    perror("open");
    return -1;
}

struct stat st;
if (fstat(fd, &st) != 0 || !S_ISREG(st.st_mode) || st.st_uid != getuid()) {
    close(fd);                  // ไม่ปลอดภัย — ยกเลิก ไฟล์เดิมยังอยู่ครบ
    return -1;
}

if (ftruncate(fd, 0) != 0) {   // ปลอดภัยแล้วค่อยล้าง — เช็คด้วย
    perror("ftruncate");
    close(fd);
    return -1;
}

FILE *f = fdopen(fd, "w");     // ครอบ fd ด้วย stdio
if (f == NULL) {
    perror("fdopen");
    close(fd);                  // fdopen ล้มเหลว → fd ยังเป็นของเรา ต้อง close เอง
    return -1;
}
// ตั้งแต่นี้ fd เป็นของ f แล้ว — ปิดด้วย fclose(f) เท่านั้น (อย่า close(fd) ซ้ำ)

O_NOFOLLOW กันแค่ องค์ประกอบสุดท้าย ของ path เป็น symlink ไม่ได้การันตีว่า /tmp หรือไดเรกทอรีแม่ทุกชั้นเชื่อถือได้ — ตัวอย่างนี้ยังต้อง assume ว่า parent directory ปลอดภัย (เช่นเป็นของเราและ sticky bit ตั้งไว้) งานที่เข้มกว่านั้นใช้ openat เดินทีละชั้นจาก fd ที่ตรวจแล้ว

6. command injection

// ❌ ช่องโหว่
char cmd[256];
snprintf(cmd, sizeof(cmd), "convert %s output.png", user_filename);
system(cmd);                            // user_filename = "x.jpg; rm -rf ~"

// ✅ ใช้ exec family (ไม่ผ่าน shell) — POSIX
execlp("convert", "convert", user_filename, "output.png", (char *)NULL);

system() และ popen() ส่งผ่าน shell — argument ถูกตีความ ใช้ execvp family ที่รับ argument เป็น array (ไม่มี shell parsing)

exec กันแค่ shell parsing ไม่กัน option injection — ถ้า user_filename ขึ้นต้นด้วย - โปรแกรมปลายทางอาจตีความเป็น flag ป้องกันด้วยการใส่ -- คั่น (execlp("convert", "convert", "--", user_filename, ...)) หรือ validate ว่าชื่อไฟล์ไม่ขึ้นต้นด้วย - และไม่มี path traversal ตามกฎของโปรแกรมนั้น ๆ

7. ส่ง struct ดิบออก network/ไฟล์ — ข้อมูลรั่วและอ่านไม่ตรง

// ❌ ส่ง struct ดิบทั้งก้อน
struct Packet p;
p.type = 1;
p.value = 42;
// p.reserved และ padding ระหว่าง field ไม่ได้ตั้ง — มีข้อมูลเก่าจาก stack (อาจ sensitive)
send(sock, &p, sizeof(p), 0);

struct p = {0}; ก่อนช่วยลดข้อมูลรั่วได้ แต่ทางที่ถูกคือไม่ส่ง struct ดิบเลย — layout, ขนาด/ตำแหน่ง padding, และ endianness ต่างกันในแต่ละคอมไพเลอร์/สถาปัตยกรรม ฝั่งรับที่ต่างเครื่องมีสิทธิ์อ่านผิด มาตรฐาน C ก็ไม่รับประกันว่า = {0} จะ zero ทุก padding bit ในทุกกรณี

// ✅ serialize ทีละ field ลง buffer ที่ layout กำหนดเอง
#include <stdint.h>
#include <string.h>
#include <arpa/inet.h>   // htonl — POSIX

unsigned char buf[8] = {0};              // อาร์เรย์ ไม่มี padding
buf[0] = (unsigned char)p.type;
buf[1] = 0;                              // reserved — เขียนให้ชัด
uint32_t v = htonl((uint32_t)p.value);   // byte order คงที่ (big-endian)
memcpy(buf + 4, &v, sizeof(v));
send_all(sock, buf, sizeof(buf));        // ไม่มี padding ไม่มีข้อมูลรั่ว อ่านฝั่งไหนก็ตรง

send() (และ write()) บน stream socket ส่งได้ไม่ครบในครั้งเดียว — คืนจำนวนไบต์ที่ส่งจริง ต้องวน send ต่อจากตำแหน่งที่ค้างจนครบ (send_all ข้างบนคือ helper ที่ทำแบบนั้น) ฝั่งรับก็อ่านกลับทีละ field แบบเดียวกัน (ntohl ฯลฯ) และต้องวน recv จนได้ครบเช่นกัน

เครื่องมือและ flag ป้องกัน

# ตอน dev/test
gcc -std=c17 -Wall -Wextra -Wformat=2 -Wconversion \
    -fsanitize=address,undefined -g prog.c -o prog

# ตอน build production (mitigation ระดับ OS)
gcc -O2 -D_FORTIFY_SOURCE=2 \
    -fstack-protector-strong \
    -fPIE -pie \
    -Wl,-z,relro,-z,now \
    prog.c -o prog
  • _FORTIFY_SOURCE=2 — libc เช็คขนาด buffer ใน strcpy/memcpy/sprintf ตอน runtime
  • -fstack-protector-strong — ใส่ canary ตรวจ stack overflow
  • -fPIE -pie + relro — ASLR + read-only GOT

checklist ก่อน commit

  • [ ] ไม่มี gets, strcpy, strcat, sprintf, scanf("%s") แบบไร้ขอบ
  • [ ] ทุก printf/fprintf มี format literal (ไม่ใช่ตัวแปร)
  • [ ] เช็ค integer overflow ก่อน malloc(a * b) หรือใช้ calloc
  • [ ] ทุก buffer มีที่สำหรับ '\0' (+1)
  • [ ] validate ทุก input: ความยาว, ช่วง, รูปแบบ
  • [ ] ไม่ใช้ system()/popen() กับ input — ใช้ exec family + -- คั่น argument ที่มาจากผู้ใช้
  • [ ] ไม่ส่ง struct ดิบออก network/ไฟล์ — serialize ทีละ field ด้วย byte order คงที่
  • [ ] วน send/write/recv/read จนครบ (คืนได้ไม่ครบในครั้งเดียว)
  • [ ] TOCTOU: เปิด fd ก่อน แล้ว fstat ตรวจ, เช็คค่าคืนของ ftruncate/fdopen, ปิด fd ให้ครบทุก path
  • [ ] รัน -fsanitize=address,undefined ผ่าน
  • [ ] เช็คค่าคืนของ malloc, fopen, read, fread

เรื่องที่คนมักพลาด

  • snprintf(buf, sizeof(buf), ...) เมื่อ buf เป็น pointer — sizeof = 8 ไม่ใช่ขนาด buffer
  • คิดว่า strncpy ปลอดภัย — ไม่ปิด '\0' ถ้า src ยาวเกิน; ต้องปิดเอง
  • validate ความยาว input หลัง copy แล้ว — สายเกินไป เช็คก่อน
  • printf(msg) เมื่อ msg มาจากไฟล์ config / log — ยังเป็น format string bug
  • malloc(n * sizeof(T)) โดย n จาก input — overflow เช็คหรือใช้ calloc
  • เชื่อว่า sanitizer/canary จับได้ทุกอย่าง — เป็นชั้นป้องกัน ไม่ใช่ข้ออ้างเขียนโค้ดไม่ระวัง

สรุป

  • buffer overflow: ห้าม gets/strcpy/strcat/sprintf/scanf("%s") ไร้ขอบ — ใช้ fgets/snprintf/%63s; sizeof buf เฉพาะอาร์เรย์จริง
  • format string bug: printf("%s", input) ไม่ใช่ printf(input) — -Wformat-security
  • integer overflow ก่อน malloc: เช็ค count > SIZE_MAX / size หรือใช้ calloc
  • command injection: execvp family ไม่ system()/popen() กับ input
  • ข้อมูลรั่ว / อ่านไม่ตรงเครื่อง: ไม่ส่ง struct ดิบออก network/ไฟล์ — serialize ทีละ field ด้วย byte order คงที่
  • build production ด้วย -D_FORTIFY_SOURCE=2 -fstack-protector-strong -fPIE -pie
  • checklist + -fsanitize=address,undefined ทุกครั้ง

จบเฟสขั้นสูง บทถัดไปเข้าเฟสโปรเจกต์ เริ่มที่โปรแกรม to-do แบบ CLI ที่ใช้ struct, file I/O และ argv