Free alternative of SmartAssembly with error reporting and dependency integration

Question

I tried Smart Assembly and very satisfied with it. It's error reporting capabilities are great. Dependency integration was also very cool feature. My question is there free alternatives available that works like Smart Assembly?

I tried Eazfuscator.NET and it was great obfuscator but lacks two of my favorites from Smart Assembly. Is there any free tools available for error reporting and dependency integration for .Net framework.

Answer 1

While reading the documents of Eazfuscator.NET i found that it includes two features called Assembly Merging and Assembly Embedding. For the sake of error reporting i created my own library. You can find this library at CodePlex CrashReporter.NET

Anyone can use assembly merging or embedding by following below instructions

Assemblies Merging

Introduction

Assemblies merging allows to merge several assemblies into one. This may be beneficial from the deployment and security points of view.

Assemblies merging technology uses ILMerge utility underneath. So in order to use assemblies merging please ensure that ILMerge is installed on your machine. Assemblies merging is also achievable by using ILMerge utility separately but at the most cases it's much more handier to use assemblies merging interface provided by Eazfuscator.NET.

Benefits from using assemblies merging from Eazfuscator.NET vs. direct ILMerge usage

Eazfuscator.NET integrates automatically into the project build process with the help from Eazfuscator.NET Assistant. In case of direct ILMerge usage, you have to write build event handlers for the project manually Eazfuscator.NET magically handles signing options of the project. In case of direct ILMerge usage, you have to supply it with signing key and options manually Eazfuscator.NET provides ILMerge with target platform information which is automatically detected from input assembly. In case of direct ILMerge usage, you have to supply this information manually Eazfuscator.NET feeds ILMerge with all required options, so you do not have to read ILMerge manual. It speeds up integration a lot

By default, assemblies merging is not used during obfuscation of the assembly.

Instructions

To enable assemblies merging you should apply specially formed attribute(s) to your assembly. In order to do that you can use the instructions below.

Instructions on enabling assemblies merging

Open obfuscatable project inside the IDE Add new source file to the project and call it ObfuscationSettings.cs (for C#) or ObfuscationSettings.vb (for Visual Basic .NET). You may prefer to use another name instead of ObfuscationSettings.cs or ObfuscationSettings.vb Fill ObfuscationSettings.cs with the following content (C#):

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "merge with XXXXXX.dll", Exclude = false)]

For Visual Basic .NET, fill ObfuscationSettings.vb with the following content:

Imports System
Imports System.Reflection

<Assembly: Obfuscation(Feature:="merge with XXXXXX.dll", Exclude:=False)> 

Note

Change XXXXXX.dll with the file name of the assembly you want to merge with.

Tip

If you want to merge with several assemblies then just add several attributes:

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "merge with Assembly1.dll", Exclude = false)]
[assembly: Obfuscation(Feature = "merge with AnotherAssembly2.dll", Exclude = false)]
…

Note Usage of assemblies merging may lead to some side effects which may make obfuscation fail. If such is the case then use the principle of the least common denominator – merge just those assemblies which do not cause obfuscation failure. Assemblies embedding can be used in conjunction or as an alternative to assemblies merging.

Custom Parameters for ILMerge

Sometimes you may need to pass custom parameters to ILMerge utility. For example, you may prefer to control class internalization yourself or use some tricky ILMerge feature. In order to do that you can use the instructions below.

Instructions on passing custom parameters to ILMerge

Open obfuscatable project inside the IDE Add new source file to the project and call it ObfuscationSettings.cs (for C#) or ObfuscationSettings.vb (for Visual Basic .NET). You may prefer to use another name instead of ObfuscationSettings.cs or ObfuscationSettings.vb Fill ObfuscationSettings.cs with the following content (C#):

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "ilmerge custom parameters: <parameters>", Exclude = false)]

For Visual Basic .NET, fill ObfuscationSettings.vb with the following content:

Imports System
Imports System.Reflection

<Assembly: Obfuscation(Feature:="ilmerge custom parameters: <parameters>", Exclude:=False)> 

Note

Change with the parameters you want to pass. Eazfuscator.NET passes /internalize /ndebug parameters by default when no attribute defined. If you do not want to pass any parameters to ILMerge then change with none string.

Assemblies Embedding Instructions

Assemblies Embedding

Introduction

Assemblies embedding allows to embed assembly's dependencies into assembly itself. This may be beneficial from the deployment and security points of view.

Assemblies embedding is similar to merging. The main difference is that the assemblies are not merged into single assembly when they are embedded. They just get encrypted and packed as the assembly resources. As a result, there is a single assembly at the output and it contains the packed dependencies at the same file.

What's the point for embedding when we have merging (or vice versa)? Assemblies merging delivers the best performance for the resulting assemblies. They can be NGENed, they work in all constrained environments (Windows Phone, Compact Framework etc.). File mappings and JIT'ted code can be cached by the operating system for such assemblies, bringing the blinding fast application startups. Assembly merging definitely rocks.

The only downside of merging is that it's not always possible to apply it without breaking the application. So this is the point where assemblies embedding comes to the rescue.

Embedded assemblies are easy goals to achieve and they work out of the box. Downsides? Well, they are present. Embedded assemblies can not be NGENed, they do not work in some constrained environments (Xbox, Windows Phone and Compact Framefork). The extraction of embedded assemblies during the application load is a performance penalty (penalty is pretty small, so it's unlikely you are able to notice it).

Assemblies embedding brings some benefits as well. The embedded assemblies are encrypted, so this is a securty hardening against the hackers. Embedded assemblies are compressed, bringing the size reduction of the resulting assembly. And of course assemblies embedding is the easiest way to achieve single-file deployment, making your application to consist of a single .exe (or .dll) file.

Instructions

To enable assemblies embedding you should apply specially formed attribute(s) to your assembly. In order to do that you can use the instructions below. Instructions on enabling assemblies embedding

Open obfuscatable project inside the IDE Add new source file to the project and call it ObfuscationSettings.cs (for C#) or ObfuscationSettings.vb (for Visual Basic .NET). You may prefer to use another name instead of ObfuscationSettings.cs or ObfuscationSettings.vb Fill ObfuscationSettings.cs with the following content (C#):

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "embed XXXXXX.dll", Exclude = false)]

For Visual Basic .NET, fill ObfuscationSettings.vb with the following content:

Imports System
Imports System.Reflection

<Assembly: Obfuscation(Feature:="embed XXXXXX.dll", Exclude:=False)> 

Note

Change XXXXXX.dll with the file name of the assembly you want to embed.

Important

It is recommended to obsuscate the embedded assemblies.
Tip

Eazfuscator.NET automatically finds the assembly path when only the file name is supplied. If you prefer to specify the exact file path to assembly then you can use script variables:

[assembly: Obfuscation(Feature = @"embed $(InputDir)\Lib\AssemblyToEmbed.dll", Exclude = false)]

Tip

If you want to embed several assemblies then just add several attributes:

[assembly: Obfuscation(Feature = "embed Assembly1.dll", Exclude = false)]
[assembly: Obfuscation(Feature = "embed AnotherAssembly2.dll", Exclude = false)]
…

Tuning

Embedded assemblies are compressed and encrypted by default. You may prefer to turn off the compression, encryption or them both. In order to do that, please read the notes below.

The full notation of a custom attribute for assembly embedding has the following form:

[assembly: Obfuscation(Feature = "embed [flags] XXXXXX.dll", Exclude = false)]

where [flags] is an optional enumeration of flags separated by spaces.

The list of available flags is presented in the table below.

Below is the list of flags for assembly embedding attribute

Flag Description no_compress Disables the compression no_encrypt Disables the encryption no_satellites Disables automatic embedding of satellite assemblies load_from_file Instructs Eazfuscator.NET to load the embedded assembly from file instead of memory during the obfuscated assembly run-time. This can be used to preserve a meaningful value of Location property from System.Reflection.Assembly type.

Let's take a look on examples.

Example 4.24. Embed assembly without compression and encryption

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "embed [no_compress no_encrypt] XXXXXX.dll", Exclude = false)]

Example 4.25. Embed assembly without encryption; compression is enabled

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "embed [no_encrypt] XXXXXX.dll", Exclude = false)]

Example 4.26. Embed assembly; compression and encryption are enabled

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "embed XXXXXX.dll", Exclude = false)]

Example 4.27. Embed own satellite assemblies; compression and encryption are enabled

using System;
using System.Reflection;

[assembly: Obfuscation(Feature = "embed satellites", Exclude = false)]

Troubleshooting While assembly embedding is the most non-intrusive way to link the assembly, some rare issues may occur. Possible issues are described in this chapter together with corresponding solutions to avoid them. Location property of System.Reflection.Assembly class Issue summary. Location property of System.Reflection.Assembly class is often used to find the paths of files near the assembly. While not being a correct solution, this works for most deployment scenarios.

What may go wrong? First of all, Location property can have a completely unexpected value when assembly shadow copying is used, thus breaking the intended application logic. Secondly, Location property has a null value when a corresponding assembly is embedded.

Solution. Use EscapedCodeBase property instead. This property always has a correct value in all deployment scenarios. Please take a look at the sample below.

using System;

class Program
{
    static string GetEulaPath()
    {
        var assembly = typeof(Program).Assembly;
        // string location = assembly.Location; // Please do not use this. This is a flawed approach
        string location = new Uri(assembly.EscapedCodeBase).LocalPath; // <-- Use this instead
        return Path.Combine(Path.GetDirectoryName(location), "EULA.rtf");
    }
}

Answer 2

For error reporting you may try NBug. For dependency integration, you may use ILMerge,

http://www.nbusy.com/projects/nbug

http://research.microsoft.com/en-us/people/mbarnett/ILMerge.aspx

BTW, if you really like SmartAssembly, consider buying it.