About this post: Thanks to MalwareHunterTeam for flagging this new payload. This analysis and write-up were produced by Claude (Opus 5.5), working as an agent in Claude Code on a REMnux analysis VM. Tools used: Malcat, capa, Binary Refinery, objdump, Recorded Future Triage, Censys and tshark.
TL;DR
mini_agent is a small backdoor for Linux servers and desktops. It deletes itself from disk, keeps running from memory under a name that looks like a normal system process, and calls home over HTTPS. Its traffic is built to look like an app talking to Microsoft’s Graph API. Underneath, it speaks the protocol of AdaptixC2, an open-source command-and-control framework, so whoever runs it gets a full remote-control panel. It is one of at least nine builds of the same custom agent seen since mid-October.
- What it is: a remote-access backdoor for 64-bit Linux, written in C. It is unsigned, 250 KB, and has no outside libraries.
- How it hides: it copies itself into memory, deletes the original file, and restarts under names such as
[kworker/u8:2],[kthreadd]orudevd. - How it talks: HTTPS
POSTrequests to paths such as/v1.0/meand/beta/me/profile, with a Microsoft Graph user-agent. They go to fiveviispaww[.]cc/viispaww[.]viphosts behind Cloudflare. - What the operator can do: run programs, browse, copy, delete and steal files (whole folders as zip), take screenshots, and open network tunnels into the victim’s network.
- Good news: it has no built-in way to survive a reboot, and its TLS handshake has an unusual quirk that makes it easy to spot.
Where the file lives: nowhere
Most malware leaves a file you can find and delete. This one deletes its own.
When mini_agent starts, it reads its own program into memory and creates an in-memory file. Linux calls this a memfd: a file that exists only in RAM. The agent names it after a harmless-looking process, picked at random from six: [kworker/u8:2], [kthreadd], [rcu_sched], udevd, systemd-journal or dbus-daemon. It then deletes the original file and restarts itself from the in-memory copy.
The result is a process that looks like part of the operating system in a process list and has no file on disk behind it. We saw exactly this in the Triage sandbox. The program started as /tmp/mini_agent, the file disappeared, and the same process carried on as udevd.

Microsoft Graph, but not really
The settings (the "config") are stored inside the program, encrypted with AES, a standard strong cipher. The key is hidden in the code. Once decrypted, the config shows that the operators put real effort into blending in:
- Requests go to paths copied from Microsoft’s Graph API, which Office 365 apps use every day:
/v1.0/me,/beta/me/profile,/v1.0/me/drive/items/…,/api/v2.0/me/drive/root/children. - The user-agent (the "who’s asking" label on a web request) is
MicrosoftGraph/1.0 (featureUsage=6), or a current Edge browser string. - Headers such as
Accept: application/json;odata.metadata=minimalandX-Ms-Client-Request-Idcopy real Graph requests. The agent hides its check-in data in that last header.
The catch is the destination. None of these requests go to Microsoft. They go to cdn-6piob[.]viispaww[.]cc and four sibling hosts, all behind Cloudflare. The certificates for both domains were issued on the same afternoon, 2 November 2026, so this infrastructure is very new.
Built on an open-source C2 framework
AdaptixC2 is a public, open-source command-and-control framework. Red teams use it, and so, increasingly, do criminals. It ships with two agents: a Windows "Beacon" written in C++ and a cross-platform "Gopher" written in Go.
mini_agent is neither of those. It is a separate program written in C, but it reuses AdaptixC2’s message formats almost line for line:
- Its built-in settings use the same field names as Gopher’s (
addresses,banner_size,conn_timeout, …). - The system details it sends when it first checks in are Gopher’s exactly (
process,user,host,elevated,os_version,encrypt_key, …). - Its first 14 command numbers are identical to Gopher’s: 1 = print the current folder, 2 = change folder, 3 = run a program, 4 = exit, and so on.
- Its check-in message is wrapped exactly the way the standard AdaptixC2 web listener (the server side) expects.
So the operator doesn’t need a custom server. A normal AdaptixC2 install plus this custom agent plugin is enough. It also explains the extras that Gopher lacks: a find command, md5sum, zip and unzip, live sleep-time changes, and an unused DNS-over-HTTPS transport.
What the operator can do
Through the AdaptixC2 panel, the operator can:
- run any program and read its output;
- list, read, create, copy, move and delete files and folders;
- upload files to the machine, or download single files and whole folders (packed as zip, sent in 1 MB pieces in the background);
- list and kill processes;
- take a screenshot with whatever screenshot tool is installed (
scrot,maim,gnome-screenshot, …); - open network tunnels and reverse port-forwards, which turns the infected machine into a doorway into the rest of the network;
- change how often it checks in. The default is every 30 seconds, randomised by 20 %.
The tell in the handshake
mini_agent doesn’t use the system’s TLS library (the code that makes HTTPS secure). It carries its own small implementation, and that implementation has a quirk. Every TLS connection starts with a "hello" message containing 32 random bytes, and by tradition the first four used to hold the current time. In every connection this agent made in the sandbox, those four bytes were 00 00 00 00. Other programs on the same machine filled them with random data.
Together with its short list of offered ciphers, this gives a stable fingerprint, JA3 5e2df0c3adc551a34e46a9ecb0d7cb66. It is useful for spotting the agent even when it hides behind Cloudflare.
Not a one-off: nine builds in five weeks
Searching VirusTotal for one of the agent’s debug messages turns up eight more builds, first seen between 15 October and 15 November 2026. We decrypted every one of them. All nine carry the same internal AdaptixC2 agent ID, so they are all builds of this one custom agent, aimed at four different server setups:
- Mid-October:
fsmonitordandprocmgrd, callingqshuimusic[.]top,sat-boleto[.]topandmtc-factura[.]topwhile posing as requests for website JavaScript files. These two still use a placeholder key,0123456789abcdef. - Late October:
mgx.binbuilds, calling older, re-used domains (ccjszl[.]com,netutilsblog[.]com,cjkingentertainment[.]com) dressed up as jQuery and WordPress requests. - 28 October: a test build named
c2_memfd_implant, the first one with the "restart from memory" trick. - November: the Microsoft Graph disguise, on
leidanwmo[.]top/sat-servir[.]topand then on theviispawwdomains from this post.
Two of the builds reached VirusTotal under names like /memfd:dbus-daemon (deleted). That is what you get when someone copies the program out of a running, infected Linux machine, so these agents have been used against real systems.
The same domains are also contacted by Windows programs. We unpacked a sample of them. Each one is a small launcher that decrypts and runs the standard, unmodified AdaptixC2 Windows agent, and the launcher is rebuilt with fresh scrambling for every copy. The Windows agents use exactly the same server addresses, web paths and keys as the Linux builds, so both report to the same control servers. One operation is running the stock Windows agent and this custom Linux agent side by side.
A small Windows DLL seen with the same servers is a cryptocurrency "clipper". It watches the clipboard, and when you copy a wallet address it swaps in one of the attacker’s own: Bitcoin, Ethereum, Litecoin, TRON, TON, XRP or Solana. We can’t prove the same people deployed it, but it showed up alongside these servers in the same week.
A second tell: the tunnel handshake
When the operator opens a network tunnel, the agent makes a separate HTTPS request carrying an odd header, X- followed by eight hex characters, with the value 1. In this build that header is X-bcfb68ed: 1. The server has to reply with the four letters TUOK before tunnel traffic flows. The eight characters are derived from each server’s key, so every build in the table below has its own.
What we couldn’t see
- How it arrives. We only had the backdoor itself, so we don’t know what drops it.
- What the operator sent. In the sandbox, the server answered every check-in, and its replies to registration and polling differed in size, so the backend appears to be live. The traffic is encrypted, though, and the sandbox couldn’t record keys for the agent’s own TLS code, so we couldn’t read the replies. Their steady size suggests no commands were sent during the run.
- The real server. Cloudflare sits in front of every C2 host, and we found no origin server behind it.
- Persistence. Nothing in the program makes it start again after a reboot. Because it deletes its own file, a reboot removes it unless the attacker added persistence separately, for example via the "run program" command.
Advice
For regular users and admins:
- A Linux process named like a kernel thread (
[kworker/…],[kthreadd]) should have no program file. Ifls -l /proc/<pid>/exepoints at/memfd:… (deleted), investigate. - Rebooting removes this agent from memory, but treat the machine as compromised and find out how it got in.
For defenders:
- Alert on Graph-API-style paths (
/v1.0/me,/beta/me/profile) and theMicrosoftGraph/1.0user-agent going to hosts that aren’t Microsoft. - Hunt for the JA3 fingerprint and for TLS ClientHellos whose random field starts with four zero bytes.
- Look for HTTP requests carrying an
X-<8 hex>: 1header answered withTUOK. - Hunt for processes whose executable is a deleted memfd.
Indicators of compromise
| Type | Indicator | Notes |
|---|---|---|
| SHA256 | a5a6c3c4779f1e14e7c2dd82f9e1d516590195e4ac5f41f6c3b107ae38723868 | mini_agent (ELF x64) |
| Domain | cdn-6piob[.]viispaww[.]cc | C2 (contacted in sandbox) |
| Domain | dxdzhu-api[.]viispaww[.]cc | C2 |
| Domain | static-eo9jo[.]viispaww[.]cc | C2 |
| Domain | edge-hm1na[.]viispaww[.]vip | C2 |
| Domain | 8ted50-dl[.]viispaww[.]vip | C2 |
| JA3 | 5e2df0c3adc551a34e46a9ecb0d7cb66 | agent’s built-in TLS client |
| JA4 | t12d030500_b80a1783d7a2_9af1e0025d52 | agent’s built-in TLS client |
| HTTP header | X-Ms-Client-Request-Id | carries check-in data to non-Microsoft hosts |
| File | /tmp/.yjsc_<8 hex>.png | temporary screenshot |
| SHA256 | dbce2dd297dd9689cbc6b4267931c16c990538036d6872f552aca2d0b885477e | sibling build (fsmonitord) |
| SHA256 | 58bfff115cfe2c4a5088f4bbf5fa2e86bbecf118f71090da15c9dd6650cb6d27 | sibling build (procmgrd) |
| SHA256 | 84a7c586f6c920596d9c7be66a56b8ad6810d86aa085ad3ac6b6350c3aad70cc | sibling build (mgx.bin) |
| SHA256 | c5b55958b4e829c01345b0d74958cbe7473b74ccda92e3ea6788dbc49fcdea49 | sibling build (mgx.bin) |
| SHA256 | eea28da56c06a32849dfaa0832b2ad9c7397974e3ab1365b66537e03b42331e9 | sibling build (mgx3.bin) |
| SHA256 | 5cdc55446a63ac08326e1785da344743f9608d64cadccc59110a873527aea705 | test build (c2_memfd_implant) |
| SHA256 | ae21c47b45e3e7a819d8050e01b6718dd5fa4995e25add992ab325be27a156ab | sibling build |
| SHA256 | fb29c836a1fb49db4dbc86d104279b27547756081eacbe387085c6fe38b38172 | sibling build (from a live host) |
| Domain | qshuimusic[.]top, sat-boleto[.]top, mtc-factura[.]top | C2 (October builds) |
| Domain | leidanwmo[.]top, sat-servir[.]top | C2 (November builds) |
| Domain | 1a993dc0.ccjszl[.]com, 04c2f3c0.netutilsblog[.]com, db69f5ff.cjkingentertainment[.]com | C2 subdomains on re-used domains |
| Domain | cdn-httptest.saisa[.]vip | C2 (test build) |
| HTTP header | X-bcfb68ed / X-14323b9a / X-d4c46a3e / X-4662bdea / X-b3409ebf with value 1 | tunnel side-channel header, one per server |
| SHA256 | e04c19e6be1f43bcc49098d2167171838c8980d258f4594091b868912941ee57 | Windows launcher for the AdaptixC2 agent |
| SHA256 | 1d3535d5a782488ca1e8c140877bbf7e8a2c8ba7716ef5ac329dde1c47798dc7 | Windows launcher for the AdaptixC2 agent |
| SHA256 | 626620ecdeba3a257dd328bc6921b137a162b4c06d9db4f2c1d05d382f75266f | Windows launcher for the AdaptixC2 agent |
| SHA256 | 3faf495eaf1d057505fd0ed5f69d7ec554c6988b0b0e1ea7129b39d7a2f757f6 | Windows AdaptixC2 agent (32-bit) |
| SHA256 | bc8cdd337b47637c0193714f3a82b1e6e8992f75cacc28618d93d6c2e19dd3b5 | clipboard wallet-swapper DLL |
| Wallet | bc1qg73sq2pz05hrcfdxul4kemq5kuew0wtekgzxxp | BTC (clipper) |
| Wallet | 0x8b551258684d959831186A09e77F58367b1DF7b0 | ETH (clipper) |
| Wallet | ltc1q99mt0262gmm650js6zmr3qa4jkmp0ezl6te7ad | LTC (clipper) |
| Wallet | TN5zbmLGbUbZ8vcDAQWhasaDJJAa2RFSCE | TRON (clipper) |
| Wallet | UQAa0PKO9LFF9iJk5yA0ZbZjEvhVgF94GS3ycNdiUVgSOOP_ | TON (clipper) |
| Wallet | rfdGoQQtsk2Pd2sT9Ag1HDJSH81RsuTyyb | XRP (clipper) |
| Wallet | APHP9afjSjZCZ9biBrzUf6TXE7tywsGsM8wYX4eJWjxQ | SOL (clipper) |
| Process | [kworker/u8:2], [kthreadd], [rcu_sched], udevd, systemd-journal, dbus-daemon | only when running from a deleted memfd |
Wrapping up
mini_agent shows how open-source C2 frameworks lower the bar. Someone wrote a small, quiet Linux agent in C, plugged it into a stock AdaptixC2 server, and dressed its traffic up as Microsoft Graph. The disguise is good, but the quirky TLS handshake and the memfd trick are both easy to hunt for once you know to look.
The sandbox run is public at tria.ge/261118-m29knset8v. AdaptixC2’s source code is on GitHub.