At a glance
| SHA-256 | 22b38dad7da097ea03aa28d0614164cd25fafeb1383dbc15047e34c8050f6f67 |
|---|---|
| Filename | v6jif.exe |
| Source | Recovered during incident response to a customer cyber attack |
| File type | PE32+ executable, x64, console subsystem, 3.77 MB, 8 sections, compiled with Go |
| Compile timestamp | Not present |
| Family | The Gentlemen ransomware (VirusTotal popular threat label ransomware.gentlemen/blackbyte) |
| Operators | Tracked as Storm-2697 by Microsoft and GOLD SHERWOOD by Sophos [1][3] |
| Public documentation | This SHA-256 is the encryptor dissected by Microsoft Threat Intelligence on 28 May 2026 [1] |
| Dekeneas verdict | Malicious — risk score 99.5% |
| Dekeneas analysis | 22 suspicious artefacts, 4 behaviour indicator categories, 28 code capabilities, 10 recovered network targets |
| VirusTotal, 18 November 2026 | 28 / 39 engines returning a verdict; 28 further engines timed out |
Summary
Dekeneas classified this binary as malicious at 99.5% risk. In a single static pass — no detonation, no signatures, no family database — it recovered the encryptor's propagation tooling, its persistence mechanisms, its evasion logic, its ransom note patterns, its cryptographic routines and the operator's Tor contact address.
This case can be checked in detail, and that is what makes it different from a detection comparison. The same file was reverse engineered and published by Microsoft Threat Intelligence in May 2026 [1], and the wider operation has been documented by Acronis [2], Sophos [3] and Trend Micro [4]. Each of the engine's principal findings can be set against that published analysis, finding by finding, and this case study does exactly that.
The result is an unusually clear picture of what static capability analysis establishes on its own, where it matches expert reverse engineering, where it goes beyond the published reporting — and where it honestly stops.
Background: The Gentlemen ransomware
The Gentlemen is a ransomware-as-a-service (RaaS) operation that emerged in mid-2025. It began as a closed group and opened its platform to affiliates in September 2025 [1]. Trend Micro first investigated a campaign by the group in August 2025 [4]. Acronis reports that the group previously operated as an affiliate of established RaaS programmes, including LockBit and Qilin, before deploying its own ransomware in July and August 2025 [2] — a pedigree that shows in the operation's tradecraft, which borrows the most aggressive techniques of its former employers.
The operation uses double extortion: data is stolen before files are encrypted, and published on a Tor leak site if the ransom is not paid [1][5]. Sophos counted 683 victim names on the leak site by the end of July 2026 [3]. Acronis reported more than 800 claimed victims by October 2026 [2], and Proven Data's leak-site tracking recorded 1,081 claimed victims as of 9 November 2026 [5]. The victim curve is steep, and it is still rising.
The Windows encryptor is written in Go and obfuscated with Garble [1]. Variants exist for Windows, Linux, NAS and BSD systems [2]. Its distinguishing feature is aggressive self-propagation: when enabled, it attempts to deploy itself to every reachable host using many independent lateral movement methods per target [1]. Intrusions typically begin with exploited firewall or VPN interfaces and valid credentials. Affiliates escalate privileges quickly, deploy EDR killers that abuse vulnerable drivers, and exfiltrate data with tools such as Rclone before deploying the encryptor — in some cases within 24 hours of first post-compromise activity [3].
Why this case has a ground truth
Case Studies 01 and 06 used industry detection as the reference point for the verdict: the question was whether the rest of the industry would eventually agree. This case has something stronger — a published, peer-visible account of what this exact file is and what it does.
The SHA-256 of the binary recovered from the customer incident is listed by Microsoft Threat Intelligence as the Gentlemen encryptor analysed in its May 2026 report [1]. That report documents the sample's command-line interface, password check, defence evasion, persistence, encryption scheme, ransom note and propagation logic in detail — the product of expert reverse engineering, published for the defence community.
That makes a precise question possible, and it is the question this case study answers: of everything that team of expert reverse engineers found in this file, how much did a fully automated static analysis recover — without executing it, without signatures, and without being told what the file was?
The sections that follow answer that question finding by finding. They are equally explicit about what the engine reported that the published analysis does not describe, because that boundary — between what is confirmed, what is corroborated and what is a lead to be checked — is itself part of what a verdict is worth.
A password the sample keeps to itself
The Gentlemen encryptor will not run without an operator password. Each build embeds its own value and compares it with the --password argument. If the argument is missing, the binary prints a usage message and exits; if the password is wrong, it prints bad args and terminates [1][2]. Microsoft describes this as a measure to prevent accidental or unauthorised detonation if the binary is recovered [1] — the operator's insurance against their own tooling being analysed live.
The Dekeneas emulator recorded behaviour consistent with this published account. It resolved six APIs at runtime — GetStdHandle, WriteFile, LoadLibraryExW, TlsAlloc, WaitForSingleObject and ExitProcess — and stopped when ExitProcess was called. Obtaining a console handle, writing to it and exiting is precisely the documented path: print a message, then quit.
This is the same pattern as Case Study 06, where an environmentally keyed Cobalt Strike loader exited cleanly without its key. Any analysis that depends on watching the sample execute sees a small console program that prints a line and stops. The ransomware never runs. Microsoft notes that because the password check is a static comparison, it can be identified and bypassed through static analysis [1] — the analysis path that does not require the sample to cooperate. The Dekeneas verdict did not need to bypass the check at all. The capabilities that establish the verdict are present in the code whether or not the password is ever supplied.
Engine findings, checked against published analysis
The table below sets each principal Dekeneas finding beside the corresponding behaviour documented by Microsoft and Acronis. Where the published behaviour is a close but not exact match, the table says so rather than smoothing the difference over.
| Dekeneas finding | Documented behaviour | Ref. |
|---|---|---|
| Compiled with Go (file scope) | Encryptor written in Go and obfuscated with Garble | [1] |
| Contain an embedded PE file | Binary carries an embedded copy of PsExec, dropped to C:\Temp\psexec.exe | [1] |
Recovered URL live.sysinternals.com/PsExec.exe | If the embedded PsExec cannot be extracted, it is downloaded from Sysinternals Live | [1] |
| PowerShell download cradle or encoded command | PsExec fallback download via Invoke-WebRequest; the locker relies heavily on PowerShell for system operations | [1][2] |
| Remote execution via WMIC | WMIC remote process creation on target hosts; WMIC also used to delete shadow copies | [1][2] |
| Malware can spread east-west | --spread mode turns the encryptor into a self-propagating worm, attempting 21 remote execution operations per host | [1] |
| Install itself for autorun at Windows startup | Run keys GupdateS (HKLM) and GupdateU (HKCU); scheduled tasks UpdateSystem and UpdateUser | [1][2] |
| Create a Windows service | Services DefSvc, UpdateSvc and UpdateSvc2 created on remote hosts during propagation | [1] |
| Escalate privileges | Relaunches itself as SYSTEM through the gentlemen_system scheduled task | [1] |
| Common ransomware note filenames or extensions | Drops README-GENTLEMEN.txt in each directory; renames files with a build-specific six-character extension | [1][3] |
| Encrypt data using Salsa20 or ChaCha | Per-file XChaCha20 encryption keyed through Curve25519 ECDH; ChaCha20 constants and quarter-rounds present in code | [1][2] |
| Time-based sandbox evasion via long sleeps | --T argument delays encryption by a number of minutes; sleeps between propagation stages (close match) | [1] |
| Resolve function by parsing PE exports | NtSetInformationProcess resolved dynamically from ntdll.dll (close match) | [2] |
Recovered .onion address | Identical address listed in Acronis network indicators | [2] |
Recovered handle x.com/TheGentlemen25 | Acronis lists the group's X account as TheGentlemen26 (related handle) | [2] |
Fifteen findings, each produced automatically from the binary, correspond to behaviour that expert reverse engineers documented by hand. Together they cover the encryptor's propagation tooling, persistence, privilege escalation, encryption, ransom note and contact infrastructure — the operational core of the intrusion, recovered without a single instruction of the binary being executed.
For an incident responder holding only the binary, that is precisely the information that sets the scope of the investigation. Other hosts reachable by PsExec, WMIC or remote services should be examined for encryption activity; Run keys, scheduled tasks and service entries are where to look for persistence; and the recovered Tor address is an indicator that can be shared with a CSIRT or ISAC immediately. The verdict is the headline, but it is this scaffolding that turns a verdict into a response.
Findings beyond the published reporting
The engine also reported capabilities that the analyses referenced here do not describe for this encryptor:
- Process hollowing (create suspended, unmap, remap, resume) and thread hijacking (suspend, context, resume)
- Decryption of protected data via DPAPI, flagged as credential theft, and a keylogger pattern
- Communications over UDP and RAW sockets, listening for incoming communication, and DNS use
- Anti-VM strings targeting QEMU and references to analysis tool strings
- Affect system token and affect private profile
These are reported here as leads, not as confirmed behaviour, and the distinction matters. A 3.77 MB Go binary links the entire Go runtime, its standard library, and an embedded third-party executable. A capability pattern can therefore reflect library or embedded code as readily as the operator's own logic — and published reverse engineering, by necessity, focuses on the code paths that drive the attack, not on every routine the compiler pulled in.
The value of reporting leads anyway is that an analyst can check each one directly. Every code capability is listed with its virtual address and disassembly, so a lead can be confirmed or dismissed in minutes — from evidence, rather than discovered by chance in a follow-up investigation, or never discovered at all. An engine that only reports what it is certain of is an engine that leaves its uncertainty invisible; reporting the uncertainty, located and checkable, is strictly more useful.
Published reporting on the wider operation does describe credential theft — affiliates locating LSASS and using Mimikatz — but as hands-on activity during the intrusion, not as a function of the encryptor itself [3]. Whether the DPAPI and keylogger patterns in this binary are affiliate tooling compiled in, library residue, or a capability the published analyses simply did not cover is exactly the kind of question the disassembly-attached leads let a responder settle.
Extortion infrastructure, recovered without detonation
The engine recovered ten network targets from strings, memory and configuration. It labels every one as an artefact and states that no live connection was observed: these are what the binary contains, not traffic it produced. That labelling discipline matters — the difference between "this binary talked to this host" and "this binary references this host" is the difference between confirmed C2 and a recovered indicator, and conflating them is how reports overclaim.
| Recovered target | What it is | Published corroboration |
|---|---|---|
tezwsse5czllksjb7cwp65rvnk4oobmzti2znn42i43bjdfd2prqqkad.onion | Tor hidden service | Identical address in Acronis network indicators [2] |
x.com/TheGentlemen25 | Social media account | Acronis lists TheGentlemen26 as the group's X account [2] |
tox.chat/download.html | Tox encrypted messaging | Leak site links to Tox chats for contacting the operators [2] |
getsession.org | Session encrypted messaging | — |
torproject.org/download/ | Tor Browser download | Ransom note directs victims to contact the operators via Tor [1] |
live.sysinternals.com/PsExec.exe | Remote execution tool | Fallback PsExec download source [1] |
The remaining targets — Microsoft certificate and CRL URLs, www.microsoft.com and go.dev — are ordinary residue of code signing and the Go toolchain. The engine reports them with the same artefact label, so the analyst sees everything that was recovered and can discard what is benign. Completeness with labelling beats filtering that hides its decisions.
The Tor address is the most significant single result in this case. It is the operator's contact point — the anchor of the double-extortion scheme — recovered from a binary that refuses to execute, and it matches, character for character, the indicator published independently by Acronis. For a CERT or SOC, that is not an abstract capability claim: it is a monitorable, shareable indicator of compromise, extracted from a file that gave a sandbox nothing.
The cryptographic layer and API resolution
The engine identified 28 code capabilities in total, each located at specific virtual addresses with the matching disassembly attached. Two clusters of those capabilities do most of the analytical work.
Encryption and hashing
Encrypt data using Salsa20 or ChaCha is the capability that corresponds to the encryptor's file encryption — the capability that makes the binary a ransomware rather than merely a loader. Microsoft documents per-file XChaCha20 encryption, with each file keyed by an ephemeral Curve25519 key pair and an ECDH exchange against the operator's embedded public key [1]. Acronis identifies the ChaCha20 constants and quarter-round operations in the decompiled code [2]. A stream cipher of this family, present in a binary with ransom note patterns and spreading logic, is the cryptographic signature of mass file encryption; nothing else in the malware economy uses XChaCha20 at file scale.
The engine also reported AES (including AES-NI encrypt and decrypt), RC4, SHA-256, SHA-384, SHA-512, HMAC, murmur3, FNV, Base64 and XOR. Neither published analysis attributes file encryption to these, and their presence is consistent with the cryptographic and hashing code a Go binary carries from its standard library and runtime — Go's crypto packages link generously, and Garble obfuscation itself uses some of these primitives.
This is the distinction capability analysis has to draw honestly, and the engine draws it: it establishes which primitives are present, and the composition of the binary — stream cipher plus ransom note plus propagation — indicates which of them matter. Presence is evidence; composition is assessment; the report keeps the two apart.
Manual API resolution
PEB access, access PEB ldr_data, get kernel32 base address, resolve function by parsing PE exports and enumerate PE sections, each matching at three locations. The binary walks the loader structures in the Process Environment Block and parses export tables to resolve functions directly — the same import-hiding technique documented in Case Studies 01 and 06, here serving an encryptor that has every reason to keep its functional surface undeclared.
Acronis documents one concrete instance of this pattern in the family's code: NtSetInformationProcess, resolved dynamically from ntdll.dll and used with the ProcessExceptionPort information class [2] — a low-level, undocumented-adjacent facility that no import-declared application needs. The 46 imports declared from kernel32.dll are not the whole picture of what the binary calls; they are the part of it the binary chose to admit to.
File-level indicators
Compiled with Go, contain an embedded PE file, contains PDB path, reference Base64 string, reference anti-VM strings targeting QEMU and reference analysis tools strings. The file-level cluster corroborates the story from a different angle: the Go provenance matches Microsoft's documentation [1], the embedded PE is the carried PsExec, and the anti-VM and analysis-tool references describe a binary that checks its surroundings before acting — consistent with the evasion-first design of the password gate and the long sleeps.
The reasoning, not just the score
No single capability above is conclusive, and each of the usual suspects has an innocent reading. Go binaries routinely carry cryptographic libraries — that is what the runtime is for. Administrators use PsExec, WMIC and PowerShell every day; an IT department without them would barely function. Sleep is called by well-behaved software the world over.
The verdict comes from the combination: an embedded remote execution tool with a download fallback, WMIC remote execution, east-west spreading, autorun persistence, service creation, privilege escalation, ransom note patterns and a stream cipher — in one binary that also carries a Tor address and encrypted-messaging contacts. Each element is explicable; the composition is not. There is no scenario in which a legitimate program needs to carry PsExec inside itself, replicate across a network, persist at startup through three independent mechanisms, escalate to SYSTEM, encrypt with an ephemeral-key stream cipher and leave a note directing victims to a Tor hidden service. That composition has no benign explanation, and it does not need one to be excluded — there simply isn't one.
The analyst note opens with the verdict and its basis:
The sample is classified as malicious by the machine learning pipeline, with a high confidence score of 99.47%.
It then assesses the consequences in terms a responder can act on:
Additionally, the potential for ransomware activities could result in data encryption and extortion.
The note maps its findings to six MITRE ATT&CK techniques — T1027 (obfuscated files or information), T1129 (shared modules), T1140 (deobfuscate/decode files or information), T1497.001 (virtualisation/sandbox evasion: system checks), T1105 (ingress tool transfer) and T1055 (process injection) — and ties each to the evidence behind it. Microsoft's analysis independently documents the PsExec download and the Garble obfuscation [1], which correspond to T1105 and T1027 respectively: two of the six mappings are confirmed by the same published research this case is checked against.
On the family attribution
The analyst note named ransomware explicitly. Alongside the persistence, propagation and C2 capabilities it reported, it identified ransom note patterns in the binary as an indication of ransomware capability, with the calibration the evidence supports:
...the presence of ransomware note patterns also hints at possible ransomware capabilities, though this is less certain without further evidence of encryption targeting user files.
The published analysis confirms it. This is the Gentlemen encryptor [1], and the ransom note the engine detected patterns for is README-GENTLEMEN.txt [1][3].
But the note stopped short of a ransomware classification. Its leading hypothesis was a loader or backdoor family, and the AI assessment recorded loader at medium confidence — lower than in Case Studies 01 and 06, where the structural evidence was unambiguous. The reason is visible in the evidence itself. The engine found a stream cipher and ransom note patterns, but capability analysis does not show on its own how a cipher is applied — whether it encrypts user files, protects an embedded payload or secures a channel. In a binary that also embeds and deploys another executable, resolves APIs manually and carries remote execution tooling, the loader reading fits the code too. And it is not a misreading: the encryptor does in fact carry and drop an embedded PsExec, and copies itself to remote hosts [1]. This binary genuinely is both things — a propagating loader whose payload happens to be an encryption stage.
The engine responded to that ambiguity the way an honest analyst should: it named ransomware as the open question, lowered its confidence on the family label, and reported everything it could establish without reservation. The description of what the binary does was never ambiguous — propagation, persistence, privilege escalation, encryption and ransom note patterns were all reported with full confidence. A responder reading the note would have scoped the incident correctly within minutes, whatever the family is called. That is the standard that matters: calibration on the claim that is uncertain, completeness on the claims that are not.
Twenty-eight detections, read closely
On 18 November 2026 — nearly six months after Microsoft published its analysis of this exact file — VirusTotal reported 28 of 39. That figure requires reading carefully, because 39 is not the number of engines that examined the file. VirusTotal listed 70.
| What the engine returned | Engines | Examples |
|---|---|---|
| Named Gentlemen | 9 | Microsoft, Elastic, GData, eScan, VIPRE, Lionic, Rising, TACHYON, ViRobot |
| Named BlackByte | 2 | Alibaba, AliCloud |
| Generic ransomware | 4 | K7AntiVirus, K7GW, Huorong, Kingsoft |
| Generic malicious or tool | 13 | CrowdStrike Falcon, Symantec, Palo Alto Networks, Malwarebytes, Cynet, ClamAV, WithSecure |
| Undetected | 11 | Acronis (Static ML), Antiy-AVL, SecureAge, TEHTRIS, Webroot, ZoneAlarm, Zoner |
| Timed out, no verdict | 28 | Kaspersky, BitDefender, ESET-NOD32, SentinelOne (Static ML), Sophos, TrendMicro, Trellix ENS |
| Unable to process file type | 3 | BitDefenderFalx, Symantec Mobile Insight, Trustlook |
A timeout is not a missed detection, and this case study does not pretend otherwise. It means the engine did not return a result within VirusTotal's analysis window — and a 3.77 MB Garble-obfuscated Go binary is exactly the kind of file that exhausts a fixed analysis budget. Several vendors in that row have published research on this family. But for anyone relying on that scan to triage the file, the practical effect is the same: no answer. Of 70 listed engines, 42 returned no verdict at all — 28 timed out, 11 reported clean, 3 could not process the file.
Of the engines that did answer, 15 identified ransomware by name or category. The remaining 13 flag the file without saying what it is — Generic.ml, Trojan Horse, Malware.AI, Unsafe. ClamAV's Win.Tool.Garble label identifies the obfuscator Microsoft documents [1] rather than the threat — a technically accurate observation that still leaves the analyst to work out what is underneath. Six months after a public, detailed dissection of this exact file, the majority of the engines that answered did not connect it to that research.
These VirusTotal results reflect static scanning configurations. Several of the vendors in the table document runtime protections against this family in their full products [1][2][3], and nothing in this section should be read as a claim about those products. The comparison is static against static — but that is the comparison a SOC holding an unexecuted binary actually faces.
A likely explanation for the gap
Large Go executables are a known, structural difficulty for static tooling, and this sample stacks three such difficulties on top of each other. The Go runtime and standard library are linked into every Go binary, so the operator's logic — the ransom note writer, the spreading engine, the encryption loop — sits inside several megabytes of code that is not malicious and was never intended to be analysed as a whole. An engine looking for signal must first find the operator's logic inside the runtime's noise. This sample then adds Garble obfuscation [1], which renames, splits and reorders that logic to defeat exactly the pattern-matching static engines rely on, and it carries no compile timestamp, removing one of the cheapest triage signals available. An engine with a fixed time budget per file may simply not finish; an engine relying on strings or structural heuristics has a great deal of noise to work through before it reaches anything decisive.
The encryptor also does much of its work indirectly. Propagation and cleanup run through PowerShell and native Windows utilities rather than direct API calls [2], which means the binary's own instruction stream contains fewer of the API patterns static engines key on — the work happens in command lines, not in imports. And, as in Case Study 06, the file refuses to run without its password [1][2], so execution-based analysis observes a console program printing a usage message and exiting. Between the runtime's noise, the obfuscator's misdirection, the indirect tooling and the execution gate, most of the standard evidence categories are degraded or absent.
Dekeneas reaches a verdict because it evaluates what the code is constructed to do, at instruction level, and locates the capabilities that matter within the code that does not. The propagation logic, the persistence writers, the ransom note patterns and the stream cipher are present in the binary as instructions, whatever Garble has done to their names — and instructions are what capability analysis reads.
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
- Automated static analysis can recover what expert reverse engineering documents. Fifteen findings correspond to behaviour Microsoft and Acronis documented in this encryptor, covering propagation, persistence, privilege escalation, encryption, the ransom note and contact infrastructure — in one pass, without execution.
- Execution gates do not hide structure. The encryptor refuses to run without its password; the emulator saw it print and exit. The verdict was still 99.5%, because the capabilities that establish it are in the code, not in the runtime behaviour.
- Actionable indicators do not require detonation. The operator's Tor address was recovered from the binary and matches the indicator published by Acronis — a shareable, monitorable IOC from a file that executed nothing.
- Confidence is calibrated per claim. Malicious at 99.5%; ransomware named explicitly but held as an open question, with the family at medium confidence — and the description of behaviour complete regardless.
- Every finding can be checked. Code capabilities come with virtual addresses and disassembly, so the findings beyond published reporting can be confirmed or dismissed directly, from evidence.
Verify this yourself
This case is checkable end to end. The SHA-256 above appears in the indicators of compromise of Microsoft's analysis [1], alongside hunting queries for Microsoft Defender XDR and Microsoft Sentinel. The VirusTotal results can be checked under the same hash, and the findings table above can be read against Microsoft's report line by line.
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.
Scope of the comparison
This is one binary, recovered from one incident. The result is what it is: an automated static analysis whose principal findings match published reverse engineering of the same file, on a day when most engines returned no verdict for it. It is not a benchmark, and we do not present it as one.
VirusTotal runs static analysis configurations, so the detection comparison is static analysis against static analysis — the appropriate comparison, since Dekeneas is performing static analysis too. Timeouts reflect a single VirusTotal scan and may resolve on reanalysis; 28 engines timing out on one file is itself a finding about the file's shape, but it is a finding about one scan, on one day. We make no claim about how these vendors' full products behave at runtime.
Where this case study describes the family, its operators or its behaviour beyond what the engine reported, it relies on the published research listed below rather than on Dekeneas output — and says so, at the point of use, throughout.
References
- Microsoft Threat Intelligence, The Gentlemen ransomware: Dissecting a self-propagating Go encryptor, Microsoft Security Blog, 28 May 2026.
- Acronis Threat Research Unit, The Gentlemen: A closer look at a not-so-gentle ransomware-as-a-service operation, 21 October 2026.
- Sophos Counter Threat Unit, Ungentlemanly behavior: Insights into a ransomware operation, 2026.
- Trend Micro, Unmasking The Gentlemen Ransomware: Tactics, Techniques, and Procedures Revealed, 2025.
- Proven Data, The Gentlemen Ransomware: Attack Chain, IOCs, and Incident Response Guide, accessed 18 November 2026.
Dekeneas maintains no signature set, no malware family database and no reputation service in the verdict path. Every assessment is computed from observed behaviour.