What is Obfuscation?

Rename obfuscation alters method and variable names to make the decompiled code harder for humans to understand without affecting program execution.
New names may follow simple schemes like “a,” “b,” “c,” numbers, or even unprintable or invisible characters. Names can be overloaded as long they have different scope. Name obfuscation is a basic transform that is is widely used across .NET (C#, etc.), Java, and Android obfuscators.

In a managed executable, all strings are clearly discoverable and readable. Even when methods and variables are renamed, strings can be used to locate critical code sections by looking for string references inside the binary. This includes messages (especially error messages) that are displayed to the user. To provide an effective barrier against this type of attack, string encryption hides strings in the executable and only restores their original value when needed. Decrypting strings at runtime typically incurs a slight runtime performance penalty.

Control flow obfuscation transforms logical structures (such as conditionals, loops, and branches) into complex patterns that produce valid executable logic but appear as chaotic "spaghetti code" when decompiled.
This makes the code difficult for attackers to interpret. However, these techniques may introduce a runtime performance penalty as they add complexity to the method's execution flow.

Converts common instructions created by the compiler to other, less obvious constructs.These are fully valid machine-language instructions, but they may not translate clearly to high-level languages like Java or C#.
For example, transient variable caching leverages the stack-based nature of Java and .NET runtimes, adding an extra layer of complexity to obscure the code.

Inserting code into the executable that does not affect the logic of the program, but breaks decompilers or makes reverse engineered code much more difficult to analyze.

Removing debug information, non-essential metadata and used code from applications make them smaller and reduce the information available to an attacker. This procedure may slightly improve the runtime performance.

This transform combines multiple input executables/libraries into one or more output binaries. Linking can be used to make your application smaller, especially when used with renaming and pruning, It can simplify deployment scenarios and it may reduce information available to hackers.

Obfuscates by adding conditional branches that always evaluate to known results—results that cannot easily be determined via static analysis. This is a way of introducing potentially incorrect code that will never actually be executed, but is confusing to attackers trying to understand decompiled output.

An obfuscator can embed self-protection measures into your code to ensure the integrity of your application. If tampering is detected, it can trigger actions such as shutting down the app, limiting functionality, causing random crashes to obscure the cause, or executing any other custom response.
Additionally, it can notify a monitoring service, providing details about the tampering attempt.

When a hacker is trying to pirate or counterfeit your app, steal your data, or alter the behavior of a critical piece of infrastructure software they will almost certainly begin with reverse engineering and stepping through your application with a debugger.
An obfuscator can layer in application self-protection by injecting code to detect if your production application is executing within a debugger. If a debugger is used, it can corrupt sensitive data (protecting it from theft), invoke random crashes (to disguise that the crash was the result of a debug check), or perform any other custom action. It might also send a message to a service to provide a warning signal.