Softpedia >Windows >Programming >Packers/Crypters/Protectors >Dotfuscator Professional Edition >  Changelog

Dotfuscator Professional Edition Changelog

What's new in Dotfuscator Professional Edition 7.1.0

Nov 14, 2023
  • Enhancements:
  • Added support for parallel configuration file access
  • Added support for target platform specific configuration file for MAUI
  • Added support for linking .NET Core assemblies
  • Improved performance of Debug Check
  • Fixes:
  • Strong name signature of resigned assemblies can now be verified using common tools (such as dumpbin.exe)
  • Improved root check
  • Improved XAML processing

New in Dotfuscator Professional Edition 7.0.0 (Oct 3, 2023)

  • Added support for MAUI
  • Added support for .NET 8 (verified compatibility with the .NET 8 preview)
  • Improved renaming functionality in embedded XAML files

New in Dotfuscator Professional Edition 6.5.4 (Apr 27, 2023)

  • Enhancements:
  • Improved detection of debuggers. Note: Running certain debuggers in the background might interfere with the MSBuild process.
  • Fixes:
  • Resolution (scaling) issues related to Dotfuscator UI

New in Dotfuscator Professional Edition 6.5.2 (Jan 14, 2023)

  • Enhancements:
  • Improved renaming of properties referenced in XAML files
  • Added a comprehensive error message when using invalid renaming schemes for Xamarin.Android projects
  • Added smart obfuscation rules for compiled XAML

New in Dotfuscator Professional Edition 6.5.1 (Sep 23, 2022)

  • Important Compatibility Changes:
  • Dotfuscator distributed as a Nuget package targets .NET 6 instead of previously .NET Core 2.1.
  • Dependencies updated to the newer version of the libraries used by Dotfuscator.

New in Dotfuscator Professional Edition 6.5.0 (Sep 13, 2022)

  • Enhancements:
  • Tamper Check support is added for .NET Core 3.1/.NET 5+.
  • Debugging Check support is added for .NET Core 3.1/.NET 5+.
  • Additional license status messages are displayed in the CLI and MSBuild output.
  • Changing the Product License does not require the client to be restarted anymore.
  • The new signing methods are used instead of the deprecated ones for Android Pie (API Level 28) and newer OSes with Tamper Check.
  • Added a Readme file for the Dotfuscator NuGet package for a more seamless setup experience.
  • Added a new “force_nuget_tools” global option.
  • [This release may include protection enhancements not described here]
  • Functional Changes:
  • Merged the Evaluation (Free Trial) and Professional version clients so that the PreEmptive Licensing Server tells the client how to behave. The client does not have to be reinstalled upon upgrading from Evaluation to Professional anymore.
  • Forward slashes are being used by default in the config file for better cross-OS support.
  • Version “6.0.0” of Microsoft.NETCore.ILAsm and Microsoft.NETCore.ILDasm NuGet packages are used by default (instead of “5.0.0” in the previous version of Dotfuscator), unless you override this value in the “DOT_ILTOOLS_CORE_VERSION” property.
  • Fixes:
  • Display that Linking is not supported for .NET Core/.NET 5+ projects instead of displaying an unrelated error message.
  • Fixed an issue when Root Check for Xamarin.Android returns false-positive results on certain Android devices.

New in Dotfuscator Professional Edition 6.4.2 (Mar 2, 2022)

  • Enhancements:
  • Metadata of NET Core/.NET 5+ assemblies will be kept after protection.
  • Added SmartObfuscation support for Enum.TryParse.
  • Removed license keys from report files.
  • Added support for the .NET 5 “Unmanaged” IL calling convention.
  • This release may include protection enhancements not described here.
  • Fixes:
  • Fixed unclear error message if the stack trace file is missing from the Lucidator input.
  • Fixed incorrect indication of “unmatched rules” for Renaming exclusions.
  • Fixed the config file generation for directory inputs.
  • Fixed an issue with the Unprintable Renaming scheme for Nullable types.

New in Dotfuscator Professional Edition 6.4.0 (May 11, 2021)

  • Enhancements
  • Added full support for default interface methods.
  • Added option to disable the renaming of managed resources.
  • User Guide improvements, including a new Release Checklist page to explain how to release an app which is protected by Dotfuscator.
  • This release may include protection enhancements not described here.
  • Functional Changes:
  • When using Automatic Input Management, such as with the recommended Protect Your App instructions, the Config Editor’s View menu will no longer allow access to report files if there could be multiple reports that vary by build configuration and platform. To access the full set of reports, check the DotfuscatorReports directory.
  • In cases where Dotfuscator downloads ILDasm and ILAsm tools via NuGet, you can now specify the NuGet feed, username, and password via environment variables. This should only be necessary if you do not have access to the public nuget.org feed.
  • When using an internet proxy requiring authentication, you can now specify the username and password via environment variables for Dotfuscator to use for licensing communications. For details, see Internet Connection Requirement.
  • Fixes:
  • Fixed issues related to renaming obfuscation.
  • Fixed an issue where strong name re-signing doesn’t support spaces in the path to the key file.
  • Fixed an issue where Automatic Input Management would fail if a solution contains a non-filesystem path to a project. For instance, when an “Existing Website” is added to a solution, the solution can contain a web address. In these scenarios, Dotfuscator now warns and continues.
  • Fixed an issue where Dotfuscator errors when protecting an assembly whose name contains netstandard.
  • Fixed an issue where Dotfuscator errors when processing an assembly which has type forwards to nested types.
  • Fixed an issue where the Output tab in the Config Editor would not indicate types which were removed by Dotfuscator.
  • Fixed other minor issues.

New in Dotfuscator Professional Edition 6.2.0 (Jan 27, 2021)

  • Enhancements:
  • Dotfuscator's MSBuild integration now works with the .NET 5 SDK.
  • Additional improvements to the .NET 5 support.
  • Documentation improvements.
  • Condensed renaming results on the Output tab.
  • Improvements to Licensing related UI.
  • This release may include protection enhancements not described here.
  • Functional Changes:
  • When the PREEMPTIVE_TELEMETRY_OPT_OUT environment variable has an unrecognized value, Dotfuscator will now warn and treat the variable as unset instead of giving an error.
  • Fixes:
  • Fixed runtime issue that could occur after renaming types that implement (or extend) types via generic instantiations nested more than two levels.
  • Fixed selecting the wrong version of ILasm and ILdasm to use in some cases.

New in Dotfuscator Professional Edition 6.1.0 (Nov 20, 2020)

  • Enhancements:
  • Support for signing assemblies when running under .NET Core and .NET 5 on non-Windows.
  • Support for Nullable Attributes.
  • Config Editor improvements.
  • This release may include protection enhancements not described here.
  • Fixes:
  • Fixed build failure when adding a Check to a delegate method.
  • Fixed issue building with a Hang Action configured for a Debug Check.
  • Stopped removing netstandard.dll and System.Runtime.dll aliases when using Linking.
  • Fixed issue finding some reference assemblies for Xamarin projects automatically.
  • Allow environment variables to be used when specifying tool locations.
  • Clarified NuGet installation instructions in the Dotfuscator user guide.
  • Fixed String Encryption runtime error that occurred when also using the new version of the Xamarin Android Linker.

New in Dotfuscator Professional Edition 6.0.1 (May 1, 2020)

  • Important Compatibility Changes:
  • Updated product name from Dotfuscator to PreEmptive Protection Dotfuscator.
  • The default installation directory when using the Windows installer is now c:Program Files (x86)PreEmptive Protection Dotfuscator Professional 6.x.y.
  • A cross-platform, .NET Core version of the Dotfuscator command line is now available in the Dotfuscator NuGet package.
  • The Dotfuscator MSBuild components now require the .NET Core 2 (version 2.1.x or higher) runtime instead of requiring the .NET Core 3 SDK (or later).
  • Running Dotfuscator on Linux is now fully supported.
  • Improvements to Dotfuscator's license validation. See Upgrading from Dotfuscator 4 for more information.
  • The premark MSBuild task has been removed.
  • Enhancements:
  • Revamped activation process.
  • Documentation improvements.
  • This release may include protection enhancements not described here.
  • Fixes:
  • Fixed crash in the Config Editor when opening a config file of a project that references PreEmptive.Attributes.dll.

New in Dotfuscator Professional Edition 6.0.0 Beta (Dec 20, 2019)

  • Important Compatibility Changes:
  • Dotfuscator's build components can now be installed on macOS and Linux. For example, you can protect a Xamarin.Android project when building it in Visual Studio for Mac. See macOS and Linux in the User Guide for more details.
  • Dotfuscator can now run under MSBuild engines for .NET Core and for Mono, in addition to the full .NET Framework MSBuild. This means that Dotfuscator-integrated projects can now build under the .NET Core dotnet command and the Mono msbuild command.
  • Important**: For this beta release, .NET Core build environments must be using SDK version 3.0 or later.
  • Dotfuscator can now be installed with the PreEmptive.Protection.Dotfuscator.Pro NuGet package on Windows, macOS, and Linux. This package is distributed privately by PreEmptive to licensed Dotfuscator Professional users.
  • The Windows installer package (.msi) continues to be supported alongside the NuGet package. Windows users can choose to use either the Windows installer or the NuGet package to provision Dotfuscator.
  • The Visual Studio integrated UI has been removed. It is replaced with an MSBuild integration which supports Visual Studio, Visual Studio for Mac, Visual Studio Code, and command line build tools. We recommend migrating your Dotfuscator Projects (.dotfuproj files) to the new integration; see migration instructions for Visual Studio Integration for details.
  • The oldest supported version of Visual Studio is now 2012 (previously was 2010).
  • The minimum version of .NET Framework required to install Dotfuscator with the Windows installer is now 4.7.2 (previously was 4.6.1).
  • Dotfuscator no longer supports injecting PreEmptive Analytics runtime telemetry. Checks are still supported, and you can use custom code triggered via application notification to report security incidents to an analytics platform of your choosing.
  • Dotfuscator no longer supports assemblies built for Silverlight, Windows Phone, or WinRT (e.g., Windows 8 apps).
  • Dotfuscator no longer supports .appx files as input packages. To protect apps which are packaged into this format, such as Universal Windows Platform (UWP) apps, use the MSBuild integration, which will apply protection before the project's packaging steps.
  • Dotfuscator no longer supports the Unity game engine.
  • Dotfuscator's Authenticode signing feature has been removed; please use a post-build event or a custom step in your build system to sign your assemblies after Dotfuscator processes them. Dotfuscator can still re-apply strong name signing to your assemblies.
  • Dotfuscator no longer has its own proxy settings. Please use the system proxy settings instead.
  • Dotfuscator's Check Attributes are now distributed separately from Dotfuscator. They are available in the PreEmptive.Protection.Checks.Attribute NuGet package on nuget.org.
  • Enhancements:
  • Updated the product's logos and branding.
  • Properties can now be defined in terms of other properties.
  • Improved Config Editor user experience.
  • Improved the stack trace translation tool and Lucidator to accommodate stack traces reported by Visual Studio App Center.
  • The SuppressIldasm feature now uses a .NET Standard version of the attribute, allowing the feature to work on assemblies not targeting the full .NET Framework.
  • Dotfuscator now recognizes the PREEMPTIVE_TELEMETRY_OPT_OUT environment variable to control customer feedback options.
  • This release may include protection enhancements not described here.
  • Functional Changes:
  • Dotfuscator 6 can be installed side-by-side with Dotfuscator 4. However, only one version of Dotfuscator 6 can be installed at a time when using the Windows Installer. To have side-by-side installations of Dotfuscator 6, please use the NuGet package.
  • Fixes:
  • Fixed an issue where changing the build configuration (e.g., "Release") when using Automatic Input Management can cause configuration rules to be ignored.
  • Fixed an issue where an invalid license file causes the Config Editor to close with no error message.
  • Fixed an issue where adding a Check after building in the Config Editor can cause a crash.
  • Fixed an issue where a config file using Automatic Input Management could be treated as changed even when there are no changes.
  • Fixed an issue where the Config Editor incorrectly changes a config file to have Manual Input Management set.

New in Dotfuscator Professional Edition 4.43.2 (Oct 14, 2019)

  • Fixes:
  • Updated probing for references for .NET Core 3.0.
  • Fixed issue where Renaming exclusion rules would be erased by the Config Editor.
  • Updated Smart Obfuscation rules to detect enums declared in .NET Standard assemblies.
  • Fixed issue processing XAML with markup extensions that have nested values.
  • Fixed issue loading ARM 64 APPX assemblies in Dotfuscator.
  • Fixed crash in the Config Editor when loading a config file with a directory input that is not on disk.
  • Updated MSBuild targets integration to allow absolute paths for IntermediateOutputPath.

New in Dotfuscator Professional Edition 4.43.1 (Jul 31, 2019)

  • Fixes:
  • Fixed an issue where Xamarin applications built in Visual Studio 2019 version 16.2 with Dotfuscator's MSBuild Targets would not be completely protected or would fail to build.

New in Dotfuscator Professional Edition 4.43.0 (Jul 25, 2019)

  • Enhancements:
  • Dotfuscator's MSBuild Targets can now be configured to include assemblies and exclude projects from protection.
  • The DotfuscatorIncludeAsInput MSBuild Property allows projects to be excluded from Dotfuscator.
  • The DotfuscatorIncludeAsInput MSBuild Item Metadata allows certain external assemblies to be included as inputs to Dotfuscator.
  • The Dotfuscator Professional Config Editor has received several updates.
  • This release may include protection enhancements not described here.
  • Functional Changes:
  • Several improvements to license checking logic, some of which can be configured.
  • Fixes:
  • Removal no longer erroneously removes Attribute Types if they are used exclusively on methods.
  • File inputs from a network (that have a path beginning with \) no longer show as unavailable.
  • The Dotfuscator Config Editor no longer crashes when a linked output assembly is removed.
  • Strong-Named project dependencies now remain strong-named when using the Dotfuscator MSBuild Targets.
  • The PDBAUTO Setting no longer causes an error if an input file path contains a single quote (') character.
  • Improved search stability and performance for external tools (such as ilasm.exe).

New in Dotfuscator Professional Edition 4.41.1 (Apr 30, 2019)

  • Enhancements:
  • Improved support for building in cloud environments. See the Build Agent Considerations page for more details.
  • Dotfuscator is now available as a privately-downloadable NuGet package in addition to the usual msi installer.
  • License keys can now be specified through command line arguments or an environment variable.
  • Note: The Dotfuscator Professional Build Task extension is also now available and can be used to add the DotfuscatorCLI task to your Azure Pipelines build process.
  • Visual Studio 2019 is supported by Dotfuscator's Visual Studio Integration.
  • The sample projects moved to GitHub and are no longer included in the installer. You can access them from the Config Editor by choosing "File" -> "Download Samples".
  • The Config Editor supports new keyboard accelerators.
  • Improved documentation for .NET Core 3 apps.
  • Additional documentation improvements.
  • This release may include protection enhancements not described here.
  • Functional Changes:
  • The entire assembly path is no longer displayed in the inclusion and exclusion tree views in the Dotfuscator Config Editor.
  • Custom Attributes are now displayed in an "Attributes" node, that is collapsed by default.
  • Fixes:
  • Corrects an issue with installing Dotfuscator's Visual Studio Integration on systems that have early versions of Visual Studio 2017.
  • Renaming will no longer generate new names that are reserved words in Java.
  • Improved support for High DPI displays.
  • Configuring a Sink method that is async, with an Action configured will now error to prevent undefined behavior at runtime.
  • Markup parsing error messages are now more specific.
  • Resolved an issue that could result in build failures when automatically creating PDBs.
  • Resolved an issue with processing generic constraints used in C# 7.3

New in Dotfuscator Professional Edition 4.38.0 (Nov 16, 2018)

  • Important Compatibility Changes:
  • Options for the "Emit Debugging Symbols" setting have changed.
  • The "No PDB" option has been renamed to "Never".
  • Other existing options are deprecated and will be removed in a future release. The Config Editor will not display these options unless the loaded Dotfuscator config file already has one of these options set.
  • An "Automatically from Input Assemblies" option has been added and is the default for new config files. Selecting this option causes Dotfuscator to emit updated debugging symbols with each protected assembly based on the format of the symbols with the corresponding input assembly. Unlike the deprecated options, this option supports Portable PDBs, as well as the original .NET Framework PDB format.
  • Dotfuscator Professional's proxy settings are deprecated and will be removed in a future release. Please use the operating system proxy settings instead.
  • The MSBuild targets no longer depend on Dotfuscator Professional's command line executable. As a result, the DotfuscatorCliPath MSBuild property is no longer required and will be ignored.
  • Enhancements:
  • The Xamarin instructions in the User Guide have been updated to show how to use the new integration for Xamarin apps, making it much easier to use and maintain Dotfuscator with Xamarin.
  • Added a new option for the "Emit Debugging Symbols" setting, "Automatically from Input Assemblies". Selecting this option causes Dotfuscator to automatically emit updated debugging symbols (e.g., PDB files) in the same format as those included with the input assemblies. This option supports Portable PDBs as well as the original .NET Framework PDB format.
  • Updated samples shipped with the product as well as the Protected-BugSweeper sample on GitHub to demonstrate the new integration.
  • Various improvements to the product activation experience.
  • This release may include protection enhancements not described here
  • Functional Changes:
  • The product name has changed to "Dotfuscator Professional".
  • References to the discontinued PreEmptive Analytics Community Workbench have been removed.
  • Fixes:
  • Fixed an error with processing BAML records.
  • Fixed an issue where ClickOnce packages were not protected during a Publish operation when using the MSBuild targets.
  • Fixed an OutOfMemoryException error when using the MSBuild targets.
  • Fixed an issue where the MSBuild targets will act as if the Dotfuscator config file exists when it has been removed during the current Visual Studio session.
  • Fixed an issue where F# projects using the original .fsproj format and the MSBuild targets would not rebuild when changes were made to the Dotfuscator config file.
  • Fixed a build error when using the Dotfuscate MSBuild task when both InputAssemblies and the input assembly list in the config file specified by ConfigPath contain the same assembly.
  • Fixed a build error when using string encryption in a config file with mixed assemblies.
  • Fixed a build error when using Root Checks in some scenarios.
  • Fixed other minor issues.

New in Dotfuscator Professional Edition 4.37.0 (Aug 22, 2018)

  • Major Changes:
  • This release includes a brand-new way to use Dotfuscator, designed to make it easier to get started, easier to integrate into your build, and easier to maintain your configuration. This new approach is built on top of our existing feature set, so current users do not have to adopt it, but we are suggesting it as the primary way that all users use Dotfuscator, from now on.
  • To get started, you insert a few lines into your existing Visual Studio project file (i.e. a .csproj file or other MSBuild file). Then you run a Release build as usual, and Dotfuscator automatically generates a config file for you (with default settings) and automatically protects your app. From there, our new Automatic Input Management feature will automatically update your Dotfuscator config as you add or remove projects from your Visual Studio solution.
  • This new approach works for nearly all our supported platforms, including .NET Framework, .NET Core, Xamarin, and UWP. It supports incremental builds on most platforms, and will integrate well with any downstream build steps like packaging and signing. (Note that it does not yet support linking.)
  • In future releases, we plan to provide a new Visual Studio integrated UI that makes the initial setup even easier. We have therefore deprecated our current Visual Studio integration, and it will be removed when we publish the new integration in a future release.
  • Note that we have also updated our terminology: a "Dotfuscator project" is now consistently referred to as a "Dotfuscator config" to avoid ambiguity with MSBuild project files, and Dotfuscator's "Standalone GUI" is now Dotfuscator's "Config Editor".
  • Functional Changes:
  • Running Dotfuscator now minimally requires .NET Framework v4.6.1 (previously, v4.5.2).
  • Telemetry/PreEmptive Analytics has been deprecated. It will be removed in a future release of Dotfuscator.
  • An unconfigured Customer Experience Improvement Program setting is now interpreted as "enabled". To change your participation in this program, launch the Dotfuscator Config Editor, open the Help menu, and select Customer Feedback Options.
  • The Visual Studio Integration UI has been deprecated. It will be removed in a future release of Dotfuscator.
  • The contents of the Dotfuscator Professional Quick Start Guide have been merged into the Dotfuscator Professional User Guide.
  • The /makeconfig option has been deprecated. The new /genconfig option should be used instead. Whereas /makeconfig both created a new Dotfuscator config and ran Dotfuscator with that config, /genconfig simply creates the new Dotfuscator config. Furthermore, /genconfig generates a <propertylist> element in the config file, populated with the property values passed in the command line via the /p option.
  • The Dotfuscator application that edits the Dotfuscator config file (dotfuscatorUI.exe) is now called "Dotfuscator Pro Config Editor" in the Windows Start Menu, and just "Config Editor" in the UI and documentation.
  • Dotfuscator no longer resorts to displaying a Proxy information request dialog when failing to reach PreEmptive's licensing and registration services. The ability to configure Proxy information for this purpose is still available in the Dotfuscator Config Editor.
  • To perform an offline activation of Dotfuscator, you will now need to call Support. The Dotfuscator command line option /offlineactivation has been removed, and the Dotfuscator Config Editor and the Visual Studio Integration no longer provide an offline activation dialog.
  • Inputs specified by the InputAssemblies property on the Dotfuscate MSBuild task are now treated as input assemblies even if they are not also listed in the config file. In other words, inputs specified by the InputAssemblies property are merged with the inputs listed in the config file.
  • Dotfuscator no longer fails when an input with an assembly-level inclusion/exclusion rule is removed from the input list in the config. Instead, Dotfuscator will warn that there are orphaned rules.
  • Enhancements:
  • Dotfuscator Professional can now be installed, activated, and run under Windows' FIPS mode provided that Dotfuscator is not an Evaluation copy and is used with a perpetual (non-subscription) license.
  • The installer will now prompt for a license key and perform the initial activation (if needed), once the primary installation is complete.
  • The User Guide has been further reorganized to make it easier to find content. In particular, the "User Interfaces" section was expanded to list all of the tools and integrations that Dotfuscator provides.
  • This release may include protection enhancements not described here.
  • Fixes:
  • Fixed an issue where "Visual Studio Build Tools 2017" was listed as an option for installing the Visual Studio integration, which would cause an installation failure if selected.
  • Fixed an issue where a file-level inclusion/exclusion rule for a file that does not exist or is not an assembly caused subsequent file-level rules to be ignored.
  • Fixed an issue where an unnecessary, renamed DotfuscatorAttribute was added to an assembly if renaming was enabled and a Root Check was injected.
  • Fixed other minor issues.

New in Dotfuscator Professional Edition 4.35.2 (Jun 29, 2018)

  • Fixed an issue where Smart Obfuscation was slow when evaluating certain LINQ expressions.
  • Fixed a build error when using control flow obfuscation and linking with assemblies that have module initializers.
  • Fixed an issue where Dotfuscator errored during startup.

New in Dotfuscator Professional Edition 4.35.0 (Apr 26, 2018)

  • Enhancements:
  • Added Root Check for Xamarin Android applications. Dotfuscator can inject code into an application to detect and react if the application is running on an Android device that has been rooted.
  • Fixes:
  • Fixed issue parsing nested classes defined within a .namespace member.
  • Fixed issue where the SuppressIldasmAttribute was being removed from input assemblies that were adding it manually.
  • Fixed issue renaming some event handlers in XAML.
  • Fixed compatibility issues with .NET 1.0/1.1.
  • Fixed a potential null reference exception when processing assemblies.
  • Fixed an issue where the Visual Studio integration caused performance issues when right-clicking Solution items in Visual Studio.

New in Dotfuscator Professional Edition 4.33.0 (Nov 21, 2017)

  • Enhancements:
  • Improved ASP.NET Core SmartObfuscation.
  • Added an ASP.NET Core sample and updated other samples.
  • The setting to use only Mono-compatible transforms can now be specified on the command line.
  • Both Removal and Smart Obfuscation report paths can now be specified from the command line.
  • Dotfuscator will now take into account configured Assembly Binding Redirects while performing cross-assembly obfuscation.
  • Dotfuscator honors configured Assembly Binding Redirects for non-strong-named assemblies.
  • For details on configuring Assembly Binding Redirection see Microsoft's documentation on Redirecting Assembly Versions.
  • Various improvements to obfuscation techniques.
  • Functional Changes:
  • Instrumentation and Check Injection are currently unsupported for .NET Core assemblies.
  • Attempting to perform these actions on .NET Core assemblies will now error the build.
  • Documentation has been updated to correctly reflect the status of .NET Core injection.
  • Fixes:
  • When updating the name of a linked output, the treeview will now correctly reflect changes.
  • Fixed a build error during Markup Analysis.
  • Fixed a WPF SmartObfuscation rule not working with .NET 4.0+ assemblies.
  • Fixed issues with cross-assembly obfuscation when the assemblies contain duplicate class names.
  • Fixed an issue where obfuscated output could cause issues with the Xamarin Linker during builds.

New in Dotfuscator Professional Edition 4.31.1 (Sep 27, 2017)

  • Functional Changes:
  • Throughout the Dotfuscator UI, displayed input assembly paths are no longer abbreviated.
  • Fixes:
  • Corrected an issue where Dotfuscator erroneously added mscorlib references to .NET Standard applications.
  • Corrected an issue where an empty stack error could occur in BAML processing.
  • Correct an issue where excluding methods from Control Flow in the Dotfuscator UI would cause included methods to also be excluded from Control Flow.
  • If you make use of specific method exclusions for Control Flow, it is possible that after the upgrade more methods will be (correctly) included in Control Flow. If you were inadvertantly relying on these included methods being erroneously excluded, you may need to update your Dotfuscator config to specifically exclude them.
  • Corrected an issue where performance of the Dotfuscator UI degrades when many assemblies are present.
  • Corrected minor display issues in the new Checks UI.
  • Corrected an issue where the "Read more here" link for non-SHA1 signing didn’t work for non-default installation locations.

New in Dotfuscator Professional Edition 4.28.2 (Apr 13, 2017)

  • Fixed an issue that could cause incorrect mscorlib references to be added to assemblies referencing System.Runtime

New in Dotfuscator Professional Edition 4.28.1 (Mar 20, 2017)

  • Enhancements:
  • When installing Dotfuscator's Visual Studio Integration for a VS2017 instance, it will now also install the Dotfuscator MSBuild task and targets files into that instance.
  • Fixes:
  • Fixed an issue that could cause a null reference exception while using the Dotfuscate MSBuild Task.

New in Dotfuscator Professional Edition 4.25.0 (Oct 4, 2016)

  • Enhancements:
  • Added a new Debugging Check feature. Dotfuscator can inject code into an application to detect and react to the presence of a managed debugger, at runtime. This feature is enabled by the "Send Debug Check Messages" global option and can be configured by adding the `DebuggingCheckAttribute` via the Instrumentation screen or in-code annotations.
  • Added a new `Action` property to `DebuggingCheckAttribute` and `InsertTamperCheckAttribute` to control how an instrumented application will react to a detected Debugging Check or Tamper Check. There are four options:
  • The default `None` action does nothing.
  • The `Exit` action causes the instrumented application to immediately exit.
  • The `Exception` action causes the instrumented application to throw an exception.
  • The `Hang` action causes the instrumented application to hang the current thread indefinitely.
  • Added a new `ActionProbability` property to `DebuggingCheckAttribute` and `InsertTamperCheckAttribute` which determines how likely the specified `Action` is to occur at runtime. Setting this to a value other than the default `1.00` will cause the instrumented application to behave less predictably, confusing attackers.
  • A warning is displayed in the Build Output if an `InsertTamperCheckAttribute` (or `DebuggingCheckAttribute`) is configured to do nothing.
  • A warning is displayed in the Build Output if Dotfuscator will inject code into a constructor, which may cause runtime errors in certain scenarios.
  • Tamper (and Debugging Check) will now send telemetry even if Setup has not yet been called.
  • Shelf Life Check telemetry will still only send telemetry if Setup has already been called.
  • Functional Changes:
  • The `DefaultAction` value for the `ApplicationNotificationSinkElement` property on an `InsertTamperCheckAttribute` is now deprecated. In order to retain the same behavior, please instead set the `ApplicationNotificationSinkElement` to `None` and set the new `Action` property to `Exit`.
  • Running `dotfuscator.exe` with no arguments will now display usage information to the command line, instead of opening the Dotfuscator stand-alone UI. If you want to run the Dotfuscator stand-alone UI, run `dotfuscatorUI.exe`.
  • The `/g` option is no longer available on `dotfuscator.exe`. If you want to run the Dotfuscator stand-alone UI, run `dotfuscatorUI.exe`.
  • Artifacts within a package now display in italics and gray text, consistent with Community Edition's UI.
  • Assemblies within a package that were previously configured but are now missing from the package now appear in the Input GUI with a red exclamation point icon.
  • Fixes:
  • Artifacts within a package display their names, instead of their paths within the package (which is redundant with the tree structure they're placed in).
  • Fixed an issue where adding `ExceptionTrackAttribute` to an assembly which references WinForms, but not `System.dll`, sometimes resulted in an incorrect `System` assembly reference.
  • Fixed an issue where having Control Flow enabled in the Visual Studio Integration UI could cause a `DuplicateKeyException`.
  • Added better handling for quoted PublicKey(s) and PublicKeyToken(s) in assemblies.
  • Increased the level of obfuscation applied to the code Dotfuscator injects into assemblies.
  • Fixed some Xamarin-related issues by adding support for XAML 2009.
  • Prevented the commandline version of Dotfuscator (`dotfuscator.exe`) from displaying GUI dialogs.
  • Fixed various other minor bugs.

New in Dotfuscator Professional Edition 4.21.0 (Jun 7, 2016)

  • Enhancements:
  • Support for randomized name assignment. Selecting this Renaming option in conjunction with any renaming scheme will assign new names for types and members randomly instead of sequentially. See the User Guide for more detail.
  • Improved Support for running multiple instances of Dotfuscator concurrently on different projects on the same machine.
  • Packages can now be processed in their unzipped or unpackaged forms, provided all metadata is available. This allows markup to be successfully transformed in MSBuild pipeline scenarios as described in this article on using Dotfuscator with UWP.
  • Fixes:
  • Satellite assemblies in ClickOnce packages are treated as assemblies, not artifacts, in the new manifest.
  • Fixed an issue where using 'yield break' in conjunction with incremental obfuscation could result in a build error.
  • Fixed missing binding warning when processing XBF files in UWP applications.
  • Fixed BAML obfuscation issue that could cause a runtime error in WPF applications.
  • Improved handling of framework attached properties in XAML that take a UIElement in their backing code.
  • Fixed an issue parsing ILDASM output of Mixed Module Assemblies produced by VS2015 Update 2.
  • Fixed issue where some assemblies were missing a header flag after obfuscation.
  • Fixed an issue that could lead to an Int32 parse error during build.
  • Fixed various other minor bugs.

New in Dotfuscator Professional Edition 4.20.0 (Jun 7, 2016)

  • Enhancements:
  • Support for obfuscating and instrumenting Universal Windows Platform (UWP) applications.
  • Revised Getting Started documentation.
  • Fixes:
  • Attempting to use PreMark with no watermark string now halts the build immediately.
  • Fixed issue with control flow obfuscation on types marked for type equivalence.
  • Fixed error when a non-PCL assembly overrides a property defined in a PCL assembly.
  • Fixed verification error when using a `try`/`catch` within a loop.
  • Fixed issue occurring when multiple assemblies contained duplicate full type names.
  • Fixed `IndexOutOfRangeException` when using Smart Obfuscation on optimized code containing enums.
  • Fixed various other minor bugs.

New in Dotfuscator Professional Edition 4.18.1 (Jun 7, 2016)

  • Fixes:
  • Deserializing obfuscated types should no longer result in runtime errors.
  • Fixed null reference exception when attempting to link two assemblies containing the same managed resource name.
  • Fixed bug in Shelf Life instrumentation.
  • Fixed issue where assemblies with non-ASCII characters were sometimes unable to be loaded.
  • Fixed issue where removing an input assembly would clear exclusions from other assemblies.

New in Dotfuscator Professional Edition 4.18.0 (Jun 7, 2016)

  • Enhancements:
  • Added option to use only Mono compatible transforms.
  • Linking now accounts for the original input's machine type.
  • Fixes:
  • The subsystem versions in the PE headers of the input assemblies will now be preserved in the outputs.
  • Fixed issue with Linking when module names contain periods.
  • Fixed issue with string encryption not being performed with Library Mode off.
  • Fixed compile error when dotfuscated portable library is added as a reference to a Windows Store app.
  • Fixed a build error with incremental obfuscation
  • Resolved issues with Pruning and mixed module inputs.

New in Dotfuscator Professional Edition 4.17.0 (Jun 7, 2016)

  • Enhancements:
  • Added platform-specific instrumentation support for Windows Phone 8.1 Store Apps.
  • Updated instrumentation injection for Windows Phone so that applications meet current certification requirements, regardless of instrumentation settings.
  • Added support for integration with Visual Studio 2015.
  • Added .NET 4.6 support.
  • Fixes:
  • Fixed an issue with processing assembly-level attributes that are used in the same assembly in which the attribute is defined, during mixed-mode obfuscation.
  • Using a method defined in a PCL correctly keeps its original definition after obfuscation, rather than the PCL definition.
  • Various fixes to linking when including an assembly containing markup.

New in Dotfuscator Professional Edition 4.16.1 (Jun 7, 2016)

  • Fixes:
  • UI now checks enabled Built-In Renaming Rules on project load.
  • Correctly builds Silverlight apps with Exception Reporting using the default dialog.
  • A number of UI issues in the Visual Studio integration were corrected

New in Dotfuscator Professional Edition 4.16.0 (Jun 7, 2016)

  • Enhancements:
  • Significant performance improvements in build times, load times, and general responsiveness.
  • Exclusions for field/method signatures can now be specified using regular expressions.
  • The v4 Analytics API now runs under .NET 4.0, rather than .NET 4.0.3.
  • Resigning packages through Dotfuscator is now optional.
  • Assembly level unhandled exception reporting is now supported in ASP.NET web applications.
  • The analytics endpoint can now be specified at runtime with web.config or app.config settings.
  • Exception reporting can now use the standard SourceElement set of sources to receive the Exception object, such as Method Argument, Field, etc.
  • The "Omit Personally Identifiable Information" instrumentation option is now exposed as a property of the SetupAttribute.
  • The help system now uses standard HTML and a web browser to display the documentation.
  • Various user interface improvements.
  • Fixes:
  • Performance probe using the v3 Analytics API is now more accurate.
  • Various bug fixes for special characters in assembly names within packages.
  • Windows Phone 8.1 Windows Store(Universal Apps) now use the Windows Store version of the Analytics API for instrumentation.

New in Dotfuscator Professional Edition 4.15.0 (Jun 7, 2016)

  • Enhancements:
  • On supported platforms, Dotfuscator now injects the same instrumentation that is provided via the PreEmptive Analytics API for .NET. Supported platforms are "classic" .NET 4.0+, Windows Phone 8.x, and Windows Store.
  • Field and method signature exclusion rules now obey the Use "Regular Expression" option.
  • Fixes:
  • URL encoded package assemblies are now processed correctly for Appx packages.
  • makeappx.exe will now be found properly on 64bit computers with Visual Studio Express.
  • Fixed runtime bug with explicit overrides.
  • Fixed UI bug with decoding obfuscated stack traces in VSIP.
  • Fixed bug where analytics attributes with special characters would cause an ilasm error.
  • Ensured caught exception reporting never throws an exception.
  • Fixed various other bugs.

New in Dotfuscator Professional Edition 4.13.0 (Jun 7, 2016)

  • Enhancements:
  • Obfuscating Windows 8.1 Store Apps is now supported.
  • Added the ability to specify the PreEmptive Analytics endpoint at runtime.
  • CustomEndpoint has been renamed to StaticEndpoint.
  • Additional hardening against deobfuscators.
  • Dotfuscator is now able to transform markup in linked assemblies, as long as only one of the assemblies has markup. Linking assemblies with satellite assemblies, or assemblies in packages (e.g. XAP), may not succeed.
  • Fixes:
  • When linking assemblies with markup, the output assembly can be given an arbitrary name.
  • Notes:
  • To support the ability to specify the endpoint at runtime, your project file might be upgraded and afterwards will no longer work with old versions of dotfuscator (to be exact, it will send messages to the wrong location).

New in Dotfuscator Professional Edition 4.12.0 (Jun 7, 2016)

  • Enhancements:
  • Instrumented applications now support Time To Live for messages, so that messages will eventually be deleted if they cannot be sent.
  • Instrumented applications now have a max message envelope size of 4MB.
  • Fixes:
  • Dotfuscator no longer adds extra version information to renaming reports that caused incremental obfuscation to break.
  • Dotfuscator will no longer create a new project GUID in Visual Studio integration projects each time a solution is opened.
  • Specifying a password for an APPX certificate file will now work properly.