WinXP下监视进程的创建

最新推荐文章于 2021-04-03 17:25:41 发布
最新推荐文章于 2021-04-03 17:25:41 发布
阅读量566 收藏
点赞数
分类专栏： 进程与线程 文章标签： null api attributes access token hook

在winxp下进程的创建无非是使用System,Winexec,ShellExecute,CreateProcess等库函数和系统API.但是为了实现对进程创建的监视,我们一般都是拦截这些api,这样工作量会很大.而实际上这些函数最终都会调用ntdll.dll所导出的ZwCreateProcessEx函数,由他填入服务索引号,并软中断进入内核模式.只要Hook了该函数就能有效地从用户层监视进程的创建.但是有人会说,在2000和Xp下不是有NtCreateProcess和ZwCreateProcess么,实际上今天晚上我自己动手试了下,上述这两者,首先他们是一个函数,其次,在Xp下创建进程的时候,根本不会使用到他们...

 首先看下ZwCreateProcessEx的定义(参考win2k/xp native api refernce):

typedef NTSTATUS (*NTCREATEPROCESSEX)(
   OUT PHANDLE ProcessHandle,
   IN ACCESS_MASK DesiredAccess,
   IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
   IN HANDLE ParentProcess,
   IN BOOLEAN InheritObjectTable,
   IN HANDLE SectionHandle OPTIONAL,
   IN HANDLE DebugPort OPTIONAL,
   IN HANDLE ExceptionPort OPTIONAL,
   IN HANDLE Unknown ); 

我们需要的只是拦截他,目前暂时具体参数的功能就不谈了,具体实现方式就不说了,在前面的<用户层下拦截API的原理与实现>中已经讲得很清楚拉.如果你忘记了,具体见:http://redcoder.blog.sohu.com/2183228.html下面是这次实验的代码,拦截了ZwCreateProcessEx函数:

编译环境:WinXp Sp2 + vc6.0

代码：
--------------------------------------------------------------------------------

#include <stdio.h>
#include <windows.h>

#define STATUS_SUCCESS  0
#define HOOKFUCTIONSIZE 10240      //定义拦截函数体的大小，以字节为单位，且以4kb为基本单位
#define HOOKEDAPIPARAMNUMINBYTE 36 //定义被拦截的api的函数的参数的大小，以字节为单位

typedef unsigned long NTSTATUS;
typedef unsigned long SYSTEM_INformATION_CLASS;

typedef struct _RemoteParam{
LPVOID          lpFunAddr;
LPVOID          lpWriteProcessMemory;
unsigned char   szOldCode[12];
unsigned char   szNewCode[12];
LPVOID          lpMessageBox;
}RemoteParam, * PRemoteParam;

typedef BOOL (__stdcall * PFN_WRITEPROCESSMEMORY)(HANDLE, LPVOID, LPCVOID, SIZE_T, SIZE_T*);
typedef int  (__stdcall * PFN_MESSAGEBOX)(HWND, LPCTSTR, LPCTSTR, DWORD);

typedef
NTSTATUS
(__stdcall * PFN_ZWCREATEPROCESSEX)(
PHANDLE,
ACCESS_MASK,
LPVOID,
HANDLE,
BOOLEAN,
HANDLE,
HANDLE,
HANDLE,
HANDLE
);

VOID HookApi(LPVOID lParam)
{
RemoteParam* Rpm = (RemoteParam*)lParam;
PFN_ZWCREATEPROCESSEX pfnZwCreateprocessEx = (PFN_ZWCREATEPROCESSEX)Rpm->lpFunAddr;
PFN_WRITEPROCESSMEMORY pfnWriteProcessMemory = (PFN_WRITEPROCESSMEMORY)Rpm->lpWriteProcessMemory;
PFN_MESSAGEBOX pfnMessageBox = (PFN_MESSAGEBOX)Rpm->lpMessageBox;

char sztest[8] = {'h', 'e', 'l', 'l', 'o', '.', '.', '/0'};
  


PHANDLE ProcessHandle = NULL;
ACCESS_MASK DesiredAccess = 0;
LPVOID ObjectAttributes = NULL;
HANDLE InheritFromProcessHandle = NULL;
BOOLEAN InheritHandles = TRUE;
HANDLE SectionHandle = NULL;
HANDLE DebugPort = NULL;
HANDLE ExceptionPort = NULL;
HANDLE reserv = NULL;


NTSTATUS Retvalue = STATUS_SUCCESS; //定义要拦截的api的默认返回植
DWORD NextIpAddr = 0;
DWORD dwParamaAddr = 0;

DWORD temp1 = 0;

__asm
{
 MOV EAX, [EBP + 12]
 MOV [NextIpAddr], EAX
 MOV EAX, [EBP + 16]
 MOV [ProcessHandle], EAX
 MOV EAX, [EBP + 20]
 MOV [DesiredAccess], EAX
 MOV EAX, [EBP + 24]
 MOV [ObjectAttributes], EAX
 MOV EAX, [EBP + 28]
 MOV [InheritFromProcessHandle], EAX
 MOV EAX, [EBP + 32]
 MOV [temp1], EAX
 MOV EAX, [EBP + 36]
 MOV [SectionHandle], EAX 
 MOV EAX, [EBP + 40]
 MOV [DebugPort], EAX
 MOV EAX, [EBP + 44]
 MOV [ExceptionPort], EAX
 MOV EAX, [EBP + 48]
 MOV [reserv], EAX 
}

InheritHandles = (BOOLEAN)temp1;


//这里可以做你的事情了，比如我只想弹出一个对话框,其实也可以在让api完成之后再做些东西
   pfnMessageBox(NULL, sztest, sztest, 0);  

pfnWriteProcessMemory((HANDLE)0XFFFFFFFF, Rpm->lpFunAddr, (LPCVOID)Rpm->szOldCode, 12, NULL);
//让api真正执行,这里换成你要拦截的api
Retvalue = pfnZwCreateprocessEx(ProcessHandle,
                             DesiredAccess,
           ObjectAttributes,
           InheritFromProcessHandle,
           InheritHandles,
           SectionHandle,
           DebugPort,
           ExceptionPort,
           reserv);

//再次恢复对他的拦截
pfnWriteProcessMemory((HANDLE)0XFFFFFFFF, Rpm->lpFunAddr, (LPCVOID)Rpm->szNewCode, 12, NULL);

 
  DWORD dwStackSize = 12 + HOOKEDAPIPARAMNUMINBYTE;
 
  //这里对拦截函数堆栈的恢复，必须放在最后
  __asm
  {
   POP EDI     //注意如果你编译生成的debug版本的程序则需要把这
   POP ESI     //三个注释去掉
   POP EBX
   MOV ECX, [dwStackSize]
   MOV EDX, [NextIpAddr]
   MOV EAX, [Retvalue]
   MOV ESP, EBP
   POP EBP
   ADD ESP, ECX //12 + HOOKEDAPIPARAMNUMINBYTE  //恢复堆栈
   PUSH EDX
   RET
  }
}


//
//************************************************************************
//模块名字：AdjustProcessPrivileges(LPCSTR)
//模块功能：修改调用进程的权限
//返回数值：成功返回TRUE，失败返回FALSE
//参数可以为下列值：
// #define SE_BACKUP_NAME        TEXT("SeBackupPrivilege")
// #define SE_RESTORE_NAME       TEXT("SeRestorePrivilege")
// #define SE_SHUTDOWN_NAME      TEXT("SeShutdownPrivilege")
// #define SE_DEBUG_NAME         TEXT("SeDebugPrivilege")
//

BOOL AdjustProcessPrivileges(LPCSTR lpPrivilegesName)
{
HANDLE hToken;
TOKEN_PRIVILEGES tkp;
if(!OpenProcessToken((HANDLE)0XFFFFFFFF,
 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
 return FALSE;
}

if(!LookupPrivilegeValue(NULL, lpPrivilegesName, &tkp.Privileges[0].Luid))
{
 CloseHandle(hToken);
 return FALSE;
}

tkp.PrivilegeCount = 1;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

if(!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL))
{
 CloseHandle(hToken);
 return FALSE;
}

CloseHandle(hToken);
return TRUE;
}


int SetHook(DWORD dwPid, LPCTSTR lpApiName, LPCTSTR lpExportDllName, LPVOID lpHookFunAddr)
{
if(!AdjustProcessPrivileges(SE_DEBUG_NAME))
{
 printf("-----AdjustProcessPrivileges error../n");
 return -1;
}
printf("1:AdjustProcessPrivileges ok/n");

//获取要拦截的api的地址
HMODULE hExportDll = LoadLibrary(lpExportDllName);
if(hExportDll == NULL)
{
 printf("-----LoadLibrary error../n");
 return -1;
}


LPVOID lpApiAddr = GetProcAddress(hExportDll, lpApiName);
if(lpApiAddr == NULL)
{
 printf("-----GetProcAddress %s error../n", lpApiName);
 FreeLibrary(hExportDll);
 return -1;
}

//打开进程句柄
HANDLE hTargetProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ,
                                       FALSE, dwPid);
if(hTargetProcess == NULL)
{
 printf("-----OpenProcess %d error../n", dwPid);
 FreeLibrary(hExportDll);
 return -1;
}

//申请拦截函数内存空间
LPVOID lpFunAddr = VirtualAllocEx(hTargetProcess, NULL, HOOKFUCTIONSIZE,
                                     MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(lpFunAddr == NULL)
{
 printf("-----VirtualAllocEx for remotefuction error../n");
 FreeLibrary(hExportDll);
 CloseHandle(hTargetProcess);
 return -1;
}

//申请远程参数空间
LPVOID lpParamaAddr = VirtualAllocEx(hTargetProcess, NULL, sizeof(RemoteParam),
                                        MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(lpParamaAddr == NULL)
{
 printf("-----VirtualAllocEx for remoteparam error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 return -1;
}

printf("2:Alloc remote memory for the hook fuction and param ok/n");


//设置远程参数，下一步要把参数写入要拦截的远程进程地址空间
RemoteParam RParam;
ZeroMemory(&RParam, sizeof(RParam));

unsigned char oldcode[12];
unsigned char newcode[12];
DWORD dwError = 0;
if(!ReadProcessMemory((HANDLE)0XFFFFFFFF,
 lpApiAddr,
 oldcode,
 12,
 &dwError))
{
 printf("-----ReadProcessMemory from lpApiName error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 return -1;
}
//生成跳转指令，这将覆盖要拦截的api的前十个字节
int praadd = (int)lpParamaAddr;
int threadadd = (int)lpFunAddr;
newcode[4] = praadd>>24;
newcode[3] = (praadd<<8)>>24;
newcode[2] = (praadd<<16)>>24;
newcode[1] = (praadd<<24)>>24;
newcode[0] = 0x68;  //PUSH lpParamaAddr

int offsetaddr = threadadd - (int)lpApiAddr - 10 ;
newcode[9] = offsetaddr>>24;
newcode[8] = (offsetaddr<<8)>>24;
newcode[7] = (offsetaddr<<16)>>24;
newcode[6] = (offsetaddr<<24)>>24;
newcode[5] = 0xE8;  //CALL lpFunAddr

newcode[10] = 0x90;
newcode[11] = 0x90;

for(int j = 0; j < 12; j++)
{
 RParam.szOldCode[j] = oldcode[j];
 RParam.szNewCode[j] = newcode[j];
}
RParam.lpFunAddr = lpApiAddr;

HMODULE hKernel32 = LoadLibrary("Kernel32.dll");
if(hKernel32 == NULL)
{
 printf("-----LoadLibrary Kernel32.dll error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 return -1;
}

RParam.lpWriteProcessMemory = GetProcAddress(hKernel32, "WriteProcessMemory");
if(RParam.lpWriteProcessMemory == NULL)
{
 printf("-----GetProcAddress WriteProcessMemory from Kernel32.dll error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 return -1;
}

//以上皆为必须，下面可以为自己的拦截函数中所需要用的一些变量以及系统api放到参数中去
HMODULE hUser32 = LoadLibrary("User32.dll");
if(hUser32 == NULL)
{
 printf("-----LoadLibrary User32.dll error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 return -1;
}

RParam.lpMessageBox = GetProcAddress(hUser32, "MessageBoxA");
if(RParam.lpMessageBox == NULL)
{
 printf("-----GetProcAddress MessageBoxA from User32.dll error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 FreeLibrary(hUser32);
 return -1;
}

FreeLibrary(hUser32);
printf("3:Generate remoteparam ok/n");

//下面为必须部分
//把参数写入要拦截的远程进程地址空间
if(!WriteProcessMemory(hTargetProcess, lpParamaAddr, (LPVOID)&RParam, sizeof(RParam), &dwError))
{
 printf("-----WriteProcessMemory for remoteparam error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 return -1;
}
printf("4:WriteProcessMemory for remoteparam ok/n");
//把拦截函数体写入目标进程地址空间
if(!WriteProcessMemory(hTargetProcess, lpFunAddr, lpHookFunAddr, HOOKFUCTIONSIZE, &dwError))
{
 printf("-----WriteProcessMemory for remotefuction error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 return -1;
}
printf("5:WriteProcessMemory for remotefuction ok/n");
//把新的跳转指令写入要拦截的目标进程的要拦截的api的函数的前十字节
if(!WriteProcessMemory(hTargetProcess, lpApiAddr , (LPVOID)newcode, 12, &dwError))
{
 printf("-----Modify remote api error../n");
 FreeLibrary(hExportDll);
 VirtualFreeEx(hTargetProcess, lpFunAddr, 0, MEM_RELEASE);
 VirtualFreeEx(hTargetProcess, lpParamaAddr, 0, MEM_RELEASE);
 CloseHandle(hTargetProcess);
 FreeLibrary(hKernel32);
 return -1;
}
   printf("6:Modify remote api %s ok/n", lpApiName);

//show..
printf("---------------------------------------------------------------------------/n"
    "You hava hooked pid: %d ,and the infomation of this hooking are as follows:/n"
    "API name: %s/n"
    "API addr: 0x%.8x/n"
    "Module name: %s/n"
    "Module addr: 0x%.8x/n"
    "Remote parama addr: 0x%.8x/n"
    "Remote thread addr: 0x%.8x/n"
    "RemoteParam.lpFunAddr: 0x%.8x/n"
    "RemoteParam.lpWriteProcessMemory: 0x%.8x/n"
    "RemoteParam.lpMessageBox: 0x%.8x/n",
    dwPid,
    lpApiName,
          lpApiAddr,
    lpExportDllName,
    hExportDll,
    lpParamaAddr,
    lpFunAddr,
    RParam.lpFunAddr,
    RParam.lpWriteProcessMemory,
    RParam.lpMessageBox);

printf("RemoteParam.szOldCode: ");
for(int i = 0; i < 12; i++)
{
 printf("0x%x ", RParam.szOldCode[i]);
}

printf("/nRemoteParam.szNewCode: ");
for(i = 0; i < 12; i++)
{
 printf("0x%x ", RParam.szNewCode[i]);
}

printf("/nThat's all, good luck ^_^/n");
Sleep(10000);


//收工，清理资源
FreeLibrary(hExportDll);
CloseHandle(hTargetProcess);
FreeLibrary(hKernel32);
return 0;
}


int main(void)
{//注意这里第一个参数是你要选择监视的进程的ID,我这里是选的我的explorer.exe
SetHook(1564, "NtCreateProcessEx", "ntdll.dll", &HookApi);
 

 

引自： http://www.hacker.cn/Get/xtaq/0691410230498975.shtml
 

syf442
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
文件操作监视工具（XP）
09-15
Windows XP系统中的文件操作监视工具，如Filemon.exe，就是这样一个实用的辅助软件，它能够实时监控并记录系统对文件和文件夹的所有访问、读取、写入、创建和删除等操作，为用户提供了宝贵的洞察力。 Filemon.exe，...
利用IShellExecuteHook接口对程序监控
JonnyLai
07-22 5058
利用IShellExecuteHook接口对程序监控
易语言api hook ShellExecuteA 执行程序
511遇见
05-25 3536
ShellExecute的功能是运行一个外部程序(或者是打开一个已注册的文件、打开一个目录、打印一个文件等等)，并对外部程序有一定的控制,和CreateProcessA比起来没有太复杂，可以简单理解为易语言里的执行。 ShellExecuteA .版本 2 .DLL命令 ShellExecuteA, 整数型, "shell32.dll", "ShellExecuteA", , 查找与指定文件关联在一起的程序的文件名,并执行相关操作，成功则返一个大于31的值。 .参数 hwnd, 整数型, , 用来指
关于进程劫持注入的一点分析与思考
輚至消亡
04-03 2475
1. 劫持进程实现注入 今天我尝试对win10 x64上的计算器进程进行进程劫持注入。 劫持进程实现注入要执行如下步骤: 以挂起方式启动目标进程 采用其他注入方式将DLL注入目标进程 继续目标进程的主线程使目标进程继续运行 这种注入方式的优点: 被注入的进程来不及做任何防御就会被注入。 因为以挂起方式启动进程，该进程的地址空间内除了目标进程的exe模块和ntdll.dll模块外 还来不及解析导入表将所需dll全部导入，也就是说作为防护的dll模块或者线程可能也来不及导入和执行，这大大提高了注入
用户层下拦截系统api的原理与实现
默数悲伤
04-15 2083
　　写这篇文章是为了复习一些知识，最近在做毕业设计，之中大量地使用了这种技术，主要是用在拦截winsock函数，对于其他系统api，其效果也是一样的．　　拦截api的技术有很多种，大体分为用户层和内核层的拦截．这里只说说用户层的拦截．而用户层也分为许多种：修改PE文件导入表，直接修改要拦截的api的内存（从开始到最后，使程序跳转到指定的地址执行）．不过大部分原理都是修改程序流程，使之跳转到你要
基于C++的Hook 暴力实现！拦截系统api，绝对给100分！
04-28 5867
1、HOOK介绍（钩子，挂钩） 是一种实现Windows平台下类似于中断的机制。HOOK机制允许应用程序拦截并处理Windows消息或指定事件，当指定的消息发出后，HOOK程序就可以在消息到达目标窗口之前将其捕获，从而得到对消息的控制权，进而可以对该消息进行处理或修改，加入我们所需的功能。如果你正在学习C/C++，加群：825414254获取资料与听课权限 ...
另一个线程监视器
04-11
线程是操作系统中并行执行的最小单元，它允许程序在单个进程中同时进行多个任务。线程监视器能够帮助开发者理解和调试多线程应用程序中的问题，例如死锁、资源竞争和性能瓶颈。 描述中提到的“将异步过程调用用于...
iis6.0 for winxp
09-11
1. **网站创建**：在IIS管理器中，右键点击“默认网站”选择“新建”->“网站”，设置网站的标识（如IP地址、端口号）、主目录路径和访问权限。 2. **应用程序池**：管理应用程序的运行环境，可以为不同网站或应用...
WinXP_SP3_IIS
10-18
4. **服务管理**：安装完成后，可以在“服务”管理工具中查看和管理IIS运行的进程，如World Wide Web Publishing Service和Internet Information Services (IIS) Admin Service。 5. **配置文件**：IIS的配置文件...
winxp常用命令集
12-14
`taskmgr`命令启动任务管理器，用于查看和管理正在运行的进程、应用程序和服务，以及监控系统资源使用情况，如CPU、内存和磁盘活动。 #### perfmon.msc —— 性能监视器 `perfmon.msc`命令启动性能监视器，用于...
APIHook ShellExecute你双击快捷方式,我就能记录下来.你双击的任何快捷方式我都知道.zip
04-04
记录双击过的快捷方式 你双击快捷方式,我就能记录下来.你双击的任何快捷方式我都知道
ShellExecuteHook 示例
05-16
利用 ShellExecuteHook 以无进程方式自动运行； 利用 ShellExecuteHook 以无进程方式自动运行
ShellExecuteHooks
07-03
利用Com技术实现的对ShellExecute和ShellExecuteEx的Hook.
系统监视器，可以实时监视正在运行的程序，并关闭他(29KB)...
10-07
系统监视器，可以实时监视正在运行的程序，并关闭他(29KB)
windows进程监控
01-10
对业务运行的指定进程进行监控，也可以对某些进程（弹出无响应窗口，假死、死机）进行监控，定期检查，并关闭指定的任务，也可定时启动某些进程（代码稍微修改即可），运行后最小化推盘位置。
Hook技术之API拦截(API Hook)
热门推荐
bobopeng
06-02 3万+
Inline Hook就是修改
ShellExecuteHook
云里雾里的专栏
02-05 2974
　【转：laiwuyingas 木马技术发展趋势回顾】 经常关注安全的用户或许会见到过"ShellExecuteHook"，如今许多木马和恶意程序都在用户层使用它作为启动方式了，但这是一种什么技术，大家可能又会迷惑不解了，究竟这个技术和木马有什么联系?其实这是一种正常的系统功能，名为"执行挂钩"，操作系统厂商开发它的初衷十分简单：为程序提供一个额外的通知功能，以实现系统中任何程序启动时都提前让使用了"执行挂钩"的程序收到新程序的启动通知，简单的说，这是操作系统在出于某种程序交互需求的考虑
WinXP下PHP环境配置指南
"该文档详细介绍了在Windows XP操作系统下如何搭建PHP开发环境，主要涉及Apache服务器、MySQL数据库和PHP的安装与配置。" 在Windows XP环境下设置PHP开发环境是一项基础任务，通常涉及到以下几个关键步骤和知识点：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值