BYOVD

BYOVD असुरक्षित ड्राइवरों का उपयोग करके AV/EDR समाधानों को अक्षम करने के तरीके प्रदर्शित करने वाले PoC का एक संग्रह है।

इस संग्रह में अप्रलेखित ड्राइवर और वे दोनों शामिल हैं जिनका कवरेज LOLDDrivers या Microsoft की अनुशंसित ड्राइवर ब्लॉक नियमों में पहले से मौजूद है।

---

अपनी प्रारंभिक खोज के बाद से, TfSysMon ड्राइवर को LOLDrivers में जोड़ा गया है और Sophos और ESET की रिपोर्ट के अनुसार, रैनसमवेयर समूहों द्वारा EDRKillShifter टूल का उपयोग करके इसका दुरुपयोग किया गया है।

---

📚 विषय-सूची

• 🔍 अवलोकन
• 🏗️ प्रोजेक्ट संरचना
• 🔧 निर्माण
• 📦 byovd-lib
• 💡 POCs
• 🔬 संपूर्ण ड्राइवर रिवर्स इंजीनियरिंग प्रक्रिया (x64)
• 🔗 संदर्भ
• ⚠️ अस्वीकरण

🔍 अवलोकन

BYOVD तकनीक ने हाल ही में आक्रामक सुरक्षा (offensive security) में लोकप्रियता हासिल की है, विशेष रूप से SpyBoy के Terminator ($3,000 में बेचा गया) और ZeroMemoryEx Blackout प्रोजेक्ट जैसे टूल के जारी होने के साथ। ये टूल AV/EDR एजेंटों को अक्षम करने के लिए असुरक्षित ड्राइवरों का लाभ उठाते हैं, जिससे पहचान कम होने से आगे के हमलों को सुविधाजनक बनाया जा सके।

इस रिपॉजिटरी में शैक्षिक उद्देश्यों के लिए विकसित कई PoC शामिल हैं, जो शोधकर्ताओं को यह समझने में मदद करते हैं कि प्रक्रियाओं को समाप्त करने के लिए इन ड्राइवरों का दुरुपयोग कैसे किया जा सकता है।

🏗️ प्रोजेक्ट संरचना

प्रोजेक्ट को Rust Cargo workspace के रूप में व्यवस्थित किया गया है। अधिकांश PoC एक सामान्य लाइब्रेरी (byovd-lib) साझा करते हैं जो बॉयलरप्लेट को संभालती है: ड्राइवर सेवा जीवनचक्र, IOCTL डिस्पैच, प्रक्रिया निगरानी, विशेषाधिकार समायोजन, और सफाई। प्रत्येक किलर एक पतला बाइनरी (~50-100 लाइनें) है जो केवल अपने ड्राइवर-विशिष्ट कॉन्फ़िगरेशन को परिभाषित करता है। K7Terminator, Astra64-Killer, Ktapi-Killer, और Xhunter1-Killer स्टैंडअलोन हैं — उनके पास अपनी स्वयं की [workspace] घोषणाएँ हैं और वे रूट workspace के माध्यम से नहीं, बल्कि सीधे अपनी निर्देशिकाओं से बनाए जाते हैं।``` BYOVD/ ├── Cargo.toml # Workspace root (deps + release profile) ├── Cargo.lock ├── README.md ├── LICENSE │ ├── byovd-lib/ # Shared library │ ├── Cargo.toml │ └── src/ │ ├── lib.rs # DriverConfig trait + run() / send_ioctl() / run_monitor() │ ├── service.rs # ByovdDriver -- SCM lifecycle (install/start/stop_and_delete) │ ├── device.rs # DeviceHandle -- 5 typed IOCTL dispatch shapes │ ├── handle.rs # WinHandle / ScHandle -- RAII handle wrappers (Send + Sync) │ ├── process.rs # find_pid_by_name / find_all_pids_by_name │ ├── monitor.rs # run_monitor_loop (closure-based) + setup_ctrlc_handler │ ├── privilege.rs # enable_privilege / ensure_running_as_local_system │ └── util.rs # to_wstring / to_cstring / get_current_dir │ ├── AppRemover-Killer/ # OPSWAT AppRemover ardrv.sys ├── Astra64-Killer/ # EnTech Astra32 / TVicHW astra64.sys -- standalone, data-only Shadow SSDT hijack EDR killer ├── BdApiUtil-Killer/ # Baidu BdApiUtil64 (CVE-2024-51324) ├── CcProtect-Killer/ # CnCrypt CcProtect ├── EnPortv-Killer/ # EnCase EnPortv ├── GameDriverX64-Killer/ # Fedeen GameDriverX64 (CVE-2025-61155) ├── GoFlyDrv-Killer/ # Golink GoFlyDrv ├── HNOs2Ec-Killer/ # HONOR PCManager HNOs2Ec.sys ├── HWAudioOs2Ec-Killer/ # Huawei Audio driver HWAudioOs2Ec.sys ├── K7Terminator/ # K7 RKScan -- standalone, LPE + BYOVD modes ├── Ksapi64-Killer/ # Kingsoft ksapi64 ├── Ktapi-Killer/ # Kontron ktapi.sys -- standalone, two-stage shellcode EDR killer ├── MonProcess-Killer/ # HONOR HnRSMService MonProcess.sys ├── MonProcessEX-Killer/ # HONOR MagicAnimation and HONOR PCManager MonProcessEX.sys ├── NSec-Killer/ # NSEC NSecKrnl (ValleyRAT BYOVD reproduction) ├── PCTcore64-Killer/ # PC Tools PCTcore64 (CVE-2026-8501) ├── PoisonX-Killer/ # Microsoft PoisonX (j3h4ck reproduction) ├── STProcessMonitor-Killer/ # Safetica STProcessMonitor (CVE-2025-70795, v114 + v2618) ├── TfSysMon-Killer/ # ThreatFire sysmon ├── UnknownKiller/ # unattributed unknown.sys ├── Viragt64-Killer/ # Tg Soft viragt64 ├── Wsftprm-Killer/ # Topaz wsftprm (CVE-2023-52271) ├── Xhunter1-Killer/ # Wellbia xhunter1.sys (CVE-2026-3609) └── Xkpsm-Killer/ # JiranJikyosoft X-Keeper xkpsm

प्रत्येक `*-Killer/` निर्देशिका में अपना स्वयं का `Cargo.toml`, `src/main.rs` (`DriverConfig` impl + CLI), `README.md` (ड्राइवर हैश + उपयोग), और मेल खाती `.sys` फ़ाइल होती है जिसे बाइनरी रनटाइम पर लोड करती है।

## 🔧 निर्माण

**पूर्वापेक्षाएँ:** Rust टूलचेन और Windows SDK के साथ Visual Studio Build Tools।```bash
# Build all tools (release, optimized + stripped)
cargo build --release

# Build a single tool
cargo build --release -p BdApiUtil-Killer

# Build multiple specific tools
cargo build --release -p NSec-Killer -p Wsftprm-Killer

बाइनरी target/release/ में आउटपुट होती हैं। चलाने से पहले संबंधित .sys ड्राइवर फ़ाइल को निष्पादन योग्य के समान निर्देशिका में कॉपी करें।

📦 byovd-lib

byovd-lib वह साझा लाइब्रेरी है जिस पर सभी PoC (K7Terminator को छोड़कर) निर्मित हैं। यह दो पूरक APIs उजागर करती है -- एक उच्च-स्तरीय घोषणात्मक (declarative) API मानक "ड्राइवर इंस्टॉल करें, देखते ही मारें, सफाई करें" प्रवाह के लिए, और एक निम्न-स्तरीय अनिवार्य (imperative) API उन किलर्स के लिए जिन्हें कस्टम प्रवाह की आवश्यकता होती है (पहले से लोड किए गए ड्राइवर से जुड़ना, कई PIDs में फैलना, संरचित IOCTL बफ़र, कस्टम रीट्राई लॉजिक, आदि)। दोनों को एक ही बाइनरी में मिश्रित किया जा सकता है।

मॉड्यूल लेआउट```

byovd-lib/src/ ├── lib.rs # DriverConfig trait + run() / send_ioctl() / run_monitor() ├── service.rs # ByovdDriver -- SCM lifecycle (install, start, stop_and_delete) ├── device.rs # DeviceHandle -- typed IOCTL dispatch (5 shapes) ├── handle.rs # WinHandle / ScHandle -- RAII handle wrappers (Send + Sync) ├── process.rs # find_pid_by_name / find_all_pids_by_name ├── monitor.rs # run_monitor_loop (closure-based) + setup_ctrlc_handler ├── privilege.rs # enable_privilege / ensure_running_as_local_system └── util.rs # to_wstring / to_cstring / get_current_dir

### उच्च-स्तरीय API: `DriverConfig` ट्रेट + `run()`

यह वही है जो बंडल किए गए किलर उपयोग करते हैं। ट्रेट को लागू करें, `byovd_lib::run()` को कॉल करें, हो गया।```rust
use byovd_lib::{DriverConfig, Result};
use clap::Parser;

struct MyDriver;
impl DriverConfig for MyDriver {
    fn driver_name(&self) -> &str { "MyDriver" }
    fn driver_file(&self) -> &str { "mydriver.sys" }
    fn device_path(&self) -> &str { "\\\\.\\MyDevice" }
    fn ioctl_code(&self) -> u32 { 0xDEAD }
    fn build_ioctl_input(&self, pid: u32, _name: &str) -> Vec<u8> {
        pid.to_ne_bytes().to_vec()
    }
}

#[derive(Parser)]
struct Cli {
    #[arg(short = 'n', long = "name", required = true)]
    process_name: String,
}