Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
All full reports
Full reportC2 infrastructureMonograph 41 / 5523 min read

Dual DNS and HTTP Beacons: ARM64 Agents and RustDesk Staging

Static analysis of four staging directories and a separate cloud C2 feed cohort

By
Odin by Brandefense
Published
19 November 2026
Reading time
23 min read
Edition
Version 1.1 · TLP:CLEAR
Scope
Prepared November 2026
Dual DNS and HTTP Beacons: ARM64 Agents and RustDesk Staging

1. Executive Summary

In short

Across records dated 14–20 November 2026, Odin by Brandefense analyzed 116 exposed files across four open HTTP directories alongside 153 command-and-control endpoints from 97,103 feed records. The directories stage DNS and HTTP beacons, Linux and macOS implants, privilege-escalation scripts, and a legitimate RustDesk package. Twelve feed-labeled Cobalt Strike ports on eight cloud hosts lack independent protocol confirmation. Hunt the five custom implant digests and four TLS JARM fingerprints, inspect recursive DNS traffic, and restrict unauthorized remote desktop installers.

Enterprise networks rarely run one operating system or permit direct outbound HTTPS traffic from every segment. Windows workstations sit behind authenticating web proxies, cloud workloads run on x86_64 and ARM64 Linux instances, and developer laptops run Apple Silicon macOS. Post-exploitation toolkits mirror that split.

The staged DNS beacon and RustDesk package could provide fallback paths if deployed. These records do not show a blocked callback, an installation, or target use.

We reviewed file paths, byte sizes, dates, and SHA-256 digests across four open HTTP directories discovered between 14 and 20 November 2026. Defenders can use cyber threat intelligence to assess protocol and certificate records across command-and-control feed families. No binary was run and no external target was contacted. All four open-directory addresses and all 137 C2 host addresses (153 reviewed endpoints) remain withheld.

1

Dual-channel DNS and HTTP beacons sit beside cross-platform Go and ELF implants.

Observed from 19 to 20 November 2026 in the United States, an 82-file directory stages fourteen root Windows DNS and HTTP beacons alongside seven secondary copies of identical byte sizes. Next to them sit a custom Linux ELF implant and twenty-six cross-platform Go binaries compiled for Linux AMD64, Linux ARM64, Windows AMD64, Windows ARM64, and macOS Intel and Apple Silicon.

2

Linux privilege-escalation kits pair ARM64 WebSocket stagers with a RustDesk installer.

Observed on 20 November 2026 in Hong Kong, a twelve-file directory combines an eight-kilobyte Linux root escalation script with custom Linux x86_64 and ARM64 WebSocket implants. The folder also stages a legitimate twenty-five-megabyte RustDesk Debian package. Two separate directories in China and South Korea stage internal scanners, Mimikatz builds, and a 32-bit Linux TCP stager.

3

Upstream C2 feed labels require independent protocol verification before firewall blocking.

Across 153 recently observed endpoints on 137 hosts spanning Cobalt Strike, Sliver, and Metasploit feeds, twelve Cobalt Strike ports on eight AWS and Azure hosts carry confirmed feed labels. The supplied inventory records do not establish independent beacon or protocol confirmation, so all eight cloud addresses and the other 141 endpoints remain withheld from blocklists.

Three Decisions for Leaders

  1. Require independent protocol confirmation before blocking feed C2 addresses. Keep uncorroborated cloud and dynamic-ISP feed addresses off automated firewall blocklists, and use the four Cobalt Strike TLS JARM fingerprints for multi-signal hunting. Inspect recursive DNS logs for high-entropy TXT, A, and AAAA tunneling queries.
  2. Treat unauthorized remote desktop packages on Linux servers as persistence events. Enforce package-repository allowlists and systemd policies across Linux fleets. Debian or RPM installers for RustDesk and similar tools must never install outside approved administration hosts.
  3. Separate custom implant hashes from public dual-use tools and shared TLS fingerprints. Load the five custom beacon, ELF, ARM64, and escalation SHA-256 digests into EDR hunting while keeping stock Mimikatz, fscan, RustDesk, and shared JARM fingerprints off automated blocklists.

The Study in Numbers

NumberWhat it is
4 HostsOpen-directory staging servers in the US, Hong Kong, China, and South Korea (addresses withheld; 0 shared hosts)
116 / 106Exposed directory files reviewed (82, 12, 21, and 1) and 106 global unique SHA-256 digests
21 + 2721 Windows DNS/HTTP beacon builds (14 root + 7 equal-length secondary copies) and 27 cross-OS ELF, Go, and Mach-O builds on Workbench A
97,103 / 153Feed records across four C2 families and 153 recently observed endpoints reviewed across 137 hosts
12 / 8Feed-labeled Cobalt Strike C2 ports (four dual-port 80/443 pairs plus four 443 listeners) on eight withheld AWS and Azure hosts
153 + 41All 153 reviewed C2 endpoints (12 feed-labeled plus 141 other rows) and 41 dual-use, remote-desktop, and log files kept off blocklists
8 + 4 IOCsPublished custom DNS/HTTP beacon, Linux ELF, ARM64 WebSocket, and root-pwn SHA-256 hashes (8) plus Cobalt Strike TLS JARM fingerprints (4) for hunting
6 + 3 RulesPublished Suricata 7 rules (6), bounded YARA rules (3), Sigma rules (2), and a Sentinel KQL hunting query

How to use this report.

Security leaders should read Chapters 1, 6, and 7. Endpoint, Linux, and cloud architects should review Chapters 3, 4, and 7. SOC analysts and detection engineers should focus on Chapters 5, 8, and 9.

2. Four-Workbench and Cloud C2 Analytical Model

In short

In records dated 14–20 November 2026, Odin by Brandefense reviewed 116 exposed files (106 unique SHA-256 digests) on four open HTTP directories alongside 153 C2 endpoints on 137 hosts. Zero shared IP addresses connect the four directories to each other or to the C2 hosts. Treat this synthesis as an analytical model separating five custom hashes and four TLS JARM fingerprints from unverified C2 and dual-use records.

Intrusions rarely stay confined to one binary format or one network protocol. Windows endpoints receive DLLs, service executables, or raw shellcode over HTTP, HTTPS, or DNS, while Linux servers and containers receive x86_64, ARM64, or 32-bit i386 ELF binaries. Once inside, operators add internal scanners, LSASS dumpers, or legitimate remote desktop packages to maintain backup access.

Comparing attack surface records for the four open directories and 137 C2 hosts shows zero shared IPv4 addresses. Between Workbench A and Workbench C, the only hash overlap is three unmodified public Mimikatz files (mimikatz.exe, mimilib.dll, and mimidrv.sys), with zero shared custom hashes. We therefore present them explicitly as an analytical model rather than one threat group. Figure 1 maps each slice to its defensive action.

Figure 1: Four open workbenches and four C2 feeds divide post-exploitation roles
Figure 1: Four open workbenches and four C2 feeds divide post-exploitation roles

Four Open HTTP Staging Directories (116 Files)

Operators on rented virtual private servers often run an ad-hoc web server, such as python3 -m http.server, to pull payloads with curl or PowerShell. Leaving that server bound to 0.0.0.0 exposes the entire folder, which defenders can find through external attack surface management. Table 2.1 summarizes all four directories (addresses withheld).

DirectoryGeo & portFilesHashedUnique SHA-256UnhashedObserved datesPrimary staged contents
Workbench A (WB-01)US · :8000828181119 to 20 Nov 2026Dual DNS/HTTP beacons, backoper_agent.elf, Go builds & scripts
Workbench B (WB-02)HK · :8000121110120 Nov 2026root_pwn.sh, ws_linux_arm64, c_agent, RR.exe & rustdesk-1.5.1-x86_64.deb
Workbench C (WB-03)CN · :80212117014 to 20 Nov 2026fscan.exe, Win32/x64 Mimikatz, kiwi_passwords.yar & archives
Workbench D (WB-04)KR · :80111020 Nov 2026Single 32-bit Linux TCP stager (/tcp_linux_i386, 2,607,220 B)

Across the 116 entries (78 executables/DLLs/shellcode, 19 text/log files, 14 scripts, and 5 archives), 114 carry SHA-256 digests. Two entries record no digest at source: /RR.exe (75,678,656 B) on Workbench B and one unindexed text entry on Workbench A. Within-server deduplication reduces 114 hashed rows to 109 per-server unique digests.

Workbench B holds one duplicate 9,848 B pair (/system_sa and /wws), while Workbench C holds four duplicate pairs (Mimikatz copies and /tools.dat matching /tools.zip). Removing the 3 shared public Mimikatz digests leaves 106 global unique SHA-256 digests.

Five Artifact Groups Across the 116 Staged Files

Static review partitions all 116 entries into five mutually exclusive groups (34 + 25 + 17 + 16 + 14 = 106 unique SHA-256 digests):

Artifact groupFilesShareUnique SHA-256UnhashedServersSize range (B)Defensive handling
Cross-platform ELF, ARM64 & Go agents3530.2%34039,848 to 6,430,904Hunt backoper_agent.elf & ws_linux_arm64
Windows DNS/HTTP beacons & shellcode2622.4%2512212 to 75,678,656Hunt 5 DNS/HTTP beacon & shellcode hashes
Credential harvest & lateral tooling2420.7%17022,834 to 9,258,745Hold public Mimikatz/fscan hashes; detect LSASS/SMB
Legitimate RMM package & log files1714.7%161327 to 25,337,156Hold RustDesk .deb & log hashes; enforce RMM policy
Privilege-escalation & callback scripts1412.1%1402102 to 8,030Hunt root_pwn.sh hash & HTTP script pulls

Figure 2 connects these five groups and the feed-labeled Cobalt Strike cohort to our published detection and hunting rules.

Figure 2: Detection rules separate custom beacons and ELF agents from dual-use kits
Figure 2: Detection rules separate custom beacons and ELF agents from dual-use kits

3. Workbench A: Dual-Channel DNS and HTTP Beacons With Cross-Platform Agents

In short

Observed in the United States on port 8000 between 19 and 20 November 2026, Workbench A exposes 82 files (81 unique SHA-256 digests). It pairs 21 Windows DNS and HTTP beacon builds (14 root, 7 equal-length secondary) with /backoper_agent.elf (6,430,904 B) and 26 cross-platform Go implants across Linux, Windows, and macOS. Inspect recursive DNS queries alongside web proxy logs and extend EDR coverage to Linux ARM64 and macOS workloads.

Workbench A (WB-01, United States, port 8000) operates as a multi-transport build directory. Its 82 files include 23 Windows beacon and shellcode binaries alongside 27 cross-platform ELF, Mach-O, and Go implants. The folder also stages 13 delivery scripts, 15 log and manifest files, and 4 Windows credential utilities added on 20 November 2026.

Equal-Length Secondary Builds Across 21 DNS and HTTP Beacons

Workbench A exposes 14 Windows beacon binaries in its root folder alongside 7 companion beacons in a task-numbered subfolder (name generalized). Comparing byte sizes against SHA-256 digests shows equal-length secondary files:

  • Seven equal-length pairs with distinct SHA-256 digests. Every secondary beacon has the same byte length as its root counterpart but a different SHA-256. The seven pairs cover /beacon_dns_x64.dll (166,400 B), /beacon_dns_x64.exe (167,424 B), /beacon_http_x64.dll (103,936 B), and /beacon_http_x64.exe (104,448 B). The remaining three pairs cover /beacon_http_x64_shellcode.bin (103,935 B), /beacon_http_x64_svc.exe (104,448 B), and /beacon_http_x86.exe (95,232 B). The inventory establishes equal lengths and different hashes, but does not identify the changed bytes.
  • DNS beacons add roughly 62.5 KB over HTTP builds. /beacon_dns_x64.dll (166,400 B) and /beacon_dns_x64.exe (167,424 B) measure 62,464 B and 62,976 B larger than their HTTP counterparts (103,936 B and 104,448 B). The file inventory establishes the size difference but does not identify the code responsible. DNS is a possible C2 transport (T1071.004).
  • Service wrappers, IAT-evasion builds, and shellcode. Additional root binaries include service wrappers (/beacon_win_x64_svc.exe at 104,448 B, /beacon_win_x64_svc2.exe at 94,720 B, and /beacon_win_x64_svc_v1.exe at 169,984 B). The folder also stages an import-table evasion build (/beacon_win_x64_iat.exe at 94,208 B), versioned executables (104,448 B to 169,984 B), /agent.x64.exe (104,448 B), and a 212-byte second_stage.bin payload.
Staged file(s) on Workbench A (:8000)Byte size (B)CopiesArchitecture & role
/beacon_dns_x64.dll & /beacon_dns_x64.exe166,400 / 167,4242 each64-bit Windows DNS C2 Beacon DLL and executable
/beacon_http_x64.dll, .exe & _svc.exe103,936 / 104,4482 each64-bit Windows HTTP Beacon DLL, EXE, and service wrapper
/beacon_http_x64_shellcode.bin103,9352Position-independent x64 HTTP Beacon raw shellcode
/beacon_http_x86.exe & /beacon_win_x64_iat.exe95,232 / 94,2082 / 132-bit HTTP Beacon and x64 import-table evasion build
/beacon_win_x64_svc2.exe, _v1.exe, _v2.exe94,720 to 169,9841 eachService and versioned 64-bit Windows Beacon variants

/backoper_agent.elf and the 27-Binary Cross-OS Go (gopher) Fleet

Beside the Windows beacons sits a 27-binary cross-platform Go implant fleet targeting six OS and CPU combinations:

  • Eighteen 6,430,904-byte Linux AMD64 ELF builds. Eighteen files share the exact length 6,430,904 B (6.13 MB) with 18 distinct SHA-256 digests. Generic builds include /backoper_agent.elf, /agent.bin, /agent_custom_tag.bin, /gopher_linux_amd64.elf, /gopher_kali_linux_amd64.elf, and /gopher_linux_amd64_c2. They also include /gopher224.elf, /gopher_201_new.elf, /gopher_relay201.elf, /g_4tomcat.elf, /g42.bin, and seven task-tagged builds (target-specific prefixes withheld). The filenames match Mythic's gopher agent conventions or a custom fork, while the inventory does not identify which bytes differ across the 18 builds.
  • ARM64 Linux, ARM64 Windows, and macOS Mach-O coverage (9 builds). Two equal-length linux/arm64 ELF files (/gopher_linux_arm64.elf and its subfolder copy) measure 5,963,960 B each with distinct hashes. Three windows/amd64 builds measure 6,048,256 B each, and two windows/arm64 builds measure 5,523,456 B each. Two macOS Mach-O binaries cover Intel (/gopher_macos_amd64.macho at 6,209,664 B) and Apple Silicon (/gopher_macos_arm64.macho at 5,854,658 B).

Out-of-Band Callback Scripts and Late Credential Staging

Thirteen scripts and fifteen log files support delivery and callback verification. Python scripts include /oob_listener.py (1,485 B). Five callback logs (73 B to 599 B) reference ports 8890, 9001, 9123, and 10143.

Companion scripts include /execws.py (1,929 B), /conn.py (269 B), and /conn2.py (399 B). Additional helpers include /serve_raw.py (553 B), /serve_small.py (499 B), and a 485 B HTTP server helper.

The directory also holds an IMAP canary (2,204 B), a 102 B batch file, and a 3,010 B PowerShell sweep script. An appliance-themed subfolder holds c2_server.py (5,198 B), agent.js (744 B), start.sh (296 B), and three C2 logs. All 78 beacon, Go, script, and log files were indexed on 19 November 2026. Four Windows credential dumpers (/mimikatz.exe, /mimilib.dll, /mimidrv.sys, and /ps64.exe) were added on 20 November 2026.

4. Workbenches B, C, and D: Root-Pwn Persistence, RustDesk Staging, and Lateral Kits

In short

Workbenches B (Hong Kong, port 8000, 12 files), C (China, port 80, 21 files), and D (South Korea, port 80, 1 file) show the post-foothold side of the model. They combine /root_pwn.sh, ARM64 and i386 Linux implants, a legitimate RustDesk Debian installer, and Mimikatz plus fscan lateral kits. Block unauthorized Linux RMM packages while hunting /root_pwn.sh and /ws_linux_arm64.

Workbenches B, C, and D illustrate privilege escalation, interactive remote-access persistence, and internal network discovery. Figure 3 models a hypothetical fallback sequence, and Figure 4 compares the four directory layouts.

Figure 3: Staged beacons and RustDesk in a hypothetical fallback model
Figure 3: Staged beacons and RustDesk in a hypothetical fallback model

Workbench B (:8000, Hong Kong): /root_pwn.sh, /ws_linux_arm64, and RustDesk Abuse

Observed on 20 November 2026 in Hong Kong on port 8000, Workbench B (WB-02) exposes 12 files (10 unique SHA-256 digests plus 1 unhashed executable):

  • Linux root escalation and WebSocket C2 stagers (9 files). /root_pwn.sh (8,030 B) sits alongside three 9,848 B Linux binaries: /system, /system_sa, and byte-identical /wws. Persistent C2 binaries span /ws (2,922,708 B), /ws_linux_arm64 (10,816 B), /cs/ws.bin (2,100 B), and two equal-length 534,256 B Linux agents (/c_agent and /c_a) with distinct SHA-256 digests.
  • Windows companions and the legitimate RustDesk 1.5.1 Debian package (3 files). Beside /system.exe (393,728 B) and /RR.exe (75,678,656 B, unhashed), Workbench B stages /rustdesk-1.5.1-x86_64.deb (25,337,156 B). RustDesk is a legitimate open-source remote desktop client (T1219). If installed, its Linux package can register rustdesk.service and use relay connections. The staged file alone does not establish persistence, GUI access, or EDR fallback. Because RustDesk is legitimate third-party software, its SHA-256 is withheld; defenders should detect unauthorized HTTP .deb pulls (SID 9541005), dpkg/apt installs (Sigma Rule 1), and .deb command lines or URLs (Sentinel KQL).
Figure 4: Four HTTP directories expose multi-arch implants, privesc kits, and RMM
Figure 4: Four HTTP directories expose multi-arch implants, privesc kits, and RMM

Workbenches C (:80, China) and D (:80, South Korea): fscan, Mimikatz, and /tcp_linux_i386

  • Workbench C (WB-03, China, port 80, 21 files, 17 unique SHA-256s). Observed from 14 to 20 November 2026, Workbench C stages /fscan.exe (8,785,920 B), /mimikatz.exe (1,355,264 B), /mimilib.dll (37,376 B), /mimidrv.sys (37,208 B), /mimikatz.zip (1,206,166 B), and /test.txt (27 B). It also hosts /tools.zip, byte-identical /tools.dat (9,258,745 B), and /tools.tar.gz (9,252,130 B). Unpacked Win32 (mimikatz.exe at 1,084,416 B, mimilib.dll, mimilove.exe, mimispool.dll, mimidrv.sys) and x64 folders sit alongside /mimikatz/kiwi_passwords.yar (2,834 B). All Workbench C hashes represent public dual-use releases or generic archives and stay withheld.
  • Workbench D (WB-04, South Korea, port 80, 1 file). Observed on 20 November 2026, Workbench D serves a single extensionless 32-bit Linux executable at /tcp_linux_i386 (2,607,220 B), suited to legacy 32-bit Linux appliances. Because this staging directory holds a single stager binary without companion kit files, its hash stays withheld.
Directory & portFile pathByte size (B)Role & indicator handling
Workbench B (HK :8000)/root_pwn.sh & /ws_linux_arm648,030 / 10,816Linux root script & ARM64 WebSocket stager · Published SHA-256s
Workbench B (HK :8000)/c_agent, /c_a, /ws, /cs/ws.bin2,100 to 2,922,708Equal-length Linux agents & WebSocket stagers (/c_agent hash withheld)
Workbench B (HK :8000)/rustdesk-1.5.1-x86_64.deb25,337,156Legitimate RustDesk Debian package · Hash withheld (RMM policy)
Workbench C (CN :80)/fscan.exe, Mimikatz, kiwi_passwords.yar2,834 to 9,258,745Public internal scanner, Win32/x64 Mimikatz & archives · Held
Workbench D (KR :80)/tcp_linux_i3862,607,220Standalone 32-bit Linux TCP stager · Hash withheld

5. Post-Exploitation Cloud C2 Cohort: Feed-Labeled Cobalt Strike vs Other Feed Matches

In short

We reviewed 153 endpoints on 137 hosts from 97,103 Cobalt Strike, Sliver, and Metasploit feed records. Twelve ports on eight AWS and Azure hosts carry confirmed Cobalt Strike feed labels. The supplied records do not establish independent beacon or protocol confirmation. Withhold all eight cloud addresses from firewall blocklists and route their four TLS JARM fingerprints and 141 other endpoints to hunting.

To evaluate upstream C2 feed records, we examined 153 recently observed endpoints from 19 to 20 November 2026. Those endpoints span 137 distinct hosts drawn from 97,103 cumulative feed records. Table 5.1 summarizes all four categories.

Feed categoryTotal feed rowsFeed-verifiedCountriesReviewed endpointsDistinct hostsFeed-confirmed (Hunt, withheld)Other reviewed (Hunt, withheld)
cobaltstrike80,37539105716012 (8 hosts withheld)59 (cloud, cert collision & telecom)
cobaltstrikeunverified7,037062109010 (unverified Azure/AWS TLS)
sliver5,59223834036040 (ports 443, 8443, 31337 & ISP)
metasploit4,0993853232032 (shared JARM, :3790 & ISP)
Total97,10365-15313712 (8 hosts withheld)141 (129 hosts withheld)

Twelve Feed-Labeled Cobalt Strike Ports Across Eight Withheld Cloud Hosts

The source inventory labels 12 of 153 reviewed endpoints as confirmed Cobalt Strike, but the supplied records do not establish independent beacon or protocol confirmation. Those 12 endpoints (7.8% of the sample, or 0.012% of 97,103 feed rows) were observed on 19 November 2026 across eight commercial cloud hosts (addresses withheld):

  • AWS and Azure concentration (7 AWS hosts, 1 Azure host, addresses withheld). Seven hosts (11 ports) sit on Amazon.com, Inc. in Australia (3 hosts), Germany (2 hosts), the United States (1 host), and Japan (1 host). The eighth host (:443) sits on Microsoft Corporation (Azure) in the United States. Because the inventory does not include independent beacon or protocol confirmation, all eight IPv4 addresses are withheld and excluded from firewall blocklists.
  • Dual-port HTTP (80) and HTTPS (443) pairing (4 hosts / 8 ports). Four AWS hosts (one in the United States, two in Germany, and one in Australia) expose paired Cobalt Strike listeners on TCP 80 and 443. Two Australian AWS hosts also share an identical custom certificate Common Name (withheld) and identical JARM (29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df96).
Withheld cloud host & port(s)Geo & cloud providerTLS JARM fingerprint (on :443)Observed date
Cloud Host 1 (:443, address withheld)US · Microsoft Corporation27d40d40d00040d00042d43d0000007d20e9b9a3e87aa1ec17cb4d646ce9a519 Nov 2026
Cloud Host 2 (:443 & :80, address withheld)US · Amazon.com, Inc.1dd40d40d00040d0001dd40d1dd40dc7fe523f2d40ec58fa09eb4367e8809419 Nov 2026
Cloud Host 3 (:443 & :80, address withheld)DE · Amazon.com, Inc.29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df9619 Nov 2026
Cloud Host 4 (:443 & :80, address withheld)DE · Amazon.com, Inc.(no JARM recorded on capture)19 Nov 2026
Cloud Host 5 (:443 & :80, address withheld)AU · Amazon.com, Inc.29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df9619 Nov 2026
Cloud Host 6 (:443, address withheld)AU · Amazon.com, Inc.29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df9619 Nov 2026
Cloud Host 7 (:443, address withheld)AU · Amazon.com, Inc.1dd40d40d00040d00042d43d000000e1ea2a807a629b496b664cf07ad7c08d19 Nov 2026
Cloud Host 8 (:443, address withheld)JP · Amazon.com, Inc.29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df9619 Nov 2026

Four Patterns Behind the Remaining 141 Withheld C2 Endpoints

  1. Dynamic telecom broadband churn (10 ISP endpoints). Two Cobalt Strike rows tagged confirmed upstream sit on dynamic Chinanet subscriber space. Eight more Cobalt Strike, Sliver, and Metasploit rows sit on Chinanet, China Telecom, China Mobile, and Moroccan carrier networks.
  2. Cross-family JARM and CDN certificate collisions (22 endpoints). JARM 29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df96 appears on 4 feed-confirmed Cobalt Strike AWS hosts, 2 other Cobalt Strike hosts, and 12 Metasploit :443 AWS hosts (18 total). Three more Cobalt Strike rows present shared CDN/appliance certificates (CloudFlare Origin Certificate), and one shares an open directory.
  3. Unverified Azure TLS templates (10 endpoints). Eight of ten cobaltstrikeunverified rows sit on Microsoft Azure (US and NL) presenting generic CN=ARM (7 endpoints on 6 hosts) or CN=CA (1 endpoint) certificates without beacon confirmation.
  4. Sliver (40) and Metasploit (32) red-team defaults. Six Sliver rows expose default multiplayer port 31337, three use CN=localhost, and two Metasploit rows expose default UI port 3790, matching everyday red-team setups.

6. Why Most Feed and Directory Entries Stay Off Blocklists

In short

We reviewed 97,103 C2 feed rows (153 endpoints) and 116 exposed directory files (97,219 combined records). Our public indicator set retains five custom SHA-256 digests and four Cobalt Strike TLS JARM fingerprints for hunting. All 153 C2 endpoints, including twelve feed-labeled Cobalt Strike ports on eight cloud hosts, remain withheld from blocklists. Apply four analytical boundaries before acting on open-directory or feed indicators.

Figure 5 compares log10-scaled feed and directory counts against the 12 feed-labeled Cobalt Strike ports (addresses withheld) and the 5 custom SHA-256 digests published in Chapter 9.

Figure 5: Only 5 custom hashes and 4 TLS JARMs are published across 97,219 records
Figure 5: Only 5 custom hashes and 4 TLS JARMs are published across 97,219 records

Four practical limits govern our conclusions:

  1. Analytical model across zero shared hosts. Zero shared IPv4 addresses or custom implant hashes link the four directories to each other or to the 137 C2 hosts. They illustrate complementary layers of post-exploitation operations, not one actor.
  2. Staged files do not establish downstream breaches. Observing /beacon_dns_x64.dll, /backoper_agent.elf, /root_pwn.sh, or /rustdesk-1.5.1-x86_64.deb in an open directory shows what an operator built or staged, not whether any external target was breached.
  3. Withheld workbench addresses and target-tagged filenames. All four open directories are assessed as adversary payload-staging workbenches, so generic implant filenames, staging paths, and five primary implant SHA-256 digests are published for hunting. Three more digests stay withheld because an earlier Odin report withheld the same files. We withhold the four workbench IPv4 addresses and generalize task-numbered or target-tagged filenames on Workbench A to avoid exposing target-specific strings or ephemeral VPS addresses.
  4. Why 41 dual-use, RustDesk, and log files stay off hash lists. Blocking the SHA-256 of /rustdesk-1.5.1-x86_64.deb misclassifies an open-source Debian package, and blocking /test.txt (27 B) or short logs risks noisy collisions. Enforce Linux RMM policies (T1219) and LSASS protections (T1003.001) instead.

7. What Defenders Should Do

Network and DNS security

  • Require independent beacon or protocol confirmation before placing upstream C2 feed addresses on firewall blocklists, and keep uncorroborated cloud and dynamic-ISP endpoints in hunting workflows.
  • Route endpoint DNS through internal resolvers, block direct outbound port 53 and unapproved DoH/DoT, and alert on high-entropy TXT or AAAA query bursts (T1071.004).

Linux platform and remote-access governance

  • Lock dpkg and apt on Linux servers to signed internal mirrors, block ad-hoc RustDesk .deb installs (rustdesk.service), and restrict outbound ports 21115 to 21119 (T1219).
  • Confirm EDR coverage across Linux ARM64, Linux x86_64/i386, Windows ARM64, and macOS .macho hosts, and close unauthenticated python3 -m http.server listeners on testing VPS assets.

Windows endpoint hardening

  • Enable Credential Guard and LSA Protection (RunAsPPL=1), block mimidrv.sys, and alert when rundll32.exe or regsvr32.exe loads unsigned DLLs from writable staging folders.

SOC and threat hunting

  • Deploy the Suricata, Sentinel KQL, Sigma, and YARA rules in Chapter 8 alongside the five custom SHA-256 digests in Chapter 9, keeping JARMs and public tool hashes hunt-only.

8. Detection Rules

The full deployable files sit in the Detection rules tab. On 21 November 2026, all four files passed static checks: Suricata lint (0 problems), Kusto type-checking (0 diagnostics), pySigma validation (2 rules), and YARA-X compilation (3 rules). Because the rules were not replayed against live traffic on this build host, test and tune them in staging before deployment.

Rule fileWhat it catches
odin_dual_dns_http_beacons_backoper_and_rustdesk.rulesSuricata 7: six signatures for staged DNS/HTTP beacons, backoper_agent.elf, Go gopher_* builds, /root_pwn.sh, RustDesk .deb pulls, and open directories
sentinel_dual_beacons_backoper_rustdesk_and_c2_hunt.kqlMicrosoft Sentinel & Defender XDR: seven-day fullouter join across custom hashes, staged beacon/ELF/root_pwn.sh processes, command lines mentioning a RustDesk .deb file, and staged payload URLs (returns process-only, network-only, and combined rows)
sigma_dual_beacons_backoper_root_pwn_and_rustdesk.ymlSigma (2 rules): Linux backoper/gopher/ARM64/root_pwn.sh and RustDesk .deb execution, plus Windows DNS/HTTP beacon execution
odin_dual_beacons_backoper_and_root_pwn_artifacts.yarYARA (3 bounded rules): dual-beacon and backoper manifests, Linux root_pwn.sh and ARM64 WebSocket bundles, and Mimikatz/kiwi_passwords.yar/fscan kits

How the Suricata Signatures Work

SIDLooks forOperational intent
9541001HTTP GET for /beacon_dns_x64*, /beacon_http_x64*, /beacon_http_x86.exe, or /beacon_win_x64*Catch HTTP pulls of staged DNS/HTTP beacons, service wrappers, IAT builds, and shellcode
9541002HTTP GET for /backoper_agent.elf, /agent_custom_tag.bin, /agent.bin, /agent.x64.exe, or /c_agentCatch HTTP staging of custom Linux ELF and Windows agent payloads
9541003HTTP GET for /gopher_linux_*, /gopher_kali_linux_amd64.elf, /gopher_windows_*, /gopher_win_x64.exe, or /gopher_macos_*.machoCatch cross-platform Go implant pulls across Linux, Windows, and macOS
9541004HTTP GET for /root_pwn.shCatch retrieval of the staged Linux root privilege-escalation script
9541005Outbound HTTP GET matching /rustdesk- and x86_64.debPolicy/hunt alert for direct HTTP pulls of RustDesk Debian packages
9541006Inbound HTTP 200 Directory listing for / naming beacon_dns_x64, backoper_agent.elf, root_pwn.sh, ws_linux_arm64, tcp_linux_i386, or kiwi_passwords.yarSpot exposed implant staging directories browsed from internal hosts

Keep SID 9541005 in alert-only mode where Linux administrators legitimately fetch RustDesk over HTTP. Pair SID 9541001 through SID 9541006 with internal DNS resolver logging to spot DNS beacon tunneling (T1071.004).

How the KQL, Sigma, and YARA Rules Work

The Sentinel KQL query looks back seven days across DeviceProcessEvents and DeviceNetworkEvents. On the process side, it matches the five custom SHA-256 digests, staged beacon_*, backoper_agent.elf, gopher_*, ws_linux_arm64, or root_pwn.sh command lines, and command lines mentioning a RustDesk .deb file. The network side adds staged-payload URL matches; the fullouter join also returns process-only and network-only rows.

Host allowlists in KQL (ApprovedRedTeamHosts, ApprovedRmmPilotHosts) and Sigma (filter_validation_hosts, filter_validation_win) match exact hostnames only (REDTEAM-BUILD-VPS-01, SEC-VALIDATION-LNX-01, SEC-VALIDATION-WIN-01, IT-RUSTDESK-PILOT-01). Those exclusions never hide a match on the five custom implant hashes.

Engine & ruleSeverityFires when
Sigma 1: Linux Multi-Arch backoper / gopher / root_pwn or RustDesk .debHighLinux runs backoper_agent.elf, ws_linux_arm64, tcp_linux_i386, gopher_linux_*, root_pwn.sh, or dpkg/apt with rustdesk-1.5.1-x86_64.deb
Sigma 2: Windows Dual-Channel DNS or HTTP Beacon ExecutionHighWindows runs staged beacon_* executables or rundll32/regsvr32 loading beacon_dns_x64.dll or beacon_http_x64.dll
YARA 1–3: Bounded Manifest & Bundle Suite (< 256 KB)Hunt / HighMatches dual-beacon/backoper manifests, root_pwn.sh + ARM64/RMM bundles, and kiwi_passwords.yar + fscan/Mimikatz kits

MITRE ATT&CK Mapping

TacticTechniqueObserved evidenceDetection
Command and ControlT1071.004 Application Layer Protocol: DNSbeacon_dns_x64.dll (166,400 B) & beacon_dns_x64.exe (167,424 B)SID 9541001; KQL; Sigma 2; YARA 1
Command and ControlT1071.001 Application Layer Protocol: Web Protocolsbeacon_http_x64*, /ws_linux_arm64, /cs/ws.bin, and 12 feed-labeled :80/:443 Cobalt Strike portsSID 9541001; KQL; Sigma 1–2
Command and ControlT1219 Remote Access Software/rustdesk-1.5.1-x86_64.deb (25.34 MB) beside root_pwn.sh and ws_linux_arm64SID 9541005; KQL; Sigma 1; YARA 2
Privilege EscalationT1068 Exploitation for Privilege Escalation/root_pwn.sh (8,030 B) staged alongside /system and /system_sa (9,848 B)SID 9541004; KQL; Sigma 1; YARA 2
Credential AccessT1003.001 OS Credential Dumping: LSASS MemoryWin32/x64 Mimikatz, mimidrv.sys, and kiwi_passwords.yar on Workbenches A & CSID 9541006; YARA 3

9. Indicators

The Indicators tab holds 9 published indicators: 5 custom SHA-256 digests and 4 TLS JARM fingerprints. All 12 feed-labeled Cobalt Strike address-and-port entries across eight cloud hosts are withheld pending independent protocol confirmation. Eight text-only file and URI patterns appear below for proxy and EDR hunting.

Indicator typePublished countRecommended action
Custom Windows beacon, shellcode, ELF, ARM64 & script SHA-256s8Hunt across Windows, Linux x86_64, and Linux ARM64 EDR
Feed-labeled Cobalt Strike TLS JARM fingerprints4TLS hunting only; never block on a JARM fingerprint alone
Staged URI and filename patterns (text-only below)8Proxy, NDR, and command-line hunting
Feed-labeled Cobalt Strike cloud addresses (12 ports on 8 hosts)0 (withheld)Withheld pending independent beacon or protocol confirmation

Custom Implant and Script SHA-256 Digests to Hunt (5 Hashes)

SHA-256 digestStaged filenameSize (B)Platform & role
8eecab05f564d2e23c876a7dea636b9a3581737ff21d648043d5d2a6a60add97/beacon_dns_x64.exe167,424Windows x64 DNS C2 Beacon executable (WB-01)
4d207c3508e92547c093d81dd41e97bc1123dc3b4e4de8d8bdc0b1846b8bd7bf/beacon_http_x64.dll103,936Windows x64 HTTP C2 Beacon DLL (WB-01)
4d2eedd82563b15f93ff9e931e8d3caa68e04f14d95495c439e951d9eeab7086/beacon_http_x64.exe104,448Windows x64 HTTP C2 Beacon executable (WB-01)
2773e2b5c49544f6c1e33c4c75e9b1320e78d8874ee0f4a046ce79ceb034de2b/root_pwn.sh8,030Linux root privilege-escalation shell script (WB-02)
9c2ef0205fe3a98208b44879a67e14007ac4c956acfe6a784c400d0928b8ff3b/ws_linux_arm6410,816Linux ARM64 WebSocket C2 stager (WB-02)

TLS JARM Fingerprints to Hunt (4 Fingerprints)

JARM fingerprintObserved onCollision warning
27d40d40d00040d00042d43d0000007d20e9b9a3e87aa1ec17cb4d646ce9a5Feed-labeled Cobalt Strike :443 host on Azure (US, address withheld)Hunt only; combine with SNI, URI, or process activity
1dd40d40d00040d0001dd40d1dd40dc7fe523f2d40ec58fa09eb4367e88094Feed-labeled Cobalt Strike :443 host on AWS (US, address withheld)Hunt only; never block on JARM alone
1dd40d40d00040d00042d43d000000e1ea2a807a629b496b664cf07ad7c08dFeed-labeled Cobalt Strike :443 host on AWS (AU, address withheld)Hunt only; never block on JARM alone
29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df96Four feed-labeled AWS Cobalt Strike :443 servers (addresses withheld)High collision: also seen on 2 other CS and 12 Metasploit AWS hosts

Text-Only Staging Path and Filename Hunt Patterns

PatternContextWhere to hunt
/beacon_dns_x64. & /beacon_http_x64Dual-channel Windows Beacon DLL, EXE, service, and shellcode pullsSuricata SID 9541001, proxy logs, Windows EDR
/backoper_agent.elf & /agent_custom_tag.binCustom 6,430,904 B Linux x86_64 ELF implant namesSuricata SID 9541002, Linux auditd / EDR
/gopher_linux_arm64.elf & /gopher_macos_arm64.machoCross-compiled Go ARM64 server and Apple Silicon macOS implantsSuricata SID 9541003, cloud & macOS EDR
/root_pwn.sh8,030 B Linux privilege-escalation shell scriptSuricata SID 9541004, Linux command-line logs
/ws_linux_arm64 & /cs/ws.binLinux ARM64 WebSocket binary (10,816 B) and 2,100 B WebSocket stagerLinux EDR & outbound WebSocket proxy logs
/rustdesk-1.5.1-x86_64.debLegitimate RustDesk Debian installer staged alongside escalation scriptsSuricata SID 9541005 (hunt), dpkg/apt logs
/tcp_linux_i3862,607,220 B standalone 32-bit Linux TCP stagerLinux appliance & legacy server process logs
/mimikatz/kiwi_passwords.yarStaged Mimikatz YARA file beside fscan.exe and mimidrv.sysSuricata SID 9541006, YARA 3

Withheld: all four open-directory host addresses, all 137 C2 host addresses (153 endpoints, including the eight cloud hosts with 12 feed-labeled Cobalt Strike ports), custom certificate Common Names, and target-tagged filenames on Workbench A. Also withheld are all 98 remaining file SHA-256 digests from the 106-digest workbench corpus, including /rustdesk-1.5.1-x86_64.deb, public Mimikatz and fscan.exe releases, and single-binary watchlist files.

10. Scope and Limits

This edition covers records dated 14–20 November 2026. It examines four open HTTP directories (116 files, 106 unique SHA-256 digests) and 153 C2 endpoints (137 hosts) from 97,103 feed records. Open-directory findings rely strictly on static file metadata (paths, byte lengths, dates, and cryptographic digests). No binary, DLL, shellcode blob, or shell script was run or tested against external systems.

Zero shared IPv4 addresses or custom hashes link the four directories to each other or to the 137 C2 hosts. Readers should treat the cross-directory and C2 synthesis strictly as an analytical model rather than one intrusion campaign. Because the inventory records for the twelve feed-labeled Cobalt Strike ports do not establish independent beacon or protocol confirmation, all eight cloud host addresses remain withheld.

11. Sources

  1. MITRE ATT&CK, Software S0154: Cobalt Strike (HTTP/HTTPS and DNS Beacon Architecture): https://attack.mitre.org/software/S0154/ (verified 21 November 2026).
  2. MITRE ATT&CK, Enterprise Sub-Technique T1071.004: Application Layer Protocol - DNS: https://attack.mitre.org/techniques/T1071/004/ (verified 21 November 2026).
  3. MITRE ATT&CK, Enterprise Sub-Technique T1071.001: Application Layer Protocol - Web Protocols: https://attack.mitre.org/techniques/T1071/001/ (verified 21 November 2026).
  4. MITRE ATT&CK, Enterprise Technique T1219: Remote Access Software: https://attack.mitre.org/techniques/T1219/ (verified 21 November 2026).
  5. RustDesk Open-Source Remote Desktop Project, Official Client Source and x86_64 Debian Package Architecture: https://github.com/rustdesk/rustdesk (verified 21 November 2026).
  6. MITRE ATT&CK, Software S0002: Mimikatz Credential Dumping Suite: https://attack.mitre.org/software/S0002/ (verified 21 November 2026).
  7. MITRE ATT&CK, Software S0633: Sliver Cross-Platform Go Command-and-Control Framework: https://attack.mitre.org/software/S0633/ (verified 21 November 2026).
  8. Salesforce Engineering, JARM: Active Transport Layer Security Server Fingerprinting Specification: https://github.com/salesforce/jarm (verified 21 November 2026).

What is…?

Short explanations of the tools and families named in this study.

All explanations

Frequently asked questions

What did we find across the four open directories?

Defenders can use external attack surface management to find unauthenticated HTTP directory listeners that expose entire build trees on virtual private servers. We reviewed file paths, byte sizes, dates, and SHA-256 digests across four directories without running any binary or contacting external targets.

How do fixed-size DNS beacons and Go implants evade single hashes?

On Workbench A, 14 root Windows beacon files sit alongside a 7-file secondary build folder. Each secondary file has the same byte length as its root counterpart but a different SHA-256 digest.

Why is a RustDesk Debian package staged next to root escalation scripts?

Workbench B holds /root_pwn.sh (8,030 B), /ws_linux_arm64 (10,816 B), and /cs/ws.bin (2,100 B). The same folder holds /rustdesk-1.5.1-x86_64.deb (25,337,156 B). RustDesk is a legitimate open-source remote desktop program. If installed on a Linux host, the .deb package can register rustdesk.service and connect to relay servers. No installation or connection was observed here.

Which cloud C2 servers should defenders block versus hunt?

The four feeds contain 97,103 rows: Cobalt Strike (80,375), Cobalt Strike unverified (7,037), Sliver (5,592), and Metasploit (4,099). We examined 153 recently active endpoints across 137 hosts. The source inventory labels 12 of 153 reviewed endpoints as confirmed Cobalt Strike, but the supplied records do not establish independent beacon or protocol confirmation.

Defender kit

Indicators of compromise

Verified adversary infrastructure and tool hashes from this study. Every value below is also discussed in the report.

IDTypeIndicatorPortContextAction
R41-IOC-01 SHA-256 8eecab05f564d2e23c876a7dea636b9a3581737ff21d648043d5d2a6a60add97 beacon_dns_x64.exe · Windows x64 DNS C2 Beacon executable Hunt
R41-IOC-02 SHA-256 4d207c3508e92547c093d81dd41e97bc1123dc3b4e4de8d8bdc0b1846b8bd7bf beacon_http_x64.dll · Windows x64 HTTP C2 Beacon DLL Hunt
R41-IOC-03 SHA-256 4d2eedd82563b15f93ff9e931e8d3caa68e04f14d95495c439e951d9eeab7086 beacon_http_x64.exe · Windows x64 HTTP C2 Beacon executable Hunt
R41-IOC-04 SHA-256 2773e2b5c49544f6c1e33c4c75e9b1320e78d8874ee0f4a046ce79ceb034de2b root_pwn.sh · Linux privilege-escalation shell script Hunt
R41-IOC-05 SHA-256 9c2ef0205fe3a98208b44879a67e14007ac4c956acfe6a784c400d0928b8ff3b ws_linux_arm64 · Linux ARM64 WebSocket C2 stager Hunt
R41-IOC-06 JARM 27d40d40d00040d00042d43d0000007d20e9b9a3e87aa1ec17cb4d646ce9a5 Cobalt Strike TLS JARM (a withheld address:443, Microsoft Azure US) Hunt
R41-IOC-07 JARM 1dd40d40d00040d0001dd40d1dd40dc7fe523f2d40ec58fa09eb4367e88094 Cobalt Strike TLS JARM (a withheld address:443, AWS US) Hunt
R41-IOC-08 JARM 1dd40d40d00040d00042d43d000000e1ea2a807a629b496b664cf07ad7c08d Cobalt Strike TLS JARM (a withheld address:443, AWS AU) Hunt
R41-IOC-09 JARM 29d29d00029d29d00041d41d00041dcb3f8752a2d70d1dbf446fc46ab5df96 Cobalt Strike TLS JARM (4 confirmed AWS listeners across AU, DE, and JP) Hunt

23 records from this study are not published in this table: candidate, suspected and dual-use hosts, victim-related values, and hashes of exposed secrets or files.

Defender kit

Detection rules

The rule files exactly as printed in the report. Test them in your own engine before deployment.

YARA odin_dual_beacons_backoper_and_root_pwn_artifacts.yar 65 lines
Download
Suricata odin_dual_dns_http_beacons_backoper_and_rustdesk.rules 18 lines
Download
Sentinel KQL sentinel_dual_beacons_backoper_rustdesk_and_c2_hunt.kql 52 lines
Download
Sigma sigma_dual_beacons_backoper_root_pwn_and_rustdesk.yml 85 lines
Download