过GPK驱动

最新推荐文章于 2022-10-27 22:01:07 发布
最新推荐文章于 2022-10-27 22:01:07 发布
阅读量2k 收藏 2
点赞数 1
分类专栏： 驱动 文章标签： byte string hook service struct table
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoyi987/article/details/7292598
版权
本文介绍了一种驱动级代码注入技术，通过修改内核服务描述符表(SSDT)中的函数指针，实现对NT开头的内核函数进行绕过和钩子操作。包括NtCreateThread、NtProtectVirtualMemory等关键函数的处理方法。
摘要由CSDN通过智能技术生成
  

NtCreateThread
NtProtectVirtualMemory
NtQueueApcThread
NtTerminateProcess
NtWriteVitualMemory


Ke386IoSetAccessProcess
KeAttachProcess
KeInitalizeApc
KeStackAttachProcess
ObCheckObjectAccess
ZwOpenSection

 

 

这些函数被挂钩，全部都是头部push   retn的形式挂钩

SSDT HOOk可以绕过上面Nt开头的函数。

下面的函数没法绕，已经挂了头部了，貌似改任何字节都给检测出来。估计得挂G。P_K驱动的函数才行

随便写个驱动，能分析10分钟左右，够用了。(其实就跟XT直接恢复的效果一样，自己动手写下也是种收获吧)

 

上代码：

 

#include <windef.h>
#include <stdio.h>
#include <string.h>




typedef struct _ServiceDescriptorTable {
	PVOID ServiceTableBase; //System Service Dispatch Table 的基地址  
	PVOID ServiceCounterTable;//包含着 SSDT 中每个服务被调用次数的计数器。这个计数器一般由sysenter 更新。 
	unsigned int NumberOfServices;//由 ServiceTableBase 描述的服务的数目。  
	PVOID ParamTableBase; //包含每个系统服务参数字节数表的基地址-系统服务参数表 
}*PServiceDescriptorTable;  

extern "C" extern PServiceDescriptorTable KeServiceDescriptorTable;
extern "C" __declspec(dllimport) _stdcall KeAddSystemServiceTable(PVOID, PVOID, PVOID, PVOID, PVOID);

BOOL MyHook_flag=FALSE;


LONG ssdt_start; 
LONG ssdt_No_53;
LONG ssdt_No_137;
LONG ssdt_No_180;
LONG ssdt_No_257;
LONG ssdt_No_277;

LONG NtCreateThreadAddr;
LONG ntCreateThreadPush1;
LONG ntCreateThreadPush2;
LONG ntCreateThread_7;

LONG NtProtectVirtualMemoryAddr;
LONG ntProtectVirtualMemoryParam1;
LONG ntProtectVirtualMemoayParam2;
LONG ntProtectVirtualMemory_7;

LONG NtQueueAqcThreadAddr;
LONG ntQueueAqcThread_6;

LONG NtTerminateProcessAddr;
LONG ntTerminateProcess_8;

LONG NtWriteVirtualMemoryAddr;
LONG ntWriteVirtualMemoryParam1;
LONG ntWriteVirtualMemoryParam2;
LONG ntWriteVirtualMemory_7;

LONG Ke386IoSetAccessProcessAddr;
LONG ke386IoSetAccessProcess_7;

LONG KeAttachProcessAddr;
LONG keAttachProcess_6;

LONG KeInitializeApcAddr;
LONG keInitializeApc_8;

LONG KeStackAttachProcessAddr;
LONG keStackAttachProcess_6;

LONG ObCheckObjectAccessAddr;
LONG obCheckObjectAccess_8;

LONG ZwOpenSectionAddr;
LONG zwOpenSection_9;

VOID getKernelFunctionAddr();
VOID MyHook();
VOID unpass();


__declspec(naked) VOID MyNtCreateThread(){

	__asm{
		push ntCreateThreadPush1
		push ntCreateThreadPush2
		jmp ntCreateThread_7
	}

}

__declspec(naked) VOID MyNtVirtualProtectMemory(){

	__asm{
		push ntProtectVirtualMemoryParam1
		push ntProtectVirtualMemoayParam2
		jmp ntProtectVirtualMemory_7
	}

}


__declspec(naked) VOID MyNtQueueAqcThread(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		push ecx
		jmp ntQueueAqcThread_6
	}

}

__declspec(naked) VOID MyNtTerminateProcess(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		sub esp,0x10
		jmp ntTerminateProcess_8
	}

}

__declspec(naked) VOID MyNtWriteVirtualMemory(){

	__asm{
		push ntWriteVirtualMemoryParam1
		push ntWriteVirtualMemoryParam2
		jmp ntWriteVirtualMemory_7
	}

}

__declspec(naked) VOID MyKe386IoSetAccessProcess(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		xor ecx,ecx
		jmp ke386IoSetAccessProcess_7
	}

}

__declspec(naked) VOID MyKeAttachProcess(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		push esi
		jmp keAttachProcess_6
	}

}

__declspec(naked) VOID MyKeInitialzeApc(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		mov eax,dword ptr[ebp+8]
		jmp keInitializeApc_8
	}

}

__declspec(naked) VOID MyStackAttachProcess(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		push esi
		jmp keStackAttachProcess_6
	}

}

__declspec(naked) VOID MyObCheckObjectAccess(){

	__asm{
		mov edi,edi
		push ebp
		mov ebp,esp
		sub esp,0x10
		jmp obCheckObjectAccess_8
	}

}


__declspec(naked) VOID MyZwOpenSection(){

	__asm{
		mov eax,0x7d
		lea edx,dword ptr[esp+4]
		jmp zwOpenSection_9
	}

}

VOID pass(){
	

	if ( TRUE == MyHook_flag )
	{
		KdPrint(("Hook Already\n"));
		return;
	}

	MyHook_flag = TRUE;

	getKernelFunctionAddr();
	MyHook();

}


VOID MyHook(){
	

	__asm //去掉页面保护
	{
		cli
		mov eax,cr0
		and eax,not 10000h //and eax,0FFFEFFFFh
		mov cr0,eax

		mov eax,ssdt_No_53
		mov ebx,MyNtCreateThread
		mov dword ptr [eax], ebx

		mov eax,ssdt_No_137
		mov ebx,MyNtVirtualProtectMemory
		mov dword ptr [eax],ebx

		mov eax,ssdt_No_180
		mov ebx,MyNtQueueAqcThread
		mov dword ptr[eax],ebx

		mov eax,ssdt_No_257
		mov ebx,MyNtTerminateProcess
		mov dword ptr[eax],ebx
	
		mov eax,ssdt_No_277
		mov ebx,MyNtWriteVirtualMemory
		mov dword ptr[eax],ebx

		mov eax,Ke386IoSetAccessProcessAddr
		mov byte ptr[eax],0x68
		mov ebx,MyKe386IoSetAccessProcess
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3

		mov eax,KeAttachProcessAddr
		mov byte ptr[eax],0x68
		mov ebx,MyKeAttachProcess
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3
		
		mov eax,KeInitializeApcAddr
		mov byte ptr[eax],0x68
		mov ebx,MyKeInitialzeApc
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3

		mov eax,KeStackAttachProcessAddr
		mov byte ptr[eax],0x68
		mov ebx,MyStackAttachProcess
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3

	
		mov eax,ObCheckObjectAccessAddr
		mov byte ptr[eax],0x68
		mov ebx,MyObCheckObjectAccess
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3


		mov eax,ZwOpenSectionAddr
		mov byte ptr[eax],0x68
		mov ebx,MyZwOpenSection
// 		sub ebx,eax
// 		sub ebx,5
		mov dword ptr[eax+1],ebx
		mov byte ptr[eax+5],0xc3

		mov  eax,cr0 
		or eax,10000h 
		mov cr0,eax 
		sti 
	}   
}

VOID unpass(){

	if ( FALSE == MyHook_flag )
	{
		KdPrint(("Not Hook Yet\n"));
		return;
	}

	KdPrint(("Unhook Ok\n"));
	MyHook_flag = FALSE;


	__asm //去掉页面保护
	{
		cli
		mov eax,cr0
		and eax,not 10000h //and eax,0FFFEFFFFh
		mov cr0,eax

		mov ebx,ssdt_No_53//ntCreateThread
		mov eax,NtCreateThreadAddr
		mov [ebx],eax

		mov ebx,ssdt_No_137//ntProtectVirtualMemory
		mov eax,NtProtectVirtualMemoryAddr
		mov [ebx],eax

		mov ebx,ssdt_No_180//ntNtQueueAqcThread
		mov eax,NtQueueAqcThreadAddr
		mov [ebx],eax

		mov ebx,ssdt_No_257//ntTerminalProcess
		mov eax,NtTerminateProcessAddr
		mov [ebx],eax

		mov ebx,ssdt_No_277
		mov eax,NtWriteVirtualMemoryAddr
		mov [ebx],eax

		mov ebx,Ke386IoSetAccessProcessAddr
		mov dword ptr[ebx],0x8b55ff8b
		mov dword ptr[ebx+4],0x57c933ec

		mov ebx,KeAttachProcessAddr
		mov dword ptr[ebx],0x8b55ff8b
		mov word ptr[ebx+4],0x56ec

		mov ebx,KeInitializeApcAddr//mov edi,edi;push ebp;mov ebp,esp;mov eax,[ebp+8]
		mov dword ptr[ebx],0x8b55ff8b
		mov dword ptr[ebx+4],0x08458bec

		mov ebx,KeStackAttachProcessAddr
		mov dword ptr[ebx],0x8b55ff8b
		mov word ptr[ebx+4],0x56ec

		mov ebx,ObCheckObjectAccessAddr
		mov dword ptr[ebx],0x8b55ff8b
		mov dword ptr[ebx+4],0x10ec83ec


		mov ebx,ObCheckObjectAccessAddr
		mov dword ptr[ebx],0x8b55ff8b
		mov dword ptr[ebx+4],0x10ec83ec
        mov dword ptr[ebx+8],0x5608458b

		mov ebx,ZwOpenSectionAddr
		mov dword ptr[ebx],0x7db8
		mov dword ptr[ebx+4],0x24548d00
		mov byte ptr[ebx+8],0x04

		mov  eax,cr0 
		or eax,10000h 
		mov cr0,eax 
		sti 
	} 
}

VOID getKernelFunctionAddr(){
	UNICODE_STRING Ke386IoSetAccessProcessStr;
	UNICODE_STRING KeAttachProcessStr;
	UNICODE_STRING KeInitializeApcStr;
	UNICODE_STRING KeStackAttachProcessStr;
	UNICODE_STRING ObCheckObjectAccessStr;
	UNICODE_STRING ZwOpenSectionStr;

	RtlInitUnicodeString(&Ke386IoSetAccessProcessStr,L"Ke386IoSetAccessProcess");
	RtlInitUnicodeString(&KeAttachProcessStr,L"KeAttachProcess");
	RtlInitUnicodeString(&KeInitializeApcStr,L"KeInitializeApc");
	RtlInitUnicodeString(&KeStackAttachProcessStr,L"KeStackAttachProcess");
	RtlInitUnicodeString(&ObCheckObjectAccessStr,L"ObCheckObjectAccess");
	RtlInitUnicodeString(&ZwOpenSectionStr,L"ZwOpenSection");

	Ke386IoSetAccessProcessAddr = (LONG)MmGetSystemRoutineAddress(&Ke386IoSetAccessProcessStr);
 	KeAttachProcessAddr         = (LONG)MmGetSystemRoutineAddress(&KeAttachProcessStr);
 	KeInitializeApcAddr         = (LONG)MmGetSystemRoutineAddress(&KeInitializeApcStr);
 	KeStackAttachProcessAddr    = (LONG)MmGetSystemRoutineAddress(&KeStackAttachProcessStr);
 	ObCheckObjectAccessAddr     = (LONG)MmGetSystemRoutineAddress(&ObCheckObjectAccessStr);
 	ZwOpenSectionAddr           = (LONG)MmGetSystemRoutineAddress(&ZwOpenSectionStr);

	ke386IoSetAccessProcess_7 = Ke386IoSetAccessProcessAddr + 7;
	keAttachProcess_6         = KeAttachProcessAddr + 6;
	keInitializeApc_8         = KeInitializeApcAddr + 8;
	keStackAttachProcess_6    = KeStackAttachProcessAddr + 6;
	obCheckObjectAccess_8     = ObCheckObjectAccessAddr + 8;
	zwOpenSection_9           = ZwOpenSectionAddr + 9;


	KdPrint(("Ke386IoSetAccessProcess=%X\n",Ke386IoSetAccessProcessAddr));
	KdPrint(("KeAttachProcess=%X\n",KeAttachProcessAddr));
	KdPrint(("KeInitializeApc=%X\n",KeInitializeApcAddr));
	KdPrint(("KeStackAttachProcess=%X\n",KeStackAttachProcessAddr));
	KdPrint(("ObCheckObjectAccess=%X\n",ObCheckObjectAccessAddr));
	KdPrint(("ZwOpenSection=%X\n",ZwOpenSectionAddr));


	ssdt_start = (LONG)KeServiceDescriptorTable->ServiceTableBase;
	ssdt_No_53  = ssdt_start + 53*4;
	ssdt_No_137 = ssdt_start + 137*4;
	ssdt_No_180 = ssdt_start + 180*4;
	ssdt_No_257 = ssdt_start + 257*4;
	ssdt_No_277 = ssdt_start + 277*4;


	NtCreateThreadAddr   = *(LONG*)ssdt_No_53;
	ntCreateThreadPush1 = *(BYTE*)(*(LONG*)ssdt_No_53+1);
	ntCreateThreadPush2 = *(LONG*)(*(LONG*)ssdt_No_53+3);
	ntCreateThread_7     = NtCreateThreadAddr+7;

	NtProtectVirtualMemoryAddr   = *(LONG*)ssdt_No_137;
	ntProtectVirtualMemoryParam1 = *(BYTE*)(*(LONG*)ssdt_No_137+1);
	ntProtectVirtualMemoayParam2 = *(LONG*)(*(LONG*)ssdt_No_137+3);
	ntProtectVirtualMemory_7     = NtProtectVirtualMemoryAddr+7;
	
	NtQueueAqcThreadAddr=*(LONG*)ssdt_No_180;
	ntQueueAqcThread_6=NtQueueAqcThreadAddr+6;

	NtTerminateProcessAddr=*(LONG*)ssdt_No_257;
	ntTerminateProcess_8=NtTerminateProcessAddr+8;
	
	NtWriteVirtualMemoryAddr   = *(LONG*)ssdt_No_277;
	ntWriteVirtualMemoryParam1 = *(BYTE*)(*(LONG*)ssdt_No_277+1);
	ntWriteVirtualMemoryParam2 = *(LONG*)(*(LONG*)ssdt_No_277+3);
	ntWriteVirtualMemory_7     = NtWriteVirtualMemoryAddr+7;



}


 

nu2987
关注
专栏目录
阻止反外挂GPK/sys加载思路
暗组-萬歲
07-20 4852
思路建议： sys 驱动加载之前，要 CreateService ，试试拦截这个api？或者更底层？ 不重启的话，Hook ZwLoadDriver,ZwSetSysteminformation基本就差不多了createservice,zwloaddriver,zwsetsyst
彩虹岛虚拟机多开 登陆游戏不了，初始化gpk异常
m0_74236454的博客
10-19 3634
在安装虚拟机之前我需要提醒你们，检查一下你的电脑是否支持虚拟化VT-X，是否开启虚拟化，虚拟机是需要电脑开启虚拟化的。如果没开，就到百度找下开启动的方法，因为开启动了，它支持虚拟机有更高的性能，在虚拟机中玩游戏才会更加流畅。登陆游戏的时候先是说初始化gpk异常，然后能进登陆界面，但是就一直在连接中然后连接服务器失败，可以确定网络没有问题，换了好几个网络，关杀毒关防火墙重启重新下载甚至重装系统都试过了。4.虚拟机中玩游戏 必不可少的，过检测。如果不过游戏检测，很多游戏基本上是无法在虚拟机使用的，请知晓。
最新CE过GPK图文教程
01-22
所需工具： 1. CheatEngine （建议用群共享里我传上去的5.6.1版本的） 2. InstDrv （群共享里叫“驱动安装”） 3. GPK (盛大27号之前的) 4. 全职业代码 （群共享里有）
游戏保护大放送之GPK
weixin_34072637的博客
01-08 335
GPK也没有啥特别。龙之谷多开检测和别的不一样。 #include "struct.h" #include "FGPK.h" ////////////////////////////////////////////////////////////////////////// char g_pFindOrigCode[8]; ULONG KiSystemService_hack...
【梅哥的Ring0湿润插入教程】【番外篇四】抓取盛大GPK驱动保护文件及简略逆向...
aejtu5698的博客
06-04 4823
【梅哥的Ring0湿润插入教程】Email:mlkui@163.com 转载请注明出处，谢绝喷子记者等，如引起各类不适请自觉滚J8蛋！番外篇四：抓取盛大GPK驱动保护文件及简略逆向【湿润前言】 随着驱动保护技术的逐步成熟，诸如网络游戏公司等越来越多的商业软件公司开始使用Ring0级保护技术保护自己的产品，以起到反用户级调试、反RootKit、反各类钩子、反各类远程注入等作用。...
过驱动保护工具（过游戏驱动保护工具）
01-11
过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）
Win10运行冒险岛提示初始化GPK失败
Dehchannel的博客
10-27 8219
左下角开始菜单→设置→更新与安全→Windows安全中心→设备安全性→内核隔离详细信息→内存完整性→关闭。
过游戏驱动保护
02-25
本文将详细讲解如何理解和绕过游戏驱动保护。 首先，驱动程序是操作系统与硬件之间的桥梁，它们在系统内核模式下运行，具有极高的权限。游戏驱动保护通常涉及到驱动层的hook技术，即在关键函数执行前后插入自定义...
易语言-易语言驱动 过保护 内核重载 钩子扫描 DPC
06-25
TP GPK HS NP等保护的处理 TP IO通信算法的逆向 各种Image Create回调的枚举和删除 等等... 还有好多 自己发现吧 其中用到了一个LIB(MyDriverLib) 因为易语言异常处理太扯蛋 所以C++的封装而已 你不懂 我也没办法了
php 绕过gpc,TinyShop SQL注入（开启GPC，绕过过滤）
weixin_42104778的博客
03-24 1165
### 简要描述：之前的都是找程序员的疏忽，这个位置是绕过程序的防注入。### 详细说明：环境：GPC = On```public static function sql($str) //过滤函数{if (!get_magic_quotes_gpc()){ //gpc off 就转义，把之前那个奇葩的漏洞补了//不使用主要是因为，先有mysql的连接//$str = mysql_real_es...
windows内核开发学习笔记三十八：内核概念之进程和线程管理
jyl_sh的专栏
06-28 745
前面在windows内核开发学习笔记三十五：系统线程和系统进程博文中介绍了系统进程和系统线程，涉及了一些线程和进程的概念，在本文更进一步的介绍进程和线程管理的相关知识。 进程（process）定义了一个执行环境，包括他自己的私有的地址空间、一个句柄表，以及一个安全环境；线程（thread）则是一个控制流，有自己的调用栈（call stack），记录了它的执行历史，每个进程都包含一个或多个线程，当进程被初始创建时系统为该进程创建第一个线程；当最后一个线程结束时，进程也随之结束...
PsSetLoadImageNotifyRoutine回调函数中使用NtProtectVirtualMemory卡死原因
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
09-12 3207
dll加载的回调应该是在MiMapViewOfSection->MiMapViewOfImageSection里吧，首先在前者调用后者前 会KeAcquireGuardedMutex (&((PROCESS)->AddressCreationLock));来进行同步NtProtectVirtualMemory->MiProtectVirtualMemory也会使用宏LOCK_ADDRESS_SPA
挂钩Windows API
luluxu的专栏
05-05 382
<br />创建时间：2004-03-06<br /> 文章属性：原创<br /> 文章提交：SoBeIt (kinsephi_at_hotmail.com)<br /><br /> ===========================[ 挂钩Windows API ]==================<br /><br />                                     SoBeIt<br /><br />                        Auth
ssh服务
yanglilinux的博客
07-26 346
SSH 为 Secure Shell 的缩写，由 IETF 的网络小组（Network Working Group）所制定；SSH 为建立在应用层基础上的安全协议。SSH 是较可靠，专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。SSH最初是UNIX系统上的一个程序，后来又迅速扩展到其他操作平台。SSH在正确使用时可弥补网络中的漏洞。SSH客户端适用于多种平台。几乎所有UNIX平台—包括HP-UX、Linux、AIX、Solaris、Digital
破解XXX游戏驱动保护过程总结
weixin_34418883的博客
07-23 1379
刚刚接触软件破解还有驱动编写，好多东西都不熟，折腾了好久，把中间可能对大家有价值的过程记录下来。    刚开始碰到的问题就是不能内核调试，因为要写驱动，需要用到。一般禁用内核调试都是在驱动里调用KdDisableDebugger，往上回溯一个函数，基本上就是驱动检测禁用是否成功的代码，否则就是一个循环不停的调用KdDisableDebugger函数。   我的做法是修改KdDisableDebug...
编写自己的驱动过游戏保护-需要具备的理论知识
热门推荐
crkres9527
09-16 1万+
A、了解SSDT结构         B、由SSDT索引号获取当前函数地址                C、如何获取索引号         D、获取起源地址-判断SSDT是否被HOOK         E、如何向内核地址写入自己代码    A、了解SSDT结构 SSDT的全称是System Services Descriptor Table，系统服务描述符表 在ntoskrnl....
过驱动保护第一套视频(63课)
M-先生
03-28 4477
63.白名单与校验的对抗.7z 62.过DebugProt.7z 61.过梦幻西游NECHECK保护.7z 60.过龙之谷GPK游戏保护.7z 59.真正过TP让CE可以附扫描.7z 58.DNF驱动保护思路代码.7z 55.IDT中断描述符表.7z 54.驱动InLine_HOOK实例.7z 53.绕过所有用户层HOOK.7z 52.真正勾住Shadow_SSDT.7z 51
电脑解压GPK安装教程：现代战争3、实况足球与都市赛车数据包位置详解
手动安装GPK文件需要一定的技术操作，但了解GPK文件的结构和游戏数据包的正确放置位置，可以帮助玩家绕过第三方应用，自行管理手机游戏。对于开发者而言，掌握这类知识也有助于优化发布流程，提升用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值