为Android的apk应用程序文件加壳以防止反编译的教程

一、什么是加壳?
加壳是在二进制的程序中植入一段代码,在运行的时候优先取得程序的控制权,做一些额外的工作。大多数病毒就是基于此原理。

二、加壳作用
加壳的程序可以有效阻止对程序的反汇编分析,以达到它不可告人的目的。这种技术也常用来保护软件版权,防止被软件破解。

三、Android Dex文件加壳原理
PC平台现在已存在大量的标准的加壳和解壳工具,但是Android作为新兴平台还未出现APK加壳工具。Android Dex文件大量使用引用给加壳带来了一定的难度,但是从理论上讲,Android APK加壳也是可行的。
在这个过程中,牵扯到三个角色:
1、加壳程序:加密源程序为解壳数据、组装解壳程序和解壳数据
2、解壳程序:解密解壳数据,并运行时通过DexClassLoader动态加载
3、源程序:需要加壳处理的被保护代码
根据解壳数据在解壳程序DEX文件中的不同分布,本文将提出两种Android Dex加壳的实现方案。

解壳数据位于解壳程序文件尾部:该种方式简单实用,合并后的DEX文件结构如下。

四、加壳程序工作流程:
1、加密源程序APK文件为解壳数据
2、把解壳数据写入解壳程序Dex文件末尾,并在文件尾部添加解壳数据的大小。
3、修改解壳程序DEX头中checksum、signature 和file_size头信息。
4、修改源程序AndroidMainfest.xml文件并覆盖解壳程序AndroidMainfest.xml文件。

五、解壳DEX程序工作流程:
1、读取DEX文件末尾数据获取借壳数据长度。
2、从DEX文件读取解壳数据,解密解壳数据。以文件形式保存解密数据到a.APK文件
3、通过DexClassLoader动态加载a.apk。

解壳数据位于解壳程序文件头
该种方式相对比较复杂, 合并后DEX文件结构如下:

六、加壳程序工作流程:
1、加密源程序APK文件为解壳数据
2、计算解壳数据长度,并添加该长度到解壳DEX文件头末尾,并继续解壳数据到文件头末尾。
(插入数据的位置为0x70处)
3、修改解壳程序DEX头中checksum、signature、file_size、header_size、string_ids_off、type_ids_off、proto_ids_off、field_ids_off、
method_ids_off、class_defs_off和data_off相关项。  分析map_off 数据,修改相关的数据偏移量。 
4、修改源程序AndroidMainfest.xml文件并覆盖解壳程序AndroidMainfest.xml文件。

七、加壳程序流程及代码实现
1、加密源程序APK为解壳数据
2、把解壳数据写入解壳程序DEX文件末尾,并在文件尾部添加解壳数据的大小。
3、修改解壳程序DEX头中checksum、signature 和file_size头信息。

代码实现如下:

package com.android.dexshell;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.zip.Adler32; 

public class DexShellTool {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  try {
   File payloadSrcFile = new File("g:/payload.apk");
   File unShellDexFile = new File("g:/unshell.dex");
   byte[] payloadArray = encrpt(readFileBytes(payloadSrcFile));
   byte[] unShellDexArray = readFileBytes(unShellDexFile);
   int payloadLen = payloadArray.length;
   int unShellDexLen = unShellDexArray.length;
   int totalLen = payloadLen + unShellDexLen +4;
   byte[] newdex = new byte[totalLen];
   //添加解壳代码
   System.arraycopy(unShellDexArray, 0, newdex, 0, unShellDexLen);
   //添加加密后的解壳数据
   System.arraycopy(payloadArray, 0, newdex, unShellDexLen,
     payloadLen);
   //添加解壳数据长度
   System.arraycopy(intToByte(payloadLen), 0, newdex, totalLen-4, 4);
      //修改DEX file size文件头
   fixFileSizeHeader(newdex);
   //修改DEX SHA1 文件头
   fixSHA1Header(newdex);
   //修改DEX CheckSum文件头
   fixCheckSumHeader(newdex); 

   String str = "g:/classes.dex";
   File file = new File(str);
   if (!file.exists()) {
    file.createNewFile();
   } 

   FileOutputStream localFileOutputStream = new FileOutputStream(str);
   localFileOutputStream.write(newdex);
   localFileOutputStream.flush();
   localFileOutputStream.close(); 

  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 } 

 //直接返回数据,读者可以添加自己加密方法
 private static byte[] encrpt(byte[] srcdata){
  return srcdata;
 } 

 private static void fixCheckSumHeader(byte[] dexBytes) {
  Adler32 adler = new Adler32();
  adler.update(dexBytes, 12, dexBytes.length - 12);
  long value = adler.getValue();
  int va = (int) value;
  byte[] newcs = intToByte(va);
  byte[] recs = new byte[4];
  for (int i = 0; i < 4; i++) {
   recs[i] = newcs[newcs.length - 1 - i];
   System.out.println(Integer.toHexString(newcs[i]));
  }
  System.arraycopy(recs, 0, dexBytes, 8, 4);
  System.out.println(Long.toHexString(value));
  System.out.println();
 } 

 public static byte[] intToByte(int number) {
  byte[] b = new byte[4];
  for (int i = 3; i >= 0; i--) {
   b[i] = (byte) (number % 256);
   number >>= 8;
  }
  return b;
 } 

 private static void fixSHA1Header(byte[] dexBytes)
   throws NoSuchAlgorithmException {
  MessageDigest md = MessageDigest.getInstance("SHA-1");
  md.update(dexBytes, 32, dexBytes.length - 32);
  byte[] newdt = md.digest();
  System.arraycopy(newdt, 0, dexBytes, 12, 20);
  String hexstr = "";
  for (int i = 0; i < newdt.length; i++) {
   hexstr += Integer.toString((newdt[i] & 0xff) + 0x100, 16)
     .substring(1);
  }
  System.out.println(hexstr);
 } 

 private static void fixFileSizeHeader(byte[] dexBytes) { 

  byte[] newfs = intToByte(dexBytes.length);
  System.out.println(Integer.toHexString(dexBytes.length));
  byte[] refs = new byte[4];
  for (int i = 0; i < 4; i++) {
   refs[i] = newfs[newfs.length - 1 - i];
   System.out.println(Integer.toHexString(newfs[i]));
  }
  System.arraycopy(refs, 0, dexBytes, 32, 4);
 } 

 private static byte[] readFileBytes(File file) throws IOException {
  byte[] arrayOfByte = new byte[1024];
  ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();
  FileInputStream fis = new FileInputStream(file);
  while (true) {
   int i = fis.read(arrayOfByte);
   if (i != -1) {
    localByteArrayOutputStream.write(arrayOfByte, 0, i);
   } else {
    return localByteArrayOutputStream.toByteArray();
   }
  }
 } 

}

八、解壳程序流程及代码实现
在解壳程序的开发过程中需要解决如下几个关键的技术问题:
1.解壳代码如何能够第一时间执行?
Android程序由不同的组件构成,系统在有需要的时候启动程序组件。因此解壳程序必须在Android系统启动组件之前运行,完成对解壳数据的解壳及APK文件的动态加载,否则会使程序出现加载类失败的异常。
Android开发者都知道Applicaiton做为整个应用的上下文,会被系统第一时间调用,这也是应用开发者程序代码的第一执行点。因此通过对AndroidMainfest.xml的application的配置可以实现解壳代码第一时间运行。

<application
 android:icon="@drawable/ic_launcher"
 android:label="@string/app_name"
 android:theme="@style/AppTheme" android:name=" 

</application>

2.如何替换回源程序原有的Application?
当在AndroidMainfest.xml文件配置为解壳代码的Application时。源程序原有的Applicaiton将被替换,为了不影响源程序代码逻辑,我们需要              在解壳代码运行完成后,替换回源程序原有的Application对象。我们通过在AndroidMainfest.xml文件中配置原有Applicaiton类信息来达到我们              的目的。解壳程序要在运行完毕后通过创建配置的Application对象,并通过反射修改回原Application。

<application
 android:icon="@drawable/ic_launcher"
 android:label="@string/app_name"
 android:theme="@style/AppTheme" android:name="
</application>

3.如何通过DexClassLoader实现对apk代码的动态加载。
我们知道DexClassLoader加载的类是没有组件生命周期的,也就是说即使DexClassLoader通过对APK的动态加载完成了对组件类的加载,当系统启动该组件时,还会出现加载类失败的异常。为什么组件类被动态加载入虚拟机,但系统却出现加载类失败呢?
通过查看Android源代码我们知道组件类的加载是由另一个ClassLoader来完成的,DexClassLoader和系统组件ClassLoader并不存在关系,系统组件ClassLoader当然找不到由DexClassLoader加载的类,如果把系统组件ClassLoader的parent修改成DexClassLoader,我们就可以实现对apk代码的动态加载。

4.如何使解壳后的APK资源文件被代码动态引用。
代码默认引用的资源文件在最外层的解壳程序中,因此我们要增加系统的资源加载路径来实现对借壳后APK文件资源的加载。

解壳实现代码:

package com.android.dexunshell; 

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream; 

import dalvik.system.DexClassLoader;
import android.app.Application;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Bundle; 

public class ProxyApplication extends Application { 

 private static final String appkey = "APPLICATION_CLASS_NAME";
 private String apkFileName;
 private String odexPath;
 private String libPath;
 @Override
 public void onCreate() {
  // TODO Auto-generated method stub
  super.onCreate();
  try {
   File odex = this.getDir("payload_odex", MODE_PRIVATE);
   File libs = this.getDir("payload_lib", MODE_PRIVATE);
   odexPath = odex.getAbsolutePath();
   libPath = libs.getAbsolutePath();
   apkFileName = odex.getAbsolutePath()+"/payload.apk";
   File dexFile = new File(apkFileName);
   if(!dexFile.exists())
    dexFile.createNewFile();
   //读取程序classes.dex文件
   byte[] dexdata = this.readDexFileFromApk();
   //分离出解壳后的apk文件已用于动态加载
   this.splitPayLoadFromDex(dexdata);
   //配置动态加载环境
   this.configApplicationEnv(); 

  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 } 

 private void configApplicationEnv() throws NameNotFoundException, IllegalAccessException, InstantiationException, ClassNotFoundException, IOException{ 

  Object currentActivityThread = RefInvoke.invokeStaticMethod("android.app.ActivityThread", "currentActivityThread", new Class[]{}, new Object[]{});
  HashMap mPackages = (HashMap)RefInvoke.getFieldOjbect("android.app.ActivityThread", currentActivityThread, "mPackages");
  //替换组件类加载器为DexClassLoader,已使动态加载代码具有组件生命周期
  WeakReference wr = (WeakReference) mPackages.get(this.getPackageName());
  DexClassLoader dLoader = new DexClassLoader(apkFileName,
    odexPath, libPath, (ClassLoader) RefInvoke.getFieldOjbect("android.app.LoadedApk", wr.get(), "mClassLoader"));
  RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader", wr.get(), dLoader); 

  //如果源应用配置有Appliction对象,则替换为源应用Applicaiton,以便不影响源程序逻辑。
  ApplicationInfo appInfo = this.getPackageManager().getApplicationInfo(this.getPackageName(),PackageManager.GET_META_DATA);
  Bundle bundle = appInfo.metaData;
  if(bundle != null && bundle.containsKey(appkey)){ 

   String appClassName = bundle.getString(appkey);
   Application app = (Application)dLoader.loadClass(appClassName).newInstance();
   RefInvoke.setFieldOjbect("android.app.ContextImpl", "mOuterContext", this.getBaseContext(), app);
   RefInvoke.setFieldOjbect("android.content.ContextWrapper", "mBase", app, this.getBaseContext());
   Object mBoundApplication = RefInvoke.getFieldOjbect("android.app.ActivityThread", currentActivityThread, "mBoundApplication");
   Object info = RefInvoke.getFieldOjbect("android.app.ActivityThread$AppBindData", mBoundApplication, "info");
   RefInvoke.setFieldOjbect("android.app.LoadedApk", "mApplication", info, app);
   Object oldApplication = RefInvoke.getFieldOjbect("android.app.ActivityThread", currentActivityThread, "mInitialApplication");
   RefInvoke.setFieldOjbect("android.app.ActivityThread", "mInitialApplication", currentActivityThread, app);
   ArrayList<Application> mAllApplications = (ArrayList<Application>)RefInvoke.getFieldOjbect("android.app.ActivityThread", currentActivityThread, "mAllApplications");
   mAllApplications.remove(oldApplication);
   mAllApplications.add(app);
   HashMap mProviderMap = (HashMap) RefInvoke.getFieldOjbect("android.app.ActivityThread", currentActivityThread, "mProviderMap");
   Iterator it = mProviderMap.values().iterator();
   while(it.hasNext()){
    Object providerClientRecord = it.next();
    Object localProvider = RefInvoke.getFieldOjbect("android.app.ProviderClientRecord", providerClientRecord, "mLocalProvider");
    RefInvoke.setFieldOjbect("android.content.ContentProvider", "mContext", localProvider, app);
   }
   RefInvoke.invokeMethod(appClassName, "onCreate", app, new Class[]{}, new Object[]{});
  }
 } 

 private void splitPayLoadFromDex(byte[] data) throws IOException{
  byte[] apkdata = decrypt(data);
  int ablen = apkdata.length;
  byte[] dexlen = new byte[4];
  System.arraycopy(apkdata, ablen - 4, dexlen, 0, 4);
  ByteArrayInputStream bais = new ByteArrayInputStream(dexlen);
  DataInputStream in = new DataInputStream(bais);
  int readInt = in.readInt();
  System.out.println(Integer.toHexString(readInt));
  byte[] newdex = new byte[readInt];
  System.arraycopy(apkdata, ablen - 4 - readInt, newdex, 0, readInt);
  File file = new File(apkFileName);
  try {
   FileOutputStream localFileOutputStream = new FileOutputStream(file);
   localFileOutputStream.write(newdex);
   localFileOutputStream.close(); 

  } catch (IOException localIOException) {
   throw new RuntimeException(localIOException);
  } 

  ZipInputStream localZipInputStream = new ZipInputStream(
    new BufferedInputStream(new FileInputStream(file)));
  while (true) {
   ZipEntry localZipEntry = localZipInputStream.getNextEntry();
   if (localZipEntry == null) {
    localZipInputStream.close();
    break;
   }
   String name = localZipEntry.getName();
   if (name.startsWith("lib/") && name.endsWith(".so")) {
    File storeFile = new File(libPath+"/"+name.substring(name.lastIndexOf('/')));
    storeFile.createNewFile();
    FileOutputStream fos = new FileOutputStream(storeFile);
    byte[] arrayOfByte = new byte[1024];
    while (true) {
     int i = localZipInputStream.read(arrayOfByte);
     if (i == -1)
      break;
     fos.write(arrayOfByte, 0, i);
    }
    fos.flush();
    fos.close();
   }
   localZipInputStream.closeEntry();
  }
  localZipInputStream.close();  

 } 

 private byte[] readDexFileFromApk() throws IOException {
  ByteArrayOutputStream dexByteArrayOutputStream = new ByteArrayOutputStream();
  ZipInputStream localZipInputStream = new ZipInputStream(
    new BufferedInputStream(new FileInputStream(this.getApplicationInfo().sourceDir)));
  while (true) {
   ZipEntry localZipEntry = localZipInputStream.getNextEntry();
   if (localZipEntry == null) {
    localZipInputStream.close();
    break;
   }
   if (localZipEntry.getName().equals("classes.dex")) {
    byte[] arrayOfByte = new byte[1024];
    while (true) {
     int i = localZipInputStream.read(arrayOfByte);
     if (i == -1)
      break;
     dexByteArrayOutputStream.write(arrayOfByte, 0, i);
    }
   }
   localZipInputStream.closeEntry();
  }
  localZipInputStream.close();
  return dexByteArrayOutputStream.toByteArray();
 } 

 ////直接返回数据,读者可以添加自己解密方法
 private byte[] decrypt(byte[] data){
  return data;
 }
}

RefInvoke为反射调用工具类:

package com.android.dexunshell; 

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; 

public class RefInvoke { 

 public static Object invokeStaticMethod(String class_name, String method_name, Class[] pareTyple, Object[] pareVaules){ 

  try {
   Class obj_class = Class.forName(class_name);
   Method method = obj_class.getMethod(method_name,pareTyple);
   return method.invoke(null, pareVaules);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchMethodException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return null; 

 } 

 public static Object invokeMethod(String class_name, String method_name, Object obj ,Class[] pareTyple, Object[] pareVaules){ 

  try {
   Class obj_class = Class.forName(class_name);
   Method method = obj_class.getMethod(method_name,pareTyple);
   return method.invoke(obj, pareVaules);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchMethodException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return null; 

 } 

 public static Object getFieldOjbect(String class_name,Object obj, String filedName){
  try {
   Class obj_class = Class.forName(class_name);
   Field field = obj_class.getDeclaredField(filedName);
   field.setAccessible(true);
   return field.get(obj);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchFieldException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return null; 

 } 

 public static Object getStaticFieldOjbect(String class_name, String filedName){ 

  try {
   Class obj_class = Class.forName(class_name);
   Field field = obj_class.getDeclaredField(filedName);
   field.setAccessible(true);
   return field.get(null);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchFieldException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return null; 

 } 

 public static void setFieldOjbect(String classname, String filedName, Object obj, Object filedVaule){
  try {
   Class obj_class = Class.forName(classname);
   Field field = obj_class.getDeclaredField(filedName);
   field.setAccessible(true);
   field.set(obj, filedVaule);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchFieldException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 } 

 public static void setStaticOjbect(String class_name, String filedName, Object filedVaule){
  try {
   Class obj_class = Class.forName(class_name);
   Field field = obj_class.getDeclaredField(filedName);
   field.setAccessible(true);
   field.set(null, filedVaule);
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchFieldException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 } 

}


九、总结
本文代码基本实现了APK文件的加壳及脱壳原理,该代码作为实验代码还有诸多地方需要改进。比如:
1、加壳数据的加密算法的添加。
2、脱壳代码由java语言实现,可通过C代码的实现对脱壳逻辑进行保护,以达到更好的反逆向分析效果。

(0)

相关推荐

  • Android简单判断某个APK是否已经安装的方法

    本文实例讲述了Android简单判断某个APK是否已经安装的方法.分享给大家供大家参考,具体如下: privateboolean isAppInstalled(String uri){ PackageManager pm = getPackageManager(); boolean installed =false; try{ pm.getPackageInfo(uri,PackageManager.GET_ACTIVITIES); installed =true; }catch(Package

  • Android studio 下的APK打包失败问题解决办法

    Android studio 下的APK打包失败问题解决办法 今天遇到了一个奇怪的问题,本来在Android studio 1.4上运行的好好的程序,到了我更新完的Android studio 2.1上就打包失败了,但是用调试机直接运行则没问题. 最后在app下的build.gradle下加入了这样的一段代码就通过了: lintOptions { abortOnError false checkReleaseBuilds false // 防止在发布的时候出现因MissingTranslatio

  • Android Apk去掉签名以及重新签名的方法

    Android Apk去掉签名以及重新签名的方法 Android开发中很重要的一部就是用自己的密钥给Apk文件签名,不经过签名的Apk文件一般是无法安装的,就算装了最后也是失败. 网上流传的"勾选允许安装未知来源的应用"其实跟签不签名没啥关系,说白了就是允许安装不从电子市场上下载的应用而已. 近几日需要修改一个Apk中JNI调用的.so文件,苦于没有apk源代码,只好研究了一下签名相关的问题.当然有很多第三方工具可以做到,但其实JDK中已经提供了强大的签名工具jarsigner. 1.

  • Android APK优化工具Zipalign详解

    Android SDK中包含了一个用于优化APK的新工具zipalign.它提高了优化后的Applications与Android系统的交互效率(俗话:"要致富先修路",Android小组重新为Applications与Android系统之间搭建了一条高速公路),从而可以使整个系统的运行速度有了较大的提升.Android小组强烈建议开发者在发布新Apps之前使用zipalign优化工具,而且对于已经发布但不受限于系统版本的Apps,建议用优化后的APK替换现有的版本. 在下面的内容中将

  • Android 如何修改APK的默认名称

    Android 如何修改APK的默认名称 用Android Studio 打包App时生成的名称默认是 app-release.apk(已签名) 或 app-debug.apk(测试版). 要想打包时修改默认名称,可以打开在build.gradle(module:app)文件,在android{}中添加如下代码: android.applicationVariants.all { variant -> variant.outputs.each { output -> def outputFil

  • Android获取apk签名指纹的md5值(防止重新被打包)的实现方法

    本文实例讲述了Android获取apk签名指纹的md5值以防止重新被打包的实现方法.分享给大家供大家参考,具体如下: 做个记录(这里只是Java层的签名校验,java层容易被破解,我建议apk加固下) 获取md5值来进行Apk签名校验, 可以防止apk重新被打包. 下面我说说怎么获取apk签名的md5值(有三种方法) 1.用代码获取签名指纹的md5值 /** * MD5加密 * @param byteStr 需要加密的内容 * @return 返回 byteStr的md5值 */ public

  • 为Android的apk应用程序文件加壳以防止反编译的教程

    一.什么是加壳? 加壳是在二进制的程序中植入一段代码,在运行的时候优先取得程序的控制权,做一些额外的工作.大多数病毒就是基于此原理. 二.加壳作用 加壳的程序可以有效阻止对程序的反汇编分析,以达到它不可告人的目的.这种技术也常用来保护软件版权,防止被软件破解. 三.Android Dex文件加壳原理 PC平台现在已存在大量的标准的加壳和解壳工具,但是Android作为新兴平台还未出现APK加壳工具.Android Dex文件大量使用引用给加壳带来了一定的难度,但是从理论上讲,Android AP

  • Android APK反编译图文教程

    在学习Android开发的过程你,你往往会去借鉴别人的应用是怎么开发的,那些漂亮的动画和精致的布局可能会让你爱不释手,作为一个开发者,你可能会很想知道这些效果界面是怎么去实现的,这时,你便可以对改应用的APK进行反编译查看.下面是我参考了一些文章后简单的教程详解. (注:反编译不是让各位开发者去对一个应用破解搞重装什么的,主要目的是为了促进开发者学习,借鉴好的代码,提升自我开发水平.) 测试环境: win 7 使用工具: 我们下载地址: apktool (资源文件获取)  下载        

  • 保护.net中的dll文件方法(防止破解、反编译dll)

    .net是一种建立在虚拟机上执行的语言,它直接生成 MSIL 的中间语言,再由.net编译器 JIT 解释映象为本机代码并交付CPU执行.中间语言很容易被反编译,所以研究下如何有效的保护dll文件. 我大致的方法为 :强签名+混淆+加密. 强签名 强命名程序集,可以确保你的程序集唯一,而不被篡改.冒用等:即使相同名字的程序集如果签名也会不同.强签名很简单 为项目添加强名称方法:1.右键单击项目,打开属性窗口;2.在属性窗口里选择<签名>标签,选中为程序集签名的选项,在下拉列表里选择新建,如下图

  • 详解Android的反编译和代码混淆

    前言 包括以下内容 要反编译apk需要下面3个工具 反编译资源文件 反编译类文件 代码混淆 要反编译apk需要下面3个工具 1.apktool(资源文件获取) 作用:资源文件获取,可以提取图片文件和布局文件进行使用查看 2.dex2jar(源文件获取) 作用:将APK反编译成java源码(classes.dex转化成jar文件) 3.jd-gui 作用:查看APK中classes.dex转化成的jar文件,即源码文件 下面进行反编译资源文件和类文件: 反编译资源文件 资源文件:包括图片资源.布局

  • android apk反编译到java源码的实现方法

    Android由于其代码是放在dalvik虚拟机上的托管代码,所以能够很容易的将其反编译为我们可以识别的代码. 之前我写过一篇文章反编译Android的apk包到smali文件 然后再重新编译签名后打包实现篡改apk的功能. 最近又有一种新的方法来实现直接从Android apk包里的classes.dex文件,把dex码反编译到java的.class二进制码,然后从.class二进制码反编译到java源码想必就不用我来多说了吧. 首先我们需要的工具是dex2jar和jd-gui 其中第一个工具

  • Android Apk反编译及加密教程

    目录 一.Apk文件组成 二.反编译必备工具及使用 1)apktool 2)Dex2jar 3)jd-gui 三.Apk的加密过程 这几天在上海出差,忙里偷闲学习了一下Apk的反编译工具的基本使用.下面就简单介绍一下如何将我们从网上下载的Apk文件进行反编译得到我们想要获得的资源文件和源码. 一.Apk文件组成 Android的应用程序APK文件说到底也是一个压缩文件,那么可以通过解压缩得打里面的文件内容,不过很显然,当你去解压完去查看的时候,发现里面的很多东西和你想象中的不太一样.资源文件等x

  • Android APK反编译技巧深入讲解

    导言: 在我们安卓开发当中,我们不仅需要掌握基础的开发技能,也需要掌握软件的安全技能,这样才可以让我们的软件能够成为一款能够真正可以进行发布的软件,同时也可以让自己的核心技术不会被别人所盗取.首先我们应当了解的是,对于反编译我们一共需要三个工具,它们分别是:APKTool,dex2jar,和jd-gui.APKTool:用于解析apk的res文件以及AndroidManifest.xml文件dex2jar:用于把apk解压后生成的classes.dex文件解析为后缀为jar的文件,与下面的jd-

  • 微信小程序反编译的实现

    首先声明:本文章仅供学习之用,不可它用. 一.前言 看到人家上线的小程序的效果,纯靠推测,部分效果在绞尽脑汁后能做出大致的实现,但是有些细节,费劲全力都没能做出来.很想一窥源码?查看究竟?看看大厂的前端大神们是如何规避了小程序的各种奇葩的坑?那么赶紧来试试吧 反编译,其实还是简单的,要想拿到微信小程序源码,找到源文件在手机存放的位置就行,源文件拿到,用反编译脚本跑一下,微信小程序代码包里的所有文件.所有资源就出来了(除了project.config.json小程序配置文件).拿到源码后,跑起来是

  • 给Android的APK程序签名和重新签名的方法

    签名工具的使用 Android源码编译出来的signapk.jar既可给apk签名,也可给rom签名的.使用格式: java –jar signapk.jar [-w] publickey.x509[.pem] privatekey.pk8 input.jar output.jar -w 是指对ROM签名时需使用的参数 publickey.x509[.pem] 是公钥文件 privatekey.pk8 是指 私钥文件 input.jar 要签名的apk或者rom output.jar 签名后生成

  • Android安装apk文件并适配Android 7.0详解

    Android安装apk文件并适配Android 7.0详解 首先在AndroidManifest.xml文件,activity同级节点注册provider: <provider android:name="android.support.v4.content.FileProvider" android:authorities="${applicationId}.file_provider" android:exported="false"

随机推荐