PreEmptive Protection DashO Change Log

11.3.1

Enhancements

A new option to automatically exclude classes with large methods (larger than 65535 bytes of code after obfuscation) that fail the builds. The option is called "Exclude classes having a method larger than 64K" and adds such classes to the "Global Processing Exclusions" list.
A new option to ignore missing entry points.

This release may contain protection enhancements not described here.

Changes

The ASM Java bytecode manipulation framework library shipped with DashO updated to version 9.3.
Apache Groovy library shipped with DashO updated to version 3.0.12.

Fixes

Fixed Spring Boot JAR processing.
Fixed Spring Boot "Flatten Hierarchy" processing and logging.

11.3.0

Enhancements

This release may contain protection enhancements not described here.

Added native support for WAR inputs without the need for complex scripts to extract before protection and repackage after protection. The classes are automatically treated as inputs and the libraries as support libraries inside the WARs.
Added native support for Spring Boot Jar and WAR projects. The classes are automatically treated as inputs and the libraries as support libraries inside the Spring Boot Jars and WARs based on the Manifest file.
All the protection features are working now with plain WARs and Spring Boot Jars and WARs including Obfuscation, Checks, Watermarking, Signing.
The "Entry Points - Libraries" screen is now merged with the "Input" screen where Libraries, Extensible Libraries, and Spring Boot inputs can be configured with the new Handler property.
Updated the Web project wizard to easily configure plain WARs and Spring Boot Jars and WARs.
Added a Spring Boot sample to our public samples repository to showcase how to configure a Spring Boot project.

Changes

The "Entry Points - Libraries" screen is now merged with the "Input" screen where Libraries, Extensible Libraries, and Spring Boot inputs can be configured with the new Handler property.
The ASM Java bytecode manipulation framework shipped with DashO updated to version 9.2.
Apache Groovy shipped with DashO updated to version 3.0.9.

11.2.1

Enhancements

This release may contain protection enhancements not described here.

Validate Modifiers input fields in the Config Editor for Include and Exclude rules.
Added an option for Properties with filesystem path values to open a system Browse dialog to choose the path.
Added a dropdown for Android Mode projects to switch between configured build variants and their associated Inputs in the Config Editor.
Added Japanese Documentation.

Changes

The Config Editor will open the last project on startup by default (can be changed to "Wizard" and "New standard project")
Turned on disabling tree nodes for checks shelf life.
Updated tooltip texts, added tooltip messages.
Changed some preferences to be enabled by default.

Fixes

Fixed an issue where input Jars with the same name could overwrite each other if "Merge Inputs" were unchecked.
Fixed an issue where the Config Editor incorrectly allowed the selection of some methods for Check injections.

11.2.0

Enhancements

This release may contain protection enhancements not described here.

Entry Points, Inclusions, and Exclusions can now use supertype and/or annotation based criteria.
Entry Points, Inclusions, and Exclusions can now match classes based on the existence of methods or fields that match the criteria.
Compiled bytecode from Java 16 (except the record type and the Sealed Classes preview feature) can now be processed.
Global Processing Excludes now allows for classes to never be updated by DashO.
Updated the New Project Wizard to include settings for generating Entry Point rules based on annotation based criteria, including a special set of entry points for Hibernate/JPA.
Improved the Android Project Wizard to support both ways the Android plugin can be applied.
Improved the "Method too large" errors to display the original name of methods when renaming has been performed. Methods from multiple classes will be displayed when necessary.
Updated the samples.

Changes

Added a warning for ambiguous Renaming Exclude class rules (will be changed to an error in a later release).
The Make Synthetic option now includes classes.
Updated to use ASM version 9.1.
Updated to include AdoptOpenJDK JRE version 11.0.11 in the installers.
Updated the End User License Agreement to match https://www.preemptive.com/eula.

Fixes

Fixed an issue where a class configured as an entrypoint could get renamed in rare circumstances.
Fixed an issue where the Config Editor showed unsupported settings on the Removal-Classes page.
Fixed an issue where the Config Editor could add a duplicate entry when dragging a class on the Removal-Classes page.
Fixed an issue where the x button on save dialog windows would proceed without saving instead of cancelling.
Fixed an issue where DashO would overflow a jump's boundaries in some cases.
Fixed an issue where the Browse dialog for selecting the Web project output folder would not allow selecting existing directories.
Fixed an issue where the Check Injection Locations list included native methods.
Fixed an issue where the splash screen would not scale properly on Windows.
Fixed an issue where deleting the last Method Call Removal rule would not save to the project file.

11.1.2

Enhancements

This release may contain protection enhancements not described here.

11.1.1

Enhancements

This release may contain protection enhancements not described here.

Changes

Updated the End User License Agreement to match https://www.preemptive.com/eula.

11.1.0

Enhancements

This release may contain protection enhancements not described here.

Support for processing bytecode from Java 15 (except the Records and Sealed Classes preview features).
DashO now saves the project file XML with attributes sorted by name (rather than random order).
Added an option to control whether injected string decrypters call intern() on decrypted strings.
Improved the samples.

Changes

Updated to use ASM version 9.0.
Updated to use Apktool version 2.5.0.
Updated to include AdoptOpenJDK JRE version 11.0.9.1 in the installers.

Fixes

Fixed an issue where DashO would encounter an exception under certain conditions when using an evaluation license.
Fixed a build script parsing issue in the Android Wizard.
Fixed an issue where DashO reported a renaming collision when there was no renaming input map.

11.0.0

IMPORTANT NOTES:

DashO 11.0 introduces Floating License support and improved product activation.

This release contains some breaking changes as mentioned below.

Please see the Upgrading page for migration instructions.

Enhancements

This release may contain protection enhancements not described here.

Improved Java 11 support for renaming and removal for classes, methods, and fields only referenced via invoke dynamic and dynamic constants.
DashO now supports Floating Licenses.
Improved the product activation procedure.
The product license can now be updated via the config editor.
The product license can now be configured via the environment or command line.
Android project wizards have improved gradle script parsing.
Android Wizard and Migration Wizard again support Android projects using Android Gradle Plugin 3.2.x, and enforce 3.2.0 as the minimum version.
Improved documentation and troubleshooting regarding Kotlin coroutines.
Reporting through the Customer Feedback Program can now be controlled by the PREEMPTIVE_TELEMETRY_OPT_OUT environment variable.
Added a Release Checklist to the User Guide.
Updated the samples.

Changes

Breaking Changes:
- DashO can no longer be run with Java 7, 9 or 10. Running on Java 8 is deprecated. The recommended runtime is Java 11 (or later).
- Removed support for the deprecated property: ${javaws.jar}.
Updated the product name from PreEmptive Protection DashO for Android & Java to PreEmptive Protection DashO.
Updated to include AdoptOpenJDK JRE version 11.0.8 in the installers.
Updated the DashO Gradle Plugins for Java to v5.0.0 with support for Gradle version 5 and later.
Removed instructions for installing .rpm Linux/GNU installation packages with rpm: use yum instead.
Support for using the license file found in DashO's installation directory has been deprecated. Please contact PreEmptive regarding migrating to a Floating license.

Fixes

Fixed an issue where ControlFlow would report it was active on a method when it didn't change anything.
Fixed an issue where Block Splitting would not be applied when Dalvik Compatibility was enabled.
Fixed an issue where Block Jumbling would not finish under certain circumstances.
Fixed an issue where DashO would encounter a StackOverflowError under certain conditions.
Fixed an issue where antconfig.bat did not work properly.
Fixed an issue where the Config Editor was partially enabled when the license was expired.

10.3.0

IMPORTANT NOTES:

Resource Encryption is no longer a beta feature. Please refer to the User Guide for information on how to configure Resource Encryption.

If you used Resource Encryption with an AAR in an earlier version of DashO, you will need to update the line in library-rules.pro from:

-keep public class * {

To:

-keep public class !dasho.**,!**.dasho.**,* {

This will allow R8 to rename the resource decryption classes that DashO injects.

Enhancements

Resource Encryption is no longer a beta feature.
Support for running DashO with Java 14.
Support for processing bytecode from Java 14 (except the preview feature Records).
Support mark() and reset() on decrypted resource streams.
Updated library-rules.pro file added by the Wizard for AAR project to allow Resource Encryption related support classes to be renamed.
Added a new Resource Encryption sample.

This release may contain protection enhancements not described here.

Changes

Updated to use apktool version 2.4.1.
Updated to use ASM version 7.3.1.

Fixes

Fixed an issue where an Android project may have used an incorrect Shelf Life jar.
Fixed an issue where the standalone Lucidator GUI had issues launching on macOS under certain conditions.

10.2.0

Enhancements

Android Mode support for Resource Encryption (Beta).
Support for Google Play Store key upgrade.
Android project wizards now put the maven.preemptive.com repository last in the repositories priority list.

This release may contain protection enhancements not described here.

Changes

Requires version 1.1 of the DashO Gradle Plugin for Android if using resource encryption.
Updated to include AdoptOpenJDK JRE version 11.0.6 in the installers.
Removed the authorized-app Shelf Life sample.

Fixes

Fixed an issue where saving a project could overwrite without prompting.
Check injections now respect global processing excludes.

10.1.0

Enhancements

Support for running DashO with Java 11, 12, & 13.
Support for processing bytecode from Java 11, 12, & 13.
The DashO installers now include an AdoptOpenJDK JRE (v11.0.4). This JVM is used, by default, when running DashO.

This release may contain protection enhancements not described here.

Changes

Running DashO with Java 7 is now deprecated.
Updated to use ASM version 7.2.
The MethodParameters attribute is now configured for removal separately from Unknown.
Application usage reporting via Customer Feedback Program is now enabled by default. Preferences that were already set in existing installations will not be modified. This setting can changed from within the DashO GUI by going to Help > Customer Feedback Options.

10.0.1

Fixes

Fixed an issue with the registration dialog being too tall on some scaled displays.
On startup, subscription expiration warning dialogs are only presented during the warning period.

10.0.0

IMPORTANT NOTES:

DashO 10.0 introduces a new Android Mode, which works with the new DashO Gradle Plugin for Android, providing better support for Android projects.

This release contains some breaking changes as mentioned below.

Please see the Upgrading page for migration instructions. Note that there is a Migration Wizard that will migrate most Android projects automatically.

Enhancements

Added a new DashO Gradle Plugin for Android.
Added Android Mode which is specifically designed to work with the DashO Gradle Plugin for Android as part of an Android build process that uses R8.
- The GUI now has a Standard Mode and an Android Mode.
- The Android Mode GUI will prompt you to refresh the list of input classes when it detects changes in the inputs.
- To migrate to this new Android integration refer to the Upgrading page.
- Added new paths in the wizard to:
  - Generate new Android Mode projects.
  - Migrate Android projects that use DashO Gradle Plugin to the new DashO Gradle Plugin for Android.
Reorganized the DashO User Guide to have a more intuitive layout, separating discussion of obfuscation concepts from the project file reference and the user interface.
The GUI listens for changes to the configuration and will prompt to reload.
DashO is no longer restricted to running on Java 7 - 10, and can be run on Java 11 and later. Support for processing bytecode from Java 11 and later is not yet available.
Updated the GUI to easily configure Dalvik compatibility.
The random reordering of simple blocks in a method by Block Jumbling now varies between runs of DashO.
When Control Flow is enabled and Removal is configured to preserve the Local Variable Table for a method, the method's parameter names will now be preserved, but information about local variables will still be removed.
Added the --pathMap command line option which allows specifying a file that configures DashO's input and output paths. This option is currently only available for Android Mode.
Updated the DashO-GameOfLife sample.
Improved the Spring Bean sample.
Improved some error messages.

This release may contain protection enhancements not described here.

Changes

Updated the product name from PreEmptive Protection - DashO to PreEmptive Protection DashO for Android & Java.
Updated the DashO Gradle Plugins for Java (previously called DashO Gradle Plugin):
- v3.4.0 with deprecated support for the Android Gradle 3.4.0 plugin.
- v4.0.0 with no Android support.
- v4.1.0 with an updated name.
Updated to use ASM version 7.1.
Updated to use apktool version 2.4.0.
Breaking Changes:
- DashO Gradle Plugin for Android versions used with DashO 10 Betas (0.9.0 and 0.10.0) are no longer supported.
- The Append current Java runtime and Use Classpath from Environment options have been removed.
- Wildcard class matching (**) for method call removal has been removed.
- DashO's public get*Version*() methods have been removed.
- Proxy configuration within the DashO GUI has been removed. Proxy configuration is now specified using standard Java system properties.
- Removed support for deprecated properties: ${dasho.java.version}, ${jce.jar}, and ${jsse.jar}.
- The DashO Eclipse Plugin has been removed.
The javaws.jar property has been deprecated, and cannot be used in some configurations.
Control Flow and String Encryption are now enabled by default on new projects.
Removed the option to hide the toolbar.
The navigation tree in the DashO GUI can no longer be collapsed.
Packages in rule editors are now listed hierarchically.
DashO will now only warn once per build if Control Flow is enabled and Removal is configured to preserve the Local Variable Table or Local Variable Type Table.
DashO now will obscure all but the last four digits of the license key in the build output.
When DashO is run with a User license (e.g. not a Build license), a notice will be printed indicating that User licenses may not be used to protect binaries for general release.
Updated the End User License Agreement to match https://www.preemptive.com/eula.

Fixes

Fixed a rare issue when reading MethodParameters attributes which do not reference a constant pool entry.

9.3.2

Enhancements

This release may contain protection enhancements not described here.

Fixes

Fixed an issue with Control Flow Block Splitting when running applications on older Android devices (KitKat / 4.4 and earlier) that use the Dalvik VM. Enable the fix by setting ANDROID_DALVIK_COMPATIBILITY to true in the User Properties.

9.3.1

Enhancements

Added a WARN_ON_MISSING_SUPPORT_ENTRY property which, when set to true, will warn instead of error if a configured support entry is missing.

This release may contain protection enhancements not described here.

9.3.0

Enhancements

This release may contain protection enhancements not described here.

Changes

Updated the DashO Gradle Plugin:
- v3.3.0 with support for the Android Gradle 3.3.0 plugin.
- v3.2.3 with includeAsInputs improvements.

Fixes

Fixed an issue with random renaming that would cause a large amount of memory to be allocated under certain conditions.
Fixed an issue where incremental renaming validation found a false conflict between methods.
Fixed an issue processing the EnclosingMethod attribute when the referenced class is not included in the inputs.
Fixed an issue where DashO would encounter an exception under certain conditions when using custom string encryption.
Fixed an issue where DashO kept too many files open at once.

9.2.0

IMPORTANT NOTES:

We fixed an issue where some field references would be inappropriately altered, which required an update to our field renaming algorithm. This change can potentially cause field renaming conflicts with incremental renaming using renaming maps created with earlier versions of DashO. DashO will check for this condition and emit an error if it is detected. Please contact support if you have issues with conflict detection.

Enhancements

Added an Emulator Check for Android.
Added a Hook Check for Android.

This release may contain protection enhancements not described here.

Changes

The algorithm for field renaming has been updated to work with the fix to field references mentioned below.
Removed default heap size limit for WAR wizard produced projects.
Added a reminder to the String Encryption page that Removal should also be enabled.
Updated the DashO Gradle Plugin to 3.2.2.

Fixes

Fixed an issue with the splash screen on macOS Mojave.
Fixed an issue where some field references would be inappropriately altered, producing incorrect behavior in rare cases.
Fixed an issue showing the User Guide in rare cases.
Clarified use of check injection settings for annotations.

9.1.1

Enhancements

This release may contain protection enhancements not described here.

Changes

Updated the DashO Gradle Plugin to 3.2.1 with support for the Android Gradle 3.2.1 plugin.

9.1.0

Enhancements

Block Jumbling may now be optionally disabled in the Control Flow configuration.
Supports Block Splitting with APKs.
Added a Troubleshooting page to the User Guide.
Improved documentation about effective use of String Encryption with Unused Member Removal.
Made additional enhancements to the Android Wizard, logging, and the usability of the DashO GUI.

This release may contain protection enhancements not described here.

Changes

Updated the DashO Gradle Plugin to 3.2.0 with:
- Support for the Android Gradle 3.2.0 plugin.
- A fix for an up-to-date issue.
- A fix for a Kotlin issue.
- A fix for an Android Test issue.
- Additional minor improvements.
Updated the dex2jar tool to use version 27 of dx.
Updated to use ASM version 6.2.1.
The DashO GUI will now warn if a project has a ${gradleInput} input without any resolved classes.
The Android project wizard will no longer configure entry point classes to be renamed by default.
Updated to use apktool version 2.3.4.
The properties in the DashO .dox file are now sorted alphabetically by name.
Includes other minor changes to the way that the DashO wizard processes common libraries.

Fixes

Fixed two Android project wizard issues seen when updating the dasho.gradle file in some scenarios.
Fixed an issue with interactions between the various control flow options which caused project builds to fail under certain circumstances.
Fixed an issue where main methods were added as entry points by default on the Android project wizard.
Fixed an issue where the Android project wizard would list test configurations as build variants.

9.0.0

IMPORTANT NOTES:

This release includes substantial new features, changes to existing features, and the removal of certain deprecated features. Please review this changelog carefully, and see the Upgrades page in the documentation to learn more about upgrading to this release.

Support for Java 9 is no longer provisional, but support for Java Modules is still provisional.
Java 10 is now supported.
It is now easier to configure a build-time JDK that is independent of the JDK/JRE that DashO is run with. Projects created with earlier versions of DashO should be updated to use this feature. See the documentation for details.
A new feature, Block Splitting, was added to DashO's Control Flow options. Block Splitting splits blocks into smaller blocks and adds control flow logic. This feature is on, by default, when Control Flow is enabled, even on existing projects.
PreEmptive Analytics features have been removed.
- Projects using PreEmptive Analytics code annotations or annotation attributes will encounter a compile-time error (when compiled with the updated lib/dasho-annotations.jar). References to these elements must be removed from the source code.
- Projects using PreEmptive Analytics virtual annotations will error at build time. Opening these projects within the DashO GUI, and saving, will automatically strip them of the affected settings.
Quick Jar Mode has been removed. Quick Jar projects will automatically be converted to Advanced Mode projects.
- The obfuscate-jar Ant task has been removed and will no longer be recognized.
Ant-based configuration of build settings is no longer supported. Nested elements of the obfuscate task will no longer be recognized, and the project attribute of the obfuscate task is now required.

Enhancements

You can now run DashO with the Java 9 or Java 10 JRE, DashO can process Java 10 classes.
It is now possible to specify the JDK used to build a project in the DashO project configuration. This is presented as Include JDK on the "Input - Support" page of the GUI, and is the preferred way to locate the runtime libraries.
A new feature, Block Splitting, was added to DashO's Control Flow options.
Tamper Checks can now reference trusted certificates in addition to signing certificates to enable support for Google Play App Signing.
Improved handling of dead code in inputs for greater Kotlin compatibility.
Java Modules (.jmod) can be added to the support classpath.
Improved call tree traversal for features introduced in Java 9.
Improved computation of stack-map frames allowing DashO to process classes built with a more recent version of Java than that which DashO is run on.
The wizard will now warn before overwriting a file.
Double clicking or pressing enter when an entry is selected in most of the list/tree editors in DashO will display the properties editor.
Include and exclude rule configuration is now done exclusively via dialogs, rather than through in-page fields. The dialogs will appear automatically when new rules are added via the "New" buttons on the side of the UI, or when clicking the new "Edit..." button in the UI. This same UI workflow has been applied to the Input and Property pages, as well.

This release may contain protection enhancements not described here.

Changes:

Support for Java 9 is no longer provisional; support for modules is still provisional.
The Append current Java runtime and Use Classpath from Environment options are deprecated. Using these options will cause an error when running DashO in Java 9 or later, and will generate a warning when running DashO in Java 7 or 8. The new Include JDK feature should be used instead.
The Java wizards now require a valid JDK location.
Automatic checking for updates is now enabled by default, even if you did not previously employ automatic update checking. You can disable update checks via the User Preferences dialog.
Signing will use the configured JDK to locate the jarsigner executable if no signing tool is configured.
DashO no longer supports appending the current runtime if running with an Apple or IBM JVM.
Updated to use ASM version 6.2.
Removed PreEmptive Analytics features.
Removed Quick Jar Mode. Existing Quick Jar projects will automatically be converted to Advanced Mode.
Removed the obfuscate-jar Ant task, and Ant-based configuration of build settings.
Removed default Java heap initial and maximum sizes from dashogui[.bat], dashocmd[.bat], premark[.bat], tokengenerator[.bat], and the native launcher configuration.
The merge attribute on <runtime> is now ignored. Shelf Life runtime classes will be merged into output whenever Shelf Life Checks are injected.
The Injection UI is now named Checks.
The jce.jar and jsse.jar properties have been deprecated, and cannot be used in some configurations.
The dasho.java.version property has been deprecated.
DashO will no longer use a single underscore (_) or var as an identifier when renaming.
The wizard will no longer merge settings with project files that already exist. It will now prompt you to either overwrite the existing file or choose a different one.
Updated the DashO Gradle Plugin:
- v3.1.1 with a fix for the Illegal reflective access warnings and -DDISABLE_DASHO.
Using a final field as a Check or Response action will cause an error, and using a final field as a Response source will generate a warning.
The navigation tree in the main GUI window is no longer resizable.
Removed navigation tree search.
Removed the up and down arrows from most panels which previously allowed reordering of entries.
Removed the readme file.
If String Encryption is enabled, DashO warns when it detects string concatenation that passes constants in bootstrap method arguments. This is currently unsupported by string encryption.

Fixes:

The Android project wizard has been updated to look for Kotlin class files in additional locations to support version 3.0.0 and later of the Android Gradle Plugin.
Fixed native method handling in call tree traversal.
Improved license checking under concurrent build scenarios.
Fixed a file browsing issue on Windows.

8.5.0

IMPORTANT NOTE: With the DashO Gradle Plugin v3.1.0, obfuscation is now enabled, in Android builds, by the standard minifyEnabled setting. The disabledForBuildTypes and disabledForBuildVariants settings can no longer be used.

Enhancements:

File > Download Sample Projects was added to allow quick access to the samples.
Method call removal now supports removing non-void-return methods.
Documented how to use method call removal to remove Android logging calls.
Improved usability of file browsing dialogs in the DashO GUI.
A default editor (notepad.exe on Windows or TextEdit.app on macOS) is now used when viewing the project and reports.
Added support for generating a ProGuard-compatible map file when renaming classes.

Changes:

The samples have been moved online and are no longer included with the DashO installation.
Improved organization of GUI documentation.
Wildcard class matching for method call removal is deprecated.
The <obfuscate-jar> task, in the Ant integration, is deprecated.
Updated the DashO Gradle Plugin:
- v3.1.0 with support for the Android Gradle 3.1.0 & 3.1.1 plugins and which uses minifyEnabled instead of disabledForBuildVariants.
- v3.0.3 with the generateProGuardMap configuration option.
Includes apktool-2.3.3.
Includes dex-tools-2.1-nightly-28.

Fixes:

Globally Excluded classes are now listed on the Method Call Removal screen.

8.4.0

IMPORTANT NOTE:
PreEmptive Analytics has been deprecated. Injecting Instrumentation and/or configuring Checks (or Responses) to send messages will generate a warning. These features will be removed in a future version of DashO.

Enhancements:

Provisional support for Java 9.
Improved installation process with platform-native installers. (Launching DashO under Java 9 requires additional steps.)
Improved command line documentation.
The Android project wizard now handles Build Variants (Flavors / Types).
Improved Android SDK lookup in the project wizard.
Improved Android wizard documentation.
Included a reference to the DashO-GameOfLife sample.

Changes:

Running the DashOPro.jar directly now invokes the DashO CLI. The DashO GUI can be launched from the Start menu or Launchpad, or by running the dashogui script.
A warning is issued when injecting Instrumentation.
A warning is issued when configuring Checks (or Responses) to send messages.
A warning is issued when injecting Tamper Checks into library projects.
An error is issued when a multi-release jar is an input.
New messages and build warnings for out-of-date software.
Updated to use ASM version 6.0.
Updated the DashO Gradle Plugin:
- v3.0.2 with the disabledForBuildVariants configuration value, the buildVariant user property, and a fix for Multidex builds.
- v3.0.1 with an enhancement for includeAsInputs.
- v2.3.4 with a manifest processing fix.
Includes apktool-2.3.1.
Removed the sendofflinedata script.
Removed redundant man page documentation.
Removed Android check-telemetry sample.

Fixes:

Improved the error message when attempting to launch the DashO UI with a headless JRE.
Fixed an issue with unusual but valid exception range table entries in input bytecode.

8.3.0

Enhancements:

Added a Kotlin Android sample and documentation.
Added an Android check-telemetry sample.
Improved the APK wizard so that unused classes will be removed by default.
Improved the UI splash screen.
Minimal support has been added for inputs and dependencies containing a Java 9 module-info.class file.
Lucidator supports decoding stack traces which contain module information.
Added some internal Kotlin specific rules to ease configuration when obfuscating the Kotlin runtime.

Changes:

Try/Catch Control Flow will no longer add Exception classes for classes excluded globally from obfuscation.
Updated the DashO Gradle Plugin:
- v3.0.0 with support for the Android Gradle 3.0.0 plugin.
- v2.3.3 with improved handing of includeAsInputs.
Includes apktool-2.3.0.
Updated the PreEmptive Analytics API to v7.6.2.
Removed the --noSplash option from dashogui.
Removed the PreEmptive Analytics samples.

Fixes:

Fixed a processing error with internally defined annotations.
Fixed the Automatic setting on Make Public to handle accessibility changes due to the renaming prefix.
Fixed a font issue during registration.
Fixed an error with Try/Catch Control Flow seen when a non inner class's name contains a $.
Fixed an issue when searching for included Java runtime packages in the WAR wizard.
Fixed an ArrayIndexOutOfBoundsException issue when optimizing some methods.
Fixed an issue where checking for updates while offline may mark the license as expired.

8.2.0

This release of PreEmptive Protection DashO includes new Root Checking capabilities, support for Android-O and Kotlin, and other enhancements, changes, and fixes.

Enhancements:

Added the ability to inject Root Checks (@RootCheck, @RootResponse), with new code annotations and a new user interface. A sample project is provided.
Supports Android-O.
Supports Kotlin.
Added search capability to the User Guide.
Improved performance when processing sets of related interfaces.
Supports APK Signature Scheme v2 by allowing the use of apksigner when signing outputs.
User properties can now be used in the additional arguments when signing output.
Passes signing passwords via the environment instead of command line.
The Android project wizard recognizes configured intents in resource xml files (as used by static shortcuts) and configures those activities as non-renameable.
The Android APK project wizard attempts to find Android's build-tools directory to ease configuration of signing and aligning the output APK file.
Runtime accessibility of sources and actions specified for injections is now checked as part of the build.

Changes:

Updated the DashO Gradle Plugin to v2.3.2.
A warning is issued and nothing is injected when @ReportCaughtExceptions or @ReportThrownExceptions is specified but is not configured send a message nor perform an action.
A warning is issued and nothing is injected when @ReportUncaughtExceptions is specified but is not configured to send a message nor perform an action nor ignore the exception.
A warning is issued when using the exit action while injecting checks into Android.
Updated to use ASM version 5.2.
Interface implementation checking now supports the Ignore Missing Methods option.
Includes apktool-2.2.3.
Quick Jar mode is deprecated and will be removed in a future release of DashO. Users will be prompted to convert their projects.

Fixes:

Fixed an issue where invalid recursive interface definitions would cause an unhandled error in DashO.
An error is issued when an extended class or implemented interface can't be found, even if Ignore Missing Classes is enabled.
Improved the warning message when there is an issue processing an XML file for renaming.
Fixed UI issues when selecting output locations on macOS.

8.1.0

Enhancements:

The project wizard now outputs warnings to the Problems tab.
The War project wizard will automatically exclude some standard frameworks from being added as entry points.
String decrypters are now generated and used on a per-jar basis, by default, for multi-jar projects.
A properties file can now be passed on the command line via --properties (filename) to provide the values for properties used in the project's configuration.

Changes:

The level and number of string decrypters both now default to 2 in the .dox schema.
All decrypters for string encryption are now added to generated anonymous static inner classes. Decrypter Class configuration is now used to specify the containing outer classes.
The optional Constant Pool Tag is now embedded as custom class attribute.
Updated the DashO Gradle Plugin
- v2.3.0 with support for the Android Gradle 2.3.0 plugin and which utilizes the new --properties command line argument.
- v2.2.1 with support for a customized transform name.
Includes apktool-2.2.2.

Fixes:

Fixed an exception when processing Spring constructor arguments under certain circumstances.
The project wizard will log a warning and continue processing .war and .jar files after errors reading metadata.
Fixed an issue where a recursive property expansion error would inaccurately occur.
Fixed an issue where string encryption could, by altering the order of events during static initialization, cause incorrect behavior, under certain conditions.
Fixed an issue with abstract method implementation resolution that could inappropriately stop the build.
Fixed an issue where the optional Constant Pool Tag did not appear in the final output classes.
Fixed the ${dasho.java.version} property value when running DashO with Java 8.

8.0.0

This release of PreEmptive Protection DashO includes a wide range of enhancements, changes, and fixes. One major new feature is the ability to inject Debug Checks that can detect and respond to debugging at runtime. This release also includes a few backwards-incompatible changes, including that the minimum-required Java version is now 1.7. Please review the Changes section carefully, before upgrading.

Enhancements:

Added the ability to inject Debug Checks (@DebuggingCheck, @DebuggingResponse, @DebugEnabledCheck, @DebugEnabledResponse), with new code annotations and a new user interface.
New Tamper and Shelf Life UI screens.
The User Guide is now in an easy-to-read HTML format.
Lucidator now provides a command-line mode and ships with DashO.
A new map file conversion tool: ConvertMap.jar.
Added an Android debug check sample.
Updated the injected code annotations and virtual annotations to include a customDataSource element which replaces @PropertySource.
Improved logging of injected code.
Improved the Android project wizard.

Changes:

DashO now requires a 1.7 JVM or higher, to run.
Changed product name from DashO to PreEmptive Protection - DashO.
The DashO GUI now saves modified projects before building.
Ant-based configuration of .dox files is deprecated.
DashO builds now stop immediately if an error is encountered. Existing projects expecting output from DashO after errors will need to be updated to fix the errors.
The HALTONFIRSTERROR global option has been removed, as its behavior is now the default. The option will be silently ignored for existing projects.
The PRE_7_0_EXIT_BEHAVIOR global option has been removed. A warning will be emitted for existing projects using this option.
The .dox configuration format has changed. Opening an older project file in this new version of DashO will perform a one-way migration of the project file.
- The <instrumentation> section has been moved under a new <injection> section.
- @TamperCheck and @TamperResponse virtual annotations are now under new <tamperCheck> and <tamperResponse> sections.
- @ExpiryCheck virtual annotation has been replaced with the new <shelfLifeCheck> section.
- @ExpiryDate, @WarningDate, @StartDateSource, @ExpiryPeriod, @WarningPeriod, and @ExpiryTokenSource virtual annotations have been replaced with attributes on the new <shelfLifeCheck> element.
- @SignerInfo virtual annotation was replaced with <signerInfo> inside the new <tamperCheck> section.
Lucidator output has been changed to better mimic actual stack traces, rather than the prior report-style output.
The Instrumentation UI has been updated.
Method-level virtual annotations can no longer be applied at the class level.
The @PropertySource annotation is deprecated and replaced with the per-annotation property customDataSource.
The @SignerInfo annotation is deprecated and replaced with properties inside @TamperCheck.
The @ExpiryCheck annotation has been renamed to @ShelfLifeCheck.
The @ExpiryDate, @WarningDate, @StartDateSource, @ExpiryPeriod, @WarningPeriod, and @ExpiryTokenSource annotations have been deprecated in favor of properties of the new @ShelfLifeCheck annotation.
The @ReportThrownExceptions and @ReportCaughtExceptions annotations will emit build warnings if the injection site has no throw statements or catch blocks, respectively.
The @TamperCheck and @TamperResponse code annotations' response attribute is now an enumeration.
The @TamperResponse code annotation now requires the source attribute to be set.
Setting the probability to 0 in a Tamper Response now disables the response, instead of triggering it every time.
A Tamper Response with an incorrectly configured probability will generate a build error.
A Tamper Check with no valid action, response, or message will generate a build error.
Checks, responses, and code injection virtual annotations that are configured but unused during injection will produce a build error. Other unused annotations will produce a build warning.
The Android Ant project wizard was removed.
The Android project wizard now defaults Make Public to Automatic.
The reflection report no longer includes classes from the merged PreEmptive Analytics runtime.
The renaming map file will now contain all classes, methods, and fields processed by DashO and not just ones which were renamed.
An error will be output when a renaming input map contains a new name for a class, method, or field which is configured as non-renameable.
Updated to use ASM version 5.1.
Includes apktool-2.2.1.

Fixes:

The incremental renaming report no longer includes the globally excluded classes.
Fixed the probability calculation for injected responses.
Tamper Response will now send a message (when configured) even when response is set to none.
Tamper Check no longer causes a validation issue on Android devices when using an old version of the Android build tools (e.g. v19.1 or v20.0) and a custom private getApplicationContext() method.
Fixed an exception when processing configuration files under certain circumstances.
Fixed an exception when processing the athrow bytecode under certain circumstances.
Direct APK processing no longer compresses assets, which prevented some apps from working properly.

7.11

Changes:

Updated the DashO Gradle Plugin to v2.2.0, with support for the Android Gradle 2.2 plugin.
Updates to the PreEmptive Analytics API (v7.6.0).

Fixes:

DashO will again rename input classes which are referenced by support classes via generics.
The output jar's manifest entry set in the UI will again properly save to the config file.
Shelf Life expiration messages, when starting their own session, now properly send to a custom endpoint.
The FeatureStop virtual annotation again defaults to end of the method.

7.10.0

Changes:

Updated the DashO Gradle Plugin to v2.1.0, with support for the Android Gradle 2.1 plugin.

7.9.0

Changes:

Updated the DashO Gradle Plugin to v2.0.0, with support for the Android Gradle 2.0 plugin.
Updates to the PreEmptive Analytics API (v7.5.0).
Includes apktool-2.1.0.

Fixes:

Input classes which are used in methods declared by support libraries will no longer be renamed(rare).
CustomAnnotations defined and used in inputs can now be removed without error.
Will not rename a method in a parent class if it implements a non-renameable interface method in a sub class.

7.8.0

Fixes:

Renaming will no longer cause a method name conflict that occurred in certain cases.
The Android Gradle Project Wizard will warn instead of stop when encountering resource parsing issues.
The Android Gradle Project Wizard looks at the new "merged" resource directory.

Changes:

Updated the DashO Gradle Plugin to v1.8.0, with support for the Android Gradle 1.5 plugin.
Includes apktool-2.0.2.
Includes dex2jar-2.0.
A full path is now selected when choosing the Build Tools Directory for APK outputs.

7.7.0

Enhancements:

Added an "APKTOOL_FRAMEWORK_DIR" property to allow custom frameworks to be used when DashO is directly processing APK files.

Fixes:

Fixed possible ArrayOutOfBounds issue when processing InvokeDynamic calls in Java 8.
Fixed: WARNING: Could not open/create prefs root node Software\JavaSoft\Prefs at root 0x80000002 (on windows).
Fixed command line documentation.
Fixed a regression in some licensing scenarios.

Changes:

Updates to the DashO Gradle Plugin (v1.7.0).
Renamed the samples for Android.

7.6.0

Enhancements:

Documentation improvements in multiple areas including incremental obfuscation, annotations, APK support, and the readme.
Added an Android tamper check sample.
Improved UI handling of default and generated company id's used for instrumentation.
Lucidator will now find the correct stack trace entries when given output lines which start with a prefix. (e.g. The "[java]" prefix output by Ant).

Fixes:

Better error handling when attempting to launch the UI in a headless environment.
Removed extraneous User Properties output by the Android APK wizard.
Application and company information will now be injected with the non-dialog AddUncaughtExceptionHandler instrumentation annotation.
Cleaned up file locks left after running the project wizard.
Copying a duplicate non-class file, via Auto Copy, to an output jar now causes a warning instead of a fatal error.

Changes:

Updates to the PreEmptive Analytics API (v7.4.2).
Includes apktool-2.0.1.
Updated to use ASM version 5.0.4.
Updated End User License Agreement to correspond to changes made for Analytics products.

7.5.3

Changes:

Updates to the DashO Gradle Plugin (v1.6.0).

7.5.2

Fixes:

Fixed an issue parsing some InvokeDynamic constants created by predicates in Java 8.

Changes:

Updates to the PreEmptive Analytics API (v7.4.1).
Updates to the DashO Gradle Plugin (v1.5.0).

7.5.1

Changes:

Updates to the DashO Gradle Plugin (v1.4.1).

7.5.0

This release includes support for direct input and output of Android APK files. There is also a new Android project wizard to help set up an APK-based project.

Other Enhancements:

Improved processing time for large classes.
Allows the configuration of multiple jar files in a single library entry point.
New <globalProcessingExclude> functionality allowing a single configuration location to exclude classes or packages from all obfuscation.
Ability to generate a Company ID for PreEmptive Analytics instrumentation.
Improved documentation relating to Tamper Detection.
New documentation on migrating Android applications from Eclipse (Ant) to Android Studio (Gradle).

Fixes:

Signing UI now enables the configuration necessary for Tamper Detection, when signing is turned off.

Changes:

Reorganized the Output UI.
Includes dex2jar-0.0.9.15.
Includes apktool-2.0.0RC3.
Updated to use ASM version 5.0.3.
Updates to the DashO Gradle Plugin (v1.4.0).
Updates to the PreEmptive Analytics API (v7.4).

7.4.4

Fixes:

Fixed a devirtualization optimization issue with interface default methods which use lambdas in Java 8.
Fixed a renaming issue with InvokeDynamic constants which reference instance methods in Java 8.

7.4.3

Fixes:

Fixed issues processing method handles and bootstrap attributes in some cases compiled with Java 8.

7.4.2

Enhancements:

Added support for Android projects created using Android Studio 0.8.1/0.8.2 (beta) to the project wizard.
Improved Android project wizard error messages.
Updated CEIP reporting to differentiate between Ant and Gradle usage.

Fixes:

Added support for identifying entrypoints referenced in the resource files of Gradle projects to the Android project wizard.

Changes:

Changes: in the Android-Gradle project wizard to allow referencing "android-L"(preview) for testing.

Updates to the DashO Gradle Plugin (v1.1.1).

7.4.1

Enhancements:

Added support for the new Android Gradle Plugin IDs, introduced in v0.12.0, to the project wizard.

Changes:

Updates to the DashO Gradle Plugin (v1.1.0).

7.4

Enhancements:

Added support for the Gradle build environment (http://www.gradle.org/) for standard Java builds and for Android (http://tools.android.com/tech-docs/new-build-system).
Updated the Android project wizard to support Gradle build environments.
Updated the AndroidPA sample to work with Gradle and Android Studio.
Added support to update the names of renamed classes referenced in JNLP files.

Fixes:

Non-class files can now be copied to locations relative to a parent folder when outputting a jar file.
A potential NullPointerException when processing JNLP files will no longer occur.
Fixed a line-ending issue on *nix.
The SendOfflineData scripts work properly.
Paths that start with with forward slashes display properly in the Input and Support UIs.

Changes:

The DashO installer no longer allows selection of individual components.
Updated End User License Agreement to correspond to changes made for Analytics products.
Updates to the PreEmptive Analytics API (v7.3.1).

7.3

This release includes support for Java 8. Java 8 specific enhancements are as follows:

Reading & Writing the updated class format.
Renaming and removal of:
- Methods created by lambda expressions (e.g. (x,y)->x+y;).
- Methods referenced by method references (e.g. MyClass::myMethod).
- Static methods in interfaces.
- Default methods in interfaces.
Renaming repeating annotations.
Option removal of the MethodParameters attribute (Controlled by "Unknown Attributes").
Removal of TypeAnnotations attributes.
Support for classes using new Java 8 functionality such as Base64 encoding and the Date & Time API.

Other Enhancements:

The windows shortcut will attempt to launch DashO as an executable jar when javaw.exe is not on the path.

Fixes:

A potential Verify Error with the Stack Map Table in Java 7 will no longer occur when working with methods > 32K and Try/Catch Control Flow is turned on.

Changes:

Updates to the PreEmptive Analytics API (v7.3).

7.2.2

Fixes:

A potential NullPointerException will no longer occur during obfuscation when DashO places a LookupSwitch or TableSwitch as the last bytecode in an exception block which ends the method.

7.2.1

Enhancements:

Android Quick Start section added to the User's Guide.
Hibernate support for many-to-many and one-to-one mappings.

Fixes:

Fixed processing of Hibernate configuration files where the package name was prepended to existing fully qualified names.
DashO will not choose a conflicting method name for a superclass private method if there is an abstract subclass which declares but does not implement an interface method.
DashO GUI no longer enables String Encryption when not specified in the configuration file.
DashO no longer expects a bean definition in all Spring XML files.
Running multiple DashO instances concurrently will no longer result in the loss of registration information.

7.2

Enhancements:

Several enhancements to the PreEmptive Analytics API client for Java/Android
- Android supports offline storage of analytic messages.
- Added configurable retry timer in case network connectivity is lost.
- Support for TimeToLive functionality allowing expiration of offline stored messages.
- Support for deleting old messages from cache if there is no space for newer messages.
- Support for omitting Personally Identifiable Information(PII) from analytics messages.
- Added a generated and persistent unique Application Instance ID when none is provided to the Java or Android APIs.
Added keywords "All" and "None" to the debug and attribute types in the DashO configuration file.
Multiple FeatureTick, FeatureStart, and FeatureStop messages can be attached to the same method using Virtual Annotations.

Fixes:

The PA API removes invalid XML characters from strings.
The PA API now sends the correct Message Group header with offline messages.
It is now possible to remove debug information when running 'ant obfuscate debug' on an Android project.
Fixes failure when a SpringBean's parent classes are in the support libraries.

Changes:

The PA API will now retry sending messages periodically.

7.1.1

Fixes:

The Android project wizard now turns on member renaming.

7.1

This release includes significant improvements to Spring framework support. Spring Beans can now be configured as SpringBean special classes. If you currently use DashO to obfuscate your Spring projects, we recommend you use this new feature. The new project wizard will help you setup the new SpringBean special classes. Documentation has been updated explaining Spring Support in great detail and a new sample application was added to demonstrate the support. The following areas of spring are supported:

Renaming properties.
Renaming entry point methods (init-method, destroy-method, factory-method, lookup-method, replaced-method).
Renaming Constant Fields using util:constant or FieldRetrievingFactoryBean.
Renaming classnames passed as values.

Other Enhancements:

Support for v22 of the Android SDK.
Improved documentation on the "copy non-class files" feature.
Better visibility of configuration errors.
Allows the preservation of jars with no remaining classes.
Better Error handling with project file read/write issues.

Fixes:

Class files with more than 32767 constants are now supported.
The renamed classes/methods listed in the results will no longer temporarily disappear when selecting another entry.
The renamemembers, renameclass, and regex attribute are supported in entrypoints defined in an Ant task.
Menu placement on OSX when running Java 1.7.
Renaming Exclusion issue with inner classes.
Fixed incorrect error during incremental renaming.
Fixed issue where incremental renaming can cause new method overrides.
Fixed placement of added exception classes in unmerged output.
Renaming will not choose a name which conflicts with an existing support class.
Better error handling with jars with invalid entries.
Virtual ReportException annotation now send messages by default.
Fixed reference to LEAVEDEBUGGINGINFO global option in documentation.

Changes:

Instrumentation Activation is no longer necessary.
Runtime Intelligence re-branded to PreEmptive Analytics. If you were using ri-*.jar files, they have been renamed to pa-*.jar.

7.00

The 7.0 release includes a variety of enhancements and fixes, including one enhancement that introduces backwards-incompatibilities in certain build scenarios. Please read this document carefully before upgrading, and refer to this summary, the user guide, or our support options if you encounter any issues.

Improved reporting of errors and warnings

This version of DashO introduces a consistent set of rules and behaviors for reporting build-time issues, which will make it easier to integrate DashO into an automated build process, and will improve the accuracy of the build results. Specifically:

DashO builds can now be configured to halt as soon as any error is encountered, rather than trying to proceed with the rest of the build, via the HALTONFIRSTERROR option. (The default behavior is still to try to continue, to facilitate debugging.)
The exit code of DashO and/or the <dasho> Ant task will indicate the number of errors (up to 255) encountered before the build halted or completed. Before, the exit code would always be 0 (meaning "success"), even after an error, unless the build was unable to complete. You can configure DashO to use the old exit-code behavior via a project-specific setting. ("Use exit behavior from DashO 6.x and earlier" UI checkbox or "PRE_7_0_EXIT_BEHAVIOR" project file setting).
Error output will always be on STDERR; before this release errors were logged to STDOUT. Warnings will continue to be logged to STDOUT. (The UI will continue to show all output within the UI.)
Some Errors and Warnings were converted to Fatal Errors (i.e. the build halts immediately). For example, if a map file for String Encryption was specified, but can't be found at build time, the build will halt immediately and report an Error.
Many Warnings have been converted to Errors. In general we are treating any condition in which the project file instructed DashO to take some action, but it was unable to take that specific action, as an Error. Most of these changes were in the instrumentation features, and cover cases where a required field was missing for a given message type. Some of these changes affect all parts of the build, such as when an input file is specified in the project but is missing from the filesystem.

The combination of these changes can result in builds that fail where they didn't before, e.g. if a previously-reported Error wasn't causing a non-zero exit code, or if a Warning was converted to an Error and now causes a non-zero exit code. In general, we suggest you investigate any errors reported by DashO 7.0 and see if they are truly issues with your build; if so, fixing them may be the best course of action. If you feel that they are not truly errors, or that they are not worth fixing right away, you can use the "Use exit behavior from DashO 6.x and earlier" checkbox or the PRE_7_0_EXIT_BEHAVIOR project file setting to get the old exit behavior. (Please also notify support if you believe the error is not truly an error.)

Other Enhancements:

It is now possible to provide custom implementations of the encryption/decryption methods for String Encryption. (Not recommended in most situations.)
Added a BYPASSDASHO option to make it easier to "turn off" DashO processing (i.e. obfuscation and/or instrumentation) but still have DashO copy the inputs to the output location
The input class list now automatically refreshes when adding or removing inputs.
Made installer improvements and fixed a minor bug to provide full support for Windows 8 as a runtime platform for DashO.
The Android project wizard now identifies Fragments as entry points, and does a better job identifying entry points on custom views.
Build run from the UI will now run much faster (i.e. the same speed as builds run from the command line or Ant).
Added a code sample to demonstrate instrumentation (for PreEmptive Analytics) of Android applications.
Internal annotations can now be renamed.

Fixes:

The values of class or enum attributes used in Annotations are renamed to match the renamed class or enum.
Interface methods which are not called directly on the interface but are called on implementing classes will not be removed.
The LocalVariableTable and LocalVariableTypeTable debug attributes are now kept when requested (except for methods affected by control flow obfuscation).
The obfuscate Ant task now supports the following attributes and elements:
- The <methodcallremoval> element inside <obfuscate>
- The <attributes> element inside <removal>
- The path attribute on <report>
- The sendMessages, supportOffline, and fullData attributes on <instrumentation>
Using private methods in Android for sources or actions from Runtime Intelligence will no longer generate Verify Errors on the Android device
Fixed an exception when re-writing classes modified by Aspect4J.
Android Runtime Intelligence no longer uses the current thread to determine the information needed for ApplicationStart. The android.os.StrictMode.ThreadPolicy can prevent retrieving host information if the application starts on the UI thread.
Fixed an issue with obfuscation of projects located on network drives referenced by UNC paths.
Fixed an issue launching DashO on Windows XP.
Unchecking 'Selects Class' inside a renaming exclusion rule works properly again.
The "ris.log.messages" system property is supported when testing Java applications.
Unchecking 'Rename-Members' for an Android special class type properly turns off method renaming.
Fixed character encoding in XML documents.

6.12

Enhancements:

Improved application startup time for instrumented applications.
The 'Removal' feature now supports exclusion rules for classes, methods, and fields.
The 'Make Synthetic' feature now supports exclusion rules for methods and fields.
Save-As will now prompt before overwriting an existing .dox file.
Several new attributes added to the DashO Ant tasks
- error: Allows for error output to be placed in a different file than standard output.
- outputProperty: Allows for standard output to be placed inside an Ant-accessible property.
- errorProperty: Allows for standard error to be placed inside an Ant-accessible property.
- resultProperty: Allows for the return code to be placed inside an Ant-accessible property.

Fixes:

The output jar files contain proper directory entries when "Files Only" is unchecked.
The ExceptionHandler class is now properly merged when using UncaughtExceptionHandler instrumentation.
Fixed the error when processing "void.class" as the default class element in an annotation.
Fixed issue with overriding MakeSynthetic settings from an Ant script.
The output file specified in the Obfuscate Ant task, will now contain errors regarding invalid .dox files.
Fixed issue where Try/Catch Control Flow would occasionally cause problems in methods that already contain exception handling.

Changes:

The New Project Wizard now launches automatically on startup.
The New Project toolbar button now launches the New Project Wizard.
Runtime Intelligence will now send a hashed windows serial number.
DashO will now produce Error messages (instead of Warning) when a specified .jar is missing or it cannot locate a specified entrypoint.
The Instrumentation UI is now disabled when not activated, and instrumentation is prevented for un-activated DashO installations If your build begins to fail with an error about activation, please contact support.

6.11

Enhancements:

Support for Android 4.1 - Jelly Bean.
Support for Android SDK Tools v20.
Enhanced control flow obfuscation.
Better support for renaming Android classes. The Android Manifest.xml is updated with new names.
Android project wizard automatically includes support libraries from device specific targets.
Support for removal of method calls (e.g. to strip-out logging).
Configurable off-line storage area for instrumentation messages.

Fixes:

DashO will automatically not rename the CREATOR field of an android.os.Parcelable implementation.
Subsequent runs of the Android project wizard properly overwrite previous configurations.
Fixed the VerifyError, in Java 7, when using Control Flow on a constructor with a ternary operation in its super call.
Updated the sendofflinedata scripts to reference the correct jar file.

6.10.3

Enhancements:

String encryption results can be reproduced for subsequent incremental runs.
More configuration options for the placement of decrypter methods.
Added support for packaging support libraries for Android applications.
Enhanced error handling when parsing war files.

Fixes:

Taglib functions with no parameters no longer cause parse issues.
No longer adds abstract method signatures for non-implemented interface methods in abstract java classes.
Context.xml is no longer removed from the META-INF directory when working with war files.

Changes:

The library wizard will set Make Synthetic to "Only private and package" by default.

6.10.2

Enhancements:

Android Wizard now supports applications built using Android SDK (tools) version 14 and above.

6.10.1

New Features:

Members can be marked as synthetic to hide them from some decompilers.

Enhancements:

Support for classes compiled with Java 1.7
Input and support file list flags items that cannot be read or contain property errors.
Added the following new built-in properties:
- ${dasho.basedir} : the absolute path of the project's directory
- ${dasho.file} : the absolute path of the project file
- ${dasho.project} : the name part of the project file, no extension
- ${dasho.java.version} : the JVM version DashO detected; currently it can hold the values "1.5", "1.6", or "1.7"

Fixes:

Wizard creates project with blank name when input item starts with a single period and has no extension.
Incorrect icon used in class trees for package-protected constructors.
Rename collision when not removing unused classes and using randomized class identifiers.

Changes:

The ${configdir} property is deprecated and replaced with ${dasho.basedir}.

6.9.3

Fixes:

When sequential string constants passed to method alternating strings not encrypted

6.9.2

Fixes:

Using the --nosplash command line option causes a NullPointerException. This also affected the Eclipse plugin.
Dates sent in Runtime Intelligence messages not normalized to Gregorian calendar
DashO registration fails when used with proxy

6.9.1

IMPORTANT NOTE:

DashO now places its license file in a directory that is accessible to users without administrative privileges. You will have to re-register DashO after upgrading to 6.9.

Enhancements:

String Encryption enhancements. Up to ten string decrypters methods can be added to the application. The level of obfuscation is adjustable from 1 (simple/fast) to 10 (complex/slow).
TamperCheck is now supported on Android applications.

Fixes:

Inflater closed error when derived class appears before base class in a jar used as a library entry point
Relative paths to keystore causes FileNotFoundException
TamperCheck placed on static method causes exception at application runtime
Java based installer fails on the shortcut screen when using 64 bit Java
Spurious missing class when instrumenting and no entry points have been defined
Removal report listed all removed fields on one line

Changes:

DashO now requires the Android Toolkit version 10.

6.8.1

Enhancements:

The New Project Wizard has be updated to work with version 7 and up of the Android SDK. The wizard now requires this version or higher of the SDK.
New system properties to control Runtime Intelligence features: ris.support.offline and ris.full.data.
Removal report displays the actual entries point used by the entry point rules.

Fixes:

The Ant task's <removal> did not support the classes attribute.
Member renaming random check-box not loaded corrected from project file.
Incorrect method signature referenced for thread-based unhandled exception reporting.
Jar mode should use default attribute removal set rather than remove all attributes.
NullPointerException in Jar mode when an input jar does not contain a manifest.
In Jar mode if the manifest Main-Class attribute references an unknown class no warning message is generated.
static modifier omitted in reports and verbose output.
Class statistics incorrect when classes are removed.
Protected fields displayed as package protected fields in class lists.
Optimizer replaces string/class reference with string/string.
Abstract class without public/protected methods causes renaming errors.
Methods with certain nested interface patterns not reconstructed correctly.
References to non-primitive static field in an interface rebound to java.lang.Object.

Changes:

Runtime Intelligence off-line storage uses upper case version of application ID to prevent issues on platforms with case sensitive file systems.
Renaming report shows the top ten member identifiers sorted by frequency rather than only single character identifiers.

6.7.1

New Features:

Exception reporting for Runtime Intelligence.
- New features have been added to instrumentation to support the capture and reporting of exceptions at the global and method level. At the method level caught, uncaught, and thrown exceptions may be intercepted and information sent to the Runtime Intelligence portal for reporting. Global and thread uncaught exception handlers can be installed that allow the application user to enter additional information before sending the exception information. The following RI annotations have been added to support new features: AddUncaughtExceptionHandler; ReportCaughtExceptions; ReportThrownExceptions]; [ReportUncaughtExceptions].
Identifiers for class and member renaming can be assigned from a random source rather than using sequentially generated names. For backwards compatibility the default is to use sequentially generated names.

Enhancements:

Runtime Intelligence API support for J2ME and RIM Blackberry 4.5 and up.
The SourceFile attribute of classes can be set to an arbitrary value. The value can contain DashO properties that are expanded before the attribute is set.
The constant pool tag and the SourceFile tag can use information about the current class with the following dynamic properties:
- CLASS_NAME - the full name of the current class, including its package name.
- CLASS_SIMPLENAME - the simple name of the class, i.e. the class name without its package name.
- CLASS_PACKAGE - the package name of the class, including a trailing period. This will be an empty string for classes in the default package: use ${CLASS_PACKAGE:-} to ensure that the property will be expanded.
The new dynamic tstamp property can be used to add a date or time stamp value to file names or other values. When used as ${tstamp} the date is formatted using the default format for the locale. To control the output of the date format you can use ${tstamp[pattern]} where the pattern is identical to Java's SimpleDateFormat pattern.

Fixes:

Renaming error when unused classes not removed.

Changes:

Runtime Intelligence for Java applications now requires Java 1.5 or up for a runtime environment.
The <constantpooltag> tag has been moved from the top level to a <constpooltag> inside of the <output>. The old tag is migrated automatically.
The <renaming> tag has been modified. The options="onlynonpublics" value has been moved to the new <member‑options keeppublics="true/false"> sub-tag's attribute. The prefix="..." attribute has been refactored into various attributes in the new <class‑options> sub-tag. The old values are migrated automatically.

6.6.1

New Features:

Tamper checking and response. Verifies at runtime that the classes have been signed and verified with a given certificate. Response can be immediate or separated from the check. Responses include sending Runtime Intelligence messages, exiting the application, hanging the application thread, throwing errors or exceptions. Responses can be configured to use a probability of occurrence to provide unpredictable behavior to attackers.

Enhancements:

Improved memory usage in user interface with large input sets.
Improved string decryption time for Runtime Intelligence libraries.
Improved property dialogs for rule editors.
The New Project Wizard recognizes the Premain-Class and Agent-Class entries in manifests.
The Premain-Class and Agent-Class entries in manifests are now rewritten.
Runtime Intelligence messages now generate "binary info" to track related jars/library names and versions. Class and method names are automatically tracked with all RI message types.
New Shelf Life sample, authorized-app
The following RI annotations have been added to support new features: Binary, BinaryId, BinaryName, BinaryVersion, BinaryVersionSource, SignerInfo, TamperCheck, and TamperResponse.

Fixes:

Performance issues when opening class files.
Rules preview throwing exception for instrumentation rules.

Changes:

Menu of virtual annotations types has been converted into a tree of menu items broken down into functional groups.
Previews of rules runs on a separate, non-UI thread and disables the application while it is running.

6.5.2

Fixes:

Implementation of interface defined method not found when located in support class.

6.5.1

New Features:

Signing of output jars.

Enhancements:

Runtime Intelligence and Shelf Life support for Android 1.6 and up.

Fixes:

GUI generates messages to stderr from which when starting up on AIX.

Changes:

New option to allow the navigation tree nodes to be collapsed.
The default Shelf Life warning and expiration messages are displayed in a dialog box if the application has a Frame.
The jar containing the Ant Tasks has been renamed from ant-dashopro.jar to ant-dasho.jar. The old version is removed when antinstall script is run.

6.4.3

Fixes:

Relative paths to drag-and-drop files incorrect.

Changes:

Dialog and message generated for evaluations that indicate the obfuscated output will expired at a specified date.

6.4.2

Enhancements:

PreMark screen indicates an error when watermark uses characters not in the current encoding.

Fixes:

Exception when processing methods > 32k bytes long with switch statement near end.
Re-written taglib descriptor (TLD) files are blank.
Spring files - class references in org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean bean not re-written.
Command-Q on Mac causes application to be terminated without asking about saving changes.

6.4.1

New Features:

RI off-line mode. If the instrumented application cannot connect to the RI server, or has been configured to only run as an off-line application, the RI messages will be stored locally for later transmission. When communications with the RI server is restored the stored messages are transferred automatically in the background. For applications that always run off-line a command line tool and Java class are provided to transmit the saved messages on demand.
Controllable removal of unused classes. You can now control what should be done with unused input classes. This follows the unused method removal syntax: unused; unused-non-public; none. Classes that are removed are listed in the DashO report.

Enhancements:

Property editors have been added to interface items. To configure items in rule trees or lists right click on the item select Properties.
Debugging information can be selectively removed. The following types of debugging information can be selectively removed: SourceFile; SourceDir; SourceDebugExtension; LineNumberTable; LocalVariableTable; LocalVariableTypeTable.
Class file attributes can be selective removed by type. The following attributes can be removed: Exceptions; Signature; Deprecated; Synthetic; EnclosingMethod; RuntimeVisibleAnnotations; RuntimeInvisibleAnnotations; RuntimeVisibleParameterAnnotations; RuntimeInvisibleParameterAnnotations; AnnotationDefault; InnerClasses.
Type and modifiers as criteria. All include and exclude list can now specify the Java modifiers as part of the criteria. In addition, classes entries can specify the type of the class: interface; enum; annotation; class. These can be combined in the same manner as they used in source code, but can also include negation, such as !public.
Duplicate class warnings now indicate the locations of the classes in question. DashO will indicate which copy of the class is being used and which is being ignored.
Items from the class list can be dragged-and-dropped into the rules list to create rules.
Tool tips added to class list and the results list. The tool tips show the declaration of the item as it would appear in source code.
Merged output can now specify the autocopy option. This automatically copies non-class files from the input to the output. Non-merged output mode always performs the automatic copying of non-class files.
You can now control the location where the string encryption decrypter method is placed. This uses a selection system identical to that used in the rule trees.
String decrypter method changed so that it blends in better with the applications methods.
Improved string encryption so that identical strings are not encrypted to the same value.
Improved the shutdown time of RI instrumented applications that have messages that have not yet been sent to the server.
The ExpiryCheck RI annotation now supports the where property.
The screen layout on the Mac has been improved. Also integration with OS-X specific features has been added.
The toolbar can now be hidden via the Preferences dialog.
The following RI annotations have been added to support new features: EndPoint; OfflineMode; OfflineModeSource; OfflineModeSupport; OfflineModeSupportSource.
The New Project Wizard now read Castor and Ehcache XML files to determine entry points and these files are rewritten after obfuscation.
The New project Wizard's identification of 3rd party jars has been improved.

Fixes:

Rename exclusion list shows constructors, which are never renamed.
Class list is blank when input classes are recompiled and class list refreshed.
No way to specify custom RI endpoint/SSL in user interface.
Method override introduced when subclassing classes with package-scoped methods.
Start-up failure when running from a read-only Samba share when dasho.dat is read-write.
Annotation properties editor text fields look like they are read-only.
Disabled text in proxy settings editor has wrong background color.
Static values() and valueOf() methods in enumerations not preserved.
Unparseable XML file in input jar causes failure.
Changes: in control flow setting et. al. do not cause pop-up menu items to be enabled correctly.
Misleading message about merging runtime when no RI annotation specified.
readObjectNoData() method must be preserved in Serializable classes.
Wizard does not open created project file for WAR files.
When processing a WAR file output may not be corrected placed in WEB-INF directory.

Changes:

Controls on the interface that were used to configure rules, such as being a regular expression, have been removed. These have been moved to property editors.
When non-merged output is selected the RI runtime jar is now merged into an existing jar or directory. Previously the jar was copied over to output directory.
The excludes panel has been moved from the input to the remove part of the tree. No functionality has changed and the project file remains unchanged.
The -j/--jar and -o/-p/--output command line options have been removed. No substitute is provided.
The global options NOINDUCTSTATICS, RENAMENATIVECLASSES, and PREOBFUSCATED, undocumented options have been removed. No substitutes are provided.
The global option LEAVEDEBUGGINGINFO has been replaced with and is migrated to <removal><debug> element.
The New Project Wizard no longer generates entry points for values() and valueOf() methods in enumerations - the obfuscation engine now handles these correctly (See Fixes).

6.3.3

Fixes:

NullPointerException when rewriting class names in Hibernate files.

6.3.2

Fixes:

ArrayIndexOutOfBoundsException when String Encryption performed on class with very long strings.

6.3.1

Enhancements:

Control Flow obfuscation is now applied to methods that contain exception handlers and synchronized blocks.
Control Flow, String Encryption, and Optimization now use a combination of includes and excludes to determine methods to be obfuscated. A method must be on the list of included methods and not on the list of excluded ones.
- If the include list is empty it is equivalent to including all methods.
- If the exclude list is empty then nothing is excluded.
Preverification phase can now pass the -nofinalize, -nofp, and -nonative options to the preverifier executable.
When obfuscating a jar that has been signed the signing information is now removed. The jar will have to be re-signed after obfuscation.

Changes:

DashO reflection detection now reports on Class and Member methods that either take or return Strings since the obfuscated programs behavior could be affected by their use.
Constant pool entry can now be changed in evaluation versions of DashO.
In the evaluation version of DashO, the output program will expire at the end of the evaluation period. If the evaluation period is extended, you will need to run your DashO builds again to prevent your output from expiring.
If String Encryption is enabled but the include list is empty all classes will have their strings encrypted. Previously no strings would be encrypted.

Note for String Encryption:

Prior to the addition of the <excludelist> for String Encryption it was recommended that a regular expression negative lookahead pattern be used to exclude one or more items from String Encryption. For example:

    (?!com\.foo\.(Foo|Bar|FooBar)).*

The limitation of this technique was that the negative lookahead had to be last <includelist> entry and any entries following it may not work as expected since the actual pattern being matched is ".*" i.e. everything. If any of your projects contains regular expression of this type we recommend moving them to the list of excluded patterns rather than leaving them in the include list. If you choose to leave the expression in the include list your DashO project behavior will not change.

6.2.2

Enhancements:

Common UI elements that are localized by the JDK are now used by DashO.
Reflection detection now detects class names passed to javax.swing.UIManager.installLookAndFeel() and javax.swing.UIManager.setLookAndFeel().

Fixes:

NullPointerException when building a project from the GUI when reports are generated.

6.2.1

Enhancements:

Registration simplified so that only the serial number is required.

6.1.1

New Features:

Shelf Life: injection of expiration and expiration warning logic into an application. Expiration checking can be added through annotations in the code or via virtual annotations.
Added tokengenerator command line tool to create and print Shelf Life tokens.
Added <generate-token> and <print-token> Ant tasks to create and print Shelf Life tokens.

Enhancements:

All Ant tags now support the if and unless attributes. These operate in the same fashion as the attributes of Ant's <target>s.

Fixes:

RI attributes containing non-ASCII characters not properly encoded.
NullPointerException in New Project Wizard when reading Spring XML files with FactoryBeans that contain a targetObject property.
User interface not saving the setting of <premark>'s truncate attribute correctly.
Missing super interface classes eventually led to NullPointerException. Warning messages are now generated correctly, but DashO may still issue an error if the missing interface can not be ignored.
antconfig.bat failed when install directory contained a space.

Changes:

RI activation is required for injection of RI messages, but not required for editing instrumentation settings in the user interface.

6.0.3

Enhancements:

Verbose engine output setting propagated to execution of the preverifier as the -verbose command line option.
Debug engine output setting propagated to execution of the preverifier as the -verify-verbose command line option.

Fixes:

Backwards branch with uninitialized object verification error with control flow obfuscation with certain construction patterns.
Output from external programs is now flushed after the program terminates. This corrects problems with message sent to the console not being in the correct order.

Changes:

Output from the execution of the preverifier is not longer buffered, reducing memory requirements.

6.0.2

Fixes:

NullPointerException when determining reflected classes.
Preview of entry points with no children rules does not correctly highlight classes.
Ant Tasks default DashO home directory incorrect.

6.0.1

New Features:

DashO uses a new input model. Items to be processed are added as inputs rather than the classpath. Global exclusions no longer need to be configured for items in the classpath. DashO will automatically migrate project files created with earlier versions. It is recommended that you open these projects in the user interface and ensure the correct items were identified as inputs. Examine the previous global excludes and delete those related to supporting classes found on the classpath as the migration process does not remove these entries.
If no entry points are defined, the items in the input are examined to determine entry points from Main-Class entries in Jar manifests. If none are found, the input items are processed like library entries.
Jar mode projects can be converted to advanced projects by selecting File -> Convert.
Command lines now include --file-version which prints the version of the project files created by the release of DashO, i.e. 6.0.1. Note that this number may be different from the release version number.

Enhancements:

User interface elements that are used for setting file values now support drag-and-drop.
Class lists now contain all methods and fields present in the input, not just those found via traversal. This makes it possible to add these as entry points that might not be detected by DashO's engine.
The class lists are loaded when a project is opened.
Entry point panels now include the list of input classes. These can be used to added items to rule lists.
Table columns are sortable when the user interface is run under Java 1.6.
The table of user properties can be directly edited by double clicking on the name or value of the property.
The removal report's summary information has been simplified for easier reading. It now includes the count of input and written classes.
Tool-tips have been added to all elements in the main user interface.
Controls for reflection detection have been added to the jar mode options.
The serial number in the About dialog can now be copied.
The new project wizard tries to determine which jars to obfuscate in WAR files by skipping "well known" jar files.
If the --quiet option is used before --version on the command line only the version number will be generated.
Context information has been added to warnings about classes not being found.

Fixes:

Improved functionality of the user interface with various look-and-feels including the Java 1.6's Nimbus look-and-feel.
Duplicated information from reflection detection is now correctly removed.
Classes identified as entry points by reflection detection are now only loaded once.
NullPointerException when command line is used without project file or quick jar entries.
Refresh button/menu item enabled in new project.
Jar mode class list behavior does not match advanced mode when renaming off.
Bad/broken DTD not ignored in wizard analysis of XML files.
Jars in WAR files cannot be read by the wizard.
DashOClassNotFoundException thrown when determining serializability when ignoring not found classes.
NullPointerException when wizard rewrites entry points in an existing project file.

Changes:

DashO now requires a 1.5 JVM or higher.
Properties prefixed by env. are only sourced from the environment.
Properties prefixed by sys. are only sourced from the system properties.
DashO will declare an error if there are no input classes available due to unavailable jars/directories or exclusions.
In previous version of DashO, using a literal class name as a renaming exclusion caused the class to be conditionally loaded. This behavior is not supported in project files created with version 6, but is supported for those created with earlier versions.
When output is not being merged, DashO only keeps a single jar file open for writing at a time. Previously all output jars were open simultaneously.
Project files now store the value as a three-part number, i.e. 6.0.1. Older style versions are still recognized, i.e. 6.0001.
The navigation tree for both advanced mode and jar mode projects has changed to reflect the behavior of the new input model.
Rules created from class lists now use patterns rather than regular expressions. If you want the rule to be a regular expression hold down the shift key when performing the action. This works when adding or removing rules.
<inputpath> tag added to the project file to support the new input model. It contains nested <pathelement> tags.
Nested <jar> and <dir> in <classpath> have been replaced with <pathelement>.
The global option NODEFAULTEXCLUDES is no longer allowed. Its behavior is applied when migrating pre-6 <classpath> elements.
The global option DONOTAPPENDRTJAR is no longer allowed. It has been replaced by <classpath appendrtjar="bool">. References in pre-6 files are migrated.

5.2.3

Enhancements:

The New Project Wizard identifies classes from the Apache Wicket framework as entry points into an application. The Wizard recognizes classes that extend these classes in the framework: org.apache.wicket.Application; org.apache.wicket.protocol.http.WebApplication; org.apache.wicket.authentication.AuthenticatedWebApplication; org.apache.wicket.spring.SpringWebApplication; org.apache.wicket.spring.injection.annot.AnnotSpringWebApplication; org.apache.wicket.Page; org.apache.wicket.markup.html.WebPage; org.apache.wicket.markup.html.pages.AccessDeniedPage; org.apache.wicket.markup.html.pages.BrowserInfoPage; org.apache.wicket.markup.html.pages.ExceptionErrorPage; org.apache.wicket.markup.html.pages.InternalErrorPage; org.apache.wicket.markup.html.pages.PageExpiredErrorPage; org.apache.wicket.markup.html.pages.RedirectPage; org.apache.wicket.authentication.pages.SignInPage; org.apache.wicket.authentication.pages.SignOutPage. Classes that extend any of the page base classes have their public constructors used as entry points.

Fixes:

New Project Wizard does not correctly identify classes implementing the following Spring interfaces: org.springframework.beans.factory.InitializingBean; org.springframework.beans.factory.BeanFactoryAware; org.springframework.beans.factory.BeanNameAware; org.springframework.context.ResourceLoaderAware; org.springframework.validation.Validator.

5.2.2

Changes:

No longer throws exceptions when the dasho.dat file is not writable.

5.2.1

New Features:

Most entry point types can now be renamed. To support this the following attributes have been added to the child tags of <entrypoint>:
- rename=bool to <classes>, <method>, and <field>.
- rename-class=bool and rename-members=bool to <publics>, <ejb>, and <unconditional>.
- rename-class=bool to the <applet>, <servlet>, <midlet>, and <iappli>.
DashO will rewrite the Main-Class attribute of a manifest if the class has been renamed.
The New Project Wizard generates entry points for classes found in various non-class sources. These include the XML files used by Spring and Hibernate as well as TLD, JNLP, and JAD files and the web.xml. DashO will rewrite the class names in these files if the entry points have been renamed.
The New Project Wizard generated projects for Google Android applications.
Names for classes and members, and method signatures for entry points and includes/excludes can be specified as simple patterns using ?, *, and **. See the user guide for details.
Names for classes and member, and method signatures for entry points can be specified using regular expressions. A regex=bool attribute has been added to the following child tags of <entrypoint>: <classes>; <midlet>; <servlet>; <iappli>; <applet>; <unconditional>; <ejb>; <public>.

Enhancements:

The following new properties have been added: ${jce.jar}; ${jsse.jar}; ${javaws.jar}. These expand to the locations of the JCE, JSSE, and Java Web Start jars.
Improved support for IBM JVMs.
The New Project Wizard generates a much simpler project file for WAR files.
When inner classes are renamed each gets its own renaming namespace, reducing the length of class names.
When renaming classes but keeping package names, each package gets its own renaming namespace, reducing the length of class names.
The RENAMEFORNAME feature uses less memory.
Icons used in class displays improved for display on non-white backgrounds.
The tar file installer includes man pages for dashocmd and dashogui in the docs directory.

Fixes:

Renamed anonymous inner classes must be prefixed by the name of their outer class.
If inner class made non-renameable, outer class must be non-renameable.
When Overload Induction™ is turned off some non-renameable classes are renamed.
Registration email address does not accept uppercase characters.
NullPointerException if registration is cancelled without entering a serial number.
Regression bug in map files where fields were written as methods.
Regression bug in stack trace decoding cause by new map file API.
Repaint error in classes trees when window is hidden and then exposed.
Results panel disabled when build executed and the results panel is the currently displayed panel.
NullPointerException when renaming is off and generic method signature includes a missing class.
Field entry point does not make its class non-renameable by default.
Field entry point should make field non-renameable even if the field has been referenced by another execution path.
NullPointerException after deleting class rule with children.
NullPointerException when incorrect base directory specified for classpath entry.
Class rename collision when rename prefix used.
User interface lock-up with project files with names longer than 37 characters on Windows.
<unconditional> entrypoint not considered included in jar mode projects.
Scripts not working in Cygwin when CDPATH is set.

Changes:

When a directory is used as the source for non-class file copying JARs and WARs in the hierarchy are not copied.
When the file META-INF/MANIFEST.MF in used in non-class file copying it will only get copied if a manifest is not already present. Its contents will be rewritten if required.
When project files are written out attributes that are set to their defaults may be omitted. This generates XML that is less cluttered.
Class names used in special entry points can no longer be specified using the internal class file format or in file name format.

5.1.3

Changes:

No longer throws exceptions when the dasho.dat file is not writable.

5.1.2

Fixes:

Map file contents not created correctly: fields written out as methods.
NullPointerException with an unresolved class in generics when renaming turned off.

5.1.1

New Features:

JSP Taglib for RIS messages. The Taglib is packaged as a separate Jar in ri-taglib.jar. An example WAR file is provided: see the Read-me for details.
Map file API for reading, modifying, and creating DashO map files. The API is packaged as a separate Jar in mapfile.jar and Javadoc is provided.

Enhancements:

Increased RIS support in MS Windows for the performance probe and system profile messages.
Line number debugging information is retained in both obfuscated and un-obfuscated code regardless of the settings of string encryption, optimization, or control flow.
Rule editors have keyboard shortcuts:
- Del - delete
- Ctrl-Up - move up
- Ctrl-Dn - move down
- Ctrl-X - validate
Rule editors now create package rules with a trailing period to prevent coincidental matching with packages that share a common prefix.
New Project Wizard creates fewer and more compact exclusion patterns for support jars.
New Project Wizard recognizes J2ME Xlet derived classes as entry points.

Fixes:

ClassCastException when creating annotation on a method when an already existing annotation has the focus.
ClassCastException in Jar mode projects.
Access error with final public methods in non-public base classes when running under Java 1.6 (additional changes from 5.0.1).
Files that end in .class but are not Java classes cause ArrayIndexOutOfBoundsException.
Exclusions created on classpath panel are not saved unless the exclude panel is visited before a save.
Property values cannot be defined in terms of other properties. This was permitted in 3.4, removed in 4.0, and restored in 5.1.
ArrayIndexOutOfBoundsException when rewriting transformed method where LDC needs to be converted to an LDC_W.
Renamer fails renaming classes to MSDOS reserved device names.
Validation error on rebound method calls to concrete methods in abstract classes.

Changes:

Class renaming now starts with a rather than b.
Methods can now be renamed to some previously excluded MSDOS device names, such as aux.
New advanced projects defaults to a directory output with the merge option off. This allows for quicker setup of cross-jar obfuscation and eliminates the need for non-class file inclusion for single jar obfuscation.
New Project Wizard no longer creates entry points for serialization methods and fields as DashO handles these automatically.
The <file> tag in project files is deprecated and has been replaced by a path in a parent tag. DashO automatically updates the project file when you save it.
When the UI does a refresh or a build the results panel is cleared to release memory from the previous build.

5.0.1

New Features:

DashO supports PreEmptive Solutions Runtime Intelligence System. Runtime Intelligence is a technology and service that gives application authors and users insight into how their applications are being used.

Enhancements:

The project file's <output> tag now supports the following attributes which apply to any jars that DashO creates:
- compress="boolean" - Should entries in jars be compressed. Defaults to true.
- level="0-9" - Compression level for jar entries. Defaults to 6. Higher values give higher compression.
- filesonly="boolean" - Should the jars contain only file entries or both file and directory entries. Defaults to true.
Property references now support operators to delete or replace text. The following Bash-like syntax is supported:
- ${prop/pattern/replace} - Replace first regular expression pattern with replace
- ${prop//pattern/replace} - Replace all regular expression pattern with replace
- ${prop/#pattern/replace} - Replace leading regular expression pattern with replace
- ${prop/%pattern/replace} - Replace trailing regular expression pattern with replace
- ${prop#pattern} - Delete leading regular expression pattern
- ${prop%pattern} - Delete trailing regular expression pattern
Formatting in reports has been improved.

Fixes:

Verify error after control-flow obfuscation in methods longer than 16k.
Access error with final public methods in non-public base classes when running under Java 1.6.
NullPointerException with string encryption when merge="false".

Changes:

The name of the resources file for DashO's Ant tasks has been changed from preemptive/dasho/anttask/antlib.xml to com/preemptive/dasho/anttask/antlib.xml.
Conversion of 3.x style method references using (applet), (servlet), (ejb), (midlet), (iappli), and (publics) in project files has been removed. These were replaced with like-named tags in 4.x.
Conversion of <output>/<dir> with jar names is not longer supported. The <dir> should be changed to a <jar>.
In project files, the <exclude> no longer supports the methodname attribute and the classname attribute is now required.
The following obsolete project file options have been removed: PACKAGERTJARCLASSES; INCLUDESUN; INCLUDEJAVA; MAPTRUNC; RENAMETRIGGERS.

4.2.4

Fixes:

Late load problem with inner classes with generic outer classes with two or more type parameters.
Eclipse plugin created with incorrect version number.

4.2.3

Enhancements:

The New Project Wizard reads Hibernate's .hbm.xml files and Android's AndroidManifest.xml to discover entry points.
The New Project Wizard tags classes that extend android.app.Activity as Midlet-like entry points.

Fixes:

ArrayIndexOutOfBoundsException when writing optimized classes compiled with Java 1.6.

4.2.2

Enhancements:

The arrangement and alignment of items in the stack trace decoding dialog has changed. The results are placed in a separate tab.

Fixes:

Problems with HotSpot compiler errors in control flow obfuscated code in Java 1.6.0_5 and up.
String encryption was forced off if there were no inner classes in the input jars.
Problems with registration confirmation.
Stack trace decoding did not work for obfuscated classes that were in packages.
Source class for the string decryption method added to map files. This class is now excluded from the files.
Some icons shown in reversed colors on Macintosh.

4.2.1

New Features:

Eclipse IDE integration. Allows project files to be created, edited, and executed from inside Eclipse. See the Eclipse Plugin documentation for installation and use.
New output option: merge="true/false". merge="false" allows cross jar/directory obfuscation and pruning while retaining the original packaging of the input classes. Previously DashO required that all output be placed in a single jar/directory. A new sample project, multijar, illustrating this feature is provided.

Enhancements:

All command lines now support short and long option names. All provide --help and --version.
Reports use standardized report headings and section breaks.
When DashO copies non-class file it attempts to preserve the original date and time of the source file.
You can add and remove exclusions for a jar in the class path by right-clicking on it and selecting Add Exclusions or Remove Exclusions.

Changes:

Project file version now includes the build number of the product. For backwards compatibility the version is encoded as M.mmbb where M is the major version number, mm is the minor version number and bb is the build number.
DashO adds a default manifest to all jars it creates if a manifest is not provided by other means.

Fixes:

Shell script bug with file names that contain spaces.
Forname detection using cast preceding Class.newInstance() invocation. DashO now correctly includes the class used in the cast and all implementing classes.
User interface creates Jar Mode projects that generates a String Encryption warning.
<sysproperty> and <env> do not work in Ant tasks.
Sourcing for property expansion prevents command line overrides of values. Values provided on the command line now override values provided in the project file.

4.1.2

New Features:

New Project Wizard in the File -> New Project menu. You can have DashO's New Project Wizard create a project for your application. The Wizard can create projects for libraries, applications, or WAR files. WAR file obfuscation requires installing DashO's Ant tasks.

Enhancements:

Control flow re-ordering is stable between obfuscation runs so that methods that trigger JIT compiler bugs can be safely excluded.
When creating an output jar with a manifest, the name of the manifest may be a jar name. This jar is then used as the source for the manifest that will be placed in the output jar.

Changes:

Entry points that reference excluded classes are now generate a warning and are ignored rather than halting the build.
DashO now excludes all packages that are defined in JDK 1.6.
INCLUDEJAVA and INCLUDESUN global options have been removed. These options are ignored and removed from the project file.
PACKAGERTJARCLASSES global option has been renamed to NODEFAULTEXCLUDES. The old option is automatically renamed when you save a project file. When this option is specified DashO does not use its internal list of Java packages that are excluded - only the exclusions in the project file will be used.
Build halted when field references are made to missing classes even when IGNORENOTFOUNDCLASSES has been specified. A warning is now generated.
Build halted when generic signatures make reference to missing classes even when IGNORENOTFOUNDCLASSES has been specified. A warning is now generated.

Fixes:

Null Pointer Exception when opening translator dialog.
Incremental renaming performance problems with large class hierarchies.
Messages not appearing on the problems tab.
Typing property reference in report name field causes exception.
Non-class file editing boxes being enabled when no item has been selected.

4.1.1

New Features:

Ant tasks : <obfuscate>; <obfuscate-jar>; <watermark>. Requires Apache Ant 1.5 or newer. See the Ant Tasks documentation for installation and use.

Enhancements:

String Encryption improvements to thwart decompilation and reduce class sizes.
New Peep Hole optimizer.
Improved error messages for missing classes showing the context of the class reference.
Entry points, special classes, library entry points, classpath, quick jars, and supporting jars panels now have popup menus.
Entry points can now contain ** and * patterns using Ant-like semantics.

Fixes:

Exception with forname detection in unusual instruction patterns.
Jar mode interface unable to turn off byte code optimization.
Problem inserting manifests files that do not contain versions. Manifest version is automatically added if not present in the text file.
Decoding of stack traces that contain a combination of renamed and non-renamed methods and classes.
String encrypted code that uses == rather than equals().
Results panel drawing blank text with Window XP using Window 2000 display mode.
Input jars list having compressed display when jar has a blank name.
User interface not saving files that contain field rules.
User interface losing value of manifest name on output panel.

4.0.1

New Features:

A new user interface.
Jar Mode interface is now combined with the Advanced Mode interface.
New installers using IzPack (izpack.org). The application, documentation, and samples can all be installed separately.

Enhancements:

Enhanced use of properties throughout the DOX file.
Class name in entry points can use wildcards. Wildcards can now locate classes stored in jars.
The script files now use a shared configuration file.
Two new sample projects have been added.

Changes:

If a property is not defined it is no longer an error that halts the build. Instead the unexpanded value is left in the string.
Relative filenames in project files are resolved relative to the project files location, not the current working directory as in 3.4.
All tags that are a child of <dasho> in the options file are now optional. Note that this makes the files incompatible with 3.4.
User preferences are now stored using Java's user preference mechanism. DashO no longer reads or writes .cfg files.