> ## Content Index
> Fetch the complete content index at: https://f4n6.co.uk/llms.txt
> Use this file to discover other available public pages before exploring further.

# The Pin Held: Repinning an AsyncRAT Client to Capture Its Check-In and Plugin Bus
- URL: https://f4n6.co.uk/asyncrat-repin-clientinfo-plugin-bus/
- Published: 2026-10-25T17:25:55.000Z
- Updated: 2026-10-25T17:25:55.000Z
- Description: A 46 KB AsyncRAT loader, an encrypted config, and a certificate pin that actually worked. A fake C2 got DNS and TLS but no data — until we rebuilt a copy around our own key and captured the check-in and the plugin bus.
- Author: Jeff Davies
- Tags: Malware Analysis, Threat Research, AsyncRAT, .NET, RAT, C2, Detection Engineering

*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:

1. Sleep `Delay` seconds (3 in this build).
2. `Settings.InitializeSettings()` decrypt the config, compute the HWID, load and verify the server certificate.
3. Create mutex `7BSpMzZAtj5C`. If it already exists, exit.
4. If `Anti` is true, run the anti-analysis routine.
5. If `Install` is true, run `NormalStartup.Install()`.
6. If `BDOS` is true and the process is elevated, call `RtlSetProcessIsCritical`.
7. Call `SetThreadExecutionState` to keep the machine awake.
8. 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 `.bat` that waits three seconds, starts the installed copy, deletes the batch, and exits. The empty `tmpXXXX.tmp` left behind is `Path.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 from `C:\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[.]fm` from the guest every \~5 seconds.
- A new TCP connection to `192[.]168[.]174[.]50:443` followed each query.
- A guest-side `Get-NetTCPConnection` poll mapped every connection to **PID 4992, `GoogleUpdate.exe`**, path `C:\Users\REM\AppData\Roaming\GoogleUpdate.exe` the 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:

```text
769,49162-49161-49172-49171-53-47-10,10-11-35-23-65281,29-23-24,0

```

```text
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`:

```text
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 over `SHA256(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:

```text
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:

```text
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:

```text
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):

```text
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:

```text
(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`:

```text
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 `ClientInfo` or 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=false` and `BDOS=false` made 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\GoogleUpdate` pointing at `%AppData%\GoogleUpdate.exe` is 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 `fc54e0d16d9764783542f0146a98b300` a .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.exe` running from `%AppData%` or `%AppData%\Roaming`, especially with the Run key below.
- `HKCU\Software\Microsoft\Windows\CurrentVersion\Run\GoogleUpdate` pointing outside `Program Files`.
- Mutex `7BSpMzZAtj5C` (per-build; do not treat it as universal).
- `HKCU\Software\<20 hex characters>` with binary values — the plugin cache.
- `%TEMP%\*.tmp` plus a short-lived `.bat` around the first execution.
- If elevated: a logon scheduled task named `GoogleUpdate` with `/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

```text
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 `CN` to 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](https://attack.mitre.org/software/S1087/?ref=f4n6.co.uk)
- NYAN-x-CAT — [AsyncRAT-C-Sharp releases](https://github.com/NYAN-x-CAT/AsyncRAT-C-Sharp/releases?ref=f4n6.co.uk) (v0.5.8)
- Splunk — [AsyncRAT Crusade: Detections and Defense](https://www.splunk.com/en%5Fus/blog/security/asyncrat-crusade-detections-and-defense.html?ref=f4n6.co.uk)
- Check Point — [AsyncRAT Malware Explained](https://www.checkpoint.com/cyber-hub/threat-prevention/what-is-malware/asyncrat-malware-explained/?ref=f4n6.co.uk)
- VirusTotal — file `aa5ce2bb…` and domain `pea[.]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.*