VirtualApp Java层Hook基础

最新推荐文章于 2024-05-08 06:50:23 发布
最新推荐文章于 2024-05-08 06:50:23 发布
阅读量6k 收藏 10
点赞数 3
分类专栏： Android 动态部署 Android插件化 文章标签： Android 插件化 VirtualApp Hook
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ximsfei/article/details/75050164
版权

VirtualApp Java层Hook基础-反射注入

Hook技术是VirtualApp(后续简称VA)的核心实现原理之一。

0x00. 什么是Hook

Hook是Windows中提供的一种用以替换DOS下“中断”的系统机制，中文译为“挂钩”或“钩子”。在对特定的系统事件进行hook后，一旦发生已hook事件，对该事件进行hook的程序就会收到系统的通知，这时程序就能在第一时间对该事件做出响应。 – 来自百度百科

在Android插件化中的Hook机制一般是通过反射注入和动态代理来实现的。

0x01. Hook实现

Android中的Hook本身依赖反射机制，VA的Hook框架基于注解的反射注入技术实现的极为优雅，初看源码可能会不知所云，深入研究就会发现VA虽然模拟了整个AndroidFramework，Hook了大量对象，代码却依然井井有条。

基于VA，研究注解的反射注入技术，相关源码:

mirror/
 - RefClass.java
 - RefConstructor.java
 - RefStaticMethod.java
 - RefStaticObject.java
 - RefStaticInt.java
 - RefMethod.java
 - RefObject.java
 - RefBoolean.java
 - RefDouble.java
 - RefFloat.java
 - RefInt.java
 - RefLong.java
 - MethodParams.java
 - MethodReflectParams.java

mirror/android/app/
 - ActivityThread.java

// Android Framework
frameworks/base/core/java/android/app/
 - ActivityThread.java

ActivityThread的反射注入-普通实现

public class PluginInstrumentation extends Instrumentation {
    private final Instrumentation mBase;

    public PluginInstrumentation(Instrumentation base) {
        mBase = base;
    }
}

public class HookHelper {
    public static void inject() throws Exception {
        Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
        Method currentActivityThreadMethod = activityThreadClass.getMethod("currentActivityThread");
        currentActivityThreadMethod.setAccessible(true);
        Object currentActivityThread = currentActivityThreadMethod.invoke(null);
        Field instrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");
        instrumentationField.setAccessible(true);
        Instrumentation instrumentation = (Instrumentation) instrumentationField.get(currentActivityThread);
        // HookHelper: 反射注入前 instrumentation = android.app.Instrumentation@3520a6d
        Log.e("HookHelper", "反射注入前 instrumentation = " + instrumentationField.get(currentActivityThread));
        if(!(instrumentation instanceof PluginInstrumentation)) {
            instrumentationField.set(currentActivityThread, new PluginInstrumentation(instrumentation));
        }
        // HookHelper: 反射注入后 instrumentation = com.ximsfei.kotlin.hook.PluginInstrumentation@669d6a2
        Log.e("HookHelper", "反射注入后 instrumentation = " + instrumentationField.get(currentActivityThread));
    }
}

ActivityThread的反射注入-VA实现

原理介绍

mirror/MethodParams.java

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodParams {
    Class<?>[] value();
}

该注解MethodParams用于标注某个方法(包括构造方法)包含哪些参数。eg: @MethodParams({IBinder.class, List.class}), 参数为Class

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodReflectParams {
    String[] value();
}

该注解MethodReflectParams用于标注某个方法(包括构造方法)包含哪些参数。eg: @MethodReflectParams({"android.content.pm.PackageParser$Package", "int"}), 参数为字符串对象(全类名)，最终通过Class.forName(params);获取对应的Class

public final class RefClass {

    private static HashMap<Class<?>,Constructor<?>> REF_TYPES = new HashMap<Class<?>, Constructor<?>>();
    static {
        try {
            REF_TYPES.put(RefObject.class, RefObject.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefMethod.class, RefMethod.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefInt.class, RefInt.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefLong.class, RefLong.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefFloat.class, RefFloat.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefDouble.class, RefDouble.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefBoolean.class, RefBoolean.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefStaticObject.class, RefStaticObject.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefStaticInt.class, RefStaticInt.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefStaticMethod.class, RefStaticMethod.class.getConstructor(Class.class, Field.class));
            REF_TYPES.put(RefConstructor.class, RefConstructor.class.getConstructor(Class.class, Field.class));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Class<?> load(Class<?> mappingClass, String className) {
        try {
            return load(mappingClass, Class.forName(className));
        } catch (Exception e) {
            return null;
        }
    }

    public static Class load(Class mappingClass, Class<?> realClass) {
        Field[] fields = mappingClass.getDeclaredFields();
        for (Field field : fields) {
            try {
                if (Modifier.isStatic(field.getModifiers())) {
                    Constructor<?> constructor = REF_TYPES.get(field.getType());
                    if (constructor != null) {
                        field.set(null, constructor.newInstance(realClass, field));
                    }
                }
            }
            catch (Exception e) {
                // Ignore
            }
        }
        return realClass;
    }
}

mirror/RefObject.java

Field类封装了Java反射中java.lang.reflect.Field的field.get()和field.set()方法；其他Field类类似。

public class RefObject<T> {
    private Field field;

    public RefObject(Class<?> cls, Field field) throws NoSuchFieldException {
        this.field = cls.getDeclaredField(field.getName());
        this.field.setAccessible(true);
    }

    public T get(Object object) {
        try {
            return (T) this.field.get(object);
        } catch (Exception e) {
            return null;
        }
    }

    public void set(Object obj, T value) {
        try {
            this.field.set(obj, value);
        } catch (Exception e) {
            //Ignore
        }
    }
}

mirror/RefMethod.java

方法类封装了Java反射中java.lang.reflect.Method的method.invoke()方法；在RefMethod构造方法中，会根据不同的注解MethodParams, MethodReflectParams获取对应的方法参数，从而获取对应的Method。如果没有注解，表明对应方法没有参数。

public class RefMethod<T> {
    private Method method;

    public RefMethod(Class<?> cls, Field field) throws NoSuchMethodException {
        if (field.isAnnotationPresent(MethodParams.class)) {
            Class<?>[] types = field.getAnnotation(MethodParams.class).value();
            for (int i = 0; i < types.length; i++) {
                Class<?> clazz = types[i];
                if (clazz.getClassLoader() == getClass().getClassLoader()) {
                    try {
                        Class.forName(clazz.getName());
                        Class<?> realClass = (Class<?>) clazz.getField("TYPE").get(null);
                        types[i] = realClass;
                    } catch (Throwable e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            this.method = cls.getDeclaredMethod(field.getName(), types);
            this.method.setAccessible(true);
        } else if (field.isAnnotationPresent(MethodReflectParams.class)) {
            String[] typeNames = field.getAnnotation(MethodReflectParams.class).value();
            Class<?>[] types = new Class<?>[typeNames.length];
            for (int i = 0; i < typeNames.length; i++) {
                Class<?> type = getProtoType(typeNames[i]);
                if (type == null) {
                    try {
                        type = Class.forName(typeNames[i]);
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
                types[i] = type;
            }
            this.method = cls.getDeclaredMethod(field.getName(), types);
            this.method.setAccessible(true);
        }
        else {
            for (Method method : cls.getDeclaredMethods()) {
                if (method.getName().equals(field.getName())) {
                    this.method = method;
                    this.method.setAccessible(true);
                    break;
                }
            }
        }
        if (this.method == null) {
            throw new NoSuchMethodException(field.getName());
        }
    }

    public T call(Object receiver, Object... args) {
        try {
            return (T) this.method.invoke(receiver, args);
        } catch (InvocationTargetException e) {
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            } else {
                e.printStackTrace();
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

    public T callWithException(Object receiver, Object... args) throws Throwable {
        try {
            return (T) this.method.invoke(receiver, args);
        } catch (InvocationTargetException e) {
            if (e.getCause() != null) {
                throw e.getCause();
            }
            throw e;
        }
    }

    public Class<?>[] paramList() {
        return method.getParameterTypes();
    }
}

mirror/RefConstructor.java

构造方法类封装了Java反射中java.lang.reflect.Constructor的ctor.newInstance()方法。

public class RefConstructor<T> {
    private Constructor<?> ctor;

    public RefConstructor(Class<?> cls, Field field) throws NoSuchMethodException {
        if (field.isAnnotationPresent(MethodParams.class)) {
            Class<?>[] types = field.getAnnotation(MethodParams.class).value();
            ctor = cls.getDeclaredConstructor(types);
        } else if (field.isAnnotationPresent(MethodReflectParams.class)) {
            String[] values = field.getAnnotation(MethodReflectParams.class).value();
            Class[] parameterTypes = new Class[values.length];
            int N = 0;
            while (N < values.length) {
                try {
                    parameterTypes[N] = Class.forName(values[N]);
                    N++;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            ctor = cls.getDeclaredConstructor(parameterTypes);
        } else {
            ctor = cls.getDeclaredConstructor();
        }
        if (ctor != null && !ctor.isAccessible()) {
            ctor.setAccessible(true);
        }
    }

    public T newInstance() {
        try {
            return (T) ctor.newInstance();
        } catch (Exception e) {
            return null;
        }
    }

    public T newInstance(Object... params) {
        try {
            return (T) ctor.newInstance(params);
        } catch (Exception e) {
            return null;
        }
    }
}
VA实例

对应ActivityThread的反射注入-普通实现，在VA中的反射注入实现:

mirror/android/app/ActivityThread.java

在mirror.android.app.ActivityThread类加载时，会调用RefClass.load(ActivityThread.class, "android.app.ActivityThread");方法，遍历mirror.android.app.ActivityThread的成员变量，并从android.app.ActivityThread中获取对应的Field封装成上述类赋给mirror.android.app.ActivityThread。

public class ActivityThread {
    public static Class<?> TYPE = RefClass.load(ActivityThread.class, "android.app.ActivityThread");
    public static RefStaticMethod currentActivityThread;
    public static RefMethod<String> getProcessName;
    public static RefMethod<Handler> getHandler;
    public static RefMethod<Object> installProvider;
    public static RefObject<Object> mBoundApplication;
    public static RefObject<Handler> mH;
    public static RefObject<Application> mInitialApplication;
    public static RefObject<Instrumentation> mInstrumentation;
    public static RefObject<Map<String, WeakReference<?>>> mPackages;
    public static RefObject<Map> mProviderMap;
    @MethodParams({IBinder.class, List.class})
    public static RefMethod<Void> performNewIntents;
    public static RefStaticObject<IInterface> sPackageManager;
    @MethodParams({IBinder.class, String.class, int.class, int.class, Intent.class})
    public static RefMethod<Void> sendActivityResult;
    public static RefMethod<Binder> getApplicationThread;
}

注: 在mirror.android.app.ActivityThread中的成员变量必须与framework中android.app.ActivityThread中对应的成员变量名相同，因为在RefClass.load()方法中是通过遍历mirror.android.app.ActivityThread中的Fields来获取对应的android.app.ActivityThread中的Fields的

com/lody/virtual/client/hook/delegate/AppInstrumentation.java

在业务层使用的时候，只需要调用ActivityThread.mInstrumentation.get(VirtualCore.mainThread());方法就可以获取当前android.app.ActivityThread中mInstrumentation的值，调用ActivityThread.mInstrumentation.set(VirtualCore.mainThread(), this);就可以通过反射注入业务层自己实现的AppInstrumentation了。

public final class AppInstrumentation extends InstrumentationDelegate implements IInjector {
    ...

    private AppInstrumentation(Instrumentation base) {
        super(base);
    }


    @Override
    public void inject() throws Throwable {
        base = ActivityThread.mInstrumentation.get(VirtualCore.mainThread());
        ActivityThread.mInstrumentation.set(VirtualCore.mainThread(), this);
    }

    ...
}

0x02. 总结

对比ActivityThread的反射注入-普通实现和ActivityThread的反射注入-VA实现，初一看，可能觉得VA实现多了很多代码，还有些绕；但是普通方法实现，每对一个属性进行反射注入都需要写下方流程中的所有代码，或者部分代码；通过VA的实现方法，只需要在对应的类中(例如: mirror.android.app.ActivityThread)写上需要反射注入的属性，业务层代码也更简洁可读性更高。

反射注入的一般流程

  1. 获取需要注入的类的Class对象

Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");

  1. 获取Class对象中需要注入的Field

Field instrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");

  1. 通过Field的set方法注入业务层已实现的对象

instrumentationField.set(currentActivityThread, new PluginInstrumentation(instrumentation));

反射调用方法的一般流程

  1. 获取需要注入的类的Class对象

Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");

  1. 获取Class对象中需要调用的Method

Method currentActivityThreadMethod = activityThreadClass.getMethod("currentActivityThread");

  1. 通过Method的invoke方法调用

Object currentActivityThread = currentActivityThreadMethod.invoke(null);

Github地址: https://github.com/ximsfei/RefInject

ximsfei
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓 java hook 免root_通过 VirtualApp 实现免 Root 权限 Hook
weixin_40000702的博客
02-16 636
一、前言之前写的 「装X指南之Xposed安装与配置」，有人反馈手机 root 风险较大，而且操作成本高，有没有什么方法是不需要 root 就能够实现 hook 的或者不需要 Xposed 也能玩起插件的？于是就有了这篇文章，离开 Xposed ，带你免 root 实现 hook！二、VirtualApp1、关于 VirtualApp 的介绍VA目前被广泛应用于插件化开发、无感知热更新、自动化、多...
AndroidHook机制——VirtualHook
精益求精
08-15 1086
对于Android应用安全研究人员来说，Xposed想必一定不陌生。作为一款流行的应用hook框架，Xposed允许对应用进行无感知的hook。许多实用工具，例如早期的脱壳工具Zjdroid，关闭证书强校验的JustTrustMe，Android恶意应用分析沙盒Cuckoo-Droid等，均是通过Xposed完成。然而，从Android 5.0时代起，DVM模式被ART模式取代，代码执行的机制进行...
2024年最全APP安全测试——HOOK技术_app hook(1)，大厂软件测试高级多套面试专题整理集合
最新发布
2401_84562251的博客
05-08 695
在程序中将其理解为”劫持“可能会更好理解，我们可以通过hook技术来劫持某个对象，从而控制它与其他对象的交互。Hook 的这个本领，使它能够将自身的代码「融入」被勾住（Hook）的程序的进程中，成为目标进程的一个部分。API Hook 技术是一种用于改变 API 执行结果的技术，能够将系统的 API 函数执行重定向。在 Android 系统中使用了沙箱机制，普通用户程序的进程空间都是独立的，程序的运行互不干扰。
装X指南之通过 VirtualApp 实现免 Root 权限 Hook
behindeye的博客
01-20 3352
一、前言 之前写的 「装X指南之Xposed安装与配置」，有人反馈手机 root 风险较大，而且操作成本高，有没有什么方法是不需要 root 就能够实现 hook 的或者不需要 Xposed 也能玩起插件的？于是就有了这篇文章，离开 Xposed ，带你免 root 实现 hook！ 二、VirtualApp 1、关于 VirtualApp 的介绍 VA目前被广泛应用于插件化开发、无感知热更新...
【VirtualAPP 双开系列03】动态代理-hook系统服务(Java层)
u014294681的博客
04-08 712
目录： 1. Hook 简述 2. ADocker Java Hook 类图 3.ADocker Java Hook实例 (ActivityManagerService) 1. Hook 简述 我们先来了解下 hook.(1) 什么是 Hook Hook 又叫“钩子”，它可以在事件传送的过程中截获并监控事件的传输，将自身的代码与系统方法进行融入。这样当这些方法被调用时，也就可以执行我们自己的代码，这也是面向切面编程的思想（AOP）。(2) Hook 分类 (3) Hook 框架 大...
VirtualApp沙盒基本原理
热门推荐
云守护的专栏
05-03 2万+
转自：http://rk700.github.io/2017/03/15/virtualapp-basic/ VirtualApp是一个开源的Android App虚拟化引擎，允许在其中创建虚拟空间，并在这个虚拟空间中运行其他应用。通过阅读源码及动态调试，基本了解了其运行原理，在此记录。 本质 Android应用隔离是基于Linux系统的多用户机制实现的，即每个应用在安装
VirtualApp：具有Android 101112兼容性的VirtualApp
03-04
VirtualApp工程全新体验，多种优化特性高级，高稳定性，修复重建错误等等本内核仅供开发人员参考，请勿构建成品并发表到任何地方仅供自行测试使用如有修改建议欢迎提交PR本项目为商业版开源，修改可看commit开源网站...
FridaAndroid02-JAVA层HOOK 示例程序
03-26
【Frida】【Android】02_JAVA层HOOK 示例程序
VirtualApp源码（完整工程）
06-21
在分析和学习这个源码时，开发者需要具备扎实的Java和C/C++基础，熟悉Android的系统架构和组件模型，理解进程和线程的管理，以及熟练运用Android Studio进行项目构建和调试。同时，对于想要深入研究虚拟化技术的人来...
java hook demo
04-09
Java Hook 和 Android Hook 是两种在Java和Android平台上进行动态代码修改和行为监控的技术。它们主要应用于调试、性能分析、安全检测以及插件化开发等领域。本文将深入探讨这两种技术的概念、原理及其应用。 首先...
Xposed的一个Hook模块，用于java加密算法破解.zip
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
Android代码-VirtualHook
08-07
VirtualHook Introduction VirtualHook is a tool for hooking application without root permission. It is based on two projects: VirtualApp. It's a plugin framework which allows running applications in its virtual space. YAHFA. It's a hook framework for ART which allows hooking Java method of the application. Currently VirtualHook supports: Android 5.0(API 21) Android 5.1(API 22) Android 6.0(API 23) Android 7.0(API 24) Android 7.1(API 25) Android 8.0(API 26) ChangeLog Basically, VirtualHook make
通过 VirtualApp 实现免 Root 权限 Hook
2401_84122965的博客
04-04 983
JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，静态方法和静态差不多，区别就是，静态的方法在hook和origin的参数中，内部类只是编译时的概念，一旦编译成功，就会出现两个不同的类，例如，类。类的包名，如果需要改的话，要同时改。
对 VirtualApp hook过程的理解
qq_25020915的博客
09-25 3261
对virtualapp的讲解 网上已经很详细了，我想从一个例子加深一下对va hook过程的理解。
安卓 java hook 免root_[原创]利用VirtualApp实现免Root注入Hook（一）
weixin_42303616的博客
02-16 1115
才疏学浅，如有不对，请轻拍。一个话题，将一个so注入到App中有几种方式？1.Root，直接注入。想必论坛的大部分人已经都会了，拿到了Root之后，我们可以利用ptrace直接注入。所以加固的第一点，便是反调试。2.Root，将so作为系统so，这样任何App起来都得把so加载到app进程当中。xposed的方式是重写孵化器，让孵化器能够加载自己的so，从而控制整个安卓。所以很多加固会去识别特征码...
VirtualHook使用
chencangui的专栏
11-30 1126
背景 想要逆向分析其他应用，除了需要有smali语法功底外，一套好用的良好的逆向装备也是必不可少的，并且当我们想要更加深入去了解一款app的实现的时候，可能还需要用到调试、替换(修改原有的逻辑)，解决方案有很多种，这里推荐使用apktool + jadx + virtualhook，apktool解决资源文件的问题，jadx解决反编译查看代码的问题，virtualhook解决热替换的要求。 环...
android无感知拍照github,装X指南之通过 VirtualApp 实现免 Root 权限 Hook
weixin_26854475的博客
05-27 753
装X指南之通过 VirtualApp 实现免 Root 权限 Hook一、前言之前写的 「装X指南之Xposed安装与配置」，有人反馈手机 root 风险较大，而且操作成本高，有没有什么方法是不需要 root 就能够实现 hook 的或者不需要 Xposed 也能玩起插件的？于是就有了这篇文章，离开 Xposed ，带你免 root 实现 hook！二、VirtualApp1、关于 Virtual...
探索VirtualHook：一款强大的Windows钩子库
gitblog_00056的博客
04-12 321
探索VirtualHook：一款强大的Windows钩子库 项目地址:https://gitcode.com/rk700/VirtualHook 项目简介 VirtualHook 是一个开源的C++库，专为Windows平台设计，提供了一种高效、灵活的方式来实现系统级别的钩子（Hooks）。该项目的目标是简化复杂且易出错的钩子编程，让开发者能够更轻松地监控和拦截应用程序的输入事件，如键盘、鼠标操作...
VirtualApp - 独立式 Resource hook
jonas_xu的博客
02-09 3015
基于之前对插件化的了解，大部分的插件对于资源都是合并式的，通过addAssetPath将插件的资源加入到assetManager中，这种方式会带来一个问题:resource id冲突。当然目前已经有方案去解决:aapt或者修改arsc文件。VirtualApp中可以安装任意的第三方APK，如果采用合并式资源加载方案，那肯定也会有resource id冲突问题，但上面说的解决方案都需要第三方APK去...
frida hook java层aes代码
06-07
以下是使用Frida hook Java层AES加密函数的JavaScript代码示例： ```javascript Java.perform(function() { // 找到目标类 var targetClass = Java.use("com.example.MyClass"); // hook目标函数 targetClass.encrypt.overload('[B', '[B').implementation = function(data, key) { // 打印参数 console.log("[*] Data: " + data); console.log("[*] Key: " + key); // 调用原始函数 var result = this.encrypt(data, key); // 打印返回值 console.log("[*] Encrypted Data: " + result); // 返回真正的返回值 return result; }; }); ``` 以上代码示例是使用Frida hook Java层AES加密函数，并在函数执行前后打印函数参数和返回值。如果需要修改加密算法，可以在hook函数中修改参数或者返回值。需要注意的是，因为Java代码是运行在虚拟机中的，所以hook Java层函数需要使用Java.use()方法来获取目标类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值