其他分享
首页 > 其他分享> > apk加壳去壳

apk加壳去壳

作者:互联网

1.1原理

(1)基础原理

在这里插入图片描述
在整个加固过程中,我们会涉及到四个文件(其实最终要实现加固,需要涉
及的文件不止四个,这里我们仅包含了主要文件):

一般加固流程
1.生成 originalAPK.apk
2.编写 addShell.java 程序(注:虽然这里没有所要操作的 shellDex.dex 文件,
但其文件格式都已知晓,不会影响程序的实现)
3.编写 shellAPK.apk,并从中提取 classes.dex 文件改名为 shellDex.dex(注:
虽然这里 originalAPK.apk 都没有被加密,也没有与 shellDex.dex 合并,但解密
算法和文件格式都已知晓,不会影响程序的实现)
4.运行 addShell.java 程序,生成 classes.dex
5.修改相关文件,如 Manifest 文件,将修改后的文件和第四步生成的
classes.dex 文件替换 shellAPK.apk 中相应的文件。最终获得的 shellAPK.apk 就
是我们加固后的 originalAPK.apk。

(2)DEX 头内容

在这里插入图片描述
需要关注的字段:

简单来说,我们将数据拼接后,还需要修改这三个字段,以保证文件正常运
行。最后,这个新 DEX 的结构大概如下
在这里插入图片描述
因此拼接步骤如下:
• 获取脱壳 DEX (二进制数据)
• 计算新 DEX 的大小(脱壳 DEX 的大小 + 加密 APK 的大小 + 4)
• 依次拼接脱壳 DEX、加密 APK、加密 APK 的大小,得到新 DEX
• 修改新 DEX 头的三个字段
• 输出新 DEX

1.2操作过程

(1)源apk

首先新建一个HelloWorld
MainAcitivity

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("helloPack", "I am coming");
    }
}

(2)加密和拼接工具(函数)

使用 Android Studio 的 Java
Moudle 来编辑 Java 函数。
再明确一下功能:对源 APK 进行加密、拼接到脱壳 DEX,得到新 DEX。

1、新建 Java Moudle

新建工程,默认模板即可,然后右键 app,New -> Moudle -> Java Library:
在这里插入图片描述

此时,会生成一个 lib 文件夹和一个默认的 MyClass.java,我们可以在里面编辑 Java 代码。

在这里插入图片描述
这里测试一下:

public class MyClass {
 public static void main(String[] args) {
 System.out.println("hello Java");
 }
}

右键 MyClass,或者点击对应文件旁边的按钮,选择 Run"MyClass.main()":
在这里插入图片描述

2、 加密和拼接

package com.example.lib;

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 MyClass {
    public static void main(String[] args){
        try {
            // 获取源APK(项目根目录下)
            File srcApkFile = new File("force/orignal.apk");
            System.out.println("apk path: " + srcApkFile.getAbsolutePath());
            System.out.println("apk size: " + srcApkFile.length());
            // 加密并返回数据
            byte[] enSrcApkArray = encrypt(readFileBytes(srcApkFile));
            // 脱壳DEX, 以二进制形式读出DEX
            File unShellDexFile = new File("force/classes.dex");
            System.out.println("unShellDexFile path: " + unShellDexFile.getAbsolutePath());
            System.out.println("unShellDexFile size: " + unShellDexFile.length());
            byte[] unShellDexArray = readFileBytes(unShellDexFile);

            // 将脱壳DEX长度和加密APK长度相加并加上存放加密APK大小的四位得到总长度
            int unShellDexLen = unShellDexArray.length;
            int enSrcApkLen = enSrcApkArray.length;
            // 多出的四位存放加密APK长度
            int totalLen = unShellDexLen + enSrcApkLen + 4;

            // 依次将脱壳DEX,加密APK,加密APK大小,拼接出新的DEX
            byte[] newDex = new byte[totalLen];
            // 复制加壳数据
            System.arraycopy(unShellDexArray, 0, newDex, 0, unShellDexLen);
            // 复制加密APK数据
            System.arraycopy(enSrcApkArray, 0, newDex, unShellDexLen, enSrcApkLen);
            // 赋值加密APK大小
            System.arraycopy(intToByte(enSrcApkLen), 0, newDex, totalLen - 4, 4);

            // 修改DEX file size 文件头
            fixFileSizeHeader(newDex);
            // 修改DEX SHA1 文件头
            fixSHA1Header(newDex);
            // 修改DEX CheckNum文件头
            fixCheckSumHeader(newDex);

            // 新DEX文件名
            String str = "force/classesShell.dex";
            File file = new File(str);
            if (!file.exists()) {
                if (!file.createNewFile()) {
                    System.out.println("File create error");
                    return;
                }
            }
            // 导出文件
            FileOutputStream fos = new FileOutputStream(str);
            fos.write(newDex);
            fos.flush();
            fos.close();
        } catch (IOException | NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    /**
     * 修改DEX头,checkSum校验码
     * @param dexBytes 要修改的二进制数据
     */
    private static void fixCheckSumHeader(byte[] dexBytes) {
        Adler32 adler = new Adler32();
        // 从12到文件末尾计算校验码
        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("fixCheckSumHeader:" + Integer.toHexString(newCs[i]));
        }
        // 校验码赋值(8-11)
        System.arraycopy(reCs, 0, dexBytes, 8, 4);
        System.out.println("fixCheckSumHeader:" + Long.toHexString(value));
    }

    /**
     * 修改DEX头, sha1值
     * @param dexBytes 要修改的二进制数组
     */
    private static void fixSHA1Header(byte[] dexBytes) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-1");
        // 从32位到结束计算sha-1
        md.update(dexBytes, 32, dexBytes.length - 32);
        byte[] newDt = md.digest();
        // 修改sha-1值(12-21)
        System.arraycopy(newDt, 0, dexBytes, 12, 20);
        // 输出sha-1值
        StringBuilder hexStr = new StringBuilder();
        for (byte aNewDt : newDt) {
            hexStr.append(Integer.toString((aNewDt & 0xFF) + 0x100, 16).substring(1));
        }
        System.out.println("fixSHA1Header:" + hexStr.toString());
    }

    /**
     * 修改DEX头, file_size值
     * @param dexBytes 二进制数据
     */
    private static void fixFileSizeHeader(byte[] dexBytes) {
        // 新文件长度
        byte[] newFs = intToByte(dexBytes.length);
        System.out.println("fixFileSizeHeader: " + 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("fixFileSizeHeader: " + Integer.toHexString(newFs[i]));
        }
        // 修改32-35
        System.arraycopy(reFs, 0, dexBytes, 32, 4);
    }

    /**
     * int 转 byte[]
     * @param number 整型
     * @return 返回字节数组
     */
    private 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;
    }



    /**
     * 读出文件的二进制数据
     * @param file 文件
     * @return 二进制数据
     */
    private static byte[] readFileBytes(File file) throws IOException {
        byte[] bytes = new byte[1024];
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        FileInputStream fis = new FileInputStream(file);
        while (true) {
            int len = fis.read(bytes);
            if (-1 == len) break;
            baos.write(bytes, 0, len);
        }
        byte[] byteArray = baos.toByteArray();
        fis.close();
        baos.close();
        return byteArray;
    }

    /**
     * 加密二进制数据
     * @param srcData 源数据
     * @return 加密后的数据
     */
    private static byte[] encrypt(byte[] srcData) {
        for (int i = 0; i < srcData.length; i++) {
            srcData[i] ^= 0xFF;
        }
        return srcData;
    }
}

项目根目录下新建文件夹 force,将源 APK 放进其中

( 3 )脱壳 DEX

编辑脱壳 APK 的解密部分和内容替换部分,取出其中的 DEX 文件,即脱壳DEX
在这里插入图片描述

( 1 )自定义 Application

首先,自定义 Application,在 AndroidManifest.xml 指定名称为
ProxyApplication,利用 Android Studio 可以自动生成
ProxyApplication.java 文件。同时,将源 APK 的 Activity 注册进来,

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.exampie.helloworld">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

( 2 )attachBaseContext 方法实现

package com.exampie.myapplication;

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

public class RefInvoke {
    /**
     * 反射执行类的静态函数(public)
     *
     * @param className  类名
     * @param methodName 方法名
     * @param pareTypes  函数的参数类型
     * @param pareValues 调用函数时传入的参数
     * @return
     */
    public static Object invokeStaticMethod(String className, String methodName, Class[] pareTypes, Object[] pareValues) {
        try {
            Class objClass = Class.forName(className);
            Method method = objClass.getMethod(methodName, pareTypes);
            return method.invoke(null, pareValues);
        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 反射执行的函数(public)
     *
     * @param className  类名
     * @param methodName 方法名
     * @param obj        对象
     * @param pareTypes  参数类型
     * @param pareValues 调用方法传入的参数
     * @return
     */
    public static Object invokeMethod(String className, String methodName, Object obj, Class[] pareTypes, Object[] pareValues) {
        try {
            Class objClass = Class.forName(className);
            Method method = objClass.getMethod(methodName, pareTypes);
            return method.invoke(obj, pareValues);
        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 反射得到类的属性(包括私有和保护)
     *
     * @param className 类名
     * @param obj       对象
     * @param fieldName 属性名
     * @return
     */
    public static Object getFieldObject(String className, Object obj, String fieldName) {
        try {
            Class objClass = Class.forName(className);
            Field field = objClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 反射得到类的静态属性(包括私有和保护)
     *
     * @param className 类名
     * @param fieldName 属性名
     * @return
     */
    public static Object getStaticFieldObject(String className, String fieldName) {
        try {
            Class objClass = Class.forName(className);
            Field field = objClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(null);
        } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 设置类的属性(包括私有和保护)
     *
     * @param className  类名
     * @param fieldName  属性名
     * @param obj        对象
     * @param fieldValue 字段值
     */
    public static void setFieldObject(String className, String fieldName, Object obj, Object fieldValue) {
        try {
            Class objClass = Class.forName(className);
            Field field = objClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(obj, fieldValue);
        } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置类的静态属性(包括私有和保护)
     *
     * @param className  类名
     * @param fieldName  属性名
     * @param fieldValue 属性值
     */
    public static void setStaticObject(String className, String fieldName, String fieldValue) {
        try {
            Class objClass = Class.forName(className);
            Field field = objClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(null, fieldValue);
        } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}

( 3 )onCreate 方法实现

在 ProxyApplication.java :

package com.exampie.myapplication;

import android.app.Application;
import android.app.Instrumentation;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.util.ArrayMap;
import android.util.Log;


import androidx.annotation.RequiresApi;

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.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import dalvik.system.DexClassLoader;

public class ProxyApplication extends Application {
    private static final String TAG = ProxyApplication.class.getSimpleName();
    /**
     * APP_KEY获取Activity入口
     */
    private static final String APP_KEY = "APPLICATION_CLASS_NAME";
    /**ActivityThread包名*/
    private static final String CLASS_NAME_ACTIVITY_THREAD = "android.app.ActivityThread";
    /**LoadedApk包名*/
    private static final String CLASS_NAME_LOADED_APK = "android.app.LoadedApk";
    /**
     * 源Apk路径
     */
    private String mSrcApkFilePath;
    /**
     * odex路径
     */
    private String mOdexPath;
    /**
     * lib路径
     */
    private String mLibPath;

    /**
     * 最先执行的方法
     */
    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        Log.d(TAG, "attachBaseContext: --------onCreate");

        try {
            // 创建payload_odex和payload_lib文件夹,payload_odex中放置源apk即源dex,payload_lib放置so文件
            File odex = this.getDir("payload_odex", MODE_PRIVATE);
            File libs = this.getDir("payload_lib", MODE_PRIVATE);
            // 用于存放源apk释放出来的dex
            mOdexPath = odex.getAbsolutePath();
            // 用于存放源apk用到的so文件
            mLibPath = libs.getAbsolutePath();
            // 用于存放解密后的apk即源apk
            mSrcApkFilePath = mOdexPath + "/payload.apk";

            File srcApkFile = new File(mSrcApkFilePath);
            Log.d(TAG, "attachBaseContext: apk size: " + srcApkFile.length());

            // 第一次加载
            if (!srcApkFile.exists()) {
                Log.d(TAG, "attachBaseContext: isFirstLoading");
                // 拿到源apk的dex文件
                byte[] dexData = this.readDexFileFromApk();
                // 取出解密后的apk放置在/payload.apk,及其so文件放置在payload_lib下
                this.splitPayLoadFromDex(dexData);
            }

            // 配置动态加载环境
            // 反射获取主线程对象,并从中获取所有已加载的package信息,找到当前LoadApk的弱引用
            // 获取主线程对象
            Object currentActivityThread = RefInvoke.invokeStaticMethod(
                    CLASS_NAME_ACTIVITY_THREAD, "currentActivityThread",
                    new Class[]{}, new Object[]{}
            );
            // 获取当前报名
            String packageName = this.getPackageName();
            // 获取已加载的所有包
            ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldObject(
                    CLASS_NAME_ACTIVITY_THREAD, currentActivityThread,
                    "mPackages"
            );
            // 获取LoadApk的弱引用
            WeakReference wr = (WeakReference) mPackages.get(packageName);
            Log.d(TAG,"获取LoadApk的弱引用");
            // 创建一个新的DexClassLoader用于加载源Apk
            // 传入apk路径,dex释放路径,so路径,及父节点的DexClassLoader使其遵循双亲委托模型
            // 反射获取属性ClassLoader
            Object mClassLoader = RefInvoke.getFieldObject(
                    CLASS_NAME_LOADED_APK, wr.get(), "mClassLoader"
            );
            // 定义新的DexClassLoader对象,指定apk路径,odex路径,lib路径
            DexClassLoader dLoader = new DexClassLoader(
                    mSrcApkFilePath, mOdexPath, mLibPath, (ClassLoader) mClassLoader
            );
            // getClassLoader()等同于 (ClassLoader) RefInvoke.getFieldOjbect()
            // 但是为了替换掉父节点我们需要通过反射来获取并修改其值
            Log.d(TAG, "attachBaseContext: 父ClassLoader: " + mClassLoader);

            // 将父节点DexClassLoader替换
            RefInvoke.setFieldObject(
                    CLASS_NAME_LOADED_APK,
                    "mClassLoader",
                    wr.get(),
                    dLoader
            );

            Log.d(TAG, "attachBaseContext: 子ClassLoader: " + dLoader);

            // 测试
            try {
                // 尝试加载源apk的MainActivity
                Object actObj = dLoader.loadClass("com.example.apkreinforcement.MainActivity");
                Log.d(TAG, "attachBaseContext: SrcApk_MainActivity: " + actObj);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
                Log.d(TAG, "attachBaseContext: LoadSrcActivityErr: " + Log.getStackTraceString(e));
            }

        } catch (IOException e) {
            e.printStackTrace();
            Log.d(TAG, "attachBaseContext: error: " + Log.getStackTraceString(e));
        }

    }

    /**
     * 从DEX中分割出资源
     * @param dexData dex资源
     */
    private void splitPayLoadFromDex(byte[] dexData) throws IOException {
        // 获取dex数据长度
        int len = dexData.length;
        // 存储被加壳apk的长度
        byte[] dexLen = new byte[4];
        // 获取最后4个字节数据
        System.arraycopy(dexData, len - 4, dexLen, 0, 4);
        ByteArrayInputStream bais = new ByteArrayInputStream(dexLen);
        DataInputStream in = new DataInputStream(bais);
        // 获取被加密apk的长度
        int readInt = in.readInt();
        // 打印被加密apk的长度
        Log.d(TAG, "splitPayLoadFromDex: Integer.toHexString(readInt): " + Integer.toHexString(readInt));

        // 取出apk
        byte[] enSrcApk = new byte[readInt];
        // 将被加密apk内容复制到二进制数组中
        System.arraycopy(dexData, len - 4 - readInt, enSrcApk, 0, readInt);

        // 对源apk解密
        byte[] srcApk = decrypt(enSrcApk);
        Log.d(TAG,"原APK解密成功");

        // 写入源apk文件
        File file = new File(mSrcApkFilePath);
        try {
            if(file.createNewFile()){
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(srcApk);
                fos.close();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // 分析源apk文件
        ZipInputStream zis = new ZipInputStream(
                new BufferedInputStream(
                        new FileInputStream(file)
                )
        );

        // 遍历压缩包
        while (true) {
            ZipEntry entry = zis.getNextEntry();
            // 判断是否有内容
            if (null == entry) {
                zis.close();
                break;
            }

            // 依次取出被加壳的apk用到的so文件,放到libPath中(data/data/包名/paytload_lib)
            String name = entry.getName();
            if (name.startsWith("lib/") && name.endsWith(".so")) {
                // 存储文件
                File storeFile = new File(
                        mLibPath + "/" + name.substring(name.lastIndexOf('/'))
                );
                storeFile.createNewFile();
                FileOutputStream fos = new FileOutputStream(storeFile);
                byte[] bytes = new byte[1024];
                while (true) {
                    int length = zis.read(bytes);
                    if (-1 == length) break;
                    fos.write(bytes);
                }
                fos.flush();
                fos.close();
            }
            zis.closeEntry();
        }
        zis.close();
    }

    /**
     * 解密二进制
     * @param srcData 二进制数
     * @return 解密后的二进制数据
     */
    private byte[] decrypt(byte[] srcData) {
        for (int i = 0; i < srcData.length; i++) {
            srcData[i] ^= 0xFF;
        }
        return srcData;
    }

    /**
     * 从新APK中获取加密APK的DEX文件
     * @return dex字节数组
     */
    private byte[] readDexFileFromApk() throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ZipInputStream zis = new ZipInputStream(
                new BufferedInputStream(
                        new FileInputStream(this.getApplicationInfo().sourceDir)
                )
        );
        // 遍历压缩包
        while (true) {
            ZipEntry entry = zis.getNextEntry();
            if (null == entry) {
                zis.close();
                break;
            }
            // 获取dex文件
            if ("classes.dex".equals(entry.getName())) {
                byte[] bytes = new byte[1024];
                while (true) {
                    int len = zis.read(bytes);
                    if (len == -1) break;
                    baos.write(bytes, 0, len);
                }
                Log.d(TAG,"classes.dex读取成功");
            }
            zis.closeEntry();
        }
        zis.close();
        return baos.toByteArray();
    }

    // 后续实现
    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate: ---------------");

        // 获取配置在清单文件的源apk的Application路径
        String appClassName = null;
        try {
            // 创建应用信息对象
            ApplicationInfo ai = this.getPackageManager().getApplicationInfo(this.getPackageName(), PackageManager.GET_META_DATA);
            // 获取metaData数据
            Bundle bundle = ai.metaData;
            if (null != bundle && bundle.containsKey(APP_KEY)) {
                appClassName = bundle.getString(APP_KEY);
            } else {
                Log.d(TAG, "onCreate: have no application class name");
                return;
            }
        } catch (PackageManager.NameNotFoundException e) {
            Log.d(TAG, "onCreate: error: " + Log.getStackTraceString(e));
            e.printStackTrace();
        }

        // 获取当前Activity线程
        Object currentActivityThread = RefInvoke.invokeStaticMethod(CLASS_NAME_ACTIVITY_THREAD,
                "currentActivityThread", new Class[]{}, new Object[]{});
        // 获取绑定的应用
        Object mBoundApplication = RefInvoke.getFieldObject(CLASS_NAME_ACTIVITY_THREAD,
                currentActivityThread, "mBoundApplication");
        // 获取加载apk的信息
        Object loadedApkInfo = RefInvoke.getFieldObject(
                CLASS_NAME_ACTIVITY_THREAD + "$AppBindData",
                mBoundApplication, "info"
        );
        // 将LoadedApk中的ApplicationInfo设置为null
        RefInvoke.setFieldObject(CLASS_NAME_LOADED_APK, "mApplication", loadedApkInfo, null);
        // 获取currentActivityThread中注册的Application
        Object oldApplication = RefInvoke.getFieldObject(
                CLASS_NAME_ACTIVITY_THREAD, currentActivityThread, "mInitialApplication"
        );
        // 获取ActivityThread中所有已注册的Application, 并将当前壳Apk的Application从中移除
        ArrayList<Application> mAllApplications = (ArrayList<Application>) RefInvoke.getFieldObject(
                CLASS_NAME_ACTIVITY_THREAD, currentActivityThread, "mAllApplications"
        );
        mAllApplications.remove(oldApplication);
        // 从loadedApk中获取应用信息
        ApplicationInfo appInfoInLoadedApk = (ApplicationInfo) RefInvoke.getFieldObject(
                CLASS_NAME_LOADED_APK, loadedApkInfo, "mApplicationInfo"
        );
        // 从AppBindData中获取应用信息
        ApplicationInfo appInfoInAppBindData = (ApplicationInfo) RefInvoke.getFieldObject(
                CLASS_NAME_ACTIVITY_THREAD + "$AppBindData", mBoundApplication, "appInfo"
        );
        // 替换原来的Application
        appInfoInLoadedApk.className = appClassName;
        appInfoInAppBindData.className = appClassName;

        // 注册Application
        Application app = (Application) RefInvoke.invokeMethod(
                CLASS_NAME_LOADED_APK, "makeApplication", loadedApkInfo,
                new Class[]{boolean.class, Instrumentation.class},
                new Object[]{false, null}
        );
        // 替换ActivityThread中的Application
        RefInvoke.setFieldObject(CLASS_NAME_ACTIVITY_THREAD, "mInitialApplication",
                currentActivityThread, app);
        ArrayMap mProviderMap = (ArrayMap) RefInvoke.getFieldObject(
                CLASS_NAME_ACTIVITY_THREAD, currentActivityThread, "mProviderMap"
        );

        // 遍历
        for (Object providerClientRecord : mProviderMap.values()) {
            Object localProvider = RefInvoke.getFieldObject(
                    CLASS_NAME_ACTIVITY_THREAD + "$ProviderClientRecord",
                    providerClientRecord, "mLocalProvider"
            );
            RefInvoke.setFieldObject("android.content.ContentProvider", "mContext",
                    localProvider, app);
        }

        Log.d(TAG, "onCreate: SrcApp: " + app);
        // 调用新的Application
        app.onCreate();
    }

}

至此脱壳目录如下
在这里插入图片描述

( 4 )新 DEX

使用加密和拼接工具(函数)对源 APK 进行加密、拼接到脱壳 DEX,得到新DEX
这一步开始,实际就是测试部分。

1、打包源 APK,这里是 helloWorld.apk。
在这里插入图片描述

2、打包脱壳 APK,这里是 默认.apk,使用解压软件打开,将其中的 classes.dex,即脱壳 DEX,拷贝出来:
在这里插入图片描述
在这里插入图片描述
运行加密和拼接函数,即 MyClass.main(),此时会生成 classesShell.dex:

在这里插入图片描述

( 5 )新 APK

对新 DEX 打包,生成新 APK
使用新 DEX 替换掉apk 里的 classes.dex
在这里插入图片描述
为 apk 被修改,所以要对其重新签名。同样打开新 APK,将其 METAIMF 文件夹删除,然后使用 jarsigner 重新签名:

jarsigner -verbose -keystore IS.keystore xx.apk IS1601

弹出日志
在这里插入图片描述
可见已经加载出了源 APK 内容。
在这里插入图片描述
该源 APK 可以直接安装运行,前提是给予相关权限。
再观察一下 AndroidKiller 逆向情况,并无 MainActivity,源 APK 内容隐藏
成功
在这里插入图片描述

标签:dex,APK,apk,import,new,byte,加壳
来源: https://blog.csdn.net/Cloud_Player/article/details/118018442