What the integrity check does (and what it doesn't)

The integrity check couples your virtualized methods with a self-check, so patching the compiled output breaks them instead of running altered logic. It is a focused tamper check on those methods — not whole-assembly anti-tamper. Here is the honest scope.

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.
A focused check, not a security suite. If you need broad anti-tamper across a whole assembly, or anti-debugging, dedicated protectors do more — the comparisons are explicit about which ones and where they lead. What the integrity check gives you is a sharp, low-effort way to make patching your virtualized methods fail loudly instead of succeeding quietly.

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.

Try it on your own assembly

Upload a DLL or EXE and download the obfuscated result. Free, no signup, nothing stored.