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

พื้นฐานแอสเซมบลี x86/x64 สำหรับนักวิเคราะห์ย้อนกลับ

อ่าน MOV, CMP, JNE, CALL และ RET พร้อมติดตามการไหลของข้อมูลผ่านรีจิสเตอร์และสแตก

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

เหตุใดผู้ทำวิศวกรรมย้อนกลับจึงต้องรู้แอสเซมบลี

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

รีจิสเตอร์

รีจิสเตอร์สำคัญของ x86-64:

  • RAX — ตัวสะสมและค่าที่ส่งกลับ
  • RBX, RCX, RDX — ใช้งานทั่วไป
  • RSI, RDI — ดัชนีต้นทาง/ปลายทาง และอาร์กิวเมนต์ฟังก์ชันตัวที่หนึ่ง/สอง
  • RSP — ตัวชี้สแตก
  • RBP — ตัวชี้ฐาน (เฟรมสแตก)
  • RIP — ตัวชี้คำสั่ง

รูปแบบการเรียกฟังก์ชัน (x64 Linux)

อาร์กิวเมนต์จะถูกส่งผ่านรีจิสเตอร์ (System V AMD64 ABI):

  1. RDI
  2. RSI
  3. RDX
  4. RCX
  5. R8
  6. R9

ค่าส่งกลับอยู่ใน RAX อาร์กิวเมนต์เพิ่มเติมจะถูกใส่ไว้บนสแตก

คำสั่งสำคัญ

คำสั่งพื้นฐานที่ควรรู้จัก:

mov rax, rbx    ; copy rbx to rax
push rax        ; push rax onto stack
pop rbx         ; pop top of stack into rbx
add rax, 8      ; rax = rax + 8
sub rsp, 0x20   ; allocate 32 bytes on stack
call 0x401234   ; call function at address
ret             ; return to caller
lea rax, [rbp-0x10] ; load address of local var

การกระโดดแบบมีเงื่อนไข

การเปรียบเทียบและการแตกแขนง:

cmp rax, 0      ; set flags based on rax - 0
test rax, rax   ; test rax & rax (check if zero)
jz  0x401234    ; jump if zero
jnz 0x401234    ; jump if not zero
jl  0x401234    ; jump if less (signed)
jge 0x401234    ; jump if >= (signed)
je  0x401234    ; jump if equal

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

การสังเกตรูปแบบทั่วไป:

; if (x == 0) return 1;
mov eax, [rbp-4]    ; load x
test eax, eax       ; x == 0?
jnz .notZero        ; if not zero, skip
mov eax, 1          ; return value = 1
ret
.notZero:
...

การสังเกตการดำเนินการกับสตริง

การดำเนินการทั่วไปกับสตริง/หน่วยความจำ:

; memcpy(dest, src, n):
; rdi=dest, rsi=src, rdx=n
rep movsb           ; copy RCX bytes from RSI to RDI

; strlen-like loop:
.loop:
  cmp byte [rsi], 0 ; check for null terminator
  je  .done
  inc rsi
  jmp .loop

การตั้งค่า/การรื้อเฟรมสแตก

ทุกฟังก์ชันจะเริ่มต้นและสิ้นสุดด้วย:

; Prologue:
push rbp            ; save caller frame
mov  rbp, rsp       ; set up new frame
sub  rsp, 0x30      ; allocate local vars

; Epilogue:
leave               ; mov rsp, rbp; pop rbp
ret

การระบุลูป

ลูปในโค้ดที่ถอดคำสั่ง:

  • การกระโดดย้อนกลับ (ไปยังที่อยู่ที่ต่ำกว่า) แสดงว่ามีลูป
  • ตัวนับในรีจิสเตอร์จะลดค่าด้วย dec/sub
  • คำสั่ง loop จะลดค่า RCX และกระโดดต่อหากค่าไม่เป็นศูนย์

การอ่านคำสั่งสวิตช์

คำสั่งสวิตช์มักถูกคอมไพล์เป็นตารางการกระโดด:

; Jump table pattern:
cmp eax, 5          ; check if case > max
ja  .default        ; jump to default
lea rcx, [jump_table]
mov rax, [rcx + rax*8]  ; index into table
jmp rax              ; jump to case handler

ค่าคงที่ SIMD และการเข้ารหัสลับ

มองหาค่าตัวเลขที่ใช้ระบุอัลกอริทึม:

  • AES S-box: ไบต์แรก 63 7C 77 7B...
  • แฮชเริ่มต้นของ SHA-256: 0x6a09e667, 0xbb67ae85...
  • MD5: 0xd76aa478

การสังเกตค่าคงที่เหล่านี้ช่วยระบุฟังก์ชันเข้ารหัสลับได้ทันที

ตรวจสอบอย่างรวดเร็ว: แอสเซมบลี x64

ใน x86-64 System V ABI รีจิสเตอร์ใดเก็บอาร์กิวเมนต์ตัวแรกของการเรียกฟังก์ชัน

สรุปบทเรียน

การทำวิศวกรรมย้อนกลับบน x86-64 จำเป็นต้องรู้จักรีจิสเตอร์สำคัญ (RAX, RDI, RSI, RSP, RIP) รูปแบบการเรียกฟังก์ชัน (อาร์กิวเมนต์อยู่ใน RDI/RSI/RDX...) และรูปแบบทั่วไป (โพรล็อก ลูป การเปรียบเทียบ และตารางการกระโดด) คุณไม่จำเป็นต้องเขียนแอสเซมบลี เพียงอ่านให้เข้าใจก็พอ ค่าคงที่ด้านการเข้ารหัสลับในโค้ดช่วยระบุอัลกอริทึมได้โดยไม่ต้องเรียกใช้ไบนารี

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

บทเรียน “พื้นฐานแอสเซมบลี x86/x64 สำหรับนักวิเคราะห์ย้อนกลับ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “พื้นฐานแอสเซมบลี x86/x64 สำหรับนักวิเคราะห์ย้อนกลับ”

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

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

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

บทเรียน “พื้นฐานแอสเซมบลี x86/x64 สำหรับนักวิเคราะห์ย้อนกลับ” ใช้เวลานานแค่ไหน

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

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

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

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

  1. Ghidra: การนำทางและใส่คำอธิบายไบนารี
  2. พื้นฐานแอสเซมบลี x86/x64 สำหรับนักวิเคราะห์ย้อนกลับ
  3. การวิเคราะห์แบบไดนามิกด้วย GDB และ pwndbg
  4. การถอดการทำให้สับสนและกลลวงต่อต้านการวิเคราะห์
← กลับไปที่ Cyber Security Academy