Cyber Security Academy · บทเรียน

พื้นฐานการรีเวิร์สและการเจาะไบนารี

บทนำสู่การวิศวกรรมย้อนกลับและการใช้ประโยชน์จากไบนารี

บทเรียน 3 จาก 413 ขั้นตอน

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

วิศวกรรมย้อนกลับและการเจาะไบนารีโดยสังเขป

หมวดหมู่ CTF สองประเภทที่เกี่ยวข้องกันอย่างใกล้ชิดนี้เน้นโปรแกรมที่ผ่านการคอมไพล์แล้ว:

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

วิศวกรรมย้อนกลับมุ่งเน้นการทำความเข้าใจ ส่วนการเจาะไบนารีมุ่งเน้นการทำลาย ทั้งสองด้านต้องอาศัยความคุ้นเคยกับแนวคิดระดับต่ำ

การตรวจดูไบนารีเบื้องต้น

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

# Identify file type and architecture
file ./challenge

# Pull human-readable strings (flags are sometimes left in plaintext)
strings ./challenge

# Check which security mitigations are enabled
checksec --file=./challenge

การวิเคราะห์แบบสถิตเทียบกับแบบไดนามิก

คุณวิเคราะห์ไบนารีได้สองวิธีที่เสริมกัน:

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

ผู้เล่นที่มีทักษะจะสลับใช้ทั้งสองวิธี โดยอ่านแบบสถิตเพื่อสร้างทฤษฎี แล้วตรวจสอบแบบไดนามิกด้วยการไล่ทำงานทีละขั้น

การอ่านโค้ดถอดแยกคำสั่ง

ในการทำวิศวกรรมย้อนกลับ คุณต้องอ่านภาษาแอสเซมบลี คุณไม่จำเป็นต้องเขียนได้อย่างคล่องแคล่ว แต่ต้องจดจำรูปแบบต่าง ๆ ได้:

cmp / test ตามด้วยการกระโดด (je, jne) คือการเปรียบเทียบและการแยกแขนง ซึ่งมักเป็นการตรวจสอบรหัสผ่าน
call ใช้เรียกฟังก์ชัน โดยอาร์กิวเมนต์จะถูกวางไว้ในรีจิสเตอร์หรือบนสแตกก่อนหน้านั้น
mov ย้ายข้อมูลระหว่างรีจิสเตอร์ หน่วยความจำ และค่าคงที่

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

เครื่องแปลย้อนกลับช่วยให้ทำงานเร็วขึ้น

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

// Decompiler output (approximate)
if (strcmp(user_input, "s3cr3t_p4ss") == 0) {
    puts("Correct! Here is your flag:");
    print_flag();
} else {
    puts("Wrong.");
}

จุดเริ่มต้นของการทำให้หน่วยความจำเสียหาย

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

หากข้อมูลป้อนเข้าล้นบัฟเฟอร์เฉพาะที่ ก็สามารถเขียนทับที่อยู่ส่งคืนที่บันทึกไว้นั้นได้ ผู้ใดควบคุมที่อยู่ส่งคืน ผู้นั้นก็ควบคุมทิศทางการทำงานถัดไป

// Vulnerable: no bound on how much is read into buf
void vuln() {
    char buf[64];
    gets(buf);   // reads until newline, ignores buf size
}

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

การเจาะไบนารีที่ง่ายที่สุดคือการเขียนทับที่อยู่ส่งคืนเพื่อกระโดดไปยังฟังก์ชันที่โปรแกรมไม่เคยตั้งใจจะเรียกใช้ เช่น win() ที่ซ่อนอยู่และพิมพ์แฟลกออกมา

ขั้นตอนมีดังนี้:

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

# Build the input with a Python exploit library
from pwn import *

p = process('./challenge')
offset = 72                 # bytes to reach the return address
win_addr = 0x401176        # address of the win() function
p.sendline(b'A' * offset + p64(win_addr))
p.interactive()

กลไกป้องกันสมัยใหม่

ไบนารีจริงมักเปิดใช้กลไกป้องกันที่ขัดขวางการล้นแบบง่าย ๆ คุณต้องตรวจสอบกลไกเหล่านี้ด้วย checksec:

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

กลไกป้องกันแต่ละอย่างจะผลักดันให้คุณต้องใช้เทคนิคที่ก้าวหน้ายิ่งขึ้น

การเขียนโปรแกรมแบบใช้การคืนค่าต่อเนื่อง (ROP)

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

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

ROP เป็นสะพานจากการล้นแบบพื้นฐานไปสู่การโจมตีในโลกจริง ซึ่งโค้ดของผู้โจมตีแทบจะไม่สามารถเรียกใช้ได้โดยตรง

ข้อบกพร่องของสตริงรูปแบบ

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

// Vulnerable: user controls the format string
printf(user_input);          // dangerous

// Safe: user input is data, not format
printf("%s", user_input);    // correct

เหตุผลที่ผู้ป้องกันต้องเรียนรู้เรื่องนี้

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

อย่าใช้ฟังก์ชันรับข้อมูลป้อนเข้าที่ไม่จำกัดความยาว เช่น gets หรือ strcpy ให้ใช้ฟังก์ชันที่เทียบเท่ากันและตรวจสอบความยาวแทน
เปิดใช้กลไกป้องกันไว้เสมอ ได้แก่ แคนารี NX, ASLR/PIE แบบเต็มรูปแบบ และ RELRO แบบเต็มรูปแบบตามค่าเริ่มต้น
เลือกใช้ภาษาที่ปลอดภัยต่อหน่วยความจำเมื่อแบบจำลองภัยคุกคามเอื้อให้ทำเช่นนั้น
ถือว่าค่าที่ผู้ใช้ควบคุมได้ซึ่งไปถึงสตริงรูปแบบหรือการคัดลอกบัฟเฟอร์ เป็นประเด็นร้ายแรงในการตรวจสอบโค้ด

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

ทดสอบความเข้าใจพื้นฐานด้านวิศวกรรมย้อนกลับและการเจาะไบนารีของคุณ

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

ตอนนี้คุณมีภาพรวมของวิศวกรรมย้อนกลับและการเจาะไบนารีแล้ว:

คัดกรองไบนารีทุกไฟล์ด้วย file, strings และ checksec ก่อนการวิเคราะห์เชิงลึก
ผสานการวิเคราะห์แบบ สถิต (เครื่องถอดแยกคำสั่งหรือเครื่องแปลย้อนกลับ) และแบบ ไดนามิก (ดีบักเกอร์) เพื่อทำความเข้าใจตรรกะ
การเจาะไบนารีเริ่มจาก บัฟเฟอร์ล้นบนสแตก ที่เขียนทับที่อยู่ส่งคืน ส่วน กลไกป้องกัน (แคนารี, NX, ASLR/PIE, RELRO) จะเพิ่มความยาก
ROP เอาชนะ NX ด้วยการนำชุดคำสั่งย่อยที่มีอยู่แล้วกลับมาใช้ใหม่ ส่วนข้อบกพร่องของ สตริงรูปแบบ เกิดจากอาร์กิวเมนต์รูปแบบที่ไม่น่าเชื่อถือ
ทุกเทคนิคยังเป็นบทเรียนด้านการป้องกันสำหรับการเขียนและตรวจสอบโค้ดให้ปลอดภัยยิ่งขึ้น

ถัดไป คุณจะสร้างชุดเครื่องมือและเรียนรู้การเขียนบทสรุปวิธีแก้โจทย์

เริ่มต้นได้ฟรี

เรียนรู้ Cyber Security Academy ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 76
บทเรียน: 303

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “พื้นฐานการรีเวิร์สและการเจาะไบนารี” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “พื้นฐานการรีเวิร์สและการเจาะไบนารี”

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

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

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

บทเรียน “พื้นฐานการรีเวิร์สและการเจาะไบนารี” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Cyber Security Academy