What whole-assembly anti-tamper is (and what we do instead)

Commercial protectors headline whole-assembly anti-tamper; we offer a narrower integrity check on purpose. Here is how a self-checksum works, its real limits — patchable checks, signing collisions, antivirus heat — and why we aim tamper detection at the virtualized methods that matter.

"Anti-tamper" is on every commercial protector's feature list, and we offer a deliberately narrower version of it. That is worth explaining precisely, because the words promise more than the technique usually delivers. Here is what whole-assembly anti-tamper actually does, its real limits, and why we aim a focused integrity check at the methods that matter instead.

What anti-tamper is trying to stop

Obfuscation makes your code hard to read. Anti-tamper addresses a different attack: hard to change. An attacker does not always need to understand your licence check — often they just patch the compiled output, flipping a single comparison so the check always returns "valid," or deleting a restriction. Anti-tamper is the attempt to detect that the shipped binary has been modified and to react — typically by crashing, exiting, or refusing to run the altered code.

How whole-assembly anti-tamper works

The classic approach embeds a checksum or hash over the assembly's own code and verifies it at runtime: the program computes the hash of its loaded code and compares it to the known-good value baked in at protection time. If the two differ, the binary has been patched, and the protection fires. Heavier variants encrypt method bodies and decrypt them only after the check passes, so a tampered binary cannot even produce working code. The selling point is breadth — it is meant to cover the whole assembly, not just a few methods.

The limits the feature list doesn't mention

Whole-assembly anti-tamper is real, but it carries the same honest caveats as any client-side defence:

  • The check runs on the attacker's machine. The verification code ships inside your binary, so a skilled attacker can locate it and patch it out — the same cat-and-mouse as anti-debugging. It raises the cost of a casual patch; it does not make the binary un-patchable.
  • It collides with legitimate changes — signing in particular. Any process that rewrites the file after protection, including applying an Authenticode signature, changes the bytes a naive whole-file checksum covers. That is one reason the order of operations matters so much; see obfuscation and code signing: do them in the right order.
  • False positives and antivirus heat. A program that checksums and defends its own code behaves a little like malware, which can push a scanner toward a false positive on your installer — the same risk packing and anti-debugging carry.
  • "Whole-assembly" is only as strong as its weakest link. If the stored good-hash or the comparison can be found, the breadth of coverage does not help — the attacker defeats the one check, not each method.

What we do instead: a focused integrity check

Rather than a broad self-checksum, we tie tamper detection to the layer that already carries the most value — method virtualization. When you virtualize your crown-jewel methods, you can turn on an integrity check that couples those methods with a self-check over their own bytecode. Patch the compiled output and the virtualized methods break rather than run the altered logic. It is narrower than whole-assembly anti-tamper on purpose:

  • It protects exactly the methods worth protecting — the licence check, the activation routine, the proprietary calculation you already chose to virtualize — not every method equally.
  • It avoids the broad-checksum downsides. Because it is scoped to virtualized bytecode rather than a hash of the whole file, it is far less prone to the signing-order and false-positive collisions a naive whole-assembly checksum invites.
  • It is honest about its scope. It is not whole-assembly anti-tamper and does not pretend to be — code outside the virtualized methods is not covered. The full scope is laid out in what the integrity check does (and what it doesn't).

If you need stronger tamper protection

Some products genuinely need whole-assembly anti-tamper, native packing, or anti-debugging layered together — typically high-value targets facing motivated attackers. Two honest pointers:

  • Move the decision off the client where you can. The most durable answer to "they patched my licence check" is to validate server-side, where the attacker cannot reach the logic at all. No client-side tamper check changes the outcome the way that does — see what obfuscation actually protects against.
  • Pair tamper detection with code signing for the honest user. A signature does not stop a determined attacker, but it lets the operating system and your users detect a modified binary — a complementary, standards-based tamper signal.
  • If you need deep, whole-assembly anti-tamper on the client, use a suite built for it. Several commercial protectors specialise in it; the comparison pages put them next to us honestly, including where they do more. Weigh that depth against the false-positive and deployability costs above.

Not sure whether your project needs tamper protection at all? The layer decision guide matches each layer to the threat it answers, so you add it only if your threat model earns it.

Try it on your own assembly

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