Rummage 2.0.640

Rummage 2.0.640 comes as a useful tool that lets you deter software pirates by making your .NET programs harder to decompile, reverse-engineer, hack or steal. Rummage obfuscates your .NET programs to prevent decompilation, re-use, stealing and hacking. Software pirates are losing you sales. Rummage’s obfuscations are sophisticated and irreversible — not merely designed to crash just some of the most popular decompilers.

Rummage is open and honest. Don't worry about sensitive detail left unencrypted in your software. Rummage gives you a detailed yet easy to read list of things left in the program. Why wasn’t this class name obfuscated? Rummage will tell you in detail. Rummage lists everything it does, everything it doesn’t do, and why.

1. Simple to use
2. • Rummage is designed to work out-of-the box, without requiring you to make advanced decisions about specific code elements or configure obfuscations in ways that do not increase security. Start Rummage, select your assembly, click “Obfuscate now”.
   • Our philosophy is to keep it that way. There are enough complex obfuscators out there. Rummage might not have every feature ever conceived, but by limiting scope we can offer the best experience for most projects.
   • Whatever question or problem arises while you use Rummage, we’ve got you covered. Whether a simple question or an advanced scenario, we’re here to discuss it with you and offer all the help we can. Just get in touch via our support page!
   • And if you just have something on your mind that you want to tell us, anonymously and without filling out any registration forms, you can do that any time and as often as you like at the quick feedback page.
3. Quick and responsive support
   • Rummage is simple on the outside but advanced under-the-hood. It is designed to be used without having to understand how our algorithms modify the program.
   • We do not believe in security through obscurity. Rummage permanently removes information which helps attackers from your program, and we want you to be sure of this. This is why we’ve explained what each of our algorithms does and why.
4. First-class obfuscation
   • Reflection is what makes obfuscation hard. Improper handling of reflection can severely limit the usefulness of an obfuscator. And it’s easy for reflection to slip in without you even knowing – for example, through the use of C#’s dynamic keyword.
   • All of Rummage algorithms take reflection into account. Rummage starts off by inferring which types and members are reflected upon and how, and subsequently makes use of this information to keep the transformations it applies safe.
5. Automatic handling of reflection
   • Debug symbols (.PDB, or program database) are produced by compilers to help debug a program. These files contain additional information which maps information in the compiled binary to the program’s source code.
   • Rummage understands this information, and carries it over through the obfuscations. This enables stepping through the obfuscated binary in the debugger, and allows obtaining stack traces with source code line information.
6. Debug symbols support
   • Rummage records exactly what it has and hasn’t changed. You may review this information to verify that particularly sensitive code got transformed according to your expectations.
   • Where Rummage was forced to skip a transformation, it tells you exactly why this occurred. For example, you might find that Rummage did not rename certain fields because the type is reflected on: Rummage will point you at the very method which performs the offending reflection call.

• Rummage used to occasionally modify COM interfaces incorrectly.
• Better support for specific P/Invoke scenarios.
• Handle pinned and pointer types correctly when obfuscating IL.
• Do not modify types used by InstallUtil.exe.
• Certain Rummage-generated members were named a, b, c, ... instead of using the plausible-looking name generator.
• Cosmetic fixes.