【逆向工程核心原理：API钩取】

最新推荐文章于 2024-05-31 10:36:01 发布
最新推荐文章于 2024-05-31 10:36:01 发布
阅读量487 收藏 1
点赞数
分类专栏： # 逆向工程核心原理 文章标签： windows c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42363151/article/details/129938432
版权
0x01、原理
  1. 通过钩子代码，来调试被钩取程序。
  2. 此时钩子代码就是调式器，被钩取程序就是被调试者。
  3. 钩子代码在要被钩取程序的API位置下 0xCC 断点.
  4. 当被调试者运行到断点处时，就会触发断点异常，此时要调试器来处理。
  5. 此时就可以更改要钩取的API的函数功能，达到自己的目的。
  6. 执行完放开让程序继续执行。
0x02、源代码
#include "windows.h"
#include "stdio.h"

LPVOID g_pfWriteFile = NULL;
CREATE_PROCESS_DEBUG_INFO g_cpdi;
BYTE g_chINT3 = 0xCC, g_chOrgByte = 0;

BOOL OnCreateProcessDebugEvent(LPDEBUG_EVENT pde)
{
    // WriteFile()获取API地址
    g_pfWriteFile = GetProcAddress(GetModuleHandleA("kernel32.dll"), "WriteFile");

    // API Hook - WriteFile()
    //   将第一个byte更改为0xCC（INT3）
    //   (orginal byte是备份)
    memcpy(&g_cpdi, &pde->u.CreateProcessInfo, sizeof(CREATE_PROCESS_DEBUG_INFO));
    ReadProcessMemory(g_cpdi.hProcess, g_pfWriteFile, 
                      &g_chOrgByte, sizeof(BYTE), NULL);
    WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile, 
                       &g_chINT3, sizeof(BYTE), NULL);

    return TRUE;
}

BOOL OnExceptionDebugEvent(LPDEBUG_EVENT pde)
{
    CONTEXT ctx;
    PBYTE lpBuffer = NULL;
    DWORD dwNumOfBytesToWrite, dwAddrOfBuffer, i;
    PEXCEPTION_RECORD per = &pde->u.Exception.ExceptionRecord;

    // 如果是BreakPoint exception（INT3）
    if( EXCEPTION_BREAKPOINT == per->ExceptionCode )
    {
        // 如果BP地址为WriteFile()
        if( g_pfWriteFile == per->ExceptionAddress )
        {
            // #1. Unhook
            //   将0xCC覆盖的部分返回到original byte
            WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile, 
                               &g_chOrgByte, sizeof(BYTE), NULL);

            // #2. 获取Thread Context
            ctx.ContextFlags = CONTEXT_CONTROL;
            GetThreadContext(g_cpdi.hThread, &ctx);

            // #3. 求WriteFile()的param2,3值
            //   函数的参数存在于该进程的堆栈中
            //   param 2 : ESP + 0x8
            //   param 3 : ESP + 0xC
            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0x8), 
                              &dwAddrOfBuffer, sizeof(DWORD), NULL);
            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0xC), 
                              &dwNumOfBytesToWrite, sizeof(DWORD), NULL);

            // #4. 分配临时缓冲区
            lpBuffer = (PBYTE)malloc(dwNumOfBytesToWrite+1);
            memset(lpBuffer, 0, dwNumOfBytesToWrite+1);

            // #5. 将WriteFile()中的缓冲区复制到临时缓冲区
            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, 
                              lpBuffer, dwNumOfBytesToWrite, NULL);
            printf("\n### original string ###\n%s\n", lpBuffer);

            // #6. 小写->大写转换
            for( i = 0; i < dwNumOfBytesToWrite; i++ )
            {
                if( 0x61 <= lpBuffer[i] && lpBuffer[i] <= 0x7A )
                    lpBuffer[i] -= 0x20;
            }

            printf("\n### converted string ###\n%s\n", lpBuffer);

            // #7. 将转换后的缓冲区复制到WriteFile()缓冲区
            WriteProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer, 
                               lpBuffer, dwNumOfBytesToWrite, NULL);
            
            // #8. 禁用临时缓冲区
            free(lpBuffer);

            // #9. 将Thread Context的EIP更改为WriteFile()开头
            //   (目前已通过WriteFile() +1)
            ctx.Eip = (DWORD)g_pfWriteFile;
            SetThreadContext(g_cpdi.hThread, &ctx);

            // #10. 进行Debuggee过程
            ContinueDebugEvent(pde->dwProcessId, pde->dwThreadId, DBG_CONTINUE);
            // 这个Sleep是让程序放弃CPU的时间片，让其他程序执行，此时钩取的notepad才能调用WriteFile函数保存内容
            // 否则，下面的WriteProcessMemory立刻会把WriteFile钩取，notepad去执行WriteFile还是被断下
            Sleep(0);

            // #11. API Hook
            WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile, 
                               &g_chINT3, sizeof(BYTE), NULL);

            return TRUE;
        }
    }

    return FALSE;
}

void DebugLoop()
{
    DEBUG_EVENT de;
    DWORD dwContinueStatus;

    // 等待Debuggee事件发生
    while( WaitForDebugEvent(&de, INFINITE) )
    {
        dwContinueStatus = DBG_CONTINUE;

        // 创建Debuggee进程或attach事件
        if( CREATE_PROCESS_DEBUG_EVENT == de.dwDebugEventCode )
        {
            OnCreateProcessDebugEvent(&de);
        }
        // 异常事件
        else if( EXCEPTION_DEBUG_EVENT == de.dwDebugEventCode )
        {
            if( OnExceptionDebugEvent(&de) )
                continue;
        }
        // Debuggee进程终止事件
        else if( EXIT_PROCESS_DEBUG_EVENT == de.dwDebugEventCode )
        {
            // debuggee结束->debugger结束
            break;
        }

        // 恢复Debuggee的运行
        ContinueDebugEvent(de.dwProcessId, de.dwThreadId, dwContinueStatus);
    }
}

int main(int argc, char* argv[])
{
    DWORD dwPID;

    if( argc != 2 )
    {
        printf("\nUSAGE : hookdbg.exe <pid>\n");
        return 1;
    }

    // Attach Process
    dwPID = atoi(argv[1]);
    if( !DebugActiveProcess(dwPID) )
    {
        printf("DebugActiveProcess(%d) failed!!!\n"
               "Error Code = %d\n", dwPID, GetLastError());
        return 1;
    }

    // 调试器循环
    DebugLoop();

    return 0;
}
0x03、程序执行流程

程序执行流

0x04、结果分析

运用在windows10 32bit Debug/Release
64bit参数结构、寄存器名字不同，需要修改才能使用
x86_debug

0x05、用到的API
// 使调试器可以附加到活动进程并调试它
BOOL WINAPI DebugActiveProcess(
  __in  DWORD dwProcessId// 要附加进程的PID
);

// 等待调试事件发生
BOOL WINAPI WaitForDebugEvent(
  __out  LPDEBUG_EVENT lpDebugEvent,// 接收DEBUG_EVENT结构，保存被调试程序的信息
  __in   DWORD dwMilliseconds// 等待调试事件的毫秒数。如果此参数为零，则函数测试调试事件并立即返回。如果参数为INFINITE，则函数在发生调试事件之前不会返回。
);


// 继续执行被调试的程序
BOOL WINAPI ContinueDebugEvent(
  __in  DWORD dwProcessId,// 继续执行程序的进程
  __in  DWORD dwThreadId,// 继续执行程序的线程
  __in  DWORD dwContinueStatus// DBG_CONTINUE继续执行；DBG_EXCEPTION_NOT_HANDLED交给SEH处理
);

// 获取线程上下文
BOOL WINAPI GetThreadContext(
  __in     HANDLE hThread,// 线程ID
  __inout  LPCONTEXT lpContext// 保存线程上下文的CONTEXT结构
);

// 设定线程上下文
BOOL WINAPI SetThreadContext(
  __in  HANDLE hThread,// 线程ID
  __in  const CONTEXT* lpContext// 要设置的CONTEXT结构
);


// 从目标进程赋复制nsize大小的数据到lpBuffer中
BOOL WINAPI ReadProcessMemory(
  __in   HANDLE hProcess,// 目标进程
  __in   LPCVOID lpBaseAddress,// 读取数据的起始地址，在读取数据前，系统将先检验该地址的数据是否可读，如果不可读，函数将调用失败
  __out  LPVOID lpBuffer,// 读取的数据保存在的缓冲区
  __in   SIZE_T nSize,// 读取数据大小
  __out  SIZE_T* lpNumberOfBytesRead// 实际被读取数据大小的存放地址。如果被指定为NULL,那么将忽略此参数。
);

// 向目标进程写入nsize大小的数据到lpBaseAddress中
BOOL WINAPI WriteProcessMemory(
  __in   HANDLE hProcess,// 目标进程
  __in   LPVOID lpBaseAddress,// 要写入的地址
  __in   LPCVOID lpBuffer,// 要写入的数据存放的缓冲区
  __in   SIZE_T nSize,// 写入数据大小
  __out  SIZE_T* lpNumberOfBytesWritten// 实际写入数据大小的存放地址。如果被指定为NULL,那么将忽略此参数。
);
0x06用到的结构
// 调试事件发生后，保存被调试程序的信息
typedef struct _DEBUG_EVENT {  
	DWORD dwDebugEventCode;  
	DWORD dwProcessId;  
	DWORD dwThreadId;
	// 每种异常也是一个结构体，说一下CREATE_PROCESS_DEBUG_INFO 
	union { 
	EXCEPTION_DEBUG_INFO Exception;    
	CREATE_THREAD_DEBUG_INFO CreateThread;    
	CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;    
	EXIT_THREAD_DEBUG_INFO ExitThread;    
	EXIT_PROCESS_DEBUG_INFO ExitProcess;    
	LOAD_DLL_DEBUG_INFO LoadDll;    
	UNLOAD_DLL_DEBUG_INFO UnloadDll;    
	OUTPUT_DEBUG_STRING_INFO DebugString;    
	RIP_INFO RipInfo;  
	} u;
} DEBUG_EVENT,  *LPDEBUG_EVENT;

typedef struct _CREATE_PROCESS_DEBUG_INFO {  
	HANDLE hFile;  
	HANDLE hProcess;  
	HANDLE hThread;  
	LPVOID lpBaseOfImage;  
	DWORD dwDebugInfoFileOffset;  
	DWORD nDebugInfoSize;  
	LPVOID lpThreadLocalBase;  
	LPTHREAD_START_ROUTINE lpStartAddress;  
	LPVOID lpImageName;  
	WORD fUnicode;
} CREATE_PROCESS_DEBUG_INFO,  *LPCREATE_PROCESS_DEBUG_INFO;

// CONTEXT x86
struct _CONTEXT {
    DWORD ContextFlags;

    DWORD   Dr0;
    DWORD   Dr1;
    DWORD   Dr2;
    DWORD   Dr3;
    DWORD   Dr6;
    DWORD   Dr7;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
    //

    FLOATING_SAVE_AREA FloatSave;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_SEGMENTS.
    //

    DWORD   SegGs;
    DWORD   SegFs;
    DWORD   SegEs;
    DWORD   SegDs;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_INTEGER.
    //

    DWORD   Edi;
    DWORD   Esi;
    DWORD   Ebx;
    DWORD   Edx;
    DWORD   Ecx;
    DWORD   Eax;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_CONTROL.
    //

    DWORD   Ebp;
    DWORD   Eip;
    DWORD   SegCs;              // MUST BE SANITIZED
    DWORD   EFlags;             // MUST BE SANITIZED
    DWORD   Esp;
    DWORD   SegSs;

    //
    // This section is specified/returned if the ContextFlags word
    // contains the flag CONTEXT_EXTENDED_REGISTERS.
    // The format and contexts are processor specific
    //

    BYTE    ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];

} CONTEXT;

// CONTEXT x64
typedef struct _CONTEXT {
  DWORD64 P1Home;
  DWORD64 P2Home;
  DWORD64 P3Home;
  DWORD64 P4Home;
  DWORD64 P5Home;
  DWORD64 P6Home;
  DWORD   ContextFlags;
  DWORD   MxCsr;
  WORD    SegCs;
  WORD    SegDs;
  WORD    SegEs;
  WORD    SegFs;
  WORD    SegGs;
  WORD    SegSs;
  DWORD   EFlags;
  DWORD64 Dr0;
  DWORD64 Dr1;
  DWORD64 Dr2;
  DWORD64 Dr3;
  DWORD64 Dr6;
  DWORD64 Dr7;
  DWORD64 Rax;
  DWORD64 Rcx;
  DWORD64 Rdx;
  DWORD64 Rbx;
  DWORD64 Rsp;
  DWORD64 Rbp;
  DWORD64 Rsi;
  DWORD64 Rdi;
  DWORD64 R8;
  DWORD64 R9;
  DWORD64 R10;
  DWORD64 R11;
  DWORD64 R12;
  DWORD64 R13;
  DWORD64 R14;
  DWORD64 R15;
  DWORD64 Rip;
  union {
    XMM_SAVE_AREA32 FltSave;
    NEON128         Q[16];
    ULONGLONG       D[32];
    struct {
      M128A Header[2];
      M128A Legacy[8];
      M128A Xmm0;
      M128A Xmm1;
      M128A Xmm2;
      M128A Xmm3;
      M128A Xmm4;
      M128A Xmm5;
      M128A Xmm6;
      M128A Xmm7;
      M128A Xmm8;
      M128A Xmm9;
      M128A Xmm10;
      M128A Xmm11;
      M128A Xmm12;
      M128A Xmm13;
      M128A Xmm14;
      M128A Xmm15;
    } DUMMYSTRUCTNAME;
    DWORD           S[32];
  } DUMMYUNIONNAME;
  M128A   VectorRegister[26];
  DWORD64 VectorControl;
  DWORD64 DebugControl;
  DWORD64 LastBranchToRip;
  DWORD64 LastBranchFromRip;
  DWORD64 LastExceptionToRip;
  DWORD64 LastExceptionFromRip;
} CONTEXT, *PCONTEXT;
-Sw0rd-
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
API HOOK 之调试HOOK hookdbg.exe源代码结构分析——《逆向工程核心原理》读书笔记
qq_41170946的博客
02-06 334
源代码 #include "windows.h" #include "stdio.h" LPVOID g_pfWriteFile = NULL; CREATE_PROCESS_DEBUG_INFO g_cpdi; BYTE g_chINT3 = 0xCC, g_chOrgByte = 0; BOOL OnCreateProcessDebugEvent(LPDEBUG_EVENT pde) { ...
逆向工程源码.zip
10-07
逆向工程核心原理一书的源代码，有需要的朋友可以下载。
逆向工程核心原理源代码
qq_39249347的博客
08-08 2068
链接：https://pan.baidu.com/s/1qvXbeE9AIZyTpVTKIIyuGA 提取码：zofw
SAPhIRE：简单的API逆向工程助手
02-05
SAP H IRE 小号imple APIřEVERSEËngineeringħelper 基本原理 SAP h IRE是一种工具，可协助对野外常见的任意API流进行逆向工程。 诸如身份验证协议之类的流通常是专有的，未记录的并且填充有缩小的JS，使它们完全被混淆。 它隔离“令牌” 饼干 标头 网址参数 HTML输入标签 请求中的表单字段 响应中的JSON ...并突出显示它们以使基本逻辑显而易见。 屏幕截图 卖点 识别类型时自动对令牌进行解码，以省去繁琐而繁琐的工作，以便在每次出现时手动完成。 智能解码器支持的类型： URL编码（额外：完全支持Unicode ） Base64编码
逆向工程核心原理——消息钩取
weixin_46601374的博客
12-07 4069
钩子（HOOK） 英文Hook一词，翻成中文是“钩子”、“鱼钩”的意思，泛指钓取所需东西而使用的一切工 具。“钩子”这一基本含义延伸发展为“偷看或截取信息时所用的手段或工具”。下面举例向各位 进一步说明“钩子”这一概念。 消息钩取 Windows操作系统向用户提供GUI （Graphic User Interface,图形用户界面），它以事件驱动 （Event Driven）方式工作。在操作系统中借助键盘、鼠标，选择菜单、按钮，以及移动鼠标、改 变窗口大小与位置等都是事件（Event ）o发生这样的事
逆向工程核心原理学习笔记（三）：检索API方法
killcoco的小窝
04-17 611
打开OD，载入程序 鼠标右键，如图。 然后就可以看到程序调用的所有API函数，便于分析。 找到messagebox函数，双击进去，就是函数所在反汇编地址了
《逆向工程核心原理》学习笔记（四）：API钩取
闵行小鱼塘
05-20 2329
继续学习《逆向工程核心原理》，本篇笔记是第四部分：API钩取，主要介绍了调试钩取、DLL注入实现IAT钩取、API代码修改钩取和全局API钩取等内容
2015 逆向工程核心原理 程序源码 资源
06-07
2015 逆向工程核心原理 程序源码 资源
逆向分析核心原理示例和源代码
01-15
逆向工程核心原理的代码和实例，其中都是全面的，是我自己找到的，网上总是有假的所以想让别人可以收到
《逆向工程核心原理》一书中提到的代码以及实验程序
12-14
《逆向工程核心原理》一书中提到的代码以及实验程序，通过该材料 可以更好地去学习及练手，不错过书中的每一个例子，通过动手更好地吸收书中的知识
Hook原理--逆向开发
wei_java144的博客
10-22 1150
fishhook的源码地址为fishhook的主要方法有两个还有一个结构体查看代码结构为，将红色圈起来部分移入到代码中，即可使用fishhook来hook代码。上面讲述了Hook的几种技术方式以及fishhook的原理探究，以及如何让别人的app实现自己的代码。下面我们对此总结一下，写了一个本篇博客的整个过程便于大家整理，希望对大家有所帮助加深理解。
用户层下API的逆向分析及重构
hongduilanjun的博客
03-10 911
Windows所提供给R3环的API，实质就是对操作系统接口的封装，其实现部分都是在R0实现的。很多恶意程序会利用钩子来钩取这些API，从而达到截取内容，修改数据的意图。现在我们使用ollydbg对ReadProcessMemory进行跟踪分析，查看其在R3的实现。 测试 od 我们首先在od里面跟一下在ring3层ReadProcessMemory的调用过程 首先在 exe 中 调用 kernel32.ReadProcessMemory函数，我们可以看到这一部分主要是call dword ptr ds:
《逆向工程核心原理》学习笔记（一）：代码逆向技术基础
闵行小鱼塘
12-12 2951
开始学习逆向，从《逆向工程核心原理》这本经典开始，本篇笔记是第一部分：代码逆向技术基础
逆向工程核心原理——DLL注入——创建远程线程
weixin_46601374的博客
11-16 3356
什么是DLL注入？ dll注入是一种将Windows动态链接库注入到目标进程中的技术，具体的说，就是将dll文件加载到一个进程的虚拟地址空间中。对某个进程进行dll注入，也就意味着dll模块与该进程共用一个进程空间，则这个dll文件就有了操纵这个进程空间的能力，以达到执行dll模块中的代码修改进程数据的能力。dll注入技术在逆向工程，病毒，外挂，调试等技术领域都有广泛的应用，它也是Windows API hook技术的基础。 改善功能与修复Bug改善功能与修复Bug DLL注入技术可用于改善功.
逆向工程的作用有哪些
2201_75362610的博客
04-27 886
1、新零件的设计在工业领域中，有些复杂产品或零件很难用一个确定的设计概念来表达，为获得更优化的设计，设计者常通过创建基于功能和分析需要的一个物理模型，来进行复杂或重要零部件的设计，然后用逆向方法构造出三维模型，在该模型的基础上作进一步的修改，实现产品的改型或仿形设计。2、已有零件的复制在缺乏二维设计图样或者原始设计参数情况下，三维扫描可以将实物零件转化为数字模型，从而通过逆向工程方法对零件进行复制，以再现原产品或零件的设计意图，并可进行产品的再创新设计。3、损坏或磨损零件的还原。
逆向工程核心原理读书笔记-API钩取之隐藏进程(二)
liujiayu2的专栏
06-09 850
上一篇文章我们实现的隐藏进程如果重新打开任务管理器或者被隐藏的进程就没有隐藏的效果了。为了弥补这个问题，我们不仅需要钩取当前运行的所有进程，还要钩取将来运行的所有进程。由于所有的进程都是由父进程使用CreateProcess创建的，所以只要钩取父进程(通常是explorer.exe)的CreateProcess将dll注入所有子进程就可以实现了。要注意下面两个问题。 1.CreateProces
[安全攻防进阶篇] 五.逆向分析之Win32 API获取及加解密目录文件、OllyDbg逆向其原理
杨秀璋的专栏
08-03 8066
这是作者安全攻防进阶篇，希望对您有所帮助。前文作者讲解了条件语句和循环语句源码还原及流程控制逆向方法，这篇文章将分享勒索病毒，通过编写程序实现获取Windows系统目录文件，并对其进行加密和解密的过程；第二部分详细讲解了OllyDbg和在线沙箱的逆向分析过程，第三部分分享恶意软件如何通过宏脚本发送勒索信息或密码至用户邮箱。基础性文章，希望您喜欢~
java新特性（Stream API）
weixin_41670405的博客
05-28 911
Stream API是 Java 8 引入的一个用于对集合数据进行函数式编程操作的强大的库。它允许我们以一种更简洁、易读、高效的方式来处理集合数据，可以极大提高 Java 程序员的生产力，是目前为止对 Java 类库最好的补充。Stream API的核心思想是将数据处理操作以函数式的方式链式连接，以便于执行各种操作，如过滤、映射、排序、归约等，而无需显式编写传统的循环代码。
LeetCode hot100-61-G
最新发布
alike_meng的博客
05-31 190
LeetCode热题100第61题
游戏安全逆向工程师 : fps逆向
01-02
游戏安全逆向工程师是指利用逆向工程技术，对游戏进行分析和破解，以解决游戏安全问题和提升游戏性能的专业人员。FPS逆向指的是对第一人称射击游戏进行逆向工程分析。 FPS游戏是一种以第一人称视角展现游戏场景和操作方式的射击游戏，逆向工程师负责对这类游戏进行深入研究和分析。他们通过分析游戏的代码和数据结构，找出潜在的安全漏洞和游戏内部机制，以便制定相应的安全策略和改善方案。同时，逆向工程师还可以通过优化游戏内存管理和计算资源的分配，提升游戏的运行效率和流畅度，提高玩家的游戏体验。 在逆向工程FPS游戏的过程中，工程师需要具备扎实的计算机编程和网络安全知识，熟悉常见的逆向工程工具和技术，以及对游戏开发和设计原理有深入理解。他们还需要对游戏的各个组成部分进行全面的分析，包括视觉效果、声音设定、操作控制等方面，以确保游戏在被破解的同时不会影响到正常的游戏体验和运营安全。 总之，游戏安全逆向工程师在逆向FPS游戏过程中扮演着重要的角色，他们的工作可以帮助游戏开发者和运营商及时发现和解决安全问题，提升游戏品质和用户体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值