0Pricing
Cyber Security Academy · บทเรียน

บัฟเฟอร์ล้นบนสแตก

ทำความเข้าใจโครงสร้างสแตก การล้นของ EIP/RIP และเขียนช่องโหว่ที่ใช้งานได้สำหรับไบนารี C ที่มีช่องโหว่

บัฟเฟอร์ล้นบนสแตก เป็นบทเรียน Cyber Security Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Cyber Security Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Cyber Security Academy มีบทเรียนทั้งหมด 4 บทเรียน

บัฟเฟอร์ล้นคืออะไร

บัฟเฟอร์ล้น เกิดขึ้นเมื่อมีการเขียนข้อมูลลงในบัฟเฟอร์มากกว่าความจุที่รองรับ ข้อมูลส่วนเกินจะเขียนทับหน่วยความจำที่อยู่ติดกัน ซึ่งอาจทำให้โครงสร้างควบคุมเสียหายและเปลี่ยนเส้นทางการทำงานของโปรแกรม

โครงสร้างหน่วยความจำสแตก

สแตกการเรียกใช้ประกอบด้วย ตัวแปรภายใน (บัฟเฟอร์) ตัวชี้เฟรมที่บันทึกไว้ (SFP) และที่อยู่ส่งคืน (RIP/EIP) ซึ่งเป็นตำแหน่งที่การทำงานจะดำเนินต่อหลังจากฟังก์ชันส่งคืนค่า การทำให้บัฟเฟอร์ภายในล้นอาจเขียนทับที่อยู่ส่งคืนได้

การเขียนทับสแตกแบบคลาสสิก

หากโปรแกรมเรียกใช้ gets() หรือ strcpy() โดยไม่ตรวจสอบความยาว ผู้โจมตีสามารถป้อนข้อมูลให้มีจำนวนไบต์มากพอที่จะเติมบัฟเฟอร์ และเขียนทับที่อยู่ส่งคืนด้วยที่อยู่ของเชลล์โค้ดหรือแกดเจ็ตที่เป็นประโยชน์

// Vulnerable C code:
void vuln() {
  char buf[64];
  gets(buf);  // No bounds checking!
}

การค้นหาระยะเหลื่อม

หาจำนวนไบต์ที่ต้องใช้เพื่อไปถึงที่อยู่ส่งคืนโดยใช้การสร้างรูปแบบ:

# Generate a cyclic pattern:
python3 -c "from pwn import *; print(cyclic(200))" | ./vuln
# After crash, find offset:
python3 -c "from pwn import *; print(cyclic_find(0x61616166))"

การป้องกัน: ค่าป้องกันสแตก

ค่าป้องกันสแตก คือค่าสุ่มที่วางไว้ระหว่างตัวแปรภายในกับที่อยู่ส่งคืนที่บันทึกไว้ ก่อนส่งคืนค่า ระบบจะตรวจสอบค่าป้องกันสแตก หากถูกเขียนทับ โปรแกรมจะยุติการทำงาน ต้องหลีกเลี่ยงกลไกนี้จึงจะใช้ประโยชน์จากบัฟเฟอร์ล้นแบบคลาสสิกได้

การป้องกัน: ASLR

การสุ่มเค้าโครงพื้นที่แอดเดรส (ASLR) จะสุ่มแอดเดรสเริ่มต้นของสแตก ฮีป และไลบรารีใหม่ทุกครั้งที่ทำงาน หากไม่มีการรั่วไหลของแอดเดรสปัจจุบัน การเดาว่าจะกระโดดไปที่ใดแทบเป็นไปไม่ได้บนระบบ 64 บิต

การป้องกัน: NX/DEP

NX (ป้องกันการเรียกใช้) / DEP (ป้องกันการเรียกใช้ข้อมูล) จะกำหนดให้สแตกไม่สามารถเรียกใช้ได้ โค้ดเชลล์ที่แทรกเข้าไปในบัฟเฟอร์จึงไม่สามารถเรียกใช้ได้โดยตรง ทำให้ผู้โจมตีต้องใช้การเขียนโปรแกรมแบบอิงการคืนค่า (ROP)

การรั่วไหลของแอดเดรส

ในการเอาชนะ ASLR ผู้โจมตีจำเป็นต้องมีช่องโหว่ที่ทำให้ข้อมูลรั่วไหล เช่น ช่องโหว่สตริงรูปแบบ การอ่านข้อมูลเกินขอบเขตจากฮีป (เช่น Heartbleed) หรือพอยน์เตอร์ที่อ่านได้ในฟังก์ชันที่ถูกโจมตี แอดเดรสที่รั่วไหลเพียงหนึ่งรายการจะเปิดเผยออฟเซ็ต และทำให้คำนวณแอดเดรสอื่น ๆ ได้

การเขียนช่องโหว่พื้นฐาน

บัฟเฟอร์ล้นบนสแตกแบบ 32 บิตที่ไม่มีการป้องกัน:

# Python exploit skeleton (pwntools):
from pwn import *
p = process("./vuln")
offset = 76
shellcode = asm(shellcraft.sh())
payload = shellcode + b"A" * (offset - len(shellcode)) + p32(stack_addr)
p.sendline(payload)
p.interactive()

เทคนิคเร็ตทูไลบ์ซี

เร็ตทูไลบ์ซีหลบเลี่ยง NX ด้วยการคืนค่าเข้าไปยังฟังก์ชันของ libc (เช่น system()) แทนการใช้โค้ดเชลล์ ผู้โจมตีจะเขียนทับแอดเดรสคืนค่าด้วยแอดเดรสของ system และส่ง "/bin/sh" เป็นอาร์กิวเมนต์

เครื่องมือสำหรับพัฒนาช่องโหว่

เครื่องมือสำคัญ:

  • ไพดับเบิลยูเอ็นทูลส์ — ไลบรารีไพธอนสำหรับสร้างช่องโหว่
  • GDB + เครื่องมือช่วยสร้างช่องโหว่ — ตัวดีบักพร้อมตัวช่วยสร้างช่องโหว่
  • เครื่องมือตรวจสอบความปลอดภัย — แสดงการป้องกันของไบนารี
  • เครื่องมือค้นหาแกดเจ็ตแบบอาร์โอพี — ค้นหาเชน ROP
checksec --file=./vuln

ตรวจสอบอย่างรวดเร็ว: บัฟเฟอร์ล้นบนสแตก

มาตรการลดความเสี่ยงใดวางค่าที่สุ่มไว้ระหว่างตัวแปรภายในเครื่องกับแอดเดรสคืนค่าที่บันทึกไว้ และยุติโปรแกรมหากค่านั้นถูกเขียนทับ

สรุปบทเรียน

บัฟเฟอร์ล้นบนสแตกจะเขียนทับแอดเดรสคืนค่าโดยเติมข้อมูลลงในบัฟเฟอร์จนเกินขอบเขต การป้องกันประกอบด้วยแคนารีของสแตก (ตรวจจับการเขียนทับ) ASLR (สุ่มแอดเดรส) และ NX/DEP (ทำให้สแตกไม่สามารถเรียกใช้ได้) เทคนิคเร็ตทูไลบ์ซีหลบเลี่ยง NX ได้ การรั่วไหลของข้อมูลเอาชนะ ASLR ได้ และไลบรารีไพธอนสำหรับสร้างช่องโหว่ช่วยให้การพัฒนาช่องโหว่ทำได้รวดเร็วยิ่งขึ้น

คำถามที่พบบ่อย

บทเรียน “บัฟเฟอร์ล้นบนสแตก” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “บัฟเฟอร์ล้นบนสแตก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Cyber Security Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Cyber Security Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “บัฟเฟอร์ล้นบนสแตก”

ทำความเข้าใจโครงสร้างสแตก การล้นของ EIP/RIP และเขียนช่องโหว่ที่ใช้งานได้สำหรับไบนารี C ที่มีช่องโหว่ คุณปฏิบัติ Cyber Security Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Cyber Security Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Cyber Security Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “บัฟเฟอร์ล้นบนสแตก” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Cyber Security Academy นี้ได้ไหม

ได้ บทเรียน Cyber Security Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. บัฟเฟอร์ล้นบนสแตก
  2. การเขียนโปรแกรมแบบ Return-Oriented (ROP)
  3. ช่องโหว่รูปแบบสตริง
  4. การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป
← กลับไปที่ Cyber Security Academy