Ethical Hacking Academy · บทเรียน

หน่วยความจำและสแตก

การทำงานของบัฟเฟอร์ล้น

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

โครงสร้างหน่วยความจำของกระบวนการ

เมื่อโปรแกรมทำงาน ระบบปฏิบัติการจะจัดโครงสร้างหน่วยความจำให้โปรแกรม โดยแบ่งเป็นส่วนต่าง ๆ ได้แก่ ส่วนข้อความ (โค้ด), ส่วนข้อมูล/BSS (ตัวแปรโกลบอล), ฮีป (การจัดสรรแบบไดนามิก) และ สแตก

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

สแตกคืออะไร

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

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

เฟรมของสแตก

การเรียกฟังก์ชันแต่ละครั้งจะสร้าง เฟรมของสแตก โดยทั่วไปเฟรมจะประกอบด้วยตัวแปรภายใน ตัวชี้ฐานที่บันทึกไว้ (EBP) และ แอดเดสส่งคืน (EIP ที่บันทึกไว้)

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

รีจิสเตอร์สำคัญ

บน x86 แบบ 32 บิต รีจิสเตอร์สำคัญมีดังนี้:

ESP: ตัวชี้สแตก ซึ่งชี้ไปยังด้านบนของสแตก
EBP: ตัวชี้ฐาน ซึ่งเป็นจุดยึดของเฟรมปัจจุบัน
EIP: ตัวชี้คำสั่ง ซึ่งเก็บแอดเดสของคำสั่งถัดไป

หากคุณควบคุม EIP ได้ คุณก็จะควบคุมลำดับการทำงานได้

บัฟเฟอร์คืออะไร

บัฟเฟอร์ คือบล็อกหน่วยความจำขนาดคงที่ เช่น อาร์เรย์อักขระภายใน โปรแกรมคาดหวังว่าข้อมูลจะมีขนาดพอดีกับบัฟเฟอร์

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

char buffer[64];
strcpy(buffer, user_input); // no bounds check

โอเวอร์โฟลว์

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

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

ฟังก์ชันอันตราย

โอเวอร์โฟลว์มักเกิดจากฟังก์ชันภาษา C ที่ไม่ปลอดภัยและไม่ตรวจสอบความยาว:

strcpy, strcat, sprintf, gets

ทางเลือกที่ปลอดภัยกว่าอย่าง strncpy หรือ snprintf จะรับขีดจำกัดขนาด แต่โค้ดเก่ามักเต็มไปด้วยฟังก์ชันอันตรายเหล่านี้

gets(buffer); // never use: no length limit at all

การเขียนทับ EIP ให้อะไรแก่คุณ

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

หากคุณชี้ EIP ไปยังโค้ดเครื่องที่ฉีดเข้าไปเอง (เชลล์โค้ด) CPU จะทำงานด้วยสิทธิ์ของโปรแกรม

การระบุแอดเดรสแบบลิตเทิลเอนเดียน

x86 เป็นแบบ ลิตเทิลเอนเดียน: ค่าหลายไบต์จะจัดเก็บไบต์ที่มีนัยสำคัญน้อยที่สุดก่อน หากต้องการเขียนทับแอดเดรสย้อนกลับด้วย 0x080414C3 คุณต้องเขียนไบต์กลับลำดับกัน

การระบุเอนเดียนผิดเป็นข้อผิดพลาดที่ผู้เริ่มต้นมักทำ และทำให้การโจมตีล้มเหลวโดยไม่มีข้อความแจ้ง

address 0x080414C3 -> bytes \xc3\x14\x04\x08

การป้องกันสมัยใหม่

ระบบสมัยใหม่เพิ่มกลไกป้องกันที่ทำให้การโจมตีซับซ้อนขึ้น:

DEP/NX: ทำเครื่องหมายว่าสแตกไม่สามารถประมวลผลได้
ASLR: สุ่มแอดเดรสหน่วยความจำ
แคนารีของสแตก: ตรวจจับการเขียนทับก่อนการคืนกลับ

หลักสูตรนี้มุ่งเน้นกรณีคลาสสิก (ปิดการป้องกัน) เพื่อสอนพื้นฐาน

เหตุใดเรื่องนี้ยังสำคัญ

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

การเข้าใจกรณีพื้นฐานอย่างถ่องแท้ยังเป็นข้อกำหนดเบื้องต้นสำหรับเทคนิคขั้นสูงอย่าง ROP ซึ่งหลบเลี่ยงมาตรการลดความเสี่ยงสมัยใหม่

ตรวจสอบอย่างรวดเร็ว

ลองทบทวนว่าท้ายที่สุดแล้วผู้โจมตีต้องการควบคุมค่าใด

สรุปทบทวน

ขณะนี้คุณเข้าใจพื้นฐานแล้ว:

สแตกจัดเก็บตัวแปรภายใน EBP ที่บันทึกไว้ และแอดเดรสย้อนกลับ และขยายลงด้านล่าง
ESP, EBP, EIP เป็นเรจิสเตอร์สำคัญของ x86 การควบคุม EIP คือการควบคุมการทำงาน
ฟังก์ชันที่ไม่ปลอดภัยอย่าง strcpy และ gets ทำให้เกิดโอเวอร์โฟลว์
x86 เป็นแบบ ลิตเทิลเอนเดียน ส่วนกลไกป้องกันสมัยใหม่คือ DEP, ASLR และแคนารี

ถัดไปคุณจะทำฟัซโปรแกรมเพื่อค้นหาออฟเซ็ตที่ทำให้โปรแกรมหยุดทำงาน

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

บทเรียน “หน่วยความจำและสแตก” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “หน่วยความจำและสแตก”

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

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

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

บทเรียน “หน่วยความจำและสแตก” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Ethical Hacking Academy