Protect your .NET code and IP with SmartAssembly
SmartAssembly is an obfuscator that helps protect your application against reverse-engineering or modification, by making it difficult for a third-party to access your source code.
If your entire business rests on the IP embodied in your software or you don't want your C# or VB.NET code exposed internationally, then obfuscating your code becomes a necessity, not a luxury.
With SmartAssembly, you get a comprehensive set of obfuscation features, including name mangling, control flow obfuscation, strings encoding, reference dynamic proxy, and declarative obfuscation.
“A great way to take your .NET application to the next level.”
“Knowing the frequency of problems (especially immediately after a release) is extremely helpful in prioritizing and triaging bugs that are reported internally.
Additionally, having the context of where those errors occurred, including debugging information, really gives you that leap forward to start troubleshooting and diagnosing the issue.”
“Not only will it make you as a developer happier and your life easier, but it will make the customer happier and less frustrated.”
“I've deployed Automated Error Reporting now for one release and I'm already seeing the benefits. I can fix bugs which might never have got my attention before. I really like it a lot!”
“It is the most effective obfuscation, optimization, and all-around compilation improvement tool we've come across to date.”
Changes the names of methods and fields to make it hard to understand their purpose.
Converts the code inside methods to 'spaghetti code' to make it difficult to see how the application works.
Creates a proxy for calls to methods outside of your assembly to make it hard to find external calls.
Encodes the strings used in your software to hide such information as passwords and SQL queries.
Compresses and encrypts managed resources to make them hard to understand, and to reduce the size of the assembly.
Removes non-useful metadata to make the code harder to reverse-engineer, reduce the size of the assembly, and improve loading time.
Takes all the DLLs and merges dependencies into the main assembly, so you don't have to load lots of DLL files, and so that they can also be obfuscated.
Compresses and embeds your dependencies into your main assembly, simplifying the deployment of your software and reducing the size of your program.
Moves methods in your code by changing the class they are in, making it harder to understand how methods and classes relate to each other.
Signs your assembly and helps to protect it against modification (the additional tamper protection is not available in the Standard edition).
Excludes a member from obfuscation using custom attributes directly in your code.
SmartAssembly decodes obfuscated stack traces and generates .pdb files containing debugging information. This enables you to debug your assembly into your IDE, and get the full stack trace when an exception occurs. SmartAssembly even helps to ensure that you're automatically releasing unneeded memory.
Obfuscation can be integrated into build processes using MS Build or command-line, and supports .NET 2.0 to 4.7, including .NET Core and .NET Standard, and XNA, with some exceptions.
Only one thing's worse than finding out your software has bugs: never finding out.
Most users won't bother to report bugs: it's tricky and technically challenging to remember and relate the details. It would be easier for everyone if you let your users just give you the whole story in one quick click, wouldn't it?
Automated Error Reporting is an exception handling mechanism that automatically and silently collects detailed information when errors occur. Although highly customizable, a typical error report consists of a full stack trace and details about the exception context (e.g. values of all the local variables).
There are two main circumstances where Automated Error Reporting is particularly useful:
Using the SDK, you can also package any data you want with the exception report, e.g. a log file or a screenshot taken at the time of the crash. You can even customize your exception handling dialog and ask the user for more information, or contact details so you can contact them when a fix is released.
And if you're using SmartAssembly's obfuscation functionality in your development, we've got you covered – SmartAssembly can decode obfuscated stack traces.
Send error reports with or without prompting the end-user.
Gives you full control over the dialog box displayed to end-users when an exception occurs.
Categorize reports to quickly see the most common errors your users experience.
View the exception reports for applications built by any developer or build system in your organization.
The version of Windows, the .NET version, and a list of loaded assemblies are sent with the stack trace.
Log files, screenshots, and any other type of file can be attached to error reports.
Impress your customers by telling them when the problem has been fixed.
Your error reports are encrypted while stored in the web service and are deleted from the server when you download them.
No complicated installation because Redgate hosts the web service that error reports are sent to.
Run the web service yourself for maximum flexibility.
Addition of Automated Error Reporting functionality can be integrated into build processes using MS Build or command-line, and supports .NET 1.1 to 4.0, and XNA, with some exceptions.
Compiling .NET code often results in multiple assembly files being created, including satellite DLLs, all of which are required for the program to run. While this is a non-issue during development, when it comes to deployment it often means an unwanted stage of users having to unzip files, or additional steps in the installer as DLLs are moved to specific places.
You can dramatically simplify your deployment process by using SmartAssembly to merge and embed the code from referenced DLLs into your main assembly
Dependency merging takes all the DLLs and merges dependencies into the main assembly so you don't have to load lots of DLL files. When a dependency is merged, it becomes a part of the main assembly and the code from a merged dependency can therefore be obfuscated and pruned as well as code from the main assembly.
Dependencies compression and embedding allows referenced DLLs to be embedded into the main assembly as resources, instead of being merged into the main assembly's contents. This feature also compresses these resources and dynamically uncompresses them at runtime.
You can control SmartAssembly's dependency merging and dependencies compression and embedding through the command line, so it is easily integrated into the build process, providing simple, reliable merging of dependencies on every build.
|Allows you to process assemblies for release to end-users
|Name mangling, control flow obfuscation, strings encoding, references dynamic proxy, pruning, re-signing strong named assemblies, declarative obfuscation, obfuscation of satellite DLLs, sign assemblies
|Method Parent Obfuscation
|Application size reduction and speed improvement
|Pruning, resource compression and encryption, dependencies compression and embedding, dependencies merging, declarative pruning
|Automated error reporting
|Jump to source code from the stack trace
|Store error reports in a local SQLite database
|Store error reports in SQL Server, allowing you to share the reports with colleagues
|Custom web service
|SDK to access your exception reports programmatically and to manually pass exceptions to SmartAssembly if you wish to
|Custom templates for customizing the error reporting dialog and capturing additional data with exception reports (e.g. a log file)
|Feature usage reporting
|Feature Usage Reporting
|Export reports to CSV
|Store feature usage reports in a local SQLite database
|Store feature usage reports in SQL Server, allowing you to share the reports with colleagues
|Custom web service
|Custom templates for customizing the dialog box that your end-users see when they are asked to consent to feature usage reporting
SmartAssembly can protect your Winforms and ASP.NET applications and more.
It can also be integrated into build processes using MS Build or the command-line.
SmartAssembly is licensed per machine, meaning per build server or per production machine (any machine you use to produce release builds) and is available in two editions (Standard and Pro).
SmartAssembly Personal edition is a free to use version of SmartAssembly which can only be used for testing builds and viewing error reports.
It cannot be used to create builds for distribution.
If you're using a free trial of SmartAssembly, it will revert to SmartAssembly Personal edition at the end of the trial period.