GentleKiller — The Gentlemen's BYOVD EDR-Killer Framework

In-house EDR-killer suite (8+ variants) · kernel-level process termination via vulnerable drivers · pre-encryption defense teardown
Threat
GentleKiller (The Gentlemen RaaS)
Severity
ACTIVE RaaS
Type
BYOVD / defense evasion
Access
Local admin → kernel
Version
v0.1 · 2026-06-22
Author
HuntPack
Confidence
High
01

Executive Summary

GentleKiller is an in-house, operator-maintained EDR-killer framework distributed by The Gentlemen ransomware-as-a-service crew to vetted affiliates, detailed by ESET on 2026-06-17 (corroborated by a May 2026 internal-data leak). It exists to tear down endpoint defenses immediately before ransomware encryption. It ships at least eight distinct variants, each impersonating a legitimate security product (fake version info, copied certificates and icons) and abusing a different Bring-Your-Own-Vulnerable-Driver (BYOVD) kernel driver to terminate protected processes from kernel space — bypassing user-mode tamper protection.

In total GentleKiller targets 400+ processes mapped to 48 security products — including Microsoft Defender, CrowdStrike, SentinelOne, Sophos, Palo Alto, ESET, Bitdefender, Kaspersky and McAfee/Trellix. Variants load signed-but-exploitable drivers (e.g. eb.sys, nseckrnl.sys, vgk.sys, stpm_old.sys/stpm_new.sys, dmx.sys, 360netmon_wfp.sys) then run a kill loop every ~2 seconds, periodically re-terminating any security process that respawns. Binaries are packed with Enigma and Themida; the crew also folds in leaked third-party killers (HexKiller, ThrottleBlood, HavocKiller) and pairs the framework with a Rust credential stealer, OxideHarvest. Notably, Gentlemen operationalizes newly published BYOVD PoCs within days.

Defender priority: Your EDR is the target. The detection that matters most is catching the BYOVD step before the kill loop succeeds — a known-vulnerable .sys driver being written and a kernel service registered for it, paired with the abrupt termination of multiple security processes. Enable Falcon sensor tamper-protection + the Vulnerable Driver blocklist (HVCI/WDAC), and alert on any sensor-health/heartbeat gap as a possible successful kill.

02

Source Review & Web Hunter Notes

TierSourceKey FindingCarry Fwd
1ESET Research / WeLiveSecurity — "Killing me gently: Inside Gentlemen's EDR killer framework" (2026-06-17)Full IOC set: 13 killer binaries (SHA-1 + ESET detections), 12 vulnerable drivers (SHA-1), packers, kill-loop behavior, OxideHarvestyes
1The Hacker News — "The Gentlemen RaaS Uses GentleKiller EDR Framework"400 processes / 48 products, 8 variants, BYOVD speed-to-operationalize, HexKiller/ThrottleBlood/HavocKilleryes
2BleepingComputer / SecurityAffairsConfirms multi-killer use, May 2026 internal leak, victim volumepartial

Web-hunter note: ESET published SHA-1 hashes (not SHA-256/MD5). Falcon Custom IOC import accepts SHA-256/MD5 only, so the SHA-1 set is provided in the appendix for YARA / retro-hunt / threat-intel matching, and the CQL hunts key on driver/binary filenames + behavior rather than hash. Re-derive SHA-256 from your own samples before promoting to a prevent IOC. This pack scopes the EDR-killer tooling; the broader Gentlemen ransomware lifecycle is covered separately.

03

Hunt Brief & Attack Chain

Hunt hypotheses (ordered by fidelity)

  1. H1 (high): A known-vulnerable driver (.sys) from the GentleKiller set is written to disk and/or a kernel service is created for it. → Q1, Q2
  2. H2 (high): Multiple security/EDR processes terminate within a short window (the ~2s kill loop). → Q5
  3. H3 (high): A binary masquerading as a security vendor (fake version info) executes from a non-standard path. → Q3
  4. H4 (medium): A .sys driver loads/installs from a user-writable directory (Temp/ProgramData/Downloads). → Q2, Q7
  5. H5 (medium): A Themida/Enigma-packed executable runs and immediately opens handles to many AV processes. → Q3, Q4
  6. H6 (medium): OxideHarvest reads Chromium/Gecko credential stores around the same intrusion window. → Q6
  7. H7 (high): Falcon sensor heartbeat/health gap coincides with one of the above (possible successful kill). → Native (s7)

Attack chain

StepBehaviorTelemetryHunt Angle
1 · Foothold + privescAffiliate gains local admin (RaaS intrusion, e.g. stolen VPN creds)UserLogon, ProcessRollup2Gentlemen intrusion hunts (separate pack)
2 · Drop driverVulnerable .sys written to user-writable pathPeFileWritten, FileCreateInfoQ1, Q7
3 · Register serviceKernel service created to load the driverServiceInstalledQ2
4 · Run killerMasquerading packed binary executes (Kasps.exe, Sent.exe, Sophos.exe, …)ProcessRollup2Q3, Q4
5 · Kill loopTerminate 400+ security processes every ~2sProcessRollup2 (terminations), sensor healthQ5, s7
6 · Steal credsOxideHarvest dumps browser credentialsProcessRollup2, FileOpenInfoQ6
7 · EncryptRansomware deploys once defenses are downPeFileWritten, mass file writesGentlemen ransomware pack
04

Consolidated IOC Table

All hashes are ESET-published SHA-1 (verbatim). Use for retro-hunt / YARA; re-derive SHA-256 for Falcon IOC import. Full lists in the appendix (s10).

TypeValueConfActionContext
drivereb.sys (SHA-1 BA914FE7…A074)highdetectKaspersky-derived vuln driver (Win64/Agent.ITG)
drivernseckrnl.sys (B0B912A3…21A1)highdetectFACEIT anti-cheat vuln driver
drivervgk.sys (7556AE58…DD1A)highdetectValorant/PerfectWorld vuln driver
driverstpm_old.sys / stpm_new.syshighdetectSafetica/Javelin vuln drivers
driverdmx.sys / 360netmon_wfp.sys / IMFForceDeletehighdetectZemana WatchDog / Qihoo360 / IObit
drivergoogleApiUtil64.sys / ThrottleBlood.sys / havoc.syshighdetectHexKiller / ThrottleBlood / HavocKiller third-party killers
binaryKasps.exe, FaceIT1.exe, Valorant2.exe, Sent.exe, Sophos.exe, Avast.exe, Symantec.exehighdetectMasquerading EDR-killer binaries (Win64/KillAV.*)
binarybuildx64.exe / buildx641.exehighhuntOxideHarvest credential stealer (Win64/Spy.Agent.AGC)
toolHexKiller / ThrottleBlood / HavocKiller / PoisonXmediumpivotThird-party / rootkit components folded into the suite
techniqueEnigma + Themida packingmediumenrichCommercial packers on all killer binaries
behavior~2-second process-kill loophighhuntRepeated termination of security processes
05

Affected Surface & Telemetry Matrix

SurfaceRequired TelemetryPriorityGap Risk
Windows servers & workstationsProcessRollup2, PeFileWritten, ServiceInstalledCriticalLow — core Falcon telemetry
Kernel driver layerDriver load events / vuln-driver blocklist (HVCI/WDAC)CriticalDriver-load visibility varies by sensor/OS config
EDR sensor healthSensor heartbeat / tamper / uninstall telemetryCriticalIf sensor is killed, local telemetry stops — rely on cloud-side health
Browser credential storesFileOpenInfo on Login Data / key4.dbHighOxideHarvest read may blend with browser use
06

ATT&CK Mapping

TacticTechniqueObserved BehaviorQuery / Control
Defense EvasionT1562.001 — Disable or Modify ToolsKill 400+ security processes from kernelQ5
Privilege EscalationT1068 — Exploitation for Priv EscBYOVD: signed-but-vulnerable driver → kernelQ1, Q2
Persistence / ExecutionT1543.003 — Windows ServiceKernel service created for the vuln driverQ2
Defense EvasionT1036.005 — Match Legitimate Name/LocationBinaries impersonate security vendors (fake version info, copied certs/icons)Q3, Q4
Defense EvasionT1027.002 — Software PackingEnigma / Themida packingQ3
Defense EvasionT1014 — RootkitPoisonX rootkit componentQ1, Q7
Credential AccessT1555.003 — Credentials from Web BrowsersOxideHarvest dumps Chromium/Gecko credsQ6
ImpactT1486 — Data Encrypted for ImpactRansomware deploys post-teardownGentlemen pack
07

Native Audit-Log Hunts (non-CQL)

  • Falcon sensor health (cloud-side): Alert on any host whose sensor stops reporting / goes RFM / heartbeat gaps unexpectedly — a successful kill blinds local telemetry, so the absence of data is the signal. Cross-reference with Q1–Q5 hits just before the gap.
  • Windows System log (Event ID 7045): New kernel-mode service install referencing a .sys in a user-writable path. Event ID 7000/7001 for driver service start failures (BYOVD often noisy).
  • Code Integrity (Event ID 3033/3023): HVCI/WDAC blocks of unsigned or blocklisted drivers — these are direct BYOVD-attempt evidence.
  • Microsoft vulnerable-driver blocklist: Confirm the blocklist is enabled; review blocked-load events for the named drivers.
  • Defender tamper alerts: If any host still runs Defender, surface "tampering"/"service stopped" alerts as corroboration.
08

CrowdStrike LogScale CQL Hunt Queries

Pick your tenant's cloud first — every "Open in Falcon" button below uses this selection.
Q1 · Known GentleKiller vulnerable driver written to disk
CONF HIGHFP LOWCOST LOW

Looks for: any of the named GentleKiller / third-party vulnerable drivers being written to disk. High-fidelity — these exact .sys filenames should not appear in a clean environment.

// HUNT: GentleKiller vulnerable .sys driver written
// MITRE: T1068, T1014  CONF: high  FP: low  COST: low | REQUIRES: PeFileWritten
#event_simpleName=/PeFileWritten|NewExecutableWritten/
| TargetFileName=/(\\)(eb|nseckrnl|vgk|stpm_old|stpm_new|dmx|360netmon_wfp|G11|googleApiUtil64|ThrottleBlood|havoc)\.sys$/i
| table([ComputerName, UserName, ImageFileName, TargetFileName, SHA256HashData], limit=200)
Q2 · Kernel service created for a driver in a user-writable path
CONF HIGHFP MEDCOST LOW

Looks for: a new kernel-mode service whose image is a .sys under Temp/ProgramData/Downloads/Users — the BYOVD load step. FP: Some legit installers register drivers from temp — exclude known software-deployment tooling and signed vendor installers.

// HUNT: kernel service install pointing at user-writable .sys
// MITRE: T1543.003, T1068  CONF: high  FP: medium  COST: low | REQUIRES: ServiceInstalled
// TUNING: exclude deployment tooling: | !in(field="ServiceImagePath", values=["*\\Windows\\System32\\drivers\\*"])
#event_simpleName=CreateService|ModifyServiceBinary
| ServiceImagePath=/\.sys/i
| ServiceImagePath=/\\Temp\\|\\ProgramData\\|\\Downloads\\|\\Users\\|\\AppData\\/i
| table([ComputerName, UserName, ServiceDisplayName, ServiceImagePath], limit=200)
Q3 · Masquerading EDR-killer binary execution
CONF HIGHFP MEDCOST LOW

Looks for: execution of the named killer binaries (security-vendor-themed names) from non-standard paths. FP: Names like Avast.exe/Sophos.exe could be legit if in the vendor's real install dir — exclude \Program Files\ vendor paths and require user-writable execution.

// HUNT: GentleKiller masquerading binary from user-writable path
// MITRE: T1036.005, T1027.002  CONF: high  FP: medium  COST: low | REQUIRES: ProcessRollup2
// TUNING: legit vendor binaries live in \Program Files\ - exclude those
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| ImageFileName=/\\(Kasps|FaceIT1|Valorant2|EASolo2Light|BitD1|MB2|Deletor|Symantec|Avast|Sent|Sophos|buildx64|buildx641)\.exe$/i
| ImageFileName=/\\Temp\\|\\ProgramData\\|\\Downloads\\|\\Users\\|\\AppData\\/i
| table([ComputerName, UserName, ImageFileName, CommandLine, SHA256HashData], limit=200)
Q4 · Single process opening handles to many AV/EDR processes
CONF MEDFP MEDCOST MED

Looks for: a process terminating/targeting multiple distinct security-product processes (the kill behavior, hash-agnostic). FP: Patch/upgrade tooling may stop one AV service — tune the count threshold and exclude approved deployment agents.

// HUNT: one actor process targeting many security processes
// MITRE: T1562.001  CONF: medium  FP: medium  COST: medium | REQUIRES: ProcessRollup2
// TUNING: sanctioned EDR migration and uninstall tooling legitimately stops several security services in one run -- exclude your deployment parent (ccmexec.exe, IntuneManagementExtension.exe) and vendor uninstallers. A real hit is an unsigned ImageFileName, or one running from a user-writable path.
#event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/
| CommandLine=/taskkill|\/IM\s|NtTerminateProcess|Stop-Service/i
| CommandLine=/CSFalcon|CSAgent|MsMpEng|SentinelAgent|SophosHealth|elastic-endpoint|bdservicehost|avp|McShield|TaniumClient/i
| groupBy([ComputerName, ImageFileName], function=count(as=kills))
| kills >= 3
| table([ComputerName, ImageFileName, kills], limit=200)
Q5 · Burst termination of security processes (kill loop)
CONF HIGHFP MEDCOST MED

Looks for: many security-product processes ending on one host in a short window — the ~2s repeating kill loop. FP: A reboot/upgrade stops services too — exclude maintenance windows and require multiple distinct products within minutes.

// HUNT: multiple distinct security processes terminate in a short window
// MITRE: T1562.001  CONF: high  FP: medium  COST: medium | REQUIRES: ProcessRollup2 (EndOfProcess)
// TUNING: exclude scheduled maintenance / reboot windows
#event_simpleName=EndOfProcess
| ImageFileName=/(CSFalconService|MsMpEng|SentinelAgent|SophosHealth|elastic-endpoint|bdservicehost|avp|McShield|ekrn|PaloAlto)\.exe$/i
| timeChart(span=2m, series=ImageFileName, function=count())
| table([ComputerName, ImageFileName, _count], limit=200)
Q6 · OxideHarvest browser credential-store access
CONF MEDFP MEDCOST LOW

Looks for: a non-browser process reading Chromium Login Data or Gecko key4.db / logins.json — OxideHarvest behavior. FP: Backup/sync agents read these — exclude approved backup tooling and the browsers themselves.

// HUNT: non-browser process reads browser credential stores
// MITRE: T1555.003  CONF: medium  FP: medium  COST: low | REQUIRES: FileOpenInfo
// TUNING: exclude browsers + approved backup agents
#event_simpleName=/FileOpenInfo/
| TargetFileName=/\\Login Data$|\\key4\.db$|\\logins\.json$/i
| ImageFileName!=/\\(chrome|msedge|firefox|brave|opera)\.exe$/i
| table([ComputerName, UserName, ImageFileName, TargetFileName], limit=200)
Q7 · Any .sys written to a user-writable directory
CONF MEDFP HIGHCOST LOW

Looks for: any kernel driver dropped into Temp/Downloads/ProgramData — generic BYOVD staging, catches new/unnamed variants. FP: High — some installers stage drivers in temp. Stack-rank by rarity of the SHA256 and correlate with Q2/Q5.

// HUNT: generic .sys dropped to user-writable path (new BYOVD variants)
// MITRE: T1068  CONF: medium  FP: high  COST: low | REQUIRES: PeFileWritten
// TUNING: rank by SHA256 prevalence; exclude vendor installer temp dirs
#event_simpleName=/PeFileWritten|NewExecutableWritten/
| TargetFileName=/\.sys$/i
| TargetFileName=/\\Temp\\|\\Downloads\\|\\ProgramData\\|\\AppData\\/i
| table([ComputerName, UserName, ImageFileName, TargetFileName, SHA256HashData], limit=200)
09

CrowdStrike Custom IOA Recommendations

IOA NamePatternExclusionsDeployment
BYOVD — Named vuln driver writtenPeFileWritten TargetFileName ∈ named .sys setNone — exact filenamesPromote Q1 → Custom IOA (Detect/Prevent, Critical)
EDRKILL — Masquerading killer execNamed killer .exe from user-writable path\Program Files\ vendor pathsPromote Q3 → Custom IOA (Prevent, Critical)
EDRKILL — Security-process kill burst≥3 distinct security processes end < 2 min, one parentMaintenance windowsPromote Q5 → Custom IOA (Detect, High) after baseline

Best defense is prevention at the driver layer: enable the Microsoft vulnerable-driver blocklist + Falcon's vuln-driver protection so the named drivers fail to load even before the IOA fires.

10

Machine-Readable IOC Appendix

Falcon IOC Management CSVbulk import
type,value,action,severity,expiration,description,tags
sha256,REPLACE_WITH_KASPS_EXE_SHA256,prevent,critical,2026-12-22,GentleKiller killer binary,campaign:GentleKiller
sha256,REPLACE_WITH_EB_SYS_SHA256,prevent,critical,2026-12-22,GentleKiller vuln driver eb.sys,campaign:GentleKiller
sha256,REPLACE_WITH_BUILDX64_SHA256,detect,high,2026-12-22,OxideHarvest stealer,campaign:GentleKiller
Killer Binaries — SHA-1 (ESET)YARA / retro-hunt
8AE6BD18B129061F63642531F1B684CF0383C75D  Kasps.exe        Win64/KillAV.EA
D605994FC72A2BB59B5CFB1624A1B9170ECA73A2  FaceIT1.exe      Win64/KillAV.EA
5AA3124E5C4921E5EDFC60133B5D71DA21B07DA3  Valorant2.exe    Win64/KillAV.EA
331879F5EEC8892BBD896F90BDBB1BAD0BF63BD6  EASolo2Light.exe Win64/KillAV.EA
A11EE9CDC59E5CAA59AEFD27B30D104F3AD68E62  BitD1.exe        Win64/KillAV.EA
2F86898528C6CAB3540C486A9BFAA0C029B73950  MB2.exe          Win64/KillAV.EA
D29670E684E40DDC89B47010C37CBC96737035B6  Symantec.exe     Win64/KillAV.EA
CF4D74DF17A91B4A36A2911B22AFEC5D8FA93A01  Avast.exe        Win32/KillAV.NVL
7131B377E96016DC1911020C9F95B1B4D042D7B4  Sent.exe         Win64/KillAV.AT
F0537CBB773AE12100B36731E7C39F5A9D852B14  Sophos.exe       Win64/KillAV.DE
A5CF917EC4A7DFBDFA43621398604805D860C718  buildx641.exe    Win64/Spy.Agent.AGC (OxideHarvest)
D4B19141102015D436321E6F26976E98183CFD27  buildx64.exe     Win64/Spy.Agent.AGC (OxideHarvest)
Vulnerable Drivers — SHA-1 (ESET)vuln-driver blocklist
BA914FE77B177B45799403B16DD14765C510A074  eb.sys             Win64/Agent.ITG
B0B912A3FD1C05D72080848EC4C92880004021A1  nseckrnl.sys       VulnDriver.NSecsoft.A
7556AE58C215B8245A43F764F0676C7A8F0FDD1A  vgk.sys            VulnDriver.PerfectWorld.A
711EF221526997039E804A18DB9647C91680BBE2  stpm_old.sys       VulnDriver.Safetica.A
68FEC379F2AE76C3D2CE913F7BE650CEA1D06990  stpm_new.sys       VulnDriver.Safetica.H
96F0DBF52AED0AFD43E44500116B04B674F7358E  dmx.sys            VulnDriver.WatchDogDev.C
9AD51AD97C01E97AB59214116740785E0F6320A8  360netmon_wfp.sys  VulnDriver.Qihoo360.A
12500F6C87CE62712A0ED6652C57468D15C14223  IMFForceDelete     VulnDriver.IObit.D.gen
56BEE9DF5833A637F5C54D5911DF98B0812FE643  G11.sys            Win64/Agent.IYQ
EC296F9501AD71E430810CB5CDC38D954D4BA536  googleApiUtil64.sys VulnDriver.Baidu.B (HexKiller)
82ED942A52CDCF120A8919730E00BA37619661A3  ThrottleBlood.sys  VulnDriver.GPUZ.B (ThrottleBlood)
1FA071303FB846308571E64727501FB98B1C2BE6  havoc.sys          VulnDriver.Huawei.D (HavocKiller)
Behavioral Signatureshunt pivots
# Behavior
- BYOVD: signed-but-vulnerable .sys loaded via new kernel service from user-writable path
- ~2-second loop terminating 400+ processes across 48 security products
- killer binaries packed with Enigma / Themida; fake vendor version info, copied certs/icons
- third-party killers folded in: HexKiller, ThrottleBlood, HavocKiller; PoisonX rootkit
- paired stealer: OxideHarvest (Rust) -> Chromium + Gecko browser creds
# Detection-by-absence
- Falcon sensor heartbeat gap immediately after Q1/Q2/Q3 = possible successful kill
# Windows events
- 7045 kernel service install (.sys in Temp/ProgramData)
- CodeIntegrity 3033/3023 blocked driver load = BYOVD attempt
11

Detection Validation Gates

  • Telemetry ready: Confirm PeFileWritten, ServiceInstalled, and EndOfProcess are flowing; verify cloud-side sensor-health alerting is configured (detection-by-absence depends on it).
  • Benign baseline: Run Q2/Q5/Q7 for 7 days, catalog legitimate driver installs (GPU/AV/VPN agents) and maintenance-window service stops; build exclusions.
  • Positive tests: In an isolated VM, attempt to load one blocklisted driver (e.g. via a known BYOVD test harness) to confirm Q1/Q2 + CodeIntegrity 3033 fire.
  • Promotion: Q1 and Q3 (named IOCs) → Custom IOA Prevent immediately; Q5 → Detect after baselining the kill-burst threshold.
12

Hardening — Tiered & Deployable

Immediate (this week)
  • Enable Microsoft Vulnerable Driver Blocklist (M1050): turn on via Windows Security / WDAC so the named drivers fail to load. The single highest-leverage control against BYOVD.
  • Lock Falcon sensor tamper-protection (M1040): enforce uninstall-protection + sensor anti-tamper; ensure agents run with maximum self-protection.
  • Alert on sensor-health gaps (M1047): wire cloud-side alerting for any unexpected sensor RFM / heartbeat loss.
Near term (1–4 weeks)
  • Enable HVCI / Memory Integrity (M1050): Hypervisor-Protected Code Integrity blocks unsigned/blocklisted kernel drivers across the fleet (pilot for driver compatibility first).
  • WDAC driver allowlist (M1038): move to an allowlist of approved drivers on servers — denies novel BYOVD variants the named-IOC hunts can't yet see.
  • Restrict local admin (M1026): BYOVD requires admin to install the driver service — tighten local-admin membership and enforce LAPS.
Strategic (1–3 months)
  • Attack-path reduction (M1018): close the Gentlemen intrusion vectors (exposed VPN/RDP, credential theft) so affiliates never reach the admin context BYOVD needs.
  • Immutable/segmented backups (M1053): assume defenses can be killed — ensure offline/immutable backups survive a successful teardown + encryption.
  • Browser credential hardening (M1042): enforce app-bound encryption + disable browser password storage where possible to blunt OxideHarvest.
13

Deployable Playbooks

1 · Enable the Microsoft vulnerable-driver blocklist (PowerShell, admin)

# Windows 11 / Server 2022+: ensure the blocklist policy is applied
# Check current state
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard |
  Select-Object -ExpandProperty SecurityServicesRunning
# Enable Memory Integrity (HVCI) via registry, then reboot
# HVCI needs VBS enabled as well -- the scenario key alone is inert and the
# control silently never activates. All three values are required.
$dg = "HKLM:\SYSTEM\CurrentControlSet\Control\DeviceGuard"
New-Item -Path $dg -Force | Out-Null
Set-ItemProperty -Path $dg -Name "EnableVirtualizationBasedSecurity" -Value 1 -Type DWord
Set-ItemProperty -Path $dg -Name "RequirePlatformSecurityFeatures" -Value 1 -Type DWord
# Prereqs: UEFI + Secure Boot + virtualization extensions. Reboot required.
# PILOT FIRST -- incompatible legacy drivers can block boot under HVCI.
# Rollback: set all three values to 0 and reboot; from Safe Mode or WinRE if it will not boot.
$p = "HKLM:\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity"
New-Item -Path $p -Force | Out-Null
Set-ItemProperty -Path $p -Name "Enabled" -Value 1 -Type DWord

2 · Hunt installed services for blocklisted drivers (PowerShell)

$bad = 'eb.sys','nseckrnl.sys','vgk.sys','stpm_old.sys','stpm_new.sys','dmx.sys',
       '360netmon_wfp.sys','googleApiUtil64.sys','ThrottleBlood.sys','havoc.sys','G11.sys'
Get-CimInstance Win32_SystemDriver |
  Where-Object { $bad -contains (Split-Path $_.PathName -Leaf) } |
  Select-Object Name, State, PathName

3 · Enforce Falcon sensor uninstall/anti-tamper (Prevention Policy)

# In Falcon console: Endpoint security > Prevention policies
#   - Sensor Visibility: ON
#   - Additional User Mode Data: ON
#   - "Uninstall Protection" (Sensor Update Policy): ON, set maintenance token
#   - Quarantine + USB policy as applicable
# Verify no host has anti-tamper disabled:
#   Host management > filter: "Sensor tags / RFM" review weekly
14

Containment Runbook

PhaseActionsOwnerEvidence
IsolateNetwork-contain any host matching Q1–Q5 or with a sensor-health gap; assume defenses down — treat as pre-ransomwareSOC / IRFalcon detections, sensor health
EradicateStop + delete the malicious kernel service; remove the dropped .sys and killer binaries; confirm no scheduled re-dropIRService list, removed files
Restore defensesReinstall/repair EDR, re-enable Defender, confirm blocklist/HVCI active; rotate any creds OxideHarvest could have takenIR / EndpointSensor re-registered, creds rotated
RecoverHunt for ransomware staging on the same host/peers; validate backups; rebuild from clean image if integrity uncertainIR / PlatformRebuild records, backup verification
ReportDocument driver(s) used, affiliate TTPs; submit hashes to vendor; review local-admin/VPN exposure that enabled itIR LeadIncident report
15

Detection Coverage Map

TechniqueBehaviorCQLIOACoverage
T1068 / T1014Vuln driver droppedQ1, Q7Q1Good
T1543.003Kernel service for driverQ2Q2Good
T1036.005 / T1027.002Masquerading packed killerQ3Q3Good
T1562.001Kill 400+ security processesQ4, Q5Q5Good
T1555.003OxideHarvest browser credsQ6Partial
T1562.001 (success)Sensor blinded after kills7 native (absence)Partial
T1486Ransomware encryption (post-teardown)Gentlemen packGAP (scope)

Validation: Coverage on the BYOVD teardown chain (drop → service → run → kill) is strong and largely promotable to Prevent IOAs, backed by driver-layer blocking. The residual gaps are the post-kill blind window (covered by detection-by-absence in s7) and the encryption stage (out of scope here — see the Gentlemen ransomware pack).

16

Hunt Summary Ticket

TITLE:      GentleKiller BYOVD EDR-killer framework (The Gentlemen RaaS)
SEVERITY:   Critical — pre-ransomware defense teardown, targets CrowdStrike directly
SCOPE:      Windows servers + workstations; kernel driver + EDR sensor layer
HYPOTHESIS: Affiliate with local admin drops a signed-but-vulnerable .sys, registers a
            kernel service, runs a masquerading packed killer, then loops killing 400+
            security processes before ransomware encrypts
QUERIES:    Q1 driver drop | Q2 kernel svc | Q3 killer exec | Q4/Q5 kill burst |
            Q6 OxideHarvest | Q7 generic .sys drop
DO FIRST:   Run Q1+Q3 (named IOCs); confirm vuln-driver blocklist + HVCI enabled;
            check for sensor-health gaps in the last 7d
FINDINGS:   <fill on triage>
GAPS:       post-kill blind window (use sensor-absence alert); encryption stage out of scope
ACTIONS:    Enable MS vuln-driver blocklist, lock sensor anti-tamper, isolate on any hit,
            treat as pre-ransomware
OWNER:      <analyst>
VERSION:    v0.1 · 2026-06-22
17

Changelog

v0.32026-07-24CQL correctness pass. All table() calls now carry an explicit row limit: the default is 200 and truncation is silent, so a capped result was indistinguishable from a complete one. Atomic-IOC sweeps (filters over 5+ hashes or C2 IPs) use limit=max so a wide infection is never silently under-scoped; behavioural hunts use limit=200, where exceeding the cap indicates the query needs tuning. Where present, event names that do not exist in the Falcon data model were corrected (e.g. ServiceInstalled is a Sysmon concept, not a Falcon event; ElfFileWritten is ELFFileWritten) — such queries could never return a row. No detection logic, fields, or IOCs changed.
v0.22026-06-29CQL syntax review (crowdstrike-logscale-v3): removed invalid FileCreateInfo event (Q6).
v0.12026-06-22Initial HuntPack — 7 CQL queries; full ESET IOC set (12 killer binaries + 12 vuln drivers, SHA-1); BYOVD-focused hardening (vuln-driver blocklist / HVCI / WDAC), playbooks, containment. Scoped to the GentleKiller EDR-killer tooling (distinct from the Gentlemen ransomware lifecycle).
18

References

TierSourceUsed ForAccess Date
1ESET / WeLiveSecurity — Killing me gently: Inside Gentlemen's EDR killer frameworkBinary + driver hashes (SHA-1), detections, kill-loop, OxideHarvest2026-06-22
1The Hacker News — The Gentlemen RaaS Uses GentleKillerScope (400/48), 8 variants, BYOVD speed, third-party killers2026-06-22
1CyberSecurityNews — GentleKiller abuses vulnerable driversPer-variant driver mapping2026-06-22
2BleepingComputer — Gentlemen ransomware uses multiple EDR killersCorroboration, May 2026 leak2026-06-22
RefMITRE ATT&CK T1562.001Technique mapping2026-06-22