# EDRChoker — Open-Source Red-Team Tool Silences Cloud-Connected EDR via Windows Policy-Based QoS Bandwidth Throttling

> EDRChoker is an open-source red-team tool published in June 2026 by researcher @TwoSevenOneT that neutralizes cloud-connected EDR agents without killing processes or injecting code. It abuses Windows native Policy-Based Quality of Service (QoS) to throttle named EDR processes to ~8 bits/sec, severing the agent's TLS connection to its cloud management plane so it cannot upload detections, fetch policy, or accept remote response actions. Enforcement occurs in pacer.sys (an NDIS Lightweight Filter Driver) below the Windows Filtering Platform, evading the packet-block/packet-drop telemetry that catches WFP-based tools such as EDRSilencer.

- **Published:** 2026-06-07T00:00:00Z
- **Last reviewed:** 2026-06-07T00:00:00Z
- **Canonical:** https://intel.threadlinqs.com/threat/TL-2026-0711
- **Card image:** https://intel.threadlinqs.com/og/threat/threat-intel-edrchoker-edr-throttling-tool-tl-2026-0711.webp?v=62c4abb6 (Threadlinqs threat intel: EDRChoker Red-Team Tool Throttles EDR: Analysis & Hunting (TL-2026-0711) — High severity, 12 IOCs, 9 detection rules.)
- **ID:** TL-2026-0711
- **Severity:** HIGH
- **Category:** THREAT_INTEL
- **Status:** ACTIVE
- **Detections:** 9 (1 shown free below) · **IOCs:** 12

## Description

EDRChoker is a defense-evasion tool that targets the architectural dependency modern EDR platforms have on persistent outbound cloud connectivity. Rather than terminating the EDR process, unhooking its DLLs, or adding a Windows Filtering Platform (WFP) block filter, EDRChoker creates Windows Policy-Based QoS policies that match the EDR agent executable by application path and apply an extreme egress bandwidth ceiling of approximately 8 bits per second via the ThrottleRateActionBitsPerSecond setting. At that rate a TLS handshake — which must transfer a 3-6 KB certificate chain — can never complete, so the agent's mutually authenticated channel to its SaaS/cloud console fails with connection-dropped and timeout errors. The agent process keeps running and appears healthy locally, but it is effectively blind and deaf to its backend: real-time detections are never delivered, threat-intel and policy updates never arrive, and analyst-initiated remote isolation or live-response commands never reach the host.

The key tradecraft advantage is the enforcement layer. Policy-Based QoS throttling is implemented by the Packet Scheduler (pacer.sys / PSched), an NDIS Lightweight Filter Driver that operates at the NDIS boundary close to the hardware, beneath tcpip.sys and the WFP callout layer. Because no WFP filter is added, EDRChoker does not generate the FWPM filter-add events or the packet-block / packet-drop signals that EDR vendors rely on to catch tools like EDRSilencer (which weaponizes the FwpmFilterAdd0 WFP API). To the defender the symptom is a vague loss of agent connectivity rather than an explicit tamper event.

The tool runs in two modes. Install mode ingests a file of EDR process names and auto-generates one uniquely named QoS policy per process, each named with the process name plus a random GUID (e.g. EDRProcess_<GUID>); these policies persist across reboots so the silencing survives a restart of the host or the agent. Remove mode, invoked with no parameters, enumerates and purges all policies the tool created, cleanly restoring connectivity. The underlying primitive is the PowerShell New-NetQosPolicy cmdlet (and the equivalent MSFT_NetQosPolicySettingData WMI / registry objects), so the activity blends into legitimate network-administration tooling.

Execution requires local administrator privileges (creating machine-scoped QoS policies is a privileged operation), so EDRChoker is a post-exploitation capability used after initial access and privilege escalation, typically immediately before a noisy objective such as ransomware deployment, credential theft, or lateral movement, to ensure the EDR cannot phone home during the operation. Defenders should treat creation of QoS policies that match security-agent executables — especially with very low ThrottleRateActionBitsPerSecond values — as high-fidelity tampering, and should monitor EDR fleet health for agents that remain 'running' but stop checking in.

## MITRE ATT&CK

- T1685 Disable or Modify Tools
- T1112 Modify Registry
- T1059 Command and Scripting Interpreter
- T1047 Windows Management Instrumentation
- T1547 Boot or Logon Autostart Execution
- T1498 Network Denial of Service
- T1518 Software Discovery
- T1489 Service Stop

## Free detection (Splunk SPL, Microsoft KQL, Sigma)

**EDRChoker QoS Throttle Policy Creation Targeting Security Agent — Exploitation Phase** (`TL-2026-0711-SPL-001`)

Detects the core EDRChoker primitive: powershell.exe (or pwsh.exe) invoking New-NetQosPolicy/Set-NetQosPolicy with ThrottleRateActionBitsPerSecond set to an abnormally low value (< 1 Kbps). At ~8 bps a TLS handshake (3-6 KB cert chain) can never complete, severing a cloud-connected EDR agent from its management plane without killing the process. The regex isolates throttle ceilings under 1000 bps, the band EDRChoker uses.

- **Languages:** Splunk SPL, Microsoft KQL, Sigma
- **ATT&CK:** T1685, T1059.001
- **Data sources:** sysmon, windows_security, microsoft_defender_for_endpoint
- **Severity:** high
- **Confidence:** high

### Splunk SPL

```spl
index=sysmon sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1 (Image="*\\powershell.exe" OR Image="*\\pwsh.exe") CommandLine="*New-NetQosPolicy*" CommandLine="*ThrottleRateActionBitsPerSecond*" | rex field=CommandLine "ThrottleRateActionBitsPerSecond\s+(?<throttle_bps>\d+)" | where isnotnull(throttle_bps) AND tonumber(throttle_bps) < 1000 | eval is_edr_target=if(match(CommandLine,"(?i)(MsMpEng|SentinelAgent|CSFalconService|elastic-agent|CarbonBlack|cb\.exe|cylancesvc|xagt|SEDservice|edr|agent)\.exe"),"yes","no") | table _time host User Image CommandLine throttle_bps is_edr_target ParentImage
```

### Microsoft KQL

```kql
DeviceProcessEvents | where Timestamp > ago(24h) | where FileName in~ ("powershell.exe","pwsh.exe") | where ProcessCommandLine has "New-NetQosPolicy" and ProcessCommandLine has "ThrottleRateActionBitsPerSecond" | extend ThrottleBps = toint(extract(@"ThrottleRateActionBitsPerSecond\s+(\d+)", 1, ProcessCommandLine)) | where isnotempty(ThrottleBps) and ThrottleBps < 1000 | extend IsEdrTarget = iff(ProcessCommandLine matches regex @"(?i)(MsMpEng|SentinelAgent|CSFalconService|elastic-agent|CarbonBlack|cylancesvc|xagt|edr|agent)\.exe", "yes", "no") | project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, ThrottleBps, IsEdrTarget, InitiatingProcessFileName
```

### Sigma

```yaml
title: EDRChoker QoS Throttle Policy Creation Targeting Security Agent
id: 8f1c2a40-7e3b-4d11-9a2e-1b6c3d4e5f01
status: experimental
description: Detects creation of a Policy-Based QoS policy via New-NetQosPolicy with an abnormally low ThrottleRateActionBitsPerSecond value used by EDRChoker to silence cloud-connected EDR agents.
references:
    - https://cybersecuritynews.com/edrchoker-tool/
    - https://attack.mitre.org/techniques/T1685/001/
author: Threadlinqs Team
date: 2026-06-07
tags:
    - attack.defense_evasion
    - attack.t1685
    - attack.t1685
    - attack.execution
    - attack.t1059.001
logsource:
    product: windows
    category: process_creation
detection:
    selection_ps:
        Image|endswith:
            - '\powershell.exe'
            - '\pwsh.exe'
        CommandLine|contains|all:
            - 'New-NetQosPolicy'
            - 'ThrottleRateActionBitsPerSecond'
    selection_low_rate:
        CommandLine|re: 'ThrottleRateActionBitsPerSecond\s+([0-9]{1,3})\b'
    condition: selection_ps and selection_low_rate
falsepositives:
    - Legitimate network administrators applying genuine low-bandwidth QoS throttling policies
level: high
```

**Known false positives:**

- Legitimate network administrators applying genuine low-bandwidth QoS throttling for traffic shaping
- Bandwidth-limit testing in lab environments

**Tuning notes:** Tune the throttle threshold (< 1000 bps) to your environment's lowest legitimate QoS value. Allowlist sanctioned network-admin service accounts and change-window automation. Raise severity to critical when is_edr_target=yes.

### 8 more detection rules (Splunk SPL, Microsoft KQL, Sigma), unlock with TL Creds

- EDRChoker QoS Policy Registry Artifact Creation — Post-Exploitation Phase (locked: unlock with TL Creds)
- EDRChoker Persistent QoS Policy Store Write — Post-Exploitation Phase (locked: unlock with TL Creds)
- EDRChoker Security Software Discovery Preceding QoS Throttle — Post-Exploitation Phase (locked: unlock with TL Creds)
- EDRChoker QoS Throttle via PowerShell Module Logging — C2/Lateral Movement Phase (locked: unlock with TL Creds)
- EDR Agent Heartbeat Loss Without Uninstall — C2/Lateral Movement Phase (locked: unlock with TL Creds)
- EDRChoker Remove-Mode Mass QoS Policy Purge — C2/Lateral Movement Phase (locked: unlock with TL Creds)
- EDRChoker QoS Policy AppPath Match Referencing EDR Binary — Exploitation Phase (locked: unlock with TL Creds)
- EDRChoker WMI NetQosPolicy Creation Without WFP Filter Add — Exploitation Phase (locked: unlock with TL Creds)

Sign up free to unlock the detection rules: https://threadlinqs.com/?modal=signup

## Sources

- [New EDRChoker Tool Uses Policy-Based Quality of Service to Block EDR Processes](https://cybersecuritynews.com/edrchoker-tool/)
- [EDRChoker — GitHub Repository (@TwoSevenOneT)](https://github.com/TwoSevenOneT/EDRChoker)
- [New-NetQosPolicy — Microsoft Learn (NetQos PowerShell module)](https://learn.microsoft.com/en-us/powershell/module/netqos/new-netqospolicy)
- [Quality of Service (QoS) Policy — Windows Policy-Based QoS overview](https://learn.microsoft.com/en-us/windows-server/networking/technologies/qos/qos-policy-top)
- [MITRE ATT&CK T1562.001 — Impair Defenses: Disable or Modify Tools](https://attack.mitre.org/techniques/T1562/001/)
- [EDRSilencer — WFP-based EDR communication blocking (technique contrast)](https://attack.mitre.org/techniques/T1562/006/)

## Full data

The other 8 detection rules (Splunk SPL / Microsoft KQL / Sigma) unlock with TL Creds; a free account includes daily creds: https://threadlinqs.com/?modal=signup
Indicator values unlock with TL Creds, at a lower price on Red and Purple; AI agents can query rules and IOCs through the Threadlinqs MCP server (Purple): https://intel.threadlinqs.com/mcp

Canonical: https://intel.threadlinqs.com/threat/TL-2026-0711
