
Patch-named executable launches three programs, not just the patch
Sandbox reports show the apparent patch launching three distinct executables. One dropped payload has the same hash as a process running from an installation path, while registry settings target installed executables for later launches. The evidence establishes deployment and launch settings, not that those settings subsequently ran.
A Windows executable carrying the name “Mt2Patch For Hack by Baseke” launched three separate programs in a sandbox: a smaller file bearing the patch name, CSRSS.EXE, and CYBAT.EXE. That raises a more useful question than whether the apparent patch is malicious: what does the outer executable deploy, and how do those components relate?
The records examined by CTX Threat Intelligence show a multi-payload launcher, not simply a patch application with a suspicious filename. Dropped-file hashes and process trees identify its outputs; another process-creation event ties the content of CYBAT.EXE to an executable running as csrss.exe in an installation directory. Registry settings point to further launches from installation paths, while network records show DNS lookups and an HTTP request involving two distinct No-IP hostnames.
The strongest finding is this relationship between content, execution and launch settings. Names alone obscure it: two different binaries appear under the csrss.exe name, while one binary appears under different names. Following those distinctions changes both the interpretation of the apparent patch and the scope of the activity attributable to it.
The patch is one child, not the whole program
In the VirusTotal Jujubox report, the outer sample, SHA-256 prefix #91d625450891, is associated with three executable drops under the user’s temporary directory. The report assigns each drop to process 2164, and its process tree places all three corresponding executables directly beneath that process. This joins the files on disk to observed launches rather than leaving them as potentially inert resources.
One child is MT2 PATCH FOR HACK BYBASEKE.EXE, a 22,528-byte .NET executable whose product metadata also carries the patch name. The others are a 67,072-byte CSRSS.EXE and a 438,272-byte CYBAT.EXE. Their different hashes establish that these are distinct contents, not three aliases for a single program.
The patch-named child matters because it explains why assessing only the apparent application would miss the deployment. A genuine or cosmetic patch function could coexist with the other components. The supplied observations do not establish what that smaller .NET program accomplishes internally, but its presence does not account for, or neutralize, the two additional launches. The outer program’s demonstrated role is broader than running that child.
CAPE provides a separate view of the same parent sample. Its process tree shows program.exe launching both temporary-directory executables, and its dropped-file record identifies the same content for CSRSS.EXE as Jujubox. These are corroborating observations from different sandbox reports, not consecutive steps in one execution.
The dates also define the scope of this case study. The outer file was first submitted on October 27, 2026, and the detailed sandbox reports carry analysis timestamps from that date. The two non-patch payload hashes already have submission records dating to 2013. This establishes that older recorded components appear in the analyzed package; it does not establish renewed distribution, a newly built payload, or a current victim campaign.
The same name conceals two different binaries
The temporary-directory CSRSS.EXE, identified by hash prefix #9056ada6df0c, appears as a child of program.exe in CAPE. Beneath it, the reported tree contains svchost.exe. A process-creation event likewise records C:\Windows\SysWOW64\svchost.exe with the temporary-directory executable as its parent.
The distinction between parent and child is important here. The system path and Microsoft product metadata belong to the created svchost.exe, not to the executable that launched it. A familiar child process therefore does not make its parent a Windows component. Conversely, the parent-child relationship alone does not establish process injection or explain what work the child performed.
The second payload creates a more revealing identity problem. Jujubox identifies the dropped CYBAT.EXE by hash prefix #609148433303. Elsewhere in the parent sample’s process-creation evidence, that same hash belongs to the created image at %APPDATA%\install\csrss.exe, where %APPDATA% denotes the user’s roaming application-data directory. The hash is attached to the process image itself, not inherited from its parent.
This exact content match changes the reading of the paths. The csrss.exe in the roaming installation directory is the same binary content as the dropped CYBAT.EXE; it is not the temporary-directory CSRSS.EXE, whose hash differs. A search or narrative based only on the executable name would merge two separate components and miss the fact that one of them also runs under another name.
CAPE’s process tree supplies additional structure around the installed path. It records CYBAT.EXE as the parent of an explorer.exe process, with that explorer.exe in turn parenting %APPDATA%\install\csrss.exe. The same report also records another process at the installed path directly beneath CYBAT.EXE. Those are explicit relationships within CAPE’s reported tree. The matching hash establishes content identity, but does not by itself identify the operation that placed the file there or prove a self-copy sequence.
Family indicators are consistent with a package containing multiple malicious components, rather than demanding a single label for every file. The outer sample matches XtremeRAT-, CyberGate- and binder-related YARA rules; the CYBAT.EXE content separately matches a CyberGate rule. Multiple sandbox reports also record SOFTWARE\XtremeRAT\Mutex with the value fMb158GS. These are classification clues, not unanimous family attribution. The observed drops and launches establish the package’s role more directly than selecting one family name.
Installation paths become launch targets
The installation locations are not merely alternate names in a file inventory. They recur as targets in registry launch settings, connecting the deployed paths to an attempt to maintain execution beyond the initial launch.
Jujubox records a Run entry named Microsoft Office pointing to C:\Windows\install\csrss.exe. Its Active Setup record contains a StubPath pointing to the same executable with the argument Restart. The familiar application name on the Run entry does not describe the target’s identity: the command points to the installed csrss.exe, not an Office executable.
Microsoft’s Run and RunOnce documentation, supplied as technical context curated on October 4, 2026, explains that these entries configure commands to run at user logon. That makes the Run write a concrete persistence-related observation. It records a launch setting, however, not a later logon or proof that the command subsequently ran.
CAPE records a different Active Setup target: %APPDATA%\install\csrss.exe Restart. This is the same path that appears in CAPE’s process tree and in the process-creation evidence carrying the CYBAT.EXE hash. The relationship is more informative than an isolated registry alert because the configured destination also exists as an observed process location. It does not establish that Active Setup triggered that process; no event in the supplied evidence makes that causal link.
Rising MOVES shows another installation layout. Within its report, a file write targets C:\Windows\InstallDir\crsss.exe, and Run entries named Windows Register, Windows and Microsoft Office 2012 point to that exact path. An Active Setup StubPath targets it with a restart argument. The spelling crsss.exe is distinct from csrss.exe and must be preserved when interpreting those records.
Here, the file-write path and registry target connect placement with configured future execution within one report. They do not supply a hash identifying which payload occupies that path. Nor should the Jujubox, CAPE and Rising locations be assembled into an imagined progression from one directory to another. Environment-dependent behavior or reporting differences could account for their variation.
Taken together, the reports support deployment accompanied by persistence-related settings. They also show why checking only the original temporary filenames would be incomplete: the recorded launch commands point elsewhere, and one installation-path executable has a verified content match to a differently named payload.
Two hostnames, two different levels of network evidence
The network observations extend the case beyond local deployment, but with less precise attribution to individual components.
Jujubox records DNS lookups for both yakupnwo.no-ip.info and yakupnwo72.no-ip.info. CAPE records a lookup for the latter. These are two distinct hostnames, not interchangeable spellings of one indicator. Their shared appearance in the parent sample’s analysis is a concrete relationship; their similar names alone would be a weaker basis for connecting them.
Rising MOVES supplies a different kind of evidence: an HTTP GET request to http://yakupnwo.no-ip.info/123.functions. That observation moves beyond name resolution to a request for a particular resource on the hostname without the numeric suffix. It does not show a corresponding request to the other hostname, and it must not be appended to the Jujubox or CAPE DNS events as though they formed one recorded session.
The distinction between a request and its result is decisive. No response content is supplied for /123.functions. The path therefore identifies what was requested, not a verified instruction file, downloaded payload or completed command-and-control exchange. A failed request or an uninformative response remains compatible with the evidence. The network records also lack the process correlation needed to assign these lookups or the GET to CSRSS.EXE, CYBAT.EXE or the patch-named child.
Jujubox additionally reports UDP traffic to 8.8.8.8:53. An Emerging Threats alert describes a suspicious No-IP DNS query and lists the same destination and port. This is resolver-side evidence, not an observed address for either remote host. The supplied traffic event does not bind a particular hostname lookup to that packet, and it offers no basis for treating the resolver as the package’s control server.
The network evidence thus establishes a narrower external role than the local evidence establishes for deployment. The parent sample’s reports contain two hostname lookups and a resource request to one of them; the precise initiating component and the outcome remain unresolved.
That asymmetry is the useful conclusion of this case. The apparent patch can be understood quite specifically as a launcher for multiple distinct executables, with one payload also identified under an installation-path alias and with recorded settings for future launches. The external activity is real at the level of the reported lookups and request, but not yet a demonstrated remote-control session. Preserving content identity, process relationships and exact launch targets reveals considerably more than the patch name—without turning separate sandbox observations into an unsupported end-to-end attack story.