Salamander .NET Linker, Native Compiler and Mini-Deployment Tool
Deploy .NET w/o Framework

download the Scribble sample application natvie code
download the Scribble sample application MSIL code

“Remotesoft tools provide great solutions for developers for protecting MSIL. Its new addition to the suite addresses real customer issues with application deployment.” -- John Montgomery, director for the Developer and Platform Evangelism Division at Microsoft Corp.

Salamander .NET Linker and mini-deployment tool allows you to link .NET assemblies together into a single file, and to deploy your application without installation of the whole Microsoft .NET Framework. The linker selectively links MSIL code putting together only the required classes and methods, and it is capable of linking into the Microsoft .NET framework class libraries. The mini-deployment tool then builds a minimum set of the Microsoft .NET runtime to ship with your application. This usually results in installation size of a few mega bytes, rather than tens of mega bytes, and the installation takes much less time without rebooting machines. The mini-deployed application can be launched directly from a CD, absolutely without copying files or adding registry entries. Starting from .NET 2.0, a native compilation feature will be introduced to compile all managed assemblies into x86 machine code, and thus improves performance and stops disassembling and decompilation. Not even a single MSIL instruction will be ever delivered to your customers.

Microsoft .NET Framework is by any standard a significant installation that one would easily notice; some users may not be willing to install it at all. On the other hand, there are still many PCs that may not be suitable for .NET framework installation. This tool helps you to reach more customers as it silently deploys a trimmed down version of the framework without any noticeable effects and conflicts. The framework itself appears as an integrated part of your own application. The deployed application runs from an isolated directory without conflicts with future installation of the full .NET framework.

Link On Demand

The linker starts with the entry methods (which you can configure), and recursively walks the call graph to link only the required bits of MSIL code. Unused code will not be linked into the final assembly. Therefore, your code becomes more efficient and file size becomes smaller.

Link into Framework APIs   sample code

The linker is so powerful that even the Microsoft .NET Framework assemblies, such as System.Windows.Forms.dll, can be linked into your own .NET assemblies. Since it links on demand, only the required portion will be linked. This is very useful for protecting your code, simple application deployment, and trouble shooting by debugging into the framework code itself.

Native Compliation

The native compiler converts all managed assemblies, including system assemblies, into x86 native code. No MSIL instruction will be shipped, no JIT compilation at run time. This provides the best ever protection against disassembling and decompilation, and it also improves performance and startup time.

Simple and Fast Deployment without full Microsoft .NET Framework Installation   sample code

The mini-deployment tool puts together the minimum set of CLR runtime files and dependent assemblies that can be simply copied to a single folder on a target machine, and your application runs as if the whole framework is installed. Since the installation is isolated into a single folder, there will be no conflicts with future .NET installation. When linking is used for the dependent assemblies, it will further reduce the file size.

Direct Launching from CD, absolutely Zero Installation 

The mini-deployed package contains all the files and registries so that it can be launched directly from a CD without any installation to the client machines. There is absolutely no need to copy files to system directories, or modify registry entries. Therefore, the client machine can be kept in tact; this is extremely useful for creating demo CDs for .NET applications. 

Code Protection    screenshot

There is one problem none of the current obfuscators address, that is, no matter how good the obfuscation is, there are system library calls and other external references scattered over in your code (see red in below). Since these calls are external references, obfuscators will have to leave them unchanged. However, these references help a lot to understand the decompiled code, because they are well documented and public APIs. The linker removes or reduces such public APIs by linking the framework APIs into your own code, and thus makes your code much more difficult to decompile after obfuscation. Below shows sample MSIL code before and after the linker is used.


before: (no obfuscators are able to rename the following code in red, since they are external public 
APIs)
  IL_0000:  ldarg.0
  IL_0001:  call       instance void [System.Windows.Forms]System.Windows.Forms.Form::.ctor()
  IL_0006:  ldarg.0
  IL_0007:  newobj     instance void  [System.Windows.Forms]System.Windows.Forms.TextBox::.ctor()
  IL_000c:  stfld      class [System.Windows.Forms]System.Windows.Forms.TextBox A.A::A
  IL_0011:  ldarg.0
  IL_0012:  ldfld      class [System.Windows.Forms]System.Windows.Forms.TextBox A.A::A
  IL_0017:  call       valuetype  [System.Drawing]System.Drawing.Color [System.Drawing]System.Drawing.Color::get_Cyan()
  IL_001c:  callvirt   instance void  [System.Windows.Forms]System.Windows.Forms.TextBoxBase::set_BackColor(valuetype [System.Drawing]System.Drawing.Color)
  IL_0021:  ldarg.0
after: (absolutely no clue Windows.Forms APIs are used, a high obstacle for a hacker to understand this junk) IL_0000: ldarg.0 IL_0001: call instance void a.A::.ctor() IL_0006: ldarg.0 IL_0007: newobj instance void D.c::.ctor() IL_000c: stfld class D.c A.A::A IL_0011: ldarg.0 IL_0012: ldfld class f.aA.A::A IL_0017: call valuetype a.B() IL_001c: callvirt instance void D.c(valuetype g.e) IL_0021: ldarg.0

Enable Powerful Debugging to Step through Framework APIs  screenshot

By linking into the .NET Framework class libraries, you now have a way to step through the system function calls under a debugger, local variables can be examined. This is very useful in understanding how internal functions are implemented to trouble shoot runtime problems.

Seamless Integration with Visual Studio .NET

An add-in is provided for seamless integration with Microsoft Visual Studio .NET. Linking and deployment can be performed within the same IDE, and can also be added into the automatic build process.

Advanced Graphical User Interfaces

An advanced GUI, Remotesoft .NET Explorer, is provided in addition to the command-line utility, the linker simply takes .exe and .dll files as input, and transforms them into the new format.

VC++ .NET Support  

The tool can be used on projects that contain mixed images (generated by VC++ .NET). assemblies with pure MSIL code (e.g., C# and VB.NET) can be linked into final EXE, and those with umanaged code (native DLLs and mixed images) will be left as separate files.

The tool has two independent capabilities, linking and minideployment. For mixed images produced by VC++.NET, the linking part does not work, but the minideployment works just fine. The tool will not be able to link native code into the EXE, assemblies containing unmanaged code will be shipped as seperate files. More info ...

We will consider adding support for linking VC++.NET assemblies depending on the demands. (voice your opinion here, http://www.remotesoft.com/salamander/feedback.html)


Copyright © 2008 Remotesoft Inc. All rights reserved.