IONSEC
Resources
Toolsopen source · ransomware

The clock is still the key: INSITO, free recovery for Rhysida's ESXi locker

INSITO is a free, open-source (MIT) single binary that recovers files encrypted by Rhysida's ESXi locker. No ransom, no attacker keys, no internet. This post covers the tool, a live recovery, and the research behind it.

IONSEC Team

Published

Updated

Read

14 minutes

The clock is still the key: INSITO, free recovery for Rhysida's ESXi locker

A datastore full of .rhysida files used to have one practical answer: the ransom note. For the ESXi build of this family, that is no longer true.

INSITO is our free, open-source recovery tool for Rhysida’s ESXi locker. It is one static binary, MIT licensed, that you copy to the ESXi shell (or any Linux box), point at the datastore and leave to work. It needs no ransom, no attacker keys and no internet connection. The name says where it works best: in situ, on the host where the ransomware ran.

32-bitwall-clock second: the only secret behind every per-file key
0attacker keys, ransom payments or network calls needed
4/4files restored byte-exact on a live datastore, clock found blind
1static x86-64 binary, ~1.4 MB, runs under ESXi's BusyBox

It builds on the researchers who broke this family first, credited in full below, and extends their method to the one build their tooling did not reach. The rest of this post covers what ships, a live recovery, how responders get the fastest result, and the research behind it.

Why this tool exists

Rhysida encrypts VMware datastores in place and leaves a CriticalBreachDetected note. In February 2024, researchers at Kookmin University, working with KISA, showed that the family’s key generation could be regenerated, and a free decryptor followed [1][2][4]. That decryptor covers the early Windows builds. Recovery guidance has since carried a consistent caveat: newer builds and the Linux/ESXi variant are not covered [5].

A production cluster with every datastore encrypted is one of the highest-stakes scenes in incident response. Decryptor work across the community and vendors never stops, and every family that gets broken matters. This was the piece we could close, so we built it and are giving it away.

The flaw, and the gap we closed

The flaw. Every Rhysida-encrypted file ends with a trailer holding the file’s AES-256 key and IV, each wrapped with RSA-4096. Unwrapping should require the attacker’s private key. But the randomness behind the key, the IV and the wrap itself comes from a stream seeded with nothing but the wall clock: a 32-bit count of seconds. The Kookmin/KISA team proved for the Windows builds that this stream can be regenerated from the seed. Recovery is therefore a search for one second, not an attack on RSA.

The gap. The ESXi locker carries the same flaw behind a different C library. It links glibc, whose rand() is an additive-feedback generator with nothing in common with the Windows C runtime’s linear congruential generator that the published method regenerates. The stream is consumed in a different order, and the target is a datastore rather than a file share: thousands of files, a BusyBox userland, no package manager, no room for tooling. None of the published tooling covered this build.

What INSITO adds. A from-scratch model of the ESXi locker’s generator and wrap construction, verified byte-for-byte in the lab; a trailer-replay check that needs nothing but the encrypted files; an automatic clock search that scales to every core when no time anchor is available; and a single static binary that runs where the incident is. The engine is one readable C file.

What ships

  • Single static binary. x86-64 Linux and ESXi, ~1.4 MB, no dependencies. scp it to the host and run it under BusyBox. Every tagged release is built in CI and published with SHA256SUMS.
  • One-time consent, then silence. A short MIT notice on first run; type accept once. The acceptance is recorded locally and later runs stay quiet. Scripts pass --accept-license.
  • Automatic clock search. With timestamps intact, the search anchors itself on the files. With no anchor, it escalates to a hardware-scaled search over the last 30 days (configurable).
  • Reports you can hand to an insurer. Every run writes a text and a JSON recovery report: clock window, the second that matched, per-file results. Encrypted originals are opened read-only and never modified.
  • Fully offline. No telemetry, no downloads, no keys sent anywhere. The crypto libraries are vendored in the repository, and the binary builds from source with two commands.
  • Tested in CI. A deterministic synthetic corpus verifies the recovery engine byte-for-byte on every push, alongside AddressSanitizer and UndefinedBehaviorSanitizer builds, secret scanning and CodeQL.

Watch it work

Four files encrypted by the real locker on a datastore. One command. The encryption second found blind, 4/4 files restored and verified by SHA-256.

Live recovery on a lab ESXi host: one command, 4/4 files restored. No sound; every line on screen is the tool's own output.

Faster recovery: a guide for responders

The tool is fastest where the ransomware ran. The search is anchored on the clock, and every step taken offline can strip away its best clue: the files’ own timestamps. Plan the recovery in this order:

TierWhere you run itSpeedWhat to do
0On the affected ESXi host, against the datastoreFastest (minutes)Nothing to configure; mount read-only if you can
1Offline, timestamps preservedSame as tier 0Copy with tar cpzf, rsync -aH or scp -p, never plain cp/scp
2Offline, timestamps lost, clock knownNear tier 0Run date +%s on the victim host, then --clock <epoch>
3Offline, nothing knownCompute-boundAutomatic full-core search; bound it with --lookback <days>

Good clock anchors for tier 2 are vmkernel or hostd log timestamps, your IR timeline, or the ransom note’s drop time. For tier 3, a few hours of window is minutes of compute; the 30-day default is a long run, so narrow it the moment anyone can name the incident week. --clock and timestamp-preserving copies are the difference between minutes and days.

Get it, build it, verify it

CyberWeek 2026 · Monday, 9 November 2026
The source repository and the release binary go public on Monday, 9 November, at 09:00 Israel time.
  • Source: github.com/ionsec/insito
  • Download: the latest release binary with SHA256SUMS
  • Verify: sha256sum -c SHA256SUMS. The release binary is fa0402e646c671478ca387c71f597a27fcf49a5cc1e0782bccc9a092afb659f5, and its VirusTotal scan is public.
  • Build: make vendor && make. LibTomCrypt and LibTomMath ship in the repository; nothing else is required.
  • Preview: ./insito --scan /vmfs/volumes/<name> is a dry run that writes nothing.
  • Recover: ./insito --datastore /vmfs/volumes/<name> confirms, restores and reports. Scripted runs add --accept-license --yes.
  • If nothing matches: leave it running. The offline search uses every core and stops on the first hit; --lookback, --window and --threads give you control.

Inside the research

The rest of this post is the research behind the tool, condensed from our internal write-up. It is here so the method can be checked rather than trusted.

R1. One ESXi sample in public reach

The scope of the claim depends on how many ESXi builds exist to test, so we swept every public acquisition channel available to us for the family’s ELF build:

SourceSearchResult
MalwareBazaar (abuse.ch)Five tag spellings plus an ELF file-type filter31 Rhysida-tagged files, exactly one ELF
ThreatFox (abuse.ch)Rhysida IOC searchIOCs present, no sample-linked hashes
theZooFull repository indexNo Rhysida (the family post-dates the collection)
Kookmin/KISA paper, Table 1 [1]11 analyzed buildsWindows (PE) builds only, no ELF hash

That single public build is an x86-64 ELF of 259,304 bytes, statically linked against glibc and LibTomCrypt, first seen on MalwareBazaar on 10 December 2023. It carries the Rhysida-0.1 label in its encryption code and the family’s ESXi behaviour: esxcli calls, a /etc/motd rewrite and an attempt to move the VMware hostd web root.

R2. Same flaw, different libc

Decompiling the ELF shows main doing what the Windows builds do, srand((unsigned) time(NULL)), and then building one global ChaCha20 generator whose 40 bytes of seed material come straight from rand():

/* ESXi build, decompiled */
srand((uint) time(NULL));
chacha20_prng_start(&ps); chacha20_prng_ready(&ps);
for (i = 0; i < 0x28; i++)                    /* 40 entropy bytes */
    ent[i] = ((char)(prng_idx + i + 1)) * (char)(rand() % 0x100);
chacha20_prng_add_entropy(ent, 0x28, &ps);
p = malloc(rand() % 0x100 + 1);               /* one interleaved draw */
chacha20_prng_read(p, 8, &ps);                /* 8-byte self-test */
free(p);

On Windows, rand() is the C runtime’s linear congruential generator, which the published method regenerates. On the ESXi build it is glibc’s TYPE_3 additive generator, and this is where the method had to be rebuilt. Two details cost us iterations and are worth recording. First, recent glibc releases no longer expose the classic published state constants, so textbook reimplementations reproduce nothing. Second, the live generator is a 31-word state: r[0] holds the seed, r[1..30] are Lehmer iterates, the feedback pointers start at 3 and 0, and 310 outputs are discarded before the first real draw. We replicated it exactly and verified it draw-for-draw against a live glibc across many seeds:

/* glibc TYPE_3, faithful model */
r[0] = seed;
for (i = 1; i <= 30; i++)                     /* Lehmer chain */
    word = 16807*(word % 127773) - 2836*(word / 127773), r[i] = word;
f = 3; k = 0;
for (i = 0; i < 310; i++)                     /* warm-up discards */
    (r[f] += r[k]) &= 0xffffffff, f = (f+1)%31, k = (k+1)%31;
/* rand(): */ r[f] += r[k]; return (uint32)r[f] >> 1;

R3. The file format

Encrypting a file takes 48 bytes from the global stream (a 32-byte key, then a 16-byte IV), encrypts the body in place with AES-256-CTR using a little-endian counter, and appends a fixed 1,036-byte (0x40C) trailer:

┌──────────────────────────── 0x40C trailer ─────────────────────────────┐
│ RSA-4096-OAEP(key32) 512 B │ len4 = 512 │ RSA-4096-OAEP(iv16) 512 B   │
│ len4 = 512 │ type4 = 1                                                │
└────────────────────────────────────────────────────────────────────────┘
  OAEP label "Rhysida-0.1"; OAEP seed bytes drawn from the same live stream

Each wrapped blob is a deterministic function of the stream. Given a candidate second, we can re-derive the key and IV, replay both RSA-OAEP wraps with the locker’s own embedded public key, and compare the result with the file’s trailer. The public key is no secret: the locker has to carry it to encrypt, and we carve it from the sample at build time. Campaign keys rotate, so --key accepts a different locker binary, a PEM block or a raw modulus and exponent.

R4. The trailer-replay check

INSITO chains those steps into one program. For every candidate second in the window, it rebuilds the ChaCha20 stream exactly as main does, draws key and IV pairs along it, replays both wraps and compares them byte-for-byte with every file’s trailer. The second that matches re-derives each file’s key and decrypts it. No plaintext, no captured keys and no RSA private key are involved; the only inputs are the encrypted files and a clock window. Each comparison costs one cheap public-key operation, and on a real incident the detonation time is usually known to the minute.

=== victim-side run against the validation set ===
#SEED 1793983242 resolved=4/5
contract_2026_final.pdf.rhysida   seq=0  3628B  exact=1
invoice_2026.xlsx.rhysida         seq=1 20024B  exact=1
notes_project.txt.rhysida         seq=2    40B  exact=1
photo_holiday.jpg.rhysida         seq=3 65560B  exact=1
=== RESULT: resolved=4/5 files; 4 byte-exact vs originals ===

The unresolved fifth file is the ransom note, not a victim file.

R5. Reproduced and recorded

Because the claim rests on a single public build, we recorded the full lifecycle (staging, detonation, recovery) inside a disposable, network-isolated container, with a filesystem snapshot at each stage. The sample stayed on a read-only mount, and the snapshots hold only synthetic decoy files and outputs.

StageContents
T0, stagedFour plaintext decoy files and their SHA-256 manifest
T1, encryptedFour .rhysida files and the CriticalBreachDetected note
T2, recoveredThe post-recovery state, including the restored copies

The decryptor ran blind over a two-minute window and returned exactly 1793983242, the recorded detonation second. Every restored file matched its pre-encryption SHA-256 from the T0 manifest. A second, independent detonation earlier the same day agreed: seed 1793982603, equal to its detonation second, 4/4 byte-exact.

R6. What this covers, and what it does not

  • Covered. The public ESXi/ELF build, validated byte-exact across three recorded live detonations and one victim-side run.
  • Build-dependent. The clock flaw is specific to the build. A Rhysida build that moved key generation off the clock, or switched generators, will not match, and no amount of searching can manufacture a hit. Triage first: check the marker strings, carve the embedded public key and confirm the entropy source before relying on a sweep. We tested the one public ESXi build; the absence of others is a finding, not proof that none exist.
  • Large files. Files well over ~1 MiB may fall under partial-encryption rules we have not exercised. Recovery covers what the trailer’s CTR body holds, and we do not claim more.
  • Not recoverable. Builds with the flaw removed.

R7. Indicators

IndicatorValue
ESXi/ELF encryptor (SHA-256)be5d2e94c2498ec052fb025e3348085e418c856dd43080501acfe2067ba54c41
Encrypted-file extension.rhysida
Ransom noteCriticalBreachDetected
Trailer0x40C bytes: [keyblob 512][len4][ivblob 512][len4][type4]
OAEP labelRhysida-0.1
Onion portal (from the note)rhysidafohrhyy2aszi7bm32tnjat5xri65fopcxkdfxhi4tidsg7cad[.]onion
Host behaviour (Linux)esxcli invocation, /etc/motd rewrite, VMware hostd web-root mv attempt
ArtifactSHA-256
Carved ESXi campaign public key (pubkey_elf.h)15d6acb635b351591edbbe6aaa8dfeb7eaf58ffd780b38e983dcd726de7ae8b4
INSITO static binary (release)fa0402e646c671478ca387c71f597a27fcf49a5cc1e0782bccc9a092afb659f5

Offline, audited, honest

A recovery tool is only as trustworthy as its behaviour when nobody is watching. INSITO’s engine is a single readable C file. The search never touches the network. Originals are opened read-only, and every write is a new file under rhysida_recovered/. There is no account, no license server and no usage ping. The one-time consent record is stored locally; inspect it with insito --license-status and delete it with rm.

All research was carried out in an isolated, authorised lab on a sample from a public malware repository. No third-party data was touched, and no attacker private key exists anywhere in our stack: everything the tool needs is the public key the malware carries and the victim’s own clock.

License and responsible use

INSITO is released under the MIT license, © 2026 IONSEC.IO. Use it only on systems you own or are explicitly authorised to recover. Recovery is best-effort: keep the encrypted originals until the restored copies are verified (INSITO never modifies them). Unlawful use is prohibited; you are responsible for your use.

Ransomware or IR emergency? On-call responders, 24/7. Assured four-hour response from first contact. Call +972 54 318 1773 WhatsApp → (opens in a new tab) info@ionsec.io

References

LibTomCrypt and LibTomMath are vendored under their own licenses.

Frequently asked questions

Can Rhysida-encrypted ESXi files be decrypted without paying?

Yes, for the ESXi/Linux build covered here. Its per-file keys come from a generator seeded with the wall clock, so INSITO can regenerate them once it finds the encryption second. No ransom, attacker key or network access is involved.

Does INSITO need the network or an attacker-supplied key?

No. INSITO works from the encrypted files themselves and the public key the locker already carries. Nothing is uploaded, fetched or sent anywhere.

Does the KISA Rhysida decryptor work on ESXi?

No. The public decryptor released with KISA in 2024 covers early Windows builds of Rhysida. The ESXi/Linux locker uses a different C library and random number generator, which is the gap INSITO closes.

What does the demo show?

A live recovery of four files encrypted by the real locker on a datastore: one command, the encryption clock found blind, and 4/4 files restored and verified by SHA-256.

Is INSITO a general ransomware decryptor?

No. It targets the Rhysida ESXi locker specifically. Builds that no longer seed from the clock, and other ransomware families, are out of scope.