The integrity check is the smallest Pro option and the easiest to misread. It is a tamper-detection self-check over your virtualized methods — useful, but narrow. Being precise about what it covers matters more than making it sound like whole-program anti-tamper, which it is not.
What it does
When you virtualize a few methods, their logic becomes bytecode for a small interpreter embedded in your assembly. Turn the integrity check on as well, and those virtualized methods are coupled by a self-check over their own bytecode. If someone patches the compiled output — flips a comparison in a licence check, say — the check notices the bytecode no longer matches and the methods break rather than run the altered logic. A silent "change the branch and move on" attack turns into a visibly broken build.
Why it is tied to virtualization
The check operates on virtualized bytecode, so it only protects methods you have
virtualized, and it has no effect without virtualize turned on.
That is by design: it is aimed at exactly the handful of crown-jewel methods —
a licence check, an activation routine, a proprietary calculation — that you already chose
to virtualize because they are worth the most protection. You enable it with
integrityCheck=true alongside virtualize=true (see the
API), or the matching option in the browser.
What it is not
This is where honesty matters, because the words "tamper detection" invite bigger assumptions than the feature earns:
- It is not whole-assembly anti-tamper. It does not checksum your entire binary. Code outside the virtualized methods — everything renamed but not virtualized — is not covered by it.
- It is not anti-debugging. It does nothing to detect or resist a debugger attached at runtime; it reacts to the compiled bytecode being changed, not to being observed.
- It is not unbreakable. An attacker who reverses your embedded VM can reason about the check too. It raises the cost of casually patching your most-protected methods; it does not make them tamper-proof.
When to turn it on
If you are already virtualizing a method because tampering with it would be costly — a client-side licence or activation path is the classic case — turning the integrity check on is nearly free and makes a patched copy break rather than run. If you are not virtualizing anything, it does nothing for you; spend your effort on the layers that fit your threat instead. The layer decision guide places it in the wider picture, and remember that a client-side check is a deterrent, not an enforcement mechanism — the threat model is blunt about that line.
Using this to protect a licence or trial check? The licensing and trial enforcement use case is a realistic account of what client-side protection buys you there.