How to check that your obfuscation actually worked

A file that downloads successfully tells you nothing about whether it is protected. Open it in ILSpy and look: what renaming, string encryption, control-flow, reference proxying and virtualization should each look like in a decompiler, plus a two-minute check to run on every release.

An obfuscated file that downloads successfully tells you nothing about whether it is protected. The only real check is to do what an attacker would: open it in a decompiler and look. It takes ten minutes, it is free, and it is the difference between knowing what you shipped and assuming. Here is what to look for, layer by layer.

Set up: one tool, two files

Install ILSpy — free, and the tool a curious reader is most likely to use. Open both assemblies side by side: your original Release build and the obfuscated copy. Comparing them is what makes the differences obvious. Then confirm you are looking at the file that ships: on modern .NET the code is in YourApp.dll, not the launcher YourApp.exe.

Renaming: can you still find anything by name?

Expand the assembly tree. In the original you see your namespaces and class names. In the obfuscated copy, private and internal types and members should have short, meaningless names, and — for an application — the namespaces should be gone.

  • Try the attacker's first move: use ILSpy's search for words like License, Trial, Password or your product's feature names. In a well-renamed build those searches find nothing among your own types.
  • Expect some names to survive, on purpose. A library's public API, virtual members, enums, serializable types and anything you excluded keep their names. If far more survived than you expected, check whether you uploaded a library — its public surface is preserved by design (why).
  • Framework names always remain. File.ReadAllText and HttpClient are not yours to rename.

String encryption: search for a string you know is there

Pick a literal you know is in the code — an error message, a URL, a registry path — and search for it. Without string encryption it is found immediately, and it leads straight to the method that uses it, renamed or not. With string encryption on, the search finds nothing; where the literal used to be, the decompiled code shows a call to a decoder instead.

This is the single most revealing check. Many people discover here that their build only had renaming applied — which is what the free tier does, and what a Pro upload does if the layer boxes were left unticked.

Control flow: read one method you know well

Open a method whose logic you remember and compare. The original decompiles to clean if/else and loops. With control-flow obfuscation, the same method becomes a tangle of jumps and goto-style blocks that does the same thing but is slow to follow. One caveat that is normal, not a failure: methods containing try/catch blocks are left in their original shape.

Reference proxying: look at the call sites

In the original, a method body shows calls like File.Delete(path) in plain view. With reference proxying, calls to external static methods go through small generated stubs, so the call site shows a meaningless name instead of the API being called.

Virtualization: the method body should be gone

Open a method you marked with [Virtualize]. Its original logic should not be there at all — in its place is a short stub that hands off to an embedded interpreter. If you can still read the method's logic, it was not virtualized: check that the attribute is on the method and that the virtualization option was on for that upload. How virtualization works explains what you are looking at.

Then run it

Looking protected and working are separate questions. After the decompiler check, run the obfuscated build and exercise the paths that use reflection, serialization or data binding — how to test your obfuscated build is the short routine for that.

What "worked" means. Passing every check above does not mean the code cannot be reverse-engineered — a patient, skilled person with a debugger still can. It means the cheap attacks no longer work: searching for a name, searching for a string, reading a method top to bottom. That is the realistic goal, and this is what it does and does not buy you.

A two-minute version for every release

  1. Open the shipped assembly in ILSpy.
  2. Search for one class name you know. It should not be found.
  3. Search for one string literal you know. With string encryption, it should not be found.
  4. Open your most sensitive method. You should not be able to read it comfortably.

If any of those fail, the release went out less protected than you think — most often because a build step shipped the unprotected file. That is exactly the mistake worth catching before your users, and anyone else, have the binary.

Try it on your own assembly

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