Java内存马前置知识

最新推荐文章于 2024-05-16 15:30:42 发布
最新推荐文章于 2024-05-16 15:30:42 发布
阅读量100 收藏 1
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/why811/article/details/133306894
版权

javaweb基础知识

javaweb(Container)三大件

Servlet

Servlet 技术是 Web 开发的原点，Tomcat 和 Jetty 这样的 Web 容器，负责加载和运行 Servlet

什么是Servlet

Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。它负责处理用户的请求，并根据请求生成相应的返回信息提供给用户。Tomcat是实现Servlet的首选web服务器。

请求处理的过程

客户端发起一个http请求，比如get或者post类型。
Servlet容器接收到请求，根据请求信息，封装成HttpServletRequest和HttpServletResponse对象。
Servlet容器调用HttpServlet的init()方法，init方法只在第一次请求的时候被调用。
Servlet容器调用service()方法。
service()方法根据请求类型，这里是get类型，分别调用doGet或者doPost方法，这里调用doGet方法。(这个地方一般需要重写方法) 在doXXX方法中是我们自己写的业务逻辑 业务逻辑处理完成之后，返回给Servlet容器，然后容器将结果返回给客户端。
容器关闭时候，会调用destory方法
生命周期
  1. 服务器启动时(web.xml中配置load-on-startup=1，默认为0)或者第一次请求该servlet时，就会初始化一个Servlet对象，也就是会执行初始化方法init(ServletConfig conf)。
  2. servlet对象去处理所有客户端请求，在service(ServletRequest req，ServletResponse res)方法中执行
  3. 服务器关闭时，销毁这个servlet对象，执行destroy()方法。
  4. 由JVM进行垃圾回收。

Filter

什么是filter

filter也称之为过滤器，是对Servlet技术的一个强补充，其主要功能是在HttpServletRequest到达 Servlet 之前，拦截客户的HttpServletRequest ，根据需要检查HttpServletRequest，也可以修改HttpServletRequest 头和数据；在HttpServletResponse到达客户端之前，拦截HttpServletResponse，根据需要检查HttpServletResponse，也可以修改HttpServletResponse头和数据。

请求处理过程
1、Filter 程序是一个实现了特殊接口的 Java 类，与 Servlet 类似，也是由 Servlet 容器进行调用和执行的。
2、当在 web.xml 注册了一个 Filter 来对某个 Servlet 程序进行拦截处理时，它可以决定是否将请求继续传递给 Servlet 程序，以及对请求和响应消息是否进行修改。
3、当 Servlet 容器开始调用某个 Servlet 程序时，如果发现已经注册了一个 Filter 程序来对该 Servlet 进行拦截，那么容器不再直接调用 Servlet 的 service 方法，而是调用 Filter 的 doFilter 方法，再由 doFilter 方法决定是否去激活 service 方法。
4、但在 Filter.doFilter 方法中不能直接调用 Servlet 的 service 方法，而是调用 FilterChain.doFilter 方法来激活目标 Servlet 的 service 方法，FilterChain 对象时通过 Filter.doFilter 方法的参数传递进来的。
5、只要在 Filter.doFilter 方法中调用 FilterChain.doFilter 方法的语句前后增加某些程序代码，这样就可以在 Servlet 进行响应前后实现某些特殊功能。
6、如果在 Filter.doFilter 方法中没有调用 FilterChain.doFilter 方法，则目标 Servlet 的 service 方法不会被执行，这样通过 Filter 就可以阻止某些非法的访问请求。

生命周期

与servlet一样，Filter的创建和销毁也由web容器负责。 web 应用程序启动时，web 服务器将创建Filter 的实例对象，并调用其init方法，读取web.xml配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（filter对象只会创建一次，init方法也只会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。

Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才销毁。在Web容器卸载 Filter 对象之前被调用。该方法在Filter的生命周期中仅执行一次。在这个方法中，可以释放过滤器使用的资源。

注意:有时候，filter不止一个，这样就会形成filter链。(根据实际的代码场景逻辑进行判断，从而进行绕过)

Listener

什么是Listener

JavaWeb开发中的监听器（Listener）就是Application、Session和Request三大对象创建、销毁或者往其中添加、修改、删除属性时自动执行代码的功能组件。

注意：javaweb中有九大内置对象 :request，response，pageContext，session，application，out，page，config，exception，需要导入相应的包才可以使用
  • ServletContextListener：对Servlet上下文的创建和销毁进行监听；
  • ServletContextAttributeListener：监听Servlet上下文属性的添加、删除和替换；
  • HttpSessionListener：对Session的创建和销毁进行监听。Session的销毁有两种情况，一个中
  • Session超时，还有一种是通过调用Session对象的invalidate()方法使session失效。
  • HttpSessionAttributeListener：对Session对象中属性的添加、删除和替换进行监听；
  • ServletRequestListener：对请求对象的初始化和销毁进行监听；
  • ServletRequestAttributeListener：对请求对象属性的添加、删除和替换进行监听。

Tomcat

简介

tomcat是http服务器+servlet容器。

Tomcat 作为Servlet容器,将http请求文本接收并解析，然后封装成HttpServletRequest类型的request对象，传递给servlet；同时会将响应的信息封装为HttpServletResponse类型的response对象，然后将response交给tomcat，tomcat就会将其变成响应文本的格式发送给浏览器

架构设计

一个 WEB 服务器 + 一个 Servlet 容器

需要处理网络的连接与 Servlet 的管理，因此，Tomcat 设计了两个核心组件来实现这两个功能，分别是连接器和容器，连接器用来处理外部网络连接，容器用来处理内部 Servlet

Tomcat 设计了 4 种容器，分别是 Engine、 Host、 Context和 Wrapper。要注意的是这 4 种容器不是平行关系，属于父子关系，

一个 Tomcat 代表一个 Server 服务器，一个 Server 服务器可以包含多个 Service 服务，Tomcat 默认的 Service 服务是 Catalina，而一个 Service 服务可以包含多个连接器，因为 Tomcat 支持多种网络协议，包括 HTTP/1.1、HTTP/2、AJP 等等，一个 Service 服务还会包括一个容器，容器外部会有一层 Engine 引擎所包裹，负责与处理连接器的请求与响应，连接器与容器之间通过 ServletRequest 和 ServletResponse 对象进行交流。

假如有用户访问一个 URL，比如图中的http://user.shopping.com:8080/order/buy，Tomcat 如何将这个 URL 定位到一个 Servlet 呢？

  1. 首先根据协议和端口号确定 Service 和 Engine。Tomcat 默认的 HTTP 连接器监听 8080 端口、默认的 AJP 连接器监听 8009 端口。上面例子中的 URL 访问的是 8080 端口，因此这个请求会被 HTTP 连接器接收，而一个连接器是属于一个 Service 组件的，这样 Service 组件就确定了。我们还知道一个 Service 组件里除了有多个连接器，还有一个容器组件，具体来说就是一个 Engine 容器，因此 Service 确定了也就意味着 Engine 也确定了。
  2. 根据域名选定 Host。 Service 和 Engine 确定后，Mapper 组件通过 URL 中的域名去查找相应的 Host 容器，比如例子中的 URL 访问的域名是user.shopping.com，因此 Mapper 会找到 Host2 这个容器。
  3. 根据 URL 路径找到 Context 组件。 Host 确定以后，Mapper 根据 URL 的路径来匹配相应的 Web 应用的路径，比如例子中访问的是 /order，因此找到了 Context4 这个 Context 容器。
  4. 根据 URL 路径找到 Wrapper（Servlet）。 Context 确定后，Mapper 再根据 web.xml 中配置的 Servlet 映射路径来找到具体的 Wrapper 和 Servlet。

java反射

java的四个基本特征是：封装，继承，多态和反射

在研究java安全的时候，大多数需要用到反射这个特性，因为，大部分情况下是不允许以正常的方式去实例化对象的。

java反射：在运行状态中，对于任意一个类，都能够知道这个类的属性和方法。
对于任意一个对象，都能够调用他的属性和方法

所以我们需要用反射的方式去实例化对象进行操作。

反射的本质相当于，直接从内存中去加载jvm编译过的,已经有的class对象，然后反向调用。

双亲委派机制，可以参考jvm的分析

当一个类加载器收到了类加载的请求的时候，它不会直接去加载这个类，而是把这个请求委托给父加载器加载。只有当父加载器无法加载这个类的时候，他才会尝试去加载这个类
  • BootstrapClassLoader是启动类加载器，由 C 语言实现，用来加载 JVM启动时所需要的核心类，比如rt.jar、resources.jar等。
  • ExtClassLoader是扩展类加载器，用来加载\jre\lib\ext目录下 JAR 包。
  • AppClassLoader是系统类加载器，用来加载 classpath下的类，应用程序默认用它来加载类。
  • 自定义类加载器，用来加载自定义路径下的类。

但是Tomcat却打破了双亲委派机制

Tomcat打破双亲委派的做法，我们称之为热加载

Tomcat 本质是通过一个后台线程做周期性的任务，定期检测类文件的变化，如果有变化就重新加载类。

Tomcat 的自定义类加载器 WebAppClassLoader打破了双亲委托机制，它首先自己尝试去加载某个类，如果找不到再代理给父类加载器，其目的是优先加载 Web 应用自己定义的类。具体实现就是重写 ClassLoader的两个方法：findClass和 loadClass。

public Class<?> findClass(String name) throws ClassNotFoundException {
    ...

    Class<?> clazz = null;
    try {
            //1. 先在 Web 应用目录下查找类
            clazz = findClassInternal(name);
    }  catch (RuntimeException e) {
           throw e;
       }

    if (clazz == null) {
    try {
            //2. 如果在本地目录没有找到，交给父加载器去查找
            clazz = super.findClass(name);
    }  catch (RuntimeException e) {
           throw e;
       }

    //3. 如果父类也没找到，抛出 ClassNotFoundException
    if (clazz == null) {
        throw new ClassNotFoundException(name);
     }

    return clazz;
}

更多细节，请看这个师傅的文章：java - Tomcat 架构原理解析到架构设计借鉴 - 个人文章 - SegmentFault 思否

我们返回来继续说java反射

反射功能可以在运行时(动态)：

  1. 获取一个类的所有成员变量和方法
  2. 创建一个类的对象：
  • a.获取对象成员变量&赋值
  • b.调用对象的方法
  • c.判断对象所属的类

常见的java反射获取对象的方式有这么几种：

  • 类名.class，如:com.anbai.sec.classloader.TestHelloWorld.class。
  • Class.forName("com.anbai.sec.classloader.TestHelloWorld")。
  • classLoader.loadClass("com.anbai.sec.classloader.TestHelloWorld");

例如，注入一个servlet型的内存马，我们需要使用反射机制来获取当前的context，然后将恶意的servlet（wrapper）添加到当前的context的children中。主要过程如下：

①获取 目标类型的Class对象

②通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

③通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息，并进行后续操作

java instrumentation

在java中，只有被JVM加载后的类才能被调用，或者在需要时通过反射通知JVM加载.

Instrumentation是Java提供的一个来自JVM的接口，该接口提供了一系列查看和操作Java类定义的方法

例如修改类的字节码、向classLoader的classpath下加入jar文件等。使得开发者可以通过Java语言来操作和监控JVM内部的一些状态，进而实现Java程序的监控分析，甚至实现一些特殊功能（如AOP、热部署）。

第一次有人请求Instrumentation的实例时，它会创建一个代理JAR文件，然后查找其自身进程的PID，并将其附加到JVM中

Java agent是一种特殊的Java程序（Jar文件），它是Instrumentation的客户端。与普通Java程序通过main方法启动不同，agent并不是一个可以单独启动的程序，而必须依附在一个Java应用程序（JVM）上，与它运行在同一个进程中，通过Instrumentation API与虚拟机交互。

在注入内存马的过程中，我们可以利用java instrumentation机制，动态的修改已加载到内存中的类里的方法，进而注入恶意的代码。

简单demo

在Example下新建两个类

Bird.java:
public class Bird {
    public void say()
    {
        System.out.println("bird is gone.");
    }
}

然后把编译后的Bird.class复制出来，放到一个文件夹下。然后把Bird.java再改成如下:

Bird.java:
public class Bird {
    public void say()
    {
        System.out.println("bird say hello");
    }
}
Main.java：
public class Main {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        while(true)
        {
            Bird bird=new Bird();
            bird.say();
            Thread.sleep(3000);
        }    
    }
}

把整个工程打包成可执行jar包Example.jar,放到之前那个文件夹。

在工程Agent中新建2个类：

AgentEntry.java:
public class AgentEntry { 
   public static void agentmain(String agentArgs, Instrumentation inst) 
           throws ClassNotFoundException, UnmodifiableClassException, 
           InterruptedException { 
       inst.addTransformer(new Transformer (), true); 
        Class[] loadedClasses = inst.getAllLoadedClasses();
        for (Class c : loadedClasses) {
            if (c.getName().equals("Bird")) {
                try {
                    inst.retransformClasses(c);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
       System.out.println("Class changed!"); 
   } 
}
Transformer.java:
public class Transformer implements ClassFileTransformer { 
   static byte[] mergeByteArray(byte[]... byteArray) {
       int totalLength = 0;
       for(int i = 0; i < byteArray.length; i ++) {
           if(byteArray[i] == null) {
               continue;
           }
           totalLength += byteArray[i].length;
       }
       byte[] result = new byte[totalLength];
       int cur = 0;
       for(int i = 0; i < byteArray.length; i++) {
           if(byteArray[i] == null) {
               continue;
           }
           System.arraycopy(byteArray[i], 0, result, cur, byteArray[i].length);
           cur += byteArray[i].length;
       }
       return result;
   }
   public static byte[] getBytesFromFile(String fileName) { 
       try { 
           byte[] result=new byte[] {};
           InputStream is = new FileInputStream(new File(fileName)); 
           byte[] bytes = new byte[1024];
           int num = 0;
           while ((num = is.read(bytes)) != -1) {
               result=mergeByteArray(result,Arrays.copyOfRange(bytes, 0, num));       
           }
           is.close();
           return result; 
       } catch (Exception e) { 
           e.printStackTrace();
           return null;
       } 
   } 
   public byte[] transform(ClassLoader classLoader, String className, Class<?> c, 
           ProtectionDomain pd, byte[] b) throws IllegalClassFormatException { 
       if (!className.equals("Bird")) { 
           return null; 
       } 
       return getBytesFromFile("d:/Bird.class"); 
   } 
}

这个也要打包成jar包，但是直接打包肯定是打包不了的

首先在SRC下创建META-INF文件夹然后再常见文件MANIFEST.MF，内容如下

MAINFEST.MF:
Manifest-Version: 1.0 
Agent-Class: AgentEntry
Can-Retransform-Classes: true

然后把Agent工程打包为Agent.jar.

然后新建run工程中，在其中新建1个类：

Attach.java：
public class Attach {
    public static void main(String[] args) throws Exception {
        VirtualMachine vm = null;
        List<VirtualMachineDescriptor> listAfter = null;
        List<VirtualMachineDescriptor> listBefore = null;
        listBefore = VirtualMachine.list();
        while (true) {
            try {
                listAfter = VirtualMachine.list();
                if (listAfter.size() <= 0)
                    continue;
                for (VirtualMachineDescriptor vmd : listAfter) {
                    vm = VirtualMachine.attach(vmd);
                    listBefore.add(vmd);
                    System.out.println("i find a vm,agent.jar was injected.");
                    Thread.sleep(1000);
                    if (null != vm) {
                        vm.loadAgent("agent.jar");
                        vm.detach();
                    }
                }
                break;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//import com.sun.tools.attach.VirtualMachineDescriptor;
//import com.sun.tools.attach.VirtualMachine;
//这里import的是这两个包，导入其他包会出错，同时还要把 java/lib下的tools.jar放到lib 移到项目中来，否则会报错

报错解决方法参考：“程序包com.sun.tools.javac.util不存在” 问题解决_java: 程序包sun.font不存在-CSDN博客

之后，打包成可执行jar包run.jar，放到该文件夹下。

先后执行

java -jar Example.jar
java -jar run.jar

就会有这样的情况

我们就实现了在动态运行中改变方法体。

动态注册之Servlet+Filter+Listener

  • xml文件注册
  • 注解注册(Servlet 3.0 +）
  • ServletContext动态注册
why811
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA架构师_前置知识.zip
09-09
JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip JAVA架构师_前置知识.zip
java内存马学习与理解
Shanfenglan's blog
11-08 5562
文章目录1. 前置知识1.1 java web 核心组件listenerfilterfilter的生命周期filter链servlet2. tomcat2.1 核心组件1. connector组件2. container组件 1. 前置知识 1.1 java web 核心组件 首先我们得知道，java网站都一定会有一个web容器。 listener 本质是一个java类。 作用是监听Application、Session和Request三大对象创建或者删除，然后根据监听的结果来执行提前编写的代码。 可以简单
Java内存马攻防实战——攻击基础篇
JavaMonsterr的博客
05-23 3084
在红蓝对抗中，攻击方广泛应用webshell等技术在防守方提供的服务中植入后门，防守方也发展出各种技术来应对攻击，传统的落地型webshell很容易被攻击方检测和绞杀。而内存马技术则是通过在运行的服务中直接插入运行攻击者的webshell逻辑，利用中间件的进程执行某些恶意代码，而不依赖实体文件的存在实现的服务后门，因此具有更好的隐蔽性，也更容易躲避传统安全监测设备的检测。 本文以Java语言为基础讨论内存马技术的攻防，分为两个篇章，分别是攻击基础篇和防护应用篇。本篇攻击基础篇介绍了Java Servlet
Java内存马学习-Filter
cjdgg的博客
05-03 902
Java内存马学习-FliterTomcat架构学习 Tomcat架构学习 Server： Server，即指的WEB服务器,一个Server包括多个Service。 Service： Service的作用是在Connector和Engine外面包了一层（可看上图），把它们组装在一起，对外提供服务。一个Service可以包含多个Connector，但是只能包含一个Engine，其中Connector的作用是从客户端接收请求，Engine的作用是处理接收进来的请求。后面再来细节分析Service。 Conne
基于Java Agent内存马
遇事不决冲冲冲
06-06 1912
在 jdk 1.5 之后引入了 `java.lang.instrument` 包，该包提供了检测 java 程序的 Api，比如用于监控、收集性能信息、诊断问题，通过 `java.lang.instrument` 实现的工具我们称之为 Java Agent，Java Agent 支持两种方式进行加载： 实现 premain 方法，在启动时进行加载 （该特性在 jdk 1.5 之后才有） 实现 agentmain 方法，在启动后进行加载 （该特性在 jdk 1.6 之后才有） ...
Java前置一些知识
bossDDYY的博客
04-08 225
傻瓜式的点下一步就行，注意：安装目录不要有空格、中文。不同的操作系统有对应的相应的JVM虚拟机。导入模块（有一点点复杂）oralce官网下载。javac 编译工具。
一、Java前置知识
qq_37923376的博客
12-27 469
Java语言的特性 Java 是一门简单的，面向对象，分布式，解释性，健壮的，安全的，结构中立的， 便 捷的，高性能的，多线程的，动态的语言 1. 简单性 在Java语言当中真正操作内存的是：JVM（Java虚拟机） 所有的java程序都是运行在Java虚拟机当中的。 而Java虚拟机执行过程中再去操作内存。 对于C或者C++来说程序员都是可以直接通过指针操作内存的。 C或者C++更灵活，可以直接程序员操作内存，但是要求程序员技术精湛。 C语言或者C++更有驾驭感。 Java语言屏蔽了指针概念，程序员不能直
java数据结构前置知识以及认识泛型
N_0050的博客
02-13 1102
Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes。如何理解这张图？
内存马涉及基础知识整理
vlogFeynman的博客
05-17 1587
Tomcat 简介 http服务器+servlet容器 部署和运行 mansger 密码文件配置 第一次如果不改都登录不进去 springboot打包 jar war的区别 Tomcat架构设计 Tomcat架构原理 几乎所有Web框架都是基于Servlet的封装，Sping应用本身就是一个Servlet,Tomcat是容器负责加载和运行Servlet 整体架构设计 一个Tomcat只有一个Server,一个Server至少一个Service 两个核心组件 A Connector----- B Co
《Java并发编程的艺术》——Java并发的前置知识（笔记）
weixin_46949627的博客
09-23 755
《Java并发编程的艺术》笔记 并发编程的挑战 并发的机制的底层实现原理 Java内存模型JMM
Netty学习前置知识（一）
u013351117的博客
11-14 2183
文章目录前言Netty 介绍Netty 使用场景互联网行业游戏行业大数据领域Java IO模型IO模型BIO,NIO,AIO场景分析比较Java BIO 编程Java BIO介绍Java BIO工作机制BIO工作机制梳理Java BIO编程实例问题分析Java NIO 编程Java NIO介绍NIO 与 BIO比较NIO三大核心原理图NIO 的 Selector、Channel 和、Buffer 之间关系三大核心关系解读缓冲区Buffer基本介绍Buffer及其子类基本属性： capacity, limit
3、前置知识pdf资料
10-15
3、前置知识
Netty实现前置系统
07-12
描述：短连接系统A-->前置系统B，长链接前置B-->系统C交互，并支持断线重连，A与C交互
java XMl JDK 前置
12-11
可用于银行的假期去年 数字签名第三方理解的是法律；手段将 收复失地fjlsdjflasdfjsdf 山东分舵是 阿呆书法大赛
数据结构 第一章 前置知识 链表
12-16
以简单的代码演示链表的增删改查和遍历
jar包增量更新分析
junlaiyan的专栏
05-16 244
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 607
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 888
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 893
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
学习springboot前置知识
08-18
学习Spring Boot之前，你可以先了解以下几个前置知识： 1. Java基础知识：Spring Boot是基于Java语言开发的，因此你需要对Java的基本语法、面向对象编程等有一定的了解。 2. Spring框架：Spring Boot是在Spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值