RustDuck Botnet — Rust-Rebuilt IoT & Server DDoS Swarm

A two-stage DDoS botnet (QiAnXin XLab, June 2026) that has been rewritten from C into Rust — a small loader decrypts and unpacks a heavier Rust core with ChaCha20-Poly1305/AES-GCM channels, Curve25519 key exchange, 10-minute key rotation, and aggressive sandbox/analysis evasion. It spreads by weak/default Telnet & SSH credentials and by exploiting known bugs in routers, DVRs and Linux server software (ThinkPHP, Jenkins, Hadoop YARN, Apache CouchDB) to enlist routers, IP cameras, Android boxes and poorly-secured servers into a DDoS swarm. C2 rides duckdns.org dynamic DNS; 20+ delivery IPs are active, busiest at 176.65.139[.]204. Defensive hunt & harden pack — no offensive code.
Threat
RustDuck DDoS botnet
Severity
HIGH · DDoS BOTNET / RCE SPREAD
Type
Rust two-stage bot · IoT + Linux server
Delivery
Weak Telnet/SSH creds · router/DVR & app-server RCE
Targets
Routers, IP cameras, Android boxes, Linux servers
Version
v0.2 · 2026-07-06
Author
HuntPack
01

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.

Defender priority & scope: Most RustDuck victims are embedded/IoT devices that do not run an EDR sensor — those are a detection GAP best covered by network telemetry (NetFlow/NGFW/DNS), not Falcon. The EDR-observable surface is your Falcon-managed Linux servers: hunt Q1 (a web/app service — ThinkPHP/Jenkins/Hadoop YARN/CouchDB — spawning a shell), Q2 (that shell fetching an ELF from a raw-IP URL), and Q3 (an ELF executing from a world-writable dir). Watch duckdns.org C2 (Q5) and the delivery IP (Q6) fleet-wide.

02

Source Review & Web Hunter Notes

TierSourceKey FindingCarry
1 · Vendor researchQiAnXin 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 checklistyes
1 · Network researchFastNetMon — "New RustDuck botnet targets internet-exposed devices and servers"Corroborates internet-exposed device + server targeting and DDoS purposeyes
2 · NewsSecurity Affairs (194556) · GBHackersConfirms IoT + weak-password/RCE spread, Rust rewrite, small-but-engineered scalepartial

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.

03

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.

StepBehaviorTelemetryHunt Angle
1 · Ingress (creds)Weak/default Telnet or SSH loginauth log; UserLogonN1
2 · Ingress (RCE)ThinkPHP/Jenkins/Hadoop YARN/CouchDB or router/DVR exploitWAF; ProcessRollup2Q1; N2
3 · DeliveryShell fetches loader ELF from a raw-IP host (e.g. 176.65.139.204)ProcessRollup2; netQ2; N3
4 · Stagechmod +x then execute ELF from /tmp, /dev/shm, /var/tmpProcessRollup2Q3, Q4
5 · UnpackSmall loader decrypts + unpacks the heavier Rust coreProcessRollup2Q3
6 · C2Encrypted beacon to duckdns dynamic DNS; 10-min key rotationDNS; NetworkConnectIP4Q5; Q6
7 · AttackReceives + launches DDoS floods on commandnet (volume)N4

Affected surface & telemetry

SurfaceRequired TelemetryPriorityGap Risk
Falcon-managed Linux servers (exposed apps)Process lineage + command lineCriticalLow — core process telemetry
Egress from any managed hostDNS (duckdns) + NetworkConnectIP4HighMedium — IPs/domains rotate
IoT / embedded devices (routers, cameras, Android)NetFlow / NGFW / DNS logs (no EDR)HighGAP — not EDR-visible
Perimeter Telnet/SSH exposureAuth logs; firewallMediumMedium — depends on log forwarding
04

Consolidated IOC Table

The loader/core are polymorphic (Rust rewrite, packed, key rotation) and delivery IPs churn (20+ observed). The exploitation-to-execution lineage on Linux servers is the durable EDR surface; atomic indicators are a perishable network watchlist. All atoms trace to XLab / cited reporting.
TypeValueConfActionContext
BehaviorExposed app service (php/java/httpd) spawning a shell / download toolhighdetectRCE ingress — flagship
BehaviorShell fetching an ELF from a raw-IP HTTP URL, then chmod +x + execute from /tmp or /dev/shmhighdetectDelivery + stage
IP (delivery)176.65.139[.]204 (busiest of 20+)mediumhuntLoader distribution — perishable
Infra (C2)*.duckdns.org dynamic-DNS C2mediumhuntEncrypted 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 / ADBhighpatchRouter/DVR + Linux app-server entry points
AttributeTwo-stage Rust bot; ChaCha20-Poly1305 / AES-GCM / Curve25519; 10-min key rotation; anti-VM/debugger/honeypot checksmediumenrichBinary triage / attribution
05

ATT&CK Mapping

TacticTechniqueObserved BehaviorQuery / Control
Initial AccessT1190 — Exploit public-facing applicationThinkPHP/Jenkins/Hadoop YARN/CouchDB + router/DVR RCEQ1; N2
Initial AccessT1078 / T1110 — Valid accounts / brute forceWeak/default Telnet + SSH credsN1
Execution / CommandT1059.004 — Unix shellService account spawns sh/bash + download toolQ1, Q2
Command & ControlT1105 — Ingress tool transferLoader ELF fetched from a raw-IP hostQ2; N3
Defense EvasionT1222.002 / T1564 / T1497 — chmod / world-writable exec / sandbox evasionchmod +x from /tmp; anti-VM/debugger/honeypot checksQ3, Q4
Persistence / ExecutionT1543 / T1053 — Service / cron autostart (device-dependent)Bot survives via device-specific autostartN (device)
Command & ControlT1071 / T1568.002 — App-layer C2 / dynamic DNSEncrypted beacon over duckdns; 10-min key rotationQ5, Q6
ImpactT1498 / T1499 — Network / endpoint DoSCoordinated DDoS floods on commandN4
06

Native Audit-Log Hunts

RustDuck's IoT/embedded victims are not EDR-visible — these network/log hunts are the primary coverage for that surface and are called out as a GAP in the Coverage Map (§12).
HuntSourceLogicResponse
N1 · Telnet/SSH brute + successauth.log / syslog / firewallA burst of failed Telnet(23)/SSH(22) logins from one source followed by a success, esp. to exposed devices/serversBlock source; rotate creds
N2 · App-server exploit signaturesWAF / reverse-proxy / app logThinkPHP (invokefunction), Jenkins, Hadoop YARN /ws/v1/cluster/apps, CouchDB _config RCE patterns against exposed appsVirtual-patch; investigate host
N3 · Raw-IP ELF downloadProxy / NGFW / DNSHTTP GET of a file from a bare IP (no domain), esp. 176.65.139.204 or another delivery node, to a server/deviceBlock IP; pull the file
N4 · Outbound DDoS volumeNetFlow / NGFWA device/server generating high-rate outbound UDP/TCP/ICMP floods to varied destinations (attack traffic)Rate-limit; isolate; notify
N5 · duckdns beacon from a serverDNSA Linux server (not a normal DDNS user) resolving *.duckdns.org on a regular intervalSinkhole; investigate host
07

CrowdStrike LogScale CQL Hunt Queries

Pick your tenant's cloud first — every "Open in Falcon" button below uses this selection.
These queries target Falcon-managed Linux servers — RustDuck's IoT victims are not EDR-visible (see §6/§12). Process hunts include SyntheticProcessRollup2; Linux paths are matched with escaped slashes. Baseline legitimate deploy/CI tooling (Jenkins agents, container init) before promoting Q1/Q3.
Q1 · Exposed app service spawning a shell (RCE ingress)
CONF HIGHFP MEDCOST LOW

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)
Q2 · Shell fetching an ELF from a raw-IP URL
CONF HIGHFP MEDCOST LOW

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)
Q3 · ELF executing from a world-writable directory
CONF HIGHFP MEDCOST LOW

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)
Q4 · chmod making a temp-dir file executable
CONF MEDFP MEDCOST LOW

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)
Q5 · duckdns dynamic-DNS C2 resolution
CONF MEDFP MEDCOST LOW

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)
Q6 · Beacon / download to the known delivery IP
CONF MEDFP LOWCOST LOW

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)
08

CrowdStrike Custom IOA Recommendations

IOA NameField PatternsBenign ExclusionsDeployment Path
RustDuck — app service shelling outParent php/httpd/nginx/java/tomcat/couchdb; child sh/bash/curl/wget/busyboxKnown deploy/health-check scripts; CI/Jenkins build steps; container initEndpoint Security → Custom IOA (Linux) → Process Creation, Detect
RustDuck — temp-dir ELF executionImage path under /tmp, /dev/shm, /var/tmp, /run/shmSanctioned installers/CI executing from temp (allow-list by hash/parent)Custom IOA (Linux) → Process Creation, Detect
RustDuck — raw-IP payload fetchcurl/wget/tftp with a bare-IP HTTP URLInternal mirrors / package hosts referenced by IP (allow-list)Custom IOA (Linux) → Process Creation, Detect
Q1 and Q3 generalize well beyond RustDuck — "web/app service spawns a shell" and "ELF runs from a world-writable dir" catch most Linux server-side RCE-to-bot chains, so they are strong fleet-wide promotions with a tuned allow-list. The delivery IP / duckdns indicators are a refreshable network watchlist, not IOAs. IoT devices need network controls, not an IOA.
09

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.

Falcon IOC Management CSVbulk import
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.
Behavioral Signaturesdetection logic
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)
Spread Vulns — patch/virtual-patchentry points
# 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.
Hardening / Blockdefense-in-depth
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
10

Hardening — Tiered & Deployable

Cut the exposed entry points, make the staging dirs non-executable, and constrain egress.

Immediate — Close the door
  • Remove Telnet(23), management SSH(22) and ADB(5555) from internet exposure; enforce strong keys/credsM1035 / M1042 / M1027. Kills the weak-credential ingress.
  • Mount /tmp, /var/tmp, /dev/shm with noexec,nosuid,nodevM1022 / M1038 (CIS Distribution Independent Linux §1.1). Breaks Q3/Q4 directly.
  • Promote Q1 / Q3 to Detect fleet-wideM1040. Generalizes to most Linux server-side RCE-to-bot chains.
  • Block 176.65.139.204 + scope duckdns alerts to servers at proxy/DNSM1037. 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
Near term — Patch & constrain (pilot first)
  • Patch / virtual-patch the router-DVR + ThinkPHP/Jenkins/Hadoop YARN/CouchDB entry pointsM1051 / M1050. Removes the RCE spread path.
  • Egress filtering: default-deny outbound from servers; alert on raw-IP ELF fetches + duckdnsM1037. Feeds Q2/Q5/Q6.
  • Restrict/monitor curl/wget/tftp on production serversM1038 / 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 \"
Strategic — Shrink the attack surface
  • Asset inventory + segmentation for IoT/OT and exposed appliancesM1030. RustDuck's core victims live here and are not EDR-visible.
  • Retire/replace end-of-life routers/DVRs that can't be patchedM1051.
  • Application allowlisting on production Linux serversM1038. Default-deny unknown ELFs.
11

Containment Runbook

PhaseActionsOwnerEvidence
IsolateNetwork-contain the host (or ACL the device); preserve the dropped ELF from /tmp//dev/shm, shell history, and the app/auth logsSOC L2Containment timestamp; Q1/Q3 events; sample ELF
TriageMap 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)IRProcess tree; exploited endpoint; C2 list
EradicateKill the loader/core processes; remove the ELF + any device-specific autostart (cron/service/rc); block the delivery IP + sinkhole duckdns nameIRKilled PIDs; removed files; blocks
RecoverPatch/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 replaceIR + ITPatch record; cred rotation; device status
Hardennoexec on temp dirs; remove Telnet/SSH/ADB exposure; egress default-deny; promote Q1/Q3; NetFlow watch for outbound floodsDetection EngMount opts; firewall; IOA enabled
RustDuck is a DDoS botnet — a compromised host may already be generating attack traffic. Check NetFlow for high-rate outbound floods (N4) and rate-limit/isolate before eradication to stop third-party impact and avoid your egress being blocklisted.
12

Detection Coverage Map & Validation

TechniqueBehaviorCQLIOACoverage
T1190 / T1059.004App-server RCE → shell (Linux server)Q1IOA-1Good (EDR-managed servers)
T1105Loader ELF fetch from raw IPQ2, Q6IOA-3Good + N3
T1564 / T1059.004ELF exec from world-writable dirQ3IOA-2Good
T1222.002chmod +x on temp payloadQ4Partial correlate to Q2
T1071.001 / T1568.002duckdns dynamic-DNS C2Q5Partial legit DDNS TLD
T1078 / T1110Weak Telnet/SSH credsGAP auth logs (N1)
T1498 / T1499DDoS flood outputGAP NetFlow/NGFW (N4)
IoT/router/camera compromise itselfGAP 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.

13

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
14

Changelog

v0.22026-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.12026-07-06Initial pack, built in the review-v2 gold layout (fixed left-sidebar scrollspy TOC, collapsible, cloud selector inside the CQL section, per-card Copy/Open-in-Falcon, Grouped IOC Quick-Copy grid, coverage+validation, .ticket). Research from QiAnXin XLab via The Hacker News + FastNetMon + Security Affairs (30 Jun – 2 Jul 2026): RustDuck, a two-stage DDoS botnet being rewritten from C to Rust (ChaCha20-Poly1305/AES-GCM/Curve25519, 10-min key rotation, anti-analysis), spreading via weak Telnet/SSH creds and router/DVR + ThinkPHP/Jenkins/Hadoop YARN/CouchDB RCE, C2 over duckdns, 20+ delivery IPs (busiest 176.65.139.204). 6 CQL (Linux server surface) + 5 native hunts, 3 IOA candidates. Scope-honest: IoT/embedded victims are not EDR-visible and are flagged as GAPs routed to network telemetry. Atomic IOCs perishable, traced to XLab / cited reporting.
15

References

TierSourceUsed For
1The 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
1FastNetMon — New RustDuck botnet targets internet-exposed devices and serversCorroboration of internet-exposed device + server targeting and DDoS purpose
2Security Affairs · GBHackersConfirms 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.