A 46 KB .NET loader with an encrypted config, a certificate pin that actually works, and a plugin bus that will run whatever the C2 sends. The first fake C2 got DNS and a TLS handshake but not one byte of application data. Here is how we got past that without touching the original sample.
Inside was a single 46,080-byte Windows PE named after its own SHA-256 the kind of file that arrives already knowing it will be hashed. VirusTotal had 57 of 75 engines calling it malicious, with labels clustering around AsyncRAT and MSIL. The compile timestamp said 2023; the first submission to VirusTotal said 2026-10-25, hours before it reached the lab.
The first detonation was almost boring in the way good lab runs are: the sample installed itself, set a Run key, relaunched from %AppData%, and spent the rest of the window trying to resolve a C2 name into a network that had no DNS server. The host pcap showed ARP requests for the Remnux address and nothing else. No DNS query, no TCP, no TLS. The implant was talking; the lab just was not answering.
So we answered. A DNS responder on the Remnux VM resolved the C2 name to the lab address, and a TLS listener waited on 443. The client connected every five seconds, sent a TLS 1.0 ClientHello with no SNI, completed the record-level handshake with our self-signed certificate and then sent nothing. No check-in, no plugin request, no error. Five seconds later it closed the socket and tried again.
The certificate pin was doing its job.
This is the story of what the stub contains, why a fake C2 cannot simply ask it for its secrets, and how a separate, instrumented copy re-pinned to a certificate we control let us watch the full application protocol: the ClientInfo check-in, the plugin request, the registry-backed DLL drop, and code execution inside the client process.
The rig, and what the evidence means
The work ran through malbox, our malware-analysis MCP server. Dynamic execution happened in the isolated VMware guest for710-win10, on host-only vmnet1, reverted to a clean snapshot before and after every run. Remnux (192[.]168[.]174[.]50) provided the fake internet. Static work .NET decompilation, config decryption, certificate parsing happened on the lab host. No sample bytes ever executed on the host, and the real C2 was never contacted.
Throughout this post:
- Observed means recorded in a guest run, a host pcap, or the isolated lab server.
- Static means reconstructed from the binary or its decompiled source.
- Inferred means a plausible explanation that still needs a trace.
192[.]168[.]174[.]50 is the lab Remnux address. It is infrastructure, not an indicator.
The sample on the bench
| Field | Value |
|---|---|
| SHA-256 | aa5ce2bb4008ae026c4e8b2fa3d02d0fdd296305dad0e6e4cfb4e3e92485ac9e |
| SHA-1 | c40f16583dde67cdfcdea811e2950eb810bbf1a8 |
| MD5 | bc9bb029da0de28ba546c80c2854e4d7 |
| Size | 46,080 bytes |
| Format | PE32 GUI, Intel 80386, .NET (MSIL), 3 sections |
| Compile timestamp | 2023-10-16 08:20:53 UTC |
| VirusTotal | 57/75 malicious; trojan.asyncrat/msil; engine labels include Marte |
| Imphash | f34d5f2d4577ed6d9ceec516c1f5a744 |
The PE is a .NET assembly with a single import, mscoree.dll!_CorExeMain. The interesting part is not the native stub; it is the managed code underneath. Decompiling it produced 2,272 lines of C# and a clean picture of an AsyncRAT 0.5.8 client.
VirusTotal’s Marte label is a detection name from some engines, not an attribution. AsyncRAT is open source; the 0.5.8 release is public, and the client is the part operators customize.
The config, unlocked
Client.Settings holds the configuration as strings encrypted with AES-256. The key is derived with PBKDF2-SHA1 (50,000 iterations) from an embedded master key; each blob is HMAC-SHA256(32) || IV(16) || AES-CBC(PKCS#7). The HMAC verified on every field, and the server signature — RSA-SHA256 over SHA256(Key) verified against the certificate embedded in the same binary.
| Setting | Value |
|---|---|
| C2 host | pea[.]radio[.]fm |
| Port | 443/TCP |
| Client version | 0.5.8 |
| Mutex | 7BSpMzZAtj5C |
| Install | true |
| Install path | %AppData%\GoogleUpdate.exe |
| Campaign group | Default |
| Pastebin fallback | null (direct C2) |
| Anti-analysis | false |
| BDOS / critical process | false |
| Server certificate | CN=AsyncRAT Server, self-signed, serial 0xc2bf6370b68bbd5d50e79b614fe9f7 |
| Certificate validity | 2026-10-23 → 9999-12-31 |
| Certificate SHA-1 | c981d59f64f0d619db82cfe0a9826319a2ee98f6 |
| Certificate SHA-256 | 0ab37e1fda8b832c7356e84f3a16a3f9727c79d82b80279440da1fce81037987 |
| SPKI SHA-256 | 915f0c875c25a295e4aff80f7870b5ae5b71f8b93f2bf1267edeee0f9c8670cc |
Two things are worth flagging. First, the Anti and BDOS switches are present but turned off. This build will not try the VMware/VirtualBox manufacturer checks, SbieDll.dll, CheckRemoteDebuggerPresent, the 61 GB disk check, or the Windows XP check and it will not call RtlSetProcessIsCritical to make itself unkillable. A different build from the same builder can flip either one. Second, the certificate is a self-signed 4096-bit RSA CA with a ten-thousand-year validity normal for an AsyncRAT builder, and a useful hunting fingerprint.
What the loader actually does
The entry point is deliberately small:
- Sleep
Delayseconds (3 in this build). Settings.InitializeSettings()decrypt the config, compute the HWID, load and verify the server certificate.- Create mutex
7BSpMzZAtj5C. If it already exists, exit. - If
Antiis true, run the anti-analysis routine. - If
Installis true, runNormalStartup.Install(). - If
BDOSis true and the process is elevated, callRtlSetProcessIsCritical. - Call
SetThreadExecutionStateto keep the machine awake. - Loop forever: if not connected, reconnect and initialize the client; sleep five seconds.
Install() is the part a responder sees:
- If the running file is not already
%AppData%\GoogleUpdate.exe, it enumerates processes and kills any process whose main module is that path. - Elevated:
schtasks /create /f /sc onlogon /rl highest /tn "GoogleUpdate" /tr "'<path>'"— a logon task at highest privileges. - Non-elevated:
HKCU\Software\Microsoft\Windows\CurrentVersion\Run\GoogleUpdate = "<path>". - It writes a temporary
.batthat waits three seconds, starts the installed copy, deletes the batch, and exits. The emptytmpXXXX.tmpleft behind isPath.GetTempFileName()residue, not a payload.
The network side connects to each resolved address on port 443, wraps the socket in SslStream, and calls AuthenticateAsClient with SslProtocols.Tls (TLS 1.0). The server certificate is checked by a callback that compares it to the embedded X509Certificate2. Then the client sends IdSender.SendInfo() and starts its read loop.
SendInfo() is the reconnaissance packet: HWID, username, OS, executable path, client version, admin/user state, active window title, installed AV product, install timestamp, and campaign group. The HWID is an MD5 of processor count, username, machine name, OS version, and system-disk size — stable enough to recognize a host, not a global identifier.
The command surface is not in the stub. Packet.Read handles only three message types: pong, plugin, and savePlugin. Everything else — remote desktop, keylogging, file manager, shell, upload/download, whatever the operator built — arrives later as a .NET plugin DLL. The stub is a loader with a mailbox.
Run one: persistence without a C2
The first detonation ran with Remnux powered off. The host pcap is the authoritative record, and it is almost empty: no DNS, no TCP, no TLS. The guest repeatedly ARPs for 192[.]168[.]174[.]50 its configured DNS server and gets no answer. The implant is retrying into a void.
Inside the guest, the observable behaviour was still complete:
- The launched sample exited with code 0 after installing.
GoogleUpdate.exe(PID 6028) was running fromC:\Users\REM\AppData\Roaming\.- The persistence diff showed the Run key:
HKCU\Software\Microsoft\Windows\CurrentVersion\Run\GoogleUpdate = "C:\Users\REM\AppData\Roaming\GoogleUpdate.exe". - Dropped files included the self-copy (identical SHA-256), a zero-byte
tmpC042.tmp, a .NET CLR usage log, and a Firefox pending-ping JSON that had nothing to do with the sample. The last two are the kind of incidental noise that makes “dropped files” lists dangerous if you do not read them.
The Run-key path also tells you the sample ran non-elevated. The scheduled-task branch was not taken. On an admin token, the same code would have created a logon task at highest privileges instead.
Run two: giving it a fake internet
Remnux came up at 192[.]168[.]174[.]50. A dnsmasq instance answered only pea[.]radio[.]fm with the lab address; a TLS 1.0 listener (SECLEVEL=0) waited on 443. The Windows guest’s DNS and default gateway already point at Remnux, a one-time lab prep that makes the isolated lane behave like a routed network without giving it a route.
The result was immediate:
- dnsmasq logged an A query for
pea[.]radio[.]fmfrom the guest every ~5 seconds. - A new TCP connection to
192[.]168[.]174[.]50:443followed each query. - A guest-side
Get-NetTCPConnectionpoll mapped every connection to PID 4992,GoogleUpdate.exe, pathC:\Users\REM\AppData\Roaming\GoogleUpdate.exethe sample, not the agent and not a Windows service. - The ClientHello was TLS 1.0, seven CBC cipher suites, curves
x25519/secp256r1/secp384r1, and no SNI. The JA3 was:
769,49162-49161-49172-49171-53-47-10,10-11-35-23-65281,29-23-24,0
fc54e0d16d9764783542f0146a98b300
That is a .NET Framework 4.0 SslStream fingerprint, not a unique AsyncRAT signature. Treat it as a correlation aid, not a family verdict. The absence of SNI is more interesting: the client passes the resolved IP as the TLS target host, so there is no server_name extension to match on. SNI-based C2 detection will miss this client by design.
The pin holds
The first listener presented a newly generated certificate with the same subject as the embedded one, CN=AsyncRAT Server, but a different key, serial, and hash. At the record layer, the client completed the handshake with it: ServerHello, Certificate, ServerKeyExchange, ServerHelloDone; the client replied with ClientKeyExchange, ChangeCipherSpec, and Finished. The server log said handshake ok on every connection.
At the application layer, the client sent zero bytes. No ClientInfo, no plugin, no pong. It held the connection for about five seconds and closed it. A second listener with a completely different CN (NotAsyncRAT Server) produced the same record-level handshake and the same silence.
The explanation is in the client, not in the listener. In the guest, I loaded the pinned certificate and our test certificate and called .NET’s X509Certificate.Equals:
pinned SHA-1: C981D59F64F0D619DB82CFE0A9826319A2EE98F6
lab SHA-1: 54A2ACE0097464ED5017055B18B4D44D847496DA
Equals(pinned, lab) = False
Equals(two same-subject self-signed certs) = False
It is a full-certificate hash comparison, not a check on the common name. The observable sequence is consistent with the pin check failing after the record-level handshake and before SendInfo() runs; the client closes silently. Whatever the exact ordering inside .NET, no application data crossed, so this is not a pinning bypass.
That is the correct outcome for an implant, and it is also the ceiling for a network-only fake C2. Without the attacker’s private key, the application protocol stays closed.
Repinning a copy
To see what the client would do after a successful C2 handshake, I built a separate instrumented copy. The original sample was not modified; the copy exists only in the lab.
The client’s pin is two encrypted strings:
Certificate: the base64 DER of the server certificate, AES-encrypted.Serversignature: an RSA-SHA256 signature overSHA256(Key), also AES-encrypted and verified against that certificate.
I generated a 4096-bit self-signed certificate under our control, signed SHA256(Key) with its private key, re-encrypted both values with the same AES/HMAC scheme, and replaced the two strings in a copy of the PE. The certificate and signature plaintexts had to stay 1,696 and 684 base64 characters so the encrypted blobs and therefore the PE strings stayed the same 2,348 and 984 characters as the originals, and the .NET user-string heap did not need rebuilding. Getting the certificate DER to exactly 1,270 bytes took one padding extension; the original signature was 512 bytes, so a 4096-bit key kept the signature length identical.
The resulting file is a lab artifact:
Instrumented copy SHA-256:
1e9087d8e7b85a197e6308c04b862e191a99bd94efc5720926167089b10d8f4b
Do not treat that hash as a malware IOC. It is the original loader re-pinned to a certificate we own. The original sample still pins the original certificate and still behaves as described above.
The fake server was a small Python TLS 1.0 service on Remnux. It understood the client’s framing a 4-byte compressed length, a 4-byte uncompressed length, a gzip stream, and a MessagePack map and answered Ping with pong. On ClientInfo it sent a plugin request; on sendPlugin it replied with savePlugin carrying a benign test DLL.
The check-in
The instrumented copy installed itself and its child connected. The server received:
| Field | Value |
|---|---|
| Packet | ClientInfo |
| Version | 0.5.8 |
| HWID | 44F0C197BA478E9C5B3E |
| User | REM |
| OS | Windows 10 Enterprise 64bit |
| Path | C:\Users\REM\AppData\Roaming\GoogleUpdate.exe |
| Admin | User |
| Antivirus | Windows Defender |
| Installed | 10/25/2026 3:29:02 PM |
| Performance | empty (no active window) |
| Pastebin | null |
| Group | Default |
Every field promised by IdSender.SendInfo() is there, including the HWID derived from the guest’s CPU count, user, machine name, OS, and system-disk size. The Path field confirms the install location; Admin=User confirms the non-elevated branch; Version=0.5.8 matches the decrypted config.
This is the packet the original sample would have sent to the real C2. It is also the packet an impostor cannot get without the private key.
The plugin bus
The loader’s command handling is small enough to quote from the decompiled source:
switch (Packet) {
case "pong": ...
case "plugin": if (registry has Dll) Invoke(); else request it
case "savePlugin": store Dll bytes under HKCU\Software\<HWID>, Invoke()
}
The exchange we observed:
server -> plugin(Dll="labplugin1", Msgpack=<empty>)
client -> sendPlugin(Hashes="labplugin1")
server -> savePlugin(Hash="labplugin1", Dll=<gzip-compressed DLL>, 1,405 bytes)
client -> stores the bytes, Assembly.Load, Plugin.Plugin.Run(...)
client -> Received
client -> Ping every ~11.5 s; server -> pong
The Dll bytes are not a raw PE. They are wrapped in the same Zip.Compress format the client uses: a 4-byte uncompressed length followed by a gzip stream. The client stores that blob as a binary registry value under HKCU\Software\<HWID> and loads it with Assembly.Load. The whole post-exploitation feature set lives behind this gate.
The first plugin delivery failed with a client-generated error that is worth quoting exactly (sample-derived text, not an instruction):
The best overloaded method match for
'Plugin.Plugin.Run(System.Net.Sockets.Socket,
System.Security.Cryptography.X509Certificates.X509Certificate2, string,
byte[], System.Threading.Mutex, string, bool, bool)' has some invalid arguments
The client passes Settings.BDOS and Settings.Install as strings ("false", "true"), not Booleans. Changing the test plugin’s signature to:
(Socket, X509Certificate2, string, byte[], Mutex, string, string, string)
made the next run succeed. The client stored the DLL, loaded it, invoked Run, and sent Received. The plugin wrote %TEMP%\labplugin_ran.txt:
labplugin ran
hwid=44F0C197BA478E9C5B3E
mutex=7BSpMzZAtj5C
bdos=false
install=true
The malbox agent collected that file as a dropped artifact, so the execution is corroborated inside the detonation as well as on the server side. Our DLL is benign; the point is that the loader will run any .NET assembly with the expected Plugin.Plugin entry point that the C2 pushes, with the arguments above. That is the difference between a loader and a RAT.
What this means for defenders
- The pin is real, but it is not a network control. A fake C2 can still elicit DNS queries, TCP connections, TLS ClientHellos, and a five-second retry loop. It cannot get
ClientInfoor deliver plugins without the private key. Blocking the domain still matters; the client will keep trying. - The stub is not the capability. AsyncRAT 0.5.8’s public plugin set includes remote desktop/screen capture, keylogging, file manager, process manager, shell, upload/download/execute, webcam/microphone, browser/password recovery, and chat. This sample’s stub contains none of that. The exact set is whatever the operator pushes after the handshake.
- The config switches matter.
Anti=falseandBDOS=falsemade this run unusually cooperative. A different build can enable VM checks, debugger checks, the 61 GB disk check, or critical-process mode. A clean sandbox run is not a family verdict. - The persistence is visible.
HKCU\...\Run\GoogleUpdatepointing at%AppData%\GoogleUpdate.exeis not subtle. The elevated branch is a logon scheduled task at highest privileges; look for both. - The plugin store is a host artifact.
HKCU\Software\<20 hex characters>with binary values is the loader’s DLL cache. It survives reboot and is the best place to recover what the operator actually delivered.
ATT&CK quick map
| Technique | Where it shows up |
|---|---|
| T1071.001 — Web Protocols | TLS C2 on 443 |
| T1573.002 — Encrypted Channel: Asymmetric Cryptography | pinned TLS certificate |
| T1547.001 — Registry Run Keys | HKCU\...\Run\GoogleUpdate |
| T1053.005 — Scheduled Task | schtasks /sc onlogon /rl highest on an elevated token |
| T1027 — Obfuscated Files or Information | AES-encrypted config strings |
| T1140 — Deobfuscate/Decode | runtime config and certificate decryption |
| T1620 — Reflective Code Loading | Assembly.Load of C2-pushed plugin DLLs |
| T1497.001 — Virtualization/Sandbox Evasion | checks present but Anti=false in this build |
| T1082 / T1033 — Discovery | fields in ClientInfo (OS, user, AV, window title) |
| T1012 / T1057 / T1083 — Discovery | registry/process/file capabilities seen by capa |
| T1112 — Modify Registry | plugin storage under HKCU\Software\<HWID> |
| T1070.004 — Indicator Removal: File Deletion | self-deleting relaunch .bat |
Detection and hunting
Network
- DNS for
pea[.]radio[.]fm, followed by TCP 443 from an unusual process. - JA3
fc54e0d16d9764783542f0146a98b300a .NET 4.0 TLS 1.0 fingerprint; useful only in combination with the domain/process behavior. - No SNI. The client passes the resolved IP as the TLS target host, so SNI matching will not see this C2. This is a detection gap, not a mistake in your sensor.
- TLS 1.0 with SHA-1 CBC cipher suites from a modern Windows host is itself worth a look, even without the domain.
Host
GoogleUpdate.exerunning from%AppData%or%AppData%\Roaming, especially with the Run key below.HKCU\Software\Microsoft\Windows\CurrentVersion\Run\GoogleUpdatepointing outsideProgram Files.- Mutex
7BSpMzZAtj5C(per-build; do not treat it as universal). HKCU\Software\<20 hex characters>with binary values — the plugin cache.%TEMP%\*.tmpplus a short-lived.bataround the first execution.- If elevated: a logon scheduled task named
GoogleUpdatewith/rl highest.
Certificate
CN=AsyncRAT Server, self-signed, 4096-bit RSA, validity to 9999.- SHA-1
c981d59f64f0d619db82cfe0a9826319a2ee98f6 - SHA-256
0ab37e1fda8b832c7356e84f3a16a3f9727c79d82b80279440da1fce81037987 - SPKI SHA-256
915f0c875c25a295e4aff80f7870b5ae5b71f8b93f2bf1267edeee0f9c8670cc
Response
If the C2 was reachable, assume the plugin bus was used. Reset credentials, review remote-access tools and browser sessions, preserve memory/disk before reimaging, and hunt the registry plugin cache. The loader alone is recoverable; the plugin set is the incident.
Indicators
Original sample
SHA-256 aa5ce2bb4008ae026c4e8b2fa3d02d0fdd296305dad0e6e4cfb4e3e92485ac9e
SHA-1 c40f16583dde67cdfcdea811e2950eb810bbf1a8
MD5 bc9bb029da0de28ba546c80c2854e4d7
C2
pea[.]radio[.]fm:443/tcp
Host
%AppData%\GoogleUpdate.exe
HKCU\Software\Microsoft\Windows\CurrentVersion\Run\GoogleUpdate
HKCU\Software\<HWID> (binary plugin DLL values)
Mutex 7BSpMzZAtj5C
%TEMP%\*.tmp / short-lived .bat (install residue)
TLS
JA3 fc54e0d16d9764783542f0146a98b300
no SNI; TLS 1.0; ECDHE-RSA-AES256-SHA et al.
Certificate
CN=AsyncRAT Server
serial 0xc2bf6370b68bbd5d50e79b614fe9f7
SHA-1 c981d59f64f0d619db82cfe0a9826319a2ee98f6
SHA-256 0ab37e1fda8b832c7356e84f3a16a3f9727c79d82b80279440da1fce81037987
The instrumented copy (1e9087d8…d8f4b) is not in this list. It is a lab vehicle re-pinned to a certificate we own; it should not be blocked or published as an IOC.
Lab notes
- The original sample and the password-protected zip were never modified; the instrumented copy is a separate quarantine entry.
- The fake internet was Remnux on the same host-only
vmnet1; the real C2 was never resolved, contacted, or fetched. - The first listener deliberately used a matching
CNto test whether the pin was subject-based. It is not: .NET compares the full certificate hash. A second, differently named certificate produced the same record-level handshake and the same silence. - The plugin test DLL was compiled in the guest with the .NET Framework
csc.exe, delivered as a gzip-wrapped assembly, and written to%TEMP%. It is benign and is not distributed with this post.
- Further reading
- MITRE ATT&CK — AsyncRAT, S1087
- NYAN-x-CAT — AsyncRAT-C-Sharp releases (v0.5.8)
- Splunk — AsyncRAT Crusade: Detections and Defense
- Check Point — AsyncRAT Malware Explained
- VirusTotal — file
aa5ce2bb…and domainpea[.]radio[.]fm, accessed 2026-10-25 (third-party resemblance evidence, not attribution)
All dynamic work was performed in an isolated lab. No real C2 infrastructure was contacted. Indicators are defanged; hashes are provided for identification only.
