The Unity 3D Obfuscator product is designed to protect Unity3D applications against decompilation (decompilation implies viewing code in a high-level language or .NET intermediate language). It obfuscates .NET assemblies included in the Unity3D project.

Obfuscation means obscuring the code of a program, i.e. making its source or executable code hard to analyze, its algorithms hard to understand and the program hard to modify in case of decompilation, but preserving its functionality. The code may be obscured on the algorithm level, on the source code level, on the assembler text level.

Obfuscation aims:

• Protecting software against decompiling and illegal use, violating developers' copyright.
• Optimizing software in order to reduce the size of executable code and (if an interpreted language is used) increasing the performance.

Product features:

• Entity Renaming:
  • Renaming scripts, classes, methods, fields into a set of meaningless or unreadable characters;
  • Supporting obfuscation control attributes (System.Reflection.ObfuscationAttribute)
• Removing events and properties:
• This method comes down to removing the metadata of events and properties from the assembly, which makes it impossible to recover or use these properties from high-level languages  (C#, Boo, ...).
• Renaming methods, variables, etc. into a set of unreadable characters:
  • It comes down to replacing names with unreadable characters, for example, Japanese characters. Though .Net works with the UTF8 encoding, not all decompilers correctly process its characters. Some change names with such characters for more understandable, some replace unreadable characters with their codes, some just refuse to work with such characters.
• Obfuscating the control flow graph:
  • Obfuscating conditional branches:
    This method comes down to adding various false conditions to the algorithm body and scattering the checks of existing conditions, loops and unconditional branches over the function body. Such manipulations destroy the standard schemes of building loops and conditions used by compilers in high-level languages (C#, VB, ..), which does not allow the program code to be translated into a high-level language. At the same time, even the analysis of IL code becomes a rather difficult task taking into account obscured code and false branches.
• Protection against decompilers:
  Protection against decompilers considerably reduces the chances to recover the source code of an application in an assembly or high-level language (C#, VB, etc.). The following methods are used to provide protection against source code recovery:
• Obscuring the protected application by adding additional methods with semantics correct for the assembly language, but incorrect for the compilers of high-level languages and, therefore, causing errors in case of recovering the code in these languages.
• Obscuring the protected application by adding additional methods with semantics incorrect even for the assembly language and, therefore, causing errors in case of recovering the code in the assembly language.
• Complicating assembly methods by adding functions with incorrect code that are unavailable for calls and that cause hidden errors occurring during an attempt to compile the disassembled code.
• Binary assembly processing for protection against decompilation.
• Complicating assembly methods by adding code with semantics incorrect for the compilers of high-level languages (if the "Control flow graph" obfuscation mode is enabled).
• Converting the code of assembly methods into code with semantics incorrect for high-level languages (if the "Control flow graph" obfuscation mode is enabled).
• Strong name:
• Signing assemblies using .SNK or .PFX keys.
• Obfuscation of Standalone Assemblies
• Supporting:
  • .NET Mono;
  • .NET Framework v 1.1;
  • .NET Framework v 2.0;
  • .NET Framework v 3.0;
  • .NET Framework v 3.5;
    

Interface description:

Exclusion from renaming - from the source code

Sometimes you may need to exclude a name from the obfuscation process. For example, if an object in the code is called by this name with the help of .NET Reflection.

You can specify exclusions right in the source code
The following attribute is used for that: System.Reflection.Obfuscation.

[System.Reflection.Obfuscation( Exclude = true [, ApplyToMembers = true|false [, Feature = "Public"]])]

Example:

//
// Exclude the class 'Class1' with all its members from renaming process
//
[System.Reflection.Obfuscation(Exclude = true,
 ApplyToMembers = true)]
public class Class1
{
    public void Function1() { }
    protected void Function2() { }
    internal void Function3() { }
}




//
// Exclude the class 'Class1' with all its public members from renaming process
//
[System.Reflection.Obfuscation(Exclude = true, ApplyToMembers = true,
 Feature = "Public")]
public class Class1
{
    public void Function1() { }
    protected void Function2() { }
    internal void Function3() { }
}




//
// Exclude the method 'Function3' from renaming process
//
public class Class1
{
    public void Function1() { }

    [System.Reflection.Obfuscation(Exclude = true)]
    protected void Function2() { }

    internal void Function3() { }
}



//
// Exclude class 'Class1' and 'Function2' from renaming process
//
[System.Reflection.Obfuscation(Exclude = true)]
public class Class1
{
    public void Function1() { }

    [System.Reflection.Obfuscation(Exclude = true)]
    protected void Function2() { }

    internal void Function3() { }
}

License Page

New project wizard

The result of the protection package