Your code is important, however, there are parts that shine more than others. It might be a license check, an algorithm, or something that differs your product from alternatives in the market. The obfuscation techniques applied in your code, uglify, hide, encrypt and apply many layers of protection on your application. However, these techniques are still part of the .NET picture, we protect your code by obscuring it with further .NET Code.
Virtualization is a major step, we will maintain the obfuscation transformations with a twist. The obfuscated code won't be .NET, instead, it will be transformed into a pseudo-random bytecode that is only understood by our virtual machine.
This ensures that the new code can't be understood by attackers, including tools and humans. Decompilers won't be capable of disassembling the code because the protected code is no longer .NET and thus makes it impossible to be interpreted by them.
Virtualization is equivalent to an all-in-one feature. It achieves more than just hiding your code.
- References to methods and other classes are completely invisible.
- Debugging becomes extremely difficult.
- Protected data remains encrypted in the disk and memory.
- Calls to internal and external methods remain invisible to external observers.
- Tampering safety is ensured as the bytecode is safely encrypted and only understood by our virtual machine.
Due to the nature of this protection, there are worthy costs that need to be taken into account while applying it.
The first drawback is performance, by removing all traces of .NET Code, the protected region can't be optimized nor compiled into ASM. Instead, our interpreter will execute iteratively your code each time, leading to a noticeable performance hit.
Simultaneously, debugging becomes meaningless, you might attach a debugger to the program, however, the displayed code won't make any sense as it will represent our virtual machine interpreting your code and not your actual code.