Key Benefits

• Protects .NET code against decompilation and reverse engineering
• Converts .NET applications to native binaries that run without the .NET Framework
• Embeds SQL Server Express databases directly into the application binary
• Eliminates compatibility errors by linking all application components into a single EXE
• Optimizes application performance with metadata reduction and code pruning

New in Xenocode .NET Obfuscator 2010!

The latest version ofXenocode .NET Obfuscator includes dozens of exciting new features, usability improvements, and engine enhancements, including:

• Windows 7 compatibility:  Xenocode is the first product in its class to include full support for all editions of the new Windows 7 operating system.
• SQL Server Express embedding: Eliminate local database setup by embedding SQL Express databases directly into your binary with a single click.
• Multi-platform capabilities:  Platform merge allows virtual application behavior to be customized on a per-operating system basis while distributing a single executable.
• Integrated support for the latest .NET runtimes and Windows components: The 2010 edition of Xenocode .NET Obfuscator support for the latest components and technologies, including .NET Framework 3.5/3.0, .NET 3.5 Client Profile, Silverlight, WPF, and LINQ.

Deploy .NET Without the .NET Framework

Xenocode .NET Obfuscator includes many unique features which reduce the complexity of testing and deploying complex .NET applications:

• Native executable generation: Xenocode .NET Obfuscator allows for the creation of a native x86 executable allowing your application to run, with or without a .NET Framework installed. Required portions of a third-party .NET Framework payload are automatically selected and embedded into the executable, dramatically reducing the complexity of application testing, deployment, and support. Xenocode .NET Obfuscator automatically identifies and statically binds a minimal set of Framework dependencies, reducing overall deployment size and eliminating dynamic link costs.
  
• Assembly linking:Xenocode .NET Obfuscator’s single-assembly output mode allows multi-assembly projects to be combined into a single output assembly, allowing for "copy" deployment of multi-assembly .NET applications. Linking is fully integrated into the obfuscation and optimization pipeline – encryption settings are automatically propagated across linked assemblies and redundant inter-assembly data are merged, reducing output assembly sizes.
• Filesystem, registry, SQL, and service virtualization: Xenocode .NET Obfuscator allows filesystem data, registry entries, SQL Server Express, and other Windows services to be directly embedded within the executable.  Virtual machine resources are visible to the executing application without any modifications to the host device.  For instance, application data files and COM components can be made available to the application without requiring any separate setup or registration.  This also allows applications to emulate behavior of privileged applications under a non-privileged user account.
• Code watermarking: Watermarking allows per-instance customization information, such as user names and registration codes, to be embedded into the visible text (for example, text in an About dialog or splash screen) as well as internal binary structures within your assembly. Watermarking can assist in tracking distribution of your product on a per-executable basis and deterring software licensing violations.

Protect Against Decompilation

Xenocode .NET Obfuscator incorporates a range of powerful, industry-leading obfuscation techniques to inhibit decompilation and other forms of reverse engineering, including:

• Symbol renaming: Xenocode .NET Obfuscator renames symbolic metadata, such as class, variable, and method names, into meaningless characters. This completely destroys the single most valuable resource available to a decompiler or a hacker studying your compiled executable.  
• Control flow obfuscation: Xenocode .NET Obfuscator manipulates the program control flow within the IL itself, editing branch instructions generated by the compiler, inserting decoy branches, and re-ordering instruction sequences. This conceals the original structure of your control flow (for example, the layout of if, for, and while blocks) and confuses decompilers. Xenocode .NET Obfuscator's control flow obfuscation is so confusing to decompilers that they often simply crash or completely fail to produce a valid decompilation.  
• String encryption: A common technique used by hackers to identify critical pieces of code involves searching the executable for a known literal string, for example "Enter password", and then looking at the point in the code which references the string. Xenocode .NET Obfuscator prevents identification of critical code locations in this manner by scrambling literal strings and injecting appropriate descrambling code whenever a scrambled string literal is referenced. This closes another door for the hacker.  
• Disassembly suppression: Xenocode .NET Obfuscator applies counter-analysis technology to your assembly to prevent many decompilers and disassemblers (for instance, Microsoft's ILDASM) to be unable to process your binaries. This prevents hackers from using such tools to analyze and disassemble your code. Xenocode .NET Obfuscator offers multiple suppression modes, depending on the security/compatibility trade-off required by your application.
• Native code generation: While primarily intended as a deployment feature, use of native code generation provides an additional obstacle to decompilation by directly merging in Framework dependencies and converting managed executables into x86-based native executables.  
• Debug data stripping: Xenocode .NET Obfuscator strips all debugging metadata from your binary. This information, which may be inserted by your compiler to facilitate debugging, can also be exploited by hackers to assist in reverse engineering your code.

Optimize Code for Maximum Performance

In addition to protecting your code through obfuscation, Xenocode .NET Obfuscator also helps to optimize your executable by eliminating dynamic links, identifying performance bottlenecks, and removing unused code:

• Executable/DLL linking: Xenocode .NET Obfuscator allows multi-executable projects to be combined into a single output executable, eliminating costs associated with dynamic linking. Redundant inter-assembly data are merged, reducing overall output size. 
• Metadata reduction:  During the course of obfuscation, Xenocode .NET Obfuscator can reduce symbolic metadata to single characters, reducing space consumed by unnecessarily long (and hacker-visible) class and variable names. 
• Transparent compression: Xenocode .NET Obfuscator includes the ability to compress output executables, significantly reducing the file size of large applications. On-the-fly decompression code is embedded directly within the carrier executable, creating a completely transparent user experience.
  
• Dead code elimination: Given a set of entry points (points in your executable where execution can initiate, such as your Main routine), Xenocode .NET Obfuscator analyzes code dependencies and identifies methods which cannot be invoked. Once identified, implementations of these methods are removed from your executable. This is done in a manner which preserves the metadata associated with the dead methods.
  
• Dead and duplicate literal elimination: Xenocode .NET Obfuscator automatically removes unused literal strings from your executable. If used in conjunction with dead code elimination, this feature automatically identifies and removes literals which are only referenced by dead code. Additionally, Xenocode .NET Obfuscator identifies and merges duplicate string literals and transparently makes all IL modifications necessary to preserve the code’s original functionality.

Easy to Configure and Use

Xenocode .NET Obfuscator has been carefully designed to minimize learning time, complexity, and configuration errors, without sacrificing power or flexibility:

• Out-of-box experience: When an assembly is opened for processing, Xenocode .NET Obfuscator automatically configures itself to settings appropriate for the most typical user scenarios. In many cases, typical projects will not require any additional configuration – Xenocode processing is a one-click process.
  
• Visual Studio and MSI integration:  Xenocode .NET Obfuscator integrates directly with the Visual Studio 2008 IDE, allowing automated post-processing as well as configuration via inline code attributes.  Xenocode .NET Obfuscator can output binaries directly into MSI setup packages.
• Intelligent symbol renaming: Xenocode .NET Obfuscator analyzes symbol naming dependencies and automatically propagates renaming selections when necessary to be consistent with the rules of the .NET Framework. This simplifies configuration and prevents many potential errors. Xenocode .NET Obfuscator also automatically identifies and suppresses invalid selections, such as renaming of IJW thunks, eliminating a large class of configuration pitfalls.
  
• Intelligent entry point selection: When configuring dead code elimination, Xenocode .NET Obfuscator can intelligently identify likely code entry points and automatically add these to the entry point list. This reduces the chance of entry point omission errors and, in many cases, completely eliminates the need for any further user configuration at all.
  
• Presets for typical scenarios: Xenocode .NET Obfuscator comes with several built-in "preset" configurations appropriate for common usage scenarios. All necessary configuration for these scenarios can be applied with a single click.
• Attribute-directed configuration: Developers can drive Xenocode .NET Obfuscator configuration settings within the source code of the application using a simple set of .NET code attributes.
• Debugging support: An easy-to-use mapping file feature allows one-click deobfuscation of symbolic information during debugging or processing of user bug reports.

Learn More About Code Obfuscation

Why Obfuscate Your .NET Code?

Traditionally, software has been compiled and distributed as native code, sequences of instructions expressed in the language of a particular system’s underlying CPU. As a side effect of this low-level encoding, much of the information about a program’s original source form is lost. While it is feasible to infer the internal operation of a program by examining its compiled native code, doing so is a very time-consuming and technically difficult process and much of the information about the high-level design and structure of the original program source is irreversibly destroyed in the compilation process.

In contrast, code designed for the .NET Framework is compiled to an architecture-neutral language known as the common intermediate language, or IL. Furthermore, .NET code is self-describing; that is, .NET executables contain additional metadata which describes the types, methods, fields, and events on which the IL instructions operate. This higher-level encoding has many advantages over compiled native code, such as improved code reliability and robustness and enhanced interoperability between diverse languages, machines, and platforms. However, as a side effect of this encoding, much of the information about the original source form of the program is preserved. Specially designed programs, known as decompilers, can exploit this information and recover much of the original source code of a program from its compiled .NET executable.

In other words, if you release your .NET executable to the world as is, you are effectively releasing your source code along with it – intellectual property and trade secrets are exposed, hackers have a tour guide to assist them in exploiting security vulnerabilities and tampering with product features, and unsavory competitors may even rip-off chunks of your code for use in their own products.

Code obfuscation transforms your compiled .NET executable into a form which resists decompilation. While, as with native code, it is still theoretically feasible to infer the internal operation of an obfuscated executable, obfuscation makes this process much more time-consuming and difficult, and irreversibly destroys much of the high-level information about the original source form of your program. This transformation is done in a way which completely preserves the functionality of your application.

Reducing Losses from Unauthorized Distribution

Xenocode .NET Obfuscator allows you to insert digital watermarks into your application executable. Watermarking allows per-instance customization information, such as user names and registration codes, to be embedded into the visible text (for example, text in an About dialog or splash screen) as well as internal binary structures within your application. Watermarking can assist in tracking distribution of your product on a per-executable basis.

 

Pricing, licensing, and features are subject to change.