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 ให้ + ล้าง 05. 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 — ใช้execfamily +--คั่น 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 bugmalloc(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:
execvpfamily ไม่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