Mbojo-Lab

Protect your software from crackers

This is just a tutorial how to protect your self against crackers/decompilers
It will protect your source code from being stolen, This means if your project is not open-source and people can decompile your project and they will upload the decompiled source-code it will become open-source even tho you did not even upload the source-code

Here is a list with obfuscators/ant-cracking software

If you don't know what obfuscators (Obfuscation) is just read this...
http://en.wikipedia.org/wiki/Obfuscated_code

2 more thing I need say, Let's say ur having a RAT and it's like 100% detected by all the anti-virus software once you obfuscated your program scan again your program and look it's not a virus anymore :hehe:

2: Themida is an anti-cracking program to protect ur program from being decompiling but it also makes it detectable at every anti-virus so its your choose to use it I recommend... :nono:

Ok so here is a list with all the obfuscator's and anti-crackers
I will also add the download links so you can download them here instead of searching at google


Ok here is a list with the obfuscators
{Smart Assembly}

Recommended Obfuscator: Yes
Download Link: Download Smart Assembly


Features:
Pruning

{smartassembly} automatically detects and removes the code that will never be executed at runtime.
It will also remove metadata such as events' and properties' names, methods parameters' names, design-time attributes, etc.
It reduces the size of your assemblies, improves loading time and performance, and Protects your code from spying eyes, by removing the non-useful metadata.

If you want to exclude a member from the pruning, you can use custom attributes directly in your code (Declarative Pruning).


Advanced Obfuscation

Obfuscation is a vital protection of your Intellectual Property, but it won't change the way your software works. {smartassembly} will change the name of your classes and methods to unreadable characters, to highly complicate the work needed to understand your code.

{smartassembly} will automatically detect non-obfuscatable code or metadata. You can also exclude a member from the obfuscation directly in your code (Declarative Obfuscation).

{smartassembly} additionally lets you choose between different Name Mangling Schemes.

Control Flow Obfuscation

Control Flow Obfuscation is an advanced option for protecting your Intellectual Property. It will change the code inside your methods into spaghetti code.

While the runtime will still be able to execute your application in exactly the same way, it will become very difficult for a cracker to analyze your code, and almost impossible for a decompiler to recreate the original source code.

References Dynamic Proxy

{smartassembly} can create a proxy for calls to external members. This high protection feature will hide most of the calls to external methods, properties or fields in your code by replacing them with calls to the proxy.

This proxy is created dynamically at run-time, which increases the protection of your code.
Additionally, the proxy is built in a way that prevents the assembly from being modified. This means that if a hacker tries to modify your assembly, even slightly, then the proxy will no longer work and the application will not be able to start.

Strings Encoding

A managed software stores all the strings in one place and in a clear form. By encoding all the strings in your software, {smartassembly} hides important information like passwords, SQL requests, serial numbers, login information, and thus improves protection.

{smartassembly} can compress and encrypt the encoded strings with advanced encryption.
It can also make your assembly cache the strings once decoded to improve performances in case strings are intensively used.

Other Protections

{smartassembly} can prevent your software from being opened by the most popular disassemblers and decompilers.

Resources Compression and Encryption

{smartassembly} can compress and encrypt your managed resources to reduce the assembly's size and improve protection.

At runtime, the first time a managed resource is needed, {smartassembly} will automatically decompress and decrypt your resources. This is a very quick operation which is done only once. After that, the performance is the same as with non-compressed resources.


Dependencies Compression and Embedding

{smartassembly} can compress and embed your dependencies in your main assembly. Embedding dependencies is a convenient solution to improve and facilitate your software deployment.

Embedding your dependencies in your main assembly will simplify the deployment and maintenance of your software, reduce the global size of your software, and ensure that dependencies are always available.

Memory Management

{smartassembly} can dramatically reduce the memory used by your software, by automatically releasing the memory no longer needed.

Debugging Capabilities

{smartassembly} can generate a .pdb file, which contains the debugging information, enabling you to debug your assembly into your IDE, and to get the full stack trace when an exception occurs.

{smartassembly} also offers Stack Trace Decoding to let you retrieve the original (non-obfuscated) stack trace, even if you don’t use the Exception Reporting feature.

Other Features

Quick process, thanks to our own direct IL read/write engine.
No need to make any change in your code, or to learn a 3rd party object model.
No need to have access to the source code.
Works with any language targeting the .NET framework.
Resulting Assembly is still a 100% .NET Assembly, and thus keeps all benefits of the .NET Framework.
{smartassembly} does not add any dependency to your .NET Assembly.

.Net Reactor
Recommended Obfuscator: Yes
Download Link: Download .Net Reactor



Features:
* Intellectual property protection
o NecroBit Protection
o Native Code generation
o Obfuscation
o Control Flow Obfuscation
o String Encryption
o Anti Tampering
o Resource Encryption and Compression
o Dependency Merging
o Protects full applications and libraries (dlls)
* Powerful licensing system
o Create trial versions of your software
+ Set an expiration date
+ Limit use to a fixed number of days after installation
+ Limit by number of uses
+ Limit to use for no more than a set number of minutes each invocation
+ Limit trial version functionality
o Easily turn your trial version into a fully licensed version
o License your software
+ Permanently (non expiring license)
+ By time period (i.e rent your software)
+ By number of uses (i.e software as a service)
* Software development kit
o Integrate license checking into you assembly and extend licensing fuctionality
o Extend licensing functions with bespoke extensions.


Whatever your .NET product, .NET Reactor protects it: Windows Forms Applications, Console Applications, .NET Libraries and Windows Services.

.NET Reactor offers full protection support for your ASP.NET Applications and Libraries.

.NET Reactor supports 32-bit and 64-bit Assemblies.

.NET Reactor supports all .NET Framework implementations, including Compact Framework, Silverlight and Mono:
NET Framework 1.1/2.0/3.0/3.5/4.0
.NET CF 1.1/2.0/3.5
Silverlight 2.0, 3.0
Mono 1.x, 2.x

.NET Reactor can merge or embed multiple .NET files into one executable(.exe) or library(.dll).
.NET Reactor is able to compress applications and embedded files up to 50-75%.
NecroBit is a powerful protection technology which stops decompilation. NecroBit replaces the CIL code within methods with encrypted code. This way it is not possible to decompile/reverse engineer your method source code.
No tool can disassemble/decompile .NET Reactor protected code. ILDASM(the Microsoft Intermediate Language disassembler) will actually report that it cannot interpret .NET Reactor protected assemblies.
.NET Reactor is able to generate a native x86 EXE file stub for your application. This way it is not possible to directly open your protected application in a decompiler. The decompiler recognizes your protected application as a native EXE file.


In combination with the Native EXE File feature and NecroBit, .NET Reactor is able to convert managed methods into REAL x86 native code. Only methods which doesn't affect the runtime and platform behavior (mostly small methods like property getters/setters...) are converted into native code. By nature this feature has an built-in protection against assembly modification.

In addition to source protection, .NET Reactor provides thorough class and member obfuscation complemented by different exclusion schemes, use of non-printable characters in obfuscated names, and even incremental obfuscation, which always generates the same obfuscation strings for type and member names.

Declarative Obfuscation support allows you to directly define which types and members should be excluded from obfuscation. This can be done by using the custom attribute System.Reflection.ObfuscationAttribute in your source code. .NET Reactor automatically detects the attribute and excludes the corresponding types and members from obfuscation.

Control Flow Obfuscation converts the code inside your methods into spaghetti code, which whilst retaining the function of the code makes it extremely difficult for human eyes and decompilers to follow the program logic. Decompilers are not able to decompile the spaghetti code back to your original source code.

String encryption makes it difficult for a hacker to understand your code and to attempt a code patch of your assembly, as he will be unable to identify the text of messages or other useful strings, making it much more difficult to identify where to patch your code. This feature has a built-in protection against assembly manipulation.

Strong Name Removal Protection prevents your protected assembly from being tampered by hacker tools as they are not able to correctly resign the assembly with a different stong name.

.NET Reactor can improve protection and assembly size by compressing and encrypting your managed resources. At runtime, when required the resources are automatically decompressed and decrypted.

Powerful and flexible, the .NET Reactor licensing features allow you to enforce your license conditions and protect your revenue stream by using hardware and software locks. The license manager can build trial or permanent licenses, in a matter of seconds. A fully documented software development kit (SDK), complete with examples, allows you to call the licensing system directly from your code, allowing you to create custom extensions to the licensing system.

.NET Reactor is a mature product which has attracted third party development of add-ons.
.NET Reactor supports all types of managed assemblies (C#, VB.NET, C++.NET, ASP.NET, Delphi.NET, J#...).
An intuitive, easy-to-operate GUI provides quick, comfortable operation.
All features support command line invocation, and event driven invocation by Visual Studio Build Events. .NET Reactor produces the finished product in the same way you do.

Salamander .Net Obfuscator
Recommended Obfuscator: No
Download Link: Download Salamander .Net Obfuscator


Features:
* change all possible member names to meaningless and duplicate ones. Most methods and fields would have the same name, 'A', after obfuscation.
* remove all unnecessary data, including debug info, parameter names and certain metadata, etc.
* cross assembly obfuscation.
* incremental obfuscation.
* easy name lookup based on the original/obfuscated images, no log file needed.
* operate directly on executable files, images with native or mixed codes are supported, e.g., it supports assemblies from managed C++ that contains native code.
* extremely easy to use, the obfuscator takes one or more .exe and .dll files, and transform them into new format either in place or save as different file names as you would specify. No extra steps are involved. No third party tools (e.g. ilasm) are needed.
* up to 20% image size reduction.
* assemblies protected by our obfuscator will NOT be able to get decompiled by our own decompiler.
* allows full customization of the obfuscation process, obfuscation is controlled by custom attribute programming or a flexible XML config file.
* graphical user interfaces is provided to work with the obfuscator.
* uses massive overloading of method and field names for even higher security.
* generates only verifiable MSIL bytecode in full compliance with the Microsoft .NET Specification.
* updates the manifest in assembly using obfuscated names and automatically generated resource names.
* code optimization and flow obfuscation will be available at a later date.

Themida
Recommended Obfuscator: Yes, But this is detectable for 100% at every anti-virus
Download Link: Download Themida


Features:
Anti-debugger techniques that detect/fool any kind of debugger
Anti-memory dumpers techniques for any Ring3 and Ring0 dumpers
Different encryption algorithms and keys in each protected application
Anti-API scanners techniques that avoids reconstruction of original import table
Automatic decompilation and scrambling techniques in target application
Virtual Machine emulation in specific blocks of code
Advanced Mutator engine
SDK communication with protection layer 
Anti-disassember techniques for any static and interactive disassemblers 
Multiple polymorphic layers with more than 50.000 permutations
Advanced API-Wrapping techniques
Anti-monitors techniques against file and registry monitors
Random garbage code insertion between real instructions
Specialized protection threads
Advanced Threads network communication
Anti-Memory patching and CRC techniques in target application
Metamorphic engine to scramble original instructions
Advanced Entry point protection 
Dynamic encryption in target application
Anti-tracing code insertion between real instructions
Advanced Anti-breakpoint manager
Real time protection in target application
Compression of target application, resources and protection code
Anti-“debugger hiders” techniques 
Full mutation in protection code to avoid pattern recognition
Real-time simulation in target application
Intelligent protection code insertion inside target application
Random internal data relocation
Possibility to customize dialogs in protected application
Support of command line
Many many more...

This post was written by: Franklin Manuel

Franklin Manuel is a professional blogger, web designer and front end web developer. Follow him on Twitter