Hello from “systemd-journal”: A Fileless Linux Backdoor Talking Like Microsoft Graph

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] or udevd.
  • How it talks: HTTPS POST requests to paths such as /v1.0/me and /beta/me/profile, with a Microsoft Graph user-agent. They go to five viispaww[.]cc / viispaww[.]vip hosts 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.

How mini_agent runs: it restarts from memory under a fake system-process name, deletes its file, and then polls its server while dressed up as Microsoft Graph traffic.
Image: How mini_agent runs: it restarts from memory under a fake system-process name, deletes its file, and then polls its server while dressed up as Microsoft Graph traffic.

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=minimal and X-Ms-Client-Request-Id copy 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: fsmonitord and procmgrd, calling qshuimusic[.]top, sat-boleto[.]top and mtc-factura[.]top while posing as requests for website JavaScript files. These two still use a placeholder key, 0123456789abcdef.
  • Late October: mgx.bin builds, 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[.]top and then on the viispaww domains 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. If ls -l /proc/<pid>/exe points 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 the MicrosoftGraph/1.0 user-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>: 1 header answered with TUOK.
  • 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.