เจาะลึกการแฮกไบนารี: เมื่อช่องโหว่กลายเป็นอาวุธและความปลอดภัยต้องเรียนรู้ที่จะปรับตัว

เจาะลึกการแฮกไบนารี: เมื่อช่องโหว่กลายเป็นอาวุธและความปลอดภัยต้องเรียนรู้ที่จะปรับตัว

โลกของการโจมตีทางไซเบอร์นั้นซับซ้อนและเต็มไปด้วยเทคนิคมากมาย หนึ่งในสายสำคัญคือ Binary Exploitation หรือการใช้ประโยชน์จากช่องโหว่ในโค้ดระดับต่ำของโปรแกรมโดยตรง ซึ่งมักจะเกี่ยวข้องกับการควบคุมหน่วยความจำของระบบ บทความนี้จะพาคุณไปสำรวจสามแนวคิดสำคัญที่นักโจมตีใช้และนักป้องกันควรรู้ นั่นคือ Format String Exploits, GOT/PLT และ ASLR

เจาะลึก Format String Exploits: การเล่นแร่แปรธาตุกับหน่วยความจำ

ลองนึกภาพว่าคุณกำลังใช้ฟังก์ชันพิมพ์ข้อความพื้นฐานอย่าง printf ซึ่งรับ “รูปแบบ” การแสดงผล เช่น %s สำหรับสตริง หรือ %d สำหรับตัวเลข

ปัญหาจะเกิดขึ้นเมื่อโปรแกรมเมอร์ปล่อยให้ Input ของผู้ใช้งาน ถูกนำไปใช้เป็น “รูปแบบ” การแสดงผลโดยตรง

ยกตัวอย่างเช่น ถ้าโปรแกรมรับชื่อผู้ใช้และนำไปพิมพ์โดยไม่มีการตรวจสอบที่เหมาะสม ผู้โจมตีสามารถป้อนข้อความพิเศษอย่าง %x หรือ %p เข้าไปได้

ผลลัพธ์คือ ฟังก์ชัน printf จะไม่พิมพ์ “รูปแบบ” เหล่านั้นออกมาตรงๆ แต่จะพยายามอ่านค่าจาก Stack Memory ราวกับว่ามีอาร์กิวเมนต์ที่หายไป ทำให้ข้อมูลภายในโปรแกรมรั่วไหลออกมาได้

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

GOT และ PLT: ประตูสู่การควบคุมฟังก์ชัน

โปรแกรมส่วนใหญ่ในปัจจุบันไม่ได้เขียนขึ้นมาใหม่ทั้งหมด แต่จะใช้ Shared Libraries หรือไลบรารีที่หลายๆ โปรแกรมใช้ร่วมกัน เพื่อประหยัดพื้นที่และลดความซับซ้อน

เมื่อโปรแกรมต้องการเรียกใช้ฟังก์ชันจากไลบรารีภายนอก เช่น printf กลไกพิเศษที่เรียกว่า GOT (Global Offset Table) และ PLT (Procedure Linkage Table) จะเข้ามามีบทบาท

พูดง่ายๆ คือ PLT ทำหน้าที่เป็นเหมือน “ทางลัด” ที่จะชี้ไปยังฟังก์ชันที่ต้องการในไลบรารีภายนอก โดยค่าที่ PLT ชี้ไปจะถูกเก็บอยู่ใน GOT

ตอนแรก GOT จะชี้ไปยังโค้ดพิเศษที่จะทำหน้าที่ “ค้นหา” ที่อยู่จริงของฟังก์ชันในไลบรารี เมื่อหาเจอแล้ว ที่อยู่จริงของฟังก์ชันจะถูกบันทึกใน GOT เพื่อให้การเรียกครั้งต่อไปรวดเร็วขึ้น

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

ASLR: เกราะป้องกันที่ต้องทำลาย

แน่นอนว่านักพัฒนาและผู้เชี่ยวชาญด้านความปลอดภัยไม่ได้อยู่นิ่งๆ เพื่อรอให้ถูกโจมตี กลไกป้องกันอย่าง ASLR (Address Space Layout Randomization) จึงถูกสร้างขึ้นมา

ASLR ทำหน้าที่ สุ่มตำแหน่งหน่วยความจำ ของส่วนสำคัญต่างๆ ในโปรแกรม เช่น Stack, Heap หรือตำแหน่งของ Shared Libraries ทุกครั้งที่โปรแกรมถูกรันขึ้นมาใหม่

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

ASLR ทำให้เทคนิคการโจมตีที่อาศัยการ “เดา” หรือ “Hardcode” ที่อยู่หน่วยความจำนั้นไร้ผลไปโดยปริยาย

อย่างไรก็ตาม ASLR ไม่ใช่กำแพงที่ทะลุไม่ได้ ผู้โจมตีมักจะใช้ช่องโหว่อื่นๆ เช่น Format String Exploit ที่ทำให้ข้อมูลรั่วไหล เพื่อ “Leak” ที่อยู่หน่วยความจำ ที่เป็นจริงออกมาก่อน จากนั้นจึงค่อยใช้ข้อมูลที่ได้มาเพื่อโจมตีในขั้นตอนต่อไป

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