Sure, you love your code. We all do! Chances are that you want to shelter your precious intellectual property. Eazfuscator.NET helps to protect .NET code and your valuable assets.

Why is it good?

Eazfuscator.NET is easy as 1-2-3:

It protects your code, without breaking it — even in most complex cases — we have taken care of it. You can consider Eazfuscator.NET as a good partner who helps you a lot, and still doesn't bother you with any of his problems. If you have some really special protection requirements, pay attention to our code virtualization feature.
It really is easy to use: once protect your Visual Studio project with the Eazfuscator.NET Assistant tool, then forget about it. Every time you build your project in Release configuration, the assembly gets obfuscated automatically — you can release your code to the wilderness.
Need some settings to be changed? Are you sure? Then, do what you love: edit your code. Eazfuscator.NET is fully configurable by using .NET obfuscation attributes — in contrast to using alien-looking and unstable configuration files and UI wizards. All you need to know is in our complete product documentation.

What does the obfuscation look like?

Protect your project once:

Build Release configuration of your project:

Enjoy your safety:

Now every time you build your project in Release configuration it gets obfuscated. Instantly. You don't even have to think about it anymore. Not only that. Your code gets faster.

Features

There are several ways to protect and obfuscate your .NET code against reverse-engineering.

Symbols renaming

When we develop a program, we often present the most valuable information in form of symbol names: names of functions, variables, classes. This information is precious to an intruder who wants to get an understanding of our software.

The simplest and the most effective approach to conceal this information is to make the names irrelevant to what happens inside the program. We will just make the names of all the symbols unreadable — when it is possible.

String encryption and compression

Other thing that discloses the information about how a program functions is strings. To hide this information, Eazfuscator.NET substitutes the strings in your code with calls of special encryption functions, which render your strings perfectly at runtime, leaving them unreadable to an intruder. Also, these functions make the size of your strings lesser by compressing them.

Your assemblies weigh less!

Code and data virtualization

There are situations when we want to protect a part of our program more than anything else. We think of a person who would inspect our code as of well-motivated and of one who would go for a desperate measures. In this case, the symbols and strings protection is just not enough.

Here we offer you a radical approach: to change the way your program is presented in memory and on disk. Our code virtualization technique translates your .NET byte code to a totally unrecognizable random-generated byte sequence, which still perfectly functions at runtime. In other words, each time you obfuscate your program, we generate a new custom virtual machine to work for you!

No one will be able to get through.

What Is Code Virtualization?

Many of us consider particular pieces of code especially important. May it be a license code check algorithm implementation, an innovative optimization method, or anything else equally important so we would want to protect it by any means possible.

As we know, the traditional obfuscation techniques basically do renaming of symbols and strings protection, thus leaving the actual algorithms — cycles, conditional branches and arithmetics almost naked to the eye of intruder. Here a radical approach may be useful: to remove all the .NET bytecode instructions from an assembly, and replace it with something completely different and unknown to an external observer, but functionally equivalent to the original algorithm during runtime — this is what the code virtualization actually is.

Eazfuscator.NET provides an implementation of custom virtual machine which works atop the .NET virtual machine, using a different virtual instruction set every time you obfuscate your application. This makes the code of a protected algorithm completely bullet-proof and hidden from others. All you need to hide your precious logic is to apply a special attribute to your methods or classes.

How to Use It?

To enable code virtualization you should apply a custom attribute to a method you want to virtualize. Like this:

Automatic code optimization

Many of us have dreamt of being able to know every performance-sensitive aspect of the platforms and programming languages we use. This way, we would always be careful to write only the fastest code. Still, not many of us are actually aware of all the performance-related details, which often change while the platform evolves.

With Eazfuscator.NET, you don't need to be a .NET performance expert to make the top-performing applications. We perform code optimization automatically for you by replacing code fragments which are proven to be slow with their faster equivalents — behind the scenes. In some cases, optimization may make your code faster by hundreds of times. Right now there is a big list of scenarios we take into account during the optimization. And this list will grow.

Eazfuscator.NET applies code optimizations to deliver the best performance to your applications. .NET compilers such as C#, VB.NET, F# and JIT already do a pretty decent job in this area. Eazfuscator.NET extends it even further with high-level optimizations.

High-level optimization is a relatively new optimization technology. Eazfuscator.NET was the first tool that delivered it to the wide .NET user base. The best way to briefly describe high-level optimization is to start thinking as developer thinks: we all know that there are some methods and code patterns which are faster than others.

What Eazfuscator.NET does is this: it finds the slow code and swaps it with a faster equivalent. Eazfuscator.NET uses a preciously brewed knowledge base of common and efficient code patterns that you can find in many .NET applications.

At first glance, high-level optimization is very similar to a well-known peephole optimization approach. The main difference is that the classical peephole optimization works only on a small window of target machine instructions, while high-level optimization works at the application-wide level and considers control and data flows as well as the sacred knowledge about specific frameworks such as LINQ, MEF and others.

Let’s take a look at example:

Example 1. The slow code

The code above uses Enum.HasFlag method in order to check whether PrepareDatabase flag is set. While being syntactically pleasant, the code has astonishingly bad performance due to two invisible boxing operations emitted by C# compiler.

Eazfuscator.NET comes to the rescue:

Example 2. The fast code. Produced by Eazfuscator.NET after optimizing the slow code

As you can see, Eazfuscator.NET emitted a functionally equivalent code. The result of optimization is 500x speed improvement of condition evaluation over original code.

Eazfuscator.NET carefully performs a bunch of other performance optimizations helping to deliver the best experience to your customers.

The optimization is on by default and works behind the scenes during obfuscation.

Resource encryption and compression

If your product is ambitious enough, it includes many valuable assets. Almost any popular application includes a designer-created icon set. If you are a game developer, the original game sounds would cost you a lot. When your assembly resources contain security information such as private keys, it becomes very sensitive.

To cover all these things protected, we transparently encrypt the resources for you when you ask it.

Code control flow obfuscation

The .NET languages compilers usually generate similar MSIL code fragments for the similar fragments of your high-level code. This fact allows the decompiler tools to reverse-engineer the high-level code (in C#, for example) from the .NET assemblies.

Eazfuscator.NET supports an advanced technique called control flow obfuscation, when the MSIL code gets replaced with functionally equivalent, but different instructions. Decompilers often crash on such code, so this may stop an intruder from trying to break into your assembly.

Assemblies merging and embedding

In some cases, we need to make one assembly from several ones. There are two methods of doing this: merging and embedding.

Eazfuscator.NET merges or embeds assemblies for you in easy way: you need to add one line of code to your project, where you specify which assembly to mix in. We are responsible for all this to be done correctly and quietly — during the obfuscation process.

XML documentation filter

XML documentation filter is an automatic sanitizer that works on XML documentation files produced by various .NET compilers such as C#, Visual Basic, F# etc.

If you are developing a class library, it is very probable that you use the auto-generated XML documentation files. The security problem concerning them is that they contain information describing your library implementation details: names and descriptions for private types, methods and fields.

We take care to automatically remove all the implementation-disclosing data from the XML documentation files.

Debugging support

After your assembly is obfuscated with Eazfuscator.NET, it doesn't become a brick of non-debuggable mess. You can always get a line number where an unhandled exception appeared, view a readable stack trace, and even attach the debugger to walk through your obfuscated code.

Supported platforms and technologies

.NET Standard versions 1.0 – 2.1
.NET Core versions 1.0 – 3.1
.NET Framework versions 2.0 – 4.8
XAML with intelligent renaming of symbols
Enterprise-grade technologies: ClickOnce, VSTO and many others
Universal Windows Platform (UWP)
Gaming technologies: Unity, MonoGame and XNA
Third-party platforms: Mono and Xamarin
Integration with Microsoft Visual Studio 2005 – 2019
Integration with JetBrains Rider 2019.1+
More…

XAML Renaming

What Is It?

All recent .NET technologies for User Interface (UI) are based on XAML. WPF, UWP and Silverlight applications use XAML to define elements, events, data binding and other aspects of UI.

XAML renaming is the process of simultaneous renaming of related symbols in code and XAML during obfuscation.

How It Works?

Eazfuscator.NET finds all connections between XAML and code:

Then, the related symbols get renamed. Synchronously and consistently in code and XAML:

As a result, XAML renaming delivers higher obfuscation coverage and ensures that all related items are accordingly and correctly processed in XAML and code.

The last but not least. The User Interface

Eazfuscator.NET provides an easy to use GUI interface as well as classical command line interface.

Testimonials

This is what folks say after experiencing Eazfuscator.NET's distortion field:

“Personally I think it's one of the easiest, cheapest, trustworthy app that I can count on, not only that but they regularly update it”

--MadApples via Stack Overflow

“This is Eazfuscator: yesterday I asked if I could use code virtualization with Unity3d builds, today he inboxed me a new version with it”

--sebify via Twitter

“I think your product is one of the best obfuscators around. Nice! The first time when I looked for an obfuscator I left your web page and did not try your product. How wrong I was.”

--Zsolt via Email

“Awesome. Congratulations and thanks for this more than useful tool! Keep up the epic work Oleksiy!”

--Thiago via Blogspot

Quick Navigation;