การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป
ทำความเข้าใจกลไกภายในของ glibc malloc เงื่อนไข use-after-free และเทคนิคการโปรยฮีป
การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป เป็นบทเรียน Cyber Security Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Cyber Security Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Cyber Security Academy มีบทเรียนทั้งหมด 4 บทเรียน
ฮีป
ฮีป คือหน่วยความจำแบบไดนามิกที่จัดสรรขณะทำงานผ่าน malloc()/free()/new/delete ฮีปแตกต่างจากสแตกตรงที่เค้าโครงของฮีปถูกกำหนดโดยรูปแบบการจัดสรรและคืนการจัดสรร ไม่ใช่สแตกการเรียกใช้ฟังก์ชัน ช่องโหว่ของฮีปพบได้บ่อยในเบราว์เซอร์ ตัวแยกวิเคราะห์ และดีมอนเครือข่าย
การใช้งานหลังคืนหน่วยความจำ (UAF)
ช่องโหว่การใช้งานหลังคืนหน่วยความจำเกิดขึ้นเมื่อโปรแกรมยังคงใช้พื้นที่หน่วยความจำหลังจากคืนพื้นที่นั้นแล้ว หากพื้นที่ที่คืนแล้วถูกจัดสรรใหม่ด้วยข้อมูลที่ผู้โจมตีควบคุม โปรแกรมจะทำงานกับข้อมูลของผู้โจมตีผ่านพอยน์เตอร์เก่าที่ยังคงค้างอยู่
ตัวอย่าง UAF
รูปแบบ UAF:
// Vulnerable C code:
struct Object *obj = malloc(sizeof(*obj));
free(obj);
// Later, attacker causes a new malloc to fill the freed region
// with their data...
obj->method(); // now calls attacker's function pointer!การจัดวางฮีปอย่างเป็นระบบ
การจัดวางฮีปอย่างเป็นระบบ (หรือการปรับแต่งฮีป) คือเทคนิคการจัดการตัวจัดสรรฮีปเพื่อวางอ็อบเจ็กต์ไว้ในตำแหน่งที่กำหนด ทำให้สามารถนำหน่วยความจำที่คืนแล้วกลับมาใช้ใหม่ได้อย่างควบคุม ผู้โจมตีจะจัดรูปฮีปด้วยการกระตุ้นการจัดสรรและการคืนการจัดสรรตามลำดับที่แม่นยำ
การโปรยข้อมูลลงฮีป
การโปรยข้อมูลลงฮีป คือการจัดสรรข้อมูลจำนวนมากที่ผู้โจมตีควบคุมได้ (โค้ดเชลล์ + ทางเลื่อน NOP) ให้กระจายทั่วฮีป เมื่อมีข้อมูลเติมเต็มฮีปเป็นจำนวนมาก พอยน์เตอร์ที่ไม่ถูกต้องก็มีโอกาสสูงที่จะชี้ไปยังข้อมูลของผู้โจมตี มักใช้ร่วมกับช่องโหว่ UAF หรือข้อผิดพลาดจากความสับสนของชนิดข้อมูล
// JavaScript heap spray:
var spray = [];
for(var i = 0; i < 100000; i++) {
spray[i] = unescape("%90%90...shellcode...");
}การคืนหน่วยความจำซ้ำสองครั้ง
การคืนหน่วยความจำซ้ำสองครั้ง เกิดขึ้นเมื่อคืนพื้นที่หน่วยความจำสองครั้ง การคืนครั้งที่สองจะทำให้ข้อมูลเมตาของตัวจัดสรรฮีปเสียหาย (พอยน์เตอร์ของรายการพื้นที่ว่าง) และอาจทำให้ผู้โจมตีควบคุมตำแหน่งที่จัดสรรครั้งถัดไปได้ ซึ่งนำไปสู่การเขียนที่แอดเดรสใด ๆ
บัฟเฟอร์ล้นบนฮีป
เช่นเดียวกับบัฟเฟอร์ล้นบนสแตก บัฟเฟอร์ล้นบนฮีปจะเขียนข้อมูลเลยจุดสิ้นสุดของพื้นที่ที่จัดสรรบนฮีป แต่ต่างจากบัฟเฟอร์ล้นบนสแตกตรงที่เป้าหมายมักเป็นข้อมูลเมตาของฮีป (ขนาด พอยน์เตอร์เดินหน้าและถอยหลัง) หรือพื้นที่จัดสรรข้างเคียงที่มีพอยน์เตอร์ฟังก์ชันหรือพอยน์เตอร์ตารางฟังก์ชันเสมือน
ความสับสนของชนิดข้อมูล
ความสับสนของชนิดข้อมูล เกิดขึ้นเมื่อใช้พื้นที่หน่วยความจำที่จัดสรรไว้เป็นชนิดหนึ่งเสมือนเป็นอีกชนิดหนึ่ง พบได้บ่อยในกลไก JavaScript และโค้ด C++ หากผู้โจมตีควบคุมลำดับการจัดสรรได้ ก็สามารถทำให้กลไกมองข้อมูลของผู้โจมตีเป็นอ็อบเจ็กต์ที่เชื่อถือได้
กลไกภายในของพีทีมัลลอคและทีซีมัลลอค
การทำความเข้าใจตัวจัดสรรฮีปช่วยในการพัฒนาช่องโหว่ ตัวจัดสรรพีทีมัลลอคของจีไลบ์ซีใช้บินต่าง ๆ (ไม่เรียงลำดับ ขนาดเล็ก และขนาดใหญ่) รวมถึงบินแบบเร็ว ทีแคช (แคชต่อเธรด) เป็นแหล่งจัดสรรลำดับแรก ช่องโหว่มักมุ่งโจมตีการทำให้บินเสียหายเพื่อควบคุมแอดเดรสของการจัดสรรในอนาคต
มาตรการลดความเสี่ยง
มาตรการลดความเสี่ยงจากการโจมตีฮีป:
- การสุ่มฮีป (เป็นส่วนหนึ่งของ ASLR) — สุ่มแอดเดรสเริ่มต้นของฮีป
- การยกเลิกการเชื่อมโยงอย่างปลอดภัย — ตรวจสอบพอยน์เตอร์เดินหน้าและถอยหลังก่อนยกเลิกการเชื่อมโยง
- การตรวจจับการวางยาพิษในทีแคช — เพิ่มเข้ามาในจีไลบ์ซี 2.32
- การทำให้พอยน์เตอร์ซับซ้อน — เข้ารหัสพอยน์เตอร์ที่จัดเก็บไว้ในทีแคช
- ภาษาที่ปลอดภัยด้านหน่วยความจำ — รัสต์กำจัด UAF ได้ตั้งแต่เวลาคอมไพล์
ช่องโหว่ฮีปของเบราว์เซอร์
ช่องโหว่แบบไม่เคยพบมาก่อนส่วนใหญ่ในเบราว์เซอร์เกี่ยวข้องกับช่องโหว่ฮีปในกลไก JavaScript (วี8, SpiderMonkey) เบราว์เซอร์สมัยใหม่ใช้เชนหลบหนีจากแซนด์บ็อกซ์หลายชั้น: ช่องโหว่ฮีปในโพรเซสเรนเดอร์ → หลบหนีไปยังโพรเซสเบราว์เซอร์ → ยกระดับสิทธิ์ใน OS แต่ละขั้นตอนต้องใช้เทคนิคของตนเอง
ตรวจสอบอย่างรวดเร็ว: การโจมตีฮีป
ช่องโหว่ใดทำให้ผู้โจมตีควบคุมการทำงานของโปรแกรมได้ โดยใช้พอยน์เตอร์เก่าชี้ไปยังหน่วยความจำที่ถูกคืนแล้วและจัดสรรใหม่ด้วยข้อมูลของผู้โจมตี
สรุปบทเรียน
ช่องโหว่ฮีป — UAF การคืนหน่วยความจำซ้ำสองครั้ง บัฟเฟอร์ล้นบนฮีป และความสับสนของชนิดข้อมูล — ล้วนใช้ประโยชน์จากการจัดการหน่วยความจำแบบไดนามิกที่ผิดพลาด การใช้งานหลังคืนหน่วยความจำเป็นประเภทช่องโหว่ที่ถูกใช้โจมตีอย่างแพร่หลายที่สุดในปัจจุบัน การโปรยข้อมูลลงฮีปช่วยเพิ่มโอกาสให้การทำงานไปตกลงบนข้อมูลของผู้โจมตี มาตรการลดความเสี่ยง ได้แก่ ASLR การยกเลิกการเชื่อมโยงอย่างปลอดภัย และการทำให้พอยน์เตอร์ซับซ้อน ภาษาที่ปลอดภัยด้านหน่วยความจำอย่างรัสต์กำจัดช่องโหว่ประเภทเหล่านี้ได้ทั้งหมด
คำถามที่พบบ่อย
บทเรียน “การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Cyber Security Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Cyber Security Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป”
ทำความเข้าใจกลไกภายในของ glibc malloc เงื่อนไข use-after-free และเทคนิคการโปรยฮีป คุณปฏิบัติ Cyber Security Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Cyber Security Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Cyber Security Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Cyber Security Academy นี้ได้ไหม
ได้ บทเรียน Cyber Security Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- บัฟเฟอร์ล้นบนสแตก
- การเขียนโปรแกรมแบบ Return-Oriented (ROP)
- ช่องโหว่รูปแบบสตริง
- การใช้ประโยชน์จากฮีป: Use-After-Free และการโปรยฮีป