TW / Independent
← Research audits

Malware Analysis / Artefact: MessagePack/MsgPack.cs · SHA-256 4482252b1a6d…

AsyncRAT: MessagePack, plugins and configurable remote control

Static review of the open C# codebase: compressed MessagePack, handlers, plugins, persistence and variant risk.

Scope
Public AsyncRAT source and MITRE technique mapping; no execution, build or campaign sample.
Method
Static source and architecture review; no malware obtained, built or executed.
Evidence
Upstream source file with locally checked hash.
Finding

The message parser, handler and plugin structure are statically inspectable; distribution and forks remain variable.

No independent sample, runtime, C2 or campaign verification.

Analyst note

What the evidence actually supports.

With AsyncRAT, the useful boundary lies between open code and a specific abuse case. The report reads the message parser and plugin paths as a protocol surface, not as proof of a particular campaign.

Evidence anchorsource snapshot checked
Artefact
MessagePack/MsgPack.cs
SHA-256
4482252b1a6de7070336649c58cb3329eed68d92d0be2ed9fe12e15845cdeeb0
Revision
0f0cba4ec3985c38082c6abb3e1e01895120ffb6
Analysis basis
Upstream source file with locally checked hash.
Malware / Evidence Atlas

Builder profile → Remote action

The analysis path for this report. Every node shows what is supported, where detection can start and where the claim stops.

5flow nodes 3detection artefacts 3rule formats
Claim

Builder profile

Configuration and the concrete fork must be attributed before any behavioural claim.

Detection focus

Version assembly traits and configuration fields.

Bound to primary research
Config Surface

Configuration fingerprint

Review pivots derived from the report — not a live configuration or universal family indicator.

01
SerializationMessagePack
core
02
Handlercommand map
core
03
Pluginsloadable modules
core
04
Persistenceconfigurable
support
MODEL / D1F7E12CCore, support and boundary — not risk scores
Detection Pack

Defensive artefacts

Source, validation and limits accompany every rule.

SourceOriginal derivation from the structure described in the report.ValidationCompiled with yara-python; synthetic truth table 3/3.LimitGeneric task telemetry requires source or configuration corroboration.
YARAOpen rule
Defensive model
rule DotNet_RAT_AsyncRAT_Project_Identifiers {
 meta:
  author = "Ruhrdigital Studio"
  scope = "project lineage indicator; dual-use caveat"
 strings:
  $family = "AsyncRAT" ascii wide
  $client = "AsyncClient" ascii wide
  $msgpack = "AsyncRAT.MessagePack" ascii wide
  $settings = "AsyncRAT.Properties.Settings" ascii wide
 condition:
  uint16(0) == 0x5a4d and filesize < 25MB and 3 of them
}

Evidence status Supported by review evidenceBound to primary researchBounded or unresolved

Scope, snapshot and evidence boundary

Public AsyncRAT source and MITRE technique mapping; no execution, build or campaign sample. The bounded question is: which architecture and behaviour claims does this specific evidence set support, and which remain attributable only to the source?

ARTIFACT MANIFEST

Files and checksums

asyncrat/AsyncRAT-C#/MessagePack/MessagePack/MsgPack.cs
4482252b1a6de7070336649c58cb3329eed68d92d0be2ed9fe12e15845cdeeb0

MessagePack decoder with preceding decompression.

What is supported — and what is missing

Primary sources, statically inspectable code and runtime observations carry different evidentiary weight. The map keeps those layers separate; missing first-party observation is not replaced by plausibility.

FILE / EVIDENCE MAP

Evidence chain and open runtime gap

The map separates primary source, reproducible source snapshots and runtime evidence not collected here.

A file reference does not establish runtime behaviour. Recorded processing is not a new execution.

SourceToolDerivedEvidenceMissingVerified referenceRecordedUnresolved

Evidence

Traceable source with an explicit sample gap.

Primary source

Published analysis or pinned upstream snapshot.

  • Primary source → MsgPack.cstechnically cross-checked · Verified reference

    File, commit and SHA-256 were pinned.

Related report section →
MsgPack.cs

Locally hash-bound source snapshot, read statically only.

File
asyncrat/AsyncRAT-C#/MessagePack/MessagePack/MsgPack.cs
SHA-256
4482252b1a6de7070336649c58cb3329eed68d92d0be2ed9fe12e15845cdeeb0
Location
1-927
  • Primary source → MsgPack.cstechnically cross-checked · Verified reference

    File, commit and SHA-256 were pinned.

  • MsgPack.cs → No local malware sampleruntime unresolved · Unresolved

    The review remains static or source-bound.

Related report section →
No local malware sample

No first-party runtime, C2 or campaign telemetry.

  • MsgPack.cs → No local malware sampleruntime unresolved · Unresolved

    The review remains static or source-bound.

Related report section →

Limit: A published observation is not an independent reproduction.

Entry and delivery chain

AsyncRAT is an open remote-access codebase used in different phishing and loader chains. Upstream does not define initial access. Analysis must therefore separate builder configuration, concrete fork and delivery artifact.

Architecture and data flow

After decompression, the client decodes MessagePack structures; server handlers map messages to functions such as shell, files, processes, desktop, webcam or recovery. Plugins extend capability. This separation creates useful boundaries for protocol and module observation.

Original code as architecture evidence

The short excerpt shows only the structure discussed in this chapter. It is not executed and does not contain a complete operational implementation.

csharpDecompression before MessagePack parsingAnalysis tool excerpt
asyncrat/AsyncRAT-C#/MessagePack/MessagePack/MsgPack.cs · Lines 483-490
Show file hashSHA-256 4482252b1a6de7070336649c58cb3329eed68d92d0be2ed9fe12e15845cdeeb0
        public void DecodeFromBytes(byte[] bytes)
        {
            using (MemoryStream ms = new MemoryStream())
            {
				bytes = Zip.Decompress(bytes);
                ms.Write(bytes, 0, bytes.Length);
                ms.Position = 0;
                DecodeFromStream(ms);
Read the code

Analysis resistance and persistence

MITRE lists debugger and VM checks, hidden windows, dynamic resolution and scheduled tasks. Depending on builder and fork, these options may be absent. A more stable model links configuration traits to actual task, process and network activity.

Capabilities, objective and impact

The open capability set ranges from system discovery and file transfer to shell, screen, camera and keyboard input. This describes attack surface and possible impact, not automatically observed use of every function.

Telemetry plan and evidence chain

Useful signals include .NET artifacts, MessagePack/compression patterns, unusual task persistence and long-lived outbound connections from a user-writable client. Older YARA strings should be tested against fork drift and legitimate MessagePack use. A defensible investigation preserves process GUID and full ancestry, user and session, command line, signer and hash state, file and registry changes, DNS/connection destinations and follow-on access to sensitive data in one timeline. Temporal proximity is an evidence parameter, not mere visualization. Missing sensor coverage is marked per stage so that an unseen event is not falsely treated as an event that did not occur.

Detection engineering and countertesting

Useful signals include .NET artifacts, MessagePack/compression patterns, unusual task persistence and long-lived outbound connections from a user-writable client. Older YARA strings should be tested against fork drift and legitimate MessagePack use. The following model is deliberately narrow, not engine-validated and must be tested against legitimate administration and software paths.

yamlDefensive model, not engine-validatedDefensive model
title: AsyncRAT hidden-task candidate
status: experimental
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    Image|endswith: '\\schtasks.exe'
    CommandLine|contains|all:
      - '/create'
      - '/sc'
      - 'onlogon'
    ParentImage|contains: '\\AppData\\'
  condition: selection
falsepositives:
  - Legitimate administrative or software activity with the same isolated pattern
level: medium
Read the code

Alternative hypotheses and negative tests

Before assigning the family, each signal used by the model is tested independently against software deployment, administration tools, installers, browser or backup software and known internal scripts. At least one structural anchor and one temporally consistent behaviour chain must align. Source capabilities establish possibilities in the pinned snapshot, not the contents of every campaign variant. Nothing was built, started or connected to a server. A negative countercheck rejects only the tested hypothesis; it is not a general all-clear.

Attribution and variant risk

Source capabilities establish possibilities in the pinned snapshot, not the contents of every campaign variant. Nothing was built, started or connected to a server.

Final assessment

The review provides a defensible architecture and detection baseline for the named snapshot. It is not proof of current activity, complete variant coverage or a specific operator.

Findings at a glance

  • Decompression and MessagePack form a clear protocol boundary.
  • Handlers and plugins separate core transport from optional capability.
  • Fork and builder drift limit static signatures.

Review limits

  • No independent sample, runtime, C2 or campaign verification.
  • Source capabilities establish possibilities in the pinned snapshot, not the contents of every campaign variant. Nothing was built, started or connected to a server.
  • Defensive models were not validated with a target engine.

Context, not evidence

The Evidence Anchor at the start identifies the binary, file or revision actually used. These links provide context and reported observations; they do not substitute for local sample analysis.

AsyncRAT upstream source ↗MITRE ATT&CK — AsyncRAT S1087 ↗
Final assessment

Conclusion

Conclusion: structure before signature

The greatest defensive value comes from connecting entry, internal architecture, persistence, impact and telemetry. Individual names, hashes or IOCs remain supporting evidence, not the conclusion.

Next steps

  • Test models against synthetic positives and legitimate negatives.
  • Rebind version and evidence snapshot with every update.
  • Extend runtime claims only after first-party, lawfully available telemetry.
Basis of this judgmentHigh for directly inspectable structure; limited for runtime and campaign claims not independently reproduced.
Public AsyncRAT source and MITRE technique mapping; no execution, build or campaign sample.
← All research audits

Start a conversation

Discuss your project.

Start a conversation