Protecting Java Android Applications that use Butter Knife

December 26, 2018 2802 Views Johnny

Butter Knife is an annotation processing library that helps streamline boilerplate Java code in Android views. At compile time, Butter Knife annotations are processed to generate the relevant UI code to make views function properly.

When obfuscating applications that use Butter Knife, there are specific configuration patterns you should follow. The code that connects generated classes to their views uses runtime reflection under the hood. Because of this, the original name of the View is required.

When configuring DashO we need to:

1. Exclude from Renaming any activity, view or fragment containing the Butterknife.bind() directive.
2. Exclude from Renaming any generated class named *_ViewBinding.

The DashO wizard helps us with proper configuration by identifying the MainActivity and any fragment as a non-renameable entry point. This means that you do not need to explicitly exclude the View or Fragment from Renaming. You only need to exclude the generated MainActivity_ViewBinding or Fragment_ViewBinding class. However, please note that it is also possible to have a class containing the Butterknife.bind() directive which is not identified as an entry point. If this is the case, we need to exclude this class in addition to its ViewBinding class.

Let’s look at an example.

I have a MainActivity with a TextView which has been decorated with the ButterKnife @BindView annotation.

I have a fragment with a button with a ButterKnife @OnClick that shows a toast.

After going through the DashO Wizard, the MainActivity and BlankFragment have been identified as non-renameable entry points:

I then create a Rename pattern Rule to ensure that any _ViewBinding doesn’t get renamed:

Based on this configuration, after obfuscation, my app loads and runs properly:

If I didn’t explicitly specify the *_ViewBinding Rename exclusion, I would see an exception in LogCat:


java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.the.basicexample/com.example.the.basicexample.MainActivity}: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.TextView.setText(java.lang.CharSequence)' on a null object reference

        at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2416)

        at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2476)

        at android.app.ActivityThread.-wrap11(ActivityThread.java)

        at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1344)

        at android.os.Handler.dispatchMessage(Handler.java:102)

        at android.os.Looper.loop(Looper.java:148)

        at android.app.ActivityThread.main(ActivityThread.java:5417)

        at java.lang.reflect.Method.invoke(Native Method)

        at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:726)

        at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)

Please note: this example uses a newer version of Butter Knife. In versions prior to 8, instead of _ViewBinding, we would add **$$ViewBinder.

In conclusion, applications using Butter Knife can be obfuscated with a just few basic configurations to ensure that generated code is handled properly.

You can download the full example here.

If you have any feedback on this topic, or other topics you would like us to discuss in the Support Corner, please feel free to contact us at support [at] preemptive [dot] com.

Latest Blog Posts

Protecting C# Applications That Use Dynamic Types

The dynamic type in C# provides flexibility that is not available in other statically-typed languages. Since its introduction in C# 4.0 (.NET 4.5), we have worked with customers who wanted to know more about how dynamic types are impacted by the obfuscation process.

Malicious actors — like any thieves — live by a simple rule: If the front door is locked, break the window.

It’s why threats like fileless malware and crypto-jacking have seen substantial gains over last few years. It’s why — despite increasing employee education and IT training — hackers are still hooking phish by developing more sophisticated and authentic-looking email spoofs. Cybercriminal communities, meanwhile, continue to grow on the dark web, allowing attackers to share info, purchase exploit kits and identify potential targets.

What does this mean for CISOs? That typical defense efforts are being outpaced as familiar attack vectors are replaced with non-traditional threats. But it’s not all bad news; here are three questions every CISO needs to ask to help close the doors, bolt the windows and leave hackers out in the cold.

Gabriel, you have been in the security industry for over 2 decades. You have seen many different tools and services. Why create a company around something as specific as obfuscation and in-app protection?

Our customers build a lot of really innovative apps that enable their users and customers to do new and cool things. These apps frequently run on untrusted client computers/devices and they control access to customer’s sensitive data or critical devices.

And after all the effort of designing, building, debugging, and deploying their applications, the last thing they want is for an attacker to steal their work or use it to look for vulnerabilities to break into their system.

Long ago, we built a Java code optimizer, but it became clear to us that our customer cared more about the obfuscation effects of the optimization than the actual performance improvement. That is when we really began to focus on app protection. First with Java, then .NET, Android, iOS, Xamarin, JavaScript, etc.

Gartner calls In-App Protection “crucial” in their July 2019 Market Guide for In-App Protection In-App Protection. The guide’s summary advises security and risk management leaders to “take due care in protecting their application clients” in order to avoid “security failure.”

This raises the question – what constitutes “due care?” Obviously, no development organization looks to recklessly expose their applications or sensitive data to attack or compromise. On the other hand, over-engineered (or poorly engineered) security controls can quickly lead to excessive development costs, performance and quality issues, and, ultimately, unacceptable user experiences. While terms and terminology may vary, there is broad consensus on how to best define “due care” for any given application/user scenario.

If you don’t follow application security closely, you might think of application obfuscation and symbol renaming as being synonymous – and with good reason. Many platforms and languages, like .NET, Java, and JavaScript have popular obfuscators that do little else--our own Dotfuscator Community Edition for .NET and ProGuard for Java are good examples. However, obfuscation is far more than symbol renaming – and in-app protection is far more than obfuscation. Much of this expansion has been driven by new security requirements, shifting attack vectors, the rise of mobile and IoT computing and, lastly, the growing recognition inside regulations and legislation of the exposure that can result from inadequately protected software.

Protecting Java Android Applications that use Butter Knife

Protecting C# Applications That Use Dynamic Types

Non-Traditional Attack Vectors: Three Questions Every CISO Needs to Ask

Q&A With PreEmptive CEO Gabriel Torok

Gabriel, you have been in the security industry for over 2 decades. You have seen many different tools and services. Why create a company around something as specific as obfuscation and in-app protection?

The Secret to Effective In-App Protection

Symbol Renaming: App Security’s Maginot Line?

Latest Blog Posts

Protecting C# Applications That Use Dynamic Types

Non-Traditional Attack Vectors: Three Questions Every CISO Needs to Ask

Q&A With PreEmptive CEO Gabriel Torok

The Secret to Effective In-App Protection

Symbol Renaming: App Security’s Maginot Line?

Twitter