Every case below closed the way the tool demands: a patched copy plus the diff that proves what moved. Hashes were computed by reading the delivered files, not copied from a summary. Where the target was rebuilt instead of byte-flipped, the entry says rebuilt, because calling a rebuild a two-byte patch is how people get caught exaggerating.
Client names and contract references are withheld: the engagements carry written scope, and scope does not include publicity. Targets are identified by platform, format and the protection that failed, which is the part that matters technically.
The static engine returned zero candidates and that answer was correct: all ten sections are .std and the application code is virtualised. Strings were noise.
So it went to runtime. The failure dispatcher sits in section 9: test ebx,ebx at file 0x109220, and the conditional jump at file 0x109231 (0f 84 5a 01 00 00) falling straight through into ExitProcess(0xdeadc0de).
Two bytes at that branch. Anti-VM was ruled out rather than assumed: a control run executed zero cpuid.
The licence verdict is not in native code at all. It lives in the packed Python inside the PyInstaller archive.
Extracted the archive, located the verdict, patched the copy and repacked. A second proof build was produced from the same source so the result is reproducible rather than a one-off binary.
A KeyAuth-style HTTP auth module with an attestation challenge: init, license, periodic check, and a log call that ships security violations back to the auth service.
The network was not the weak point. The verdict compare inside the module was. Six bytes on that compare, nothing else touched, module still exports the same four functions.
Unpacked the PyInstaller bundle, removed the licence gate in the Python, repacked the single-file executable and re-ran the entry stub so the loader still finds its archive.
This one is a rebuild, not a byte flip, and the size moves because of it. The record says so instead of implying a two-byte patch.
Five separate checks stand between the licence response and a working window: response HMAC, expiry parse, a 120-second freshness window, the success byte in the JSON, and a signature over the features block.
Flipping one of them is not a bypass and would have looked like one under a bad test. All five had to be accounted for, and the expiry/freshness pair means a stale captured response does not work either.
The shipped build is a rebuild with the gates removed, not a minimal byte patch. Stated plainly because a buyer will ask.
Licence enforcement was entirely in the renderer JavaScript, and the "licence server" was a public JSON bin whose master credential shipped inside the app. Any key unlocked it.
Patch is one gate (unlockApp) plus recomputing the per-file integrity hash in the ASAR manifest. Skip the integrity step and Electron refuses to load the archive, which is the part most patches get wrong.
A 151 MB single-file .NET host. The licence check was neutralised in the assembly and the host rebuilt around it rather than byte-flipped in place.
Largest target in the set, and the reason the deliverable is a rebuilt host: hand-patching a bundle that size is where corrupted deliverables come from.
Protected with ConfuserEx. Deobfuscated first, and the deobfuscated assembly was kept as its own artefact so the step is auditable instead of a black box.
Then the registration verdict in the registration class was forced. Both assemblies shipped: the deobfuscated one and the patched one.
Four libraries, four different jobs. RegisterAndLog is a 22-byte verdict flip and the cleanest artefact in the whole set.
CommonRegister and TS.Common were rewritten around the same shared helper. SecurityLaunchCLR was replaced outright with a 3,584-byte stub against a 319,576-byte original.
Repacked APK with the licence check stubbed. The manifest was preserved rather than regenerated, then resigned with a debug key under schemes v1+v2+v3 so it installs without a warning cascade.
Signature is verifiable and the certificate hash is recorded, so anyone can confirm the build is the one described here.
Not a Java app, which is where a lazy assessment stops. The licence logic is in a 25 MB stripped ARM64 shared library and entitlement is server-authoritative: the client authenticates, receives entitlement data, and the protected library unlocks operations from it.
That means no single client branch unlocks it. The client-side login gate was patched for the proof of concept and the report states the server-side truth as the actual fix. This is the case that makes the point better than any marketing line.
Two binaries that matter: a native engine under VMProtect (.vmp0/.vmp1) and a C++/CLI managed wrapper around it.
Attacking the virtualised engine is the hard road and it is unnecessary. The wrapper carries the verdict, so that is where the patch went, plus a stub replacement for SecurityLaunchCLR. Four libraries and a patched installer shipped.