Metadata Optimizations

Metadata optimizations in Babel Obfuscator involve a series of techniques to enhance the obfuscated code's metadata, which contains information about types, members, attributes, and other crucial aspects of the codebase. These optimizations focus on improving the code's security, reducing its size, and making it more resistant to reverse engineering attempts.

Automatic Class Sealing

Automatic Class Sealing is an optimization technique offered by Babel Obfuscator that aims to improve the performance of code execution by sealing classes that are not used as base classes in an inheritance chain. When a class is sealed, the Just-In-Time (JIT) compiler can generate more efficient code by calling virtual methods non-virtually, eliminating the overhead associated with virtual method resolution.

Command Line

Enabling automatic class sealing can be done through the command line using the --seal switch, which applies optimization to all non-public types within the target assembly. For example, the following command seals the classes in the "myapp.exe" assembly:

babel myapp.exe --seal

However, if there is a need to selectively exclude certain types from automatic class sealing, an XML rule can be defined. By specifying a regular expression pattern, it is possible to exclude specific types from being sealed. In the example XML rule provided, classes within the "Utilities" namespace will not be automatically sealed:

<Rule name="seal classes" feature="optimizations" exclude="false">
  <Pattern>Utilities.*</Pattern>
  <Properties>
    <ClassSealing>false</ClassSealing>
  </Properties>
</Rule>

It's important to note that the "exclude" attribute is set to "false" in this example to prevent disabling all optimizations. By using automatic class sealing selectively, developers can fine-tune the optimization process to suit their specific requirements and strike a balance between performance improvements and preserving certain class behaviours.

MsBuild Babel Task

To enable the automatic sealing of classes using the MSBuild Babel Task, you can set the <SealClasses> property within a <PropertyGroup> element:

<PropertyGroup>
  <SealClasses>true</SealClasses>
</PropertyGroup>

<Babel SealClasses="$(SealClasses)" />

In this example, the <SealClasses> property is set to true, indicating that the automatic sealing of classes should be enabled during the obfuscation process.

Unwanted Attributes Removal

The attribute removal optimization in Babel Obfuscator focuses on removing unnecessary attributes from the compiler-generated code. Often, the code generated by the compiler includes attributes that do not affect the application's behaviour during execution. Babel can identify and remove such attributes applied to defined symbols, resulting in a more concise and efficient obfuscated codebase.

For example, attributes like CompilerGeneratedAttribute or DebuggerDisplayAttribute, which are not essential to the application itself, can be safely removed. By eliminating these unwanted attributes, Babel reduces the size of the obfuscated target and eliminates any distinction between compiler-generated code and user code.

Command Line

To enable the "Unwanted Attributes Removal" optimization, the --cleanattrs switch can be used at the command line when running Babel.

babel myapp.exe --cleanattrs

The list of attributes that will be removed can be found in the babel.exe.config file. To view the configured attributes for removal, the following command can be used:

babel --help cleanattrs

The output will display the unwanted attributes along with their full type names.

Babel also allows for specifying a regular expression to match unwanted attribute type full names. For example:

babel myapp.exe --cleanattrs System.Diagnostics.*Attribute

This command will remove all custom attribute types defined in the System.Diagnostics namespace.

The configuration section of babel.exe.config includes a predefined list of unwanted attributes stored under the "UnwantedAttributes" element. Each item in the collection represents a qualified attribute type name.

MsBuild Babel Task

To enable the removal of unwanted attributes using the MSBuild Babel Task, you can set the <CleanAttributes> property within a <PropertyGroup> element:

<PropertyGroup>
  <CleanAttributes>System.Diagnostics.*Attribute;true</CleanAttributes>
</PropertyGroup>

<Babel CleanAttributes="$(CleanAttributes)" />

In this example, the <CleanAttributes> property specifies the list of regular expressions matching the unwanted attribute's full type name to be removed. The true at the end is the global switch for this feature.

XML Rules

An XML rule property called "UnwantedAttributes" is available to finely configure attribute removal for all members matching a given regular expression. By defining rules, developers have the flexibility to exclude specific subsets of code from the removal of unwanted attributes.

Here's an example XML rule for excluding the "Utilities" namespace from attribute removal:

<Rule name="unwanted attributes" feature="optimizations" exclude="false">
  <Pattern>Utilities.*</Pattern>
  <Properties>
    <UnwantedAttributes>false</UnwantedAttributes>
  </Properties>
</Rule>

By utilizing the "Removing of Unwanted Attributes" optimization, Babel Obfuscator helps optimize the obfuscated code by eliminating unnecessary attributes, reducing code size, and ensuring that only relevant and essential information remains within the obfuscated assembly.

System Enum Types Removal

Enum Types Removal is an optimization capability offered by Babel Obfuscator that focuses on removing System.Enum types defined within the target assembly. This optimization technique replaces the fields of these enumeration types with their corresponding values, resulting in a more compact codebase and making the disassembled code harder to comprehend, as constant values are used instead of field names.

Command Line

Enabling the removal of enumeration types can be done by using the --enumremoval option at the command line when running Babel. For example:

babel myapp.exe --enumremoval

This command activates the optimization to remove System.Enum types from the obfuscated assembly.

MSBuild Babel Task

To enable Enum Types Removal using the MSBuild Babel Task, you can set the <EnumRemoval> property to true within a <PropertyGroup> element:

<PropertyGroup>
  <EnumRemoval>true</EnumRemoval>
</PropertyGroup>

<Babel EnumRemoval="$(EnumRemoval)" />

XML Rules

Babel provides the EnumRemoval rule property in XML Rules, which allows developers to selectively include or exclude specific enumeration types. This can be achieved by defining XML rules that specify the desired behaviour for certain patterns or namespaces. Here is an example XML rule that excludes the "Utilities" namespace from the removal of enumeration types:

<Rule name="enum removal" feature="optimizations" exclude="false">
  <Pattern>Utilities.*</Pattern>
  <Properties>
    <EnumRemoval>false</EnumRemoval>
  </Properties>
</Rule>

By using this rule, the enumeration types within the "Utilities" namespace will not be removed during the optimization process.

The System Enum Types Removal optimization offers several benefits. Firstly, it helps save disk space by reducing the size of the obfuscated assembly. Secondly, by replacing the enumeration fields with their corresponding values, it adds an additional layer of obfuscation and complexity to the disassembled code, making it more challenging for potential adversaries to understand the underlying logic and behaviour.

By leveraging the System Enum Types Removal optimization in Babel Obfuscator, developers can enhance the security and protect the integrity of their codebase while also optimizing the size and readability of the obfuscated assembly.

Disgregate Removal

Disgregate Removal is an optimization feature offered by Babel Obfuscator that focuses on removing properties and events information from the respective metadata tables. This optimization technique involves converting the get_ and set_ methods of properties, as well as the add_ and remove_ methods of events, into standard methods. By removing this metadata and converting the methods, the size of the metadata is reduced, and when combined with renaming, it enhances obfuscation, making it more challenging to reconstruct the original property or event.

Command Line

To enable the removal of properties and event metadata, the --disgregateremoval option can be used at the command line when running Babel. For example:

babel.exe myapp.exe --disgregateremoval

This command activates the optimization to remove properties and events metadata from the obfuscated assembly.

MSBuild Babel Task

To enable Disgregate Removal using the MSBuild Babel Task, you can set the <DisgregateRemoval> property to true within a <PropertyGroup> element:

<PropertyGroup>
  <DisgregateRemoval>true</DisgregateRemoval>
</PropertyGroup>

<Babel DisgregateRemoval="$(DisgregateRemoval)" />

XML Rules

Additionally, Babel allows for selective enabling or disabling of properties and events disgregation through XML rules. By defining XML rules, developers can specify the desired behavior for specific patterns or namespaces. Here is an example XML rule that disables disgregate removal for the "Utilities" namespace:

<Rule name="disgregate removal" feature="optimizations" exclude="false">
  <Pattern>Utilities.*</Pattern>
  <Properties>
    <DisgregateRemoval>false</DisgregateRemoval>
  </Properties>
</Rule>

With this rule, the properties and events within the "Utilities" namespace will not undergo the disgregate removal optimization during the obfuscation process.

Disgregate Removal optimization provides several benefits. Firstly, it reduces the size of the metadata tables, resulting in a more compact, obfuscated assembly. Secondly, when combined with renaming, it improves the overall obfuscation of the codebase, making it more difficult for attackers to understand and reconstruct the original properties and events.

By utilizing the Disgregate Removal optimization in Babel Obfuscator, developers can enhance the security and protection of their code, optimize the size of the obfuscated assembly, and add an additional layer of complexity to the code structure, thereby increasing the difficulty of reverse engineering.