Allatori Java Obfuscator

ALLATORI JAVA OBFUSCATOR

Allatori is a second generation Java obfuscator, which offers a full spectrum of protection for your intellectual property. 

Although most second generation obfuscators allow for a worthy level of protection, we have developed a number of additional functions into Allatori to make reverse engineering the code nigh on impossible. 

Allatori does not just obfuscate, it also minimizes application size, and boosts the speed, and all the while your code is unreadable by anyone but you and your team. Allatori, as every modern Java obfuscator, has full watermark functionality, allowing potential for proper licensing of your software! 

If it is necessary for you to protect your software, and if you want to reduce both its size and processing time, Allatori obfuscator is for you.

FEATURE

Obfuscation is an essential part of the build process nowadays. Understanding its importance, we have approached the problem with special attention and carefulness. And the Allatori team have achieved tremendous results - we have managed to provide the most comprehensive set of features on the market for the highest possible protection of your intellectual property. 

Allatori Obfuscator has all the features you may need for protecting your Java software, and is continually enhanced and improved to meet the challenge of functioning as a cutting edge Java obfuscator system. We have combined all classic obfuscation techniques as well as innovations that can be found only in Allatori. 
 

Name Obfuscation

Name obfuscation includes the obfuscation of class names, method names and parameters. The quality of the name obfuscation is dependant on the algorithms it uses; the more deliberate and complex these algorithms the better.

That's why we have devoted a lot of time to crafting our name obfuscation algorithm, and as a result Allatori is able to understand and work with any project of any complexity. Your software's architecture doesn't really matter to Allatori - unlike other obfuscators. It is able to distinguish and convert any dependencies and schemes of inheritance into incomprehensible, impenetrable code.

Allatori's name obfuscation seems to be one of the product's peculiarities; Allatori gives one name to as many elements as possible. As a result, there is a certain probability that one name will be used for naming the class, the class methods (e.g. methods, which differ only by argument types) and class variables. This means that the code is simply impossible to fathom, by machine and human alike.

As well as securing and protecting your code, name obfuscation also provides another handy benefit: minification, making it as small as possible. This is of great importance in applications where a smaller size is imperative - take applets for example.

Flow Obfuscation

With the help of name obfuscation it is possible to obtain a certain level of protection which will probably stop an unskilled or lazy intruder, but an experienced hacker will only lose a negligible amount time converting a reverse engineered code into a readable one. That's why serious obfuscators implement at least some form of control flow obfuscation.

Allatori changes the standard Java constructions (loops, conditional and branching instructions) and, what's more, in cases where it's possible, the series of commands are altered so that after decompilation (if they make it that far) the Java equivalent is impossible to find.

The mixture of unique methods used in Allatori makes the code safe to the maximum, often causing the process of decompilation to fail.

Debug Info Obfuscation

Allatori can be easily configured to do the following: 

1. Leave debug information without modifications.
Helpful for internal testing of your application. In other cases it's better to choose other options. 

2. Remove debug information.
This option can be used when the size of your application matters; by removing debug information you can save a considerable amount of space. 

3. Substitute (obfuscate) debug information.
Debug information remains, but it's obfuscated, and so the use of it without transforming simply stupefies the hacker. In this case it is absolutely impossible to understand where the exception has taken place. But Allatori has a special utility which allows reconstruction of the original stack trace with the help of a substituted one. Substitution of debug information shrinks the application and doesn't affect productivity at all, so it is desirable to use this option in the majority of cases. 

String Encryption

Every application - even if it's as simple as possible - always has string data. This may be the text in shortcuts, buttons and other GUI components, error messages and exception information; any kind of textual information which is used by your application. This sort of information can help the hacker more than any code can. A simple search of the string in the code will show the exact place where it's used, which means it will localize the necessary piece of code and, as a consequence, make it much easier for the hacker to understand the algorithm of your program. So the string data encryption must be grasped not just as a subsidiary feature, but as an indispensable attribute of every high-quality obfuscator - just like Allatori.

After analyzing your class Allatori will find all the string data and encode it. In this state it will be kept in constant pool of your class. Allatori also adds a small piece of code that decodes the strings at runtime. As a result the hacker, having decompiled the class obfuscated by Allatori, will be presented with a seemingly random collection of symbols, rather than the string data.

100% Protection Against Popular Decompilers

You should study the foe's weapon to defeat him 
Bushido, Way of the Warrior

It is known from the theory of tactics that the best defence is offence. That's why our Allatori Team spends a lot of time studying and analyzing the work of modern decompilers. We not only study how they work, but we try to trace their susceptibilities, which will make the process of decompilation eventually fail. There's a special module integrated into Allatori that transforms the code in order to cause fatal errors in the decompiler upon attempt. So for the majority of hackers that use standard decompilers, your code turns out to be absolutely 100% safe, because correct decompilation becomes impossible.

Optimizing

Allatori optimizes the obfuscated code according to the General Systems Theory by Ludwig von Bertalanffy. Therefore, we have been able to use a complex system approach to analyzing and developing obfuscation and optimization. Which seems natural, because it's impossible to solve a problem having only one of its features in mind. It's absolutely necessary to look at the problem from all points of view, to study all of its aspects. For example, name obfuscation. It could have been simple to rename the methods into a haphazard series of symbols, but we've chosen another way. In the process of renaming we chose the names, which were as short as possible, and thus Allatori effectively reduces the size of your application.

So we can single out three main problems during optimization: performance, size reduction, and stability. Among the elements which have been optimized we'd like you to pay special attention to the optimization of the constant pool, class loading, fields and methods usage, loops and boolean expressions.

We're confident enough to claim that for the majority of applications, the methods and algorithms used in Allatori will definitely reduce size, and enhance performance.

Watermarking

Watermarks are special collections of data which are embedded into the class files using steganography techniques, used for the purpose of identification. This data can contain any kind of information, but usually it is used for identifying the owner of the application. For example, you can generate a separate build for every client and place the data concerning the client himself in it. And if someday you find your product on a warez site, you'll be able to reveal (with the help of Allatori's utility) which of your clients has helped the pirated copy of your application to be spread. It must be emphasized, that watermarks are admitted to be verification of copyright in the court. So, because Allatori has all the functionality to work with watermarks, you can feel secure, because watermarks are considered to be a great weapon against pirates and those who help them.

 

Incremental Obfuscation

Incremental obfuscation is used when you need to create a patch or add-on to your application. In such case you need the guarantee that new names of classes, methods and fields are consistent with the previously obfuscated version. 
Using the log file generated during the previous run of Allatori as input when obfuscating the next release, makes the two fully compatible. So a patch or add-on can be seamlessly integrated to the previously deployed application.

 

Stack Trace Utility

Allatori Stack Trace Utility restores original stack trace from an obfuscated one with the help of log file created during obfuscation process.

 

Build Tool Interface

Allatori Obfuscator was designed to suit any automated build environment. Its command line interface can be seamlessly integrated into build scripts. Moreover, we have made the integration with Apache Ant and Maven - the most widely used build tools - as easy as possible. 

 

J2ME Obfuscation

Allatori Obfuscator comes with the plugin for the Sun Java Wireless Toolkit for CLDC, thus making the obfuscation of your J2ME applications very easy. Moreover, Allatori automatically generates a configuration file for your WTK project. 

After setting up the plugin you will just need to select "Project | Package | Create Obfuscated Package" menu option in the KToolBar to get an obfuscated application.

 

Android Obfuscation

Allatori performs full-featured obfuscation of Android applications and can be easily integrated into the build process. We've created a typical configuration file for Android projects, making it very easy to obfuscate Android code. 

The resulting apk will be smaller and reverse engineering will be much harder. Now, your Android code can have the maximum level of protection.