Renaming hides your names. It never touches the framework's. So even a fully
renamed assembly still shows every call it makes to HttpClient, the registry,
the file system or your crypto library — and those calls are often the fastest route to
the code that matters. Reference proxying is the layer that closes that gap.
Why renaming leaves the call graph readable
Every time your code calls a method it does not define — httpClient.PostAsync,
File.ReadAllText, RegistryKey.GetValue,
RSA.Create — the compiler records that call in the assembly's metadata as a
reference to the target by name. Those targets live in .NET or a third-party package, not
in your code, so renaming cannot rename them: the names have to stay for
the call to resolve at runtime.
The result is that a decompiler, looking at an assembly where all of your
identifiers are meaningless, can still read the external call graph perfectly. An
attacker does not need your method names; they search the decompiled output for
Process.Start, WebClient, Registry or a crypto
type and land directly on your network calls, your licensing check or your file access —
the handful of places worth their time.
What reference proxying changes
Instead of calling the external member directly, the obfuscator routes the call through a
generated proxy — a small stub method, or a dispatcher that resolves the
real target indirectly. At each call site, the direct reference to
HttpClient.PostAsync is replaced with a call into one of these stubs. The
framework method still runs; it is just no longer named at the point where you use it.
To a static decompiler, the giveaway is gone. Where the output used to read
foo.PostAsync(url, content), it now reads a call into an opaque proxy, and
the mapping from proxy to real target is not sitting there in plain sight. The "find every
caller of HttpClient" shortcut — the one that normally takes seconds —
stops working.
Why it compounds with the other layers
Proxying is most effective next to the layers that hide the rest of the picture. Consider a licence check that calls your activation server:
- String encryption hides the URL, so the endpoint is not a readable literal.
- Reference proxying hides the
HttpClientcall, so searching for the network call no longer finds the check. - Control-flow obfuscation hides the surrounding logic, so even once located it does not read cleanly.
Each layer removes one of the footholds a static analyst relies on. Together they turn a quick grep-and-read into real work.
Cost and compatibility
The indirection adds a small amount of code and one extra hop per proxied call, which is irrelevant for ordinary application code — see does obfuscation slow your app down? for where any of the layers actually costs you. Because the behaviour is preserved, correct code keeps working; the edge to watch is code that reflects over the call site itself, which is rare — keep an unobfuscated build and run your reflection checklist before shipping.
Reference proxying is a Pro layer, opt-in per run. The free tier covers renaming; turn this on when the calls your code makes — to the network, the system or your crypto — are themselves a signpost you would rather not hand an attacker. Not sure which layers your project needs? The layer decision guide matches each one to the threat it answers.