RustDuck Botnet — Rust-Rebuilt IoT & Server DDoS Swarm
176.65.139[.]204. Defensive hunt & harden pack — no offensive code.Executive Summary
QiAnXin's XLab team (reported publicly 30 June 2026, corroborated by FastNetMon and Security Affairs in early July) documented RustDuck, a DDoS botnet they have tracked since February 2026 that is being rewritten from C into Rust. The Rust core shows real engineering depth: a ChaCha20-Poly1305 handshake, an AES-GCM command channel, HKDF-SHA256 key derivation, Curve25519 key exchange, and key rotation every ten minutes — plus a two-stage design where a small loader decrypts and unpacks the heavier core.
RustDuck grows two ways: (1) weak or default credentials on internet-exposed Telnet and SSH, and (2) exploitation of known holes in routers/DVRs and Linux server software. Reported exploit targets include CVE-2017-17215 (Huawei HG532), CVE-2025-29635 (D-Link DIR-823X), CVE-2024-1781 (Totolink X6000R), CVE-2018-8007 (Apache CouchDB), plus ThinkPHP, Jenkins and Hadoop YARN and exposed Android Debug Bridge interfaces. Enlisted devices span TVT DVRs/cameras, Ruijie, TP-Link and ZTE gear. C2 rides duckdns.org dynamic DNS and the command set covers start/stop attacks, status reporting, control-server switching and self-upgrade. XLab counted 20+ delivery addresses, busiest at 176.65.139[.]204. The core also runs an anti-analysis checklist — Wireshark/gdb/debugger/honeypot/VM fingerprinting, a reserved-address probe, and a clock-skew sandbox test — erasing traces if it thinks it is being watched.
Source Review & Web Hunter Notes
| Tier | Source | Key Finding | Carry |
|---|---|---|---|
| 1 · Vendor research | QiAnXin XLab (via The Hacker News) — "RustDuck Botnet Rebuilds in Rust" | Two-stage Rust design; crypto stack; Telnet/SSH + router/DVR/app-server RCE spread; duckdns C2; 20+ IPs, busiest 176.65.139.204; anti-analysis checklist | yes |
| 1 · Network research | FastNetMon — "New RustDuck botnet targets internet-exposed devices and servers" | Corroborates internet-exposed device + server targeting and DDoS purpose | yes |
| 2 · News | Security Affairs (194556) · GBHackers | Confirms IoT + weak-password/RCE spread, Rust rewrite, small-but-engineered scale | partial |
Decisions: scope-honest and behavior-first. RustDuck's core victims (routers, cameras, Android boxes) are outside EDR coverage — the pack routes those to network telemetry (N1–N3) and treats them as an explicit GAP. The Falcon-actionable surface is Linux servers compromised via the app-server RCE path (ThinkPHP/Jenkins/Hadoop YARN/CouchDB) and any managed host beaconing to duckdns / the delivery IPs. Atomic IOCs (delivery IP 176.65.139.204, duckdns C2, the CVE set) are carried as a perishable watchlist; XLab notes 20+ delivery IPs, so 176.65.139.204 is one busy node, not the whole set. All atoms trace to XLab / the cited reporting.
Hunt Brief & Attack Chain
Working hypothesis: An internet-exposed Linux server (or IoT device) is compromised via a weak Telnet/SSH credential or an app-server RCE (ThinkPHP/Jenkins/Hadoop YARN/CouchDB); a shell fetches the RustDuck loader ELF from a raw-IP delivery host into a world-writable dir, marks it executable and runs it; the loader unpacks the Rust core, which beacons duckdns C2 over an encrypted channel and awaits DDoS commands.
| Step | Behavior | Telemetry | Hunt Angle |
|---|---|---|---|
| 1 · Ingress (creds) | Weak/default Telnet or SSH login | auth log; UserLogon | N1 |
| 2 · Ingress (RCE) | ThinkPHP/Jenkins/Hadoop YARN/CouchDB or router/DVR exploit | WAF; ProcessRollup2 | Q1; N2 |
| 3 · Delivery | Shell fetches loader ELF from a raw-IP host (e.g. 176.65.139.204) | ProcessRollup2; net | Q2; N3 |
| 4 · Stage | chmod +x then execute ELF from /tmp, /dev/shm, /var/tmp | ProcessRollup2 | Q3, Q4 |
| 5 · Unpack | Small loader decrypts + unpacks the heavier Rust core | ProcessRollup2 | Q3 |
| 6 · C2 | Encrypted beacon to duckdns dynamic DNS; 10-min key rotation | DNS; NetworkConnectIP4 | Q5; Q6 |
| 7 · Attack | Receives + launches DDoS floods on command | net (volume) | N4 |
Affected surface & telemetry
| Surface | Required Telemetry | Priority | Gap Risk |
|---|---|---|---|
| Falcon-managed Linux servers (exposed apps) | Process lineage + command line | Critical | Low — core process telemetry |
| Egress from any managed host | DNS (duckdns) + NetworkConnectIP4 | High | Medium — IPs/domains rotate |
| IoT / embedded devices (routers, cameras, Android) | NetFlow / NGFW / DNS logs (no EDR) | High | GAP — not EDR-visible |
| Perimeter Telnet/SSH exposure | Auth logs; firewall | Medium | Medium — depends on log forwarding |
Consolidated IOC Table
| Type | Value | Conf | Action | Context |
|---|---|---|---|---|
| Behavior | Exposed app service (php/java/httpd) spawning a shell / download tool | high | detect | RCE ingress — flagship |
| Behavior | Shell fetching an ELF from a raw-IP HTTP URL, then chmod +x + execute from /tmp or /dev/shm | high | detect | Delivery + stage |
| IP (delivery) | 176.65.139[.]204 (busiest of 20+) | medium | hunt | Loader distribution — perishable |
| Infra (C2) | *.duckdns.org dynamic-DNS C2 | medium | hunt | Encrypted beacon; legit DDNS also uses this TLD |
| Vuln (spread) | CVE-2017-17215 · CVE-2025-29635 · CVE-2024-1781 · CVE-2018-8007 + ThinkPHP / Jenkins / Hadoop YARN / ADB | high | patch | Router/DVR + Linux app-server entry points |
| Attribute | Two-stage Rust bot; ChaCha20-Poly1305 / AES-GCM / Curve25519; 10-min key rotation; anti-VM/debugger/honeypot checks | medium | enrich | Binary triage / attribution |
ATT&CK Mapping
| Tactic | Technique | Observed Behavior | Query / Control |
|---|---|---|---|
| Initial Access | T1190 — Exploit public-facing application | ThinkPHP/Jenkins/Hadoop YARN/CouchDB + router/DVR RCE | Q1; N2 |
| Initial Access | T1078 / T1110 — Valid accounts / brute force | Weak/default Telnet + SSH creds | N1 |
| Execution / Command | T1059.004 — Unix shell | Service account spawns sh/bash + download tool | Q1, Q2 |
| Command & Control | T1105 — Ingress tool transfer | Loader ELF fetched from a raw-IP host | Q2; N3 |
| Defense Evasion | T1222.002 / T1564 / T1497 — chmod / world-writable exec / sandbox evasion | chmod +x from /tmp; anti-VM/debugger/honeypot checks | Q3, Q4 |
| Persistence / Execution | T1543 / T1053 — Service / cron autostart (device-dependent) | Bot survives via device-specific autostart | N (device) |
| Command & Control | T1071 / T1568.002 — App-layer C2 / dynamic DNS | Encrypted beacon over duckdns; 10-min key rotation | Q5, Q6 |
| Impact | T1498 / T1499 — Network / endpoint DoS | Coordinated DDoS floods on command | N4 |
Native Audit-Log Hunts
| Hunt | Source | Logic | Response |
|---|---|---|---|
| N1 · Telnet/SSH brute + success | auth.log / syslog / firewall | A burst of failed Telnet(23)/SSH(22) logins from one source followed by a success, esp. to exposed devices/servers | Block source; rotate creds |
| N2 · App-server exploit signatures | WAF / reverse-proxy / app log | ThinkPHP (invokefunction), Jenkins, Hadoop YARN /ws/v1/cluster/apps, CouchDB _config RCE patterns against exposed apps | Virtual-patch; investigate host |
| N3 · Raw-IP ELF download | Proxy / NGFW / DNS | HTTP GET of a file from a bare IP (no domain), esp. 176.65.139.204 or another delivery node, to a server/device | Block IP; pull the file |
| N4 · Outbound DDoS volume | NetFlow / NGFW | A device/server generating high-rate outbound UDP/TCP/ICMP floods to varied destinations (attack traffic) | Rate-limit; isolate; notify |
| N5 · duckdns beacon from a server | DNS | A Linux server (not a normal DDNS user) resolving *.duckdns.org on a regular interval | Sinkhole; investigate host |
CrowdStrike LogScale CQL Hunt Queries
SyntheticProcessRollup2; Linux paths are matched with escaped slashes. Baseline legitimate deploy/CI tooling (Jenkins agents, container init) before promoting Q1/Q3.Looks for: a web/app service process (php/httpd/nginx/java/tomcat/couchdb) spawning a Unix shell or download tool. Accomplishes: catches the ThinkPHP/Jenkins/Hadoop YARN/CouchDB RCE foothold. FP: medium — some apps legitimately shell out; exclude known deploy/health-check scripts and CI agents.
// HUNT: exposed app service spawning a shell / download tool (RustDuck RCE ingress) // MITRE: T1190, T1059.004 | CONF: high FP: medium COST: low | REQUIRES: ProcessRollup2 (Linux) // TUNING: exclude known deploy/health-check scripts, CI/Jenkins build steps, container init #event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/ | ParentBaseFileName=/^(php|php-fpm|httpd|apache2|nginx|java|tomcat|catalina|couchdb|beam\.smp)$/i | FileName=/^(sh|bash|dash|ash|curl|wget|tftp|busybox)$/i | table([@timestamp, ComputerName, UserName, ParentBaseFileName, FileName, CommandLine], limit=200)
Looks for: curl/wget/tftp pulling from a bare-IP HTTP URL (no domain), including the known delivery node. Accomplishes: the loader download. FP: medium — some infra pulls from IPs; the bare-IP-URL pattern plus a server context is the discriminator.
// HUNT: download tool fetching from a raw-IP URL (RustDuck loader delivery) // MITRE: T1105 | CONF: high FP: medium COST: low | REQUIRES: ProcessRollup2 (Linux) // TUNING: allow-list sanctioned internal mirrors / package hosts by IP #event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/ | FileName=/^(curl|wget|tftp|busybox)$/i | CommandLine=/176\.65\.139\.204|https?:[\\/][\\/][0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/i | table([@timestamp, ComputerName, UserName, ParentBaseFileName, FileName, CommandLine], limit=200)
Looks for: a process image running out of /tmp, /var/tmp, /dev/shm or /run/shm — where the loader stages and unpacks the Rust core. FP: medium — some installers/CI use temp dirs; correlate to Q1/Q2 lineage on the same host.
// HUNT: ELF execution from a world-writable dir (RustDuck loader/core stage) // MITRE: T1564, T1059.004 | CONF: high FP: medium COST: low | REQUIRES: ProcessRollup2 (Linux) // TUNING: baseline installers/CI that legitimately execute from /tmp; correlate to Q1/Q2 #event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/ | ImageFileName=/^[\\/](tmp|var[\\/]tmp|dev[\\/]shm|run[\\/]shm)[\\/]/i | table([@timestamp, ComputerName, UserName, ParentBaseFileName, ImageFileName, CommandLine, SHA256HashData], limit=200)
Looks for: chmod granting execute (+x or a 7-mode) on a file under a world-writable dir — the classic drop-and-run step. FP: medium — build tooling does this; anchor on the temp path + correlate to Q2 download.
// HUNT: chmod +x on a temp-dir payload (RustDuck drop-and-run) // MITRE: T1222.002 | CONF: medium FP: medium COST: low | REQUIRES: ProcessRollup2 (Linux) // TUNING: build/install tooling also chmods in /tmp; require the temp path + correlate to Q2 #event_simpleName=/ProcessRollup2|SyntheticProcessRollup2/ | FileName=/^chmod$/i | CommandLine=/(\+x|[0-7]*7[0-7]*)\s.*(tmp|dev[\\/]shm)/i | table([@timestamp, ComputerName, UserName, ParentBaseFileName, CommandLine], limit=200)
Looks for: resolution of a *.duckdns.org name from a server. Accomplishes: RustDuck C2 lookup. FP: medium — duckdns is a legitimate free DDNS service; a server resolving it on an interval is the discriminator, not the TLD alone.
// HUNT: duckdns dynamic-DNS C2 lookup (RustDuck) // MITRE: T1071.001, T1568.002 | CONF: medium FP: medium COST: low | REQUIRES: DnsRequest // TUNING: duckdns is a legit DDNS TLD; scope to servers and look for interval beaconing #event_simpleName=DnsRequest | DomainName=/\.duckdns\.org$/i | table([@timestamp, ComputerName, ContextBaseFileName, DomainName], limit=200)
Looks for: any managed host connecting to the busiest reported delivery node. Accomplishes: confirms contact with RustDuck infrastructure. FP: low, but XLab lists 20+ delivery IPs — a miss here is not "clean"; refresh the IP set from current intel.
// HUNT: connection to the busiest RustDuck delivery IP (one of 20+, perishable) // MITRE: T1105 | CONF: medium FP: low COST: low | REQUIRES: NetworkConnectIP4 // FALSE POSITIVES: 20+ delivery IPs reported; add the rest from current threat intel #event_simpleName=NetworkConnectIP4 | in(RemoteAddressIP4, values=["176.65.139.204"]) | table([@timestamp, ComputerName, ContextBaseFileName, RemoteAddressIP4, RemotePort], limit=200)
CrowdStrike Custom IOA Recommendations
| IOA Name | Field Patterns | Benign Exclusions | Deployment Path |
|---|---|---|---|
| RustDuck — app service shelling out | Parent php/httpd/nginx/java/tomcat/couchdb; child sh/bash/curl/wget/busybox | Known deploy/health-check scripts; CI/Jenkins build steps; container init | Endpoint Security → Custom IOA (Linux) → Process Creation, Detect |
| RustDuck — temp-dir ELF execution | Image path under /tmp, /dev/shm, /var/tmp, /run/shm | Sanctioned installers/CI executing from temp (allow-list by hash/parent) | Custom IOA (Linux) → Process Creation, Detect |
| RustDuck — raw-IP payload fetch | curl/wget/tftp with a bare-IP HTTP URL | Internal mirrors / package hosts referenced by IP (allow-list) | Custom IOA (Linux) → Process Creation, Detect |
Machine-Readable IOC Appendix
Grouped IOC Quick-Copy
One-click blocks for detection. Atomic indicators are perishable (20+ delivery IPs; duckdns rotates) and trace to XLab / cited reporting — the server exploitation-to-execution lineage is the durable EDR surface.
type,value,action,severity,expiration,description,tags ipv4,176.65.139.204,detect,high,2026-10-06,RustDuck busiest delivery node (1 of 20+),campaign:RustDuck domain,duckdns.org,detect,medium,2026-10-06,RustDuck DDNS C2 TLD -- scope to servers to limit FP,campaign:RustDuck # NOTE: XLab reports 20+ delivery IPs -- add the remainder from current XLab/threat-intel data. # duckdns.org is a legitimate free DDNS provider; prefer the server-scoped hunt (Q5) over a blanket block.
Exposed app service (php/php-fpm/httpd/nginx/java/tomcat/couchdb) spawning sh/bash/curl/wget/busybox (Q1) curl/wget/tftp fetching an ELF from a bare-IP HTTP URL, incl. 176.65.139.204 (Q2/N3) ELF executing from /tmp, /var/tmp, /dev/shm or /run/shm (Q3) chmod +x (or 7-mode) on a file under a world-writable dir, then execute (Q4) Linux server resolving *.duckdns.org on a regular interval (Q5/N5) Telnet(23)/SSH(22) brute-force burst from one source followed by a login success (N1) High-rate outbound UDP/TCP/ICMP flood from a device/server (DDoS attack traffic) (N4)
# Router / DVR / device CVEs exploited by RustDuck: CVE-2017-17215 # Huawei HG532 router RCE CVE-2025-29635 # D-Link DIR-823X command injection (CISA KEV, Apr 2026) CVE-2024-1781 # Totolink X6000R command injection CVE-2018-8007 # Apache CouchDB RCE # App-server / service entry points (patch + restrict exposure): ThinkPHP (invokefunction RCE) Jenkins (exposed / unauth build exec) Hadoop YARN ResourceManager (unauth app submission -> RCE) Android Debug Bridge (ADB) exposed on 5555 # Action: patch where possible; otherwise virtual-patch at WAF and remove internet exposure.
Remove Telnet(23) + management SSH(22) + ADB(5555) from internet exposure; enforce strong creds/keys Patch or virtual-patch the router/DVR + ThinkPHP/Jenkins/Hadoop YARN/CouchDB entry points Mount /tmp, /var/tmp, /dev/shm with noexec,nosuid,nodev Egress filtering: default-deny outbound from servers; alert on raw-IP ELF fetches + duckdns from servers Promote Q1/Q3 (app-shell + temp-dir ELF) to Detect fleet-wide with a tuned allow-list Rate-limit / monitor outbound flood volume (NetFlow) to catch DDoS participation
Hardening — Tiered & Deployable
Cut the exposed entry points, make the staging dirs non-executable, and constrain egress.
- Remove Telnet(23), management SSH(22) and ADB(5555) from internet exposure; enforce strong keys/creds — M1035 / M1042 / M1027. Kills the weak-credential ingress.
- Mount
/tmp,/var/tmp,/dev/shmwithnoexec,nosuid,nodev— M1022 / M1038 (CIS Distribution Independent Linux §1.1). Breaks Q3/Q4 directly. - Promote Q1 / Q3 to Detect fleet-wide — M1040. Generalizes to most Linux server-side RCE-to-bot chains.
- Block
176.65.139.204+ scope duckdns alerts to servers at proxy/DNS — M1037. Feeds Q5/Q6.
Deployable — enforce noexec on world-writable dirs (fstab)
# Add mount options and remount (validate on a pilot host first). # /etc/fstab entries (adjust device/tmpfs to your layout): tmpfs /tmp tmpfs defaults,noexec,nosuid,nodev 0 0 tmpfs /dev/shm tmpfs defaults,noexec,nosuid,nodev 0 0 # Apply without reboot: mount -o remount,noexec,nosuid,nodev /tmp mount -o remount,noexec,nosuid,nodev /dev/shm # Verify: findmnt -no OPTIONS /tmp ; findmnt -no OPTIONS /dev/shm
- Patch / virtual-patch the router-DVR + ThinkPHP/Jenkins/Hadoop YARN/CouchDB entry points — M1051 / M1050. Removes the RCE spread path.
- Egress filtering: default-deny outbound from servers; alert on raw-IP ELF fetches + duckdns — M1037. Feeds Q2/Q5/Q6.
- Restrict/monitor
curl/wget/tftpon production servers — M1038 / M1042.
Deployable — egress firewall (default-deny with allow-list, nftables)
# Server egress: allow DNS + your package/update mirrors, drop the rest (pilot in a log-only mode first).
# Replace 203.0.113.0/24 with your sanctioned mirror/update ranges.
nft add table inet egress
nft add chain inet egress out { type filter hook output priority 0 \; policy drop \; }
nft add rule inet egress out ct state established,related accept
nft add rule inet egress out udp dport 53 accept
nft add rule inet egress out ip daddr 203.0.113.0/24 tcp dport { 80, 443 } accept
nft add rule inet egress out log prefix \"EGRESS-DROP \"
- Asset inventory + segmentation for IoT/OT and exposed appliances — M1030. RustDuck's core victims live here and are not EDR-visible.
- Retire/replace end-of-life routers/DVRs that can't be patched — M1051.
- Application allowlisting on production Linux servers — M1038. Default-deny unknown ELFs.
Containment Runbook
| Phase | Actions | Owner | Evidence |
|---|---|---|---|
| Isolate | Network-contain the host (or ACL the device); preserve the dropped ELF from /tmp//dev/shm, shell history, and the app/auth logs | SOC L2 | Containment timestamp; Q1/Q3 events; sample ELF |
| Triage | Map ingress (RCE via Q1 / brute via N1) → loader fetch (Q2) → temp-dir exec (Q3) → duckdns/IP C2 (Q5/Q6); note the exploited service + CVE; capture the delivery IP(s) | IR | Process tree; exploited endpoint; C2 list |
| Eradicate | Kill the loader/core processes; remove the ELF + any device-specific autostart (cron/service/rc); block the delivery IP + sinkhole duckdns name | IR | Killed PIDs; removed files; blocks |
| Recover | Patch/virtual-patch the exploited service; rotate any credentials exposed on the host; for IoT devices that can't be cleaned, factory-reset + firmware-update or replace | IR + IT | Patch record; cred rotation; device status |
| Harden | noexec on temp dirs; remove Telnet/SSH/ADB exposure; egress default-deny; promote Q1/Q3; NetFlow watch for outbound floods | Detection Eng | Mount opts; firewall; IOA enabled |
Detection Coverage Map & Validation
| Technique | Behavior | CQL | IOA | Coverage |
|---|---|---|---|---|
| T1190 / T1059.004 | App-server RCE → shell (Linux server) | Q1 | IOA-1 | Good (EDR-managed servers) |
| T1105 | Loader ELF fetch from raw IP | Q2, Q6 | IOA-3 | Good + N3 |
| T1564 / T1059.004 | ELF exec from world-writable dir | Q3 | IOA-2 | Good |
| T1222.002 | chmod +x on temp payload | Q4 | — | Partial correlate to Q2 |
| T1071.001 / T1568.002 | duckdns dynamic-DNS C2 | Q5 | — | Partial legit DDNS TLD |
| T1078 / T1110 | Weak Telnet/SSH creds | — | — | GAP auth logs (N1) |
| T1498 / T1499 | DDoS flood output | — | — | GAP NetFlow/NGFW (N4) |
| — | IoT/router/camera compromise itself | — | — | GAP no EDR on devices — network only |
Validation gates: (1) confirm Linux process + DNS + network telemetry is flowing from Falcon-managed servers (RustDuck's IoT victims are out of scope — cover via NetFlow/NGFW/DNS, tracked as GAPs above); (2) baseline legitimate app-shell-outs (deploy/health-check scripts, CI/Jenkins agents, container init) and any temp-dir installers so Q1/Q3/Q4 stay clean; (3) lab-test — a benign CI job that shells out and runs from /tmp should be added to the allow-list, and confirm noexec on /tmp actually blocks execution; (4) refresh the delivery-IP set (Q6) and duckdns scoping from current XLab intel — a miss on a single IP is not "clean" given 20+ nodes. No durable payload hash — anchor on behavior.
Hunt Summary Ticket
TITLE: Hunt — RustDuck Botnet (Rust-rebuilt IoT/server DDoS swarm)
SEVERITY: High (Linux server RCE-to-bot + DDoS participation; IoT spread out of EDR scope)
SCOPE: Falcon-managed Linux servers (exposed apps); egress from all hosts; perimeter Telnet/SSH/ADB
HYPOTHESIS: Exposed app (ThinkPHP/Jenkins/Hadoop YARN/CouchDB) or weak Telnet/SSH cred -> shell fetches
a loader ELF from a raw-IP host (176.65.139.204 +) -> chmod +x + exec from /tmp|/dev/shm ->
unpacks Rust core -> encrypted duckdns C2 (10-min key rotation) -> DDoS on command.
QUERIES RUN: Q1 app->shell (IOA) | Q2 raw-IP ELF fetch (IOA) | Q3 temp-dir ELF (IOA) | Q4 chmod +x |
Q5 duckdns C2 | Q6 delivery-IP beacon + Native N1-N5 (brute, WAF sigs, raw-IP dl, DDoS vol, duckdns)
DO FIRST: Q1, Q3 -- then correlate Q2 download + Q5/Q6 C2 on the same host
FINDINGS: <pending analyst execution>
GAPS: IoT/router/camera compromise (no EDR -> NetFlow/NGFW); Telnet/SSH brute (auth logs);
DDoS flood output (NetFlow); 20+ delivery IPs perishable
ACTIONS: noexec on /tmp,/dev/shm; remove Telnet/SSH/ADB exposure; patch app-server entry points;
egress default-deny; promote Q1/Q3; NetFlow watch for outbound floods
OWNER: HuntPack
VERSION: v0.2 - 2026-07-06
Changelog
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.References
| Tier | Source | Used For |
|---|---|---|
| 1 | The Hacker News — RustDuck Botnet Rebuilds in Rust to Hijack Routers and Servers for DDoS (reporting QiAnXin XLab) | Two-stage Rust design, crypto stack, spread (creds + CVEs + app-server RCE), duckdns C2, delivery IPs, anti-analysis |
| 1 | FastNetMon — New RustDuck botnet targets internet-exposed devices and servers | Corroboration of internet-exposed device + server targeting and DDoS purpose |
| 2 | Security Affairs · GBHackers | Confirms IoT + weak-password/RCE spread, Rust rewrite, scale/engineering |
HuntPack v0.1 · RustDuck DDoS Botnet · Generated 2026-07-06 · Defensive use only — no offensive code. RustDuck's core victims are IoT/embedded devices with no EDR sensor — those are covered by network telemetry (N1–N5) and flagged as GAPs; the Falcon-actionable surface is exposed Linux servers. The loader/core are polymorphic and delivery IPs churn (20+), so anchor on the exploitation-to-execution lineage, not a fixed hash. Validate field names and baseline app-shell-outs / temp-dir CI usage before promoting any query.