Declarative Obfuscation Using Custom Attributes

This attribute can be applied to an assembly to tell obfuscator how to treat it. Setting the AssemblyIsPrivate property to false tells obfuscator to treat an assembly as a library. Setting the AssemblyIsPrivate property to true tells obfuscator to treat an assembly as an executable. The difference is how Eazfuscator.NET renames and seals public types and their public members. In case of an executable all public types and their public members are considered terminal so they gets renamed. In case of a library, those types and members may be used by other assemblies, thus they do not get renamed.

The default obfuscator behavior is to treat all .dll assemblies as libraries and all .exe and .com assemblies as executables. If the assembly has another file extension (nor .dll neither .exe/.com) then Eazfuscator.NET treats such assemblies depending on the entry point presence. If the assembly has the entry point then it is treated as an executable, otherwise it is treated as a library.

This attribute is the main troubleshooter of the reflection related problems that may occur during obfuscation. As it was mentioned above Eazfuscator.NET has no formal reflection scenarios analysis engine and it uses heuristic algorithms instead. Decisions produced by those algorithms may be wrong in some rare cases so you may need to override them by using System.Reflection.ObfuscationAttribute

System.Reflection.ObfuscationAttribute can be applied to a type. Possible feature property values are "all" (by default), "renaming" and "properties renaming". So if you want to disable renaming of your class you may write something like an example below (C#):

[System.Reflection.ObfuscationAttribute(Feature = "renaming", ApplyToMembers = false)]
class MyOneThousandAndFirstClass
{
    …
}

If you want to disable renaming of your class and all its members you may write:

[System.Reflection.ObfuscationAttribute(Feature = "renaming", ApplyToMembers = true)]
class MyOneThousandAndSecondClass
{
    …
}

If you want to disable renaming of the properties in your class you may write:

[System.Reflection.ObfuscationAttribute(Feature = "properties renaming")]
class MyOneThousandAndThirdClass
{
    …
}

Sometimes it may be useful to disable just single or several properties in a class. In order to do that you may write:

class MyOneThousandAndFourthClass
{
    [System.Reflection.ObfuscationAttribute(Feature = "renaming")]
    public string DisplayName
    {
        get;
        set;
    }
}

In some rare cases you may want to disable the renaming of properties for anonymous types. In order to do that, you should apply the following attribute at the assembly level:

using System.Reflection;

[assembly: Obfuscation(Feature = "anonymous type properties renaming", Exclude = true)]

Another appliance of System.Reflection.ObfuscationAttribute is to configure Eazfuscator.NET features. You may find more information about this at the following places:

There are no System.Reflection.ObfuscateAssemblyAttribute and System.Reflection.ObfuscationAttribute attributes available in .NET Compact Framework, Silverlight and WinRT runtimes. So if you want to use declarative obfuscation you must define corresponding attributes in your assembly. The easiest way to do this is to add ready-to-use file ObfuscationAttributes.cs (for C#) or ObfuscationAttributes.vb (for VB.NET) to your project. These files can be found at Start Menu → Eazfuscator.NET → Eazfuscator.NET Code Snippets menu item. Alternatively they can be found at C:\Program Files\Eazfuscator.NET\Code Snippets path.

	Note
	The path may differ depending on the installation options and operating system. For example, this path may look like C:\Program Files (x86)\Eazfuscator.NET\Code Snippets on 64-bit operating systems.

Sometimes it may not be possible to access the class definition directly to apply a custom attribute for obfuscation tuning. If latter is the case then indirect declarative obfuscation comes to the rescue. It allows to indirectly tune the obfuscation by using custom attributes defined at the assembly level.

Let's take a closer look on an example. Suppose there is a class MyNamespace.ResourceClass1 and its declaration can not be changed because it was automatically generated by a tool. So how to disable the renaming of that class during obfuscation? The solution is to use indirect declarative obfuscation. In order to do that, you should apply the following attribute at the assembly level (C#):

using System.Reflection;

[assembly: Obfuscation(Feature = "Apply to type MyNamespace.ResourceClass1: renaming", Exclude = true, ApplyToMembers = false)]

Please note, the feature string starts with "Apply to type" expression in the sample above. That expression signals Eazfuscator.NET that feature should be redirected to MyNamespace.ResourceClass1 class. There is a semicolon after the class name; just next to it, there is a real feature name "renaming". So, the above sample code is virtually equivalent to the code shown below (C#):

namespace MyNamespace
{
    [System.Reflection.ObfuscationAttribute(Feature = "renaming", Exclude = true, ApplyToMembers = false)]
    class ResourceClass1
    {
        …
    }
}

The class name in indirect expression can contain mask characters such as * and ?, so one indirect expression can match several classes. * stands for several any characters, ? stands for any character.

As for example, it's possible to disable all obfuscation features for all classes inside a given namespace. The following attribute should be applied at the assembly level in order to do that (C#):

using System.Reflection;

[assembly: Obfuscation(Feature = "Apply to type SomeExcludedNamespace.*: all", Exclude = true, ApplyToMembers = true)]

A more powerful configuration syntax is available in conditional obfuscation.