From 6a93f7000847068dfe4ab4a668d661f8c58e367b Mon Sep 17 00:00:00 2001 From: Edo -maland- Date: Tue, 14 Mar 2017 18:56:22 +0700 Subject: [PATCH] New --- config/android.pro | 171 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 config/android.pro diff --git a/config/android.pro b/config/android.pro new file mode 100644 index 0000000..0da07bd --- /dev/null +++ b/config/android.pro @@ -0,0 +1,171 @@ +# +# This ProGuard configuration file is part of the backdoor-apk project. +# +# GitHub: https://github.com/dana-at-cp/backdoor-apk +# + +# Specify the input jars, output jars, and library jars. +# Note that ProGuard works with Java bytecode (.class), +# before the dex compiler converts it into Dalvik code (.dex). + +-injars ../temp/bin/classes +-injars ../temp/libs +-outjars ../temp/bin/classes-processed.jar + +-libraryjars ../tools/android-sdk-25.0.2/platforms/android.jar +#-libraryjars /usr/local/android-sdk/add-ons/google_apis-7_r01/libs/maps.jar +# ... + +# Save the obfuscation mapping to a file, so you can de-obfuscate any stack +# traces later on. + +-printmapping ../temp/bin/classes-processed.map + +# You can print out the seeds that are matching the keep options below. + +#-printseeds bin/classes-processed.seeds + +# Preverification is irrelevant for the dex compiler and the Dalvik VM. + +-dontpreverify + +# Reduce the size of the output some more. + +-repackageclasses 'net/dirtybox/util' +-allowaccessmodification + +# Switch off some optimizations that trip older versions of the Dalvik VM. + +-optimizations !code/simplification/arithmetic + +# Keep a fixed source file attribute and all line number tables to get line +# numbers in the stack traces. +# You can comment this out if you're not interested in stack traces. + +-renamesourcefileattribute SourceFile +-keepattributes SourceFile,LineNumberTable + +# RemoteViews might need annotations. + +-keepattributes *Annotation* + +# Preserve all fundamental application classes. + +-keep public class * extends android.app.Activity +-keep public class * extends android.app.Application +-keep public class * extends android.app.Service +-keep public class * extends android.content.BroadcastReceiver +-keep public class * extends android.content.ContentProvider + +# Preserve all View implementations, their special context constructors, and +# their setters. + +-keep public class * extends android.view.View { + public (android.content.Context); + public (android.content.Context, android.util.AttributeSet); + public (android.content.Context, android.util.AttributeSet, int); + public void set*(...); +} + +# Preserve all classes that have special context constructors, and the +# constructors themselves. + +-keepclasseswithmembers class * { + public (android.content.Context, android.util.AttributeSet); +} + +# Preserve all classes that have special context constructors, and the +# constructors themselves. + +-keepclasseswithmembers class * { + public (android.content.Context, android.util.AttributeSet, int); +} + +# Preserve all possible onClick handlers. + +-keepclassmembers class * extends android.content.Context { + public void *(android.view.View); + public void *(android.view.MenuItem); +} + +# Preserve the special fields of all Parcelable implementations. + +-keepclassmembers class * implements android.os.Parcelable { + static android.os.Parcelable$Creator CREATOR; +} + +# Preserve static fields of inner classes of R classes that might be accessed +# through introspection. + +-keepclassmembers class **.R$* { + public static ; +} + +# Preserve annotated Javascript interface methods. + +-keepclassmembers class * { + @android.webkit.JavascriptInterface ; +} + +# Preserve the required interface from the License Verification Library +# (but don't nag the developer if the library is not used at all). + +-keep public interface com.android.vending.licensing.ILicensingService + +-dontnote com.android.vending.licensing.ILicensingService + +# The Android Compatibility library references some classes that may not be +# present in all versions of the API, but we know that's ok. + +-dontwarn android.support.** + +# Preserve all native method names and the names of their classes. + +-keepclasseswithmembernames,includedescriptorclasses class * { + native ; +} + +# Preserve the special static methods that are required in all enumeration +# classes. + +-keepclassmembers,allowoptimization enum * { + public static **[] values(); + public static ** valueOf(java.lang.String); +} + +# Explicitly preserve all serialization members. The Serializable interface +# is only a marker interface, so it wouldn't save them. +# You can comment this out if your application doesn't use serialization. +# If your code contains serializable classes that have to be backward +# compatible, please refer to the manual. + +-keepclassmembers class * implements java.io.Serializable { + static final long serialVersionUID; + static final java.io.ObjectStreamField[] serialPersistentFields; + private void writeObject(java.io.ObjectOutputStream); + private void readObject(java.io.ObjectInputStream); + java.lang.Object writeReplace(); + java.lang.Object readResolve(); +} + +# Your application may contain more items that need to be preserved; +# typically classes that are dynamically created using Class.forName: + +# -keep public class mypackage.MyClass +# -keep public interface mypackage.MyInterface +# -keep public class * implements mypackage.MyInterface + +-keep,allowobfuscation public class net.dirtybox.util.obfuscation.StringObfuscator { + public static java.lang.String obfuscate(java.lang.String); +} + +# If you wish, you can let the optimization step remove Android logging calls. + +#-assumenosideeffects class android.util.Log { +# public static boolean isLoggable(java.lang.String, int); +# public static int v(...); +# public static int i(...); +# public static int w(...); +# public static int d(...); +# public static int e(...); +#}