At a glance

SHA-256e25a1e68eee3514ad5645139437ec51ede3f1d687487873239fdcfa3d2f541f7
Filenamewssus_update.exe
SourceCollected during incident response to a customer cyber attack, approximately ten months before publication
File typePE32+ executable, x64, GUI subsystem, 48.45 KB, 16 sections, overlay present
Compile timestamp2025-12-10 09:47:13 UTC
Dekeneas verdictMalicious — risk score 100.0%
Dekeneas assessmentLoader — high confidence
VirusTotal, most recent analysis30 / 71 engines
Engines naming Cobalt Strike8 / 71
Family, per VirusTotaltrojan.cobaltstrike/misc (popular threat label)

This case study concerns a 48.45 KB Windows executable that poses as a software update — wssus_update.exe, a filename chosen to blend into the noise of legitimate Windows servicing activity. The file was recovered during incident response to a real customer intrusion, analysed by Dekeneas at the time, and classified as malicious at maximum risk, with a structural assessment of loader at high confidence. Both of those verdicts were available on day one.

Ten months later, the broader industry has only partially caught up. Of the 71 engines on VirusTotal, 30 now flag the file and 41 still return Undetected — among them Kaspersky, BitDefender, ESET-NOD32, TrendMicro, SentinelOne (Static ML), Acronis (Static ML), DrWeb, Emsisoft, GData, Webroot, Ikarus, AhnLab-V3, ClamAV and Xcitium. Detection, where it exists, is also shallow: only 8 of the 71 engines identify the file as what it actually is, a Cobalt Strike stager, and 4 of the 30 that flag it at all rate it as riskware or a potentially unwanted application — a classification that is frequently deprioritised or explicitly allowed by policy.

Cobalt Strike is not an exotic target. It is one of the most widely deployed post-exploitation frameworks in existence, commercially available, exhaustively documented, and the subject of detection research at every major vendor for over a decade. A loader for its Beacon payload is close to the most thoroughly "detectable" object in the threat landscape — in principle. This case is about why, in practice, most of the industry still cannot see one ten months after it was collected.

VirusTotal: 30 of 71 security vendors flagged this file as malicious, popular threat label trojan.cobaltstrike/misc, Code Insights summary
Figure 1 — VirusTotal: 30/71, trojan.cobaltstrike/misc, Code Insights summary
VirusTotal security vendors' analysis, detections, part 1: Alibaba through McAfee Scanner
Figure 2 — VirusTotal vendor analysis, detections (1 of 2)
VirusTotal security vendors' analysis, detections, part 2: Microsoft through WithSecure; the undetected list begins below
Figure 2b — Detections (2 of 2): Microsoft through WithSecure; the undetected list begins
VirusTotal security vendors' analysis, undetected, part 1: Acronis (Static ML) through Gridinsoft, all Undetected
Figure 3 — VirusTotal vendor analysis, undetected (1 of 2)
VirusTotal security vendors' analysis, undetected, part 2: through Zoner, then engines unable to process the file type
Figure 3b — Undetected (2 of 2): through Zoner, then engines unable to process the file type

Why the timeline matters

Case Study 01 documented a gap that closed. A sample went from 17 to 50 detections in five weeks, and the industry arrived at the verdict Dekeneas had reached on day one. That case demonstrated that signature-dependent detection is late, but that it eventually arrives.

This case documents a gap that has not closed — and the difference between the two outcomes is itself the finding.

  • Collection — the sample is recovered during incident response to a customer cyber attack. Dekeneas: Malicious, 100%; loader, high confidence.
  • Approximately ten months later — 30 of 71 engines detect. 41 do not. Eight name the framework.

Understand what ten months represents in the lifecycle of a signature. A detection gap closes through a well-understood pipeline: a sample is collected, shared through the industry's exchange channels, triaged by a vendor's analysts, turned into a signature or model update, and deployed to customers. For a commodity family, that pipeline is measured in days; even for unusual material, it is measured in weeks. Ten months exceeds it by an order of magnitude. Every mechanism that signature-dependent coverage relies on — reputation accumulation, sample sharing, cluster expansion, vendor research interest — has had ample time to operate.

And yet the file is not new, not rare and not obscure. Its compile timestamp places it in December 2025, and its payload belongs to a framework that every vendor on the list has been writing detections for since the previous decade. The reason the gap has persisted is not that the industry has never seen Cobalt Strike. It is that this particular binary is engineered so that most of the evidence those engines depend on is not present in the file. The techniques that achieve that are standard and well known individually; their combination is what makes the file operationally invisible.

The assumption behind signature-dependent coverage is that time closes the gap. This sample is evidence that it does not have to. An organisation relying on most of these engines would still be exposed to this loader today — not because the engines are badly run, but because the evidence they are built to read has been deliberately removed.


A key the sample keeps to itself

The central design decision in this binary is environmental keying. The loader expects a 7-character key on the command line, and it uses that key to decrypt both its API names and the embedded shellcode. The key is not stored in the file, cannot be guessed from the file, and is known only to the operator. Without it, the binary contains — from the perspective of anything that reads data — no API names and no payload.

This is a deliberate architectural choice with a precise security consequence: the secrets that would identify the malware are physically absent from the artefact an analyst (or an engine) is holding. String extraction, the oldest and most widely deployed static technique, recovers nothing useful because there are no plaintext strings to recover. Content signatures for Cobalt Strike shellcode have nothing to match against because the shellcode exists only as ciphertext until the moment of execution, in the operator's environment, with the operator's key.

The Dekeneas emulator shows the practical effect directly. Executed without the key, the program resolved seven APIs at runtime — InitializeCriticalSection, SetUnhandledExceptionFilter, __getmainargs, __set_app_type, _initterm, exit and malloc — all standard C runtime start-up routines. Emulation then stopped with exit called. That is the entire observable story of this binary under execution: it initialises its runtime, finds no key, and terminates cleanly.

The implication deserves to be stated plainly. Any verdict that depends on what the sample does when executed — dynamic analysis, sandboxing, behavioural detection — sees a small, well-behaved program that starts and quits. Nothing in that observation is malicious. A sandbox would score it benign, and would be correctly reporting what it saw.

The Dekeneas verdict does not depend on that observation. The emulator is one signal among several, and for this sample it is deliberately a weak one. The decisive evidence sits in the code itself — how it resolves functions, how it treats memory, how it parses PE structures — and that evidence is present in the binary in readable form whether or not the key is ever supplied, because the loader cannot perform its function without it. A loader that encrypts its payload still has to contain loader logic, and loader logic is identifiable on its own terms.

The risk score remained 100%.

Dekeneas emulation: seven CRT APIs resolved at runtime, emulation stopped with exit called
Figure 4 — Dekeneas emulation: seven CRT APIs resolved, stop on exit

What the engine reported

The verdict rests on 1 suspicious artefact, 3 behaviour indicator categories and 10 distinct code capabilities, each located at a specific virtual address with the matching disassembly attached. Individually, as we will keep emphasising, none of these is conclusive. Together they describe a single, coherent program with a single, coherent purpose.

Runtime function linking

Link function at runtime on Windows matched at two locations, at instruction scope. The disassembly shows the pattern directly: indirect call rax instructions whose results are stored and then tested for null before execution continues. Function addresses are obtained at runtime and verified before use, rather than declared and bound by the loader.

The reason a loader does this is the same reason it matters analytically. An address resolved through GetProcAddress or manual export-table parsing appears nowhere in the import table, which means the binary's declared API surface — the first thing most static engines enumerate — describes only what the binary is willing to admit to. The null checks are characteristic, too: dynamically resolved addresses are untrusted by construction, and careful loaders validate them before calling, exactly as this code does.

The import table is correspondingly small. KERNEL32.dll supplies twelve imports, among them GetProcAddress, Sleep, TlsGetValue and GetCurrentProcess — start-up, timing and self-reference primitives. The functions the loader actually depends on for its payload — the virtual-memory allocation and protection routines a shellcode stage requires — do not appear there, because they are resolved at runtime, after decryption, under the operator's key.

Memory staged for execution

Change memory protection, allocate or change RWX memory and allocate or change RW memory, each matching at three locations.

Read in sequence, these three capabilities describe the standard choreography of shellcode staging. First, memory is allocated writable (RW) — a region the loader can fill with decrypted content. Then, once the payload bytes are in place, the region's protections are changed to make it executable — the transition the change memory protection and allocate or change RWX memory capabilities capture. Finally, control is transferred into the region. No application with a legitimate purpose performs this dance: allocating memory you intend to execute, and toggling its protection flags to get there, is the structural fingerprint of code that exists to run code that is not itself.

PE structure parsing

Parse PE header and enumerate PE sections, each matching at three locations, together with contain loop at function scope.

The binary reads PE structures in memory and iterates over them. This is how a loader locates modules and their exports without relying on the import table: walk the loader data structures, walk each module's export directory, hash or compare names, recover addresses. The presence of PE-parsing loops in a 48 KB executable with twelve imports is a structural contradiction that resolves in only one direction — the binary is reading the structures of other images in its own address space in order to find functionality it declined to declare.

Anti-analysis

Delay execution, matching at two locations, and the suspicious artefact time-based sandbox evasion via long sleeps.

Delay is the cheapest effective anti-sandbox technique in existence. Automated analysis environments observe a sample for a bounded window — seconds to a few minutes — because analysis at scale is a queueing problem. A sample that sleeps longer than the window produces, from the sandbox's perspective, a program that does nothing. The long sleeps flagged here serve exactly that purpose, and they compound the keying problem described above: this binary gives an observer neither its data nor its time.

Thread local storage

Get thread local storage value at two locations, and the presence of a .tls section at file scope.

TLS provides a mechanism for code to run and state to be held outside the main execution path — callbacks fire before the entry point, and per-thread storage persists across the thread's lifetime. In ordinary applications TLS is a compiler-generated artefact of the C runtime. In a deliberately minimal loader, a .tls section combined with explicit TLS access is a place to keep state, or run code, that does not appear in the linear story the disassembly of main would tell. It is one more way this file's interesting behaviour lives outside the obvious path.

Behaviour indicators

Anti analysis, memory operations and process operations — three indicator categories that summarise the capability set above: an executable that stalls, stages memory for execution, and manipulates its own process context.

Dekeneas verdict: Malicious, risk score 100%, with SHA-256 and PE metadata
Figure 5 — Dekeneas verdict and PE metadata
Suspicious artefact (1), behaviour indicators (3) and emulation with seven APIs resolved at runtime
Figure 6 — Suspicious artefacts, behaviour indicators and emulation
link function at runtime on Windows capability, two matches with disassembly at virtual addresses
Figure 7 — link function at runtime on Windows, two matches with disassembly
Suspicious code, ten capabilities: delay execution, change memory protection, allocate or change RWX memory, parse PE header and others
Figure 8 — Suspicious code, ten capabilities
Import Address Table: KERNEL32.dll with twelve imports including GetProcAddress, Sleep, TlsGetValue and GetCurrentProcess
Figure 9 — Import Address Table, KERNEL32.dll

The reasoning, not just the score

No single capability above is conclusive, and it is worth being precise about why, because the precision is what makes the composition persuasive. Legitimate software changes memory protections — any JIT compiler or self-modifying interpreter does. Legitimate software calls Sleep. Legitimate software resolves functions with GetProcAddress, and some hardening-conscious applications do so deliberately to complicate exploitation. Each capability, taken alone, has a plausible innocent reading.

The verdict comes from the combination, and from what the combination excludes. Runtime function linking means the binary hides its functional dependencies. Memory allocated and re-protected for execution means it prepares a stage for code that is not itself. PE structures walked in memory mean it finds that stage's supporting functionality without declaring it. Deliberate execution delay means it refuses to demonstrate any of this under observation. And all of this lives in a 48 KB binary with twelve imports and no functionality of its own to explain any of it — no UI, no document handling, no protocol implementation, nothing a user could have run on purpose. Everything the code is built to do serves one purpose: to prepare memory and hand control to something else.

The analyst note states that purpose directly:

The sample has been classified as malicious by the machine learning pipeline. It exhibits behaviors typical of a loader, as evidenced by its ability to allocate and modify memory permissions, delay execution, and dynamically resolve function addresses at runtime.

It then assesses the consequence:

The primary risk associated with this sample is its potential to load and execute additional malicious payloads, which could lead to further system compromise.

The note maps the findings to six MITRE ATT&CK techniques, and the mapping repays reading closely, because each technique corresponds to one structural observation: T1129 (execution through API, the runtime-resolved calls), T1106 (execution through module load), T1620 (reflective code loading — the staged, in-memory payload), T1055 (process injection, the class of behaviour the memory choreography belongs to), T1497.003 (time-based evasion, the sleeps) and T1622 (defensive-evasion techniques including the PE-structure parsing used to avoid declared imports). This is what a detection engineer or an incident responder actually consumes: not a score, but an account of mechanism, mapped to a shared taxonomy, that can be turned into a hunt or a control.

AI Malware Analyst Note: behavior, possible family type, MITRE techniques and possible risks
Figure 10 — AI Malware Analyst Note
AI Assessment: family loader at high confidence, key behavior and MITRE ATT&CK techniques
Figure 11 — AI Assessment: loader, high confidence

Thirty detections, read closely

A detection count treats every flag as equal, and this is the single most misleading thing about the way multi-engine results are conventionally reported. Operationally, flags are not equal, and a security team does not respond to them equally. A label of Trojan:Win64/CobaltStrike triggers an incident response playbook: isolate the host, scope the intrusion, hunt for the second stage. A label of Riskware/Application triggers, at most, a policy check — and in many enterprise environments, riskware categories are explicitly allow-listed because they generate too many false positives on legitimate tooling to treat as incidents.

What the engine returnedEnginesExamples
Named Cobalt Strike8Microsoft, Alibaba, AliCloud, Antiy-AVL, CTX, Kingsoft, Lionic, Rising
Generic or ML-based malicious18Symantec, CrowdStrike Falcon, Elastic, DeepInstinct, Palo Alto Networks, Trellix ENS, WithSecure
Riskware or potentially unwanted4Fortinet, K7AntiVirus, K7GW, Sophos
Undetected41Kaspersky, BitDefender, ESET-NOD32, TrendMicro, SentinelOne (Static ML), Emsisoft

Read this way, the "30 detections" headline resolves into something much thinner. Eight of 71 engines tell an analyst what this file is. Eighteen more establish that something is wrong — genuinely useful, but undifferentiated: a label such as Malicious (score: 99) or Win/malicious_confidence_70% carries no account of why the engine is suspicious, which means the analyst inherits the analysis the engine declined to do. Four engines flag the file at a severity that is commonly deprioritised or allowed by policy, which in practice can be worse than no flag at all — a riskware label suppresses urgency rather than creating it. And 41 engines return nothing.

Dekeneas returns the verdict and the reasoning together: a role (loader), the capabilities that establish it, and the code — at virtual addresses, with disassembly — that proves them. The difference between "malicious, confidence 70%" and "loader, high confidence, here is the memory-staging sequence" is the difference between an alert and an assessment.


On the family attribution

The AI assessment classified the sample as a loader, at high confidence. It did not name Cobalt Strike — and that omission is a feature of the analysis, not a gap in it.

The distinction is between a file's role and its lineage. The role is a property of the code in front of you: what it is constructed to do. The lineage is a property of its payload: what it was built to carry. This PE is a stager. Cobalt Strike is what it carries — an encrypted shellcode payload that, by design, cannot be read without the operator's key. The code Dekeneas analysed is the code that prepares memory, resolves functions and transfers execution. That code is a loader, whatever it happens to be holding, and the note says so on exactly that basis:

This conclusion is drawn from its behavior of allocating and modifying memory, resolving APIs at runtime, and its lack of direct command-processing or interactive capabilities, which are typical of loaders that prepare the environment for a second-stage payload.

The observation about absent command-processing capability deserves emphasis, because it is the piece of negative evidence that disciplined the attribution. A Beacon implant carries command handling, tasking and C2 logic. None of that is visible in this binary — not because the binary is benign, but because none of it is in this binary in readable form. It sits behind the operator's key, in the encrypted region, as ciphertext. Naming the framework from this artefact alone would have meant asserting something the analysed code does not contain: an analyst with only this file genuinely cannot know whether the payload is Cobalt Strike, Brute Ratel, a custom implant, or anything else. The evidence supports the role; the lineage is unavailable by construction.

This is the same principle described in Case Study 01, where the engine declined to name a family the capabilities could not discriminate. Here the principle has a harder edge: the payload was deliberately made unreadable, so the restraint is not just epistemically correct, it is the only option. And it still produces operationally useful output. A defender who knows the file is a keyed loader — not "generic malware", not "riskware" — knows to look for the second stage it was built to deliver, and knows that the absence of observed payload activity means nothing about whether the payload ran.


Independent corroboration

There is one more piece of evidence, and it comes from an unexpected direction. VirusTotal's own Code Insights — an AI analysis of the file that is independent of Dekeneas in method, training and operation — reached the same structural conclusion from the same bytes. It describes an environmentally keyed shellcode loader that locates ntdll.dll through PEB traversal, decrypts and resolves native APIs such as NtAllocateVirtualMemory, changes memory protection to PAGE_EXECUTE_READ via VirtualProtect, and executes the decrypted shellcode directly.

Convergence of this kind is worth more than either result alone. Two analyses built differently — different engines, different pipelines, different design choices — reading the same file and agreeing on the mechanism is exactly what independent corroboration looks like. Both identify runtime API resolution. Both identify memory staged for execution. Both identify a payload gated behind a key. Both mark the file malicious.

The point generalises: the verdict does not rest on engine counts, on reputation, or on any single method. It rests on what the code is built to do — and on that question, the independent evidence converges.


A likely explanation for the detection gap

Taken together, the sample's properties explain — structurally, not speculatively — why ten months have not been enough. Each layer of the design removes one category of evidence:

  • Declarations. At 48 KB with twelve imports, the import table describes almost nothing of what the binary does. Engines that characterise files by their declared API surface are reading a deliberately impoverished summary.
  • Strings. API names are encrypted until the key is supplied, so string extraction recovers none of them. The plaintext indicators most static signatures and heuristics feed on are absent.
  • Content. The payload is encrypted, so content signatures for Cobalt Strike shellcode — among the most widely deployed signatures in the industry — have nothing to match against.
  • Execution. Without the key, execution ends after runtime initialisation, so behaviour observed at runtime is benign. Sandboxes and dynamic engines are not failing; they are being shown a program that does nothing.
  • Time. Long sleeps add a further obstacle for any sandbox with a fixed observation window, stretching the already-empty execution trace past the point of patience.

Each of these is a standard, well-documented technique. None is novel. What makes this file hard to detect is not sophistication — it is the thoroughness with which the ordinary techniques cover one another's blind spots. Together, they leave an engine that relies on declarations, strings, content or execution with almost no evidence at all.

Dekeneas reaches a verdict because the structure of the loader cannot be encrypted away. The code that resolves functions, re-protects memory and walks PE headers has to be present in readable form for the loader to work — those instructions are the loader. An engine that evaluates what the code is constructed to do, at instruction level, therefore retains a full evidential basis where engines that evaluate what the file declares, contains, or does have been given nothing.

We offer this as an explanation consistent with the evidence, not as a claim about how any specific vendor's engine operates.


What this case demonstrates

  • Time does not close every gap. Ten months after collection, 41 of 71 engines still miss a Cobalt Strike loader — a detection lag an order of magnitude beyond the industry's own signature pipeline.
  • Detection counts overstate coverage. Of the 30 detections, 8 identify the framework and 4 rate it as riskware or a potentially unwanted application — severities that are commonly deprioritised or allowed by policy.
  • Environmental keying defeats execution, not structure. Without its key, the sample does nothing observable at runtime, and its strings and payload are unreadable. The verdict was still 100%, because the loader's logic cannot hide.
  • Attribution follows the evidence. The engine named the file's role — loader — at high confidence, and made no claim about a payload it could not read. That restraint is the analysis, and it is what makes the output actionable.
  • The output is verifiable. Every capability is reported with its virtual address and disassembly, and an independent analysis of the same file reached the same structural conclusion.

Verify this yourself

This case is checkable end to end. The sample can be looked up on VirusTotal under the hash above, where the detection results — the 30 flags, the 41 silences, the eight engines that name Cobalt Strike — and the Code Insights summary can be verified directly against what this page reports.

The Dekeneas free tier includes malware analysis at no cost and requires no commitment. We encourage prospective users to test the engine against samples where they already know the ground truth — including samples the industry handles well, so the comparison runs in both directions. An engine is only worth trusting on the samples it gets right that others miss if it is also right on the samples everyone gets right.


Scope of the comparison

As with the earlier case studies, the limits of this result are part of the result. This is one binary, and the honest summary is exactly what it is: a correct verdict on a Cobalt Strike loader that most static engines still miss ten months after collection. It is not a detection rate, and we do not present it as one.

The comparison is also specific in scope. VirusTotal runs static analysis configurations, so this compares static analysis against static analysis — the appropriate comparison, since Dekeneas is performing static analysis too. The engines listed on a VirusTotal report are not the vendors' full endpoint products, and we make no claim about how those products behave at runtime, having neither tested them nor any basis for an opinion. Where runtime behaviour is the question — and for this key-gated sample, runtime behaviour is deliberately uninformative — the right instrument is a different one, and the right claim is the narrower one we have made.

Dekeneas maintains no signature set, no malware family database and no reputation service in the verdict path. Every assessment is computed from observed behaviour.

Analyse a sample →