FILEPublic
FILE

Two dropped executables expose registry-backed and logon launch mechanisms

An executable running as `ollama.exe` wrote and launched two distinct programs from a Windows temporary directory. Their associated records link executable data stored in the registry to an assembly-loading command, while separate service and user-logon settings show how execution was configured beyond the dropped files.

Nov 19, 2026, 09:41 (UTC+9)Last seenNov 19, 2026Severity77ByCTX TeamActorSnowglobeAnimal FarmIOC10RegionsKZUAUS

An executable running as ollama.exe wrote two different programs into a Windows temporary directory, and a sandbox recorded both as its children. That raises a more useful question than whether the filename looks familiar: what work did the executable distribute to those components, and where did their execution mechanisms extend beyond ordinary files?

The records examined by CTX Threat Intelligence show a multi-component delivery mechanism, with registry-backed assembly loading and distinct service- and user-logon-related launch settings. The strongest connections are concrete: dropped-file hashes identify the two components; a recorded PowerShell command reads executable data from the registry; and a Run-value write points to a pathname that appears in separate file-creation and process records. These relationships explain substantially more than a malware-family label, without requiring the separate analyses to represent one uninterrupted execution.

Two components, not two interchangeable filenames

In the Zenbox analysis, the parent executable—SHA-256 prefix 4e85e17ac996—ran from the desktop as ollama.exe. Its dropped-file records identify %TEMP%\Install.exe with SHA-256 prefix d574b3a4fcf6 and %TEMP%\firle.exe with prefix bbd43d51c9b7. Both records name the desktop process as their source, and the reported process tree places both temporary executables beneath that parent.

The combination matters. A file-write record establishes that a pathname was written; a dropped-file hash identifies the content at that location; a parent-child relationship adds evidence of execution. Here, those observations support describing the desktop executable as delivering and launching two distinct components, rather than merely leaving behind files with suggestive names.

A separate VirusTotal Jujubox report records the same two dropped hashes and places Install.exe beneath ollama.exe in its process tree. It does not supply the equivalent child-process observation for firle.exe. That difference preserves the boundaries of the reports while reinforcing the content relationship: two environments recorded the parent producing the same pair of executables.

An installer can legitimately unpack and launch several programs, so that structure alone would not establish a malicious mechanism. Nor does the name ollama.exe establish provenance, an official distribution channel or a compromise of a similarly named product. The more consequential evidence lies in what the associated records show about registry storage, PowerShell launch commands and a user-logon setting.

The two files also have different technical profiles. Install.exe is a comparatively small Windows executable whose supplied imports include service-management and registry-writing functions. firle.exe is a much larger UPX-compressed executable. Those static properties help distinguish the branches, but do not themselves prove that either performed a particular action. The event records provide the stronger basis for interpreting their roles.

The registry holds more than a launch path

The clearest registry-loading evidence appears within a C2AE report for the parent executable. It records a write presented as HKEY_LOCAL_MACHINE\SOFTWARE\NRstager, containing bytes beginning 4D 5A. The longer excerpt includes a DOS executable-header message and a PE signature. This is not simply a registry string naming a program on disk: the recorded data has the structure of executable content.

The same report contains a cmd.exe command that invokes PowerShell to read a value from the registry, pass its contents to [Reflection.Assembly]::Load, and call .EntryPoint.Invoke($Null,$Null). Character-by-character construction obscures the strings, but the visible expressions resolve to the SOFTWARE subkey and the NRstager value.

The command therefore gives the stored bytes a specific role. It opens the machine-wide SOFTWARE key, retrieves NRstager, treats the result as a .NET assembly and requests execution through its entry point. The registry write and the command refer to the same storage location within this report. That relationship is more informative than either an unexplained binary registry value or a generic “in-memory execution” alert viewed alone.

This does not establish that the assembly loaded successfully or that its entry point completed. The supplied evidence contains the recorded command and the stored executable-header bytes, not a complete trace of the called code. It nevertheless supports a substantive finding: the execution design includes retrieving executable content from the registry, rather than relying exclusively on launching another pathname.

Other reports for the parent also record NRstager, including a Zenbox excerpt beginning with the same executable-header bytes. These observations reinforce the importance of that location, but their excerpts do not establish that every report stored an identical full assembly.

For this case, the practical distinction is between a registry value that tells Windows where a program resides and one used to hold the program data itself. An examination limited to Install.exe and firle.exe would describe the delivery surface but omit the recorded loading mechanism. Conversely, calling the entire activity “fileless” would obscure the two executables demonstrably written to disk. The evidence supports a combination of disk-based components and registry-backed loading.

A service setting meets an observed process relationship

A second set of observations concerns NRsvc. Matched registry events associated with the parent record services.exe setting:

HKLM\System\CurrentControlSet\Services\NRsvc\ImagePath

The value is not a simple executable pathname. It begins with cmd.exe /c and embeds a PowerShell command. The visible script defines a function and uses AppDomain.CurrentDomain.DefineDynamicAssembly, Reflection.AssemblyName and Reflection.Emit.AssemblyBuilderAccess::Run. Numerous [Char](...) expressions construct strings at runtime.

Process-creation events add an important relationship to that setting. A recorded cmd.exe process has services.exe as its parent and carries the corresponding PowerShell-launching command. A PowerShell process, in turn, names cmd.exe as its parent and includes the matching parent command line. Both created processes have a reported System integrity level. This is more than a service-related registry alert: the records also describe the service-manager-to-command-shell-to-PowerShell parent relationships.

The script content supplies the technical significance. It invokes facilities for creating a dynamic assembly in the running environment, rather than merely using PowerShell to start a plainly named application. A script-block event records the same visible function structure, adding a view of the script beyond the process command line. Obfuscated string construction makes the command less readable, but the exposed assembly-building calls remain identifiable.

There are two related mechanisms here, and they should not be collapsed. The C2AE command explicitly reads NRstager and calls Reflection.Assembly::Load. The service-related excerpts show dynamic assembly construction, but are truncated. They do not reveal enough to establish that the NRsvc command consumes the same registry value or executes the same assembly. The supported interpretation is that the parent’s analyses expose both a registry-backed loader and a service-associated PowerShell execution mechanism—not a fully traced handoff between them.

The Install.exe profile contains closely corresponding event details: the same NRsvc\ImagePath target, a service-manager-parented command shell, PowerShell process creation and a script block using dynamic assembly construction. Its function and variable names differ from those in the parent’s matched events. Combined with the exact dropped-file identity, these observations make Install.exe a concrete component to examine for the service-related behavior. They do not establish that every service event attached to the parent was caused by that child.

The scope of the result is also specific. The records show a service launch setting and associated process relationships, not a tested restart cycle or confirmed long-term persistence. Likewise, a Sigma rule title referring to debug-privilege abuse does not add a privilege-change event to the visible process fields. CTX Team’s assessment rests on the registry target, command content and parent relationships, rather than treating each rule name as a separate completed action.

A logon target connects the other branch to a new location

The firle.exe branch has a different, directly recorded persistence-related action. A registry SetValue event identifies %TEMP%\firle.exe as the process writing a user’s CurrentVersion\Run entry. The entry’s data points to %APPDATA%\NRExtExport.exe.

The target path matters because it reappears in an analysis of the exact payload hash dropped as firle.exe. In that separate CAPE report, the submitted executable runs as software.exe. A Sysmon Event 29 identifies it as the process creating %APPDATA%\NRExtExport.exe, and the event’s hash matches the analyzed payload’s content.

Correctly reading that event changes the interpretation. Under the supplied Sysmon semantics, Event 29’s hash belongs to the created executable, not the creating process. It therefore establishes that the file materialized at the roaming-profile path has the same content identity as the payload delivered under the temporary firle.exe name. This is a content link across locations, not merely a resemblance between filenames.

CAPE also lists the roaming-profile file among written files and records NRExtExport.exe as a child of software.exe, with a corresponding command-execution entry. Together, these observations give the path two roles within that report: it is a written executable location and a reported child-process location. The child-process entry does not include its own hash, so it should not be presented as independent verification of the running image’s bytes.

The Run-value write adds a complementary role from the parent’s matched events: that same pathname is configured as a user-logon launch target. Microsoft’s Run and RunOnce documentation, supplied as technical context curated on October 4, 2026, explains that these entries configure commands to run when a user logs on. It explains why this write is persistence-related; it is not evidence that a later logon occurred.

The distinction between the observations is useful rather than merely cautious. The Run event identifies the writer and intended launch target. CAPE identifies content created at that target and records a child process at the same path. They support a coherent account of placement and a logon-oriented setting, while remaining separate observations rather than a demonstrated sequence of copying, rebooting and relaunching.

What emerges is not one suspicious filename followed by an undifferentiated list of alerts. The parent executable delivers two hash-identified components. Its analyses expose executable data stored in the registry and a command designed to load it, alongside service-associated PowerShell activity. The other branch connects a temporary executable to a roaming-profile location that is also named in a Run entry.

That changes the investigative unit for this case. The original desktop executable is the delivery point, but its pathname alone does not describe the mechanism. The meaningful objects are the delivered content, the registry value used as a loading source, the service command and the user-logon target. Following those relationships retains the behavior that a file-only inventory would miss—without turning separate sandbox findings into an attack timeline they do not establish.

Indicators of compromise10 indicators

Files

(8)

Domains

(1)

URLs

(1)
Source: CTX Threat Intelligence