Skip to content

Hyper-breakpoint (EPT-backed VMI breakpoint)

Hypervisor tarafından Extended Page Table permission'ları veya trap-and-restore yoluyla enforce edilen bir breakpoint; böylece execution, memory'de guest-visible bir 0xCC bırakmadan VMX root'a trap eder — in-guest bir int3 software breakpoint'inin stealthy alternatifi.

Mechanism

Neden çalışır

Klasik bir software breakpoint, target byte'ı 0xCC (int3) ile patch'ler, dolayısıyla guest'in yaptığı bir memory read patch'i görür — integrity check'leri ile kolayca tespit edilir. Bir hyper-breakpoint ise breakpoint'i guest dışından, hypervisor'da enforce eder ve orijinal instruction byte'larını guest-visible memory'de bozulmamış bırakır.

Execute-trap varyantı Extended Page Tables (EPT) kullanır. Hypervisor, target'ın guest physical page'inden execute permission'ını kaldırır (read/write'ı bozulmamış bırakırken). Guest CPU o page'den bir instruction fetch ettiğinde, CPU bir EPT violation üretir ve VMX root'a bir VM-exit'e yol açar. Hypervisor artık breakpoint'e "sahiptir": register/memory state'ini inceleyebilir veya değiştirebilir, event'i log'layabilir ya da bir debug notification teslim edebilir — tüm bunlar guest'in byte'ları değişmemişken olur, dolayısıyla page'i okuyan in-guest bir memory scanner el değmemiş kod görür.

Execution'ın trap edilen page'in ötesine geçmesine izin vermek için hypervisor, gerçek instruction'(lar)ı çalıştırıp sonra yeniden arm etmelidir. Public hyper-breakpoint tasarımları bunu nasıl yaptıklarına göre farklılaşır — üç varyantla yakalanır:

  • EPT switching (altp2m): iki EPT view tutun — biri page executable, diğeri değil — ve bir instruction çalıştırmak için aktif EPTP'yi atomik olarak flip edip sonra geri flip edin. (Bkz. ept-switch-single-step.md.)
  • Instruction repair: page'de execute permission'ını geçici olarak restore edin, Monitor Trap Flag (MTF) üzerinden tam olarak bir instruction single-step edin, sonra execute'u tekrar kaldırın. (Bkz. guest-single-stepping.md.)
  • Instruction emulation: trap edilen tek instruction'ı EPT'yi hiç gevşetmeden hypervisor içinde decode edip emule edin, sonra devam edin.

Üçü de invariant'ı korur: guest hiçbir zaman değişmiş bir byte görmez ve bir debugger'a atfedebileceği bir #BP almaz. (Buna karşın klasik bir EPT hook — örn. HyperDbg'ninki — kasıtlı olarak gizli bir 0xCC / #BP yazar ve bu yüzden bu tekniğin guest-visible kuzenidir.)

Walkthrough

VMX root / kontrol ettiğiniz bir hypervisor gerektirir

Aşağıdaki EPT-violation + step/emulate loop'u public VT-x introspection yazılarını takip eder (HyperDbg, DRAKVUF ve hyper-breakpoint varyant karşılaştırması). EPT switching özellikle Xen altp2m'e dayanır.

1. Breakpoint'i arm et — target GPA'dan execute'u soyun:

ept_set_perms(target_gpa, /*R*/1, /*W*/1, /*X*/0);   // exec now faults

2. Execution'da trap et — fetch hypervisor'a fault eder:

[vmexit] reason=EPT_VIOLATION gpa=<target> access=exec  -> hyper-breakpoint hit
         inspect RIP/registers, log, notify debugger ...

3. Üzerinden adımla — gerçek instruction'ı çalıştırmak için bir varyant seç:

// (a) instruction repair
ept_set_perms(target_gpa, 1,1,1);   // restore X
set_mtf();                          // arm MTF (one-instruction step)
// VM-entry; MTF VM-exit (basic reason 37) after one instruction:
ept_set_perms(target_gpa, 1,1,0);   // re-protect
clear_mtf();

// (b) EPT switching
switch_to_view(exec_view);  step_one_via_mtf();  switch_to_view(trap_view);

// (c) instruction emulation
emulate_one_instruction_at(RIP);    // never relax EPT
Stealth karşılaştırması vs. guest-visible int3 
hyper-breakpoint (EPT exec-trap):
  guest reads target page  -> ORIGINAL bytes        (no 0xCC present)
  guest executes target    -> EPT violation -> trap to hypervisor (invisible)

classic software breakpoint:
  guest reads target page  -> sees 0xCC             (detectable patch)
  guest executes target    -> #BP delivered in-guest (debugger inferable)

Varyantlar maliyet ile fidelity arasında takas yapar: emulation, eksiksiz ve doğru bir decoder ister; MTF repair her hit'te iki VM-exit ekler; EPT switching re-stepping permission churn'ünden kaçınır ama altp2m gerektirir. Bu hyper-breakpoint varyantlarının public bir performance karşılaştırması bu takasları sayısallaştırır.

Detection

  • In-guest: memory karşılaştırması başarısız olur (byte'lar değişmemiştir), dolayısıyla detection timing'e geri düşer — her hit EPT-violation VM-exit'lerine (ve repair varyantı için ek bir MTF exit'e) mal olur ve trap edilen bölgenin execution süresini mertebelerce şişirir.
  • From the host: tek bir GFN üzerindeki tekrarlı EPT violation'lar, MTF exit'leri veya sık EPTP switch'leri ile eşleştiğinde, hypervisor telemetry'sinde net bir hyper-breakpoint signature'ıdır.

Mitigation

  • Guest-side: kodu byte okuyarak değil, hypervisor'ın temiz bir shadow'dan karşılayamayacağı execute-and-time / execute-and-hash path'leriyle ölçün; integrity garantileri için hardware attestation'a güvenin.
  • Host-side: EPT-permission ve altp2m control'lerini gate'leyin ki untrusted domain'ler hyper-breakpoint arm edemesin ve stealth instrumentation'a işaret eden sürekli per-GFN violation/MTF fırtınalarına alert üretin.

References